From 338eafd7c75379d55b370ab0c7f932aec485b4ab Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sat, 2 Aug 2025 11:54:30 -0700 Subject: [PATCH 01/67] wip Signed-off-by: James Hamlin --- pkg/codegen/README.md | 46 +++++++ pkg/codegen/codegen.go | 159 ++++++++++++++++++++++ pkg/codegen/codegen_test.go | 132 ++++++++++++++++++ pkg/codegen/testdata/01_const_number.glj | 1 + pkg/codegen/testdata/01_const_number.go | 12 ++ pkg/codegen/testdata/02_const_string.glj | 1 + pkg/codegen/testdata/02_const_string.go | 12 ++ pkg/codegen/testdata/03_const_keyword.glj | 1 + pkg/codegen/testdata/03_const_keyword.go | 12 ++ pkg/codegen/testdata/04_ns.glj | 2 + pkg/codegen/testdata/04_ns.go | 12 ++ pkg/codegen/testdata/05_def_simple.glj | 1 + pkg/codegen/testdata/05_def_simple.go | 12 ++ pkg/codegen/testdata/06_loop_simple.glj | 3 + 14 files changed, 406 insertions(+) create mode 100644 pkg/codegen/README.md create mode 100644 pkg/codegen/codegen.go create mode 100644 pkg/codegen/codegen_test.go create mode 100644 pkg/codegen/testdata/01_const_number.glj create mode 100644 pkg/codegen/testdata/01_const_number.go create mode 100644 pkg/codegen/testdata/02_const_string.glj create mode 100644 pkg/codegen/testdata/02_const_string.go create mode 100644 pkg/codegen/testdata/03_const_keyword.glj create mode 100644 pkg/codegen/testdata/03_const_keyword.go create mode 100644 pkg/codegen/testdata/04_ns.glj create mode 100644 pkg/codegen/testdata/04_ns.go create mode 100644 pkg/codegen/testdata/05_def_simple.glj create mode 100644 pkg/codegen/testdata/05_def_simple.go create mode 100644 pkg/codegen/testdata/06_loop_simple.glj diff --git a/pkg/codegen/README.md b/pkg/codegen/README.md new file mode 100644 index 00000000..7b6559a7 --- /dev/null +++ b/pkg/codegen/README.md @@ -0,0 +1,46 @@ +# Glojure Code Generator + +This package implements ahead-of-time (AOT) compilation of Glojure code to Go. + +## Structure + +- `codegen.go` - Core code generation logic +- `codegen_test.go` - Test harness that verifies generated code +- `testdata/` - Test cases with input `.glj` files and expected `.go` output + +## Running Tests + +```bash +# Run tests and verify generated code matches golden files +go test ./pkg/codegen + +# Update golden files when code generation changes +go test ./pkg/codegen -update +``` + +## How It Works + +1. **Input**: Glojure source code (`.glj` files) +2. **Parse**: Use Glojure reader to parse into s-expressions +3. **Analyze**: Use Glojure analyzer to produce AST nodes +4. **Generate**: Convert AST nodes to Go code +5. **Verify**: Compare with golden files and test behavior + +## Current Status + +- [x] Basic test harness infrastructure +- [x] OpConst support for numbers, strings, keywords +- [ ] OpConst support for other types (symbols, collections) +- [ ] Variable references (OpVar, OpLocal) +- [ ] Collection literals (OpVector, OpMap, OpSet) +- [ ] Control flow (OpIf, OpDo) +- [ ] Function invocation and definition +- [ ] Behavioral testing (compile and run generated code) + +## Next Steps + +1. Add support for more constant types +2. Implement behavioral testing that compiles and runs generated code +3. Add variable reference support +4. Expand to collection literals +5. Build up to more complex AST nodes \ No newline at end of file diff --git a/pkg/codegen/codegen.go b/pkg/codegen/codegen.go new file mode 100644 index 00000000..0df3da7f --- /dev/null +++ b/pkg/codegen/codegen.go @@ -0,0 +1,159 @@ +package codegen + +import ( + "bytes" + "fmt" + "go/format" + "io" + "strings" + + "github.com/glojurelang/glojure/pkg/ast" + "github.com/glojurelang/glojure/pkg/lang" +) + +// Generator handles the conversion of AST nodes to Go code +type Generator struct { + originalWriter io.Writer + w io.Writer + indent int +} + +// New creates a new code generator +func New(w io.Writer) *Generator { + return &Generator{originalWriter: w, w: w} +} + +// Generate takes analyzed AST nodes and generates Go code +func (g *Generator) Generate(nodes []*ast.Node) error { + // Generate to a buffer first so we can format + var buf bytes.Buffer + g.w = &buf + + // Write package header + if err := g.writeHeader(); err != nil { + return err + } + + // Generate code for each top-level form + for i, node := range nodes { + if err := g.generateTopLevel(node, i); err != nil { + return fmt.Errorf("error generating form %d: %w", i, err) + } + + // Add newline between functions, but not after the last one + if i < len(nodes)-1 { + if _, err := io.WriteString(g.w, "\n"); err != nil { + return err + } + } + } + + // Format the generated code + formatted, err := format.Source(buf.Bytes()) + if err != nil { + // If formatting fails, write the unformatted code with the error + return fmt.Errorf("formatting failed: %w\n\nGenerated code:\n%s", err, buf.String()) + } + + // Write formatted code to the original writer + _, err = g.originalWriter.Write(formatted) + return err +} + +func (g *Generator) writeHeader() error { + header := `// Code generated by glojure codegen. DO NOT EDIT. + +package generated + +import ( + "github.com/glojurelang/glojure/pkg/lang" +) + +` + _, err := io.WriteString(g.w, header) + return err +} + +func (g *Generator) generateTopLevel(node *ast.Node, index int) error { + // Generate a function for each top-level form + funcName := fmt.Sprintf("Form_%d", index) + + if err := g.writef("// %s\n", formatForm(node.Form)); err != nil { + return err + } + + if err := g.writef("func %s() interface{} {\n", funcName); err != nil { + return err + } + + g.indent++ + + // Generate the actual code + if err := g.generateNode(node); err != nil { + return err + } + + g.indent-- + + if err := g.writef("}\n"); err != nil { + return err + } + + return nil +} + +func (g *Generator) generateNode(node *ast.Node) error { + switch node.Op { + case ast.OpConst: + return g.generateConst(node) + default: + // For now, generate a placeholder for unsupported nodes + return g.writef("return nil // TODO: OpCode %d\n", node.Op) + } +} + +func (g *Generator) generateConst(node *ast.Node) error { + constNode := node.Sub.(*ast.ConstNode) + val := constNode.Value + + switch v := val.(type) { + case int64: + return g.writef("return int64(%d)\n", v) + case float64: + return g.writef("return float64(%f)\n", v) + case string: + return g.writef("return %q\n", v) + case bool: + return g.writef("return %t\n", v) + case nil: + return g.writef("return nil\n") + case *lang.Keyword: + return g.writef("return lang.NewKeyword(%q)\n", v.Name()) + case lang.Keyword: + // Handle non-pointer keyword type + return g.writef("return lang.NewKeyword(%q)\n", v.Name()) + default: + // Placeholder for other constant types + return g.writef("return nil // TODO: const type %T\n", v) + } +} + +//////////////////////////////////////////////////////////////////////////////// + +func (g *Generator) writef(format string, args ...interface{}) error { + // Handle indentation + if g.indent > 0 && len(format) > 0 && format[0] != '\n' { + if _, err := io.WriteString(g.w, strings.Repeat("\t", g.indent)); err != nil { + return err + } + } + + _, err := fmt.Fprintf(g.w, format, args...) + return err +} + +// formatForm returns a string representation of a form for comments +func formatForm(form interface{}) string { + // Simple string representation for now + return fmt.Sprintf("%v", form) +} diff --git a/pkg/codegen/codegen_test.go b/pkg/codegen/codegen_test.go new file mode 100644 index 00000000..c9c0e53f --- /dev/null +++ b/pkg/codegen/codegen_test.go @@ -0,0 +1,132 @@ +package codegen + +import ( + "bytes" + "flag" + "fmt" + "io/ioutil" + "path/filepath" + "strings" + "testing" + + "github.com/glojurelang/glojure/pkg/ast" + "github.com/glojurelang/glojure/pkg/compiler" + "github.com/glojurelang/glojure/pkg/lang" + "github.com/glojurelang/glojure/pkg/reader" +) + +var updateGolden = flag.Bool("update", false, "update golden files") + +func TestCodegen(t *testing.T) { + testFiles, err := filepath.Glob("testdata/*.glj") + if err != nil { + t.Fatal(err) + } + + for _, testFile := range testFiles { + testName := strings.TrimSuffix(filepath.Base(testFile), ".glj") + t.Run(testName, func(t *testing.T) { + // Read input file + input, err := ioutil.ReadFile(testFile) + if err != nil { + t.Fatal(err) + } + + // Parse and analyze + nodes, err := parseAndAnalyze(string(input)) + if err != nil { + t.Fatalf("failed to parse/analyze: %v", err) + } + + // Generate code + var buf bytes.Buffer + gen := New(&buf) + if err := gen.Generate(nodes); err != nil { + t.Fatalf("failed to generate code: %v", err) + } + + generated := buf.Bytes() + + // Compare with golden file + goldenFile := strings.TrimSuffix(testFile, ".glj") + ".go" + if *updateGolden { + if err := ioutil.WriteFile(goldenFile, generated, 0644); err != nil { + t.Fatal(err) + } + } + + expected, err := ioutil.ReadFile(goldenFile) + if err != nil { + t.Fatalf("failed to read golden file: %v", err) + } + + if !bytes.Equal(generated, expected) { + t.Errorf("generated code does not match golden file.\nGenerated:\n%s\nExpected:\n%s", + generated, expected) + } + + // TODO: Compile and run the generated code to verify behavior + // This will be added once we have more complete code generation + }) + } +} + +func parseAndAnalyze(input string) ([]*ast.Node, error) { + // Create reader without needing full environment + r := reader.New(strings.NewReader(input), reader.WithFilename("test.glj"), + reader.WithGetCurrentNS(func() *lang.Namespace { + // Return a minimal namespace for testing + return lang.FindOrCreateNamespace(lang.NewSymbol("user")) + })) + + // Create analyzer with minimal setup + analyzer := &compiler.Analyzer{ + Macroexpand1: func(form interface{}) (interface{}, error) { + // For now, no macro expansion in tests + return form, nil + }, + CreateVar: func(sym *lang.Symbol, env compiler.Env) (interface{}, error) { + // Create a var in the current namespace + ns := lang.FindOrCreateNamespace(lang.NewSymbol("user")) + return ns.Intern(sym), nil + }, + IsVar: func(v interface{}) bool { + _, ok := v.(*lang.Var) + return ok + }, + Gensym: func(prefix string) *lang.Symbol { + // Simple gensym for testing + return lang.NewSymbol(fmt.Sprintf("%s_%d", prefix, 1)) + }, + FindNamespace: func(sym *lang.Symbol) *lang.Namespace { + return lang.FindNamespace(sym) + }, + } + + // Parse and analyze all forms + var nodes []*ast.Node + for { + form, err := r.ReadOne() + if err == reader.ErrEOF { + break + } + if err != nil { + return nil, err + } + + node, err := analyzer.Analyze(form, lang.NewMap()) + if err != nil { + return nil, err + } + + nodes = append(nodes, node) + } + + return nodes, nil +} + +// TestBehavior verifies that generated code produces the same results as interpreted code +func TestBehavior(t *testing.T) { + // This test will be implemented once we can compile and run generated code + t.Skip("Behavioral testing not yet implemented") +} diff --git a/pkg/codegen/testdata/01_const_number.glj b/pkg/codegen/testdata/01_const_number.glj new file mode 100644 index 00000000..f70d7bba --- /dev/null +++ b/pkg/codegen/testdata/01_const_number.glj @@ -0,0 +1 @@ +42 \ No newline at end of file diff --git a/pkg/codegen/testdata/01_const_number.go b/pkg/codegen/testdata/01_const_number.go new file mode 100644 index 00000000..bcaac110 --- /dev/null +++ b/pkg/codegen/testdata/01_const_number.go @@ -0,0 +1,12 @@ +// Code generated by glojure codegen. DO NOT EDIT. + +package generated + +import ( + "github.com/glojurelang/glojure/pkg/lang" +) + +// 42 +func Form_0() interface{} { + return int64(42) +} diff --git a/pkg/codegen/testdata/02_const_string.glj b/pkg/codegen/testdata/02_const_string.glj new file mode 100644 index 00000000..84ed78b6 --- /dev/null +++ b/pkg/codegen/testdata/02_const_string.glj @@ -0,0 +1 @@ +"hello" \ No newline at end of file diff --git a/pkg/codegen/testdata/02_const_string.go b/pkg/codegen/testdata/02_const_string.go new file mode 100644 index 00000000..0a3cffbd --- /dev/null +++ b/pkg/codegen/testdata/02_const_string.go @@ -0,0 +1,12 @@ +// Code generated by glojure codegen. DO NOT EDIT. + +package generated + +import ( + "github.com/glojurelang/glojure/pkg/lang" +) + +// hello +func Form_0() interface{} { + return "hello" +} diff --git a/pkg/codegen/testdata/03_const_keyword.glj b/pkg/codegen/testdata/03_const_keyword.glj new file mode 100644 index 00000000..2a2d08c2 --- /dev/null +++ b/pkg/codegen/testdata/03_const_keyword.glj @@ -0,0 +1 @@ +:foo \ No newline at end of file diff --git a/pkg/codegen/testdata/03_const_keyword.go b/pkg/codegen/testdata/03_const_keyword.go new file mode 100644 index 00000000..337f96ae --- /dev/null +++ b/pkg/codegen/testdata/03_const_keyword.go @@ -0,0 +1,12 @@ +// Code generated by glojure codegen. DO NOT EDIT. + +package generated + +import ( + "github.com/glojurelang/glojure/pkg/lang" +) + +// :foo +func Form_0() interface{} { + return lang.NewKeyword("foo") +} diff --git a/pkg/codegen/testdata/04_ns.glj b/pkg/codegen/testdata/04_ns.glj new file mode 100644 index 00000000..d3488944 --- /dev/null +++ b/pkg/codegen/testdata/04_ns.glj @@ -0,0 +1,2 @@ +;; (ns codegen.test) +:skip diff --git a/pkg/codegen/testdata/04_ns.go b/pkg/codegen/testdata/04_ns.go new file mode 100644 index 00000000..ab05570e --- /dev/null +++ b/pkg/codegen/testdata/04_ns.go @@ -0,0 +1,12 @@ +// Code generated by glojure codegen. DO NOT EDIT. + +package generated + +import ( + "github.com/glojurelang/glojure/pkg/lang" +) + +// :skip +func Form_0() interface{} { + return lang.NewKeyword("skip") +} diff --git a/pkg/codegen/testdata/05_def_simple.glj b/pkg/codegen/testdata/05_def_simple.glj new file mode 100644 index 00000000..68148ffd --- /dev/null +++ b/pkg/codegen/testdata/05_def_simple.glj @@ -0,0 +1 @@ +(def foo) diff --git a/pkg/codegen/testdata/05_def_simple.go b/pkg/codegen/testdata/05_def_simple.go new file mode 100644 index 00000000..73c5e4fa --- /dev/null +++ b/pkg/codegen/testdata/05_def_simple.go @@ -0,0 +1,12 @@ +// Code generated by glojure codegen. DO NOT EDIT. + +package generated + +import ( + "github.com/glojurelang/glojure/pkg/lang" +) + +// (def foo) +func Form_0() interface{} { + return nil // TODO: OpCode 2 +} diff --git a/pkg/codegen/testdata/06_loop_simple.glj b/pkg/codegen/testdata/06_loop_simple.glj new file mode 100644 index 00000000..15847d7d --- /dev/null +++ b/pkg/codegen/testdata/06_loop_simple.glj @@ -0,0 +1,3 @@ +(loop [i 0] + (if (< i 10) + (recur (inc i)))) From c79c64abbe993be6880b07c3947f7d8fa7f21a71 Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Mon, 4 Aug 2025 20:47:26 -0700 Subject: [PATCH 02/67] wip aot Signed-off-by: James Hamlin --- pkg/codegen/allocator_test.go | 66 ++ pkg/codegen/codegen.go | 574 +++++++++++++++--- pkg/codegen/codegen_test.go | 130 ++-- pkg/codegen/example_usage.go | 105 ++++ pkg/codegen/testdata/01_const_number.glj | 1 - pkg/codegen/testdata/01_const_number.go | 12 - pkg/codegen/testdata/02_const_string.glj | 1 - pkg/codegen/testdata/02_const_string.go | 12 - pkg/codegen/testdata/03_const_keyword.glj | 1 - pkg/codegen/testdata/04_ns.glj | 2 - pkg/codegen/testdata/04_ns.go | 12 - pkg/codegen/testdata/05_def_simple.glj | 1 - pkg/codegen/testdata/05_def_simple.go | 12 - pkg/codegen/testdata/06_loop_simple.glj | 3 - .../testdata/codegen/test/const_keyword.glj | 3 + .../testdata/codegen/test/const_keyword.go | 17 + .../testdata/codegen/test/const_number.glj | 5 + .../testdata/codegen/test/const_number.go | 17 + .../testdata/codegen/test/const_string.glj | 3 + .../testdata/codegen/test/const_string.go | 17 + .../testdata/codegen/test/def_simple.glj | 3 + .../testdata/codegen/test/def_simple.go | 17 + .../testdata/codegen/test/loop_simple.glj | 6 + .../testdata/codegen/test/loop_simple.go | 28 + pkg/codegen/testdata/codegen/test/ns_skip.glj | 3 + .../test/ns_skip.go} | 6 +- pkg/runtime/fn.go | 4 + 27 files changed, 864 insertions(+), 197 deletions(-) create mode 100644 pkg/codegen/allocator_test.go create mode 100644 pkg/codegen/example_usage.go delete mode 100644 pkg/codegen/testdata/01_const_number.glj delete mode 100644 pkg/codegen/testdata/01_const_number.go delete mode 100644 pkg/codegen/testdata/02_const_string.glj delete mode 100644 pkg/codegen/testdata/02_const_string.go delete mode 100644 pkg/codegen/testdata/03_const_keyword.glj delete mode 100644 pkg/codegen/testdata/04_ns.glj delete mode 100644 pkg/codegen/testdata/04_ns.go delete mode 100644 pkg/codegen/testdata/05_def_simple.glj delete mode 100644 pkg/codegen/testdata/05_def_simple.go delete mode 100644 pkg/codegen/testdata/06_loop_simple.glj create mode 100644 pkg/codegen/testdata/codegen/test/const_keyword.glj create mode 100644 pkg/codegen/testdata/codegen/test/const_keyword.go create mode 100644 pkg/codegen/testdata/codegen/test/const_number.glj create mode 100644 pkg/codegen/testdata/codegen/test/const_number.go create mode 100644 pkg/codegen/testdata/codegen/test/const_string.glj create mode 100644 pkg/codegen/testdata/codegen/test/const_string.go create mode 100644 pkg/codegen/testdata/codegen/test/def_simple.glj create mode 100644 pkg/codegen/testdata/codegen/test/def_simple.go create mode 100644 pkg/codegen/testdata/codegen/test/loop_simple.glj create mode 100644 pkg/codegen/testdata/codegen/test/loop_simple.go create mode 100644 pkg/codegen/testdata/codegen/test/ns_skip.glj rename pkg/codegen/testdata/{03_const_keyword.go => codegen/test/ns_skip.go} (57%) diff --git a/pkg/codegen/allocator_test.go b/pkg/codegen/allocator_test.go new file mode 100644 index 00000000..4de3e0cd --- /dev/null +++ b/pkg/codegen/allocator_test.go @@ -0,0 +1,66 @@ +package codegen + +import ( + "bytes" + "testing" +) + +func TestVarAllocator(t *testing.T) { + var buf bytes.Buffer + gen := New(&buf) + + // Test initial allocation + if name := gen.allocateVar("x"); name != "v0" { + t.Errorf("expected first var to be v0, got %s", name) + } + if name := gen.allocateVar("y"); name != "v1" { + t.Errorf("expected second var to be v1, got %s", name) + } + + // Test that same name in same scope returns same variable name + if name := gen.allocateVar("x"); name != "v0" { + t.Errorf("expected x to still be v0, got %s", name) + } + + // Test pushing a new scope + gen.pushVarScope() + + // New scope should start from where the previous scope left off + if name := gen.allocateVar("z"); name != "v2" { + t.Errorf("expected first var in new scope to be v2, got %s", name) + } + + // Same name in new scope should get new variable name + if name := gen.allocateVar("x"); name != "v3" { + t.Errorf("expected x in new scope to be v3, got %s", name) + } + + // Test popping scope + gen.popVarScope() + + // Back in original scope, allocating new var should continue from where we left off + if name := gen.allocateVar("w"); name != "v2" { + t.Errorf("expected w to be v2 after popping scope, got %s", name) + } + + // Original x should still be v0 + if name := gen.allocateVar("x"); name != "v0" { + t.Errorf("expected x to be v0 after popping scope, got %s", name) + } +} + +// TestVarName is no longer needed since allocateVar returns the name directly + +func TestPopRootScopePanics(t *testing.T) { + var buf bytes.Buffer + gen := New(&buf) + + // Should panic when trying to pop the root scope + defer func() { + if r := recover(); r == nil { + t.Errorf("expected panic when popping root scope") + } + }() + + gen.popVarScope() +} \ No newline at end of file diff --git a/pkg/codegen/codegen.go b/pkg/codegen/codegen.go index 0df3da7f..d4bf86a4 100644 --- a/pkg/codegen/codegen.go +++ b/pkg/codegen/codegen.go @@ -9,45 +9,106 @@ import ( "github.com/glojurelang/glojure/pkg/ast" "github.com/glojurelang/glojure/pkg/lang" + "github.com/glojurelang/glojure/pkg/runtime" ) +// varScope represents a variable allocation scope +type varScope struct { + nextNum int + names map[string]string // maps Clojure names to Go variable names +} + // Generator handles the conversion of AST nodes to Go code type Generator struct { originalWriter io.Writer w io.Writer - indent int + varScopes []varScope // stack of variable scopes } // New creates a new code generator func New(w io.Writer) *Generator { - return &Generator{originalWriter: w, w: w} + return &Generator{ + originalWriter: w, + w: w, + varScopes: []varScope{{nextNum: 0, names: make(map[string]string)}}, + } } -// Generate takes analyzed AST nodes and generates Go code -func (g *Generator) Generate(nodes []*ast.Node) error { - // Generate to a buffer first so we can format +// Generate takes a namespace and generates Go code that populates the same namespace +func (g *Generator) Generate(ns *lang.Namespace) error { + // TODO: Implement namespace-based code generation + // For now, just stub it out var buf bytes.Buffer g.w = &buf + // Check if we need fmt import (for functions with arity checks) + needsFmt := false + mappings := ns.Mappings() + + // Only check vars that are interned in this namespace + for seq := mappings.Seq(); seq != nil; seq = seq.Next() { + entry := seq.First() + name, ok := lang.First(entry).(*lang.Symbol) + if !ok { + continue + } + second, _ := lang.Nth(entry, 1) + vr, ok := second.(*lang.Var) + if !ok { + continue + } + + // Skip non-interned mappings + if !(vr.Namespace() == ns && lang.Equals(vr.Symbol(), name)) { + continue + } + + if vr.IsBound() { + if _, ok := vr.Get().(*runtime.Fn); ok { + needsFmt = true + break + } + } + } + // Write package header - if err := g.writeHeader(); err != nil { + if err := g.writeHeader(needsFmt); err != nil { return err } - // Generate code for each top-level form - for i, node := range nodes { - if err := g.generateTopLevel(node, i); err != nil { - return fmt.Errorf("error generating form %d: %w", i, err) + g.writef("func init() {\n") + + g.writef(" ns := lang.FindOrCreateNamespace(lang.NewSymbol(\"%s\"))\n", ns.Name().String()) + g.writef(" _ = ns\n") + + // TODO: Generate code to populate the namespace + // This will involve: + // 1. Iterating through ns.Mappings() + // 2. Generating Go code for each var + // 3. Creating initialization functions + for seq := mappings.Seq(); seq != nil; seq = seq.Next() { + entry := seq.First() + name, ok := lang.First(entry).(*lang.Symbol) + if !ok { + panic(fmt.Sprintf("expected symbol, got %T", entry)) + } + second, _ := lang.Nth(entry, 1) + vr, ok := second.(*lang.Var) + if !ok { + panic(fmt.Sprintf("expected var, got %T", second)) } - // Add newline between functions, but not after the last one - if i < len(nodes)-1 { - if _, err := io.WriteString(g.w, "\n"); err != nil { - return err - } + if !(vr.Namespace() == ns && lang.Equals(vr.Symbol(), name)) { + continue // Skip non-interned mappings + } + + if err := g.generateVar("ns", name, vr); err != nil { + return fmt.Errorf("failed to generate code for var %s: %w", name, err) } } + g.writef("}\n") + // Format the generated code formatted, err := format.Source(buf.Bytes()) if err != nil { @@ -60,100 +121,463 @@ func (g *Generator) Generate(nodes []*ast.Node) error { return err } -func (g *Generator) writeHeader() error { - header := `// Code generated by glojure codegen. DO NOT EDIT. +//////////////////////////////////////////////////////////////////////////////// -package generated +// generateVar generates Go code for a single Var +func (g *Generator) generateVar(nsVariableName string, name *lang.Symbol, vr *lang.Var) error { + g.pushVarScope() + defer g.popVarScope() -import ( - "github.com/glojurelang/glojure/pkg/lang" -) + g.writef("// %s\n", name.String()) + g.writef("{\n") + defer g.writef("}\n") -` - _, err := io.WriteString(g.w, header) - return err + meta := name.Meta() + varSym := g.allocateVar("varSym") + if meta == nil { + g.writef("%s := lang.NewSymbol(\"%s\")\n", varSym, name.String()) + } else { + metaVariable := g.generateValue(meta) + g.writef("%s := lang.NewSymbol(\"%s\").WithMeta(%s).(*lang.Symbol)\n", varSym, name.String(), metaVariable) + } + + // check if the var has a value + if vr.IsBound() { + g.writef("%s.InternWithValue(%s, %s, true)\n", nsVariableName, varSym, g.generateValue(vr.Get())) + } else { + g.writef("%s.Intern(%s)\n", nsVariableName, varSym) + } + + return nil } -func (g *Generator) generateTopLevel(node *ast.Node, index int) error { - // Generate a function for each top-level form - funcName := fmt.Sprintf("Form_%d", index) +// returns the variable name or constant expression for the value +func (g *Generator) generateValue(value any) string { + switch v := value.(type) { + case *runtime.Fn: + return g.generateFn(v) + case *lang.Map: + return g.generateMap(v) + case *lang.Vector: + return g.generateVector(v) + case lang.Keyword: + if ns := v.Namespace(); ns != "" { + return fmt.Sprintf("lang.NewKeyword(\"%s/%s\")", ns, v.Name()) + } else { + return fmt.Sprintf("lang.NewKeyword(\"%s\")", v.Name()) + } + case string: + // just return the string as a Go string literal + return fmt.Sprintf("%#v", v) + case int: + return fmt.Sprintf("int(%d)", v) + case int64: + return fmt.Sprintf("int64(%d)", v) + case bool: + // return the boolean as a Go boolean literal + if v { + return "true" + } + return "false" + case nil: + return "nil" + default: + if lang.IsSeq(v) { + var vals []string + for seq := lang.Seq(v); seq != nil; seq = seq.Next() { + first := seq.First() + vals = append(vals, g.generateValue(first)) + } + return fmt.Sprintf("lang.NewList(%s)", strings.Join(vals, ", ")) + } + panic(fmt.Sprintf("unsupported value type %T: %s", v, v)) + } +} - if err := g.writef("// %s\n", formatForm(node.Form)); err != nil { - return err +// generateMap generates Go code for a Clojure map +func (g *Generator) generateMap(m *lang.Map) string { + var buf bytes.Buffer + buf.WriteString("lang.NewMap(") + + // Iterate through the map entries + for seq := m.Seq(); seq != nil; seq = seq.Next() { + entry := seq.First() + key := lang.First(entry) + value, _ := lang.Nth(entry, 1) + keyVar := g.generateValue(key) + valueVar := g.generateValue(value) + buf.WriteString(keyVar + ", " + valueVar + ", ") } - if err := g.writef("func %s() interface{} {\n", funcName); err != nil { - return err + // Remove trailing comma and space + if buf.Len() > 0 { + buf.Truncate(buf.Len() - 2) } - g.indent++ + buf.WriteString(")") + return buf.String() +} - // Generate the actual code - if err := g.generateNode(node); err != nil { - return err +// generateVector generates Go code for a Clojure vector +func (g *Generator) generateVector(v *lang.Vector) string { + var buf bytes.Buffer + buf.WriteString("lang.NewVector(") + + // Iterate through the vector elements + for i := 0; i < v.Count(); i++ { + if i > 0 { + buf.WriteString(", ") + } + element := v.Nth(i) + elementVar := g.generateValue(element) + buf.WriteString(elementVar) } - g.indent-- + buf.WriteString(")") + return buf.String() +} - if err := g.writef("}\n"); err != nil { - return err +func (g *Generator) generateFn(fn *runtime.Fn) string { + astNode := fn.ASTNode() + fnNode := astNode.Sub.(*ast.FnNode) + + // Allocate a variable for the function + fnVar := g.allocateVar("fn") + + // Start building the function + var buf bytes.Buffer + + // Generate an immediately invoked function expression (IIFE) to define and return the function + buf.WriteString("func() interface{} {\n") + + // Push a new scope for the function definition + g.pushVarScope() + defer g.popVarScope() + + // If there's only one method and it's not variadic, generate a simple function + if len(fnNode.Methods) == 1 && !fnNode.IsVariadic { + method := fnNode.Methods[0] + methodNode := method.Sub.(*ast.FnMethodNode) + + buf.WriteString(fmt.Sprintf(" %s := lang.IFnFunc(func(args ...interface{}) interface{} {\n", fnVar)) + + // Check arity + buf.WriteString(fmt.Sprintf(" if len(args) != %d {\n", methodNode.FixedArity)) + buf.WriteString(fmt.Sprintf(" panic(lang.NewIllegalArgumentError(\"wrong number of arguments (\" + fmt.Sprint(len(args)) + \")\"))\n")) + buf.WriteString(" }\n") + + // Generate method body + g.generateFnMethod(&buf, methodNode, "args", 0) + + buf.WriteString(" })\n") + } else { + // Multiple arities or variadic - need to dispatch + buf.WriteString(fmt.Sprintf(" %s := lang.IFnFunc(func(args ...interface{}) interface{} {\n", fnVar)) + buf.WriteString(" switch len(args) {\n") + + // Generate cases for fixed arity methods + var variadicMethod *ast.Node + for _, method := range fnNode.Methods { + methodNode := method.Sub.(*ast.FnMethodNode) + if methodNode.IsVariadic { + variadicMethod = method + continue + } + + buf.WriteString(fmt.Sprintf(" case %d:\n", methodNode.FixedArity)) + g.generateFnMethod(&buf, methodNode, "args", 2) + } + + // Generate default case for variadic method + if variadicMethod != nil { + variadicMethodNode := variadicMethod.Sub.(*ast.FnMethodNode) + buf.WriteString(" default:\n") + buf.WriteString(fmt.Sprintf(" if len(args) < %d {\n", variadicMethodNode.FixedArity)) + buf.WriteString(fmt.Sprintf(" panic(lang.NewIllegalArgumentError(\"wrong number of arguments (\" + fmt.Sprint(len(args)) + \")\"))\n")) + buf.WriteString(" }\n") + g.generateFnMethod(&buf, variadicMethodNode, "args", 2) + } else { + // No variadic method - error on any other arity + buf.WriteString(" default:\n") + buf.WriteString(fmt.Sprintf(" panic(lang.NewIllegalArgumentError(\"wrong number of arguments (\" + fmt.Sprint(len(args)) + \")\"))\n")) + } + + buf.WriteString(" }\n") + buf.WriteString(" })\n") } - return nil + // Handle metadata if present + if meta := fn.Meta(); meta != nil { + metaVar := g.generateValue(meta) + // IFnFunc doesn't support metadata directly, so wrap it + buf.WriteString(fmt.Sprintf(" // Note: metadata on functions is not yet supported in generated code\n")) + buf.WriteString(fmt.Sprintf(" // Original metadata: %s\n", metaVar)) + buf.WriteString(fmt.Sprintf(" return %s\n", fnVar)) + } else { + buf.WriteString(fmt.Sprintf(" return %s\n", fnVar)) + } + + buf.WriteString("}()") + + return buf.String() } -func (g *Generator) generateNode(node *ast.Node) error { +// generateFnMethod generates the body of a function method +func (g *Generator) generateFnMethod(buf *bytes.Buffer, methodNode *ast.FnMethodNode, argsVar string, indentLevel int) { + indent := strings.Repeat(" ", indentLevel) + + // Push a new scope for the method body + g.pushVarScope() + defer g.popVarScope() + + // TODO: Handle recur with a label when we implement recur + // if methodNode.LoopID != nil { + // buf.WriteString(fmt.Sprintf("%s Recur_%s:\n", indent, mungeID(methodNode.LoopID.Name()))) + // } + + // Bind parameters + for i, param := range methodNode.Params { + paramNode := param.Sub.(*ast.BindingNode) + paramVar := g.allocateVar(paramNode.Name.Name()) + + if i < methodNode.FixedArity { + // Regular parameter + buf.WriteString(fmt.Sprintf("%s %s := %s[%d]\n", indent, paramVar, argsVar, i)) + } else { + // Variadic parameter - collect rest args + buf.WriteString(fmt.Sprintf("%s %s := lang.NewList(%s[%d:]...)\n", indent, paramVar, argsVar, methodNode.FixedArity)) + } + } + + // Generate the body + bodyVar := g.generateASTNode(methodNode.Body) + buf.WriteString(fmt.Sprintf("%s return %s\n", indent, bodyVar)) +} + +// generateASTNode generates code for an AST node +func (g *Generator) generateASTNode(node *ast.Node) string { + fmt.Printf("Generating code for AST node: %T %+v\n", node.Sub, node.Sub) switch node.Op { case ast.OpConst: - return g.generateConst(node) + constNode := node.Sub.(*ast.ConstNode) + return g.generateValue(constNode.Value) + case ast.OpLocal: + localNode := node.Sub.(*ast.LocalNode) + // Look up the variable in our scope + return g.allocateVar(localNode.Name.Name()) + case ast.OpDo: + return g.generateDo(node) + case ast.OpLoop: + return g.generateLet(node, true) + case ast.OpIf: + return g.generateIf(node) + case ast.OpInvoke: + return g.generateInvoke(node) default: - // For now, generate a placeholder for unsupported nodes - return g.writef("return nil // TODO: OpCode %d\n", node.Op) + panic(fmt.Sprintf("unsupported AST node type %T", node.Sub)) } } -func (g *Generator) generateConst(node *ast.Node) error { - constNode := node.Sub.(*ast.ConstNode) - val := constNode.Value +// generateDo generates code for a Do node +func (g *Generator) generateDo(node *ast.Node) string { + var buf bytes.Buffer + doNode := node.Sub.(*ast.DoNode) + for _, subNode := range doNode.Statements { + if subNode == nil { + continue + } + subCode := g.generateASTNode(subNode) + buf.WriteString(subCode + "\n") + } + return g.generateASTNode(doNode.Ret) +} - switch v := val.(type) { - case int64: - return g.writef("return int64(%d)\n", v) - case float64: - return g.writef("return float64(%f)\n", v) - case string: - return g.writef("return %q\n", v) - case bool: - return g.writef("return %t\n", v) - case nil: - return g.writef("return nil\n") - case *lang.Keyword: - return g.writef("return lang.NewKeyword(%q)\n", v.Name()) - case lang.Keyword: - // Handle non-pointer keyword type - return g.writef("return lang.NewKeyword(%q)\n", v.Name()) - default: - // Placeholder for other constant types - return g.writef("return nil // TODO: const type %T\n", v) +// generateIf generates code for an If node +func (g *Generator) generateIf(node *ast.Node) string { + ifNode := node.Sub.(*ast.IfNode) + + test := ifNode.Test + then := ifNode.Then + els := ifNode.Else + + // testVal, err := env.EvalAST(test) + // if err != nil { + // return nil, err + // } + // if lang.IsTruthy(testVal) { + // return env.EvalAST(then) + // } else { + // return env.EvalAST(els) + // } + + var buf bytes.Buffer + buf.WriteString("if lang.IsTruthy(") + buf.WriteString(g.generateASTNode(test) + ") {\n") + buf.WriteString(" return " + g.generateASTNode(then) + "\n") + if els != nil { + buf.WriteString("} else {\n") + buf.WriteString(" return " + g.generateASTNode(els) + "\n") + } + buf.WriteString("}\n") + return buf.String() +} + +// func (env *environment) EvalASTLet(n *ast.Node, isLoop bool) (interface{}, error) { +// letNode := n.Sub.(*ast.LetNode) + +// newEnv := env.PushScope().(*environment) + +// var bindNameVals []interface{} + +// bindings := letNode.Bindings +// for _, binding := range bindings { +// bindingNode := binding.Sub.(*ast.BindingNode) + +// name := bindingNode.Name +// init := bindingNode.Init +// initVal, err := newEnv.EvalAST(init) +// if err != nil { +// return nil, err +// } +// // TODO: this should not mutate in-place! +// newEnv.BindLocal(name, initVal) + +// bindNameVals = append(bindNameVals, name, initVal) +// } + +// Recur: +// for i := 0; i < len(bindNameVals); i += 2 { +// name := bindNameVals[i].(*lang.Symbol) +// val := bindNameVals[i+1] +// newEnv.BindLocal(name, val) +// } + +// rt := lang.NewRecurTarget() +// recurEnv := newEnv.WithRecurTarget(rt).(*environment) +// recurErr := &lang.RecurError{Target: rt} + +// res, err := recurEnv.EvalAST(letNode.Body) +// if isLoop && errors.As(err, &recurErr) { +// newVals := recurErr.Args +// if len(newVals) != len(bindNameVals)/2 { +// return nil, env.errorf(n, "invalid recur, expected %d arguments, got %d", len(bindNameVals)/2, len(newVals)) +// } +// for i := 0; i < len(bindNameVals); i += 2 { +// newValsIndex := i / 2 +// val := newVals[newValsIndex] +// bindNameVals[i+1] = val +// } +// goto Recur +// } +// return res, err +// } + +// generateLet generates code for a Let node +func (g *Generator) generateLet(node *ast.Node, isLoop bool) string { + letNode := node.Sub.(*ast.LetNode) + + // Push a new variable scope for the let bindings + g.pushVarScope() + defer g.popVarScope() + + var buf bytes.Buffer + + // Bind variables + for _, binding := range letNode.Bindings { + bindingNode := binding.Sub.(*ast.BindingNode) + name := bindingNode.Name.Name() + init := bindingNode.Init + + // Allocate a Go variable for the Clojure name + varName := g.allocateVar(name) + + // Generate initialization code + initCode := g.generateASTNode(init) + buf.WriteString(fmt.Sprintf("%s := %s\n", varName, initCode)) } + + // Generate the body of the let + bodyCode := g.generateASTNode(letNode.Body) + buf.WriteString(fmt.Sprintf("return %s\n", bodyCode)) + + return buf.String() } //////////////////////////////////////////////////////////////////////////////// -func (g *Generator) writef(format string, args ...interface{}) error { - // Handle indentation - if g.indent > 0 && len(format) > 0 && format[0] != '\n' { - if _, err := io.WriteString(g.w, strings.Repeat("\t", g.indent)); err != nil { - return err - } +func (g *Generator) writeHeader(needsFmt bool) error { + header := `// Code generated by glojure codegen. DO NOT EDIT. + +package generated + +import ( +` + if needsFmt { + header += ` "fmt" +` } + header += ` "github.com/glojurelang/glojure/pkg/lang" +) + +` + _, err := io.WriteString(g.w, header) + return err +} +func (g *Generator) writef(format string, args ...interface{}) error { _, err := fmt.Fprintf(g.w, format, args...) return err } -// formatForm returns a string representation of a form for comments -func formatForm(form interface{}) string { - // Simple string representation for now - return fmt.Sprintf("%v", form) +//////////////////////////////////////////////////////////////////////////////// +// Variable Scope Management + +// PushVarScope creates a new variable scope +func (g *Generator) pushVarScope() { + // Get the current scope's next number as the start for the new scope + nextNum := 0 + if len(g.varScopes) > 0 { + currentScope := &g.varScopes[len(g.varScopes)-1] + nextNum = currentScope.nextNum + } + + // Push new scope onto the stack + g.varScopes = append(g.varScopes, varScope{ + nextNum: nextNum, + names: make(map[string]string), + }) +} + +// PopVarScope removes the current variable scope +func (g *Generator) popVarScope() { + if len(g.varScopes) <= 1 { + panic("cannot pop the root variable scope") + } + g.varScopes = g.varScopes[:len(g.varScopes)-1] +} + +// AllocateVar allocates a Go variable name for the given Clojure name in the current scope +// If the name already exists in the current scope, it returns the existing Go variable name +func (g *Generator) allocateVar(name string) string { + if len(g.varScopes) == 0 { + panic("no variable scope available") + } + + currentScope := &g.varScopes[len(g.varScopes)-1] + + // Check if already allocated in current scope + if varName, exists := currentScope.names[name]; exists { + return varName + } + + // Allocate new variable name + varName := fmt.Sprintf("v%d", currentScope.nextNum) + currentScope.names[name] = varName + currentScope.nextNum++ + + return varName +} + +func mungeID(name string) string { + return strings.ReplaceAll(name, "-", "__") } diff --git a/pkg/codegen/codegen_test.go b/pkg/codegen/codegen_test.go index c9c0e53f..ca48c606 100644 --- a/pkg/codegen/codegen_test.go +++ b/pkg/codegen/codegen_test.go @@ -5,43 +5,63 @@ import ( "flag" "fmt" "io/ioutil" + "os" + "os/exec" "path/filepath" + "sort" "strings" "testing" - "github.com/glojurelang/glojure/pkg/ast" - "github.com/glojurelang/glojure/pkg/compiler" + "github.com/glojurelang/glojure/pkg/glj" "github.com/glojurelang/glojure/pkg/lang" "github.com/glojurelang/glojure/pkg/reader" + "github.com/glojurelang/glojure/pkg/runtime" ) var updateGolden = flag.Bool("update", false, "update golden files") func TestCodegen(t *testing.T) { - testFiles, err := filepath.Glob("testdata/*.glj") + var testFiles []string + err := filepath.Walk("testdata", func(path string, info os.FileInfo, err error) error { + if err != nil { + return err + } + if strings.HasSuffix(path, ".glj") { + testFiles = append(testFiles, path) + } + return nil + }) if err != nil { t.Fatal(err) } - for _, testFile := range testFiles { - testName := strings.TrimSuffix(filepath.Base(testFile), ".glj") + // Sort test files for consistent ordering + sort.Strings(testFiles) + + for i, testFile := range testFiles { + baseName := strings.TrimSuffix(filepath.Base(testFile), ".glj") + testName := fmt.Sprintf("%02d_%s", i+1, baseName) t.Run(testName, func(t *testing.T) { - // Read input file - input, err := ioutil.ReadFile(testFile) - if err != nil { - t.Fatal(err) + // Parse test file to get namespace name + nsName := getNamespaceFromFile(t, testFile) + if nsName == "" { + // If no namespace declaration, use the filename as namespace + nsName = strings.TrimSuffix(filepath.Base(testFile), ".glj") + nsName = strings.ReplaceAll(nsName, "_", "-") + nsName = strings.ReplaceAll(nsName, ".", "-") } - // Parse and analyze - nodes, err := parseAndAnalyze(string(input)) - if err != nil { - t.Fatalf("failed to parse/analyze: %v", err) - } + require := glj.Var("glojure.core", "require") + runtime.AddLoadPath(os.DirFS("testdata")) + // Load the namespace + require.Invoke(lang.NewSymbol(nsName)) + + ns := lang.FindNamespace(lang.NewSymbol(nsName)) - // Generate code + // Generate code for the namespace var buf bytes.Buffer gen := New(&buf) - if err := gen.Generate(nodes); err != nil { + if err := gen.Generate(ns); err != nil { t.Fatalf("failed to generate code: %v", err) } @@ -65,64 +85,50 @@ func TestCodegen(t *testing.T) { generated, expected) } + // run go vet on the output file. print any errors from stderr + cmd := exec.Command("go", "vet", "-all", goldenFile) + var stderr bytes.Buffer + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Errorf("go vet failed for %s: %v\nStderr:\n%s", goldenFile, err, stderr.String()) + } + // TODO: Compile and run the generated code to verify behavior // This will be added once we have more complete code generation }) } } -func parseAndAnalyze(input string) ([]*ast.Node, error) { - // Create reader without needing full environment - r := reader.New(strings.NewReader(input), reader.WithFilename("test.glj"), - reader.WithGetCurrentNS(func() *lang.Namespace { - // Return a minimal namespace for testing - return lang.FindOrCreateNamespace(lang.NewSymbol("user")) - })) - - // Create analyzer with minimal setup - analyzer := &compiler.Analyzer{ - Macroexpand1: func(form interface{}) (interface{}, error) { - // For now, no macro expansion in tests - return form, nil - }, - CreateVar: func(sym *lang.Symbol, env compiler.Env) (interface{}, error) { - // Create a var in the current namespace - ns := lang.FindOrCreateNamespace(lang.NewSymbol("user")) - return ns.Intern(sym), nil - }, - IsVar: func(v interface{}) bool { - _, ok := v.(*lang.Var) - return ok - }, - Gensym: func(prefix string) *lang.Symbol { - // Simple gensym for testing - return lang.NewSymbol(fmt.Sprintf("%s_%d", prefix, 1)) - }, - FindNamespace: func(sym *lang.Symbol) *lang.Namespace { - return lang.FindNamespace(sym) - }, +// getNamespaceFromFile attempts to extract the namespace declaration from a file +func getNamespaceFromFile(t *testing.T, filename string) string { + input, err := ioutil.ReadFile(filename) + if err != nil { + return "" } - // Parse and analyze all forms - var nodes []*ast.Node - for { - form, err := r.ReadOne() - if err == reader.ErrEOF { - break - } - if err != nil { - return nil, err - } + r := reader.New(strings.NewReader(string(input)), + reader.WithFilename(filename), + ) - node, err := analyzer.Analyze(form, lang.NewMap()) - if err != nil { - return nil, err - } + // Look for first form, check if it's an ns declaration + form, err := r.ReadOne() + if err != nil { + return "" + } - nodes = append(nodes, node) + // Check if it's a list starting with 'ns + if list, ok := form.(lang.ISeq); ok { + first := lang.First(list) + if sym, ok := first.(*lang.Symbol); ok && sym.Name() == "ns" { + // Get the namespace name (second element) + second := lang.First(lang.Next(list)) + if nsSym, ok := second.(*lang.Symbol); ok { + return nsSym.Name() + } + } } - return nodes, nil + panic("expected namespace declaration in " + filename) } // TestBehavior verifies that generated code produces the same results as interpreted code diff --git a/pkg/codegen/example_usage.go b/pkg/codegen/example_usage.go new file mode 100644 index 00000000..511a970b --- /dev/null +++ b/pkg/codegen/example_usage.go @@ -0,0 +1,105 @@ +package codegen + +// Example showing the intended use of allocateVar +// This file demonstrates how the variable allocator would be used +// when generating Go code from Clojure expressions. + +func exampleUsage(g *Generator) { + // Example 1: Simple let binding + // Clojure: (let [x 10 y 20] (+ x y)) + // Would generate something like: + + g.writef("// (let [x 10 y 20] (+ x y))\n") + g.writef("func() interface{} {\n") + g.pushVarScope() // New scope for let bindings + + // Allocate variables for the let bindings + xVar := g.allocateVar("x") // Returns "v0" + yVar := g.allocateVar("y") // Returns "v1" + + // Generate the bindings + g.writef(" %s := int64(10)\n", xVar) // v0 := int64(10) + g.writef(" %s := int64(20)\n", yVar) // v1 := int64(20) + + // Generate the body - when we see 'x' or 'y', we look them up + xRef := g.allocateVar("x") // Returns "v0" (same as before) + yRef := g.allocateVar("y") // Returns "v1" (same as before) + + g.writef(" return %s + %s\n", xRef, yRef) // return v0 + v1 + g.writef("}()\n") + g.popVarScope() + + // Example 2: Nested let bindings with shadowing + // Clojure: (let [x 10] (let [x 20 y x] (+ x y))) + + g.writef("\n// (let [x 10] (let [x 20 y x] (+ x y)))\n") + g.writef("func() interface{} {\n") + g.pushVarScope() // Outer let + + outerX := g.allocateVar("x") // Returns "v2" (continuing from previous example) + g.writef(" %s := int64(10)\n", outerX) // v2 := int64(10) + + // Inner let + g.writef(" return func() interface{} {\n") + g.pushVarScope() // Inner let scope + + innerX := g.allocateVar("x") // Returns "v3" (new x, shadows outer x) + innerY := g.allocateVar("y") // Returns "v4" + + g.writef(" %s := int64(20)\n", innerX) // v3 := int64(20) + g.writef(" %s := %s\n", innerY, innerX) // v4 := v3 + + // In the body, 'x' refers to inner x + xRef2 := g.allocateVar("x") // Returns "v3" (finds inner x) + yRef2 := g.allocateVar("y") // Returns "v4" + + g.writef(" return %s + %s\n", xRef2, yRef2) // return v3 + v4 + g.writef(" }()\n") + + g.popVarScope() // Pop inner scope + g.writef("}()\n") + g.popVarScope() // Pop outer scope + + // Example 3: Function parameters + // Clojure: (fn [a b] (+ a b)) + + g.writef("\n// (fn [a b] (+ a b))\n") + g.writef("func() interface{} {\n") + g.writef(" return lang.NewFn(func(args ...interface{}) interface{} {\n") + g.pushVarScope() // Function body scope + + // Allocate variables for parameters + aVar := g.allocateVar("a") // Returns "v5" + bVar := g.allocateVar("b") // Returns "v6" + + // Extract parameters from args + g.writef(" %s := args[0]\n", aVar) // v5 := args[0] + g.writef(" %s := args[1]\n", bVar) // v6 := args[1] + + // Generate body + aRef2 := g.allocateVar("a") // Returns "v5" (same) + bRef2 := g.allocateVar("b") // Returns "v6" (same) + + g.writef(" return %s + %s\n", aRef2, bRef2) // return v5 + v6 + g.writef(" })\n") + g.writef("}()\n") + g.popVarScope() +} + +// The point of the name parameter in allocateVar: +// +// 1. **Consistency**: When the same Clojure variable is referenced multiple times +// in the same scope, it should map to the same Go variable. The name ensures +// we can look up existing allocations. +// +// 2. **Shadowing**: Different scopes can have variables with the same name +// (like nested lets with the same binding name). The scope stack ensures +// these get different variable numbers. +// +// 3. **Debugging**: Although we generate names like v0, v1, etc., keeping track +// of the original Clojure name helps with debugging and potentially generating +// comments. +// +// Without the name parameter, we'd have to maintain a separate mapping from +// Clojure symbols to variable numbers outside the generator, which would be +// more complex and error-prone. \ No newline at end of file diff --git a/pkg/codegen/testdata/01_const_number.glj b/pkg/codegen/testdata/01_const_number.glj deleted file mode 100644 index f70d7bba..00000000 --- a/pkg/codegen/testdata/01_const_number.glj +++ /dev/null @@ -1 +0,0 @@ -42 \ No newline at end of file diff --git a/pkg/codegen/testdata/01_const_number.go b/pkg/codegen/testdata/01_const_number.go deleted file mode 100644 index bcaac110..00000000 --- a/pkg/codegen/testdata/01_const_number.go +++ /dev/null @@ -1,12 +0,0 @@ -// Code generated by glojure codegen. DO NOT EDIT. - -package generated - -import ( - "github.com/glojurelang/glojure/pkg/lang" -) - -// 42 -func Form_0() interface{} { - return int64(42) -} diff --git a/pkg/codegen/testdata/02_const_string.glj b/pkg/codegen/testdata/02_const_string.glj deleted file mode 100644 index 84ed78b6..00000000 --- a/pkg/codegen/testdata/02_const_string.glj +++ /dev/null @@ -1 +0,0 @@ -"hello" \ No newline at end of file diff --git a/pkg/codegen/testdata/02_const_string.go b/pkg/codegen/testdata/02_const_string.go deleted file mode 100644 index 0a3cffbd..00000000 --- a/pkg/codegen/testdata/02_const_string.go +++ /dev/null @@ -1,12 +0,0 @@ -// Code generated by glojure codegen. DO NOT EDIT. - -package generated - -import ( - "github.com/glojurelang/glojure/pkg/lang" -) - -// hello -func Form_0() interface{} { - return "hello" -} diff --git a/pkg/codegen/testdata/03_const_keyword.glj b/pkg/codegen/testdata/03_const_keyword.glj deleted file mode 100644 index 2a2d08c2..00000000 --- a/pkg/codegen/testdata/03_const_keyword.glj +++ /dev/null @@ -1 +0,0 @@ -:foo \ No newline at end of file diff --git a/pkg/codegen/testdata/04_ns.glj b/pkg/codegen/testdata/04_ns.glj deleted file mode 100644 index d3488944..00000000 --- a/pkg/codegen/testdata/04_ns.glj +++ /dev/null @@ -1,2 +0,0 @@ -;; (ns codegen.test) -:skip diff --git a/pkg/codegen/testdata/04_ns.go b/pkg/codegen/testdata/04_ns.go deleted file mode 100644 index ab05570e..00000000 --- a/pkg/codegen/testdata/04_ns.go +++ /dev/null @@ -1,12 +0,0 @@ -// Code generated by glojure codegen. DO NOT EDIT. - -package generated - -import ( - "github.com/glojurelang/glojure/pkg/lang" -) - -// :skip -func Form_0() interface{} { - return lang.NewKeyword("skip") -} diff --git a/pkg/codegen/testdata/05_def_simple.glj b/pkg/codegen/testdata/05_def_simple.glj deleted file mode 100644 index 68148ffd..00000000 --- a/pkg/codegen/testdata/05_def_simple.glj +++ /dev/null @@ -1 +0,0 @@ -(def foo) diff --git a/pkg/codegen/testdata/05_def_simple.go b/pkg/codegen/testdata/05_def_simple.go deleted file mode 100644 index 73c5e4fa..00000000 --- a/pkg/codegen/testdata/05_def_simple.go +++ /dev/null @@ -1,12 +0,0 @@ -// Code generated by glojure codegen. DO NOT EDIT. - -package generated - -import ( - "github.com/glojurelang/glojure/pkg/lang" -) - -// (def foo) -func Form_0() interface{} { - return nil // TODO: OpCode 2 -} diff --git a/pkg/codegen/testdata/06_loop_simple.glj b/pkg/codegen/testdata/06_loop_simple.glj deleted file mode 100644 index 15847d7d..00000000 --- a/pkg/codegen/testdata/06_loop_simple.glj +++ /dev/null @@ -1,3 +0,0 @@ -(loop [i 0] - (if (< i 10) - (recur (inc i)))) diff --git a/pkg/codegen/testdata/codegen/test/const_keyword.glj b/pkg/codegen/testdata/codegen/test/const_keyword.glj new file mode 100644 index 00000000..433fc59f --- /dev/null +++ b/pkg/codegen/testdata/codegen/test/const_keyword.glj @@ -0,0 +1,3 @@ +(ns codegen.test.const-keyword) + +(def const-keyword :foo) diff --git a/pkg/codegen/testdata/codegen/test/const_keyword.go b/pkg/codegen/testdata/codegen/test/const_keyword.go new file mode 100644 index 00000000..fd9e3580 --- /dev/null +++ b/pkg/codegen/testdata/codegen/test/const_keyword.go @@ -0,0 +1,17 @@ +// Code generated by glojure codegen. DO NOT EDIT. + +package generated + +import ( + "github.com/glojurelang/glojure/pkg/lang" +) + +func init() { + ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.const-keyword")) + _ = ns + // const-keyword + { + v0 := lang.NewSymbol("const-keyword").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/const_keyword.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(18))).(*lang.Symbol) + ns.InternWithValue(v0, lang.NewKeyword("foo"), true) + } +} diff --git a/pkg/codegen/testdata/codegen/test/const_number.glj b/pkg/codegen/testdata/codegen/test/const_number.glj new file mode 100644 index 00000000..087a52eb --- /dev/null +++ b/pkg/codegen/testdata/codegen/test/const_number.glj @@ -0,0 +1,5 @@ +(ns codegen.test.const-number) + +(def const-number + "A constant number." + 42) diff --git a/pkg/codegen/testdata/codegen/test/const_number.go b/pkg/codegen/testdata/codegen/test/const_number.go new file mode 100644 index 00000000..c4b018b2 --- /dev/null +++ b/pkg/codegen/testdata/codegen/test/const_number.go @@ -0,0 +1,17 @@ +// Code generated by glojure codegen. DO NOT EDIT. + +package generated + +import ( + "github.com/glojurelang/glojure/pkg/lang" +) + +func init() { + ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.const-number")) + _ = ns + // const-number + { + v0 := lang.NewSymbol("const-number").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/const_number.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("doc"), "A constant number.")).(*lang.Symbol) + ns.InternWithValue(v0, int64(42), true) + } +} diff --git a/pkg/codegen/testdata/codegen/test/const_string.glj b/pkg/codegen/testdata/codegen/test/const_string.glj new file mode 100644 index 00000000..38e0bb99 --- /dev/null +++ b/pkg/codegen/testdata/codegen/test/const_string.glj @@ -0,0 +1,3 @@ +(ns codegen.test.const-string) + +(def ^:hello const-string "Hello, World!") diff --git a/pkg/codegen/testdata/codegen/test/const_string.go b/pkg/codegen/testdata/codegen/test/const_string.go new file mode 100644 index 00000000..ed242ea8 --- /dev/null +++ b/pkg/codegen/testdata/codegen/test/const_string.go @@ -0,0 +1,17 @@ +// Code generated by glojure codegen. DO NOT EDIT. + +package generated + +import ( + "github.com/glojurelang/glojure/pkg/lang" +) + +func init() { + ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.const-string")) + _ = ns + // const-string + { + v0 := lang.NewSymbol("const-string").WithMeta(lang.NewMap(lang.NewKeyword("hello"), true, lang.NewKeyword("file"), "codegen/test/const_string.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(25))).(*lang.Symbol) + ns.InternWithValue(v0, "Hello, World!", true) + } +} diff --git a/pkg/codegen/testdata/codegen/test/def_simple.glj b/pkg/codegen/testdata/codegen/test/def_simple.glj new file mode 100644 index 00000000..f7ff0f9c --- /dev/null +++ b/pkg/codegen/testdata/codegen/test/def_simple.glj @@ -0,0 +1,3 @@ +(ns codegen.test.def-simple) + +(def foo) diff --git a/pkg/codegen/testdata/codegen/test/def_simple.go b/pkg/codegen/testdata/codegen/test/def_simple.go new file mode 100644 index 00000000..f0aadc31 --- /dev/null +++ b/pkg/codegen/testdata/codegen/test/def_simple.go @@ -0,0 +1,17 @@ +// Code generated by glojure codegen. DO NOT EDIT. + +package generated + +import ( + "github.com/glojurelang/glojure/pkg/lang" +) + +func init() { + ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.def-simple")) + _ = ns + // foo + { + v0 := lang.NewSymbol("foo").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/def_simple.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(8))).(*lang.Symbol) + ns.Intern(v0) + } +} diff --git a/pkg/codegen/testdata/codegen/test/loop_simple.glj b/pkg/codegen/testdata/codegen/test/loop_simple.glj new file mode 100644 index 00000000..331bc333 --- /dev/null +++ b/pkg/codegen/testdata/codegen/test/loop_simple.glj @@ -0,0 +1,6 @@ +(ns codegen.test.loop-simple) + +(defn simple-loop [] + (loop [i 0] + (if (< i 10) + (recur (inc i))))) diff --git a/pkg/codegen/testdata/codegen/test/loop_simple.go b/pkg/codegen/testdata/codegen/test/loop_simple.go new file mode 100644 index 00000000..15b2a3df --- /dev/null +++ b/pkg/codegen/testdata/codegen/test/loop_simple.go @@ -0,0 +1,28 @@ +// Code generated by glojure codegen. DO NOT EDIT. + +package generated + +import ( + "fmt" + "github.com/glojurelang/glojure/pkg/lang" +) + +func init() { + ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.loop-simple")) + _ = ns + // simple-loop + { + v0 := lang.NewSymbol("simple-loop").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/loop_simple.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()))).(*lang.Symbol) + ns.InternWithValue(v0, func() interface{} { + v1 := lang.IFnFunc(func(args ...interface{}) interface{} { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + return nil + }) + // Note: metadata on functions is not yet supported in generated code + // Original metadata: lang.NewMap(lang.NewKeyword("rettag"), nil) + return v1 + }(), true) + } +} diff --git a/pkg/codegen/testdata/codegen/test/ns_skip.glj b/pkg/codegen/testdata/codegen/test/ns_skip.glj new file mode 100644 index 00000000..f5356b50 --- /dev/null +++ b/pkg/codegen/testdata/codegen/test/ns_skip.glj @@ -0,0 +1,3 @@ +(ns codegen.test.ns-skip) + +:skip diff --git a/pkg/codegen/testdata/03_const_keyword.go b/pkg/codegen/testdata/codegen/test/ns_skip.go similarity index 57% rename from pkg/codegen/testdata/03_const_keyword.go rename to pkg/codegen/testdata/codegen/test/ns_skip.go index 337f96ae..d60d30b3 100644 --- a/pkg/codegen/testdata/03_const_keyword.go +++ b/pkg/codegen/testdata/codegen/test/ns_skip.go @@ -6,7 +6,7 @@ import ( "github.com/glojurelang/glojure/pkg/lang" ) -// :foo -func Form_0() interface{} { - return lang.NewKeyword("foo") +func init() { + ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.ns-skip")) + _ = ns } diff --git a/pkg/runtime/fn.go b/pkg/runtime/fn.go index e288e47e..76260300 100644 --- a/pkg/runtime/fn.go +++ b/pkg/runtime/fn.go @@ -33,6 +33,10 @@ func (fn *Fn) WithMeta(meta lang.IPersistentMap) interface{} { return &cpy } +func (fn *Fn) ASTNode() *ast.Node { + return fn.astNode +} + func (fn *Fn) Invoke(args ...interface{}) interface{} { fnNode := fn.astNode.Sub.(*ast.FnNode) From 715ad47c1c59fec7dc935611e32e98b0302fb294 Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sat, 16 Aug 2025 11:29:18 -0700 Subject: [PATCH 03/67] cleanup Signed-off-by: James Hamlin --- pkg/codegen/codegen.go | 163 ++++++++++++++++++++++------------------- 1 file changed, 87 insertions(+), 76 deletions(-) diff --git a/pkg/codegen/codegen.go b/pkg/codegen/codegen.go index d4bf86a4..059dfb66 100644 --- a/pkg/codegen/codegen.go +++ b/pkg/codegen/codegen.go @@ -244,12 +244,6 @@ func (g *Generator) generateFn(fn *runtime.Fn) string { // Allocate a variable for the function fnVar := g.allocateVar("fn") - // Start building the function - var buf bytes.Buffer - - // Generate an immediately invoked function expression (IIFE) to define and return the function - buf.WriteString("func() interface{} {\n") - // Push a new scope for the function definition g.pushVarScope() defer g.popVarScope() @@ -259,21 +253,21 @@ func (g *Generator) generateFn(fn *runtime.Fn) string { method := fnNode.Methods[0] methodNode := method.Sub.(*ast.FnMethodNode) - buf.WriteString(fmt.Sprintf(" %s := lang.IFnFunc(func(args ...interface{}) interface{} {\n", fnVar)) + g.writef("%s := lang.IFnFunc(func(args ...any) any {\n", fnVar) // Check arity - buf.WriteString(fmt.Sprintf(" if len(args) != %d {\n", methodNode.FixedArity)) - buf.WriteString(fmt.Sprintf(" panic(lang.NewIllegalArgumentError(\"wrong number of arguments (\" + fmt.Sprint(len(args)) + \")\"))\n")) - buf.WriteString(" }\n") + g.writef(" if len(args) != %d {\n", methodNode.FixedArity) + g.writef(" panic(lang.NewIllegalArgumentError(\"wrong number of arguments (\" + fmt.Sprint(len(args)) + \")\"))\n") + g.writef(" }\n") // Generate method body - g.generateFnMethod(&buf, methodNode, "args", 0) + g.generateFnMethod(methodNode, "args", 0) - buf.WriteString(" })\n") + g.writef("})\n") } else { // Multiple arities or variadic - need to dispatch - buf.WriteString(fmt.Sprintf(" %s := lang.IFnFunc(func(args ...interface{}) interface{} {\n", fnVar)) - buf.WriteString(" switch len(args) {\n") + g.writef("%s := lang.IFnFunc(func(args ...any) any {\n", fnVar) + g.writef(" switch len(args) {\n") // Generate cases for fixed arity methods var variadicMethod *ast.Node @@ -284,46 +278,42 @@ func (g *Generator) generateFn(fn *runtime.Fn) string { continue } - buf.WriteString(fmt.Sprintf(" case %d:\n", methodNode.FixedArity)) - g.generateFnMethod(&buf, methodNode, "args", 2) + g.writef(" case %d:\n", methodNode.FixedArity) + g.generateFnMethod(methodNode, "args", 1) } // Generate default case for variadic method if variadicMethod != nil { variadicMethodNode := variadicMethod.Sub.(*ast.FnMethodNode) - buf.WriteString(" default:\n") - buf.WriteString(fmt.Sprintf(" if len(args) < %d {\n", variadicMethodNode.FixedArity)) - buf.WriteString(fmt.Sprintf(" panic(lang.NewIllegalArgumentError(\"wrong number of arguments (\" + fmt.Sprint(len(args)) + \")\"))\n")) - buf.WriteString(" }\n") - g.generateFnMethod(&buf, variadicMethodNode, "args", 2) + g.writef(" default:\n") + g.writef(" if len(args) < %d {\n", variadicMethodNode.FixedArity) + g.writef(" panic(lang.NewIllegalArgumentError(\"wrong number of arguments (\" + fmt.Sprint(len(args)) + \")\"))\n") + g.writef(" }\n") + g.generateFnMethod(variadicMethodNode, "args", 1) } else { // No variadic method - error on any other arity - buf.WriteString(" default:\n") - buf.WriteString(fmt.Sprintf(" panic(lang.NewIllegalArgumentError(\"wrong number of arguments (\" + fmt.Sprint(len(args)) + \")\"))\n")) + g.writef(" default:\n") + g.writef(" panic(lang.NewIllegalArgumentError(\"wrong number of arguments (\" + fmt.Sprint(len(args)) + \")\"))\n") } - buf.WriteString(" }\n") - buf.WriteString(" })\n") + g.writef(" }\n") + g.writef("})\n") } // Handle metadata if present if meta := fn.Meta(); meta != nil { metaVar := g.generateValue(meta) // IFnFunc doesn't support metadata directly, so wrap it - buf.WriteString(fmt.Sprintf(" // Note: metadata on functions is not yet supported in generated code\n")) - buf.WriteString(fmt.Sprintf(" // Original metadata: %s\n", metaVar)) - buf.WriteString(fmt.Sprintf(" return %s\n", fnVar)) - } else { - buf.WriteString(fmt.Sprintf(" return %s\n", fnVar)) + g.writef("// Note: metadata on functions is not yet supported in generated code\n") + g.writef("// Original metadata: %s\n", metaVar) } - buf.WriteString("}()") - - return buf.String() + // Return the function variable + return fnVar } // generateFnMethod generates the body of a function method -func (g *Generator) generateFnMethod(buf *bytes.Buffer, methodNode *ast.FnMethodNode, argsVar string, indentLevel int) { +func (g *Generator) generateFnMethod(methodNode *ast.FnMethodNode, argsVar string, indentLevel int) { indent := strings.Repeat(" ", indentLevel) // Push a new scope for the method body @@ -332,7 +322,7 @@ func (g *Generator) generateFnMethod(buf *bytes.Buffer, methodNode *ast.FnMethod // TODO: Handle recur with a label when we implement recur // if methodNode.LoopID != nil { - // buf.WriteString(fmt.Sprintf("%s Recur_%s:\n", indent, mungeID(methodNode.LoopID.Name()))) + // g.writef("%sRecur_%s:\n", indent, mungeID(methodNode.LoopID.Name())) // } // Bind parameters @@ -342,16 +332,16 @@ func (g *Generator) generateFnMethod(buf *bytes.Buffer, methodNode *ast.FnMethod if i < methodNode.FixedArity { // Regular parameter - buf.WriteString(fmt.Sprintf("%s %s := %s[%d]\n", indent, paramVar, argsVar, i)) + g.writef("%s %s := %s[%d]\n", indent, paramVar, argsVar, i) } else { // Variadic parameter - collect rest args - buf.WriteString(fmt.Sprintf("%s %s := lang.NewList(%s[%d:]...)\n", indent, paramVar, argsVar, methodNode.FixedArity)) + g.writef("%s %s := lang.NewList(%s[%d:]...)\n", indent, paramVar, argsVar, methodNode.FixedArity) } } // Generate the body bodyVar := g.generateASTNode(methodNode.Body) - buf.WriteString(fmt.Sprintf("%s return %s\n", indent, bodyVar)) + g.writef("%s return %s\n", indent, bodyVar) } // generateASTNode generates code for an AST node @@ -378,17 +368,47 @@ func (g *Generator) generateASTNode(node *ast.Node) string { } } +// generateInvoke generates code for an Invoke node +func (g *Generator) generateInvoke(node *ast.Node) string { + invokeNode := node.Sub.(*ast.InvokeNode) + + // Generate the function expression + fnExpr := g.generateASTNode(invokeNode.Fn) + + // Generate the arguments + var argExprs []string + for _, arg := range invokeNode.Args { + argExprs = append(argExprs, g.generateASTNode(arg)) + } + + // Allocate a result variable for the invocation + resultVar := g.allocateVar("invokeResult") + + // Emit the invocation + if len(argExprs) == 0 { + g.writef("%s := lang.Invoke(%s)\n", resultVar, fnExpr) + } else { + g.writef("%s := lang.Invoke(%s, %s)\n", resultVar, fnExpr, strings.Join(argExprs, ", ")) + } + + // Return the result variable + return resultVar +} + // generateDo generates code for a Do node func (g *Generator) generateDo(node *ast.Node) string { - var buf bytes.Buffer doNode := node.Sub.(*ast.DoNode) - for _, subNode := range doNode.Statements { - if subNode == nil { + + // Emit all statements except the last to g.w + for _, stmt := range doNode.Statements { + if stmt == nil { continue } - subCode := g.generateASTNode(subNode) - buf.WriteString(subCode + "\n") + stmtResult := g.generateASTNode(stmt) + g.writef("_ = %s\n", stmtResult) // Discard intermediate results } + + // Return the final expression return g.generateASTNode(doNode.Ret) } @@ -396,30 +416,26 @@ func (g *Generator) generateDo(node *ast.Node) string { func (g *Generator) generateIf(node *ast.Node) string { ifNode := node.Sub.(*ast.IfNode) - test := ifNode.Test - then := ifNode.Then - els := ifNode.Else - - // testVal, err := env.EvalAST(test) - // if err != nil { - // return nil, err - // } - // if lang.IsTruthy(testVal) { - // return env.EvalAST(then) - // } else { - // return env.EvalAST(els) - // } - - var buf bytes.Buffer - buf.WriteString("if lang.IsTruthy(") - buf.WriteString(g.generateASTNode(test) + ") {\n") - buf.WriteString(" return " + g.generateASTNode(then) + "\n") - if els != nil { - buf.WriteString("} else {\n") - buf.WriteString(" return " + g.generateASTNode(els) + "\n") + // Allocate result variable + resultVar := g.allocateVar("ifResult") + + // Emit the if statement to g.w + g.writef("var %s any\n", resultVar) + testExpr := g.generateASTNode(ifNode.Test) + g.writef("if lang.IsTruthy(%s) {\n", testExpr) + thenExpr := g.generateASTNode(ifNode.Then) + g.writef(" %s = %s\n", resultVar, thenExpr) + g.writef("} else {\n") + if ifNode.Else != nil { + elsExpr := g.generateASTNode(ifNode.Else) + g.writef(" %s = %s\n", resultVar, elsExpr) + } else { + g.writef(" %s = nil\n", resultVar) } - buf.WriteString("}\n") - return buf.String() + g.writef("}\n") + + // Return the r-value + return resultVar } // func (env *environment) EvalASTLet(n *ast.Node, isLoop bool) (interface{}, error) { @@ -480,9 +496,7 @@ func (g *Generator) generateLet(node *ast.Node, isLoop bool) string { g.pushVarScope() defer g.popVarScope() - var buf bytes.Buffer - - // Bind variables + // Emit bindings directly to g.w for _, binding := range letNode.Bindings { bindingNode := binding.Sub.(*ast.BindingNode) name := bindingNode.Name.Name() @@ -493,14 +507,11 @@ func (g *Generator) generateLet(node *ast.Node, isLoop bool) string { // Generate initialization code initCode := g.generateASTNode(init) - buf.WriteString(fmt.Sprintf("%s := %s\n", varName, initCode)) + g.writef("%s := %s\n", varName, initCode) } - // Generate the body of the let - bodyCode := g.generateASTNode(letNode.Body) - buf.WriteString(fmt.Sprintf("return %s\n", bodyCode)) - - return buf.String() + // Return the body expression (r-value) + return g.generateASTNode(letNode.Body) } //////////////////////////////////////////////////////////////////////////////// @@ -524,7 +535,7 @@ import ( return err } -func (g *Generator) writef(format string, args ...interface{}) error { +func (g *Generator) writef(format string, args ...any) error { _, err := fmt.Fprintf(g.w, format, args...) return err } From 801a74a68571df5a11c748e566fe7a1c843677b8 Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sat, 16 Aug 2025 12:16:27 -0700 Subject: [PATCH 04/67] wip Signed-off-by: James Hamlin --- pkg/codegen/codegen.go | 90 +++++++++++++++---- .../testdata/codegen/test/loop_simple.go | 37 +++++--- 2 files changed, 99 insertions(+), 28 deletions(-) diff --git a/pkg/codegen/codegen.go b/pkg/codegen/codegen.go index 059dfb66..dca36acc 100644 --- a/pkg/codegen/codegen.go +++ b/pkg/codegen/codegen.go @@ -81,11 +81,9 @@ func (g *Generator) Generate(ns *lang.Namespace) error { g.writef(" ns := lang.FindOrCreateNamespace(lang.NewSymbol(\"%s\"))\n", ns.Name().String()) g.writef(" _ = ns\n") - // TODO: Generate code to populate the namespace - // This will involve: - // 1. Iterating through ns.Mappings() - // 2. Generating Go code for each var - // 3. Creating initialization functions + // 1. Iterate through ns.Mappings() + // 2. Generate Go code for each var + // 3. Create initialization functions for seq := mappings.Seq(); seq != nil; seq = seq.Next() { entry := seq.First() name, ok := lang.First(entry).(*lang.Symbol) @@ -346,7 +344,6 @@ func (g *Generator) generateFnMethod(methodNode *ast.FnMethodNode, argsVar strin // generateASTNode generates code for an AST node func (g *Generator) generateASTNode(node *ast.Node) string { - fmt.Printf("Generating code for AST node: %T %+v\n", node.Sub, node.Sub) switch node.Op { case ast.OpConst: constNode := node.Sub.(*ast.ConstNode) @@ -363,34 +360,64 @@ func (g *Generator) generateASTNode(node *ast.Node) string { return g.generateIf(node) case ast.OpInvoke: return g.generateInvoke(node) + case ast.OpVar: + return g.generateVarDeref(node) + case ast.OpRecur: + return g.generateRecur(node) default: + fmt.Printf("Generating code for AST node: %T %+v\n", node.Sub, node.Sub) panic(fmt.Sprintf("unsupported AST node type %T", node.Sub)) } } +// generateVarDeref generates code for a Var dereference +func (g *Generator) generateVarDeref(node *ast.Node) string { + varNode := node.Sub.(*ast.VarNode) + + varNamespace := varNode.Var.Namespace() + varSymbol := varNode.Var.Symbol() + + // generate code to look up the var in the namespace + nsVar := g.allocateVar("ns") + g.writef("%s := lang.FindNamespace(lang.NewSymbol(\"%s\"))\n", nsVar, varNamespace.Name()) + // look up the var in the namespace + varId := g.allocateVar("varId") + g.writef("%s := %s.FindInternedVar(lang.NewSymbol(\"%s\"))\n", varId, nsVar, varSymbol.Name()) + + // if macro, panic with 'can't take value of macro: %v' + g.writef("if %s.IsMacro() {\n", varId) + g.writef(" panic(lang.NewIllegalArgumentError(\"can't take value of macro: %v\"))\n", varId) + g.writef("}\n") + // else, return Get() + resultId := g.allocateVar("result") + g.writef("%s := %s.Get()\n", resultId, varId) + + return resultId +} + // generateInvoke generates code for an Invoke node func (g *Generator) generateInvoke(node *ast.Node) string { invokeNode := node.Sub.(*ast.InvokeNode) - + // Generate the function expression fnExpr := g.generateASTNode(invokeNode.Fn) - + // Generate the arguments var argExprs []string for _, arg := range invokeNode.Args { argExprs = append(argExprs, g.generateASTNode(arg)) } - + // Allocate a result variable for the invocation resultVar := g.allocateVar("invokeResult") - + // Emit the invocation if len(argExprs) == 0 { - g.writef("%s := lang.Invoke(%s)\n", resultVar, fnExpr) + g.writef("%s := lang.Apply(%s, nil)\n", resultVar, fnExpr) } else { - g.writef("%s := lang.Invoke(%s, %s)\n", resultVar, fnExpr, strings.Join(argExprs, ", ")) + g.writef("%s := lang.Apply(%s, []any{%s})\n", resultVar, fnExpr, strings.Join(argExprs, ", ")) } - + // Return the result variable return resultVar } @@ -398,7 +425,7 @@ func (g *Generator) generateInvoke(node *ast.Node) string { // generateDo generates code for a Do node func (g *Generator) generateDo(node *ast.Node) string { doNode := node.Sub.(*ast.DoNode) - + // Emit all statements except the last to g.w for _, stmt := range doNode.Statements { if stmt == nil { @@ -407,7 +434,7 @@ func (g *Generator) generateDo(node *ast.Node) string { stmtResult := g.generateASTNode(stmt) g.writef("_ = %s\n", stmtResult) // Discard intermediate results } - + // Return the final expression return g.generateASTNode(doNode.Ret) } @@ -418,7 +445,7 @@ func (g *Generator) generateIf(node *ast.Node) string { // Allocate result variable resultVar := g.allocateVar("ifResult") - + // Emit the if statement to g.w g.writef("var %s any\n", resultVar) testExpr := g.generateASTNode(ifNode.Test) @@ -433,7 +460,7 @@ func (g *Generator) generateIf(node *ast.Node) string { g.writef(" %s = nil\n", resultVar) } g.writef("}\n") - + // Return the r-value return resultVar } @@ -510,8 +537,35 @@ func (g *Generator) generateLet(node *ast.Node, isLoop bool) string { g.writef("%s := %s\n", varName, initCode) } + resultId := g.allocateVar("letResult") + if isLoop { + g.writef("var %s any\n", resultId) + g.writef("for {\n") + } + // Return the body expression (r-value) - return g.generateASTNode(letNode.Body) + result := g.generateASTNode(letNode.Body) + if isLoop { + g.writef(" %s = %s\n", resultId, result) + g.writef(" break\n") // Break out of the loop after the body + g.writef("}\n") + return resultId + } else { + return result + } +} + +func (g *Generator) generateRecur(node *ast.Node) string { + recurNode := node.Sub.(*ast.RecurNode) + + exprs := recurNode.Exprs + for _, expr := range exprs { + val, err := noRecurEnv.EvalAST(expr) + if err != nil { + return nil, err + } + vals = append(vals, val) + } } //////////////////////////////////////////////////////////////////////////////// diff --git a/pkg/codegen/testdata/codegen/test/loop_simple.go b/pkg/codegen/testdata/codegen/test/loop_simple.go index 15b2a3df..37c71b50 100644 --- a/pkg/codegen/testdata/codegen/test/loop_simple.go +++ b/pkg/codegen/testdata/codegen/test/loop_simple.go @@ -13,16 +13,33 @@ func init() { // simple-loop { v0 := lang.NewSymbol("simple-loop").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/loop_simple.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()))).(*lang.Symbol) - ns.InternWithValue(v0, func() interface{} { - v1 := lang.IFnFunc(func(args ...interface{}) interface{} { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + v1 := lang.IFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v2 := int64(0) + var v3 any + for { + var v4 any + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("<")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError("can't take value of macro: v6")) } - return nil - }) - // Note: metadata on functions is not yet supported in generated code - // Original metadata: lang.NewMap(lang.NewKeyword("rettag"), nil) - return v1 - }(), true) + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v2, int64(10)}) + if lang.IsTruthy(v8) { + v4 = nil + } else { + v4 = nil + } + v3 = v4 + break + } + return v3 + }) + // Note: metadata on functions is not yet supported in generated code + // Original metadata: lang.NewMap(lang.NewKeyword("rettag"), nil) + ns.InternWithValue(v0, v1, true) } } From e4feff47cc3266bc421351e74e2e9d9c75673ff9 Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sat, 16 Aug 2025 14:00:13 -0700 Subject: [PATCH 05/67] Recur for loops Signed-off-by: James Hamlin --- pkg/codegen/codegen.go | 113 ++++++++++++++---- .../testdata/codegen/test/loop_simple.glj | 3 +- .../testdata/codegen/test/loop_simple.go | 15 ++- .../testdata/codegen/test/main/main.go | 14 +++ 4 files changed, 117 insertions(+), 28 deletions(-) create mode 100644 pkg/codegen/testdata/codegen/test/main/main.go diff --git a/pkg/codegen/codegen.go b/pkg/codegen/codegen.go index dca36acc..dd6e8d30 100644 --- a/pkg/codegen/codegen.go +++ b/pkg/codegen/codegen.go @@ -18,11 +18,18 @@ type varScope struct { names map[string]string // maps Clojure names to Go variable names } +// recurContext represents the context for a loop/recur form +type recurContext struct { + loopID *lang.Symbol // The loop ID to match recur with its loop + bindings []string // Go variable names for loop bindings (in order) +} + // Generator handles the conversion of AST nodes to Go code type Generator struct { originalWriter io.Writer w io.Writer - varScopes []varScope // stack of variable scopes + varScopes []varScope // stack of variable scopes + recurStack []recurContext // stack of recur contexts for nested loops } // New creates a new code generator @@ -31,6 +38,7 @@ func New(w io.Writer) *Generator { originalWriter: w, w: w, varScopes: []varScope{{nextNum: 0, names: make(map[string]string)}}, + recurStack: []recurContext{}, } } @@ -259,7 +267,7 @@ func (g *Generator) generateFn(fn *runtime.Fn) string { g.writef(" }\n") // Generate method body - g.generateFnMethod(methodNode, "args", 0) + g.generateFnMethod(methodNode, "args") g.writef("})\n") } else { @@ -277,7 +285,7 @@ func (g *Generator) generateFn(fn *runtime.Fn) string { } g.writef(" case %d:\n", methodNode.FixedArity) - g.generateFnMethod(methodNode, "args", 1) + g.generateFnMethod(methodNode, "args") } // Generate default case for variadic method @@ -287,7 +295,7 @@ func (g *Generator) generateFn(fn *runtime.Fn) string { g.writef(" if len(args) < %d {\n", variadicMethodNode.FixedArity) g.writef(" panic(lang.NewIllegalArgumentError(\"wrong number of arguments (\" + fmt.Sprint(len(args)) + \")\"))\n") g.writef(" }\n") - g.generateFnMethod(variadicMethodNode, "args", 1) + g.generateFnMethod(variadicMethodNode, "args") } else { // No variadic method - error on any other arity g.writef(" default:\n") @@ -311,17 +319,12 @@ func (g *Generator) generateFn(fn *runtime.Fn) string { } // generateFnMethod generates the body of a function method -func (g *Generator) generateFnMethod(methodNode *ast.FnMethodNode, argsVar string, indentLevel int) { - indent := strings.Repeat(" ", indentLevel) - +func (g *Generator) generateFnMethod(methodNode *ast.FnMethodNode, argsVar string) { // Push a new scope for the method body g.pushVarScope() defer g.popVarScope() - // TODO: Handle recur with a label when we implement recur - // if methodNode.LoopID != nil { - // g.writef("%sRecur_%s:\n", indent, mungeID(methodNode.LoopID.Name())) - // } + // TODO: Handle recur with a label // Bind parameters for i, param := range methodNode.Params { @@ -330,16 +333,16 @@ func (g *Generator) generateFnMethod(methodNode *ast.FnMethodNode, argsVar strin if i < methodNode.FixedArity { // Regular parameter - g.writef("%s %s := %s[%d]\n", indent, paramVar, argsVar, i) + g.writef("%s := %s[%d]\n", paramVar, argsVar, i) } else { // Variadic parameter - collect rest args - g.writef("%s %s := lang.NewList(%s[%d:]...)\n", indent, paramVar, argsVar, methodNode.FixedArity) + g.writef("%s := lang.NewList(%s[%d:]...)\n", paramVar, argsVar, methodNode.FixedArity) } } // Generate the body bodyVar := g.generateASTNode(methodNode.Body) - g.writef("%s return %s\n", indent, bodyVar) + g.writef("return %s\n", bodyVar) } // generateASTNode generates code for an AST node @@ -354,6 +357,8 @@ func (g *Generator) generateASTNode(node *ast.Node) string { return g.allocateVar(localNode.Name.Name()) case ast.OpDo: return g.generateDo(node) + case ast.OpLet: + return g.generateLet(node, false) case ast.OpLoop: return g.generateLet(node, true) case ast.OpIf: @@ -451,11 +456,11 @@ func (g *Generator) generateIf(node *ast.Node) string { testExpr := g.generateASTNode(ifNode.Test) g.writef("if lang.IsTruthy(%s) {\n", testExpr) thenExpr := g.generateASTNode(ifNode.Then) - g.writef(" %s = %s\n", resultVar, thenExpr) + g.writeAssign(resultVar, thenExpr) g.writef("} else {\n") if ifNode.Else != nil { elsExpr := g.generateASTNode(ifNode.Else) - g.writef(" %s = %s\n", resultVar, elsExpr) + g.writeAssign(resultVar, elsExpr) } else { g.writef(" %s = nil\n", resultVar) } @@ -523,6 +528,12 @@ func (g *Generator) generateLet(node *ast.Node, isLoop bool) string { g.pushVarScope() defer g.popVarScope() + // Collect binding variable names for recur context if this is a loop + var bindingVars []string + if isLoop { + bindingVars = make([]string, 0, len(letNode.Bindings)) + } + // Emit bindings directly to g.w for _, binding := range letNode.Bindings { bindingNode := binding.Sub.(*ast.BindingNode) @@ -534,11 +545,26 @@ func (g *Generator) generateLet(node *ast.Node, isLoop bool) string { // Generate initialization code initCode := g.generateASTNode(init) - g.writef("%s := %s\n", varName, initCode) + g.writef("var %s any = %s\n", varName, initCode) + + // Collect binding variables for loop + if isLoop { + bindingVars = append(bindingVars, varName) + } } resultId := g.allocateVar("letResult") if isLoop { + // Push recur context for this loop + g.recurStack = append(g.recurStack, recurContext{ + loopID: letNode.LoopID, + bindings: bindingVars, + }) + defer func() { + // Pop recur context when done + g.recurStack = g.recurStack[:len(g.recurStack)-1] + }() + g.writef("var %s any\n", resultId) g.writef("for {\n") } @@ -546,7 +572,7 @@ func (g *Generator) generateLet(node *ast.Node, isLoop bool) string { // Return the body expression (r-value) result := g.generateASTNode(letNode.Body) if isLoop { - g.writef(" %s = %s\n", resultId, result) + g.writeAssign(resultId, result) g.writef(" break\n") // Break out of the loop after the body g.writef("}\n") return resultId @@ -558,14 +584,45 @@ func (g *Generator) generateLet(node *ast.Node, isLoop bool) string { func (g *Generator) generateRecur(node *ast.Node) string { recurNode := node.Sub.(*ast.RecurNode) - exprs := recurNode.Exprs - for _, expr := range exprs { - val, err := noRecurEnv.EvalAST(expr) - if err != nil { - return nil, err + // Find the matching recur context + var ctx *recurContext + for i := len(g.recurStack) - 1; i >= 0; i-- { + if lang.Equals(g.recurStack[i].loopID, recurNode.LoopID) { + ctx = &g.recurStack[i] + break } - vals = append(vals, val) } + + if ctx == nil { + panic(fmt.Sprintf("recur without matching loop for ID: %v", recurNode.LoopID)) + } + + // Verify the number of recur expressions matches the number of loop bindings + if len(recurNode.Exprs) != len(ctx.bindings) { + panic(fmt.Sprintf("recur expects %d arguments, got %d", len(ctx.bindings), len(recurNode.Exprs))) + } + + // Generate temporary variables to hold the new values + // This prevents issues with bindings that reference each other + tempVars := make([]string, len(recurNode.Exprs)) + for i, expr := range recurNode.Exprs { + tempVar := g.allocateVar(fmt.Sprintf("recurTemp%d", i)) + tempVars[i] = tempVar + exprCode := g.generateASTNode(expr) + g.writef("var %s any = %s\n", tempVar, exprCode) + } + + // Assign the temporary values to the loop bindings + for i, bindingVar := range ctx.bindings { + g.writef("%s = %s\n", bindingVar, tempVars[i]) + } + + // Continue the loop + g.writef("continue\n") + + // Return empty string since recur doesn't produce a value + // (control flow never reaches past the continue) + return "" } //////////////////////////////////////////////////////////////////////////////// @@ -594,6 +651,14 @@ func (g *Generator) writef(format string, args ...any) error { return err } +// writeAssign writes an assignment iff the r-value string is non-empty +func (g *Generator) writeAssign(varName, rValue string) { + if rValue == "" { + return + } + g.writef("%s = %s\n", varName, rValue) +} + //////////////////////////////////////////////////////////////////////////////// // Variable Scope Management diff --git a/pkg/codegen/testdata/codegen/test/loop_simple.glj b/pkg/codegen/testdata/codegen/test/loop_simple.glj index 331bc333..e2f1b9e2 100644 --- a/pkg/codegen/testdata/codegen/test/loop_simple.glj +++ b/pkg/codegen/testdata/codegen/test/loop_simple.glj @@ -3,4 +3,5 @@ (defn simple-loop [] (loop [i 0] (if (< i 10) - (recur (inc i))))) + (recur (inc i)) + i))) diff --git a/pkg/codegen/testdata/codegen/test/loop_simple.go b/pkg/codegen/testdata/codegen/test/loop_simple.go index 37c71b50..248a754c 100644 --- a/pkg/codegen/testdata/codegen/test/loop_simple.go +++ b/pkg/codegen/testdata/codegen/test/loop_simple.go @@ -17,7 +17,7 @@ func init() { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v2 := int64(0) + var v2 any = int64(0) var v3 any for { var v4 any @@ -29,9 +29,18 @@ func init() { v7 := v6.Get() v8 := lang.Apply(v7, []any{v2, int64(10)}) if lang.IsTruthy(v8) { - v4 = nil + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("inc")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError("can't take value of macro: v6")) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v2}) + var v9 any = v8 + v2 = v9 + continue } else { - v4 = nil + v4 = v2 } v3 = v4 break diff --git a/pkg/codegen/testdata/codegen/test/main/main.go b/pkg/codegen/testdata/codegen/test/main/main.go new file mode 100644 index 00000000..c27c4be0 --- /dev/null +++ b/pkg/codegen/testdata/codegen/test/main/main.go @@ -0,0 +1,14 @@ +package main + +import ( + "fmt" + + _ "github.com/glojurelang/glojure/pkg/codegen/testdata/codegen/test" + "github.com/glojurelang/glojure/pkg/glj" +) + +func main() { + run := glj.Var("codegen.test.loop-simple", "simple-loop") + result := run.Invoke() + fmt.Printf("%v (%T)\n", result, result) +} From ecdfc284d1ac37b078a3baf843f3dcddfba5d417 Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sat, 16 Aug 2025 14:25:28 -0700 Subject: [PATCH 06/67] wip add main test Signed-off-by: James Hamlin --- pkg/codegen/codegen_test.go | 156 +++++++++++++++++- .../testdata/codegen/test/loop_simple.glj | 3 + .../testdata/codegen/test/loop_simple.go | 20 +++ .../testdata/codegen/test/main/main.go | 14 -- 4 files changed, 173 insertions(+), 20 deletions(-) delete mode 100644 pkg/codegen/testdata/codegen/test/main/main.go diff --git a/pkg/codegen/codegen_test.go b/pkg/codegen/codegen_test.go index ca48c606..3b78b7bf 100644 --- a/pkg/codegen/codegen_test.go +++ b/pkg/codegen/codegen_test.go @@ -20,6 +20,97 @@ import ( var updateGolden = flag.Bool("update", false, "update golden files") +const testHarnessCode = `package main + +import ( + "fmt" + "io/ioutil" + "os" + "path/filepath" + "strings" + + _ "github.com/glojurelang/glojure/pkg/codegen/testdata/codegen/test" + "github.com/glojurelang/glojure/pkg/lang" +) + +func main() { + // Find all .glj files in testdata directory + // Get the testdata path relative to GOPATH or module root + testdataDir := os.Args[1] + var namespaces []string + + err := filepath.Walk(testdataDir, func(path string, info os.FileInfo, err error) error { + if err != nil { + return err + } + if strings.HasSuffix(path, ".glj") { + // Read first line to get namespace + content, err := ioutil.ReadFile(path) + if err != nil { + return err + } + lines := strings.Split(string(content), "\n") + if len(lines) > 0 && strings.HasPrefix(lines[0], "(ns ") { + // Extract namespace name + nsLine := lines[0] + nsLine = strings.TrimPrefix(nsLine, "(ns ") + nsLine = strings.TrimSuffix(nsLine, ")") + parts := strings.Fields(nsLine) + if len(parts) > 0 { + namespaces = append(namespaces, parts[0]) + } + } + } + return nil + }) + if err != nil { + fmt.Printf("Error walking testdata: %v\n", err) + os.Exit(1) + } + + failed := false + for _, nsName := range namespaces { + ns := lang.FindNamespace(lang.NewSymbol(nsName)) + if ns == nil { + fmt.Printf("SKIP: namespace %s not found\n", nsName) + continue + } + + mainVar := ns.FindInternedVar(lang.NewSymbol("-main")) + if mainVar == nil { + fmt.Printf("SKIP: %s/-main not found\n", nsName) + continue + } + + // Check if -main has :expected-output metadata + meta := mainVar.Meta() + if meta == nil { + fmt.Printf("SKIP: %s/-main has no metadata\n", nsName) + continue + } + + expected := meta.ValAt(lang.NewKeyword("expected-output")) + if expected == nil { + fmt.Printf("SKIP: %s/-main has no :expected-output\n", nsName) + continue + } + + // Run -main and check the result + result := mainVar.Invoke() + if !lang.Equals(result, expected) { + fmt.Printf("FAIL: %s/-main returned %v, expected %v\n", nsName, result, expected) + failed = true + } else { + fmt.Printf("PASS: %s/-main\n", nsName) + } + } + + if failed { + os.Exit(1) + } +} +` + func TestCodegen(t *testing.T) { var testFiles []string err := filepath.Walk("testdata", func(path string, info os.FileInfo, err error) error { @@ -93,8 +184,8 @@ func TestCodegen(t *testing.T) { t.Errorf("go vet failed for %s: %v\nStderr:\n%s", goldenFile, err, stderr.String()) } - // TODO: Compile and run the generated code to verify behavior - // This will be added once we have more complete code generation + // Check if namespace has -main function with expected output + testMainFunction(t, ns) }) } } @@ -131,8 +222,61 @@ func getNamespaceFromFile(t *testing.T, filename string) string { panic("expected namespace declaration in " + filename) } -// TestBehavior verifies that generated code produces the same results as interpreted code -func TestBehavior(t *testing.T) { - // This test will be implemented once we can compile and run generated code - t.Skip("Behavioral testing not yet implemented") +// testMainFunction tests the -main function if it exists and has :expected-output metadata +func testMainFunction(t *testing.T, ns *lang.Namespace) { + // Look for -main var in the namespace + mainVar := ns.FindInternedVar(lang.NewSymbol("-main")) + if mainVar == nil { + // No -main function, nothing to test + return + } + + // Check if -main has :expected-output metadata + meta := mainVar.Meta() + if meta == nil { + return + } + + expectedOutput := meta.ValAt(lang.NewKeyword("expected-output")) + if expectedOutput == nil { + return + } + + // Run -main and check the result + result := mainVar.Invoke() + if !lang.Equals(result, expectedOutput) { + t.Errorf("-main returned %v, expected %v", result, expectedOutput) + } +} + +// TestGeneratedCode compiles and runs the generated code to verify behavior +func TestGeneratedCode(t *testing.T) { + // Write the test harness in a temporary directory + tmpDir, err := ioutil.TempDir("", "glojure_test_harness") + if err != nil { + t.Fatal(err) + } + defer os.RemoveAll(tmpDir) + + harnessPath := filepath.Join(tmpDir, "harness_main.go") + if err := ioutil.WriteFile(harnessPath, []byte(testHarnessCode), 0644); err != nil { + t.Fatal(err) + } + + // Get absolute path to testdata directory + testdataPath, err := filepath.Abs("testdata") + if err != nil { + t.Fatal(err) + } + + // Compile and run the test harness + cmd := exec.Command("go", "run", harnessPath, testdataPath) + cmd.Dir = "." + output, err := cmd.CombinedOutput() + if err != nil { + t.Fatalf("Test harness failed: %v\nOutput:\n%s", err, output) + } + + // Print the output for visibility + t.Logf("Test harness output:\n%s", output) } diff --git a/pkg/codegen/testdata/codegen/test/loop_simple.glj b/pkg/codegen/testdata/codegen/test/loop_simple.glj index e2f1b9e2..6b3c78f9 100644 --- a/pkg/codegen/testdata/codegen/test/loop_simple.glj +++ b/pkg/codegen/testdata/codegen/test/loop_simple.glj @@ -5,3 +5,6 @@ (if (< i 10) (recur (inc i)) i))) + +(defn ^{:expected-output 10} + -main [] (simple-loop)) diff --git a/pkg/codegen/testdata/codegen/test/loop_simple.go b/pkg/codegen/testdata/codegen/test/loop_simple.go index 248a754c..ceb5220a 100644 --- a/pkg/codegen/testdata/codegen/test/loop_simple.go +++ b/pkg/codegen/testdata/codegen/test/loop_simple.go @@ -10,6 +10,26 @@ import ( func init() { ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.loop-simple")) _ = ns + // -main + { + v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), int64(10), lang.NewKeyword("file"), "codegen/test/loop_simple.glj", lang.NewKeyword("line"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(10), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()))).(*lang.Symbol) + v1 := lang.IFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v2 := lang.FindNamespace(lang.NewSymbol("codegen.test.loop-simple")) + v3 := v2.FindInternedVar(lang.NewSymbol("simple-loop")) + if v3.IsMacro() { + panic(lang.NewIllegalArgumentError("can't take value of macro: v3")) + } + v4 := v3.Get() + v5 := lang.Apply(v4, nil) + return v5 + }) + // Note: metadata on functions is not yet supported in generated code + // Original metadata: lang.NewMap(lang.NewKeyword("rettag"), nil) + ns.InternWithValue(v0, v1, true) + } // simple-loop { v0 := lang.NewSymbol("simple-loop").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/loop_simple.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()))).(*lang.Symbol) diff --git a/pkg/codegen/testdata/codegen/test/main/main.go b/pkg/codegen/testdata/codegen/test/main/main.go deleted file mode 100644 index c27c4be0..00000000 --- a/pkg/codegen/testdata/codegen/test/main/main.go +++ /dev/null @@ -1,14 +0,0 @@ -package main - -import ( - "fmt" - - _ "github.com/glojurelang/glojure/pkg/codegen/testdata/codegen/test" - "github.com/glojurelang/glojure/pkg/glj" -) - -func main() { - run := glj.Var("codegen.test.loop-simple", "simple-loop") - result := run.Invoke() - fmt.Printf("%v (%T)\n", result, result) -} From f65333df6330acefb64576823d46bc24081470a4 Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sat, 16 Aug 2025 14:35:45 -0700 Subject: [PATCH 07/67] Wire up main test properly Signed-off-by: James Hamlin --- pkg/codegen/codegen_test.go | 128 +------------------- pkg/codegen/codegengotest/codegengo_test.go | 84 +++++++++++++ 2 files changed, 87 insertions(+), 125 deletions(-) create mode 100644 pkg/codegen/codegengotest/codegengo_test.go diff --git a/pkg/codegen/codegen_test.go b/pkg/codegen/codegen_test.go index 3b78b7bf..87429249 100644 --- a/pkg/codegen/codegen_test.go +++ b/pkg/codegen/codegen_test.go @@ -1,4 +1,4 @@ -package codegen +package codegen_test import ( "bytes" @@ -12,6 +12,7 @@ import ( "strings" "testing" + "github.com/glojurelang/glojure/pkg/codegen" "github.com/glojurelang/glojure/pkg/glj" "github.com/glojurelang/glojure/pkg/lang" "github.com/glojurelang/glojure/pkg/reader" @@ -20,97 +21,6 @@ import ( var updateGolden = flag.Bool("update", false, "update golden files") -const testHarnessCode = `package main - -import ( - "fmt" - "io/ioutil" - "os" - "path/filepath" - "strings" - - _ "github.com/glojurelang/glojure/pkg/codegen/testdata/codegen/test" - "github.com/glojurelang/glojure/pkg/lang" -) - -func main() { - // Find all .glj files in testdata directory - // Get the testdata path relative to GOPATH or module root - testdataDir := os.Args[1] - var namespaces []string - - err := filepath.Walk(testdataDir, func(path string, info os.FileInfo, err error) error { - if err != nil { - return err - } - if strings.HasSuffix(path, ".glj") { - // Read first line to get namespace - content, err := ioutil.ReadFile(path) - if err != nil { - return err - } - lines := strings.Split(string(content), "\n") - if len(lines) > 0 && strings.HasPrefix(lines[0], "(ns ") { - // Extract namespace name - nsLine := lines[0] - nsLine = strings.TrimPrefix(nsLine, "(ns ") - nsLine = strings.TrimSuffix(nsLine, ")") - parts := strings.Fields(nsLine) - if len(parts) > 0 { - namespaces = append(namespaces, parts[0]) - } - } - } - return nil - }) - if err != nil { - fmt.Printf("Error walking testdata: %v\n", err) - os.Exit(1) - } - - failed := false - for _, nsName := range namespaces { - ns := lang.FindNamespace(lang.NewSymbol(nsName)) - if ns == nil { - fmt.Printf("SKIP: namespace %s not found\n", nsName) - continue - } - - mainVar := ns.FindInternedVar(lang.NewSymbol("-main")) - if mainVar == nil { - fmt.Printf("SKIP: %s/-main not found\n", nsName) - continue - } - - // Check if -main has :expected-output metadata - meta := mainVar.Meta() - if meta == nil { - fmt.Printf("SKIP: %s/-main has no metadata\n", nsName) - continue - } - - expected := meta.ValAt(lang.NewKeyword("expected-output")) - if expected == nil { - fmt.Printf("SKIP: %s/-main has no :expected-output\n", nsName) - continue - } - - // Run -main and check the result - result := mainVar.Invoke() - if !lang.Equals(result, expected) { - fmt.Printf("FAIL: %s/-main returned %v, expected %v\n", nsName, result, expected) - failed = true - } else { - fmt.Printf("PASS: %s/-main\n", nsName) - } - } - - if failed { - os.Exit(1) - } -} -` - func TestCodegen(t *testing.T) { var testFiles []string err := filepath.Walk("testdata", func(path string, info os.FileInfo, err error) error { @@ -151,7 +61,7 @@ func TestCodegen(t *testing.T) { // Generate code for the namespace var buf bytes.Buffer - gen := New(&buf) + gen := codegen.New(&buf) if err := gen.Generate(ns); err != nil { t.Fatalf("failed to generate code: %v", err) } @@ -248,35 +158,3 @@ func testMainFunction(t *testing.T, ns *lang.Namespace) { t.Errorf("-main returned %v, expected %v", result, expectedOutput) } } - -// TestGeneratedCode compiles and runs the generated code to verify behavior -func TestGeneratedCode(t *testing.T) { - // Write the test harness in a temporary directory - tmpDir, err := ioutil.TempDir("", "glojure_test_harness") - if err != nil { - t.Fatal(err) - } - defer os.RemoveAll(tmpDir) - - harnessPath := filepath.Join(tmpDir, "harness_main.go") - if err := ioutil.WriteFile(harnessPath, []byte(testHarnessCode), 0644); err != nil { - t.Fatal(err) - } - - // Get absolute path to testdata directory - testdataPath, err := filepath.Abs("testdata") - if err != nil { - t.Fatal(err) - } - - // Compile and run the test harness - cmd := exec.Command("go", "run", harnessPath, testdataPath) - cmd.Dir = "." - output, err := cmd.CombinedOutput() - if err != nil { - t.Fatalf("Test harness failed: %v\nOutput:\n%s", err, output) - } - - // Print the output for visibility - t.Logf("Test harness output:\n%s", output) -} diff --git a/pkg/codegen/codegengotest/codegengo_test.go b/pkg/codegen/codegengotest/codegengo_test.go new file mode 100644 index 00000000..92b4b1a2 --- /dev/null +++ b/pkg/codegen/codegengotest/codegengo_test.go @@ -0,0 +1,84 @@ +package codegentest + +import ( + "io/ioutil" + "os" + "path/filepath" + "strings" + "testing" + + _ "github.com/glojurelang/glojure/pkg/codegen/testdata/codegen/test" + "github.com/glojurelang/glojure/pkg/lang" +) + +// TestMain is the entry point for running tests. We use it to ensure +// that this test runs in a separate process. +func TestMain(m *testing.M) { + os.Exit(m.Run()) +} + +func TestGeneratedGo(t *testing.T) { + // Find all .glj files in testdata directory + testdataDir := "../testdata" + var namespaces []string + + err := filepath.Walk(testdataDir, func(path string, info os.FileInfo, err error) error { + if err != nil { + return err + } + if strings.HasSuffix(path, ".glj") { + // Read first line to get namespace + content, err := ioutil.ReadFile(path) + if err != nil { + return err + } + lines := strings.Split(string(content), "\n") + if len(lines) > 0 && strings.HasPrefix(lines[0], "(ns ") { + // Extract namespace name + nsLine := lines[0] + nsLine = strings.TrimPrefix(nsLine, "(ns ") + nsLine = strings.TrimSuffix(nsLine, ")") + parts := strings.Fields(nsLine) + if len(parts) > 0 { + namespaces = append(namespaces, parts[0]) + } + } + } + return nil + }) + if err != nil { + t.Fatalf("Error walking testdata: %v", err) + } + + for _, nsName := range namespaces { + nsName := nsName // Capture range variable + t.Run(nsName, func(t *testing.T) { + ns := lang.FindNamespace(lang.NewSymbol(nsName)) + if ns == nil { + t.Fatalf("namespace %s not found", nsName) + } + + mainVar := ns.FindInternedVar(lang.NewSymbol("-main")) + if mainVar == nil { + t.Skip() + } + + // Check if -main has :expected-output metadata + meta := mainVar.Meta() + if meta == nil { + t.Fatalf("metadata for %s/-main is nil", nsName) + } + + expected := meta.ValAt(lang.NewKeyword("expected-output")) + if expected == nil { + t.Fatalf("no :expected-output metadata for %s/-main", nsName) + } + + // Run -main and check the result + result := mainVar.Invoke() + if !lang.Equals(result, expected) { + t.Errorf("%s/-main returned %v, expected %v", nsName, result, expected) + } + }) + } +} From ab769f99e2e097b9fd4f24a4b244b79c4bedc001 Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sat, 16 Aug 2025 14:46:28 -0700 Subject: [PATCH 08/67] fix up codegen test Signed-off-by: James Hamlin --- pkg/codegen/codegen.go | 16 ++++- pkg/codegen/codegengotest/codegengo_test.go | 3 +- .../testdata/codegen/test/const_keyword.go | 5 +- .../testdata/codegen/test/const_number.go | 5 +- .../testdata/codegen/test/const_string.go | 5 +- .../testdata/codegen/test/def_simple.go | 5 +- .../testdata/codegen/test/loop_simple.go | 70 ++++++++++--------- 7 files changed, 70 insertions(+), 39 deletions(-) diff --git a/pkg/codegen/codegen.go b/pkg/codegen/codegen.go index dd6e8d30..d900d8dc 100644 --- a/pkg/codegen/codegen.go +++ b/pkg/codegen/codegen.go @@ -12,6 +12,10 @@ import ( "github.com/glojurelang/glojure/pkg/runtime" ) +// TODO +// - handle namespace requires/uses/etc. +// - handle let bindings that are shared across multiple vars + // varScope represents a variable allocation scope type varScope struct { nextNum int @@ -148,10 +152,18 @@ func (g *Generator) generateVar(nsVariableName string, name *lang.Symbol, vr *la } // check if the var has a value + varVar := g.allocateVar("var") if vr.IsBound() { - g.writef("%s.InternWithValue(%s, %s, true)\n", nsVariableName, varSym, g.generateValue(vr.Get())) + g.writef("%s := %s.InternWithValue(%s, %s, true)\n", varVar, nsVariableName, varSym, g.generateValue(vr.Get())) } else { - g.writef("%s.Intern(%s)\n", nsVariableName, varSym) + g.writef("%s := %s.Intern(%s)\n", varVar, nsVariableName, varSym) + } + + // Set metadata on the var if the symbol has metadata + if meta != nil { + g.writef("if %s.Meta() != nil {\n", varSym) + g.writef("\t%s.SetMeta(%s.Meta().(lang.IPersistentMap))\n", varVar, varSym) + g.writef("}\n") } return nil diff --git a/pkg/codegen/codegengotest/codegengo_test.go b/pkg/codegen/codegengotest/codegengo_test.go index 92b4b1a2..a74fadd7 100644 --- a/pkg/codegen/codegengotest/codegengo_test.go +++ b/pkg/codegen/codegengotest/codegengo_test.go @@ -1,4 +1,4 @@ -package codegentest +package codegengotest import ( "io/ioutil" @@ -8,6 +8,7 @@ import ( "testing" _ "github.com/glojurelang/glojure/pkg/codegen/testdata/codegen/test" + _ "github.com/glojurelang/glojure/pkg/glj" "github.com/glojurelang/glojure/pkg/lang" ) diff --git a/pkg/codegen/testdata/codegen/test/const_keyword.go b/pkg/codegen/testdata/codegen/test/const_keyword.go index fd9e3580..0536f462 100644 --- a/pkg/codegen/testdata/codegen/test/const_keyword.go +++ b/pkg/codegen/testdata/codegen/test/const_keyword.go @@ -12,6 +12,9 @@ func init() { // const-keyword { v0 := lang.NewSymbol("const-keyword").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/const_keyword.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(18))).(*lang.Symbol) - ns.InternWithValue(v0, lang.NewKeyword("foo"), true) + v1 := ns.InternWithValue(v0, lang.NewKeyword("foo"), true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } } } diff --git a/pkg/codegen/testdata/codegen/test/const_number.go b/pkg/codegen/testdata/codegen/test/const_number.go index c4b018b2..23f4b288 100644 --- a/pkg/codegen/testdata/codegen/test/const_number.go +++ b/pkg/codegen/testdata/codegen/test/const_number.go @@ -12,6 +12,9 @@ func init() { // const-number { v0 := lang.NewSymbol("const-number").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/const_number.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("doc"), "A constant number.")).(*lang.Symbol) - ns.InternWithValue(v0, int64(42), true) + v1 := ns.InternWithValue(v0, int64(42), true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } } } diff --git a/pkg/codegen/testdata/codegen/test/const_string.go b/pkg/codegen/testdata/codegen/test/const_string.go index ed242ea8..385c564e 100644 --- a/pkg/codegen/testdata/codegen/test/const_string.go +++ b/pkg/codegen/testdata/codegen/test/const_string.go @@ -12,6 +12,9 @@ func init() { // const-string { v0 := lang.NewSymbol("const-string").WithMeta(lang.NewMap(lang.NewKeyword("hello"), true, lang.NewKeyword("file"), "codegen/test/const_string.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(25))).(*lang.Symbol) - ns.InternWithValue(v0, "Hello, World!", true) + v1 := ns.InternWithValue(v0, "Hello, World!", true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } } } diff --git a/pkg/codegen/testdata/codegen/test/def_simple.go b/pkg/codegen/testdata/codegen/test/def_simple.go index f0aadc31..4f804cae 100644 --- a/pkg/codegen/testdata/codegen/test/def_simple.go +++ b/pkg/codegen/testdata/codegen/test/def_simple.go @@ -12,6 +12,9 @@ func init() { // foo { v0 := lang.NewSymbol("foo").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/def_simple.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(8))).(*lang.Symbol) - ns.Intern(v0) + v1 := ns.Intern(v0) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } } } diff --git a/pkg/codegen/testdata/codegen/test/loop_simple.go b/pkg/codegen/testdata/codegen/test/loop_simple.go index ceb5220a..772e9a3e 100644 --- a/pkg/codegen/testdata/codegen/test/loop_simple.go +++ b/pkg/codegen/testdata/codegen/test/loop_simple.go @@ -13,62 +13,68 @@ func init() { // -main { v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), int64(10), lang.NewKeyword("file"), "codegen/test/loop_simple.glj", lang.NewKeyword("line"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(10), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()))).(*lang.Symbol) - v1 := lang.IFnFunc(func(args ...any) any { + v2 := lang.IFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v2 := lang.FindNamespace(lang.NewSymbol("codegen.test.loop-simple")) - v3 := v2.FindInternedVar(lang.NewSymbol("simple-loop")) - if v3.IsMacro() { - panic(lang.NewIllegalArgumentError("can't take value of macro: v3")) + v3 := lang.FindNamespace(lang.NewSymbol("codegen.test.loop-simple")) + v4 := v3.FindInternedVar(lang.NewSymbol("simple-loop")) + if v4.IsMacro() { + panic(lang.NewIllegalArgumentError("can't take value of macro: v4")) } - v4 := v3.Get() - v5 := lang.Apply(v4, nil) - return v5 + v5 := v4.Get() + v6 := lang.Apply(v5, nil) + return v6 }) // Note: metadata on functions is not yet supported in generated code // Original metadata: lang.NewMap(lang.NewKeyword("rettag"), nil) - ns.InternWithValue(v0, v1, true) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } } // simple-loop { v0 := lang.NewSymbol("simple-loop").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/loop_simple.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()))).(*lang.Symbol) - v1 := lang.IFnFunc(func(args ...any) any { + v2 := lang.IFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - var v2 any = int64(0) - var v3 any + var v3 any = int64(0) + var v4 any for { - var v4 any - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("<")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError("can't take value of macro: v6")) + var v5 any + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("<")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError("can't take value of macro: v7")) } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v2, int64(10)}) - if lang.IsTruthy(v8) { - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("inc")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError("can't take value of macro: v6")) + v8 := v7.Get() + v9 := lang.Apply(v8, []any{v3, int64(10)}) + if lang.IsTruthy(v9) { + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("inc")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError("can't take value of macro: v7")) } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v2}) - var v9 any = v8 - v2 = v9 + v8 := v7.Get() + v9 := lang.Apply(v8, []any{v3}) + var v10 any = v9 + v3 = v10 continue } else { - v4 = v2 + v5 = v3 } - v3 = v4 + v4 = v5 break } - return v3 + return v4 }) // Note: metadata on functions is not yet supported in generated code // Original metadata: lang.NewMap(lang.NewKeyword("rettag"), nil) - ns.InternWithValue(v0, v1, true) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } } } From 1c658a0bfb514063227c9a44ac5eb120fe5456d0 Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sat, 16 Aug 2025 16:18:37 -0700 Subject: [PATCH 09/67] Try/catch Signed-off-by: James Hamlin --- pkg/codegen/CLAUDE.md | 249 +++++++++++++ pkg/codegen/codegen.go | 157 +++++++- pkg/codegen/codegen_test.go | 26 +- .../testdata/codegen/test/loop_simple.go | 19 +- .../testdata/codegen/test/throw_simple.glj | 4 + .../testdata/codegen/test/throw_simple.go | 29 ++ .../testdata/codegen/test/try_advanced.glj | 38 ++ .../testdata/codegen/test/try_advanced.go | 178 +++++++++ .../testdata/codegen/test/try_basic.glj | 74 ++++ .../testdata/codegen/test/try_basic.go | 339 ++++++++++++++++++ 10 files changed, 1089 insertions(+), 24 deletions(-) create mode 100644 pkg/codegen/CLAUDE.md create mode 100644 pkg/codegen/testdata/codegen/test/throw_simple.glj create mode 100644 pkg/codegen/testdata/codegen/test/throw_simple.go create mode 100644 pkg/codegen/testdata/codegen/test/try_advanced.glj create mode 100644 pkg/codegen/testdata/codegen/test/try_advanced.go create mode 100644 pkg/codegen/testdata/codegen/test/try_basic.glj create mode 100644 pkg/codegen/testdata/codegen/test/try_basic.go diff --git a/pkg/codegen/CLAUDE.md b/pkg/codegen/CLAUDE.md new file mode 100644 index 00000000..8125a6a2 --- /dev/null +++ b/pkg/codegen/CLAUDE.md @@ -0,0 +1,249 @@ +# Glojure Codegen System + +This document provides guidance for understanding and working with Glojure's ahead-of-time (AOT) code generation system. + +## Overview + +The codegen package transforms Glojure AST nodes into Go source code, enabling ahead-of-time compilation. This is a work-in-progress alternative to the default tree-walking interpreter that offers potential performance benefits through static compilation. + +## Architecture + +### Compilation Pipeline + +``` +Source (.glj) → Reader → S-expressions → Analyzer → AST → Codegen → Go Source → go build → Native Binary + ↓ + Runtime Eval (default path) +``` + +### Key Components + +- **Generator** (pkg/codegen/codegen.go:32-46): Main code generation engine + - Manages variable scopes and recur contexts + - Handles output buffering and Go code formatting + +- **AST Nodes** (pkg/ast/ast.go:17-158): 44 different operation types + - Each node has an `Op` field determining its type + - `Sub` field contains op-specific data structures + +- **Analyzer** (pkg/compiler/analyze.go): Creates AST from S-expressions + - Performs macro expansion (pkg/compiler/analyze.go:87-122) + - Manages lexical environments (pkg/compiler/analyze.go:32-51) + - Dispatches to specialized analyzers (pkg/compiler/analyze.go:196-408) + +## Current Implementation Status + +### ✅ Supported Features + +| Feature | Implementation | Reference | +|---------|----------------|-----------| +| Constants | Numbers, strings, keywords, booleans, nil | codegen.go:383-385 | +| Local Variables | Let bindings, function parameters | codegen.go:386-389 | +| Namespace Vars | Var dereference and lookup | codegen.go:410-433 | +| Functions | Single/multi-arity, variadic | codegen.go:258-331 | +| Let/Loop | Including loop/recur | codegen.go:555-614 | +| Recur | Tail recursion within loops | codegen.go:616-658 | +| If/Else | Conditional expressions | codegen.go:479-503 | +| Do Blocks | Sequential evaluation | codegen.go:462-477 | +| Function Calls | Via lang.Apply | codegen.go:435-460 | +| Collections | Vectors, Maps | codegen.go:215-256 | + +### ❌ Not Yet Implemented + +- Host interop (., .., new) +- Try/catch/finally +- Case expressions +- Set literals +- Metadata on functions +- deftype/defprotocol +- Lazy sequences +- Transducers + +## Code Generation Process + +### 1. Namespace Generation (codegen.go:50-132) + +```go +func (g *Generator) Generate(ns *lang.Namespace) error +``` + +- Iterates through namespace mappings +- Generates init() function containing var definitions +- Applies go fmt to output + +### 2. Var Generation (codegen.go:136-170) + +Each var becomes: +```go +{ + varSym := lang.NewSymbol("var-name") + var := ns.InternWithValue(varSym, value, true) + // metadata handling... +} +``` + +### 3. Value Generation (codegen.go:173-213) + +Recursively generates Go expressions for Clojure values: +- Primitives: Direct Go literals +- Collections: `lang.NewVector(...)`, `lang.NewMap(...)` +- Functions: `lang.IFnFunc(func(args ...any) any { ... })` + +### 4. AST Node Generation (codegen.go:361-408) + +Dispatches on `node.Op` to specialized generators: +- Control flow nodes generate Go control structures +- Expression nodes generate Go expressions +- Special forms have custom handling + +## Variable Scope Management + +### Scope Stack (codegen.go:19-23, 696-741) + +```go +type varScope struct { + nextNum int // Counter for unique var names + names map[string]string // Clojure name → Go var name +} +``` + +- Each let/fn/loop pushes new scope +- Variables allocated as v0, v1, v2... +- Scopes inherit counter from parent + +### Example Scoping + +```clojure +(let [x 1] ; x → v0 + (let [x 2 y 3] ; x → v1 (shadows), y → v2 + (+ x y))) ; references v1, v2 +``` + +## Loop/Recur Implementation + +### Recur Context (codegen.go:25-29) + +```go +type recurContext struct { + loopID *lang.Symbol // Matches recur to its loop + bindings []string // Go variable names for rebinding +} +``` + +### Generated Pattern (codegen.go:589-614, 616-658) + +```go +// (loop [x 0] ... (recur (inc x))) +var v0 any = 0 +for { + // body... + var recurTemp0 any = v0 + 1 // Evaluate recur args + v0 = recurTemp0 // Rebind + continue // Loop +} +``` + +## Testing Infrastructure + +### Test Harness (pkg/codegen/codegen_test.go) + +1. **Golden Files** (codegen_test.go:24-71): Compare generated output + - Input: `testdata/*.glj` + - Expected: `testdata/*.glj.expected` + +2. **Go Vet Validation** (codegen_test.go:207-223): Ensures valid Go syntax + +3. **Behavioral Tests** (codegen_test.go:72-172): Run generated code + - Compiles to temporary binary + - Executes -main function + - Verifies output + +### Running Tests + +```bash +# Run all codegen tests +go test ./pkg/codegen/... + +# Update golden files +go test ./pkg/codegen/... -update + +# Verbose output with generated code +go test ./pkg/codegen/... -v +``` + +## Extending the Codegen + +### Adding New AST Node Support + +1. Add case in `generateASTNode()` (codegen.go:361-408) +2. Implement generator function following pattern: + ```go + func (g *Generator) generateNewOp(node *ast.Node) string { + newOpNode := node.Sub.(*ast.NewOpNode) + // Generate Go code... + resultVar := g.allocateVar("result") + g.writef("...") + return resultVar + } + ``` +3. Add test case in `testdata/` +4. Run tests with `-update` to create expected output + +### Common Patterns + +**R-values vs Statements**: Generators return variable names (r-values) and emit statements to `g.w`: +```go +testExpr := g.generateASTNode(node.Test) // Get r-value +g.writef("if lang.IsTruthy(%s) {\n", testExpr) // Use in statement +``` + +**Temporary Variables**: Use `allocateVar()` for unique names: +```go +tempVar := g.allocateVar("temp") +g.writef("%s := complexExpression()\n", tempVar) +``` + +**Scope Management**: Always push/pop for new lexical scopes: +```go +g.pushVarScope() +defer g.popVarScope() +``` + +## Debugging Tips + +1. **Examine Generated Code**: Tests output generated code on failure +2. **Check AST Structure**: Use `fmt.Printf("%#v\n", node)` to inspect +3. **Trace Execution**: Add logging to generator methods +4. **Validate Manually**: Copy generated code to test file and run + +## Integration Points + +### Runtime Compatibility + +Generated code uses same primitives as runtime: +- `lang.Apply()` for function calls (pkg/lang/ifn.go:8-25) +- `lang.IsTruthy()` for conditionals (pkg/lang/truthy.go:3-18) +- `lang.NewList/Vector/Map()` for collections (pkg/lang/collections.go) + +### Namespace System + +Generated code integrates with runtime namespaces: +- `lang.FindOrCreateNamespace()` (pkg/lang/namespace.go:340-350) +- `ns.InternWithValue()` (pkg/lang/namespace.go:112-125) +- Vars are accessible from REPL after loading + +## Future Directions + +1. **Full AST Coverage**: Implement remaining node types +2. **Optimization**: Dead code elimination, constant folding +3. **Integration**: Add `glj compile` command for AOT compilation +4. **Performance**: Benchmark against runtime interpreter +5. **Debugging**: Source maps for generated code + +## Related Files + +- **AST Definition**: pkg/ast/ast.go +- **Analyzer**: pkg/compiler/analyze.go +- **Runtime Evaluator**: pkg/runtime/evalast.go (comparison reference) +- **Test Data**: pkg/codegen/testdata/*.glj +- **Language Primitives**: pkg/lang/*.go \ No newline at end of file diff --git a/pkg/codegen/codegen.go b/pkg/codegen/codegen.go index d900d8dc..f3805d6a 100644 --- a/pkg/codegen/codegen.go +++ b/pkg/codegen/codegen.go @@ -143,7 +143,7 @@ func (g *Generator) generateVar(nsVariableName string, name *lang.Symbol, vr *la defer g.writef("}\n") meta := name.Meta() - varSym := g.allocateVar("varSym") + varSym := g.allocateTempVar() if meta == nil { g.writef("%s := lang.NewSymbol(\"%s\")\n", varSym, name.String()) } else { @@ -152,7 +152,7 @@ func (g *Generator) generateVar(nsVariableName string, name *lang.Symbol, vr *la } // check if the var has a value - varVar := g.allocateVar("var") + varVar := g.allocateTempVar() if vr.IsBound() { g.writef("%s := %s.InternWithValue(%s, %s, true)\n", varVar, nsVariableName, varSym, g.generateValue(vr.Get())) } else { @@ -260,7 +260,7 @@ func (g *Generator) generateFn(fn *runtime.Fn) string { fnNode := astNode.Sub.(*ast.FnNode) // Allocate a variable for the function - fnVar := g.allocateVar("fn") + fnVar := g.allocateTempVar() // Push a new scope for the function definition g.pushVarScope() @@ -354,12 +354,37 @@ func (g *Generator) generateFnMethod(methodNode *ast.FnMethodNode, argsVar strin // Generate the body bodyVar := g.generateASTNode(methodNode.Body) - g.writef("return %s\n", bodyVar) + if bodyVar != "" { + g.writef("return %s\n", bodyVar) + } + // If bodyVar is empty (e.g., from throw), no return is generated } // generateASTNode generates code for an AST node func (g *Generator) generateASTNode(node *ast.Node) string { switch node.Op { + // OpDef + // OpSetBang + // OpMaybeClass + // OpWithMeta + // OpFn + // OpMap + // OpVector + // OpSet + // OpLetFn + // OpQuote + // OpGoBuiltin + // OpGo + // OpHostCall + // OpHostInterop + // OpMaybeHostForm + // OpCase + // OpTheVar + // OpNew + case ast.OpTry: + return g.generateTry(node) + case ast.OpThrow: + return g.generateThrow(node) case ast.OpConst: constNode := node.Sub.(*ast.ConstNode) return g.generateValue(constNode.Value) @@ -381,6 +406,11 @@ func (g *Generator) generateASTNode(node *ast.Node) string { return g.generateVarDeref(node) case ast.OpRecur: return g.generateRecur(node) + case ast.OpGoBuiltin: + // For now, just return a reference to the go type + // This is used for catch clauses with go/any + goBuiltinNode := node.Sub.(*ast.GoBuiltinNode) + return fmt.Sprintf("lang.NewSymbol(\"%s\")", goBuiltinNode.Sym.Name()) default: fmt.Printf("Generating code for AST node: %T %+v\n", node.Sub, node.Sub) panic(fmt.Sprintf("unsupported AST node type %T", node.Sub)) @@ -395,18 +425,18 @@ func (g *Generator) generateVarDeref(node *ast.Node) string { varSymbol := varNode.Var.Symbol() // generate code to look up the var in the namespace - nsVar := g.allocateVar("ns") + nsVar := g.allocateTempVar() g.writef("%s := lang.FindNamespace(lang.NewSymbol(\"%s\"))\n", nsVar, varNamespace.Name()) // look up the var in the namespace - varId := g.allocateVar("varId") + varId := g.allocateTempVar() g.writef("%s := %s.FindInternedVar(lang.NewSymbol(\"%s\"))\n", varId, nsVar, varSymbol.Name()) // if macro, panic with 'can't take value of macro: %v' g.writef("if %s.IsMacro() {\n", varId) - g.writef(" panic(lang.NewIllegalArgumentError(\"can't take value of macro: %v\"))\n", varId) + g.writef(" panic(lang.NewIllegalArgumentError(fmt.Sprintf(\"can't take value of macro: %%v\", %s)))\n", varId) g.writef("}\n") // else, return Get() - resultId := g.allocateVar("result") + resultId := g.allocateTempVar() g.writef("%s := %s.Get()\n", resultId, varId) return resultId @@ -426,7 +456,7 @@ func (g *Generator) generateInvoke(node *ast.Node) string { } // Allocate a result variable for the invocation - resultVar := g.allocateVar("invokeResult") + resultVar := g.allocateTempVar() // Emit the invocation if len(argExprs) == 0 { @@ -449,7 +479,7 @@ func (g *Generator) generateDo(node *ast.Node) string { continue } stmtResult := g.generateASTNode(stmt) - g.writef("_ = %s\n", stmtResult) // Discard intermediate results + g.writeAssign("_", stmtResult) // Discard intermediate results } // Return the final expression @@ -461,7 +491,7 @@ func (g *Generator) generateIf(node *ast.Node) string { ifNode := node.Sub.(*ast.IfNode) // Allocate result variable - resultVar := g.allocateVar("ifResult") + resultVar := g.allocateTempVar() // Emit the if statement to g.w g.writef("var %s any\n", resultVar) @@ -558,6 +588,7 @@ func (g *Generator) generateLet(node *ast.Node, isLoop bool) string { // Generate initialization code initCode := g.generateASTNode(init) g.writef("var %s any = %s\n", varName, initCode) + g.writeAssign("_", varName) // Prevent unused variable warning // Collect binding variables for loop if isLoop { @@ -565,7 +596,7 @@ func (g *Generator) generateLet(node *ast.Node, isLoop bool) string { } } - resultId := g.allocateVar("letResult") + resultId := g.allocateTempVar() if isLoop { // Push recur context for this loop g.recurStack = append(g.recurStack, recurContext{ @@ -637,6 +668,96 @@ func (g *Generator) generateRecur(node *ast.Node) string { return "" } +// generateThrow generates code for a throw node +func (g *Generator) generateThrow(node *ast.Node) string { + throwNode := node.Sub.(*ast.ThrowNode) + + // Generate the exception expression + exceptionExpr := g.generateASTNode(throwNode.Exception) + + // Panic with the exception + g.writef("panic(%s)\n", exceptionExpr) + + // Return empty string to signal no value is produced + // The calling function should not generate a return after this + return "" +} + +// generateTry generates code for a try node +func (g *Generator) generateTry(node *ast.Node) string { + tryNode := node.Sub.(*ast.TryNode) + + // Allocate result variable + resultVar := g.allocateTempVar() + g.writef("var %s any\n", resultVar) + + // Use a closure to handle the try logic + g.writef("func() {\n") + + // Generate finally block if present + if tryNode.Finally != nil { + g.writef("defer func() {\n") + // Finally doesn't affect the return value + _ = g.generateASTNode(tryNode.Finally) + g.writef("}()\n") + } + + // Generate catch blocks if present + if len(tryNode.Catches) > 0 { + g.writef("defer func() {\n") + g.writef("if r := recover(); r != nil {\n") + + for i, catchNode := range tryNode.Catches { + catch := catchNode.Sub.(*ast.CatchNode) + + // Generate the class/type check + // For now, we'll handle simple cases + // TODO: implement proper type matching + classExpr := g.generateASTNode(catch.Class) + + // For each catch, check if the exception matches + if i > 0 { + g.writef("} else ") + } + + // Simple implementation: check for "any" or assume it catches + // In a full implementation, we'd need to check types properly + g.writef("if true { // TODO: implement catchMatches(r, %s)\n", classExpr) + + // Create new scope for catch binding + g.pushVarScope() + + // Bind the exception to the catch variable + bindingNode := catch.Local.Sub.(*ast.BindingNode) + catchVar := g.allocateVar(bindingNode.Name.Name()) + g.writef("%s := r\n", catchVar) + g.writeAssign("_", catchVar) // Mark as used since catch body might not reference it + + // Generate the catch body + bodyResult := g.generateASTNode(catch.Body) + g.writeAssign(resultVar, bodyResult) + + g.popVarScope() + } + + // Re-panic if no catch matched + g.writef("} else {\n") + g.writef("panic(r)\n") + g.writef("}\n") + + g.writef("}\n") + g.writef("}()\n") + } + + // Generate the try body + bodyResult := g.generateASTNode(tryNode.Body) + g.writeAssign(resultVar, bodyResult) + + g.writef("}()\n") + + return resultVar +} + //////////////////////////////////////////////////////////////////////////////// func (g *Generator) writeHeader(needsFmt bool) error { @@ -720,6 +841,18 @@ func (g *Generator) allocateVar(name string) string { return varName } +// allocateTempVar allocates a fresh temporary variable without name tracking +func (g *Generator) allocateTempVar() string { + if len(g.varScopes) == 0 { + panic("no variable scope available") + } + + currentScope := &g.varScopes[len(g.varScopes)-1] + varName := fmt.Sprintf("v%d", currentScope.nextNum) + currentScope.nextNum++ + return varName +} + func mungeID(name string) string { return strings.ReplaceAll(name, "-", "__") } diff --git a/pkg/codegen/codegen_test.go b/pkg/codegen/codegen_test.go index 87429249..720c9dee 100644 --- a/pkg/codegen/codegen_test.go +++ b/pkg/codegen/codegen_test.go @@ -132,7 +132,7 @@ func getNamespaceFromFile(t *testing.T, filename string) string { panic("expected namespace declaration in " + filename) } -// testMainFunction tests the -main function if it exists and has :expected-output metadata +// testMainFunction tests the -main function if it exists and has :expected-output or :expected-error metadata func testMainFunction(t *testing.T, ns *lang.Namespace) { // Look for -main var in the namespace mainVar := ns.FindInternedVar(lang.NewSymbol("-main")) @@ -141,14 +141,34 @@ func testMainFunction(t *testing.T, ns *lang.Namespace) { return } - // Check if -main has :expected-output metadata + // Check if -main has :expected-output or :expected-error metadata meta := mainVar.Meta() if meta == nil { return } expectedOutput := meta.ValAt(lang.NewKeyword("expected-output")) - if expectedOutput == nil { + expectedError := meta.ValAt(lang.NewKeyword("expected-error")) + + if expectedOutput == nil && expectedError == nil { + return + } + + // If we expect an error, use recover to catch it + if expectedError != nil { + defer func() { + if r := recover(); r != nil { + // Check if the panic matches expected error + if !lang.Equals(r, expectedError) { + t.Errorf("-main panicked with %v, expected %v", r, expectedError) + } + } else { + t.Errorf("-main should have panicked with %v, but didn't", expectedError) + } + }() + + // Run -main - should panic + mainVar.Invoke() return } diff --git a/pkg/codegen/testdata/codegen/test/loop_simple.go b/pkg/codegen/testdata/codegen/test/loop_simple.go index 772e9a3e..f1b603cd 100644 --- a/pkg/codegen/testdata/codegen/test/loop_simple.go +++ b/pkg/codegen/testdata/codegen/test/loop_simple.go @@ -20,7 +20,7 @@ func init() { v3 := lang.FindNamespace(lang.NewSymbol("codegen.test.loop-simple")) v4 := v3.FindInternedVar(lang.NewSymbol("simple-loop")) if v4.IsMacro() { - panic(lang.NewIllegalArgumentError("can't take value of macro: v4")) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) } v5 := v4.Get() v6 := lang.Apply(v5, nil) @@ -41,25 +41,26 @@ func init() { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } var v3 any = int64(0) + _ = v3 var v4 any for { var v5 any v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v7 := v6.FindInternedVar(lang.NewSymbol("<")) if v7.IsMacro() { - panic(lang.NewIllegalArgumentError("can't take value of macro: v7")) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } v8 := v7.Get() v9 := lang.Apply(v8, []any{v3, int64(10)}) if lang.IsTruthy(v9) { - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("inc")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError("can't take value of macro: v7")) + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("inc")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{v3}) - var v10 any = v9 + v13 := v12.Get() + v14 := lang.Apply(v13, []any{v3}) + var v10 any = v14 v3 = v10 continue } else { diff --git a/pkg/codegen/testdata/codegen/test/throw_simple.glj b/pkg/codegen/testdata/codegen/test/throw_simple.glj new file mode 100644 index 00000000..e344c9ee --- /dev/null +++ b/pkg/codegen/testdata/codegen/test/throw_simple.glj @@ -0,0 +1,4 @@ +(ns codegen.test.throw-simple) + +(defn ^{:expected-error "uncaught error"} -main [] + (throw "uncaught error")) \ No newline at end of file diff --git a/pkg/codegen/testdata/codegen/test/throw_simple.go b/pkg/codegen/testdata/codegen/test/throw_simple.go new file mode 100644 index 00000000..f066b6c5 --- /dev/null +++ b/pkg/codegen/testdata/codegen/test/throw_simple.go @@ -0,0 +1,29 @@ +// Code generated by glojure codegen. DO NOT EDIT. + +package generated + +import ( + "fmt" + "github.com/glojurelang/glojure/pkg/lang" +) + +func init() { + ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.throw-simple")) + _ = ns + // -main + { + v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-error"), "uncaught error", lang.NewKeyword("file"), "codegen/test/throw_simple.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(47), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()))).(*lang.Symbol) + v2 := lang.IFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + panic("uncaught error") + }) + // Note: metadata on functions is not yet supported in generated code + // Original metadata: lang.NewMap(lang.NewKeyword("rettag"), nil) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } +} diff --git a/pkg/codegen/testdata/codegen/test/try_advanced.glj b/pkg/codegen/testdata/codegen/test/try_advanced.glj new file mode 100644 index 00000000..567623c3 --- /dev/null +++ b/pkg/codegen/testdata/codegen/test/try_advanced.glj @@ -0,0 +1,38 @@ +(ns codegen.test.try-advanced) + +(defn try-custom-value [] + (try + (throw "custom error") + (catch go/any e + e))) + +(defn catch-binding-scope [] + (let [e "outer"] + (try + (throw "test") + (catch go/any e + e)))) ; should be the exception, not "outer" + +(defn finally-with-return [] + (try + 42 + (finally + 100))) ; should return 42, not 100 + +(defn ^{:expected-output "advanced tests passed"} -main [] + ;; Test that custom values can be thrown and caught + (if (= (try-custom-value) "custom error") + nil + (throw "try-custom-value failed")) + + ;; Test that catch binding shadows outer scope + (if (= (catch-binding-scope) "test") + nil + (throw "catch-binding-scope failed")) + + ;; Test that finally doesn't affect return value + (if (= (finally-with-return) 42) + nil + (throw "finally-with-return failed")) + + "advanced tests passed") diff --git a/pkg/codegen/testdata/codegen/test/try_advanced.go b/pkg/codegen/testdata/codegen/test/try_advanced.go new file mode 100644 index 00000000..0b12aaab --- /dev/null +++ b/pkg/codegen/testdata/codegen/test/try_advanced.go @@ -0,0 +1,178 @@ +// Code generated by glojure codegen. DO NOT EDIT. + +package generated + +import ( + "fmt" + "github.com/glojurelang/glojure/pkg/lang" +) + +func init() { + ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-advanced")) + _ = ns + // try-custom-value + { + v0 := lang.NewSymbol("try-custom-value").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_advanced.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()))).(*lang.Symbol) + v2 := lang.IFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v3 any + func() { + defer func() { + if r := recover(); r != nil { + if true { // TODO: implement catchMatches(r, lang.NewSymbol("any")) + v4 := r + _ = v4 + v3 = v4 + } else { + panic(r) + } + } + }() + panic("custom error") + }() + return v3 + }) + // Note: metadata on functions is not yet supported in generated code + // Original metadata: lang.NewMap(lang.NewKeyword("rettag"), nil) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // -main + { + v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), "advanced tests passed", lang.NewKeyword("file"), "codegen/test/try_advanced.glj", lang.NewKeyword("line"), int(22), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(22), lang.NewKeyword("end-column"), int(55), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()))).(*lang.Symbol) + v2 := lang.IFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v3 any + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("=")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("codegen.test.try-advanced")) + v8 := v7.FindInternedVar(lang.NewSymbol("try-custom-value")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, nil) + v11 := lang.Apply(v6, []any{v10, "custom error"}) + if lang.IsTruthy(v11) { + v3 = nil + } else { + panic("try-custom-value failed") + } + _ = v3 + var v12 any + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("=")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.FindNamespace(lang.NewSymbol("codegen.test.try-advanced")) + v17 := v16.FindInternedVar(lang.NewSymbol("catch-binding-scope")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, nil) + v20 := lang.Apply(v15, []any{v19, "test"}) + if lang.IsTruthy(v20) { + v12 = nil + } else { + panic("catch-binding-scope failed") + } + _ = v12 + var v21 any + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("=")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.FindNamespace(lang.NewSymbol("codegen.test.try-advanced")) + v26 := v25.FindInternedVar(lang.NewSymbol("finally-with-return")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.Apply(v27, nil) + v29 := lang.Apply(v24, []any{v28, int64(42)}) + if lang.IsTruthy(v29) { + v21 = nil + } else { + panic("finally-with-return failed") + } + _ = v21 + return "advanced tests passed" + }) + // Note: metadata on functions is not yet supported in generated code + // Original metadata: lang.NewMap(lang.NewKeyword("rettag"), nil) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // finally-with-return + { + v0 := lang.NewSymbol("finally-with-return").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_advanced.glj", lang.NewKeyword("line"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(16), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()))).(*lang.Symbol) + v2 := lang.IFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v3 any + func() { + defer func() { + }() + v3 = int64(42) + }() + return v3 + }) + // Note: metadata on functions is not yet supported in generated code + // Original metadata: lang.NewMap(lang.NewKeyword("rettag"), nil) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // catch-binding-scope + { + v0 := lang.NewSymbol("catch-binding-scope").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_advanced.glj", lang.NewKeyword("line"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(9), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()))).(*lang.Symbol) + v2 := lang.IFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v3 any = "outer" + _ = v3 + var v5 any + func() { + defer func() { + if r := recover(); r != nil { + if true { // TODO: implement catchMatches(r, lang.NewSymbol("any")) + v6 := r + _ = v6 + v5 = v6 + } else { + panic(r) + } + } + }() + panic("test") + }() + return v5 + }) + // Note: metadata on functions is not yet supported in generated code + // Original metadata: lang.NewMap(lang.NewKeyword("rettag"), nil) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } +} diff --git a/pkg/codegen/testdata/codegen/test/try_basic.glj b/pkg/codegen/testdata/codegen/test/try_basic.glj new file mode 100644 index 00000000..0ca9160e --- /dev/null +++ b/pkg/codegen/testdata/codegen/test/try_basic.glj @@ -0,0 +1,74 @@ +(ns codegen.test.try-basic) + +(defn basic-try [] + (try + "success" + (catch go/any e + "caught"))) + +(defn try-with-throw [] + (try + (throw "test error") + "not reached" + (catch go/any e + "caught exception"))) + +(defn try-no-catch [] + (try + "just body")) + +(defn try-finally-only [] + (try + "body" + (finally + nil))) ; finally doesn't affect return value + +(defn try-catch-finally [] + (try + (throw "error") + (catch go/any e + "caught") + (finally + nil))) + +(defn nested-try [] + (try + (try + (throw "inner") + (catch go/any e + "inner caught")) + (catch go/any e + "outer caught"))) + +(defn ^{:expected-output "all tests passed"} -main [] + ;; Test that basic-try returns success (no exception thrown) + (if (= (basic-try) "success") + nil + (throw "basic-try failed")) + + ;; Test that try-with-throw catches the exception + (if (= (try-with-throw) "caught exception") + nil + (throw "try-with-throw failed")) + + ;; Test that try-no-catch returns the body + (if (= (try-no-catch) "just body") + nil + (throw "try-no-catch failed")) + + ;; Test that try-finally-only returns body (not finally result) + (if (= (try-finally-only) "body") + nil + (throw "try-finally-only failed")) + + ;; Test that try-catch-finally catches the exception + (if (= (try-catch-finally) "caught") + nil + (throw "try-catch-finally failed")) + + ;; Test that nested-try catches in inner block + (if (= (nested-try) "inner caught") + nil + (throw "nested-try failed")) + + "all tests passed") diff --git a/pkg/codegen/testdata/codegen/test/try_basic.go b/pkg/codegen/testdata/codegen/test/try_basic.go new file mode 100644 index 00000000..fc918c26 --- /dev/null +++ b/pkg/codegen/testdata/codegen/test/try_basic.go @@ -0,0 +1,339 @@ +// Code generated by glojure codegen. DO NOT EDIT. + +package generated + +import ( + "fmt" + "github.com/glojurelang/glojure/pkg/lang" +) + +func init() { + ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")) + _ = ns + // try-catch-finally + { + v0 := lang.NewSymbol("try-catch-finally").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(26), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(26), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()))).(*lang.Symbol) + v2 := lang.IFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v3 any + func() { + defer func() { + }() + defer func() { + if r := recover(); r != nil { + if true { // TODO: implement catchMatches(r, lang.NewSymbol("any")) + v4 := r + _ = v4 + v3 = "caught" + } else { + panic(r) + } + } + }() + panic("error") + }() + return v3 + }) + // Note: metadata on functions is not yet supported in generated code + // Original metadata: lang.NewMap(lang.NewKeyword("rettag"), nil) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // -main + { + v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), "all tests passed", lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(43), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(43), lang.NewKeyword("end-column"), int(50), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()))).(*lang.Symbol) + v2 := lang.IFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v3 any + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("=")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("codegen.test.try-basic")) + v8 := v7.FindInternedVar(lang.NewSymbol("basic-try")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, nil) + v11 := lang.Apply(v6, []any{v10, "success"}) + if lang.IsTruthy(v11) { + v3 = nil + } else { + panic("basic-try failed") + } + _ = v3 + var v12 any + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("=")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.FindNamespace(lang.NewSymbol("codegen.test.try-basic")) + v17 := v16.FindInternedVar(lang.NewSymbol("try-with-throw")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, nil) + v20 := lang.Apply(v15, []any{v19, "caught exception"}) + if lang.IsTruthy(v20) { + v12 = nil + } else { + panic("try-with-throw failed") + } + _ = v12 + var v21 any + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("=")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.FindNamespace(lang.NewSymbol("codegen.test.try-basic")) + v26 := v25.FindInternedVar(lang.NewSymbol("try-no-catch")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.Apply(v27, nil) + v29 := lang.Apply(v24, []any{v28, "just body"}) + if lang.IsTruthy(v29) { + v21 = nil + } else { + panic("try-no-catch failed") + } + _ = v21 + var v30 any + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("=")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.FindNamespace(lang.NewSymbol("codegen.test.try-basic")) + v35 := v34.FindInternedVar(lang.NewSymbol("try-finally-only")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.Apply(v36, nil) + v38 := lang.Apply(v33, []any{v37, "body"}) + if lang.IsTruthy(v38) { + v30 = nil + } else { + panic("try-finally-only failed") + } + _ = v30 + var v39 any + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("=")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.FindNamespace(lang.NewSymbol("codegen.test.try-basic")) + v44 := v43.FindInternedVar(lang.NewSymbol("try-catch-finally")) + if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) + } + v45 := v44.Get() + v46 := lang.Apply(v45, nil) + v47 := lang.Apply(v42, []any{v46, "caught"}) + if lang.IsTruthy(v47) { + v39 = nil + } else { + panic("try-catch-finally failed") + } + _ = v39 + var v48 any + v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v50 := v49.FindInternedVar(lang.NewSymbol("=")) + if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) + } + v51 := v50.Get() + v52 := lang.FindNamespace(lang.NewSymbol("codegen.test.try-basic")) + v53 := v52.FindInternedVar(lang.NewSymbol("nested-try")) + if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) + } + v54 := v53.Get() + v55 := lang.Apply(v54, nil) + v56 := lang.Apply(v51, []any{v55, "inner caught"}) + if lang.IsTruthy(v56) { + v48 = nil + } else { + panic("nested-try failed") + } + _ = v48 + return "all tests passed" + }) + // Note: metadata on functions is not yet supported in generated code + // Original metadata: lang.NewMap(lang.NewKeyword("rettag"), nil) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // try-with-throw + { + v0 := lang.NewSymbol("try-with-throw").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(9), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()))).(*lang.Symbol) + v2 := lang.IFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v3 any + func() { + defer func() { + if r := recover(); r != nil { + if true { // TODO: implement catchMatches(r, lang.NewSymbol("any")) + v4 := r + _ = v4 + v3 = "caught exception" + } else { + panic(r) + } + } + }() + panic("test error") + v3 = "not reached" + }() + return v3 + }) + // Note: metadata on functions is not yet supported in generated code + // Original metadata: lang.NewMap(lang.NewKeyword("rettag"), nil) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // try-finally-only + { + v0 := lang.NewSymbol("try-finally-only").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(20), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()))).(*lang.Symbol) + v2 := lang.IFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v3 any + func() { + defer func() { + }() + v3 = "body" + }() + return v3 + }) + // Note: metadata on functions is not yet supported in generated code + // Original metadata: lang.NewMap(lang.NewKeyword("rettag"), nil) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // nested-try + { + v0 := lang.NewSymbol("nested-try").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(34), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(34), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()))).(*lang.Symbol) + v2 := lang.IFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v3 any + func() { + defer func() { + if r := recover(); r != nil { + if true { // TODO: implement catchMatches(r, lang.NewSymbol("any")) + v4 := r + _ = v4 + v3 = "outer caught" + } else { + panic(r) + } + } + }() + var v4 any + func() { + defer func() { + if r := recover(); r != nil { + if true { // TODO: implement catchMatches(r, lang.NewSymbol("any")) + v5 := r + _ = v5 + v4 = "inner caught" + } else { + panic(r) + } + } + }() + panic("inner") + }() + v3 = v4 + }() + return v3 + }) + // Note: metadata on functions is not yet supported in generated code + // Original metadata: lang.NewMap(lang.NewKeyword("rettag"), nil) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // basic-try + { + v0 := lang.NewSymbol("basic-try").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()))).(*lang.Symbol) + v2 := lang.IFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v3 any + func() { + defer func() { + if r := recover(); r != nil { + if true { // TODO: implement catchMatches(r, lang.NewSymbol("any")) + v4 := r + _ = v4 + v3 = "caught" + } else { + panic(r) + } + } + }() + v3 = "success" + }() + return v3 + }) + // Note: metadata on functions is not yet supported in generated code + // Original metadata: lang.NewMap(lang.NewKeyword("rettag"), nil) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // try-no-catch + { + v0 := lang.NewSymbol("try-no-catch").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(16), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()))).(*lang.Symbol) + v2 := lang.IFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v3 any + func() { + v3 = "just body" + }() + return v3 + }) + // Note: metadata on functions is not yet supported in generated code + // Original metadata: lang.NewMap(lang.NewKeyword("rettag"), nil) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } +} From 693d020ca1aaaa4c90711fa7dd132be6a120dff9 Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sat, 16 Aug 2025 16:26:45 -0700 Subject: [PATCH 10/67] fix Signed-off-by: James Hamlin --- pkg/codegen/codegengotest/codegengo_test.go | 19 +++++++++++++++++-- .../testdata/codegen/test/throw_simple.glj | 4 ++-- .../testdata/codegen/test/throw_simple.go | 2 +- 3 files changed, 20 insertions(+), 5 deletions(-) diff --git a/pkg/codegen/codegengotest/codegengo_test.go b/pkg/codegen/codegengotest/codegengo_test.go index a74fadd7..ac6e62f9 100644 --- a/pkg/codegen/codegengotest/codegengo_test.go +++ b/pkg/codegen/codegengotest/codegengo_test.go @@ -1,6 +1,7 @@ package codegengotest import ( + "fmt" "io/ioutil" "os" "path/filepath" @@ -71,8 +72,22 @@ func TestGeneratedGo(t *testing.T) { } expected := meta.ValAt(lang.NewKeyword("expected-output")) - if expected == nil { - t.Fatalf("no :expected-output metadata for %s/-main", nsName) + expectedThrow := meta.ValAt(lang.NewKeyword("expected-throw")) + fmt.Println("META:", meta) + if lang.IsNil(expected) && lang.IsNil(expectedThrow) { + t.Fatalf("no :expected-output or :expected-throw metadata for %s/-main", nsName) + } + + if !lang.IsNil(expectedThrow) { + defer func() { + if r := recover(); r != nil { + if !lang.Equals(r, expectedThrow) { + t.Errorf("%s/-main threw %v, expected %v", nsName, r, expectedThrow) + } + } else { + t.Errorf("%s/-main did not throw, expected %v", nsName, expectedThrow) + } + }() } // Run -main and check the result diff --git a/pkg/codegen/testdata/codegen/test/throw_simple.glj b/pkg/codegen/testdata/codegen/test/throw_simple.glj index e344c9ee..05754944 100644 --- a/pkg/codegen/testdata/codegen/test/throw_simple.glj +++ b/pkg/codegen/testdata/codegen/test/throw_simple.glj @@ -1,4 +1,4 @@ (ns codegen.test.throw-simple) -(defn ^{:expected-error "uncaught error"} -main [] - (throw "uncaught error")) \ No newline at end of file +(defn ^{:expected-throw "uncaught error"} -main [] + (throw "uncaught error")) diff --git a/pkg/codegen/testdata/codegen/test/throw_simple.go b/pkg/codegen/testdata/codegen/test/throw_simple.go index f066b6c5..6cba058f 100644 --- a/pkg/codegen/testdata/codegen/test/throw_simple.go +++ b/pkg/codegen/testdata/codegen/test/throw_simple.go @@ -12,7 +12,7 @@ func init() { _ = ns // -main { - v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-error"), "uncaught error", lang.NewKeyword("file"), "codegen/test/throw_simple.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(47), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()))).(*lang.Symbol) + v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-throw"), "uncaught error", lang.NewKeyword("file"), "codegen/test/throw_simple.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(47), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()))).(*lang.Symbol) v2 := lang.IFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) From 2b6f48afed98328fee151e153626ea374b4de77b Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sat, 16 Aug 2025 16:51:18 -0700 Subject: [PATCH 11/67] Fix up catch Signed-off-by: James Hamlin --- pkg/codegen/codegen.go | 89 ++++++++----------- .../testdata/codegen/test/try_advanced.go | 4 +- .../testdata/codegen/test/try_basic.go | 10 +-- pkg/lang/catch.go | 45 ++++++++++ pkg/runtime/evalast.go | 23 +---- 5 files changed, 89 insertions(+), 82 deletions(-) create mode 100644 pkg/lang/catch.go diff --git a/pkg/codegen/codegen.go b/pkg/codegen/codegen.go index f3805d6a..9007b3f4 100644 --- a/pkg/codegen/codegen.go +++ b/pkg/codegen/codegen.go @@ -34,6 +34,8 @@ type Generator struct { w io.Writer varScopes []varScope // stack of variable scopes recurStack []recurContext // stack of recur contexts for nested loops + + imports map[string]bool // set of imported packages to avoid duplicates } // New creates a new code generator @@ -43,6 +45,7 @@ func New(w io.Writer) *Generator { w: w, varScopes: []varScope{{nextNum: 0, names: make(map[string]string)}}, recurStack: []recurContext{}, + imports: make(map[string]bool), } } @@ -53,41 +56,6 @@ func (g *Generator) Generate(ns *lang.Namespace) error { var buf bytes.Buffer g.w = &buf - // Check if we need fmt import (for functions with arity checks) - needsFmt := false - mappings := ns.Mappings() - - // Only check vars that are interned in this namespace - for seq := mappings.Seq(); seq != nil; seq = seq.Next() { - entry := seq.First() - name, ok := lang.First(entry).(*lang.Symbol) - if !ok { - continue - } - second, _ := lang.Nth(entry, 1) - vr, ok := second.(*lang.Var) - if !ok { - continue - } - - // Skip non-interned mappings - if !(vr.Namespace() == ns && lang.Equals(vr.Symbol(), name)) { - continue - } - - if vr.IsBound() { - if _, ok := vr.Get().(*runtime.Fn); ok { - needsFmt = true - break - } - } - } - - // Write package header - if err := g.writeHeader(needsFmt); err != nil { - return err - } - g.writef("func init() {\n") g.writef(" ns := lang.FindOrCreateNamespace(lang.NewSymbol(\"%s\"))\n", ns.Name().String()) @@ -96,6 +64,7 @@ func (g *Generator) Generate(ns *lang.Namespace) error { // 1. Iterate through ns.Mappings() // 2. Generate Go code for each var // 3. Create initialization functions + mappings := ns.Mappings() for seq := mappings.Seq(); seq != nil; seq = seq.Next() { entry := seq.First() name, ok := lang.First(entry).(*lang.Symbol) @@ -119,8 +88,12 @@ func (g *Generator) Generate(ns *lang.Namespace) error { g.writef("}\n") + // Write package header + sourceBytes := []byte(g.header()) + sourceBytes = append(sourceBytes, buf.Bytes()...) + // Format the generated code - formatted, err := format.Source(buf.Bytes()) + formatted, err := format.Source(sourceBytes) if err != nil { // If formatting fails, write the unformatted code with the error return fmt.Errorf("formatting failed: %w\n\nGenerated code:\n%s", err, buf.String()) @@ -273,6 +246,7 @@ func (g *Generator) generateFn(fn *runtime.Fn) string { g.writef("%s := lang.IFnFunc(func(args ...any) any {\n", fnVar) + g.addImport("fmt") // Import fmt for error formatting // Check arity g.writef(" if len(args) != %d {\n", methodNode.FixedArity) g.writef(" panic(lang.NewIllegalArgumentError(\"wrong number of arguments (\" + fmt.Sprint(len(args)) + \")\"))\n") @@ -373,7 +347,6 @@ func (g *Generator) generateASTNode(node *ast.Node) string { // OpSet // OpLetFn // OpQuote - // OpGoBuiltin // OpGo // OpHostCall // OpHostInterop @@ -407,10 +380,7 @@ func (g *Generator) generateASTNode(node *ast.Node) string { case ast.OpRecur: return g.generateRecur(node) case ast.OpGoBuiltin: - // For now, just return a reference to the go type - // This is used for catch clauses with go/any - goBuiltinNode := node.Sub.(*ast.GoBuiltinNode) - return fmt.Sprintf("lang.NewSymbol(\"%s\")", goBuiltinNode.Sym.Name()) + return g.generateGoBuiltin(node) default: fmt.Printf("Generating code for AST node: %T %+v\n", node.Sub, node.Sub) panic(fmt.Sprintf("unsupported AST node type %T", node.Sub)) @@ -720,9 +690,8 @@ func (g *Generator) generateTry(node *ast.Node) string { g.writef("} else ") } - // Simple implementation: check for "any" or assume it catches - // In a full implementation, we'd need to check types properly - g.writef("if true { // TODO: implement catchMatches(r, %s)\n", classExpr) + // Check if the exception matches this catch type + g.writef("if lang.CatchMatches(r, %s) {\n", classExpr) // Create new scope for catch binding g.pushVarScope() @@ -758,25 +727,39 @@ func (g *Generator) generateTry(node *ast.Node) string { return resultVar } +func (g *Generator) generateGoBuiltin(node *ast.Node) string { + goBuiltinNode := node.Sub.(*ast.GoBuiltinNode) + sym := goBuiltinNode.Sym + + _, ok := lang.Builtins[sym.Name()] + if !ok { + panic(fmt.Sprintf("unknown Go builtin: %s", sym.Name())) + } + + return "lang.Builtins[\"" + sym.Name() + "\"]" +} + //////////////////////////////////////////////////////////////////////////////// -func (g *Generator) writeHeader(needsFmt bool) error { +func (g *Generator) addImport(pkg string) { + g.imports[pkg] = true +} + +func (g *Generator) header() string { header := `// Code generated by glojure codegen. DO NOT EDIT. package generated import ( + "github.com/glojurelang/glojure/pkg/lang" ` - if needsFmt { - header += ` "fmt" -` + + for pkg := range g.imports { + header += fmt.Sprintf(" \"%s\"\n", pkg) } - header += ` "github.com/glojurelang/glojure/pkg/lang" -) -` - _, err := io.WriteString(g.w, header) - return err + header += ")\n" + return header } func (g *Generator) writef(format string, args ...any) error { diff --git a/pkg/codegen/testdata/codegen/test/try_advanced.go b/pkg/codegen/testdata/codegen/test/try_advanced.go index 0b12aaab..f53ce86e 100644 --- a/pkg/codegen/testdata/codegen/test/try_advanced.go +++ b/pkg/codegen/testdata/codegen/test/try_advanced.go @@ -21,7 +21,7 @@ func init() { func() { defer func() { if r := recover(); r != nil { - if true { // TODO: implement catchMatches(r, lang.NewSymbol("any")) + if lang.CatchMatches(r, lang.Builtins["any"]) { v4 := r _ = v4 v3 = v4 @@ -155,7 +155,7 @@ func init() { func() { defer func() { if r := recover(); r != nil { - if true { // TODO: implement catchMatches(r, lang.NewSymbol("any")) + if lang.CatchMatches(r, lang.Builtins["any"]) { v6 := r _ = v6 v5 = v6 diff --git a/pkg/codegen/testdata/codegen/test/try_basic.go b/pkg/codegen/testdata/codegen/test/try_basic.go index fc918c26..b89ca989 100644 --- a/pkg/codegen/testdata/codegen/test/try_basic.go +++ b/pkg/codegen/testdata/codegen/test/try_basic.go @@ -23,7 +23,7 @@ func init() { }() defer func() { if r := recover(); r != nil { - if true { // TODO: implement catchMatches(r, lang.NewSymbol("any")) + if lang.CatchMatches(r, lang.Builtins["any"]) { v4 := r _ = v4 v3 = "caught" @@ -196,7 +196,7 @@ func init() { func() { defer func() { if r := recover(); r != nil { - if true { // TODO: implement catchMatches(r, lang.NewSymbol("any")) + if lang.CatchMatches(r, lang.Builtins["any"]) { v4 := r _ = v4 v3 = "caught exception" @@ -250,7 +250,7 @@ func init() { func() { defer func() { if r := recover(); r != nil { - if true { // TODO: implement catchMatches(r, lang.NewSymbol("any")) + if lang.CatchMatches(r, lang.Builtins["any"]) { v4 := r _ = v4 v3 = "outer caught" @@ -263,7 +263,7 @@ func init() { func() { defer func() { if r := recover(); r != nil { - if true { // TODO: implement catchMatches(r, lang.NewSymbol("any")) + if lang.CatchMatches(r, lang.Builtins["any"]) { v5 := r _ = v5 v4 = "inner caught" @@ -296,7 +296,7 @@ func init() { func() { defer func() { if r := recover(); r != nil { - if true { // TODO: implement catchMatches(r, lang.NewSymbol("any")) + if lang.CatchMatches(r, lang.Builtins["any"]) { v4 := r _ = v4 v3 = "caught" diff --git a/pkg/lang/catch.go b/pkg/lang/catch.go new file mode 100644 index 00000000..55d311ed --- /dev/null +++ b/pkg/lang/catch.go @@ -0,0 +1,45 @@ +package lang + +import ( + "errors" + "reflect" +) + +var ( + errorType = reflect.TypeOf((*error)(nil)).Elem() +) + +// CatchMatches checks if a recovered panic value matches an expected catch type. +// This implements the semantics of Clojure's try/catch matching. +func CatchMatches(r, expect any) bool { + if IsNil(expect) { + return false + } + + // Special case: the symbol "any" catches everything (for go/any) + if sym, ok := expect.(*Symbol); ok && sym.Name() == "any" { + return true + } + + // If expect is an error type, check if r is an instance of it + if rErr, ok := r.(error); ok { + if expectTyp, ok := expect.(reflect.Type); ok && expectTyp.Implements(errorType) { + expectVal := reflect.New(expectTyp).Elem().Interface().(error) + if errors.Is(rErr, expectVal) { + return true + } + } + } + + // General type check + if expectTyp, ok := expect.(reflect.Type); ok { + return reflect.TypeOf(r).AssignableTo(expectTyp) + } + + // For interface{} type (go/any), catch everything + if expectTyp, ok := expect.(reflect.Type); ok && expectTyp.Kind() == reflect.Interface && expectTyp.NumMethod() == 0 { + return true + } + + return false +} \ No newline at end of file diff --git a/pkg/runtime/evalast.go b/pkg/runtime/evalast.go index 9e8d2367..cb7dda40 100644 --- a/pkg/runtime/evalast.go +++ b/pkg/runtime/evalast.go @@ -689,27 +689,6 @@ func (env *environment) EvalASTNew(n *ast.Node) (interface{}, error) { return reflect.New(classValTyp).Interface(), nil } -var ( - errorType = reflect.TypeOf((*error)(nil)).Elem() -) - -func catchMatches(r, expect any) bool { - if lang.IsNil(expect) { - return false - } - - // if expect is an error type, check if r is an instance of it - if rErr, ok := r.(error); ok { - if expectTyp, ok := expect.(reflect.Type); ok && expectTyp.Implements(errorType) { - expectVal := reflect.New(expectTyp).Elem().Interface().(error) - if errors.Is(rErr, expectVal) { - return true - } - } - } - - return reflect.TypeOf(r).AssignableTo(expect.(reflect.Type)) -} func (env *environment) EvalASTTry(n *ast.Node) (res interface{}, err error) { tryNode := n.Sub.(*ast.TryNode) @@ -735,7 +714,7 @@ func (env *environment) EvalASTTry(n *ast.Node) (res interface{}, err error) { panic(classErr) } - if !catchMatches(r, classVal) { + if !lang.CatchMatches(r, classVal) { continue } From 21b60521d23ad4453e77b027195341dbf24b4bfe Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sat, 16 Aug 2025 17:34:33 -0700 Subject: [PATCH 12/67] codegen for withmeta nodes Signed-off-by: James Hamlin --- pkg/codegen/codegen.go | 74 +++++++++++++-- pkg/codegen/codegen_test.go | 90 +++++++++++-------- .../testdata/codegen/test/with_meta.glj | 4 + .../testdata/codegen/test/with_meta.go | 48 ++++++++++ 4 files changed, 171 insertions(+), 45 deletions(-) create mode 100644 pkg/codegen/testdata/codegen/test/with_meta.glj create mode 100644 pkg/codegen/testdata/codegen/test/with_meta.go diff --git a/pkg/codegen/codegen.go b/pkg/codegen/codegen.go index 9007b3f4..75dec498 100644 --- a/pkg/codegen/codegen.go +++ b/pkg/codegen/codegen.go @@ -148,15 +148,17 @@ func (g *Generator) generateValue(value any) string { case *runtime.Fn: return g.generateFn(v) case *lang.Map: - return g.generateMap(v) + return g.generateMapValue(v) case *lang.Vector: - return g.generateVector(v) + return g.generateVectorValue(v) case lang.Keyword: if ns := v.Namespace(); ns != "" { return fmt.Sprintf("lang.NewKeyword(\"%s/%s\")", ns, v.Name()) } else { return fmt.Sprintf("lang.NewKeyword(\"%s\")", v.Name()) } + case *lang.Symbol: + return fmt.Sprintf("lang.NewSymbol(\"%s\")", v.FullName()) case string: // just return the string as a Go string literal return fmt.Sprintf("%#v", v) @@ -185,8 +187,8 @@ func (g *Generator) generateValue(value any) string { } } -// generateMap generates Go code for a Clojure map -func (g *Generator) generateMap(m *lang.Map) string { +// generateMapValue generates Go code for a Clojure map +func (g *Generator) generateMapValue(m *lang.Map) string { var buf bytes.Buffer buf.WriteString("lang.NewMap(") @@ -209,8 +211,8 @@ func (g *Generator) generateMap(m *lang.Map) string { return buf.String() } -// generateVector generates Go code for a Clojure vector -func (g *Generator) generateVector(v *lang.Vector) string { +// generateVectorValue generates Go code for a Clojure vector +func (g *Generator) generateVectorValue(v *lang.Vector) string { var buf bytes.Buffer buf.WriteString("lang.NewVector(") @@ -340,10 +342,8 @@ func (g *Generator) generateASTNode(node *ast.Node) string { // OpDef // OpSetBang // OpMaybeClass - // OpWithMeta // OpFn // OpMap - // OpVector // OpSet // OpLetFn // OpQuote @@ -361,6 +361,10 @@ func (g *Generator) generateASTNode(node *ast.Node) string { case ast.OpConst: constNode := node.Sub.(*ast.ConstNode) return g.generateValue(constNode.Value) + case ast.OpVector: + return g.generateVector(node) + case ast.OpMap: + return g.generateMap(node) case ast.OpLocal: localNode := node.Sub.(*ast.LocalNode) // Look up the variable in our scope @@ -381,6 +385,8 @@ func (g *Generator) generateASTNode(node *ast.Node) string { return g.generateRecur(node) case ast.OpGoBuiltin: return g.generateGoBuiltin(node) + case ast.OpWithMeta: + return g.generateWithMeta(node) default: fmt.Printf("Generating code for AST node: %T %+v\n", node.Sub, node.Sub) panic(fmt.Sprintf("unsupported AST node type %T", node.Sub)) @@ -739,6 +745,58 @@ func (g *Generator) generateGoBuiltin(node *ast.Node) string { return "lang.Builtins[\"" + sym.Name() + "\"]" } +// generateWithMeta generates code for a WithMeta node +func (g *Generator) generateWithMeta(node *ast.Node) string { + wmNode := node.Sub.(*ast.WithMetaNode) + + expr := wmNode.Expr + meta := wmNode.Meta + + exprVal := g.generateASTNode(expr) + metaVal := g.generateASTNode(meta) + + resultId := g.allocateTempVar() + g.writef("%s, err := lang.WithMeta(%s, %s.(lang.IPersistentMap))\n", resultId, exprVal, metaVal) + g.writef("if err != nil {\n") + g.writef(" panic(err)\n") + g.writef("}\n") + + return resultId +} + +func (g *Generator) generateVector(node *ast.Node) string { + vectorNode := node.Sub.(*ast.VectorNode) + + itemIds := make([]string, len(vectorNode.Items)) + for i, item := range vectorNode.Items { + itemId := g.generateASTNode(item) + itemIds[i] = itemId + } + vecId := g.allocateTempVar() + g.writef("%s := lang.NewVector(%s)\n", vecId, strings.Join(itemIds, ", ")) + + return vecId +} + +func (g *Generator) generateMap(node *ast.Node) string { + mapNode := node.Sub.(*ast.MapNode) + + keyValIds := make([]string, 2*len(mapNode.Keys)) + for i, key := range mapNode.Keys { + keyId := g.generateASTNode(key) + + valNode := mapNode.Vals[i] + valId := g.generateASTNode(valNode) + + keyValIds[2*i] = keyId // key + keyValIds[2*i+1] = valId // value + } + mapId := g.allocateTempVar() + g.writef("%s := lang.NewMap(%s)\n", mapId, strings.Join(keyValIds, ", ")) + + return mapId +} + //////////////////////////////////////////////////////////////////////////////// func (g *Generator) addImport(pkg string) { diff --git a/pkg/codegen/codegen_test.go b/pkg/codegen/codegen_test.go index 720c9dee..b48db5e5 100644 --- a/pkg/codegen/codegen_test.go +++ b/pkg/codegen/codegen_test.go @@ -2,7 +2,6 @@ package codegen_test import ( "bytes" - "flag" "fmt" "io/ioutil" "os" @@ -19,8 +18,6 @@ import ( "github.com/glojurelang/glojure/pkg/runtime" ) -var updateGolden = flag.Bool("update", false, "update golden files") - func TestCodegen(t *testing.T) { var testFiles []string err := filepath.Walk("testdata", func(path string, info os.FileInfo, err error) error { @@ -59,45 +56,64 @@ func TestCodegen(t *testing.T) { ns := lang.FindNamespace(lang.NewSymbol(nsName)) - // Generate code for the namespace - var buf bytes.Buffer - gen := codegen.New(&buf) - if err := gen.Generate(ns); err != nil { - t.Fatalf("failed to generate code: %v", err) - } + generateAndTestNamespace(t, ns, strings.TrimSuffix(testFile, ".glj")+".go") + }) + } - generated := buf.Bytes() + t.Run("glojure.core", func(t *testing.T) { + // Test the core namespace + ns := lang.FindNamespace(lang.NewSymbol("glojure.core")) + if ns == nil { + t.Fatal("glojure.core namespace not found") + } - // Compare with golden file - goldenFile := strings.TrimSuffix(testFile, ".glj") + ".go" - if *updateGolden { - if err := ioutil.WriteFile(goldenFile, generated, 0644); err != nil { - t.Fatal(err) - } - } + goldenFile := "testdata/codegen/test/core.go" + generateAndTestNamespace(t, ns, goldenFile) + }) +} - expected, err := ioutil.ReadFile(goldenFile) - if err != nil { - t.Fatalf("failed to read golden file: %v", err) - } +func generateAndTestNamespace(t *testing.T, ns *lang.Namespace, goldenFile string) { + t.Helper() - if !bytes.Equal(generated, expected) { - t.Errorf("generated code does not match golden file.\nGenerated:\n%s\nExpected:\n%s", - generated, expected) - } + // Generate code for the namespace + var buf bytes.Buffer + gen := codegen.New(&buf) + if err := gen.Generate(ns); err != nil { + t.Fatalf("failed to generate code: %v", err) + } - // run go vet on the output file. print any errors from stderr - cmd := exec.Command("go", "vet", "-all", goldenFile) - var stderr bytes.Buffer - cmd.Stderr = &stderr - if err := cmd.Run(); err != nil { - t.Errorf("go vet failed for %s: %v\nStderr:\n%s", goldenFile, err, stderr.String()) - } + generated := buf.Bytes() - // Check if namespace has -main function with expected output - testMainFunction(t, ns) - }) + updateGolden := os.Getenv("UPDATE_SNAPSHOT") == "1" + if updateGolden { + if err := ioutil.WriteFile(goldenFile, generated, 0644); err != nil { + t.Fatal(err) + } + } + + // Compare with golden file + expected, err := ioutil.ReadFile(goldenFile) + if err != nil { + t.Fatalf("failed to read golden file: %v", err) + } + + if !bytes.Equal(generated, expected) { + t.Errorf("generated code does not match golden file.\nGenerated:\n%s\nExpected:\n%s", + generated, expected) + } + + // run go vet on the output file. print any errors from stderr + cmd := exec.Command("go", "vet", "-all", goldenFile) + var stderr bytes.Buffer + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Errorf("go vet failed for %s: %v\nStderr:\n%s", goldenFile, err, stderr.String()) } + + // Check if namespace has -main function with expected output + // TODO: consider dropping this; we really just want to ensure + // the interpreter, here, behaves the same as the generated code + testMainFunction(t, ns) } // getNamespaceFromFile attempts to extract the namespace declaration from a file @@ -149,7 +165,7 @@ func testMainFunction(t *testing.T, ns *lang.Namespace) { expectedOutput := meta.ValAt(lang.NewKeyword("expected-output")) expectedError := meta.ValAt(lang.NewKeyword("expected-error")) - + if expectedOutput == nil && expectedError == nil { return } @@ -166,7 +182,7 @@ func testMainFunction(t *testing.T, ns *lang.Namespace) { t.Errorf("-main should have panicked with %v, but didn't", expectedError) } }() - + // Run -main - should panic mainVar.Invoke() return diff --git a/pkg/codegen/testdata/codegen/test/with_meta.glj b/pkg/codegen/testdata/codegen/test/with_meta.glj new file mode 100644 index 00000000..80798540 --- /dev/null +++ b/pkg/codegen/testdata/codegen/test/with_meta.glj @@ -0,0 +1,4 @@ +(ns codegen.test.with-meta) + +(defn ^{:expected-output :bar} -main [] + (:foo (meta ^{:foo :bar}[]))) diff --git a/pkg/codegen/testdata/codegen/test/with_meta.go b/pkg/codegen/testdata/codegen/test/with_meta.go new file mode 100644 index 00000000..b0f52e3e --- /dev/null +++ b/pkg/codegen/testdata/codegen/test/with_meta.go @@ -0,0 +1,48 @@ +// Code generated by glojure codegen. DO NOT EDIT. + +package generated + +import ( + "fmt" + "github.com/glojurelang/glojure/pkg/lang" +) + +func init() { + ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.with-meta")) + _ = ns + // -main + { + v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), lang.NewKeyword("bar"), lang.NewKeyword("file"), "codegen/test/with_meta.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(36), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()))).(*lang.Symbol) + v2 := lang.IFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v4 := v3.FindInternedVar(lang.NewSymbol("meta")) + if v4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) + } + v5 := v4.Get() + v6 := lang.NewVector() + v7 := lang.NewMap(lang.NewKeyword("foo"), lang.NewKeyword("bar"), lang.NewKeyword("file"), "codegen/test/with_meta.glj", lang.NewKeyword("line"), int(4), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(4), lang.NewKeyword("end-column"), int(28)) + v8 := lang.NewMap(lang.NewKeyword("file"), "codegen/test/with_meta.glj", lang.NewKeyword("line"), int(4), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(4), lang.NewKeyword("end-column"), int(26)) + v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v10, err := lang.WithMeta(v6, v9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v11 := lang.Apply(v5, []any{v10}) + v12 := lang.Apply(lang.NewKeyword("foo"), []any{v11}) + return v12 + }) + // Note: metadata on functions is not yet supported in generated code + // Original metadata: lang.NewMap(lang.NewKeyword("rettag"), nil) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } +} From 00b95148e01a72d9726346fc251c7efc16026493 Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sat, 16 Aug 2025 17:37:17 -0700 Subject: [PATCH 13/67] Fix CatchMatches Signed-off-by: James Hamlin --- pkg/lang/catch.go | 21 +++------------------ 1 file changed, 3 insertions(+), 18 deletions(-) diff --git a/pkg/lang/catch.go b/pkg/lang/catch.go index 55d311ed..5d13f8e5 100644 --- a/pkg/lang/catch.go +++ b/pkg/lang/catch.go @@ -16,12 +16,7 @@ func CatchMatches(r, expect any) bool { return false } - // Special case: the symbol "any" catches everything (for go/any) - if sym, ok := expect.(*Symbol); ok && sym.Name() == "any" { - return true - } - - // If expect is an error type, check if r is an instance of it + // if expect is an error type, check if r is an instance of it if rErr, ok := r.(error); ok { if expectTyp, ok := expect.(reflect.Type); ok && expectTyp.Implements(errorType) { expectVal := reflect.New(expectTyp).Elem().Interface().(error) @@ -31,15 +26,5 @@ func CatchMatches(r, expect any) bool { } } - // General type check - if expectTyp, ok := expect.(reflect.Type); ok { - return reflect.TypeOf(r).AssignableTo(expectTyp) - } - - // For interface{} type (go/any), catch everything - if expectTyp, ok := expect.(reflect.Type); ok && expectTyp.Kind() == reflect.Interface && expectTyp.NumMethod() == 0 { - return true - } - - return false -} \ No newline at end of file + return reflect.TypeOf(r).AssignableTo(expect.(reflect.Type)) +} From 9e97862176fdca524fb9f00e6c94023099269dc0 Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sat, 16 Aug 2025 18:06:42 -0700 Subject: [PATCH 14/67] Support for maybe-class (package export references) Signed-off-by: James Hamlin --- pkg/codegen/codegen.go | 52 ++++++++++++++++--- pkg/codegen/codegengotest/codegengo_test.go | 2 +- .../testdata/codegen/test/loop_simple.go | 2 +- .../testdata/codegen/test/maybe_class.glj | 4 ++ .../testdata/codegen/test/maybe_class.go | 38 ++++++++++++++ .../testdata/codegen/test/throw_simple.go | 2 +- .../testdata/codegen/test/try_advanced.go | 2 +- .../testdata/codegen/test/try_basic.go | 2 +- .../testdata/codegen/test/with_meta.go | 2 +- 9 files changed, 94 insertions(+), 12 deletions(-) create mode 100644 pkg/codegen/testdata/codegen/test/maybe_class.glj create mode 100644 pkg/codegen/testdata/codegen/test/maybe_class.go diff --git a/pkg/codegen/codegen.go b/pkg/codegen/codegen.go index 75dec498..1edfc090 100644 --- a/pkg/codegen/codegen.go +++ b/pkg/codegen/codegen.go @@ -9,6 +9,7 @@ import ( "github.com/glojurelang/glojure/pkg/ast" "github.com/glojurelang/glojure/pkg/lang" + "github.com/glojurelang/glojure/pkg/pkgmap" "github.com/glojurelang/glojure/pkg/runtime" ) @@ -35,7 +36,7 @@ type Generator struct { varScopes []varScope // stack of variable scopes recurStack []recurContext // stack of recur contexts for nested loops - imports map[string]bool // set of imported packages to avoid duplicates + imports map[string]string // set of imported packages with their aliases } // New creates a new code generator @@ -45,7 +46,7 @@ func New(w io.Writer) *Generator { w: w, varScopes: []varScope{{nextNum: 0, names: make(map[string]string)}}, recurStack: []recurContext{}, - imports: make(map[string]bool), + imports: make(map[string]string), } } @@ -111,6 +112,7 @@ func (g *Generator) generateVar(nsVariableName string, name *lang.Symbol, vr *la g.pushVarScope() defer g.popVarScope() + fmt.Printf("Generating var: %s\n", name.String()) g.writef("// %s\n", name.String()) g.writef("{\n") defer g.writef("}\n") @@ -151,6 +153,9 @@ func (g *Generator) generateValue(value any) string { return g.generateMapValue(v) case *lang.Vector: return g.generateVectorValue(v) + case *lang.SubVector: + // XXX TODO: handle sub-vectors + return fmt.Sprintf("%#v", "subvector not implemented yet") case lang.Keyword: if ns := v.Namespace(); ns != "" { return fmt.Sprintf("lang.NewKeyword(\"%s/%s\")", ns, v.Name()) @@ -341,7 +346,6 @@ func (g *Generator) generateASTNode(node *ast.Node) string { switch node.Op { // OpDef // OpSetBang - // OpMaybeClass // OpFn // OpMap // OpSet @@ -387,6 +391,8 @@ func (g *Generator) generateASTNode(node *ast.Node) string { return g.generateGoBuiltin(node) case ast.OpWithMeta: return g.generateWithMeta(node) + case ast.OpMaybeClass: + return g.generateMaybeClass(node) default: fmt.Printf("Generating code for AST node: %T %+v\n", node.Sub, node.Sub) panic(fmt.Sprintf("unsupported AST node type %T", node.Sub)) @@ -797,10 +803,44 @@ func (g *Generator) generateMap(node *ast.Node) string { return mapId } +func (g *Generator) generateMaybeClass(node *ast.Node) string { + sym := node.Sub.(*ast.MaybeClassNode).Class.(*lang.Symbol) + pkg := sym.FullName() + + // find last dot in the package name + dotIndex := strings.LastIndex(pkg, ".") + if dotIndex == -1 { + panic(fmt.Sprintf("invalid package reference: %s", pkg)) + } + mungedPkgName := pkg[:dotIndex] + exportedName := pkg[dotIndex+1:] + + packageName := pkgmap.UnmungePkg(mungedPkgName) + alias := g.addImportWithAlias(packageName) + + return alias + "." + exportedName +} + //////////////////////////////////////////////////////////////////////////////// func (g *Generator) addImport(pkg string) { - g.imports[pkg] = true + parts := strings.Split(pkg, "/") + alias := parts[len(parts)-1] + g.imports[pkg] = alias +} + +func (g *Generator) addImportWithAlias(pkg string) string { + // Check if the package is already imported + if alias, ok := g.imports[pkg]; ok { + return alias // Return existing alias + } + // Generate a new alias based on the last part of the package name + parts := strings.Split(pkg, "/") + // Use the last part of the package name and current import count + alias := fmt.Sprintf("%s%d", parts[len(parts)-1], len(g.imports)) + g.imports[pkg] = alias // Store the alias for this package + + return alias } func (g *Generator) header() string { @@ -812,8 +852,8 @@ import ( "github.com/glojurelang/glojure/pkg/lang" ` - for pkg := range g.imports { - header += fmt.Sprintf(" \"%s\"\n", pkg) + for pkg, alias := range g.imports { + header += fmt.Sprintf(" %s \"%s\"\n", alias, pkg) } header += ")\n" diff --git a/pkg/codegen/codegengotest/codegengo_test.go b/pkg/codegen/codegengotest/codegengo_test.go index ac6e62f9..39fb6444 100644 --- a/pkg/codegen/codegengotest/codegengo_test.go +++ b/pkg/codegen/codegengotest/codegengo_test.go @@ -73,7 +73,6 @@ func TestGeneratedGo(t *testing.T) { expected := meta.ValAt(lang.NewKeyword("expected-output")) expectedThrow := meta.ValAt(lang.NewKeyword("expected-throw")) - fmt.Println("META:", meta) if lang.IsNil(expected) && lang.IsNil(expectedThrow) { t.Fatalf("no :expected-output or :expected-throw metadata for %s/-main", nsName) } @@ -93,6 +92,7 @@ func TestGeneratedGo(t *testing.T) { // Run -main and check the result result := mainVar.Invoke() if !lang.Equals(result, expected) { + fmt.Printf("Result of %s/-main: %+v (%T)\n", nsName, result, result) t.Errorf("%s/-main returned %v, expected %v", nsName, result, expected) } }) diff --git a/pkg/codegen/testdata/codegen/test/loop_simple.go b/pkg/codegen/testdata/codegen/test/loop_simple.go index f1b603cd..28310c5a 100644 --- a/pkg/codegen/testdata/codegen/test/loop_simple.go +++ b/pkg/codegen/testdata/codegen/test/loop_simple.go @@ -3,7 +3,7 @@ package generated import ( - "fmt" + fmt "fmt" "github.com/glojurelang/glojure/pkg/lang" ) diff --git a/pkg/codegen/testdata/codegen/test/maybe_class.glj b/pkg/codegen/testdata/codegen/test/maybe_class.glj new file mode 100644 index 00000000..9ecd5256 --- /dev/null +++ b/pkg/codegen/testdata/codegen/test/maybe_class.glj @@ -0,0 +1,4 @@ +(ns codegen.test.maybe-class) + +(defn ^{:expected-output ["1" "2" "3"]} -main [] + (vec (strings.Split "1,2,3" ","))) diff --git a/pkg/codegen/testdata/codegen/test/maybe_class.go b/pkg/codegen/testdata/codegen/test/maybe_class.go new file mode 100644 index 00000000..9006a27d --- /dev/null +++ b/pkg/codegen/testdata/codegen/test/maybe_class.go @@ -0,0 +1,38 @@ +// Code generated by glojure codegen. DO NOT EDIT. + +package generated + +import ( + fmt "fmt" + "github.com/glojurelang/glojure/pkg/lang" + strings1 "strings" +) + +func init() { + ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.maybe-class")) + _ = ns + // -main + { + v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), lang.NewVector("1", "2", "3"), lang.NewKeyword("file"), "codegen/test/maybe_class.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(45), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()))).(*lang.Symbol) + v2 := lang.IFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v4 := v3.FindInternedVar(lang.NewSymbol("vec")) + if v4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) + } + v5 := v4.Get() + v6 := lang.Apply(strings1.Split, []any{"1,2,3", ","}) + v7 := lang.Apply(v5, []any{v6}) + return v7 + }) + // Note: metadata on functions is not yet supported in generated code + // Original metadata: lang.NewMap(lang.NewKeyword("rettag"), nil) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } +} diff --git a/pkg/codegen/testdata/codegen/test/throw_simple.go b/pkg/codegen/testdata/codegen/test/throw_simple.go index 6cba058f..899ce2a0 100644 --- a/pkg/codegen/testdata/codegen/test/throw_simple.go +++ b/pkg/codegen/testdata/codegen/test/throw_simple.go @@ -3,7 +3,7 @@ package generated import ( - "fmt" + fmt "fmt" "github.com/glojurelang/glojure/pkg/lang" ) diff --git a/pkg/codegen/testdata/codegen/test/try_advanced.go b/pkg/codegen/testdata/codegen/test/try_advanced.go index f53ce86e..34579d95 100644 --- a/pkg/codegen/testdata/codegen/test/try_advanced.go +++ b/pkg/codegen/testdata/codegen/test/try_advanced.go @@ -3,7 +3,7 @@ package generated import ( - "fmt" + fmt "fmt" "github.com/glojurelang/glojure/pkg/lang" ) diff --git a/pkg/codegen/testdata/codegen/test/try_basic.go b/pkg/codegen/testdata/codegen/test/try_basic.go index b89ca989..d4c50adc 100644 --- a/pkg/codegen/testdata/codegen/test/try_basic.go +++ b/pkg/codegen/testdata/codegen/test/try_basic.go @@ -3,7 +3,7 @@ package generated import ( - "fmt" + fmt "fmt" "github.com/glojurelang/glojure/pkg/lang" ) diff --git a/pkg/codegen/testdata/codegen/test/with_meta.go b/pkg/codegen/testdata/codegen/test/with_meta.go index b0f52e3e..b89d6b4f 100644 --- a/pkg/codegen/testdata/codegen/test/with_meta.go +++ b/pkg/codegen/testdata/codegen/test/with_meta.go @@ -3,7 +3,7 @@ package generated import ( - "fmt" + fmt "fmt" "github.com/glojurelang/glojure/pkg/lang" ) From dc2ddcb9c104ffe95debcfd2c55e6cfc5c71d5a1 Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sat, 16 Aug 2025 18:52:03 -0700 Subject: [PATCH 15/67] Add codegen for quote; fix var meta Signed-off-by: James Hamlin --- pkg/codegen/codegen.go | 19 +++++++----- .../testdata/codegen/test/const_keyword.go | 2 +- .../testdata/codegen/test/const_number.go | 2 +- .../testdata/codegen/test/const_string.go | 2 +- .../testdata/codegen/test/def_simple.go | 2 +- .../testdata/codegen/test/loop_simple.go | 4 +-- .../testdata/codegen/test/maybe_class.go | 2 +- .../testdata/codegen/test/quote_simple.glj | 4 +++ .../testdata/codegen/test/quote_simple.go | 29 +++++++++++++++++++ .../testdata/codegen/test/throw_simple.go | 2 +- .../testdata/codegen/test/try_advanced.go | 8 ++--- .../testdata/codegen/test/try_basic.go | 14 ++++----- .../testdata/codegen/test/with_meta.go | 2 +- 13 files changed, 64 insertions(+), 28 deletions(-) create mode 100644 pkg/codegen/testdata/codegen/test/quote_simple.glj create mode 100644 pkg/codegen/testdata/codegen/test/quote_simple.go diff --git a/pkg/codegen/codegen.go b/pkg/codegen/codegen.go index 1edfc090..f575eb91 100644 --- a/pkg/codegen/codegen.go +++ b/pkg/codegen/codegen.go @@ -59,7 +59,7 @@ func (g *Generator) Generate(ns *lang.Namespace) error { g.writef("func init() {\n") - g.writef(" ns := lang.FindOrCreateNamespace(lang.NewSymbol(\"%s\"))\n", ns.Name().String()) + g.writef(" ns := lang.FindOrCreateNamespace(lang.NewSymbol(%#v))\n", ns.Name().String()) g.writef(" _ = ns\n") // 1. Iterate through ns.Mappings() @@ -117,9 +117,9 @@ func (g *Generator) generateVar(nsVariableName string, name *lang.Symbol, vr *la g.writef("{\n") defer g.writef("}\n") - meta := name.Meta() + meta := vr.Meta() varSym := g.allocateTempVar() - if meta == nil { + if lang.IsNil(meta) { g.writef("%s := lang.NewSymbol(\"%s\")\n", varSym, name.String()) } else { metaVariable := g.generateValue(meta) @@ -147,6 +147,9 @@ func (g *Generator) generateVar(nsVariableName string, name *lang.Symbol, vr *la // returns the variable name or constant expression for the value func (g *Generator) generateValue(value any) string { switch v := value.(type) { + case *lang.Namespace: + // Generate code to find or create the namespace + return fmt.Sprintf("lang.FindOrCreateNamespace(lang.NewSymbol(%#v))", v.Name().String()) case *runtime.Fn: return g.generateFn(v) case *lang.Map: @@ -154,8 +157,7 @@ func (g *Generator) generateValue(value any) string { case *lang.Vector: return g.generateVectorValue(v) case *lang.SubVector: - // XXX TODO: handle sub-vectors - return fmt.Sprintf("%#v", "subvector not implemented yet") + return g.generateVectorValue(v) case lang.Keyword: if ns := v.Namespace(); ns != "" { return fmt.Sprintf("lang.NewKeyword(\"%s/%s\")", ns, v.Name()) @@ -208,7 +210,7 @@ func (g *Generator) generateMapValue(m *lang.Map) string { } // Remove trailing comma and space - if buf.Len() > 0 { + if m.Count() > 0 { buf.Truncate(buf.Len() - 2) } @@ -217,7 +219,7 @@ func (g *Generator) generateMapValue(m *lang.Map) string { } // generateVectorValue generates Go code for a Clojure vector -func (g *Generator) generateVectorValue(v *lang.Vector) string { +func (g *Generator) generateVectorValue(v lang.IPersistentVector) string { var buf bytes.Buffer buf.WriteString("lang.NewVector(") @@ -350,7 +352,6 @@ func (g *Generator) generateASTNode(node *ast.Node) string { // OpMap // OpSet // OpLetFn - // OpQuote // OpGo // OpHostCall // OpHostInterop @@ -393,6 +394,8 @@ func (g *Generator) generateASTNode(node *ast.Node) string { return g.generateWithMeta(node) case ast.OpMaybeClass: return g.generateMaybeClass(node) + case ast.OpQuote: + return g.generateValue(node.Sub.(*ast.QuoteNode).Expr.Sub.(*ast.ConstNode).Value) default: fmt.Printf("Generating code for AST node: %T %+v\n", node.Sub, node.Sub) panic(fmt.Sprintf("unsupported AST node type %T", node.Sub)) diff --git a/pkg/codegen/testdata/codegen/test/const_keyword.go b/pkg/codegen/testdata/codegen/test/const_keyword.go index 0536f462..59146387 100644 --- a/pkg/codegen/testdata/codegen/test/const_keyword.go +++ b/pkg/codegen/testdata/codegen/test/const_keyword.go @@ -11,7 +11,7 @@ func init() { _ = ns // const-keyword { - v0 := lang.NewSymbol("const-keyword").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/const_keyword.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(18))).(*lang.Symbol) + v0 := lang.NewSymbol("const-keyword").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/const_keyword.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.const-keyword")))).(*lang.Symbol) v1 := ns.InternWithValue(v0, lang.NewKeyword("foo"), true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) diff --git a/pkg/codegen/testdata/codegen/test/const_number.go b/pkg/codegen/testdata/codegen/test/const_number.go index 23f4b288..0173fd77 100644 --- a/pkg/codegen/testdata/codegen/test/const_number.go +++ b/pkg/codegen/testdata/codegen/test/const_number.go @@ -11,7 +11,7 @@ func init() { _ = ns // const-number { - v0 := lang.NewSymbol("const-number").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/const_number.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("doc"), "A constant number.")).(*lang.Symbol) + v0 := lang.NewSymbol("const-number").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/const_number.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("doc"), "A constant number.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.const-number")))).(*lang.Symbol) v1 := ns.InternWithValue(v0, int64(42), true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) diff --git a/pkg/codegen/testdata/codegen/test/const_string.go b/pkg/codegen/testdata/codegen/test/const_string.go index 385c564e..3f0bf444 100644 --- a/pkg/codegen/testdata/codegen/test/const_string.go +++ b/pkg/codegen/testdata/codegen/test/const_string.go @@ -11,7 +11,7 @@ func init() { _ = ns // const-string { - v0 := lang.NewSymbol("const-string").WithMeta(lang.NewMap(lang.NewKeyword("hello"), true, lang.NewKeyword("file"), "codegen/test/const_string.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(25))).(*lang.Symbol) + v0 := lang.NewSymbol("const-string").WithMeta(lang.NewMap(lang.NewKeyword("hello"), true, lang.NewKeyword("file"), "codegen/test/const_string.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.const-string")))).(*lang.Symbol) v1 := ns.InternWithValue(v0, "Hello, World!", true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) diff --git a/pkg/codegen/testdata/codegen/test/def_simple.go b/pkg/codegen/testdata/codegen/test/def_simple.go index 4f804cae..4e3cbb6c 100644 --- a/pkg/codegen/testdata/codegen/test/def_simple.go +++ b/pkg/codegen/testdata/codegen/test/def_simple.go @@ -11,7 +11,7 @@ func init() { _ = ns // foo { - v0 := lang.NewSymbol("foo").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/def_simple.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(8))).(*lang.Symbol) + v0 := lang.NewSymbol("foo").WithMeta(lang.NewMap()).(*lang.Symbol) v1 := ns.Intern(v0) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) diff --git a/pkg/codegen/testdata/codegen/test/loop_simple.go b/pkg/codegen/testdata/codegen/test/loop_simple.go index 28310c5a..8dda4b28 100644 --- a/pkg/codegen/testdata/codegen/test/loop_simple.go +++ b/pkg/codegen/testdata/codegen/test/loop_simple.go @@ -12,7 +12,7 @@ func init() { _ = ns // -main { - v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), int64(10), lang.NewKeyword("file"), "codegen/test/loop_simple.glj", lang.NewKeyword("line"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(10), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()))).(*lang.Symbol) + v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), int64(10), lang.NewKeyword("file"), "codegen/test/loop_simple.glj", lang.NewKeyword("line"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(10), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.loop-simple")))).(*lang.Symbol) v2 := lang.IFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -35,7 +35,7 @@ func init() { } // simple-loop { - v0 := lang.NewSymbol("simple-loop").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/loop_simple.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()))).(*lang.Symbol) + v0 := lang.NewSymbol("simple-loop").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/loop_simple.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.loop-simple")))).(*lang.Symbol) v2 := lang.IFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) diff --git a/pkg/codegen/testdata/codegen/test/maybe_class.go b/pkg/codegen/testdata/codegen/test/maybe_class.go index 9006a27d..c9e4bebc 100644 --- a/pkg/codegen/testdata/codegen/test/maybe_class.go +++ b/pkg/codegen/testdata/codegen/test/maybe_class.go @@ -13,7 +13,7 @@ func init() { _ = ns // -main { - v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), lang.NewVector("1", "2", "3"), lang.NewKeyword("file"), "codegen/test/maybe_class.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(45), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()))).(*lang.Symbol) + v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), lang.NewVector("1", "2", "3"), lang.NewKeyword("file"), "codegen/test/maybe_class.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(45), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.maybe-class")))).(*lang.Symbol) v2 := lang.IFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) diff --git a/pkg/codegen/testdata/codegen/test/quote_simple.glj b/pkg/codegen/testdata/codegen/test/quote_simple.glj new file mode 100644 index 00000000..251603bc --- /dev/null +++ b/pkg/codegen/testdata/codegen/test/quote_simple.glj @@ -0,0 +1,4 @@ +(ns codegen.test.quote-simple) + +(defn ^{:expected-output (list 1 2 3)} -main [] + '(1 2 3)) diff --git a/pkg/codegen/testdata/codegen/test/quote_simple.go b/pkg/codegen/testdata/codegen/test/quote_simple.go new file mode 100644 index 00000000..49673aed --- /dev/null +++ b/pkg/codegen/testdata/codegen/test/quote_simple.go @@ -0,0 +1,29 @@ +// Code generated by glojure codegen. DO NOT EDIT. + +package generated + +import ( + fmt "fmt" + "github.com/glojurelang/glojure/pkg/lang" +) + +func init() { + ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.quote-simple")) + _ = ns + // -main + { + v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), lang.NewList(int64(1), int64(2), int64(3)), lang.NewKeyword("file"), "codegen/test/quote_simple.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(44), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.quote-simple")))).(*lang.Symbol) + v2 := lang.IFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + return lang.NewList(int64(1), int64(2), int64(3)) + }) + // Note: metadata on functions is not yet supported in generated code + // Original metadata: lang.NewMap(lang.NewKeyword("rettag"), nil) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } +} diff --git a/pkg/codegen/testdata/codegen/test/throw_simple.go b/pkg/codegen/testdata/codegen/test/throw_simple.go index 899ce2a0..1a1ec289 100644 --- a/pkg/codegen/testdata/codegen/test/throw_simple.go +++ b/pkg/codegen/testdata/codegen/test/throw_simple.go @@ -12,7 +12,7 @@ func init() { _ = ns // -main { - v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-throw"), "uncaught error", lang.NewKeyword("file"), "codegen/test/throw_simple.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(47), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()))).(*lang.Symbol) + v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-throw"), "uncaught error", lang.NewKeyword("file"), "codegen/test/throw_simple.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(47), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.throw-simple")))).(*lang.Symbol) v2 := lang.IFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) diff --git a/pkg/codegen/testdata/codegen/test/try_advanced.go b/pkg/codegen/testdata/codegen/test/try_advanced.go index 34579d95..54b13588 100644 --- a/pkg/codegen/testdata/codegen/test/try_advanced.go +++ b/pkg/codegen/testdata/codegen/test/try_advanced.go @@ -12,7 +12,7 @@ func init() { _ = ns // try-custom-value { - v0 := lang.NewSymbol("try-custom-value").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_advanced.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()))).(*lang.Symbol) + v0 := lang.NewSymbol("try-custom-value").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_advanced.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-advanced")))).(*lang.Symbol) v2 := lang.IFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -43,7 +43,7 @@ func init() { } // -main { - v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), "advanced tests passed", lang.NewKeyword("file"), "codegen/test/try_advanced.glj", lang.NewKeyword("line"), int(22), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(22), lang.NewKeyword("end-column"), int(55), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()))).(*lang.Symbol) + v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), "advanced tests passed", lang.NewKeyword("file"), "codegen/test/try_advanced.glj", lang.NewKeyword("line"), int(22), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(22), lang.NewKeyword("end-column"), int(55), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-advanced")))).(*lang.Symbol) v2 := lang.IFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -122,7 +122,7 @@ func init() { } // finally-with-return { - v0 := lang.NewSymbol("finally-with-return").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_advanced.glj", lang.NewKeyword("line"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(16), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()))).(*lang.Symbol) + v0 := lang.NewSymbol("finally-with-return").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_advanced.glj", lang.NewKeyword("line"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(16), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-advanced")))).(*lang.Symbol) v2 := lang.IFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -144,7 +144,7 @@ func init() { } // catch-binding-scope { - v0 := lang.NewSymbol("catch-binding-scope").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_advanced.glj", lang.NewKeyword("line"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(9), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()))).(*lang.Symbol) + v0 := lang.NewSymbol("catch-binding-scope").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_advanced.glj", lang.NewKeyword("line"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(9), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-advanced")))).(*lang.Symbol) v2 := lang.IFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) diff --git a/pkg/codegen/testdata/codegen/test/try_basic.go b/pkg/codegen/testdata/codegen/test/try_basic.go index d4c50adc..8abb017e 100644 --- a/pkg/codegen/testdata/codegen/test/try_basic.go +++ b/pkg/codegen/testdata/codegen/test/try_basic.go @@ -12,7 +12,7 @@ func init() { _ = ns // try-catch-finally { - v0 := lang.NewSymbol("try-catch-finally").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(26), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(26), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()))).(*lang.Symbol) + v0 := lang.NewSymbol("try-catch-finally").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(26), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(26), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")))).(*lang.Symbol) v2 := lang.IFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -45,7 +45,7 @@ func init() { } // -main { - v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), "all tests passed", lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(43), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(43), lang.NewKeyword("end-column"), int(50), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()))).(*lang.Symbol) + v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), "all tests passed", lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(43), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(43), lang.NewKeyword("end-column"), int(50), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")))).(*lang.Symbol) v2 := lang.IFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -187,7 +187,7 @@ func init() { } // try-with-throw { - v0 := lang.NewSymbol("try-with-throw").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(9), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()))).(*lang.Symbol) + v0 := lang.NewSymbol("try-with-throw").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(9), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")))).(*lang.Symbol) v2 := lang.IFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -219,7 +219,7 @@ func init() { } // try-finally-only { - v0 := lang.NewSymbol("try-finally-only").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(20), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()))).(*lang.Symbol) + v0 := lang.NewSymbol("try-finally-only").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(20), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")))).(*lang.Symbol) v2 := lang.IFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -241,7 +241,7 @@ func init() { } // nested-try { - v0 := lang.NewSymbol("nested-try").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(34), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(34), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()))).(*lang.Symbol) + v0 := lang.NewSymbol("nested-try").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(34), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(34), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")))).(*lang.Symbol) v2 := lang.IFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -287,7 +287,7 @@ func init() { } // basic-try { - v0 := lang.NewSymbol("basic-try").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()))).(*lang.Symbol) + v0 := lang.NewSymbol("basic-try").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")))).(*lang.Symbol) v2 := lang.IFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -318,7 +318,7 @@ func init() { } // try-no-catch { - v0 := lang.NewSymbol("try-no-catch").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(16), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()))).(*lang.Symbol) + v0 := lang.NewSymbol("try-no-catch").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(16), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")))).(*lang.Symbol) v2 := lang.IFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) diff --git a/pkg/codegen/testdata/codegen/test/with_meta.go b/pkg/codegen/testdata/codegen/test/with_meta.go index b89d6b4f..890660ff 100644 --- a/pkg/codegen/testdata/codegen/test/with_meta.go +++ b/pkg/codegen/testdata/codegen/test/with_meta.go @@ -12,7 +12,7 @@ func init() { _ = ns // -main { - v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), lang.NewKeyword("bar"), lang.NewKeyword("file"), "codegen/test/with_meta.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(36), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()))).(*lang.Symbol) + v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), lang.NewKeyword("bar"), lang.NewKeyword("file"), "codegen/test/with_meta.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(36), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.with-meta")))).(*lang.Symbol) v2 := lang.IFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) From 809cd7fce2d01d4aa3154da10543422c7fc6a29d Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sat, 16 Aug 2025 18:54:37 -0700 Subject: [PATCH 16/67] Clean up codegen for vector, map Signed-off-by: James Hamlin --- pkg/codegen/codegen.go | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/pkg/codegen/codegen.go b/pkg/codegen/codegen.go index f575eb91..0c5daa4d 100644 --- a/pkg/codegen/codegen.go +++ b/pkg/codegen/codegen.go @@ -152,11 +152,9 @@ func (g *Generator) generateValue(value any) string { return fmt.Sprintf("lang.FindOrCreateNamespace(lang.NewSymbol(%#v))", v.Name().String()) case *runtime.Fn: return g.generateFn(v) - case *lang.Map: + case lang.IPersistentMap: return g.generateMapValue(v) - case *lang.Vector: - return g.generateVectorValue(v) - case *lang.SubVector: + case lang.IPersistentVector: return g.generateVectorValue(v) case lang.Keyword: if ns := v.Namespace(); ns != "" { @@ -195,7 +193,7 @@ func (g *Generator) generateValue(value any) string { } // generateMapValue generates Go code for a Clojure map -func (g *Generator) generateMapValue(m *lang.Map) string { +func (g *Generator) generateMapValue(m lang.IPersistentMap) string { var buf bytes.Buffer buf.WriteString("lang.NewMap(") From 5776240f08f331b1c13dd01d58c16d07dd6d6ee3 Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sat, 16 Aug 2025 20:17:41 -0700 Subject: [PATCH 17/67] WIP handle function recurs Signed-off-by: James Hamlin --- pkg/codegen/analyze.go | 28 +++ pkg/codegen/codegen.go | 180 +++++++++++------- .../testdata/codegen/test/fn_recur.glj | 13 ++ pkg/codegen/testdata/codegen/test/fn_recur.go | 104 ++++++++++ 4 files changed, 261 insertions(+), 64 deletions(-) create mode 100644 pkg/codegen/analyze.go create mode 100644 pkg/codegen/testdata/codegen/test/fn_recur.glj create mode 100644 pkg/codegen/testdata/codegen/test/fn_recur.go diff --git a/pkg/codegen/analyze.go b/pkg/codegen/analyze.go new file mode 100644 index 00000000..86efde2e --- /dev/null +++ b/pkg/codegen/analyze.go @@ -0,0 +1,28 @@ +package codegen + +import ( + "github.com/glojurelang/glojure/pkg/ast" +) + +// return true to stop visiting +type visitor func(*ast.Node) bool + +func nodeRecurs(n *ast.Node, loopID string) bool { + switch n.Op { + case ast.OpRecur: + recurNode := n.Sub.(*ast.RecurNode) + return recurNode.LoopID.Name() == loopID + case ast.OpDo: + doNode := n.Sub.(*ast.DoNode) + return nodeRecurs(doNode.Ret, loopID) + case ast.OpLet, ast.OpLoop: + letNode := n.Sub.(*ast.LetNode) + return nodeRecurs(letNode.Body, loopID) + case ast.OpIf: + ifNode := n.Sub.(*ast.IfNode) + return nodeRecurs(ifNode.Then, loopID) || nodeRecurs(ifNode.Else, loopID) + // TODO: review all other node types + default: + return false // can't recur in this node type + } +} diff --git a/pkg/codegen/codegen.go b/pkg/codegen/codegen.go index 0c5daa4d..db3cab0a 100644 --- a/pkg/codegen/codegen.go +++ b/pkg/codegen/codegen.go @@ -27,6 +27,7 @@ type varScope struct { type recurContext struct { loopID *lang.Symbol // The loop ID to match recur with its loop bindings []string // Go variable names for loop bindings (in order) + useGoto bool // Whether to use Go's "goto" for recur } // Generator handles the conversion of AST nodes to Go code @@ -156,6 +157,8 @@ func (g *Generator) generateValue(value any) string { return g.generateMapValue(v) case lang.IPersistentVector: return g.generateVectorValue(v) + case lang.IPersistentSet: + return g.generateSetValue(v) case lang.Keyword: if ns := v.Namespace(); ns != "" { return fmt.Sprintf("lang.NewKeyword(\"%s/%s\")", ns, v.Name()) @@ -164,6 +167,8 @@ func (g *Generator) generateValue(value any) string { } case *lang.Symbol: return fmt.Sprintf("lang.NewSymbol(\"%s\")", v.FullName()) + case lang.Char: + return fmt.Sprintf("lang.NewChar(%#v)", rune(v)) case string: // just return the string as a Go string literal return fmt.Sprintf("%#v", v) @@ -235,6 +240,27 @@ func (g *Generator) generateVectorValue(v lang.IPersistentVector) string { return buf.String() } +// generateSetValue generates Go code for a Clojure set +func (g *Generator) generateSetValue(s lang.IPersistentSet) string { + var buf bytes.Buffer + buf.WriteString("lang.CreatePersistentTreeSet(") + + idx := 0 + + // Iterate through the set elements + for seq := s.Seq(); seq != nil; seq = seq.Next() { + if idx > 0 { + buf.WriteString(", ") + } + element := seq.First() + elementVar := g.generateValue(element) + buf.WriteString(elementVar) + } + + buf.WriteString(")") + return buf.String() +} + func (g *Generator) generateFn(fn *runtime.Fn) string { astNode := fn.ASTNode() fnNode := astNode.Sub.(*ast.FnNode) @@ -317,7 +343,7 @@ func (g *Generator) generateFnMethod(methodNode *ast.FnMethodNode, argsVar strin g.pushVarScope() defer g.popVarScope() - // TODO: Handle recur with a label + paramVars := make([]string, methodNode.FixedArity) // Bind parameters for i, param := range methodNode.Params { @@ -327,12 +353,22 @@ func (g *Generator) generateFnMethod(methodNode *ast.FnMethodNode, argsVar strin if i < methodNode.FixedArity { // Regular parameter g.writef("%s := %s[%d]\n", paramVar, argsVar, i) + paramVars[i] = paramVar } else { // Variadic parameter - collect rest args g.writef("%s := lang.NewList(%s[%d:]...)\n", paramVar, argsVar, methodNode.FixedArity) + paramVars = append(paramVars, paramVar) } } + // Add a recur label + if methodNode.LoopID != nil && nodeRecurs(methodNode.Body, methodNode.LoopID.Name()) { + g.writef("recur_%s:\n", methodNode.LoopID.Name()) + + g.pushRecurContext(methodNode.LoopID, paramVars, true) + defer g.popRecurContext() + } + // Generate the body bodyVar := g.generateASTNode(methodNode.Body) if bodyVar != "" { @@ -346,12 +382,9 @@ func (g *Generator) generateASTNode(node *ast.Node) string { switch node.Op { // OpDef // OpSetBang - // OpFn // OpMap - // OpSet // OpLetFn // OpGo - // OpHostCall // OpHostInterop // OpMaybeHostForm // OpCase @@ -368,6 +401,8 @@ func (g *Generator) generateASTNode(node *ast.Node) string { return g.generateVector(node) case ast.OpMap: return g.generateMap(node) + case ast.OpSet: + return g.generateSet(node) case ast.OpLocal: localNode := node.Sub.(*ast.LocalNode) // Look up the variable in our scope @@ -394,6 +429,10 @@ func (g *Generator) generateASTNode(node *ast.Node) string { return g.generateMaybeClass(node) case ast.OpQuote: return g.generateValue(node.Sub.(*ast.QuoteNode).Expr.Sub.(*ast.ConstNode).Value) + case ast.OpFn: + return g.generateFn(runtime.NewFn(node, nil)) + case ast.OpHostCall: + return g.generateHostCall(node) default: fmt.Printf("Generating code for AST node: %T %+v\n", node.Sub, node.Sub) panic(fmt.Sprintf("unsupported AST node type %T", node.Sub)) @@ -495,56 +534,6 @@ func (g *Generator) generateIf(node *ast.Node) string { return resultVar } -// func (env *environment) EvalASTLet(n *ast.Node, isLoop bool) (interface{}, error) { -// letNode := n.Sub.(*ast.LetNode) - -// newEnv := env.PushScope().(*environment) - -// var bindNameVals []interface{} - -// bindings := letNode.Bindings -// for _, binding := range bindings { -// bindingNode := binding.Sub.(*ast.BindingNode) - -// name := bindingNode.Name -// init := bindingNode.Init -// initVal, err := newEnv.EvalAST(init) -// if err != nil { -// return nil, err -// } -// // TODO: this should not mutate in-place! -// newEnv.BindLocal(name, initVal) - -// bindNameVals = append(bindNameVals, name, initVal) -// } - -// Recur: -// for i := 0; i < len(bindNameVals); i += 2 { -// name := bindNameVals[i].(*lang.Symbol) -// val := bindNameVals[i+1] -// newEnv.BindLocal(name, val) -// } - -// rt := lang.NewRecurTarget() -// recurEnv := newEnv.WithRecurTarget(rt).(*environment) -// recurErr := &lang.RecurError{Target: rt} - -// res, err := recurEnv.EvalAST(letNode.Body) -// if isLoop && errors.As(err, &recurErr) { -// newVals := recurErr.Args -// if len(newVals) != len(bindNameVals)/2 { -// return nil, env.errorf(n, "invalid recur, expected %d arguments, got %d", len(bindNameVals)/2, len(newVals)) -// } -// for i := 0; i < len(bindNameVals); i += 2 { -// newValsIndex := i / 2 -// val := newVals[newValsIndex] -// bindNameVals[i+1] = val -// } -// goto Recur -// } -// return res, err -// } - // generateLet generates code for a Let node func (g *Generator) generateLet(node *ast.Node, isLoop bool) string { letNode := node.Sub.(*ast.LetNode) @@ -582,14 +571,8 @@ func (g *Generator) generateLet(node *ast.Node, isLoop bool) string { resultId := g.allocateTempVar() if isLoop { // Push recur context for this loop - g.recurStack = append(g.recurStack, recurContext{ - loopID: letNode.LoopID, - bindings: bindingVars, - }) - defer func() { - // Pop recur context when done - g.recurStack = g.recurStack[:len(g.recurStack)-1] - }() + g.pushRecurContext(letNode.LoopID, bindingVars, false) + defer g.popRecurContext() g.writef("var %s any\n", resultId) g.writef("for {\n") @@ -643,8 +626,13 @@ func (g *Generator) generateRecur(node *ast.Node) string { g.writef("%s = %s\n", bindingVar, tempVars[i]) } - // Continue the loop - g.writef("continue\n") + if ctx.useGoto { + // Use a goto statement to jump back to the loop label + g.writef("goto recur_%s\n", ctx.loopID.Name()) + } else { + // Continue the loop + g.writef("continue\n") + } // Return empty string since recur doesn't produce a value // (control flow never reaches past the continue) @@ -804,6 +792,19 @@ func (g *Generator) generateMap(node *ast.Node) string { return mapId } +func (g *Generator) generateSet(node *ast.Node) string { + setNode := node.Sub.(*ast.SetNode) + + itemIds := make([]string, len(setNode.Items)) + for i, item := range setNode.Items { + itemId := g.generateASTNode(item) + itemIds[i] = itemId + } + setId := g.allocateTempVar() + g.writef("%s := lang.CreatePersistentTreeSet(%s)\n", setId, strings.Join(itemIds, ", ")) + return setId +} + func (g *Generator) generateMaybeClass(node *ast.Node) string { sym := node.Sub.(*ast.MaybeClassNode).Class.(*lang.Symbol) pkg := sym.FullName() @@ -822,6 +823,35 @@ func (g *Generator) generateMaybeClass(node *ast.Node) string { return alias + "." + exportedName } +func (g *Generator) generateHostCall(node *ast.Node) string { + hostCallNode := node.Sub.(*ast.HostCallNode) + + tgt := hostCallNode.Target + method := hostCallNode.Method + args := hostCallNode.Args + + tgtId := g.generateASTNode(tgt) + + argIds := make([]string, len(args)) + for i, arg := range args { + argIds[i] = g.generateASTNode(arg) + } + + g.addImport("reflect") + + methodName := method.Name() + methodId := g.allocateTempVar() + g.writef("%s, _ := lang.FieldOrMethod(%s, %q)\n", methodId, tgtId, methodName) + g.writef("if reflect.TypeOf(%s).Kind() != reflect.Func {\n", methodId) + g.writef(" panic(lang.NewIllegalArgumentError(fmt.Sprintf(\"%s is not a function\")))\n", methodName) + g.writef("}\n") + + resultId := g.allocateTempVar() + g.writef("%s := lang.Apply(%s, []any{%s})\n", resultId, methodId, strings.Join(argIds, ", ")) + + return resultId +} + //////////////////////////////////////////////////////////////////////////////// func (g *Generator) addImport(pkg string) { @@ -938,3 +968,25 @@ func (g *Generator) allocateTempVar() string { func mungeID(name string) string { return strings.ReplaceAll(name, "-", "__") } + +func (g *Generator) pushRecurContext(loopID *lang.Symbol, bindings []string, useGoto bool) { + g.recurStack = append(g.recurStack, recurContext{ + loopID: loopID, + bindings: bindings, + useGoto: useGoto, + }) +} + +func (g *Generator) popRecurContext() { + if len(g.recurStack) == 0 { + panic("no recur context to pop") + } + g.recurStack = g.recurStack[:len(g.recurStack)-1] +} + +func (g *Generator) currentRecurContext() *recurContext { + if len(g.recurStack) == 0 { + return nil // No recur context available + } + return &g.recurStack[len(g.recurStack)-1] +} diff --git a/pkg/codegen/testdata/codegen/test/fn_recur.glj b/pkg/codegen/testdata/codegen/test/fn_recur.glj new file mode 100644 index 00000000..9928c457 --- /dev/null +++ b/pkg/codegen/testdata/codegen/test/fn_recur.glj @@ -0,0 +1,13 @@ +(ns codegen.test.fn-recur) + +(defn fib + "Calculates the nth Fibonacci number using iteration with recur." + [n] + (let [fib-helper (fn fib-helper [a b i] + (if (= i n) + a + (recur b (+ a b) (inc i))))] + (fib-helper 0 1 0))) + +(defn ^{:expected-output 55} -main [] + (fib 10)) diff --git a/pkg/codegen/testdata/codegen/test/fn_recur.go b/pkg/codegen/testdata/codegen/test/fn_recur.go new file mode 100644 index 00000000..ba01a564 --- /dev/null +++ b/pkg/codegen/testdata/codegen/test/fn_recur.go @@ -0,0 +1,104 @@ +// Code generated by glojure codegen. DO NOT EDIT. + +package generated + +import ( + fmt "fmt" + "github.com/glojurelang/glojure/pkg/lang" +) + +func init() { + ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.fn-recur")) + _ = ns + // -main + { + v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), int64(55), lang.NewKeyword("file"), "codegen/test/fn_recur.glj", lang.NewKeyword("line"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(12), lang.NewKeyword("end-column"), int(34), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.fn-recur")))).(*lang.Symbol) + v2 := lang.IFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := lang.FindNamespace(lang.NewSymbol("codegen.test.fn-recur")) + v4 := v3.FindInternedVar(lang.NewSymbol("fib")) + if v4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) + } + v5 := v4.Get() + v6 := lang.Apply(v5, []any{int64(10)}) + return v6 + }) + // Note: metadata on functions is not yet supported in generated code + // Original metadata: lang.NewMap(lang.NewKeyword("rettag"), nil) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // fib + { + v0 := lang.NewSymbol("fib").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/fn_recur.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Calculates the nth Fibonacci number using iteration with recur.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.fn-recur")))).(*lang.Symbol) + v2 := lang.IFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + v5 := lang.IFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v6 := args[0] + v7 := args[1] + v8 := args[2] + recur_loop_1620: + var v9 any + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("=")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v14 := lang.Apply(v12, []any{v8, v13}) + if lang.IsTruthy(v14) { + v9 = v6 + } else { + var v15 any = v7 + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("+")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.Apply(v19, []any{v6, v7}) + var v16 any = v20 + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("inc")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v8}) + var v21 any = v25 + v6 = v15 + v7 = v16 + v8 = v21 + goto recur_loop_1620 + } + return v9 + }) + v6 := lang.NewMap(lang.NewKeyword("file"), "codegen/test/fn_recur.glj", lang.NewKeyword("line"), int(6), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(9), lang.NewKeyword("end-column"), int(50)) + v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v4 any = v7 + _ = v4 + v9 := lang.Apply(v4, []any{int64(0), int64(1), int64(0)}) + return v9 + }) + // Note: metadata on functions is not yet supported in generated code + // Original metadata: lang.NewMap(lang.NewKeyword("rettag"), nil) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } +} From 5119352031fdcbfd74ee001be1454dae413ce902 Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sat, 16 Aug 2025 20:24:31 -0700 Subject: [PATCH 18/67] Handle more node types in recur lookup Signed-off-by: James Hamlin --- pkg/codegen/analyze.go | 32 +++++++++++++++++++++++++++++++- 1 file changed, 31 insertions(+), 1 deletion(-) diff --git a/pkg/codegen/analyze.go b/pkg/codegen/analyze.go index 86efde2e..d5605609 100644 --- a/pkg/codegen/analyze.go +++ b/pkg/codegen/analyze.go @@ -18,11 +18,41 @@ func nodeRecurs(n *ast.Node, loopID string) bool { case ast.OpLet, ast.OpLoop: letNode := n.Sub.(*ast.LetNode) return nodeRecurs(letNode.Body, loopID) + case ast.OpLetFn: + letFnNode := n.Sub.(*ast.LetFnNode) + return nodeRecurs(letFnNode.Body, loopID) case ast.OpIf: ifNode := n.Sub.(*ast.IfNode) return nodeRecurs(ifNode.Then, loopID) || nodeRecurs(ifNode.Else, loopID) - // TODO: review all other node types + case ast.OpTry: + tryNode := n.Sub.(*ast.TryNode) + if nodeRecurs(tryNode.Body, loopID) { + return true + } + for _, catch := range tryNode.Catches { + if nodeRecurs(catch, loopID) { + return true + } + } + case ast.OpCatch: + catchNode := n.Sub.(*ast.CatchNode) + return nodeRecurs(catchNode.Body, loopID) + case ast.OpCase: + caseNode := n.Sub.(*ast.CaseNode) + if nodeRecurs(caseNode.Default, loopID) { + return true + } + for _, branch := range caseNode.Nodes { + if nodeRecurs(branch, loopID) { + return true + } + } + case ast.OpCaseNode: + caseNode := n.Sub.(*ast.CaseNodeNode) + return nodeRecurs(caseNode.Then, loopID) default: return false // can't recur in this node type } + + return false } From 3e0b773148d98328a6a3c1966130a50e730a2694 Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sat, 16 Aug 2025 20:43:07 -0700 Subject: [PATCH 19/67] Fix up fn recur Signed-off-by: James Hamlin --- pkg/codegen/allocator_test.go | 66 ----------- pkg/codegen/codegen.go | 34 +++--- pkg/codegen/example_usage.go | 105 ------------------ pkg/codegen/testdata/codegen/test/fn_recur.go | 46 ++++---- .../testdata/codegen/test/loop_simple.go | 4 +- .../testdata/codegen/test/maybe_class.go | 2 +- .../testdata/codegen/test/quote_simple.go | 2 +- .../testdata/codegen/test/throw_simple.go | 2 +- .../testdata/codegen/test/try_advanced.go | 8 +- .../testdata/codegen/test/try_basic.go | 14 +-- .../testdata/codegen/test/with_meta.go | 2 +- pkg/gen/gljimports/gljimports_darwin_amd64.go | 5 +- pkg/gen/gljimports/gljimports_darwin_arm64.go | 5 +- pkg/gen/gljimports/gljimports_js_wasm.go | 5 +- pkg/gen/gljimports/gljimports_linux_amd64.go | 5 +- pkg/gen/gljimports/gljimports_linux_arm64.go | 5 +- .../gljimports/gljimports_windows_amd64.go | 5 +- pkg/gen/gljimports/gljimports_windows_arm.go | 5 +- pkg/lang/ifn.go | 38 +++++-- pkg/lang/lazilypersistentvector.go | 2 +- pkg/runtime/envinit.go | 2 +- pkg/runtime/environment.go | 2 +- 22 files changed, 121 insertions(+), 243 deletions(-) delete mode 100644 pkg/codegen/allocator_test.go delete mode 100644 pkg/codegen/example_usage.go diff --git a/pkg/codegen/allocator_test.go b/pkg/codegen/allocator_test.go deleted file mode 100644 index 4de3e0cd..00000000 --- a/pkg/codegen/allocator_test.go +++ /dev/null @@ -1,66 +0,0 @@ -package codegen - -import ( - "bytes" - "testing" -) - -func TestVarAllocator(t *testing.T) { - var buf bytes.Buffer - gen := New(&buf) - - // Test initial allocation - if name := gen.allocateVar("x"); name != "v0" { - t.Errorf("expected first var to be v0, got %s", name) - } - if name := gen.allocateVar("y"); name != "v1" { - t.Errorf("expected second var to be v1, got %s", name) - } - - // Test that same name in same scope returns same variable name - if name := gen.allocateVar("x"); name != "v0" { - t.Errorf("expected x to still be v0, got %s", name) - } - - // Test pushing a new scope - gen.pushVarScope() - - // New scope should start from where the previous scope left off - if name := gen.allocateVar("z"); name != "v2" { - t.Errorf("expected first var in new scope to be v2, got %s", name) - } - - // Same name in new scope should get new variable name - if name := gen.allocateVar("x"); name != "v3" { - t.Errorf("expected x in new scope to be v3, got %s", name) - } - - // Test popping scope - gen.popVarScope() - - // Back in original scope, allocating new var should continue from where we left off - if name := gen.allocateVar("w"); name != "v2" { - t.Errorf("expected w to be v2 after popping scope, got %s", name) - } - - // Original x should still be v0 - if name := gen.allocateVar("x"); name != "v0" { - t.Errorf("expected x to be v0 after popping scope, got %s", name) - } -} - -// TestVarName is no longer needed since allocateVar returns the name directly - -func TestPopRootScopePanics(t *testing.T) { - var buf bytes.Buffer - gen := New(&buf) - - // Should panic when trying to pop the root scope - defer func() { - if r := recover(); r == nil { - t.Errorf("expected panic when popping root scope") - } - }() - - gen.popVarScope() -} \ No newline at end of file diff --git a/pkg/codegen/codegen.go b/pkg/codegen/codegen.go index db3cab0a..5ac76127 100644 --- a/pkg/codegen/codegen.go +++ b/pkg/codegen/codegen.go @@ -277,7 +277,7 @@ func (g *Generator) generateFn(fn *runtime.Fn) string { method := fnNode.Methods[0] methodNode := method.Sub.(*ast.FnMethodNode) - g.writef("%s := lang.IFnFunc(func(args ...any) any {\n", fnVar) + g.writef("%s := lang.NewFnFunc(func(args ...any) any {\n", fnVar) g.addImport("fmt") // Import fmt for error formatting // Check arity @@ -291,7 +291,7 @@ func (g *Generator) generateFn(fn *runtime.Fn) string { g.writef("})\n") } else { // Multiple arities or variadic - need to dispatch - g.writef("%s := lang.IFnFunc(func(args ...any) any {\n", fnVar) + g.writef("%s := lang.NewFnFunc(func(args ...any) any {\n", fnVar) g.writef(" switch len(args) {\n") // Generate cases for fixed arity methods @@ -348,7 +348,7 @@ func (g *Generator) generateFnMethod(methodNode *ast.FnMethodNode, argsVar strin // Bind parameters for i, param := range methodNode.Params { paramNode := param.Sub.(*ast.BindingNode) - paramVar := g.allocateVar(paramNode.Name.Name()) + paramVar := g.allocateLocal(paramNode.Name.Name()) if i < methodNode.FixedArity { // Regular parameter @@ -406,7 +406,7 @@ func (g *Generator) generateASTNode(node *ast.Node) string { case ast.OpLocal: localNode := node.Sub.(*ast.LocalNode) // Look up the variable in our scope - return g.allocateVar(localNode.Name.Name()) + return g.getLocal(localNode.Name.Name()) case ast.OpDo: return g.generateDo(node) case ast.OpLet: @@ -555,7 +555,7 @@ func (g *Generator) generateLet(node *ast.Node, isLoop bool) string { init := bindingNode.Init // Allocate a Go variable for the Clojure name - varName := g.allocateVar(name) + varName := g.allocateLocal(name) // Generate initialization code initCode := g.generateASTNode(init) @@ -615,7 +615,7 @@ func (g *Generator) generateRecur(node *ast.Node) string { // This prevents issues with bindings that reference each other tempVars := make([]string, len(recurNode.Exprs)) for i, expr := range recurNode.Exprs { - tempVar := g.allocateVar(fmt.Sprintf("recurTemp%d", i)) + tempVar := g.allocateLocal(fmt.Sprintf("recurTemp%d", i)) tempVars[i] = tempVar exprCode := g.generateASTNode(expr) g.writef("var %s any = %s\n", tempVar, exprCode) @@ -699,7 +699,7 @@ func (g *Generator) generateTry(node *ast.Node) string { // Bind the exception to the catch variable bindingNode := catch.Local.Sub.(*ast.BindingNode) - catchVar := g.allocateVar(bindingNode.Name.Name()) + catchVar := g.allocateLocal(bindingNode.Name.Name()) g.writef("%s := r\n", catchVar) g.writeAssign("_", catchVar) // Mark as used since catch body might not reference it @@ -931,20 +931,15 @@ func (g *Generator) popVarScope() { g.varScopes = g.varScopes[:len(g.varScopes)-1] } -// AllocateVar allocates a Go variable name for the given Clojure name in the current scope +// allocateLocal allocates a Go variable name for the given Clojure name in the current scope // If the name already exists in the current scope, it returns the existing Go variable name -func (g *Generator) allocateVar(name string) string { +func (g *Generator) allocateLocal(name string) string { if len(g.varScopes) == 0 { panic("no variable scope available") } currentScope := &g.varScopes[len(g.varScopes)-1] - // Check if already allocated in current scope - if varName, exists := currentScope.names[name]; exists { - return varName - } - // Allocate new variable name varName := fmt.Sprintf("v%d", currentScope.nextNum) currentScope.names[name] = varName @@ -953,6 +948,17 @@ func (g *Generator) allocateVar(name string) string { return varName } +func (g *Generator) getLocal(name string) string { + for i := len(g.varScopes) - 1; i >= 0; i-- { + currentScope := &g.varScopes[i] + if varName, ok := currentScope.names[name]; ok { + return varName + } + } + + panic(fmt.Sprintf("variable %s not found in any scope", name)) +} + // allocateTempVar allocates a fresh temporary variable without name tracking func (g *Generator) allocateTempVar() string { if len(g.varScopes) == 0 { diff --git a/pkg/codegen/example_usage.go b/pkg/codegen/example_usage.go deleted file mode 100644 index 511a970b..00000000 --- a/pkg/codegen/example_usage.go +++ /dev/null @@ -1,105 +0,0 @@ -package codegen - -// Example showing the intended use of allocateVar -// This file demonstrates how the variable allocator would be used -// when generating Go code from Clojure expressions. - -func exampleUsage(g *Generator) { - // Example 1: Simple let binding - // Clojure: (let [x 10 y 20] (+ x y)) - // Would generate something like: - - g.writef("// (let [x 10 y 20] (+ x y))\n") - g.writef("func() interface{} {\n") - g.pushVarScope() // New scope for let bindings - - // Allocate variables for the let bindings - xVar := g.allocateVar("x") // Returns "v0" - yVar := g.allocateVar("y") // Returns "v1" - - // Generate the bindings - g.writef(" %s := int64(10)\n", xVar) // v0 := int64(10) - g.writef(" %s := int64(20)\n", yVar) // v1 := int64(20) - - // Generate the body - when we see 'x' or 'y', we look them up - xRef := g.allocateVar("x") // Returns "v0" (same as before) - yRef := g.allocateVar("y") // Returns "v1" (same as before) - - g.writef(" return %s + %s\n", xRef, yRef) // return v0 + v1 - g.writef("}()\n") - g.popVarScope() - - // Example 2: Nested let bindings with shadowing - // Clojure: (let [x 10] (let [x 20 y x] (+ x y))) - - g.writef("\n// (let [x 10] (let [x 20 y x] (+ x y)))\n") - g.writef("func() interface{} {\n") - g.pushVarScope() // Outer let - - outerX := g.allocateVar("x") // Returns "v2" (continuing from previous example) - g.writef(" %s := int64(10)\n", outerX) // v2 := int64(10) - - // Inner let - g.writef(" return func() interface{} {\n") - g.pushVarScope() // Inner let scope - - innerX := g.allocateVar("x") // Returns "v3" (new x, shadows outer x) - innerY := g.allocateVar("y") // Returns "v4" - - g.writef(" %s := int64(20)\n", innerX) // v3 := int64(20) - g.writef(" %s := %s\n", innerY, innerX) // v4 := v3 - - // In the body, 'x' refers to inner x - xRef2 := g.allocateVar("x") // Returns "v3" (finds inner x) - yRef2 := g.allocateVar("y") // Returns "v4" - - g.writef(" return %s + %s\n", xRef2, yRef2) // return v3 + v4 - g.writef(" }()\n") - - g.popVarScope() // Pop inner scope - g.writef("}()\n") - g.popVarScope() // Pop outer scope - - // Example 3: Function parameters - // Clojure: (fn [a b] (+ a b)) - - g.writef("\n// (fn [a b] (+ a b))\n") - g.writef("func() interface{} {\n") - g.writef(" return lang.NewFn(func(args ...interface{}) interface{} {\n") - g.pushVarScope() // Function body scope - - // Allocate variables for parameters - aVar := g.allocateVar("a") // Returns "v5" - bVar := g.allocateVar("b") // Returns "v6" - - // Extract parameters from args - g.writef(" %s := args[0]\n", aVar) // v5 := args[0] - g.writef(" %s := args[1]\n", bVar) // v6 := args[1] - - // Generate body - aRef2 := g.allocateVar("a") // Returns "v5" (same) - bRef2 := g.allocateVar("b") // Returns "v6" (same) - - g.writef(" return %s + %s\n", aRef2, bRef2) // return v5 + v6 - g.writef(" })\n") - g.writef("}()\n") - g.popVarScope() -} - -// The point of the name parameter in allocateVar: -// -// 1. **Consistency**: When the same Clojure variable is referenced multiple times -// in the same scope, it should map to the same Go variable. The name ensures -// we can look up existing allocations. -// -// 2. **Shadowing**: Different scopes can have variables with the same name -// (like nested lets with the same binding name). The scope stack ensures -// these get different variable numbers. -// -// 3. **Debugging**: Although we generate names like v0, v1, etc., keeping track -// of the original Clojure name helps with debugging and potentially generating -// comments. -// -// Without the name parameter, we'd have to maintain a separate mapping from -// Clojure symbols to variable numbers outside the generator, which would be -// more complex and error-prone. \ No newline at end of file diff --git a/pkg/codegen/testdata/codegen/test/fn_recur.go b/pkg/codegen/testdata/codegen/test/fn_recur.go index ba01a564..915d1b65 100644 --- a/pkg/codegen/testdata/codegen/test/fn_recur.go +++ b/pkg/codegen/testdata/codegen/test/fn_recur.go @@ -13,7 +13,7 @@ func init() { // -main { v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), int64(55), lang.NewKeyword("file"), "codegen/test/fn_recur.glj", lang.NewKeyword("line"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(12), lang.NewKeyword("end-column"), int(34), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.fn-recur")))).(*lang.Symbol) - v2 := lang.IFnFunc(func(args ...any) any { + v2 := lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -36,12 +36,12 @@ func init() { // fib { v0 := lang.NewSymbol("fib").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/fn_recur.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Calculates the nth Fibonacci number using iteration with recur.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.fn-recur")))).(*lang.Symbol) - v2 := lang.IFnFunc(func(args ...any) any { + v2 := lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] - v5 := lang.IFnFunc(func(args ...any) any { + v5 := lang.NewFnFunc(func(args ...any) any { if len(args) != 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -56,30 +56,30 @@ func init() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } v12 := v11.Get() - v14 := lang.Apply(v12, []any{v8, v13}) - if lang.IsTruthy(v14) { + v13 := lang.Apply(v12, []any{v8, v3}) + if lang.IsTruthy(v13) { v9 = v6 } else { - var v15 any = v7 - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("+")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + var v14 any = v7 + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("+")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } - v19 := v18.Get() - v20 := lang.Apply(v19, []any{v6, v7}) - var v16 any = v20 - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("inc")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + v18 := v17.Get() + v19 := lang.Apply(v18, []any{v6, v7}) + var v15 any = v19 + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("inc")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v8}) - var v21 any = v25 - v6 = v15 - v7 = v16 - v8 = v21 + v23 := v22.Get() + v24 := lang.Apply(v23, []any{v8}) + var v20 any = v24 + v6 = v14 + v7 = v15 + v8 = v20 goto recur_loop_1620 } return v9 diff --git a/pkg/codegen/testdata/codegen/test/loop_simple.go b/pkg/codegen/testdata/codegen/test/loop_simple.go index 8dda4b28..9c7a1313 100644 --- a/pkg/codegen/testdata/codegen/test/loop_simple.go +++ b/pkg/codegen/testdata/codegen/test/loop_simple.go @@ -13,7 +13,7 @@ func init() { // -main { v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), int64(10), lang.NewKeyword("file"), "codegen/test/loop_simple.glj", lang.NewKeyword("line"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(10), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.loop-simple")))).(*lang.Symbol) - v2 := lang.IFnFunc(func(args ...any) any { + v2 := lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -36,7 +36,7 @@ func init() { // simple-loop { v0 := lang.NewSymbol("simple-loop").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/loop_simple.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.loop-simple")))).(*lang.Symbol) - v2 := lang.IFnFunc(func(args ...any) any { + v2 := lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } diff --git a/pkg/codegen/testdata/codegen/test/maybe_class.go b/pkg/codegen/testdata/codegen/test/maybe_class.go index c9e4bebc..f07a357f 100644 --- a/pkg/codegen/testdata/codegen/test/maybe_class.go +++ b/pkg/codegen/testdata/codegen/test/maybe_class.go @@ -14,7 +14,7 @@ func init() { // -main { v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), lang.NewVector("1", "2", "3"), lang.NewKeyword("file"), "codegen/test/maybe_class.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(45), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.maybe-class")))).(*lang.Symbol) - v2 := lang.IFnFunc(func(args ...any) any { + v2 := lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } diff --git a/pkg/codegen/testdata/codegen/test/quote_simple.go b/pkg/codegen/testdata/codegen/test/quote_simple.go index 49673aed..7e1c5bb6 100644 --- a/pkg/codegen/testdata/codegen/test/quote_simple.go +++ b/pkg/codegen/testdata/codegen/test/quote_simple.go @@ -13,7 +13,7 @@ func init() { // -main { v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), lang.NewList(int64(1), int64(2), int64(3)), lang.NewKeyword("file"), "codegen/test/quote_simple.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(44), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.quote-simple")))).(*lang.Symbol) - v2 := lang.IFnFunc(func(args ...any) any { + v2 := lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } diff --git a/pkg/codegen/testdata/codegen/test/throw_simple.go b/pkg/codegen/testdata/codegen/test/throw_simple.go index 1a1ec289..4a137eee 100644 --- a/pkg/codegen/testdata/codegen/test/throw_simple.go +++ b/pkg/codegen/testdata/codegen/test/throw_simple.go @@ -13,7 +13,7 @@ func init() { // -main { v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-throw"), "uncaught error", lang.NewKeyword("file"), "codegen/test/throw_simple.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(47), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.throw-simple")))).(*lang.Symbol) - v2 := lang.IFnFunc(func(args ...any) any { + v2 := lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } diff --git a/pkg/codegen/testdata/codegen/test/try_advanced.go b/pkg/codegen/testdata/codegen/test/try_advanced.go index 54b13588..22945ece 100644 --- a/pkg/codegen/testdata/codegen/test/try_advanced.go +++ b/pkg/codegen/testdata/codegen/test/try_advanced.go @@ -13,7 +13,7 @@ func init() { // try-custom-value { v0 := lang.NewSymbol("try-custom-value").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_advanced.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-advanced")))).(*lang.Symbol) - v2 := lang.IFnFunc(func(args ...any) any { + v2 := lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -44,7 +44,7 @@ func init() { // -main { v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), "advanced tests passed", lang.NewKeyword("file"), "codegen/test/try_advanced.glj", lang.NewKeyword("line"), int(22), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(22), lang.NewKeyword("end-column"), int(55), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-advanced")))).(*lang.Symbol) - v2 := lang.IFnFunc(func(args ...any) any { + v2 := lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -123,7 +123,7 @@ func init() { // finally-with-return { v0 := lang.NewSymbol("finally-with-return").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_advanced.glj", lang.NewKeyword("line"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(16), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-advanced")))).(*lang.Symbol) - v2 := lang.IFnFunc(func(args ...any) any { + v2 := lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -145,7 +145,7 @@ func init() { // catch-binding-scope { v0 := lang.NewSymbol("catch-binding-scope").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_advanced.glj", lang.NewKeyword("line"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(9), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-advanced")))).(*lang.Symbol) - v2 := lang.IFnFunc(func(args ...any) any { + v2 := lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } diff --git a/pkg/codegen/testdata/codegen/test/try_basic.go b/pkg/codegen/testdata/codegen/test/try_basic.go index 8abb017e..abb8b839 100644 --- a/pkg/codegen/testdata/codegen/test/try_basic.go +++ b/pkg/codegen/testdata/codegen/test/try_basic.go @@ -13,7 +13,7 @@ func init() { // try-catch-finally { v0 := lang.NewSymbol("try-catch-finally").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(26), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(26), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")))).(*lang.Symbol) - v2 := lang.IFnFunc(func(args ...any) any { + v2 := lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -46,7 +46,7 @@ func init() { // -main { v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), "all tests passed", lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(43), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(43), lang.NewKeyword("end-column"), int(50), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")))).(*lang.Symbol) - v2 := lang.IFnFunc(func(args ...any) any { + v2 := lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -188,7 +188,7 @@ func init() { // try-with-throw { v0 := lang.NewSymbol("try-with-throw").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(9), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")))).(*lang.Symbol) - v2 := lang.IFnFunc(func(args ...any) any { + v2 := lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -220,7 +220,7 @@ func init() { // try-finally-only { v0 := lang.NewSymbol("try-finally-only").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(20), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")))).(*lang.Symbol) - v2 := lang.IFnFunc(func(args ...any) any { + v2 := lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -242,7 +242,7 @@ func init() { // nested-try { v0 := lang.NewSymbol("nested-try").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(34), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(34), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")))).(*lang.Symbol) - v2 := lang.IFnFunc(func(args ...any) any { + v2 := lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -288,7 +288,7 @@ func init() { // basic-try { v0 := lang.NewSymbol("basic-try").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")))).(*lang.Symbol) - v2 := lang.IFnFunc(func(args ...any) any { + v2 := lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -319,7 +319,7 @@ func init() { // try-no-catch { v0 := lang.NewSymbol("try-no-catch").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(16), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")))).(*lang.Symbol) - v2 := lang.IFnFunc(func(args ...any) any { + v2 := lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } diff --git a/pkg/codegen/testdata/codegen/test/with_meta.go b/pkg/codegen/testdata/codegen/test/with_meta.go index 890660ff..77fbac16 100644 --- a/pkg/codegen/testdata/codegen/test/with_meta.go +++ b/pkg/codegen/testdata/codegen/test/with_meta.go @@ -13,7 +13,7 @@ func init() { // -main { v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), lang.NewKeyword("bar"), lang.NewKeyword("file"), "codegen/test/with_meta.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(36), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.with-meta")))).(*lang.Symbol) - v2 := lang.IFnFunc(func(args ...any) any { + v2 := lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } diff --git a/pkg/gen/gljimports/gljimports_darwin_amd64.go b/pkg/gen/gljimports/gljimports_darwin_amd64.go index 9e7c3739..68cf4e9c 100644 --- a/pkg/gen/gljimports/gljimports_darwin_amd64.go +++ b/pkg/gen/gljimports/gljimports_darwin_amd64.go @@ -3452,6 +3452,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.BuiltinTypes", github_com_glojurelang_glojure_pkg_lang.BuiltinTypes) _register("github.com/glojurelang/glojure/pkg/lang.Builtins", github_com_glojurelang_glojure_pkg_lang.Builtins) _register("github.com/glojurelang/glojure/pkg/lang.ByteCast", github_com_glojurelang_glojure_pkg_lang.ByteCast) + _register("github.com/glojurelang/glojure/pkg/lang.CatchMatches", github_com_glojurelang_glojure_pkg_lang.CatchMatches) _register("github.com/glojurelang/glojure/pkg/lang.Category", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Category)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.CategoryDecimal", github_com_glojurelang_glojure_pkg_lang.CategoryDecimal) _register("github.com/glojurelang/glojure/pkg/lang.CategoryFloating", github_com_glojurelang_glojure_pkg_lang.CategoryFloating) @@ -3506,6 +3507,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.FindOrCreateNamespace", github_com_glojurelang_glojure_pkg_lang.FindOrCreateNamespace) _register("github.com/glojurelang/glojure/pkg/lang.First", github_com_glojurelang_glojure_pkg_lang.First) _register("github.com/glojurelang/glojure/pkg/lang.FloatCast", github_com_glojurelang_glojure_pkg_lang.FloatCast) + _register("github.com/glojurelang/glojure/pkg/lang.FnFunc", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.FnFunc)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.*FnFunc", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.FnFunc)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.Future", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Future)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.GT", github_com_glojurelang_glojure_pkg_lang.GT) _register("github.com/glojurelang/glojure/pkg/lang.Get", github_com_glojurelang_glojure_pkg_lang.Get) @@ -3550,7 +3553,6 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.IDrop", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.IDrop)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.IEditableCollection", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.IEditableCollection)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.IFn", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.IFn)(nil)).Elem()) - _register("github.com/glojurelang/glojure/pkg/lang.IFnFunc", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.IFnFunc)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.IHashEq", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.IHashEq)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.IKVReduce", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.IKVReduce)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.ILookup", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ILookup)(nil)).Elem()) @@ -3779,6 +3781,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewCons", github_com_glojurelang_glojure_pkg_lang.NewCons) _register("github.com/glojurelang/glojure/pkg/lang.NewCycle", github_com_glojurelang_glojure_pkg_lang.NewCycle) _register("github.com/glojurelang/glojure/pkg/lang.NewError", github_com_glojurelang_glojure_pkg_lang.NewError) + _register("github.com/glojurelang/glojure/pkg/lang.NewFnFunc", github_com_glojurelang_glojure_pkg_lang.NewFnFunc) _register("github.com/glojurelang/glojure/pkg/lang.NewGoMapSeq", github_com_glojurelang_glojure_pkg_lang.NewGoMapSeq) _register("github.com/glojurelang/glojure/pkg/lang.NewIllegalArgumentError", github_com_glojurelang_glojure_pkg_lang.NewIllegalArgumentError) _register("github.com/glojurelang/glojure/pkg/lang.NewIllegalStateError", github_com_glojurelang_glojure_pkg_lang.NewIllegalStateError) diff --git a/pkg/gen/gljimports/gljimports_darwin_arm64.go b/pkg/gen/gljimports/gljimports_darwin_arm64.go index f4133476..50e02442 100644 --- a/pkg/gen/gljimports/gljimports_darwin_arm64.go +++ b/pkg/gen/gljimports/gljimports_darwin_arm64.go @@ -3452,6 +3452,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.BuiltinTypes", github_com_glojurelang_glojure_pkg_lang.BuiltinTypes) _register("github.com/glojurelang/glojure/pkg/lang.Builtins", github_com_glojurelang_glojure_pkg_lang.Builtins) _register("github.com/glojurelang/glojure/pkg/lang.ByteCast", github_com_glojurelang_glojure_pkg_lang.ByteCast) + _register("github.com/glojurelang/glojure/pkg/lang.CatchMatches", github_com_glojurelang_glojure_pkg_lang.CatchMatches) _register("github.com/glojurelang/glojure/pkg/lang.Category", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Category)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.CategoryDecimal", github_com_glojurelang_glojure_pkg_lang.CategoryDecimal) _register("github.com/glojurelang/glojure/pkg/lang.CategoryFloating", github_com_glojurelang_glojure_pkg_lang.CategoryFloating) @@ -3506,6 +3507,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.FindOrCreateNamespace", github_com_glojurelang_glojure_pkg_lang.FindOrCreateNamespace) _register("github.com/glojurelang/glojure/pkg/lang.First", github_com_glojurelang_glojure_pkg_lang.First) _register("github.com/glojurelang/glojure/pkg/lang.FloatCast", github_com_glojurelang_glojure_pkg_lang.FloatCast) + _register("github.com/glojurelang/glojure/pkg/lang.FnFunc", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.FnFunc)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.*FnFunc", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.FnFunc)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.Future", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Future)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.GT", github_com_glojurelang_glojure_pkg_lang.GT) _register("github.com/glojurelang/glojure/pkg/lang.Get", github_com_glojurelang_glojure_pkg_lang.Get) @@ -3550,7 +3553,6 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.IDrop", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.IDrop)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.IEditableCollection", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.IEditableCollection)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.IFn", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.IFn)(nil)).Elem()) - _register("github.com/glojurelang/glojure/pkg/lang.IFnFunc", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.IFnFunc)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.IHashEq", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.IHashEq)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.IKVReduce", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.IKVReduce)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.ILookup", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ILookup)(nil)).Elem()) @@ -3779,6 +3781,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewCons", github_com_glojurelang_glojure_pkg_lang.NewCons) _register("github.com/glojurelang/glojure/pkg/lang.NewCycle", github_com_glojurelang_glojure_pkg_lang.NewCycle) _register("github.com/glojurelang/glojure/pkg/lang.NewError", github_com_glojurelang_glojure_pkg_lang.NewError) + _register("github.com/glojurelang/glojure/pkg/lang.NewFnFunc", github_com_glojurelang_glojure_pkg_lang.NewFnFunc) _register("github.com/glojurelang/glojure/pkg/lang.NewGoMapSeq", github_com_glojurelang_glojure_pkg_lang.NewGoMapSeq) _register("github.com/glojurelang/glojure/pkg/lang.NewIllegalArgumentError", github_com_glojurelang_glojure_pkg_lang.NewIllegalArgumentError) _register("github.com/glojurelang/glojure/pkg/lang.NewIllegalStateError", github_com_glojurelang_glojure_pkg_lang.NewIllegalStateError) diff --git a/pkg/gen/gljimports/gljimports_js_wasm.go b/pkg/gen/gljimports/gljimports_js_wasm.go index adfec5ae..cdf7b961 100644 --- a/pkg/gen/gljimports/gljimports_js_wasm.go +++ b/pkg/gen/gljimports/gljimports_js_wasm.go @@ -3452,6 +3452,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.BuiltinTypes", github_com_glojurelang_glojure_pkg_lang.BuiltinTypes) _register("github.com/glojurelang/glojure/pkg/lang.Builtins", github_com_glojurelang_glojure_pkg_lang.Builtins) _register("github.com/glojurelang/glojure/pkg/lang.ByteCast", github_com_glojurelang_glojure_pkg_lang.ByteCast) + _register("github.com/glojurelang/glojure/pkg/lang.CatchMatches", github_com_glojurelang_glojure_pkg_lang.CatchMatches) _register("github.com/glojurelang/glojure/pkg/lang.Category", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Category)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.CategoryDecimal", github_com_glojurelang_glojure_pkg_lang.CategoryDecimal) _register("github.com/glojurelang/glojure/pkg/lang.CategoryFloating", github_com_glojurelang_glojure_pkg_lang.CategoryFloating) @@ -3506,6 +3507,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.FindOrCreateNamespace", github_com_glojurelang_glojure_pkg_lang.FindOrCreateNamespace) _register("github.com/glojurelang/glojure/pkg/lang.First", github_com_glojurelang_glojure_pkg_lang.First) _register("github.com/glojurelang/glojure/pkg/lang.FloatCast", github_com_glojurelang_glojure_pkg_lang.FloatCast) + _register("github.com/glojurelang/glojure/pkg/lang.FnFunc", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.FnFunc)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.*FnFunc", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.FnFunc)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.Future", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Future)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.GT", github_com_glojurelang_glojure_pkg_lang.GT) _register("github.com/glojurelang/glojure/pkg/lang.Get", github_com_glojurelang_glojure_pkg_lang.Get) @@ -3550,7 +3553,6 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.IDrop", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.IDrop)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.IEditableCollection", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.IEditableCollection)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.IFn", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.IFn)(nil)).Elem()) - _register("github.com/glojurelang/glojure/pkg/lang.IFnFunc", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.IFnFunc)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.IHashEq", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.IHashEq)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.IKVReduce", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.IKVReduce)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.ILookup", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ILookup)(nil)).Elem()) @@ -3779,6 +3781,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewCons", github_com_glojurelang_glojure_pkg_lang.NewCons) _register("github.com/glojurelang/glojure/pkg/lang.NewCycle", github_com_glojurelang_glojure_pkg_lang.NewCycle) _register("github.com/glojurelang/glojure/pkg/lang.NewError", github_com_glojurelang_glojure_pkg_lang.NewError) + _register("github.com/glojurelang/glojure/pkg/lang.NewFnFunc", github_com_glojurelang_glojure_pkg_lang.NewFnFunc) _register("github.com/glojurelang/glojure/pkg/lang.NewGoMapSeq", github_com_glojurelang_glojure_pkg_lang.NewGoMapSeq) _register("github.com/glojurelang/glojure/pkg/lang.NewIllegalArgumentError", github_com_glojurelang_glojure_pkg_lang.NewIllegalArgumentError) _register("github.com/glojurelang/glojure/pkg/lang.NewIllegalStateError", github_com_glojurelang_glojure_pkg_lang.NewIllegalStateError) diff --git a/pkg/gen/gljimports/gljimports_linux_amd64.go b/pkg/gen/gljimports/gljimports_linux_amd64.go index 9d7331e7..dc585a1f 100644 --- a/pkg/gen/gljimports/gljimports_linux_amd64.go +++ b/pkg/gen/gljimports/gljimports_linux_amd64.go @@ -3452,6 +3452,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.BuiltinTypes", github_com_glojurelang_glojure_pkg_lang.BuiltinTypes) _register("github.com/glojurelang/glojure/pkg/lang.Builtins", github_com_glojurelang_glojure_pkg_lang.Builtins) _register("github.com/glojurelang/glojure/pkg/lang.ByteCast", github_com_glojurelang_glojure_pkg_lang.ByteCast) + _register("github.com/glojurelang/glojure/pkg/lang.CatchMatches", github_com_glojurelang_glojure_pkg_lang.CatchMatches) _register("github.com/glojurelang/glojure/pkg/lang.Category", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Category)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.CategoryDecimal", github_com_glojurelang_glojure_pkg_lang.CategoryDecimal) _register("github.com/glojurelang/glojure/pkg/lang.CategoryFloating", github_com_glojurelang_glojure_pkg_lang.CategoryFloating) @@ -3506,6 +3507,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.FindOrCreateNamespace", github_com_glojurelang_glojure_pkg_lang.FindOrCreateNamespace) _register("github.com/glojurelang/glojure/pkg/lang.First", github_com_glojurelang_glojure_pkg_lang.First) _register("github.com/glojurelang/glojure/pkg/lang.FloatCast", github_com_glojurelang_glojure_pkg_lang.FloatCast) + _register("github.com/glojurelang/glojure/pkg/lang.FnFunc", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.FnFunc)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.*FnFunc", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.FnFunc)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.Future", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Future)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.GT", github_com_glojurelang_glojure_pkg_lang.GT) _register("github.com/glojurelang/glojure/pkg/lang.Get", github_com_glojurelang_glojure_pkg_lang.Get) @@ -3550,7 +3553,6 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.IDrop", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.IDrop)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.IEditableCollection", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.IEditableCollection)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.IFn", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.IFn)(nil)).Elem()) - _register("github.com/glojurelang/glojure/pkg/lang.IFnFunc", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.IFnFunc)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.IHashEq", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.IHashEq)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.IKVReduce", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.IKVReduce)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.ILookup", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ILookup)(nil)).Elem()) @@ -3779,6 +3781,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewCons", github_com_glojurelang_glojure_pkg_lang.NewCons) _register("github.com/glojurelang/glojure/pkg/lang.NewCycle", github_com_glojurelang_glojure_pkg_lang.NewCycle) _register("github.com/glojurelang/glojure/pkg/lang.NewError", github_com_glojurelang_glojure_pkg_lang.NewError) + _register("github.com/glojurelang/glojure/pkg/lang.NewFnFunc", github_com_glojurelang_glojure_pkg_lang.NewFnFunc) _register("github.com/glojurelang/glojure/pkg/lang.NewGoMapSeq", github_com_glojurelang_glojure_pkg_lang.NewGoMapSeq) _register("github.com/glojurelang/glojure/pkg/lang.NewIllegalArgumentError", github_com_glojurelang_glojure_pkg_lang.NewIllegalArgumentError) _register("github.com/glojurelang/glojure/pkg/lang.NewIllegalStateError", github_com_glojurelang_glojure_pkg_lang.NewIllegalStateError) diff --git a/pkg/gen/gljimports/gljimports_linux_arm64.go b/pkg/gen/gljimports/gljimports_linux_arm64.go index 7e427803..c8fcfb6d 100644 --- a/pkg/gen/gljimports/gljimports_linux_arm64.go +++ b/pkg/gen/gljimports/gljimports_linux_arm64.go @@ -3452,6 +3452,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.BuiltinTypes", github_com_glojurelang_glojure_pkg_lang.BuiltinTypes) _register("github.com/glojurelang/glojure/pkg/lang.Builtins", github_com_glojurelang_glojure_pkg_lang.Builtins) _register("github.com/glojurelang/glojure/pkg/lang.ByteCast", github_com_glojurelang_glojure_pkg_lang.ByteCast) + _register("github.com/glojurelang/glojure/pkg/lang.CatchMatches", github_com_glojurelang_glojure_pkg_lang.CatchMatches) _register("github.com/glojurelang/glojure/pkg/lang.Category", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Category)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.CategoryDecimal", github_com_glojurelang_glojure_pkg_lang.CategoryDecimal) _register("github.com/glojurelang/glojure/pkg/lang.CategoryFloating", github_com_glojurelang_glojure_pkg_lang.CategoryFloating) @@ -3506,6 +3507,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.FindOrCreateNamespace", github_com_glojurelang_glojure_pkg_lang.FindOrCreateNamespace) _register("github.com/glojurelang/glojure/pkg/lang.First", github_com_glojurelang_glojure_pkg_lang.First) _register("github.com/glojurelang/glojure/pkg/lang.FloatCast", github_com_glojurelang_glojure_pkg_lang.FloatCast) + _register("github.com/glojurelang/glojure/pkg/lang.FnFunc", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.FnFunc)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.*FnFunc", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.FnFunc)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.Future", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Future)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.GT", github_com_glojurelang_glojure_pkg_lang.GT) _register("github.com/glojurelang/glojure/pkg/lang.Get", github_com_glojurelang_glojure_pkg_lang.Get) @@ -3550,7 +3553,6 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.IDrop", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.IDrop)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.IEditableCollection", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.IEditableCollection)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.IFn", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.IFn)(nil)).Elem()) - _register("github.com/glojurelang/glojure/pkg/lang.IFnFunc", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.IFnFunc)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.IHashEq", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.IHashEq)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.IKVReduce", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.IKVReduce)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.ILookup", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ILookup)(nil)).Elem()) @@ -3779,6 +3781,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewCons", github_com_glojurelang_glojure_pkg_lang.NewCons) _register("github.com/glojurelang/glojure/pkg/lang.NewCycle", github_com_glojurelang_glojure_pkg_lang.NewCycle) _register("github.com/glojurelang/glojure/pkg/lang.NewError", github_com_glojurelang_glojure_pkg_lang.NewError) + _register("github.com/glojurelang/glojure/pkg/lang.NewFnFunc", github_com_glojurelang_glojure_pkg_lang.NewFnFunc) _register("github.com/glojurelang/glojure/pkg/lang.NewGoMapSeq", github_com_glojurelang_glojure_pkg_lang.NewGoMapSeq) _register("github.com/glojurelang/glojure/pkg/lang.NewIllegalArgumentError", github_com_glojurelang_glojure_pkg_lang.NewIllegalArgumentError) _register("github.com/glojurelang/glojure/pkg/lang.NewIllegalStateError", github_com_glojurelang_glojure_pkg_lang.NewIllegalStateError) diff --git a/pkg/gen/gljimports/gljimports_windows_amd64.go b/pkg/gen/gljimports/gljimports_windows_amd64.go index 6de5d4b4..ac1b3014 100644 --- a/pkg/gen/gljimports/gljimports_windows_amd64.go +++ b/pkg/gen/gljimports/gljimports_windows_amd64.go @@ -3452,6 +3452,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.BuiltinTypes", github_com_glojurelang_glojure_pkg_lang.BuiltinTypes) _register("github.com/glojurelang/glojure/pkg/lang.Builtins", github_com_glojurelang_glojure_pkg_lang.Builtins) _register("github.com/glojurelang/glojure/pkg/lang.ByteCast", github_com_glojurelang_glojure_pkg_lang.ByteCast) + _register("github.com/glojurelang/glojure/pkg/lang.CatchMatches", github_com_glojurelang_glojure_pkg_lang.CatchMatches) _register("github.com/glojurelang/glojure/pkg/lang.Category", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Category)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.CategoryDecimal", github_com_glojurelang_glojure_pkg_lang.CategoryDecimal) _register("github.com/glojurelang/glojure/pkg/lang.CategoryFloating", github_com_glojurelang_glojure_pkg_lang.CategoryFloating) @@ -3506,6 +3507,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.FindOrCreateNamespace", github_com_glojurelang_glojure_pkg_lang.FindOrCreateNamespace) _register("github.com/glojurelang/glojure/pkg/lang.First", github_com_glojurelang_glojure_pkg_lang.First) _register("github.com/glojurelang/glojure/pkg/lang.FloatCast", github_com_glojurelang_glojure_pkg_lang.FloatCast) + _register("github.com/glojurelang/glojure/pkg/lang.FnFunc", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.FnFunc)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.*FnFunc", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.FnFunc)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.Future", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Future)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.GT", github_com_glojurelang_glojure_pkg_lang.GT) _register("github.com/glojurelang/glojure/pkg/lang.Get", github_com_glojurelang_glojure_pkg_lang.Get) @@ -3550,7 +3553,6 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.IDrop", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.IDrop)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.IEditableCollection", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.IEditableCollection)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.IFn", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.IFn)(nil)).Elem()) - _register("github.com/glojurelang/glojure/pkg/lang.IFnFunc", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.IFnFunc)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.IHashEq", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.IHashEq)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.IKVReduce", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.IKVReduce)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.ILookup", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ILookup)(nil)).Elem()) @@ -3779,6 +3781,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewCons", github_com_glojurelang_glojure_pkg_lang.NewCons) _register("github.com/glojurelang/glojure/pkg/lang.NewCycle", github_com_glojurelang_glojure_pkg_lang.NewCycle) _register("github.com/glojurelang/glojure/pkg/lang.NewError", github_com_glojurelang_glojure_pkg_lang.NewError) + _register("github.com/glojurelang/glojure/pkg/lang.NewFnFunc", github_com_glojurelang_glojure_pkg_lang.NewFnFunc) _register("github.com/glojurelang/glojure/pkg/lang.NewGoMapSeq", github_com_glojurelang_glojure_pkg_lang.NewGoMapSeq) _register("github.com/glojurelang/glojure/pkg/lang.NewIllegalArgumentError", github_com_glojurelang_glojure_pkg_lang.NewIllegalArgumentError) _register("github.com/glojurelang/glojure/pkg/lang.NewIllegalStateError", github_com_glojurelang_glojure_pkg_lang.NewIllegalStateError) diff --git a/pkg/gen/gljimports/gljimports_windows_arm.go b/pkg/gen/gljimports/gljimports_windows_arm.go index ff2506e9..cfe54dfe 100644 --- a/pkg/gen/gljimports/gljimports_windows_arm.go +++ b/pkg/gen/gljimports/gljimports_windows_arm.go @@ -3452,6 +3452,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.BuiltinTypes", github_com_glojurelang_glojure_pkg_lang.BuiltinTypes) _register("github.com/glojurelang/glojure/pkg/lang.Builtins", github_com_glojurelang_glojure_pkg_lang.Builtins) _register("github.com/glojurelang/glojure/pkg/lang.ByteCast", github_com_glojurelang_glojure_pkg_lang.ByteCast) + _register("github.com/glojurelang/glojure/pkg/lang.CatchMatches", github_com_glojurelang_glojure_pkg_lang.CatchMatches) _register("github.com/glojurelang/glojure/pkg/lang.Category", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Category)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.CategoryDecimal", github_com_glojurelang_glojure_pkg_lang.CategoryDecimal) _register("github.com/glojurelang/glojure/pkg/lang.CategoryFloating", github_com_glojurelang_glojure_pkg_lang.CategoryFloating) @@ -3506,6 +3507,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.FindOrCreateNamespace", github_com_glojurelang_glojure_pkg_lang.FindOrCreateNamespace) _register("github.com/glojurelang/glojure/pkg/lang.First", github_com_glojurelang_glojure_pkg_lang.First) _register("github.com/glojurelang/glojure/pkg/lang.FloatCast", github_com_glojurelang_glojure_pkg_lang.FloatCast) + _register("github.com/glojurelang/glojure/pkg/lang.FnFunc", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.FnFunc)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.*FnFunc", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.FnFunc)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.Future", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Future)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.GT", github_com_glojurelang_glojure_pkg_lang.GT) _register("github.com/glojurelang/glojure/pkg/lang.Get", github_com_glojurelang_glojure_pkg_lang.Get) @@ -3550,7 +3553,6 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.IDrop", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.IDrop)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.IEditableCollection", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.IEditableCollection)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.IFn", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.IFn)(nil)).Elem()) - _register("github.com/glojurelang/glojure/pkg/lang.IFnFunc", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.IFnFunc)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.IHashEq", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.IHashEq)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.IKVReduce", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.IKVReduce)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.ILookup", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ILookup)(nil)).Elem()) @@ -3779,6 +3781,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewCons", github_com_glojurelang_glojure_pkg_lang.NewCons) _register("github.com/glojurelang/glojure/pkg/lang.NewCycle", github_com_glojurelang_glojure_pkg_lang.NewCycle) _register("github.com/glojurelang/glojure/pkg/lang.NewError", github_com_glojurelang_glojure_pkg_lang.NewError) + _register("github.com/glojurelang/glojure/pkg/lang.NewFnFunc", github_com_glojurelang_glojure_pkg_lang.NewFnFunc) _register("github.com/glojurelang/glojure/pkg/lang.NewGoMapSeq", github_com_glojurelang_glojure_pkg_lang.NewGoMapSeq) _register("github.com/glojurelang/glojure/pkg/lang.NewIllegalArgumentError", github_com_glojurelang_glojure_pkg_lang.NewIllegalArgumentError) _register("github.com/glojurelang/glojure/pkg/lang.NewIllegalStateError", github_com_glojurelang_glojure_pkg_lang.NewIllegalStateError) diff --git a/pkg/lang/ifn.go b/pkg/lang/ifn.go index 1084eda2..6c9cd2a0 100644 --- a/pkg/lang/ifn.go +++ b/pkg/lang/ifn.go @@ -1,17 +1,39 @@ package lang -// IFnFunc is a function that can be applied to a list of -// arguments. -type IFnFunc func(args ...interface{}) interface{} +// FnFunc is a wrapped Go function that implements the IFn interface. +type FnFunc struct { + fn func(args ...any) any + meta IPersistentMap +} var ( - _ IFn = IFnFunc(nil) + _ IFn = FnFunc{} ) -func (f IFnFunc) Invoke(args ...interface{}) interface{} { - return f(args...) +func NewFnFunc(fn func(args ...any) any) FnFunc { + return FnFunc{ + fn: fn, + } +} + +func (f FnFunc) Invoke(args ...any) any { + return f.fn(args...) +} + +func (f FnFunc) ApplyTo(args ISeq) any { + return f.fn(seqToSlice(args)) +} + +func (f FnFunc) Meta() IPersistentMap { + return f.meta } -func (f IFnFunc) ApplyTo(args ISeq) interface{} { - return f(seqToSlice(args)) +func (f FnFunc) WithMeta(meta IPersistentMap) any { + if f.meta == meta { + return f + } + + cpy := f + cpy.meta = meta + return cpy } diff --git a/pkg/lang/lazilypersistentvector.go b/pkg/lang/lazilypersistentvector.go index 44fc5988..dd11801f 100644 --- a/pkg/lang/lazilypersistentvector.go +++ b/pkg/lang/lazilypersistentvector.go @@ -20,7 +20,7 @@ func CreateOwningLazilyPersistentVector(items any) IPersistentVector { func CreateLazilyPersistentVector(obj any) IPersistentVector { switch obj := obj.(type) { case IReduceInit: - return obj.ReduceInit(IFnFunc(func(args ...any) any { + return obj.ReduceInit(NewFnFunc(func(args ...any) any { acc, item := args[0], args[1] return acc.(IPersistentVector).Cons(item) }), emptyVector).(IPersistentVector) diff --git a/pkg/runtime/envinit.go b/pkg/runtime/envinit.go index 94f41fa4..df8ce6ca 100644 --- a/pkg/runtime/envinit.go +++ b/pkg/runtime/envinit.go @@ -70,7 +70,7 @@ func NewEnvironment(opts ...EvalOption) lang.Environment { // bootstrap namespace control { // bootstrap implementation of the ns macro - env.DefVar(lang.NewSymbol("in-ns"), lang.IFnFunc(func(args ...interface{}) interface{} { + env.DefVar(lang.NewSymbol("in-ns"), lang.NewFnFunc(func(args ...interface{}) interface{} { if len(args) != 1 { panic(fmt.Errorf("in-ns: expected namespace name")) } diff --git a/pkg/runtime/environment.go b/pkg/runtime/environment.go index 7d858019..17fca4ee 100644 --- a/pkg/runtime/environment.go +++ b/pkg/runtime/environment.go @@ -72,7 +72,7 @@ func newEnvironment(ctx context.Context, stdout, stderr io.Writer) *environment // bootstrap some vars e.namespaceVar = coreNS.InternWithValue(SymbolNamespace, - lang.IFnFunc(func(args ...interface{}) interface{} { + lang.NewFnFunc(func(args ...interface{}) interface{} { return coreNS }), true) e.namespaceVar.SetMacro() From 2b39e6ac3d6af008e820c2e01211a366daa721d5 Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sat, 16 Aug 2025 20:52:28 -0700 Subject: [PATCH 20/67] Update codegen with FnFunc metadata Signed-off-by: James Hamlin --- pkg/codegen/codegen.go | 6 +++--- pkg/codegen/testdata/codegen/test/fn_recur.go | 6 ++---- .../testdata/codegen/test/loop_simple.go | 6 ++---- .../testdata/codegen/test/maybe_class.go | 3 +-- .../testdata/codegen/test/quote_simple.go | 3 +-- .../testdata/codegen/test/throw_simple.go | 3 +-- .../testdata/codegen/test/try_advanced.go | 12 ++++------- .../testdata/codegen/test/try_basic.go | 21 +++++++------------ .../testdata/codegen/test/with_meta.go | 3 +-- 9 files changed, 22 insertions(+), 41 deletions(-) diff --git a/pkg/codegen/codegen.go b/pkg/codegen/codegen.go index 5ac76127..d0b3b8c4 100644 --- a/pkg/codegen/codegen.go +++ b/pkg/codegen/codegen.go @@ -326,11 +326,11 @@ func (g *Generator) generateFn(fn *runtime.Fn) string { } // Handle metadata if present + // NB: we've got metadata with :rettag on our function, but clojure's functions have no metadata... + // TODO: before merge, investigate this. if meta := fn.Meta(); meta != nil { metaVar := g.generateValue(meta) - // IFnFunc doesn't support metadata directly, so wrap it - g.writef("// Note: metadata on functions is not yet supported in generated code\n") - g.writef("// Original metadata: %s\n", metaVar) + g.writeAssign(fnVar, fmt.Sprintf("%s.WithMeta(%s).(lang.FnFunc)", fnVar, metaVar)) } // Return the function variable diff --git a/pkg/codegen/testdata/codegen/test/fn_recur.go b/pkg/codegen/testdata/codegen/test/fn_recur.go index 915d1b65..384bb901 100644 --- a/pkg/codegen/testdata/codegen/test/fn_recur.go +++ b/pkg/codegen/testdata/codegen/test/fn_recur.go @@ -26,8 +26,7 @@ func init() { v6 := lang.Apply(v5, []any{int64(10)}) return v6 }) - // Note: metadata on functions is not yet supported in generated code - // Original metadata: lang.NewMap(lang.NewKeyword("rettag"), nil) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) @@ -94,8 +93,7 @@ func init() { v9 := lang.Apply(v4, []any{int64(0), int64(1), int64(0)}) return v9 }) - // Note: metadata on functions is not yet supported in generated code - // Original metadata: lang.NewMap(lang.NewKeyword("rettag"), nil) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) diff --git a/pkg/codegen/testdata/codegen/test/loop_simple.go b/pkg/codegen/testdata/codegen/test/loop_simple.go index 9c7a1313..b307d219 100644 --- a/pkg/codegen/testdata/codegen/test/loop_simple.go +++ b/pkg/codegen/testdata/codegen/test/loop_simple.go @@ -26,8 +26,7 @@ func init() { v6 := lang.Apply(v5, nil) return v6 }) - // Note: metadata on functions is not yet supported in generated code - // Original metadata: lang.NewMap(lang.NewKeyword("rettag"), nil) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) @@ -71,8 +70,7 @@ func init() { } return v4 }) - // Note: metadata on functions is not yet supported in generated code - // Original metadata: lang.NewMap(lang.NewKeyword("rettag"), nil) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) diff --git a/pkg/codegen/testdata/codegen/test/maybe_class.go b/pkg/codegen/testdata/codegen/test/maybe_class.go index f07a357f..1da8852f 100644 --- a/pkg/codegen/testdata/codegen/test/maybe_class.go +++ b/pkg/codegen/testdata/codegen/test/maybe_class.go @@ -28,8 +28,7 @@ func init() { v7 := lang.Apply(v5, []any{v6}) return v7 }) - // Note: metadata on functions is not yet supported in generated code - // Original metadata: lang.NewMap(lang.NewKeyword("rettag"), nil) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) diff --git a/pkg/codegen/testdata/codegen/test/quote_simple.go b/pkg/codegen/testdata/codegen/test/quote_simple.go index 7e1c5bb6..e1824a88 100644 --- a/pkg/codegen/testdata/codegen/test/quote_simple.go +++ b/pkg/codegen/testdata/codegen/test/quote_simple.go @@ -19,8 +19,7 @@ func init() { } return lang.NewList(int64(1), int64(2), int64(3)) }) - // Note: metadata on functions is not yet supported in generated code - // Original metadata: lang.NewMap(lang.NewKeyword("rettag"), nil) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) diff --git a/pkg/codegen/testdata/codegen/test/throw_simple.go b/pkg/codegen/testdata/codegen/test/throw_simple.go index 4a137eee..18de2dce 100644 --- a/pkg/codegen/testdata/codegen/test/throw_simple.go +++ b/pkg/codegen/testdata/codegen/test/throw_simple.go @@ -19,8 +19,7 @@ func init() { } panic("uncaught error") }) - // Note: metadata on functions is not yet supported in generated code - // Original metadata: lang.NewMap(lang.NewKeyword("rettag"), nil) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) diff --git a/pkg/codegen/testdata/codegen/test/try_advanced.go b/pkg/codegen/testdata/codegen/test/try_advanced.go index 22945ece..9334408b 100644 --- a/pkg/codegen/testdata/codegen/test/try_advanced.go +++ b/pkg/codegen/testdata/codegen/test/try_advanced.go @@ -34,8 +34,7 @@ func init() { }() return v3 }) - // Note: metadata on functions is not yet supported in generated code - // Original metadata: lang.NewMap(lang.NewKeyword("rettag"), nil) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) @@ -113,8 +112,7 @@ func init() { _ = v21 return "advanced tests passed" }) - // Note: metadata on functions is not yet supported in generated code - // Original metadata: lang.NewMap(lang.NewKeyword("rettag"), nil) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) @@ -135,8 +133,7 @@ func init() { }() return v3 }) - // Note: metadata on functions is not yet supported in generated code - // Original metadata: lang.NewMap(lang.NewKeyword("rettag"), nil) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) @@ -168,8 +165,7 @@ func init() { }() return v5 }) - // Note: metadata on functions is not yet supported in generated code - // Original metadata: lang.NewMap(lang.NewKeyword("rettag"), nil) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) diff --git a/pkg/codegen/testdata/codegen/test/try_basic.go b/pkg/codegen/testdata/codegen/test/try_basic.go index abb8b839..9520c2e2 100644 --- a/pkg/codegen/testdata/codegen/test/try_basic.go +++ b/pkg/codegen/testdata/codegen/test/try_basic.go @@ -36,8 +36,7 @@ func init() { }() return v3 }) - // Note: metadata on functions is not yet supported in generated code - // Original metadata: lang.NewMap(lang.NewKeyword("rettag"), nil) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) @@ -178,8 +177,7 @@ func init() { _ = v48 return "all tests passed" }) - // Note: metadata on functions is not yet supported in generated code - // Original metadata: lang.NewMap(lang.NewKeyword("rettag"), nil) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) @@ -210,8 +208,7 @@ func init() { }() return v3 }) - // Note: metadata on functions is not yet supported in generated code - // Original metadata: lang.NewMap(lang.NewKeyword("rettag"), nil) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) @@ -232,8 +229,7 @@ func init() { }() return v3 }) - // Note: metadata on functions is not yet supported in generated code - // Original metadata: lang.NewMap(lang.NewKeyword("rettag"), nil) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) @@ -278,8 +274,7 @@ func init() { }() return v3 }) - // Note: metadata on functions is not yet supported in generated code - // Original metadata: lang.NewMap(lang.NewKeyword("rettag"), nil) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) @@ -309,8 +304,7 @@ func init() { }() return v3 }) - // Note: metadata on functions is not yet supported in generated code - // Original metadata: lang.NewMap(lang.NewKeyword("rettag"), nil) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) @@ -329,8 +323,7 @@ func init() { }() return v3 }) - // Note: metadata on functions is not yet supported in generated code - // Original metadata: lang.NewMap(lang.NewKeyword("rettag"), nil) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) diff --git a/pkg/codegen/testdata/codegen/test/with_meta.go b/pkg/codegen/testdata/codegen/test/with_meta.go index 77fbac16..a1c1adce 100644 --- a/pkg/codegen/testdata/codegen/test/with_meta.go +++ b/pkg/codegen/testdata/codegen/test/with_meta.go @@ -38,8 +38,7 @@ func init() { v12 := lang.Apply(lang.NewKeyword("foo"), []any{v11}) return v12 }) - // Note: metadata on functions is not yet supported in generated code - // Original metadata: lang.NewMap(lang.NewKeyword("rettag"), nil) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) From 5e35f1ee108bc7b3389a362bc223fa0520ae3b77 Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sat, 16 Aug 2025 21:35:35 -0700 Subject: [PATCH 21/67] Add name binding for named fns Signed-off-by: James Hamlin --- pkg/codegen/codegen.go | 40 +++++++++++- pkg/codegen/testdata/codegen/test/fn_recur.go | 2 +- .../testdata/codegen/test/try_advanced.glj | 13 ++++ .../testdata/codegen/test/try_advanced.go | 64 +++++++++++++++++-- 4 files changed, 110 insertions(+), 9 deletions(-) diff --git a/pkg/codegen/codegen.go b/pkg/codegen/codegen.go index d0b3b8c4..8aa48a2f 100644 --- a/pkg/codegen/codegen.go +++ b/pkg/codegen/codegen.go @@ -266,7 +266,14 @@ func (g *Generator) generateFn(fn *runtime.Fn) string { fnNode := astNode.Sub.(*ast.FnNode) // Allocate a variable for the function - fnVar := g.allocateTempVar() + var fnVar string + if fnNode.Local == nil { + fnVar = g.allocateTempVar() + } else { + // If there's a local binding, use that name + localNode := fnNode.Local.Sub.(*ast.BindingNode) + fnVar = g.allocateLocal(localNode.Name.Name()) + } // Push a new scope for the function definition g.pushVarScope() @@ -385,7 +392,6 @@ func (g *Generator) generateASTNode(node *ast.Node) string { // OpMap // OpLetFn // OpGo - // OpHostInterop // OpMaybeHostForm // OpCase // OpTheVar @@ -433,6 +439,8 @@ func (g *Generator) generateASTNode(node *ast.Node) string { return g.generateFn(runtime.NewFn(node, nil)) case ast.OpHostCall: return g.generateHostCall(node) + case ast.OpHostInterop: + return g.generateHostInterop(node) default: fmt.Printf("Generating code for AST node: %T %+v\n", node.Sub, node.Sub) panic(fmt.Sprintf("unsupported AST node type %T", node.Sub)) @@ -615,7 +623,7 @@ func (g *Generator) generateRecur(node *ast.Node) string { // This prevents issues with bindings that reference each other tempVars := make([]string, len(recurNode.Exprs)) for i, expr := range recurNode.Exprs { - tempVar := g.allocateLocal(fmt.Sprintf("recurTemp%d", i)) + tempVar := g.allocateTempVar() tempVars[i] = tempVar exprCode := g.generateASTNode(expr) g.writef("var %s any = %s\n", tempVar, exprCode) @@ -852,6 +860,32 @@ func (g *Generator) generateHostCall(node *ast.Node) string { return resultId } +func (g *Generator) generateHostInterop(node *ast.Node) string { + hostInteropNode := node.Sub.(*ast.HostInteropNode) + + tgtId := g.generateASTNode(hostInteropNode.Target) + + mOrF := hostInteropNode.MOrF.Name() + mOrFId := g.allocateTempVar() + g.writef("%s, ok := lang.FieldOrMethod(%s, %q)\n", mOrFId, tgtId, mOrF) + g.writef("if !ok {\n") + g.writef(" panic(lang.NewIllegalArgumentError(fmt.Sprintf(\"no such field or method on %%T: %%s\", %s, %q)))\n", tgtId, mOrF) + g.writef("}\n") + + g.addImport("reflect") + + resultId := g.allocateTempVar() + g.writef("var %s any\n", resultId) + g.writef("switch reflect.TypeOf(%s).Kind() {\n", mOrFId) + g.writef("case reflect.Func:\n") + g.writef(" %s = lang.Apply(%s, nil)\n", resultId, mOrFId) + g.writef("default:\n") + g.writef(" %s = %s\n", resultId, mOrFId) + g.writef("}\n") + + return resultId +} + //////////////////////////////////////////////////////////////////////////////// func (g *Generator) addImport(pkg string) { diff --git a/pkg/codegen/testdata/codegen/test/fn_recur.go b/pkg/codegen/testdata/codegen/test/fn_recur.go index 384bb901..50bf6f0b 100644 --- a/pkg/codegen/testdata/codegen/test/fn_recur.go +++ b/pkg/codegen/testdata/codegen/test/fn_recur.go @@ -90,7 +90,7 @@ func init() { } var v4 any = v7 _ = v4 - v9 := lang.Apply(v4, []any{int64(0), int64(1), int64(0)}) + v9 := lang.Apply(v5, []any{int64(0), int64(1), int64(0)}) return v9 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) diff --git a/pkg/codegen/testdata/codegen/test/try_advanced.glj b/pkg/codegen/testdata/codegen/test/try_advanced.glj index 567623c3..39f440ad 100644 --- a/pkg/codegen/testdata/codegen/test/try_advanced.glj +++ b/pkg/codegen/testdata/codegen/test/try_advanced.glj @@ -13,6 +13,14 @@ (catch go/any e e)))) ; should be the exception, not "outer" +(defn catch-binding-scope-2 [] + (let [e "outer"] + (try + (throw "test") + (catch go/any e + e)) + e)) ; should be "outer", not the exception + (defn finally-with-return [] (try 42 @@ -30,6 +38,11 @@ nil (throw "catch-binding-scope failed")) + ;; Test that catch binding does not affect outer scope + (if (= (catch-binding-scope-2) "outer") + nil + (throw "catch-binding-scope-2 failed")) + ;; Test that finally doesn't affect return value (if (= (finally-with-return) 42) nil diff --git a/pkg/codegen/testdata/codegen/test/try_advanced.go b/pkg/codegen/testdata/codegen/test/try_advanced.go index 9334408b..4cf34f3a 100644 --- a/pkg/codegen/testdata/codegen/test/try_advanced.go +++ b/pkg/codegen/testdata/codegen/test/try_advanced.go @@ -40,9 +40,42 @@ func init() { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } + // catch-binding-scope-2 + { + v0 := lang.NewSymbol("catch-binding-scope-2").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_advanced.glj", lang.NewKeyword("line"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(16), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-advanced")))).(*lang.Symbol) + v2 := lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v3 any = "outer" + _ = v3 + var v5 any + func() { + defer func() { + if r := recover(); r != nil { + if lang.CatchMatches(r, lang.Builtins["any"]) { + v6 := r + _ = v6 + v5 = v6 + } else { + panic(r) + } + } + }() + panic("test") + }() + _ = v5 + return v3 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } // -main { - v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), "advanced tests passed", lang.NewKeyword("file"), "codegen/test/try_advanced.glj", lang.NewKeyword("line"), int(22), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(22), lang.NewKeyword("end-column"), int(55), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-advanced")))).(*lang.Symbol) + v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), "advanced tests passed", lang.NewKeyword("file"), "codegen/test/try_advanced.glj", lang.NewKeyword("line"), int(30), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(30), lang.NewKeyword("end-column"), int(55), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-advanced")))).(*lang.Symbol) v2 := lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -97,19 +130,40 @@ func init() { } v24 := v23.Get() v25 := lang.FindNamespace(lang.NewSymbol("codegen.test.try-advanced")) - v26 := v25.FindInternedVar(lang.NewSymbol("finally-with-return")) + v26 := v25.FindInternedVar(lang.NewSymbol("catch-binding-scope-2")) if v26.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } v27 := v26.Get() v28 := lang.Apply(v27, nil) - v29 := lang.Apply(v24, []any{v28, int64(42)}) + v29 := lang.Apply(v24, []any{v28, "outer"}) if lang.IsTruthy(v29) { v21 = nil } else { - panic("finally-with-return failed") + panic("catch-binding-scope-2 failed") } _ = v21 + var v30 any + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("=")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.FindNamespace(lang.NewSymbol("codegen.test.try-advanced")) + v35 := v34.FindInternedVar(lang.NewSymbol("finally-with-return")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.Apply(v36, nil) + v38 := lang.Apply(v33, []any{v37, int64(42)}) + if lang.IsTruthy(v38) { + v30 = nil + } else { + panic("finally-with-return failed") + } + _ = v30 return "advanced tests passed" }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -120,7 +174,7 @@ func init() { } // finally-with-return { - v0 := lang.NewSymbol("finally-with-return").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_advanced.glj", lang.NewKeyword("line"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(16), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-advanced")))).(*lang.Symbol) + v0 := lang.NewSymbol("finally-with-return").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_advanced.glj", lang.NewKeyword("line"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(24), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-advanced")))).(*lang.Symbol) v2 := lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) From d360288304039754d252fde401bfd9bbd479b4b4 Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sun, 17 Aug 2025 17:18:16 -0700 Subject: [PATCH 22/67] Codegen support for 'maybe-host-form' Signed-off-by: James Hamlin --- pkg/codegen/codegen.go | 14 +++++++++++++- pkg/gen/gljimports/gljimports_darwin_amd64.go | 3 +++ pkg/gen/gljimports/gljimports_darwin_arm64.go | 3 +++ pkg/gen/gljimports/gljimports_js_wasm.go | 3 +++ pkg/gen/gljimports/gljimports_linux_amd64.go | 3 +++ pkg/gen/gljimports/gljimports_linux_arm64.go | 3 +++ pkg/gen/gljimports/gljimports_windows_amd64.go | 3 +++ pkg/gen/gljimports/gljimports_windows_arm.go | 3 +++ pkg/lang/error.go | 17 +++++++++++++++++ pkg/stdlib/glojure/core.glj | 4 ++-- scripts/rewrite-core/rewrite.clj | 2 ++ 11 files changed, 55 insertions(+), 3 deletions(-) diff --git a/pkg/codegen/codegen.go b/pkg/codegen/codegen.go index 8aa48a2f..507a658d 100644 --- a/pkg/codegen/codegen.go +++ b/pkg/codegen/codegen.go @@ -392,7 +392,6 @@ func (g *Generator) generateASTNode(node *ast.Node) string { // OpMap // OpLetFn // OpGo - // OpMaybeHostForm // OpCase // OpTheVar // OpNew @@ -441,6 +440,8 @@ func (g *Generator) generateASTNode(node *ast.Node) string { return g.generateHostCall(node) case ast.OpHostInterop: return g.generateHostInterop(node) + case ast.OpMaybeHostForm: + return g.generateMaybeHostForm(node) default: fmt.Printf("Generating code for AST node: %T %+v\n", node.Sub, node.Sub) panic(fmt.Sprintf("unsupported AST node type %T", node.Sub)) @@ -886,6 +887,17 @@ func (g *Generator) generateHostInterop(node *ast.Node) string { return resultId } +// generateMaybeHostForm generates code for a MaybeHostForm node +func (g *Generator) generateMaybeHostForm(node *ast.Node) string { + maybeHostNode := node.Sub.(*ast.MaybeHostFormNode) + field := maybeHostNode.Field + + switch maybeHostNode.Class { + default: + panic(fmt.Sprintf("unsupported host form class: %s.%s", maybeHostNode.Class, field)) + } +} + //////////////////////////////////////////////////////////////////////////////// func (g *Generator) addImport(pkg string) { diff --git a/pkg/gen/gljimports/gljimports_darwin_amd64.go b/pkg/gen/gljimports/gljimports_darwin_amd64.go index 68cf4e9c..758b4554 100644 --- a/pkg/gen/gljimports/gljimports_darwin_amd64.go +++ b/pkg/gen/gljimports/gljimports_darwin_amd64.go @@ -3798,6 +3798,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewMapValSeq", github_com_glojurelang_glojure_pkg_lang.NewMapValSeq) _register("github.com/glojurelang/glojure/pkg/lang.NewMultiFn", github_com_glojurelang_glojure_pkg_lang.NewMultiFn) _register("github.com/glojurelang/glojure/pkg/lang.NewNamespace", github_com_glojurelang_glojure_pkg_lang.NewNamespace) + _register("github.com/glojurelang/glojure/pkg/lang.NewNumberFormatError", github_com_glojurelang_glojure_pkg_lang.NewNumberFormatError) _register("github.com/glojurelang/glojure/pkg/lang.NewPersistentArrayMapAsIfByAssoc", github_com_glojurelang_glojure_pkg_lang.NewPersistentArrayMapAsIfByAssoc) _register("github.com/glojurelang/glojure/pkg/lang.NewPersistentHashMap", github_com_glojurelang_glojure_pkg_lang.NewPersistentHashMap) _register("github.com/glojurelang/glojure/pkg/lang.NewRange", github_com_glojurelang_glojure_pkg_lang.NewRange) @@ -3829,6 +3830,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.*NodeSeq", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NodeSeq)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.Nth", github_com_glojurelang_glojure_pkg_lang.Nth) _register("github.com/glojurelang/glojure/pkg/lang.Nther", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Nther)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.NumberFormatError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberFormatError)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.*NumberFormatError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberFormatError)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.NumberMethods", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberMethods)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*NumberMethods", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberMethods)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.Numbers", github_com_glojurelang_glojure_pkg_lang.Numbers) diff --git a/pkg/gen/gljimports/gljimports_darwin_arm64.go b/pkg/gen/gljimports/gljimports_darwin_arm64.go index 50e02442..5cbddf80 100644 --- a/pkg/gen/gljimports/gljimports_darwin_arm64.go +++ b/pkg/gen/gljimports/gljimports_darwin_arm64.go @@ -3798,6 +3798,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewMapValSeq", github_com_glojurelang_glojure_pkg_lang.NewMapValSeq) _register("github.com/glojurelang/glojure/pkg/lang.NewMultiFn", github_com_glojurelang_glojure_pkg_lang.NewMultiFn) _register("github.com/glojurelang/glojure/pkg/lang.NewNamespace", github_com_glojurelang_glojure_pkg_lang.NewNamespace) + _register("github.com/glojurelang/glojure/pkg/lang.NewNumberFormatError", github_com_glojurelang_glojure_pkg_lang.NewNumberFormatError) _register("github.com/glojurelang/glojure/pkg/lang.NewPersistentArrayMapAsIfByAssoc", github_com_glojurelang_glojure_pkg_lang.NewPersistentArrayMapAsIfByAssoc) _register("github.com/glojurelang/glojure/pkg/lang.NewPersistentHashMap", github_com_glojurelang_glojure_pkg_lang.NewPersistentHashMap) _register("github.com/glojurelang/glojure/pkg/lang.NewRange", github_com_glojurelang_glojure_pkg_lang.NewRange) @@ -3829,6 +3830,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.*NodeSeq", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NodeSeq)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.Nth", github_com_glojurelang_glojure_pkg_lang.Nth) _register("github.com/glojurelang/glojure/pkg/lang.Nther", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Nther)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.NumberFormatError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberFormatError)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.*NumberFormatError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberFormatError)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.NumberMethods", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberMethods)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*NumberMethods", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberMethods)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.Numbers", github_com_glojurelang_glojure_pkg_lang.Numbers) diff --git a/pkg/gen/gljimports/gljimports_js_wasm.go b/pkg/gen/gljimports/gljimports_js_wasm.go index cdf7b961..3452fd04 100644 --- a/pkg/gen/gljimports/gljimports_js_wasm.go +++ b/pkg/gen/gljimports/gljimports_js_wasm.go @@ -3798,6 +3798,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewMapValSeq", github_com_glojurelang_glojure_pkg_lang.NewMapValSeq) _register("github.com/glojurelang/glojure/pkg/lang.NewMultiFn", github_com_glojurelang_glojure_pkg_lang.NewMultiFn) _register("github.com/glojurelang/glojure/pkg/lang.NewNamespace", github_com_glojurelang_glojure_pkg_lang.NewNamespace) + _register("github.com/glojurelang/glojure/pkg/lang.NewNumberFormatError", github_com_glojurelang_glojure_pkg_lang.NewNumberFormatError) _register("github.com/glojurelang/glojure/pkg/lang.NewPersistentArrayMapAsIfByAssoc", github_com_glojurelang_glojure_pkg_lang.NewPersistentArrayMapAsIfByAssoc) _register("github.com/glojurelang/glojure/pkg/lang.NewPersistentHashMap", github_com_glojurelang_glojure_pkg_lang.NewPersistentHashMap) _register("github.com/glojurelang/glojure/pkg/lang.NewRange", github_com_glojurelang_glojure_pkg_lang.NewRange) @@ -3829,6 +3830,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.*NodeSeq", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NodeSeq)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.Nth", github_com_glojurelang_glojure_pkg_lang.Nth) _register("github.com/glojurelang/glojure/pkg/lang.Nther", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Nther)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.NumberFormatError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberFormatError)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.*NumberFormatError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberFormatError)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.NumberMethods", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberMethods)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*NumberMethods", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberMethods)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.Numbers", github_com_glojurelang_glojure_pkg_lang.Numbers) diff --git a/pkg/gen/gljimports/gljimports_linux_amd64.go b/pkg/gen/gljimports/gljimports_linux_amd64.go index dc585a1f..72d1f6f3 100644 --- a/pkg/gen/gljimports/gljimports_linux_amd64.go +++ b/pkg/gen/gljimports/gljimports_linux_amd64.go @@ -3798,6 +3798,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewMapValSeq", github_com_glojurelang_glojure_pkg_lang.NewMapValSeq) _register("github.com/glojurelang/glojure/pkg/lang.NewMultiFn", github_com_glojurelang_glojure_pkg_lang.NewMultiFn) _register("github.com/glojurelang/glojure/pkg/lang.NewNamespace", github_com_glojurelang_glojure_pkg_lang.NewNamespace) + _register("github.com/glojurelang/glojure/pkg/lang.NewNumberFormatError", github_com_glojurelang_glojure_pkg_lang.NewNumberFormatError) _register("github.com/glojurelang/glojure/pkg/lang.NewPersistentArrayMapAsIfByAssoc", github_com_glojurelang_glojure_pkg_lang.NewPersistentArrayMapAsIfByAssoc) _register("github.com/glojurelang/glojure/pkg/lang.NewPersistentHashMap", github_com_glojurelang_glojure_pkg_lang.NewPersistentHashMap) _register("github.com/glojurelang/glojure/pkg/lang.NewRange", github_com_glojurelang_glojure_pkg_lang.NewRange) @@ -3829,6 +3830,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.*NodeSeq", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NodeSeq)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.Nth", github_com_glojurelang_glojure_pkg_lang.Nth) _register("github.com/glojurelang/glojure/pkg/lang.Nther", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Nther)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.NumberFormatError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberFormatError)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.*NumberFormatError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberFormatError)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.NumberMethods", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberMethods)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*NumberMethods", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberMethods)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.Numbers", github_com_glojurelang_glojure_pkg_lang.Numbers) diff --git a/pkg/gen/gljimports/gljimports_linux_arm64.go b/pkg/gen/gljimports/gljimports_linux_arm64.go index c8fcfb6d..80c1ee3d 100644 --- a/pkg/gen/gljimports/gljimports_linux_arm64.go +++ b/pkg/gen/gljimports/gljimports_linux_arm64.go @@ -3798,6 +3798,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewMapValSeq", github_com_glojurelang_glojure_pkg_lang.NewMapValSeq) _register("github.com/glojurelang/glojure/pkg/lang.NewMultiFn", github_com_glojurelang_glojure_pkg_lang.NewMultiFn) _register("github.com/glojurelang/glojure/pkg/lang.NewNamespace", github_com_glojurelang_glojure_pkg_lang.NewNamespace) + _register("github.com/glojurelang/glojure/pkg/lang.NewNumberFormatError", github_com_glojurelang_glojure_pkg_lang.NewNumberFormatError) _register("github.com/glojurelang/glojure/pkg/lang.NewPersistentArrayMapAsIfByAssoc", github_com_glojurelang_glojure_pkg_lang.NewPersistentArrayMapAsIfByAssoc) _register("github.com/glojurelang/glojure/pkg/lang.NewPersistentHashMap", github_com_glojurelang_glojure_pkg_lang.NewPersistentHashMap) _register("github.com/glojurelang/glojure/pkg/lang.NewRange", github_com_glojurelang_glojure_pkg_lang.NewRange) @@ -3829,6 +3830,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.*NodeSeq", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NodeSeq)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.Nth", github_com_glojurelang_glojure_pkg_lang.Nth) _register("github.com/glojurelang/glojure/pkg/lang.Nther", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Nther)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.NumberFormatError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberFormatError)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.*NumberFormatError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberFormatError)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.NumberMethods", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberMethods)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*NumberMethods", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberMethods)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.Numbers", github_com_glojurelang_glojure_pkg_lang.Numbers) diff --git a/pkg/gen/gljimports/gljimports_windows_amd64.go b/pkg/gen/gljimports/gljimports_windows_amd64.go index ac1b3014..a01ba1b1 100644 --- a/pkg/gen/gljimports/gljimports_windows_amd64.go +++ b/pkg/gen/gljimports/gljimports_windows_amd64.go @@ -3798,6 +3798,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewMapValSeq", github_com_glojurelang_glojure_pkg_lang.NewMapValSeq) _register("github.com/glojurelang/glojure/pkg/lang.NewMultiFn", github_com_glojurelang_glojure_pkg_lang.NewMultiFn) _register("github.com/glojurelang/glojure/pkg/lang.NewNamespace", github_com_glojurelang_glojure_pkg_lang.NewNamespace) + _register("github.com/glojurelang/glojure/pkg/lang.NewNumberFormatError", github_com_glojurelang_glojure_pkg_lang.NewNumberFormatError) _register("github.com/glojurelang/glojure/pkg/lang.NewPersistentArrayMapAsIfByAssoc", github_com_glojurelang_glojure_pkg_lang.NewPersistentArrayMapAsIfByAssoc) _register("github.com/glojurelang/glojure/pkg/lang.NewPersistentHashMap", github_com_glojurelang_glojure_pkg_lang.NewPersistentHashMap) _register("github.com/glojurelang/glojure/pkg/lang.NewRange", github_com_glojurelang_glojure_pkg_lang.NewRange) @@ -3829,6 +3830,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.*NodeSeq", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NodeSeq)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.Nth", github_com_glojurelang_glojure_pkg_lang.Nth) _register("github.com/glojurelang/glojure/pkg/lang.Nther", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Nther)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.NumberFormatError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberFormatError)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.*NumberFormatError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberFormatError)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.NumberMethods", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberMethods)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*NumberMethods", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberMethods)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.Numbers", github_com_glojurelang_glojure_pkg_lang.Numbers) diff --git a/pkg/gen/gljimports/gljimports_windows_arm.go b/pkg/gen/gljimports/gljimports_windows_arm.go index cfe54dfe..ee309f4a 100644 --- a/pkg/gen/gljimports/gljimports_windows_arm.go +++ b/pkg/gen/gljimports/gljimports_windows_arm.go @@ -3798,6 +3798,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewMapValSeq", github_com_glojurelang_glojure_pkg_lang.NewMapValSeq) _register("github.com/glojurelang/glojure/pkg/lang.NewMultiFn", github_com_glojurelang_glojure_pkg_lang.NewMultiFn) _register("github.com/glojurelang/glojure/pkg/lang.NewNamespace", github_com_glojurelang_glojure_pkg_lang.NewNamespace) + _register("github.com/glojurelang/glojure/pkg/lang.NewNumberFormatError", github_com_glojurelang_glojure_pkg_lang.NewNumberFormatError) _register("github.com/glojurelang/glojure/pkg/lang.NewPersistentArrayMapAsIfByAssoc", github_com_glojurelang_glojure_pkg_lang.NewPersistentArrayMapAsIfByAssoc) _register("github.com/glojurelang/glojure/pkg/lang.NewPersistentHashMap", github_com_glojurelang_glojure_pkg_lang.NewPersistentHashMap) _register("github.com/glojurelang/glojure/pkg/lang.NewRange", github_com_glojurelang_glojure_pkg_lang.NewRange) @@ -3829,6 +3830,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.*NodeSeq", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NodeSeq)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.Nth", github_com_glojurelang_glojure_pkg_lang.Nth) _register("github.com/glojurelang/glojure/pkg/lang.Nther", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Nther)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.NumberFormatError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberFormatError)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.*NumberFormatError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberFormatError)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.NumberMethods", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberMethods)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*NumberMethods", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberMethods)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.Numbers", github_com_glojurelang_glojure_pkg_lang.Numbers) diff --git a/pkg/lang/error.go b/pkg/lang/error.go index 62d86aa9..9e30f621 100644 --- a/pkg/lang/error.go +++ b/pkg/lang/error.go @@ -25,6 +25,10 @@ type ( msg string } + NumberFormatError struct { + msg string + } + // Stacker is an interface for retrieving stack traces. Stacker interface { Stack() []StackFrame @@ -98,6 +102,19 @@ func (e *ArithmeticError) Is(other error) bool { return ok } +func NewNumberFormatError(msg string) error { + return &NumberFormatError{msg: msg} +} + +func (e *NumberFormatError) Error() string { + return e.msg +} + +func (e *NumberFormatError) Is(other error) bool { + _, ok := other.(*NumberFormatError) + return ok +} + func NewIllegalStateError(msg string) error { return &IllegalStateError{msg: msg} } diff --git a/pkg/stdlib/glojure/core.glj b/pkg/stdlib/glojure/core.glj index 0f362c13..cd5ce919 100644 --- a/pkg/stdlib/glojure/core.glj +++ b/pkg/stdlib/glojure/core.glj @@ -8003,7 +8003,7 @@ fails, attempts to require sym's namespace and retries." (if (string? s) (try (Long/valueOf s) - (catch NumberFormatException _ nil)) + (catch github.com$glojurelang$glojure$pkg$lang.NumberFormatError _ nil)) (throw (github.com$glojurelang$glojure$pkg$lang.NewIllegalArgumentError (parsing-err s))))) (defn parse-double @@ -8016,7 +8016,7 @@ fails, attempts to require sym's namespace and retries." (if (string? s) (try (Double/valueOf s) - (catch NumberFormatException _ nil)) + (catch github.com$glojurelang$glojure$pkg$lang.NumberFormatError _ nil)) (throw (github.com$glojurelang$glojure$pkg$lang.NewIllegalArgumentError (parsing-err s))))) (defn parse-uuid diff --git a/scripts/rewrite-core/rewrite.clj b/scripts/rewrite-core/rewrite.clj index fd6a3477..bb8efdbb 100644 --- a/scripts/rewrite-core/rewrite.clj +++ b/scripts/rewrite-core/rewrite.clj @@ -285,6 +285,8 @@ (fn visit [zloc] (z/replace zloc 'go/any))] + (sexpr-replace 'NumberFormatException 'github.com$glojurelang$glojure$pkg$lang.NumberFormatError) + ;; ===== Metadata Operations ===== ;; replace .withMeta [(fn select [zloc] (and (z/list? zloc) (= '.withMeta (first (z/sexpr zloc))))) From 0cd1aafea7649d0eb973712fcc61c00274a353cc Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sun, 17 Aug 2025 18:01:18 -0700 Subject: [PATCH 23/67] Add support for the-var and tests for parse-double/long Signed-off-by: James Hamlin --- pkg/codegen/codegen.go | 19 +++-- pkg/codegen/testdata/codegen/test/the_var.glj | 6 ++ pkg/codegen/testdata/codegen/test/the_var.go | 49 +++++++++++ pkg/gen/gljimports/gljimports_darwin_amd64.go | 3 - pkg/gen/gljimports/gljimports_darwin_arm64.go | 3 - pkg/gen/gljimports/gljimports_js_wasm.go | 3 - pkg/gen/gljimports/gljimports_linux_amd64.go | 3 - pkg/gen/gljimports/gljimports_linux_arm64.go | 3 - .../gljimports/gljimports_windows_amd64.go | 3 - pkg/gen/gljimports/gljimports_windows_arm.go | 3 - pkg/lang/error.go | 17 ---- pkg/stdlib/glojure/core.glj | 8 +- scripts/rewrite-core/rewrite.clj | 26 +++++- test/glojure/test_glojure/numbers.glj | 81 +++++++++++++++++++ 14 files changed, 177 insertions(+), 50 deletions(-) create mode 100644 pkg/codegen/testdata/codegen/test/the_var.glj create mode 100644 pkg/codegen/testdata/codegen/test/the_var.go diff --git a/pkg/codegen/codegen.go b/pkg/codegen/codegen.go index 507a658d..f31f29fa 100644 --- a/pkg/codegen/codegen.go +++ b/pkg/codegen/codegen.go @@ -393,7 +393,6 @@ func (g *Generator) generateASTNode(node *ast.Node) string { // OpLetFn // OpGo // OpCase - // OpTheVar // OpNew case ast.OpTry: return g.generateTry(node) @@ -442,6 +441,8 @@ func (g *Generator) generateASTNode(node *ast.Node) string { return g.generateHostInterop(node) case ast.OpMaybeHostForm: return g.generateMaybeHostForm(node) + case ast.OpTheVar: + return g.generateTheVar(node) default: fmt.Printf("Generating code for AST node: %T %+v\n", node.Sub, node.Sub) panic(fmt.Sprintf("unsupported AST node type %T", node.Sub)) @@ -892,10 +893,18 @@ func (g *Generator) generateMaybeHostForm(node *ast.Node) string { maybeHostNode := node.Sub.(*ast.MaybeHostFormNode) field := maybeHostNode.Field - switch maybeHostNode.Class { - default: - panic(fmt.Sprintf("unsupported host form class: %s.%s", maybeHostNode.Class, field)) - } + panic(fmt.Sprintf("unsupported form: %s/%s", maybeHostNode.Class, field)) +} + +func (g *Generator) generateTheVar(node *ast.Node) string { + theVarNode := node.Sub.(*ast.TheVarNode) + varSym := theVarNode.Var + ns := varSym.Namespace() + name := varSym.Symbol() + + resultId := g.allocateTempVar() + g.writef("%s := lang.InternVarName(lang.NewSymbol(\"%s\"), lang.NewSymbol(\"%s\"))\n", resultId, ns.Name(), name.Name()) + return resultId } //////////////////////////////////////////////////////////////////////////////// diff --git a/pkg/codegen/testdata/codegen/test/the_var.glj b/pkg/codegen/testdata/codegen/test/the_var.glj new file mode 100644 index 00000000..4389fffe --- /dev/null +++ b/pkg/codegen/testdata/codegen/test/the_var.glj @@ -0,0 +1,6 @@ +(ns codegen.test.the-var) + +(def foo 42) + +(defn ^{:expected-output 42} -main [] + (.get #'foo)) diff --git a/pkg/codegen/testdata/codegen/test/the_var.go b/pkg/codegen/testdata/codegen/test/the_var.go new file mode 100644 index 00000000..8966d517 --- /dev/null +++ b/pkg/codegen/testdata/codegen/test/the_var.go @@ -0,0 +1,49 @@ +// Code generated by glojure codegen. DO NOT EDIT. + +package generated + +import ( + fmt "fmt" + "github.com/glojurelang/glojure/pkg/lang" + reflect "reflect" +) + +func init() { + ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.the-var")) + _ = ns + // -main + { + v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), int64(42), lang.NewKeyword("file"), "codegen/test/the_var.glj", lang.NewKeyword("line"), int(5), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(5), lang.NewKeyword("end-column"), int(34), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.the-var")))).(*lang.Symbol) + v2 := lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := lang.InternVarName(lang.NewSymbol("codegen.test.the-var"), lang.NewSymbol("foo")) + v4, ok := lang.FieldOrMethod(v3, "get") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "get"))) + } + var v5 any + switch reflect.TypeOf(v4).Kind() { + case reflect.Func: + v5 = lang.Apply(v4, nil) + default: + v5 = v4 + } + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // foo + { + v0 := lang.NewSymbol("foo").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/the_var.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.the-var")))).(*lang.Symbol) + v1 := ns.InternWithValue(v0, int64(42), true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } +} diff --git a/pkg/gen/gljimports/gljimports_darwin_amd64.go b/pkg/gen/gljimports/gljimports_darwin_amd64.go index 758b4554..68cf4e9c 100644 --- a/pkg/gen/gljimports/gljimports_darwin_amd64.go +++ b/pkg/gen/gljimports/gljimports_darwin_amd64.go @@ -3798,7 +3798,6 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewMapValSeq", github_com_glojurelang_glojure_pkg_lang.NewMapValSeq) _register("github.com/glojurelang/glojure/pkg/lang.NewMultiFn", github_com_glojurelang_glojure_pkg_lang.NewMultiFn) _register("github.com/glojurelang/glojure/pkg/lang.NewNamespace", github_com_glojurelang_glojure_pkg_lang.NewNamespace) - _register("github.com/glojurelang/glojure/pkg/lang.NewNumberFormatError", github_com_glojurelang_glojure_pkg_lang.NewNumberFormatError) _register("github.com/glojurelang/glojure/pkg/lang.NewPersistentArrayMapAsIfByAssoc", github_com_glojurelang_glojure_pkg_lang.NewPersistentArrayMapAsIfByAssoc) _register("github.com/glojurelang/glojure/pkg/lang.NewPersistentHashMap", github_com_glojurelang_glojure_pkg_lang.NewPersistentHashMap) _register("github.com/glojurelang/glojure/pkg/lang.NewRange", github_com_glojurelang_glojure_pkg_lang.NewRange) @@ -3830,8 +3829,6 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.*NodeSeq", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NodeSeq)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.Nth", github_com_glojurelang_glojure_pkg_lang.Nth) _register("github.com/glojurelang/glojure/pkg/lang.Nther", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Nther)(nil)).Elem()) - _register("github.com/glojurelang/glojure/pkg/lang.NumberFormatError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberFormatError)(nil)).Elem()) - _register("github.com/glojurelang/glojure/pkg/lang.*NumberFormatError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberFormatError)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.NumberMethods", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberMethods)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*NumberMethods", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberMethods)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.Numbers", github_com_glojurelang_glojure_pkg_lang.Numbers) diff --git a/pkg/gen/gljimports/gljimports_darwin_arm64.go b/pkg/gen/gljimports/gljimports_darwin_arm64.go index 5cbddf80..50e02442 100644 --- a/pkg/gen/gljimports/gljimports_darwin_arm64.go +++ b/pkg/gen/gljimports/gljimports_darwin_arm64.go @@ -3798,7 +3798,6 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewMapValSeq", github_com_glojurelang_glojure_pkg_lang.NewMapValSeq) _register("github.com/glojurelang/glojure/pkg/lang.NewMultiFn", github_com_glojurelang_glojure_pkg_lang.NewMultiFn) _register("github.com/glojurelang/glojure/pkg/lang.NewNamespace", github_com_glojurelang_glojure_pkg_lang.NewNamespace) - _register("github.com/glojurelang/glojure/pkg/lang.NewNumberFormatError", github_com_glojurelang_glojure_pkg_lang.NewNumberFormatError) _register("github.com/glojurelang/glojure/pkg/lang.NewPersistentArrayMapAsIfByAssoc", github_com_glojurelang_glojure_pkg_lang.NewPersistentArrayMapAsIfByAssoc) _register("github.com/glojurelang/glojure/pkg/lang.NewPersistentHashMap", github_com_glojurelang_glojure_pkg_lang.NewPersistentHashMap) _register("github.com/glojurelang/glojure/pkg/lang.NewRange", github_com_glojurelang_glojure_pkg_lang.NewRange) @@ -3830,8 +3829,6 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.*NodeSeq", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NodeSeq)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.Nth", github_com_glojurelang_glojure_pkg_lang.Nth) _register("github.com/glojurelang/glojure/pkg/lang.Nther", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Nther)(nil)).Elem()) - _register("github.com/glojurelang/glojure/pkg/lang.NumberFormatError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberFormatError)(nil)).Elem()) - _register("github.com/glojurelang/glojure/pkg/lang.*NumberFormatError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberFormatError)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.NumberMethods", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberMethods)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*NumberMethods", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberMethods)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.Numbers", github_com_glojurelang_glojure_pkg_lang.Numbers) diff --git a/pkg/gen/gljimports/gljimports_js_wasm.go b/pkg/gen/gljimports/gljimports_js_wasm.go index 3452fd04..cdf7b961 100644 --- a/pkg/gen/gljimports/gljimports_js_wasm.go +++ b/pkg/gen/gljimports/gljimports_js_wasm.go @@ -3798,7 +3798,6 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewMapValSeq", github_com_glojurelang_glojure_pkg_lang.NewMapValSeq) _register("github.com/glojurelang/glojure/pkg/lang.NewMultiFn", github_com_glojurelang_glojure_pkg_lang.NewMultiFn) _register("github.com/glojurelang/glojure/pkg/lang.NewNamespace", github_com_glojurelang_glojure_pkg_lang.NewNamespace) - _register("github.com/glojurelang/glojure/pkg/lang.NewNumberFormatError", github_com_glojurelang_glojure_pkg_lang.NewNumberFormatError) _register("github.com/glojurelang/glojure/pkg/lang.NewPersistentArrayMapAsIfByAssoc", github_com_glojurelang_glojure_pkg_lang.NewPersistentArrayMapAsIfByAssoc) _register("github.com/glojurelang/glojure/pkg/lang.NewPersistentHashMap", github_com_glojurelang_glojure_pkg_lang.NewPersistentHashMap) _register("github.com/glojurelang/glojure/pkg/lang.NewRange", github_com_glojurelang_glojure_pkg_lang.NewRange) @@ -3830,8 +3829,6 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.*NodeSeq", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NodeSeq)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.Nth", github_com_glojurelang_glojure_pkg_lang.Nth) _register("github.com/glojurelang/glojure/pkg/lang.Nther", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Nther)(nil)).Elem()) - _register("github.com/glojurelang/glojure/pkg/lang.NumberFormatError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberFormatError)(nil)).Elem()) - _register("github.com/glojurelang/glojure/pkg/lang.*NumberFormatError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberFormatError)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.NumberMethods", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberMethods)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*NumberMethods", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberMethods)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.Numbers", github_com_glojurelang_glojure_pkg_lang.Numbers) diff --git a/pkg/gen/gljimports/gljimports_linux_amd64.go b/pkg/gen/gljimports/gljimports_linux_amd64.go index 72d1f6f3..dc585a1f 100644 --- a/pkg/gen/gljimports/gljimports_linux_amd64.go +++ b/pkg/gen/gljimports/gljimports_linux_amd64.go @@ -3798,7 +3798,6 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewMapValSeq", github_com_glojurelang_glojure_pkg_lang.NewMapValSeq) _register("github.com/glojurelang/glojure/pkg/lang.NewMultiFn", github_com_glojurelang_glojure_pkg_lang.NewMultiFn) _register("github.com/glojurelang/glojure/pkg/lang.NewNamespace", github_com_glojurelang_glojure_pkg_lang.NewNamespace) - _register("github.com/glojurelang/glojure/pkg/lang.NewNumberFormatError", github_com_glojurelang_glojure_pkg_lang.NewNumberFormatError) _register("github.com/glojurelang/glojure/pkg/lang.NewPersistentArrayMapAsIfByAssoc", github_com_glojurelang_glojure_pkg_lang.NewPersistentArrayMapAsIfByAssoc) _register("github.com/glojurelang/glojure/pkg/lang.NewPersistentHashMap", github_com_glojurelang_glojure_pkg_lang.NewPersistentHashMap) _register("github.com/glojurelang/glojure/pkg/lang.NewRange", github_com_glojurelang_glojure_pkg_lang.NewRange) @@ -3830,8 +3829,6 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.*NodeSeq", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NodeSeq)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.Nth", github_com_glojurelang_glojure_pkg_lang.Nth) _register("github.com/glojurelang/glojure/pkg/lang.Nther", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Nther)(nil)).Elem()) - _register("github.com/glojurelang/glojure/pkg/lang.NumberFormatError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberFormatError)(nil)).Elem()) - _register("github.com/glojurelang/glojure/pkg/lang.*NumberFormatError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberFormatError)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.NumberMethods", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberMethods)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*NumberMethods", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberMethods)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.Numbers", github_com_glojurelang_glojure_pkg_lang.Numbers) diff --git a/pkg/gen/gljimports/gljimports_linux_arm64.go b/pkg/gen/gljimports/gljimports_linux_arm64.go index 80c1ee3d..c8fcfb6d 100644 --- a/pkg/gen/gljimports/gljimports_linux_arm64.go +++ b/pkg/gen/gljimports/gljimports_linux_arm64.go @@ -3798,7 +3798,6 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewMapValSeq", github_com_glojurelang_glojure_pkg_lang.NewMapValSeq) _register("github.com/glojurelang/glojure/pkg/lang.NewMultiFn", github_com_glojurelang_glojure_pkg_lang.NewMultiFn) _register("github.com/glojurelang/glojure/pkg/lang.NewNamespace", github_com_glojurelang_glojure_pkg_lang.NewNamespace) - _register("github.com/glojurelang/glojure/pkg/lang.NewNumberFormatError", github_com_glojurelang_glojure_pkg_lang.NewNumberFormatError) _register("github.com/glojurelang/glojure/pkg/lang.NewPersistentArrayMapAsIfByAssoc", github_com_glojurelang_glojure_pkg_lang.NewPersistentArrayMapAsIfByAssoc) _register("github.com/glojurelang/glojure/pkg/lang.NewPersistentHashMap", github_com_glojurelang_glojure_pkg_lang.NewPersistentHashMap) _register("github.com/glojurelang/glojure/pkg/lang.NewRange", github_com_glojurelang_glojure_pkg_lang.NewRange) @@ -3830,8 +3829,6 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.*NodeSeq", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NodeSeq)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.Nth", github_com_glojurelang_glojure_pkg_lang.Nth) _register("github.com/glojurelang/glojure/pkg/lang.Nther", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Nther)(nil)).Elem()) - _register("github.com/glojurelang/glojure/pkg/lang.NumberFormatError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberFormatError)(nil)).Elem()) - _register("github.com/glojurelang/glojure/pkg/lang.*NumberFormatError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberFormatError)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.NumberMethods", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberMethods)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*NumberMethods", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberMethods)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.Numbers", github_com_glojurelang_glojure_pkg_lang.Numbers) diff --git a/pkg/gen/gljimports/gljimports_windows_amd64.go b/pkg/gen/gljimports/gljimports_windows_amd64.go index a01ba1b1..ac1b3014 100644 --- a/pkg/gen/gljimports/gljimports_windows_amd64.go +++ b/pkg/gen/gljimports/gljimports_windows_amd64.go @@ -3798,7 +3798,6 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewMapValSeq", github_com_glojurelang_glojure_pkg_lang.NewMapValSeq) _register("github.com/glojurelang/glojure/pkg/lang.NewMultiFn", github_com_glojurelang_glojure_pkg_lang.NewMultiFn) _register("github.com/glojurelang/glojure/pkg/lang.NewNamespace", github_com_glojurelang_glojure_pkg_lang.NewNamespace) - _register("github.com/glojurelang/glojure/pkg/lang.NewNumberFormatError", github_com_glojurelang_glojure_pkg_lang.NewNumberFormatError) _register("github.com/glojurelang/glojure/pkg/lang.NewPersistentArrayMapAsIfByAssoc", github_com_glojurelang_glojure_pkg_lang.NewPersistentArrayMapAsIfByAssoc) _register("github.com/glojurelang/glojure/pkg/lang.NewPersistentHashMap", github_com_glojurelang_glojure_pkg_lang.NewPersistentHashMap) _register("github.com/glojurelang/glojure/pkg/lang.NewRange", github_com_glojurelang_glojure_pkg_lang.NewRange) @@ -3830,8 +3829,6 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.*NodeSeq", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NodeSeq)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.Nth", github_com_glojurelang_glojure_pkg_lang.Nth) _register("github.com/glojurelang/glojure/pkg/lang.Nther", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Nther)(nil)).Elem()) - _register("github.com/glojurelang/glojure/pkg/lang.NumberFormatError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberFormatError)(nil)).Elem()) - _register("github.com/glojurelang/glojure/pkg/lang.*NumberFormatError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberFormatError)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.NumberMethods", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberMethods)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*NumberMethods", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberMethods)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.Numbers", github_com_glojurelang_glojure_pkg_lang.Numbers) diff --git a/pkg/gen/gljimports/gljimports_windows_arm.go b/pkg/gen/gljimports/gljimports_windows_arm.go index ee309f4a..cfe54dfe 100644 --- a/pkg/gen/gljimports/gljimports_windows_arm.go +++ b/pkg/gen/gljimports/gljimports_windows_arm.go @@ -3798,7 +3798,6 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewMapValSeq", github_com_glojurelang_glojure_pkg_lang.NewMapValSeq) _register("github.com/glojurelang/glojure/pkg/lang.NewMultiFn", github_com_glojurelang_glojure_pkg_lang.NewMultiFn) _register("github.com/glojurelang/glojure/pkg/lang.NewNamespace", github_com_glojurelang_glojure_pkg_lang.NewNamespace) - _register("github.com/glojurelang/glojure/pkg/lang.NewNumberFormatError", github_com_glojurelang_glojure_pkg_lang.NewNumberFormatError) _register("github.com/glojurelang/glojure/pkg/lang.NewPersistentArrayMapAsIfByAssoc", github_com_glojurelang_glojure_pkg_lang.NewPersistentArrayMapAsIfByAssoc) _register("github.com/glojurelang/glojure/pkg/lang.NewPersistentHashMap", github_com_glojurelang_glojure_pkg_lang.NewPersistentHashMap) _register("github.com/glojurelang/glojure/pkg/lang.NewRange", github_com_glojurelang_glojure_pkg_lang.NewRange) @@ -3830,8 +3829,6 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.*NodeSeq", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NodeSeq)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.Nth", github_com_glojurelang_glojure_pkg_lang.Nth) _register("github.com/glojurelang/glojure/pkg/lang.Nther", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Nther)(nil)).Elem()) - _register("github.com/glojurelang/glojure/pkg/lang.NumberFormatError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberFormatError)(nil)).Elem()) - _register("github.com/glojurelang/glojure/pkg/lang.*NumberFormatError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberFormatError)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.NumberMethods", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberMethods)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*NumberMethods", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.NumberMethods)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.Numbers", github_com_glojurelang_glojure_pkg_lang.Numbers) diff --git a/pkg/lang/error.go b/pkg/lang/error.go index 9e30f621..62d86aa9 100644 --- a/pkg/lang/error.go +++ b/pkg/lang/error.go @@ -25,10 +25,6 @@ type ( msg string } - NumberFormatError struct { - msg string - } - // Stacker is an interface for retrieving stack traces. Stacker interface { Stack() []StackFrame @@ -102,19 +98,6 @@ func (e *ArithmeticError) Is(other error) bool { return ok } -func NewNumberFormatError(msg string) error { - return &NumberFormatError{msg: msg} -} - -func (e *NumberFormatError) Error() string { - return e.msg -} - -func (e *NumberFormatError) Is(other error) bool { - _, ok := other.(*NumberFormatError) - return ok -} - func NewIllegalStateError(msg string) error { return &IllegalStateError{msg: msg} } diff --git a/pkg/stdlib/glojure/core.glj b/pkg/stdlib/glojure/core.glj index cd5ce919..5b7a456d 100644 --- a/pkg/stdlib/glojure/core.glj +++ b/pkg/stdlib/glojure/core.glj @@ -8001,9 +8001,7 @@ fails, attempts to require sym's namespace and retries." :added "1.11"} ^go/int64 [^go/string s] (if (string? s) - (try - (Long/valueOf s) - (catch github.com$glojurelang$glojure$pkg$lang.NumberFormatError _ nil)) + (glojure.core/let [result__3638__auto__ (strconv.ParseInt s 10 64)] (if (result__3638__auto__ 1) nil (result__3638__auto__ 0))) (throw (github.com$glojurelang$glojure$pkg$lang.NewIllegalArgumentError (parsing-err s))))) (defn parse-double @@ -8014,9 +8012,7 @@ fails, attempts to require sym's namespace and retries." :added "1.11"} ^go/float64 [^go/string s] (if (string? s) - (try - (Double/valueOf s) - (catch github.com$glojurelang$glojure$pkg$lang.NumberFormatError _ nil)) + (glojure.core/let [result__3639__auto__ (strconv.ParseFloat s 64)] (if (result__3639__auto__ 1) nil (result__3639__auto__ 0))) (throw (github.com$glojurelang$glojure$pkg$lang.NewIllegalArgumentError (parsing-err s))))) (defn parse-uuid diff --git a/scripts/rewrite-core/rewrite.clj b/scripts/rewrite-core/rewrite.clj index bb8efdbb..6f0fd911 100644 --- a/scripts/rewrite-core/rewrite.clj +++ b/scripts/rewrite-core/rewrite.clj @@ -285,7 +285,31 @@ (fn visit [zloc] (z/replace zloc 'go/any))] - (sexpr-replace 'NumberFormatException 'github.com$glojurelang$glojure$pkg$lang.NumberFormatError) + ;; Replace try/catch blocks for Long/valueOf + [(fn select [zloc] + (and (z/list? zloc) + (= 'try (first (z/sexpr zloc))) + (let [body (second (z/sexpr zloc))] + (and (list? body) + (= 'Long/valueOf (first body)))))) + (fn visit [zloc] + (let [s (second (second (z/sexpr zloc)))] ; extract the 's' variable + (z/replace zloc + `(let [result# (strconv.ParseInt ~s 10 64)] + (if (result# 1) nil (result# 0))))))] + + ;; Replace try/catch blocks for Double/valueOf + [(fn select [zloc] + (and (z/list? zloc) + (= 'try (first (z/sexpr zloc))) + (let [body (second (z/sexpr zloc))] + (and (list? body) + (= 'Double/valueOf (first body)))))) + (fn visit [zloc] + (let [s (second (second (z/sexpr zloc)))] ; extract the 's' variable + (z/replace zloc + `(let [result# (strconv.ParseFloat ~s 64)] + (if (result# 1) nil (result# 0))))))] ;; ===== Metadata Operations ===== ;; replace .withMeta diff --git a/test/glojure/test_glojure/numbers.glj b/test/glojure/test_glojure/numbers.glj index bb786113..b923d69c 100644 --- a/test/glojure/test_glojure/numbers.glj +++ b/test/glojure/test_glojure/numbers.glj @@ -940,4 +940,85 @@ Math/pow overflows to Infinity." (/ nan onan) (/ onan nan) )))) +(deftest test-parse-long + (testing "parse-long with valid inputs" + (are [s expected] (= expected (parse-long s)) + "0" 0 + "1" 1 + "-1" -1 + "42" 42 + "-42" -42 + "9223372036854775807" 9223372036854775807 ; Long/MAX_VALUE + "-9223372036854775808" -9223372036854775808 ; Long/MIN_VALUE + "+123" 123 + "00123" 123)) + + (testing "parse-long with invalid inputs returns nil" + (are [s] (nil? (parse-long s)) + "" + "abc" + "12.34" + "1 2 3" + " 123" + "123 " + "12abc" + "9223372036854775808" ; overflow + "-9223372036854775809" ; underflow + "++1" + "--1" + "1.0" + "NaN" + "Infinity")) + + (testing "parse-long throws on non-string input" + (is (thrown? *IllegalArgumentError (parse-long 123))) + (is (thrown? *IllegalArgumentError (parse-long nil))) + (is (thrown? *IllegalArgumentError (parse-long :keyword))) + (is (thrown? *IllegalArgumentError (parse-long 'symbol))))) + +(deftest test-parse-double + (testing "parse-double with valid inputs" + (are [s expected] (= expected (parse-double s)) + "0" 0.0 + "0.0" 0.0 + "1" 1.0 + "1.0" 1.0 + "-1" -1.0 + "-1.0" -1.0 + "42.5" 42.5 + "-42.5" -42.5 + "3.14159" 3.14159 + "1.23e10" 1.23e10 + "1.23E10" 1.23E10 + "-1.23e-10" -1.23e-10 + "+123.456" 123.456 + ".5" 0.5 + "-.5" -0.5)) + + (testing "parse-double special values" + (let [inf-result (parse-double "Inf") + neg-inf-result (parse-double "-Inf") + nan-result (parse-double "NaN")] + (is (= ##Inf inf-result)) + (is (= ##-Inf neg-inf-result)) + (is (NaN? nan-result)))) + + (testing "parse-double with invalid inputs returns nil" + (are [s] (nil? (parse-double s)) + "" + "abc" + "1 2 3" + " 123" + "123 " + "12abc" + "++1" + "--1" + "1.2.3")) + + (testing "parse-double throws on non-string input" + (is (thrown? *IllegalArgumentError (parse-double 123))) + (is (thrown? *IllegalArgumentError (parse-double nil))) + (is (thrown? *IllegalArgumentError (parse-double :keyword))) + (is (thrown? *IllegalArgumentError (parse-double 'symbol))))) + (run-tests) From 65ae77d6069e85c559d512dfe057a8639ee3ef3e Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sun, 17 Aug 2025 18:39:21 -0700 Subject: [PATCH 24/67] Slop for generating code for reflect.Types Signed-off-by: James Hamlin --- pkg/codegen/codegen.go | 179 +++++++++++++++++++ pkg/codegen/testdata/codegen/test/values.glj | 7 + pkg/codegen/testdata/codegen/test/values.go | 84 +++++++++ pkg/lang/bigdecimal.go | 6 + 4 files changed, 276 insertions(+) create mode 100644 pkg/codegen/testdata/codegen/test/values.glj create mode 100644 pkg/codegen/testdata/codegen/test/values.go diff --git a/pkg/codegen/codegen.go b/pkg/codegen/codegen.go index f31f29fa..5d21a193 100644 --- a/pkg/codegen/codegen.go +++ b/pkg/codegen/codegen.go @@ -2,9 +2,11 @@ package codegen import ( "bytes" + "encoding/hex" "fmt" "go/format" "io" + "reflect" "strings" "github.com/glojurelang/glojure/pkg/ast" @@ -145,9 +147,14 @@ func (g *Generator) generateVar(nsVariableName string, name *lang.Symbol, vr *la return nil } +//////////////////////////////////////////////////////////////////////////////// +// Value Generation + // returns the variable name or constant expression for the value func (g *Generator) generateValue(value any) string { switch v := value.(type) { + case reflect.Type: + return g.generateTypeValue(v) case *lang.Namespace: // Generate code to find or create the namespace return fmt.Sprintf("lang.FindOrCreateNamespace(lang.NewSymbol(%#v))", v.Name().String()) @@ -176,6 +183,8 @@ func (g *Generator) generateValue(value any) string { return fmt.Sprintf("int(%d)", v) case int64: return fmt.Sprintf("int64(%d)", v) + case *lang.BigDecimal: + return g.generateBigDecimalValue(v) case bool: // return the boolean as a Go boolean literal if v { @@ -197,6 +206,148 @@ func (g *Generator) generateValue(value any) string { } } +func (g *Generator) generateTypeValue(t reflect.Type) string { + g.addImport("reflect") + + resultId := g.allocateTempVar() + + // Generate the appropriate zero value expression based on the type + // TODO: review this LLM slop + zeroValueExpr := g.generateZeroValueExpr(t) + + // For named types (structs, interfaces), use the (*T)(nil).Elem() pattern + // For other types, use the zero value directly + if t.Kind() == reflect.Struct || t.Kind() == reflect.Interface { + g.writef("%s := reflect.TypeOf((*%s)(nil)).Elem()\n", resultId, zeroValueExpr) + } else { + g.writef("%s := reflect.TypeOf(%s)\n", resultId, zeroValueExpr) + } + + return resultId +} + +// generateZeroValueExpr generates a Go expression that creates a zero value +// of the given type, handling package imports as needed +func (g *Generator) generateZeroValueExpr(t reflect.Type) string { + switch t.Kind() { + case reflect.Bool: + return "false" + case reflect.Int: + return "int(0)" + case reflect.Int8: + return "int8(0)" + case reflect.Int16: + return "int16(0)" + case reflect.Int32: + return "int32(0)" + case reflect.Int64: + return "int64(0)" + case reflect.Uint: + return "uint(0)" + case reflect.Uint8: + return "uint8(0)" + case reflect.Uint16: + return "uint16(0)" + case reflect.Uint32: + return "uint32(0)" + case reflect.Uint64: + return "uint64(0)" + case reflect.Uintptr: + return "uintptr(0)" + case reflect.Float32: + return "float32(0)" + case reflect.Float64: + return "float64(0)" + case reflect.Complex64: + return "complex64(0)" + case reflect.Complex128: + return "complex128(0)" + case reflect.String: + return `""` + case reflect.Array: + elemExpr := g.generateZeroValueExpr(t.Elem()) + return fmt.Sprintf("[%d]%s{}", t.Len(), elemExpr) + case reflect.Slice: + elemType := g.getTypeString(t.Elem()) + return fmt.Sprintf("[]%s(nil)", elemType) + case reflect.Map: + keyType := g.getTypeString(t.Key()) + elemType := g.getTypeString(t.Elem()) + return fmt.Sprintf("map[%s]%s(nil)", keyType, elemType) + case reflect.Chan: + elemType := g.getTypeString(t.Elem()) + switch t.ChanDir() { + case reflect.RecvDir: + return fmt.Sprintf("(<-chan %s)(nil)", elemType) + case reflect.SendDir: + return fmt.Sprintf("(chan<- %s)(nil)", elemType) + default: + return fmt.Sprintf("(chan %s)(nil)", elemType) + } + case reflect.Func: + return g.getTypeString(t) + "(nil)" + case reflect.Interface: + // For interfaces, return the type string for use with (*T)(nil).Elem() + return g.getTypeString(t) + case reflect.Ptr: + elemType := g.getTypeString(t.Elem()) + return fmt.Sprintf("(*%s)(nil)", elemType) + case reflect.Struct: + // For structs, return the type string for use with (*T)(nil).Elem() + return g.getTypeString(t) + default: + // Fallback: try to use the type string directly + return g.getTypeString(t) + "{}" + } +} + +// getTypeString returns a string representation of the type suitable for use +// in Go code, adding package imports as necessary +func (g *Generator) getTypeString(t reflect.Type) string { + // Handle unnamed types + if t.Name() == "" { + switch t.Kind() { + case reflect.Slice: + return "[]" + g.getTypeString(t.Elem()) + case reflect.Array: + return fmt.Sprintf("[%d]%s", t.Len(), g.getTypeString(t.Elem())) + case reflect.Map: + return fmt.Sprintf("map[%s]%s", g.getTypeString(t.Key()), g.getTypeString(t.Elem())) + case reflect.Ptr: + return "*" + g.getTypeString(t.Elem()) + case reflect.Chan: + switch t.ChanDir() { + case reflect.RecvDir: + return "<-chan " + g.getTypeString(t.Elem()) + case reflect.SendDir: + return "chan<- " + g.getTypeString(t.Elem()) + default: + return "chan " + g.getTypeString(t.Elem()) + } + default: + // For basic types like int, string, etc. + // Note: We can't use t.String() directly here because it might + // return "package.Type" format which is not what we want + return t.Kind().String() + } + } + + // Handle named types + pkgPath := t.PkgPath() + if pkgPath == "" { + // Built-in type or type from current package + // For built-in types, Name() might be empty, so use String() as fallback + if t.Name() != "" { + return t.Name() + } + return t.String() + } + + // Import the package and get an alias + alias := g.addImportWithAlias(pkgPath) + return alias + "." + t.Name() +} + // generateMapValue generates Go code for a Clojure map func (g *Generator) generateMapValue(m lang.IPersistentMap) string { var buf bytes.Buffer @@ -240,6 +391,31 @@ func (g *Generator) generateVectorValue(v lang.IPersistentVector) string { return buf.String() } +func (g *Generator) generateBigDecimalValue(bd *lang.BigDecimal) string { + bigFloat := bd.ToBigFloat() + blob, err := bigFloat.GobEncode() + if err != nil { + panic(fmt.Sprintf("failed to encode big.Float: %v", err)) + } + // nice compact hex literal + hexBlob := hex.EncodeToString(blob) + + resultId := g.allocateTempVar() + + hexAlias := g.addImportWithAlias("encoding/hex") + bigAlias := g.addImportWithAlias("math/big") + + g.writef(`%s := lang.NewBigDecimalFromBigFloat((func() *%s.Float { + var z %s.Float + b, _ := %s.DecodeString("%s") + if err := z.GobDecode(b); err != nil { panic(err) } + return &z +})()) +`, resultId, bigAlias, bigAlias, hexAlias, hexBlob) + + return resultId +} + // generateSetValue generates Go code for a Clojure set func (g *Generator) generateSetValue(s lang.IPersistentSet) string { var buf bytes.Buffer @@ -384,6 +560,9 @@ func (g *Generator) generateFnMethod(methodNode *ast.FnMethodNode, argsVar strin // If bodyVar is empty (e.g., from throw), no return is generated } +//////////////////////////////////////////////////////////////////////////////// +// AST Node Generation + // generateASTNode generates code for an AST node func (g *Generator) generateASTNode(node *ast.Node) string { switch node.Op { diff --git a/pkg/codegen/testdata/codegen/test/values.glj b/pkg/codegen/testdata/codegen/test/values.glj new file mode 100644 index 00000000..44274d38 --- /dev/null +++ b/pkg/codegen/testdata/codegen/test/values.glj @@ -0,0 +1,7 @@ +(ns codegen.test.values) + +(def big-decimal 10M) +(def big-decimal-type (type big-decimal)) + +(defn ^{:expected-output [10M (type big-decimal)]} -main [] + [big-decimal big-decimal-type]) diff --git a/pkg/codegen/testdata/codegen/test/values.go b/pkg/codegen/testdata/codegen/test/values.go new file mode 100644 index 00000000..56f0920a --- /dev/null +++ b/pkg/codegen/testdata/codegen/test/values.go @@ -0,0 +1,84 @@ +// Code generated by glojure codegen. DO NOT EDIT. + +package generated + +import ( + hex0 "encoding/hex" + fmt "fmt" + "github.com/glojurelang/glojure/pkg/lang" + lang3 "github.com/glojurelang/glojure/pkg/lang" + big1 "math/big" + reflect "reflect" +) + +func init() { + ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.values")) + _ = ns + // -main + { + v1 := lang.NewBigDecimalFromBigFloat((func() *big1.Float { + var z big1.Float + b, _ := hex0.DecodeString("010a0000004000000004a000000000000000") + if err := z.GobDecode(b); err != nil { + panic(err) + } + return &z + })()) + v2 := reflect.TypeOf((*lang3.BigDecimal)(nil)) + v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), lang.NewVector(v1, v2), lang.NewKeyword("file"), "codegen/test/values.glj", lang.NewKeyword("line"), int(6), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(6), lang.NewKeyword("end-column"), int(56), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.values")))).(*lang.Symbol) + v4 := lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := lang.FindNamespace(lang.NewSymbol("codegen.test.values")) + v6 := v5.FindInternedVar(lang.NewSymbol("big-decimal")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("codegen.test.values")) + v9 := v8.FindInternedVar(lang.NewSymbol("big-decimal-type")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.NewVector(v7, v10) + v12 := lang.NewMap(lang.NewKeyword("file"), "codegen/test/values.glj", lang.NewKeyword("line"), int(7), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(7), lang.NewKeyword("end-column"), int(32)) + v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v13 + }) + v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v3 := ns.InternWithValue(v0, v4, true) + if v0.Meta() != nil { + v3.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // big-decimal + { + v0 := lang.NewSymbol("big-decimal").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/values.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.values")))).(*lang.Symbol) + v2 := lang.NewBigDecimalFromBigFloat((func() *big1.Float { + var z big1.Float + b, _ := hex0.DecodeString("010a0000004000000004a000000000000000") + if err := z.GobDecode(b); err != nil { + panic(err) + } + return &z + })()) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // big-decimal-type + { + v0 := lang.NewSymbol("big-decimal-type").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/values.glj", lang.NewKeyword("line"), int(4), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(4), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.values")))).(*lang.Symbol) + v2 := reflect.TypeOf((*lang3.BigDecimal)(nil)) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } +} diff --git a/pkg/lang/bigdecimal.go b/pkg/lang/bigdecimal.go index e4603ef5..526e00f2 100644 --- a/pkg/lang/bigdecimal.go +++ b/pkg/lang/bigdecimal.go @@ -44,6 +44,12 @@ func (n *BigDecimal) ToBigInteger() *big.Int { return res } +func (n *BigDecimal) ToBigFloat() *big.Float { + res := new(big.Float) + res.Set(n.val) + return res +} + func (n *BigDecimal) String() string { return n.val.String() } From d26f6927764d566640eb6a35863dd52e4e19b05e Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sun, 17 Aug 2025 19:21:30 -0700 Subject: [PATCH 25/67] Fix allocation of named function variable Signed-off-by: James Hamlin --- pkg/codegen/codegen.go | 35 ++++--- pkg/codegen/testdata/codegen/test/fn_recur.go | 95 ++++++++++--------- .../testdata/codegen/test/loop_simple.go | 6 +- .../testdata/codegen/test/maybe_class.go | 3 +- .../testdata/codegen/test/quote_simple.go | 3 +- pkg/codegen/testdata/codegen/test/the_var.go | 3 +- .../testdata/codegen/test/throw_simple.go | 3 +- .../testdata/codegen/test/try_advanced.go | 15 ++- .../testdata/codegen/test/try_basic.go | 21 ++-- pkg/codegen/testdata/codegen/test/values.go | 3 +- .../testdata/codegen/test/with_meta.go | 3 +- 11 files changed, 115 insertions(+), 75 deletions(-) diff --git a/pkg/codegen/codegen.go b/pkg/codegen/codegen.go index 5d21a193..03d0a62e 100644 --- a/pkg/codegen/codegen.go +++ b/pkg/codegen/codegen.go @@ -441,26 +441,39 @@ func (g *Generator) generateFn(fn *runtime.Fn) string { astNode := fn.ASTNode() fnNode := astNode.Sub.(*ast.FnNode) - // Allocate a variable for the function - var fnVar string - if fnNode.Local == nil { - fnVar = g.allocateTempVar() - } else { - // If there's a local binding, use that name - localNode := fnNode.Local.Sub.(*ast.BindingNode) - fnVar = g.allocateLocal(localNode.Name.Name()) - } + // Allocate a variable to return the function + fnVar := g.allocateTempVar() + + // declare it now to make sure it's in the scope of the caller + // we may add a nested scope to declare the function in to keep a + // scoped variable for the function itelf, if the function is named + g.writef("var %s lang.FnFunc\n", fnVar) // Push a new scope for the function definition g.pushVarScope() defer g.popVarScope() + if fnNode.Local != nil { + // If there's a local binding, use that name + localNode := fnNode.Local.Sub.(*ast.BindingNode) + if fnName := localNode.Name.Name(); fnName != "" { + g.writef("{ // function %s\n", fnName) + defer g.writef("}\n") + + namedFnVar := g.allocateLocal(fnName) + defer func() { + g.writef("%s := %s\n", namedFnVar, fnVar) + g.writeAssign("_", namedFnVar) // Prevent unused variable warning + }() + } + } + // If there's only one method and it's not variadic, generate a simple function if len(fnNode.Methods) == 1 && !fnNode.IsVariadic { method := fnNode.Methods[0] methodNode := method.Sub.(*ast.FnMethodNode) - g.writef("%s := lang.NewFnFunc(func(args ...any) any {\n", fnVar) + g.writef("%s = lang.NewFnFunc(func(args ...any) any {\n", fnVar) g.addImport("fmt") // Import fmt for error formatting // Check arity @@ -474,7 +487,7 @@ func (g *Generator) generateFn(fn *runtime.Fn) string { g.writef("})\n") } else { // Multiple arities or variadic - need to dispatch - g.writef("%s := lang.NewFnFunc(func(args ...any) any {\n", fnVar) + g.writef("%s = lang.NewFnFunc(func(args ...any) any {\n", fnVar) g.writef(" switch len(args) {\n") // Generate cases for fixed arity methods diff --git a/pkg/codegen/testdata/codegen/test/fn_recur.go b/pkg/codegen/testdata/codegen/test/fn_recur.go index 50bf6f0b..31bd7381 100644 --- a/pkg/codegen/testdata/codegen/test/fn_recur.go +++ b/pkg/codegen/testdata/codegen/test/fn_recur.go @@ -13,7 +13,8 @@ func init() { // -main { v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), int64(55), lang.NewKeyword("file"), "codegen/test/fn_recur.glj", lang.NewKeyword("line"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(12), lang.NewKeyword("end-column"), int(34), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.fn-recur")))).(*lang.Symbol) - v2 := lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -35,54 +36,60 @@ func init() { // fib { v0 := lang.NewSymbol("fib").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/fn_recur.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Calculates the nth Fibonacci number using iteration with recur.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.fn-recur")))).(*lang.Symbol) - v2 := lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] - v5 := lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v6 := args[0] - v7 := args[1] - v8 := args[2] - recur_loop_1620: - var v9 any - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("=")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{v8, v3}) - if lang.IsTruthy(v13) { - v9 = v6 - } else { - var v14 any = v7 - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("+")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + var v5 lang.FnFunc + { // function fib-helper + v5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{v6, v7}) - var v15 any = v19 - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("inc")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + v7 := args[0] + v8 := args[1] + v9 := args[2] + recur_loop_1620: + var v10 any + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("=")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } - v23 := v22.Get() - v24 := lang.Apply(v23, []any{v8}) - var v20 any = v24 - v6 = v14 - v7 = v15 - v8 = v20 - goto recur_loop_1620 - } - return v9 - }) + v13 := v12.Get() + v14 := lang.Apply(v13, []any{v9, v3}) + if lang.IsTruthy(v14) { + v10 = v7 + } else { + var v15 any = v8 + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("+")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.Apply(v19, []any{v7, v8}) + var v16 any = v20 + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("inc")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v9}) + var v21 any = v25 + v7 = v15 + v8 = v16 + v9 = v21 + goto recur_loop_1620 + } + return v10 + }) + v6 := v5 + _ = v6 + } v6 := lang.NewMap(lang.NewKeyword("file"), "codegen/test/fn_recur.glj", lang.NewKeyword("line"), int(6), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(9), lang.NewKeyword("end-column"), int(50)) v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) if err != nil { @@ -90,7 +97,7 @@ func init() { } var v4 any = v7 _ = v4 - v9 := lang.Apply(v5, []any{int64(0), int64(1), int64(0)}) + v9 := lang.Apply(v4, []any{int64(0), int64(1), int64(0)}) return v9 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) diff --git a/pkg/codegen/testdata/codegen/test/loop_simple.go b/pkg/codegen/testdata/codegen/test/loop_simple.go index b307d219..d5d5d367 100644 --- a/pkg/codegen/testdata/codegen/test/loop_simple.go +++ b/pkg/codegen/testdata/codegen/test/loop_simple.go @@ -13,7 +13,8 @@ func init() { // -main { v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), int64(10), lang.NewKeyword("file"), "codegen/test/loop_simple.glj", lang.NewKeyword("line"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(10), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.loop-simple")))).(*lang.Symbol) - v2 := lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -35,7 +36,8 @@ func init() { // simple-loop { v0 := lang.NewSymbol("simple-loop").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/loop_simple.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.loop-simple")))).(*lang.Symbol) - v2 := lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } diff --git a/pkg/codegen/testdata/codegen/test/maybe_class.go b/pkg/codegen/testdata/codegen/test/maybe_class.go index 1da8852f..8ca9010b 100644 --- a/pkg/codegen/testdata/codegen/test/maybe_class.go +++ b/pkg/codegen/testdata/codegen/test/maybe_class.go @@ -14,7 +14,8 @@ func init() { // -main { v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), lang.NewVector("1", "2", "3"), lang.NewKeyword("file"), "codegen/test/maybe_class.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(45), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.maybe-class")))).(*lang.Symbol) - v2 := lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } diff --git a/pkg/codegen/testdata/codegen/test/quote_simple.go b/pkg/codegen/testdata/codegen/test/quote_simple.go index e1824a88..43d5d832 100644 --- a/pkg/codegen/testdata/codegen/test/quote_simple.go +++ b/pkg/codegen/testdata/codegen/test/quote_simple.go @@ -13,7 +13,8 @@ func init() { // -main { v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), lang.NewList(int64(1), int64(2), int64(3)), lang.NewKeyword("file"), "codegen/test/quote_simple.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(44), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.quote-simple")))).(*lang.Symbol) - v2 := lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } diff --git a/pkg/codegen/testdata/codegen/test/the_var.go b/pkg/codegen/testdata/codegen/test/the_var.go index 8966d517..3e1e1d2d 100644 --- a/pkg/codegen/testdata/codegen/test/the_var.go +++ b/pkg/codegen/testdata/codegen/test/the_var.go @@ -14,7 +14,8 @@ func init() { // -main { v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), int64(42), lang.NewKeyword("file"), "codegen/test/the_var.glj", lang.NewKeyword("line"), int(5), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(5), lang.NewKeyword("end-column"), int(34), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.the-var")))).(*lang.Symbol) - v2 := lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } diff --git a/pkg/codegen/testdata/codegen/test/throw_simple.go b/pkg/codegen/testdata/codegen/test/throw_simple.go index 18de2dce..b78e232b 100644 --- a/pkg/codegen/testdata/codegen/test/throw_simple.go +++ b/pkg/codegen/testdata/codegen/test/throw_simple.go @@ -13,7 +13,8 @@ func init() { // -main { v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-throw"), "uncaught error", lang.NewKeyword("file"), "codegen/test/throw_simple.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(47), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.throw-simple")))).(*lang.Symbol) - v2 := lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } diff --git a/pkg/codegen/testdata/codegen/test/try_advanced.go b/pkg/codegen/testdata/codegen/test/try_advanced.go index 4cf34f3a..ca833d3f 100644 --- a/pkg/codegen/testdata/codegen/test/try_advanced.go +++ b/pkg/codegen/testdata/codegen/test/try_advanced.go @@ -13,7 +13,8 @@ func init() { // try-custom-value { v0 := lang.NewSymbol("try-custom-value").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_advanced.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-advanced")))).(*lang.Symbol) - v2 := lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -43,7 +44,8 @@ func init() { // catch-binding-scope-2 { v0 := lang.NewSymbol("catch-binding-scope-2").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_advanced.glj", lang.NewKeyword("line"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(16), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-advanced")))).(*lang.Symbol) - v2 := lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -76,7 +78,8 @@ func init() { // -main { v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), "advanced tests passed", lang.NewKeyword("file"), "codegen/test/try_advanced.glj", lang.NewKeyword("line"), int(30), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(30), lang.NewKeyword("end-column"), int(55), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-advanced")))).(*lang.Symbol) - v2 := lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -175,7 +178,8 @@ func init() { // finally-with-return { v0 := lang.NewSymbol("finally-with-return").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_advanced.glj", lang.NewKeyword("line"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(24), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-advanced")))).(*lang.Symbol) - v2 := lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -196,7 +200,8 @@ func init() { // catch-binding-scope { v0 := lang.NewSymbol("catch-binding-scope").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_advanced.glj", lang.NewKeyword("line"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(9), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-advanced")))).(*lang.Symbol) - v2 := lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } diff --git a/pkg/codegen/testdata/codegen/test/try_basic.go b/pkg/codegen/testdata/codegen/test/try_basic.go index 9520c2e2..7ddd410e 100644 --- a/pkg/codegen/testdata/codegen/test/try_basic.go +++ b/pkg/codegen/testdata/codegen/test/try_basic.go @@ -13,7 +13,8 @@ func init() { // try-catch-finally { v0 := lang.NewSymbol("try-catch-finally").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(26), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(26), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")))).(*lang.Symbol) - v2 := lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -45,7 +46,8 @@ func init() { // -main { v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), "all tests passed", lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(43), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(43), lang.NewKeyword("end-column"), int(50), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")))).(*lang.Symbol) - v2 := lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -186,7 +188,8 @@ func init() { // try-with-throw { v0 := lang.NewSymbol("try-with-throw").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(9), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")))).(*lang.Symbol) - v2 := lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -217,7 +220,8 @@ func init() { // try-finally-only { v0 := lang.NewSymbol("try-finally-only").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(20), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")))).(*lang.Symbol) - v2 := lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -238,7 +242,8 @@ func init() { // nested-try { v0 := lang.NewSymbol("nested-try").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(34), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(34), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")))).(*lang.Symbol) - v2 := lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -283,7 +288,8 @@ func init() { // basic-try { v0 := lang.NewSymbol("basic-try").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")))).(*lang.Symbol) - v2 := lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -313,7 +319,8 @@ func init() { // try-no-catch { v0 := lang.NewSymbol("try-no-catch").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(16), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")))).(*lang.Symbol) - v2 := lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } diff --git a/pkg/codegen/testdata/codegen/test/values.go b/pkg/codegen/testdata/codegen/test/values.go index 56f0920a..eb9f4db1 100644 --- a/pkg/codegen/testdata/codegen/test/values.go +++ b/pkg/codegen/testdata/codegen/test/values.go @@ -26,7 +26,8 @@ func init() { })()) v2 := reflect.TypeOf((*lang3.BigDecimal)(nil)) v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), lang.NewVector(v1, v2), lang.NewKeyword("file"), "codegen/test/values.glj", lang.NewKeyword("line"), int(6), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(6), lang.NewKeyword("end-column"), int(56), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.values")))).(*lang.Symbol) - v4 := lang.NewFnFunc(func(args ...any) any { + var v4 lang.FnFunc + v4 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } diff --git a/pkg/codegen/testdata/codegen/test/with_meta.go b/pkg/codegen/testdata/codegen/test/with_meta.go index a1c1adce..f6938df9 100644 --- a/pkg/codegen/testdata/codegen/test/with_meta.go +++ b/pkg/codegen/testdata/codegen/test/with_meta.go @@ -13,7 +13,8 @@ func init() { // -main { v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), lang.NewKeyword("bar"), lang.NewKeyword("file"), "codegen/test/with_meta.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(36), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.with-meta")))).(*lang.Symbol) - v2 := lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } From 0354915fb0db8a098a52e2c45079a18a9875b758 Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sun, 17 Aug 2025 19:29:39 -0700 Subject: [PATCH 26/67] Add failing test for pre-compiled closures Signed-off-by: James Hamlin --- .../testdata/codegen/test/fn_closure.glj | 7 ++ .../testdata/codegen/test/fn_closure.go | 66 +++++++++++++++++++ 2 files changed, 73 insertions(+) create mode 100644 pkg/codegen/testdata/codegen/test/fn_closure.glj create mode 100644 pkg/codegen/testdata/codegen/test/fn_closure.go diff --git a/pkg/codegen/testdata/codegen/test/fn_closure.glj b/pkg/codegen/testdata/codegen/test/fn_closure.glj new file mode 100644 index 00000000..ad0de904 --- /dev/null +++ b/pkg/codegen/testdata/codegen/test/fn_closure.glj @@ -0,0 +1,7 @@ +(ns codegen.test.fn-closure) + +(defn gen-closure [the-result] (fn [] the-result)) + +(def closed (gen-closure 42)) + +(defn ^{:expected-output 42} -main [] (closed)) diff --git a/pkg/codegen/testdata/codegen/test/fn_closure.go b/pkg/codegen/testdata/codegen/test/fn_closure.go new file mode 100644 index 00000000..4d9bcd3c --- /dev/null +++ b/pkg/codegen/testdata/codegen/test/fn_closure.go @@ -0,0 +1,66 @@ +// Code generated by glojure codegen. DO NOT EDIT. + +package generated + +import ( + fmt "fmt" + "github.com/glojurelang/glojure/pkg/lang" +) + +func init() { + ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.fn-closure")) + _ = ns + // -main + { + v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), int64(42), lang.NewKeyword("file"), "codegen/test/fn_closure.glj", lang.NewKeyword("line"), int(5), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(5), lang.NewKeyword("end-column"), int(34), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.fn-closure")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := lang.FindNamespace(lang.NewSymbol("codegen.test.fn-closure")) + v4 := v3.FindInternedVar(lang.NewSymbol("gen-closure")) + if v4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) + } + v5 := v4.Get() + v6 := lang.Apply(v5, []any{int64(42)}) + v7 := lang.Apply(v6, nil) + return v7 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // gen-closure + { + v0 := lang.NewSymbol("gen-closure").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/fn_closure.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("the-result"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.fn-closure")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + var v4 lang.FnFunc + v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + return v3 + }) + v5 := lang.NewMap(lang.NewKeyword("file"), "codegen/test/fn_closure.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(49)) + v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v6 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } +} From 997cd6b7ea4bc21f2bbaa58846d1f6256c6f62b7 Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sun, 17 Aug 2025 20:19:09 -0700 Subject: [PATCH 27/67] WIP on closures Signed-off-by: James Hamlin --- pkg/codegen/TODO.txt | 5 + pkg/codegen/codegen.go | 148 +++++++++++++++++- .../testdata/codegen/test/fn_closure.glj | 11 +- .../testdata/codegen/test/fn_closure.go | 30 +++- pkg/codegen/testdata/codegen/test/fn_recur.go | 4 +- pkg/lang/atom.go | 19 ++- pkg/lang/environment.go | 4 + pkg/runtime/environment.go | 9 ++ pkg/runtime/fn.go | 6 + 9 files changed, 223 insertions(+), 13 deletions(-) create mode 100644 pkg/codegen/TODO.txt diff --git a/pkg/codegen/TODO.txt b/pkg/codegen/TODO.txt new file mode 100644 index 00000000..e47bb77b --- /dev/null +++ b/pkg/codegen/TODO.txt @@ -0,0 +1,5 @@ + +- locals scope should start EMPTY when generating values! +- handle namespace requires/uses/etc. +- handle let bindings that are shared across multiple vars +- test repeated let bindings of the same name, where previous bindings are shadowed diff --git a/pkg/codegen/codegen.go b/pkg/codegen/codegen.go index 03d0a62e..b1fbb57e 100644 --- a/pkg/codegen/codegen.go +++ b/pkg/codegen/codegen.go @@ -7,6 +7,7 @@ import ( "go/format" "io" "reflect" + "sort" "strings" "github.com/glojurelang/glojure/pkg/ast" @@ -18,6 +19,7 @@ import ( // TODO // - handle namespace requires/uses/etc. // - handle let bindings that are shared across multiple vars +// - test repeated let bindings of the same name, where previous bindings are shadowed // varScope represents a variable allocation scope type varScope struct { @@ -32,6 +34,19 @@ type recurContext struct { useGoto bool // Whether to use Go's "goto" for recur } +// liftedKey is a composite key for deduplicating lifted values +type liftedKey struct { + isPointer bool + pointer uintptr // For reference types + value any // For primitive types (used in equality check) +} + +// liftedValue represents a value that has been lifted to package scope +type liftedValue struct { + value any + varName string +} + // Generator handles the conversion of AST nodes to Go code type Generator struct { originalWriter io.Writer @@ -40,6 +55,11 @@ type Generator struct { recurStack []recurContext // stack of recur contexts for nested loops imports map[string]string // set of imported packages with their aliases + + // Fields for handling closures + liftedValues map[liftedKey]*liftedValue // Dedupe by composite key + liftedCounter int // Counter for closed0, closed1... + currentFnEnv lang.Environment // Current function's captured env } // New creates a new code generator @@ -50,6 +70,8 @@ func New(w io.Writer) *Generator { varScopes: []varScope{{nextNum: 0, names: make(map[string]string)}}, recurStack: []recurContext{}, imports: make(map[string]string), + liftedValues: make(map[liftedKey]*liftedValue), + liftedCounter: 0, } } @@ -92,15 +114,40 @@ func (g *Generator) Generate(ns *lang.Namespace) error { g.writef("}\n") - // Write package header - sourceBytes := []byte(g.header()) - sourceBytes = append(sourceBytes, buf.Bytes()...) + // Prepare the final source + sourceBytes := []byte(g.header()) // Package declaration and imports + + // Generate lifted values block if any + if len(g.liftedValues) > 0 { + var liftedBuf bytes.Buffer + liftedBuf.WriteString("\n// Closed-over values\nvar (\n") + + // Sort by variable name for deterministic output + var sortedLifted []*liftedValue + for _, lifted := range g.liftedValues { + sortedLifted = append(sortedLifted, lifted) + } + sort.Slice(sortedLifted, func(i, j int) bool { + return sortedLifted[i].varName < sortedLifted[j].varName + }) + + // Generate each lifted value + for _, lifted := range sortedLifted { + valueCode := g.generateValue(lifted.value) + liftedBuf.WriteString(fmt.Sprintf(" %s = %s\n", + lifted.varName, valueCode)) + } + liftedBuf.WriteString(")\n\n") + sourceBytes = append(sourceBytes, liftedBuf.Bytes()...) + } + + sourceBytes = append(sourceBytes, buf.Bytes()...) // The init function // Format the generated code formatted, err := format.Source(sourceBytes) if err != nil { // If formatting fails, write the unformatted code with the error - return fmt.Errorf("formatting failed: %w\n\nGenerated code:\n%s", err, buf.String()) + return fmt.Errorf("formatting failed: %w\n\nGenerated code:\n%s", err, string(sourceBytes)) } // Write formatted code to the original writer @@ -155,6 +202,8 @@ func (g *Generator) generateValue(value any) string { switch v := value.(type) { case reflect.Type: return g.generateTypeValue(v) + case *lang.Atom: + return g.generateAtomValue(v) case *lang.Namespace: // Generate code to find or create the namespace return fmt.Sprintf("lang.FindOrCreateNamespace(lang.NewSymbol(%#v))", v.Name().String()) @@ -348,6 +397,27 @@ func (g *Generator) getTypeString(t reflect.Type) string { return alias + "." + t.Name() } +func (g *Generator) generateAtomValue(atom *lang.Atom) string { + // Allocate a variable to hold the atom + atomVar := g.allocateTempVar() + + // Generate the initial value + initialValue := g.generateValue(atom.Deref()) + + var metaVar string + if meta := atom.Meta(); meta != nil { + metaVar = g.generateValue(meta) + } + + if metaVar == "" { + g.writef("%s := lang.NewAtom(%s)\n", atomVar, initialValue) + } else { + g.writef("%s := lang.NewAtomWithMeta(%s, %s)\n", atomVar, initialValue, metaVar) + } + + return atomVar +} + // generateMapValue generates Go code for a Clojure map func (g *Generator) generateMapValue(m lang.IPersistentMap) string { var buf bytes.Buffer @@ -438,6 +508,11 @@ func (g *Generator) generateSetValue(s lang.IPersistentSet) string { } func (g *Generator) generateFn(fn *runtime.Fn) string { + // Save and restore current environment + prevEnv := g.currentFnEnv + g.currentFnEnv = fn.GetEnvironment() // Set the captured environment for this function + defer func() { g.currentFnEnv = prevEnv }() + astNode := fn.ASTNode() fnNode := astNode.Sub.(*ast.FnNode) @@ -1195,7 +1270,49 @@ func (g *Generator) allocateLocal(name string) string { return varName } +// makeLiftedKey creates a composite key for deduplicating lifted values +func (g *Generator) makeLiftedKey(value any) liftedKey { + // Handle primitive types that should be compared by value + switch v := value.(type) { + case int, int8, int16, int32, int64, + uint, uint8, uint16, uint32, uint64, + float32, float64, complex64, complex128, + bool, string, lang.Keyword, lang.Char: + // Primitive types - use value-based comparison + return liftedKey{ + isPointer: false, + value: value, + } + case *lang.Symbol: + // Symbols are immutable singletons, use value comparison + return liftedKey{ + isPointer: false, + value: v.FullName(), // Use string representation for key + } + default: + // Reference types - use pointer-based comparison + rv := reflect.ValueOf(value) + if rv.Kind() == reflect.Ptr || rv.Kind() == reflect.Interface { + if rv.IsNil() { + return liftedKey{isPointer: false, value: nil} + } + if rv.CanAddr() || rv.Kind() == reflect.Ptr { + return liftedKey{ + isPointer: true, + pointer: rv.Pointer(), + } + } + } + // Fallback: use value comparison + return liftedKey{ + isPointer: false, + value: value, + } + } +} + func (g *Generator) getLocal(name string) string { + // First check normal scopes for i := len(g.varScopes) - 1; i >= 0; i-- { currentScope := &g.varScopes[i] if varName, ok := currentScope.names[name]; ok { @@ -1203,6 +1320,29 @@ func (g *Generator) getLocal(name string) string { } } + // Not in scope - check if we have a captured environment + if g.currentFnEnv != nil { + // Look up in the environment using the new public method + if value, found := g.currentFnEnv.LookupLocal(name); found { + // Create a key for deduplication + key := g.makeLiftedKey(value) + + // Check if already lifted + if lifted, ok := g.liftedValues[key]; ok { + return lifted.varName + } + + // Create new lifted value + varName := fmt.Sprintf("closed%d", g.liftedCounter) + g.liftedCounter++ + g.liftedValues[key] = &liftedValue{ + value: value, + varName: varName, + } + return varName + } + } + panic(fmt.Sprintf("variable %s not found in any scope", name)) } diff --git a/pkg/codegen/testdata/codegen/test/fn_closure.glj b/pkg/codegen/testdata/codegen/test/fn_closure.glj index ad0de904..4f041274 100644 --- a/pkg/codegen/testdata/codegen/test/fn_closure.glj +++ b/pkg/codegen/testdata/codegen/test/fn_closure.glj @@ -4,4 +4,13 @@ (def closed (gen-closure 42)) -(defn ^{:expected-output 42} -main [] (closed)) +(let [hidden-atom (atom 0)] + (defn inc-atom [] + (swap! hidden-atom inc)) + (defn get-atom [] + @hidden-atom)) + +(defn ^{:expected-output [42 1]} -main [] + (inc-atom) + [(closed) + (get-atom)]) diff --git a/pkg/codegen/testdata/codegen/test/fn_closure.go b/pkg/codegen/testdata/codegen/test/fn_closure.go index 4d9bcd3c..bbda08cb 100644 --- a/pkg/codegen/testdata/codegen/test/fn_closure.go +++ b/pkg/codegen/testdata/codegen/test/fn_closure.go @@ -7,26 +7,30 @@ import ( "github.com/glojurelang/glojure/pkg/lang" ) +// Closed-over values +var ( + closed0 = int64(42) +) + func init() { ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.fn-closure")) _ = ns // -main { - v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), int64(42), lang.NewKeyword("file"), "codegen/test/fn_closure.glj", lang.NewKeyword("line"), int(5), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(5), lang.NewKeyword("end-column"), int(34), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.fn-closure")))).(*lang.Symbol) + v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), int64(42), lang.NewKeyword("file"), "codegen/test/fn_closure.glj", lang.NewKeyword("line"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(7), lang.NewKeyword("end-column"), int(34), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.fn-closure")))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := lang.FindNamespace(lang.NewSymbol("codegen.test.fn-closure")) - v4 := v3.FindInternedVar(lang.NewSymbol("gen-closure")) + v4 := v3.FindInternedVar(lang.NewSymbol("closed")) if v4.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) } v5 := v4.Get() - v6 := lang.Apply(v5, []any{int64(42)}) - v7 := lang.Apply(v6, nil) - return v7 + v6 := lang.Apply(v5, nil) + return v6 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -34,6 +38,22 @@ func init() { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } + // closed + { + v0 := lang.NewSymbol("closed").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/fn_closure.glj", lang.NewKeyword("line"), int(5), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(5), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.fn-closure")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + return closed0 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/fn_closure.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(49))).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } // gen-closure { v0 := lang.NewSymbol("gen-closure").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/fn_closure.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("the-result"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.fn-closure")))).(*lang.Symbol) diff --git a/pkg/codegen/testdata/codegen/test/fn_recur.go b/pkg/codegen/testdata/codegen/test/fn_recur.go index 31bd7381..bc3be496 100644 --- a/pkg/codegen/testdata/codegen/test/fn_recur.go +++ b/pkg/codegen/testdata/codegen/test/fn_recur.go @@ -51,7 +51,7 @@ func init() { v7 := args[0] v8 := args[1] v9 := args[2] - recur_loop_1620: + recur_loop_1627: var v10 any v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v12 := v11.FindInternedVar(lang.NewSymbol("=")) @@ -83,7 +83,7 @@ func init() { v7 = v15 v8 = v16 v9 = v21 - goto recur_loop_1620 + goto recur_loop_1627 } return v10 }) diff --git a/pkg/lang/atom.go b/pkg/lang/atom.go index 6dbd8e02..b8fb374a 100644 --- a/pkg/lang/atom.go +++ b/pkg/lang/atom.go @@ -5,6 +5,8 @@ import "sync/atomic" type ( Atom struct { state atomic.Value + + meta IPersistentMap } ) @@ -13,12 +15,20 @@ var ( _ IRef = (*Atom)(nil) ) -func NewAtom(val interface{}) *Atom { +func NewAtom(val any) *Atom { a := &Atom{} a.state.Store(Box{val}) return a } +func NewAtomWithMeta(val any, meta IPersistentMap) *Atom { + a := NewAtom(val) + if meta != nil { + a.meta = meta + } + return a +} + func (a *Atom) Deref() interface{} { return a.state.Load().(Box).val } @@ -53,3 +63,10 @@ func (a *Atom) Reset(newVal interface{}) interface{} { // TODO: notifyWatches return newVal } + +func (a *Atom) Meta() IPersistentMap { + if a.meta == nil { + return nil + } + return a.meta +} diff --git a/pkg/lang/environment.go b/pkg/lang/environment.go index a57e4e97..805fdca0 100644 --- a/pkg/lang/environment.go +++ b/pkg/lang/environment.go @@ -67,6 +67,10 @@ type ( Context() context.Context Errorf(form interface{}, format string, args ...interface{}) error + + // LookupLocal looks up a local binding in the environment. + // This is used by the codegen system to access captured values. + LookupLocal(name string) (any, bool) } // RecurError is an error returned by a recur form. diff --git a/pkg/runtime/environment.go b/pkg/runtime/environment.go index 17fca4ee..6baa4d39 100644 --- a/pkg/runtime/environment.go +++ b/pkg/runtime/environment.go @@ -213,3 +213,12 @@ func (env *environment) errorf(n interface{}, format string, args ...interface{} return fmt.Errorf("%s: "+format, append([]interface{}{location}, args...)...) } + +// LookupLocal looks up a local binding in the environment. +// This is used by the codegen system to access captured values. +func (env *environment) LookupLocal(name string) (any, bool) { + if env == nil || env.scope == nil { + return nil, false + } + return env.scope.lookup(lang.NewSymbol(name)) +} diff --git a/pkg/runtime/fn.go b/pkg/runtime/fn.go index 76260300..9b265735 100644 --- a/pkg/runtime/fn.go +++ b/pkg/runtime/fn.go @@ -37,6 +37,12 @@ func (fn *Fn) ASTNode() *ast.Node { return fn.astNode } +// GetEnvironment returns the captured environment for this function. +// This is used by the codegen system to access captured values. +func (fn *Fn) GetEnvironment() lang.Environment { + return fn.env +} + func (fn *Fn) Invoke(args ...interface{}) interface{} { fnNode := fn.astNode.Sub.(*ast.FnNode) From e09b70e4c69831bcff7ac3447d1dc8f5da0acce9 Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sun, 17 Aug 2025 20:27:25 -0700 Subject: [PATCH 28/67] Fix closure codegen Signed-off-by: James Hamlin --- pkg/codegen/codegen.go | 49 +++++----- .../testdata/codegen/test/fn_closure.go | 91 +++++++++++++++++-- 2 files changed, 110 insertions(+), 30 deletions(-) diff --git a/pkg/codegen/codegen.go b/pkg/codegen/codegen.go index b1fbb57e..598ed70e 100644 --- a/pkg/codegen/codegen.go +++ b/pkg/codegen/codegen.go @@ -77,19 +77,15 @@ func New(w io.Writer) *Generator { // Generate takes a namespace and generates Go code that populates the same namespace func (g *Generator) Generate(ns *lang.Namespace) error { - // TODO: Implement namespace-based code generation - // For now, just stub it out - var buf bytes.Buffer - g.w = &buf - - g.writef("func init() {\n") + // Buffer for the vars and namespace setup + var varsBuf bytes.Buffer + g.w = &varsBuf g.writef(" ns := lang.FindOrCreateNamespace(lang.NewSymbol(%#v))\n", ns.Name().String()) g.writef(" _ = ns\n") // 1. Iterate through ns.Mappings() - // 2. Generate Go code for each var - // 3. Create initialization functions + // 2. Generate Go code for each var (this discovers lifted values) mappings := ns.Mappings() for seq := mappings.Seq(); seq != nil; seq = seq.Next() { entry := seq.First() @@ -112,15 +108,13 @@ func (g *Generator) Generate(ns *lang.Namespace) error { } } - g.writef("}\n") - - // Prepare the final source - sourceBytes := []byte(g.header()) // Package declaration and imports + // Now construct the complete init function + var initBuf bytes.Buffer + initBuf.WriteString("func init() {\n") - // Generate lifted values block if any + // Generate lifted values at the beginning of init() if any if len(g.liftedValues) > 0 { - var liftedBuf bytes.Buffer - liftedBuf.WriteString("\n// Closed-over values\nvar (\n") + initBuf.WriteString(" // Closed-over values\n") // Sort by variable name for deterministic output var sortedLifted []*liftedValue @@ -131,17 +125,30 @@ func (g *Generator) Generate(ns *lang.Namespace) error { return sortedLifted[i].varName < sortedLifted[j].varName }) - // Generate each lifted value + // Generate code for each lifted value + // Use a temporary buffer to capture any initialization code + var liftedBuf bytes.Buffer + g.w = &liftedBuf + for _, lifted := range sortedLifted { + // Generate the value - this will write any needed initialization valueCode := g.generateValue(lifted.value) - liftedBuf.WriteString(fmt.Sprintf(" %s = %s\n", - lifted.varName, valueCode)) + // Declare the lifted variable with the final value + g.writef(" var %s = %s\n", lifted.varName, valueCode) } - liftedBuf.WriteString(")\n\n") - sourceBytes = append(sourceBytes, liftedBuf.Bytes()...) + + // Write the lifted values code to init + initBuf.Write(liftedBuf.Bytes()) + initBuf.WriteString("\n") } - sourceBytes = append(sourceBytes, buf.Bytes()...) // The init function + // Add the vars code after the lifted values + initBuf.Write(varsBuf.Bytes()) + initBuf.WriteString("}\n") + + // Prepare the final source + sourceBytes := []byte(g.header()) // Package declaration and imports + sourceBytes = append(sourceBytes, initBuf.Bytes()...) // The complete init function // Format the generated code formatted, err := format.Source(sourceBytes) diff --git a/pkg/codegen/testdata/codegen/test/fn_closure.go b/pkg/codegen/testdata/codegen/test/fn_closure.go index bbda08cb..3df055da 100644 --- a/pkg/codegen/testdata/codegen/test/fn_closure.go +++ b/pkg/codegen/testdata/codegen/test/fn_closure.go @@ -7,30 +7,103 @@ import ( "github.com/glojurelang/glojure/pkg/lang" ) -// Closed-over values -var ( - closed0 = int64(42) -) - func init() { + // Closed-over values + v0 := lang.NewAtom(int64(0)) + var closed0 = v0 + var closed1 = int64(42) + ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.fn-closure")) _ = ns + // get-atom + { + v0 := lang.NewSymbol("get-atom").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/fn_closure.glj", lang.NewKeyword("line"), int(10), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(10), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.fn-closure")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v4 := v3.FindInternedVar(lang.NewSymbol("deref")) + if v4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) + } + v5 := v4.Get() + v6 := lang.Apply(v5, []any{closed0}) + return v6 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // inc-atom + { + v0 := lang.NewSymbol("inc-atom").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/fn_closure.glj", lang.NewKeyword("line"), int(8), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(8), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.fn-closure")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v4 := v3.FindInternedVar(lang.NewSymbol("swap!")) + if v4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) + } + v5 := v4.Get() + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("inc")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v5, []any{closed0, v8}) + return v9 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } // -main { - v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), int64(42), lang.NewKeyword("file"), "codegen/test/fn_closure.glj", lang.NewKeyword("line"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(7), lang.NewKeyword("end-column"), int(34), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.fn-closure")))).(*lang.Symbol) + v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), lang.NewVector(int64(42), int64(1)), lang.NewKeyword("file"), "codegen/test/fn_closure.glj", lang.NewKeyword("line"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(13), lang.NewKeyword("end-column"), int(38), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.fn-closure")))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := lang.FindNamespace(lang.NewSymbol("codegen.test.fn-closure")) - v4 := v3.FindInternedVar(lang.NewSymbol("closed")) + v4 := v3.FindInternedVar(lang.NewSymbol("inc-atom")) if v4.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) } v5 := v4.Get() v6 := lang.Apply(v5, nil) - return v6 + _ = v6 + v7 := lang.FindNamespace(lang.NewSymbol("codegen.test.fn-closure")) + v8 := v7.FindInternedVar(lang.NewSymbol("closed")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, nil) + v11 := lang.FindNamespace(lang.NewSymbol("codegen.test.fn-closure")) + v12 := v11.FindInternedVar(lang.NewSymbol("get-atom")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, nil) + v15 := lang.NewVector(v10, v14) + v16 := lang.NewMap(lang.NewKeyword("file"), "codegen/test/fn_closure.glj", lang.NewKeyword("line"), int(15), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(16), lang.NewKeyword("end-column"), int(14)) + v17, err := lang.WithMeta(v15, v16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v17 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -46,7 +119,7 @@ func init() { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - return closed0 + return closed1 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/fn_closure.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(49))).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) From 5d2f0e4f3f8ba333a8e58e4a9398d87751dc9501 Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sun, 17 Aug 2025 20:41:04 -0700 Subject: [PATCH 29/67] fixup references to gt Signed-off-by: James Hamlin --- pkg/gen/gljimports/gljimports_darwin_amd64.go | 1 + pkg/gen/gljimports/gljimports_darwin_arm64.go | 1 + pkg/gen/gljimports/gljimports_js_wasm.go | 1 + pkg/gen/gljimports/gljimports_linux_amd64.go | 1 + pkg/gen/gljimports/gljimports_linux_arm64.go | 1 + .../gljimports/gljimports_windows_amd64.go | 1 + pkg/gen/gljimports/gljimports_windows_arm.go | 1 + pkg/stdlib/glojure/core.glj | 234 +++++++++--------- scripts/rewrite-core/rewrite.clj | 31 ++- 9 files changed, 146 insertions(+), 126 deletions(-) diff --git a/pkg/gen/gljimports/gljimports_darwin_amd64.go b/pkg/gen/gljimports/gljimports_darwin_amd64.go index 68cf4e9c..d14c026c 100644 --- a/pkg/gen/gljimports/gljimports_darwin_amd64.go +++ b/pkg/gen/gljimports/gljimports_darwin_amd64.go @@ -3766,6 +3766,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.Namespaces", github_com_glojurelang_glojure_pkg_lang.Namespaces) _register("github.com/glojurelang/glojure/pkg/lang.NewArithmeticError", github_com_glojurelang_glojure_pkg_lang.NewArithmeticError) _register("github.com/glojurelang/glojure/pkg/lang.NewAtom", github_com_glojurelang_glojure_pkg_lang.NewAtom) + _register("github.com/glojurelang/glojure/pkg/lang.NewAtomWithMeta", github_com_glojurelang_glojure_pkg_lang.NewAtomWithMeta) _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimal", github_com_glojurelang_glojure_pkg_lang.NewBigDecimal) _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimalFromBigFloat", github_com_glojurelang_glojure_pkg_lang.NewBigDecimalFromBigFloat) _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimalFromFloat64", github_com_glojurelang_glojure_pkg_lang.NewBigDecimalFromFloat64) diff --git a/pkg/gen/gljimports/gljimports_darwin_arm64.go b/pkg/gen/gljimports/gljimports_darwin_arm64.go index 50e02442..a151ba45 100644 --- a/pkg/gen/gljimports/gljimports_darwin_arm64.go +++ b/pkg/gen/gljimports/gljimports_darwin_arm64.go @@ -3766,6 +3766,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.Namespaces", github_com_glojurelang_glojure_pkg_lang.Namespaces) _register("github.com/glojurelang/glojure/pkg/lang.NewArithmeticError", github_com_glojurelang_glojure_pkg_lang.NewArithmeticError) _register("github.com/glojurelang/glojure/pkg/lang.NewAtom", github_com_glojurelang_glojure_pkg_lang.NewAtom) + _register("github.com/glojurelang/glojure/pkg/lang.NewAtomWithMeta", github_com_glojurelang_glojure_pkg_lang.NewAtomWithMeta) _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimal", github_com_glojurelang_glojure_pkg_lang.NewBigDecimal) _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimalFromBigFloat", github_com_glojurelang_glojure_pkg_lang.NewBigDecimalFromBigFloat) _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimalFromFloat64", github_com_glojurelang_glojure_pkg_lang.NewBigDecimalFromFloat64) diff --git a/pkg/gen/gljimports/gljimports_js_wasm.go b/pkg/gen/gljimports/gljimports_js_wasm.go index cdf7b961..6a25de3b 100644 --- a/pkg/gen/gljimports/gljimports_js_wasm.go +++ b/pkg/gen/gljimports/gljimports_js_wasm.go @@ -3766,6 +3766,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.Namespaces", github_com_glojurelang_glojure_pkg_lang.Namespaces) _register("github.com/glojurelang/glojure/pkg/lang.NewArithmeticError", github_com_glojurelang_glojure_pkg_lang.NewArithmeticError) _register("github.com/glojurelang/glojure/pkg/lang.NewAtom", github_com_glojurelang_glojure_pkg_lang.NewAtom) + _register("github.com/glojurelang/glojure/pkg/lang.NewAtomWithMeta", github_com_glojurelang_glojure_pkg_lang.NewAtomWithMeta) _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimal", github_com_glojurelang_glojure_pkg_lang.NewBigDecimal) _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimalFromBigFloat", github_com_glojurelang_glojure_pkg_lang.NewBigDecimalFromBigFloat) _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimalFromFloat64", github_com_glojurelang_glojure_pkg_lang.NewBigDecimalFromFloat64) diff --git a/pkg/gen/gljimports/gljimports_linux_amd64.go b/pkg/gen/gljimports/gljimports_linux_amd64.go index dc585a1f..8e6a3a8d 100644 --- a/pkg/gen/gljimports/gljimports_linux_amd64.go +++ b/pkg/gen/gljimports/gljimports_linux_amd64.go @@ -3766,6 +3766,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.Namespaces", github_com_glojurelang_glojure_pkg_lang.Namespaces) _register("github.com/glojurelang/glojure/pkg/lang.NewArithmeticError", github_com_glojurelang_glojure_pkg_lang.NewArithmeticError) _register("github.com/glojurelang/glojure/pkg/lang.NewAtom", github_com_glojurelang_glojure_pkg_lang.NewAtom) + _register("github.com/glojurelang/glojure/pkg/lang.NewAtomWithMeta", github_com_glojurelang_glojure_pkg_lang.NewAtomWithMeta) _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimal", github_com_glojurelang_glojure_pkg_lang.NewBigDecimal) _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimalFromBigFloat", github_com_glojurelang_glojure_pkg_lang.NewBigDecimalFromBigFloat) _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimalFromFloat64", github_com_glojurelang_glojure_pkg_lang.NewBigDecimalFromFloat64) diff --git a/pkg/gen/gljimports/gljimports_linux_arm64.go b/pkg/gen/gljimports/gljimports_linux_arm64.go index c8fcfb6d..e393d8b4 100644 --- a/pkg/gen/gljimports/gljimports_linux_arm64.go +++ b/pkg/gen/gljimports/gljimports_linux_arm64.go @@ -3766,6 +3766,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.Namespaces", github_com_glojurelang_glojure_pkg_lang.Namespaces) _register("github.com/glojurelang/glojure/pkg/lang.NewArithmeticError", github_com_glojurelang_glojure_pkg_lang.NewArithmeticError) _register("github.com/glojurelang/glojure/pkg/lang.NewAtom", github_com_glojurelang_glojure_pkg_lang.NewAtom) + _register("github.com/glojurelang/glojure/pkg/lang.NewAtomWithMeta", github_com_glojurelang_glojure_pkg_lang.NewAtomWithMeta) _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimal", github_com_glojurelang_glojure_pkg_lang.NewBigDecimal) _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimalFromBigFloat", github_com_glojurelang_glojure_pkg_lang.NewBigDecimalFromBigFloat) _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimalFromFloat64", github_com_glojurelang_glojure_pkg_lang.NewBigDecimalFromFloat64) diff --git a/pkg/gen/gljimports/gljimports_windows_amd64.go b/pkg/gen/gljimports/gljimports_windows_amd64.go index ac1b3014..95fffe71 100644 --- a/pkg/gen/gljimports/gljimports_windows_amd64.go +++ b/pkg/gen/gljimports/gljimports_windows_amd64.go @@ -3766,6 +3766,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.Namespaces", github_com_glojurelang_glojure_pkg_lang.Namespaces) _register("github.com/glojurelang/glojure/pkg/lang.NewArithmeticError", github_com_glojurelang_glojure_pkg_lang.NewArithmeticError) _register("github.com/glojurelang/glojure/pkg/lang.NewAtom", github_com_glojurelang_glojure_pkg_lang.NewAtom) + _register("github.com/glojurelang/glojure/pkg/lang.NewAtomWithMeta", github_com_glojurelang_glojure_pkg_lang.NewAtomWithMeta) _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimal", github_com_glojurelang_glojure_pkg_lang.NewBigDecimal) _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimalFromBigFloat", github_com_glojurelang_glojure_pkg_lang.NewBigDecimalFromBigFloat) _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimalFromFloat64", github_com_glojurelang_glojure_pkg_lang.NewBigDecimalFromFloat64) diff --git a/pkg/gen/gljimports/gljimports_windows_arm.go b/pkg/gen/gljimports/gljimports_windows_arm.go index cfe54dfe..1135686b 100644 --- a/pkg/gen/gljimports/gljimports_windows_arm.go +++ b/pkg/gen/gljimports/gljimports_windows_arm.go @@ -3766,6 +3766,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.Namespaces", github_com_glojurelang_glojure_pkg_lang.Namespaces) _register("github.com/glojurelang/glojure/pkg/lang.NewArithmeticError", github_com_glojurelang_glojure_pkg_lang.NewArithmeticError) _register("github.com/glojurelang/glojure/pkg/lang.NewAtom", github_com_glojurelang_glojure_pkg_lang.NewAtom) + _register("github.com/glojurelang/glojure/pkg/lang.NewAtomWithMeta", github_com_glojurelang_glojure_pkg_lang.NewAtomWithMeta) _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimal", github_com_glojurelang_glojure_pkg_lang.NewBigDecimal) _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimalFromBigFloat", github_com_glojurelang_glojure_pkg_lang.NewBigDecimalFromBigFloat) _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimalFromFloat64", github_com_glojurelang_glojure_pkg_lang.NewBigDecimalFromFloat64) diff --git a/pkg/stdlib/glojure/core.glj b/pkg/stdlib/glojure/core.glj index 5b7a456d..e3607e0f 100644 --- a/pkg/stdlib/glojure/core.glj +++ b/pkg/stdlib/glojure/core.glj @@ -860,9 +860,9 @@ (defn zero? "Returns true if num is zero, else false" { - :inline (fn [num] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (IsZero ~num))) + :inline (fn [num] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (isZero ~num))) :added "1.0"} - [num] (. github.com$glojurelang$glojure$pkg$lang.Numbers (IsZero num))) + [num] (. github.com$glojurelang$glojure$pkg$lang.Numbers (isZero num))) (defn count "Returns the number of items in the collection. (count nil) returns @@ -893,11 +893,11 @@ (defn < "Returns non-nil if nums are in monotonically increasing order, otherwise false." - {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Lt ~x ~y))) + {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (lt ~x ~y))) :inline-arities #{2} :added "1.0"} ([x] true) - ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Lt x y))) + ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (lt x y))) ([x y & more] (if (< x y) (if (next more) @@ -908,16 +908,16 @@ (defn inc' "Returns a number one greater than num. Supports arbitrary precision. See also: inc" - {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (IncP ~x))) + {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (incP ~x))) :added "1.0"} - [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (IncP x))) + [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (incP x))) (defn inc "Returns a number one greater than num. Does not auto-promote longs, will throw on overflow. See also: inc'" {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (~(if *unchecked-math* 'unchecked_inc 'inc) ~x))) :added "1.2"} - [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Inc x))) + [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (inc x))) ;; reduce is defined again later after InternalReduce loads (defn ^:private ^:static @@ -959,8 +959,8 @@ (fn [a b] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (~op ~a ~b))) `(. github.com$glojurelang$glojure$pkg$lang.Numbers (~op ~x ~y)) more)))))) -(defn ^:private >1? [n] (glojure.lang.Numbers/gt n 1)) -(defn ^:private >0? [n] (glojure.lang.Numbers/gt n 0)) +(defn ^:private >1? [n] (.Gt github.com$glojurelang$glojure$pkg$lang.Numbers n 1)) +(defn ^:private >0? [n] (.Gt github.com$glojurelang$glojure$pkg$lang.Numbers n 0)) (defn +' "Returns the sum of nums. (+') returns 0. Supports arbitrary precision. @@ -970,7 +970,7 @@ :added "1.0"} ([] 0) ([x] (github.com$glojurelang$glojure$pkg$lang.MustAsNumber x)) - ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (AddP x y))) + ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (addP x y))) ([x y & more] (reduce1 +' (+' x y) more))) @@ -982,7 +982,7 @@ :added "1.2"} ([] 0) ([x] (github.com$glojurelang$glojure$pkg$lang.MustAsNumber x)) - ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Add x y))) + ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (add x y))) ([x y & more] (reduce1 + (+ x y) more))) @@ -994,7 +994,7 @@ :added "1.0"} ([] 1) ([x] (github.com$glojurelang$glojure$pkg$lang.MustAsNumber x)) - ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (MultiplyP x y))) + ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (multiplyP x y))) ([x y & more] (reduce1 *' (*' x y) more))) @@ -1006,7 +1006,7 @@ :added "1.2"} ([] 1) ([x] (github.com$glojurelang$glojure$pkg$lang.MustAsNumber x)) - ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Multiply x y))) + ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (multiply x y))) ([x y & more] (reduce1 * (* x y) more))) @@ -1017,7 +1017,7 @@ :inline-arities >1? :added "1.0"} ([x] (/ 1 x)) - ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Divide x y))) + ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (divide x y))) ([x y & more] (reduce1 / (/ x y) more))) @@ -1029,7 +1029,7 @@ :inline-arities >0? :added "1.0"} ([x] (*' -1 x)) - ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (MinusP x y))) + ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (minusP x y))) ([x y & more] (reduce1 -' (-' x y) more))) @@ -1041,18 +1041,18 @@ :inline-arities >0? :added "1.2"} ([x] (* -1 x)) - ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Minus x y))) + ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (minus x y))) ([x y & more] (reduce1 - (- x y) more))) (defn <= "Returns non-nil if nums are in monotonically non-decreasing order, otherwise false." - {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Lte ~x ~y))) + {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (lte ~x ~y))) :inline-arities #{2} :added "1.0"} ([x] true) - ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Lte x y))) + ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (lte x y))) ([x y & more] (if (<= x y) (if (next more) @@ -1063,11 +1063,11 @@ (defn > "Returns non-nil if nums are in monotonically decreasing order, otherwise false." - {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Gt ~x ~y))) + {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (gt ~x ~y))) :inline-arities #{2} :added "1.0"} ([x] true) - ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Gt x y))) + ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (gt x y))) ([x y & more] (if (> x y) (if (next more) @@ -1078,11 +1078,11 @@ (defn >= "Returns non-nil if nums are in monotonically non-increasing order, otherwise false." - {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Gte ~x ~y))) + {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (gte ~x ~y))) :inline-arities #{2} :added "1.0"} ([x] true) - ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Gte x y))) + ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (gte x y))) ([x y & more] (if (>= x y) (if (next more) @@ -1093,11 +1093,11 @@ (defn == "Returns non-nil if nums all have the equivalent value (type-independent), otherwise false" - {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Equiv ~x ~y))) + {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (equiv ~x ~y))) :inline-arities #{2} :added "1.0"} ([x] true) - ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Equiv x y))) + ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (equiv x y))) ([x y & more] (if (== x y) (if (next more) @@ -1111,7 +1111,7 @@ :inline-arities >1? :inline (nary-inline 'max)} ([x] x) - ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Max x y))) + ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (max x y))) ([x y & more] (reduce1 max (max x y) more))) @@ -1121,7 +1121,7 @@ :inline-arities >1? :inline (nary-inline 'min)} ([x] x) - ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Min x y))) + ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (min x y))) ([x y & more] (reduce1 min (min x y) more))) @@ -1140,159 +1140,159 @@ (defn dec' "Returns a number one less than num. Supports arbitrary precision. See also: dec" - {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (DecP ~x))) + {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (decP ~x))) :added "1.0"} - [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (DecP x))) + [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (decP x))) (defn dec "Returns a number one less than num. Does not auto-promote longs, will throw on overflow. See also: dec'" {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (~(if *unchecked-math* 'unchecked_dec 'dec) ~x))) :added "1.2"} - [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Dec x))) + [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (dec x))) (defn unchecked-inc-int "Returns a number one greater than x, an int. Note - uses a primitive operator subject to overflow." - {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_int_inc ~x))) + {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_int_inc ~x))) :added "1.0"} - [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_int_inc x))) + [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_int_inc x))) (defn unchecked-inc "Returns a number one greater than x, a long. Note - uses a primitive operator subject to overflow." - {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_inc ~x))) + {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_inc ~x))) :added "1.0"} - [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_inc x))) + [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_inc x))) (defn unchecked-dec-int "Returns a number one less than x, an int. Note - uses a primitive operator subject to overflow." - {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_int_dec ~x))) + {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_int_dec ~x))) :added "1.0"} - [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_int_dec x))) + [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_int_dec x))) (defn unchecked-dec "Returns a number one less than x, a long. Note - uses a primitive operator subject to overflow." - {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (UncheckedDec ~x))) + {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_dec ~x))) :added "1.0"} - [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (UncheckedDec x))) + [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_dec x))) (defn unchecked-negate-int "Returns the negation of x, an int. Note - uses a primitive operator subject to overflow." - {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_int_negate ~x))) + {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_int_negate ~x))) :added "1.0"} - [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_int_negate x))) + [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_int_negate x))) (defn unchecked-negate "Returns the negation of x, a long. Note - uses a primitive operator subject to overflow." - {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_minus ~x))) + {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_minus ~x))) :added "1.0"} [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_negate x))) (defn unchecked-add-int "Returns the sum of x and y, both int. Note - uses a primitive operator subject to overflow." - {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_int_add ~x ~y))) + {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_int_add ~x ~y))) :added "1.0"} - [x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_int_add x y))) + [x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_int_add x y))) (defn unchecked-add "Returns the sum of x and y, both long. Note - uses a primitive operator subject to overflow." - {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (UncheckedAdd ~x ~y))) + {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_add ~x ~y))) :added "1.0"} - [x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (UncheckedAdd x y))) + [x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_add x y))) (defn unchecked-subtract-int "Returns the difference of x and y, both int. Note - uses a primitive operator subject to overflow." - {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_int_subtract ~x ~y))) + {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_int_subtract ~x ~y))) :added "1.0"} - [x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_int_subtract x y))) + [x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_int_subtract x y))) (defn unchecked-subtract "Returns the difference of x and y, both long. Note - uses a primitive operator subject to overflow." - {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_minus ~x ~y))) + {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_minus ~x ~y))) :added "1.0"} - [x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_minus x y))) + [x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_minus x y))) (defn unchecked-multiply-int "Returns the product of x and y, both int. Note - uses a primitive operator subject to overflow." - {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_int_multiply ~x ~y))) + {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_int_multiply ~x ~y))) :added "1.0"} - [x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_int_multiply x y))) + [x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_int_multiply x y))) (defn unchecked-multiply "Returns the product of x and y, both long. Note - uses a primitive operator subject to overflow." - {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_multiply ~x ~y))) + {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_multiply ~x ~y))) :added "1.0"} - [x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_multiply x y))) + [x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_multiply x y))) (defn unchecked-divide-int "Returns the division of x by y, both int. Note - uses a primitive operator subject to truncation." - {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (UncheckedIntDivide ~x ~y))) + {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_int_divide ~x ~y))) :added "1.0"} - [x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (UncheckedIntDivide x y))) + [x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_int_divide x y))) (defn unchecked-remainder-int "Returns the remainder of division of x by y, both int. Note - uses a primitive operator subject to truncation." - {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_int_remainder ~x ~y))) + {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_int_remainder ~x ~y))) :added "1.0"} - [x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_int_remainder x y))) + [x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_int_remainder x y))) (defn pos? "Returns true if num is greater than zero, else false" { - :inline (fn [num] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (IsPos ~num))) + :inline (fn [num] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (isPos ~num))) :added "1.0"} - [num] (. github.com$glojurelang$glojure$pkg$lang.Numbers (IsPos num))) + [num] (. github.com$glojurelang$glojure$pkg$lang.Numbers (isPos num))) (defn neg? "Returns true if num is less than zero, else false" { - :inline (fn [num] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (IsNeg ~num))) + :inline (fn [num] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (isNeg ~num))) :added "1.0"} - [num] (. github.com$glojurelang$glojure$pkg$lang.Numbers (IsNeg num))) + [num] (. github.com$glojurelang$glojure$pkg$lang.Numbers (isNeg num))) (defn quot "quot[ient] of dividing numerator by denominator." {:added "1.0" :static true - :inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Quotient ~x ~y)))} + :inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (quotient ~x ~y)))} [num div] - (. github.com$glojurelang$glojure$pkg$lang.Numbers (Quotient num div))) + (. github.com$glojurelang$glojure$pkg$lang.Numbers (quotient num div))) (defn rem "remainder of dividing numerator by denominator." {:added "1.0" :static true - :inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Remainder ~x ~y)))} + :inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (remainder ~x ~y)))} [num div] - (. github.com$glojurelang$glojure$pkg$lang.Numbers (Remainder num div))) + (. github.com$glojurelang$glojure$pkg$lang.Numbers (remainder num div))) (defn rationalize "returns the rational value of num" {:added "1.0" :static true} [num] - (. github.com$glojurelang$glojure$pkg$lang.Numbers (Rationalize num))) + (. github.com$glojurelang$glojure$pkg$lang.Numbers (rationalize num))) ;;Bit ops (defn bit-not "Bitwise complement" - {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Not ~x))) + {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (not ~x))) :added "1.0"} - [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers Not x)) + [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers not x)) (defn bit-and @@ -1300,7 +1300,7 @@ {:inline (nary-inline 'and) :inline-arities >1? :added "1.0"} - ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers And x y)) + ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers and x y)) ([x y & more] (reduce1 bit-and (bit-and x y) more))) @@ -1309,7 +1309,7 @@ {:inline (nary-inline 'or) :inline-arities >1? :added "1.0"} - ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers Or x y)) + ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers or x y)) ([x y & more] (reduce1 bit-or (bit-or x y) more))) @@ -1318,7 +1318,7 @@ {:inline (nary-inline 'xor) :inline-arities >1? :added "1.0"} - ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers Xor x y)) + ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers xor x y)) ([x y & more] (reduce1 bit-xor (bit-xor x y) more))) @@ -1328,7 +1328,7 @@ :inline-arities >1? :added "1.0" :static true} - ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers AndNot x y)) + ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers andNot x y)) ([x y & more] (reduce1 bit-and-not (bit-and-not x y) more))) @@ -1337,44 +1337,44 @@ "Clear bit at index n" {:added "1.0" :static true} - [x n] (. github.com$glojurelang$glojure$pkg$lang.Numbers ClearBit x n)) + [x n] (. github.com$glojurelang$glojure$pkg$lang.Numbers clearBit x n)) (defn bit-set "Set bit at index n" {:added "1.0" :static true} - [x n] (. github.com$glojurelang$glojure$pkg$lang.Numbers SetBit x n)) + [x n] (. github.com$glojurelang$glojure$pkg$lang.Numbers setBit x n)) (defn bit-flip "Flip bit at index n" {:added "1.0" :static true} - [x n] (. github.com$glojurelang$glojure$pkg$lang.Numbers FlipBit x n)) + [x n] (. github.com$glojurelang$glojure$pkg$lang.Numbers flipBit x n)) (defn bit-test "Test bit at index n" {:added "1.0" :static true} - [x n] (. github.com$glojurelang$glojure$pkg$lang.Numbers TestBit x n)) + [x n] (. github.com$glojurelang$glojure$pkg$lang.Numbers testBit x n)) (defn bit-shift-left "Bitwise shift left" - {:inline (fn [x n] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (ShiftLeft ~x ~n))) + {:inline (fn [x n] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (shiftLeft ~x ~n))) :added "1.0"} - [x n] (. github.com$glojurelang$glojure$pkg$lang.Numbers ShiftLeft x n)) + [x n] (. github.com$glojurelang$glojure$pkg$lang.Numbers shiftLeft x n)) (defn bit-shift-right "Bitwise shift right" - {:inline (fn [x n] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (ShiftRight ~x ~n))) + {:inline (fn [x n] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (shiftRight ~x ~n))) :added "1.0"} - [x n] (. github.com$glojurelang$glojure$pkg$lang.Numbers ShiftRight x n)) + [x n] (. github.com$glojurelang$glojure$pkg$lang.Numbers shiftRight x n)) (defn unsigned-bit-shift-right "Bitwise shift right, without sign-extension." - {:inline (fn [x n] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (UnsignedShiftRight ~x ~n))) + {:inline (fn [x n] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (unsignedShiftRight ~x ~n))) :added "1.6"} - [x n] (. github.com$glojurelang$glojure$pkg$lang.Numbers UnsignedShiftRight x n)) + [x n] (. github.com$glojurelang$glojure$pkg$lang.Numbers unsignedShiftRight x n)) (defn integer? "Returns true if n is an integer" {:added "1.0", :static true} [n] (github.com$glojurelang$glojure$pkg$lang.IsInteger n)) @@ -3474,9 +3474,9 @@ (defn num "Coerce to Number" { - :inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Num ~x))) + :inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (num ~x))) :added "1.0"} - [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Num x))) + [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (num x))) (defn long "Coerce to long" @@ -5300,51 +5300,51 @@ (defn float-array "Creates an array of floats" - {:inline (fn [& args] `(. github.com$glojurelang$glojure$pkg$lang.Numbers FloatArray (unquote-splicing args))) + {:inline (fn [& args] `(. github.com$glojurelang$glojure$pkg$lang.Numbers floatArray (unquote-splicing args))) :inline-arities #{1 2} :added "1.0"} - ([size-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers FloatArray size-or-seq)) - ([size init-val-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers FloatArrayInit size init-val-or-seq))) + ([size-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers floatArray size-or-seq)) + ([size init-val-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers floatArrayInit size init-val-or-seq))) (defn boolean-array "Creates an array of booleans" - {:inline (fn [& args] `(. github.com$glojurelang$glojure$pkg$lang.Numbers BooleanArray (unquote-splicing args))) + {:inline (fn [& args] `(. github.com$glojurelang$glojure$pkg$lang.Numbers booleanArray (unquote-splicing args))) :inline-arities #{1 2} :added "1.1"} - ([size-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers BooleanArray size-or-seq)) - ([size init-val-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers BooleanArrayInit size init-val-or-seq))) + ([size-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers booleanArray size-or-seq)) + ([size init-val-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers booleanArrayInit size init-val-or-seq))) (defn byte-array "Creates an array of bytes" - {:inline (fn [& args] `(. github.com$glojurelang$glojure$pkg$lang.Numbers ByteArray (unquote-splicing args))) + {:inline (fn [& args] `(. github.com$glojurelang$glojure$pkg$lang.Numbers byteArray (unquote-splicing args))) :inline-arities #{1 2} :added "1.1"} - ([size-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers ByteArray size-or-seq)) - ([size init-val-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers ByteArrayInit size init-val-or-seq))) + ([size-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers byteArray size-or-seq)) + ([size init-val-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers byteArrayInit size init-val-or-seq))) (defn char-array "Creates an array of chars" - {:inline (fn [& args] `(. github.com$glojurelang$glojure$pkg$lang.Numbers CharArray (unquote-splicing args))) + {:inline (fn [& args] `(. github.com$glojurelang$glojure$pkg$lang.Numbers charArray (unquote-splicing args))) :inline-arities #{1 2} :added "1.1"} - ([size-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers CharArray size-or-seq)) - ([size init-val-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers CharArrayInit size init-val-or-seq))) + ([size-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers charArray size-or-seq)) + ([size init-val-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers charArrayInit size init-val-or-seq))) (defn short-array "Creates an array of shorts" - {:inline (fn [& args] `(. github.com$glojurelang$glojure$pkg$lang.Numbers ShortArray (unquote-splicing args))) + {:inline (fn [& args] `(. github.com$glojurelang$glojure$pkg$lang.Numbers shortArray (unquote-splicing args))) :inline-arities #{1 2} :added "1.1"} - ([size-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers ShortArray size-or-seq)) - ([size init-val-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers ShortArrayInit size init-val-or-seq))) + ([size-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers shortArray size-or-seq)) + ([size init-val-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers shortArrayInit size init-val-or-seq))) (defn double-array "Creates an array of doubles" - {:inline (fn [& args] `(. github.com$glojurelang$glojure$pkg$lang.Numbers DoubleArray (unquote-splicing args))) + {:inline (fn [& args] `(. github.com$glojurelang$glojure$pkg$lang.Numbers doubleArray (unquote-splicing args))) :inline-arities #{1 2} :added "1.0"} - ([size-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers DoubleArray size-or-seq)) - ([size init-val-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers DoubleArrayInit size init-val-or-seq))) + ([size-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers doubleArray size-or-seq)) + ([size init-val-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers doubleArrayInit size init-val-or-seq))) (defn object-array "Creates an array of objects" @@ -5355,59 +5355,59 @@ (defn int-array "Creates an array of ints" - {:inline (fn [& args] `(. github.com$glojurelang$glojure$pkg$lang.Numbers IntArray (unquote-splicing args))) + {:inline (fn [& args] `(. github.com$glojurelang$glojure$pkg$lang.Numbers intArray (unquote-splicing args))) :inline-arities #{1 2} :added "1.0"} - ([size-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers IntArray size-or-seq)) - ([size init-val-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers IntArrayInit size init-val-or-seq))) + ([size-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers intArray size-or-seq)) + ([size init-val-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers intArrayInit size init-val-or-seq))) (defn long-array "Creates an array of longs" - {:inline (fn [& args] `(. github.com$glojurelang$glojure$pkg$lang.Numbers LongArray (unquote-splicing args))) + {:inline (fn [& args] `(. github.com$glojurelang$glojure$pkg$lang.Numbers longArray (unquote-splicing args))) :inline-arities #{1 2} :added "1.0"} - ([size-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers LongArray size-or-seq)) - ([size init-val-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers LongArrayInit size init-val-or-seq))) + ([size-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers longArray size-or-seq)) + ([size init-val-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers longArrayInit size init-val-or-seq))) (definline booleans "Casts to boolean[]" {:added "1.1"} - [xs] `(. github.com$glojurelang$glojure$pkg$lang.Numbers Booleans ~xs)) + [xs] `(. github.com$glojurelang$glojure$pkg$lang.Numbers booleans ~xs)) (definline bytes "Casts to bytes[]" {:added "1.1"} - [xs] `(. github.com$glojurelang$glojure$pkg$lang.Numbers Bytes ~xs)) + [xs] `(. github.com$glojurelang$glojure$pkg$lang.Numbers bytes ~xs)) (definline chars "Casts to chars[]" {:added "1.1"} - [xs] `(. github.com$glojurelang$glojure$pkg$lang.Numbers Chars ~xs)) + [xs] `(. github.com$glojurelang$glojure$pkg$lang.Numbers chars ~xs)) (definline shorts "Casts to shorts[]" {:added "1.1"} - [xs] `(. github.com$glojurelang$glojure$pkg$lang.Numbers Shorts ~xs)) + [xs] `(. github.com$glojurelang$glojure$pkg$lang.Numbers shorts ~xs)) (definline floats "Casts to float[]" {:added "1.0"} - [xs] `(. github.com$glojurelang$glojure$pkg$lang.Numbers Floats ~xs)) + [xs] `(. github.com$glojurelang$glojure$pkg$lang.Numbers floats ~xs)) (definline ints "Casts to int[]" {:added "1.0"} - [xs] `(. github.com$glojurelang$glojure$pkg$lang.Numbers Ints ~xs)) + [xs] `(. github.com$glojurelang$glojure$pkg$lang.Numbers ints ~xs)) (definline doubles "Casts to double[]" {:added "1.0"} - [xs] `(. github.com$glojurelang$glojure$pkg$lang.Numbers Doubles ~xs)) + [xs] `(. github.com$glojurelang$glojure$pkg$lang.Numbers doubles ~xs)) (definline longs "Casts to long[]" {:added "1.0"} - [xs] `(. github.com$glojurelang$glojure$pkg$lang.Numbers Longs ~xs)) + [xs] `(. github.com$glojurelang$glojure$pkg$lang.Numbers longs ~xs)) (defn bytes? "Return true if x is a byte array" @@ -8001,7 +8001,7 @@ fails, attempts to require sym's namespace and retries." :added "1.11"} ^go/int64 [^go/string s] (if (string? s) - (glojure.core/let [result__3638__auto__ (strconv.ParseInt s 10 64)] (if (result__3638__auto__ 1) nil (result__3638__auto__ 0))) + (glojure.core/let [result__3647__auto__ (strconv.ParseInt s 10 64)] (if (result__3647__auto__ 1) nil (result__3647__auto__ 0))) (throw (github.com$glojurelang$glojure$pkg$lang.NewIllegalArgumentError (parsing-err s))))) (defn parse-double @@ -8012,7 +8012,7 @@ fails, attempts to require sym's namespace and retries." :added "1.11"} ^go/float64 [^go/string s] (if (string? s) - (glojure.core/let [result__3639__auto__ (strconv.ParseFloat s 64)] (if (result__3639__auto__ 1) nil (result__3639__auto__ 0))) + (glojure.core/let [result__3648__auto__ (strconv.ParseFloat s 64)] (if (result__3648__auto__ 1) nil (result__3648__auto__ 0))) (throw (github.com$glojurelang$glojure$pkg$lang.NewIllegalArgumentError (parsing-err s))))) (defn parse-uuid diff --git a/scripts/rewrite-core/rewrite.clj b/scripts/rewrite-core/rewrite.clj index 6f0fd911..1bf3e1f2 100644 --- a/scripts/rewrite-core/rewrite.clj +++ b/scripts/rewrite-core/rewrite.clj @@ -27,6 +27,25 @@ (= (str (z/node zloc)) (str old))) (fn visit [zloc] (z/replace zloc new))])) +(defn sexpr-splice-replace + "Replace a single form with multiple forms from a list" + [old replacement-list] + [(fn select [zloc] (and (z/sexpr-able? zloc) (= old (z/sexpr zloc)))) + (fn visit [zloc] + ;; We need to replace the current node with multiple nodes + ;; First insert all the new nodes after the current one, then remove the current + (let [parent (z/up zloc)] + (if (and parent (z/list? parent)) + ;; We're in a list context, can splice + (loop [zloc zloc + forms (reverse replacement-list)] + (if (empty? forms) + (z/remove zloc) + (recur (z/insert-right zloc (first forms)) + (rest forms)))) + ;; Not in a list context, fall back to regular replacement with a list + (z/replace zloc (cons 'do replacement-list)))))]) + (defn sexpr-remove [old] [(fn select [zloc] (and (z/sexpr-able? zloc) (= old (z/sexpr zloc)))) (fn visit [zloc] (z/remove zloc))]) @@ -652,15 +671,9 @@ (sexpr-replace 'clojure.lang.RT/uncheckedIntCast 'github.com$glojurelang$glojure$pkg$lang.UncheckedIntCast) - [(fn select [zloc] (try - (and (symbol? (z/sexpr zloc)) - (or - (and (z/leftmost? zloc) (= 'github.com$glojurelang$glojure$pkg$lang.Numbers (-> zloc z/up z/left z/sexpr))) - (= 'github.com$glojurelang$glojure$pkg$lang.Numbers (-> zloc z/left z/sexpr)))) - (catch Exception e false))) - (fn visit [zloc] (z/replace zloc - (let [sym (-> zloc z/sexpr str)] - (symbol (str (string/upper-case (first sym)) (subs sym 1))))))] + (sexpr-splice-replace 'clojure.lang.Numbers/gt + ['.Gt 'github.com$glojurelang$glojure$pkg$lang.Numbers]) + (sexpr-replace 'clojure.lang.Numbers 'github.com$glojurelang$glojure$pkg$lang.Numbers) (sexpr-replace '(cast Number x) '(github.com$glojurelang$glojure$pkg$lang.MustAsNumber x)) (sexpr-replace '(instance? Number x) '(github.com$glojurelang$glojure$pkg$lang.IsNumber x)) From e3fec300f6c30278fe7cf77ea6f9f25289e0f4dd Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sun, 17 Aug 2025 21:15:31 -0700 Subject: [PATCH 30/67] Let some unsupported stuff pass through just to see where we stand Signed-off-by: James Hamlin --- pkg/codegen/analyze.go | 3 -- pkg/codegen/codegen.go | 55 +++++++++++++++++++++++++++++--- pkg/stdlib/glojure/core.glj | 19 ----------- scripts/rewrite-core/rewrite.clj | 6 ++++ 4 files changed, 57 insertions(+), 26 deletions(-) diff --git a/pkg/codegen/analyze.go b/pkg/codegen/analyze.go index d5605609..b15bd2a4 100644 --- a/pkg/codegen/analyze.go +++ b/pkg/codegen/analyze.go @@ -4,9 +4,6 @@ import ( "github.com/glojurelang/glojure/pkg/ast" ) -// return true to stop visiting -type visitor func(*ast.Node) bool - func nodeRecurs(n *ast.Node, loopID string) bool { switch n.Op { case ast.OpRecur: diff --git a/pkg/codegen/codegen.go b/pkg/codegen/codegen.go index 598ed70e..37df7203 100644 --- a/pkg/codegen/codegen.go +++ b/pkg/codegen/codegen.go @@ -62,6 +62,14 @@ type Generator struct { currentFnEnv lang.Environment // Current function's captured env } +var ( + omittedVars = map[string]bool{ + // initialized by the runtime + "#'glojure.core/*in*": true, + "#'glojure.core/*out*": true, + } +) + // New creates a new code generator func New(w io.Writer) *Generator { return &Generator{ @@ -166,6 +174,12 @@ func (g *Generator) Generate(ns *lang.Namespace) error { // generateVar generates Go code for a single Var func (g *Generator) generateVar(nsVariableName string, name *lang.Symbol, vr *lang.Var) error { + if omittedVars[vr.String()] { + // Skip omitted vars + fmt.Printf("Skipping omitted var: %s\n", name.String()) + return nil + } + g.pushVarScope() defer g.popVarScope() @@ -663,11 +677,9 @@ func (g *Generator) generateASTNode(node *ast.Node) string { switch node.Op { // OpDef // OpSetBang - // OpMap // OpLetFn // OpGo // OpCase - // OpNew case ast.OpTry: return g.generateTry(node) case ast.OpThrow: @@ -717,6 +729,8 @@ func (g *Generator) generateASTNode(node *ast.Node) string { return g.generateMaybeHostForm(node) case ast.OpTheVar: return g.generateTheVar(node) + case ast.OpNew: + return g.generateNew(node) default: fmt.Printf("Generating code for AST node: %T %+v\n", node.Sub, node.Sub) panic(fmt.Sprintf("unsupported AST node type %T", node.Sub)) @@ -1096,7 +1110,11 @@ func (g *Generator) generateMaybeClass(node *ast.Node) string { // find last dot in the package name dotIndex := strings.LastIndex(pkg, ".") if dotIndex == -1 { - panic(fmt.Sprintf("invalid package reference: %s", pkg)) + // TODO: panic + // For now, return a nil value to avoid panic + fmt.Println("Warning: invalid package reference:", pkg) + return "nil" + //panic(fmt.Sprintf("invalid package reference: %s", pkg)) } mungedPkgName := pkg[:dotIndex] exportedName := pkg[dotIndex+1:] @@ -1165,9 +1183,14 @@ func (g *Generator) generateHostInterop(node *ast.Node) string { // generateMaybeHostForm generates code for a MaybeHostForm node func (g *Generator) generateMaybeHostForm(node *ast.Node) string { maybeHostNode := node.Sub.(*ast.MaybeHostFormNode) + class := maybeHostNode.Class field := maybeHostNode.Field - panic(fmt.Sprintf("unsupported form: %s/%s", maybeHostNode.Class, field)) + // TODO: implement support for host forms or disallow entirely + //panic(fmt.Sprintf("unsupported form: %s/%s", maybeHostNode.Class, field)) + + fmt.Printf("skipping host form: %s/%s\n", class, field) + return "nil" } func (g *Generator) generateTheVar(node *ast.Node) string { @@ -1181,6 +1204,30 @@ func (g *Generator) generateTheVar(node *ast.Node) string { return resultId } +func (g *Generator) generateNew(node *ast.Node) string { + newNode := node.Sub.(*ast.NewNode) + + // the interpreter is more lax; it allows for expressions that evaluate to a type + // here we assume the class is a constant type. clojure's new form is similar + constNode, ok := newNode.Class.Sub.(*ast.ConstNode) + if !ok { + fmt.Println("Warning: glojure codegen only supports new with constant class types.") + return fmt.Sprintf("%q", "unimplemented: new with non-constant class type") + } + + class, ok := constNode.Value.(reflect.Type) + if !ok { + fmt.Println("Warning: glojure codegen only supports new with constant class types.") + return fmt.Sprintf("%q", "unimplemented: new with non-constant class type") + } + + // generate a reflect.Type for the class + classId := g.generateValue(class) + resultId := g.allocateTempVar() + g.writef("%s := reflect.New(%s).Interface()\n", resultId, classId) + return resultId +} + //////////////////////////////////////////////////////////////////////////////// func (g *Generator) addImport(pkg string) { diff --git a/pkg/stdlib/glojure/core.glj b/pkg/stdlib/glojure/core.glj index e3607e0f..5b7b5e1f 100644 --- a/pkg/stdlib/glojure/core.glj +++ b/pkg/stdlib/glojure/core.glj @@ -7933,17 +7933,6 @@ fails, attempts to require sym's namespace and retries." [x] (instance? java.net.URI x)) (defonce ^:private tapset (atom #{})) -(defn add-tap - "adds f, a fn of one argument, to the tap set. This function will be called with anything sent via tap>. - This function may (briefly) block (e.g. for streams), and will never impede calls to tap>, - but blocking indefinitely may cause tap values to be dropped. - Remember f in order to remove-tap" - {:added "1.10"} - [f] - (force tap-loop) - (swap! tapset conj f) - nil) - (defn remove-tap "Remove f from the tap set." {:added "1.10"} @@ -7951,14 +7940,6 @@ fails, attempts to require sym's namespace and retries." (swap! tapset disj f) nil) -(defn tap> - "sends x to any taps. Will not block. Returns true if there was room in the queue, - false if not (dropped)." - {:added "1.10"} - [x] - (force tap-loop) - (.offer tapq (if (nil? x) ::tap-nil x))) - (defn update-vals "m f => {k (f v) ...} diff --git a/scripts/rewrite-core/rewrite.clj b/scripts/rewrite-core/rewrite.clj index 1bf3e1f2..b21c56f6 100644 --- a/scripts/rewrite-core/rewrite.clj +++ b/scripts/rewrite-core/rewrite.clj @@ -402,6 +402,12 @@ (omitp #(and (z/list? %) (= 'defonce (first (z/sexpr %))) (= 'tapq (second (z/sexpr %))))) + (omitp #(and (z/list? %) + (= 'defn (first (z/sexpr %))) + (= 'add-tap (second (z/sexpr %))))) + (omitp #(and (z/list? %) + (= 'defn (first (z/sexpr %))) + (= 'tap> (second (z/sexpr %))))) [(fn select [zloc] (and (z/list? zloc) (= 'defn- (first (z/sexpr zloc))) From 6c1468d62f34258fa2865ef8732e7f974c1cad76 Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sun, 17 Aug 2025 21:37:22 -0700 Subject: [PATCH 31/67] Ignore errors to generate stdlib core go Signed-off-by: James Hamlin --- pkg/codegen/codegen.go | 27 +- pkg/codegen/codegen_test.go | 8 + pkg/codegen/testdata/codegen/test/core.go | 81793 ++++++++++++++++++++ 3 files changed, 81822 insertions(+), 6 deletions(-) create mode 100644 pkg/codegen/testdata/codegen/test/core.go diff --git a/pkg/codegen/codegen.go b/pkg/codegen/codegen.go index 37df7203..35e34967 100644 --- a/pkg/codegen/codegen.go +++ b/pkg/codegen/codegen.go @@ -162,6 +162,7 @@ func (g *Generator) Generate(ns *lang.Namespace) error { formatted, err := format.Source(sourceBytes) if err != nil { // If formatting fails, write the unformatted code with the error + g.originalWriter.Write(sourceBytes) return fmt.Errorf("formatting failed: %w\n\nGenerated code:\n%s", err, string(sourceBytes)) } @@ -272,7 +273,11 @@ func (g *Generator) generateValue(value any) string { } return fmt.Sprintf("lang.NewList(%s)", strings.Join(vals, ", ")) } - panic(fmt.Sprintf("unsupported value type %T: %s", v, v)) + + fmt.Println("Unsupported value type:", reflect.TypeOf(v), v) + return "nil" + // TODO: panic + //panic(fmt.Sprintf("unsupported value type %T: %s", v, v)) } } @@ -675,11 +680,21 @@ func (g *Generator) generateFnMethod(methodNode *ast.FnMethodNode, argsVar strin // generateASTNode generates code for an AST node func (g *Generator) generateASTNode(node *ast.Node) string { switch node.Op { - // OpDef - // OpSetBang - // OpLetFn - // OpGo - // OpCase + case ast.OpDef: + fmt.Println("Def not yet implemented; returning nil") + return "nil" + case ast.OpSetBang: + fmt.Println("SetBang not yet implemented; returning nil") + return "nil" + case ast.OpLetFn: + fmt.Println("LetFn not yet implemented; returning nil") + return "nil" + case ast.OpGo: + fmt.Println("Go not yet implemented; returning nil") + return "nil" + case ast.OpCase: + fmt.Println("Case not yet implemented; returning nil") + return "nil" case ast.OpTry: return g.generateTry(node) case ast.OpThrow: diff --git a/pkg/codegen/codegen_test.go b/pkg/codegen/codegen_test.go index b48db5e5..81ce8f86 100644 --- a/pkg/codegen/codegen_test.go +++ b/pkg/codegen/codegen_test.go @@ -79,6 +79,14 @@ func generateAndTestNamespace(t *testing.T, ns *lang.Namespace, goldenFile strin var buf bytes.Buffer gen := codegen.New(&buf) if err := gen.Generate(ns); err != nil { + if os.Getenv("UPDATE_SNAPSHOT") == "1" { + // write the output anyway if we're updating the snapshot + generated := buf.Bytes() + if len(generated) > 0 { + ioutil.WriteFile(goldenFile, generated, 0644) + } + } + t.Fatalf("failed to generate code: %v", err) } diff --git a/pkg/codegen/testdata/codegen/test/core.go b/pkg/codegen/testdata/codegen/test/core.go new file mode 100644 index 00000000..7c26a035 --- /dev/null +++ b/pkg/codegen/testdata/codegen/test/core.go @@ -0,0 +1,81793 @@ +// Code generated by glojure codegen. DO NOT EDIT. + +package generated + +import ( + "github.com/glojurelang/glojure/pkg/lang" + Eduction28 "Eduction" + CompilerException34 "glojure.lang.Compiler/CompilerException" + lang1 "github.com/glojurelang/glojure/pkg/lang" + strconv4 "strconv" + java.net16 "java.net" + StringBuilder19 "StringBuilder" + BigDecimal8 "BigDecimal" + rand36 "math/rand" + java.lang.UnsupportedOperationException29 "java.lang.UnsupportedOperationException" + regexp33 "regexp" + BigInteger12 "BigInteger" + java.util13 "java.util" + Object23 "Object" + Exception25 "Exception" + strings22 "strings" + glojure.lang.Volatile24 "glojure.lang.Volatile" + glojure.lang.LineNumberingPushbackReader5 "glojure.lang.LineNumberingPushbackReader" + math7 "math" + big9 "math/big" + java.lang.annotation17 "java.lang.annotation" + bytes18 "bytes" + time30 "time" + java.util.concurrent.CountDownLatch32 "java.util.concurrent.CountDownLatch" + fmt "fmt" + java.io.InputStreamReader6 "java.io.InputStreamReader" + errors10 "errors" + glojure.lang11 "glojure.lang" + LinkedBlockingQueue31 "LinkedBlockingQueue" + ExceptionInfo14 "ExceptionInfo" + java.util.concurrent15 "java.util.concurrent" + java.io.BufferedWriter21 "java.io.BufferedWriter" + java.util.ArrayList27 "java.util.ArrayList" + reflect "reflect" + java.lang35 "java.lang" + java.io.StringReader37 "java.io.StringReader" + runtime3 "github.com/glojurelang/glojure/pkg/runtime" + java.io.PrintWriter20 "java.io.PrintWriter" + runtime26 "runtime" +) +func init() { + // Closed-over values + var closed0 = lang.NewSymbol("addP") +var v0 lang.FnFunc +v0 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v1 := args[0] +var v2 any +if lang.IsTruthy(v1) { +v2 = false +} else { +v2 = true +} +return v2 +}) +v1 := reflect.TypeOf(false) +v0 = v0.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v1)).(lang.FnFunc) + var closed1 = v0 + var closed10 = lang.NewSymbol("unchecked_add") +var v1 lang.FnFunc +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v2 := args[0] +v3 := args[1] +recur_loop_481: +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +var v4 any = v8 +_ = v4 +var v10 any +if lang.IsTruthy(v4) { +var v11 any = v4 +_ = v11 +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("first")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v11}) +v18 := lang.Apply(v2, []any{v17}) +var v13 any = v18 +_ = v13 +var v20 any +if lang.IsTruthy(v13) { +v20 = v13 +} else { +var v21 any = v2 +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("next")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{v11}) +var v22 any = v26 +v2 = v21 +v3 = v22 +goto recur_loop_481 +} +v10 = v20 +} else { +v10 = nil +} +return v10 +}) +v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + var closed11 = v1 + var closed12 = lang.NewSymbol("multiplyP") + var closed13 = lang.NewSymbol("xor") + var closed14 = lang.NewSymbol("max") + var closed15 = lang.NewSymbol("divide") +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +recur_loop_480: +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("nil?")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("seq")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v4}) +v13 := lang.Apply(v8, []any{v12}) +if lang.IsTruthy(v13) { +v5 = true +} else { +var v14 any +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("first")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v4}) +v19 := lang.Apply(v3, []any{v18}) +if lang.IsTruthy(v19) { +var v20 any = v3 +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("next")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v4}) +var v21 any = v25 +v3 = v20 +v4 = v21 +goto recur_loop_480 +} else { +var v26 any +if lang.IsTruthy(lang.NewKeyword("else")) { +v26 = false +} else { +v26 = nil +} +v14 = v26 +} +v5 = v14 +} +return v5 +}) +v3 := reflect.TypeOf(false) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v3)).(lang.FnFunc) + var closed2 = v2 + var closed3 = lang.NewSymbol("unchecked_multiply") + var closed4 = lang.NewSymbol("or") + var closed5 = lang.NewSymbol("andNot") + var closed6 = lang.NewSymbol("unchecked_minus") + var closed7 = lang.NewSymbol("min") + var closed8 = lang.NewSymbol("minusP") + var closed9 = lang.NewSymbol("and") + + ns := lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")) + _ = ns +// normalize-slurp-opts +{ +v0 := lang.NewSymbol("normalize-slurp-opts").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7017), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7017), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("opts"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("string?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("first")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v3}) +v12 := lang.Apply(v7, []any{v11}) +if lang.IsTruthy(v12) { +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("println")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{"WARNING: (slurp f enc) is deprecated, use (slurp f :encoding enc)."}) +_ = v16 +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("first")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v3}) +v21 := lang.NewVector(lang.NewKeyword("encoding"), v20) +v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7022), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(7022), lang.NewKeyword("end-column"), int(30)) +v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v4 = v23 +} else { +v4 = v3 +} +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// with-open +{ +v0 := lang.NewSymbol("with-open").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "bindings => [name init ...]\n\n Evaluates body in a try expression with names bound to the values\n of the inits, and a finally clause that calls (.close name) on each\n name in reverse order.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3832), lang.NewKeyword("end-line"), int(3832))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +var v7 any +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v5}) +if lang.IsTruthy(v11) { +v7 = nil +} else { +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("str")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("first")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v3}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("meta")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v3}) +v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) +v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) +v28 := lang.Apply(lang1.NewIllegalArgumentError, []any{v27}) +panic(v28) +} +_ = v7 +var v29 any +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("even?")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("count")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v5}) +v37 := lang.Apply(v32, []any{v36}) +if lang.IsTruthy(v37) { +v29 = nil +} else { +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("str")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("first")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v3}) +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +} +v47 := v46.Get() +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("meta")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v3}) +v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) +v53 := lang.Apply(v40, []any{v44, " requires ", "an even number of forms in binding vector", " in ", v47, ":", v52}) +v54 := lang.Apply(lang1.NewIllegalArgumentError, []any{v53}) +panic(v54) +} +_ = v29 +_ = nil +var v55 any +v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v57 := v56.FindInternedVar(lang.NewSymbol("=")) +if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) +} +v58 := v57.Get() +v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v60 := v59.FindInternedVar(lang.NewSymbol("count")) +if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) +} +v61 := v60.Get() +v62 := lang.Apply(v61, []any{v5}) +v63 := lang.Apply(v58, []any{v62, int64(0)}) +if lang.IsTruthy(v63) { +v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v65 := v64.FindInternedVar(lang.NewSymbol("seq")) +if v65.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) +} +v66 := v65.Get() +v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v68 := v67.FindInternedVar(lang.NewSymbol("concat")) +if v68.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) +} +v69 := v68.Get() +v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v71 := v70.FindInternedVar(lang.NewSymbol("list")) +if v71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) +} +v72 := v71.Get() +v73 := lang.Apply(v72, []any{lang.NewSymbol("do")}) +v74 := lang.Apply(v69, []any{v73, v6}) +v75 := lang.Apply(v66, []any{v74}) +v55 = v75 +} else { +var v76 any +v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v78 := v77.FindInternedVar(lang.NewSymbol("symbol?")) +if v78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) +} +v79 := v78.Get() +v80 := lang.Apply(v5, []any{int64(0)}) +v81 := lang.Apply(v79, []any{v80}) +if lang.IsTruthy(v81) { +v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v83 := v82.FindInternedVar(lang.NewSymbol("seq")) +if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) +} +v84 := v83.Get() +v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v86 := v85.FindInternedVar(lang.NewSymbol("concat")) +if v86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) +} +v87 := v86.Get() +v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v89 := v88.FindInternedVar(lang.NewSymbol("list")) +if v89.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) +} +v90 := v89.Get() +v91 := lang.Apply(v90, []any{lang.NewSymbol("glojure.core/let")}) +v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v93 := v92.FindInternedVar(lang.NewSymbol("list")) +if v93.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) +} +v94 := v93.Get() +v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v96 := v95.FindInternedVar(lang.NewSymbol("subvec")) +if v96.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) +} +v97 := v96.Get() +v98 := lang.Apply(v97, []any{v5, int64(0), int64(2)}) +v99 := lang.Apply(v94, []any{v98}) +v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v101 := v100.FindInternedVar(lang.NewSymbol("list")) +if v101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) +} +v102 := v101.Get() +v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v104 := v103.FindInternedVar(lang.NewSymbol("seq")) +if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) +} +v105 := v104.Get() +v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v107 := v106.FindInternedVar(lang.NewSymbol("concat")) +if v107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) +} +v108 := v107.Get() +v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v110 := v109.FindInternedVar(lang.NewSymbol("list")) +if v110.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) +} +v111 := v110.Get() +v112 := lang.Apply(v111, []any{lang.NewSymbol("try")}) +v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v114 := v113.FindInternedVar(lang.NewSymbol("list")) +if v114.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) +} +v115 := v114.Get() +v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v117 := v116.FindInternedVar(lang.NewSymbol("seq")) +if v117.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) +} +v118 := v117.Get() +v119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v120 := v119.FindInternedVar(lang.NewSymbol("concat")) +if v120.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v120))) +} +v121 := v120.Get() +v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v123 := v122.FindInternedVar(lang.NewSymbol("list")) +if v123.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) +} +v124 := v123.Get() +v125 := lang.Apply(v124, []any{lang.NewSymbol("glojure.core/with-open")}) +v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v127 := v126.FindInternedVar(lang.NewSymbol("list")) +if v127.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) +} +v128 := v127.Get() +v129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v130 := v129.FindInternedVar(lang.NewSymbol("subvec")) +if v130.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v130))) +} +v131 := v130.Get() +v132 := lang.Apply(v131, []any{v5, int64(2)}) +v133 := lang.Apply(v128, []any{v132}) +v134 := lang.Apply(v121, []any{v125, v133, v6}) +v135 := lang.Apply(v118, []any{v134}) +v136 := lang.Apply(v115, []any{v135}) +v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v138 := v137.FindInternedVar(lang.NewSymbol("list")) +if v138.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) +} +v139 := v138.Get() +v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v141 := v140.FindInternedVar(lang.NewSymbol("seq")) +if v141.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) +} +v142 := v141.Get() +v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v144 := v143.FindInternedVar(lang.NewSymbol("concat")) +if v144.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) +} +v145 := v144.Get() +v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v147 := v146.FindInternedVar(lang.NewSymbol("list")) +if v147.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) +} +v148 := v147.Get() +v149 := lang.Apply(v148, []any{lang.NewSymbol("finally")}) +v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v151 := v150.FindInternedVar(lang.NewSymbol("list")) +if v151.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) +} +v152 := v151.Get() +v153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v154 := v153.FindInternedVar(lang.NewSymbol("seq")) +if v154.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v154))) +} +v155 := v154.Get() +v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v157 := v156.FindInternedVar(lang.NewSymbol("concat")) +if v157.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) +} +v158 := v157.Get() +v159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v160 := v159.FindInternedVar(lang.NewSymbol("list")) +if v160.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v160))) +} +v161 := v160.Get() +v162 := lang.Apply(v161, []any{lang.NewSymbol(".")}) +v163 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v164 := v163.FindInternedVar(lang.NewSymbol("list")) +if v164.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v164))) +} +v165 := v164.Get() +v166 := lang.Apply(v5, []any{int64(0)}) +v167 := lang.Apply(v165, []any{v166}) +v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v169 := v168.FindInternedVar(lang.NewSymbol("list")) +if v169.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) +} +v170 := v169.Get() +v171 := lang.Apply(v170, []any{lang.NewSymbol("close")}) +v172 := lang.Apply(v158, []any{v162, v167, v171}) +v173 := lang.Apply(v155, []any{v172}) +v174 := lang.Apply(v152, []any{v173}) +v175 := lang.Apply(v145, []any{v149, v174}) +v176 := lang.Apply(v142, []any{v175}) +v177 := lang.Apply(v139, []any{v176}) +v178 := lang.Apply(v108, []any{v112, v136, v177}) +v179 := lang.Apply(v105, []any{v178}) +v180 := lang.Apply(v102, []any{v179}) +v181 := lang.Apply(v87, []any{v91, v99, v180}) +v182 := lang.Apply(v84, []any{v181}) +v76 = v182 +} else { +var v183 any +if lang.IsTruthy(lang.NewKeyword("else")) { +v184 := lang.Apply(lang1.NewIllegalArgumentError, []any{"with-open only allows Symbols in bindings"}) +panic(v184) +} else { +v183 = nil +} +v76 = v183 +} +v55 = v76 +} +return v55 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// ns +{ +v0 := lang.NewSymbol("ns").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("docstring?"), lang.NewSymbol("attr-map?"), lang.NewSymbol("references*"))), lang.NewKeyword("doc"), "Sets *ns* to the namespace named by name (unevaluated), creating it\n if needed. references can be zero or more of: (:refer-glojure ...)\n (:require ...) (:use ...) (:import ...) (:load ...) (:gen-class)\n with the syntax of refer-glojure/require/use/import/load/gen-class\n respectively, except the arguments are unevaluated and need not be\n quoted. (:gen-class ...), when supplied, defaults to :name\n corresponding to the ns name, :main true, :impl-ns same as ns, and\n :init-impl-ns true. All options of gen-class are\n supported. The :gen-class directive is ignored when not\n compiling. If :gen-class is not supplied, when compiled only an\n nsname__init.class will be generated. If :refer-glojure is not used, a\n default (refer 'glojure.core) is used. Use of ns is preferred to\n individual calls to in-ns/require/use/import:\n\n (ns foo.bar\n (:refer-glojure :exclude [ancestors printf])\n (:require (glojure.contrib sql combinatorics))\n (:use (my.lib this that))\n (:import (java.util Date Timer Random)\n (java.sql Connection Statement)))", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5785), lang.NewKeyword("end-line"), int(5785))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +var v8 lang.FnFunc +v8 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v9 := args[0] +var v10 any = v9 +_ = v10 +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("seq")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v10}) +var v11 any = v15 +_ = v11 +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("first")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v11}) +var v16 any = v20 +_ = v16 +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("next")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v21}) +var v21 any = v25 +_ = v21 +var v26 any = v16 +_ = v26 +var v27 any = v21 +_ = v27 +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("seq")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("concat")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("list")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("symbol")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("name")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v26}) +v45 := lang.Apply(v40, []any{"glojure.core", v44}) +v46 := lang.Apply(v37, []any{v45}) +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("map")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +} +v49 := v48.Get() +var v50 lang.FnFunc +v50 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v51 := args[0] +v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v53 := v52.FindInternedVar(lang.NewSymbol("list")) +if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) +} +v54 := v53.Get() +v55 := lang.Apply(v54, []any{lang.NewSymbol("quote"), v51}) +return v55 +}) +v51 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5812), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(5812), lang.NewKeyword("end-column"), int(36)) +v52, err := lang.WithMeta(v50, v51.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v53 := lang.Apply(v49, []any{v52, v27}) +v54 := lang.Apply(v34, []any{v46, v53}) +v55 := lang.Apply(v31, []any{v54}) +return v55 +}) +v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5810), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(5812), lang.NewKeyword("end-column"), int(44)) +v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v7 any = v10 +_ = v7 +var v12 any +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("string?")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("first")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v6}) +v20 := lang.Apply(v15, []any{v19}) +if lang.IsTruthy(v20) { +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("first")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v6}) +v12 = v24 +} else { +v12 = nil +} +var v11 any = v12 +_ = v11 +var v26 any +if lang.IsTruthy(v11) { +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("next")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{v25}) +v26 = v30 +} else { +v26 = v25 +} +var v25 any = v26 +_ = v25 +var v32 any +if lang.IsTruthy(v11) { +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("vary-meta")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("assoc")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v35, []any{v31, v38, lang.NewKeyword("doc"), v11}) +v32 = v39 +} else { +v32 = v31 +} +var v31 any = v32 +_ = v31 +var v41 any +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("map?")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +} +v44 := v43.Get() +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("first")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +} +v47 := v46.Get() +v48 := lang.Apply(v47, []any{v25}) +v49 := lang.Apply(v44, []any{v48}) +if lang.IsTruthy(v49) { +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("first")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +} +v52 := v51.Get() +v53 := lang.Apply(v52, []any{v25}) +v41 = v53 +} else { +v41 = nil +} +var v40 any = v41 +_ = v40 +var v55 any +if lang.IsTruthy(v40) { +v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v57 := v56.FindInternedVar(lang.NewSymbol("next")) +if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) +} +v58 := v57.Get() +v59 := lang.Apply(v58, []any{v54}) +v55 = v59 +} else { +v55 = v54 +} +var v54 any = v55 +_ = v54 +var v61 any +if lang.IsTruthy(v40) { +v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v63 := v62.FindInternedVar(lang.NewSymbol("vary-meta")) +if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +} +v64 := v63.Get() +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("merge")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +} +v67 := v66.Get() +v68 := lang.Apply(v64, []any{v60, v67, v40}) +v61 = v68 +} else { +v61 = v60 +} +var v60 any = v61 +_ = v60 +v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v71 := v70.FindInternedVar(lang.NewSymbol("first")) +if v71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) +} +v72 := v71.Get() +v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v74 := v73.FindInternedVar(lang.NewSymbol("filter")) +if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) +} +v75 := v74.Get() +var v76 lang.FnFunc +v76 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v77 := args[0] +v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v79 := v78.FindInternedVar(lang.NewSymbol("=")) +if v79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) +} +v80 := v79.Get() +v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v82 := v81.FindInternedVar(lang.NewSymbol("first")) +if v82.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) +} +v83 := v82.Get() +v84 := lang.Apply(v83, []any{v77}) +v85 := lang.Apply(v80, []any{lang.NewKeyword("gen-class"), v84}) +return v85 +}) +v77 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5823), lang.NewKeyword("column"), int(41), lang.NewKeyword("end-line"), int(5823), lang.NewKeyword("end-column"), int(65)) +v78, err := lang.WithMeta(v76, v77.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v79 := lang.Apply(v75, []any{v78, v54}) +v80 := lang.Apply(v72, []any{v79}) +var v69 any = v80 +_ = v69 +var v82 any +if lang.IsTruthy(v69) { +v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v84 := v83.FindInternedVar(lang.NewSymbol("list*")) +if v84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) +} +v85 := v84.Get() +v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v87 := v86.FindInternedVar(lang.NewSymbol("str")) +if v87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) +} +v88 := v87.Get() +v89 := lang.Apply(v88, []any{v60}) +v90, _ := lang.FieldOrMethod(v89, "replace") +if reflect.TypeOf(v90).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("replace is not a function"))) +} +v91 := lang.Apply(v90, []any{lang.NewChar(45), lang.NewChar(95)}) +v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v93 := v92.FindInternedVar(lang.NewSymbol("next")) +if v93.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) +} +v94 := v93.Get() +v95 := lang.Apply(v94, []any{v69}) +v96 := lang.Apply(v85, []any{lang.NewSymbol("glojure.core/gen-class"), lang.NewKeyword("name"), v91, lang.NewKeyword("impl-ns"), v60, lang.NewKeyword("main"), true, v95}) +v82 = v96 +} else { +v82 = nil +} +var v81 any = v82 +_ = v81 +v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v99 := v98.FindInternedVar(lang.NewSymbol("remove")) +if v99.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) +} +v100 := v99.Get() +var v101 lang.FnFunc +v101 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v102 := args[0] +v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v104 := v103.FindInternedVar(lang.NewSymbol("=")) +if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) +} +v105 := v104.Get() +v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v107 := v106.FindInternedVar(lang.NewSymbol("first")) +if v107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) +} +v108 := v107.Get() +v109 := lang.Apply(v108, []any{v102}) +v110 := lang.Apply(v105, []any{lang.NewKeyword("gen-class"), v109}) +return v110 +}) +v102 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5827), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(5827), lang.NewKeyword("end-column"), int(52)) +v103, err := lang.WithMeta(v101, v102.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v104 := lang.Apply(v100, []any{v103, v97}) +var v97 any = v104 +_ = v97 +v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v107 := v106.FindInternedVar(lang.NewSymbol("meta")) +if v107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) +} +v108 := v107.Get() +v109 := lang.Apply(v108, []any{v60}) +var v105 any = v109 +_ = v105 +v111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v112 := v111.FindInternedVar(lang.NewSymbol("seq")) +if v112.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v112))) +} +v113 := v112.Get() +v114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v115 := v114.FindInternedVar(lang.NewSymbol("concat")) +if v115.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v115))) +} +v116 := v115.Get() +v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v118 := v117.FindInternedVar(lang.NewSymbol("list")) +if v118.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) +} +v119 := v118.Get() +v120 := lang.Apply(v119, []any{lang.NewSymbol("do")}) +v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v122 := v121.FindInternedVar(lang.NewSymbol("list")) +if v122.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) +} +v123 := v122.Get() +v124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v125 := v124.FindInternedVar(lang.NewSymbol("seq")) +if v125.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v125))) +} +v126 := v125.Get() +v127 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v128 := v127.FindInternedVar(lang.NewSymbol("concat")) +if v128.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v128))) +} +v129 := v128.Get() +v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v131 := v130.FindInternedVar(lang.NewSymbol("list")) +if v131.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) +} +v132 := v131.Get() +v133 := lang.Apply(v132, []any{lang.NewSymbol("glojure.core/in-ns")}) +v134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v135 := v134.FindInternedVar(lang.NewSymbol("list")) +if v135.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v135))) +} +v136 := v135.Get() +v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v138 := v137.FindInternedVar(lang.NewSymbol("seq")) +if v138.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) +} +v139 := v138.Get() +v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v141 := v140.FindInternedVar(lang.NewSymbol("concat")) +if v141.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) +} +v142 := v141.Get() +v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v144 := v143.FindInternedVar(lang.NewSymbol("list")) +if v144.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) +} +v145 := v144.Get() +v146 := lang.Apply(v145, []any{lang.NewSymbol("quote")}) +v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v148 := v147.FindInternedVar(lang.NewSymbol("list")) +if v148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) +} +v149 := v148.Get() +v150 := lang.Apply(v149, []any{v60}) +v151 := lang.Apply(v142, []any{v146, v150}) +v152 := lang.Apply(v139, []any{v151}) +v153 := lang.Apply(v136, []any{v152}) +v154 := lang.Apply(v129, []any{v133, v153}) +v155 := lang.Apply(v126, []any{v154}) +v156 := lang.Apply(v123, []any{v155}) +var v157 any +if lang.IsTruthy(v105) { +v158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v159 := v158.FindInternedVar(lang.NewSymbol("seq")) +if v159.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v159))) +} +v160 := v159.Get() +v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v162 := v161.FindInternedVar(lang.NewSymbol("concat")) +if v162.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) +} +v163 := v162.Get() +v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v165 := v164.FindInternedVar(lang.NewSymbol("list")) +if v165.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) +} +v166 := v165.Get() +v167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v168 := v167.FindInternedVar(lang.NewSymbol("seq")) +if v168.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v168))) +} +v169 := v168.Get() +v170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v171 := v170.FindInternedVar(lang.NewSymbol("concat")) +if v171.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v171))) +} +v172 := v171.Get() +v173 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v174 := v173.FindInternedVar(lang.NewSymbol("list")) +if v174.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v174))) +} +v175 := v174.Get() +v176 := lang.Apply(v175, []any{lang.NewSymbol(".ResetMeta")}) +v177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v178 := v177.FindInternedVar(lang.NewSymbol("list")) +if v178.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v178))) +} +v179 := v178.Get() +v180 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v181 := v180.FindInternedVar(lang.NewSymbol("seq")) +if v181.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v181))) +} +v182 := v181.Get() +v183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v184 := v183.FindInternedVar(lang.NewSymbol("concat")) +if v184.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v184))) +} +v185 := v184.Get() +v186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v187 := v186.FindInternedVar(lang.NewSymbol("list")) +if v187.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v187))) +} +v188 := v187.Get() +v189 := lang.Apply(v188, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.FindNamespace")}) +v190 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v191 := v190.FindInternedVar(lang.NewSymbol("list")) +if v191.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v191))) +} +v192 := v191.Get() +v193 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v194 := v193.FindInternedVar(lang.NewSymbol("seq")) +if v194.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v194))) +} +v195 := v194.Get() +v196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v197 := v196.FindInternedVar(lang.NewSymbol("concat")) +if v197.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v197))) +} +v198 := v197.Get() +v199 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v200 := v199.FindInternedVar(lang.NewSymbol("list")) +if v200.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v200))) +} +v201 := v200.Get() +v202 := lang.Apply(v201, []any{lang.NewSymbol("quote")}) +v203 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v204 := v203.FindInternedVar(lang.NewSymbol("list")) +if v204.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v204))) +} +v205 := v204.Get() +v206 := lang.Apply(v205, []any{v60}) +v207 := lang.Apply(v198, []any{v202, v206}) +v208 := lang.Apply(v195, []any{v207}) +v209 := lang.Apply(v192, []any{v208}) +v210 := lang.Apply(v185, []any{v189, v209}) +v211 := lang.Apply(v182, []any{v210}) +v212 := lang.Apply(v179, []any{v211}) +v213 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v214 := v213.FindInternedVar(lang.NewSymbol("list")) +if v214.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v214))) +} +v215 := v214.Get() +v216 := lang.Apply(v215, []any{v105}) +v217 := lang.Apply(v172, []any{v176, v212, v216}) +v218 := lang.Apply(v169, []any{v217}) +v219 := lang.Apply(v166, []any{v218}) +v220 := lang.Apply(v163, []any{v219}) +v221 := lang.Apply(v160, []any{v220}) +v157 = v221 +} else { +v157 = nil +} +v222 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v223 := v222.FindInternedVar(lang.NewSymbol("list")) +if v223.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v223))) +} +v224 := v223.Get() +v225 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v226 := v225.FindInternedVar(lang.NewSymbol("seq")) +if v226.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v226))) +} +v227 := v226.Get() +v228 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v229 := v228.FindInternedVar(lang.NewSymbol("concat")) +if v229.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v229))) +} +v230 := v229.Get() +v231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v232 := v231.FindInternedVar(lang.NewSymbol("list")) +if v232.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v232))) +} +v233 := v232.Get() +v234 := lang.Apply(v233, []any{lang.NewSymbol("glojure.core/with-loading-context")}) +var v235 any +if lang.IsTruthy(v81) { +v236 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v237 := v236.FindInternedVar(lang.NewSymbol("list")) +if v237.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v237))) +} +v238 := v237.Get() +v239 := lang.Apply(v238, []any{v81}) +v235 = v239 +} else { +v235 = nil +} +var v240 any +v242 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v243 := v242.FindInternedVar(lang.NewSymbol("not=")) +if v243.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v243))) +} +v244 := v243.Get() +v245 := lang.Apply(v244, []any{v60, lang.NewSymbol("glojure.core")}) +var v241 any = v245 +_ = v241 +var v247 any +if lang.IsTruthy(v241) { +v248 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v249 := v248.FindInternedVar(lang.NewSymbol("not-any?")) +if v249.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v249))) +} +v250 := v249.Get() +var v251 lang.FnFunc +v251 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v252 := args[0] +v253 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v254 := v253.FindInternedVar(lang.NewSymbol("=")) +if v254.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v254))) +} +v255 := v254.Get() +v256 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v257 := v256.FindInternedVar(lang.NewSymbol("first")) +if v257.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v257))) +} +v258 := v257.Get() +v259 := lang.Apply(v258, []any{v252}) +v260 := lang.Apply(v255, []any{lang.NewKeyword("refer-glojure"), v259}) +return v260 +}) +v252 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5836), lang.NewKeyword("column"), int(58), lang.NewKeyword("end-line"), int(5836), lang.NewKeyword("end-column"), int(86)) +v253, err := lang.WithMeta(v251, v252.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v254 := lang.Apply(v250, []any{v253, v97}) +v247 = v254 +} else { +v247 = v241 +} +if lang.IsTruthy(v247) { +v241 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v242 := v241.FindInternedVar(lang.NewSymbol("seq")) +if v242.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v242))) +} +v243 := v242.Get() +v244 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v245 := v244.FindInternedVar(lang.NewSymbol("concat")) +if v245.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v245))) +} +v246 := v245.Get() +v247 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v248 := v247.FindInternedVar(lang.NewSymbol("list")) +if v248.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v248))) +} +v249 := v248.Get() +v250 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v251 := v250.FindInternedVar(lang.NewSymbol("seq")) +if v251.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v251))) +} +v252 := v251.Get() +v253 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v254 := v253.FindInternedVar(lang.NewSymbol("concat")) +if v254.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v254))) +} +v255 := v254.Get() +v256 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v257 := v256.FindInternedVar(lang.NewSymbol("list")) +if v257.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v257))) +} +v258 := v257.Get() +v259 := lang.Apply(v258, []any{lang.NewSymbol("glojure.core/refer")}) +v260 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v261 := v260.FindInternedVar(lang.NewSymbol("list")) +if v261.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v261))) +} +v262 := v261.Get() +v263 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v264 := v263.FindInternedVar(lang.NewSymbol("seq")) +if v264.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v264))) +} +v265 := v264.Get() +v266 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v267 := v266.FindInternedVar(lang.NewSymbol("concat")) +if v267.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v267))) +} +v268 := v267.Get() +v269 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v270 := v269.FindInternedVar(lang.NewSymbol("list")) +if v270.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v270))) +} +v271 := v270.Get() +v272 := lang.Apply(v271, []any{lang.NewSymbol("quote")}) +v273 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v274 := v273.FindInternedVar(lang.NewSymbol("list")) +if v274.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v274))) +} +v275 := v274.Get() +v276 := lang.Apply(v275, []any{lang.NewSymbol("glojure.core")}) +v277 := lang.Apply(v268, []any{v272, v276}) +v278 := lang.Apply(v265, []any{v277}) +v279 := lang.Apply(v262, []any{v278}) +v280 := lang.Apply(v255, []any{v259, v279}) +v281 := lang.Apply(v252, []any{v280}) +v282 := lang.Apply(v249, []any{v281}) +v283 := lang.Apply(v246, []any{v282}) +v284 := lang.Apply(v243, []any{v283}) +v240 = v284 +} else { +v240 = nil +} +v285 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v286 := v285.FindInternedVar(lang.NewSymbol("map")) +if v286.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v286))) +} +v287 := v286.Get() +v288 := lang.Apply(v287, []any{v7, v97}) +v289 := lang.Apply(v230, []any{v234, v235, v240, v288}) +v290 := lang.Apply(v227, []any{v289}) +v291 := lang.Apply(v224, []any{v290}) +v292 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v293 := v292.FindInternedVar(lang.NewSymbol("list")) +if v293.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v293))) +} +v294 := v293.Get() +v295 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v296 := v295.FindInternedVar(lang.NewSymbol("seq")) +if v296.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v296))) +} +v297 := v296.Get() +v298 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v299 := v298.FindInternedVar(lang.NewSymbol("concat")) +if v299.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v299))) +} +v300 := v299.Get() +v301 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v302 := v301.FindInternedVar(lang.NewSymbol("list")) +if v302.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v302))) +} +v303 := v302.Get() +v304 := lang.Apply(v303, []any{lang.NewSymbol("if")}) +v305 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v306 := v305.FindInternedVar(lang.NewSymbol("list")) +if v306.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v306))) +} +v307 := v306.Get() +v308 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v309 := v308.FindInternedVar(lang.NewSymbol("seq")) +if v309.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v309))) +} +v310 := v309.Get() +v311 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v312 := v311.FindInternedVar(lang.NewSymbol("concat")) +if v312.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v312))) +} +v313 := v312.Get() +v314 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v315 := v314.FindInternedVar(lang.NewSymbol("list")) +if v315.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v315))) +} +v316 := v315.Get() +v317 := lang.Apply(v316, []any{lang.NewSymbol(".Equals")}) +v318 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v319 := v318.FindInternedVar(lang.NewSymbol("list")) +if v319.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v319))) +} +v320 := v319.Get() +v321 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v322 := v321.FindInternedVar(lang.NewSymbol("seq")) +if v322.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v322))) +} +v323 := v322.Get() +v324 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v325 := v324.FindInternedVar(lang.NewSymbol("concat")) +if v325.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v325))) +} +v326 := v325.Get() +v327 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v328 := v327.FindInternedVar(lang.NewSymbol("list")) +if v328.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v328))) +} +v329 := v328.Get() +v330 := lang.Apply(v329, []any{lang.NewSymbol("quote")}) +v331 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v332 := v331.FindInternedVar(lang.NewSymbol("list")) +if v332.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v332))) +} +v333 := v332.Get() +v334 := lang.Apply(v333, []any{v60}) +v335 := lang.Apply(v326, []any{v330, v334}) +v336 := lang.Apply(v323, []any{v335}) +v337 := lang.Apply(v320, []any{v336}) +v338 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v339 := v338.FindInternedVar(lang.NewSymbol("list")) +if v339.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v339))) +} +v340 := v339.Get() +v341 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v342 := v341.FindInternedVar(lang.NewSymbol("seq")) +if v342.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v342))) +} +v343 := v342.Get() +v344 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v345 := v344.FindInternedVar(lang.NewSymbol("concat")) +if v345.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v345))) +} +v346 := v345.Get() +v347 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v348 := v347.FindInternedVar(lang.NewSymbol("list")) +if v348.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v348))) +} +v349 := v348.Get() +v350 := lang.Apply(v349, []any{lang.NewSymbol("quote")}) +v351 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v352 := v351.FindInternedVar(lang.NewSymbol("list")) +if v352.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v352))) +} +v353 := v352.Get() +v354 := lang.Apply(v353, []any{lang.NewSymbol("glojure.core")}) +v355 := lang.Apply(v346, []any{v350, v354}) +v356 := lang.Apply(v343, []any{v355}) +v357 := lang.Apply(v340, []any{v356}) +v358 := lang.Apply(v313, []any{v317, v337, v357}) +v359 := lang.Apply(v310, []any{v358}) +v360 := lang.Apply(v307, []any{v359}) +v361 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v362 := v361.FindInternedVar(lang.NewSymbol("list")) +if v362.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v362))) +} +v363 := v362.Get() +v364 := lang.Apply(v363, []any{nil}) +v365 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v366 := v365.FindInternedVar(lang.NewSymbol("list")) +if v366.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v366))) +} +v367 := v366.Get() +v368 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v369 := v368.FindInternedVar(lang.NewSymbol("seq")) +if v369.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v369))) +} +v370 := v369.Get() +v371 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v372 := v371.FindInternedVar(lang.NewSymbol("concat")) +if v372.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v372))) +} +v373 := v372.Get() +v374 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v375 := v374.FindInternedVar(lang.NewSymbol("list")) +if v375.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v375))) +} +v376 := v375.Get() +v377 := lang.Apply(v376, []any{lang.NewSymbol("do")}) +v378 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v379 := v378.FindInternedVar(lang.NewSymbol("list")) +if v379.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v379))) +} +v380 := v379.Get() +v381 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v382 := v381.FindInternedVar(lang.NewSymbol("seq")) +if v382.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v382))) +} +v383 := v382.Get() +v384 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v385 := v384.FindInternedVar(lang.NewSymbol("concat")) +if v385.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v385))) +} +v386 := v385.Get() +v387 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v388 := v387.FindInternedVar(lang.NewSymbol("list")) +if v388.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v388))) +} +v389 := v388.Get() +v390 := lang.Apply(v389, []any{lang.NewSymbol("glojure.core/dosync")}) +v391 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v392 := v391.FindInternedVar(lang.NewSymbol("list")) +if v392.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v392))) +} +v393 := v392.Get() +v394 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v395 := v394.FindInternedVar(lang.NewSymbol("seq")) +if v395.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v395))) +} +v396 := v395.Get() +v397 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v398 := v397.FindInternedVar(lang.NewSymbol("concat")) +if v398.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v398))) +} +v399 := v398.Get() +v400 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v401 := v400.FindInternedVar(lang.NewSymbol("list")) +if v401.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v401))) +} +v402 := v401.Get() +v403 := lang.Apply(v402, []any{lang.NewSymbol("glojure.core/commute")}) +v404 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v405 := v404.FindInternedVar(lang.NewSymbol("list")) +if v405.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v405))) +} +v406 := v405.Get() +v407 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v408 := v407.FindInternedVar(lang.NewSymbol("seq")) +if v408.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v408))) +} +v409 := v408.Get() +v410 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v411 := v410.FindInternedVar(lang.NewSymbol("concat")) +if v411.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v411))) +} +v412 := v411.Get() +v413 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v414 := v413.FindInternedVar(lang.NewSymbol("list")) +if v414.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v414))) +} +v415 := v414.Get() +v416 := lang.Apply(v415, []any{lang.NewSymbol("glojure.core/deref")}) +v417 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v418 := v417.FindInternedVar(lang.NewSymbol("list")) +if v418.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v418))) +} +v419 := v418.Get() +v420 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v421 := v420.FindInternedVar(lang.NewSymbol("seq")) +if v421.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v421))) +} +v422 := v421.Get() +v423 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v424 := v423.FindInternedVar(lang.NewSymbol("concat")) +if v424.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v424))) +} +v425 := v424.Get() +v426 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v427 := v426.FindInternedVar(lang.NewSymbol("list")) +if v427.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v427))) +} +v428 := v427.Get() +v429 := lang.Apply(v428, []any{lang.NewSymbol("var")}) +v430 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v431 := v430.FindInternedVar(lang.NewSymbol("list")) +if v431.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v431))) +} +v432 := v431.Get() +v433 := lang.Apply(v432, []any{lang.NewSymbol("glojure.core/*loaded-libs*")}) +v434 := lang.Apply(v425, []any{v429, v433}) +v435 := lang.Apply(v422, []any{v434}) +v436 := lang.Apply(v419, []any{v435}) +v437 := lang.Apply(v412, []any{v416, v436}) +v438 := lang.Apply(v409, []any{v437}) +v439 := lang.Apply(v406, []any{v438}) +v440 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v441 := v440.FindInternedVar(lang.NewSymbol("list")) +if v441.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v441))) +} +v442 := v441.Get() +v443 := lang.Apply(v442, []any{lang.NewSymbol("glojure.core/conj")}) +v444 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v445 := v444.FindInternedVar(lang.NewSymbol("list")) +if v445.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v445))) +} +v446 := v445.Get() +v447 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v448 := v447.FindInternedVar(lang.NewSymbol("seq")) +if v448.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v448))) +} +v449 := v448.Get() +v450 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v451 := v450.FindInternedVar(lang.NewSymbol("concat")) +if v451.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v451))) +} +v452 := v451.Get() +v453 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v454 := v453.FindInternedVar(lang.NewSymbol("list")) +if v454.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v454))) +} +v455 := v454.Get() +v456 := lang.Apply(v455, []any{lang.NewSymbol("quote")}) +v457 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v458 := v457.FindInternedVar(lang.NewSymbol("list")) +if v458.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v458))) +} +v459 := v458.Get() +v460 := lang.Apply(v459, []any{v60}) +v461 := lang.Apply(v452, []any{v456, v460}) +v462 := lang.Apply(v449, []any{v461}) +v463 := lang.Apply(v446, []any{v462}) +v464 := lang.Apply(v399, []any{v403, v439, v443, v463}) +v465 := lang.Apply(v396, []any{v464}) +v466 := lang.Apply(v393, []any{v465}) +v467 := lang.Apply(v386, []any{v390, v466}) +v468 := lang.Apply(v383, []any{v467}) +v469 := lang.Apply(v380, []any{v468}) +v470 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v471 := v470.FindInternedVar(lang.NewSymbol("list")) +if v471.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v471))) +} +v472 := v471.Get() +v473 := lang.Apply(v472, []any{nil}) +v474 := lang.Apply(v373, []any{v377, v469, v473}) +v475 := lang.Apply(v370, []any{v474}) +v476 := lang.Apply(v367, []any{v475}) +v477 := lang.Apply(v300, []any{v304, v360, v364, v476}) +v478 := lang.Apply(v297, []any{v477}) +v479 := lang.Apply(v294, []any{v478}) +v480 := lang.Apply(v116, []any{v120, v156, v157, v291, v479}) +v481 := lang.Apply(v113, []any{v480}) +return v481 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// print-meta +{ +v0 := lang.NewSymbol("print-meta").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(70), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(70), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("meta")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v3}) +var v5 any = v9 +_ = v5 +var v11 any +if lang.IsTruthy(v5) { +var v12 any = v5 +_ = v12 +var v14 any +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("pos?")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("count")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v12}) +v23 := lang.Apply(v18, []any{v22}) +var v15 any = v23 +_ = v15 +var v25 any +if lang.IsTruthy(v15) { +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("*print-dup*")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +var v26 any = v29 +_ = v26 +var v31 any +if lang.IsTruthy(v26) { +v31 = v26 +} else { +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("*print-meta*")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +var v32 any = v35 +_ = v32 +var v37 any +if lang.IsTruthy(v32) { +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("*print-readably*")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v37 = v40 +} else { +v37 = v32 +} +v31 = v37 +} +v25 = v31 +} else { +v25 = v15 +} +if lang.IsTruthy(v25) { +v15 := lang.Apply(lang1.WriteWriter, []any{v4, "^"}) +_ = v15 +var v16 any +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("=")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("count")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v12}) +v25 := lang.Apply(v20, []any{v24, int64(1)}) +var v17 any = v25 +_ = v17 +var v27 any +if lang.IsTruthy(v17) { +v28 := lang.Apply(lang.NewKeyword("tag"), []any{v12}) +v27 = v28 +} else { +v27 = v17 +} +if lang.IsTruthy(v27) { +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("pr-on")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(lang.NewKeyword("tag"), []any{v12}) +v21 := lang.Apply(v19, []any{v20, v4}) +v16 = v21 +} else { +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("pr-on")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v12, v4}) +v16 = v25 +} +_ = v16 +v26 := lang.Apply(lang1.WriteWriter, []any{v4, " "}) +v14 = v26 +} else { +v14 = nil +} +v11 = v14 +} else { +v11 = nil +} +return v11 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// peek +{ +v0 := lang.NewSymbol("peek").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "For a list or queue, same as first, for a vector, same as, but much\n more efficient than, last. If the collection is empty, returns nil.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1455), lang.NewKeyword("end-line"), int(1455))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, _ := lang.FieldOrMethod(runtime3.RT, "Peek") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Peek is not a function"))) +} +v5 := lang.Apply(v4, []any{v3}) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// merge-hash-collisions +{ +v0 := lang.NewSymbol("merge-hash-collisions").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr-sym"), lang.NewSymbol("default"), lang.NewSymbol("tests"), lang.NewSymbol("thens"))), lang.NewKeyword("doc"), "Takes a case expression, default expression, and a sequence of test constants\n and a corresponding sequence of then expressions. Returns a tuple of\n [tests thens skip-check-set] where no tests have the same hash. Each set of\n input test constants with the same hash is replaced with a single test\n constant (the case int), and their respective thens are combined into:\n (condp = expr\n test-1 then-1\n ...\n test-n then-n\n default).\n The skip-check is a set of case ints for which post-switch equivalence\n checking must not be done (the cases holding the above condp thens).", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6690), lang.NewKeyword("end-line"), int(6690), lang.NewKeyword("private"), true)).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v9 := lang.NewMap() +v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6704), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(6704), lang.NewKeyword("end-column"), int(27)) +v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v8 any = v11 +_ = v8 +var v12 any = v5 +_ = v12 +var v13 any = v6 +_ = v13 +var v14 any +for { +var v15 any +var v16 any = v12 +_ = v16 +var v18 any +if lang.IsTruthy(v16) { +v18 = v13 +} else { +v18 = v16 +} +if lang.IsTruthy(v18) { +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("update")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("first")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.Apply(v22, []any{v12}) +v24 := lang.Apply(lang1.Hash, []any{v23}) +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("fnil")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("conj")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.NewVector() +v32 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6707), lang.NewKeyword("column"), int(102), lang.NewKeyword("end-line"), int(6707), lang.NewKeyword("end-column"), int(103)) +v33, err := lang.WithMeta(v31, v32.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v34 := lang.Apply(v27, []any{v30, v33}) +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("first")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v37, []any{v12}) +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("first")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +} +v41 := v40.Get() +v42 := lang.Apply(v41, []any{v13}) +v43 := lang.NewVector(v38, v42) +v44 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6707), lang.NewKeyword("column"), int(106), lang.NewKeyword("end-line"), int(6707), lang.NewKeyword("end-column"), int(128)) +v45, err := lang.WithMeta(v43, v44.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v46 := lang.Apply(v19, []any{v8, v24, v34, v45}) +var v16 any = v46 +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("next")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v12}) +var v47 any = v51 +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("next")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +} +v55 := v54.Get() +v56 := lang.Apply(v55, []any{v13}) +var v52 any = v56 +v8 = v16 +v12 = v47 +v13 = v52 +continue +} else { +v15 = v8 +} +v14 = v15 + break +} +var v7 any = v14 +_ = v7 +var v9 lang.FnFunc +v9 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v10 := args[0] +v11 := args[1] +v12 := args[2] +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("mapcat")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +var v17 lang.FnFunc +v17 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v18 := args[0] +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("first")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v18}) +v26 := lang.Apply(v21, []any{lang.NewSymbol("quote"), v25}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("second")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{v18}) +v31 := lang.NewVector(v26, v30) +v32 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6711), lang.NewKeyword("column"), int(56), lang.NewKeyword("end-line"), int(6711), lang.NewKeyword("end-column"), int(93)) +v33, err := lang.WithMeta(v31, v32.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v33 +}) +v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6711), lang.NewKeyword("column"), int(47), lang.NewKeyword("end-line"), int(6711), lang.NewKeyword("end-column"), int(94)) +v19, err := lang.WithMeta(v17, v18.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v20 := lang.Apply(v16, []any{v19, v12}) +var v13 any = v20 +_ = v13 +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("seq")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("concat")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("list")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/condp")}) +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{lang.NewSymbol("glojure.core/=")}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v3}) +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v4}) +v44 := lang.Apply(v27, []any{v31, v35, v39, v13, v43}) +v45 := lang.Apply(v24, []any{v44}) +var v21 any = v45 +_ = v21 +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("assoc")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +} +v49 := v48.Get() +v50 := lang.Apply(v49, []any{v10, v11, v21}) +return v50 +}) +v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6710), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(6713), lang.NewKeyword("end-column"), int(42)) +v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v8 any = v11 +_ = v8 +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("reduce1")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +var v16 lang.FnFunc +v16 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v17 := args[0] +v18 := args[1] +var v19 any = v18 +_ = v19 +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("nth")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v19, int64(0), nil}) +var v20 any = v24 +_ = v20 +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("nth")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.Apply(v28, []any{v19, int64(1), nil}) +var v25 any = v29 +_ = v25 +var v31 any +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("==")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("count")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v37, []any{v25}) +v39 := lang.Apply(v34, []any{int64(1), v38}) +if lang.IsTruthy(v39) { +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("assoc")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("ffirst")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +} +v45 := v44.Get() +v46 := lang.Apply(v45, []any{v25}) +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("second")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +} +v49 := v48.Get() +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("first")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +} +v52 := v51.Get() +v53 := lang.Apply(v52, []any{v25}) +v54 := lang.Apply(v49, []any{v53}) +v55 := lang.Apply(v42, []any{v17, v46, v54}) +v31 = v55 +} else { +v56 := lang.Apply(v8, []any{v17, v20, v25}) +v31 = v56 +} +return v31 +}) +v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6715), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(6718), lang.NewKeyword("end-column"), int(45)) +v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v19 := lang.NewMap() +v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6719), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(6719), lang.NewKeyword("end-column"), int(17)) +v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v22 := lang.Apply(v15, []any{v18, v21, v7}) +var v12 any = v22 +_ = v12 +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("into1")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.CreatePersistentTreeSet() +v28 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6723), lang.NewKeyword("column"), int(29), lang.NewKeyword("end-line"), int(6723), lang.NewKeyword("end-column"), int(31)) +v29, err := lang.WithMeta(v27, v28.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("map")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("first")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("filter")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +var v39 lang.FnFunc +v39 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v40 := args[0] +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("<")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("count")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("second")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +} +v49 := v48.Get() +v50 := lang.Apply(v49, []any{v40}) +v51 := lang.Apply(v46, []any{v50}) +v52 := lang.Apply(v43, []any{int64(1), v51}) +return v52 +}) +v40 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6721), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(6721), lang.NewKeyword("end-column"), int(54)) +v41, err := lang.WithMeta(v39, v40.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v42 := lang.Apply(v38, []any{v41, v7}) +v43 := lang.Apply(v32, []any{v35, v42}) +v44 := lang.Apply(v26, []any{v29, v43}) +var v23 any = v44 +_ = v23 +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("keys")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +} +v48 := v47.Get() +v49 := lang.Apply(v48, []any{v12}) +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("vals")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +} +v52 := v51.Get() +v53 := lang.Apply(v52, []any{v12}) +v54 := lang.NewVector(v49, v53, v23) +v55 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6724), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(6724), lang.NewKeyword("end-column"), int(40)) +v56, err := lang.WithMeta(v54, v55.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v56 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// butlast +{ +v0 := lang.NewSymbol("butlast").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return a seq of all but the last item in coll, in linear time", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(272), lang.NewKeyword("end-line"), int(276))).(*lang.Symbol) +var v2 lang.FnFunc +{ // function butlast +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v6 := lang.NewVector() +v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(277), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(277), lang.NewKeyword("end-column"), int(24)) +v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v5 any = v8 +_ = v5 +var v9 any = v9 +_ = v9 +var v10 any +for { +var v11 any +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("next")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v9}) +if lang.IsTruthy(v15) { +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("conj")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("first")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.Apply(v22, []any{v9}) +v24 := lang.Apply(v19, []any{v5, v23}) +var v16 any = v24 +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("next")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.Apply(v28, []any{v9}) +var v25 any = v29 +v5 = v16 +v9 = v25 +continue +} else { +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("seq")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.Apply(v32, []any{v5}) +v11 = v33 +} +v10 = v11 + break +} +return v10 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(276), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(280), lang.NewKeyword("end-column"), int(27))).(lang.FnFunc) +v3 := v2 +_ = v3 +} +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// find +{ +v0 := lang.NewSymbol("find").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"))), lang.NewKeyword("doc"), "Returns the map entry for key, or nil if key not present.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1530), lang.NewKeyword("end-line"), int(1530))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5, _ := lang.FieldOrMethod(runtime3.RT, "Find") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Find is not a function"))) +} +v6 := lang.Apply(v5, []any{v3, v4}) +return v6 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// = +{ +var v1 lang.FnFunc +{ // function =__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("concat")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("list")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol("glojure.lang.Util")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{lang.NewSymbol("glojure.core/equiv")}) +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{v3}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{v4}) +v31 := lang.Apply(v10, []any{v14, v18, v22, v26, v30}) +v32 := lang.Apply(v7, []any{v31}) +return v32 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("=").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Equality. Returns true if x equals y, false if not. Same as\n Java x.equals(y) except it also works for nil, and compares\n numbers and collections in a type-independent manner. Clojure's immutable data\n structures define equals() (and thus =) as a value, not an identity,\n comparison.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(776), lang.NewKeyword("end-line"), int(776))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v4 := args[0] +return true + case 2: +v4 := args[0] +v5 := args[1] +v6 := lang.Apply(lang1.Equiv, []any{v4, v5}) +return v6 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := args[1] +v6 := lang.NewList(args[2:]...) +recur_loop_126: +var v7 any +v8 := lang.Apply(lang1.Equiv, []any{v4, v5}) +if lang.IsTruthy(v8) { +var v9 any +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("next")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{v6}) +if lang.IsTruthy(v13) { +var v14 any = v5 +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("first")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v6}) +var v15 any = v19 +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("next")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v6}) +var v20 any = v24 +v4 = v14 +v5 = v15 +v6 = v20 +goto recur_loop_126 +} else { +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("first")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.Apply(v27, []any{v6}) +v29 := lang.Apply(lang1.Equiv, []any{v5, v28}) +v9 = v29 +} +v7 = v9 +} else { +v7 = false +} +return v7 + } +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// rand-int +{ +v0 := lang.NewSymbol("rand-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns a random integer between 0 (inclusive) and n (exclusive).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4943), lang.NewKeyword("end-line"), int(4943))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("int")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("rand")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v3}) +v11 := lang.Apply(v6, []any{v10}) +return v11 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// fnext +{ +v0 := lang.NewSymbol("fnext").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Same as (first (next x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(112), lang.NewKeyword("end-line"), int(116))).(*lang.Symbol) +var v2 lang.FnFunc +{ // function fnext +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("first")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("next")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v4}) +v12 := lang.Apply(v7, []any{v11}) +return v12 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(116), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(116), lang.NewKeyword("end-column"), int(47))).(lang.FnFunc) +v3 := v2 +_ = v3 +} +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// error-handler +{ +v0 := lang.NewSymbol("error-handler").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("doc"), "Returns the error-handler of agent a, or nil if there is none.\n See set-error-handler!", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2202), lang.NewKeyword("end-line"), int(2202))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, ok := lang.FieldOrMethod(v3, "getErrorHandler") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getErrorHandler"))) +} +var v5 any +switch reflect.TypeOf(v4).Kind() { +case reflect.Func: + v5 = lang.Apply(v4, nil) +default: + v5 = v4 +} +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// zero? +{ +var v1 lang.FnFunc +{ // function zero?__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/isZero")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v3}) +v35 := lang.Apply(v26, []any{v30, v34}) +v36 := lang.Apply(v23, []any{v35}) +v37 := lang.Apply(v20, []any{v36}) +v38 := lang.Apply(v9, []any{v13, v17, v37}) +v39 := lang.Apply(v6, []any{v38}) +return v39 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("zero?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns true if num is zero, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(860), lang.NewKeyword("end-line"), int(860))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "isZero") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("isZero is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// use +{ +v0 := lang.NewSymbol("use").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Like 'require, but also refers to each lib's namespace using\n glojure.core/refer. Use :use in the ns macro in preference to calling\n this directly.\n\n 'use accepts additional options in libspecs: :exclude, :only, :rename.\n The arguments and semantics for :exclude, :only, and :rename are the same\n as those documented for glojure.core/refer.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6122), lang.NewKeyword("end-line"), int(6122))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.NewList(args[0:]...) +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("apply")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("load-libs")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v6, []any{v9, lang.NewKeyword("require"), lang.NewKeyword("use"), v3}) +return v10 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// amap +{ +v0 := lang.NewSymbol("amap").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("idx"), lang.NewSymbol("ret"), lang.NewSymbol("expr"))), lang.NewKeyword("doc"), "Maps an expression across an array a, using an index named idx, and\n return value named ret, initialized to a clone of a, then setting \n each element of ret to the evaluation of expr, returning the new \n array ret.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5273), lang.NewKeyword("end-line"), int(5273))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 6 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := args[4] +v8 := args[5] +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("seq")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("concat")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol("glojure.core/let")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("apply")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("vector")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("seq")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("concat")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("list")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.Apply(v36, []any{lang.NewSymbol("a__0__auto__")}) +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("list")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.Apply(v40, []any{v5}) +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("list")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +} +v44 := v43.Get() +v45 := lang.Apply(v44, []any{lang.NewSymbol("l__1__auto__")}) +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("list")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +} +v48 := v47.Get() +v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v50 := v49.FindInternedVar(lang.NewSymbol("seq")) +if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) +} +v51 := v50.Get() +v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v53 := v52.FindInternedVar(lang.NewSymbol("concat")) +if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) +} +v54 := v53.Get() +v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v56 := v55.FindInternedVar(lang.NewSymbol("list")) +if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) +} +v57 := v56.Get() +v58 := lang.Apply(v57, []any{lang.NewSymbol("glojure.core/alength")}) +v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v60 := v59.FindInternedVar(lang.NewSymbol("list")) +if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) +} +v61 := v60.Get() +v62 := lang.Apply(v61, []any{lang.NewSymbol("a__0__auto__")}) +v63 := lang.Apply(v54, []any{v58, v62}) +v64 := lang.Apply(v51, []any{v63}) +v65 := lang.Apply(v48, []any{v64}) +v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v67 := v66.FindInternedVar(lang.NewSymbol("list")) +if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) +} +v68 := v67.Get() +v69 := lang.Apply(v68, []any{v7}) +v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v71 := v70.FindInternedVar(lang.NewSymbol("list")) +if v71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) +} +v72 := v71.Get() +v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v74 := v73.FindInternedVar(lang.NewSymbol("seq")) +if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) +} +v75 := v74.Get() +v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v77 := v76.FindInternedVar(lang.NewSymbol("concat")) +if v77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) +} +v78 := v77.Get() +v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v80 := v79.FindInternedVar(lang.NewSymbol("list")) +if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) +} +v81 := v80.Get() +v82 := lang.Apply(v81, []any{lang.NewSymbol("glojure.core/aclone")}) +v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v84 := v83.FindInternedVar(lang.NewSymbol("list")) +if v84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) +} +v85 := v84.Get() +v86 := lang.Apply(v85, []any{lang.NewSymbol("a__0__auto__")}) +v87 := lang.Apply(v78, []any{v82, v86}) +v88 := lang.Apply(v75, []any{v87}) +v89 := lang.Apply(v72, []any{v88}) +v90 := lang.Apply(v33, []any{v37, v41, v45, v65, v69, v89}) +v91 := lang.Apply(v30, []any{v90}) +v92 := lang.Apply(v24, []any{v27, v91}) +v93 := lang.Apply(v21, []any{v92}) +v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v95 := v94.FindInternedVar(lang.NewSymbol("list")) +if v95.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) +} +v96 := v95.Get() +v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v98 := v97.FindInternedVar(lang.NewSymbol("seq")) +if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) +} +v99 := v98.Get() +v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v101 := v100.FindInternedVar(lang.NewSymbol("concat")) +if v101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) +} +v102 := v101.Get() +v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v104 := v103.FindInternedVar(lang.NewSymbol("list")) +if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) +} +v105 := v104.Get() +v106 := lang.Apply(v105, []any{lang.NewSymbol("glojure.core/loop")}) +v107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v108 := v107.FindInternedVar(lang.NewSymbol("list")) +if v108.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v108))) +} +v109 := v108.Get() +v110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v111 := v110.FindInternedVar(lang.NewSymbol("apply")) +if v111.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v111))) +} +v112 := v111.Get() +v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v114 := v113.FindInternedVar(lang.NewSymbol("vector")) +if v114.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) +} +v115 := v114.Get() +v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v117 := v116.FindInternedVar(lang.NewSymbol("seq")) +if v117.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) +} +v118 := v117.Get() +v119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v120 := v119.FindInternedVar(lang.NewSymbol("concat")) +if v120.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v120))) +} +v121 := v120.Get() +v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v123 := v122.FindInternedVar(lang.NewSymbol("list")) +if v123.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) +} +v124 := v123.Get() +v125 := lang.Apply(v124, []any{v6}) +v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v127 := v126.FindInternedVar(lang.NewSymbol("list")) +if v127.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) +} +v128 := v127.Get() +v129 := lang.Apply(v128, []any{int64(0)}) +v130 := lang.Apply(v121, []any{v125, v129}) +v131 := lang.Apply(v118, []any{v130}) +v132 := lang.Apply(v112, []any{v115, v131}) +v133 := lang.Apply(v109, []any{v132}) +v134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v135 := v134.FindInternedVar(lang.NewSymbol("list")) +if v135.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v135))) +} +v136 := v135.Get() +v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v138 := v137.FindInternedVar(lang.NewSymbol("seq")) +if v138.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) +} +v139 := v138.Get() +v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v141 := v140.FindInternedVar(lang.NewSymbol("concat")) +if v141.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) +} +v142 := v141.Get() +v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v144 := v143.FindInternedVar(lang.NewSymbol("list")) +if v144.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) +} +v145 := v144.Get() +v146 := lang.Apply(v145, []any{lang.NewSymbol("if")}) +v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v148 := v147.FindInternedVar(lang.NewSymbol("list")) +if v148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) +} +v149 := v148.Get() +v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v151 := v150.FindInternedVar(lang.NewSymbol("seq")) +if v151.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) +} +v152 := v151.Get() +v153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v154 := v153.FindInternedVar(lang.NewSymbol("concat")) +if v154.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v154))) +} +v155 := v154.Get() +v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v157 := v156.FindInternedVar(lang.NewSymbol("list")) +if v157.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) +} +v158 := v157.Get() +v159 := lang.Apply(v158, []any{lang.NewSymbol("glojure.core/<")}) +v160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v161 := v160.FindInternedVar(lang.NewSymbol("list")) +if v161.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v161))) +} +v162 := v161.Get() +v163 := lang.Apply(v162, []any{v6}) +v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v165 := v164.FindInternedVar(lang.NewSymbol("list")) +if v165.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) +} +v166 := v165.Get() +v167 := lang.Apply(v166, []any{lang.NewSymbol("l__1__auto__")}) +v168 := lang.Apply(v155, []any{v159, v163, v167}) +v169 := lang.Apply(v152, []any{v168}) +v170 := lang.Apply(v149, []any{v169}) +v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v172 := v171.FindInternedVar(lang.NewSymbol("list")) +if v172.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) +} +v173 := v172.Get() +v174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v175 := v174.FindInternedVar(lang.NewSymbol("seq")) +if v175.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v175))) +} +v176 := v175.Get() +v177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v178 := v177.FindInternedVar(lang.NewSymbol("concat")) +if v178.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v178))) +} +v179 := v178.Get() +v180 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v181 := v180.FindInternedVar(lang.NewSymbol("list")) +if v181.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v181))) +} +v182 := v181.Get() +v183 := lang.Apply(v182, []any{lang.NewSymbol("do")}) +v184 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v185 := v184.FindInternedVar(lang.NewSymbol("list")) +if v185.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v185))) +} +v186 := v185.Get() +v187 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v188 := v187.FindInternedVar(lang.NewSymbol("seq")) +if v188.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v188))) +} +v189 := v188.Get() +v190 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v191 := v190.FindInternedVar(lang.NewSymbol("concat")) +if v191.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v191))) +} +v192 := v191.Get() +v193 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v194 := v193.FindInternedVar(lang.NewSymbol("list")) +if v194.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v194))) +} +v195 := v194.Get() +v196 := lang.Apply(v195, []any{lang.NewSymbol("glojure.core/aset")}) +v197 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v198 := v197.FindInternedVar(lang.NewSymbol("list")) +if v198.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v198))) +} +v199 := v198.Get() +v200 := lang.Apply(v199, []any{v7}) +v201 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v202 := v201.FindInternedVar(lang.NewSymbol("list")) +if v202.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v202))) +} +v203 := v202.Get() +v204 := lang.Apply(v203, []any{v6}) +v205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v206 := v205.FindInternedVar(lang.NewSymbol("list")) +if v206.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v206))) +} +v207 := v206.Get() +v208 := lang.Apply(v207, []any{v8}) +v209 := lang.Apply(v192, []any{v196, v200, v204, v208}) +v210 := lang.Apply(v189, []any{v209}) +v211 := lang.Apply(v186, []any{v210}) +v212 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v213 := v212.FindInternedVar(lang.NewSymbol("list")) +if v213.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v213))) +} +v214 := v213.Get() +v215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v216 := v215.FindInternedVar(lang.NewSymbol("seq")) +if v216.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v216))) +} +v217 := v216.Get() +v218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v219 := v218.FindInternedVar(lang.NewSymbol("concat")) +if v219.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v219))) +} +v220 := v219.Get() +v221 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v222 := v221.FindInternedVar(lang.NewSymbol("list")) +if v222.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v222))) +} +v223 := v222.Get() +v224 := lang.Apply(v223, []any{lang.NewSymbol("recur")}) +v225 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v226 := v225.FindInternedVar(lang.NewSymbol("list")) +if v226.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v226))) +} +v227 := v226.Get() +v228 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v229 := v228.FindInternedVar(lang.NewSymbol("seq")) +if v229.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v229))) +} +v230 := v229.Get() +v231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v232 := v231.FindInternedVar(lang.NewSymbol("concat")) +if v232.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v232))) +} +v233 := v232.Get() +v234 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v235 := v234.FindInternedVar(lang.NewSymbol("list")) +if v235.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v235))) +} +v236 := v235.Get() +v237 := lang.Apply(v236, []any{lang.NewSymbol("glojure.core/unchecked-inc")}) +v238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v239 := v238.FindInternedVar(lang.NewSymbol("list")) +if v239.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v239))) +} +v240 := v239.Get() +v241 := lang.Apply(v240, []any{v6}) +v242 := lang.Apply(v233, []any{v237, v241}) +v243 := lang.Apply(v230, []any{v242}) +v244 := lang.Apply(v227, []any{v243}) +v245 := lang.Apply(v220, []any{v224, v244}) +v246 := lang.Apply(v217, []any{v245}) +v247 := lang.Apply(v214, []any{v246}) +v248 := lang.Apply(v179, []any{v183, v211, v247}) +v249 := lang.Apply(v176, []any{v248}) +v250 := lang.Apply(v173, []any{v249}) +v251 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v252 := v251.FindInternedVar(lang.NewSymbol("list")) +if v252.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v252))) +} +v253 := v252.Get() +v254 := lang.Apply(v253, []any{v7}) +v255 := lang.Apply(v142, []any{v146, v170, v250, v254}) +v256 := lang.Apply(v139, []any{v255}) +v257 := lang.Apply(v136, []any{v256}) +v258 := lang.Apply(v102, []any{v106, v133, v257}) +v259 := lang.Apply(v99, []any{v258}) +v260 := lang.Apply(v96, []any{v259}) +v261 := lang.Apply(v14, []any{v18, v93, v260}) +v262 := lang.Apply(v11, []any{v261}) +return v262 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// ns-unalias +{ +v0 := lang.NewSymbol("ns-unalias").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Removes the alias for the symbol from the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4280), lang.NewKeyword("end-line"), int(4280))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("the-ns")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +v9, _ := lang.FieldOrMethod(v8, "removeAlias") +if reflect.TypeOf(v9).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("removeAlias is not a function"))) +} +v10 := lang.Apply(v9, []any{v4}) +return v10 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// def-aset +{ +v0 := lang.NewSymbol("def-aset").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("method"), lang.NewSymbol("coerce"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3935), lang.NewKeyword("end-line"), int(3936), lang.NewKeyword("private"), true)).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 5 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := args[4] +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("seq")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("concat")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("glojure.core/defn")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, []any{v5}) +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("list")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("apply")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("hash-map")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("seq")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("concat")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("list")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.Apply(v39, []any{lang.NewKeyword("arglists")}) +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("list")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("seq")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("concat")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +} +v49 := v48.Get() +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("list")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +} +v52 := v51.Get() +v53 := lang.Apply(v52, []any{lang.NewSymbol("quote")}) +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("list")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +} +v56 := v55.Get() +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("seq")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +} +v59 := v58.Get() +v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v61 := v60.FindInternedVar(lang.NewSymbol("concat")) +if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) +} +v62 := v61.Get() +v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v64 := v63.FindInternedVar(lang.NewSymbol("list")) +if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) +} +v65 := v64.Get() +v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v67 := v66.FindInternedVar(lang.NewSymbol("apply")) +if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) +} +v68 := v67.Get() +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("vector")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +} +v71 := v70.Get() +v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v73 := v72.FindInternedVar(lang.NewSymbol("seq")) +if v73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) +} +v74 := v73.Get() +v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v76 := v75.FindInternedVar(lang.NewSymbol("concat")) +if v76.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) +} +v77 := v76.Get() +v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v79 := v78.FindInternedVar(lang.NewSymbol("list")) +if v79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) +} +v80 := v79.Get() +v81 := lang.Apply(v80, []any{lang.NewSymbol("array")}) +v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v83 := v82.FindInternedVar(lang.NewSymbol("list")) +if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) +} +v84 := v83.Get() +v85 := lang.Apply(v84, []any{lang.NewSymbol("idx")}) +v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v87 := v86.FindInternedVar(lang.NewSymbol("list")) +if v87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) +} +v88 := v87.Get() +v89 := lang.Apply(v88, []any{lang.NewSymbol("val")}) +v90 := lang.Apply(v77, []any{v81, v85, v89}) +v91 := lang.Apply(v74, []any{v90}) +v92 := lang.Apply(v68, []any{v71, v91}) +v93 := lang.Apply(v65, []any{v92}) +v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v95 := v94.FindInternedVar(lang.NewSymbol("list")) +if v95.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) +} +v96 := v95.Get() +v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v98 := v97.FindInternedVar(lang.NewSymbol("apply")) +if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) +} +v99 := v98.Get() +v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v101 := v100.FindInternedVar(lang.NewSymbol("vector")) +if v101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) +} +v102 := v101.Get() +v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v104 := v103.FindInternedVar(lang.NewSymbol("seq")) +if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) +} +v105 := v104.Get() +v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v107 := v106.FindInternedVar(lang.NewSymbol("concat")) +if v107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) +} +v108 := v107.Get() +v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v110 := v109.FindInternedVar(lang.NewSymbol("list")) +if v110.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) +} +v111 := v110.Get() +v112 := lang.Apply(v111, []any{lang.NewSymbol("array")}) +v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v114 := v113.FindInternedVar(lang.NewSymbol("list")) +if v114.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) +} +v115 := v114.Get() +v116 := lang.Apply(v115, []any{lang.NewSymbol("idx")}) +v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v118 := v117.FindInternedVar(lang.NewSymbol("list")) +if v118.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) +} +v119 := v118.Get() +v120 := lang.Apply(v119, []any{lang.NewSymbol("idx2")}) +v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v122 := v121.FindInternedVar(lang.NewSymbol("list")) +if v122.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) +} +v123 := v122.Get() +v124 := lang.Apply(v123, []any{lang.NewSymbol("&")}) +v125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v126 := v125.FindInternedVar(lang.NewSymbol("list")) +if v126.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v126))) +} +v127 := v126.Get() +v128 := lang.Apply(v127, []any{lang.NewSymbol("idxv")}) +v129 := lang.Apply(v108, []any{v112, v116, v120, v124, v128}) +v130 := lang.Apply(v105, []any{v129}) +v131 := lang.Apply(v99, []any{v102, v130}) +v132 := lang.Apply(v96, []any{v131}) +v133 := lang.Apply(v62, []any{v93, v132}) +v134 := lang.Apply(v59, []any{v133}) +v135 := lang.Apply(v56, []any{v134}) +v136 := lang.Apply(v49, []any{v53, v135}) +v137 := lang.Apply(v46, []any{v136}) +v138 := lang.Apply(v43, []any{v137}) +v139 := lang.Apply(v36, []any{v40, v138}) +v140 := lang.Apply(v33, []any{v139}) +v141 := lang.Apply(v27, []any{v30, v140}) +v142 := lang.Apply(v24, []any{v141}) +v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v144 := v143.FindInternedVar(lang.NewSymbol("list")) +if v144.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) +} +v145 := v144.Get() +v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v147 := v146.FindInternedVar(lang.NewSymbol("seq")) +if v147.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) +} +v148 := v147.Get() +v149 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v150 := v149.FindInternedVar(lang.NewSymbol("concat")) +if v150.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v150))) +} +v151 := v150.Get() +v152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v153 := v152.FindInternedVar(lang.NewSymbol("list")) +if v153.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v153))) +} +v154 := v153.Get() +v155 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v156 := v155.FindInternedVar(lang.NewSymbol("apply")) +if v156.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v156))) +} +v157 := v156.Get() +v158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v159 := v158.FindInternedVar(lang.NewSymbol("vector")) +if v159.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v159))) +} +v160 := v159.Get() +v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v162 := v161.FindInternedVar(lang.NewSymbol("seq")) +if v162.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) +} +v163 := v162.Get() +v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v165 := v164.FindInternedVar(lang.NewSymbol("concat")) +if v165.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) +} +v166 := v165.Get() +v167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v168 := v167.FindInternedVar(lang.NewSymbol("list")) +if v168.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v168))) +} +v169 := v168.Get() +v170 := lang.Apply(v169, []any{lang.NewSymbol("array__0__auto__")}) +v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v172 := v171.FindInternedVar(lang.NewSymbol("list")) +if v172.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) +} +v173 := v172.Get() +v174 := lang.Apply(v173, []any{lang.NewSymbol("idx__1__auto__")}) +v175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v176 := v175.FindInternedVar(lang.NewSymbol("list")) +if v176.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v176))) +} +v177 := v176.Get() +v178 := lang.Apply(v177, []any{lang.NewSymbol("val__2__auto__")}) +v179 := lang.Apply(v166, []any{v170, v174, v178}) +v180 := lang.Apply(v163, []any{v179}) +v181 := lang.Apply(v157, []any{v160, v180}) +v182 := lang.Apply(v154, []any{v181}) +v183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v184 := v183.FindInternedVar(lang.NewSymbol("list")) +if v184.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v184))) +} +v185 := v184.Get() +v186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v187 := v186.FindInternedVar(lang.NewSymbol("seq")) +if v187.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v187))) +} +v188 := v187.Get() +v189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v190 := v189.FindInternedVar(lang.NewSymbol("concat")) +if v190.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v190))) +} +v191 := v190.Get() +v192 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v193 := v192.FindInternedVar(lang.NewSymbol("list")) +if v193.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v193))) +} +v194 := v193.Get() +v195 := lang.Apply(v194, []any{lang.NewSymbol(".")}) +v196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v197 := v196.FindInternedVar(lang.NewSymbol("list")) +if v197.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v197))) +} +v198 := v197.Get() +v199 := lang.Apply(v198, []any{lang.NewSymbol("glojure.core/Array")}) +v200 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v201 := v200.FindInternedVar(lang.NewSymbol("list")) +if v201.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v201))) +} +v202 := v201.Get() +v203 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v204 := v203.FindInternedVar(lang.NewSymbol("seq")) +if v204.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v204))) +} +v205 := v204.Get() +v206 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v207 := v206.FindInternedVar(lang.NewSymbol("concat")) +if v207.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v207))) +} +v208 := v207.Get() +v209 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v210 := v209.FindInternedVar(lang.NewSymbol("list")) +if v210.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v210))) +} +v211 := v210.Get() +v212 := lang.Apply(v211, []any{v6}) +v213 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v214 := v213.FindInternedVar(lang.NewSymbol("list")) +if v214.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v214))) +} +v215 := v214.Get() +v216 := lang.Apply(v215, []any{lang.NewSymbol("array__0__auto__")}) +v217 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v218 := v217.FindInternedVar(lang.NewSymbol("list")) +if v218.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v218))) +} +v219 := v218.Get() +v220 := lang.Apply(v219, []any{lang.NewSymbol("idx__1__auto__")}) +v221 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v222 := v221.FindInternedVar(lang.NewSymbol("list")) +if v222.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v222))) +} +v223 := v222.Get() +v224 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v225 := v224.FindInternedVar(lang.NewSymbol("seq")) +if v225.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v225))) +} +v226 := v225.Get() +v227 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v228 := v227.FindInternedVar(lang.NewSymbol("concat")) +if v228.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v228))) +} +v229 := v228.Get() +v230 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v231 := v230.FindInternedVar(lang.NewSymbol("list")) +if v231.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v231))) +} +v232 := v231.Get() +v233 := lang.Apply(v232, []any{v7}) +v234 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v235 := v234.FindInternedVar(lang.NewSymbol("list")) +if v235.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v235))) +} +v236 := v235.Get() +v237 := lang.Apply(v236, []any{lang.NewSymbol("val__2__auto__")}) +v238 := lang.Apply(v229, []any{v233, v237}) +v239 := lang.Apply(v226, []any{v238}) +v240 := lang.Apply(v223, []any{v239}) +v241 := lang.Apply(v208, []any{v212, v216, v220, v240}) +v242 := lang.Apply(v205, []any{v241}) +v243 := lang.Apply(v202, []any{v242}) +v244 := lang.Apply(v191, []any{v195, v199, v243}) +v245 := lang.Apply(v188, []any{v244}) +v246 := lang.Apply(v185, []any{v245}) +v247 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v248 := v247.FindInternedVar(lang.NewSymbol("list")) +if v248.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v248))) +} +v249 := v248.Get() +v250 := lang.Apply(v249, []any{lang.NewSymbol("val__2__auto__")}) +v251 := lang.Apply(v151, []any{v182, v246, v250}) +v252 := lang.Apply(v148, []any{v251}) +v253 := lang.Apply(v145, []any{v252}) +v254 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v255 := v254.FindInternedVar(lang.NewSymbol("list")) +if v255.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v255))) +} +v256 := v255.Get() +v257 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v258 := v257.FindInternedVar(lang.NewSymbol("seq")) +if v258.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v258))) +} +v259 := v258.Get() +v260 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v261 := v260.FindInternedVar(lang.NewSymbol("concat")) +if v261.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v261))) +} +v262 := v261.Get() +v263 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v264 := v263.FindInternedVar(lang.NewSymbol("list")) +if v264.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v264))) +} +v265 := v264.Get() +v266 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v267 := v266.FindInternedVar(lang.NewSymbol("apply")) +if v267.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v267))) +} +v268 := v267.Get() +v269 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v270 := v269.FindInternedVar(lang.NewSymbol("vector")) +if v270.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v270))) +} +v271 := v270.Get() +v272 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v273 := v272.FindInternedVar(lang.NewSymbol("seq")) +if v273.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v273))) +} +v274 := v273.Get() +v275 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v276 := v275.FindInternedVar(lang.NewSymbol("concat")) +if v276.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v276))) +} +v277 := v276.Get() +v278 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v279 := v278.FindInternedVar(lang.NewSymbol("list")) +if v279.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v279))) +} +v280 := v279.Get() +v281 := lang.Apply(v280, []any{lang.NewSymbol("array__0__auto__")}) +v282 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v283 := v282.FindInternedVar(lang.NewSymbol("list")) +if v283.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v283))) +} +v284 := v283.Get() +v285 := lang.Apply(v284, []any{lang.NewSymbol("idx__1__auto__")}) +v286 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v287 := v286.FindInternedVar(lang.NewSymbol("list")) +if v287.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v287))) +} +v288 := v287.Get() +v289 := lang.Apply(v288, []any{lang.NewSymbol("idx2__3__auto__")}) +v290 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v291 := v290.FindInternedVar(lang.NewSymbol("list")) +if v291.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v291))) +} +v292 := v291.Get() +v293 := lang.Apply(v292, []any{lang.NewSymbol("&")}) +v294 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v295 := v294.FindInternedVar(lang.NewSymbol("list")) +if v295.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v295))) +} +v296 := v295.Get() +v297 := lang.Apply(v296, []any{lang.NewSymbol("idxv__4__auto__")}) +v298 := lang.Apply(v277, []any{v281, v285, v289, v293, v297}) +v299 := lang.Apply(v274, []any{v298}) +v300 := lang.Apply(v268, []any{v271, v299}) +v301 := lang.Apply(v265, []any{v300}) +v302 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v303 := v302.FindInternedVar(lang.NewSymbol("list")) +if v303.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v303))) +} +v304 := v303.Get() +v305 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v306 := v305.FindInternedVar(lang.NewSymbol("seq")) +if v306.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v306))) +} +v307 := v306.Get() +v308 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v309 := v308.FindInternedVar(lang.NewSymbol("concat")) +if v309.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v309))) +} +v310 := v309.Get() +v311 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v312 := v311.FindInternedVar(lang.NewSymbol("list")) +if v312.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v312))) +} +v313 := v312.Get() +v314 := lang.Apply(v313, []any{lang.NewSymbol("glojure.core/apply")}) +v315 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v316 := v315.FindInternedVar(lang.NewSymbol("list")) +if v316.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v316))) +} +v317 := v316.Get() +v318 := lang.Apply(v317, []any{v5}) +v319 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v320 := v319.FindInternedVar(lang.NewSymbol("list")) +if v320.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v320))) +} +v321 := v320.Get() +v322 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v323 := v322.FindInternedVar(lang.NewSymbol("seq")) +if v323.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v323))) +} +v324 := v323.Get() +v325 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v326 := v325.FindInternedVar(lang.NewSymbol("concat")) +if v326.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v326))) +} +v327 := v326.Get() +v328 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v329 := v328.FindInternedVar(lang.NewSymbol("list")) +if v329.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v329))) +} +v330 := v329.Get() +v331 := lang.Apply(v330, []any{lang.NewSymbol("glojure.core/aget")}) +v332 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v333 := v332.FindInternedVar(lang.NewSymbol("list")) +if v333.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v333))) +} +v334 := v333.Get() +v335 := lang.Apply(v334, []any{lang.NewSymbol("array__0__auto__")}) +v336 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v337 := v336.FindInternedVar(lang.NewSymbol("list")) +if v337.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v337))) +} +v338 := v337.Get() +v339 := lang.Apply(v338, []any{lang.NewSymbol("idx__1__auto__")}) +v340 := lang.Apply(v327, []any{v331, v335, v339}) +v341 := lang.Apply(v324, []any{v340}) +v342 := lang.Apply(v321, []any{v341}) +v343 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v344 := v343.FindInternedVar(lang.NewSymbol("list")) +if v344.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v344))) +} +v345 := v344.Get() +v346 := lang.Apply(v345, []any{lang.NewSymbol("idx2__3__auto__")}) +v347 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v348 := v347.FindInternedVar(lang.NewSymbol("list")) +if v348.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v348))) +} +v349 := v348.Get() +v350 := lang.Apply(v349, []any{lang.NewSymbol("idxv__4__auto__")}) +v351 := lang.Apply(v310, []any{v314, v318, v342, v346, v350}) +v352 := lang.Apply(v307, []any{v351}) +v353 := lang.Apply(v304, []any{v352}) +v354 := lang.Apply(v262, []any{v301, v353}) +v355 := lang.Apply(v259, []any{v354}) +v356 := lang.Apply(v256, []any{v355}) +v357 := lang.Apply(v13, []any{v17, v21, v142, v253, v356}) +v358 := lang.Apply(v10, []any{v357}) +return v358 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// chunked-seq? +{ +v0 := lang.NewSymbol("chunked-seq?").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(708), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(708), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{lang1.IChunkedSeq, v3}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// some-fn +{ +v0 := lang.NewSymbol("some-fn").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("p")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2"), lang.NewSymbol("p3")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2"), lang.NewSymbol("p3"), lang.NewSymbol("&"), lang.NewSymbol("ps"))), lang.NewKeyword("doc"), "Takes a set of predicates and returns a function f that returns the first logical true value\n returned by one of its composing predicates against any of its arguments, else it returns\n logical false. Note that f is short-circuiting in that it will stop execution on the first\n argument that triggers a logical true result against the original predicates.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7505), lang.NewKeyword("end-line"), int(7505))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +var v4 lang.FnFunc +{ // function sp1 +v4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +return nil + case 1: +v6 := args[0] +v7 := lang.Apply(v3, []any{v6}) +return v7 + case 2: +v6 := args[0] +v7 := args[1] +v9 := lang.Apply(v3, []any{v6}) +var v8 any = v9 +_ = v8 +var v11 any +if lang.IsTruthy(v8) { +v11 = v8 +} else { +v12 := lang.Apply(v3, []any{v7}) +v11 = v12 +} +return v11 + case 3: +v6 := args[0] +v7 := args[1] +v8 := args[2] +v10 := lang.Apply(v3, []any{v6}) +var v9 any = v10 +_ = v9 +var v12 any +if lang.IsTruthy(v9) { +v12 = v9 +} else { +v14 := lang.Apply(v3, []any{v7}) +var v13 any = v14 +_ = v13 +var v16 any +if lang.IsTruthy(v13) { +v16 = v13 +} else { +v17 := lang.Apply(v3, []any{v8}) +v16 = v17 +} +v12 = v16 +} +return v12 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v6 := args[0] +v7 := args[1] +v8 := args[2] +v9 := lang.NewList(args[3:]...) +v11 := lang.Apply(v5, []any{v6, v7, v8}) +var v10 any = v11 +_ = v10 +var v13 any +if lang.IsTruthy(v10) { +v13 = v10 +} else { +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("some")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v3, v9}) +v13 = v17 +} +return v13 + } +}) +v5 := v4 +_ = v5 +} +v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7512), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7518), lang.NewKeyword("end-column"), int(43)) +v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v6 + case 2: +v3 := args[0] +v4 := args[1] +var v5 lang.FnFunc +{ // function sp2 +v5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +return nil + case 1: +v7 := args[0] +v9 := lang.Apply(v3, []any{v7}) +var v8 any = v9 +_ = v8 +var v11 any +if lang.IsTruthy(v8) { +v11 = v8 +} else { +v12 := lang.Apply(v4, []any{v7}) +v11 = v12 +} +return v11 + case 2: +v7 := args[0] +v8 := args[1] +v10 := lang.Apply(v3, []any{v7}) +var v9 any = v10 +_ = v9 +var v12 any +if lang.IsTruthy(v9) { +v12 = v9 +} else { +v14 := lang.Apply(v3, []any{v8}) +var v13 any = v14 +_ = v13 +var v16 any +if lang.IsTruthy(v13) { +v16 = v13 +} else { +v18 := lang.Apply(v4, []any{v7}) +var v17 any = v18 +_ = v17 +var v20 any +if lang.IsTruthy(v17) { +v20 = v17 +} else { +v21 := lang.Apply(v4, []any{v8}) +v20 = v21 +} +v16 = v20 +} +v12 = v16 +} +return v12 + case 3: +v7 := args[0] +v8 := args[1] +v9 := args[2] +v11 := lang.Apply(v3, []any{v7}) +var v10 any = v11 +_ = v10 +var v13 any +if lang.IsTruthy(v10) { +v13 = v10 +} else { +v15 := lang.Apply(v3, []any{v8}) +var v14 any = v15 +_ = v14 +var v17 any +if lang.IsTruthy(v14) { +v17 = v14 +} else { +v19 := lang.Apply(v3, []any{v9}) +var v18 any = v19 +_ = v18 +var v21 any +if lang.IsTruthy(v18) { +v21 = v18 +} else { +v23 := lang.Apply(v4, []any{v7}) +var v22 any = v23 +_ = v22 +var v25 any +if lang.IsTruthy(v22) { +v25 = v22 +} else { +v27 := lang.Apply(v4, []any{v8}) +var v26 any = v27 +_ = v26 +var v29 any +if lang.IsTruthy(v26) { +v29 = v26 +} else { +v30 := lang.Apply(v4, []any{v9}) +v29 = v30 +} +v25 = v29 +} +v21 = v25 +} +v17 = v21 +} +v13 = v17 +} +return v13 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v7 := args[0] +v8 := args[1] +v9 := args[2] +v10 := lang.NewList(args[3:]...) +v12 := lang.Apply(v6, []any{v7, v8, v9}) +var v11 any = v12 +_ = v11 +var v14 any +if lang.IsTruthy(v11) { +v14 = v11 +} else { +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("some")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +var v18 lang.FnFunc +v18 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v19 := args[0] +v21 := lang.Apply(v3, []any{v19}) +var v20 any = v21 +_ = v20 +var v23 any +if lang.IsTruthy(v20) { +v23 = v20 +} else { +v24 := lang.Apply(v4, []any{v19}) +v23 = v24 +} +return v23 +}) +v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7526), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(7526), lang.NewKeyword("end-column"), int(52)) +v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v21 := lang.Apply(v17, []any{v20, v10}) +v14 = v21 +} +return v14 + } +}) +v6 := v5 +_ = v6 +} +v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7520), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7526), lang.NewKeyword("end-column"), int(61)) +v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v7 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +var v6 lang.FnFunc +{ // function sp3 +v6 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +return nil + case 1: +v8 := args[0] +v10 := lang.Apply(v3, []any{v8}) +var v9 any = v10 +_ = v9 +var v12 any +if lang.IsTruthy(v9) { +v12 = v9 +} else { +v14 := lang.Apply(v4, []any{v8}) +var v13 any = v14 +_ = v13 +var v16 any +if lang.IsTruthy(v13) { +v16 = v13 +} else { +v17 := lang.Apply(v5, []any{v8}) +v16 = v17 +} +v12 = v16 +} +return v12 + case 2: +v8 := args[0] +v9 := args[1] +v11 := lang.Apply(v3, []any{v8}) +var v10 any = v11 +_ = v10 +var v13 any +if lang.IsTruthy(v10) { +v13 = v10 +} else { +v15 := lang.Apply(v3, []any{v9}) +var v14 any = v15 +_ = v14 +var v17 any +if lang.IsTruthy(v14) { +v17 = v14 +} else { +v19 := lang.Apply(v4, []any{v8}) +var v18 any = v19 +_ = v18 +var v21 any +if lang.IsTruthy(v18) { +v21 = v18 +} else { +v23 := lang.Apply(v4, []any{v9}) +var v22 any = v23 +_ = v22 +var v25 any +if lang.IsTruthy(v22) { +v25 = v22 +} else { +v27 := lang.Apply(v5, []any{v8}) +var v26 any = v27 +_ = v26 +var v29 any +if lang.IsTruthy(v26) { +v29 = v26 +} else { +v30 := lang.Apply(v5, []any{v9}) +v29 = v30 +} +v25 = v29 +} +v21 = v25 +} +v17 = v21 +} +v13 = v17 +} +return v13 + case 3: +v8 := args[0] +v9 := args[1] +v10 := args[2] +v12 := lang.Apply(v3, []any{v8}) +var v11 any = v12 +_ = v11 +var v14 any +if lang.IsTruthy(v11) { +v14 = v11 +} else { +v16 := lang.Apply(v3, []any{v9}) +var v15 any = v16 +_ = v15 +var v18 any +if lang.IsTruthy(v15) { +v18 = v15 +} else { +v20 := lang.Apply(v3, []any{v10}) +var v19 any = v20 +_ = v19 +var v22 any +if lang.IsTruthy(v19) { +v22 = v19 +} else { +v24 := lang.Apply(v4, []any{v8}) +var v23 any = v24 +_ = v23 +var v26 any +if lang.IsTruthy(v23) { +v26 = v23 +} else { +v28 := lang.Apply(v4, []any{v9}) +var v27 any = v28 +_ = v27 +var v30 any +if lang.IsTruthy(v27) { +v30 = v27 +} else { +v32 := lang.Apply(v4, []any{v10}) +var v31 any = v32 +_ = v31 +var v34 any +if lang.IsTruthy(v31) { +v34 = v31 +} else { +v36 := lang.Apply(v5, []any{v8}) +var v35 any = v36 +_ = v35 +var v38 any +if lang.IsTruthy(v35) { +v38 = v35 +} else { +v40 := lang.Apply(v5, []any{v9}) +var v39 any = v40 +_ = v39 +var v42 any +if lang.IsTruthy(v39) { +v42 = v39 +} else { +v43 := lang.Apply(v5, []any{v10}) +v42 = v43 +} +v38 = v42 +} +v34 = v38 +} +v30 = v34 +} +v26 = v30 +} +v22 = v26 +} +v18 = v22 +} +v14 = v18 +} +return v14 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v8 := args[0] +v9 := args[1] +v10 := args[2] +v11 := lang.NewList(args[3:]...) +v13 := lang.Apply(v7, []any{v8, v9, v10}) +var v12 any = v13 +_ = v12 +var v15 any +if lang.IsTruthy(v12) { +v15 = v12 +} else { +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("some")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +var v19 lang.FnFunc +v19 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v20 := args[0] +v22 := lang.Apply(v3, []any{v20}) +var v21 any = v22 +_ = v21 +var v24 any +if lang.IsTruthy(v21) { +v24 = v21 +} else { +v26 := lang.Apply(v4, []any{v20}) +var v25 any = v26 +_ = v25 +var v28 any +if lang.IsTruthy(v25) { +v28 = v25 +} else { +v29 := lang.Apply(v5, []any{v20}) +v28 = v29 +} +v24 = v28 +} +return v24 +}) +v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7534), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(7534), lang.NewKeyword("end-column"), int(59)) +v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v22 := lang.Apply(v18, []any{v21, v11}) +v15 = v22 +} +return v15 + } +}) +v7 := v6 +_ = v7 +} +v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7528), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7534), lang.NewKeyword("end-column"), int(68)) +v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v8 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("list*")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v3, v4, v5, v7}) +var v7 any = v11 +_ = v7 +var v13 lang.FnFunc +{ // function spn +v13 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +return nil + case 1: +v15 := args[0] +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("some")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +var v19 lang.FnFunc +v19 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v20 := args[0] +v21 := lang.Apply(v20, []any{v15}) +return v21 +}) +v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7539), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(7539), lang.NewKeyword("end-column"), int(26)) +v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v22 := lang.Apply(v18, []any{v21, v7}) +return v22 + case 2: +v15 := args[0] +v16 := args[1] +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("some")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +var v20 lang.FnFunc +v20 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v21 := args[0] +v23 := lang.Apply(v21, []any{v15}) +var v22 any = v23 +_ = v22 +var v25 any +if lang.IsTruthy(v22) { +v25 = v22 +} else { +v26 := lang.Apply(v21, []any{v16}) +v25 = v26 +} +return v25 +}) +v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7540), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(7540), lang.NewKeyword("end-column"), int(39)) +v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v23 := lang.Apply(v19, []any{v22, v7}) +return v23 + case 3: +v15 := args[0] +v16 := args[1] +v17 := args[2] +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("some")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +var v21 lang.FnFunc +v21 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v22 := args[0] +v24 := lang.Apply(v22, []any{v15}) +var v23 any = v24 +_ = v23 +var v26 any +if lang.IsTruthy(v23) { +v26 = v23 +} else { +v28 := lang.Apply(v22, []any{v16}) +var v27 any = v28 +_ = v27 +var v30 any +if lang.IsTruthy(v27) { +v30 = v27 +} else { +v31 := lang.Apply(v22, []any{v17}) +v30 = v31 +} +v26 = v30 +} +return v26 +}) +v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7541), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7541), lang.NewKeyword("end-column"), int(47)) +v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v24 := lang.Apply(v20, []any{v23, v7}) +return v24 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v15 := args[0] +v16 := args[1] +v17 := args[2] +v18 := lang.NewList(args[3:]...) +v20 := lang.Apply(v14, []any{v15, v16, v17}) +var v19 any = v20 +_ = v19 +var v22 any +if lang.IsTruthy(v19) { +v22 = v19 +} else { +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("some")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +var v26 lang.FnFunc +v26 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v27 := args[0] +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("some")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{v27, v18}) +return v31 +}) +v27 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7543), lang.NewKeyword("column"), int(36), lang.NewKeyword("end-line"), int(7543), lang.NewKeyword("end-column"), int(49)) +v28, err := lang.WithMeta(v26, v27.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v29 := lang.Apply(v25, []any{v28, v7}) +v22 = v29 +} +return v22 + } +}) +v14 := v13 +_ = v14 +} +v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7537), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7543), lang.NewKeyword("end-column"), int(56)) +v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v15 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// parse-double +{ +v0 := lang.NewSymbol("parse-double").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse string with floating point components and return a Double value,\n or nil if parse fails.\n\n Grammar: https://docs.oracle.com/javase/8/docs/api/java/lang/Double.html#valueOf-java.lang.String-", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7988), lang.NewKeyword("end-line"), int(7988))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("string?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +if lang.IsTruthy(v8) { +v10 := lang.Apply(strconv4.ParseFloat, []any{v3, int64(64)}) +var v9 any = v10 +_ = v9 +var v12 any +v13 := lang.Apply(v9, []any{int64(1)}) +if lang.IsTruthy(v13) { +v12 = nil +} else { +v14 := lang.Apply(v9, []any{int64(0)}) +v12 = v14 +} +v4 = v12 +} else { +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("parsing-err")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v3}) +v13 := lang.Apply(lang1.NewIllegalArgumentError, []any{v12}) +panic(v13) +} +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// load-data-reader-file +{ +v0 := lang.NewSymbol("load-data-reader-file").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7889), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7889), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("mappings"), lang.NewSymbol("url"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v6, ok := lang.FieldOrMethod(v4, "openStream") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "openStream"))) +} +var v7 any +switch reflect.TypeOf(v6).Kind() { +case reflect.Func: + v7 = lang.Apply(v6, nil) +default: + v7 = v6 +} +v8 := lang.Apply(java.io.InputStreamReader6., []any{v7, "UTF-8"}) +v9 := lang.Apply(glojure.lang.LineNumberingPushbackReader5., []any{v8}) +var v5 any = v9 +_ = v5 +var v11 any +func() { +defer func() { +v12, ok := lang.FieldOrMethod(v5, "close") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "close"))) +} +var v13 any +switch reflect.TypeOf(v12).Kind() { +case reflect.Func: + v13 = lang.Apply(v12, nil) +default: + v13 = v12 +} +}() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("push-thread-bindings")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("hash-map")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*file*")) +v22, ok := lang.FieldOrMethod(v4, "getFile") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "getFile"))) +} +var v23 any +switch reflect.TypeOf(v22).Kind() { +case reflect.Func: + v23 = lang.Apply(v22, nil) +default: + v23 = v22 +} +v24 := lang.Apply(v20, []any{v21, v23}) +v25 := lang.Apply(v17, []any{v24}) +_ = v25 +var v26 any +func() { +defer func() { +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, nil) +}() +var v32 any +v33, ok := lang.FieldOrMethod(v4, "getPath") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "getPath"))) +} +var v34 any +switch reflect.TypeOf(v33).Kind() { +case reflect.Func: + v34 = lang.Apply(v33, nil) +default: + v34 = v33 +} +v35, _ := lang.FieldOrMethod(v34, "endsWith") +if reflect.TypeOf(v35).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("endsWith is not a function"))) +} +v36 := lang.Apply(v35, []any{"cljc"}) +if lang.IsTruthy(v36) { +v37 := lang.NewMap(lang.NewKeyword("eof"), nil, lang.NewKeyword("read-cond"), lang.NewKeyword("allow")) +v38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7895), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7895), lang.NewKeyword("end-column"), int(52)) +v39, err := lang.WithMeta(v37, v38.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v32 = v39 +} else { +v40 := lang.NewMap(lang.NewKeyword("eof"), nil) +v41 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7896), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7896), lang.NewKeyword("end-column"), int(34)) +v42, err := lang.WithMeta(v40, v41.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v32 = v42 +} +var v31 any = v32 +_ = v31 +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("read")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v31, v5}) +var v43 any = v47 +_ = v43 +var v49 any +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("not")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +} +v52 := v51.Get() +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("map?")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +} +v55 := v54.Get() +v56 := lang.Apply(v55, []any{v43}) +v57 := lang.Apply(v52, []any{v56}) +if lang.IsTruthy(v57) { +v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v59 := v58.FindInternedVar(lang.NewSymbol("ex-info")) +if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) +} +v60 := v59.Get() +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("str")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +} +v63 := v62.Get() +v64 := lang.Apply(v63, []any{"Not a valid data-reader map"}) +v65 := lang.NewMap(lang.NewKeyword("url"), v4) +v66 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7900), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(7900), lang.NewKeyword("end-column"), int(36)) +v67, err := lang.WithMeta(v65, v66.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v68 := lang.Apply(v60, []any{v64, v67}) +panic(v68) +} else { +v49 = nil +} +_ = v49 +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("reduce")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +} +v71 := v70.Get() +var v72 lang.FnFunc +v72 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v73 := args[0] +v74 := args[1] +var v75 any = v74 +_ = v75 +v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v78 := v77.FindInternedVar(lang.NewSymbol("nth")) +if v78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) +} +v79 := v78.Get() +v80 := lang.Apply(v79, []any{v75, int64(0), nil}) +var v76 any = v80 +_ = v76 +v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v83 := v82.FindInternedVar(lang.NewSymbol("nth")) +if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) +} +v84 := v83.Get() +v85 := lang.Apply(v84, []any{v75, int64(1), nil}) +var v81 any = v85 +_ = v81 +var v87 any +v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v89 := v88.FindInternedVar(lang.NewSymbol("not")) +if v89.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) +} +v90 := v89.Get() +v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v92 := v91.FindInternedVar(lang.NewSymbol("symbol?")) +if v92.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) +} +v93 := v92.Get() +v94 := lang.Apply(v93, []any{v76}) +v95 := lang.Apply(v90, []any{v94}) +if lang.IsTruthy(v95) { +v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v97 := v96.FindInternedVar(lang.NewSymbol("ex-info")) +if v97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) +} +v98 := v97.Get() +v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v100 := v99.FindInternedVar(lang.NewSymbol("str")) +if v100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) +} +v101 := v100.Get() +v102 := lang.Apply(v101, []any{"Invalid form in data-reader file"}) +v103 := lang.NewMap(lang.NewKeyword("url"), v4, lang.NewKeyword("form"), v76) +v104 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7905), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(7906), lang.NewKeyword("end-column"), int(38)) +v105, err := lang.WithMeta(v103, v104.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v106 := lang.Apply(v98, []any{v102, v105}) +panic(v106) +} else { +v87 = nil +} +_ = v87 +v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v109 := v108.FindInternedVar(lang.NewSymbol("data-reader-var")) +if v109.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) +} +v110 := v109.Get() +v111 := lang.Apply(v110, []any{v81}) +var v107 any = v111 +_ = v107 +var v113 any +v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v116 := v115.FindInternedVar(lang.NewSymbol("contains?")) +if v116.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) +} +v117 := v116.Get() +v118 := lang.Apply(v117, []any{v3, v76}) +var v114 any = v118 +_ = v114 +var v120 any +if lang.IsTruthy(v114) { +v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v122 := v121.FindInternedVar(lang.NewSymbol("not=")) +if v122.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) +} +v123 := v122.Get() +v124 := lang.Apply(v3, []any{v76}) +v125 := lang.Apply(v123, []any{v124, v107}) +v120 = v125 +} else { +v120 = v114 +} +if lang.IsTruthy(v120) { +v114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v115 := v114.FindInternedVar(lang.NewSymbol("ex-info")) +if v115.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v115))) +} +v116 := v115.Get() +v117 := lang.NewMap(lang.NewKeyword("url"), v4, lang.NewKeyword("conflict"), v76, lang.NewKeyword("mappings"), v73) +v118 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7911), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(7913), lang.NewKeyword("end-column"), int(44)) +v119, err := lang.WithMeta(v117, v118.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v120 := lang.Apply(v116, []any{"Conflicting data-reader mapping", v119}) +panic(v120) +} else { +v113 = nil +} +_ = v113 +v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v122 := v121.FindInternedVar(lang.NewSymbol("assoc")) +if v122.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) +} +v123 := v122.Get() +v124 := lang.Apply(v123, []any{v73, v76, v107}) +return v124 +}) +v73 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7902), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(7914), lang.NewKeyword("end-column"), int(32)) +v74, err := lang.WithMeta(v72, v73.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v75 := lang.Apply(v71, []any{v74, v3, v43}) +v26 = v75 +}() +v11 = v26 +}() +return v11 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// short +{ +var v1 lang.FnFunc +{ // function short__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +var v30 any +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +if lang.IsTruthy(v33) { +v30 = lang.NewSymbol("uncheckedShortCast") +} else { +v30 = lang.NewSymbol("shortCast") +} +v34 := lang.Apply(v29, []any{v30}) +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("list")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v37, []any{v3}) +v39 := lang.Apply(v26, []any{v34, v38}) +v40 := lang.Apply(v23, []any{v39}) +v41 := lang.Apply(v20, []any{v40}) +v42 := lang.Apply(v9, []any{v13, v17, v41}) +v43 := lang.Apply(v6, []any{v42}) +return v43 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("short").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to short", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3499), lang.NewKeyword("end-line"), int(3499))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := lang.Apply(lang1.ShortCast, []any{v4}) +return v5 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// disj +{ +v0 := lang.NewSymbol("disj").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("set")), lang.NewVector(lang.NewSymbol("set"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("set"), lang.NewSymbol("key"), lang.NewSymbol("&"), lang.NewSymbol("ks"))), lang.NewKeyword("doc"), "disj[oin]. Returns a new set of the same (hashed/sorted) type, that\n does not contain key(s).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1514), lang.NewKeyword("end-line"), int(1514))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +return v3 + case 2: +v3 := args[0] +v4 := args[1] +var v5 any +if lang.IsTruthy(v3) { +v6, _ := lang.FieldOrMethod(v3, "Disjoin") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Disjoin is not a function"))) +} +v7 := lang.Apply(v6, []any{v4}) +v5 = v7 +} else { +v5 = nil +} +return v5 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +recur_loop_304: +var v6 any +if lang.IsTruthy(v3) { +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("disj")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v3, v4}) +var v7 any = v11 +_ = v7 +var v13 any +if lang.IsTruthy(v5) { +var v14 any = v7 +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("first")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v5}) +var v15 any = v19 +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("next")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v5}) +var v20 any = v24 +v3 = v14 +v4 = v15 +v5 = v20 +goto recur_loop_304 +} else { +v13 = v7 +} +v6 = v13 +} else { +v6 = nil +} +return v6 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// map +{ +v0 := lang.NewSymbol("map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2"), lang.NewSymbol("c3")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2"), lang.NewSymbol("c3"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Returns a lazy sequence consisting of the result of applying f to\n the set of first items of each coll, followed by applying f to the\n set of second items in each coll, until any one of the colls is\n exhausted. Any remaining items in other colls are ignored. Function\n f should accept number-of-colls arguments. Returns a transducer when\n no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2719), lang.NewKeyword("end-line"), int(2719))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +var v6 lang.FnFunc +v6 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v7 := lang.Apply(v5, nil) +return v7 + case 1: +v7 := args[0] +v8 := lang.Apply(v5, []any{v7}) +return v8 + case 2: +v7 := args[0] +v8 := args[1] +v9 := lang.Apply(v3, []any{v8}) +v10 := lang.Apply(v5, []any{v7, v9}) +return v10 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v7 := args[0] +v8 := args[1] +v9 := lang.NewList(args[2:]...) +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("apply")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{v3, v8, v9}) +v14 := lang.Apply(v5, []any{v7, v13}) +return v14 + } +}) +v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2730), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(2736), lang.NewKeyword("end-column"), int(47)) +v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v8 +}) +v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2729), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2736), lang.NewKeyword("end-column"), int(48)) +v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v6 + case 2: +v3 := args[0] +v4 := args[1] +var v5 lang.FnFunc +v5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("seq")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v4}) +var v6 any = v10 +_ = v6 +var v12 any +if lang.IsTruthy(v6) { +var v13 any = v6 +_ = v13 +var v15 any +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("chunked-seq?")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v13}) +if lang.IsTruthy(v19) { +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("chunk-first")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v13}) +var v20 any = v24 +_ = v20 +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("int")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("count")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.Apply(v31, []any{v20}) +v33 := lang.Apply(v28, []any{v32}) +var v25 any = v33 +_ = v25 +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("chunk-buffer")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v37, []any{v25}) +var v34 any = v38 +_ = v34 +v41 := lang.Apply(lang1.LongCast, []any{v25}) +var v40 any = v41 +_ = v40 +var v43 any = int64(0) +_ = v43 +var v44 any +for { +var v45 any +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("<")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +} +v48 := v47.Get() +v49 := lang.Apply(v48, []any{v43, v40}) +if lang.IsTruthy(v49) { +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("chunk-append")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +} +v52 := v51.Get() +v53, _ := lang.FieldOrMethod(v20, "nth") +if reflect.TypeOf(v53).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) +} +v54 := lang.Apply(v53, []any{v43}) +v55 := lang.Apply(v3, []any{v54}) +v56 := lang.Apply(v52, []any{v34, v55}) +_ = v56 +v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v59 := v58.FindInternedVar(lang.NewSymbol("unchecked-inc")) +if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) +} +v60 := v59.Get() +v61 := lang.Apply(v60, []any{v43}) +var v57 any = v61 +v43 = v57 +continue +} else { +v45 = nil +} +v44 = v45 + break +} +_ = v44 +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("chunk-cons")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("chunk")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +} +v45 := v44.Get() +v46 := lang.Apply(v45, []any{v34}) +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("map")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +} +v49 := v48.Get() +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("chunk-rest")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +} +v52 := v51.Get() +v53 := lang.Apply(v52, []any{v13}) +v54 := lang.Apply(v49, []any{v3, v53}) +v55 := lang.Apply(v42, []any{v46, v54}) +v15 = v55 +} else { +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("cons")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("first")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{v13}) +v27 := lang.Apply(v3, []any{v26}) +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("map")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("rest")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v13}) +v35 := lang.Apply(v30, []any{v3, v34}) +v36 := lang.Apply(v22, []any{v27, v35}) +v15 = v36 +} +v12 = v15 +} else { +v12 = nil +} +return v12 +}) +v6 := lang.Apply(lang1.NewLazySeq, []any{v5}) +return v6 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +var v6 lang.FnFunc +v6 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("seq")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v4}) +var v7 any = v11 +_ = v7 +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("seq")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v5}) +var v12 any = v16 +_ = v12 +var v18 any +var v19 any = v7 +_ = v19 +var v21 any +if lang.IsTruthy(v19) { +v21 = v12 +} else { +v21 = v19 +} +if lang.IsTruthy(v21) { +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("cons")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("first")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v7}) +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("first")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.Apply(v28, []any{v12}) +v30 := lang.Apply(v3, []any{v25, v29}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("map")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("rest")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.Apply(v36, []any{v7}) +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("rest")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.Apply(v40, []any{v12}) +v42 := lang.Apply(v33, []any{v3, v37, v41}) +v43 := lang.Apply(v21, []any{v30, v42}) +v18 = v43 +} else { +v18 = nil +} +return v18 +}) +v7 := lang.Apply(lang1.NewLazySeq, []any{v6}) +return v7 + case 4: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +var v7 lang.FnFunc +v7 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("seq")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v4}) +var v8 any = v12 +_ = v8 +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("seq")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v5}) +var v13 any = v17 +_ = v13 +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("seq")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v6}) +var v18 any = v22 +_ = v18 +var v24 any +var v25 any = v8 +_ = v25 +var v27 any +if lang.IsTruthy(v25) { +var v28 any = v13 +_ = v28 +var v30 any +if lang.IsTruthy(v28) { +v30 = v18 +} else { +v30 = v28 +} +v27 = v30 +} else { +v27 = v25 +} +if lang.IsTruthy(v27) { +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("cons")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("first")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{v8}) +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("first")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v13}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("first")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v18}) +v40 := lang.Apply(v3, []any{v31, v35, v39}) +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("map")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("rest")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v8}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("rest")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v13}) +v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v53 := v52.FindInternedVar(lang.NewSymbol("rest")) +if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) +} +v54 := v53.Get() +v55 := lang.Apply(v54, []any{v18}) +v56 := lang.Apply(v43, []any{v3, v47, v51, v55}) +v57 := lang.Apply(v27, []any{v40, v56}) +v24 = v57 +} else { +v24 = nil +} +return v24 +}) +v8 := lang.Apply(lang1.NewLazySeq, []any{v7}) +return v8 + default: + if len(args) < 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := lang.NewList(args[4:]...) +var v9 lang.FnFunc +{ // function step +v9 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v11 := args[0] +var v12 lang.FnFunc +v12 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("map")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v16, []any{v19, v11}) +var v13 any = v20 +_ = v13 +var v22 any +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("every?")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("identity")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.Apply(v25, []any{v28, v13}) +if lang.IsTruthy(v29) { +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("cons")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("map")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("first")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v35, []any{v38, v13}) +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("map")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("rest")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +} +v45 := v44.Get() +v46 := lang.Apply(v42, []any{v45, v13}) +v47 := lang.Apply(v10, []any{v46}) +v48 := lang.Apply(v32, []any{v39, v47}) +v22 = v48 +} else { +v22 = nil +} +return v22 +}) +v13 := lang.Apply(lang1.NewLazySeq, []any{v12}) +return v13 +}) +v10 := v9 +_ = v10 +} +v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2761), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(2765), lang.NewKeyword("end-column"), int(68)) +v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v8 any = v11 +_ = v8 +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("map")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +var v16 lang.FnFunc +v16 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v17 := args[0] +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("apply")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, []any{v3, v17}) +return v21 +}) +v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2766), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(2766), lang.NewKeyword("end-column"), int(22)) +v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("conj")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v7, v6, v5, v4}) +v23 := lang.Apply(v8, []any{v22}) +v24 := lang.Apply(v15, []any{v18, v23}) +return v24 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// chunk-first +{ +v0 := lang.NewSymbol("chunk-first").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(694), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(694), lang.NewKeyword("end-column"), int(48), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, ok := lang.FieldOrMethod(v3, "chunkedFirst") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "chunkedFirst"))) +} +var v5 any +switch reflect.TypeOf(v4).Kind() { +case reflect.Func: + v5 = lang.Apply(v4, nil) +default: + v5 = v4 +} +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// NaN? +{ +var v1 lang.FnFunc +{ // function NaN?__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol("math.IsNaN")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v3}) +v18 := lang.Apply(v9, []any{v13, v17}) +v19 := lang.Apply(v6, []any{v18}) +return v19 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("NaN?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns true if num is NaN, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)), lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(8021), lang.NewKeyword("end-line"), int(8021))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := lang.Apply(math7.IsNaN, []any{v4}) +return v5 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// partitionv-all +{ +v0 := lang.NewSymbol("partitionv-all").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of vector partitions, but may include\n partitions with fewer than n items at the end.\n Returns a stateful transducer when no collection is provided.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7328), lang.NewKeyword("end-line"), int(7328))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("partition-all")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{v3}) +return v7 + case 2: +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("partitionv-all")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3, v3, v4}) +return v8 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +var v6 lang.FnFunc +v6 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("seq")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v5}) +var v7 any = v11 +_ = v7 +var v13 any +if lang.IsTruthy(v7) { +var v14 any = v7 +_ = v14 +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("into")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.NewVector() +v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7340), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(7340), lang.NewKeyword("end-column"), int(25)) +v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("take")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{v3}) +v27 := lang.Apply(v19, []any{v22, v26, v5}) +var v16 any = v27 +_ = v16 +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("cons")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("partitionv-all")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("drop")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v37, []any{v4, v14}) +v39 := lang.Apply(v34, []any{v3, v4, v38}) +v40 := lang.Apply(v31, []any{v16, v39}) +v13 = v40 +} else { +v13 = nil +} +return v13 +}) +v7 := lang.Apply(lang1.NewLazySeq, []any{v6}) +return v7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// error-mode +{ +v0 := lang.NewSymbol("error-mode").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("doc"), "Returns the error-mode of agent a. See set-error-mode!", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2227), lang.NewKeyword("end-line"), int(2227))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, ok := lang.FieldOrMethod(v3, "getErrorMode") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getErrorMode"))) +} +var v5 any +switch reflect.TypeOf(v4).Kind() { +case reflect.Func: + v5 = lang.Apply(v4, nil) +default: + v5 = v4 +} +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// bigdec +{ +v1 := reflect.TypeOf((*lang1.BigDecimal)(nil)) +v0 := lang.NewSymbol("bigdec").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Coerce to BigDecimal", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3648), lang.NewKeyword("end-line"), int(3648))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("decimal?")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v4}) +if lang.IsTruthy(v9) { +v5 = v4 +} else { +var v10 any +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("float?")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v4}) +if lang.IsTruthy(v14) { +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("double")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v4}) +v19 := lang.Apply(lang1.NewBigDecimalFromFloat64, []any{v18}) +v10 = v19 +} else { +var v20 any +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("ratio?")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v4}) +if lang.IsTruthy(v24) { +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("/")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28, ok := lang.FieldOrMethod(v4, "numerator") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "numerator"))) +} +var v29 any +switch reflect.TypeOf(v28).Kind() { +case reflect.Func: + v29 = lang.Apply(v28, nil) +default: + v29 = v28 +} +v30 := lang.Apply(BigDecimal8., []any{v29}) +v31, ok := lang.FieldOrMethod(v4, "denominator") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "denominator"))) +} +var v32 any +switch reflect.TypeOf(v31).Kind() { +case reflect.Func: + v32 = lang.Apply(v31, nil) +default: + v32 = v31 +} +v33 := lang.Apply(v27, []any{v30, v32}) +v20 = v33 +} else { +var v34 any +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("instance?")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v37, []any{lang1.*BigInt, v4}) +if lang.IsTruthy(v38) { +v39, ok := lang.FieldOrMethod(v4, "toBigDecimal") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "toBigDecimal"))) +} +var v40 any +switch reflect.TypeOf(v39).Kind() { +case reflect.Func: + v40 = lang.Apply(v39, nil) +default: + v40 = v39 +} +v34 = v40 +} else { +var v41 any +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("instance?")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +} +v44 := v43.Get() +v45 := lang.Apply(v44, []any{big9.*Int, v4}) +if lang.IsTruthy(v45) { +v46 := lang.Apply(BigDecimal8., []any{v4}) +v41 = v46 +} else { +var v47 any +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("number?")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v4}) +if lang.IsTruthy(v51) { +v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v53 := v52.FindInternedVar(lang.NewSymbol("long")) +if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) +} +v54 := v53.Get() +v55 := lang.Apply(v54, []any{v4}) +v56 := lang.Apply(lang1.NewBigDecimalFromInt64, []any{v55}) +v47 = v56 +} else { +var v57 any +if lang.IsTruthy(lang.NewKeyword("else")) { +v58 := lang.Apply(BigDecimal8., []any{v4}) +v57 = v58 +} else { +v57 = nil +} +v47 = v57 +} +v41 = v47 +} +v34 = v41 +} +v20 = v34 +} +v10 = v20 +} +v5 = v10 +} +return v5 +}) +v4 := reflect.TypeOf((*lang1.BigDecimal)(nil)) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// fits-table? +{ +v0 := lang.NewSymbol("fits-table?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ints"))), lang.NewKeyword("doc"), "Returns true if the collection of ints can fit within the\n max-table-switch-size, false otherwise.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6668), lang.NewKeyword("end-line"), int(6668), lang.NewKeyword("private"), true)).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("<")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("-")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("apply")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("max")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("seq")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v3}) +v20 := lang.Apply(v12, []any{v15, v19}) +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("apply")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("min")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("seq")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{v3}) +v31 := lang.Apply(v23, []any{v26, v30}) +v32 := lang.Apply(v9, []any{v20, v31}) +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("max-switch-table-size")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v6, []any{v32, v35}) +return v36 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// transient +{ +v0 := lang.NewSymbol("transient").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a new, transient version of the collection, in constant time.\n\n Transients support a parallel set of 'changing' operations, with similar names\n followed by ! - assoc!, conj! etc. These do the same things as their persistent\n counterparts except the return values are themselves transient.\n\n Note in particular that transients are not designed to be bashed in-place. You\n must capture and use the return value in the next call. In this way, they support\n the same code structure as the functional persistent code they replace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3335), lang.NewKeyword("end-line"), int(3335))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, ok := lang.FieldOrMethod(v3, "AsTransient") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "AsTransient"))) +} +var v5 any +switch reflect.TypeOf(v4).Kind() { +case reflect.Func: + v5 = lang.Apply(v4, nil) +default: + v5 = v4 +} +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// StackTraceElement->vec +{ +v0 := lang.NewSymbol("StackTraceElement->vec").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"))), lang.NewKeyword("doc"), "Constructs a data representation for a StackTraceElement: [class method file line]", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(436), lang.NewKeyword("end-line"), int(436))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("symbol")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7, ok := lang.FieldOrMethod(v3, "getClassName") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getClassName"))) +} +var v8 any +switch reflect.TypeOf(v7).Kind() { +case reflect.Func: + v8 = lang.Apply(v7, nil) +default: + v8 = v7 +} +v9 := lang.Apply(v6, []any{v8}) +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("symbol")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13, ok := lang.FieldOrMethod(v3, "getMethodName") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getMethodName"))) +} +var v14 any +switch reflect.TypeOf(v13).Kind() { +case reflect.Func: + v14 = lang.Apply(v13, nil) +default: + v14 = v13 +} +v15 := lang.Apply(v12, []any{v14}) +v16, ok := lang.FieldOrMethod(v3, "getFileName") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getFileName"))) +} +var v17 any +switch reflect.TypeOf(v16).Kind() { +case reflect.Func: + v17 = lang.Apply(v16, nil) +default: + v17 = v16 +} +v18, ok := lang.FieldOrMethod(v3, "getLineNumber") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getLineNumber"))) +} +var v19 any +switch reflect.TypeOf(v18).Kind() { +case reflect.Func: + v19 = lang.Apply(v18, nil) +default: + v19 = v18 +} +v20 := lang.NewVector(v9, v15, v17, v19) +v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(440), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(440), lang.NewKeyword("end-column"), int(94)) +v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v22 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// conj +{ +v0 := lang.NewSymbol("conj").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("xs"))), lang.NewKeyword("doc"), "conj[oin]. Returns a new collection with the xs\n 'added'. (conj nil item) returns (item).\n (conj coll) returns coll. (conj) returns [].\n The 'addition' may happen at different 'places' depending\n on the concrete type.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(73), lang.NewKeyword("end-line"), int(81))).(*lang.Symbol) +var v2 lang.FnFunc +{ // function conj +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v4 := lang.NewVector() +v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(82), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(82), lang.NewKeyword("end-column"), int(14)) +v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v6 + case 1: +v4 := args[0] +return v4 + case 2: +v4 := args[0] +v5 := args[1] +v6 := lang.Apply(lang1.Conj, []any{v4, v5}) +return v6 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := args[1] +v6 := lang.NewList(args[2:]...) +recur_loop_10: +var v7 any +if lang.IsTruthy(v6) { +v9 := lang.Apply(lang1.Conj, []any{v4, v5}) +var v8 any = v9 +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("first")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v6}) +var v10 any = v14 +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("next")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v6}) +var v15 any = v19 +v4 = v8 +v5 = v10 +v6 = v15 +goto recur_loop_10 +} else { +v20 := lang.Apply(lang1.Conj, []any{v4, v5}) +v7 = v20 +} +return v7 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(81), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(88), lang.NewKeyword("end-column"), int(67))).(lang.FnFunc) +v3 := v2 +_ = v3 +} +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// remove-watch +{ +v0 := lang.NewSymbol("remove-watch").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("reference"), lang.NewSymbol("key"))), lang.NewKeyword("doc"), "Removes a watch (set by add-watch) from a reference", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2160), lang.NewKeyword("end-line"), int(2160))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5, _ := lang.FieldOrMethod(v3, "removeWatch") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("removeWatch is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// ensure +{ +v0 := lang.NewSymbol("ensure").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref"))), lang.NewKeyword("doc"), "Must be called in a transaction. Protects the ref from modification\n by other transactions. Returns the in-transaction-value of\n ref. Allows for more concurrency than (ref-set ref @ref)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2480), lang.NewKeyword("end-line"), int(2480))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, _ := lang.FieldOrMethod(v3, "touch") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("touch is not a function"))) +} +v5 := lang.Apply(v4, []any{}) +_ = v5 +v6, _ := lang.FieldOrMethod(v3, "deref") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("deref is not a function"))) +} +v7 := lang.Apply(v6, []any{}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// +' +{ +var v1 lang.FnFunc +v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v2 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +if lang.IsTruthy(v7) { +v4 = closed0 +} else { +v4 = v3 +} +var v3 any = v4 +_ = v3 +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("seq")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("concat")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("seq")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("concat")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v2}) +v40 := lang.Apply(v31, []any{v35, v39}) +v41 := lang.Apply(v28, []any{v40}) +v42 := lang.Apply(v25, []any{v41}) +v43 := lang.Apply(v14, []any{v18, v22, v42}) +v44 := lang.Apply(v11, []any{v43}) +return v44 + case 2: +v2 := args[0] +v3 := args[1] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +if lang.IsTruthy(v8) { +v5 = closed0 +} else { +v5 = v4 +} +var v4 any = v5 +_ = v4 +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("seq")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("concat")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("list")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("list")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("list")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("seq")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("concat")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("list")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v4}) +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("list")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v2}) +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("list")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v3}) +v45 := lang.Apply(v32, []any{v36, v40, v44}) +v46 := lang.Apply(v29, []any{v45}) +v47 := lang.Apply(v26, []any{v46}) +v48 := lang.Apply(v15, []any{v19, v23, v47}) +v49 := lang.Apply(v12, []any{v48}) +return v49 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v2 := args[0] +v3 := args[1] +v4 := lang.NewList(args[2:]...) +var v6 any +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +if lang.IsTruthy(v9) { +v6 = closed0 +} else { +v6 = v5 +} +var v5 any = v6 +_ = v5 +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +var v14 lang.FnFunc +v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v15 := args[0] +v16 := args[1] +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v5}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v15}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v16}) +v52 := lang.Apply(v39, []any{v43, v47, v51}) +v53 := lang.Apply(v36, []any{v52}) +v54 := lang.Apply(v33, []any{v53}) +v55 := lang.Apply(v22, []any{v26, v30, v54}) +v56 := lang.Apply(v19, []any{v55}) +return v56 +}) +v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) +v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v5}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v2}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v3}) +v52 := lang.Apply(v39, []any{v43, v47, v51}) +v53 := lang.Apply(v36, []any{v52}) +v54 := lang.Apply(v33, []any{v53}) +v55 := lang.Apply(v22, []any{v26, v30, v54}) +v56 := lang.Apply(v19, []any{v55}) +v57 := lang.Apply(v13, []any{v16, v56, v4}) +return v57 + } +}) +v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) +} +v5 := lang.Apply(v4, []any{v3, int64(1)}) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v0 := lang.NewSymbol("+'").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the sum of nums. (+') returns 0. Supports arbitrary precision.\n See also: +", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(965), lang.NewKeyword("end-line"), int(965))).(*lang.Symbol) +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +return int64(0) + case 1: +v5 := args[0] +v6 := lang.Apply(lang1.MustAsNumber, []any{v5}) +return v6 + case 2: +v5 := args[0] +v6 := args[1] +v7, _ := lang.FieldOrMethod(lang1.Numbers, "addP") +if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("addP is not a function"))) +} +v8 := lang.Apply(v7, []any{v5, v6}) +return v8 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +v6 := args[1] +v7 := lang.NewList(args[2:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("+'")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("+'")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v5, v6}) +v18 := lang.Apply(v10, []any{v13, v17, v7}) +return v18 + } +}) +v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v3 := ns.InternWithValue(v0, v4, true) +if v0.Meta() != nil { + v3.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// await +{ +v0 := lang.NewSymbol("await").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("agents"))), lang.NewKeyword("doc"), "Blocks the current thread (indefinitely!) until all actions\n dispatched thus far, from this thread or agent, to the agent(s) have\n occurred. Will block on failed agents. Will never return if\n a failed agent is restarted with :clear-actions true or shutdown-agents was called.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3267), lang.NewKeyword("end-line"), int(3267))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.NewList(args[0:]...) +var v4 any +v5 := lang.Apply(nil, nil) +if lang.IsTruthy(v5) { +panic("unimplemented: new with non-constant class type") +} else { +var v6 any +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("*agent*")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +if lang.IsTruthy(v9) { +v10 := lang.Apply(errors10.New, []any{"Can't await in agent action"}) +panic(v10) +} else { +v6 = nil +} +_ = v6 +var v11 any = "unimplemented: new with non-constant class type" +_ = v11 +var v13 lang.FnFunc +v13 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v14 := args[0] +v15, _ := lang.FieldOrMethod(v11, "countDown") +if reflect.TypeOf(v15).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("countDown is not a function"))) +} +v16 := lang.Apply(v15, []any{}) +_ = v16 +return v14 +}) +v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3279), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(3279), lang.NewKeyword("end-column"), int(61)) +v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v12 any = v15 +_ = v12 +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("seq")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, []any{v3}) +var v17 any = v21 +_ = v17 +var v22 any = nil +_ = v22 +var v23 any = int64(0) +_ = v23 +var v24 any = int64(0) +_ = v24 +var v25 any +for { +var v26 any +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("<")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{v24, v23}) +if lang.IsTruthy(v30) { +v32, _ := lang.FieldOrMethod(v22, "nth") +if reflect.TypeOf(v32).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) +} +v33 := lang.Apply(v32, []any{v24}) +var v31 any = v33 +_ = v31 +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("send")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v37, []any{v31, v12}) +_ = v38 +var v39 any = v17 +var v40 any = v22 +var v41 any = v23 +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("unchecked-inc")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +} +v45 := v44.Get() +v46 := lang.Apply(v45, []any{v24}) +var v42 any = v46 +v17 = v39 +v22 = v40 +v23 = v41 +v24 = v42 +continue +} else { +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("seq")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v17}) +var v31 any = v35 +_ = v31 +var v37 any +if lang.IsTruthy(v31) { +var v38 any = v31 +_ = v38 +var v40 any +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("chunked-seq?")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v38}) +if lang.IsTruthy(v44) { +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("chunk-first")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +} +v48 := v47.Get() +v49 := lang.Apply(v48, []any{v38}) +var v45 any = v49 +_ = v45 +v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v53 := v52.FindInternedVar(lang.NewSymbol("chunk-rest")) +if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) +} +v54 := v53.Get() +v55 := lang.Apply(v54, []any{v38}) +var v51 any = v55 +var v56 any = v45 +v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v59 := v58.FindInternedVar(lang.NewSymbol("int")) +if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) +} +v60 := v59.Get() +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("count")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +} +v63 := v62.Get() +v64 := lang.Apply(v63, []any{v45}) +v65 := lang.Apply(v60, []any{v64}) +var v57 any = v65 +v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v68 := v67.FindInternedVar(lang.NewSymbol("int")) +if v68.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) +} +v69 := v68.Get() +v70 := lang.Apply(v69, []any{int64(0)}) +var v66 any = v70 +v17 = v51 +v22 = v56 +v23 = v57 +v24 = v66 +continue +} else { +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("first")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +} +v48 := v47.Get() +v49 := lang.Apply(v48, []any{v38}) +var v45 any = v49 +_ = v45 +v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v52 := v51.FindInternedVar(lang.NewSymbol("send")) +if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) +} +v53 := v52.Get() +v54 := lang.Apply(v53, []any{v45, v12}) +_ = v54 +v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v57 := v56.FindInternedVar(lang.NewSymbol("next")) +if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) +} +v58 := v57.Get() +v59 := lang.Apply(v58, []any{v38}) +var v55 any = v59 +var v60 any = nil +var v61 any = int64(0) +var v62 any = int64(0) +v17 = v55 +v22 = v60 +v23 = v61 +v24 = v62 +continue +} +v37 = v40 +} else { +v37 = nil +} +v26 = v37 +} +v25 = v26 + break +} +_ = v25 +v17, _ := lang.FieldOrMethod(v11, "await") +if reflect.TypeOf(v17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) +} +v18 := lang.Apply(v17, []any{}) +v4 = v18 +} +return v4 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// nary-inline +{ +v0 := lang.NewSymbol("nary-inline").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(948), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(948), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("op")), lang.NewVector(lang.NewSymbol("op"), lang.NewSymbol("unchecked-op"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("nary-inline")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{v3, v3}) +return v7 + case 2: +v3 := args[0] +v4 := args[1] +var v5 lang.FnFunc +v5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v6 := args[0] +var v8 any +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +if lang.IsTruthy(v11) { +v8 = v4 +} else { +v8 = v7 +} +var v7 any = v8 +_ = v7 +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("seq")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("concat")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{lang.NewSymbol(".")}) +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("seq")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("concat")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v7}) +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v6}) +v44 := lang.Apply(v35, []any{v39, v43}) +v45 := lang.Apply(v32, []any{v44}) +v46 := lang.Apply(v29, []any{v45}) +v47 := lang.Apply(v18, []any{v22, v26, v46}) +v48 := lang.Apply(v15, []any{v47}) +return v48 + case 2: +v6 := args[0] +v7 := args[1] +var v9 any +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +if lang.IsTruthy(v12) { +v9 = v4 +} else { +v9 = v8 +} +var v8 any = v9 +_ = v8 +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("seq")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("concat")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("list")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.Apply(v22, []any{lang.NewSymbol(".")}) +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("list")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.Apply(v26, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("list")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("seq")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("concat")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("list")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v8}) +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("list")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v6}) +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("list")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +} +v47 := v46.Get() +v48 := lang.Apply(v47, []any{v7}) +v49 := lang.Apply(v36, []any{v40, v44, v48}) +v50 := lang.Apply(v33, []any{v49}) +v51 := lang.Apply(v30, []any{v50}) +v52 := lang.Apply(v19, []any{v23, v27, v51}) +v53 := lang.Apply(v16, []any{v52}) +return v53 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v6 := args[0] +v7 := args[1] +v8 := lang.NewList(args[2:]...) +var v10 any +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +if lang.IsTruthy(v13) { +v10 = v4 +} else { +v10 = v9 +} +var v9 any = v10 +_ = v9 +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("reduce1")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +var v18 lang.FnFunc +v18 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v19 := args[0] +v20 := args[1] +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol(".")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("list")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("seq")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("concat")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v9}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v19}) +v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v53 := v52.FindInternedVar(lang.NewSymbol("list")) +if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) +} +v54 := v53.Get() +v55 := lang.Apply(v54, []any{v20}) +v56 := lang.Apply(v43, []any{v47, v51, v55}) +v57 := lang.Apply(v40, []any{v56}) +v58 := lang.Apply(v37, []any{v57}) +v59 := lang.Apply(v26, []any{v30, v34, v58}) +v60 := lang.Apply(v23, []any{v59}) +return v60 +}) +v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) +v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol(".")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("list")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("seq")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("concat")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v9}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v6}) +v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v53 := v52.FindInternedVar(lang.NewSymbol("list")) +if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) +} +v54 := v53.Get() +v55 := lang.Apply(v54, []any{v7}) +v56 := lang.Apply(v43, []any{v47, v51, v55}) +v57 := lang.Apply(v40, []any{v56}) +v58 := lang.Apply(v37, []any{v57}) +v59 := lang.Apply(v26, []any{v30, v34, v58}) +v60 := lang.Apply(v23, []any{v59}) +v61 := lang.Apply(v17, []any{v20, v60, v8}) +return v61 + } +}) +v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86)) +v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// array-map +{ +v0 := lang.NewSymbol("array-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keyvals"))), lang.NewKeyword("doc"), "Constructs an array-map. If any keys are equal, they are handled as\n if by repeated uses of assoc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4378), lang.NewKeyword("end-line"), int(4378))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v3, ok := lang.FieldOrMethod(glojure.lang11.PersistentArrayMap, "EMPTY") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", glojure.lang11.PersistentArrayMap, "EMPTY"))) +} +var v4 any +switch reflect.TypeOf(v3).Kind() { +case reflect.Func: + v4 = lang.Apply(v3, nil) +default: + v4 = v3 +} +return v4 + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.NewList(args[0:]...) +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("to-array")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +var v4 any = v8 +_ = v4 +var v10 any +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("odd?")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("alength")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v4}) +v18 := lang.Apply(v13, []any{v17}) +if lang.IsTruthy(v18) { +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("str")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("last")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v3}) +v26 := lang.Apply(v21, []any{"No value supplied for key: ", v25}) +v27 := lang.Apply(lang1.NewIllegalArgumentError, []any{v26}) +panic(v27) +} else { +v28 := lang.Apply(lang1.NewPersistentArrayMapAsIfByAssoc, []any{v4}) +v10 = v28 +} +return v10 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// long +{ +var v1 lang.FnFunc +{ // function long__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/LongCast")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v3}) +v35 := lang.Apply(v26, []any{v30, v34}) +v36 := lang.Apply(v23, []any{v35}) +v37 := lang.Apply(v20, []any{v36}) +v38 := lang.Apply(v9, []any{v13, v17, v37}) +v39 := lang.Apply(v6, []any{v38}) +return v39 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("long").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to long", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3481), lang.NewKeyword("end-line"), int(3481))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := lang.Apply(lang1.LongCast, []any{v4}) +return v5 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// filter +{ +v0 := lang.NewSymbol("filter").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred")), lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the items in coll for which\n (pred item) returns logical true. pred must be free of side-effects.\n Returns a transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2785), lang.NewKeyword("end-line"), int(2785))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +var v6 lang.FnFunc +v6 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v7 := lang.Apply(v5, nil) +return v7 + case 1: +v7 := args[0] +v8 := lang.Apply(v5, []any{v7}) +return v8 + case 2: +v7 := args[0] +v8 := args[1] +var v9 any +v10 := lang.Apply(v3, []any{v8}) +if lang.IsTruthy(v10) { +v11 := lang.Apply(v5, []any{v7, v8}) +v9 = v11 +} else { +v9 = v7 +} +return v9 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2793), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(2799), lang.NewKeyword("end-column"), int(22)) +v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v8 +}) +v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2792), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2799), lang.NewKeyword("end-column"), int(23)) +v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v6 + case 2: +v3 := args[0] +v4 := args[1] +var v5 lang.FnFunc +v5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("seq")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v4}) +var v6 any = v10 +_ = v6 +var v12 any +if lang.IsTruthy(v6) { +var v13 any = v6 +_ = v13 +var v15 any +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("chunked-seq?")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v13}) +if lang.IsTruthy(v19) { +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("chunk-first")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v13}) +var v20 any = v24 +_ = v20 +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("count")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.Apply(v28, []any{v20}) +var v25 any = v29 +_ = v25 +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("chunk-buffer")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v25}) +var v30 any = v34 +_ = v30 +v37 := lang.Apply(lang1.LongCast, []any{v25}) +var v36 any = v37 +_ = v36 +var v39 any = int64(0) +_ = v39 +var v40 any +for { +var v41 any +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("<")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +} +v44 := v43.Get() +v45 := lang.Apply(v44, []any{v39, v36}) +if lang.IsTruthy(v45) { +v47, _ := lang.FieldOrMethod(v20, "nth") +if reflect.TypeOf(v47).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) +} +v48 := lang.Apply(v47, []any{v39}) +var v46 any = v48 +_ = v46 +var v50 any +v51 := lang.Apply(v3, []any{v46}) +if lang.IsTruthy(v51) { +v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v53 := v52.FindInternedVar(lang.NewSymbol("chunk-append")) +if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) +} +v54 := v53.Get() +v55 := lang.Apply(v54, []any{v30, v46}) +v50 = v55 +} else { +v50 = nil +} +_ = v50 +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("unchecked-inc")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +} +v49 := v48.Get() +v50 := lang.Apply(v49, []any{v39}) +var v46 any = v50 +v39 = v46 +continue +} else { +v41 = nil +} +v40 = v41 + break +} +_ = v40 +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("chunk-cons")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("chunk")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +} +v41 := v40.Get() +v42 := lang.Apply(v41, []any{v30}) +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("filter")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +} +v45 := v44.Get() +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("chunk-rest")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +} +v48 := v47.Get() +v49 := lang.Apply(v48, []any{v13}) +v50 := lang.Apply(v45, []any{v3, v49}) +v51 := lang.Apply(v38, []any{v42, v50}) +v15 = v51 +} else { +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("first")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v13}) +var v20 any = v24 +_ = v20 +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("rest")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.Apply(v28, []any{v13}) +var v25 any = v29 +_ = v25 +var v31 any +v32 := lang.Apply(v3, []any{v20}) +if lang.IsTruthy(v32) { +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("cons")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("filter")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v3, v25}) +v40 := lang.Apply(v35, []any{v20, v39}) +v31 = v40 +} else { +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("filter")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v3, v25}) +v31 = v44 +} +v15 = v31 +} +v12 = v15 +} else { +v12 = nil +} +return v12 +}) +v6 := lang.Apply(lang1.NewLazySeq, []any{v5}) +return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// sorted-set-by +{ +v0 := lang.NewSymbol("sorted-set-by").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("comparator"), lang.NewSymbol("&"), lang.NewSymbol("keys"))), lang.NewKeyword("doc"), "Returns a new sorted set with supplied keys, using the supplied\n comparator. Any equal keys are handled as if by repeated uses of\n conj.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(424), lang.NewKeyword("end-line"), int(424))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.NewList(args[1:]...) +v5 := lang.Apply(lang1.CreatePersistentTreeSetWithComparator, []any{v3, v4}) +return v5 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// ns-resolve +{ +v0 := lang.NewSymbol("ns-resolve").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("sym")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("env"), lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Returns the var or Class to which a symbol will be resolved in the\n namespace (unless found in the environment), else nil. Note that\n if the symbol is fully qualified, the var/Class to which it resolves\n need not be present in the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4358), lang.NewKeyword("end-line"), int(4358))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("ns-resolve")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3, nil, v4}) +return v8 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +var v6 any +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("contains?")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v4, v5}) +if lang.IsTruthy(v10) { +v6 = nil +} else { +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("the-ns")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v3}) +v15, _ := lang.FieldOrMethod(runtime3.Compiler, "maybeResolveIn") +if reflect.TypeOf(v15).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("maybeResolveIn is not a function"))) +} +v16 := lang.Apply(v15, []any{v14, v5}) +v6 = v16 +} +return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// prependss +{ +v0 := lang.NewSymbol("prependss").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Prepends a symbol or a seq to coll", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5900), lang.NewKeyword("end-line"), int(5900), lang.NewKeyword("private"), true)).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("symbol?")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v3}) +if lang.IsTruthy(v9) { +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("cons")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{v3, v4}) +v5 = v13 +} else { +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("concat")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v3, v4}) +v5 = v17 +} +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// add-watch +{ +v0 := lang.NewSymbol("add-watch").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("reference"), lang.NewSymbol("key"), lang.NewSymbol("fn"))), lang.NewKeyword("doc"), "Adds a watch function to an agent/atom/var/ref reference. The watch\n fn must be a fn of 4 args: a key, the reference, its old-state, its\n new-state. Whenever the reference's state might have been changed,\n any registered watches will have their functions called. The watch fn\n will be called synchronously, on the agent's thread if an agent,\n before any pending sends if agent or ref. Note that an atom's or\n ref's state may have changed again prior to the fn call, so use\n old/new-state rather than derefing the reference. Note also that watch\n fns may be called from multiple threads simultaneously. Var watchers\n are triggered only by root binding changes, not thread-local\n set!s. Keys must be unique per reference, and can be used to remove\n the watch with remove-watch, but are otherwise considered opaque by\n the watch mechanism.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2142), lang.NewKeyword("end-line"), int(2142))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6, _ := lang.FieldOrMethod(v3, "addWatch") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("addWatch is not a function"))) +} +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// conj! +{ +v0 := lang.NewSymbol("conj!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Adds x to the transient collection, and return coll. The 'addition'\n may happen at different 'places' depending on the concrete type.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3359), lang.NewKeyword("end-line"), int(3359))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v4 := v3.FindInternedVar(lang.NewSymbol("transient")) +if v4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) +} +v5 := v4.Get() +v6 := lang.NewVector() +v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3364), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(3364), lang.NewKeyword("end-column"), int(19)) +v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v9 := lang.Apply(v5, []any{v8}) +return v9 + case 1: +v3 := args[0] +return v3 + case 2: +v3 := args[0] +v4 := args[1] +v5, _ := lang.FieldOrMethod(v3, "Conj") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Conj is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// re-matches +{ +v0 := lang.NewSymbol("re-matches").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("re"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns the match, if any, of string to pattern, using\n java.util.regex.Matcher.matches(). Uses re-groups to return the\n groups.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4910), lang.NewKeyword("end-line"), int(4910))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("re-matcher")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v3, v4}) +var v5 any = v9 +_ = v5 +var v11 any +v12, _ := lang.FieldOrMethod(v5, "matches") +if reflect.TypeOf(v12).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("matches is not a function"))) +} +v13 := lang.Apply(v12, []any{}) +if lang.IsTruthy(v13) { +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("re-groups")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v5}) +v11 = v17 +} else { +v11 = nil +} +return v11 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// aset-int +{ +v0 := lang.NewSymbol("aset-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of int. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3946), lang.NewKeyword("end-line"), int(3948))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("int")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v5}) +v10, _ := lang.FieldOrMethod(nil, "setInt") +if reflect.TypeOf(v10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setInt is not a function"))) +} +v11 := lang.Apply(v10, []any{v3, v4, v9}) +_ = v11 +return v5 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("apply")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("aset-int")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("aget")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v3, v4}) +v17 := lang.Apply(v9, []any{v12, v16, v5, v6}) +return v17 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// read-line +{ +v0 := lang.NewSymbol("read-line").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Reads the next line from stream that is the current value of *in* .", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3797), lang.NewKeyword("end-line"), int(3797))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +var v3 any +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("*in*")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v6, []any{glojure.lang11.LineNumberingPushbackReader, v9}) +if lang.IsTruthy(v10) { +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("*in*")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14, ok := lang.FieldOrMethod(v13, "readLine") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v13, "readLine"))) +} +var v15 any +switch reflect.TypeOf(v14).Kind() { +case reflect.Func: + v15 = lang.Apply(v14, nil) +default: + v15 = v14 +} +v3 = v15 +} else { +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("*in*")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19, ok := lang.FieldOrMethod(v18, "readLine") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v18, "readLine"))) +} +var v20 any +switch reflect.TypeOf(v19).Kind() { +case reflect.Func: + v20 = lang.Apply(v19, nil) +default: + v20 = v19 +} +v3 = v20 +} +return v3 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// with-bindings* +{ +v0 := lang.NewSymbol("with-bindings*").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("binding-map"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Takes a map of Var/value pairs. Installs for the given Vars the associated\n values as thread-local bindings. Then calls f with the supplied arguments.\n Pops the installed bindings after f returned. Returns whatever f returns.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1971), lang.NewKeyword("end-line"), int(1971))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("push-thread-bindings")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v3}) +_ = v9 +var v10 any +func() { +defer func() { +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, nil) +}() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("apply")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v4, v5}) +v10 = v18 +}() +return v10 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// memfn +{ +v0 := lang.NewSymbol("memfn").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Expands into code that creates a fn that expects to be passed an\n object and any args and calls the named instance method on the\n object passing the args. Use when you want to treat a Java method as\n a first-class fn. name may be type-hinted with the method receiver's\n type in order to avoid reflective calls.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3872), lang.NewKeyword("end-line"), int(3872))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("with-meta")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("gensym")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{"target"}) +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("meta")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v5}) +v19 := lang.Apply(v10, []any{v14, v18}) +var v7 any = v19 +_ = v7 +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/fn")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("apply")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("vector")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("seq")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("concat")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +} +v45 := v44.Get() +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("list")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +} +v48 := v47.Get() +v49 := lang.Apply(v48, []any{v7}) +v50 := lang.Apply(v45, []any{v49, v6}) +v51 := lang.Apply(v42, []any{v50}) +v52 := lang.Apply(v36, []any{v39, v51}) +v53 := lang.Apply(v33, []any{v52}) +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("list")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +} +v56 := v55.Get() +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("seq")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +} +v59 := v58.Get() +v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v61 := v60.FindInternedVar(lang.NewSymbol("concat")) +if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) +} +v62 := v61.Get() +v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v64 := v63.FindInternedVar(lang.NewSymbol("list")) +if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) +} +v65 := v64.Get() +v66 := lang.Apply(v65, []any{lang.NewSymbol(".")}) +v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v68 := v67.FindInternedVar(lang.NewSymbol("list")) +if v68.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) +} +v69 := v68.Get() +v70 := lang.Apply(v69, []any{v7}) +v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v72 := v71.FindInternedVar(lang.NewSymbol("list")) +if v72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) +} +v73 := v72.Get() +v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v75 := v74.FindInternedVar(lang.NewSymbol("seq")) +if v75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) +} +v76 := v75.Get() +v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v78 := v77.FindInternedVar(lang.NewSymbol("concat")) +if v78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) +} +v79 := v78.Get() +v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v81 := v80.FindInternedVar(lang.NewSymbol("list")) +if v81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) +} +v82 := v81.Get() +v83 := lang.Apply(v82, []any{v5}) +v84 := lang.Apply(v79, []any{v83, v6}) +v85 := lang.Apply(v76, []any{v84}) +v86 := lang.Apply(v73, []any{v85}) +v87 := lang.Apply(v62, []any{v66, v70, v86}) +v88 := lang.Apply(v59, []any{v87}) +v89 := lang.Apply(v56, []any{v88}) +v90 := lang.Apply(v26, []any{v30, v53, v89}) +v91 := lang.Apply(v23, []any{v90}) +return v91 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// inst? +{ +v0 := lang.NewSymbol("inst?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x satisfies Inst", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6880), lang.NewKeyword("end-line"), int(6880))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +return nil +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// *e +{ +v0 := lang.NewSymbol("*e").WithMeta(lang.NewMap()).(*lang.Symbol) +v1 := ns.Intern(v0) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// set? +{ +v0 := lang.NewSymbol("set?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements IPersistentSet", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4098), lang.NewKeyword("end-line"), int(4098))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{lang1.IPersistentSet, v3}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// simple-keyword? +{ +v0 := lang.NewSymbol("simple-keyword?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a keyword without a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1633), lang.NewKeyword("end-line"), int(1633))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("keyword?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +var v4 any = v8 +_ = v4 +var v10 any +if lang.IsTruthy(v4) { +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("nil?")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("namespace")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v3}) +v18 := lang.Apply(v13, []any{v17}) +v10 = v18 +} else { +v10 = v4 +} +return v10 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// dotimes +{ +v0 := lang.NewSymbol("dotimes").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "bindings => name n\n\n Repeatedly executes body (presumably for side-effects) with name\n bound to integers from 0 through n-1.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3306), lang.NewKeyword("end-line"), int(3306))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +var v7 any +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v5}) +if lang.IsTruthy(v11) { +v7 = nil +} else { +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("str")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("first")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v3}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("meta")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v3}) +v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) +v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) +v28 := lang.Apply(lang1.NewIllegalArgumentError, []any{v27}) +panic(v28) +} +_ = v7 +var v29 any +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("=")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("count")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v5}) +v37 := lang.Apply(v32, []any{int64(2), v36}) +if lang.IsTruthy(v37) { +v29 = nil +} else { +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("str")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("first")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v3}) +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +} +v47 := v46.Get() +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("meta")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v3}) +v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) +v53 := lang.Apply(v40, []any{v44, " requires ", "exactly 2 forms in binding vector", " in ", v47, ":", v52}) +v54 := lang.Apply(lang1.NewIllegalArgumentError, []any{v53}) +panic(v54) +} +_ = v29 +_ = nil +v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v57 := v56.FindInternedVar(lang.NewSymbol("first")) +if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) +} +v58 := v57.Get() +v59 := lang.Apply(v58, []any{v5}) +var v55 any = v59 +_ = v55 +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("second")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +} +v63 := v62.Get() +v64 := lang.Apply(v63, []any{v5}) +var v60 any = v64 +_ = v60 +v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v67 := v66.FindInternedVar(lang.NewSymbol("seq")) +if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) +} +v68 := v67.Get() +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("concat")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +} +v71 := v70.Get() +v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v73 := v72.FindInternedVar(lang.NewSymbol("list")) +if v73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) +} +v74 := v73.Get() +v75 := lang.Apply(v74, []any{lang.NewSymbol("glojure.core/let")}) +v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v77 := v76.FindInternedVar(lang.NewSymbol("list")) +if v77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) +} +v78 := v77.Get() +v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v80 := v79.FindInternedVar(lang.NewSymbol("apply")) +if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) +} +v81 := v80.Get() +v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v83 := v82.FindInternedVar(lang.NewSymbol("vector")) +if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) +} +v84 := v83.Get() +v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v86 := v85.FindInternedVar(lang.NewSymbol("seq")) +if v86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) +} +v87 := v86.Get() +v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v89 := v88.FindInternedVar(lang.NewSymbol("concat")) +if v89.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) +} +v90 := v89.Get() +v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v92 := v91.FindInternedVar(lang.NewSymbol("list")) +if v92.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) +} +v93 := v92.Get() +v94 := lang.Apply(v93, []any{lang.NewSymbol("n__0__auto__")}) +v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v96 := v95.FindInternedVar(lang.NewSymbol("list")) +if v96.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) +} +v97 := v96.Get() +v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v99 := v98.FindInternedVar(lang.NewSymbol("seq")) +if v99.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) +} +v100 := v99.Get() +v101 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v102 := v101.FindInternedVar(lang.NewSymbol("concat")) +if v102.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v102))) +} +v103 := v102.Get() +v104 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v105 := v104.FindInternedVar(lang.NewSymbol("list")) +if v105.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v105))) +} +v106 := v105.Get() +v107 := lang.Apply(v106, []any{lang.NewSymbol("glojure.core/long")}) +v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v109 := v108.FindInternedVar(lang.NewSymbol("list")) +if v109.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) +} +v110 := v109.Get() +v111 := lang.Apply(v110, []any{v60}) +v112 := lang.Apply(v103, []any{v107, v111}) +v113 := lang.Apply(v100, []any{v112}) +v114 := lang.Apply(v97, []any{v113}) +v115 := lang.Apply(v90, []any{v94, v114}) +v116 := lang.Apply(v87, []any{v115}) +v117 := lang.Apply(v81, []any{v84, v116}) +v118 := lang.Apply(v78, []any{v117}) +v119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v120 := v119.FindInternedVar(lang.NewSymbol("list")) +if v120.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v120))) +} +v121 := v120.Get() +v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v123 := v122.FindInternedVar(lang.NewSymbol("seq")) +if v123.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) +} +v124 := v123.Get() +v125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v126 := v125.FindInternedVar(lang.NewSymbol("concat")) +if v126.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v126))) +} +v127 := v126.Get() +v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v129 := v128.FindInternedVar(lang.NewSymbol("list")) +if v129.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v129))) +} +v130 := v129.Get() +v131 := lang.Apply(v130, []any{lang.NewSymbol("glojure.core/loop")}) +v132 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v133 := v132.FindInternedVar(lang.NewSymbol("list")) +if v133.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v133))) +} +v134 := v133.Get() +v135 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v136 := v135.FindInternedVar(lang.NewSymbol("apply")) +if v136.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v136))) +} +v137 := v136.Get() +v138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v139 := v138.FindInternedVar(lang.NewSymbol("vector")) +if v139.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v139))) +} +v140 := v139.Get() +v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v142 := v141.FindInternedVar(lang.NewSymbol("seq")) +if v142.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) +} +v143 := v142.Get() +v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v145 := v144.FindInternedVar(lang.NewSymbol("concat")) +if v145.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) +} +v146 := v145.Get() +v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v148 := v147.FindInternedVar(lang.NewSymbol("list")) +if v148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) +} +v149 := v148.Get() +v150 := lang.Apply(v149, []any{v55}) +v151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v152 := v151.FindInternedVar(lang.NewSymbol("list")) +if v152.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v152))) +} +v153 := v152.Get() +v154 := lang.Apply(v153, []any{int64(0)}) +v155 := lang.Apply(v146, []any{v150, v154}) +v156 := lang.Apply(v143, []any{v155}) +v157 := lang.Apply(v137, []any{v140, v156}) +v158 := lang.Apply(v134, []any{v157}) +v159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v160 := v159.FindInternedVar(lang.NewSymbol("list")) +if v160.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v160))) +} +v161 := v160.Get() +v162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v163 := v162.FindInternedVar(lang.NewSymbol("seq")) +if v163.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v163))) +} +v164 := v163.Get() +v165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v166 := v165.FindInternedVar(lang.NewSymbol("concat")) +if v166.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v166))) +} +v167 := v166.Get() +v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v169 := v168.FindInternedVar(lang.NewSymbol("list")) +if v169.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) +} +v170 := v169.Get() +v171 := lang.Apply(v170, []any{lang.NewSymbol("glojure.core/when")}) +v172 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v173 := v172.FindInternedVar(lang.NewSymbol("list")) +if v173.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v173))) +} +v174 := v173.Get() +v175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v176 := v175.FindInternedVar(lang.NewSymbol("seq")) +if v176.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v176))) +} +v177 := v176.Get() +v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v179 := v178.FindInternedVar(lang.NewSymbol("concat")) +if v179.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) +} +v180 := v179.Get() +v181 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v182 := v181.FindInternedVar(lang.NewSymbol("list")) +if v182.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v182))) +} +v183 := v182.Get() +v184 := lang.Apply(v183, []any{lang.NewSymbol("glojure.core/<")}) +v185 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v186 := v185.FindInternedVar(lang.NewSymbol("list")) +if v186.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v186))) +} +v187 := v186.Get() +v188 := lang.Apply(v187, []any{v55}) +v189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v190 := v189.FindInternedVar(lang.NewSymbol("list")) +if v190.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v190))) +} +v191 := v190.Get() +v192 := lang.Apply(v191, []any{lang.NewSymbol("n__0__auto__")}) +v193 := lang.Apply(v180, []any{v184, v188, v192}) +v194 := lang.Apply(v177, []any{v193}) +v195 := lang.Apply(v174, []any{v194}) +v196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v197 := v196.FindInternedVar(lang.NewSymbol("list")) +if v197.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v197))) +} +v198 := v197.Get() +v199 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v200 := v199.FindInternedVar(lang.NewSymbol("seq")) +if v200.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v200))) +} +v201 := v200.Get() +v202 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v203 := v202.FindInternedVar(lang.NewSymbol("concat")) +if v203.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v203))) +} +v204 := v203.Get() +v205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v206 := v205.FindInternedVar(lang.NewSymbol("list")) +if v206.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v206))) +} +v207 := v206.Get() +v208 := lang.Apply(v207, []any{lang.NewSymbol("recur")}) +v209 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v210 := v209.FindInternedVar(lang.NewSymbol("list")) +if v210.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v210))) +} +v211 := v210.Get() +v212 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v213 := v212.FindInternedVar(lang.NewSymbol("seq")) +if v213.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v213))) +} +v214 := v213.Get() +v215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v216 := v215.FindInternedVar(lang.NewSymbol("concat")) +if v216.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v216))) +} +v217 := v216.Get() +v218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v219 := v218.FindInternedVar(lang.NewSymbol("list")) +if v219.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v219))) +} +v220 := v219.Get() +v221 := lang.Apply(v220, []any{lang.NewSymbol("glojure.core/unchecked-inc")}) +v222 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v223 := v222.FindInternedVar(lang.NewSymbol("list")) +if v223.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v223))) +} +v224 := v223.Get() +v225 := lang.Apply(v224, []any{v55}) +v226 := lang.Apply(v217, []any{v221, v225}) +v227 := lang.Apply(v214, []any{v226}) +v228 := lang.Apply(v211, []any{v227}) +v229 := lang.Apply(v204, []any{v208, v228}) +v230 := lang.Apply(v201, []any{v229}) +v231 := lang.Apply(v198, []any{v230}) +v232 := lang.Apply(v167, []any{v171, v195, v6, v231}) +v233 := lang.Apply(v164, []any{v232}) +v234 := lang.Apply(v161, []any{v233}) +v235 := lang.Apply(v127, []any{v131, v158, v234}) +v236 := lang.Apply(v124, []any{v235}) +v237 := lang.Apply(v121, []any{v236}) +v238 := lang.Apply(v71, []any{v75, v118, v237}) +v239 := lang.Apply(v68, []any{v238}) +return v239 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// aset +{ +var v1 lang.FnFunc +{ // function aset__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("seq")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("concat")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("list")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{lang.NewSymbol(".")}) +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("list")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("list")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("seq")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("concat")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("list")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.Apply(v31, []any{lang.NewSymbol("glojure.core/Aset")}) +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("list")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v3}) +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("list")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("seq")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("concat")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +} +v45 := v44.Get() +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("list")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +} +v48 := v47.Get() +v49 := lang.Apply(v48, []any{lang.NewSymbol("glojure.core/int")}) +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("list")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +} +v52 := v51.Get() +v53 := lang.Apply(v52, []any{v4}) +v54 := lang.Apply(v45, []any{v49, v53}) +v55 := lang.Apply(v42, []any{v54}) +v56 := lang.Apply(v39, []any{v55}) +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("list")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +} +v59 := v58.Get() +v60 := lang.Apply(v59, []any{v5}) +v61 := lang.Apply(v28, []any{v32, v36, v56, v60}) +v62 := lang.Apply(v25, []any{v61}) +v63 := lang.Apply(v22, []any{v62}) +v64 := lang.Apply(v11, []any{v15, v19, v63}) +v65 := lang.Apply(v8, []any{v64}) +return v65 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("aset").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on Java arrays of\n reference types. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(3)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3922), lang.NewKeyword("end-line"), int(3922))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: +v4 := args[0] +v5 := args[1] +v6 := args[2] +v7 := lang.Apply(lang1.SliceSet, []any{v4, v5, v6}) +_ = v7 +return v6 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := args[1] +v6 := args[2] +v7 := lang.NewList(args[3:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("apply")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("aset")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("aget")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v4, v5}) +v18 := lang.Apply(v10, []any{v13, v17, v6, v7}) +return v18 + } +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// *default-data-reader-fn* +{ +v0 := lang.NewSymbol("*default-data-reader-fn*").WithMeta(lang.NewMap(lang.NewKeyword("doc"), "When no data reader is found for a tag and *default-data-reader-fn*\n is non-nil, it will be called with two arguments,\n the tag and the value. If *default-data-reader-fn* is nil (the\n default), an exception will be thrown for the unknown tag.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(59), lang.NewKeyword("column"), int(6), lang.NewKeyword("line"), int(7876), lang.NewKeyword("end-line"), int(7876), lang.NewKeyword("dynamic"), true)).(*lang.Symbol) +v1 := ns.InternWithValue(v0, nil, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// disj! +{ +v0 := lang.NewSymbol("disj!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("set")), lang.NewVector(lang.NewSymbol("set"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("set"), lang.NewSymbol("key"), lang.NewSymbol("&"), lang.NewSymbol("ks"))), lang.NewKeyword("doc"), "disj[oin]. Returns a transient set of the same (hashed/sorted) type, that\n does not contain key(s).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3401), lang.NewKeyword("end-line"), int(3401))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +return v3 + case 2: +v3 := args[0] +v4 := args[1] +v5, _ := lang.FieldOrMethod(v3, "Disjoin") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Disjoin is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +recur_loop_615: +v7, _ := lang.FieldOrMethod(v3, "Disjoin") +if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Disjoin is not a function"))) +} +v8 := lang.Apply(v7, []any{v4}) +var v6 any = v8 +_ = v6 +var v10 any +if lang.IsTruthy(v5) { +var v11 any = v6 +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("first")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v5}) +var v12 any = v16 +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("next")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, []any{v5}) +var v17 any = v21 +v3 = v11 +v4 = v12 +v5 = v17 +goto recur_loop_615 +} else { +v10 = v6 +} +return v10 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// print-object +{ +v0 := lang.NewSymbol("print-object").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(115), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(115), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("print-tagged-object")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("str")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v3}) +v12 := lang.Apply(v7, []any{v3, v11, v4}) +return v12 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// all-ns +{ +v0 := lang.NewSymbol("all-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Returns a sequence of all namespaces.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4146), lang.NewKeyword("end-line"), int(4146))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.Apply(nil, nil) +return v3 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// not +{ +v1 := reflect.TypeOf(false) +v0 := lang.NewSymbol("not").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is logical false, false otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(523), lang.NewKeyword("end-line"), int(523))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +var v5 any +if lang.IsTruthy(v4) { +v5 = false +} else { +v5 = true +} +return v5 +}) +v4 := reflect.TypeOf(false) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// biginteger +{ +v1 := reflect.TypeOf((*big9.Int)(nil)) +v0 := lang.NewSymbol("biginteger").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Coerce to BigInteger", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3634), lang.NewKeyword("end-line"), int(3634))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{big9.*Int, v4}) +if lang.IsTruthy(v9) { +v5 = v4 +} else { +var v10 any +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("instance?")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{lang1.*BigInt, v4}) +if lang.IsTruthy(v14) { +v15, ok := lang.FieldOrMethod(v4, "toBigInteger") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "toBigInteger"))) +} +var v16 any +switch reflect.TypeOf(v15).Kind() { +case reflect.Func: + v16 = lang.Apply(v15, nil) +default: + v16 = v15 +} +v10 = v16 +} else { +var v17 any +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("decimal?")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, []any{v4}) +if lang.IsTruthy(v21) { +v22, ok := lang.FieldOrMethod(v4, "toBigInteger") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "toBigInteger"))) +} +var v23 any +switch reflect.TypeOf(v22).Kind() { +case reflect.Func: + v23 = lang.Apply(v22, nil) +default: + v23 = v22 +} +v17 = v23 +} else { +var v24 any +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("float?")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.Apply(v27, []any{v4}) +if lang.IsTruthy(v28) { +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("double")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.Apply(v31, []any{v4}) +v33 := lang.Apply(lang1.NewBigDecimalFromFloat64, []any{v32}) +v34, ok := lang.FieldOrMethod(v33, "toBigInteger") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v33, "toBigInteger"))) +} +var v35 any +switch reflect.TypeOf(v34).Kind() { +case reflect.Func: + v35 = lang.Apply(v34, nil) +default: + v35 = v34 +} +v24 = v35 +} else { +var v36 any +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("ratio?")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v4}) +if lang.IsTruthy(v40) { +v41, ok := lang.FieldOrMethod(v4, "bigIntegerValue") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "bigIntegerValue"))) +} +var v42 any +switch reflect.TypeOf(v41).Kind() { +case reflect.Func: + v42 = lang.Apply(v41, nil) +default: + v42 = v41 +} +v36 = v42 +} else { +var v43 any +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("number?")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v4}) +if lang.IsTruthy(v47) { +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("long")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v4}) +v52 := lang.Apply(big9.NewInt, []any{v51}) +v43 = v52 +} else { +var v53 any +if lang.IsTruthy(lang.NewKeyword("else")) { +v54 := lang.Apply(BigInteger12., []any{v4}) +v53 = v54 +} else { +v53 = nil +} +v43 = v53 +} +v36 = v43 +} +v24 = v36 +} +v17 = v24 +} +v10 = v17 +} +v5 = v10 +} +return v5 +}) +v4 := reflect.TypeOf((*big9.Int)(nil)) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// uuid? +{ +v0 := lang.NewSymbol("uuid?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a java.util.UUID", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6890), lang.NewKeyword("end-line"), int(6890))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{java.util13.UUID, v3}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// .. +{ +v0 := lang.NewSymbol("..").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("form")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("form"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "form => fieldName-symbol or (instanceMethodName-symbol args*)\n\n Expands into a member access (.) of the first member on the first\n argument, followed by the next member on the result, etc. For\n instance:\n\n (.. System (getProperties) (get \"os.name\"))\n\n expands to:\n\n (. (. System (getProperties)) (get \"os.name\"))\n\n but is easier to write, read, and understand.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1657), lang.NewKeyword("end-line"), int(1657))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 4: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("seq")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("concat")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("list")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{lang.NewSymbol(".")}) +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("list")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v5}) +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("list")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v6}) +v25 := lang.Apply(v12, []any{v16, v20, v24}) +v26 := lang.Apply(v9, []any{v25}) +return v26 + default: + if len(args) < 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := lang.NewList(args[4:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("seq")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("concat")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("..")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol(".")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v5}) +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("list")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v37, []any{v6}) +v39 := lang.Apply(v26, []any{v30, v34, v38}) +v40 := lang.Apply(v23, []any{v39}) +v41 := lang.Apply(v20, []any{v40}) +v42 := lang.Apply(v13, []any{v17, v41, v7}) +v43 := lang.Apply(v10, []any{v42}) +return v43 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// not-every? +{ +v1 := reflect.TypeOf(false) +v0 := lang.NewSymbol("not-every?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns false if (pred x) is logical true for every x in\n coll, else true.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(2677), lang.NewKeyword("end-line"), int(2682))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v4 := lang.Apply(closed2, nil) +v5 := lang.Apply(closed1, []any{v4}) +return v5 + case 1: +v4 := args[0] +v5 := lang.Apply(closed2, []any{v4}) +v6 := lang.Apply(closed1, []any{v5}) +return v6 + case 2: +v4 := args[0] +v5 := args[1] +v6 := lang.Apply(closed2, []any{v4, v5}) +v7 := lang.Apply(closed1, []any{v6}) +return v7 + case 3: +v4 := args[0] +v5 := args[1] +v6 := args[2] +v7 := lang.Apply(closed2, []any{v4, v5, v6}) +v8 := lang.Apply(closed1, []any{v7}) +return v8 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := args[1] +v6 := args[2] +v7 := lang.NewList(args[3:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("apply")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{closed2, v4, v5, v6, v7}) +v12 := lang.Apply(closed1, []any{v11}) +return v12 + } +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2559), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2564), lang.NewKeyword("end-column"), int(49))).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// system-newline +{ +v0 := lang.NewSymbol("system-newline").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3695), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(3695), lang.NewKeyword("end-column"), int(40), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, "\n", true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// remove +{ +v0 := lang.NewSymbol("remove").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred")), lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the items in coll for which\n (pred item) returns logical false. pred must be free of side-effects.\n Returns a transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2818), lang.NewKeyword("end-line"), int(2818))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("filter")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("complement")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v3}) +v11 := lang.Apply(v6, []any{v10}) +return v11 + case 2: +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("filter")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("complement")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v3}) +v12 := lang.Apply(v7, []any{v11, v4}) +return v12 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// maybe-min-hash +{ +v0 := lang.NewSymbol("maybe-min-hash").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("hashes"))), lang.NewKeyword("doc"), "takes a collection of hashes and returns [shift mask] or nil if none found", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6647), lang.NewKeyword("end-line"), int(6647), lang.NewKeyword("private"), true)).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("first")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("filter")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +var v10 lang.FnFunc +v10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v11 := args[0] +var v12 any = v11 +_ = v12 +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("nth")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v12, int64(0), nil}) +var v13 any = v17 +_ = v13 +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("nth")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v12, int64(1), nil}) +var v18 any = v22 +_ = v18 +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("apply")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("distinct?")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("map")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +var v33 lang.FnFunc +v33 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v34 := args[0] +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("shift-mask")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v37, []any{v13, v18, v34}) +return v38 +}) +v34 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6652), lang.NewKeyword("column"), int(37), lang.NewKeyword("end-line"), int(6652), lang.NewKeyword("end-column"), int(55)) +v35, err := lang.WithMeta(v33, v34.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v36 := lang.Apply(v32, []any{v35, v3}) +v37 := lang.Apply(v26, []any{v29, v36}) +return v37 +}) +v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6651), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(6652), lang.NewKeyword("end-column"), int(65)) +v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v14 lang.FnFunc +{ // function iter__181 +v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v16 := args[0] +var v17 lang.FnFunc +v17 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +var v18 any = v18 +_ = v18 +var v19 any +for { +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v18}) +var v20 any = v24 +_ = v20 +var v26 any +if lang.IsTruthy(v20) { +var v27 any = v20 +_ = v27 +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("first")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.Apply(v32, []any{v27}) +var v29 any = v33 +_ = v29 +var v36 lang.FnFunc +{ // function iter__183 +v36 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v38 := args[0] +var v39 lang.FnFunc +v39 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +var v40 any = v40 +_ = v40 +var v41 any +for { +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("seq")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +} +v45 := v44.Get() +v46 := lang.Apply(v45, []any{v40}) +var v42 any = v46 +_ = v42 +var v48 any +if lang.IsTruthy(v42) { +var v49 any = v42 +_ = v49 +var v51 any +v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v53 := v52.FindInternedVar(lang.NewSymbol("chunked-seq?")) +if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) +} +v54 := v53.Get() +v55 := lang.Apply(v54, []any{v49}) +if lang.IsTruthy(v55) { +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("chunk-first")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +} +v59 := v58.Get() +v60 := lang.Apply(v59, []any{v49}) +var v56 any = v60 +_ = v56 +v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v63 := v62.FindInternedVar(lang.NewSymbol("int")) +if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +} +v64 := v63.Get() +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("count")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +} +v67 := v66.Get() +v68 := lang.Apply(v67, []any{v56}) +v69 := lang.Apply(v64, []any{v68}) +var v61 any = v69 +_ = v61 +v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v72 := v71.FindInternedVar(lang.NewSymbol("chunk-buffer")) +if v72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) +} +v73 := v72.Get() +v74 := lang.Apply(v73, []any{v61}) +var v70 any = v74 +_ = v70 +var v76 any +v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v79 := v78.FindInternedVar(lang.NewSymbol("int")) +if v79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) +} +v80 := v79.Get() +v81 := lang.Apply(v80, []any{int64(0)}) +var v77 any = v81 +_ = v77 +var v82 any +for { +var v83 any +v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v85 := v84.FindInternedVar(lang.NewSymbol("<")) +if v85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) +} +v86 := v85.Get() +v87 := lang.Apply(v86, []any{v77, v61}) +if lang.IsTruthy(v87) { +v89, _ := lang.FieldOrMethod(v56, "nth") +if reflect.TypeOf(v89).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) +} +v90 := lang.Apply(v89, []any{v77}) +var v88 any = v90 +_ = v88 +v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v93 := v92.FindInternedVar(lang.NewSymbol("chunk-append")) +if v93.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) +} +v94 := v93.Get() +v95 := lang.NewVector(v88, v29) +v96 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6655), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(6655), lang.NewKeyword("end-column"), int(26)) +v97, err := lang.WithMeta(v95, v96.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v98 := lang.Apply(v94, []any{v70, v97}) +_ = v98 +v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v101 := v100.FindInternedVar(lang.NewSymbol("unchecked-inc")) +if v101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) +} +v102 := v101.Get() +v103 := lang.Apply(v102, []any{v77}) +var v99 any = v103 +v77 = v99 +continue +} else { +v83 = true +} +v82 = v83 + break +} +if lang.IsTruthy(v82) { +v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v78 := v77.FindInternedVar(lang.NewSymbol("chunk-cons")) +if v78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) +} +v79 := v78.Get() +v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v81 := v80.FindInternedVar(lang.NewSymbol("chunk")) +if v81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) +} +v82 := v81.Get() +v83 := lang.Apply(v82, []any{v70}) +v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v85 := v84.FindInternedVar(lang.NewSymbol("chunk-rest")) +if v85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) +} +v86 := v85.Get() +v87 := lang.Apply(v86, []any{v49}) +v88 := lang.Apply(v37, []any{v87}) +v89 := lang.Apply(v79, []any{v83, v88}) +v76 = v89 +} else { +v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v91 := v90.FindInternedVar(lang.NewSymbol("chunk-cons")) +if v91.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) +} +v92 := v91.Get() +v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v94 := v93.FindInternedVar(lang.NewSymbol("chunk")) +if v94.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) +} +v95 := v94.Get() +v96 := lang.Apply(v95, []any{v70}) +v97 := lang.Apply(v92, []any{v96, nil}) +v76 = v97 +} +v51 = v76 +} else { +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("first")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +} +v59 := v58.Get() +v60 := lang.Apply(v59, []any{v49}) +var v56 any = v60 +_ = v56 +v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v63 := v62.FindInternedVar(lang.NewSymbol("cons")) +if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +} +v64 := v63.Get() +v65 := lang.NewVector(v56, v29) +v66 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6655), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(6655), lang.NewKeyword("end-column"), int(26)) +v67, err := lang.WithMeta(v65, v66.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v69 := v68.FindInternedVar(lang.NewSymbol("rest")) +if v69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) +} +v70 := v69.Get() +v71 := lang.Apply(v70, []any{v49}) +v72 := lang.Apply(v37, []any{v71}) +v73 := lang.Apply(v64, []any{v67, v72}) +v51 = v73 +} +v48 = v51 +} else { +v48 = nil +} +v41 = v48 + break +} +return v41 +}) +v40 := lang.Apply(lang1.NewLazySeq, []any{v39}) +return v40 +}) +v37 := v36 +_ = v37 +} +var v35 any = v36 +_ = v35 +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("seq")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("range")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v43, []any{int64(0), int64(31)}) +v45 := lang.Apply(v35, []any{v44}) +v46 := lang.Apply(v40, []any{v45}) +var v37 any = v46 +_ = v37 +var v48 any +if lang.IsTruthy(v37) { +v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v50 := v49.FindInternedVar(lang.NewSymbol("concat")) +if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) +} +v51 := v50.Get() +v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v53 := v52.FindInternedVar(lang.NewSymbol("rest")) +if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) +} +v54 := v53.Get() +v55 := lang.Apply(v54, []any{v18}) +v56 := lang.Apply(v15, []any{v55}) +v57 := lang.Apply(v51, []any{v37, v56}) +v48 = v57 +} else { +v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v60 := v59.FindInternedVar(lang.NewSymbol("rest")) +if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) +} +v61 := v60.Get() +v62 := lang.Apply(v61, []any{v18}) +var v58 any = v62 +v18 = v58 +continue +} +v26 = v48 +} else { +v26 = nil +} +v19 = v26 + break +} +return v19 +}) +v18 := lang.Apply(lang1.NewLazySeq, []any{v17}) +return v18 +}) +v15 := v14 +_ = v15 +} +var v13 any = v14 +_ = v13 +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("map")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +var v19 lang.FnFunc +v19 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v20 := args[0] +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("dec")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("bit-shift-left")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.Apply(v26, []any{int64(1), v20}) +v28 := lang.Apply(v23, []any{v27}) +return v28 +}) +v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6653), lang.NewKeyword("column"), int(29), lang.NewKeyword("end-line"), int(6653), lang.NewKeyword("end-column"), int(55)) +v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("range")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("inc")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("max-mask-bits")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v27, []any{v30}) +v32 := lang.Apply(v24, []any{int64(1), v31}) +v33 := lang.Apply(v18, []any{v21, v32}) +v34 := lang.Apply(v13, []any{v33}) +v13 := lang.Apply(v9, []any{v12, v34}) +v14 := lang.Apply(v6, []any{v13}) +return v14 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// rem +{ +var v1 lang.FnFunc +{ // function rem__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("concat")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("list")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("seq")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("concat")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("list")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/remainder")}) +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v4}) +v40 := lang.Apply(v27, []any{v31, v35, v39}) +v41 := lang.Apply(v24, []any{v40}) +v42 := lang.Apply(v21, []any{v41}) +v43 := lang.Apply(v10, []any{v14, v18, v42}) +v44 := lang.Apply(v7, []any{v43}) +return v44 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("rem").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"), lang.NewSymbol("div"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "remainder of dividing numerator by denominator.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1274), lang.NewKeyword("end-line"), int(1274))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := args[1] +v6, _ := lang.FieldOrMethod(lang1.Numbers, "remainder") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("remainder is not a function"))) +} +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// unchecked-int +{ +var v1 lang.FnFunc +{ // function unchecked-int__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/UncheckedIntCast")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v3}) +v35 := lang.Apply(v26, []any{v30, v34}) +v36 := lang.Apply(v23, []any{v35}) +v37 := lang.Apply(v20, []any{v36}) +v38 := lang.Apply(v9, []any{v13, v17, v37}) +v39 := lang.Apply(v6, []any{v38}) +return v39 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("unchecked-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to int. Subject to rounding or truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3535), lang.NewKeyword("end-line"), int(3535))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := lang.Apply(lang1.UncheckedIntCast, []any{v4}) +return v5 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// print-ctor +{ +v0 := lang.NewSymbol("print-ctor").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(95), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(95), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("print-args"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.Apply(lang1.WriteWriter, []any{v5, "#=("}) +_ = v6 +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("class")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v3}) +v11, ok := lang.FieldOrMethod(v10, "Name") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v10, "Name"))) +} +var v12 any +switch reflect.TypeOf(v11).Kind() { +case reflect.Func: + v12 = lang.Apply(v11, nil) +default: + v12 = v11 +} +v13 := lang.Apply(lang1.WriteWriter, []any{v5, v12}) +_ = v13 +v14 := lang.Apply(lang1.WriteWriter, []any{v5, ". "}) +_ = v14 +v15 := lang.Apply(v4, []any{v3, v5}) +_ = v15 +v16 := lang.Apply(lang1.WriteWriter, []any{v5, ")"}) +return v16 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// ex-info +{ +v0 := lang.NewSymbol("ex-info").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("msg"), lang.NewSymbol("map")), lang.NewVector(lang.NewSymbol("msg"), lang.NewSymbol("map"), lang.NewSymbol("cause"))), lang.NewKeyword("doc"), "Create an instance of ExceptionInfo, a RuntimeException subclass\n that carries a map of additional data.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4803), lang.NewKeyword("end-line"), int(4803))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("elide-top-frames")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(ExceptionInfo14., []any{v3, v4}) +v9 := lang.Apply(v7, []any{v8, "glojure.core$ex_info"}) +return v9 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("elide-top-frames")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(ExceptionInfo14., []any{v3, v4, v5}) +v10 := lang.Apply(v8, []any{v9, "glojure.core$ex_info"}) +return v10 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// aset-boolean +{ +v0 := lang.NewSymbol("aset-boolean").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of boolean. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3956), lang.NewKeyword("end-line"), int(3958))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("boolean")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v5}) +v10, _ := lang.FieldOrMethod(nil, "setBoolean") +if reflect.TypeOf(v10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setBoolean is not a function"))) +} +v11 := lang.Apply(v10, []any{v3, v4, v9}) +_ = v11 +return v5 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("apply")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("aset-boolean")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("aget")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v3, v4}) +v17 := lang.Apply(v9, []any{v12, v16, v5, v6}) +return v17 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// binding-conveyor-fn +{ +v0 := lang.NewSymbol("binding-conveyor-fn").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2020), lang.NewKeyword("end-line"), int(2020), lang.NewKeyword("private"), true)).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v5 := lang.Apply(lang1.CloneThreadBindingFrame, nil) +var v4 any = v5 +_ = v4 +var v7 lang.FnFunc +v7 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v8 := lang.Apply(lang1.ResetThreadBindingFrame, []any{v4}) +_ = v8 +v9 := lang.Apply(v3, nil) +return v9 + case 1: +v8 := args[0] +v9 := lang.Apply(lang1.ResetThreadBindingFrame, []any{v4}) +_ = v9 +v10 := lang.Apply(v3, []any{v8}) +return v10 + case 2: +v8 := args[0] +v9 := args[1] +v10 := lang.Apply(lang1.ResetThreadBindingFrame, []any{v4}) +_ = v10 +v11 := lang.Apply(v3, []any{v8, v9}) +return v11 + case 3: +v8 := args[0] +v9 := args[1] +v10 := args[2] +v11 := lang.Apply(lang1.ResetThreadBindingFrame, []any{v4}) +_ = v11 +v12 := lang.Apply(v3, []any{v8, v9, v10}) +return v12 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v8 := args[0] +v9 := args[1] +v10 := args[2] +v11 := lang.NewList(args[3:]...) +v12 := lang.Apply(lang1.ResetThreadBindingFrame, []any{v4}) +_ = v12 +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("apply")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v3, v8, v9, v10, v11}) +return v16 + } +}) +v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2025), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2040), lang.NewKeyword("end-column"), int(31)) +v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v9 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// get-thread-bindings +{ +v0 := lang.NewSymbol("get-thread-bindings").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Get a map with the Var/value pairs which is currently in effect for the\n current thread.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1937), lang.NewKeyword("end-line"), int(1937))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.Apply(nil, nil) +return v3 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// re-groups +{ +v0 := lang.NewSymbol("re-groups").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"))), lang.NewKeyword("doc"), "Returns the groups from the most recent match/find. If there are no\n nested groups, returns a string of the entire match. If there are\n nested groups, returns a vector of the groups, the first element\n being the entire match.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4882), lang.NewKeyword("end-line"), int(4882))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v5, _ := lang.FieldOrMethod(v3, "groupCount") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("groupCount is not a function"))) +} +v6 := lang.Apply(v5, []any{}) +var v4 any = v6 +_ = v4 +var v8 any +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("zero?")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v4}) +if lang.IsTruthy(v12) { +v13, _ := lang.FieldOrMethod(v3, "group") +if reflect.TypeOf(v13).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("group is not a function"))) +} +v14 := lang.Apply(v13, []any{}) +v8 = v14 +} else { +v16 := lang.NewVector() +v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4893), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(4893), lang.NewKeyword("end-column"), int(21)) +v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v15 any = v18 +_ = v15 +var v19 any = int64(0) +_ = v19 +var v20 any +for { +var v21 any +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("<=")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v19, v4}) +if lang.IsTruthy(v25) { +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("conj")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30, _ := lang.FieldOrMethod(v3, "groupInt") +if reflect.TypeOf(v30).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("groupInt is not a function"))) +} +v31 := lang.Apply(v30, []any{v19}) +v32 := lang.Apply(v29, []any{v15, v31}) +var v26 any = v32 +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("inc")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.Apply(v36, []any{v19}) +var v33 any = v37 +v15 = v26 +v19 = v33 +continue +} else { +v21 = v15 +} +v20 = v21 + break +} +v8 = v20 +} +return v8 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// await-for +{ +v0 := lang.NewSymbol("await-for").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("timeout-ms"), lang.NewSymbol("&"), lang.NewSymbol("agents"))), lang.NewKeyword("doc"), "Blocks the current thread until all actions dispatched thus\n far (from this thread or agent) to the agents have occurred, or the\n timeout (in milliseconds) has elapsed. Returns logical false if\n returning due to timeout, logical true otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3289), lang.NewKeyword("end-line"), int(3289))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.NewList(args[1:]...) +var v5 any +v6 := lang.Apply(nil, nil) +if lang.IsTruthy(v6) { +panic("unimplemented: new with non-constant class type") +} else { +var v7 any +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("*agent*")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +if lang.IsTruthy(v10) { +v11 := lang.Apply(errors10.New, []any{"Can't await in agent action"}) +panic(v11) +} else { +v7 = nil +} +_ = v7 +var v12 any = "unimplemented: new with non-constant class type" +_ = v12 +var v14 lang.FnFunc +v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v15 := args[0] +v16, _ := lang.FieldOrMethod(v12, "countDown") +if reflect.TypeOf(v16).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("countDown is not a function"))) +} +v17 := lang.Apply(v16, []any{}) +_ = v17 +return v15 +}) +v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3301), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(3301), lang.NewKeyword("end-column"), int(62)) +v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v13 any = v16 +_ = v13 +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("seq")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v4}) +var v18 any = v22 +_ = v18 +var v23 any = nil +_ = v23 +var v24 any = int64(0) +_ = v24 +var v25 any = int64(0) +_ = v25 +var v26 any +for { +var v27 any +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("<")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{v25, v24}) +if lang.IsTruthy(v31) { +v33, _ := lang.FieldOrMethod(v23, "nth") +if reflect.TypeOf(v33).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) +} +v34 := lang.Apply(v33, []any{v25}) +var v32 any = v34 +_ = v32 +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("send")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v32, v13}) +_ = v39 +var v40 any = v18 +var v41 any = v23 +var v42 any = v24 +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("unchecked-inc")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v25}) +var v43 any = v47 +v18 = v40 +v23 = v41 +v24 = v42 +v25 = v43 +continue +} else { +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("seq")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v18}) +var v32 any = v36 +_ = v32 +var v38 any +if lang.IsTruthy(v32) { +var v39 any = v32 +_ = v39 +var v41 any +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("chunked-seq?")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +} +v44 := v43.Get() +v45 := lang.Apply(v44, []any{v39}) +if lang.IsTruthy(v45) { +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("chunk-first")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +} +v49 := v48.Get() +v50 := lang.Apply(v49, []any{v39}) +var v46 any = v50 +_ = v46 +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("chunk-rest")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +} +v55 := v54.Get() +v56 := lang.Apply(v55, []any{v39}) +var v52 any = v56 +var v57 any = v46 +v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v60 := v59.FindInternedVar(lang.NewSymbol("int")) +if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) +} +v61 := v60.Get() +v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v63 := v62.FindInternedVar(lang.NewSymbol("count")) +if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +} +v64 := v63.Get() +v65 := lang.Apply(v64, []any{v46}) +v66 := lang.Apply(v61, []any{v65}) +var v58 any = v66 +v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v69 := v68.FindInternedVar(lang.NewSymbol("int")) +if v69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) +} +v70 := v69.Get() +v71 := lang.Apply(v70, []any{int64(0)}) +var v67 any = v71 +v18 = v52 +v23 = v57 +v24 = v58 +v25 = v67 +continue +} else { +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("first")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +} +v49 := v48.Get() +v50 := lang.Apply(v49, []any{v39}) +var v46 any = v50 +_ = v46 +v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v53 := v52.FindInternedVar(lang.NewSymbol("send")) +if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) +} +v54 := v53.Get() +v55 := lang.Apply(v54, []any{v46, v13}) +_ = v55 +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("next")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +} +v59 := v58.Get() +v60 := lang.Apply(v59, []any{v39}) +var v56 any = v60 +var v61 any = nil +var v62 any = int64(0) +var v63 any = int64(0) +v18 = v56 +v23 = v61 +v24 = v62 +v25 = v63 +continue +} +v38 = v41 +} else { +v38 = nil +} +v27 = v38 +} +v26 = v27 + break +} +_ = v26 +v18, ok := lang.FieldOrMethod(java.util.concurrent15.TimeUnit, "MILLISECONDS") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", java.util.concurrent15.TimeUnit, "MILLISECONDS"))) +} +var v19 any +switch reflect.TypeOf(v18).Kind() { +case reflect.Func: + v19 = lang.Apply(v18, nil) +default: + v19 = v18 +} +v20, _ := lang.FieldOrMethod(v12, "await") +if reflect.TypeOf(v20).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) +} +v21 := lang.Apply(v20, []any{v3, v19}) +v5 = v21 +} +return v5 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// mix-collection-hash +{ +v0 := lang.NewSymbol("mix-collection-hash").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("hash-basis"), lang.NewSymbol("count"))), lang.NewKeyword("doc"), "Mix final collection hash for ordered or unordered collections.\n hash-basis is the combined collection hash, count is the number\n of elements included in the basis. Note this is the hash code\n consistent with =, different from .hashCode.\n See http://glojure.org/data_structures#hash for full algorithms.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5199), lang.NewKeyword("end-line"), int(5199))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.Apply(nil, []any{v3, v4}) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// distinct +{ +v0 := lang.NewSymbol("distinct").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the elements of coll with duplicates removed.\n Returns a stateful transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5053), lang.NewKeyword("end-line"), int(5053))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("volatile!")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.CreatePersistentTreeSet() +v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5060), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(5060), lang.NewKeyword("end-column"), int(30)) +v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v12 := lang.Apply(v8, []any{v11}) +var v5 any = v12 +_ = v5 +var v14 lang.FnFunc +v14 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v15 := lang.Apply(v4, nil) +return v15 + case 1: +v15 := args[0] +v16 := lang.Apply(v4, []any{v15}) +return v16 + case 2: +v15 := args[0] +v16 := args[1] +var v17 any +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("contains?")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("deref")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v5}) +v25 := lang.Apply(v20, []any{v24, v16}) +if lang.IsTruthy(v25) { +v17 = v15 +} else { +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("conj")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29, ok := lang.FieldOrMethod(v5, "Deref") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "Deref"))) +} +var v30 any +switch reflect.TypeOf(v29).Kind() { +case reflect.Func: + v30 = lang.Apply(v29, nil) +default: + v30 = v29 +} +v31 := lang.Apply(v28, []any{v30, v16}) +v32, _ := lang.FieldOrMethod(v5, "reset") +if reflect.TypeOf(v32).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) +} +v33 := lang.Apply(v32, []any{v31}) +_ = v33 +v34 := lang.Apply(v4, []any{v15, v16}) +v17 = v34 +} +return v17 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5061), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(5068), lang.NewKeyword("end-column"), int(37)) +v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v16 +}) +v4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5059), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(5068), lang.NewKeyword("end-column"), int(39)) +v5, err := lang.WithMeta(v3, v4.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v5 + case 1: +v3 := args[0] +var v5 lang.FnFunc +{ // function step +v5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v7 := args[0] +v8 := args[1] +var v9 lang.FnFunc +v9 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +var v10 lang.FnFunc +v10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v11 := args[0] +v12 := args[1] +recur_loop_877: +var v13 any = v11 +_ = v13 +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("nth")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v13, int64(0), nil}) +var v14 any = v18 +_ = v14 +var v19 any = v13 +_ = v19 +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("seq")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v19}) +var v21 any = v25 +_ = v21 +var v27 any +if lang.IsTruthy(v21) { +var v28 any = v21 +_ = v28 +var v30 any +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("contains?")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v12, v14}) +if lang.IsTruthy(v34) { +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("rest")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v28}) +var v35 any = v39 +var v40 any = v12 +v11 = v35 +v12 = v40 +goto recur_loop_877 +} else { +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("cons")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("rest")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v28}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("conj")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v12, v14}) +v52 := lang.Apply(v6, []any{v47, v51}) +v53 := lang.Apply(v43, []any{v14, v52}) +v30 = v53 +} +v27 = v30 +} else { +v27 = nil +} +return v27 +}) +v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5072), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(5076), lang.NewKeyword("end-column"), int(66)) +v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v13 := lang.Apply(v12, []any{v7, v8}) +return v13 +}) +v10 := lang.Apply(lang1.NewLazySeq, []any{v9}) +return v10 +}) +v6 := v5 +_ = v6 +} +v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5070), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(5077), lang.NewKeyword("end-column"), int(29)) +v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v4 any = v7 +_ = v4 +v9 := lang.CreatePersistentTreeSet() +v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5078), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(5078), lang.NewKeyword("end-column"), int(19)) +v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v12 := lang.Apply(v4, []any{v3, v11}) +return v12 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// pr-on +{ +v0 := lang.NewSymbol("pr-on").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("w"))), lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3669), lang.NewKeyword("end-line"), int(3669), lang.NewKeyword("private"), true)).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("*print-dup*")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +if lang.IsTruthy(v8) { +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("print-dup")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v3, v4}) +v5 = v12 +} else { +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("print-method")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v3, v4}) +v5 = v16 +} +_ = v5 +return nil +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// seq-to-map-for-destructuring +{ +v0 := lang.NewSymbol("seq-to-map-for-destructuring").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Builds a map from a seq as described in\n https://glojure.org/reference/special_forms#keyword-arguments", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(34), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4390), lang.NewKeyword("end-line"), int(4390))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("next")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +if lang.IsTruthy(v8) { +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("to-array")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v3}) +v13 := lang.Apply(lang1.NewPersistentArrayMapAsIfByAssoc, []any{v12}) +v4 = v13 +} else { +var v14 any +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("seq")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v3}) +if lang.IsTruthy(v18) { +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("first")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v3}) +v14 = v22 +} else { +v14 = nil +} +v4 = v14 +} +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// take-while +{ +v0 := lang.NewSymbol("take-while").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred")), lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of successive items from coll while\n (pred item) returns logical true. pred must be free of side-effects.\n Returns a transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2880), lang.NewKeyword("end-line"), int(2880))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +var v6 lang.FnFunc +v6 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v7 := lang.Apply(v5, nil) +return v7 + case 1: +v7 := args[0] +v8 := lang.Apply(v5, []any{v7}) +return v8 + case 2: +v7 := args[0] +v8 := args[1] +var v9 any +v10 := lang.Apply(v3, []any{v8}) +if lang.IsTruthy(v10) { +v11 := lang.Apply(v5, []any{v7, v8}) +v9 = v11 +} else { +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("reduced")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v7}) +v9 = v15 +} +return v9 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2888), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(2894), lang.NewKeyword("end-column"), int(33)) +v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v8 +}) +v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2887), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2894), lang.NewKeyword("end-column"), int(34)) +v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v6 + case 2: +v3 := args[0] +v4 := args[1] +var v5 lang.FnFunc +v5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("seq")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v4}) +var v6 any = v10 +_ = v6 +var v12 any +if lang.IsTruthy(v6) { +var v13 any = v6 +_ = v13 +var v15 any +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("first")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v13}) +v20 := lang.Apply(v3, []any{v19}) +if lang.IsTruthy(v20) { +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("cons")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("first")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v13}) +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("take-while")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("rest")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v13}) +v35 := lang.Apply(v30, []any{v3, v34}) +v36 := lang.Apply(v23, []any{v27, v35}) +v15 = v36 +} else { +v15 = nil +} +v12 = v15 +} else { +v12 = nil +} +return v12 +}) +v6 := lang.Apply(lang1.NewLazySeq, []any{v5}) +return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// restart-agent +{ +v0 := lang.NewSymbol("restart-agent").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("new-state"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "When an agent is failed, changes the agent state to new-state and\n then un-fails the agent so that sends are allowed again. If\n a :clear-actions true option is given, any actions queued on the\n agent that were being held while it was failed will be discarded,\n otherwise those held actions will proceed. The new-state must pass\n the validator if any, or restart will throw an exception and the\n agent will remain failed with its old state and error. Watchers, if\n any, will NOT be notified of the new state. Throws an exception if\n the agent is not failed.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2175), lang.NewKeyword("end-line"), int(2175))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("apply")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("hash-map")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v9, []any{v12, v5}) +var v6 any = v13 +_ = v6 +var v15 any +v16 := lang.Apply(lang.NewKeyword("clear-actions"), []any{v6}) +if lang.IsTruthy(v16) { +v15 = true +} else { +v15 = false +} +v17, _ := lang.FieldOrMethod(v3, "restart") +if reflect.TypeOf(v17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("restart is not a function"))) +} +v18 := lang.Apply(v17, []any{v4, v15}) +return v18 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// println-str +{ +v1 := reflect.TypeOf("") +v0 := lang.NewSymbol("println-str").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("xs"))), lang.NewKeyword("doc"), "println to a string, returning it", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4785), lang.NewKeyword("end-line"), int(4785))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := lang.NewList(args[0:]...) +var v5 any = "unimplemented: new with non-constant class type" +_ = v5 +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("push-thread-bindings")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("hash-map")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*out*")) +v15 := lang.Apply(v13, []any{v14, v5}) +v16 := lang.Apply(v10, []any{v15}) +_ = v16 +var v17 any +func() { +defer func() { +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, nil) +}() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("apply")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("println")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.Apply(v24, []any{v27, v4}) +_ = v28 +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("str")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.Apply(v31, []any{v5}) +v17 = v32 +}() +return v17 + } +}) +v4 := reflect.TypeOf("") +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// when-some +{ +v0 := lang.NewSymbol("when-some").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "bindings => binding-form test\n\n When test is not nil, evaluates body with binding-form bound to the\n value of test", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1894), lang.NewKeyword("end-line"), int(1894))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +var v7 any +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v5}) +if lang.IsTruthy(v11) { +v7 = nil +} else { +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("str")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("first")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v3}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("meta")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v3}) +v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) +v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) +v28 := lang.Apply(lang1.NewIllegalArgumentError, []any{v27}) +panic(v28) +} +_ = v7 +var v29 any +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("=")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("count")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v5}) +v37 := lang.Apply(v32, []any{int64(2), v36}) +if lang.IsTruthy(v37) { +v29 = nil +} else { +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("str")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("first")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v3}) +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +} +v47 := v46.Get() +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("meta")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v3}) +v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) +v53 := lang.Apply(v40, []any{v44, " requires ", "exactly 2 forms in binding vector", " in ", v47, ":", v52}) +v54 := lang.Apply(lang1.NewIllegalArgumentError, []any{v53}) +panic(v54) +} +_ = v29 +_ = nil +v56 := lang.Apply(v5, []any{int64(0)}) +var v55 any = v56 +_ = v55 +v58 := lang.Apply(v5, []any{int64(1)}) +var v57 any = v58 +_ = v57 +v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v61 := v60.FindInternedVar(lang.NewSymbol("seq")) +if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) +} +v62 := v61.Get() +v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v64 := v63.FindInternedVar(lang.NewSymbol("concat")) +if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) +} +v65 := v64.Get() +v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v67 := v66.FindInternedVar(lang.NewSymbol("list")) +if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) +} +v68 := v67.Get() +v69 := lang.Apply(v68, []any{lang.NewSymbol("glojure.core/let")}) +v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v71 := v70.FindInternedVar(lang.NewSymbol("list")) +if v71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) +} +v72 := v71.Get() +v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v74 := v73.FindInternedVar(lang.NewSymbol("apply")) +if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) +} +v75 := v74.Get() +v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v77 := v76.FindInternedVar(lang.NewSymbol("vector")) +if v77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) +} +v78 := v77.Get() +v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v80 := v79.FindInternedVar(lang.NewSymbol("seq")) +if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) +} +v81 := v80.Get() +v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v83 := v82.FindInternedVar(lang.NewSymbol("concat")) +if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) +} +v84 := v83.Get() +v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v86 := v85.FindInternedVar(lang.NewSymbol("list")) +if v86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) +} +v87 := v86.Get() +v88 := lang.Apply(v87, []any{lang.NewSymbol("temp__0__auto__")}) +v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v90 := v89.FindInternedVar(lang.NewSymbol("list")) +if v90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) +} +v91 := v90.Get() +v92 := lang.Apply(v91, []any{v57}) +v93 := lang.Apply(v84, []any{v88, v92}) +v94 := lang.Apply(v81, []any{v93}) +v95 := lang.Apply(v75, []any{v78, v94}) +v96 := lang.Apply(v72, []any{v95}) +v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v98 := v97.FindInternedVar(lang.NewSymbol("list")) +if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) +} +v99 := v98.Get() +v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v101 := v100.FindInternedVar(lang.NewSymbol("seq")) +if v101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) +} +v102 := v101.Get() +v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v104 := v103.FindInternedVar(lang.NewSymbol("concat")) +if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) +} +v105 := v104.Get() +v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v107 := v106.FindInternedVar(lang.NewSymbol("list")) +if v107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) +} +v108 := v107.Get() +v109 := lang.Apply(v108, []any{lang.NewSymbol("if")}) +v110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v111 := v110.FindInternedVar(lang.NewSymbol("list")) +if v111.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v111))) +} +v112 := v111.Get() +v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v114 := v113.FindInternedVar(lang.NewSymbol("seq")) +if v114.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) +} +v115 := v114.Get() +v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v117 := v116.FindInternedVar(lang.NewSymbol("concat")) +if v117.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) +} +v118 := v117.Get() +v119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v120 := v119.FindInternedVar(lang.NewSymbol("list")) +if v120.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v120))) +} +v121 := v120.Get() +v122 := lang.Apply(v121, []any{lang.NewSymbol("glojure.core/nil?")}) +v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v124 := v123.FindInternedVar(lang.NewSymbol("list")) +if v124.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) +} +v125 := v124.Get() +v126 := lang.Apply(v125, []any{lang.NewSymbol("temp__0__auto__")}) +v127 := lang.Apply(v118, []any{v122, v126}) +v128 := lang.Apply(v115, []any{v127}) +v129 := lang.Apply(v112, []any{v128}) +v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v131 := v130.FindInternedVar(lang.NewSymbol("list")) +if v131.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) +} +v132 := v131.Get() +v133 := lang.Apply(v132, []any{nil}) +v134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v135 := v134.FindInternedVar(lang.NewSymbol("list")) +if v135.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v135))) +} +v136 := v135.Get() +v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v138 := v137.FindInternedVar(lang.NewSymbol("seq")) +if v138.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) +} +v139 := v138.Get() +v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v141 := v140.FindInternedVar(lang.NewSymbol("concat")) +if v141.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) +} +v142 := v141.Get() +v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v144 := v143.FindInternedVar(lang.NewSymbol("list")) +if v144.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) +} +v145 := v144.Get() +v146 := lang.Apply(v145, []any{lang.NewSymbol("glojure.core/let")}) +v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v148 := v147.FindInternedVar(lang.NewSymbol("list")) +if v148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) +} +v149 := v148.Get() +v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v151 := v150.FindInternedVar(lang.NewSymbol("apply")) +if v151.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) +} +v152 := v151.Get() +v153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v154 := v153.FindInternedVar(lang.NewSymbol("vector")) +if v154.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v154))) +} +v155 := v154.Get() +v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v157 := v156.FindInternedVar(lang.NewSymbol("seq")) +if v157.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) +} +v158 := v157.Get() +v159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v160 := v159.FindInternedVar(lang.NewSymbol("concat")) +if v160.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v160))) +} +v161 := v160.Get() +v162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v163 := v162.FindInternedVar(lang.NewSymbol("list")) +if v163.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v163))) +} +v164 := v163.Get() +v165 := lang.Apply(v164, []any{v55}) +v166 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v167 := v166.FindInternedVar(lang.NewSymbol("list")) +if v167.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v167))) +} +v168 := v167.Get() +v169 := lang.Apply(v168, []any{lang.NewSymbol("temp__0__auto__")}) +v170 := lang.Apply(v161, []any{v165, v169}) +v171 := lang.Apply(v158, []any{v170}) +v172 := lang.Apply(v152, []any{v155, v171}) +v173 := lang.Apply(v149, []any{v172}) +v174 := lang.Apply(v142, []any{v146, v173, v6}) +v175 := lang.Apply(v139, []any{v174}) +v176 := lang.Apply(v136, []any{v175}) +v177 := lang.Apply(v105, []any{v109, v129, v133, v176}) +v178 := lang.Apply(v102, []any{v177}) +v179 := lang.Apply(v99, []any{v178}) +v180 := lang.Apply(v65, []any{v69, v96, v179}) +v181 := lang.Apply(v62, []any{v180}) +return v181 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// shutdown-agents +{ +v0 := lang.NewSymbol("shutdown-agents").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Initiates a shutdown of the thread pools that back the agent\n system. Running actions will complete, but no new actions will be\n accepted", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2252), lang.NewKeyword("end-line"), int(2252))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.Apply(lang1.ShutdownAgents, nil) +return v3 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// uri? +{ +v0 := lang.NewSymbol("uri?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a java.net.URI", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7930), lang.NewKeyword("end-line"), int(7930))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{java.net16.URI, v3}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// pop +{ +v0 := lang.NewSymbol("pop").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "For a list or queue, returns a new list/queue without the first\n item, for a vector, returns a new vector without the last item. If\n the collection is empty, throws an exception. Note - not the same\n as next/butlast.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1462), lang.NewKeyword("end-line"), int(1462))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, _ := lang.FieldOrMethod(runtime3.RT, "Pop") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Pop is not a function"))) +} +v5 := lang.Apply(v4, []any{v3}) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// rsubseq +{ +v0 := lang.NewSymbol("rsubseq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sc"), lang.NewSymbol("test"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("sc"), lang.NewSymbol("start-test"), lang.NewSymbol("start-key"), lang.NewSymbol("end-test"), lang.NewSymbol("end-key"))), lang.NewKeyword("doc"), "sc must be a sorted collection, test(s) one of <, <=, > or\n >=. Returns a reverse seq of those entries with keys ek for\n which (test (.. sc comparator (compare ek key)) 0) is true", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5150), lang.NewKeyword("end-line"), int(5150))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("mk-bound-fn")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v3, v4, v5}) +var v6 any = v10 +_ = v6 +var v12 any +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("<")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("<=")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.CreatePersistentTreeSet(v15, v18) +v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5158), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5158), lang.NewKeyword("end-column"), int(17)) +v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v22 := lang.Apply(v21, []any{v4}) +if lang.IsTruthy(v22) { +v24, _ := lang.FieldOrMethod(v3, "seqFrom") +if reflect.TypeOf(v24).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("seqFrom is not a function"))) +} +v25 := lang.Apply(v24, []any{v5, false}) +var v23 any = v25 +_ = v23 +var v27 any +if lang.IsTruthy(v23) { +var v28 any = v23 +_ = v28 +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("nth")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.Apply(v32, []any{v28, int64(0), nil}) +var v29 any = v33 +_ = v29 +var v34 any = v28 +_ = v34 +var v36 any +v37 := lang.Apply(v6, []any{v29}) +if lang.IsTruthy(v37) { +v36 = v34 +} else { +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("next")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.Apply(v40, []any{v34}) +v36 = v41 +} +v27 = v36 +} else { +v27 = nil +} +v12 = v27 +} else { +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("take-while")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26, _ := lang.FieldOrMethod(v3, "seq") +if reflect.TypeOf(v26).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("seq is not a function"))) +} +v27 := lang.Apply(v26, []any{false}) +v28 := lang.Apply(v25, []any{v6, v27}) +v12 = v28 +} +return v12 + case 5: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := args[4] +v9, _ := lang.FieldOrMethod(v3, "seqFrom") +if reflect.TypeOf(v9).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("seqFrom is not a function"))) +} +v10 := lang.Apply(v9, []any{v7, false}) +var v8 any = v10 +_ = v8 +var v12 any +if lang.IsTruthy(v8) { +var v13 any = v8 +_ = v13 +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("nth")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v13, int64(0), nil}) +var v14 any = v18 +_ = v14 +var v19 any = v13 +_ = v19 +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("take-while")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("mk-bound-fn")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v3, v4, v5}) +var v28 any +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("mk-bound-fn")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.Apply(v31, []any{v3, v6, v7}) +v33 := lang.Apply(v32, []any{v14}) +if lang.IsTruthy(v33) { +v28 = v19 +} else { +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("next")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.Apply(v36, []any{v19}) +v28 = v37 +} +v38 := lang.Apply(v23, []any{v27, v28}) +v12 = v38 +} else { +v12 = nil +} +return v12 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// io! +{ +v0 := lang.NewSymbol("io!").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "If an io! block occurs in a transaction, throws an\n IllegalStateException, else runs body in an implicit do. If the\n first expression in body is a literal string, will use that as the\n exception message.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(2504), lang.NewKeyword("end-line"), int(2504))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +var v7 any +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("string?")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("first")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v5}) +v15 := lang.Apply(v10, []any{v14}) +if lang.IsTruthy(v15) { +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("first")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v5}) +v7 = v19 +} else { +v7 = nil +} +var v6 any = v7 +_ = v6 +var v21 any +if lang.IsTruthy(v6) { +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("next")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v20}) +v21 = v25 +} else { +v21 = v20 +} +var v20 any = v21 +_ = v20 +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("seq")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("concat")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("list")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v35, []any{lang.NewSymbol("if")}) +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("list")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("seq")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("concat")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +} +v45 := v44.Get() +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("list")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +} +v48 := v47.Get() +v49 := lang.Apply(v48, []any{lang.NewSymbol("glojure.lang.LockingTransaction/isRunning")}) +v50 := lang.Apply(v45, []any{v49}) +v51 := lang.Apply(v42, []any{v50}) +v52 := lang.Apply(v39, []any{v51}) +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("list")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +} +v55 := v54.Get() +v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v57 := v56.FindInternedVar(lang.NewSymbol("seq")) +if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) +} +v58 := v57.Get() +v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v60 := v59.FindInternedVar(lang.NewSymbol("concat")) +if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) +} +v61 := v60.Get() +v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v63 := v62.FindInternedVar(lang.NewSymbol("list")) +if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +} +v64 := v63.Get() +v65 := lang.Apply(v64, []any{lang.NewSymbol("throw")}) +v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v67 := v66.FindInternedVar(lang.NewSymbol("list")) +if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) +} +v68 := v67.Get() +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("seq")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +} +v71 := v70.Get() +v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v73 := v72.FindInternedVar(lang.NewSymbol("concat")) +if v73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) +} +v74 := v73.Get() +v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v76 := v75.FindInternedVar(lang.NewSymbol("list")) +if v76.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) +} +v77 := v76.Get() +v78 := lang.Apply(v77, []any{lang.NewSymbol("new")}) +v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v80 := v79.FindInternedVar(lang.NewSymbol("list")) +if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) +} +v81 := v80.Get() +v82 := lang.Apply(v81, []any{lang.NewSymbol("glojure.core/IllegalStateException")}) +v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v84 := v83.FindInternedVar(lang.NewSymbol("list")) +if v84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) +} +v85 := v84.Get() +var v86 any = v6 +_ = v86 +var v88 any +if lang.IsTruthy(v86) { +v88 = v86 +} else { +v88 = "I/O in transaction" +} +v86 := lang.Apply(v85, []any{v88}) +v87 := lang.Apply(v74, []any{v78, v82, v86}) +v88 := lang.Apply(v71, []any{v87}) +v89 := lang.Apply(v68, []any{v88}) +v90 := lang.Apply(v61, []any{v65, v89}) +v91 := lang.Apply(v58, []any{v90}) +v92 := lang.Apply(v55, []any{v91}) +v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v94 := v93.FindInternedVar(lang.NewSymbol("list")) +if v94.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) +} +v95 := v94.Get() +v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v97 := v96.FindInternedVar(lang.NewSymbol("seq")) +if v97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) +} +v98 := v97.Get() +v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v100 := v99.FindInternedVar(lang.NewSymbol("concat")) +if v100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) +} +v101 := v100.Get() +v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v103 := v102.FindInternedVar(lang.NewSymbol("list")) +if v103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) +} +v104 := v103.Get() +v105 := lang.Apply(v104, []any{lang.NewSymbol("do")}) +v106 := lang.Apply(v101, []any{v105, v20}) +v107 := lang.Apply(v98, []any{v106}) +v108 := lang.Apply(v95, []any{v107}) +v109 := lang.Apply(v32, []any{v36, v52, v92, v108}) +v110 := lang.Apply(v29, []any{v109}) +return v110 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// *data-readers* +{ +v0 := lang.NewSymbol("*data-readers*").WithMeta(lang.NewMap(lang.NewKeyword("doc"), "Map from reader tag symbols to data reader Vars.\n\n When Clojure starts, it searches for files named 'data_readers.clj'\n and 'data_readers.cljc' at the root of the classpath. Each such file\n must contain a literal map of symbols, like this:\n\n {foo/bar my.project.foo/bar\n foo/baz my.project/baz}\n\n The first symbol in each pair is a tag that will be recognized by\n the Clojure reader. The second symbol in the pair is the\n fully-qualified name of a Var which will be invoked by the reader to\n parse the form following the tag. For example, given the\n data_readers.clj file above, the Clojure reader would parse this\n form:\n\n #foo/bar [1 2 3]\n\n by invoking the Var #'my.project.foo/bar on the vector [1 2 3]. The\n data reader function is invoked on the form AFTER it has been read\n as a normal Clojure data structure by the reader.\n\n Reader tags without namespace qualifiers are reserved for\n Clojure. Default reader tags are defined in\n glojure.core/default-data-readers but may be overridden in\n data_readers.clj, data_readers.cljc, or by rebinding this Var.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(49), lang.NewKeyword("column"), int(6), lang.NewKeyword("line"), int(7847), lang.NewKeyword("end-line"), int(7847), lang.NewKeyword("dynamic"), true)).(*lang.Symbol) +v1 := ns.InternWithValue(v0, lang.NewMap(), true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// clear-agent-errors +{ +v0 := lang.NewSymbol("clear-agent-errors").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("doc"), "DEPRECATED: Use 'restart-agent' instead.\n Clears any exceptions thrown during asynchronous actions of the\n agent, allowing subsequent actions to occur.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("deprecated"), "1.2", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2244), lang.NewKeyword("end-line"), int(2244))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("restart-agent")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7, ok := lang.FieldOrMethod(v3, "Deref") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "Deref"))) +} +var v8 any +switch reflect.TypeOf(v7).Kind() { +case reflect.Func: + v8 = lang.Apply(v7, nil) +default: + v8 = v7 +} +v9 := lang.Apply(v6, []any{v3, v8}) +return v9 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// re-find +{ +v0 := lang.NewSymbol("re-find").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m")), lang.NewVector(lang.NewSymbol("re"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns the next regex match, if any, of string to pattern, using\n java.util.regex.Matcher.find(). Uses re-groups to return the\n groups.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4922), lang.NewKeyword("end-line"), int(4922))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +var v4 any +v5, _ := lang.FieldOrMethod(v3, "find") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("find is not a function"))) +} +v6 := lang.Apply(v5, []any{}) +if lang.IsTruthy(v6) { +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("re-groups")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v3}) +v4 = v10 +} else { +v4 = nil +} +return v4 + case 2: +v3 := args[0] +v4 := args[1] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("re-matcher")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v3, v4}) +var v5 any = v9 +_ = v5 +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("re-find")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v5}) +return v14 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// unchecked-subtract +{ +var v1 lang.FnFunc +{ // function unchecked-subtract__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("concat")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("list")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("seq")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("concat")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("list")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/unchecked_minus")}) +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v4}) +v40 := lang.Apply(v27, []any{v31, v35, v39}) +v41 := lang.Apply(v24, []any{v40}) +v42 := lang.Apply(v21, []any{v41}) +v43 := lang.Apply(v10, []any{v14, v18, v42}) +v44 := lang.Apply(v7, []any{v43}) +return v44 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("unchecked-subtract").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the difference of x and y, both long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1217), lang.NewKeyword("end-line"), int(1217))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := args[1] +v6, _ := lang.FieldOrMethod(lang1.Numbers, "unchecked_minus") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_minus is not a function"))) +} +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// is-annotation? +{ +v0 := lang.NewSymbol("is-annotation?").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5471), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(5471), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("class?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +var v4 any = v8 +_ = v4 +var v10 any +if lang.IsTruthy(v4) { +v11, _ := lang.FieldOrMethod(java.lang.annotation17.Annotation, "isAssignableFrom") +if reflect.TypeOf(v11).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("isAssignableFrom is not a function"))) +} +v12 := lang.Apply(v11, []any{v3}) +v10 = v12 +} else { +v10 = v4 +} +return v10 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// assoc +{ +v0 := lang.NewSymbol("assoc").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"), lang.NewSymbol("val"), lang.NewSymbol("&"), lang.NewSymbol("kvs"))), lang.NewKeyword("doc"), "assoc[iate]. When applied to a map, returns a new map of the\n same (hashed/sorted) type, that contains the mapping of key(s) to\n val(s). When applied to a vector, returns a new vector that\n contains val at index. Note - index must be <= (count vector).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(181), lang.NewKeyword("end-line"), int(188))).(*lang.Symbol) +var v2 lang.FnFunc +{ // function assoc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: +v4 := args[0] +v5 := args[1] +v6 := args[2] +v7 := lang.Apply(lang1.Assoc, []any{v4, v5, v6}) +return v7 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := args[1] +v6 := args[2] +v7 := lang.NewList(args[3:]...) +recur_loop_24: +v9 := lang.Apply(lang1.Assoc, []any{v4, v5, v6}) +var v8 any = v9 +_ = v8 +var v11 any +if lang.IsTruthy(v7) { +var v12 any +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("next")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v7}) +if lang.IsTruthy(v16) { +var v17 any = v8 +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("first")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v7}) +var v18 any = v22 +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("second")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v7}) +var v23 any = v27 +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("nnext")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.Apply(v31, []any{v7}) +var v28 any = v32 +v4 = v17 +v5 = v18 +v6 = v23 +v7 = v28 +goto recur_loop_24 +} else { +v33 := lang.Apply(lang1.NewIllegalArgumentError, []any{"assoc expects even number of arguments after map/vector, found odd number"}) +panic(v33) +} +v11 = v12 +} else { +v11 = v8 +} +return v11 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(189), lang.NewKeyword("column"), int(2), lang.NewKeyword("end-line"), int(198), lang.NewKeyword("end-column"), int(15))).(lang.FnFunc) +v3 := v2 +_ = v3 +} +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// *3 +{ +v0 := lang.NewSymbol("*3").WithMeta(lang.NewMap()).(*lang.Symbol) +v1 := ns.Intern(v0) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// coll? +{ +v0 := lang.NewSymbol("coll?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements IPersistentCollection", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6235), lang.NewKeyword("end-line"), int(6235))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{lang1.IPersistentCollection, v3}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// printf +{ +v0 := lang.NewSymbol("printf").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fmt"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Prints formatted output, as per format", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5768), lang.NewKeyword("end-line"), int(5768))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.NewList(args[1:]...) +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("print")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("apply")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("format")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v10, []any{v13, v3, v4}) +v15 := lang.Apply(v7, []any{v14}) +return v15 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// tapset +{ +v0 := lang.NewSymbol("tapset").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7935), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(7935), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v2 := lang.NewAtom(lang.CreatePersistentTreeSet()) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// name +{ +v1 := reflect.TypeOf("") +v0 := lang.NewSymbol("name").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns the name String of a string, symbol or keyword.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1585), lang.NewKeyword("end-line"), int(1585))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("string?")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v4}) +if lang.IsTruthy(v9) { +v5 = v4 +} else { +v10, _ := lang.FieldOrMethod(v4, "Name") +if reflect.TypeOf(v10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Name is not a function"))) +} +v11 := lang.Apply(v10, []any{}) +v5 = v11 +} +return v5 +}) +v4 := reflect.TypeOf("") +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// iteration +{ +v0 := lang.NewSymbol("iteration").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("step"), lang.NewSymbol("&"), lang.NewMap(lang.NewKeyword("keys"), lang.NewVector(lang.NewSymbol("somef"), lang.NewSymbol("vf"), lang.NewSymbol("kf"), lang.NewSymbol("initk")), lang.NewKeyword("or"), lang.NewMap(lang.NewSymbol("vf"), lang.NewSymbol("identity"), lang.NewSymbol("kf"), lang.NewSymbol("identity"), lang.NewSymbol("somef"), lang.NewSymbol("some?"), lang.NewSymbol("initk"), nil)))), lang.NewKeyword("doc"), "Creates a seqable/reducible via repeated calls to step,\n a function of some (continuation token) 'k'. The first call to step\n will be passed initk, returning 'ret'. Iff (somef ret) is true,\n (vf ret) will be included in the iteration, else iteration will\n terminate and vf/kf will not be called. If (kf ret) is non-nil it\n will be passed to the next step call, else iteration will terminate.\n\n This can be used e.g. to consume APIs that return paginated or batched data.\n\n step - (possibly impure) fn of 'k' -> 'ret'\n\n :somef - fn of 'ret' -> logical true/false, default 'some?'\n :vf - fn of 'ret' -> 'v', a value produced by the iteration, default 'identity'\n :kf - fn of 'ret' -> 'next-k' or nil (signaling 'do not continue'), default 'identity'\n :initk - the first value passed to step, default 'nil'\n\n It is presumed that step with non-initk is unreproducible/non-idempotent.\n If step with initk is unreproducible it is on the consumer to not consume twice.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7769), lang.NewKeyword("end-line"), int(7769))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.NewList(args[1:]...) +var v5 any = v4 +_ = v5 +var v7 any +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("seq?")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v6}) +if lang.IsTruthy(v11) { +var v12 any +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("next")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v6}) +if lang.IsTruthy(v16) { +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("to-array")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v6}) +v21 := lang.Apply(lang1.NewPersistentArrayMapAsIfByAssoc, []any{v20}) +v12 = v21 +} else { +var v22 any +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("seq")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{v6}) +if lang.IsTruthy(v26) { +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("first")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{v6}) +v22 = v30 +} else { +v22 = nil +} +v12 = v22 +} +v7 = v12 +} else { +v7 = v6 +} +var v6 any = v7 +_ = v6 +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("get")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("some?")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v34, []any{v6, lang.NewKeyword("somef"), v37}) +var v31 any = v38 +_ = v31 +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("get")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("identity")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +} +v45 := v44.Get() +v46 := lang.Apply(v42, []any{v6, lang.NewKeyword("vf"), v45}) +var v39 any = v46 +_ = v39 +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("get")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v52 := v51.FindInternedVar(lang.NewSymbol("identity")) +if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) +} +v53 := v52.Get() +v54 := lang.Apply(v50, []any{v6, lang.NewKeyword("kf"), v53}) +var v47 any = v54 +_ = v47 +v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v57 := v56.FindInternedVar(lang.NewSymbol("get")) +if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) +} +v58 := v57.Get() +v59 := lang.Apply(v58, []any{v6, lang.NewKeyword("initk"), nil}) +var v55 any = v59 +_ = v55 +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("seq")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +} +v63 := v62.Get() +v64 := lang.NewVector(nil) +v65 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7796), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(7796), lang.NewKeyword("end-column"), int(11)) +v66, err := lang.WithMeta(v64, v65.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v67 lang.FnFunc +{ // function next +v67 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v69 := args[0] +var v70 any +v71 := lang.Apply(v31, []any{v69}) +if lang.IsTruthy(v71) { +v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v73 := v72.FindInternedVar(lang.NewSymbol("cons")) +if v73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) +} +v74 := v73.Get() +v75 := lang.Apply(v39, []any{v69}) +v77 := lang.Apply(v47, []any{v69}) +var v76 any = v77 +_ = v76 +var v79 any +v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v81 := v80.FindInternedVar(lang.NewSymbol("nil?")) +if v81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) +} +v82 := v81.Get() +v83 := lang.Apply(v82, []any{v76}) +if lang.IsTruthy(v83) { +v79 = nil +} else { +var v84 any = v76 +_ = v84 +var v86 lang.FnFunc +v86 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v87 := lang.Apply(v3, []any{v84}) +v88 := lang.Apply(v68, []any{v87}) +return v88 +}) +v87 := lang.Apply(lang1.NewLazySeq, []any{v86}) +v79 = v87 +} +v76 := lang.Apply(v74, []any{v75, v79}) +v70 = v76 +} else { +v70 = nil +} +return v70 +}) +v68 := v67 +_ = v68 +} +v68 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7797), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(7801), lang.NewKeyword("end-column"), int(51)) +v69, err := lang.WithMeta(v67, v68.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v70 := lang.Apply(v3, []any{v55}) +v71 := lang.Apply(v69, []any{v70}) +v72 := lang.Apply(v63, []any{v66, v71}) +v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v74 := v73.FindInternedVar(lang.NewSymbol("reduce")) +if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) +} +v75 := v74.Get() +v76 := lang.NewVector(nil, nil, nil) +v77 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7804), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(7804), lang.NewKeyword("end-column"), int(22)) +v78, err := lang.WithMeta(v76, v77.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v79 any = nil +_ = v79 +v81 := lang.Apply(v3, []any{v55}) +var v80 any = v81 +_ = v80 +var v82 any +for { +var v83 any +v84 := lang.Apply(v31, []any{v80}) +if lang.IsTruthy(v84) { +v86 := lang.Apply(v39, []any{v80}) +v87 := lang.Apply(nil, []any{v85, v86}) +var v85 any = v87 +_ = v85 +var v89 any +v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v91 := v90.FindInternedVar(lang.NewSymbol("reduced?")) +if v91.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) +} +v92 := v91.Get() +v93 := lang.Apply(v92, []any{v85}) +if lang.IsTruthy(v93) { +v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v95 := v94.FindInternedVar(lang.NewSymbol("deref")) +if v95.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) +} +v96 := v95.Get() +v97 := lang.Apply(v96, []any{v85}) +v89 = v97 +} else { +v99 := lang.Apply(v47, []any{v80}) +var v98 any = v99 +_ = v98 +var v101 any +v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v103 := v102.FindInternedVar(lang.NewSymbol("nil?")) +if v103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) +} +v104 := v103.Get() +v105 := lang.Apply(v104, []any{v98}) +if lang.IsTruthy(v105) { +v101 = v85 +} else { +var v106 any = v98 +_ = v106 +var v108 any = v85 +v110 := lang.Apply(v3, []any{v106}) +var v109 any = v110 +v79 = v108 +v80 = v109 +continue +} +v89 = v101 +} +v83 = v89 +} else { +v83 = v79 +} +v82 = v83 + break +} +v79 := lang.Apply(v75, []any{v78, v82}) +v80 := lang.Apply(nil, []any{glojure.lang11.Seqable, v72, lang1.IReduceInit, v79}) +return v80 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// count +{ +var v1 lang.FnFunc +{ // function count__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/Count")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v3}) +v35 := lang.Apply(v26, []any{v30, v34}) +v36 := lang.Apply(v23, []any{v35}) +v37 := lang.Apply(v20, []any{v36}) +v38 := lang.Apply(v9, []any{v13, v17, v37}) +v39 := lang.Apply(v6, []any{v38}) +return v39 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("count").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the number of items in the collection. (count nil) returns\n 0. Also works on strings, arrays, and Java Collections and Maps", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(867), lang.NewKeyword("end-line"), int(867))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := lang.Apply(lang1.Count, []any{v4}) +return v5 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// >0? +{ +v0 := lang.NewSymbol(">0?").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(963), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(963), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) +} +v5 := lang.Apply(v4, []any{v3, int64(0)}) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// reduced? +{ +var v1 lang.FnFunc +{ // function reduced?__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.IsReduced")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v3}) +v18 := lang.Apply(v9, []any{v13, v17}) +v19 := lang.Apply(v6, []any{v18}) +return v19 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("reduced?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns true if x is the result of a call to reduced", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)), lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2834), lang.NewKeyword("end-line"), int(2834))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := lang.Apply(lang1.IsReduced, []any{v4}) +return v5 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// unchecked-multiply-int +{ +var v1 lang.FnFunc +{ // function unchecked-multiply-int__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("concat")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("list")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("seq")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("concat")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("list")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/unchecked_int_multiply")}) +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v4}) +v40 := lang.Apply(v27, []any{v31, v35, v39}) +v41 := lang.Apply(v24, []any{v40}) +v42 := lang.Apply(v21, []any{v41}) +v43 := lang.Apply(v10, []any{v14, v18, v42}) +v44 := lang.Apply(v7, []any{v43}) +return v44 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("unchecked-multiply-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the product of x and y, both int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1224), lang.NewKeyword("end-line"), int(1224))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := args[1] +v6, _ := lang.FieldOrMethod(lang1.Numbers, "unchecked_int_multiply") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_multiply is not a function"))) +} +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// sync +{ +v0 := lang.NewSymbol("sync").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("flags-ignored-for-now"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "transaction-flags => TBD, pass nil for now\n\n Runs the exprs (in an implicit do) in a transaction that encompasses\n exprs and any nested calls. Starts a transaction if none is already\n running on this thread. Any uncaught exception will abort the\n transaction and flow out of sync. The exprs may be run more than\n once, but any effects on Refs will be atomic.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(2490), lang.NewKeyword("end-line"), int(2490))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("seq")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("concat")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("list")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{lang.NewSymbol(".")}) +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("list")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v19, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.LockingTransaction")}) +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("list")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("seq")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("concat")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("list")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.Apply(v32, []any{lang.NewSymbol("glojure.core/RunInTransaction")}) +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("list")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("seq")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("concat")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("list")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +} +v45 := v44.Get() +v46 := lang.Apply(v45, []any{lang.NewSymbol("glojure.core/fn")}) +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("list")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +} +v49 := v48.Get() +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("apply")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +} +v52 := v51.Get() +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("vector")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +} +v55 := v54.Get() +v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v57 := v56.FindInternedVar(lang.NewSymbol("seq")) +if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) +} +v58 := v57.Get() +v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v60 := v59.FindInternedVar(lang.NewSymbol("concat")) +if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) +} +v61 := v60.Get() +v62 := lang.Apply(v61, nil) +v63 := lang.Apply(v58, []any{v62}) +v64 := lang.Apply(v52, []any{v55, v63}) +v65 := lang.Apply(v49, []any{v64}) +v66 := lang.Apply(v42, []any{v46, v65, v6}) +v67 := lang.Apply(v39, []any{v66}) +v68 := lang.Apply(v36, []any{v67}) +v69 := lang.Apply(v29, []any{v33, v68}) +v70 := lang.Apply(v26, []any{v69}) +v71 := lang.Apply(v23, []any{v70}) +v72 := lang.Apply(v12, []any{v16, v20, v71}) +v73 := lang.Apply(v9, []any{v72}) +return v73 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// keyword +{ +v1 := reflect.TypeOf((*lang1.Keyword)(nil)).Elem() +v0 := lang.NewSymbol("keyword").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name"))), lang.NewKeyword("doc"), "Returns a Keyword with the given namespace and name. Do not use :\n in the keyword strings, it will be added automatically.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(609), lang.NewKeyword("end-line"), int(609))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v4 := args[0] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("keyword?")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v4}) +if lang.IsTruthy(v9) { +v5 = v4 +} else { +var v10 any +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("symbol?")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v4}) +if lang.IsTruthy(v14) { +v15 := lang.Apply(lang1.InternKeywordSymbol, []any{v4}) +v10 = v15 +} else { +var v16 any +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("string?")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v4}) +if lang.IsTruthy(v20) { +v21 := lang.Apply(lang1.InternKeywordString, []any{v4}) +v16 = v21 +} else { +v16 = nil +} +v10 = v16 +} +v5 = v10 +} +return v5 + case 2: +v4 := args[0] +v5 := args[1] +v6 := lang.Apply(lang1.InternKeyword, []any{v4, v5}) +return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v4 := reflect.TypeOf((*lang1.Keyword)(nil)).Elem() +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// number? +{ +v0 := lang.NewSymbol("number?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is a Number", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3560), lang.NewKeyword("end-line"), int(3560))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.Apply(lang1.IsNumber, []any{v3}) +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// print-throwable +{ +v0 := lang.NewSymbol("print-throwable").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(478), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(478), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.Apply(lang1.WriteWriter, []any{v4, "#error {\n :cause "}) +_ = v5 +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("Throwable->map")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v3}) +var v6 any = v10 +_ = v6 +var v12 any +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("seq?")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v11}) +if lang.IsTruthy(v16) { +var v17 any +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("next")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, []any{v11}) +if lang.IsTruthy(v21) { +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("to-array")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v11}) +v26 := lang.Apply(lang1.NewPersistentArrayMapAsIfByAssoc, []any{v25}) +v17 = v26 +} else { +var v27 any +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("seq")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{v11}) +if lang.IsTruthy(v31) { +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("first")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v11}) +v27 = v35 +} else { +v27 = nil +} +v17 = v27 +} +v12 = v17 +} else { +v12 = v11 +} +var v11 any = v12 +_ = v11 +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("get")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v11, lang.NewKeyword("cause")}) +var v36 any = v40 +_ = v36 +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("get")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +} +v44 := v43.Get() +v45 := lang.Apply(v44, []any{v11, lang.NewKeyword("data")}) +var v41 any = v45 +_ = v41 +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("get")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +} +v49 := v48.Get() +v50 := lang.Apply(v49, []any{v11, lang.NewKeyword("via")}) +var v46 any = v50 +_ = v46 +v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v53 := v52.FindInternedVar(lang.NewSymbol("get")) +if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) +} +v54 := v53.Get() +v55 := lang.Apply(v54, []any{v11, lang.NewKeyword("trace")}) +var v51 any = v55 +_ = v51 +var v57 lang.FnFunc +v57 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v58 := args[0] +v59 := lang.Apply(lang1.WriteWriter, []any{v4, "{:type "}) +_ = v59 +v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v61 := v60.FindInternedVar(lang.NewSymbol("print-method")) +if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) +} +v62 := v61.Get() +v63 := lang.Apply(lang.NewKeyword("type"), []any{v58}) +v64 := lang.Apply(v62, []any{v63, v4}) +_ = v64 +v65 := lang.Apply(lang1.WriteWriter, []any{v4, "\n :message "}) +_ = v65 +v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v67 := v66.FindInternedVar(lang.NewSymbol("print-method")) +if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) +} +v68 := v67.Get() +v69 := lang.Apply(lang.NewKeyword("message"), []any{v58}) +v70 := lang.Apply(v68, []any{v69, v4}) +_ = v70 +v72 := lang.Apply(lang.NewKeyword("data"), []any{v58}) +var v71 any = v72 +_ = v71 +var v74 any +if lang.IsTruthy(v71) { +var v75 any = v71 +_ = v75 +v77 := lang.Apply(lang1.WriteWriter, []any{v4, "\n :data "}) +_ = v77 +v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v79 := v78.FindInternedVar(lang.NewSymbol("print-method")) +if v79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) +} +v80 := v79.Get() +v81 := lang.Apply(v80, []any{v75, v4}) +v74 = v81 +} else { +v74 = nil +} +_ = v74 +v72 := lang.Apply(lang.NewKeyword("at"), []any{v58}) +var v71 any = v72 +_ = v71 +var v74 any +if lang.IsTruthy(v71) { +var v75 any = v71 +_ = v75 +v77 := lang.Apply(lang1.WriteWriter, []any{v4, "\n :at "}) +_ = v77 +v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v79 := v78.FindInternedVar(lang.NewSymbol("print-method")) +if v79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) +} +v80 := v79.Get() +v81 := lang.Apply(lang.NewKeyword("at"), []any{v58}) +v82 := lang.Apply(v80, []any{v81, v4}) +v74 = v82 +} else { +v74 = nil +} +_ = v74 +v71 := lang.Apply(lang1.WriteWriter, []any{v4, "}"}) +return v71 +}) +v58 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(481), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(491), lang.NewKeyword("end-column"), int(73)) +v59, err := lang.WithMeta(v57, v58.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v56 any = v59 +_ = v56 +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("print-method")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +} +v63 := v62.Get() +v64 := lang.Apply(v63, []any{v36, v4}) +_ = v64 +var v65 any +if lang.IsTruthy(v41) { +v66 := lang.Apply(lang1.WriteWriter, []any{v4, "\n :data "}) +_ = v66 +v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v68 := v67.FindInternedVar(lang.NewSymbol("print-method")) +if v68.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) +} +v69 := v68.Get() +v70 := lang.Apply(v69, []any{v41, v4}) +v65 = v70 +} else { +v65 = nil +} +_ = v65 +var v71 any +if lang.IsTruthy(v46) { +v72 := lang.Apply(lang1.WriteWriter, []any{v4, "\n :via\n ["}) +_ = v72 +v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v75 := v74.FindInternedVar(lang.NewSymbol("first")) +if v75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) +} +v76 := v75.Get() +v77 := lang.Apply(v76, []any{v46}) +var v73 any = v77 +_ = v73 +var v79 any +if lang.IsTruthy(v73) { +var v80 any = v73 +_ = v80 +v82 := lang.Apply(v56, []any{v80}) +_ = v82 +v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v85 := v84.FindInternedVar(lang.NewSymbol("seq")) +if v85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) +} +v86 := v85.Get() +v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v88 := v87.FindInternedVar(lang.NewSymbol("rest")) +if v88.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) +} +v89 := v88.Get() +v90 := lang.Apply(v89, []any{v46}) +v91 := lang.Apply(v86, []any{v90}) +var v83 any = v91 +_ = v83 +var v92 any = nil +_ = v92 +var v93 any = int64(0) +_ = v93 +var v94 any = int64(0) +_ = v94 +var v95 any +for { +var v96 any +v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v98 := v97.FindInternedVar(lang.NewSymbol("<")) +if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) +} +v99 := v98.Get() +v100 := lang.Apply(v99, []any{v94, v93}) +if lang.IsTruthy(v100) { +v102, _ := lang.FieldOrMethod(v92, "nth") +if reflect.TypeOf(v102).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) +} +v103 := lang.Apply(v102, []any{v94}) +var v101 any = v103 +_ = v101 +v105 := lang.Apply(lang1.WriteWriter, []any{v4, "\n "}) +_ = v105 +v106 := lang.Apply(v56, []any{v101}) +_ = v106 +var v107 any = v83 +var v108 any = v92 +var v109 any = v93 +v111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v112 := v111.FindInternedVar(lang.NewSymbol("unchecked-inc")) +if v112.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v112))) +} +v113 := v112.Get() +v114 := lang.Apply(v113, []any{v94}) +var v110 any = v114 +v83 = v107 +v92 = v108 +v93 = v109 +v94 = v110 +continue +} else { +v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v103 := v102.FindInternedVar(lang.NewSymbol("seq")) +if v103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) +} +v104 := v103.Get() +v105 := lang.Apply(v104, []any{v83}) +var v101 any = v105 +_ = v101 +var v107 any +if lang.IsTruthy(v101) { +var v108 any = v101 +_ = v108 +var v110 any +v111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v112 := v111.FindInternedVar(lang.NewSymbol("chunked-seq?")) +if v112.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v112))) +} +v113 := v112.Get() +v114 := lang.Apply(v113, []any{v108}) +if lang.IsTruthy(v114) { +v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v117 := v116.FindInternedVar(lang.NewSymbol("chunk-first")) +if v117.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) +} +v118 := v117.Get() +v119 := lang.Apply(v118, []any{v108}) +var v115 any = v119 +_ = v115 +v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v123 := v122.FindInternedVar(lang.NewSymbol("chunk-rest")) +if v123.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) +} +v124 := v123.Get() +v125 := lang.Apply(v124, []any{v108}) +var v121 any = v125 +var v126 any = v115 +v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v129 := v128.FindInternedVar(lang.NewSymbol("int")) +if v129.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v129))) +} +v130 := v129.Get() +v131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v132 := v131.FindInternedVar(lang.NewSymbol("count")) +if v132.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v132))) +} +v133 := v132.Get() +v134 := lang.Apply(v133, []any{v115}) +v135 := lang.Apply(v130, []any{v134}) +var v127 any = v135 +v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v138 := v137.FindInternedVar(lang.NewSymbol("int")) +if v138.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) +} +v139 := v138.Get() +v140 := lang.Apply(v139, []any{int64(0)}) +var v136 any = v140 +v83 = v121 +v92 = v126 +v93 = v127 +v94 = v136 +continue +} else { +v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v117 := v116.FindInternedVar(lang.NewSymbol("first")) +if v117.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) +} +v118 := v117.Get() +v119 := lang.Apply(v118, []any{v108}) +var v115 any = v119 +_ = v115 +v121 := lang.Apply(lang1.WriteWriter, []any{v4, "\n "}) +_ = v121 +v122 := lang.Apply(v56, []any{v115}) +_ = v122 +v124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v125 := v124.FindInternedVar(lang.NewSymbol("next")) +if v125.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v125))) +} +v126 := v125.Get() +v127 := lang.Apply(v126, []any{v108}) +var v123 any = v127 +var v128 any = nil +var v129 any = int64(0) +var v130 any = int64(0) +v83 = v123 +v92 = v128 +v93 = v129 +v94 = v130 +continue +} +v107 = v110 +} else { +v107 = nil +} +v96 = v107 +} +v95 = v96 + break +} +v79 = v95 +} else { +v79 = nil +} +_ = v79 +v73 := lang.Apply(lang1.WriteWriter, []any{v4, "]"}) +v71 = v73 +} else { +v71 = nil +} +_ = v71 +var v74 any +if lang.IsTruthy(v51) { +v75 := lang.Apply(lang1.WriteWriter, []any{v4, "\n :trace\n ["}) +_ = v75 +v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v78 := v77.FindInternedVar(lang.NewSymbol("first")) +if v78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) +} +v79 := v78.Get() +v80 := lang.Apply(v79, []any{v51}) +var v76 any = v80 +_ = v76 +var v82 any +if lang.IsTruthy(v76) { +var v83 any = v76 +_ = v83 +v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v86 := v85.FindInternedVar(lang.NewSymbol("print-method")) +if v86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) +} +v87 := v86.Get() +v88 := lang.Apply(v87, []any{v83, v4}) +_ = v88 +v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v91 := v90.FindInternedVar(lang.NewSymbol("seq")) +if v91.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) +} +v92 := v91.Get() +v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v94 := v93.FindInternedVar(lang.NewSymbol("rest")) +if v94.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) +} +v95 := v94.Get() +v96 := lang.Apply(v95, []any{v51}) +v97 := lang.Apply(v92, []any{v96}) +var v89 any = v97 +_ = v89 +var v98 any = nil +_ = v98 +var v99 any = int64(0) +_ = v99 +var v100 any = int64(0) +_ = v100 +var v101 any +for { +var v102 any +v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v104 := v103.FindInternedVar(lang.NewSymbol("<")) +if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) +} +v105 := v104.Get() +v106 := lang.Apply(v105, []any{v100, v99}) +if lang.IsTruthy(v106) { +v108, _ := lang.FieldOrMethod(v98, "nth") +if reflect.TypeOf(v108).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) +} +v109 := lang.Apply(v108, []any{v100}) +var v107 any = v109 +_ = v107 +v111 := lang.Apply(lang1.WriteWriter, []any{v4, "\n "}) +_ = v111 +v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v113 := v112.FindInternedVar(lang.NewSymbol("print-method")) +if v113.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) +} +v114 := v113.Get() +v115 := lang.Apply(v114, []any{v107, v4}) +_ = v115 +var v116 any = v89 +var v117 any = v98 +var v118 any = v99 +v120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v121 := v120.FindInternedVar(lang.NewSymbol("unchecked-inc")) +if v121.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v121))) +} +v122 := v121.Get() +v123 := lang.Apply(v122, []any{v100}) +var v119 any = v123 +v89 = v116 +v98 = v117 +v99 = v118 +v100 = v119 +continue +} else { +v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v109 := v108.FindInternedVar(lang.NewSymbol("seq")) +if v109.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) +} +v110 := v109.Get() +v111 := lang.Apply(v110, []any{v89}) +var v107 any = v111 +_ = v107 +var v113 any +if lang.IsTruthy(v107) { +var v114 any = v107 +_ = v114 +var v116 any +v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v118 := v117.FindInternedVar(lang.NewSymbol("chunked-seq?")) +if v118.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) +} +v119 := v118.Get() +v120 := lang.Apply(v119, []any{v114}) +if lang.IsTruthy(v120) { +v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v123 := v122.FindInternedVar(lang.NewSymbol("chunk-first")) +if v123.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) +} +v124 := v123.Get() +v125 := lang.Apply(v124, []any{v114}) +var v121 any = v125 +_ = v121 +v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v129 := v128.FindInternedVar(lang.NewSymbol("chunk-rest")) +if v129.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v129))) +} +v130 := v129.Get() +v131 := lang.Apply(v130, []any{v114}) +var v127 any = v131 +var v132 any = v121 +v134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v135 := v134.FindInternedVar(lang.NewSymbol("int")) +if v135.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v135))) +} +v136 := v135.Get() +v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v138 := v137.FindInternedVar(lang.NewSymbol("count")) +if v138.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) +} +v139 := v138.Get() +v140 := lang.Apply(v139, []any{v121}) +v141 := lang.Apply(v136, []any{v140}) +var v133 any = v141 +v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v144 := v143.FindInternedVar(lang.NewSymbol("int")) +if v144.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) +} +v145 := v144.Get() +v146 := lang.Apply(v145, []any{int64(0)}) +var v142 any = v146 +v89 = v127 +v98 = v132 +v99 = v133 +v100 = v142 +continue +} else { +v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v123 := v122.FindInternedVar(lang.NewSymbol("first")) +if v123.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) +} +v124 := v123.Get() +v125 := lang.Apply(v124, []any{v114}) +var v121 any = v125 +_ = v121 +v127 := lang.Apply(lang1.WriteWriter, []any{v4, "\n "}) +_ = v127 +v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v129 := v128.FindInternedVar(lang.NewSymbol("print-method")) +if v129.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v129))) +} +v130 := v129.Get() +v131 := lang.Apply(v130, []any{v121, v4}) +_ = v131 +v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v134 := v133.FindInternedVar(lang.NewSymbol("next")) +if v134.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) +} +v135 := v134.Get() +v136 := lang.Apply(v135, []any{v114}) +var v132 any = v136 +var v137 any = nil +var v138 any = int64(0) +var v139 any = int64(0) +v89 = v132 +v98 = v137 +v99 = v138 +v100 = v139 +continue +} +v113 = v116 +} else { +v113 = nil +} +v102 = v113 +} +v101 = v102 + break +} +v82 = v101 +} else { +v82 = nil +} +_ = v82 +v76 := lang.Apply(lang1.WriteWriter, []any{v4, "]"}) +v74 = v76 +} else { +v74 = nil +} +_ = v74 +v6 := lang.Apply(lang1.WriteWriter, []any{v4, "}"}) +return v6 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// read-string +{ +v0 := lang.NewSymbol("read-string").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s")), lang.NewVector(lang.NewSymbol("opts"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Reads one object from the string s. Optionally include reader\n options, as specified in read.\n\n Note that read-string can execute code (controlled by *read-eval*),\n and as such should be used only with trusted sources.\n\n For data structure interop use glojure.edn/read-string", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3806), lang.NewKeyword("end-line"), int(3806))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +v4 := lang.Apply(runtime3.RTReadString, []any{v3}) +return v4 + case 2: +v3 := args[0] +v4 := args[1] +v5 := lang.Apply(runtime3.RTReadString, []any{v4, v3}) +return v5 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// identity +{ +v0 := lang.NewSymbol("identity").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns its argument.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1446), lang.NewKeyword("end-line"), int(1446))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +return v3 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// split-at +{ +v0 := lang.NewSymbol("split-at").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a vector of [(take n coll) (drop n coll)]", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2983), lang.NewKeyword("end-line"), int(2983))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("take")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3, v4}) +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("drop")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v3, v4}) +v13 := lang.NewVector(v8, v12) +v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2988), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2988), lang.NewKeyword("end-column"), int(33)) +v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v15 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// first +{ +v0 := lang.NewSymbol("first").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns the first item in the collection. Calls seq on its\n argument. If coll is nil, returns nil.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(47), lang.NewKeyword("end-line"), int(52))).(*lang.Symbol) +var v2 lang.FnFunc +{ // function first +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := lang.Apply(lang1.First, []any{v4}) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(52), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(52), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) +v3 := v2 +_ = v3 +} +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// qualified-symbol? +{ +v0 := lang.NewSymbol("qualified-symbol?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a symbol with a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1628), lang.NewKeyword("end-line"), int(1628))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("boolean")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("symbol?")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v3}) +var v7 any = v11 +_ = v7 +var v13 any +if lang.IsTruthy(v7) { +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("namespace")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v3}) +var v14 any = v18 +_ = v14 +var v20 any +if lang.IsTruthy(v14) { +v20 = true +} else { +v20 = v14 +} +v13 = v20 +} else { +v13 = v7 +} +v7 := lang.Apply(v6, []any{v13}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// var? +{ +v0 := lang.NewSymbol("var?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("v"))), lang.NewKeyword("doc"), "Returns true if v is of type glojure.lang.Var", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4999), lang.NewKeyword("end-line"), int(4999))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{lang1.*Var, v3}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// if-some +{ +v0 := lang.NewSymbol("if-some").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("then")), lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("then"), lang.NewSymbol("else"), lang.NewSymbol("&"), lang.NewSymbol("oldform"))), lang.NewKeyword("doc"), "bindings => binding-form test\n\n If test is not nil, evaluates then with binding-form bound to the\n value of test, if not, yields else", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1874), lang.NewKeyword("end-line"), int(1874))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 4: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("seq")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("concat")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("list")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/if-some")}) +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("list")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v5}) +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("list")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v6}) +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("list")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.Apply(v27, []any{nil}) +v29 := lang.Apply(v12, []any{v16, v20, v24, v28}) +v30 := lang.Apply(v9, []any{v29}) +return v30 + default: + if len(args) < 5 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := args[4] +v8 := lang.NewList(args[5:]...) +var v9 any +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("vector?")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{v5}) +if lang.IsTruthy(v13) { +v9 = nil +} else { +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("str")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("first")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v3}) +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("*ns*")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("meta")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v3}) +v28 := lang.Apply(lang.NewKeyword("line"), []any{v27}) +v29 := lang.Apply(v16, []any{v20, " requires ", "a vector for its binding", " in ", v23, ":", v28}) +v30 := lang.Apply(lang1.NewIllegalArgumentError, []any{v29}) +panic(v30) +} +_ = v9 +var v31 any +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("nil?")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v8}) +if lang.IsTruthy(v35) { +v31 = nil +} else { +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("str")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("first")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +} +v41 := v40.Get() +v42 := lang.Apply(v41, []any{v3}) +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("*ns*")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +} +v45 := v44.Get() +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("meta")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +} +v48 := v47.Get() +v49 := lang.Apply(v48, []any{v3}) +v50 := lang.Apply(lang.NewKeyword("line"), []any{v49}) +v51 := lang.Apply(v38, []any{v42, " requires ", "1 or 2 forms after binding vector", " in ", v45, ":", v50}) +v52 := lang.Apply(lang1.NewIllegalArgumentError, []any{v51}) +panic(v52) +} +_ = v31 +var v53 any +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("=")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +} +v56 := v55.Get() +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("count")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +} +v59 := v58.Get() +v60 := lang.Apply(v59, []any{v5}) +v61 := lang.Apply(v56, []any{int64(2), v60}) +if lang.IsTruthy(v61) { +v53 = nil +} else { +v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v63 := v62.FindInternedVar(lang.NewSymbol("str")) +if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +} +v64 := v63.Get() +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("first")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +} +v67 := v66.Get() +v68 := lang.Apply(v67, []any{v3}) +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("*ns*")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +} +v71 := v70.Get() +v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v73 := v72.FindInternedVar(lang.NewSymbol("meta")) +if v73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) +} +v74 := v73.Get() +v75 := lang.Apply(v74, []any{v3}) +v76 := lang.Apply(lang.NewKeyword("line"), []any{v75}) +v77 := lang.Apply(v64, []any{v68, " requires ", "exactly 2 forms in binding vector", " in ", v71, ":", v76}) +v78 := lang.Apply(lang1.NewIllegalArgumentError, []any{v77}) +panic(v78) +} +_ = v53 +_ = nil +v80 := lang.Apply(v5, []any{int64(0)}) +var v79 any = v80 +_ = v79 +v82 := lang.Apply(v5, []any{int64(1)}) +var v81 any = v82 +_ = v81 +v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v85 := v84.FindInternedVar(lang.NewSymbol("seq")) +if v85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) +} +v86 := v85.Get() +v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v88 := v87.FindInternedVar(lang.NewSymbol("concat")) +if v88.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) +} +v89 := v88.Get() +v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v91 := v90.FindInternedVar(lang.NewSymbol("list")) +if v91.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) +} +v92 := v91.Get() +v93 := lang.Apply(v92, []any{lang.NewSymbol("glojure.core/let")}) +v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v95 := v94.FindInternedVar(lang.NewSymbol("list")) +if v95.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) +} +v96 := v95.Get() +v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v98 := v97.FindInternedVar(lang.NewSymbol("apply")) +if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) +} +v99 := v98.Get() +v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v101 := v100.FindInternedVar(lang.NewSymbol("vector")) +if v101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) +} +v102 := v101.Get() +v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v104 := v103.FindInternedVar(lang.NewSymbol("seq")) +if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) +} +v105 := v104.Get() +v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v107 := v106.FindInternedVar(lang.NewSymbol("concat")) +if v107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) +} +v108 := v107.Get() +v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v110 := v109.FindInternedVar(lang.NewSymbol("list")) +if v110.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) +} +v111 := v110.Get() +v112 := lang.Apply(v111, []any{lang.NewSymbol("temp__0__auto__")}) +v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v114 := v113.FindInternedVar(lang.NewSymbol("list")) +if v114.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) +} +v115 := v114.Get() +v116 := lang.Apply(v115, []any{v81}) +v117 := lang.Apply(v108, []any{v112, v116}) +v118 := lang.Apply(v105, []any{v117}) +v119 := lang.Apply(v99, []any{v102, v118}) +v120 := lang.Apply(v96, []any{v119}) +v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v122 := v121.FindInternedVar(lang.NewSymbol("list")) +if v122.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) +} +v123 := v122.Get() +v124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v125 := v124.FindInternedVar(lang.NewSymbol("seq")) +if v125.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v125))) +} +v126 := v125.Get() +v127 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v128 := v127.FindInternedVar(lang.NewSymbol("concat")) +if v128.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v128))) +} +v129 := v128.Get() +v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v131 := v130.FindInternedVar(lang.NewSymbol("list")) +if v131.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) +} +v132 := v131.Get() +v133 := lang.Apply(v132, []any{lang.NewSymbol("if")}) +v134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v135 := v134.FindInternedVar(lang.NewSymbol("list")) +if v135.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v135))) +} +v136 := v135.Get() +v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v138 := v137.FindInternedVar(lang.NewSymbol("seq")) +if v138.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) +} +v139 := v138.Get() +v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v141 := v140.FindInternedVar(lang.NewSymbol("concat")) +if v141.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) +} +v142 := v141.Get() +v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v144 := v143.FindInternedVar(lang.NewSymbol("list")) +if v144.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) +} +v145 := v144.Get() +v146 := lang.Apply(v145, []any{lang.NewSymbol("glojure.core/nil?")}) +v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v148 := v147.FindInternedVar(lang.NewSymbol("list")) +if v148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) +} +v149 := v148.Get() +v150 := lang.Apply(v149, []any{lang.NewSymbol("temp__0__auto__")}) +v151 := lang.Apply(v142, []any{v146, v150}) +v152 := lang.Apply(v139, []any{v151}) +v153 := lang.Apply(v136, []any{v152}) +v154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v155 := v154.FindInternedVar(lang.NewSymbol("list")) +if v155.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v155))) +} +v156 := v155.Get() +v157 := lang.Apply(v156, []any{v7}) +v158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v159 := v158.FindInternedVar(lang.NewSymbol("list")) +if v159.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v159))) +} +v160 := v159.Get() +v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v162 := v161.FindInternedVar(lang.NewSymbol("seq")) +if v162.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) +} +v163 := v162.Get() +v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v165 := v164.FindInternedVar(lang.NewSymbol("concat")) +if v165.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) +} +v166 := v165.Get() +v167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v168 := v167.FindInternedVar(lang.NewSymbol("list")) +if v168.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v168))) +} +v169 := v168.Get() +v170 := lang.Apply(v169, []any{lang.NewSymbol("glojure.core/let")}) +v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v172 := v171.FindInternedVar(lang.NewSymbol("list")) +if v172.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) +} +v173 := v172.Get() +v174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v175 := v174.FindInternedVar(lang.NewSymbol("apply")) +if v175.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v175))) +} +v176 := v175.Get() +v177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v178 := v177.FindInternedVar(lang.NewSymbol("vector")) +if v178.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v178))) +} +v179 := v178.Get() +v180 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v181 := v180.FindInternedVar(lang.NewSymbol("seq")) +if v181.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v181))) +} +v182 := v181.Get() +v183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v184 := v183.FindInternedVar(lang.NewSymbol("concat")) +if v184.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v184))) +} +v185 := v184.Get() +v186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v187 := v186.FindInternedVar(lang.NewSymbol("list")) +if v187.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v187))) +} +v188 := v187.Get() +v189 := lang.Apply(v188, []any{v79}) +v190 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v191 := v190.FindInternedVar(lang.NewSymbol("list")) +if v191.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v191))) +} +v192 := v191.Get() +v193 := lang.Apply(v192, []any{lang.NewSymbol("temp__0__auto__")}) +v194 := lang.Apply(v185, []any{v189, v193}) +v195 := lang.Apply(v182, []any{v194}) +v196 := lang.Apply(v176, []any{v179, v195}) +v197 := lang.Apply(v173, []any{v196}) +v198 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v199 := v198.FindInternedVar(lang.NewSymbol("list")) +if v199.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v199))) +} +v200 := v199.Get() +v201 := lang.Apply(v200, []any{v6}) +v202 := lang.Apply(v166, []any{v170, v197, v201}) +v203 := lang.Apply(v163, []any{v202}) +v204 := lang.Apply(v160, []any{v203}) +v205 := lang.Apply(v129, []any{v133, v153, v157, v204}) +v206 := lang.Apply(v126, []any{v205}) +v207 := lang.Apply(v123, []any{v206}) +v208 := lang.Apply(v89, []any{v93, v120, v207}) +v209 := lang.Apply(v86, []any{v208}) +return v209 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// hash-unordered-coll +{ +v0 := lang.NewSymbol("hash-unordered-coll").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns the hash code, consistent with =, for an external unordered\n collection implementing Iterable. For maps, the iterator should\n return map entries whose hash is computed as\n (hash-ordered-coll [k v]).\n See http://glojure.org/data_structures#hash for full algorithms.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5219), lang.NewKeyword("end-line"), int(5219))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.Apply(nil, []any{v3}) +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// load-data-readers +{ +v0 := lang.NewSymbol("load-data-readers").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7918), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7918), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v4 := v3.FindInternedVar(lang.NewSymbol("alter-var-root")) +if v4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) +} +v5 := v4.Get() +v6 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*data-readers*")) +var v7 lang.FnFunc +v7 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v8 := args[0] +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("reduce")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("load-data-reader-file")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("data-reader-urls")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, nil) +v19 := lang.Apply(v11, []any{v14, v8, v18}) +return v19 +}) +v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7920), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(7922), lang.NewKeyword("end-column"), int(57)) +v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v10 := lang.Apply(v5, []any{v6, v9}) +return v10 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// rest +{ +v1 := reflect.TypeOf((*lang1.ISeq)(nil)).Elem() +v0 := lang.NewSymbol("rest").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a possibly empty seq of the items after the first. Calls seq on its\n argument.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(64), lang.NewKeyword("end-line"), int(70))).(*lang.Symbol) +var v3 lang.FnFunc +{ // function rest +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +v6 := lang.Apply(lang1.Rest, []any{v5}) +return v6 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(70), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(70), lang.NewKeyword("end-column"), int(77))).(lang.FnFunc) +v4 := v3 +_ = v4 +} +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// PrintWriter-on +{ +v1 := reflect.TypeOf((*bytes18.Buffer)(nil)) +v0 := lang.NewSymbol("PrintWriter-on").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("flush-fn"), lang.NewSymbol("close-fn")), lang.NewVector(lang.NewSymbol("flush-fn"), lang.NewSymbol("close-fn"), lang.NewSymbol("autoflush?"))), lang.NewKeyword("doc"), "implements java.io.PrintWriter given flush-fn, which will be called\n when .flush() is called, with a string built up since the last call to .flush().\n if not nil, close-fn will be called with no arguments when .close is called.\n autoflush? determines if the PrintWriter will autoflush, false by default.", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(73), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(522), lang.NewKeyword("end-line"), int(522))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v4 := args[0] +v5 := args[1] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("PrintWriter-on")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v4, v5, false}) +return v9 + case 3: +v4 := args[0] +v5 := args[1] +v6 := args[2] +v8 := lang.Apply(StringBuilder19., nil) +var v7 any = v8 +_ = v7 +v10 := lang.NewVector(nil) +v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(532), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(532), lang.NewKeyword("end-column"), int(23)) +v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v13 := lang.NewVector() +v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(532), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(532), lang.NewKeyword("end-column"), int(26)) +v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("flush")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.NewVector() +v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(533), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(533), lang.NewKeyword("end-column"), int(19)) +v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v22 any +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("pos?")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26, ok := lang.FieldOrMethod(v7, "length") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "length"))) +} +var v27 any +switch reflect.TypeOf(v26).Kind() { +case reflect.Func: + v27 = lang.Apply(v26, nil) +default: + v27 = v26 +} +v28 := lang.Apply(v25, []any{v27}) +if lang.IsTruthy(v28) { +v29 := lang.Apply(lang1.ToString, []any{v7}) +v30 := lang.Apply(v4, []any{v29}) +v22 = v30 +} else { +v22 = nil +} +v31, _ := lang.FieldOrMethod(v7, "setLength") +if reflect.TypeOf(v31).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setLength is not a function"))) +} +v32 := lang.Apply(v31, []any{int64(0)}) +v33 := lang.Apply(v18, []any{v21, v22, v32}) +v34 := lang.NewVector() +v35 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(537), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(537), lang.NewKeyword("end-column"), int(19)) +v36, err := lang.WithMeta(v34, v35.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v37, ok := lang.FieldOrMethod(nil, "flush") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "flush"))) +} +var v38 any +switch reflect.TypeOf(v37).Kind() { +case reflect.Func: + v38 = lang.Apply(v37, nil) +default: + v38 = v37 +} +var v39 any +if lang.IsTruthy(v5) { +v40 := lang.Apply(v5, nil) +v39 = v40 +} else { +v39 = nil +} +v41 := lang.Apply(nil, []any{v36, v38, v39, nil}) +v42 := lang.NewVector(nil, nil, nil) +v43 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(541), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(541), lang.NewKeyword("end-column"), int(35)) +v44, err := lang.WithMeta(v42, v43.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v45 any +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("pos?")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +} +v48 := v47.Get() +v49 := lang.Apply(v48, []any{nil}) +if lang.IsTruthy(v49) { +var v50 any +v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v52 := v51.FindInternedVar(lang.NewSymbol("instance?")) +if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) +} +v53 := v52.Get() +v54 := lang.Apply(v53, []any{lang.Builtins["string"], nil}) +if lang.IsTruthy(v54) { +v55 := lang.Apply(lang1.AppendWriter, []any{v7, nil, nil, nil}) +v50 = v55 +} else { +v56 := lang.Apply(lang1.AppendWriter, []any{v7, nil, nil, nil}) +v50 = v56 +} +v45 = v50 +} else { +v45 = nil +} +v57 := lang.Apply(nil, []any{v44, v45}) +v58 := lang.Apply(nil, []any{v12, v15, v33, v41, v57}) +v59 := lang.Apply(java.io.BufferedWriter21., []any{v58}) +v60 := lang.Apply(java.io.PrintWriter20., []any{v59, v6}) +return v60 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v4 := reflect.TypeOf((*bytes18.Buffer)(nil)) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// * +{ +var v1 lang.FnFunc +v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v2 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +if lang.IsTruthy(v7) { +v4 = closed3 +} else { +v4 = v3 +} +var v3 any = v4 +_ = v3 +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("seq")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("concat")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("seq")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("concat")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v2}) +v40 := lang.Apply(v31, []any{v35, v39}) +v41 := lang.Apply(v28, []any{v40}) +v42 := lang.Apply(v25, []any{v41}) +v43 := lang.Apply(v14, []any{v18, v22, v42}) +v44 := lang.Apply(v11, []any{v43}) +return v44 + case 2: +v2 := args[0] +v3 := args[1] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +if lang.IsTruthy(v8) { +v5 = closed3 +} else { +v5 = v4 +} +var v4 any = v5 +_ = v4 +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("seq")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("concat")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("list")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("list")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("list")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("seq")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("concat")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("list")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v4}) +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("list")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v2}) +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("list")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v3}) +v45 := lang.Apply(v32, []any{v36, v40, v44}) +v46 := lang.Apply(v29, []any{v45}) +v47 := lang.Apply(v26, []any{v46}) +v48 := lang.Apply(v15, []any{v19, v23, v47}) +v49 := lang.Apply(v12, []any{v48}) +return v49 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v2 := args[0] +v3 := args[1] +v4 := lang.NewList(args[2:]...) +var v6 any +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +if lang.IsTruthy(v9) { +v6 = closed3 +} else { +v6 = v5 +} +var v5 any = v6 +_ = v5 +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +var v14 lang.FnFunc +v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v15 := args[0] +v16 := args[1] +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v5}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v15}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v16}) +v52 := lang.Apply(v39, []any{v43, v47, v51}) +v53 := lang.Apply(v36, []any{v52}) +v54 := lang.Apply(v33, []any{v53}) +v55 := lang.Apply(v22, []any{v26, v30, v54}) +v56 := lang.Apply(v19, []any{v55}) +return v56 +}) +v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) +v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v5}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v2}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v3}) +v52 := lang.Apply(v39, []any{v43, v47, v51}) +v53 := lang.Apply(v36, []any{v52}) +v54 := lang.Apply(v33, []any{v53}) +v55 := lang.Apply(v22, []any{v26, v30, v54}) +v56 := lang.Apply(v19, []any{v55}) +v57 := lang.Apply(v13, []any{v16, v56, v4}) +return v57 + } +}) +v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) +} +v5 := lang.Apply(v4, []any{v3, int64(1)}) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v0 := lang.NewSymbol("*").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the product of nums. (*) returns 1. Does not auto-promote\n longs, will throw on overflow. See also: *'", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1001), lang.NewKeyword("end-line"), int(1001))).(*lang.Symbol) +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +return int64(1) + case 1: +v5 := args[0] +v6 := lang.Apply(lang1.MustAsNumber, []any{v5}) +return v6 + case 2: +v5 := args[0] +v6 := args[1] +v7, _ := lang.FieldOrMethod(lang1.Numbers, "multiply") +if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("multiply is not a function"))) +} +v8 := lang.Apply(v7, []any{v5, v6}) +return v8 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +v6 := args[1] +v7 := lang.NewList(args[2:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("*")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("*")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v5, v6}) +v18 := lang.Apply(v10, []any{v13, v17, v7}) +return v18 + } +}) +v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v3 := ns.InternWithValue(v0, v4, true) +if v0.Meta() != nil { + v3.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// map-indexed +{ +v0 := lang.NewSymbol("map-indexed").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence consisting of the result of applying f to 0\n and the first item of coll, followed by applying f to 1 and the second\n item in coll, etc, until coll is exhausted. Thus function f should\n accept 2 arguments, index and item. Returns a stateful transducer when\n no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7352), lang.NewKeyword("end-line"), int(7352))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("volatile!")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{int64(-1)}) +var v6 any = v10 +_ = v6 +var v12 lang.FnFunc +v12 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v13 := lang.Apply(v5, nil) +return v13 + case 1: +v13 := args[0] +v14 := lang.Apply(v5, []any{v13}) +return v14 + case 2: +v13 := args[0] +v14 := args[1] +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("inc")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18, ok := lang.FieldOrMethod(v6, "Deref") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "Deref"))) +} +var v19 any +switch reflect.TypeOf(v18).Kind() { +case reflect.Func: + v19 = lang.Apply(v18, nil) +default: + v19 = v18 +} +v20 := lang.Apply(v17, []any{v19}) +v21, _ := lang.FieldOrMethod(v6, "reset") +if reflect.TypeOf(v21).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) +} +v22 := lang.Apply(v21, []any{v20}) +v23 := lang.Apply(v3, []any{v22, v14}) +v24 := lang.Apply(v5, []any{v13, v23}) +return v24 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7363), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7367), lang.NewKeyword("end-column"), int(48)) +v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v14 +}) +v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7361), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7367), lang.NewKeyword("end-column"), int(50)) +v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v6 + case 2: +v3 := args[0] +v4 := args[1] +return nil + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// mapcat +{ +v0 := lang.NewSymbol("mapcat").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Returns the result of applying concat to the result of applying map\n to f and colls. Thus function f should return a collection. Returns\n a transducer when no collections are provided", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2775), lang.NewKeyword("end-line"), int(2775))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("comp")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("map")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v3}) +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("cat")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v6, []any{v10, v13}) +return v14 + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.NewList(args[1:]...) +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("apply")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("concat")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("apply")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("map")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v13, []any{v16, v3, v4}) +v18 := lang.Apply(v7, []any{v10, v17}) +return v18 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// sigs +{ +v0 := lang.NewSymbol("sigs").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(223), lang.NewKeyword("column"), int(2), lang.NewKeyword("end-line"), int(224), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("assert-valid-fdecl")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{v3}) +_ = v7 +var v9 lang.FnFunc +v9 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v10 := args[0] +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("first")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v10}) +var v11 any = v15 +_ = v11 +var v17 any +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("first")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, []any{v16}) +v22 := lang.Apply(lang1.Equals, []any{lang.NewSymbol("&form"), v21}) +if lang.IsTruthy(v22) { +v23 := lang.Apply(lang1.Count, []any{v16}) +v24 := lang.Apply(lang1.Subvec, []any{v16, int64(2), v23}) +v17 = v24 +} else { +v17 = v16 +} +var v16 any = v17 +_ = v16 +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("next")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.Apply(v28, []any{v10}) +var v25 any = v29 +_ = v25 +var v31 any +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("map?")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("first")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v37, []any{v25}) +v39 := lang.Apply(v34, []any{v38}) +if lang.IsTruthy(v39) { +var v40 any +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("next")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v25}) +if lang.IsTruthy(v44) { +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("with-meta")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +} +v47 := v46.Get() +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("conj")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +var v51 any +v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v53 := v52.FindInternedVar(lang.NewSymbol("meta")) +if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) +} +v54 := v53.Get() +v55 := lang.Apply(v54, []any{v16}) +if lang.IsTruthy(v55) { +v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v57 := v56.FindInternedVar(lang.NewSymbol("meta")) +if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) +} +v58 := v57.Get() +v59 := lang.Apply(v58, []any{v16}) +v51 = v59 +} else { +v60 := lang.NewMap() +v61 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(237), lang.NewKeyword("column"), int(77), lang.NewKeyword("end-line"), int(237), lang.NewKeyword("end-column"), int(78)) +v62, err := lang.WithMeta(v60, v61.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v51 = v62 +} +v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v64 := v63.FindInternedVar(lang.NewSymbol("first")) +if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) +} +v65 := v64.Get() +v66 := lang.Apply(v65, []any{v25}) +v67 := lang.Apply(v50, []any{v51, v66}) +v68 := lang.Apply(v47, []any{v16, v67}) +v40 = v68 +} else { +v40 = v16 +} +v31 = v40 +} else { +v31 = v16 +} +return v31 +}) +v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(228), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(239), lang.NewKeyword("end-column"), int(25)) +v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v8 any = v11 +_ = v8 +var v13 lang.FnFunc +v13 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v14 := args[0] +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("meta")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v14}) +var v15 any = v19 +_ = v15 +v21 := lang.Apply(lang.NewKeyword("tag"), []any{v15}) +var v20 any = v21 +_ = v20 +var v23 any +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("instance?")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.Apply(v26, []any{lang1.*Symbol, v20}) +if lang.IsTruthy(v27) { +var v28 any +v29, ok := lang.FieldOrMethod(v20, "Name") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v20, "Name"))) +} +var v30 any +switch reflect.TypeOf(v29).Kind() { +case reflect.Func: + v30 = lang.Apply(v29, nil) +default: + v30 = v29 +} +v31 := lang.Apply(strings22.Index, []any{v30, "."}) +v32 := lang.Apply(lang1.Equiv, []any{v31, int64(-1)}) +if lang.IsTruthy(v32) { +var v33 any +v34 := lang.Apply(lang1.Equals, []any{nil, nil}) +if lang.IsTruthy(v34) { +var v35 any = nil +_ = v35 +var v37 any +if lang.IsTruthy(v35) { +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("with-meta")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("assoc")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44, ok := lang.FieldOrMethod(v35, "Name") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v35, "Name"))) +} +var v45 any +switch reflect.TypeOf(v44).Kind() { +case reflect.Func: + v45 = lang.Apply(v44, nil) +default: + v45 = v44 +} +v46 := lang.Apply(lang1.NewSymbol, []any{v45}) +v47 := lang.Apply(v43, []any{v15, lang.NewKeyword("tag"), v46}) +v48 := lang.Apply(v40, []any{v14, v47}) +v37 = v48 +} else { +v37 = v14 +} +v33 = v37 +} else { +v33 = v14 +} +v28 = v33 +} else { +v28 = v14 +} +v23 = v28 +} else { +v23 = v14 +} +return v23 +}) +v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(240), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(252), lang.NewKeyword("end-column"), int(37)) +v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v12 any = v15 +_ = v12 +var v17 any +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("seq?")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("first")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v3}) +v25 := lang.Apply(v20, []any{v24}) +if lang.IsTruthy(v25) { +v27 := lang.NewVector() +v28 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(254), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(254), lang.NewKeyword("end-column"), int(20)) +v29, err := lang.WithMeta(v27, v28.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v26 any = v29 +_ = v26 +var v30 any = v3 +_ = v30 +var v31 any +for { +var v32 any +if lang.IsTruthy(v30) { +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("conj")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("first")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v30}) +v41 := lang.Apply(v8, []any{v40}) +v42 := lang.Apply(v12, []any{v41}) +v43 := lang.Apply(v36, []any{v26, v42}) +var v33 any = v43 +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("next")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +} +v47 := v46.Get() +v48 := lang.Apply(v47, []any{v30}) +var v44 any = v48 +v26 = v33 +v30 = v44 +continue +} else { +v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v50 := v49.FindInternedVar(lang.NewSymbol("seq")) +if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) +} +v51 := v50.Get() +v52 := lang.Apply(v51, []any{v26}) +v32 = v52 +} +v31 = v32 + break +} +v17 = v31 +} else { +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("list")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.Apply(v8, []any{v3}) +v30 := lang.Apply(v12, []any{v29}) +v31 := lang.Apply(v28, []any{v30}) +v17 = v31 +} +return v17 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(225), lang.NewKeyword("column"), int(2), lang.NewKeyword("end-line"), int(258), lang.NewKeyword("end-column"), int(43))).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// chunk-buffer +{ +v0 := lang.NewSymbol("chunk-buffer").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(685), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(685), lang.NewKeyword("end-column"), int(53), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("capacity"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.Apply(lang1.NewChunkBuffer, []any{v3}) +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// contains? +{ +v0 := lang.NewSymbol("contains?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("key"))), lang.NewKeyword("doc"), "Returns true if key is present in the given collection, otherwise\n returns false. Note that for numerically indexed collections like\n vectors and Java arrays, this tests if the numeric key is within the\n range of indexes. 'contains?' operates constant or logarithmic time;\n it will not perform a linear search for a value. See also 'some'.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1479), lang.NewKeyword("end-line"), int(1479))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5, _ := lang.FieldOrMethod(runtime3.RT, "Contains") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Contains is not a function"))) +} +v6 := lang.Apply(v5, []any{v3, v4}) +return v6 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// thread-bound? +{ +v0 := lang.NewSymbol("thread-bound?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("vars"))), lang.NewKeyword("doc"), "Returns true if all of the vars provided as arguments have thread-local bindings.\n Implies that set!'ing the provided vars will succeed. Returns true if no vars are provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5542), lang.NewKeyword("end-line"), int(5542))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.NewList(args[0:]...) +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("every?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +var v7 lang.FnFunc +v7 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v8 := args[0] +v9, ok := lang.FieldOrMethod(v8, "getThreadBinding") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "getThreadBinding"))) +} +var v10 any +switch reflect.TypeOf(v9).Kind() { +case reflect.Func: + v10 = lang.Apply(v9, nil) +default: + v10 = v9 +} +return v10 +}) +v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5548), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5548), lang.NewKeyword("end-column"), int(78)) +v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v10 := lang.Apply(v6, []any{v9, v3}) +return v10 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// struct-map +{ +v0 := lang.NewSymbol("struct-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("&"), lang.NewSymbol("inits"))), lang.NewKeyword("doc"), "Returns a new structmap instance with the keys of the\n structure-basis. keyvals may contain all, some or none of the basis\n keys - where values are not supplied they will default to nil.\n keyvals can also contain keys not in the basis.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4051), lang.NewKeyword("end-line"), int(4051))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.NewList(args[1:]...) +v5 := lang.Apply(lang1.CreatePersistentStructMap, []any{v3, v4}) +return v5 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// distinct? +{ +v1 := reflect.TypeOf(false) +v0 := lang.NewSymbol("distinct?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Returns true if no two of the arguments are =", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5707), lang.NewKeyword("end-line"), int(5707))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v4 := args[0] +return true + case 2: +v4 := args[0] +v5 := args[1] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("not")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("=")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v4, v5}) +v13 := lang.Apply(v8, []any{v12}) +return v13 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := args[1] +v6 := lang.NewList(args[2:]...) +var v7 any +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("not=")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v4, v5}) +if lang.IsTruthy(v11) { +v13 := lang.CreatePersistentTreeSet(v4, v5) +v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5716), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(5716), lang.NewKeyword("end-column"), int(20)) +v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v12 any = v15 +_ = v12 +var v16 any = v6 +_ = v16 +var v17 any = v16 +_ = v17 +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("seq")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v17}) +var v18 any = v22 +_ = v18 +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("first")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v18}) +var v23 any = v27 +_ = v23 +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("next")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.Apply(v31, []any{v28}) +var v28 any = v32 +_ = v28 +var v33 any = v23 +_ = v33 +var v34 any = v28 +_ = v34 +var v35 any = v17 +_ = v35 +var v37 any = v37 +_ = v37 +var v38 any = v38 +_ = v38 +var v39 any +for { +var v40 any = v40 +_ = v40 +var v41 any = v38 +_ = v41 +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("seq")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +} +v45 := v44.Get() +v46 := lang.Apply(v45, []any{v41}) +var v42 any = v46 +_ = v42 +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("first")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v42}) +var v47 any = v51 +_ = v47 +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("next")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +} +v55 := v54.Get() +v56 := lang.Apply(v55, []any{v52}) +var v52 any = v56 +_ = v52 +var v57 any = v47 +_ = v57 +var v58 any = v52 +_ = v58 +var v59 any = v41 +_ = v59 +var v61 any +if lang.IsTruthy(v59) { +var v62 any +v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v64 := v63.FindInternedVar(lang.NewSymbol("contains?")) +if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) +} +v65 := v64.Get() +v66 := lang.Apply(v65, []any{v40, v57}) +if lang.IsTruthy(v66) { +v62 = false +} else { +v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v69 := v68.FindInternedVar(lang.NewSymbol("conj")) +if v69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) +} +v70 := v69.Get() +v71 := lang.Apply(v70, []any{v40, v57}) +var v67 any = v71 +var v72 any = v58 +v37 = v67 +v38 = v72 +continue +} +v61 = v62 +} else { +v61 = true +} +v39 = v61 + break +} +v7 = v39 +} else { +v7 = false +} +return v7 + } +}) +v4 := reflect.TypeOf(false) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// keep-indexed +{ +v0 := lang.NewSymbol("keep-indexed").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the non-nil results of (f index item). Note,\n this means false return values will be included. f must be free of\n side-effects. Returns a stateful transducer when no collection is\n provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7415), lang.NewKeyword("end-line"), int(7415))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("volatile!")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{int64(-1)}) +var v6 any = v10 +_ = v6 +var v12 lang.FnFunc +v12 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v13 := lang.Apply(v5, nil) +return v13 + case 1: +v13 := args[0] +v14 := lang.Apply(v5, []any{v13}) +return v14 + case 2: +v13 := args[0] +v14 := args[1] +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("inc")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19, ok := lang.FieldOrMethod(v6, "Deref") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "Deref"))) +} +var v20 any +switch reflect.TypeOf(v19).Kind() { +case reflect.Func: + v20 = lang.Apply(v19, nil) +default: + v20 = v19 +} +v21 := lang.Apply(v18, []any{v20}) +v22, _ := lang.FieldOrMethod(v6, "reset") +if reflect.TypeOf(v22).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) +} +v23 := lang.Apply(v22, []any{v21}) +var v15 any = v23 +_ = v15 +v25 := lang.Apply(v3, []any{v15, v14}) +var v24 any = v25 +_ = v24 +var v27 any +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("nil?")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{v24}) +if lang.IsTruthy(v31) { +v27 = v13 +} else { +v32 := lang.Apply(v5, []any{v13, v24}) +v27 = v32 +} +return v27 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7425), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7433), lang.NewKeyword("end-column"), int(33)) +v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v14 +}) +v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7423), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7433), lang.NewKeyword("end-column"), int(35)) +v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v6 + case 2: +v3 := args[0] +v4 := args[1] +return nil + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// *print-dup* +{ +v0 := lang.NewSymbol("*print-dup*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "When set to logical true, objects will be printed in a way that preserves\n their type when read in later.\n\n Defaults to false.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, nil, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// reduce1 +{ +v0 := lang.NewSymbol("reduce1").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(923), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(924), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("val"), lang.NewSymbol("coll"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v3 := args[0] +v4 := args[1] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("seq")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v4}) +var v5 any = v9 +_ = v5 +var v11 any +if lang.IsTruthy(v5) { +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("reduce1")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("first")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v5}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("next")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v5}) +v23 := lang.Apply(v14, []any{v3, v18, v22}) +v11 = v23 +} else { +v24 := lang.Apply(v3, nil) +v11 = v24 +} +return v11 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +recur_loop_156: +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("seq")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v5}) +var v6 any = v10 +_ = v6 +var v12 any +if lang.IsTruthy(v6) { +var v13 any +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("chunked-seq?")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v6}) +if lang.IsTruthy(v17) { +var v18 any = v3 +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("chunk-first")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.Apply(v22, []any{v6}) +v24, _ := lang.FieldOrMethod(v23, "ReduceInit") +if reflect.TypeOf(v24).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) +} +v25 := lang.Apply(v24, []any{v3, v4}) +var v19 any = v25 +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("chunk-next")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{v6}) +var v26 any = v30 +v3 = v18 +v4 = v19 +v5 = v26 +goto recur_loop_156 +} else { +var v31 any = v3 +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("first")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v6}) +v37 := lang.Apply(v3, []any{v4, v36}) +var v32 any = v37 +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("next")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +} +v41 := v40.Get() +v42 := lang.Apply(v41, []any{v6}) +var v38 any = v42 +v3 = v31 +v4 = v32 +v5 = v38 +goto recur_loop_156 +} +v12 = v13 +} else { +v12 = v4 +} +return v12 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// ensure-reduced +{ +v0 := lang.NewSymbol("ensure-reduced").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "If x is already reduced?, returns it, else returns (reduced x)", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2841), lang.NewKeyword("end-line"), int(2841))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("reduced?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +if lang.IsTruthy(v8) { +v4 = v3 +} else { +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("reduced")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v3}) +v4 = v12 +} +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// data-reader-urls +{ +v0 := lang.NewSymbol("data-reader-urls").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7883), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7883), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +return lang.NewList() +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// repeatedly +{ +v0 := lang.NewSymbol("repeatedly").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Takes a function of no args, presumably with side effects, and\n returns an infinite (or length n if supplied) lazy sequence of calls\n to it", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5167), lang.NewKeyword("end-line"), int(5167))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("cons")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v3, nil) +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("repeatedly")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v3}) +v13 := lang.Apply(v7, []any{v8, v12}) +return v13 +}) +v5 := lang.Apply(lang1.NewLazySeq, []any{v4}) +return v5 + case 2: +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("take")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("repeatedly")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v4}) +v12 := lang.Apply(v7, []any{v3, v11}) +return v12 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// find-ns +{ +v0 := lang.NewSymbol("find-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Returns the namespace named by the symbol or nil if it doesn't exist.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4125), lang.NewKeyword("end-line"), int(4125))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.Apply(lang1.FindNamespace, []any{v3}) +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// *print-meta* +{ +v0 := lang.NewSymbol("*print-meta*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "If set to logical true, when printing an object, its metadata will also\n be printed in a form that can be read back by the reader.\n\n Defaults to false.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, nil, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// set-error-handler! +{ +v0 := lang.NewSymbol("set-error-handler!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("handler-fn"))), lang.NewKeyword("doc"), "Sets the error-handler of agent a to handler-fn. If an action\n being run by the agent throws an exception or doesn't pass the\n validator fn, handler-fn will be called with two arguments: the\n agent and the exception.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2192), lang.NewKeyword("end-line"), int(2192))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5, _ := lang.FieldOrMethod(v3, "setErrorHandler") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorHandler is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// add-classpath +{ +v0 := lang.NewSymbol("add-classpath").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("url"))), lang.NewKeyword("doc"), "DEPRECATED \n\n Adds the url (String or URL object) to the classpath per\n URLClassLoader.addURL", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("deprecated"), "1.1", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5176), lang.NewKeyword("end-line"), int(5176))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("println")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{"WARNING: add-classpath is deprecated"}) +_ = v7 +v8 := lang.Apply(nil, []any{v3}) +return v8 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// ns-unmap +{ +v0 := lang.NewSymbol("ns-unmap").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Removes the mappings for the symbol from the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4177), lang.NewKeyword("end-line"), int(4177))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("the-ns")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +v9, _ := lang.FieldOrMethod(v8, "unmap") +if reflect.TypeOf(v9).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unmap is not a function"))) +} +v10 := lang.Apply(v9, []any{v4}) +return v10 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// even? +{ +v0 := lang.NewSymbol("even?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is even, throws an exception if n is not an integer", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1381), lang.NewKeyword("end-line"), int(1381))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("integer?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +if lang.IsTruthy(v8) { +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("zero?")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("bit-and")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(lang1.UncheckedLongCast, []any{v3}) +v16 := lang.Apply(v14, []any{v15, int64(1)}) +v17 := lang.Apply(v11, []any{v16}) +v4 = v17 +} else { +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("str")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, []any{"Argument must be an integer: ", v3}) +v22 := lang.Apply(lang1.NewIllegalArgumentError, []any{v21}) +panic(v22) +} +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// booleans +{ +var v1 lang.FnFunc +{ // function booleans +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/booleans")}) +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("list")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v3}) +v26 := lang.Apply(v9, []any{v13, v17, v21, v25}) +v27 := lang.Apply(v6, []any{v26}) +return v27 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("booleans").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Casts to boolean[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5372), lang.NewKeyword("end-line"), int(5372))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "booleans") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("booleans is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// unchecked-negate-int +{ +var v1 lang.FnFunc +{ // function unchecked-negate-int__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/unchecked_int_negate")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v3}) +v35 := lang.Apply(v26, []any{v30, v34}) +v36 := lang.Apply(v23, []any{v35}) +v37 := lang.Apply(v20, []any{v36}) +v38 := lang.Apply(v9, []any{v13, v17, v37}) +v39 := lang.Apply(v6, []any{v38}) +return v39 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("unchecked-negate-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the negation of x, an int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(26), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1182), lang.NewKeyword("end-line"), int(1182))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "unchecked_int_negate") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_negate is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// print-prefix-map +{ +v0 := lang.NewSymbol("print-prefix-map").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(243), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(243), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("prefix"), lang.NewSymbol("kvs"), lang.NewSymbol("print-one"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("print-sequential")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("str")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{v3, "{"}) +var v14 lang.FnFunc +v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v15 := args[0] +v16 := args[1] +var v17 any = v15 +_ = v17 +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("nth")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v17, int64(0), nil}) +var v18 any = v22 +_ = v18 +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("nth")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v17, int64(1), nil}) +var v23 any = v27 +_ = v23 +v29 := lang.Apply(v5, []any{v18, v16}) +_ = v29 +v30 := lang.Apply(lang1.AppendWriter, []any{v16, lang.NewChar(32)}) +_ = v30 +v31 := lang.Apply(v5, []any{v23, v16}) +return v31 +}) +v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(246), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(247), lang.NewKeyword("end-column"), int(107)) +v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v17 := lang.Apply(v9, []any{v13, v16, ", ", "}", v4, v6}) +return v17 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// compile +{ +v0 := lang.NewSymbol("compile").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"))), lang.NewKeyword("doc"), "Compiles the namespace named by the symbol lib into a set of\n classfiles. The source for the lib must be in a proper\n classpath-relative directory. The output files will go into the\n directory specified by *compile-path*, and that directory too must\n be in the classpath.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6157), lang.NewKeyword("end-line"), int(6157))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("push-thread-bindings")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("hash-map")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*compile-files*")) +v12 := lang.Apply(v10, []any{v11, true}) +v13 := lang.Apply(v7, []any{v12}) +_ = v13 +var v14 any +func() { +defer func() { +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, nil) +}() +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("load-one")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v3, true, true}) +v14 = v22 +}() +_ = v14 +return v3 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// unquote +{ +v0 := lang.NewSymbol("unquote").WithMeta(lang.NewMap()).(*lang.Symbol) +v1 := ns.Intern(v0) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// ref-set +{ +v0 := lang.NewSymbol("ref-set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Must be called in a transaction. Sets the value of ref.\n Returns val.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2447), lang.NewKeyword("end-line"), int(2447))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5, _ := lang.FieldOrMethod(v3, "set") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("set is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// identical? +{ +var v1 lang.FnFunc +{ // function identical?__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("concat")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("list")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol("glojure.lang.Util")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{lang.NewSymbol("glojure.core/identical")}) +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{v3}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{v4}) +v31 := lang.Apply(v10, []any{v14, v18, v22, v26, v30}) +v32 := lang.Apply(v7, []any{v31}) +return v32 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("identical?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Tests if 2 arguments are the same object", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(768), lang.NewKeyword("end-line"), int(768))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := args[1] +v6 := lang.Apply(lang1.Identical, []any{v4, v5}) +return v6 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// type +{ +v0 := lang.NewSymbol("type").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns the :type metadata of x, or its Class if none", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3467), lang.NewKeyword("end-line"), int(3467))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("get")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("meta")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v3}) +v12 := lang.Apply(v7, []any{v11, lang.NewKeyword("type")}) +var v4 any = v12 +_ = v4 +var v14 any +if lang.IsTruthy(v4) { +v14 = v4 +} else { +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("class")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v3}) +v14 = v18 +} +return v14 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// prefer-method +{ +v0 := lang.NewSymbol("prefer-method").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"), lang.NewSymbol("dispatch-val-x"), lang.NewSymbol("dispatch-val-y"))), lang.NewKeyword("doc"), "Causes the multimethod to prefer matches of dispatch-val-x over dispatch-val-y \n when there is a conflict", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1801), lang.NewKeyword("end-line"), int(1801))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6, _ := lang.FieldOrMethod(v3, "PreferMethod") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("PreferMethod is not a function"))) +} +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// sorted-set +{ +v0 := lang.NewSymbol("sorted-set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keys"))), lang.NewKeyword("doc"), "Returns a new sorted set with supplied keys. Any equal keys are\n handled as if by repeated uses of conj.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(416), lang.NewKeyword("end-line"), int(416))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.NewList(args[0:]...) +v4 := lang.Apply(lang1.CreatePersistentTreeSet, []any{v3}) +return v4 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// get-in +{ +v0 := lang.NewSymbol("get-in").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("ks")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("ks"), lang.NewSymbol("not-found"))), lang.NewKeyword("doc"), "Returns the value in a nested associative structure,\n where ks is a sequence of keys. Returns nil if the key\n is not present, or the not-found value if supplied.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6171), lang.NewKeyword("end-line"), int(6171))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("reduce1")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("get")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v7, []any{v10, v3, v4}) +return v11 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v7 := lang.Apply(Object23., nil) +var v6 any = v7 +_ = v6 +var v8 any = v8 +_ = v8 +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("seq")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{v9}) +var v9 any = v13 +_ = v9 +var v14 any +for { +var v15 any +if lang.IsTruthy(v9) { +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("get")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("first")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.Apply(v22, []any{v9}) +v24 := lang.Apply(v19, []any{v16, v23, v6}) +var v16 any = v24 +_ = v16 +var v26 any +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("identical?")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{v6, v16}) +if lang.IsTruthy(v30) { +v26 = v5 +} else { +var v31 any = v6 +var v32 any = v16 +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("next")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.Apply(v36, []any{v9}) +var v33 any = v37 +v6 = v31 +v8 = v32 +v9 = v33 +continue +} +v15 = v26 +} else { +v15 = v8 +} +v14 = v15 + break +} +return v14 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// nfirst +{ +v0 := lang.NewSymbol("nfirst").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Same as (next (first x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(105), lang.NewKeyword("end-line"), int(109))).(*lang.Symbol) +var v2 lang.FnFunc +{ // function nfirst +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("next")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("first")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v4}) +v12 := lang.Apply(v7, []any{v11}) +return v12 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(109), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(109), lang.NewKeyword("end-column"), int(49))).(lang.FnFunc) +v3 := v2 +_ = v3 +} +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// var-get +{ +v0 := lang.NewSymbol("var-get").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Gets the value in the var object", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4326), lang.NewKeyword("end-line"), int(4326))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, _ := lang.FieldOrMethod(v3, "Get") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Get is not a function"))) +} +v5 := lang.Apply(v4, []any{}) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// load +{ +v0 := lang.NewSymbol("load").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("paths"))), lang.NewKeyword("doc"), "Loads Clojure code from resources in classpath. A path is interpreted as\n classpath-relative if it begins with a slash or relative to the root\n directory for the current namespace otherwise.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("redef"), true, lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6138), lang.NewKeyword("end-line"), int(6138))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.NewList(args[0:]...) +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +var v4 any = v8 +_ = v4 +var v9 any = nil +_ = v9 +var v10 any = int64(0) +_ = v10 +var v11 any = int64(0) +_ = v11 +var v12 any +for { +var v13 any +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("<")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v11, v10}) +if lang.IsTruthy(v17) { +v19, _ := lang.FieldOrMethod(v9, "nth") +if reflect.TypeOf(v19).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) +} +v20 := lang.Apply(v19, []any{v11}) +var v18 any = v20 +_ = v18 +var v23 any +v24 := lang.Apply(strings22.HasPrefix, []any{v22, "/"}) +if lang.IsTruthy(v24) { +v23 = v22 +} else { +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("str")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("root-directory")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("ns-name")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("*ns*")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.Apply(v33, []any{v36}) +v38 := lang.Apply(v30, []any{v37}) +v39 := lang.Apply(v27, []any{v38, lang.NewChar(47), v22}) +v23 = v39 +} +var v22 any = v23 +_ = v22 +var v41 any +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +} +v44 := v43.Get() +if lang.IsTruthy(v44) { +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("printf")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +} +v47 := v46.Get() +v48 := lang.Apply(v47, []any{"(glojure.core/load \"%s\")\n", v22}) +_ = v48 +v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v50 := v49.FindInternedVar(lang.NewSymbol("flush")) +if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) +} +v51 := v50.Get() +v52 := lang.Apply(v51, nil) +v41 = v52 +} else { +v41 = nil +} +_ = v41 +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("check-cyclic-dependency")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +} +v55 := v54.Get() +v56 := lang.Apply(v55, []any{v22}) +_ = v56 +var v57 any +v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v59 := v58.FindInternedVar(lang.NewSymbol("=")) +if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) +} +v60 := v59.Get() +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("first")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +} +v63 := v62.Get() +v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v65 := v64.FindInternedVar(lang.NewSymbol("*pending-paths*")) +if v65.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) +} +v66 := v65.Get() +v67 := lang.Apply(v63, []any{v66}) +v68 := lang.Apply(v60, []any{v22, v67}) +if lang.IsTruthy(v68) { +v57 = nil +} else { +v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v71 := v70.FindInternedVar(lang.NewSymbol("push-thread-bindings")) +if v71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) +} +v72 := v71.Get() +v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v74 := v73.FindInternedVar(lang.NewSymbol("hash-map")) +if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) +} +v75 := v74.Get() +v76 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*pending-paths*")) +v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v78 := v77.FindInternedVar(lang.NewSymbol("conj")) +if v78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) +} +v79 := v78.Get() +v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v81 := v80.FindInternedVar(lang.NewSymbol("*pending-paths*")) +if v81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) +} +v82 := v81.Get() +v83 := lang.Apply(v79, []any{v82, v22}) +v84 := lang.Apply(v75, []any{v76, v83}) +v85 := lang.Apply(v72, []any{v84}) +_ = v85 +var v86 any +func() { +defer func() { +v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v88 := v87.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) +if v88.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) +} +v89 := v88.Get() +v90 := lang.Apply(v89, nil) +}() +v91 := lang.Apply(strings22.TrimPrefix, []any{v22, "/"}) +v92, _ := lang.FieldOrMethod(runtime3.RT, "Load") +if reflect.TypeOf(v92).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Load is not a function"))) +} +v93 := lang.Apply(v92, []any{v91}) +v86 = v93 +}() +v57 = v86 +} +_ = v57 +var v22 any = v4 +var v23 any = v9 +var v24 any = v10 +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("unchecked-inc")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.Apply(v28, []any{v11}) +var v25 any = v29 +v4 = v22 +v9 = v23 +v10 = v24 +v11 = v25 +continue +} else { +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("seq")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v4}) +var v18 any = v22 +_ = v18 +var v24 any +if lang.IsTruthy(v18) { +var v25 any = v18 +_ = v25 +var v27 any +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("chunked-seq?")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{v25}) +if lang.IsTruthy(v31) { +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("chunk-first")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v25}) +var v32 any = v36 +_ = v32 +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("chunk-rest")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +} +v41 := v40.Get() +v42 := lang.Apply(v41, []any{v25}) +var v38 any = v42 +var v43 any = v32 +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("int")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +} +v47 := v46.Get() +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("count")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v32}) +v52 := lang.Apply(v47, []any{v51}) +var v44 any = v52 +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("int")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +} +v56 := v55.Get() +v57 := lang.Apply(v56, []any{int64(0)}) +var v53 any = v57 +v4 = v38 +v9 = v43 +v10 = v44 +v11 = v53 +continue +} else { +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("first")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v25}) +var v32 any = v36 +_ = v32 +var v39 any +v40 := lang.Apply(strings22.HasPrefix, []any{v38, "/"}) +if lang.IsTruthy(v40) { +v39 = v38 +} else { +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("str")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("root-directory")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("ns-name")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +} +v49 := v48.Get() +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("*ns*")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +} +v52 := v51.Get() +v53 := lang.Apply(v49, []any{v52}) +v54 := lang.Apply(v46, []any{v53}) +v55 := lang.Apply(v43, []any{v54, lang.NewChar(47), v38}) +v39 = v55 +} +var v38 any = v39 +_ = v38 +var v57 any +v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v59 := v58.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) +if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) +} +v60 := v59.Get() +if lang.IsTruthy(v60) { +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("printf")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +} +v63 := v62.Get() +v64 := lang.Apply(v63, []any{"(glojure.core/load \"%s\")\n", v38}) +_ = v64 +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("flush")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +} +v67 := v66.Get() +v68 := lang.Apply(v67, nil) +v57 = v68 +} else { +v57 = nil +} +_ = v57 +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("check-cyclic-dependency")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +} +v71 := v70.Get() +v72 := lang.Apply(v71, []any{v38}) +_ = v72 +var v73 any +v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v75 := v74.FindInternedVar(lang.NewSymbol("=")) +if v75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) +} +v76 := v75.Get() +v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v78 := v77.FindInternedVar(lang.NewSymbol("first")) +if v78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) +} +v79 := v78.Get() +v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v81 := v80.FindInternedVar(lang.NewSymbol("*pending-paths*")) +if v81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) +} +v82 := v81.Get() +v83 := lang.Apply(v79, []any{v82}) +v84 := lang.Apply(v76, []any{v38, v83}) +if lang.IsTruthy(v84) { +v73 = nil +} else { +v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v87 := v86.FindInternedVar(lang.NewSymbol("push-thread-bindings")) +if v87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) +} +v88 := v87.Get() +v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v90 := v89.FindInternedVar(lang.NewSymbol("hash-map")) +if v90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) +} +v91 := v90.Get() +v92 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*pending-paths*")) +v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v94 := v93.FindInternedVar(lang.NewSymbol("conj")) +if v94.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) +} +v95 := v94.Get() +v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v97 := v96.FindInternedVar(lang.NewSymbol("*pending-paths*")) +if v97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) +} +v98 := v97.Get() +v99 := lang.Apply(v95, []any{v98, v38}) +v100 := lang.Apply(v91, []any{v92, v99}) +v101 := lang.Apply(v88, []any{v100}) +_ = v101 +var v102 any +func() { +defer func() { +v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v104 := v103.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) +if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) +} +v105 := v104.Get() +v106 := lang.Apply(v105, nil) +}() +v107 := lang.Apply(strings22.TrimPrefix, []any{v38, "/"}) +v108, _ := lang.FieldOrMethod(runtime3.RT, "Load") +if reflect.TypeOf(v108).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Load is not a function"))) +} +v109 := lang.Apply(v108, []any{v107}) +v102 = v109 +}() +v73 = v102 +} +_ = v73 +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("next")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +} +v41 := v40.Get() +v42 := lang.Apply(v41, []any{v25}) +var v38 any = v42 +var v43 any = nil +var v44 any = int64(0) +var v45 any = int64(0) +v4 = v38 +v9 = v43 +v10 = v44 +v11 = v45 +continue +} +v24 = v27 +} else { +v24 = nil +} +v13 = v24 +} +v12 = v13 + break +} +return v12 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// rand-nth +{ +v0 := lang.NewSymbol("rand-nth").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return a random element of the (sequential) collection. Will have\n the same performance characteristics as nth for the given\n collection.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7256), lang.NewKeyword("end-line"), int(7256))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("nth")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("rand-int")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("count")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{v3}) +v14 := lang.Apply(v9, []any{v13}) +v15 := lang.Apply(v6, []any{v3, v14}) +return v15 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// class +{ +v0 := lang.NewSymbol("class").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns the Class of x", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3461), lang.NewKeyword("end-line"), int(3461))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("nil?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +if lang.IsTruthy(v8) { +v4 = v3 +} else { +v9 := lang.Apply(lang1.TypeOf, []any{v3}) +v4 = v9 +} +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// seqable? +{ +v0 := lang.NewSymbol("seqable?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if the seq function is supported for x", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6247), lang.NewKeyword("end-line"), int(6247))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.Apply(nil, []any{v3}) +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// future? +{ +v0 := lang.NewSymbol("future?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is a future", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6575), lang.NewKeyword("end-line"), int(6575))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{java.util.concurrent15.Future, v3}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// denominator +{ +v1 := reflect.TypeOf((*big9.Int)(nil)) +v0 := lang.NewSymbol("denominator").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("r"))), lang.NewKeyword("doc"), "Returns the denominator part of a Ratio.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3591), lang.NewKeyword("end-line"), int(3591))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5, ok := lang.FieldOrMethod(v4, "denominator") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "denominator"))) +} +var v6 any +switch reflect.TypeOf(v5).Kind() { +case reflect.Func: + v6 = lang.Apply(v5, nil) +default: + v6 = v5 +} +return v6 +}) +v4 := reflect.TypeOf((*big9.Int)(nil)) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// when-let +{ +v0 := lang.NewSymbol("when-let").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "bindings => binding-form test\n\n When test is true, evaluates body with binding-form bound to the value of test", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1859), lang.NewKeyword("end-line"), int(1859))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +var v7 any +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v5}) +if lang.IsTruthy(v11) { +v7 = nil +} else { +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("str")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("first")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v3}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("meta")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v3}) +v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) +v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) +v28 := lang.Apply(lang1.NewIllegalArgumentError, []any{v27}) +panic(v28) +} +_ = v7 +var v29 any +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("=")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("count")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v5}) +v37 := lang.Apply(v32, []any{int64(2), v36}) +if lang.IsTruthy(v37) { +v29 = nil +} else { +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("str")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("first")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v3}) +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +} +v47 := v46.Get() +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("meta")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v3}) +v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) +v53 := lang.Apply(v40, []any{v44, " requires ", "exactly 2 forms in binding vector", " in ", v47, ":", v52}) +v54 := lang.Apply(lang1.NewIllegalArgumentError, []any{v53}) +panic(v54) +} +_ = v29 +_ = nil +v56 := lang.Apply(v5, []any{int64(0)}) +var v55 any = v56 +_ = v55 +v58 := lang.Apply(v5, []any{int64(1)}) +var v57 any = v58 +_ = v57 +v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v61 := v60.FindInternedVar(lang.NewSymbol("seq")) +if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) +} +v62 := v61.Get() +v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v64 := v63.FindInternedVar(lang.NewSymbol("concat")) +if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) +} +v65 := v64.Get() +v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v67 := v66.FindInternedVar(lang.NewSymbol("list")) +if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) +} +v68 := v67.Get() +v69 := lang.Apply(v68, []any{lang.NewSymbol("glojure.core/let")}) +v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v71 := v70.FindInternedVar(lang.NewSymbol("list")) +if v71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) +} +v72 := v71.Get() +v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v74 := v73.FindInternedVar(lang.NewSymbol("apply")) +if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) +} +v75 := v74.Get() +v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v77 := v76.FindInternedVar(lang.NewSymbol("vector")) +if v77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) +} +v78 := v77.Get() +v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v80 := v79.FindInternedVar(lang.NewSymbol("seq")) +if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) +} +v81 := v80.Get() +v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v83 := v82.FindInternedVar(lang.NewSymbol("concat")) +if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) +} +v84 := v83.Get() +v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v86 := v85.FindInternedVar(lang.NewSymbol("list")) +if v86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) +} +v87 := v86.Get() +v88 := lang.Apply(v87, []any{lang.NewSymbol("temp__0__auto__")}) +v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v90 := v89.FindInternedVar(lang.NewSymbol("list")) +if v90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) +} +v91 := v90.Get() +v92 := lang.Apply(v91, []any{v57}) +v93 := lang.Apply(v84, []any{v88, v92}) +v94 := lang.Apply(v81, []any{v93}) +v95 := lang.Apply(v75, []any{v78, v94}) +v96 := lang.Apply(v72, []any{v95}) +v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v98 := v97.FindInternedVar(lang.NewSymbol("list")) +if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) +} +v99 := v98.Get() +v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v101 := v100.FindInternedVar(lang.NewSymbol("seq")) +if v101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) +} +v102 := v101.Get() +v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v104 := v103.FindInternedVar(lang.NewSymbol("concat")) +if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) +} +v105 := v104.Get() +v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v107 := v106.FindInternedVar(lang.NewSymbol("list")) +if v107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) +} +v108 := v107.Get() +v109 := lang.Apply(v108, []any{lang.NewSymbol("glojure.core/when")}) +v110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v111 := v110.FindInternedVar(lang.NewSymbol("list")) +if v111.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v111))) +} +v112 := v111.Get() +v113 := lang.Apply(v112, []any{lang.NewSymbol("temp__0__auto__")}) +v114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v115 := v114.FindInternedVar(lang.NewSymbol("list")) +if v115.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v115))) +} +v116 := v115.Get() +v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v118 := v117.FindInternedVar(lang.NewSymbol("seq")) +if v118.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) +} +v119 := v118.Get() +v120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v121 := v120.FindInternedVar(lang.NewSymbol("concat")) +if v121.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v121))) +} +v122 := v121.Get() +v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v124 := v123.FindInternedVar(lang.NewSymbol("list")) +if v124.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) +} +v125 := v124.Get() +v126 := lang.Apply(v125, []any{lang.NewSymbol("glojure.core/let")}) +v127 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v128 := v127.FindInternedVar(lang.NewSymbol("list")) +if v128.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v128))) +} +v129 := v128.Get() +v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v131 := v130.FindInternedVar(lang.NewSymbol("apply")) +if v131.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) +} +v132 := v131.Get() +v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v134 := v133.FindInternedVar(lang.NewSymbol("vector")) +if v134.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) +} +v135 := v134.Get() +v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v137 := v136.FindInternedVar(lang.NewSymbol("seq")) +if v137.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) +} +v138 := v137.Get() +v139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v140 := v139.FindInternedVar(lang.NewSymbol("concat")) +if v140.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v140))) +} +v141 := v140.Get() +v142 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v143 := v142.FindInternedVar(lang.NewSymbol("list")) +if v143.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v143))) +} +v144 := v143.Get() +v145 := lang.Apply(v144, []any{v55}) +v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v147 := v146.FindInternedVar(lang.NewSymbol("list")) +if v147.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) +} +v148 := v147.Get() +v149 := lang.Apply(v148, []any{lang.NewSymbol("temp__0__auto__")}) +v150 := lang.Apply(v141, []any{v145, v149}) +v151 := lang.Apply(v138, []any{v150}) +v152 := lang.Apply(v132, []any{v135, v151}) +v153 := lang.Apply(v129, []any{v152}) +v154 := lang.Apply(v122, []any{v126, v153, v6}) +v155 := lang.Apply(v119, []any{v154}) +v156 := lang.Apply(v116, []any{v155}) +v157 := lang.Apply(v105, []any{v109, v113, v156}) +v158 := lang.Apply(v102, []any{v157}) +v159 := lang.Apply(v99, []any{v158}) +v160 := lang.Apply(v65, []any{v69, v96, v159}) +v161 := lang.Apply(v62, []any{v160}) +return v161 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// completing +{ +v0 := lang.NewSymbol("completing").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("cf"))), lang.NewKeyword("doc"), "Takes a reducing function f of 2 args and returns a fn suitable for\n transduce by adding an arity-1 signature that calls cf (default -\n identity) on the result argument.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6936), lang.NewKeyword("end-line"), int(6936))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("completing")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("identity")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v6, []any{v3, v9}) +return v10 + case 2: +v3 := args[0] +v4 := args[1] +var v5 lang.FnFunc +v5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v6 := lang.Apply(v3, nil) +return v6 + case 1: +v6 := args[0] +v7 := lang.Apply(v4, []any{v6}) +return v7 + case 2: +v6 := args[0] +v7 := args[1] +v8 := lang.Apply(v3, []any{v6, v7}) +return v8 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6943), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(6946), lang.NewKeyword("end-column"), int(23)) +v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// resolve +{ +v0 := lang.NewSymbol("resolve").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym")), lang.NewVector(lang.NewSymbol("env"), lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "same as (ns-resolve *ns* symbol) or (ns-resolve *ns* &env symbol)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4371), lang.NewKeyword("end-line"), int(4371))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("ns-resolve")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("*ns*")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v6, []any{v9, v3}) +return v10 + case 2: +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("ns-resolve")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("*ns*")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v7, []any{v10, v3, v4}) +return v11 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// set-agent-send-off-executor! +{ +v0 := lang.NewSymbol("set-agent-send-off-executor!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("executor"))), lang.NewKeyword("doc"), "Sets the ExecutorService to be used by send-off", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(34), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2093), lang.NewKeyword("end-line"), int(2093))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +return nil +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// nil? +{ +v1 := reflect.TypeOf(false) +var v2 lang.FnFunc +{ // function nil?__inliner +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("list")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Identical"), v4, nil}) +return v8 +}) +v3 := v2 +_ = v3 +} +v0 := lang.NewSymbol("nil?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v2, lang.NewKeyword("doc"), "Returns true if x is nil, false otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(435), lang.NewKeyword("end-line"), int(435))).(*lang.Symbol) +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +v6 := lang.Apply(lang1.IsNil, []any{v5}) +return v6 +}) +v5 := reflect.TypeOf(false) +v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v5)).(lang.FnFunc) +v3 := ns.InternWithValue(v0, v4, true) +if v0.Meta() != nil { + v3.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// *loading-verbosely* +{ +v0 := lang.NewSymbol("*loading-verbosely*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5870), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(5873), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, false, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// vector? +{ +v0 := lang.NewSymbol("vector?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x implements IPersistentVector", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(174), lang.NewKeyword("end-line"), int(178))).(*lang.Symbol) +var v2 lang.FnFunc +{ // function vector? +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{lang1.IPersistentVector, v4}) +return v8 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(178), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(178), lang.NewKeyword("end-column"), int(106))).(lang.FnFunc) +v3 := v2 +_ = v3 +} +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// doto +{ +v0 := lang.NewSymbol("doto").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "Evaluates x then calls all of the methods and functions with the\n value of x supplied at the front of the given arguments. The forms\n are evaluated in order. Returns x.\n\n (doto (new java.util.HashMap) (.put \"a\" 1) (.put \"b\" 2))", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3853), lang.NewKeyword("end-line"), int(3853))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("gensym")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, nil) +var v7 any = v11 +_ = v7 +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("seq")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("concat")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{lang.NewSymbol("glojure.core/let")}) +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("apply")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("vector")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("seq")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("concat")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("list")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.Apply(v40, []any{v7}) +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("list")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +} +v44 := v43.Get() +v45 := lang.Apply(v44, []any{v5}) +v46 := lang.Apply(v37, []any{v41, v45}) +v47 := lang.Apply(v34, []any{v46}) +v48 := lang.Apply(v28, []any{v31, v47}) +v49 := lang.Apply(v25, []any{v48}) +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("map")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +} +v52 := v51.Get() +var v53 lang.FnFunc +v53 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v54 := args[0] +v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v56 := v55.FindInternedVar(lang.NewSymbol("with-meta")) +if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) +} +v57 := v56.Get() +var v58 any +v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v60 := v59.FindInternedVar(lang.NewSymbol("seq?")) +if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) +} +v61 := v60.Get() +v62 := lang.Apply(v61, []any{v54}) +if lang.IsTruthy(v62) { +v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v64 := v63.FindInternedVar(lang.NewSymbol("seq")) +if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) +} +v65 := v64.Get() +v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v67 := v66.FindInternedVar(lang.NewSymbol("concat")) +if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) +} +v68 := v67.Get() +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("list")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +} +v71 := v70.Get() +v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v73 := v72.FindInternedVar(lang.NewSymbol("first")) +if v73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) +} +v74 := v73.Get() +v75 := lang.Apply(v74, []any{v54}) +v76 := lang.Apply(v71, []any{v75}) +v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v78 := v77.FindInternedVar(lang.NewSymbol("list")) +if v78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) +} +v79 := v78.Get() +v80 := lang.Apply(v79, []any{v7}) +v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v82 := v81.FindInternedVar(lang.NewSymbol("next")) +if v82.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) +} +v83 := v82.Get() +v84 := lang.Apply(v83, []any{v54}) +v85 := lang.Apply(v68, []any{v76, v80, v84}) +v86 := lang.Apply(v65, []any{v85}) +v58 = v86 +} else { +v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v88 := v87.FindInternedVar(lang.NewSymbol("seq")) +if v88.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) +} +v89 := v88.Get() +v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v91 := v90.FindInternedVar(lang.NewSymbol("concat")) +if v91.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) +} +v92 := v91.Get() +v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v94 := v93.FindInternedVar(lang.NewSymbol("list")) +if v94.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) +} +v95 := v94.Get() +v96 := lang.Apply(v95, []any{v54}) +v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v98 := v97.FindInternedVar(lang.NewSymbol("list")) +if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) +} +v99 := v98.Get() +v100 := lang.Apply(v99, []any{v7}) +v101 := lang.Apply(v92, []any{v96, v100}) +v102 := lang.Apply(v89, []any{v101}) +v58 = v102 +} +v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v104 := v103.FindInternedVar(lang.NewSymbol("meta")) +if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) +} +v105 := v104.Get() +v106 := lang.Apply(v105, []any{v54}) +v107 := lang.Apply(v57, []any{v58, v106}) +return v107 +}) +v54 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3863), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(3868), lang.NewKeyword("end-column"), int(30)) +v55, err := lang.WithMeta(v53, v54.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v56 := lang.Apply(v52, []any{v55, v6}) +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("list")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +} +v59 := v58.Get() +v60 := lang.Apply(v59, []any{v7}) +v61 := lang.Apply(v18, []any{v22, v49, v56, v60}) +v62 := lang.Apply(v15, []any{v61}) +return v62 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// *loaded-libs* +{ +v0 := lang.NewSymbol("*loaded-libs*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5860), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(5863), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, nil, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// intern +{ +v0 := lang.NewSymbol("intern").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name"), lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Finds or creates a var named by the symbol name in the namespace\n ns (which can be a symbol or a namespace), setting its root binding\n to val if supplied. The namespace must exist. The var will adopt any\n metadata from the name symbol. Returns the var.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6354), lang.NewKeyword("end-line"), int(6354))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v3 := args[0] +v4 := args[1] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("the-ns")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v3}) +v10 := lang.Apply(nil, []any{v9, v4}) +var v5 any = v10 +_ = v5 +var v12 any +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("meta")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v4}) +if lang.IsTruthy(v16) { +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("meta")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v4}) +v21, _ := lang.FieldOrMethod(v5, "setMeta") +if reflect.TypeOf(v21).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMeta is not a function"))) +} +v22 := lang.Apply(v21, []any{v20}) +v12 = v22 +} else { +v12 = nil +} +_ = v12 +return v5 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("the-ns")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v3}) +v11 := lang.Apply(nil, []any{v10, v4, v5}) +var v6 any = v11 +_ = v6 +var v13 any +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("meta")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v4}) +if lang.IsTruthy(v17) { +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("meta")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, []any{v4}) +v22, _ := lang.FieldOrMethod(v6, "setMeta") +if reflect.TypeOf(v22).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMeta is not a function"))) +} +v23 := lang.Apply(v22, []any{v21}) +v13 = v23 +} else { +v13 = nil +} +_ = v13 +return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// prep-ints +{ +v0 := lang.NewSymbol("prep-ints").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tests"), lang.NewSymbol("thens"))), lang.NewKeyword("doc"), "Takes a sequence of int-sized test constants and a corresponding sequence of\n then expressions. Returns a tuple of [shift mask case-map switch-type] where\n case-map is a map of int case values to [test then] tuples, and switch-type\n is either :sparse or :compact.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6674), lang.NewKeyword("end-line"), int(6674), lang.NewKeyword("private"), true)).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("fits-table?")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v3}) +if lang.IsTruthy(v9) { +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("case-map")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("int")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("int")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v12, []any{v15, v18, v3, v4}) +v20 := lang.NewVector(int64(0), int64(0), v19, lang.NewKeyword("compact")) +v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6682), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(6682), lang.NewKeyword("end-column"), int(49)) +v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v5 = v22 +} else { +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("maybe-min-hash")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("map")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("int")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v30, []any{v33, v3}) +v35 := lang.Apply(v27, []any{v34}) +var v24 any = v35 +_ = v24 +var v37 any +if lang.IsTruthy(v24) { +v37 = v24 +} else { +v38 := lang.NewVector(int64(0), int64(0)) +v39 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6683), lang.NewKeyword("column"), int(61), lang.NewKeyword("end-line"), int(6683), lang.NewKeyword("end-column"), int(65)) +v40, err := lang.WithMeta(v38, v39.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v37 = v40 +} +var v23 any = v37 +_ = v23 +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("nth")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.Apply(v27, []any{v23, int64(0), nil}) +var v24 any = v28 +_ = v24 +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("nth")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.Apply(v32, []any{v23, int64(1), nil}) +var v29 any = v33 +_ = v29 +var v35 any +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("zero?")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v29}) +if lang.IsTruthy(v39) { +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("case-map")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("int")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +} +v45 := v44.Get() +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("int")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +} +v48 := v47.Get() +v49 := lang.Apply(v42, []any{v45, v48, v3, v4}) +v50 := lang.NewVector(int64(0), int64(0), v49, lang.NewKeyword("sparse")) +v51 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6686), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(6686), lang.NewKeyword("end-column"), int(52)) +v52, err := lang.WithMeta(v50, v51.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v35 = v52 +} else { +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("case-map")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +} +v55 := v54.Get() +var v56 lang.FnFunc +v56 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v57 := args[0] +v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v59 := v58.FindInternedVar(lang.NewSymbol("shift-mask")) +if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) +} +v60 := v59.Get() +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("int")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +} +v63 := v62.Get() +v64 := lang.Apply(v63, []any{v57}) +v65 := lang.Apply(v60, []any{v24, v29, v64}) +return v65 +}) +v57 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6688), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(6688), lang.NewKeyword("end-column"), int(62)) +v58, err := lang.WithMeta(v56, v57.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v60 := v59.FindInternedVar(lang.NewSymbol("int")) +if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) +} +v61 := v60.Get() +v62 := lang.Apply(v55, []any{v58, v61, v3, v4}) +v63 := lang.NewVector(v24, v29, v62, lang.NewKeyword("compact")) +v64 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6688), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(6688), lang.NewKeyword("end-column"), int(89)) +v65, err := lang.WithMeta(v63, v64.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v35 = v65 +} +v5 = v35 +} +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// persistent! +{ +v0 := lang.NewSymbol("persistent!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a new, persistent version of the transient collection, in\n constant time. The transient collection cannot be used after this\n call, any such use will throw an exception.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3350), lang.NewKeyword("end-line"), int(3350))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, ok := lang.FieldOrMethod(v3, "Persistent") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "Persistent"))) +} +var v5 any +switch reflect.TypeOf(v4).Kind() { +case reflect.Func: + v5 = lang.Apply(v4, nil) +default: + v5 = v4 +} +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// print-simple +{ +v0 := lang.NewSymbol("print-simple").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(81), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(81), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("print-meta")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3, v4}) +_ = v8 +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("str")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v3}) +v13 := lang.Apply(lang1.WriteWriter, []any{v4, v12}) +return v13 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// bound-fn +{ +v0 := lang.NewSymbol("bound-fn").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("fntail"))), lang.NewKeyword("doc"), "Returns a function defined by the given fntail, which will install the\n same bindings in effect as in the thread at the time bound-fn was called.\n This may be used to define a helper function which runs on a different\n thread, but needs the same bindings in place.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(2004), lang.NewKeyword("end-line"), int(2004))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("seq")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("concat")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("list")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{lang.NewSymbol("glojure.core/bound-fn*")}) +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("list")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("seq")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("concat")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("list")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.Apply(v27, []any{lang.NewSymbol("glojure.core/fn")}) +v29 := lang.Apply(v24, []any{v28, v5}) +v30 := lang.Apply(v21, []any{v29}) +v31 := lang.Apply(v18, []any{v30}) +v32 := lang.Apply(v11, []any{v15, v31}) +v33 := lang.Apply(v8, []any{v32}) +return v33 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// volatile! +{ +v1 := reflect.TypeOf((*lang1.Volatile)(nil)).Elem() +v0 := lang.NewSymbol("volatile!").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Creates and returns a Volatile with an initial value of val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2517), lang.NewKeyword("end-line"), int(2517))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := lang.Apply(glojure.lang.Volatile24., []any{v4}) +return v5 +}) +v4 := reflect.TypeOf((*lang1.Volatile)(nil)).Elem() +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// if-let +{ +v0 := lang.NewSymbol("if-let").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("then")), lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("then"), lang.NewSymbol("else"), lang.NewSymbol("&"), lang.NewSymbol("oldform"))), lang.NewKeyword("doc"), "bindings => binding-form test\n\n If test is true, evaluates then with binding-form bound to the value of \n test, if not, yields else", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1839), lang.NewKeyword("end-line"), int(1839))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 4: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("seq")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("concat")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("list")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/if-let")}) +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("list")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v5}) +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("list")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v6}) +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("list")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.Apply(v27, []any{nil}) +v29 := lang.Apply(v12, []any{v16, v20, v24, v28}) +v30 := lang.Apply(v9, []any{v29}) +return v30 + default: + if len(args) < 5 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := args[4] +v8 := lang.NewList(args[5:]...) +var v9 any +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("vector?")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{v5}) +if lang.IsTruthy(v13) { +v9 = nil +} else { +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("str")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("first")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v3}) +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("*ns*")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("meta")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v3}) +v28 := lang.Apply(lang.NewKeyword("line"), []any{v27}) +v29 := lang.Apply(v16, []any{v20, " requires ", "a vector for its binding", " in ", v23, ":", v28}) +v30 := lang.Apply(lang1.NewIllegalArgumentError, []any{v29}) +panic(v30) +} +_ = v9 +var v31 any +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("nil?")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v8}) +if lang.IsTruthy(v35) { +v31 = nil +} else { +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("str")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("first")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +} +v41 := v40.Get() +v42 := lang.Apply(v41, []any{v3}) +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("*ns*")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +} +v45 := v44.Get() +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("meta")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +} +v48 := v47.Get() +v49 := lang.Apply(v48, []any{v3}) +v50 := lang.Apply(lang.NewKeyword("line"), []any{v49}) +v51 := lang.Apply(v38, []any{v42, " requires ", "1 or 2 forms after binding vector", " in ", v45, ":", v50}) +v52 := lang.Apply(lang1.NewIllegalArgumentError, []any{v51}) +panic(v52) +} +_ = v31 +var v53 any +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("=")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +} +v56 := v55.Get() +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("count")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +} +v59 := v58.Get() +v60 := lang.Apply(v59, []any{v5}) +v61 := lang.Apply(v56, []any{int64(2), v60}) +if lang.IsTruthy(v61) { +v53 = nil +} else { +v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v63 := v62.FindInternedVar(lang.NewSymbol("str")) +if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +} +v64 := v63.Get() +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("first")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +} +v67 := v66.Get() +v68 := lang.Apply(v67, []any{v3}) +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("*ns*")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +} +v71 := v70.Get() +v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v73 := v72.FindInternedVar(lang.NewSymbol("meta")) +if v73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) +} +v74 := v73.Get() +v75 := lang.Apply(v74, []any{v3}) +v76 := lang.Apply(lang.NewKeyword("line"), []any{v75}) +v77 := lang.Apply(v64, []any{v68, " requires ", "exactly 2 forms in binding vector", " in ", v71, ":", v76}) +v78 := lang.Apply(lang1.NewIllegalArgumentError, []any{v77}) +panic(v78) +} +_ = v53 +_ = nil +v80 := lang.Apply(v5, []any{int64(0)}) +var v79 any = v80 +_ = v79 +v82 := lang.Apply(v5, []any{int64(1)}) +var v81 any = v82 +_ = v81 +v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v85 := v84.FindInternedVar(lang.NewSymbol("seq")) +if v85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) +} +v86 := v85.Get() +v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v88 := v87.FindInternedVar(lang.NewSymbol("concat")) +if v88.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) +} +v89 := v88.Get() +v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v91 := v90.FindInternedVar(lang.NewSymbol("list")) +if v91.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) +} +v92 := v91.Get() +v93 := lang.Apply(v92, []any{lang.NewSymbol("glojure.core/let")}) +v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v95 := v94.FindInternedVar(lang.NewSymbol("list")) +if v95.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) +} +v96 := v95.Get() +v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v98 := v97.FindInternedVar(lang.NewSymbol("apply")) +if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) +} +v99 := v98.Get() +v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v101 := v100.FindInternedVar(lang.NewSymbol("vector")) +if v101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) +} +v102 := v101.Get() +v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v104 := v103.FindInternedVar(lang.NewSymbol("seq")) +if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) +} +v105 := v104.Get() +v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v107 := v106.FindInternedVar(lang.NewSymbol("concat")) +if v107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) +} +v108 := v107.Get() +v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v110 := v109.FindInternedVar(lang.NewSymbol("list")) +if v110.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) +} +v111 := v110.Get() +v112 := lang.Apply(v111, []any{lang.NewSymbol("temp__0__auto__")}) +v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v114 := v113.FindInternedVar(lang.NewSymbol("list")) +if v114.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) +} +v115 := v114.Get() +v116 := lang.Apply(v115, []any{v81}) +v117 := lang.Apply(v108, []any{v112, v116}) +v118 := lang.Apply(v105, []any{v117}) +v119 := lang.Apply(v99, []any{v102, v118}) +v120 := lang.Apply(v96, []any{v119}) +v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v122 := v121.FindInternedVar(lang.NewSymbol("list")) +if v122.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) +} +v123 := v122.Get() +v124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v125 := v124.FindInternedVar(lang.NewSymbol("seq")) +if v125.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v125))) +} +v126 := v125.Get() +v127 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v128 := v127.FindInternedVar(lang.NewSymbol("concat")) +if v128.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v128))) +} +v129 := v128.Get() +v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v131 := v130.FindInternedVar(lang.NewSymbol("list")) +if v131.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) +} +v132 := v131.Get() +v133 := lang.Apply(v132, []any{lang.NewSymbol("if")}) +v134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v135 := v134.FindInternedVar(lang.NewSymbol("list")) +if v135.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v135))) +} +v136 := v135.Get() +v137 := lang.Apply(v136, []any{lang.NewSymbol("temp__0__auto__")}) +v138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v139 := v138.FindInternedVar(lang.NewSymbol("list")) +if v139.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v139))) +} +v140 := v139.Get() +v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v142 := v141.FindInternedVar(lang.NewSymbol("seq")) +if v142.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) +} +v143 := v142.Get() +v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v145 := v144.FindInternedVar(lang.NewSymbol("concat")) +if v145.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) +} +v146 := v145.Get() +v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v148 := v147.FindInternedVar(lang.NewSymbol("list")) +if v148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) +} +v149 := v148.Get() +v150 := lang.Apply(v149, []any{lang.NewSymbol("glojure.core/let")}) +v151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v152 := v151.FindInternedVar(lang.NewSymbol("list")) +if v152.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v152))) +} +v153 := v152.Get() +v154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v155 := v154.FindInternedVar(lang.NewSymbol("apply")) +if v155.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v155))) +} +v156 := v155.Get() +v157 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v158 := v157.FindInternedVar(lang.NewSymbol("vector")) +if v158.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v158))) +} +v159 := v158.Get() +v160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v161 := v160.FindInternedVar(lang.NewSymbol("seq")) +if v161.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v161))) +} +v162 := v161.Get() +v163 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v164 := v163.FindInternedVar(lang.NewSymbol("concat")) +if v164.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v164))) +} +v165 := v164.Get() +v166 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v167 := v166.FindInternedVar(lang.NewSymbol("list")) +if v167.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v167))) +} +v168 := v167.Get() +v169 := lang.Apply(v168, []any{v79}) +v170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v171 := v170.FindInternedVar(lang.NewSymbol("list")) +if v171.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v171))) +} +v172 := v171.Get() +v173 := lang.Apply(v172, []any{lang.NewSymbol("temp__0__auto__")}) +v174 := lang.Apply(v165, []any{v169, v173}) +v175 := lang.Apply(v162, []any{v174}) +v176 := lang.Apply(v156, []any{v159, v175}) +v177 := lang.Apply(v153, []any{v176}) +v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v179 := v178.FindInternedVar(lang.NewSymbol("list")) +if v179.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) +} +v180 := v179.Get() +v181 := lang.Apply(v180, []any{v6}) +v182 := lang.Apply(v146, []any{v150, v177, v181}) +v183 := lang.Apply(v143, []any{v182}) +v184 := lang.Apply(v140, []any{v183}) +v185 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v186 := v185.FindInternedVar(lang.NewSymbol("list")) +if v186.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v186))) +} +v187 := v186.Get() +v188 := lang.Apply(v187, []any{v7}) +v189 := lang.Apply(v129, []any{v133, v137, v184, v188}) +v190 := lang.Apply(v126, []any{v189}) +v191 := lang.Apply(v123, []any{v190}) +v192 := lang.Apply(v89, []any{v93, v120, v191}) +v193 := lang.Apply(v86, []any{v192}) +return v193 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// *repl* +{ +v0 := lang.NewSymbol("*repl*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6331), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(6334), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, false, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// send-via +{ +v0 := lang.NewSymbol("send-via").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("executor"), lang.NewSymbol("a"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Dispatch an action to an agent. Returns the agent immediately.\n Subsequently, in a thread supplied by executor, the state of the agent\n will be set to the value of:\n\n (apply action-fn state-of-agent args)", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2099), lang.NewKeyword("end-line"), int(2099))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("push-thread-bindings")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("hash-map")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*agent*")) +v15 := lang.Apply(v13, []any{v14, v4}) +v16 := lang.Apply(v10, []any{v15}) +_ = v16 +var v17 any +func() { +defer func() { +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, nil) +}() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("binding-conveyor-fn")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v5}) +v17 = v25 +}() +v7, _ := lang.FieldOrMethod(v4, "dispatch") +if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("dispatch is not a function"))) +} +v8 := lang.Apply(v7, []any{v17, v6, v3}) +return v8 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// ->> +{ +v0 := lang.NewSymbol("->>").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "Threads the expr through the forms. Inserts x as the\n last item in the first form, making a list of it if it is not a\n list already. If there are more forms, inserts the first form as the\n last item in second form, etc.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1691), lang.NewKeyword("end-line"), int(1691))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +var v7 any = v7 +_ = v7 +var v8 any = v8 +_ = v8 +var v9 any +for { +var v10 any +if lang.IsTruthy(v8) { +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("first")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v8}) +var v11 any = v15 +_ = v11 +var v17 any +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("seq?")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, []any{v11}) +if lang.IsTruthy(v21) { +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("with-meta")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("seq")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("concat")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("first")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.Apply(v36, []any{v11}) +v38 := lang.Apply(v33, []any{v37}) +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("next")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +} +v41 := v40.Get() +v42 := lang.Apply(v41, []any{v11}) +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("list")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +} +v45 := v44.Get() +v46 := lang.Apply(v45, []any{v7}) +v47 := lang.Apply(v30, []any{v38, v42, v46}) +v48 := lang.Apply(v27, []any{v47}) +v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v50 := v49.FindInternedVar(lang.NewSymbol("meta")) +if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) +} +v51 := v50.Get() +v52 := lang.Apply(v51, []any{v11}) +v53 := lang.Apply(v24, []any{v48, v52}) +v17 = v53 +} else { +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("list")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +} +v56 := v55.Get() +v57 := lang.Apply(v56, []any{v11, v7}) +v17 = v57 +} +var v16 any = v17 +_ = v16 +var v59 any = v16 +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("next")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +} +v63 := v62.Get() +v64 := lang.Apply(v63, []any{v8}) +var v60 any = v64 +v7 = v59 +v8 = v60 +continue +} else { +v10 = v7 +} +v9 = v10 + break +} +return v9 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// unchecked-char +{ +var v1 lang.FnFunc +{ // function unchecked-char__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/UncheckedCharCast")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v3}) +v35 := lang.Apply(v26, []any{v30, v34}) +v36 := lang.Apply(v23, []any{v35}) +v37 := lang.Apply(v20, []any{v36}) +v38 := lang.Apply(v9, []any{v13, v17, v37}) +v39 := lang.Apply(v6, []any{v38}) +return v39 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("unchecked-char").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to char. Subject to rounding or truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3529), lang.NewKeyword("end-line"), int(3529))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5, _ := lang.FieldOrMethod(runtime3.RT, "UncheckedCharCast") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedCharCast is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// bit-or +{ +var v1 lang.FnFunc +v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v2 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +if lang.IsTruthy(v7) { +v4 = closed4 +} else { +v4 = v3 +} +var v3 any = v4 +_ = v3 +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("seq")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("concat")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("seq")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("concat")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v2}) +v40 := lang.Apply(v31, []any{v35, v39}) +v41 := lang.Apply(v28, []any{v40}) +v42 := lang.Apply(v25, []any{v41}) +v43 := lang.Apply(v14, []any{v18, v22, v42}) +v44 := lang.Apply(v11, []any{v43}) +return v44 + case 2: +v2 := args[0] +v3 := args[1] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +if lang.IsTruthy(v8) { +v5 = closed4 +} else { +v5 = v4 +} +var v4 any = v5 +_ = v4 +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("seq")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("concat")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("list")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("list")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("list")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("seq")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("concat")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("list")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v4}) +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("list")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v2}) +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("list")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v3}) +v45 := lang.Apply(v32, []any{v36, v40, v44}) +v46 := lang.Apply(v29, []any{v45}) +v47 := lang.Apply(v26, []any{v46}) +v48 := lang.Apply(v15, []any{v19, v23, v47}) +v49 := lang.Apply(v12, []any{v48}) +return v49 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v2 := args[0] +v3 := args[1] +v4 := lang.NewList(args[2:]...) +var v6 any +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +if lang.IsTruthy(v9) { +v6 = closed4 +} else { +v6 = v5 +} +var v5 any = v6 +_ = v5 +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +var v14 lang.FnFunc +v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v15 := args[0] +v16 := args[1] +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v5}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v15}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v16}) +v52 := lang.Apply(v39, []any{v43, v47, v51}) +v53 := lang.Apply(v36, []any{v52}) +v54 := lang.Apply(v33, []any{v53}) +v55 := lang.Apply(v22, []any{v26, v30, v54}) +v56 := lang.Apply(v19, []any{v55}) +return v56 +}) +v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) +v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v5}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v2}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v3}) +v52 := lang.Apply(v39, []any{v43, v47, v51}) +v53 := lang.Apply(v36, []any{v52}) +v54 := lang.Apply(v33, []any{v53}) +v55 := lang.Apply(v22, []any{v26, v30, v54}) +v56 := lang.Apply(v19, []any{v55}) +v57 := lang.Apply(v13, []any{v16, v56, v4}) +return v57 + } +}) +v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) +} +v5 := lang.Apply(v4, []any{v3, int64(1)}) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v0 := lang.NewSymbol("bit-or").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Bitwise or", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1307), lang.NewKeyword("end-line"), int(1307))).(*lang.Symbol) +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v5 := args[0] +v6 := args[1] +v7, _ := lang.FieldOrMethod(lang1.Numbers, "or") +if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("or is not a function"))) +} +v8 := lang.Apply(v7, []any{v5, v6}) +return v8 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +v6 := args[1] +v7 := lang.NewList(args[2:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("bit-or")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("bit-or")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v5, v6}) +v18 := lang.Apply(v10, []any{v13, v17, v7}) +return v18 + } +}) +v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v3 := ns.InternWithValue(v0, v4, true) +if v0.Meta() != nil { + v3.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// rational? +{ +v0 := lang.NewSymbol("rational?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is a rational number", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3613), lang.NewKeyword("end-line"), int(3613))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("integer?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +var v4 any = v8 +_ = v4 +var v10 any +if lang.IsTruthy(v4) { +v10 = v4 +} else { +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("ratio?")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v3}) +var v11 any = v15 +_ = v11 +var v17 any +if lang.IsTruthy(v11) { +v17 = v11 +} else { +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("decimal?")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, []any{v3}) +v17 = v21 +} +v10 = v17 +} +return v10 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// bigint +{ +v1 := reflect.TypeOf((*lang1.BigInt)(nil)) +v0 := lang.NewSymbol("bigint").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Coerce to BigInt", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3620), lang.NewKeyword("end-line"), int(3620))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{lang1.*BigInt, v4}) +if lang.IsTruthy(v9) { +v5 = v4 +} else { +var v10 any +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("instance?")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{big9.*Int, v4}) +if lang.IsTruthy(v14) { +v15 := lang.Apply(lang1.NewBigIntFromGoBigInt, []any{v4}) +v10 = v15 +} else { +var v16 any +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("decimal?")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v4}) +if lang.IsTruthy(v20) { +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("bigint")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24, ok := lang.FieldOrMethod(v4, "toBigInteger") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "toBigInteger"))) +} +var v25 any +switch reflect.TypeOf(v24).Kind() { +case reflect.Func: + v25 = lang.Apply(v24, nil) +default: + v25 = v24 +} +v26 := lang.Apply(v23, []any{v25}) +v16 = v26 +} else { +var v27 any +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("float?")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{v4}) +if lang.IsTruthy(v31) { +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("bigint")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("double")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v37, []any{v4}) +v39 := lang.Apply(lang1.NewBigDecimalFromFloat64, []any{v38}) +v40 := lang.Apply(v34, []any{v39}) +v27 = v40 +} else { +var v41 any +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("ratio?")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +} +v44 := v43.Get() +v45 := lang.Apply(v44, []any{v4}) +if lang.IsTruthy(v45) { +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("bigint")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +} +v48 := v47.Get() +v49, ok := lang.FieldOrMethod(v4, "bigIntegerValue") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "bigIntegerValue"))) +} +var v50 any +switch reflect.TypeOf(v49).Kind() { +case reflect.Func: + v50 = lang.Apply(v49, nil) +default: + v50 = v49 +} +v51 := lang.Apply(v48, []any{v50}) +v41 = v51 +} else { +var v52 any +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("number?")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +} +v55 := v54.Get() +v56 := lang.Apply(v55, []any{v4}) +if lang.IsTruthy(v56) { +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("long")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +} +v59 := v58.Get() +v60 := lang.Apply(v59, []any{v4}) +v61 := lang.Apply(lang1.NewBigIntFromInt64, []any{v60}) +v52 = v61 +} else { +var v62 any +if lang.IsTruthy(lang.NewKeyword("else")) { +v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v64 := v63.FindInternedVar(lang.NewSymbol("bigint")) +if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) +} +v65 := v64.Get() +v66 := lang.Apply(BigInteger12., []any{v4}) +v67 := lang.Apply(v65, []any{v66}) +v62 = v67 +} else { +v62 = nil +} +v52 = v62 +} +v41 = v52 +} +v27 = v41 +} +v16 = v27 +} +v10 = v16 +} +v5 = v10 +} +return v5 +}) +v4 := reflect.TypeOf((*lang1.BigInt)(nil)) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// bit-and-not +{ +var v1 lang.FnFunc +v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v2 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +if lang.IsTruthy(v7) { +v4 = closed5 +} else { +v4 = v3 +} +var v3 any = v4 +_ = v3 +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("seq")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("concat")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("seq")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("concat")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v2}) +v40 := lang.Apply(v31, []any{v35, v39}) +v41 := lang.Apply(v28, []any{v40}) +v42 := lang.Apply(v25, []any{v41}) +v43 := lang.Apply(v14, []any{v18, v22, v42}) +v44 := lang.Apply(v11, []any{v43}) +return v44 + case 2: +v2 := args[0] +v3 := args[1] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +if lang.IsTruthy(v8) { +v5 = closed5 +} else { +v5 = v4 +} +var v4 any = v5 +_ = v4 +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("seq")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("concat")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("list")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("list")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("list")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("seq")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("concat")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("list")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v4}) +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("list")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v2}) +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("list")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v3}) +v45 := lang.Apply(v32, []any{v36, v40, v44}) +v46 := lang.Apply(v29, []any{v45}) +v47 := lang.Apply(v26, []any{v46}) +v48 := lang.Apply(v15, []any{v19, v23, v47}) +v49 := lang.Apply(v12, []any{v48}) +return v49 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v2 := args[0] +v3 := args[1] +v4 := lang.NewList(args[2:]...) +var v6 any +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +if lang.IsTruthy(v9) { +v6 = closed5 +} else { +v6 = v5 +} +var v5 any = v6 +_ = v5 +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +var v14 lang.FnFunc +v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v15 := args[0] +v16 := args[1] +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v5}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v15}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v16}) +v52 := lang.Apply(v39, []any{v43, v47, v51}) +v53 := lang.Apply(v36, []any{v52}) +v54 := lang.Apply(v33, []any{v53}) +v55 := lang.Apply(v22, []any{v26, v30, v54}) +v56 := lang.Apply(v19, []any{v55}) +return v56 +}) +v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) +v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v5}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v2}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v3}) +v52 := lang.Apply(v39, []any{v43, v47, v51}) +v53 := lang.Apply(v36, []any{v52}) +v54 := lang.Apply(v33, []any{v53}) +v55 := lang.Apply(v22, []any{v26, v30, v54}) +v56 := lang.Apply(v19, []any{v55}) +v57 := lang.Apply(v13, []any{v16, v56, v4}) +return v57 + } +}) +v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) +} +v5 := lang.Apply(v4, []any{v3, int64(1)}) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v0 := lang.NewSymbol("bit-and-not").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Bitwise and with complement", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1325), lang.NewKeyword("end-line"), int(1325))).(*lang.Symbol) +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v5 := args[0] +v6 := args[1] +v7, _ := lang.FieldOrMethod(lang1.Numbers, "andNot") +if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("andNot is not a function"))) +} +v8 := lang.Apply(v7, []any{v5, v6}) +return v8 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +v6 := args[1] +v7 := lang.NewList(args[2:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("bit-and-not")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("bit-and-not")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v5, v6}) +v18 := lang.Apply(v10, []any{v13, v17, v7}) +return v18 + } +}) +v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v3 := ns.InternWithValue(v0, v4, true) +if v0.Meta() != nil { + v3.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// refer-glojure +{ +v0 := lang.NewSymbol("refer-glojure").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("filters"))), lang.NewKeyword("doc"), "Same as (refer 'glojure.core )", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5843), lang.NewKeyword("end-line"), int(5843))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("seq")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("concat")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("list")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{lang.NewSymbol("glojure.core/refer")}) +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("list")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("seq")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("concat")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("list")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.Apply(v27, []any{lang.NewSymbol("quote")}) +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("list")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.Apply(v31, []any{lang.NewSymbol("glojure.core")}) +v33 := lang.Apply(v24, []any{v28, v32}) +v34 := lang.Apply(v21, []any{v33}) +v35 := lang.Apply(v18, []any{v34}) +v36 := lang.Apply(v11, []any{v15, v35, v5}) +v37 := lang.Apply(v8, []any{v36}) +return v37 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// unreduced +{ +v0 := lang.NewSymbol("unreduced").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "If x is reduced?, returns (deref x), else returns x", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2847), lang.NewKeyword("end-line"), int(2847))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("reduced?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +if lang.IsTruthy(v8) { +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("deref")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v3}) +v4 = v12 +} else { +v4 = v3 +} +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// str +{ +v1 := reflect.TypeOf("") +v0 := lang.NewSymbol("str").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("ys"))), lang.NewKeyword("doc"), "With no args, returns the empty string. With one arg x, returns\n x.toString(). (str nil) returns the empty string. With more than\n one arg, returns the concatenation of the str values of the args.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(543), lang.NewKeyword("end-line"), int(543))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +return "" + case 1: +v4 := args[0] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("nil?")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v4}) +if lang.IsTruthy(v9) { +v5 = "" +} else { +v10 := lang.Apply(lang1.ToString, []any{v4}) +v5 = v10 +} +return v5 + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := lang.NewList(args[1:]...) +var v6 lang.FnFunc +v6 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v7 := args[0] +v8 := args[1] +recur_loop_74: +var v9 any +if lang.IsTruthy(v8) { +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("str")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("first")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v8}) +v18 := lang.Apply(v13, []any{v17}) +v19, _ := lang.FieldOrMethod(v7, "WriteString") +if reflect.TypeOf(v19).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("WriteString is not a function"))) +} +v20 := lang.Apply(v19, []any{v18}) +_ = v20 +var v10 any = v7 +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("next")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v8}) +var v21 any = v25 +v7 = v10 +v8 = v21 +goto recur_loop_74 +} else { +v26, ok := lang.FieldOrMethod(v7, "String") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "String"))) +} +var v27 any +switch reflect.TypeOf(v26).Kind() { +case reflect.Func: + v27 = lang.Apply(v26, nil) +default: + v27 = v26 +} +v9 = v27 +} +return v9 +}) +v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(554), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(554), lang.NewKeyword("end-column"), int(127)) +v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("cons")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v4, v5}) +v13 := lang.Apply(v8, []any{"unimplemented: new with non-constant class type", v12}) +return v13 + } +}) +v4 := reflect.TypeOf("") +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// shorts +{ +var v1 lang.FnFunc +{ // function shorts +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/shorts")}) +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("list")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v3}) +v26 := lang.Apply(v9, []any{v13, v17, v21, v25}) +v27 := lang.Apply(v6, []any{v26}) +return v27 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("shorts").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Casts to shorts[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5387), lang.NewKeyword("end-line"), int(5387))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "shorts") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("shorts is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// delay +{ +v0 := lang.NewSymbol("delay").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Takes a body of expressions and yields a Delay object that will\n invoke the body only the first time it is forced (with force or deref/@), and\n will cache the result and return it on all subsequent force\n calls. See also - realized?", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(739), lang.NewKeyword("end-line"), int(739))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("list")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("list*")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.NewVector() +v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(746), lang.NewKeyword("column"), int(62), lang.NewKeyword("end-line"), int(746), lang.NewKeyword("end-column"), int(63)) +v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v15 := lang.Apply(v11, []any{lang.NewSymbol("fn*"), v14, v5}) +v16 := lang.Apply(v8, []any{lang.NewSymbol("new"), lang.NewSymbol("glojure.lang.Delay"), v15}) +return v16 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// tagged-literal? +{ +v0 := lang.NewSymbol("tagged-literal?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("value"))), lang.NewKeyword("doc"), "Return true if the value is the data representation of a tagged literal", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7816), lang.NewKeyword("end-line"), int(7816))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{glojure.lang11.TaggedLiteral, v3}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// pop-thread-bindings +{ +v0 := lang.NewSymbol("pop-thread-bindings").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Pop one set of bindings pushed with push-binding before. It is an error to\n pop bindings without pushing before.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1929), lang.NewKeyword("end-line"), int(1929))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.Apply(lang1.PopThreadBindings, nil) +return v3 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// unquote-splicing +{ +v0 := lang.NewSymbol("unquote-splicing").WithMeta(lang.NewMap()).(*lang.Symbol) +v1 := ns.Intern(v0) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// *unchecked-math* +{ +v0 := lang.NewSymbol("*unchecked-math*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.3", lang.NewKeyword("doc"), "While bound to true, compilations of +, -, *, inc, dec and the\n coercions will be done without overflow checks. While bound\n to :warn-on-boxed, same behavior as true, and a warning is emitted\n when compilation uses boxed math. Default: false.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, nil, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// ref-max-history +{ +v0 := lang.NewSymbol("ref-max-history").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref")), lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Gets the max-history of a ref, or sets it and returns the ref", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2471), lang.NewKeyword("end-line"), int(2471))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +v4, ok := lang.FieldOrMethod(v3, "getMaxHistory") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getMaxHistory"))) +} +var v5 any +switch reflect.TypeOf(v4).Kind() { +case reflect.Func: + v5 = lang.Apply(v4, nil) +default: + v5 = v4 +} +return v5 + case 2: +v3 := args[0] +v4 := args[1] +v5, _ := lang.FieldOrMethod(v3, "setMaxHistory") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMaxHistory is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// as-> +{ +v0 := lang.NewSymbol("as->").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "Binds name to expr, evaluates the first form in the lexical context\n of that binding, then binds name to that result, repeating for each\n successive form, returning the result of the last form.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7641), lang.NewKeyword("end-line"), int(7641))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := lang.NewList(args[4:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("seq")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("concat")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("glojure.core/let")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("apply")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("vector")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("seq")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("concat")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("list")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v6}) +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("list")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v5}) +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("interleave")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("repeat")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v6}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("butlast")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v7}) +v52 := lang.Apply(v43, []any{v47, v51}) +v53 := lang.Apply(v32, []any{v36, v40, v52}) +v54 := lang.Apply(v29, []any{v53}) +v55 := lang.Apply(v23, []any{v26, v54}) +v56 := lang.Apply(v20, []any{v55}) +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("list")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +} +v59 := v58.Get() +var v60 any +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("empty?")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +} +v63 := v62.Get() +v64 := lang.Apply(v63, []any{v7}) +if lang.IsTruthy(v64) { +v60 = v6 +} else { +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("last")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +} +v67 := v66.Get() +v68 := lang.Apply(v67, []any{v7}) +v60 = v68 +} +v69 := lang.Apply(v59, []any{v60}) +v70 := lang.Apply(v13, []any{v17, v56, v69}) +v71 := lang.Apply(v10, []any{v70}) +return v71 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// unchecked-float +{ +var v1 lang.FnFunc +{ // function unchecked-float__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/UncheckedFloatCast")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v3}) +v35 := lang.Apply(v26, []any{v30, v34}) +v36 := lang.Apply(v23, []any{v35}) +v37 := lang.Apply(v20, []any{v36}) +v38 := lang.Apply(v9, []any{v13, v17, v37}) +v39 := lang.Apply(v6, []any{v38}) +return v39 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("unchecked-float").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to float. Subject to rounding.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3547), lang.NewKeyword("end-line"), int(3547))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := lang.Apply(lang1.UncheckedFloatCast, []any{v4}) +return v5 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// select-keys +{ +v0 := lang.NewSymbol("select-keys").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("keyseq"))), lang.NewKeyword("doc"), "Returns a map containing only those entries in map whose key is in keys", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1536), lang.NewKeyword("end-line"), int(1536))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v6 := lang.NewMap() +v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1541), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(1541), lang.NewKeyword("end-column"), int(17)) +v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v5 any = v8 +_ = v5 +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("seq")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{v4}) +var v9 any = v13 +_ = v9 +var v14 any +for { +var v15 any +if lang.IsTruthy(v9) { +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("first")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v9}) +v21, _ := lang.FieldOrMethod(runtime3.RT, "Find") +if reflect.TypeOf(v21).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Find is not a function"))) +} +v22 := lang.Apply(v21, []any{v3, v20}) +var v16 any = v22 +_ = v16 +var v25 any +if lang.IsTruthy(v16) { +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("conj")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.Apply(v28, []any{v5, v16}) +v25 = v29 +} else { +v25 = v5 +} +var v24 any = v25 +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("next")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v9}) +var v30 any = v34 +v5 = v24 +v9 = v30 +continue +} else { +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("with-meta")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("meta")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v3}) +v23 := lang.Apply(v18, []any{v5, v22}) +v15 = v23 +} +v14 = v15 + break +} +return v14 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// longs +{ +var v1 lang.FnFunc +{ // function longs +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/longs")}) +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("list")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v3}) +v26 := lang.Apply(v9, []any{v13, v17, v21, v25}) +v27 := lang.Apply(v6, []any{v26}) +return v27 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("longs").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Casts to long[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5407), lang.NewKeyword("end-line"), int(5407))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "longs") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("longs is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// realized? +{ +v0 := lang.NewSymbol("realized?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if a value has been produced for a promise, delay, future or lazy sequence.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7602), lang.NewKeyword("end-line"), int(7602))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, ok := lang.FieldOrMethod(v3, "isRealized") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "isRealized"))) +} +var v5 any +switch reflect.TypeOf(v4).Kind() { +case reflect.Func: + v5 = lang.Apply(v4, nil) +default: + v5 = v4 +} +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// float? +{ +v0 := lang.NewSymbol("float?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is a floating point number", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3605), lang.NewKeyword("end-line"), int(3605))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{lang.Builtins["float64"], v3}) +var v4 any = v8 +_ = v4 +var v10 any +if lang.IsTruthy(v4) { +v10 = v4 +} else { +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("instance?")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{lang.Builtins["float32"], v3}) +v10 = v14 +} +return v10 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// interpose +{ +v0 := lang.NewSymbol("interpose").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sep")), lang.NewVector(lang.NewSymbol("sep"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy seq of the elements of coll separated by sep.\n Returns a stateful transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5230), lang.NewKeyword("end-line"), int(5230))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("volatile!")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{false}) +var v6 any = v10 +_ = v6 +var v12 lang.FnFunc +v12 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v13 := lang.Apply(v5, nil) +return v13 + case 1: +v13 := args[0] +v14 := lang.Apply(v5, []any{v13}) +return v14 + case 2: +v13 := args[0] +v14 := args[1] +var v15 any +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("deref")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v6}) +if lang.IsTruthy(v19) { +v21 := lang.Apply(v5, []any{v13, v3}) +var v20 any = v21 +_ = v20 +var v23 any +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("reduced?")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v20}) +if lang.IsTruthy(v27) { +v23 = v20 +} else { +v28 := lang.Apply(v5, []any{v20, v14}) +v23 = v28 +} +v15 = v23 +} else { +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("vreset!")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.Apply(v22, []any{v6, true}) +_ = v23 +v24 := lang.Apply(v5, []any{v13, v14}) +v15 = v24 +} +return v15 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5238), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(5249), lang.NewKeyword("end-column"), int(35)) +v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v14 +}) +v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5236), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(5249), lang.NewKeyword("end-column"), int(37)) +v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v6 + case 2: +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("drop")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("interleave")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("repeat")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v3}) +v15 := lang.Apply(v10, []any{v14, v4}) +v16 := lang.Apply(v7, []any{int64(1), v15}) +return v16 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// get-validator +{ +v0 := lang.NewSymbol("get-validator").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("iref"))), lang.NewKeyword("doc"), "Gets the validator-fn for a var/ref/agent/atom.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2392), lang.NewKeyword("end-line"), int(2392))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, _ := lang.FieldOrMethod(v3, "getValidator") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getValidator is not a function"))) +} +v5 := lang.Apply(v4, []any{}) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// flush +{ +v0 := lang.NewSymbol("flush").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Flushes the output stream that is the current value of\n *out*", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3706), lang.NewKeyword("end-line"), int(3706))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v4 := v3.FindInternedVar(lang.NewSymbol("*out*")) +if v4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) +} +v5 := v4.Get() +v6, _ := lang.FieldOrMethod(v5, "Sync") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Sync is not a function"))) +} +v7 := lang.Apply(v6, []any{}) +_ = v7 +return nil +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// load-all +{ +v0 := lang.NewSymbol("load-all").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"), lang.NewSymbol("need-ns"), lang.NewSymbol("require"))), lang.NewKeyword("doc"), "Loads a lib given its name and forces a load of any libs it directly or\n indirectly loads. If need-ns, ensures that the associated namespace\n exists after loading. If require, records the load so any duplicate loads\n can be skipped.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5935), lang.NewKeyword("end-line"), int(5935), lang.NewKeyword("private"), true)).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +var v6 lang.FnFunc +v6 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("commute")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("*loaded-libs*")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +var v13 lang.FnFunc +v13 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v14 := args[0] +v15 := args[1] +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("reduce1")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("conj")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v18, []any{v21, v14, v15}) +return v22 +}) +v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5942), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(5942), lang.NewKeyword("end-column"), int(47)) +v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("push-thread-bindings")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("hash-map")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*loaded-libs*")) +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("ref")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("sorted-set")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, nil) +v31 := lang.Apply(v26, []any{v30}) +v32 := lang.Apply(v22, []any{v23, v31}) +v33 := lang.Apply(v19, []any{v32}) +_ = v33 +var v34 any +func() { +defer func() { +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v37, nil) +}() +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("load-one")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +} +v41 := v40.Get() +v42 := lang.Apply(v41, []any{v3, v4, v5}) +_ = v42 +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("deref")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +} +v45 := v44.Get() +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("*loaded-libs*")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +} +v48 := v47.Get() +v49 := lang.Apply(v45, []any{v48}) +v34 = v49 +}() +v16 := lang.Apply(v9, []any{v12, v15, v34}) +return v16 +}) +v7, _ := lang.FieldOrMethod(lang1.LockingTransaction, "RunInTransaction") +if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("RunInTransaction is not a function"))) +} +v8 := lang.Apply(v7, []any{v6}) +return v8 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// byte-array +{ +var v1 lang.FnFunc +{ // function byte-array__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.NewList(args[0:]...) +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/byteArray")}) +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("list")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("seq")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("concat")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("list")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v37, []any{lang.NewSymbol("glojure.core/args")}) +v39 := lang.Apply(v30, []any{v34, v38}) +v40 := lang.Apply(v27, []any{v39}) +v41 := lang.Apply(v24, []any{v40}) +v42 := lang.Apply(v9, []any{v13, v17, v21, v41}) +v43 := lang.Apply(v6, []any{v42}) +return v43 + } +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("byte-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Creates an array of bytes", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)int64(2)), lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5317), lang.NewKeyword("end-line"), int(5317))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "byteArray") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("byteArray is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 + case 2: +v4 := args[0] +v5 := args[1] +v6, _ := lang.FieldOrMethod(lang1.Numbers, "byteArrayInit") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("byteArrayInit is not a function"))) +} +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// sorted? +{ +v0 := lang.NewSymbol("sorted?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements Sorted", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6278), lang.NewKeyword("end-line"), int(6278))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{glojure.lang11.Sorted, v3}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// chunk-rest +{ +v0 := lang.NewSymbol("chunk-rest").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(697), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(697), lang.NewKeyword("end-column"), int(71), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, ok := lang.FieldOrMethod(v3, "chunkedMore") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "chunkedMore"))) +} +var v5 any +switch reflect.TypeOf(v4).Kind() { +case reflect.Func: + v5 = lang.Apply(v4, nil) +default: + v5 = v4 +} +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// int? +{ +v0 := lang.NewSymbol("int?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a fixed precision integer", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1395), lang.NewKeyword("end-line"), int(1395))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{lang.Builtins["int64"], v3}) +var v4 any = v8 +_ = v4 +var v10 any +if lang.IsTruthy(v4) { +v10 = v4 +} else { +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("instance?")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{nil, v3}) +var v11 any = v15 +_ = v11 +var v17 any +if lang.IsTruthy(v11) { +v17 = v11 +} else { +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("instance?")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{nil, v3}) +var v18 any = v22 +_ = v18 +var v24 any +if lang.IsTruthy(v18) { +v24 = v18 +} else { +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("instance?")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.Apply(v27, []any{nil, v3}) +v24 = v28 +} +v17 = v24 +} +v10 = v17 +} +return v10 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// spit +{ +v0 := lang.NewSymbol("spit").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("content"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Opposite of slurp. Opens f with writer, writes content, then\n closes f. Options passed to glojure.java.io/writer.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7037), lang.NewKeyword("end-line"), int(7037))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("apply")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{nil, v3, v5}) +var v6 any = v10 +_ = v6 +var v12 any +func() { +defer func() { +v13, ok := lang.FieldOrMethod(v6, "close") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "close"))) +} +var v14 any +switch reflect.TypeOf(v13).Kind() { +case reflect.Func: + v14 = lang.Apply(v13, nil) +default: + v14 = v13 +} +}() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("str")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v4}) +v19 := lang.Apply(lang1.WriteWriter, []any{v6, v18}) +v12 = v19 +}() +return v12 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// unchecked-add +{ +var v1 lang.FnFunc +{ // function unchecked-add__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("concat")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("list")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("seq")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("concat")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("list")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/unchecked_add")}) +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v4}) +v40 := lang.Apply(v27, []any{v31, v35, v39}) +v41 := lang.Apply(v24, []any{v40}) +v42 := lang.Apply(v21, []any{v41}) +v43 := lang.Apply(v10, []any{v14, v18, v42}) +v44 := lang.Apply(v7, []any{v43}) +return v44 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("unchecked-add").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the sum of x and y, both long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1203), lang.NewKeyword("end-line"), int(1203))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := args[1] +v6, _ := lang.FieldOrMethod(lang1.Numbers, "unchecked_add") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_add is not a function"))) +} +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// float-array +{ +var v1 lang.FnFunc +{ // function float-array__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.NewList(args[0:]...) +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/floatArray")}) +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("list")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("seq")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("concat")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("list")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v37, []any{lang.NewSymbol("glojure.core/args")}) +v39 := lang.Apply(v30, []any{v34, v38}) +v40 := lang.Apply(v27, []any{v39}) +v41 := lang.Apply(v24, []any{v40}) +v42 := lang.Apply(v9, []any{v13, v17, v21, v41}) +v43 := lang.Apply(v6, []any{v42}) +return v43 + } +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("float-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Creates an array of floats", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5301), lang.NewKeyword("end-line"), int(5301))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "floatArray") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("floatArray is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 + case 2: +v4 := args[0] +v5 := args[1] +v6, _ := lang.FieldOrMethod(lang1.Numbers, "floatArrayInit") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("floatArrayInit is not a function"))) +} +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// reduced +{ +v0 := lang.NewSymbol("reduced").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Wraps x in a way such that a reduce will terminate with the value x", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2828), lang.NewKeyword("end-line"), int(2828))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.Apply(lang1.NewReduced, []any{v3}) +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// doubles +{ +var v1 lang.FnFunc +{ // function doubles +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/doubles")}) +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("list")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v3}) +v26 := lang.Apply(v9, []any{v13, v17, v21, v25}) +v27 := lang.Apply(v6, []any{v26}) +return v27 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("doubles").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Casts to double[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5402), lang.NewKeyword("end-line"), int(5402))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "doubles") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("doubles is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// bases +{ +v0 := lang.NewSymbol("bases").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"))), lang.NewKeyword("doc"), "Returns the immediate superclass and direct interfaces of c, if any", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5565), lang.NewKeyword("end-line"), int(5565))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +var v4 any +if lang.IsTruthy(v3) { +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("seq")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{nil}) +var v5 any = v9 +_ = v5 +var v10 any = nil +_ = v10 +var v12 any +if lang.IsTruthy(v10) { +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("cons")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v10, v5}) +v12 = v16 +} else { +v12 = v5 +} +v4 = v12 +} else { +v4 = nil +} +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// get-method +{ +v0 := lang.NewSymbol("get-method").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"), lang.NewSymbol("dispatch-val"))), lang.NewKeyword("doc"), "Given a multimethod and a dispatch value, returns the dispatch fn\n that would apply to that value, or nil if none apply and no default", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1815), lang.NewKeyword("end-line"), int(1815))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5, _ := lang.FieldOrMethod(v3, "getMethod") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getMethod is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// cycle +{ +v0 := lang.NewSymbol("cycle").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy (infinite!) sequence of repetitions of the items in coll.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2977), lang.NewKeyword("end-line"), int(2977))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{v3}) +v8 := lang.Apply(lang1.NewCycle, []any{v7}) +return v8 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// iterate +{ +v0 := lang.NewSymbol("iterate").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns a lazy (infinite!) sequence of x, (f x), (f (f x)) etc.\n f must be free of side-effects", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3011), lang.NewKeyword("end-line"), int(3011))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.Apply(nil, []any{v3, v4}) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// check-cyclic-dependency +{ +v0 := lang.NewSymbol("check-cyclic-dependency").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("path"))), lang.NewKeyword("doc"), "Detects and rejects non-trivial cyclic load dependencies. The\n exception message shows the dependency chain with the cycle\n highlighted. Ignores the trivial case of a file attempting to load\n itself because that can occur when a gen-class'd class loads its\n implementation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(30), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6017), lang.NewKeyword("end-line"), int(6017), lang.NewKeyword("private"), true)).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("some")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.CreatePersistentTreeSet(v3) +v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6024), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(6024), lang.NewKeyword("end-column"), int(21)) +v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("rest")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("*pending-paths*")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v13, []any{v16}) +v18 := lang.Apply(v7, []any{v10, v17}) +if lang.IsTruthy(v18) { +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("map")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +var v23 lang.FnFunc +v23 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v24 := args[0] +var v25 any +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("=")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.Apply(v28, []any{v24, v3}) +if lang.IsTruthy(v29) { +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("str")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.Apply(v32, []any{"[ ", v24, " ]"}) +v25 = v33 +} else { +v25 = v24 +} +return v25 +}) +v24 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6025), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(6025), lang.NewKeyword("end-column"), int(59)) +v25, err := lang.WithMeta(v23, v24.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("cons")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("*pending-paths*")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.Apply(v28, []any{v3, v31}) +v33 := lang.Apply(v22, []any{v25, v32}) +var v19 any = v33 +_ = v19 +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("apply")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("str")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("interpose")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v43, []any{"->", v19}) +v45 := lang.Apply(v37, []any{v40, v44}) +var v34 any = v45 +_ = v34 +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("throw-if")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +} +v49 := v48.Get() +v50 := lang.Apply(v49, []any{true, "Cyclic load dependency: %s", v34}) +v4 = v50 +} else { +v4 = nil +} +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// create-struct +{ +v0 := lang.NewSymbol("create-struct").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keys"))), lang.NewKeyword("doc"), "Returns a structure basis object.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4037), lang.NewKeyword("end-line"), int(4037))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.NewList(args[0:]...) +v4 := lang.Apply(lang1.CreatePersistentStructMapSlotMap, []any{v3}) +return v4 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// string? +{ +v0 := lang.NewSymbol("string?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a String", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(160), lang.NewKeyword("end-line"), int(164))).(*lang.Symbol) +var v2 lang.FnFunc +{ // function string? +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{lang.Builtins["string"], v4}) +return v8 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(164), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(164), lang.NewKeyword("end-column"), int(58))).(lang.FnFunc) +v3 := v2 +_ = v3 +} +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// strip-ns +{ +v0 := lang.NewSymbol("strip-ns").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(255), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(255), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("named"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("symbol?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +if lang.IsTruthy(v8) { +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("symbol")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("name")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v3}) +v16 := lang.Apply(v11, []any{nil, v15}) +v4 = v16 +} else { +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("keyword")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("name")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.Apply(v22, []any{v3}) +v24 := lang.Apply(v19, []any{nil, v23}) +v4 = v24 +} +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// defstruct +{ +v0 := lang.NewSymbol("defstruct").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("keys"))), lang.NewKeyword("doc"), "Same as (def name (create-struct keys...))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4044), lang.NewKeyword("end-line"), int(4044))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("seq")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("concat")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("list")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{lang.NewSymbol("def")}) +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("list")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v5}) +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("list")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("seq")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("concat")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("list")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.Apply(v32, []any{lang.NewSymbol("glojure.core/create-struct")}) +v34 := lang.Apply(v29, []any{v33, v6}) +v35 := lang.Apply(v26, []any{v34}) +v36 := lang.Apply(v23, []any{v35}) +v37 := lang.Apply(v12, []any{v16, v20, v36}) +v38 := lang.Apply(v9, []any{v37}) +return v38 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// reset-meta! +{ +v0 := lang.NewSymbol("reset-meta!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("iref"), lang.NewSymbol("metadata-map"))), lang.NewKeyword("doc"), "Atomically resets the metadata for a namespace/var/ref/agent/atom", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2408), lang.NewKeyword("end-line"), int(2408))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5, _ := lang.FieldOrMethod(v3, "ResetMeta") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ResetMeta is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// reset! +{ +v0 := lang.NewSymbol("reset!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atom"), lang.NewSymbol("newval"))), lang.NewKeyword("doc"), "Sets the value of atom to newval without regard for the\n current value. Returns newval.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2368), lang.NewKeyword("end-line"), int(2368))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5, _ := lang.FieldOrMethod(v3, "reset") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// add-doc-and-meta +{ +v0 := lang.NewSymbol("add-doc-and-meta").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("docstring"), lang.NewSymbol("meta"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(26), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6443), lang.NewKeyword("end-line"), int(6443), lang.NewKeyword("private"), true)).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 5 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := args[4] +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("seq")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("concat")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("glojure.core/alter-meta!")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("var")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v5}) +v35 := lang.Apply(v26, []any{v30, v34}) +v36 := lang.Apply(v23, []any{v35}) +v37 := lang.Apply(v20, []any{v36}) +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("list")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.Apply(v40, []any{lang.NewSymbol("glojure.core/merge")}) +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("list")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +} +v44 := v43.Get() +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("seq")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +} +v47 := v46.Get() +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("concat")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v52 := v51.FindInternedVar(lang.NewSymbol("list")) +if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) +} +v53 := v52.Get() +v54 := lang.Apply(v53, []any{lang.NewSymbol("glojure.core/assoc")}) +v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v56 := v55.FindInternedVar(lang.NewSymbol("list")) +if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) +} +v57 := v56.Get() +v58 := lang.Apply(v57, []any{v7}) +v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v60 := v59.FindInternedVar(lang.NewSymbol("list")) +if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) +} +v61 := v60.Get() +v62 := lang.Apply(v61, []any{lang.NewKeyword("doc")}) +v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v64 := v63.FindInternedVar(lang.NewSymbol("list")) +if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) +} +v65 := v64.Get() +v66 := lang.Apply(v65, []any{v6}) +v67 := lang.Apply(v50, []any{v54, v58, v62, v66}) +v68 := lang.Apply(v47, []any{v67}) +v69 := lang.Apply(v44, []any{v68}) +v70 := lang.Apply(v13, []any{v17, v37, v41, v69}) +v71 := lang.Apply(v10, []any{v70}) +return v71 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// eval +{ +v0 := lang.NewSymbol("eval").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("form"))), lang.NewKeyword("doc"), "Evaluates the form data structure (not text!) and returns the result.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3203), lang.NewKeyword("end-line"), int(3203))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, _ := lang.FieldOrMethod(runtime3.Compiler, "Eval") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Eval is not a function"))) +} +v5 := lang.Apply(v4, []any{v3}) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// unchecked-byte +{ +var v1 lang.FnFunc +{ // function unchecked-byte__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/UncheckedByteCast")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v3}) +v35 := lang.Apply(v26, []any{v30, v34}) +v36 := lang.Apply(v23, []any{v35}) +v37 := lang.Apply(v20, []any{v36}) +v38 := lang.Apply(v9, []any{v13, v17, v37}) +v39 := lang.Apply(v6, []any{v38}) +return v39 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("unchecked-byte").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to byte. Subject to rounding or truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3517), lang.NewKeyword("end-line"), int(3517))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := lang.Apply(lang1.UncheckedByteCast, []any{v4}) +return v5 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// swap-vals! +{ +v0 := lang.NewSymbol("swap-vals!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atom"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Atomically swaps the value of atom to be:\n (apply f current-value-of-atom args). Note that f may be called\n multiple times, and thus should be free of side effects.\n Returns [old new], the value of the atom before and after the swap.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2352), lang.NewKeyword("end-line"), int(2352))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +v6, _ := lang.FieldOrMethod(v3, "swapVals") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("swapVals is not a function"))) +} +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// comment +{ +v0 := lang.NewSymbol("comment").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Ignores body, yields nil", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4733), lang.NewKeyword("end-line"), int(4733))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +return nil + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// next +{ +v1 := reflect.TypeOf((*lang1.ISeq)(nil)).Elem() +v0 := lang.NewSymbol("next").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a seq of the items after the first. Calls seq on its\n argument. If there are no more items, returns nil.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(55), lang.NewKeyword("end-line"), int(61))).(*lang.Symbol) +var v3 lang.FnFunc +{ // function next +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +v6 := lang.Apply(lang1.Next, []any{v5}) +return v6 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(61), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(61), lang.NewKeyword("end-column"), int(77))).(lang.FnFunc) +v4 := v3 +_ = v4 +} +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// quot +{ +var v1 lang.FnFunc +{ // function quot__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("concat")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("list")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("seq")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("concat")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("list")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/quotient")}) +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v4}) +v40 := lang.Apply(v27, []any{v31, v35, v39}) +v41 := lang.Apply(v24, []any{v40}) +v42 := lang.Apply(v21, []any{v41}) +v43 := lang.Apply(v10, []any{v14, v18, v42}) +v44 := lang.Apply(v7, []any{v43}) +return v44 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("quot").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"), lang.NewSymbol("div"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "quot[ient] of dividing numerator by denominator.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1266), lang.NewKeyword("end-line"), int(1266))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := args[1] +v6, _ := lang.FieldOrMethod(lang1.Numbers, "quotient") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("quotient is not a function"))) +} +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// with-redefs-fn +{ +v0 := lang.NewSymbol("with-redefs-fn").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("binding-map"), lang.NewSymbol("func"))), lang.NewKeyword("doc"), "Temporarily redefines Vars during a call to func. Each val of\n binding-map will replace the root value of its key which must be\n a Var. After func is called with no args, the root values of all\n the Vars will be set back to their old values. These temporary\n changes will be visible in all threads. Useful for mocking out\n functions during testing.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7567), lang.NewKeyword("end-line"), int(7567))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +var v6 lang.FnFunc +v6 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v7 := args[0] +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("seq")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v7}) +var v8 any = v12 +_ = v8 +var v13 any = nil +_ = v13 +var v14 any = int64(0) +_ = v14 +var v15 any = int64(0) +_ = v15 +var v16 any +for { +var v17 any +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("<")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, []any{v15, v14}) +if lang.IsTruthy(v21) { +v23, _ := lang.FieldOrMethod(v13, "nth") +if reflect.TypeOf(v23).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) +} +v24 := lang.Apply(v23, []any{v15}) +var v22 any = v24 +_ = v22 +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("nth")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.Apply(v28, []any{v22, int64(0), nil}) +var v25 any = v29 +_ = v25 +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("nth")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v22, int64(1), nil}) +var v30 any = v34 +_ = v30 +v36, _ := lang.FieldOrMethod(v25, "bindRoot") +if reflect.TypeOf(v36).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("bindRoot is not a function"))) +} +v37 := lang.Apply(v36, []any{v30}) +_ = v37 +var v38 any = v8 +var v39 any = v13 +var v40 any = v14 +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("unchecked-inc")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +} +v44 := v43.Get() +v45 := lang.Apply(v44, []any{v15}) +var v41 any = v45 +v8 = v38 +v13 = v39 +v14 = v40 +v15 = v41 +continue +} else { +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("seq")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{v8}) +var v22 any = v26 +_ = v22 +var v28 any +if lang.IsTruthy(v22) { +var v29 any = v22 +_ = v29 +var v31 any +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("chunked-seq?")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v29}) +if lang.IsTruthy(v35) { +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("chunk-first")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v29}) +var v36 any = v40 +_ = v36 +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("chunk-rest")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +} +v45 := v44.Get() +v46 := lang.Apply(v45, []any{v29}) +var v42 any = v46 +var v47 any = v36 +v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v50 := v49.FindInternedVar(lang.NewSymbol("int")) +if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) +} +v51 := v50.Get() +v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v53 := v52.FindInternedVar(lang.NewSymbol("count")) +if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) +} +v54 := v53.Get() +v55 := lang.Apply(v54, []any{v36}) +v56 := lang.Apply(v51, []any{v55}) +var v48 any = v56 +v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v59 := v58.FindInternedVar(lang.NewSymbol("int")) +if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) +} +v60 := v59.Get() +v61 := lang.Apply(v60, []any{int64(0)}) +var v57 any = v61 +v8 = v42 +v13 = v47 +v14 = v48 +v15 = v57 +continue +} else { +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("first")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v29}) +var v36 any = v40 +_ = v36 +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("nth")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +} +v44 := v43.Get() +v45 := lang.Apply(v44, []any{v36, int64(0), nil}) +var v41 any = v45 +_ = v41 +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("nth")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +} +v49 := v48.Get() +v50 := lang.Apply(v49, []any{v36, int64(1), nil}) +var v46 any = v50 +_ = v46 +v52, _ := lang.FieldOrMethod(v41, "bindRoot") +if reflect.TypeOf(v52).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("bindRoot is not a function"))) +} +v53 := lang.Apply(v52, []any{v46}) +_ = v53 +v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v56 := v55.FindInternedVar(lang.NewSymbol("next")) +if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) +} +v57 := v56.Get() +v58 := lang.Apply(v57, []any{v29}) +var v54 any = v58 +var v59 any = nil +var v60 any = int64(0) +var v61 any = int64(0) +v8 = v54 +v13 = v59 +v14 = v60 +v15 = v61 +continue +} +v28 = v31 +} else { +v28 = nil +} +v17 = v28 +} +v16 = v17 + break +} +return v16 +}) +v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7576), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(7578), lang.NewKeyword("end-column"), int(93)) +v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v5 any = v8 +_ = v5 +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("zipmap")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("keys")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v3}) +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("map")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +var v20 lang.FnFunc +v20 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v21 := args[0] +v22, ok := lang.FieldOrMethod(v21, "getRawRoot") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v21, "getRawRoot"))) +} +var v23 any +switch reflect.TypeOf(v22).Kind() { +case reflect.Func: + v23 = lang.Apply(v22, nil) +default: + v23 = v22 +} +return v23 +}) +v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7580), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(7580), lang.NewKeyword("end-column"), int(92)) +v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("keys")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{v3}) +v27 := lang.Apply(v19, []any{v22, v26}) +v28 := lang.Apply(v12, []any{v16, v27}) +var v9 any = v28 +_ = v9 +var v30 any +func() { +defer func() { +v31 := lang.Apply(v5, []any{v9}) +}() +v32 := lang.Apply(v5, []any{v3}) +_ = v32 +v33 := lang.Apply(v4, nil) +v30 = v33 +}() +return v30 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// inc' +{ +var v1 lang.FnFunc +{ // function inc'__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/incP")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v3}) +v35 := lang.Apply(v26, []any{v30, v34}) +v36 := lang.Apply(v23, []any{v35}) +v37 := lang.Apply(v20, []any{v36}) +v38 := lang.Apply(v9, []any{v13, v17, v37}) +v39 := lang.Apply(v6, []any{v38}) +return v39 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("inc'").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns a number one greater than num. Supports arbitrary precision.\n See also: inc", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(908), lang.NewKeyword("end-line"), int(908))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "incP") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("incP is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// gensym +{ +v0 := lang.NewSymbol("gensym").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("prefix-string"))), lang.NewKeyword("doc"), "Returns a new symbol with a unique name. If a prefix string is\n supplied, the name is prefix# where # is some unique number. If\n prefix is not supplied, the prefix is 'G__'.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(599), lang.NewKeyword("end-line"), int(599))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v4 := v3.FindInternedVar(lang.NewSymbol("gensym")) +if v4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) +} +v5 := v4.Get() +v6 := lang.Apply(v5, []any{"G__"}) +return v6 + case 1: +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("str")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("str")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10, _ := lang.FieldOrMethod(runtime3.RT, "NextID") +if reflect.TypeOf(v10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("NextID is not a function"))) +} +v11 := lang.Apply(v10, []any{}) +v12 := lang.Apply(v9, []any{v11}) +v13 := lang.Apply(v6, []any{v3, v12}) +v14 := lang.Apply(lang1.NewSymbol, []any{v13}) +return v14 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// rseq +{ +v0 := lang.NewSymbol("rseq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rev"))), lang.NewKeyword("doc"), "Returns, in constant time, a seq of the items in rev (which\n can be a vector or sorted-map), in reverse order. If rev is empty returns nil", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1577), lang.NewKeyword("end-line"), int(1577))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, _ := lang.FieldOrMethod(v3, "rseq") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("rseq is not a function"))) +} +v5 := lang.Apply(v4, []any{}) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// emit-extend-type +{ +v0 := lang.NewSymbol("emit-extend-type").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(175), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(175), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"), lang.NewSymbol("specs"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("parse-impls")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v4}) +var v5 any = v9 +_ = v5 +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("seq")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("concat")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("list")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v19, []any{lang.NewSymbol("glojure.core/extend")}) +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("list")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v3}) +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("mapcat")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("partial")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("emit-hinted-impl")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v30, []any{v33, v3}) +v35 := lang.Apply(v27, []any{v34, v5}) +v36 := lang.Apply(v16, []any{v20, v24, v35}) +v37 := lang.Apply(v13, []any{v36}) +return v37 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// class? +{ +v0 := lang.NewSymbol("class?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is an instance of Class", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5465), lang.NewKeyword("end-line"), int(5465))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{reflect.Type, v3}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// chars +{ +var v1 lang.FnFunc +{ // function chars +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/chars")}) +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("list")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v3}) +v26 := lang.Apply(v9, []any{v13, v17, v21, v25}) +v27 := lang.Apply(v6, []any{v26}) +return v27 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("chars").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Casts to chars[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5382), lang.NewKeyword("end-line"), int(5382))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "chars") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("chars is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// with-bindings +{ +v0 := lang.NewSymbol("with-bindings").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("binding-map"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Takes a map of Var/value pairs. Installs for the given Vars the associated\n values as thread-local bindings. Then executes body. Pops the installed\n bindings after body was evaluated. Returns the value of body.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1984), lang.NewKeyword("end-line"), int(1984))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("seq")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("concat")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("list")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/with-bindings*")}) +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("list")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v5}) +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("list")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("seq")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("concat")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("list")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.Apply(v32, []any{lang.NewSymbol("glojure.core/fn")}) +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("list")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("apply")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("vector")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("seq")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +} +v45 := v44.Get() +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("concat")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +} +v48 := v47.Get() +v49 := lang.Apply(v48, nil) +v50 := lang.Apply(v45, []any{v49}) +v51 := lang.Apply(v39, []any{v42, v50}) +v52 := lang.Apply(v36, []any{v51}) +v53 := lang.Apply(v29, []any{v33, v52, v6}) +v54 := lang.Apply(v26, []any{v53}) +v55 := lang.Apply(v23, []any{v54}) +v56 := lang.Apply(v12, []any{v16, v20, v55}) +v57 := lang.Apply(v9, []any{v56}) +return v57 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// stream-seq! +{ +v0 := lang.NewSymbol("stream-seq!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Takes a java.util.stream.BaseStream instance s and returns a seq of its\n contents. This is a terminal operation on the stream.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6836), lang.NewKeyword("end-line"), int(6836))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("iterator-seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7, ok := lang.FieldOrMethod(v3, "iterator") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "iterator"))) +} +var v8 any +switch reflect.TypeOf(v7).Kind() { +case reflect.Func: + v8 = lang.Apply(v7, nil) +default: + v8 = v7 +} +v9 := lang.Apply(v6, []any{v8}) +return v9 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// hash-ordered-coll +{ +v0 := lang.NewSymbol("hash-ordered-coll").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns the hash code, consistent with =, for an external ordered\n collection implementing Iterable.\n See http://glojure.org/data_structures#hash for full algorithms.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5210), lang.NewKeyword("end-line"), int(5210))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.Apply(nil, []any{v3}) +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// import +{ +v0 := lang.NewSymbol("import").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("import-symbols-or-lists"))), lang.NewKeyword("doc"), "import-list => (package-symbol class-name-symbols*)\n\n For each name in class-name-symbols, adds a mapping from name to the\n class named by package.name to the current namespace. Use :import in the ns\n macro in preference to calling this directly.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3426), lang.NewKeyword("end-line"), int(3426))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("map")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +var v10 lang.FnFunc +v10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v11 := args[0] +var v12 any +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("seq?")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v11}) +var v13 any = v17 +_ = v13 +var v19 any +if lang.IsTruthy(v13) { +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("=")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("first")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{v11}) +v27 := lang.Apply(v22, []any{lang.NewSymbol("quote"), v26}) +v19 = v27 +} else { +v19 = v13 +} +if lang.IsTruthy(v19) { +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("second")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v11}) +v12 = v16 +} else { +v12 = v11 +} +return v12 +}) +v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3434), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(3434), lang.NewKeyword("end-column"), int(73)) +v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v13 := lang.Apply(v9, []any{v12, v5}) +var v6 any = v13 +_ = v6 +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("seq")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("concat")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("list")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(v23, []any{lang.NewSymbol("do")}) +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("map")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +var v28 lang.FnFunc +v28 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v29 := args[0] +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("list")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.Apply(v32, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Import"), v29}) +return v33 +}) +v29 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3436), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(3436), lang.NewKeyword("end-column"), int(73)) +v30, err := lang.WithMeta(v28, v29.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("reduce1")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +var v34 lang.FnFunc +v34 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v35 := args[0] +v36 := args[1] +var v37 any +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("symbol?")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.Apply(v40, []any{v36}) +if lang.IsTruthy(v41) { +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("conj")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +} +v44 := v43.Get() +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("name")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +} +v47 := v46.Get() +v48 := lang.Apply(v47, []any{v36}) +v49 := lang.Apply(v44, []any{v35, v48}) +v37 = v49 +} else { +v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v52 := v51.FindInternedVar(lang.NewSymbol("first")) +if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) +} +v53 := v52.Get() +v54 := lang.Apply(v53, []any{v36}) +var v50 any = v54 +_ = v50 +v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v57 := v56.FindInternedVar(lang.NewSymbol("rest")) +if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) +} +v58 := v57.Get() +v59 := lang.Apply(v58, []any{v36}) +var v55 any = v59 +_ = v55 +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("into1")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +} +v63 := v62.Get() +v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v65 := v64.FindInternedVar(lang.NewSymbol("map")) +if v65.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) +} +v66 := v65.Get() +var v67 lang.FnFunc +v67 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v68 := args[0] +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("str")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +} +v71 := v70.Get() +v72 := lang.Apply(v71, []any{v50, ".", v68}) +return v72 +}) +v68 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3441), lang.NewKeyword("column"), int(45), lang.NewKeyword("end-line"), int(3441), lang.NewKeyword("end-column"), int(58)) +v69, err := lang.WithMeta(v67, v68.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v70 := lang.Apply(v66, []any{v69, v55}) +v71 := lang.Apply(v63, []any{v35, v70}) +v37 = v71 +} +return v37 +}) +v35 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3437), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(3441), lang.NewKeyword("end-column"), int(66)) +v36, err := lang.WithMeta(v34, v35.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v37 := lang.NewVector() +v38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3442), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(3442), lang.NewKeyword("end-column"), int(26)) +v39, err := lang.WithMeta(v37, v38.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v40 := lang.Apply(v33, []any{v36, v39, v6}) +v41 := lang.Apply(v27, []any{v30, v40}) +v42 := lang.Apply(v20, []any{v24, v41}) +v43 := lang.Apply(v17, []any{v42}) +return v43 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// requiring-resolve +{ +v0 := lang.NewSymbol("requiring-resolve").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Resolves namespace-qualified sym per 'resolve'. If initial resolve\nfails, attempts to require sym's namespace and retries.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6111), lang.NewKeyword("end-line"), int(6111))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("qualified-symbol?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +if lang.IsTruthy(v8) { +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("resolve")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{v3}) +var v9 any = v13 +_ = v9 +var v15 any +if lang.IsTruthy(v9) { +v15 = v9 +} else { +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("serialized-require")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("symbol")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("namespace")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v3}) +v26 := lang.Apply(v21, []any{v25}) +v27 := lang.Apply(v18, []any{v26}) +_ = v27 +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("resolve")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{v3}) +v15 = v31 +} +v4 = v15 +} else { +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("str")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v11, []any{"Not a qualified symbol: ", v3}) +v13 := lang.Apply(lang1.NewIllegalArgumentError, []any{v12}) +panic(v13) +} +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// empty +{ +v0 := lang.NewSymbol("empty").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns an empty collection of the same category as coll, or nil", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5265), lang.NewKeyword("end-line"), int(5265))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{lang1.IPersistentCollection, v3}) +if lang.IsTruthy(v8) { +v9, ok := lang.FieldOrMethod(v3, "empty") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "empty"))) +} +var v10 any +switch reflect.TypeOf(v9).Kind() { +case reflect.Func: + v10 = lang.Apply(v9, nil) +default: + v10 = v9 +} +v4 = v10 +} else { +v4 = nil +} +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// vals +{ +v0 := lang.NewSymbol("vals").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"))), lang.NewKeyword("doc"), "Returns a sequence of the map's values, in the same order as (seq map).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1557), lang.NewKeyword("end-line"), int(1557))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.Apply(lang1.Vals, []any{v3}) +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// print-initialized +{ +v0 := lang.NewSymbol("print-initialized").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(520), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(520), lang.NewKeyword("end-column"), int(39), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, true, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// fn +{ +v0 := lang.NewSymbol("fn").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("sigs"))), lang.NewKeyword("doc"), "params => positional-params*, or positional-params* & rest-param\n positional-param => binding-form\n rest-param => binding-form\n binding-form => name, or destructuring-form\n\n Defines a function.\n\n See https://glojure.org/reference/special_forms#fn for more information", lang.NewKeyword("forms"), lang.NewVector(lang.NewList(lang.NewSymbol("fn"), lang.NewSymbol("name?"), lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("exprs*")), lang.NewList(lang.NewSymbol("fn"), lang.NewSymbol("name?"), lang.NewList(lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("exprs*")), lang.NewSymbol("+"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4533), lang.NewKeyword("end-line"), int(4533), lang.NewKeyword("special-form"), true)).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +var v7 any +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("symbol?")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("first")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v5}) +v15 := lang.Apply(v10, []any{v14}) +if lang.IsTruthy(v15) { +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("first")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v5}) +v7 = v19 +} else { +v7 = nil +} +var v6 any = v7 +_ = v6 +var v21 any +if lang.IsTruthy(v6) { +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("next")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v20}) +v21 = v25 +} else { +v21 = v20 +} +var v20 any = v21 +_ = v20 +var v27 any +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("vector?")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("first")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v26}) +v35 := lang.Apply(v30, []any{v34}) +if lang.IsTruthy(v35) { +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v26}) +v27 = v39 +} else { +var v40 any +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("seq?")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("first")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v26}) +v48 := lang.Apply(v43, []any{v47}) +if lang.IsTruthy(v48) { +v40 = v26 +} else { +var v49 any +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("seq")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +} +v52 := v51.Get() +v53 := lang.Apply(v52, []any{v26}) +if lang.IsTruthy(v53) { +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("str")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +} +v56 := v55.Get() +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("first")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +} +v59 := v58.Get() +v60 := lang.Apply(v59, []any{v26}) +v61 := lang.Apply(v56, []any{"Parameter declaration ", v60, " should be a vector"}) +v49 = v61 +} else { +v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v63 := v62.FindInternedVar(lang.NewSymbol("str")) +if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +} +v64 := v63.Get() +v65 := lang.Apply(v64, []any{"Parameter declaration missing"}) +v49 = v65 +} +v66 := lang.Apply(lang1.NewIllegalArgumentError, []any{v49}) +panic(v66) +} +v27 = v40 +} +var v26 any = v27 +_ = v26 +var v68 lang.FnFunc +v68 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v69 := args[0] +var v70 any +v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v72 := v71.FindInternedVar(lang.NewSymbol("not")) +if v72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) +} +v73 := v72.Get() +v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v75 := v74.FindInternedVar(lang.NewSymbol("seq?")) +if v75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) +} +v76 := v75.Get() +v77 := lang.Apply(v76, []any{v69}) +v78 := lang.Apply(v73, []any{v77}) +if lang.IsTruthy(v78) { +v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v80 := v79.FindInternedVar(lang.NewSymbol("str")) +if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) +} +v81 := v80.Get() +v82 := lang.Apply(v81, []any{"Invalid signature ", v69, " should be a list"}) +v83 := lang.Apply(lang1.NewIllegalArgumentError, []any{v82}) +panic(v83) +} else { +v70 = nil +} +_ = v70 +var v84 any = v69 +_ = v84 +v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v87 := v86.FindInternedVar(lang.NewSymbol("seq")) +if v87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) +} +v88 := v87.Get() +v89 := lang.Apply(v88, []any{v84}) +var v85 any = v89 +_ = v85 +v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v92 := v91.FindInternedVar(lang.NewSymbol("first")) +if v92.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) +} +v93 := v92.Get() +v94 := lang.Apply(v93, []any{v85}) +var v90 any = v94 +_ = v90 +v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v97 := v96.FindInternedVar(lang.NewSymbol("next")) +if v97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) +} +v98 := v97.Get() +v99 := lang.Apply(v98, []any{v95}) +var v95 any = v99 +_ = v95 +var v100 any = v90 +_ = v100 +var v101 any = v95 +_ = v101 +var v103 any +v104 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v105 := v104.FindInternedVar(lang.NewSymbol("not")) +if v105.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v105))) +} +v106 := v105.Get() +v107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v108 := v107.FindInternedVar(lang.NewSymbol("vector?")) +if v108.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v108))) +} +v109 := v108.Get() +v110 := lang.Apply(v109, []any{v100}) +v111 := lang.Apply(v106, []any{v110}) +if lang.IsTruthy(v111) { +var v112 any +v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v114 := v113.FindInternedVar(lang.NewSymbol("seq?")) +if v114.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) +} +v115 := v114.Get() +v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v117 := v116.FindInternedVar(lang.NewSymbol("first")) +if v117.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) +} +v118 := v117.Get() +v119 := lang.Apply(v118, []any{v26}) +v120 := lang.Apply(v115, []any{v119}) +if lang.IsTruthy(v120) { +v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v122 := v121.FindInternedVar(lang.NewSymbol("str")) +if v122.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) +} +v123 := v122.Get() +v124 := lang.Apply(v123, []any{"Parameter declaration ", v100, " should be a vector"}) +v112 = v124 +} else { +v125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v126 := v125.FindInternedVar(lang.NewSymbol("str")) +if v126.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v126))) +} +v127 := v126.Get() +v128 := lang.Apply(v127, []any{"Invalid signature ", v69, " should be a list"}) +v112 = v128 +} +v129 := lang.Apply(lang1.NewIllegalArgumentError, []any{v112}) +panic(v129) +} else { +v103 = nil +} +var v102 any = v103 +_ = v102 +var v131 any +v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v134 := v133.FindInternedVar(lang.NewSymbol("next")) +if v134.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) +} +v135 := v134.Get() +v136 := lang.Apply(v135, []any{v101}) +var v132 any = v136 +_ = v132 +var v138 any +if lang.IsTruthy(v132) { +v139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v140 := v139.FindInternedVar(lang.NewSymbol("map?")) +if v140.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v140))) +} +v141 := v140.Get() +v142 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v143 := v142.FindInternedVar(lang.NewSymbol("first")) +if v143.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v143))) +} +v144 := v143.Get() +v145 := lang.Apply(v144, []any{v101}) +v146 := lang.Apply(v141, []any{v145}) +v138 = v146 +} else { +v138 = v132 +} +if lang.IsTruthy(v138) { +v132 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v133 := v132.FindInternedVar(lang.NewSymbol("first")) +if v133.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v133))) +} +v134 := v133.Get() +v135 := lang.Apply(v134, []any{v101}) +v131 = v135 +} else { +v131 = nil +} +var v130 any = v131 +_ = v130 +var v137 any +if lang.IsTruthy(v130) { +v138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v139 := v138.FindInternedVar(lang.NewSymbol("next")) +if v139.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v139))) +} +v140 := v139.Get() +v141 := lang.Apply(v140, []any{v136}) +v137 = v141 +} else { +v137 = v136 +} +var v136 any = v137 +_ = v136 +var v143 any = v142 +_ = v143 +var v145 any +if lang.IsTruthy(v143) { +v145 = v143 +} else { +v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v147 := v146.FindInternedVar(lang.NewSymbol("meta")) +if v147.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) +} +v148 := v147.Get() +v149 := lang.Apply(v148, []any{v100}) +v145 = v149 +} +var v142 any = v145 +_ = v142 +v144 := lang.Apply(lang.NewKeyword("pre"), []any{v142}) +var v143 any = v144 +_ = v143 +v146 := lang.Apply(lang.NewKeyword("post"), []any{v142}) +var v145 any = v146 +_ = v145 +var v148 any +if lang.IsTruthy(v145) { +v149 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v150 := v149.FindInternedVar(lang.NewSymbol("seq")) +if v150.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v150))) +} +v151 := v150.Get() +v152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v153 := v152.FindInternedVar(lang.NewSymbol("concat")) +if v153.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v153))) +} +v154 := v153.Get() +v155 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v156 := v155.FindInternedVar(lang.NewSymbol("list")) +if v156.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v156))) +} +v157 := v156.Get() +v158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v159 := v158.FindInternedVar(lang.NewSymbol("seq")) +if v159.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v159))) +} +v160 := v159.Get() +v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v162 := v161.FindInternedVar(lang.NewSymbol("concat")) +if v162.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) +} +v163 := v162.Get() +v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v165 := v164.FindInternedVar(lang.NewSymbol("list")) +if v165.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) +} +v166 := v165.Get() +v167 := lang.Apply(v166, []any{lang.NewSymbol("glojure.core/let")}) +v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v169 := v168.FindInternedVar(lang.NewSymbol("list")) +if v169.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) +} +v170 := v169.Get() +v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v172 := v171.FindInternedVar(lang.NewSymbol("apply")) +if v172.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) +} +v173 := v172.Get() +v174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v175 := v174.FindInternedVar(lang.NewSymbol("vector")) +if v175.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v175))) +} +v176 := v175.Get() +v177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v178 := v177.FindInternedVar(lang.NewSymbol("seq")) +if v178.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v178))) +} +v179 := v178.Get() +v180 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v181 := v180.FindInternedVar(lang.NewSymbol("concat")) +if v181.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v181))) +} +v182 := v181.Get() +v183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v184 := v183.FindInternedVar(lang.NewSymbol("list")) +if v184.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v184))) +} +v185 := v184.Get() +v186 := lang.Apply(v185, []any{lang.NewSymbol("%")}) +v187 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v188 := v187.FindInternedVar(lang.NewSymbol("list")) +if v188.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v188))) +} +v189 := v188.Get() +var v190 any +v191 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v192 := v191.FindInternedVar(lang.NewSymbol("<")) +if v192.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v192))) +} +v193 := v192.Get() +v194 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v195 := v194.FindInternedVar(lang.NewSymbol("count")) +if v195.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v195))) +} +v196 := v195.Get() +v197 := lang.Apply(v196, []any{v147}) +v198 := lang.Apply(v193, []any{int64(1), v197}) +if lang.IsTruthy(v198) { +v199 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v200 := v199.FindInternedVar(lang.NewSymbol("seq")) +if v200.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v200))) +} +v201 := v200.Get() +v202 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v203 := v202.FindInternedVar(lang.NewSymbol("concat")) +if v203.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v203))) +} +v204 := v203.Get() +v205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v206 := v205.FindInternedVar(lang.NewSymbol("list")) +if v206.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v206))) +} +v207 := v206.Get() +v208 := lang.Apply(v207, []any{lang.NewSymbol("do")}) +v209 := lang.Apply(v204, []any{v208, v147}) +v210 := lang.Apply(v201, []any{v209}) +v190 = v210 +} else { +v211 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v212 := v211.FindInternedVar(lang.NewSymbol("first")) +if v212.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v212))) +} +v213 := v212.Get() +v214 := lang.Apply(v213, []any{v147}) +v190 = v214 +} +v215 := lang.Apply(v189, []any{v190}) +v216 := lang.Apply(v182, []any{v186, v215}) +v217 := lang.Apply(v179, []any{v216}) +v218 := lang.Apply(v173, []any{v176, v217}) +v219 := lang.Apply(v170, []any{v218}) +v220 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v221 := v220.FindInternedVar(lang.NewSymbol("map")) +if v221.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v221))) +} +v222 := v221.Get() +var v223 lang.FnFunc +v223 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v224 := args[0] +v225 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v226 := v225.FindInternedVar(lang.NewSymbol("seq")) +if v226.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v226))) +} +v227 := v226.Get() +v228 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v229 := v228.FindInternedVar(lang.NewSymbol("concat")) +if v229.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v229))) +} +v230 := v229.Get() +v231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v232 := v231.FindInternedVar(lang.NewSymbol("list")) +if v232.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v232))) +} +v233 := v232.Get() +v234 := lang.Apply(v233, []any{lang.NewSymbol("glojure.core/assert")}) +v235 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v236 := v235.FindInternedVar(lang.NewSymbol("list")) +if v236.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v236))) +} +v237 := v236.Get() +v238 := lang.Apply(v237, []any{v224}) +v239 := lang.Apply(v230, []any{v234, v238}) +v240 := lang.Apply(v227, []any{v239}) +return v240 +}) +v224 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4582), lang.NewKeyword("column"), int(41), lang.NewKeyword("end-line"), int(4582), lang.NewKeyword("end-column"), int(62)) +v225, err := lang.WithMeta(v223, v224.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v226 := lang.Apply(v222, []any{v225, v145}) +v227 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v228 := v227.FindInternedVar(lang.NewSymbol("list")) +if v228.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v228))) +} +v229 := v228.Get() +v230 := lang.Apply(v229, []any{lang.NewSymbol("%")}) +v231 := lang.Apply(v163, []any{v167, v219, v226, v230}) +v232 := lang.Apply(v160, []any{v231}) +v233 := lang.Apply(v157, []any{v232}) +v234 := lang.Apply(v154, []any{v233}) +v235 := lang.Apply(v151, []any{v234}) +v148 = v235 +} else { +v148 = v147 +} +var v147 any = v148 +_ = v147 +var v237 any +if lang.IsTruthy(v143) { +v238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v239 := v238.FindInternedVar(lang.NewSymbol("concat")) +if v239.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v239))) +} +v240 := v239.Get() +v241 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v242 := v241.FindInternedVar(lang.NewSymbol("map")) +if v242.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v242))) +} +v243 := v242.Get() +var v244 lang.FnFunc +v244 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v245 := args[0] +v246 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v247 := v246.FindInternedVar(lang.NewSymbol("seq")) +if v247.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v247))) +} +v248 := v247.Get() +v249 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v250 := v249.FindInternedVar(lang.NewSymbol("concat")) +if v250.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v250))) +} +v251 := v250.Get() +v252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v253 := v252.FindInternedVar(lang.NewSymbol("list")) +if v253.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v253))) +} +v254 := v253.Get() +v255 := lang.Apply(v254, []any{lang.NewSymbol("glojure.core/assert")}) +v256 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v257 := v256.FindInternedVar(lang.NewSymbol("list")) +if v257.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v257))) +} +v258 := v257.Get() +v259 := lang.Apply(v258, []any{v245}) +v260 := lang.Apply(v251, []any{v255, v259}) +v261 := lang.Apply(v248, []any{v260}) +return v261 +}) +v245 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4586), lang.NewKeyword("column"), int(44), lang.NewKeyword("end-line"), int(4586), lang.NewKeyword("end-column"), int(65)) +v246, err := lang.WithMeta(v244, v245.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v247 := lang.Apply(v243, []any{v246, v143}) +v248 := lang.Apply(v240, []any{v247, v236}) +v237 = v248 +} else { +v237 = v236 +} +var v236 any = v237 +_ = v236 +v250 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v251 := v250.FindInternedVar(lang.NewSymbol("maybe-destructured")) +if v251.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v251))) +} +v252 := v251.Get() +v253 := lang.Apply(v252, []any{v100, v236}) +return v253 +}) +v69 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4558), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(4589), lang.NewKeyword("end-column"), int(53)) +v70, err := lang.WithMeta(v68, v69.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v67 any = v70 +_ = v67 +v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v73 := v72.FindInternedVar(lang.NewSymbol("map")) +if v73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) +} +v74 := v73.Get() +v75 := lang.Apply(v74, []any{v67, v26}) +var v71 any = v75 +_ = v71 +v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v78 := v77.FindInternedVar(lang.NewSymbol("with-meta")) +if v78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) +} +v79 := v78.Get() +var v80 any +if lang.IsTruthy(v6) { +v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v82 := v81.FindInternedVar(lang.NewSymbol("list*")) +if v82.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) +} +v83 := v82.Get() +v84 := lang.Apply(v83, []any{lang.NewSymbol("fn*"), v6, v71}) +v80 = v84 +} else { +v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v86 := v85.FindInternedVar(lang.NewSymbol("cons")) +if v86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) +} +v87 := v86.Get() +v88 := lang.Apply(v87, []any{lang.NewSymbol("fn*"), v71}) +v80 = v88 +} +v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v90 := v89.FindInternedVar(lang.NewSymbol("meta")) +if v90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) +} +v91 := v90.Get() +v92 := lang.Apply(v91, []any{v3}) +v93 := lang.Apply(v79, []any{v80, v92}) +return v93 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// complement +{ +v0 := lang.NewSymbol("complement").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Takes a fn f and returns a fn that takes the same arguments as f,\n has the same effects, if any, and returns the opposite truth value.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1428), lang.NewKeyword("end-line"), int(1428))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("not")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v3, nil) +v9 := lang.Apply(v7, []any{v8}) +return v9 + case 1: +v5 := args[0] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("not")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v3, []any{v5}) +v10 := lang.Apply(v8, []any{v9}) +return v10 + case 2: +v5 := args[0] +v6 := args[1] +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("not")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v3, []any{v5, v6}) +v11 := lang.Apply(v9, []any{v10}) +return v11 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +v6 := args[1] +v7 := lang.NewList(args[2:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("not")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("apply")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v3, v5, v6, v7}) +v15 := lang.Apply(v10, []any{v14}) +return v15 + } +}) +v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1434), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(1438), lang.NewKeyword("end-column"), int(40)) +v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v6 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// remove-tap +{ +v0 := lang.NewSymbol("remove-tap").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Remove f from the tap set.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7936), lang.NewKeyword("end-line"), int(7936))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("swap!")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("tapset")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("disj")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v6, []any{v9, v12, v3}) +_ = v13 +return nil +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// print-map +{ +v0 := lang.NewSymbol("print-map").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(252), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(252), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("print-one"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("print-prefix-map")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{nil, v3, v4, v5}) +return v9 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// prn +{ +v0 := lang.NewSymbol("prn").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Same as pr followed by (newline). Observes *flush-on-newline*", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3715), lang.NewKeyword("end-line"), int(3715))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.NewList(args[0:]...) +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("apply")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("pr")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v6, []any{v9, v3}) +_ = v10 +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("newline")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, nil) +_ = v14 +var v15 any +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("*flush-on-newline*")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +if lang.IsTruthy(v18) { +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("flush")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, nil) +v15 = v22 +} else { +v15 = nil +} +return v15 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// parse-long +{ +v0 := lang.NewSymbol("parse-long").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse string of decimal digits with optional leading -/+ and return a\n Long value, or nil if parse fails", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7979), lang.NewKeyword("end-line"), int(7979))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("string?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +if lang.IsTruthy(v8) { +v10 := lang.Apply(strconv4.ParseInt, []any{v3, int64(10), int64(64)}) +var v9 any = v10 +_ = v9 +var v12 any +v13 := lang.Apply(v9, []any{int64(1)}) +if lang.IsTruthy(v13) { +v12 = nil +} else { +v14 := lang.Apply(v9, []any{int64(0)}) +v12 = v14 +} +v4 = v12 +} else { +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("parsing-err")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v3}) +v13 := lang.Apply(lang1.NewIllegalArgumentError, []any{v12}) +panic(v13) +} +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// map-entry? +{ +v0 := lang.NewSymbol("map-entry?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a map entry", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.8", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1473), lang.NewKeyword("end-line"), int(1473))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{java.util13.Map$Entry, v3}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// cond +{ +v0 := lang.NewSymbol("cond").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes a set of test/expr pairs. It evaluates each test one at a\n time. If a test returns logical true, cond evaluates and returns\n the value of the corresponding expr and doesn't evaluate any of the\n other tests or exprs. (cond) returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(569), lang.NewKeyword("end-line"), int(569))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +var v6 any +if lang.IsTruthy(v5) { +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("list")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("first")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{v5}) +var v14 any +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("next")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v5}) +if lang.IsTruthy(v18) { +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("second")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v5}) +v14 = v22 +} else { +v23 := lang.Apply(lang1.NewIllegalArgumentError, []any{"cond requires an even number of forms"}) +panic(v23) +} +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("cons")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("next")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("next")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.Apply(v32, []any{v5}) +v34 := lang.Apply(v29, []any{v33}) +v35 := lang.Apply(v26, []any{lang.NewSymbol("glojure.core/cond"), v34}) +v36 := lang.Apply(v9, []any{lang.NewSymbol("if"), v13, v14, v35}) +v6 = v36 +} else { +v6 = nil +} +return v6 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// reduce-kv +{ +v0 := lang.NewSymbol("reduce-kv").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Reduces an associative collection. f should be a function of 3\n arguments. Returns the result of applying f to init, the first key\n and the first value in coll, then applying f to that result and the\n 2nd key and value, etc. If coll contains no entries, returns init\n and f is not called. Note that reduce-kv is supported on vectors,\n where the keys will be the ordinals.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6925), lang.NewKeyword("end-line"), int(6925))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core.protocols")) +v7 := v6.FindInternedVar(lang.NewSymbol("kv-reduce")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v5, v3, v4}) +return v9 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// supers +{ +v0 := lang.NewSymbol("supers").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("class"))), lang.NewKeyword("doc"), "Returns the immediate and indirect superclasses and interfaces of c, if any", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5575), lang.NewKeyword("end-line"), int(5575))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("set")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("bases")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v3}) +v12 := lang.Apply(v7, []any{v11}) +var v4 any = v12 +_ = v4 +var v13 any = v4 +_ = v13 +var v14 any +for { +var v15 any +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("seq")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v13}) +if lang.IsTruthy(v19) { +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("first")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v13}) +var v20 any = v24 +_ = v20 +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("bases")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.Apply(v28, []any{v20}) +var v25 any = v29 +_ = v25 +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("into1")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v4, v25}) +var v31 any = v35 +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("into1")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("disj")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v13, v20}) +v44 := lang.Apply(v39, []any{v43, v25}) +var v36 any = v44 +v4 = v31 +v13 = v36 +continue +} else { +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("not-empty")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.Apply(v22, []any{v4}) +v15 = v23 +} +v14 = v15 + break +} +return v14 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// update-vals +{ +v0 := lang.NewSymbol("update-vals").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("f"))), lang.NewKeyword("doc"), "m f => {k (f v) ...}\n\n Given a map m and a function f of 1-argument, returns a new map where the keys of m\n are mapped to result of applying f to the corresponding values of m.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7943), lang.NewKeyword("end-line"), int(7943))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("with-meta")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("persistent!")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("reduce-kv")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +var v14 lang.FnFunc +v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v15 := args[0] +v16 := args[1] +v17 := args[2] +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("assoc!")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v4, []any{v17}) +v22 := lang.Apply(v20, []any{v15, v16, v21}) +return v22 +}) +v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7952), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(7952), lang.NewKeyword("end-column"), int(51)) +v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v17 any +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("instance?")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, []any{lang1.IEditableCollection, v3}) +if lang.IsTruthy(v21) { +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("transient")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v3}) +v17 = v25 +} else { +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("transient")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.NewMap() +v30 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7955), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(7955), lang.NewKeyword("end-column"), int(31)) +v31, err := lang.WithMeta(v29, v30.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v32 := lang.Apply(v28, []any{v31}) +v17 = v32 +} +v33 := lang.Apply(v13, []any{v16, v17, v3}) +v34 := lang.Apply(v10, []any{v33}) +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("meta")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v37, []any{v3}) +v39 := lang.Apply(v7, []any{v34, v38}) +return v39 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// vreset! +{ +v0 := lang.NewSymbol("vreset!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("vol"), lang.NewSymbol("newval"))), lang.NewKeyword("doc"), "Sets the value of volatile to newval without regard for the\n current value. Returns newval.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2524), lang.NewKeyword("end-line"), int(2524))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5, _ := lang.FieldOrMethod(v3, "reset") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// deref-as-map +{ +v0 := lang.NewSymbol("deref-as-map").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(408), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(408), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{lang1.IPending, v3}) +var v5 any = v9 +_ = v5 +var v11 any +if lang.IsTruthy(v5) { +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("not")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15, ok := lang.FieldOrMethod(v3, "isRealized") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "isRealized"))) +} +var v16 any +switch reflect.TypeOf(v15).Kind() { +case reflect.Func: + v16 = lang.Apply(v15, nil) +default: + v16 = v15 +} +v17 := lang.Apply(v14, []any{v16}) +v11 = v17 +} else { +v11 = v5 +} +var v4 any = v11 +_ = v4 +var v6 any +if lang.IsTruthy(v4) { +v6 = nil +} else { +var v7 any +func() { +defer func() { +if r := recover(); r != nil { +if lang.CatchMatches(r, lang1.Throwable) { +v8 := r +_ = v8 +v9 := lang.NewVector(true, v8) +v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(415), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(415), lang.NewKeyword("end-column"), int(25)) +v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v7 = v11 +} else { +panic(r) +} +} +}() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("deref")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v3}) +v12 := lang.NewVector(false, v11) +v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(413), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(413), lang.NewKeyword("end-column"), int(32)) +v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v7 = v14 +}() +v6 = v7 +} +var v5 any = v6 +_ = v5 +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("nth")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v5, int64(0), nil}) +var v15 any = v19 +_ = v15 +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("nth")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v5, int64(1), nil}) +var v20 any = v24 +_ = v20 +var v26 any +var v27 any = v15 +_ = v27 +var v29 any +if lang.IsTruthy(v27) { +v29 = v27 +} else { +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("instance?")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{lang1.*Agent, v3}) +var v30 any = v34 +_ = v30 +var v36 any +if lang.IsTruthy(v30) { +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("agent-error")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v3}) +v36 = v40 +} else { +v36 = v30 +} +v29 = v36 +} +if lang.IsTruthy(v29) { +v26 = lang.NewKeyword("failed") +} else { +var v27 any +if lang.IsTruthy(v4) { +v27 = lang.NewKeyword("pending") +} else { +var v28 any +if lang.IsTruthy(lang.NewKeyword("else")) { +v28 = lang.NewKeyword("ready") +} else { +v28 = nil +} +v27 = v28 +} +v26 = v27 +} +v29 := lang.NewMap(lang.NewKeyword("status"), v26, lang.NewKeyword("val"), v20) +v30 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(416), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(429), lang.NewKeyword("end-column"), int(14)) +v31, err := lang.WithMeta(v29, v30.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v31 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// cat +{ +v0 := lang.NewSymbol("cat").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rf"))), lang.NewKeyword("doc"), "A transducer which concatenates the contents of each input, which must be a\n collection, into the reduction.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7688), lang.NewKeyword("end-line"), int(7688))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("preserving-reduced")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +var v4 any = v8 +_ = v4 +var v10 lang.FnFunc +v10 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v11 := lang.Apply(v3, nil) +return v11 + case 1: +v11 := args[0] +v12 := lang.Apply(v3, []any{v11}) +return v12 + case 2: +v11 := args[0] +v12 := args[1] +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("reduce")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v4, v11, v12}) +return v16 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7694), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(7698), lang.NewKeyword("end-column"), int(36)) +v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v12 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// ex-data +{ +v0 := lang.NewSymbol("ex-data").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ex"))), lang.NewKeyword("doc"), "Returns exception data (a map) if ex is an IExceptionInfo.\n Otherwise returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4812), lang.NewKeyword("end-line"), int(4812))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{nil, v3}) +if lang.IsTruthy(v8) { +v9, ok := lang.FieldOrMethod(v3, "getData") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getData"))) +} +var v10 any +switch reflect.TypeOf(v9).Kind() { +case reflect.Func: + v10 = lang.Apply(v9, nil) +default: + v10 = v9 +} +v4 = v10 +} else { +v4 = nil +} +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// last +{ +v0 := lang.NewSymbol("last").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return the last item in coll, in linear time", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(262), lang.NewKeyword("end-line"), int(266))).(*lang.Symbol) +var v2 lang.FnFunc +{ // function last +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +recur_loop_32: +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("next")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v4}) +if lang.IsTruthy(v9) { +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("next")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v4}) +var v10 any = v14 +v4 = v10 +goto recur_loop_32 +} else { +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("first")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v4}) +v5 = v18 +} +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(266), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(269), lang.NewKeyword("end-column"), int(21))).(lang.FnFunc) +v3 := v2 +_ = v3 +} +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// newline +{ +v0 := lang.NewSymbol("newline").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Writes a platform-specific newline to *out*", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3698), lang.NewKeyword("end-line"), int(3698))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v4 := v3.FindInternedVar(lang.NewSymbol("*out*")) +if v4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) +} +v5 := v4.Get() +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("system-newline")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(lang1.AppendWriter, []any{v5, v8}) +_ = v9 +return nil +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// not= +{ +v1 := reflect.TypeOf(false) +v0 := lang.NewSymbol("not=").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Same as (not (= obj1 obj2))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(812), lang.NewKeyword("end-line"), int(812))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v4 := args[0] +return false + case 2: +v4 := args[0] +v5 := args[1] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("not")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("=")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v4, v5}) +v13 := lang.Apply(v8, []any{v12}) +return v13 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := args[1] +v6 := lang.NewList(args[2:]...) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("not")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("apply")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("=")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v12, []any{v15, v4, v5, v6}) +v17 := lang.Apply(v9, []any{v16}) +return v17 + } +}) +v4 := reflect.TypeOf(false) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// char +{ +var v1 lang.FnFunc +{ // function char__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +var v30 any +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +if lang.IsTruthy(v33) { +v30 = lang.NewSymbol("uncheckedCharCast") +} else { +v30 = lang.NewSymbol("charCast") +} +v34 := lang.Apply(v29, []any{v30}) +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("list")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v37, []any{v3}) +v39 := lang.Apply(v26, []any{v34, v38}) +v40 := lang.Apply(v23, []any{v39}) +v41 := lang.Apply(v20, []any{v40}) +v42 := lang.Apply(v9, []any{v13, v17, v41}) +v43 := lang.Apply(v6, []any{v42}) +return v43 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("char").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to char", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3511), lang.NewKeyword("end-line"), int(3511))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5, _ := lang.FieldOrMethod(runtime3.RT, "CharCast") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("CharCast is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// read+string +{ +v0 := lang.NewSymbol("read+string").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("stream")), lang.NewVector(lang.NewSymbol("stream"), lang.NewSymbol("eof-error?"), lang.NewSymbol("eof-value")), lang.NewVector(lang.NewSymbol("stream"), lang.NewSymbol("eof-error?"), lang.NewSymbol("eof-value"), lang.NewSymbol("recursive?")), lang.NewVector(lang.NewSymbol("opts"), lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Like read, and taking the same args. stream must be a LineNumberingPushbackReader.\n Returns a vector containing the object read and the (whitespace-trimmed) string read.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3771), lang.NewKeyword("end-line"), int(3771))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v4 := v3.FindInternedVar(lang.NewSymbol("read+string")) +if v4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) +} +v5 := v4.Get() +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("*in*")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v5, []any{v8}) +return v9 + case 1: +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("read+string")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{v3, true, nil}) +return v7 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("read+string")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v3, v4, v5, false}) +return v9 + case 4: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +var v7 any +func() { +defer func() { +if r := recover(); r != nil { +if lang.CatchMatches(r, lang1.Throwable) { +v8 := r +_ = v8 +v9, ok := lang.FieldOrMethod(v3, "getString") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getString"))) +} +var v10 any +switch reflect.TypeOf(v9).Kind() { +case reflect.Func: + v10 = lang.Apply(v9, nil) +default: + v10 = v9 +} +_ = v10 +panic(v8) +} else { +panic(r) +} +} +}() +v8, ok := lang.FieldOrMethod(v3, "captureString") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "captureString"))) +} +var v9 any +switch reflect.TypeOf(v8).Kind() { +case reflect.Func: + v9 = lang.Apply(v8, nil) +default: + v9 = v8 +} +_ = v9 +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("read")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v3, v4, v5, v6}) +var v10 any = v14 +_ = v10 +v16, ok := lang.FieldOrMethod(v3, "getString") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getString"))) +} +var v17 any +switch reflect.TypeOf(v16).Kind() { +case reflect.Func: + v17 = lang.Apply(v16, nil) +default: + v17 = v16 +} +v18, ok := lang.FieldOrMethod(v17, "trim") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v17, "trim"))) +} +var v19 any +switch reflect.TypeOf(v18).Kind() { +case reflect.Func: + v19 = lang.Apply(v18, nil) +default: + v19 = v18 +} +var v15 any = v19 +_ = v15 +v21 := lang.NewVector(v10, v15) +v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3783), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(3783), lang.NewKeyword("end-column"), int(12)) +v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v7 = v23 +}() +return v7 + case 2: +v3 := args[0] +v4 := args[1] +var v5 any +func() { +defer func() { +if r := recover(); r != nil { +if lang.CatchMatches(r, lang1.Throwable) { +v6 := r +_ = v6 +v7, ok := lang.FieldOrMethod(v4, "getString") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "getString"))) +} +var v8 any +switch reflect.TypeOf(v7).Kind() { +case reflect.Func: + v8 = lang.Apply(v7, nil) +default: + v8 = v7 +} +_ = v8 +panic(v6) +} else { +panic(r) +} +} +}() +v6, ok := lang.FieldOrMethod(v4, "captureString") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "captureString"))) +} +var v7 any +switch reflect.TypeOf(v6).Kind() { +case reflect.Func: + v7 = lang.Apply(v6, nil) +default: + v7 = v6 +} +_ = v7 +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("read")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v3, v4}) +var v8 any = v12 +_ = v8 +v14, ok := lang.FieldOrMethod(v4, "getString") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "getString"))) +} +var v15 any +switch reflect.TypeOf(v14).Kind() { +case reflect.Func: + v15 = lang.Apply(v14, nil) +default: + v15 = v14 +} +v16, ok := lang.FieldOrMethod(v15, "trim") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v15, "trim"))) +} +var v17 any +switch reflect.TypeOf(v16).Kind() { +case reflect.Func: + v17 = lang.Apply(v16, nil) +default: + v17 = v16 +} +var v13 any = v17 +_ = v13 +v19 := lang.NewVector(v8, v13) +v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3792), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(3792), lang.NewKeyword("end-column"), int(12)) +v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v5 = v21 +}() +return v5 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// root-resource +{ +v1 := reflect.TypeOf("") +v0 := lang.NewSymbol("root-resource").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"))), lang.NewKeyword("doc"), "Returns the root directory path for a lib", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5907), lang.NewKeyword("end-line"), int(5907), lang.NewKeyword("private"), true)).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("str")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("name")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v4}) +v12 := lang.Apply(strings22.ReplaceAll, []any{v11, "-", "_"}) +v13 := lang.Apply(strings22.ReplaceAll, []any{v12, ".", "/"}) +v14 := lang.Apply(v7, []any{lang.NewChar(47), v13}) +return v14 +}) +v4 := reflect.TypeOf("") +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// vector +{ +v0 := lang.NewSymbol("vector").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("a")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d"), lang.NewSymbol("e")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d"), lang.NewSymbol("e"), lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d"), lang.NewSymbol("e"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Creates a new vector containing the args.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(352), lang.NewKeyword("end-line"), int(352))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v3 := lang.NewVector() +v4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(356), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(356), lang.NewKeyword("end-column"), int(8)) +v5, err := lang.WithMeta(v3, v4.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v5 + case 1: +v3 := args[0] +v4 := lang.NewVector(v3) +v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(357), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(357), lang.NewKeyword("end-column"), int(10)) +v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v6 + case 2: +v3 := args[0] +v4 := args[1] +v5 := lang.NewVector(v3, v4) +v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(358), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(358), lang.NewKeyword("end-column"), int(14)) +v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v7 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewVector(v3, v4, v5) +v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(359), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(359), lang.NewKeyword("end-column"), int(18)) +v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v8 + case 4: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := lang.NewVector(v3, v4, v5, v6) +v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(360), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(360), lang.NewKeyword("end-column"), int(22)) +v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v9 + case 5: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := args[4] +v8 := lang.NewVector(v3, v4, v5, v6, v7) +v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(361), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(361), lang.NewKeyword("end-column"), int(25)) +v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v10 + case 6: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := args[4] +v8 := args[5] +v9 := lang.NewVector(v3, v4, v5, v6, v7, v8) +v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(362), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(362), lang.NewKeyword("end-column"), int(29)) +v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v11 + default: + if len(args) < 6 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := args[4] +v8 := args[5] +v9 := lang.NewList(args[6:]...) +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("cons")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("cons")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("cons")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("cons")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("cons")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("cons")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.Apply(v27, []any{v8, v9}) +v29 := lang.Apply(v24, []any{v7, v28}) +v30 := lang.Apply(v21, []any{v6, v29}) +v31 := lang.Apply(v18, []any{v5, v30}) +v32 := lang.Apply(v15, []any{v4, v31}) +v33 := lang.Apply(v12, []any{v3, v32}) +v34 := lang.Apply(lang1.CreateLazilyPersistentVector, []any{v33}) +return v34 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// gen-class +{ +v0 := lang.NewSymbol("gen-class").WithMeta(lang.NewMap()).(*lang.Symbol) +v1 := ns.Intern(v0) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// lazy-cat +{ +v0 := lang.NewSymbol("lazy-cat").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Expands to code which yields a lazy sequence of the concatenation\n of the supplied colls. Each coll expr is not evaluated until it is\n needed. \n\n (lazy-cat xs ys zs) === (concat (lazy-seq xs) (lazy-seq ys) (lazy-seq zs))", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4636), lang.NewKeyword("end-line"), int(4636))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("seq")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("concat")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("list")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{lang.NewSymbol("glojure.core/concat")}) +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("map")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +var v19 lang.FnFunc +v19 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v20 := args[0] +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("list")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(v23, []any{lang.NewSymbol("glojure.core/lazy-seq"), v20}) +return v24 +}) +v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4644), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(4644), lang.NewKeyword("end-column"), int(37)) +v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v22 := lang.Apply(v18, []any{v21, v5}) +v23 := lang.Apply(v11, []any{v15, v22}) +v24 := lang.Apply(v8, []any{v23}) +return v24 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// -> +{ +v0 := lang.NewSymbol("->").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "Threads the expr through the forms. Inserts x as the\n second item in the first form, making a list of it if it is not a\n list already. If there are more forms, inserts the first form as the\n second item in second form, etc.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1675), lang.NewKeyword("end-line"), int(1675))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +var v7 any = v7 +_ = v7 +var v8 any = v8 +_ = v8 +var v9 any +for { +var v10 any +if lang.IsTruthy(v8) { +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("first")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v8}) +var v11 any = v15 +_ = v11 +var v17 any +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("seq?")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, []any{v11}) +if lang.IsTruthy(v21) { +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("with-meta")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("seq")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("concat")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("first")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.Apply(v36, []any{v11}) +v38 := lang.Apply(v33, []any{v37}) +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("list")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +} +v41 := v40.Get() +v42 := lang.Apply(v41, []any{v7}) +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("next")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +} +v45 := v44.Get() +v46 := lang.Apply(v45, []any{v11}) +v47 := lang.Apply(v30, []any{v38, v42, v46}) +v48 := lang.Apply(v27, []any{v47}) +v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v50 := v49.FindInternedVar(lang.NewSymbol("meta")) +if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) +} +v51 := v50.Get() +v52 := lang.Apply(v51, []any{v11}) +v53 := lang.Apply(v24, []any{v48, v52}) +v17 = v53 +} else { +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("list")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +} +v56 := v55.Get() +v57 := lang.Apply(v56, []any{v11, v7}) +v17 = v57 +} +var v16 any = v17 +_ = v16 +var v59 any = v16 +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("next")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +} +v63 := v62.Get() +v64 := lang.Apply(v63, []any{v8}) +var v60 any = v64 +v7 = v59 +v8 = v60 +continue +} else { +v10 = v7 +} +v9 = v10 + break +} +return v9 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// Throwable->map +{ +v0 := lang.NewSymbol("Throwable->map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"))), lang.NewKeyword("doc"), "Constructs a data representation for a Throwable with keys:\n :cause - root cause message\n :phase - error phase\n :via - cause chain, with cause keys:\n :type - exception class symbol\n :message - exception message\n :data - ex-data\n :at - top stack element\n :trace - root cause stack elements", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(442), lang.NewKeyword("end-line"), int(442))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +var v5 lang.FnFunc +v5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v6 := args[0] +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("merge")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("symbol")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("class")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v6}) +v17, ok := lang.FieldOrMethod(v16, "Name") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v16, "Name"))) +} +var v18 any +switch reflect.TypeOf(v17).Kind() { +case reflect.Func: + v18 = lang.Apply(v17, nil) +default: + v18 = v17 +} +v19 := lang.Apply(v12, []any{v18}) +v20 := lang.NewMap(lang.NewKeyword("type"), v19) +v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(455), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(455), lang.NewKeyword("end-column"), int(56)) +v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v24, ok := lang.FieldOrMethod(v6, "getLocalizedMessage") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "getLocalizedMessage"))) +} +var v25 any +switch reflect.TypeOf(v24).Kind() { +case reflect.Func: + v25 = lang.Apply(v24, nil) +default: + v25 = v24 +} +var v23 any = v25 +_ = v23 +var v27 any +if lang.IsTruthy(v23) { +var v28 any = v23 +_ = v28 +v30 := lang.NewMap(lang.NewKeyword("message"), v28) +v31 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(457), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(457), lang.NewKeyword("end-column"), int(33)) +v32, err := lang.WithMeta(v30, v31.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v27 = v32 +} else { +v27 = nil +} +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("ex-data")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v6}) +var v23 any = v27 +_ = v23 +var v29 any +if lang.IsTruthy(v23) { +var v30 any = v23 +_ = v30 +v32 := lang.NewMap(lang.NewKeyword("data"), v30) +v33 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(459), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(459), lang.NewKeyword("end-column"), int(29)) +v34, err := lang.WithMeta(v32, v33.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v29 = v34 +} else { +v29 = nil +} +v24, ok := lang.FieldOrMethod(v6, "getStackTrace") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "getStackTrace"))) +} +var v25 any +switch reflect.TypeOf(v24).Kind() { +case reflect.Func: + v25 = lang.Apply(v24, nil) +default: + v25 = v24 +} +var v23 any = v25 +_ = v23 +var v27 any +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("pos?")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("alength")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v23}) +v35 := lang.Apply(v30, []any{v34}) +if lang.IsTruthy(v35) { +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("StackTraceElement->vec")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("aget")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +} +v41 := v40.Get() +v42 := lang.Apply(v41, []any{v23, int64(0)}) +v43 := lang.Apply(v38, []any{v42}) +v44 := lang.NewMap(lang.NewKeyword("at"), v43) +v45 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(462), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(462), lang.NewKeyword("end-column"), int(63)) +v46, err := lang.WithMeta(v44, v45.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v27 = v46 +} else { +v27 = nil +} +v23 := lang.Apply(v9, []any{v22, v27, v29, v27}) +return v23 +}) +v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(454), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(462), lang.NewKeyword("end-column"), int(67)) +v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v4 any = v7 +_ = v4 +v10 := lang.NewVector() +v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(463), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(463), lang.NewKeyword("end-column"), int(25)) +v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v9 any = v12 +_ = v9 +var v13 any = v3 +_ = v13 +var v14 any +for { +var v15 any +if lang.IsTruthy(v13) { +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("conj")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v9, v13}) +var v16 any = v20 +v22, ok := lang.FieldOrMethod(v13, "getCause") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v13, "getCause"))) +} +var v23 any +switch reflect.TypeOf(v22).Kind() { +case reflect.Func: + v23 = lang.Apply(v22, nil) +default: + v23 = v22 +} +var v21 any = v23 +v9 = v16 +v13 = v21 +continue +} else { +v15 = v9 +} +v14 = v15 + break +} +var v8 any = v14 +_ = v8 +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("peek")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{v8}) +var v9 any = v13 +_ = v9 +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("merge")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("vec")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("map")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v4, v8}) +v25 := lang.Apply(v20, []any{v24}) +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("vec")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("map")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("StackTraceElement->vec")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +var v35 any = v9 +_ = v35 +var v37 any +if lang.IsTruthy(v35) { +v37 = v35 +} else { +v37 = v3 +} +v35, ok := lang.FieldOrMethod(v37, "getStackTrace") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v37, "getStackTrace"))) +} +var v36 any +switch reflect.TypeOf(v35).Kind() { +case reflect.Func: + v36 = lang.Apply(v35, nil) +default: + v36 = v35 +} +v37 := lang.Apply(v31, []any{v34, v36}) +v38 := lang.Apply(v28, []any{v37}) +v39 := lang.NewMap(lang.NewKeyword("via"), v25, lang.NewKeyword("trace"), v38) +v40 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(468), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(470), lang.NewKeyword("end-column"), int(111)) +v41, err := lang.WithMeta(v39, v40.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v43, ok := lang.FieldOrMethod(v9, "getLocalizedMessage") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v9, "getLocalizedMessage"))) +} +var v44 any +switch reflect.TypeOf(v43).Kind() { +case reflect.Func: + v44 = lang.Apply(v43, nil) +default: + v44 = v43 +} +var v42 any = v44 +_ = v42 +var v46 any +if lang.IsTruthy(v42) { +var v47 any = v42 +_ = v47 +v49 := lang.NewMap(lang.NewKeyword("cause"), v47) +v50 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(472), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(472), lang.NewKeyword("end-column"), int(25)) +v51, err := lang.WithMeta(v49, v50.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v46 = v51 +} else { +v46 = nil +} +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("ex-data")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +} +v45 := v44.Get() +v46 := lang.Apply(v45, []any{v9}) +var v42 any = v46 +_ = v42 +var v48 any +if lang.IsTruthy(v42) { +var v49 any = v42 +_ = v49 +v51 := lang.NewMap(lang.NewKeyword("data"), v49) +v52 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(474), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(474), lang.NewKeyword("end-column"), int(20)) +v53, err := lang.WithMeta(v51, v52.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v48 = v53 +} else { +v48 = nil +} +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("ex-data")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +} +v45 := v44.Get() +v46 := lang.Apply(v45, []any{v3}) +v47 := lang.Apply(lang.NewKeyword("glojure.error/phase"), []any{v46}) +var v42 any = v47 +_ = v42 +var v49 any +if lang.IsTruthy(v42) { +var v50 any = v42 +_ = v50 +v52 := lang.NewMap(lang.NewKeyword("phase"), v50) +v53 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(476), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(476), lang.NewKeyword("end-column"), int(22)) +v54, err := lang.WithMeta(v52, v53.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v49 = v54 +} else { +v49 = nil +} +v42 := lang.Apply(v17, []any{v41, v46, v48, v49}) +return v42 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// unsigned-bit-shift-right +{ +var v1 lang.FnFunc +{ // function unsigned-bit-shift-right__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("concat")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("list")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("seq")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("concat")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("list")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/unsignedShiftRight")}) +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v4}) +v40 := lang.Apply(v27, []any{v31, v35, v39}) +v41 := lang.Apply(v24, []any{v40}) +v42 := lang.Apply(v21, []any{v41}) +v43 := lang.Apply(v10, []any{v14, v18, v42}) +v44 := lang.Apply(v7, []any{v43}) +return v44 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("unsigned-bit-shift-right").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Bitwise shift right, without sign-extension.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(30), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1373), lang.NewKeyword("end-line"), int(1373))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := args[1] +v6, _ := lang.FieldOrMethod(lang1.Numbers, "unsignedShiftRight") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unsignedShiftRight is not a function"))) +} +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// extend-type +{ +v0 := lang.NewSymbol("extend-type").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("t"), lang.NewSymbol("&"), lang.NewSymbol("specs"))), lang.NewKeyword("doc"), "A macro that expands into an extend call. Useful when you are\n supplying the definitions explicitly inline, extend-type\n automatically creates the maps required by extend. Propagates the\n class as a type hint on the first argument of all fns.\n\n (extend-type MyType \n Countable\n (cnt [c] ...)\n Foo\n (bar [x y] ...)\n (baz ([x] ...) ([x y & zs] ...)))\n\n expands into:\n\n (extend MyType\n Countable\n {:cnt (fn [c] ...)}\n Foo\n {:baz (fn ([x] ...) ([x y & zs] ...))\n :bar (fn [x y] ...)})", lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(180), lang.NewKeyword("end-line"), int(180))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("emit-extend-type")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v5, v6}) +return v10 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// take +{ +v0 := lang.NewSymbol("take").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the first n items in coll, or all items if\n there are fewer than n. Returns a stateful transducer when\n no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2853), lang.NewKeyword("end-line"), int(2853))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("volatile!")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v3}) +var v6 any = v10 +_ = v6 +var v12 lang.FnFunc +v12 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v13 := lang.Apply(v5, nil) +return v13 + case 1: +v13 := args[0] +v14 := lang.Apply(v5, []any{v13}) +return v14 + case 2: +v13 := args[0] +v14 := args[1] +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("deref")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v6}) +var v15 any = v19 +_ = v15 +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("dec")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24, ok := lang.FieldOrMethod(v6, "Deref") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "Deref"))) +} +var v25 any +switch reflect.TypeOf(v24).Kind() { +case reflect.Func: + v25 = lang.Apply(v24, nil) +default: + v25 = v24 +} +v26 := lang.Apply(v23, []any{v25}) +v27, _ := lang.FieldOrMethod(v6, "reset") +if reflect.TypeOf(v27).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) +} +v28 := lang.Apply(v27, []any{v26}) +var v20 any = v28 +_ = v20 +var v30 any +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("pos?")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v15}) +if lang.IsTruthy(v34) { +v35 := lang.Apply(v5, []any{v29, v14}) +v30 = v35 +} else { +v30 = v29 +} +var v29 any = v30 +_ = v29 +var v37 any +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("not")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("pos?")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v20}) +v45 := lang.Apply(v40, []any{v44}) +if lang.IsTruthy(v45) { +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("ensure-reduced")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +} +v48 := v47.Get() +v49 := lang.Apply(v48, []any{v29}) +v37 = v49 +} else { +v37 = v29 +} +return v37 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2862), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(2873), lang.NewKeyword("end-column"), int(28)) +v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v14 +}) +v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2860), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2873), lang.NewKeyword("end-column"), int(30)) +v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v6 + case 2: +v3 := args[0] +v4 := args[1] +var v5 lang.FnFunc +v5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +var v6 any +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("pos?")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v3}) +if lang.IsTruthy(v10) { +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("seq")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v4}) +var v11 any = v15 +_ = v11 +var v17 any +if lang.IsTruthy(v11) { +var v18 any = v11 +_ = v18 +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("cons")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("first")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{v18}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("take")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("dec")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.Apply(v32, []any{v3}) +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("rest")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.Apply(v36, []any{v18}) +v38 := lang.Apply(v29, []any{v33, v37}) +v39 := lang.Apply(v22, []any{v26, v38}) +v17 = v39 +} else { +v17 = nil +} +v6 = v17 +} else { +v6 = nil +} +return v6 +}) +v6 := lang.Apply(lang1.NewLazySeq, []any{v5}) +return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// *read-eval* +{ +v0 := lang.NewSymbol("*read-eval*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "Defaults to true (or value specified by system property, see below)\n ***This setting implies that the full power of the reader is in play,\n including syntax that can cause code to execute. It should never be\n used with untrusted sources. See also: glojure.edn/read.***\n\n When set to logical false in the thread-local binding,\n the eval reader (#=) and record/type literal syntax are disabled in read/load.\n Example (will fail): (binding [*read-eval* false] (read-string \"#=(* 2 21)\"))\n\n The default binding can be controlled by the system property\n 'glojure.read.eval' System properties can be set on the command line\n like this:\n\n java -Dglojure.read.eval=false ...\n\n The system property can also be set to 'unknown' via\n -Dglojure.read.eval=unknown, in which case the default binding\n is :unknown and all reads will fail in contexts where *read-eval*\n has not been explicitly bound to either true or false. This setting\n can be a useful diagnostic tool to ensure that all of your reads\n occur in considered contexts. You can also accomplish this in a\n particular scope by binding *read-eval* to :unknown\n ", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, nil, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// trampoline +{ +v0 := lang.NewSymbol("trampoline").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "trampoline can be used to convert algorithms requiring mutual\n recursion without stack consumption. Calls f with supplied args, if\n any. If f returns a fn, calls that fn with no arguments, and\n continues to repeat, until the return value is not a fn, then\n returns that non-fn value. Note that if you want to return a fn as a\n final value, you must wrap it in some data structure and unpack it\n after trampoline returns.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6336), lang.NewKeyword("end-line"), int(6336))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +recur_loop_1083: +v5 := lang.Apply(v3, nil) +var v4 any = v5 +_ = v4 +var v7 any +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("fn?")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v4}) +if lang.IsTruthy(v11) { +var v12 any = v4 +v3 = v12 +goto recur_loop_1083 +} else { +v7 = v4 +} +return v7 + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.NewList(args[1:]...) +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("trampoline")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +var v8 lang.FnFunc +v8 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("apply")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v3, v4}) +return v12 +}) +v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6352), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(6352), lang.NewKeyword("end-column"), int(32)) +v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v11 := lang.Apply(v7, []any{v10}) +return v11 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// val +{ +v0 := lang.NewSymbol("val").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("e"))), lang.NewKeyword("doc"), "Returns the value in the map entry.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1570), lang.NewKeyword("end-line"), int(1570))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, _ := lang.FieldOrMethod(v3, "GetValue") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("GetValue is not a function"))) +} +v5 := lang.Apply(v4, []any{}) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// split-with +{ +v0 := lang.NewSymbol("split-with").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a vector of [(take-while pred coll) (drop-while pred coll)]", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2990), lang.NewKeyword("end-line"), int(2990))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("take-while")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3, v4}) +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("drop-while")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v3, v4}) +v13 := lang.NewVector(v8, v12) +v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2995), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2995), lang.NewKeyword("end-column"), int(51)) +v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v15 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// for +{ +v0 := lang.NewSymbol("for").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("seq-exprs"), lang.NewSymbol("body-expr"))), lang.NewKeyword("doc"), "List comprehension. Takes a vector of one or more\n binding-form/collection-expr pairs, each followed by zero or more\n modifiers, and yields a lazy sequence of evaluations of expr.\n Collections are iterated in a nested fashion, rightmost fastest,\n and nested coll-exprs can refer to bindings created in prior\n binding-forms. Supported modifiers are: :let [binding-form expr ...],\n :while test, :when test.\n\n (take 100 (for [x (range 100000000) y (range 1000000) :while (< y x)] [x y]))", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4646), lang.NewKeyword("end-line"), int(4646))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +var v7 any +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v5}) +if lang.IsTruthy(v11) { +v7 = nil +} else { +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("str")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("first")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v3}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("meta")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v3}) +v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) +v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) +v28 := lang.Apply(lang1.NewIllegalArgumentError, []any{v27}) +panic(v28) +} +_ = v7 +var v29 any +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("even?")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("count")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v5}) +v37 := lang.Apply(v32, []any{v36}) +if lang.IsTruthy(v37) { +v29 = nil +} else { +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("str")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("first")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v3}) +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +} +v47 := v46.Get() +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("meta")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v3}) +v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) +v53 := lang.Apply(v40, []any{v44, " requires ", "an even number of forms in binding vector", " in ", v47, ":", v52}) +v54 := lang.Apply(lang1.NewIllegalArgumentError, []any{v53}) +panic(v54) +} +_ = v29 +_ = nil +var v56 lang.FnFunc +v56 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v57 := args[0] +v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v59 := v58.FindInternedVar(lang.NewSymbol("reduce1")) +if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) +} +v60 := v59.Get() +var v61 lang.FnFunc +v61 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v62 := args[0] +v63 := args[1] +var v64 any = v63 +_ = v64 +v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v67 := v66.FindInternedVar(lang.NewSymbol("nth")) +if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) +} +v68 := v67.Get() +v69 := lang.Apply(v68, []any{v64, int64(0), nil}) +var v65 any = v69 +_ = v65 +v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v72 := v71.FindInternedVar(lang.NewSymbol("nth")) +if v72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) +} +v73 := v72.Get() +v74 := lang.Apply(v73, []any{v64, int64(1), nil}) +var v70 any = v74 +_ = v70 +var v76 any +v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v78 := v77.FindInternedVar(lang.NewSymbol("keyword?")) +if v78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) +} +v79 := v78.Get() +v80 := lang.Apply(v79, []any{v65}) +if lang.IsTruthy(v80) { +v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v82 := v81.FindInternedVar(lang.NewSymbol("conj")) +if v82.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) +} +v83 := v82.Get() +v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v85 := v84.FindInternedVar(lang.NewSymbol("pop")) +if v85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) +} +v86 := v85.Get() +v87 := lang.Apply(v86, []any{v62}) +v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v89 := v88.FindInternedVar(lang.NewSymbol("conj")) +if v89.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) +} +v90 := v89.Get() +v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v92 := v91.FindInternedVar(lang.NewSymbol("peek")) +if v92.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) +} +v93 := v92.Get() +v94 := lang.Apply(v93, []any{v62}) +v95 := lang.NewVector(v65, v70) +v96 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4664), lang.NewKeyword("column"), int(72), lang.NewKeyword("end-line"), int(4664), lang.NewKeyword("end-column"), int(76)) +v97, err := lang.WithMeta(v95, v96.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v98 := lang.Apply(v90, []any{v94, v97}) +v99 := lang.Apply(v83, []any{v87, v98}) +v76 = v99 +} else { +v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v101 := v100.FindInternedVar(lang.NewSymbol("conj")) +if v101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) +} +v102 := v101.Get() +v103 := lang.NewVector(v65, v70) +v104 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4665), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(4665), lang.NewKeyword("end-column"), int(50)) +v105, err := lang.WithMeta(v103, v104.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v106 := lang.Apply(v102, []any{v62, v105}) +v76 = v106 +} +return v76 +}) +v62 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4662), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(4665), lang.NewKeyword("end-column"), int(53)) +v63, err := lang.WithMeta(v61, v62.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v64 := lang.NewVector() +v65 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4666), lang.NewKeyword("column"), int(29), lang.NewKeyword("end-line"), int(4666), lang.NewKeyword("end-column"), int(30)) +v66, err := lang.WithMeta(v64, v65.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v68 := v67.FindInternedVar(lang.NewSymbol("partition")) +if v68.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) +} +v69 := v68.Get() +v70 := lang.Apply(v69, []any{int64(2), v57}) +v71 := lang.Apply(v60, []any{v63, v66, v70}) +return v71 +}) +v57 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4661), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(4666), lang.NewKeyword("end-column"), int(56)) +v58, err := lang.WithMeta(v56, v57.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v55 any = v58 +_ = v55 +var v60 lang.FnFunc +v60 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v61 := lang.NewList(args[0:]...) +v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v63 := v62.FindInternedVar(lang.NewSymbol("apply")) +if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +} +v64 := v63.Get() +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("str")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +} +v67 := v66.Get() +v68 := lang.Apply(v64, []any{v67, v61}) +v69 := lang.Apply(lang1.NewIllegalArgumentError, []any{v68}) +panic(v69) + } +}) +v61 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4667), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(4667), lang.NewKeyword("end-column"), int(125)) +v62, err := lang.WithMeta(v60, v61.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v59 any = v62 +_ = v59 +var v64 lang.FnFunc +{ // function emit-bind +v64 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v66 := args[0] +var v67 any = v66 +_ = v67 +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("seq")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +} +v71 := v70.Get() +v72 := lang.Apply(v71, []any{v67}) +var v68 any = v72 +_ = v68 +v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v75 := v74.FindInternedVar(lang.NewSymbol("first")) +if v75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) +} +v76 := v75.Get() +v77 := lang.Apply(v76, []any{v68}) +var v73 any = v77 +_ = v73 +v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v80 := v79.FindInternedVar(lang.NewSymbol("next")) +if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) +} +v81 := v80.Get() +v82 := lang.Apply(v81, []any{v78}) +var v78 any = v82 +_ = v78 +var v83 any = v73 +_ = v83 +v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v86 := v85.FindInternedVar(lang.NewSymbol("seq")) +if v86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) +} +v87 := v86.Get() +v88 := lang.Apply(v87, []any{v83}) +var v84 any = v88 +_ = v84 +v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v91 := v90.FindInternedVar(lang.NewSymbol("first")) +if v91.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) +} +v92 := v91.Get() +v93 := lang.Apply(v92, []any{v84}) +var v89 any = v93 +_ = v89 +v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v96 := v95.FindInternedVar(lang.NewSymbol("next")) +if v96.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) +} +v97 := v96.Get() +v98 := lang.Apply(v97, []any{v94}) +var v94 any = v98 +_ = v94 +var v99 any = v89 +_ = v99 +v101 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v102 := v101.FindInternedVar(lang.NewSymbol("first")) +if v102.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v102))) +} +v103 := v102.Get() +v104 := lang.Apply(v103, []any{v94}) +var v100 any = v104 +_ = v100 +v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v107 := v106.FindInternedVar(lang.NewSymbol("next")) +if v107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) +} +v108 := v107.Get() +v109 := lang.Apply(v108, []any{v105}) +var v105 any = v109 +_ = v105 +var v110 any = v100 +_ = v110 +var v111 any = v105 +_ = v111 +var v112 any = v78 +_ = v112 +v114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v115 := v114.FindInternedVar(lang.NewSymbol("nth")) +if v115.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v115))) +} +v116 := v115.Get() +v117 := lang.Apply(v116, []any{v112, int64(0), nil}) +var v113 any = v117 +_ = v113 +v119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v120 := v119.FindInternedVar(lang.NewSymbol("nth")) +if v120.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v120))) +} +v121 := v120.Get() +v122 := lang.Apply(v121, []any{v113, int64(0), nil}) +var v118 any = v122 +_ = v118 +v124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v125 := v124.FindInternedVar(lang.NewSymbol("nth")) +if v125.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v125))) +} +v126 := v125.Get() +v127 := lang.Apply(v126, []any{v113, int64(1), nil}) +var v123 any = v127 +_ = v123 +var v128 any = v112 +_ = v128 +v131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v132 := v131.FindInternedVar(lang.NewSymbol("gensym")) +if v132.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v132))) +} +v133 := v132.Get() +v134 := lang.Apply(v133, []any{"iter__"}) +var v130 any = v134 +_ = v130 +v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v137 := v136.FindInternedVar(lang.NewSymbol("gensym")) +if v137.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) +} +v138 := v137.Get() +v139 := lang.Apply(v138, []any{"s__"}) +var v135 any = v139 +_ = v135 +var v141 lang.FnFunc +{ // function do-mod +v141 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v143 := args[0] +var v144 any = v143 +_ = v144 +v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v147 := v146.FindInternedVar(lang.NewSymbol("seq")) +if v147.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) +} +v148 := v147.Get() +v149 := lang.Apply(v148, []any{v144}) +var v145 any = v149 +_ = v145 +v151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v152 := v151.FindInternedVar(lang.NewSymbol("first")) +if v152.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v152))) +} +v153 := v152.Get() +v154 := lang.Apply(v153, []any{v145}) +var v150 any = v154 +_ = v150 +v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v157 := v156.FindInternedVar(lang.NewSymbol("next")) +if v157.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) +} +v158 := v157.Get() +v159 := lang.Apply(v158, []any{v155}) +var v155 any = v159 +_ = v155 +var v160 any = v150 +_ = v160 +v162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v163 := v162.FindInternedVar(lang.NewSymbol("nth")) +if v163.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v163))) +} +v164 := v163.Get() +v165 := lang.Apply(v164, []any{v160, int64(0), nil}) +var v161 any = v165 +_ = v161 +v167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v168 := v167.FindInternedVar(lang.NewSymbol("nth")) +if v168.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v168))) +} +v169 := v168.Get() +v170 := lang.Apply(v169, []any{v160, int64(1), nil}) +var v166 any = v170 +_ = v166 +var v171 any = v160 +_ = v171 +var v172 any = v155 +_ = v172 +var v174 any +v175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v176 := v175.FindInternedVar(lang.NewSymbol("=")) +if v176.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v176))) +} +v177 := v176.Get() +v178 := lang.Apply(v177, []any{v161, lang.NewKeyword("let")}) +if lang.IsTruthy(v178) { +v179 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v180 := v179.FindInternedVar(lang.NewSymbol("seq")) +if v180.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v180))) +} +v181 := v180.Get() +v182 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v183 := v182.FindInternedVar(lang.NewSymbol("concat")) +if v183.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v183))) +} +v184 := v183.Get() +v185 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v186 := v185.FindInternedVar(lang.NewSymbol("list")) +if v186.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v186))) +} +v187 := v186.Get() +v188 := lang.Apply(v187, []any{lang.NewSymbol("glojure.core/let")}) +v189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v190 := v189.FindInternedVar(lang.NewSymbol("list")) +if v190.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v190))) +} +v191 := v190.Get() +v192 := lang.Apply(v191, []any{v166}) +v193 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v194 := v193.FindInternedVar(lang.NewSymbol("list")) +if v194.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v194))) +} +v195 := v194.Get() +v196 := lang.Apply(v142, []any{v172}) +v197 := lang.Apply(v195, []any{v196}) +v198 := lang.Apply(v184, []any{v188, v192, v197}) +v199 := lang.Apply(v181, []any{v198}) +v174 = v199 +} else { +var v200 any +v201 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v202 := v201.FindInternedVar(lang.NewSymbol("=")) +if v202.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v202))) +} +v203 := v202.Get() +v204 := lang.Apply(v203, []any{v161, lang.NewKeyword("while")}) +if lang.IsTruthy(v204) { +v205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v206 := v205.FindInternedVar(lang.NewSymbol("seq")) +if v206.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v206))) +} +v207 := v206.Get() +v208 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v209 := v208.FindInternedVar(lang.NewSymbol("concat")) +if v209.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v209))) +} +v210 := v209.Get() +v211 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v212 := v211.FindInternedVar(lang.NewSymbol("list")) +if v212.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v212))) +} +v213 := v212.Get() +v214 := lang.Apply(v213, []any{lang.NewSymbol("glojure.core/when")}) +v215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v216 := v215.FindInternedVar(lang.NewSymbol("list")) +if v216.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v216))) +} +v217 := v216.Get() +v218 := lang.Apply(v217, []any{v166}) +v219 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v220 := v219.FindInternedVar(lang.NewSymbol("list")) +if v220.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v220))) +} +v221 := v220.Get() +v222 := lang.Apply(v142, []any{v172}) +v223 := lang.Apply(v221, []any{v222}) +v224 := lang.Apply(v210, []any{v214, v218, v223}) +v225 := lang.Apply(v207, []any{v224}) +v200 = v225 +} else { +var v226 any +v227 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v228 := v227.FindInternedVar(lang.NewSymbol("=")) +if v228.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v228))) +} +v229 := v228.Get() +v230 := lang.Apply(v229, []any{v161, lang.NewKeyword("when")}) +if lang.IsTruthy(v230) { +v231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v232 := v231.FindInternedVar(lang.NewSymbol("seq")) +if v232.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v232))) +} +v233 := v232.Get() +v234 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v235 := v234.FindInternedVar(lang.NewSymbol("concat")) +if v235.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v235))) +} +v236 := v235.Get() +v237 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v238 := v237.FindInternedVar(lang.NewSymbol("list")) +if v238.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v238))) +} +v239 := v238.Get() +v240 := lang.Apply(v239, []any{lang.NewSymbol("if")}) +v241 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v242 := v241.FindInternedVar(lang.NewSymbol("list")) +if v242.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v242))) +} +v243 := v242.Get() +v244 := lang.Apply(v243, []any{v166}) +v245 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v246 := v245.FindInternedVar(lang.NewSymbol("list")) +if v246.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v246))) +} +v247 := v246.Get() +v248 := lang.Apply(v142, []any{v172}) +v249 := lang.Apply(v247, []any{v248}) +v250 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v251 := v250.FindInternedVar(lang.NewSymbol("list")) +if v251.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v251))) +} +v252 := v251.Get() +v253 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v254 := v253.FindInternedVar(lang.NewSymbol("seq")) +if v254.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v254))) +} +v255 := v254.Get() +v256 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v257 := v256.FindInternedVar(lang.NewSymbol("concat")) +if v257.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v257))) +} +v258 := v257.Get() +v259 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v260 := v259.FindInternedVar(lang.NewSymbol("list")) +if v260.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v260))) +} +v261 := v260.Get() +v262 := lang.Apply(v261, []any{lang.NewSymbol("recur")}) +v263 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v264 := v263.FindInternedVar(lang.NewSymbol("list")) +if v264.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v264))) +} +v265 := v264.Get() +v266 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v267 := v266.FindInternedVar(lang.NewSymbol("seq")) +if v267.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v267))) +} +v268 := v267.Get() +v269 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v270 := v269.FindInternedVar(lang.NewSymbol("concat")) +if v270.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v270))) +} +v271 := v270.Get() +v272 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v273 := v272.FindInternedVar(lang.NewSymbol("list")) +if v273.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v273))) +} +v274 := v273.Get() +v275 := lang.Apply(v274, []any{lang.NewSymbol("glojure.core/rest")}) +v276 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v277 := v276.FindInternedVar(lang.NewSymbol("list")) +if v277.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v277))) +} +v278 := v277.Get() +v279 := lang.Apply(v278, []any{v135}) +v280 := lang.Apply(v271, []any{v275, v279}) +v281 := lang.Apply(v268, []any{v280}) +v282 := lang.Apply(v265, []any{v281}) +v283 := lang.Apply(v258, []any{v262, v282}) +v284 := lang.Apply(v255, []any{v283}) +v285 := lang.Apply(v252, []any{v284}) +v286 := lang.Apply(v236, []any{v240, v244, v249, v285}) +v287 := lang.Apply(v233, []any{v286}) +v226 = v287 +} else { +var v288 any +v289 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v290 := v289.FindInternedVar(lang.NewSymbol("keyword?")) +if v290.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v290))) +} +v291 := v290.Get() +v292 := lang.Apply(v291, []any{v161}) +if lang.IsTruthy(v292) { +v293 := lang.Apply(v59, []any{"Invalid 'for' keyword ", v161}) +v288 = v293 +} else { +var v294 any +if lang.IsTruthy(v128) { +v295 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v296 := v295.FindInternedVar(lang.NewSymbol("seq")) +if v296.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v296))) +} +v297 := v296.Get() +v298 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v299 := v298.FindInternedVar(lang.NewSymbol("concat")) +if v299.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v299))) +} +v300 := v299.Get() +v301 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v302 := v301.FindInternedVar(lang.NewSymbol("list")) +if v302.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v302))) +} +v303 := v302.Get() +v304 := lang.Apply(v303, []any{lang.NewSymbol("glojure.core/let")}) +v305 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v306 := v305.FindInternedVar(lang.NewSymbol("list")) +if v306.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v306))) +} +v307 := v306.Get() +v308 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v309 := v308.FindInternedVar(lang.NewSymbol("apply")) +if v309.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v309))) +} +v310 := v309.Get() +v311 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v312 := v311.FindInternedVar(lang.NewSymbol("vector")) +if v312.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v312))) +} +v313 := v312.Get() +v314 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v315 := v314.FindInternedVar(lang.NewSymbol("seq")) +if v315.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v315))) +} +v316 := v315.Get() +v317 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v318 := v317.FindInternedVar(lang.NewSymbol("concat")) +if v318.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v318))) +} +v319 := v318.Get() +v320 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v321 := v320.FindInternedVar(lang.NewSymbol("list")) +if v321.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v321))) +} +v322 := v321.Get() +v323 := lang.Apply(v322, []any{lang.NewSymbol("iterys__0__auto__")}) +v324 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v325 := v324.FindInternedVar(lang.NewSymbol("list")) +if v325.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v325))) +} +v326 := v325.Get() +v327 := lang.Apply(v65, []any{v128}) +v328 := lang.Apply(v326, []any{v327}) +v329 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v330 := v329.FindInternedVar(lang.NewSymbol("list")) +if v330.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v330))) +} +v331 := v330.Get() +v332 := lang.Apply(v331, []any{lang.NewSymbol("fs__1__auto__")}) +v333 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v334 := v333.FindInternedVar(lang.NewSymbol("list")) +if v334.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v334))) +} +v335 := v334.Get() +v336 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v337 := v336.FindInternedVar(lang.NewSymbol("seq")) +if v337.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v337))) +} +v338 := v337.Get() +v339 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v340 := v339.FindInternedVar(lang.NewSymbol("concat")) +if v340.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v340))) +} +v341 := v340.Get() +v342 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v343 := v342.FindInternedVar(lang.NewSymbol("list")) +if v343.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v343))) +} +v344 := v343.Get() +v345 := lang.Apply(v344, []any{lang.NewSymbol("glojure.core/seq")}) +v346 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v347 := v346.FindInternedVar(lang.NewSymbol("list")) +if v347.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v347))) +} +v348 := v347.Get() +v349 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v350 := v349.FindInternedVar(lang.NewSymbol("seq")) +if v350.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v350))) +} +v351 := v350.Get() +v352 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v353 := v352.FindInternedVar(lang.NewSymbol("concat")) +if v353.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v353))) +} +v354 := v353.Get() +v355 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v356 := v355.FindInternedVar(lang.NewSymbol("list")) +if v356.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v356))) +} +v357 := v356.Get() +v358 := lang.Apply(v357, []any{lang.NewSymbol("iterys__0__auto__")}) +v359 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v360 := v359.FindInternedVar(lang.NewSymbol("list")) +if v360.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v360))) +} +v361 := v360.Get() +v362 := lang.Apply(v361, []any{v123}) +v363 := lang.Apply(v354, []any{v358, v362}) +v364 := lang.Apply(v351, []any{v363}) +v365 := lang.Apply(v348, []any{v364}) +v366 := lang.Apply(v341, []any{v345, v365}) +v367 := lang.Apply(v338, []any{v366}) +v368 := lang.Apply(v335, []any{v367}) +v369 := lang.Apply(v319, []any{v323, v328, v332, v368}) +v370 := lang.Apply(v316, []any{v369}) +v371 := lang.Apply(v310, []any{v313, v370}) +v372 := lang.Apply(v307, []any{v371}) +v373 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v374 := v373.FindInternedVar(lang.NewSymbol("list")) +if v374.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v374))) +} +v375 := v374.Get() +v376 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v377 := v376.FindInternedVar(lang.NewSymbol("seq")) +if v377.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v377))) +} +v378 := v377.Get() +v379 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v380 := v379.FindInternedVar(lang.NewSymbol("concat")) +if v380.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v380))) +} +v381 := v380.Get() +v382 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v383 := v382.FindInternedVar(lang.NewSymbol("list")) +if v383.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v383))) +} +v384 := v383.Get() +v385 := lang.Apply(v384, []any{lang.NewSymbol("if")}) +v386 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v387 := v386.FindInternedVar(lang.NewSymbol("list")) +if v387.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v387))) +} +v388 := v387.Get() +v389 := lang.Apply(v388, []any{lang.NewSymbol("fs__1__auto__")}) +v390 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v391 := v390.FindInternedVar(lang.NewSymbol("list")) +if v391.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v391))) +} +v392 := v391.Get() +v393 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v394 := v393.FindInternedVar(lang.NewSymbol("seq")) +if v394.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v394))) +} +v395 := v394.Get() +v396 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v397 := v396.FindInternedVar(lang.NewSymbol("concat")) +if v397.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v397))) +} +v398 := v397.Get() +v399 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v400 := v399.FindInternedVar(lang.NewSymbol("list")) +if v400.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v400))) +} +v401 := v400.Get() +v402 := lang.Apply(v401, []any{lang.NewSymbol("glojure.core/concat")}) +v403 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v404 := v403.FindInternedVar(lang.NewSymbol("list")) +if v404.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v404))) +} +v405 := v404.Get() +v406 := lang.Apply(v405, []any{lang.NewSymbol("fs__1__auto__")}) +v407 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v408 := v407.FindInternedVar(lang.NewSymbol("list")) +if v408.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v408))) +} +v409 := v408.Get() +v410 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v411 := v410.FindInternedVar(lang.NewSymbol("seq")) +if v411.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v411))) +} +v412 := v411.Get() +v413 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v414 := v413.FindInternedVar(lang.NewSymbol("concat")) +if v414.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v414))) +} +v415 := v414.Get() +v416 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v417 := v416.FindInternedVar(lang.NewSymbol("list")) +if v417.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v417))) +} +v418 := v417.Get() +v419 := lang.Apply(v418, []any{v130}) +v420 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v421 := v420.FindInternedVar(lang.NewSymbol("list")) +if v421.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v421))) +} +v422 := v421.Get() +v423 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v424 := v423.FindInternedVar(lang.NewSymbol("seq")) +if v424.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v424))) +} +v425 := v424.Get() +v426 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v427 := v426.FindInternedVar(lang.NewSymbol("concat")) +if v427.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v427))) +} +v428 := v427.Get() +v429 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v430 := v429.FindInternedVar(lang.NewSymbol("list")) +if v430.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v430))) +} +v431 := v430.Get() +v432 := lang.Apply(v431, []any{lang.NewSymbol("glojure.core/rest")}) +v433 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v434 := v433.FindInternedVar(lang.NewSymbol("list")) +if v434.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v434))) +} +v435 := v434.Get() +v436 := lang.Apply(v435, []any{v135}) +v437 := lang.Apply(v428, []any{v432, v436}) +v438 := lang.Apply(v425, []any{v437}) +v439 := lang.Apply(v422, []any{v438}) +v440 := lang.Apply(v415, []any{v419, v439}) +v441 := lang.Apply(v412, []any{v440}) +v442 := lang.Apply(v409, []any{v441}) +v443 := lang.Apply(v398, []any{v402, v406, v442}) +v444 := lang.Apply(v395, []any{v443}) +v445 := lang.Apply(v392, []any{v444}) +v446 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v447 := v446.FindInternedVar(lang.NewSymbol("list")) +if v447.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v447))) +} +v448 := v447.Get() +v449 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v450 := v449.FindInternedVar(lang.NewSymbol("seq")) +if v450.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v450))) +} +v451 := v450.Get() +v452 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v453 := v452.FindInternedVar(lang.NewSymbol("concat")) +if v453.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v453))) +} +v454 := v453.Get() +v455 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v456 := v455.FindInternedVar(lang.NewSymbol("list")) +if v456.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v456))) +} +v457 := v456.Get() +v458 := lang.Apply(v457, []any{lang.NewSymbol("recur")}) +v459 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v460 := v459.FindInternedVar(lang.NewSymbol("list")) +if v460.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v460))) +} +v461 := v460.Get() +v462 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v463 := v462.FindInternedVar(lang.NewSymbol("seq")) +if v463.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v463))) +} +v464 := v463.Get() +v465 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v466 := v465.FindInternedVar(lang.NewSymbol("concat")) +if v466.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v466))) +} +v467 := v466.Get() +v468 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v469 := v468.FindInternedVar(lang.NewSymbol("list")) +if v469.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v469))) +} +v470 := v469.Get() +v471 := lang.Apply(v470, []any{lang.NewSymbol("glojure.core/rest")}) +v472 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v473 := v472.FindInternedVar(lang.NewSymbol("list")) +if v473.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v473))) +} +v474 := v473.Get() +v475 := lang.Apply(v474, []any{v135}) +v476 := lang.Apply(v467, []any{v471, v475}) +v477 := lang.Apply(v464, []any{v476}) +v478 := lang.Apply(v461, []any{v477}) +v479 := lang.Apply(v454, []any{v458, v478}) +v480 := lang.Apply(v451, []any{v479}) +v481 := lang.Apply(v448, []any{v480}) +v482 := lang.Apply(v381, []any{v385, v389, v445, v481}) +v483 := lang.Apply(v378, []any{v482}) +v484 := lang.Apply(v375, []any{v483}) +v485 := lang.Apply(v300, []any{v304, v372, v484}) +v486 := lang.Apply(v297, []any{v485}) +v294 = v486 +} else { +var v487 any +if lang.IsTruthy(lang.NewKeyword("else")) { +v488 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v489 := v488.FindInternedVar(lang.NewSymbol("seq")) +if v489.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v489))) +} +v490 := v489.Get() +v491 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v492 := v491.FindInternedVar(lang.NewSymbol("concat")) +if v492.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v492))) +} +v493 := v492.Get() +v494 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v495 := v494.FindInternedVar(lang.NewSymbol("list")) +if v495.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v495))) +} +v496 := v495.Get() +v497 := lang.Apply(v496, []any{lang.NewSymbol("glojure.core/cons")}) +v498 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v499 := v498.FindInternedVar(lang.NewSymbol("list")) +if v499.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v499))) +} +v500 := v499.Get() +v501 := lang.Apply(v500, []any{v6}) +v502 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v503 := v502.FindInternedVar(lang.NewSymbol("list")) +if v503.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v503))) +} +v504 := v503.Get() +v505 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v506 := v505.FindInternedVar(lang.NewSymbol("seq")) +if v506.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v506))) +} +v507 := v506.Get() +v508 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v509 := v508.FindInternedVar(lang.NewSymbol("concat")) +if v509.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v509))) +} +v510 := v509.Get() +v511 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v512 := v511.FindInternedVar(lang.NewSymbol("list")) +if v512.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v512))) +} +v513 := v512.Get() +v514 := lang.Apply(v513, []any{v130}) +v515 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v516 := v515.FindInternedVar(lang.NewSymbol("list")) +if v516.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v516))) +} +v517 := v516.Get() +v518 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v519 := v518.FindInternedVar(lang.NewSymbol("seq")) +if v519.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v519))) +} +v520 := v519.Get() +v521 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v522 := v521.FindInternedVar(lang.NewSymbol("concat")) +if v522.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v522))) +} +v523 := v522.Get() +v524 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v525 := v524.FindInternedVar(lang.NewSymbol("list")) +if v525.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v525))) +} +v526 := v525.Get() +v527 := lang.Apply(v526, []any{lang.NewSymbol("glojure.core/rest")}) +v528 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v529 := v528.FindInternedVar(lang.NewSymbol("list")) +if v529.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v529))) +} +v530 := v529.Get() +v531 := lang.Apply(v530, []any{v135}) +v532 := lang.Apply(v523, []any{v527, v531}) +v533 := lang.Apply(v520, []any{v532}) +v534 := lang.Apply(v517, []any{v533}) +v535 := lang.Apply(v510, []any{v514, v534}) +v536 := lang.Apply(v507, []any{v535}) +v537 := lang.Apply(v504, []any{v536}) +v538 := lang.Apply(v493, []any{v497, v501, v537}) +v539 := lang.Apply(v490, []any{v538}) +v487 = v539 +} else { +v487 = nil +} +v294 = v487 +} +v288 = v294 +} +v226 = v288 +} +v200 = v226 +} +v174 = v200 +} +return v174 +}) +v142 := v141 +_ = v142 +} +v142 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4672), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(4687), lang.NewKeyword("end-column"), int(73)) +v143, err := lang.WithMeta(v141, v142.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v140 any = v143 +_ = v140 +var v145 any +if lang.IsTruthy(v128) { +v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v147 := v146.FindInternedVar(lang.NewSymbol("seq")) +if v147.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) +} +v148 := v147.Get() +v149 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v150 := v149.FindInternedVar(lang.NewSymbol("concat")) +if v150.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v150))) +} +v151 := v150.Get() +v152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v153 := v152.FindInternedVar(lang.NewSymbol("list")) +if v153.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v153))) +} +v154 := v153.Get() +v155 := lang.Apply(v154, []any{lang.NewSymbol("glojure.core/fn")}) +v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v157 := v156.FindInternedVar(lang.NewSymbol("list")) +if v157.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) +} +v158 := v157.Get() +v159 := lang.Apply(v158, []any{v130}) +v160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v161 := v160.FindInternedVar(lang.NewSymbol("list")) +if v161.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v161))) +} +v162 := v161.Get() +v163 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v164 := v163.FindInternedVar(lang.NewSymbol("apply")) +if v164.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v164))) +} +v165 := v164.Get() +v166 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v167 := v166.FindInternedVar(lang.NewSymbol("vector")) +if v167.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v167))) +} +v168 := v167.Get() +v169 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v170 := v169.FindInternedVar(lang.NewSymbol("seq")) +if v170.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v170))) +} +v171 := v170.Get() +v172 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v173 := v172.FindInternedVar(lang.NewSymbol("concat")) +if v173.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v173))) +} +v174 := v173.Get() +v175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v176 := v175.FindInternedVar(lang.NewSymbol("list")) +if v176.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v176))) +} +v177 := v176.Get() +v178 := lang.Apply(v177, []any{v135}) +v179 := lang.Apply(v174, []any{v178}) +v180 := lang.Apply(v171, []any{v179}) +v181 := lang.Apply(v165, []any{v168, v180}) +v182 := lang.Apply(v162, []any{v181}) +v183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v184 := v183.FindInternedVar(lang.NewSymbol("list")) +if v184.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v184))) +} +v185 := v184.Get() +v186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v187 := v186.FindInternedVar(lang.NewSymbol("seq")) +if v187.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v187))) +} +v188 := v187.Get() +v189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v190 := v189.FindInternedVar(lang.NewSymbol("concat")) +if v190.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v190))) +} +v191 := v190.Get() +v192 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v193 := v192.FindInternedVar(lang.NewSymbol("list")) +if v193.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v193))) +} +v194 := v193.Get() +v195 := lang.Apply(v194, []any{lang.NewSymbol("glojure.core/lazy-seq")}) +v196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v197 := v196.FindInternedVar(lang.NewSymbol("list")) +if v197.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v197))) +} +v198 := v197.Get() +v199 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v200 := v199.FindInternedVar(lang.NewSymbol("seq")) +if v200.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v200))) +} +v201 := v200.Get() +v202 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v203 := v202.FindInternedVar(lang.NewSymbol("concat")) +if v203.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v203))) +} +v204 := v203.Get() +v205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v206 := v205.FindInternedVar(lang.NewSymbol("list")) +if v206.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v206))) +} +v207 := v206.Get() +v208 := lang.Apply(v207, []any{lang.NewSymbol("glojure.core/loop")}) +v209 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v210 := v209.FindInternedVar(lang.NewSymbol("list")) +if v210.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v210))) +} +v211 := v210.Get() +v212 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v213 := v212.FindInternedVar(lang.NewSymbol("apply")) +if v213.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v213))) +} +v214 := v213.Get() +v215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v216 := v215.FindInternedVar(lang.NewSymbol("vector")) +if v216.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v216))) +} +v217 := v216.Get() +v218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v219 := v218.FindInternedVar(lang.NewSymbol("seq")) +if v219.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v219))) +} +v220 := v219.Get() +v221 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v222 := v221.FindInternedVar(lang.NewSymbol("concat")) +if v222.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v222))) +} +v223 := v222.Get() +v224 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v225 := v224.FindInternedVar(lang.NewSymbol("list")) +if v225.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v225))) +} +v226 := v225.Get() +v227 := lang.Apply(v226, []any{v135}) +v228 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v229 := v228.FindInternedVar(lang.NewSymbol("list")) +if v229.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v229))) +} +v230 := v229.Get() +v231 := lang.Apply(v230, []any{v135}) +v232 := lang.Apply(v223, []any{v227, v231}) +v233 := lang.Apply(v220, []any{v232}) +v234 := lang.Apply(v214, []any{v217, v233}) +v235 := lang.Apply(v211, []any{v234}) +v236 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v237 := v236.FindInternedVar(lang.NewSymbol("list")) +if v237.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v237))) +} +v238 := v237.Get() +v239 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v240 := v239.FindInternedVar(lang.NewSymbol("seq")) +if v240.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v240))) +} +v241 := v240.Get() +v242 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v243 := v242.FindInternedVar(lang.NewSymbol("concat")) +if v243.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v243))) +} +v244 := v243.Get() +v245 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v246 := v245.FindInternedVar(lang.NewSymbol("list")) +if v246.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v246))) +} +v247 := v246.Get() +v248 := lang.Apply(v247, []any{lang.NewSymbol("glojure.core/when-first")}) +v249 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v250 := v249.FindInternedVar(lang.NewSymbol("list")) +if v250.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v250))) +} +v251 := v250.Get() +v252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v253 := v252.FindInternedVar(lang.NewSymbol("apply")) +if v253.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v253))) +} +v254 := v253.Get() +v255 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v256 := v255.FindInternedVar(lang.NewSymbol("vector")) +if v256.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v256))) +} +v257 := v256.Get() +v258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v259 := v258.FindInternedVar(lang.NewSymbol("seq")) +if v259.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v259))) +} +v260 := v259.Get() +v261 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v262 := v261.FindInternedVar(lang.NewSymbol("concat")) +if v262.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v262))) +} +v263 := v262.Get() +v264 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v265 := v264.FindInternedVar(lang.NewSymbol("list")) +if v265.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v265))) +} +v266 := v265.Get() +v267 := lang.Apply(v266, []any{v99}) +v268 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v269 := v268.FindInternedVar(lang.NewSymbol("list")) +if v269.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v269))) +} +v270 := v269.Get() +v271 := lang.Apply(v270, []any{v135}) +v272 := lang.Apply(v263, []any{v267, v271}) +v273 := lang.Apply(v260, []any{v272}) +v274 := lang.Apply(v254, []any{v257, v273}) +v275 := lang.Apply(v251, []any{v274}) +v276 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v277 := v276.FindInternedVar(lang.NewSymbol("list")) +if v277.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v277))) +} +v278 := v277.Get() +v279 := lang.Apply(v140, []any{v111}) +v280 := lang.Apply(v278, []any{v279}) +v281 := lang.Apply(v244, []any{v248, v275, v280}) +v282 := lang.Apply(v241, []any{v281}) +v283 := lang.Apply(v238, []any{v282}) +v284 := lang.Apply(v204, []any{v208, v235, v283}) +v285 := lang.Apply(v201, []any{v284}) +v286 := lang.Apply(v198, []any{v285}) +v287 := lang.Apply(v191, []any{v195, v286}) +v288 := lang.Apply(v188, []any{v287}) +v289 := lang.Apply(v185, []any{v288}) +v290 := lang.Apply(v151, []any{v155, v159, v182, v289}) +v291 := lang.Apply(v148, []any{v290}) +v145 = v291 +} else { +v293 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v294 := v293.FindInternedVar(lang.NewSymbol("gensym")) +if v294.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v294))) +} +v295 := v294.Get() +v296 := lang.Apply(v295, []any{"i__"}) +var v292 any = v296 +_ = v292 +v298 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v299 := v298.FindInternedVar(lang.NewSymbol("gensym")) +if v299.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v299))) +} +v300 := v299.Get() +v301 := lang.Apply(v300, []any{"b__"}) +var v297 any = v301 +_ = v297 +var v303 lang.FnFunc +{ // function do-cmod +v303 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v305 := args[0] +var v306 any = v305 +_ = v306 +v308 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v309 := v308.FindInternedVar(lang.NewSymbol("seq")) +if v309.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v309))) +} +v310 := v309.Get() +v311 := lang.Apply(v310, []any{v306}) +var v307 any = v311 +_ = v307 +v313 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v314 := v313.FindInternedVar(lang.NewSymbol("first")) +if v314.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v314))) +} +v315 := v314.Get() +v316 := lang.Apply(v315, []any{v307}) +var v312 any = v316 +_ = v312 +v318 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v319 := v318.FindInternedVar(lang.NewSymbol("next")) +if v319.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v319))) +} +v320 := v319.Get() +v321 := lang.Apply(v320, []any{v317}) +var v317 any = v321 +_ = v317 +var v322 any = v312 +_ = v322 +v324 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v325 := v324.FindInternedVar(lang.NewSymbol("nth")) +if v325.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v325))) +} +v326 := v325.Get() +v327 := lang.Apply(v326, []any{v322, int64(0), nil}) +var v323 any = v327 +_ = v323 +v329 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v330 := v329.FindInternedVar(lang.NewSymbol("nth")) +if v330.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v330))) +} +v331 := v330.Get() +v332 := lang.Apply(v331, []any{v322, int64(1), nil}) +var v328 any = v332 +_ = v328 +var v333 any = v322 +_ = v333 +var v334 any = v317 +_ = v334 +var v336 any +v337 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v338 := v337.FindInternedVar(lang.NewSymbol("=")) +if v338.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v338))) +} +v339 := v338.Get() +v340 := lang.Apply(v339, []any{v323, lang.NewKeyword("let")}) +if lang.IsTruthy(v340) { +v341 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v342 := v341.FindInternedVar(lang.NewSymbol("seq")) +if v342.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v342))) +} +v343 := v342.Get() +v344 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v345 := v344.FindInternedVar(lang.NewSymbol("concat")) +if v345.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v345))) +} +v346 := v345.Get() +v347 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v348 := v347.FindInternedVar(lang.NewSymbol("list")) +if v348.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v348))) +} +v349 := v348.Get() +v350 := lang.Apply(v349, []any{lang.NewSymbol("glojure.core/let")}) +v351 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v352 := v351.FindInternedVar(lang.NewSymbol("list")) +if v352.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v352))) +} +v353 := v352.Get() +v354 := lang.Apply(v353, []any{v328}) +v355 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v356 := v355.FindInternedVar(lang.NewSymbol("list")) +if v356.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v356))) +} +v357 := v356.Get() +v358 := lang.Apply(v304, []any{v334}) +v359 := lang.Apply(v357, []any{v358}) +v360 := lang.Apply(v346, []any{v350, v354, v359}) +v361 := lang.Apply(v343, []any{v360}) +v336 = v361 +} else { +var v362 any +v363 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v364 := v363.FindInternedVar(lang.NewSymbol("=")) +if v364.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v364))) +} +v365 := v364.Get() +v366 := lang.Apply(v365, []any{v323, lang.NewKeyword("while")}) +if lang.IsTruthy(v366) { +v367 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v368 := v367.FindInternedVar(lang.NewSymbol("seq")) +if v368.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v368))) +} +v369 := v368.Get() +v370 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v371 := v370.FindInternedVar(lang.NewSymbol("concat")) +if v371.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v371))) +} +v372 := v371.Get() +v373 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v374 := v373.FindInternedVar(lang.NewSymbol("list")) +if v374.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v374))) +} +v375 := v374.Get() +v376 := lang.Apply(v375, []any{lang.NewSymbol("glojure.core/when")}) +v377 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v378 := v377.FindInternedVar(lang.NewSymbol("list")) +if v378.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v378))) +} +v379 := v378.Get() +v380 := lang.Apply(v379, []any{v328}) +v381 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v382 := v381.FindInternedVar(lang.NewSymbol("list")) +if v382.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v382))) +} +v383 := v382.Get() +v384 := lang.Apply(v304, []any{v334}) +v385 := lang.Apply(v383, []any{v384}) +v386 := lang.Apply(v372, []any{v376, v380, v385}) +v387 := lang.Apply(v369, []any{v386}) +v362 = v387 +} else { +var v388 any +v389 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v390 := v389.FindInternedVar(lang.NewSymbol("=")) +if v390.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v390))) +} +v391 := v390.Get() +v392 := lang.Apply(v391, []any{v323, lang.NewKeyword("when")}) +if lang.IsTruthy(v392) { +v393 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v394 := v393.FindInternedVar(lang.NewSymbol("seq")) +if v394.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v394))) +} +v395 := v394.Get() +v396 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v397 := v396.FindInternedVar(lang.NewSymbol("concat")) +if v397.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v397))) +} +v398 := v397.Get() +v399 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v400 := v399.FindInternedVar(lang.NewSymbol("list")) +if v400.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v400))) +} +v401 := v400.Get() +v402 := lang.Apply(v401, []any{lang.NewSymbol("if")}) +v403 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v404 := v403.FindInternedVar(lang.NewSymbol("list")) +if v404.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v404))) +} +v405 := v404.Get() +v406 := lang.Apply(v405, []any{v328}) +v407 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v408 := v407.FindInternedVar(lang.NewSymbol("list")) +if v408.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v408))) +} +v409 := v408.Get() +v410 := lang.Apply(v304, []any{v334}) +v411 := lang.Apply(v409, []any{v410}) +v412 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v413 := v412.FindInternedVar(lang.NewSymbol("list")) +if v413.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v413))) +} +v414 := v413.Get() +v415 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v416 := v415.FindInternedVar(lang.NewSymbol("seq")) +if v416.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v416))) +} +v417 := v416.Get() +v418 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v419 := v418.FindInternedVar(lang.NewSymbol("concat")) +if v419.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v419))) +} +v420 := v419.Get() +v421 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v422 := v421.FindInternedVar(lang.NewSymbol("list")) +if v422.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v422))) +} +v423 := v422.Get() +v424 := lang.Apply(v423, []any{lang.NewSymbol("recur")}) +v425 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v426 := v425.FindInternedVar(lang.NewSymbol("list")) +if v426.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v426))) +} +v427 := v426.Get() +v428 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v429 := v428.FindInternedVar(lang.NewSymbol("seq")) +if v429.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v429))) +} +v430 := v429.Get() +v431 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v432 := v431.FindInternedVar(lang.NewSymbol("concat")) +if v432.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v432))) +} +v433 := v432.Get() +v434 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v435 := v434.FindInternedVar(lang.NewSymbol("list")) +if v435.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v435))) +} +v436 := v435.Get() +v437 := lang.Apply(v436, []any{lang.NewSymbol("glojure.core/unchecked-inc")}) +v438 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v439 := v438.FindInternedVar(lang.NewSymbol("list")) +if v439.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v439))) +} +v440 := v439.Get() +v441 := lang.Apply(v440, []any{v292}) +v442 := lang.Apply(v433, []any{v437, v441}) +v443 := lang.Apply(v430, []any{v442}) +v444 := lang.Apply(v427, []any{v443}) +v445 := lang.Apply(v420, []any{v424, v444}) +v446 := lang.Apply(v417, []any{v445}) +v447 := lang.Apply(v414, []any{v446}) +v448 := lang.Apply(v398, []any{v402, v406, v411, v447}) +v449 := lang.Apply(v395, []any{v448}) +v388 = v449 +} else { +var v450 any +v451 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v452 := v451.FindInternedVar(lang.NewSymbol("keyword?")) +if v452.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v452))) +} +v453 := v452.Get() +v454 := lang.Apply(v453, []any{v323}) +if lang.IsTruthy(v454) { +v455 := lang.Apply(v59, []any{"Invalid 'for' keyword ", v323}) +v450 = v455 +} else { +var v456 any +if lang.IsTruthy(lang.NewKeyword("else")) { +v457 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v458 := v457.FindInternedVar(lang.NewSymbol("seq")) +if v458.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v458))) +} +v459 := v458.Get() +v460 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v461 := v460.FindInternedVar(lang.NewSymbol("concat")) +if v461.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v461))) +} +v462 := v461.Get() +v463 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v464 := v463.FindInternedVar(lang.NewSymbol("list")) +if v464.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v464))) +} +v465 := v464.Get() +v466 := lang.Apply(v465, []any{lang.NewSymbol("do")}) +v467 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v468 := v467.FindInternedVar(lang.NewSymbol("list")) +if v468.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v468))) +} +v469 := v468.Get() +v470 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v471 := v470.FindInternedVar(lang.NewSymbol("seq")) +if v471.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v471))) +} +v472 := v471.Get() +v473 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v474 := v473.FindInternedVar(lang.NewSymbol("concat")) +if v474.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v474))) +} +v475 := v474.Get() +v476 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v477 := v476.FindInternedVar(lang.NewSymbol("list")) +if v477.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v477))) +} +v478 := v477.Get() +v479 := lang.Apply(v478, []any{lang.NewSymbol("glojure.core/chunk-append")}) +v480 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v481 := v480.FindInternedVar(lang.NewSymbol("list")) +if v481.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v481))) +} +v482 := v481.Get() +v483 := lang.Apply(v482, []any{v297}) +v484 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v485 := v484.FindInternedVar(lang.NewSymbol("list")) +if v485.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v485))) +} +v486 := v485.Get() +v487 := lang.Apply(v486, []any{v6}) +v488 := lang.Apply(v475, []any{v479, v483, v487}) +v489 := lang.Apply(v472, []any{v488}) +v490 := lang.Apply(v469, []any{v489}) +v491 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v492 := v491.FindInternedVar(lang.NewSymbol("list")) +if v492.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v492))) +} +v493 := v492.Get() +v494 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v495 := v494.FindInternedVar(lang.NewSymbol("seq")) +if v495.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v495))) +} +v496 := v495.Get() +v497 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v498 := v497.FindInternedVar(lang.NewSymbol("concat")) +if v498.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v498))) +} +v499 := v498.Get() +v500 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v501 := v500.FindInternedVar(lang.NewSymbol("list")) +if v501.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v501))) +} +v502 := v501.Get() +v503 := lang.Apply(v502, []any{lang.NewSymbol("recur")}) +v504 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v505 := v504.FindInternedVar(lang.NewSymbol("list")) +if v505.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v505))) +} +v506 := v505.Get() +v507 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v508 := v507.FindInternedVar(lang.NewSymbol("seq")) +if v508.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v508))) +} +v509 := v508.Get() +v510 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v511 := v510.FindInternedVar(lang.NewSymbol("concat")) +if v511.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v511))) +} +v512 := v511.Get() +v513 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v514 := v513.FindInternedVar(lang.NewSymbol("list")) +if v514.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v514))) +} +v515 := v514.Get() +v516 := lang.Apply(v515, []any{lang.NewSymbol("glojure.core/unchecked-inc")}) +v517 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v518 := v517.FindInternedVar(lang.NewSymbol("list")) +if v518.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v518))) +} +v519 := v518.Get() +v520 := lang.Apply(v519, []any{v292}) +v521 := lang.Apply(v512, []any{v516, v520}) +v522 := lang.Apply(v509, []any{v521}) +v523 := lang.Apply(v506, []any{v522}) +v524 := lang.Apply(v499, []any{v503, v523}) +v525 := lang.Apply(v496, []any{v524}) +v526 := lang.Apply(v493, []any{v525}) +v527 := lang.Apply(v462, []any{v466, v490, v526}) +v528 := lang.Apply(v459, []any{v527}) +v456 = v528 +} else { +v456 = nil +} +v450 = v456 +} +v388 = v450 +} +v362 = v388 +} +v336 = v362 +} +return v336 +}) +v304 := v303 +_ = v304 +} +v304 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4698), lang.NewKeyword("column"), int(39), lang.NewKeyword("end-line"), int(4710), lang.NewKeyword("end-column"), int(79)) +v305, err := lang.WithMeta(v303, v304.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v302 any = v305 +_ = v302 +v307 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v308 := v307.FindInternedVar(lang.NewSymbol("seq")) +if v308.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v308))) +} +v309 := v308.Get() +v310 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v311 := v310.FindInternedVar(lang.NewSymbol("concat")) +if v311.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v311))) +} +v312 := v311.Get() +v313 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v314 := v313.FindInternedVar(lang.NewSymbol("list")) +if v314.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v314))) +} +v315 := v314.Get() +v316 := lang.Apply(v315, []any{lang.NewSymbol("glojure.core/fn")}) +v317 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v318 := v317.FindInternedVar(lang.NewSymbol("list")) +if v318.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v318))) +} +v319 := v318.Get() +v320 := lang.Apply(v319, []any{v130}) +v321 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v322 := v321.FindInternedVar(lang.NewSymbol("list")) +if v322.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v322))) +} +v323 := v322.Get() +v324 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v325 := v324.FindInternedVar(lang.NewSymbol("apply")) +if v325.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v325))) +} +v326 := v325.Get() +v327 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v328 := v327.FindInternedVar(lang.NewSymbol("vector")) +if v328.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v328))) +} +v329 := v328.Get() +v330 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v331 := v330.FindInternedVar(lang.NewSymbol("seq")) +if v331.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v331))) +} +v332 := v331.Get() +v333 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v334 := v333.FindInternedVar(lang.NewSymbol("concat")) +if v334.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v334))) +} +v335 := v334.Get() +v336 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v337 := v336.FindInternedVar(lang.NewSymbol("list")) +if v337.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v337))) +} +v338 := v337.Get() +v339 := lang.Apply(v338, []any{v135}) +v340 := lang.Apply(v335, []any{v339}) +v341 := lang.Apply(v332, []any{v340}) +v342 := lang.Apply(v326, []any{v329, v341}) +v343 := lang.Apply(v323, []any{v342}) +v344 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v345 := v344.FindInternedVar(lang.NewSymbol("list")) +if v345.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v345))) +} +v346 := v345.Get() +v347 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v348 := v347.FindInternedVar(lang.NewSymbol("seq")) +if v348.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v348))) +} +v349 := v348.Get() +v350 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v351 := v350.FindInternedVar(lang.NewSymbol("concat")) +if v351.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v351))) +} +v352 := v351.Get() +v353 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v354 := v353.FindInternedVar(lang.NewSymbol("list")) +if v354.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v354))) +} +v355 := v354.Get() +v356 := lang.Apply(v355, []any{lang.NewSymbol("glojure.core/lazy-seq")}) +v357 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v358 := v357.FindInternedVar(lang.NewSymbol("list")) +if v358.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v358))) +} +v359 := v358.Get() +v360 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v361 := v360.FindInternedVar(lang.NewSymbol("seq")) +if v361.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v361))) +} +v362 := v361.Get() +v363 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v364 := v363.FindInternedVar(lang.NewSymbol("concat")) +if v364.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v364))) +} +v365 := v364.Get() +v366 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v367 := v366.FindInternedVar(lang.NewSymbol("list")) +if v367.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v367))) +} +v368 := v367.Get() +v369 := lang.Apply(v368, []any{lang.NewSymbol("glojure.core/loop")}) +v370 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v371 := v370.FindInternedVar(lang.NewSymbol("list")) +if v371.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v371))) +} +v372 := v371.Get() +v373 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v374 := v373.FindInternedVar(lang.NewSymbol("apply")) +if v374.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v374))) +} +v375 := v374.Get() +v376 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v377 := v376.FindInternedVar(lang.NewSymbol("vector")) +if v377.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v377))) +} +v378 := v377.Get() +v379 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v380 := v379.FindInternedVar(lang.NewSymbol("seq")) +if v380.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v380))) +} +v381 := v380.Get() +v382 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v383 := v382.FindInternedVar(lang.NewSymbol("concat")) +if v383.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v383))) +} +v384 := v383.Get() +v385 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v386 := v385.FindInternedVar(lang.NewSymbol("list")) +if v386.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v386))) +} +v387 := v386.Get() +v388 := lang.Apply(v387, []any{v135}) +v389 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v390 := v389.FindInternedVar(lang.NewSymbol("list")) +if v390.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v390))) +} +v391 := v390.Get() +v392 := lang.Apply(v391, []any{v135}) +v393 := lang.Apply(v384, []any{v388, v392}) +v394 := lang.Apply(v381, []any{v393}) +v395 := lang.Apply(v375, []any{v378, v394}) +v396 := lang.Apply(v372, []any{v395}) +v397 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v398 := v397.FindInternedVar(lang.NewSymbol("list")) +if v398.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v398))) +} +v399 := v398.Get() +v400 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v401 := v400.FindInternedVar(lang.NewSymbol("seq")) +if v401.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v401))) +} +v402 := v401.Get() +v403 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v404 := v403.FindInternedVar(lang.NewSymbol("concat")) +if v404.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v404))) +} +v405 := v404.Get() +v406 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v407 := v406.FindInternedVar(lang.NewSymbol("list")) +if v407.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v407))) +} +v408 := v407.Get() +v409 := lang.Apply(v408, []any{lang.NewSymbol("glojure.core/when-let")}) +v410 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v411 := v410.FindInternedVar(lang.NewSymbol("list")) +if v411.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v411))) +} +v412 := v411.Get() +v413 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v414 := v413.FindInternedVar(lang.NewSymbol("apply")) +if v414.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v414))) +} +v415 := v414.Get() +v416 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v417 := v416.FindInternedVar(lang.NewSymbol("vector")) +if v417.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v417))) +} +v418 := v417.Get() +v419 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v420 := v419.FindInternedVar(lang.NewSymbol("seq")) +if v420.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v420))) +} +v421 := v420.Get() +v422 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v423 := v422.FindInternedVar(lang.NewSymbol("concat")) +if v423.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v423))) +} +v424 := v423.Get() +v425 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v426 := v425.FindInternedVar(lang.NewSymbol("list")) +if v426.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v426))) +} +v427 := v426.Get() +v428 := lang.Apply(v427, []any{v135}) +v429 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v430 := v429.FindInternedVar(lang.NewSymbol("list")) +if v430.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v430))) +} +v431 := v430.Get() +v432 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v433 := v432.FindInternedVar(lang.NewSymbol("seq")) +if v433.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v433))) +} +v434 := v433.Get() +v435 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v436 := v435.FindInternedVar(lang.NewSymbol("concat")) +if v436.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v436))) +} +v437 := v436.Get() +v438 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v439 := v438.FindInternedVar(lang.NewSymbol("list")) +if v439.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v439))) +} +v440 := v439.Get() +v441 := lang.Apply(v440, []any{lang.NewSymbol("glojure.core/seq")}) +v442 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v443 := v442.FindInternedVar(lang.NewSymbol("list")) +if v443.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v443))) +} +v444 := v443.Get() +v445 := lang.Apply(v444, []any{v135}) +v446 := lang.Apply(v437, []any{v441, v445}) +v447 := lang.Apply(v434, []any{v446}) +v448 := lang.Apply(v431, []any{v447}) +v449 := lang.Apply(v424, []any{v428, v448}) +v450 := lang.Apply(v421, []any{v449}) +v451 := lang.Apply(v415, []any{v418, v450}) +v452 := lang.Apply(v412, []any{v451}) +v453 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v454 := v453.FindInternedVar(lang.NewSymbol("list")) +if v454.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v454))) +} +v455 := v454.Get() +v456 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v457 := v456.FindInternedVar(lang.NewSymbol("seq")) +if v457.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v457))) +} +v458 := v457.Get() +v459 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v460 := v459.FindInternedVar(lang.NewSymbol("concat")) +if v460.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v460))) +} +v461 := v460.Get() +v462 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v463 := v462.FindInternedVar(lang.NewSymbol("list")) +if v463.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v463))) +} +v464 := v463.Get() +v465 := lang.Apply(v464, []any{lang.NewSymbol("if")}) +v466 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v467 := v466.FindInternedVar(lang.NewSymbol("list")) +if v467.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v467))) +} +v468 := v467.Get() +v469 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v470 := v469.FindInternedVar(lang.NewSymbol("seq")) +if v470.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v470))) +} +v471 := v470.Get() +v472 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v473 := v472.FindInternedVar(lang.NewSymbol("concat")) +if v473.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v473))) +} +v474 := v473.Get() +v475 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v476 := v475.FindInternedVar(lang.NewSymbol("list")) +if v476.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v476))) +} +v477 := v476.Get() +v478 := lang.Apply(v477, []any{lang.NewSymbol("glojure.core/chunked-seq?")}) +v479 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v480 := v479.FindInternedVar(lang.NewSymbol("list")) +if v480.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v480))) +} +v481 := v480.Get() +v482 := lang.Apply(v481, []any{v135}) +v483 := lang.Apply(v474, []any{v478, v482}) +v484 := lang.Apply(v471, []any{v483}) +v485 := lang.Apply(v468, []any{v484}) +v486 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v487 := v486.FindInternedVar(lang.NewSymbol("list")) +if v487.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v487))) +} +v488 := v487.Get() +v489 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v490 := v489.FindInternedVar(lang.NewSymbol("seq")) +if v490.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v490))) +} +v491 := v490.Get() +v492 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v493 := v492.FindInternedVar(lang.NewSymbol("concat")) +if v493.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v493))) +} +v494 := v493.Get() +v495 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v496 := v495.FindInternedVar(lang.NewSymbol("list")) +if v496.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v496))) +} +v497 := v496.Get() +v498 := lang.Apply(v497, []any{lang.NewSymbol("glojure.core/let")}) +v499 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v500 := v499.FindInternedVar(lang.NewSymbol("list")) +if v500.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v500))) +} +v501 := v500.Get() +v502 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v503 := v502.FindInternedVar(lang.NewSymbol("apply")) +if v503.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v503))) +} +v504 := v503.Get() +v505 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v506 := v505.FindInternedVar(lang.NewSymbol("vector")) +if v506.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v506))) +} +v507 := v506.Get() +v508 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v509 := v508.FindInternedVar(lang.NewSymbol("seq")) +if v509.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v509))) +} +v510 := v509.Get() +v511 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v512 := v511.FindInternedVar(lang.NewSymbol("concat")) +if v512.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v512))) +} +v513 := v512.Get() +v514 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v515 := v514.FindInternedVar(lang.NewSymbol("list")) +if v515.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v515))) +} +v516 := v515.Get() +v517 := lang.Apply(v516, []any{lang.NewSymbol("c__0__auto__")}) +v518 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v519 := v518.FindInternedVar(lang.NewSymbol("list")) +if v519.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v519))) +} +v520 := v519.Get() +v521 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v522 := v521.FindInternedVar(lang.NewSymbol("seq")) +if v522.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v522))) +} +v523 := v522.Get() +v524 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v525 := v524.FindInternedVar(lang.NewSymbol("concat")) +if v525.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v525))) +} +v526 := v525.Get() +v527 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v528 := v527.FindInternedVar(lang.NewSymbol("list")) +if v528.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v528))) +} +v529 := v528.Get() +v530 := lang.Apply(v529, []any{lang.NewSymbol("glojure.core/chunk-first")}) +v531 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v532 := v531.FindInternedVar(lang.NewSymbol("list")) +if v532.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v532))) +} +v533 := v532.Get() +v534 := lang.Apply(v533, []any{v135}) +v535 := lang.Apply(v526, []any{v530, v534}) +v536 := lang.Apply(v523, []any{v535}) +v537 := lang.Apply(v520, []any{v536}) +v538 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v539 := v538.FindInternedVar(lang.NewSymbol("list")) +if v539.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v539))) +} +v540 := v539.Get() +v541 := lang.Apply(v540, []any{lang.NewSymbol("size__1__auto__")}) +v542 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v543 := v542.FindInternedVar(lang.NewSymbol("list")) +if v543.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v543))) +} +v544 := v543.Get() +v545 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v546 := v545.FindInternedVar(lang.NewSymbol("seq")) +if v546.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v546))) +} +v547 := v546.Get() +v548 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v549 := v548.FindInternedVar(lang.NewSymbol("concat")) +if v549.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v549))) +} +v550 := v549.Get() +v551 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v552 := v551.FindInternedVar(lang.NewSymbol("list")) +if v552.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v552))) +} +v553 := v552.Get() +v554 := lang.Apply(v553, []any{lang.NewSymbol("glojure.core/int")}) +v555 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v556 := v555.FindInternedVar(lang.NewSymbol("list")) +if v556.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v556))) +} +v557 := v556.Get() +v558 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v559 := v558.FindInternedVar(lang.NewSymbol("seq")) +if v559.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v559))) +} +v560 := v559.Get() +v561 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v562 := v561.FindInternedVar(lang.NewSymbol("concat")) +if v562.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v562))) +} +v563 := v562.Get() +v564 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v565 := v564.FindInternedVar(lang.NewSymbol("list")) +if v565.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v565))) +} +v566 := v565.Get() +v567 := lang.Apply(v566, []any{lang.NewSymbol("glojure.core/count")}) +v568 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v569 := v568.FindInternedVar(lang.NewSymbol("list")) +if v569.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v569))) +} +v570 := v569.Get() +v571 := lang.Apply(v570, []any{lang.NewSymbol("c__0__auto__")}) +v572 := lang.Apply(v563, []any{v567, v571}) +v573 := lang.Apply(v560, []any{v572}) +v574 := lang.Apply(v557, []any{v573}) +v575 := lang.Apply(v550, []any{v554, v574}) +v576 := lang.Apply(v547, []any{v575}) +v577 := lang.Apply(v544, []any{v576}) +v578 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v579 := v578.FindInternedVar(lang.NewSymbol("list")) +if v579.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v579))) +} +v580 := v579.Get() +v581 := lang.Apply(v580, []any{v297}) +v582 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v583 := v582.FindInternedVar(lang.NewSymbol("list")) +if v583.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v583))) +} +v584 := v583.Get() +v585 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v586 := v585.FindInternedVar(lang.NewSymbol("seq")) +if v586.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v586))) +} +v587 := v586.Get() +v588 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v589 := v588.FindInternedVar(lang.NewSymbol("concat")) +if v589.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v589))) +} +v590 := v589.Get() +v591 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v592 := v591.FindInternedVar(lang.NewSymbol("list")) +if v592.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v592))) +} +v593 := v592.Get() +v594 := lang.Apply(v593, []any{lang.NewSymbol("glojure.core/chunk-buffer")}) +v595 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v596 := v595.FindInternedVar(lang.NewSymbol("list")) +if v596.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v596))) +} +v597 := v596.Get() +v598 := lang.Apply(v597, []any{lang.NewSymbol("size__1__auto__")}) +v599 := lang.Apply(v590, []any{v594, v598}) +v600 := lang.Apply(v587, []any{v599}) +v601 := lang.Apply(v584, []any{v600}) +v602 := lang.Apply(v513, []any{v517, v537, v541, v577, v581, v601}) +v603 := lang.Apply(v510, []any{v602}) +v604 := lang.Apply(v504, []any{v507, v603}) +v605 := lang.Apply(v501, []any{v604}) +v606 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v607 := v606.FindInternedVar(lang.NewSymbol("list")) +if v607.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v607))) +} +v608 := v607.Get() +v609 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v610 := v609.FindInternedVar(lang.NewSymbol("seq")) +if v610.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v610))) +} +v611 := v610.Get() +v612 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v613 := v612.FindInternedVar(lang.NewSymbol("concat")) +if v613.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v613))) +} +v614 := v613.Get() +v615 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v616 := v615.FindInternedVar(lang.NewSymbol("list")) +if v616.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v616))) +} +v617 := v616.Get() +v618 := lang.Apply(v617, []any{lang.NewSymbol("if")}) +v619 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v620 := v619.FindInternedVar(lang.NewSymbol("list")) +if v620.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v620))) +} +v621 := v620.Get() +v622 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v623 := v622.FindInternedVar(lang.NewSymbol("seq")) +if v623.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v623))) +} +v624 := v623.Get() +v625 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v626 := v625.FindInternedVar(lang.NewSymbol("concat")) +if v626.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v626))) +} +v627 := v626.Get() +v628 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v629 := v628.FindInternedVar(lang.NewSymbol("list")) +if v629.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v629))) +} +v630 := v629.Get() +v631 := lang.Apply(v630, []any{lang.NewSymbol("glojure.core/loop")}) +v632 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v633 := v632.FindInternedVar(lang.NewSymbol("list")) +if v633.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v633))) +} +v634 := v633.Get() +v635 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v636 := v635.FindInternedVar(lang.NewSymbol("apply")) +if v636.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v636))) +} +v637 := v636.Get() +v638 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v639 := v638.FindInternedVar(lang.NewSymbol("vector")) +if v639.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v639))) +} +v640 := v639.Get() +v641 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v642 := v641.FindInternedVar(lang.NewSymbol("seq")) +if v642.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v642))) +} +v643 := v642.Get() +v644 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v645 := v644.FindInternedVar(lang.NewSymbol("concat")) +if v645.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v645))) +} +v646 := v645.Get() +v647 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v648 := v647.FindInternedVar(lang.NewSymbol("list")) +if v648.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v648))) +} +v649 := v648.Get() +v650 := lang.Apply(v649, []any{v292}) +v651 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v652 := v651.FindInternedVar(lang.NewSymbol("list")) +if v652.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v652))) +} +v653 := v652.Get() +v654 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v655 := v654.FindInternedVar(lang.NewSymbol("seq")) +if v655.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v655))) +} +v656 := v655.Get() +v657 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v658 := v657.FindInternedVar(lang.NewSymbol("concat")) +if v658.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v658))) +} +v659 := v658.Get() +v660 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v661 := v660.FindInternedVar(lang.NewSymbol("list")) +if v661.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v661))) +} +v662 := v661.Get() +v663 := lang.Apply(v662, []any{lang.NewSymbol("glojure.core/int")}) +v664 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v665 := v664.FindInternedVar(lang.NewSymbol("list")) +if v665.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v665))) +} +v666 := v665.Get() +v667 := lang.Apply(v666, []any{int64(0)}) +v668 := lang.Apply(v659, []any{v663, v667}) +v669 := lang.Apply(v656, []any{v668}) +v670 := lang.Apply(v653, []any{v669}) +v671 := lang.Apply(v646, []any{v650, v670}) +v672 := lang.Apply(v643, []any{v671}) +v673 := lang.Apply(v637, []any{v640, v672}) +v674 := lang.Apply(v634, []any{v673}) +v675 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v676 := v675.FindInternedVar(lang.NewSymbol("list")) +if v676.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v676))) +} +v677 := v676.Get() +v678 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v679 := v678.FindInternedVar(lang.NewSymbol("seq")) +if v679.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v679))) +} +v680 := v679.Get() +v681 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v682 := v681.FindInternedVar(lang.NewSymbol("concat")) +if v682.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v682))) +} +v683 := v682.Get() +v684 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v685 := v684.FindInternedVar(lang.NewSymbol("list")) +if v685.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v685))) +} +v686 := v685.Get() +v687 := lang.Apply(v686, []any{lang.NewSymbol("if")}) +v688 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v689 := v688.FindInternedVar(lang.NewSymbol("list")) +if v689.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v689))) +} +v690 := v689.Get() +v691 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v692 := v691.FindInternedVar(lang.NewSymbol("seq")) +if v692.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v692))) +} +v693 := v692.Get() +v694 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v695 := v694.FindInternedVar(lang.NewSymbol("concat")) +if v695.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v695))) +} +v696 := v695.Get() +v697 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v698 := v697.FindInternedVar(lang.NewSymbol("list")) +if v698.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v698))) +} +v699 := v698.Get() +v700 := lang.Apply(v699, []any{lang.NewSymbol("glojure.core/<")}) +v701 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v702 := v701.FindInternedVar(lang.NewSymbol("list")) +if v702.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v702))) +} +v703 := v702.Get() +v704 := lang.Apply(v703, []any{v292}) +v705 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v706 := v705.FindInternedVar(lang.NewSymbol("list")) +if v706.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v706))) +} +v707 := v706.Get() +v708 := lang.Apply(v707, []any{lang.NewSymbol("size__1__auto__")}) +v709 := lang.Apply(v696, []any{v700, v704, v708}) +v710 := lang.Apply(v693, []any{v709}) +v711 := lang.Apply(v690, []any{v710}) +v712 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v713 := v712.FindInternedVar(lang.NewSymbol("list")) +if v713.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v713))) +} +v714 := v713.Get() +v715 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v716 := v715.FindInternedVar(lang.NewSymbol("seq")) +if v716.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v716))) +} +v717 := v716.Get() +v718 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v719 := v718.FindInternedVar(lang.NewSymbol("concat")) +if v719.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v719))) +} +v720 := v719.Get() +v721 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v722 := v721.FindInternedVar(lang.NewSymbol("list")) +if v722.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v722))) +} +v723 := v722.Get() +v724 := lang.Apply(v723, []any{lang.NewSymbol("glojure.core/let")}) +v725 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v726 := v725.FindInternedVar(lang.NewSymbol("list")) +if v726.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v726))) +} +v727 := v726.Get() +v728 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v729 := v728.FindInternedVar(lang.NewSymbol("apply")) +if v729.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v729))) +} +v730 := v729.Get() +v731 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v732 := v731.FindInternedVar(lang.NewSymbol("vector")) +if v732.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v732))) +} +v733 := v732.Get() +v734 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v735 := v734.FindInternedVar(lang.NewSymbol("seq")) +if v735.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v735))) +} +v736 := v735.Get() +v737 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v738 := v737.FindInternedVar(lang.NewSymbol("concat")) +if v738.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v738))) +} +v739 := v738.Get() +v740 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v741 := v740.FindInternedVar(lang.NewSymbol("list")) +if v741.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v741))) +} +v742 := v741.Get() +v743 := lang.Apply(v742, []any{v99}) +v744 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v745 := v744.FindInternedVar(lang.NewSymbol("list")) +if v745.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v745))) +} +v746 := v745.Get() +v747 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v748 := v747.FindInternedVar(lang.NewSymbol("seq")) +if v748.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v748))) +} +v749 := v748.Get() +v750 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v751 := v750.FindInternedVar(lang.NewSymbol("concat")) +if v751.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v751))) +} +v752 := v751.Get() +v753 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v754 := v753.FindInternedVar(lang.NewSymbol("list")) +if v754.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v754))) +} +v755 := v754.Get() +v756 := lang.Apply(v755, []any{lang.NewSymbol(".nth")}) +v757 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v758 := v757.FindInternedVar(lang.NewSymbol("list")) +if v758.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v758))) +} +v759 := v758.Get() +v760 := lang.Apply(v759, []any{lang.NewSymbol("c__0__auto__")}) +v761 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v762 := v761.FindInternedVar(lang.NewSymbol("list")) +if v762.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v762))) +} +v763 := v762.Get() +v764 := lang.Apply(v763, []any{v292}) +v765 := lang.Apply(v752, []any{v756, v760, v764}) +v766 := lang.Apply(v749, []any{v765}) +v767 := lang.Apply(v746, []any{v766}) +v768 := lang.Apply(v739, []any{v743, v767}) +v769 := lang.Apply(v736, []any{v768}) +v770 := lang.Apply(v730, []any{v733, v769}) +v771 := lang.Apply(v727, []any{v770}) +v772 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v773 := v772.FindInternedVar(lang.NewSymbol("list")) +if v773.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v773))) +} +v774 := v773.Get() +v775 := lang.Apply(v302, []any{v111}) +v776 := lang.Apply(v774, []any{v775}) +v777 := lang.Apply(v720, []any{v724, v771, v776}) +v778 := lang.Apply(v717, []any{v777}) +v779 := lang.Apply(v714, []any{v778}) +v780 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v781 := v780.FindInternedVar(lang.NewSymbol("list")) +if v781.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v781))) +} +v782 := v781.Get() +v783 := lang.Apply(v782, []any{true}) +v784 := lang.Apply(v683, []any{v687, v711, v779, v783}) +v785 := lang.Apply(v680, []any{v784}) +v786 := lang.Apply(v677, []any{v785}) +v787 := lang.Apply(v627, []any{v631, v674, v786}) +v788 := lang.Apply(v624, []any{v787}) +v789 := lang.Apply(v621, []any{v788}) +v790 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v791 := v790.FindInternedVar(lang.NewSymbol("list")) +if v791.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v791))) +} +v792 := v791.Get() +v793 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v794 := v793.FindInternedVar(lang.NewSymbol("seq")) +if v794.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v794))) +} +v795 := v794.Get() +v796 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v797 := v796.FindInternedVar(lang.NewSymbol("concat")) +if v797.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v797))) +} +v798 := v797.Get() +v799 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v800 := v799.FindInternedVar(lang.NewSymbol("list")) +if v800.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v800))) +} +v801 := v800.Get() +v802 := lang.Apply(v801, []any{lang.NewSymbol("glojure.core/chunk-cons")}) +v803 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v804 := v803.FindInternedVar(lang.NewSymbol("list")) +if v804.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v804))) +} +v805 := v804.Get() +v806 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v807 := v806.FindInternedVar(lang.NewSymbol("seq")) +if v807.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v807))) +} +v808 := v807.Get() +v809 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v810 := v809.FindInternedVar(lang.NewSymbol("concat")) +if v810.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v810))) +} +v811 := v810.Get() +v812 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v813 := v812.FindInternedVar(lang.NewSymbol("list")) +if v813.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v813))) +} +v814 := v813.Get() +v815 := lang.Apply(v814, []any{lang.NewSymbol("glojure.core/chunk")}) +v816 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v817 := v816.FindInternedVar(lang.NewSymbol("list")) +if v817.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v817))) +} +v818 := v817.Get() +v819 := lang.Apply(v818, []any{v297}) +v820 := lang.Apply(v811, []any{v815, v819}) +v821 := lang.Apply(v808, []any{v820}) +v822 := lang.Apply(v805, []any{v821}) +v823 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v824 := v823.FindInternedVar(lang.NewSymbol("list")) +if v824.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v824))) +} +v825 := v824.Get() +v826 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v827 := v826.FindInternedVar(lang.NewSymbol("seq")) +if v827.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v827))) +} +v828 := v827.Get() +v829 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v830 := v829.FindInternedVar(lang.NewSymbol("concat")) +if v830.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v830))) +} +v831 := v830.Get() +v832 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v833 := v832.FindInternedVar(lang.NewSymbol("list")) +if v833.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v833))) +} +v834 := v833.Get() +v835 := lang.Apply(v834, []any{v130}) +v836 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v837 := v836.FindInternedVar(lang.NewSymbol("list")) +if v837.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v837))) +} +v838 := v837.Get() +v839 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v840 := v839.FindInternedVar(lang.NewSymbol("seq")) +if v840.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v840))) +} +v841 := v840.Get() +v842 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v843 := v842.FindInternedVar(lang.NewSymbol("concat")) +if v843.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v843))) +} +v844 := v843.Get() +v845 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v846 := v845.FindInternedVar(lang.NewSymbol("list")) +if v846.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v846))) +} +v847 := v846.Get() +v848 := lang.Apply(v847, []any{lang.NewSymbol("glojure.core/chunk-rest")}) +v849 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v850 := v849.FindInternedVar(lang.NewSymbol("list")) +if v850.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v850))) +} +v851 := v850.Get() +v852 := lang.Apply(v851, []any{v135}) +v853 := lang.Apply(v844, []any{v848, v852}) +v854 := lang.Apply(v841, []any{v853}) +v855 := lang.Apply(v838, []any{v854}) +v856 := lang.Apply(v831, []any{v835, v855}) +v857 := lang.Apply(v828, []any{v856}) +v858 := lang.Apply(v825, []any{v857}) +v859 := lang.Apply(v798, []any{v802, v822, v858}) +v860 := lang.Apply(v795, []any{v859}) +v861 := lang.Apply(v792, []any{v860}) +v862 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v863 := v862.FindInternedVar(lang.NewSymbol("list")) +if v863.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v863))) +} +v864 := v863.Get() +v865 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v866 := v865.FindInternedVar(lang.NewSymbol("seq")) +if v866.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v866))) +} +v867 := v866.Get() +v868 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v869 := v868.FindInternedVar(lang.NewSymbol("concat")) +if v869.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v869))) +} +v870 := v869.Get() +v871 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v872 := v871.FindInternedVar(lang.NewSymbol("list")) +if v872.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v872))) +} +v873 := v872.Get() +v874 := lang.Apply(v873, []any{lang.NewSymbol("glojure.core/chunk-cons")}) +v875 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v876 := v875.FindInternedVar(lang.NewSymbol("list")) +if v876.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v876))) +} +v877 := v876.Get() +v878 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v879 := v878.FindInternedVar(lang.NewSymbol("seq")) +if v879.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v879))) +} +v880 := v879.Get() +v881 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v882 := v881.FindInternedVar(lang.NewSymbol("concat")) +if v882.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v882))) +} +v883 := v882.Get() +v884 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v885 := v884.FindInternedVar(lang.NewSymbol("list")) +if v885.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v885))) +} +v886 := v885.Get() +v887 := lang.Apply(v886, []any{lang.NewSymbol("glojure.core/chunk")}) +v888 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v889 := v888.FindInternedVar(lang.NewSymbol("list")) +if v889.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v889))) +} +v890 := v889.Get() +v891 := lang.Apply(v890, []any{v297}) +v892 := lang.Apply(v883, []any{v887, v891}) +v893 := lang.Apply(v880, []any{v892}) +v894 := lang.Apply(v877, []any{v893}) +v895 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v896 := v895.FindInternedVar(lang.NewSymbol("list")) +if v896.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v896))) +} +v897 := v896.Get() +v898 := lang.Apply(v897, []any{nil}) +v899 := lang.Apply(v870, []any{v874, v894, v898}) +v900 := lang.Apply(v867, []any{v899}) +v901 := lang.Apply(v864, []any{v900}) +v902 := lang.Apply(v614, []any{v618, v789, v861, v901}) +v903 := lang.Apply(v611, []any{v902}) +v904 := lang.Apply(v608, []any{v903}) +v905 := lang.Apply(v494, []any{v498, v605, v904}) +v906 := lang.Apply(v491, []any{v905}) +v907 := lang.Apply(v488, []any{v906}) +v908 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v909 := v908.FindInternedVar(lang.NewSymbol("list")) +if v909.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v909))) +} +v910 := v909.Get() +v911 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v912 := v911.FindInternedVar(lang.NewSymbol("seq")) +if v912.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v912))) +} +v913 := v912.Get() +v914 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v915 := v914.FindInternedVar(lang.NewSymbol("concat")) +if v915.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v915))) +} +v916 := v915.Get() +v917 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v918 := v917.FindInternedVar(lang.NewSymbol("list")) +if v918.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v918))) +} +v919 := v918.Get() +v920 := lang.Apply(v919, []any{lang.NewSymbol("glojure.core/let")}) +v921 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v922 := v921.FindInternedVar(lang.NewSymbol("list")) +if v922.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v922))) +} +v923 := v922.Get() +v924 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v925 := v924.FindInternedVar(lang.NewSymbol("apply")) +if v925.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v925))) +} +v926 := v925.Get() +v927 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v928 := v927.FindInternedVar(lang.NewSymbol("vector")) +if v928.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v928))) +} +v929 := v928.Get() +v930 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v931 := v930.FindInternedVar(lang.NewSymbol("seq")) +if v931.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v931))) +} +v932 := v931.Get() +v933 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v934 := v933.FindInternedVar(lang.NewSymbol("concat")) +if v934.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v934))) +} +v935 := v934.Get() +v936 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v937 := v936.FindInternedVar(lang.NewSymbol("list")) +if v937.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v937))) +} +v938 := v937.Get() +v939 := lang.Apply(v938, []any{v99}) +v940 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v941 := v940.FindInternedVar(lang.NewSymbol("list")) +if v941.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v941))) +} +v942 := v941.Get() +v943 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v944 := v943.FindInternedVar(lang.NewSymbol("seq")) +if v944.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v944))) +} +v945 := v944.Get() +v946 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v947 := v946.FindInternedVar(lang.NewSymbol("concat")) +if v947.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v947))) +} +v948 := v947.Get() +v949 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v950 := v949.FindInternedVar(lang.NewSymbol("list")) +if v950.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v950))) +} +v951 := v950.Get() +v952 := lang.Apply(v951, []any{lang.NewSymbol("glojure.core/first")}) +v953 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v954 := v953.FindInternedVar(lang.NewSymbol("list")) +if v954.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v954))) +} +v955 := v954.Get() +v956 := lang.Apply(v955, []any{v135}) +v957 := lang.Apply(v948, []any{v952, v956}) +v958 := lang.Apply(v945, []any{v957}) +v959 := lang.Apply(v942, []any{v958}) +v960 := lang.Apply(v935, []any{v939, v959}) +v961 := lang.Apply(v932, []any{v960}) +v962 := lang.Apply(v926, []any{v929, v961}) +v963 := lang.Apply(v923, []any{v962}) +v964 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v965 := v964.FindInternedVar(lang.NewSymbol("list")) +if v965.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v965))) +} +v966 := v965.Get() +v967 := lang.Apply(v140, []any{v111}) +v968 := lang.Apply(v966, []any{v967}) +v969 := lang.Apply(v916, []any{v920, v963, v968}) +v970 := lang.Apply(v913, []any{v969}) +v971 := lang.Apply(v910, []any{v970}) +v972 := lang.Apply(v461, []any{v465, v485, v907, v971}) +v973 := lang.Apply(v458, []any{v972}) +v974 := lang.Apply(v455, []any{v973}) +v975 := lang.Apply(v405, []any{v409, v452, v974}) +v976 := lang.Apply(v402, []any{v975}) +v977 := lang.Apply(v399, []any{v976}) +v978 := lang.Apply(v365, []any{v369, v396, v977}) +v979 := lang.Apply(v362, []any{v978}) +v980 := lang.Apply(v359, []any{v979}) +v981 := lang.Apply(v352, []any{v356, v980}) +v982 := lang.Apply(v349, []any{v981}) +v983 := lang.Apply(v346, []any{v982}) +v984 := lang.Apply(v312, []any{v316, v320, v343, v983}) +v985 := lang.Apply(v309, []any{v984}) +v145 = v985 +} +return v145 +}) +v65 := v64 +_ = v65 +} +v65 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4668), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(4729), lang.NewKeyword("end-column"), int(68)) +v66, err := lang.WithMeta(v64, v65.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v63 any = v66 +_ = v63 +v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v69 := v68.FindInternedVar(lang.NewSymbol("seq")) +if v69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) +} +v70 := v69.Get() +v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v72 := v71.FindInternedVar(lang.NewSymbol("concat")) +if v72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) +} +v73 := v72.Get() +v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v75 := v74.FindInternedVar(lang.NewSymbol("list")) +if v75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) +} +v76 := v75.Get() +v77 := lang.Apply(v76, []any{lang.NewSymbol("glojure.core/let")}) +v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v79 := v78.FindInternedVar(lang.NewSymbol("list")) +if v79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) +} +v80 := v79.Get() +v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v82 := v81.FindInternedVar(lang.NewSymbol("apply")) +if v82.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) +} +v83 := v82.Get() +v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v85 := v84.FindInternedVar(lang.NewSymbol("vector")) +if v85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) +} +v86 := v85.Get() +v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v88 := v87.FindInternedVar(lang.NewSymbol("seq")) +if v88.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) +} +v89 := v88.Get() +v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v91 := v90.FindInternedVar(lang.NewSymbol("concat")) +if v91.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) +} +v92 := v91.Get() +v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v94 := v93.FindInternedVar(lang.NewSymbol("list")) +if v94.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) +} +v95 := v94.Get() +v96 := lang.Apply(v95, []any{lang.NewSymbol("iter__0__auto__")}) +v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v98 := v97.FindInternedVar(lang.NewSymbol("list")) +if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) +} +v99 := v98.Get() +v100 := lang.Apply(v55, []any{v5}) +v101 := lang.Apply(v63, []any{v100}) +v102 := lang.Apply(v99, []any{v101}) +v103 := lang.Apply(v92, []any{v96, v102}) +v104 := lang.Apply(v89, []any{v103}) +v105 := lang.Apply(v83, []any{v86, v104}) +v106 := lang.Apply(v80, []any{v105}) +v107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v108 := v107.FindInternedVar(lang.NewSymbol("list")) +if v108.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v108))) +} +v109 := v108.Get() +v110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v111 := v110.FindInternedVar(lang.NewSymbol("seq")) +if v111.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v111))) +} +v112 := v111.Get() +v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v114 := v113.FindInternedVar(lang.NewSymbol("concat")) +if v114.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) +} +v115 := v114.Get() +v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v117 := v116.FindInternedVar(lang.NewSymbol("list")) +if v117.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) +} +v118 := v117.Get() +v119 := lang.Apply(v118, []any{lang.NewSymbol("iter__0__auto__")}) +v120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v121 := v120.FindInternedVar(lang.NewSymbol("list")) +if v121.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v121))) +} +v122 := v121.Get() +v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v124 := v123.FindInternedVar(lang.NewSymbol("second")) +if v124.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) +} +v125 := v124.Get() +v126 := lang.Apply(v125, []any{v5}) +v127 := lang.Apply(v122, []any{v126}) +v128 := lang.Apply(v115, []any{v119, v127}) +v129 := lang.Apply(v112, []any{v128}) +v130 := lang.Apply(v109, []any{v129}) +v131 := lang.Apply(v73, []any{v77, v106, v130}) +v132 := lang.Apply(v70, []any{v131}) +return v132 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// derive +{ +v0 := lang.NewSymbol("derive").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag"), lang.NewSymbol("parent")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"), lang.NewSymbol("parent"))), lang.NewKeyword("doc"), "Establishes a parent/child relationship between parent and\n tag. Parent must be a namespace-qualified symbol or keyword and\n child can be either a namespace-qualified symbol or keyword or a\n class. h must be a hierarchy obtained from make-hierarchy, if not\n supplied defaults to, and modifies, the global hierarchy.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5648), lang.NewKeyword("end-line"), int(5648))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v3 := args[0] +v4 := args[1] +_ = nil +_ = nil +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("alter-var-root")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("global-hierarchy")) +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("derive")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v7, []any{v8, v11, v3, v4}) +_ = v12 +return nil + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +_ = nil +_ = nil +_ = nil +v7 := lang.Apply(lang.NewKeyword("parents"), []any{v3}) +var v6 any = v7 +_ = v6 +v9 := lang.Apply(lang.NewKeyword("descendants"), []any{v3}) +var v8 any = v9 +_ = v8 +v11 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) +var v10 any = v11 +_ = v10 +var v13 lang.FnFunc +v13 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 5 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v14 := args[0] +v15 := args[1] +v16 := args[2] +v17 := args[3] +v18 := args[4] +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("reduce1")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +var v22 lang.FnFunc +v22 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v23 := args[0] +v24 := args[1] +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("assoc")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("reduce1")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("conj")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("get")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.CreatePersistentTreeSet() +v38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5671), lang.NewKeyword("column"), int(61), lang.NewKeyword("end-line"), int(5671), lang.NewKeyword("end-column"), int(63)) +v39, err := lang.WithMeta(v37, v38.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v40 := lang.Apply(v36, []any{v18, v24, v39}) +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("cons")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v18, []any{v17}) +v45 := lang.Apply(v43, []any{v17, v44}) +v46 := lang.Apply(v30, []any{v33, v40, v45}) +v47 := lang.Apply(v27, []any{v23, v24, v46}) +return v47 +}) +v23 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5669), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(5671), lang.NewKeyword("end-column"), int(98)) +v24, err := lang.WithMeta(v22, v23.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("cons")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.Apply(v16, []any{v15}) +v29 := lang.Apply(v27, []any{v15, v28}) +v30 := lang.Apply(v21, []any{v24, v14, v29}) +return v30 +}) +v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5668), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(5672), lang.NewKeyword("end-column"), int(56)) +v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v12 any = v15 +_ = v12 +var v18 any +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("contains?")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v6, []any{v4}) +v23 := lang.Apply(v21, []any{v22, v5}) +if lang.IsTruthy(v23) { +v18 = nil +} else { +var v24 any +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("contains?")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.Apply(v10, []any{v4}) +v29 := lang.Apply(v27, []any{v28, v5}) +if lang.IsTruthy(v29) { +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("print-str")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.Apply(v32, []any{v4, "already has", v5, "as ancestor"}) +v34 := lang.Apply(Exception25., []any{v33}) +panic(v34) +} else { +v24 = nil +} +_ = v24 +var v35 any +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("contains?")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v10, []any{v5}) +v40 := lang.Apply(v38, []any{v39, v4}) +if lang.IsTruthy(v40) { +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("print-str")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v43, []any{"Cyclic derivation:", v5, "has", v4, "as ancestor"}) +v45 := lang.Apply(Exception25., []any{v44}) +panic(v45) +} else { +v35 = nil +} +_ = v35 +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("assoc")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +} +v48 := v47.Get() +v49 := lang.Apply(lang.NewKeyword("parents"), []any{v3}) +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("conj")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +} +v52 := v51.Get() +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("get")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +} +v55 := v54.Get() +v56 := lang.CreatePersistentTreeSet() +v57 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5679), lang.NewKeyword("column"), int(61), lang.NewKeyword("end-line"), int(5679), lang.NewKeyword("end-column"), int(63)) +v58, err := lang.WithMeta(v56, v57.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v59 := lang.Apply(v55, []any{v6, v4, v58}) +v60 := lang.Apply(v52, []any{v59, v5}) +v61 := lang.Apply(v48, []any{v49, v4, v60}) +v62 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) +v63 := lang.Apply(v12, []any{v62, v4, v8, v5, v10}) +v64 := lang.Apply(lang.NewKeyword("descendants"), []any{v3}) +v65 := lang.Apply(v12, []any{v64, v5, v10, v4, v8}) +v66 := lang.NewMap(lang.NewKeyword("parents"), v61, lang.NewKeyword("ancestors"), v63, lang.NewKeyword("descendants"), v65) +v67 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5679), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(5681), lang.NewKeyword("end-column"), int(61)) +v68, err := lang.WithMeta(v66, v67.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v18 = v68 +} +var v17 any = v18 +_ = v17 +var v70 any +if lang.IsTruthy(v17) { +v70 = v17 +} else { +v70 = v3 +} +return v70 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// future +{ +v0 := lang.NewSymbol("future").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Takes a body of expressions and yields a future object that will\n invoke the body in another thread, and will cache the result and\n return it on all subsequent calls to deref/@. If the computation has\n not yet finished, calls to deref/@ will block, unless the variant of\n deref with timeout is used. See also - realized?.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7052), lang.NewKeyword("end-line"), int(7052))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("seq")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("concat")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("list")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{lang.NewSymbol("glojure.core/future-call")}) +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("list")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("seq")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("concat")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("list")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.Apply(v27, []any{lang.NewSymbol("fn*")}) +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("list")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("apply")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("vector")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("seq")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("concat")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v43, nil) +v45 := lang.Apply(v40, []any{v44}) +v46 := lang.Apply(v34, []any{v37, v45}) +v47 := lang.Apply(v31, []any{v46}) +v48 := lang.Apply(v24, []any{v28, v47, v5}) +v49 := lang.Apply(v21, []any{v48}) +v50 := lang.Apply(v18, []any{v49}) +v51 := lang.Apply(v11, []any{v15, v50}) +v52 := lang.Apply(v8, []any{v51}) +return v52 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// cond->> +{ +v0 := lang.NewSymbol("cond->>").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes an expression and a set of test/form pairs. Threads expr (via ->>)\n through each form for which the corresponding test expression\n is true. Note that, unlike cond branching, cond->> threading does not short circuit\n after the first true test expression.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7624), lang.NewKeyword("end-line"), int(7624))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +_ = nil +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("gensym")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, nil) +var v7 any = v11 +_ = v7 +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("map")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +var v16 lang.FnFunc +v16 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v17 := args[0] +var v18 any = v17 +_ = v18 +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("nth")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.Apply(v22, []any{v18, int64(0), nil}) +var v19 any = v23 +_ = v19 +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("nth")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.Apply(v27, []any{v18, int64(1), nil}) +var v24 any = v28 +_ = v24 +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("seq")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("concat")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{lang.NewSymbol("if")}) +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v19}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("seq")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +} +v49 := v48.Get() +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("concat")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +} +v52 := v51.Get() +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("list")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +} +v55 := v54.Get() +v56 := lang.Apply(v55, []any{lang.NewSymbol("glojure.core/->>")}) +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("list")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +} +v59 := v58.Get() +v60 := lang.Apply(v59, []any{v7}) +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("list")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +} +v63 := v62.Get() +v64 := lang.Apply(v63, []any{v24}) +v65 := lang.Apply(v52, []any{v56, v60, v64}) +v66 := lang.Apply(v49, []any{v65}) +v67 := lang.Apply(v46, []any{v66}) +v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v69 := v68.FindInternedVar(lang.NewSymbol("list")) +if v69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) +} +v70 := v69.Get() +v71 := lang.Apply(v70, []any{v7}) +v72 := lang.Apply(v35, []any{v39, v43, v67, v71}) +v73 := lang.Apply(v32, []any{v72}) +return v73 +}) +v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7633), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7633), lang.NewKeyword("end-column"), int(67)) +v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("partition")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{int64(2), v6}) +v23 := lang.Apply(v15, []any{v18, v22}) +var v12 any = v23 +_ = v12 +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("seq")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("concat")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/let")}) +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("list")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("apply")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("vector")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("seq")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("concat")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +} +v49 := v48.Get() +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("list")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +} +v52 := v51.Get() +v53 := lang.Apply(v52, []any{v7}) +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("list")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +} +v56 := v55.Get() +v57 := lang.Apply(v56, []any{v5}) +v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v59 := v58.FindInternedVar(lang.NewSymbol("interleave")) +if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) +} +v60 := v59.Get() +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("repeat")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +} +v63 := v62.Get() +v64 := lang.Apply(v63, []any{v7}) +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("butlast")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +} +v67 := v66.Get() +v68 := lang.Apply(v67, []any{v12}) +v69 := lang.Apply(v60, []any{v64, v68}) +v70 := lang.Apply(v49, []any{v53, v57, v69}) +v71 := lang.Apply(v46, []any{v70}) +v72 := lang.Apply(v40, []any{v43, v71}) +v73 := lang.Apply(v37, []any{v72}) +v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v75 := v74.FindInternedVar(lang.NewSymbol("list")) +if v75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) +} +v76 := v75.Get() +var v77 any +v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v79 := v78.FindInternedVar(lang.NewSymbol("empty?")) +if v79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) +} +v80 := v79.Get() +v81 := lang.Apply(v80, []any{v12}) +if lang.IsTruthy(v81) { +v77 = v7 +} else { +v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v83 := v82.FindInternedVar(lang.NewSymbol("last")) +if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) +} +v84 := v83.Get() +v85 := lang.Apply(v84, []any{v12}) +v77 = v85 +} +v86 := lang.Apply(v76, []any{v77}) +v87 := lang.Apply(v30, []any{v34, v73, v86}) +v88 := lang.Apply(v27, []any{v87}) +return v88 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// pmap +{ +v0 := lang.NewSymbol("pmap").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Like map, except f is applied in parallel. Semi-lazy in that the\n parallel computation stays ahead of the consumption, but doesn't\n realize the entire result unless required. Only useful for\n computationally intensive functions where the time of f dominates\n the coordination overhead.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7074), lang.NewKeyword("end-line"), int(7074))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v3 := args[0] +v4 := args[1] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("+")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(runtime26.NumCPU, nil) +v10 := lang.Apply(v8, []any{int64(2), v9}) +var v5 any = v10 +_ = v5 +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("map")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +var v15 lang.FnFunc +v15 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v16 := args[0] +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("future-call")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +var v20 lang.FnFunc +v20 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v21 := lang.Apply(v3, []any{v16}) +return v21 +}) +v21 := lang.Apply(v19, []any{v20}) +return v21 +}) +v16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7084), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7084), lang.NewKeyword("end-column"), int(34)) +v17, err := lang.WithMeta(v15, v16.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v18 := lang.Apply(v14, []any{v17, v4}) +var v11 any = v18 +_ = v11 +var v20 lang.FnFunc +{ // function step +v20 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v22 := args[0] +v23 := args[1] +var v24 any = v22 +_ = v24 +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("seq")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.Apply(v28, []any{v24}) +var v25 any = v29 +_ = v25 +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("first")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v25}) +var v30 any = v34 +_ = v30 +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("next")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v35}) +var v35 any = v39 +_ = v35 +var v40 any = v30 +_ = v40 +var v41 any = v35 +_ = v41 +var v42 any = v24 +_ = v42 +var v44 lang.FnFunc +v44 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("seq")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +} +v48 := v47.Get() +v49 := lang.Apply(v48, []any{v23}) +var v45 any = v49 +_ = v45 +var v51 any +if lang.IsTruthy(v45) { +var v52 any = v45 +_ = v52 +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("cons")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +} +v56 := v55.Get() +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("deref")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +} +v59 := v58.Get() +v60 := lang.Apply(v59, []any{v40}) +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("rest")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +} +v63 := v62.Get() +v64 := lang.Apply(v63, []any{v52}) +v65 := lang.Apply(v21, []any{v41, v64}) +v66 := lang.Apply(v56, []any{v60, v65}) +v51 = v66 +} else { +v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v53 := v52.FindInternedVar(lang.NewSymbol("map")) +if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) +} +v54 := v53.Get() +v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v56 := v55.FindInternedVar(lang.NewSymbol("deref")) +if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) +} +v57 := v56.Get() +v58 := lang.Apply(v54, []any{v57, v42}) +v51 = v58 +} +return v51 +}) +v45 := lang.Apply(lang1.NewLazySeq, []any{v44}) +return v45 +}) +v21 := v20 +_ = v21 +} +v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7085), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(7089), lang.NewKeyword("end-column"), int(36)) +v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v19 any = v22 +_ = v19 +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("drop")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v5, v11}) +v28 := lang.Apply(v19, []any{v11, v27}) +return v28 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +var v7 lang.FnFunc +{ // function step +v7 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v9 := args[0] +var v10 lang.FnFunc +v10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("map")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("seq")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v14, []any{v17, v9}) +var v11 any = v18 +_ = v11 +var v20 any +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("every?")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("identity")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.Apply(v23, []any{v26, v11}) +if lang.IsTruthy(v27) { +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("cons")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("map")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("first")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.Apply(v33, []any{v36, v11}) +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("map")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("rest")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v40, []any{v43, v11}) +v45 := lang.Apply(v8, []any{v44}) +v46 := lang.Apply(v30, []any{v37, v45}) +v20 = v46 +} else { +v20 = nil +} +return v20 +}) +v11 := lang.Apply(lang1.NewLazySeq, []any{v10}) +return v11 +}) +v8 := v7 +_ = v8 +} +v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7092), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(7096), lang.NewKeyword("end-column"), int(67)) +v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v6 any = v9 +_ = v6 +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("pmap")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +var v14 lang.FnFunc +v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v15 := args[0] +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("apply")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v3, v15}) +return v19 +}) +v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7097), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(7097), lang.NewKeyword("end-column"), int(23)) +v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("cons")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v4, v5}) +v21 := lang.Apply(v6, []any{v20}) +v22 := lang.Apply(v13, []any{v16, v21}) +return v22 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// defonce +{ +v0 := lang.NewSymbol("defonce").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("expr"))), lang.NewKeyword("doc"), "defs name to have the root value of the expr iff the named var has no root value,\n else expr is unevaluated", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5849), lang.NewKeyword("end-line"), int(5849))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("seq")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("concat")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("list")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/let")}) +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("list")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("apply")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("vector")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("seq")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("concat")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{lang.NewSymbol("v__0__auto__")}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("seq")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +} +v41 := v40.Get() +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("concat")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +} +v44 := v43.Get() +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("list")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +} +v47 := v46.Get() +v48 := lang.Apply(v47, []any{lang.NewSymbol("def")}) +v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v50 := v49.FindInternedVar(lang.NewSymbol("list")) +if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) +} +v51 := v50.Get() +v52 := lang.Apply(v51, []any{v5}) +v53 := lang.Apply(v44, []any{v48, v52}) +v54 := lang.Apply(v41, []any{v53}) +v55 := lang.Apply(v38, []any{v54}) +v56 := lang.Apply(v31, []any{v35, v55}) +v57 := lang.Apply(v28, []any{v56}) +v58 := lang.Apply(v22, []any{v25, v57}) +v59 := lang.Apply(v19, []any{v58}) +v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v61 := v60.FindInternedVar(lang.NewSymbol("list")) +if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) +} +v62 := v61.Get() +v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v64 := v63.FindInternedVar(lang.NewSymbol("seq")) +if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) +} +v65 := v64.Get() +v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v67 := v66.FindInternedVar(lang.NewSymbol("concat")) +if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) +} +v68 := v67.Get() +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("list")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +} +v71 := v70.Get() +v72 := lang.Apply(v71, []any{lang.NewSymbol("glojure.core/when-not")}) +v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v74 := v73.FindInternedVar(lang.NewSymbol("list")) +if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) +} +v75 := v74.Get() +v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v77 := v76.FindInternedVar(lang.NewSymbol("seq")) +if v77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) +} +v78 := v77.Get() +v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v80 := v79.FindInternedVar(lang.NewSymbol("concat")) +if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) +} +v81 := v80.Get() +v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v83 := v82.FindInternedVar(lang.NewSymbol("list")) +if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) +} +v84 := v83.Get() +v85 := lang.Apply(v84, []any{lang.NewSymbol(".HasRoot")}) +v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v87 := v86.FindInternedVar(lang.NewSymbol("list")) +if v87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) +} +v88 := v87.Get() +v89 := lang.Apply(v88, []any{lang.NewSymbol("v__0__auto__")}) +v90 := lang.Apply(v81, []any{v85, v89}) +v91 := lang.Apply(v78, []any{v90}) +v92 := lang.Apply(v75, []any{v91}) +v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v94 := v93.FindInternedVar(lang.NewSymbol("list")) +if v94.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) +} +v95 := v94.Get() +v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v97 := v96.FindInternedVar(lang.NewSymbol("seq")) +if v97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) +} +v98 := v97.Get() +v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v100 := v99.FindInternedVar(lang.NewSymbol("concat")) +if v100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) +} +v101 := v100.Get() +v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v103 := v102.FindInternedVar(lang.NewSymbol("list")) +if v103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) +} +v104 := v103.Get() +v105 := lang.Apply(v104, []any{lang.NewSymbol("def")}) +v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v107 := v106.FindInternedVar(lang.NewSymbol("list")) +if v107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) +} +v108 := v107.Get() +v109 := lang.Apply(v108, []any{v5}) +v110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v111 := v110.FindInternedVar(lang.NewSymbol("list")) +if v111.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v111))) +} +v112 := v111.Get() +v113 := lang.Apply(v112, []any{v6}) +v114 := lang.Apply(v101, []any{v105, v109, v113}) +v115 := lang.Apply(v98, []any{v114}) +v116 := lang.Apply(v95, []any{v115}) +v117 := lang.Apply(v68, []any{v72, v92, v116}) +v118 := lang.Apply(v65, []any{v117}) +v119 := lang.Apply(v62, []any{v118}) +v120 := lang.Apply(v12, []any{v16, v59, v119}) +v121 := lang.Apply(v9, []any{v120}) +return v121 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// dorun +{ +v0 := lang.NewSymbol("dorun").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "When lazy sequences are produced via functions that have side\n effects, any effects other than those needed to produce the first\n element in the seq do not occur until the seq is consumed. dorun can\n be used to force any effects. Walks through the successive nexts of\n the seq, does not retain the head and returns nil.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3116), lang.NewKeyword("end-line"), int(3116))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +recur_loop_579: +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +var v4 any = v8 +_ = v4 +var v10 any +if lang.IsTruthy(v4) { +var v11 any = v4 +_ = v11 +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("next")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v11}) +var v13 any = v17 +v3 = v13 +goto recur_loop_579 +} else { +v10 = nil +} +return v10 + case 2: +v3 := args[0] +v4 := args[1] +recur_loop_580: +var v5 any +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("seq")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v4}) +var v6 any = v10 +_ = v6 +var v12 any +if lang.IsTruthy(v6) { +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("pos?")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v3}) +v12 = v16 +} else { +v12 = v6 +} +if lang.IsTruthy(v12) { +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("dec")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v3}) +var v6 any = v10 +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("next")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v4}) +var v11 any = v15 +v3 = v6 +v4 = v11 +goto recur_loop_580 +} else { +v5 = nil +} +return v5 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// max-switch-table-size +{ +v0 := lang.NewSymbol("max-switch-table-size").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6645), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(6645), lang.NewKeyword("end-column"), int(36), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, int64(8192), true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// assert +{ +v0 := lang.NewSymbol("assert").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("message"))), lang.NewKeyword("doc"), "Evaluates expression x and throws an AssertionError with optional\n message if x does not evaluate to logical true.\n\n Assertion checks are omitted from compiled code if '*assert*' is\n false.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4837), lang.NewKeyword("end-line"), int(4837))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +var v6 any +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("*assert*")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +if lang.IsTruthy(v9) { +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("seq")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("concat")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("list")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{lang.NewSymbol("glojure.core/when-not")}) +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("list")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.Apply(v22, []any{v5}) +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("list")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("seq")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("concat")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("list")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v35, []any{lang.NewSymbol("throw")}) +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("list")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("seq")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("concat")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +} +v45 := v44.Get() +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("list")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +} +v48 := v47.Get() +v49 := lang.Apply(v48, []any{lang.NewSymbol("new")}) +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("list")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +} +v52 := v51.Get() +v53 := lang.Apply(v52, []any{lang.NewSymbol("glojure.core/AssertionError")}) +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("list")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +} +v56 := v55.Get() +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("seq")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +} +v59 := v58.Get() +v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v61 := v60.FindInternedVar(lang.NewSymbol("concat")) +if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) +} +v62 := v61.Get() +v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v64 := v63.FindInternedVar(lang.NewSymbol("list")) +if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) +} +v65 := v64.Get() +v66 := lang.Apply(v65, []any{lang.NewSymbol("glojure.core/str")}) +v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v68 := v67.FindInternedVar(lang.NewSymbol("list")) +if v68.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) +} +v69 := v68.Get() +v70 := lang.Apply(v69, []any{"Assert failed: "}) +v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v72 := v71.FindInternedVar(lang.NewSymbol("list")) +if v72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) +} +v73 := v72.Get() +v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v75 := v74.FindInternedVar(lang.NewSymbol("seq")) +if v75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) +} +v76 := v75.Get() +v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v78 := v77.FindInternedVar(lang.NewSymbol("concat")) +if v78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) +} +v79 := v78.Get() +v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v81 := v80.FindInternedVar(lang.NewSymbol("list")) +if v81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) +} +v82 := v81.Get() +v83 := lang.Apply(v82, []any{lang.NewSymbol("glojure.core/pr-str")}) +v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v85 := v84.FindInternedVar(lang.NewSymbol("list")) +if v85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) +} +v86 := v85.Get() +v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v88 := v87.FindInternedVar(lang.NewSymbol("seq")) +if v88.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) +} +v89 := v88.Get() +v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v91 := v90.FindInternedVar(lang.NewSymbol("concat")) +if v91.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) +} +v92 := v91.Get() +v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v94 := v93.FindInternedVar(lang.NewSymbol("list")) +if v94.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) +} +v95 := v94.Get() +v96 := lang.Apply(v95, []any{lang.NewSymbol("quote")}) +v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v98 := v97.FindInternedVar(lang.NewSymbol("list")) +if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) +} +v99 := v98.Get() +v100 := lang.Apply(v99, []any{v5}) +v101 := lang.Apply(v92, []any{v96, v100}) +v102 := lang.Apply(v89, []any{v101}) +v103 := lang.Apply(v86, []any{v102}) +v104 := lang.Apply(v79, []any{v83, v103}) +v105 := lang.Apply(v76, []any{v104}) +v106 := lang.Apply(v73, []any{v105}) +v107 := lang.Apply(v62, []any{v66, v70, v106}) +v108 := lang.Apply(v59, []any{v107}) +v109 := lang.Apply(v56, []any{v108}) +v110 := lang.Apply(v45, []any{v49, v53, v109}) +v111 := lang.Apply(v42, []any{v110}) +v112 := lang.Apply(v39, []any{v111}) +v113 := lang.Apply(v32, []any{v36, v112}) +v114 := lang.Apply(v29, []any{v113}) +v115 := lang.Apply(v26, []any{v114}) +v116 := lang.Apply(v15, []any{v19, v23, v115}) +v117 := lang.Apply(v12, []any{v116}) +v6 = v117 +} else { +v6 = nil +} +return v6 + case 4: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +var v7 any +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("*assert*")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +if lang.IsTruthy(v10) { +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("seq")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("concat")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("list")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v19, []any{lang.NewSymbol("glojure.core/when-not")}) +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("list")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v5}) +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("list")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("seq")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("concat")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("list")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.Apply(v36, []any{lang.NewSymbol("throw")}) +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("list")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("seq")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("concat")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("list")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +} +v49 := v48.Get() +v50 := lang.Apply(v49, []any{lang.NewSymbol("new")}) +v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v52 := v51.FindInternedVar(lang.NewSymbol("list")) +if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) +} +v53 := v52.Get() +v54 := lang.Apply(v53, []any{lang.NewSymbol("glojure.core/AssertionError")}) +v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v56 := v55.FindInternedVar(lang.NewSymbol("list")) +if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) +} +v57 := v56.Get() +v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v59 := v58.FindInternedVar(lang.NewSymbol("seq")) +if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) +} +v60 := v59.Get() +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("concat")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +} +v63 := v62.Get() +v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v65 := v64.FindInternedVar(lang.NewSymbol("list")) +if v65.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) +} +v66 := v65.Get() +v67 := lang.Apply(v66, []any{lang.NewSymbol("glojure.core/str")}) +v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v69 := v68.FindInternedVar(lang.NewSymbol("list")) +if v69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) +} +v70 := v69.Get() +v71 := lang.Apply(v70, []any{"Assert failed: "}) +v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v73 := v72.FindInternedVar(lang.NewSymbol("list")) +if v73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) +} +v74 := v73.Get() +v75 := lang.Apply(v74, []any{v6}) +v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v77 := v76.FindInternedVar(lang.NewSymbol("list")) +if v77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) +} +v78 := v77.Get() +v79 := lang.Apply(v78, []any{"\n"}) +v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v81 := v80.FindInternedVar(lang.NewSymbol("list")) +if v81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) +} +v82 := v81.Get() +v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v84 := v83.FindInternedVar(lang.NewSymbol("seq")) +if v84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) +} +v85 := v84.Get() +v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v87 := v86.FindInternedVar(lang.NewSymbol("concat")) +if v87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) +} +v88 := v87.Get() +v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v90 := v89.FindInternedVar(lang.NewSymbol("list")) +if v90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) +} +v91 := v90.Get() +v92 := lang.Apply(v91, []any{lang.NewSymbol("glojure.core/pr-str")}) +v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v94 := v93.FindInternedVar(lang.NewSymbol("list")) +if v94.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) +} +v95 := v94.Get() +v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v97 := v96.FindInternedVar(lang.NewSymbol("seq")) +if v97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) +} +v98 := v97.Get() +v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v100 := v99.FindInternedVar(lang.NewSymbol("concat")) +if v100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) +} +v101 := v100.Get() +v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v103 := v102.FindInternedVar(lang.NewSymbol("list")) +if v103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) +} +v104 := v103.Get() +v105 := lang.Apply(v104, []any{lang.NewSymbol("quote")}) +v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v107 := v106.FindInternedVar(lang.NewSymbol("list")) +if v107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) +} +v108 := v107.Get() +v109 := lang.Apply(v108, []any{v5}) +v110 := lang.Apply(v101, []any{v105, v109}) +v111 := lang.Apply(v98, []any{v110}) +v112 := lang.Apply(v95, []any{v111}) +v113 := lang.Apply(v88, []any{v92, v112}) +v114 := lang.Apply(v85, []any{v113}) +v115 := lang.Apply(v82, []any{v114}) +v116 := lang.Apply(v63, []any{v67, v71, v75, v79, v115}) +v117 := lang.Apply(v60, []any{v116}) +v118 := lang.Apply(v57, []any{v117}) +v119 := lang.Apply(v46, []any{v50, v54, v118}) +v120 := lang.Apply(v43, []any{v119}) +v121 := lang.Apply(v40, []any{v120}) +v122 := lang.Apply(v33, []any{v37, v121}) +v123 := lang.Apply(v30, []any{v122}) +v124 := lang.Apply(v27, []any{v123}) +v125 := lang.Apply(v16, []any{v20, v24, v124}) +v126 := lang.Apply(v13, []any{v125}) +v7 = v126 +} else { +v7 = nil +} +return v7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// assoc! +{ +v0 := lang.NewSymbol("assoc!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("key"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("key"), lang.NewSymbol("val"), lang.NewSymbol("&"), lang.NewSymbol("kvs"))), lang.NewKeyword("doc"), "When applied to a transient map, adds mapping of key(s) to\n val(s). When applied to a transient vector, sets the val at index.\n Note - index must be <= (count vector). Returns coll.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3369), lang.NewKeyword("end-line"), int(3369))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6, _ := lang.FieldOrMethod(v3, "Assoc") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Assoc is not a function"))) +} +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +recur_loop_609: +v8, _ := lang.FieldOrMethod(v3, "Assoc") +if reflect.TypeOf(v8).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Assoc is not a function"))) +} +v9 := lang.Apply(v8, []any{v4, v5}) +var v7 any = v9 +_ = v7 +var v11 any +if lang.IsTruthy(v6) { +var v12 any = v7 +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("first")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v6}) +var v13 any = v17 +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("second")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v6}) +var v18 any = v22 +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("nnext")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v6}) +var v23 any = v27 +v3 = v12 +v4 = v13 +v5 = v18 +v6 = v23 +goto recur_loop_609 +} else { +v11 = v7 +} +return v11 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// tagged-literal +{ +v0 := lang.NewSymbol("tagged-literal").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag"), lang.NewSymbol("form"))), lang.NewKeyword("doc"), "Construct a data representation of a tagged literal from a\n tag symbol and a form.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7822), lang.NewKeyword("end-line"), int(7822))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.Apply(nil, []any{v3, v4}) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// assert-valid-fdecl +{ +v0 := lang.NewSymbol("assert-valid-fdecl").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fdecl"))), lang.NewKeyword("doc"), "A good fdecl looks like (([a] ...) ([a b] ...)) near the end of defn.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(42), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(7545), lang.NewKeyword("end-line"), int(7545), lang.NewKeyword("private"), true, lang.NewKeyword("dynamic"), true)).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("empty?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +if lang.IsTruthy(v8) { +v9 := lang.Apply(lang1.NewIllegalArgumentError, []any{"Parameter declaration missing"}) +panic(v9) +} else { +v4 = nil +} +_ = v4 +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("map")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +var v14 lang.FnFunc +v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v15 := args[0] +var v16 any +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq?")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v15}) +if lang.IsTruthy(v20) { +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("first")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v15}) +v16 = v24 +} else { +var v25 any +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("seq?")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("first")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.Apply(v31, []any{v3}) +v33 := lang.Apply(v28, []any{v32}) +if lang.IsTruthy(v33) { +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("str")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.Apply(v36, []any{"Invalid signature \"", v15, "\" should be a list"}) +v25 = v37 +} else { +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("str")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.Apply(v40, []any{"Parameter declaration \"", v15, "\" should be a vector"}) +v25 = v41 +} +v42 := lang.Apply(lang1.NewIllegalArgumentError, []any{v25}) +panic(v42) +} +return v16 +}) +v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7551), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7560), lang.NewKeyword("end-column"), int(59)) +v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v17 := lang.Apply(v13, []any{v16, v3}) +var v10 any = v17 +_ = v10 +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("seq")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("remove")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +var v25 lang.FnFunc +v25 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v26 := args[0] +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("vector?")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{v26}) +return v30 +}) +v26 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7562), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(7562), lang.NewKeyword("end-column"), int(42)) +v27, err := lang.WithMeta(v25, v26.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v28 := lang.Apply(v24, []any{v27, v10}) +v29 := lang.Apply(v21, []any{v28}) +var v18 any = v29 +_ = v18 +var v31 any +if lang.IsTruthy(v18) { +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("str")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("first")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v37, []any{v18}) +v39 := lang.Apply(v34, []any{"Parameter declaration \"", v38, "\" should be a vector"}) +v40 := lang.Apply(lang1.NewIllegalArgumentError, []any{v39}) +panic(v40) +} else { +v31 = nil +} +return v31 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// pop! +{ +v0 := lang.NewSymbol("pop!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Removes the last item from a transient vector. If\n the collection is empty, throws an exception. Returns coll", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3393), lang.NewKeyword("end-line"), int(3393))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, ok := lang.FieldOrMethod(v3, "pop") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "pop"))) +} +var v5 any +switch reflect.TypeOf(v4).Kind() { +case reflect.Func: + v5 = lang.Apply(v4, nil) +default: + v5 = v4 +} +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// into-array +{ +v0 := lang.NewSymbol("into-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("aseq")), lang.NewVector(lang.NewSymbol("type"), lang.NewSymbol("aseq"))), lang.NewKeyword("doc"), "Returns an array with components set to the values in aseq. The array's\n component type is type if provided, or the type of the first value in\n aseq if present, or Object. All values in aseq must be compatible with\n the component type. Class objects for the primitive types can be obtained\n using, e.g., Integer/TYPE.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3444), lang.NewKeyword("end-line"), int(3444))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{v3}) +v8 := lang.Apply(nil, []any{v7}) +return v8 + case 2: +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v4}) +v9 := lang.Apply(nil, []any{v3, v8}) +return v9 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// set-validator! +{ +v0 := lang.NewSymbol("set-validator!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("iref"), lang.NewSymbol("validator-fn"))), lang.NewKeyword("doc"), "Sets the validator-fn for a var/ref/agent/atom. validator-fn must be nil or a\n side-effect-free fn of one argument, which will be passed the intended\n new state on any state change. If the new state is unacceptable, the\n validator-fn should return false or throw an exception. If the current state (root\n value if var) is not acceptable to the new validator, an exception\n will be thrown and the validator will not be changed.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2381), lang.NewKeyword("end-line"), int(2381))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5, _ := lang.FieldOrMethod(v3, "setValidator") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setValidator is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// char-name-string +{ +v1 := reflect.TypeOf("") +v0 := lang.NewSymbol("char-name-string").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("doc"), "Returns name string for char or nil if none", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(6), lang.NewKeyword("line"), int(335), lang.NewKeyword("end-line"), int(338))).(*lang.Symbol) +v2 := ns.InternWithValue(v0, lang.NewMap(lang.NewChar(10), "newline", lang.NewChar(9), "tab", lang.NewChar(32), "space", lang.NewChar(8), "backspace", lang.NewChar(12), "formfeed", lang.NewChar(13), "return"), true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// char-escape-string +{ +v1 := reflect.TypeOf("") +v0 := lang.NewSymbol("char-escape-string").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("doc"), "Returns escape string for char or nil if none", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(6), lang.NewKeyword("line"), int(214), lang.NewKeyword("end-line"), int(217))).(*lang.Symbol) +v2 := ns.InternWithValue(v0, lang.NewMap(lang.NewChar(10), "\\n", lang.NewChar(9), "\\t", lang.NewChar(13), "\\r", lang.NewChar(34), "\\\"", lang.NewChar(92), "\\\\", lang.NewChar(12), "\\f", lang.NewChar(8), "\\b"), true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// byte +{ +var v1 lang.FnFunc +{ // function byte__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +var v30 any +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +if lang.IsTruthy(v33) { +v30 = lang.NewSymbol("uncheckedByteCast") +} else { +v30 = lang.NewSymbol("byteCast") +} +v34 := lang.Apply(v29, []any{v30}) +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("list")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v37, []any{v3}) +v39 := lang.Apply(v26, []any{v34, v38}) +v40 := lang.Apply(v23, []any{v39}) +v41 := lang.Apply(v20, []any{v40}) +v42 := lang.Apply(v9, []any{v13, v17, v41}) +v43 := lang.Apply(v6, []any{v42}) +return v43 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("byte").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to byte", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3505), lang.NewKeyword("end-line"), int(3505))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := lang.Apply(lang1.ByteCast, []any{v4}) +return v5 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// >1? +{ +v0 := lang.NewSymbol(">1?").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(962), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(962), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) +} +v5 := lang.Apply(v4, []any{v3, int64(1)}) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// ints +{ +var v1 lang.FnFunc +{ // function ints +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/ints")}) +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("list")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v3}) +v26 := lang.Apply(v9, []any{v13, v17, v21, v25}) +v27 := lang.Apply(v6, []any{v26}) +return v27 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("ints").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Casts to int[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5397), lang.NewKeyword("end-line"), int(5397))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "ints") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ints is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// *print-length* +{ +v0 := lang.NewSymbol("*print-length*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(14), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(23), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, nil, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// reduce +{ +v0 := lang.NewSymbol("reduce").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("val"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "f should be a function of 2 arguments. If val is not supplied,\n returns the result of applying f to the first 2 items in coll, then\n applying f to that result and the 3rd item, etc. If coll contains no\n items, f must accept no arguments as well, and reduce returns the\n result of calling f with no arguments. If coll has only 1 item, it\n is returned and f is not called. If val is supplied, returns the\n result of applying f to val and the first item in coll, then\n applying f to that result and the 2nd item, etc. If coll contains no\n items, returns val and f is not called.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6903), lang.NewKeyword("end-line"), int(6903))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v3 := args[0] +v4 := args[1] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{lang1.IReduce, v4}) +if lang.IsTruthy(v9) { +v10, _ := lang.FieldOrMethod(v4, "Reduce") +if reflect.TypeOf(v10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Reduce is not a function"))) +} +v11 := lang.Apply(v10, []any{v3}) +v5 = v11 +} else { +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core.protocols")) +v13 := v12.FindInternedVar(lang.NewSymbol("coll-reduce")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v4, v3}) +v5 = v15 +} +return v5 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +var v6 any +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("instance?")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{lang1.IReduceInit, v5}) +if lang.IsTruthy(v10) { +v11, _ := lang.FieldOrMethod(v5, "ReduceInit") +if reflect.TypeOf(v11).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) +} +v12 := lang.Apply(v11, []any{v3, v4}) +v6 = v12 +} else { +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core.protocols")) +v14 := v13.FindInternedVar(lang.NewSymbol("coll-reduce")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v5, v3, v4}) +v6 = v16 +} +return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// qualified-ident? +{ +v0 := lang.NewSymbol("qualified-ident?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a symbol or keyword with a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1618), lang.NewKeyword("end-line"), int(1618))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("boolean")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("ident?")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v3}) +var v7 any = v11 +_ = v7 +var v13 any +if lang.IsTruthy(v7) { +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("namespace")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v3}) +var v14 any = v18 +_ = v14 +var v20 any +if lang.IsTruthy(v14) { +v20 = true +} else { +v20 = v14 +} +v13 = v20 +} else { +v13 = v7 +} +v7 := lang.Apply(v6, []any{v13}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// double? +{ +v0 := lang.NewSymbol("double?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a Double", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1421), lang.NewKeyword("end-line"), int(1421))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{lang.Builtins["float64"], v3}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// agent-error +{ +v0 := lang.NewSymbol("agent-error").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("doc"), "Returns the exception thrown during an asynchronous action of the\n agent if the agent is failed. Returns nil if the agent is not\n failed.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2167), lang.NewKeyword("end-line"), int(2167))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, ok := lang.FieldOrMethod(v3, "getError") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getError"))) +} +var v5 any +switch reflect.TypeOf(v4).Kind() { +case reflect.Func: + v5 = lang.Apply(v4, nil) +default: + v5 = v4 +} +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// is-runtime-annotation? +{ +v0 := lang.NewSymbol("is-runtime-annotation?").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5475), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(5475), lang.NewKeyword("end-column"), int(29), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("boolean")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("is-annotation?")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v3}) +var v7 any = v11 +_ = v7 +var v13 any +if lang.IsTruthy(v7) { +v15, _ := lang.FieldOrMethod(v3, "getAnnotation") +if reflect.TypeOf(v15).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getAnnotation is not a function"))) +} +v16 := lang.Apply(v15, []any{java.lang.annotation17.Retention}) +var v14 any = v16 +_ = v14 +var v18 any +if lang.IsTruthy(v14) { +var v19 any = v14 +_ = v19 +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("=")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24, ok := lang.FieldOrMethod(v19, "value") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v19, "value"))) +} +var v25 any +switch reflect.TypeOf(v24).Kind() { +case reflect.Func: + v25 = lang.Apply(v24, nil) +default: + v25 = v24 +} +v26 := lang.Apply(v23, []any{v25, nil}) +v18 = v26 +} else { +v18 = nil +} +v13 = v18 +} else { +v13 = v7 +} +v7 := lang.Apply(v6, []any{v13}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// float +{ +var v1 lang.FnFunc +{ // function float__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +var v30 any +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +if lang.IsTruthy(v33) { +v30 = lang.NewSymbol("uncheckedFloatCast") +} else { +v30 = lang.NewSymbol("floatCast") +} +v34 := lang.Apply(v29, []any{v30}) +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("list")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v37, []any{v3}) +v39 := lang.Apply(v26, []any{v34, v38}) +v40 := lang.Apply(v23, []any{v39}) +v41 := lang.Apply(v20, []any{v40}) +v42 := lang.Apply(v9, []any{v13, v17, v41}) +v43 := lang.Apply(v6, []any{v42}) +return v43 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("float").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to float", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3487), lang.NewKeyword("end-line"), int(3487))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := lang.Apply(lang1.FloatCast, []any{v4}) +return v5 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// alter-meta! +{ +v0 := lang.NewSymbol("alter-meta!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("iref"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Atomically sets the metadata for a namespace/var/ref/agent/atom to be:\n\n (apply f its-current-meta args)\n\n f must be free of side-effects", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2398), lang.NewKeyword("end-line"), int(2398))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +v6, _ := lang.FieldOrMethod(v3, "AlterMeta") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("AlterMeta is not a function"))) +} +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// ns-name +{ +v0 := lang.NewSymbol("ns-name").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns the name of the namespace, a symbol.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4163), lang.NewKeyword("end-line"), int(4163))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("the-ns")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{v3}) +v8, ok := lang.FieldOrMethod(v7, "Name") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "Name"))) +} +var v9 any +switch reflect.TypeOf(v8).Kind() { +case reflect.Func: + v9 = lang.Apply(v8, nil) +default: + v9 = v8 +} +return v9 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// find-keyword +{ +v1 := reflect.TypeOf((*lang1.Keyword)(nil)).Elem() +v0 := lang.NewSymbol("find-keyword").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name"))), lang.NewKeyword("doc"), "Returns a Keyword with the given namespace and name if one already\n exists. This function will not intern a new keyword. If the keyword\n has not already been interned, it will return nil. Do not use :\n in the keyword strings, it will be added automatically.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(618), lang.NewKeyword("end-line"), int(618))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v4 := args[0] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("keyword?")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v4}) +if lang.IsTruthy(v9) { +v5 = v4 +} else { +var v10 any +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("symbol?")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v4}) +if lang.IsTruthy(v14) { +v15 := lang.Apply(nil, []any{v4}) +v10 = v15 +} else { +var v16 any +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("string?")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v4}) +if lang.IsTruthy(v20) { +v21 := lang.Apply(nil, []any{v4}) +v16 = v21 +} else { +v16 = nil +} +v10 = v16 +} +v5 = v10 +} +return v5 + case 2: +v4 := args[0] +v5 := args[1] +v6 := lang.Apply(nil, []any{v4, v5}) +return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v4 := reflect.TypeOf((*lang1.Keyword)(nil)).Elem() +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// time +{ +v0 := lang.NewSymbol("time").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"))), lang.NewKeyword("doc"), "Evaluates expr and prints the time it took. Returns the value of\n expr.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3885), lang.NewKeyword("end-line"), int(3885))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("seq")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("concat")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("list")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{lang.NewSymbol("glojure.core/let")}) +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("list")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("apply")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("vector")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("seq")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("concat")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{lang.NewSymbol("start__0__auto__")}) +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("list")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("seq")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("concat")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{lang.NewSymbol(".UnixNano")}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v52 := v51.FindInternedVar(lang.NewSymbol("seq")) +if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) +} +v53 := v52.Get() +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("concat")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +} +v56 := v55.Get() +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("list")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +} +v59 := v58.Get() +v60 := lang.Apply(v59, []any{lang.NewSymbol("time.Now")}) +v61 := lang.Apply(v56, []any{v60}) +v62 := lang.Apply(v53, []any{v61}) +v63 := lang.Apply(v50, []any{v62}) +v64 := lang.Apply(v43, []any{v47, v63}) +v65 := lang.Apply(v40, []any{v64}) +v66 := lang.Apply(v37, []any{v65}) +v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v68 := v67.FindInternedVar(lang.NewSymbol("list")) +if v68.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) +} +v69 := v68.Get() +v70 := lang.Apply(v69, []any{lang.NewSymbol("ret__1__auto__")}) +v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v72 := v71.FindInternedVar(lang.NewSymbol("list")) +if v72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) +} +v73 := v72.Get() +v74 := lang.Apply(v73, []any{v5}) +v75 := lang.Apply(v30, []any{v34, v66, v70, v74}) +v76 := lang.Apply(v27, []any{v75}) +v77 := lang.Apply(v21, []any{v24, v76}) +v78 := lang.Apply(v18, []any{v77}) +v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v80 := v79.FindInternedVar(lang.NewSymbol("list")) +if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) +} +v81 := v80.Get() +v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v83 := v82.FindInternedVar(lang.NewSymbol("seq")) +if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) +} +v84 := v83.Get() +v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v86 := v85.FindInternedVar(lang.NewSymbol("concat")) +if v86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) +} +v87 := v86.Get() +v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v89 := v88.FindInternedVar(lang.NewSymbol("list")) +if v89.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) +} +v90 := v89.Get() +v91 := lang.Apply(v90, []any{lang.NewSymbol("glojure.core/prn")}) +v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v93 := v92.FindInternedVar(lang.NewSymbol("list")) +if v93.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) +} +v94 := v93.Get() +v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v96 := v95.FindInternedVar(lang.NewSymbol("seq")) +if v96.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) +} +v97 := v96.Get() +v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v99 := v98.FindInternedVar(lang.NewSymbol("concat")) +if v99.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) +} +v100 := v99.Get() +v101 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v102 := v101.FindInternedVar(lang.NewSymbol("list")) +if v102.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v102))) +} +v103 := v102.Get() +v104 := lang.Apply(v103, []any{lang.NewSymbol("glojure.core/str")}) +v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v106 := v105.FindInternedVar(lang.NewSymbol("list")) +if v106.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) +} +v107 := v106.Get() +v108 := lang.Apply(v107, []any{"Elapsed time: "}) +v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v110 := v109.FindInternedVar(lang.NewSymbol("list")) +if v110.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) +} +v111 := v110.Get() +v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v113 := v112.FindInternedVar(lang.NewSymbol("seq")) +if v113.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) +} +v114 := v113.Get() +v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v116 := v115.FindInternedVar(lang.NewSymbol("concat")) +if v116.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) +} +v117 := v116.Get() +v118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v119 := v118.FindInternedVar(lang.NewSymbol("list")) +if v119.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v119))) +} +v120 := v119.Get() +v121 := lang.Apply(v120, []any{lang.NewSymbol("glojure.core//")}) +v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v123 := v122.FindInternedVar(lang.NewSymbol("list")) +if v123.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) +} +v124 := v123.Get() +v125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v126 := v125.FindInternedVar(lang.NewSymbol("seq")) +if v126.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v126))) +} +v127 := v126.Get() +v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v129 := v128.FindInternedVar(lang.NewSymbol("concat")) +if v129.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v129))) +} +v130 := v129.Get() +v131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v132 := v131.FindInternedVar(lang.NewSymbol("list")) +if v132.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v132))) +} +v133 := v132.Get() +v134 := lang.Apply(v133, []any{lang.NewSymbol("glojure.core/double")}) +v135 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v136 := v135.FindInternedVar(lang.NewSymbol("list")) +if v136.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v136))) +} +v137 := v136.Get() +v138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v139 := v138.FindInternedVar(lang.NewSymbol("seq")) +if v139.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v139))) +} +v140 := v139.Get() +v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v142 := v141.FindInternedVar(lang.NewSymbol("concat")) +if v142.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) +} +v143 := v142.Get() +v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v145 := v144.FindInternedVar(lang.NewSymbol("list")) +if v145.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) +} +v146 := v145.Get() +v147 := lang.Apply(v146, []any{lang.NewSymbol("glojure.core/-")}) +v148 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v149 := v148.FindInternedVar(lang.NewSymbol("list")) +if v149.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v149))) +} +v150 := v149.Get() +v151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v152 := v151.FindInternedVar(lang.NewSymbol("seq")) +if v152.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v152))) +} +v153 := v152.Get() +v154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v155 := v154.FindInternedVar(lang.NewSymbol("concat")) +if v155.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v155))) +} +v156 := v155.Get() +v157 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v158 := v157.FindInternedVar(lang.NewSymbol("list")) +if v158.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v158))) +} +v159 := v158.Get() +v160 := lang.Apply(v159, []any{lang.NewSymbol(".UnixNano")}) +v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v162 := v161.FindInternedVar(lang.NewSymbol("list")) +if v162.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) +} +v163 := v162.Get() +v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v165 := v164.FindInternedVar(lang.NewSymbol("seq")) +if v165.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) +} +v166 := v165.Get() +v167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v168 := v167.FindInternedVar(lang.NewSymbol("concat")) +if v168.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v168))) +} +v169 := v168.Get() +v170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v171 := v170.FindInternedVar(lang.NewSymbol("list")) +if v171.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v171))) +} +v172 := v171.Get() +v173 := lang.Apply(v172, []any{lang.NewSymbol("time.Now")}) +v174 := lang.Apply(v169, []any{v173}) +v175 := lang.Apply(v166, []any{v174}) +v176 := lang.Apply(v163, []any{v175}) +v177 := lang.Apply(v156, []any{v160, v176}) +v178 := lang.Apply(v153, []any{v177}) +v179 := lang.Apply(v150, []any{v178}) +v180 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v181 := v180.FindInternedVar(lang.NewSymbol("list")) +if v181.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v181))) +} +v182 := v181.Get() +v183 := lang.Apply(v182, []any{lang.NewSymbol("start__0__auto__")}) +v184 := lang.Apply(v143, []any{v147, v179, v183}) +v185 := lang.Apply(v140, []any{v184}) +v186 := lang.Apply(v137, []any{v185}) +v187 := lang.Apply(v130, []any{v134, v186}) +v188 := lang.Apply(v127, []any{v187}) +v189 := lang.Apply(v124, []any{v188}) +v190 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v191 := v190.FindInternedVar(lang.NewSymbol("list")) +if v191.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v191))) +} +v192 := v191.Get() +v193 := lang.Apply(v192, []any{nil}) +v194 := lang.Apply(v117, []any{v121, v189, v193}) +v195 := lang.Apply(v114, []any{v194}) +v196 := lang.Apply(v111, []any{v195}) +v197 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v198 := v197.FindInternedVar(lang.NewSymbol("list")) +if v198.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v198))) +} +v199 := v198.Get() +v200 := lang.Apply(v199, []any{" msecs"}) +v201 := lang.Apply(v100, []any{v104, v108, v196, v200}) +v202 := lang.Apply(v97, []any{v201}) +v203 := lang.Apply(v94, []any{v202}) +v204 := lang.Apply(v87, []any{v91, v203}) +v205 := lang.Apply(v84, []any{v204}) +v206 := lang.Apply(v81, []any{v205}) +v207 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v208 := v207.FindInternedVar(lang.NewSymbol("list")) +if v208.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v208))) +} +v209 := v208.Get() +v210 := lang.Apply(v209, []any{lang.NewSymbol("ret__1__auto__")}) +v211 := lang.Apply(v11, []any{v15, v78, v206, v210}) +v212 := lang.Apply(v8, []any{v211}) +return v212 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// partial +{ +v0 := lang.NewSymbol("partial").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("arg1")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("arg1"), lang.NewSymbol("arg2")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("arg1"), lang.NewSymbol("arg2"), lang.NewSymbol("arg3")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("arg1"), lang.NewSymbol("arg2"), lang.NewSymbol("arg3"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Takes a function f and fewer than the normal arguments to f, and\n returns a fn that takes a variable number of additional args. When\n called, the returned function calls f with args + additional args.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2606), lang.NewKeyword("end-line"), int(2606))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +return v3 + case 2: +v3 := args[0] +v4 := args[1] +var v5 lang.FnFunc +v5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v6 := lang.Apply(v3, []any{v4}) +return v6 + case 1: +v6 := args[0] +v7 := lang.Apply(v3, []any{v4, v6}) +return v7 + case 2: +v6 := args[0] +v7 := args[1] +v8 := lang.Apply(v3, []any{v4, v6, v7}) +return v8 + case 3: +v6 := args[0] +v7 := args[1] +v8 := args[2] +v9 := lang.Apply(v3, []any{v4, v6, v7, v8}) +return v9 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v6 := args[0] +v7 := args[1] +v8 := args[2] +v9 := lang.NewList(args[3:]...) +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("apply")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{v3, v4, v6, v7, v8, v9}) +return v13 + } +}) +v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2614), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(2619), lang.NewKeyword("end-column"), int(48)) +v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v7 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +var v6 lang.FnFunc +v6 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v7 := lang.Apply(v3, []any{v4, v5}) +return v7 + case 1: +v7 := args[0] +v8 := lang.Apply(v3, []any{v4, v5, v7}) +return v8 + case 2: +v7 := args[0] +v8 := args[1] +v9 := lang.Apply(v3, []any{v4, v5, v7, v8}) +return v9 + case 3: +v7 := args[0] +v8 := args[1] +v9 := args[2] +v10 := lang.Apply(v3, []any{v4, v5, v7, v8, v9}) +return v10 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v7 := args[0] +v8 := args[1] +v9 := args[2] +v10 := lang.NewList(args[3:]...) +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("apply")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v3, v4, v5, v7, v8, v9, v10}) +return v14 + } +}) +v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2621), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(2626), lang.NewKeyword("end-column"), int(53)) +v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v8 + case 4: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +var v7 lang.FnFunc +v7 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v8 := lang.Apply(v3, []any{v4, v5, v6}) +return v8 + case 1: +v8 := args[0] +v9 := lang.Apply(v3, []any{v4, v5, v6, v8}) +return v9 + case 2: +v8 := args[0] +v9 := args[1] +v10 := lang.Apply(v3, []any{v4, v5, v6, v8, v9}) +return v10 + case 3: +v8 := args[0] +v9 := args[1] +v10 := args[2] +v11 := lang.Apply(v3, []any{v4, v5, v6, v8, v9, v10}) +return v11 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v8 := args[0] +v9 := args[1] +v10 := args[2] +v11 := lang.NewList(args[3:]...) +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("apply")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v3, v4, v5, v6, v8, v9, v10, v11}) +return v15 + } +}) +v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2628), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(2633), lang.NewKeyword("end-column"), int(58)) +v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v9 + default: + if len(args) < 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := lang.NewList(args[4:]...) +var v8 lang.FnFunc +v8 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v9 := lang.NewList(args[0:]...) +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("apply")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("concat")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v7, v9}) +v17 := lang.Apply(v12, []any{v3, v4, v5, v6, v16}) +return v17 + } +}) +v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2635), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(2635), lang.NewKeyword("end-column"), int(60)) +v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v10 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// *1 +{ +v0 := lang.NewSymbol("*1").WithMeta(lang.NewMap()).(*lang.Symbol) +v1 := ns.Intern(v0) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// fnil +{ +v0 := lang.NewSymbol("fnil").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("z"))), lang.NewKeyword("doc"), "Takes a function f, and returns a function that calls f, replacing\n a nil first argument to f with the supplied value x. Higher arity\n versions can replace arguments in the second and third\n positions (y, z). Note that the function f can take any number of\n arguments, not just the one(s) being nil-patched.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6601), lang.NewKeyword("end-line"), int(6601))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v3 := args[0] +v4 := args[1] +var v5 lang.FnFunc +v5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v6 := args[0] +var v7 any +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("nil?")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v6}) +if lang.IsTruthy(v11) { +v7 = v4 +} else { +v7 = v6 +} +v12 := lang.Apply(v3, []any{v7}) +return v12 + case 2: +v6 := args[0] +v7 := args[1] +var v8 any +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("nil?")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v6}) +if lang.IsTruthy(v12) { +v8 = v4 +} else { +v8 = v6 +} +v13 := lang.Apply(v3, []any{v8, v7}) +return v13 + case 3: +v6 := args[0] +v7 := args[1] +v8 := args[2] +var v9 any +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("nil?")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{v6}) +if lang.IsTruthy(v13) { +v9 = v4 +} else { +v9 = v6 +} +v14 := lang.Apply(v3, []any{v9, v7, v8}) +return v14 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v6 := args[0] +v7 := args[1] +v8 := args[2] +v9 := lang.NewList(args[3:]...) +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("apply")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +var v13 any +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("nil?")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v6}) +if lang.IsTruthy(v17) { +v13 = v4 +} else { +v13 = v6 +} +v18 := lang.Apply(v12, []any{v3, v13, v7, v8, v9}) +return v18 + } +}) +v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6610), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(6614), lang.NewKeyword("end-column"), int(55)) +v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v7 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +var v6 lang.FnFunc +v6 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v7 := args[0] +v8 := args[1] +var v9 any +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("nil?")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{v7}) +if lang.IsTruthy(v13) { +v9 = v4 +} else { +v9 = v7 +} +var v14 any +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("nil?")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v8}) +if lang.IsTruthy(v18) { +v14 = v5 +} else { +v14 = v8 +} +v19 := lang.Apply(v3, []any{v9, v14}) +return v19 + case 3: +v7 := args[0] +v8 := args[1] +v9 := args[2] +var v10 any +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("nil?")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v7}) +if lang.IsTruthy(v14) { +v10 = v4 +} else { +v10 = v7 +} +var v15 any +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("nil?")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v8}) +if lang.IsTruthy(v19) { +v15 = v5 +} else { +v15 = v8 +} +v20 := lang.Apply(v3, []any{v10, v15, v9}) +return v20 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v7 := args[0] +v8 := args[1] +v9 := args[2] +v10 := lang.NewList(args[3:]...) +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("apply")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +var v14 any +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("nil?")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v7}) +if lang.IsTruthy(v18) { +v14 = v4 +} else { +v14 = v7 +} +var v19 any +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("nil?")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.Apply(v22, []any{v8}) +if lang.IsTruthy(v23) { +v19 = v5 +} else { +v19 = v8 +} +v24 := lang.Apply(v13, []any{v3, v14, v19, v9, v10}) +return v24 + } +}) +v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6616), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(6619), lang.NewKeyword("end-column"), int(71)) +v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v8 + case 4: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +var v7 lang.FnFunc +v7 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v8 := args[0] +v9 := args[1] +var v10 any +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("nil?")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v8}) +if lang.IsTruthy(v14) { +v10 = v4 +} else { +v10 = v8 +} +var v15 any +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("nil?")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v9}) +if lang.IsTruthy(v19) { +v15 = v5 +} else { +v15 = v9 +} +v20 := lang.Apply(v3, []any{v10, v15}) +return v20 + case 3: +v8 := args[0] +v9 := args[1] +v10 := args[2] +var v11 any +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("nil?")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v8}) +if lang.IsTruthy(v15) { +v11 = v4 +} else { +v11 = v8 +} +var v16 any +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("nil?")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v9}) +if lang.IsTruthy(v20) { +v16 = v5 +} else { +v16 = v9 +} +var v21 any +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("nil?")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v10}) +if lang.IsTruthy(v25) { +v21 = v6 +} else { +v21 = v10 +} +v26 := lang.Apply(v3, []any{v11, v16, v21}) +return v26 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v8 := args[0] +v9 := args[1] +v10 := args[2] +v11 := lang.NewList(args[3:]...) +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("apply")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +var v15 any +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("nil?")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v8}) +if lang.IsTruthy(v19) { +v15 = v4 +} else { +v15 = v8 +} +var v20 any +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("nil?")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v9}) +if lang.IsTruthy(v24) { +v20 = v5 +} else { +v20 = v9 +} +var v25 any +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("nil?")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.Apply(v28, []any{v10}) +if lang.IsTruthy(v29) { +v25 = v6 +} else { +v25 = v10 +} +v30 := lang.Apply(v14, []any{v3, v15, v20, v25, v11}) +return v30 + } +}) +v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6621), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(6624), lang.NewKeyword("end-column"), int(87)) +v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v9 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// print-sequential +{ +v0 := lang.NewSymbol("print-sequential").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(46), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(46), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("begin"), lang.NewSymbol("print-one"), lang.NewSymbol("sep"), lang.NewSymbol("end"), lang.NewSymbol("sequence"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 6 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := args[4] +v8 := args[5] +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("push-thread-bindings")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("hash-map")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*print-level*")) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("not")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("*print-dup*")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(v20, []any{v23}) +var v17 any = v24 +_ = v17 +var v26 any +if lang.IsTruthy(v17) { +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("*print-level*")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +var v27 any = v30 +_ = v27 +var v32 any +if lang.IsTruthy(v27) { +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("dec")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("*print-level*")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v35, []any{v38}) +v32 = v39 +} else { +v32 = v27 +} +v26 = v32 +} else { +v26 = v17 +} +v17 := lang.Apply(v15, []any{v16, v26}) +v18 := lang.Apply(v12, []any{v17}) +_ = v18 +var v19 any +func() { +defer func() { +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.Apply(v22, nil) +}() +var v24 any +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("*print-level*")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +var v25 any = v28 +_ = v25 +var v30 any +if lang.IsTruthy(v25) { +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("neg?")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("*print-level*")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.Apply(v33, []any{v36}) +v30 = v37 +} else { +v30 = v25 +} +if lang.IsTruthy(v30) { +v25 := lang.Apply(lang1.WriteWriter, []any{v8, "#"}) +v24 = v25 +} else { +v26 := lang.Apply(lang1.WriteWriter, []any{v8, v3}) +_ = v26 +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("seq")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{v7}) +var v27 any = v31 +_ = v27 +var v33 any +if lang.IsTruthy(v27) { +var v34 any = v27 +_ = v34 +var v36 any +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("not")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("*print-dup*")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v40, []any{v43}) +var v37 any = v44 +_ = v37 +var v46 any +if lang.IsTruthy(v37) { +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("*print-length*")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +} +v49 := v48.Get() +v46 = v49 +} else { +v46 = v37 +} +if lang.IsTruthy(v46) { +var v37 any = v34 +_ = v37 +var v38 any = v37 +_ = v38 +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("seq")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v38}) +var v39 any = v43 +_ = v39 +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("first")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +} +v47 := v46.Get() +v48 := lang.Apply(v47, []any{v39}) +var v44 any = v48 +_ = v44 +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("next")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +} +v52 := v51.Get() +v53 := lang.Apply(v52, []any{v49}) +var v49 any = v53 +_ = v49 +var v54 any = v44 +_ = v54 +var v55 any = v49 +_ = v55 +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("*print-length*")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +} +v59 := v58.Get() +var v56 any = v59 +_ = v56 +var v61 any = v61 +_ = v61 +var v62 any = v62 +_ = v62 +var v63 any +for { +var v64 any = v61 +_ = v64 +v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v67 := v66.FindInternedVar(lang.NewSymbol("seq")) +if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) +} +v68 := v67.Get() +v69 := lang.Apply(v68, []any{v64}) +var v65 any = v69 +_ = v65 +v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v72 := v71.FindInternedVar(lang.NewSymbol("first")) +if v72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) +} +v73 := v72.Get() +v74 := lang.Apply(v73, []any{v65}) +var v70 any = v74 +_ = v70 +v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v77 := v76.FindInternedVar(lang.NewSymbol("next")) +if v77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) +} +v78 := v77.Get() +v79 := lang.Apply(v78, []any{v75}) +var v75 any = v79 +_ = v75 +var v80 any = v70 +_ = v80 +var v81 any = v75 +_ = v81 +var v82 any = v82 +_ = v82 +var v84 any +v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v86 := v85.FindInternedVar(lang.NewSymbol("zero?")) +if v86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) +} +v87 := v86.Get() +v88 := lang.Apply(v87, []any{v82}) +if lang.IsTruthy(v88) { +v89 := lang.Apply(lang1.WriteWriter, []any{v8, "..."}) +v84 = v89 +} else { +v90 := lang.Apply(v4, []any{v80, v8}) +_ = v90 +var v91 any +if lang.IsTruthy(v81) { +v92 := lang.Apply(lang1.WriteWriter, []any{v8, v5}) +_ = v92 +var v93 any = v81 +v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v96 := v95.FindInternedVar(lang.NewSymbol("dec")) +if v96.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) +} +v97 := v96.Get() +v98 := lang.Apply(v97, []any{v82}) +var v94 any = v98 +v61 = v93 +v62 = v94 +continue +} else { +v91 = nil +} +v84 = v91 +} +v63 = v84 + break +} +v36 = v63 +} else { +var v37 any = v34 +_ = v37 +var v38 any = v37 +_ = v38 +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("seq")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v38}) +var v39 any = v43 +_ = v39 +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("first")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +} +v47 := v46.Get() +v48 := lang.Apply(v47, []any{v39}) +var v44 any = v48 +_ = v44 +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("next")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +} +v52 := v51.Get() +v53 := lang.Apply(v52, []any{v49}) +var v49 any = v53 +_ = v49 +var v54 any = v44 +_ = v54 +var v55 any = v49 +_ = v55 +var v57 any = v57 +_ = v57 +var v58 any +for { +var v59 any = v57 +_ = v59 +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("seq")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +} +v63 := v62.Get() +v64 := lang.Apply(v63, []any{v59}) +var v60 any = v64 +_ = v60 +v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v67 := v66.FindInternedVar(lang.NewSymbol("first")) +if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) +} +v68 := v67.Get() +v69 := lang.Apply(v68, []any{v60}) +var v65 any = v69 +_ = v65 +v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v72 := v71.FindInternedVar(lang.NewSymbol("next")) +if v72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) +} +v73 := v72.Get() +v74 := lang.Apply(v73, []any{v70}) +var v70 any = v74 +_ = v70 +var v75 any = v65 +_ = v75 +var v76 any = v70 +_ = v76 +v78 := lang.Apply(v4, []any{v75, v8}) +_ = v78 +var v79 any +if lang.IsTruthy(v76) { +v80 := lang.Apply(lang1.WriteWriter, []any{v8, v5}) +_ = v80 +var v81 any = v76 +v57 = v81 +continue +} else { +v79 = nil +} +v58 = v79 + break +} +v36 = v58 +} +v33 = v36 +} else { +v33 = nil +} +_ = v33 +v27 := lang.Apply(lang1.WriteWriter, []any{v8, v6}) +v24 = v27 +} +v19 = v24 +}() +return v19 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// chunk-cons +{ +v0 := lang.NewSymbol("chunk-cons").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(703), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(703), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("chunk"), lang.NewSymbol("rest"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +var v5 any +v6 := lang.Apply(lang1.Count, []any{v3}) +v7 := lang.Apply(lang1.IsZero, []any{v6}) +if lang.IsTruthy(v7) { +v5 = v4 +} else { +v8 := lang.Apply(lang1.NewChunkedCons, []any{v3, v4}) +v5 = v8 +} +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// setup-reference +{ +v0 := lang.NewSymbol("setup-reference").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2043), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(2044), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("r"), lang.NewSymbol("options"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("apply")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("hash-map")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v8, []any{v11, v4}) +var v5 any = v12 +_ = v5 +var v14 any +v15 := lang.Apply(lang.NewKeyword("meta"), []any{v5}) +if lang.IsTruthy(v15) { +v16 := lang.Apply(lang.NewKeyword("meta"), []any{v5}) +v17, _ := lang.FieldOrMethod(v3, "ResetMeta") +if reflect.TypeOf(v17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ResetMeta is not a function"))) +} +v18 := lang.Apply(v17, []any{v16}) +v14 = v18 +} else { +v14 = nil +} +_ = v14 +var v19 any +v20 := lang.Apply(lang.NewKeyword("validator"), []any{v5}) +if lang.IsTruthy(v20) { +v21 := lang.Apply(lang.NewKeyword("validator"), []any{v5}) +v22, _ := lang.FieldOrMethod(v3, "setValidator") +if reflect.TypeOf(v22).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setValidator is not a function"))) +} +v23 := lang.Apply(v22, []any{v21}) +v19 = v23 +} else { +v19 = nil +} +_ = v19 +return v3 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// unchecked-negate +{ +var v1 lang.FnFunc +{ // function unchecked-negate__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/unchecked_minus")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v3}) +v35 := lang.Apply(v26, []any{v30, v34}) +v36 := lang.Apply(v23, []any{v35}) +v37 := lang.Apply(v20, []any{v36}) +v38 := lang.Apply(v9, []any{v13, v17, v37}) +v39 := lang.Apply(v6, []any{v38}) +return v39 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("unchecked-negate").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the negation of x, a long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1189), lang.NewKeyword("end-line"), int(1189))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "Unchecked_negate") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_negate is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// char? +{ +v0 := lang.NewSymbol("char?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a Character", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(153), lang.NewKeyword("end-line"), int(157))).(*lang.Symbol) +var v2 lang.FnFunc +{ // function char? +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{lang1.Char, v4}) +return v8 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(157), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(157), lang.NewKeyword("end-column"), int(89))).(lang.FnFunc) +v3 := v2 +_ = v3 +} +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// fn? +{ +v0 := lang.NewSymbol("fn?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements Fn, i.e. is an object created via fn.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6259), lang.NewKeyword("end-line"), int(6259))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{runtime3.*Fn, v3}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// true? +{ +v1 := reflect.TypeOf(false) +v0 := lang.NewSymbol("true?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is the value true, false otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(511), lang.NewKeyword("end-line"), int(511))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := lang.Apply(lang1.Identical, []any{v4, true}) +return v5 +}) +v4 := reflect.TypeOf(false) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// in-ns +{ +v0 := lang.NewSymbol("in-ns").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, nil, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// ref-min-history +{ +v0 := lang.NewSymbol("ref-min-history").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref")), lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Gets the min-history of a ref, or sets it and returns the ref", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2462), lang.NewKeyword("end-line"), int(2462))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +v4, ok := lang.FieldOrMethod(v3, "getMinHistory") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getMinHistory"))) +} +var v5 any +switch reflect.TypeOf(v4).Kind() { +case reflect.Func: + v5 = lang.Apply(v4, nil) +default: + v5 = v4 +} +return v5 + case 2: +v3 := args[0] +v4 := args[1] +v5, _ := lang.FieldOrMethod(v3, "setMinHistory") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMinHistory is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// decimal? +{ +v0 := lang.NewSymbol("decimal?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is a BigDecimal", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3599), lang.NewKeyword("end-line"), int(3599))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{lang1.*BigDecimal, v3}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// create-ns +{ +v0 := lang.NewSymbol("create-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Create a new namespace named by the symbol if one doesn't already\n exist, returns it or the already-existing namespace of the same\n name.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4131), lang.NewKeyword("end-line"), int(4131))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.Apply(nil, []any{v3}) +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// symbol +{ +v1 := reflect.TypeOf((*lang1.Symbol)(nil)) +v0 := lang.NewSymbol("symbol").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name"))), lang.NewKeyword("doc"), "Returns a Symbol with the given namespace and name. Arity-1 works\n on strings, keywords, and vars.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(584), lang.NewKeyword("end-line"), int(584))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v4 := args[0] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("symbol?")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v4}) +if lang.IsTruthy(v9) { +v5 = v4 +} else { +var v10 any +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("instance?")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{lang.Builtins["string"], v4}) +if lang.IsTruthy(v14) { +v15 := lang.Apply(lang1.NewSymbol, []any{v4}) +v10 = v15 +} else { +var v16 any +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("instance?")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v19, []any{lang1.*Var, v4}) +if lang.IsTruthy(v20) { +v21, ok := lang.FieldOrMethod(v4, "toSymbol") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "toSymbol"))) +} +var v22 any +switch reflect.TypeOf(v21).Kind() { +case reflect.Func: + v22 = lang.Apply(v21, nil) +default: + v22 = v21 +} +v16 = v22 +} else { +var v23 any +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("instance?")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.Apply(v26, []any{lang1.Keyword, v4}) +if lang.IsTruthy(v27) { +v28, ok := lang.FieldOrMethod(v4, "sym") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "sym"))) +} +var v29 any +switch reflect.TypeOf(v28).Kind() { +case reflect.Func: + v29 = lang.Apply(v28, nil) +default: + v29 = v28 +} +v23 = v29 +} else { +var v30 any +if lang.IsTruthy(lang.NewKeyword("else")) { +v31 := lang.Apply(lang1.NewIllegalArgumentError, []any{"no conversion to symbol"}) +panic(v31) +} else { +v30 = nil +} +v23 = v30 +} +v16 = v23 +} +v10 = v16 +} +v5 = v10 +} +return v5 + case 2: +v4 := args[0] +v5 := args[1] +v6 := lang.Apply(lang1.InternSymbol, []any{v4, v5}) +return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v4 := reflect.TypeOf((*lang1.Symbol)(nil)) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// bit-shift-left +{ +var v1 lang.FnFunc +{ // function bit-shift-left__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("concat")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("list")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("seq")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("concat")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("list")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/shiftLeft")}) +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v4}) +v40 := lang.Apply(v27, []any{v31, v35, v39}) +v41 := lang.Apply(v24, []any{v40}) +v42 := lang.Apply(v21, []any{v41}) +v43 := lang.Apply(v10, []any{v14, v18, v42}) +v44 := lang.Apply(v7, []any{v43}) +return v44 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("bit-shift-left").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Bitwise shift left", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1361), lang.NewKeyword("end-line"), int(1361))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := args[1] +v6, _ := lang.FieldOrMethod(lang1.Numbers, "shiftLeft") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("shiftLeft is not a function"))) +} +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// random-sample +{ +v0 := lang.NewSymbol("random-sample").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("prob")), lang.NewVector(lang.NewSymbol("prob"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns items from coll with random probability of prob (0.0 -\n 1.0). Returns a transducer when no collection is provided.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7742), lang.NewKeyword("end-line"), int(7742))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("filter")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +var v7 lang.FnFunc +v7 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v8 := args[0] +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("<")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("rand")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, nil) +v16 := lang.Apply(v11, []any{v15, v3}) +return v16 +}) +v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7747), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(7747), lang.NewKeyword("end-column"), int(37)) +v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v10 := lang.Apply(v6, []any{v9}) +return v10 + case 2: +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("filter")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +var v8 lang.FnFunc +v8 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v9 := args[0] +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("<")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("rand")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, nil) +v17 := lang.Apply(v12, []any{v16, v3}) +return v17 +}) +v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7749), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(7749), lang.NewKeyword("end-column"), int(37)) +v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v11 := lang.Apply(v7, []any{v10, v4}) +return v11 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// subvec +{ +v0 := lang.NewSymbol("subvec").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("v"), lang.NewSymbol("start")), lang.NewVector(lang.NewSymbol("v"), lang.NewSymbol("start"), lang.NewSymbol("end"))), lang.NewKeyword("doc"), "Returns a persistent vector of the items in vector from\n start (inclusive) to end (exclusive). If end is not supplied,\n defaults to (count vector). This operation is O(1) and very fast, as\n the resulting vector shares structure with the original and no\n trimming is done.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3819), lang.NewKeyword("end-line"), int(3819))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("subvec")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("count")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v3}) +v12 := lang.Apply(v7, []any{v3, v4, v11}) +return v12 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6, _ := lang.FieldOrMethod(runtime3.RT, "Subvec") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Subvec is not a function"))) +} +v7 := lang.Apply(v6, []any{v3, v4, v5}) +return v7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// ffirst +{ +v0 := lang.NewSymbol("ffirst").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Same as (first (first x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(98), lang.NewKeyword("end-line"), int(102))).(*lang.Symbol) +var v2 lang.FnFunc +{ // function ffirst +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("first")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("first")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v4}) +v12 := lang.Apply(v7, []any{v11}) +return v12 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(102), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(102), lang.NewKeyword("end-column"), int(50))).(lang.FnFunc) +v3 := v2 +_ = v3 +} +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// read +{ +v0 := lang.NewSymbol("read").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("stream")), lang.NewVector(lang.NewSymbol("stream"), lang.NewSymbol("eof-error?"), lang.NewSymbol("eof-value")), lang.NewVector(lang.NewSymbol("stream"), lang.NewSymbol("eof-error?"), lang.NewSymbol("eof-value"), lang.NewSymbol("recursive?")), lang.NewVector(lang.NewSymbol("opts"), lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Reads the next object from stream, which must be an instance of\n java.io.PushbackReader or some derivee. stream defaults to the\n current value of *in*.\n\n Opts is a persistent map with valid keys:\n :read-cond - :allow to process reader conditionals, or\n :preserve to keep all branches\n :features - persistent set of feature keywords for reader conditionals\n :eof - on eof, return value unless :eofthrow, then throw.\n if not specified, will throw\n\n Note that read can execute code (controlled by *read-eval*),\n and as such should be used only with trusted sources.\n\n For data structure interop use glojure.edn/read", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3742), lang.NewKeyword("end-line"), int(3742))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v4 := v3.FindInternedVar(lang.NewSymbol("read")) +if v4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) +} +v5 := v4.Get() +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("*in*")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v5, []any{v8}) +return v9 + case 1: +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("read")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{v3, true, nil}) +return v7 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("read")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v3, v4, v5, false}) +return v9 + case 4: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("boolean")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v4}) +v11, _ := lang.FieldOrMethod(glojure.lang11.LispReader, "read") +if reflect.TypeOf(v11).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("read is not a function"))) +} +v12 := lang.Apply(v11, []any{v3, v10, v5, v6}) +return v12 + case 2: +v3 := args[0] +v4 := args[1] +v5, _ := lang.FieldOrMethod(glojure.lang11.LispReader, "read") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("read is not a function"))) +} +v6 := lang.Apply(v5, []any{v4, v3}) +return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// partition-by +{ +v0 := lang.NewSymbol("partition-by").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Applies f to each value in coll, splitting it each time f returns a\n new value. Returns a lazy seq of partitions. Returns a stateful\n transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7185), lang.NewKeyword("end-line"), int(7185))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +v7 := lang.Apply(java.util.ArrayList27., nil) +var v6 any = v7 +_ = v6 +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("volatile!")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v11, []any{lang.NewKeyword("glojure.core/none")}) +var v8 any = v12 +_ = v8 +var v14 lang.FnFunc +v14 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v15 := lang.Apply(v5, nil) +return v15 + case 1: +v15 := args[0] +var v17 any +v18, ok := lang.FieldOrMethod(v6, "isEmpty") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "isEmpty"))) +} +var v19 any +switch reflect.TypeOf(v18).Kind() { +case reflect.Func: + v19 = lang.Apply(v18, nil) +default: + v19 = v18 +} +if lang.IsTruthy(v19) { +v17 = v16 +} else { +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("vec")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24, ok := lang.FieldOrMethod(v6, "toArray") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "toArray"))) +} +var v25 any +switch reflect.TypeOf(v24).Kind() { +case reflect.Func: + v25 = lang.Apply(v24, nil) +default: + v25 = v24 +} +v26 := lang.Apply(v23, []any{v25}) +var v20 any = v26 +_ = v20 +v28, ok := lang.FieldOrMethod(v6, "clear") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "clear"))) +} +var v29 any +switch reflect.TypeOf(v28).Kind() { +case reflect.Func: + v29 = lang.Apply(v28, nil) +default: + v29 = v28 +} +_ = v29 +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("unreduced")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.Apply(v5, []any{v16, v20}) +v34 := lang.Apply(v32, []any{v33}) +v17 = v34 +} +var v16 any = v17 +_ = v16 +v21 := lang.Apply(v5, []any{v16}) +return v21 + case 2: +v15 := args[0] +v16 := args[1] +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("deref")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, []any{v8}) +var v17 any = v21 +_ = v17 +v23 := lang.Apply(v3, []any{v16}) +var v22 any = v23 +_ = v22 +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("vreset!")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.Apply(v27, []any{v8, v22}) +_ = v28 +var v29 any +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("identical?")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v17, lang.NewKeyword("glojure.core/none")}) +var v30 any = v34 +_ = v30 +var v36 any +if lang.IsTruthy(v30) { +v36 = v30 +} else { +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("=")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v22, v17}) +v36 = v40 +} +if lang.IsTruthy(v36) { +v30, _ := lang.FieldOrMethod(v6, "add") +if reflect.TypeOf(v30).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) +} +v31 := lang.Apply(v30, []any{v16}) +_ = v31 +v29 = v15 +} else { +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("vec")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36, ok := lang.FieldOrMethod(v6, "toArray") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "toArray"))) +} +var v37 any +switch reflect.TypeOf(v36).Kind() { +case reflect.Func: + v37 = lang.Apply(v36, nil) +default: + v37 = v36 +} +v38 := lang.Apply(v35, []any{v37}) +var v32 any = v38 +_ = v32 +v40, ok := lang.FieldOrMethod(v6, "clear") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "clear"))) +} +var v41 any +switch reflect.TypeOf(v40).Kind() { +case reflect.Func: + v41 = lang.Apply(v40, nil) +default: + v41 = v40 +} +_ = v41 +v43 := lang.Apply(v5, []any{v15, v32}) +var v42 any = v43 +_ = v42 +var v45 any +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("reduced?")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +} +v48 := v47.Get() +v49 := lang.Apply(v48, []any{v42}) +if lang.IsTruthy(v49) { +v45 = nil +} else { +v50, _ := lang.FieldOrMethod(v6, "add") +if reflect.TypeOf(v50).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) +} +v51 := lang.Apply(v50, []any{v16}) +v45 = v51 +} +_ = v45 +v29 = v42 +} +return v29 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7195), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(7219), lang.NewKeyword("end-column"), int(28)) +v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v16 +}) +v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7192), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(7219), lang.NewKeyword("end-column"), int(30)) +v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v6 + case 2: +v3 := args[0] +v4 := args[1] +var v5 lang.FnFunc +v5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("seq")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v4}) +var v6 any = v10 +_ = v6 +var v12 any +if lang.IsTruthy(v6) { +var v13 any = v6 +_ = v13 +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("first")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v13}) +var v15 any = v19 +_ = v15 +v21 := lang.Apply(v3, []any{v15}) +var v20 any = v21 +_ = v20 +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("cons")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("take-while")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +var v29 lang.FnFunc +v29 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v30 := args[0] +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("=")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v3, []any{v30}) +v35 := lang.Apply(v33, []any{v20, v34}) +return v35 +}) +v30 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7225), lang.NewKeyword("column"), int(41), lang.NewKeyword("end-line"), int(7225), lang.NewKeyword("end-column"), int(53)) +v31, err := lang.WithMeta(v29, v30.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("next")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v13}) +v36 := lang.Apply(v28, []any{v31, v35}) +v37 := lang.Apply(v25, []any{v15, v36}) +var v22 any = v37 +_ = v22 +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("cons")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +} +v41 := v40.Get() +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("partition-by")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +} +v44 := v43.Get() +var v45 lang.FnFunc +v45 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("drop")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +} +v48 := v47.Get() +v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v50 := v49.FindInternedVar(lang.NewSymbol("count")) +if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) +} +v51 := v50.Get() +v52 := lang.Apply(v51, []any{v22}) +v53 := lang.Apply(v48, []any{v52, v13}) +return v53 +}) +v46 := lang.Apply(lang1.NewLazySeq, []any{v45}) +v47 := lang.Apply(v44, []any{v3, v46}) +v48 := lang.Apply(v41, []any{v22, v47}) +v12 = v48 +} else { +v12 = nil +} +return v12 +}) +v6 := lang.Apply(lang1.NewLazySeq, []any{v5}) +return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// num +{ +var v1 lang.FnFunc +{ // function num__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/num")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v3}) +v35 := lang.Apply(v26, []any{v30, v34}) +v36 := lang.Apply(v23, []any{v35}) +v37 := lang.Apply(v20, []any{v36}) +v38 := lang.Apply(v9, []any{v13, v17, v37}) +v39 := lang.Apply(v6, []any{v38}) +return v39 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("num").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to Number", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3474), lang.NewKeyword("end-line"), int(3474))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "num") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("num is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// check-valid-options +{ +v0 := lang.NewSymbol("check-valid-options").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("options"), lang.NewSymbol("&"), lang.NewSymbol("valid-keys"))), lang.NewKeyword("doc"), "Throws an exception if the given option map contains keys not listed\n as valid, else returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(35), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1709), lang.NewKeyword("end-line"), int(1709), lang.NewKeyword("private"), true)).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.NewList(args[1:]...) +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("seq")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("apply")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("disj")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("apply")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("hash-set")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("keys")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v3}) +v25 := lang.Apply(v17, []any{v20, v24}) +v26 := lang.Apply(v11, []any{v14, v25, v4}) +v27 := lang.Apply(v8, []any{v26}) +if lang.IsTruthy(v27) { +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("apply")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("str")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("first")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.Apply(v36, []any{v4}) +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("map")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +var v41 lang.FnFunc +v41 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v42 := args[0] +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("str")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +} +v45 := v44.Get() +v46 := lang.Apply(v45, []any{", ", v42}) +return v46 +}) +v42 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1718), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(1718), lang.NewKeyword("end-column"), int(28)) +v43, err := lang.WithMeta(v41, v42.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("rest")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v4}) +v48 := lang.Apply(v40, []any{v43, v47}) +v49 := lang.Apply(v30, []any{v33, "Only these options are valid: ", v37, v48}) +v50 := lang.Apply(lang1.NewIllegalArgumentError, []any{v49}) +panic(v50) +} else { +v5 = nil +} +return v5 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// dec +{ +var v1 lang.FnFunc +{ // function dec__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +var v30 any +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +if lang.IsTruthy(v33) { +v30 = lang.NewSymbol("unchecked_dec") +} else { +v30 = lang.NewSymbol("dec") +} +v34 := lang.Apply(v29, []any{v30}) +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("list")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v37, []any{v3}) +v39 := lang.Apply(v26, []any{v34, v38}) +v40 := lang.Apply(v23, []any{v39}) +v41 := lang.Apply(v20, []any{v40}) +v42 := lang.Apply(v9, []any{v13, v17, v41}) +v43 := lang.Apply(v6, []any{v42}) +return v43 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("dec").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns a number one less than num. Does not auto-promote\n longs, will throw on overflow. See also: dec'", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1147), lang.NewKeyword("end-line"), int(1147))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "dec") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("dec is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// file-seq +{ +v0 := lang.NewSymbol("file-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("dir"))), lang.NewKeyword("doc"), "A tree seq on java.io.Files", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4972), lang.NewKeyword("end-line"), int(4972))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("tree-seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +var v7 lang.FnFunc +v7 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v8 := args[0] +v9, _ := lang.FieldOrMethod(v8, "isDirectory") +if reflect.TypeOf(v9).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("isDirectory is not a function"))) +} +v10 := lang.Apply(v9, []any{}) +return v10 +}) +v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4978), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(4978), lang.NewKeyword("end-column"), int(47)) +v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v10 lang.FnFunc +v10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v11 := args[0] +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("seq")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15, _ := lang.FieldOrMethod(v11, "listFiles") +if reflect.TypeOf(v15).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("listFiles is not a function"))) +} +v16 := lang.Apply(v15, []any{}) +v17 := lang.Apply(v14, []any{v16}) +return v17 +}) +v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4979), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(4979), lang.NewKeyword("end-column"), int(51)) +v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v13 := lang.Apply(v6, []any{v9, v12, v3}) +return v13 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// aset-char +{ +v0 := lang.NewSymbol("aset-char").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of char. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3981), lang.NewKeyword("end-line"), int(3983))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("char")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v5}) +v10, _ := lang.FieldOrMethod(nil, "setChar") +if reflect.TypeOf(v10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setChar is not a function"))) +} +v11 := lang.Apply(v10, []any{v3, v4, v9}) +_ = v11 +return v5 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("apply")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("aset-char")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("aget")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v3, v4}) +v17 := lang.Apply(v9, []any{v12, v16, v5, v6}) +return v17 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// every? +{ +v1 := reflect.TypeOf(false) +v0 := lang.NewSymbol("every?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if (pred x) is logical true for every x in coll, else\n false.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2664), lang.NewKeyword("end-line"), int(2664))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := args[1] +recur_loop_480: +var v6 any +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("nil?")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("seq")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{v5}) +v14 := lang.Apply(v9, []any{v13}) +if lang.IsTruthy(v14) { +v6 = true +} else { +var v15 any +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("first")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v5}) +v20 := lang.Apply(v4, []any{v19}) +if lang.IsTruthy(v20) { +var v21 any = v4 +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("next")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{v5}) +var v22 any = v26 +v4 = v21 +v5 = v22 +goto recur_loop_480 +} else { +var v27 any +if lang.IsTruthy(lang.NewKeyword("else")) { +v27 = false +} else { +v27 = nil +} +v15 = v27 +} +v6 = v15 +} +return v6 +}) +v4 := reflect.TypeOf(false) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// chunk-append +{ +v0 := lang.NewSymbol("chunk-append").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(688), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(688), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("b"), lang.NewSymbol("x"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5, _ := lang.FieldOrMethod(v3, "add") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// remove-ns +{ +v0 := lang.NewSymbol("remove-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Removes the namespace named by the symbol. Use with caution.\n Cannot be used to remove the glojure namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4139), lang.NewKeyword("end-line"), int(4139))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.Apply(lang1.RemoveNamespace, []any{v3}) +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// boolean +{ +var v1 lang.FnFunc +{ // function boolean__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/BooleanCast")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v3}) +v35 := lang.Apply(v26, []any{v30, v34}) +v36 := lang.Apply(v23, []any{v35}) +v37 := lang.Apply(v20, []any{v36}) +v38 := lang.Apply(v9, []any{v13, v17, v37}) +v39 := lang.Apply(v6, []any{v38}) +return v39 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("boolean").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to boolean", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1601), lang.NewKeyword("end-line"), int(1601))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5, _ := lang.FieldOrMethod(runtime3.RT, "BooleanCast") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("BooleanCast is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// filter-key +{ +v0 := lang.NewSymbol("filter-key").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("keyfn"), lang.NewSymbol("pred"), lang.NewSymbol("amap"))), lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4115), lang.NewKeyword("end-line"), int(4117), lang.NewKeyword("private"), true)).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v7 := lang.NewMap() +v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4118), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(4118), lang.NewKeyword("end-column"), int(17)) +v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v6 any = v9 +_ = v6 +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("seq")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v5}) +var v10 any = v14 +_ = v10 +var v15 any +for { +var v16 any +if lang.IsTruthy(v10) { +var v17 any +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("first")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, []any{v10}) +v22 := lang.Apply(v3, []any{v21}) +v23 := lang.Apply(v4, []any{v22}) +if lang.IsTruthy(v23) { +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("assoc")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("key")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("first")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v10}) +v35 := lang.Apply(v30, []any{v34}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("val")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("first")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +} +v41 := v40.Get() +v42 := lang.Apply(v41, []any{v10}) +v43 := lang.Apply(v38, []any{v42}) +v44 := lang.Apply(v27, []any{v6, v35, v43}) +var v24 any = v44 +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("next")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +} +v48 := v47.Get() +v49 := lang.Apply(v48, []any{v10}) +var v45 any = v49 +v6 = v24 +v10 = v45 +continue +} else { +var v50 any = v6 +v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v53 := v52.FindInternedVar(lang.NewSymbol("next")) +if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) +} +v54 := v53.Get() +v55 := lang.Apply(v54, []any{v10}) +var v51 any = v55 +v6 = v50 +v10 = v51 +continue +} +v16 = v17 +} else { +v16 = v6 +} +v15 = v16 + break +} +return v15 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// deref +{ +v0 := lang.NewSymbol("deref").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref")), lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("timeout-ms"), lang.NewSymbol("timeout-val"))), lang.NewKeyword("doc"), "Also reader macro: @ref/@agent/@var/@atom/@delay/@future/@promise. Within a transaction,\n returns the in-transaction-value of ref, else returns the\n most-recently-committed value of ref. When applied to a var, agent\n or atom, returns its current state. When applied to a delay, forces\n it if not already forced. When applied to a future, will block if\n computation not complete. When applied to a promise, will block\n until a value is delivered. The variant taking a timeout can be\n used for blocking references (futures and promises), and will return\n timeout-val if the timeout (in milliseconds) is reached before a\n value is available. See also - realized?.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2304), lang.NewKeyword("end-line"), int(2304))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{lang1.IDeref, v3}) +if lang.IsTruthy(v8) { +v9, ok := lang.FieldOrMethod(v3, "Deref") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "Deref"))) +} +var v10 any +switch reflect.TypeOf(v9).Kind() { +case reflect.Func: + v10 = lang.Apply(v9, nil) +default: + v10 = v9 +} +v4 = v10 +} else { +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("deref-future")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v3}) +v4 = v14 +} +return v4 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +var v6 any +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("instance?")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{lang1.IBlockingDeref, v3}) +if lang.IsTruthy(v10) { +v11, _ := lang.FieldOrMethod(v3, "DerefWithTimeout") +if reflect.TypeOf(v11).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("DerefWithTimeout is not a function"))) +} +v12 := lang.Apply(v11, []any{v4, v5}) +v6 = v12 +} else { +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("deref-future")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v3, v4, v5}) +v6 = v16 +} +return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// reversible? +{ +v0 := lang.NewSymbol("reversible?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements Reversible", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6300), lang.NewKeyword("end-line"), int(6300))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{glojure.lang11.Reversible, v3}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// partitionv +{ +v0 := lang.NewSymbol("partitionv").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("pad"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of vectors of n items each, at offsets step\n apart. If step is not supplied, defaults to n, i.e. the partitions\n do not overlap. If a pad collection is supplied, use its elements as\n necessary to complete last partition upto n items. In case there are\n not enough padding elements, return a partition with less than n items.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7305), lang.NewKeyword("end-line"), int(7305))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("partitionv")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3, v3, v4}) +return v8 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +var v6 lang.FnFunc +v6 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("seq")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v5}) +var v7 any = v11 +_ = v7 +var v13 any +if lang.IsTruthy(v7) { +var v14 any = v7 +_ = v14 +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("into")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.NewVector() +v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7317), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(7317), lang.NewKeyword("end-column"), int(23)) +v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("take")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{v3}) +v27 := lang.Apply(v19, []any{v22, v26, v14}) +var v16 any = v27 +_ = v16 +var v29 any +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("=")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("count")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v16}) +v37 := lang.Apply(v32, []any{v3, v36}) +if lang.IsTruthy(v37) { +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("cons")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("partitionv")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("nthrest")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v14, v4}) +v48 := lang.Apply(v43, []any{v3, v4, v47}) +v49 := lang.Apply(v40, []any{v16, v48}) +v29 = v49 +} else { +v29 = nil +} +v13 = v29 +} else { +v13 = nil +} +return v13 +}) +v7 := lang.Apply(lang1.NewLazySeq, []any{v6}) +return v7 + case 4: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +var v7 lang.FnFunc +v7 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("seq")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v6}) +var v8 any = v12 +_ = v8 +var v14 any +if lang.IsTruthy(v8) { +var v15 any = v8 +_ = v15 +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("into")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.NewVector() +v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7323), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(7323), lang.NewKeyword("end-column"), int(23)) +v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("take")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v3}) +v28 := lang.Apply(v20, []any{v23, v27, v15}) +var v17 any = v28 +_ = v17 +var v30 any +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("=")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("count")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.Apply(v36, []any{v17}) +v38 := lang.Apply(v33, []any{v3, v37}) +if lang.IsTruthy(v38) { +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("cons")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +} +v41 := v40.Get() +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("partitionv")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +} +v44 := v43.Get() +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("nthrest")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +} +v47 := v46.Get() +v48 := lang.Apply(v47, []any{v15, v4}) +v49 := lang.Apply(v44, []any{v3, v4, v5, v48}) +v50 := lang.Apply(v41, []any{v17, v49}) +v30 = v50 +} else { +v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v52 := v51.FindInternedVar(lang.NewSymbol("list")) +if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) +} +v53 := v52.Get() +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("into")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +} +v56 := v55.Get() +v57 := lang.NewVector() +v58 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7326), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(7326), lang.NewKeyword("end-column"), int(25)) +v59, err := lang.WithMeta(v57, v58.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v61 := v60.FindInternedVar(lang.NewSymbol("take")) +if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) +} +v62 := v61.Get() +v63 := lang.Apply(v62, []any{v3}) +v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v65 := v64.FindInternedVar(lang.NewSymbol("concat")) +if v65.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) +} +v66 := v65.Get() +v67 := lang.Apply(v66, []any{v17, v5}) +v68 := lang.Apply(v56, []any{v59, v63, v67}) +v69 := lang.Apply(v53, []any{v68}) +v30 = v69 +} +v14 = v30 +} else { +v14 = nil +} +return v14 +}) +v8 := lang.Apply(lang1.NewLazySeq, []any{v7}) +return v8 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// alter +{ +v0 := lang.NewSymbol("alter").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("fun"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Must be called in a transaction. Sets the in-transaction-value of\n ref to:\n\n (apply fun in-transaction-value-of-ref args)\n\n and returns the in-transaction-value of ref.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2435), lang.NewKeyword("end-line"), int(2435))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +v6, _ := lang.FieldOrMethod(v3, "alter") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("alter is not a function"))) +} +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// require +{ +v0 := lang.NewSymbol("require").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Loads libs, skipping any that are already loaded. Each argument is\n either a libspec that identifies a lib, a prefix list that identifies\n multiple libs whose names share a common prefix, or a flag that modifies\n how all the identified libs are loaded. Use :require in the ns macro\n in preference to calling this directly.\n\n Libs\n\n A 'lib' is a named set of resources in classpath whose contents define a\n library of Clojure code. Lib names are symbols and each lib is associated\n with a Clojure namespace and a Java package that share its name. A lib's\n name also locates its root directory within classpath using Java's\n package name to classpath-relative path mapping. All resources in a lib\n should be contained in the directory structure under its root directory.\n All definitions a lib makes should be in its associated namespace.\n\n 'require loads a lib by loading its root resource. The root resource path\n is derived from the lib name in the following manner:\n Consider a lib named by the symbol 'x.y.z; it has the root directory\n /x/y/, and its root resource is /x/y/z.clj, or\n /x/y/z.cljc if /x/y/z.clj does not exist. The\n root resource should contain code to create the lib's\n namespace (usually by using the ns macro) and load any additional\n lib resources.\n\n Libspecs\n\n A libspec is a lib name or a vector containing a lib name followed by\n options expressed as sequential keywords and arguments.\n\n Recognized options:\n :as takes a symbol as its argument and makes that symbol an alias to the\n lib's namespace in the current namespace.\n :as-alias takes a symbol as its argument and aliases like :as, however\n the lib will not be loaded. If the lib has not been loaded, a new\n empty namespace will be created (as with create-ns).\n :refer takes a list of symbols to refer from the namespace or the :all\n keyword to bring in all public vars.\n\n Prefix Lists\n\n It's common for Clojure code to depend on several libs whose names have\n the same prefix. When specifying libs, prefix lists can be used to reduce\n repetition. A prefix list contains the shared prefix followed by libspecs\n with the shared prefix removed from the lib names. After removing the\n prefix, the names that remain must not contain any periods.\n\n Flags\n\n A flag is a keyword.\n Recognized flags: :reload, :reload-all, :verbose\n :reload forces loading of all the identified libs even if they are\n already loaded (has no effect on libspecs using :as-alias)\n :reload-all implies :reload and also forces loading of all libs that the\n identified libs directly or indirectly load via require or use\n (has no effect on libspecs using :as-alias)\n :verbose triggers printing information about each load, alias, and refer\n\n Example:\n\n The following would load the libraries glojure.zip and glojure.set\n abbreviated as 's'.\n\n (require '(glojure zip [set :as s]))", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6032), lang.NewKeyword("end-line"), int(6032))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.NewList(args[0:]...) +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("apply")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("load-libs")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v6, []any{v9, lang.NewKeyword("require"), v3}) +return v10 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// case-map +{ +v0 := lang.NewSymbol("case-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("case-f"), lang.NewSymbol("test-f"), lang.NewSymbol("tests"), lang.NewSymbol("thens"))), lang.NewKeyword("doc"), "Transforms a sequence of test constants and a corresponding sequence of then\n expressions into a sorted map to be consumed by case*. The form of the map\n entries are {(case-f test) [(test-f test) then]}.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6657), lang.NewKeyword("end-line"), int(6657), lang.NewKeyword("private"), true)).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("into1")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("sorted-map")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, nil) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("zipmap")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("map")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v3, v5}) +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("map")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("vector")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("map")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{v4, v5}) +v31 := lang.Apply(v23, []any{v26, v30, v6}) +v32 := lang.Apply(v16, []any{v20, v31}) +v33 := lang.Apply(v9, []any{v13, v32}) +return v33 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// hash-map +{ +v0 := lang.NewSymbol("hash-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keyvals"))), lang.NewKeyword("doc"), "keyval => key val\n Returns a new hash map with supplied mappings. If any keys are\n equal, they are handled as if by repeated uses of assoc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(378), lang.NewKeyword("end-line"), int(378))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v3 := lang.NewMap() +v4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(384), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(384), lang.NewKeyword("end-column"), int(8)) +v5, err := lang.WithMeta(v3, v4.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v5 + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.NewList(args[0:]...) +v4 := lang.Apply(lang1.CreatePersistentHashMap, []any{v3}) +return v4 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// zipmap +{ +v0 := lang.NewSymbol("zipmap").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("keys"), lang.NewSymbol("vals"))), lang.NewKeyword("doc"), "Returns a map with the keys mapped to the corresponding vals.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6626), lang.NewKeyword("end-line"), int(6626))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("transient")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.NewMap() +v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6631), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(6631), lang.NewKeyword("end-column"), int(28)) +v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v12 := lang.Apply(v8, []any{v11}) +var v5 any = v12 +_ = v5 +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("seq")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v3}) +var v13 any = v17 +_ = v13 +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("seq")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v4}) +var v18 any = v22 +_ = v18 +var v23 any +for { +var v24 any +var v25 any = v13 +_ = v25 +var v27 any +if lang.IsTruthy(v25) { +v27 = v18 +} else { +v27 = v25 +} +if lang.IsTruthy(v27) { +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("assoc!")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("first")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.Apply(v31, []any{v13}) +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("first")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v18}) +v37 := lang.Apply(v28, []any{v5, v32, v36}) +var v25 any = v37 +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("next")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +} +v41 := v40.Get() +v42 := lang.Apply(v41, []any{v13}) +var v38 any = v42 +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("next")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v18}) +var v43 any = v47 +v5 = v25 +v13 = v38 +v18 = v43 +continue +} else { +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("persistent!")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v5}) +v24 = v51 +} +v23 = v24 + break +} +return v23 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// cond-> +{ +v0 := lang.NewSymbol("cond->").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes an expression and a set of test/form pairs. Threads expr (via ->)\n through each form for which the corresponding test\n expression is true. Note that, unlike cond branching, cond-> threading does\n not short circuit after the first true test expression.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7607), lang.NewKeyword("end-line"), int(7607))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +_ = nil +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("gensym")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, nil) +var v7 any = v11 +_ = v7 +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("map")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +var v16 lang.FnFunc +v16 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v17 := args[0] +var v18 any = v17 +_ = v18 +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("nth")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.Apply(v22, []any{v18, int64(0), nil}) +var v19 any = v23 +_ = v19 +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("nth")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.Apply(v27, []any{v18, int64(1), nil}) +var v24 any = v28 +_ = v24 +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("seq")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("concat")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{lang.NewSymbol("if")}) +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v19}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("seq")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +} +v49 := v48.Get() +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("concat")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +} +v52 := v51.Get() +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("list")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +} +v55 := v54.Get() +v56 := lang.Apply(v55, []any{lang.NewSymbol("glojure.core/->")}) +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("list")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +} +v59 := v58.Get() +v60 := lang.Apply(v59, []any{v7}) +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("list")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +} +v63 := v62.Get() +v64 := lang.Apply(v63, []any{v24}) +v65 := lang.Apply(v52, []any{v56, v60, v64}) +v66 := lang.Apply(v49, []any{v65}) +v67 := lang.Apply(v46, []any{v66}) +v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v69 := v68.FindInternedVar(lang.NewSymbol("list")) +if v69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) +} +v70 := v69.Get() +v71 := lang.Apply(v70, []any{v7}) +v72 := lang.Apply(v35, []any{v39, v43, v67, v71}) +v73 := lang.Apply(v32, []any{v72}) +return v73 +}) +v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7616), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7616), lang.NewKeyword("end-column"), int(66)) +v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("partition")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{int64(2), v6}) +v23 := lang.Apply(v15, []any{v18, v22}) +var v12 any = v23 +_ = v12 +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("seq")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("concat")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/let")}) +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("list")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("apply")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("vector")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("seq")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("concat")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +} +v49 := v48.Get() +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("list")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +} +v52 := v51.Get() +v53 := lang.Apply(v52, []any{v7}) +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("list")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +} +v56 := v55.Get() +v57 := lang.Apply(v56, []any{v5}) +v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v59 := v58.FindInternedVar(lang.NewSymbol("interleave")) +if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) +} +v60 := v59.Get() +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("repeat")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +} +v63 := v62.Get() +v64 := lang.Apply(v63, []any{v7}) +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("butlast")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +} +v67 := v66.Get() +v68 := lang.Apply(v67, []any{v12}) +v69 := lang.Apply(v60, []any{v64, v68}) +v70 := lang.Apply(v49, []any{v53, v57, v69}) +v71 := lang.Apply(v46, []any{v70}) +v72 := lang.Apply(v40, []any{v43, v71}) +v73 := lang.Apply(v37, []any{v72}) +v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v75 := v74.FindInternedVar(lang.NewSymbol("list")) +if v75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) +} +v76 := v75.Get() +var v77 any +v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v79 := v78.FindInternedVar(lang.NewSymbol("empty?")) +if v79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) +} +v80 := v79.Get() +v81 := lang.Apply(v80, []any{v12}) +if lang.IsTruthy(v81) { +v77 = v7 +} else { +v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v83 := v82.FindInternedVar(lang.NewSymbol("last")) +if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) +} +v84 := v83.Get() +v85 := lang.Apply(v84, []any{v12}) +v77 = v85 +} +v86 := lang.Apply(v76, []any{v77}) +v87 := lang.Apply(v30, []any{v34, v73, v86}) +v88 := lang.Apply(v27, []any{v87}) +return v88 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// with-out-str +{ +v0 := lang.NewSymbol("with-out-str").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Evaluates exprs in a context in which *out* is bound to a fresh\n StringWriter. Returns the string created by any nested printing\n calls.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4738), lang.NewKeyword("end-line"), int(4738))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("seq")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("concat")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("list")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{lang.NewSymbol("glojure.core/let")}) +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("list")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("apply")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("vector")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("seq")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("concat")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{lang.NewSymbol("s__0__auto__")}) +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("list")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("seq")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("concat")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{lang.NewSymbol("new")}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{lang.NewSymbol("strings.Builder")}) +v52 := lang.Apply(v43, []any{v47, v51}) +v53 := lang.Apply(v40, []any{v52}) +v54 := lang.Apply(v37, []any{v53}) +v55 := lang.Apply(v30, []any{v34, v54}) +v56 := lang.Apply(v27, []any{v55}) +v57 := lang.Apply(v21, []any{v24, v56}) +v58 := lang.Apply(v18, []any{v57}) +v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v60 := v59.FindInternedVar(lang.NewSymbol("list")) +if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) +} +v61 := v60.Get() +v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v63 := v62.FindInternedVar(lang.NewSymbol("seq")) +if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +} +v64 := v63.Get() +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("concat")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +} +v67 := v66.Get() +v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v69 := v68.FindInternedVar(lang.NewSymbol("list")) +if v69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) +} +v70 := v69.Get() +v71 := lang.Apply(v70, []any{lang.NewSymbol("glojure.core/binding")}) +v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v73 := v72.FindInternedVar(lang.NewSymbol("list")) +if v73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) +} +v74 := v73.Get() +v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v76 := v75.FindInternedVar(lang.NewSymbol("apply")) +if v76.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) +} +v77 := v76.Get() +v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v79 := v78.FindInternedVar(lang.NewSymbol("vector")) +if v79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) +} +v80 := v79.Get() +v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v82 := v81.FindInternedVar(lang.NewSymbol("seq")) +if v82.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) +} +v83 := v82.Get() +v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v85 := v84.FindInternedVar(lang.NewSymbol("concat")) +if v85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) +} +v86 := v85.Get() +v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v88 := v87.FindInternedVar(lang.NewSymbol("list")) +if v88.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) +} +v89 := v88.Get() +v90 := lang.Apply(v89, []any{lang.NewSymbol("glojure.core/*out*")}) +v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v92 := v91.FindInternedVar(lang.NewSymbol("list")) +if v92.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) +} +v93 := v92.Get() +v94 := lang.Apply(v93, []any{lang.NewSymbol("s__0__auto__")}) +v95 := lang.Apply(v86, []any{v90, v94}) +v96 := lang.Apply(v83, []any{v95}) +v97 := lang.Apply(v77, []any{v80, v96}) +v98 := lang.Apply(v74, []any{v97}) +v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v100 := v99.FindInternedVar(lang.NewSymbol("list")) +if v100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) +} +v101 := v100.Get() +v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v103 := v102.FindInternedVar(lang.NewSymbol("seq")) +if v103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) +} +v104 := v103.Get() +v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v106 := v105.FindInternedVar(lang.NewSymbol("concat")) +if v106.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) +} +v107 := v106.Get() +v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v109 := v108.FindInternedVar(lang.NewSymbol("list")) +if v109.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) +} +v110 := v109.Get() +v111 := lang.Apply(v110, []any{lang.NewSymbol("glojure.core/str")}) +v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v113 := v112.FindInternedVar(lang.NewSymbol("list")) +if v113.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) +} +v114 := v113.Get() +v115 := lang.Apply(v114, []any{lang.NewSymbol("s__0__auto__")}) +v116 := lang.Apply(v107, []any{v111, v115}) +v117 := lang.Apply(v104, []any{v116}) +v118 := lang.Apply(v101, []any{v117}) +v119 := lang.Apply(v67, []any{v71, v98, v5, v118}) +v120 := lang.Apply(v64, []any{v119}) +v121 := lang.Apply(v61, []any{v120}) +v122 := lang.Apply(v11, []any{v15, v58, v121}) +v123 := lang.Apply(v8, []any{v122}) +return v123 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// with-loading-context +{ +v0 := lang.NewSymbol("with-loading-context").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5777), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5777), lang.NewKeyword("end-column"), int(30), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("macro"), true)).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("seq")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("concat")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("list")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("seq")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("concat")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("list")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(v23, []any{lang.NewSymbol("glojure.core/fn")}) +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("list")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.Apply(v27, []any{lang.NewSymbol("loading__0__auto__")}) +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("list")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("apply")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("vector")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("seq")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("concat")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v43, nil) +v45 := lang.Apply(v40, []any{v44}) +v46 := lang.Apply(v34, []any{v37, v45}) +v47 := lang.Apply(v31, []any{v46}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v52 := v51.FindInternedVar(lang.NewSymbol("seq")) +if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) +} +v53 := v52.Get() +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("concat")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +} +v56 := v55.Get() +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("list")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +} +v59 := v58.Get() +v60 := lang.Apply(v59, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.PushThreadBindings")}) +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("list")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +} +v63 := v62.Get() +v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v65 := v64.FindInternedVar(lang.NewSymbol("apply")) +if v65.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) +} +v66 := v65.Get() +v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v68 := v67.FindInternedVar(lang.NewSymbol("hash-map")) +if v68.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) +} +v69 := v68.Get() +v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v71 := v70.FindInternedVar(lang.NewSymbol("seq")) +if v71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) +} +v72 := v71.Get() +v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v74 := v73.FindInternedVar(lang.NewSymbol("concat")) +if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) +} +v75 := v74.Get() +v76 := lang.Apply(v75, nil) +v77 := lang.Apply(v72, []any{v76}) +v78 := lang.Apply(v66, []any{v69, v77}) +v79 := lang.Apply(v63, []any{v78}) +v80 := lang.Apply(v56, []any{v60, v79}) +v81 := lang.Apply(v53, []any{v80}) +v82 := lang.Apply(v50, []any{v81}) +v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v84 := v83.FindInternedVar(lang.NewSymbol("list")) +if v84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) +} +v85 := v84.Get() +v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v87 := v86.FindInternedVar(lang.NewSymbol("seq")) +if v87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) +} +v88 := v87.Get() +v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v90 := v89.FindInternedVar(lang.NewSymbol("concat")) +if v90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) +} +v91 := v90.Get() +v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v93 := v92.FindInternedVar(lang.NewSymbol("list")) +if v93.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) +} +v94 := v93.Get() +v95 := lang.Apply(v94, []any{lang.NewSymbol("try")}) +v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v97 := v96.FindInternedVar(lang.NewSymbol("list")) +if v97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) +} +v98 := v97.Get() +v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v100 := v99.FindInternedVar(lang.NewSymbol("seq")) +if v100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) +} +v101 := v100.Get() +v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v103 := v102.FindInternedVar(lang.NewSymbol("concat")) +if v103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) +} +v104 := v103.Get() +v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v106 := v105.FindInternedVar(lang.NewSymbol("list")) +if v106.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) +} +v107 := v106.Get() +v108 := lang.Apply(v107, []any{lang.NewSymbol("finally")}) +v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v110 := v109.FindInternedVar(lang.NewSymbol("list")) +if v110.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) +} +v111 := v110.Get() +v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v113 := v112.FindInternedVar(lang.NewSymbol("seq")) +if v113.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) +} +v114 := v113.Get() +v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v116 := v115.FindInternedVar(lang.NewSymbol("concat")) +if v116.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) +} +v117 := v116.Get() +v118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v119 := v118.FindInternedVar(lang.NewSymbol("list")) +if v119.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v119))) +} +v120 := v119.Get() +v121 := lang.Apply(v120, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.PopThreadBindings")}) +v122 := lang.Apply(v117, []any{v121}) +v123 := lang.Apply(v114, []any{v122}) +v124 := lang.Apply(v111, []any{v123}) +v125 := lang.Apply(v104, []any{v108, v124}) +v126 := lang.Apply(v101, []any{v125}) +v127 := lang.Apply(v98, []any{v126}) +v128 := lang.Apply(v91, []any{v95, v5, v127}) +v129 := lang.Apply(v88, []any{v128}) +v130 := lang.Apply(v85, []any{v129}) +v131 := lang.Apply(v20, []any{v24, v28, v47, v82, v130}) +v132 := lang.Apply(v17, []any{v131}) +v133 := lang.Apply(v14, []any{v132}) +v134 := lang.Apply(v11, []any{v133}) +v135 := lang.Apply(v8, []any{v134}) +return v135 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// print +{ +v0 := lang.NewSymbol("print").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Prints the object(s) to the output stream that is the current value\n of *out*. print and println produce output for human consumption.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3725), lang.NewKeyword("end-line"), int(3725))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.NewList(args[0:]...) +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("push-thread-bindings")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("hash-map")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*print-readably*")) +v12 := lang.Apply(v10, []any{v11, nil}) +v13 := lang.Apply(v7, []any{v12}) +_ = v13 +var v14 any +func() { +defer func() { +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, nil) +}() +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("apply")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("pr")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v21, []any{v24, v3}) +v14 = v25 +}() +return v14 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// eduction +{ +v0 := lang.NewSymbol("eduction").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xform*"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a reducible/iterable application of the transducers\n to the items in coll. Transducers are applied in order as if\n combined with comp. Note that these applications will be\n performed every time reduce/iterator is called.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7751), lang.NewKeyword("end-line"), int(7751))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.NewList(args[0:]...) +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("apply")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("comp")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("butlast")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{v3}) +v14 := lang.Apply(v6, []any{v9, v13}) +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("last")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v3}) +v19 := lang.Apply(Eduction28., []any{v14, v18}) +return v19 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// ex-message +{ +v0 := lang.NewSymbol("ex-message").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ex"))), lang.NewKeyword("doc"), "Returns the message attached to ex if ex is a Throwable.\n Otherwise returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4820), lang.NewKeyword("end-line"), int(4820))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{lang1.Throwable, v3}) +if lang.IsTruthy(v8) { +v9, ok := lang.FieldOrMethod(v3, "getMessage") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getMessage"))) +} +var v10 any +switch reflect.TypeOf(v9).Kind() { +case reflect.Func: + v10 = lang.Apply(v9, nil) +default: + v10 = v9 +} +v4 = v10 +} else { +v4 = nil +} +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// load-libs +{ +v0 := lang.NewSymbol("load-libs").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Loads libs, interpreting libspecs, prefix lists, and flags for\n forwarding to load-lib", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5994), lang.NewKeyword("end-line"), int(5994), lang.NewKeyword("private"), true)).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.NewList(args[0:]...) +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("filter")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("keyword?")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v7, []any{v10, v3}) +var v4 any = v11 +_ = v4 +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("interleave")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("repeat")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{true}) +v20 := lang.Apply(v15, []any{v4, v19}) +var v12 any = v20 +_ = v12 +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("filter")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("complement")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("keyword?")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v27, []any{v30}) +v32 := lang.Apply(v24, []any{v31, v21}) +var v21 any = v32 +_ = v21 +v35 := lang.CreatePersistentTreeSet(lang.NewKeyword("as"), lang.NewKeyword("reload"), lang.NewKeyword("reload-all"), lang.NewKeyword("require"), lang.NewKeyword("use"), lang.NewKeyword("verbose"), lang.NewKeyword("refer"), lang.NewKeyword("as-alias")) +v36 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6002), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(6002), lang.NewKeyword("end-column"), int(86)) +v37, err := lang.WithMeta(v35, v36.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v34 any = v37 +_ = v34 +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("seq")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +} +v41 := v40.Get() +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("remove")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +} +v44 := v43.Get() +v45 := lang.Apply(v44, []any{v34, v4}) +v46 := lang.Apply(v41, []any{v45}) +var v38 any = v46 +_ = v38 +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("throw-if")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v52 := v51.FindInternedVar(lang.NewSymbol("apply")) +if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) +} +v53 := v52.Get() +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("str")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +} +v56 := v55.Get() +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("interpose")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +} +v59 := v58.Get() +v60 := lang.Apply(v59, []any{lang.NewChar(44), v38}) +v61 := lang.Apply(v53, []any{v56, "Unsupported option(s) supplied: ", v60}) +v62 := lang.Apply(v50, []any{v38, v61}) +_ = v62 +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("throw-if")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("not")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("seq")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v21}) +v44 := lang.Apply(v39, []any{v43}) +v45 := lang.Apply(v36, []any{v44, "Nothing specified to load"}) +_ = v45 +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("seq")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +} +v49 := v48.Get() +v50 := lang.Apply(v49, []any{v21}) +var v46 any = v50 +_ = v46 +var v51 any = nil +_ = v51 +var v52 any = int64(0) +_ = v52 +var v53 any = int64(0) +_ = v53 +var v54 any +for { +var v55 any +v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v57 := v56.FindInternedVar(lang.NewSymbol("<")) +if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) +} +v58 := v57.Get() +v59 := lang.Apply(v58, []any{v53, v52}) +if lang.IsTruthy(v59) { +v61, _ := lang.FieldOrMethod(v51, "nth") +if reflect.TypeOf(v61).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) +} +v62 := lang.Apply(v61, []any{v53}) +var v60 any = v62 +_ = v60 +var v64 any +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("libspec?")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +} +v67 := v66.Get() +v68 := lang.Apply(v67, []any{v60}) +if lang.IsTruthy(v68) { +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("apply")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +} +v71 := v70.Get() +v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v73 := v72.FindInternedVar(lang.NewSymbol("load-lib")) +if v73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) +} +v74 := v73.Get() +v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v76 := v75.FindInternedVar(lang.NewSymbol("prependss")) +if v76.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) +} +v77 := v76.Get() +v78 := lang.Apply(v77, []any{v60, v12}) +v79 := lang.Apply(v71, []any{v74, nil, v78}) +v64 = v79 +} else { +var v80 any = v60 +_ = v80 +v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v83 := v82.FindInternedVar(lang.NewSymbol("seq")) +if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) +} +v84 := v83.Get() +v85 := lang.Apply(v84, []any{v80}) +var v81 any = v85 +_ = v81 +v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v88 := v87.FindInternedVar(lang.NewSymbol("first")) +if v88.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) +} +v89 := v88.Get() +v90 := lang.Apply(v89, []any{v81}) +var v86 any = v90 +_ = v86 +v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v93 := v92.FindInternedVar(lang.NewSymbol("next")) +if v93.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) +} +v94 := v93.Get() +v95 := lang.Apply(v94, []any{v91}) +var v91 any = v95 +_ = v91 +var v96 any = v86 +_ = v96 +var v97 any = v91 +_ = v97 +v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v100 := v99.FindInternedVar(lang.NewSymbol("throw-if")) +if v100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) +} +v101 := v100.Get() +v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v103 := v102.FindInternedVar(lang.NewSymbol("nil?")) +if v103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) +} +v104 := v103.Get() +v105 := lang.Apply(v104, []any{v96}) +v106 := lang.Apply(v101, []any{v105, "prefix cannot be nil"}) +_ = v106 +v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v109 := v108.FindInternedVar(lang.NewSymbol("seq")) +if v109.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) +} +v110 := v109.Get() +v111 := lang.Apply(v110, []any{v97}) +var v107 any = v111 +_ = v107 +var v112 any = nil +_ = v112 +var v113 any = int64(0) +_ = v113 +var v114 any = int64(0) +_ = v114 +var v115 any +for { +var v116 any +v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v118 := v117.FindInternedVar(lang.NewSymbol("<")) +if v118.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) +} +v119 := v118.Get() +v120 := lang.Apply(v119, []any{v114, v113}) +if lang.IsTruthy(v120) { +v122, _ := lang.FieldOrMethod(v112, "nth") +if reflect.TypeOf(v122).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) +} +v123 := lang.Apply(v122, []any{v114}) +var v121 any = v123 +_ = v121 +v125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v126 := v125.FindInternedVar(lang.NewSymbol("apply")) +if v126.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v126))) +} +v127 := v126.Get() +v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v129 := v128.FindInternedVar(lang.NewSymbol("load-lib")) +if v129.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v129))) +} +v130 := v129.Get() +v131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v132 := v131.FindInternedVar(lang.NewSymbol("prependss")) +if v132.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v132))) +} +v133 := v132.Get() +v134 := lang.Apply(v133, []any{v121, v12}) +v135 := lang.Apply(v127, []any{v130, v96, v134}) +_ = v135 +var v136 any = v107 +var v137 any = v112 +var v138 any = v113 +v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v141 := v140.FindInternedVar(lang.NewSymbol("unchecked-inc")) +if v141.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) +} +v142 := v141.Get() +v143 := lang.Apply(v142, []any{v114}) +var v139 any = v143 +v107 = v136 +v112 = v137 +v113 = v138 +v114 = v139 +continue +} else { +v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v123 := v122.FindInternedVar(lang.NewSymbol("seq")) +if v123.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) +} +v124 := v123.Get() +v125 := lang.Apply(v124, []any{v107}) +var v121 any = v125 +_ = v121 +var v127 any +if lang.IsTruthy(v121) { +var v128 any = v121 +_ = v128 +var v130 any +v131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v132 := v131.FindInternedVar(lang.NewSymbol("chunked-seq?")) +if v132.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v132))) +} +v133 := v132.Get() +v134 := lang.Apply(v133, []any{v128}) +if lang.IsTruthy(v134) { +v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v137 := v136.FindInternedVar(lang.NewSymbol("chunk-first")) +if v137.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) +} +v138 := v137.Get() +v139 := lang.Apply(v138, []any{v128}) +var v135 any = v139 +_ = v135 +v142 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v143 := v142.FindInternedVar(lang.NewSymbol("chunk-rest")) +if v143.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v143))) +} +v144 := v143.Get() +v145 := lang.Apply(v144, []any{v128}) +var v141 any = v145 +var v146 any = v135 +v148 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v149 := v148.FindInternedVar(lang.NewSymbol("int")) +if v149.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v149))) +} +v150 := v149.Get() +v151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v152 := v151.FindInternedVar(lang.NewSymbol("count")) +if v152.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v152))) +} +v153 := v152.Get() +v154 := lang.Apply(v153, []any{v135}) +v155 := lang.Apply(v150, []any{v154}) +var v147 any = v155 +v157 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v158 := v157.FindInternedVar(lang.NewSymbol("int")) +if v158.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v158))) +} +v159 := v158.Get() +v160 := lang.Apply(v159, []any{int64(0)}) +var v156 any = v160 +v107 = v141 +v112 = v146 +v113 = v147 +v114 = v156 +continue +} else { +v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v137 := v136.FindInternedVar(lang.NewSymbol("first")) +if v137.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) +} +v138 := v137.Get() +v139 := lang.Apply(v138, []any{v128}) +var v135 any = v139 +_ = v135 +v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v142 := v141.FindInternedVar(lang.NewSymbol("apply")) +if v142.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) +} +v143 := v142.Get() +v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v145 := v144.FindInternedVar(lang.NewSymbol("load-lib")) +if v145.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) +} +v146 := v145.Get() +v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v148 := v147.FindInternedVar(lang.NewSymbol("prependss")) +if v148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) +} +v149 := v148.Get() +v150 := lang.Apply(v149, []any{v135, v12}) +v151 := lang.Apply(v143, []any{v146, v96, v150}) +_ = v151 +v153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v154 := v153.FindInternedVar(lang.NewSymbol("next")) +if v154.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v154))) +} +v155 := v154.Get() +v156 := lang.Apply(v155, []any{v128}) +var v152 any = v156 +var v157 any = nil +var v158 any = int64(0) +var v159 any = int64(0) +v107 = v152 +v112 = v157 +v113 = v158 +v114 = v159 +continue +} +v127 = v130 +} else { +v127 = nil +} +v116 = v127 +} +v115 = v116 + break +} +v64 = v115 +} +_ = v64 +var v80 any = v46 +var v81 any = v51 +var v82 any = v52 +v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v85 := v84.FindInternedVar(lang.NewSymbol("unchecked-inc")) +if v85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) +} +v86 := v85.Get() +v87 := lang.Apply(v86, []any{v53}) +var v83 any = v87 +v46 = v80 +v51 = v81 +v52 = v82 +v53 = v83 +continue +} else { +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("seq")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +} +v63 := v62.Get() +v64 := lang.Apply(v63, []any{v46}) +var v60 any = v64 +_ = v60 +var v66 any +if lang.IsTruthy(v60) { +var v67 any = v60 +_ = v67 +var v69 any +v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v71 := v70.FindInternedVar(lang.NewSymbol("chunked-seq?")) +if v71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) +} +v72 := v71.Get() +v73 := lang.Apply(v72, []any{v67}) +if lang.IsTruthy(v73) { +v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v76 := v75.FindInternedVar(lang.NewSymbol("chunk-first")) +if v76.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) +} +v77 := v76.Get() +v78 := lang.Apply(v77, []any{v67}) +var v74 any = v78 +_ = v74 +v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v82 := v81.FindInternedVar(lang.NewSymbol("chunk-rest")) +if v82.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) +} +v83 := v82.Get() +v84 := lang.Apply(v83, []any{v67}) +var v80 any = v84 +var v85 any = v74 +v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v88 := v87.FindInternedVar(lang.NewSymbol("int")) +if v88.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) +} +v89 := v88.Get() +v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v91 := v90.FindInternedVar(lang.NewSymbol("count")) +if v91.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) +} +v92 := v91.Get() +v93 := lang.Apply(v92, []any{v74}) +v94 := lang.Apply(v89, []any{v93}) +var v86 any = v94 +v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v97 := v96.FindInternedVar(lang.NewSymbol("int")) +if v97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) +} +v98 := v97.Get() +v99 := lang.Apply(v98, []any{int64(0)}) +var v95 any = v99 +v46 = v80 +v51 = v85 +v52 = v86 +v53 = v95 +continue +} else { +v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v76 := v75.FindInternedVar(lang.NewSymbol("first")) +if v76.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) +} +v77 := v76.Get() +v78 := lang.Apply(v77, []any{v67}) +var v74 any = v78 +_ = v74 +var v80 any +v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v82 := v81.FindInternedVar(lang.NewSymbol("libspec?")) +if v82.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) +} +v83 := v82.Get() +v84 := lang.Apply(v83, []any{v74}) +if lang.IsTruthy(v84) { +v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v86 := v85.FindInternedVar(lang.NewSymbol("apply")) +if v86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) +} +v87 := v86.Get() +v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v89 := v88.FindInternedVar(lang.NewSymbol("load-lib")) +if v89.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) +} +v90 := v89.Get() +v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v92 := v91.FindInternedVar(lang.NewSymbol("prependss")) +if v92.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) +} +v93 := v92.Get() +v94 := lang.Apply(v93, []any{v74, v12}) +v95 := lang.Apply(v87, []any{v90, nil, v94}) +v80 = v95 +} else { +var v96 any = v74 +_ = v96 +v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v99 := v98.FindInternedVar(lang.NewSymbol("seq")) +if v99.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) +} +v100 := v99.Get() +v101 := lang.Apply(v100, []any{v96}) +var v97 any = v101 +_ = v97 +v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v104 := v103.FindInternedVar(lang.NewSymbol("first")) +if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) +} +v105 := v104.Get() +v106 := lang.Apply(v105, []any{v97}) +var v102 any = v106 +_ = v102 +v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v109 := v108.FindInternedVar(lang.NewSymbol("next")) +if v109.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) +} +v110 := v109.Get() +v111 := lang.Apply(v110, []any{v107}) +var v107 any = v111 +_ = v107 +var v112 any = v102 +_ = v112 +var v113 any = v107 +_ = v113 +v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v116 := v115.FindInternedVar(lang.NewSymbol("throw-if")) +if v116.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) +} +v117 := v116.Get() +v118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v119 := v118.FindInternedVar(lang.NewSymbol("nil?")) +if v119.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v119))) +} +v120 := v119.Get() +v121 := lang.Apply(v120, []any{v112}) +v122 := lang.Apply(v117, []any{v121, "prefix cannot be nil"}) +_ = v122 +v124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v125 := v124.FindInternedVar(lang.NewSymbol("seq")) +if v125.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v125))) +} +v126 := v125.Get() +v127 := lang.Apply(v126, []any{v113}) +var v123 any = v127 +_ = v123 +var v128 any = nil +_ = v128 +var v129 any = int64(0) +_ = v129 +var v130 any = int64(0) +_ = v130 +var v131 any +for { +var v132 any +v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v134 := v133.FindInternedVar(lang.NewSymbol("<")) +if v134.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) +} +v135 := v134.Get() +v136 := lang.Apply(v135, []any{v130, v129}) +if lang.IsTruthy(v136) { +v138, _ := lang.FieldOrMethod(v128, "nth") +if reflect.TypeOf(v138).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) +} +v139 := lang.Apply(v138, []any{v130}) +var v137 any = v139 +_ = v137 +v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v142 := v141.FindInternedVar(lang.NewSymbol("apply")) +if v142.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) +} +v143 := v142.Get() +v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v145 := v144.FindInternedVar(lang.NewSymbol("load-lib")) +if v145.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) +} +v146 := v145.Get() +v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v148 := v147.FindInternedVar(lang.NewSymbol("prependss")) +if v148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) +} +v149 := v148.Get() +v150 := lang.Apply(v149, []any{v137, v12}) +v151 := lang.Apply(v143, []any{v146, v112, v150}) +_ = v151 +var v152 any = v123 +var v153 any = v128 +var v154 any = v129 +v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v157 := v156.FindInternedVar(lang.NewSymbol("unchecked-inc")) +if v157.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) +} +v158 := v157.Get() +v159 := lang.Apply(v158, []any{v130}) +var v155 any = v159 +v123 = v152 +v128 = v153 +v129 = v154 +v130 = v155 +continue +} else { +v138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v139 := v138.FindInternedVar(lang.NewSymbol("seq")) +if v139.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v139))) +} +v140 := v139.Get() +v141 := lang.Apply(v140, []any{v123}) +var v137 any = v141 +_ = v137 +var v143 any +if lang.IsTruthy(v137) { +var v144 any = v137 +_ = v144 +var v146 any +v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v148 := v147.FindInternedVar(lang.NewSymbol("chunked-seq?")) +if v148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) +} +v149 := v148.Get() +v150 := lang.Apply(v149, []any{v144}) +if lang.IsTruthy(v150) { +v152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v153 := v152.FindInternedVar(lang.NewSymbol("chunk-first")) +if v153.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v153))) +} +v154 := v153.Get() +v155 := lang.Apply(v154, []any{v144}) +var v151 any = v155 +_ = v151 +v158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v159 := v158.FindInternedVar(lang.NewSymbol("chunk-rest")) +if v159.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v159))) +} +v160 := v159.Get() +v161 := lang.Apply(v160, []any{v144}) +var v157 any = v161 +var v162 any = v151 +v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v165 := v164.FindInternedVar(lang.NewSymbol("int")) +if v165.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) +} +v166 := v165.Get() +v167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v168 := v167.FindInternedVar(lang.NewSymbol("count")) +if v168.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v168))) +} +v169 := v168.Get() +v170 := lang.Apply(v169, []any{v151}) +v171 := lang.Apply(v166, []any{v170}) +var v163 any = v171 +v173 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v174 := v173.FindInternedVar(lang.NewSymbol("int")) +if v174.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v174))) +} +v175 := v174.Get() +v176 := lang.Apply(v175, []any{int64(0)}) +var v172 any = v176 +v123 = v157 +v128 = v162 +v129 = v163 +v130 = v172 +continue +} else { +v152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v153 := v152.FindInternedVar(lang.NewSymbol("first")) +if v153.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v153))) +} +v154 := v153.Get() +v155 := lang.Apply(v154, []any{v144}) +var v151 any = v155 +_ = v151 +v157 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v158 := v157.FindInternedVar(lang.NewSymbol("apply")) +if v158.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v158))) +} +v159 := v158.Get() +v160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v161 := v160.FindInternedVar(lang.NewSymbol("load-lib")) +if v161.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v161))) +} +v162 := v161.Get() +v163 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v164 := v163.FindInternedVar(lang.NewSymbol("prependss")) +if v164.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v164))) +} +v165 := v164.Get() +v166 := lang.Apply(v165, []any{v151, v12}) +v167 := lang.Apply(v159, []any{v162, v112, v166}) +_ = v167 +v169 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v170 := v169.FindInternedVar(lang.NewSymbol("next")) +if v170.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v170))) +} +v171 := v170.Get() +v172 := lang.Apply(v171, []any{v144}) +var v168 any = v172 +var v173 any = nil +var v174 any = int64(0) +var v175 any = int64(0) +v123 = v168 +v128 = v173 +v129 = v174 +v130 = v175 +continue +} +v143 = v146 +} else { +v143 = nil +} +v132 = v143 +} +v131 = v132 + break +} +v80 = v131 +} +_ = v80 +v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v98 := v97.FindInternedVar(lang.NewSymbol("next")) +if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) +} +v99 := v98.Get() +v100 := lang.Apply(v99, []any{v67}) +var v96 any = v100 +var v101 any = nil +var v102 any = int64(0) +var v103 any = int64(0) +v46 = v96 +v51 = v101 +v52 = v102 +v53 = v103 +continue +} +v66 = v69 +} else { +v66 = nil +} +v55 = v66 +} +v54 = v55 + break +} +return v54 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// replicate +{ +v0 := lang.NewSymbol("replicate").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "DEPRECATED: Use 'repeat' instead.\n Returns a lazy seq of n xs.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("deprecated"), "1.3", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3004), lang.NewKeyword("end-line"), int(3004))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("take")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("repeat")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v4}) +v12 := lang.Apply(v7, []any{v3, v11}) +return v12 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// prefers +{ +v0 := lang.NewSymbol("prefers").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"))), lang.NewKeyword("doc"), "Given a multimethod, returns a map of preferred value -> set of other values", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1822), lang.NewKeyword("end-line"), int(1822))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, ok := lang.FieldOrMethod(v3, "getPreferTable") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getPreferTable"))) +} +var v5 any +switch reflect.TypeOf(v4).Kind() { +case reflect.Func: + v5 = lang.Apply(v4, nil) +default: + v5 = v4 +} +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// - +{ +var v1 lang.FnFunc +v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v2 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +if lang.IsTruthy(v7) { +v4 = closed6 +} else { +v4 = v3 +} +var v3 any = v4 +_ = v3 +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("seq")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("concat")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("seq")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("concat")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v2}) +v40 := lang.Apply(v31, []any{v35, v39}) +v41 := lang.Apply(v28, []any{v40}) +v42 := lang.Apply(v25, []any{v41}) +v43 := lang.Apply(v14, []any{v18, v22, v42}) +v44 := lang.Apply(v11, []any{v43}) +return v44 + case 2: +v2 := args[0] +v3 := args[1] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +if lang.IsTruthy(v8) { +v5 = closed6 +} else { +v5 = v4 +} +var v4 any = v5 +_ = v4 +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("seq")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("concat")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("list")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("list")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("list")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("seq")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("concat")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("list")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v4}) +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("list")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v2}) +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("list")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v3}) +v45 := lang.Apply(v32, []any{v36, v40, v44}) +v46 := lang.Apply(v29, []any{v45}) +v47 := lang.Apply(v26, []any{v46}) +v48 := lang.Apply(v15, []any{v19, v23, v47}) +v49 := lang.Apply(v12, []any{v48}) +return v49 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v2 := args[0] +v3 := args[1] +v4 := lang.NewList(args[2:]...) +var v6 any +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +if lang.IsTruthy(v9) { +v6 = closed6 +} else { +v6 = v5 +} +var v5 any = v6 +_ = v5 +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +var v14 lang.FnFunc +v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v15 := args[0] +v16 := args[1] +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v5}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v15}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v16}) +v52 := lang.Apply(v39, []any{v43, v47, v51}) +v53 := lang.Apply(v36, []any{v52}) +v54 := lang.Apply(v33, []any{v53}) +v55 := lang.Apply(v22, []any{v26, v30, v54}) +v56 := lang.Apply(v19, []any{v55}) +return v56 +}) +v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) +v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v5}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v2}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v3}) +v52 := lang.Apply(v39, []any{v43, v47, v51}) +v53 := lang.Apply(v36, []any{v52}) +v54 := lang.Apply(v33, []any{v53}) +v55 := lang.Apply(v22, []any{v26, v30, v54}) +v56 := lang.Apply(v19, []any{v55}) +v57 := lang.Apply(v13, []any{v16, v56, v4}) +return v57 + } +}) +v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) +} +v5 := lang.Apply(v4, []any{v3, int64(0)}) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v0 := lang.NewSymbol("-").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "If no ys are supplied, returns the negation of x, else subtracts\n the ys from x and returns the result. Does not auto-promote\n longs, will throw on overflow. See also: -'", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1036), lang.NewKeyword("end-line"), int(1036))).(*lang.Symbol) +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v5 := args[0] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("*")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{int64(-1), v5}) +return v9 + case 2: +v5 := args[0] +v6 := args[1] +v7, _ := lang.FieldOrMethod(lang1.Numbers, "minus") +if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("minus is not a function"))) +} +v8 := lang.Apply(v7, []any{v5, v6}) +return v8 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +v6 := args[1] +v7 := lang.NewList(args[2:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("-")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("-")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v5, v6}) +v18 := lang.Apply(v10, []any{v13, v17, v7}) +return v18 + } +}) +v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v3 := ns.InternWithValue(v0, v4, true) +if v0.Meta() != nil { + v3.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// with-meta +{ +v0 := lang.NewSymbol("with-meta").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("obj"), lang.NewSymbol("m"))), lang.NewKeyword("doc"), "Returns an object of the same type and value as obj, with\n map m as its metadata.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(211), lang.NewKeyword("end-line"), int(216))).(*lang.Symbol) +var v2 lang.FnFunc +{ // function with-meta +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := args[1] +v6, _ := lang.FieldOrMethod(v4, "WithMeta") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("WithMeta is not a function"))) +} +v7 := lang.Apply(v6, []any{v5}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(216), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(217), lang.NewKeyword("end-column"), int(32))).(lang.FnFunc) +v3 := v2 +_ = v3 +} +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// aset-byte +{ +v0 := lang.NewSymbol("aset-byte").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of byte. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3976), lang.NewKeyword("end-line"), int(3978))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("byte")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v5}) +v10, _ := lang.FieldOrMethod(nil, "setByte") +if reflect.TypeOf(v10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setByte is not a function"))) +} +v11 := lang.Apply(v10, []any{v3, v4, v9}) +_ = v11 +return v5 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("apply")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("aset-byte")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("aget")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v3, v4}) +v17 := lang.Apply(v9, []any{v12, v16, v5, v6}) +return v17 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// flatten +{ +v0 := lang.NewSymbol("flatten").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Takes any nested combination of sequential things (lists, vectors,\n etc.) and returns their contents as a single, flat lazy sequence.\n (flatten nil) returns an empty sequence.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7161), lang.NewKeyword("end-line"), int(7161))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("filter")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("complement")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("sequential?")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v9, []any{v12}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("rest")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("tree-seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("sequential?")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("seq")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v19, []any{v22, v25, v3}) +v27 := lang.Apply(v16, []any{v26}) +v28 := lang.Apply(v6, []any{v13, v27}) +return v28 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// future-call +{ +v0 := lang.NewSymbol("future-call").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Takes a function of no args and yields a future object that will\n invoke the function in another thread, and will cache the result and\n return it on all subsequent calls to deref/@. If the computation has\n not yet finished, calls to deref/@ will block, unless the variant\n of deref with timeout is used. See also - realized?.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7046), lang.NewKeyword("end-line"), int(7046))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("binding-conveyor-fn")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v4}) +var v4 any = v8 +_ = v4 +v10 := lang.Apply(lang1.AgentSubmit, []any{v4}) +var v9 any = v10 +_ = v9 +return v9 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// pr +{ +v0 := lang.NewSymbol("pr").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Prints the object(s) to the output stream that is the current value\n of *out*. Prints the object(s), separated by spaces if there is\n more than one. By default, pr and prn print in a way that objects\n can be read by the reader", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3678), lang.NewKeyword("end-line"), int(3678), lang.NewKeyword("dynamic"), true)).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +return nil + case 1: +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("pr-on")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("*out*")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v6, []any{v3, v9}) +return v10 + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.NewList(args[1:]...) +recur_loop_671: +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("pr")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +_ = v8 +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("*out*")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(lang1.AppendWriter, []any{v11, lang.NewChar(32)}) +_ = v12 +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("next")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v4}) +var v13 any = v17 +_ = v13 +var v19 any +if lang.IsTruthy(v13) { +var v20 any = v13 +_ = v20 +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("first")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{v4}) +var v22 any = v26 +var v27 any = v20 +v3 = v22 +v4 = v27 +goto recur_loop_671 +} else { +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("apply")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("pr")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v22, []any{v25, v4}) +v19 = v26 +} +return v19 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// re-matcher +{ +v1 := reflect.TypeOf((*lang1.RegexpMatcher)(nil)) +v0 := lang.NewSymbol("re-matcher").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("re"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns an instance of java.util.regex.Matcher, for use, e.g. in\n re-find.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4873), lang.NewKeyword("end-line"), int(4873))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := args[1] +v6 := lang.Apply(lang1.NewRegexpMatcher, []any{v4, v5}) +return v6 +}) +v4 := reflect.TypeOf((*lang1.RegexpMatcher)(nil)) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// take-last +{ +v0 := lang.NewSymbol("take-last").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a seq of the last n items in coll. Depending on the type\n of coll may be no better than linear time. For vectors, see also subvec.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2939), lang.NewKeyword("end-line"), int(2939))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("seq")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v4}) +var v5 any = v9 +_ = v5 +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("seq")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("drop")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v3, v4}) +v18 := lang.Apply(v13, []any{v17}) +var v10 any = v18 +_ = v10 +var v19 any +for { +var v20 any +if lang.IsTruthy(v10) { +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("next")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v5}) +var v21 any = v25 +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("next")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{v10}) +var v26 any = v30 +v5 = v21 +v10 = v26 +continue +} else { +v20 = v5 +} +v19 = v20 + break +} +return v19 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// sort-by +{ +v0 := lang.NewSymbol("sort-by").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("keyfn"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("keyfn"), lang.NewSymbol("comp"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a sorted sequence of the items in coll, where the sort\n order is determined by comparing (keyfn item). If no comparator is\n supplied, uses compare. comparator must implement\n java.util.Comparator. Guaranteed to be stable: equal elements will\n not be reordered. If coll is a Java array, it will be modified. To\n avoid this, sort a copy of the array.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3102), lang.NewKeyword("end-line"), int(3102))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("sort-by")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("compare")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v7, []any{v3, v10, v4}) +return v11 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("sort")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +var v9 lang.FnFunc +v9 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v10 := args[0] +v11 := args[1] +v12 := lang.Apply(v3, []any{v10}) +v13 := lang.Apply(v3, []any{v11}) +v14 := lang.Apply(v4, []any{v12, v13}) +return v14 +}) +v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3114), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(3114), lang.NewKeyword("end-column"), int(46)) +v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v12 := lang.Apply(v8, []any{v11, v5}) +return v12 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// root-directory +{ +v0 := lang.NewSymbol("root-directory").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"))), lang.NewKeyword("doc"), "Returns the root resource path for a lib", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5914), lang.NewKeyword("end-line"), int(5914), lang.NewKeyword("private"), true)).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("root-resource")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +var v4 any = v8 +_ = v4 +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("subs")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(strings22.LastIndex, []any{v4, "/"}) +v14 := lang.Apply(v12, []any{v4, int64(0), v13}) +return v14 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// *pending-paths* +{ +v0 := lang.NewSymbol("*pending-paths*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5865), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(5868), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, lang.NewList(), true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// *print-readably* +{ +v0 := lang.NewSymbol("*print-readably*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "When set to logical false, strings and characters will be printed with\n non-alphanumeric characters converted to the appropriate escape sequences.\n\n Defaults to true", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, true, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// bit-test +{ +v0 := lang.NewSymbol("bit-test").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Test bit at index n", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1354), lang.NewKeyword("end-line"), int(1354))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "testBit") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("testBit is not a function"))) +} +v6 := lang.Apply(v5, []any{v3, v4}) +return v6 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// unchecked-add-int +{ +var v1 lang.FnFunc +{ // function unchecked-add-int__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("concat")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("list")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("seq")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("concat")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("list")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/unchecked_int_add")}) +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v4}) +v40 := lang.Apply(v27, []any{v31, v35, v39}) +v41 := lang.Apply(v24, []any{v40}) +v42 := lang.Apply(v21, []any{v41}) +v43 := lang.Apply(v10, []any{v14, v18, v42}) +v44 := lang.Apply(v7, []any{v43}) +return v44 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("unchecked-add-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the sum of x and y, both int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1196), lang.NewKeyword("end-line"), int(1196))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := args[1] +v6, _ := lang.FieldOrMethod(lang1.Numbers, "unchecked_int_add") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_add is not a function"))) +} +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// declare +{ +v0 := lang.NewSymbol("declare").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("names"))), lang.NewKeyword("doc"), "defs the supplied var names with no bindings, useful for making forward declarations.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(2768), lang.NewKeyword("end-line"), int(2768))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("seq")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("concat")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("list")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{lang.NewSymbol("do")}) +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("map")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +var v19 lang.FnFunc +v19 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v20 := args[0] +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("list")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("vary-meta")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("assoc")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v26, []any{v20, v29, lang.NewKeyword("declared"), true}) +v31 := lang.Apply(v23, []any{lang.NewSymbol("def"), v30}) +return v31 +}) +v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2771), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(2771), lang.NewKeyword("end-column"), int(71)) +v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v22 := lang.Apply(v18, []any{v21, v5}) +v23 := lang.Apply(v11, []any{v15, v22}) +v24 := lang.Apply(v8, []any{v23}) +return v24 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// prn-str +{ +v1 := reflect.TypeOf("") +v0 := lang.NewSymbol("prn-str").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("xs"))), lang.NewKeyword("doc"), "prn to a string, returning it", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4767), lang.NewKeyword("end-line"), int(4767))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := lang.NewList(args[0:]...) +var v5 any = "unimplemented: new with non-constant class type" +_ = v5 +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("push-thread-bindings")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("hash-map")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*out*")) +v15 := lang.Apply(v13, []any{v14, v5}) +v16 := lang.Apply(v10, []any{v15}) +_ = v16 +var v17 any +func() { +defer func() { +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, nil) +}() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("apply")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("prn")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.Apply(v24, []any{v27, v4}) +_ = v28 +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("str")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.Apply(v31, []any{v5}) +v17 = v32 +}() +return v17 + } +}) +v4 := reflect.TypeOf("") +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// send-off +{ +v0 := lang.NewSymbol("send-off").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Dispatch a potentially blocking action to an agent. Returns the\n agent immediately. Subsequently, in a separate thread, the state of\n the agent will be set to the value of:\n\n (apply action-fn state-of-agent args)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2120), lang.NewKeyword("end-line"), int(2120))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("apply")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("send-via")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v8, []any{v11, nil, v3, v4, v5}) +return v12 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// swap! +{ +v0 := lang.NewSymbol("swap!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atom"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Atomically swaps the value of atom to be:\n (apply f current-value-of-atom args). Note that f may be called\n multiple times, and thus should be free of side effects. Returns\n the value that was swapped in.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2343), lang.NewKeyword("end-line"), int(2343))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +v6, _ := lang.FieldOrMethod(v3, "swap") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("swap is not a function"))) +} +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// ancestors +{ +v0 := lang.NewSymbol("ancestors").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"))), lang.NewKeyword("doc"), "Returns the immediate and indirect parents of tag, either via a Java type\n inheritance relationship or a relationship established via derive. h\n must be a hierarchy obtained from make-hierarchy, if not supplied\n defaults to the global hierarchy", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5620), lang.NewKeyword("end-line"), int(5620))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("ancestors")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("global-hierarchy")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v6, []any{v9, v3}) +return v10 + case 2: +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("not-empty")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("get")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) +v13 := lang.Apply(v11, []any{v12, v4}) +var v8 any = v13 +_ = v8 +var v15 any +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("class?")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v4}) +if lang.IsTruthy(v19) { +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("set")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("supers")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v4}) +v28 := lang.Apply(v23, []any{v27}) +var v20 any = v28 +_ = v20 +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("reduce1")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("into1")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("cons")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("map")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +} +v41 := v40.Get() +var v42 lang.FnFunc +v42 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v43 := args[0] +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("get")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) +v48 := lang.Apply(v46, []any{v47, v43}) +return v48 +}) +v43 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5633), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(5633), lang.NewKeyword("end-column"), int(54)) +v44, err := lang.WithMeta(v42, v43.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v45 := lang.Apply(v41, []any{v44, v20}) +v46 := lang.Apply(v38, []any{v8, v45}) +v47 := lang.Apply(v32, []any{v35, v20, v46}) +v15 = v47 +} else { +v15 = v8 +} +v8 := lang.Apply(v7, []any{v15}) +return v8 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// hash-set +{ +v0 := lang.NewSymbol("hash-set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keys"))), lang.NewKeyword("doc"), "Returns a new hash set with supplied keys. Any equal keys are\n handled as if by repeated uses of conj.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(388), lang.NewKeyword("end-line"), int(388))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v3 := lang.CreatePersistentTreeSet() +v4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(393), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(393), lang.NewKeyword("end-column"), int(9)) +v5, err := lang.WithMeta(v3, v4.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v5 + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.NewList(args[0:]...) +v4 := lang.Apply(nil, []any{v3}) +return v4 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// reset-vals! +{ +v0 := lang.NewSymbol("reset-vals!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atom"), lang.NewSymbol("newval"))), lang.NewKeyword("doc"), "Sets the value of atom to newval. Returns [old new], the value of the\n atom before and after the reset.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2375), lang.NewKeyword("end-line"), int(2375))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5, _ := lang.FieldOrMethod(v3, "resetVals") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("resetVals is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// interleave +{ +v0 := lang.NewSymbol("interleave").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("c1")), lang.NewVector(lang.NewSymbol("c1"), lang.NewSymbol("c2")), lang.NewVector(lang.NewSymbol("c1"), lang.NewSymbol("c2"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Returns a lazy seq of the first item in each coll, then the second etc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4308), lang.NewKeyword("end-line"), int(4308))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +return lang.NewList() + case 1: +v3 := args[0] +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +return v3 +}) +v5 := lang.Apply(lang1.NewLazySeq, []any{v4}) +return v5 + case 2: +v3 := args[0] +v4 := args[1] +var v5 lang.FnFunc +v5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("seq")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v3}) +var v6 any = v10 +_ = v6 +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("seq")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v4}) +var v11 any = v15 +_ = v11 +var v17 any +var v18 any = v6 +_ = v18 +var v20 any +if lang.IsTruthy(v18) { +v20 = v11 +} else { +v20 = v18 +} +if lang.IsTruthy(v20) { +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("cons")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("first")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v6}) +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("cons")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("first")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{v11}) +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("interleave")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("rest")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v37, []any{v6}) +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("rest")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +} +v41 := v40.Get() +v42 := lang.Apply(v41, []any{v11}) +v43 := lang.Apply(v34, []any{v38, v42}) +v44 := lang.Apply(v27, []any{v31, v43}) +v45 := lang.Apply(v20, []any{v24, v44}) +v17 = v45 +} else { +v17 = nil +} +return v17 +}) +v6 := lang.Apply(lang1.NewLazySeq, []any{v5}) +return v6 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +var v6 lang.FnFunc +v6 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("map")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("seq")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("conj")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v5, v4, v3}) +v18 := lang.Apply(v10, []any{v13, v17}) +var v7 any = v18 +_ = v7 +var v20 any +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("every?")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("identity")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.Apply(v23, []any{v26, v7}) +if lang.IsTruthy(v27) { +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("concat")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("map")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("first")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.Apply(v33, []any{v36, v7}) +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("apply")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("interleave")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("map")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("rest")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +} +v49 := v48.Get() +v50 := lang.Apply(v46, []any{v49, v7}) +v51 := lang.Apply(v40, []any{v43, v50}) +v52 := lang.Apply(v30, []any{v37, v51}) +v20 = v52 +} else { +v20 = nil +} +return v20 +}) +v7 := lang.Apply(lang1.NewLazySeq, []any{v6}) +return v7 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// bit-shift-right +{ +var v1 lang.FnFunc +{ // function bit-shift-right__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("concat")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("list")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("seq")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("concat")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("list")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/shiftRight")}) +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v4}) +v40 := lang.Apply(v27, []any{v31, v35, v39}) +v41 := lang.Apply(v24, []any{v40}) +v42 := lang.Apply(v21, []any{v41}) +v43 := lang.Apply(v10, []any{v14, v18, v42}) +v44 := lang.Apply(v7, []any{v43}) +return v44 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("bit-shift-right").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Bitwise shift right", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1367), lang.NewKeyword("end-line"), int(1367))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := args[1] +v6, _ := lang.FieldOrMethod(lang1.Numbers, "shiftRight") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("shiftRight is not a function"))) +} +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// symbol? +{ +v0 := lang.NewSymbol("symbol?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a Symbol", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(557), lang.NewKeyword("end-line"), int(557))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{lang1.*Symbol, v3}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// chunk +{ +v0 := lang.NewSymbol("chunk").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(691), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(691), lang.NewKeyword("end-column"), int(41), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("b"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, ok := lang.FieldOrMethod(v3, "chunk") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "chunk"))) +} +var v5 any +switch reflect.TypeOf(v4).Kind() { +case reflect.Func: + v5 = lang.Apply(v4, nil) +default: + v5 = v4 +} +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// remove-all-methods +{ +v0 := lang.NewSymbol("remove-all-methods").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"))), lang.NewKeyword("doc"), "Removes all of the methods of multimethod.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1787), lang.NewKeyword("end-line"), int(1787))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, ok := lang.FieldOrMethod(v3, "reset") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "reset"))) +} +var v5 any +switch reflect.TypeOf(v4).Kind() { +case reflect.Func: + v5 = lang.Apply(v4, nil) +default: + v5 = v4 +} +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// ns-refers +{ +v0 := lang.NewSymbol("ns-refers").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of the refer mappings for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4253), lang.NewKeyword("end-line"), int(4253))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("the-ns")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v4}) +var v4 any = v8 +_ = v4 +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("filter-key")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("val")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +var v16 lang.FnFunc +v16 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v17 := args[0] +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("instance?")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{lang1.*Var, v17}) +var v18 any = v22 +_ = v18 +var v24 any +if lang.IsTruthy(v18) { +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("not=")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28, ok := lang.FieldOrMethod(v17, "Namespace") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v17, "Namespace"))) +} +var v29 any +switch reflect.TypeOf(v28).Kind() { +case reflect.Func: + v29 = lang.Apply(v28, nil) +default: + v29 = v28 +} +v30 := lang.Apply(v27, []any{v4, v29}) +v24 = v30 +} else { +v24 = v18 +} +return v24 +}) +v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4259), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(4260), lang.NewKeyword("end-column"), int(59)) +v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("ns-map")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v4}) +v23 := lang.Apply(v12, []any{v15, v18, v22}) +return v23 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// subseq +{ +v0 := lang.NewSymbol("subseq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sc"), lang.NewSymbol("test"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("sc"), lang.NewSymbol("start-test"), lang.NewSymbol("start-key"), lang.NewSymbol("end-test"), lang.NewSymbol("end-key"))), lang.NewKeyword("doc"), "sc must be a sorted collection, test(s) one of <, <=, > or\n >=. Returns a seq of those entries with keys ek for\n which (test (.. sc comparator (compare ek key)) 0) is true", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5133), lang.NewKeyword("end-line"), int(5133))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("mk-bound-fn")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v3, v4, v5}) +var v6 any = v10 +_ = v6 +var v12 any +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol(">")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol(">=")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.CreatePersistentTreeSet(v15, v18) +v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5141), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5141), lang.NewKeyword("end-column"), int(17)) +v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v22 := lang.Apply(v21, []any{v4}) +if lang.IsTruthy(v22) { +v24, _ := lang.FieldOrMethod(v3, "seqFrom") +if reflect.TypeOf(v24).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("seqFrom is not a function"))) +} +v25 := lang.Apply(v24, []any{v5, true}) +var v23 any = v25 +_ = v23 +var v27 any +if lang.IsTruthy(v23) { +var v28 any = v23 +_ = v28 +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("nth")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.Apply(v32, []any{v28, int64(0), nil}) +var v29 any = v33 +_ = v29 +var v34 any = v28 +_ = v34 +var v36 any +v37 := lang.Apply(v6, []any{v29}) +if lang.IsTruthy(v37) { +v36 = v34 +} else { +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("next")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.Apply(v40, []any{v34}) +v36 = v41 +} +v27 = v36 +} else { +v27 = nil +} +v12 = v27 +} else { +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("take-while")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26, _ := lang.FieldOrMethod(v3, "seq") +if reflect.TypeOf(v26).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("seq is not a function"))) +} +v27 := lang.Apply(v26, []any{true}) +v28 := lang.Apply(v25, []any{v6, v27}) +v12 = v28 +} +return v12 + case 5: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := args[4] +v9, _ := lang.FieldOrMethod(v3, "seqFrom") +if reflect.TypeOf(v9).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("seqFrom is not a function"))) +} +v10 := lang.Apply(v9, []any{v5, true}) +var v8 any = v10 +_ = v8 +var v12 any +if lang.IsTruthy(v8) { +var v13 any = v8 +_ = v13 +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("nth")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v13, int64(0), nil}) +var v14 any = v18 +_ = v14 +var v19 any = v13 +_ = v19 +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("take-while")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("mk-bound-fn")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v3, v6, v7}) +var v28 any +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("mk-bound-fn")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.Apply(v31, []any{v3, v4, v5}) +v33 := lang.Apply(v32, []any{v14}) +if lang.IsTruthy(v33) { +v28 = v19 +} else { +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("next")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.Apply(v36, []any{v19}) +v28 = v37 +} +v38 := lang.Apply(v23, []any{v27, v28}) +v12 = v38 +} else { +v12 = nil +} +return v12 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// protocol? +{ +v0 := lang.NewSymbol("protocol?").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(110), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(110), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("maybe-p"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{lang1.IAtom, v3}) +if lang.IsTruthy(v8) { +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("boolean")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("deref")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v3}) +v16 := lang.Apply(lang.NewKeyword("on-interface"), []any{v15}) +v17 := lang.Apply(v11, []any{v16}) +v4 = v17 +} else { +v4 = false +} +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// await1 +{ +v0 := lang.NewSymbol("await1").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3284), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3284), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("pos?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8, ok := lang.FieldOrMethod(v3, "getQueueCount") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getQueueCount"))) +} +var v9 any +switch reflect.TypeOf(v8).Kind() { +case reflect.Func: + v9 = lang.Apply(v8, nil) +default: + v9 = v8 +} +v10 := lang.Apply(v7, []any{v9}) +if lang.IsTruthy(v10) { +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("await")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v3}) +v4 = v14 +} else { +v4 = nil +} +_ = v4 +return v3 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// unchecked-inc-int +{ +var v1 lang.FnFunc +{ // function unchecked-inc-int__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/unchecked_int_inc")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v3}) +v35 := lang.Apply(v26, []any{v30, v34}) +v36 := lang.Apply(v23, []any{v35}) +v37 := lang.Apply(v20, []any{v36}) +v38 := lang.Apply(v9, []any{v13, v17, v37}) +v39 := lang.Apply(v6, []any{v38}) +return v39 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("unchecked-inc-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns a number one greater than x, an int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1154), lang.NewKeyword("end-line"), int(1154))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "unchecked_int_inc") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_inc is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// to-array +{ +v0 := lang.NewSymbol("to-array").WithMeta(lang.NewMap(lang.NewKeyword("tag"), "[Ljava.lang.Object;", lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns an array of Objects containing the contents of coll, which\n can be any Collection. Maps to java.util.Collection.toArray().", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(337), lang.NewKeyword("end-line"), int(337))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, _ := lang.FieldOrMethod(runtime3.RT, "ToArray") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ToArray is not a function"))) +} +v5 := lang.Apply(v4, []any{v3}) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), "[Ljava.lang.Object;")).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// range +{ +v0 := lang.NewSymbol("range").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("end")), lang.NewVector(lang.NewSymbol("start"), lang.NewSymbol("end")), lang.NewVector(lang.NewSymbol("start"), lang.NewSymbol("end"), lang.NewSymbol("step"))), lang.NewKeyword("doc"), "Returns a lazy seq of nums from start (inclusive) to end\n (exclusive), by step, where start defaults to 0, step to 1, and end to\n infinity. When step is equal to 0, returns an infinite sequence of\n start. When start is equal to end, returns empty list.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3018), lang.NewKeyword("end-line"), int(3018))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v4 := v3.FindInternedVar(lang.NewSymbol("iterate")) +if v4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) +} +v5 := v4.Get() +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("inc'")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v5, []any{v8, int64(0)}) +return v9 + case 1: +v3 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("int?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +if lang.IsTruthy(v8) { +v9 := lang.Apply(lang1.NewLongRange, []any{int64(0), v3, int64(1)}) +v4 = v9 +} else { +v10 := lang.Apply(lang1.NewRange, []any{int64(0), v3, int64(1)}) +v4 = v10 +} +return v4 + case 2: +v3 := args[0] +v4 := args[1] +var v5 any +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("int?")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v3}) +var v6 any = v10 +_ = v6 +var v12 any +if lang.IsTruthy(v6) { +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("int?")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v4}) +v12 = v16 +} else { +v12 = v6 +} +if lang.IsTruthy(v12) { +v6 := lang.Apply(lang1.NewLongRange, []any{v3, v4, int64(1)}) +v5 = v6 +} else { +v7 := lang.Apply(lang1.NewRange, []any{v3, v4, int64(1)}) +v5 = v7 +} +return v5 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +var v6 any +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("int?")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v3}) +var v7 any = v11 +_ = v7 +var v13 any +if lang.IsTruthy(v7) { +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("int?")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v4}) +var v14 any = v18 +_ = v14 +var v20 any +if lang.IsTruthy(v14) { +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("int?")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v5}) +v20 = v24 +} else { +v20 = v14 +} +v13 = v20 +} else { +v13 = v7 +} +if lang.IsTruthy(v13) { +v7 := lang.Apply(lang1.NewLongRange, []any{v3, v4, v5}) +v6 = v7 +} else { +v8 := lang.Apply(lang1.NewRange, []any{v3, v4, v5}) +v6 = v8 +} +return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// qualified-keyword? +{ +v0 := lang.NewSymbol("qualified-keyword?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a keyword with a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1638), lang.NewKeyword("end-line"), int(1638))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("boolean")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("keyword?")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v3}) +var v7 any = v11 +_ = v7 +var v13 any +if lang.IsTruthy(v7) { +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("namespace")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v3}) +var v14 any = v18 +_ = v14 +var v20 any +if lang.IsTruthy(v14) { +v20 = true +} else { +v20 = v14 +} +v13 = v20 +} else { +v13 = v7 +} +v7 := lang.Apply(v6, []any{v13}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// agent +{ +v0 := lang.NewSymbol("agent").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("state"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Creates and returns an agent with an initial value of state and\n zero or more options (in any order):\n\n :meta metadata-map\n\n :validator validate-fn\n\n :error-handler handler-fn\n\n :error-mode mode-keyword\n\n If metadata-map is supplied, it will become the metadata on the\n agent. validate-fn must be nil or a side-effect-free fn of one\n argument, which will be passed the intended new state on any state\n change. If the new state is unacceptable, the validate-fn should\n return false or throw an exception. handler-fn is called if an\n action throws an exception or if validate-fn rejects a new state --\n see set-error-handler! for details. The mode-keyword may be either\n :continue (the default if an error-handler is given) or :fail (the\n default if no error-handler is given) -- see set-error-mode! for\n details.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2052), lang.NewKeyword("end-line"), int(2052))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.NewList(args[1:]...) +var v5 any = "unimplemented: new with non-constant class type" +_ = v5 +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("apply")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("hash-map")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v9, []any{v12, v4}) +var v6 any = v13 +_ = v6 +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("setup-reference")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v5, v4}) +_ = v18 +var v19 any +v20 := lang.Apply(lang.NewKeyword("error-handler"), []any{v6}) +if lang.IsTruthy(v20) { +v21 := lang.Apply(lang.NewKeyword("error-handler"), []any{v6}) +v22, _ := lang.FieldOrMethod(v5, "setErrorHandler") +if reflect.TypeOf(v22).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorHandler is not a function"))) +} +v23 := lang.Apply(v22, []any{v21}) +v19 = v23 +} else { +v19 = nil +} +_ = v19 +v25 := lang.Apply(lang.NewKeyword("error-mode"), []any{v6}) +var v24 any = v25 +_ = v24 +var v27 any +if lang.IsTruthy(v24) { +v27 = v24 +} else { +var v28 any +v29 := lang.Apply(lang.NewKeyword("error-handler"), []any{v6}) +if lang.IsTruthy(v29) { +v28 = lang.NewKeyword("continue") +} else { +v28 = lang.NewKeyword("fail") +} +v27 = v28 +} +v24, _ := lang.FieldOrMethod(v5, "setErrorMode") +if reflect.TypeOf(v24).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorMode is not a function"))) +} +v25 := lang.Apply(v24, []any{v27}) +_ = v25 +return v5 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// release-pending-sends +{ +v0 := lang.NewSymbol("release-pending-sends").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Normally, actions sent directly or indirectly during another action\n are held until the action completes (changes the agent's\n state). This function can be used to dispatch any pending sent\n actions immediately. This has no impact on actions sent during a\n transaction, which are still held until commit. If no action is\n occurring, does nothing. Returns the number of actions dispatched.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2131), lang.NewKeyword("end-line"), int(2131))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.Apply(nil, nil) +return v3 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// *print-namespace-maps* +{ +v0 := lang.NewSymbol("*print-namespace-maps*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(39), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(44), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, false, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// double-array +{ +var v1 lang.FnFunc +{ // function double-array__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.NewList(args[0:]...) +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/doubleArray")}) +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("list")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("seq")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("concat")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("list")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v37, []any{lang.NewSymbol("glojure.core/args")}) +v39 := lang.Apply(v30, []any{v34, v38}) +v40 := lang.Apply(v27, []any{v39}) +v41 := lang.Apply(v24, []any{v40}) +v42 := lang.Apply(v9, []any{v13, v17, v21, v41}) +v43 := lang.Apply(v6, []any{v42}) +return v43 + } +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("double-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Creates an array of doubles", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5341), lang.NewKeyword("end-line"), int(5341))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "doubleArray") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("doubleArray is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 + case 2: +v4 := args[0] +v5 := args[1] +v6, _ := lang.FieldOrMethod(lang1.Numbers, "doubleArrayInit") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("doubleArrayInit is not a function"))) +} +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// bound? +{ +v0 := lang.NewSymbol("bound?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("vars"))), lang.NewKeyword("doc"), "Returns true if all of the vars provided as arguments have any bound value, root or thread-local.\n Implies that deref'ing the provided vars will succeed. Returns true if no vars are provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5534), lang.NewKeyword("end-line"), int(5534))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.NewList(args[0:]...) +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("every?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +var v7 lang.FnFunc +v7 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v8 := args[0] +v9, ok := lang.FieldOrMethod(v8, "isBound") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "isBound"))) +} +var v10 any +switch reflect.TypeOf(v9).Kind() { +case reflect.Func: + v10 = lang.Apply(v9, nil) +default: + v10 = v9 +} +return v10 +}) +v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5540), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5540), lang.NewKeyword("end-column"), int(69)) +v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v10 := lang.Apply(v6, []any{v9, v3}) +return v10 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// unchecked-inc +{ +var v1 lang.FnFunc +{ // function unchecked-inc__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/unchecked_inc")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v3}) +v35 := lang.Apply(v26, []any{v30, v34}) +v36 := lang.Apply(v23, []any{v35}) +v37 := lang.Apply(v20, []any{v36}) +v38 := lang.Apply(v9, []any{v13, v17, v37}) +v39 := lang.Apply(v6, []any{v38}) +return v39 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("unchecked-inc").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns a number one greater than x, a long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1161), lang.NewKeyword("end-line"), int(1161))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "unchecked_inc") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_inc is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// struct +{ +v0 := lang.NewSymbol("struct").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("&"), lang.NewSymbol("vals"))), lang.NewKeyword("doc"), "Returns a new structmap instance with the keys of the\n structure-basis. vals must be supplied for basis keys in order -\n where values are not supplied they will default to nil.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4061), lang.NewKeyword("end-line"), int(4061))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.NewList(args[1:]...) +v5 := lang.Apply(lang1.ConstructPersistentStructMap, []any{v3, v4}) +return v5 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// libspec? +{ +v0 := lang.NewSymbol("libspec?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is a libspec", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5891), lang.NewKeyword("end-line"), int(5891), lang.NewKeyword("private"), true)).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("symbol?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +var v4 any = v8 +_ = v4 +var v10 any +if lang.IsTruthy(v4) { +v10 = v4 +} else { +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("vector?")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v3}) +var v11 any = v15 +_ = v11 +var v17 any +if lang.IsTruthy(v11) { +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("nil?")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("second")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v3}) +v26 := lang.Apply(v21, []any{v25}) +var v18 any = v26 +_ = v18 +var v28 any +if lang.IsTruthy(v18) { +v28 = v18 +} else { +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("keyword?")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("second")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.Apply(v31, []any{v35}) +v28 = v36 +} +v17 = v28 +} else { +v17 = v11 +} +v10 = v17 +} +return v10 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// boolean? +{ +v0 := lang.NewSymbol("boolean?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a Boolean", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(518), lang.NewKeyword("end-line"), int(518))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{lang.Builtins["bool"], v3}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// print-str +{ +v1 := reflect.TypeOf("") +v0 := lang.NewSymbol("print-str").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("xs"))), lang.NewKeyword("doc"), "print to a string, returning it", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4776), lang.NewKeyword("end-line"), int(4776))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := lang.NewList(args[0:]...) +var v5 any = "unimplemented: new with non-constant class type" +_ = v5 +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("push-thread-bindings")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("hash-map")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*out*")) +v15 := lang.Apply(v13, []any{v14, v5}) +v16 := lang.Apply(v10, []any{v15}) +_ = v16 +var v17 any +func() { +defer func() { +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, nil) +}() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("apply")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("print")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.Apply(v24, []any{v27, v4}) +_ = v28 +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("str")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.Apply(v31, []any{v5}) +v17 = v32 +}() +return v17 + } +}) +v4 := reflect.TypeOf("") +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// stream-into! +{ +v0 := lang.NewSymbol("stream-into!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("stream")), lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("xform"), lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Returns a new coll consisting of coll with all of the items of the\n stream conjoined. This is a terminal operation on the stream.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6853), lang.NewKeyword("end-line"), int(6853))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v3 := args[0] +v4 := args[1] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{lang1.IEditableCollection, v3}) +if lang.IsTruthy(v9) { +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("with-meta")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("persistent!")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("stream-reduce!")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("conj!")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("transient")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v3}) +v26 := lang.Apply(v18, []any{v21, v25, v4}) +v27 := lang.Apply(v15, []any{v26}) +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("meta")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{v3}) +v32 := lang.Apply(v12, []any{v27, v31}) +v5 = v32 +} else { +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("stream-reduce!")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("conj")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v35, []any{v38, v3, v4}) +v5 = v39 +} +return v5 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +var v6 any +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("instance?")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{lang1.IEditableCollection, v3}) +if lang.IsTruthy(v10) { +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("with-meta")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("persistent!")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("stream-transduce!")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("conj!")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("transient")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{v3}) +v27 := lang.Apply(v19, []any{v4, v22, v26, v5}) +v28 := lang.Apply(v16, []any{v27}) +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("meta")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.Apply(v31, []any{v3}) +v33 := lang.Apply(v13, []any{v28, v32}) +v6 = v33 +} else { +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("stream-transduce!")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("conj")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.Apply(v36, []any{v4, v39, v3, v5}) +v6 = v40 +} +return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// filterv +{ +v0 := lang.NewSymbol("filterv").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a vector of the items in coll for which\n (pred item) returns logical true. pred must be free of side-effects.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7004), lang.NewKeyword("end-line"), int(7004))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("persistent!")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("reduce")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +var v11 lang.FnFunc +v11 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v12 := args[0] +v13 := args[1] +var v14 any +v15 := lang.Apply(v3, []any{v13}) +if lang.IsTruthy(v15) { +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("conj!")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v12, v13}) +v14 = v19 +} else { +v14 = v12 +} +return v14 +}) +v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7010), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(7010), lang.NewKeyword("end-column"), int(52)) +v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("transient")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.NewVector() +v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7011), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(7011), lang.NewKeyword("end-column"), int(27)) +v19, err := lang.WithMeta(v17, v18.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v20 := lang.Apply(v16, []any{v19}) +v21 := lang.Apply(v10, []any{v13, v20, v4}) +v22 := lang.Apply(v7, []any{v21}) +return v22 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// min +{ +var v1 lang.FnFunc +v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v2 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +if lang.IsTruthy(v7) { +v4 = closed7 +} else { +v4 = v3 +} +var v3 any = v4 +_ = v3 +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("seq")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("concat")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("seq")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("concat")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v2}) +v40 := lang.Apply(v31, []any{v35, v39}) +v41 := lang.Apply(v28, []any{v40}) +v42 := lang.Apply(v25, []any{v41}) +v43 := lang.Apply(v14, []any{v18, v22, v42}) +v44 := lang.Apply(v11, []any{v43}) +return v44 + case 2: +v2 := args[0] +v3 := args[1] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +if lang.IsTruthy(v8) { +v5 = closed7 +} else { +v5 = v4 +} +var v4 any = v5 +_ = v4 +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("seq")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("concat")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("list")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("list")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("list")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("seq")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("concat")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("list")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v4}) +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("list")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v2}) +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("list")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v3}) +v45 := lang.Apply(v32, []any{v36, v40, v44}) +v46 := lang.Apply(v29, []any{v45}) +v47 := lang.Apply(v26, []any{v46}) +v48 := lang.Apply(v15, []any{v19, v23, v47}) +v49 := lang.Apply(v12, []any{v48}) +return v49 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v2 := args[0] +v3 := args[1] +v4 := lang.NewList(args[2:]...) +var v6 any +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +if lang.IsTruthy(v9) { +v6 = closed7 +} else { +v6 = v5 +} +var v5 any = v6 +_ = v5 +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +var v14 lang.FnFunc +v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v15 := args[0] +v16 := args[1] +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v5}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v15}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v16}) +v52 := lang.Apply(v39, []any{v43, v47, v51}) +v53 := lang.Apply(v36, []any{v52}) +v54 := lang.Apply(v33, []any{v53}) +v55 := lang.Apply(v22, []any{v26, v30, v54}) +v56 := lang.Apply(v19, []any{v55}) +return v56 +}) +v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) +v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v5}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v2}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v3}) +v52 := lang.Apply(v39, []any{v43, v47, v51}) +v53 := lang.Apply(v36, []any{v52}) +v54 := lang.Apply(v33, []any{v53}) +v55 := lang.Apply(v22, []any{v26, v30, v54}) +v56 := lang.Apply(v19, []any{v55}) +v57 := lang.Apply(v13, []any{v16, v56, v4}) +return v57 + } +}) +v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) +} +v5 := lang.Apply(v4, []any{v3, int64(1)}) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v0 := lang.NewSymbol("min").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the least of the nums.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1118), lang.NewKeyword("end-line"), int(1118))).(*lang.Symbol) +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v5 := args[0] +return v5 + case 2: +v5 := args[0] +v6 := args[1] +v7, _ := lang.FieldOrMethod(lang1.Numbers, "min") +if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("min is not a function"))) +} +v8 := lang.Apply(v7, []any{v5, v6}) +return v8 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +v6 := args[1] +v7 := lang.NewList(args[2:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("min")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("min")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v5, v6}) +v18 := lang.Apply(v10, []any{v13, v17, v7}) +return v18 + } +}) +v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v3 := ns.InternWithValue(v0, v4, true) +if v0.Meta() != nil { + v3.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// lazy-seq +{ +v0 := lang.NewSymbol("lazy-seq").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Takes a body of expressions that returns an ISeq or nil, and yields\n a Seqable object that will invoke the body only the first time seq\n is called, and will cache the result and return it on all subsequent\n seq calls. See also - realized?", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(676), lang.NewKeyword("end-line"), int(676))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("list")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("list*")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.NewVector() +v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(683), lang.NewKeyword("column"), int(101), lang.NewKeyword("end-line"), int(683), lang.NewKeyword("end-column"), int(102)) +v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v15 := lang.Apply(v11, []any{lang.NewSymbol("fn*"), v14, v5}) +v16 := lang.Apply(v8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewLazySeq"), v15}) +return v16 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// nthrest +{ +v0 := lang.NewSymbol("nthrest").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns the nth rest of coll, coll when n is 0.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3161), lang.NewKeyword("end-line"), int(3161))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("pos?")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v4}) +if lang.IsTruthy(v9) { +var v11 any +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("instance?")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{lang1.IDrop, v3}) +if lang.IsTruthy(v15) { +var v16 any +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("int?")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v4}) +if lang.IsTruthy(v20) { +v16 = v4 +} else { +v21 := lang.Apply(nil, []any{v4}) +v16 = v21 +} +v22, _ := lang.FieldOrMethod(v3, "drop") +if reflect.TypeOf(v22).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("drop is not a function"))) +} +v23 := lang.Apply(v22, []any{v16}) +v11 = v23 +} else { +var v24 any = v24 +_ = v24 +var v25 any = v3 +_ = v25 +var v26 any +for { +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("pos?")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.Apply(v31, []any{v24}) +var v28 any = v32 +_ = v28 +var v34 any +if lang.IsTruthy(v28) { +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("seq")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v37, []any{v25}) +v34 = v38 +} else { +v34 = v28 +} +var v27 any = v34 +_ = v27 +var v29 any +if lang.IsTruthy(v27) { +var v30 any = v27 +_ = v30 +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("dec")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v24}) +var v32 any = v36 +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("rest")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.Apply(v40, []any{v30}) +var v37 any = v41 +v24 = v32 +v25 = v37 +continue +} else { +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("seq")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.Apply(v32, []any{v25}) +v29 = v33 +} +v26 = v29 + break +} +v11 = v26 +} +var v10 any = v11 +_ = v10 +var v25 any +if lang.IsTruthy(v10) { +v25 = v10 +} else { +v25 = lang.NewList() +} +v5 = v25 +} else { +v5 = v3 +} +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// *command-line-args* +{ +v0 := lang.NewSymbol("*command-line-args*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "A sequence of the supplied command line arguments, or nil if\n none were supplied", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, nil, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// descendants +{ +v0 := lang.NewSymbol("descendants").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"))), lang.NewKeyword("doc"), "Returns the immediate and indirect children of tag, through a\n relationship established via derive. h must be a hierarchy obtained\n from make-hierarchy, if not supplied defaults to the global\n hierarchy. Note: does not work on Java type inheritance\n relationships.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5636), lang.NewKeyword("end-line"), int(5636))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("descendants")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("global-hierarchy")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v6, []any{v9, v3}) +return v10 + case 2: +v3 := args[0] +v4 := args[1] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("class?")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v4}) +if lang.IsTruthy(v9) { +v10 := lang.Apply(java.lang.UnsupportedOperationException29., []any{"Can't get descendants of classes"}) +panic(v10) +} else { +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("not-empty")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("get")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(lang.NewKeyword("descendants"), []any{v3}) +v18 := lang.Apply(v16, []any{v17, v4}) +v19 := lang.Apply(v13, []any{v18}) +v5 = v19 +} +return v5 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// mapv +{ +v0 := lang.NewSymbol("mapv").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2"), lang.NewSymbol("c3")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2"), lang.NewSymbol("c3"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Returns a vector consisting of the result of applying f to the\n set of first items of each coll, followed by applying f to the set\n of second items in each coll, until any one of the colls is\n exhausted. Any remaining items in other colls are ignored. Function\n f should accept number-of-colls arguments.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6986), lang.NewKeyword("end-line"), int(6986))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("persistent!")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("reduce")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +var v11 lang.FnFunc +v11 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v12 := args[0] +v13 := args[1] +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("conj!")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v3, []any{v13}) +v18 := lang.Apply(v16, []any{v12, v17}) +return v18 +}) +v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6995), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(6995), lang.NewKeyword("end-column"), int(43)) +v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("transient")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.NewVector() +v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6995), lang.NewKeyword("column"), int(56), lang.NewKeyword("end-line"), int(6995), lang.NewKeyword("end-column"), int(57)) +v19, err := lang.WithMeta(v17, v18.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v20 := lang.Apply(v16, []any{v19}) +v21 := lang.Apply(v10, []any{v13, v20, v4}) +v22 := lang.Apply(v7, []any{v21}) +return v22 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("into")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.NewVector() +v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6998), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(6998), lang.NewKeyword("end-column"), int(13)) +v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("map")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v3, v4, v5}) +v16 := lang.Apply(v8, []any{v11, v15}) +return v16 + case 4: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("into")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.NewVector() +v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7000), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(7000), lang.NewKeyword("end-column"), int(13)) +v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("map")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v3, v4, v5, v6}) +v17 := lang.Apply(v9, []any{v12, v16}) +return v17 + default: + if len(args) < 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := lang.NewList(args[4:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("into")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.NewVector() +v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7002), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(7002), lang.NewKeyword("end-column"), int(13)) +v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("apply")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("map")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v16, []any{v19, v3, v4, v5, v6, v7}) +v21 := lang.Apply(v10, []any{v13, v20}) +return v21 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// doseq +{ +v0 := lang.NewSymbol("doseq").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("seq-exprs"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Repeatedly executes body (presumably for side-effects) with\n bindings and filtering as provided by \"for\". Does not retain\n the head of the sequence. Returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3209), lang.NewKeyword("end-line"), int(3209))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +var v7 any +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v5}) +if lang.IsTruthy(v11) { +v7 = nil +} else { +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("str")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("first")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v3}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("meta")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v3}) +v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) +v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) +v28 := lang.Apply(lang1.NewIllegalArgumentError, []any{v27}) +panic(v28) +} +_ = v7 +var v29 any +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("even?")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("count")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v5}) +v37 := lang.Apply(v32, []any{v36}) +if lang.IsTruthy(v37) { +v29 = nil +} else { +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("str")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("first")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v3}) +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +} +v47 := v46.Get() +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("meta")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v3}) +v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) +v53 := lang.Apply(v40, []any{v44, " requires ", "an even number of forms in binding vector", " in ", v47, ":", v52}) +v54 := lang.Apply(lang1.NewIllegalArgumentError, []any{v53}) +panic(v54) +} +_ = v29 +_ = nil +var v56 lang.FnFunc +{ // function step +v56 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v58 := args[0] +v59 := args[1] +var v60 any +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("not")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +} +v63 := v62.Get() +v64 := lang.Apply(v63, []any{v59}) +if lang.IsTruthy(v64) { +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("seq")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +} +v67 := v66.Get() +v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v69 := v68.FindInternedVar(lang.NewSymbol("concat")) +if v69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) +} +v70 := v69.Get() +v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v72 := v71.FindInternedVar(lang.NewSymbol("list")) +if v72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) +} +v73 := v72.Get() +v74 := lang.Apply(v73, []any{lang.NewSymbol("do")}) +v75 := lang.Apply(v70, []any{v74, v6}) +v76 := lang.Apply(v67, []any{v75}) +v77 := lang.NewVector(true, v76) +v78 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3220), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(3220), lang.NewKeyword("end-column"), int(36)) +v79, err := lang.WithMeta(v77, v78.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v60 = v79 +} else { +v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v82 := v81.FindInternedVar(lang.NewSymbol("first")) +if v82.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) +} +v83 := v82.Get() +v84 := lang.Apply(v83, []any{v59}) +var v80 any = v84 +_ = v80 +v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v87 := v86.FindInternedVar(lang.NewSymbol("second")) +if v87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) +} +v88 := v87.Get() +v89 := lang.Apply(v88, []any{v59}) +var v85 any = v89 +_ = v85 +var v91 any +v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v93 := v92.FindInternedVar(lang.NewSymbol("keyword?")) +if v93.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) +} +v94 := v93.Get() +v95 := lang.Apply(v94, []any{v80}) +if lang.IsTruthy(v95) { +v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v98 := v97.FindInternedVar(lang.NewSymbol("nnext")) +if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) +} +v99 := v98.Get() +v100 := lang.Apply(v99, []any{v59}) +v101 := lang.Apply(v57, []any{v58, v100}) +var v96 any = v101 +_ = v96 +v103 := lang.Apply(v96, []any{int64(0)}) +var v102 any = v103 +_ = v102 +v105 := lang.Apply(v96, []any{int64(1)}) +var v104 any = v105 +_ = v104 +var v107 any +v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v109 := v108.FindInternedVar(lang.NewSymbol("=")) +if v109.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) +} +v110 := v109.Get() +v111 := lang.Apply(v110, []any{v80, lang.NewKeyword("let")}) +if lang.IsTruthy(v111) { +v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v113 := v112.FindInternedVar(lang.NewSymbol("seq")) +if v113.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) +} +v114 := v113.Get() +v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v116 := v115.FindInternedVar(lang.NewSymbol("concat")) +if v116.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) +} +v117 := v116.Get() +v118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v119 := v118.FindInternedVar(lang.NewSymbol("list")) +if v119.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v119))) +} +v120 := v119.Get() +v121 := lang.Apply(v120, []any{lang.NewSymbol("glojure.core/let")}) +v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v123 := v122.FindInternedVar(lang.NewSymbol("list")) +if v123.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) +} +v124 := v123.Get() +v125 := lang.Apply(v124, []any{v85}) +v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v127 := v126.FindInternedVar(lang.NewSymbol("list")) +if v127.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) +} +v128 := v127.Get() +v129 := lang.Apply(v128, []any{v104}) +v130 := lang.Apply(v117, []any{v121, v125, v129}) +v131 := lang.Apply(v114, []any{v130}) +v132 := lang.NewVector(v102, v131) +v133 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3228), lang.NewKeyword("column"), int(37), lang.NewKeyword("end-line"), int(3228), lang.NewKeyword("end-column"), int(64)) +v134, err := lang.WithMeta(v132, v133.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v107 = v134 +} else { +var v135 any +v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v137 := v136.FindInternedVar(lang.NewSymbol("=")) +if v137.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) +} +v138 := v137.Get() +v139 := lang.Apply(v138, []any{v80, lang.NewKeyword("while")}) +if lang.IsTruthy(v139) { +v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v141 := v140.FindInternedVar(lang.NewSymbol("seq")) +if v141.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) +} +v142 := v141.Get() +v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v144 := v143.FindInternedVar(lang.NewSymbol("concat")) +if v144.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) +} +v145 := v144.Get() +v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v147 := v146.FindInternedVar(lang.NewSymbol("list")) +if v147.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) +} +v148 := v147.Get() +v149 := lang.Apply(v148, []any{lang.NewSymbol("glojure.core/when")}) +v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v151 := v150.FindInternedVar(lang.NewSymbol("list")) +if v151.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) +} +v152 := v151.Get() +v153 := lang.Apply(v152, []any{v85}) +v154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v155 := v154.FindInternedVar(lang.NewSymbol("list")) +if v155.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v155))) +} +v156 := v155.Get() +v157 := lang.Apply(v156, []any{v104}) +var v158 any +if lang.IsTruthy(v102) { +v159 := lang.NewVector(v58) +v160 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3231), lang.NewKeyword("column"), int(65), lang.NewKeyword("end-line"), int(3231), lang.NewKeyword("end-column"), int(73)) +v161, err := lang.WithMeta(v159, v160.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v158 = v161 +} else { +v158 = nil +} +v162 := lang.Apply(v145, []any{v149, v153, v157, v158}) +v163 := lang.Apply(v142, []any{v162}) +v164 := lang.NewVector(false, v163) +v165 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3229), lang.NewKeyword("column"), int(39), lang.NewKeyword("end-line"), int(3231), lang.NewKeyword("end-column"), int(76)) +v166, err := lang.WithMeta(v164, v165.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v135 = v166 +} else { +var v167 any +v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v169 := v168.FindInternedVar(lang.NewSymbol("=")) +if v169.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) +} +v170 := v169.Get() +v171 := lang.Apply(v170, []any{v80, lang.NewKeyword("when")}) +if lang.IsTruthy(v171) { +v172 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v173 := v172.FindInternedVar(lang.NewSymbol("seq")) +if v173.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v173))) +} +v174 := v173.Get() +v175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v176 := v175.FindInternedVar(lang.NewSymbol("concat")) +if v176.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v176))) +} +v177 := v176.Get() +v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v179 := v178.FindInternedVar(lang.NewSymbol("list")) +if v179.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) +} +v180 := v179.Get() +v181 := lang.Apply(v180, []any{lang.NewSymbol("if")}) +v182 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v183 := v182.FindInternedVar(lang.NewSymbol("list")) +if v183.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v183))) +} +v184 := v183.Get() +v185 := lang.Apply(v184, []any{v85}) +v186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v187 := v186.FindInternedVar(lang.NewSymbol("list")) +if v187.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v187))) +} +v188 := v187.Get() +v189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v190 := v189.FindInternedVar(lang.NewSymbol("seq")) +if v190.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v190))) +} +v191 := v190.Get() +v192 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v193 := v192.FindInternedVar(lang.NewSymbol("concat")) +if v193.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v193))) +} +v194 := v193.Get() +v195 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v196 := v195.FindInternedVar(lang.NewSymbol("list")) +if v196.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v196))) +} +v197 := v196.Get() +v198 := lang.Apply(v197, []any{lang.NewSymbol("do")}) +v199 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v200 := v199.FindInternedVar(lang.NewSymbol("list")) +if v200.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v200))) +} +v201 := v200.Get() +v202 := lang.Apply(v201, []any{v104}) +var v203 any +if lang.IsTruthy(v102) { +v204 := lang.NewVector(v58) +v205 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3235), lang.NewKeyword("column"), int(66), lang.NewKeyword("end-line"), int(3235), lang.NewKeyword("end-column"), int(74)) +v206, err := lang.WithMeta(v204, v205.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v203 = v206 +} else { +v203 = nil +} +v207 := lang.Apply(v194, []any{v198, v202, v203}) +v208 := lang.Apply(v191, []any{v207}) +v209 := lang.Apply(v188, []any{v208}) +v210 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v211 := v210.FindInternedVar(lang.NewSymbol("list")) +if v211.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v211))) +} +v212 := v211.Get() +v213 := lang.Apply(v212, []any{v58}) +v214 := lang.Apply(v177, []any{v181, v185, v209, v213}) +v215 := lang.Apply(v174, []any{v214}) +v216 := lang.NewVector(false, v215) +v217 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3232), lang.NewKeyword("column"), int(38), lang.NewKeyword("end-line"), int(3236), lang.NewKeyword("end-column"), int(57)) +v218, err := lang.WithMeta(v216, v217.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v167 = v218 +} else { +v167 = nil +} +v135 = v167 +} +v107 = v135 +} +v91 = v107 +} else { +v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v98 := v97.FindInternedVar(lang.NewSymbol("gensym")) +if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) +} +v99 := v98.Get() +v100 := lang.Apply(v99, []any{"seq_"}) +var v96 any = v100 +_ = v96 +v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v103 := v102.FindInternedVar(lang.NewSymbol("with-meta")) +if v103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) +} +v104 := v103.Get() +v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v106 := v105.FindInternedVar(lang.NewSymbol("gensym")) +if v106.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) +} +v107 := v106.Get() +v108 := lang.Apply(v107, []any{"chunk_"}) +v109 := lang.NewMap(lang.NewKeyword("tag"), lang.NewSymbol("glojure.lang.IChunk")) +v110 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3239), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(3239), lang.NewKeyword("end-column"), int(72)) +v111, err := lang.WithMeta(v109, v110.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v112 := lang.Apply(v104, []any{v108, v111}) +var v101 any = v112 +_ = v101 +v114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v115 := v114.FindInternedVar(lang.NewSymbol("gensym")) +if v115.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v115))) +} +v116 := v115.Get() +v117 := lang.Apply(v116, []any{"count_"}) +var v113 any = v117 +_ = v113 +v119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v120 := v119.FindInternedVar(lang.NewSymbol("gensym")) +if v120.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v120))) +} +v121 := v120.Get() +v122 := lang.Apply(v121, []any{"i_"}) +var v118 any = v122 +_ = v118 +v124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v125 := v124.FindInternedVar(lang.NewSymbol("seq")) +if v125.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v125))) +} +v126 := v125.Get() +v127 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v128 := v127.FindInternedVar(lang.NewSymbol("concat")) +if v128.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v128))) +} +v129 := v128.Get() +v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v131 := v130.FindInternedVar(lang.NewSymbol("list")) +if v131.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) +} +v132 := v131.Get() +v133 := lang.Apply(v132, []any{lang.NewSymbol("recur")}) +v134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v135 := v134.FindInternedVar(lang.NewSymbol("list")) +if v135.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v135))) +} +v136 := v135.Get() +v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v138 := v137.FindInternedVar(lang.NewSymbol("seq")) +if v138.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) +} +v139 := v138.Get() +v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v141 := v140.FindInternedVar(lang.NewSymbol("concat")) +if v141.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) +} +v142 := v141.Get() +v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v144 := v143.FindInternedVar(lang.NewSymbol("list")) +if v144.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) +} +v145 := v144.Get() +v146 := lang.Apply(v145, []any{lang.NewSymbol("glojure.core/next")}) +v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v148 := v147.FindInternedVar(lang.NewSymbol("list")) +if v148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) +} +v149 := v148.Get() +v150 := lang.Apply(v149, []any{v96}) +v151 := lang.Apply(v142, []any{v146, v150}) +v152 := lang.Apply(v139, []any{v151}) +v153 := lang.Apply(v136, []any{v152}) +v154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v155 := v154.FindInternedVar(lang.NewSymbol("list")) +if v155.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v155))) +} +v156 := v155.Get() +v157 := lang.Apply(v156, []any{nil}) +v158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v159 := v158.FindInternedVar(lang.NewSymbol("list")) +if v159.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v159))) +} +v160 := v159.Get() +v161 := lang.Apply(v160, []any{int64(0)}) +v162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v163 := v162.FindInternedVar(lang.NewSymbol("list")) +if v163.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v163))) +} +v164 := v163.Get() +v165 := lang.Apply(v164, []any{int64(0)}) +v166 := lang.Apply(v129, []any{v133, v153, v157, v161, v165}) +v167 := lang.Apply(v126, []any{v166}) +var v123 any = v167 +_ = v123 +v169 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v170 := v169.FindInternedVar(lang.NewSymbol("nnext")) +if v170.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v170))) +} +v171 := v170.Get() +v172 := lang.Apply(v171, []any{v59}) +v173 := lang.Apply(v57, []any{v123, v172}) +var v168 any = v173 +_ = v168 +v175 := lang.Apply(v168, []any{int64(0)}) +var v174 any = v175 +_ = v174 +v177 := lang.Apply(v168, []any{int64(1)}) +var v176 any = v177 +_ = v176 +v179 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v180 := v179.FindInternedVar(lang.NewSymbol("seq")) +if v180.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v180))) +} +v181 := v180.Get() +v182 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v183 := v182.FindInternedVar(lang.NewSymbol("concat")) +if v183.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v183))) +} +v184 := v183.Get() +v185 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v186 := v185.FindInternedVar(lang.NewSymbol("list")) +if v186.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v186))) +} +v187 := v186.Get() +v188 := lang.Apply(v187, []any{lang.NewSymbol("recur")}) +v189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v190 := v189.FindInternedVar(lang.NewSymbol("list")) +if v190.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v190))) +} +v191 := v190.Get() +v192 := lang.Apply(v191, []any{v96}) +v193 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v194 := v193.FindInternedVar(lang.NewSymbol("list")) +if v194.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v194))) +} +v195 := v194.Get() +v196 := lang.Apply(v195, []any{v101}) +v197 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v198 := v197.FindInternedVar(lang.NewSymbol("list")) +if v198.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v198))) +} +v199 := v198.Get() +v200 := lang.Apply(v199, []any{v113}) +v201 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v202 := v201.FindInternedVar(lang.NewSymbol("list")) +if v202.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v202))) +} +v203 := v202.Get() +v204 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v205 := v204.FindInternedVar(lang.NewSymbol("seq")) +if v205.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v205))) +} +v206 := v205.Get() +v207 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v208 := v207.FindInternedVar(lang.NewSymbol("concat")) +if v208.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v208))) +} +v209 := v208.Get() +v210 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v211 := v210.FindInternedVar(lang.NewSymbol("list")) +if v211.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v211))) +} +v212 := v211.Get() +v213 := lang.Apply(v212, []any{lang.NewSymbol("glojure.core/unchecked-inc")}) +v214 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v215 := v214.FindInternedVar(lang.NewSymbol("list")) +if v215.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v215))) +} +v216 := v215.Get() +v217 := lang.Apply(v216, []any{v118}) +v218 := lang.Apply(v209, []any{v213, v217}) +v219 := lang.Apply(v206, []any{v218}) +v220 := lang.Apply(v203, []any{v219}) +v221 := lang.Apply(v184, []any{v188, v192, v196, v200, v220}) +v222 := lang.Apply(v181, []any{v221}) +var v178 any = v222 +_ = v178 +v224 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v225 := v224.FindInternedVar(lang.NewSymbol("nnext")) +if v225.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v225))) +} +v226 := v225.Get() +v227 := lang.Apply(v226, []any{v59}) +v228 := lang.Apply(v57, []any{v178, v227}) +var v223 any = v228 +_ = v223 +v230 := lang.Apply(v223, []any{int64(1)}) +var v229 any = v230 +_ = v229 +v232 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v233 := v232.FindInternedVar(lang.NewSymbol("seq")) +if v233.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v233))) +} +v234 := v233.Get() +v235 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v236 := v235.FindInternedVar(lang.NewSymbol("concat")) +if v236.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v236))) +} +v237 := v236.Get() +v238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v239 := v238.FindInternedVar(lang.NewSymbol("list")) +if v239.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v239))) +} +v240 := v239.Get() +v241 := lang.Apply(v240, []any{lang.NewSymbol("glojure.core/loop")}) +v242 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v243 := v242.FindInternedVar(lang.NewSymbol("list")) +if v243.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v243))) +} +v244 := v243.Get() +v245 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v246 := v245.FindInternedVar(lang.NewSymbol("apply")) +if v246.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v246))) +} +v247 := v246.Get() +v248 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v249 := v248.FindInternedVar(lang.NewSymbol("vector")) +if v249.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v249))) +} +v250 := v249.Get() +v251 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v252 := v251.FindInternedVar(lang.NewSymbol("seq")) +if v252.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v252))) +} +v253 := v252.Get() +v254 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v255 := v254.FindInternedVar(lang.NewSymbol("concat")) +if v255.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v255))) +} +v256 := v255.Get() +v257 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v258 := v257.FindInternedVar(lang.NewSymbol("list")) +if v258.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v258))) +} +v259 := v258.Get() +v260 := lang.Apply(v259, []any{v96}) +v261 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v262 := v261.FindInternedVar(lang.NewSymbol("list")) +if v262.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v262))) +} +v263 := v262.Get() +v264 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v265 := v264.FindInternedVar(lang.NewSymbol("seq")) +if v265.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v265))) +} +v266 := v265.Get() +v267 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v268 := v267.FindInternedVar(lang.NewSymbol("concat")) +if v268.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v268))) +} +v269 := v268.Get() +v270 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v271 := v270.FindInternedVar(lang.NewSymbol("list")) +if v271.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v271))) +} +v272 := v271.Get() +v273 := lang.Apply(v272, []any{lang.NewSymbol("glojure.core/seq")}) +v274 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v275 := v274.FindInternedVar(lang.NewSymbol("list")) +if v275.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v275))) +} +v276 := v275.Get() +v277 := lang.Apply(v276, []any{v85}) +v278 := lang.Apply(v269, []any{v273, v277}) +v279 := lang.Apply(v266, []any{v278}) +v280 := lang.Apply(v263, []any{v279}) +v281 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v282 := v281.FindInternedVar(lang.NewSymbol("list")) +if v282.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v282))) +} +v283 := v282.Get() +v284 := lang.Apply(v283, []any{v101}) +v285 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v286 := v285.FindInternedVar(lang.NewSymbol("list")) +if v286.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v286))) +} +v287 := v286.Get() +v288 := lang.Apply(v287, []any{nil}) +v289 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v290 := v289.FindInternedVar(lang.NewSymbol("list")) +if v290.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v290))) +} +v291 := v290.Get() +v292 := lang.Apply(v291, []any{v113}) +v293 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v294 := v293.FindInternedVar(lang.NewSymbol("list")) +if v294.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v294))) +} +v295 := v294.Get() +v296 := lang.Apply(v295, []any{int64(0)}) +v297 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v298 := v297.FindInternedVar(lang.NewSymbol("list")) +if v298.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v298))) +} +v299 := v298.Get() +v300 := lang.Apply(v299, []any{v118}) +v301 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v302 := v301.FindInternedVar(lang.NewSymbol("list")) +if v302.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v302))) +} +v303 := v302.Get() +v304 := lang.Apply(v303, []any{int64(0)}) +v305 := lang.Apply(v256, []any{v260, v280, v284, v288, v292, v296, v300, v304}) +v306 := lang.Apply(v253, []any{v305}) +v307 := lang.Apply(v247, []any{v250, v306}) +v308 := lang.Apply(v244, []any{v307}) +v309 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v310 := v309.FindInternedVar(lang.NewSymbol("list")) +if v310.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v310))) +} +v311 := v310.Get() +v312 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v313 := v312.FindInternedVar(lang.NewSymbol("seq")) +if v313.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v313))) +} +v314 := v313.Get() +v315 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v316 := v315.FindInternedVar(lang.NewSymbol("concat")) +if v316.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v316))) +} +v317 := v316.Get() +v318 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v319 := v318.FindInternedVar(lang.NewSymbol("list")) +if v319.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v319))) +} +v320 := v319.Get() +v321 := lang.Apply(v320, []any{lang.NewSymbol("if")}) +v322 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v323 := v322.FindInternedVar(lang.NewSymbol("list")) +if v323.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v323))) +} +v324 := v323.Get() +v325 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v326 := v325.FindInternedVar(lang.NewSymbol("seq")) +if v326.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v326))) +} +v327 := v326.Get() +v328 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v329 := v328.FindInternedVar(lang.NewSymbol("concat")) +if v329.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v329))) +} +v330 := v329.Get() +v331 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v332 := v331.FindInternedVar(lang.NewSymbol("list")) +if v332.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v332))) +} +v333 := v332.Get() +v334 := lang.Apply(v333, []any{lang.NewSymbol("glojure.core/<")}) +v335 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v336 := v335.FindInternedVar(lang.NewSymbol("list")) +if v336.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v336))) +} +v337 := v336.Get() +v338 := lang.Apply(v337, []any{v118}) +v339 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v340 := v339.FindInternedVar(lang.NewSymbol("list")) +if v340.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v340))) +} +v341 := v340.Get() +v342 := lang.Apply(v341, []any{v113}) +v343 := lang.Apply(v330, []any{v334, v338, v342}) +v344 := lang.Apply(v327, []any{v343}) +v345 := lang.Apply(v324, []any{v344}) +v346 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v347 := v346.FindInternedVar(lang.NewSymbol("list")) +if v347.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v347))) +} +v348 := v347.Get() +v349 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v350 := v349.FindInternedVar(lang.NewSymbol("seq")) +if v350.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v350))) +} +v351 := v350.Get() +v352 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v353 := v352.FindInternedVar(lang.NewSymbol("concat")) +if v353.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v353))) +} +v354 := v353.Get() +v355 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v356 := v355.FindInternedVar(lang.NewSymbol("list")) +if v356.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v356))) +} +v357 := v356.Get() +v358 := lang.Apply(v357, []any{lang.NewSymbol("glojure.core/let")}) +v359 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v360 := v359.FindInternedVar(lang.NewSymbol("list")) +if v360.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v360))) +} +v361 := v360.Get() +v362 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v363 := v362.FindInternedVar(lang.NewSymbol("apply")) +if v363.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v363))) +} +v364 := v363.Get() +v365 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v366 := v365.FindInternedVar(lang.NewSymbol("vector")) +if v366.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v366))) +} +v367 := v366.Get() +v368 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v369 := v368.FindInternedVar(lang.NewSymbol("seq")) +if v369.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v369))) +} +v370 := v369.Get() +v371 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v372 := v371.FindInternedVar(lang.NewSymbol("concat")) +if v372.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v372))) +} +v373 := v372.Get() +v374 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v375 := v374.FindInternedVar(lang.NewSymbol("list")) +if v375.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v375))) +} +v376 := v375.Get() +v377 := lang.Apply(v376, []any{v80}) +v378 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v379 := v378.FindInternedVar(lang.NewSymbol("list")) +if v379.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v379))) +} +v380 := v379.Get() +v381 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v382 := v381.FindInternedVar(lang.NewSymbol("seq")) +if v382.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v382))) +} +v383 := v382.Get() +v384 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v385 := v384.FindInternedVar(lang.NewSymbol("concat")) +if v385.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v385))) +} +v386 := v385.Get() +v387 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v388 := v387.FindInternedVar(lang.NewSymbol("list")) +if v388.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v388))) +} +v389 := v388.Get() +v390 := lang.Apply(v389, []any{lang.NewSymbol(".nth")}) +v391 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v392 := v391.FindInternedVar(lang.NewSymbol("list")) +if v392.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v392))) +} +v393 := v392.Get() +v394 := lang.Apply(v393, []any{v101}) +v395 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v396 := v395.FindInternedVar(lang.NewSymbol("list")) +if v396.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v396))) +} +v397 := v396.Get() +v398 := lang.Apply(v397, []any{v118}) +v399 := lang.Apply(v386, []any{v390, v394, v398}) +v400 := lang.Apply(v383, []any{v399}) +v401 := lang.Apply(v380, []any{v400}) +v402 := lang.Apply(v373, []any{v377, v401}) +v403 := lang.Apply(v370, []any{v402}) +v404 := lang.Apply(v364, []any{v367, v403}) +v405 := lang.Apply(v361, []any{v404}) +v406 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v407 := v406.FindInternedVar(lang.NewSymbol("list")) +if v407.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v407))) +} +v408 := v407.Get() +v409 := lang.Apply(v408, []any{v229}) +var v410 any +if lang.IsTruthy(v174) { +v411 := lang.NewVector(v178) +v412 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3256), lang.NewKeyword("column"), int(48), lang.NewKeyword("end-line"), int(3256), lang.NewKeyword("end-column"), int(62)) +v413, err := lang.WithMeta(v411, v412.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v410 = v413 +} else { +v410 = nil +} +v414 := lang.Apply(v354, []any{v358, v405, v409, v410}) +v415 := lang.Apply(v351, []any{v414}) +v416 := lang.Apply(v348, []any{v415}) +v417 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v418 := v417.FindInternedVar(lang.NewSymbol("list")) +if v418.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v418))) +} +v419 := v418.Get() +v420 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v421 := v420.FindInternedVar(lang.NewSymbol("seq")) +if v421.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v421))) +} +v422 := v421.Get() +v423 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v424 := v423.FindInternedVar(lang.NewSymbol("concat")) +if v424.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v424))) +} +v425 := v424.Get() +v426 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v427 := v426.FindInternedVar(lang.NewSymbol("list")) +if v427.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v427))) +} +v428 := v427.Get() +v429 := lang.Apply(v428, []any{lang.NewSymbol("glojure.core/when-let")}) +v430 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v431 := v430.FindInternedVar(lang.NewSymbol("list")) +if v431.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v431))) +} +v432 := v431.Get() +v433 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v434 := v433.FindInternedVar(lang.NewSymbol("apply")) +if v434.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v434))) +} +v435 := v434.Get() +v436 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v437 := v436.FindInternedVar(lang.NewSymbol("vector")) +if v437.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v437))) +} +v438 := v437.Get() +v439 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v440 := v439.FindInternedVar(lang.NewSymbol("seq")) +if v440.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v440))) +} +v441 := v440.Get() +v442 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v443 := v442.FindInternedVar(lang.NewSymbol("concat")) +if v443.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v443))) +} +v444 := v443.Get() +v445 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v446 := v445.FindInternedVar(lang.NewSymbol("list")) +if v446.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v446))) +} +v447 := v446.Get() +v448 := lang.Apply(v447, []any{v96}) +v449 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v450 := v449.FindInternedVar(lang.NewSymbol("list")) +if v450.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v450))) +} +v451 := v450.Get() +v452 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v453 := v452.FindInternedVar(lang.NewSymbol("seq")) +if v453.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v453))) +} +v454 := v453.Get() +v455 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v456 := v455.FindInternedVar(lang.NewSymbol("concat")) +if v456.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v456))) +} +v457 := v456.Get() +v458 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v459 := v458.FindInternedVar(lang.NewSymbol("list")) +if v459.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v459))) +} +v460 := v459.Get() +v461 := lang.Apply(v460, []any{lang.NewSymbol("glojure.core/seq")}) +v462 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v463 := v462.FindInternedVar(lang.NewSymbol("list")) +if v463.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v463))) +} +v464 := v463.Get() +v465 := lang.Apply(v464, []any{v96}) +v466 := lang.Apply(v457, []any{v461, v465}) +v467 := lang.Apply(v454, []any{v466}) +v468 := lang.Apply(v451, []any{v467}) +v469 := lang.Apply(v444, []any{v448, v468}) +v470 := lang.Apply(v441, []any{v469}) +v471 := lang.Apply(v435, []any{v438, v470}) +v472 := lang.Apply(v432, []any{v471}) +v473 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v474 := v473.FindInternedVar(lang.NewSymbol("list")) +if v474.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v474))) +} +v475 := v474.Get() +v476 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v477 := v476.FindInternedVar(lang.NewSymbol("seq")) +if v477.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v477))) +} +v478 := v477.Get() +v479 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v480 := v479.FindInternedVar(lang.NewSymbol("concat")) +if v480.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v480))) +} +v481 := v480.Get() +v482 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v483 := v482.FindInternedVar(lang.NewSymbol("list")) +if v483.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v483))) +} +v484 := v483.Get() +v485 := lang.Apply(v484, []any{lang.NewSymbol("if")}) +v486 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v487 := v486.FindInternedVar(lang.NewSymbol("list")) +if v487.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v487))) +} +v488 := v487.Get() +v489 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v490 := v489.FindInternedVar(lang.NewSymbol("seq")) +if v490.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v490))) +} +v491 := v490.Get() +v492 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v493 := v492.FindInternedVar(lang.NewSymbol("concat")) +if v493.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v493))) +} +v494 := v493.Get() +v495 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v496 := v495.FindInternedVar(lang.NewSymbol("list")) +if v496.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v496))) +} +v497 := v496.Get() +v498 := lang.Apply(v497, []any{lang.NewSymbol("glojure.core/chunked-seq?")}) +v499 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v500 := v499.FindInternedVar(lang.NewSymbol("list")) +if v500.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v500))) +} +v501 := v500.Get() +v502 := lang.Apply(v501, []any{v96}) +v503 := lang.Apply(v494, []any{v498, v502}) +v504 := lang.Apply(v491, []any{v503}) +v505 := lang.Apply(v488, []any{v504}) +v506 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v507 := v506.FindInternedVar(lang.NewSymbol("list")) +if v507.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v507))) +} +v508 := v507.Get() +v509 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v510 := v509.FindInternedVar(lang.NewSymbol("seq")) +if v510.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v510))) +} +v511 := v510.Get() +v512 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v513 := v512.FindInternedVar(lang.NewSymbol("concat")) +if v513.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v513))) +} +v514 := v513.Get() +v515 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v516 := v515.FindInternedVar(lang.NewSymbol("list")) +if v516.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v516))) +} +v517 := v516.Get() +v518 := lang.Apply(v517, []any{lang.NewSymbol("glojure.core/let")}) +v519 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v520 := v519.FindInternedVar(lang.NewSymbol("list")) +if v520.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v520))) +} +v521 := v520.Get() +v522 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v523 := v522.FindInternedVar(lang.NewSymbol("apply")) +if v523.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v523))) +} +v524 := v523.Get() +v525 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v526 := v525.FindInternedVar(lang.NewSymbol("vector")) +if v526.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v526))) +} +v527 := v526.Get() +v528 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v529 := v528.FindInternedVar(lang.NewSymbol("seq")) +if v529.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v529))) +} +v530 := v529.Get() +v531 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v532 := v531.FindInternedVar(lang.NewSymbol("concat")) +if v532.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v532))) +} +v533 := v532.Get() +v534 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v535 := v534.FindInternedVar(lang.NewSymbol("list")) +if v535.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v535))) +} +v536 := v535.Get() +v537 := lang.Apply(v536, []any{lang.NewSymbol("c__0__auto__")}) +v538 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v539 := v538.FindInternedVar(lang.NewSymbol("list")) +if v539.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v539))) +} +v540 := v539.Get() +v541 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v542 := v541.FindInternedVar(lang.NewSymbol("seq")) +if v542.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v542))) +} +v543 := v542.Get() +v544 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v545 := v544.FindInternedVar(lang.NewSymbol("concat")) +if v545.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v545))) +} +v546 := v545.Get() +v547 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v548 := v547.FindInternedVar(lang.NewSymbol("list")) +if v548.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v548))) +} +v549 := v548.Get() +v550 := lang.Apply(v549, []any{lang.NewSymbol("glojure.core/chunk-first")}) +v551 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v552 := v551.FindInternedVar(lang.NewSymbol("list")) +if v552.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v552))) +} +v553 := v552.Get() +v554 := lang.Apply(v553, []any{v96}) +v555 := lang.Apply(v546, []any{v550, v554}) +v556 := lang.Apply(v543, []any{v555}) +v557 := lang.Apply(v540, []any{v556}) +v558 := lang.Apply(v533, []any{v537, v557}) +v559 := lang.Apply(v530, []any{v558}) +v560 := lang.Apply(v524, []any{v527, v559}) +v561 := lang.Apply(v521, []any{v560}) +v562 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v563 := v562.FindInternedVar(lang.NewSymbol("list")) +if v563.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v563))) +} +v564 := v563.Get() +v565 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v566 := v565.FindInternedVar(lang.NewSymbol("seq")) +if v566.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v566))) +} +v567 := v566.Get() +v568 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v569 := v568.FindInternedVar(lang.NewSymbol("concat")) +if v569.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v569))) +} +v570 := v569.Get() +v571 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v572 := v571.FindInternedVar(lang.NewSymbol("list")) +if v572.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v572))) +} +v573 := v572.Get() +v574 := lang.Apply(v573, []any{lang.NewSymbol("recur")}) +v575 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v576 := v575.FindInternedVar(lang.NewSymbol("list")) +if v576.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v576))) +} +v577 := v576.Get() +v578 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v579 := v578.FindInternedVar(lang.NewSymbol("seq")) +if v579.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v579))) +} +v580 := v579.Get() +v581 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v582 := v581.FindInternedVar(lang.NewSymbol("concat")) +if v582.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v582))) +} +v583 := v582.Get() +v584 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v585 := v584.FindInternedVar(lang.NewSymbol("list")) +if v585.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v585))) +} +v586 := v585.Get() +v587 := lang.Apply(v586, []any{lang.NewSymbol("glojure.core/chunk-rest")}) +v588 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v589 := v588.FindInternedVar(lang.NewSymbol("list")) +if v589.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v589))) +} +v590 := v589.Get() +v591 := lang.Apply(v590, []any{v96}) +v592 := lang.Apply(v583, []any{v587, v591}) +v593 := lang.Apply(v580, []any{v592}) +v594 := lang.Apply(v577, []any{v593}) +v595 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v596 := v595.FindInternedVar(lang.NewSymbol("list")) +if v596.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v596))) +} +v597 := v596.Get() +v598 := lang.Apply(v597, []any{lang.NewSymbol("c__0__auto__")}) +v599 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v600 := v599.FindInternedVar(lang.NewSymbol("list")) +if v600.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v600))) +} +v601 := v600.Get() +v602 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v603 := v602.FindInternedVar(lang.NewSymbol("seq")) +if v603.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v603))) +} +v604 := v603.Get() +v605 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v606 := v605.FindInternedVar(lang.NewSymbol("concat")) +if v606.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v606))) +} +v607 := v606.Get() +v608 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v609 := v608.FindInternedVar(lang.NewSymbol("list")) +if v609.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v609))) +} +v610 := v609.Get() +v611 := lang.Apply(v610, []any{lang.NewSymbol("glojure.core/int")}) +v612 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v613 := v612.FindInternedVar(lang.NewSymbol("list")) +if v613.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v613))) +} +v614 := v613.Get() +v615 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v616 := v615.FindInternedVar(lang.NewSymbol("seq")) +if v616.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v616))) +} +v617 := v616.Get() +v618 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v619 := v618.FindInternedVar(lang.NewSymbol("concat")) +if v619.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v619))) +} +v620 := v619.Get() +v621 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v622 := v621.FindInternedVar(lang.NewSymbol("list")) +if v622.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v622))) +} +v623 := v622.Get() +v624 := lang.Apply(v623, []any{lang.NewSymbol("glojure.core/count")}) +v625 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v626 := v625.FindInternedVar(lang.NewSymbol("list")) +if v626.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v626))) +} +v627 := v626.Get() +v628 := lang.Apply(v627, []any{lang.NewSymbol("c__0__auto__")}) +v629 := lang.Apply(v620, []any{v624, v628}) +v630 := lang.Apply(v617, []any{v629}) +v631 := lang.Apply(v614, []any{v630}) +v632 := lang.Apply(v607, []any{v611, v631}) +v633 := lang.Apply(v604, []any{v632}) +v634 := lang.Apply(v601, []any{v633}) +v635 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v636 := v635.FindInternedVar(lang.NewSymbol("list")) +if v636.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v636))) +} +v637 := v636.Get() +v638 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v639 := v638.FindInternedVar(lang.NewSymbol("seq")) +if v639.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v639))) +} +v640 := v639.Get() +v641 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v642 := v641.FindInternedVar(lang.NewSymbol("concat")) +if v642.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v642))) +} +v643 := v642.Get() +v644 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v645 := v644.FindInternedVar(lang.NewSymbol("list")) +if v645.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v645))) +} +v646 := v645.Get() +v647 := lang.Apply(v646, []any{lang.NewSymbol("glojure.core/int")}) +v648 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v649 := v648.FindInternedVar(lang.NewSymbol("list")) +if v649.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v649))) +} +v650 := v649.Get() +v651 := lang.Apply(v650, []any{int64(0)}) +v652 := lang.Apply(v643, []any{v647, v651}) +v653 := lang.Apply(v640, []any{v652}) +v654 := lang.Apply(v637, []any{v653}) +v655 := lang.Apply(v570, []any{v574, v594, v598, v634, v654}) +v656 := lang.Apply(v567, []any{v655}) +v657 := lang.Apply(v564, []any{v656}) +v658 := lang.Apply(v514, []any{v518, v561, v657}) +v659 := lang.Apply(v511, []any{v658}) +v660 := lang.Apply(v508, []any{v659}) +v661 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v662 := v661.FindInternedVar(lang.NewSymbol("list")) +if v662.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v662))) +} +v663 := v662.Get() +v664 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v665 := v664.FindInternedVar(lang.NewSymbol("seq")) +if v665.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v665))) +} +v666 := v665.Get() +v667 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v668 := v667.FindInternedVar(lang.NewSymbol("concat")) +if v668.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v668))) +} +v669 := v668.Get() +v670 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v671 := v670.FindInternedVar(lang.NewSymbol("list")) +if v671.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v671))) +} +v672 := v671.Get() +v673 := lang.Apply(v672, []any{lang.NewSymbol("glojure.core/let")}) +v674 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v675 := v674.FindInternedVar(lang.NewSymbol("list")) +if v675.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v675))) +} +v676 := v675.Get() +v677 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v678 := v677.FindInternedVar(lang.NewSymbol("apply")) +if v678.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v678))) +} +v679 := v678.Get() +v680 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v681 := v680.FindInternedVar(lang.NewSymbol("vector")) +if v681.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v681))) +} +v682 := v681.Get() +v683 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v684 := v683.FindInternedVar(lang.NewSymbol("seq")) +if v684.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v684))) +} +v685 := v684.Get() +v686 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v687 := v686.FindInternedVar(lang.NewSymbol("concat")) +if v687.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v687))) +} +v688 := v687.Get() +v689 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v690 := v689.FindInternedVar(lang.NewSymbol("list")) +if v690.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v690))) +} +v691 := v690.Get() +v692 := lang.Apply(v691, []any{v80}) +v693 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v694 := v693.FindInternedVar(lang.NewSymbol("list")) +if v694.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v694))) +} +v695 := v694.Get() +v696 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v697 := v696.FindInternedVar(lang.NewSymbol("seq")) +if v697.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v697))) +} +v698 := v697.Get() +v699 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v700 := v699.FindInternedVar(lang.NewSymbol("concat")) +if v700.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v700))) +} +v701 := v700.Get() +v702 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v703 := v702.FindInternedVar(lang.NewSymbol("list")) +if v703.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v703))) +} +v704 := v703.Get() +v705 := lang.Apply(v704, []any{lang.NewSymbol("glojure.core/first")}) +v706 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v707 := v706.FindInternedVar(lang.NewSymbol("list")) +if v707.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v707))) +} +v708 := v707.Get() +v709 := lang.Apply(v708, []any{v96}) +v710 := lang.Apply(v701, []any{v705, v709}) +v711 := lang.Apply(v698, []any{v710}) +v712 := lang.Apply(v695, []any{v711}) +v713 := lang.Apply(v688, []any{v692, v712}) +v714 := lang.Apply(v685, []any{v713}) +v715 := lang.Apply(v679, []any{v682, v714}) +v716 := lang.Apply(v676, []any{v715}) +v717 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v718 := v717.FindInternedVar(lang.NewSymbol("list")) +if v718.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v718))) +} +v719 := v718.Get() +v720 := lang.Apply(v719, []any{v176}) +var v721 any +if lang.IsTruthy(v174) { +v722 := lang.NewVector(v123) +v723 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3264), lang.NewKeyword("column"), int(52), lang.NewKeyword("end-line"), int(3264), lang.NewKeyword("end-column"), int(60)) +v724, err := lang.WithMeta(v722, v723.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v721 = v724 +} else { +v721 = nil +} +v725 := lang.Apply(v669, []any{v673, v716, v720, v721}) +v726 := lang.Apply(v666, []any{v725}) +v727 := lang.Apply(v663, []any{v726}) +v728 := lang.Apply(v481, []any{v485, v505, v660, v727}) +v729 := lang.Apply(v478, []any{v728}) +v730 := lang.Apply(v475, []any{v729}) +v731 := lang.Apply(v425, []any{v429, v472, v730}) +v732 := lang.Apply(v422, []any{v731}) +v733 := lang.Apply(v419, []any{v732}) +v734 := lang.Apply(v317, []any{v321, v345, v416, v733}) +v735 := lang.Apply(v314, []any{v734}) +v736 := lang.Apply(v311, []any{v735}) +v737 := lang.Apply(v237, []any{v241, v308, v736}) +v738 := lang.Apply(v234, []any{v737}) +v739 := lang.NewVector(true, v738) +v740 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3250), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(3264), lang.NewKeyword("end-column"), int(67)) +v741, err := lang.WithMeta(v739, v740.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v91 = v741 +} +v60 = v91 +} +return v60 +}) +v57 := v56 +_ = v57 +} +v57 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3218), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(3264), lang.NewKeyword("end-column"), int(72)) +v58, err := lang.WithMeta(v56, v57.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v55 any = v58 +_ = v55 +v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v61 := v60.FindInternedVar(lang.NewSymbol("nth")) +if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) +} +v62 := v61.Get() +v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v64 := v63.FindInternedVar(lang.NewSymbol("seq")) +if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) +} +v65 := v64.Get() +v66 := lang.Apply(v65, []any{v5}) +v67 := lang.Apply(v55, []any{nil, v66}) +v68 := lang.Apply(v62, []any{v67, int64(1)}) +return v68 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// abs +{ +var v1 lang.FnFunc +{ // function abs__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Abs")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v3}) +v18 := lang.Apply(v9, []any{v13, v17}) +v19 := lang.Apply(v6, []any{v18}) +return v19 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("abs").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the absolute value of a.\n If a is Long/MIN_VALUE => Long/MIN_VALUE\n If a is a double and zero => +0.0\n If a is a double and ##Inf or ##-Inf => ##Inf\n If a is a double and ##NaN => ##NaN", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)), lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1128), lang.NewKeyword("end-line"), int(1128))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := lang.Apply(lang1.Abs, []any{v4}) +return v5 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// aclone +{ +var v1 lang.FnFunc +{ // function aclone__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/Aclone")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v3}) +v35 := lang.Apply(v26, []any{v30, v34}) +v36 := lang.Apply(v23, []any{v35}) +v37 := lang.Apply(v20, []any{v36}) +v38 := lang.Apply(v9, []any{v13, v17, v37}) +v39 := lang.Apply(v6, []any{v38}) +return v39 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("aclone").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns a clone of the Java array. Works on arrays of known\n types.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3904), lang.NewKeyword("end-line"), int(3904))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5, _ := lang.FieldOrMethod(runtime3.RT, "Aclone") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Aclone is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// serialized-require +{ +v0 := lang.NewSymbol("serialized-require").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Like 'require', but serializes loading.\n Interim function preferred over 'require' for known asynchronous loads.\n Future changes may make these equivalent.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6102), lang.NewKeyword("end-line"), int(6102), lang.NewKeyword("private"), true)).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.NewList(args[0:]...) +var v4 any = nil +_ = v4 +var v6 any +func() { +var v7 any = v4 +_ = v7 +v9 := lang.Apply(nil, []any{v7}) +_ = v9 +var v10 any +func() { +defer func() { +v11 := lang.Apply(nil, []any{v7}) +}() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("apply")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("require")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v14, []any{v17, v3}) +v10 = v18 +}() +v6 = v10 +}() +return v6 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// ns-publics +{ +v0 := lang.NewSymbol("ns-publics").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of the public intern mappings for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4188), lang.NewKeyword("end-line"), int(4188))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("the-ns")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v4}) +var v4 any = v8 +_ = v4 +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("filter-key")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("val")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +var v16 lang.FnFunc +v16 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v17 := args[0] +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("instance?")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{lang1.*Var, v17}) +var v18 any = v22 +_ = v18 +var v24 any +if lang.IsTruthy(v18) { +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("=")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29, ok := lang.FieldOrMethod(v17, "Namespace") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v17, "Namespace"))) +} +var v30 any +switch reflect.TypeOf(v29).Kind() { +case reflect.Func: + v30 = lang.Apply(v29, nil) +default: + v30 = v29 +} +v31 := lang.Apply(v28, []any{v4, v30}) +var v25 any = v31 +_ = v25 +var v33 any +if lang.IsTruthy(v25) { +v34, ok := lang.FieldOrMethod(v17, "IsPublic") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v17, "IsPublic"))) +} +var v35 any +switch reflect.TypeOf(v34).Kind() { +case reflect.Func: + v35 = lang.Apply(v34, nil) +default: + v35 = v34 +} +v33 = v35 +} else { +v33 = v25 +} +v24 = v33 +} else { +v24 = v18 +} +return v24 +}) +v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4194), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(4196), lang.NewKeyword("end-column"), int(48)) +v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("ns-map")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v4}) +v23 := lang.Apply(v12, []any{v15, v18, v22}) +return v23 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// alias +{ +v0 := lang.NewSymbol("alias").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("alias"), lang.NewSymbol("namespace-sym"))), lang.NewKeyword("doc"), "Add an alias in the current namespace to another\n namespace. Arguments are two symbols: the alias to be used, and\n the symbolic name of the target namespace. Use :as in the ns macro in preference\n to calling this directly.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4263), lang.NewKeyword("end-line"), int(4263))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("*ns*")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("the-ns")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v4}) +v12, _ := lang.FieldOrMethod(v7, "AddAlias") +if reflect.TypeOf(v12).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("AddAlias is not a function"))) +} +v13 := lang.Apply(v12, []any{v3, v11}) +return v13 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// set-agent-send-executor! +{ +v0 := lang.NewSymbol("set-agent-send-executor!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("executor"))), lang.NewKeyword("doc"), "Sets the ExecutorService to be used by send", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(30), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2087), lang.NewKeyword("end-line"), int(2087))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +return nil +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// get +{ +var v1 lang.FnFunc +{ // function get__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("seq")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("concat")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("list")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{lang.NewSymbol(".")}) +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("list")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("list")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("seq")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("concat")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("list")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.Apply(v31, []any{lang.NewSymbol("glojure.core/Get")}) +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("list")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v3}) +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("list")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v4}) +v41 := lang.Apply(v28, []any{v32, v36, v40, v5}) +v42 := lang.Apply(v25, []any{v41}) +v43 := lang.Apply(v22, []any{v42}) +v44 := lang.Apply(v11, []any{v15, v19, v43}) +v45 := lang.Apply(v8, []any{v44}) +return v45 + } +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("get").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"), lang.NewSymbol("not-found"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the value mapped to key, not-found or nil if key not present\n in associative collection, set, string, array, or ILookup instance.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)int64(3)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1489), lang.NewKeyword("end-line"), int(1489))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v4 := args[0] +v5 := args[1] +v6 := lang.Apply(lang1.Get, []any{v4, v5}) +return v6 + case 3: +v4 := args[0] +v5 := args[1] +v6 := args[2] +v7 := lang.Apply(lang1.GetDefault, []any{v4, v5, v6}) +return v7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// mk-bound-fn +{ +v0 := lang.NewSymbol("mk-bound-fn").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5127), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(5127), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sc"), lang.NewSymbol("test"), lang.NewSymbol("key"))), lang.NewKeyword("private"), true, lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +var v6 lang.FnFunc +v6 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v7 := args[0] +v8, ok := lang.FieldOrMethod(v3, "comparator") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "comparator"))) +} +var v9 any +switch reflect.TypeOf(v8).Kind() { +case reflect.Func: + v9 = lang.Apply(v8, nil) +default: + v9 = v8 +} +v10, _ := lang.FieldOrMethod(v3, "entryKey") +if reflect.TypeOf(v10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("entryKey is not a function"))) +} +v11 := lang.Apply(v10, []any{v7}) +v12, _ := lang.FieldOrMethod(v9, "compare") +if reflect.TypeOf(v12).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("compare is not a function"))) +} +v13 := lang.Apply(v12, []any{v11, v5}) +v14 := lang.Apply(v4, []any{v13, int64(0)}) +return v14 +}) +v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5130), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(5131), lang.NewKeyword("end-column"), int(64)) +v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v8 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// second +{ +v0 := lang.NewSymbol("second").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Same as (first (next x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(91), lang.NewKeyword("end-line"), int(95))).(*lang.Symbol) +var v2 lang.FnFunc +{ // function second +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("first")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("next")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v4}) +v12 := lang.Apply(v7, []any{v11}) +return v12 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(95), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(95), lang.NewKeyword("end-column"), int(49))).(lang.FnFunc) +v3 := v2 +_ = v3 +} +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// delay? +{ +v0 := lang.NewSymbol("delay?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "returns true if x is a Delay created with delay", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(748), lang.NewKeyword("end-line"), int(748))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{glojure.lang11.Delay, v3}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// *2 +{ +v0 := lang.NewSymbol("*2").WithMeta(lang.NewMap()).(*lang.Symbol) +v1 := ns.Intern(v0) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// *warn-on-reflection* +{ +v0 := lang.NewSymbol("*warn-on-reflection*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "When set to true, the compiler will emit warnings when reflection is\n needed to resolve Java method calls or field accesses.\n\n Defaults to false.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, nil, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// boolean-array +{ +var v1 lang.FnFunc +{ // function boolean-array__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.NewList(args[0:]...) +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/booleanArray")}) +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("list")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("seq")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("concat")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("list")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v37, []any{lang.NewSymbol("glojure.core/args")}) +v39 := lang.Apply(v30, []any{v34, v38}) +v40 := lang.Apply(v27, []any{v39}) +v41 := lang.Apply(v24, []any{v40}) +v42 := lang.Apply(v9, []any{v13, v17, v21, v41}) +v43 := lang.Apply(v6, []any{v42}) +return v43 + } +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("boolean-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Creates an array of booleans", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)int64(2)), lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5309), lang.NewKeyword("end-line"), int(5309))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "booleanArray") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("booleanArray is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 + case 2: +v4 := args[0] +v5 := args[1] +v6, _ := lang.FieldOrMethod(lang1.Numbers, "booleanArrayInit") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("booleanArrayInit is not a function"))) +} +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// list +{ +v0 := lang.NewSymbol("list").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("items"))), lang.NewKeyword("doc"), "Creates a new list containing the items.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(15), lang.NewKeyword("end-line"), int(18))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, nil, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// -' +{ +var v1 lang.FnFunc +v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v2 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +if lang.IsTruthy(v7) { +v4 = closed8 +} else { +v4 = v3 +} +var v3 any = v4 +_ = v3 +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("seq")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("concat")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("seq")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("concat")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v2}) +v40 := lang.Apply(v31, []any{v35, v39}) +v41 := lang.Apply(v28, []any{v40}) +v42 := lang.Apply(v25, []any{v41}) +v43 := lang.Apply(v14, []any{v18, v22, v42}) +v44 := lang.Apply(v11, []any{v43}) +return v44 + case 2: +v2 := args[0] +v3 := args[1] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +if lang.IsTruthy(v8) { +v5 = closed8 +} else { +v5 = v4 +} +var v4 any = v5 +_ = v4 +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("seq")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("concat")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("list")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("list")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("list")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("seq")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("concat")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("list")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v4}) +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("list")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v2}) +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("list")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v3}) +v45 := lang.Apply(v32, []any{v36, v40, v44}) +v46 := lang.Apply(v29, []any{v45}) +v47 := lang.Apply(v26, []any{v46}) +v48 := lang.Apply(v15, []any{v19, v23, v47}) +v49 := lang.Apply(v12, []any{v48}) +return v49 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v2 := args[0] +v3 := args[1] +v4 := lang.NewList(args[2:]...) +var v6 any +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +if lang.IsTruthy(v9) { +v6 = closed8 +} else { +v6 = v5 +} +var v5 any = v6 +_ = v5 +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +var v14 lang.FnFunc +v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v15 := args[0] +v16 := args[1] +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v5}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v15}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v16}) +v52 := lang.Apply(v39, []any{v43, v47, v51}) +v53 := lang.Apply(v36, []any{v52}) +v54 := lang.Apply(v33, []any{v53}) +v55 := lang.Apply(v22, []any{v26, v30, v54}) +v56 := lang.Apply(v19, []any{v55}) +return v56 +}) +v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) +v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v5}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v2}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v3}) +v52 := lang.Apply(v39, []any{v43, v47, v51}) +v53 := lang.Apply(v36, []any{v52}) +v54 := lang.Apply(v33, []any{v53}) +v55 := lang.Apply(v22, []any{v26, v30, v54}) +v56 := lang.Apply(v19, []any{v55}) +v57 := lang.Apply(v13, []any{v16, v56, v4}) +return v57 + } +}) +v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) +} +v5 := lang.Apply(v4, []any{v3, int64(0)}) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v0 := lang.NewSymbol("-'").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "If no ys are supplied, returns the negation of x, else subtracts\n the ys from x and returns the result. Supports arbitrary precision.\n See also: -", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1024), lang.NewKeyword("end-line"), int(1024))).(*lang.Symbol) +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v5 := args[0] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("*'")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{int64(-1), v5}) +return v9 + case 2: +v5 := args[0] +v6 := args[1] +v7, _ := lang.FieldOrMethod(lang1.Numbers, "minusP") +if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("minusP is not a function"))) +} +v8 := lang.Apply(v7, []any{v5, v6}) +return v8 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +v6 := args[1] +v7 := lang.NewList(args[2:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("-'")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("-'")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v5, v6}) +v18 := lang.Apply(v10, []any{v13, v17, v7}) +return v18 + } +}) +v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v3 := ns.InternWithValue(v0, v4, true) +if v0.Meta() != nil { + v3.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// replace +{ +v0 := lang.NewSymbol("replace").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("smap")), lang.NewVector(lang.NewSymbol("smap"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Given a map of replacement pairs and a vector/collection, returns a\n vector/seq with any elements = a key in smap replaced with the\n corresponding val in smap. Returns a transducer when no collection\n is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5082), lang.NewKeyword("end-line"), int(5082))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("map")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +var v7 lang.FnFunc +v7 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v8 := args[0] +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("find")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{v3, v8}) +var v9 any = v13 +_ = v9 +var v15 any +if lang.IsTruthy(v9) { +var v16 any = v9 +_ = v16 +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("val")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, []any{v16}) +v15 = v21 +} else { +v15 = v8 +} +return v15 +}) +v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5090), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5090), lang.NewKeyword("end-column"), int(47)) +v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v10 := lang.Apply(v6, []any{v9}) +return v10 + case 2: +v3 := args[0] +v4 := args[1] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("vector?")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v4}) +if lang.IsTruthy(v9) { +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("reduce1")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +var v13 lang.FnFunc +v13 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v14 := args[0] +v15 := args[1] +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("find")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("nth")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.Apply(v22, []any{v14, v15}) +v24 := lang.Apply(v19, []any{v3, v23}) +var v16 any = v24 +_ = v16 +var v26 any +if lang.IsTruthy(v16) { +var v27 any = v16 +_ = v27 +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("assoc")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("val")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v27}) +v36 := lang.Apply(v31, []any{v14, v15, v35}) +v26 = v36 +} else { +v26 = v14 +} +return v26 +}) +v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5093), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(5096), lang.NewKeyword("end-column"), int(23)) +v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("range")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("count")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v4}) +v23 := lang.Apply(v18, []any{v22}) +v24 := lang.Apply(v12, []any{v15, v4, v23}) +v5 = v24 +} else { +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("map")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +var v28 lang.FnFunc +v28 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v29 := args[0] +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("find")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v3, v29}) +var v30 any = v34 +_ = v30 +var v36 any +if lang.IsTruthy(v30) { +var v37 any = v30 +_ = v37 +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("val")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +} +v41 := v40.Get() +v42 := lang.Apply(v41, []any{v37}) +v36 = v42 +} else { +v36 = v29 +} +return v36 +}) +v29 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5098), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(5098), lang.NewKeyword("end-column"), int(49)) +v30, err := lang.WithMeta(v28, v29.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v31 := lang.Apply(v27, []any{v30, v4}) +v5 = v31 +} +return v5 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// deref-future +{ +v0 := lang.NewSymbol("deref-future").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2296), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(2296), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fut")), lang.NewVector(lang.NewSymbol("fut"), lang.NewSymbol("timeout-ms"), lang.NewSymbol("timeout-val"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +v4, ok := lang.FieldOrMethod(v3, "Get") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "Get"))) +} +var v5 any +switch reflect.TypeOf(v4).Kind() { +case reflect.Func: + v5 = lang.Apply(v4, nil) +default: + v5 = v4 +} +return v5 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +var v6 any +func() { +defer func() { +if r := recover(); r != nil { +if lang.CatchMatches(r, lang1.TimeoutError) { +v7 := r +_ = v7 +v6 = v5 +} else { +panic(r) +} +} +}() +v7, _ := lang.FieldOrMethod(v3, "Get") +if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Get is not a function"))) +} +v8 := lang.Apply(v7, []any{v4, time30.Millisecond}) +v6 = v8 +}() +return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// *agent* +{ +v0 := lang.NewSymbol("*agent*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, nil, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// object-array +{ +var v1 lang.FnFunc +{ // function object-array__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/Object_array")}) +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("list")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v3}) +v26 := lang.Apply(v9, []any{v13, v17, v21, v25}) +v27 := lang.Apply(v6, []any{v26}) +return v27 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("object-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Creates an array of objects", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)), lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5349), lang.NewKeyword("end-line"), int(5349))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5, _ := lang.FieldOrMethod(runtime3.RT, "Object_array") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Object_array is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// find-var +{ +v0 := lang.NewSymbol("find-var").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Returns the global var named by the namespace-qualified symbol, or\n nil if no var with that name.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2013), lang.NewKeyword("end-line"), int(2013))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, _ := lang.FieldOrMethod(runtime3.RT, "FindVar") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("FindVar is not a function"))) +} +v5 := lang.Apply(v4, []any{v3}) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// bit-and +{ +var v1 lang.FnFunc +v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v2 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +if lang.IsTruthy(v7) { +v4 = closed9 +} else { +v4 = v3 +} +var v3 any = v4 +_ = v3 +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("seq")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("concat")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("seq")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("concat")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v2}) +v40 := lang.Apply(v31, []any{v35, v39}) +v41 := lang.Apply(v28, []any{v40}) +v42 := lang.Apply(v25, []any{v41}) +v43 := lang.Apply(v14, []any{v18, v22, v42}) +v44 := lang.Apply(v11, []any{v43}) +return v44 + case 2: +v2 := args[0] +v3 := args[1] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +if lang.IsTruthy(v8) { +v5 = closed9 +} else { +v5 = v4 +} +var v4 any = v5 +_ = v4 +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("seq")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("concat")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("list")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("list")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("list")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("seq")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("concat")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("list")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v4}) +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("list")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v2}) +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("list")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v3}) +v45 := lang.Apply(v32, []any{v36, v40, v44}) +v46 := lang.Apply(v29, []any{v45}) +v47 := lang.Apply(v26, []any{v46}) +v48 := lang.Apply(v15, []any{v19, v23, v47}) +v49 := lang.Apply(v12, []any{v48}) +return v49 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v2 := args[0] +v3 := args[1] +v4 := lang.NewList(args[2:]...) +var v6 any +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +if lang.IsTruthy(v9) { +v6 = closed9 +} else { +v6 = v5 +} +var v5 any = v6 +_ = v5 +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +var v14 lang.FnFunc +v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v15 := args[0] +v16 := args[1] +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v5}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v15}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v16}) +v52 := lang.Apply(v39, []any{v43, v47, v51}) +v53 := lang.Apply(v36, []any{v52}) +v54 := lang.Apply(v33, []any{v53}) +v55 := lang.Apply(v22, []any{v26, v30, v54}) +v56 := lang.Apply(v19, []any{v55}) +return v56 +}) +v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) +v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v5}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v2}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v3}) +v52 := lang.Apply(v39, []any{v43, v47, v51}) +v53 := lang.Apply(v36, []any{v52}) +v54 := lang.Apply(v33, []any{v53}) +v55 := lang.Apply(v22, []any{v26, v30, v54}) +v56 := lang.Apply(v19, []any{v55}) +v57 := lang.Apply(v13, []any{v16, v56, v4}) +return v57 + } +}) +v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) +} +v5 := lang.Apply(v4, []any{v3, int64(1)}) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v0 := lang.NewSymbol("bit-and").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Bitwise and", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1298), lang.NewKeyword("end-line"), int(1298))).(*lang.Symbol) +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v5 := args[0] +v6 := args[1] +v7, _ := lang.FieldOrMethod(lang1.Numbers, "and") +if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("and is not a function"))) +} +v8 := lang.Apply(v7, []any{v5, v6}) +return v8 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +v6 := args[1] +v7 := lang.NewList(args[2:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("bit-and")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("bit-and")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v5, v6}) +v18 := lang.Apply(v10, []any{v13, v17, v7}) +return v18 + } +}) +v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v3 := ns.InternWithValue(v0, v4, true) +if v0.Meta() != nil { + v3.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// ident? +{ +v0 := lang.NewSymbol("ident?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a symbol or keyword", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1608), lang.NewKeyword("end-line"), int(1608))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("keyword?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +var v4 any = v8 +_ = v4 +var v10 any +if lang.IsTruthy(v4) { +v10 = v4 +} else { +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("symbol?")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v3}) +v10 = v14 +} +return v10 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// any? +{ +v1 := reflect.TypeOf(false) +v0 := lang.NewSymbol("any?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true given any argument.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(537), lang.NewKeyword("end-line"), int(537))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +return true +}) +v4 := reflect.TypeOf(false) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// merge-with +{ +v0 := lang.NewSymbol("merge-with").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("maps"))), lang.NewKeyword("doc"), "Returns a map that consists of the rest of the maps conj-ed onto\n the first. If a key occurs in more than one map, the mapping(s)\n from the latter (left-to-right) will be combined with the mapping in\n the result by calling (f val-in-result val-in-latter).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3050), lang.NewKeyword("end-line"), int(3050))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.NewList(args[1:]...) +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("some")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("identity")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v8, []any{v11, v4}) +if lang.IsTruthy(v12) { +var v14 lang.FnFunc +v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v15 := args[0] +v16 := args[1] +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("key")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, []any{v16}) +var v17 any = v21 +_ = v17 +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("val")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{v16}) +var v22 any = v26 +_ = v22 +var v28 any +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("contains?")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.Apply(v31, []any{v15, v17}) +if lang.IsTruthy(v32) { +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("assoc")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("get")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v15, v17}) +v40 := lang.Apply(v3, []any{v39, v22}) +v41 := lang.Apply(v35, []any{v15, v17, v40}) +v28 = v41 +} else { +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("assoc")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +} +v44 := v43.Get() +v45 := lang.Apply(v44, []any{v15, v17, v22}) +v28 = v45 +} +return v28 +}) +v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3059), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(3063), lang.NewKeyword("end-column"), int(23)) +v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v13 any = v16 +_ = v13 +var v18 lang.FnFunc +v18 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v19 := args[0] +v20 := args[1] +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("reduce1")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +var v24 any = v19 +_ = v24 +var v26 any +if lang.IsTruthy(v24) { +v26 = v24 +} else { +v27 := lang.NewMap() +v28 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3065), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(3065), lang.NewKeyword("end-column"), int(35)) +v29, err := lang.WithMeta(v27, v28.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v26 = v29 +} +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("seq")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v20}) +v28 := lang.Apply(v23, []any{v13, v26, v27}) +return v28 +}) +v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3064), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(3065), lang.NewKeyword("end-column"), int(47)) +v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v17 any = v20 +_ = v17 +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("reduce1")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v17, v4}) +v5 = v25 +} else { +v5 = nil +} +return v5 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// if-not +{ +v0 := lang.NewSymbol("if-not").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("test"), lang.NewSymbol("then")), lang.NewVector(lang.NewSymbol("test"), lang.NewSymbol("then"), lang.NewSymbol("else"))), lang.NewKeyword("doc"), "Evaluates test. If logical false, evaluates and returns then expr, \n otherwise else expr, if supplied, else nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(760), lang.NewKeyword("end-line"), int(760))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 4: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("seq")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("concat")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("list")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/if-not")}) +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("list")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v5}) +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("list")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v6}) +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("list")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.Apply(v27, []any{nil}) +v29 := lang.Apply(v12, []any{v16, v20, v24, v28}) +v30 := lang.Apply(v9, []any{v29}) +return v30 + case 5: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := args[4] +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("seq")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("concat")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("if")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/not")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v5}) +v35 := lang.Apply(v26, []any{v30, v34}) +v36 := lang.Apply(v23, []any{v35}) +v37 := lang.Apply(v20, []any{v36}) +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("list")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.Apply(v40, []any{v6}) +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("list")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +} +v44 := v43.Get() +v45 := lang.Apply(v44, []any{v7}) +v46 := lang.Apply(v13, []any{v17, v37, v41, v45}) +v47 := lang.Apply(v10, []any{v46}) +return v47 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// extend-protocol +{ +v0 := lang.NewSymbol("extend-protocol").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("p"), lang.NewSymbol("&"), lang.NewSymbol("specs"))), lang.NewKeyword("doc"), "Useful when you want to provide several implementations of the same\n protocol all at once. Takes a single protocol and the implementation\n of that protocol for one or more types.\n\n (extend-protocol Protocol\n AType\n (foo [x] ...)\n (bar [x y] ...)\n BType\n (foo [x] ...)\n (bar [x y] ...)\n AClass\n (foo [x] ...)\n (bar [x y] ...)\n nil\n (foo [x] ...)\n (bar [x y] ...))\n\n expands into:\n\n (do\n (clojure.core/extend-type AType Protocol \n (foo [x] ...) \n (bar [x y] ...))\n (clojure.core/extend-type BType Protocol \n (foo [x] ...) \n (bar [x y] ...))\n (clojure.core/extend-type AClass Protocol \n (foo [x] ...) \n (bar [x y] ...))\n (clojure.core/extend-type nil Protocol \n (foo [x] ...) \n (bar [x y] ...)))", lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(212), lang.NewKeyword("end-line"), int(212))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("emit-extend-protocol")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v5, v6}) +return v10 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// bit-not +{ +var v1 lang.FnFunc +{ // function bit-not__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/not")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v3}) +v35 := lang.Apply(v26, []any{v30, v34}) +v36 := lang.Apply(v23, []any{v35}) +v37 := lang.Apply(v20, []any{v36}) +v38 := lang.Apply(v9, []any{v13, v17, v37}) +v39 := lang.Apply(v6, []any{v38}) +return v39 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("bit-not").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Bitwise complement", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1291), lang.NewKeyword("end-line"), int(1291))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "not") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("not is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// subs +{ +v0 := lang.NewSymbol("subs").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("start")), lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("start"), lang.NewSymbol("end"))), lang.NewKeyword("doc"), "Returns the substring of s beginning at start inclusive, and ending\n at end (defaults to length of string), exclusive.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5005), lang.NewKeyword("end-line"), int(5005))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v3 := args[0] +v4 := args[1] +v5 := lang.Apply(lang.Builtins["slice"], []any{v3, v4}) +return v5 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.Apply(lang.Builtins["slice"], []any{v3, v4, v5}) +return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// alength +{ +var v1 lang.FnFunc +{ // function alength__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/Alength")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v3}) +v35 := lang.Apply(v26, []any{v30, v34}) +v36 := lang.Apply(v23, []any{v35}) +v37 := lang.Apply(v20, []any{v36}) +v38 := lang.Apply(v9, []any{v13, v17, v37}) +v39 := lang.Apply(v6, []any{v38}) +return v39 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("alength").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the length of the Java array. Works on arrays of all\n types.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3897), lang.NewKeyword("end-line"), int(3897))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5, _ := lang.FieldOrMethod(runtime3.RT, "Alength") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Alength is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// dedupe +{ +v0 := lang.NewSymbol("dedupe").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence removing consecutive duplicates in coll.\n Returns a transducer when no collection is provided.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7724), lang.NewKeyword("end-line"), int(7724))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("volatile!")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{lang.NewKeyword("glojure.core/none")}) +var v5 any = v9 +_ = v5 +var v11 lang.FnFunc +v11 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v12 := lang.Apply(v4, nil) +return v12 + case 1: +v12 := args[0] +v13 := lang.Apply(v4, []any{v12}) +return v13 + case 2: +v12 := args[0] +v13 := args[1] +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("deref")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v5}) +var v14 any = v18 +_ = v14 +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("vreset!")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.Apply(v22, []any{v5, v13}) +_ = v23 +var v24 any +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("=")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.Apply(v27, []any{v14, v13}) +if lang.IsTruthy(v28) { +v24 = v12 +} else { +v29 := lang.Apply(v4, []any{v12, v13}) +v24 = v29 +} +return v24 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7731), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7739), lang.NewKeyword("end-column"), int(37)) +v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v13 +}) +v4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7729), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7739), lang.NewKeyword("end-column"), int(39)) +v5, err := lang.WithMeta(v3, v4.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v5 + case 1: +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("sequence")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("dedupe")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, nil) +v11 := lang.Apply(v6, []any{v10, v3}) +return v11 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// bounded-count +{ +v0 := lang.NewSymbol("bounded-count").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "If coll is counted? returns its count, else will count at most the first n\n elements of coll using its seq", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7453), lang.NewKeyword("end-line"), int(7453))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("counted?")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v4}) +if lang.IsTruthy(v9) { +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("count")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{v4}) +v5 = v13 +} else { +var v14 any = int64(0) +_ = v14 +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("seq")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v4}) +var v15 any = v19 +_ = v15 +var v20 any +for { +var v21 any +var v22 any = v15 +_ = v22 +var v24 any +if lang.IsTruthy(v22) { +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("<")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.Apply(v27, []any{v14, v3}) +v24 = v28 +} else { +v24 = v22 +} +if lang.IsTruthy(v24) { +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("inc")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{v14}) +var v22 any = v26 +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("next")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{v15}) +var v27 any = v31 +v14 = v22 +v15 = v27 +continue +} else { +v21 = v14 +} +v20 = v21 + break +} +v5 = v20 +} +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// neg-int? +{ +v0 := lang.NewSymbol("neg-int?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a negative fixed precision integer", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1409), lang.NewKeyword("end-line"), int(1409))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("int?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +var v4 any = v8 +_ = v4 +var v10 any +if lang.IsTruthy(v4) { +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("neg?")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v3}) +v10 = v14 +} else { +v10 = v4 +} +return v10 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// when-first +{ +v0 := lang.NewSymbol("when-first").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "bindings => x xs\n\n Roughly the same as (when (seq xs) (let [x (first xs)] body)) but xs is evaluated only once", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4622), lang.NewKeyword("end-line"), int(4622))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +var v7 any +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v5}) +if lang.IsTruthy(v11) { +v7 = nil +} else { +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("str")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("first")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v3}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("meta")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v3}) +v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) +v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) +v28 := lang.Apply(lang1.NewIllegalArgumentError, []any{v27}) +panic(v28) +} +_ = v7 +var v29 any +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("=")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("count")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v5}) +v37 := lang.Apply(v32, []any{int64(2), v36}) +if lang.IsTruthy(v37) { +v29 = nil +} else { +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("str")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("first")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v3}) +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +} +v47 := v46.Get() +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("meta")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v3}) +v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) +v53 := lang.Apply(v40, []any{v44, " requires ", "exactly 2 forms in binding vector", " in ", v47, ":", v52}) +v54 := lang.Apply(lang1.NewIllegalArgumentError, []any{v53}) +panic(v54) +} +_ = v29 +_ = nil +var v55 any = v5 +_ = v55 +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("nth")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +} +v59 := v58.Get() +v60 := lang.Apply(v59, []any{v55, int64(0), nil}) +var v56 any = v60 +_ = v56 +v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v63 := v62.FindInternedVar(lang.NewSymbol("nth")) +if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +} +v64 := v63.Get() +v65 := lang.Apply(v64, []any{v55, int64(1), nil}) +var v61 any = v65 +_ = v61 +v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v68 := v67.FindInternedVar(lang.NewSymbol("seq")) +if v68.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) +} +v69 := v68.Get() +v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v71 := v70.FindInternedVar(lang.NewSymbol("concat")) +if v71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) +} +v72 := v71.Get() +v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v74 := v73.FindInternedVar(lang.NewSymbol("list")) +if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) +} +v75 := v74.Get() +v76 := lang.Apply(v75, []any{lang.NewSymbol("glojure.core/when-let")}) +v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v78 := v77.FindInternedVar(lang.NewSymbol("list")) +if v78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) +} +v79 := v78.Get() +v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v81 := v80.FindInternedVar(lang.NewSymbol("apply")) +if v81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) +} +v82 := v81.Get() +v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v84 := v83.FindInternedVar(lang.NewSymbol("vector")) +if v84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) +} +v85 := v84.Get() +v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v87 := v86.FindInternedVar(lang.NewSymbol("seq")) +if v87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) +} +v88 := v87.Get() +v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v90 := v89.FindInternedVar(lang.NewSymbol("concat")) +if v90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) +} +v91 := v90.Get() +v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v93 := v92.FindInternedVar(lang.NewSymbol("list")) +if v93.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) +} +v94 := v93.Get() +v95 := lang.Apply(v94, []any{lang.NewSymbol("xs__0__auto__")}) +v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v97 := v96.FindInternedVar(lang.NewSymbol("list")) +if v97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) +} +v98 := v97.Get() +v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v100 := v99.FindInternedVar(lang.NewSymbol("seq")) +if v100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) +} +v101 := v100.Get() +v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v103 := v102.FindInternedVar(lang.NewSymbol("concat")) +if v103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) +} +v104 := v103.Get() +v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v106 := v105.FindInternedVar(lang.NewSymbol("list")) +if v106.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) +} +v107 := v106.Get() +v108 := lang.Apply(v107, []any{lang.NewSymbol("glojure.core/seq")}) +v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v110 := v109.FindInternedVar(lang.NewSymbol("list")) +if v110.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) +} +v111 := v110.Get() +v112 := lang.Apply(v111, []any{v61}) +v113 := lang.Apply(v104, []any{v108, v112}) +v114 := lang.Apply(v101, []any{v113}) +v115 := lang.Apply(v98, []any{v114}) +v116 := lang.Apply(v91, []any{v95, v115}) +v117 := lang.Apply(v88, []any{v116}) +v118 := lang.Apply(v82, []any{v85, v117}) +v119 := lang.Apply(v79, []any{v118}) +v120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v121 := v120.FindInternedVar(lang.NewSymbol("list")) +if v121.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v121))) +} +v122 := v121.Get() +v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v124 := v123.FindInternedVar(lang.NewSymbol("seq")) +if v124.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) +} +v125 := v124.Get() +v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v127 := v126.FindInternedVar(lang.NewSymbol("concat")) +if v127.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) +} +v128 := v127.Get() +v129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v130 := v129.FindInternedVar(lang.NewSymbol("list")) +if v130.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v130))) +} +v131 := v130.Get() +v132 := lang.Apply(v131, []any{lang.NewSymbol("glojure.core/let")}) +v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v134 := v133.FindInternedVar(lang.NewSymbol("list")) +if v134.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) +} +v135 := v134.Get() +v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v137 := v136.FindInternedVar(lang.NewSymbol("apply")) +if v137.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) +} +v138 := v137.Get() +v139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v140 := v139.FindInternedVar(lang.NewSymbol("vector")) +if v140.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v140))) +} +v141 := v140.Get() +v142 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v143 := v142.FindInternedVar(lang.NewSymbol("seq")) +if v143.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v143))) +} +v144 := v143.Get() +v145 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v146 := v145.FindInternedVar(lang.NewSymbol("concat")) +if v146.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v146))) +} +v147 := v146.Get() +v148 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v149 := v148.FindInternedVar(lang.NewSymbol("list")) +if v149.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v149))) +} +v150 := v149.Get() +v151 := lang.Apply(v150, []any{v56}) +v152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v153 := v152.FindInternedVar(lang.NewSymbol("list")) +if v153.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v153))) +} +v154 := v153.Get() +v155 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v156 := v155.FindInternedVar(lang.NewSymbol("seq")) +if v156.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v156))) +} +v157 := v156.Get() +v158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v159 := v158.FindInternedVar(lang.NewSymbol("concat")) +if v159.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v159))) +} +v160 := v159.Get() +v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v162 := v161.FindInternedVar(lang.NewSymbol("list")) +if v162.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) +} +v163 := v162.Get() +v164 := lang.Apply(v163, []any{lang.NewSymbol("glojure.core/first")}) +v165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v166 := v165.FindInternedVar(lang.NewSymbol("list")) +if v166.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v166))) +} +v167 := v166.Get() +v168 := lang.Apply(v167, []any{lang.NewSymbol("xs__0__auto__")}) +v169 := lang.Apply(v160, []any{v164, v168}) +v170 := lang.Apply(v157, []any{v169}) +v171 := lang.Apply(v154, []any{v170}) +v172 := lang.Apply(v147, []any{v151, v171}) +v173 := lang.Apply(v144, []any{v172}) +v174 := lang.Apply(v138, []any{v141, v173}) +v175 := lang.Apply(v135, []any{v174}) +v176 := lang.Apply(v128, []any{v132, v175, v6}) +v177 := lang.Apply(v125, []any{v176}) +v178 := lang.Apply(v122, []any{v177}) +v179 := lang.Apply(v72, []any{v76, v119, v178}) +v180 := lang.Apply(v69, []any{v179}) +return v180 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// comp +{ +v0 := lang.NewSymbol("comp").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("g")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("g"), lang.NewSymbol("&"), lang.NewSymbol("fs"))), lang.NewKeyword("doc"), "Takes a set of functions and returns a fn that is the composition\n of those fns. The returned fn takes a variable number of args,\n applies the rightmost of fns to the args, the next\n fn (right-to-left) to the result, etc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2549), lang.NewKeyword("end-line"), int(2549))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v4 := v3.FindInternedVar(lang.NewSymbol("identity")) +if v4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) +} +v5 := v4.Get() +return v5 + case 1: +v3 := args[0] +return v3 + case 2: +v3 := args[0] +v4 := args[1] +var v5 lang.FnFunc +v5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v6 := lang.Apply(v4, nil) +v7 := lang.Apply(v3, []any{v6}) +return v7 + case 1: +v6 := args[0] +v7 := lang.Apply(v4, []any{v6}) +v8 := lang.Apply(v3, []any{v7}) +return v8 + case 2: +v6 := args[0] +v7 := args[1] +v8 := lang.Apply(v4, []any{v6, v7}) +v9 := lang.Apply(v3, []any{v8}) +return v9 + case 3: +v6 := args[0] +v7 := args[1] +v8 := args[2] +v9 := lang.Apply(v4, []any{v6, v7, v8}) +v10 := lang.Apply(v3, []any{v9}) +return v10 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v6 := args[0] +v7 := args[1] +v8 := args[2] +v9 := lang.NewList(args[3:]...) +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("apply")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{v4, v6, v7, v8, v9}) +v14 := lang.Apply(v3, []any{v13}) +return v14 + } +}) +v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2559), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2564), lang.NewKeyword("end-column"), int(49)) +v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v7 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("reduce1")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("comp")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("list*")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v3, v4, v5}) +v16 := lang.Apply(v8, []any{v11, v15}) +return v16 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// namespace +{ +v1 := reflect.TypeOf("") +v0 := lang.NewSymbol("namespace").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns the namespace String of a symbol or keyword, or nil if not present.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1593), lang.NewKeyword("end-line"), int(1593))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5, _ := lang.FieldOrMethod(v4, "Namespace") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Namespace is not a function"))) +} +v6 := lang.Apply(v5, []any{}) +return v6 +}) +v4 := reflect.TypeOf("") +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// format +{ +v0 := lang.NewSymbol("format").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fmt"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Formats a string using java.lang.String.format, see java.util.Formatter for format\n string syntax", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5760), lang.NewKeyword("end-line"), int(5760))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.NewList(args[1:]...) +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("apply")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{fmt.Sprintf, v3, v4}) +return v8 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// vary-meta +{ +v0 := lang.NewSymbol("vary-meta").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("obj"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Returns an object of the same type and value as obj, with\n (apply f (meta obj) args) as its metadata.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(668), lang.NewKeyword("end-line"), int(668))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("with-meta")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("apply")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("meta")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v3}) +v16 := lang.Apply(v11, []any{v4, v15, v5}) +v17 := lang.Apply(v8, []any{v3, v16}) +return v17 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// nth +{ +var v1 lang.FnFunc +{ // function nth__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("seq")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("concat")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("list")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{lang.NewSymbol(".")}) +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("list")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("list")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("seq")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("concat")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("list")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.Apply(v31, []any{lang.NewSymbol("glojure.core/Nth")}) +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("list")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("seq")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("concat")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +} +v41 := v40.Get() +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("list")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +} +v44 := v43.Get() +v45 := lang.Apply(v44, []any{lang.NewSymbol("glojure.core/unquote")}) +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("list")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +} +v48 := v47.Get() +v49 := lang.Apply(v48, []any{lang.NewSymbol("glojure.core/c")}) +v50 := lang.Apply(v41, []any{v45, v49}) +v51 := lang.Apply(v38, []any{v50}) +v52 := lang.Apply(v35, []any{v51}) +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("list")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +} +v55 := v54.Get() +v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v57 := v56.FindInternedVar(lang.NewSymbol("seq")) +if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) +} +v58 := v57.Get() +v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v60 := v59.FindInternedVar(lang.NewSymbol("concat")) +if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) +} +v61 := v60.Get() +v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v63 := v62.FindInternedVar(lang.NewSymbol("list")) +if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +} +v64 := v63.Get() +v65 := lang.Apply(v64, []any{lang.NewSymbol("glojure.core/unquote")}) +v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v67 := v66.FindInternedVar(lang.NewSymbol("list")) +if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) +} +v68 := v67.Get() +v69 := lang.Apply(v68, []any{lang.NewSymbol("glojure.core/i")}) +v70 := lang.Apply(v61, []any{v65, v69}) +v71 := lang.Apply(v58, []any{v70}) +v72 := lang.Apply(v55, []any{v71}) +v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v74 := v73.FindInternedVar(lang.NewSymbol("list")) +if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) +} +v75 := v74.Get() +v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v77 := v76.FindInternedVar(lang.NewSymbol("seq")) +if v77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) +} +v78 := v77.Get() +v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v80 := v79.FindInternedVar(lang.NewSymbol("concat")) +if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) +} +v81 := v80.Get() +v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v83 := v82.FindInternedVar(lang.NewSymbol("list")) +if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) +} +v84 := v83.Get() +v85 := lang.Apply(v84, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) +v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v87 := v86.FindInternedVar(lang.NewSymbol("list")) +if v87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) +} +v88 := v87.Get() +v89 := lang.Apply(v88, []any{lang.NewSymbol("glojure.core/nf")}) +v90 := lang.Apply(v81, []any{v85, v89}) +v91 := lang.Apply(v78, []any{v90}) +v92 := lang.Apply(v75, []any{v91}) +v93 := lang.Apply(v28, []any{v32, v52, v72, v92}) +v94 := lang.Apply(v25, []any{v93}) +v95 := lang.Apply(v22, []any{v94}) +v96 := lang.Apply(v11, []any{v15, v19, v95}) +v97 := lang.Apply(v8, []any{v96}) +return v97 + } +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("nth").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("index")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("index"), lang.NewSymbol("not-found"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the value at the index. get returns nil if index out of\n bounds, nth throws an exception unless not-found is supplied. nth\n also works for strings, Java arrays, regex Matchers and Lists, and,\n in O(n) time, for sequences.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)int64(3)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(882), lang.NewKeyword("end-line"), int(882))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v4 := args[0] +v5 := args[1] +v6, _ := lang.FieldOrMethod(runtime3.RT, "Nth") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Nth is not a function"))) +} +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 + case 3: +v4 := args[0] +v5 := args[1] +v6 := args[2] +v7, _ := lang.FieldOrMethod(runtime3.RT, "NthDefault") +if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("NthDefault is not a function"))) +} +v8 := lang.Apply(v7, []any{v4, v5, v6}) +return v8 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// prep-hashes +{ +v0 := lang.NewSymbol("prep-hashes").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr-sym"), lang.NewSymbol("default"), lang.NewSymbol("tests"), lang.NewSymbol("thens"))), lang.NewKeyword("doc"), "Takes a sequence of test constants and a corresponding sequence of then\n expressions. Returns a tuple of [shift mask case-map switch-type skip-check]\n where case-map is a map of int case values to [test then] tuples, switch-type\n is either :sparse or :compact, and skip-check is a set of case ints for which\n post-switch equivalence checking must not be done (occurs with hash\n collisions).", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6726), lang.NewKeyword("end-line"), int(6726), lang.NewKeyword("private"), true)).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +var v8 lang.FnFunc +v8 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v9 := args[0] +v10 := lang.Apply(lang1.Hash, []any{v9}) +return v10 +}) +v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6734), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(6734), lang.NewKeyword("end-column"), int(66)) +v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v7 any = v10 +_ = v7 +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("into1")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.CreatePersistentTreeSet() +v16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6735), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(6735), lang.NewKeyword("end-column"), int(25)) +v17, err := lang.WithMeta(v15, v16.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("map")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, []any{v7, v5}) +v22 := lang.Apply(v14, []any{v17, v21}) +var v11 any = v22 +_ = v11 +var v24 any +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("==")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("count")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{v5}) +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("count")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v11}) +v36 := lang.Apply(v27, []any{v31, v35}) +if lang.IsTruthy(v36) { +var v37 any +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("fits-table?")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.Apply(v40, []any{v11}) +if lang.IsTruthy(v41) { +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("case-map")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +} +v44 := v43.Get() +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("identity")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +} +v47 := v46.Get() +v48 := lang.Apply(v44, []any{v7, v47, v5, v6}) +v49 := lang.NewVector(int64(0), int64(0), v48, lang.NewKeyword("compact")) +v50 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6739), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(6739), lang.NewKeyword("end-column"), int(63)) +v51, err := lang.WithMeta(v49, v50.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v37 = v51 +} else { +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("maybe-min-hash")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +} +v56 := v55.Get() +v57 := lang.Apply(v56, []any{v11}) +var v53 any = v57 +_ = v53 +var v59 any +if lang.IsTruthy(v53) { +v59 = v53 +} else { +v60 := lang.NewVector(int64(0), int64(0)) +v61 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6740), lang.NewKeyword("column"), int(56), lang.NewKeyword("end-line"), int(6740), lang.NewKeyword("end-column"), int(60)) +v62, err := lang.WithMeta(v60, v61.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v59 = v62 +} +var v52 any = v59 +_ = v52 +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("nth")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +} +v56 := v55.Get() +v57 := lang.Apply(v56, []any{v52, int64(0), nil}) +var v53 any = v57 +_ = v53 +v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v60 := v59.FindInternedVar(lang.NewSymbol("nth")) +if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) +} +v61 := v60.Get() +v62 := lang.Apply(v61, []any{v52, int64(1), nil}) +var v58 any = v62 +_ = v58 +var v64 any +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("zero?")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +} +v67 := v66.Get() +v68 := lang.Apply(v67, []any{v58}) +if lang.IsTruthy(v68) { +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("case-map")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +} +v71 := v70.Get() +v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v73 := v72.FindInternedVar(lang.NewSymbol("identity")) +if v73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) +} +v74 := v73.Get() +v75 := lang.Apply(v71, []any{v7, v74, v5, v6}) +v76 := lang.NewVector(int64(0), int64(0), v75, lang.NewKeyword("sparse")) +v77 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6743), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(6743), lang.NewKeyword("end-column"), int(66)) +v78, err := lang.WithMeta(v76, v77.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v64 = v78 +} else { +v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v80 := v79.FindInternedVar(lang.NewSymbol("case-map")) +if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) +} +v81 := v80.Get() +var v82 lang.FnFunc +v82 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v83 := args[0] +v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v85 := v84.FindInternedVar(lang.NewSymbol("shift-mask")) +if v85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) +} +v86 := v85.Get() +v87 := lang.Apply(v7, []any{v83}) +v88 := lang.Apply(v86, []any{v53, v58, v87}) +return v88 +}) +v83 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6745), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(6745), lang.NewKeyword("end-column"), int(71)) +v84, err := lang.WithMeta(v82, v83.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v86 := v85.FindInternedVar(lang.NewSymbol("identity")) +if v86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) +} +v87 := v86.Get() +v88 := lang.Apply(v81, []any{v84, v87, v5, v6}) +v89 := lang.NewVector(v53, v58, v88, lang.NewKeyword("compact")) +v90 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6745), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(6745), lang.NewKeyword("end-column"), int(103)) +v91, err := lang.WithMeta(v89, v90.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v64 = v91 +} +v37 = v64 +} +v24 = v37 +} else { +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("merge-hash-collisions")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +} +v55 := v54.Get() +v56 := lang.Apply(v55, []any{v3, v4, v5, v6}) +var v52 any = v56 +_ = v52 +v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v59 := v58.FindInternedVar(lang.NewSymbol("nth")) +if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) +} +v60 := v59.Get() +v61 := lang.Apply(v60, []any{v52, int64(0), nil}) +var v57 any = v61 +_ = v57 +v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v64 := v63.FindInternedVar(lang.NewSymbol("nth")) +if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) +} +v65 := v64.Get() +v66 := lang.Apply(v65, []any{v52, int64(1), nil}) +var v62 any = v66 +_ = v62 +v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v69 := v68.FindInternedVar(lang.NewSymbol("nth")) +if v69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) +} +v70 := v69.Get() +v71 := lang.Apply(v70, []any{v52, int64(2), nil}) +var v67 any = v71 +_ = v67 +v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v74 := v73.FindInternedVar(lang.NewSymbol("prep-hashes")) +if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) +} +v75 := v74.Get() +v76 := lang.Apply(v75, []any{v3, v4, v57, v62}) +var v72 any = v76 +_ = v72 +v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v79 := v78.FindInternedVar(lang.NewSymbol("nth")) +if v79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) +} +v80 := v79.Get() +v81 := lang.Apply(v80, []any{v72, int64(0), nil}) +var v77 any = v81 +_ = v77 +v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v84 := v83.FindInternedVar(lang.NewSymbol("nth")) +if v84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) +} +v85 := v84.Get() +v86 := lang.Apply(v85, []any{v72, int64(1), nil}) +var v82 any = v86 +_ = v82 +v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v89 := v88.FindInternedVar(lang.NewSymbol("nth")) +if v89.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) +} +v90 := v89.Get() +v91 := lang.Apply(v90, []any{v72, int64(2), nil}) +var v87 any = v91 +_ = v87 +v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v94 := v93.FindInternedVar(lang.NewSymbol("nth")) +if v94.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) +} +v95 := v94.Get() +v96 := lang.Apply(v95, []any{v72, int64(3), nil}) +var v92 any = v96 +_ = v92 +var v98 any +v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v100 := v99.FindInternedVar(lang.NewSymbol("zero?")) +if v100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) +} +v101 := v100.Get() +v102 := lang.Apply(v101, []any{v82}) +if lang.IsTruthy(v102) { +v98 = v97 +} else { +v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v104 := v103.FindInternedVar(lang.NewSymbol("into1")) +if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) +} +v105 := v104.Get() +v106 := lang.CreatePersistentTreeSet() +v107 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6751), lang.NewKeyword("column"), int(33), lang.NewKeyword("end-line"), int(6751), lang.NewKeyword("end-column"), int(35)) +v108, err := lang.WithMeta(v106, v107.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v110 := v109.FindInternedVar(lang.NewSymbol("map")) +if v110.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) +} +v111 := v110.Get() +var v112 lang.FnFunc +v112 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v113 := args[0] +v114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v115 := v114.FindInternedVar(lang.NewSymbol("shift-mask")) +if v115.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v115))) +} +v116 := v115.Get() +v117 := lang.Apply(v116, []any{v77, v82, v113}) +return v117 +}) +v113 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6751), lang.NewKeyword("column"), int(42), lang.NewKeyword("end-line"), int(6751), lang.NewKeyword("end-column"), int(67)) +v114, err := lang.WithMeta(v112, v113.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v115 := lang.Apply(v111, []any{v114, v97}) +v116 := lang.Apply(v105, []any{v108, v115}) +v98 = v116 +} +var v97 any = v98 +_ = v97 +v118 := lang.NewVector(v77, v82, v87, v92, v97) +v119 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6752), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(6752), lang.NewKeyword("end-column"), int(52)) +v120, err := lang.WithMeta(v118, v119.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v24 = v120 +} +return v24 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// min-key +{ +v0 := lang.NewSymbol("min-key").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Returns the x for which (k x), a number, is least.\n\n If there are multiple such xs, the last one is returned.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5033), lang.NewKeyword("end-line"), int(5033))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v3 := args[0] +v4 := args[1] +return v4 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +var v6 any +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("<")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v3, []any{v4}) +v11 := lang.Apply(v3, []any{v5}) +v12 := lang.Apply(v9, []any{v10, v11}) +if lang.IsTruthy(v12) { +v6 = v4 +} else { +v6 = v5 +} +return v6 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v8 := lang.Apply(v3, []any{v4}) +var v7 any = v8 +_ = v7 +v10 := lang.Apply(v3, []any{v5}) +var v9 any = v10 +_ = v9 +var v12 any +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("<")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v7, v9}) +if lang.IsTruthy(v16) { +v17 := lang.NewVector(v4, v7) +v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5043), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(5043), lang.NewKeyword("end-column"), int(36)) +v19, err := lang.WithMeta(v17, v18.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v12 = v19 +} else { +v20 := lang.NewVector(v5, v9) +v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5043), lang.NewKeyword("column"), int(38), lang.NewKeyword("end-line"), int(5043), lang.NewKeyword("end-column"), int(43)) +v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v12 = v22 +} +var v11 any = v12 +_ = v11 +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("nth")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v11, int64(0), nil}) +var v23 any = v27 +_ = v23 +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("nth")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.Apply(v31, []any{v11, int64(1), nil}) +var v28 any = v32 +_ = v28 +var v34 any = v34 +_ = v34 +var v35 any = v35 +_ = v35 +var v36 any = v36 +_ = v36 +var v37 any +for { +var v38 any +if lang.IsTruthy(v36) { +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("first")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v36}) +var v39 any = v43 +_ = v39 +v45 := lang.Apply(v3, []any{v39}) +var v44 any = v45 +_ = v44 +var v47 any +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("<=")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v44, v35}) +if lang.IsTruthy(v51) { +var v52 any = v39 +var v53 any = v44 +v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v56 := v55.FindInternedVar(lang.NewSymbol("next")) +if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) +} +v57 := v56.Get() +v58 := lang.Apply(v57, []any{v36}) +var v54 any = v58 +v34 = v52 +v35 = v53 +v36 = v54 +continue +} else { +var v59 any = v34 +var v60 any = v35 +v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v63 := v62.FindInternedVar(lang.NewSymbol("next")) +if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +} +v64 := v63.Get() +v65 := lang.Apply(v64, []any{v36}) +var v61 any = v65 +v34 = v59 +v35 = v60 +v36 = v61 +continue +} +v38 = v47 +} else { +v38 = v34 +} +v37 = v38 + break +} +return v37 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// future-cancelled? +{ +v0 := lang.NewSymbol("future-cancelled?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Returns true if future f is cancelled", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7068), lang.NewKeyword("end-line"), int(7068))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, ok := lang.FieldOrMethod(v3, "isCancelled") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "isCancelled"))) +} +var v5 any +switch reflect.TypeOf(v4).Kind() { +case reflect.Func: + v5 = lang.Apply(v4, nil) +default: + v5 = v4 +} +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// long-array +{ +var v1 lang.FnFunc +{ // function long-array__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.NewList(args[0:]...) +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/longArray")}) +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("list")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("seq")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("concat")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("list")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v37, []any{lang.NewSymbol("glojure.core/args")}) +v39 := lang.Apply(v30, []any{v34, v38}) +v40 := lang.Apply(v27, []any{v39}) +v41 := lang.Apply(v24, []any{v40}) +v42 := lang.Apply(v9, []any{v13, v17, v21, v41}) +v43 := lang.Apply(v6, []any{v42}) +return v43 + } +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("long-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Creates an array of longs", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5364), lang.NewKeyword("end-line"), int(5364))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "longArray") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("longArray is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 + case 2: +v4 := args[0] +v5 := args[1] +v6, _ := lang.FieldOrMethod(lang1.Numbers, "longArrayInit") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("longArrayInit is not a function"))) +} +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// unchecked-remainder-int +{ +var v1 lang.FnFunc +{ // function unchecked-remainder-int__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("concat")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("list")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("seq")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("concat")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("list")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/unchecked_int_remainder")}) +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v4}) +v40 := lang.Apply(v27, []any{v31, v35, v39}) +v41 := lang.Apply(v24, []any{v40}) +v42 := lang.Apply(v21, []any{v41}) +v43 := lang.Apply(v10, []any{v14, v18, v42}) +v44 := lang.Apply(v7, []any{v43}) +return v44 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("unchecked-remainder-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the remainder of division of x by y, both int.\n Note - uses a primitive operator subject to truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(29), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1245), lang.NewKeyword("end-line"), int(1245))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := args[1] +v6, _ := lang.FieldOrMethod(lang1.Numbers, "unchecked_int_remainder") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_remainder is not a function"))) +} +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// to-array-2d +{ +v0 := lang.NewSymbol("to-array-2d").WithMeta(lang.NewMap(lang.NewKeyword("tag"), "[[Ljava.lang.Object;", lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a (potentially-ragged) 2-dimensional array of Objects\n containing the contents of coll, which can be any Collection of any\n Collection.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4002), lang.NewKeyword("end-line"), int(4002))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("make-array")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8, _ := lang.FieldOrMethod(reflect.Type, "forName") +if reflect.TypeOf(v8).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("forName is not a function"))) +} +v9 := lang.Apply(v8, []any{"[Ljava.lang.Object;"}) +v10, _ := lang.FieldOrMethod(v3, "size") +if reflect.TypeOf(v10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("size is not a function"))) +} +v11 := lang.Apply(v10, []any{}) +v12 := lang.Apply(v7, []any{v9, v11}) +var v4 any = v12 +_ = v4 +var v14 any = int64(0) +_ = v14 +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("seq")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v3}) +var v15 any = v19 +_ = v15 +var v20 any +for { +var v21 any +if lang.IsTruthy(v15) { +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("aset")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("to-array")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("first")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{v15}) +v32 := lang.Apply(v27, []any{v31}) +v33 := lang.Apply(v24, []any{v4, v14, v32}) +_ = v33 +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("inc")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v37, []any{v14}) +var v34 any = v38 +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("next")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v15}) +var v39 any = v43 +v14 = v34 +v15 = v39 +continue +} else { +v21 = nil +} +v20 = v21 + break +} +_ = v20 +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), "[[Ljava.lang.Object;")).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// with-redefs +{ +v0 := lang.NewSymbol("with-redefs").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "binding => var-symbol temp-value-expr\n\n Temporarily redefines Vars while executing the body. The\n temp-value-exprs will be evaluated and each resulting value will\n replace in parallel the root value of its Var. After the body is\n executed, the root values of all the Vars will be set back to their\n old values. These temporary changes will be visible in all threads.\n Useful for mocking out functions during testing.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7587), lang.NewKeyword("end-line"), int(7587))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("seq")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("concat")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("list")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/with-redefs-fn")}) +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("list")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("zipmap")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("map")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +var v26 lang.FnFunc +v26 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v27 := args[0] +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("list")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{lang.NewSymbol("var"), v27}) +return v31 +}) +v27 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7598), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(7598), lang.NewKeyword("end-column"), int(47)) +v28, err := lang.WithMeta(v26, v27.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("take-nth")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.Apply(v31, []any{int64(2), v5}) +v33 := lang.Apply(v25, []any{v28, v32}) +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("take-nth")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("next")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v5}) +v41 := lang.Apply(v36, []any{int64(2), v40}) +v42 := lang.Apply(v22, []any{v33, v41}) +v43 := lang.Apply(v19, []any{v42}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("seq")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +} +v49 := v48.Get() +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("concat")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +} +v52 := v51.Get() +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("list")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +} +v55 := v54.Get() +v56 := lang.Apply(v55, []any{lang.NewSymbol("glojure.core/fn")}) +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("list")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +} +v59 := v58.Get() +v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v61 := v60.FindInternedVar(lang.NewSymbol("apply")) +if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) +} +v62 := v61.Get() +v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v64 := v63.FindInternedVar(lang.NewSymbol("vector")) +if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) +} +v65 := v64.Get() +v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v67 := v66.FindInternedVar(lang.NewSymbol("seq")) +if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) +} +v68 := v67.Get() +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("concat")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +} +v71 := v70.Get() +v72 := lang.Apply(v71, nil) +v73 := lang.Apply(v68, []any{v72}) +v74 := lang.Apply(v62, []any{v65, v73}) +v75 := lang.Apply(v59, []any{v74}) +v76 := lang.Apply(v52, []any{v56, v75, v6}) +v77 := lang.Apply(v49, []any{v76}) +v78 := lang.Apply(v46, []any{v77}) +v79 := lang.Apply(v12, []any{v16, v43, v78}) +v80 := lang.Apply(v9, []any{v79}) +return v80 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// vec +{ +v0 := lang.NewSymbol("vec").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Creates a new vector containing the contents of coll. Java arrays\n will be aliased and should not be modified.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(366), lang.NewKeyword("end-line"), int(366))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("vector?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +if lang.IsTruthy(v8) { +var v9 any +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("instance?")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang1.IObj, v3}) +if lang.IsTruthy(v13) { +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("with-meta")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v3, nil}) +v9 = v17 +} else { +v18 := lang.Apply(lang1.CreateLazilyPersistentVector, []any{v3}) +v9 = v18 +} +v4 = v9 +} else { +v19 := lang.Apply(lang1.CreateLazilyPersistentVector, []any{v3}) +v4 = v19 +} +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// ns-aliases +{ +v0 := lang.NewSymbol("ns-aliases").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of the aliases for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4273), lang.NewKeyword("end-line"), int(4273))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("the-ns")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{v3}) +v8, ok := lang.FieldOrMethod(v7, "getAliases") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "getAliases"))) +} +var v9 any +switch reflect.TypeOf(v8).Kind() { +case reflect.Func: + v9 = lang.Apply(v8, nil) +default: + v9 = v8 +} +return v9 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// aset-long +{ +v0 := lang.NewSymbol("aset-long").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of long. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3951), lang.NewKeyword("end-line"), int(3953))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("long")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v5}) +v10, _ := lang.FieldOrMethod(nil, "setLong") +if reflect.TypeOf(v10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setLong is not a function"))) +} +v11 := lang.Apply(v10, []any{v3, v4, v9}) +_ = v11 +return v5 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("apply")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("aset-long")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("aget")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v3, v4}) +v17 := lang.Apply(v9, []any{v12, v16, v5, v6}) +return v17 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// == +{ +var v1 lang.FnFunc +{ // function ==__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("concat")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("list")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("seq")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("concat")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("list")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/equiv")}) +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v4}) +v40 := lang.Apply(v27, []any{v31, v35, v39}) +v41 := lang.Apply(v24, []any{v40}) +v42 := lang.Apply(v21, []any{v41}) +v43 := lang.Apply(v10, []any{v14, v18, v42}) +v44 := lang.Apply(v7, []any{v43}) +return v44 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("==").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns non-nil if nums all have the equivalent\n value (type-independent), otherwise false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1093), lang.NewKeyword("end-line"), int(1093))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v4 := args[0] +return true + case 2: +v4 := args[0] +v5 := args[1] +v6, _ := lang.FieldOrMethod(lang1.Numbers, "equiv") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("equiv is not a function"))) +} +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := args[1] +v6 := lang.NewList(args[2:]...) +recur_loop_206: +var v7 any +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("==")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v4, v5}) +if lang.IsTruthy(v11) { +var v12 any +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("next")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v6}) +if lang.IsTruthy(v16) { +var v17 any = v5 +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("first")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v6}) +var v18 any = v22 +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("next")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v6}) +var v23 any = v27 +v4 = v17 +v5 = v18 +v6 = v23 +goto recur_loop_206 +} else { +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("==")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("first")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v6}) +v35 := lang.Apply(v30, []any{v5, v34}) +v12 = v35 +} +v7 = v12 +} else { +v7 = false +} +return v7 + } +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// *assert* +{ +v0 := lang.NewSymbol("*assert*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "When set to logical false, 'assert' will omit assertion checks in\n compiled code. Defaults to true.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, false, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// *verbose-defrecords* +{ +v0 := lang.NewSymbol("*verbose-defrecords*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(37), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(37), lang.NewKeyword("end-column"), int(35), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, false, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// simple-symbol? +{ +v0 := lang.NewSymbol("simple-symbol?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a symbol without a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1623), lang.NewKeyword("end-line"), int(1623))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("symbol?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +var v4 any = v8 +_ = v4 +var v10 any +if lang.IsTruthy(v4) { +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("nil?")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("namespace")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v3}) +v18 := lang.Apply(v13, []any{v17}) +v10 = v18 +} else { +v10 = v4 +} +return v10 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// short-array +{ +var v1 lang.FnFunc +{ // function short-array__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.NewList(args[0:]...) +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/shortArray")}) +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("list")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("seq")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("concat")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("list")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v37, []any{lang.NewSymbol("glojure.core/args")}) +v39 := lang.Apply(v30, []any{v34, v38}) +v40 := lang.Apply(v27, []any{v39}) +v41 := lang.Apply(v24, []any{v40}) +v42 := lang.Apply(v9, []any{v13, v17, v21, v41}) +v43 := lang.Apply(v6, []any{v42}) +return v43 + } +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("short-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Creates an array of shorts", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)int64(2)), lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5333), lang.NewKeyword("end-line"), int(5333))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "shortArray") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("shortArray is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 + case 2: +v4 := args[0] +v5 := args[1] +v6, _ := lang.FieldOrMethod(lang1.Numbers, "shortArrayInit") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("shortArrayInit is not a function"))) +} +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// dissoc! +{ +v0 := lang.NewSymbol("dissoc!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"), lang.NewSymbol("&"), lang.NewSymbol("ks"))), lang.NewKeyword("doc"), "Returns a transient map that doesn't contain a mapping for key(s).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3382), lang.NewKeyword("end-line"), int(3382))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v3 := args[0] +v4 := args[1] +v5, _ := lang.FieldOrMethod(v3, "without") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("without is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +recur_loop_611: +v7, _ := lang.FieldOrMethod(v3, "without") +if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("without is not a function"))) +} +v8 := lang.Apply(v7, []any{v4}) +var v6 any = v8 +_ = v6 +var v10 any +if lang.IsTruthy(v5) { +var v11 any = v6 +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("first")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v5}) +var v12 any = v16 +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("next")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, []any{v5}) +var v17 any = v21 +v3 = v11 +v4 = v12 +v5 = v17 +goto recur_loop_611 +} else { +v10 = v6 +} +return v10 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// ref +{ +v0 := lang.NewSymbol("ref").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Creates and returns a Ref with an initial value of x and zero or\n more options (in any order):\n\n :meta metadata-map\n\n :validator validate-fn\n\n :min-history (default 0)\n :max-history (default 10)\n\n If metadata-map is supplied, it will become the metadata on the\n ref. validate-fn must be nil or a side-effect-free fn of one\n argument, which will be passed the intended new state on any state\n change. If the new state is unacceptable, the validate-fn should\n return false or throw an exception. validate-fn will be called on\n transaction commit, when all refs have their final values.\n\n Normally refs accumulate history dynamically as needed to deal with\n read demands. If you know in advance you will need history you can\n set :min-history to ensure it will be available when first needed (instead\n of after a read fault). History is limited, and the limit can be set\n with :max-history.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2260), lang.NewKeyword("end-line"), int(2260))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +v4 := lang.Apply(lang1.NewRef, []any{v3}) +return v4 + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.NewList(args[1:]...) +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("setup-reference")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("ref")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v3}) +v13 := lang.Apply(v8, []any{v12, v4}) +var v5 any = v13 +_ = v5 +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("apply")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("hash-map")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v17, []any{v20, v4}) +var v14 any = v21 +_ = v14 +var v23 any +v24 := lang.Apply(lang.NewKeyword("max-history"), []any{v14}) +if lang.IsTruthy(v24) { +v25 := lang.Apply(lang.NewKeyword("max-history"), []any{v14}) +v26, _ := lang.FieldOrMethod(v5, "setMaxHistory") +if reflect.TypeOf(v26).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMaxHistory is not a function"))) +} +v27 := lang.Apply(v26, []any{v25}) +v23 = v27 +} else { +v23 = nil +} +_ = v23 +var v28 any +v29 := lang.Apply(lang.NewKeyword("min-history"), []any{v14}) +if lang.IsTruthy(v29) { +v30 := lang.Apply(lang.NewKeyword("min-history"), []any{v14}) +v31, _ := lang.FieldOrMethod(v5, "setMinHistory") +if reflect.TypeOf(v31).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMinHistory is not a function"))) +} +v32 := lang.Apply(v31, []any{v30}) +v28 = v32 +} else { +v28 = nil +} +_ = v28 +return v5 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// areduce +{ +v0 := lang.NewSymbol("areduce").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("idx"), lang.NewSymbol("ret"), lang.NewSymbol("init"), lang.NewSymbol("expr"))), lang.NewKeyword("doc"), "Reduces an expression across an array a, using an index named idx,\n and return value named ret, initialized to init, setting ret to the \n evaluation of expr at each step, returning ret.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5289), lang.NewKeyword("end-line"), int(5289))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 7 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := args[4] +v8 := args[5] +v9 := args[6] +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("seq")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("concat")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("list")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{lang.NewSymbol("glojure.core/let")}) +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("list")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("apply")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("vector")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("seq")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("concat")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("list")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v37, []any{lang.NewSymbol("a__0__auto__")}) +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("list")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +} +v41 := v40.Get() +v42 := lang.Apply(v41, []any{v5}) +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("list")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +} +v45 := v44.Get() +v46 := lang.Apply(v45, []any{lang.NewSymbol("l__1__auto__")}) +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("list")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +} +v49 := v48.Get() +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("seq")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +} +v52 := v51.Get() +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("concat")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +} +v55 := v54.Get() +v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v57 := v56.FindInternedVar(lang.NewSymbol("list")) +if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) +} +v58 := v57.Get() +v59 := lang.Apply(v58, []any{lang.NewSymbol("glojure.core/alength")}) +v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v61 := v60.FindInternedVar(lang.NewSymbol("list")) +if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) +} +v62 := v61.Get() +v63 := lang.Apply(v62, []any{lang.NewSymbol("a__0__auto__")}) +v64 := lang.Apply(v55, []any{v59, v63}) +v65 := lang.Apply(v52, []any{v64}) +v66 := lang.Apply(v49, []any{v65}) +v67 := lang.Apply(v34, []any{v38, v42, v46, v66}) +v68 := lang.Apply(v31, []any{v67}) +v69 := lang.Apply(v25, []any{v28, v68}) +v70 := lang.Apply(v22, []any{v69}) +v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v72 := v71.FindInternedVar(lang.NewSymbol("list")) +if v72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) +} +v73 := v72.Get() +v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v75 := v74.FindInternedVar(lang.NewSymbol("seq")) +if v75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) +} +v76 := v75.Get() +v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v78 := v77.FindInternedVar(lang.NewSymbol("concat")) +if v78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) +} +v79 := v78.Get() +v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v81 := v80.FindInternedVar(lang.NewSymbol("list")) +if v81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) +} +v82 := v81.Get() +v83 := lang.Apply(v82, []any{lang.NewSymbol("glojure.core/loop")}) +v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v85 := v84.FindInternedVar(lang.NewSymbol("list")) +if v85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) +} +v86 := v85.Get() +v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v88 := v87.FindInternedVar(lang.NewSymbol("apply")) +if v88.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) +} +v89 := v88.Get() +v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v91 := v90.FindInternedVar(lang.NewSymbol("vector")) +if v91.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) +} +v92 := v91.Get() +v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v94 := v93.FindInternedVar(lang.NewSymbol("seq")) +if v94.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) +} +v95 := v94.Get() +v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v97 := v96.FindInternedVar(lang.NewSymbol("concat")) +if v97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) +} +v98 := v97.Get() +v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v100 := v99.FindInternedVar(lang.NewSymbol("list")) +if v100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) +} +v101 := v100.Get() +v102 := lang.Apply(v101, []any{v6}) +v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v104 := v103.FindInternedVar(lang.NewSymbol("list")) +if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) +} +v105 := v104.Get() +v106 := lang.Apply(v105, []any{int64(0)}) +v107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v108 := v107.FindInternedVar(lang.NewSymbol("list")) +if v108.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v108))) +} +v109 := v108.Get() +v110 := lang.Apply(v109, []any{v7}) +v111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v112 := v111.FindInternedVar(lang.NewSymbol("list")) +if v112.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v112))) +} +v113 := v112.Get() +v114 := lang.Apply(v113, []any{v8}) +v115 := lang.Apply(v98, []any{v102, v106, v110, v114}) +v116 := lang.Apply(v95, []any{v115}) +v117 := lang.Apply(v89, []any{v92, v116}) +v118 := lang.Apply(v86, []any{v117}) +v119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v120 := v119.FindInternedVar(lang.NewSymbol("list")) +if v120.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v120))) +} +v121 := v120.Get() +v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v123 := v122.FindInternedVar(lang.NewSymbol("seq")) +if v123.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) +} +v124 := v123.Get() +v125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v126 := v125.FindInternedVar(lang.NewSymbol("concat")) +if v126.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v126))) +} +v127 := v126.Get() +v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v129 := v128.FindInternedVar(lang.NewSymbol("list")) +if v129.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v129))) +} +v130 := v129.Get() +v131 := lang.Apply(v130, []any{lang.NewSymbol("if")}) +v132 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v133 := v132.FindInternedVar(lang.NewSymbol("list")) +if v133.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v133))) +} +v134 := v133.Get() +v135 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v136 := v135.FindInternedVar(lang.NewSymbol("seq")) +if v136.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v136))) +} +v137 := v136.Get() +v138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v139 := v138.FindInternedVar(lang.NewSymbol("concat")) +if v139.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v139))) +} +v140 := v139.Get() +v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v142 := v141.FindInternedVar(lang.NewSymbol("list")) +if v142.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) +} +v143 := v142.Get() +v144 := lang.Apply(v143, []any{lang.NewSymbol("glojure.core/<")}) +v145 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v146 := v145.FindInternedVar(lang.NewSymbol("list")) +if v146.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v146))) +} +v147 := v146.Get() +v148 := lang.Apply(v147, []any{v6}) +v149 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v150 := v149.FindInternedVar(lang.NewSymbol("list")) +if v150.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v150))) +} +v151 := v150.Get() +v152 := lang.Apply(v151, []any{lang.NewSymbol("l__1__auto__")}) +v153 := lang.Apply(v140, []any{v144, v148, v152}) +v154 := lang.Apply(v137, []any{v153}) +v155 := lang.Apply(v134, []any{v154}) +v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v157 := v156.FindInternedVar(lang.NewSymbol("list")) +if v157.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) +} +v158 := v157.Get() +v159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v160 := v159.FindInternedVar(lang.NewSymbol("seq")) +if v160.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v160))) +} +v161 := v160.Get() +v162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v163 := v162.FindInternedVar(lang.NewSymbol("concat")) +if v163.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v163))) +} +v164 := v163.Get() +v165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v166 := v165.FindInternedVar(lang.NewSymbol("list")) +if v166.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v166))) +} +v167 := v166.Get() +v168 := lang.Apply(v167, []any{lang.NewSymbol("recur")}) +v169 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v170 := v169.FindInternedVar(lang.NewSymbol("list")) +if v170.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v170))) +} +v171 := v170.Get() +v172 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v173 := v172.FindInternedVar(lang.NewSymbol("seq")) +if v173.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v173))) +} +v174 := v173.Get() +v175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v176 := v175.FindInternedVar(lang.NewSymbol("concat")) +if v176.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v176))) +} +v177 := v176.Get() +v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v179 := v178.FindInternedVar(lang.NewSymbol("list")) +if v179.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) +} +v180 := v179.Get() +v181 := lang.Apply(v180, []any{lang.NewSymbol("glojure.core/unchecked-inc-int")}) +v182 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v183 := v182.FindInternedVar(lang.NewSymbol("list")) +if v183.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v183))) +} +v184 := v183.Get() +v185 := lang.Apply(v184, []any{v6}) +v186 := lang.Apply(v177, []any{v181, v185}) +v187 := lang.Apply(v174, []any{v186}) +v188 := lang.Apply(v171, []any{v187}) +v189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v190 := v189.FindInternedVar(lang.NewSymbol("list")) +if v190.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v190))) +} +v191 := v190.Get() +v192 := lang.Apply(v191, []any{v9}) +v193 := lang.Apply(v164, []any{v168, v188, v192}) +v194 := lang.Apply(v161, []any{v193}) +v195 := lang.Apply(v158, []any{v194}) +v196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v197 := v196.FindInternedVar(lang.NewSymbol("list")) +if v197.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v197))) +} +v198 := v197.Get() +v199 := lang.Apply(v198, []any{v7}) +v200 := lang.Apply(v127, []any{v131, v155, v195, v199}) +v201 := lang.Apply(v124, []any{v200}) +v202 := lang.Apply(v121, []any{v201}) +v203 := lang.Apply(v79, []any{v83, v118, v202}) +v204 := lang.Apply(v76, []any{v203}) +v205 := lang.Apply(v73, []any{v204}) +v206 := lang.Apply(v15, []any{v19, v70, v205}) +v207 := lang.Apply(v12, []any{v206}) +return v207 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// int +{ +var v1 lang.FnFunc +{ // function int__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +var v30 any +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +if lang.IsTruthy(v33) { +v30 = lang.NewSymbol("uncheckedIntCast") +} else { +v30 = lang.NewSymbol("intCast") +} +v34 := lang.Apply(v29, []any{v30}) +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("list")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v37, []any{v3}) +v39 := lang.Apply(v26, []any{v34, v38}) +v40 := lang.Apply(v23, []any{v39}) +v41 := lang.Apply(v20, []any{v40}) +v42 := lang.Apply(v9, []any{v13, v17, v41}) +v43 := lang.Apply(v6, []any{v42}) +return v43 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to int", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(875), lang.NewKeyword("end-line"), int(875))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5, _ := lang.FieldOrMethod(runtime3.RT, "IntCast") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("IntCast is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// + +{ +var v1 lang.FnFunc +v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v2 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +if lang.IsTruthy(v7) { +v4 = closed10 +} else { +v4 = v3 +} +var v3 any = v4 +_ = v3 +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("seq")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("concat")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("seq")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("concat")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v2}) +v40 := lang.Apply(v31, []any{v35, v39}) +v41 := lang.Apply(v28, []any{v40}) +v42 := lang.Apply(v25, []any{v41}) +v43 := lang.Apply(v14, []any{v18, v22, v42}) +v44 := lang.Apply(v11, []any{v43}) +return v44 + case 2: +v2 := args[0] +v3 := args[1] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +if lang.IsTruthy(v8) { +v5 = closed10 +} else { +v5 = v4 +} +var v4 any = v5 +_ = v4 +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("seq")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("concat")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("list")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("list")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("list")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("seq")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("concat")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("list")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v4}) +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("list")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v2}) +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("list")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v3}) +v45 := lang.Apply(v32, []any{v36, v40, v44}) +v46 := lang.Apply(v29, []any{v45}) +v47 := lang.Apply(v26, []any{v46}) +v48 := lang.Apply(v15, []any{v19, v23, v47}) +v49 := lang.Apply(v12, []any{v48}) +return v49 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v2 := args[0] +v3 := args[1] +v4 := lang.NewList(args[2:]...) +var v6 any +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +if lang.IsTruthy(v9) { +v6 = closed10 +} else { +v6 = v5 +} +var v5 any = v6 +_ = v5 +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +var v14 lang.FnFunc +v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v15 := args[0] +v16 := args[1] +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v5}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v15}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v16}) +v52 := lang.Apply(v39, []any{v43, v47, v51}) +v53 := lang.Apply(v36, []any{v52}) +v54 := lang.Apply(v33, []any{v53}) +v55 := lang.Apply(v22, []any{v26, v30, v54}) +v56 := lang.Apply(v19, []any{v55}) +return v56 +}) +v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) +v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v5}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v2}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v3}) +v52 := lang.Apply(v39, []any{v43, v47, v51}) +v53 := lang.Apply(v36, []any{v52}) +v54 := lang.Apply(v33, []any{v53}) +v55 := lang.Apply(v22, []any{v26, v30, v54}) +v56 := lang.Apply(v19, []any{v55}) +v57 := lang.Apply(v13, []any{v16, v56, v4}) +return v57 + } +}) +v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) +} +v5 := lang.Apply(v4, []any{v3, int64(1)}) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v0 := lang.NewSymbol("+").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the sum of nums. (+) returns 0. Does not auto-promote\n longs, will throw on overflow. See also: +'", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(977), lang.NewKeyword("end-line"), int(977))).(*lang.Symbol) +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +return int64(0) + case 1: +v5 := args[0] +v6 := lang.Apply(lang1.MustAsNumber, []any{v5}) +return v6 + case 2: +v5 := args[0] +v6 := args[1] +v7, _ := lang.FieldOrMethod(lang1.Numbers, "add") +if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) +} +v8 := lang.Apply(v7, []any{v5, v6}) +return v8 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +v6 := args[1] +v7 := lang.NewList(args[2:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("+")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("+")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v5, v6}) +v18 := lang.Apply(v10, []any{v13, v17, v7}) +return v18 + } +}) +v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v3 := ns.InternWithValue(v0, v4, true) +if v0.Meta() != nil { + v3.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// assoc-in +{ +v0 := lang.NewSymbol("assoc-in").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("&"), lang.NewSymbol("ks")), lang.NewSymbol("v"))), lang.NewKeyword("doc"), "Associates a value in a nested associative structure, where ks is a\n sequence of keys and v is the new value and returns a new nested structure.\n If any levels do not exist, hash-maps will be created.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6190), lang.NewKeyword("end-line"), int(6190))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +var v6 any = v4 +_ = v6 +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("seq")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v6}) +var v7 any = v11 +_ = v7 +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("first")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v7}) +var v12 any = v16 +_ = v12 +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("next")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, []any{v17}) +var v17 any = v21 +_ = v17 +var v22 any = v12 +_ = v22 +var v23 any = v17 +_ = v23 +var v25 any +if lang.IsTruthy(v23) { +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("assoc")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("assoc-in")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("get")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3, v22}) +v36 := lang.Apply(v31, []any{v35, v23, v5}) +v37 := lang.Apply(v28, []any{v3, v22, v36}) +v25 = v37 +} else { +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("assoc")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.Apply(v40, []any{v3, v22, v5}) +v25 = v41 +} +return v25 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// seque +{ +v0 := lang.NewSymbol("seque").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s")), lang.NewVector(lang.NewSymbol("n-or-q"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Creates a queued seq on another (presumably lazy) seq s. The queued\n seq will produce a concrete seq in the background, and can get up to\n n items ahead of the consumer. n-or-q can be an integer n buffer\n size, or an instance of java.util.concurrent BlockingQueue. Note\n that reading from a seque can block if the reader gets ahead of the\n producer.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5419), lang.NewKeyword("end-line"), int(5419))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seque")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{int64(100), v3}) +return v7 + case 2: +v3 := args[0] +v4 := args[1] +var v6 any +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("instance?")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{nil, v3}) +if lang.IsTruthy(v10) { +v6 = v3 +} else { +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("int")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v3}) +v15 := lang.Apply(LinkedBlockingQueue31., []any{v14}) +v6 = v15 +} +var v5 any = v6 +_ = v5 +v17 := lang.Apply(Object23., nil) +var v16 any = v17 +_ = v16 +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("agent")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +var v22 lang.FnFunc +v22 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +return v4 +}) +v23 := lang.Apply(lang1.NewLazySeq, []any{v22}) +v24 := lang.Apply(v21, []any{v23}) +var v18 any = v24 +_ = v18 +var v26 lang.FnFunc +v26 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v27 := args[0] +v28 := args[1] +var v29 any +v30, _ := lang.FieldOrMethod(v27, "offer") +if reflect.TypeOf(v30).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("offer is not a function"))) +} +v31 := lang.Apply(v30, []any{v27}) +if lang.IsTruthy(v31) { +panic(v28) +} else { +v29 = v28 +} +return v29 +}) +v27 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5435), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(5438), lang.NewKeyword("end-column"), int(26)) +v28, err := lang.WithMeta(v26, v27.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v25 any = v28 +_ = v25 +var v30 lang.FnFunc +v30 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v31 := args[0] +var v32 any +if lang.IsTruthy(v31) { +var v33 any +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("instance?")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.Apply(v36, []any{nil, v31}) +if lang.IsTruthy(v37) { +v38 := lang.Apply(v25, []any{v5, v31}) +v33 = v38 +} else { +var v39 any +func() { +defer func() { +if r := recover(); r != nil { +if lang.CatchMatches(r, lang.Builtins["any"]) { +v40 := r +_ = v40 +v41 := lang.Apply(v25, []any{v5, v40}) +v39 = v41 +} else { +panic(r) +} +} +}() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("seq")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v31}) +var v40 any = v44 +_ = v40 +var v45 any = v40 +_ = v45 +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("seq")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +} +v49 := v48.Get() +v50 := lang.Apply(v49, []any{v45}) +var v46 any = v50 +_ = v46 +v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v53 := v52.FindInternedVar(lang.NewSymbol("first")) +if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) +} +v54 := v53.Get() +v55 := lang.Apply(v54, []any{v46}) +var v51 any = v55 +_ = v51 +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("next")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +} +v59 := v58.Get() +v60 := lang.Apply(v59, []any{v56}) +var v56 any = v60 +_ = v56 +var v61 any = v51 +_ = v61 +var v62 any = v56 +_ = v62 +var v63 any = v45 +_ = v63 +var v65 any = v65 +_ = v65 +var v66 any +for { +var v67 any = v65 +_ = v67 +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("seq")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +} +v71 := v70.Get() +v72 := lang.Apply(v71, []any{v67}) +var v68 any = v72 +_ = v68 +v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v75 := v74.FindInternedVar(lang.NewSymbol("first")) +if v75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) +} +v76 := v75.Get() +v77 := lang.Apply(v76, []any{v68}) +var v73 any = v77 +_ = v73 +v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v80 := v79.FindInternedVar(lang.NewSymbol("next")) +if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) +} +v81 := v80.Get() +v82 := lang.Apply(v81, []any{v78}) +var v78 any = v82 +_ = v78 +var v83 any = v73 +_ = v83 +var v84 any = v78 +_ = v84 +var v85 any = v67 +_ = v85 +var v87 any +if lang.IsTruthy(v85) { +var v88 any +var v89 any +v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v91 := v90.FindInternedVar(lang.NewSymbol("nil?")) +if v91.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) +} +v92 := v91.Get() +v93 := lang.Apply(v92, []any{v83}) +if lang.IsTruthy(v93) { +v89 = v16 +} else { +v89 = v83 +} +v94, _ := lang.FieldOrMethod(v5, "offer") +if reflect.TypeOf(v94).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("offer is not a function"))) +} +v95 := lang.Apply(v94, []any{v89}) +if lang.IsTruthy(v95) { +var v96 any = v84 +v65 = v96 +continue +} else { +v88 = v85 +} +v87 = v88 +} else { +var v97 any +v98, _ := lang.FieldOrMethod(v5, "offer") +if reflect.TypeOf(v98).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("offer is not a function"))) +} +v99 := lang.Apply(v98, []any{v5}) +if lang.IsTruthy(v99) { +v97 = nil +} else { +v97 = lang.NewList() +} +v87 = v97 +} +v66 = v87 + break +} +v39 = v66 +}() +v33 = v39 +} +v32 = v33 +} else { +v32 = nil +} +return v32 +}) +v31 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5439), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(5452), lang.NewKeyword("end-column"), int(44)) +v32, err := lang.WithMeta(v30, v31.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v29 any = v32 +_ = v29 +var v34 lang.FnFunc +{ // function drain +v34 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +var v36 lang.FnFunc +v36 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v38, ok := lang.FieldOrMethod(v5, "take") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "take"))) +} +var v39 any +switch reflect.TypeOf(v38).Kind() { +case reflect.Func: + v39 = lang.Apply(v38, nil) +default: + v39 = v38 +} +var v37 any = v39 +_ = v37 +var v41 any +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("identical?")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +} +v44 := v43.Get() +v45 := lang.Apply(v44, []any{v37, v5}) +if lang.IsTruthy(v45) { +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("deref")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +} +v48 := v47.Get() +v49 := lang.Apply(v48, []any{v18}) +_ = v49 +v41 = nil +} else { +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("send-off")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +} +v52 := v51.Get() +v53 := lang.Apply(v52, []any{v18, v29}) +_ = v53 +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("release-pending-sends")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +} +v56 := v55.Get() +v57 := lang.Apply(v56, nil) +_ = v57 +v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v59 := v58.FindInternedVar(lang.NewSymbol("cons")) +if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) +} +v60 := v59.Get() +var v61 any +v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v63 := v62.FindInternedVar(lang.NewSymbol("identical?")) +if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +} +v64 := v63.Get() +v65 := lang.Apply(v64, []any{v37, v16}) +if lang.IsTruthy(v65) { +v61 = nil +} else { +v61 = v37 +} +v66 := lang.Apply(v35, nil) +v67 := lang.Apply(v60, []any{v61, v66}) +v41 = v67 +} +return v41 +}) +v37 := lang.Apply(lang1.NewLazySeq, []any{v36}) +return v37 +}) +v35 := v34 +_ = v35 +} +v35 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5453), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(5461), lang.NewKeyword("end-column"), int(73)) +v36, err := lang.WithMeta(v34, v35.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v33 any = v36 +_ = v33 +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("send-off")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.Apply(v40, []any{v18, v29}) +_ = v41 +v42 := lang.Apply(v33, nil) +return v42 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// load-file +{ +v0 := lang.NewSymbol("load-file").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, nil, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// unchecked-dec +{ +var v1 lang.FnFunc +{ // function unchecked-dec__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/unchecked_dec")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v3}) +v35 := lang.Apply(v26, []any{v30, v34}) +v36 := lang.Apply(v23, []any{v35}) +v37 := lang.Apply(v20, []any{v36}) +v38 := lang.Apply(v9, []any{v13, v17, v37}) +v39 := lang.Apply(v6, []any{v38}) +return v39 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("unchecked-dec").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns a number one less than x, a long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1175), lang.NewKeyword("end-line"), int(1175))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "unchecked_dec") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_dec is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// volatile? +{ +v0 := lang.NewSymbol("volatile?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is a volatile.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2540), lang.NewKeyword("end-line"), int(2540))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{lang1.Volatile, v3}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// parse-uuid +{ +v0 := lang.NewSymbol("parse-uuid").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse a string representing a UUID and return a java.util.UUID instance,\n or nil if parse fails.\n\n Grammar: https://docs.oracle.com/javase/8/docs/api/java/util/UUID.html#toString--", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7999), lang.NewKeyword("end-line"), int(7999))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +var v4 any +func() { +defer func() { +if r := recover(); r != nil { +if lang.CatchMatches(r, nil) { +v5 := r +_ = v5 +v4 = nil +} else { +panic(r) +} +} +}() +v5 := lang.Apply(nil, []any{v3}) +v4 = v5 +}() +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// *ns* +{ +v0 := lang.NewSymbol("*ns*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "A glojure.lang.Namespace object representing the current namespace.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// resultset-seq +{ +v0 := lang.NewSymbol("resultset-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rs"))), lang.NewKeyword("doc"), "Creates and returns a lazy sequence of structmaps corresponding to\n the rows in the java.sql.ResultSet rs", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5724), lang.NewKeyword("end-line"), int(5724))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v5, _ := lang.FieldOrMethod(v3, "getMetaData") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getMetaData is not a function"))) +} +v6 := lang.Apply(v5, []any{}) +var v4 any = v6 +_ = v4 +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("range")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("inc")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14, _ := lang.FieldOrMethod(v4, "getColumnCount") +if reflect.TypeOf(v14).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getColumnCount is not a function"))) +} +v15 := lang.Apply(v14, []any{}) +v16 := lang.Apply(v13, []any{v15}) +v17 := lang.Apply(v10, []any{int64(1), v16}) +var v7 any = v17 +_ = v7 +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("map")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("comp")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("keyword")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +var v28 lang.FnFunc +v28 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v29 := args[0] +v30, ok := lang.FieldOrMethod(v29, "toLowerCase") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v29, "toLowerCase"))) +} +var v31 any +switch reflect.TypeOf(v30).Kind() { +case reflect.Func: + v31 = lang.Apply(v30, nil) +default: + v31 = v30 +} +return v31 +}) +v29 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5731), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(5731), lang.NewKeyword("end-column"), int(62)) +v30, err := lang.WithMeta(v28, v29.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v31 := lang.Apply(v24, []any{v27, v30}) +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("map")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +var v35 lang.FnFunc +v35 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v36 := args[0] +v37, _ := lang.FieldOrMethod(v4, "getColumnLabel") +if reflect.TypeOf(v37).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getColumnLabel is not a function"))) +} +v38 := lang.Apply(v37, []any{v36}) +return v38 +}) +v36 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5732), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(5732), lang.NewKeyword("end-column"), int(63)) +v37, err := lang.WithMeta(v35, v36.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v38 := lang.Apply(v34, []any{v37, v7}) +v39 := lang.Apply(v21, []any{v31, v38}) +var v18 any = v39 +_ = v18 +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("apply")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +} +v44 := v43.Get() +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("distinct?")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +} +v47 := v46.Get() +v48 := lang.Apply(v44, []any{v47, v18}) +var v41 any = v48 +_ = v41 +var v50 any +if lang.IsTruthy(v41) { +v50 = v41 +} else { +v51 := lang.Apply(Exception25., []any{"ResultSet must have unique column labels"}) +panic(v51) +} +var v40 any = v50 +_ = v40 +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("apply")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +} +v44 := v43.Get() +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("create-struct")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +} +v47 := v46.Get() +v48 := lang.Apply(v44, []any{v47, v18}) +var v41 any = v48 +_ = v41 +var v50 lang.FnFunc +v50 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v52 := v51.FindInternedVar(lang.NewSymbol("map")) +if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) +} +v53 := v52.Get() +var v54 lang.FnFunc +v54 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v55 := args[0] +v56, _ := lang.FieldOrMethod(v3, "getObject") +if reflect.TypeOf(v56).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getObject is not a function"))) +} +v57 := lang.Apply(v56, []any{v55}) +return v57 +}) +v55 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5737), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(5737), lang.NewKeyword("end-column"), int(71)) +v56, err := lang.WithMeta(v54, v55.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v57 := lang.Apply(v53, []any{v56, v7}) +return v57 +}) +v51 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5737), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(5737), lang.NewKeyword("end-column"), int(78)) +v52, err := lang.WithMeta(v50, v51.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v49 any = v52 +_ = v49 +var v54 lang.FnFunc +{ // function thisfn +v54 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +var v56 any +v57, _ := lang.FieldOrMethod(v3, "next") +if reflect.TypeOf(v57).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("next is not a function"))) +} +v58 := lang.Apply(v57, []any{}) +if lang.IsTruthy(v58) { +v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v60 := v59.FindInternedVar(lang.NewSymbol("cons")) +if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) +} +v61 := v60.Get() +v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v63 := v62.FindInternedVar(lang.NewSymbol("apply")) +if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +} +v64 := v63.Get() +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("struct")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +} +v67 := v66.Get() +v68 := lang.Apply(v49, nil) +v69 := lang.Apply(v64, []any{v67, v41, v68}) +var v70 lang.FnFunc +v70 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v71 := lang.Apply(v55, nil) +return v71 +}) +v71 := lang.Apply(lang1.NewLazySeq, []any{v70}) +v72 := lang.Apply(v61, []any{v69, v71}) +v56 = v72 +} else { +v56 = nil +} +return v56 +}) +v55 := v54 +_ = v55 +} +v55 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5738), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(5740), lang.NewKeyword("end-column"), int(86)) +v56, err := lang.WithMeta(v54, v55.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v53 any = v56 +_ = v53 +v58 := lang.Apply(v53, nil) +return v58 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// aget +{ +var v1 lang.FnFunc +{ // function aget__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("concat")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("list")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("seq")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("concat")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("list")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/Aget")}) +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("seq")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +} +v41 := v40.Get() +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("concat")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +} +v44 := v43.Get() +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("list")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +} +v47 := v46.Get() +v48 := lang.Apply(v47, []any{lang.NewSymbol("glojure.core/int")}) +v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v50 := v49.FindInternedVar(lang.NewSymbol("list")) +if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) +} +v51 := v50.Get() +v52 := lang.Apply(v51, []any{v4}) +v53 := lang.Apply(v44, []any{v48, v52}) +v54 := lang.Apply(v41, []any{v53}) +v55 := lang.Apply(v38, []any{v54}) +v56 := lang.Apply(v27, []any{v31, v35, v55}) +v57 := lang.Apply(v24, []any{v56}) +v58 := lang.Apply(v21, []any{v57}) +v59 := lang.Apply(v10, []any{v14, v18, v58}) +v60 := lang.Apply(v7, []any{v59}) +return v60 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("aget").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("&"), lang.NewSymbol("idxs"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the value at the index/indices. Works on Java arrays of all\n types.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3911), lang.NewKeyword("end-line"), int(3911))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v4 := args[0] +v5 := args[1] +v6 := lang.Apply(lang1.Get, []any{v4, v5}) +return v6 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := args[1] +v6 := lang.NewList(args[2:]...) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("apply")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("aget")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("aget")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v4, v5}) +v17 := lang.Apply(v9, []any{v12, v16, v6}) +return v17 + } +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// sequence +{ +v0 := lang.NewSymbol("sequence").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("coll"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Coerces coll to a (possibly empty) sequence, if it is not already\n one. Will not force a lazy seq. (sequence nil) yields (), When a\n transducer is supplied, returns a lazy sequence of applications of\n the transform to the items in coll(s), i.e. to the set of first\n items of each coll, followed by the set of second\n items in each coll, until any one of the colls is exhausted. Any\n remaining items in other colls are ignored. The transform should accept\n number-of-colls arguments", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2639), lang.NewKeyword("end-line"), int(2639))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +if lang.IsTruthy(v8) { +v4 = v3 +} else { +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("seq")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{v3}) +var v9 any = v13 +_ = v9 +var v15 any +if lang.IsTruthy(v9) { +v15 = v9 +} else { +v15 = lang.NewList() +} +v4 = v15 +} +return v4 + case 2: +v3 := args[0] +v4 := args[1] +v6 := lang.Apply(nil, []any{v4}) +v7 := lang.Apply(nil, []any{v3, v6}) +v8 := lang.Apply(nil, []any{v7}) +var v5 any = v8 +_ = v5 +var v10 any +if lang.IsTruthy(v5) { +v10 = v5 +} else { +v10 = lang.NewList() +} +return v10 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("map")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +var v10 lang.FnFunc +v10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v11 := args[0] +v12 := lang.Apply(nil, []any{v11}) +return v12 +}) +v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2661), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(2661), lang.NewKeyword("end-column"), int(41)) +v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("cons")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v4, v5}) +v17 := lang.Apply(v9, []any{v12, v16}) +v18 := lang.Apply(nil, []any{v3, v17}) +v19 := lang.Apply(nil, []any{v18}) +var v6 any = v19 +_ = v6 +var v21 any +if lang.IsTruthy(v6) { +v21 = v6 +} else { +v21 = lang.NewList() +} +return v21 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// drop-while +{ +v0 := lang.NewSymbol("drop-while").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred")), lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the items in coll starting from the\n first item for which (pred item) returns logical false. Returns a\n stateful transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2950), lang.NewKeyword("end-line"), int(2950))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("volatile!")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{true}) +var v6 any = v10 +_ = v6 +var v12 lang.FnFunc +v12 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v13 := lang.Apply(v5, nil) +return v13 + case 1: +v13 := args[0] +v14 := lang.Apply(v5, []any{v13}) +return v14 + case 2: +v13 := args[0] +v14 := args[1] +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("deref")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v6}) +var v15 any = v19 +_ = v15 +var v21 any +var v22 any = v15 +_ = v22 +var v24 any +if lang.IsTruthy(v22) { +v25 := lang.Apply(v3, []any{v14}) +v24 = v25 +} else { +v24 = v22 +} +if lang.IsTruthy(v24) { +v21 = v13 +} else { +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("vreset!")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v6, nil}) +_ = v25 +v26 := lang.Apply(v5, []any{v13, v14}) +v21 = v26 +} +return v21 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2959), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(2968), lang.NewKeyword("end-column"), int(42)) +v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v14 +}) +v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2957), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2968), lang.NewKeyword("end-column"), int(44)) +v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v6 + case 2: +v3 := args[0] +v4 := args[1] +var v6 lang.FnFunc +v6 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v7 := args[0] +v8 := args[1] +recur_loop_552: +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("seq")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{v8}) +var v9 any = v13 +_ = v9 +var v15 any +var v16 any = v9 +_ = v16 +var v18 any +if lang.IsTruthy(v16) { +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("first")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v9}) +v23 := lang.Apply(v7, []any{v22}) +v18 = v23 +} else { +v18 = v16 +} +if lang.IsTruthy(v18) { +var v16 any = v7 +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("rest")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, []any{v9}) +var v17 any = v21 +v7 = v16 +v8 = v17 +goto recur_loop_552 +} else { +v15 = v9 +} +return v15 +}) +v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2970), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(2974), lang.NewKeyword("end-column"), int(26)) +v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v5 any = v8 +_ = v5 +var v10 lang.FnFunc +v10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v11 := lang.Apply(v5, []any{v3, v4}) +return v11 +}) +v11 := lang.Apply(lang1.NewLazySeq, []any{v10}) +return v11 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// chunk-next +{ +v0 := lang.NewSymbol("chunk-next").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(700), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(700), lang.NewKeyword("end-column"), int(71), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, ok := lang.FieldOrMethod(v3, "chunkedNext") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "chunkedNext"))) +} +var v5 any +switch reflect.TypeOf(v4).Kind() { +case reflect.Func: + v5 = lang.Apply(v4, nil) +default: + v5 = v4 +} +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// list? +{ +v0 := lang.NewSymbol("list?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements IPersistentList", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6241), lang.NewKeyword("end-line"), int(6241))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{lang1.IPersistentList, v3}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// global-hierarchy +{ +v0 := lang.NewSymbol("global-hierarchy").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5556), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(5557), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, lang.NewMap(lang.NewKeyword("parents"), lang.NewMap(), lang.NewKeyword("descendants"), lang.NewMap(), lang.NewKeyword("ancestors"), lang.NewMap()), true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// int-array +{ +var v1 lang.FnFunc +{ // function int-array__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.NewList(args[0:]...) +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/intArray")}) +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("list")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("seq")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("concat")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("list")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v37, []any{lang.NewSymbol("glojure.core/args")}) +v39 := lang.Apply(v30, []any{v34, v38}) +v40 := lang.Apply(v27, []any{v39}) +v41 := lang.Apply(v24, []any{v40}) +v42 := lang.Apply(v9, []any{v13, v17, v21, v41}) +v43 := lang.Apply(v6, []any{v42}) +return v43 + } +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("int-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Creates an array of ints", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5356), lang.NewKeyword("end-line"), int(5356))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "intArray") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("intArray is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 + case 2: +v4 := args[0] +v5 := args[1] +v6, _ := lang.FieldOrMethod(lang1.Numbers, "intArrayInit") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("intArrayInit is not a function"))) +} +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// emit-extend-protocol +{ +v0 := lang.NewSymbol("emit-extend-protocol").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(205), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(205), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("p"), lang.NewSymbol("specs"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("parse-impls")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v4}) +var v5 any = v9 +_ = v5 +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("seq")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("concat")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("list")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v19, []any{lang.NewSymbol("do")}) +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("map")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +var v24 lang.FnFunc +v24 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v25 := args[0] +var v26 any = v25 +_ = v26 +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("nth")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{v26, int64(0), nil}) +var v27 any = v31 +_ = v27 +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("nth")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v26, int64(1), nil}) +var v32 any = v36 +_ = v32 +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("seq")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("concat")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{lang.NewSymbol("glojure.core/extend-type")}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v27}) +v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v53 := v52.FindInternedVar(lang.NewSymbol("list")) +if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) +} +v54 := v53.Get() +v55 := lang.Apply(v54, []any{v3}) +v56 := lang.Apply(v43, []any{v47, v51, v55, v32}) +v57 := lang.Apply(v40, []any{v56}) +return v57 +}) +v25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(208), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(209), lang.NewKeyword("end-column"), int(42)) +v26, err := lang.WithMeta(v24, v25.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v27 := lang.Apply(v23, []any{v26, v5}) +v28 := lang.Apply(v16, []any{v20, v27}) +v29 := lang.Apply(v13, []any{v28}) +return v29 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// aset-double +{ +v0 := lang.NewSymbol("aset-double").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of double. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3966), lang.NewKeyword("end-line"), int(3968))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("double")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v5}) +v10, _ := lang.FieldOrMethod(nil, "setDouble") +if reflect.TypeOf(v10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setDouble is not a function"))) +} +v11 := lang.Apply(v10, []any{v3, v4, v9}) +_ = v11 +return v5 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("apply")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("aset-double")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("aget")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v3, v4}) +v17 := lang.Apply(v9, []any{v12, v16, v5, v6}) +return v17 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// promise +{ +v0 := lang.NewSymbol("promise").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Returns a promise object that can be read with deref/@, and set,\n once only, with deliver. Calls to deref/@ prior to delivery will\n block, unless the variant of deref with timeout is used. All\n subsequent derefs will return the same delivered value without\n blocking. See also - realized?.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7121), lang.NewKeyword("end-line"), int(7121))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := lang.Apply(java.util.concurrent.CountDownLatch32., []any{int64(1)}) +var v3 any = v4 +_ = v3 +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("atom")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v3}) +var v5 any = v9 +_ = v5 +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("deref")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.NewVector(nil) +v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7134), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(7134), lang.NewKeyword("end-column"), int(17)) +v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v17, ok := lang.FieldOrMethod(v3, "await") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "await"))) +} +var v18 any +switch reflect.TypeOf(v17).Kind() { +case reflect.Func: + v18 = lang.Apply(v17, nil) +default: + v18 = v17 +} +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("deref")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v5}) +v23 := lang.Apply(v13, []any{v16, v18, v22}) +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("deref")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.NewVector(nil, nil, nil) +v28 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7137), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(7137), lang.NewKeyword("end-column"), int(34)) +v29, err := lang.WithMeta(v27, v28.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v30 any +v31, _ := lang.FieldOrMethod(v3, "await") +if reflect.TypeOf(v31).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) +} +v32 := lang.Apply(v31, []any{nil, time30.Millisecond}) +if lang.IsTruthy(v32) { +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("deref")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v5}) +v30 = v36 +} else { +v30 = nil +} +v37 := lang.Apply(v26, []any{v29, v30}) +v38 := lang.NewVector(nil) +v39 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7142), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(7142), lang.NewKeyword("end-column"), int(24)) +v40, err := lang.WithMeta(v38, v39.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("zero?")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44, ok := lang.FieldOrMethod(v3, "getCount") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getCount"))) +} +var v45 any +switch reflect.TypeOf(v44).Kind() { +case reflect.Func: + v45 = lang.Apply(v44, nil) +default: + v45 = v44 +} +v46 := lang.Apply(v43, []any{v45}) +v47 := lang.Apply(nil, []any{v40, v46}) +v48 := lang.NewVector(nil, nil) +v49 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7146), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(7146), lang.NewKeyword("end-column"), int(14)) +v50, err := lang.WithMeta(v48, v49.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v51 any +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("pos?")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +} +v55 := v54.Get() +v56, ok := lang.FieldOrMethod(v3, "getCount") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getCount"))) +} +var v57 any +switch reflect.TypeOf(v56).Kind() { +case reflect.Func: + v57 = lang.Apply(v56, nil) +default: + v57 = v56 +} +v58 := lang.Apply(v55, []any{v57}) +var v52 any = v58 +_ = v52 +var v60 any +if lang.IsTruthy(v52) { +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("compare-and-set!")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +} +v63 := v62.Get() +v64 := lang.Apply(v63, []any{v5, v3, nil}) +v60 = v64 +} else { +v60 = v52 +} +if lang.IsTruthy(v60) { +v52, ok := lang.FieldOrMethod(v3, "countDown") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "countDown"))) +} +var v53 any +switch reflect.TypeOf(v52).Kind() { +case reflect.Func: + v53 = lang.Apply(v52, nil) +default: + v53 = v52 +} +_ = v53 +v51 = nil +} else { +v51 = nil +} +v54 := lang.Apply(nil, []any{v50, v51}) +v55 := lang.Apply(nil, []any{lang1.IDeref, v23, lang1.IBlockingDeref, v37, lang1.IPending, v47, glojure.lang11.IFn, v54}) +return v55 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// associative? +{ +v0 := lang.NewSymbol("associative?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements Associative", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6266), lang.NewKeyword("end-line"), int(6266))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{glojure.lang11.Associative, v3}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// push-thread-bindings +{ +v0 := lang.NewSymbol("push-thread-bindings").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"))), lang.NewKeyword("doc"), "WARNING: This is a low-level function. Prefer high-level macros like\n binding where ever possible.\n\n Takes a map of Var/value pairs. Binds each Var to the associated value for\n the current thread. Each call *MUST* be accompanied by a matching call to\n pop-thread-bindings wrapped in a try-finally!\n \n (push-thread-bindings bindings)\n (try\n ...\n (finally\n (pop-thread-bindings)))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(26), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1911), lang.NewKeyword("end-line"), int(1911))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.Apply(lang1.PushThreadBindings, []any{v3}) +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// comparator +{ +v0 := lang.NewSymbol("comparator").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"))), lang.NewKeyword("doc"), "Returns an implementation of java.util.Comparator based upon pred.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3077), lang.NewKeyword("end-line"), int(3077))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +v6 := args[1] +var v7 any +v8 := lang.Apply(v3, []any{v5, v6}) +if lang.IsTruthy(v8) { +v7 = int64(-1) +} else { +var v9 any +v10 := lang.Apply(v3, []any{v6, v5}) +if lang.IsTruthy(v10) { +v9 = int64(1) +} else { +var v11 any +if lang.IsTruthy(lang.NewKeyword("else")) { +v11 = int64(0) +} else { +v11 = nil +} +v9 = v11 +} +v7 = v9 +} +return v7 +}) +v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3082), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(3083), lang.NewKeyword("end-column"), int(48)) +v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v6 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// partition-all +{ +v0 := lang.NewSymbol("partition-all").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of lists like partition, but may include\n partitions with fewer than n items at the end. Returns a stateful\n transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7265), lang.NewKeyword("end-line"), int(7265))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +v7 := lang.Apply(java.util.ArrayList27., []any{v3}) +var v6 any = v7 +_ = v6 +var v9 lang.FnFunc +v9 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v10 := lang.Apply(v5, nil) +return v10 + case 1: +v10 := args[0] +var v12 any +v13, ok := lang.FieldOrMethod(v6, "isEmpty") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "isEmpty"))) +} +var v14 any +switch reflect.TypeOf(v13).Kind() { +case reflect.Func: + v14 = lang.Apply(v13, nil) +default: + v14 = v13 +} +if lang.IsTruthy(v14) { +v12 = v11 +} else { +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("vec")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19, ok := lang.FieldOrMethod(v6, "toArray") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "toArray"))) +} +var v20 any +switch reflect.TypeOf(v19).Kind() { +case reflect.Func: + v20 = lang.Apply(v19, nil) +default: + v20 = v19 +} +v21 := lang.Apply(v18, []any{v20}) +var v15 any = v21 +_ = v15 +v23, ok := lang.FieldOrMethod(v6, "clear") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "clear"))) +} +var v24 any +switch reflect.TypeOf(v23).Kind() { +case reflect.Func: + v24 = lang.Apply(v23, nil) +default: + v24 = v23 +} +_ = v24 +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("unreduced")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.Apply(v5, []any{v11, v15}) +v29 := lang.Apply(v27, []any{v28}) +v12 = v29 +} +var v11 any = v12 +_ = v11 +v16 := lang.Apply(v5, []any{v11}) +return v16 + case 2: +v10 := args[0] +v11 := args[1] +v12, _ := lang.FieldOrMethod(v6, "add") +if reflect.TypeOf(v12).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) +} +v13 := lang.Apply(v12, []any{v11}) +_ = v13 +var v14 any +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("=")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18, ok := lang.FieldOrMethod(v6, "size") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "size"))) +} +var v19 any +switch reflect.TypeOf(v18).Kind() { +case reflect.Func: + v19 = lang.Apply(v18, nil) +default: + v19 = v18 +} +v20 := lang.Apply(v17, []any{v3, v19}) +if lang.IsTruthy(v20) { +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("vec")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25, ok := lang.FieldOrMethod(v6, "toArray") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "toArray"))) +} +var v26 any +switch reflect.TypeOf(v25).Kind() { +case reflect.Func: + v26 = lang.Apply(v25, nil) +default: + v26 = v25 +} +v27 := lang.Apply(v24, []any{v26}) +var v21 any = v27 +_ = v21 +v29, ok := lang.FieldOrMethod(v6, "clear") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "clear"))) +} +var v30 any +switch reflect.TypeOf(v29).Kind() { +case reflect.Func: + v30 = lang.Apply(v29, nil) +default: + v30 = v29 +} +_ = v30 +v31 := lang.Apply(v5, []any{v10, v21}) +v14 = v31 +} else { +v14 = v10 +} +return v14 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7274), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7290), lang.NewKeyword("end-column"), int(23)) +v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v11 +}) +v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7272), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7290), lang.NewKeyword("end-column"), int(25)) +v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v6 + case 2: +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("partition-all")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3, v3, v4}) +return v8 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +var v6 lang.FnFunc +v6 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("seq")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v5}) +var v7 any = v11 +_ = v7 +var v13 any +if lang.IsTruthy(v7) { +var v14 any = v7 +_ = v14 +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("doall")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("take")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.Apply(v22, []any{v3, v14}) +v24 := lang.Apply(v19, []any{v23}) +var v16 any = v24 +_ = v16 +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("cons")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("partition-all")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("nthrest")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v14, v4}) +v36 := lang.Apply(v31, []any{v3, v4, v35}) +v37 := lang.Apply(v28, []any{v16, v36}) +v13 = v37 +} else { +v13 = nil +} +return v13 +}) +v7 := lang.Apply(lang1.NewLazySeq, []any{v6}) +return v7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// *print-level* +{ +v0 := lang.NewSymbol("*print-level*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(25), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(35), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, nil, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// merge +{ +v0 := lang.NewSymbol("merge").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("maps"))), lang.NewKeyword("doc"), "Returns a map that consists of the rest of the maps conj-ed onto\n the first. If a key occurs in more than one map, the mapping from\n the latter (left-to-right) will be the mapping in the result.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3040), lang.NewKeyword("end-line"), int(3040))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.NewList(args[0:]...) +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("some")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("identity")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v7, []any{v10, v3}) +if lang.IsTruthy(v11) { +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("reduce1")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +var v15 lang.FnFunc +v15 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v16 := args[0] +v17 := args[1] +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("conj")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +var v21 any = v16 +_ = v21 +var v23 any +if lang.IsTruthy(v21) { +v23 = v21 +} else { +v24 := lang.NewMap() +v25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3048), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(3048), lang.NewKeyword("end-column"), int(29)) +v26, err := lang.WithMeta(v24, v25.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v23 = v26 +} +v21 := lang.Apply(v20, []any{v23, v17}) +return v21 +}) +v16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3048), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(3048), lang.NewKeyword("end-column"), int(34)) +v17, err := lang.WithMeta(v15, v16.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v18 := lang.Apply(v14, []any{v17, v3}) +v4 = v18 +} else { +v4 = nil +} +return v4 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// take-nth +{ +v0 := lang.NewSymbol("take-nth").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy seq of every nth item in coll. Returns a stateful\n transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4287), lang.NewKeyword("end-line"), int(4287))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("volatile!")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{int64(-1)}) +var v6 any = v10 +_ = v6 +var v12 lang.FnFunc +v12 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v13 := lang.Apply(v5, nil) +return v13 + case 1: +v13 := args[0] +v14 := lang.Apply(v5, []any{v13}) +return v14 + case 2: +v13 := args[0] +v14 := args[1] +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("inc")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19, ok := lang.FieldOrMethod(v6, "Deref") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "Deref"))) +} +var v20 any +switch reflect.TypeOf(v19).Kind() { +case reflect.Func: + v20 = lang.Apply(v19, nil) +default: + v20 = v19 +} +v21 := lang.Apply(v18, []any{v20}) +v22, _ := lang.FieldOrMethod(v6, "reset") +if reflect.TypeOf(v22).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) +} +v23 := lang.Apply(v22, []any{v21}) +var v15 any = v23 +_ = v15 +var v25 any +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("zero?")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("rem")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.Apply(v31, []any{v15, v3}) +v33 := lang.Apply(v28, []any{v32}) +if lang.IsTruthy(v33) { +v34 := lang.Apply(v5, []any{v13, v14}) +v25 = v34 +} else { +v25 = v13 +} +return v25 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4295), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(4302), lang.NewKeyword("end-column"), int(28)) +v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v14 +}) +v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4293), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(4302), lang.NewKeyword("end-column"), int(30)) +v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v6 + case 2: +v3 := args[0] +v4 := args[1] +var v5 lang.FnFunc +v5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("seq")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v4}) +var v6 any = v10 +_ = v6 +var v12 any +if lang.IsTruthy(v6) { +var v13 any = v6 +_ = v13 +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("cons")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("first")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, []any{v13}) +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("take-nth")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("drop")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.Apply(v27, []any{v3, v13}) +v29 := lang.Apply(v24, []any{v3, v28}) +v30 := lang.Apply(v17, []any{v21, v29}) +v12 = v30 +} else { +v12 = nil +} +return v12 +}) +v6 := lang.Apply(lang1.NewLazySeq, []any{v5}) +return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// false? +{ +v1 := reflect.TypeOf(false) +v0 := lang.NewSymbol("false?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is the value false, false otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(504), lang.NewKeyword("end-line"), int(504))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := lang.Apply(lang1.Identical, []any{v4, false}) +return v5 +}) +v4 := reflect.TypeOf(false) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// sort +{ +v0 := lang.NewSymbol("sort").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("comp"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a sorted sequence of the items in coll. If no comparator is\n supplied, uses compare. comparator must implement\n java.util.Comparator. Guaranteed to be stable: equal elements will\n not be reordered. If coll is a Java array, it will be modified. To\n avoid this, sort a copy of the array.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3085), lang.NewKeyword("end-line"), int(3085))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("sort")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("compare")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v6, []any{v9, v3}) +return v10 + case 2: +v3 := args[0] +v4 := args[1] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("seq")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v4}) +if lang.IsTruthy(v9) { +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("to-array")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v4}) +var v10 any = v14 +_ = v10 +v16 := lang.Apply(lang1.SortSlice, []any{v10, v3}) +_ = v16 +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("with-meta")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("seq")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.Apply(v22, []any{v10}) +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("meta")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v4}) +v28 := lang.Apply(v19, []any{v23, v27}) +v5 = v28 +} else { +v5 = lang.NewList() +} +return v5 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// max-key +{ +v0 := lang.NewSymbol("max-key").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Returns the x for which (k x), a number, is greatest.\n\n If there are multiple such xs, the last one is returned.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5013), lang.NewKeyword("end-line"), int(5013))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v3 := args[0] +v4 := args[1] +return v4 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +var v6 any +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol(">")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v3, []any{v4}) +v11 := lang.Apply(v3, []any{v5}) +v12 := lang.Apply(v9, []any{v10, v11}) +if lang.IsTruthy(v12) { +v6 = v4 +} else { +v6 = v5 +} +return v6 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v8 := lang.Apply(v3, []any{v4}) +var v7 any = v8 +_ = v7 +v10 := lang.Apply(v3, []any{v5}) +var v9 any = v10 +_ = v9 +var v12 any +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol(">")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v7, v9}) +if lang.IsTruthy(v16) { +v17 := lang.NewVector(v4, v7) +v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5023), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(5023), lang.NewKeyword("end-column"), int(36)) +v19, err := lang.WithMeta(v17, v18.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v12 = v19 +} else { +v20 := lang.NewVector(v5, v9) +v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5023), lang.NewKeyword("column"), int(38), lang.NewKeyword("end-line"), int(5023), lang.NewKeyword("end-column"), int(43)) +v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v12 = v22 +} +var v11 any = v12 +_ = v11 +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("nth")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v11, int64(0), nil}) +var v23 any = v27 +_ = v23 +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("nth")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.Apply(v31, []any{v11, int64(1), nil}) +var v28 any = v32 +_ = v28 +var v34 any = v34 +_ = v34 +var v35 any = v35 +_ = v35 +var v36 any = v36 +_ = v36 +var v37 any +for { +var v38 any +if lang.IsTruthy(v36) { +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("first")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v36}) +var v39 any = v43 +_ = v39 +v45 := lang.Apply(v3, []any{v39}) +var v44 any = v45 +_ = v44 +var v47 any +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol(">=")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v44, v35}) +if lang.IsTruthy(v51) { +var v52 any = v39 +var v53 any = v44 +v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v56 := v55.FindInternedVar(lang.NewSymbol("next")) +if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) +} +v57 := v56.Get() +v58 := lang.Apply(v57, []any{v36}) +var v54 any = v58 +v34 = v52 +v35 = v53 +v36 = v54 +continue +} else { +var v59 any = v34 +var v60 any = v35 +v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v63 := v62.FindInternedVar(lang.NewSymbol("next")) +if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +} +v64 := v63.Get() +v65 := lang.Apply(v64, []any{v36}) +var v61 any = v65 +v34 = v59 +v35 = v60 +v36 = v61 +continue +} +v38 = v47 +} else { +v38 = v34 +} +v37 = v38 + break +} +return v37 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// some +{ +v0 := lang.NewSymbol("some").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns the first logical true value of (pred x) for any x in coll,\n else nil. One common idiom is to use a set as pred, for example\n this will return :fred if :fred is in the sequence, otherwise nil:\n (some #{:fred} coll)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2684), lang.NewKeyword("end-line"), int(2684))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +recur_loop_481: +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("seq")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v4}) +var v5 any = v9 +_ = v5 +var v11 any +if lang.IsTruthy(v5) { +var v12 any = v5 +_ = v12 +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("first")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v12}) +v19 := lang.Apply(v3, []any{v18}) +var v14 any = v19 +_ = v14 +var v21 any +if lang.IsTruthy(v14) { +v21 = v14 +} else { +var v22 any = v3 +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("next")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v12}) +var v23 any = v27 +v3 = v22 +v4 = v23 +goto recur_loop_481 +} +v11 = v21 +} else { +v11 = nil +} +return v11 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// make-hierarchy +{ +v0 := lang.NewSymbol("make-hierarchy").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Creates a hierarchy object for use with derive, isa? etc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5550), lang.NewKeyword("end-line"), int(5550))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.NewMap() +v4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5554), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(5554), lang.NewKeyword("end-column"), int(17)) +v5, err := lang.WithMeta(v3, v4.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v6 := lang.NewMap() +v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5554), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(5554), lang.NewKeyword("end-column"), int(33)) +v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v9 := lang.NewMap() +v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5554), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(5554), lang.NewKeyword("end-column"), int(47)) +v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v12 := lang.NewMap(lang.NewKeyword("parents"), v5, lang.NewKeyword("descendants"), v8, lang.NewKeyword("ancestors"), v11) +v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5554), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(5554), lang.NewKeyword("end-column"), int(48)) +v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v14 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// assert-args +{ +v0 := lang.NewSymbol("assert-args").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("pairs"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(38), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1830), lang.NewKeyword("end-line"), int(1830), lang.NewKeyword("private"), true)).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("seq")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("concat")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("list")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{lang.NewSymbol("do")}) +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("list")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("seq")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("concat")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("list")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.Apply(v27, []any{lang.NewSymbol("glojure.core/when-not")}) +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("list")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("first")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v5}) +v36 := lang.Apply(v31, []any{v35}) +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("list")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("seq")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("concat")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +} +v45 := v44.Get() +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("list")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +} +v48 := v47.Get() +v49 := lang.Apply(v48, []any{lang.NewSymbol("throw")}) +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("list")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +} +v52 := v51.Get() +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("seq")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +} +v55 := v54.Get() +v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v57 := v56.FindInternedVar(lang.NewSymbol("concat")) +if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) +} +v58 := v57.Get() +v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v60 := v59.FindInternedVar(lang.NewSymbol("list")) +if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) +} +v61 := v60.Get() +v62 := lang.Apply(v61, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewIllegalArgumentError")}) +v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v64 := v63.FindInternedVar(lang.NewSymbol("list")) +if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) +} +v65 := v64.Get() +v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v67 := v66.FindInternedVar(lang.NewSymbol("seq")) +if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) +} +v68 := v67.Get() +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("concat")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +} +v71 := v70.Get() +v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v73 := v72.FindInternedVar(lang.NewSymbol("list")) +if v73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) +} +v74 := v73.Get() +v75 := lang.Apply(v74, []any{lang.NewSymbol("glojure.core/str")}) +v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v77 := v76.FindInternedVar(lang.NewSymbol("list")) +if v77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) +} +v78 := v77.Get() +v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v80 := v79.FindInternedVar(lang.NewSymbol("seq")) +if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) +} +v81 := v80.Get() +v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v83 := v82.FindInternedVar(lang.NewSymbol("concat")) +if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) +} +v84 := v83.Get() +v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v86 := v85.FindInternedVar(lang.NewSymbol("list")) +if v86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) +} +v87 := v86.Get() +v88 := lang.Apply(v87, []any{lang.NewSymbol("glojure.core/first")}) +v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v90 := v89.FindInternedVar(lang.NewSymbol("list")) +if v90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) +} +v91 := v90.Get() +v92 := lang.Apply(v91, []any{lang.NewSymbol("&form")}) +v93 := lang.Apply(v84, []any{v88, v92}) +v94 := lang.Apply(v81, []any{v93}) +v95 := lang.Apply(v78, []any{v94}) +v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v97 := v96.FindInternedVar(lang.NewSymbol("list")) +if v97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) +} +v98 := v97.Get() +v99 := lang.Apply(v98, []any{" requires "}) +v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v101 := v100.FindInternedVar(lang.NewSymbol("list")) +if v101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) +} +v102 := v101.Get() +v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v104 := v103.FindInternedVar(lang.NewSymbol("second")) +if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) +} +v105 := v104.Get() +v106 := lang.Apply(v105, []any{v5}) +v107 := lang.Apply(v102, []any{v106}) +v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v109 := v108.FindInternedVar(lang.NewSymbol("list")) +if v109.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) +} +v110 := v109.Get() +v111 := lang.Apply(v110, []any{" in "}) +v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v113 := v112.FindInternedVar(lang.NewSymbol("list")) +if v113.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) +} +v114 := v113.Get() +v115 := lang.Apply(v114, []any{lang.NewSymbol("*ns*")}) +v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v117 := v116.FindInternedVar(lang.NewSymbol("list")) +if v117.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) +} +v118 := v117.Get() +v119 := lang.Apply(v118, []any{":"}) +v120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v121 := v120.FindInternedVar(lang.NewSymbol("list")) +if v121.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v121))) +} +v122 := v121.Get() +v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v124 := v123.FindInternedVar(lang.NewSymbol("seq")) +if v124.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) +} +v125 := v124.Get() +v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v127 := v126.FindInternedVar(lang.NewSymbol("concat")) +if v127.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) +} +v128 := v127.Get() +v129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v130 := v129.FindInternedVar(lang.NewSymbol("list")) +if v130.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v130))) +} +v131 := v130.Get() +v132 := lang.Apply(v131, []any{lang.NewKeyword("line")}) +v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v134 := v133.FindInternedVar(lang.NewSymbol("list")) +if v134.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) +} +v135 := v134.Get() +v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v137 := v136.FindInternedVar(lang.NewSymbol("seq")) +if v137.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) +} +v138 := v137.Get() +v139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v140 := v139.FindInternedVar(lang.NewSymbol("concat")) +if v140.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v140))) +} +v141 := v140.Get() +v142 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v143 := v142.FindInternedVar(lang.NewSymbol("list")) +if v143.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v143))) +} +v144 := v143.Get() +v145 := lang.Apply(v144, []any{lang.NewSymbol("glojure.core/meta")}) +v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v147 := v146.FindInternedVar(lang.NewSymbol("list")) +if v147.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) +} +v148 := v147.Get() +v149 := lang.Apply(v148, []any{lang.NewSymbol("&form")}) +v150 := lang.Apply(v141, []any{v145, v149}) +v151 := lang.Apply(v138, []any{v150}) +v152 := lang.Apply(v135, []any{v151}) +v153 := lang.Apply(v128, []any{v132, v152}) +v154 := lang.Apply(v125, []any{v153}) +v155 := lang.Apply(v122, []any{v154}) +v156 := lang.Apply(v71, []any{v75, v95, v99, v107, v111, v115, v119, v155}) +v157 := lang.Apply(v68, []any{v156}) +v158 := lang.Apply(v65, []any{v157}) +v159 := lang.Apply(v58, []any{v62, v158}) +v160 := lang.Apply(v55, []any{v159}) +v161 := lang.Apply(v52, []any{v160}) +v162 := lang.Apply(v45, []any{v49, v161}) +v163 := lang.Apply(v42, []any{v162}) +v164 := lang.Apply(v39, []any{v163}) +v165 := lang.Apply(v24, []any{v28, v36, v164}) +v166 := lang.Apply(v21, []any{v165}) +v167 := lang.Apply(v18, []any{v166}) +v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v169 := v168.FindInternedVar(lang.NewSymbol("list")) +if v169.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) +} +v170 := v169.Get() +v172 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v173 := v172.FindInternedVar(lang.NewSymbol("nnext")) +if v173.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v173))) +} +v174 := v173.Get() +v175 := lang.Apply(v174, []any{v5}) +var v171 any = v175 +_ = v171 +var v177 any +if lang.IsTruthy(v171) { +v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v179 := v178.FindInternedVar(lang.NewSymbol("list*")) +if v179.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) +} +v180 := v179.Get() +v181 := lang.Apply(v180, []any{lang.NewSymbol("glojure.core/assert-args"), v171}) +v177 = v181 +} else { +v177 = nil +} +v171 := lang.Apply(v170, []any{v177}) +v172 := lang.Apply(v11, []any{v15, v167, v171}) +v173 := lang.Apply(v8, []any{v172}) +return v173 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// stream-reduce! +{ +v0 := lang.NewSymbol("stream-reduce!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("s")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Works like reduce but takes a java.util.stream.BaseStream as its source.\n Honors 'reduced', is a terminal operation on the stream", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6827), lang.NewKeyword("end-line"), int(6827))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v3 := args[0] +v4 := args[1] +v5, ok := lang.FieldOrMethod(v4, "iterator") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "iterator"))) +} +var v6 any +switch reflect.TypeOf(v5).Kind() { +case reflect.Func: + v6 = lang.Apply(v5, nil) +default: + v6 = v5 +} +v7 := lang.Apply(nil, []any{v6, v3}) +return v7 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6, ok := lang.FieldOrMethod(v5, "iterator") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "iterator"))) +} +var v7 any +switch reflect.TypeOf(v6).Kind() { +case reflect.Func: + v7 = lang.Apply(v6, nil) +default: + v7 = v6 +} +v8 := lang.Apply(nil, []any{v7, v3, v4}) +return v8 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// bytes? +{ +v0 := lang.NewSymbol("bytes?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a byte array", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5412), lang.NewKeyword("end-line"), int(5412))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("nil?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +if lang.IsTruthy(v8) { +v4 = false +} else { +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("=")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("class")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v3}) +v16, ok := lang.FieldOrMethod(v15, "getComponentType") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v15, "getComponentType"))) +} +var v17 any +switch reflect.TypeOf(v16).Kind() { +case reflect.Func: + v17 = lang.Apply(v16, nil) +default: + v17 = v16 +} +v18 := lang.Apply(v11, []any{v17, nil}) +v4 = v18 +} +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// when-not +{ +v0 := lang.NewSymbol("when-not").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("test"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Evaluates test. If logical false, evaluates body in an implicit do.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(498), lang.NewKeyword("end-line"), int(498))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("list")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("cons")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol("do"), v6}) +v14 := lang.Apply(v9, []any{lang.NewSymbol("if"), v5, nil, v13}) +return v14 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// seq? +{ +v0 := lang.NewSymbol("seq?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x implements ISeq", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(146), lang.NewKeyword("end-line"), int(150))).(*lang.Symbol) +var v2 lang.FnFunc +{ // function seq? +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{lang1.ISeq, v4}) +return v8 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(150), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(150), lang.NewKeyword("end-column"), int(87))).(lang.FnFunc) +v3 := v2 +_ = v3 +} +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// underive +{ +v0 := lang.NewSymbol("underive").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag"), lang.NewSymbol("parent")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"), lang.NewSymbol("parent"))), lang.NewKeyword("doc"), "Removes a parent/child relationship between parent and\n tag. h must be a hierarchy obtained from make-hierarchy, if not\n supplied defaults to, and modifies, the global hierarchy.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5686), lang.NewKeyword("end-line"), int(5686))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("alter-var-root")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("global-hierarchy")) +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("underive")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v7, []any{v8, v11, v3, v4}) +_ = v12 +return nil + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v7 := lang.Apply(lang.NewKeyword("parents"), []any{v3}) +var v6 any = v7 +_ = v6 +var v9 any +v10 := lang.Apply(v6, []any{v4}) +if lang.IsTruthy(v10) { +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("disj")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v6, []any{v4}) +v15 := lang.Apply(v13, []any{v14, v5}) +v9 = v15 +} else { +v16 := lang.CreatePersistentTreeSet() +v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5695), lang.NewKeyword("column"), int(36), lang.NewKeyword("end-line"), int(5695), lang.NewKeyword("end-column"), int(38)) +v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v9 = v18 +} +var v8 any = v9 +_ = v8 +var v20 any +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("not-empty")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v8}) +if lang.IsTruthy(v24) { +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("assoc")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.Apply(v27, []any{v6, v4, v8}) +v20 = v28 +} else { +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("dissoc")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.Apply(v31, []any{v6, v4}) +v20 = v32 +} +var v19 any = v20 +_ = v19 +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("flatten")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("map")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +var v40 lang.FnFunc +v40 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v41 := args[0] +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("cons")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +} +v44 := v43.Get() +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("key")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +} +v47 := v46.Get() +v48 := lang.Apply(v47, []any{v41}) +v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v50 := v49.FindInternedVar(lang.NewSymbol("interpose")) +if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) +} +v51 := v50.Get() +v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v53 := v52.FindInternedVar(lang.NewSymbol("key")) +if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) +} +v54 := v53.Get() +v55 := lang.Apply(v54, []any{v41}) +v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v57 := v56.FindInternedVar(lang.NewSymbol("val")) +if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) +} +v58 := v57.Get() +v59 := lang.Apply(v58, []any{v41}) +v60 := lang.Apply(v51, []any{v55, v59}) +v61 := lang.Apply(v44, []any{v48, v60}) +return v61 +}) +v41 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5699), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(5699), lang.NewKeyword("end-column"), int(70)) +v42, err := lang.WithMeta(v40, v41.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("seq")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +} +v45 := v44.Get() +v46 := lang.Apply(v45, []any{v19}) +v47 := lang.Apply(v39, []any{v42, v46}) +v48 := lang.Apply(v36, []any{v47}) +var v33 any = v48 +_ = v33 +var v50 any +v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v52 := v51.FindInternedVar(lang.NewSymbol("contains?")) +if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) +} +v53 := v52.Get() +v54 := lang.Apply(v6, []any{v4}) +v55 := lang.Apply(v53, []any{v54, v5}) +if lang.IsTruthy(v55) { +v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v57 := v56.FindInternedVar(lang.NewSymbol("reduce1")) +if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) +} +v58 := v57.Get() +var v59 lang.FnFunc +v59 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v60 := args[0] +v61 := args[1] +v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v63 := v62.FindInternedVar(lang.NewSymbol("apply")) +if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +} +v64 := v63.Get() +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("derive")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +} +v67 := v66.Get() +v68 := lang.Apply(v64, []any{v67, v60, v61}) +return v68 +}) +v60 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5702), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5702), lang.NewKeyword("end-column"), int(31)) +v61, err := lang.WithMeta(v59, v60.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v63 := v62.FindInternedVar(lang.NewSymbol("make-hierarchy")) +if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +} +v64 := v63.Get() +v65 := lang.Apply(v64, nil) +v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v67 := v66.FindInternedVar(lang.NewSymbol("partition")) +if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) +} +v68 := v67.Get() +v69 := lang.Apply(v68, []any{int64(2), v33}) +v70 := lang.Apply(v58, []any{v61, v65, v69}) +v50 = v70 +} else { +v50 = v3 +} +return v50 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// vswap! +{ +v0 := lang.NewSymbol("vswap!").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("vol"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Non-atomically swaps the value of the volatile as if:\n (apply f current-value-of-vol args). Returns the value that\n was swapped in.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(2531), lang.NewKeyword("end-line"), int(2531))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := lang.NewList(args[4:]...) +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("with-meta")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.NewMap(lang.NewKeyword("tag"), lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Volatile")) +v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2537), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(2537), lang.NewKeyword("end-column"), int(81)) +v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v15 := lang.Apply(v11, []any{v5, v14}) +var v8 any = v15 +_ = v8 +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol(".reset")}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{v8}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v6}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("seq")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +} +v49 := v48.Get() +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("concat")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +} +v52 := v51.Get() +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("list")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +} +v55 := v54.Get() +v56 := lang.Apply(v55, []any{lang.NewSymbol(".Deref")}) +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("list")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +} +v59 := v58.Get() +v60 := lang.Apply(v59, []any{v8}) +v61 := lang.Apply(v52, []any{v56, v60}) +v62 := lang.Apply(v49, []any{v61}) +v63 := lang.Apply(v46, []any{v62}) +v64 := lang.Apply(v39, []any{v43, v63, v7}) +v65 := lang.Apply(v36, []any{v64}) +v66 := lang.Apply(v33, []any{v65}) +v67 := lang.Apply(v22, []any{v26, v30, v66}) +v68 := lang.Apply(v19, []any{v67}) +return v68 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// set-error-mode! +{ +v0 := lang.NewSymbol("set-error-mode!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("mode-keyword"))), lang.NewKeyword("doc"), "Sets the error-mode of agent a to mode-keyword, which must be\n either :fail or :continue. If an action being run by the agent\n throws an exception or doesn't pass the validator fn, an\n error-handler may be called (see set-error-handler!), after which,\n if the mode is :continue, the agent will continue as if neither the\n action that caused the error nor the error itself ever happened.\n \n If the mode is :fail, the agent will become failed and will stop\n accepting new 'send' and 'send-off' actions, and any previously\n queued actions will be held until a 'restart-agent'. Deref will\n still work, returning the state of the agent before the error.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2210), lang.NewKeyword("end-line"), int(2210))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5, _ := lang.FieldOrMethod(v3, "setErrorMode") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorMode is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// char-array +{ +var v1 lang.FnFunc +{ // function char-array__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.NewList(args[0:]...) +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/charArray")}) +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("list")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("seq")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("concat")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("list")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v37, []any{lang.NewSymbol("glojure.core/args")}) +v39 := lang.Apply(v30, []any{v34, v38}) +v40 := lang.Apply(v27, []any{v39}) +v41 := lang.Apply(v24, []any{v40}) +v42 := lang.Apply(v9, []any{v13, v17, v21, v41}) +v43 := lang.Apply(v6, []any{v42}) +return v43 + } +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("char-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Creates an array of chars", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)int64(2)), lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5325), lang.NewKeyword("end-line"), int(5325))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "charArray") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("charArray is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 + case 2: +v4 := args[0] +v5 := args[1] +v6, _ := lang.FieldOrMethod(lang1.Numbers, "charArrayInit") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("charArrayInit is not a function"))) +} +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// memoize +{ +v0 := lang.NewSymbol("memoize").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Returns a memoized version of a referentially transparent function. The\n memoized version of the function keeps a cache of the mapping from arguments\n to results and, when calls with the same arguments are repeated often, has\n higher performance at the expense of higher memory use.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6380), lang.NewKeyword("end-line"), int(6380))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("atom")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.NewMap() +v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6388), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(6388), lang.NewKeyword("end-column"), int(20)) +v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v11 := lang.Apply(v7, []any{v10}) +var v4 any = v11 +_ = v4 +var v13 lang.FnFunc +v13 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v14 := lang.NewList(args[0:]...) +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("find")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("deref")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v4}) +v23 := lang.Apply(v18, []any{v22, v14}) +var v15 any = v23 +_ = v15 +var v25 any +if lang.IsTruthy(v15) { +var v26 any = v15 +_ = v26 +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("val")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{v26}) +v25 = v31 +} else { +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("apply")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{v3, v14}) +var v26 any = v30 +_ = v26 +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("swap!")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("assoc")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v34, []any{v4, v37, v14, v26}) +_ = v38 +v25 = v26 +} +return v25 + } +}) +v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6389), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(6394), lang.NewKeyword("end-column"), int(16)) +v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v15 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// when +{ +v0 := lang.NewSymbol("when").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("test"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Evaluates test. If logical true, evaluates body in an implicit do.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(492), lang.NewKeyword("end-line"), int(492))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("list")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("cons")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol("do"), v6}) +v14 := lang.Apply(v9, []any{lang.NewSymbol("if"), v5, v13}) +return v14 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// ratio? +{ +v0 := lang.NewSymbol("ratio?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is a Ratio", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3577), lang.NewKeyword("end-line"), int(3577))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{lang1.*Ratio, v3}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// slurp +{ +v1 := reflect.TypeOf("") +v0 := lang.NewSymbol("slurp").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("opts"))), lang.NewKeyword("doc"), "Opens a reader on f and reads all its contents, returning a string.\n See glojure.java.io/reader for a complete list of supported arguments.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7025), lang.NewKeyword("end-line"), int(7025))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := lang.NewList(args[1:]...) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("normalize-slurp-opts")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v6}) +var v6 any = v10 +_ = v6 +var v11 any = "unimplemented: new with non-constant class type" +_ = v11 +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("apply")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.FindNamespace(lang.NewSymbol("glojure.go.io")) +v18 := v17.FindInternedVar(lang.NewSymbol("reader")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v16, []any{v19, v4, v6}) +var v13 any = v20 +_ = v13 +var v22 any +func() { +defer func() { +v23, ok := lang.FieldOrMethod(v13, "close") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v13, "close"))) +} +var v24 any +switch reflect.TypeOf(v23).Kind() { +case reflect.Func: + v24 = lang.Apply(v23, nil) +default: + v24 = v23 +} +}() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.go.io")) +v26 := v25.FindInternedVar(lang.NewSymbol("copy")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.Apply(v27, []any{v13, v11}) +_ = v28 +v29 := lang.Apply(lang1.ToString, []any{v11}) +v22 = v29 +}() +return v22 + } +}) +v4 := reflect.TypeOf("") +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// ifn? +{ +v0 := lang.NewSymbol("ifn?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements IFn. Note that many data structures\n (e.g. sets and maps) implement IFn", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6252), lang.NewKeyword("end-line"), int(6252))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{glojure.lang11.IFn, v3}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// drop-last +{ +v0 := lang.NewSymbol("drop-last").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return a lazy sequence of all but the last n (default 1) items in coll", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2932), lang.NewKeyword("end-line"), int(2932))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("drop-last")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{int64(1), v3}) +return v7 + case 2: +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("map")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +var v8 lang.FnFunc +v8 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v9 := args[0] +v10 := args[1] +return v9 +}) +v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2937), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(2937), lang.NewKeyword("end-column"), int(29)) +v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("drop")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v3, v4}) +v15 := lang.Apply(v7, []any{v10, v4, v14}) +return v15 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// unchecked-subtract-int +{ +var v1 lang.FnFunc +{ // function unchecked-subtract-int__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("concat")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("list")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("seq")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("concat")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("list")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/unchecked_int_subtract")}) +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v4}) +v40 := lang.Apply(v27, []any{v31, v35, v39}) +v41 := lang.Apply(v24, []any{v40}) +v42 := lang.Apply(v21, []any{v41}) +v43 := lang.Apply(v10, []any{v14, v18, v42}) +v44 := lang.Apply(v7, []any{v43}) +return v44 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("unchecked-subtract-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the difference of x and y, both int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1210), lang.NewKeyword("end-line"), int(1210))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := args[1] +v6, _ := lang.FieldOrMethod(lang1.Numbers, "unchecked_int_subtract") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_subtract is not a function"))) +} +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// stream-transduce! +{ +v0 := lang.NewSymbol("stream-transduce!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("f"), lang.NewSymbol("stream")), lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Works like transduce but takes a java.util.stream.BaseStream as its source.\n This is a terminal operation on the stream.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6843), lang.NewKeyword("end-line"), int(6843))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("stream-transduce!")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v4, nil) +v10 := lang.Apply(v8, []any{v3, v4, v9, v5}) +return v10 + case 4: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v8 := lang.Apply(v3, []any{v7}) +var v7 any = v8 +_ = v7 +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("stream-reduce!")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{v7, v5, v6}) +var v9 any = v13 +_ = v9 +v15 := lang.Apply(v7, []any{v9}) +return v15 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// unchecked-short +{ +var v1 lang.FnFunc +{ // function unchecked-short__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/UncheckedShortCast")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v3}) +v35 := lang.Apply(v26, []any{v30, v34}) +v36 := lang.Apply(v23, []any{v35}) +v37 := lang.Apply(v20, []any{v36}) +v38 := lang.Apply(v9, []any{v13, v17, v37}) +v39 := lang.Apply(v6, []any{v38}) +return v39 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("unchecked-short").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to short. Subject to rounding or truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3523), lang.NewKeyword("end-line"), int(3523))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := lang.Apply(lang1.UncheckedShortCast, []any{v4}) +return v5 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// bit-clear +{ +v0 := lang.NewSymbol("bit-clear").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Clear bit at index n", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1336), lang.NewKeyword("end-line"), int(1336))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "clearBit") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("clearBit is not a function"))) +} +v6 := lang.Apply(v5, []any{v3, v4}) +return v6 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// some->> +{ +v0 := lang.NewSymbol("some->>").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "When expr is not nil, threads it into the first form (via ->>),\n and when that result is not nil, through the next etc", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7667), lang.NewKeyword("end-line"), int(7667))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("gensym")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, nil) +var v7 any = v11 +_ = v7 +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("map")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +var v16 lang.FnFunc +v16 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v17 := args[0] +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("seq")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("concat")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("list")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.Apply(v26, []any{lang.NewSymbol("if")}) +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("list")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("seq")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("concat")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("list")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.Apply(v39, []any{lang.NewSymbol("glojure.core/nil?")}) +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("list")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v7}) +v45 := lang.Apply(v36, []any{v40, v44}) +v46 := lang.Apply(v33, []any{v45}) +v47 := lang.Apply(v30, []any{v46}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{nil}) +v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v53 := v52.FindInternedVar(lang.NewSymbol("list")) +if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) +} +v54 := v53.Get() +v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v56 := v55.FindInternedVar(lang.NewSymbol("seq")) +if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) +} +v57 := v56.Get() +v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v59 := v58.FindInternedVar(lang.NewSymbol("concat")) +if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) +} +v60 := v59.Get() +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("list")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +} +v63 := v62.Get() +v64 := lang.Apply(v63, []any{lang.NewSymbol("glojure.core/->>")}) +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("list")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +} +v67 := v66.Get() +v68 := lang.Apply(v67, []any{v7}) +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("list")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +} +v71 := v70.Get() +v72 := lang.Apply(v71, []any{v17}) +v73 := lang.Apply(v60, []any{v64, v68, v72}) +v74 := lang.Apply(v57, []any{v73}) +v75 := lang.Apply(v54, []any{v74}) +v76 := lang.Apply(v23, []any{v27, v47, v51, v75}) +v77 := lang.Apply(v20, []any{v76}) +return v77 +}) +v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7673), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7673), lang.NewKeyword("end-column"), int(65)) +v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v19 := lang.Apply(v15, []any{v18, v6}) +var v12 any = v19 +_ = v12 +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/let")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("apply")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("vector")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("seq")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("concat")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +} +v45 := v44.Get() +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("list")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +} +v48 := v47.Get() +v49 := lang.Apply(v48, []any{v7}) +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("list")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +} +v52 := v51.Get() +v53 := lang.Apply(v52, []any{v5}) +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("interleave")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +} +v56 := v55.Get() +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("repeat")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +} +v59 := v58.Get() +v60 := lang.Apply(v59, []any{v7}) +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("butlast")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +} +v63 := v62.Get() +v64 := lang.Apply(v63, []any{v12}) +v65 := lang.Apply(v56, []any{v60, v64}) +v66 := lang.Apply(v45, []any{v49, v53, v65}) +v67 := lang.Apply(v42, []any{v66}) +v68 := lang.Apply(v36, []any{v39, v67}) +v69 := lang.Apply(v33, []any{v68}) +v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v71 := v70.FindInternedVar(lang.NewSymbol("list")) +if v71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) +} +v72 := v71.Get() +var v73 any +v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v75 := v74.FindInternedVar(lang.NewSymbol("empty?")) +if v75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) +} +v76 := v75.Get() +v77 := lang.Apply(v76, []any{v12}) +if lang.IsTruthy(v77) { +v73 = v7 +} else { +v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v79 := v78.FindInternedVar(lang.NewSymbol("last")) +if v79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) +} +v80 := v79.Get() +v81 := lang.Apply(v80, []any{v12}) +v73 = v81 +} +v82 := lang.Apply(v72, []any{v73}) +v83 := lang.Apply(v26, []any{v30, v69, v82}) +v84 := lang.Apply(v23, []any{v83}) +return v84 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// update-in +{ +v0 := lang.NewSymbol("update-in").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("ks"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "'Updates' a value in a nested associative structure, where ks is a\n sequence of keys and f is a function that will take the old value\n and any supplied args and return the new value, and returns a new\n nested structure. If any levels do not exist, hash-maps will be\n created.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6201), lang.NewKeyword("end-line"), int(6201))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +var v8 lang.FnFunc +{ // function up +v8 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v10 := args[0] +v11 := args[1] +v12 := args[2] +v13 := args[3] +var v14 any = v11 +_ = v14 +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("seq")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v14}) +var v15 any = v19 +_ = v15 +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("first")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v15}) +var v20 any = v24 +_ = v20 +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("next")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.Apply(v28, []any{v25}) +var v25 any = v29 +_ = v25 +var v30 any = v20 +_ = v30 +var v31 any = v25 +_ = v31 +var v33 any +if lang.IsTruthy(v31) { +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("assoc")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("get")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v10, v30}) +v41 := lang.Apply(v9, []any{v40, v31, v12, v13}) +v42 := lang.Apply(v36, []any{v10, v30, v41}) +v33 = v42 +} else { +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("assoc")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +} +v45 := v44.Get() +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("apply")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +} +v48 := v47.Get() +v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v50 := v49.FindInternedVar(lang.NewSymbol("get")) +if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) +} +v51 := v50.Get() +v52 := lang.Apply(v51, []any{v10, v30}) +v53 := lang.Apply(v48, []any{v12, v52, v13}) +v54 := lang.Apply(v45, []any{v10, v30, v53}) +v33 = v54 +} +return v33 +}) +v9 := v8 +_ = v9 +} +v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6210), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(6214), lang.NewKeyword("end-column"), int(59)) +v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v7 any = v10 +_ = v7 +v12 := lang.Apply(v7, []any{v3, v4, v5, v6}) +return v12 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// not-any? +{ +v1 := reflect.TypeOf(false) +v0 := lang.NewSymbol("not-any?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns false if (pred x) is logical true for any x in coll,\n else true.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(2696), lang.NewKeyword("end-line"), int(2701))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v4 := lang.Apply(closed11, nil) +v5 := lang.Apply(closed1, []any{v4}) +return v5 + case 1: +v4 := args[0] +v5 := lang.Apply(closed11, []any{v4}) +v6 := lang.Apply(closed1, []any{v5}) +return v6 + case 2: +v4 := args[0] +v5 := args[1] +v6 := lang.Apply(closed11, []any{v4, v5}) +v7 := lang.Apply(closed1, []any{v6}) +return v7 + case 3: +v4 := args[0] +v5 := args[1] +v6 := args[2] +v7 := lang.Apply(closed11, []any{v4, v5, v6}) +v8 := lang.Apply(closed1, []any{v7}) +return v8 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := args[1] +v6 := args[2] +v7 := lang.NewList(args[3:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("apply")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{closed11, v4, v5, v6, v7}) +v12 := lang.Apply(closed1, []any{v11}) +return v12 + } +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2559), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2564), lang.NewKeyword("end-column"), int(49))).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// reader-conditional? +{ +v0 := lang.NewSymbol("reader-conditional?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("value"))), lang.NewKeyword("doc"), "Return true if the value is the data representation of a reader conditional", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7829), lang.NewKeyword("end-line"), int(7829))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{glojure.lang11.ReaderConditional, v3}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// xml-seq +{ +v0 := lang.NewSymbol("xml-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("root"))), lang.NewKeyword("doc"), "A tree seq on the xml elements as per xml/parse", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4982), lang.NewKeyword("end-line"), int(4982))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("tree-seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("complement")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("string?")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v9, []any{v12}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("comp")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v16, []any{v19, lang.NewKeyword("content")}) +v21 := lang.Apply(v6, []any{v13, v20, v3}) +return v21 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// group-by +{ +v0 := lang.NewSymbol("group-by").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a map of the elements of coll keyed by the result of\n f on each element. The value at each key will be a vector of the\n corresponding elements, in the order they appeared in coll.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7171), lang.NewKeyword("end-line"), int(7171))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("persistent!")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("reduce")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +var v11 lang.FnFunc +v11 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v12 := args[0] +v13 := args[1] +v15 := lang.Apply(v3, []any{v13}) +var v14 any = v15 +_ = v14 +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("assoc!")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("conj")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("get")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.NewVector() +v27 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7182), lang.NewKeyword("column"), int(40), lang.NewKeyword("end-line"), int(7182), lang.NewKeyword("end-column"), int(41)) +v28, err := lang.WithMeta(v26, v27.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v29 := lang.Apply(v25, []any{v12, v14, v28}) +v30 := lang.Apply(v22, []any{v29, v13}) +v31 := lang.Apply(v19, []any{v12, v14, v30}) +return v31 +}) +v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7180), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(7182), lang.NewKeyword("end-column"), int(48)) +v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("transient")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.NewMap() +v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7183), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(7183), lang.NewKeyword("end-column"), int(17)) +v19, err := lang.WithMeta(v17, v18.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v20 := lang.Apply(v16, []any{v19}) +v21 := lang.Apply(v10, []any{v13, v20, v4}) +v22 := lang.Apply(v7, []any{v21}) +return v22 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// numerator +{ +v1 := reflect.TypeOf((*big9.Int)(nil)) +v0 := lang.NewSymbol("numerator").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("r"))), lang.NewKeyword("doc"), "Returns the numerator part of a Ratio.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3583), lang.NewKeyword("end-line"), int(3583))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5, ok := lang.FieldOrMethod(v4, "numerator") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "numerator"))) +} +var v6 any +switch reflect.TypeOf(v5).Kind() { +case reflect.Func: + v6 = lang.Apply(v5, nil) +default: + v6 = v5 +} +return v6 +}) +v4 := reflect.TypeOf((*big9.Int)(nil)) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// defn +{ +v0 := lang.NewSymbol("defn").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("doc-string?"), lang.NewSymbol("attr-map?"), lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("prepost-map?"), lang.NewSymbol("body")), lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("doc-string?"), lang.NewSymbol("attr-map?"), lang.NewList(lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("prepost-map?"), lang.NewSymbol("body")), lang.NewSymbol("+"), lang.NewSymbol("attr-map?"))), lang.NewKeyword("doc"), "Same as (def name (fn [params* ] exprs*)) or (def\n name (fn ([params* ] exprs*)+)) with any doc-string or attrs added\n to the var metadata. prepost-map defines a map with optional keys\n :pre and :post that contain collections of pre or post conditions.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(284), lang.NewKeyword("end-line"), int(291))).(*lang.Symbol) +var v2 lang.FnFunc +{ // function defn +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := args[1] +v6 := args[2] +v7 := lang.NewList(args[3:]...) +var v8 any +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("instance?")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v11, []any{lang1.*Symbol, v6}) +if lang.IsTruthy(v12) { +v8 = nil +} else { +v13 := lang.Apply(lang1.NewIllegalArgumentError, []any{"First argument to defn must be a symbol"}) +panic(v13) +} +_ = v8 +var v15 any +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("string?")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("first")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v7}) +v23 := lang.Apply(v18, []any{v22}) +if lang.IsTruthy(v23) { +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("first")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v7}) +v28 := lang.NewMap(lang.NewKeyword("doc"), v27) +v29 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(297), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(297), lang.NewKeyword("end-column"), int(38)) +v30, err := lang.WithMeta(v28, v29.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v15 = v30 +} else { +v31 := lang.NewMap() +v32 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(298), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(298), lang.NewKeyword("end-column"), int(20)) +v33, err := lang.WithMeta(v31, v32.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v15 = v33 +} +var v14 any = v15 +_ = v14 +var v35 any +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("string?")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("first")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +} +v41 := v40.Get() +v42 := lang.Apply(v41, []any{v34}) +v43 := lang.Apply(v38, []any{v42}) +if lang.IsTruthy(v43) { +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("next")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v34}) +v35 = v47 +} else { +v35 = v34 +} +var v34 any = v35 +_ = v34 +var v49 any +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("map?")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +} +v52 := v51.Get() +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("first")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +} +v55 := v54.Get() +v56 := lang.Apply(v55, []any{v34}) +v57 := lang.Apply(v52, []any{v56}) +if lang.IsTruthy(v57) { +v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v59 := v58.FindInternedVar(lang.NewSymbol("conj")) +if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) +} +v60 := v59.Get() +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("first")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +} +v63 := v62.Get() +v64 := lang.Apply(v63, []any{v34}) +v65 := lang.Apply(v60, []any{v48, v64}) +v49 = v65 +} else { +v49 = v48 +} +var v48 any = v49 +_ = v48 +var v67 any +v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v69 := v68.FindInternedVar(lang.NewSymbol("map?")) +if v69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) +} +v70 := v69.Get() +v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v72 := v71.FindInternedVar(lang.NewSymbol("first")) +if v72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) +} +v73 := v72.Get() +v74 := lang.Apply(v73, []any{v66}) +v75 := lang.Apply(v70, []any{v74}) +if lang.IsTruthy(v75) { +v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v77 := v76.FindInternedVar(lang.NewSymbol("next")) +if v77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) +} +v78 := v77.Get() +v79 := lang.Apply(v78, []any{v66}) +v67 = v79 +} else { +v67 = v66 +} +var v66 any = v67 +_ = v66 +var v81 any +v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v83 := v82.FindInternedVar(lang.NewSymbol("vector?")) +if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) +} +v84 := v83.Get() +v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v86 := v85.FindInternedVar(lang.NewSymbol("first")) +if v86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) +} +v87 := v86.Get() +v88 := lang.Apply(v87, []any{v80}) +v89 := lang.Apply(v84, []any{v88}) +if lang.IsTruthy(v89) { +v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v91 := v90.FindInternedVar(lang.NewSymbol("list")) +if v91.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) +} +v92 := v91.Get() +v93 := lang.Apply(v92, []any{v80}) +v81 = v93 +} else { +v81 = v80 +} +var v80 any = v81 +_ = v80 +var v95 any +v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v97 := v96.FindInternedVar(lang.NewSymbol("map?")) +if v97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) +} +v98 := v97.Get() +v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v100 := v99.FindInternedVar(lang.NewSymbol("last")) +if v100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) +} +v101 := v100.Get() +v102 := lang.Apply(v101, []any{v80}) +v103 := lang.Apply(v98, []any{v102}) +if lang.IsTruthy(v103) { +v104 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v105 := v104.FindInternedVar(lang.NewSymbol("conj")) +if v105.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v105))) +} +v106 := v105.Get() +v107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v108 := v107.FindInternedVar(lang.NewSymbol("last")) +if v108.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v108))) +} +v109 := v108.Get() +v110 := lang.Apply(v109, []any{v80}) +v111 := lang.Apply(v106, []any{v94, v110}) +v95 = v111 +} else { +v95 = v94 +} +var v94 any = v95 +_ = v94 +var v113 any +v114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v115 := v114.FindInternedVar(lang.NewSymbol("map?")) +if v115.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v115))) +} +v116 := v115.Get() +v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v118 := v117.FindInternedVar(lang.NewSymbol("last")) +if v118.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) +} +v119 := v118.Get() +v120 := lang.Apply(v119, []any{v112}) +v121 := lang.Apply(v116, []any{v120}) +if lang.IsTruthy(v121) { +v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v123 := v122.FindInternedVar(lang.NewSymbol("butlast")) +if v123.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) +} +v124 := v123.Get() +v125 := lang.Apply(v124, []any{v112}) +v113 = v125 +} else { +v113 = v112 +} +var v112 any = v113 +_ = v112 +v127 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v128 := v127.FindInternedVar(lang.NewSymbol("conj")) +if v128.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v128))) +} +v129 := v128.Get() +v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v131 := v130.FindInternedVar(lang.NewSymbol("list")) +if v131.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) +} +v132 := v131.Get() +v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v134 := v133.FindInternedVar(lang.NewSymbol("sigs")) +if v134.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) +} +v135 := v134.Get() +v136 := lang.Apply(v135, []any{v112}) +v137 := lang.Apply(v132, []any{lang.NewSymbol("quote"), v136}) +v138 := lang.NewMap(lang.NewKeyword("arglists"), v137) +v139 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(317), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(317), lang.NewKeyword("end-column"), int(60)) +v140, err := lang.WithMeta(v138, v139.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v141 := lang.Apply(v129, []any{v140, v126}) +var v126 any = v141 +_ = v126 +v144 := lang.Apply(lang.NewKeyword("inline"), []any{v142}) +var v143 any = v144 +_ = v143 +v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v147 := v146.FindInternedVar(lang.NewSymbol("first")) +if v147.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) +} +v148 := v147.Get() +v149 := lang.Apply(v148, []any{v143}) +var v145 any = v149 +_ = v145 +v151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v152 := v151.FindInternedVar(lang.NewSymbol("second")) +if v152.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v152))) +} +v153 := v152.Get() +v154 := lang.Apply(v153, []any{v143}) +var v150 any = v154 +_ = v150 +var v156 any +var v157 any +v158 := lang.Apply(lang1.Equiv, []any{lang.NewSymbol("fn"), v145}) +if lang.IsTruthy(v158) { +var v159 any +v160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v161 := v160.FindInternedVar(lang.NewSymbol("instance?")) +if v161.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v161))) +} +v162 := v161.Get() +v163 := lang.Apply(v162, []any{lang1.*Symbol, v150}) +if lang.IsTruthy(v163) { +v159 = false +} else { +v159 = true +} +v157 = v159 +} else { +v157 = nil +} +if lang.IsTruthy(v157) { +v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v165 := v164.FindInternedVar(lang.NewSymbol("assoc")) +if v165.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) +} +v166 := v165.Get() +v167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v168 := v167.FindInternedVar(lang.NewSymbol("cons")) +if v168.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v168))) +} +v169 := v168.Get() +v170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v171 := v170.FindInternedVar(lang.NewSymbol("cons")) +if v171.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v171))) +} +v172 := v171.Get() +v173, ok := lang.FieldOrMethod(v6, "Name") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "Name"))) +} +var v174 any +switch reflect.TypeOf(v173).Kind() { +case reflect.Func: + v174 = lang.Apply(v173, nil) +default: + v174 = v173 +} +v175 := lang.Apply(lang1.ConcatStrings, []any{v174, "__inliner"}) +v176 := lang.Apply(lang1.NewSymbol, []any{v175}) +v177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v178 := v177.FindInternedVar(lang.NewSymbol("next")) +if v178.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v178))) +} +v179 := v178.Get() +v180 := lang.Apply(v179, []any{v143}) +v181 := lang.Apply(v172, []any{v176, v180}) +v182 := lang.Apply(v169, []any{v145, v181}) +v183 := lang.Apply(v166, []any{v142, lang.NewKeyword("inline"), v182}) +v156 = v183 +} else { +v156 = v142 +} +var v142 any = v156 +_ = v142 +v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v145 := v144.FindInternedVar(lang.NewSymbol("conj")) +if v145.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) +} +v146 := v145.Get() +var v147 any +v148 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v149 := v148.FindInternedVar(lang.NewSymbol("meta")) +if v149.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v149))) +} +v150 := v149.Get() +v151 := lang.Apply(v150, []any{v6}) +if lang.IsTruthy(v151) { +v152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v153 := v152.FindInternedVar(lang.NewSymbol("meta")) +if v153.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v153))) +} +v154 := v153.Get() +v155 := lang.Apply(v154, []any{v6}) +v147 = v155 +} else { +v156 := lang.NewMap() +v157 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(328), lang.NewKeyword("column"), int(51), lang.NewKeyword("end-line"), int(328), lang.NewKeyword("end-column"), int(52)) +v158, err := lang.WithMeta(v156, v157.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v147 = v158 +} +v159 := lang.Apply(v146, []any{v147, v143}) +var v143 any = v159 +_ = v143 +v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v162 := v161.FindInternedVar(lang.NewSymbol("list")) +if v162.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) +} +v163 := v162.Get() +v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v165 := v164.FindInternedVar(lang.NewSymbol("with-meta")) +if v165.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) +} +v166 := v165.Get() +v167 := lang.Apply(v166, []any{v6, v143}) +v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v169 := v168.FindInternedVar(lang.NewSymbol("with-meta")) +if v169.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) +} +v170 := v169.Get() +v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v172 := v171.FindInternedVar(lang.NewSymbol("cons")) +if v172.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) +} +v173 := v172.Get() +v174 := lang.Apply(v173, []any{lang.NewSymbol("glojure.core/fn"), v112}) +v175 := lang.Apply(lang.NewKeyword("tag"), []any{v143}) +v176 := lang.NewMap(lang.NewKeyword("rettag"), v175) +v177 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(333), lang.NewKeyword("column"), int(37), lang.NewKeyword("end-line"), int(333), lang.NewKeyword("end-column"), int(54)) +v178, err := lang.WithMeta(v176, v177.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v179 := lang.Apply(v170, []any{v174, v178}) +v180 := lang.Apply(v163, []any{lang.NewSymbol("def"), v167, v179}) +return v180 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(291), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(333), lang.NewKeyword("end-column"), int(58))).(lang.FnFunc) +v3 := v2 +_ = v3 +} +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// pos-int? +{ +v0 := lang.NewSymbol("pos-int?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a positive fixed precision integer", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1403), lang.NewKeyword("end-line"), int(1403))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("int?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +var v4 any = v8 +_ = v4 +var v10 any +if lang.IsTruthy(v4) { +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("pos?")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v3}) +v10 = v14 +} else { +v10 = v4 +} +return v10 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// special-symbol? +{ +v0 := lang.NewSymbol("special-symbol?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns true if s names a special form", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4992), lang.NewKeyword("end-line"), int(4992))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("contains?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7, ok := lang.FieldOrMethod(runtime3.Compiler, "specials") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", runtime3.Compiler, "specials"))) +} +var v8 any +switch reflect.TypeOf(v7).Kind() { +case reflect.Func: + v8 = lang.Apply(v7, nil) +default: + v8 = v7 +} +v9 := lang.Apply(v6, []any{v8, v3}) +return v9 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// ns-interns +{ +v0 := lang.NewSymbol("ns-interns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of the intern mappings for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4206), lang.NewKeyword("end-line"), int(4206))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("the-ns")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v4}) +var v4 any = v8 +_ = v4 +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("filter-key")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("val")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +var v16 lang.FnFunc +v16 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v17 := args[0] +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("instance?")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{lang1.*Var, v17}) +var v18 any = v22 +_ = v18 +var v24 any +if lang.IsTruthy(v18) { +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("=")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28, ok := lang.FieldOrMethod(v17, "Namespace") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v17, "Namespace"))) +} +var v29 any +switch reflect.TypeOf(v28).Kind() { +case reflect.Func: + v29 = lang.Apply(v28, nil) +default: + v29 = v28 +} +v30 := lang.Apply(v27, []any{v4, v29}) +v24 = v30 +} else { +v24 = v18 +} +return v24 +}) +v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4212), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(4213), lang.NewKeyword("end-column"), int(56)) +v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("ns-map")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v4}) +v23 := lang.Apply(v12, []any{v15, v18, v22}) +return v23 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// pos? +{ +var v1 lang.FnFunc +{ // function pos?__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/isPos")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v3}) +v35 := lang.Apply(v26, []any{v30, v34}) +v36 := lang.Apply(v23, []any{v35}) +v37 := lang.Apply(v20, []any{v36}) +v38 := lang.Apply(v9, []any{v13, v17, v37}) +v39 := lang.Apply(v6, []any{v38}) +return v39 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("pos?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns true if num is greater than zero, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1252), lang.NewKeyword("end-line"), int(1252))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "isPos") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("isPos is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// repeat +{ +v0 := lang.NewSymbol("repeat").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns a lazy (infinite!, or length n if supplied) sequence of xs.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2997), lang.NewKeyword("end-line"), int(2997))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +v4 := lang.Apply(lang1.NewRepeat, []any{v3}) +return v4 + case 2: +v3 := args[0] +v4 := args[1] +v5 := lang.Apply(lang1.NewRepeatN, []any{v3, v4}) +return v5 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// bound-fn* +{ +v0 := lang.NewSymbol("bound-fn*").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Returns a function, which will install the same bindings in effect as in\n the thread at the time bound-fn* was called and then call f with any given\n arguments. This may be used to define a helper function which runs on a\n different thread, but needs the same bindings in place.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1992), lang.NewKeyword("end-line"), int(1992))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("get-thread-bindings")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, nil) +var v4 any = v8 +_ = v4 +var v10 lang.FnFunc +v10 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v11 := lang.NewList(args[0:]...) +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("apply")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("with-bindings*")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v14, []any{v17, v4, v3, v11}) +return v18 + } +}) +v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2001), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2002), lang.NewKeyword("end-column"), int(45)) +v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v12 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// *' +{ +var v1 lang.FnFunc +v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v2 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +if lang.IsTruthy(v7) { +v4 = closed12 +} else { +v4 = v3 +} +var v3 any = v4 +_ = v3 +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("seq")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("concat")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("seq")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("concat")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v2}) +v40 := lang.Apply(v31, []any{v35, v39}) +v41 := lang.Apply(v28, []any{v40}) +v42 := lang.Apply(v25, []any{v41}) +v43 := lang.Apply(v14, []any{v18, v22, v42}) +v44 := lang.Apply(v11, []any{v43}) +return v44 + case 2: +v2 := args[0] +v3 := args[1] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +if lang.IsTruthy(v8) { +v5 = closed12 +} else { +v5 = v4 +} +var v4 any = v5 +_ = v4 +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("seq")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("concat")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("list")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("list")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("list")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("seq")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("concat")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("list")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v4}) +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("list")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v2}) +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("list")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v3}) +v45 := lang.Apply(v32, []any{v36, v40, v44}) +v46 := lang.Apply(v29, []any{v45}) +v47 := lang.Apply(v26, []any{v46}) +v48 := lang.Apply(v15, []any{v19, v23, v47}) +v49 := lang.Apply(v12, []any{v48}) +return v49 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v2 := args[0] +v3 := args[1] +v4 := lang.NewList(args[2:]...) +var v6 any +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +if lang.IsTruthy(v9) { +v6 = closed12 +} else { +v6 = v5 +} +var v5 any = v6 +_ = v5 +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +var v14 lang.FnFunc +v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v15 := args[0] +v16 := args[1] +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v5}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v15}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v16}) +v52 := lang.Apply(v39, []any{v43, v47, v51}) +v53 := lang.Apply(v36, []any{v52}) +v54 := lang.Apply(v33, []any{v53}) +v55 := lang.Apply(v22, []any{v26, v30, v54}) +v56 := lang.Apply(v19, []any{v55}) +return v56 +}) +v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) +v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v5}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v2}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v3}) +v52 := lang.Apply(v39, []any{v43, v47, v51}) +v53 := lang.Apply(v36, []any{v52}) +v54 := lang.Apply(v33, []any{v53}) +v55 := lang.Apply(v22, []any{v26, v30, v54}) +v56 := lang.Apply(v19, []any{v55}) +v57 := lang.Apply(v13, []any{v16, v56, v4}) +return v57 + } +}) +v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) +} +v5 := lang.Apply(v4, []any{v3, int64(1)}) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v0 := lang.NewSymbol("*'").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the product of nums. (*') returns 1. Supports arbitrary precision.\n See also: *", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(989), lang.NewKeyword("end-line"), int(989))).(*lang.Symbol) +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +return int64(1) + case 1: +v5 := args[0] +v6 := lang.Apply(lang1.MustAsNumber, []any{v5}) +return v6 + case 2: +v5 := args[0] +v6 := args[1] +v7, _ := lang.FieldOrMethod(lang1.Numbers, "multiplyP") +if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("multiplyP is not a function"))) +} +v8 := lang.Apply(v7, []any{v5, v6}) +return v8 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +v6 := args[1] +v7 := lang.NewList(args[2:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("*'")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("*'")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v5, v6}) +v18 := lang.Apply(v10, []any{v13, v17, v7}) +return v18 + } +}) +v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v3 := ns.InternWithValue(v0, v4, true) +if v0.Meta() != nil { + v3.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// unchecked-multiply +{ +var v1 lang.FnFunc +{ // function unchecked-multiply__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("concat")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("list")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("seq")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("concat")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("list")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/unchecked_multiply")}) +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v4}) +v40 := lang.Apply(v27, []any{v31, v35, v39}) +v41 := lang.Apply(v24, []any{v40}) +v42 := lang.Apply(v21, []any{v41}) +v43 := lang.Apply(v10, []any{v14, v18, v42}) +v44 := lang.Apply(v7, []any{v43}) +return v44 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("unchecked-multiply").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the product of x and y, both long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1231), lang.NewKeyword("end-line"), int(1231))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := args[1] +v6, _ := lang.FieldOrMethod(lang1.Numbers, "unchecked_multiply") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_multiply is not a function"))) +} +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// <= +{ +var v1 lang.FnFunc +{ // function <=__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("concat")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("list")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("seq")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("concat")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("list")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/lte")}) +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v4}) +v40 := lang.Apply(v27, []any{v31, v35, v39}) +v41 := lang.Apply(v24, []any{v40}) +v42 := lang.Apply(v21, []any{v41}) +v43 := lang.Apply(v10, []any{v14, v18, v42}) +v44 := lang.Apply(v7, []any{v43}) +return v44 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("<=").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns non-nil if nums are in monotonically non-decreasing order,\n otherwise false.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1048), lang.NewKeyword("end-line"), int(1048))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v4 := args[0] +return true + case 2: +v4 := args[0] +v5 := args[1] +v6, _ := lang.FieldOrMethod(lang1.Numbers, "lte") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("lte is not a function"))) +} +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := args[1] +v6 := lang.NewList(args[2:]...) +recur_loop_194: +var v7 any +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("<=")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v4, v5}) +if lang.IsTruthy(v11) { +var v12 any +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("next")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v6}) +if lang.IsTruthy(v16) { +var v17 any = v5 +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("first")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v6}) +var v18 any = v22 +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("next")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v6}) +var v23 any = v27 +v4 = v17 +v5 = v18 +v6 = v23 +goto recur_loop_194 +} else { +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("<=")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("first")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v6}) +v35 := lang.Apply(v30, []any{v5, v34}) +v12 = v35 +} +v7 = v12 +} else { +v7 = false +} +return v7 + } +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// lift-ns +{ +v0 := lang.NewSymbol("lift-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"))), lang.NewKeyword("doc"), "Returns [lifted-ns lifted-kvs] or nil if m can't be lifted.", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(261), lang.NewKeyword("end-line"), int(261), lang.NewKeyword("private"), true)).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("*print-namespace-maps*")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +if lang.IsTruthy(v7) { +var v8 any = nil +_ = v8 +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("seq")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{v3}) +var v9 any = v13 +_ = v9 +var v14 any = v9 +_ = v14 +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("seq")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v14}) +var v15 any = v19 +_ = v15 +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("first")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v15}) +var v20 any = v24 +_ = v20 +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("next")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.Apply(v28, []any{v25}) +var v25 any = v29 +_ = v25 +var v30 any = v20 +_ = v30 +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("nth")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v30, int64(0), nil}) +var v31 any = v35 +_ = v31 +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("nth")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v30, int64(1), nil}) +var v36 any = v40 +_ = v36 +var v41 any = v30 +_ = v41 +var v42 any = v25 +_ = v42 +v44 := lang.NewVector() +v45 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(267), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(267), lang.NewKeyword("end-column"), int(17)) +v46, err := lang.WithMeta(v44, v45.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v43 any = v46 +_ = v43 +var v48 any = v48 +_ = v48 +var v49 any = v49 +_ = v49 +var v50 any = v50 +_ = v50 +var v51 any +for { +var v52 any = v52 +_ = v52 +var v53 any = v49 +_ = v53 +v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v56 := v55.FindInternedVar(lang.NewSymbol("seq")) +if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) +} +v57 := v56.Get() +v58 := lang.Apply(v57, []any{v53}) +var v54 any = v58 +_ = v54 +v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v61 := v60.FindInternedVar(lang.NewSymbol("first")) +if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) +} +v62 := v61.Get() +v63 := lang.Apply(v62, []any{v54}) +var v59 any = v63 +_ = v59 +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("next")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +} +v67 := v66.Get() +v68 := lang.Apply(v67, []any{v64}) +var v64 any = v68 +_ = v64 +var v69 any = v59 +_ = v69 +v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v72 := v71.FindInternedVar(lang.NewSymbol("nth")) +if v72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) +} +v73 := v72.Get() +v74 := lang.Apply(v73, []any{v69, int64(0), nil}) +var v70 any = v74 +_ = v70 +v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v77 := v76.FindInternedVar(lang.NewSymbol("nth")) +if v77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) +} +v78 := v77.Get() +v79 := lang.Apply(v78, []any{v69, int64(1), nil}) +var v75 any = v79 +_ = v75 +var v80 any = v69 +_ = v80 +var v81 any = v64 +_ = v81 +var v82 any = v82 +_ = v82 +var v84 any +if lang.IsTruthy(v80) { +var v85 any +v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v87 := v86.FindInternedVar(lang.NewSymbol("qualified-ident?")) +if v87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) +} +v88 := v87.Get() +v89 := lang.Apply(v88, []any{v70}) +if lang.IsTruthy(v89) { +var v90 any +if lang.IsTruthy(v52) { +var v91 any +v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v93 := v92.FindInternedVar(lang.NewSymbol("=")) +if v93.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) +} +v94 := v93.Get() +v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v96 := v95.FindInternedVar(lang.NewSymbol("namespace")) +if v96.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) +} +v97 := v96.Get() +v98 := lang.Apply(v97, []any{v70}) +v99 := lang.Apply(v94, []any{v52, v98}) +if lang.IsTruthy(v99) { +var v100 any = v52 +var v101 any = v81 +v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v104 := v103.FindInternedVar(lang.NewSymbol("conj")) +if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) +} +v105 := v104.Get() +v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v107 := v106.FindInternedVar(lang.NewSymbol("strip-ns")) +if v107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) +} +v108 := v107.Get() +v109 := lang.Apply(v108, []any{v70}) +v110 := lang.NewVector(v109, v75) +v111 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(272), lang.NewKeyword("column"), int(43), lang.NewKeyword("end-line"), int(272), lang.NewKeyword("end-column"), int(58)) +v112, err := lang.WithMeta(v110, v111.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v113 := lang.Apply(v105, []any{v82, v112}) +var v102 any = v113 +v48 = v100 +v49 = v101 +v50 = v102 +continue +} else { +v91 = nil +} +v90 = v91 +} else { +v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v116 := v115.FindInternedVar(lang.NewSymbol("namespace")) +if v116.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) +} +v117 := v116.Get() +v118 := lang.Apply(v117, []any{v70}) +var v114 any = v118 +_ = v114 +var v120 any +if lang.IsTruthy(v114) { +var v121 any = v114 +_ = v121 +var v123 any = v121 +var v124 any = v81 +v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v127 := v126.FindInternedVar(lang.NewSymbol("conj")) +if v127.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) +} +v128 := v127.Get() +v129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v130 := v129.FindInternedVar(lang.NewSymbol("strip-ns")) +if v130.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v130))) +} +v131 := v130.Get() +v132 := lang.Apply(v131, []any{v70}) +v133 := lang.NewVector(v132, v75) +v134 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(274), lang.NewKeyword("column"), int(47), lang.NewKeyword("end-line"), int(274), lang.NewKeyword("end-column"), int(62)) +v135, err := lang.WithMeta(v133, v134.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v136 := lang.Apply(v128, []any{v82, v135}) +var v125 any = v136 +v48 = v123 +v49 = v124 +v50 = v125 +continue +} else { +v120 = nil +} +v90 = v120 +} +v85 = v90 +} else { +v85 = nil +} +v84 = v85 +} else { +v114 := lang.NewVector(v52, v82) +v115 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(275), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(275), lang.NewKeyword("end-column"), int(16)) +v116, err := lang.WithMeta(v114, v115.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v84 = v116 +} +v51 = v84 + break +} +v4 = v51 +} else { +v4 = nil +} +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// nnext +{ +v0 := lang.NewSymbol("nnext").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Same as (next (next x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(119), lang.NewKeyword("end-line"), int(123))).(*lang.Symbol) +var v2 lang.FnFunc +{ // function nnext +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("next")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("next")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v4}) +v12 := lang.Apply(v7, []any{v11}) +return v12 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(123), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(123), lang.NewKeyword("end-column"), int(46))).(lang.FnFunc) +v3 := v2 +_ = v3 +} +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// ex-cause +{ +v0 := lang.NewSymbol("ex-cause").WithMeta(lang.NewMap(lang.NewKeyword("tag"), nil, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ex"))), lang.NewKeyword("doc"), "Returns the cause of ex if ex is a Throwable.\n Otherwise returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4828), lang.NewKeyword("end-line"), int(4828))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{lang1.Throwable, v3}) +if lang.IsTruthy(v8) { +v9, ok := lang.FieldOrMethod(v3, "getCause") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getCause"))) +} +var v10 any +switch reflect.TypeOf(v9).Kind() { +case reflect.Func: + v10 = lang.Apply(v9, nil) +default: + v10 = v9 +} +v4 = v10 +} else { +v4 = nil +} +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// counted? +{ +v0 := lang.NewSymbol("counted?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements count in constant time", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6284), lang.NewKeyword("end-line"), int(6284))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{lang1.Counted, v3}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// bit-xor +{ +var v1 lang.FnFunc +v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v2 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +if lang.IsTruthy(v7) { +v4 = closed13 +} else { +v4 = v3 +} +var v3 any = v4 +_ = v3 +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("seq")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("concat")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("seq")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("concat")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v2}) +v40 := lang.Apply(v31, []any{v35, v39}) +v41 := lang.Apply(v28, []any{v40}) +v42 := lang.Apply(v25, []any{v41}) +v43 := lang.Apply(v14, []any{v18, v22, v42}) +v44 := lang.Apply(v11, []any{v43}) +return v44 + case 2: +v2 := args[0] +v3 := args[1] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +if lang.IsTruthy(v8) { +v5 = closed13 +} else { +v5 = v4 +} +var v4 any = v5 +_ = v4 +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("seq")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("concat")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("list")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("list")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("list")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("seq")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("concat")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("list")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v4}) +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("list")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v2}) +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("list")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v3}) +v45 := lang.Apply(v32, []any{v36, v40, v44}) +v46 := lang.Apply(v29, []any{v45}) +v47 := lang.Apply(v26, []any{v46}) +v48 := lang.Apply(v15, []any{v19, v23, v47}) +v49 := lang.Apply(v12, []any{v48}) +return v49 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v2 := args[0] +v3 := args[1] +v4 := lang.NewList(args[2:]...) +var v6 any +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +if lang.IsTruthy(v9) { +v6 = closed13 +} else { +v6 = v5 +} +var v5 any = v6 +_ = v5 +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +var v14 lang.FnFunc +v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v15 := args[0] +v16 := args[1] +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v5}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v15}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v16}) +v52 := lang.Apply(v39, []any{v43, v47, v51}) +v53 := lang.Apply(v36, []any{v52}) +v54 := lang.Apply(v33, []any{v53}) +v55 := lang.Apply(v22, []any{v26, v30, v54}) +v56 := lang.Apply(v19, []any{v55}) +return v56 +}) +v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) +v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v5}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v2}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v3}) +v52 := lang.Apply(v39, []any{v43, v47, v51}) +v53 := lang.Apply(v36, []any{v52}) +v54 := lang.Apply(v33, []any{v53}) +v55 := lang.Apply(v22, []any{v26, v30, v54}) +v56 := lang.Apply(v19, []any{v55}) +v57 := lang.Apply(v13, []any{v16, v56, v4}) +return v57 + } +}) +v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) +} +v5 := lang.Apply(v4, []any{v3, int64(1)}) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v0 := lang.NewSymbol("bit-xor").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Bitwise exclusive or", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1316), lang.NewKeyword("end-line"), int(1316))).(*lang.Symbol) +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v5 := args[0] +v6 := args[1] +v7, _ := lang.FieldOrMethod(lang1.Numbers, "xor") +if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("xor is not a function"))) +} +v8 := lang.Apply(v7, []any{v5, v6}) +return v8 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +v6 := args[1] +v7 := lang.NewList(args[2:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("bit-xor")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("bit-xor")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v5, v6}) +v18 := lang.Apply(v10, []any{v13, v17, v7}) +return v18 + } +}) +v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v3 := ns.InternWithValue(v0, v4, true) +if v0.Meta() != nil { + v3.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// re-seq +{ +v0 := lang.NewSymbol("re-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("re"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns a lazy sequence of successive matches of pattern in string,\n using java.util.regex.Matcher.find(), each such match processed with\n re-groups.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4898), lang.NewKeyword("end-line"), int(4898))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("re-matcher")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v3, v4}) +var v5 any = v9 +_ = v5 +var v11 lang.FnFunc +{ // function step +v11 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +var v13 any +v14, _ := lang.FieldOrMethod(v5, "find") +if reflect.TypeOf(v14).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("find is not a function"))) +} +v15 := lang.Apply(v14, []any{}) +if lang.IsTruthy(v15) { +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("cons")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("re-groups")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v5}) +var v23 lang.FnFunc +v23 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v24 := lang.Apply(v12, nil) +return v24 +}) +v24 := lang.Apply(lang1.NewLazySeq, []any{v23}) +v25 := lang.Apply(v18, []any{v22, v24}) +v13 = v25 +} else { +v13 = nil +} +return v13 +}) +v12 := v11 +_ = v12 +} +v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4906), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(4908), lang.NewKeyword("end-column"), int(49)) +v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v14 := lang.Apply(v13, nil) +return v14 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// remove-method +{ +v0 := lang.NewSymbol("remove-method").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"), lang.NewSymbol("dispatch-val"))), lang.NewKeyword("doc"), "Removes the method of multimethod associated with dispatch-value.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1794), lang.NewKeyword("end-line"), int(1794))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5, _ := lang.FieldOrMethod(v3, "removeMethod") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("removeMethod is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// parse-boolean +{ +v0 := lang.NewSymbol("parse-boolean").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse strings \"true\" or \"false\" and return a boolean, or nil if invalid", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(8010), lang.NewKeyword("end-line"), int(8010))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("string?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +if lang.IsTruthy(v8) { +var v9 any = v3 +_ = v9 +v4 = nil +} else { +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("parsing-err")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v3}) +v13 := lang.Apply(lang1.NewIllegalArgumentError, []any{v12}) +panic(v13) +} +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// max +{ +var v1 lang.FnFunc +v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v2 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +if lang.IsTruthy(v7) { +v4 = closed14 +} else { +v4 = v3 +} +var v3 any = v4 +_ = v3 +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("seq")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("concat")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("seq")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("concat")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v2}) +v40 := lang.Apply(v31, []any{v35, v39}) +v41 := lang.Apply(v28, []any{v40}) +v42 := lang.Apply(v25, []any{v41}) +v43 := lang.Apply(v14, []any{v18, v22, v42}) +v44 := lang.Apply(v11, []any{v43}) +return v44 + case 2: +v2 := args[0] +v3 := args[1] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +if lang.IsTruthy(v8) { +v5 = closed14 +} else { +v5 = v4 +} +var v4 any = v5 +_ = v4 +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("seq")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("concat")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("list")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("list")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("list")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("seq")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("concat")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("list")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v4}) +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("list")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v2}) +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("list")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v3}) +v45 := lang.Apply(v32, []any{v36, v40, v44}) +v46 := lang.Apply(v29, []any{v45}) +v47 := lang.Apply(v26, []any{v46}) +v48 := lang.Apply(v15, []any{v19, v23, v47}) +v49 := lang.Apply(v12, []any{v48}) +return v49 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v2 := args[0] +v3 := args[1] +v4 := lang.NewList(args[2:]...) +var v6 any +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +if lang.IsTruthy(v9) { +v6 = closed14 +} else { +v6 = v5 +} +var v5 any = v6 +_ = v5 +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +var v14 lang.FnFunc +v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v15 := args[0] +v16 := args[1] +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v5}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v15}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v16}) +v52 := lang.Apply(v39, []any{v43, v47, v51}) +v53 := lang.Apply(v36, []any{v52}) +v54 := lang.Apply(v33, []any{v53}) +v55 := lang.Apply(v22, []any{v26, v30, v54}) +v56 := lang.Apply(v19, []any{v55}) +return v56 +}) +v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) +v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v5}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v2}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v3}) +v52 := lang.Apply(v39, []any{v43, v47, v51}) +v53 := lang.Apply(v36, []any{v52}) +v54 := lang.Apply(v33, []any{v53}) +v55 := lang.Apply(v22, []any{v26, v30, v54}) +v56 := lang.Apply(v19, []any{v55}) +v57 := lang.Apply(v13, []any{v16, v56, v4}) +return v57 + } +}) +v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) +} +v5 := lang.Apply(v4, []any{v3, int64(1)}) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v0 := lang.NewSymbol("max").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the greatest of the nums.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1108), lang.NewKeyword("end-line"), int(1108))).(*lang.Symbol) +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v5 := args[0] +return v5 + case 2: +v5 := args[0] +v6 := args[1] +v7, _ := lang.FieldOrMethod(lang1.Numbers, "max") +if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("max is not a function"))) +} +v8 := lang.Apply(v7, []any{v5, v6}) +return v8 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +v6 := args[1] +v7 := lang.NewList(args[2:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("max")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("max")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v5, v6}) +v18 := lang.Apply(v10, []any{v13, v17, v7}) +return v18 + } +}) +v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v3 := ns.InternWithValue(v0, v4, true) +if v0.Meta() != nil { + v3.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// *compiler-options* +{ +v0 := lang.NewSymbol("*compiler-options*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.4", lang.NewKeyword("doc"), "A map of keys to options.\n Note, when binding dynamically make sure to merge with previous value.\n Supported options:\n :elide-meta - a collection of metadata keys to elide during compilation.\n :disable-locals-clearing - set to true to disable clearing, useful for using a debugger\n :direct-linking - set to true to use direct static invocation of functions, rather than vars\n Note that call sites compiled with direct linking will not be affected by var redefinition.\n Use ^:redef (or ^:dynamic) on a var to prevent direct linking and allow redefinition.\n See https://glojure.org/reference/compilation for more information.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, nil, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// > +{ +var v1 lang.FnFunc +{ // function >__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("concat")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("list")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("seq")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("concat")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("list")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/gt")}) +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v4}) +v40 := lang.Apply(v27, []any{v31, v35, v39}) +v41 := lang.Apply(v24, []any{v40}) +v42 := lang.Apply(v21, []any{v41}) +v43 := lang.Apply(v10, []any{v14, v18, v42}) +v44 := lang.Apply(v7, []any{v43}) +return v44 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol(">").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns non-nil if nums are in monotonically decreasing order,\n otherwise false.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1063), lang.NewKeyword("end-line"), int(1063))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v4 := args[0] +return true + case 2: +v4 := args[0] +v5 := args[1] +v6, _ := lang.FieldOrMethod(lang1.Numbers, "gt") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("gt is not a function"))) +} +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := args[1] +v6 := lang.NewList(args[2:]...) +recur_loop_198: +var v7 any +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol(">")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v4, v5}) +if lang.IsTruthy(v11) { +var v12 any +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("next")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v6}) +if lang.IsTruthy(v16) { +var v17 any = v5 +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("first")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v6}) +var v18 any = v22 +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("next")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v6}) +var v23 any = v27 +v4 = v17 +v5 = v18 +v6 = v23 +goto recur_loop_198 +} else { +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol(">")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("first")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v6}) +v35 := lang.Apply(v30, []any{v5, v34}) +v12 = v35 +} +v7 = v12 +} else { +v7 = false +} +return v7 + } +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// aset-float +{ +v0 := lang.NewSymbol("aset-float").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of float. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3961), lang.NewKeyword("end-line"), int(3963))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("float")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v5}) +v10, _ := lang.FieldOrMethod(nil, "setFloat") +if reflect.TypeOf(v10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setFloat is not a function"))) +} +v11 := lang.Apply(v10, []any{v3, v4, v9}) +_ = v11 +return v5 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("apply")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("aset-float")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("aget")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v3, v4}) +v17 := lang.Apply(v9, []any{v12, v16, v5, v6}) +return v17 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// defmethod +{ +v0 := lang.NewSymbol("defmethod").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"), lang.NewSymbol("dispatch-val"), lang.NewSymbol("&"), lang.NewSymbol("fn-tail"))), lang.NewKeyword("doc"), "Creates and installs a new method of multimethod associated with dispatch-value. ", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1781), lang.NewKeyword("end-line"), int(1781))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := lang.NewList(args[4:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("seq")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("concat")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol(".")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("with-meta")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.NewMap(lang.NewKeyword("tag"), lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.*MultiFn")) +v25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1785), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(1785), lang.NewKeyword("end-column"), int(82)) +v26, err := lang.WithMeta(v24, v25.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v27 := lang.Apply(v23, []any{v5, v26}) +v28 := lang.Apply(v20, []any{v27}) +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("list")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.Apply(v31, []any{lang.NewSymbol("glojure.core/AddMethod")}) +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("list")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v6}) +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("list")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("seq")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("concat")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +} +v45 := v44.Get() +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("list")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +} +v48 := v47.Get() +v49 := lang.Apply(v48, []any{lang.NewSymbol("glojure.core/fn")}) +v50 := lang.Apply(v45, []any{v49, v7}) +v51 := lang.Apply(v42, []any{v50}) +v52 := lang.Apply(v39, []any{v51}) +v53 := lang.Apply(v13, []any{v17, v28, v32, v36, v52}) +v54 := lang.Apply(v10, []any{v53}) +return v54 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// elide-top-frames +{ +v0 := lang.NewSymbol("elide-top-frames").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4794), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(4794), lang.NewKeyword("end-column"), int(32), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ex"), lang.NewSymbol("class-name"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v6, ok := lang.FieldOrMethod(v3, "getStackTrace") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getStackTrace"))) +} +var v7 any +switch reflect.TypeOf(v6).Kind() { +case reflect.Func: + v7 = lang.Apply(v6, nil) +default: + v7 = v6 +} +var v5 any = v7 +_ = v5 +var v9 any = v3 +_ = v9 +var v11 any +if lang.IsTruthy(v5) { +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("into-array")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("drop-while")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +var v18 lang.FnFunc +v18 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v19 := args[0] +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("=")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23, ok := lang.FieldOrMethod(v19, "getClassName") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v19, "getClassName"))) +} +var v24 any +switch reflect.TypeOf(v23).Kind() { +case reflect.Func: + v24 = lang.Apply(v23, nil) +default: + v24 = v23 +} +v25 := lang.Apply(v22, []any{v4, v24}) +return v25 +}) +v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4801), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(4801), lang.NewKeyword("end-column"), int(77)) +v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v21 := lang.Apply(v17, []any{v20, v5}) +v22 := lang.Apply(v14, []any{nil, v21}) +v11 = v22 +} else { +v11 = nil +} +v23, _ := lang.FieldOrMethod(v9, "setStackTrace") +if reflect.TypeOf(v23).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setStackTrace is not a function"))) +} +v24 := lang.Apply(v23, []any{v11}) +_ = v24 +return v9 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// sorted-map +{ +v0 := lang.NewSymbol("sorted-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keyvals"))), lang.NewKeyword("doc"), "keyval => key val\n Returns a new sorted map with supplied mappings. If any keys are\n equal, they are handled as if by repeated uses of assoc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(397), lang.NewKeyword("end-line"), int(397))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.NewList(args[0:]...) +v4 := lang.Apply(lang1.CreatePersistentTreeMap, []any{v3}) +return v4 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// reductions +{ +v0 := lang.NewSymbol("reductions").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy seq of the intermediate values of the reduction (as\n per reduce) of coll by f, starting with init.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7239), lang.NewKeyword("end-line"), int(7239))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v3 := args[0] +v4 := args[1] +var v5 lang.FnFunc +v5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("seq")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v4}) +var v6 any = v10 +_ = v6 +var v12 any +if lang.IsTruthy(v6) { +var v13 any = v6 +_ = v13 +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("reductions")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("first")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, []any{v13}) +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("rest")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v13}) +v26 := lang.Apply(v17, []any{v3, v21, v25}) +v12 = v26 +} else { +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("list")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v3, nil) +v17 := lang.Apply(v15, []any{v16}) +v12 = v17 +} +return v12 +}) +v6 := lang.Apply(lang1.NewLazySeq, []any{v5}) +return v6 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +var v6 any +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("reduced?")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v4}) +if lang.IsTruthy(v10) { +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("list")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("deref")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v4}) +v18 := lang.Apply(v13, []any{v17}) +v6 = v18 +} else { +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("cons")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +var v22 lang.FnFunc +v22 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("seq")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v5}) +var v23 any = v27 +_ = v23 +var v29 any +if lang.IsTruthy(v23) { +var v30 any = v23 +_ = v30 +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("reductions")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("first")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v37, []any{v30}) +v39 := lang.Apply(v3, []any{v4, v38}) +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("rest")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v30}) +v44 := lang.Apply(v34, []any{v3, v39, v43}) +v29 = v44 +} else { +v29 = nil +} +return v29 +}) +v23 := lang.Apply(lang1.NewLazySeq, []any{v22}) +v24 := lang.Apply(v21, []any{v4, v23}) +v6 = v24 +} +return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// reverse +{ +v0 := lang.NewSymbol("reverse").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a seq of the items in coll in reverse order. Not lazy.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(940), lang.NewKeyword("end-line"), int(940))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("reduce1")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("conj")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v6, []any{v9, lang.NewList(), v3}) +return v10 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// ref-history-count +{ +v0 := lang.NewSymbol("ref-history-count").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref"))), lang.NewKeyword("doc"), "Returns the history count of a ref", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2455), lang.NewKeyword("end-line"), int(2455))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, ok := lang.FieldOrMethod(v3, "getHistoryCount") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getHistoryCount"))) +} +var v5 any +switch reflect.TypeOf(v4).Kind() { +case reflect.Func: + v5 = lang.Apply(v4, nil) +default: + v5 = v4 +} +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// *file* +{ +v0 := lang.NewSymbol("*file*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "The path of the file being evaluated, as a String.\n\n When there is no file, e.g. in the REPL, the value is not defined.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, "NO_SOURCE_FILE", true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// make-array +{ +v0 := lang.NewSymbol("make-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("type"), lang.NewSymbol("len")), lang.NewVector(lang.NewSymbol("type"), lang.NewSymbol("dim"), lang.NewSymbol("&"), lang.NewSymbol("more-dims"))), lang.NewKeyword("doc"), "Creates and returns an array of instances of the specified class of\n the specified dimension(s). Note that a class object is required.\n Class objects can be obtained by using their imported or\n fully-qualified name. Class objects for the primitive types can be\n obtained using, e.g., Integer/TYPE.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3985), lang.NewKeyword("end-line"), int(3985))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("int")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v4}) +v9, _ := lang.FieldOrMethod(nil, "newInstance") +if reflect.TypeOf(v9).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("newInstance is not a function"))) +} +v10 := lang.Apply(v9, []any{v3, v8}) +return v10 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("cons")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v4, v5}) +var v6 any = v10 +_ = v6 +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("make-array")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15, ok := lang.FieldOrMethod(nil, "TYPE") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "TYPE"))) +} +var v16 any +switch reflect.TypeOf(v15).Kind() { +case reflect.Func: + v16 = lang.Apply(v15, nil) +default: + v16 = v15 +} +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("count")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v6}) +v21 := lang.Apply(v14, []any{v16, v20}) +var v11 any = v21 +_ = v11 +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("long")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("alength")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{v11}) +v31 := lang.Apply(v26, []any{v30}) +var v23 any = v31 +_ = v23 +var v33 any = int64(0) +_ = v33 +var v34 any +for { +var v35 any +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("<")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v33, v23}) +if lang.IsTruthy(v39) { +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("aset-int")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("nth")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +} +v45 := v44.Get() +v46 := lang.Apply(v45, []any{v6, v33}) +v47 := lang.Apply(v42, []any{v11, v33, v46}) +_ = v47 +v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v50 := v49.FindInternedVar(lang.NewSymbol("unchecked-inc")) +if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) +} +v51 := v50.Get() +v52 := lang.Apply(v51, []any{v33}) +var v48 any = v52 +v33 = v48 +continue +} else { +v35 = nil +} +v34 = v35 + break +} +_ = v34 +v23, _ := lang.FieldOrMethod(nil, "newInstance") +if reflect.TypeOf(v23).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("newInstance is not a function"))) +} +v24 := lang.Apply(v23, []any{v3, v11}) +return v24 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// re-pattern +{ +v1 := reflect.TypeOf((*regexp33.Regexp)(nil)) +v0 := lang.NewSymbol("re-pattern").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns an instance of java.util.regex.Pattern, for use, e.g. in\n re-matcher.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4863), lang.NewKeyword("end-line"), int(4863))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{regexp33.*Regexp, v4}) +if lang.IsTruthy(v9) { +v5 = v4 +} else { +v10 := lang.Apply(regexp33.MustCompile, []any{v4}) +v5 = v10 +} +return v5 +}) +v4 := reflect.TypeOf((*regexp33.Regexp)(nil)) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// into +{ +v0 := lang.NewSymbol("into").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("to")), lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("from")), lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("xform"), lang.NewSymbol("from"))), lang.NewKeyword("doc"), "Returns a new coll consisting of to with all of the items of\n from conjoined. A transducer may be supplied.\n (into x) returns x. (into) returns [].", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6965), lang.NewKeyword("end-line"), int(6965))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v3 := lang.NewVector() +v4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6971), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(6971), lang.NewKeyword("end-column"), int(8)) +v5, err := lang.WithMeta(v3, v4.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v5 + case 1: +v3 := args[0] +return v3 + case 2: +v3 := args[0] +v4 := args[1] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{lang1.IEditableCollection, v3}) +if lang.IsTruthy(v9) { +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("with-meta")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("persistent!")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("reduce")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("conj!")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("transient")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v3}) +v26 := lang.Apply(v18, []any{v21, v25, v4}) +v27 := lang.Apply(v15, []any{v26}) +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("meta")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{v3}) +v32 := lang.Apply(v12, []any{v27, v31}) +v5 = v32 +} else { +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("reduce")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("conj")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v35, []any{v38, v3, v4}) +v5 = v39 +} +return v5 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +var v6 any +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("instance?")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{lang1.IEditableCollection, v3}) +if lang.IsTruthy(v10) { +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("meta")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v3}) +var v11 any = v15 +_ = v11 +var v17 lang.FnFunc +v17 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v18 := args[0] +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("with-meta")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("persistent!")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v18}) +v26 := lang.Apply(v21, []any{v25, v11}) +return v26 + case 2: +v18 := args[0] +v19 := args[1] +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("conj!")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.Apply(v22, []any{v18, v19}) +return v23 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6980), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(6982), lang.NewKeyword("end-column"), int(44)) +v19, err := lang.WithMeta(v17, v18.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v16 any = v19 +_ = v16 +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("transduce")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("transient")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v3}) +v28 := lang.Apply(v23, []any{v4, v16, v27, v5}) +v6 = v28 +} else { +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("transduce")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("conj")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v13, []any{v4, v16, v3, v5}) +v6 = v17 +} +return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// list* +{ +v0 := lang.NewSymbol("list*").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Creates a new seq containing the items prepended to the rest, the\n last of which will be treated as a sequence.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(641), lang.NewKeyword("end-line"), int(641))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{v3}) +return v7 + case 2: +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("cons")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3, v4}) +return v8 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("cons")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("cons")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v4, v5}) +v13 := lang.Apply(v8, []any{v3, v12}) +return v13 + case 4: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("cons")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("cons")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("cons")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v5, v6}) +v17 := lang.Apply(v12, []any{v4, v16}) +v18 := lang.Apply(v9, []any{v3, v17}) +return v18 + default: + if len(args) < 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := lang.NewList(args[4:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("cons")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("cons")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("cons")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("cons")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("spread")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.Apply(v22, []any{v7}) +v24 := lang.Apply(v19, []any{v6, v23}) +v25 := lang.Apply(v16, []any{v5, v24}) +v26 := lang.Apply(v13, []any{v4, v25}) +v27 := lang.Apply(v10, []any{v3, v26}) +return v27 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// load-lib +{ +v0 := lang.NewSymbol("load-lib").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("prefix"), lang.NewSymbol("lib"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Loads a lib with options", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5947), lang.NewKeyword("end-line"), int(5947), lang.NewKeyword("private"), true)).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("throw-if")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +var v9 any = v3 +_ = v9 +var v11 any +if lang.IsTruthy(v9) { +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("pos?")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("name")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v4}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("int")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{lang.NewChar(46)}) +v23 := lang.Apply(strings22.Index, []any{v18, v22}) +v24 := lang.Apply(v14, []any{v23}) +v11 = v24 +} else { +v11 = v9 +} +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("name")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v4}) +v13 := lang.Apply(v8, []any{v11, "Found lib name '%s' containing period with prefix '%s'. lib names inside prefix lists must not contain periods", v12, v3}) +_ = v13 +var v15 any +if lang.IsTruthy(v3) { +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("symbol")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("str")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v3, lang.NewChar(46), v14}) +v23 := lang.Apply(v18, []any{v22}) +v15 = v23 +} else { +v15 = v14 +} +var v14 any = v15 +_ = v14 +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("apply")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("hash-map")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v27, []any{v30, v5}) +var v24 any = v31 +_ = v24 +var v32 any = v24 +_ = v32 +var v34 any +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("seq?")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v37, []any{v33}) +if lang.IsTruthy(v38) { +var v39 any +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("next")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v33}) +if lang.IsTruthy(v43) { +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("to-array")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v33}) +v48 := lang.Apply(lang1.NewPersistentArrayMapAsIfByAssoc, []any{v47}) +v39 = v48 +} else { +var v49 any +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("seq")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +} +v52 := v51.Get() +v53 := lang.Apply(v52, []any{v33}) +if lang.IsTruthy(v53) { +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("first")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +} +v56 := v55.Get() +v57 := lang.Apply(v56, []any{v33}) +v49 = v57 +} else { +v49 = nil +} +v39 = v49 +} +v34 = v39 +} else { +v34 = v33 +} +var v33 any = v34 +_ = v33 +v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v60 := v59.FindInternedVar(lang.NewSymbol("get")) +if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) +} +v61 := v60.Get() +v62 := lang.Apply(v61, []any{v33, lang.NewKeyword("as")}) +var v58 any = v62 +_ = v58 +v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v65 := v64.FindInternedVar(lang.NewSymbol("get")) +if v65.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) +} +v66 := v65.Get() +v67 := lang.Apply(v66, []any{v33, lang.NewKeyword("reload")}) +var v63 any = v67 +_ = v63 +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("get")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +} +v71 := v70.Get() +v72 := lang.Apply(v71, []any{v33, lang.NewKeyword("reload-all")}) +var v68 any = v72 +_ = v68 +v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v75 := v74.FindInternedVar(lang.NewSymbol("get")) +if v75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) +} +v76 := v75.Get() +v77 := lang.Apply(v76, []any{v33, lang.NewKeyword("require")}) +var v73 any = v77 +_ = v73 +v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v80 := v79.FindInternedVar(lang.NewSymbol("get")) +if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) +} +v81 := v80.Get() +v82 := lang.Apply(v81, []any{v33, lang.NewKeyword("use")}) +var v78 any = v82 +_ = v78 +v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v85 := v84.FindInternedVar(lang.NewSymbol("get")) +if v85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) +} +v86 := v85.Get() +v87 := lang.Apply(v86, []any{v33, lang.NewKeyword("verbose")}) +var v83 any = v87 +_ = v83 +v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v90 := v89.FindInternedVar(lang.NewSymbol("get")) +if v90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) +} +v91 := v90.Get() +v92 := lang.Apply(v91, []any{v33, lang.NewKeyword("as-alias")}) +var v88 any = v92 +_ = v88 +v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v95 := v94.FindInternedVar(lang.NewSymbol("contains?")) +if v95.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) +} +v96 := v95.Get() +v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v98 := v97.FindInternedVar(lang.NewSymbol("deref")) +if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) +} +v99 := v98.Get() +v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v101 := v100.FindInternedVar(lang.NewSymbol("*loaded-libs*")) +if v101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) +} +v102 := v101.Get() +v103 := lang.Apply(v99, []any{v102}) +v104 := lang.Apply(v96, []any{v103, v14}) +var v93 any = v104 +_ = v93 +var v106 any = v58 +_ = v106 +var v108 any +if lang.IsTruthy(v106) { +v108 = v106 +} else { +v108 = v78 +} +var v105 any = v108 +_ = v105 +var v107 any +if lang.IsTruthy(v68) { +v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v109 := v108.FindInternedVar(lang.NewSymbol("load-all")) +if v109.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) +} +v110 := v109.Get() +v107 = v110 +} else { +var v111 any +if lang.IsTruthy(v63) { +v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v113 := v112.FindInternedVar(lang.NewSymbol("load-one")) +if v113.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) +} +v114 := v113.Get() +v111 = v114 +} else { +var v115 any +v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v117 := v116.FindInternedVar(lang.NewSymbol("not")) +if v117.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) +} +v118 := v117.Get() +v119 := lang.Apply(v118, []any{v93}) +if lang.IsTruthy(v119) { +var v120 any +if lang.IsTruthy(v105) { +v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v122 := v121.FindInternedVar(lang.NewSymbol("load-one")) +if v122.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) +} +v123 := v122.Get() +v120 = v123 +} else { +var v124 any +if lang.IsTruthy(v88) { +var v125 lang.FnFunc +v125 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v126 := args[0] +v127 := args[1] +v128 := args[2] +v129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v130 := v129.FindInternedVar(lang.NewSymbol("create-ns")) +if v130.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v130))) +} +v131 := v130.Get() +v132 := lang.Apply(v131, []any{v126}) +return v132 +}) +v126 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5961), lang.NewKeyword("column"), int(48), lang.NewKeyword("end-line"), int(5961), lang.NewKeyword("end-column"), int(88)) +v127, err := lang.WithMeta(v125, v126.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v124 = v127 +} else { +var v128 any +if lang.IsTruthy(lang.NewKeyword("else")) { +v129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v130 := v129.FindInternedVar(lang.NewSymbol("load-one")) +if v130.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v130))) +} +v131 := v130.Get() +v128 = v131 +} else { +v128 = nil +} +v124 = v128 +} +v120 = v124 +} +v115 = v120 +} else { +v115 = nil +} +v111 = v115 +} +v107 = v111 +} +var v106 any = v107 +_ = v106 +v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v134 := v133.FindInternedVar(lang.NewSymbol("select-keys")) +if v134.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) +} +v135 := v134.Get() +v136 := lang.Apply(v135, []any{v24, lang.NewList(lang.NewKeyword("exclude"), lang.NewKeyword("only"), lang.NewKeyword("rename"), lang.NewKeyword("refer"))}) +var v132 any = v136 +_ = v132 +v138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v139 := v138.FindInternedVar(lang.NewSymbol("not")) +if v139.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v139))) +} +v140 := v139.Get() +v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v142 := v141.FindInternedVar(lang.NewSymbol("find-ns")) +if v142.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) +} +v143 := v142.Get() +v144 := lang.Apply(v143, []any{v14}) +v145 := lang.Apply(v140, []any{v144}) +var v137 any = v145 +_ = v137 +v148 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v149 := v148.FindInternedVar(lang.NewSymbol("push-thread-bindings")) +if v149.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v149))) +} +v150 := v149.Get() +v151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v152 := v151.FindInternedVar(lang.NewSymbol("hash-map")) +if v152.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v152))) +} +v153 := v152.Get() +v154 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*loading-verbosely*")) +v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v157 := v156.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) +if v157.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) +} +v158 := v157.Get() +var v155 any = v158 +_ = v155 +var v160 any +if lang.IsTruthy(v155) { +v160 = v155 +} else { +v160 = v83 +} +v155 := lang.Apply(v153, []any{v154, v160}) +v156 := lang.Apply(v150, []any{v155}) +_ = v156 +var v157 any +func() { +defer func() { +v158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v159 := v158.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) +if v159.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v159))) +} +v160 := v159.Get() +v161 := lang.Apply(v160, nil) +}() +var v162 any +if lang.IsTruthy(v106) { +var v163 any +func() { +defer func() { +if r := recover(); r != nil { +if lang.CatchMatches(r, lang.Builtins["any"]) { +v164 := r +_ = v164 +var v165 any +if lang.IsTruthy(v137) { +v166 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v167 := v166.FindInternedVar(lang.NewSymbol("remove-ns")) +if v167.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v167))) +} +v168 := v167.Get() +v169 := lang.Apply(v168, []any{v14}) +v165 = v169 +} else { +v165 = nil +} +_ = v165 +panic(v164) +} else { +panic(r) +} +} +}() +v164 := lang.Apply(v106, []any{v14, v105, v73}) +v163 = v164 +}() +v162 = v163 +} else { +v165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v166 := v165.FindInternedVar(lang.NewSymbol("throw-if")) +if v166.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v166))) +} +v167 := v166.Get() +var v168 any = v105 +_ = v168 +var v170 any +if lang.IsTruthy(v168) { +v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v172 := v171.FindInternedVar(lang.NewSymbol("not")) +if v172.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) +} +v173 := v172.Get() +v174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v175 := v174.FindInternedVar(lang.NewSymbol("find-ns")) +if v175.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v175))) +} +v176 := v175.Get() +v177 := lang.Apply(v176, []any{v14}) +v178 := lang.Apply(v173, []any{v177}) +v170 = v178 +} else { +v170 = v168 +} +v168 := lang.Apply(v167, []any{v170, "namespace '%s' not found", v14}) +v162 = v168 +} +_ = v162 +var v169 any +var v170 any = v105 +_ = v170 +var v172 any +if lang.IsTruthy(v170) { +v173 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v174 := v173.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) +if v174.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v174))) +} +v175 := v174.Get() +v172 = v175 +} else { +v172 = v170 +} +if lang.IsTruthy(v172) { +v170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v171 := v170.FindInternedVar(lang.NewSymbol("printf")) +if v171.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v171))) +} +v172 := v171.Get() +v173 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v174 := v173.FindInternedVar(lang.NewSymbol("ns-name")) +if v174.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v174))) +} +v175 := v174.Get() +v176 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v177 := v176.FindInternedVar(lang.NewSymbol("*ns*")) +if v177.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v177))) +} +v178 := v177.Get() +v179 := lang.Apply(v175, []any{v178}) +v180 := lang.Apply(v172, []any{"(glojure.core/in-ns '%s)\n", v179}) +v169 = v180 +} else { +v169 = nil +} +_ = v169 +var v181 any +if lang.IsTruthy(v58) { +var v182 any +v183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v184 := v183.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) +if v184.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v184))) +} +v185 := v184.Get() +if lang.IsTruthy(v185) { +v186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v187 := v186.FindInternedVar(lang.NewSymbol("printf")) +if v187.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v187))) +} +v188 := v187.Get() +v189 := lang.Apply(v188, []any{"(glojure.core/alias '%s '%s)\n", v58, v14}) +v182 = v189 +} else { +v182 = nil +} +_ = v182 +v190 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v191 := v190.FindInternedVar(lang.NewSymbol("alias")) +if v191.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v191))) +} +v192 := v191.Get() +v193 := lang.Apply(v192, []any{v58, v14}) +v181 = v193 +} else { +v181 = nil +} +_ = v181 +var v194 any +if lang.IsTruthy(v88) { +var v195 any +v196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v197 := v196.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) +if v197.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v197))) +} +v198 := v197.Get() +if lang.IsTruthy(v198) { +v199 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v200 := v199.FindInternedVar(lang.NewSymbol("printf")) +if v200.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v200))) +} +v201 := v200.Get() +v202 := lang.Apply(v201, []any{"(glojure.core/alias '%s '%s)\n", v88, v14}) +v195 = v202 +} else { +v195 = nil +} +_ = v195 +v203 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v204 := v203.FindInternedVar(lang.NewSymbol("alias")) +if v204.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v204))) +} +v205 := v204.Get() +v206 := lang.Apply(v205, []any{v88, v14}) +v194 = v206 +} else { +v194 = nil +} +_ = v194 +var v207 any +var v208 any = v78 +_ = v208 +var v210 any +if lang.IsTruthy(v208) { +v210 = v208 +} else { +v211 := lang.Apply(lang.NewKeyword("refer"), []any{v132}) +v210 = v211 +} +if lang.IsTruthy(v210) { +var v208 any +v209 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v210 := v209.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) +if v210.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v210))) +} +v211 := v210.Get() +if lang.IsTruthy(v211) { +v212 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v213 := v212.FindInternedVar(lang.NewSymbol("printf")) +if v213.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v213))) +} +v214 := v213.Get() +v215 := lang.Apply(v214, []any{"(glojure.core/refer '%s", v14}) +_ = v215 +v217 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v218 := v217.FindInternedVar(lang.NewSymbol("seq")) +if v218.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v218))) +} +v219 := v218.Get() +v220 := lang.Apply(v219, []any{v132}) +var v216 any = v220 +_ = v216 +var v221 any = nil +_ = v221 +var v222 any = int64(0) +_ = v222 +var v223 any = int64(0) +_ = v223 +var v224 any +for { +var v225 any +v226 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v227 := v226.FindInternedVar(lang.NewSymbol("<")) +if v227.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v227))) +} +v228 := v227.Get() +v229 := lang.Apply(v228, []any{v223, v222}) +if lang.IsTruthy(v229) { +v231, _ := lang.FieldOrMethod(v221, "nth") +if reflect.TypeOf(v231).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) +} +v232 := lang.Apply(v231, []any{v223}) +var v230 any = v232 +_ = v230 +v234 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v235 := v234.FindInternedVar(lang.NewSymbol("printf")) +if v235.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v235))) +} +v236 := v235.Get() +v237 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v238 := v237.FindInternedVar(lang.NewSymbol("key")) +if v238.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v238))) +} +v239 := v238.Get() +v240 := lang.Apply(v239, []any{v230}) +v241 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v242 := v241.FindInternedVar(lang.NewSymbol("print-str")) +if v242.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v242))) +} +v243 := v242.Get() +v244 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v245 := v244.FindInternedVar(lang.NewSymbol("val")) +if v245.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v245))) +} +v246 := v245.Get() +v247 := lang.Apply(v246, []any{v230}) +v248 := lang.Apply(v243, []any{v247}) +v249 := lang.Apply(v236, []any{" %s '%s", v240, v248}) +_ = v249 +var v250 any = v216 +var v251 any = v221 +var v252 any = v222 +v254 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v255 := v254.FindInternedVar(lang.NewSymbol("unchecked-inc")) +if v255.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v255))) +} +v256 := v255.Get() +v257 := lang.Apply(v256, []any{v223}) +var v253 any = v257 +v216 = v250 +v221 = v251 +v222 = v252 +v223 = v253 +continue +} else { +v231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v232 := v231.FindInternedVar(lang.NewSymbol("seq")) +if v232.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v232))) +} +v233 := v232.Get() +v234 := lang.Apply(v233, []any{v216}) +var v230 any = v234 +_ = v230 +var v236 any +if lang.IsTruthy(v230) { +var v237 any = v230 +_ = v237 +var v239 any +v240 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v241 := v240.FindInternedVar(lang.NewSymbol("chunked-seq?")) +if v241.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v241))) +} +v242 := v241.Get() +v243 := lang.Apply(v242, []any{v237}) +if lang.IsTruthy(v243) { +v245 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v246 := v245.FindInternedVar(lang.NewSymbol("chunk-first")) +if v246.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v246))) +} +v247 := v246.Get() +v248 := lang.Apply(v247, []any{v237}) +var v244 any = v248 +_ = v244 +v251 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v252 := v251.FindInternedVar(lang.NewSymbol("chunk-rest")) +if v252.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v252))) +} +v253 := v252.Get() +v254 := lang.Apply(v253, []any{v237}) +var v250 any = v254 +var v255 any = v244 +v257 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v258 := v257.FindInternedVar(lang.NewSymbol("int")) +if v258.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v258))) +} +v259 := v258.Get() +v260 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v261 := v260.FindInternedVar(lang.NewSymbol("count")) +if v261.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v261))) +} +v262 := v261.Get() +v263 := lang.Apply(v262, []any{v244}) +v264 := lang.Apply(v259, []any{v263}) +var v256 any = v264 +v266 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v267 := v266.FindInternedVar(lang.NewSymbol("int")) +if v267.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v267))) +} +v268 := v267.Get() +v269 := lang.Apply(v268, []any{int64(0)}) +var v265 any = v269 +v216 = v250 +v221 = v255 +v222 = v256 +v223 = v265 +continue +} else { +v245 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v246 := v245.FindInternedVar(lang.NewSymbol("first")) +if v246.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v246))) +} +v247 := v246.Get() +v248 := lang.Apply(v247, []any{v237}) +var v244 any = v248 +_ = v244 +v250 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v251 := v250.FindInternedVar(lang.NewSymbol("printf")) +if v251.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v251))) +} +v252 := v251.Get() +v253 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v254 := v253.FindInternedVar(lang.NewSymbol("key")) +if v254.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v254))) +} +v255 := v254.Get() +v256 := lang.Apply(v255, []any{v244}) +v257 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v258 := v257.FindInternedVar(lang.NewSymbol("print-str")) +if v258.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v258))) +} +v259 := v258.Get() +v260 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v261 := v260.FindInternedVar(lang.NewSymbol("val")) +if v261.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v261))) +} +v262 := v261.Get() +v263 := lang.Apply(v262, []any{v244}) +v264 := lang.Apply(v259, []any{v263}) +v265 := lang.Apply(v252, []any{" %s '%s", v256, v264}) +_ = v265 +v267 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v268 := v267.FindInternedVar(lang.NewSymbol("next")) +if v268.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v268))) +} +v269 := v268.Get() +v270 := lang.Apply(v269, []any{v237}) +var v266 any = v270 +var v271 any = nil +var v272 any = int64(0) +var v273 any = int64(0) +v216 = v266 +v221 = v271 +v222 = v272 +v223 = v273 +continue +} +v236 = v239 +} else { +v236 = nil +} +v225 = v236 +} +v224 = v225 + break +} +_ = v224 +v216 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v217 := v216.FindInternedVar(lang.NewSymbol("printf")) +if v217.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v217))) +} +v218 := v217.Get() +v219 := lang.Apply(v218, []any{")\n"}) +v208 = v219 +} else { +v208 = nil +} +_ = v208 +v220 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v221 := v220.FindInternedVar(lang.NewSymbol("apply")) +if v221.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v221))) +} +v222 := v221.Get() +v223 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v224 := v223.FindInternedVar(lang.NewSymbol("refer")) +if v224.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v224))) +} +v225 := v224.Get() +v226 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v227 := v226.FindInternedVar(lang.NewSymbol("mapcat")) +if v227.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v227))) +} +v228 := v227.Get() +v229 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v230 := v229.FindInternedVar(lang.NewSymbol("seq")) +if v230.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v230))) +} +v231 := v230.Get() +v232 := lang.Apply(v228, []any{v231, v132}) +v233 := lang.Apply(v222, []any{v225, v14, v232}) +v207 = v233 +} else { +v207 = nil +} +v157 = v207 +}() +return v157 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// pvalues +{ +v0 := lang.NewSymbol("pvalues").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("exprs"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the values of the exprs, which are\n evaluated in parallel", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7106), lang.NewKeyword("end-line"), int(7106))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("seq")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("concat")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("list")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{lang.NewSymbol("glojure.core/pcalls")}) +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("map")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +var v19 lang.FnFunc +v19 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v20 := args[0] +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("list")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.NewVector() +v25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7112), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(7112), lang.NewKeyword("end-column"), int(31)) +v26, err := lang.WithMeta(v24, v25.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v27 := lang.Apply(v23, []any{lang.NewSymbol("glojure.core/fn"), v26, v20}) +return v27 +}) +v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7112), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(7112), lang.NewKeyword("end-column"), int(34)) +v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v22 := lang.Apply(v18, []any{v21, v5}) +v23 := lang.Apply(v11, []any{v15, v22}) +v24 := lang.Apply(v8, []any{v23}) +return v24 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// macroexpand-1 +{ +v0 := lang.NewSymbol("macroexpand-1").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("form"))), lang.NewKeyword("doc"), "If form represents a macro form, returns its expansion,\n else returns form.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4017), lang.NewKeyword("end-line"), int(4017))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, _ := lang.FieldOrMethod(runtime3.Compiler, "macroexpand1") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("macroexpand1 is not a function"))) +} +v5 := lang.Apply(v4, []any{v3}) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// methods +{ +v0 := lang.NewSymbol("methods").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"))), lang.NewKeyword("doc"), "Given a multimethod, returns a map of dispatch values -> dispatch fns", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1809), lang.NewKeyword("end-line"), int(1809))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, ok := lang.FieldOrMethod(v3, "getMethodTable") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getMethodTable"))) +} +var v5 any +switch reflect.TypeOf(v4).Kind() { +case reflect.Func: + v5 = lang.Apply(v4, nil) +default: + v5 = v4 +} +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// *compile-path* +{ +v0 := lang.NewSymbol("*compile-path*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "Specifies the directory where 'compile' will write out .class\n files. This directory must be in the classpath for 'compile' to\n work.\n\n Defaults to \"classes\"", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, nil, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// keep +{ +v0 := lang.NewSymbol("keep").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the non-nil results of (f item). Note,\n this means false return values will be included. f must be free of\n side-effects. Returns a transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7382), lang.NewKeyword("end-line"), int(7382))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +var v6 lang.FnFunc +v6 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v7 := lang.Apply(v5, nil) +return v7 + case 1: +v7 := args[0] +v8 := lang.Apply(v5, []any{v7}) +return v8 + case 2: +v7 := args[0] +v8 := args[1] +v10 := lang.Apply(v3, []any{v8}) +var v9 any = v10 +_ = v9 +var v12 any +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("nil?")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v9}) +if lang.IsTruthy(v16) { +v12 = v7 +} else { +v17 := lang.Apply(v5, []any{v7, v9}) +v12 = v17 +} +return v12 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7390), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7397), lang.NewKeyword("end-column"), int(31)) +v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v8 +}) +v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7389), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7397), lang.NewKeyword("end-column"), int(32)) +v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v6 + case 2: +v3 := args[0] +v4 := args[1] +var v5 lang.FnFunc +v5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("seq")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v4}) +var v6 any = v10 +_ = v6 +var v12 any +if lang.IsTruthy(v6) { +var v13 any = v6 +_ = v13 +var v15 any +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("chunked-seq?")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v13}) +if lang.IsTruthy(v19) { +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("chunk-first")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v13}) +var v20 any = v24 +_ = v20 +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("count")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.Apply(v28, []any{v20}) +var v25 any = v29 +_ = v25 +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("chunk-buffer")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v25}) +var v30 any = v34 +_ = v30 +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("long")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v25}) +var v36 any = v40 +_ = v36 +var v42 any = int64(0) +_ = v42 +var v43 any +for { +var v44 any +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("<")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +} +v47 := v46.Get() +v48 := lang.Apply(v47, []any{v42, v36}) +if lang.IsTruthy(v48) { +v50, _ := lang.FieldOrMethod(v20, "nth") +if reflect.TypeOf(v50).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) +} +v51 := lang.Apply(v50, []any{v42}) +v52 := lang.Apply(v3, []any{v51}) +var v49 any = v52 +_ = v49 +var v54 any +v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v56 := v55.FindInternedVar(lang.NewSymbol("nil?")) +if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) +} +v57 := v56.Get() +v58 := lang.Apply(v57, []any{v49}) +if lang.IsTruthy(v58) { +v54 = nil +} else { +v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v60 := v59.FindInternedVar(lang.NewSymbol("chunk-append")) +if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) +} +v61 := v60.Get() +v62 := lang.Apply(v61, []any{v30, v49}) +v54 = v62 +} +_ = v54 +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("unchecked-inc")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +} +v52 := v51.Get() +v53 := lang.Apply(v52, []any{v42}) +var v49 any = v53 +v42 = v49 +continue +} else { +v44 = nil +} +v43 = v44 + break +} +_ = v43 +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("chunk-cons")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("chunk")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +} +v41 := v40.Get() +v42 := lang.Apply(v41, []any{v30}) +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("keep")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +} +v45 := v44.Get() +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("chunk-rest")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +} +v48 := v47.Get() +v49 := lang.Apply(v48, []any{v13}) +v50 := lang.Apply(v45, []any{v3, v49}) +v51 := lang.Apply(v38, []any{v42, v50}) +v15 = v51 +} else { +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("first")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v13}) +v25 := lang.Apply(v3, []any{v24}) +var v20 any = v25 +_ = v20 +var v27 any +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("nil?")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{v20}) +if lang.IsTruthy(v31) { +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("keep")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("rest")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v37, []any{v13}) +v39 := lang.Apply(v34, []any{v3, v38}) +v27 = v39 +} else { +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("cons")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("keep")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +} +v45 := v44.Get() +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("rest")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +} +v48 := v47.Get() +v49 := lang.Apply(v48, []any{v13}) +v50 := lang.Apply(v45, []any{v3, v49}) +v51 := lang.Apply(v42, []any{v20, v50}) +v27 = v51 +} +v15 = v27 +} +v12 = v15 +} else { +v12 = nil +} +return v12 +}) +v6 := lang.Apply(lang1.NewLazySeq, []any{v5}) +return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// parse-impls +{ +v0 := lang.NewSymbol("parse-impls").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(13), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(13), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("specs"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v5 := lang.NewMap() +v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(14), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(14), lang.NewKeyword("end-column"), int(15)) +v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v4 any = v7 +_ = v4 +var v8 any = v3 +_ = v8 +var v9 any +for { +var v10 any +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("seq")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v8}) +if lang.IsTruthy(v14) { +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("assoc")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("first")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v8}) +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("take-while")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("seq?")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("next")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.Apply(v31, []any{v8}) +v33 := lang.Apply(v25, []any{v28, v32}) +v34 := lang.Apply(v18, []any{v4, v22, v33}) +var v15 any = v34 +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("drop-while")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("seq?")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +} +v41 := v40.Get() +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("next")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +} +v44 := v43.Get() +v45 := lang.Apply(v44, []any{v8}) +v46 := lang.Apply(v38, []any{v41, v45}) +var v35 any = v46 +v4 = v15 +v8 = v35 +continue +} else { +v10 = v4 +} +v9 = v10 + break +} +return v9 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// or +{ +v0 := lang.NewSymbol("or").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("next"))), lang.NewKeyword("doc"), "Evaluates exprs one at a time, from left to right. If a form\n returns a logical true value, or returns that value and doesn't\n evaluate any of the other expressions, otherwise it returns the\n value of the last expression. (or) returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(847), lang.NewKeyword("end-line"), int(847))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v3 := args[0] +v4 := args[1] +return nil + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +return v5 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("seq")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("concat")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("list")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/let")}) +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("list")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("apply")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("vector")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("seq")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("concat")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{lang.NewSymbol("or__0__auto__")}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v5}) +v40 := lang.Apply(v31, []any{v35, v39}) +v41 := lang.Apply(v28, []any{v40}) +v42 := lang.Apply(v22, []any{v25, v41}) +v43 := lang.Apply(v19, []any{v42}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("seq")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +} +v49 := v48.Get() +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("concat")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +} +v52 := v51.Get() +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("list")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +} +v55 := v54.Get() +v56 := lang.Apply(v55, []any{lang.NewSymbol("if")}) +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("list")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +} +v59 := v58.Get() +v60 := lang.Apply(v59, []any{lang.NewSymbol("or__0__auto__")}) +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("list")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +} +v63 := v62.Get() +v64 := lang.Apply(v63, []any{lang.NewSymbol("or__0__auto__")}) +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("list")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +} +v67 := v66.Get() +v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v69 := v68.FindInternedVar(lang.NewSymbol("seq")) +if v69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) +} +v70 := v69.Get() +v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v72 := v71.FindInternedVar(lang.NewSymbol("concat")) +if v72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) +} +v73 := v72.Get() +v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v75 := v74.FindInternedVar(lang.NewSymbol("list")) +if v75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) +} +v76 := v75.Get() +v77 := lang.Apply(v76, []any{lang.NewSymbol("glojure.core/or")}) +v78 := lang.Apply(v73, []any{v77, v6}) +v79 := lang.Apply(v70, []any{v78}) +v80 := lang.Apply(v67, []any{v79}) +v81 := lang.Apply(v52, []any{v56, v60, v64, v80}) +v82 := lang.Apply(v49, []any{v81}) +v83 := lang.Apply(v46, []any{v82}) +v84 := lang.Apply(v12, []any{v16, v43, v83}) +v85 := lang.Apply(v9, []any{v84}) +return v85 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// deliver +{ +v0 := lang.NewSymbol("deliver").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("promise"), lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Delivers the supplied value to the promise, releasing any pending\n derefs. A subsequent call to deliver on a promise will have no effect.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7152), lang.NewKeyword("end-line"), int(7152))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.Apply(v3, []any{v4}) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// some? +{ +v1 := reflect.TypeOf(false) +v0 := lang.NewSymbol("some?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is not nil, false otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(530), lang.NewKeyword("end-line"), int(530))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("not")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("nil?")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v4}) +v12 := lang.Apply(v7, []any{v11}) +return v12 +}) +v4 := reflect.TypeOf(false) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// load-one +{ +v0 := lang.NewSymbol("load-one").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"), lang.NewSymbol("need-ns"), lang.NewSymbol("require"))), lang.NewKeyword("doc"), "Loads a lib given its name. If need-ns, ensures that the associated\n namespace exists after loading. If require, records the load so any\n duplicate loads can be skipped.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5922), lang.NewKeyword("end-line"), int(5922), lang.NewKeyword("private"), true)).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("load")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("root-resource")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v3}) +v13 := lang.Apply(v8, []any{v12}) +_ = v13 +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("throw-if")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +var v17 any = v4 +_ = v17 +var v19 any +if lang.IsTruthy(v17) { +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("not")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("find-ns")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{v3}) +v27 := lang.Apply(v22, []any{v26}) +v19 = v27 +} else { +v19 = v17 +} +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("root-resource")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v3}) +v21 := lang.Apply(v16, []any{v19, "namespace '%s' not found after loading '%s'", v3, v20}) +_ = v21 +var v22 any +if lang.IsTruthy(v5) { +var v23 lang.FnFunc +v23 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("commute")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("*loaded-libs*")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("conj")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.Apply(v26, []any{v29, v32, v3}) +return v33 +}) +v24, _ := lang.FieldOrMethod(lang1.LockingTransaction, "RunInTransaction") +if reflect.TypeOf(v24).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("RunInTransaction is not a function"))) +} +v25 := lang.Apply(v24, []any{v23}) +v22 = v25 +} else { +v22 = nil +} +return v22 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// atom +{ +v0 := lang.NewSymbol("atom").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Creates and returns an Atom with an initial value of x and zero or\n more options (in any order):\n\n :meta metadata-map\n\n :validator validate-fn\n\n If metadata-map is supplied, it will become the metadata on the\n atom. validate-fn must be nil or a side-effect-free fn of one\n argument, which will be passed the intended new state on any state\n change. If the new state is unacceptable, the validate-fn should\n return false or throw an exception.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2325), lang.NewKeyword("end-line"), int(2325))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +v4 := lang.Apply(lang1.NewAtom, []any{v3}) +return v4 + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.NewList(args[1:]...) +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("setup-reference")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("atom")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v3}) +v12 := lang.Apply(v7, []any{v11, v4}) +return v12 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// *err* +{ +v0 := lang.NewSymbol("*err*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "A java.io.Writer object representing standard error for print operations.\n\n Defaults to System/err, wrapped in a PrintWriter", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, nil, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// enumeration-seq +{ +v0 := lang.NewSymbol("enumeration-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("e"))), lang.NewKeyword("doc"), "Returns a seq on a java.util.Enumeration", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5753), lang.NewKeyword("end-line"), int(5753))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.Apply(nil, []any{v3}) +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// while +{ +v0 := lang.NewSymbol("while").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("test"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Repeatedly executes body while test expression is true. Presumes\n some side-effect will cause test to become false/nil. Returns nil", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6370), lang.NewKeyword("end-line"), int(6370))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("seq")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("concat")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("list")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/loop")}) +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("list")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("apply")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("vector")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("seq")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("concat")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.Apply(v31, nil) +v33 := lang.Apply(v28, []any{v32}) +v34 := lang.Apply(v22, []any{v25, v33}) +v35 := lang.Apply(v19, []any{v34}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("seq")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +} +v41 := v40.Get() +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("concat")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +} +v44 := v43.Get() +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("list")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +} +v47 := v46.Get() +v48 := lang.Apply(v47, []any{lang.NewSymbol("glojure.core/when")}) +v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v50 := v49.FindInternedVar(lang.NewSymbol("list")) +if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) +} +v51 := v50.Get() +v52 := lang.Apply(v51, []any{v5}) +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("list")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +} +v55 := v54.Get() +v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v57 := v56.FindInternedVar(lang.NewSymbol("seq")) +if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) +} +v58 := v57.Get() +v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v60 := v59.FindInternedVar(lang.NewSymbol("concat")) +if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) +} +v61 := v60.Get() +v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v63 := v62.FindInternedVar(lang.NewSymbol("list")) +if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +} +v64 := v63.Get() +v65 := lang.Apply(v64, []any{lang.NewSymbol("recur")}) +v66 := lang.Apply(v61, []any{v65}) +v67 := lang.Apply(v58, []any{v66}) +v68 := lang.Apply(v55, []any{v67}) +v69 := lang.Apply(v44, []any{v48, v52, v6, v68}) +v70 := lang.Apply(v41, []any{v69}) +v71 := lang.Apply(v38, []any{v70}) +v72 := lang.Apply(v12, []any{v16, v35, v71}) +v73 := lang.Apply(v9, []any{v72}) +return v73 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// meta +{ +v0 := lang.NewSymbol("meta").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("obj"))), lang.NewKeyword("doc"), "Returns the metadata of obj, returns nil if there is no metadata.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(202), lang.NewKeyword("end-line"), int(206))).(*lang.Symbol) +var v2 lang.FnFunc +{ // function meta +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{lang1.IMeta, v4}) +if lang.IsTruthy(v9) { +v10, ok := lang.FieldOrMethod(v4, "Meta") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "Meta"))) +} +var v11 any +switch reflect.TypeOf(v10).Kind() { +case reflect.Func: + v11 = lang.Apply(v10, nil) +default: + v11 = v10 +} +v5 = v11 +} else { +v5 = nil +} +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(206), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(208), lang.NewKeyword("end-column"), int(21))).(lang.FnFunc) +v3 := v2 +_ = v3 +} +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// dec' +{ +var v1 lang.FnFunc +{ // function dec'__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/decP")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v3}) +v35 := lang.Apply(v26, []any{v30, v34}) +v36 := lang.Apply(v23, []any{v35}) +v37 := lang.Apply(v20, []any{v36}) +v38 := lang.Apply(v9, []any{v13, v17, v37}) +v39 := lang.Apply(v6, []any{v38}) +return v39 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("dec'").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns a number one less than num. Supports arbitrary precision.\n See also: dec", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1140), lang.NewKeyword("end-line"), int(1140))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "decP") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("decP is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// into1 +{ +v0 := lang.NewSymbol("into1").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("from"))), lang.NewKeyword("doc"), "Returns a new coll consisting of to-coll with all of the items of\n from-coll conjoined.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3416), lang.NewKeyword("end-line"), int(3416), lang.NewKeyword("private"), true)).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{lang1.IEditableCollection, v3}) +if lang.IsTruthy(v9) { +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("persistent!")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("reduce1")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("conj!")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("transient")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v3}) +v23 := lang.Apply(v15, []any{v18, v22, v4}) +v24 := lang.Apply(v12, []any{v23}) +v5 = v24 +} else { +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("reduce1")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("conj")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v27, []any{v30, v3, v4}) +v5 = v31 +} +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// println +{ +v0 := lang.NewSymbol("println").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Same as print followed by (newline)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3734), lang.NewKeyword("end-line"), int(3734))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.NewList(args[0:]...) +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("push-thread-bindings")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("hash-map")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*print-readably*")) +v12 := lang.Apply(v10, []any{v11, nil}) +v13 := lang.Apply(v7, []any{v12}) +_ = v13 +var v14 any +func() { +defer func() { +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, nil) +}() +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("apply")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("prn")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v21, []any{v24, v3}) +v14 = v25 +}() +return v14 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// drop +{ +v0 := lang.NewSymbol("drop").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a laziness-preserving sequence of all but the first n items in coll.\n Returns a stateful transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2901), lang.NewKeyword("end-line"), int(2901))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("volatile!")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v3}) +var v6 any = v10 +_ = v6 +var v12 lang.FnFunc +v12 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v13 := lang.Apply(v5, nil) +return v13 + case 1: +v13 := args[0] +v14 := lang.Apply(v5, []any{v13}) +return v14 + case 2: +v13 := args[0] +v14 := args[1] +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("deref")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v6}) +var v15 any = v19 +_ = v15 +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("dec")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24, ok := lang.FieldOrMethod(v6, "Deref") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "Deref"))) +} +var v25 any +switch reflect.TypeOf(v24).Kind() { +case reflect.Func: + v25 = lang.Apply(v24, nil) +default: + v25 = v24 +} +v26 := lang.Apply(v23, []any{v25}) +v27, _ := lang.FieldOrMethod(v6, "reset") +if reflect.TypeOf(v27).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) +} +v28 := lang.Apply(v27, []any{v26}) +_ = v28 +var v29 any +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("pos?")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.Apply(v32, []any{v15}) +if lang.IsTruthy(v33) { +v29 = v13 +} else { +v34 := lang.Apply(v5, []any{v13, v14}) +v29 = v34 +} +return v29 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2909), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(2917), lang.NewKeyword("end-column"), int(39)) +v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v14 +}) +v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2907), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2917), lang.NewKeyword("end-column"), int(41)) +v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v6 + case 2: +v3 := args[0] +v4 := args[1] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{lang1.IDrop, v4}) +if lang.IsTruthy(v9) { +var v11 any +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("pos?")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v3}) +if lang.IsTruthy(v15) { +var v16 any +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("int?")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v3}) +if lang.IsTruthy(v20) { +v16 = v3 +} else { +v21 := lang.Apply(nil, []any{v3}) +v16 = v21 +} +v22, _ := lang.FieldOrMethod(v4, "drop") +if reflect.TypeOf(v22).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("drop is not a function"))) +} +v23 := lang.Apply(v22, []any{v16}) +v11 = v23 +} else { +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("seq")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v4}) +v11 = v27 +} +var v10 any = v11 +_ = v10 +var v29 any +if lang.IsTruthy(v10) { +v29 = v10 +} else { +v29 = lang.NewList() +} +v5 = v29 +} else { +var v11 lang.FnFunc +v11 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v12 := args[0] +v13 := args[1] +recur_loop_539: +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("seq")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v13}) +var v14 any = v18 +_ = v14 +var v20 any +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("pos?")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v12}) +var v21 any = v25 +_ = v21 +var v27 any +if lang.IsTruthy(v21) { +v27 = v14 +} else { +v27 = v21 +} +if lang.IsTruthy(v27) { +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("dec")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v12}) +var v21 any = v25 +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("rest")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{v14}) +var v26 any = v30 +v12 = v21 +v13 = v26 +goto recur_loop_539 +} else { +v20 = v14 +} +return v20 +}) +v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2925), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(2929), lang.NewKeyword("end-column"), int(28)) +v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v10 any = v13 +_ = v10 +var v15 lang.FnFunc +v15 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v16 := lang.Apply(v10, []any{v3, v4}) +return v16 +}) +v16 := lang.Apply(lang1.NewLazySeq, []any{v15}) +v5 = v16 +} +return v5 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// the-ns +{ +v0 := lang.NewSymbol("the-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "If passed a namespace, returns it. Else, when passed a symbol,\n returns the namespace named by it, throwing an exception if not\n found.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4152), lang.NewKeyword("end-line"), int(4152))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{lang1.*Namespace, v3}) +if lang.IsTruthy(v8) { +v4 = v3 +} else { +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("find-ns")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{v3}) +var v9 any = v13 +_ = v9 +var v15 any +if lang.IsTruthy(v9) { +v15 = v9 +} else { +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("str")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{"No namespace: ", v3, " found"}) +v20 := lang.Apply(Exception25., []any{v19}) +panic(v20) +} +v4 = v15 +} +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// descriptor +{ +v0 := lang.NewSymbol("descriptor").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5482), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(5482), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.Apply(nil, []any{v3}) +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// process-annotation +{ +v0 := lang.NewSymbol("process-annotation").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5505), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(5505), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("av"), lang.NewSymbol("v"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("map?")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v4}) +if lang.IsTruthy(v9) { +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("seq")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v4}) +var v10 any = v14 +_ = v10 +var v15 any = nil +_ = v15 +var v16 any = int64(0) +_ = v16 +var v17 any = int64(0) +_ = v17 +var v18 any +for { +var v19 any +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("<")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.Apply(v22, []any{v17, v16}) +if lang.IsTruthy(v23) { +v25, _ := lang.FieldOrMethod(v15, "nth") +if reflect.TypeOf(v25).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) +} +v26 := lang.Apply(v25, []any{v17}) +var v24 any = v26 +_ = v24 +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("nth")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{v24, int64(0), nil}) +var v27 any = v31 +_ = v27 +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("nth")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v24, int64(1), nil}) +var v32 any = v36 +_ = v32 +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("add-annotation")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("name")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v27}) +v45 := lang.Apply(v40, []any{v3, v44, v32}) +_ = v45 +var v46 any = v10 +var v47 any = v15 +var v48 any = v16 +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("unchecked-inc")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +} +v52 := v51.Get() +v53 := lang.Apply(v52, []any{v17}) +var v49 any = v53 +v10 = v46 +v15 = v47 +v16 = v48 +v17 = v49 +continue +} else { +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("seq")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.Apply(v27, []any{v10}) +var v24 any = v28 +_ = v24 +var v30 any +if lang.IsTruthy(v24) { +var v31 any = v24 +_ = v31 +var v33 any +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("chunked-seq?")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.Apply(v36, []any{v31}) +if lang.IsTruthy(v37) { +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("chunk-first")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +} +v41 := v40.Get() +v42 := lang.Apply(v41, []any{v31}) +var v38 any = v42 +_ = v38 +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("chunk-rest")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +} +v47 := v46.Get() +v48 := lang.Apply(v47, []any{v31}) +var v44 any = v48 +var v49 any = v38 +v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v52 := v51.FindInternedVar(lang.NewSymbol("int")) +if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) +} +v53 := v52.Get() +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("count")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +} +v56 := v55.Get() +v57 := lang.Apply(v56, []any{v38}) +v58 := lang.Apply(v53, []any{v57}) +var v50 any = v58 +v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v61 := v60.FindInternedVar(lang.NewSymbol("int")) +if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) +} +v62 := v61.Get() +v63 := lang.Apply(v62, []any{int64(0)}) +var v59 any = v63 +v10 = v44 +v15 = v49 +v16 = v50 +v17 = v59 +continue +} else { +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("first")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +} +v41 := v40.Get() +v42 := lang.Apply(v41, []any{v31}) +var v38 any = v42 +_ = v38 +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("nth")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v38, int64(0), nil}) +var v43 any = v47 +_ = v43 +v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v50 := v49.FindInternedVar(lang.NewSymbol("nth")) +if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) +} +v51 := v50.Get() +v52 := lang.Apply(v51, []any{v38, int64(1), nil}) +var v48 any = v52 +_ = v48 +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("add-annotation")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +} +v56 := v55.Get() +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("name")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +} +v59 := v58.Get() +v60 := lang.Apply(v59, []any{v43}) +v61 := lang.Apply(v56, []any{v3, v60, v48}) +_ = v61 +v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v64 := v63.FindInternedVar(lang.NewSymbol("next")) +if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) +} +v65 := v64.Get() +v66 := lang.Apply(v65, []any{v31}) +var v62 any = v66 +var v67 any = nil +var v68 any = int64(0) +var v69 any = int64(0) +v10 = v62 +v15 = v67 +v16 = v68 +v17 = v69 +continue +} +v30 = v33 +} else { +v30 = nil +} +v19 = v30 +} +v18 = v19 + break +} +v5 = v18 +} else { +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("add-annotation")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{v3, "value", v4}) +v5 = v13 +} +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// / +{ +var v1 lang.FnFunc +v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v2 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +if lang.IsTruthy(v7) { +v4 = closed15 +} else { +v4 = v3 +} +var v3 any = v4 +_ = v3 +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("seq")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("concat")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("seq")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("concat")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v2}) +v40 := lang.Apply(v31, []any{v35, v39}) +v41 := lang.Apply(v28, []any{v40}) +v42 := lang.Apply(v25, []any{v41}) +v43 := lang.Apply(v14, []any{v18, v22, v42}) +v44 := lang.Apply(v11, []any{v43}) +return v44 + case 2: +v2 := args[0] +v3 := args[1] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +if lang.IsTruthy(v8) { +v5 = closed15 +} else { +v5 = v4 +} +var v4 any = v5 +_ = v4 +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("seq")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("concat")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("list")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("list")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("list")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("seq")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("concat")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("list")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v4}) +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("list")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v2}) +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("list")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v3}) +v45 := lang.Apply(v32, []any{v36, v40, v44}) +v46 := lang.Apply(v29, []any{v45}) +v47 := lang.Apply(v26, []any{v46}) +v48 := lang.Apply(v15, []any{v19, v23, v47}) +v49 := lang.Apply(v12, []any{v48}) +return v49 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v2 := args[0] +v3 := args[1] +v4 := lang.NewList(args[2:]...) +var v6 any +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +if lang.IsTruthy(v9) { +v6 = closed15 +} else { +v6 = v5 +} +var v5 any = v6 +_ = v5 +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +var v14 lang.FnFunc +v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v15 := args[0] +v16 := args[1] +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v5}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v15}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v16}) +v52 := lang.Apply(v39, []any{v43, v47, v51}) +v53 := lang.Apply(v36, []any{v52}) +v54 := lang.Apply(v33, []any{v53}) +v55 := lang.Apply(v22, []any{v26, v30, v54}) +v56 := lang.Apply(v19, []any{v55}) +return v56 +}) +v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) +v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v5}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v2}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v3}) +v52 := lang.Apply(v39, []any{v43, v47, v51}) +v53 := lang.Apply(v36, []any{v52}) +v54 := lang.Apply(v33, []any{v53}) +v55 := lang.Apply(v22, []any{v26, v30, v54}) +v56 := lang.Apply(v19, []any{v55}) +v57 := lang.Apply(v13, []any{v16, v56, v4}) +return v57 + } +}) +v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) +} +v5 := lang.Apply(v4, []any{v3, int64(1)}) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v0 := lang.NewSymbol("/").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "If no denominators are supplied, returns 1/numerator,\n else returns numerator divided by all of the denominators.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1013), lang.NewKeyword("end-line"), int(1013))).(*lang.Symbol) +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v5 := args[0] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("/")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{int64(1), v5}) +return v9 + case 2: +v5 := args[0] +v6 := args[1] +v7, _ := lang.FieldOrMethod(lang1.Numbers, "divide") +if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("divide is not a function"))) +} +v8 := lang.Apply(v7, []any{v5, v6}) +return v8 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +v6 := args[1] +v7 := lang.NewList(args[2:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("/")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("/")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v5, v6}) +v18 := lang.Apply(v10, []any{v13, v17, v7}) +return v18 + } +}) +v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v3 := ns.InternWithValue(v0, v4, true) +if v0.Meta() != nil { + v3.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// binding +{ +v0 := lang.NewSymbol("binding").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "binding => var-symbol init-expr\n\n Creates new bindings for the (already-existing) vars, with the\n supplied initial values, executes the exprs in an implicit do, then\n re-establishes the bindings that existed before. The new bindings\n are made in parallel (unlike let); all init-exprs are evaluated\n before the vars are bound to their new values.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1945), lang.NewKeyword("end-line"), int(1945))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +var v7 any +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v5}) +if lang.IsTruthy(v11) { +v7 = nil +} else { +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("str")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("first")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v3}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("meta")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v3}) +v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) +v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) +v28 := lang.Apply(lang1.NewIllegalArgumentError, []any{v27}) +panic(v28) +} +_ = v7 +var v29 any +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("even?")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("count")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v5}) +v37 := lang.Apply(v32, []any{v36}) +if lang.IsTruthy(v37) { +v29 = nil +} else { +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("str")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("first")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v3}) +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +} +v47 := v46.Get() +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("meta")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v3}) +v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) +v53 := lang.Apply(v40, []any{v44, " requires ", "an even number of forms in binding vector", " in ", v47, ":", v52}) +v54 := lang.Apply(lang1.NewIllegalArgumentError, []any{v53}) +panic(v54) +} +_ = v29 +_ = nil +var v56 lang.FnFunc +v56 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v57 := args[0] +v59 := lang.NewVector() +v60 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1959), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(1959), lang.NewKeyword("end-column"), int(31)) +v61, err := lang.WithMeta(v59, v60.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v58 any = v61 +_ = v58 +v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v64 := v63.FindInternedVar(lang.NewSymbol("seq")) +if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) +} +v65 := v64.Get() +v66 := lang.Apply(v65, []any{v57}) +var v62 any = v66 +_ = v62 +var v67 any +for { +var v68 any +if lang.IsTruthy(v62) { +v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v71 := v70.FindInternedVar(lang.NewSymbol("conj")) +if v71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) +} +v72 := v71.Get() +v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v74 := v73.FindInternedVar(lang.NewSymbol("conj")) +if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) +} +v75 := v74.Get() +v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v77 := v76.FindInternedVar(lang.NewSymbol("seq")) +if v77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) +} +v78 := v77.Get() +v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v80 := v79.FindInternedVar(lang.NewSymbol("concat")) +if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) +} +v81 := v80.Get() +v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v83 := v82.FindInternedVar(lang.NewSymbol("list")) +if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) +} +v84 := v83.Get() +v85 := lang.Apply(v84, []any{lang.NewSymbol("var")}) +v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v87 := v86.FindInternedVar(lang.NewSymbol("list")) +if v87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) +} +v88 := v87.Get() +v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v90 := v89.FindInternedVar(lang.NewSymbol("first")) +if v90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) +} +v91 := v90.Get() +v92 := lang.Apply(v91, []any{v62}) +v93 := lang.Apply(v88, []any{v92}) +v94 := lang.Apply(v81, []any{v85, v93}) +v95 := lang.Apply(v78, []any{v94}) +v96 := lang.Apply(v75, []any{v58, v95}) +v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v98 := v97.FindInternedVar(lang.NewSymbol("second")) +if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) +} +v99 := v98.Get() +v100 := lang.Apply(v99, []any{v62}) +v101 := lang.Apply(v72, []any{v96, v100}) +var v69 any = v101 +v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v104 := v103.FindInternedVar(lang.NewSymbol("next")) +if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) +} +v105 := v104.Get() +v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v107 := v106.FindInternedVar(lang.NewSymbol("next")) +if v107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) +} +v108 := v107.Get() +v109 := lang.Apply(v108, []any{v62}) +v110 := lang.Apply(v105, []any{v109}) +var v102 any = v110 +v58 = v69 +v62 = v102 +continue +} else { +v111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v112 := v111.FindInternedVar(lang.NewSymbol("seq")) +if v112.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v112))) +} +v113 := v112.Get() +v114 := lang.Apply(v113, []any{v58}) +v68 = v114 +} +v67 = v68 + break +} +return v67 +}) +v57 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1958), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(1963), lang.NewKeyword("end-column"), int(34)) +v58, err := lang.WithMeta(v56, v57.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v55 any = v58 +_ = v55 +v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v61 := v60.FindInternedVar(lang.NewSymbol("seq")) +if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) +} +v62 := v61.Get() +v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v64 := v63.FindInternedVar(lang.NewSymbol("concat")) +if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) +} +v65 := v64.Get() +v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v67 := v66.FindInternedVar(lang.NewSymbol("list")) +if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) +} +v68 := v67.Get() +v69 := lang.Apply(v68, []any{lang.NewSymbol("glojure.core/let")}) +v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v71 := v70.FindInternedVar(lang.NewSymbol("list")) +if v71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) +} +v72 := v71.Get() +v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v74 := v73.FindInternedVar(lang.NewSymbol("apply")) +if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) +} +v75 := v74.Get() +v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v77 := v76.FindInternedVar(lang.NewSymbol("vector")) +if v77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) +} +v78 := v77.Get() +v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v80 := v79.FindInternedVar(lang.NewSymbol("seq")) +if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) +} +v81 := v80.Get() +v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v83 := v82.FindInternedVar(lang.NewSymbol("concat")) +if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) +} +v84 := v83.Get() +v85 := lang.Apply(v84, nil) +v86 := lang.Apply(v81, []any{v85}) +v87 := lang.Apply(v75, []any{v78, v86}) +v88 := lang.Apply(v72, []any{v87}) +v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v90 := v89.FindInternedVar(lang.NewSymbol("list")) +if v90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) +} +v91 := v90.Get() +v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v93 := v92.FindInternedVar(lang.NewSymbol("seq")) +if v93.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) +} +v94 := v93.Get() +v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v96 := v95.FindInternedVar(lang.NewSymbol("concat")) +if v96.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) +} +v97 := v96.Get() +v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v99 := v98.FindInternedVar(lang.NewSymbol("list")) +if v99.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) +} +v100 := v99.Get() +v101 := lang.Apply(v100, []any{lang.NewSymbol("glojure.core/push-thread-bindings")}) +v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v103 := v102.FindInternedVar(lang.NewSymbol("list")) +if v103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) +} +v104 := v103.Get() +v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v106 := v105.FindInternedVar(lang.NewSymbol("seq")) +if v106.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) +} +v107 := v106.Get() +v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v109 := v108.FindInternedVar(lang.NewSymbol("concat")) +if v109.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) +} +v110 := v109.Get() +v111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v112 := v111.FindInternedVar(lang.NewSymbol("list")) +if v112.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v112))) +} +v113 := v112.Get() +v114 := lang.Apply(v113, []any{lang.NewSymbol("glojure.core/hash-map")}) +v115 := lang.Apply(v55, []any{v5}) +v116 := lang.Apply(v110, []any{v114, v115}) +v117 := lang.Apply(v107, []any{v116}) +v118 := lang.Apply(v104, []any{v117}) +v119 := lang.Apply(v97, []any{v101, v118}) +v120 := lang.Apply(v94, []any{v119}) +v121 := lang.Apply(v91, []any{v120}) +v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v123 := v122.FindInternedVar(lang.NewSymbol("list")) +if v123.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) +} +v124 := v123.Get() +v125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v126 := v125.FindInternedVar(lang.NewSymbol("seq")) +if v126.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v126))) +} +v127 := v126.Get() +v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v129 := v128.FindInternedVar(lang.NewSymbol("concat")) +if v129.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v129))) +} +v130 := v129.Get() +v131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v132 := v131.FindInternedVar(lang.NewSymbol("list")) +if v132.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v132))) +} +v133 := v132.Get() +v134 := lang.Apply(v133, []any{lang.NewSymbol("try")}) +v135 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v136 := v135.FindInternedVar(lang.NewSymbol("list")) +if v136.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v136))) +} +v137 := v136.Get() +v138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v139 := v138.FindInternedVar(lang.NewSymbol("seq")) +if v139.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v139))) +} +v140 := v139.Get() +v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v142 := v141.FindInternedVar(lang.NewSymbol("concat")) +if v142.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) +} +v143 := v142.Get() +v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v145 := v144.FindInternedVar(lang.NewSymbol("list")) +if v145.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) +} +v146 := v145.Get() +v147 := lang.Apply(v146, []any{lang.NewSymbol("finally")}) +v148 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v149 := v148.FindInternedVar(lang.NewSymbol("list")) +if v149.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v149))) +} +v150 := v149.Get() +v151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v152 := v151.FindInternedVar(lang.NewSymbol("seq")) +if v152.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v152))) +} +v153 := v152.Get() +v154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v155 := v154.FindInternedVar(lang.NewSymbol("concat")) +if v155.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v155))) +} +v156 := v155.Get() +v157 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v158 := v157.FindInternedVar(lang.NewSymbol("list")) +if v158.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v158))) +} +v159 := v158.Get() +v160 := lang.Apply(v159, []any{lang.NewSymbol("glojure.core/pop-thread-bindings")}) +v161 := lang.Apply(v156, []any{v160}) +v162 := lang.Apply(v153, []any{v161}) +v163 := lang.Apply(v150, []any{v162}) +v164 := lang.Apply(v143, []any{v147, v163}) +v165 := lang.Apply(v140, []any{v164}) +v166 := lang.Apply(v137, []any{v165}) +v167 := lang.Apply(v130, []any{v134, v6, v166}) +v168 := lang.Apply(v127, []any{v167}) +v169 := lang.Apply(v124, []any{v168}) +v170 := lang.Apply(v65, []any{v69, v88, v121, v169}) +v171 := lang.Apply(v62, []any{v170}) +return v171 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// double +{ +var v1 lang.FnFunc +{ // function double__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/DoubleCast")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v3}) +v35 := lang.Apply(v26, []any{v30, v34}) +v36 := lang.Apply(v23, []any{v35}) +v37 := lang.Apply(v20, []any{v36}) +v38 := lang.Apply(v9, []any{v13, v17, v37}) +v39 := lang.Apply(v6, []any{v38}) +return v39 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("double").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to double", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3493), lang.NewKeyword("end-line"), int(3493))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := lang.Apply(lang1.AsFloat64, []any{v4}) +return v5 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// *compile-files* +{ +v0 := lang.NewSymbol("*compile-files*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "Set to true when compiling files, false otherwise.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, false, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// defmacro +{ +v0 := lang.NewSymbol("defmacro").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("doc-string?"), lang.NewSymbol("attr-map?"), lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("body")), lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("doc-string?"), lang.NewSymbol("attr-map?"), lang.NewList(lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("body")), lang.NewSymbol("+"), lang.NewSymbol("attr-map?"))), lang.NewKeyword("doc"), "Like defn, but the resulting function name is declared as a\n macro and will be used as a macro by the compiler when it is\n called.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(445), lang.NewKeyword("end-line"), int(451))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("list")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v5}) +var v8 any = v12 +_ = v8 +var v13 any = v13 +_ = v13 +var v14 any +for { +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("first")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v13}) +var v15 any = v19 +_ = v15 +var v21 any +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("string?")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v15}) +if lang.IsTruthy(v25) { +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("cons")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{v15, v8}) +var v26 any = v30 +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("next")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v13}) +var v31 any = v35 +v8 = v26 +v13 = v31 +continue +} else { +var v36 any +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("map?")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v15}) +if lang.IsTruthy(v40) { +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("cons")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +} +v44 := v43.Get() +v45 := lang.Apply(v44, []any{v15, v8}) +var v41 any = v45 +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("next")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +} +v49 := v48.Get() +v50 := lang.Apply(v49, []any{v13}) +var v46 any = v50 +v8 = v41 +v13 = v46 +continue +} else { +v36 = v8 +} +v21 = v36 +} +v14 = v21 + break +} +var v7 any = v14 +_ = v7 +var v9 any = v6 +_ = v9 +var v10 any +for { +var v11 any +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("string?")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("first")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v9}) +v19 := lang.Apply(v14, []any{v18}) +if lang.IsTruthy(v19) { +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("next")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v9}) +var v20 any = v24 +v9 = v20 +continue +} else { +var v25 any +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("map?")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("first")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.Apply(v31, []any{v9}) +v33 := lang.Apply(v28, []any{v32}) +if lang.IsTruthy(v33) { +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("next")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v37, []any{v9}) +var v34 any = v38 +v9 = v34 +continue +} else { +v25 = v9 +} +v11 = v25 +} +v10 = v11 + break +} +var v8 any = v10 +_ = v8 +var v10 any +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("vector?")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("first")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v9}) +v18 := lang.Apply(v13, []any{v17}) +if lang.IsTruthy(v18) { +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v9}) +v10 = v22 +} else { +v10 = v9 +} +var v9 any = v10 +_ = v9 +var v24 lang.FnFunc +v24 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v25 := args[0] +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("first")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{v25}) +var v26 any = v30 +_ = v26 +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("cons")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("vec")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("cons")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("cons")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v43, []any{lang.NewSymbol("&env"), v26}) +v45 := lang.Apply(v40, []any{lang.NewSymbol("&form"), v44}) +v46 := lang.Apply(v37, []any{v45}) +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("next")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +} +v49 := v48.Get() +v50 := lang.Apply(v49, []any{v25}) +v51 := lang.Apply(v34, []any{v46, v50}) +return v51 +}) +v25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(469), lang.NewKeyword("column"), int(38), lang.NewKeyword("end-line"), int(471), lang.NewKeyword("end-column"), int(87)) +v26, err := lang.WithMeta(v24, v25.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v23 any = v26 +_ = v23 +var v28 lang.FnFunc +v28 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v29 := args[0] +v30 := args[1] +recur_loop_61: +var v31 any +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("nil?")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v30}) +if lang.IsTruthy(v35) { +v31 = v29 +} else { +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("first")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v30}) +var v36 any = v40 +_ = v36 +var v42 any +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("map?")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +} +v45 := v44.Get() +v46 := lang.Apply(v45, []any{v36}) +if lang.IsTruthy(v46) { +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("conj")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +} +v49 := v48.Get() +v50 := lang.Apply(v49, []any{v29, v36}) +v42 = v50 +} else { +v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v53 := v52.FindInternedVar(lang.NewSymbol("conj")) +if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) +} +v54 := v53.Get() +v55 := lang.Apply(v23, []any{v36}) +v56 := lang.Apply(v54, []any{v29, v55}) +var v51 any = v56 +v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v59 := v58.FindInternedVar(lang.NewSymbol("next")) +if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) +} +v60 := v59.Get() +v61 := lang.Apply(v60, []any{v30}) +var v57 any = v61 +v29 = v51 +v30 = v57 +goto recur_loop_61 +} +v31 = v42 +} +return v31 +}) +v29 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(472), lang.NewKeyword("column"), int(29), lang.NewKeyword("end-line"), int(478), lang.NewKeyword("end-column"), int(90)) +v30, err := lang.WithMeta(v28, v29.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v27 any = v30 +_ = v27 +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("seq")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.NewVector() +v36 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(479), lang.NewKeyword("column"), int(41), lang.NewKeyword("end-line"), int(479), lang.NewKeyword("end-column"), int(42)) +v37, err := lang.WithMeta(v35, v36.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v38 := lang.Apply(v27, []any{v37, v31}) +v39 := lang.Apply(v34, []any{v38}) +var v31 any = v39 +_ = v31 +var v41 any = v7 +_ = v41 +var v42 any = v31 +_ = v42 +var v43 any +for { +var v44 any +if lang.IsTruthy(v41) { +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("next")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +} +v48 := v47.Get() +v49 := lang.Apply(v48, []any{v41}) +var v45 any = v49 +v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v52 := v51.FindInternedVar(lang.NewSymbol("cons")) +if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) +} +v53 := v52.Get() +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("first")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +} +v56 := v55.Get() +v57 := lang.Apply(v56, []any{v41}) +v58 := lang.Apply(v53, []any{v57, v42}) +var v50 any = v58 +v41 = v45 +v42 = v50 +continue +} else { +v44 = v42 +} +v43 = v44 + break +} +var v40 any = v43 +_ = v40 +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("list")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +} +v44 := v43.Get() +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("cons")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +} +v47 := v46.Get() +v48 := lang.Apply(v47, []any{lang.NewSymbol("glojure.core/defn"), v40}) +v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v50 := v49.FindInternedVar(lang.NewSymbol("list")) +if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) +} +v51 := v50.Get() +v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v53 := v52.FindInternedVar(lang.NewSymbol("list")) +if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) +} +v54 := v53.Get() +v55 := lang.Apply(v54, []any{lang.NewSymbol("var"), v5}) +v56 := lang.Apply(v51, []any{lang.NewSymbol("."), v55, lang.NewList(lang.NewSymbol("SetMacro"))}) +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("list")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +} +v59 := v58.Get() +v60 := lang.Apply(v59, []any{lang.NewSymbol("var"), v5}) +v61 := lang.Apply(v44, []any{lang.NewSymbol("do"), v48, v56, v60}) +return v61 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(451), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(487), lang.NewKeyword("end-column"), int(40))).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// cons +{ +v0 := lang.NewSymbol("cons").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("seq"))), lang.NewKeyword("doc"), "Returns a new seq where x is the first element and seq is\n the rest.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(21), lang.NewKeyword("end-line"), int(27))).(*lang.Symbol) +var v2 lang.FnFunc +{ // function cons +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := args[1] +v6 := lang.Apply(lang1.NewCons, []any{v4, v5}) +return v6 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(27), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(27), lang.NewKeyword("end-column"), int(89))).(lang.FnFunc) +v3 := v2 +_ = v3 +} +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// splitv-at +{ +v0 := lang.NewSymbol("splitv-at").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a vector of [(into [] (take n) coll) (drop n coll)]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7299), lang.NewKeyword("end-line"), int(7299))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("into")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.NewVector() +v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7303), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(7303), lang.NewKeyword("end-column"), int(11)) +v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("take")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v3}) +v15 := lang.Apply(v7, []any{v10, v14, v4}) +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("drop")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v3, v4}) +v20 := lang.NewVector(v15, v19) +v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7303), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(7303), lang.NewKeyword("end-column"), int(41)) +v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v22 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// future-cancel +{ +v0 := lang.NewSymbol("future-cancel").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Cancels the future, if possible.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7062), lang.NewKeyword("end-line"), int(7062))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, _ := lang.FieldOrMethod(v3, "cancel") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("cancel is not a function"))) +} +v5 := lang.Apply(v4, []any{true}) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// iterator-seq +{ +v0 := lang.NewSymbol("iterator-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("iter"))), lang.NewKeyword("doc"), "Returns a seq on a java.util.Iterator. Note that most collections\n providing iterators implement Iterable and thus support seq directly.\n Seqs cache values, thus iterator-seq should not be used on any\n iterator that repeatedly returns the same mutable object.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5743), lang.NewKeyword("end-line"), int(5743))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.Apply(nil, []any{v3}) +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// max-mask-bits +{ +v0 := lang.NewSymbol("max-mask-bits").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6644), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(6644), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, int64(13), true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// var-set +{ +v0 := lang.NewSymbol("var-set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Sets the value in the var object to val. The var must be\n thread-locally bound.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4332), lang.NewKeyword("end-line"), int(4332))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5, _ := lang.FieldOrMethod(v3, "Set") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Set is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// update-keys +{ +v0 := lang.NewSymbol("update-keys").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("f"))), lang.NewKeyword("doc"), "m f => {(f k) v ...}\n\n Given a map m and a function f of 1-argument, returns a new map whose\n keys are the result of applying f to the keys of m, mapped to the\n corresponding values of m.\n f must return a unique key for each key of m, else the behavior is undefined.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7959), lang.NewKeyword("end-line"), int(7959))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("persistent!")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("reduce-kv")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +var v12 lang.FnFunc +v12 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v13 := args[0] +v14 := args[1] +v15 := args[2] +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("assoc!")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v4, []any{v14}) +v20 := lang.Apply(v18, []any{v13, v19, v15}) +return v20 +}) +v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7969), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7969), lang.NewKeyword("end-column"), int(59)) +v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("transient")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.NewMap() +v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7970), lang.NewKeyword("column"), int(36), lang.NewKeyword("end-line"), int(7970), lang.NewKeyword("end-column"), int(37)) +v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v21 := lang.Apply(v17, []any{v20}) +v22 := lang.Apply(v11, []any{v14, v21, v3}) +v23 := lang.Apply(v8, []any{v22}) +var v5 any = v23 +_ = v5 +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("with-meta")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("meta")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{v3}) +v32 := lang.Apply(v27, []any{v5, v31}) +return v32 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// extend +{ +v0 := lang.NewSymbol("extend").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atype"), lang.NewSymbol("&"), lang.NewSymbol("proto+mmaps"))), lang.NewKeyword("doc"), "Implementations of protocol methods can be provided using the extend construct:\n\n (extend AType\n AProtocol\n {:foo an-existing-fn\n :bar (fn [a b] ...)\n :baz (fn ([a]...) ([a b] ...)...)}\n BProtocol \n {...} \n ...)\n \n extend takes a type/class (or interface, see below), and one or more\n protocol + method map pairs. It will extend the polymorphism of the\n protocol's methods to call the supplied methods when an AType is\n provided as the first argument. \n\n Method maps are maps of the keyword-ized method names to ordinary\n fns. This facilitates easy reuse of existing fns and fn maps, for\n code reuse/mixins without derivation or composition. You can extend\n an interface to a protocol. This is primarily to facilitate interop\n with the host (e.g. Java) but opens the door to incidental multiple\n inheritance of implementation since a class can inherit from more\n than one interface, both of which extend the protocol. It is TBD how\n to specify which impl to use. You can extend a protocol on nil.\n\n If you are supplying the definitions explicitly (i.e. not reusing\n exsting functions or mixin maps), you may find it more convenient to\n use the extend-type or extend-protocol macros.\n\n Note that multiple independent extend clauses can exist for the same\n type, not all protocols need be defined in a single extend call.\n\n See also:\n extends?, satisfies?, extenders", lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(116), lang.NewKeyword("end-line"), int(116))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.NewList(args[1:]...) +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("seq")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("partition")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v11, []any{int64(2), v4}) +v13 := lang.Apply(v8, []any{v12}) +var v5 any = v13 +_ = v5 +var v14 any = nil +_ = v14 +var v15 any = int64(0) +_ = v15 +var v16 any = int64(0) +_ = v16 +var v17 any +for { +var v18 any +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("<")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v16, v15}) +if lang.IsTruthy(v22) { +v24, _ := lang.FieldOrMethod(v14, "nth") +if reflect.TypeOf(v24).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) +} +v25 := lang.Apply(v24, []any{v16}) +var v23 any = v25 +_ = v23 +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("nth")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{v23, int64(0), nil}) +var v26 any = v30 +_ = v26 +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("nth")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v23, int64(1), nil}) +var v31 any = v35 +_ = v31 +var v37 any +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("protocol?")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.Apply(v40, []any{v26}) +if lang.IsTruthy(v41) { +v37 = nil +} else { +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("str")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +} +v44 := v43.Get() +v45 := lang.Apply(v44, []any{v26, " is not a protocol"}) +v46 := lang.Apply(errors10.New, []any{v45}) +panic(v46) +} +_ = v37 +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("reduce1")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +} +v49 := v48.Get() +var v50 lang.FnFunc +v50 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v51 := args[0] +v52 := args[1] +var v53 any = v52 +_ = v53 +v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v56 := v55.FindInternedVar(lang.NewSymbol("nth")) +if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) +} +v57 := v56.Get() +v58 := lang.Apply(v57, []any{v53, int64(0), nil}) +var v54 any = v58 +_ = v54 +v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v61 := v60.FindInternedVar(lang.NewSymbol("nth")) +if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) +} +v62 := v61.Get() +v63 := lang.Apply(v62, []any{v53, int64(1), nil}) +var v59 any = v63 +_ = v59 +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("get-in")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +} +v67 := v66.Get() +v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v69 := v68.FindInternedVar(lang.NewSymbol("deref")) +if v69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) +} +v70 := v69.Get() +v71 := lang.Apply(v70, []any{v26}) +v72 := lang.NewVector(lang.NewKeyword("multis"), v54) +v73 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(158), lang.NewKeyword("column"), int(33), lang.NewKeyword("end-line"), int(158), lang.NewKeyword("end-column"), int(43)) +v74, err := lang.WithMeta(v72, v73.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v75 := lang.Apply(v67, []any{v71, v74}) +var v76 lang.FnFunc +v76 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v77 := args[0] +v78 := lang.NewList(args[1:]...) +v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v80 := v79.FindInternedVar(lang.NewSymbol("apply")) +if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) +} +v81 := v80.Get() +v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v83 := v82.FindInternedVar(lang.NewSymbol("cons")) +if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) +} +v84 := v83.Get() +v85 := lang.Apply(v84, []any{v77, v78}) +v86 := lang.Apply(v81, []any{v59, v85}) +return v86 + } +}) +v77, _ := lang.FieldOrMethod(v75, "AddMethod") +if reflect.TypeOf(v77).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("AddMethod is not a function"))) +} +v78 := lang.Apply(v77, []any{v3, v76}) +return v78 +}) +v51 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(156), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(160), lang.NewKeyword("end-column"), int(45)) +v52, err := lang.WithMeta(v50, v51.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v53 := lang.Apply(v49, []any{v52, nil, v31}) +_ = v53 +var v54 any = v5 +var v55 any = v14 +var v56 any = v15 +v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v59 := v58.FindInternedVar(lang.NewSymbol("unchecked-inc")) +if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) +} +v60 := v59.Get() +v61 := lang.Apply(v60, []any{v16}) +var v57 any = v61 +v5 = v54 +v14 = v55 +v15 = v56 +v16 = v57 +continue +} else { +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("seq")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v5}) +var v23 any = v27 +_ = v23 +var v29 any +if lang.IsTruthy(v23) { +var v30 any = v23 +_ = v30 +var v32 any +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("chunked-seq?")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v30}) +if lang.IsTruthy(v36) { +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("chunk-first")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.Apply(v40, []any{v30}) +var v37 any = v41 +_ = v37 +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("chunk-rest")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v30}) +var v43 any = v47 +var v48 any = v37 +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("int")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +} +v52 := v51.Get() +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("count")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +} +v55 := v54.Get() +v56 := lang.Apply(v55, []any{v37}) +v57 := lang.Apply(v52, []any{v56}) +var v49 any = v57 +v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v60 := v59.FindInternedVar(lang.NewSymbol("int")) +if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) +} +v61 := v60.Get() +v62 := lang.Apply(v61, []any{int64(0)}) +var v58 any = v62 +v5 = v43 +v14 = v48 +v15 = v49 +v16 = v58 +continue +} else { +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("first")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.Apply(v40, []any{v30}) +var v37 any = v41 +_ = v37 +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("nth")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +} +v45 := v44.Get() +v46 := lang.Apply(v45, []any{v37, int64(0), nil}) +var v42 any = v46 +_ = v42 +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("nth")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v37, int64(1), nil}) +var v47 any = v51 +_ = v47 +var v53 any +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("protocol?")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +} +v56 := v55.Get() +v57 := lang.Apply(v56, []any{v42}) +if lang.IsTruthy(v57) { +v53 = nil +} else { +v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v59 := v58.FindInternedVar(lang.NewSymbol("str")) +if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) +} +v60 := v59.Get() +v61 := lang.Apply(v60, []any{v42, " is not a protocol"}) +v62 := lang.Apply(errors10.New, []any{v61}) +panic(v62) +} +_ = v53 +v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v64 := v63.FindInternedVar(lang.NewSymbol("reduce1")) +if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) +} +v65 := v64.Get() +var v66 lang.FnFunc +v66 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v67 := args[0] +v68 := args[1] +var v69 any = v68 +_ = v69 +v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v72 := v71.FindInternedVar(lang.NewSymbol("nth")) +if v72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) +} +v73 := v72.Get() +v74 := lang.Apply(v73, []any{v69, int64(0), nil}) +var v70 any = v74 +_ = v70 +v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v77 := v76.FindInternedVar(lang.NewSymbol("nth")) +if v77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) +} +v78 := v77.Get() +v79 := lang.Apply(v78, []any{v69, int64(1), nil}) +var v75 any = v79 +_ = v75 +v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v82 := v81.FindInternedVar(lang.NewSymbol("get-in")) +if v82.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) +} +v83 := v82.Get() +v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v85 := v84.FindInternedVar(lang.NewSymbol("deref")) +if v85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) +} +v86 := v85.Get() +v87 := lang.Apply(v86, []any{v42}) +v88 := lang.NewVector(lang.NewKeyword("multis"), v70) +v89 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(158), lang.NewKeyword("column"), int(33), lang.NewKeyword("end-line"), int(158), lang.NewKeyword("end-column"), int(43)) +v90, err := lang.WithMeta(v88, v89.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v91 := lang.Apply(v83, []any{v87, v90}) +var v92 lang.FnFunc +v92 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v93 := args[0] +v94 := lang.NewList(args[1:]...) +v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v96 := v95.FindInternedVar(lang.NewSymbol("apply")) +if v96.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) +} +v97 := v96.Get() +v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v99 := v98.FindInternedVar(lang.NewSymbol("cons")) +if v99.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) +} +v100 := v99.Get() +v101 := lang.Apply(v100, []any{v93, v94}) +v102 := lang.Apply(v97, []any{v75, v101}) +return v102 + } +}) +v93, _ := lang.FieldOrMethod(v91, "AddMethod") +if reflect.TypeOf(v93).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("AddMethod is not a function"))) +} +v94 := lang.Apply(v93, []any{v3, v92}) +return v94 +}) +v67 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(156), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(160), lang.NewKeyword("end-column"), int(45)) +v68, err := lang.WithMeta(v66, v67.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v69 := lang.Apply(v65, []any{v68, nil, v47}) +_ = v69 +v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v72 := v71.FindInternedVar(lang.NewSymbol("next")) +if v72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) +} +v73 := v72.Get() +v74 := lang.Apply(v73, []any{v30}) +var v70 any = v74 +var v75 any = nil +var v76 any = int64(0) +var v77 any = int64(0) +v5 = v70 +v14 = v75 +v15 = v76 +v16 = v77 +continue +} +v29 = v32 +} else { +v29 = nil +} +v18 = v29 +} +v17 = v18 + break +} +return v17 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// sorted-map-by +{ +v0 := lang.NewSymbol("sorted-map-by").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("comparator"), lang.NewSymbol("&"), lang.NewSymbol("keyvals"))), lang.NewKeyword("doc"), "keyval => key val\n Returns a new sorted map with supplied mappings, using the supplied\n comparator. If any keys are equal, they are handled as if by\n repeated uses of assoc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(406), lang.NewKeyword("end-line"), int(406))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.NewList(args[1:]...) +v5 := lang.Apply(nil, []any{v3, v4}) +return v5 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// throw-if +{ +v0 := lang.NewSymbol("throw-if").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("fmt"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Throws a CompilerException with a message if pred is true", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5875), lang.NewKeyword("end-line"), int(5875), lang.NewKeyword("private"), true)).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +var v6 any +if lang.IsTruthy(v3) { +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("apply")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("format")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v10, []any{v13, v4, v5}) +var v7 any = v14 +_ = v7 +v16 := lang.Apply(Exception25., []any{v7}) +var v15 any = v16 +_ = v15 +v18, ok := lang.FieldOrMethod(v15, "getStackTrace") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v15, "getStackTrace"))) +} +var v19 any +switch reflect.TypeOf(v18).Kind() { +case reflect.Func: + v19 = lang.Apply(v18, nil) +default: + v19 = v18 +} +var v17 any = v19 +_ = v17 +var v21 lang.FnFunc +v21 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v22 := args[0] +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("not=")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26, ok := lang.FieldOrMethod(v22, "getMethodName") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v22, "getMethodName"))) +} +var v27 any +switch reflect.TypeOf(v26).Kind() { +case reflect.Func: + v27 = lang.Apply(v26, nil) +default: + v27 = v26 +} +v28 := lang.Apply(v25, []any{v27, "doInvoke"}) +return v28 +}) +v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5882), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(5882), lang.NewKeyword("end-column"), int(74)) +v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v20 any = v23 +_ = v20 +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("into-array")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("drop")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("drop-while")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v20, v17}) +v35 := lang.Apply(v30, []any{int64(2), v34}) +v36 := lang.Apply(v27, []any{nil, v35}) +var v24 any = v36 +_ = v24 +v38, _ := lang.FieldOrMethod(v15, "setStackTrace") +if reflect.TypeOf(v38).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setStackTrace is not a function"))) +} +v39 := lang.Apply(v38, []any{v24}) +_ = v39 +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("*file*")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43, ok := lang.FieldOrMethod(nil, "Deref") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "Deref"))) +} +var v44 any +switch reflect.TypeOf(v43).Kind() { +case reflect.Func: + v44 = lang.Apply(v43, nil) +default: + v44 = v43 +} +v45, ok := lang.FieldOrMethod(nil, "Deref") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "Deref"))) +} +var v46 any +switch reflect.TypeOf(v45).Kind() { +case reflect.Func: + v46 = lang.Apply(v45, nil) +default: + v46 = v45 +} +v47 := lang.Apply(CompilerException34., []any{v42, v44, v46, v15}) +panic(v47) +} else { +v6 = nil +} +return v6 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// hash +{ +v0 := lang.NewSymbol("hash").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns the hash code of its argument. Note this is the hash code\n consistent with =, and thus is different than .hashCode for Integer,\n Short, Byte and Clojure collections.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5189), lang.NewKeyword("end-line"), int(5189))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.Apply(lang1.HashEq, []any{v3}) +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// run! +{ +v0 := lang.NewSymbol("run!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("proc"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Runs the supplied procedure (via reduce), for purposes of side\n effects, on successive items in the collection. Returns nil", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7761), lang.NewKeyword("end-line"), int(7761))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("reduce")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +var v8 lang.FnFunc +v8 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v9 := args[0] +v10 := args[1] +v11 := lang.Apply(v3, []any{v10}) +return v11 +}) +v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7766), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(7766), lang.NewKeyword("end-column"), int(20)) +v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v11 := lang.Apply(v7, []any{v10, nil, v4}) +_ = v11 +return nil +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// line-seq +{ +v0 := lang.NewSymbol("line-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rdr"))), lang.NewKeyword("doc"), "Returns the lines of text from rdr as a lazy sequence of strings.\n rdr must implement java.io.BufferedReader.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3068), lang.NewKeyword("end-line"), int(3068))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v5, ok := lang.FieldOrMethod(v3, "readLine") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "readLine"))) +} +var v6 any +switch reflect.TypeOf(v5).Kind() { +case reflect.Func: + v6 = lang.Apply(v5, nil) +default: + v6 = v5 +} +var v4 any = v6 +_ = v4 +var v8 any +if lang.IsTruthy(v4) { +var v9 any = v4 +_ = v9 +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("cons")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +var v14 lang.FnFunc +v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("line-seq")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v3}) +return v18 +}) +v15 := lang.Apply(lang1.NewLazySeq, []any{v14}) +v16 := lang.Apply(v13, []any{v9, v15}) +v8 = v16 +} else { +v8 = nil +} +return v8 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// mod +{ +v0 := lang.NewSymbol("mod").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"), lang.NewSymbol("div"))), lang.NewKeyword("doc"), "Modulus of num and div. Truncates toward negative infinity.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3567), lang.NewKeyword("end-line"), int(3567))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("rem")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v3, v4}) +var v5 any = v9 +_ = v5 +var v11 any +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("zero?")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v5}) +var v12 any = v16 +_ = v12 +var v18 any +if lang.IsTruthy(v12) { +v18 = v12 +} else { +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("=")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("pos?")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v3}) +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("pos?")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.Apply(v28, []any{v4}) +v30 := lang.Apply(v21, []any{v25, v29}) +v18 = v30 +} +if lang.IsTruthy(v18) { +v11 = v5 +} else { +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("+")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v5, v4}) +v11 = v15 +} +return v11 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// add-annotations +{ +v0 := lang.NewSymbol("add-annotations").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5511), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(5511), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("visitor"), lang.NewSymbol("m")), lang.NewVector(lang.NewSymbol("visitor"), lang.NewSymbol("m"), lang.NewSymbol("i"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("add-annotations")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3, v4, nil}) +return v8 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("seq")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v4}) +var v6 any = v10 +_ = v6 +var v11 any = nil +_ = v11 +var v12 any = int64(0) +_ = v12 +var v13 any = int64(0) +_ = v13 +var v14 any +for { +var v15 any +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("<")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v13, v12}) +if lang.IsTruthy(v19) { +v21, _ := lang.FieldOrMethod(v11, "nth") +if reflect.TypeOf(v21).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) +} +v22 := lang.Apply(v21, []any{v13}) +var v20 any = v22 +_ = v20 +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("nth")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v20, int64(0), nil}) +var v23 any = v27 +_ = v23 +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("nth")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.Apply(v31, []any{v20, int64(1), nil}) +var v28 any = v32 +_ = v28 +var v34 any +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("symbol?")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v37, []any{v23}) +if lang.IsTruthy(v38) { +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("resolve")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v23}) +var v39 any = v43 +_ = v39 +var v45 any +if lang.IsTruthy(v39) { +var v46 any = v39 +_ = v46 +var v48 any +v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v50 := v49.FindInternedVar(lang.NewSymbol("is-annotation?")) +if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) +} +v51 := v50.Get() +v52 := lang.Apply(v51, []any{v46}) +if lang.IsTruthy(v52) { +var v54 any +if lang.IsTruthy(v5) { +v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v56 := v55.FindInternedVar(lang.NewSymbol("descriptor")) +if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) +} +v57 := v56.Get() +v58 := lang.Apply(v57, []any{v46}) +v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v60 := v59.FindInternedVar(lang.NewSymbol("is-runtime-annotation?")) +if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) +} +v61 := v60.Get() +v62 := lang.Apply(v61, []any{v46}) +v63, _ := lang.FieldOrMethod(v3, "visitParameterAnnotation") +if reflect.TypeOf(v63).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("visitParameterAnnotation is not a function"))) +} +v64 := lang.Apply(v63, []any{v5, v58, v62}) +v54 = v64 +} else { +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("descriptor")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +} +v67 := v66.Get() +v68 := lang.Apply(v67, []any{v46}) +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("is-runtime-annotation?")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +} +v71 := v70.Get() +v72 := lang.Apply(v71, []any{v46}) +v73, _ := lang.FieldOrMethod(v3, "visitAnnotation") +if reflect.TypeOf(v73).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("visitAnnotation is not a function"))) +} +v74 := lang.Apply(v73, []any{v68, v72}) +v54 = v74 +} +var v53 any = v54 +_ = v53 +v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v77 := v76.FindInternedVar(lang.NewSymbol("process-annotation")) +if v77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) +} +v78 := v77.Get() +v79 := lang.Apply(v78, []any{v53, v28}) +_ = v79 +v80, ok := lang.FieldOrMethod(v53, "visitEnd") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v53, "visitEnd"))) +} +var v81 any +switch reflect.TypeOf(v80).Kind() { +case reflect.Func: + v81 = lang.Apply(v80, nil) +default: + v81 = v80 +} +v48 = v81 +} else { +v48 = nil +} +v45 = v48 +} else { +v45 = nil +} +v34 = v45 +} else { +v34 = nil +} +_ = v34 +var v39 any = v6 +var v40 any = v11 +var v41 any = v12 +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("unchecked-inc")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +} +v45 := v44.Get() +v46 := lang.Apply(v45, []any{v13}) +var v42 any = v46 +v6 = v39 +v11 = v40 +v12 = v41 +v13 = v42 +continue +} else { +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v6}) +var v20 any = v24 +_ = v20 +var v26 any +if lang.IsTruthy(v20) { +var v27 any = v20 +_ = v27 +var v29 any +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("chunked-seq?")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.Apply(v32, []any{v27}) +if lang.IsTruthy(v33) { +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("chunk-first")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v37, []any{v27}) +var v34 any = v38 +_ = v34 +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("chunk-rest")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v27}) +var v40 any = v44 +var v45 any = v34 +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("int")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +} +v49 := v48.Get() +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("count")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +} +v52 := v51.Get() +v53 := lang.Apply(v52, []any{v34}) +v54 := lang.Apply(v49, []any{v53}) +var v46 any = v54 +v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v57 := v56.FindInternedVar(lang.NewSymbol("int")) +if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) +} +v58 := v57.Get() +v59 := lang.Apply(v58, []any{int64(0)}) +var v55 any = v59 +v6 = v40 +v11 = v45 +v12 = v46 +v13 = v55 +continue +} else { +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("first")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v37, []any{v27}) +var v34 any = v38 +_ = v34 +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("nth")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v34, int64(0), nil}) +var v39 any = v43 +_ = v39 +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("nth")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +} +v47 := v46.Get() +v48 := lang.Apply(v47, []any{v34, int64(1), nil}) +var v44 any = v48 +_ = v44 +var v50 any +v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v52 := v51.FindInternedVar(lang.NewSymbol("symbol?")) +if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) +} +v53 := v52.Get() +v54 := lang.Apply(v53, []any{v39}) +if lang.IsTruthy(v54) { +v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v57 := v56.FindInternedVar(lang.NewSymbol("resolve")) +if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) +} +v58 := v57.Get() +v59 := lang.Apply(v58, []any{v39}) +var v55 any = v59 +_ = v55 +var v61 any +if lang.IsTruthy(v55) { +var v62 any = v55 +_ = v62 +var v64 any +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("is-annotation?")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +} +v67 := v66.Get() +v68 := lang.Apply(v67, []any{v62}) +if lang.IsTruthy(v68) { +var v70 any +if lang.IsTruthy(v5) { +v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v72 := v71.FindInternedVar(lang.NewSymbol("descriptor")) +if v72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) +} +v73 := v72.Get() +v74 := lang.Apply(v73, []any{v62}) +v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v76 := v75.FindInternedVar(lang.NewSymbol("is-runtime-annotation?")) +if v76.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) +} +v77 := v76.Get() +v78 := lang.Apply(v77, []any{v62}) +v79, _ := lang.FieldOrMethod(v3, "visitParameterAnnotation") +if reflect.TypeOf(v79).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("visitParameterAnnotation is not a function"))) +} +v80 := lang.Apply(v79, []any{v5, v74, v78}) +v70 = v80 +} else { +v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v82 := v81.FindInternedVar(lang.NewSymbol("descriptor")) +if v82.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) +} +v83 := v82.Get() +v84 := lang.Apply(v83, []any{v62}) +v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v86 := v85.FindInternedVar(lang.NewSymbol("is-runtime-annotation?")) +if v86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) +} +v87 := v86.Get() +v88 := lang.Apply(v87, []any{v62}) +v89, _ := lang.FieldOrMethod(v3, "visitAnnotation") +if reflect.TypeOf(v89).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("visitAnnotation is not a function"))) +} +v90 := lang.Apply(v89, []any{v84, v88}) +v70 = v90 +} +var v69 any = v70 +_ = v69 +v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v93 := v92.FindInternedVar(lang.NewSymbol("process-annotation")) +if v93.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) +} +v94 := v93.Get() +v95 := lang.Apply(v94, []any{v69, v44}) +_ = v95 +v96, ok := lang.FieldOrMethod(v69, "visitEnd") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v69, "visitEnd"))) +} +var v97 any +switch reflect.TypeOf(v96).Kind() { +case reflect.Func: + v97 = lang.Apply(v96, nil) +default: + v97 = v96 +} +v64 = v97 +} else { +v64 = nil +} +v61 = v64 +} else { +v61 = nil +} +v50 = v61 +} else { +v50 = nil +} +_ = v50 +v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v57 := v56.FindInternedVar(lang.NewSymbol("next")) +if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) +} +v58 := v57.Get() +v59 := lang.Apply(v58, []any{v27}) +var v55 any = v59 +var v60 any = nil +var v61 any = int64(0) +var v62 any = int64(0) +v6 = v55 +v11 = v60 +v12 = v61 +v13 = v62 +continue +} +v26 = v29 +} else { +v26 = nil +} +v15 = v26 +} +v14 = v15 + break +} +return v14 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// sequential? +{ +v0 := lang.NewSymbol("sequential?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements Sequential", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6272), lang.NewKeyword("end-line"), int(6272))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{lang1.Sequential, v3}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// case +{ +v0 := lang.NewSymbol("case").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("e"), lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes an expression, and a set of clauses.\n\n Each clause can take the form of either:\n\n test-constant result-expr\n\n (test-constant1 ... test-constantN) result-expr\n\n The test-constants are not evaluated. They must be compile-time\n literals, and need not be quoted. If the expression is equal to a\n test-constant, the corresponding result-expr is returned. A single\n default expression can follow the clauses, and its value will be\n returned if no clause matches. If no default expression is provided\n and no clause matches, an IllegalArgumentException is thrown.\n\n Unlike cond and condp, case does a constant-time dispatch, the\n clauses are not considered sequentially. All manner of constant\n expressions are acceptable in case, including numbers, strings,\n symbols, keywords, and (Clojure) composites thereof. Note that since\n lists are used to group multiple constants that map to the same\n expression, a vector can be used to match a list if needed. The\n test-constants need not be all of the same type.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6755), lang.NewKeyword("end-line"), int(6755))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("with-meta")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("gensym")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, nil) +v15 := lang.NewMap(lang.NewKeyword("tag"), lang1.Object) +v16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6781), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(6781), lang.NewKeyword("end-column"), int(84)) +v17, err := lang.WithMeta(v15, v16.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v18 := lang.Apply(v10, []any{v14, v17}) +var v7 any = v18 +_ = v7 +var v20 any +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("odd?")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("count")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v6}) +v28 := lang.Apply(v23, []any{v27}) +if lang.IsTruthy(v28) { +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("last")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.Apply(v31, []any{v6}) +v20 = v32 +} else { +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("seq")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("concat")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("list")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +} +v41 := v40.Get() +v42 := lang.Apply(v41, []any{lang.NewSymbol("throw")}) +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("list")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +} +v45 := v44.Get() +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("seq")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +} +v48 := v47.Get() +v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v50 := v49.FindInternedVar(lang.NewSymbol("concat")) +if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) +} +v51 := v50.Get() +v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v53 := v52.FindInternedVar(lang.NewSymbol("list")) +if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) +} +v54 := v53.Get() +v55 := lang.Apply(v54, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewIllegalArgumentError")}) +v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v57 := v56.FindInternedVar(lang.NewSymbol("list")) +if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) +} +v58 := v57.Get() +v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v60 := v59.FindInternedVar(lang.NewSymbol("seq")) +if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) +} +v61 := v60.Get() +v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v63 := v62.FindInternedVar(lang.NewSymbol("concat")) +if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +} +v64 := v63.Get() +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("list")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +} +v67 := v66.Get() +v68 := lang.Apply(v67, []any{lang.NewSymbol("glojure.core/str")}) +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("list")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +} +v71 := v70.Get() +v72 := lang.Apply(v71, []any{"No matching clause: "}) +v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v74 := v73.FindInternedVar(lang.NewSymbol("list")) +if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) +} +v75 := v74.Get() +v76 := lang.Apply(v75, []any{v7}) +v77 := lang.Apply(v64, []any{v68, v72, v76}) +v78 := lang.Apply(v61, []any{v77}) +v79 := lang.Apply(v58, []any{v78}) +v80 := lang.Apply(v51, []any{v55, v79}) +v81 := lang.Apply(v48, []any{v80}) +v82 := lang.Apply(v45, []any{v81}) +v83 := lang.Apply(v38, []any{v42, v82}) +v84 := lang.Apply(v35, []any{v83}) +v20 = v84 +} +var v19 any = v20 +_ = v19 +var v86 any +v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v88 := v87.FindInternedVar(lang.NewSymbol(">")) +if v88.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) +} +v89 := v88.Get() +v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v91 := v90.FindInternedVar(lang.NewSymbol("count")) +if v91.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) +} +v92 := v91.Get() +v93 := lang.Apply(v92, []any{v6}) +v94 := lang.Apply(v89, []any{int64(2), v93}) +if lang.IsTruthy(v94) { +v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v96 := v95.FindInternedVar(lang.NewSymbol("seq")) +if v96.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) +} +v97 := v96.Get() +v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v99 := v98.FindInternedVar(lang.NewSymbol("concat")) +if v99.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) +} +v100 := v99.Get() +v101 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v102 := v101.FindInternedVar(lang.NewSymbol("list")) +if v102.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v102))) +} +v103 := v102.Get() +v104 := lang.Apply(v103, []any{lang.NewSymbol("glojure.core/let")}) +v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v106 := v105.FindInternedVar(lang.NewSymbol("list")) +if v106.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) +} +v107 := v106.Get() +v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v109 := v108.FindInternedVar(lang.NewSymbol("apply")) +if v109.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) +} +v110 := v109.Get() +v111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v112 := v111.FindInternedVar(lang.NewSymbol("vector")) +if v112.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v112))) +} +v113 := v112.Get() +v114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v115 := v114.FindInternedVar(lang.NewSymbol("seq")) +if v115.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v115))) +} +v116 := v115.Get() +v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v118 := v117.FindInternedVar(lang.NewSymbol("concat")) +if v118.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) +} +v119 := v118.Get() +v120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v121 := v120.FindInternedVar(lang.NewSymbol("list")) +if v121.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v121))) +} +v122 := v121.Get() +v123 := lang.Apply(v122, []any{v7}) +v124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v125 := v124.FindInternedVar(lang.NewSymbol("list")) +if v125.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v125))) +} +v126 := v125.Get() +v127 := lang.Apply(v126, []any{v5}) +v128 := lang.Apply(v119, []any{v123, v127}) +v129 := lang.Apply(v116, []any{v128}) +v130 := lang.Apply(v110, []any{v113, v129}) +v131 := lang.Apply(v107, []any{v130}) +v132 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v133 := v132.FindInternedVar(lang.NewSymbol("list")) +if v133.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v133))) +} +v134 := v133.Get() +v135 := lang.Apply(v134, []any{v19}) +v136 := lang.Apply(v100, []any{v104, v131, v135}) +v137 := lang.Apply(v97, []any{v136}) +v86 = v137 +} else { +v139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v140 := v139.FindInternedVar(lang.NewSymbol("partition")) +if v140.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v140))) +} +v141 := v140.Get() +v142 := lang.Apply(v141, []any{int64(2), v6}) +var v138 any = v142 +_ = v138 +var v144 lang.FnFunc +{ // function assoc-test +v144 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v146 := args[0] +v147 := args[1] +v148 := args[2] +var v149 any +v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v151 := v150.FindInternedVar(lang.NewSymbol("contains?")) +if v151.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) +} +v152 := v151.Get() +v153 := lang.Apply(v152, []any{v146, v147}) +if lang.IsTruthy(v153) { +v154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v155 := v154.FindInternedVar(lang.NewSymbol("str")) +if v155.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v155))) +} +v156 := v155.Get() +v157 := lang.Apply(v156, []any{"Duplicate case test constant: ", v147}) +v158 := lang.Apply(lang1.NewIllegalArgumentError, []any{v157}) +panic(v158) +} else { +v159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v160 := v159.FindInternedVar(lang.NewSymbol("assoc")) +if v160.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v160))) +} +v161 := v160.Get() +v162 := lang.Apply(v161, []any{v146, v147, v148}) +v149 = v162 +} +return v149 +}) +v145 := v144 +_ = v145 +} +v145 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6788), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(6791), lang.NewKeyword("end-column"), int(48)) +v146, err := lang.WithMeta(v144, v145.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v143 any = v146 +_ = v143 +v148 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v149 := v148.FindInternedVar(lang.NewSymbol("reduce1")) +if v149.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v149))) +} +v150 := v149.Get() +var v151 lang.FnFunc +v151 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v152 := args[0] +v153 := args[1] +var v154 any = v153 +_ = v154 +v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v157 := v156.FindInternedVar(lang.NewSymbol("nth")) +if v157.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) +} +v158 := v157.Get() +v159 := lang.Apply(v158, []any{v154, int64(0), nil}) +var v155 any = v159 +_ = v155 +v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v162 := v161.FindInternedVar(lang.NewSymbol("nth")) +if v162.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) +} +v163 := v162.Get() +v164 := lang.Apply(v163, []any{v154, int64(1), nil}) +var v160 any = v164 +_ = v160 +var v166 any +v167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v168 := v167.FindInternedVar(lang.NewSymbol("seq?")) +if v168.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v168))) +} +v169 := v168.Get() +v170 := lang.Apply(v169, []any{v155}) +if lang.IsTruthy(v170) { +v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v172 := v171.FindInternedVar(lang.NewSymbol("reduce1")) +if v172.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) +} +v173 := v172.Get() +var v174 lang.FnFunc +v174 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v175 := args[0] +v176 := args[1] +v177 := lang.Apply(v143, []any{v175, v176, v160}) +return v177 +}) +v175 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6795), lang.NewKeyword("column"), int(37), lang.NewKeyword("end-line"), int(6795), lang.NewKeyword("end-column"), int(60)) +v176, err := lang.WithMeta(v174, v175.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v177 := lang.Apply(v173, []any{v176, v152, v155}) +v166 = v177 +} else { +v178 := lang.Apply(v143, []any{v152, v155, v160}) +v166 = v178 +} +return v166 +}) +v152 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6793), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(6796), lang.NewKeyword("end-column"), int(53)) +v153, err := lang.WithMeta(v151, v152.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v154 := lang.NewMap() +v155 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6797), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(6797), lang.NewKeyword("end-column"), int(25)) +v156, err := lang.WithMeta(v154, v155.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v157 := lang.Apply(v150, []any{v153, v156, v147}) +var v147 any = v157 +_ = v147 +v159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v160 := v159.FindInternedVar(lang.NewSymbol("keys")) +if v160.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v160))) +} +v161 := v160.Get() +v162 := lang.Apply(v161, []any{v147}) +var v158 any = v162 +_ = v158 +v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v165 := v164.FindInternedVar(lang.NewSymbol("vals")) +if v165.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) +} +v166 := v165.Get() +v167 := lang.Apply(v166, []any{v147}) +var v163 any = v167 +_ = v163 +var v169 any +v170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v171 := v170.FindInternedVar(lang.NewSymbol("every?")) +if v171.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v171))) +} +v172 := v171.Get() +var v173 lang.FnFunc +v173 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v174 := args[0] +v176 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v177 := v176.FindInternedVar(lang.NewSymbol("integer?")) +if v177.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v177))) +} +v178 := v177.Get() +v179 := lang.Apply(v178, []any{v174}) +var v175 any = v179 +_ = v175 +var v181 any +if lang.IsTruthy(v175) { +v182 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v183 := v182.FindInternedVar(lang.NewSymbol("<=")) +if v183.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v183))) +} +v184 := v183.Get() +v185 := lang.Apply(v184, []any{math7.MinInt, v174, math7.MaxInt}) +v181 = v185 +} else { +v181 = v175 +} +return v181 +}) +v174 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6801), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(6801), lang.NewKeyword("end-column"), int(77)) +v175, err := lang.WithMeta(v173, v174.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v176 := lang.Apply(v172, []any{v175, v158}) +if lang.IsTruthy(v176) { +v169 = lang.NewKeyword("ints") +} else { +var v177 any +v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v179 := v178.FindInternedVar(lang.NewSymbol("every?")) +if v179.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) +} +v180 := v179.Get() +v181 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v182 := v181.FindInternedVar(lang.NewSymbol("keyword?")) +if v182.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v182))) +} +v183 := v182.Get() +v184 := lang.Apply(v180, []any{v183, v158}) +if lang.IsTruthy(v184) { +v177 = lang.NewKeyword("identity") +} else { +var v185 any +if lang.IsTruthy(lang.NewKeyword("else")) { +v185 = lang.NewKeyword("hashes") +} else { +v185 = nil +} +v177 = v185 +} +v169 = v177 +} +var v168 any = v169 +_ = v168 +v188 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v189 := v188.FindInternedVar(lang.NewSymbol("=")) +if v189.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v189))) +} +v190 := v189.Get() +var v187 any = v190 +_ = v187 +var v191 any = v168 +_ = v191 +var v193 any +v194 := lang.Apply(v187, []any{lang.NewKeyword("ints"), v191}) +if lang.IsTruthy(v194) { +v196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v197 := v196.FindInternedVar(lang.NewSymbol("prep-ints")) +if v197.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v197))) +} +v198 := v197.Get() +v199 := lang.Apply(v198, []any{v158, v163}) +var v195 any = v199 +_ = v195 +v201 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v202 := v201.FindInternedVar(lang.NewSymbol("nth")) +if v202.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v202))) +} +v203 := v202.Get() +v204 := lang.Apply(v203, []any{v195, int64(0), nil}) +var v200 any = v204 +_ = v200 +v206 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v207 := v206.FindInternedVar(lang.NewSymbol("nth")) +if v207.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v207))) +} +v208 := v207.Get() +v209 := lang.Apply(v208, []any{v195, int64(1), nil}) +var v205 any = v209 +_ = v205 +v211 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v212 := v211.FindInternedVar(lang.NewSymbol("nth")) +if v212.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v212))) +} +v213 := v212.Get() +v214 := lang.Apply(v213, []any{v195, int64(2), nil}) +var v210 any = v214 +_ = v210 +v216 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v217 := v216.FindInternedVar(lang.NewSymbol("nth")) +if v217.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v217))) +} +v218 := v217.Get() +v219 := lang.Apply(v218, []any{v195, int64(3), nil}) +var v215 any = v219 +_ = v215 +v221 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v222 := v221.FindInternedVar(lang.NewSymbol("seq")) +if v222.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v222))) +} +v223 := v222.Get() +v224 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v225 := v224.FindInternedVar(lang.NewSymbol("concat")) +if v225.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v225))) +} +v226 := v225.Get() +v227 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v228 := v227.FindInternedVar(lang.NewSymbol("list")) +if v228.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v228))) +} +v229 := v228.Get() +v230 := lang.Apply(v229, []any{lang.NewSymbol("glojure.core/let")}) +v231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v232 := v231.FindInternedVar(lang.NewSymbol("list")) +if v232.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v232))) +} +v233 := v232.Get() +v234 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v235 := v234.FindInternedVar(lang.NewSymbol("apply")) +if v235.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v235))) +} +v236 := v235.Get() +v237 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v238 := v237.FindInternedVar(lang.NewSymbol("vector")) +if v238.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v238))) +} +v239 := v238.Get() +v240 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v241 := v240.FindInternedVar(lang.NewSymbol("seq")) +if v241.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v241))) +} +v242 := v241.Get() +v243 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v244 := v243.FindInternedVar(lang.NewSymbol("concat")) +if v244.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v244))) +} +v245 := v244.Get() +v246 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v247 := v246.FindInternedVar(lang.NewSymbol("list")) +if v247.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v247))) +} +v248 := v247.Get() +v249 := lang.Apply(v248, []any{v7}) +v250 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v251 := v250.FindInternedVar(lang.NewSymbol("list")) +if v251.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v251))) +} +v252 := v251.Get() +v253 := lang.Apply(v252, []any{v5}) +v254 := lang.Apply(v245, []any{v249, v253}) +v255 := lang.Apply(v242, []any{v254}) +v256 := lang.Apply(v236, []any{v239, v255}) +v257 := lang.Apply(v233, []any{v256}) +v258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v259 := v258.FindInternedVar(lang.NewSymbol("list")) +if v259.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v259))) +} +v260 := v259.Get() +v261 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v262 := v261.FindInternedVar(lang.NewSymbol("seq")) +if v262.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v262))) +} +v263 := v262.Get() +v264 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v265 := v264.FindInternedVar(lang.NewSymbol("concat")) +if v265.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v265))) +} +v266 := v265.Get() +v267 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v268 := v267.FindInternedVar(lang.NewSymbol("list")) +if v268.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v268))) +} +v269 := v268.Get() +v270 := lang.Apply(v269, []any{lang.NewSymbol("case*")}) +v271 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v272 := v271.FindInternedVar(lang.NewSymbol("list")) +if v272.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v272))) +} +v273 := v272.Get() +v274 := lang.Apply(v273, []any{v7}) +v275 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v276 := v275.FindInternedVar(lang.NewSymbol("list")) +if v276.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v276))) +} +v277 := v276.Get() +v278 := lang.Apply(v277, []any{v200}) +v279 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v280 := v279.FindInternedVar(lang.NewSymbol("list")) +if v280.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v280))) +} +v281 := v280.Get() +v282 := lang.Apply(v281, []any{v205}) +v283 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v284 := v283.FindInternedVar(lang.NewSymbol("list")) +if v284.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v284))) +} +v285 := v284.Get() +v286 := lang.Apply(v285, []any{v19}) +v287 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v288 := v287.FindInternedVar(lang.NewSymbol("list")) +if v288.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v288))) +} +v289 := v288.Get() +v290 := lang.Apply(v289, []any{v210}) +v291 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v292 := v291.FindInternedVar(lang.NewSymbol("list")) +if v292.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v292))) +} +v293 := v292.Get() +v294 := lang.Apply(v293, []any{v215}) +v295 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v296 := v295.FindInternedVar(lang.NewSymbol("list")) +if v296.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v296))) +} +v297 := v296.Get() +v298 := lang.Apply(v297, []any{lang.NewKeyword("int")}) +v299 := lang.Apply(v266, []any{v270, v274, v278, v282, v286, v290, v294, v298}) +v300 := lang.Apply(v263, []any{v299}) +v301 := lang.Apply(v260, []any{v300}) +v302 := lang.Apply(v226, []any{v230, v257, v301}) +v303 := lang.Apply(v223, []any{v302}) +v193 = v303 +} else { +var v195 any +v196 := lang.Apply(v187, []any{lang.NewKeyword("hashes"), v191}) +if lang.IsTruthy(v196) { +v198 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v199 := v198.FindInternedVar(lang.NewSymbol("prep-hashes")) +if v199.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v199))) +} +v200 := v199.Get() +v201 := lang.Apply(v200, []any{v7, v19, v158, v163}) +var v197 any = v201 +_ = v197 +v203 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v204 := v203.FindInternedVar(lang.NewSymbol("nth")) +if v204.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v204))) +} +v205 := v204.Get() +v206 := lang.Apply(v205, []any{v197, int64(0), nil}) +var v202 any = v206 +_ = v202 +v208 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v209 := v208.FindInternedVar(lang.NewSymbol("nth")) +if v209.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v209))) +} +v210 := v209.Get() +v211 := lang.Apply(v210, []any{v197, int64(1), nil}) +var v207 any = v211 +_ = v207 +v213 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v214 := v213.FindInternedVar(lang.NewSymbol("nth")) +if v214.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v214))) +} +v215 := v214.Get() +v216 := lang.Apply(v215, []any{v197, int64(2), nil}) +var v212 any = v216 +_ = v212 +v218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v219 := v218.FindInternedVar(lang.NewSymbol("nth")) +if v219.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v219))) +} +v220 := v219.Get() +v221 := lang.Apply(v220, []any{v197, int64(3), nil}) +var v217 any = v221 +_ = v217 +v223 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v224 := v223.FindInternedVar(lang.NewSymbol("nth")) +if v224.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v224))) +} +v225 := v224.Get() +v226 := lang.Apply(v225, []any{v197, int64(4), nil}) +var v222 any = v226 +_ = v222 +v228 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v229 := v228.FindInternedVar(lang.NewSymbol("seq")) +if v229.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v229))) +} +v230 := v229.Get() +v231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v232 := v231.FindInternedVar(lang.NewSymbol("concat")) +if v232.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v232))) +} +v233 := v232.Get() +v234 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v235 := v234.FindInternedVar(lang.NewSymbol("list")) +if v235.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v235))) +} +v236 := v235.Get() +v237 := lang.Apply(v236, []any{lang.NewSymbol("glojure.core/let")}) +v238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v239 := v238.FindInternedVar(lang.NewSymbol("list")) +if v239.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v239))) +} +v240 := v239.Get() +v241 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v242 := v241.FindInternedVar(lang.NewSymbol("apply")) +if v242.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v242))) +} +v243 := v242.Get() +v244 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v245 := v244.FindInternedVar(lang.NewSymbol("vector")) +if v245.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v245))) +} +v246 := v245.Get() +v247 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v248 := v247.FindInternedVar(lang.NewSymbol("seq")) +if v248.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v248))) +} +v249 := v248.Get() +v250 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v251 := v250.FindInternedVar(lang.NewSymbol("concat")) +if v251.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v251))) +} +v252 := v251.Get() +v253 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v254 := v253.FindInternedVar(lang.NewSymbol("list")) +if v254.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v254))) +} +v255 := v254.Get() +v256 := lang.Apply(v255, []any{v7}) +v257 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v258 := v257.FindInternedVar(lang.NewSymbol("list")) +if v258.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v258))) +} +v259 := v258.Get() +v260 := lang.Apply(v259, []any{v5}) +v261 := lang.Apply(v252, []any{v256, v260}) +v262 := lang.Apply(v249, []any{v261}) +v263 := lang.Apply(v243, []any{v246, v262}) +v264 := lang.Apply(v240, []any{v263}) +v265 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v266 := v265.FindInternedVar(lang.NewSymbol("list")) +if v266.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v266))) +} +v267 := v266.Get() +v268 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v269 := v268.FindInternedVar(lang.NewSymbol("seq")) +if v269.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v269))) +} +v270 := v269.Get() +v271 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v272 := v271.FindInternedVar(lang.NewSymbol("concat")) +if v272.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v272))) +} +v273 := v272.Get() +v274 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v275 := v274.FindInternedVar(lang.NewSymbol("list")) +if v275.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v275))) +} +v276 := v275.Get() +v277 := lang.Apply(v276, []any{lang.NewSymbol("case*")}) +v278 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v279 := v278.FindInternedVar(lang.NewSymbol("list")) +if v279.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v279))) +} +v280 := v279.Get() +v281 := lang.Apply(v280, []any{v7}) +v282 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v283 := v282.FindInternedVar(lang.NewSymbol("list")) +if v283.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v283))) +} +v284 := v283.Get() +v285 := lang.Apply(v284, []any{v202}) +v286 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v287 := v286.FindInternedVar(lang.NewSymbol("list")) +if v287.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v287))) +} +v288 := v287.Get() +v289 := lang.Apply(v288, []any{v207}) +v290 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v291 := v290.FindInternedVar(lang.NewSymbol("list")) +if v291.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v291))) +} +v292 := v291.Get() +v293 := lang.Apply(v292, []any{v19}) +v294 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v295 := v294.FindInternedVar(lang.NewSymbol("list")) +if v295.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v295))) +} +v296 := v295.Get() +v297 := lang.Apply(v296, []any{v212}) +v298 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v299 := v298.FindInternedVar(lang.NewSymbol("list")) +if v299.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v299))) +} +v300 := v299.Get() +v301 := lang.Apply(v300, []any{v217}) +v302 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v303 := v302.FindInternedVar(lang.NewSymbol("list")) +if v303.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v303))) +} +v304 := v303.Get() +v305 := lang.Apply(v304, []any{lang.NewKeyword("hash-equiv")}) +v306 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v307 := v306.FindInternedVar(lang.NewSymbol("list")) +if v307.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v307))) +} +v308 := v307.Get() +v309 := lang.Apply(v308, []any{v222}) +v310 := lang.Apply(v273, []any{v277, v281, v285, v289, v293, v297, v301, v305, v309}) +v311 := lang.Apply(v270, []any{v310}) +v312 := lang.Apply(v267, []any{v311}) +v313 := lang.Apply(v233, []any{v237, v264, v312}) +v314 := lang.Apply(v230, []any{v313}) +v195 = v314 +} else { +var v197 any +v198 := lang.Apply(v187, []any{lang.NewKeyword("identity"), v191}) +if lang.IsTruthy(v198) { +v200 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v201 := v200.FindInternedVar(lang.NewSymbol("prep-hashes")) +if v201.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v201))) +} +v202 := v201.Get() +v203 := lang.Apply(v202, []any{v7, v19, v158, v163}) +var v199 any = v203 +_ = v199 +v205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v206 := v205.FindInternedVar(lang.NewSymbol("nth")) +if v206.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v206))) +} +v207 := v206.Get() +v208 := lang.Apply(v207, []any{v199, int64(0), nil}) +var v204 any = v208 +_ = v204 +v210 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v211 := v210.FindInternedVar(lang.NewSymbol("nth")) +if v211.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v211))) +} +v212 := v211.Get() +v213 := lang.Apply(v212, []any{v199, int64(1), nil}) +var v209 any = v213 +_ = v209 +v215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v216 := v215.FindInternedVar(lang.NewSymbol("nth")) +if v216.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v216))) +} +v217 := v216.Get() +v218 := lang.Apply(v217, []any{v199, int64(2), nil}) +var v214 any = v218 +_ = v214 +v220 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v221 := v220.FindInternedVar(lang.NewSymbol("nth")) +if v221.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v221))) +} +v222 := v221.Get() +v223 := lang.Apply(v222, []any{v199, int64(3), nil}) +var v219 any = v223 +_ = v219 +v225 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v226 := v225.FindInternedVar(lang.NewSymbol("nth")) +if v226.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v226))) +} +v227 := v226.Get() +v228 := lang.Apply(v227, []any{v199, int64(4), nil}) +var v224 any = v228 +_ = v224 +v230 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v231 := v230.FindInternedVar(lang.NewSymbol("seq")) +if v231.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v231))) +} +v232 := v231.Get() +v233 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v234 := v233.FindInternedVar(lang.NewSymbol("concat")) +if v234.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v234))) +} +v235 := v234.Get() +v236 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v237 := v236.FindInternedVar(lang.NewSymbol("list")) +if v237.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v237))) +} +v238 := v237.Get() +v239 := lang.Apply(v238, []any{lang.NewSymbol("glojure.core/let")}) +v240 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v241 := v240.FindInternedVar(lang.NewSymbol("list")) +if v241.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v241))) +} +v242 := v241.Get() +v243 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v244 := v243.FindInternedVar(lang.NewSymbol("apply")) +if v244.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v244))) +} +v245 := v244.Get() +v246 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v247 := v246.FindInternedVar(lang.NewSymbol("vector")) +if v247.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v247))) +} +v248 := v247.Get() +v249 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v250 := v249.FindInternedVar(lang.NewSymbol("seq")) +if v250.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v250))) +} +v251 := v250.Get() +v252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v253 := v252.FindInternedVar(lang.NewSymbol("concat")) +if v253.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v253))) +} +v254 := v253.Get() +v255 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v256 := v255.FindInternedVar(lang.NewSymbol("list")) +if v256.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v256))) +} +v257 := v256.Get() +v258 := lang.Apply(v257, []any{v7}) +v259 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v260 := v259.FindInternedVar(lang.NewSymbol("list")) +if v260.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v260))) +} +v261 := v260.Get() +v262 := lang.Apply(v261, []any{v5}) +v263 := lang.Apply(v254, []any{v258, v262}) +v264 := lang.Apply(v251, []any{v263}) +v265 := lang.Apply(v245, []any{v248, v264}) +v266 := lang.Apply(v242, []any{v265}) +v267 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v268 := v267.FindInternedVar(lang.NewSymbol("list")) +if v268.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v268))) +} +v269 := v268.Get() +v270 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v271 := v270.FindInternedVar(lang.NewSymbol("seq")) +if v271.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v271))) +} +v272 := v271.Get() +v273 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v274 := v273.FindInternedVar(lang.NewSymbol("concat")) +if v274.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v274))) +} +v275 := v274.Get() +v276 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v277 := v276.FindInternedVar(lang.NewSymbol("list")) +if v277.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v277))) +} +v278 := v277.Get() +v279 := lang.Apply(v278, []any{lang.NewSymbol("case*")}) +v280 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v281 := v280.FindInternedVar(lang.NewSymbol("list")) +if v281.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v281))) +} +v282 := v281.Get() +v283 := lang.Apply(v282, []any{v7}) +v284 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v285 := v284.FindInternedVar(lang.NewSymbol("list")) +if v285.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v285))) +} +v286 := v285.Get() +v287 := lang.Apply(v286, []any{v204}) +v288 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v289 := v288.FindInternedVar(lang.NewSymbol("list")) +if v289.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v289))) +} +v290 := v289.Get() +v291 := lang.Apply(v290, []any{v209}) +v292 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v293 := v292.FindInternedVar(lang.NewSymbol("list")) +if v293.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v293))) +} +v294 := v293.Get() +v295 := lang.Apply(v294, []any{v19}) +v296 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v297 := v296.FindInternedVar(lang.NewSymbol("list")) +if v297.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v297))) +} +v298 := v297.Get() +v299 := lang.Apply(v298, []any{v214}) +v300 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v301 := v300.FindInternedVar(lang.NewSymbol("list")) +if v301.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v301))) +} +v302 := v301.Get() +v303 := lang.Apply(v302, []any{v219}) +v304 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v305 := v304.FindInternedVar(lang.NewSymbol("list")) +if v305.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v305))) +} +v306 := v305.Get() +v307 := lang.Apply(v306, []any{lang.NewKeyword("hash-identity")}) +v308 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v309 := v308.FindInternedVar(lang.NewSymbol("list")) +if v309.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v309))) +} +v310 := v309.Get() +v311 := lang.Apply(v310, []any{v224}) +v312 := lang.Apply(v275, []any{v279, v283, v287, v291, v295, v299, v303, v307, v311}) +v313 := lang.Apply(v272, []any{v312}) +v314 := lang.Apply(v269, []any{v313}) +v315 := lang.Apply(v235, []any{v239, v266, v314}) +v316 := lang.Apply(v232, []any{v315}) +v197 = v316 +} else { +v199 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v200 := v199.FindInternedVar(lang.NewSymbol("str")) +if v200.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v200))) +} +v201 := v200.Get() +v202 := lang.Apply(v201, []any{"No matching clause: ", v191}) +v203 := lang.Apply(lang1.NewIllegalArgumentError, []any{v202}) +panic(v203) +} +v195 = v197 +} +v193 = v195 +} +v86 = v193 +} +return v86 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// instance? +{ +v0 := lang.NewSymbol("instance?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Evaluates x and tests if it is an instance of the type\n t. Returns true or false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(139), lang.NewKeyword("end-line"), int(143))).(*lang.Symbol) +var v2 lang.FnFunc +{ // function instance? +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := args[1] +v6 := lang.Apply(lang1.HasType, []any{v4, v5}) +return v6 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(143), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(143), lang.NewKeyword("end-column"), int(85))).(lang.FnFunc) +v3 := v2 +_ = v3 +} +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// isa? +{ +v0 := lang.NewSymbol("isa?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("child"), lang.NewSymbol("parent")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("child"), lang.NewSymbol("parent"))), lang.NewKeyword("doc"), "Returns true if (= child parent), or child is directly or indirectly derived from\n parent, either via a Java type inheritance relationship or a\n relationship established via derive. h must be a hierarchy obtained\n from make-hierarchy, if not supplied defaults to the global\n hierarchy", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5586), lang.NewKeyword("end-line"), int(5586))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("isa?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("global-hierarchy")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v7, []any{v10, v3, v4}) +return v11 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("=")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v4, v5}) +var v6 any = v10 +_ = v6 +var v12 any +if lang.IsTruthy(v6) { +v12 = v6 +} else { +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("class?")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v5}) +var v14 any = v18 +_ = v14 +var v20 any +if lang.IsTruthy(v14) { +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("class?")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v4}) +var v21 any = v25 +_ = v21 +var v27 any +if lang.IsTruthy(v21) { +v28, _ := lang.FieldOrMethod(v4, "AssignableTo") +if reflect.TypeOf(v28).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("AssignableTo is not a function"))) +} +v29 := lang.Apply(v28, []any{v5}) +v27 = v29 +} else { +v27 = v21 +} +v20 = v27 +} else { +v20 = v14 +} +var v13 any = v20 +_ = v13 +var v15 any +if lang.IsTruthy(v13) { +v15 = v13 +} else { +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("contains?")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) +v21 := lang.Apply(v20, []any{v4}) +v22 := lang.Apply(v19, []any{v21, v5}) +var v16 any = v22 +_ = v16 +var v24 any +if lang.IsTruthy(v16) { +v24 = v16 +} else { +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("class?")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{v4}) +var v26 any = v30 +_ = v26 +var v32 any +if lang.IsTruthy(v26) { +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("some")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +var v36 lang.FnFunc +v36 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v37 := args[0] +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("contains?")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) +v42 := lang.Apply(v41, []any{v37}) +v43 := lang.Apply(v40, []any{v42, v5}) +return v43 +}) +v37 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5599), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(5599), lang.NewKeyword("end-column"), int(71)) +v38, err := lang.WithMeta(v36, v37.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("supers")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +} +v41 := v40.Get() +v42 := lang.Apply(v41, []any{v4}) +v43 := lang.Apply(v35, []any{v38, v42}) +v32 = v43 +} else { +v32 = v26 +} +var v25 any = v32 +_ = v25 +var v27 any +if lang.IsTruthy(v25) { +v27 = v25 +} else { +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("vector?")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.Apply(v31, []any{v5}) +var v28 any = v32 +_ = v28 +var v34 any +if lang.IsTruthy(v28) { +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("vector?")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v4}) +var v35 any = v39 +_ = v35 +var v41 any +if lang.IsTruthy(v35) { +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("=")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +} +v45 := v44.Get() +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("count")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +} +v48 := v47.Get() +v49 := lang.Apply(v48, []any{v5}) +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("count")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +} +v52 := v51.Get() +v53 := lang.Apply(v52, []any{v4}) +v54 := lang.Apply(v45, []any{v49, v53}) +var v42 any = v54 +_ = v42 +var v56 any +if lang.IsTruthy(v42) { +var v57 any = true +_ = v57 +var v58 any = int64(0) +_ = v58 +var v59 any +for { +var v60 any +v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v63 := v62.FindInternedVar(lang.NewSymbol("not")) +if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +} +v64 := v63.Get() +v65 := lang.Apply(v64, []any{v57}) +var v61 any = v65 +_ = v61 +var v67 any +if lang.IsTruthy(v61) { +v67 = v61 +} else { +v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v69 := v68.FindInternedVar(lang.NewSymbol("=")) +if v69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) +} +v70 := v69.Get() +v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v72 := v71.FindInternedVar(lang.NewSymbol("count")) +if v72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) +} +v73 := v72.Get() +v74 := lang.Apply(v73, []any{v5}) +v75 := lang.Apply(v70, []any{v58, v74}) +v67 = v75 +} +if lang.IsTruthy(v67) { +v60 = v57 +} else { +v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v63 := v62.FindInternedVar(lang.NewSymbol("isa?")) +if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +} +v64 := v63.Get() +v65 := lang.Apply(v4, []any{v58}) +v66 := lang.Apply(v5, []any{v58}) +v67 := lang.Apply(v64, []any{v3, v65, v66}) +var v61 any = v67 +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("inc")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +} +v71 := v70.Get() +v72 := lang.Apply(v71, []any{v58}) +var v68 any = v72 +v57 = v61 +v58 = v68 +continue +} +v59 = v60 + break +} +v56 = v59 +} else { +v56 = v42 +} +v41 = v56 +} else { +v41 = v35 +} +v34 = v41 +} else { +v34 = v28 +} +v27 = v34 +} +v24 = v27 +} +v15 = v24 +} +v12 = v15 +} +return v12 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// keys +{ +v0 := lang.NewSymbol("keys").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"))), lang.NewKeyword("doc"), "Returns a sequence of the map's keys, in the same order as (seq map).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1551), lang.NewKeyword("end-line"), int(1551))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.Apply(lang1.Keys, []any{v3}) +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// nat-int? +{ +v0 := lang.NewSymbol("nat-int?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a non-negative fixed precision integer", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1415), lang.NewKeyword("end-line"), int(1415))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("int?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +var v4 any = v8 +_ = v4 +var v10 any +if lang.IsTruthy(v4) { +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("not")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("neg?")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v3}) +v18 := lang.Apply(v13, []any{v17}) +v10 = v18 +} else { +v10 = v4 +} +return v10 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// destructure +{ +v0 := lang.NewSymbol("destructure").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4400), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(4400), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("partition")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{int64(2), v3}) +var v4 any = v8 +_ = v4 +var v10 lang.FnFunc +{ // function pb +v10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v12 := args[0] +v13 := args[1] +v14 := args[2] +var v16 lang.FnFunc +v16 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v17 := args[0] +v18 := args[1] +v19 := args[2] +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("gensym")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(v23, []any{"vec__"}) +var v20 any = v24 +_ = v20 +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("gensym")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.Apply(v28, []any{"seq__"}) +var v25 any = v29 +_ = v25 +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("gensym")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{"first__"}) +var v30 any = v34 +_ = v30 +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("some")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.CreatePersistentTreeSet(lang.NewSymbol("&")) +v40 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4408), lang.NewKeyword("column"), int(43), lang.NewKeyword("end-line"), int(4408), lang.NewKeyword("end-column"), int(47)) +v41, err := lang.WithMeta(v39, v40.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v42 := lang.Apply(v38, []any{v41, v18}) +var v35 any = v42 +_ = v35 +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("conj")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +} +v48 := v47.Get() +v49 := lang.Apply(v48, []any{v17, v20, v19}) +var v45 any = v49 +_ = v45 +var v51 any +if lang.IsTruthy(v35) { +v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v53 := v52.FindInternedVar(lang.NewSymbol("conj")) +if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) +} +v54 := v53.Get() +v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v56 := v55.FindInternedVar(lang.NewSymbol("list")) +if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) +} +v57 := v56.Get() +v58 := lang.Apply(v57, []any{lang.NewSymbol("glojure.core/seq"), v20}) +v59 := lang.Apply(v54, []any{v45, v25, v58}) +v51 = v59 +} else { +v51 = v45 +} +var v44 any = v51 +_ = v44 +var v45 any = int64(0) +_ = v45 +var v46 any = v18 +_ = v46 +var v47 any = false +_ = v47 +var v48 any +for { +var v49 any +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("seq")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +} +v52 := v51.Get() +v53 := lang.Apply(v52, []any{v46}) +if lang.IsTruthy(v53) { +v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v56 := v55.FindInternedVar(lang.NewSymbol("first")) +if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) +} +v57 := v56.Get() +v58 := lang.Apply(v57, []any{v46}) +var v54 any = v58 +_ = v54 +var v60 any +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("=")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +} +v63 := v62.Get() +v64 := lang.Apply(v63, []any{v54, lang.NewSymbol("&")}) +if lang.IsTruthy(v64) { +v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v67 := v66.FindInternedVar(lang.NewSymbol("second")) +if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) +} +v68 := v67.Get() +v69 := lang.Apply(v68, []any{v46}) +v70 := lang.Apply(v11, []any{v44, v69, v25}) +var v65 any = v70 +var v71 any = v45 +v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v74 := v73.FindInternedVar(lang.NewSymbol("nnext")) +if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) +} +v75 := v74.Get() +v76 := lang.Apply(v75, []any{v46}) +var v72 any = v76 +var v77 any = true +v44 = v65 +v45 = v71 +v46 = v72 +v47 = v77 +continue +} else { +var v78 any +v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v80 := v79.FindInternedVar(lang.NewSymbol("=")) +if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) +} +v81 := v80.Get() +v82 := lang.Apply(v81, []any{v54, lang.NewKeyword("as")}) +if lang.IsTruthy(v82) { +v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v84 := v83.FindInternedVar(lang.NewSymbol("second")) +if v84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) +} +v85 := v84.Get() +v86 := lang.Apply(v85, []any{v46}) +v87 := lang.Apply(v11, []any{v44, v86, v20}) +v78 = v87 +} else { +var v88 any +if lang.IsTruthy(lang.NewKeyword("else")) { +var v89 any +if lang.IsTruthy(v47) { +v90 := lang.Apply(errors10.New, []any{"Unsupported binding form, only :as can follow & parameter"}) +panic(v90) +} else { +var v92 any +if lang.IsTruthy(v35) { +v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v94 := v93.FindInternedVar(lang.NewSymbol("conj")) +if v94.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) +} +v95 := v94.Get() +v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v97 := v96.FindInternedVar(lang.NewSymbol("seq")) +if v97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) +} +v98 := v97.Get() +v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v100 := v99.FindInternedVar(lang.NewSymbol("concat")) +if v100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) +} +v101 := v100.Get() +v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v103 := v102.FindInternedVar(lang.NewSymbol("list")) +if v103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) +} +v104 := v103.Get() +v105 := lang.Apply(v104, []any{lang.NewSymbol("glojure.core/first")}) +v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v107 := v106.FindInternedVar(lang.NewSymbol("list")) +if v107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) +} +v108 := v107.Get() +v109 := lang.Apply(v108, []any{v25}) +v110 := lang.Apply(v101, []any{v105, v109}) +v111 := lang.Apply(v98, []any{v110}) +v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v113 := v112.FindInternedVar(lang.NewSymbol("seq")) +if v113.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) +} +v114 := v113.Get() +v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v116 := v115.FindInternedVar(lang.NewSymbol("concat")) +if v116.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) +} +v117 := v116.Get() +v118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v119 := v118.FindInternedVar(lang.NewSymbol("list")) +if v119.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v119))) +} +v120 := v119.Get() +v121 := lang.Apply(v120, []any{lang.NewSymbol("glojure.core/next")}) +v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v123 := v122.FindInternedVar(lang.NewSymbol("list")) +if v123.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) +} +v124 := v123.Get() +v125 := lang.Apply(v124, []any{v25}) +v126 := lang.Apply(v117, []any{v121, v125}) +v127 := lang.Apply(v114, []any{v126}) +v128 := lang.Apply(v95, []any{v44, v30, v111, v25, v127}) +v92 = v128 +} else { +v92 = v44 +} +var v129 any +if lang.IsTruthy(v35) { +v129 = v30 +} else { +v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v131 := v130.FindInternedVar(lang.NewSymbol("list")) +if v131.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) +} +v132 := v131.Get() +v133 := lang.Apply(v132, []any{lang.NewSymbol("glojure.core/nth"), v20, v45, nil}) +v129 = v133 +} +v134 := lang.Apply(v11, []any{v92, v54, v129}) +var v91 any = v134 +v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v137 := v136.FindInternedVar(lang.NewSymbol("inc")) +if v137.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) +} +v138 := v137.Get() +v139 := lang.Apply(v138, []any{v45}) +var v135 any = v139 +v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v142 := v141.FindInternedVar(lang.NewSymbol("next")) +if v142.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) +} +v143 := v142.Get() +v144 := lang.Apply(v143, []any{v46}) +var v140 any = v144 +var v145 any = v47 +v44 = v91 +v45 = v135 +v46 = v140 +v47 = v145 +continue +} +v88 = v89 +} else { +v88 = nil +} +v78 = v88 +} +v60 = v78 +} +v49 = v60 +} else { +v49 = v44 +} +v48 = v49 + break +} +return v48 +}) +v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4404), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(4438), lang.NewKeyword("end-column"), int(34)) +v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v15 any = v18 +_ = v15 +var v20 lang.FnFunc +v20 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v21 := args[0] +v22 := args[1] +v23 := args[2] +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("gensym")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.Apply(v27, []any{"map__"}) +var v24 any = v28 +_ = v24 +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("with-meta")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.NewMap(lang.NewKeyword("tag"), lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.ISeq")) +v34 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4442), lang.NewKeyword("column"), int(52), lang.NewKeyword("end-line"), int(4442), lang.NewKeyword("end-column"), int(103)) +v35, err := lang.WithMeta(v33, v34.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v36 := lang.Apply(v32, []any{v24, v35}) +var v29 any = v36 +_ = v29 +v38 := lang.Apply(lang.NewKeyword("or"), []any{v22}) +var v37 any = v38 +_ = v37 +var v41 lang.FnFunc +v41 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v42 := args[0] +var v43 any +v44 := lang.Apply(lang.NewKeyword("as"), []any{v22}) +if lang.IsTruthy(v44) { +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("conj")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +} +v47 := v46.Get() +v48 := lang.Apply(lang.NewKeyword("as"), []any{v22}) +v49 := lang.Apply(v47, []any{v42, v48, v24}) +v43 = v49 +} else { +v43 = v42 +} +return v43 +}) +v42 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4450), lang.NewKeyword("column"), int(40), lang.NewKeyword("end-line"), int(4453), lang.NewKeyword("end-column"), int(48)) +v43, err := lang.WithMeta(v41, v42.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("conj")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("conj")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +} +v49 := v48.Get() +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("conj")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +} +v52 := v51.Get() +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("conj")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +} +v55 := v54.Get() +v56 := lang.Apply(v55, []any{v21, v24}) +v57 := lang.Apply(v52, []any{v56, v23}) +v58 := lang.Apply(v49, []any{v57, v24}) +v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v60 := v59.FindInternedVar(lang.NewSymbol("seq")) +if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) +} +v61 := v60.Get() +v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v63 := v62.FindInternedVar(lang.NewSymbol("concat")) +if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +} +v64 := v63.Get() +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("list")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +} +v67 := v66.Get() +v68 := lang.Apply(v67, []any{lang.NewSymbol("if")}) +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("list")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +} +v71 := v70.Get() +v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v73 := v72.FindInternedVar(lang.NewSymbol("seq")) +if v73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) +} +v74 := v73.Get() +v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v76 := v75.FindInternedVar(lang.NewSymbol("concat")) +if v76.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) +} +v77 := v76.Get() +v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v79 := v78.FindInternedVar(lang.NewSymbol("list")) +if v79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) +} +v80 := v79.Get() +v81 := lang.Apply(v80, []any{lang.NewSymbol("glojure.core/seq?")}) +v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v83 := v82.FindInternedVar(lang.NewSymbol("list")) +if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) +} +v84 := v83.Get() +v85 := lang.Apply(v84, []any{v24}) +v86 := lang.Apply(v77, []any{v81, v85}) +v87 := lang.Apply(v74, []any{v86}) +v88 := lang.Apply(v71, []any{v87}) +v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v90 := v89.FindInternedVar(lang.NewSymbol("list")) +if v90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) +} +v91 := v90.Get() +v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v93 := v92.FindInternedVar(lang.NewSymbol("seq")) +if v93.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) +} +v94 := v93.Get() +v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v96 := v95.FindInternedVar(lang.NewSymbol("concat")) +if v96.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) +} +v97 := v96.Get() +v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v99 := v98.FindInternedVar(lang.NewSymbol("list")) +if v99.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) +} +v100 := v99.Get() +v101 := lang.Apply(v100, []any{lang.NewSymbol("if")}) +v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v103 := v102.FindInternedVar(lang.NewSymbol("list")) +if v103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) +} +v104 := v103.Get() +v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v106 := v105.FindInternedVar(lang.NewSymbol("seq")) +if v106.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) +} +v107 := v106.Get() +v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v109 := v108.FindInternedVar(lang.NewSymbol("concat")) +if v109.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) +} +v110 := v109.Get() +v111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v112 := v111.FindInternedVar(lang.NewSymbol("list")) +if v112.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v112))) +} +v113 := v112.Get() +v114 := lang.Apply(v113, []any{lang.NewSymbol("glojure.core/next")}) +v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v116 := v115.FindInternedVar(lang.NewSymbol("list")) +if v116.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) +} +v117 := v116.Get() +v118 := lang.Apply(v117, []any{v29}) +v119 := lang.Apply(v110, []any{v114, v118}) +v120 := lang.Apply(v107, []any{v119}) +v121 := lang.Apply(v104, []any{v120}) +v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v123 := v122.FindInternedVar(lang.NewSymbol("list")) +if v123.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) +} +v124 := v123.Get() +v125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v126 := v125.FindInternedVar(lang.NewSymbol("seq")) +if v126.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v126))) +} +v127 := v126.Get() +v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v129 := v128.FindInternedVar(lang.NewSymbol("concat")) +if v129.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v129))) +} +v130 := v129.Get() +v131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v132 := v131.FindInternedVar(lang.NewSymbol("list")) +if v132.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v132))) +} +v133 := v132.Get() +v134 := lang.Apply(v133, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewPersistentArrayMapAsIfByAssoc")}) +v135 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v136 := v135.FindInternedVar(lang.NewSymbol("list")) +if v136.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v136))) +} +v137 := v136.Get() +v138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v139 := v138.FindInternedVar(lang.NewSymbol("seq")) +if v139.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v139))) +} +v140 := v139.Get() +v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v142 := v141.FindInternedVar(lang.NewSymbol("concat")) +if v142.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) +} +v143 := v142.Get() +v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v145 := v144.FindInternedVar(lang.NewSymbol("list")) +if v145.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) +} +v146 := v145.Get() +v147 := lang.Apply(v146, []any{lang.NewSymbol("glojure.core/to-array")}) +v148 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v149 := v148.FindInternedVar(lang.NewSymbol("list")) +if v149.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v149))) +} +v150 := v149.Get() +v151 := lang.Apply(v150, []any{v29}) +v152 := lang.Apply(v143, []any{v147, v151}) +v153 := lang.Apply(v140, []any{v152}) +v154 := lang.Apply(v137, []any{v153}) +v155 := lang.Apply(v130, []any{v134, v154}) +v156 := lang.Apply(v127, []any{v155}) +v157 := lang.Apply(v124, []any{v156}) +v158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v159 := v158.FindInternedVar(lang.NewSymbol("list")) +if v159.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v159))) +} +v160 := v159.Get() +v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v162 := v161.FindInternedVar(lang.NewSymbol("seq")) +if v162.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) +} +v163 := v162.Get() +v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v165 := v164.FindInternedVar(lang.NewSymbol("concat")) +if v165.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) +} +v166 := v165.Get() +v167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v168 := v167.FindInternedVar(lang.NewSymbol("list")) +if v168.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v168))) +} +v169 := v168.Get() +v170 := lang.Apply(v169, []any{lang.NewSymbol("if")}) +v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v172 := v171.FindInternedVar(lang.NewSymbol("list")) +if v172.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) +} +v173 := v172.Get() +v174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v175 := v174.FindInternedVar(lang.NewSymbol("seq")) +if v175.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v175))) +} +v176 := v175.Get() +v177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v178 := v177.FindInternedVar(lang.NewSymbol("concat")) +if v178.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v178))) +} +v179 := v178.Get() +v180 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v181 := v180.FindInternedVar(lang.NewSymbol("list")) +if v181.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v181))) +} +v182 := v181.Get() +v183 := lang.Apply(v182, []any{lang.NewSymbol("glojure.core/seq")}) +v184 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v185 := v184.FindInternedVar(lang.NewSymbol("list")) +if v185.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v185))) +} +v186 := v185.Get() +v187 := lang.Apply(v186, []any{v29}) +v188 := lang.Apply(v179, []any{v183, v187}) +v189 := lang.Apply(v176, []any{v188}) +v190 := lang.Apply(v173, []any{v189}) +v191 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v192 := v191.FindInternedVar(lang.NewSymbol("list")) +if v192.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v192))) +} +v193 := v192.Get() +v194 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v195 := v194.FindInternedVar(lang.NewSymbol("seq")) +if v195.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v195))) +} +v196 := v195.Get() +v197 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v198 := v197.FindInternedVar(lang.NewSymbol("concat")) +if v198.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v198))) +} +v199 := v198.Get() +v200 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v201 := v200.FindInternedVar(lang.NewSymbol("list")) +if v201.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v201))) +} +v202 := v201.Get() +v203 := lang.Apply(v202, []any{lang.NewSymbol("glojure.core/first")}) +v204 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v205 := v204.FindInternedVar(lang.NewSymbol("list")) +if v205.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v205))) +} +v206 := v205.Get() +v207 := lang.Apply(v206, []any{v29}) +v208 := lang.Apply(v199, []any{v203, v207}) +v209 := lang.Apply(v196, []any{v208}) +v210 := lang.Apply(v193, []any{v209}) +v211 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v212 := v211.FindInternedVar(lang.NewSymbol("list")) +if v212.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v212))) +} +v213 := v212.Get() +v214 := lang.Apply(v213, []any{lang.NewSymbol("glojure.lang.PersistentArrayMap/EMPTY")}) +v215 := lang.Apply(v166, []any{v170, v190, v210, v214}) +v216 := lang.Apply(v163, []any{v215}) +v217 := lang.Apply(v160, []any{v216}) +v218 := lang.Apply(v97, []any{v101, v121, v157, v217}) +v219 := lang.Apply(v94, []any{v218}) +v220 := lang.Apply(v91, []any{v219}) +v221 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v222 := v221.FindInternedVar(lang.NewSymbol("list")) +if v222.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v222))) +} +v223 := v222.Get() +v224 := lang.Apply(v223, []any{v24}) +v225 := lang.Apply(v64, []any{v68, v88, v220, v224}) +v226 := lang.Apply(v61, []any{v225}) +v227 := lang.Apply(v46, []any{v58, v226}) +v228 := lang.Apply(v43, []any{v227}) +var v40 any = v228 +_ = v40 +v231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v232 := v231.FindInternedVar(lang.NewSymbol("reduce1")) +if v232.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v232))) +} +v233 := v232.Get() +var v234 lang.FnFunc +v234 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v235 := args[0] +v236 := args[1] +var v237 any +v238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v239 := v238.FindInternedVar(lang.NewSymbol("keyword?")) +if v239.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v239))) +} +v240 := v239.Get() +v241 := lang.Apply(v240, []any{v236}) +if lang.IsTruthy(v241) { +v243 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v244 := v243.FindInternedVar(lang.NewSymbol("namespace")) +if v244.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v244))) +} +v245 := v244.Get() +v246 := lang.Apply(v245, []any{v236}) +var v242 any = v246 +_ = v242 +v248 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v249 := v248.FindInternedVar(lang.NewSymbol("name")) +if v249.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v249))) +} +v250 := v249.Get() +v251 := lang.Apply(v250, []any{v236}) +var v247 any = v251 +_ = v247 +var v253 any +v254 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v255 := v254.FindInternedVar(lang.NewSymbol("=")) +if v255.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v255))) +} +v256 := v255.Get() +v257 := lang.Apply(v256, []any{v247, "keys"}) +if lang.IsTruthy(v257) { +v258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v259 := v258.FindInternedVar(lang.NewSymbol("assoc")) +if v259.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v259))) +} +v260 := v259.Get() +var v261 lang.FnFunc +v261 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v262 := args[0] +v263 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v264 := v263.FindInternedVar(lang.NewSymbol("keyword")) +if v264.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v264))) +} +v265 := v264.Get() +var v266 any = v242 +_ = v266 +var v268 any +if lang.IsTruthy(v266) { +v268 = v266 +} else { +v269 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v270 := v269.FindInternedVar(lang.NewSymbol("namespace")) +if v270.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v270))) +} +v271 := v270.Get() +v272 := lang.Apply(v271, []any{v262}) +v268 = v272 +} +v266 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v267 := v266.FindInternedVar(lang.NewSymbol("name")) +if v267.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v267))) +} +v268 := v267.Get() +v269 := lang.Apply(v268, []any{v262}) +v270 := lang.Apply(v265, []any{v268, v269}) +return v270 +}) +v262 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4460), lang.NewKeyword("column"), int(93), lang.NewKeyword("end-line"), int(4460), lang.NewKeyword("end-column"), int(135)) +v263, err := lang.WithMeta(v261, v262.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v264 := lang.Apply(v260, []any{v235, v236, v263}) +v253 = v264 +} else { +var v265 any +v266 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v267 := v266.FindInternedVar(lang.NewSymbol("=")) +if v267.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v267))) +} +v268 := v267.Get() +v269 := lang.Apply(v268, []any{v247, "syms"}) +if lang.IsTruthy(v269) { +v270 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v271 := v270.FindInternedVar(lang.NewSymbol("assoc")) +if v271.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v271))) +} +v272 := v271.Get() +var v273 lang.FnFunc +v273 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v274 := args[0] +v275 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v276 := v275.FindInternedVar(lang.NewSymbol("list")) +if v276.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v276))) +} +v277 := v276.Get() +v278 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v279 := v278.FindInternedVar(lang.NewSymbol("symbol")) +if v279.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v279))) +} +v280 := v279.Get() +var v281 any = v242 +_ = v281 +var v283 any +if lang.IsTruthy(v281) { +v283 = v281 +} else { +v284 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v285 := v284.FindInternedVar(lang.NewSymbol("namespace")) +if v285.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v285))) +} +v286 := v285.Get() +v287 := lang.Apply(v286, []any{v274}) +v283 = v287 +} +v281 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v282 := v281.FindInternedVar(lang.NewSymbol("name")) +if v282.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v282))) +} +v283 := v282.Get() +v284 := lang.Apply(v283, []any{v274}) +v285 := lang.Apply(v280, []any{v283, v284}) +v286 := lang.Apply(v277, []any{lang.NewSymbol("quote"), v285}) +return v286 +}) +v274 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4461), lang.NewKeyword("column"), int(93), lang.NewKeyword("end-line"), int(4461), lang.NewKeyword("end-column"), int(148)) +v275, err := lang.WithMeta(v273, v274.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v276 := lang.Apply(v272, []any{v235, v236, v275}) +v265 = v276 +} else { +var v277 any +v278 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v279 := v278.FindInternedVar(lang.NewSymbol("=")) +if v279.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v279))) +} +v280 := v279.Get() +v281 := lang.Apply(v280, []any{v247, "strs"}) +if lang.IsTruthy(v281) { +v282 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v283 := v282.FindInternedVar(lang.NewSymbol("assoc")) +if v283.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v283))) +} +v284 := v283.Get() +v285 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v286 := v285.FindInternedVar(lang.NewSymbol("str")) +if v286.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v286))) +} +v287 := v286.Get() +v288 := lang.Apply(v284, []any{v235, v236, v287}) +v277 = v288 +} else { +var v289 any +if lang.IsTruthy(lang.NewKeyword("else")) { +v289 = v235 +} else { +v289 = nil +} +v277 = v289 +} +v265 = v277 +} +v253 = v265 +} +v237 = v253 +} else { +v237 = v235 +} +return v237 +}) +v235 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4456), lang.NewKeyword("column"), int(45), lang.NewKeyword("end-line"), int(4464), lang.NewKeyword("end-column"), int(60)) +v236, err := lang.WithMeta(v234, v235.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v237 := lang.NewMap() +v238 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4465), lang.NewKeyword("column"), int(45), lang.NewKeyword("end-line"), int(4465), lang.NewKeyword("end-column"), int(46)) +v239, err := lang.WithMeta(v237, v238.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v240 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v241 := v240.FindInternedVar(lang.NewSymbol("keys")) +if v241.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v241))) +} +v242 := v241.Get() +v243 := lang.Apply(v242, []any{v22}) +v244 := lang.Apply(v233, []any{v236, v239, v243}) +var v230 any = v244 +_ = v230 +v246 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v247 := v246.FindInternedVar(lang.NewSymbol("reduce1")) +if v247.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v247))) +} +v248 := v247.Get() +var v249 lang.FnFunc +v249 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v250 := args[0] +v251 := args[1] +v252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v253 := v252.FindInternedVar(lang.NewSymbol("reduce1")) +if v253.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v253))) +} +v254 := v253.Get() +var v255 lang.FnFunc +v255 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v256 := args[0] +v257 := args[1] +v258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v259 := v258.FindInternedVar(lang.NewSymbol("assoc")) +if v259.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v259))) +} +v260 := v259.Get() +v261 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v262 := v261.FindInternedVar(lang.NewSymbol("val")) +if v262.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v262))) +} +v263 := v262.Get() +v264 := lang.Apply(v263, []any{v251}) +v265 := lang.Apply(v264, []any{v257}) +v266 := lang.Apply(v260, []any{v256, v257, v265}) +return v266 +}) +v256 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4469), lang.NewKeyword("column"), int(52), lang.NewKeyword("end-line"), int(4469), lang.NewKeyword("end-column"), int(82)) +v257, err := lang.WithMeta(v255, v256.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v259 := v258.FindInternedVar(lang.NewSymbol("dissoc")) +if v259.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v259))) +} +v260 := v259.Get() +v261 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v262 := v261.FindInternedVar(lang.NewSymbol("key")) +if v262.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v262))) +} +v263 := v262.Get() +v264 := lang.Apply(v263, []any{v251}) +v265 := lang.Apply(v260, []any{v250, v264}) +v266 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v267 := v266.FindInternedVar(lang.NewSymbol("key")) +if v267.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v267))) +} +v268 := v267.Get() +v269 := lang.Apply(v268, []any{v251}) +v270 := lang.Apply(v269, []any{v250}) +v271 := lang.Apply(v254, []any{v257, v265, v270}) +return v271 +}) +v250 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4468), lang.NewKeyword("column"), int(41), lang.NewKeyword("end-line"), int(4471), lang.NewKeyword("end-column"), int(70)) +v251, err := lang.WithMeta(v249, v250.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v253 := v252.FindInternedVar(lang.NewSymbol("dissoc")) +if v253.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v253))) +} +v254 := v253.Get() +v255 := lang.Apply(v254, []any{v22, lang.NewKeyword("as"), lang.NewKeyword("or")}) +v256 := lang.Apply(v248, []any{v251, v255, v230}) +var v229 any = v256 +_ = v229 +var v230 any +for { +var v231 any +v232 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v233 := v232.FindInternedVar(lang.NewSymbol("seq")) +if v233.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v233))) +} +v234 := v233.Get() +v235 := lang.Apply(v234, []any{v229}) +if lang.IsTruthy(v235) { +v237 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v238 := v237.FindInternedVar(lang.NewSymbol("key")) +if v238.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v238))) +} +v239 := v238.Get() +v240 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v241 := v240.FindInternedVar(lang.NewSymbol("first")) +if v241.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v241))) +} +v242 := v241.Get() +v243 := lang.Apply(v242, []any{v229}) +v244 := lang.Apply(v239, []any{v243}) +var v236 any = v244 +_ = v236 +v246 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v247 := v246.FindInternedVar(lang.NewSymbol("val")) +if v247.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v247))) +} +v248 := v247.Get() +v249 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v250 := v249.FindInternedVar(lang.NewSymbol("first")) +if v250.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v250))) +} +v251 := v250.Get() +v252 := lang.Apply(v251, []any{v229}) +v253 := lang.Apply(v248, []any{v252}) +var v245 any = v253 +_ = v245 +var v255 any +v256 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v257 := v256.FindInternedVar(lang.NewSymbol("instance?")) +if v257.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v257))) +} +v258 := v257.Get() +v259 := lang.Apply(v258, []any{lang1.Named, v236}) +if lang.IsTruthy(v259) { +v260 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v261 := v260.FindInternedVar(lang.NewSymbol("with-meta")) +if v261.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v261))) +} +v262 := v261.Get() +v263 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v264 := v263.FindInternedVar(lang.NewSymbol("symbol")) +if v264.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v264))) +} +v265 := v264.Get() +v266 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v267 := v266.FindInternedVar(lang.NewSymbol("name")) +if v267.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v267))) +} +v268 := v267.Get() +v269 := lang.Apply(v268, []any{v236}) +v270 := lang.Apply(v265, []any{nil, v269}) +v271 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v272 := v271.FindInternedVar(lang.NewSymbol("meta")) +if v272.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v272))) +} +v273 := v272.Get() +v274 := lang.Apply(v273, []any{v236}) +v275 := lang.Apply(v262, []any{v270, v274}) +v255 = v275 +} else { +v255 = v236 +} +var v254 any = v255 +_ = v254 +var v277 any +v278 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v279 := v278.FindInternedVar(lang.NewSymbol("contains?")) +if v279.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v279))) +} +v280 := v279.Get() +v281 := lang.Apply(v280, []any{v37, v254}) +if lang.IsTruthy(v281) { +v282 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v283 := v282.FindInternedVar(lang.NewSymbol("list")) +if v283.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v283))) +} +v284 := v283.Get() +v285 := lang.Apply(v37, []any{v254}) +v286 := lang.Apply(v284, []any{lang.NewSymbol("glojure.core/get"), v24, v245, v285}) +v277 = v286 +} else { +v287 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v288 := v287.FindInternedVar(lang.NewSymbol("list")) +if v288.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v288))) +} +v289 := v288.Get() +v290 := lang.Apply(v289, []any{lang.NewSymbol("glojure.core/get"), v24, v245}) +v277 = v290 +} +var v276 any = v277 +_ = v276 +var v293 any +v294 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v295 := v294.FindInternedVar(lang.NewSymbol("ident?")) +if v295.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v295))) +} +v296 := v295.Get() +v297 := lang.Apply(v296, []any{v236}) +if lang.IsTruthy(v297) { +v298 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v299 := v298.FindInternedVar(lang.NewSymbol("conj")) +if v299.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v299))) +} +v300 := v299.Get() +v301 := lang.Apply(v300, []any{v40, v254, v276}) +v293 = v301 +} else { +v302 := lang.Apply(v11, []any{v40, v236, v276}) +v293 = v302 +} +var v292 any = v293 +v304 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v305 := v304.FindInternedVar(lang.NewSymbol("next")) +if v305.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v305))) +} +v306 := v305.Get() +v307 := lang.Apply(v306, []any{v229}) +var v303 any = v307 +v40 = v292 +v229 = v303 +continue +} else { +v231 = v40 +} +v230 = v231 + break +} +return v230 +}) +v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4440), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(4485), lang.NewKeyword("end-column"), int(34)) +v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v19 any = v22 +_ = v19 +var v24 any +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("symbol?")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.Apply(v27, []any{v13}) +if lang.IsTruthy(v28) { +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("conj")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("conj")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v12, v13}) +v36 := lang.Apply(v31, []any{v35, v14}) +v24 = v36 +} else { +var v37 any +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("vector?")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.Apply(v40, []any{v13}) +if lang.IsTruthy(v41) { +v42 := lang.Apply(v15, []any{v12, v13, v14}) +v37 = v42 +} else { +var v43 any +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("map?")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v13}) +if lang.IsTruthy(v47) { +v48 := lang.Apply(v19, []any{v12, v13, v14}) +v43 = v48 +} else { +var v49 any +if lang.IsTruthy(lang.NewKeyword("else")) { +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("str")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +} +v52 := v51.Get() +v53 := lang.Apply(v52, []any{"Unsupported binding form: ", v13}) +v54 := lang.Apply(errors10.New, []any{v53}) +panic(v54) +} else { +v49 = nil +} +v43 = v49 +} +v37 = v43 +} +v24 = v37 +} +return v24 +}) +v11 := v10 +_ = v11 +} +v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4402), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(4490), lang.NewKeyword("end-column"), int(82)) +v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v9 any = v12 +_ = v9 +var v14 lang.FnFunc +v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v15 := args[0] +v16 := args[1] +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("first")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v16}) +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("second")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v16}) +v25 := lang.Apply(v9, []any{v15, v20, v24}) +return v25 +}) +v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4491), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(4491), lang.NewKeyword("end-column"), int(66)) +v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v13 any = v16 +_ = v13 +var v18 any +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("every?")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("symbol?")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("map")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("first")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v27, []any{v30, v4}) +v32 := lang.Apply(v21, []any{v24, v31}) +if lang.IsTruthy(v32) { +v18 = v3 +} else { +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("reduce1")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.NewVector() +v37 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4494), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(4494), lang.NewKeyword("end-column"), int(31)) +v38, err := lang.WithMeta(v36, v37.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v39 := lang.Apply(v35, []any{v13, v38, v4}) +v18 = v39 +} +return v18 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// loaded-libs +{ +v0 := lang.NewSymbol("loaded-libs").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Returns a sorted set of symbols naming the currently loaded libs", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6133), lang.NewKeyword("end-line"), int(6133))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v4 := v3.FindInternedVar(lang.NewSymbol("deref")) +if v4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) +} +v5 := v4.Get() +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("*loaded-libs*")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v5, []any{v8}) +return v9 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// load-reader +{ +v0 := lang.NewSymbol("load-reader").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rdr"))), lang.NewKeyword("doc"), "Sequentially read and evaluate the set of forms contained in the\n stream/file", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4081), lang.NewKeyword("end-line"), int(4081))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, _ := lang.FieldOrMethod(runtime3.Compiler, "load") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("load is not a function"))) +} +v5 := lang.Apply(v4, []any{v3}) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// defmulti +{ +v0 := lang.NewSymbol("defmulti").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("docstring?"), lang.NewSymbol("attr-map?"), lang.NewSymbol("dispatch-fn"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Creates a new multimethod with the associated dispatch function.\n The docstring and attr-map are optional.\n\n Options are key-value pairs and may be one of:\n\n :default\n\n The default dispatch value, defaults to :default\n\n :hierarchy\n\n The value used for hierarchical dispatch (e.g. ::square is-a ::shape)\n\n Hierarchies are type-like relationships that do not depend upon type\n inheritance. By default Clojure's multimethods dispatch off of a\n global hierarchy map. However, a hierarchy relationship can be\n created with the derive function used to augment the root ancestor\n created with make-hierarchy.\n\n Multimethods expect the value of the hierarchy option to be supplied as\n a reference type e.g. a var (i.e. via the Var-quote dispatch macro #'\n or the var special form).", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1723), lang.NewKeyword("end-line"), int(1723))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +var v8 any +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("string?")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("first")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v6}) +v16 := lang.Apply(v11, []any{v15}) +if lang.IsTruthy(v16) { +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("first")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v6}) +v8 = v20 +} else { +v8 = nil +} +var v7 any = v8 +_ = v7 +var v22 any +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("string?")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("first")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.Apply(v28, []any{v21}) +v30 := lang.Apply(v25, []any{v29}) +if lang.IsTruthy(v30) { +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("next")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v21}) +v22 = v34 +} else { +v22 = v21 +} +var v21 any = v22 +_ = v21 +var v36 any +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("map?")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("first")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v21}) +v44 := lang.Apply(v39, []any{v43}) +if lang.IsTruthy(v44) { +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("first")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +} +v47 := v46.Get() +v48 := lang.Apply(v47, []any{v21}) +v36 = v48 +} else { +v49 := lang.NewMap() +v50 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1757), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(1757), lang.NewKeyword("end-column"), int(24)) +v51, err := lang.WithMeta(v49, v50.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v36 = v51 +} +var v35 any = v36 +_ = v35 +var v53 any +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("map?")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +} +v56 := v55.Get() +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("first")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +} +v59 := v58.Get() +v60 := lang.Apply(v59, []any{v52}) +v61 := lang.Apply(v56, []any{v60}) +if lang.IsTruthy(v61) { +v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v63 := v62.FindInternedVar(lang.NewSymbol("next")) +if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +} +v64 := v63.Get() +v65 := lang.Apply(v64, []any{v52}) +v53 = v65 +} else { +v53 = v52 +} +var v52 any = v53 +_ = v52 +v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v68 := v67.FindInternedVar(lang.NewSymbol("first")) +if v68.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) +} +v69 := v68.Get() +v70 := lang.Apply(v69, []any{v52}) +var v66 any = v70 +_ = v66 +v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v73 := v72.FindInternedVar(lang.NewSymbol("next")) +if v73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) +} +v74 := v73.Get() +v75 := lang.Apply(v74, []any{v71}) +var v71 any = v75 +_ = v71 +var v77 any +if lang.IsTruthy(v7) { +v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v79 := v78.FindInternedVar(lang.NewSymbol("assoc")) +if v79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) +} +v80 := v79.Get() +v81 := lang.Apply(v80, []any{v76, lang.NewKeyword("doc"), v7}) +v77 = v81 +} else { +v77 = v76 +} +var v76 any = v77 +_ = v76 +var v83 any +v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v85 := v84.FindInternedVar(lang.NewSymbol("meta")) +if v85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) +} +v86 := v85.Get() +v87 := lang.Apply(v86, []any{v5}) +if lang.IsTruthy(v87) { +v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v89 := v88.FindInternedVar(lang.NewSymbol("conj")) +if v89.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) +} +v90 := v89.Get() +v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v92 := v91.FindInternedVar(lang.NewSymbol("meta")) +if v92.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) +} +v93 := v92.Get() +v94 := lang.Apply(v93, []any{v5}) +v95 := lang.Apply(v90, []any{v94, v82}) +v83 = v95 +} else { +v83 = v82 +} +var v82 any = v83 +_ = v82 +v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v98 := v97.FindInternedVar(lang.NewSymbol("with-meta")) +if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) +} +v99 := v98.Get() +v100 := lang.Apply(v99, []any{v96, v82}) +var v96 any = v100 +_ = v96 +var v102 any +v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v104 := v103.FindInternedVar(lang.NewSymbol("=")) +if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) +} +v105 := v104.Get() +v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v107 := v106.FindInternedVar(lang.NewSymbol("count")) +if v107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) +} +v108 := v107.Get() +v109 := lang.Apply(v108, []any{v71}) +v110 := lang.Apply(v105, []any{v109, int64(1)}) +if lang.IsTruthy(v110) { +v111 := lang.Apply(Exception25., []any{"The syntax for defmulti has changed. Example: (defmulti name dispatch-fn :default dispatch-value)"}) +panic(v111) +} else { +v102 = nil +} +_ = v102 +v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v114 := v113.FindInternedVar(lang.NewSymbol("apply")) +if v114.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) +} +v115 := v114.Get() +v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v117 := v116.FindInternedVar(lang.NewSymbol("hash-map")) +if v117.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) +} +v118 := v117.Get() +v119 := lang.Apply(v115, []any{v118, v112}) +var v112 any = v119 +_ = v112 +v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v122 := v121.FindInternedVar(lang.NewSymbol("get")) +if v122.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) +} +v123 := v122.Get() +v124 := lang.Apply(v123, []any{v112, lang.NewKeyword("default"), lang.NewKeyword("default")}) +var v120 any = v124 +_ = v120 +v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v127 := v126.FindInternedVar(lang.NewSymbol("get")) +if v127.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) +} +v128 := v127.Get() +v129 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("global-hierarchy")) +v130 := lang.Apply(v128, []any{v112, lang.NewKeyword("hierarchy"), v129}) +var v125 any = v130 +_ = v125 +v132 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v133 := v132.FindInternedVar(lang.NewSymbol("check-valid-options")) +if v133.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v133))) +} +v134 := v133.Get() +v135 := lang.Apply(v134, []any{v112, lang.NewKeyword("default"), lang.NewKeyword("hierarchy")}) +_ = v135 +v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v137 := v136.FindInternedVar(lang.NewSymbol("seq")) +if v137.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) +} +v138 := v137.Get() +v139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v140 := v139.FindInternedVar(lang.NewSymbol("concat")) +if v140.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v140))) +} +v141 := v140.Get() +v142 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v143 := v142.FindInternedVar(lang.NewSymbol("list")) +if v143.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v143))) +} +v144 := v143.Get() +v145 := lang.Apply(v144, []any{lang.NewSymbol("glojure.core/let")}) +v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v147 := v146.FindInternedVar(lang.NewSymbol("list")) +if v147.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) +} +v148 := v147.Get() +v149 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v150 := v149.FindInternedVar(lang.NewSymbol("apply")) +if v150.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v150))) +} +v151 := v150.Get() +v152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v153 := v152.FindInternedVar(lang.NewSymbol("vector")) +if v153.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v153))) +} +v154 := v153.Get() +v155 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v156 := v155.FindInternedVar(lang.NewSymbol("seq")) +if v156.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v156))) +} +v157 := v156.Get() +v158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v159 := v158.FindInternedVar(lang.NewSymbol("concat")) +if v159.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v159))) +} +v160 := v159.Get() +v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v162 := v161.FindInternedVar(lang.NewSymbol("list")) +if v162.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) +} +v163 := v162.Get() +v164 := lang.Apply(v163, []any{lang.NewSymbol("v__0__auto__")}) +v165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v166 := v165.FindInternedVar(lang.NewSymbol("list")) +if v166.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v166))) +} +v167 := v166.Get() +v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v169 := v168.FindInternedVar(lang.NewSymbol("seq")) +if v169.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) +} +v170 := v169.Get() +v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v172 := v171.FindInternedVar(lang.NewSymbol("concat")) +if v172.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) +} +v173 := v172.Get() +v174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v175 := v174.FindInternedVar(lang.NewSymbol("list")) +if v175.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v175))) +} +v176 := v175.Get() +v177 := lang.Apply(v176, []any{lang.NewSymbol("def")}) +v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v179 := v178.FindInternedVar(lang.NewSymbol("list")) +if v179.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) +} +v180 := v179.Get() +v181 := lang.Apply(v180, []any{v96}) +v182 := lang.Apply(v173, []any{v177, v181}) +v183 := lang.Apply(v170, []any{v182}) +v184 := lang.Apply(v167, []any{v183}) +v185 := lang.Apply(v160, []any{v164, v184}) +v186 := lang.Apply(v157, []any{v185}) +v187 := lang.Apply(v151, []any{v154, v186}) +v188 := lang.Apply(v148, []any{v187}) +v189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v190 := v189.FindInternedVar(lang.NewSymbol("list")) +if v190.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v190))) +} +v191 := v190.Get() +v192 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v193 := v192.FindInternedVar(lang.NewSymbol("seq")) +if v193.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v193))) +} +v194 := v193.Get() +v195 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v196 := v195.FindInternedVar(lang.NewSymbol("concat")) +if v196.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v196))) +} +v197 := v196.Get() +v198 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v199 := v198.FindInternedVar(lang.NewSymbol("list")) +if v199.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v199))) +} +v200 := v199.Get() +v201 := lang.Apply(v200, []any{lang.NewSymbol("glojure.core/when-not")}) +v202 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v203 := v202.FindInternedVar(lang.NewSymbol("list")) +if v203.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v203))) +} +v204 := v203.Get() +v205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v206 := v205.FindInternedVar(lang.NewSymbol("seq")) +if v206.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v206))) +} +v207 := v206.Get() +v208 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v209 := v208.FindInternedVar(lang.NewSymbol("concat")) +if v209.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v209))) +} +v210 := v209.Get() +v211 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v212 := v211.FindInternedVar(lang.NewSymbol("list")) +if v212.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v212))) +} +v213 := v212.Get() +v214 := lang.Apply(v213, []any{lang.NewSymbol("glojure.core/and")}) +v215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v216 := v215.FindInternedVar(lang.NewSymbol("list")) +if v216.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v216))) +} +v217 := v216.Get() +v218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v219 := v218.FindInternedVar(lang.NewSymbol("seq")) +if v219.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v219))) +} +v220 := v219.Get() +v221 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v222 := v221.FindInternedVar(lang.NewSymbol("concat")) +if v222.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v222))) +} +v223 := v222.Get() +v224 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v225 := v224.FindInternedVar(lang.NewSymbol("list")) +if v225.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v225))) +} +v226 := v225.Get() +v227 := lang.Apply(v226, []any{lang.NewSymbol(".HasRoot")}) +v228 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v229 := v228.FindInternedVar(lang.NewSymbol("list")) +if v229.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v229))) +} +v230 := v229.Get() +v231 := lang.Apply(v230, []any{lang.NewSymbol("v__0__auto__")}) +v232 := lang.Apply(v223, []any{v227, v231}) +v233 := lang.Apply(v220, []any{v232}) +v234 := lang.Apply(v217, []any{v233}) +v235 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v236 := v235.FindInternedVar(lang.NewSymbol("list")) +if v236.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v236))) +} +v237 := v236.Get() +v238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v239 := v238.FindInternedVar(lang.NewSymbol("seq")) +if v239.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v239))) +} +v240 := v239.Get() +v241 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v242 := v241.FindInternedVar(lang.NewSymbol("concat")) +if v242.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v242))) +} +v243 := v242.Get() +v244 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v245 := v244.FindInternedVar(lang.NewSymbol("list")) +if v245.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v245))) +} +v246 := v245.Get() +v247 := lang.Apply(v246, []any{lang.NewSymbol("glojure.core/instance?")}) +v248 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v249 := v248.FindInternedVar(lang.NewSymbol("list")) +if v249.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v249))) +} +v250 := v249.Get() +v251 := lang.Apply(v250, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.*MultiFn")}) +v252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v253 := v252.FindInternedVar(lang.NewSymbol("list")) +if v253.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v253))) +} +v254 := v253.Get() +v255 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v256 := v255.FindInternedVar(lang.NewSymbol("seq")) +if v256.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v256))) +} +v257 := v256.Get() +v258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v259 := v258.FindInternedVar(lang.NewSymbol("concat")) +if v259.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v259))) +} +v260 := v259.Get() +v261 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v262 := v261.FindInternedVar(lang.NewSymbol("list")) +if v262.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v262))) +} +v263 := v262.Get() +v264 := lang.Apply(v263, []any{lang.NewSymbol("glojure.core/deref")}) +v265 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v266 := v265.FindInternedVar(lang.NewSymbol("list")) +if v266.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v266))) +} +v267 := v266.Get() +v268 := lang.Apply(v267, []any{lang.NewSymbol("v__0__auto__")}) +v269 := lang.Apply(v260, []any{v264, v268}) +v270 := lang.Apply(v257, []any{v269}) +v271 := lang.Apply(v254, []any{v270}) +v272 := lang.Apply(v243, []any{v247, v251, v271}) +v273 := lang.Apply(v240, []any{v272}) +v274 := lang.Apply(v237, []any{v273}) +v275 := lang.Apply(v210, []any{v214, v234, v274}) +v276 := lang.Apply(v207, []any{v275}) +v277 := lang.Apply(v204, []any{v276}) +v278 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v279 := v278.FindInternedVar(lang.NewSymbol("list")) +if v279.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v279))) +} +v280 := v279.Get() +v281 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v282 := v281.FindInternedVar(lang.NewSymbol("seq")) +if v282.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v282))) +} +v283 := v282.Get() +v284 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v285 := v284.FindInternedVar(lang.NewSymbol("concat")) +if v285.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v285))) +} +v286 := v285.Get() +v287 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v288 := v287.FindInternedVar(lang.NewSymbol("list")) +if v288.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v288))) +} +v289 := v288.Get() +v290 := lang.Apply(v289, []any{lang.NewSymbol("def")}) +v291 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v292 := v291.FindInternedVar(lang.NewSymbol("list")) +if v292.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v292))) +} +v293 := v292.Get() +v294 := lang.Apply(v293, []any{v96}) +v295 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v296 := v295.FindInternedVar(lang.NewSymbol("list")) +if v296.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v296))) +} +v297 := v296.Get() +v298 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v299 := v298.FindInternedVar(lang.NewSymbol("seq")) +if v299.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v299))) +} +v300 := v299.Get() +v301 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v302 := v301.FindInternedVar(lang.NewSymbol("concat")) +if v302.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v302))) +} +v303 := v302.Get() +v304 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v305 := v304.FindInternedVar(lang.NewSymbol("list")) +if v305.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v305))) +} +v306 := v305.Get() +v307 := lang.Apply(v306, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewMultiFn")}) +v308 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v309 := v308.FindInternedVar(lang.NewSymbol("list")) +if v309.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v309))) +} +v310 := v309.Get() +v311 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v312 := v311.FindInternedVar(lang.NewSymbol("name")) +if v312.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v312))) +} +v313 := v312.Get() +v314 := lang.Apply(v313, []any{v96}) +v315 := lang.Apply(v310, []any{v314}) +v316 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v317 := v316.FindInternedVar(lang.NewSymbol("list")) +if v317.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v317))) +} +v318 := v317.Get() +v319 := lang.Apply(v318, []any{v66}) +v320 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v321 := v320.FindInternedVar(lang.NewSymbol("list")) +if v321.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v321))) +} +v322 := v321.Get() +v323 := lang.Apply(v322, []any{v120}) +v324 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v325 := v324.FindInternedVar(lang.NewSymbol("list")) +if v325.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v325))) +} +v326 := v325.Get() +v327 := lang.Apply(v326, []any{v125}) +v328 := lang.Apply(v303, []any{v307, v315, v319, v323, v327}) +v329 := lang.Apply(v300, []any{v328}) +v330 := lang.Apply(v297, []any{v329}) +v331 := lang.Apply(v286, []any{v290, v294, v330}) +v332 := lang.Apply(v283, []any{v331}) +v333 := lang.Apply(v280, []any{v332}) +v334 := lang.Apply(v197, []any{v201, v277, v333}) +v335 := lang.Apply(v194, []any{v334}) +v336 := lang.Apply(v191, []any{v335}) +v337 := lang.Apply(v141, []any{v145, v188, v336}) +v338 := lang.Apply(v138, []any{v337}) +return v338 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// preserving-reduced +{ +v0 := lang.NewSymbol("preserving-reduced").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7681), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(7681), lang.NewKeyword("end-column"), int(34), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rf"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +v6 := args[1] +v8 := lang.Apply(v3, []any{v5, v6}) +var v7 any = v8 +_ = v7 +var v10 any +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("reduced?")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v7}) +if lang.IsTruthy(v14) { +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("reduced")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v7}) +v10 = v18 +} else { +v10 = v7 +} +return v10 +}) +v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7683), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(7686), lang.NewKeyword("end-column"), int(12)) +v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v6 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// ns-map +{ +v0 := lang.NewSymbol("ns-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of all the mappings for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4170), lang.NewKeyword("end-line"), int(4170))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("the-ns")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{v3}) +v8, ok := lang.FieldOrMethod(v7, "Mappings") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "Mappings"))) +} +var v9 any +switch reflect.TypeOf(v8).Kind() { +case reflect.Func: + v9 = lang.Apply(v8, nil) +default: + v9 = v8 +} +return v9 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// compare +{ +var v1 lang.FnFunc +{ // function compare__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("concat")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("list")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol("glojure.lang.Util")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{lang.NewSymbol("glojure.core/compare")}) +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{v3}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{v4}) +v31 := lang.Apply(v10, []any{v14, v18, v22, v26, v30}) +v32 := lang.Apply(v7, []any{v31}) +return v32 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("compare").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Comparator. Returns a negative number, zero, or a positive number\n when x is logically 'less than', 'equal to', or 'greater than'\n y. Same as Java x.compareTo(y) except it also works for nil, and\n compares numbers and collections in a type-independent manner. x\n must implement Comparable", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(824), lang.NewKeyword("end-line"), int(824))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := args[1] +v6 := lang.Apply(lang1.Compare, []any{v4, v5}) +return v6 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// spread +{ +v0 := lang.NewSymbol("spread").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("arglist"))), lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(632), lang.NewKeyword("end-line"), int(632), lang.NewKeyword("private"), true)).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("nil?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +if lang.IsTruthy(v8) { +v4 = nil +} else { +var v9 any +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("nil?")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("next")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v3}) +v17 := lang.Apply(v12, []any{v16}) +if lang.IsTruthy(v17) { +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("seq")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("first")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v3}) +v25 := lang.Apply(v20, []any{v24}) +v9 = v25 +} else { +var v26 any +if lang.IsTruthy(lang.NewKeyword("else")) { +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("cons")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("first")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.Apply(v32, []any{v3}) +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("spread")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("next")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v3}) +v41 := lang.Apply(v36, []any{v40}) +v42 := lang.Apply(v29, []any{v33, v41}) +v26 = v42 +} else { +v26 = nil +} +v9 = v26 +} +v4 = v9 +} +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// future-done? +{ +v0 := lang.NewSymbol("future-done?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Returns true if future f is done", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6581), lang.NewKeyword("end-line"), int(6581))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, ok := lang.FieldOrMethod(v3, "isDone") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "isDone"))) +} +var v5 any +switch reflect.TypeOf(v4).Kind() { +case reflect.Func: + v5 = lang.Apply(v4, nil) +default: + v5 = v4 +} +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// inst-ms +{ +v0 := lang.NewSymbol("inst-ms").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("inst"))), lang.NewKeyword("doc"), "Return the number of milliseconds since January 1, 1970, 00:00:00 GMT", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6874), lang.NewKeyword("end-line"), int(6874))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.Apply(nil, []any{v3}) +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// add-annotation +{ +v0 := lang.NewSymbol("add-annotation").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5485), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(5485), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("av"), lang.NewSymbol("name"), lang.NewSymbol("v"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +var v6 any +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("vector?")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v5}) +if lang.IsTruthy(v10) { +v12, _ := lang.FieldOrMethod(v3, "visitArray") +if reflect.TypeOf(v12).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("visitArray is not a function"))) +} +v13 := lang.Apply(v12, []any{v4}) +var v11 any = v13 +_ = v11 +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("seq")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v5}) +var v15 any = v19 +_ = v15 +var v20 any = nil +_ = v20 +var v21 any = int64(0) +_ = v21 +var v22 any = int64(0) +_ = v22 +var v23 any +for { +var v24 any +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("<")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.Apply(v27, []any{v22, v21}) +if lang.IsTruthy(v28) { +v30, _ := lang.FieldOrMethod(v20, "nth") +if reflect.TypeOf(v30).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) +} +v31 := lang.Apply(v30, []any{v22}) +var v29 any = v31 +_ = v29 +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("add-annotation")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v11, "value", v29}) +_ = v36 +var v37 any = v15 +var v38 any = v20 +var v39 any = v21 +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("unchecked-inc")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v22}) +var v40 any = v44 +v15 = v37 +v20 = v38 +v21 = v39 +v22 = v40 +continue +} else { +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("seq")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.Apply(v32, []any{v15}) +var v29 any = v33 +_ = v29 +var v35 any +if lang.IsTruthy(v29) { +var v36 any = v29 +_ = v36 +var v38 any +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("chunked-seq?")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +} +v41 := v40.Get() +v42 := lang.Apply(v41, []any{v36}) +if lang.IsTruthy(v42) { +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("chunk-first")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v36}) +var v43 any = v47 +_ = v43 +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("chunk-rest")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +} +v52 := v51.Get() +v53 := lang.Apply(v52, []any{v36}) +var v49 any = v53 +var v54 any = v43 +v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v57 := v56.FindInternedVar(lang.NewSymbol("int")) +if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) +} +v58 := v57.Get() +v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v60 := v59.FindInternedVar(lang.NewSymbol("count")) +if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) +} +v61 := v60.Get() +v62 := lang.Apply(v61, []any{v43}) +v63 := lang.Apply(v58, []any{v62}) +var v55 any = v63 +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("int")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +} +v67 := v66.Get() +v68 := lang.Apply(v67, []any{int64(0)}) +var v64 any = v68 +v15 = v49 +v20 = v54 +v21 = v55 +v22 = v64 +continue +} else { +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("first")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v36}) +var v43 any = v47 +_ = v43 +v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v50 := v49.FindInternedVar(lang.NewSymbol("add-annotation")) +if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) +} +v51 := v50.Get() +v52 := lang.Apply(v51, []any{v11, "value", v43}) +_ = v52 +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("next")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +} +v56 := v55.Get() +v57 := lang.Apply(v56, []any{v36}) +var v53 any = v57 +var v58 any = nil +var v59 any = int64(0) +var v60 any = int64(0) +v15 = v53 +v20 = v58 +v21 = v59 +v22 = v60 +continue +} +v35 = v38 +} else { +v35 = nil +} +v24 = v35 +} +v23 = v24 + break +} +_ = v23 +v15, ok := lang.FieldOrMethod(v11, "visitEnd") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v11, "visitEnd"))) +} +var v16 any +switch reflect.TypeOf(v15).Kind() { +case reflect.Func: + v16 = lang.Apply(v15, nil) +default: + v16 = v15 +} +v6 = v16 +} else { +var v11 any +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("symbol?")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v5}) +if lang.IsTruthy(v15) { +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("eval")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v5}) +var v16 any = v20 +_ = v16 +var v22 any +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("instance?")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{java.lang35.Enum, v16}) +if lang.IsTruthy(v26) { +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("descriptor")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("class")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.Apply(v32, []any{v16}) +v34 := lang.Apply(v29, []any{v33}) +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("str")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v37, []any{v16}) +v39, _ := lang.FieldOrMethod(v3, "visitEnum") +if reflect.TypeOf(v39).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("visitEnum is not a function"))) +} +v40 := lang.Apply(v39, []any{v4, v34, v38}) +v22 = v40 +} else { +var v41 any +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("class?")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +} +v44 := v43.Get() +v45 := lang.Apply(v44, []any{v16}) +if lang.IsTruthy(v45) { +v46 := lang.Apply(nil, []any{v16}) +v47, _ := lang.FieldOrMethod(v3, "visit") +if reflect.TypeOf(v47).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("visit is not a function"))) +} +v48 := lang.Apply(v47, []any{v4, v46}) +v41 = v48 +} else { +var v49 any +if lang.IsTruthy(lang.NewKeyword("else")) { +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("str")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +} +v52 := v51.Get() +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("class")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +} +v55 := v54.Get() +v56 := lang.Apply(v55, []any{v16}) +v57 := lang.Apply(v52, []any{"Unsupported annotation value: ", v5, " of class ", v56}) +v58 := lang.Apply(lang1.NewIllegalArgumentError, []any{v57}) +panic(v58) +} else { +v49 = nil +} +v41 = v49 +} +v22 = v41 +} +v11 = v22 +} else { +var v16 any +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq?")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v5}) +if lang.IsTruthy(v20) { +var v21 any = v5 +_ = v21 +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("nth")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{v21, int64(0), nil}) +var v22 any = v26 +_ = v22 +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("nth")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{v21, int64(1), nil}) +var v27 any = v31 +_ = v27 +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("resolve")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v22}) +var v32 any = v36 +_ = v32 +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("descriptor")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.Apply(v40, []any{v32}) +v42, _ := lang.FieldOrMethod(v3, "visitAnnotation") +if reflect.TypeOf(v42).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("visitAnnotation is not a function"))) +} +v43 := lang.Apply(v42, []any{v4, v41}) +var v37 any = v43 +_ = v37 +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("process-annotation")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +} +v47 := v46.Get() +v48 := lang.Apply(v47, []any{v37, v27}) +_ = v48 +v49, ok := lang.FieldOrMethod(v37, "visitEnd") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v37, "visitEnd"))) +} +var v50 any +switch reflect.TypeOf(v49).Kind() { +case reflect.Func: + v50 = lang.Apply(v49, nil) +default: + v50 = v49 +} +v16 = v50 +} else { +var v21 any +if lang.IsTruthy(lang.NewKeyword("else")) { +v22, _ := lang.FieldOrMethod(v3, "visit") +if reflect.TypeOf(v22).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("visit is not a function"))) +} +v23 := lang.Apply(v22, []any{v4, v5}) +v21 = v23 +} else { +v21 = nil +} +v16 = v21 +} +v11 = v16 +} +v6 = v11 +} +return v6 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// accessor +{ +v0 := lang.NewSymbol("accessor").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("key"))), lang.NewKeyword("doc"), "Returns a fn that, given an instance of a structmap with the basis,\n returns the value at the key. The key must be in the basis. The\n returned function should be (slightly) more efficient than using\n get, but such use of accessors should be limited to known\n performance-critical areas.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4070), lang.NewKeyword("end-line"), int(4070))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5, _ := lang.FieldOrMethod(glojure.lang11.PersistentStructMap, "getAccessor") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getAccessor is not a function"))) +} +v6 := lang.Apply(v5, []any{v3, v4}) +return v6 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// agent-errors +{ +v0 := lang.NewSymbol("agent-errors").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("doc"), "DEPRECATED: Use 'agent-error' instead.\n Returns a sequence of the exceptions thrown during asynchronous\n actions of the agent.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("deprecated"), "1.2", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2234), lang.NewKeyword("end-line"), int(2234))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("agent-error")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +var v4 any = v8 +_ = v4 +var v10 any +if lang.IsTruthy(v4) { +var v11 any = v4 +_ = v11 +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("list")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v11}) +v10 = v16 +} else { +v10 = nil +} +return v10 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// emit-hinted-impl +{ +v0 := lang.NewSymbol("emit-hinted-impl").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(163), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(163), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"), lang.NewVector(lang.NewSymbol("p"), lang.NewSymbol("fs")))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +var v5 any = v4 +_ = v5 +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("nth")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v5, int64(0), nil}) +var v6 any = v10 +_ = v6 +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("nth")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v5, int64(1), nil}) +var v11 any = v15 +_ = v11 +var v18 lang.FnFunc +v18 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v19 := args[0] +var v21 any +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("vector?")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("first")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.Apply(v27, []any{v20}) +v29 := lang.Apply(v24, []any{v28}) +if lang.IsTruthy(v29) { +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("list")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.Apply(v32, []any{v20}) +v21 = v33 +} else { +v21 = v20 +} +var v20 any = v21 +_ = v20 +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("map")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +var v38 lang.FnFunc +v38 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v39 := args[0] +var v40 any = v39 +_ = v40 +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("seq")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +} +v44 := v43.Get() +v45 := lang.Apply(v44, []any{v40}) +var v41 any = v45 +_ = v41 +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("first")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +} +v49 := v48.Get() +v50 := lang.Apply(v49, []any{v41}) +var v46 any = v50 +_ = v46 +v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v53 := v52.FindInternedVar(lang.NewSymbol("next")) +if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) +} +v54 := v53.Get() +v55 := lang.Apply(v54, []any{v51}) +var v51 any = v55 +_ = v51 +var v56 any = v46 +_ = v56 +v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v59 := v58.FindInternedVar(lang.NewSymbol("seq")) +if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) +} +v60 := v59.Get() +v61 := lang.Apply(v60, []any{v56}) +var v57 any = v61 +_ = v57 +v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v64 := v63.FindInternedVar(lang.NewSymbol("first")) +if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) +} +v65 := v64.Get() +v66 := lang.Apply(v65, []any{v57}) +var v62 any = v66 +_ = v62 +v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v69 := v68.FindInternedVar(lang.NewSymbol("next")) +if v69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) +} +v70 := v69.Get() +v71 := lang.Apply(v70, []any{v67}) +var v67 any = v71 +_ = v67 +var v72 any = v62 +_ = v72 +var v73 any = v67 +_ = v73 +var v74 any = v51 +_ = v74 +v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v77 := v76.FindInternedVar(lang.NewSymbol("cons")) +if v77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) +} +v78 := v77.Get() +v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v80 := v79.FindInternedVar(lang.NewSymbol("apply")) +if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) +} +v81 := v80.Get() +v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v83 := v82.FindInternedVar(lang.NewSymbol("vector")) +if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) +} +v84 := v83.Get() +v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v86 := v85.FindInternedVar(lang.NewSymbol("vary-meta")) +if v86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) +} +v87 := v86.Get() +v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v89 := v88.FindInternedVar(lang.NewSymbol("assoc")) +if v89.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) +} +v90 := v89.Get() +v91 := lang.Apply(v87, []any{v72, v90, lang.NewKeyword("tag"), v3}) +v92 := lang.Apply(v81, []any{v84, v91, v73}) +v93 := lang.Apply(v78, []any{v92, v74}) +return v93 +}) +v39 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(168), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(170), lang.NewKeyword("end-column"), int(36)) +v40, err := lang.WithMeta(v38, v39.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v41 := lang.Apply(v37, []any{v40, v20}) +return v41 +}) +v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(164), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(171), lang.NewKeyword("end-column"), int(30)) +v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v17 any = v20 +_ = v17 +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("zipmap")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("map")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +var v28 lang.FnFunc +v28 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v29 := args[0] +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("keyword")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("name")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("first")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v29}) +v40 := lang.Apply(v35, []any{v39}) +v41 := lang.Apply(v32, []any{v40}) +return v41 +}) +v29 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(172), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(172), lang.NewKeyword("end-column"), int(46)) +v30, err := lang.WithMeta(v28, v29.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v31 := lang.Apply(v27, []any{v30, v11}) +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("map")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +var v35 lang.FnFunc +v35 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v36 := args[0] +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("cons")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("drop")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{int64(1), v36}) +v44 := lang.Apply(v17, []any{v43}) +v45 := lang.Apply(v39, []any{lang.NewSymbol("glojure.core/fn"), v44}) +return v45 +}) +v36 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(173), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(173), lang.NewKeyword("end-column"), int(49)) +v37, err := lang.WithMeta(v35, v36.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v38 := lang.Apply(v34, []any{v37, v11}) +v39 := lang.Apply(v24, []any{v31, v38}) +v40 := lang.NewVector(v6, v39) +v41 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(172), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(173), lang.NewKeyword("end-column"), int(55)) +v42, err := lang.WithMeta(v40, v41.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v42 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// rand +{ +v0 := lang.NewSymbol("rand").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns a random floating point number between 0 (inclusive) and\n n (default 1) (exclusive).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4935), lang.NewKeyword("end-line"), int(4935))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v3 := lang.Apply(rand36.Float64, nil) +return v3 + case 1: +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("*")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("rand")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, nil) +v11 := lang.Apply(v6, []any{v3, v10}) +return v11 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// shift-mask +{ +v0 := lang.NewSymbol("shift-mask").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6641), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(6641), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("shift"), lang.NewSymbol("mask"), lang.NewSymbol("x"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("bit-and")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("bit-shift-right")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v5, v3}) +v13 := lang.Apply(v8, []any{v12, v4}) +return v13 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// integer? +{ +v0 := lang.NewSymbol("integer?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is an integer", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1379), lang.NewKeyword("end-line"), int(1379))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.Apply(lang1.IsInteger, []any{v3}) +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// maybe-destructured +{ +v0 := lang.NewSymbol("maybe-destructured").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4514), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(4515), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("params"), lang.NewSymbol("body"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("every?")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("symbol?")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v8, []any{v11, v3}) +if lang.IsTruthy(v12) { +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("cons")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v3, v4}) +v5 = v16 +} else { +var v17 any = v17 +_ = v17 +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("with-meta")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.NewVector() +v23 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4520), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(4520), lang.NewKeyword("end-column"), int(35)) +v24, err := lang.WithMeta(v22, v23.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("meta")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.Apply(v27, []any{v17}) +v29 := lang.Apply(v21, []any{v24, v28}) +var v18 any = v29 +_ = v18 +v31 := lang.NewVector() +v32 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4521), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(4521), lang.NewKeyword("end-column"), int(18)) +v33, err := lang.WithMeta(v31, v32.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v30 any = v33 +_ = v30 +var v34 any +for { +var v35 any +if lang.IsTruthy(v17) { +var v36 any +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("symbol?")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("first")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v17}) +v44 := lang.Apply(v39, []any{v43}) +if lang.IsTruthy(v44) { +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("next")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +} +v48 := v47.Get() +v49 := lang.Apply(v48, []any{v17}) +var v45 any = v49 +v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v52 := v51.FindInternedVar(lang.NewSymbol("conj")) +if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) +} +v53 := v52.Get() +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("first")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +} +v56 := v55.Get() +v57 := lang.Apply(v56, []any{v17}) +v58 := lang.Apply(v53, []any{v18, v57}) +var v50 any = v58 +var v59 any = v30 +v17 = v45 +v18 = v50 +v30 = v59 +continue +} else { +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("gensym")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +} +v63 := v62.Get() +v64 := lang.Apply(v63, []any{"p__"}) +var v60 any = v64 +_ = v60 +v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v68 := v67.FindInternedVar(lang.NewSymbol("next")) +if v68.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) +} +v69 := v68.Get() +v70 := lang.Apply(v69, []any{v17}) +var v66 any = v70 +v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v73 := v72.FindInternedVar(lang.NewSymbol("conj")) +if v73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) +} +v74 := v73.Get() +v75 := lang.Apply(v74, []any{v18, v60}) +var v71 any = v75 +v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v78 := v77.FindInternedVar(lang.NewSymbol("conj")) +if v78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) +} +v79 := v78.Get() +v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v81 := v80.FindInternedVar(lang.NewSymbol("conj")) +if v81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) +} +v82 := v81.Get() +v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v84 := v83.FindInternedVar(lang.NewSymbol("first")) +if v84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) +} +v85 := v84.Get() +v86 := lang.Apply(v85, []any{v17}) +v87 := lang.Apply(v82, []any{v30, v86}) +v88 := lang.Apply(v79, []any{v87, v60}) +var v76 any = v88 +v17 = v66 +v18 = v71 +v30 = v76 +continue +} +v35 = v36 +} else { +v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v61 := v60.FindInternedVar(lang.NewSymbol("seq")) +if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) +} +v62 := v61.Get() +v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v64 := v63.FindInternedVar(lang.NewSymbol("concat")) +if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) +} +v65 := v64.Get() +v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v67 := v66.FindInternedVar(lang.NewSymbol("list")) +if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) +} +v68 := v67.Get() +v69 := lang.Apply(v68, []any{v18}) +v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v71 := v70.FindInternedVar(lang.NewSymbol("list")) +if v71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) +} +v72 := v71.Get() +v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v74 := v73.FindInternedVar(lang.NewSymbol("seq")) +if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) +} +v75 := v74.Get() +v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v77 := v76.FindInternedVar(lang.NewSymbol("concat")) +if v77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) +} +v78 := v77.Get() +v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v80 := v79.FindInternedVar(lang.NewSymbol("list")) +if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) +} +v81 := v80.Get() +v82 := lang.Apply(v81, []any{lang.NewSymbol("glojure.core/let")}) +v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v84 := v83.FindInternedVar(lang.NewSymbol("list")) +if v84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) +} +v85 := v84.Get() +v86 := lang.Apply(v85, []any{v30}) +v87 := lang.Apply(v78, []any{v82, v86, v4}) +v88 := lang.Apply(v75, []any{v87}) +v89 := lang.Apply(v72, []any{v88}) +v90 := lang.Apply(v65, []any{v69, v89}) +v91 := lang.Apply(v62, []any{v90}) +v35 = v91 +} +v34 = v35 + break +} +v5 = v34 +} +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// cast +{ +v0 := lang.NewSymbol("cast").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Throws a ClassCastException if x is not a c, else returns x.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(345), lang.NewKeyword("end-line"), int(345))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5, _ := lang.FieldOrMethod(v3, "cast") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("cast is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// print-method +{ +v0 := lang.NewSymbol("print-method").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3664), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(3664), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, nil, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// dissoc +{ +v0 := lang.NewSymbol("dissoc").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map")), lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"), lang.NewSymbol("&"), lang.NewSymbol("ks"))), lang.NewKeyword("doc"), "dissoc[iate]. Returns a new map of the same (hashed/sorted) type,\n that does not contain a mapping for key(s).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1500), lang.NewKeyword("end-line"), int(1500))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +return v3 + case 2: +v3 := args[0] +v4 := args[1] +v5, _ := lang.FieldOrMethod(runtime3.RT, "Dissoc") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Dissoc is not a function"))) +} +v6 := lang.Apply(v5, []any{v3, v4}) +return v6 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +recur_loop_301: +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("dissoc")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v3, v4}) +var v6 any = v10 +_ = v6 +var v12 any +if lang.IsTruthy(v5) { +var v13 any = v6 +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("first")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v5}) +var v14 any = v18 +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("next")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.Apply(v22, []any{v5}) +var v19 any = v23 +v3 = v13 +v4 = v14 +v5 = v19 +goto recur_loop_301 +} else { +v12 = v6 +} +return v12 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// map? +{ +v0 := lang.NewSymbol("map?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x implements IPersistentMap", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(167), lang.NewKeyword("end-line"), int(171))).(*lang.Symbol) +var v2 lang.FnFunc +{ // function map? +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{lang1.IPersistentMap, v4}) +return v8 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(171), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(171), lang.NewKeyword("end-column"), int(97))).(lang.FnFunc) +v3 := v2 +_ = v3 +} +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// *flush-on-newline* +{ +v0 := lang.NewSymbol("*flush-on-newline*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "When set to true, output will be flushed whenever a newline is printed.\n\n Defaults to true.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, nil, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// defprotocol +{ +v0 := lang.NewSymbol("defprotocol").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("opts+sigs"))), lang.NewKeyword("doc"), "A protocol is a named set of named methods and their signatures:\n (defprotocol AProtocolName\n\n ;optional doc string\n \"A doc string for AProtocol abstraction\"\n\n ;options\n :extend-via-metadata true\n\n ;method signatures\n (bar [this a b] \"bar docs\")\n (baz [this a] [this a b] [this a b c] \"baz docs\"))\n\n No implementations are provided. Docs can be specified for the\n protocol overall and for each method. The above yields a set of\n polymorphic functions and a protocol object. All are\n namespace-qualified by the ns enclosing the definition The resulting\n functions dispatch on the type of their first argument, which is\n required and corresponds to the implicit target object ('this' in \n Java parlance). defprotocol is dynamic, has no special compile-time \n effect, and defines no new types or classes. Implementations of \n the protocol methods can be provided using extend.\n\n When :extend-via-metadata is true, values can extend protocols by\n adding metadata where keys are fully-qualified protocol function\n symbols and values are function implementations. Protocol\n implementations are checked first for direct definitions (defrecord,\n deftype, reify), then metadata definitions, then external\n extensions (extend, extend-type, extend-protocol)\n\n defprotocol will automatically generate a corresponding interface,\n with the same name as the protocol, i.e. given a protocol:\n my.ns/Protocol, an interface: my.ns.Protocol. The interface will\n have methods corresponding to the protocol functions, and the\n protocol will automatically work with instances of the interface.\n\n Note that you should not use this interface with deftype or\n reify, as they support the protocol directly:\n\n (defprotocol P \n (foo [this]) \n (bar-me [this] [this y]))\n\n (deftype Foo [a b c] \n P\n (foo [this] a)\n (bar-me [this] b)\n (bar-me [this y] (+ c y)))\n \n (bar-me (Foo. 1 2 3) 42)\n => 45\n\n (foo \n (let [x 42]\n (reify P \n (foo [this] 17)\n (bar-me [this] x)\n (bar-me [this y] x))))\n => 17", lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(28), lang.NewKeyword("end-line"), int(28))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +var v8 any +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("string?")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("first")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v6}) +v16 := lang.Apply(v11, []any{v15}) +if lang.IsTruthy(v16) { +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("first")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v6}) +v8 = v20 +} else { +v8 = nil +} +var v7 any = v8 +_ = v7 +var v22 any +if lang.IsTruthy(v7) { +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("rest")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{v21}) +v22 = v26 +} else { +v22 = v21 +} +var v21 any = v22 +_ = v21 +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("take-while")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +var v31 lang.FnFunc +v31 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v32 := args[0] +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("not")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("seq?")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v32}) +v40 := lang.Apply(v35, []any{v39}) +return v40 +}) +v32 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(92), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(92), lang.NewKeyword("end-column"), int(40)) +v33, err := lang.WithMeta(v31, v32.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v34 := lang.Apply(v30, []any{v33, v21}) +var v27 any = v34 +_ = v27 +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("drop-while")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +var v39 lang.FnFunc +v39 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v40 := args[0] +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("not")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("seq?")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v40}) +v48 := lang.Apply(v43, []any{v47}) +return v48 +}) +v40 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(93), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(93), lang.NewKeyword("end-column"), int(40)) +v41, err := lang.WithMeta(v39, v40.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v42 := lang.Apply(v38, []any{v41, v21}) +var v35 any = v42 +_ = v35 +var v44 any +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("=")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +} +v47 := v46.Get() +v48 := lang.Apply(v47, []any{v35, v43}) +if lang.IsTruthy(v48) { +v44 = nil +} else { +v44 = v43 +} +var v43 any = v44 +_ = v43 +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("seq")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +} +v52 := v51.Get() +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("concat")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +} +v55 := v54.Get() +v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v57 := v56.FindInternedVar(lang.NewSymbol("list")) +if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) +} +v58 := v57.Get() +v59 := lang.Apply(v58, []any{lang.NewSymbol("do")}) +v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v61 := v60.FindInternedVar(lang.NewSymbol("list")) +if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) +} +v62 := v61.Get() +v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v64 := v63.FindInternedVar(lang.NewSymbol("seq")) +if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) +} +v65 := v64.Get() +v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v67 := v66.FindInternedVar(lang.NewSymbol("concat")) +if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) +} +v68 := v67.Get() +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("list")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +} +v71 := v70.Get() +v72 := lang.Apply(v71, []any{lang.NewSymbol("def")}) +v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v74 := v73.FindInternedVar(lang.NewSymbol("list")) +if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) +} +v75 := v74.Get() +v76 := lang.Apply(v75, []any{v5}) +v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v78 := v77.FindInternedVar(lang.NewSymbol("list")) +if v78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) +} +v79 := v78.Get() +v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v81 := v80.FindInternedVar(lang.NewSymbol("seq")) +if v81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) +} +v82 := v81.Get() +v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v84 := v83.FindInternedVar(lang.NewSymbol("concat")) +if v84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) +} +v85 := v84.Get() +v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v87 := v86.FindInternedVar(lang.NewSymbol("list")) +if v87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) +} +v88 := v87.Get() +v89 := lang.Apply(v88, []any{lang.NewSymbol("glojure.core/atom")}) +v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v91 := v90.FindInternedVar(lang.NewSymbol("list")) +if v91.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) +} +v92 := v91.Get() +v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v94 := v93.FindInternedVar(lang.NewSymbol("apply")) +if v94.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) +} +v95 := v94.Get() +v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v97 := v96.FindInternedVar(lang.NewSymbol("hash-map")) +if v97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) +} +v98 := v97.Get() +v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v100 := v99.FindInternedVar(lang.NewSymbol("seq")) +if v100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) +} +v101 := v100.Get() +v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v103 := v102.FindInternedVar(lang.NewSymbol("concat")) +if v103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) +} +v104 := v103.Get() +v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v106 := v105.FindInternedVar(lang.NewSymbol("list")) +if v106.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) +} +v107 := v106.Get() +v108 := lang.Apply(v107, []any{lang.NewKeyword("on-interface")}) +v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v110 := v109.FindInternedVar(lang.NewSymbol("list")) +if v110.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) +} +v111 := v110.Get() +v112 := lang.Apply(v111, []any{true}) +v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v114 := v113.FindInternedVar(lang.NewSymbol("list")) +if v114.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) +} +v115 := v114.Get() +v116 := lang.Apply(v115, []any{lang.NewKeyword("sigs")}) +v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v118 := v117.FindInternedVar(lang.NewSymbol("list")) +if v118.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) +} +v119 := v118.Get() +v120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v121 := v120.FindInternedVar(lang.NewSymbol("seq")) +if v121.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v121))) +} +v122 := v121.Get() +v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v124 := v123.FindInternedVar(lang.NewSymbol("concat")) +if v124.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) +} +v125 := v124.Get() +v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v127 := v126.FindInternedVar(lang.NewSymbol("list")) +if v127.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) +} +v128 := v127.Get() +v129 := lang.Apply(v128, []any{lang.NewSymbol("quote")}) +v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v131 := v130.FindInternedVar(lang.NewSymbol("list")) +if v131.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) +} +v132 := v131.Get() +v133 := lang.Apply(v132, []any{v35}) +v134 := lang.Apply(v125, []any{v129, v133}) +v135 := lang.Apply(v122, []any{v134}) +v136 := lang.Apply(v119, []any{v135}) +v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v138 := v137.FindInternedVar(lang.NewSymbol("list")) +if v138.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) +} +v139 := v138.Get() +v140 := lang.Apply(v139, []any{lang.NewKeyword("multis")}) +v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v142 := v141.FindInternedVar(lang.NewSymbol("list")) +if v142.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) +} +v143 := v142.Get() +v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v145 := v144.FindInternedVar(lang.NewSymbol("apply")) +if v145.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) +} +v146 := v145.Get() +v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v148 := v147.FindInternedVar(lang.NewSymbol("hash-map")) +if v148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) +} +v149 := v148.Get() +v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v151 := v150.FindInternedVar(lang.NewSymbol("seq")) +if v151.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) +} +v152 := v151.Get() +v153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v154 := v153.FindInternedVar(lang.NewSymbol("concat")) +if v154.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v154))) +} +v155 := v154.Get() +v156 := lang.Apply(v155, nil) +v157 := lang.Apply(v152, []any{v156}) +v158 := lang.Apply(v146, []any{v149, v157}) +v159 := lang.Apply(v143, []any{v158}) +v160 := lang.Apply(v104, []any{v108, v112, v116, v136, v140, v159}) +v161 := lang.Apply(v101, []any{v160}) +v162 := lang.Apply(v95, []any{v98, v161}) +v163 := lang.Apply(v92, []any{v162}) +v164 := lang.Apply(v85, []any{v89, v163}) +v165 := lang.Apply(v82, []any{v164}) +v166 := lang.Apply(v79, []any{v165}) +v167 := lang.Apply(v68, []any{v72, v76, v166}) +v168 := lang.Apply(v65, []any{v167}) +v169 := lang.Apply(v62, []any{v168}) +v170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v171 := v170.FindInternedVar(lang.NewSymbol("list")) +if v171.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v171))) +} +v172 := v171.Get() +v173 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v174 := v173.FindInternedVar(lang.NewSymbol("seq")) +if v174.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v174))) +} +v175 := v174.Get() +v176 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v177 := v176.FindInternedVar(lang.NewSymbol("concat")) +if v177.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v177))) +} +v178 := v177.Get() +v179 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v180 := v179.FindInternedVar(lang.NewSymbol("list")) +if v180.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v180))) +} +v181 := v180.Get() +v182 := lang.Apply(v181, []any{lang.NewSymbol("glojure.core/swap!")}) +v183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v184 := v183.FindInternedVar(lang.NewSymbol("list")) +if v184.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v184))) +} +v185 := v184.Get() +v186 := lang.Apply(v185, []any{lang.NewSymbol("glojure.core/-protocols")}) +v187 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v188 := v187.FindInternedVar(lang.NewSymbol("list")) +if v188.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v188))) +} +v189 := v188.Get() +v190 := lang.Apply(v189, []any{lang.NewSymbol("glojure.core/assoc")}) +v191 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v192 := v191.FindInternedVar(lang.NewSymbol("list")) +if v192.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v192))) +} +v193 := v192.Get() +v194 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v195 := v194.FindInternedVar(lang.NewSymbol("seq")) +if v195.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v195))) +} +v196 := v195.Get() +v197 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v198 := v197.FindInternedVar(lang.NewSymbol("concat")) +if v198.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v198))) +} +v199 := v198.Get() +v200 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v201 := v200.FindInternedVar(lang.NewSymbol("list")) +if v201.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v201))) +} +v202 := v201.Get() +v203 := lang.Apply(v202, []any{lang.NewSymbol("quote")}) +v204 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v205 := v204.FindInternedVar(lang.NewSymbol("list")) +if v205.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v205))) +} +v206 := v205.Get() +v207 := lang.Apply(v206, []any{v5}) +v208 := lang.Apply(v199, []any{v203, v207}) +v209 := lang.Apply(v196, []any{v208}) +v210 := lang.Apply(v193, []any{v209}) +v211 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v212 := v211.FindInternedVar(lang.NewSymbol("list")) +if v212.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v212))) +} +v213 := v212.Get() +v214 := lang.Apply(v213, []any{v5}) +v215 := lang.Apply(v178, []any{v182, v186, v190, v210, v214}) +v216 := lang.Apply(v175, []any{v215}) +v217 := lang.Apply(v172, []any{v216}) +v218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v219 := v218.FindInternedVar(lang.NewSymbol("map")) +if v219.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v219))) +} +v220 := v219.Get() +var v221 lang.FnFunc +v221 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v222 := args[0] +v223 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v224 := v223.FindInternedVar(lang.NewSymbol("seq")) +if v224.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v224))) +} +v225 := v224.Get() +v226 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v227 := v226.FindInternedVar(lang.NewSymbol("concat")) +if v227.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v227))) +} +v228 := v227.Get() +v229 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v230 := v229.FindInternedVar(lang.NewSymbol("list")) +if v230.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v230))) +} +v231 := v230.Get() +v232 := lang.Apply(v231, []any{lang.NewSymbol("do")}) +v233 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v234 := v233.FindInternedVar(lang.NewSymbol("list")) +if v234.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v234))) +} +v235 := v234.Get() +v236 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v237 := v236.FindInternedVar(lang.NewSymbol("seq")) +if v237.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v237))) +} +v238 := v237.Get() +v239 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v240 := v239.FindInternedVar(lang.NewSymbol("concat")) +if v240.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v240))) +} +v241 := v240.Get() +v242 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v243 := v242.FindInternedVar(lang.NewSymbol("list")) +if v243.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v243))) +} +v244 := v243.Get() +v245 := lang.Apply(v244, []any{lang.NewSymbol("glojure.core/defmulti")}) +v246 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v247 := v246.FindInternedVar(lang.NewSymbol("list")) +if v247.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v247))) +} +v248 := v247.Get() +v249 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v250 := v249.FindInternedVar(lang.NewSymbol("first")) +if v250.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v250))) +} +v251 := v250.Get() +v252 := lang.Apply(v251, []any{v222}) +v253 := lang.Apply(v248, []any{v252}) +v254 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v255 := v254.FindInternedVar(lang.NewSymbol("list")) +if v255.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v255))) +} +v256 := v255.Get() +v257 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v258 := v257.FindInternedVar(lang.NewSymbol("seq")) +if v258.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v258))) +} +v259 := v258.Get() +v260 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v261 := v260.FindInternedVar(lang.NewSymbol("concat")) +if v261.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v261))) +} +v262 := v261.Get() +v263 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v264 := v263.FindInternedVar(lang.NewSymbol("list")) +if v264.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v264))) +} +v265 := v264.Get() +v266 := lang.Apply(v265, []any{lang.NewSymbol("glojure.core/fn")}) +v267 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v268 := v267.FindInternedVar(lang.NewSymbol("list")) +if v268.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v268))) +} +v269 := v268.Get() +v270 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v271 := v270.FindInternedVar(lang.NewSymbol("apply")) +if v271.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v271))) +} +v272 := v271.Get() +v273 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v274 := v273.FindInternedVar(lang.NewSymbol("vector")) +if v274.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v274))) +} +v275 := v274.Get() +v276 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v277 := v276.FindInternedVar(lang.NewSymbol("seq")) +if v277.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v277))) +} +v278 := v277.Get() +v279 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v280 := v279.FindInternedVar(lang.NewSymbol("concat")) +if v280.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v280))) +} +v281 := v280.Get() +v282 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v283 := v282.FindInternedVar(lang.NewSymbol("list")) +if v283.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v283))) +} +v284 := v283.Get() +v285 := lang.Apply(v284, []any{lang.NewSymbol("this")}) +v286 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v287 := v286.FindInternedVar(lang.NewSymbol("list")) +if v287.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v287))) +} +v288 := v287.Get() +v289 := lang.Apply(v288, []any{lang.NewSymbol("&")}) +v290 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v291 := v290.FindInternedVar(lang.NewSymbol("list")) +if v291.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v291))) +} +v292 := v291.Get() +v293 := lang.Apply(v292, []any{lang.NewSymbol("args")}) +v294 := lang.Apply(v281, []any{v285, v289, v293}) +v295 := lang.Apply(v278, []any{v294}) +v296 := lang.Apply(v272, []any{v275, v295}) +v297 := lang.Apply(v269, []any{v296}) +v298 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v299 := v298.FindInternedVar(lang.NewSymbol("list")) +if v299.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v299))) +} +v300 := v299.Get() +v301 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v302 := v301.FindInternedVar(lang.NewSymbol("seq")) +if v302.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v302))) +} +v303 := v302.Get() +v304 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v305 := v304.FindInternedVar(lang.NewSymbol("concat")) +if v305.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v305))) +} +v306 := v305.Get() +v307 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v308 := v307.FindInternedVar(lang.NewSymbol("list")) +if v308.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v308))) +} +v309 := v308.Get() +v310 := lang.Apply(v309, []any{lang.NewSymbol("glojure.core/class")}) +v311 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v312 := v311.FindInternedVar(lang.NewSymbol("list")) +if v312.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v312))) +} +v313 := v312.Get() +v314 := lang.Apply(v313, []any{lang.NewSymbol("this")}) +v315 := lang.Apply(v306, []any{v310, v314}) +v316 := lang.Apply(v303, []any{v315}) +v317 := lang.Apply(v300, []any{v316}) +v318 := lang.Apply(v262, []any{v266, v297, v317}) +v319 := lang.Apply(v259, []any{v318}) +v320 := lang.Apply(v256, []any{v319}) +v321 := lang.Apply(v241, []any{v245, v253, v320}) +v322 := lang.Apply(v238, []any{v321}) +v323 := lang.Apply(v235, []any{v322}) +v324 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v325 := v324.FindInternedVar(lang.NewSymbol("list")) +if v325.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v325))) +} +v326 := v325.Get() +v327 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v328 := v327.FindInternedVar(lang.NewSymbol("seq")) +if v328.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v328))) +} +v329 := v328.Get() +v330 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v331 := v330.FindInternedVar(lang.NewSymbol("concat")) +if v331.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v331))) +} +v332 := v331.Get() +v333 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v334 := v333.FindInternedVar(lang.NewSymbol("list")) +if v334.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v334))) +} +v335 := v334.Get() +v336 := lang.Apply(v335, []any{lang.NewSymbol("glojure.core/swap!")}) +v337 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v338 := v337.FindInternedVar(lang.NewSymbol("list")) +if v338.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v338))) +} +v339 := v338.Get() +v340 := lang.Apply(v339, []any{v5}) +v341 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v342 := v341.FindInternedVar(lang.NewSymbol("list")) +if v342.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v342))) +} +v343 := v342.Get() +v344 := lang.Apply(v343, []any{lang.NewSymbol("glojure.core/assoc-in")}) +v345 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v346 := v345.FindInternedVar(lang.NewSymbol("list")) +if v346.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v346))) +} +v347 := v346.Get() +v348 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v349 := v348.FindInternedVar(lang.NewSymbol("apply")) +if v349.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v349))) +} +v350 := v349.Get() +v351 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v352 := v351.FindInternedVar(lang.NewSymbol("vector")) +if v352.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v352))) +} +v353 := v352.Get() +v354 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v355 := v354.FindInternedVar(lang.NewSymbol("seq")) +if v355.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v355))) +} +v356 := v355.Get() +v357 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v358 := v357.FindInternedVar(lang.NewSymbol("concat")) +if v358.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v358))) +} +v359 := v358.Get() +v360 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v361 := v360.FindInternedVar(lang.NewSymbol("list")) +if v361.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v361))) +} +v362 := v361.Get() +v363 := lang.Apply(v362, []any{lang.NewKeyword("multis")}) +v364 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v365 := v364.FindInternedVar(lang.NewSymbol("list")) +if v365.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v365))) +} +v366 := v365.Get() +v367 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v368 := v367.FindInternedVar(lang.NewSymbol("seq")) +if v368.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v368))) +} +v369 := v368.Get() +v370 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v371 := v370.FindInternedVar(lang.NewSymbol("concat")) +if v371.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v371))) +} +v372 := v371.Get() +v373 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v374 := v373.FindInternedVar(lang.NewSymbol("list")) +if v374.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v374))) +} +v375 := v374.Get() +v376 := lang.Apply(v375, []any{lang.NewSymbol("glojure.core/keyword")}) +v377 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v378 := v377.FindInternedVar(lang.NewSymbol("list")) +if v378.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v378))) +} +v379 := v378.Get() +v380 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v381 := v380.FindInternedVar(lang.NewSymbol("seq")) +if v381.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v381))) +} +v382 := v381.Get() +v383 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v384 := v383.FindInternedVar(lang.NewSymbol("concat")) +if v384.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v384))) +} +v385 := v384.Get() +v386 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v387 := v386.FindInternedVar(lang.NewSymbol("list")) +if v387.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v387))) +} +v388 := v387.Get() +v389 := lang.Apply(v388, []any{lang.NewSymbol("quote")}) +v390 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v391 := v390.FindInternedVar(lang.NewSymbol("list")) +if v391.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v391))) +} +v392 := v391.Get() +v393 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v394 := v393.FindInternedVar(lang.NewSymbol("first")) +if v394.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v394))) +} +v395 := v394.Get() +v396 := lang.Apply(v395, []any{v222}) +v397 := lang.Apply(v392, []any{v396}) +v398 := lang.Apply(v385, []any{v389, v397}) +v399 := lang.Apply(v382, []any{v398}) +v400 := lang.Apply(v379, []any{v399}) +v401 := lang.Apply(v372, []any{v376, v400}) +v402 := lang.Apply(v369, []any{v401}) +v403 := lang.Apply(v366, []any{v402}) +v404 := lang.Apply(v359, []any{v363, v403}) +v405 := lang.Apply(v356, []any{v404}) +v406 := lang.Apply(v350, []any{v353, v405}) +v407 := lang.Apply(v347, []any{v406}) +v408 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v409 := v408.FindInternedVar(lang.NewSymbol("list")) +if v409.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v409))) +} +v410 := v409.Get() +v411 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v412 := v411.FindInternedVar(lang.NewSymbol("first")) +if v412.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v412))) +} +v413 := v412.Get() +v414 := lang.Apply(v413, []any{v222}) +v415 := lang.Apply(v410, []any{v414}) +v416 := lang.Apply(v332, []any{v336, v340, v344, v407, v415}) +v417 := lang.Apply(v329, []any{v416}) +v418 := lang.Apply(v326, []any{v417}) +v419 := lang.Apply(v228, []any{v232, v323, v418}) +v420 := lang.Apply(v225, []any{v419}) +return v420 +}) +v222 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(102), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(104), lang.NewKeyword("end-column"), int(90)) +v223, err := lang.WithMeta(v221, v222.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v224 := lang.Apply(v220, []any{v223, v35}) +v225 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v226 := v225.FindInternedVar(lang.NewSymbol("list")) +if v226.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v226))) +} +v227 := v226.Get() +v228 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v229 := v228.FindInternedVar(lang.NewSymbol("seq")) +if v229.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v229))) +} +v230 := v229.Get() +v231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v232 := v231.FindInternedVar(lang.NewSymbol("concat")) +if v232.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v232))) +} +v233 := v232.Get() +v234 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v235 := v234.FindInternedVar(lang.NewSymbol("list")) +if v235.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v235))) +} +v236 := v235.Get() +v237 := lang.Apply(v236, []any{lang.NewSymbol("var")}) +v238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v239 := v238.FindInternedVar(lang.NewSymbol("list")) +if v239.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v239))) +} +v240 := v239.Get() +v241 := lang.Apply(v240, []any{v5}) +v242 := lang.Apply(v233, []any{v237, v241}) +v243 := lang.Apply(v230, []any{v242}) +v244 := lang.Apply(v227, []any{v243}) +v245 := lang.Apply(v55, []any{v59, v169, v217, v224, v244}) +v246 := lang.Apply(v52, []any{v245}) +return v246 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// print-dup +{ +v0 := lang.NewSymbol("print-dup").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3667), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(3667), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, nil, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// force +{ +v0 := lang.NewSymbol("force").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "If x is a Delay, returns the (possibly cached) value of its expression, else returns x", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(754), lang.NewKeyword("end-line"), int(754))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, _ := lang.FieldOrMethod(glojure.lang11.Delay, "force") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("force is not a function"))) +} +v5 := lang.Apply(v4, []any{v3}) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// with-local-vars +{ +v0 := lang.NewSymbol("with-local-vars").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name-vals-vec"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "varbinding=> symbol init-expr\n\n Executes the exprs in a context in which the symbols are bound to\n vars with per-thread bindings to the init-exprs. The symbols refer\n to the var objects themselves, and must be accessed with var-get and\n var-set", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4339), lang.NewKeyword("end-line"), int(4339))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +var v7 any +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v5}) +if lang.IsTruthy(v11) { +v7 = nil +} else { +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("str")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("first")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v3}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("meta")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v3}) +v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) +v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) +v28 := lang.Apply(lang1.NewIllegalArgumentError, []any{v27}) +panic(v28) +} +_ = v7 +var v29 any +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("even?")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("count")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v5}) +v37 := lang.Apply(v32, []any{v36}) +if lang.IsTruthy(v37) { +v29 = nil +} else { +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("str")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("first")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v3}) +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +} +v47 := v46.Get() +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("meta")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v3}) +v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) +v53 := lang.Apply(v40, []any{v44, " requires ", "an even number of forms in binding vector", " in ", v47, ":", v52}) +v54 := lang.Apply(lang1.NewIllegalArgumentError, []any{v53}) +panic(v54) +} +_ = v29 +_ = nil +v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v56 := v55.FindInternedVar(lang.NewSymbol("seq")) +if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) +} +v57 := v56.Get() +v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v59 := v58.FindInternedVar(lang.NewSymbol("concat")) +if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) +} +v60 := v59.Get() +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("list")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +} +v63 := v62.Get() +v64 := lang.Apply(v63, []any{lang.NewSymbol("glojure.core/let")}) +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("list")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +} +v67 := v66.Get() +v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v69 := v68.FindInternedVar(lang.NewSymbol("apply")) +if v69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) +} +v70 := v69.Get() +v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v72 := v71.FindInternedVar(lang.NewSymbol("vector")) +if v72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) +} +v73 := v72.Get() +v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v75 := v74.FindInternedVar(lang.NewSymbol("seq")) +if v75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) +} +v76 := v75.Get() +v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v78 := v77.FindInternedVar(lang.NewSymbol("concat")) +if v78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) +} +v79 := v78.Get() +v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v81 := v80.FindInternedVar(lang.NewSymbol("interleave")) +if v81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) +} +v82 := v81.Get() +v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v84 := v83.FindInternedVar(lang.NewSymbol("take-nth")) +if v84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) +} +v85 := v84.Get() +v86 := lang.Apply(v85, []any{int64(2), v5}) +v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v88 := v87.FindInternedVar(lang.NewSymbol("repeat")) +if v88.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) +} +v89 := v88.Get() +v90 := lang.Apply(v89, []any{lang.NewList(lang.NewSymbol(".."), lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.*Var"), lang.NewSymbol("create"), lang.NewSymbol("setDynamic"))}) +v91 := lang.Apply(v82, []any{v86, v90}) +v92 := lang.Apply(v79, []any{v91}) +v93 := lang.Apply(v76, []any{v92}) +v94 := lang.Apply(v70, []any{v73, v93}) +v95 := lang.Apply(v67, []any{v94}) +v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v97 := v96.FindInternedVar(lang.NewSymbol("list")) +if v97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) +} +v98 := v97.Get() +v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v100 := v99.FindInternedVar(lang.NewSymbol("seq")) +if v100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) +} +v101 := v100.Get() +v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v103 := v102.FindInternedVar(lang.NewSymbol("concat")) +if v103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) +} +v104 := v103.Get() +v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v106 := v105.FindInternedVar(lang.NewSymbol("list")) +if v106.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) +} +v107 := v106.Get() +v108 := lang.Apply(v107, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.PushThreadBindings")}) +v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v110 := v109.FindInternedVar(lang.NewSymbol("list")) +if v110.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) +} +v111 := v110.Get() +v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v113 := v112.FindInternedVar(lang.NewSymbol("apply")) +if v113.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) +} +v114 := v113.Get() +v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v116 := v115.FindInternedVar(lang.NewSymbol("hash-map")) +if v116.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) +} +v117 := v116.Get() +v118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v119 := v118.FindInternedVar(lang.NewSymbol("seq")) +if v119.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v119))) +} +v120 := v119.Get() +v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v122 := v121.FindInternedVar(lang.NewSymbol("concat")) +if v122.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) +} +v123 := v122.Get() +v124 := lang.Apply(v123, nil) +v125 := lang.Apply(v120, []any{v124}) +v126 := lang.Apply(v114, []any{v117, v125}) +v127 := lang.Apply(v111, []any{v126}) +v128 := lang.Apply(v104, []any{v108, v127}) +v129 := lang.Apply(v101, []any{v128}) +v130 := lang.Apply(v98, []any{v129}) +v131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v132 := v131.FindInternedVar(lang.NewSymbol("list")) +if v132.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v132))) +} +v133 := v132.Get() +v134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v135 := v134.FindInternedVar(lang.NewSymbol("seq")) +if v135.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v135))) +} +v136 := v135.Get() +v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v138 := v137.FindInternedVar(lang.NewSymbol("concat")) +if v138.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) +} +v139 := v138.Get() +v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v141 := v140.FindInternedVar(lang.NewSymbol("list")) +if v141.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) +} +v142 := v141.Get() +v143 := lang.Apply(v142, []any{lang.NewSymbol("try")}) +v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v145 := v144.FindInternedVar(lang.NewSymbol("list")) +if v145.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) +} +v146 := v145.Get() +v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v148 := v147.FindInternedVar(lang.NewSymbol("seq")) +if v148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) +} +v149 := v148.Get() +v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v151 := v150.FindInternedVar(lang.NewSymbol("concat")) +if v151.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) +} +v152 := v151.Get() +v153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v154 := v153.FindInternedVar(lang.NewSymbol("list")) +if v154.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v154))) +} +v155 := v154.Get() +v156 := lang.Apply(v155, []any{lang.NewSymbol("finally")}) +v157 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v158 := v157.FindInternedVar(lang.NewSymbol("list")) +if v158.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v158))) +} +v159 := v158.Get() +v160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v161 := v160.FindInternedVar(lang.NewSymbol("seq")) +if v161.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v161))) +} +v162 := v161.Get() +v163 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v164 := v163.FindInternedVar(lang.NewSymbol("concat")) +if v164.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v164))) +} +v165 := v164.Get() +v166 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v167 := v166.FindInternedVar(lang.NewSymbol("list")) +if v167.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v167))) +} +v168 := v167.Get() +v169 := lang.Apply(v168, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.PopThreadBindings")}) +v170 := lang.Apply(v165, []any{v169}) +v171 := lang.Apply(v162, []any{v170}) +v172 := lang.Apply(v159, []any{v171}) +v173 := lang.Apply(v152, []any{v156, v172}) +v174 := lang.Apply(v149, []any{v173}) +v175 := lang.Apply(v146, []any{v174}) +v176 := lang.Apply(v139, []any{v143, v6, v175}) +v177 := lang.Apply(v136, []any{v176}) +v178 := lang.Apply(v133, []any{v177}) +v179 := lang.Apply(v60, []any{v64, v95, v130, v178}) +v180 := lang.Apply(v57, []any{v179}) +return v180 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// constantly +{ +v0 := lang.NewSymbol("constantly").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns a function that takes any number of arguments and returns x.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1440), lang.NewKeyword("end-line"), int(1440))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := lang.NewList(args[0:]...) +return v3 + } +}) +v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1444), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(1444), lang.NewKeyword("end-column"), int(21)) +v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v6 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// nthnext +{ +v0 := lang.NewSymbol("nthnext").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns the nth next of coll, (seq coll) when n is 0.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3147), lang.NewKeyword("end-line"), int(3147))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{lang1.IDrop, v3}) +if lang.IsTruthy(v9) { +var v10 any +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("pos?")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v4}) +if lang.IsTruthy(v14) { +var v15 any +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("int?")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v4}) +if lang.IsTruthy(v19) { +v15 = v4 +} else { +v20 := lang.Apply(nil, []any{v4}) +v15 = v20 +} +v21, _ := lang.FieldOrMethod(v3, "drop") +if reflect.TypeOf(v21).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("drop is not a function"))) +} +v22 := lang.Apply(v21, []any{v15}) +v10 = v22 +} else { +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("seq")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{v3}) +v10 = v26 +} +v5 = v10 +} else { +var v27 any = v27 +_ = v27 +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("seq")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.Apply(v31, []any{v3}) +var v28 any = v32 +_ = v28 +var v33 any +for { +var v34 any +var v35 any = v28 +_ = v35 +var v37 any +if lang.IsTruthy(v35) { +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("pos?")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.Apply(v40, []any{v27}) +v37 = v41 +} else { +v37 = v35 +} +if lang.IsTruthy(v37) { +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("dec")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v27}) +var v35 any = v39 +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("next")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v28}) +var v40 any = v44 +v27 = v35 +v28 = v40 +continue +} else { +v34 = v28 +} +v33 = v34 + break +} +v5 = v33 +} +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// floats +{ +var v1 lang.FnFunc +{ // function floats +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/floats")}) +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("list")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v3}) +v26 := lang.Apply(v9, []any{v13, v17, v21, v25}) +v27 := lang.Apply(v6, []any{v26}) +return v27 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("floats").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Casts to float[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5392), lang.NewKeyword("end-line"), int(5392))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "floats") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("floats is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// neg? +{ +var v1 lang.FnFunc +{ // function neg?__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/isNeg")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v3}) +v35 := lang.Apply(v26, []any{v30, v34}) +v36 := lang.Apply(v23, []any{v35}) +v37 := lang.Apply(v20, []any{v36}) +v38 := lang.Apply(v9, []any{v13, v17, v37}) +v39 := lang.Apply(v6, []any{v38}) +return v39 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("neg?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns true if num is less than zero, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1259), lang.NewKeyword("end-line"), int(1259))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "isNeg") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("isNeg is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// alter-var-root +{ +v0 := lang.NewSymbol("alter-var-root").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("v"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Atomically alters the root binding of var v by applying f to its\n current value plus any args", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5527), lang.NewKeyword("end-line"), int(5527))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +v6, _ := lang.FieldOrMethod(v3, "alterRoot") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("alterRoot is not a function"))) +} +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// seq +{ +v1 := reflect.TypeOf((*lang1.ISeq)(nil)).Elem() +v0 := lang.NewSymbol("seq").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a seq on the collection. If the collection is\n empty, returns nil. (seq nil) returns nil. seq also works on\n Strings, native Java arrays (of reference types) and any objects\n that implement Iterable. Note that seqs cache values, thus seq\n should not be used on any Iterable whose iterator repeatedly\n returns the same mutable object.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(4), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(126), lang.NewKeyword("end-line"), int(136))).(*lang.Symbol) +var v3 lang.FnFunc +{ // function seq +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +v6 := lang.Apply(lang1.Seq, []any{v5}) +return v6 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(136), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(136), lang.NewKeyword("end-column"), int(126))).(lang.FnFunc) +v4 := v3 +_ = v4 +} +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// some-> +{ +v0 := lang.NewSymbol("some->").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "When expr is not nil, threads it into the first form (via ->),\n and when that result is not nil, through the next etc", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7653), lang.NewKeyword("end-line"), int(7653))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("gensym")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, nil) +var v7 any = v11 +_ = v7 +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("map")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +var v16 lang.FnFunc +v16 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v17 := args[0] +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("seq")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("concat")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("list")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.Apply(v26, []any{lang.NewSymbol("if")}) +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("list")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("seq")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("concat")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("list")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.Apply(v39, []any{lang.NewSymbol("glojure.core/nil?")}) +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("list")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v7}) +v45 := lang.Apply(v36, []any{v40, v44}) +v46 := lang.Apply(v33, []any{v45}) +v47 := lang.Apply(v30, []any{v46}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{nil}) +v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v53 := v52.FindInternedVar(lang.NewSymbol("list")) +if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) +} +v54 := v53.Get() +v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v56 := v55.FindInternedVar(lang.NewSymbol("seq")) +if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) +} +v57 := v56.Get() +v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v59 := v58.FindInternedVar(lang.NewSymbol("concat")) +if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) +} +v60 := v59.Get() +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("list")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +} +v63 := v62.Get() +v64 := lang.Apply(v63, []any{lang.NewSymbol("glojure.core/->")}) +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("list")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +} +v67 := v66.Get() +v68 := lang.Apply(v67, []any{v7}) +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("list")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +} +v71 := v70.Get() +v72 := lang.Apply(v71, []any{v17}) +v73 := lang.Apply(v60, []any{v64, v68, v72}) +v74 := lang.Apply(v57, []any{v73}) +v75 := lang.Apply(v54, []any{v74}) +v76 := lang.Apply(v23, []any{v27, v47, v51, v75}) +v77 := lang.Apply(v20, []any{v76}) +return v77 +}) +v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7659), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7659), lang.NewKeyword("end-column"), int(64)) +v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v19 := lang.Apply(v15, []any{v18, v6}) +var v12 any = v19 +_ = v12 +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/let")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("apply")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("vector")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("seq")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("concat")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +} +v45 := v44.Get() +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("list")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +} +v48 := v47.Get() +v49 := lang.Apply(v48, []any{v7}) +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("list")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +} +v52 := v51.Get() +v53 := lang.Apply(v52, []any{v5}) +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("interleave")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +} +v56 := v55.Get() +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("repeat")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +} +v59 := v58.Get() +v60 := lang.Apply(v59, []any{v7}) +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("butlast")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +} +v63 := v62.Get() +v64 := lang.Apply(v63, []any{v12}) +v65 := lang.Apply(v56, []any{v60, v64}) +v66 := lang.Apply(v45, []any{v49, v53, v65}) +v67 := lang.Apply(v42, []any{v66}) +v68 := lang.Apply(v36, []any{v39, v67}) +v69 := lang.Apply(v33, []any{v68}) +v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v71 := v70.FindInternedVar(lang.NewSymbol("list")) +if v71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) +} +v72 := v71.Get() +var v73 any +v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v75 := v74.FindInternedVar(lang.NewSymbol("empty?")) +if v75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) +} +v76 := v75.Get() +v77 := lang.Apply(v76, []any{v12}) +if lang.IsTruthy(v77) { +v73 = v7 +} else { +v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v79 := v78.FindInternedVar(lang.NewSymbol("last")) +if v79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) +} +v80 := v79.Get() +v81 := lang.Apply(v80, []any{v12}) +v73 = v81 +} +v82 := lang.Apply(v72, []any{v73}) +v83 := lang.Apply(v26, []any{v30, v69, v82}) +v84 := lang.Apply(v23, []any{v83}) +return v84 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// bytes +{ +var v1 lang.FnFunc +{ // function bytes +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/bytes")}) +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("list")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v3}) +v26 := lang.Apply(v9, []any{v13, v17, v21, v25}) +v27 := lang.Apply(v6, []any{v26}) +return v27 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("bytes").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Casts to bytes[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5377), lang.NewKeyword("end-line"), int(5377))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "bytes") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("bytes is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// key +{ +v0 := lang.NewSymbol("key").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("e"))), lang.NewKeyword("doc"), "Returns the key of the map entry.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1563), lang.NewKeyword("end-line"), int(1563))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, _ := lang.FieldOrMethod(v3, "GetKey") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("GetKey is not a function"))) +} +v5 := lang.Apply(v4, []any{}) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// parsing-err +{ +v0 := lang.NewSymbol("parsing-err").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Construct message for parsing for non-string parsing error", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(7974), lang.NewKeyword("end-line"), int(7974), lang.NewKeyword("private"), true)).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("str")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +var v7 any +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("nil?")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v3}) +if lang.IsTruthy(v11) { +v7 = "nil" +} else { +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("class")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v3}) +v16, ok := lang.FieldOrMethod(v15, "Name") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v15, "Name"))) +} +var v17 any +switch reflect.TypeOf(v16).Kind() { +case reflect.Func: + v17 = lang.Apply(v16, nil) +default: + v17 = v16 +} +v7 = v17 +} +v18 := lang.Apply(v6, []any{"Expected string, got ", v7}) +return v18 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// definline +{ +v0 := lang.NewSymbol("definline").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("decl"))), lang.NewKeyword("doc"), "Experimental - like defmacro, except defines a named function whose\n body is the expansion, calls to which may be expanded inline as if\n it were a macro. Cannot be used with variadic (&) args.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5253), lang.NewKeyword("end-line"), int(5253))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("split-with")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("comp")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("not")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("vector?")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v13, []any{v16, v19}) +v21 := lang.Apply(v10, []any{v20, v6}) +var v7 any = v21 +_ = v7 +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("nth")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{v7, int64(0), nil}) +var v22 any = v26 +_ = v22 +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("nth")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{v7, int64(1), nil}) +var v27 any = v31 +_ = v27 +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("nth")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v27, int64(0), nil}) +var v32 any = v36 +_ = v32 +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("nth")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.Apply(v40, []any{v27, int64(1), nil}) +var v37 any = v41 +_ = v37 +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("seq")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +} +v45 := v44.Get() +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("concat")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +} +v48 := v47.Get() +v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v50 := v49.FindInternedVar(lang.NewSymbol("list")) +if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) +} +v51 := v50.Get() +v52 := lang.Apply(v51, []any{lang.NewSymbol("do")}) +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("list")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +} +v55 := v54.Get() +v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v57 := v56.FindInternedVar(lang.NewSymbol("seq")) +if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) +} +v58 := v57.Get() +v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v60 := v59.FindInternedVar(lang.NewSymbol("concat")) +if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) +} +v61 := v60.Get() +v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v63 := v62.FindInternedVar(lang.NewSymbol("list")) +if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +} +v64 := v63.Get() +v65 := lang.Apply(v64, []any{lang.NewSymbol("glojure.core/defn")}) +v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v67 := v66.FindInternedVar(lang.NewSymbol("list")) +if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) +} +v68 := v67.Get() +v69 := lang.Apply(v68, []any{v5}) +v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v71 := v70.FindInternedVar(lang.NewSymbol("list")) +if v71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) +} +v72 := v71.Get() +v73 := lang.Apply(v72, []any{v32}) +v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v75 := v74.FindInternedVar(lang.NewSymbol("list")) +if v75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) +} +v76 := v75.Get() +v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v78 := v77.FindInternedVar(lang.NewSymbol("apply")) +if v78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) +} +v79 := v78.Get() +v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v81 := v80.FindInternedVar(lang.NewSymbol("eval")) +if v81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) +} +v82 := v81.Get() +v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v84 := v83.FindInternedVar(lang.NewSymbol("list")) +if v84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) +} +v85 := v84.Get() +v86 := lang.Apply(v85, []any{lang.NewSymbol("glojure.core/fn"), v32, v37}) +v87 := lang.Apply(v82, []any{v86}) +v88 := lang.Apply(v79, []any{v87, v32}) +v89 := lang.Apply(v76, []any{v88}) +v90 := lang.Apply(v61, []any{v65, v69, v22, v73, v89}) +v91 := lang.Apply(v58, []any{v90}) +v92 := lang.Apply(v55, []any{v91}) +v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v94 := v93.FindInternedVar(lang.NewSymbol("list")) +if v94.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) +} +v95 := v94.Get() +v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v97 := v96.FindInternedVar(lang.NewSymbol("seq")) +if v97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) +} +v98 := v97.Get() +v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v100 := v99.FindInternedVar(lang.NewSymbol("concat")) +if v100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) +} +v101 := v100.Get() +v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v103 := v102.FindInternedVar(lang.NewSymbol("list")) +if v103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) +} +v104 := v103.Get() +v105 := lang.Apply(v104, []any{lang.NewSymbol("glojure.core/alter-meta!")}) +v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v107 := v106.FindInternedVar(lang.NewSymbol("list")) +if v107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) +} +v108 := v107.Get() +v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v110 := v109.FindInternedVar(lang.NewSymbol("seq")) +if v110.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) +} +v111 := v110.Get() +v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v113 := v112.FindInternedVar(lang.NewSymbol("concat")) +if v113.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) +} +v114 := v113.Get() +v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v116 := v115.FindInternedVar(lang.NewSymbol("list")) +if v116.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) +} +v117 := v116.Get() +v118 := lang.Apply(v117, []any{lang.NewSymbol("var")}) +v119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v120 := v119.FindInternedVar(lang.NewSymbol("list")) +if v120.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v120))) +} +v121 := v120.Get() +v122 := lang.Apply(v121, []any{v5}) +v123 := lang.Apply(v114, []any{v118, v122}) +v124 := lang.Apply(v111, []any{v123}) +v125 := lang.Apply(v108, []any{v124}) +v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v127 := v126.FindInternedVar(lang.NewSymbol("list")) +if v127.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) +} +v128 := v127.Get() +v129 := lang.Apply(v128, []any{lang.NewSymbol("glojure.core/assoc")}) +v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v131 := v130.FindInternedVar(lang.NewSymbol("list")) +if v131.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) +} +v132 := v131.Get() +v133 := lang.Apply(v132, []any{lang.NewKeyword("inline")}) +v134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v135 := v134.FindInternedVar(lang.NewSymbol("list")) +if v135.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v135))) +} +v136 := v135.Get() +v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v138 := v137.FindInternedVar(lang.NewSymbol("seq")) +if v138.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) +} +v139 := v138.Get() +v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v141 := v140.FindInternedVar(lang.NewSymbol("concat")) +if v141.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) +} +v142 := v141.Get() +v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v144 := v143.FindInternedVar(lang.NewSymbol("list")) +if v144.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) +} +v145 := v144.Get() +v146 := lang.Apply(v145, []any{lang.NewSymbol("glojure.core/fn")}) +v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v148 := v147.FindInternedVar(lang.NewSymbol("list")) +if v148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) +} +v149 := v148.Get() +v150 := lang.Apply(v149, []any{v5}) +v151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v152 := v151.FindInternedVar(lang.NewSymbol("list")) +if v152.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v152))) +} +v153 := v152.Get() +v154 := lang.Apply(v153, []any{v32}) +v155 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v156 := v155.FindInternedVar(lang.NewSymbol("list")) +if v156.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v156))) +} +v157 := v156.Get() +v158 := lang.Apply(v157, []any{v37}) +v159 := lang.Apply(v142, []any{v146, v150, v154, v158}) +v160 := lang.Apply(v139, []any{v159}) +v161 := lang.Apply(v136, []any{v160}) +v162 := lang.Apply(v101, []any{v105, v125, v129, v133, v161}) +v163 := lang.Apply(v98, []any{v162}) +v164 := lang.Apply(v95, []any{v163}) +v165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v166 := v165.FindInternedVar(lang.NewSymbol("list")) +if v166.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v166))) +} +v167 := v166.Get() +v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v169 := v168.FindInternedVar(lang.NewSymbol("seq")) +if v169.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) +} +v170 := v169.Get() +v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v172 := v171.FindInternedVar(lang.NewSymbol("concat")) +if v172.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) +} +v173 := v172.Get() +v174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v175 := v174.FindInternedVar(lang.NewSymbol("list")) +if v175.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v175))) +} +v176 := v175.Get() +v177 := lang.Apply(v176, []any{lang.NewSymbol("var")}) +v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v179 := v178.FindInternedVar(lang.NewSymbol("list")) +if v179.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) +} +v180 := v179.Get() +v181 := lang.Apply(v180, []any{v5}) +v182 := lang.Apply(v173, []any{v177, v181}) +v183 := lang.Apply(v170, []any{v182}) +v184 := lang.Apply(v167, []any{v183}) +v185 := lang.Apply(v48, []any{v52, v92, v164, v184}) +v186 := lang.Apply(v45, []any{v185}) +return v186 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// frequencies +{ +v0 := lang.NewSymbol("frequencies").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a map from distinct items in coll to the number of times\n they appear.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7228), lang.NewKeyword("end-line"), int(7228))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("persistent!")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("reduce")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +var v10 lang.FnFunc +v10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v11 := args[0] +v12 := args[1] +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("assoc!")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("inc")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("get")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v11, v12, int64(0)}) +v23 := lang.Apply(v18, []any{v22}) +v24 := lang.Apply(v15, []any{v11, v12, v23}) +return v24 +}) +v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7235), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(7236), lang.NewKeyword("end-column"), int(54)) +v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("transient")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.NewMap() +v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7237), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(7237), lang.NewKeyword("end-column"), int(24)) +v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v19 := lang.Apply(v15, []any{v18}) +v20 := lang.Apply(v9, []any{v12, v19, v3}) +v21 := lang.Apply(v6, []any{v20}) +return v21 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// load-string +{ +v0 := lang.NewSymbol("load-string").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Sequentially read and evaluate the set of forms contained in the\n string", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4088), lang.NewKeyword("end-line"), int(4088))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v5 := lang.Apply(java.io.StringReader37., []any{v3}) +v6 := lang.Apply(glojure.lang.LineNumberingPushbackReader5., []any{v5}) +var v4 any = v6 +_ = v4 +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("load-reader")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v4}) +return v11 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// with-in-str +{ +v0 := lang.NewSymbol("with-in-str").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Evaluates body in a context in which *in* is bound to a fresh\n StringReader initialized with the string s.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4749), lang.NewKeyword("end-line"), int(4749))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("seq")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("concat")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("list")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/with-open")}) +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("list")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("apply")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("vector")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("seq")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("concat")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{lang.NewSymbol("s__0__auto__")}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("seq")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +} +v41 := v40.Get() +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("concat")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +} +v44 := v43.Get() +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("list")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +} +v47 := v46.Get() +v48 := lang.Apply(v47, []any{lang.NewSymbol("glojure.core/->")}) +v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v50 := v49.FindInternedVar(lang.NewSymbol("list")) +if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) +} +v51 := v50.Get() +v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v53 := v52.FindInternedVar(lang.NewSymbol("seq")) +if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) +} +v54 := v53.Get() +v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v56 := v55.FindInternedVar(lang.NewSymbol("concat")) +if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) +} +v57 := v56.Get() +v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v59 := v58.FindInternedVar(lang.NewSymbol("list")) +if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) +} +v60 := v59.Get() +v61 := lang.Apply(v60, []any{lang.NewSymbol("java.io.StringReader.")}) +v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v63 := v62.FindInternedVar(lang.NewSymbol("list")) +if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +} +v64 := v63.Get() +v65 := lang.Apply(v64, []any{v5}) +v66 := lang.Apply(v57, []any{v61, v65}) +v67 := lang.Apply(v54, []any{v66}) +v68 := lang.Apply(v51, []any{v67}) +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("list")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +} +v71 := v70.Get() +v72 := lang.Apply(v71, []any{lang.NewSymbol("glojure.lang.LineNumberingPushbackReader.")}) +v73 := lang.Apply(v44, []any{v48, v68, v72}) +v74 := lang.Apply(v41, []any{v73}) +v75 := lang.Apply(v38, []any{v74}) +v76 := lang.Apply(v31, []any{v35, v75}) +v77 := lang.Apply(v28, []any{v76}) +v78 := lang.Apply(v22, []any{v25, v77}) +v79 := lang.Apply(v19, []any{v78}) +v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v81 := v80.FindInternedVar(lang.NewSymbol("list")) +if v81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) +} +v82 := v81.Get() +v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v84 := v83.FindInternedVar(lang.NewSymbol("seq")) +if v84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) +} +v85 := v84.Get() +v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v87 := v86.FindInternedVar(lang.NewSymbol("concat")) +if v87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) +} +v88 := v87.Get() +v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v90 := v89.FindInternedVar(lang.NewSymbol("list")) +if v90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) +} +v91 := v90.Get() +v92 := lang.Apply(v91, []any{lang.NewSymbol("glojure.core/binding")}) +v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v94 := v93.FindInternedVar(lang.NewSymbol("list")) +if v94.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) +} +v95 := v94.Get() +v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v97 := v96.FindInternedVar(lang.NewSymbol("apply")) +if v97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) +} +v98 := v97.Get() +v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v100 := v99.FindInternedVar(lang.NewSymbol("vector")) +if v100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) +} +v101 := v100.Get() +v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v103 := v102.FindInternedVar(lang.NewSymbol("seq")) +if v103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) +} +v104 := v103.Get() +v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v106 := v105.FindInternedVar(lang.NewSymbol("concat")) +if v106.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) +} +v107 := v106.Get() +v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v109 := v108.FindInternedVar(lang.NewSymbol("list")) +if v109.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) +} +v110 := v109.Get() +v111 := lang.Apply(v110, []any{lang.NewSymbol("glojure.core/*in*")}) +v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v113 := v112.FindInternedVar(lang.NewSymbol("list")) +if v113.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) +} +v114 := v113.Get() +v115 := lang.Apply(v114, []any{lang.NewSymbol("s__0__auto__")}) +v116 := lang.Apply(v107, []any{v111, v115}) +v117 := lang.Apply(v104, []any{v116}) +v118 := lang.Apply(v98, []any{v101, v117}) +v119 := lang.Apply(v95, []any{v118}) +v120 := lang.Apply(v88, []any{v92, v119, v6}) +v121 := lang.Apply(v85, []any{v120}) +v122 := lang.Apply(v82, []any{v121}) +v123 := lang.Apply(v12, []any{v16, v79, v122}) +v124 := lang.Apply(v9, []any{v123}) +return v124 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// simple-ident? +{ +v0 := lang.NewSymbol("simple-ident?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a symbol or keyword without a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1613), lang.NewKeyword("end-line"), int(1613))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("ident?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +var v4 any = v8 +_ = v4 +var v10 any +if lang.IsTruthy(v4) { +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("nil?")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("namespace")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v3}) +v18 := lang.Apply(v13, []any{v17}) +v10 = v18 +} else { +v10 = v4 +} +return v10 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// print-tagged-object +{ +v0 := lang.NewSymbol("print-tagged-object").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(102), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(102), lang.NewKeyword("end-column"), int(26), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("rep"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +var v6 any +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("instance?")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{lang1.IMeta, v3}) +if lang.IsTruthy(v10) { +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("print-meta")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v3, v5}) +v6 = v14 +} else { +v6 = nil +} +_ = v6 +v15 := lang.Apply(lang1.WriteWriter, []any{v5, "#object["}) +_ = v15 +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("class")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v3}) +var v16 any = v20 +_ = v16 +var v22 any +if lang.IsTruthy(false) { +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("print-method")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26, ok := lang.FieldOrMethod(v16, "Name") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v16, "Name"))) +} +var v27 any +switch reflect.TypeOf(v26).Kind() { +case reflect.Func: + v27 = lang.Apply(v26, nil) +default: + v27 = v26 +} +v28 := lang.Apply(v25, []any{v27, v5}) +v22 = v28 +} else { +v29, ok := lang.FieldOrMethod(v16, "Name") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v16, "Name"))) +} +var v30 any +switch reflect.TypeOf(v29).Kind() { +case reflect.Func: + v30 = lang.Apply(v29, nil) +default: + v30 = v29 +} +v31 := lang.Apply(lang1.WriteWriter, []any{v5, v30}) +v22 = v31 +} +_ = v22 +v16 := lang.Apply(lang1.WriteWriter, []any{v5, " "}) +_ = v16 +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("format")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(lang1.IdentityHash, []any{v3}) +v21 := lang.Apply(v19, []any{"0x%x ", v20}) +v22 := lang.Apply(lang1.WriteWriter, []any{v5, v21}) +_ = v22 +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("print-method")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{v4, v5}) +_ = v26 +v27 := lang.Apply(lang1.WriteWriter, []any{v5, "]"}) +return v27 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// empty? +{ +v0 := lang.NewSymbol("empty?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll has no items. To check the emptiness of a seq,\n please use the idiom (seq x) rather than (not (empty? x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6290), lang.NewKeyword("end-line"), int(6290))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("counted?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +if lang.IsTruthy(v8) { +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("zero?")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("count")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v3}) +v16 := lang.Apply(v11, []any{v15}) +v4 = v16 +} else { +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("not")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("seq")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.Apply(v22, []any{v3}) +v24 := lang.Apply(v19, []any{v23}) +v4 = v24 +} +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// indexed? +{ +v0 := lang.NewSymbol("indexed?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return true if coll implements Indexed, indicating efficient lookup by index", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6306), lang.NewKeyword("end-line"), int(6306))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{glojure.lang11.Indexed, v3}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// aset-short +{ +v0 := lang.NewSymbol("aset-short").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of short. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3971), lang.NewKeyword("end-line"), int(3973))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("short")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v5}) +v10, _ := lang.FieldOrMethod(nil, "setShort") +if reflect.TypeOf(v10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setShort is not a function"))) +} +v11 := lang.Apply(v10, []any{v3, v4, v9}) +_ = v11 +return v5 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("apply")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("aset-short")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("aget")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v3, v4}) +v17 := lang.Apply(v9, []any{v12, v16, v5, v6}) +return v17 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// unchecked-divide-int +{ +var v1 lang.FnFunc +{ // function unchecked-divide-int__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("concat")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("list")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("seq")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("concat")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("list")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/unchecked_int_divide")}) +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v4}) +v40 := lang.Apply(v27, []any{v31, v35, v39}) +v41 := lang.Apply(v24, []any{v40}) +v42 := lang.Apply(v21, []any{v41}) +v43 := lang.Apply(v10, []any{v14, v18, v42}) +v44 := lang.Apply(v7, []any{v43}) +return v44 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("unchecked-divide-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the division of x by y, both int.\n Note - uses a primitive operator subject to truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(26), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1238), lang.NewKeyword("end-line"), int(1238))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := args[1] +v6, _ := lang.FieldOrMethod(lang1.Numbers, "unchecked_int_divide") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_divide is not a function"))) +} +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// loop +{ +v0 := lang.NewSymbol("loop").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Evaluates the exprs in a lexical context in which the symbols in\n the binding-forms are bound to their respective init-exprs or parts\n therein. Acts as a recur target.", lang.NewKeyword("forms"), lang.NewVector(lang.NewList(lang.NewSymbol("loop"), lang.NewVector(lang.NewSymbol("bindings*")), lang.NewSymbol("exprs*"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4597), lang.NewKeyword("end-line"), int(4597), lang.NewKeyword("special-form"), true)).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +var v7 any +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v5}) +if lang.IsTruthy(v11) { +v7 = nil +} else { +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("str")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("first")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v3}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("meta")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v3}) +v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) +v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) +v28 := lang.Apply(lang1.NewIllegalArgumentError, []any{v27}) +panic(v28) +} +_ = v7 +var v29 any +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("even?")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("count")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v5}) +v37 := lang.Apply(v32, []any{v36}) +if lang.IsTruthy(v37) { +v29 = nil +} else { +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("str")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("first")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v3}) +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +} +v47 := v46.Get() +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("meta")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v3}) +v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) +v53 := lang.Apply(v40, []any{v44, " requires ", "an even number of forms in binding vector", " in ", v47, ":", v52}) +v54 := lang.Apply(lang1.NewIllegalArgumentError, []any{v53}) +panic(v54) +} +_ = v29 +_ = nil +v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v57 := v56.FindInternedVar(lang.NewSymbol("destructure")) +if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) +} +v58 := v57.Get() +v59 := lang.Apply(v58, []any{v5}) +var v55 any = v59 +_ = v55 +var v61 any +v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v63 := v62.FindInternedVar(lang.NewSymbol("=")) +if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +} +v64 := v63.Get() +v65 := lang.Apply(v64, []any{v55, v5}) +if lang.IsTruthy(v65) { +v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v67 := v66.FindInternedVar(lang.NewSymbol("seq")) +if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) +} +v68 := v67.Get() +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("concat")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +} +v71 := v70.Get() +v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v73 := v72.FindInternedVar(lang.NewSymbol("list")) +if v73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) +} +v74 := v73.Get() +v75 := lang.Apply(v74, []any{lang.NewSymbol("loop*")}) +v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v77 := v76.FindInternedVar(lang.NewSymbol("list")) +if v77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) +} +v78 := v77.Get() +v79 := lang.Apply(v78, []any{v5}) +v80 := lang.Apply(v71, []any{v75, v79, v6}) +v81 := lang.Apply(v68, []any{v80}) +v61 = v81 +} else { +v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v84 := v83.FindInternedVar(lang.NewSymbol("take-nth")) +if v84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) +} +v85 := v84.Get() +v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v87 := v86.FindInternedVar(lang.NewSymbol("drop")) +if v87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) +} +v88 := v87.Get() +v89 := lang.Apply(v88, []any{int64(1), v5}) +v90 := lang.Apply(v85, []any{int64(2), v89}) +var v82 any = v90 +_ = v82 +v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v93 := v92.FindInternedVar(lang.NewSymbol("take-nth")) +if v93.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) +} +v94 := v93.Get() +v95 := lang.Apply(v94, []any{int64(2), v5}) +var v91 any = v95 +_ = v91 +v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v98 := v97.FindInternedVar(lang.NewSymbol("map")) +if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) +} +v99 := v98.Get() +var v100 lang.FnFunc +v100 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v101 := args[0] +var v102 any +v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v104 := v103.FindInternedVar(lang.NewSymbol("symbol?")) +if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) +} +v105 := v104.Get() +v106 := lang.Apply(v105, []any{v101}) +if lang.IsTruthy(v106) { +v102 = v101 +} else { +v107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v108 := v107.FindInternedVar(lang.NewSymbol("gensym")) +if v108.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v108))) +} +v109 := v108.Get() +v110 := lang.Apply(v109, nil) +v102 = v110 +} +return v102 +}) +v101 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4611), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(4611), lang.NewKeyword("end-column"), int(58)) +v102, err := lang.WithMeta(v100, v101.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v103 := lang.Apply(v99, []any{v102, v91}) +var v96 any = v103 +_ = v96 +v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v106 := v105.FindInternedVar(lang.NewSymbol("reduce1")) +if v106.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) +} +v107 := v106.Get() +var v108 lang.FnFunc +v108 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v109 := args[0] +v110 := args[1] +var v111 any = v110 +_ = v111 +v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v114 := v113.FindInternedVar(lang.NewSymbol("nth")) +if v114.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) +} +v115 := v114.Get() +v116 := lang.Apply(v115, []any{v111, int64(0), nil}) +var v112 any = v116 +_ = v112 +v118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v119 := v118.FindInternedVar(lang.NewSymbol("nth")) +if v119.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v119))) +} +v120 := v119.Get() +v121 := lang.Apply(v120, []any{v111, int64(1), nil}) +var v117 any = v121 +_ = v117 +v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v124 := v123.FindInternedVar(lang.NewSymbol("nth")) +if v124.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) +} +v125 := v124.Get() +v126 := lang.Apply(v125, []any{v111, int64(2), nil}) +var v122 any = v126 +_ = v122 +var v128 any +v129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v130 := v129.FindInternedVar(lang.NewSymbol("symbol?")) +if v130.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v130))) +} +v131 := v130.Get() +v132 := lang.Apply(v131, []any{v112}) +if lang.IsTruthy(v132) { +v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v134 := v133.FindInternedVar(lang.NewSymbol("conj")) +if v134.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) +} +v135 := v134.Get() +v136 := lang.Apply(v135, []any{v109, v122, v117}) +v128 = v136 +} else { +v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v138 := v137.FindInternedVar(lang.NewSymbol("conj")) +if v138.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) +} +v139 := v138.Get() +v140 := lang.Apply(v139, []any{v109, v122, v117, v112, v122}) +v128 = v140 +} +return v128 +}) +v109 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4612), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(4615), lang.NewKeyword("end-column"), int(50)) +v110, err := lang.WithMeta(v108, v109.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v111 := lang.NewVector() +v112 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4616), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(4616), lang.NewKeyword("end-column"), int(28)) +v113, err := lang.WithMeta(v111, v112.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v115 := v114.FindInternedVar(lang.NewSymbol("map")) +if v115.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v115))) +} +v116 := v115.Get() +v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v118 := v117.FindInternedVar(lang.NewSymbol("vector")) +if v118.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) +} +v119 := v118.Get() +v120 := lang.Apply(v116, []any{v119, v91, v82, v96}) +v121 := lang.Apply(v107, []any{v110, v113, v120}) +var v104 any = v121 +_ = v104 +v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v124 := v123.FindInternedVar(lang.NewSymbol("seq")) +if v124.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) +} +v125 := v124.Get() +v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v127 := v126.FindInternedVar(lang.NewSymbol("concat")) +if v127.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) +} +v128 := v127.Get() +v129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v130 := v129.FindInternedVar(lang.NewSymbol("list")) +if v130.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v130))) +} +v131 := v130.Get() +v132 := lang.Apply(v131, []any{lang.NewSymbol("glojure.core/let")}) +v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v134 := v133.FindInternedVar(lang.NewSymbol("list")) +if v134.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) +} +v135 := v134.Get() +v136 := lang.Apply(v135, []any{v104}) +v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v138 := v137.FindInternedVar(lang.NewSymbol("list")) +if v138.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) +} +v139 := v138.Get() +v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v141 := v140.FindInternedVar(lang.NewSymbol("seq")) +if v141.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) +} +v142 := v141.Get() +v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v144 := v143.FindInternedVar(lang.NewSymbol("concat")) +if v144.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) +} +v145 := v144.Get() +v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v147 := v146.FindInternedVar(lang.NewSymbol("list")) +if v147.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) +} +v148 := v147.Get() +v149 := lang.Apply(v148, []any{lang.NewSymbol("loop*")}) +v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v151 := v150.FindInternedVar(lang.NewSymbol("list")) +if v151.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) +} +v152 := v151.Get() +v153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v154 := v153.FindInternedVar(lang.NewSymbol("vec")) +if v154.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v154))) +} +v155 := v154.Get() +v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v157 := v156.FindInternedVar(lang.NewSymbol("interleave")) +if v157.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) +} +v158 := v157.Get() +v159 := lang.Apply(v158, []any{v96, v96}) +v160 := lang.Apply(v155, []any{v159}) +v161 := lang.Apply(v152, []any{v160}) +v162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v163 := v162.FindInternedVar(lang.NewSymbol("list")) +if v163.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v163))) +} +v164 := v163.Get() +v165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v166 := v165.FindInternedVar(lang.NewSymbol("seq")) +if v166.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v166))) +} +v167 := v166.Get() +v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v169 := v168.FindInternedVar(lang.NewSymbol("concat")) +if v169.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) +} +v170 := v169.Get() +v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v172 := v171.FindInternedVar(lang.NewSymbol("list")) +if v172.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) +} +v173 := v172.Get() +v174 := lang.Apply(v173, []any{lang.NewSymbol("glojure.core/let")}) +v175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v176 := v175.FindInternedVar(lang.NewSymbol("list")) +if v176.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v176))) +} +v177 := v176.Get() +v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v179 := v178.FindInternedVar(lang.NewSymbol("vec")) +if v179.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) +} +v180 := v179.Get() +v181 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v182 := v181.FindInternedVar(lang.NewSymbol("interleave")) +if v182.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v182))) +} +v183 := v182.Get() +v184 := lang.Apply(v183, []any{v91, v96}) +v185 := lang.Apply(v180, []any{v184}) +v186 := lang.Apply(v177, []any{v185}) +v187 := lang.Apply(v170, []any{v174, v186, v6}) +v188 := lang.Apply(v167, []any{v187}) +v189 := lang.Apply(v164, []any{v188}) +v190 := lang.Apply(v145, []any{v149, v161, v189}) +v191 := lang.Apply(v142, []any{v190}) +v192 := lang.Apply(v139, []any{v191}) +v193 := lang.Apply(v128, []any{v132, v136, v192}) +v194 := lang.Apply(v125, []any{v193}) +v61 = v194 +} +return v61 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// tree-seq +{ +v0 := lang.NewSymbol("tree-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("branch?"), lang.NewSymbol("children"), lang.NewSymbol("root"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the nodes in a tree, via a depth-first walk.\n branch? must be a fn of one arg that returns true if passed a node\n that can have children (but may not). children must be a fn of one\n arg that returns a sequence of the children. Will only be called on\n nodes for which branch? returns true. Root is the root node of the\n tree.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4955), lang.NewKeyword("end-line"), int(4955))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +var v7 lang.FnFunc +{ // function walk +v7 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v9 := args[0] +var v10 lang.FnFunc +v10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("cons")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +var v14 any +v15 := lang.Apply(v3, []any{v9}) +if lang.IsTruthy(v15) { +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("mapcat")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v4, []any{v9}) +v20 := lang.Apply(v18, []any{v8, v19}) +v14 = v20 +} else { +v14 = nil +} +v21 := lang.Apply(v13, []any{v9, v14}) +return v21 +}) +v11 := lang.Apply(lang1.NewLazySeq, []any{v10}) +return v11 +}) +v8 := v7 +_ = v8 +} +v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4965), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(4969), lang.NewKeyword("end-column"), int(53)) +v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v6 any = v9 +_ = v6 +v11 := lang.Apply(v6, []any{v5}) +return v11 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// odd? +{ +v0 := lang.NewSymbol("odd?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is odd, throws an exception if n is not an integer", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1389), lang.NewKeyword("end-line"), int(1389))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("not")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("even?")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v3}) +v11 := lang.Apply(v6, []any{v10}) +return v11 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// unchecked-double +{ +var v1 lang.FnFunc +{ // function unchecked-double__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/UncheckedDoubleCast")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v3}) +v35 := lang.Apply(v26, []any{v30, v34}) +v36 := lang.Apply(v23, []any{v35}) +v37 := lang.Apply(v20, []any{v36}) +v38 := lang.Apply(v9, []any{v13, v17, v37}) +v39 := lang.Apply(v6, []any{v38}) +return v39 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("unchecked-double").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to double. Subject to rounding.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3553), lang.NewKeyword("end-line"), int(3553))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := lang.Apply(lang1.AsFloat64, []any{v4}) +return v5 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// partition +{ +v0 := lang.NewSymbol("partition").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("pad"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of lists of n items each, at offsets step\n apart. If step is not supplied, defaults to n, i.e. the partitions\n do not overlap. If a pad collection is supplied, use its elements as\n necessary to complete last partition upto n items. In case there are\n not enough padding elements, return a partition with less than n items.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3177), lang.NewKeyword("end-line"), int(3177))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("partition")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3, v3, v4}) +return v8 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +var v6 lang.FnFunc +v6 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("seq")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v5}) +var v7 any = v11 +_ = v7 +var v13 any +if lang.IsTruthy(v7) { +var v14 any = v7 +_ = v14 +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("doall")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("take")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.Apply(v22, []any{v3, v14}) +v24 := lang.Apply(v19, []any{v23}) +var v16 any = v24 +_ = v16 +var v26 any +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("=")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("count")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.Apply(v32, []any{v16}) +v34 := lang.Apply(v29, []any{v3, v33}) +if lang.IsTruthy(v34) { +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("cons")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("partition")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("nthrest")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v14, v4}) +v45 := lang.Apply(v40, []any{v3, v4, v44}) +v46 := lang.Apply(v37, []any{v16, v45}) +v26 = v46 +} else { +v26 = nil +} +v13 = v26 +} else { +v13 = nil +} +return v13 +}) +v7 := lang.Apply(lang1.NewLazySeq, []any{v6}) +return v7 + case 4: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +var v7 lang.FnFunc +v7 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("seq")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v6}) +var v8 any = v12 +_ = v8 +var v14 any +if lang.IsTruthy(v8) { +var v15 any = v8 +_ = v15 +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("doall")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("take")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v3, v15}) +v25 := lang.Apply(v20, []any{v24}) +var v17 any = v25 +_ = v17 +var v27 any +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("=")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("count")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v17}) +v35 := lang.Apply(v30, []any{v3, v34}) +if lang.IsTruthy(v35) { +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("cons")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("partition")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +} +v41 := v40.Get() +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("nthrest")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +} +v44 := v43.Get() +v45 := lang.Apply(v44, []any{v15, v4}) +v46 := lang.Apply(v41, []any{v3, v4, v5, v45}) +v47 := lang.Apply(v38, []any{v17, v46}) +v27 = v47 +} else { +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v52 := v51.FindInternedVar(lang.NewSymbol("take")) +if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) +} +v53 := v52.Get() +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("concat")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +} +v56 := v55.Get() +v57 := lang.Apply(v56, []any{v17, v5}) +v58 := lang.Apply(v53, []any{v3, v57}) +v59 := lang.Apply(v50, []any{v58}) +v27 = v59 +} +v14 = v27 +} else { +v14 = nil +} +return v14 +}) +v8 := lang.Apply(lang1.NewLazySeq, []any{v7}) +return v8 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// defn- +{ +v0 := lang.NewSymbol("defn-").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("decls"))), lang.NewKeyword("doc"), "same as defn, yielding non-public def", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4949), lang.NewKeyword("end-line"), int(4949))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("list*")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("with-meta")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("assoc")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("meta")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v5}) +v20 := lang.Apply(v15, []any{v19, lang.NewKeyword("private"), true}) +v21 := lang.Apply(v12, []any{v5, v20}) +v22 := lang.Apply(v9, []any{lang.NewSymbol("glojure.core/defn"), v21, v6}) +return v22 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// bit-set +{ +v0 := lang.NewSymbol("bit-set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Set bit at index n", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1342), lang.NewKeyword("end-line"), int(1342))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "setBit") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setBit is not a function"))) +} +v6 := lang.Apply(v5, []any{v3, v4}) +return v6 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// halt-when +{ +v0 := lang.NewSymbol("halt-when").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred")), lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("retf"))), lang.NewKeyword("doc"), "Returns a transducer that ends transduction when pred returns true\n for an input. When retf is supplied it must be a fn of 2 arguments -\n it will be passed the (completed) result so far and the input that\n triggered the predicate, and its return value (if it does not throw\n an exception) will be the return value of the transducer. If retf\n is not supplied, the input that triggered the predicate will be\n returned. If the predicate never returns true the transduction is\n unaffected.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7700), lang.NewKeyword("end-line"), int(7700))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("halt-when")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{v3, nil}) +return v7 + case 2: +v3 := args[0] +v4 := args[1] +var v5 lang.FnFunc +v5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v6 := args[0] +var v7 lang.FnFunc +v7 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v8 := lang.Apply(v6, nil) +return v8 + case 1: +v8 := args[0] +var v9 any +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("map?")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v8}) +var v10 any = v14 +_ = v10 +var v16 any +if lang.IsTruthy(v10) { +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("contains?")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v8, lang.NewKeyword("glojure.core/halt")}) +v16 = v20 +} else { +v16 = v10 +} +if lang.IsTruthy(v16) { +v10 := lang.Apply(lang.NewKeyword("glojure.core/halt"), []any{v8}) +v9 = v10 +} else { +v11 := lang.Apply(v6, []any{v8}) +v9 = v11 +} +return v9 + case 2: +v8 := args[0] +v9 := args[1] +var v10 any +v11 := lang.Apply(v3, []any{v9}) +if lang.IsTruthy(v11) { +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("reduced")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +var v15 any +if lang.IsTruthy(v4) { +v16 := lang.Apply(v6, []any{v8}) +v17 := lang.Apply(v4, []any{v16, v9}) +v15 = v17 +} else { +v15 = v9 +} +v18 := lang.NewMap(lang.NewKeyword("glojure.core/halt"), v15) +v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7721), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(7721), lang.NewKeyword("end-column"), int(72)) +v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v21 := lang.Apply(v14, []any{v20}) +v10 = v21 +} else { +v22 := lang.Apply(v6, []any{v8, v9}) +v10 = v22 +} +return v10 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7713), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7722), lang.NewKeyword("end-column"), int(34)) +v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v9 +}) +v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7712), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7722), lang.NewKeyword("end-column"), int(35)) +v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// reader-conditional +{ +v0 := lang.NewSymbol("reader-conditional").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("form"), lang.NewSymbol("splicing?"))), lang.NewKeyword("doc"), "Construct a data representation of a reader conditional.\n If true, splicing? indicates read-cond-splicing.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7835), lang.NewKeyword("end-line"), int(7835))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.Apply(nil, []any{v3, v4}) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// dosync +{ +v0 := lang.NewSymbol("dosync").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("exprs"))), lang.NewKeyword("doc"), "Runs the exprs (in an implicit do) in a transaction that encompasses\n exprs and any nested calls. Starts a transaction if none is already\n running on this thread. Any uncaught exception will abort the\n transaction and flow out of dosync. The exprs may be run more than\n once, but any effects on Refs will be atomic.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5100), lang.NewKeyword("end-line"), int(5100))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("seq")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("concat")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("list")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{lang.NewSymbol("glojure.core/sync")}) +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("list")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{nil}) +v20 := lang.Apply(v11, []any{v15, v19, v5}) +v21 := lang.Apply(v8, []any{v20}) +return v21 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// send +{ +v0 := lang.NewSymbol("send").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Dispatch an action to an agent. Returns the agent immediately.\n Subsequently, in a thread from a thread pool, the state of the agent\n will be set to the value of:\n\n (apply action-fn state-of-agent args)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2109), lang.NewKeyword("end-line"), int(2109))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("apply")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("send-via")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v8, []any{v11, nil, v3, v4, v5}) +return v12 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// refer +{ +v0 := lang.NewSymbol("refer").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns-sym"), lang.NewSymbol("&"), lang.NewSymbol("filters"))), lang.NewKeyword("doc"), "refers to all public vars of ns, subject to filters.\n filters can include at most one each of:\n\n :exclude list-of-symbols\n :only list-of-symbols\n :rename map-of-fromsymbol-tosymbol\n\n For each public interned var in the namespace named by the symbol,\n adds a mapping from the name of the var to the var to the current\n namespace. Throws an exception if name is already mapped to\n something else in the current namespace. Filters can be used to\n select a subset, via inclusion or exclusion, or to provide a mapping\n to a symbol different from the var's name, in order to prevent\n clashes. Use :use in the ns macro in preference to calling this directly.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4216), lang.NewKeyword("end-line"), int(4216))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.NewList(args[1:]...) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("find-ns")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v3}) +var v6 any = v10 +_ = v6 +var v12 any +if lang.IsTruthy(v6) { +v12 = v6 +} else { +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("str")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{"No namespace: ", v3}) +v17 := lang.Apply(errors10.New, []any{v16}) +panic(v17) +} +var v5 any = v12 +_ = v5 +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("apply")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("hash-map")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v9, []any{v12, v4}) +var v6 any = v13 +_ = v6 +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("ns-publics")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v5}) +var v14 any = v18 +_ = v14 +v21 := lang.Apply(lang.NewKeyword("rename"), []any{v6}) +var v20 any = v21 +_ = v20 +var v23 any +if lang.IsTruthy(v20) { +v23 = v20 +} else { +v24 := lang.NewMap() +v25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4236), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(4236), lang.NewKeyword("end-column"), int(36)) +v26, err := lang.WithMeta(v24, v25.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v23 = v26 +} +var v19 any = v23 +_ = v19 +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("set")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(lang.NewKeyword("exclude"), []any{v6}) +v25 := lang.Apply(v23, []any{v24}) +var v20 any = v25 +_ = v20 +var v27 any +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("=")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(lang.NewKeyword("refer"), []any{v6}) +v32 := lang.Apply(v30, []any{lang.NewKeyword("all"), v31}) +if lang.IsTruthy(v32) { +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("keys")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v14}) +v27 = v36 +} else { +v38 := lang.Apply(lang.NewKeyword("refer"), []any{v6}) +var v37 any = v38 +_ = v37 +var v40 any +if lang.IsTruthy(v37) { +v40 = v37 +} else { +v42 := lang.Apply(lang.NewKeyword("only"), []any{v6}) +var v41 any = v42 +_ = v41 +var v44 any +if lang.IsTruthy(v41) { +v44 = v41 +} else { +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("keys")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +} +v47 := v46.Get() +v48 := lang.Apply(v47, []any{v14}) +v44 = v48 +} +v40 = v44 +} +v27 = v40 +} +var v26 any = v27 +_ = v26 +var v38 any +var v39 any = v26 +_ = v39 +var v41 any +if lang.IsTruthy(v39) { +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("not")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +} +v44 := v43.Get() +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("instance?")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +} +v47 := v46.Get() +v48 := lang.Apply(v47, []any{lang1.Sequential, v26}) +v49 := lang.Apply(v44, []any{v48}) +v41 = v49 +} else { +v41 = v39 +} +if lang.IsTruthy(v41) { +v39 := lang.Apply(errors10.New, []any{":only/:refer value must be a sequential collection of symbols"}) +panic(v39) +} else { +v38 = nil +} +_ = v38 +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("seq")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v26}) +var v40 any = v44 +_ = v40 +var v45 any = nil +_ = v45 +var v46 any = int64(0) +_ = v46 +var v47 any = int64(0) +_ = v47 +var v48 any +for { +var v49 any +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("<")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +} +v52 := v51.Get() +v53 := lang.Apply(v52, []any{v47, v46}) +if lang.IsTruthy(v53) { +v55, _ := lang.FieldOrMethod(v45, "nth") +if reflect.TypeOf(v55).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) +} +v56 := lang.Apply(v55, []any{v47}) +var v54 any = v56 +_ = v54 +var v58 any +v59 := lang.Apply(v20, []any{v54}) +if lang.IsTruthy(v59) { +v58 = nil +} else { +v61 := lang.Apply(v14, []any{v54}) +var v60 any = v61 +_ = v60 +var v63 any +if lang.IsTruthy(v60) { +v63 = nil +} else { +panic("unimplemented: new with non-constant class type") +} +_ = v63 +v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v65 := v64.FindInternedVar(lang.NewSymbol("*ns*")) +if v65.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) +} +v66 := v65.Get() +v68 := lang.Apply(v19, []any{v54}) +var v67 any = v68 +_ = v67 +var v70 any +if lang.IsTruthy(v67) { +v70 = v67 +} else { +v70 = v54 +} +v67, _ := lang.FieldOrMethod(v66, "Refer") +if reflect.TypeOf(v67).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Refer is not a function"))) +} +v68 := lang.Apply(v67, []any{v70, v60}) +v58 = v68 +} +_ = v58 +var v60 any = v40 +var v61 any = v45 +var v62 any = v46 +v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v65 := v64.FindInternedVar(lang.NewSymbol("unchecked-inc")) +if v65.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) +} +v66 := v65.Get() +v67 := lang.Apply(v66, []any{v47}) +var v63 any = v67 +v40 = v60 +v45 = v61 +v46 = v62 +v47 = v63 +continue +} else { +v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v56 := v55.FindInternedVar(lang.NewSymbol("seq")) +if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) +} +v57 := v56.Get() +v58 := lang.Apply(v57, []any{v40}) +var v54 any = v58 +_ = v54 +var v60 any +if lang.IsTruthy(v54) { +var v61 any = v54 +_ = v61 +var v63 any +v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v65 := v64.FindInternedVar(lang.NewSymbol("chunked-seq?")) +if v65.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) +} +v66 := v65.Get() +v67 := lang.Apply(v66, []any{v61}) +if lang.IsTruthy(v67) { +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("chunk-first")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +} +v71 := v70.Get() +v72 := lang.Apply(v71, []any{v61}) +var v68 any = v72 +_ = v68 +v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v76 := v75.FindInternedVar(lang.NewSymbol("chunk-rest")) +if v76.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) +} +v77 := v76.Get() +v78 := lang.Apply(v77, []any{v61}) +var v74 any = v78 +var v79 any = v68 +v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v82 := v81.FindInternedVar(lang.NewSymbol("int")) +if v82.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) +} +v83 := v82.Get() +v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v85 := v84.FindInternedVar(lang.NewSymbol("count")) +if v85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) +} +v86 := v85.Get() +v87 := lang.Apply(v86, []any{v68}) +v88 := lang.Apply(v83, []any{v87}) +var v80 any = v88 +v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v91 := v90.FindInternedVar(lang.NewSymbol("int")) +if v91.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) +} +v92 := v91.Get() +v93 := lang.Apply(v92, []any{int64(0)}) +var v89 any = v93 +v40 = v74 +v45 = v79 +v46 = v80 +v47 = v89 +continue +} else { +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("first")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +} +v71 := v70.Get() +v72 := lang.Apply(v71, []any{v61}) +var v68 any = v72 +_ = v68 +var v74 any +v75 := lang.Apply(v20, []any{v68}) +if lang.IsTruthy(v75) { +v74 = nil +} else { +v77 := lang.Apply(v14, []any{v68}) +var v76 any = v77 +_ = v76 +var v79 any +if lang.IsTruthy(v76) { +v79 = nil +} else { +panic("unimplemented: new with non-constant class type") +} +_ = v79 +v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v81 := v80.FindInternedVar(lang.NewSymbol("*ns*")) +if v81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) +} +v82 := v81.Get() +v84 := lang.Apply(v19, []any{v68}) +var v83 any = v84 +_ = v83 +var v86 any +if lang.IsTruthy(v83) { +v86 = v83 +} else { +v86 = v68 +} +v83, _ := lang.FieldOrMethod(v82, "Refer") +if reflect.TypeOf(v83).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Refer is not a function"))) +} +v84 := lang.Apply(v83, []any{v86, v76}) +v74 = v84 +} +_ = v74 +v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v78 := v77.FindInternedVar(lang.NewSymbol("next")) +if v78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) +} +v79 := v78.Get() +v80 := lang.Apply(v79, []any{v61}) +var v76 any = v80 +var v81 any = nil +var v82 any = int64(0) +var v83 any = int64(0) +v40 = v76 +v45 = v81 +v46 = v82 +v47 = v83 +continue +} +v60 = v63 +} else { +v60 = nil +} +v49 = v60 +} +v48 = v49 + break +} +return v48 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// >= +{ +var v1 lang.FnFunc +{ // function >=__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("concat")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("list")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("seq")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("concat")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("list")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/gte")}) +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v4}) +v40 := lang.Apply(v27, []any{v31, v35, v39}) +v41 := lang.Apply(v24, []any{v40}) +v42 := lang.Apply(v21, []any{v41}) +v43 := lang.Apply(v10, []any{v14, v18, v42}) +v44 := lang.Apply(v7, []any{v43}) +return v44 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol(">=").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns non-nil if nums are in monotonically non-increasing order,\n otherwise false.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1078), lang.NewKeyword("end-line"), int(1078))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v4 := args[0] +return true + case 2: +v4 := args[0] +v5 := args[1] +v6, _ := lang.FieldOrMethod(lang1.Numbers, "gte") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("gte is not a function"))) +} +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := args[1] +v6 := lang.NewList(args[2:]...) +recur_loop_202: +var v7 any +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol(">=")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v4, v5}) +if lang.IsTruthy(v11) { +var v12 any +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("next")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v6}) +if lang.IsTruthy(v16) { +var v17 any = v5 +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("first")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v6}) +var v18 any = v22 +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("next")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v6}) +var v23 any = v27 +v4 = v17 +v5 = v18 +v6 = v23 +goto recur_loop_202 +} else { +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol(">=")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("first")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v6}) +v35 := lang.Apply(v30, []any{v5, v34}) +v12 = v35 +} +v7 = v12 +} else { +v7 = false +} +return v7 + } +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// unchecked-dec-int +{ +var v1 lang.FnFunc +{ // function unchecked-dec-int__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/unchecked_int_dec")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v3}) +v35 := lang.Apply(v26, []any{v30, v34}) +v36 := lang.Apply(v23, []any{v35}) +v37 := lang.Apply(v20, []any{v36}) +v38 := lang.Apply(v9, []any{v13, v17, v37}) +v39 := lang.Apply(v6, []any{v38}) +return v39 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("unchecked-dec-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns a number one less than x, an int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1168), lang.NewKeyword("end-line"), int(1168))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "unchecked_int_dec") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_dec is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// array +{ +v0 := lang.NewSymbol("array").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3457), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3458), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("items"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.NewList(args[0:]...) +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("into-array")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{v3}) +return v7 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// let +{ +v0 := lang.NewSymbol("let").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "binding => binding-form init-expr\n binding-form => name, or destructuring-form\n destructuring-form => map-destructure-form, or seq-destructure-form\n\n Evaluates the exprs in a lexical context in which the symbols in\n the binding-forms are bound to their respective init-exprs or parts\n therein.\n\n See https://glojure.org/reference/special_forms#binding-forms for\n more information about destructuring.", lang.NewKeyword("forms"), lang.NewVector(lang.NewList(lang.NewSymbol("let"), lang.NewVector(lang.NewSymbol("bindings*")), lang.NewSymbol("exprs*"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4496), lang.NewKeyword("end-line"), int(4496), lang.NewKeyword("special-form"), true)).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +var v7 any +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v5}) +if lang.IsTruthy(v11) { +v7 = nil +} else { +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("str")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("first")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v3}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("meta")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v3}) +v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) +v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) +v28 := lang.Apply(lang1.NewIllegalArgumentError, []any{v27}) +panic(v28) +} +_ = v7 +var v29 any +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("even?")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("count")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v5}) +v37 := lang.Apply(v32, []any{v36}) +if lang.IsTruthy(v37) { +v29 = nil +} else { +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("str")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("first")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v3}) +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +} +v47 := v46.Get() +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("meta")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v3}) +v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) +v53 := lang.Apply(v40, []any{v44, " requires ", "an even number of forms in binding vector", " in ", v47, ":", v52}) +v54 := lang.Apply(lang1.NewIllegalArgumentError, []any{v53}) +panic(v54) +} +_ = v29 +_ = nil +v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v56 := v55.FindInternedVar(lang.NewSymbol("seq")) +if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) +} +v57 := v56.Get() +v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v59 := v58.FindInternedVar(lang.NewSymbol("concat")) +if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) +} +v60 := v59.Get() +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("list")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +} +v63 := v62.Get() +v64 := lang.Apply(v63, []any{lang.NewSymbol("let*")}) +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("list")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +} +v67 := v66.Get() +v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v69 := v68.FindInternedVar(lang.NewSymbol("destructure")) +if v69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) +} +v70 := v69.Get() +v71 := lang.Apply(v70, []any{v5}) +v72 := lang.Apply(v67, []any{v71}) +v73 := lang.Apply(v60, []any{v64, v72, v6}) +v74 := lang.Apply(v57, []any{v73}) +return v74 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// not-empty +{ +v0 := lang.NewSymbol("not-empty").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "If coll is empty, returns nil, else coll", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5559), lang.NewKeyword("end-line"), int(5559))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +if lang.IsTruthy(v8) { +v4 = v3 +} else { +v4 = nil +} +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// and +{ +v0 := lang.NewSymbol("and").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("next"))), lang.NewKeyword("doc"), "Evaluates exprs one at a time, from left to right. If a form\n returns logical false (nil or false), and returns that value and\n doesn't evaluate any of the other expressions, otherwise it returns\n the value of the last expr. (and) returns true.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(835), lang.NewKeyword("end-line"), int(835))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v3 := args[0] +v4 := args[1] +return true + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +return v5 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("seq")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("concat")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("list")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/let")}) +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("list")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("apply")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("vector")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("seq")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("concat")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{lang.NewSymbol("and__0__auto__")}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v5}) +v40 := lang.Apply(v31, []any{v35, v39}) +v41 := lang.Apply(v28, []any{v40}) +v42 := lang.Apply(v22, []any{v25, v41}) +v43 := lang.Apply(v19, []any{v42}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("seq")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +} +v49 := v48.Get() +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("concat")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +} +v52 := v51.Get() +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("list")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +} +v55 := v54.Get() +v56 := lang.Apply(v55, []any{lang.NewSymbol("if")}) +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("list")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +} +v59 := v58.Get() +v60 := lang.Apply(v59, []any{lang.NewSymbol("and__0__auto__")}) +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("list")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +} +v63 := v62.Get() +v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v65 := v64.FindInternedVar(lang.NewSymbol("seq")) +if v65.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) +} +v66 := v65.Get() +v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v68 := v67.FindInternedVar(lang.NewSymbol("concat")) +if v68.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) +} +v69 := v68.Get() +v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v71 := v70.FindInternedVar(lang.NewSymbol("list")) +if v71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) +} +v72 := v71.Get() +v73 := lang.Apply(v72, []any{lang.NewSymbol("glojure.core/and")}) +v74 := lang.Apply(v69, []any{v73, v6}) +v75 := lang.Apply(v66, []any{v74}) +v76 := lang.Apply(v63, []any{v75}) +v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v78 := v77.FindInternedVar(lang.NewSymbol("list")) +if v78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) +} +v79 := v78.Get() +v80 := lang.Apply(v79, []any{lang.NewSymbol("and__0__auto__")}) +v81 := lang.Apply(v52, []any{v56, v60, v76, v80}) +v82 := lang.Apply(v49, []any{v81}) +v83 := lang.Apply(v46, []any{v82}) +v84 := lang.Apply(v12, []any{v16, v43, v83}) +v85 := lang.Apply(v9, []any{v84}) +return v85 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// shuffle +{ +v0 := lang.NewSymbol("shuffle").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return a random permutation of coll", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7343), lang.NewKeyword("end-line"), int(7343))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v5 := lang.Apply(java.util.ArrayList27., []any{v3}) +var v4 any = v5 +_ = v4 +v7 := lang.Apply(nil, []any{v4}) +_ = v7 +v8, ok := lang.FieldOrMethod(v4, "toArray") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "toArray"))) +} +var v9 any +switch reflect.TypeOf(v8).Kind() { +case reflect.Func: + v9 = lang.Apply(v8, nil) +default: + v9 = v8 +} +v10 := lang.Apply(nil, []any{v9}) +return v10 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// every-pred +{ +v0 := lang.NewSymbol("every-pred").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("p")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2"), lang.NewSymbol("p3")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2"), lang.NewSymbol("p3"), lang.NewSymbol("&"), lang.NewSymbol("ps"))), lang.NewKeyword("doc"), "Takes a set of predicates and returns a function f that returns true if all of its\n composing predicates return a logical true value against all of its arguments, else it returns\n false. Note that f is short-circuiting in that it will stop execution on the first\n argument that triggers a logical false result against the original predicates.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7465), lang.NewKeyword("end-line"), int(7465))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +var v4 lang.FnFunc +{ // function ep1 +v4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +return true + case 1: +v6 := args[0] +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("boolean")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v3, []any{v6}) +v11 := lang.Apply(v9, []any{v10}) +return v11 + case 2: +v6 := args[0] +v7 := args[1] +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("boolean")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v12 := lang.Apply(v3, []any{v6}) +var v11 any = v12 +_ = v11 +var v14 any +if lang.IsTruthy(v11) { +v15 := lang.Apply(v3, []any{v7}) +v14 = v15 +} else { +v14 = v11 +} +v11 := lang.Apply(v10, []any{v14}) +return v11 + case 3: +v6 := args[0] +v7 := args[1] +v8 := args[2] +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("boolean")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v13 := lang.Apply(v3, []any{v6}) +var v12 any = v13 +_ = v12 +var v15 any +if lang.IsTruthy(v12) { +v17 := lang.Apply(v3, []any{v7}) +var v16 any = v17 +_ = v16 +var v19 any +if lang.IsTruthy(v16) { +v20 := lang.Apply(v3, []any{v8}) +v19 = v20 +} else { +v19 = v16 +} +v15 = v19 +} else { +v15 = v12 +} +v12 := lang.Apply(v11, []any{v15}) +return v12 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v6 := args[0] +v7 := args[1] +v8 := args[2] +v9 := lang.NewList(args[3:]...) +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("boolean")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v14 := lang.Apply(v5, []any{v6, v7, v8}) +var v13 any = v14 +_ = v13 +var v16 any +if lang.IsTruthy(v13) { +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("every?")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v3, v9}) +v16 = v20 +} else { +v16 = v13 +} +v13 := lang.Apply(v12, []any{v16}) +return v13 + } +}) +v5 := v4 +_ = v5 +} +v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7472), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7478), lang.NewKeyword("end-column"), int(56)) +v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v6 + case 2: +v3 := args[0] +v4 := args[1] +var v5 lang.FnFunc +{ // function ep2 +v5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +return true + case 1: +v7 := args[0] +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("boolean")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v12 := lang.Apply(v3, []any{v7}) +var v11 any = v12 +_ = v11 +var v14 any +if lang.IsTruthy(v11) { +v15 := lang.Apply(v4, []any{v7}) +v14 = v15 +} else { +v14 = v11 +} +v11 := lang.Apply(v10, []any{v14}) +return v11 + case 2: +v7 := args[0] +v8 := args[1] +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("boolean")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v13 := lang.Apply(v3, []any{v7}) +var v12 any = v13 +_ = v12 +var v15 any +if lang.IsTruthy(v12) { +v17 := lang.Apply(v3, []any{v8}) +var v16 any = v17 +_ = v16 +var v19 any +if lang.IsTruthy(v16) { +v21 := lang.Apply(v4, []any{v7}) +var v20 any = v21 +_ = v20 +var v23 any +if lang.IsTruthy(v20) { +v24 := lang.Apply(v4, []any{v8}) +v23 = v24 +} else { +v23 = v20 +} +v19 = v23 +} else { +v19 = v16 +} +v15 = v19 +} else { +v15 = v12 +} +v12 := lang.Apply(v11, []any{v15}) +return v12 + case 3: +v7 := args[0] +v8 := args[1] +v9 := args[2] +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("boolean")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v14 := lang.Apply(v3, []any{v7}) +var v13 any = v14 +_ = v13 +var v16 any +if lang.IsTruthy(v13) { +v18 := lang.Apply(v3, []any{v8}) +var v17 any = v18 +_ = v17 +var v20 any +if lang.IsTruthy(v17) { +v22 := lang.Apply(v3, []any{v9}) +var v21 any = v22 +_ = v21 +var v24 any +if lang.IsTruthy(v21) { +v26 := lang.Apply(v4, []any{v7}) +var v25 any = v26 +_ = v25 +var v28 any +if lang.IsTruthy(v25) { +v30 := lang.Apply(v4, []any{v8}) +var v29 any = v30 +_ = v29 +var v32 any +if lang.IsTruthy(v29) { +v33 := lang.Apply(v4, []any{v9}) +v32 = v33 +} else { +v32 = v29 +} +v28 = v32 +} else { +v28 = v25 +} +v24 = v28 +} else { +v24 = v21 +} +v20 = v24 +} else { +v20 = v17 +} +v16 = v20 +} else { +v16 = v13 +} +v13 := lang.Apply(v12, []any{v16}) +return v13 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v7 := args[0] +v8 := args[1] +v9 := args[2] +v10 := lang.NewList(args[3:]...) +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("boolean")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v15 := lang.Apply(v6, []any{v7, v8, v9}) +var v14 any = v15 +_ = v14 +var v17 any +if lang.IsTruthy(v14) { +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("every?")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +var v21 lang.FnFunc +v21 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v22 := args[0] +v24 := lang.Apply(v3, []any{v22}) +var v23 any = v24 +_ = v23 +var v26 any +if lang.IsTruthy(v23) { +v27 := lang.Apply(v4, []any{v22}) +v26 = v27 +} else { +v26 = v23 +} +return v26 +}) +v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7486), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(7486), lang.NewKeyword("end-column"), int(65)) +v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v24 := lang.Apply(v20, []any{v23, v10}) +v17 = v24 +} else { +v17 = v14 +} +v14 := lang.Apply(v13, []any{v17}) +return v14 + } +}) +v6 := v5 +_ = v6 +} +v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7480), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7486), lang.NewKeyword("end-column"), int(75)) +v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v7 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +var v6 lang.FnFunc +{ // function ep3 +v6 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +return true + case 1: +v8 := args[0] +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("boolean")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v13 := lang.Apply(v3, []any{v8}) +var v12 any = v13 +_ = v12 +var v15 any +if lang.IsTruthy(v12) { +v17 := lang.Apply(v4, []any{v8}) +var v16 any = v17 +_ = v16 +var v19 any +if lang.IsTruthy(v16) { +v20 := lang.Apply(v5, []any{v8}) +v19 = v20 +} else { +v19 = v16 +} +v15 = v19 +} else { +v15 = v12 +} +v12 := lang.Apply(v11, []any{v15}) +return v12 + case 2: +v8 := args[0] +v9 := args[1] +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("boolean")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v14 := lang.Apply(v3, []any{v8}) +var v13 any = v14 +_ = v13 +var v16 any +if lang.IsTruthy(v13) { +v18 := lang.Apply(v3, []any{v9}) +var v17 any = v18 +_ = v17 +var v20 any +if lang.IsTruthy(v17) { +v22 := lang.Apply(v4, []any{v8}) +var v21 any = v22 +_ = v21 +var v24 any +if lang.IsTruthy(v21) { +v26 := lang.Apply(v4, []any{v9}) +var v25 any = v26 +_ = v25 +var v28 any +if lang.IsTruthy(v25) { +v30 := lang.Apply(v5, []any{v8}) +var v29 any = v30 +_ = v29 +var v32 any +if lang.IsTruthy(v29) { +v33 := lang.Apply(v5, []any{v9}) +v32 = v33 +} else { +v32 = v29 +} +v28 = v32 +} else { +v28 = v25 +} +v24 = v28 +} else { +v24 = v21 +} +v20 = v24 +} else { +v20 = v17 +} +v16 = v20 +} else { +v16 = v13 +} +v13 := lang.Apply(v12, []any{v16}) +return v13 + case 3: +v8 := args[0] +v9 := args[1] +v10 := args[2] +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("boolean")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v15 := lang.Apply(v3, []any{v8}) +var v14 any = v15 +_ = v14 +var v17 any +if lang.IsTruthy(v14) { +v19 := lang.Apply(v3, []any{v9}) +var v18 any = v19 +_ = v18 +var v21 any +if lang.IsTruthy(v18) { +v23 := lang.Apply(v3, []any{v10}) +var v22 any = v23 +_ = v22 +var v25 any +if lang.IsTruthy(v22) { +v27 := lang.Apply(v4, []any{v8}) +var v26 any = v27 +_ = v26 +var v29 any +if lang.IsTruthy(v26) { +v31 := lang.Apply(v4, []any{v9}) +var v30 any = v31 +_ = v30 +var v33 any +if lang.IsTruthy(v30) { +v35 := lang.Apply(v4, []any{v10}) +var v34 any = v35 +_ = v34 +var v37 any +if lang.IsTruthy(v34) { +v39 := lang.Apply(v5, []any{v8}) +var v38 any = v39 +_ = v38 +var v41 any +if lang.IsTruthy(v38) { +v43 := lang.Apply(v5, []any{v9}) +var v42 any = v43 +_ = v42 +var v45 any +if lang.IsTruthy(v42) { +v46 := lang.Apply(v5, []any{v10}) +v45 = v46 +} else { +v45 = v42 +} +v41 = v45 +} else { +v41 = v38 +} +v37 = v41 +} else { +v37 = v34 +} +v33 = v37 +} else { +v33 = v30 +} +v29 = v33 +} else { +v29 = v26 +} +v25 = v29 +} else { +v25 = v22 +} +v21 = v25 +} else { +v21 = v18 +} +v17 = v21 +} else { +v17 = v14 +} +v14 := lang.Apply(v13, []any{v17}) +return v14 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v8 := args[0] +v9 := args[1] +v10 := args[2] +v11 := lang.NewList(args[3:]...) +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("boolean")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v16 := lang.Apply(v7, []any{v8, v9, v10}) +var v15 any = v16 +_ = v15 +var v18 any +if lang.IsTruthy(v15) { +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("every?")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +var v22 lang.FnFunc +v22 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v23 := args[0] +v25 := lang.Apply(v3, []any{v23}) +var v24 any = v25 +_ = v24 +var v27 any +if lang.IsTruthy(v24) { +v29 := lang.Apply(v4, []any{v23}) +var v28 any = v29 +_ = v28 +var v31 any +if lang.IsTruthy(v28) { +v32 := lang.Apply(v5, []any{v23}) +v31 = v32 +} else { +v31 = v28 +} +v27 = v31 +} else { +v27 = v24 +} +return v27 +}) +v23 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7494), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(7494), lang.NewKeyword("end-column"), int(72)) +v24, err := lang.WithMeta(v22, v23.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v25 := lang.Apply(v21, []any{v24, v11}) +v18 = v25 +} else { +v18 = v15 +} +v15 := lang.Apply(v14, []any{v18}) +return v15 + } +}) +v7 := v6 +_ = v7 +} +v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7488), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7494), lang.NewKeyword("end-column"), int(82)) +v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v8 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("list*")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v3, v4, v5, v7}) +var v7 any = v11 +_ = v7 +var v13 lang.FnFunc +{ // function epn +v13 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +return true + case 1: +v15 := args[0] +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("every?")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +var v19 lang.FnFunc +v19 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v20 := args[0] +v21 := lang.Apply(v20, []any{v15}) +return v21 +}) +v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7499), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(7499), lang.NewKeyword("end-column"), int(28)) +v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v22 := lang.Apply(v18, []any{v21, v7}) +return v22 + case 2: +v15 := args[0] +v16 := args[1] +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("every?")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +var v20 lang.FnFunc +v20 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v21 := args[0] +v23 := lang.Apply(v21, []any{v15}) +var v22 any = v23 +_ = v22 +var v25 any +if lang.IsTruthy(v22) { +v26 := lang.Apply(v21, []any{v16}) +v25 = v26 +} else { +v25 = v22 +} +return v25 +}) +v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7500), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7500), lang.NewKeyword("end-column"), int(42)) +v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v23 := lang.Apply(v19, []any{v22, v7}) +return v23 + case 3: +v15 := args[0] +v16 := args[1] +v17 := args[2] +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("every?")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +var v21 lang.FnFunc +v21 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v22 := args[0] +v24 := lang.Apply(v22, []any{v15}) +var v23 any = v24 +_ = v23 +var v26 any +if lang.IsTruthy(v23) { +v28 := lang.Apply(v22, []any{v16}) +var v27 any = v28 +_ = v27 +var v30 any +if lang.IsTruthy(v27) { +v31 := lang.Apply(v22, []any{v17}) +v30 = v31 +} else { +v30 = v27 +} +v26 = v30 +} else { +v26 = v23 +} +return v26 +}) +v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7501), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(7501), lang.NewKeyword("end-column"), int(50)) +v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v24 := lang.Apply(v20, []any{v23, v7}) +return v24 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v15 := args[0] +v16 := args[1] +v17 := args[2] +v18 := lang.NewList(args[3:]...) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("boolean")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v23 := lang.Apply(v14, []any{v15, v16, v17}) +var v22 any = v23 +_ = v22 +var v25 any +if lang.IsTruthy(v22) { +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("every?")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +var v29 lang.FnFunc +v29 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v30 := args[0] +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("every?")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v30, v18}) +return v34 +}) +v30 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7503), lang.NewKeyword("column"), int(48), lang.NewKeyword("end-line"), int(7503), lang.NewKeyword("end-column"), int(63)) +v31, err := lang.WithMeta(v29, v30.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v32 := lang.Apply(v28, []any{v31, v7}) +v25 = v32 +} else { +v25 = v22 +} +v22 := lang.Apply(v21, []any{v25}) +return v22 + } +}) +v14 := v13 +_ = v14 +} +v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7497), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7503), lang.NewKeyword("end-column"), int(71)) +v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v15 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// compare-and-set! +{ +v0 := lang.NewSymbol("compare-and-set!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atom"), lang.NewSymbol("oldval"), lang.NewSymbol("newval"))), lang.NewKeyword("doc"), "Atomically sets the value of atom to newval if and only if the\n current value of the atom is identical to oldval. Returns true if\n set happened, else false", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2360), lang.NewKeyword("end-line"), int(2360))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6, _ := lang.FieldOrMethod(v3, "compareAndSet") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("compareAndSet is not a function"))) +} +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// with-precision +{ +v0 := lang.NewSymbol("with-precision").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("precision"), lang.NewSymbol("&"), lang.NewSymbol("exprs"))), lang.NewKeyword("doc"), "Sets the precision and rounding mode to be used for BigDecimal operations.\n\n Usage: (with-precision 10 (/ 1M 3))\n or: (with-precision 10 :rounding HALF_DOWN (/ 1M 3))\n\n The rounding mode is one of CEILING, FLOOR, HALF_UP, HALF_DOWN,\n HALF_EVEN, UP, DOWN and UNNECESSARY; it defaults to HALF_UP.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5110), lang.NewKeyword("end-line"), int(5110))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +var v8 any +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("=")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("first")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v6}) +v16 := lang.Apply(v11, []any{v15, lang.NewKeyword("rounding")}) +if lang.IsTruthy(v16) { +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("next")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("next")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.Apply(v22, []any{v6}) +v24 := lang.Apply(v19, []any{v23}) +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("seq")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("concat")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{lang.NewSymbol(".")}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{lang.NewSymbol("java.math.RoundingMode")}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v52 := v51.FindInternedVar(lang.NewSymbol("second")) +if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) +} +v53 := v52.Get() +v54 := lang.Apply(v53, []any{v6}) +v55 := lang.Apply(v50, []any{v54}) +v56 := lang.Apply(v39, []any{v43, v47, v55}) +v57 := lang.Apply(v36, []any{v56}) +v58 := lang.Apply(v33, []any{v57}) +v59 := lang.Apply(v30, []any{v58}) +v60 := lang.Apply(v27, []any{v59}) +v61 := lang.NewVector(v24, v60) +v62 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5121), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(5122), lang.NewKeyword("end-column"), int(69)) +v63, err := lang.WithMeta(v61, v62.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v8 = v63 +} else { +v64 := lang.NewVector(v6, nil) +v65 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5123), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(5123), lang.NewKeyword("end-column"), int(33)) +v66, err := lang.WithMeta(v64, v65.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v8 = v66 +} +var v7 any = v8 +_ = v7 +v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v69 := v68.FindInternedVar(lang.NewSymbol("nth")) +if v69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) +} +v70 := v69.Get() +v71 := lang.Apply(v70, []any{v7, int64(0), nil}) +var v67 any = v71 +_ = v67 +v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v74 := v73.FindInternedVar(lang.NewSymbol("nth")) +if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) +} +v75 := v74.Get() +v76 := lang.Apply(v75, []any{v7, int64(1), nil}) +var v72 any = v76 +_ = v72 +v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v79 := v78.FindInternedVar(lang.NewSymbol("seq")) +if v79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) +} +v80 := v79.Get() +v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v82 := v81.FindInternedVar(lang.NewSymbol("concat")) +if v82.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) +} +v83 := v82.Get() +v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v85 := v84.FindInternedVar(lang.NewSymbol("list")) +if v85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) +} +v86 := v85.Get() +v87 := lang.Apply(v86, []any{lang.NewSymbol("glojure.core/binding")}) +v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v89 := v88.FindInternedVar(lang.NewSymbol("list")) +if v89.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) +} +v90 := v89.Get() +v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v92 := v91.FindInternedVar(lang.NewSymbol("apply")) +if v92.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) +} +v93 := v92.Get() +v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v95 := v94.FindInternedVar(lang.NewSymbol("vector")) +if v95.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) +} +v96 := v95.Get() +v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v98 := v97.FindInternedVar(lang.NewSymbol("seq")) +if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) +} +v99 := v98.Get() +v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v101 := v100.FindInternedVar(lang.NewSymbol("concat")) +if v101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) +} +v102 := v101.Get() +v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v104 := v103.FindInternedVar(lang.NewSymbol("list")) +if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) +} +v105 := v104.Get() +v106 := lang.Apply(v105, []any{lang.NewSymbol("glojure.core/*math-context*")}) +v107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v108 := v107.FindInternedVar(lang.NewSymbol("list")) +if v108.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v108))) +} +v109 := v108.Get() +v110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v111 := v110.FindInternedVar(lang.NewSymbol("seq")) +if v111.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v111))) +} +v112 := v111.Get() +v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v114 := v113.FindInternedVar(lang.NewSymbol("concat")) +if v114.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) +} +v115 := v114.Get() +v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v117 := v116.FindInternedVar(lang.NewSymbol("list")) +if v117.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) +} +v118 := v117.Get() +v119 := lang.Apply(v118, []any{lang.NewSymbol("java.math.MathContext.")}) +v120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v121 := v120.FindInternedVar(lang.NewSymbol("list")) +if v121.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v121))) +} +v122 := v121.Get() +v123 := lang.Apply(v122, []any{v5}) +v124 := lang.Apply(v115, []any{v119, v123, v72}) +v125 := lang.Apply(v112, []any{v124}) +v126 := lang.Apply(v109, []any{v125}) +v127 := lang.Apply(v102, []any{v106, v126}) +v128 := lang.Apply(v99, []any{v127}) +v129 := lang.Apply(v93, []any{v96, v128}) +v130 := lang.Apply(v90, []any{v129}) +v131 := lang.Apply(v83, []any{v87, v130, v67}) +v132 := lang.Apply(v80, []any{v131}) +return v132 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// transduce +{ +v0 := lang.NewSymbol("transduce").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "reduce with a transformation of f (xf). If init is not\n supplied, (f) will be called to produce it. f should be a reducing\n step function that accepts both 1 and 2 arguments, if it accepts\n only 2 you can add the arity-1 with 'completing'. Returns the result\n of applying (the transformed) xf to init and the first item in coll,\n then applying xf to that result and the 2nd item, etc. If coll\n contains no items, returns init and f is not called. Note that\n certain transforms may inject or skip items.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6948), lang.NewKeyword("end-line"), int(6948))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("transduce")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v4, nil) +v10 := lang.Apply(v8, []any{v3, v4, v9, v5}) +return v10 + case 4: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v8 := lang.Apply(v3, []any{v7}) +var v7 any = v8 +_ = v7 +var v10 any +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("instance?")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{lang1.IReduceInit, v6}) +if lang.IsTruthy(v14) { +v15, _ := lang.FieldOrMethod(v6, "ReduceInit") +if reflect.TypeOf(v15).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) +} +v16 := lang.Apply(v15, []any{v7, v5}) +v10 = v16 +} else { +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core.protocols")) +v18 := v17.FindInternedVar(lang.NewSymbol("coll-reduce")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v6, v7, v5}) +v10 = v20 +} +var v9 any = v10 +_ = v9 +v22 := lang.Apply(v7, []any{v9}) +return v22 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// parents +{ +v0 := lang.NewSymbol("parents").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"))), lang.NewKeyword("doc"), "Returns the immediate parents of tag, either via a Java type\n inheritance relationship or a relationship established via derive. h\n must be a hierarchy obtained from make-hierarchy, if not supplied\n defaults to the global hierarchy", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5607), lang.NewKeyword("end-line"), int(5607))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("parents")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("global-hierarchy")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v6, []any{v9, v3}) +return v10 + case 2: +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("not-empty")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("get")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(lang.NewKeyword("parents"), []any{v3}) +v13 := lang.Apply(v11, []any{v12, v4}) +var v8 any = v13 +_ = v8 +var v15 any +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("class?")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v4}) +if lang.IsTruthy(v19) { +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("into1")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("set")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("bases")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.Apply(v28, []any{v4}) +v30 := lang.Apply(v25, []any{v29}) +v31 := lang.Apply(v22, []any{v30, v8}) +v15 = v31 +} else { +v15 = v8 +} +v8 := lang.Apply(v7, []any{v15}) +return v8 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// random-uuid +{ +v0 := lang.NewSymbol("random-uuid").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Returns a pseudo-randomly generated java.util.UUID instance (i.e. type 4).\n\n See: https://docs.oracle.com/javase/8/docs/api/java/util/UUID.html#randomUUID--", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6895), lang.NewKeyword("end-line"), int(6895))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.Apply(nil, nil) +return v3 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// juxt +{ +v0 := lang.NewSymbol("juxt").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("g")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("g"), lang.NewSymbol("h")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("g"), lang.NewSymbol("h"), lang.NewSymbol("&"), lang.NewSymbol("fs"))), lang.NewKeyword("doc"), "Takes a set of functions and returns a fn that is the juxtaposition\n of those fns. The returned fn takes a variable number of args, and\n returns a vector containing the result of applying each fn to the\n args (left-to-right).\n ((juxt a b c) x) => [(a x) (b x) (c x)]", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2568), lang.NewKeyword("end-line"), int(2568))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v5 := lang.Apply(v3, nil) +v6 := lang.NewVector(v5) +v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2578), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(2578), lang.NewKeyword("end-column"), int(16)) +v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v8 + case 1: +v5 := args[0] +v6 := lang.Apply(v3, []any{v5}) +v7 := lang.NewVector(v6) +v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2579), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(2579), lang.NewKeyword("end-column"), int(19)) +v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v9 + case 2: +v5 := args[0] +v6 := args[1] +v7 := lang.Apply(v3, []any{v5, v6}) +v8 := lang.NewVector(v7) +v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2580), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(2580), lang.NewKeyword("end-column"), int(23)) +v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v10 + case 3: +v5 := args[0] +v6 := args[1] +v7 := args[2] +v8 := lang.Apply(v3, []any{v5, v6, v7}) +v9 := lang.NewVector(v8) +v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2581), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(2581), lang.NewKeyword("end-column"), int(27)) +v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v11 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +v6 := args[1] +v7 := args[2] +v8 := lang.NewList(args[3:]...) +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("apply")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v3, v5, v6, v7, v8}) +v13 := lang.NewVector(v12) +v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2582), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(2582), lang.NewKeyword("end-column"), int(45)) +v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v15 + } +}) +v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2577), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2582), lang.NewKeyword("end-column"), int(47)) +v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v6 + case 2: +v3 := args[0] +v4 := args[1] +var v5 lang.FnFunc +v5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v6 := lang.Apply(v3, nil) +v7 := lang.Apply(v4, nil) +v8 := lang.NewVector(v6, v7) +v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2585), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(2585), lang.NewKeyword("end-column"), int(20)) +v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v10 + case 1: +v6 := args[0] +v7 := lang.Apply(v3, []any{v6}) +v8 := lang.Apply(v4, []any{v6}) +v9 := lang.NewVector(v7, v8) +v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2586), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(2586), lang.NewKeyword("end-column"), int(25)) +v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v11 + case 2: +v6 := args[0] +v7 := args[1] +v8 := lang.Apply(v3, []any{v6, v7}) +v9 := lang.Apply(v4, []any{v6, v7}) +v10 := lang.NewVector(v8, v9) +v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2587), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(2587), lang.NewKeyword("end-column"), int(31)) +v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v12 + case 3: +v6 := args[0] +v7 := args[1] +v8 := args[2] +v9 := lang.Apply(v3, []any{v6, v7, v8}) +v10 := lang.Apply(v4, []any{v6, v7, v8}) +v11 := lang.NewVector(v9, v10) +v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2588), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(2588), lang.NewKeyword("end-column"), int(37)) +v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v13 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v6 := args[0] +v7 := args[1] +v8 := args[2] +v9 := lang.NewList(args[3:]...) +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("apply")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{v3, v6, v7, v8, v9}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("apply")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v4, v6, v7, v8, v9}) +v18 := lang.NewVector(v13, v17) +v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2589), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(2589), lang.NewKeyword("end-column"), int(66)) +v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v20 + } +}) +v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2584), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2589), lang.NewKeyword("end-column"), int(68)) +v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v7 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +var v6 lang.FnFunc +v6 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v7 := lang.Apply(v3, nil) +v8 := lang.Apply(v4, nil) +v9 := lang.Apply(v5, nil) +v10 := lang.NewVector(v7, v8, v9) +v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2592), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(2592), lang.NewKeyword("end-column"), int(24)) +v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v12 + case 1: +v7 := args[0] +v8 := lang.Apply(v3, []any{v7}) +v9 := lang.Apply(v4, []any{v7}) +v10 := lang.Apply(v5, []any{v7}) +v11 := lang.NewVector(v8, v9, v10) +v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2593), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(2593), lang.NewKeyword("end-column"), int(31)) +v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v13 + case 2: +v7 := args[0] +v8 := args[1] +v9 := lang.Apply(v3, []any{v7, v8}) +v10 := lang.Apply(v4, []any{v7, v8}) +v11 := lang.Apply(v5, []any{v7, v8}) +v12 := lang.NewVector(v9, v10, v11) +v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2594), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(2594), lang.NewKeyword("end-column"), int(39)) +v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v14 + case 3: +v7 := args[0] +v8 := args[1] +v9 := args[2] +v10 := lang.Apply(v3, []any{v7, v8, v9}) +v11 := lang.Apply(v4, []any{v7, v8, v9}) +v12 := lang.Apply(v5, []any{v7, v8, v9}) +v13 := lang.NewVector(v10, v11, v12) +v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2595), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(2595), lang.NewKeyword("end-column"), int(47)) +v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v15 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v7 := args[0] +v8 := args[1] +v9 := args[2] +v10 := lang.NewList(args[3:]...) +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("apply")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v3, v7, v8, v9, v10}) +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("apply")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v4, v7, v8, v9, v10}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("apply")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v5, v7, v8, v9, v10}) +v23 := lang.NewVector(v14, v18, v22) +v24 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2596), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(2596), lang.NewKeyword("end-column"), int(87)) +v25, err := lang.WithMeta(v23, v24.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v25 + } +}) +v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2591), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2596), lang.NewKeyword("end-column"), int(89)) +v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v8 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("list*")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v3, v4, v5, v7}) +var v7 any = v11 +_ = v7 +var v13 lang.FnFunc +v13 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("reduce1")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +var v17 lang.FnFunc +v17 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v18 := args[0] +v19 := args[1] +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("conj")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.Apply(v19, nil) +v24 := lang.Apply(v22, []any{v18, v23}) +return v24 +}) +v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2600), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(2600), lang.NewKeyword("end-column"), int(37)) +v19, err := lang.WithMeta(v17, v18.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v20 := lang.NewVector() +v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2600), lang.NewKeyword("column"), int(39), lang.NewKeyword("end-line"), int(2600), lang.NewKeyword("end-column"), int(40)) +v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v23 := lang.Apply(v16, []any{v19, v22, v7}) +return v23 + case 1: +v14 := args[0] +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("reduce1")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +var v18 lang.FnFunc +v18 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v19 := args[0] +v20 := args[1] +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("conj")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(v20, []any{v14}) +v25 := lang.Apply(v23, []any{v19, v24}) +return v25 +}) +v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2601), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(2601), lang.NewKeyword("end-column"), int(40)) +v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v21 := lang.NewVector() +v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2601), lang.NewKeyword("column"), int(42), lang.NewKeyword("end-line"), int(2601), lang.NewKeyword("end-column"), int(43)) +v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v24 := lang.Apply(v17, []any{v20, v23, v7}) +return v24 + case 2: +v14 := args[0] +v15 := args[1] +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("reduce1")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +var v19 lang.FnFunc +v19 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v20 := args[0] +v21 := args[1] +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("conj")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v21, []any{v14, v15}) +v26 := lang.Apply(v24, []any{v20, v25}) +return v26 +}) +v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2602), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(2602), lang.NewKeyword("end-column"), int(44)) +v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v22 := lang.NewVector() +v23 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2602), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(2602), lang.NewKeyword("end-column"), int(47)) +v24, err := lang.WithMeta(v22, v23.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v25 := lang.Apply(v18, []any{v21, v24, v7}) +return v25 + case 3: +v14 := args[0] +v15 := args[1] +v16 := args[2] +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("reduce1")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +var v20 lang.FnFunc +v20 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v21 := args[0] +v22 := args[1] +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("conj")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v22, []any{v14, v15, v16}) +v27 := lang.Apply(v25, []any{v21, v26}) +return v27 +}) +v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2603), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(2603), lang.NewKeyword("end-column"), int(48)) +v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v23 := lang.NewVector() +v24 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2603), lang.NewKeyword("column"), int(50), lang.NewKeyword("end-line"), int(2603), lang.NewKeyword("end-column"), int(51)) +v25, err := lang.WithMeta(v23, v24.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v26 := lang.Apply(v19, []any{v22, v25, v7}) +return v26 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v14 := args[0] +v15 := args[1] +v16 := args[2] +v17 := lang.NewList(args[3:]...) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("reduce1")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +var v21 lang.FnFunc +v21 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v22 := args[0] +v23 := args[1] +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("conj")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("apply")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{v23, v14, v15, v16, v17}) +v31 := lang.Apply(v26, []any{v22, v30}) +return v31 +}) +v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2604), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(2604), lang.NewKeyword("end-column"), int(66)) +v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v24 := lang.NewVector() +v25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2604), lang.NewKeyword("column"), int(68), lang.NewKeyword("end-line"), int(2604), lang.NewKeyword("end-column"), int(69)) +v26, err := lang.WithMeta(v24, v25.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v27 := lang.Apply(v20, []any{v23, v26, v7}) +return v27 + } +}) +v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2599), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(2604), lang.NewKeyword("end-column"), int(75)) +v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v15 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// unchecked-long +{ +var v1 lang.FnFunc +{ // function unchecked-long__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/UncheckedLongCast")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v3}) +v35 := lang.Apply(v26, []any{v30, v34}) +v36 := lang.Apply(v23, []any{v35}) +v37 := lang.Apply(v20, []any{v36}) +v38 := lang.Apply(v9, []any{v13, v17, v37}) +v39 := lang.Apply(v6, []any{v38}) +return v39 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("unchecked-long").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to long. Subject to rounding or truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3541), lang.NewKeyword("end-line"), int(3541))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := lang.Apply(lang1.UncheckedLongCast, []any{v4}) +return v5 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// bit-flip +{ +v0 := lang.NewSymbol("bit-flip").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Flip bit at index n", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1348), lang.NewKeyword("end-line"), int(1348))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "flipBit") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("flipBit is not a function"))) +} +v6 := lang.Apply(v5, []any{v3, v4}) +return v6 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// infinite? +{ +var v1 lang.FnFunc +{ // function infinite?__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol("Double/isInfinite")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v3}) +v18 := lang.Apply(v9, []any{v13, v17}) +v19 := lang.Apply(v6, []any{v18}) +return v19 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("infinite?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns true if num is negative or positive infinity, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)), lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(8030), lang.NewKeyword("end-line"), int(8030))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := lang.Apply(nil, []any{v4}) +return v5 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// pcalls +{ +v0 := lang.NewSymbol("pcalls").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("fns"))), lang.NewKeyword("doc"), "Executes the no-arg fns in parallel, returning a lazy sequence of\n their values", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7099), lang.NewKeyword("end-line"), int(7099))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.NewList(args[0:]...) +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("pmap")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +var v7 lang.FnFunc +v7 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v8 := args[0] +v9 := lang.Apply(v8, nil) +return v9 +}) +v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7104), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(7104), lang.NewKeyword("end-column"), int(20)) +v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v10 := lang.Apply(v6, []any{v9, v3}) +return v10 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// locking +{ +v0 := lang.NewSymbol("locking").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Executes exprs in an implicit do, while holding the monitor of x.\n Will release the monitor of x in all circumstances.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1643), lang.NewKeyword("end-line"), int(1643))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("seq")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("concat")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("list")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/let")}) +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("list")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("apply")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("vector")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("seq")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("concat")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{lang.NewSymbol("lockee__0__auto__")}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v5}) +v40 := lang.Apply(v31, []any{v35, v39}) +v41 := lang.Apply(v28, []any{v40}) +v42 := lang.Apply(v22, []any{v25, v41}) +v43 := lang.Apply(v19, []any{v42}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("seq")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +} +v49 := v48.Get() +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("concat")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +} +v52 := v51.Get() +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("list")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +} +v55 := v54.Get() +v56 := lang.Apply(v55, []any{lang.NewSymbol("try")}) +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("list")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +} +v59 := v58.Get() +v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v61 := v60.FindInternedVar(lang.NewSymbol("seq")) +if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) +} +v62 := v61.Get() +v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v64 := v63.FindInternedVar(lang.NewSymbol("concat")) +if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) +} +v65 := v64.Get() +v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v67 := v66.FindInternedVar(lang.NewSymbol("list")) +if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) +} +v68 := v67.Get() +v69 := lang.Apply(v68, []any{lang.NewSymbol("glojure.core/let")}) +v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v71 := v70.FindInternedVar(lang.NewSymbol("list")) +if v71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) +} +v72 := v71.Get() +v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v74 := v73.FindInternedVar(lang.NewSymbol("apply")) +if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) +} +v75 := v74.Get() +v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v77 := v76.FindInternedVar(lang.NewSymbol("vector")) +if v77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) +} +v78 := v77.Get() +v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v80 := v79.FindInternedVar(lang.NewSymbol("seq")) +if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) +} +v81 := v80.Get() +v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v83 := v82.FindInternedVar(lang.NewSymbol("concat")) +if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) +} +v84 := v83.Get() +v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v86 := v85.FindInternedVar(lang.NewSymbol("list")) +if v86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) +} +v87 := v86.Get() +v88 := lang.Apply(v87, []any{lang.NewSymbol("locklocal__1__auto__")}) +v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v90 := v89.FindInternedVar(lang.NewSymbol("list")) +if v90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) +} +v91 := v90.Get() +v92 := lang.Apply(v91, []any{lang.NewSymbol("lockee__0__auto__")}) +v93 := lang.Apply(v84, []any{v88, v92}) +v94 := lang.Apply(v81, []any{v93}) +v95 := lang.Apply(v75, []any{v78, v94}) +v96 := lang.Apply(v72, []any{v95}) +v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v98 := v97.FindInternedVar(lang.NewSymbol("list")) +if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) +} +v99 := v98.Get() +v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v101 := v100.FindInternedVar(lang.NewSymbol("seq")) +if v101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) +} +v102 := v101.Get() +v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v104 := v103.FindInternedVar(lang.NewSymbol("concat")) +if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) +} +v105 := v104.Get() +v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v107 := v106.FindInternedVar(lang.NewSymbol("list")) +if v107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) +} +v108 := v107.Get() +v109 := lang.Apply(v108, []any{lang.NewSymbol("monitor-enter")}) +v110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v111 := v110.FindInternedVar(lang.NewSymbol("list")) +if v111.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v111))) +} +v112 := v111.Get() +v113 := lang.Apply(v112, []any{lang.NewSymbol("locklocal__1__auto__")}) +v114 := lang.Apply(v105, []any{v109, v113}) +v115 := lang.Apply(v102, []any{v114}) +v116 := lang.Apply(v99, []any{v115}) +v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v118 := v117.FindInternedVar(lang.NewSymbol("list")) +if v118.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) +} +v119 := v118.Get() +v120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v121 := v120.FindInternedVar(lang.NewSymbol("seq")) +if v121.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v121))) +} +v122 := v121.Get() +v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v124 := v123.FindInternedVar(lang.NewSymbol("concat")) +if v124.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) +} +v125 := v124.Get() +v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v127 := v126.FindInternedVar(lang.NewSymbol("list")) +if v127.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) +} +v128 := v127.Get() +v129 := lang.Apply(v128, []any{lang.NewSymbol("try")}) +v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v131 := v130.FindInternedVar(lang.NewSymbol("list")) +if v131.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) +} +v132 := v131.Get() +v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v134 := v133.FindInternedVar(lang.NewSymbol("seq")) +if v134.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) +} +v135 := v134.Get() +v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v137 := v136.FindInternedVar(lang.NewSymbol("concat")) +if v137.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) +} +v138 := v137.Get() +v139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v140 := v139.FindInternedVar(lang.NewSymbol("list")) +if v140.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v140))) +} +v141 := v140.Get() +v142 := lang.Apply(v141, []any{lang.NewSymbol("finally")}) +v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v144 := v143.FindInternedVar(lang.NewSymbol("list")) +if v144.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) +} +v145 := v144.Get() +v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v147 := v146.FindInternedVar(lang.NewSymbol("seq")) +if v147.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) +} +v148 := v147.Get() +v149 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v150 := v149.FindInternedVar(lang.NewSymbol("concat")) +if v150.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v150))) +} +v151 := v150.Get() +v152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v153 := v152.FindInternedVar(lang.NewSymbol("list")) +if v153.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v153))) +} +v154 := v153.Get() +v155 := lang.Apply(v154, []any{lang.NewSymbol("monitor-exit")}) +v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v157 := v156.FindInternedVar(lang.NewSymbol("list")) +if v157.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) +} +v158 := v157.Get() +v159 := lang.Apply(v158, []any{lang.NewSymbol("locklocal__1__auto__")}) +v160 := lang.Apply(v151, []any{v155, v159}) +v161 := lang.Apply(v148, []any{v160}) +v162 := lang.Apply(v145, []any{v161}) +v163 := lang.Apply(v138, []any{v142, v162}) +v164 := lang.Apply(v135, []any{v163}) +v165 := lang.Apply(v132, []any{v164}) +v166 := lang.Apply(v125, []any{v129, v6, v165}) +v167 := lang.Apply(v122, []any{v166}) +v168 := lang.Apply(v119, []any{v167}) +v169 := lang.Apply(v65, []any{v69, v96, v116, v168}) +v170 := lang.Apply(v62, []any{v169}) +v171 := lang.Apply(v59, []any{v170}) +v172 := lang.Apply(v52, []any{v56, v171}) +v173 := lang.Apply(v49, []any{v172}) +v174 := lang.Apply(v46, []any{v173}) +v175 := lang.Apply(v12, []any{v16, v43, v174}) +v176 := lang.Apply(v9, []any{v175}) +return v176 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// update +{ +v0 := lang.NewSymbol("update").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f"), lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("z")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("z"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "'Updates' a value in an associative structure, where k is a\n key and f is a function that will take the old value\n and any supplied args and return the new value, and returns a new\n structure. If the key does not exist, nil is passed as the old value.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6217), lang.NewKeyword("end-line"), int(6217))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("assoc")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("get")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v3, v4}) +v13 := lang.Apply(v5, []any{v12}) +v14 := lang.Apply(v8, []any{v3, v4, v13}) +return v14 + case 4: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("assoc")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("get")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{v3, v4}) +v14 := lang.Apply(v5, []any{v13, v6}) +v15 := lang.Apply(v9, []any{v3, v4, v14}) +return v15 + case 5: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := args[4] +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("assoc")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("get")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v3, v4}) +v15 := lang.Apply(v5, []any{v14, v6, v7}) +v16 := lang.Apply(v10, []any{v3, v4, v15}) +return v16 + case 6: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := args[4] +v8 := args[5] +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("assoc")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("get")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v3, v4}) +v16 := lang.Apply(v5, []any{v15, v6, v7, v8}) +v17 := lang.Apply(v11, []any{v3, v4, v16}) +return v17 + default: + if len(args) < 6 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := args[4] +v8 := args[5] +v9 := lang.NewList(args[6:]...) +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("assoc")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("apply")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("get")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v3, v4}) +v20 := lang.Apply(v15, []any{v5, v19, v6, v7, v8, v9}) +v21 := lang.Apply(v12, []any{v3, v4, v20}) +return v21 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// letfn +{ +v0 := lang.NewSymbol("letfn").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fnspecs"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "fnspec ==> (fname [params*] exprs) or (fname ([params*] exprs)+)\n\n Takes a vector of function specs and a body, and generates a set of\n bindings of functions to their names. All of the names are available\n in all of the definitions of the functions, as well as the body.", lang.NewKeyword("forms"), lang.NewVector(lang.NewList(lang.NewSymbol("letfn"), lang.NewVector(lang.NewSymbol("fnspecs*")), lang.NewSymbol("exprs*"))), lang.NewKeyword("url"), nil, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6588), lang.NewKeyword("end-line"), int(6588), lang.NewKeyword("special-form"), true)).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("seq")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("concat")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("list")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{lang.NewSymbol("letfn*")}) +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("list")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("vec")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("interleave")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("map")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("first")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.Apply(v28, []any{v31, v5}) +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("map")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +var v36 lang.FnFunc +v36 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v37 := args[0] +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("cons")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.Apply(v40, []any{lang.NewSymbol("glojure.core/fn"), v37}) +return v41 +}) +v37 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6598), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(6598), lang.NewKeyword("end-column"), int(47)) +v38, err := lang.WithMeta(v36, v37.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v39 := lang.Apply(v35, []any{v38, v5}) +v40 := lang.Apply(v25, []any{v32, v39}) +v41 := lang.Apply(v22, []any{v40}) +v42 := lang.Apply(v19, []any{v41}) +v43 := lang.Apply(v12, []any{v16, v42, v6}) +v44 := lang.Apply(v9, []any{v43}) +return v44 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// commute +{ +v0 := lang.NewSymbol("commute").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("fun"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Must be called in a transaction. Sets the in-transaction-value of\n ref to:\n\n (apply fun in-transaction-value-of-ref args)\n\n and returns the in-transaction-value of ref.\n\n At the commit point of the transaction, sets the value of ref to be:\n\n (apply fun most-recently-committed-value-of-ref args)\n\n Thus fun should be commutative, or, failing that, you must accept\n last-one-in-wins behavior. commute allows for more concurrency than\n ref-set.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2414), lang.NewKeyword("end-line"), int(2414))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +v6, _ := lang.FieldOrMethod(v3, "Commute") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Commute is not a function"))) +} +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// keyword? +{ +v0 := lang.NewSymbol("keyword?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a Keyword", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(563), lang.NewKeyword("end-line"), int(563))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{lang1.Keyword, v3}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// -protocols +{ +v0 := lang.NewSymbol("-protocols").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("doc"), "Private store of protocols. Go's reflection capabilities\n don't yet support a native interface-based implementation, so\n protocols are implemented in Glojure as maps from type to protocol\n method implementations.", lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(21), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(26), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v3 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("coll-reduce"), nil), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("coll-reduce"), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("f"), lang.NewSymbol("val")))))) +v4 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("internal-reduce"), nil), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("internal-reduce"), lang.NewVector(lang.NewSymbol("seq"), lang.NewSymbol("f"), lang.NewSymbol("start")))))) +v5 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("kv-reduce"), nil), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("kv-reduce"), lang.NewVector(lang.NewSymbol("amap"), lang.NewSymbol("f"), lang.NewSymbol("init")))))) +v6 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("datafy"), nil), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("datafy"), lang.NewVector(lang.NewSymbol("o")), "return a representation of o as data (default identity)")))) +v7 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("nav"), nil), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("nav"), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("k"), lang.NewSymbol("v")), "return (possibly transformed) v in the context of coll and k (a key/index or nil),\ndefaults to returning v.")))) +v8 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("make-reader"), nil, lang.NewKeyword("make-writer"), nil, lang.NewKeyword("make-input-stream"), nil, lang.NewKeyword("make-output-stream"), nil), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("make-reader"), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("opts")), "Creates an io.Reader. See also IOFactory docs."), lang.NewList(lang.NewSymbol("make-writer"), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("opts")), "Creates an io.Reader. See also IOFactory docs."), lang.NewList(lang.NewSymbol("make-input-stream"), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("opts")), "Creates a BufferedInputStream. See also IOFactory docs."), lang.NewList(lang.NewSymbol("make-output-stream"), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("opts")), "Creates a BufferedOutputStream. See also IOFactory docs.")))) +v2 := lang.NewAtom(lang.NewMap(lang.NewSymbol("CollReduce"), v3, lang.NewSymbol("InternalReduce"), v4, lang.NewSymbol("IKVReduce"), v5, lang.NewSymbol("Datafiable"), v6, lang.NewSymbol("Navigable"), v7, lang.NewSymbol("IOFactory"), v8)) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// macroexpand +{ +v0 := lang.NewSymbol("macroexpand").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("form"))), lang.NewKeyword("doc"), "Repeatedly calls macroexpand-1 on form until it no longer\n represents a macro form, then returns it. Note neither\n macroexpand-1 nor macroexpand expand macros in subforms.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4025), lang.NewKeyword("end-line"), int(4025))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("macroexpand-1")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +var v4 any = v8 +_ = v4 +var v10 any +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("identical?")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v4, v3}) +if lang.IsTruthy(v14) { +v10 = v3 +} else { +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("macroexpand")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v4}) +v10 = v18 +} +return v10 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// concat +{ +v0 := lang.NewSymbol("concat").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("zs"))), lang.NewKeyword("doc"), "Returns a lazy seq representing the concatenation of the elements in the supplied colls.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(711), lang.NewKeyword("end-line"), int(711))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +return nil +}) +v4 := lang.Apply(lang1.NewLazySeq, []any{v3}) +return v4 + case 1: +v3 := args[0] +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +return v3 +}) +v5 := lang.Apply(lang1.NewLazySeq, []any{v4}) +return v5 + case 2: +v3 := args[0] +v4 := args[1] +var v5 lang.FnFunc +v5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("seq")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v3}) +var v6 any = v10 +_ = v6 +var v12 any +if lang.IsTruthy(v6) { +var v13 any +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("chunked-seq?")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v6}) +if lang.IsTruthy(v17) { +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("chunk-cons")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("chunk-first")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v6}) +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("concat")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("chunk-rest")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{v6}) +v32 := lang.Apply(v27, []any{v31, v4}) +v33 := lang.Apply(v20, []any{v24, v32}) +v13 = v33 +} else { +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("cons")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("first")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v6}) +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("concat")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("rest")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v6}) +v48 := lang.Apply(v43, []any{v47, v4}) +v49 := lang.Apply(v36, []any{v40, v48}) +v13 = v49 +} +v12 = v13 +} else { +v12 = v4 +} +return v12 +}) +v6 := lang.Apply(lang1.NewLazySeq, []any{v5}) +return v6 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +var v7 lang.FnFunc +{ // function cat +v7 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v9 := args[0] +v10 := args[1] +var v11 lang.FnFunc +v11 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("seq")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v12}) +var v12 any = v16 +_ = v12 +var v18 any +if lang.IsTruthy(v12) { +var v19 any +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("chunked-seq?")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.Apply(v22, []any{v12}) +if lang.IsTruthy(v23) { +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("chunk-cons")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("chunk-first")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{v12}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("chunk-rest")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v12}) +v35 := lang.Apply(v8, []any{v34, v10}) +v36 := lang.Apply(v26, []any{v30, v35}) +v19 = v36 +} else { +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("cons")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("first")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v12}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("rest")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v12}) +v48 := lang.Apply(v8, []any{v47, v10}) +v49 := lang.Apply(v39, []any{v43, v48}) +v19 = v49 +} +v18 = v19 +} else { +var v50 any +if lang.IsTruthy(v10) { +v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v52 := v51.FindInternedVar(lang.NewSymbol("first")) +if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) +} +v53 := v52.Get() +v54 := lang.Apply(v53, []any{v10}) +v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v56 := v55.FindInternedVar(lang.NewSymbol("next")) +if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) +} +v57 := v56.Get() +v58 := lang.Apply(v57, []any{v10}) +v59 := lang.Apply(v8, []any{v54, v58}) +v50 = v59 +} else { +v50 = nil +} +v18 = v50 +} +return v18 +}) +v12 := lang.Apply(lang1.NewLazySeq, []any{v11}) +return v12 +}) +v8 := v7 +_ = v8 +} +v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(726), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(735), lang.NewKeyword("end-column"), int(56)) +v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v6 any = v9 +_ = v6 +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("concat")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v3, v4}) +v15 := lang.Apply(v6, []any{v14, v5}) +return v15 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// doall +{ +v0 := lang.NewSymbol("doall").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "When lazy sequences are produced via functions that have side\n effects, any effects other than those needed to produce the first\n element in the seq do not occur until the seq is consumed. doall can\n be used to force any effects. Walks through the successive nexts of\n the seq, retains the head and returns it, thus causing the entire\n seq to reside in memory at one time.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3131), lang.NewKeyword("end-line"), int(3131))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("dorun")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{v3}) +_ = v7 +return v3 + case 2: +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("dorun")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3, v4}) +_ = v8 +return v4 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// pr-str +{ +v1 := reflect.TypeOf("") +v0 := lang.NewSymbol("pr-str").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("xs"))), lang.NewKeyword("doc"), "pr to a string, returning it", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4758), lang.NewKeyword("end-line"), int(4758))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := lang.NewList(args[0:]...) +var v5 any = "unimplemented: new with non-constant class type" +_ = v5 +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("push-thread-bindings")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("hash-map")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*out*")) +v15 := lang.Apply(v13, []any{v14, v5}) +v16 := lang.Apply(v10, []any{v15}) +_ = v16 +var v17 any +func() { +defer func() { +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, nil) +}() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("apply")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("pr")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.Apply(v24, []any{v27, v4}) +_ = v28 +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("str")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.Apply(v31, []any{v5}) +v17 = v32 +}() +return v17 + } +}) +v4 := reflect.TypeOf("") +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// condp +{ +v0 := lang.NewSymbol("condp").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes a binary predicate, an expression, and a set of clauses.\n Each clause can take the form of either:\n\n test-expr result-expr\n\n test-expr :>> result-fn\n\n Note :>> is an ordinary keyword.\n\n For each clause, (pred test-expr expr) is evaluated. If it returns\n logical true, the clause is a match. If a binary clause matches, the\n result-expr is returned, if a ternary clause matches, its result-fn,\n which must be a unary function, is called with the result of the\n predicate as its argument, the result of that call being the return\n value of condp. A single default expression can follow the clauses,\n and its value will be returned if no clause matches. If no default\n expression is provided and no clause matches, an\n IllegalArgumentException is thrown.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6396), lang.NewKeyword("end-line"), int(6396))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := lang.NewList(args[4:]...) +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("gensym")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v11, []any{"pred__"}) +var v8 any = v12 +_ = v8 +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("gensym")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{"expr__"}) +var v13 any = v17 +_ = v13 +var v19 lang.FnFunc +{ // function emit +v19 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v21 := args[0] +v22 := args[1] +v23 := args[2] +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("split-at")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +var v28 any +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("=")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("second")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v23}) +v36 := lang.Apply(v31, []any{lang.NewKeyword(">>"), v35}) +if lang.IsTruthy(v36) { +v28 = int64(3) +} else { +v28 = int64(2) +} +v37 := lang.Apply(v27, []any{v28, v23}) +var v24 any = v37 +_ = v24 +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("nth")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +} +v41 := v40.Get() +v42 := lang.Apply(v41, []any{v24, int64(0), nil}) +var v38 any = v42 +_ = v38 +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("nth")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v38, int64(0), nil}) +var v43 any = v47 +_ = v43 +v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v50 := v49.FindInternedVar(lang.NewSymbol("nth")) +if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) +} +v51 := v50.Get() +v52 := lang.Apply(v51, []any{v38, int64(1), nil}) +var v48 any = v52 +_ = v48 +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("nth")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +} +v56 := v55.Get() +v57 := lang.Apply(v56, []any{v38, int64(2), nil}) +var v53 any = v57 +_ = v53 +var v58 any = v38 +_ = v58 +v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v61 := v60.FindInternedVar(lang.NewSymbol("nth")) +if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) +} +v62 := v61.Get() +v63 := lang.Apply(v62, []any{v24, int64(1), nil}) +var v59 any = v63 +_ = v59 +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("count")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +} +v67 := v66.Get() +v68 := lang.Apply(v67, []any{v58}) +var v64 any = v68 +_ = v64 +var v70 any +v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v72 := v71.FindInternedVar(lang.NewSymbol("=")) +if v72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) +} +v73 := v72.Get() +v74 := lang.Apply(v73, []any{int64(0), v64}) +if lang.IsTruthy(v74) { +v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v76 := v75.FindInternedVar(lang.NewSymbol("seq")) +if v76.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) +} +v77 := v76.Get() +v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v79 := v78.FindInternedVar(lang.NewSymbol("concat")) +if v79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) +} +v80 := v79.Get() +v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v82 := v81.FindInternedVar(lang.NewSymbol("list")) +if v82.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) +} +v83 := v82.Get() +v84 := lang.Apply(v83, []any{lang.NewSymbol("throw")}) +v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v86 := v85.FindInternedVar(lang.NewSymbol("list")) +if v86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) +} +v87 := v86.Get() +v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v89 := v88.FindInternedVar(lang.NewSymbol("seq")) +if v89.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) +} +v90 := v89.Get() +v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v92 := v91.FindInternedVar(lang.NewSymbol("concat")) +if v92.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) +} +v93 := v92.Get() +v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v95 := v94.FindInternedVar(lang.NewSymbol("list")) +if v95.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) +} +v96 := v95.Get() +v97 := lang.Apply(v96, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewIllegalArgumentError")}) +v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v99 := v98.FindInternedVar(lang.NewSymbol("list")) +if v99.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) +} +v100 := v99.Get() +v101 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v102 := v101.FindInternedVar(lang.NewSymbol("seq")) +if v102.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v102))) +} +v103 := v102.Get() +v104 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v105 := v104.FindInternedVar(lang.NewSymbol("concat")) +if v105.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v105))) +} +v106 := v105.Get() +v107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v108 := v107.FindInternedVar(lang.NewSymbol("list")) +if v108.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v108))) +} +v109 := v108.Get() +v110 := lang.Apply(v109, []any{lang.NewSymbol("glojure.core/str")}) +v111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v112 := v111.FindInternedVar(lang.NewSymbol("list")) +if v112.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v112))) +} +v113 := v112.Get() +v114 := lang.Apply(v113, []any{"No matching clause: "}) +v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v116 := v115.FindInternedVar(lang.NewSymbol("list")) +if v116.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) +} +v117 := v116.Get() +v118 := lang.Apply(v117, []any{v22}) +v119 := lang.Apply(v106, []any{v110, v114, v118}) +v120 := lang.Apply(v103, []any{v119}) +v121 := lang.Apply(v100, []any{v120}) +v122 := lang.Apply(v93, []any{v97, v121}) +v123 := lang.Apply(v90, []any{v122}) +v124 := lang.Apply(v87, []any{v123}) +v125 := lang.Apply(v80, []any{v84, v124}) +v126 := lang.Apply(v77, []any{v125}) +v70 = v126 +} else { +var v127 any +v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v129 := v128.FindInternedVar(lang.NewSymbol("=")) +if v129.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v129))) +} +v130 := v129.Get() +v131 := lang.Apply(v130, []any{int64(1), v64}) +if lang.IsTruthy(v131) { +v127 = v43 +} else { +var v132 any +v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v134 := v133.FindInternedVar(lang.NewSymbol("=")) +if v134.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) +} +v135 := v134.Get() +v136 := lang.Apply(v135, []any{int64(2), v64}) +if lang.IsTruthy(v136) { +v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v138 := v137.FindInternedVar(lang.NewSymbol("seq")) +if v138.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) +} +v139 := v138.Get() +v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v141 := v140.FindInternedVar(lang.NewSymbol("concat")) +if v141.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) +} +v142 := v141.Get() +v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v144 := v143.FindInternedVar(lang.NewSymbol("list")) +if v144.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) +} +v145 := v144.Get() +v146 := lang.Apply(v145, []any{lang.NewSymbol("if")}) +v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v148 := v147.FindInternedVar(lang.NewSymbol("list")) +if v148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) +} +v149 := v148.Get() +v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v151 := v150.FindInternedVar(lang.NewSymbol("seq")) +if v151.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) +} +v152 := v151.Get() +v153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v154 := v153.FindInternedVar(lang.NewSymbol("concat")) +if v154.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v154))) +} +v155 := v154.Get() +v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v157 := v156.FindInternedVar(lang.NewSymbol("list")) +if v157.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) +} +v158 := v157.Get() +v159 := lang.Apply(v158, []any{v21}) +v160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v161 := v160.FindInternedVar(lang.NewSymbol("list")) +if v161.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v161))) +} +v162 := v161.Get() +v163 := lang.Apply(v162, []any{v43}) +v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v165 := v164.FindInternedVar(lang.NewSymbol("list")) +if v165.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) +} +v166 := v165.Get() +v167 := lang.Apply(v166, []any{v22}) +v168 := lang.Apply(v155, []any{v159, v163, v167}) +v169 := lang.Apply(v152, []any{v168}) +v170 := lang.Apply(v149, []any{v169}) +v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v172 := v171.FindInternedVar(lang.NewSymbol("list")) +if v172.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) +} +v173 := v172.Get() +v174 := lang.Apply(v173, []any{v48}) +v175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v176 := v175.FindInternedVar(lang.NewSymbol("list")) +if v176.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v176))) +} +v177 := v176.Get() +v178 := lang.Apply(v20, []any{v21, v22, v59}) +v179 := lang.Apply(v177, []any{v178}) +v180 := lang.Apply(v142, []any{v146, v170, v174, v179}) +v181 := lang.Apply(v139, []any{v180}) +v132 = v181 +} else { +var v182 any +if lang.IsTruthy(lang.NewKeyword("else")) { +v183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v184 := v183.FindInternedVar(lang.NewSymbol("seq")) +if v184.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v184))) +} +v185 := v184.Get() +v186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v187 := v186.FindInternedVar(lang.NewSymbol("concat")) +if v187.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v187))) +} +v188 := v187.Get() +v189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v190 := v189.FindInternedVar(lang.NewSymbol("list")) +if v190.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v190))) +} +v191 := v190.Get() +v192 := lang.Apply(v191, []any{lang.NewSymbol("glojure.core/if-let")}) +v193 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v194 := v193.FindInternedVar(lang.NewSymbol("list")) +if v194.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v194))) +} +v195 := v194.Get() +v196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v197 := v196.FindInternedVar(lang.NewSymbol("apply")) +if v197.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v197))) +} +v198 := v197.Get() +v199 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v200 := v199.FindInternedVar(lang.NewSymbol("vector")) +if v200.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v200))) +} +v201 := v200.Get() +v202 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v203 := v202.FindInternedVar(lang.NewSymbol("seq")) +if v203.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v203))) +} +v204 := v203.Get() +v205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v206 := v205.FindInternedVar(lang.NewSymbol("concat")) +if v206.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v206))) +} +v207 := v206.Get() +v208 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v209 := v208.FindInternedVar(lang.NewSymbol("list")) +if v209.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v209))) +} +v210 := v209.Get() +v211 := lang.Apply(v210, []any{lang.NewSymbol("p__0__auto__")}) +v212 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v213 := v212.FindInternedVar(lang.NewSymbol("list")) +if v213.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v213))) +} +v214 := v213.Get() +v215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v216 := v215.FindInternedVar(lang.NewSymbol("seq")) +if v216.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v216))) +} +v217 := v216.Get() +v218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v219 := v218.FindInternedVar(lang.NewSymbol("concat")) +if v219.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v219))) +} +v220 := v219.Get() +v221 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v222 := v221.FindInternedVar(lang.NewSymbol("list")) +if v222.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v222))) +} +v223 := v222.Get() +v224 := lang.Apply(v223, []any{v21}) +v225 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v226 := v225.FindInternedVar(lang.NewSymbol("list")) +if v226.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v226))) +} +v227 := v226.Get() +v228 := lang.Apply(v227, []any{v43}) +v229 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v230 := v229.FindInternedVar(lang.NewSymbol("list")) +if v230.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v230))) +} +v231 := v230.Get() +v232 := lang.Apply(v231, []any{v22}) +v233 := lang.Apply(v220, []any{v224, v228, v232}) +v234 := lang.Apply(v217, []any{v233}) +v235 := lang.Apply(v214, []any{v234}) +v236 := lang.Apply(v207, []any{v211, v235}) +v237 := lang.Apply(v204, []any{v236}) +v238 := lang.Apply(v198, []any{v201, v237}) +v239 := lang.Apply(v195, []any{v238}) +v240 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v241 := v240.FindInternedVar(lang.NewSymbol("list")) +if v241.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v241))) +} +v242 := v241.Get() +v243 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v244 := v243.FindInternedVar(lang.NewSymbol("seq")) +if v244.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v244))) +} +v245 := v244.Get() +v246 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v247 := v246.FindInternedVar(lang.NewSymbol("concat")) +if v247.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v247))) +} +v248 := v247.Get() +v249 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v250 := v249.FindInternedVar(lang.NewSymbol("list")) +if v250.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v250))) +} +v251 := v250.Get() +v252 := lang.Apply(v251, []any{v53}) +v253 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v254 := v253.FindInternedVar(lang.NewSymbol("list")) +if v254.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v254))) +} +v255 := v254.Get() +v256 := lang.Apply(v255, []any{lang.NewSymbol("p__0__auto__")}) +v257 := lang.Apply(v248, []any{v252, v256}) +v258 := lang.Apply(v245, []any{v257}) +v259 := lang.Apply(v242, []any{v258}) +v260 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v261 := v260.FindInternedVar(lang.NewSymbol("list")) +if v261.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v261))) +} +v262 := v261.Get() +v263 := lang.Apply(v20, []any{v21, v22, v59}) +v264 := lang.Apply(v262, []any{v263}) +v265 := lang.Apply(v188, []any{v192, v239, v259, v264}) +v266 := lang.Apply(v185, []any{v265}) +v182 = v266 +} else { +v182 = nil +} +v132 = v182 +} +v127 = v132 +} +v70 = v127 +} +return v70 +}) +v20 := v19 +_ = v20 +} +v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6420), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(6432), lang.NewKeyword("end-column"), int(53)) +v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v18 any = v21 +_ = v18 +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("seq")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("concat")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("list")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.Apply(v31, []any{lang.NewSymbol("glojure.core/let")}) +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("list")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("apply")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("vector")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +} +v41 := v40.Get() +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("seq")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +} +v44 := v43.Get() +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("concat")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +} +v47 := v46.Get() +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v8}) +v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v53 := v52.FindInternedVar(lang.NewSymbol("list")) +if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) +} +v54 := v53.Get() +v55 := lang.Apply(v54, []any{v5}) +v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v57 := v56.FindInternedVar(lang.NewSymbol("list")) +if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) +} +v58 := v57.Get() +v59 := lang.Apply(v58, []any{v13}) +v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v61 := v60.FindInternedVar(lang.NewSymbol("list")) +if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) +} +v62 := v61.Get() +v63 := lang.Apply(v62, []any{v6}) +v64 := lang.Apply(v47, []any{v51, v55, v59, v63}) +v65 := lang.Apply(v44, []any{v64}) +v66 := lang.Apply(v38, []any{v41, v65}) +v67 := lang.Apply(v35, []any{v66}) +v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v69 := v68.FindInternedVar(lang.NewSymbol("list")) +if v69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) +} +v70 := v69.Get() +v71 := lang.Apply(v18, []any{v8, v13, v7}) +v72 := lang.Apply(v70, []any{v71}) +v73 := lang.Apply(v28, []any{v32, v67, v72}) +v74 := lang.Apply(v25, []any{v73}) +return v74 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// data-reader-var +{ +v0 := lang.NewSymbol("data-reader-var").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7885), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7885), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("intern")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("create-ns")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("symbol")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("namespace")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v3}) +v17 := lang.Apply(v12, []any{v16}) +v18 := lang.Apply(v9, []any{v17}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("symbol")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("name")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v3}) +v26 := lang.Apply(v21, []any{v25}) +v27 := lang.Apply(v6, []any{v18, v26}) +return v27 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// ns-imports +{ +v0 := lang.NewSymbol("ns-imports").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of the import mappings for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4199), lang.NewKeyword("end-line"), int(4199))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("filter-key")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("val")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("partial")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("instance?")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v12, []any{v15, reflect.Type}) +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("ns-map")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v3}) +v21 := lang.Apply(v6, []any{v9, v16, v20}) +return v21 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// rationalize +{ +v0 := lang.NewSymbol("rationalize").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("doc"), "returns the rational value of num", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1282), lang.NewKeyword("end-line"), int(1282))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, _ := lang.FieldOrMethod(lang1.Numbers, "rationalize") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("rationalize is not a function"))) +} +v5 := lang.Apply(v4, []any{v3}) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// apply +{ +v0 := lang.NewSymbol("apply").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("z"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Applies fn f to the argument list formed by prepending intervening arguments to args.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(653), lang.NewKeyword("end-line"), int(653))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v4}) +v9 := lang.Apply(lang1.Apply, []any{v3, v8}) +return v9 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("list*")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v4, v5}) +v10 := lang.Apply(lang1.Apply, []any{v3, v9}) +return v10 + case 4: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("list*")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v4, v5, v6}) +v11 := lang.Apply(lang1.Apply, []any{v3, v10}) +return v11 + case 5: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := args[4] +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("list*")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v4, v5, v6, v7}) +v12 := lang.Apply(lang1.Apply, []any{v3, v11}) +return v12 + default: + if len(args) < 5 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := args[4] +v8 := lang.NewList(args[5:]...) +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("cons")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("cons")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("cons")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("cons")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("spread")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v8}) +v25 := lang.Apply(v20, []any{v7, v24}) +v26 := lang.Apply(v17, []any{v6, v25}) +v27 := lang.Apply(v14, []any{v5, v26}) +v28 := lang.Apply(v11, []any{v4, v27}) +v29 := lang.Apply(lang1.Apply, []any{v3, v28}) +return v29 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// inc +{ +var v1 lang.FnFunc +{ // function inc__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +var v30 any +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +if lang.IsTruthy(v33) { +v30 = lang.NewSymbol("unchecked_inc") +} else { +v30 = lang.NewSymbol("inc") +} +v34 := lang.Apply(v29, []any{v30}) +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("list")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v37, []any{v3}) +v39 := lang.Apply(v26, []any{v34, v38}) +v40 := lang.Apply(v23, []any{v39}) +v41 := lang.Apply(v20, []any{v40}) +v42 := lang.Apply(v9, []any{v13, v17, v41}) +v43 := lang.Apply(v6, []any{v42}) +return v43 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("inc").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns a number one greater than num. Does not auto-promote\n longs, will throw on overflow. See also: inc'", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(915), lang.NewKeyword("end-line"), int(915))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "inc") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("inc is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// test +{ +v0 := lang.NewSymbol("test").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("v"))), lang.NewKeyword("doc"), "test [v] finds fn at key :test in var metadata and calls it,\n presuming failure will throw exception", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4853), lang.NewKeyword("end-line"), int(4853))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("meta")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +v9 := lang.Apply(lang.NewKeyword("test"), []any{v8}) +var v4 any = v9 +_ = v4 +var v11 any +if lang.IsTruthy(v4) { +v12 := lang.Apply(v4, nil) +_ = v12 +v11 = lang.NewKeyword("ok") +} else { +v11 = lang.NewKeyword("no-test") +} +return v11 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// < +{ +var v1 lang.FnFunc +{ // function <__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("concat")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("list")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("seq")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("concat")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("list")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/lt")}) +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v4}) +v40 := lang.Apply(v27, []any{v31, v35, v39}) +v41 := lang.Apply(v24, []any{v40}) +v42 := lang.Apply(v21, []any{v41}) +v43 := lang.Apply(v10, []any{v14, v18, v42}) +v44 := lang.Apply(v7, []any{v43}) +return v44 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("<").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns non-nil if nums are in monotonically increasing order,\n otherwise false.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(893), lang.NewKeyword("end-line"), int(893))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v4 := args[0] +return true + case 2: +v4 := args[0] +v5 := args[1] +v6, _ := lang.FieldOrMethod(lang1.Numbers, "lt") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("lt is not a function"))) +} +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := args[1] +v6 := lang.NewList(args[2:]...) +recur_loop_150: +var v7 any +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("<")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v4, v5}) +if lang.IsTruthy(v11) { +var v12 any +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("next")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v6}) +if lang.IsTruthy(v16) { +var v17 any = v5 +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("first")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v6}) +var v18 any = v22 +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("next")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v6}) +var v23 any = v27 +v4 = v17 +v5 = v18 +v6 = v23 +goto recur_loop_150 +} else { +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("<")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("first")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v6}) +v35 := lang.Apply(v30, []any{v5, v34}) +v12 = v35 +} +v7 = v12 +} else { +v7 = false +} +return v7 + } +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// set +{ +v0 := lang.NewSymbol("set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a set of the distinct elements of coll.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4104), lang.NewKeyword("end-line"), int(4104))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("set?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +if lang.IsTruthy(v8) { +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("with-meta")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v3, nil}) +v4 = v12 +} else { +var v13 any +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("instance?")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang1.IReduceInit, v3}) +if lang.IsTruthy(v17) { +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("persistent!")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("conj!")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("transient")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.CreatePersistentTreeSet() +v28 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4112), lang.NewKeyword("column"), int(108), lang.NewKeyword("end-line"), int(4112), lang.NewKeyword("end-column"), int(110)) +v29, err := lang.WithMeta(v27, v28.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v30 := lang.Apply(v26, []any{v29}) +v31, _ := lang.FieldOrMethod(v3, "ReduceInit") +if reflect.TypeOf(v31).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) +} +v32 := lang.Apply(v31, []any{v23, v30}) +v33 := lang.Apply(v20, []any{v32}) +v13 = v33 +} else { +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("persistent!")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("reduce1")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("conj!")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("transient")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +} +v45 := v44.Get() +v46 := lang.CreatePersistentTreeSet() +v47 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4113), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(4113), lang.NewKeyword("end-column"), int(48)) +v48, err := lang.WithMeta(v46, v47.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v49 := lang.Apply(v45, []any{v48}) +v50 := lang.Apply(v39, []any{v42, v49, v3}) +v51 := lang.Apply(v36, []any{v50}) +v13 = v51 +} +v4 = v13 +} +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +} From 193e143af72d519d5ad2b9645d82a13fdcd4ef4a Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sun, 17 Aug 2025 21:38:16 -0700 Subject: [PATCH 32/67] rm md files Signed-off-by: James Hamlin --- pkg/codegen/CLAUDE.md | 249 ------------------------------------------ pkg/codegen/README.md | 46 -------- 2 files changed, 295 deletions(-) delete mode 100644 pkg/codegen/CLAUDE.md delete mode 100644 pkg/codegen/README.md diff --git a/pkg/codegen/CLAUDE.md b/pkg/codegen/CLAUDE.md deleted file mode 100644 index 8125a6a2..00000000 --- a/pkg/codegen/CLAUDE.md +++ /dev/null @@ -1,249 +0,0 @@ -# Glojure Codegen System - -This document provides guidance for understanding and working with Glojure's ahead-of-time (AOT) code generation system. - -## Overview - -The codegen package transforms Glojure AST nodes into Go source code, enabling ahead-of-time compilation. This is a work-in-progress alternative to the default tree-walking interpreter that offers potential performance benefits through static compilation. - -## Architecture - -### Compilation Pipeline - -``` -Source (.glj) → Reader → S-expressions → Analyzer → AST → Codegen → Go Source → go build → Native Binary - ↓ - Runtime Eval (default path) -``` - -### Key Components - -- **Generator** (pkg/codegen/codegen.go:32-46): Main code generation engine - - Manages variable scopes and recur contexts - - Handles output buffering and Go code formatting - -- **AST Nodes** (pkg/ast/ast.go:17-158): 44 different operation types - - Each node has an `Op` field determining its type - - `Sub` field contains op-specific data structures - -- **Analyzer** (pkg/compiler/analyze.go): Creates AST from S-expressions - - Performs macro expansion (pkg/compiler/analyze.go:87-122) - - Manages lexical environments (pkg/compiler/analyze.go:32-51) - - Dispatches to specialized analyzers (pkg/compiler/analyze.go:196-408) - -## Current Implementation Status - -### ✅ Supported Features - -| Feature | Implementation | Reference | -|---------|----------------|-----------| -| Constants | Numbers, strings, keywords, booleans, nil | codegen.go:383-385 | -| Local Variables | Let bindings, function parameters | codegen.go:386-389 | -| Namespace Vars | Var dereference and lookup | codegen.go:410-433 | -| Functions | Single/multi-arity, variadic | codegen.go:258-331 | -| Let/Loop | Including loop/recur | codegen.go:555-614 | -| Recur | Tail recursion within loops | codegen.go:616-658 | -| If/Else | Conditional expressions | codegen.go:479-503 | -| Do Blocks | Sequential evaluation | codegen.go:462-477 | -| Function Calls | Via lang.Apply | codegen.go:435-460 | -| Collections | Vectors, Maps | codegen.go:215-256 | - -### ❌ Not Yet Implemented - -- Host interop (., .., new) -- Try/catch/finally -- Case expressions -- Set literals -- Metadata on functions -- deftype/defprotocol -- Lazy sequences -- Transducers - -## Code Generation Process - -### 1. Namespace Generation (codegen.go:50-132) - -```go -func (g *Generator) Generate(ns *lang.Namespace) error -``` - -- Iterates through namespace mappings -- Generates init() function containing var definitions -- Applies go fmt to output - -### 2. Var Generation (codegen.go:136-170) - -Each var becomes: -```go -{ - varSym := lang.NewSymbol("var-name") - var := ns.InternWithValue(varSym, value, true) - // metadata handling... -} -``` - -### 3. Value Generation (codegen.go:173-213) - -Recursively generates Go expressions for Clojure values: -- Primitives: Direct Go literals -- Collections: `lang.NewVector(...)`, `lang.NewMap(...)` -- Functions: `lang.IFnFunc(func(args ...any) any { ... })` - -### 4. AST Node Generation (codegen.go:361-408) - -Dispatches on `node.Op` to specialized generators: -- Control flow nodes generate Go control structures -- Expression nodes generate Go expressions -- Special forms have custom handling - -## Variable Scope Management - -### Scope Stack (codegen.go:19-23, 696-741) - -```go -type varScope struct { - nextNum int // Counter for unique var names - names map[string]string // Clojure name → Go var name -} -``` - -- Each let/fn/loop pushes new scope -- Variables allocated as v0, v1, v2... -- Scopes inherit counter from parent - -### Example Scoping - -```clojure -(let [x 1] ; x → v0 - (let [x 2 y 3] ; x → v1 (shadows), y → v2 - (+ x y))) ; references v1, v2 -``` - -## Loop/Recur Implementation - -### Recur Context (codegen.go:25-29) - -```go -type recurContext struct { - loopID *lang.Symbol // Matches recur to its loop - bindings []string // Go variable names for rebinding -} -``` - -### Generated Pattern (codegen.go:589-614, 616-658) - -```go -// (loop [x 0] ... (recur (inc x))) -var v0 any = 0 -for { - // body... - var recurTemp0 any = v0 + 1 // Evaluate recur args - v0 = recurTemp0 // Rebind - continue // Loop -} -``` - -## Testing Infrastructure - -### Test Harness (pkg/codegen/codegen_test.go) - -1. **Golden Files** (codegen_test.go:24-71): Compare generated output - - Input: `testdata/*.glj` - - Expected: `testdata/*.glj.expected` - -2. **Go Vet Validation** (codegen_test.go:207-223): Ensures valid Go syntax - -3. **Behavioral Tests** (codegen_test.go:72-172): Run generated code - - Compiles to temporary binary - - Executes -main function - - Verifies output - -### Running Tests - -```bash -# Run all codegen tests -go test ./pkg/codegen/... - -# Update golden files -go test ./pkg/codegen/... -update - -# Verbose output with generated code -go test ./pkg/codegen/... -v -``` - -## Extending the Codegen - -### Adding New AST Node Support - -1. Add case in `generateASTNode()` (codegen.go:361-408) -2. Implement generator function following pattern: - ```go - func (g *Generator) generateNewOp(node *ast.Node) string { - newOpNode := node.Sub.(*ast.NewOpNode) - // Generate Go code... - resultVar := g.allocateVar("result") - g.writef("...") - return resultVar - } - ``` -3. Add test case in `testdata/` -4. Run tests with `-update` to create expected output - -### Common Patterns - -**R-values vs Statements**: Generators return variable names (r-values) and emit statements to `g.w`: -```go -testExpr := g.generateASTNode(node.Test) // Get r-value -g.writef("if lang.IsTruthy(%s) {\n", testExpr) // Use in statement -``` - -**Temporary Variables**: Use `allocateVar()` for unique names: -```go -tempVar := g.allocateVar("temp") -g.writef("%s := complexExpression()\n", tempVar) -``` - -**Scope Management**: Always push/pop for new lexical scopes: -```go -g.pushVarScope() -defer g.popVarScope() -``` - -## Debugging Tips - -1. **Examine Generated Code**: Tests output generated code on failure -2. **Check AST Structure**: Use `fmt.Printf("%#v\n", node)` to inspect -3. **Trace Execution**: Add logging to generator methods -4. **Validate Manually**: Copy generated code to test file and run - -## Integration Points - -### Runtime Compatibility - -Generated code uses same primitives as runtime: -- `lang.Apply()` for function calls (pkg/lang/ifn.go:8-25) -- `lang.IsTruthy()` for conditionals (pkg/lang/truthy.go:3-18) -- `lang.NewList/Vector/Map()` for collections (pkg/lang/collections.go) - -### Namespace System - -Generated code integrates with runtime namespaces: -- `lang.FindOrCreateNamespace()` (pkg/lang/namespace.go:340-350) -- `ns.InternWithValue()` (pkg/lang/namespace.go:112-125) -- Vars are accessible from REPL after loading - -## Future Directions - -1. **Full AST Coverage**: Implement remaining node types -2. **Optimization**: Dead code elimination, constant folding -3. **Integration**: Add `glj compile` command for AOT compilation -4. **Performance**: Benchmark against runtime interpreter -5. **Debugging**: Source maps for generated code - -## Related Files - -- **AST Definition**: pkg/ast/ast.go -- **Analyzer**: pkg/compiler/analyze.go -- **Runtime Evaluator**: pkg/runtime/evalast.go (comparison reference) -- **Test Data**: pkg/codegen/testdata/*.glj -- **Language Primitives**: pkg/lang/*.go \ No newline at end of file diff --git a/pkg/codegen/README.md b/pkg/codegen/README.md deleted file mode 100644 index 7b6559a7..00000000 --- a/pkg/codegen/README.md +++ /dev/null @@ -1,46 +0,0 @@ -# Glojure Code Generator - -This package implements ahead-of-time (AOT) compilation of Glojure code to Go. - -## Structure - -- `codegen.go` - Core code generation logic -- `codegen_test.go` - Test harness that verifies generated code -- `testdata/` - Test cases with input `.glj` files and expected `.go` output - -## Running Tests - -```bash -# Run tests and verify generated code matches golden files -go test ./pkg/codegen - -# Update golden files when code generation changes -go test ./pkg/codegen -update -``` - -## How It Works - -1. **Input**: Glojure source code (`.glj` files) -2. **Parse**: Use Glojure reader to parse into s-expressions -3. **Analyze**: Use Glojure analyzer to produce AST nodes -4. **Generate**: Convert AST nodes to Go code -5. **Verify**: Compare with golden files and test behavior - -## Current Status - -- [x] Basic test harness infrastructure -- [x] OpConst support for numbers, strings, keywords -- [ ] OpConst support for other types (symbols, collections) -- [ ] Variable references (OpVar, OpLocal) -- [ ] Collection literals (OpVector, OpMap, OpSet) -- [ ] Control flow (OpIf, OpDo) -- [ ] Function invocation and definition -- [ ] Behavioral testing (compile and run generated code) - -## Next Steps - -1. Add support for more constant types -2. Implement behavioral testing that compiles and runs generated code -3. Add variable reference support -4. Expand to collection literals -5. Build up to more complex AST nodes \ No newline at end of file From 02ce5077de5cc1ad08d3ff6e011351b69289be23 Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sat, 23 Aug 2025 11:58:37 -0700 Subject: [PATCH 33/67] Omit eduction for now Signed-off-by: James Hamlin --- pkg/codegen/testdata/codegen/test/core.go | 720 +++++++++--------- pkg/codegen/testdata/codegen/test/fn_recur.go | 4 +- pkg/gen/gljimports/gljimports_darwin_amd64.go | 7 + pkg/gen/gljimports/gljimports_darwin_arm64.go | 7 + pkg/gen/gljimports/gljimports_js_wasm.go | 7 + pkg/gen/gljimports/gljimports_linux_amd64.go | 7 + pkg/gen/gljimports/gljimports_linux_arm64.go | 7 + .../gljimports/gljimports_windows_amd64.go | 7 + pkg/gen/gljimports/gljimports_windows_arm.go | 7 + pkg/lang/arraylist.go | 30 + pkg/lang/functional.go | 3 + pkg/lang/interfaces.go | 7 + pkg/lang/persistentarraymap.go | 12 + pkg/lang/persistenthashmap.go | 6 + pkg/lang/transformer_iterator.go | 67 ++ pkg/lang/vector.go | 6 + pkg/runtime/rtcompat.go | 57 +- pkg/stdlib/glojure/core.glj | 18 +- scripts/rewrite-core/rewrite.clj | 11 + test/glojure/test_glojure/transducers.glj | 409 ++++++++++ 20 files changed, 988 insertions(+), 411 deletions(-) create mode 100644 pkg/lang/arraylist.go create mode 100644 pkg/lang/transformer_iterator.go create mode 100644 test/glojure/test_glojure/transducers.glj diff --git a/pkg/codegen/testdata/codegen/test/core.go b/pkg/codegen/testdata/codegen/test/core.go index 7c26a035..d88a94ec 100644 --- a/pkg/codegen/testdata/codegen/test/core.go +++ b/pkg/codegen/testdata/codegen/test/core.go @@ -4,44 +4,41 @@ package generated import ( "github.com/glojurelang/glojure/pkg/lang" - Eduction28 "Eduction" - CompilerException34 "glojure.lang.Compiler/CompilerException" - lang1 "github.com/glojurelang/glojure/pkg/lang" + CompilerException31 "glojure.lang.Compiler/CompilerException" + runtime3 "github.com/glojurelang/glojure/pkg/runtime" strconv4 "strconv" - java.net16 "java.net" - StringBuilder19 "StringBuilder" - BigDecimal8 "BigDecimal" - rand36 "math/rand" - java.lang.UnsupportedOperationException29 "java.lang.UnsupportedOperationException" - regexp33 "regexp" BigInteger12 "BigInteger" - java.util13 "java.util" - Object23 "Object" - Exception25 "Exception" + regexp30 "regexp" + rand33 "math/rand" + reflect "reflect" strings22 "strings" - glojure.lang.Volatile24 "glojure.lang.Volatile" + java.lang.UnsupportedOperationException26 "java.lang.UnsupportedOperationException" + java.io.BufferedWriter21 "java.io.BufferedWriter" + time27 "time" + java.util13 "java.util" + java.util.concurrent15 "java.util.concurrent" + java.net16 "java.net" + Exception24 "Exception" + LinkedBlockingQueue28 "LinkedBlockingQueue" + java.util.concurrent.CountDownLatch29 "java.util.concurrent.CountDownLatch" + java.io.StringReader34 "java.io.StringReader" glojure.lang.LineNumberingPushbackReader5 "glojure.lang.LineNumberingPushbackReader" + java.io.InputStreamReader6 "java.io.InputStreamReader" + errors10 "errors" + fmt "fmt" math7 "math" + BigDecimal8 "BigDecimal" big9 "math/big" - java.lang.annotation17 "java.lang.annotation" + Object23 "Object" + java.lang32 "java.lang" bytes18 "bytes" - time30 "time" - java.util.concurrent.CountDownLatch32 "java.util.concurrent.CountDownLatch" - fmt "fmt" - java.io.InputStreamReader6 "java.io.InputStreamReader" - errors10 "errors" - glojure.lang11 "glojure.lang" - LinkedBlockingQueue31 "LinkedBlockingQueue" - ExceptionInfo14 "ExceptionInfo" - java.util.concurrent15 "java.util.concurrent" - java.io.BufferedWriter21 "java.io.BufferedWriter" - java.util.ArrayList27 "java.util.ArrayList" - reflect "reflect" - java.lang35 "java.lang" - java.io.StringReader37 "java.io.StringReader" - runtime3 "github.com/glojurelang/glojure/pkg/runtime" java.io.PrintWriter20 "java.io.PrintWriter" - runtime26 "runtime" + lang1 "github.com/glojurelang/glojure/pkg/lang" + ExceptionInfo14 "ExceptionInfo" + java.lang.annotation17 "java.lang.annotation" + glojure.lang11 "glojure.lang" + StringBuilder19 "StringBuilder" + runtime25 "runtime" ) func init() { // Closed-over values @@ -4610,7 +4607,7 @@ if v0.Meta() != nil { } // parse-double { -v0 := lang.NewSymbol("parse-double").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse string with floating point components and return a Double value,\n or nil if parse fails.\n\n Grammar: https://docs.oracle.com/javase/8/docs/api/java/lang/Double.html#valueOf-java.lang.String-", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7988), lang.NewKeyword("end-line"), int(7988))).(*lang.Symbol) +v0 := lang.NewSymbol("parse-double").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse string with floating point components and return a Double value,\n or nil if parse fails.\n\n Grammar: https://docs.oracle.com/javase/8/docs/api/java/lang/Double.html#valueOf-java.lang.String-", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7978), lang.NewKeyword("end-line"), int(7978))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -4659,7 +4656,7 @@ if v0.Meta() != nil { } // load-data-reader-file { -v0 := lang.NewSymbol("load-data-reader-file").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7889), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7889), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("mappings"), lang.NewSymbol("url"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v0 := lang.NewSymbol("load-data-reader-file").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7879), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7879), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("mappings"), lang.NewSymbol("url"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { @@ -4754,7 +4751,7 @@ if reflect.TypeOf(v35).Kind() != reflect.Func { v36 := lang.Apply(v35, []any{"cljc"}) if lang.IsTruthy(v36) { v37 := lang.NewMap(lang.NewKeyword("eof"), nil, lang.NewKeyword("read-cond"), lang.NewKeyword("allow")) -v38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7895), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7895), lang.NewKeyword("end-column"), int(52)) +v38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7885), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7885), lang.NewKeyword("end-column"), int(52)) v39, err := lang.WithMeta(v37, v38.(lang.IPersistentMap)) if err != nil { panic(err) @@ -4762,7 +4759,7 @@ if err != nil { v32 = v39 } else { v40 := lang.NewMap(lang.NewKeyword("eof"), nil) -v41 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7896), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7896), lang.NewKeyword("end-column"), int(34)) +v41 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7886), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7886), lang.NewKeyword("end-column"), int(34)) v42, err := lang.WithMeta(v40, v41.(lang.IPersistentMap)) if err != nil { panic(err) @@ -4810,7 +4807,7 @@ if v62.IsMacro() { v63 := v62.Get() v64 := lang.Apply(v63, []any{"Not a valid data-reader map"}) v65 := lang.NewMap(lang.NewKeyword("url"), v4) -v66 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7900), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(7900), lang.NewKeyword("end-column"), int(36)) +v66 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7890), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(7890), lang.NewKeyword("end-column"), int(36)) v67, err := lang.WithMeta(v65, v66.(lang.IPersistentMap)) if err != nil { panic(err) @@ -4884,7 +4881,7 @@ if v100.IsMacro() { v101 := v100.Get() v102 := lang.Apply(v101, []any{"Invalid form in data-reader file"}) v103 := lang.NewMap(lang.NewKeyword("url"), v4, lang.NewKeyword("form"), v76) -v104 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7905), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(7906), lang.NewKeyword("end-column"), int(38)) +v104 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7895), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(7896), lang.NewKeyword("end-column"), int(38)) v105, err := lang.WithMeta(v103, v104.(lang.IPersistentMap)) if err != nil { panic(err) @@ -4936,7 +4933,7 @@ if v115.IsMacro() { } v116 := v115.Get() v117 := lang.NewMap(lang.NewKeyword("url"), v4, lang.NewKeyword("conflict"), v76, lang.NewKeyword("mappings"), v73) -v118 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7911), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(7913), lang.NewKeyword("end-column"), int(44)) +v118 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7901), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(7903), lang.NewKeyword("end-column"), int(44)) v119, err := lang.WithMeta(v117, v118.(lang.IPersistentMap)) if err != nil { panic(err) @@ -4956,7 +4953,7 @@ v123 := v122.Get() v124 := lang.Apply(v123, []any{v73, v76, v107}) return v124 }) -v73 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7902), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(7914), lang.NewKeyword("end-column"), int(32)) +v73 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7892), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(7904), lang.NewKeyword("end-column"), int(32)) v74, err := lang.WithMeta(v72, v73.(lang.IPersistentMap)) if err != nil { panic(err) @@ -5828,7 +5825,7 @@ return v19 v2 := v1 _ = v2 } -v0 := lang.NewSymbol("NaN?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns true if num is NaN, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)), lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(8021), lang.NewKeyword("end-line"), int(8021))).(*lang.Symbol) +v0 := lang.NewSymbol("NaN?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns true if num is NaN, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)), lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(8011), lang.NewKeyword("end-line"), int(8011))).(*lang.Symbol) var v3 lang.FnFunc v3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -9237,7 +9234,7 @@ if v0.Meta() != nil { } // *default-data-reader-fn* { -v0 := lang.NewSymbol("*default-data-reader-fn*").WithMeta(lang.NewMap(lang.NewKeyword("doc"), "When no data reader is found for a tag and *default-data-reader-fn*\n is non-nil, it will be called with two arguments,\n the tag and the value. If *default-data-reader-fn* is nil (the\n default), an exception will be thrown for the unknown tag.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(59), lang.NewKeyword("column"), int(6), lang.NewKeyword("line"), int(7876), lang.NewKeyword("end-line"), int(7876), lang.NewKeyword("dynamic"), true)).(*lang.Symbol) +v0 := lang.NewSymbol("*default-data-reader-fn*").WithMeta(lang.NewMap(lang.NewKeyword("doc"), "When no data reader is found for a tag and *default-data-reader-fn*\n is non-nil, it will be called with two arguments,\n the tag and the value. If *default-data-reader-fn* is nil (the\n default), an exception will be thrown for the unknown tag.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(59), lang.NewKeyword("column"), int(6), lang.NewKeyword("line"), int(7866), lang.NewKeyword("end-line"), int(7866), lang.NewKeyword("dynamic"), true)).(*lang.Symbol) v1 := ns.InternWithValue(v0, nil, true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) @@ -12067,7 +12064,7 @@ if v0.Meta() != nil { } // uri? { -v0 := lang.NewSymbol("uri?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a java.net.URI", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7930), lang.NewKeyword("end-line"), int(7930))).(*lang.Symbol) +v0 := lang.NewSymbol("uri?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a java.net.URI", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7920), lang.NewKeyword("end-line"), int(7920))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -12509,7 +12506,7 @@ if v0.Meta() != nil { } // *data-readers* { -v0 := lang.NewSymbol("*data-readers*").WithMeta(lang.NewMap(lang.NewKeyword("doc"), "Map from reader tag symbols to data reader Vars.\n\n When Clojure starts, it searches for files named 'data_readers.clj'\n and 'data_readers.cljc' at the root of the classpath. Each such file\n must contain a literal map of symbols, like this:\n\n {foo/bar my.project.foo/bar\n foo/baz my.project/baz}\n\n The first symbol in each pair is a tag that will be recognized by\n the Clojure reader. The second symbol in the pair is the\n fully-qualified name of a Var which will be invoked by the reader to\n parse the form following the tag. For example, given the\n data_readers.clj file above, the Clojure reader would parse this\n form:\n\n #foo/bar [1 2 3]\n\n by invoking the Var #'my.project.foo/bar on the vector [1 2 3]. The\n data reader function is invoked on the form AFTER it has been read\n as a normal Clojure data structure by the reader.\n\n Reader tags without namespace qualifiers are reserved for\n Clojure. Default reader tags are defined in\n glojure.core/default-data-readers but may be overridden in\n data_readers.clj, data_readers.cljc, or by rebinding this Var.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(49), lang.NewKeyword("column"), int(6), lang.NewKeyword("line"), int(7847), lang.NewKeyword("end-line"), int(7847), lang.NewKeyword("dynamic"), true)).(*lang.Symbol) +v0 := lang.NewSymbol("*data-readers*").WithMeta(lang.NewMap(lang.NewKeyword("doc"), "Map from reader tag symbols to data reader Vars.\n\n When Clojure starts, it searches for files named 'data_readers.clj'\n and 'data_readers.cljc' at the root of the classpath. Each such file\n must contain a literal map of symbols, like this:\n\n {foo/bar my.project.foo/bar\n foo/baz my.project/baz}\n\n The first symbol in each pair is a tag that will be recognized by\n the Clojure reader. The second symbol in the pair is the\n fully-qualified name of a Var which will be invoked by the reader to\n parse the form following the tag. For example, given the\n data_readers.clj file above, the Clojure reader would parse this\n form:\n\n #foo/bar [1 2 3]\n\n by invoking the Var #'my.project.foo/bar on the vector [1 2 3]. The\n data reader function is invoked on the form AFTER it has been read\n as a normal Clojure data structure by the reader.\n\n Reader tags without namespace qualifiers are reserved for\n Clojure. Default reader tags are defined in\n glojure.core/default-data-readers but may be overridden in\n data_readers.clj, data_readers.cljc, or by rebinding this Var.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(49), lang.NewKeyword("column"), int(6), lang.NewKeyword("line"), int(7837), lang.NewKeyword("end-line"), int(7837), lang.NewKeyword("dynamic"), true)).(*lang.Symbol) v1 := ns.InternWithValue(v0, lang.NewMap(), true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) @@ -12911,7 +12908,7 @@ if v0.Meta() != nil { } // tapset { -v0 := lang.NewSymbol("tapset").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7935), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(7935), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v0 := lang.NewSymbol("tapset").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7925), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(7925), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) v2 := lang.NewAtom(lang.CreatePersistentTreeSet()) v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { @@ -12957,7 +12954,7 @@ if v0.Meta() != nil { } // iteration { -v0 := lang.NewSymbol("iteration").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("step"), lang.NewSymbol("&"), lang.NewMap(lang.NewKeyword("keys"), lang.NewVector(lang.NewSymbol("somef"), lang.NewSymbol("vf"), lang.NewSymbol("kf"), lang.NewSymbol("initk")), lang.NewKeyword("or"), lang.NewMap(lang.NewSymbol("vf"), lang.NewSymbol("identity"), lang.NewSymbol("kf"), lang.NewSymbol("identity"), lang.NewSymbol("somef"), lang.NewSymbol("some?"), lang.NewSymbol("initk"), nil)))), lang.NewKeyword("doc"), "Creates a seqable/reducible via repeated calls to step,\n a function of some (continuation token) 'k'. The first call to step\n will be passed initk, returning 'ret'. Iff (somef ret) is true,\n (vf ret) will be included in the iteration, else iteration will\n terminate and vf/kf will not be called. If (kf ret) is non-nil it\n will be passed to the next step call, else iteration will terminate.\n\n This can be used e.g. to consume APIs that return paginated or batched data.\n\n step - (possibly impure) fn of 'k' -> 'ret'\n\n :somef - fn of 'ret' -> logical true/false, default 'some?'\n :vf - fn of 'ret' -> 'v', a value produced by the iteration, default 'identity'\n :kf - fn of 'ret' -> 'next-k' or nil (signaling 'do not continue'), default 'identity'\n :initk - the first value passed to step, default 'nil'\n\n It is presumed that step with non-initk is unreproducible/non-idempotent.\n If step with initk is unreproducible it is on the consumer to not consume twice.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7769), lang.NewKeyword("end-line"), int(7769))).(*lang.Symbol) +v0 := lang.NewSymbol("iteration").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("step"), lang.NewSymbol("&"), lang.NewMap(lang.NewKeyword("keys"), lang.NewVector(lang.NewSymbol("somef"), lang.NewSymbol("vf"), lang.NewSymbol("kf"), lang.NewSymbol("initk")), lang.NewKeyword("or"), lang.NewMap(lang.NewSymbol("vf"), lang.NewSymbol("identity"), lang.NewSymbol("kf"), lang.NewSymbol("identity"), lang.NewSymbol("somef"), lang.NewSymbol("some?"), lang.NewSymbol("initk"), nil)))), lang.NewKeyword("doc"), "Creates a seqable/reducible via repeated calls to step,\n a function of some (continuation token) 'k'. The first call to step\n will be passed initk, returning 'ret'. Iff (somef ret) is true,\n (vf ret) will be included in the iteration, else iteration will\n terminate and vf/kf will not be called. If (kf ret) is non-nil it\n will be passed to the next step call, else iteration will terminate.\n\n This can be used e.g. to consume APIs that return paginated or batched data.\n\n step - (possibly impure) fn of 'k' -> 'ret'\n\n :somef - fn of 'ret' -> logical true/false, default 'some?'\n :vf - fn of 'ret' -> 'v', a value produced by the iteration, default 'identity'\n :kf - fn of 'ret' -> 'next-k' or nil (signaling 'do not continue'), default 'identity'\n :initk - the first value passed to step, default 'nil'\n\n It is presumed that step with non-initk is unreproducible/non-idempotent.\n If step with initk is unreproducible it is on the consumer to not consume twice.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7759), lang.NewKeyword("end-line"), int(7759))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -13086,7 +13083,7 @@ if v62.IsMacro() { } v63 := v62.Get() v64 := lang.NewVector(nil) -v65 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7796), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(7796), lang.NewKeyword("end-column"), int(11)) +v65 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7786), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(7786), lang.NewKeyword("end-column"), int(11)) v66, err := lang.WithMeta(v64, v65.(lang.IPersistentMap)) if err != nil { panic(err) @@ -13146,7 +13143,7 @@ return v70 v68 := v67 _ = v68 } -v68 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7797), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(7801), lang.NewKeyword("end-column"), int(51)) +v68 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7787), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(7791), lang.NewKeyword("end-column"), int(51)) v69, err := lang.WithMeta(v67, v68.(lang.IPersistentMap)) if err != nil { panic(err) @@ -13161,7 +13158,7 @@ if v74.IsMacro() { } v75 := v74.Get() v76 := lang.NewVector(nil, nil, nil) -v77 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7804), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(7804), lang.NewKeyword("end-column"), int(22)) +v77 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7794), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(7794), lang.NewKeyword("end-column"), int(22)) v78, err := lang.WithMeta(v76, v77.(lang.IPersistentMap)) if err != nil { panic(err) @@ -15027,7 +15024,7 @@ if v0.Meta() != nil { } // load-data-readers { -v0 := lang.NewSymbol("load-data-readers").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7918), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7918), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v0 := lang.NewSymbol("load-data-readers").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7908), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7908), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { @@ -15068,7 +15065,7 @@ v18 := lang.Apply(v17, nil) v19 := lang.Apply(v11, []any{v14, v8, v18}) return v19 }) -v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7920), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(7922), lang.NewKeyword("end-column"), int(57)) +v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7910), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(7912), lang.NewKeyword("end-column"), int(57)) v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) if err != nil { panic(err) @@ -16779,7 +16776,7 @@ if v0.Meta() != nil { } // data-reader-urls { -v0 := lang.NewSymbol("data-reader-urls").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7883), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7883), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v0 := lang.NewSymbol("data-reader-urls").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7873), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7873), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { @@ -19456,7 +19453,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5 := lang.Apply(glojure.lang.Volatile24., []any{v4}) +v5 := lang.Apply(lang1.NewVolatile, []any{v4}) return v5 }) v4 := reflect.TypeOf((*lang1.Volatile)(nil)).Elem() @@ -21598,7 +21595,7 @@ if v0.Meta() != nil { } // tagged-literal? { -v0 := lang.NewSymbol("tagged-literal?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("value"))), lang.NewKeyword("doc"), "Return true if the value is the data representation of a tagged literal", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7816), lang.NewKeyword("end-line"), int(7816))).(*lang.Symbol) +v0 := lang.NewSymbol("tagged-literal?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("value"))), lang.NewKeyword("doc"), "Return true if the value is the data representation of a tagged literal", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7806), lang.NewKeyword("end-line"), int(7806))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -25958,7 +25955,7 @@ if v0.Meta() != nil { } // remove-tap { -v0 := lang.NewSymbol("remove-tap").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Remove f from the tap set.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7936), lang.NewKeyword("end-line"), int(7936))).(*lang.Symbol) +v0 := lang.NewSymbol("remove-tap").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Remove f from the tap set.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7926), lang.NewKeyword("end-line"), int(7926))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -26082,7 +26079,7 @@ if v0.Meta() != nil { } // parse-long { -v0 := lang.NewSymbol("parse-long").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse string of decimal digits with optional leading -/+ and return a\n Long value, or nil if parse fails", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7979), lang.NewKeyword("end-line"), int(7979))).(*lang.Symbol) +v0 := lang.NewSymbol("parse-long").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse string of decimal digits with optional leading -/+ and return a\n Long value, or nil if parse fails", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7969), lang.NewKeyword("end-line"), int(7969))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -26368,7 +26365,7 @@ if v0.Meta() != nil { } // update-vals { -v0 := lang.NewSymbol("update-vals").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("f"))), lang.NewKeyword("doc"), "m f => {k (f v) ...}\n\n Given a map m and a function f of 1-argument, returns a new map where the keys of m\n are mapped to result of applying f to the corresponding values of m.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7943), lang.NewKeyword("end-line"), int(7943))).(*lang.Symbol) +v0 := lang.NewSymbol("update-vals").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("f"))), lang.NewKeyword("doc"), "m f => {k (f v) ...}\n\n Given a map m and a function f of 1-argument, returns a new map where the keys of m\n are mapped to result of applying f to the corresponding values of m.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7933), lang.NewKeyword("end-line"), int(7933))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { @@ -26412,7 +26409,7 @@ v21 := lang.Apply(v4, []any{v17}) v22 := lang.Apply(v20, []any{v15, v16, v21}) return v22 }) -v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7952), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(7952), lang.NewKeyword("end-column"), int(51)) +v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7942), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(7942), lang.NewKeyword("end-column"), int(51)) v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) if err != nil { panic(err) @@ -26442,7 +26439,7 @@ if v27.IsMacro() { } v28 := v27.Get() v29 := lang.NewMap() -v30 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7955), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(7955), lang.NewKeyword("end-column"), int(31)) +v30 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7945), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(7945), lang.NewKeyword("end-column"), int(31)) v31, err := lang.WithMeta(v29, v30.(lang.IPersistentMap)) if err != nil { panic(err) @@ -31816,7 +31813,7 @@ if v31.IsMacro() { } v32 := v31.Get() v33 := lang.Apply(v32, []any{v4, "already has", v5, "as ancestor"}) -v34 := lang.Apply(Exception25., []any{v33}) +v34 := lang.Apply(Exception24., []any{v33}) panic(v34) } else { v24 = nil @@ -31839,7 +31836,7 @@ if v42.IsMacro() { } v43 := v42.Get() v44 := lang.Apply(v43, []any{"Cyclic derivation:", v5, "has", v4, "as ancestor"}) -v45 := lang.Apply(Exception25., []any{v44}) +v45 := lang.Apply(Exception24., []any{v44}) panic(v45) } else { v35 = nil @@ -32300,7 +32297,7 @@ if v7.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } v8 := v7.Get() -v9 := lang.Apply(runtime26.NumCPU, nil) +v9 := lang.Apply(runtime25.NumCPU, nil) v10 := lang.Apply(v8, []any{int64(2), v9}) var v5 any = v10 _ = v5 @@ -33459,7 +33456,7 @@ if v0.Meta() != nil { } // tagged-literal { -v0 := lang.NewSymbol("tagged-literal").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag"), lang.NewSymbol("form"))), lang.NewKeyword("doc"), "Construct a data representation of a tagged literal from a\n tag symbol and a form.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7822), lang.NewKeyword("end-line"), int(7822))).(*lang.Symbol) +v0 := lang.NewSymbol("tagged-literal").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag"), lang.NewSymbol("form"))), lang.NewKeyword("doc"), "Construct a data representation of a tagged literal from a\n tag symbol and a form.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7812), lang.NewKeyword("end-line"), int(7812))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { @@ -36642,209 +36639,208 @@ v4 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v5 := args[0] -v7 := lang.Apply(java.util.ArrayList27., nil) -var v6 any = v7 +var v6 any = "unimplemented: new with non-constant class type" _ = v6 -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("volatile!")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("volatile!")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v11 := v10.Get() -v12 := lang.Apply(v11, []any{lang.NewKeyword("glojure.core/none")}) -var v8 any = v12 -_ = v8 -var v14 lang.FnFunc -v14 = lang.NewFnFunc(func(args ...any) any { +v10 := v9.Get() +v11 := lang.Apply(v10, []any{lang.NewKeyword("glojure.core/none")}) +var v7 any = v11 +_ = v7 +var v13 lang.FnFunc +v13 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: -v15 := lang.Apply(v5, nil) -return v15 +v14 := lang.Apply(v5, nil) +return v14 case 1: -v15 := args[0] -var v17 any -v18, ok := lang.FieldOrMethod(v6, "isEmpty") +v14 := args[0] +var v16 any +v17, ok := lang.FieldOrMethod(v6, "isEmpty") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "isEmpty"))) } -var v19 any -switch reflect.TypeOf(v18).Kind() { +var v18 any +switch reflect.TypeOf(v17).Kind() { case reflect.Func: - v19 = lang.Apply(v18, nil) + v18 = lang.Apply(v17, nil) default: - v19 = v18 + v18 = v17 } -if lang.IsTruthy(v19) { -v17 = v16 +if lang.IsTruthy(v18) { +v16 = v15 } else { -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("vec")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("vec")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v23 := v22.Get() -v24, ok := lang.FieldOrMethod(v6, "toArray") +v22 := v21.Get() +v23, ok := lang.FieldOrMethod(v6, "toArray") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "toArray"))) } -var v25 any -switch reflect.TypeOf(v24).Kind() { +var v24 any +switch reflect.TypeOf(v23).Kind() { case reflect.Func: - v25 = lang.Apply(v24, nil) + v24 = lang.Apply(v23, nil) default: - v25 = v24 + v24 = v23 } -v26 := lang.Apply(v23, []any{v25}) -var v20 any = v26 -_ = v20 -v28, ok := lang.FieldOrMethod(v6, "clear") +v25 := lang.Apply(v22, []any{v24}) +var v19 any = v25 +_ = v19 +v27, ok := lang.FieldOrMethod(v6, "clear") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "clear"))) } -var v29 any -switch reflect.TypeOf(v28).Kind() { +var v28 any +switch reflect.TypeOf(v27).Kind() { case reflect.Func: - v29 = lang.Apply(v28, nil) + v28 = lang.Apply(v27, nil) default: - v29 = v28 + v28 = v27 } -_ = v29 -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("unreduced")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +_ = v28 +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("unreduced")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) } -v32 := v31.Get() -v33 := lang.Apply(v5, []any{v16, v20}) -v34 := lang.Apply(v32, []any{v33}) -v17 = v34 +v31 := v30.Get() +v32 := lang.Apply(v5, []any{v15, v19}) +v33 := lang.Apply(v31, []any{v32}) +v16 = v33 } -var v16 any = v17 -_ = v16 -v21 := lang.Apply(v5, []any{v16}) -return v21 +var v15 any = v16 +_ = v15 +v20 := lang.Apply(v5, []any{v15}) +return v20 case 2: -v15 := args[0] -v16 := args[1] -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("deref")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v14 := args[0] +v15 := args[1] +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("deref")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v20 := v19.Get() -v21 := lang.Apply(v20, []any{v8}) -var v17 any = v21 -_ = v17 -v23 := lang.Apply(v3, []any{v16}) -var v22 any = v23 -_ = v22 -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("vreset!")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v7}) +var v16 any = v20 +_ = v16 +v22 := lang.Apply(v3, []any{v15}) +var v21 any = v22 +_ = v21 +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("vreset!")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -v27 := v26.Get() -v28 := lang.Apply(v27, []any{v8, v22}) -_ = v28 -var v29 any -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("identical?")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v7, v21}) +_ = v27 +var v28 any +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("identical?")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) } -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v17, lang.NewKeyword("glojure.core/none")}) -var v30 any = v34 -_ = v30 -var v36 any -if lang.IsTruthy(v30) { -v36 = v30 +v32 := v31.Get() +v33 := lang.Apply(v32, []any{v16, lang.NewKeyword("glojure.core/none")}) +var v29 any = v33 +_ = v29 +var v35 any +if lang.IsTruthy(v29) { +v35 = v29 } else { -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("=")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("=")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) } -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v22, v17}) -v36 = v40 +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v21, v16}) +v35 = v39 } -if lang.IsTruthy(v36) { -v30, _ := lang.FieldOrMethod(v6, "add") -if reflect.TypeOf(v30).Kind() != reflect.Func { +if lang.IsTruthy(v35) { +v29, _ := lang.FieldOrMethod(v6, "add") +if reflect.TypeOf(v29).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) } -v31 := lang.Apply(v30, []any{v16}) -_ = v31 -v29 = v15 +v30 := lang.Apply(v29, []any{v15}) +_ = v30 +v28 = v14 } else { -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("vec")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("vec")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) } -v35 := v34.Get() -v36, ok := lang.FieldOrMethod(v6, "toArray") +v34 := v33.Get() +v35, ok := lang.FieldOrMethod(v6, "toArray") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "toArray"))) } -var v37 any -switch reflect.TypeOf(v36).Kind() { +var v36 any +switch reflect.TypeOf(v35).Kind() { case reflect.Func: - v37 = lang.Apply(v36, nil) + v36 = lang.Apply(v35, nil) default: - v37 = v36 + v36 = v35 } -v38 := lang.Apply(v35, []any{v37}) -var v32 any = v38 -_ = v32 -v40, ok := lang.FieldOrMethod(v6, "clear") +v37 := lang.Apply(v34, []any{v36}) +var v31 any = v37 +_ = v31 +v39, ok := lang.FieldOrMethod(v6, "clear") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "clear"))) } -var v41 any -switch reflect.TypeOf(v40).Kind() { +var v40 any +switch reflect.TypeOf(v39).Kind() { case reflect.Func: - v41 = lang.Apply(v40, nil) + v40 = lang.Apply(v39, nil) default: - v41 = v40 + v40 = v39 } +_ = v40 +v42 := lang.Apply(v5, []any{v14, v31}) +var v41 any = v42 _ = v41 -v43 := lang.Apply(v5, []any{v15, v32}) -var v42 any = v43 -_ = v42 -var v45 any -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("reduced?")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +var v44 any +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("reduced?")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) } -v48 := v47.Get() -v49 := lang.Apply(v48, []any{v42}) -if lang.IsTruthy(v49) { -v45 = nil +v47 := v46.Get() +v48 := lang.Apply(v47, []any{v41}) +if lang.IsTruthy(v48) { +v44 = nil } else { -v50, _ := lang.FieldOrMethod(v6, "add") -if reflect.TypeOf(v50).Kind() != reflect.Func { +v49, _ := lang.FieldOrMethod(v6, "add") +if reflect.TypeOf(v49).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) } -v51 := lang.Apply(v50, []any{v16}) -v45 = v51 +v50 := lang.Apply(v49, []any{v15}) +v44 = v50 } -_ = v45 -v29 = v42 +_ = v44 +v28 = v41 } -return v29 +return v28 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) -v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7195), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(7219), lang.NewKeyword("end-column"), int(28)) -v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) +v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7195), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(7219), lang.NewKeyword("end-column"), int(28)) +v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) if err != nil { panic(err) } -return v16 +return v15 }) v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7192), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(7219), lang.NewKeyword("end-column"), int(30)) v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) @@ -39214,54 +39210,6 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// eduction -{ -v0 := lang.NewSymbol("eduction").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xform*"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a reducible/iterable application of the transducers\n to the items in coll. Transducers are applied in order as if\n combined with comp. Note that these applications will be\n performed every time reduce/iterator is called.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7751), lang.NewKeyword("end-line"), int(7751))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewList(args[0:]...) -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("apply")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("comp")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("butlast")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{v3}) -v14 := lang.Apply(v6, []any{v9, v13}) -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("last")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v3}) -v19 := lang.Apply(Eduction28., []any{v14, v18}) -return v19 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} // ex-message { v0 := lang.NewSymbol("ex-message").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ex"))), lang.NewKeyword("doc"), "Returns the message attached to ex if ex is a Throwable.\n Otherwise returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4820), lang.NewKeyword("end-line"), int(4820))).(*lang.Symbol) @@ -44194,7 +44142,7 @@ if v7.IsMacro() { v8 := v7.Get() v9 := lang.Apply(v8, []any{v4}) if lang.IsTruthy(v9) { -v10 := lang.Apply(java.lang.UnsupportedOperationException29., []any{"Can't get descendants of classes"}) +v10 := lang.Apply(java.lang.UnsupportedOperationException26., []any{"Can't get descendants of classes"}) panic(v10) } else { v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) @@ -47390,7 +47338,7 @@ v7, _ := lang.FieldOrMethod(v3, "Get") if reflect.TypeOf(v7).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Get is not a function"))) } -v8 := lang.Apply(v7, []any{v4, time30.Millisecond}) +v8 := lang.Apply(v7, []any{v4, time27.Millisecond}) v6 = v8 }() return v6 @@ -52280,7 +52228,7 @@ if v12.IsMacro() { } v13 := v12.Get() v14 := lang.Apply(v13, []any{v3}) -v15 := lang.Apply(LinkedBlockingQueue31., []any{v14}) +v15 := lang.Apply(LinkedBlockingQueue28., []any{v14}) v6 = v15 } var v5 any = v6 @@ -52760,7 +52708,7 @@ if v0.Meta() != nil { } // parse-uuid { -v0 := lang.NewSymbol("parse-uuid").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse a string representing a UUID and return a java.util.UUID instance,\n or nil if parse fails.\n\n Grammar: https://docs.oracle.com/javase/8/docs/api/java/util/UUID.html#toString--", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7999), lang.NewKeyword("end-line"), int(7999))).(*lang.Symbol) +v0 := lang.NewSymbol("parse-uuid").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse a string representing a UUID and return a java.util.UUID instance,\n or nil if parse fails.\n\n Grammar: https://docs.oracle.com/javase/8/docs/api/java/util/UUID.html#toString--", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7989), lang.NewKeyword("end-line"), int(7989))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -52926,7 +52874,7 @@ var v50 any if lang.IsTruthy(v41) { v50 = v41 } else { -v51 := lang.Apply(Exception25., []any{"ResultSet must have unique column labels"}) +v51 := lang.Apply(Exception24., []any{"ResultSet must have unique column labels"}) panic(v51) } var v40 any = v50 @@ -53856,7 +53804,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v4 := lang.Apply(java.util.concurrent.CountDownLatch32., []any{int64(1)}) +v4 := lang.Apply(java.util.concurrent.CountDownLatch29., []any{int64(1)}) var v3 any = v4 _ = v3 v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) @@ -53916,7 +53864,7 @@ v31, _ := lang.FieldOrMethod(v3, "await") if reflect.TypeOf(v31).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) } -v32 := lang.Apply(v31, []any{nil, time30.Millisecond}) +v32 := lang.Apply(v31, []any{nil, time27.Millisecond}) if lang.IsTruthy(v32) { v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v34 := v33.FindInternedVar(lang.NewSymbol("deref")) @@ -54129,155 +54077,162 @@ v4 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v5 := args[0] -v7 := lang.Apply(java.util.ArrayList27., []any{v3}) -var v6 any = v7 +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("to-array")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v3}) +v11 := lang.Apply(lang1.NewArrayList, []any{v10}) +var v6 any = v11 _ = v6 -var v9 lang.FnFunc -v9 = lang.NewFnFunc(func(args ...any) any { +var v13 lang.FnFunc +v13 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: -v10 := lang.Apply(v5, nil) -return v10 +v14 := lang.Apply(v5, nil) +return v14 case 1: -v10 := args[0] -var v12 any -v13, ok := lang.FieldOrMethod(v6, "isEmpty") +v14 := args[0] +var v16 any +v17, ok := lang.FieldOrMethod(v6, "isEmpty") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "isEmpty"))) } -var v14 any -switch reflect.TypeOf(v13).Kind() { +var v18 any +switch reflect.TypeOf(v17).Kind() { case reflect.Func: - v14 = lang.Apply(v13, nil) + v18 = lang.Apply(v17, nil) default: - v14 = v13 + v18 = v17 } -if lang.IsTruthy(v14) { -v12 = v11 +if lang.IsTruthy(v18) { +v16 = v15 } else { -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("vec")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("vec")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v18 := v17.Get() -v19, ok := lang.FieldOrMethod(v6, "toArray") +v22 := v21.Get() +v23, ok := lang.FieldOrMethod(v6, "toArray") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "toArray"))) } -var v20 any -switch reflect.TypeOf(v19).Kind() { +var v24 any +switch reflect.TypeOf(v23).Kind() { case reflect.Func: - v20 = lang.Apply(v19, nil) + v24 = lang.Apply(v23, nil) default: - v20 = v19 + v24 = v23 } -v21 := lang.Apply(v18, []any{v20}) -var v15 any = v21 -_ = v15 -v23, ok := lang.FieldOrMethod(v6, "clear") +v25 := lang.Apply(v22, []any{v24}) +var v19 any = v25 +_ = v19 +v27, ok := lang.FieldOrMethod(v6, "clear") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "clear"))) } -var v24 any -switch reflect.TypeOf(v23).Kind() { +var v28 any +switch reflect.TypeOf(v27).Kind() { case reflect.Func: - v24 = lang.Apply(v23, nil) + v28 = lang.Apply(v27, nil) default: - v24 = v23 + v28 = v27 } -_ = v24 -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("unreduced")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +_ = v28 +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("unreduced")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) } -v27 := v26.Get() -v28 := lang.Apply(v5, []any{v11, v15}) -v29 := lang.Apply(v27, []any{v28}) -v12 = v29 +v31 := v30.Get() +v32 := lang.Apply(v5, []any{v15, v19}) +v33 := lang.Apply(v31, []any{v32}) +v16 = v33 } -var v11 any = v12 -_ = v11 -v16 := lang.Apply(v5, []any{v11}) -return v16 +var v15 any = v16 +_ = v15 +v20 := lang.Apply(v5, []any{v15}) +return v20 case 2: -v10 := args[0] -v11 := args[1] -v12, _ := lang.FieldOrMethod(v6, "add") -if reflect.TypeOf(v12).Kind() != reflect.Func { +v14 := args[0] +v15 := args[1] +v16, _ := lang.FieldOrMethod(v6, "add") +if reflect.TypeOf(v16).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) } -v13 := lang.Apply(v12, []any{v11}) -_ = v13 -var v14 any -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("=")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +v17 := lang.Apply(v16, []any{v15}) +_ = v17 +var v18 any +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("=")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v17 := v16.Get() -v18, ok := lang.FieldOrMethod(v6, "size") +v21 := v20.Get() +v22, ok := lang.FieldOrMethod(v6, "size") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "size"))) } -var v19 any -switch reflect.TypeOf(v18).Kind() { +var v23 any +switch reflect.TypeOf(v22).Kind() { case reflect.Func: - v19 = lang.Apply(v18, nil) + v23 = lang.Apply(v22, nil) default: - v19 = v18 + v23 = v22 } -v20 := lang.Apply(v17, []any{v3, v19}) -if lang.IsTruthy(v20) { -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("vec")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v24 := lang.Apply(v21, []any{v3, v23}) +if lang.IsTruthy(v24) { +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("vec")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) } -v24 := v23.Get() -v25, ok := lang.FieldOrMethod(v6, "toArray") +v28 := v27.Get() +v29, ok := lang.FieldOrMethod(v6, "toArray") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "toArray"))) } -var v26 any -switch reflect.TypeOf(v25).Kind() { +var v30 any +switch reflect.TypeOf(v29).Kind() { case reflect.Func: - v26 = lang.Apply(v25, nil) + v30 = lang.Apply(v29, nil) default: - v26 = v25 + v30 = v29 } -v27 := lang.Apply(v24, []any{v26}) -var v21 any = v27 -_ = v21 -v29, ok := lang.FieldOrMethod(v6, "clear") +v31 := lang.Apply(v28, []any{v30}) +var v25 any = v31 +_ = v25 +v33, ok := lang.FieldOrMethod(v6, "clear") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "clear"))) } -var v30 any -switch reflect.TypeOf(v29).Kind() { +var v34 any +switch reflect.TypeOf(v33).Kind() { case reflect.Func: - v30 = lang.Apply(v29, nil) + v34 = lang.Apply(v33, nil) default: - v30 = v29 + v34 = v33 } -_ = v30 -v31 := lang.Apply(v5, []any{v10, v21}) -v14 = v31 +_ = v34 +v35 := lang.Apply(v5, []any{v14, v25}) +v18 = v35 } else { -v14 = v10 +v18 = v14 } -return v14 +return v18 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) -v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7274), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7290), lang.NewKeyword("end-column"), int(23)) -v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) +v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7274), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7290), lang.NewKeyword("end-column"), int(23)) +v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) if err != nil { panic(err) } -return v11 +return v15 }) v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7272), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7290), lang.NewKeyword("end-column"), int(25)) v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) @@ -57048,7 +57003,7 @@ if v0.Meta() != nil { } // reader-conditional? { -v0 := lang.NewSymbol("reader-conditional?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("value"))), lang.NewKeyword("doc"), "Return true if the value is the data representation of a reader conditional", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7829), lang.NewKeyword("end-line"), int(7829))).(*lang.Symbol) +v0 := lang.NewSymbol("reader-conditional?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("value"))), lang.NewKeyword("doc"), "Return true if the value is the data representation of a reader conditional", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7819), lang.NewKeyword("end-line"), int(7819))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -59668,7 +59623,7 @@ if v0.Meta() != nil { } // parse-boolean { -v0 := lang.NewSymbol("parse-boolean").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse strings \"true\" or \"false\" and return a boolean, or nil if invalid", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(8010), lang.NewKeyword("end-line"), int(8010))).(*lang.Symbol) +v0 := lang.NewSymbol("parse-boolean").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse strings \"true\" or \"false\" and return a boolean, or nil if invalid", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(8000), lang.NewKeyword("end-line"), int(8000))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -60964,7 +60919,7 @@ if v0.Meta() != nil { } // re-pattern { -v1 := reflect.TypeOf((*regexp33.Regexp)(nil)) +v1 := reflect.TypeOf((*regexp30.Regexp)(nil)) v0 := lang.NewSymbol("re-pattern").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns an instance of java.util.regex.Pattern, for use, e.g. in\n re-matcher.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4863), lang.NewKeyword("end-line"), int(4863))).(*lang.Symbol) var v3 lang.FnFunc v3 = lang.NewFnFunc(func(args ...any) any { @@ -60979,16 +60934,16 @@ if v7.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } v8 := v7.Get() -v9 := lang.Apply(v8, []any{regexp33.*Regexp, v4}) +v9 := lang.Apply(v8, []any{regexp30.*Regexp, v4}) if lang.IsTruthy(v9) { v5 = v4 } else { -v10 := lang.Apply(regexp33.MustCompile, []any{v4}) +v10 := lang.Apply(regexp30.MustCompile, []any{v4}) v5 = v10 } return v5 }) -v4 := reflect.TypeOf((*regexp33.Regexp)(nil)) +v4 := reflect.TypeOf((*regexp30.Regexp)(nil)) v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { @@ -63821,7 +63776,7 @@ if v17.IsMacro() { } v18 := v17.Get() v19 := lang.Apply(v18, []any{"No namespace: ", v3, " found"}) -v20 := lang.Apply(Exception25., []any{v19}) +v20 := lang.Apply(Exception24., []any{v19}) panic(v20) } v4 = v15 @@ -65665,7 +65620,7 @@ if v0.Meta() != nil { } // update-keys { -v0 := lang.NewSymbol("update-keys").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("f"))), lang.NewKeyword("doc"), "m f => {(f k) v ...}\n\n Given a map m and a function f of 1-argument, returns a new map whose\n keys are the result of applying f to the keys of m, mapped to the\n corresponding values of m.\n f must return a unique key for each key of m, else the behavior is undefined.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7959), lang.NewKeyword("end-line"), int(7959))).(*lang.Symbol) +v0 := lang.NewSymbol("update-keys").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("f"))), lang.NewKeyword("doc"), "m f => {(f k) v ...}\n\n Given a map m and a function f of 1-argument, returns a new map whose\n keys are the result of applying f to the keys of m, mapped to the\n corresponding values of m.\n f must return a unique key for each key of m, else the behavior is undefined.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7949), lang.NewKeyword("end-line"), int(7949))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { @@ -65703,7 +65658,7 @@ v19 := lang.Apply(v4, []any{v14}) v20 := lang.Apply(v18, []any{v13, v19, v15}) return v20 }) -v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7969), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7969), lang.NewKeyword("end-column"), int(59)) +v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7959), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7959), lang.NewKeyword("end-column"), int(59)) v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) if err != nil { panic(err) @@ -65715,7 +65670,7 @@ if v16.IsMacro() { } v17 := v16.Get() v18 := lang.NewMap() -v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7970), lang.NewKeyword("column"), int(36), lang.NewKeyword("end-line"), int(7970), lang.NewKeyword("end-column"), int(37)) +v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7960), lang.NewKeyword("column"), int(36), lang.NewKeyword("end-line"), int(7960), lang.NewKeyword("end-column"), int(37)) v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) if err != nil { panic(err) @@ -66247,7 +66202,7 @@ v13 := v12.Get() v14 := lang.Apply(v10, []any{v13, v4, v5}) var v7 any = v14 _ = v7 -v16 := lang.Apply(Exception25., []any{v7}) +v16 := lang.Apply(Exception24., []any{v7}) var v15 any = v16 _ = v15 v18, ok := lang.FieldOrMethod(v15, "getStackTrace") @@ -66353,7 +66308,7 @@ case reflect.Func: default: v46 = v45 } -v47 := lang.Apply(CompilerException34., []any{v42, v44, v46, v15}) +v47 := lang.Apply(CompilerException31., []any{v42, v44, v46, v15}) panic(v47) } else { v6 = nil @@ -66387,7 +66342,7 @@ if v0.Meta() != nil { } // run! { -v0 := lang.NewSymbol("run!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("proc"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Runs the supplied procedure (via reduce), for purposes of side\n effects, on successive items in the collection. Returns nil", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7761), lang.NewKeyword("end-line"), int(7761))).(*lang.Symbol) +v0 := lang.NewSymbol("run!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("proc"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Runs the supplied procedure (via reduce), for purposes of side\n effects, on successive items in the collection. Returns nil", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7751), lang.NewKeyword("end-line"), int(7751))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { @@ -66411,7 +66366,7 @@ v10 := args[1] v11 := lang.Apply(v3, []any{v10}) return v11 }) -v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7766), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(7766), lang.NewKeyword("end-column"), int(20)) +v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7756), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(7756), lang.NewKeyword("end-column"), int(20)) v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) if err != nil { panic(err) @@ -70183,7 +70138,7 @@ v108 := v107.Get() v109 := lang.Apply(v108, []any{v71}) v110 := lang.Apply(v105, []any{v109, int64(1)}) if lang.IsTruthy(v110) { -v111 := lang.Apply(Exception25., []any{"The syntax for defmulti has changed. Example: (defmulti name dispatch-fn :default dispatch-value)"}) +v111 := lang.Apply(Exception24., []any{"The syntax for defmulti has changed. Example: (defmulti name dispatch-fn :default dispatch-value)"}) panic(v111) } else { v102 = nil @@ -71146,7 +71101,7 @@ if v24.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } v25 := v24.Get() -v26 := lang.Apply(v25, []any{java.lang35.Enum, v16}) +v26 := lang.Apply(v25, []any{java.lang32.Enum, v16}) if lang.IsTruthy(v26) { v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v28 := v27.FindInternedVar(lang.NewSymbol("descriptor")) @@ -71677,7 +71632,7 @@ var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: -v3 := lang.Apply(rand36.Float64, nil) +v3 := lang.Apply(rand33.Float64, nil) return v3 case 1: v3 := args[0] @@ -74116,7 +74071,7 @@ if v0.Meta() != nil { } // parsing-err { -v0 := lang.NewSymbol("parsing-err").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Construct message for parsing for non-string parsing error", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(7974), lang.NewKeyword("end-line"), int(7974), lang.NewKeyword("private"), true)).(*lang.Symbol) +v0 := lang.NewSymbol("parsing-err").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Construct message for parsing for non-string parsing error", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(7964), lang.NewKeyword("end-line"), int(7964), lang.NewKeyword("private"), true)).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -74596,7 +74551,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v5 := lang.Apply(java.io.StringReader37., []any{v3}) +v5 := lang.Apply(java.io.StringReader34., []any{v3}) v6 := lang.Apply(glojure.lang.LineNumberingPushbackReader5., []any{v5}) var v4 any = v6 _ = v4 @@ -76324,7 +76279,7 @@ if v0.Meta() != nil { } // reader-conditional { -v0 := lang.NewSymbol("reader-conditional").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("form"), lang.NewSymbol("splicing?"))), lang.NewKeyword("doc"), "Construct a data representation of a reader conditional.\n If true, splicing? indicates read-cond-splicing.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7835), lang.NewKeyword("end-line"), int(7835))).(*lang.Symbol) +v0 := lang.NewSymbol("reader-conditional").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("form"), lang.NewSymbol("splicing?"))), lang.NewKeyword("doc"), "Construct a data representation of a reader conditional.\n If true, splicing? indicates read-cond-splicing.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7825), lang.NewKeyword("end-line"), int(7825))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { @@ -77495,24 +77450,31 @@ v2 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v5 := lang.Apply(java.util.ArrayList27., []any{v3}) -var v4 any = v5 +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("to-array")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +v9 := lang.Apply(lang1.NewArrayList, []any{v8}) +var v4 any = v9 _ = v4 -v7 := lang.Apply(nil, []any{v4}) -_ = v7 -v8, ok := lang.FieldOrMethod(v4, "toArray") +v11 := lang.Apply(nil, []any{v4}) +_ = v11 +v12, ok := lang.FieldOrMethod(v4, "toArray") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "toArray"))) } -var v9 any -switch reflect.TypeOf(v8).Kind() { +var v13 any +switch reflect.TypeOf(v12).Kind() { case reflect.Func: - v9 = lang.Apply(v8, nil) + v13 = lang.Apply(v12, nil) default: - v9 = v8 + v13 = v12 } -v10 := lang.Apply(nil, []any{v9}) -return v10 +v14 := lang.Apply(nil, []any{v13}) +return v14 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -79398,7 +79360,7 @@ return v19 v2 := v1 _ = v2 } -v0 := lang.NewSymbol("infinite?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns true if num is negative or positive infinity, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)), lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(8030), lang.NewKeyword("end-line"), int(8030))).(*lang.Symbol) +v0 := lang.NewSymbol("infinite?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns true if num is negative or positive infinity, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)), lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(8020), lang.NewKeyword("end-line"), int(8020))).(*lang.Symbol) var v3 lang.FnFunc v3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -81110,7 +81072,7 @@ if v0.Meta() != nil { } // data-reader-var { -v0 := lang.NewSymbol("data-reader-var").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7885), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7885), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v0 := lang.NewSymbol("data-reader-var").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7875), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7875), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { diff --git a/pkg/codegen/testdata/codegen/test/fn_recur.go b/pkg/codegen/testdata/codegen/test/fn_recur.go index bc3be496..a6a322a9 100644 --- a/pkg/codegen/testdata/codegen/test/fn_recur.go +++ b/pkg/codegen/testdata/codegen/test/fn_recur.go @@ -51,7 +51,7 @@ func init() { v7 := args[0] v8 := args[1] v9 := args[2] - recur_loop_1627: + recur_loop_1624: var v10 any v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v12 := v11.FindInternedVar(lang.NewSymbol("=")) @@ -83,7 +83,7 @@ func init() { v7 = v15 v8 = v16 v9 = v21 - goto recur_loop_1627 + goto recur_loop_1624 } return v10 }) diff --git a/pkg/gen/gljimports/gljimports_darwin_amd64.go b/pkg/gen/gljimports/gljimports_darwin_amd64.go index d14c026c..3d7dcfb9 100644 --- a/pkg/gen/gljimports/gljimports_darwin_amd64.go +++ b/pkg/gen/gljimports/gljimports_darwin_amd64.go @@ -3422,6 +3422,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.Apply", github_com_glojurelang_glojure_pkg_lang.Apply) _register("github.com/glojurelang/glojure/pkg/lang.ArithmeticError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ArithmeticError)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*ArithmeticError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ArithmeticError)(nil))) + _register("github.com/glojurelang/glojure/pkg/lang.ArrayList", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ArrayList)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.*ArrayList", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ArrayList)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.ArrayNode", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ArrayNode)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*ArrayNode", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ArrayNode)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.ArrayNodeIterator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ArrayNodeIterator)(nil)).Elem()) @@ -3604,6 +3606,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.IsSeq", github_com_glojurelang_glojure_pkg_lang.IsSeq) _register("github.com/glojurelang/glojure/pkg/lang.IsTruthy", github_com_glojurelang_glojure_pkg_lang.IsTruthy) _register("github.com/glojurelang/glojure/pkg/lang.IsZero", github_com_glojurelang_glojure_pkg_lang.IsZero) + _register("github.com/glojurelang/glojure/pkg/lang.Iterator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Iterator)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.KWAliases", github_com_glojurelang_glojure_pkg_lang.KWAliases) _register("github.com/glojurelang/glojure/pkg/lang.KWArg", github_com_glojurelang_glojure_pkg_lang.KWArg) _register("github.com/glojurelang/glojure/pkg/lang.KWArgId", github_com_glojurelang_glojure_pkg_lang.KWArgId) @@ -3765,6 +3768,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NamespaceFor", github_com_glojurelang_glojure_pkg_lang.NamespaceFor) _register("github.com/glojurelang/glojure/pkg/lang.Namespaces", github_com_glojurelang_glojure_pkg_lang.Namespaces) _register("github.com/glojurelang/glojure/pkg/lang.NewArithmeticError", github_com_glojurelang_glojure_pkg_lang.NewArithmeticError) + _register("github.com/glojurelang/glojure/pkg/lang.NewArrayList", github_com_glojurelang_glojure_pkg_lang.NewArrayList) _register("github.com/glojurelang/glojure/pkg/lang.NewAtom", github_com_glojurelang_glojure_pkg_lang.NewAtom) _register("github.com/glojurelang/glojure/pkg/lang.NewAtomWithMeta", github_com_glojurelang_glojure_pkg_lang.NewAtomWithMeta) _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimal", github_com_glojurelang_glojure_pkg_lang.NewBigDecimal) @@ -3818,6 +3822,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewSubVector", github_com_glojurelang_glojure_pkg_lang.NewSubVector) _register("github.com/glojurelang/glojure/pkg/lang.NewSymbol", github_com_glojurelang_glojure_pkg_lang.NewSymbol) _register("github.com/glojurelang/glojure/pkg/lang.NewTimeoutError", github_com_glojurelang_glojure_pkg_lang.NewTimeoutError) + _register("github.com/glojurelang/glojure/pkg/lang.NewTransformerIterator", github_com_glojurelang_glojure_pkg_lang.NewTransformerIterator) _register("github.com/glojurelang/glojure/pkg/lang.NewVar", github_com_glojurelang_glojure_pkg_lang.NewVar) _register("github.com/glojurelang/glojure/pkg/lang.NewVarWithRoot", github_com_glojurelang_glojure_pkg_lang.NewVarWithRoot) _register("github.com/glojurelang/glojure/pkg/lang.NewVector", github_com_glojurelang_glojure_pkg_lang.NewVector) @@ -3912,6 +3917,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.*TimeoutError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TimeoutError)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.ToSlice", github_com_glojurelang_glojure_pkg_lang.ToSlice) _register("github.com/glojurelang/glojure/pkg/lang.ToString", github_com_glojurelang_glojure_pkg_lang.ToString) + _register("github.com/glojurelang/glojure/pkg/lang.TransformerIterator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransformerIterator)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.*TransformerIterator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransformerIterator)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.TransientMap", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransientMap)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*TransientMap", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransientMap)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.TransientSet", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransientSet)(nil)).Elem()) diff --git a/pkg/gen/gljimports/gljimports_darwin_arm64.go b/pkg/gen/gljimports/gljimports_darwin_arm64.go index a151ba45..ce8d350b 100644 --- a/pkg/gen/gljimports/gljimports_darwin_arm64.go +++ b/pkg/gen/gljimports/gljimports_darwin_arm64.go @@ -3422,6 +3422,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.Apply", github_com_glojurelang_glojure_pkg_lang.Apply) _register("github.com/glojurelang/glojure/pkg/lang.ArithmeticError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ArithmeticError)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*ArithmeticError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ArithmeticError)(nil))) + _register("github.com/glojurelang/glojure/pkg/lang.ArrayList", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ArrayList)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.*ArrayList", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ArrayList)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.ArrayNode", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ArrayNode)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*ArrayNode", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ArrayNode)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.ArrayNodeIterator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ArrayNodeIterator)(nil)).Elem()) @@ -3604,6 +3606,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.IsSeq", github_com_glojurelang_glojure_pkg_lang.IsSeq) _register("github.com/glojurelang/glojure/pkg/lang.IsTruthy", github_com_glojurelang_glojure_pkg_lang.IsTruthy) _register("github.com/glojurelang/glojure/pkg/lang.IsZero", github_com_glojurelang_glojure_pkg_lang.IsZero) + _register("github.com/glojurelang/glojure/pkg/lang.Iterator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Iterator)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.KWAliases", github_com_glojurelang_glojure_pkg_lang.KWAliases) _register("github.com/glojurelang/glojure/pkg/lang.KWArg", github_com_glojurelang_glojure_pkg_lang.KWArg) _register("github.com/glojurelang/glojure/pkg/lang.KWArgId", github_com_glojurelang_glojure_pkg_lang.KWArgId) @@ -3765,6 +3768,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NamespaceFor", github_com_glojurelang_glojure_pkg_lang.NamespaceFor) _register("github.com/glojurelang/glojure/pkg/lang.Namespaces", github_com_glojurelang_glojure_pkg_lang.Namespaces) _register("github.com/glojurelang/glojure/pkg/lang.NewArithmeticError", github_com_glojurelang_glojure_pkg_lang.NewArithmeticError) + _register("github.com/glojurelang/glojure/pkg/lang.NewArrayList", github_com_glojurelang_glojure_pkg_lang.NewArrayList) _register("github.com/glojurelang/glojure/pkg/lang.NewAtom", github_com_glojurelang_glojure_pkg_lang.NewAtom) _register("github.com/glojurelang/glojure/pkg/lang.NewAtomWithMeta", github_com_glojurelang_glojure_pkg_lang.NewAtomWithMeta) _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimal", github_com_glojurelang_glojure_pkg_lang.NewBigDecimal) @@ -3818,6 +3822,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewSubVector", github_com_glojurelang_glojure_pkg_lang.NewSubVector) _register("github.com/glojurelang/glojure/pkg/lang.NewSymbol", github_com_glojurelang_glojure_pkg_lang.NewSymbol) _register("github.com/glojurelang/glojure/pkg/lang.NewTimeoutError", github_com_glojurelang_glojure_pkg_lang.NewTimeoutError) + _register("github.com/glojurelang/glojure/pkg/lang.NewTransformerIterator", github_com_glojurelang_glojure_pkg_lang.NewTransformerIterator) _register("github.com/glojurelang/glojure/pkg/lang.NewVar", github_com_glojurelang_glojure_pkg_lang.NewVar) _register("github.com/glojurelang/glojure/pkg/lang.NewVarWithRoot", github_com_glojurelang_glojure_pkg_lang.NewVarWithRoot) _register("github.com/glojurelang/glojure/pkg/lang.NewVector", github_com_glojurelang_glojure_pkg_lang.NewVector) @@ -3912,6 +3917,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.*TimeoutError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TimeoutError)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.ToSlice", github_com_glojurelang_glojure_pkg_lang.ToSlice) _register("github.com/glojurelang/glojure/pkg/lang.ToString", github_com_glojurelang_glojure_pkg_lang.ToString) + _register("github.com/glojurelang/glojure/pkg/lang.TransformerIterator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransformerIterator)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.*TransformerIterator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransformerIterator)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.TransientMap", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransientMap)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*TransientMap", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransientMap)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.TransientSet", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransientSet)(nil)).Elem()) diff --git a/pkg/gen/gljimports/gljimports_js_wasm.go b/pkg/gen/gljimports/gljimports_js_wasm.go index 6a25de3b..7df65a69 100644 --- a/pkg/gen/gljimports/gljimports_js_wasm.go +++ b/pkg/gen/gljimports/gljimports_js_wasm.go @@ -3422,6 +3422,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.Apply", github_com_glojurelang_glojure_pkg_lang.Apply) _register("github.com/glojurelang/glojure/pkg/lang.ArithmeticError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ArithmeticError)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*ArithmeticError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ArithmeticError)(nil))) + _register("github.com/glojurelang/glojure/pkg/lang.ArrayList", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ArrayList)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.*ArrayList", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ArrayList)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.ArrayNode", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ArrayNode)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*ArrayNode", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ArrayNode)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.ArrayNodeIterator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ArrayNodeIterator)(nil)).Elem()) @@ -3604,6 +3606,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.IsSeq", github_com_glojurelang_glojure_pkg_lang.IsSeq) _register("github.com/glojurelang/glojure/pkg/lang.IsTruthy", github_com_glojurelang_glojure_pkg_lang.IsTruthy) _register("github.com/glojurelang/glojure/pkg/lang.IsZero", github_com_glojurelang_glojure_pkg_lang.IsZero) + _register("github.com/glojurelang/glojure/pkg/lang.Iterator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Iterator)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.KWAliases", github_com_glojurelang_glojure_pkg_lang.KWAliases) _register("github.com/glojurelang/glojure/pkg/lang.KWArg", github_com_glojurelang_glojure_pkg_lang.KWArg) _register("github.com/glojurelang/glojure/pkg/lang.KWArgId", github_com_glojurelang_glojure_pkg_lang.KWArgId) @@ -3765,6 +3768,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NamespaceFor", github_com_glojurelang_glojure_pkg_lang.NamespaceFor) _register("github.com/glojurelang/glojure/pkg/lang.Namespaces", github_com_glojurelang_glojure_pkg_lang.Namespaces) _register("github.com/glojurelang/glojure/pkg/lang.NewArithmeticError", github_com_glojurelang_glojure_pkg_lang.NewArithmeticError) + _register("github.com/glojurelang/glojure/pkg/lang.NewArrayList", github_com_glojurelang_glojure_pkg_lang.NewArrayList) _register("github.com/glojurelang/glojure/pkg/lang.NewAtom", github_com_glojurelang_glojure_pkg_lang.NewAtom) _register("github.com/glojurelang/glojure/pkg/lang.NewAtomWithMeta", github_com_glojurelang_glojure_pkg_lang.NewAtomWithMeta) _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimal", github_com_glojurelang_glojure_pkg_lang.NewBigDecimal) @@ -3818,6 +3822,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewSubVector", github_com_glojurelang_glojure_pkg_lang.NewSubVector) _register("github.com/glojurelang/glojure/pkg/lang.NewSymbol", github_com_glojurelang_glojure_pkg_lang.NewSymbol) _register("github.com/glojurelang/glojure/pkg/lang.NewTimeoutError", github_com_glojurelang_glojure_pkg_lang.NewTimeoutError) + _register("github.com/glojurelang/glojure/pkg/lang.NewTransformerIterator", github_com_glojurelang_glojure_pkg_lang.NewTransformerIterator) _register("github.com/glojurelang/glojure/pkg/lang.NewVar", github_com_glojurelang_glojure_pkg_lang.NewVar) _register("github.com/glojurelang/glojure/pkg/lang.NewVarWithRoot", github_com_glojurelang_glojure_pkg_lang.NewVarWithRoot) _register("github.com/glojurelang/glojure/pkg/lang.NewVector", github_com_glojurelang_glojure_pkg_lang.NewVector) @@ -3912,6 +3917,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.*TimeoutError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TimeoutError)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.ToSlice", github_com_glojurelang_glojure_pkg_lang.ToSlice) _register("github.com/glojurelang/glojure/pkg/lang.ToString", github_com_glojurelang_glojure_pkg_lang.ToString) + _register("github.com/glojurelang/glojure/pkg/lang.TransformerIterator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransformerIterator)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.*TransformerIterator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransformerIterator)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.TransientMap", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransientMap)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*TransientMap", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransientMap)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.TransientSet", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransientSet)(nil)).Elem()) diff --git a/pkg/gen/gljimports/gljimports_linux_amd64.go b/pkg/gen/gljimports/gljimports_linux_amd64.go index 8e6a3a8d..8a89186d 100644 --- a/pkg/gen/gljimports/gljimports_linux_amd64.go +++ b/pkg/gen/gljimports/gljimports_linux_amd64.go @@ -3422,6 +3422,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.Apply", github_com_glojurelang_glojure_pkg_lang.Apply) _register("github.com/glojurelang/glojure/pkg/lang.ArithmeticError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ArithmeticError)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*ArithmeticError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ArithmeticError)(nil))) + _register("github.com/glojurelang/glojure/pkg/lang.ArrayList", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ArrayList)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.*ArrayList", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ArrayList)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.ArrayNode", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ArrayNode)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*ArrayNode", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ArrayNode)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.ArrayNodeIterator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ArrayNodeIterator)(nil)).Elem()) @@ -3604,6 +3606,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.IsSeq", github_com_glojurelang_glojure_pkg_lang.IsSeq) _register("github.com/glojurelang/glojure/pkg/lang.IsTruthy", github_com_glojurelang_glojure_pkg_lang.IsTruthy) _register("github.com/glojurelang/glojure/pkg/lang.IsZero", github_com_glojurelang_glojure_pkg_lang.IsZero) + _register("github.com/glojurelang/glojure/pkg/lang.Iterator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Iterator)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.KWAliases", github_com_glojurelang_glojure_pkg_lang.KWAliases) _register("github.com/glojurelang/glojure/pkg/lang.KWArg", github_com_glojurelang_glojure_pkg_lang.KWArg) _register("github.com/glojurelang/glojure/pkg/lang.KWArgId", github_com_glojurelang_glojure_pkg_lang.KWArgId) @@ -3765,6 +3768,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NamespaceFor", github_com_glojurelang_glojure_pkg_lang.NamespaceFor) _register("github.com/glojurelang/glojure/pkg/lang.Namespaces", github_com_glojurelang_glojure_pkg_lang.Namespaces) _register("github.com/glojurelang/glojure/pkg/lang.NewArithmeticError", github_com_glojurelang_glojure_pkg_lang.NewArithmeticError) + _register("github.com/glojurelang/glojure/pkg/lang.NewArrayList", github_com_glojurelang_glojure_pkg_lang.NewArrayList) _register("github.com/glojurelang/glojure/pkg/lang.NewAtom", github_com_glojurelang_glojure_pkg_lang.NewAtom) _register("github.com/glojurelang/glojure/pkg/lang.NewAtomWithMeta", github_com_glojurelang_glojure_pkg_lang.NewAtomWithMeta) _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimal", github_com_glojurelang_glojure_pkg_lang.NewBigDecimal) @@ -3818,6 +3822,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewSubVector", github_com_glojurelang_glojure_pkg_lang.NewSubVector) _register("github.com/glojurelang/glojure/pkg/lang.NewSymbol", github_com_glojurelang_glojure_pkg_lang.NewSymbol) _register("github.com/glojurelang/glojure/pkg/lang.NewTimeoutError", github_com_glojurelang_glojure_pkg_lang.NewTimeoutError) + _register("github.com/glojurelang/glojure/pkg/lang.NewTransformerIterator", github_com_glojurelang_glojure_pkg_lang.NewTransformerIterator) _register("github.com/glojurelang/glojure/pkg/lang.NewVar", github_com_glojurelang_glojure_pkg_lang.NewVar) _register("github.com/glojurelang/glojure/pkg/lang.NewVarWithRoot", github_com_glojurelang_glojure_pkg_lang.NewVarWithRoot) _register("github.com/glojurelang/glojure/pkg/lang.NewVector", github_com_glojurelang_glojure_pkg_lang.NewVector) @@ -3912,6 +3917,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.*TimeoutError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TimeoutError)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.ToSlice", github_com_glojurelang_glojure_pkg_lang.ToSlice) _register("github.com/glojurelang/glojure/pkg/lang.ToString", github_com_glojurelang_glojure_pkg_lang.ToString) + _register("github.com/glojurelang/glojure/pkg/lang.TransformerIterator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransformerIterator)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.*TransformerIterator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransformerIterator)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.TransientMap", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransientMap)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*TransientMap", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransientMap)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.TransientSet", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransientSet)(nil)).Elem()) diff --git a/pkg/gen/gljimports/gljimports_linux_arm64.go b/pkg/gen/gljimports/gljimports_linux_arm64.go index e393d8b4..ac133be0 100644 --- a/pkg/gen/gljimports/gljimports_linux_arm64.go +++ b/pkg/gen/gljimports/gljimports_linux_arm64.go @@ -3422,6 +3422,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.Apply", github_com_glojurelang_glojure_pkg_lang.Apply) _register("github.com/glojurelang/glojure/pkg/lang.ArithmeticError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ArithmeticError)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*ArithmeticError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ArithmeticError)(nil))) + _register("github.com/glojurelang/glojure/pkg/lang.ArrayList", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ArrayList)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.*ArrayList", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ArrayList)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.ArrayNode", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ArrayNode)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*ArrayNode", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ArrayNode)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.ArrayNodeIterator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ArrayNodeIterator)(nil)).Elem()) @@ -3604,6 +3606,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.IsSeq", github_com_glojurelang_glojure_pkg_lang.IsSeq) _register("github.com/glojurelang/glojure/pkg/lang.IsTruthy", github_com_glojurelang_glojure_pkg_lang.IsTruthy) _register("github.com/glojurelang/glojure/pkg/lang.IsZero", github_com_glojurelang_glojure_pkg_lang.IsZero) + _register("github.com/glojurelang/glojure/pkg/lang.Iterator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Iterator)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.KWAliases", github_com_glojurelang_glojure_pkg_lang.KWAliases) _register("github.com/glojurelang/glojure/pkg/lang.KWArg", github_com_glojurelang_glojure_pkg_lang.KWArg) _register("github.com/glojurelang/glojure/pkg/lang.KWArgId", github_com_glojurelang_glojure_pkg_lang.KWArgId) @@ -3765,6 +3768,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NamespaceFor", github_com_glojurelang_glojure_pkg_lang.NamespaceFor) _register("github.com/glojurelang/glojure/pkg/lang.Namespaces", github_com_glojurelang_glojure_pkg_lang.Namespaces) _register("github.com/glojurelang/glojure/pkg/lang.NewArithmeticError", github_com_glojurelang_glojure_pkg_lang.NewArithmeticError) + _register("github.com/glojurelang/glojure/pkg/lang.NewArrayList", github_com_glojurelang_glojure_pkg_lang.NewArrayList) _register("github.com/glojurelang/glojure/pkg/lang.NewAtom", github_com_glojurelang_glojure_pkg_lang.NewAtom) _register("github.com/glojurelang/glojure/pkg/lang.NewAtomWithMeta", github_com_glojurelang_glojure_pkg_lang.NewAtomWithMeta) _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimal", github_com_glojurelang_glojure_pkg_lang.NewBigDecimal) @@ -3818,6 +3822,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewSubVector", github_com_glojurelang_glojure_pkg_lang.NewSubVector) _register("github.com/glojurelang/glojure/pkg/lang.NewSymbol", github_com_glojurelang_glojure_pkg_lang.NewSymbol) _register("github.com/glojurelang/glojure/pkg/lang.NewTimeoutError", github_com_glojurelang_glojure_pkg_lang.NewTimeoutError) + _register("github.com/glojurelang/glojure/pkg/lang.NewTransformerIterator", github_com_glojurelang_glojure_pkg_lang.NewTransformerIterator) _register("github.com/glojurelang/glojure/pkg/lang.NewVar", github_com_glojurelang_glojure_pkg_lang.NewVar) _register("github.com/glojurelang/glojure/pkg/lang.NewVarWithRoot", github_com_glojurelang_glojure_pkg_lang.NewVarWithRoot) _register("github.com/glojurelang/glojure/pkg/lang.NewVector", github_com_glojurelang_glojure_pkg_lang.NewVector) @@ -3912,6 +3917,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.*TimeoutError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TimeoutError)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.ToSlice", github_com_glojurelang_glojure_pkg_lang.ToSlice) _register("github.com/glojurelang/glojure/pkg/lang.ToString", github_com_glojurelang_glojure_pkg_lang.ToString) + _register("github.com/glojurelang/glojure/pkg/lang.TransformerIterator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransformerIterator)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.*TransformerIterator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransformerIterator)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.TransientMap", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransientMap)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*TransientMap", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransientMap)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.TransientSet", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransientSet)(nil)).Elem()) diff --git a/pkg/gen/gljimports/gljimports_windows_amd64.go b/pkg/gen/gljimports/gljimports_windows_amd64.go index 95fffe71..3fa1ff3b 100644 --- a/pkg/gen/gljimports/gljimports_windows_amd64.go +++ b/pkg/gen/gljimports/gljimports_windows_amd64.go @@ -3422,6 +3422,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.Apply", github_com_glojurelang_glojure_pkg_lang.Apply) _register("github.com/glojurelang/glojure/pkg/lang.ArithmeticError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ArithmeticError)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*ArithmeticError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ArithmeticError)(nil))) + _register("github.com/glojurelang/glojure/pkg/lang.ArrayList", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ArrayList)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.*ArrayList", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ArrayList)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.ArrayNode", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ArrayNode)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*ArrayNode", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ArrayNode)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.ArrayNodeIterator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ArrayNodeIterator)(nil)).Elem()) @@ -3604,6 +3606,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.IsSeq", github_com_glojurelang_glojure_pkg_lang.IsSeq) _register("github.com/glojurelang/glojure/pkg/lang.IsTruthy", github_com_glojurelang_glojure_pkg_lang.IsTruthy) _register("github.com/glojurelang/glojure/pkg/lang.IsZero", github_com_glojurelang_glojure_pkg_lang.IsZero) + _register("github.com/glojurelang/glojure/pkg/lang.Iterator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Iterator)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.KWAliases", github_com_glojurelang_glojure_pkg_lang.KWAliases) _register("github.com/glojurelang/glojure/pkg/lang.KWArg", github_com_glojurelang_glojure_pkg_lang.KWArg) _register("github.com/glojurelang/glojure/pkg/lang.KWArgId", github_com_glojurelang_glojure_pkg_lang.KWArgId) @@ -3765,6 +3768,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NamespaceFor", github_com_glojurelang_glojure_pkg_lang.NamespaceFor) _register("github.com/glojurelang/glojure/pkg/lang.Namespaces", github_com_glojurelang_glojure_pkg_lang.Namespaces) _register("github.com/glojurelang/glojure/pkg/lang.NewArithmeticError", github_com_glojurelang_glojure_pkg_lang.NewArithmeticError) + _register("github.com/glojurelang/glojure/pkg/lang.NewArrayList", github_com_glojurelang_glojure_pkg_lang.NewArrayList) _register("github.com/glojurelang/glojure/pkg/lang.NewAtom", github_com_glojurelang_glojure_pkg_lang.NewAtom) _register("github.com/glojurelang/glojure/pkg/lang.NewAtomWithMeta", github_com_glojurelang_glojure_pkg_lang.NewAtomWithMeta) _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimal", github_com_glojurelang_glojure_pkg_lang.NewBigDecimal) @@ -3818,6 +3822,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewSubVector", github_com_glojurelang_glojure_pkg_lang.NewSubVector) _register("github.com/glojurelang/glojure/pkg/lang.NewSymbol", github_com_glojurelang_glojure_pkg_lang.NewSymbol) _register("github.com/glojurelang/glojure/pkg/lang.NewTimeoutError", github_com_glojurelang_glojure_pkg_lang.NewTimeoutError) + _register("github.com/glojurelang/glojure/pkg/lang.NewTransformerIterator", github_com_glojurelang_glojure_pkg_lang.NewTransformerIterator) _register("github.com/glojurelang/glojure/pkg/lang.NewVar", github_com_glojurelang_glojure_pkg_lang.NewVar) _register("github.com/glojurelang/glojure/pkg/lang.NewVarWithRoot", github_com_glojurelang_glojure_pkg_lang.NewVarWithRoot) _register("github.com/glojurelang/glojure/pkg/lang.NewVector", github_com_glojurelang_glojure_pkg_lang.NewVector) @@ -3912,6 +3917,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.*TimeoutError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TimeoutError)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.ToSlice", github_com_glojurelang_glojure_pkg_lang.ToSlice) _register("github.com/glojurelang/glojure/pkg/lang.ToString", github_com_glojurelang_glojure_pkg_lang.ToString) + _register("github.com/glojurelang/glojure/pkg/lang.TransformerIterator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransformerIterator)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.*TransformerIterator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransformerIterator)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.TransientMap", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransientMap)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*TransientMap", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransientMap)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.TransientSet", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransientSet)(nil)).Elem()) diff --git a/pkg/gen/gljimports/gljimports_windows_arm.go b/pkg/gen/gljimports/gljimports_windows_arm.go index 1135686b..d57eb57e 100644 --- a/pkg/gen/gljimports/gljimports_windows_arm.go +++ b/pkg/gen/gljimports/gljimports_windows_arm.go @@ -3422,6 +3422,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.Apply", github_com_glojurelang_glojure_pkg_lang.Apply) _register("github.com/glojurelang/glojure/pkg/lang.ArithmeticError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ArithmeticError)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*ArithmeticError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ArithmeticError)(nil))) + _register("github.com/glojurelang/glojure/pkg/lang.ArrayList", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ArrayList)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.*ArrayList", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ArrayList)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.ArrayNode", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ArrayNode)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*ArrayNode", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ArrayNode)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.ArrayNodeIterator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.ArrayNodeIterator)(nil)).Elem()) @@ -3604,6 +3606,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.IsSeq", github_com_glojurelang_glojure_pkg_lang.IsSeq) _register("github.com/glojurelang/glojure/pkg/lang.IsTruthy", github_com_glojurelang_glojure_pkg_lang.IsTruthy) _register("github.com/glojurelang/glojure/pkg/lang.IsZero", github_com_glojurelang_glojure_pkg_lang.IsZero) + _register("github.com/glojurelang/glojure/pkg/lang.Iterator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Iterator)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.KWAliases", github_com_glojurelang_glojure_pkg_lang.KWAliases) _register("github.com/glojurelang/glojure/pkg/lang.KWArg", github_com_glojurelang_glojure_pkg_lang.KWArg) _register("github.com/glojurelang/glojure/pkg/lang.KWArgId", github_com_glojurelang_glojure_pkg_lang.KWArgId) @@ -3765,6 +3768,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NamespaceFor", github_com_glojurelang_glojure_pkg_lang.NamespaceFor) _register("github.com/glojurelang/glojure/pkg/lang.Namespaces", github_com_glojurelang_glojure_pkg_lang.Namespaces) _register("github.com/glojurelang/glojure/pkg/lang.NewArithmeticError", github_com_glojurelang_glojure_pkg_lang.NewArithmeticError) + _register("github.com/glojurelang/glojure/pkg/lang.NewArrayList", github_com_glojurelang_glojure_pkg_lang.NewArrayList) _register("github.com/glojurelang/glojure/pkg/lang.NewAtom", github_com_glojurelang_glojure_pkg_lang.NewAtom) _register("github.com/glojurelang/glojure/pkg/lang.NewAtomWithMeta", github_com_glojurelang_glojure_pkg_lang.NewAtomWithMeta) _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimal", github_com_glojurelang_glojure_pkg_lang.NewBigDecimal) @@ -3818,6 +3822,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewSubVector", github_com_glojurelang_glojure_pkg_lang.NewSubVector) _register("github.com/glojurelang/glojure/pkg/lang.NewSymbol", github_com_glojurelang_glojure_pkg_lang.NewSymbol) _register("github.com/glojurelang/glojure/pkg/lang.NewTimeoutError", github_com_glojurelang_glojure_pkg_lang.NewTimeoutError) + _register("github.com/glojurelang/glojure/pkg/lang.NewTransformerIterator", github_com_glojurelang_glojure_pkg_lang.NewTransformerIterator) _register("github.com/glojurelang/glojure/pkg/lang.NewVar", github_com_glojurelang_glojure_pkg_lang.NewVar) _register("github.com/glojurelang/glojure/pkg/lang.NewVarWithRoot", github_com_glojurelang_glojure_pkg_lang.NewVarWithRoot) _register("github.com/glojurelang/glojure/pkg/lang.NewVector", github_com_glojurelang_glojure_pkg_lang.NewVector) @@ -3912,6 +3917,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.*TimeoutError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TimeoutError)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.ToSlice", github_com_glojurelang_glojure_pkg_lang.ToSlice) _register("github.com/glojurelang/glojure/pkg/lang.ToString", github_com_glojurelang_glojure_pkg_lang.ToString) + _register("github.com/glojurelang/glojure/pkg/lang.TransformerIterator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransformerIterator)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.*TransformerIterator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransformerIterator)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.TransientMap", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransientMap)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*TransientMap", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransientMap)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.TransientSet", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransientSet)(nil)).Elem()) diff --git a/pkg/lang/arraylist.go b/pkg/lang/arraylist.go new file mode 100644 index 00000000..ece04dcd --- /dev/null +++ b/pkg/lang/arraylist.go @@ -0,0 +1,30 @@ +package lang + +// ArrayList is a minimal implementation of a subset of Java's +// ArrayList to replace uses of java.util.ArrayList in the Clojure +// standard library. +type ArrayList struct { + data []any +} + +func NewArrayList(items []any) *ArrayList { + return &ArrayList{ + data: items, + } +} + +func (al *ArrayList) Add(item any) { + al.data = append(al.data, item) +} + +func (al *ArrayList) Clear() { + al.data = []any{} +} + +func (al *ArrayList) IsEmpty() bool { + return len(al.data) == 0 +} + +func (al *ArrayList) ToArray() []any { + return al.data +} diff --git a/pkg/lang/functional.go b/pkg/lang/functional.go index 6d490fb7..a9b02dd7 100644 --- a/pkg/lang/functional.go +++ b/pkg/lang/functional.go @@ -12,6 +12,9 @@ func ReduceInit(f func(interface{}, interface{}) interface{}, init interface{}, var res interface{} = init for ; seq != nil; seq = seq.Next() { res = f(res, seq.First()) + if IsReduced(res) { + return res.(IDeref).Deref() + } } return res } diff --git a/pkg/lang/interfaces.go b/pkg/lang/interfaces.go index 9d107938..6c81d112 100644 --- a/pkg/lang/interfaces.go +++ b/pkg/lang/interfaces.go @@ -312,6 +312,13 @@ type ( Pop() ITransientVector } + // Iterator is a Java-like iterator interface; included + // to more easly translate Clojure Java-isms. + Iterator interface { + HasNext() bool + Next() any + } + //////////////////////////////////////////////////////////////////////////// // Abstract classes // diff --git a/pkg/lang/persistentarraymap.go b/pkg/lang/persistentarraymap.go index 63e50b92..825e8025 100644 --- a/pkg/lang/persistentarraymap.go +++ b/pkg/lang/persistentarraymap.go @@ -290,6 +290,9 @@ func (m *Map) Reduce(f IFn) any { continue } res = f.Invoke(res, seq.First()) + if IsReduced(res) { + return res.(IDeref).Deref() + } } return res } @@ -298,6 +301,9 @@ func (m *Map) ReduceInit(f IFn, init any) any { res := init for seq := Seq(m); seq != nil; seq = seq.Next() { res = f.Invoke(res, seq.First()) + if IsReduced(res) { + return res.(IDeref).Deref() + } } return res } @@ -637,6 +643,9 @@ func (s *MapValSeq) Reduce(f IFn) any { continue } res = f.Invoke(res, seq.First()) + if IsReduced(res) { + return res.(IDeref).Deref() + } } if count == 0 { return f.Invoke() @@ -648,6 +657,9 @@ func (s *MapValSeq) ReduceInit(f IFn, init any) any { res := init for seq := Seq(s); seq != nil; seq = seq.Next() { res = f.Invoke(res, seq.First()) + if IsReduced(res) { + return res.(IDeref).Deref() + } } return res } diff --git a/pkg/lang/persistenthashmap.go b/pkg/lang/persistenthashmap.go index 03155669..7eb3c31b 100644 --- a/pkg/lang/persistenthashmap.go +++ b/pkg/lang/persistenthashmap.go @@ -212,6 +212,9 @@ func (m *PersistentHashMap) Reduce(f IFn) any { continue } res = f.Invoke(res, seq.First()) + if IsReduced(res) { + return res.(IDeref).Deref() + } } return res } @@ -220,6 +223,9 @@ func (m *PersistentHashMap) ReduceInit(f IFn, init any) any { res := init for seq := Seq(m); seq != nil; seq = seq.Next() { res = f.Invoke(res, seq.First()) + if IsReduced(res) { + return res.(IDeref).Deref() + } } return res } diff --git a/pkg/lang/transformer_iterator.go b/pkg/lang/transformer_iterator.go new file mode 100644 index 00000000..30d6202f --- /dev/null +++ b/pkg/lang/transformer_iterator.go @@ -0,0 +1,67 @@ +package lang + +import "errors" + +// TransformerIterator provides a view over a Transduced collection. +type TransformerIterator struct { + // source + sourceIter any + xf IFn + multi bool + + // iteration state + buffer []any + next any + completed bool +} + +var ( + _ Iterator = (*TransformerIterator)(nil) + + transformerIteratorNone = &struct{}{} +) + +// NewTransformerIteratorSeq creates a new transformer iterator. +func NewTransformerIterator(xform IFn, iter any, multi bool) *TransformerIterator { + ti := &TransformerIterator{ + sourceIter: iter, + multi: multi, + next: transformerIteratorNone, + } + ti.xf = xform.Invoke(NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return nil + case 1: + return args[0] + case 2: + ti.buffer = append(ti.buffer, args[1]) + return args[0] + default: + panic("invalid arity") + } + })).(IFn) + + return ti +} + +func (ti *TransformerIterator) HasNext() bool { + return ti.step() +} + +func (ti *TransformerIterator) Next() any { + if ti.HasNext() { + ret := ti.next + ti.next = transformerIteratorNone + return ret + } + panic(errors.New("no next element")) +} + +func (ti *TransformerIterator) Remove() { + panic(errors.New("remove not supported")) +} + +func (ti *TransformerIterator) step() bool { + return false +} diff --git a/pkg/lang/vector.go b/pkg/lang/vector.go index 2dc696b1..5bee8fcc 100644 --- a/pkg/lang/vector.go +++ b/pkg/lang/vector.go @@ -229,6 +229,9 @@ func (v *Vector) ReduceInit(f IFn, init any) any { res := init for i := 0; i < v.Count(); i++ { res = f.Invoke(res, v.ValAt(i)) + if IsReduced(res) { + return res.(IDeref).Deref() + } } return res } @@ -240,6 +243,9 @@ func (v *Vector) Reduce(f IFn) any { res := v.ValAt(0) for i := 1; i < v.Count(); i++ { res = f.Invoke(res, v.ValAt(i)) + if IsReduced(res) { + return res.(IDeref).Deref() + } } return res } diff --git a/pkg/runtime/rtcompat.go b/pkg/runtime/rtcompat.go index 7f848693..706e86b9 100644 --- a/pkg/runtime/rtcompat.go +++ b/pkg/runtime/rtcompat.go @@ -42,11 +42,11 @@ func (rt *RTMethods) NextID() int { return int(rt.id.Add(1)) } -func (rt *RTMethods) Nth(x interface{}, i int) interface{} { +func (rt *RTMethods) Nth(x any, i int) any { return MustNth(x, i) } -func (rt *RTMethods) NthDefault(x interface{}, i int, def interface{}) interface{} { +func (rt *RTMethods) NthDefault(x any, i int, def any) any { v, ok := Nth(x, i) if !ok { return def @@ -54,7 +54,7 @@ func (rt *RTMethods) NthDefault(x interface{}, i int, def interface{}) interface return v } -func (rt *RTMethods) Peek(x interface{}) interface{} { +func (rt *RTMethods) Peek(x any) any { if IsNil(x) { return nil } @@ -62,7 +62,7 @@ func (rt *RTMethods) Peek(x interface{}) interface{} { return stk.Peek() } -func (rt *RTMethods) Pop(x interface{}) interface{} { +func (rt *RTMethods) Pop(x any) any { if IsNil(x) { return nil } @@ -70,31 +70,31 @@ func (rt *RTMethods) Pop(x interface{}) interface{} { return stk.Pop() } -func (rt *RTMethods) IntCast(x interface{}) int { +func (rt *RTMethods) IntCast(x any) int { return lang.IntCast(x) } -func (rt *RTMethods) BooleanCast(x interface{}) bool { +func (rt *RTMethods) BooleanCast(x any) bool { return lang.BooleanCast(x) } -func (rt *RTMethods) ByteCast(x interface{}) byte { +func (rt *RTMethods) ByteCast(x any) byte { return lang.ByteCast(x) } -func (rt *RTMethods) CharCast(x interface{}) Char { +func (rt *RTMethods) CharCast(x any) Char { return lang.CharCast(x) } -func (rt *RTMethods) UncheckedCharCast(x interface{}) Char { +func (rt *RTMethods) UncheckedCharCast(x any) Char { return lang.UncheckedCharCast(x) } -func (rt *RTMethods) Dissoc(x interface{}, k interface{}) interface{} { +func (rt *RTMethods) Dissoc(x any, k any) any { return Dissoc(x, k) } -func (rt *RTMethods) Contains(coll, key interface{}) bool { +func (rt *RTMethods) Contains(coll, key any) bool { switch coll := coll.(type) { case nil: return false @@ -111,7 +111,7 @@ func (rt *RTMethods) Subvec(v IPersistentVector, start, end int) IPersistentVect return Subvec(v, start, end) } -func (rt *RTMethods) Find(coll, key interface{}) interface{} { +func (rt *RTMethods) Find(coll, key any) any { switch coll := coll.(type) { case nil: return nil @@ -123,7 +123,7 @@ func (rt *RTMethods) Find(coll, key interface{}) interface{} { } func (rt *RTMethods) Load(scriptBase string) { - kvs := make([]interface{}, 0, 3) + kvs := make([]any, 0, 3) for _, vr := range []*Var{VarCurrentNS, VarWarnOnReflection, VarUncheckedMath, lang.VarDataReaders} { kvs = append(kvs, vr, vr.Deref()) } @@ -172,7 +172,7 @@ func (rt *RTMethods) FindVar(qualifiedSym *Symbol) *Var { return ns.FindInternedVar(NewSymbol(qualifiedSym.Name())) } -func (rt *RTMethods) Alength(x interface{}) int { +func (rt *RTMethods) Alength(x any) int { xVal := reflect.ValueOf(x) if xVal.Kind() == reflect.Slice || xVal.Kind() == reflect.Array { return xVal.Len() @@ -180,10 +180,35 @@ func (rt *RTMethods) Alength(x interface{}) int { panic(fmt.Errorf("Alength not supported on type: %T", x)) } -func (rt *RTMethods) ToArray(coll interface{}) interface{} { +func (rt *RTMethods) ToArray(coll any) any { return lang.ToSlice(coll) } +func (rt *RTMethods) ChunkIteratorSeq(iter any) ISeq { + // Go does not have an iterator interface like Java, but it does now + // have the iter.Seq functions. For now, we support only TransformerIterators. + ti, ok := iter.(*lang.TransformerIterator) + if !ok { + panic(fmt.Errorf("ChunkIteratorSeq requires a TransformerIterator, got %T", iter)) + } + + if !ti.HasNext() { + return nil + } + + const chunkSize = 32 + + return lang.NewLazySeq(func() any { + arr := make([]any, 0, chunkSize) + n := 0 + for ti.HasNext() && n < chunkSize { + arr[n] = ti.Next() + n++ + } + return lang.NewChunkedCons(lang.NewSliceChunk(arr), rt.ChunkIteratorSeq(ti)) + }) +} + var ( mungeCharMap = map[rune]string{ '-': "_", @@ -226,7 +251,7 @@ func (rt *RTMethods) Munge(name string) string { return sb.String() } -func RTReadString(s string) interface{} { +func RTReadString(s string) any { rdr := reader.New(strings.NewReader(s), reader.WithGetCurrentNS(func() *lang.Namespace { return lang.VarCurrentNS.Deref().(*lang.Namespace) })) diff --git a/pkg/stdlib/glojure/core.glj b/pkg/stdlib/glojure/core.glj index 5b7b5e1f..350e0b85 100644 --- a/pkg/stdlib/glojure/core.glj +++ b/pkg/stdlib/glojure/core.glj @@ -2519,7 +2519,7 @@ {:added "1.7" :tag github.com$glojurelang$glojure$pkg$lang.Volatile} [val] - (glojure.lang.Volatile. val)) + (github.com$glojurelang$glojure$pkg$lang.NewVolatile val)) (defn vreset! "Sets the value of volatile to newval without regard for the @@ -7190,7 +7190,7 @@ fails, attempts to require sym's namespace and retries." :static true} ([f] (fn [rf] - (let [a (java.util.ArrayList.) + (let [a (new github.com$glojurelang$glojure$pkg$lang.ArrayList) pv (volatile! ::none)] (fn ([] (rf)) @@ -7270,7 +7270,7 @@ fails, attempts to require sym's namespace and retries." :static true} ([^long n] (fn [rf] - (let [a (java.util.ArrayList. n)] + (let [a (github.com$glojurelang$glojure$pkg$lang.NewArrayList (to-array n))] (fn ([] (rf)) ([result] @@ -7345,7 +7345,7 @@ fails, attempts to require sym's namespace and retries." {:added "1.2" :static true} [^java.util.Collection coll] - (let [al (java.util.ArrayList. coll)] + (let [al (github.com$glojurelang$glojure$pkg$lang.NewArrayList (to-array coll))] (java.util.Collections/shuffle al) (glojure.lang.RT/vector (.toArray al)))) @@ -7748,16 +7748,6 @@ fails, attempts to require sym's namespace and retries." ([prob coll] (filter (fn [_] (< (rand) prob)) coll))) -(defn eduction - "Returns a reducible/iterable application of the transducers - to the items in coll. Transducers are applied in order as if - combined with comp. Note that these applications will be - performed every time reduce/iterator is called." - {:arglists '([xform* coll]) - :added "1.7"} - [& xforms] - (Eduction. (apply comp (butlast xforms)) (last xforms))) - (defn run! "Runs the supplied procedure (via reduce), for purposes of side effects, on successive items in the collection. Returns nil" diff --git a/scripts/rewrite-core/rewrite.clj b/scripts/rewrite-core/rewrite.clj index b21c56f6..e210290f 100644 --- a/scripts/rewrite-core/rewrite.clj +++ b/scripts/rewrite-core/rewrite.clj @@ -213,6 +213,10 @@ (sexpr-replace '(. clojure.lang.PersistentHashMap (create keyvals)) '(github.com$glojurelang$glojure$pkg$lang.CreatePersistentHashMap keyvals)) + (sexpr-replace '(java.util.ArrayList. n) '(github.com$glojurelang$glojure$pkg$lang.NewArrayList (to-array n))) + (sexpr-replace '(java.util.ArrayList. coll) '(github.com$glojurelang$glojure$pkg$lang.NewArrayList (to-array coll))) + (sexpr-replace '(java.util.ArrayList.) '(new github.com$glojurelang$glojure$pkg$lang.ArrayList)) + ;; ===== Java Type Mappings ===== ;; map a bunch of java types to go equivalent ;; TODO: once everything passes, see if we can replace with a blanket @@ -232,6 +236,8 @@ 'github.com$glojurelang$glojure$pkg$lang.*MultiFn) (sexpr-replace 'clojure.lang.Volatile 'github.com$glojurelang$glojure$pkg$lang.Volatile) + (sexpr-replace 'clojure.lang.Volatile. + 'github.com$glojurelang$glojure$pkg$lang.NewVolatile) (sexpr-replace 'clojure.lang.IAtom 'github.com$glojurelang$glojure$pkg$lang.IAtom) (sexpr-replace 'clojure.lang.IMapEntry @@ -390,6 +396,11 @@ (= 'defmethod (first (z/sexpr %))) (= 'Eduction (nth (z/sexpr %) 2)))) + ;; Omit eduction function + (omitp #(and (z/list? %) + (= 'defn (first (z/sexpr %))) + (= 'eduction (second (z/sexpr %))))) + ;; omit default-data-readers for now (omitp #(and (z/list? %) (= 'def (first (z/sexpr %))) diff --git a/test/glojure/test_glojure/transducers.glj b/test/glojure/test_glojure/transducers.glj new file mode 100644 index 00000000..6c524442 --- /dev/null +++ b/test/glojure/test_glojure/transducers.glj @@ -0,0 +1,409 @@ +; Copyright (c) Rich Hickey. All rights reserved. +; The use and distribution terms for this software are covered by the +; Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php) +; which can be found in the file epl-v10.html at the root of this distribution. +; By using this software in any fashion, you are agreeing to be bound by +; the terms of this license. +; You must not remove this notice, or any other, from this software. + +; Author: Alex Miller + +(ns glojure.test-glojure.transducers + (:require [glojure.string :as s] + [glojure.test :refer :all])) + +;; TODO: enable these tests + +;; (defmacro fbind [source-gen f] +;; `(gen/fmap +;; (fn [s#] +;; {:desc (list '~f (:name s#)) +;; :seq (partial ~f (:val s#)) +;; :xf (~f (:val s#))}) +;; ~source-gen)) + +;; (defmacro pickfn [& fns] +;; `(gen/elements +;; [~@(for [f fns] `{:val ~f :name '~f})])) + +;; (defn literal +;; [g] +;; (gen/fmap +;; (fn [s] {:val s :name s}) +;; g)) + +;; ;; These $ versions are "safe" when used with possibly mixed numbers, sequences, etc + +;; (defn- inc$ [n] +;; (if (number? n) (inc n) 1)) + +;; (defn- dec$ [n] +;; (if (number? n) (dec n) 1)) + +;; (defn- odd?$ [n] +;; (if (number? n) (odd? n) false)) + +;; (defn- pos?$ [n] +;; (if (number? n) (pos? n) false)) + +;; (defn- empty?$ [s] +;; (if (instance? clojure.lang.Seqable s) (empty? s) false)) + +;; (def gen-mapfn +;; (pickfn inc$ dec$)) + +;; (def gen-mapcatfn +;; (pickfn vector +;; #(if (instance? clojure.lang.Seqable %) (partition-all 3 %) (vector %)))) + +;; (def gen-predfn +;; (pickfn odd?$ pos?$ empty?$ sequential?)) + +;; (def gen-indexedfn +;; (pickfn (fn [index item] index) +;; (fn [index item] item) +;; (fn [index item] (if (number? item) (+ index item) index)))) + +;; (def gen-take (fbind (literal gen/s-pos-int) take)) +;; (def gen-drop (fbind (literal gen/pos-int) drop)) +;; (def gen-drop-while (fbind gen-predfn drop-while)) +;; (def gen-map (fbind gen-mapfn map)) +;; (def gen-mapcat (fbind gen-mapcatfn mapcat)) +;; (def gen-filter (fbind gen-predfn filter)) +;; (def gen-remove (fbind gen-predfn remove)) +;; (def gen-keep (fbind gen-predfn keep)) +;; (def gen-partition-all (fbind (literal gen/s-pos-int) partition-all)) +;; (def gen-partition-by (fbind gen-predfn partition-by)) +;; (def gen-take-while (fbind gen-predfn take-while)) +;; (def gen-take-nth (fbind (literal gen/s-pos-int) take-nth)) +;; (def gen-keep-indexed (fbind gen-indexedfn keep-indexed)) +;; (def gen-map-indexed (fbind gen-indexedfn map-indexed)) +;; (def gen-replace (fbind (literal (gen/return (hash-map (range 100) (range 1 100)))) replace)) +;; (def gen-distinct (gen/return {:desc 'distinct :seq (partial distinct) :xf (distinct)})) +;; (def gen-dedupe (gen/return {:desc 'dedupe :seq (partial dedupe) :xf (dedupe)})) +;; (def gen-interpose (fbind (literal gen/s-pos-int) interpose)) + +;; (def gen-action +;; (gen/one-of [gen-take gen-drop gen-map gen-mapcat +;; gen-filter gen-remove gen-keep +;; gen-partition-all gen-partition-by gen-take-while +;; gen-take-nth gen-drop-while +;; gen-keep-indexed gen-map-indexed +;; gen-distinct gen-dedupe gen-interpose])) + +;; (def gen-actions +;; (gen/vector gen-action 1 5)) + +;; (def gen-coll +;; (gen/vector gen/int)) + +;; (defn apply-as-seq [coll actions] +;; (doall +;; (loop [s coll +;; [action & actions'] actions] +;; (if action +;; (recur ((:seq action) s) actions') +;; s)))) + +;; (defn apply-as-xf-seq +;; [coll actions] +;; (doall (sequence (apply comp (map :xf actions)) coll))) + +;; (defn apply-as-xf-into +;; [coll actions] +;; (into [] (apply comp (map :xf actions)) coll)) + +;; (defn apply-as-xf-eduction +;; [coll actions] +;; (into [] (eduction (apply comp (map :xf actions)) coll))) + +;; (defn apply-as-xf-transduce +;; [coll actions] +;; (transduce (apply comp (map :xf actions)) conj coll)) + +;; (defmacro return-exc [& forms] +;; `(try ~@forms (catch Throwable e# e#))) + +;; (defn build-results +;; [coll actions] +;; (let [s (return-exc (apply-as-seq coll actions)) +;; xs (return-exc (apply-as-xf-seq coll actions)) +;; xi (return-exc (apply-as-xf-into coll actions)) +;; xe (return-exc (apply-as-xf-eduction coll actions)) +;; xt (return-exc (apply-as-xf-transduce coll actions))] +;; {:coll coll +;; :actions (concat '(->> coll) (map :desc actions)) +;; :s s +;; :xs xs +;; :xi xi +;; :xe xe +;; :xt xt})) + +;; (def result-gen +;; (gen/fmap +;; (fn [[c a]] (build-results c a)) +;; (gen/tuple gen-coll gen-actions))) + +;; (defn result-good? +;; [{:keys [s xs xi xe xt]}] +;; (= s xs xi xe xt)) + +;; (deftest seq-and-transducer +;; (let [res (chk/quick-check +;; 200000 +;; (prop/for-all* [result-gen] result-good?))] +;; (when-not (:result res) +;; (is +;; (:result res) +;; (-> +;; res +;; :shrunk +;; :smallest +;; first +;; clojure.pprint/pprint +;; with-out-str))))) + +(deftest test-transduce + (let [long+ (fn ([a b] (+ (long a) (long b))) + ([a] a) + ([] 0)) + mapinc (map inc) + mapinclong (map (comp inc long)) + arange (range 100) + avec (into [] arange) + alist (into () arange) + obj-array (into-array arange) + int-array (into-array Integer/TYPE (map #(Integer. (int %)) arange)) + long-array (into-array Long/TYPE arange) + float-array (into-array Float/TYPE arange) + char-array (into-array Character/TYPE (map char arange)) + double-array (into-array Double/TYPE arange) + byte-array (into-array Byte/TYPE (map byte arange)) + int-vec (into (vector-of :int) arange) + long-vec (into (vector-of :long) arange) + float-vec (into (vector-of :float) arange) + char-vec (into (vector-of :char) (map char arange)) + double-vec (into (vector-of :double) arange) + byte-vec (into (vector-of :byte) (map byte arange))] + (is (== 5050 + (transduce mapinc + arange) + (transduce mapinc + avec) + (transduce mapinc + alist) + (transduce mapinc + obj-array) + (transduce mapinc + int-array) + (transduce mapinc + long-array) + (transduce mapinc + float-array) + (transduce mapinclong + char-array) + (transduce mapinc + double-array) + (transduce mapinclong + byte-array) + (transduce mapinc + int-vec) + (transduce mapinc + long-vec) + (transduce mapinc + float-vec) + (transduce mapinclong + char-vec) + (transduce mapinc + double-vec) + (transduce mapinclong + byte-vec) + )) + (is (== 5051 + (transduce mapinc + 1 arange) + (transduce mapinc + 1 avec) + (transduce mapinc + 1 alist) + (transduce mapinc + 1 obj-array) + (transduce mapinc + 1 int-array) + (transduce mapinc + 1 long-array) + (transduce mapinc + 1 float-array) + (transduce mapinclong + 1 char-array) + (transduce mapinc + 1 double-array) + (transduce mapinclong + 1 byte-array) + (transduce mapinc + 1 int-vec) + (transduce mapinc + 1 long-vec) + (transduce mapinc + 1 float-vec) + (transduce mapinclong + 1 char-vec) + (transduce mapinc + 1 double-vec) + (transduce mapinclong + 1 byte-vec))))) + +(deftest test-dedupe + (are [x y] (= (transduce (dedupe) conj x) y) + [] [] + [1] [1] + [1 2 3] [1 2 3] + [1 2 3 1 2 2 1 1] [1 2 3 1 2 1] + [1 1 1 2] [1 2] + [1 1 1 1] [1] + + "" [] + "a" [\a] + "aaaa" [\a] + "aabaa" [\a \b \a] + "abba" [\a \b \a] + + [nil nil nil] [nil] + [1 1.0 1.0M 1N] [1 1.0 1.0M 1N] + [0.5 0.5] [0.5])) + +(deftest test-cat + (are [x y] (= (transduce cat conj x) y) + [] [] + [[1 2]] [1 2] + [[1 2] [3 4]] [1 2 3 4] + [[] [3 4]] [3 4] + [[1 2] []] [1 2] + [[] []] [] + [[1 2] [3 4] [5 6]] [1 2 3 4 5 6])) + +(deftest test-partition-all + (are [n coll y] (= (transduce (partition-all n) conj coll) y) + 2 [1 2 3] '((1 2) (3)) + 2 [1 2 3 4] '((1 2) (3 4)) + 2 [] () + 1 [] () + 1 [1 2 3] '((1) (2) (3)) + 5 [1 2 3] '((1 2 3)))) + +(deftest test-take + (are [n y] (= (transduce (take n) conj [1 2 3 4 5]) y) + 1 '(1) + 3 '(1 2 3) + 5 '(1 2 3 4 5) + 9 '(1 2 3 4 5) + 0 () + -1 () + -2 ())) + +(deftest test-drop + (are [n y] (= (transduce (drop n) conj [1 2 3 4 5]) y) + 1 '(2 3 4 5) + 3 '(4 5) + 5 () + 9 () + 0 '(1 2 3 4 5) + -1 '(1 2 3 4 5) + -2 '(1 2 3 4 5))) + +(deftest test-take-nth + (are [n y] (= (transduce (take-nth n) conj [1 2 3 4 5]) y) + 1 '(1 2 3 4 5) + 2 '(1 3 5) + 3 '(1 4) + 4 '(1 5) + 5 '(1) + 9 '(1))) + +(deftest test-take-while + (are [coll y] (= (transduce (take-while pos?) conj coll) y) + [] () + [1 2 3 4] '(1 2 3 4) + [1 2 3 -1] '(1 2 3) + [1 -1 2 3] '(1) + [-1 1 2 3] () + [-1 -2 -3] ())) + +(deftest test-drop-while + (are [coll y] (= (transduce (drop-while pos?) conj coll) y) + [] () + [1 2 3 4] () + [1 2 3 -1] '(-1) + [1 -1 2 3] '(-1 2 3) + [-1 1 2 3] '(-1 1 2 3) + [-1 -2 -3] '(-1 -2 -3))) + +(deftest test-re-reduced + (is (= [:a] (transduce (take 1) conj [:a]))) + (is (= [:a] (transduce (comp (take 1) (take 1)) conj [:a]))) + (is (= [:a] (transduce (comp (take 1) (take 1) (take 1)) conj [:a]))) + (is (= [:a] (transduce (comp (take 1) (take 1) (take 1) (take 1)) conj [:a]))) + (is (= [[:a]] (transduce (comp (partition-by keyword?) (take 1)) conj [] [:a]))) + (is (= [[:a]] (sequence (comp (partition-by keyword?) (take 1)) [:a]))) + (is (= [[[:a]]] (sequence (comp (partition-by keyword?) (take 1) (partition-by keyword?) (take 1)) [:a]))) + (is (= [[0]] (transduce (comp (take 1) (partition-all 3) (take 1)) conj [] (range 15)))) + (is (= [1] (transduce (take 1) conj (seq (long-array [1 2 3 4])))))) + +(deftest test-sequence-multi-xform + (is (= [11 12 13 14] (sequence (map +) [1 2 3 4] (repeat 10)))) + (is (= [11 12 13 14] (sequence (map +) (repeat 10) [1 2 3 4]))) + (is (= [31 32 33 34] (sequence (map +) (repeat 10) (repeat 20) [1 2 3 4])))) + +;; (deftest test-eduction +;; (testing "one xform" +;; (is (= [1 2 3 4 5] +;; (eduction (map inc) (range 5))))) +;; (testing "multiple xforms" +;; (is (= ["2" "4"] +;; (eduction (map inc) (filter even?) (map str) (range 5))))) +;; (testing "materialize at the end" +;; (is (= [1 1 1 1 2 2 2 3 3 4] +;; (->> (range 5) +;; (eduction (mapcat range) (map inc)) +;; sort))) +;; (is (= [1 1 2 1 2 3 1 2 3 4] +;; (vec (->> (range 5) +;; (eduction (mapcat range) (map inc)) +;; to-array)))) +;; (is (= {1 4, 2 3, 3 2, 4 1} +;; (->> (range 5) +;; (eduction (mapcat range) (map inc)) +;; frequencies))) +;; (is (= ["drib" "god" "hsif" "kravdraa" "tac"] +;; (->> ["cat" "dog" "fish" "bird" "aardvark"] +;; (eduction (map clojure.string/reverse)) +;; (sort-by first))))) +;; (testing "expanding transducer with nils" +;; (is (= '(1 2 3 nil 4 5 6 nil) +;; (eduction cat [[1 2 3 nil] [4 5 6 nil]]))))) + +;; (deftest test-eduction-completion +;; (testing "eduction completes inner xformed reducing fn" +;; (is (= [[0 1 2] [3 4 5] [6 7]] +;; (into [] +;; (comp cat (partition-all 3)) +;; (eduction (partition-all 5) (range 8)))))) +;; (testing "outer reducing fn completed only once" +;; (let [counter (atom 0) +;; ;; outer rfn +;; rf (completing conj #(do (swap! counter inc) +;; (vec %))) +;; coll (eduction (map inc) (range 5)) +;; res (transduce (map str) rf [] coll)] +;; (is (= 1 @counter)) +;; (is (= ["1" "2" "3" "4" "5"] res))))) + +(deftest test-run! + (is (nil? (run! identity [1]))) + (is (nil? (run! reduced (range))))) + +(deftest test-distinct + (are [out in] (= out (sequence (distinct in)) (sequence (distinct) in)) + [] [] + (range 10) (range 10) + [0] (repeat 10 0) + [0 1 2] [0 0 1 1 2 2 1 1 0 0] + [1] [1 1N])) + +(deftest test-interpose + (are [out in] (= out (sequence (interpose :s) in)) + [] (range 0) + [0] (range 1) + [0 :s 1] (range 2) + [0 :s 1 :s 2] (range 3)) + (testing "Can end reduction on separator or input" + (let [expected (interpose :s (range))] + (dotimes [i 10] + (is (= (take i expected) + (sequence (comp (interpose :s) (take i)) + (range)))))))) + +(deftest test-map-indexed + (is (= [] + (sequence (map-indexed vector) []))) + (is (= [[0 1] [1 2] [2 3] [3 4]] + (sequence (map-indexed vector) (range 1 5))))) + +(deftest test-into+halt-when + (is (= :anomaly (into [] (comp (filter some?) (halt-when #{:anomaly})) + [1 2 3 :anomaly 4]))) + (is (= {:anomaly :oh-no!, + :partial-results [1 2]} + (into [] + (halt-when :anomaly #(assoc %2 :partial-results %1)) + [1 2 {:anomaly :oh-no!} 3 4])))) + +(run-tests) From 989821e2c0775d1a3f9f0803fa7fcdf4ad9b30a8 Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sat, 23 Aug 2025 12:10:30 -0700 Subject: [PATCH 34/67] add CompilerError, sort vars for deterministic codegen Signed-off-by: James Hamlin --- pkg/codegen/codegen.go | 18 +- pkg/codegen/testdata/codegen/test/core.go | 129498 +++++++-------- .../testdata/codegen/test/fn_closure.go | 110 +- .../testdata/codegen/test/try_advanced.go | 146 +- .../testdata/codegen/test/try_basic.go | 126 +- pkg/gen/gljimports/gljimports_darwin_amd64.go | 3 + pkg/gen/gljimports/gljimports_darwin_arm64.go | 3 + pkg/gen/gljimports/gljimports_js_wasm.go | 3 + pkg/gen/gljimports/gljimports_linux_amd64.go | 3 + pkg/gen/gljimports/gljimports_linux_arm64.go | 3 + .../gljimports/gljimports_windows_amd64.go | 3 + pkg/gen/gljimports/gljimports_windows_arm.go | 3 + pkg/lang/error.go | 32 + scripts/rewrite-core/rewrite.clj | 3 + 14 files changed, 65012 insertions(+), 64942 deletions(-) diff --git a/pkg/codegen/codegen.go b/pkg/codegen/codegen.go index 35e34967..2a2cf811 100644 --- a/pkg/codegen/codegen.go +++ b/pkg/codegen/codegen.go @@ -95,6 +95,13 @@ func (g *Generator) Generate(ns *lang.Namespace) error { // 1. Iterate through ns.Mappings() // 2. Generate Go code for each var (this discovers lifted values) mappings := ns.Mappings() + + type namedVar struct { + name *lang.Symbol + vr *lang.Var + } + var internedVars []namedVar + for seq := mappings.Seq(); seq != nil; seq = seq.Next() { entry := seq.First() name, ok := lang.First(entry).(*lang.Symbol) @@ -111,8 +118,15 @@ func (g *Generator) Generate(ns *lang.Namespace) error { continue // Skip non-interned mappings } - if err := g.generateVar("ns", name, vr); err != nil { - return fmt.Errorf("failed to generate code for var %s: %w", name, err) + internedVars = append(internedVars, namedVar{name: name, vr: vr}) + } + // Sort internedVars by name for deterministic output + sort.Slice(internedVars, func(i, j int) bool { + return internedVars[i].name.String() < internedVars[j].name.String() + }) + for _, nv := range internedVars { + if err := g.generateVar("ns", nv.name, nv.vr); err != nil { + return fmt.Errorf("failed to generate code for var %s: %w", nv.name, err) } } diff --git a/pkg/codegen/testdata/codegen/test/core.go b/pkg/codegen/testdata/codegen/test/core.go index d88a94ec..8595e086 100644 --- a/pkg/codegen/testdata/codegen/test/core.go +++ b/pkg/codegen/testdata/codegen/test/core.go @@ -4,45 +4,49 @@ package generated import ( "github.com/glojurelang/glojure/pkg/lang" - CompilerException31 "glojure.lang.Compiler/CompilerException" - runtime3 "github.com/glojurelang/glojure/pkg/runtime" - strconv4 "strconv" - BigInteger12 "BigInteger" - regexp30 "regexp" - rand33 "math/rand" reflect "reflect" - strings22 "strings" - java.lang.UnsupportedOperationException26 "java.lang.UnsupportedOperationException" - java.io.BufferedWriter21 "java.io.BufferedWriter" - time27 "time" - java.util13 "java.util" - java.util.concurrent15 "java.util.concurrent" - java.net16 "java.net" - Exception24 "Exception" - LinkedBlockingQueue28 "LinkedBlockingQueue" - java.util.concurrent.CountDownLatch29 "java.util.concurrent.CountDownLatch" - java.io.StringReader34 "java.io.StringReader" - glojure.lang.LineNumberingPushbackReader5 "glojure.lang.LineNumberingPushbackReader" - java.io.InputStreamReader6 "java.io.InputStreamReader" - errors10 "errors" + java.io.PrintWriter6 "java.io.PrintWriter" + java.lang10 "java.lang" + java.util26 "java.util" + java.net34 "java.net" fmt "fmt" - math7 "math" - BigDecimal8 "BigDecimal" - big9 "math/big" - Object23 "Object" - java.lang32 "java.lang" - bytes18 "bytes" - java.io.PrintWriter20 "java.io.PrintWriter" + StringBuilder5 "StringBuilder" + java.io.BufferedWriter7 "java.io.BufferedWriter" + time17 "time" + ExceptionInfo19 "ExceptionInfo" lang1 "github.com/glojurelang/glojure/pkg/lang" - ExceptionInfo14 "ExceptionInfo" - java.lang.annotation17 "java.lang.annotation" - glojure.lang11 "glojure.lang" - StringBuilder19 "StringBuilder" - runtime25 "runtime" + bytes4 "bytes" + glojure.lang8 "glojure.lang" + runtime9 "github.com/glojurelang/glojure/pkg/runtime" + Object20 "Object" + strconv27 "strconv" + rand30 "math/rand" + LinkedBlockingQueue32 "LinkedBlockingQueue" + regexp31 "regexp" + java.util.concurrent12 "java.util.concurrent" + BigDecimal13 "BigDecimal" + BigInteger15 "BigInteger" + java.lang.annotation21 "java.lang.annotation" + glojure.lang.LineNumberingPushbackReader23 "glojure.lang.LineNumberingPushbackReader" + java.io.StringReader25 "java.io.StringReader" + CompilerException33 "glojure.lang.Compiler/CompilerException" + errors11 "errors" + math3 "math" + big14 "math/big" + Exception16 "Exception" + java.lang.UnsupportedOperationException18 "java.lang.UnsupportedOperationException" + strings22 "strings" + java.io.InputStreamReader24 "java.io.InputStreamReader" + runtime28 "runtime" + java.util.concurrent.CountDownLatch29 "java.util.concurrent.CountDownLatch" ) func init() { // Closed-over values - var closed0 = lang.NewSymbol("addP") + var closed0 = lang.NewSymbol("unchecked_multiply") + var closed1 = lang.NewSymbol("multiplyP") + var closed10 = lang.NewSymbol("xor") + var closed11 = lang.NewSymbol("max") + var closed12 = lang.NewSymbol("min") var v0 lang.FnFunc v0 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -59,8 +63,7 @@ return v2 }) v1 := reflect.TypeOf(false) v0 = v0.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v1)).(lang.FnFunc) - var closed1 = v0 - var closed10 = lang.NewSymbol("unchecked_add") + var closed13 = v0 var v1 lang.FnFunc v1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { @@ -116,11 +119,7 @@ v10 = nil return v10 }) v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - var closed11 = v1 - var closed12 = lang.NewSymbol("multiplyP") - var closed13 = lang.NewSymbol("xor") - var closed14 = lang.NewSymbol("max") - var closed15 = lang.NewSymbol("divide") + var closed14 = v1 var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { @@ -184,2607 +183,2423 @@ return v5 }) v3 := reflect.TypeOf(false) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v3)).(lang.FnFunc) - var closed2 = v2 - var closed3 = lang.NewSymbol("unchecked_multiply") - var closed4 = lang.NewSymbol("or") - var closed5 = lang.NewSymbol("andNot") - var closed6 = lang.NewSymbol("unchecked_minus") - var closed7 = lang.NewSymbol("min") - var closed8 = lang.NewSymbol("minusP") - var closed9 = lang.NewSymbol("and") + var closed15 = v2 + var closed2 = lang.NewSymbol("unchecked_add") + var closed3 = lang.NewSymbol("addP") + var closed4 = lang.NewSymbol("unchecked_minus") + var closed5 = lang.NewSymbol("minusP") + var closed6 = lang.NewSymbol("divide") + var closed7 = lang.NewSymbol("and") + var closed8 = lang.NewSymbol("andNot") + var closed9 = lang.NewSymbol("or") ns := lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")) _ = ns -// normalize-slurp-opts +// * { -v0 := lang.NewSymbol("normalize-slurp-opts").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7017), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7017), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("opts"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] +var v1 lang.FnFunc +v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v2 := args[0] var v4 any v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("string?")) +v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) if v6.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("first")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v3}) -v12 := lang.Apply(v7, []any{v11}) -if lang.IsTruthy(v12) { -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("println")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{"WARNING: (slurp f enc) is deprecated, use (slurp f :encoding enc)."}) -_ = v16 -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("first")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v3}) -v21 := lang.NewVector(lang.NewKeyword("encoding"), v20) -v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7022), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(7022), lang.NewKeyword("end-column"), int(30)) -v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v4 = v23 +if lang.IsTruthy(v7) { +v4 = closed0 } else { v4 = v3 } -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// with-open -{ -v0 := lang.NewSymbol("with-open").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "bindings => [name init ...]\n\n Evaluates body in a try expression with names bound to the values\n of the inits, and a finally clause that calls (.close name) on each\n name in reverse order.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3832), lang.NewKeyword("end-line"), int(3832))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -var v7 any -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +var v3 any = v4 +_ = v3 +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("seq")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v5}) -if lang.IsTruthy(v11) { -v7 = nil -} else { +v11 := v10.Get() v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("str")) +v13 := v12.FindInternedVar(lang.NewSymbol("concat")) if v13.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } v14 := v13.Get() v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("first")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) if v16.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } v17 := v16.Get() -v18 := lang.Apply(v17, []any{v3}) +v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) if v20.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("meta")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) -v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) -v28 := lang.Apply(lang1.NewIllegalArgumentError, []any{v27}) -panic(v28) +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("seq")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) } -_ = v7 -var v29 any +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("concat")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v2}) +v40 := lang.Apply(v31, []any{v35, v39}) +v41 := lang.Apply(v28, []any{v40}) +v42 := lang.Apply(v25, []any{v41}) +v43 := lang.Apply(v14, []any{v18, v22, v42}) +v44 := lang.Apply(v11, []any{v43}) +return v44 + case 2: +v2 := args[0] +v3 := args[1] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +if lang.IsTruthy(v8) { +v5 = closed0 +} else { +v5 = v4 +} +var v4 any = v5 +_ = v4 +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("seq")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("concat")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("list")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("list")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("list")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("seq")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("even?")) +v31 := v30.FindInternedVar(lang.NewSymbol("concat")) if v31.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) } v32 := v31.Get() v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("count")) +v34 := v33.FindInternedVar(lang.NewSymbol("list")) if v34.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) } v35 := v34.Get() -v36 := lang.Apply(v35, []any{v5}) -v37 := lang.Apply(v32, []any{v36}) -if lang.IsTruthy(v37) { -v29 = nil -} else { -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("str")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +v36 := lang.Apply(v35, []any{v4}) +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("list")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -v40 := v39.Get() +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v2}) v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("first")) +v42 := v41.FindInternedVar(lang.NewSymbol("list")) if v42.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } v43 := v42.Get() v44 := lang.Apply(v43, []any{v3}) -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +v45 := lang.Apply(v32, []any{v36, v40, v44}) +v46 := lang.Apply(v29, []any{v45}) +v47 := lang.Apply(v26, []any{v46}) +v48 := lang.Apply(v15, []any{v19, v23, v47}) +v49 := lang.Apply(v12, []any{v48}) +return v49 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v2 := args[0] +v3 := args[1] +v4 := lang.NewList(args[2:]...) +var v6 any +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v47 := v46.Get() -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("meta")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +v9 := v8.Get() +if lang.IsTruthy(v9) { +v6 = closed0 +} else { +v6 = v5 } -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v3}) -v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) -v53 := lang.Apply(v40, []any{v44, " requires ", "an even number of forms in binding vector", " in ", v47, ":", v52}) -v54 := lang.Apply(lang1.NewIllegalArgumentError, []any{v53}) -panic(v54) +var v5 any = v6 +_ = v5 +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -_ = v29 -_ = nil -var v55 any -v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v57 := v56.FindInternedVar(lang.NewSymbol("=")) -if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) +v13 := v12.Get() +var v14 lang.FnFunc +v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v15 := args[0] +v16 := args[1] +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v58 := v57.Get() -v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v60 := v59.FindInternedVar(lang.NewSymbol("count")) -if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v61 := v60.Get() -v62 := lang.Apply(v61, []any{v5}) -v63 := lang.Apply(v58, []any{v62, int64(0)}) -if lang.IsTruthy(v63) { -v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v65 := v64.FindInternedVar(lang.NewSymbol("seq")) -if v65.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v66 := v65.Get() -v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v68 := v67.FindInternedVar(lang.NewSymbol("concat")) -if v68.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v69 := v68.Get() -v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v71 := v70.FindInternedVar(lang.NewSymbol("list")) -if v71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -v72 := v71.Get() -v73 := lang.Apply(v72, []any{lang.NewSymbol("do")}) -v74 := lang.Apply(v69, []any{v73, v6}) -v75 := lang.Apply(v66, []any{v74}) -v55 = v75 -} else { -var v76 any -v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v78 := v77.FindInternedVar(lang.NewSymbol("symbol?")) -if v78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } -v79 := v78.Get() -v80 := lang.Apply(v5, []any{int64(0)}) -v81 := lang.Apply(v79, []any{v80}) -if lang.IsTruthy(v81) { -v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v83 := v82.FindInternedVar(lang.NewSymbol("seq")) -if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -v84 := v83.Get() -v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v86 := v85.FindInternedVar(lang.NewSymbol("concat")) -if v86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) } -v87 := v86.Get() -v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v89 := v88.FindInternedVar(lang.NewSymbol("list")) -if v89.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v5}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } -v90 := v89.Get() -v91 := lang.Apply(v90, []any{lang.NewSymbol("glojure.core/let")}) -v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v93 := v92.FindInternedVar(lang.NewSymbol("list")) -if v93.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v15}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) } -v94 := v93.Get() -v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v96 := v95.FindInternedVar(lang.NewSymbol("subvec")) -if v96.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v16}) +v52 := lang.Apply(v39, []any{v43, v47, v51}) +v53 := lang.Apply(v36, []any{v52}) +v54 := lang.Apply(v33, []any{v53}) +v55 := lang.Apply(v22, []any{v26, v30, v54}) +v56 := lang.Apply(v19, []any{v55}) +return v56 +}) +v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) +v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v97 := v96.Get() -v98 := lang.Apply(v97, []any{v5, int64(0), int64(2)}) -v99 := lang.Apply(v94, []any{v98}) -v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v101 := v100.FindInternedVar(lang.NewSymbol("list")) -if v101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v102 := v101.Get() -v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v104 := v103.FindInternedVar(lang.NewSymbol("seq")) -if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v105 := v104.Get() -v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v107 := v106.FindInternedVar(lang.NewSymbol("concat")) -if v107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v108 := v107.Get() -v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v110 := v109.FindInternedVar(lang.NewSymbol("list")) -if v110.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v111 := v110.Get() -v112 := lang.Apply(v111, []any{lang.NewSymbol("try")}) -v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v114 := v113.FindInternedVar(lang.NewSymbol("list")) -if v114.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -v115 := v114.Get() -v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v117 := v116.FindInternedVar(lang.NewSymbol("seq")) -if v117.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } -v118 := v117.Get() -v119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v120 := v119.FindInternedVar(lang.NewSymbol("concat")) -if v120.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v120))) +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -v121 := v120.Get() -v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v123 := v122.FindInternedVar(lang.NewSymbol("list")) -if v123.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) } -v124 := v123.Get() -v125 := lang.Apply(v124, []any{lang.NewSymbol("glojure.core/with-open")}) -v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v127 := v126.FindInternedVar(lang.NewSymbol("list")) -if v127.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v5}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } -v128 := v127.Get() -v129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v130 := v129.FindInternedVar(lang.NewSymbol("subvec")) -if v130.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v130))) -} -v131 := v130.Get() -v132 := lang.Apply(v131, []any{v5, int64(2)}) -v133 := lang.Apply(v128, []any{v132}) -v134 := lang.Apply(v121, []any{v125, v133, v6}) -v135 := lang.Apply(v118, []any{v134}) -v136 := lang.Apply(v115, []any{v135}) -v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v138 := v137.FindInternedVar(lang.NewSymbol("list")) -if v138.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) -} -v139 := v138.Get() -v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v141 := v140.FindInternedVar(lang.NewSymbol("seq")) -if v141.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) -} -v142 := v141.Get() -v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v144 := v143.FindInternedVar(lang.NewSymbol("concat")) -if v144.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) -} -v145 := v144.Get() -v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v147 := v146.FindInternedVar(lang.NewSymbol("list")) -if v147.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) -} -v148 := v147.Get() -v149 := lang.Apply(v148, []any{lang.NewSymbol("finally")}) -v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v151 := v150.FindInternedVar(lang.NewSymbol("list")) -if v151.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) -} -v152 := v151.Get() -v153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v154 := v153.FindInternedVar(lang.NewSymbol("seq")) -if v154.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v154))) -} -v155 := v154.Get() -v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v157 := v156.FindInternedVar(lang.NewSymbol("concat")) -if v157.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) -} -v158 := v157.Get() -v159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v160 := v159.FindInternedVar(lang.NewSymbol("list")) -if v160.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v160))) +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v2}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) } -v161 := v160.Get() -v162 := lang.Apply(v161, []any{lang.NewSymbol(".")}) -v163 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v164 := v163.FindInternedVar(lang.NewSymbol("list")) -if v164.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v164))) +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v3}) +v52 := lang.Apply(v39, []any{v43, v47, v51}) +v53 := lang.Apply(v36, []any{v52}) +v54 := lang.Apply(v33, []any{v53}) +v55 := lang.Apply(v22, []any{v26, v30, v54}) +v56 := lang.Apply(v19, []any{v55}) +v57 := lang.Apply(v13, []any{v16, v56, v4}) +return v57 + } +}) +v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } -v165 := v164.Get() -v166 := lang.Apply(v5, []any{int64(0)}) -v167 := lang.Apply(v165, []any{v166}) -v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v169 := v168.FindInternedVar(lang.NewSymbol("list")) -if v169.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) +v5 := lang.Apply(v4, []any{v3, int64(1)}) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v0 := lang.NewSymbol("*").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the product of nums. (*) returns 1. Does not auto-promote\n longs, will throw on overflow. See also: *'", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1001), lang.NewKeyword("end-line"), int(1001))).(*lang.Symbol) +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +return int64(1) + case 1: +v5 := args[0] +v6 := lang.Apply(lang1.MustAsNumber, []any{v5}) +return v6 + case 2: +v5 := args[0] +v6 := args[1] +v7, _ := lang.FieldOrMethod(lang1.Numbers, "multiply") +if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("multiply is not a function"))) } -v170 := v169.Get() -v171 := lang.Apply(v170, []any{lang.NewSymbol("close")}) -v172 := lang.Apply(v158, []any{v162, v167, v171}) -v173 := lang.Apply(v155, []any{v172}) -v174 := lang.Apply(v152, []any{v173}) -v175 := lang.Apply(v145, []any{v149, v174}) -v176 := lang.Apply(v142, []any{v175}) -v177 := lang.Apply(v139, []any{v176}) -v178 := lang.Apply(v108, []any{v112, v136, v177}) -v179 := lang.Apply(v105, []any{v178}) -v180 := lang.Apply(v102, []any{v179}) -v181 := lang.Apply(v87, []any{v91, v99, v180}) -v182 := lang.Apply(v84, []any{v181}) -v76 = v182 -} else { -var v183 any -if lang.IsTruthy(lang.NewKeyword("else")) { -v184 := lang.Apply(lang1.NewIllegalArgumentError, []any{"with-open only allows Symbols in bindings"}) -panic(v184) -} else { -v183 = nil +v8 := lang.Apply(v7, []any{v5, v6}) +return v8 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +v6 := args[1] +v7 := lang.NewList(args[2:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v76 = v183 +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("*")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v55 = v76 +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("*")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -return v55 +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v5, v6}) +v18 := lang.Apply(v10, []any{v13, v17, v7}) +return v18 } }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) +v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v3 := ns.InternWithValue(v0, v4, true) if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + v3.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// ns +// *' { -v0 := lang.NewSymbol("ns").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("docstring?"), lang.NewSymbol("attr-map?"), lang.NewSymbol("references*"))), lang.NewKeyword("doc"), "Sets *ns* to the namespace named by name (unevaluated), creating it\n if needed. references can be zero or more of: (:refer-glojure ...)\n (:require ...) (:use ...) (:import ...) (:load ...) (:gen-class)\n with the syntax of refer-glojure/require/use/import/load/gen-class\n respectively, except the arguments are unevaluated and need not be\n quoted. (:gen-class ...), when supplied, defaults to :name\n corresponding to the ns name, :main true, :impl-ns same as ns, and\n :init-impl-ns true. All options of gen-class are\n supported. The :gen-class directive is ignored when not\n compiling. If :gen-class is not supplied, when compiled only an\n nsname__init.class will be generated. If :refer-glojure is not used, a\n default (refer 'glojure.core) is used. Use of ns is preferred to\n individual calls to in-ns/require/use/import:\n\n (ns foo.bar\n (:refer-glojure :exclude [ancestors printf])\n (:require (glojure.contrib sql combinatorics))\n (:use (my.lib this that))\n (:import (java.util Date Timer Random)\n (java.sql Connection Statement)))", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5785), lang.NewKeyword("end-line"), int(5785))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { +var v1 lang.FnFunc +v1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -var v8 lang.FnFunc -v8 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v9 := args[0] -var v10 any = v9 -_ = v10 + case 1: +v2 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +if lang.IsTruthy(v7) { +v4 = closed1 +} else { +v4 = v3 +} +var v3 any = v4 +_ = v3 +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("seq")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("seq")) +v13 := v12.FindInternedVar(lang.NewSymbol("concat")) if v13.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } v14 := v13.Get() -v15 := lang.Apply(v14, []any{v10}) -var v11 any = v15 -_ = v11 -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("first")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v11}) -var v16 any = v20 -_ = v16 -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("next")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v21}) -var v21 any = v25 -_ = v21 -var v26 any = v16 -_ = v26 -var v27 any = v21 -_ = v27 +v21 := v20.Get() +v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("seq")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("seq")) +v30 := v29.FindInternedVar(lang.NewSymbol("concat")) if v30.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) } v31 := v30.Get() v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("concat")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) if v33.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) } v34 := v33.Get() -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("list")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("symbol")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("name")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v26}) -v45 := lang.Apply(v40, []any{"glojure.core", v44}) -v46 := lang.Apply(v37, []any{v45}) -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("map")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) } -v49 := v48.Get() -var v50 lang.FnFunc -v50 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v51 := args[0] -v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("list")) -if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v2}) +v40 := lang.Apply(v31, []any{v35, v39}) +v41 := lang.Apply(v28, []any{v40}) +v42 := lang.Apply(v25, []any{v41}) +v43 := lang.Apply(v14, []any{v18, v22, v42}) +v44 := lang.Apply(v11, []any{v43}) +return v44 + case 2: +v2 := args[0] +v3 := args[1] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v54 := v53.Get() -v55 := lang.Apply(v54, []any{lang.NewSymbol("quote"), v51}) -return v55 -}) -v51 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5812), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(5812), lang.NewKeyword("end-column"), int(36)) -v52, err := lang.WithMeta(v50, v51.(lang.IPersistentMap)) -if err != nil { - panic(err) +v8 := v7.Get() +if lang.IsTruthy(v8) { +v5 = closed1 +} else { +v5 = v4 } -v53 := lang.Apply(v49, []any{v52, v27}) -v54 := lang.Apply(v34, []any{v46, v53}) -v55 := lang.Apply(v31, []any{v54}) -return v55 -}) -v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5810), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(5812), lang.NewKeyword("end-column"), int(44)) -v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) -if err != nil { - panic(err) +var v4 any = v5 +_ = v4 +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("seq")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -var v7 any = v10 -_ = v7 -var v12 any +v12 := v11.Get() v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("string?")) +v14 := v13.FindInternedVar(lang.NewSymbol("concat")) if v14.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } v15 := v14.Get() v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("first")) +v17 := v16.FindInternedVar(lang.NewSymbol("list")) if v17.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } v18 := v17.Get() -v19 := lang.Apply(v18, []any{v6}) -v20 := lang.Apply(v15, []any{v19}) -if lang.IsTruthy(v20) { -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("first")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("list")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v6}) -v12 = v24 -} else { -v12 = nil +v22 := v21.Get() +v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("list")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -var v11 any = v12 -_ = v11 -var v26 any -if lang.IsTruthy(v11) { +v26 := v25.Get() v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("next")) +v28 := v27.FindInternedVar(lang.NewSymbol("seq")) if v28.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } v29 := v28.Get() -v30 := lang.Apply(v29, []any{v25}) -v26 = v30 -} else { -v26 = v25 +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("concat")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) } -var v25 any = v26 -_ = v25 -var v32 any -if lang.IsTruthy(v11) { +v32 := v31.Get() v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("vary-meta")) +v34 := v33.FindInternedVar(lang.NewSymbol("list")) if v34.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) } v35 := v34.Get() -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("assoc")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v35, []any{v31, v38, lang.NewKeyword("doc"), v11}) -v32 = v39 -} else { -v32 = v31 -} -var v31 any = v32 -_ = v31 -var v41 any -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("map?")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +v36 := lang.Apply(v35, []any{v4}) +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("list")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -v44 := v43.Get() -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("first")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v2}) +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("list")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } -v47 := v46.Get() -v48 := lang.Apply(v47, []any{v25}) -v49 := lang.Apply(v44, []any{v48}) -if lang.IsTruthy(v49) { -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("first")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v3}) +v45 := lang.Apply(v32, []any{v36, v40, v44}) +v46 := lang.Apply(v29, []any{v45}) +v47 := lang.Apply(v26, []any{v46}) +v48 := lang.Apply(v15, []any{v19, v23, v47}) +v49 := lang.Apply(v12, []any{v48}) +return v49 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v2 := args[0] +v3 := args[1] +v4 := lang.NewList(args[2:]...) +var v6 any +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v52 := v51.Get() -v53 := lang.Apply(v52, []any{v25}) -v41 = v53 +v9 := v8.Get() +if lang.IsTruthy(v9) { +v6 = closed1 } else { -v41 = nil +v6 = v5 } -var v40 any = v41 -_ = v40 -var v55 any -if lang.IsTruthy(v40) { -v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v57 := v56.FindInternedVar(lang.NewSymbol("next")) -if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) +var v5 any = v6 +_ = v5 +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v58 := v57.Get() -v59 := lang.Apply(v58, []any{v54}) -v55 = v59 -} else { -v55 = v54 +v13 := v12.Get() +var v14 lang.FnFunc +v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v15 := args[0] +v16 := args[1] +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -var v54 any = v55 -_ = v54 -var v61 any -if lang.IsTruthy(v40) { -v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v63 := v62.FindInternedVar(lang.NewSymbol("vary-meta")) -if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v64 := v63.Get() -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("merge")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v67 := v66.Get() -v68 := lang.Apply(v64, []any{v60, v67, v40}) -v61 = v68 -} else { -v61 = v60 +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -var v60 any = v61 -_ = v60 -v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v71 := v70.FindInternedVar(lang.NewSymbol("first")) -if v71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -v72 := v71.Get() -v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v74 := v73.FindInternedVar(lang.NewSymbol("filter")) -if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } -v75 := v74.Get() -var v76 lang.FnFunc -v76 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v77 := args[0] -v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v79 := v78.FindInternedVar(lang.NewSymbol("=")) -if v79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -v80 := v79.Get() -v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v82 := v81.FindInternedVar(lang.NewSymbol("first")) -if v82.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) } -v83 := v82.Get() -v84 := lang.Apply(v83, []any{v77}) -v85 := lang.Apply(v80, []any{lang.NewKeyword("gen-class"), v84}) -return v85 +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v5}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v15}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v16}) +v52 := lang.Apply(v39, []any{v43, v47, v51}) +v53 := lang.Apply(v36, []any{v52}) +v54 := lang.Apply(v33, []any{v53}) +v55 := lang.Apply(v22, []any{v26, v30, v54}) +v56 := lang.Apply(v19, []any{v55}) +return v56 }) -v77 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5823), lang.NewKeyword("column"), int(41), lang.NewKeyword("end-line"), int(5823), lang.NewKeyword("end-column"), int(65)) -v78, err := lang.WithMeta(v76, v77.(lang.IPersistentMap)) +v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) +v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) if err != nil { panic(err) } -v79 := lang.Apply(v75, []any{v78, v54}) -v80 := lang.Apply(v72, []any{v79}) -var v69 any = v80 -_ = v69 -var v82 any -if lang.IsTruthy(v69) { -v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v84 := v83.FindInternedVar(lang.NewSymbol("list*")) -if v84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v85 := v84.Get() -v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v87 := v86.FindInternedVar(lang.NewSymbol("str")) -if v87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v88 := v87.Get() -v89 := lang.Apply(v88, []any{v60}) -v90, _ := lang.FieldOrMethod(v89, "replace") -if reflect.TypeOf(v90).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("replace is not a function"))) +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v91 := lang.Apply(v90, []any{lang.NewChar(45), lang.NewChar(95)}) -v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v93 := v92.FindInternedVar(lang.NewSymbol("next")) -if v93.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v94 := v93.Get() -v95 := lang.Apply(v94, []any{v69}) -v96 := lang.Apply(v85, []any{lang.NewSymbol("glojure.core/gen-class"), lang.NewKeyword("name"), v91, lang.NewKeyword("impl-ns"), v60, lang.NewKeyword("main"), true, v95}) -v82 = v96 -} else { -v82 = nil +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -var v81 any = v82 -_ = v81 -v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v99 := v98.FindInternedVar(lang.NewSymbol("remove")) -if v99.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } -v100 := v99.Get() -var v101 lang.FnFunc -v101 = lang.NewFnFunc(func(args ...any) any { +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v5}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v2}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v3}) +v52 := lang.Apply(v39, []any{v43, v47, v51}) +v53 := lang.Apply(v36, []any{v52}) +v54 := lang.Apply(v33, []any{v53}) +v55 := lang.Apply(v22, []any{v26, v30, v54}) +v56 := lang.Apply(v19, []any{v55}) +v57 := lang.Apply(v13, []any{v16, v56, v4}) +return v57 + } +}) +v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v102 := args[0] -v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v104 := v103.FindInternedVar(lang.NewSymbol("=")) -if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) -} -v105 := v104.Get() -v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v107 := v106.FindInternedVar(lang.NewSymbol("first")) -if v107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) +v3 := args[0] +v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } -v108 := v107.Get() -v109 := lang.Apply(v108, []any{v102}) -v110 := lang.Apply(v105, []any{lang.NewKeyword("gen-class"), v109}) -return v110 +v5 := lang.Apply(v4, []any{v3, int64(1)}) +return v5 }) -v102 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5827), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(5827), lang.NewKeyword("end-column"), int(52)) -v103, err := lang.WithMeta(v101, v102.(lang.IPersistentMap)) -if err != nil { - panic(err) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v0 := lang.NewSymbol("*'").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the product of nums. (*') returns 1. Supports arbitrary precision.\n See also: *", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(989), lang.NewKeyword("end-line"), int(989))).(*lang.Symbol) +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +return int64(1) + case 1: +v5 := args[0] +v6 := lang.Apply(lang1.MustAsNumber, []any{v5}) +return v6 + case 2: +v5 := args[0] +v6 := args[1] +v7, _ := lang.FieldOrMethod(lang1.Numbers, "multiplyP") +if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("multiplyP is not a function"))) } -v104 := lang.Apply(v100, []any{v103, v97}) -var v97 any = v104 -_ = v97 -v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v107 := v106.FindInternedVar(lang.NewSymbol("meta")) -if v107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) +v8 := lang.Apply(v7, []any{v5, v6}) +return v8 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +v6 := args[1] +v7 := lang.NewList(args[2:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v108 := v107.Get() -v109 := lang.Apply(v108, []any{v60}) -var v105 any = v109 -_ = v105 -v111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v112 := v111.FindInternedVar(lang.NewSymbol("seq")) -if v112.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v112))) +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("*'")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v113 := v112.Get() -v114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v115 := v114.FindInternedVar(lang.NewSymbol("concat")) -if v115.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v115))) +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("*'")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v116 := v115.Get() -v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v118 := v117.FindInternedVar(lang.NewSymbol("list")) -if v118.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v5, v6}) +v18 := lang.Apply(v10, []any{v13, v17, v7}) +return v18 + } +}) +v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v3 := ns.InternWithValue(v0, v4, true) +if v0.Meta() != nil { + v3.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v119 := v118.Get() -v120 := lang.Apply(v119, []any{lang.NewSymbol("do")}) -v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v122 := v121.FindInternedVar(lang.NewSymbol("list")) -if v122.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) } -v123 := v122.Get() -v124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v125 := v124.FindInternedVar(lang.NewSymbol("seq")) -if v125.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v125))) +// *1 +{ +v0 := lang.NewSymbol("*1").WithMeta(lang.NewMap()).(*lang.Symbol) +v1 := ns.Intern(v0) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v126 := v125.Get() -v127 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v128 := v127.FindInternedVar(lang.NewSymbol("concat")) -if v128.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v128))) } -v129 := v128.Get() -v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v131 := v130.FindInternedVar(lang.NewSymbol("list")) -if v131.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) +// *2 +{ +v0 := lang.NewSymbol("*2").WithMeta(lang.NewMap()).(*lang.Symbol) +v1 := ns.Intern(v0) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v132 := v131.Get() -v133 := lang.Apply(v132, []any{lang.NewSymbol("glojure.core/in-ns")}) -v134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v135 := v134.FindInternedVar(lang.NewSymbol("list")) -if v135.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v135))) } -v136 := v135.Get() -v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v138 := v137.FindInternedVar(lang.NewSymbol("seq")) -if v138.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) +// *3 +{ +v0 := lang.NewSymbol("*3").WithMeta(lang.NewMap()).(*lang.Symbol) +v1 := ns.Intern(v0) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v139 := v138.Get() -v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v141 := v140.FindInternedVar(lang.NewSymbol("concat")) -if v141.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) } -v142 := v141.Get() -v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v144 := v143.FindInternedVar(lang.NewSymbol("list")) -if v144.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) +// *agent* +{ +v0 := lang.NewSymbol("*agent*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, nil, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v145 := v144.Get() -v146 := lang.Apply(v145, []any{lang.NewSymbol("quote")}) -v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v148 := v147.FindInternedVar(lang.NewSymbol("list")) -if v148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) } -v149 := v148.Get() -v150 := lang.Apply(v149, []any{v60}) -v151 := lang.Apply(v142, []any{v146, v150}) -v152 := lang.Apply(v139, []any{v151}) -v153 := lang.Apply(v136, []any{v152}) -v154 := lang.Apply(v129, []any{v133, v153}) -v155 := lang.Apply(v126, []any{v154}) -v156 := lang.Apply(v123, []any{v155}) -var v157 any -if lang.IsTruthy(v105) { -v158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v159 := v158.FindInternedVar(lang.NewSymbol("seq")) -if v159.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v159))) +// *assert* +{ +v0 := lang.NewSymbol("*assert*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "When set to logical false, 'assert' will omit assertion checks in\n compiled code. Defaults to true.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, false, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v160 := v159.Get() -v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v162 := v161.FindInternedVar(lang.NewSymbol("concat")) -if v162.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) } -v163 := v162.Get() -v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v165 := v164.FindInternedVar(lang.NewSymbol("list")) -if v165.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) +// *command-line-args* +{ +v0 := lang.NewSymbol("*command-line-args*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "A sequence of the supplied command line arguments, or nil if\n none were supplied", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, nil, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v166 := v165.Get() -v167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v168 := v167.FindInternedVar(lang.NewSymbol("seq")) -if v168.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v168))) } -v169 := v168.Get() -v170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v171 := v170.FindInternedVar(lang.NewSymbol("concat")) -if v171.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v171))) +// *compile-files* +{ +v0 := lang.NewSymbol("*compile-files*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "Set to true when compiling files, false otherwise.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, false, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v172 := v171.Get() -v173 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v174 := v173.FindInternedVar(lang.NewSymbol("list")) -if v174.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v174))) } -v175 := v174.Get() -v176 := lang.Apply(v175, []any{lang.NewSymbol(".ResetMeta")}) -v177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v178 := v177.FindInternedVar(lang.NewSymbol("list")) -if v178.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v178))) +// *compile-path* +{ +v0 := lang.NewSymbol("*compile-path*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "Specifies the directory where 'compile' will write out .class\n files. This directory must be in the classpath for 'compile' to\n work.\n\n Defaults to \"classes\"", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, nil, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v179 := v178.Get() -v180 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v181 := v180.FindInternedVar(lang.NewSymbol("seq")) -if v181.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v181))) } -v182 := v181.Get() -v183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v184 := v183.FindInternedVar(lang.NewSymbol("concat")) -if v184.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v184))) +// *compiler-options* +{ +v0 := lang.NewSymbol("*compiler-options*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.4", lang.NewKeyword("doc"), "A map of keys to options.\n Note, when binding dynamically make sure to merge with previous value.\n Supported options:\n :elide-meta - a collection of metadata keys to elide during compilation.\n :disable-locals-clearing - set to true to disable clearing, useful for using a debugger\n :direct-linking - set to true to use direct static invocation of functions, rather than vars\n Note that call sites compiled with direct linking will not be affected by var redefinition.\n Use ^:redef (or ^:dynamic) on a var to prevent direct linking and allow redefinition.\n See https://glojure.org/reference/compilation for more information.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, nil, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v185 := v184.Get() -v186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v187 := v186.FindInternedVar(lang.NewSymbol("list")) -if v187.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v187))) } -v188 := v187.Get() -v189 := lang.Apply(v188, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.FindNamespace")}) -v190 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v191 := v190.FindInternedVar(lang.NewSymbol("list")) -if v191.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v191))) +// *data-readers* +{ +v0 := lang.NewSymbol("*data-readers*").WithMeta(lang.NewMap(lang.NewKeyword("doc"), "Map from reader tag symbols to data reader Vars.\n\n When Clojure starts, it searches for files named 'data_readers.clj'\n and 'data_readers.cljc' at the root of the classpath. Each such file\n must contain a literal map of symbols, like this:\n\n {foo/bar my.project.foo/bar\n foo/baz my.project/baz}\n\n The first symbol in each pair is a tag that will be recognized by\n the Clojure reader. The second symbol in the pair is the\n fully-qualified name of a Var which will be invoked by the reader to\n parse the form following the tag. For example, given the\n data_readers.clj file above, the Clojure reader would parse this\n form:\n\n #foo/bar [1 2 3]\n\n by invoking the Var #'my.project.foo/bar on the vector [1 2 3]. The\n data reader function is invoked on the form AFTER it has been read\n as a normal Clojure data structure by the reader.\n\n Reader tags without namespace qualifiers are reserved for\n Clojure. Default reader tags are defined in\n glojure.core/default-data-readers but may be overridden in\n data_readers.clj, data_readers.cljc, or by rebinding this Var.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(49), lang.NewKeyword("column"), int(6), lang.NewKeyword("line"), int(7837), lang.NewKeyword("end-line"), int(7837), lang.NewKeyword("dynamic"), true)).(*lang.Symbol) +v1 := ns.InternWithValue(v0, lang.NewMap(), true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v192 := v191.Get() -v193 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v194 := v193.FindInternedVar(lang.NewSymbol("seq")) -if v194.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v194))) } -v195 := v194.Get() -v196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v197 := v196.FindInternedVar(lang.NewSymbol("concat")) -if v197.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v197))) +// *default-data-reader-fn* +{ +v0 := lang.NewSymbol("*default-data-reader-fn*").WithMeta(lang.NewMap(lang.NewKeyword("doc"), "When no data reader is found for a tag and *default-data-reader-fn*\n is non-nil, it will be called with two arguments,\n the tag and the value. If *default-data-reader-fn* is nil (the\n default), an exception will be thrown for the unknown tag.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(59), lang.NewKeyword("column"), int(6), lang.NewKeyword("line"), int(7866), lang.NewKeyword("end-line"), int(7866), lang.NewKeyword("dynamic"), true)).(*lang.Symbol) +v1 := ns.InternWithValue(v0, nil, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v198 := v197.Get() -v199 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v200 := v199.FindInternedVar(lang.NewSymbol("list")) -if v200.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v200))) -} -v201 := v200.Get() -v202 := lang.Apply(v201, []any{lang.NewSymbol("quote")}) -v203 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v204 := v203.FindInternedVar(lang.NewSymbol("list")) -if v204.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v204))) } -v205 := v204.Get() -v206 := lang.Apply(v205, []any{v60}) -v207 := lang.Apply(v198, []any{v202, v206}) -v208 := lang.Apply(v195, []any{v207}) -v209 := lang.Apply(v192, []any{v208}) -v210 := lang.Apply(v185, []any{v189, v209}) -v211 := lang.Apply(v182, []any{v210}) -v212 := lang.Apply(v179, []any{v211}) -v213 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v214 := v213.FindInternedVar(lang.NewSymbol("list")) -if v214.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v214))) +// *e +{ +v0 := lang.NewSymbol("*e").WithMeta(lang.NewMap()).(*lang.Symbol) +v1 := ns.Intern(v0) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v215 := v214.Get() -v216 := lang.Apply(v215, []any{v105}) -v217 := lang.Apply(v172, []any{v176, v212, v216}) -v218 := lang.Apply(v169, []any{v217}) -v219 := lang.Apply(v166, []any{v218}) -v220 := lang.Apply(v163, []any{v219}) -v221 := lang.Apply(v160, []any{v220}) -v157 = v221 -} else { -v157 = nil } -v222 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v223 := v222.FindInternedVar(lang.NewSymbol("list")) -if v223.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v223))) +// *err* +{ +v0 := lang.NewSymbol("*err*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "A java.io.Writer object representing standard error for print operations.\n\n Defaults to System/err, wrapped in a PrintWriter", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, nil, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v224 := v223.Get() -v225 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v226 := v225.FindInternedVar(lang.NewSymbol("seq")) -if v226.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v226))) } -v227 := v226.Get() -v228 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v229 := v228.FindInternedVar(lang.NewSymbol("concat")) -if v229.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v229))) +// *file* +{ +v0 := lang.NewSymbol("*file*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "The path of the file being evaluated, as a String.\n\n When there is no file, e.g. in the REPL, the value is not defined.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, "NO_SOURCE_FILE", true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v230 := v229.Get() -v231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v232 := v231.FindInternedVar(lang.NewSymbol("list")) -if v232.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v232))) } -v233 := v232.Get() -v234 := lang.Apply(v233, []any{lang.NewSymbol("glojure.core/with-loading-context")}) -var v235 any -if lang.IsTruthy(v81) { -v236 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v237 := v236.FindInternedVar(lang.NewSymbol("list")) -if v237.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v237))) +// *flush-on-newline* +{ +v0 := lang.NewSymbol("*flush-on-newline*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "When set to true, output will be flushed whenever a newline is printed.\n\n Defaults to true.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, nil, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v238 := v237.Get() -v239 := lang.Apply(v238, []any{v81}) -v235 = v239 -} else { -v235 = nil } -var v240 any -v242 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v243 := v242.FindInternedVar(lang.NewSymbol("not=")) -if v243.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v243))) +// *loaded-libs* +{ +v0 := lang.NewSymbol("*loaded-libs*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5860), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(5863), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, nil, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v244 := v243.Get() -v245 := lang.Apply(v244, []any{v60, lang.NewSymbol("glojure.core")}) -var v241 any = v245 -_ = v241 -var v247 any -if lang.IsTruthy(v241) { -v248 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v249 := v248.FindInternedVar(lang.NewSymbol("not-any?")) -if v249.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v249))) } -v250 := v249.Get() -var v251 lang.FnFunc -v251 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v252 := args[0] -v253 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v254 := v253.FindInternedVar(lang.NewSymbol("=")) -if v254.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v254))) +// *loading-verbosely* +{ +v0 := lang.NewSymbol("*loading-verbosely*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5870), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(5873), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, false, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v255 := v254.Get() -v256 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v257 := v256.FindInternedVar(lang.NewSymbol("first")) -if v257.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v257))) } -v258 := v257.Get() -v259 := lang.Apply(v258, []any{v252}) -v260 := lang.Apply(v255, []any{lang.NewKeyword("refer-glojure"), v259}) -return v260 -}) -v252 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5836), lang.NewKeyword("column"), int(58), lang.NewKeyword("end-line"), int(5836), lang.NewKeyword("end-column"), int(86)) -v253, err := lang.WithMeta(v251, v252.(lang.IPersistentMap)) -if err != nil { - panic(err) +// *ns* +{ +v0 := lang.NewSymbol("*ns*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "A glojure.lang.Namespace object representing the current namespace.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v254 := lang.Apply(v250, []any{v253, v97}) -v247 = v254 -} else { -v247 = v241 } -if lang.IsTruthy(v247) { -v241 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v242 := v241.FindInternedVar(lang.NewSymbol("seq")) -if v242.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v242))) +// *pending-paths* +{ +v0 := lang.NewSymbol("*pending-paths*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5865), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(5868), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, lang.NewList(), true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v243 := v242.Get() -v244 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v245 := v244.FindInternedVar(lang.NewSymbol("concat")) -if v245.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v245))) } -v246 := v245.Get() -v247 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v248 := v247.FindInternedVar(lang.NewSymbol("list")) -if v248.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v248))) +// *print-dup* +{ +v0 := lang.NewSymbol("*print-dup*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "When set to logical true, objects will be printed in a way that preserves\n their type when read in later.\n\n Defaults to false.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, nil, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v249 := v248.Get() -v250 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v251 := v250.FindInternedVar(lang.NewSymbol("seq")) -if v251.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v251))) } -v252 := v251.Get() -v253 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v254 := v253.FindInternedVar(lang.NewSymbol("concat")) -if v254.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v254))) +// *print-length* +{ +v0 := lang.NewSymbol("*print-length*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(14), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(23), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, nil, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v255 := v254.Get() -v256 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v257 := v256.FindInternedVar(lang.NewSymbol("list")) -if v257.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v257))) } -v258 := v257.Get() -v259 := lang.Apply(v258, []any{lang.NewSymbol("glojure.core/refer")}) -v260 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v261 := v260.FindInternedVar(lang.NewSymbol("list")) -if v261.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v261))) +// *print-level* +{ +v0 := lang.NewSymbol("*print-level*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(25), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(35), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, nil, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v262 := v261.Get() -v263 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v264 := v263.FindInternedVar(lang.NewSymbol("seq")) -if v264.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v264))) } -v265 := v264.Get() -v266 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v267 := v266.FindInternedVar(lang.NewSymbol("concat")) -if v267.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v267))) +// *print-meta* +{ +v0 := lang.NewSymbol("*print-meta*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "If set to logical true, when printing an object, its metadata will also\n be printed in a form that can be read back by the reader.\n\n Defaults to false.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, nil, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v268 := v267.Get() -v269 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v270 := v269.FindInternedVar(lang.NewSymbol("list")) -if v270.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v270))) } -v271 := v270.Get() -v272 := lang.Apply(v271, []any{lang.NewSymbol("quote")}) -v273 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v274 := v273.FindInternedVar(lang.NewSymbol("list")) -if v274.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v274))) +// *print-namespace-maps* +{ +v0 := lang.NewSymbol("*print-namespace-maps*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(39), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(44), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, false, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v275 := v274.Get() -v276 := lang.Apply(v275, []any{lang.NewSymbol("glojure.core")}) -v277 := lang.Apply(v268, []any{v272, v276}) -v278 := lang.Apply(v265, []any{v277}) -v279 := lang.Apply(v262, []any{v278}) -v280 := lang.Apply(v255, []any{v259, v279}) -v281 := lang.Apply(v252, []any{v280}) -v282 := lang.Apply(v249, []any{v281}) -v283 := lang.Apply(v246, []any{v282}) -v284 := lang.Apply(v243, []any{v283}) -v240 = v284 -} else { -v240 = nil } -v285 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v286 := v285.FindInternedVar(lang.NewSymbol("map")) -if v286.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v286))) +// *print-readably* +{ +v0 := lang.NewSymbol("*print-readably*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "When set to logical false, strings and characters will be printed with\n non-alphanumeric characters converted to the appropriate escape sequences.\n\n Defaults to true", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, true, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v287 := v286.Get() -v288 := lang.Apply(v287, []any{v7, v97}) -v289 := lang.Apply(v230, []any{v234, v235, v240, v288}) -v290 := lang.Apply(v227, []any{v289}) -v291 := lang.Apply(v224, []any{v290}) -v292 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v293 := v292.FindInternedVar(lang.NewSymbol("list")) -if v293.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v293))) } -v294 := v293.Get() -v295 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v296 := v295.FindInternedVar(lang.NewSymbol("seq")) -if v296.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v296))) +// *read-eval* +{ +v0 := lang.NewSymbol("*read-eval*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "Defaults to true (or value specified by system property, see below)\n ***This setting implies that the full power of the reader is in play,\n including syntax that can cause code to execute. It should never be\n used with untrusted sources. See also: glojure.edn/read.***\n\n When set to logical false in the thread-local binding,\n the eval reader (#=) and record/type literal syntax are disabled in read/load.\n Example (will fail): (binding [*read-eval* false] (read-string \"#=(* 2 21)\"))\n\n The default binding can be controlled by the system property\n 'glojure.read.eval' System properties can be set on the command line\n like this:\n\n java -Dglojure.read.eval=false ...\n\n The system property can also be set to 'unknown' via\n -Dglojure.read.eval=unknown, in which case the default binding\n is :unknown and all reads will fail in contexts where *read-eval*\n has not been explicitly bound to either true or false. This setting\n can be a useful diagnostic tool to ensure that all of your reads\n occur in considered contexts. You can also accomplish this in a\n particular scope by binding *read-eval* to :unknown\n ", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, nil, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v297 := v296.Get() -v298 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v299 := v298.FindInternedVar(lang.NewSymbol("concat")) -if v299.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v299))) } -v300 := v299.Get() -v301 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v302 := v301.FindInternedVar(lang.NewSymbol("list")) -if v302.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v302))) +// *repl* +{ +v0 := lang.NewSymbol("*repl*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6331), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(6334), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, false, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v303 := v302.Get() -v304 := lang.Apply(v303, []any{lang.NewSymbol("if")}) -v305 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v306 := v305.FindInternedVar(lang.NewSymbol("list")) -if v306.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v306))) } -v307 := v306.Get() -v308 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v309 := v308.FindInternedVar(lang.NewSymbol("seq")) -if v309.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v309))) +// *unchecked-math* +{ +v0 := lang.NewSymbol("*unchecked-math*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.3", lang.NewKeyword("doc"), "While bound to true, compilations of +, -, *, inc, dec and the\n coercions will be done without overflow checks. While bound\n to :warn-on-boxed, same behavior as true, and a warning is emitted\n when compilation uses boxed math. Default: false.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, nil, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v310 := v309.Get() -v311 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v312 := v311.FindInternedVar(lang.NewSymbol("concat")) -if v312.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v312))) } -v313 := v312.Get() -v314 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v315 := v314.FindInternedVar(lang.NewSymbol("list")) -if v315.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v315))) +// *verbose-defrecords* +{ +v0 := lang.NewSymbol("*verbose-defrecords*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(37), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(37), lang.NewKeyword("end-column"), int(35), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, false, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v316 := v315.Get() -v317 := lang.Apply(v316, []any{lang.NewSymbol(".Equals")}) -v318 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v319 := v318.FindInternedVar(lang.NewSymbol("list")) -if v319.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v319))) } -v320 := v319.Get() -v321 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v322 := v321.FindInternedVar(lang.NewSymbol("seq")) -if v322.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v322))) +// *warn-on-reflection* +{ +v0 := lang.NewSymbol("*warn-on-reflection*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "When set to true, the compiler will emit warnings when reflection is\n needed to resolve Java method calls or field accesses.\n\n Defaults to false.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, nil, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v323 := v322.Get() -v324 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v325 := v324.FindInternedVar(lang.NewSymbol("concat")) -if v325.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v325))) } -v326 := v325.Get() -v327 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v328 := v327.FindInternedVar(lang.NewSymbol("list")) -if v328.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v328))) +// + +{ +var v1 lang.FnFunc +v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v2 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v329 := v328.Get() -v330 := lang.Apply(v329, []any{lang.NewSymbol("quote")}) -v331 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v332 := v331.FindInternedVar(lang.NewSymbol("list")) -if v332.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v332))) +v7 := v6.Get() +if lang.IsTruthy(v7) { +v4 = closed2 +} else { +v4 = v3 } -v333 := v332.Get() -v334 := lang.Apply(v333, []any{v60}) -v335 := lang.Apply(v326, []any{v330, v334}) -v336 := lang.Apply(v323, []any{v335}) -v337 := lang.Apply(v320, []any{v336}) -v338 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v339 := v338.FindInternedVar(lang.NewSymbol("list")) -if v339.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v339))) +var v3 any = v4 +_ = v3 +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("seq")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -v340 := v339.Get() -v341 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v342 := v341.FindInternedVar(lang.NewSymbol("seq")) -if v342.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v342))) +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("concat")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } -v343 := v342.Get() -v344 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v345 := v344.FindInternedVar(lang.NewSymbol("concat")) -if v345.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v345))) +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } -v346 := v345.Get() -v347 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v348 := v347.FindInternedVar(lang.NewSymbol("list")) -if v348.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v348))) +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v349 := v348.Get() -v350 := lang.Apply(v349, []any{lang.NewSymbol("quote")}) -v351 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v352 := v351.FindInternedVar(lang.NewSymbol("list")) -if v352.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v352))) +v21 := v20.Get() +v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v353 := v352.Get() -v354 := lang.Apply(v353, []any{lang.NewSymbol("glojure.core")}) -v355 := lang.Apply(v346, []any{v350, v354}) -v356 := lang.Apply(v343, []any{v355}) -v357 := lang.Apply(v340, []any{v356}) -v358 := lang.Apply(v313, []any{v317, v337, v357}) -v359 := lang.Apply(v310, []any{v358}) -v360 := lang.Apply(v307, []any{v359}) -v361 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v362 := v361.FindInternedVar(lang.NewSymbol("list")) -if v362.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v362))) +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("seq")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) } -v363 := v362.Get() -v364 := lang.Apply(v363, []any{nil}) -v365 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v366 := v365.FindInternedVar(lang.NewSymbol("list")) -if v366.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v366))) +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("concat")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) } -v367 := v366.Get() -v368 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v369 := v368.FindInternedVar(lang.NewSymbol("seq")) -if v369.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v369))) +v31 := v30.Get() +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) } -v370 := v369.Get() -v371 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v372 := v371.FindInternedVar(lang.NewSymbol("concat")) -if v372.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v372))) +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) } -v373 := v372.Get() -v374 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v375 := v374.FindInternedVar(lang.NewSymbol("list")) -if v375.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v375))) +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v2}) +v40 := lang.Apply(v31, []any{v35, v39}) +v41 := lang.Apply(v28, []any{v40}) +v42 := lang.Apply(v25, []any{v41}) +v43 := lang.Apply(v14, []any{v18, v22, v42}) +v44 := lang.Apply(v11, []any{v43}) +return v44 + case 2: +v2 := args[0] +v3 := args[1] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v376 := v375.Get() -v377 := lang.Apply(v376, []any{lang.NewSymbol("do")}) -v378 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v379 := v378.FindInternedVar(lang.NewSymbol("list")) -if v379.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v379))) -} -v380 := v379.Get() -v381 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v382 := v381.FindInternedVar(lang.NewSymbol("seq")) -if v382.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v382))) -} -v383 := v382.Get() -v384 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v385 := v384.FindInternedVar(lang.NewSymbol("concat")) -if v385.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v385))) -} -v386 := v385.Get() -v387 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v388 := v387.FindInternedVar(lang.NewSymbol("list")) -if v388.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v388))) -} -v389 := v388.Get() -v390 := lang.Apply(v389, []any{lang.NewSymbol("glojure.core/dosync")}) -v391 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v392 := v391.FindInternedVar(lang.NewSymbol("list")) -if v392.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v392))) -} -v393 := v392.Get() -v394 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v395 := v394.FindInternedVar(lang.NewSymbol("seq")) -if v395.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v395))) -} -v396 := v395.Get() -v397 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v398 := v397.FindInternedVar(lang.NewSymbol("concat")) -if v398.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v398))) -} -v399 := v398.Get() -v400 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v401 := v400.FindInternedVar(lang.NewSymbol("list")) -if v401.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v401))) -} -v402 := v401.Get() -v403 := lang.Apply(v402, []any{lang.NewSymbol("glojure.core/commute")}) -v404 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v405 := v404.FindInternedVar(lang.NewSymbol("list")) -if v405.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v405))) -} -v406 := v405.Get() -v407 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v408 := v407.FindInternedVar(lang.NewSymbol("seq")) -if v408.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v408))) -} -v409 := v408.Get() -v410 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v411 := v410.FindInternedVar(lang.NewSymbol("concat")) -if v411.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v411))) -} -v412 := v411.Get() -v413 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v414 := v413.FindInternedVar(lang.NewSymbol("list")) -if v414.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v414))) -} -v415 := v414.Get() -v416 := lang.Apply(v415, []any{lang.NewSymbol("glojure.core/deref")}) -v417 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v418 := v417.FindInternedVar(lang.NewSymbol("list")) -if v418.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v418))) -} -v419 := v418.Get() -v420 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v421 := v420.FindInternedVar(lang.NewSymbol("seq")) -if v421.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v421))) -} -v422 := v421.Get() -v423 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v424 := v423.FindInternedVar(lang.NewSymbol("concat")) -if v424.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v424))) -} -v425 := v424.Get() -v426 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v427 := v426.FindInternedVar(lang.NewSymbol("list")) -if v427.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v427))) -} -v428 := v427.Get() -v429 := lang.Apply(v428, []any{lang.NewSymbol("var")}) -v430 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v431 := v430.FindInternedVar(lang.NewSymbol("list")) -if v431.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v431))) -} -v432 := v431.Get() -v433 := lang.Apply(v432, []any{lang.NewSymbol("glojure.core/*loaded-libs*")}) -v434 := lang.Apply(v425, []any{v429, v433}) -v435 := lang.Apply(v422, []any{v434}) -v436 := lang.Apply(v419, []any{v435}) -v437 := lang.Apply(v412, []any{v416, v436}) -v438 := lang.Apply(v409, []any{v437}) -v439 := lang.Apply(v406, []any{v438}) -v440 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v441 := v440.FindInternedVar(lang.NewSymbol("list")) -if v441.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v441))) -} -v442 := v441.Get() -v443 := lang.Apply(v442, []any{lang.NewSymbol("glojure.core/conj")}) -v444 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v445 := v444.FindInternedVar(lang.NewSymbol("list")) -if v445.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v445))) -} -v446 := v445.Get() -v447 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v448 := v447.FindInternedVar(lang.NewSymbol("seq")) -if v448.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v448))) -} -v449 := v448.Get() -v450 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v451 := v450.FindInternedVar(lang.NewSymbol("concat")) -if v451.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v451))) -} -v452 := v451.Get() -v453 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v454 := v453.FindInternedVar(lang.NewSymbol("list")) -if v454.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v454))) -} -v455 := v454.Get() -v456 := lang.Apply(v455, []any{lang.NewSymbol("quote")}) -v457 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v458 := v457.FindInternedVar(lang.NewSymbol("list")) -if v458.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v458))) -} -v459 := v458.Get() -v460 := lang.Apply(v459, []any{v60}) -v461 := lang.Apply(v452, []any{v456, v460}) -v462 := lang.Apply(v449, []any{v461}) -v463 := lang.Apply(v446, []any{v462}) -v464 := lang.Apply(v399, []any{v403, v439, v443, v463}) -v465 := lang.Apply(v396, []any{v464}) -v466 := lang.Apply(v393, []any{v465}) -v467 := lang.Apply(v386, []any{v390, v466}) -v468 := lang.Apply(v383, []any{v467}) -v469 := lang.Apply(v380, []any{v468}) -v470 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v471 := v470.FindInternedVar(lang.NewSymbol("list")) -if v471.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v471))) -} -v472 := v471.Get() -v473 := lang.Apply(v472, []any{nil}) -v474 := lang.Apply(v373, []any{v377, v469, v473}) -v475 := lang.Apply(v370, []any{v474}) -v476 := lang.Apply(v367, []any{v475}) -v477 := lang.Apply(v300, []any{v304, v360, v364, v476}) -v478 := lang.Apply(v297, []any{v477}) -v479 := lang.Apply(v294, []any{v478}) -v480 := lang.Apply(v116, []any{v120, v156, v157, v291, v479}) -v481 := lang.Apply(v113, []any{v480}) -return v481 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v8 := v7.Get() +if lang.IsTruthy(v8) { +v5 = closed2 +} else { +v5 = v4 } +var v4 any = v5 +_ = v4 +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("seq")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -// print-meta -{ -v0 := lang.NewSymbol("print-meta").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(70), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(70), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("meta")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("concat")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v3}) -var v5 any = v9 -_ = v5 -var v11 any -if lang.IsTruthy(v5) { -var v12 any = v5 -_ = v12 -var v14 any +v15 := v14.Get() v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("pos?")) +v17 := v16.FindInternedVar(lang.NewSymbol("list")) if v17.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } v18 := v17.Get() -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("count")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("list")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v12}) -v23 := lang.Apply(v18, []any{v22}) -var v15 any = v23 -_ = v15 -var v25 any -if lang.IsTruthy(v15) { +v22 := v21.Get() +v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("list")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("*print-dup*")) +v28 := v27.FindInternedVar(lang.NewSymbol("seq")) if v28.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } v29 := v28.Get() -var v26 any = v29 -_ = v26 -var v31 any -if lang.IsTruthy(v26) { -v31 = v26 -} else { +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("concat")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("*print-meta*")) +v34 := v33.FindInternedVar(lang.NewSymbol("list")) if v34.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) } v35 := v34.Get() -var v32 any = v35 -_ = v32 -var v37 any -if lang.IsTruthy(v32) { -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("*print-readably*")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +v36 := lang.Apply(v35, []any{v4}) +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("list")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -v40 := v39.Get() -v37 = v40 -} else { -v37 = v32 +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v2}) +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("list")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } -v31 = v37 +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v3}) +v45 := lang.Apply(v32, []any{v36, v40, v44}) +v46 := lang.Apply(v29, []any{v45}) +v47 := lang.Apply(v26, []any{v46}) +v48 := lang.Apply(v15, []any{v19, v23, v47}) +v49 := lang.Apply(v12, []any{v48}) +return v49 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v2 := args[0] +v3 := args[1] +v4 := lang.NewList(args[2:]...) +var v6 any +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v25 = v31 +v9 := v8.Get() +if lang.IsTruthy(v9) { +v6 = closed2 } else { -v25 = v15 -} -if lang.IsTruthy(v25) { -v15 := lang.Apply(lang1.WriteWriter, []any{v4, "^"}) -_ = v15 -var v16 any -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("=")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("count")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +v6 = v5 } -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v12}) -v25 := lang.Apply(v20, []any{v24, int64(1)}) -var v17 any = v25 -_ = v17 -var v27 any -if lang.IsTruthy(v17) { -v28 := lang.Apply(lang.NewKeyword("tag"), []any{v12}) -v27 = v28 -} else { -v27 = v17 +var v5 any = v6 +_ = v5 +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -if lang.IsTruthy(v27) { +v13 := v12.Get() +var v14 lang.FnFunc +v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v15 := args[0] +v16 := args[1] v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("pr-on")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) if v18.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } v19 := v18.Get() -v20 := lang.Apply(lang.NewKeyword("tag"), []any{v12}) -v21 := lang.Apply(v19, []any{v20, v4}) -v16 = v21 -} else { -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("pr-on")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v12, v4}) -v16 = v25 +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -_ = v16 -v26 := lang.Apply(lang1.WriteWriter, []any{v4, " "}) -v14 = v26 -} else { -v14 = nil +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v11 = v14 -} else { -v11 = nil +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -return v11 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -// peek -{ -v0 := lang.NewSymbol("peek").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "For a list or queue, same as first, for a vector, same as, but much\n more efficient than, last. If the collection is empty, returns nil.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1455), lang.NewKeyword("end-line"), int(1455))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, _ := lang.FieldOrMethod(runtime3.RT, "Peek") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Peek is not a function"))) +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) } -v5 := lang.Apply(v4, []any{v3}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v5}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v15}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) } -// merge-hash-collisions -{ -v0 := lang.NewSymbol("merge-hash-collisions").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr-sym"), lang.NewSymbol("default"), lang.NewSymbol("tests"), lang.NewSymbol("thens"))), lang.NewKeyword("doc"), "Takes a case expression, default expression, and a sequence of test constants\n and a corresponding sequence of then expressions. Returns a tuple of\n [tests thens skip-check-set] where no tests have the same hash. Each set of\n input test constants with the same hash is replaced with a single test\n constant (the case int), and their respective thens are combined into:\n (condp = expr\n test-1 then-1\n ...\n test-n then-n\n default).\n The skip-check is a set of case ints for which post-switch equivalence\n checking must not be done (the cases holding the above condp thens).", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6690), lang.NewKeyword("end-line"), int(6690), lang.NewKeyword("private"), true)).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v9 := lang.NewMap() -v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6704), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(6704), lang.NewKeyword("end-column"), int(27)) -v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v16}) +v52 := lang.Apply(v39, []any{v43, v47, v51}) +v53 := lang.Apply(v36, []any{v52}) +v54 := lang.Apply(v33, []any{v53}) +v55 := lang.Apply(v22, []any{v26, v30, v54}) +v56 := lang.Apply(v19, []any{v55}) +return v56 +}) +v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) +v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) if err != nil { panic(err) } -var v8 any = v11 -_ = v8 -var v12 any = v5 -_ = v12 -var v13 any = v6 -_ = v13 -var v14 any -for { -var v15 any -var v16 any = v12 -_ = v16 -var v18 any -if lang.IsTruthy(v16) { -v18 = v13 -} else { -v18 = v16 -} -if lang.IsTruthy(v18) { v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("update")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) if v18.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } v19 := v18.Get() v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("first")) +v21 := v20.FindInternedVar(lang.NewSymbol("concat")) if v21.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } v22 := v21.Get() -v23 := lang.Apply(v22, []any{v12}) -v24 := lang.Apply(lang1.Hash, []any{v23}) -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("fnil")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("conj")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v30 := v29.Get() -v31 := lang.NewVector() -v32 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6707), lang.NewKeyword("column"), int(102), lang.NewKeyword("end-line"), int(6707), lang.NewKeyword("end-column"), int(103)) -v33, err := lang.WithMeta(v31, v32.(lang.IPersistentMap)) -if err != nil { - panic(err) +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -v34 := lang.Apply(v27, []any{v30, v33}) -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("first")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v12}) -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("first")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -v41 := v40.Get() -v42 := lang.Apply(v41, []any{v13}) -v43 := lang.NewVector(v38, v42) -v44 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6707), lang.NewKeyword("column"), int(106), lang.NewKeyword("end-line"), int(6707), lang.NewKeyword("end-column"), int(128)) -v45, err := lang.WithMeta(v43, v44.(lang.IPersistentMap)) -if err != nil { - panic(err) +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) } -v46 := lang.Apply(v19, []any{v8, v24, v34, v45}) -var v16 any = v46 +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v5}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v2}) v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("next")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) if v49.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) } v50 := v49.Get() -v51 := lang.Apply(v50, []any{v12}) -var v47 any = v51 -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("next")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +v51 := lang.Apply(v50, []any{v3}) +v52 := lang.Apply(v39, []any{v43, v47, v51}) +v53 := lang.Apply(v36, []any{v52}) +v54 := lang.Apply(v33, []any{v53}) +v55 := lang.Apply(v22, []any{v26, v30, v54}) +v56 := lang.Apply(v19, []any{v55}) +v57 := lang.Apply(v13, []any{v16, v56, v4}) +return v57 + } +}) +v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } -v55 := v54.Get() -v56 := lang.Apply(v55, []any{v13}) -var v52 any = v56 -v8 = v16 -v12 = v47 -v13 = v52 -continue -} else { -v15 = v8 +v5 := lang.Apply(v4, []any{v3, int64(1)}) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v0 := lang.NewSymbol("+").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the sum of nums. (+) returns 0. Does not auto-promote\n longs, will throw on overflow. See also: +'", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(977), lang.NewKeyword("end-line"), int(977))).(*lang.Symbol) +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +return int64(0) + case 1: +v5 := args[0] +v6 := lang.Apply(lang1.MustAsNumber, []any{v5}) +return v6 + case 2: +v5 := args[0] +v6 := args[1] +v7, _ := lang.FieldOrMethod(lang1.Numbers, "add") +if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) } -v14 = v15 - break +v8 := lang.Apply(v7, []any{v5, v6}) +return v8 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +v6 := args[1] +v7 := lang.NewList(args[2:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -var v7 any = v14 -_ = v7 -var v9 lang.FnFunc -v9 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v10 := args[0] -v11 := args[1] -v12 := args[2] +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("+")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("mapcat")) +v15 := v14.FindInternedVar(lang.NewSymbol("+")) if v15.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } v16 := v15.Get() -var v17 lang.FnFunc -v17 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) +v17 := lang.Apply(v16, []any{v5, v6}) +v18 := lang.Apply(v10, []any{v13, v17, v7}) +return v18 } -v18 := args[0] +}) +v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v3 := ns.InternWithValue(v0, v4, true) +if v0.Meta() != nil { + v3.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// +' +{ +var v1 lang.FnFunc +v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v2 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +if lang.IsTruthy(v7) { +v4 = closed3 +} else { +v4 = v3 +} +var v3 any = v4 +_ = v3 +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("seq")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("concat")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v20 := v19.FindInternedVar(lang.NewSymbol("list")) if v20.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("first")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v18}) -v26 := lang.Apply(v21, []any{lang.NewSymbol("quote"), v25}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("second")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{v18}) -v31 := lang.NewVector(v26, v30) -v32 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6711), lang.NewKeyword("column"), int(56), lang.NewKeyword("end-line"), int(6711), lang.NewKeyword("end-column"), int(93)) -v33, err := lang.WithMeta(v31, v32.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v33 -}) -v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6711), lang.NewKeyword("column"), int(47), lang.NewKeyword("end-line"), int(6711), lang.NewKeyword("end-column"), int(94)) -v19, err := lang.WithMeta(v17, v18.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v20 := lang.Apply(v16, []any{v19, v12}) -var v13 any = v20 -_ = v13 -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("seq")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("concat")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("seq")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) } -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("list")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("concat")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) } -v30 := v29.Get() -v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/condp")}) +v31 := v30.Get() v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v33 := v32.FindInternedVar(lang.NewSymbol("list")) if v33.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) } v34 := v33.Get() -v35 := lang.Apply(v34, []any{lang.NewSymbol("glojure.core/=")}) +v35 := lang.Apply(v34, []any{v3}) v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v37 := v36.FindInternedVar(lang.NewSymbol("list")) if v37.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) } v38 := v37.Get() -v39 := lang.Apply(v38, []any{v3}) -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +v39 := lang.Apply(v38, []any{v2}) +v40 := lang.Apply(v31, []any{v35, v39}) +v41 := lang.Apply(v28, []any{v40}) +v42 := lang.Apply(v25, []any{v41}) +v43 := lang.Apply(v14, []any{v18, v22, v42}) +v44 := lang.Apply(v11, []any{v43}) +return v44 + case 2: +v2 := args[0] +v3 := args[1] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v4}) -v44 := lang.Apply(v27, []any{v31, v35, v39, v13, v43}) -v45 := lang.Apply(v24, []any{v44}) -var v21 any = v45 -_ = v21 -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("assoc")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +v8 := v7.Get() +if lang.IsTruthy(v8) { +v5 = closed3 +} else { +v5 = v4 } -v49 := v48.Get() -v50 := lang.Apply(v49, []any{v10, v11, v21}) -return v50 -}) -v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6710), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(6713), lang.NewKeyword("end-column"), int(42)) -v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) -if err != nil { - panic(err) +var v4 any = v5 +_ = v4 +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("seq")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -var v8 any = v11 -_ = v8 +v12 := v11.Get() v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("reduce1")) +v14 := v13.FindInternedVar(lang.NewSymbol("concat")) if v14.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } v15 := v14.Get() -var v16 lang.FnFunc -v16 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v17 := args[0] -v18 := args[1] -var v19 any = v18 -_ = v19 -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("nth")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v19, int64(0), nil}) -var v20 any = v24 -_ = v20 -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("nth")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.Apply(v28, []any{v19, int64(1), nil}) -var v25 any = v29 -_ = v25 -var v31 any -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("==")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("count")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v25}) -v39 := lang.Apply(v34, []any{int64(1), v38}) -if lang.IsTruthy(v39) { -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("assoc")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("ffirst")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.Apply(v45, []any{v25}) -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("second")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) -} -v49 := v48.Get() -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("first")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.Apply(v52, []any{v25}) -v54 := lang.Apply(v49, []any{v53}) -v55 := lang.Apply(v42, []any{v17, v46, v54}) -v31 = v55 -} else { -v56 := lang.Apply(v8, []any{v17, v20, v25}) -v31 = v56 -} -return v31 -}) -v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6715), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(6718), lang.NewKeyword("end-column"), int(45)) -v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) -if err != nil { - panic(err) +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("list")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -v19 := lang.NewMap() -v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6719), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(6719), lang.NewKeyword("end-column"), int(17)) -v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) -if err != nil { - panic(err) +v18 := v17.Get() +v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("list")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v22 := lang.Apply(v15, []any{v18, v21, v7}) -var v12 any = v22 -_ = v12 +v22 := v21.Get() +v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("into1")) +v25 := v24.FindInternedVar(lang.NewSymbol("list")) if v25.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } v26 := v25.Get() -v27 := lang.CreatePersistentTreeSet() -v28 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6723), lang.NewKeyword("column"), int(29), lang.NewKeyword("end-line"), int(6723), lang.NewKeyword("end-column"), int(31)) -v29, err := lang.WithMeta(v27, v28.(lang.IPersistentMap)) -if err != nil { - panic(err) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("seq")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } +v29 := v28.Get() v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("map")) +v31 := v30.FindInternedVar(lang.NewSymbol("concat")) if v31.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) } v32 := v31.Get() v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("first")) +v34 := v33.FindInternedVar(lang.NewSymbol("list")) if v34.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) } v35 := v34.Get() -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("filter")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +v36 := lang.Apply(v35, []any{v4}) +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("list")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -v38 := v37.Get() -var v39 lang.FnFunc -v39 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v40 := args[0] +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v2}) v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("<")) +v42 := v41.FindInternedVar(lang.NewSymbol("list")) if v42.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } v43 := v42.Get() -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("count")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("second")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +v44 := lang.Apply(v43, []any{v3}) +v45 := lang.Apply(v32, []any{v36, v40, v44}) +v46 := lang.Apply(v29, []any{v45}) +v47 := lang.Apply(v26, []any{v46}) +v48 := lang.Apply(v15, []any{v19, v23, v47}) +v49 := lang.Apply(v12, []any{v48}) +return v49 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v2 := args[0] +v3 := args[1] +v4 := lang.NewList(args[2:]...) +var v6 any +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v49 := v48.Get() -v50 := lang.Apply(v49, []any{v40}) -v51 := lang.Apply(v46, []any{v50}) -v52 := lang.Apply(v43, []any{int64(1), v51}) -return v52 -}) -v40 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6721), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(6721), lang.NewKeyword("end-column"), int(54)) -v41, err := lang.WithMeta(v39, v40.(lang.IPersistentMap)) -if err != nil { - panic(err) +v9 := v8.Get() +if lang.IsTruthy(v9) { +v6 = closed3 +} else { +v6 = v5 } -v42 := lang.Apply(v38, []any{v41, v7}) -v43 := lang.Apply(v32, []any{v35, v42}) -v44 := lang.Apply(v26, []any{v29, v43}) -var v23 any = v44 -_ = v23 -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("keys")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +var v5 any = v6 +_ = v5 +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v48 := v47.Get() -v49 := lang.Apply(v48, []any{v12}) -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("vals")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +v13 := v12.Get() +var v14 lang.FnFunc +v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v15 := args[0] +v16 := args[1] +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v52 := v51.Get() -v53 := lang.Apply(v52, []any{v12}) -v54 := lang.NewVector(v49, v53, v23) -v55 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6724), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(6724), lang.NewKeyword("end-column"), int(40)) -v56, err := lang.WithMeta(v54, v55.(lang.IPersistentMap)) -if err != nil { - panic(err) +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -return v56 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -// butlast -{ -v0 := lang.NewSymbol("butlast").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return a seq of all but the last item in coll, in linear time", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(272), lang.NewKeyword("end-line"), int(276))).(*lang.Symbol) -var v2 lang.FnFunc -{ // function butlast -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v6 := lang.NewVector() -v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(277), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(277), lang.NewKeyword("end-column"), int(24)) -v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v5}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v15}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v16}) +v52 := lang.Apply(v39, []any{v43, v47, v51}) +v53 := lang.Apply(v36, []any{v52}) +v54 := lang.Apply(v33, []any{v53}) +v55 := lang.Apply(v22, []any{v26, v30, v54}) +v56 := lang.Apply(v19, []any{v55}) +return v56 +}) +v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) +v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) if err != nil { panic(err) } -var v5 any = v8 -_ = v5 -var v9 any = v9 -_ = v9 -var v10 any -for { -var v11 any -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("next")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v9}) -if lang.IsTruthy(v15) { v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("conj")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) if v18.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } v19 := v18.Get() v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("first")) +v21 := v20.FindInternedVar(lang.NewSymbol("concat")) if v21.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } v22 := v21.Get() -v23 := lang.Apply(v22, []any{v9}) -v24 := lang.Apply(v19, []any{v5, v23}) -var v16 any = v24 -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("next")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v28 := v27.Get() -v29 := lang.Apply(v28, []any{v9}) -var v25 any = v29 -v5 = v16 -v9 = v25 -continue -} else { -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("seq")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v32 := v31.Get() -v33 := lang.Apply(v32, []any{v5}) -v11 = v33 +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -v10 = v11 - break +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } -return v10 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(276), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(280), lang.NewKeyword("end-column"), int(27))).(lang.FnFunc) -v3 := v2 -_ = v3 +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v5}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v2}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) } -// find -{ -v0 := lang.NewSymbol("find").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"))), lang.NewKeyword("doc"), "Returns the map entry for key, or nil if key not present.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1530), lang.NewKeyword("end-line"), int(1530))).(*lang.Symbol) +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v3}) +v52 := lang.Apply(v39, []any{v43, v47, v51}) +v53 := lang.Apply(v36, []any{v52}) +v54 := lang.Apply(v33, []any{v53}) +v55 := lang.Apply(v22, []any{v26, v30, v54}) +v56 := lang.Apply(v19, []any{v55}) +v57 := lang.Apply(v13, []any{v16, v56, v4}) +return v57 + } +}) +v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := args[1] -v5, _ := lang.FieldOrMethod(runtime3.RT, "Find") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Find is not a function"))) +v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } -v6 := lang.Apply(v5, []any{v3, v4}) -return v6 +v5 := lang.Apply(v4, []any{v3, int64(1)}) +return v5 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) +v0 := lang.NewSymbol("+'").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the sum of nums. (+') returns 0. Supports arbitrary precision.\n See also: +", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(965), lang.NewKeyword("end-line"), int(965))).(*lang.Symbol) +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +return int64(0) + case 1: +v5 := args[0] +v6 := lang.Apply(lang1.MustAsNumber, []any{v5}) +return v6 + case 2: +v5 := args[0] +v6 := args[1] +v7, _ := lang.FieldOrMethod(lang1.Numbers, "addP") +if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("addP is not a function"))) +} +v8 := lang.Apply(v7, []any{v5, v6}) +return v8 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +v6 := args[1] +v7 := lang.NewList(args[2:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("+'")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("+'")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v5, v6}) +v18 := lang.Apply(v10, []any{v13, v17, v7}) +return v18 + } +}) +v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v3 := ns.InternWithValue(v0, v4, true) if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + v3.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// = +// - { var v1 lang.FnFunc -{ // function =__inliner v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] + switch len(args) { + case 1: +v2 := args[0] +var v4 any v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) if v6.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("concat")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +if lang.IsTruthy(v7) { +v4 = closed4 +} else { +v4 = v3 } -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("list")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +var v3 any = v4 +_ = v3 +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("seq")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -v13 := v12.Get() -v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("concat")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v16 := v15.FindInternedVar(lang.NewSymbol("list")) if v16.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol("glojure.lang.Util")}) +v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v20 := v19.FindInternedVar(lang.NewSymbol("list")) if v20.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } v21 := v20.Get() -v22 := lang.Apply(v21, []any{lang.NewSymbol("glojure.core/equiv")}) +v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v24 := v23.FindInternedVar(lang.NewSymbol("list")) if v24.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } v25 := v24.Get() -v26 := lang.Apply(v25, []any{v3}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("seq")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) } -v29 := v28.Get() -v30 := lang.Apply(v29, []any{v4}) -v31 := lang.Apply(v10, []any{v14, v18, v22, v26, v30}) -v32 := lang.Apply(v7, []any{v31}) -return v32 -}) -v2 := v1 -_ = v2 +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("concat")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) } -v0 := lang.NewSymbol("=").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Equality. Returns true if x equals y, false if not. Same as\n Java x.equals(y) except it also works for nil, and compares\n numbers and collections in a type-independent manner. Clojure's immutable data\n structures define equals() (and thus =) as a value, not an identity,\n comparison.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(776), lang.NewKeyword("end-line"), int(776))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v4 := args[0] -return true +v31 := v30.Get() +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v2}) +v40 := lang.Apply(v31, []any{v35, v39}) +v41 := lang.Apply(v28, []any{v40}) +v42 := lang.Apply(v25, []any{v41}) +v43 := lang.Apply(v14, []any{v18, v22, v42}) +v44 := lang.Apply(v11, []any{v43}) +return v44 case 2: -v4 := args[0] -v5 := args[1] -v6 := lang.Apply(lang1.Equiv, []any{v4, v5}) -return v6 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6 := lang.NewList(args[2:]...) -recur_loop_126: -var v7 any -v8 := lang.Apply(lang1.Equiv, []any{v4, v5}) +v2 := args[0] +v3 := args[1] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() if lang.IsTruthy(v8) { -var v9 any +v5 = closed4 +} else { +v5 = v4 +} +var v4 any = v5 +_ = v4 v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("next")) +v11 := v10.FindInternedVar(lang.NewSymbol("seq")) if v11.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } v12 := v11.Get() -v13 := lang.Apply(v12, []any{v6}) -if lang.IsTruthy(v13) { -var v14 any = v5 +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("concat")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("first")) +v17 := v16.FindInternedVar(lang.NewSymbol("list")) if v17.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } v18 := v17.Get() -v19 := lang.Apply(v18, []any{v6}) -var v15 any = v19 -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("next")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("list")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v6}) -var v20 any = v24 -v4 = v14 -v5 = v15 -v6 = v20 -goto recur_loop_126 -} else { -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("first")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +v22 := v21.Get() +v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("list")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -v27 := v26.Get() -v28 := lang.Apply(v27, []any{v6}) -v29 := lang.Apply(lang1.Equiv, []any{v5, v28}) -v9 = v29 +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("seq")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v7 = v9 -} else { -v7 = false +v29 := v28.Get() +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("concat")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) } -return v7 - } -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("list")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) } +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v4}) +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("list")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -// rand-int -{ -v0 := lang.NewSymbol("rand-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns a random integer between 0 (inclusive) and n (exclusive).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4943), lang.NewKeyword("end-line"), int(4943))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("int")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v2}) +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("list")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } -v6 := v5.Get() +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v3}) +v45 := lang.Apply(v32, []any{v36, v40, v44}) +v46 := lang.Apply(v29, []any{v45}) +v47 := lang.Apply(v26, []any{v46}) +v48 := lang.Apply(v15, []any{v19, v23, v47}) +v49 := lang.Apply(v12, []any{v48}) +return v49 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v2 := args[0] +v3 := args[1] +v4 := lang.NewList(args[2:]...) +var v6 any v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("rand")) +v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) if v8.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } v9 := v8.Get() -v10 := lang.Apply(v9, []any{v3}) -v11 := lang.Apply(v6, []any{v10}) -return v11 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +if lang.IsTruthy(v9) { +v6 = closed4 +} else { +v6 = v5 } +var v5 any = v6 +_ = v5 +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -// fnext -{ -v0 := lang.NewSymbol("fnext").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Same as (first (next x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(112), lang.NewKeyword("end-line"), int(116))).(*lang.Symbol) -var v2 lang.FnFunc -{ // function fnext -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { +v13 := v12.Get() +var v14 lang.FnFunc +v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v4 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("first")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("next")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v4}) -v12 := lang.Apply(v7, []any{v11}) -return v12 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(116), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(116), lang.NewKeyword("end-column"), int(47))).(lang.FnFunc) -v3 := v2 -_ = v3 +v15 := args[0] +v16 := args[1] +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -// error-handler -{ -v0 := lang.NewSymbol("error-handler").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("doc"), "Returns the error-handler of agent a, or nil if there is none.\n See set-error-handler!", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2202), lang.NewKeyword("end-line"), int(2202))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, ok := lang.FieldOrMethod(v3, "getErrorHandler") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getErrorHandler"))) +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -var v5 any -switch reflect.TypeOf(v4).Kind() { -case reflect.Func: - v5 = lang.Apply(v4, nil) -default: - v5 = v4 +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -// zero? -{ -var v1 lang.FnFunc -{ // function zero?__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) } -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v5}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v15}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) } -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v16}) +v52 := lang.Apply(v39, []any{v43, v47, v51}) +v53 := lang.Apply(v36, []any{v52}) +v54 := lang.Apply(v33, []any{v53}) +v55 := lang.Apply(v22, []any{v26, v30, v54}) +v56 := lang.Apply(v19, []any{v55}) +return v56 +}) +v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) +v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v26 := v25.Get() +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v28 := v27.FindInternedVar(lang.NewSymbol("list")) if v28.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/isZero")}) +v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v32 := v31.FindInternedVar(lang.NewSymbol("list")) if v32.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } v33 := v32.Get() -v34 := lang.Apply(v33, []any{v3}) -v35 := lang.Apply(v26, []any{v30, v34}) -v36 := lang.Apply(v23, []any{v35}) -v37 := lang.Apply(v20, []any{v36}) -v38 := lang.Apply(v9, []any{v13, v17, v37}) -v39 := lang.Apply(v6, []any{v38}) -return v39 -}) -v2 := v1 -_ = v2 +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } -v0 := lang.NewSymbol("zero?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns true if num is zero, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(860), lang.NewKeyword("end-line"), int(860))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v5}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v2}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v3}) +v52 := lang.Apply(v39, []any{v43, v47, v51}) +v53 := lang.Apply(v36, []any{v52}) +v54 := lang.Apply(v33, []any{v53}) +v55 := lang.Apply(v22, []any{v26, v30, v54}) +v56 := lang.Apply(v19, []any{v55}) +v57 := lang.Apply(v13, []any{v16, v56, v4}) +return v57 + } +}) +v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "isZero") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("isZero is not a function"))) +v3 := args[0] +v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } -v6 := lang.Apply(v5, []any{v4}) -return v6 +v5 := lang.Apply(v4, []any{v3, int64(0)}) +return v5 }) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v0 := lang.NewSymbol("-").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "If no ys are supplied, returns the negation of x, else subtracts\n the ys from x and returns the result. Does not auto-promote\n longs, will throw on overflow. See also: -'", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1036), lang.NewKeyword("end-line"), int(1036))).(*lang.Symbol) +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v5 := args[0] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("*")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } +v8 := v7.Get() +v9 := lang.Apply(v8, []any{int64(-1), v5}) +return v9 + case 2: +v5 := args[0] +v6 := args[1] +v7, _ := lang.FieldOrMethod(lang1.Numbers, "minus") +if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("minus is not a function"))) } -// use -{ -v0 := lang.NewSymbol("use").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Like 'require, but also refers to each lib's namespace using\n glojure.core/refer. Use :use in the ns macro in preference to calling\n this directly.\n\n 'use accepts additional options in libspecs: :exclude, :only, :rename.\n The arguments and semantics for :exclude, :only, and :rename are the same\n as those documented for glojure.core/refer.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6122), lang.NewKeyword("end-line"), int(6122))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { +v8 := lang.Apply(v7, []any{v5, v6}) +return v8 default: - if len(args) < 0 { + if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := lang.NewList(args[0:]...) -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("apply")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v5 := args[0] +v6 := args[1] +v7 := lang.NewList(args[2:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("load-libs")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("-")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v9 := v8.Get() -v10 := lang.Apply(v6, []any{v9, lang.NewKeyword("require"), lang.NewKeyword("use"), v3}) -return v10 +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("-")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v5, v6}) +v18 := lang.Apply(v10, []any{v13, v17, v7}) +return v18 } }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) +v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v3 := ns.InternWithValue(v0, v4, true) if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + v3.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// amap +// -' { -v0 := lang.NewSymbol("amap").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("idx"), lang.NewSymbol("ret"), lang.NewSymbol("expr"))), lang.NewKeyword("doc"), "Maps an expression across an array a, using an index named idx, and\n return value named ret, initialized to a clone of a, then setting \n each element of ret to the evaluation of expr, returning the new \n array ret.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5273), lang.NewKeyword("end-line"), int(5273))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 6 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := args[4] -v8 := args[5] +var v1 lang.FnFunc +v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v2 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +if lang.IsTruthy(v7) { +v4 = closed5 +} else { +v4 = v3 +} +var v3 any = v4 +_ = v3 v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v10 := v9.FindInternedVar(lang.NewSymbol("seq")) if v10.IsMacro() { @@ -2803,465 +2618,528 @@ if v16.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol("glojure.core/let")}) +v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v20 := v19.FindInternedVar(lang.NewSymbol("list")) if v20.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("apply")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("vector")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("seq")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) } -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("seq")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("concat")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) } -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("concat")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v31 := v30.Get() +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) } -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("list")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) } -v36 := v35.Get() -v37 := lang.Apply(v36, []any{lang.NewSymbol("a__0__auto__")}) -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("list")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v2}) +v40 := lang.Apply(v31, []any{v35, v39}) +v41 := lang.Apply(v28, []any{v40}) +v42 := lang.Apply(v25, []any{v41}) +v43 := lang.Apply(v14, []any{v18, v22, v42}) +v44 := lang.Apply(v11, []any{v43}) +return v44 + case 2: +v2 := args[0] +v3 := args[1] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v40 := v39.Get() -v41 := lang.Apply(v40, []any{v5}) -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("list")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +v8 := v7.Get() +if lang.IsTruthy(v8) { +v5 = closed5 +} else { +v5 = v4 } -v44 := v43.Get() -v45 := lang.Apply(v44, []any{lang.NewSymbol("l__1__auto__")}) -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("list")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +var v4 any = v5 +_ = v4 +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("seq")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v48 := v47.Get() -v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v50 := v49.FindInternedVar(lang.NewSymbol("seq")) -if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("concat")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } -v51 := v50.Get() -v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("concat")) -if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) +v15 := v14.Get() +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("list")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -v54 := v53.Get() -v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v56 := v55.FindInternedVar(lang.NewSymbol("list")) -if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) +v18 := v17.Get() +v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("list")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v57 := v56.Get() -v58 := lang.Apply(v57, []any{lang.NewSymbol("glojure.core/alength")}) -v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v60 := v59.FindInternedVar(lang.NewSymbol("list")) -if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) +v22 := v21.Get() +v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("list")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -v61 := v60.Get() -v62 := lang.Apply(v61, []any{lang.NewSymbol("a__0__auto__")}) -v63 := lang.Apply(v54, []any{v58, v62}) -v64 := lang.Apply(v51, []any{v63}) -v65 := lang.Apply(v48, []any{v64}) -v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v67 := v66.FindInternedVar(lang.NewSymbol("list")) -if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("seq")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v68 := v67.Get() -v69 := lang.Apply(v68, []any{v7}) -v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v71 := v70.FindInternedVar(lang.NewSymbol("list")) -if v71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) +v29 := v28.Get() +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("concat")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) } -v72 := v71.Get() -v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v74 := v73.FindInternedVar(lang.NewSymbol("seq")) -if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("list")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) } -v75 := v74.Get() -v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v77 := v76.FindInternedVar(lang.NewSymbol("concat")) -if v77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v4}) +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("list")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -v78 := v77.Get() -v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v80 := v79.FindInternedVar(lang.NewSymbol("list")) -if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v2}) +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("list")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } -v81 := v80.Get() -v82 := lang.Apply(v81, []any{lang.NewSymbol("glojure.core/aclone")}) -v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v84 := v83.FindInternedVar(lang.NewSymbol("list")) -if v84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v3}) +v45 := lang.Apply(v32, []any{v36, v40, v44}) +v46 := lang.Apply(v29, []any{v45}) +v47 := lang.Apply(v26, []any{v46}) +v48 := lang.Apply(v15, []any{v19, v23, v47}) +v49 := lang.Apply(v12, []any{v48}) +return v49 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v2 := args[0] +v3 := args[1] +v4 := lang.NewList(args[2:]...) +var v6 any +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v85 := v84.Get() -v86 := lang.Apply(v85, []any{lang.NewSymbol("a__0__auto__")}) -v87 := lang.Apply(v78, []any{v82, v86}) -v88 := lang.Apply(v75, []any{v87}) -v89 := lang.Apply(v72, []any{v88}) -v90 := lang.Apply(v33, []any{v37, v41, v45, v65, v69, v89}) -v91 := lang.Apply(v30, []any{v90}) -v92 := lang.Apply(v24, []any{v27, v91}) -v93 := lang.Apply(v21, []any{v92}) -v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v95 := v94.FindInternedVar(lang.NewSymbol("list")) -if v95.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) +v9 := v8.Get() +if lang.IsTruthy(v9) { +v6 = closed5 +} else { +v6 = v5 } -v96 := v95.Get() -v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v98 := v97.FindInternedVar(lang.NewSymbol("seq")) -if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) +var v5 any = v6 +_ = v5 +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v99 := v98.Get() -v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v101 := v100.FindInternedVar(lang.NewSymbol("concat")) -if v101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) +v13 := v12.Get() +var v14 lang.FnFunc +v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v15 := args[0] +v16 := args[1] +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v102 := v101.Get() -v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v104 := v103.FindInternedVar(lang.NewSymbol("list")) -if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v105 := v104.Get() -v106 := lang.Apply(v105, []any{lang.NewSymbol("glojure.core/loop")}) -v107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v108 := v107.FindInternedVar(lang.NewSymbol("list")) -if v108.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v108))) +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v109 := v108.Get() -v110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v111 := v110.FindInternedVar(lang.NewSymbol("apply")) -if v111.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v111))) +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v112 := v111.Get() -v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v114 := v113.FindInternedVar(lang.NewSymbol("vector")) -if v114.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -v115 := v114.Get() -v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v117 := v116.FindInternedVar(lang.NewSymbol("seq")) -if v117.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } -v118 := v117.Get() -v119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v120 := v119.FindInternedVar(lang.NewSymbol("concat")) -if v120.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v120))) +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -v121 := v120.Get() -v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v123 := v122.FindInternedVar(lang.NewSymbol("list")) -if v123.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) } -v124 := v123.Get() -v125 := lang.Apply(v124, []any{v6}) -v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v127 := v126.FindInternedVar(lang.NewSymbol("list")) -if v127.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v5}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } -v128 := v127.Get() -v129 := lang.Apply(v128, []any{int64(0)}) -v130 := lang.Apply(v121, []any{v125, v129}) -v131 := lang.Apply(v118, []any{v130}) -v132 := lang.Apply(v112, []any{v115, v131}) -v133 := lang.Apply(v109, []any{v132}) -v134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v135 := v134.FindInternedVar(lang.NewSymbol("list")) -if v135.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v135))) +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v15}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) } -v136 := v135.Get() -v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v138 := v137.FindInternedVar(lang.NewSymbol("seq")) -if v138.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v16}) +v52 := lang.Apply(v39, []any{v43, v47, v51}) +v53 := lang.Apply(v36, []any{v52}) +v54 := lang.Apply(v33, []any{v53}) +v55 := lang.Apply(v22, []any{v26, v30, v54}) +v56 := lang.Apply(v19, []any{v55}) +return v56 +}) +v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) +v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v139 := v138.Get() -v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v141 := v140.FindInternedVar(lang.NewSymbol("concat")) -if v141.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v142 := v141.Get() -v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v144 := v143.FindInternedVar(lang.NewSymbol("list")) -if v144.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v145 := v144.Get() -v146 := lang.Apply(v145, []any{lang.NewSymbol("if")}) -v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v148 := v147.FindInternedVar(lang.NewSymbol("list")) -if v148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v149 := v148.Get() -v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v151 := v150.FindInternedVar(lang.NewSymbol("seq")) -if v151.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v152 := v151.Get() -v153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v154 := v153.FindInternedVar(lang.NewSymbol("concat")) -if v154.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v154))) +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -v155 := v154.Get() -v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v157 := v156.FindInternedVar(lang.NewSymbol("list")) -if v157.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } -v158 := v157.Get() -v159 := lang.Apply(v158, []any{lang.NewSymbol("glojure.core/<")}) -v160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v161 := v160.FindInternedVar(lang.NewSymbol("list")) -if v161.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v161))) +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -v162 := v161.Get() -v163 := lang.Apply(v162, []any{v6}) -v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v165 := v164.FindInternedVar(lang.NewSymbol("list")) -if v165.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) } -v166 := v165.Get() -v167 := lang.Apply(v166, []any{lang.NewSymbol("l__1__auto__")}) -v168 := lang.Apply(v155, []any{v159, v163, v167}) -v169 := lang.Apply(v152, []any{v168}) -v170 := lang.Apply(v149, []any{v169}) -v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v172 := v171.FindInternedVar(lang.NewSymbol("list")) -if v172.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v5}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } -v173 := v172.Get() -v174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v175 := v174.FindInternedVar(lang.NewSymbol("seq")) -if v175.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v175))) +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v2}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) } -v176 := v175.Get() -v177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v178 := v177.FindInternedVar(lang.NewSymbol("concat")) -if v178.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v178))) +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v3}) +v52 := lang.Apply(v39, []any{v43, v47, v51}) +v53 := lang.Apply(v36, []any{v52}) +v54 := lang.Apply(v33, []any{v53}) +v55 := lang.Apply(v22, []any{v26, v30, v54}) +v56 := lang.Apply(v19, []any{v55}) +v57 := lang.Apply(v13, []any{v16, v56, v4}) +return v57 + } +}) +v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } -v179 := v178.Get() -v180 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v181 := v180.FindInternedVar(lang.NewSymbol("list")) -if v181.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v181))) +v5 := lang.Apply(v4, []any{v3, int64(0)}) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v0 := lang.NewSymbol("-'").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "If no ys are supplied, returns the negation of x, else subtracts\n the ys from x and returns the result. Supports arbitrary precision.\n See also: -", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1024), lang.NewKeyword("end-line"), int(1024))).(*lang.Symbol) +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v5 := args[0] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("*'")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v182 := v181.Get() -v183 := lang.Apply(v182, []any{lang.NewSymbol("do")}) -v184 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v185 := v184.FindInternedVar(lang.NewSymbol("list")) -if v185.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v185))) +v8 := v7.Get() +v9 := lang.Apply(v8, []any{int64(-1), v5}) +return v9 + case 2: +v5 := args[0] +v6 := args[1] +v7, _ := lang.FieldOrMethod(lang1.Numbers, "minusP") +if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("minusP is not a function"))) } -v186 := v185.Get() -v187 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v188 := v187.FindInternedVar(lang.NewSymbol("seq")) -if v188.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v188))) +v8 := lang.Apply(v7, []any{v5, v6}) +return v8 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +v6 := args[1] +v7 := lang.NewList(args[2:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v189 := v188.Get() -v190 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v191 := v190.FindInternedVar(lang.NewSymbol("concat")) -if v191.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v191))) +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("-'")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v192 := v191.Get() -v193 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v194 := v193.FindInternedVar(lang.NewSymbol("list")) -if v194.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v194))) +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("-'")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v195 := v194.Get() -v196 := lang.Apply(v195, []any{lang.NewSymbol("glojure.core/aset")}) -v197 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v198 := v197.FindInternedVar(lang.NewSymbol("list")) -if v198.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v198))) +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v5, v6}) +v18 := lang.Apply(v10, []any{v13, v17, v7}) +return v18 + } +}) +v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v3 := ns.InternWithValue(v0, v4, true) +if v0.Meta() != nil { + v3.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v199 := v198.Get() -v200 := lang.Apply(v199, []any{v7}) -v201 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v202 := v201.FindInternedVar(lang.NewSymbol("list")) -if v202.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v202))) } -v203 := v202.Get() -v204 := lang.Apply(v203, []any{v6}) -v205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v206 := v205.FindInternedVar(lang.NewSymbol("list")) -if v206.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v206))) +// -> +{ +v0 := lang.NewSymbol("->").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "Threads the expr through the forms. Inserts x as the\n second item in the first form, making a list of it if it is not a\n list already. If there are more forms, inserts the first form as the\n second item in second form, etc.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1675), lang.NewKeyword("end-line"), int(1675))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +var v7 any = v7 +_ = v7 +var v8 any = v8 +_ = v8 +var v9 any +for { +var v10 any +if lang.IsTruthy(v8) { +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("first")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } -v207 := v206.Get() -v208 := lang.Apply(v207, []any{v8}) -v209 := lang.Apply(v192, []any{v196, v200, v204, v208}) -v210 := lang.Apply(v189, []any{v209}) -v211 := lang.Apply(v186, []any{v210}) -v212 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v213 := v212.FindInternedVar(lang.NewSymbol("list")) -if v213.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v213))) +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v8}) +var v11 any = v15 +_ = v11 +var v17 any +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("seq?")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v214 := v213.Get() -v215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v216 := v215.FindInternedVar(lang.NewSymbol("seq")) -if v216.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v216))) +v20 := v19.Get() +v21 := lang.Apply(v20, []any{v11}) +if lang.IsTruthy(v21) { +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("with-meta")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -v217 := v216.Get() -v218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v219 := v218.FindInternedVar(lang.NewSymbol("concat")) -if v219.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v219))) +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("seq")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -v220 := v219.Get() -v221 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v222 := v221.FindInternedVar(lang.NewSymbol("list")) -if v222.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v222))) +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("concat")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } -v223 := v222.Get() -v224 := lang.Apply(v223, []any{lang.NewSymbol("recur")}) -v225 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v226 := v225.FindInternedVar(lang.NewSymbol("list")) -if v226.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v226))) +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -v227 := v226.Get() -v228 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v229 := v228.FindInternedVar(lang.NewSymbol("seq")) -if v229.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v229))) +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("first")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } -v230 := v229.Get() -v231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v232 := v231.FindInternedVar(lang.NewSymbol("concat")) -if v232.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v232))) +v36 := v35.Get() +v37 := lang.Apply(v36, []any{v11}) +v38 := lang.Apply(v33, []any{v37}) +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("list")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) } -v233 := v232.Get() -v234 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v235 := v234.FindInternedVar(lang.NewSymbol("list")) -if v235.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v235))) +v41 := v40.Get() +v42 := lang.Apply(v41, []any{v7}) +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("next")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) } -v236 := v235.Get() -v237 := lang.Apply(v236, []any{lang.NewSymbol("glojure.core/unchecked-inc")}) -v238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v239 := v238.FindInternedVar(lang.NewSymbol("list")) -if v239.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v239))) +v45 := v44.Get() +v46 := lang.Apply(v45, []any{v11}) +v47 := lang.Apply(v30, []any{v38, v42, v46}) +v48 := lang.Apply(v27, []any{v47}) +v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v50 := v49.FindInternedVar(lang.NewSymbol("meta")) +if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) } -v240 := v239.Get() -v241 := lang.Apply(v240, []any{v6}) -v242 := lang.Apply(v233, []any{v237, v241}) -v243 := lang.Apply(v230, []any{v242}) -v244 := lang.Apply(v227, []any{v243}) -v245 := lang.Apply(v220, []any{v224, v244}) -v246 := lang.Apply(v217, []any{v245}) -v247 := lang.Apply(v214, []any{v246}) -v248 := lang.Apply(v179, []any{v183, v211, v247}) -v249 := lang.Apply(v176, []any{v248}) -v250 := lang.Apply(v173, []any{v249}) -v251 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v252 := v251.FindInternedVar(lang.NewSymbol("list")) -if v252.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v252))) +v51 := v50.Get() +v52 := lang.Apply(v51, []any{v11}) +v53 := lang.Apply(v24, []any{v48, v52}) +v17 = v53 +} else { +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("list")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) } -v253 := v252.Get() -v254 := lang.Apply(v253, []any{v7}) -v255 := lang.Apply(v142, []any{v146, v170, v250, v254}) -v256 := lang.Apply(v139, []any{v255}) -v257 := lang.Apply(v136, []any{v256}) -v258 := lang.Apply(v102, []any{v106, v133, v257}) -v259 := lang.Apply(v99, []any{v258}) -v260 := lang.Apply(v96, []any{v259}) -v261 := lang.Apply(v14, []any{v18, v93, v260}) -v262 := lang.Apply(v11, []any{v261}) -return v262 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v56 := v55.Get() +v57 := lang.Apply(v56, []any{v11, v7}) +v17 = v57 } +var v16 any = v17 +_ = v16 +var v59 any = v16 +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("next")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) } -// ns-unalias -{ -v0 := lang.NewSymbol("ns-unalias").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Removes the alias for the symbol from the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4280), lang.NewKeyword("end-line"), int(4280))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("the-ns")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v63 := v62.Get() +v64 := lang.Apply(v63, []any{v8}) +var v60 any = v64 +v7 = v59 +v8 = v60 +continue +} else { +v10 = v7 } -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -v9, _ := lang.FieldOrMethod(v8, "removeAlias") -if reflect.TypeOf(v9).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("removeAlias is not a function"))) +v9 = v10 + break } -v10 := lang.Apply(v9, []any{v4}) -return v10 +return v9 + } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -3269,1701 +3147,1607 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// def-aset +// ->> { -v0 := lang.NewSymbol("def-aset").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("method"), lang.NewSymbol("coerce"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3935), lang.NewKeyword("end-line"), int(3936), lang.NewKeyword("private"), true)).(*lang.Symbol) +v0 := lang.NewSymbol("->>").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "Threads the expr through the forms. Inserts x as the\n last item in the first form, making a list of it if it is not a\n list already. If there are more forms, inserts the first form as the\n last item in second form, etc.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1691), lang.NewKeyword("end-line"), int(1691))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 5 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] v4 := args[1] v5 := args[2] -v6 := args[3] -v7 := args[4] -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("seq")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("concat")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v6 := lang.NewList(args[3:]...) +var v7 any = v7 +_ = v7 +var v8 any = v8 +_ = v8 +var v9 any +for { +var v10 any +if lang.IsTruthy(v8) { +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("first")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("glojure.core/defn")}) +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v8}) +var v11 any = v15 +_ = v11 +var v17 any v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) +v19 := v18.FindInternedVar(lang.NewSymbol("seq?")) if v19.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } v20 := v19.Get() -v21 := lang.Apply(v20, []any{v5}) +v21 := lang.Apply(v20, []any{v11}) +if lang.IsTruthy(v21) { v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("list")) +v23 := v22.FindInternedVar(lang.NewSymbol("with-meta")) if v23.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } v24 := v23.Get() v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("apply")) +v26 := v25.FindInternedVar(lang.NewSymbol("seq")) if v26.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } v27 := v26.Get() v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("hash-map")) +v29 := v28.FindInternedVar(lang.NewSymbol("concat")) if v29.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } v30 := v29.Get() v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("seq")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) if v32.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } v33 := v32.Get() v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("concat")) +v35 := v34.FindInternedVar(lang.NewSymbol("first")) if v35.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("list")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.Apply(v39, []any{lang.NewKeyword("arglists")}) -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("list")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("seq")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +v37 := lang.Apply(v36, []any{v11}) +v38 := lang.Apply(v33, []any{v37}) +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("next")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) } -v46 := v45.Get() -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("concat")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +v41 := v40.Get() +v42 := lang.Apply(v41, []any{v11}) +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("list")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) } -v49 := v48.Get() -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("list")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +v45 := v44.Get() +v46 := lang.Apply(v45, []any{v7}) +v47 := lang.Apply(v30, []any{v38, v42, v46}) +v48 := lang.Apply(v27, []any{v47}) +v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v50 := v49.FindInternedVar(lang.NewSymbol("meta")) +if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) } -v52 := v51.Get() -v53 := lang.Apply(v52, []any{lang.NewSymbol("quote")}) +v51 := v50.Get() +v52 := lang.Apply(v51, []any{v11}) +v53 := lang.Apply(v24, []any{v48, v52}) +v17 = v53 +} else { v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v55 := v54.FindInternedVar(lang.NewSymbol("list")) if v55.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) } v56 := v55.Get() -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("seq")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) -} -v59 := v58.Get() -v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v61 := v60.FindInternedVar(lang.NewSymbol("concat")) -if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) -} -v62 := v61.Get() -v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v64 := v63.FindInternedVar(lang.NewSymbol("list")) -if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) -} -v65 := v64.Get() -v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v67 := v66.FindInternedVar(lang.NewSymbol("apply")) -if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) +v57 := lang.Apply(v56, []any{v11, v7}) +v17 = v57 } -v68 := v67.Get() -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("vector")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +var v16 any = v17 +_ = v16 +var v59 any = v16 +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("next")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) } -v71 := v70.Get() -v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v73 := v72.FindInternedVar(lang.NewSymbol("seq")) -if v73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) +v63 := v62.Get() +v64 := lang.Apply(v63, []any{v8}) +var v60 any = v64 +v7 = v59 +v8 = v60 +continue +} else { +v10 = v7 } -v74 := v73.Get() -v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v76 := v75.FindInternedVar(lang.NewSymbol("concat")) -if v76.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) +v9 = v10 + break } -v77 := v76.Get() -v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v79 := v78.FindInternedVar(lang.NewSymbol("list")) -if v79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) +return v9 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v80 := v79.Get() -v81 := lang.Apply(v80, []any{lang.NewSymbol("array")}) -v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v83 := v82.FindInternedVar(lang.NewSymbol("list")) -if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) } -v84 := v83.Get() -v85 := lang.Apply(v84, []any{lang.NewSymbol("idx")}) -v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v87 := v86.FindInternedVar(lang.NewSymbol("list")) -if v87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) +// -protocols +{ +v0 := lang.NewSymbol("-protocols").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("doc"), "Private store of protocols. Go's reflection capabilities\n don't yet support a native interface-based implementation, so\n protocols are implemented in Glojure as maps from type to protocol\n method implementations.", lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(21), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(26), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v3 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("coll-reduce"), nil), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("coll-reduce"), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("f"), lang.NewSymbol("val")))))) +v4 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("internal-reduce"), nil), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("internal-reduce"), lang.NewVector(lang.NewSymbol("seq"), lang.NewSymbol("f"), lang.NewSymbol("start")))))) +v5 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("kv-reduce"), nil), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("kv-reduce"), lang.NewVector(lang.NewSymbol("amap"), lang.NewSymbol("f"), lang.NewSymbol("init")))))) +v6 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("datafy"), nil), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("datafy"), lang.NewVector(lang.NewSymbol("o")), "return a representation of o as data (default identity)")))) +v7 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("nav"), nil), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("nav"), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("k"), lang.NewSymbol("v")), "return (possibly transformed) v in the context of coll and k (a key/index or nil),\ndefaults to returning v.")))) +v8 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("make-reader"), nil, lang.NewKeyword("make-writer"), nil, lang.NewKeyword("make-input-stream"), nil, lang.NewKeyword("make-output-stream"), nil), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("make-reader"), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("opts")), "Creates an io.Reader. See also IOFactory docs."), lang.NewList(lang.NewSymbol("make-writer"), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("opts")), "Creates an io.Reader. See also IOFactory docs."), lang.NewList(lang.NewSymbol("make-input-stream"), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("opts")), "Creates a BufferedInputStream. See also IOFactory docs."), lang.NewList(lang.NewSymbol("make-output-stream"), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("opts")), "Creates a BufferedOutputStream. See also IOFactory docs.")))) +v2 := lang.NewAtom(lang.NewMap(lang.NewSymbol("CollReduce"), v3, lang.NewSymbol("InternalReduce"), v4, lang.NewSymbol("IKVReduce"), v5, lang.NewSymbol("Datafiable"), v6, lang.NewSymbol("Navigable"), v7, lang.NewSymbol("IOFactory"), v8)) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v88 := v87.Get() -v89 := lang.Apply(v88, []any{lang.NewSymbol("val")}) -v90 := lang.Apply(v77, []any{v81, v85, v89}) -v91 := lang.Apply(v74, []any{v90}) -v92 := lang.Apply(v68, []any{v71, v91}) -v93 := lang.Apply(v65, []any{v92}) -v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v95 := v94.FindInternedVar(lang.NewSymbol("list")) -if v95.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) } -v96 := v95.Get() -v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v98 := v97.FindInternedVar(lang.NewSymbol("apply")) -if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) +// .. +{ +v0 := lang.NewSymbol("..").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("form")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("form"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "form => fieldName-symbol or (instanceMethodName-symbol args*)\n\n Expands into a member access (.) of the first member on the first\n argument, followed by the next member on the result, etc. For\n instance:\n\n (.. System (getProperties) (get \"os.name\"))\n\n expands to:\n\n (. (. System (getProperties)) (get \"os.name\"))\n\n but is easier to write, read, and understand.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1657), lang.NewKeyword("end-line"), int(1657))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 4: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("seq")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v99 := v98.Get() -v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v101 := v100.FindInternedVar(lang.NewSymbol("vector")) -if v101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("concat")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v102 := v101.Get() -v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v104 := v103.FindInternedVar(lang.NewSymbol("seq")) -if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("list")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } -v105 := v104.Get() -v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v107 := v106.FindInternedVar(lang.NewSymbol("concat")) -if v107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) +v15 := v14.Get() +v16 := lang.Apply(v15, []any{lang.NewSymbol(".")}) +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("list")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v108 := v107.Get() -v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v110 := v109.FindInternedVar(lang.NewSymbol("list")) -if v110.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v5}) +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("list")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v111 := v110.Get() -v112 := lang.Apply(v111, []any{lang.NewSymbol("array")}) -v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v114 := v113.FindInternedVar(lang.NewSymbol("list")) -if v114.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) -} -v115 := v114.Get() -v116 := lang.Apply(v115, []any{lang.NewSymbol("idx")}) -v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v118 := v117.FindInternedVar(lang.NewSymbol("list")) -if v118.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v6}) +v25 := lang.Apply(v12, []any{v16, v20, v24}) +v26 := lang.Apply(v9, []any{v25}) +return v26 + default: + if len(args) < 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := lang.NewList(args[4:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("seq")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v119 := v118.Get() -v120 := lang.Apply(v119, []any{lang.NewSymbol("idx2")}) -v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v122 := v121.FindInternedVar(lang.NewSymbol("list")) -if v122.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("concat")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v123 := v122.Get() -v124 := lang.Apply(v123, []any{lang.NewSymbol("&")}) -v125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v126 := v125.FindInternedVar(lang.NewSymbol("list")) -if v126.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v126))) +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v127 := v126.Get() -v128 := lang.Apply(v127, []any{lang.NewSymbol("idxv")}) -v129 := lang.Apply(v108, []any{v112, v116, v120, v124, v128}) -v130 := lang.Apply(v105, []any{v129}) -v131 := lang.Apply(v99, []any{v102, v130}) -v132 := lang.Apply(v96, []any{v131}) -v133 := lang.Apply(v62, []any{v93, v132}) -v134 := lang.Apply(v59, []any{v133}) -v135 := lang.Apply(v56, []any{v134}) -v136 := lang.Apply(v49, []any{v53, v135}) -v137 := lang.Apply(v46, []any{v136}) -v138 := lang.Apply(v43, []any{v137}) -v139 := lang.Apply(v36, []any{v40, v138}) -v140 := lang.Apply(v33, []any{v139}) -v141 := lang.Apply(v27, []any{v30, v140}) -v142 := lang.Apply(v24, []any{v141}) -v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v144 := v143.FindInternedVar(lang.NewSymbol("list")) -if v144.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("..")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v145 := v144.Get() -v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v147 := v146.FindInternedVar(lang.NewSymbol("seq")) -if v147.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v148 := v147.Get() -v149 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v150 := v149.FindInternedVar(lang.NewSymbol("concat")) -if v150.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v150))) +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -v151 := v150.Get() -v152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v153 := v152.FindInternedVar(lang.NewSymbol("list")) -if v153.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v153))) +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v154 := v153.Get() -v155 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v156 := v155.FindInternedVar(lang.NewSymbol("apply")) -if v156.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v156))) +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol(".")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -v157 := v156.Get() -v158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v159 := v158.FindInternedVar(lang.NewSymbol("vector")) -if v159.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v159))) +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v5}) +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("list")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) } -v160 := v159.Get() -v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v162 := v161.FindInternedVar(lang.NewSymbol("seq")) -if v162.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) +v37 := v36.Get() +v38 := lang.Apply(v37, []any{v6}) +v39 := lang.Apply(v26, []any{v30, v34, v38}) +v40 := lang.Apply(v23, []any{v39}) +v41 := lang.Apply(v20, []any{v40}) +v42 := lang.Apply(v13, []any{v17, v41, v7}) +v43 := lang.Apply(v10, []any{v42}) +return v43 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v163 := v162.Get() -v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v165 := v164.FindInternedVar(lang.NewSymbol("concat")) -if v165.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) } -v166 := v165.Get() -v167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v168 := v167.FindInternedVar(lang.NewSymbol("list")) -if v168.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v168))) +// / +{ +var v1 lang.FnFunc +v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v2 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v169 := v168.Get() -v170 := lang.Apply(v169, []any{lang.NewSymbol("array__0__auto__")}) -v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v172 := v171.FindInternedVar(lang.NewSymbol("list")) -if v172.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) +v7 := v6.Get() +if lang.IsTruthy(v7) { +v4 = closed6 +} else { +v4 = v3 } -v173 := v172.Get() -v174 := lang.Apply(v173, []any{lang.NewSymbol("idx__1__auto__")}) -v175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v176 := v175.FindInternedVar(lang.NewSymbol("list")) -if v176.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v176))) +var v3 any = v4 +_ = v3 +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("seq")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -v177 := v176.Get() -v178 := lang.Apply(v177, []any{lang.NewSymbol("val__2__auto__")}) -v179 := lang.Apply(v166, []any{v170, v174, v178}) -v180 := lang.Apply(v163, []any{v179}) -v181 := lang.Apply(v157, []any{v160, v180}) -v182 := lang.Apply(v154, []any{v181}) -v183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v184 := v183.FindInternedVar(lang.NewSymbol("list")) -if v184.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v184))) +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("concat")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } -v185 := v184.Get() -v186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v187 := v186.FindInternedVar(lang.NewSymbol("seq")) -if v187.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v187))) +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } -v188 := v187.Get() -v189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v190 := v189.FindInternedVar(lang.NewSymbol("concat")) -if v190.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v190))) +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v191 := v190.Get() -v192 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v193 := v192.FindInternedVar(lang.NewSymbol("list")) -if v193.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v193))) +v21 := v20.Get() +v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v194 := v193.Get() -v195 := lang.Apply(v194, []any{lang.NewSymbol(".")}) -v196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v197 := v196.FindInternedVar(lang.NewSymbol("list")) -if v197.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v197))) +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("seq")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) } -v198 := v197.Get() -v199 := lang.Apply(v198, []any{lang.NewSymbol("glojure.core/Array")}) -v200 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v201 := v200.FindInternedVar(lang.NewSymbol("list")) -if v201.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v201))) +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("concat")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) } -v202 := v201.Get() -v203 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v204 := v203.FindInternedVar(lang.NewSymbol("seq")) -if v204.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v204))) +v31 := v30.Get() +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) } -v205 := v204.Get() -v206 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v207 := v206.FindInternedVar(lang.NewSymbol("concat")) -if v207.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v207))) +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) } -v208 := v207.Get() -v209 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v210 := v209.FindInternedVar(lang.NewSymbol("list")) -if v210.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v210))) +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v2}) +v40 := lang.Apply(v31, []any{v35, v39}) +v41 := lang.Apply(v28, []any{v40}) +v42 := lang.Apply(v25, []any{v41}) +v43 := lang.Apply(v14, []any{v18, v22, v42}) +v44 := lang.Apply(v11, []any{v43}) +return v44 + case 2: +v2 := args[0] +v3 := args[1] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v211 := v210.Get() -v212 := lang.Apply(v211, []any{v6}) -v213 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v214 := v213.FindInternedVar(lang.NewSymbol("list")) -if v214.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v214))) +v8 := v7.Get() +if lang.IsTruthy(v8) { +v5 = closed6 +} else { +v5 = v4 } -v215 := v214.Get() -v216 := lang.Apply(v215, []any{lang.NewSymbol("array__0__auto__")}) -v217 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v218 := v217.FindInternedVar(lang.NewSymbol("list")) -if v218.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v218))) +var v4 any = v5 +_ = v4 +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("seq")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v219 := v218.Get() -v220 := lang.Apply(v219, []any{lang.NewSymbol("idx__1__auto__")}) -v221 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v222 := v221.FindInternedVar(lang.NewSymbol("list")) -if v222.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v222))) +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("concat")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } -v223 := v222.Get() -v224 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v225 := v224.FindInternedVar(lang.NewSymbol("seq")) -if v225.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v225))) +v15 := v14.Get() +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("list")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -v226 := v225.Get() -v227 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v228 := v227.FindInternedVar(lang.NewSymbol("concat")) -if v228.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v228))) +v18 := v17.Get() +v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("list")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v229 := v228.Get() -v230 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v231 := v230.FindInternedVar(lang.NewSymbol("list")) -if v231.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v231))) +v22 := v21.Get() +v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("list")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -v232 := v231.Get() -v233 := lang.Apply(v232, []any{v7}) -v234 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v235 := v234.FindInternedVar(lang.NewSymbol("list")) -if v235.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v235))) +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("seq")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v236 := v235.Get() -v237 := lang.Apply(v236, []any{lang.NewSymbol("val__2__auto__")}) -v238 := lang.Apply(v229, []any{v233, v237}) -v239 := lang.Apply(v226, []any{v238}) -v240 := lang.Apply(v223, []any{v239}) -v241 := lang.Apply(v208, []any{v212, v216, v220, v240}) -v242 := lang.Apply(v205, []any{v241}) -v243 := lang.Apply(v202, []any{v242}) -v244 := lang.Apply(v191, []any{v195, v199, v243}) -v245 := lang.Apply(v188, []any{v244}) -v246 := lang.Apply(v185, []any{v245}) -v247 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v248 := v247.FindInternedVar(lang.NewSymbol("list")) -if v248.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v248))) +v29 := v28.Get() +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("concat")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) } -v249 := v248.Get() -v250 := lang.Apply(v249, []any{lang.NewSymbol("val__2__auto__")}) -v251 := lang.Apply(v151, []any{v182, v246, v250}) -v252 := lang.Apply(v148, []any{v251}) -v253 := lang.Apply(v145, []any{v252}) -v254 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v255 := v254.FindInternedVar(lang.NewSymbol("list")) -if v255.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v255))) +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("list")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) } -v256 := v255.Get() -v257 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v258 := v257.FindInternedVar(lang.NewSymbol("seq")) -if v258.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v258))) +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v4}) +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("list")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -v259 := v258.Get() -v260 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v261 := v260.FindInternedVar(lang.NewSymbol("concat")) -if v261.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v261))) +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v2}) +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("list")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } -v262 := v261.Get() -v263 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v264 := v263.FindInternedVar(lang.NewSymbol("list")) -if v264.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v264))) +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v3}) +v45 := lang.Apply(v32, []any{v36, v40, v44}) +v46 := lang.Apply(v29, []any{v45}) +v47 := lang.Apply(v26, []any{v46}) +v48 := lang.Apply(v15, []any{v19, v23, v47}) +v49 := lang.Apply(v12, []any{v48}) +return v49 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v2 := args[0] +v3 := args[1] +v4 := lang.NewList(args[2:]...) +var v6 any +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v265 := v264.Get() -v266 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v267 := v266.FindInternedVar(lang.NewSymbol("apply")) -if v267.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v267))) +v9 := v8.Get() +if lang.IsTruthy(v9) { +v6 = closed6 +} else { +v6 = v5 } -v268 := v267.Get() -v269 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v270 := v269.FindInternedVar(lang.NewSymbol("vector")) -if v270.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v270))) +var v5 any = v6 +_ = v5 +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v271 := v270.Get() -v272 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v273 := v272.FindInternedVar(lang.NewSymbol("seq")) -if v273.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v273))) +v13 := v12.Get() +var v14 lang.FnFunc +v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v15 := args[0] +v16 := args[1] +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v274 := v273.Get() -v275 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v276 := v275.FindInternedVar(lang.NewSymbol("concat")) -if v276.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v276))) +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v277 := v276.Get() -v278 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v279 := v278.FindInternedVar(lang.NewSymbol("list")) -if v279.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v279))) -} -v280 := v279.Get() -v281 := lang.Apply(v280, []any{lang.NewSymbol("array__0__auto__")}) -v282 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v283 := v282.FindInternedVar(lang.NewSymbol("list")) -if v283.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v283))) +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v284 := v283.Get() -v285 := lang.Apply(v284, []any{lang.NewSymbol("idx__1__auto__")}) -v286 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v287 := v286.FindInternedVar(lang.NewSymbol("list")) -if v287.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v287))) +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v288 := v287.Get() -v289 := lang.Apply(v288, []any{lang.NewSymbol("idx2__3__auto__")}) -v290 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v291 := v290.FindInternedVar(lang.NewSymbol("list")) -if v291.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v291))) +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -v292 := v291.Get() -v293 := lang.Apply(v292, []any{lang.NewSymbol("&")}) -v294 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v295 := v294.FindInternedVar(lang.NewSymbol("list")) -if v295.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v295))) +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } -v296 := v295.Get() -v297 := lang.Apply(v296, []any{lang.NewSymbol("idxv__4__auto__")}) -v298 := lang.Apply(v277, []any{v281, v285, v289, v293, v297}) -v299 := lang.Apply(v274, []any{v298}) -v300 := lang.Apply(v268, []any{v271, v299}) -v301 := lang.Apply(v265, []any{v300}) -v302 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v303 := v302.FindInternedVar(lang.NewSymbol("list")) -if v303.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v303))) +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -v304 := v303.Get() -v305 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v306 := v305.FindInternedVar(lang.NewSymbol("seq")) -if v306.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v306))) +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) } -v307 := v306.Get() -v308 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v309 := v308.FindInternedVar(lang.NewSymbol("concat")) -if v309.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v309))) +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v5}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } -v310 := v309.Get() -v311 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v312 := v311.FindInternedVar(lang.NewSymbol("list")) -if v312.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v312))) +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v15}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) } -v313 := v312.Get() -v314 := lang.Apply(v313, []any{lang.NewSymbol("glojure.core/apply")}) -v315 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v316 := v315.FindInternedVar(lang.NewSymbol("list")) -if v316.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v316))) +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v16}) +v52 := lang.Apply(v39, []any{v43, v47, v51}) +v53 := lang.Apply(v36, []any{v52}) +v54 := lang.Apply(v33, []any{v53}) +v55 := lang.Apply(v22, []any{v26, v30, v54}) +v56 := lang.Apply(v19, []any{v55}) +return v56 +}) +v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) +v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v317 := v316.Get() -v318 := lang.Apply(v317, []any{v5}) -v319 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v320 := v319.FindInternedVar(lang.NewSymbol("list")) -if v320.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v320))) +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v321 := v320.Get() -v322 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v323 := v322.FindInternedVar(lang.NewSymbol("seq")) -if v323.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v323))) +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v324 := v323.Get() -v325 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v326 := v325.FindInternedVar(lang.NewSymbol("concat")) -if v326.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v326))) +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v327 := v326.Get() -v328 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v329 := v328.FindInternedVar(lang.NewSymbol("list")) -if v329.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v329))) +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v330 := v329.Get() -v331 := lang.Apply(v330, []any{lang.NewSymbol("glojure.core/aget")}) -v332 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v333 := v332.FindInternedVar(lang.NewSymbol("list")) -if v333.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v333))) +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -v334 := v333.Get() -v335 := lang.Apply(v334, []any{lang.NewSymbol("array__0__auto__")}) -v336 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v337 := v336.FindInternedVar(lang.NewSymbol("list")) -if v337.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v337))) +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } -v338 := v337.Get() -v339 := lang.Apply(v338, []any{lang.NewSymbol("idx__1__auto__")}) -v340 := lang.Apply(v327, []any{v331, v335, v339}) -v341 := lang.Apply(v324, []any{v340}) -v342 := lang.Apply(v321, []any{v341}) -v343 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v344 := v343.FindInternedVar(lang.NewSymbol("list")) -if v344.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v344))) +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -v345 := v344.Get() -v346 := lang.Apply(v345, []any{lang.NewSymbol("idx2__3__auto__")}) -v347 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v348 := v347.FindInternedVar(lang.NewSymbol("list")) -if v348.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v348))) +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) } -v349 := v348.Get() -v350 := lang.Apply(v349, []any{lang.NewSymbol("idxv__4__auto__")}) -v351 := lang.Apply(v310, []any{v314, v318, v342, v346, v350}) -v352 := lang.Apply(v307, []any{v351}) -v353 := lang.Apply(v304, []any{v352}) -v354 := lang.Apply(v262, []any{v301, v353}) -v355 := lang.Apply(v259, []any{v354}) -v356 := lang.Apply(v256, []any{v355}) -v357 := lang.Apply(v13, []any{v17, v21, v142, v253, v356}) -v358 := lang.Apply(v10, []any{v357}) -return v358 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v5}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v2}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) } -// chunked-seq? -{ -v0 := lang.NewSymbol("chunked-seq?").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(708), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(708), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v3}) +v52 := lang.Apply(v39, []any{v43, v47, v51}) +v53 := lang.Apply(v36, []any{v52}) +v54 := lang.Apply(v33, []any{v53}) +v55 := lang.Apply(v22, []any{v26, v30, v54}) +v56 := lang.Apply(v19, []any{v55}) +v57 := lang.Apply(v13, []any{v16, v56, v4}) +return v57 + } +}) +v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } -v6 := v5.Get() -v7 := lang.Apply(v6, []any{lang1.IChunkedSeq, v3}) -return v7 +v5 := lang.Apply(v4, []any{v3, int64(1)}) +return v5 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// some-fn -{ -v0 := lang.NewSymbol("some-fn").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("p")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2"), lang.NewSymbol("p3")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2"), lang.NewSymbol("p3"), lang.NewSymbol("&"), lang.NewSymbol("ps"))), lang.NewKeyword("doc"), "Takes a set of predicates and returns a function f that returns the first logical true value\n returned by one of its composing predicates against any of its arguments, else it returns\n logical false. Note that f is short-circuiting in that it will stop execution on the first\n argument that triggers a logical true result against the original predicates.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7505), lang.NewKeyword("end-line"), int(7505))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] +v0 := lang.NewSymbol("/").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "If no denominators are supplied, returns 1/numerator,\n else returns numerator divided by all of the denominators.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1013), lang.NewKeyword("end-line"), int(1013))).(*lang.Symbol) var v4 lang.FnFunc -{ // function sp1 v4 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 0: -return nil case 1: -v6 := args[0] -v7 := lang.Apply(v3, []any{v6}) -return v7 - case 2: -v6 := args[0] -v7 := args[1] -v9 := lang.Apply(v3, []any{v6}) -var v8 any = v9 -_ = v8 -var v11 any -if lang.IsTruthy(v8) { -v11 = v8 -} else { -v12 := lang.Apply(v3, []any{v7}) -v11 = v12 -} -return v11 - case 3: -v6 := args[0] -v7 := args[1] -v8 := args[2] -v10 := lang.Apply(v3, []any{v6}) -var v9 any = v10 -_ = v9 -var v12 any -if lang.IsTruthy(v9) { -v12 = v9 -} else { -v14 := lang.Apply(v3, []any{v7}) -var v13 any = v14 -_ = v13 -var v16 any -if lang.IsTruthy(v13) { -v16 = v13 -} else { -v17 := lang.Apply(v3, []any{v8}) -v16 = v17 +v5 := args[0] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("/")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v12 = v16 +v8 := v7.Get() +v9 := lang.Apply(v8, []any{int64(1), v5}) +return v9 + case 2: +v5 := args[0] +v6 := args[1] +v7, _ := lang.FieldOrMethod(lang1.Numbers, "divide") +if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("divide is not a function"))) } -return v12 +v8 := lang.Apply(v7, []any{v5, v6}) +return v8 default: - if len(args) < 3 { + if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v6 := args[0] -v7 := args[1] -v8 := args[2] -v9 := lang.NewList(args[3:]...) -v11 := lang.Apply(v5, []any{v6, v7, v8}) -var v10 any = v11 -_ = v10 -var v13 any -if lang.IsTruthy(v10) { -v13 = v10 -} else { +v5 := args[0] +v6 := args[1] +v7 := lang.NewList(args[2:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("/")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("some")) +v15 := v14.FindInternedVar(lang.NewSymbol("/")) if v15.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } v16 := v15.Get() -v17 := lang.Apply(v16, []any{v3, v9}) -v13 = v17 -} -return v13 +v17 := lang.Apply(v16, []any{v5, v6}) +v18 := lang.Apply(v10, []any{v13, v17, v7}) +return v18 } }) -v5 := v4 -_ = v5 +v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v3 := ns.InternWithValue(v0, v4, true) +if v0.Meta() != nil { + v3.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7512), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7518), lang.NewKeyword("end-column"), int(43)) -v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) -if err != nil { - panic(err) } -return v6 - case 2: +// < +{ +var v1 lang.FnFunc +{ // function <__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] v4 := args[1] -var v5 lang.FnFunc -{ // function sp2 -v5 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -return nil - case 1: -v7 := args[0] -v9 := lang.Apply(v3, []any{v7}) -var v8 any = v9 -_ = v8 -var v11 any -if lang.IsTruthy(v8) { -v11 = v8 -} else { -v12 := lang.Apply(v4, []any{v7}) -v11 = v12 +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -return v11 - case 2: -v7 := args[0] -v8 := args[1] -v10 := lang.Apply(v3, []any{v7}) -var v9 any = v10 -_ = v9 -var v12 any -if lang.IsTruthy(v9) { -v12 = v9 -} else { -v14 := lang.Apply(v3, []any{v8}) -var v13 any = v14 -_ = v13 -var v16 any -if lang.IsTruthy(v13) { -v16 = v13 -} else { -v18 := lang.Apply(v4, []any{v7}) -var v17 any = v18 -_ = v17 -var v20 any -if lang.IsTruthy(v17) { -v20 = v17 -} else { -v21 := lang.Apply(v4, []any{v8}) -v20 = v21 +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("concat")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v16 = v20 +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("list")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v12 = v16 +v13 := v12.Get() +v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } -return v12 - case 3: -v7 := args[0] -v8 := args[1] -v9 := args[2] -v11 := lang.Apply(v3, []any{v7}) -var v10 any = v11 -_ = v10 -var v13 any -if lang.IsTruthy(v10) { -v13 = v10 -} else { -v15 := lang.Apply(v3, []any{v8}) -var v14 any = v15 -_ = v14 -var v17 any -if lang.IsTruthy(v14) { -v17 = v14 -} else { -v19 := lang.Apply(v3, []any{v9}) -var v18 any = v19 -_ = v18 -var v21 any -if lang.IsTruthy(v18) { -v21 = v18 -} else { -v23 := lang.Apply(v4, []any{v7}) -var v22 any = v23 -_ = v22 -var v25 any -if lang.IsTruthy(v22) { -v25 = v22 -} else { -v27 := lang.Apply(v4, []any{v8}) -var v26 any = v27 -_ = v26 -var v29 any -if lang.IsTruthy(v26) { -v29 = v26 -} else { -v30 := lang.Apply(v4, []any{v9}) -v29 = v30 +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v25 = v29 +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("seq")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -v21 = v25 +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("concat")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -v17 = v21 +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("list")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } -v13 = v17 +v30 := v29.Get() +v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/lt")}) +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) } -return v13 +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v4}) +v40 := lang.Apply(v27, []any{v31, v35, v39}) +v41 := lang.Apply(v24, []any{v40}) +v42 := lang.Apply(v21, []any{v41}) +v43 := lang.Apply(v10, []any{v14, v18, v42}) +v44 := lang.Apply(v7, []any{v43}) +return v44 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("<").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns non-nil if nums are in monotonically increasing order,\n otherwise false.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(893), lang.NewKeyword("end-line"), int(893))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v4 := args[0] +return true + case 2: +v4 := args[0] +v5 := args[1] +v6, _ := lang.FieldOrMethod(lang1.Numbers, "lt") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("lt is not a function"))) +} +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 default: - if len(args) < 3 { + if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v7 := args[0] -v8 := args[1] -v9 := args[2] -v10 := lang.NewList(args[3:]...) -v12 := lang.Apply(v6, []any{v7, v8, v9}) -var v11 any = v12 -_ = v11 -var v14 any +v4 := args[0] +v5 := args[1] +v6 := lang.NewList(args[2:]...) +recur_loop_150: +var v7 any +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("<")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v4, v5}) if lang.IsTruthy(v11) { -v14 = v11 -} else { -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("some")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +var v12 any +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("next")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } -v17 := v16.Get() -var v18 lang.FnFunc -v18 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v19 := args[0] -v21 := lang.Apply(v3, []any{v19}) -var v20 any = v21 -_ = v20 -var v23 any -if lang.IsTruthy(v20) { -v23 = v20 +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v6}) +if lang.IsTruthy(v16) { +var v17 any = v5 +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("first")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v6}) +var v18 any = v22 +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("next")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v6}) +var v23 any = v27 +v4 = v17 +v5 = v18 +v6 = v23 +goto recur_loop_150 } else { -v24 := lang.Apply(v4, []any{v19}) -v23 = v24 +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("<")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } -return v23 -}) -v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7526), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(7526), lang.NewKeyword("end-column"), int(52)) -v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) -if err != nil { - panic(err) +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("first")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -v21 := lang.Apply(v17, []any{v20, v10}) -v14 = v21 +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v6}) +v35 := lang.Apply(v30, []any{v5, v34}) +v12 = v35 } -return v14 +v7 = v12 +} else { +v7 = false +} +return v7 } }) -v6 := v5 -_ = v6 +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7520), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7526), lang.NewKeyword("end-column"), int(61)) -v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) -if err != nil { - panic(err) } -return v7 - case 3: +// <= +{ +var v1 lang.FnFunc +{ // function <=__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] v4 := args[1] -v5 := args[2] -var v6 lang.FnFunc -{ // function sp3 -v6 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -return nil - case 1: -v8 := args[0] -v10 := lang.Apply(v3, []any{v8}) -var v9 any = v10 -_ = v9 -var v12 any -if lang.IsTruthy(v9) { -v12 = v9 -} else { -v14 := lang.Apply(v4, []any{v8}) -var v13 any = v14 -_ = v13 -var v16 any -if lang.IsTruthy(v13) { -v16 = v13 -} else { -v17 := lang.Apply(v5, []any{v8}) -v16 = v17 -} -v12 = v16 -} -return v12 - case 2: -v8 := args[0] -v9 := args[1] -v11 := lang.Apply(v3, []any{v8}) -var v10 any = v11 -_ = v10 -var v13 any -if lang.IsTruthy(v10) { -v13 = v10 -} else { -v15 := lang.Apply(v3, []any{v9}) -var v14 any = v15 -_ = v14 -var v17 any -if lang.IsTruthy(v14) { -v17 = v14 -} else { -v19 := lang.Apply(v4, []any{v8}) -var v18 any = v19 -_ = v18 -var v21 any -if lang.IsTruthy(v18) { -v21 = v18 -} else { -v23 := lang.Apply(v4, []any{v9}) -var v22 any = v23 -_ = v22 -var v25 any -if lang.IsTruthy(v22) { -v25 = v22 -} else { -v27 := lang.Apply(v5, []any{v8}) -var v26 any = v27 -_ = v26 -var v29 any -if lang.IsTruthy(v26) { -v29 = v26 -} else { -v30 := lang.Apply(v5, []any{v9}) -v29 = v30 -} -v25 = v29 +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v21 = v25 +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("concat")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v17 = v21 +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("list")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v13 = v17 +v13 := v12.Get() +v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } -return v13 - case 3: -v8 := args[0] -v9 := args[1] -v10 := args[2] -v12 := lang.Apply(v3, []any{v8}) -var v11 any = v12 -_ = v11 -var v14 any -if lang.IsTruthy(v11) { -v14 = v11 -} else { -v16 := lang.Apply(v3, []any{v9}) -var v15 any = v16 -_ = v15 -var v18 any -if lang.IsTruthy(v15) { -v18 = v15 -} else { -v20 := lang.Apply(v3, []any{v10}) -var v19 any = v20 -_ = v19 -var v22 any -if lang.IsTruthy(v19) { -v22 = v19 -} else { -v24 := lang.Apply(v4, []any{v8}) -var v23 any = v24 -_ = v23 -var v26 any -if lang.IsTruthy(v23) { -v26 = v23 -} else { -v28 := lang.Apply(v4, []any{v9}) -var v27 any = v28 -_ = v27 -var v30 any -if lang.IsTruthy(v27) { -v30 = v27 -} else { -v32 := lang.Apply(v4, []any{v10}) -var v31 any = v32 -_ = v31 -var v34 any -if lang.IsTruthy(v31) { -v34 = v31 -} else { -v36 := lang.Apply(v5, []any{v8}) -var v35 any = v36 -_ = v35 -var v38 any -if lang.IsTruthy(v35) { -v38 = v35 -} else { -v40 := lang.Apply(v5, []any{v9}) -var v39 any = v40 -_ = v39 -var v42 any -if lang.IsTruthy(v39) { -v42 = v39 -} else { -v43 := lang.Apply(v5, []any{v10}) -v42 = v43 +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v38 = v42 +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("seq")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -v34 = v38 +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("concat")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -v30 = v34 +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("list")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } -v26 = v30 +v30 := v29.Get() +v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/lte")}) +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) } -v22 = v26 +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) } -v18 = v22 +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v4}) +v40 := lang.Apply(v27, []any{v31, v35, v39}) +v41 := lang.Apply(v24, []any{v40}) +v42 := lang.Apply(v21, []any{v41}) +v43 := lang.Apply(v10, []any{v14, v18, v42}) +v44 := lang.Apply(v7, []any{v43}) +return v44 +}) +v2 := v1 +_ = v2 } -v14 = v18 +v0 := lang.NewSymbol("<=").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns non-nil if nums are in monotonically non-decreasing order,\n otherwise false.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1048), lang.NewKeyword("end-line"), int(1048))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v4 := args[0] +return true + case 2: +v4 := args[0] +v5 := args[1] +v6, _ := lang.FieldOrMethod(lang1.Numbers, "lte") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("lte is not a function"))) } -return v14 +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 default: - if len(args) < 3 { + if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v8 := args[0] -v9 := args[1] -v10 := args[2] -v11 := lang.NewList(args[3:]...) -v13 := lang.Apply(v7, []any{v8, v9, v10}) -var v12 any = v13 -_ = v12 -var v15 any -if lang.IsTruthy(v12) { -v15 = v12 -} else { -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("some")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +v4 := args[0] +v5 := args[1] +v6 := lang.NewList(args[2:]...) +recur_loop_194: +var v7 any +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("<=")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v18 := v17.Get() -var v19 lang.FnFunc -v19 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v20 := args[0] -v22 := lang.Apply(v3, []any{v20}) -var v21 any = v22 -_ = v21 -var v24 any -if lang.IsTruthy(v21) { -v24 = v21 -} else { -v26 := lang.Apply(v4, []any{v20}) -var v25 any = v26 -_ = v25 -var v28 any -if lang.IsTruthy(v25) { -v28 = v25 +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v4, v5}) +if lang.IsTruthy(v11) { +var v12 any +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("next")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v6}) +if lang.IsTruthy(v16) { +var v17 any = v5 +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("first")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v6}) +var v18 any = v22 +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("next")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v6}) +var v23 any = v27 +v4 = v17 +v5 = v18 +v6 = v23 +goto recur_loop_194 } else { -v29 := lang.Apply(v5, []any{v20}) -v28 = v29 +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("<=")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } -v24 = v28 +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("first")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -return v24 -}) -v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7534), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(7534), lang.NewKeyword("end-column"), int(59)) -v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) -if err != nil { - panic(err) +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v6}) +v35 := lang.Apply(v30, []any{v5, v34}) +v12 = v35 } -v22 := lang.Apply(v18, []any{v21, v11}) -v15 = v22 +v7 = v12 +} else { +v7 = false } -return v15 +return v7 } }) -v7 := v6 -_ = v7 +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7528), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7534), lang.NewKeyword("end-column"), int(68)) -v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) -if err != nil { - panic(err) } -return v8 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } +// = +{ +var v1 lang.FnFunc +{ // function =__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("list*")) +v9 := v8.FindInternedVar(lang.NewSymbol("concat")) if v9.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } v10 := v9.Get() -v11 := lang.Apply(v10, []any{v3, v4, v5, v7}) -var v7 any = v11 -_ = v7 -var v13 lang.FnFunc -{ // function spn -v13 = lang.NewFnFunc(func(args ...any) any { +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("list")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol("glojure.lang.Util")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{lang.NewSymbol("glojure.core/equiv")}) +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{v3}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{v4}) +v31 := lang.Apply(v10, []any{v14, v18, v22, v26, v30}) +v32 := lang.Apply(v7, []any{v31}) +return v32 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("=").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Equality. Returns true if x equals y, false if not. Same as\n Java x.equals(y) except it also works for nil, and compares\n numbers and collections in a type-independent manner. Clojure's immutable data\n structures define equals() (and thus =) as a value, not an identity,\n comparison.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(776), lang.NewKeyword("end-line"), int(776))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 0: -return nil case 1: -v15 := args[0] +v4 := args[0] +return true + case 2: +v4 := args[0] +v5 := args[1] +v6 := lang.Apply(lang1.Equiv, []any{v4, v5}) +return v6 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := args[1] +v6 := lang.NewList(args[2:]...) +recur_loop_126: +var v7 any +v8 := lang.Apply(lang1.Equiv, []any{v4, v5}) +if lang.IsTruthy(v8) { +var v9 any +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("next")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{v6}) +if lang.IsTruthy(v13) { +var v14 any = v5 v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("some")) +v17 := v16.FindInternedVar(lang.NewSymbol("first")) if v17.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } v18 := v17.Get() -var v19 lang.FnFunc -v19 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v20 := args[0] -v21 := lang.Apply(v20, []any{v15}) -return v21 -}) -v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7539), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(7539), lang.NewKeyword("end-column"), int(26)) -v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) -if err != nil { - panic(err) +v19 := lang.Apply(v18, []any{v6}) +var v15 any = v19 +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("next")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v22 := lang.Apply(v18, []any{v21, v7}) -return v22 - case 2: -v15 := args[0] -v16 := args[1] -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("some")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v6}) +var v20 any = v24 +v4 = v14 +v5 = v15 +v6 = v20 +goto recur_loop_126 +} else { +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("first")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -v19 := v18.Get() -var v20 lang.FnFunc -v20 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v21 := args[0] -v23 := lang.Apply(v21, []any{v15}) -var v22 any = v23 -_ = v22 -var v25 any -if lang.IsTruthy(v22) { -v25 = v22 +v27 := v26.Get() +v28 := lang.Apply(v27, []any{v6}) +v29 := lang.Apply(lang1.Equiv, []any{v5, v28}) +v9 = v29 +} +v7 = v9 } else { -v26 := lang.Apply(v21, []any{v16}) -v25 = v26 +v7 = false } -return v25 +return v7 + } }) -v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7540), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(7540), lang.NewKeyword("end-column"), int(39)) -v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) -if err != nil { - panic(err) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v23 := lang.Apply(v19, []any{v22, v7}) -return v23 - case 3: -v15 := args[0] -v16 := args[1] -v17 := args[2] -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("some")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v20 := v19.Get() -var v21 lang.FnFunc -v21 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { +// == +{ +var v1 lang.FnFunc +{ // function ==__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v22 := args[0] -v24 := lang.Apply(v22, []any{v15}) -var v23 any = v24 -_ = v23 -var v26 any -if lang.IsTruthy(v23) { -v26 = v23 -} else { -v28 := lang.Apply(v22, []any{v16}) -var v27 any = v28 -_ = v27 -var v30 any -if lang.IsTruthy(v27) { -v30 = v27 -} else { -v31 := lang.Apply(v22, []any{v17}) -v30 = v31 +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v26 = v30 +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("concat")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -return v26 +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("list")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("seq")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("concat")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("list")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/equiv")}) +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v4}) +v40 := lang.Apply(v27, []any{v31, v35, v39}) +v41 := lang.Apply(v24, []any{v40}) +v42 := lang.Apply(v21, []any{v41}) +v43 := lang.Apply(v10, []any{v14, v18, v42}) +v44 := lang.Apply(v7, []any{v43}) +return v44 }) -v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7541), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7541), lang.NewKeyword("end-column"), int(47)) -v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) -if err != nil { - panic(err) +v2 := v1 +_ = v2 } -v24 := lang.Apply(v20, []any{v23, v7}) -return v24 +v0 := lang.NewSymbol("==").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns non-nil if nums all have the equivalent\n value (type-independent), otherwise false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1093), lang.NewKeyword("end-line"), int(1093))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v4 := args[0] +return true + case 2: +v4 := args[0] +v5 := args[1] +v6, _ := lang.FieldOrMethod(lang1.Numbers, "equiv") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("equiv is not a function"))) +} +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 default: - if len(args) < 3 { + if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v15 := args[0] -v16 := args[1] -v17 := args[2] -v18 := lang.NewList(args[3:]...) -v20 := lang.Apply(v14, []any{v15, v16, v17}) -var v19 any = v20 -_ = v19 -var v22 any -if lang.IsTruthy(v19) { -v22 = v19 -} else { -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("some")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +v4 := args[0] +v5 := args[1] +v6 := lang.NewList(args[2:]...) +recur_loop_206: +var v7 any +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("==")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v25 := v24.Get() -var v26 lang.FnFunc -v26 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v27 := args[0] +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v4, v5}) +if lang.IsTruthy(v11) { +var v12 any +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("next")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v6}) +if lang.IsTruthy(v16) { +var v17 any = v5 +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("first")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v6}) +var v18 any = v22 +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("next")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v6}) +var v23 any = v27 +v4 = v17 +v5 = v18 +v6 = v23 +goto recur_loop_206 +} else { v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("some")) +v29 := v28.FindInternedVar(lang.NewSymbol("==")) if v29.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } v30 := v29.Get() -v31 := lang.Apply(v30, []any{v27, v18}) -return v31 -}) -v27 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7543), lang.NewKeyword("column"), int(36), lang.NewKeyword("end-line"), int(7543), lang.NewKeyword("end-column"), int(49)) -v28, err := lang.WithMeta(v26, v27.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v29 := lang.Apply(v25, []any{v28, v7}) -v22 = v29 +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("first")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -return v22 - } -}) -v14 := v13 -_ = v14 +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v6}) +v35 := lang.Apply(v30, []any{v5, v34}) +v12 = v35 } -v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7537), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7543), lang.NewKeyword("end-column"), int(56)) -v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) -if err != nil { - panic(err) +v7 = v12 +} else { +v7 = false } -return v15 +return v7 } }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// parse-double +// > { -v0 := lang.NewSymbol("parse-double").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse string with floating point components and return a Double value,\n or nil if parse fails.\n\n Grammar: https://docs.oracle.com/javase/8/docs/api/java/lang/Double.html#valueOf-java.lang.String-", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7978), lang.NewKeyword("end-line"), int(7978))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { +var v1 lang.FnFunc +{ // function >__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -var v4 any +v4 := args[1] v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("string?")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq")) if v6.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -if lang.IsTruthy(v8) { -v10 := lang.Apply(strconv4.ParseFloat, []any{v3, int64(64)}) -var v9 any = v10 -_ = v9 -var v12 any -v13 := lang.Apply(v9, []any{int64(1)}) -if lang.IsTruthy(v13) { -v12 = nil -} else { -v14 := lang.Apply(v9, []any{int64(0)}) -v12 = v14 +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("concat")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v4 = v12 -} else { -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("parsing-err")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("list")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v3}) -v13 := lang.Apply(lang1.NewIllegalArgumentError, []any{v12}) -panic(v13) +v13 := v12.Get() +v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("seq")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -// load-data-reader-file -{ -v0 := lang.NewSymbol("load-data-reader-file").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7879), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7879), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("mappings"), lang.NewSymbol("url"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v6, ok := lang.FieldOrMethod(v4, "openStream") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "openStream"))) +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("concat")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -var v7 any -switch reflect.TypeOf(v6).Kind() { -case reflect.Func: - v7 = lang.Apply(v6, nil) -default: - v7 = v6 -} -v8 := lang.Apply(java.io.InputStreamReader6., []any{v7, "UTF-8"}) -v9 := lang.Apply(glojure.lang.LineNumberingPushbackReader5., []any{v8}) -var v5 any = v9 -_ = v5 -var v11 any -func() { -defer func() { -v12, ok := lang.FieldOrMethod(v5, "close") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "close"))) -} -var v13 any -switch reflect.TypeOf(v12).Kind() { -case reflect.Func: - v13 = lang.Apply(v12, nil) -default: - v13 = v12 -} -}() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("push-thread-bindings")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("list")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } -v17 := v16.Get() -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("hash-map")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v30 := v29.Get() +v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/gt")}) +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) } -v20 := v19.Get() -v21 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*file*")) -v22, ok := lang.FieldOrMethod(v4, "getFile") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "getFile"))) +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) } -var v23 any -switch reflect.TypeOf(v22).Kind() { -case reflect.Func: - v23 = lang.Apply(v22, nil) -default: - v23 = v22 +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v4}) +v40 := lang.Apply(v27, []any{v31, v35, v39}) +v41 := lang.Apply(v24, []any{v40}) +v42 := lang.Apply(v21, []any{v41}) +v43 := lang.Apply(v10, []any{v14, v18, v42}) +v44 := lang.Apply(v7, []any{v43}) +return v44 +}) +v2 := v1 +_ = v2 } -v24 := lang.Apply(v20, []any{v21, v23}) -v25 := lang.Apply(v17, []any{v24}) -_ = v25 -var v26 any -func() { -defer func() { -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v0 := lang.NewSymbol(">").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns non-nil if nums are in monotonically decreasing order,\n otherwise false.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1063), lang.NewKeyword("end-line"), int(1063))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v4 := args[0] +return true + case 2: +v4 := args[0] +v5 := args[1] +v6, _ := lang.FieldOrMethod(lang1.Numbers, "gt") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("gt is not a function"))) } -v29 := v28.Get() -v30 := lang.Apply(v29, nil) -}() -var v32 any -v33, ok := lang.FieldOrMethod(v4, "getPath") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "getPath"))) +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := args[1] +v6 := lang.NewList(args[2:]...) +recur_loop_198: +var v7 any +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol(">")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -var v34 any -switch reflect.TypeOf(v33).Kind() { -case reflect.Func: - v34 = lang.Apply(v33, nil) -default: - v34 = v33 +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v4, v5}) +if lang.IsTruthy(v11) { +var v12 any +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("next")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } -v35, _ := lang.FieldOrMethod(v34, "endsWith") -if reflect.TypeOf(v35).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("endsWith is not a function"))) +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v6}) +if lang.IsTruthy(v16) { +var v17 any = v5 +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("first")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v36 := lang.Apply(v35, []any{"cljc"}) -if lang.IsTruthy(v36) { -v37 := lang.NewMap(lang.NewKeyword("eof"), nil, lang.NewKeyword("read-cond"), lang.NewKeyword("allow")) -v38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7885), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7885), lang.NewKeyword("end-column"), int(52)) -v39, err := lang.WithMeta(v37, v38.(lang.IPersistentMap)) -if err != nil { - panic(err) +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v6}) +var v18 any = v22 +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("next")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -v32 = v39 +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v6}) +var v23 any = v27 +v4 = v17 +v5 = v18 +v6 = v23 +goto recur_loop_198 } else { -v40 := lang.NewMap(lang.NewKeyword("eof"), nil) -v41 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7886), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7886), lang.NewKeyword("end-column"), int(34)) -v42, err := lang.WithMeta(v40, v41.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v32 = v42 -} -var v31 any = v32 -_ = v31 -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("read")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v31, v5}) -var v43 any = v47 -_ = v43 -var v49 any -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("not")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("map?")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) -} -v55 := v54.Get() -v56 := lang.Apply(v55, []any{v43}) -v57 := lang.Apply(v52, []any{v56}) -if lang.IsTruthy(v57) { -v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v59 := v58.FindInternedVar(lang.NewSymbol("ex-info")) -if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol(">")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } -v60 := v59.Get() -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("str")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("first")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -v63 := v62.Get() -v64 := lang.Apply(v63, []any{"Not a valid data-reader map"}) -v65 := lang.NewMap(lang.NewKeyword("url"), v4) -v66 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7890), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(7890), lang.NewKeyword("end-column"), int(36)) -v67, err := lang.WithMeta(v65, v66.(lang.IPersistentMap)) -if err != nil { - panic(err) +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v6}) +v35 := lang.Apply(v30, []any{v5, v34}) +v12 = v35 } -v68 := lang.Apply(v60, []any{v64, v67}) -panic(v68) +v7 = v12 } else { -v49 = nil -} -_ = v49 -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("reduce")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +v7 = false } -v71 := v70.Get() -var v72 lang.FnFunc -v72 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) +return v7 } -v73 := args[0] -v74 := args[1] -var v75 any = v74 -_ = v75 -v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v78 := v77.FindInternedVar(lang.NewSymbol("nth")) -if v78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) -} -v79 := v78.Get() -v80 := lang.Apply(v79, []any{v75, int64(0), nil}) -var v76 any = v80 -_ = v76 -v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v83 := v82.FindInternedVar(lang.NewSymbol("nth")) -if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) -} -v84 := v83.Get() -v85 := lang.Apply(v84, []any{v75, int64(1), nil}) -var v81 any = v85 -_ = v81 -var v87 any -v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v89 := v88.FindInternedVar(lang.NewSymbol("not")) -if v89.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) -} -v90 := v89.Get() -v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v92 := v91.FindInternedVar(lang.NewSymbol("symbol?")) -if v92.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) -} -v93 := v92.Get() -v94 := lang.Apply(v93, []any{v76}) -v95 := lang.Apply(v90, []any{v94}) -if lang.IsTruthy(v95) { -v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v97 := v96.FindInternedVar(lang.NewSymbol("ex-info")) -if v97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) -} -v98 := v97.Get() -v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v100 := v99.FindInternedVar(lang.NewSymbol("str")) -if v100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) -} -v101 := v100.Get() -v102 := lang.Apply(v101, []any{"Invalid form in data-reader file"}) -v103 := lang.NewMap(lang.NewKeyword("url"), v4, lang.NewKeyword("form"), v76) -v104 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7895), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(7896), lang.NewKeyword("end-column"), int(38)) -v105, err := lang.WithMeta(v103, v104.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v106 := lang.Apply(v98, []any{v102, v105}) -panic(v106) -} else { -v87 = nil -} -_ = v87 -v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v109 := v108.FindInternedVar(lang.NewSymbol("data-reader-var")) -if v109.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) -} -v110 := v109.Get() -v111 := lang.Apply(v110, []any{v81}) -var v107 any = v111 -_ = v107 -var v113 any -v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v116 := v115.FindInternedVar(lang.NewSymbol("contains?")) -if v116.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) -} -v117 := v116.Get() -v118 := lang.Apply(v117, []any{v3, v76}) -var v114 any = v118 -_ = v114 -var v120 any -if lang.IsTruthy(v114) { -v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v122 := v121.FindInternedVar(lang.NewSymbol("not=")) -if v122.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) -} -v123 := v122.Get() -v124 := lang.Apply(v3, []any{v76}) -v125 := lang.Apply(v123, []any{v124, v107}) -v120 = v125 -} else { -v120 = v114 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } -if lang.IsTruthy(v120) { -v114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v115 := v114.FindInternedVar(lang.NewSymbol("ex-info")) -if v115.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v115))) } -v116 := v115.Get() -v117 := lang.NewMap(lang.NewKeyword("url"), v4, lang.NewKeyword("conflict"), v76, lang.NewKeyword("mappings"), v73) -v118 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7901), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(7903), lang.NewKeyword("end-column"), int(44)) -v119, err := lang.WithMeta(v117, v118.(lang.IPersistentMap)) -if err != nil { - panic(err) +// >0? +{ +v0 := lang.NewSymbol(">0?").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(963), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(963), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } -v120 := lang.Apply(v116, []any{"Conflicting data-reader mapping", v119}) -panic(v120) -} else { -v113 = nil +v5 := lang.Apply(v4, []any{v3, int64(0)}) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -_ = v113 -v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v122 := v121.FindInternedVar(lang.NewSymbol("assoc")) -if v122.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) } -v123 := v122.Get() -v124 := lang.Apply(v123, []any{v73, v76, v107}) -return v124 -}) -v73 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7892), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(7904), lang.NewKeyword("end-column"), int(32)) -v74, err := lang.WithMeta(v72, v73.(lang.IPersistentMap)) -if err != nil { - panic(err) +// >1? +{ +v0 := lang.NewSymbol(">1?").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(962), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(962), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } -v75 := lang.Apply(v71, []any{v74, v3, v43}) -v26 = v75 -}() -v11 = v26 -}() -return v11 +v5 := lang.Apply(v4, []any{v3, int64(1)}) +return v5 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -4971,811 +4755,839 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// short +// >= { var v1 lang.FnFunc -{ // function short__inliner +{ // function >=__inliner v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { + if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("concat")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("list")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v13 := v12.Get() +v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("seq")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("concat")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("list")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } -v29 := v28.Get() -var v30 any -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v30 := v29.Get() +v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/gte")}) +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) } -v33 := v32.Get() -if lang.IsTruthy(v33) { -v30 = lang.NewSymbol("uncheckedShortCast") -} else { -v30 = lang.NewSymbol("shortCast") -} -v34 := lang.Apply(v29, []any{v30}) -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("list")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) } -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v3}) -v39 := lang.Apply(v26, []any{v34, v38}) -v40 := lang.Apply(v23, []any{v39}) -v41 := lang.Apply(v20, []any{v40}) -v42 := lang.Apply(v9, []any{v13, v17, v41}) -v43 := lang.Apply(v6, []any{v42}) -return v43 +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v4}) +v40 := lang.Apply(v27, []any{v31, v35, v39}) +v41 := lang.Apply(v24, []any{v40}) +v42 := lang.Apply(v21, []any{v41}) +v43 := lang.Apply(v10, []any{v14, v18, v42}) +v44 := lang.Apply(v7, []any{v43}) +return v44 }) v2 := v1 _ = v2 } -v0 := lang.NewSymbol("short").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to short", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3499), lang.NewKeyword("end-line"), int(3499))).(*lang.Symbol) +v0 := lang.NewSymbol(">=").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns non-nil if nums are in monotonically non-increasing order,\n otherwise false.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1078), lang.NewKeyword("end-line"), int(1078))).(*lang.Symbol) var v3 lang.FnFunc v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := lang.Apply(lang1.ShortCast, []any{v4}) -return v5 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// disj -{ -v0 := lang.NewSymbol("disj").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("set")), lang.NewVector(lang.NewSymbol("set"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("set"), lang.NewSymbol("key"), lang.NewSymbol("&"), lang.NewSymbol("ks"))), lang.NewKeyword("doc"), "disj[oin]. Returns a new set of the same (hashed/sorted) type, that\n does not contain key(s).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1514), lang.NewKeyword("end-line"), int(1514))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: -v3 := args[0] -return v3 +v4 := args[0] +return true case 2: -v3 := args[0] -v4 := args[1] -var v5 any -if lang.IsTruthy(v3) { -v6, _ := lang.FieldOrMethod(v3, "Disjoin") +v4 := args[0] +v5 := args[1] +v6, _ := lang.FieldOrMethod(lang1.Numbers, "gte") if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Disjoin is not a function"))) -} -v7 := lang.Apply(v6, []any{v4}) -v5 = v7 -} else { -v5 = nil + panic(lang.NewIllegalArgumentError(fmt.Sprintf("gte is not a function"))) } -return v5 +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 default: if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -recur_loop_304: -var v6 any -if lang.IsTruthy(v3) { +v4 := args[0] +v5 := args[1] +v6 := lang.NewList(args[2:]...) +recur_loop_202: +var v7 any v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("disj")) +v9 := v8.FindInternedVar(lang.NewSymbol(">=")) if v9.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } v10 := v9.Get() -v11 := lang.Apply(v10, []any{v3, v4}) -var v7 any = v11 -_ = v7 -var v13 any -if lang.IsTruthy(v5) { -var v14 any = v7 -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("first")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +v11 := lang.Apply(v10, []any{v4, v5}) +if lang.IsTruthy(v11) { +var v12 any +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("next")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v5}) -var v15 any = v19 -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("next")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v6}) +if lang.IsTruthy(v16) { +var v17 any = v5 +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("first")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v5}) -var v20 any = v24 -v3 = v14 -v4 = v15 -v5 = v20 -goto recur_loop_304 +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v6}) +var v18 any = v22 +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("next")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v6}) +var v23 any = v27 +v4 = v17 +v5 = v18 +v6 = v23 +goto recur_loop_202 } else { -v13 = v7 +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol(">=")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } -v6 = v13 +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("first")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v6}) +v35 := lang.Apply(v30, []any{v5, v34}) +v12 = v35 +} +v7 = v12 } else { -v6 = nil +v7 = false } -return v6 +return v7 } }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// map +// NaN? { -v0 := lang.NewSymbol("map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2"), lang.NewSymbol("c3")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2"), lang.NewSymbol("c3"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Returns a lazy sequence consisting of the result of applying f to\n the set of first items of each coll, followed by applying f to the\n set of second items in each coll, until any one of the colls is\n exhausted. Any remaining items in other colls are ignored. Function\n f should accept number-of-colls arguments. Returns a transducer when\n no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2719), lang.NewKeyword("end-line"), int(2719))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { +var v1 lang.FnFunc +{ // function NaN?__inliner +v1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v5 := args[0] -var v6 lang.FnFunc -v6 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v7 := lang.Apply(v5, nil) -return v7 - case 1: -v7 := args[0] -v8 := lang.Apply(v5, []any{v7}) -return v8 - case 2: -v7 := args[0] -v8 := args[1] -v9 := lang.Apply(v3, []any{v8}) -v10 := lang.Apply(v5, []any{v7, v9}) -return v10 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v7 := args[0] -v8 := args[1] -v9 := lang.NewList(args[2:]...) +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("apply")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) if v11.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } v12 := v11.Get() -v13 := lang.Apply(v12, []any{v3, v8, v9}) -v14 := lang.Apply(v5, []any{v7, v13}) -return v14 +v13 := lang.Apply(v12, []any{lang.NewSymbol("math.IsNaN")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v3}) +v18 := lang.Apply(v9, []any{v13, v17}) +v19 := lang.Apply(v6, []any{v18}) +return v19 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("NaN?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns true if num is NaN, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)), lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(8011), lang.NewKeyword("end-line"), int(8011))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } +v4 := args[0] +v5 := lang.Apply(math3.IsNaN, []any{v4}) +return v5 }) -v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2730), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(2736), lang.NewKeyword("end-column"), int(47)) -v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// PrintWriter-on +{ +v1 := reflect.TypeOf((*bytes4.Buffer)(nil)) +v0 := lang.NewSymbol("PrintWriter-on").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("flush-fn"), lang.NewSymbol("close-fn")), lang.NewVector(lang.NewSymbol("flush-fn"), lang.NewSymbol("close-fn"), lang.NewSymbol("autoflush?"))), lang.NewKeyword("doc"), "implements java.io.PrintWriter given flush-fn, which will be called\n when .flush() is called, with a string built up since the last call to .flush().\n if not nil, close-fn will be called with no arguments when .close is called.\n autoflush? determines if the PrintWriter will autoflush, false by default.", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(73), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(522), lang.NewKeyword("end-line"), int(522))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v4 := args[0] +v5 := args[1] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("PrintWriter-on")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v4, v5, false}) +return v9 + case 3: +v4 := args[0] +v5 := args[1] +v6 := args[2] +v8 := lang.Apply(StringBuilder5., nil) +var v7 any = v8 +_ = v7 +v10 := lang.NewVector(nil) +v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(532), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(532), lang.NewKeyword("end-column"), int(23)) +v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) if err != nil { panic(err) } -return v8 -}) -v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2729), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2736), lang.NewKeyword("end-column"), int(48)) -v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) +v13 := lang.NewVector() +v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(532), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(532), lang.NewKeyword("end-column"), int(26)) +v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) if err != nil { panic(err) } -return v6 - case 2: -v3 := args[0] -v4 := args[1] -var v5 lang.FnFunc -v5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("seq")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v4}) -var v6 any = v10 -_ = v6 -var v12 any -if lang.IsTruthy(v6) { -var v13 any = v6 -_ = v13 -var v15 any v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("chunked-seq?")) +v17 := v16.FindInternedVar(lang.NewSymbol("flush")) if v17.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } v18 := v17.Get() -v19 := lang.Apply(v18, []any{v13}) -if lang.IsTruthy(v19) { -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("chunk-first")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +v19 := lang.NewVector() +v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(533), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(533), lang.NewKeyword("end-column"), int(19)) +v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v13}) -var v20 any = v24 -_ = v20 -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("int")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +var v22 any +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("pos?")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("count")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +v25 := v24.Get() +v26, ok := lang.FieldOrMethod(v7, "length") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "length"))) } -v31 := v30.Get() -v32 := lang.Apply(v31, []any{v20}) -v33 := lang.Apply(v28, []any{v32}) -var v25 any = v33 -_ = v25 -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("chunk-buffer")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +var v27 any +switch reflect.TypeOf(v26).Kind() { +case reflect.Func: + v27 = lang.Apply(v26, nil) +default: + v27 = v26 +} +v28 := lang.Apply(v25, []any{v27}) +if lang.IsTruthy(v28) { +v29 := lang.Apply(lang1.ToString, []any{v7}) +v30 := lang.Apply(v4, []any{v29}) +v22 = v30 +} else { +v22 = nil +} +v31, _ := lang.FieldOrMethod(v7, "setLength") +if reflect.TypeOf(v31).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setLength is not a function"))) +} +v32 := lang.Apply(v31, []any{int64(0)}) +v33 := lang.Apply(v18, []any{v21, v22, v32}) +v34 := lang.NewVector() +v35 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(537), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(537), lang.NewKeyword("end-column"), int(19)) +v36, err := lang.WithMeta(v34, v35.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v37, ok := lang.FieldOrMethod(nil, "flush") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "flush"))) +} +var v38 any +switch reflect.TypeOf(v37).Kind() { +case reflect.Func: + v38 = lang.Apply(v37, nil) +default: + v38 = v37 +} +var v39 any +if lang.IsTruthy(v5) { +v40 := lang.Apply(v5, nil) +v39 = v40 +} else { +v39 = nil +} +v41 := lang.Apply(nil, []any{v36, v38, v39, nil}) +v42 := lang.NewVector(nil, nil, nil) +v43 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(541), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(541), lang.NewKeyword("end-column"), int(35)) +v44, err := lang.WithMeta(v42, v43.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v25}) -var v34 any = v38 -_ = v34 -v41 := lang.Apply(lang1.LongCast, []any{v25}) -var v40 any = v41 -_ = v40 -var v43 any = int64(0) -_ = v43 -var v44 any -for { var v45 any v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("<")) +v47 := v46.FindInternedVar(lang.NewSymbol("pos?")) if v47.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) } v48 := v47.Get() -v49 := lang.Apply(v48, []any{v43, v40}) +v49 := lang.Apply(v48, []any{nil}) if lang.IsTruthy(v49) { -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("chunk-append")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53, _ := lang.FieldOrMethod(v20, "nth") -if reflect.TypeOf(v53).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) +var v50 any +v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v52 := v51.FindInternedVar(lang.NewSymbol("instance?")) +if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) } -v54 := lang.Apply(v53, []any{v43}) -v55 := lang.Apply(v3, []any{v54}) -v56 := lang.Apply(v52, []any{v34, v55}) -_ = v56 -v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v59 := v58.FindInternedVar(lang.NewSymbol("unchecked-inc")) -if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) +v53 := v52.Get() +v54 := lang.Apply(v53, []any{lang.Builtins["string"], nil}) +if lang.IsTruthy(v54) { +v55 := lang.Apply(lang1.AppendWriter, []any{v7, nil, nil, nil}) +v50 = v55 +} else { +v56 := lang.Apply(lang1.AppendWriter, []any{v7, nil, nil, nil}) +v50 = v56 } -v60 := v59.Get() -v61 := lang.Apply(v60, []any{v43}) -var v57 any = v61 -v43 = v57 -continue +v45 = v50 } else { v45 = nil } -v44 = v45 - break +v57 := lang.Apply(nil, []any{v44, v45}) +v58 := lang.Apply(nil, []any{v12, v15, v33, v41, v57}) +v59 := lang.Apply(java.io.BufferedWriter7., []any{v58}) +v60 := lang.Apply(java.io.PrintWriter6., []any{v59, v6}) +return v60 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v4 := reflect.TypeOf((*bytes4.Buffer)(nil)) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } -_ = v44 -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("chunk-cons")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) } -v42 := v41.Get() -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("chunk")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +// StackTraceElement->vec +{ +v0 := lang.NewSymbol("StackTraceElement->vec").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"))), lang.NewKeyword("doc"), "Constructs a data representation for a StackTraceElement: [class method file line]", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(436), lang.NewKeyword("end-line"), int(436))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("symbol")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v45 := v44.Get() -v46 := lang.Apply(v45, []any{v34}) -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("map")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +v6 := v5.Get() +v7, ok := lang.FieldOrMethod(v3, "getClassName") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getClassName"))) } -v49 := v48.Get() -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("chunk-rest")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +var v8 any +switch reflect.TypeOf(v7).Kind() { +case reflect.Func: + v8 = lang.Apply(v7, nil) +default: + v8 = v7 } -v52 := v51.Get() -v53 := lang.Apply(v52, []any{v13}) -v54 := lang.Apply(v49, []any{v3, v53}) -v55 := lang.Apply(v42, []any{v46, v54}) -v15 = v55 -} else { -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("cons")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +v9 := lang.Apply(v6, []any{v8}) +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("symbol")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("first")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +v12 := v11.Get() +v13, ok := lang.FieldOrMethod(v3, "getMethodName") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getMethodName"))) } -v25 := v24.Get() -v26 := lang.Apply(v25, []any{v13}) -v27 := lang.Apply(v3, []any{v26}) -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("map")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +var v14 any +switch reflect.TypeOf(v13).Kind() { +case reflect.Func: + v14 = lang.Apply(v13, nil) +default: + v14 = v13 } -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("rest")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v15 := lang.Apply(v12, []any{v14}) +v16, ok := lang.FieldOrMethod(v3, "getFileName") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getFileName"))) } -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v13}) -v35 := lang.Apply(v30, []any{v3, v34}) -v36 := lang.Apply(v22, []any{v27, v35}) -v15 = v36 +var v17 any +switch reflect.TypeOf(v16).Kind() { +case reflect.Func: + v17 = lang.Apply(v16, nil) +default: + v17 = v16 } -v12 = v15 -} else { -v12 = nil +v18, ok := lang.FieldOrMethod(v3, "getLineNumber") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getLineNumber"))) } -return v12 +var v19 any +switch reflect.TypeOf(v18).Kind() { +case reflect.Func: + v19 = lang.Apply(v18, nil) +default: + v19 = v18 +} +v20 := lang.NewVector(v9, v15, v17, v19) +v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(440), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(440), lang.NewKeyword("end-column"), int(94)) +v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v22 }) -v6 := lang.Apply(lang1.NewLazySeq, []any{v5}) -return v6 - case 3: +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// Throwable->map +{ +v0 := lang.NewSymbol("Throwable->map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"))), lang.NewKeyword("doc"), "Constructs a data representation for a Throwable with keys:\n :cause - root cause message\n :phase - error phase\n :via - cause chain, with cause keys:\n :type - exception class symbol\n :message - exception message\n :data - ex-data\n :at - top stack element\n :trace - root cause stack elements", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(442), lang.NewKeyword("end-line"), int(442))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] -v4 := args[1] -v5 := args[2] -var v6 lang.FnFunc -v6 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { +var v5 lang.FnFunc +v5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("seq")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v6 := args[0] +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("merge")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v4}) -var v7 any = v11 -_ = v7 +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("symbol")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("seq")) +v14 := v13.FindInternedVar(lang.NewSymbol("class")) if v14.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } v15 := v14.Get() -v16 := lang.Apply(v15, []any{v5}) -var v12 any = v16 -_ = v12 -var v18 any -var v19 any = v7 -_ = v19 -var v21 any -if lang.IsTruthy(v19) { -v21 = v12 -} else { -v21 = v19 -} -if lang.IsTruthy(v21) { -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("cons")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v16 := lang.Apply(v15, []any{v6}) +v17, ok := lang.FieldOrMethod(v16, "Name") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v16, "Name"))) } -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("first")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +var v18 any +switch reflect.TypeOf(v17).Kind() { +case reflect.Func: + v18 = lang.Apply(v17, nil) +default: + v18 = v17 } -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v7}) -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("first")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +v19 := lang.Apply(v12, []any{v18}) +v20 := lang.NewMap(lang.NewKeyword("type"), v19) +v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(455), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(455), lang.NewKeyword("end-column"), int(56)) +v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v28 := v27.Get() -v29 := lang.Apply(v28, []any{v12}) -v30 := lang.Apply(v3, []any{v25, v29}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("map")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v24, ok := lang.FieldOrMethod(v6, "getLocalizedMessage") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "getLocalizedMessage"))) } -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("rest")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +var v25 any +switch reflect.TypeOf(v24).Kind() { +case reflect.Func: + v25 = lang.Apply(v24, nil) +default: + v25 = v24 } -v36 := v35.Get() -v37 := lang.Apply(v36, []any{v7}) -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("rest")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +var v23 any = v25 +_ = v23 +var v27 any +if lang.IsTruthy(v23) { +var v28 any = v23 +_ = v28 +v30 := lang.NewMap(lang.NewKeyword("message"), v28) +v31 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(457), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(457), lang.NewKeyword("end-column"), int(33)) +v32, err := lang.WithMeta(v30, v31.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v40 := v39.Get() -v41 := lang.Apply(v40, []any{v12}) -v42 := lang.Apply(v33, []any{v3, v37, v41}) -v43 := lang.Apply(v21, []any{v30, v42}) -v18 = v43 +v27 = v32 } else { -v18 = nil -} -return v18 -}) -v7 := lang.Apply(lang1.NewLazySeq, []any{v6}) -return v7 - case 4: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -var v7 lang.FnFunc -v7 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("seq")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +v27 = nil } -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v4}) -var v8 any = v12 -_ = v8 -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("seq")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("ex-data")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v5}) -var v13 any = v17 -_ = v13 -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("seq")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v6}) +var v23 any = v27 +_ = v23 +var v29 any +if lang.IsTruthy(v23) { +var v30 any = v23 +_ = v30 +v32 := lang.NewMap(lang.NewKeyword("data"), v30) +v33 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(459), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(459), lang.NewKeyword("end-column"), int(29)) +v34, err := lang.WithMeta(v32, v33.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v6}) -var v18 any = v22 -_ = v18 -var v24 any -var v25 any = v8 -_ = v25 -var v27 any -if lang.IsTruthy(v25) { -var v28 any = v13 -_ = v28 -var v30 any -if lang.IsTruthy(v28) { -v30 = v18 +v29 = v34 } else { -v30 = v28 +v29 = nil } -v27 = v30 -} else { -v27 = v25 +v24, ok := lang.FieldOrMethod(v6, "getStackTrace") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "getStackTrace"))) } -if lang.IsTruthy(v27) { -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("cons")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +var v25 any +switch reflect.TypeOf(v24).Kind() { +case reflect.Func: + v25 = lang.Apply(v24, nil) +default: + v25 = v24 } -v27 := v26.Get() +var v23 any = v25 +_ = v23 +var v27 any v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("first")) +v29 := v28.FindInternedVar(lang.NewSymbol("pos?")) if v29.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } v30 := v29.Get() -v31 := lang.Apply(v30, []any{v8}) -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("first")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("alength")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v13}) +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v23}) +v35 := lang.Apply(v30, []any{v34}) +if lang.IsTruthy(v35) { v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("first")) +v37 := v36.FindInternedVar(lang.NewSymbol("StackTraceElement->vec")) if v37.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) } v38 := v37.Get() -v39 := lang.Apply(v38, []any{v18}) -v40 := lang.Apply(v3, []any{v31, v35, v39}) -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("map")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("rest")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v8}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("rest")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("aget")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) } -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v13}) -v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("rest")) -if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) +v41 := v40.Get() +v42 := lang.Apply(v41, []any{v23, int64(0)}) +v43 := lang.Apply(v38, []any{v42}) +v44 := lang.NewMap(lang.NewKeyword("at"), v43) +v45 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(462), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(462), lang.NewKeyword("end-column"), int(63)) +v46, err := lang.WithMeta(v44, v45.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v54 := v53.Get() -v55 := lang.Apply(v54, []any{v18}) -v56 := lang.Apply(v43, []any{v3, v47, v51, v55}) -v57 := lang.Apply(v27, []any{v40, v56}) -v24 = v57 +v27 = v46 } else { -v24 = nil +v27 = nil } -return v24 +v23 := lang.Apply(v9, []any{v22, v27, v29, v27}) +return v23 }) -v8 := lang.Apply(lang1.NewLazySeq, []any{v7}) -return v8 - default: - if len(args) < 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := lang.NewList(args[4:]...) -var v9 lang.FnFunc -{ // function step -v9 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v11 := args[0] -var v12 lang.FnFunc -v12 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("map")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(454), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(462), lang.NewKeyword("end-column"), int(67)) +v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v16 := v15.Get() +var v4 any = v7 +_ = v4 +v10 := lang.NewVector() +v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(463), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(463), lang.NewKeyword("end-column"), int(25)) +v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v9 any = v12 +_ = v9 +var v13 any = v3 +_ = v13 +var v14 any +for { +var v15 any +if lang.IsTruthy(v13) { v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +v18 := v17.FindInternedVar(lang.NewSymbol("conj")) if v18.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } v19 := v18.Get() -v20 := lang.Apply(v16, []any{v19, v11}) -var v13 any = v20 -_ = v13 -var v22 any -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("every?")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +v20 := lang.Apply(v19, []any{v9, v13}) +var v16 any = v20 +v22, ok := lang.FieldOrMethod(v13, "getCause") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v13, "getCause"))) } -v25 := v24.Get() +var v23 any +switch reflect.TypeOf(v22).Kind() { +case reflect.Func: + v23 = lang.Apply(v22, nil) +default: + v23 = v22 +} +var v21 any = v23 +v9 = v16 +v13 = v21 +continue +} else { +v15 = v9 +} +v14 = v15 + break +} +var v8 any = v14 +_ = v8 +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("peek")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{v8}) +var v9 any = v13 +_ = v9 +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("merge")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("vec")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("map")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v4, v8}) +v25 := lang.Apply(v20, []any{v24}) v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("identity")) +v27 := v26.FindInternedVar(lang.NewSymbol("vec")) if v27.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) } v28 := v27.Get() -v29 := lang.Apply(v25, []any{v28, v13}) -if lang.IsTruthy(v29) { -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("cons")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("map")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("map")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) } -v35 := v34.Get() -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("first")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +v31 := v30.Get() +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("StackTraceElement->vec")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) } -v38 := v37.Get() -v39 := lang.Apply(v35, []any{v38, v13}) -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("map")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("rest")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.Apply(v42, []any{v45, v13}) -v47 := lang.Apply(v10, []any{v46}) -v48 := lang.Apply(v32, []any{v39, v47}) -v22 = v48 +v34 := v33.Get() +var v35 any = v9 +_ = v35 +var v37 any +if lang.IsTruthy(v35) { +v37 = v35 } else { -v22 = nil +v37 = v3 } -return v22 -}) -v13 := lang.Apply(lang1.NewLazySeq, []any{v12}) -return v13 -}) -v10 := v9 -_ = v10 +v35, ok := lang.FieldOrMethod(v37, "getStackTrace") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v37, "getStackTrace"))) } -v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2761), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(2765), lang.NewKeyword("end-column"), int(68)) -v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) +var v36 any +switch reflect.TypeOf(v35).Kind() { +case reflect.Func: + v36 = lang.Apply(v35, nil) +default: + v36 = v35 +} +v37 := lang.Apply(v31, []any{v34, v36}) +v38 := lang.Apply(v28, []any{v37}) +v39 := lang.NewMap(lang.NewKeyword("via"), v25, lang.NewKeyword("trace"), v38) +v40 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(468), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(470), lang.NewKeyword("end-column"), int(111)) +v41, err := lang.WithMeta(v39, v40.(lang.IPersistentMap)) if err != nil { panic(err) } -var v8 any = v11 -_ = v8 -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("map")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +v43, ok := lang.FieldOrMethod(v9, "getLocalizedMessage") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v9, "getLocalizedMessage"))) } -v15 := v14.Get() -var v16 lang.FnFunc -v16 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v17 := args[0] -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("apply")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +var v44 any +switch reflect.TypeOf(v43).Kind() { +case reflect.Func: + v44 = lang.Apply(v43, nil) +default: + v44 = v43 } -v20 := v19.Get() -v21 := lang.Apply(v20, []any{v3, v17}) -return v21 -}) -v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2766), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(2766), lang.NewKeyword("end-column"), int(22)) -v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) +var v42 any = v44 +_ = v42 +var v46 any +if lang.IsTruthy(v42) { +var v47 any = v42 +_ = v47 +v49 := lang.NewMap(lang.NewKeyword("cause"), v47) +v50 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(472), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(472), lang.NewKeyword("end-column"), int(25)) +v51, err := lang.WithMeta(v49, v50.(lang.IPersistentMap)) if err != nil { panic(err) } -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("conj")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v46 = v51 +} else { +v46 = nil } -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v7, v6, v5, v4}) -v23 := lang.Apply(v8, []any{v22}) -v24 := lang.Apply(v15, []any{v18, v23}) -return v24 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("ex-data")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) } +v45 := v44.Get() +v46 := lang.Apply(v45, []any{v9}) +var v42 any = v46 +_ = v42 +var v48 any +if lang.IsTruthy(v42) { +var v49 any = v42 +_ = v49 +v51 := lang.NewMap(lang.NewKeyword("data"), v49) +v52 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(474), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(474), lang.NewKeyword("end-column"), int(20)) +v53, err := lang.WithMeta(v51, v52.(lang.IPersistentMap)) +if err != nil { + panic(err) } -// chunk-first -{ -v0 := lang.NewSymbol("chunk-first").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(694), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(694), lang.NewKeyword("end-column"), int(48), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, ok := lang.FieldOrMethod(v3, "chunkedFirst") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "chunkedFirst"))) +v48 = v53 +} else { +v48 = nil } -var v5 any -switch reflect.TypeOf(v4).Kind() { -case reflect.Func: - v5 = lang.Apply(v4, nil) -default: - v5 = v4 +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("ex-data")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) } -return v5 +v45 := v44.Get() +v46 := lang.Apply(v45, []any{v3}) +v47 := lang.Apply(lang.NewKeyword("glojure.error/phase"), []any{v46}) +var v42 any = v47 +_ = v42 +var v49 any +if lang.IsTruthy(v42) { +var v50 any = v42 +_ = v50 +v52 := lang.NewMap(lang.NewKeyword("phase"), v50) +v53 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(476), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(476), lang.NewKeyword("end-column"), int(22)) +v54, err := lang.WithMeta(v52, v53.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v49 = v54 +} else { +v49 = nil +} +v42 := lang.Apply(v17, []any{v41, v46, v48, v49}) +return v42 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -5783,10 +5595,10 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// NaN? +// abs { var v1 lang.FnFunc -{ // function NaN?__inliner +{ // function abs__inliner v1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -5810,7 +5622,7 @@ if v11.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol("math.IsNaN")}) +v13 := lang.Apply(v12, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Abs")}) v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v15 := v14.FindInternedVar(lang.NewSymbol("list")) if v15.IsMacro() { @@ -5825,14 +5637,14 @@ return v19 v2 := v1 _ = v2 } -v0 := lang.NewSymbol("NaN?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns true if num is NaN, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)), lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(8011), lang.NewKeyword("end-line"), int(8011))).(*lang.Symbol) +v0 := lang.NewSymbol("abs").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the absolute value of a.\n If a is Long/MIN_VALUE => Long/MIN_VALUE\n If a is a double and zero => +0.0\n If a is a double and ##Inf or ##-Inf => ##Inf\n If a is a double and ##NaN => ##NaN", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)), lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1128), lang.NewKeyword("end-line"), int(1128))).(*lang.Symbol) var v3 lang.FnFunc v3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5 := lang.Apply(math7.IsNaN, []any{v4}) +v5 := lang.Apply(lang1.Abs, []any{v4}) return v5 }) v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -5841,137 +5653,22 @@ if v0.Meta() != nil { v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// partitionv-all -{ -v0 := lang.NewSymbol("partitionv-all").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of vector partitions, but may include\n partitions with fewer than n items at the end.\n Returns a stateful transducer when no collection is provided.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7328), lang.NewKeyword("end-line"), int(7328))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("partition-all")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{v3}) -return v7 - case 2: -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("partitionv-all")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3, v3, v4}) -return v8 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -var v6 lang.FnFunc -v6 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("seq")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v5}) -var v7 any = v11 -_ = v7 -var v13 any -if lang.IsTruthy(v7) { -var v14 any = v7 -_ = v14 -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("into")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.NewVector() -v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7340), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(7340), lang.NewKeyword("end-column"), int(25)) -v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("take")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{v3}) -v27 := lang.Apply(v19, []any{v22, v26, v5}) -var v16 any = v27 -_ = v16 -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("cons")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("partitionv-all")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("drop")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v4, v14}) -v39 := lang.Apply(v34, []any{v3, v4, v38}) -v40 := lang.Apply(v31, []any{v16, v39}) -v13 = v40 -} else { -v13 = nil -} -return v13 -}) -v7 := lang.Apply(lang1.NewLazySeq, []any{v6}) -return v7 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// error-mode +// accessor { -v0 := lang.NewSymbol("error-mode").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("doc"), "Returns the error-mode of agent a. See set-error-mode!", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2227), lang.NewKeyword("end-line"), int(2227))).(*lang.Symbol) +v0 := lang.NewSymbol("accessor").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("key"))), lang.NewKeyword("doc"), "Returns a fn that, given an instance of a structmap with the basis,\n returns the value at the key. The key must be in the basis. The\n returned function should be (slightly) more efficient than using\n get, but such use of accessors should be limited to known\n performance-critical areas.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4070), lang.NewKeyword("end-line"), int(4070))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { + if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4, ok := lang.FieldOrMethod(v3, "getErrorMode") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getErrorMode"))) -} -var v5 any -switch reflect.TypeOf(v4).Kind() { -case reflect.Func: - v5 = lang.Apply(v4, nil) -default: - v5 = v4 +v4 := args[1] +v5, _ := lang.FieldOrMethod(glojure.lang8.PersistentStructMap, "getAccessor") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getAccessor is not a function"))) } -return v5 +v6 := lang.Apply(v5, []any{v3, v4}) +return v6 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -5979,1136 +5676,943 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// bigdec -{ -v1 := reflect.TypeOf((*lang1.BigDecimal)(nil)) -v0 := lang.NewSymbol("bigdec").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Coerce to BigDecimal", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3648), lang.NewKeyword("end-line"), int(3648))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("decimal?")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v4}) -if lang.IsTruthy(v9) { -v5 = v4 -} else { -var v10 any -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("float?")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v4}) -if lang.IsTruthy(v14) { -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("double")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v4}) -v19 := lang.Apply(lang1.NewBigDecimalFromFloat64, []any{v18}) -v10 = v19 -} else { -var v20 any -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("ratio?")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v4}) -if lang.IsTruthy(v24) { -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("/")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28, ok := lang.FieldOrMethod(v4, "numerator") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "numerator"))) -} -var v29 any -switch reflect.TypeOf(v28).Kind() { -case reflect.Func: - v29 = lang.Apply(v28, nil) -default: - v29 = v28 -} -v30 := lang.Apply(BigDecimal8., []any{v29}) -v31, ok := lang.FieldOrMethod(v4, "denominator") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "denominator"))) -} -var v32 any -switch reflect.TypeOf(v31).Kind() { -case reflect.Func: - v32 = lang.Apply(v31, nil) -default: - v32 = v31 -} -v33 := lang.Apply(v27, []any{v30, v32}) -v20 = v33 -} else { -var v34 any -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("instance?")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.Apply(v37, []any{lang1.*BigInt, v4}) -if lang.IsTruthy(v38) { -v39, ok := lang.FieldOrMethod(v4, "toBigDecimal") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "toBigDecimal"))) -} -var v40 any -switch reflect.TypeOf(v39).Kind() { -case reflect.Func: - v40 = lang.Apply(v39, nil) -default: - v40 = v39 -} -v34 = v40 -} else { -var v41 any -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("instance?")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) -} -v44 := v43.Get() -v45 := lang.Apply(v44, []any{big9.*Int, v4}) -if lang.IsTruthy(v45) { -v46 := lang.Apply(BigDecimal8., []any{v4}) -v41 = v46 -} else { -var v47 any -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("number?")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v4}) -if lang.IsTruthy(v51) { -v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("long")) -if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) -} -v54 := v53.Get() -v55 := lang.Apply(v54, []any{v4}) -v56 := lang.Apply(lang1.NewBigDecimalFromInt64, []any{v55}) -v47 = v56 -} else { -var v57 any -if lang.IsTruthy(lang.NewKeyword("else")) { -v58 := lang.Apply(BigDecimal8., []any{v4}) -v57 = v58 -} else { -v57 = nil -} -v47 = v57 -} -v41 = v47 -} -v34 = v41 -} -v20 = v34 -} -v10 = v20 -} -v5 = v10 -} -return v5 -}) -v4 := reflect.TypeOf((*lang1.BigDecimal)(nil)) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// fits-table? +// aclone { -v0 := lang.NewSymbol("fits-table?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ints"))), lang.NewKeyword("doc"), "Returns true if the collection of ints can fit within the\n max-table-switch-size, false otherwise.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6668), lang.NewKeyword("end-line"), int(6668), lang.NewKeyword("private"), true)).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { +var v1 lang.FnFunc +{ // function aclone__inliner +v1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("<")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("-")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) if v8.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } v9 := v8.Get() v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("apply")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) if v11.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("max")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("seq")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v3}) -v20 := lang.Apply(v12, []any{v15, v19}) +v20 := v19.Get() v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("apply")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) if v22.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } v23 := v22.Get() v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("min")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) if v25.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } v26 := v25.Get() v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("seq")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) if v28.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } v29 := v28.Get() -v30 := lang.Apply(v29, []any{v3}) -v31 := lang.Apply(v23, []any{v26, v30}) -v32 := lang.Apply(v9, []any{v20, v31}) -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("max-switch-table-size")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/Aclone")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -v35 := v34.Get() -v36 := lang.Apply(v6, []any{v32, v35}) -return v36 +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v3}) +v35 := lang.Apply(v26, []any{v30, v34}) +v36 := lang.Apply(v23, []any{v35}) +v37 := lang.Apply(v20, []any{v36}) +v38 := lang.Apply(v9, []any{v13, v17, v37}) +v39 := lang.Apply(v6, []any{v38}) +return v39 }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} +v2 := v1 +_ = v2 } -// transient -{ -v0 := lang.NewSymbol("transient").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a new, transient version of the collection, in constant time.\n\n Transients support a parallel set of 'changing' operations, with similar names\n followed by ! - assoc!, conj! etc. These do the same things as their persistent\n counterparts except the return values are themselves transient.\n\n Note in particular that transients are not designed to be bashed in-place. You\n must capture and use the return value in the next call. In this way, they support\n the same code structure as the functional persistent code they replace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3335), lang.NewKeyword("end-line"), int(3335))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { +v0 := lang.NewSymbol("aclone").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns a clone of the Java array. Works on arrays of known\n types.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3904), lang.NewKeyword("end-line"), int(3904))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := args[0] -v4, ok := lang.FieldOrMethod(v3, "AsTransient") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "AsTransient"))) -} -var v5 any -switch reflect.TypeOf(v4).Kind() { -case reflect.Func: - v5 = lang.Apply(v4, nil) -default: - v5 = v4 +v4 := args[0] +v5, _ := lang.FieldOrMethod(runtime9.RT, "Aclone") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Aclone is not a function"))) } -return v5 +v6 := lang.Apply(v5, []any{v4}) +return v6 }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// StackTraceElement->vec +// add-annotation { -v0 := lang.NewSymbol("StackTraceElement->vec").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"))), lang.NewKeyword("doc"), "Constructs a data representation for a StackTraceElement: [class method file line]", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(436), lang.NewKeyword("end-line"), int(436))).(*lang.Symbol) +v0 := lang.NewSymbol("add-annotation").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5485), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(5485), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("av"), lang.NewSymbol("name"), lang.NewSymbol("v"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { + if len(args) != 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("symbol")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7, ok := lang.FieldOrMethod(v3, "getClassName") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getClassName"))) -} -var v8 any -switch reflect.TypeOf(v7).Kind() { -case reflect.Func: - v8 = lang.Apply(v7, nil) -default: - v8 = v7 +v4 := args[1] +v5 := args[2] +var v6 any +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("vector?")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v9 := lang.Apply(v6, []any{v8}) -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("symbol")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v5}) +if lang.IsTruthy(v10) { +v12, _ := lang.FieldOrMethod(v3, "visitArray") +if reflect.TypeOf(v12).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("visitArray is not a function"))) } -v12 := v11.Get() -v13, ok := lang.FieldOrMethod(v3, "getMethodName") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getMethodName"))) +v13 := lang.Apply(v12, []any{v4}) +var v11 any = v13 +_ = v11 +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("seq")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -var v14 any -switch reflect.TypeOf(v13).Kind() { -case reflect.Func: - v14 = lang.Apply(v13, nil) -default: - v14 = v13 +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v5}) +var v15 any = v19 +_ = v15 +var v20 any = nil +_ = v20 +var v21 any = int64(0) +_ = v21 +var v22 any = int64(0) +_ = v22 +var v23 any +for { +var v24 any +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("<")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -v15 := lang.Apply(v12, []any{v14}) -v16, ok := lang.FieldOrMethod(v3, "getFileName") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getFileName"))) +v27 := v26.Get() +v28 := lang.Apply(v27, []any{v22, v21}) +if lang.IsTruthy(v28) { +v30, _ := lang.FieldOrMethod(v20, "nth") +if reflect.TypeOf(v30).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) } -var v17 any -switch reflect.TypeOf(v16).Kind() { -case reflect.Func: - v17 = lang.Apply(v16, nil) -default: - v17 = v16 +v31 := lang.Apply(v30, []any{v22}) +var v29 any = v31 +_ = v29 +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("add-annotation")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) } -v18, ok := lang.FieldOrMethod(v3, "getLineNumber") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getLineNumber"))) +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v11, "value", v29}) +_ = v36 +var v37 any = v15 +var v38 any = v20 +var v39 any = v21 +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("unchecked-inc")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } -var v19 any -switch reflect.TypeOf(v18).Kind() { -case reflect.Func: - v19 = lang.Apply(v18, nil) -default: - v19 = v18 +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v22}) +var v40 any = v44 +v15 = v37 +v20 = v38 +v21 = v39 +v22 = v40 +continue +} else { +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("seq")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) } -v20 := lang.NewVector(v9, v15, v17, v19) -v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(440), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(440), lang.NewKeyword("end-column"), int(94)) -v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) -if err != nil { - panic(err) +v32 := v31.Get() +v33 := lang.Apply(v32, []any{v15}) +var v29 any = v33 +_ = v29 +var v35 any +if lang.IsTruthy(v29) { +var v36 any = v29 +_ = v36 +var v38 any +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("chunked-seq?")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) } -return v22 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v41 := v40.Get() +v42 := lang.Apply(v41, []any{v36}) +if lang.IsTruthy(v42) { +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("chunk-first")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v36}) +var v43 any = v47 +_ = v43 +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("chunk-rest")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) } -// conj -{ -v0 := lang.NewSymbol("conj").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("xs"))), lang.NewKeyword("doc"), "conj[oin]. Returns a new collection with the xs\n 'added'. (conj nil item) returns (item).\n (conj coll) returns coll. (conj) returns [].\n The 'addition' may happen at different 'places' depending\n on the concrete type.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(73), lang.NewKeyword("end-line"), int(81))).(*lang.Symbol) -var v2 lang.FnFunc -{ // function conj -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v4 := lang.NewVector() -v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(82), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(82), lang.NewKeyword("end-column"), int(14)) -v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) -if err != nil { - panic(err) +v52 := v51.Get() +v53 := lang.Apply(v52, []any{v36}) +var v49 any = v53 +var v54 any = v43 +v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v57 := v56.FindInternedVar(lang.NewSymbol("int")) +if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) } -return v6 - case 1: -v4 := args[0] -return v4 - case 2: -v4 := args[0] -v5 := args[1] -v6 := lang.Apply(lang1.Conj, []any{v4, v5}) -return v6 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6 := lang.NewList(args[2:]...) -recur_loop_10: -var v7 any -if lang.IsTruthy(v6) { -v9 := lang.Apply(lang1.Conj, []any{v4, v5}) -var v8 any = v9 -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("first")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v58 := v57.Get() +v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v60 := v59.FindInternedVar(lang.NewSymbol("count")) +if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) } -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v6}) -var v10 any = v14 -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("next")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +v61 := v60.Get() +v62 := lang.Apply(v61, []any{v43}) +v63 := lang.Apply(v58, []any{v62}) +var v55 any = v63 +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("int")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) } -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v6}) -var v15 any = v19 -v4 = v8 -v5 = v10 -v6 = v15 -goto recur_loop_10 +v67 := v66.Get() +v68 := lang.Apply(v67, []any{int64(0)}) +var v64 any = v68 +v15 = v49 +v20 = v54 +v21 = v55 +v22 = v64 +continue } else { -v20 := lang.Apply(lang1.Conj, []any{v4, v5}) -v7 = v20 -} -return v7 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(81), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(88), lang.NewKeyword("end-column"), int(67))).(lang.FnFunc) -v3 := v2 -_ = v3 -} -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("first")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } -// remove-watch -{ -v0 := lang.NewSymbol("remove-watch").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("reference"), lang.NewSymbol("key"))), lang.NewKeyword("doc"), "Removes a watch (set by add-watch) from a reference", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2160), lang.NewKeyword("end-line"), int(2160))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5, _ := lang.FieldOrMethod(v3, "removeWatch") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("removeWatch is not a function"))) +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v36}) +var v43 any = v47 +_ = v43 +v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v50 := v49.FindInternedVar(lang.NewSymbol("add-annotation")) +if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) } -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v51 := v50.Get() +v52 := lang.Apply(v51, []any{v11, "value", v43}) +_ = v52 +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("next")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) } +v56 := v55.Get() +v57 := lang.Apply(v56, []any{v36}) +var v53 any = v57 +var v58 any = nil +var v59 any = int64(0) +var v60 any = int64(0) +v15 = v53 +v20 = v58 +v21 = v59 +v22 = v60 +continue } -// ensure -{ -v0 := lang.NewSymbol("ensure").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref"))), lang.NewKeyword("doc"), "Must be called in a transaction. Protects the ref from modification\n by other transactions. Returns the in-transaction-value of\n ref. Allows for more concurrency than (ref-set ref @ref)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2480), lang.NewKeyword("end-line"), int(2480))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, _ := lang.FieldOrMethod(v3, "touch") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("touch is not a function"))) +v35 = v38 +} else { +v35 = nil } -v5 := lang.Apply(v4, []any{}) -_ = v5 -v6, _ := lang.FieldOrMethod(v3, "deref") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("deref is not a function"))) +v24 = v35 } -v7 := lang.Apply(v6, []any{}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v23 = v24 + break } +_ = v23 +v15, ok := lang.FieldOrMethod(v11, "visitEnd") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v11, "visitEnd"))) } -// +' -{ -var v1 lang.FnFunc -v1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v2 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +var v16 any +switch reflect.TypeOf(v15).Kind() { +case reflect.Func: + v16 = lang.Apply(v15, nil) +default: + v16 = v15 } -v7 := v6.Get() -if lang.IsTruthy(v7) { -v4 = closed0 +v6 = v16 } else { -v4 = v3 -} -var v3 any = v4 -_ = v3 -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("seq")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() +var v11 any v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("concat")) +v13 := v12.FindInternedVar(lang.NewSymbol("symbol?")) if v13.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v15 := lang.Apply(v14, []any{v5}) +if lang.IsTruthy(v15) { +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("eval")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v21 := v20.Get() -v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v5}) +var v16 any = v20 +_ = v16 +var v22 any v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) +v24 := v23.FindInternedVar(lang.NewSymbol("instance?")) if v24.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("seq")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("concat")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +v26 := lang.Apply(v25, []any{java.lang10.Enum, v16}) +if lang.IsTruthy(v26) { +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("descriptor")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +v29 := v28.Get() +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("class")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) } -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +v32 := v31.Get() +v33 := lang.Apply(v32, []any{v16}) +v34 := lang.Apply(v29, []any{v33}) +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("str")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) } -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v2}) -v40 := lang.Apply(v31, []any{v35, v39}) -v41 := lang.Apply(v28, []any{v40}) -v42 := lang.Apply(v25, []any{v41}) -v43 := lang.Apply(v14, []any{v18, v22, v42}) -v44 := lang.Apply(v11, []any{v43}) -return v44 - case 2: -v2 := args[0] -v3 := args[1] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +v37 := v36.Get() +v38 := lang.Apply(v37, []any{v16}) +v39, _ := lang.FieldOrMethod(v3, "visitEnum") +if reflect.TypeOf(v39).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("visitEnum is not a function"))) } -v8 := v7.Get() -if lang.IsTruthy(v8) { -v5 = closed0 +v40 := lang.Apply(v39, []any{v4, v34, v38}) +v22 = v40 } else { -v5 = v4 -} -var v4 any = v5 -_ = v4 -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("seq")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("concat")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("list")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("list")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("list")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +var v41 any +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("class?")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) } -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("seq")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v44 := v43.Get() +v45 := lang.Apply(v44, []any{v16}) +if lang.IsTruthy(v45) { +v46 := lang.Apply(nil, []any{v16}) +v47, _ := lang.FieldOrMethod(v3, "visit") +if reflect.TypeOf(v47).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("visit is not a function"))) } -v29 := v28.Get() -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("concat")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +v48 := lang.Apply(v47, []any{v4, v46}) +v41 = v48 +} else { +var v49 any +if lang.IsTruthy(lang.NewKeyword("else")) { +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("str")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) } -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("list")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +v52 := v51.Get() +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("class")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) } -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v4}) -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("list")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +v55 := v54.Get() +v56 := lang.Apply(v55, []any{v16}) +v57 := lang.Apply(v52, []any{"Unsupported annotation value: ", v5, " of class ", v56}) +v58 := lang.Apply(lang1.NewIllegalArgumentError, []any{v57}) +panic(v58) +} else { +v49 = nil } -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v2}) -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("list")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +v41 = v49 } -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v3}) -v45 := lang.Apply(v32, []any{v36, v40, v44}) -v46 := lang.Apply(v29, []any{v45}) -v47 := lang.Apply(v26, []any{v46}) -v48 := lang.Apply(v15, []any{v19, v23, v47}) -v49 := lang.Apply(v12, []any{v48}) -return v49 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v2 := args[0] -v3 := args[1] -v4 := lang.NewList(args[2:]...) -var v6 any -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v22 = v41 } -v9 := v8.Get() -if lang.IsTruthy(v9) { -v6 = closed0 +v11 = v22 } else { -v6 = v5 -} -var v5 any = v6 -_ = v5 -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -var v14 lang.FnFunc -v14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v15 := args[0] -v16 := args[1] +var v16 any v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq?")) if v18.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("concat")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() +v20 := lang.Apply(v19, []any{v5}) +if lang.IsTruthy(v20) { +var v21 any = v5 +_ = v21 v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) +v24 := v23.FindInternedVar(lang.NewSymbol("nth")) if v24.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v5}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v15}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v16}) -v52 := lang.Apply(v39, []any{v43, v47, v51}) -v53 := lang.Apply(v36, []any{v52}) -v54 := lang.Apply(v33, []any{v53}) -v55 := lang.Apply(v22, []any{v26, v30, v54}) -v56 := lang.Apply(v19, []any{v55}) -return v56 -}) -v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) -v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) -if err != nil { - panic(err) +v26 := lang.Apply(v25, []any{v21, int64(0), nil}) +var v22 any = v26 +_ = v22 +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("nth")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +v30 := v29.Get() +v31 := lang.Apply(v30, []any{v21, int64(1), nil}) +var v27 any = v31 +_ = v27 +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("resolve")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) } -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("concat")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v22}) +var v32 any = v36 +_ = v32 +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("descriptor")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) } -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +v40 := v39.Get() +v41 := lang.Apply(v40, []any{v32}) +v42, _ := lang.FieldOrMethod(v3, "visitAnnotation") +if reflect.TypeOf(v42).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("visitAnnotation is not a function"))) } -v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v43 := lang.Apply(v42, []any{v4, v41}) +var v37 any = v43 +_ = v37 +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("process-annotation")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) } -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v47 := v46.Get() +v48 := lang.Apply(v47, []any{v37, v27}) +_ = v48 +v49, ok := lang.FieldOrMethod(v37, "visitEnd") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v37, "visitEnd"))) } -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +var v50 any +switch reflect.TypeOf(v49).Kind() { +case reflect.Func: + v50 = lang.Apply(v49, nil) +default: + v50 = v49 } -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +v16 = v50 +} else { +var v21 any +if lang.IsTruthy(lang.NewKeyword("else")) { +v22, _ := lang.FieldOrMethod(v3, "visit") +if reflect.TypeOf(v22).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("visit is not a function"))) } -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +v23 := lang.Apply(v22, []any{v4, v5}) +v21 = v23 +} else { +v21 = nil } -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v5}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +v16 = v21 } -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v2}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +v11 = v16 } -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v3}) -v52 := lang.Apply(v39, []any{v43, v47, v51}) -v53 := lang.Apply(v36, []any{v52}) -v54 := lang.Apply(v33, []any{v53}) -v55 := lang.Apply(v22, []any{v26, v30, v54}) -v56 := lang.Apply(v19, []any{v55}) -v57 := lang.Apply(v13, []any{v16, v56, v4}) -return v57 - } -}) -v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) +v6 = v11 } -v5 := lang.Apply(v4, []any{v3, int64(1)}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v0 := lang.NewSymbol("+'").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the sum of nums. (+') returns 0. Supports arbitrary precision.\n See also: +", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(965), lang.NewKeyword("end-line"), int(965))).(*lang.Symbol) -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -return int64(0) - case 1: -v5 := args[0] -v6 := lang.Apply(lang1.MustAsNumber, []any{v5}) return v6 - case 2: -v5 := args[0] -v6 := args[1] -v7, _ := lang.FieldOrMethod(lang1.Numbers, "addP") -if reflect.TypeOf(v7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("addP is not a function"))) -} -v8 := lang.Apply(v7, []any{v5, v6}) -return v8 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := args[0] -v6 := args[1] -v7 := lang.NewList(args[2:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("+'")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("+'")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v5, v6}) -v18 := lang.Apply(v10, []any{v13, v17, v7}) -return v18 - } }) -v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v3 := ns.InternWithValue(v0, v4, true) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { - v3.SetMeta(v0.Meta().(lang.IPersistentMap)) + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// await +// add-annotations { -v0 := lang.NewSymbol("await").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("agents"))), lang.NewKeyword("doc"), "Blocks the current thread (indefinitely!) until all actions\n dispatched thus far, from this thread or agent, to the agent(s) have\n occurred. Will block on failed agents. Will never return if\n a failed agent is restarted with :clear-actions true or shutdown-agents was called.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3267), lang.NewKeyword("end-line"), int(3267))).(*lang.Symbol) +v0 := lang.NewSymbol("add-annotations").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5511), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(5511), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("visitor"), lang.NewSymbol("m")), lang.NewVector(lang.NewSymbol("visitor"), lang.NewSymbol("m"), lang.NewSymbol("i"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewList(args[0:]...) -var v4 any -v5 := lang.Apply(nil, nil) -if lang.IsTruthy(v5) { -panic("unimplemented: new with non-constant class type") -} else { -var v6 any + case 2: +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("add-annotations")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3, v4, nil}) +return v8 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("*agent*")) +v8 := v7.FindInternedVar(lang.NewSymbol("seq")) if v8.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } v9 := v8.Get() -if lang.IsTruthy(v9) { -v10 := lang.Apply(errors10.New, []any{"Can't await in agent action"}) -panic(v10) -} else { -v6 = nil -} +v10 := lang.Apply(v9, []any{v4}) +var v6 any = v10 _ = v6 -var v11 any = "unimplemented: new with non-constant class type" +var v11 any = nil _ = v11 -var v13 lang.FnFunc -v13 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v14 := args[0] -v15, _ := lang.FieldOrMethod(v11, "countDown") -if reflect.TypeOf(v15).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("countDown is not a function"))) -} -v16 := lang.Apply(v15, []any{}) -_ = v16 -return v14 -}) -v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3279), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(3279), lang.NewKeyword("end-column"), int(61)) -v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v12 any = v15 +var v12 any = int64(0) _ = v12 -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("seq")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v20, []any{v3}) -var v17 any = v21 -_ = v17 -var v22 any = nil -_ = v22 -var v23 any = int64(0) -_ = v23 -var v24 any = int64(0) -_ = v24 -var v25 any +var v13 any = int64(0) +_ = v13 +var v14 any for { -var v26 any -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("<")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +var v15 any +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("<")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -v29 := v28.Get() -v30 := lang.Apply(v29, []any{v24, v23}) -if lang.IsTruthy(v30) { -v32, _ := lang.FieldOrMethod(v22, "nth") -if reflect.TypeOf(v32).Kind() != reflect.Func { +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v13, v12}) +if lang.IsTruthy(v19) { +v21, _ := lang.FieldOrMethod(v11, "nth") +if reflect.TypeOf(v21).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) } -v33 := lang.Apply(v32, []any{v24}) -var v31 any = v33 -_ = v31 +v22 := lang.Apply(v21, []any{v13}) +var v20 any = v22 +_ = v20 +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("nth")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v20, int64(0), nil}) +var v23 any = v27 +_ = v23 +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("nth")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.Apply(v31, []any{v20, int64(1), nil}) +var v28 any = v32 +_ = v28 +var v34 any v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("send")) +v36 := v35.FindInternedVar(lang.NewSymbol("symbol?")) if v36.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) } v37 := v36.Get() -v38 := lang.Apply(v37, []any{v31, v12}) -_ = v38 -var v39 any = v17 -var v40 any = v22 -var v41 any = v23 +v38 := lang.Apply(v37, []any{v23}) +if lang.IsTruthy(v38) { +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("resolve")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v23}) +var v39 any = v43 +_ = v39 +var v45 any +if lang.IsTruthy(v39) { +var v46 any = v39 +_ = v46 +var v48 any +v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v50 := v49.FindInternedVar(lang.NewSymbol("is-annotation?")) +if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) +} +v51 := v50.Get() +v52 := lang.Apply(v51, []any{v46}) +if lang.IsTruthy(v52) { +var v54 any +if lang.IsTruthy(v5) { +v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v56 := v55.FindInternedVar(lang.NewSymbol("descriptor")) +if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) +} +v57 := v56.Get() +v58 := lang.Apply(v57, []any{v46}) +v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v60 := v59.FindInternedVar(lang.NewSymbol("is-runtime-annotation?")) +if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) +} +v61 := v60.Get() +v62 := lang.Apply(v61, []any{v46}) +v63, _ := lang.FieldOrMethod(v3, "visitParameterAnnotation") +if reflect.TypeOf(v63).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("visitParameterAnnotation is not a function"))) +} +v64 := lang.Apply(v63, []any{v5, v58, v62}) +v54 = v64 +} else { +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("descriptor")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +} +v67 := v66.Get() +v68 := lang.Apply(v67, []any{v46}) +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("is-runtime-annotation?")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +} +v71 := v70.Get() +v72 := lang.Apply(v71, []any{v46}) +v73, _ := lang.FieldOrMethod(v3, "visitAnnotation") +if reflect.TypeOf(v73).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("visitAnnotation is not a function"))) +} +v74 := lang.Apply(v73, []any{v68, v72}) +v54 = v74 +} +var v53 any = v54 +_ = v53 +v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v77 := v76.FindInternedVar(lang.NewSymbol("process-annotation")) +if v77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) +} +v78 := v77.Get() +v79 := lang.Apply(v78, []any{v53, v28}) +_ = v79 +v80, ok := lang.FieldOrMethod(v53, "visitEnd") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v53, "visitEnd"))) +} +var v81 any +switch reflect.TypeOf(v80).Kind() { +case reflect.Func: + v81 = lang.Apply(v80, nil) +default: + v81 = v80 +} +v48 = v81 +} else { +v48 = nil +} +v45 = v48 +} else { +v45 = nil +} +v34 = v45 +} else { +v34 = nil +} +_ = v34 +var v39 any = v6 +var v40 any = v11 +var v41 any = v12 v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v44 := v43.FindInternedVar(lang.NewSymbol("unchecked-inc")) if v44.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) } v45 := v44.Get() -v46 := lang.Apply(v45, []any{v24}) +v46 := lang.Apply(v45, []any{v13}) var v42 any = v46 -v17 = v39 -v22 = v40 -v23 = v41 -v24 = v42 +v6 = v39 +v11 = v40 +v12 = v41 +v13 = v42 continue } else { -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("seq")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v17}) -var v31 any = v35 -_ = v31 -var v37 any -if lang.IsTruthy(v31) { -var v38 any = v31 -_ = v38 -var v40 any +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v6}) +var v20 any = v24 +_ = v20 +var v26 any +if lang.IsTruthy(v20) { +var v27 any = v20 +_ = v27 +var v29 any +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("chunked-seq?")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.Apply(v32, []any{v27}) +if lang.IsTruthy(v33) { +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("chunk-first")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v37, []any{v27}) +var v34 any = v38 +_ = v34 v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("chunked-seq?")) +v42 := v41.FindInternedVar(lang.NewSymbol("chunk-rest")) if v42.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } v43 := v42.Get() -v44 := lang.Apply(v43, []any{v38}) -if lang.IsTruthy(v44) { -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("chunk-first")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) -} -v48 := v47.Get() -v49 := lang.Apply(v48, []any{v38}) -var v45 any = v49 -_ = v45 -v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("chunk-rest")) -if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) -} -v54 := v53.Get() -v55 := lang.Apply(v54, []any{v38}) -var v51 any = v55 -var v56 any = v45 -v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v59 := v58.FindInternedVar(lang.NewSymbol("int")) -if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) +v44 := lang.Apply(v43, []any{v27}) +var v40 any = v44 +var v45 any = v34 +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("int")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) } -v60 := v59.Get() -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("count")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +v49 := v48.Get() +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("count")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) } -v63 := v62.Get() -v64 := lang.Apply(v63, []any{v45}) -v65 := lang.Apply(v60, []any{v64}) -var v57 any = v65 -v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v68 := v67.FindInternedVar(lang.NewSymbol("int")) -if v68.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) +v52 := v51.Get() +v53 := lang.Apply(v52, []any{v34}) +v54 := lang.Apply(v49, []any{v53}) +var v46 any = v54 +v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v57 := v56.FindInternedVar(lang.NewSymbol("int")) +if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) } -v69 := v68.Get() -v70 := lang.Apply(v69, []any{int64(0)}) -var v66 any = v70 -v17 = v51 -v22 = v56 -v23 = v57 -v24 = v66 +v58 := v57.Get() +v59 := lang.Apply(v58, []any{int64(0)}) +var v55 any = v59 +v6 = v40 +v11 = v45 +v12 = v46 +v13 = v55 continue } else { -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("first")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("first")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) } -v48 := v47.Get() -v49 := lang.Apply(v48, []any{v38}) -var v45 any = v49 -_ = v45 +v37 := v36.Get() +v38 := lang.Apply(v37, []any{v27}) +var v34 any = v38 +_ = v34 +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("nth")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v34, int64(0), nil}) +var v39 any = v43 +_ = v39 +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("nth")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +} +v47 := v46.Get() +v48 := lang.Apply(v47, []any{v34, int64(1), nil}) +var v44 any = v48 +_ = v44 +var v50 any v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v52 := v51.FindInternedVar(lang.NewSymbol("send")) +v52 := v51.FindInternedVar(lang.NewSymbol("symbol?")) if v52.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) } v53 := v52.Get() -v54 := lang.Apply(v53, []any{v45, v12}) -_ = v54 +v54 := lang.Apply(v53, []any{v39}) +if lang.IsTruthy(v54) { +v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v57 := v56.FindInternedVar(lang.NewSymbol("resolve")) +if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) +} +v58 := v57.Get() +v59 := lang.Apply(v58, []any{v39}) +var v55 any = v59 +_ = v55 +var v61 any +if lang.IsTruthy(v55) { +var v62 any = v55 +_ = v62 +var v64 any +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("is-annotation?")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +} +v67 := v66.Get() +v68 := lang.Apply(v67, []any{v62}) +if lang.IsTruthy(v68) { +var v70 any +if lang.IsTruthy(v5) { +v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v72 := v71.FindInternedVar(lang.NewSymbol("descriptor")) +if v72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) +} +v73 := v72.Get() +v74 := lang.Apply(v73, []any{v62}) +v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v76 := v75.FindInternedVar(lang.NewSymbol("is-runtime-annotation?")) +if v76.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) +} +v77 := v76.Get() +v78 := lang.Apply(v77, []any{v62}) +v79, _ := lang.FieldOrMethod(v3, "visitParameterAnnotation") +if reflect.TypeOf(v79).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("visitParameterAnnotation is not a function"))) +} +v80 := lang.Apply(v79, []any{v5, v74, v78}) +v70 = v80 +} else { +v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v82 := v81.FindInternedVar(lang.NewSymbol("descriptor")) +if v82.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) +} +v83 := v82.Get() +v84 := lang.Apply(v83, []any{v62}) +v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v86 := v85.FindInternedVar(lang.NewSymbol("is-runtime-annotation?")) +if v86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) +} +v87 := v86.Get() +v88 := lang.Apply(v87, []any{v62}) +v89, _ := lang.FieldOrMethod(v3, "visitAnnotation") +if reflect.TypeOf(v89).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("visitAnnotation is not a function"))) +} +v90 := lang.Apply(v89, []any{v84, v88}) +v70 = v90 +} +var v69 any = v70 +_ = v69 +v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v93 := v92.FindInternedVar(lang.NewSymbol("process-annotation")) +if v93.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) +} +v94 := v93.Get() +v95 := lang.Apply(v94, []any{v69, v44}) +_ = v95 +v96, ok := lang.FieldOrMethod(v69, "visitEnd") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v69, "visitEnd"))) +} +var v97 any +switch reflect.TypeOf(v96).Kind() { +case reflect.Func: + v97 = lang.Apply(v96, nil) +default: + v97 = v96 +} +v64 = v97 +} else { +v64 = nil +} +v61 = v64 +} else { +v61 = nil +} +v50 = v61 +} else { +v50 = nil +} +_ = v50 v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v57 := v56.FindInternedVar(lang.NewSymbol("next")) if v57.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) } v58 := v57.Get() -v59 := lang.Apply(v58, []any{v38}) +v59 := lang.Apply(v58, []any{v27}) var v55 any = v59 var v60 any = nil var v61 any = int64(0) var v62 any = int64(0) -v17 = v55 -v22 = v60 -v23 = v61 -v24 = v62 +v6 = v55 +v11 = v60 +v12 = v61 +v13 = v62 continue } -v37 = v40 +v26 = v29 } else { -v37 = nil +v26 = nil } -v26 = v37 +v15 = v26 } -v25 = v26 +v14 = v15 break } -_ = v25 -v17, _ := lang.FieldOrMethod(v11, "await") -if reflect.TypeOf(v17).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) -} -v18 := lang.Apply(v17, []any{}) -v4 = v18 -} -return v4 +return v14 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -7117,230 +6621,70 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// nary-inline +// add-classpath { -v0 := lang.NewSymbol("nary-inline").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(948), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(948), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("op")), lang.NewVector(lang.NewSymbol("op"), lang.NewSymbol("unchecked-op"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v0 := lang.NewSymbol("add-classpath").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("url"))), lang.NewKeyword("doc"), "DEPRECATED \n\n Adds the url (String or URL object) to the classpath per\n URLClassLoader.addURL", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("deprecated"), "1.1", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5176), lang.NewKeyword("end-line"), int(5176))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("nary-inline")) +v5 := v4.FindInternedVar(lang.NewSymbol("println")) if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -v7 := lang.Apply(v6, []any{v3, v3}) -return v7 - case 2: +v7 := lang.Apply(v6, []any{"WARNING: add-classpath is deprecated"}) +_ = v7 +v8 := lang.Apply(nil, []any{v3}) +return v8 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// add-doc-and-meta +{ +v0 := lang.NewSymbol("add-doc-and-meta").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("docstring"), lang.NewSymbol("meta"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(26), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6443), lang.NewKeyword("end-line"), int(6443), lang.NewKeyword("private"), true)).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 5 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] v4 := args[1] -var v5 lang.FnFunc -v5 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v6 := args[0] -var v8 any -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +v5 := args[2] +v6 := args[3] +v7 := args[4] +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("seq")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v11 := v10.Get() -if lang.IsTruthy(v11) { -v8 = v4 -} else { -v8 = v7 +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("concat")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -var v7 any = v8 -_ = v7 -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("seq")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("concat")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{lang.NewSymbol(".")}) -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("seq")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("concat")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v7}) -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v6}) -v44 := lang.Apply(v35, []any{v39, v43}) -v45 := lang.Apply(v32, []any{v44}) -v46 := lang.Apply(v29, []any{v45}) -v47 := lang.Apply(v18, []any{v22, v26, v46}) -v48 := lang.Apply(v15, []any{v47}) -return v48 - case 2: -v6 := args[0] -v7 := args[1] -var v9 any -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -if lang.IsTruthy(v12) { -v9 = v4 -} else { -v9 = v8 -} -var v8 any = v9 -_ = v8 +v13 := v12.Get() v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("seq")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) if v15.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } v16 := v15.Get() -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("concat")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("list")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.Apply(v22, []any{lang.NewSymbol(".")}) -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("list")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v26, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("list")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("seq")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("concat")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("list")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v8}) -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("list")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v6}) -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("list")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.Apply(v47, []any{v7}) -v49 := lang.Apply(v36, []any{v40, v44, v48}) -v50 := lang.Apply(v33, []any{v49}) -v51 := lang.Apply(v30, []any{v50}) -v52 := lang.Apply(v19, []any{v23, v27, v51}) -v53 := lang.Apply(v16, []any{v52}) -return v53 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v6 := args[0] -v7 := args[1] -v8 := lang.NewList(args[2:]...) -var v10 any -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -if lang.IsTruthy(v13) { -v10 = v4 -} else { -v10 = v9 -} -var v9 any = v10 -_ = v9 -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("reduce1")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +v17 := lang.Apply(v16, []any{lang.NewSymbol("glojure.core/alter-meta!")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v17 := v16.Get() -var v18 lang.FnFunc -v18 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v19 := args[0] -v20 := args[1] +v20 := v19.Get() v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v22 := v21.FindInternedVar(lang.NewSymbol("seq")) if v22.IsMacro() { @@ -7359,148 +6703,100 @@ if v28.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol(".")}) +v30 := lang.Apply(v29, []any{lang.NewSymbol("var")}) v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v32 := v31.FindInternedVar(lang.NewSymbol("list")) if v32.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } v33 := v32.Get() -v34 := lang.Apply(v33, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("list")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() +v34 := lang.Apply(v33, []any{v5}) +v35 := lang.Apply(v26, []any{v30, v34}) +v36 := lang.Apply(v23, []any{v35}) +v37 := lang.Apply(v20, []any{v36}) v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("seq")) +v39 := v38.FindInternedVar(lang.NewSymbol("list")) if v39.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) } v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("concat")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +v41 := lang.Apply(v40, []any{lang.NewSymbol("glojure.core/merge")}) +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("list")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) } -v43 := v42.Get() -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +v44 := v43.Get() +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("seq")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) } -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v9}) +v47 := v46.Get() v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) +v49 := v48.FindInternedVar(lang.NewSymbol("concat")) if v49.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) } v50 := v49.Get() -v51 := lang.Apply(v50, []any{v19}) -v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("list")) -if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) -} -v54 := v53.Get() -v55 := lang.Apply(v54, []any{v20}) -v56 := lang.Apply(v43, []any{v47, v51, v55}) -v57 := lang.Apply(v40, []any{v56}) -v58 := lang.Apply(v37, []any{v57}) -v59 := lang.Apply(v26, []any{v30, v34, v58}) -v60 := lang.Apply(v23, []any{v59}) -return v60 -}) -v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) -v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol(".")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("list")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v52 := v51.FindInternedVar(lang.NewSymbol("list")) +if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) } -v37 := v36.Get() -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("seq")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +v53 := v52.Get() +v54 := lang.Apply(v53, []any{lang.NewSymbol("glojure.core/assoc")}) +v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v56 := v55.FindInternedVar(lang.NewSymbol("list")) +if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) } -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("concat")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +v57 := v56.Get() +v58 := lang.Apply(v57, []any{v7}) +v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v60 := v59.FindInternedVar(lang.NewSymbol("list")) +if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) } -v43 := v42.Get() -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +v61 := v60.Get() +v62 := lang.Apply(v61, []any{lang.NewKeyword("doc")}) +v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v64 := v63.FindInternedVar(lang.NewSymbol("list")) +if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) } -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v9}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +v65 := v64.Get() +v66 := lang.Apply(v65, []any{v6}) +v67 := lang.Apply(v50, []any{v54, v58, v62, v66}) +v68 := lang.Apply(v47, []any{v67}) +v69 := lang.Apply(v44, []any{v68}) +v70 := lang.Apply(v13, []any{v17, v37, v41, v69}) +v71 := lang.Apply(v10, []any{v70}) +return v71 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v6}) -v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("list")) -if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) } -v54 := v53.Get() -v55 := lang.Apply(v54, []any{v7}) -v56 := lang.Apply(v43, []any{v47, v51, v55}) -v57 := lang.Apply(v40, []any{v56}) -v58 := lang.Apply(v37, []any{v57}) -v59 := lang.Apply(v26, []any{v30, v34, v58}) -v60 := lang.Apply(v23, []any{v59}) -v61 := lang.Apply(v17, []any{v20, v60, v8}) -return v61 +// add-watch +{ +v0 := lang.NewSymbol("add-watch").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("reference"), lang.NewSymbol("key"), lang.NewSymbol("fn"))), lang.NewKeyword("doc"), "Adds a watch function to an agent/atom/var/ref reference. The watch\n fn must be a fn of 4 args: a key, the reference, its old-state, its\n new-state. Whenever the reference's state might have been changed,\n any registered watches will have their functions called. The watch fn\n will be called synchronously, on the agent's thread if an agent,\n before any pending sends if agent or ref. Note that an atom's or\n ref's state may have changed again prior to the fn call, so use\n old/new-state rather than derefing the reference. Note also that watch\n fns may be called from multiple threads simultaneously. Var watchers\n are triggered only by root binding changes, not thread-local\n set!s. Keys must be unique per reference, and can be used to remove\n the watch with remove-watch, but are otherwise considered opaque by\n the watch mechanism.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2142), lang.NewKeyword("end-line"), int(2142))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -}) -v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86)) -v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) -if err != nil { - panic(err) +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6, _ := lang.FieldOrMethod(v3, "addWatch") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("addWatch is not a function"))) } +v7 := lang.Apply(v6, []any{v4, v5}) return v7 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -7508,76 +6804,80 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// array-map +// agent { -v0 := lang.NewSymbol("array-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keyvals"))), lang.NewKeyword("doc"), "Constructs an array-map. If any keys are equal, they are handled as\n if by repeated uses of assoc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4378), lang.NewKeyword("end-line"), int(4378))).(*lang.Symbol) +v0 := lang.NewSymbol("agent").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("state"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Creates and returns an agent with an initial value of state and\n zero or more options (in any order):\n\n :meta metadata-map\n\n :validator validate-fn\n\n :error-handler handler-fn\n\n :error-mode mode-keyword\n\n If metadata-map is supplied, it will become the metadata on the\n agent. validate-fn must be nil or a side-effect-free fn of one\n argument, which will be passed the intended new state on any state\n change. If the new state is unacceptable, the validate-fn should\n return false or throw an exception. handler-fn is called if an\n action throws an exception or if validate-fn rejects a new state --\n see set-error-handler! for details. The mode-keyword may be either\n :continue (the default if an error-handler is given) or :fail (the\n default if no error-handler is given) -- see set-error-mode! for\n details.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2052), lang.NewKeyword("end-line"), int(2052))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 0: -v3, ok := lang.FieldOrMethod(glojure.lang11.PersistentArrayMap, "EMPTY") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", glojure.lang11.PersistentArrayMap, "EMPTY"))) -} -var v4 any -switch reflect.TypeOf(v3).Kind() { -case reflect.Func: - v4 = lang.Apply(v3, nil) -default: - v4 = v3 -} -return v4 default: - if len(args) < 0 { + if len(args) < 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := lang.NewList(args[0:]...) -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("to-array")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v3 := args[0] +v4 := lang.NewList(args[1:]...) +var v5 any = "unimplemented: new with non-constant class type" +_ = v5 +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("apply")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -var v4 any = v8 -_ = v4 -var v10 any -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("odd?")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("hash-map")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("alength")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v12 := v11.Get() +v13 := lang.Apply(v9, []any{v12, v4}) +var v6 any = v13 +_ = v6 +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("setup-reference")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v4}) -v18 := lang.Apply(v13, []any{v17}) -if lang.IsTruthy(v18) { -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("str")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v5, v4}) +_ = v18 +var v19 any +v20 := lang.Apply(lang.NewKeyword("error-handler"), []any{v6}) +if lang.IsTruthy(v20) { +v21 := lang.Apply(lang.NewKeyword("error-handler"), []any{v6}) +v22, _ := lang.FieldOrMethod(v5, "setErrorHandler") +if reflect.TypeOf(v22).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorHandler is not a function"))) } -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("last")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v23 := lang.Apply(v22, []any{v21}) +v19 = v23 +} else { +v19 = nil } -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v26 := lang.Apply(v21, []any{"No value supplied for key: ", v25}) -v27 := lang.Apply(lang1.NewIllegalArgumentError, []any{v26}) -panic(v27) +_ = v19 +v25 := lang.Apply(lang.NewKeyword("error-mode"), []any{v6}) +var v24 any = v25 +_ = v24 +var v27 any +if lang.IsTruthy(v24) { +v27 = v24 } else { -v28 := lang.Apply(lang1.NewPersistentArrayMapAsIfByAssoc, []any{v4}) -v10 = v28 +var v28 any +v29 := lang.Apply(lang.NewKeyword("error-handler"), []any{v6}) +if lang.IsTruthy(v29) { +v28 = lang.NewKeyword("continue") +} else { +v28 = lang.NewKeyword("fail") } -return v10 +v27 = v28 +} +v24, _ := lang.FieldOrMethod(v5, "setErrorMode") +if reflect.TypeOf(v24).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorMode is not a function"))) +} +v25 := lang.Apply(v24, []any{v27}) +_ = v25 +return v5 } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -7586,28 +6886,255 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// long +// agent-error { -var v1 lang.FnFunc -{ // function long__inliner -v1 = lang.NewFnFunc(func(args ...any) any { +v0 := lang.NewSymbol("agent-error").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("doc"), "Returns the exception thrown during an asynchronous action of the\n agent if the agent is failed. Returns nil if the agent is not\n failed.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2167), lang.NewKeyword("end-line"), int(2167))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v4, ok := lang.FieldOrMethod(v3, "getError") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getError"))) } -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +var v5 any +switch reflect.TypeOf(v4).Kind() { +case reflect.Func: + v5 = lang.Apply(v4, nil) +default: + v5 = v4 } -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// agent-errors +{ +v0 := lang.NewSymbol("agent-errors").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("doc"), "DEPRECATED: Use 'agent-error' instead.\n Returns a sequence of the exceptions thrown during asynchronous\n actions of the agent.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("deprecated"), "1.2", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2234), lang.NewKeyword("end-line"), int(2234))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("agent-error")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +var v4 any = v8 +_ = v4 +var v10 any +if lang.IsTruthy(v4) { +var v11 any = v4 +_ = v11 +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("list")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v11}) +v10 = v16 +} else { +v10 = nil +} +return v10 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// aget +{ +var v1 lang.FnFunc +{ // function aget__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("concat")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("list")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("seq")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("concat")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("list")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/Aget")}) +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("seq")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +} +v41 := v40.Get() +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("concat")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +} +v44 := v43.Get() +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("list")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +} +v47 := v46.Get() +v48 := lang.Apply(v47, []any{lang.NewSymbol("glojure.core/int")}) +v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v50 := v49.FindInternedVar(lang.NewSymbol("list")) +if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) +} +v51 := v50.Get() +v52 := lang.Apply(v51, []any{v4}) +v53 := lang.Apply(v44, []any{v48, v52}) +v54 := lang.Apply(v41, []any{v53}) +v55 := lang.Apply(v38, []any{v54}) +v56 := lang.Apply(v27, []any{v31, v35, v55}) +v57 := lang.Apply(v24, []any{v56}) +v58 := lang.Apply(v21, []any{v57}) +v59 := lang.Apply(v10, []any{v14, v18, v58}) +v60 := lang.Apply(v7, []any{v59}) +return v60 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("aget").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("&"), lang.NewSymbol("idxs"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the value at the index/indices. Works on Java arrays of all\n types.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3911), lang.NewKeyword("end-line"), int(3911))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v4 := args[0] +v5 := args[1] +v6 := lang.Apply(lang1.Get, []any{v4, v5}) +return v6 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := args[1] +v6 := lang.NewList(args[2:]...) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("apply")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("aget")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("aget")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v4, v5}) +v17 := lang.Apply(v9, []any{v12, v16, v6}) +return v17 + } +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// alength +{ +var v1 lang.FnFunc +{ // function alength__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v11 := v10.FindInternedVar(lang.NewSymbol("list")) if v11.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) @@ -7645,7 +7172,7 @@ if v28.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/LongCast")}) +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/Alength")}) v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v32 := v31.FindInternedVar(lang.NewSymbol("list")) if v32.IsMacro() { @@ -7663,15 +7190,19 @@ return v39 v2 := v1 _ = v2 } -v0 := lang.NewSymbol("long").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to long", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3481), lang.NewKeyword("end-line"), int(3481))).(*lang.Symbol) +v0 := lang.NewSymbol("alength").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the length of the Java array. Works on arrays of all\n types.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3897), lang.NewKeyword("end-line"), int(3897))).(*lang.Symbol) var v3 lang.FnFunc v3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5 := lang.Apply(lang1.LongCast, []any{v4}) -return v5 +v5, _ := lang.FieldOrMethod(runtime9.RT, "Alength") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Alength is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 }) v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v2 := ns.InternWithValue(v0, v3, true) @@ -7679,451 +7210,601 @@ if v0.Meta() != nil { v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// filter +// alias { -v0 := lang.NewSymbol("filter").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred")), lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the items in coll for which\n (pred item) returns logical true. pred must be free of side-effects.\n Returns a transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2785), lang.NewKeyword("end-line"), int(2785))).(*lang.Symbol) +v0 := lang.NewSymbol("alias").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("alias"), lang.NewSymbol("namespace-sym"))), lang.NewKeyword("doc"), "Add an alias in the current namespace to another\n namespace. Arguments are two symbols: the alias to be used, and\n the symbolic name of the target namespace. Use :as in the ns macro in preference\n to calling this directly.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4263), lang.NewKeyword("end-line"), int(4263))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("*ns*")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("the-ns")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v4}) +v12, _ := lang.FieldOrMethod(v7, "AddAlias") +if reflect.TypeOf(v12).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("AddAlias is not a function"))) +} +v13 := lang.Apply(v12, []any{v3, v11}) +return v13 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// all-ns +{ +v0 := lang.NewSymbol("all-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Returns a sequence of all namespaces.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4146), lang.NewKeyword("end-line"), int(4146))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v5 := args[0] -var v6 lang.FnFunc -v6 = lang.NewFnFunc(func(args ...any) any { +v3 := lang.Apply(nil, nil) +return v3 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// alter +{ +v0 := lang.NewSymbol("alter").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("fun"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Must be called in a transaction. Sets the in-transaction-value of\n ref to:\n\n (apply fun in-transaction-value-of-ref args)\n\n and returns the in-transaction-value of ref.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2435), lang.NewKeyword("end-line"), int(2435))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 0: -v7 := lang.Apply(v5, nil) + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +v6, _ := lang.FieldOrMethod(v3, "alter") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("alter is not a function"))) +} +v7 := lang.Apply(v6, []any{v4, v5}) return v7 - case 1: -v7 := args[0] -v8 := lang.Apply(v5, []any{v7}) -return v8 - case 2: -v7 := args[0] -v8 := args[1] -var v9 any -v10 := lang.Apply(v3, []any{v8}) -if lang.IsTruthy(v10) { -v11 := lang.Apply(v5, []any{v7, v8}) -v9 = v11 -} else { -v9 = v7 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -return v9 +} +// alter-meta! +{ +v0 := lang.NewSymbol("alter-meta!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("iref"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Atomically sets the metadata for a namespace/var/ref/agent/atom to be:\n\n (apply f its-current-meta args)\n\n f must be free of side-effects", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2398), lang.NewKeyword("end-line"), int(2398))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +v6, _ := lang.FieldOrMethod(v3, "AlterMeta") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("AlterMeta is not a function"))) +} +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 } }) -v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2793), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(2799), lang.NewKeyword("end-column"), int(22)) -v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) -if err != nil { - panic(err) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -return v8 -}) -v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2792), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2799), lang.NewKeyword("end-column"), int(23)) -v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) -if err != nil { - panic(err) } -return v6 - case 2: +// alter-var-root +{ +v0 := lang.NewSymbol("alter-var-root").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("v"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Atomically alters the root binding of var v by applying f to its\n current value plus any args", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5527), lang.NewKeyword("end-line"), int(5527))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] v4 := args[1] -var v5 lang.FnFunc -v5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { +v5 := lang.NewList(args[2:]...) +v6, _ := lang.FieldOrMethod(v3, "alterRoot") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("alterRoot is not a function"))) +} +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// amap +{ +v0 := lang.NewSymbol("amap").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("idx"), lang.NewSymbol("ret"), lang.NewSymbol("expr"))), lang.NewKeyword("doc"), "Maps an expression across an array a, using an index named idx, and\n return value named ret, initialized to a clone of a, then setting \n each element of ret to the evaluation of expr, returning the new \n array ret.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5273), lang.NewKeyword("end-line"), int(5273))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 6 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("seq")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := args[4] +v8 := args[5] +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("seq")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v4}) -var v6 any = v10 -_ = v6 -var v12 any -if lang.IsTruthy(v6) { -var v13 any = v6 -_ = v13 -var v15 any -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("chunked-seq?")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("concat")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v13}) -if lang.IsTruthy(v19) { -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("chunk-first")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v13}) -var v20 any = v24 -_ = v20 -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("count")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol("glojure.core/let")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v28 := v27.Get() -v29 := lang.Apply(v28, []any{v20}) -var v25 any = v29 -_ = v25 +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("apply")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("vector")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("seq")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("chunk-buffer")) +v32 := v31.FindInternedVar(lang.NewSymbol("concat")) if v32.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } v33 := v32.Get() -v34 := lang.Apply(v33, []any{v25}) -var v30 any = v34 -_ = v30 -v37 := lang.Apply(lang1.LongCast, []any{v25}) -var v36 any = v37 -_ = v36 -var v39 any = int64(0) -_ = v39 -var v40 any -for { -var v41 any -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("<")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("list")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } -v44 := v43.Get() -v45 := lang.Apply(v44, []any{v39, v36}) -if lang.IsTruthy(v45) { -v47, _ := lang.FieldOrMethod(v20, "nth") -if reflect.TypeOf(v47).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) +v36 := v35.Get() +v37 := lang.Apply(v36, []any{lang.NewSymbol("a__0__auto__")}) +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("list")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) } -v48 := lang.Apply(v47, []any{v39}) -var v46 any = v48 -_ = v46 -var v50 any -v51 := lang.Apply(v3, []any{v46}) -if lang.IsTruthy(v51) { +v40 := v39.Get() +v41 := lang.Apply(v40, []any{v5}) +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("list")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +} +v44 := v43.Get() +v45 := lang.Apply(v44, []any{lang.NewSymbol("l__1__auto__")}) +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("list")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +} +v48 := v47.Get() +v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v50 := v49.FindInternedVar(lang.NewSymbol("seq")) +if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) +} +v51 := v50.Get() v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("chunk-append")) +v53 := v52.FindInternedVar(lang.NewSymbol("concat")) if v53.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) } v54 := v53.Get() -v55 := lang.Apply(v54, []any{v30, v46}) -v50 = v55 -} else { -v50 = nil +v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v56 := v55.FindInternedVar(lang.NewSymbol("list")) +if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) } -_ = v50 -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("unchecked-inc")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +v57 := v56.Get() +v58 := lang.Apply(v57, []any{lang.NewSymbol("glojure.core/alength")}) +v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v60 := v59.FindInternedVar(lang.NewSymbol("list")) +if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) } -v49 := v48.Get() -v50 := lang.Apply(v49, []any{v39}) -var v46 any = v50 -v39 = v46 -continue -} else { -v41 = nil +v61 := v60.Get() +v62 := lang.Apply(v61, []any{lang.NewSymbol("a__0__auto__")}) +v63 := lang.Apply(v54, []any{v58, v62}) +v64 := lang.Apply(v51, []any{v63}) +v65 := lang.Apply(v48, []any{v64}) +v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v67 := v66.FindInternedVar(lang.NewSymbol("list")) +if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) } -v40 = v41 - break +v68 := v67.Get() +v69 := lang.Apply(v68, []any{v7}) +v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v71 := v70.FindInternedVar(lang.NewSymbol("list")) +if v71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) } -_ = v40 -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("chunk-cons")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +v72 := v71.Get() +v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v74 := v73.FindInternedVar(lang.NewSymbol("seq")) +if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) } -v38 := v37.Get() -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("chunk")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +v75 := v74.Get() +v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v77 := v76.FindInternedVar(lang.NewSymbol("concat")) +if v77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) } -v41 := v40.Get() -v42 := lang.Apply(v41, []any{v30}) -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("filter")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +v78 := v77.Get() +v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v80 := v79.FindInternedVar(lang.NewSymbol("list")) +if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) } -v45 := v44.Get() -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("chunk-rest")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +v81 := v80.Get() +v82 := lang.Apply(v81, []any{lang.NewSymbol("glojure.core/aclone")}) +v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v84 := v83.FindInternedVar(lang.NewSymbol("list")) +if v84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) } -v48 := v47.Get() -v49 := lang.Apply(v48, []any{v13}) -v50 := lang.Apply(v45, []any{v3, v49}) -v51 := lang.Apply(v38, []any{v42, v50}) -v15 = v51 -} else { -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("first")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +v85 := v84.Get() +v86 := lang.Apply(v85, []any{lang.NewSymbol("a__0__auto__")}) +v87 := lang.Apply(v78, []any{v82, v86}) +v88 := lang.Apply(v75, []any{v87}) +v89 := lang.Apply(v72, []any{v88}) +v90 := lang.Apply(v33, []any{v37, v41, v45, v65, v69, v89}) +v91 := lang.Apply(v30, []any{v90}) +v92 := lang.Apply(v24, []any{v27, v91}) +v93 := lang.Apply(v21, []any{v92}) +v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v95 := v94.FindInternedVar(lang.NewSymbol("list")) +if v95.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) } -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v13}) -var v20 any = v24 -_ = v20 -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("rest")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +v96 := v95.Get() +v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v98 := v97.FindInternedVar(lang.NewSymbol("seq")) +if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) } -v28 := v27.Get() -v29 := lang.Apply(v28, []any{v13}) -var v25 any = v29 -_ = v25 -var v31 any -v32 := lang.Apply(v3, []any{v20}) -if lang.IsTruthy(v32) { -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("cons")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +v99 := v98.Get() +v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v101 := v100.FindInternedVar(lang.NewSymbol("concat")) +if v101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) } -v35 := v34.Get() -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("filter")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +v102 := v101.Get() +v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v104 := v103.FindInternedVar(lang.NewSymbol("list")) +if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) } -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v3, v25}) -v40 := lang.Apply(v35, []any{v20, v39}) -v31 = v40 -} else { -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("filter")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +v105 := v104.Get() +v106 := lang.Apply(v105, []any{lang.NewSymbol("glojure.core/loop")}) +v107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v108 := v107.FindInternedVar(lang.NewSymbol("list")) +if v108.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v108))) } -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v3, v25}) -v31 = v44 +v109 := v108.Get() +v110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v111 := v110.FindInternedVar(lang.NewSymbol("apply")) +if v111.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v111))) } -v15 = v31 +v112 := v111.Get() +v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v114 := v113.FindInternedVar(lang.NewSymbol("vector")) +if v114.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) } -v12 = v15 -} else { -v12 = nil +v115 := v114.Get() +v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v117 := v116.FindInternedVar(lang.NewSymbol("seq")) +if v117.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) } -return v12 -}) -v6 := lang.Apply(lang1.NewLazySeq, []any{v5}) -return v6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v118 := v117.Get() +v119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v120 := v119.FindInternedVar(lang.NewSymbol("concat")) +if v120.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v120))) } +v121 := v120.Get() +v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v123 := v122.FindInternedVar(lang.NewSymbol("list")) +if v123.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) } -// sorted-set-by -{ -v0 := lang.NewSymbol("sorted-set-by").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("comparator"), lang.NewSymbol("&"), lang.NewSymbol("keys"))), lang.NewKeyword("doc"), "Returns a new sorted set with supplied keys, using the supplied\n comparator. Any equal keys are handled as if by repeated uses of\n conj.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(424), lang.NewKeyword("end-line"), int(424))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.NewList(args[1:]...) -v5 := lang.Apply(lang1.CreatePersistentTreeSetWithComparator, []any{v3, v4}) -return v5 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v124 := v123.Get() +v125 := lang.Apply(v124, []any{v6}) +v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v127 := v126.FindInternedVar(lang.NewSymbol("list")) +if v127.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) } +v128 := v127.Get() +v129 := lang.Apply(v128, []any{int64(0)}) +v130 := lang.Apply(v121, []any{v125, v129}) +v131 := lang.Apply(v118, []any{v130}) +v132 := lang.Apply(v112, []any{v115, v131}) +v133 := lang.Apply(v109, []any{v132}) +v134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v135 := v134.FindInternedVar(lang.NewSymbol("list")) +if v135.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v135))) } -// ns-resolve -{ -v0 := lang.NewSymbol("ns-resolve").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("sym")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("env"), lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Returns the var or Class to which a symbol will be resolved in the\n namespace (unless found in the environment), else nil. Note that\n if the symbol is fully qualified, the var/Class to which it resolves\n need not be present in the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4358), lang.NewKeyword("end-line"), int(4358))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("ns-resolve")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v136 := v135.Get() +v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v138 := v137.FindInternedVar(lang.NewSymbol("seq")) +if v138.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) } -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3, nil, v4}) -return v8 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -var v6 any -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("contains?")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v139 := v138.Get() +v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v141 := v140.FindInternedVar(lang.NewSymbol("concat")) +if v141.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) } -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v4, v5}) -if lang.IsTruthy(v10) { -v6 = nil -} else { -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("the-ns")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v142 := v141.Get() +v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v144 := v143.FindInternedVar(lang.NewSymbol("list")) +if v144.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) } -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v3}) -v15, _ := lang.FieldOrMethod(runtime3.Compiler, "maybeResolveIn") -if reflect.TypeOf(v15).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("maybeResolveIn is not a function"))) +v145 := v144.Get() +v146 := lang.Apply(v145, []any{lang.NewSymbol("if")}) +v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v148 := v147.FindInternedVar(lang.NewSymbol("list")) +if v148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) } -v16 := lang.Apply(v15, []any{v14, v5}) -v6 = v16 +v149 := v148.Get() +v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v151 := v150.FindInternedVar(lang.NewSymbol("seq")) +if v151.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) } -return v6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v152 := v151.Get() +v153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v154 := v153.FindInternedVar(lang.NewSymbol("concat")) +if v154.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v154))) } +v155 := v154.Get() +v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v157 := v156.FindInternedVar(lang.NewSymbol("list")) +if v157.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) } -// prependss -{ -v0 := lang.NewSymbol("prependss").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Prepends a symbol or a seq to coll", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5900), lang.NewKeyword("end-line"), int(5900), lang.NewKeyword("private"), true)).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("symbol?")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +v158 := v157.Get() +v159 := lang.Apply(v158, []any{lang.NewSymbol("glojure.core/<")}) +v160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v161 := v160.FindInternedVar(lang.NewSymbol("list")) +if v161.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v161))) } -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v3}) -if lang.IsTruthy(v9) { -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("cons")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v162 := v161.Get() +v163 := lang.Apply(v162, []any{v6}) +v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v165 := v164.FindInternedVar(lang.NewSymbol("list")) +if v165.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) } -v12 := v11.Get() -v13 := lang.Apply(v12, []any{v3, v4}) -v5 = v13 -} else { -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("concat")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v166 := v165.Get() +v167 := lang.Apply(v166, []any{lang.NewSymbol("l__1__auto__")}) +v168 := lang.Apply(v155, []any{v159, v163, v167}) +v169 := lang.Apply(v152, []any{v168}) +v170 := lang.Apply(v149, []any{v169}) +v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v172 := v171.FindInternedVar(lang.NewSymbol("list")) +if v172.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v3, v4}) -v5 = v17 +v173 := v172.Get() +v174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v175 := v174.FindInternedVar(lang.NewSymbol("seq")) +if v175.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v175))) } -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v176 := v175.Get() +v177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v178 := v177.FindInternedVar(lang.NewSymbol("concat")) +if v178.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v178))) } +v179 := v178.Get() +v180 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v181 := v180.FindInternedVar(lang.NewSymbol("list")) +if v181.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v181))) } -// add-watch -{ -v0 := lang.NewSymbol("add-watch").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("reference"), lang.NewSymbol("key"), lang.NewSymbol("fn"))), lang.NewKeyword("doc"), "Adds a watch function to an agent/atom/var/ref reference. The watch\n fn must be a fn of 4 args: a key, the reference, its old-state, its\n new-state. Whenever the reference's state might have been changed,\n any registered watches will have their functions called. The watch fn\n will be called synchronously, on the agent's thread if an agent,\n before any pending sends if agent or ref. Note that an atom's or\n ref's state may have changed again prior to the fn call, so use\n old/new-state rather than derefing the reference. Note also that watch\n fns may be called from multiple threads simultaneously. Var watchers\n are triggered only by root binding changes, not thread-local\n set!s. Keys must be unique per reference, and can be used to remove\n the watch with remove-watch, but are otherwise considered opaque by\n the watch mechanism.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2142), lang.NewKeyword("end-line"), int(2142))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6, _ := lang.FieldOrMethod(v3, "addWatch") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("addWatch is not a function"))) +v182 := v181.Get() +v183 := lang.Apply(v182, []any{lang.NewSymbol("do")}) +v184 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v185 := v184.FindInternedVar(lang.NewSymbol("list")) +if v185.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v185))) } -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v186 := v185.Get() +v187 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v188 := v187.FindInternedVar(lang.NewSymbol("seq")) +if v188.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v188))) } +v189 := v188.Get() +v190 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v191 := v190.FindInternedVar(lang.NewSymbol("concat")) +if v191.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v191))) } -// conj! -{ -v0 := lang.NewSymbol("conj!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Adds x to the transient collection, and return coll. The 'addition'\n may happen at different 'places' depending on the concrete type.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3359), lang.NewKeyword("end-line"), int(3359))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v4 := v3.FindInternedVar(lang.NewSymbol("transient")) -if v4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) +v192 := v191.Get() +v193 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v194 := v193.FindInternedVar(lang.NewSymbol("list")) +if v194.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v194))) } -v5 := v4.Get() -v6 := lang.NewVector() -v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3364), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(3364), lang.NewKeyword("end-column"), int(19)) -v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) -if err != nil { - panic(err) +v195 := v194.Get() +v196 := lang.Apply(v195, []any{lang.NewSymbol("glojure.core/aset")}) +v197 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v198 := v197.FindInternedVar(lang.NewSymbol("list")) +if v198.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v198))) } -v9 := lang.Apply(v5, []any{v8}) -return v9 - case 1: -v3 := args[0] -return v3 - case 2: -v3 := args[0] -v4 := args[1] -v5, _ := lang.FieldOrMethod(v3, "Conj") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Conj is not a function"))) +v199 := v198.Get() +v200 := lang.Apply(v199, []any{v7}) +v201 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v202 := v201.FindInternedVar(lang.NewSymbol("list")) +if v202.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v202))) } -v6 := lang.Apply(v5, []any{v4}) -return v6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } +v203 := v202.Get() +v204 := lang.Apply(v203, []any{v6}) +v205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v206 := v205.FindInternedVar(lang.NewSymbol("list")) +if v206.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v206))) +} +v207 := v206.Get() +v208 := lang.Apply(v207, []any{v8}) +v209 := lang.Apply(v192, []any{v196, v200, v204, v208}) +v210 := lang.Apply(v189, []any{v209}) +v211 := lang.Apply(v186, []any{v210}) +v212 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v213 := v212.FindInternedVar(lang.NewSymbol("list")) +if v213.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v213))) +} +v214 := v213.Get() +v215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v216 := v215.FindInternedVar(lang.NewSymbol("seq")) +if v216.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v216))) +} +v217 := v216.Get() +v218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v219 := v218.FindInternedVar(lang.NewSymbol("concat")) +if v219.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v219))) +} +v220 := v219.Get() +v221 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v222 := v221.FindInternedVar(lang.NewSymbol("list")) +if v222.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v222))) +} +v223 := v222.Get() +v224 := lang.Apply(v223, []any{lang.NewSymbol("recur")}) +v225 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v226 := v225.FindInternedVar(lang.NewSymbol("list")) +if v226.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v226))) +} +v227 := v226.Get() +v228 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v229 := v228.FindInternedVar(lang.NewSymbol("seq")) +if v229.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v229))) +} +v230 := v229.Get() +v231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v232 := v231.FindInternedVar(lang.NewSymbol("concat")) +if v232.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v232))) +} +v233 := v232.Get() +v234 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v235 := v234.FindInternedVar(lang.NewSymbol("list")) +if v235.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v235))) +} +v236 := v235.Get() +v237 := lang.Apply(v236, []any{lang.NewSymbol("glojure.core/unchecked-inc")}) +v238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v239 := v238.FindInternedVar(lang.NewSymbol("list")) +if v239.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v239))) +} +v240 := v239.Get() +v241 := lang.Apply(v240, []any{v6}) +v242 := lang.Apply(v233, []any{v237, v241}) +v243 := lang.Apply(v230, []any{v242}) +v244 := lang.Apply(v227, []any{v243}) +v245 := lang.Apply(v220, []any{v224, v244}) +v246 := lang.Apply(v217, []any{v245}) +v247 := lang.Apply(v214, []any{v246}) +v248 := lang.Apply(v179, []any{v183, v211, v247}) +v249 := lang.Apply(v176, []any{v248}) +v250 := lang.Apply(v173, []any{v249}) +v251 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v252 := v251.FindInternedVar(lang.NewSymbol("list")) +if v252.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v252))) +} +v253 := v252.Get() +v254 := lang.Apply(v253, []any{v7}) +v255 := lang.Apply(v142, []any{v146, v170, v250, v254}) +v256 := lang.Apply(v139, []any{v255}) +v257 := lang.Apply(v136, []any{v256}) +v258 := lang.Apply(v102, []any{v106, v133, v257}) +v259 := lang.Apply(v99, []any{v258}) +v260 := lang.Apply(v96, []any{v259}) +v261 := lang.Apply(v14, []any{v18, v93, v260}) +v262 := lang.Apply(v11, []any{v261}) +return v262 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -8131,44 +7812,129 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// re-matches +// ancestors { -v0 := lang.NewSymbol("re-matches").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("re"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns the match, if any, of string to pattern, using\n java.util.regex.Matcher.matches(). Uses re-groups to return the\n groups.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4910), lang.NewKeyword("end-line"), int(4910))).(*lang.Symbol) +v0 := lang.NewSymbol("ancestors").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"))), lang.NewKeyword("doc"), "Returns the immediate and indirect parents of tag, either via a Java type\n inheritance relationship or a relationship established via derive. h\n must be a hierarchy obtained from make-hierarchy, if not supplied\n defaults to the global hierarchy", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5620), lang.NewKeyword("end-line"), int(5620))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + switch len(args) { + case 1: +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("ancestors")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("global-hierarchy")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v6, []any{v9, v3}) +return v10 + case 2: v3 := args[0] v4 := args[1] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("re-matcher")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("not-empty")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v3, v4}) -var v5 any = v9 -_ = v5 -var v11 any -v12, _ := lang.FieldOrMethod(v5, "matches") -if reflect.TypeOf(v12).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("matches is not a function"))) +v7 := v6.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("get")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -v13 := lang.Apply(v12, []any{}) -if lang.IsTruthy(v13) { -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("re-groups")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v11 := v10.Get() +v12 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) +v13 := lang.Apply(v11, []any{v12, v4}) +var v8 any = v13 +_ = v8 +var v15 any +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("class?")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v5}) -v11 = v17 +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v4}) +if lang.IsTruthy(v19) { +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("set")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("supers")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v4}) +v28 := lang.Apply(v23, []any{v27}) +var v20 any = v28 +_ = v20 +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("reduce1")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("into1")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("cons")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("map")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +} +v41 := v40.Get() +var v42 lang.FnFunc +v42 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v43 := args[0] +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("get")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) +v48 := lang.Apply(v46, []any{v47, v43}) +return v48 +}) +v43 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5633), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(5633), lang.NewKeyword("end-column"), int(54)) +v44, err := lang.WithMeta(v42, v43.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v45 := lang.Apply(v41, []any{v44, v20}) +v46 := lang.Apply(v38, []any{v8, v45}) +v47 := lang.Apply(v32, []any{v35, v20, v46}) +v15 = v47 } else { -v11 = nil +v15 = v8 } -return v11 +v8 := lang.Apply(v7, []any{v15}) +return v8 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -8176,29 +7942,20 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// aset-int +// and { -v0 := lang.NewSymbol("aset-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of int. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3946), lang.NewKeyword("end-line"), int(3948))).(*lang.Symbol) +v0 := lang.NewSymbol("and").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("next"))), lang.NewKeyword("doc"), "Evaluates exprs one at a time, from left to right. If a form\n returns logical false (nil or false), and returns that value and\n doesn't evaluate any of the other expressions, otherwise it returns\n the value of the last expr. (and) returns true.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(835), lang.NewKeyword("end-line"), int(835))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { + case 2: +v3 := args[0] +v4 := args[1] +return true case 3: v3 := args[0] v4 := args[1] v5 := args[2] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("int")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v5}) -v10, _ := lang.FieldOrMethod(nil, "setInt") -if reflect.TypeOf(v10).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setInt is not a function"))) -} -v11 := lang.Apply(v10, []any{v3, v4, v9}) -_ = v11 return v5 default: if len(args) < 3 { @@ -8209,96 +7966,146 @@ v4 := args[1] v5 := args[2] v6 := lang.NewList(args[3:]...) v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("apply")) +v8 := v7.FindInternedVar(lang.NewSymbol("seq")) if v8.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } v9 := v8.Get() v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("aset-int")) +v11 := v10.FindInternedVar(lang.NewSymbol("concat")) if v11.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } v12 := v11.Get() v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("aget")) +v14 := v13.FindInternedVar(lang.NewSymbol("list")) if v14.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } v15 := v14.Get() -v16 := lang.Apply(v15, []any{v3, v4}) -v17 := lang.Apply(v9, []any{v12, v16, v5, v6}) -return v17 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/let")}) +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("list")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("apply")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -// read-line -{ -v0 := lang.NewSymbol("read-line").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Reads the next line from stream that is the current value of *in* .", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3797), lang.NewKeyword("end-line"), int(3797))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -var v3 any -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("vector")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("*in*")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("seq")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) } -v9 := v8.Get() -v10 := lang.Apply(v6, []any{glojure.lang11.LineNumberingPushbackReader, v9}) -if lang.IsTruthy(v10) { -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("*in*")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("concat")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) } -v13 := v12.Get() -v14, ok := lang.FieldOrMethod(v13, "readLine") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v13, "readLine"))) +v31 := v30.Get() +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) } -var v15 any -switch reflect.TypeOf(v14).Kind() { -case reflect.Func: - v15 = lang.Apply(v14, nil) -default: - v15 = v14 +v34 := v33.Get() +v35 := lang.Apply(v34, []any{lang.NewSymbol("and__0__auto__")}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) } -v3 = v15 -} else { -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("*in*")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v5}) +v40 := lang.Apply(v31, []any{v35, v39}) +v41 := lang.Apply(v28, []any{v40}) +v42 := lang.Apply(v22, []any{v25, v41}) +v43 := lang.Apply(v19, []any{v42}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } -v18 := v17.Get() -v19, ok := lang.FieldOrMethod(v18, "readLine") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v18, "readLine"))) +v46 := v45.Get() +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("seq")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) } -var v20 any -switch reflect.TypeOf(v19).Kind() { -case reflect.Func: - v20 = lang.Apply(v19, nil) -default: - v20 = v19 +v49 := v48.Get() +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("concat")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) } -v3 = v20 +v52 := v51.Get() +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("list")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) } -return v3 +v55 := v54.Get() +v56 := lang.Apply(v55, []any{lang.NewSymbol("if")}) +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("list")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +} +v59 := v58.Get() +v60 := lang.Apply(v59, []any{lang.NewSymbol("and__0__auto__")}) +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("list")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +} +v63 := v62.Get() +v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v65 := v64.FindInternedVar(lang.NewSymbol("seq")) +if v65.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) +} +v66 := v65.Get() +v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v68 := v67.FindInternedVar(lang.NewSymbol("concat")) +if v68.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) +} +v69 := v68.Get() +v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v71 := v70.FindInternedVar(lang.NewSymbol("list")) +if v71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) +} +v72 := v71.Get() +v73 := lang.Apply(v72, []any{lang.NewSymbol("glojure.core/and")}) +v74 := lang.Apply(v69, []any{v73, v6}) +v75 := lang.Apply(v66, []any{v74}) +v76 := lang.Apply(v63, []any{v75}) +v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v78 := v77.FindInternedVar(lang.NewSymbol("list")) +if v78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) +} +v79 := v78.Get() +v80 := lang.Apply(v79, []any{lang.NewSymbol("and__0__auto__")}) +v81 := lang.Apply(v52, []any{v56, v60, v76, v80}) +v82 := lang.Apply(v49, []any{v81}) +v83 := lang.Apply(v46, []any{v82}) +v84 := lang.Apply(v12, []any{v16, v43, v83}) +v85 := lang.Apply(v9, []any{v84}) +return v85 + } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -8306,185 +8113,264 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// with-bindings* +// any? { -v0 := lang.NewSymbol("with-bindings*").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("binding-map"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Takes a map of Var/value pairs. Installs for the given Vars the associated\n values as thread-local bindings. Then calls f with the supplied arguments.\n Pops the installed bindings after f returned. Returns whatever f returns.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1971), lang.NewKeyword("end-line"), int(1971))).(*lang.Symbol) +v1 := reflect.TypeOf(false) +v0 := lang.NewSymbol("any?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true given any argument.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(537), lang.NewKeyword("end-line"), int(537))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +return true +}) +v4 := reflect.TypeOf(false) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// apply +{ +v0 := lang.NewSymbol("apply").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("z"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Applies fn f to the argument list formed by prepending intervening arguments to args.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(653), lang.NewKeyword("end-line"), int(653))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + case 2: v3 := args[0] v4 := args[1] -v5 := lang.NewList(args[2:]...) +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v4}) +v9 := lang.Apply(lang1.Apply, []any{v3, v8}) +return v9 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("push-thread-bindings")) +v7 := v6.FindInternedVar(lang.NewSymbol("list*")) if v7.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } v8 := v7.Get() -v9 := lang.Apply(v8, []any{v3}) -_ = v9 -var v10 any -func() { -defer func() { -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, nil) -}() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("apply")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v4, v5}) -v10 = v18 -}() +v9 := lang.Apply(v8, []any{v4, v5}) +v10 := lang.Apply(lang1.Apply, []any{v3, v9}) return v10 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} + case 4: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("list*")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -// memfn -{ -v0 := lang.NewSymbol("memfn").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Expands into code that creates a fn that expects to be passed an\n object and any args and calls the named instance method on the\n object passing the args. Use when you want to treat a Java method as\n a first-class fn. name may be type-hinted with the method receiver's\n type in order to avoid reflective calls.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3872), lang.NewKeyword("end-line"), int(3872))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v4, v5, v6}) +v11 := lang.Apply(lang1.Apply, []any{v3, v10}) +return v11 + case 5: v3 := args[0] v4 := args[1] v5 := args[2] -v6 := lang.NewList(args[3:]...) +v6 := args[3] +v7 := args[4] v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("with-meta")) +v9 := v8.FindInternedVar(lang.NewSymbol("list*")) if v9.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("gensym")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v11 := lang.Apply(v10, []any{v4, v5, v6, v7}) +v12 := lang.Apply(lang1.Apply, []any{v3, v11}) +return v12 + default: + if len(args) < 5 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := args[4] +v8 := lang.NewList(args[5:]...) +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("cons")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -v13 := v12.Get() -v14 := lang.Apply(v13, []any{"target"}) +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("cons")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("meta")) +v16 := v15.FindInternedVar(lang.NewSymbol("cons")) if v16.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } v17 := v16.Get() -v18 := lang.Apply(v17, []any{v5}) -v19 := lang.Apply(v10, []any{v14, v18}) -var v7 any = v19 -_ = v7 +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("cons")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +v22 := v21.FindInternedVar(lang.NewSymbol("spread")) if v22.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +v24 := lang.Apply(v23, []any{v8}) +v25 := lang.Apply(v20, []any{v7, v24}) +v26 := lang.Apply(v17, []any{v6, v25}) +v27 := lang.Apply(v14, []any{v5, v26}) +v28 := lang.Apply(v11, []any{v4, v27}) +v29 := lang.Apply(lang1.Apply, []any{v3, v28}) +return v29 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/fn")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +// areduce +{ +v0 := lang.NewSymbol("areduce").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("idx"), lang.NewSymbol("ret"), lang.NewSymbol("init"), lang.NewSymbol("expr"))), lang.NewKeyword("doc"), "Reduces an expression across an array a, using an index named idx,\n and return value named ret, initialized to init, setting ret to the \n evaluation of expr at each step, returning ret.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5289), lang.NewKeyword("end-line"), int(5289))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 7 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := args[4] +v8 := args[5] +v9 := args[6] +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("seq")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("apply")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("concat")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("vector")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +v15 := v14.Get() +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("list")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("seq")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +v18 := v17.Get() +v19 := lang.Apply(v18, []any{lang.NewSymbol("glojure.core/let")}) +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("list")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v42 := v41.Get() +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("apply")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("vector")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("seq")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("concat")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("list")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v37, []any{lang.NewSymbol("a__0__auto__")}) +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("list")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +} +v41 := v40.Get() +v42 := lang.Apply(v41, []any{v5}) v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("concat")) +v44 := v43.FindInternedVar(lang.NewSymbol("list")) if v44.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) } v45 := v44.Get() -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("list")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +v46 := lang.Apply(v45, []any{lang.NewSymbol("l__1__auto__")}) +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("list")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) } -v48 := v47.Get() -v49 := lang.Apply(v48, []any{v7}) -v50 := lang.Apply(v45, []any{v49, v6}) -v51 := lang.Apply(v42, []any{v50}) -v52 := lang.Apply(v36, []any{v39, v51}) -v53 := lang.Apply(v33, []any{v52}) -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("list")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +v49 := v48.Get() +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("seq")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) } -v56 := v55.Get() -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("seq")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +v52 := v51.Get() +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("concat")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) } -v59 := v58.Get() +v55 := v54.Get() +v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v57 := v56.FindInternedVar(lang.NewSymbol("list")) +if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) +} +v58 := v57.Get() +v59 := lang.Apply(v58, []any{lang.NewSymbol("glojure.core/alength")}) v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v61 := v60.FindInternedVar(lang.NewSymbol("concat")) +v61 := v60.FindInternedVar(lang.NewSymbol("list")) if v61.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) } v62 := v61.Get() -v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v64 := v63.FindInternedVar(lang.NewSymbol("list")) -if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) -} -v65 := v64.Get() -v66 := lang.Apply(v65, []any{lang.NewSymbol(".")}) -v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v68 := v67.FindInternedVar(lang.NewSymbol("list")) -if v68.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) -} -v69 := v68.Get() -v70 := lang.Apply(v69, []any{v7}) +v63 := lang.Apply(v62, []any{lang.NewSymbol("a__0__auto__")}) +v64 := lang.Apply(v55, []any{v59, v63}) +v65 := lang.Apply(v52, []any{v64}) +v66 := lang.Apply(v49, []any{v65}) +v67 := lang.Apply(v34, []any{v38, v42, v46, v66}) +v68 := lang.Apply(v31, []any{v67}) +v69 := lang.Apply(v25, []any{v28, v68}) +v70 := lang.Apply(v22, []any{v69}) v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v72 := v71.FindInternedVar(lang.NewSymbol("list")) if v72.IsMacro() { @@ -8509,552 +8395,326 @@ if v81.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) } v82 := v81.Get() -v83 := lang.Apply(v82, []any{v5}) -v84 := lang.Apply(v79, []any{v83, v6}) -v85 := lang.Apply(v76, []any{v84}) -v86 := lang.Apply(v73, []any{v85}) -v87 := lang.Apply(v62, []any{v66, v70, v86}) -v88 := lang.Apply(v59, []any{v87}) -v89 := lang.Apply(v56, []any{v88}) -v90 := lang.Apply(v26, []any{v30, v53, v89}) -v91 := lang.Apply(v23, []any{v90}) -return v91 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} +v83 := lang.Apply(v82, []any{lang.NewSymbol("glojure.core/loop")}) +v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v85 := v84.FindInternedVar(lang.NewSymbol("list")) +if v85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) } -// inst? -{ -v0 := lang.NewSymbol("inst?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x satisfies Inst", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6880), lang.NewKeyword("end-line"), int(6880))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -return nil -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v86 := v85.Get() +v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v88 := v87.FindInternedVar(lang.NewSymbol("apply")) +if v88.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) } +v89 := v88.Get() +v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v91 := v90.FindInternedVar(lang.NewSymbol("vector")) +if v91.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) } -// *e -{ -v0 := lang.NewSymbol("*e").WithMeta(lang.NewMap()).(*lang.Symbol) -v1 := ns.Intern(v0) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v92 := v91.Get() +v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v94 := v93.FindInternedVar(lang.NewSymbol("seq")) +if v94.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) } +v95 := v94.Get() +v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v97 := v96.FindInternedVar(lang.NewSymbol("concat")) +if v97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) } -// set? -{ -v0 := lang.NewSymbol("set?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements IPersistentSet", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4098), lang.NewKeyword("end-line"), int(4098))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v98 := v97.Get() +v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v100 := v99.FindInternedVar(lang.NewSymbol("list")) +if v100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) } -v6 := v5.Get() -v7 := lang.Apply(v6, []any{lang1.IPersistentSet, v3}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v101 := v100.Get() +v102 := lang.Apply(v101, []any{v6}) +v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v104 := v103.FindInternedVar(lang.NewSymbol("list")) +if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) } +v105 := v104.Get() +v106 := lang.Apply(v105, []any{int64(0)}) +v107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v108 := v107.FindInternedVar(lang.NewSymbol("list")) +if v108.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v108))) } -// simple-keyword? -{ -v0 := lang.NewSymbol("simple-keyword?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a keyword without a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1633), lang.NewKeyword("end-line"), int(1633))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("keyword?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v109 := v108.Get() +v110 := lang.Apply(v109, []any{v7}) +v111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v112 := v111.FindInternedVar(lang.NewSymbol("list")) +if v112.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v112))) } -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -var v4 any = v8 -_ = v4 -var v10 any -if lang.IsTruthy(v4) { -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("nil?")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v113 := v112.Get() +v114 := lang.Apply(v113, []any{v8}) +v115 := lang.Apply(v98, []any{v102, v106, v110, v114}) +v116 := lang.Apply(v95, []any{v115}) +v117 := lang.Apply(v89, []any{v92, v116}) +v118 := lang.Apply(v86, []any{v117}) +v119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v120 := v119.FindInternedVar(lang.NewSymbol("list")) +if v120.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v120))) } -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("namespace")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v121 := v120.Get() +v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v123 := v122.FindInternedVar(lang.NewSymbol("seq")) +if v123.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v3}) -v18 := lang.Apply(v13, []any{v17}) -v10 = v18 -} else { -v10 = v4 +v124 := v123.Get() +v125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v126 := v125.FindInternedVar(lang.NewSymbol("concat")) +if v126.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v126))) } -return v10 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v127 := v126.Get() +v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v129 := v128.FindInternedVar(lang.NewSymbol("list")) +if v129.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v129))) } +v130 := v129.Get() +v131 := lang.Apply(v130, []any{lang.NewSymbol("if")}) +v132 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v133 := v132.FindInternedVar(lang.NewSymbol("list")) +if v133.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v133))) } -// dotimes -{ -v0 := lang.NewSymbol("dotimes").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "bindings => name n\n\n Repeatedly executes body (presumably for side-effects) with name\n bound to integers from 0 through n-1.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3306), lang.NewKeyword("end-line"), int(3306))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -var v7 any -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v134 := v133.Get() +v135 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v136 := v135.FindInternedVar(lang.NewSymbol("seq")) +if v136.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v136))) } -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v5}) -if lang.IsTruthy(v11) { -v7 = nil -} else { -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("str")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +v137 := v136.Get() +v138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v139 := v138.FindInternedVar(lang.NewSymbol("concat")) +if v139.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v139))) } -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("first")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +v140 := v139.Get() +v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v142 := v141.FindInternedVar(lang.NewSymbol("list")) +if v142.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) } -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v3}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v143 := v142.Get() +v144 := lang.Apply(v143, []any{lang.NewSymbol("glojure.core/<")}) +v145 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v146 := v145.FindInternedVar(lang.NewSymbol("list")) +if v146.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v146))) } -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("meta")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) -v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) -v28 := lang.Apply(lang1.NewIllegalArgumentError, []any{v27}) -panic(v28) -} -_ = v7 -var v29 any -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("=")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("count")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v5}) -v37 := lang.Apply(v32, []any{int64(2), v36}) -if lang.IsTruthy(v37) { -v29 = nil -} else { -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("str")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("first")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v3}) -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("meta")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v3}) -v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) -v53 := lang.Apply(v40, []any{v44, " requires ", "exactly 2 forms in binding vector", " in ", v47, ":", v52}) -v54 := lang.Apply(lang1.NewIllegalArgumentError, []any{v53}) -panic(v54) -} -_ = v29 -_ = nil -v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v57 := v56.FindInternedVar(lang.NewSymbol("first")) -if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) -} -v58 := v57.Get() -v59 := lang.Apply(v58, []any{v5}) -var v55 any = v59 -_ = v55 -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("second")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) -} -v63 := v62.Get() -v64 := lang.Apply(v63, []any{v5}) -var v60 any = v64 -_ = v60 -v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v67 := v66.FindInternedVar(lang.NewSymbol("seq")) -if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) -} -v68 := v67.Get() -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("concat")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) -} -v71 := v70.Get() -v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v73 := v72.FindInternedVar(lang.NewSymbol("list")) -if v73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) -} -v74 := v73.Get() -v75 := lang.Apply(v74, []any{lang.NewSymbol("glojure.core/let")}) -v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v77 := v76.FindInternedVar(lang.NewSymbol("list")) -if v77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) -} -v78 := v77.Get() -v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v80 := v79.FindInternedVar(lang.NewSymbol("apply")) -if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) -} -v81 := v80.Get() -v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v83 := v82.FindInternedVar(lang.NewSymbol("vector")) -if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) -} -v84 := v83.Get() -v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v86 := v85.FindInternedVar(lang.NewSymbol("seq")) -if v86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) -} -v87 := v86.Get() -v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v89 := v88.FindInternedVar(lang.NewSymbol("concat")) -if v89.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) -} -v90 := v89.Get() -v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v92 := v91.FindInternedVar(lang.NewSymbol("list")) -if v92.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) -} -v93 := v92.Get() -v94 := lang.Apply(v93, []any{lang.NewSymbol("n__0__auto__")}) -v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v96 := v95.FindInternedVar(lang.NewSymbol("list")) -if v96.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) -} -v97 := v96.Get() -v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v99 := v98.FindInternedVar(lang.NewSymbol("seq")) -if v99.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) -} -v100 := v99.Get() -v101 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v102 := v101.FindInternedVar(lang.NewSymbol("concat")) -if v102.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v102))) -} -v103 := v102.Get() -v104 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v105 := v104.FindInternedVar(lang.NewSymbol("list")) -if v105.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v105))) -} -v106 := v105.Get() -v107 := lang.Apply(v106, []any{lang.NewSymbol("glojure.core/long")}) -v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v109 := v108.FindInternedVar(lang.NewSymbol("list")) -if v109.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) -} -v110 := v109.Get() -v111 := lang.Apply(v110, []any{v60}) -v112 := lang.Apply(v103, []any{v107, v111}) -v113 := lang.Apply(v100, []any{v112}) -v114 := lang.Apply(v97, []any{v113}) -v115 := lang.Apply(v90, []any{v94, v114}) -v116 := lang.Apply(v87, []any{v115}) -v117 := lang.Apply(v81, []any{v84, v116}) -v118 := lang.Apply(v78, []any{v117}) -v119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v120 := v119.FindInternedVar(lang.NewSymbol("list")) -if v120.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v120))) -} -v121 := v120.Get() -v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v123 := v122.FindInternedVar(lang.NewSymbol("seq")) -if v123.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) -} -v124 := v123.Get() -v125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v126 := v125.FindInternedVar(lang.NewSymbol("concat")) -if v126.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v126))) -} -v127 := v126.Get() -v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v129 := v128.FindInternedVar(lang.NewSymbol("list")) -if v129.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v129))) -} -v130 := v129.Get() -v131 := lang.Apply(v130, []any{lang.NewSymbol("glojure.core/loop")}) -v132 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v133 := v132.FindInternedVar(lang.NewSymbol("list")) -if v133.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v133))) -} -v134 := v133.Get() -v135 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v136 := v135.FindInternedVar(lang.NewSymbol("apply")) -if v136.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v136))) -} -v137 := v136.Get() -v138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v139 := v138.FindInternedVar(lang.NewSymbol("vector")) -if v139.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v139))) -} -v140 := v139.Get() -v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v142 := v141.FindInternedVar(lang.NewSymbol("seq")) -if v142.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) -} -v143 := v142.Get() -v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v145 := v144.FindInternedVar(lang.NewSymbol("concat")) -if v145.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) -} -v146 := v145.Get() -v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v148 := v147.FindInternedVar(lang.NewSymbol("list")) -if v148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) +v147 := v146.Get() +v148 := lang.Apply(v147, []any{v6}) +v149 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v150 := v149.FindInternedVar(lang.NewSymbol("list")) +if v150.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v150))) } -v149 := v148.Get() -v150 := lang.Apply(v149, []any{v55}) -v151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v152 := v151.FindInternedVar(lang.NewSymbol("list")) -if v152.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v152))) +v151 := v150.Get() +v152 := lang.Apply(v151, []any{lang.NewSymbol("l__1__auto__")}) +v153 := lang.Apply(v140, []any{v144, v148, v152}) +v154 := lang.Apply(v137, []any{v153}) +v155 := lang.Apply(v134, []any{v154}) +v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v157 := v156.FindInternedVar(lang.NewSymbol("list")) +if v157.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) } -v153 := v152.Get() -v154 := lang.Apply(v153, []any{int64(0)}) -v155 := lang.Apply(v146, []any{v150, v154}) -v156 := lang.Apply(v143, []any{v155}) -v157 := lang.Apply(v137, []any{v140, v156}) -v158 := lang.Apply(v134, []any{v157}) +v158 := v157.Get() v159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v160 := v159.FindInternedVar(lang.NewSymbol("list")) +v160 := v159.FindInternedVar(lang.NewSymbol("seq")) if v160.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v160))) } v161 := v160.Get() v162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v163 := v162.FindInternedVar(lang.NewSymbol("seq")) +v163 := v162.FindInternedVar(lang.NewSymbol("concat")) if v163.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v163))) } v164 := v163.Get() v165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v166 := v165.FindInternedVar(lang.NewSymbol("concat")) +v166 := v165.FindInternedVar(lang.NewSymbol("list")) if v166.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v166))) } v167 := v166.Get() -v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v169 := v168.FindInternedVar(lang.NewSymbol("list")) -if v169.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) +v168 := lang.Apply(v167, []any{lang.NewSymbol("recur")}) +v169 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v170 := v169.FindInternedVar(lang.NewSymbol("list")) +if v170.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v170))) } -v170 := v169.Get() -v171 := lang.Apply(v170, []any{lang.NewSymbol("glojure.core/when")}) +v171 := v170.Get() v172 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v173 := v172.FindInternedVar(lang.NewSymbol("list")) +v173 := v172.FindInternedVar(lang.NewSymbol("seq")) if v173.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v173))) } v174 := v173.Get() v175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v176 := v175.FindInternedVar(lang.NewSymbol("seq")) +v176 := v175.FindInternedVar(lang.NewSymbol("concat")) if v176.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v176))) } v177 := v176.Get() v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v179 := v178.FindInternedVar(lang.NewSymbol("concat")) +v179 := v178.FindInternedVar(lang.NewSymbol("list")) if v179.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) } v180 := v179.Get() -v181 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v182 := v181.FindInternedVar(lang.NewSymbol("list")) -if v182.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v182))) -} -v183 := v182.Get() -v184 := lang.Apply(v183, []any{lang.NewSymbol("glojure.core/<")}) -v185 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v186 := v185.FindInternedVar(lang.NewSymbol("list")) -if v186.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v186))) +v181 := lang.Apply(v180, []any{lang.NewSymbol("glojure.core/unchecked-inc-int")}) +v182 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v183 := v182.FindInternedVar(lang.NewSymbol("list")) +if v183.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v183))) } -v187 := v186.Get() -v188 := lang.Apply(v187, []any{v55}) +v184 := v183.Get() +v185 := lang.Apply(v184, []any{v6}) +v186 := lang.Apply(v177, []any{v181, v185}) +v187 := lang.Apply(v174, []any{v186}) +v188 := lang.Apply(v171, []any{v187}) v189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v190 := v189.FindInternedVar(lang.NewSymbol("list")) if v190.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v190))) } v191 := v190.Get() -v192 := lang.Apply(v191, []any{lang.NewSymbol("n__0__auto__")}) -v193 := lang.Apply(v180, []any{v184, v188, v192}) -v194 := lang.Apply(v177, []any{v193}) -v195 := lang.Apply(v174, []any{v194}) +v192 := lang.Apply(v191, []any{v9}) +v193 := lang.Apply(v164, []any{v168, v188, v192}) +v194 := lang.Apply(v161, []any{v193}) +v195 := lang.Apply(v158, []any{v194}) v196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v197 := v196.FindInternedVar(lang.NewSymbol("list")) if v197.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v197))) } v198 := v197.Get() -v199 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v200 := v199.FindInternedVar(lang.NewSymbol("seq")) -if v200.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v200))) +v199 := lang.Apply(v198, []any{v7}) +v200 := lang.Apply(v127, []any{v131, v155, v195, v199}) +v201 := lang.Apply(v124, []any{v200}) +v202 := lang.Apply(v121, []any{v201}) +v203 := lang.Apply(v79, []any{v83, v118, v202}) +v204 := lang.Apply(v76, []any{v203}) +v205 := lang.Apply(v73, []any{v204}) +v206 := lang.Apply(v15, []any{v19, v70, v205}) +v207 := lang.Apply(v12, []any{v206}) +return v207 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v201 := v200.Get() -v202 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v203 := v202.FindInternedVar(lang.NewSymbol("concat")) -if v203.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v203))) } -v204 := v203.Get() -v205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v206 := v205.FindInternedVar(lang.NewSymbol("list")) -if v206.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v206))) +// array +{ +v0 := lang.NewSymbol("array").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3457), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3458), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("items"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.NewList(args[0:]...) +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("into-array")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v207 := v206.Get() -v208 := lang.Apply(v207, []any{lang.NewSymbol("recur")}) -v209 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v210 := v209.FindInternedVar(lang.NewSymbol("list")) -if v210.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v210))) +v6 := v5.Get() +v7 := lang.Apply(v6, []any{v3}) +return v7 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v211 := v210.Get() -v212 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v213 := v212.FindInternedVar(lang.NewSymbol("seq")) -if v213.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v213))) } -v214 := v213.Get() -v215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v216 := v215.FindInternedVar(lang.NewSymbol("concat")) -if v216.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v216))) +// array-map +{ +v0 := lang.NewSymbol("array-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keyvals"))), lang.NewKeyword("doc"), "Constructs an array-map. If any keys are equal, they are handled as\n if by repeated uses of assoc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4378), lang.NewKeyword("end-line"), int(4378))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v3, ok := lang.FieldOrMethod(glojure.lang8.PersistentArrayMap, "EMPTY") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", glojure.lang8.PersistentArrayMap, "EMPTY"))) } -v217 := v216.Get() -v218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v219 := v218.FindInternedVar(lang.NewSymbol("list")) -if v219.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v219))) +var v4 any +switch reflect.TypeOf(v3).Kind() { +case reflect.Func: + v4 = lang.Apply(v3, nil) +default: + v4 = v3 } -v220 := v219.Get() -v221 := lang.Apply(v220, []any{lang.NewSymbol("glojure.core/unchecked-inc")}) -v222 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v223 := v222.FindInternedVar(lang.NewSymbol("list")) -if v223.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v223))) +return v4 + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.NewList(args[0:]...) +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("to-array")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v224 := v223.Get() -v225 := lang.Apply(v224, []any{v55}) -v226 := lang.Apply(v217, []any{v221, v225}) -v227 := lang.Apply(v214, []any{v226}) -v228 := lang.Apply(v211, []any{v227}) -v229 := lang.Apply(v204, []any{v208, v228}) -v230 := lang.Apply(v201, []any{v229}) -v231 := lang.Apply(v198, []any{v230}) -v232 := lang.Apply(v167, []any{v171, v195, v6, v231}) -v233 := lang.Apply(v164, []any{v232}) -v234 := lang.Apply(v161, []any{v233}) -v235 := lang.Apply(v127, []any{v131, v158, v234}) -v236 := lang.Apply(v124, []any{v235}) -v237 := lang.Apply(v121, []any{v236}) -v238 := lang.Apply(v71, []any{v75, v118, v237}) -v239 := lang.Apply(v68, []any{v238}) -return v239 +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +var v4 any = v8 +_ = v4 +var v10 any +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("odd?")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("alength")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v4}) +v18 := lang.Apply(v13, []any{v17}) +if lang.IsTruthy(v18) { +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("str")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("last")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v3}) +v26 := lang.Apply(v21, []any{"No value supplied for key: ", v25}) +v27 := lang.Apply(lang1.NewIllegalArgumentError, []any{v26}) +panic(v27) +} else { +v28 := lang.Apply(lang1.NewPersistentArrayMapAsIfByAssoc, []any{v4}) +v10 = v28 +} +return v10 } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -9063,27 +8723,168 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// aset +// as-> { -var v1 lang.FnFunc -{ // function aset__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } +v0 := lang.NewSymbol("as->").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "Binds name to expr, evaluates the first form in the lexical context\n of that binding, then binds name to that result, repeating for each\n successive form, returning the result of the last form.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7641), lang.NewKeyword("end-line"), int(7641))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] v4 := args[1] v5 := args[2] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("seq")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +v6 := args[3] +v7 := lang.NewList(args[4:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("seq")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("concat")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("concat")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("glojure.core/let")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("apply")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("vector")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("seq")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("concat")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("list")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v6}) +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("list")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v5}) +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("interleave")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("repeat")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v6}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("butlast")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v7}) +v52 := lang.Apply(v43, []any{v47, v51}) +v53 := lang.Apply(v32, []any{v36, v40, v52}) +v54 := lang.Apply(v29, []any{v53}) +v55 := lang.Apply(v23, []any{v26, v54}) +v56 := lang.Apply(v20, []any{v55}) +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("list")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +} +v59 := v58.Get() +var v60 any +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("empty?")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +} +v63 := v62.Get() +v64 := lang.Apply(v63, []any{v7}) +if lang.IsTruthy(v64) { +v60 = v6 +} else { +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("last")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +} +v67 := v66.Get() +v68 := lang.Apply(v67, []any{v7}) +v60 = v68 +} +v69 := lang.Apply(v59, []any{v60}) +v70 := lang.Apply(v13, []any{v17, v56, v69}) +v71 := lang.Apply(v10, []any{v70}) +return v71 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// aset +{ +var v1 lang.FnFunc +{ // function aset__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("seq")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("concat")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } v11 := v10.Get() v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) @@ -9232,74 +9033,120 @@ if v0.Meta() != nil { v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// *default-data-reader-fn* +// aset-boolean { -v0 := lang.NewSymbol("*default-data-reader-fn*").WithMeta(lang.NewMap(lang.NewKeyword("doc"), "When no data reader is found for a tag and *default-data-reader-fn*\n is non-nil, it will be called with two arguments,\n the tag and the value. If *default-data-reader-fn* is nil (the\n default), an exception will be thrown for the unknown tag.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(59), lang.NewKeyword("column"), int(6), lang.NewKeyword("line"), int(7866), lang.NewKeyword("end-line"), int(7866), lang.NewKeyword("dynamic"), true)).(*lang.Symbol) -v1 := ns.InternWithValue(v0, nil, true) +v0 := lang.NewSymbol("aset-boolean").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of boolean. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3956), lang.NewKeyword("end-line"), int(3958))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("boolean")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v5}) +v10, _ := lang.FieldOrMethod(nil, "setBoolean") +if reflect.TypeOf(v10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setBoolean is not a function"))) +} +v11 := lang.Apply(v10, []any{v3, v4, v9}) +_ = v11 +return v5 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("apply")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("aset-boolean")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("aget")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v3, v4}) +v17 := lang.Apply(v9, []any{v12, v16, v5, v6}) +return v17 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// disj! +// aset-byte { -v0 := lang.NewSymbol("disj!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("set")), lang.NewVector(lang.NewSymbol("set"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("set"), lang.NewSymbol("key"), lang.NewSymbol("&"), lang.NewSymbol("ks"))), lang.NewKeyword("doc"), "disj[oin]. Returns a transient set of the same (hashed/sorted) type, that\n does not contain key(s).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3401), lang.NewKeyword("end-line"), int(3401))).(*lang.Symbol) +v0 := lang.NewSymbol("aset-byte").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of byte. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3976), lang.NewKeyword("end-line"), int(3978))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 1: -v3 := args[0] -return v3 - case 2: + case 3: v3 := args[0] v4 := args[1] -v5, _ := lang.FieldOrMethod(v3, "Disjoin") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Disjoin is not a function"))) +v5 := args[2] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("byte")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v6 := lang.Apply(v5, []any{v4}) -return v6 +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v5}) +v10, _ := lang.FieldOrMethod(nil, "setByte") +if reflect.TypeOf(v10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setByte is not a function"))) +} +v11 := lang.Apply(v10, []any{v3, v4, v9}) +_ = v11 +return v5 default: - if len(args) < 2 { + if len(args) < 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] v4 := args[1] -v5 := lang.NewList(args[2:]...) -recur_loop_615: -v7, _ := lang.FieldOrMethod(v3, "Disjoin") -if reflect.TypeOf(v7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Disjoin is not a function"))) +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("apply")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v8 := lang.Apply(v7, []any{v4}) -var v6 any = v8 -_ = v6 -var v10 any -if lang.IsTruthy(v5) { -var v11 any = v6 +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("aset-byte")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("first")) +v14 := v13.FindInternedVar(lang.NewSymbol("aget")) if v14.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } v15 := v14.Get() -v16 := lang.Apply(v15, []any{v5}) -var v12 any = v16 -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("next")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v20, []any{v5}) -var v17 any = v21 -v3 = v11 -v4 = v12 -v5 = v17 -goto recur_loop_615 -} else { -v10 = v6 -} -return v10 +v16 := lang.Apply(v15, []any{v3, v4}) +v17 := lang.Apply(v9, []any{v12, v16, v5, v6}) +return v17 } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -9308,31 +9155,60 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// print-object +// aset-char { -v0 := lang.NewSymbol("print-object").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(115), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(115), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v0 := lang.NewSymbol("aset-char").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of char. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3981), lang.NewKeyword("end-line"), int(3983))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + switch len(args) { + case 3: v3 := args[0] v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("print-tagged-object")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v5 := args[2] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("char")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("str")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v5}) +v10, _ := lang.FieldOrMethod(nil, "setChar") +if reflect.TypeOf(v10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setChar is not a function"))) } -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v3}) -v12 := lang.Apply(v7, []any{v3, v11, v4}) -return v12 +v11 := lang.Apply(v10, []any{v3, v4, v9}) +_ = v11 +return v5 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("apply")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("aset-char")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("aget")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v3, v4}) +v17 := lang.Apply(v9, []any{v12, v16, v5, v6}) +return v17 + } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -9340,16 +9216,60 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// all-ns +// aset-double { -v0 := lang.NewSymbol("all-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Returns a sequence of all namespaces.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4146), lang.NewKeyword("end-line"), int(4146))).(*lang.Symbol) +v0 := lang.NewSymbol("aset-double").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of double. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3966), lang.NewKeyword("end-line"), int(3968))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + switch len(args) { + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("double")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v5}) +v10, _ := lang.FieldOrMethod(nil, "setDouble") +if reflect.TypeOf(v10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setDouble is not a function"))) +} +v11 := lang.Apply(v10, []any{v3, v4, v9}) +_ = v11 +return v5 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("apply")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("aset-double")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("aget")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v3, v4}) +v17 := lang.Apply(v9, []any{v12, v16, v5, v6}) +return v17 } -v3 := lang.Apply(nil, nil) -return v3 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -9357,212 +9277,121 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// not +// aset-float { -v1 := reflect.TypeOf(false) -v0 := lang.NewSymbol("not").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is logical false, false otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(523), lang.NewKeyword("end-line"), int(523))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -var v5 any -if lang.IsTruthy(v4) { -v5 = false -} else { -v5 = true +v0 := lang.NewSymbol("aset-float").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of float. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3961), lang.NewKeyword("end-line"), int(3963))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("float")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v5}) +v10, _ := lang.FieldOrMethod(nil, "setFloat") +if reflect.TypeOf(v10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setFloat is not a function"))) } +v11 := lang.Apply(v10, []any{v3, v4, v9}) +_ = v11 return v5 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("apply")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("aset-float")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("aget")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v3, v4}) +v17 := lang.Apply(v9, []any{v12, v16, v5, v6}) +return v17 + } }) -v4 := reflect.TypeOf(false) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// biginteger +// aset-int { -v1 := reflect.TypeOf((*big9.Int)(nil)) -v0 := lang.NewSymbol("biginteger").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Coerce to BigInteger", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3634), lang.NewKeyword("end-line"), int(3634))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -var v5 any +v0 := lang.NewSymbol("aset-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of int. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3946), lang.NewKeyword("end-line"), int(3948))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) +v7 := v6.FindInternedVar(lang.NewSymbol("int")) if v7.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } v8 := v7.Get() -v9 := lang.Apply(v8, []any{big9.*Int, v4}) -if lang.IsTruthy(v9) { -v5 = v4 -} else { -var v10 any -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("instance?")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{lang1.*BigInt, v4}) -if lang.IsTruthy(v14) { -v15, ok := lang.FieldOrMethod(v4, "toBigInteger") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "toBigInteger"))) -} -var v16 any -switch reflect.TypeOf(v15).Kind() { -case reflect.Func: - v16 = lang.Apply(v15, nil) -default: - v16 = v15 -} -v10 = v16 -} else { -var v17 any -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("decimal?")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v20, []any{v4}) -if lang.IsTruthy(v21) { -v22, ok := lang.FieldOrMethod(v4, "toBigInteger") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "toBigInteger"))) -} -var v23 any -switch reflect.TypeOf(v22).Kind() { -case reflect.Func: - v23 = lang.Apply(v22, nil) -default: - v23 = v22 -} -v17 = v23 -} else { -var v24 any -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("float?")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.Apply(v27, []any{v4}) -if lang.IsTruthy(v28) { -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("double")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.Apply(v31, []any{v4}) -v33 := lang.Apply(lang1.NewBigDecimalFromFloat64, []any{v32}) -v34, ok := lang.FieldOrMethod(v33, "toBigInteger") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v33, "toBigInteger"))) -} -var v35 any -switch reflect.TypeOf(v34).Kind() { -case reflect.Func: - v35 = lang.Apply(v34, nil) -default: - v35 = v34 -} -v24 = v35 -} else { -var v36 any -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("ratio?")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v4}) -if lang.IsTruthy(v40) { -v41, ok := lang.FieldOrMethod(v4, "bigIntegerValue") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "bigIntegerValue"))) -} -var v42 any -switch reflect.TypeOf(v41).Kind() { -case reflect.Func: - v42 = lang.Apply(v41, nil) -default: - v42 = v41 -} -v36 = v42 -} else { -var v43 any -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("number?")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v4}) -if lang.IsTruthy(v47) { -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("long")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v4}) -v52 := lang.Apply(big9.NewInt, []any{v51}) -v43 = v52 -} else { -var v53 any -if lang.IsTruthy(lang.NewKeyword("else")) { -v54 := lang.Apply(BigInteger12., []any{v4}) -v53 = v54 -} else { -v53 = nil -} -v43 = v53 -} -v36 = v43 -} -v24 = v36 -} -v17 = v24 -} -v10 = v17 -} -v5 = v10 +v9 := lang.Apply(v8, []any{v5}) +v10, _ := lang.FieldOrMethod(nil, "setInt") +if reflect.TypeOf(v10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setInt is not a function"))) } +v11 := lang.Apply(v10, []any{v3, v4, v9}) +_ = v11 return v5 -}) -v4 := reflect.TypeOf((*big9.Int)(nil)) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("apply")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("aset-int")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -// uuid? -{ -v0 := lang.NewSymbol("uuid?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a java.util.UUID", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6890), lang.NewKeyword("end-line"), int(6890))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("aget")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } -v6 := v5.Get() -v7 := lang.Apply(v6, []any{java.util13.UUID, v3}) -return v7 +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v3, v4}) +v17 := lang.Apply(v9, []any{v12, v16, v5, v6}) +return v17 + } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -9570,126 +9399,59 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// .. +// aset-long { -v0 := lang.NewSymbol("..").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("form")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("form"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "form => fieldName-symbol or (instanceMethodName-symbol args*)\n\n Expands into a member access (.) of the first member on the first\n argument, followed by the next member on the result, etc. For\n instance:\n\n (.. System (getProperties) (get \"os.name\"))\n\n expands to:\n\n (. (. System (getProperties)) (get \"os.name\"))\n\n but is easier to write, read, and understand.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1657), lang.NewKeyword("end-line"), int(1657))).(*lang.Symbol) +v0 := lang.NewSymbol("aset-long").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of long. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3951), lang.NewKeyword("end-line"), int(3953))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 4: + case 3: v3 := args[0] v4 := args[1] v5 := args[2] -v6 := args[3] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("long")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v5}) +v10, _ := lang.FieldOrMethod(nil, "setLong") +if reflect.TypeOf(v10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setLong is not a function"))) +} +v11 := lang.Apply(v10, []any{v3, v4, v9}) +_ = v11 +return v5 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("seq")) +v8 := v7.FindInternedVar(lang.NewSymbol("apply")) if v8.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } v9 := v8.Get() v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("concat")) +v11 := v10.FindInternedVar(lang.NewSymbol("aset-long")) if v11.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } v12 := v11.Get() v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("list")) +v14 := v13.FindInternedVar(lang.NewSymbol("aget")) if v14.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } v15 := v14.Get() -v16 := lang.Apply(v15, []any{lang.NewSymbol(".")}) -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("list")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v5}) -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("list")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v6}) -v25 := lang.Apply(v12, []any{v16, v20, v24}) -v26 := lang.Apply(v9, []any{v25}) -return v26 - default: - if len(args) < 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := lang.NewList(args[4:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("seq")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("concat")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("..")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol(".")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v5}) -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("list")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v6}) -v39 := lang.Apply(v26, []any{v30, v34, v38}) -v40 := lang.Apply(v23, []any{v39}) -v41 := lang.Apply(v20, []any{v40}) -v42 := lang.Apply(v13, []any{v17, v41, v7}) -v43 := lang.Apply(v10, []any{v42}) -return v43 +v16 := lang.Apply(v15, []any{v3, v4}) +v17 := lang.Apply(v9, []any{v12, v16, v5, v6}) +return v17 } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -9698,111 +9460,59 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// not-every? +// aset-short { -v1 := reflect.TypeOf(false) -v0 := lang.NewSymbol("not-every?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns false if (pred x) is logical true for every x in\n coll, else true.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(2677), lang.NewKeyword("end-line"), int(2682))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { +v0 := lang.NewSymbol("aset-short").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of short. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3971), lang.NewKeyword("end-line"), int(3973))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 0: -v4 := lang.Apply(closed2, nil) -v5 := lang.Apply(closed1, []any{v4}) -return v5 - case 1: -v4 := args[0] -v5 := lang.Apply(closed2, []any{v4}) -v6 := lang.Apply(closed1, []any{v5}) -return v6 - case 2: -v4 := args[0] -v5 := args[1] -v6 := lang.Apply(closed2, []any{v4, v5}) -v7 := lang.Apply(closed1, []any{v6}) -return v7 case 3: -v4 := args[0] -v5 := args[1] -v6 := args[2] -v7 := lang.Apply(closed2, []any{v4, v5, v6}) -v8 := lang.Apply(closed1, []any{v7}) -return v8 +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("short")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v5}) +v10, _ := lang.FieldOrMethod(nil, "setShort") +if reflect.TypeOf(v10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setShort is not a function"))) +} +v11 := lang.Apply(v10, []any{v3, v4, v9}) +_ = v11 +return v5 default: if len(args) < 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v4 := args[0] -v5 := args[1] -v6 := args[2] -v7 := lang.NewList(args[3:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("apply")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{closed2, v4, v5, v6, v7}) -v12 := lang.Apply(closed1, []any{v11}) -return v12 - } -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2559), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2564), lang.NewKeyword("end-column"), int(49))).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// system-newline -{ -v0 := lang.NewSymbol("system-newline").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3695), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(3695), lang.NewKeyword("end-column"), int(40), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, "\n", true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// remove -{ -v0 := lang.NewSymbol("remove").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred")), lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the items in coll for which\n (pred item) returns logical false. pred must be free of side-effects.\n Returns a transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2818), lang.NewKeyword("end-line"), int(2818))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("filter")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("complement")) +v8 := v7.FindInternedVar(lang.NewSymbol("apply")) if v8.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } v9 := v8.Get() -v10 := lang.Apply(v9, []any{v3}) -v11 := lang.Apply(v6, []any{v10}) -return v11 - case 2: -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("filter")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("aset-short")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("complement")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("aget")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v3}) -v12 := lang.Apply(v7, []any{v11, v4}) -return v12 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v3, v4}) +v17 := lang.Apply(v9, []any{v12, v16, v5, v6}) +return v17 } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -9811,482 +9521,442 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// maybe-min-hash +// assert { -v0 := lang.NewSymbol("maybe-min-hash").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("hashes"))), lang.NewKeyword("doc"), "takes a collection of hashes and returns [shift mask] or nil if none found", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6647), lang.NewKeyword("end-line"), int(6647), lang.NewKeyword("private"), true)).(*lang.Symbol) +v0 := lang.NewSymbol("assert").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("message"))), lang.NewKeyword("doc"), "Evaluates expression x and throws an AssertionError with optional\n message if x does not evaluate to logical true.\n\n Assertion checks are omitted from compiled code if '*assert*' is\n false.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4837), lang.NewKeyword("end-line"), int(4837))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + switch len(args) { + case 3: v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("first")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() +v4 := args[1] +v5 := args[2] +var v6 any v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("filter")) +v8 := v7.FindInternedVar(lang.NewSymbol("*assert*")) if v8.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } v9 := v8.Get() -var v10 lang.FnFunc -v10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v11 := args[0] -var v12 any = v11 -_ = v12 -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("nth")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +if lang.IsTruthy(v9) { +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("seq")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v12, int64(0), nil}) -var v13 any = v17 -_ = v13 -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("nth")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("concat")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v12, int64(1), nil}) -var v18 any = v22 -_ = v18 +v15 := v14.Get() +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("list")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{lang.NewSymbol("glojure.core/when-not")}) +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("list")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.Apply(v22, []any{v5}) v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("apply")) +v25 := v24.FindInternedVar(lang.NewSymbol("list")) if v25.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } v26 := v25.Get() v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("distinct?")) +v28 := v27.FindInternedVar(lang.NewSymbol("seq")) if v28.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } v29 := v28.Get() v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("map")) +v31 := v30.FindInternedVar(lang.NewSymbol("concat")) if v31.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) } v32 := v31.Get() -var v33 lang.FnFunc -v33 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v34 := args[0] -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("shift-mask")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v13, v18, v34}) -return v38 -}) -v34 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6652), lang.NewKeyword("column"), int(37), lang.NewKeyword("end-line"), int(6652), lang.NewKeyword("end-column"), int(55)) -v35, err := lang.WithMeta(v33, v34.(lang.IPersistentMap)) -if err != nil { - panic(err) +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("list")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) } -v36 := lang.Apply(v32, []any{v35, v3}) -v37 := lang.Apply(v26, []any{v29, v36}) -return v37 -}) -v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6651), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(6652), lang.NewKeyword("end-column"), int(65)) -v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v14 lang.FnFunc -{ // function iter__181 -v14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v16 := args[0] -var v17 lang.FnFunc -v17 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -var v18 any = v18 -_ = v18 -var v19 any -for { -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +v35 := v34.Get() +v36 := lang.Apply(v35, []any{lang.NewSymbol("throw")}) +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("list")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v18}) -var v20 any = v24 -_ = v20 -var v26 any -if lang.IsTruthy(v20) { -var v27 any = v20 -_ = v27 -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("first")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("seq")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) } -v32 := v31.Get() -v33 := lang.Apply(v32, []any{v27}) -var v29 any = v33 -_ = v29 -var v36 lang.FnFunc -{ // function iter__183 -v36 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v38 := args[0] -var v39 lang.FnFunc -v39 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -var v40 any = v40 -_ = v40 -var v41 any -for { +v42 := v41.Get() v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("seq")) +v44 := v43.FindInternedVar(lang.NewSymbol("concat")) if v44.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) } v45 := v44.Get() -v46 := lang.Apply(v45, []any{v40}) -var v42 any = v46 -_ = v42 -var v48 any -if lang.IsTruthy(v42) { -var v49 any = v42 -_ = v49 -var v51 any -v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("chunked-seq?")) -if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("list")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) } -v54 := v53.Get() -v55 := lang.Apply(v54, []any{v49}) -if lang.IsTruthy(v55) { +v48 := v47.Get() +v49 := lang.Apply(v48, []any{lang.NewSymbol("new")}) +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("list")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +} +v52 := v51.Get() +v53 := lang.Apply(v52, []any{lang.NewSymbol("glojure.core/AssertionError")}) +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("list")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +} +v56 := v55.Get() v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("chunk-first")) +v58 := v57.FindInternedVar(lang.NewSymbol("seq")) if v58.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) } v59 := v58.Get() -v60 := lang.Apply(v59, []any{v49}) -var v56 any = v60 -_ = v56 -v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v63 := v62.FindInternedVar(lang.NewSymbol("int")) -if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v61 := v60.FindInternedVar(lang.NewSymbol("concat")) +if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) } -v64 := v63.Get() -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("count")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +v62 := v61.Get() +v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v64 := v63.FindInternedVar(lang.NewSymbol("list")) +if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) } -v67 := v66.Get() -v68 := lang.Apply(v67, []any{v56}) -v69 := lang.Apply(v64, []any{v68}) -var v61 any = v69 -_ = v61 +v65 := v64.Get() +v66 := lang.Apply(v65, []any{lang.NewSymbol("glojure.core/str")}) +v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v68 := v67.FindInternedVar(lang.NewSymbol("list")) +if v68.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) +} +v69 := v68.Get() +v70 := lang.Apply(v69, []any{"Assert failed: "}) v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v72 := v71.FindInternedVar(lang.NewSymbol("chunk-buffer")) +v72 := v71.FindInternedVar(lang.NewSymbol("list")) if v72.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) } v73 := v72.Get() -v74 := lang.Apply(v73, []any{v61}) -var v70 any = v74 -_ = v70 -var v76 any -v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v79 := v78.FindInternedVar(lang.NewSymbol("int")) -if v79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) -} -v80 := v79.Get() -v81 := lang.Apply(v80, []any{int64(0)}) -var v77 any = v81 -_ = v77 -var v82 any -for { -var v83 any -v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v85 := v84.FindInternedVar(lang.NewSymbol("<")) -if v85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) -} -v86 := v85.Get() -v87 := lang.Apply(v86, []any{v77, v61}) -if lang.IsTruthy(v87) { -v89, _ := lang.FieldOrMethod(v56, "nth") -if reflect.TypeOf(v89).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) -} -v90 := lang.Apply(v89, []any{v77}) -var v88 any = v90 -_ = v88 -v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v93 := v92.FindInternedVar(lang.NewSymbol("chunk-append")) -if v93.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) -} -v94 := v93.Get() -v95 := lang.NewVector(v88, v29) -v96 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6655), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(6655), lang.NewKeyword("end-column"), int(26)) -v97, err := lang.WithMeta(v95, v96.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v98 := lang.Apply(v94, []any{v70, v97}) -_ = v98 -v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v101 := v100.FindInternedVar(lang.NewSymbol("unchecked-inc")) -if v101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) -} -v102 := v101.Get() -v103 := lang.Apply(v102, []any{v77}) -var v99 any = v103 -v77 = v99 -continue -} else { -v83 = true -} -v82 = v83 - break +v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v75 := v74.FindInternedVar(lang.NewSymbol("seq")) +if v75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) } -if lang.IsTruthy(v82) { +v76 := v75.Get() v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v78 := v77.FindInternedVar(lang.NewSymbol("chunk-cons")) +v78 := v77.FindInternedVar(lang.NewSymbol("concat")) if v78.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) } v79 := v78.Get() v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v81 := v80.FindInternedVar(lang.NewSymbol("chunk")) +v81 := v80.FindInternedVar(lang.NewSymbol("list")) if v81.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) } v82 := v81.Get() -v83 := lang.Apply(v82, []any{v70}) +v83 := lang.Apply(v82, []any{lang.NewSymbol("glojure.core/pr-str")}) v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v85 := v84.FindInternedVar(lang.NewSymbol("chunk-rest")) +v85 := v84.FindInternedVar(lang.NewSymbol("list")) if v85.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) } v86 := v85.Get() -v87 := lang.Apply(v86, []any{v49}) -v88 := lang.Apply(v37, []any{v87}) -v89 := lang.Apply(v79, []any{v83, v88}) -v76 = v89 -} else { +v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v88 := v87.FindInternedVar(lang.NewSymbol("seq")) +if v88.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) +} +v89 := v88.Get() v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v91 := v90.FindInternedVar(lang.NewSymbol("chunk-cons")) +v91 := v90.FindInternedVar(lang.NewSymbol("concat")) if v91.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) } v92 := v91.Get() v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v94 := v93.FindInternedVar(lang.NewSymbol("chunk")) +v94 := v93.FindInternedVar(lang.NewSymbol("list")) if v94.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) } v95 := v94.Get() -v96 := lang.Apply(v95, []any{v70}) -v97 := lang.Apply(v92, []any{v96, nil}) -v76 = v97 +v96 := lang.Apply(v95, []any{lang.NewSymbol("quote")}) +v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v98 := v97.FindInternedVar(lang.NewSymbol("list")) +if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) } -v51 = v76 +v99 := v98.Get() +v100 := lang.Apply(v99, []any{v5}) +v101 := lang.Apply(v92, []any{v96, v100}) +v102 := lang.Apply(v89, []any{v101}) +v103 := lang.Apply(v86, []any{v102}) +v104 := lang.Apply(v79, []any{v83, v103}) +v105 := lang.Apply(v76, []any{v104}) +v106 := lang.Apply(v73, []any{v105}) +v107 := lang.Apply(v62, []any{v66, v70, v106}) +v108 := lang.Apply(v59, []any{v107}) +v109 := lang.Apply(v56, []any{v108}) +v110 := lang.Apply(v45, []any{v49, v53, v109}) +v111 := lang.Apply(v42, []any{v110}) +v112 := lang.Apply(v39, []any{v111}) +v113 := lang.Apply(v32, []any{v36, v112}) +v114 := lang.Apply(v29, []any{v113}) +v115 := lang.Apply(v26, []any{v114}) +v116 := lang.Apply(v15, []any{v19, v23, v115}) +v117 := lang.Apply(v12, []any{v116}) +v6 = v117 } else { -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("first")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +v6 = nil } -v59 := v58.Get() -v60 := lang.Apply(v59, []any{v49}) -var v56 any = v60 -_ = v56 -v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v63 := v62.FindInternedVar(lang.NewSymbol("cons")) -if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +return v6 + case 4: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +var v7 any +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("*assert*")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v64 := v63.Get() -v65 := lang.NewVector(v56, v29) -v66 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6655), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(6655), lang.NewKeyword("end-column"), int(26)) -v67, err := lang.WithMeta(v65, v66.(lang.IPersistentMap)) -if err != nil { - panic(err) +v10 := v9.Get() +if lang.IsTruthy(v10) { +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("seq")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v69 := v68.FindInternedVar(lang.NewSymbol("rest")) -if v69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("concat")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v70 := v69.Get() -v71 := lang.Apply(v70, []any{v49}) -v72 := lang.Apply(v37, []any{v71}) -v73 := lang.Apply(v64, []any{v67, v72}) -v51 = v73 +v16 := v15.Get() +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("list")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v48 = v51 -} else { -v48 = nil +v19 := v18.Get() +v20 := lang.Apply(v19, []any{lang.NewSymbol("glojure.core/when-not")}) +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("list")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v41 = v48 - break +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v5}) +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("list")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -return v41 -}) -v40 := lang.Apply(lang1.NewLazySeq, []any{v39}) -return v40 -}) -v37 := v36 -_ = v37 +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("seq")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } -var v35 any = v36 -_ = v35 +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("concat")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("list")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.Apply(v36, []any{lang.NewSymbol("throw")}) v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("seq")) +v39 := v38.FindInternedVar(lang.NewSymbol("list")) if v39.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) } v40 := v39.Get() v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("range")) +v42 := v41.FindInternedVar(lang.NewSymbol("seq")) if v42.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } v43 := v42.Get() -v44 := lang.Apply(v43, []any{int64(0), int64(31)}) -v45 := lang.Apply(v35, []any{v44}) -v46 := lang.Apply(v40, []any{v45}) -var v37 any = v46 -_ = v37 -var v48 any -if lang.IsTruthy(v37) { -v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v50 := v49.FindInternedVar(lang.NewSymbol("concat")) -if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("concat")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } -v51 := v50.Get() -v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("rest")) -if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) +v46 := v45.Get() +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("list")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) } -v54 := v53.Get() -v55 := lang.Apply(v54, []any{v18}) -v56 := lang.Apply(v15, []any{v55}) -v57 := lang.Apply(v51, []any{v37, v56}) -v48 = v57 -} else { -v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v60 := v59.FindInternedVar(lang.NewSymbol("rest")) -if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) +v49 := v48.Get() +v50 := lang.Apply(v49, []any{lang.NewSymbol("new")}) +v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v52 := v51.FindInternedVar(lang.NewSymbol("list")) +if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) } -v61 := v60.Get() -v62 := lang.Apply(v61, []any{v18}) -var v58 any = v62 -v18 = v58 -continue +v53 := v52.Get() +v54 := lang.Apply(v53, []any{lang.NewSymbol("glojure.core/AssertionError")}) +v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v56 := v55.FindInternedVar(lang.NewSymbol("list")) +if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) } -v26 = v48 -} else { -v26 = nil +v57 := v56.Get() +v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v59 := v58.FindInternedVar(lang.NewSymbol("seq")) +if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) } -v19 = v26 - break +v60 := v59.Get() +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("concat")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) } -return v19 -}) -v18 := lang.Apply(lang1.NewLazySeq, []any{v17}) -return v18 -}) -v15 := v14 -_ = v15 +v63 := v62.Get() +v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v65 := v64.FindInternedVar(lang.NewSymbol("list")) +if v65.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) } -var v13 any = v14 -_ = v13 -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("map")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +v66 := v65.Get() +v67 := lang.Apply(v66, []any{lang.NewSymbol("glojure.core/str")}) +v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v69 := v68.FindInternedVar(lang.NewSymbol("list")) +if v69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) } -v18 := v17.Get() -var v19 lang.FnFunc -v19 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v20 := args[0] -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("dec")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +v70 := v69.Get() +v71 := lang.Apply(v70, []any{"Assert failed: "}) +v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v73 := v72.FindInternedVar(lang.NewSymbol("list")) +if v73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) } -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("bit-shift-left")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +v74 := v73.Get() +v75 := lang.Apply(v74, []any{v6}) +v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v77 := v76.FindInternedVar(lang.NewSymbol("list")) +if v77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) } -v26 := v25.Get() -v27 := lang.Apply(v26, []any{int64(1), v20}) -v28 := lang.Apply(v23, []any{v27}) -return v28 -}) -v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6653), lang.NewKeyword("column"), int(29), lang.NewKeyword("end-line"), int(6653), lang.NewKeyword("end-column"), int(55)) -v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) -if err != nil { - panic(err) +v78 := v77.Get() +v79 := lang.Apply(v78, []any{"\n"}) +v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v81 := v80.FindInternedVar(lang.NewSymbol("list")) +if v81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) } -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("range")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v82 := v81.Get() +v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v84 := v83.FindInternedVar(lang.NewSymbol("seq")) +if v84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) } -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("inc")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +v85 := v84.Get() +v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v87 := v86.FindInternedVar(lang.NewSymbol("concat")) +if v87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) } -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("max-mask-bits")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +v88 := v87.Get() +v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v90 := v89.FindInternedVar(lang.NewSymbol("list")) +if v90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) } -v30 := v29.Get() -v31 := lang.Apply(v27, []any{v30}) -v32 := lang.Apply(v24, []any{int64(1), v31}) -v33 := lang.Apply(v18, []any{v21, v32}) -v34 := lang.Apply(v13, []any{v33}) -v13 := lang.Apply(v9, []any{v12, v34}) -v14 := lang.Apply(v6, []any{v13}) -return v14 +v91 := v90.Get() +v92 := lang.Apply(v91, []any{lang.NewSymbol("glojure.core/pr-str")}) +v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v94 := v93.FindInternedVar(lang.NewSymbol("list")) +if v94.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) +} +v95 := v94.Get() +v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v97 := v96.FindInternedVar(lang.NewSymbol("seq")) +if v97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) +} +v98 := v97.Get() +v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v100 := v99.FindInternedVar(lang.NewSymbol("concat")) +if v100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) +} +v101 := v100.Get() +v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v103 := v102.FindInternedVar(lang.NewSymbol("list")) +if v103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) +} +v104 := v103.Get() +v105 := lang.Apply(v104, []any{lang.NewSymbol("quote")}) +v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v107 := v106.FindInternedVar(lang.NewSymbol("list")) +if v107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) +} +v108 := v107.Get() +v109 := lang.Apply(v108, []any{v5}) +v110 := lang.Apply(v101, []any{v105, v109}) +v111 := lang.Apply(v98, []any{v110}) +v112 := lang.Apply(v95, []any{v111}) +v113 := lang.Apply(v88, []any{v92, v112}) +v114 := lang.Apply(v85, []any{v113}) +v115 := lang.Apply(v82, []any{v114}) +v116 := lang.Apply(v63, []any{v67, v71, v75, v79, v115}) +v117 := lang.Apply(v60, []any{v116}) +v118 := lang.Apply(v57, []any{v117}) +v119 := lang.Apply(v46, []any{v50, v54, v118}) +v120 := lang.Apply(v43, []any{v119}) +v121 := lang.Apply(v40, []any{v120}) +v122 := lang.Apply(v33, []any{v37, v121}) +v123 := lang.Apply(v30, []any{v122}) +v124 := lang.Apply(v27, []any{v123}) +v125 := lang.Apply(v16, []any{v20, v24, v124}) +v126 := lang.Apply(v13, []any{v125}) +v7 = v126 +} else { +v7 = nil +} +return v7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -10294,345 +9964,336 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// rem +// assert-args { -var v1 lang.FnFunc -{ // function rem__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } +v0 := lang.NewSymbol("assert-args").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("pairs"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(38), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1830), lang.NewKeyword("end-line"), int(1830), lang.NewKeyword("private"), true)).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v5 := lang.NewList(args[2:]...) +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("seq")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("concat")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("concat")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("list")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("list")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } -v13 := v12.Get() -v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +v14 := v13.Get() +v15 := lang.Apply(v14, []any{lang.NewSymbol("do")}) +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("list")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := v17.Get() v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) +v20 := v19.FindInternedVar(lang.NewSymbol("seq")) if v20.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } v21 := v20.Get() v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("seq")) +v23 := v22.FindInternedVar(lang.NewSymbol("concat")) if v23.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } v24 := v23.Get() v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("concat")) +v26 := v25.FindInternedVar(lang.NewSymbol("list")) if v26.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("list")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +v28 := lang.Apply(v27, []any{lang.NewSymbol("glojure.core/when-not")}) +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("list")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) } -v30 := v29.Get() -v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/remainder")}) +v31 := v30.Get() v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) +v33 := v32.FindInternedVar(lang.NewSymbol("first")) if v33.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) } v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +v35 := lang.Apply(v34, []any{v5}) +v36 := lang.Apply(v31, []any{v35}) +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("list")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v4}) -v40 := lang.Apply(v27, []any{v31, v35, v39}) -v41 := lang.Apply(v24, []any{v40}) -v42 := lang.Apply(v21, []any{v41}) -v43 := lang.Apply(v10, []any{v14, v18, v42}) -v44 := lang.Apply(v7, []any{v43}) -return v44 -}) -v2 := v1 -_ = v2 +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("seq")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) } -v0 := lang.NewSymbol("rem").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"), lang.NewSymbol("div"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "remainder of dividing numerator by denominator.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1274), lang.NewKeyword("end-line"), int(1274))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6, _ := lang.FieldOrMethod(lang1.Numbers, "remainder") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("remainder is not a function"))) +v42 := v41.Get() +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("concat")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) } -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +v45 := v44.Get() +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("list")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) } +v48 := v47.Get() +v49 := lang.Apply(v48, []any{lang.NewSymbol("throw")}) +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("list")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) } -// unchecked-int -{ -var v1 lang.FnFunc -{ // function unchecked-int__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v52 := v51.Get() +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("seq")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) } -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v55 := v54.Get() +v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v57 := v56.FindInternedVar(lang.NewSymbol("concat")) +if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) } -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v58 := v57.Get() +v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v60 := v59.FindInternedVar(lang.NewSymbol("list")) +if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) } -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v61 := v60.Get() +v62 := lang.Apply(v61, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewIllegalArgumentError")}) +v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v64 := v63.FindInternedVar(lang.NewSymbol("list")) +if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v65 := v64.Get() +v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v67 := v66.FindInternedVar(lang.NewSymbol("seq")) +if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) } -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +v68 := v67.Get() +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("concat")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) } -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +v71 := v70.Get() +v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v73 := v72.FindInternedVar(lang.NewSymbol("list")) +if v73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) } -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v74 := v73.Get() +v75 := lang.Apply(v74, []any{lang.NewSymbol("glojure.core/str")}) +v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v77 := v76.FindInternedVar(lang.NewSymbol("list")) +if v77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) } -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/UncheckedIntCast")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v78 := v77.Get() +v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v80 := v79.FindInternedVar(lang.NewSymbol("seq")) +if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) } -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v3}) -v35 := lang.Apply(v26, []any{v30, v34}) -v36 := lang.Apply(v23, []any{v35}) -v37 := lang.Apply(v20, []any{v36}) -v38 := lang.Apply(v9, []any{v13, v17, v37}) -v39 := lang.Apply(v6, []any{v38}) -return v39 -}) -v2 := v1 -_ = v2 +v81 := v80.Get() +v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v83 := v82.FindInternedVar(lang.NewSymbol("concat")) +if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) } -v0 := lang.NewSymbol("unchecked-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to int. Subject to rounding or truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3535), lang.NewKeyword("end-line"), int(3535))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := lang.Apply(lang1.UncheckedIntCast, []any{v4}) -return v5 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +v84 := v83.Get() +v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v86 := v85.FindInternedVar(lang.NewSymbol("list")) +if v86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) } +v87 := v86.Get() +v88 := lang.Apply(v87, []any{lang.NewSymbol("glojure.core/first")}) +v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v90 := v89.FindInternedVar(lang.NewSymbol("list")) +if v90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) } -// print-ctor -{ -v0 := lang.NewSymbol("print-ctor").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(95), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(95), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("print-args"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.Apply(lang1.WriteWriter, []any{v5, "#=("}) -_ = v6 -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("class")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v91 := v90.Get() +v92 := lang.Apply(v91, []any{lang.NewSymbol("&form")}) +v93 := lang.Apply(v84, []any{v88, v92}) +v94 := lang.Apply(v81, []any{v93}) +v95 := lang.Apply(v78, []any{v94}) +v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v97 := v96.FindInternedVar(lang.NewSymbol("list")) +if v97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) } -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v3}) -v11, ok := lang.FieldOrMethod(v10, "Name") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v10, "Name"))) +v98 := v97.Get() +v99 := lang.Apply(v98, []any{" requires "}) +v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v101 := v100.FindInternedVar(lang.NewSymbol("list")) +if v101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) } -var v12 any -switch reflect.TypeOf(v11).Kind() { -case reflect.Func: - v12 = lang.Apply(v11, nil) -default: - v12 = v11 +v102 := v101.Get() +v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v104 := v103.FindInternedVar(lang.NewSymbol("second")) +if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) } -v13 := lang.Apply(lang1.WriteWriter, []any{v5, v12}) -_ = v13 -v14 := lang.Apply(lang1.WriteWriter, []any{v5, ". "}) -_ = v14 -v15 := lang.Apply(v4, []any{v3, v5}) -_ = v15 -v16 := lang.Apply(lang1.WriteWriter, []any{v5, ")"}) -return v16 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v105 := v104.Get() +v106 := lang.Apply(v105, []any{v5}) +v107 := lang.Apply(v102, []any{v106}) +v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v109 := v108.FindInternedVar(lang.NewSymbol("list")) +if v109.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) } +v110 := v109.Get() +v111 := lang.Apply(v110, []any{" in "}) +v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v113 := v112.FindInternedVar(lang.NewSymbol("list")) +if v113.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) } -// ex-info -{ -v0 := lang.NewSymbol("ex-info").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("msg"), lang.NewSymbol("map")), lang.NewVector(lang.NewSymbol("msg"), lang.NewSymbol("map"), lang.NewSymbol("cause"))), lang.NewKeyword("doc"), "Create an instance of ExceptionInfo, a RuntimeException subclass\n that carries a map of additional data.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4803), lang.NewKeyword("end-line"), int(4803))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("elide-top-frames")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v114 := v113.Get() +v115 := lang.Apply(v114, []any{lang.NewSymbol("*ns*")}) +v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v117 := v116.FindInternedVar(lang.NewSymbol("list")) +if v117.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) } -v7 := v6.Get() -v8 := lang.Apply(ExceptionInfo14., []any{v3, v4}) -v9 := lang.Apply(v7, []any{v8, "glojure.core$ex_info"}) -return v9 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("elide-top-frames")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +v118 := v117.Get() +v119 := lang.Apply(v118, []any{":"}) +v120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v121 := v120.FindInternedVar(lang.NewSymbol("list")) +if v121.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v121))) } -v8 := v7.Get() -v9 := lang.Apply(ExceptionInfo14., []any{v3, v4, v5}) -v10 := lang.Apply(v8, []any{v9, "glojure.core$ex_info"}) -return v10 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v122 := v121.Get() +v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v124 := v123.FindInternedVar(lang.NewSymbol("seq")) +if v124.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) } +v125 := v124.Get() +v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v127 := v126.FindInternedVar(lang.NewSymbol("concat")) +if v127.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) } -// aset-boolean -{ -v0 := lang.NewSymbol("aset-boolean").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of boolean. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3956), lang.NewKeyword("end-line"), int(3958))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("boolean")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +v128 := v127.Get() +v129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v130 := v129.FindInternedVar(lang.NewSymbol("list")) +if v130.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v130))) } -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v5}) -v10, _ := lang.FieldOrMethod(nil, "setBoolean") -if reflect.TypeOf(v10).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setBoolean is not a function"))) +v131 := v130.Get() +v132 := lang.Apply(v131, []any{lang.NewKeyword("line")}) +v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v134 := v133.FindInternedVar(lang.NewSymbol("list")) +if v134.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) } -v11 := lang.Apply(v10, []any{v3, v4, v9}) -_ = v11 -return v5 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("apply")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v135 := v134.Get() +v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v137 := v136.FindInternedVar(lang.NewSymbol("seq")) +if v137.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) } -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("aset-boolean")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v138 := v137.Get() +v139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v140 := v139.FindInternedVar(lang.NewSymbol("concat")) +if v140.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v140))) } -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("aget")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +v141 := v140.Get() +v142 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v143 := v142.FindInternedVar(lang.NewSymbol("list")) +if v143.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v143))) } -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v3, v4}) -v17 := lang.Apply(v9, []any{v12, v16, v5, v6}) -return v17 +v144 := v143.Get() +v145 := lang.Apply(v144, []any{lang.NewSymbol("glojure.core/meta")}) +v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v147 := v146.FindInternedVar(lang.NewSymbol("list")) +if v147.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) +} +v148 := v147.Get() +v149 := lang.Apply(v148, []any{lang.NewSymbol("&form")}) +v150 := lang.Apply(v141, []any{v145, v149}) +v151 := lang.Apply(v138, []any{v150}) +v152 := lang.Apply(v135, []any{v151}) +v153 := lang.Apply(v128, []any{v132, v152}) +v154 := lang.Apply(v125, []any{v153}) +v155 := lang.Apply(v122, []any{v154}) +v156 := lang.Apply(v71, []any{v75, v95, v99, v107, v111, v115, v119, v155}) +v157 := lang.Apply(v68, []any{v156}) +v158 := lang.Apply(v65, []any{v157}) +v159 := lang.Apply(v58, []any{v62, v158}) +v160 := lang.Apply(v55, []any{v159}) +v161 := lang.Apply(v52, []any{v160}) +v162 := lang.Apply(v45, []any{v49, v161}) +v163 := lang.Apply(v42, []any{v162}) +v164 := lang.Apply(v39, []any{v163}) +v165 := lang.Apply(v24, []any{v28, v36, v164}) +v166 := lang.Apply(v21, []any{v165}) +v167 := lang.Apply(v18, []any{v166}) +v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v169 := v168.FindInternedVar(lang.NewSymbol("list")) +if v169.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) +} +v170 := v169.Get() +v172 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v173 := v172.FindInternedVar(lang.NewSymbol("nnext")) +if v173.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v173))) +} +v174 := v173.Get() +v175 := lang.Apply(v174, []any{v5}) +var v171 any = v175 +_ = v171 +var v177 any +if lang.IsTruthy(v171) { +v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v179 := v178.FindInternedVar(lang.NewSymbol("list*")) +if v179.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) +} +v180 := v179.Get() +v181 := lang.Apply(v180, []any{lang.NewSymbol("glojure.core/assert-args"), v171}) +v177 = v181 +} else { +v177 = nil +} +v171 := lang.Apply(v170, []any{v177}) +v172 := lang.Apply(v11, []any{v15, v167, v171}) +v173 := lang.Apply(v8, []any{v172}) +return v173 } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -10641,183 +10302,165 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// binding-conveyor-fn +// assert-valid-fdecl { -v0 := lang.NewSymbol("binding-conveyor-fn").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2020), lang.NewKeyword("end-line"), int(2020), lang.NewKeyword("private"), true)).(*lang.Symbol) +v0 := lang.NewSymbol("assert-valid-fdecl").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fdecl"))), lang.NewKeyword("doc"), "A good fdecl looks like (([a] ...) ([a b] ...)) near the end of defn.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(42), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(7545), lang.NewKeyword("end-line"), int(7545), lang.NewKeyword("private"), true, lang.NewKeyword("dynamic"), true)).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v5 := lang.Apply(lang1.CloneThreadBindingFrame, nil) -var v4 any = v5 -_ = v4 -var v7 lang.FnFunc -v7 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v8 := lang.Apply(lang1.ResetThreadBindingFrame, []any{v4}) -_ = v8 -v9 := lang.Apply(v3, nil) -return v9 - case 1: -v8 := args[0] -v9 := lang.Apply(lang1.ResetThreadBindingFrame, []any{v4}) -_ = v9 -v10 := lang.Apply(v3, []any{v8}) -return v10 - case 2: -v8 := args[0] -v9 := args[1] -v10 := lang.Apply(lang1.ResetThreadBindingFrame, []any{v4}) -_ = v10 -v11 := lang.Apply(v3, []any{v8, v9}) -return v11 - case 3: -v8 := args[0] -v9 := args[1] -v10 := args[2] -v11 := lang.Apply(lang1.ResetThreadBindingFrame, []any{v4}) -_ = v11 -v12 := lang.Apply(v3, []any{v8, v9, v10}) -return v12 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v8 := args[0] -v9 := args[1] -v10 := args[2] -v11 := lang.NewList(args[3:]...) -v12 := lang.Apply(lang1.ResetThreadBindingFrame, []any{v4}) -_ = v12 -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("apply")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v3, v8, v9, v10, v11}) -return v16 - } -}) -v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2025), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2040), lang.NewKeyword("end-column"), int(31)) -v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) -if err != nil { - panic(err) +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("empty?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -return v9 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +if lang.IsTruthy(v8) { +v9 := lang.Apply(lang1.NewIllegalArgumentError, []any{"Parameter declaration missing"}) +panic(v9) +} else { +v4 = nil } +_ = v4 +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("map")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -// get-thread-bindings -{ -v0 := lang.NewSymbol("get-thread-bindings").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Get a map with the Var/value pairs which is currently in effect for the\n current thread.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1937), lang.NewKeyword("end-line"), int(1937))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { +v13 := v12.Get() +var v14 lang.FnFunc +v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := lang.Apply(nil, nil) -return v3 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v15 := args[0] +var v16 any +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq?")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v15}) +if lang.IsTruthy(v20) { +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("first")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -// re-groups -{ -v0 := lang.NewSymbol("re-groups").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"))), lang.NewKeyword("doc"), "Returns the groups from the most recent match/find. If there are no\n nested groups, returns a string of the entire match. If there are\n nested groups, returns a vector of the groups, the first element\n being the entire match.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4882), lang.NewKeyword("end-line"), int(4882))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v5, _ := lang.FieldOrMethod(v3, "groupCount") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("groupCount is not a function"))) +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v15}) +v16 = v24 +} else { +var v25 any +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("seq?")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) } -v6 := lang.Apply(v5, []any{}) -var v4 any = v6 -_ = v4 -var v8 any -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("zero?")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("first")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) } -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v4}) -if lang.IsTruthy(v12) { -v13, _ := lang.FieldOrMethod(v3, "group") -if reflect.TypeOf(v13).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("group is not a function"))) +v31 := v30.Get() +v32 := lang.Apply(v31, []any{v3}) +v33 := lang.Apply(v28, []any{v32}) +if lang.IsTruthy(v33) { +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("str")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } -v14 := lang.Apply(v13, []any{}) -v8 = v14 +v36 := v35.Get() +v37 := lang.Apply(v36, []any{"Invalid signature \"", v15, "\" should be a list"}) +v25 = v37 } else { -v16 := lang.NewVector() -v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4893), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(4893), lang.NewKeyword("end-column"), int(21)) -v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("str")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.Apply(v40, []any{"Parameter declaration \"", v15, "\" should be a vector"}) +v25 = v41 +} +v42 := lang.Apply(lang1.NewIllegalArgumentError, []any{v25}) +panic(v42) +} +return v16 +}) +v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7551), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7560), lang.NewKeyword("end-column"), int(59)) +v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) if err != nil { panic(err) } -var v15 any = v18 -_ = v15 -var v19 any = int64(0) -_ = v19 -var v20 any -for { -var v21 any +v17 := lang.Apply(v13, []any{v16, v3}) +var v10 any = v17 +_ = v10 +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("seq")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("<=")) +v23 := v22.FindInternedVar(lang.NewSymbol("remove")) if v23.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } v24 := v23.Get() -v25 := lang.Apply(v24, []any{v19, v4}) -if lang.IsTruthy(v25) { +var v25 lang.FnFunc +v25 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v26 := args[0] v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("conj")) +v28 := v27.FindInternedVar(lang.NewSymbol("vector?")) if v28.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } v29 := v28.Get() -v30, _ := lang.FieldOrMethod(v3, "groupInt") -if reflect.TypeOf(v30).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("groupInt is not a function"))) -} -v31 := lang.Apply(v30, []any{v19}) -v32 := lang.Apply(v29, []any{v15, v31}) -var v26 any = v32 -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("inc")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +v30 := lang.Apply(v29, []any{v26}) +return v30 +}) +v26 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7562), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(7562), lang.NewKeyword("end-column"), int(42)) +v27, err := lang.WithMeta(v25, v26.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v36 := v35.Get() -v37 := lang.Apply(v36, []any{v19}) -var v33 any = v37 -v15 = v26 -v19 = v33 -continue -} else { -v21 = v15 +v28 := lang.Apply(v24, []any{v27, v10}) +v29 := lang.Apply(v21, []any{v28}) +var v18 any = v29 +_ = v18 +var v31 any +if lang.IsTruthy(v18) { +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("str")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) } -v20 = v21 - break +v34 := v33.Get() +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("first")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) } -v8 = v20 +v37 := v36.Get() +v38 := lang.Apply(v37, []any{v18}) +v39 := lang.Apply(v34, []any{"Parameter declaration \"", v38, "\" should be a vector"}) +v40 := lang.Apply(lang1.NewIllegalArgumentError, []any{v39}) +panic(v40) +} else { +v31 = nil } -return v8 +return v31 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -10825,251 +10468,247 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// await-for +// assoc { -v0 := lang.NewSymbol("await-for").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("timeout-ms"), lang.NewSymbol("&"), lang.NewSymbol("agents"))), lang.NewKeyword("doc"), "Blocks the current thread until all actions dispatched thus\n far (from this thread or agent) to the agents have occurred, or the\n timeout (in milliseconds) has elapsed. Returns logical false if\n returning due to timeout, logical true otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3289), lang.NewKeyword("end-line"), int(3289))).(*lang.Symbol) +v0 := lang.NewSymbol("assoc").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"), lang.NewSymbol("val"), lang.NewSymbol("&"), lang.NewSymbol("kvs"))), lang.NewKeyword("doc"), "assoc[iate]. When applied to a map, returns a new map of the\n same (hashed/sorted) type, that contains the mapping of key(s) to\n val(s). When applied to a vector, returns a new vector that\n contains val at index. Note - index must be <= (count vector).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(181), lang.NewKeyword("end-line"), int(188))).(*lang.Symbol) var v2 lang.FnFunc +{ // function assoc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { + case 3: +v4 := args[0] +v5 := args[1] +v6 := args[2] +v7 := lang.Apply(lang1.Assoc, []any{v4, v5, v6}) +return v7 default: - if len(args) < 1 { + if len(args) < 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := args[0] -v4 := lang.NewList(args[1:]...) -var v5 any -v6 := lang.Apply(nil, nil) -if lang.IsTruthy(v6) { -panic("unimplemented: new with non-constant class type") -} else { -var v7 any -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("*agent*")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -if lang.IsTruthy(v10) { -v11 := lang.Apply(errors10.New, []any{"Can't await in agent action"}) -panic(v11) -} else { -v7 = nil -} -_ = v7 -var v12 any = "unimplemented: new with non-constant class type" -_ = v12 -var v14 lang.FnFunc -v14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v15 := args[0] -v16, _ := lang.FieldOrMethod(v12, "countDown") -if reflect.TypeOf(v16).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("countDown is not a function"))) -} -v17 := lang.Apply(v16, []any{}) -_ = v17 -return v15 -}) -v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3301), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(3301), lang.NewKeyword("end-column"), int(62)) -v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) -if err != nil { - panic(err) +v4 := args[0] +v5 := args[1] +v6 := args[2] +v7 := lang.NewList(args[3:]...) +recur_loop_24: +v9 := lang.Apply(lang1.Assoc, []any{v4, v5, v6}) +var v8 any = v9 +_ = v8 +var v11 any +if lang.IsTruthy(v7) { +var v12 any +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("next")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } -var v13 any = v16 -_ = v13 +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v7}) +if lang.IsTruthy(v16) { +var v17 any = v8 v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("seq")) +v20 := v19.FindInternedVar(lang.NewSymbol("first")) if v20.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } v21 := v20.Get() -v22 := lang.Apply(v21, []any{v4}) +v22 := lang.Apply(v21, []any{v7}) var v18 any = v22 -_ = v18 -var v23 any = nil -_ = v23 -var v24 any = int64(0) -_ = v24 -var v25 any = int64(0) -_ = v25 -var v26 any -for { -var v27 any -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("<")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{v25, v24}) -if lang.IsTruthy(v31) { -v33, _ := lang.FieldOrMethod(v23, "nth") -if reflect.TypeOf(v33).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("second")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -v34 := lang.Apply(v33, []any{v25}) -var v32 any = v34 -_ = v32 -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("send")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v7}) +var v23 any = v27 +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("nnext")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) } -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v32, v13}) -_ = v39 -var v40 any = v18 -var v41 any = v23 -var v42 any = v24 -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("unchecked-inc")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +v31 := v30.Get() +v32 := lang.Apply(v31, []any{v7}) +var v28 any = v32 +v4 = v17 +v5 = v18 +v6 = v23 +v7 = v28 +goto recur_loop_24 +} else { +v33 := lang.Apply(lang1.NewIllegalArgumentError, []any{"assoc expects even number of arguments after map/vector, found odd number"}) +panic(v33) } -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v25}) -var v43 any = v47 -v18 = v40 -v23 = v41 -v24 = v42 -v25 = v43 -continue +v11 = v12 } else { -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("seq")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +v11 = v8 } -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v18}) -var v32 any = v36 -_ = v32 -var v38 any -if lang.IsTruthy(v32) { -var v39 any = v32 -_ = v39 -var v41 any -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("chunked-seq?")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +return v11 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(189), lang.NewKeyword("column"), int(2), lang.NewKeyword("end-line"), int(198), lang.NewKeyword("end-column"), int(15))).(lang.FnFunc) +v3 := v2 +_ = v3 } -v44 := v43.Get() -v45 := lang.Apply(v44, []any{v39}) -if lang.IsTruthy(v45) { -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("chunk-first")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v49 := v48.Get() -v50 := lang.Apply(v49, []any{v39}) -var v46 any = v50 -_ = v46 -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("chunk-rest")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) } -v55 := v54.Get() -v56 := lang.Apply(v55, []any{v39}) -var v52 any = v56 -var v57 any = v46 -v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v60 := v59.FindInternedVar(lang.NewSymbol("int")) -if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) +// assoc! +{ +v0 := lang.NewSymbol("assoc!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("key"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("key"), lang.NewSymbol("val"), lang.NewSymbol("&"), lang.NewSymbol("kvs"))), lang.NewKeyword("doc"), "When applied to a transient map, adds mapping of key(s) to\n val(s). When applied to a transient vector, sets the val at index.\n Note - index must be <= (count vector). Returns coll.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3369), lang.NewKeyword("end-line"), int(3369))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6, _ := lang.FieldOrMethod(v3, "Assoc") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Assoc is not a function"))) } -v61 := v60.Get() -v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v63 := v62.FindInternedVar(lang.NewSymbol("count")) -if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +recur_loop_609: +v8, _ := lang.FieldOrMethod(v3, "Assoc") +if reflect.TypeOf(v8).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Assoc is not a function"))) } -v64 := v63.Get() -v65 := lang.Apply(v64, []any{v46}) -v66 := lang.Apply(v61, []any{v65}) -var v58 any = v66 -v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v69 := v68.FindInternedVar(lang.NewSymbol("int")) -if v69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) +v9 := lang.Apply(v8, []any{v4, v5}) +var v7 any = v9 +_ = v7 +var v11 any +if lang.IsTruthy(v6) { +var v12 any = v7 +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("first")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v70 := v69.Get() -v71 := lang.Apply(v70, []any{int64(0)}) -var v67 any = v71 -v18 = v52 -v23 = v57 -v24 = v58 -v25 = v67 -continue +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v6}) +var v13 any = v17 +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("second")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v6}) +var v18 any = v22 +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("nnext")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v6}) +var v23 any = v27 +v3 = v12 +v4 = v13 +v5 = v18 +v6 = v23 +goto recur_loop_609 } else { -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("first")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +v11 = v7 } -v49 := v48.Get() -v50 := lang.Apply(v49, []any{v39}) -var v46 any = v50 -_ = v46 -v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("send")) -if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) +return v11 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v54 := v53.Get() -v55 := lang.Apply(v54, []any{v46, v13}) -_ = v55 -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("next")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) } -v59 := v58.Get() -v60 := lang.Apply(v59, []any{v39}) -var v56 any = v60 -var v61 any = nil -var v62 any = int64(0) -var v63 any = int64(0) -v18 = v56 -v23 = v61 -v24 = v62 -v25 = v63 -continue +// assoc-in +{ +v0 := lang.NewSymbol("assoc-in").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("&"), lang.NewSymbol("ks")), lang.NewSymbol("v"))), lang.NewKeyword("doc"), "Associates a value in a nested associative structure, where ks is a\n sequence of keys and v is the new value and returns a new nested structure.\n If any levels do not exist, hash-maps will be created.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6190), lang.NewKeyword("end-line"), int(6190))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +var v6 any = v4 +_ = v6 +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("seq")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v38 = v41 -} else { -v38 = nil +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v6}) +var v7 any = v11 +_ = v7 +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("first")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } -v27 = v38 +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v7}) +var v12 any = v16 +_ = v12 +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("next")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v26 = v27 - break +v20 := v19.Get() +v21 := lang.Apply(v20, []any{v17}) +var v17 any = v21 +_ = v17 +var v22 any = v12 +_ = v22 +var v23 any = v17 +_ = v23 +var v25 any +if lang.IsTruthy(v23) { +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("assoc")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) } -_ = v26 -v18, ok := lang.FieldOrMethod(java.util.concurrent15.TimeUnit, "MILLISECONDS") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", java.util.concurrent15.TimeUnit, "MILLISECONDS"))) +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("assoc-in")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) } -var v19 any -switch reflect.TypeOf(v18).Kind() { -case reflect.Func: - v19 = lang.Apply(v18, nil) -default: - v19 = v18 +v31 := v30.Get() +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("get")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) } -v20, _ := lang.FieldOrMethod(v12, "await") -if reflect.TypeOf(v20).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3, v22}) +v36 := lang.Apply(v31, []any{v35, v23, v5}) +v37 := lang.Apply(v28, []any{v3, v22, v36}) +v25 = v37 +} else { +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("assoc")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) } -v21 := lang.Apply(v20, []any{v3, v19}) -v5 = v21 +v40 := v39.Get() +v41 := lang.Apply(v40, []any{v3, v22, v5}) +v25 = v41 } -return v5 - } +return v25 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -11077,18 +10716,23 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// mix-collection-hash +// associative? { -v0 := lang.NewSymbol("mix-collection-hash").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("hash-basis"), lang.NewSymbol("count"))), lang.NewKeyword("doc"), "Mix final collection hash for ordered or unordered collections.\n hash-basis is the combined collection hash, count is the number\n of elements included in the basis. Note this is the hash code\n consistent with =, different from .hashCode.\n See http://glojure.org/data_structures#hash for full algorithms.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5199), lang.NewKeyword("end-line"), int(5199))).(*lang.Symbol) +v0 := lang.NewSymbol("associative?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements Associative", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6266), lang.NewKeyword("end-line"), int(6266))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := args[1] -v5 := lang.Apply(nil, []any{v3, v4}) -return v5 +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{glojure.lang8.Associative, v3}) +return v7 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -11096,346 +10740,278 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// distinct +// atom { -v0 := lang.NewSymbol("distinct").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the elements of coll with duplicates removed.\n Returns a stateful transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5053), lang.NewKeyword("end-line"), int(5053))).(*lang.Symbol) +v0 := lang.NewSymbol("atom").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Creates and returns an Atom with an initial value of x and zero or\n more options (in any order):\n\n :meta metadata-map\n\n :validator validate-fn\n\n If metadata-map is supplied, it will become the metadata on the\n atom. validate-fn must be nil or a side-effect-free fn of one\n argument, which will be passed the intended new state on any state\n change. If the new state is unacceptable, the validate-fn should\n return false or throw an exception.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2325), lang.NewKeyword("end-line"), int(2325))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 0: -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { + case 1: +v3 := args[0] +v4 := lang.Apply(lang1.NewAtom, []any{v3}) +return v4 + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.NewList(args[1:]...) +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("setup-reference")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("atom")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v3}) +v12 := lang.Apply(v7, []any{v11, v4}) +return v12 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// await +{ +v0 := lang.NewSymbol("await").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("agents"))), lang.NewKeyword("doc"), "Blocks the current thread (indefinitely!) until all actions\n dispatched thus far, from this thread or agent, to the agent(s) have\n occurred. Will block on failed agents. Will never return if\n a failed agent is restarted with :clear-actions true or shutdown-agents was called.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3267), lang.NewKeyword("end-line"), int(3267))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.NewList(args[0:]...) +var v4 any +v5 := lang.Apply(nil, nil) +if lang.IsTruthy(v5) { +panic("unimplemented: new with non-constant class type") +} else { +var v6 any +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("*agent*")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +if lang.IsTruthy(v9) { +v10 := lang.Apply(errors11.New, []any{"Can't await in agent action"}) +panic(v10) +} else { +v6 = nil +} +_ = v6 +var v11 any = "unimplemented: new with non-constant class type" +_ = v11 +var v13 lang.FnFunc +v13 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v4 := args[0] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("volatile!")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +v14 := args[0] +v15, _ := lang.FieldOrMethod(v11, "countDown") +if reflect.TypeOf(v15).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("countDown is not a function"))) } -v8 := v7.Get() -v9 := lang.CreatePersistentTreeSet() -v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5060), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(5060), lang.NewKeyword("end-column"), int(30)) -v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) +v16 := lang.Apply(v15, []any{}) +_ = v16 +return v14 +}) +v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3279), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(3279), lang.NewKeyword("end-column"), int(61)) +v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) if err != nil { panic(err) } -v12 := lang.Apply(v8, []any{v11}) -var v5 any = v12 -_ = v5 -var v14 lang.FnFunc -v14 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v15 := lang.Apply(v4, nil) -return v15 - case 1: -v15 := args[0] -v16 := lang.Apply(v4, []any{v15}) -return v16 - case 2: -v15 := args[0] -v16 := args[1] -var v17 any +var v12 any = v15 +_ = v12 v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("contains?")) +v19 := v18.FindInternedVar(lang.NewSymbol("seq")) if v19.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("deref")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v5}) -v25 := lang.Apply(v20, []any{v24, v16}) -if lang.IsTruthy(v25) { -v17 = v15 -} else { -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("conj")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29, ok := lang.FieldOrMethod(v5, "Deref") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "Deref"))) -} -var v30 any -switch reflect.TypeOf(v29).Kind() { -case reflect.Func: - v30 = lang.Apply(v29, nil) -default: - v30 = v29 +v21 := lang.Apply(v20, []any{v3}) +var v17 any = v21 +_ = v17 +var v22 any = nil +_ = v22 +var v23 any = int64(0) +_ = v23 +var v24 any = int64(0) +_ = v24 +var v25 any +for { +var v26 any +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("<")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v31 := lang.Apply(v28, []any{v30, v16}) -v32, _ := lang.FieldOrMethod(v5, "reset") +v29 := v28.Get() +v30 := lang.Apply(v29, []any{v24, v23}) +if lang.IsTruthy(v30) { +v32, _ := lang.FieldOrMethod(v22, "nth") if reflect.TypeOf(v32).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) -} -v33 := lang.Apply(v32, []any{v31}) -_ = v33 -v34 := lang.Apply(v4, []any{v15, v16}) -v17 = v34 + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) } -return v17 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5061), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(5068), lang.NewKeyword("end-column"), int(37)) -v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) -if err != nil { - panic(err) +v33 := lang.Apply(v32, []any{v24}) +var v31 any = v33 +_ = v31 +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("send")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) } -return v16 -}) -v4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5059), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(5068), lang.NewKeyword("end-column"), int(39)) -v5, err := lang.WithMeta(v3, v4.(lang.IPersistentMap)) -if err != nil { - panic(err) +v37 := v36.Get() +v38 := lang.Apply(v37, []any{v31, v12}) +_ = v38 +var v39 any = v17 +var v40 any = v22 +var v41 any = v23 +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("unchecked-inc")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) } -return v5 - case 1: -v3 := args[0] -var v5 lang.FnFunc -{ // function step -v5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v7 := args[0] -v8 := args[1] -var v9 lang.FnFunc -v9 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -var v10 lang.FnFunc -v10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v11 := args[0] -v12 := args[1] -recur_loop_877: -var v13 any = v11 -_ = v13 -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("nth")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v13, int64(0), nil}) -var v14 any = v18 -_ = v14 -var v19 any = v13 -_ = v19 -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("seq")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v19}) -var v21 any = v25 -_ = v21 -var v27 any -if lang.IsTruthy(v21) { -var v28 any = v21 -_ = v28 -var v30 any -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("contains?")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v12, v14}) -if lang.IsTruthy(v34) { -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("rest")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v28}) -var v35 any = v39 -var v40 any = v12 -v11 = v35 -v12 = v40 -goto recur_loop_877 +v45 := v44.Get() +v46 := lang.Apply(v45, []any{v24}) +var v42 any = v46 +v17 = v39 +v22 = v40 +v23 = v41 +v24 = v42 +continue } else { +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("seq")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v17}) +var v31 any = v35 +_ = v31 +var v37 any +if lang.IsTruthy(v31) { +var v38 any = v31 +_ = v38 +var v40 any v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("cons")) +v42 := v41.FindInternedVar(lang.NewSymbol("chunked-seq?")) if v42.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } v43 := v42.Get() -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("rest")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v28}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("conj")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v12, v14}) -v52 := lang.Apply(v6, []any{v47, v51}) -v53 := lang.Apply(v43, []any{v14, v52}) -v30 = v53 -} -v27 = v30 -} else { -v27 = nil -} -return v27 -}) -v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5072), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(5076), lang.NewKeyword("end-column"), int(66)) -v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v13 := lang.Apply(v12, []any{v7, v8}) -return v13 -}) -v10 := lang.Apply(lang1.NewLazySeq, []any{v9}) -return v10 -}) -v6 := v5 -_ = v6 -} -v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5070), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(5077), lang.NewKeyword("end-column"), int(29)) -v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v4 any = v7 -_ = v4 -v9 := lang.CreatePersistentTreeSet() -v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5078), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(5078), lang.NewKeyword("end-column"), int(19)) -v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) -if err != nil { - panic(err) +v44 := lang.Apply(v43, []any{v38}) +if lang.IsTruthy(v44) { +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("chunk-first")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) } -v12 := lang.Apply(v4, []any{v3, v11}) -return v12 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v48 := v47.Get() +v49 := lang.Apply(v48, []any{v38}) +var v45 any = v49 +_ = v45 +v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v53 := v52.FindInternedVar(lang.NewSymbol("chunk-rest")) +if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) } +v54 := v53.Get() +v55 := lang.Apply(v54, []any{v38}) +var v51 any = v55 +var v56 any = v45 +v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v59 := v58.FindInternedVar(lang.NewSymbol("int")) +if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) } -// pr-on -{ -v0 := lang.NewSymbol("pr-on").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("w"))), lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3669), lang.NewKeyword("end-line"), int(3669), lang.NewKeyword("private"), true)).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("*print-dup*")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +v60 := v59.Get() +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("count")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) } -v8 := v7.Get() -if lang.IsTruthy(v8) { -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("print-dup")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +v63 := v62.Get() +v64 := lang.Apply(v63, []any{v45}) +v65 := lang.Apply(v60, []any{v64}) +var v57 any = v65 +v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v68 := v67.FindInternedVar(lang.NewSymbol("int")) +if v68.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) } -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v3, v4}) -v5 = v12 +v69 := v68.Get() +v70 := lang.Apply(v69, []any{int64(0)}) +var v66 any = v70 +v17 = v51 +v22 = v56 +v23 = v57 +v24 = v66 +continue } else { -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("print-method")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v3, v4}) -v5 = v16 -} -_ = v5 -return nil -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("first")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) } +v48 := v47.Get() +v49 := lang.Apply(v48, []any{v38}) +var v45 any = v49 +_ = v45 +v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v52 := v51.FindInternedVar(lang.NewSymbol("send")) +if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) } -// seq-to-map-for-destructuring -{ -v0 := lang.NewSymbol("seq-to-map-for-destructuring").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Builds a map from a seq as described in\n https://glojure.org/reference/special_forms#keyword-arguments", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(34), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4390), lang.NewKeyword("end-line"), int(4390))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("next")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v53 := v52.Get() +v54 := lang.Apply(v53, []any{v45, v12}) +_ = v54 +v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v57 := v56.FindInternedVar(lang.NewSymbol("next")) +if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) } -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -if lang.IsTruthy(v8) { -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("to-array")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +v58 := v57.Get() +v59 := lang.Apply(v58, []any{v38}) +var v55 any = v59 +var v60 any = nil +var v61 any = int64(0) +var v62 any = int64(0) +v17 = v55 +v22 = v60 +v23 = v61 +v24 = v62 +continue } -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v3}) -v13 := lang.Apply(lang1.NewPersistentArrayMapAsIfByAssoc, []any{v12}) -v4 = v13 +v37 = v40 } else { -var v14 any -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("seq")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +v37 = nil } -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v3}) -if lang.IsTruthy(v18) { -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("first")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v26 = v37 } -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v3}) -v14 = v22 -} else { -v14 = nil +v25 = v26 + break } -v4 = v14 +_ = v25 +v17, _ := lang.FieldOrMethod(v11, "await") +if reflect.TypeOf(v17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) +} +v18 := lang.Apply(v17, []any{}) +v4 = v18 } return v4 + } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -11443,139 +11019,250 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// take-while +// await-for { -v0 := lang.NewSymbol("take-while").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred")), lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of successive items from coll while\n (pred item) returns logical true. pred must be free of side-effects.\n Returns a transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2880), lang.NewKeyword("end-line"), int(2880))).(*lang.Symbol) +v0 := lang.NewSymbol("await-for").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("timeout-ms"), lang.NewSymbol("&"), lang.NewSymbol("agents"))), lang.NewKeyword("doc"), "Blocks the current thread until all actions dispatched thus\n far (from this thread or agent) to the agents have occurred, or the\n timeout (in milliseconds) has elapsed. Returns logical false if\n returning due to timeout, logical true otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3289), lang.NewKeyword("end-line"), int(3289))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 1: + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := args[0] -var v6 lang.FnFunc -v6 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v7 := lang.Apply(v5, nil) -return v7 - case 1: -v7 := args[0] -v8 := lang.Apply(v5, []any{v7}) -return v8 - case 2: -v7 := args[0] -v8 := args[1] -var v9 any -v10 := lang.Apply(v3, []any{v8}) -if lang.IsTruthy(v10) { -v11 := lang.Apply(v5, []any{v7, v8}) -v9 = v11 +v4 := lang.NewList(args[1:]...) +var v5 any +v6 := lang.Apply(nil, nil) +if lang.IsTruthy(v6) { +panic("unimplemented: new with non-constant class type") } else { -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("reduced")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +var v7 any +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("*agent*")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v7}) -v9 = v15 +v10 := v9.Get() +if lang.IsTruthy(v10) { +v11 := lang.Apply(errors11.New, []any{"Can't await in agent action"}) +panic(v11) +} else { +v7 = nil } -return v9 - default: +_ = v7 +var v12 any = "unimplemented: new with non-constant class type" +_ = v12 +var v14 lang.FnFunc +v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -}) -v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2888), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(2894), lang.NewKeyword("end-column"), int(33)) -v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) -if err != nil { - panic(err) +v15 := args[0] +v16, _ := lang.FieldOrMethod(v12, "countDown") +if reflect.TypeOf(v16).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("countDown is not a function"))) } -return v8 +v17 := lang.Apply(v16, []any{}) +_ = v17 +return v15 }) -v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2887), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2894), lang.NewKeyword("end-column"), int(34)) -v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) +v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3301), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(3301), lang.NewKeyword("end-column"), int(62)) +v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) if err != nil { panic(err) } -return v6 - case 2: -v3 := args[0] -v4 := args[1] -var v5 lang.FnFunc -v5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("seq")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v4}) -var v6 any = v10 -_ = v6 -var v12 any -if lang.IsTruthy(v6) { -var v13 any = v6 +var v13 any = v16 _ = v13 -var v15 any -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("first")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v13}) -v20 := lang.Apply(v3, []any{v19}) -if lang.IsTruthy(v20) { -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("cons")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("first")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("seq")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v13}) +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v4}) +var v18 any = v22 +_ = v18 +var v23 any = nil +_ = v23 +var v24 any = int64(0) +_ = v24 +var v25 any = int64(0) +_ = v25 +var v26 any +for { +var v27 any v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("take-while")) +v29 := v28.FindInternedVar(lang.NewSymbol("<")) if v29.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("rest")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v31 := lang.Apply(v30, []any{v25, v24}) +if lang.IsTruthy(v31) { +v33, _ := lang.FieldOrMethod(v23, "nth") +if reflect.TypeOf(v33).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) } -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v13}) -v35 := lang.Apply(v30, []any{v3, v34}) -v36 := lang.Apply(v23, []any{v27, v35}) -v15 = v36 -} else { -v15 = nil +v34 := lang.Apply(v33, []any{v25}) +var v32 any = v34 +_ = v32 +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("send")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) } -v12 = v15 +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v32, v13}) +_ = v39 +var v40 any = v18 +var v41 any = v23 +var v42 any = v24 +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("unchecked-inc")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v25}) +var v43 any = v47 +v18 = v40 +v23 = v41 +v24 = v42 +v25 = v43 +continue } else { -v12 = nil +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("seq")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) } -return v12 -}) -v6 := lang.Apply(lang1.NewLazySeq, []any{v5}) -return v6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v18}) +var v32 any = v36 +_ = v32 +var v38 any +if lang.IsTruthy(v32) { +var v39 any = v32 +_ = v39 +var v41 any +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("chunked-seq?")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +} +v44 := v43.Get() +v45 := lang.Apply(v44, []any{v39}) +if lang.IsTruthy(v45) { +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("chunk-first")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +} +v49 := v48.Get() +v50 := lang.Apply(v49, []any{v39}) +var v46 any = v50 +_ = v46 +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("chunk-rest")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +} +v55 := v54.Get() +v56 := lang.Apply(v55, []any{v39}) +var v52 any = v56 +var v57 any = v46 +v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v60 := v59.FindInternedVar(lang.NewSymbol("int")) +if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) +} +v61 := v60.Get() +v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v63 := v62.FindInternedVar(lang.NewSymbol("count")) +if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +} +v64 := v63.Get() +v65 := lang.Apply(v64, []any{v46}) +v66 := lang.Apply(v61, []any{v65}) +var v58 any = v66 +v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v69 := v68.FindInternedVar(lang.NewSymbol("int")) +if v69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) +} +v70 := v69.Get() +v71 := lang.Apply(v70, []any{int64(0)}) +var v67 any = v71 +v18 = v52 +v23 = v57 +v24 = v58 +v25 = v67 +continue +} else { +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("first")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +} +v49 := v48.Get() +v50 := lang.Apply(v49, []any{v39}) +var v46 any = v50 +_ = v46 +v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v53 := v52.FindInternedVar(lang.NewSymbol("send")) +if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) +} +v54 := v53.Get() +v55 := lang.Apply(v54, []any{v46, v13}) +_ = v55 +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("next")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +} +v59 := v58.Get() +v60 := lang.Apply(v59, []any{v39}) +var v56 any = v60 +var v61 any = nil +var v62 any = int64(0) +var v63 any = int64(0) +v18 = v56 +v23 = v61 +v24 = v62 +v25 = v63 +continue +} +v38 = v41 +} else { +v38 = nil +} +v27 = v38 +} +v26 = v27 + break +} +_ = v26 +v18, ok := lang.FieldOrMethod(java.util.concurrent12.TimeUnit, "MILLISECONDS") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", java.util.concurrent12.TimeUnit, "MILLISECONDS"))) +} +var v19 any +switch reflect.TypeOf(v18).Kind() { +case reflect.Func: + v19 = lang.Apply(v18, nil) +default: + v19 = v18 +} +v20, _ := lang.FieldOrMethod(v12, "await") +if reflect.TypeOf(v20).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) +} +v21 := lang.Apply(v20, []any{v3, v19}) +v5 = v21 +} +return v5 } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -11584,48 +11271,48 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// restart-agent +// await1 { -v0 := lang.NewSymbol("restart-agent").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("new-state"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "When an agent is failed, changes the agent state to new-state and\n then un-fails the agent so that sends are allowed again. If\n a :clear-actions true option is given, any actions queued on the\n agent that were being held while it was failed will be discarded,\n otherwise those held actions will proceed. The new-state must pass\n the validator if any, or restart will throw an exception and the\n agent will remain failed with its old state and error. Watchers, if\n any, will NOT be notified of the new state. Throws an exception if\n the agent is not failed.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2175), lang.NewKeyword("end-line"), int(2175))).(*lang.Symbol) +v0 := lang.NewSymbol("await1").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3284), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3284), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("apply")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("pos?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("hash-map")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v7 := v6.Get() +v8, ok := lang.FieldOrMethod(v3, "getQueueCount") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getQueueCount"))) } -v12 := v11.Get() -v13 := lang.Apply(v9, []any{v12, v5}) -var v6 any = v13 -_ = v6 -var v15 any -v16 := lang.Apply(lang.NewKeyword("clear-actions"), []any{v6}) -if lang.IsTruthy(v16) { -v15 = true -} else { -v15 = false +var v9 any +switch reflect.TypeOf(v8).Kind() { +case reflect.Func: + v9 = lang.Apply(v8, nil) +default: + v9 = v8 } -v17, _ := lang.FieldOrMethod(v3, "restart") -if reflect.TypeOf(v17).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("restart is not a function"))) +v10 := lang.Apply(v7, []any{v9}) +if lang.IsTruthy(v10) { +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("await")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v18 := lang.Apply(v17, []any{v4, v15}) -return v18 - } +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v3}) +v4 = v14 +} else { +v4 = nil +} +_ = v4 +return v3 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -11633,913 +11320,980 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// println-str +// bases { -v1 := reflect.TypeOf("") -v0 := lang.NewSymbol("println-str").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("xs"))), lang.NewKeyword("doc"), "println to a string, returning it", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4785), lang.NewKeyword("end-line"), int(4785))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := lang.NewList(args[0:]...) -var v5 any = "unimplemented: new with non-constant class type" -_ = v5 -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("push-thread-bindings")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("hash-map")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*out*")) -v15 := lang.Apply(v13, []any{v14, v5}) -v16 := lang.Apply(v10, []any{v15}) -_ = v16 -var v17 any -func() { -defer func() { -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v0 := lang.NewSymbol("bases").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"))), lang.NewKeyword("doc"), "Returns the immediate superclass and direct interfaces of c, if any", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5565), lang.NewKeyword("end-line"), int(5565))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +var v4 any +if lang.IsTruthy(v3) { +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("seq")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v20 := v19.Get() -v21 := lang.Apply(v20, nil) -}() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("apply")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v8 := v7.Get() +v9 := lang.Apply(v8, []any{nil}) +var v5 any = v9 +_ = v5 +var v10 any = nil +_ = v10 +var v12 any +if lang.IsTruthy(v10) { +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("cons")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("println")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v10, v5}) +v12 = v16 +} else { +v12 = v5 } -v27 := v26.Get() -v28 := lang.Apply(v24, []any{v27, v4}) -_ = v28 -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("str")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +v4 = v12 +} else { +v4 = nil } -v31 := v30.Get() -v32 := lang.Apply(v31, []any{v5}) -v17 = v32 -}() -return v17 - } +return v4 }) -v4 := reflect.TypeOf("") -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// when-some +// bigdec { -v0 := lang.NewSymbol("when-some").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "bindings => binding-form test\n\n When test is not nil, evaluates body with binding-form bound to the\n value of test", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1894), lang.NewKeyword("end-line"), int(1894))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -var v7 any -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v1 := reflect.TypeOf((*lang1.BigDecimal)(nil)) +v0 := lang.NewSymbol("bigdec").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Coerce to BigDecimal", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3648), lang.NewKeyword("end-line"), int(3648))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("decimal?")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v5}) -if lang.IsTruthy(v11) { -v7 = nil +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v4}) +if lang.IsTruthy(v9) { +v5 = v4 } else { -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("str")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +var v10 any +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("float?")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v14 := v13.Get() +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v4}) +if lang.IsTruthy(v14) { v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("first")) +v16 := v15.FindInternedVar(lang.NewSymbol("double")) if v16.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } v17 := v16.Get() -v18 := lang.Apply(v17, []any{v3}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v18 := lang.Apply(v17, []any{v4}) +v19 := lang.Apply(lang1.NewBigDecimalFromFloat64, []any{v18}) +v10 = v19 +} else { +var v20 any +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("ratio?")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("meta")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v4}) +if lang.IsTruthy(v24) { +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("/")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) -v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) -v28 := lang.Apply(lang1.NewIllegalArgumentError, []any{v27}) -panic(v28) +v27 := v26.Get() +v28, ok := lang.FieldOrMethod(v4, "numerator") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "numerator"))) } -_ = v7 var v29 any -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("=")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +switch reflect.TypeOf(v28).Kind() { +case reflect.Func: + v29 = lang.Apply(v28, nil) +default: + v29 = v28 } -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("count")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +v30 := lang.Apply(BigDecimal13., []any{v29}) +v31, ok := lang.FieldOrMethod(v4, "denominator") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "denominator"))) } -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v5}) -v37 := lang.Apply(v32, []any{int64(2), v36}) -if lang.IsTruthy(v37) { -v29 = nil +var v32 any +switch reflect.TypeOf(v31).Kind() { +case reflect.Func: + v32 = lang.Apply(v31, nil) +default: + v32 = v31 +} +v33 := lang.Apply(v27, []any{v30, v32}) +v20 = v33 } else { -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("str")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +var v34 any +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("instance?")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) } -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("first")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +v37 := v36.Get() +v38 := lang.Apply(v37, []any{lang1.*BigInt, v4}) +if lang.IsTruthy(v38) { +v39, ok := lang.FieldOrMethod(v4, "toBigDecimal") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "toBigDecimal"))) } -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v3}) -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +var v40 any +switch reflect.TypeOf(v39).Kind() { +case reflect.Func: + v40 = lang.Apply(v39, nil) +default: + v40 = v39 } -v47 := v46.Get() +v34 = v40 +} else { +var v41 any +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("instance?")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +} +v44 := v43.Get() +v45 := lang.Apply(v44, []any{big14.*Int, v4}) +if lang.IsTruthy(v45) { +v46 := lang.Apply(BigDecimal13., []any{v4}) +v41 = v46 +} else { +var v47 any v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("meta")) +v49 := v48.FindInternedVar(lang.NewSymbol("number?")) if v49.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) } v50 := v49.Get() -v51 := lang.Apply(v50, []any{v3}) -v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) -v53 := lang.Apply(v40, []any{v44, " requires ", "exactly 2 forms in binding vector", " in ", v47, ":", v52}) -v54 := lang.Apply(lang1.NewIllegalArgumentError, []any{v53}) -panic(v54) +v51 := lang.Apply(v50, []any{v4}) +if lang.IsTruthy(v51) { +v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v53 := v52.FindInternedVar(lang.NewSymbol("long")) +if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) } -_ = v29 -_ = nil -v56 := lang.Apply(v5, []any{int64(0)}) -var v55 any = v56 -_ = v55 -v58 := lang.Apply(v5, []any{int64(1)}) -var v57 any = v58 -_ = v57 -v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v61 := v60.FindInternedVar(lang.NewSymbol("seq")) -if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) +v54 := v53.Get() +v55 := lang.Apply(v54, []any{v4}) +v56 := lang.Apply(lang1.NewBigDecimalFromInt64, []any{v55}) +v47 = v56 +} else { +var v57 any +if lang.IsTruthy(lang.NewKeyword("else")) { +v58 := lang.Apply(BigDecimal13., []any{v4}) +v57 = v58 +} else { +v57 = nil } -v62 := v61.Get() -v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v64 := v63.FindInternedVar(lang.NewSymbol("concat")) -if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) +v47 = v57 } -v65 := v64.Get() -v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v67 := v66.FindInternedVar(lang.NewSymbol("list")) -if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) -} -v68 := v67.Get() -v69 := lang.Apply(v68, []any{lang.NewSymbol("glojure.core/let")}) -v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v71 := v70.FindInternedVar(lang.NewSymbol("list")) -if v71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) +v41 = v47 } -v72 := v71.Get() -v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v74 := v73.FindInternedVar(lang.NewSymbol("apply")) -if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) +v34 = v41 } -v75 := v74.Get() -v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v77 := v76.FindInternedVar(lang.NewSymbol("vector")) -if v77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) +v20 = v34 } -v78 := v77.Get() -v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v80 := v79.FindInternedVar(lang.NewSymbol("seq")) -if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) +v10 = v20 } -v81 := v80.Get() -v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v83 := v82.FindInternedVar(lang.NewSymbol("concat")) -if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) +v5 = v10 } -v84 := v83.Get() -v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v86 := v85.FindInternedVar(lang.NewSymbol("list")) -if v86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) +return v5 +}) +v4 := reflect.TypeOf((*lang1.BigDecimal)(nil)) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v87 := v86.Get() -v88 := lang.Apply(v87, []any{lang.NewSymbol("temp__0__auto__")}) -v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v90 := v89.FindInternedVar(lang.NewSymbol("list")) -if v90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) } -v91 := v90.Get() -v92 := lang.Apply(v91, []any{v57}) -v93 := lang.Apply(v84, []any{v88, v92}) -v94 := lang.Apply(v81, []any{v93}) -v95 := lang.Apply(v75, []any{v78, v94}) -v96 := lang.Apply(v72, []any{v95}) -v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v98 := v97.FindInternedVar(lang.NewSymbol("list")) -if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) +// bigint +{ +v1 := reflect.TypeOf((*lang1.BigInt)(nil)) +v0 := lang.NewSymbol("bigint").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Coerce to BigInt", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3620), lang.NewKeyword("end-line"), int(3620))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v99 := v98.Get() -v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v101 := v100.FindInternedVar(lang.NewSymbol("seq")) -if v101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) +v8 := v7.Get() +v9 := lang.Apply(v8, []any{lang1.*BigInt, v4}) +if lang.IsTruthy(v9) { +v5 = v4 +} else { +var v10 any +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("instance?")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v102 := v101.Get() -v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v104 := v103.FindInternedVar(lang.NewSymbol("concat")) -if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) +v13 := v12.Get() +v14 := lang.Apply(v13, []any{big14.*Int, v4}) +if lang.IsTruthy(v14) { +v15 := lang.Apply(lang1.NewBigIntFromGoBigInt, []any{v4}) +v10 = v15 +} else { +var v16 any +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("decimal?")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v105 := v104.Get() -v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v107 := v106.FindInternedVar(lang.NewSymbol("list")) -if v107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v4}) +if lang.IsTruthy(v20) { +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("bigint")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v108 := v107.Get() -v109 := lang.Apply(v108, []any{lang.NewSymbol("if")}) -v110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v111 := v110.FindInternedVar(lang.NewSymbol("list")) -if v111.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v111))) +v23 := v22.Get() +v24, ok := lang.FieldOrMethod(v4, "toBigInteger") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "toBigInteger"))) } -v112 := v111.Get() -v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v114 := v113.FindInternedVar(lang.NewSymbol("seq")) -if v114.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) +var v25 any +switch reflect.TypeOf(v24).Kind() { +case reflect.Func: + v25 = lang.Apply(v24, nil) +default: + v25 = v24 } -v115 := v114.Get() -v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v117 := v116.FindInternedVar(lang.NewSymbol("concat")) -if v117.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) +v26 := lang.Apply(v23, []any{v25}) +v16 = v26 +} else { +var v27 any +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("float?")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } -v118 := v117.Get() -v119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v120 := v119.FindInternedVar(lang.NewSymbol("list")) -if v120.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v120))) +v30 := v29.Get() +v31 := lang.Apply(v30, []any{v4}) +if lang.IsTruthy(v31) { +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("bigint")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) } -v121 := v120.Get() -v122 := lang.Apply(v121, []any{lang.NewSymbol("glojure.core/nil?")}) -v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v124 := v123.FindInternedVar(lang.NewSymbol("list")) -if v124.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) +v34 := v33.Get() +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("double")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) } -v125 := v124.Get() -v126 := lang.Apply(v125, []any{lang.NewSymbol("temp__0__auto__")}) -v127 := lang.Apply(v118, []any{v122, v126}) -v128 := lang.Apply(v115, []any{v127}) -v129 := lang.Apply(v112, []any{v128}) -v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v131 := v130.FindInternedVar(lang.NewSymbol("list")) -if v131.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) +v37 := v36.Get() +v38 := lang.Apply(v37, []any{v4}) +v39 := lang.Apply(lang1.NewBigDecimalFromFloat64, []any{v38}) +v40 := lang.Apply(v34, []any{v39}) +v27 = v40 +} else { +var v41 any +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("ratio?")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) } -v132 := v131.Get() -v133 := lang.Apply(v132, []any{nil}) -v134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v135 := v134.FindInternedVar(lang.NewSymbol("list")) -if v135.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v135))) +v44 := v43.Get() +v45 := lang.Apply(v44, []any{v4}) +if lang.IsTruthy(v45) { +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("bigint")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) } -v136 := v135.Get() -v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v138 := v137.FindInternedVar(lang.NewSymbol("seq")) -if v138.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) +v48 := v47.Get() +v49, ok := lang.FieldOrMethod(v4, "bigIntegerValue") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "bigIntegerValue"))) } -v139 := v138.Get() -v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v141 := v140.FindInternedVar(lang.NewSymbol("concat")) -if v141.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) +var v50 any +switch reflect.TypeOf(v49).Kind() { +case reflect.Func: + v50 = lang.Apply(v49, nil) +default: + v50 = v49 } -v142 := v141.Get() -v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v144 := v143.FindInternedVar(lang.NewSymbol("list")) -if v144.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) +v51 := lang.Apply(v48, []any{v50}) +v41 = v51 +} else { +var v52 any +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("number?")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) } -v145 := v144.Get() -v146 := lang.Apply(v145, []any{lang.NewSymbol("glojure.core/let")}) -v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v148 := v147.FindInternedVar(lang.NewSymbol("list")) -if v148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) +v55 := v54.Get() +v56 := lang.Apply(v55, []any{v4}) +if lang.IsTruthy(v56) { +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("long")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) } -v149 := v148.Get() -v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v151 := v150.FindInternedVar(lang.NewSymbol("apply")) -if v151.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) +v59 := v58.Get() +v60 := lang.Apply(v59, []any{v4}) +v61 := lang.Apply(lang1.NewBigIntFromInt64, []any{v60}) +v52 = v61 +} else { +var v62 any +if lang.IsTruthy(lang.NewKeyword("else")) { +v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v64 := v63.FindInternedVar(lang.NewSymbol("bigint")) +if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) } -v152 := v151.Get() -v153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v154 := v153.FindInternedVar(lang.NewSymbol("vector")) -if v154.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v154))) +v65 := v64.Get() +v66 := lang.Apply(BigInteger15., []any{v4}) +v67 := lang.Apply(v65, []any{v66}) +v62 = v67 +} else { +v62 = nil } -v155 := v154.Get() -v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v157 := v156.FindInternedVar(lang.NewSymbol("seq")) -if v157.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) +v52 = v62 } -v158 := v157.Get() -v159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v160 := v159.FindInternedVar(lang.NewSymbol("concat")) -if v160.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v160))) +v41 = v52 } -v161 := v160.Get() -v162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v163 := v162.FindInternedVar(lang.NewSymbol("list")) -if v163.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v163))) +v27 = v41 } -v164 := v163.Get() -v165 := lang.Apply(v164, []any{v55}) -v166 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v167 := v166.FindInternedVar(lang.NewSymbol("list")) -if v167.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v167))) +v16 = v27 } -v168 := v167.Get() -v169 := lang.Apply(v168, []any{lang.NewSymbol("temp__0__auto__")}) -v170 := lang.Apply(v161, []any{v165, v169}) -v171 := lang.Apply(v158, []any{v170}) -v172 := lang.Apply(v152, []any{v155, v171}) -v173 := lang.Apply(v149, []any{v172}) -v174 := lang.Apply(v142, []any{v146, v173, v6}) -v175 := lang.Apply(v139, []any{v174}) -v176 := lang.Apply(v136, []any{v175}) -v177 := lang.Apply(v105, []any{v109, v129, v133, v176}) -v178 := lang.Apply(v102, []any{v177}) -v179 := lang.Apply(v99, []any{v178}) -v180 := lang.Apply(v65, []any{v69, v96, v179}) -v181 := lang.Apply(v62, []any{v180}) -return v181 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v10 = v16 } +v5 = v10 } -// shutdown-agents -{ -v0 := lang.NewSymbol("shutdown-agents").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Initiates a shutdown of the thread pools that back the agent\n system. Running actions will complete, but no new actions will be\n accepted", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2252), lang.NewKeyword("end-line"), int(2252))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.Apply(lang1.ShutdownAgents, nil) -return v3 +return v5 }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) +v4 := reflect.TypeOf((*lang1.BigInt)(nil)) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// uri? +// biginteger { -v0 := lang.NewSymbol("uri?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a java.net.URI", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7920), lang.NewKeyword("end-line"), int(7920))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { +v1 := reflect.TypeOf((*big14.Int)(nil)) +v0 := lang.NewSymbol("biginteger").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Coerce to BigInteger", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3634), lang.NewKeyword("end-line"), int(3634))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v4 := args[0] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v6 := v5.Get() -v7 := lang.Apply(v6, []any{java.net16.URI, v3}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v8 := v7.Get() +v9 := lang.Apply(v8, []any{big14.*Int, v4}) +if lang.IsTruthy(v9) { +v5 = v4 +} else { +var v10 any +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("instance?")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } +v13 := v12.Get() +v14 := lang.Apply(v13, []any{lang1.*BigInt, v4}) +if lang.IsTruthy(v14) { +v15, ok := lang.FieldOrMethod(v4, "toBigInteger") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "toBigInteger"))) } -// pop -{ -v0 := lang.NewSymbol("pop").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "For a list or queue, returns a new list/queue without the first\n item, for a vector, returns a new vector without the last item. If\n the collection is empty, throws an exception. Note - not the same\n as next/butlast.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1462), lang.NewKeyword("end-line"), int(1462))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, _ := lang.FieldOrMethod(runtime3.RT, "Pop") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Pop is not a function"))) +var v16 any +switch reflect.TypeOf(v15).Kind() { +case reflect.Func: + v16 = lang.Apply(v15, nil) +default: + v16 = v15 } -v5 := lang.Apply(v4, []any{v3}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v10 = v16 +} else { +var v17 any +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("decimal?")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } +v20 := v19.Get() +v21 := lang.Apply(v20, []any{v4}) +if lang.IsTruthy(v21) { +v22, ok := lang.FieldOrMethod(v4, "toBigInteger") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "toBigInteger"))) } -// rsubseq -{ -v0 := lang.NewSymbol("rsubseq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sc"), lang.NewSymbol("test"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("sc"), lang.NewSymbol("start-test"), lang.NewSymbol("start-key"), lang.NewSymbol("end-test"), lang.NewSymbol("end-key"))), lang.NewKeyword("doc"), "sc must be a sorted collection, test(s) one of <, <=, > or\n >=. Returns a reverse seq of those entries with keys ek for\n which (test (.. sc comparator (compare ek key)) 0) is true", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5150), lang.NewKeyword("end-line"), int(5150))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("mk-bound-fn")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +var v23 any +switch reflect.TypeOf(v22).Kind() { +case reflect.Func: + v23 = lang.Apply(v22, nil) +default: + v23 = v22 } -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v3, v4, v5}) -var v6 any = v10 -_ = v6 -var v12 any -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("<")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +v17 = v23 +} else { +var v24 any +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("float?")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("<=")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +v27 := v26.Get() +v28 := lang.Apply(v27, []any{v4}) +if lang.IsTruthy(v28) { +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("double")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) } -v18 := v17.Get() -v19 := lang.CreatePersistentTreeSet(v15, v18) -v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5158), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5158), lang.NewKeyword("end-column"), int(17)) -v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) -if err != nil { - panic(err) +v31 := v30.Get() +v32 := lang.Apply(v31, []any{v4}) +v33 := lang.Apply(lang1.NewBigDecimalFromFloat64, []any{v32}) +v34, ok := lang.FieldOrMethod(v33, "toBigInteger") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v33, "toBigInteger"))) } -v22 := lang.Apply(v21, []any{v4}) -if lang.IsTruthy(v22) { -v24, _ := lang.FieldOrMethod(v3, "seqFrom") -if reflect.TypeOf(v24).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("seqFrom is not a function"))) +var v35 any +switch reflect.TypeOf(v34).Kind() { +case reflect.Func: + v35 = lang.Apply(v34, nil) +default: + v35 = v34 } -v25 := lang.Apply(v24, []any{v5, false}) -var v23 any = v25 -_ = v23 -var v27 any -if lang.IsTruthy(v23) { -var v28 any = v23 -_ = v28 -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("nth")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +v24 = v35 +} else { +var v36 any +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("ratio?")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -v32 := v31.Get() -v33 := lang.Apply(v32, []any{v28, int64(0), nil}) -var v29 any = v33 -_ = v29 -var v34 any = v28 -_ = v34 -var v36 any -v37 := lang.Apply(v6, []any{v29}) -if lang.IsTruthy(v37) { -v36 = v34 -} else { -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("next")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.Apply(v40, []any{v34}) -v36 = v41 +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v4}) +if lang.IsTruthy(v40) { +v41, ok := lang.FieldOrMethod(v4, "bigIntegerValue") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "bigIntegerValue"))) } -v27 = v36 -} else { -v27 = nil +var v42 any +switch reflect.TypeOf(v41).Kind() { +case reflect.Func: + v42 = lang.Apply(v41, nil) +default: + v42 = v41 } -v12 = v27 +v36 = v42 } else { -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("take-while")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26, _ := lang.FieldOrMethod(v3, "seq") -if reflect.TypeOf(v26).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("seq is not a function"))) -} -v27 := lang.Apply(v26, []any{false}) -v28 := lang.Apply(v25, []any{v6, v27}) -v12 = v28 +var v43 any +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("number?")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } -return v12 - case 5: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := args[4] -v9, _ := lang.FieldOrMethod(v3, "seqFrom") -if reflect.TypeOf(v9).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("seqFrom is not a function"))) +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v4}) +if lang.IsTruthy(v47) { +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("long")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) } -v10 := lang.Apply(v9, []any{v7, false}) -var v8 any = v10 -_ = v8 -var v12 any -if lang.IsTruthy(v8) { -var v13 any = v8 -_ = v13 -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("nth")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v4}) +v52 := lang.Apply(big14.NewInt, []any{v51}) +v43 = v52 +} else { +var v53 any +if lang.IsTruthy(lang.NewKeyword("else")) { +v54 := lang.Apply(BigInteger15., []any{v4}) +v53 = v54 +} else { +v53 = nil } -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v13, int64(0), nil}) -var v14 any = v18 -_ = v14 -var v19 any = v13 -_ = v19 -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("take-while")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +v43 = v53 } -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("mk-bound-fn")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +v36 = v43 } -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v3, v4, v5}) -var v28 any -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("mk-bound-fn")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +v24 = v36 } -v31 := v30.Get() -v32 := lang.Apply(v31, []any{v3, v6, v7}) -v33 := lang.Apply(v32, []any{v14}) -if lang.IsTruthy(v33) { -v28 = v19 -} else { -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("next")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +v17 = v24 } -v36 := v35.Get() -v37 := lang.Apply(v36, []any{v19}) -v28 = v37 +v10 = v17 } -v38 := lang.Apply(v23, []any{v27, v28}) -v12 = v38 -} else { -v12 = nil +v5 = v10 } -return v12 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } +return v5 }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) +v4 := reflect.TypeOf((*big14.Int)(nil)) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// io! +// binding { -v0 := lang.NewSymbol("io!").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "If an io! block occurs in a transaction, throws an\n IllegalStateException, else runs body in an implicit do. If the\n first expression in body is a literal string, will use that as the\n exception message.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(2504), lang.NewKeyword("end-line"), int(2504))).(*lang.Symbol) +v0 := lang.NewSymbol("binding").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "binding => var-symbol init-expr\n\n Creates new bindings for the (already-existing) vars, with the\n supplied initial values, executes the exprs in an implicit do, then\n re-establishes the bindings that existed before. The new bindings\n are made in parallel (unlike let); all init-exprs are evaluated\n before the vars are bound to their new values.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1945), lang.NewKeyword("end-line"), int(1945))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 2 { + if len(args) < 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] v4 := args[1] -v5 := lang.NewList(args[2:]...) +v5 := args[2] +v6 := lang.NewList(args[3:]...) var v7 any v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("string?")) +v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) if v9.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("first")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v11 := lang.Apply(v10, []any{v5}) +if lang.IsTruthy(v11) { +v7 = nil +} else { +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("str")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v5}) -v15 := lang.Apply(v10, []any{v14}) -if lang.IsTruthy(v15) { -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("first")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("first")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v5}) -v7 = v19 -} else { -v7 = nil +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v3}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -var v6 any = v7 -_ = v6 -var v21 any -if lang.IsTruthy(v6) { +v21 := v20.Get() v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("next")) +v23 := v22.FindInternedVar(lang.NewSymbol("meta")) if v23.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } v24 := v23.Get() -v25 := lang.Apply(v24, []any{v20}) -v21 = v25 -} else { -v21 = v20 -} -var v20 any = v21 -_ = v20 -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("seq")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v25 := lang.Apply(v24, []any{v3}) +v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) +v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) +v28 := lang.Apply(lang1.NewIllegalArgumentError, []any{v27}) +panic(v28) } -v29 := v28.Get() +_ = v7 +var v29 any v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("concat")) +v31 := v30.FindInternedVar(lang.NewSymbol("even?")) if v31.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) } v32 := v31.Get() v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("list")) +v34 := v33.FindInternedVar(lang.NewSymbol("count")) if v34.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) } v35 := v34.Get() -v36 := lang.Apply(v35, []any{lang.NewSymbol("if")}) -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("list")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("seq")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("concat")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +v36 := lang.Apply(v35, []any{v5}) +v37 := lang.Apply(v32, []any{v36}) +if lang.IsTruthy(v37) { +v29 = nil +} else { +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("str")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) } -v45 := v44.Get() -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("list")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("first")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } -v48 := v47.Get() -v49 := lang.Apply(v48, []any{lang.NewSymbol("glojure.lang.LockingTransaction/isRunning")}) -v50 := lang.Apply(v45, []any{v49}) -v51 := lang.Apply(v42, []any{v50}) -v52 := lang.Apply(v39, []any{v51}) -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("list")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v3}) +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) } -v55 := v54.Get() -v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v57 := v56.FindInternedVar(lang.NewSymbol("seq")) -if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) +v47 := v46.Get() +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("meta")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) } -v58 := v57.Get() -v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v60 := v59.FindInternedVar(lang.NewSymbol("concat")) -if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v3}) +v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) +v53 := lang.Apply(v40, []any{v44, " requires ", "an even number of forms in binding vector", " in ", v47, ":", v52}) +v54 := lang.Apply(lang1.NewIllegalArgumentError, []any{v53}) +panic(v54) } -v61 := v60.Get() -v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v63 := v62.FindInternedVar(lang.NewSymbol("list")) -if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +_ = v29 +_ = nil +var v56 lang.FnFunc +v56 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v57 := args[0] +v59 := lang.NewVector() +v60 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1959), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(1959), lang.NewKeyword("end-column"), int(31)) +v61, err := lang.WithMeta(v59, v60.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v64 := v63.Get() -v65 := lang.Apply(v64, []any{lang.NewSymbol("throw")}) -v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v67 := v66.FindInternedVar(lang.NewSymbol("list")) -if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) +var v58 any = v61 +_ = v58 +v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v64 := v63.FindInternedVar(lang.NewSymbol("seq")) +if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) } -v68 := v67.Get() -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("seq")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +v65 := v64.Get() +v66 := lang.Apply(v65, []any{v57}) +var v62 any = v66 +_ = v62 +var v67 any +for { +var v68 any +if lang.IsTruthy(v62) { +v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v71 := v70.FindInternedVar(lang.NewSymbol("conj")) +if v71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) } -v71 := v70.Get() -v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v73 := v72.FindInternedVar(lang.NewSymbol("concat")) -if v73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) +v72 := v71.Get() +v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v74 := v73.FindInternedVar(lang.NewSymbol("conj")) +if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) } -v74 := v73.Get() -v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v76 := v75.FindInternedVar(lang.NewSymbol("list")) -if v76.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) +v75 := v74.Get() +v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v77 := v76.FindInternedVar(lang.NewSymbol("seq")) +if v77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) } -v77 := v76.Get() -v78 := lang.Apply(v77, []any{lang.NewSymbol("new")}) +v78 := v77.Get() v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v80 := v79.FindInternedVar(lang.NewSymbol("list")) +v80 := v79.FindInternedVar(lang.NewSymbol("concat")) if v80.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) } v81 := v80.Get() -v82 := lang.Apply(v81, []any{lang.NewSymbol("glojure.core/IllegalStateException")}) -v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v84 := v83.FindInternedVar(lang.NewSymbol("list")) -if v84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) -} -v85 := v84.Get() -var v86 any = v6 -_ = v86 -var v88 any -if lang.IsTruthy(v86) { -v88 = v86 -} else { -v88 = "I/O in transaction" +v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v83 := v82.FindInternedVar(lang.NewSymbol("list")) +if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) } -v86 := lang.Apply(v85, []any{v88}) -v87 := lang.Apply(v74, []any{v78, v82, v86}) -v88 := lang.Apply(v71, []any{v87}) -v89 := lang.Apply(v68, []any{v88}) -v90 := lang.Apply(v61, []any{v65, v89}) -v91 := lang.Apply(v58, []any{v90}) -v92 := lang.Apply(v55, []any{v91}) -v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v94 := v93.FindInternedVar(lang.NewSymbol("list")) -if v94.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) +v84 := v83.Get() +v85 := lang.Apply(v84, []any{lang.NewSymbol("var")}) +v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v87 := v86.FindInternedVar(lang.NewSymbol("list")) +if v87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) } -v95 := v94.Get() -v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v97 := v96.FindInternedVar(lang.NewSymbol("seq")) -if v97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) +v88 := v87.Get() +v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v90 := v89.FindInternedVar(lang.NewSymbol("first")) +if v90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) } -v98 := v97.Get() -v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v100 := v99.FindInternedVar(lang.NewSymbol("concat")) -if v100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) +v91 := v90.Get() +v92 := lang.Apply(v91, []any{v62}) +v93 := lang.Apply(v88, []any{v92}) +v94 := lang.Apply(v81, []any{v85, v93}) +v95 := lang.Apply(v78, []any{v94}) +v96 := lang.Apply(v75, []any{v58, v95}) +v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v98 := v97.FindInternedVar(lang.NewSymbol("second")) +if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) } -v101 := v100.Get() -v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v103 := v102.FindInternedVar(lang.NewSymbol("list")) -if v103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) +v99 := v98.Get() +v100 := lang.Apply(v99, []any{v62}) +v101 := lang.Apply(v72, []any{v96, v100}) +var v69 any = v101 +v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v104 := v103.FindInternedVar(lang.NewSymbol("next")) +if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) } -v104 := v103.Get() -v105 := lang.Apply(v104, []any{lang.NewSymbol("do")}) -v106 := lang.Apply(v101, []any{v105, v20}) -v107 := lang.Apply(v98, []any{v106}) -v108 := lang.Apply(v95, []any{v107}) -v109 := lang.Apply(v32, []any{v36, v52, v92, v108}) -v110 := lang.Apply(v29, []any{v109}) -return v110 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v105 := v104.Get() +v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v107 := v106.FindInternedVar(lang.NewSymbol("next")) +if v107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) } +v108 := v107.Get() +v109 := lang.Apply(v108, []any{v62}) +v110 := lang.Apply(v105, []any{v109}) +var v102 any = v110 +v58 = v69 +v62 = v102 +continue +} else { +v111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v112 := v111.FindInternedVar(lang.NewSymbol("seq")) +if v112.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v112))) } -// *data-readers* -{ -v0 := lang.NewSymbol("*data-readers*").WithMeta(lang.NewMap(lang.NewKeyword("doc"), "Map from reader tag symbols to data reader Vars.\n\n When Clojure starts, it searches for files named 'data_readers.clj'\n and 'data_readers.cljc' at the root of the classpath. Each such file\n must contain a literal map of symbols, like this:\n\n {foo/bar my.project.foo/bar\n foo/baz my.project/baz}\n\n The first symbol in each pair is a tag that will be recognized by\n the Clojure reader. The second symbol in the pair is the\n fully-qualified name of a Var which will be invoked by the reader to\n parse the form following the tag. For example, given the\n data_readers.clj file above, the Clojure reader would parse this\n form:\n\n #foo/bar [1 2 3]\n\n by invoking the Var #'my.project.foo/bar on the vector [1 2 3]. The\n data reader function is invoked on the form AFTER it has been read\n as a normal Clojure data structure by the reader.\n\n Reader tags without namespace qualifiers are reserved for\n Clojure. Default reader tags are defined in\n glojure.core/default-data-readers but may be overridden in\n data_readers.clj, data_readers.cljc, or by rebinding this Var.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(49), lang.NewKeyword("column"), int(6), lang.NewKeyword("line"), int(7837), lang.NewKeyword("end-line"), int(7837), lang.NewKeyword("dynamic"), true)).(*lang.Symbol) -v1 := ns.InternWithValue(v0, lang.NewMap(), true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v113 := v112.Get() +v114 := lang.Apply(v113, []any{v58}) +v68 = v114 } +v67 = v68 + break } -// clear-agent-errors -{ -v0 := lang.NewSymbol("clear-agent-errors").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("doc"), "DEPRECATED: Use 'restart-agent' instead.\n Clears any exceptions thrown during asynchronous actions of the\n agent, allowing subsequent actions to occur.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("deprecated"), "1.2", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2244), lang.NewKeyword("end-line"), int(2244))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("restart-agent")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +return v67 +}) +v57 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1958), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(1963), lang.NewKeyword("end-column"), int(34)) +v58, err := lang.WithMeta(v56, v57.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v6 := v5.Get() -v7, ok := lang.FieldOrMethod(v3, "Deref") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "Deref"))) +var v55 any = v58 +_ = v55 +v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v61 := v60.FindInternedVar(lang.NewSymbol("seq")) +if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) } -var v8 any -switch reflect.TypeOf(v7).Kind() { -case reflect.Func: - v8 = lang.Apply(v7, nil) -default: - v8 = v7 +v62 := v61.Get() +v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v64 := v63.FindInternedVar(lang.NewSymbol("concat")) +if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) } -v9 := lang.Apply(v6, []any{v3, v8}) -return v9 +v65 := v64.Get() +v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v67 := v66.FindInternedVar(lang.NewSymbol("list")) +if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) +} +v68 := v67.Get() +v69 := lang.Apply(v68, []any{lang.NewSymbol("glojure.core/let")}) +v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v71 := v70.FindInternedVar(lang.NewSymbol("list")) +if v71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) +} +v72 := v71.Get() +v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v74 := v73.FindInternedVar(lang.NewSymbol("apply")) +if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) +} +v75 := v74.Get() +v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v77 := v76.FindInternedVar(lang.NewSymbol("vector")) +if v77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) +} +v78 := v77.Get() +v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v80 := v79.FindInternedVar(lang.NewSymbol("seq")) +if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) +} +v81 := v80.Get() +v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v83 := v82.FindInternedVar(lang.NewSymbol("concat")) +if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) +} +v84 := v83.Get() +v85 := lang.Apply(v84, nil) +v86 := lang.Apply(v81, []any{v85}) +v87 := lang.Apply(v75, []any{v78, v86}) +v88 := lang.Apply(v72, []any{v87}) +v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v90 := v89.FindInternedVar(lang.NewSymbol("list")) +if v90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) +} +v91 := v90.Get() +v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v93 := v92.FindInternedVar(lang.NewSymbol("seq")) +if v93.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) +} +v94 := v93.Get() +v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v96 := v95.FindInternedVar(lang.NewSymbol("concat")) +if v96.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) +} +v97 := v96.Get() +v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v99 := v98.FindInternedVar(lang.NewSymbol("list")) +if v99.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) +} +v100 := v99.Get() +v101 := lang.Apply(v100, []any{lang.NewSymbol("glojure.core/push-thread-bindings")}) +v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v103 := v102.FindInternedVar(lang.NewSymbol("list")) +if v103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) +} +v104 := v103.Get() +v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v106 := v105.FindInternedVar(lang.NewSymbol("seq")) +if v106.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) +} +v107 := v106.Get() +v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v109 := v108.FindInternedVar(lang.NewSymbol("concat")) +if v109.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) +} +v110 := v109.Get() +v111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v112 := v111.FindInternedVar(lang.NewSymbol("list")) +if v112.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v112))) +} +v113 := v112.Get() +v114 := lang.Apply(v113, []any{lang.NewSymbol("glojure.core/hash-map")}) +v115 := lang.Apply(v55, []any{v5}) +v116 := lang.Apply(v110, []any{v114, v115}) +v117 := lang.Apply(v107, []any{v116}) +v118 := lang.Apply(v104, []any{v117}) +v119 := lang.Apply(v97, []any{v101, v118}) +v120 := lang.Apply(v94, []any{v119}) +v121 := lang.Apply(v91, []any{v120}) +v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v123 := v122.FindInternedVar(lang.NewSymbol("list")) +if v123.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) +} +v124 := v123.Get() +v125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v126 := v125.FindInternedVar(lang.NewSymbol("seq")) +if v126.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v126))) +} +v127 := v126.Get() +v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v129 := v128.FindInternedVar(lang.NewSymbol("concat")) +if v129.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v129))) +} +v130 := v129.Get() +v131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v132 := v131.FindInternedVar(lang.NewSymbol("list")) +if v132.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v132))) +} +v133 := v132.Get() +v134 := lang.Apply(v133, []any{lang.NewSymbol("try")}) +v135 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v136 := v135.FindInternedVar(lang.NewSymbol("list")) +if v136.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v136))) +} +v137 := v136.Get() +v138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v139 := v138.FindInternedVar(lang.NewSymbol("seq")) +if v139.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v139))) +} +v140 := v139.Get() +v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v142 := v141.FindInternedVar(lang.NewSymbol("concat")) +if v142.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) +} +v143 := v142.Get() +v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v145 := v144.FindInternedVar(lang.NewSymbol("list")) +if v145.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) +} +v146 := v145.Get() +v147 := lang.Apply(v146, []any{lang.NewSymbol("finally")}) +v148 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v149 := v148.FindInternedVar(lang.NewSymbol("list")) +if v149.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v149))) +} +v150 := v149.Get() +v151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v152 := v151.FindInternedVar(lang.NewSymbol("seq")) +if v152.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v152))) +} +v153 := v152.Get() +v154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v155 := v154.FindInternedVar(lang.NewSymbol("concat")) +if v155.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v155))) +} +v156 := v155.Get() +v157 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v158 := v157.FindInternedVar(lang.NewSymbol("list")) +if v158.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v158))) +} +v159 := v158.Get() +v160 := lang.Apply(v159, []any{lang.NewSymbol("glojure.core/pop-thread-bindings")}) +v161 := lang.Apply(v156, []any{v160}) +v162 := lang.Apply(v153, []any{v161}) +v163 := lang.Apply(v150, []any{v162}) +v164 := lang.Apply(v143, []any{v147, v163}) +v165 := lang.Apply(v140, []any{v164}) +v166 := lang.Apply(v137, []any{v165}) +v167 := lang.Apply(v130, []any{v134, v6, v166}) +v168 := lang.Apply(v127, []any{v167}) +v169 := lang.Apply(v124, []any{v168}) +v170 := lang.Apply(v65, []any{v69, v88, v121, v169}) +v171 := lang.Apply(v62, []any{v170}) +return v171 + } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -12547,124 +12301,145 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// re-find +// binding-conveyor-fn { -v0 := lang.NewSymbol("re-find").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m")), lang.NewVector(lang.NewSymbol("re"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns the next regex match, if any, of string to pattern, using\n java.util.regex.Matcher.find(). Uses re-groups to return the\n groups.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4922), lang.NewKeyword("end-line"), int(4922))).(*lang.Symbol) +v0 := lang.NewSymbol("binding-conveyor-fn").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2020), lang.NewKeyword("end-line"), int(2020), lang.NewKeyword("private"), true)).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v5 := lang.Apply(lang1.CloneThreadBindingFrame, nil) +var v4 any = v5 +_ = v4 +var v7 lang.FnFunc +v7 = lang.NewFnFunc(func(args ...any) any { switch len(args) { + case 0: +v8 := lang.Apply(lang1.ResetThreadBindingFrame, []any{v4}) +_ = v8 +v9 := lang.Apply(v3, nil) +return v9 case 1: -v3 := args[0] -var v4 any -v5, _ := lang.FieldOrMethod(v3, "find") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("find is not a function"))) -} -v6 := lang.Apply(v5, []any{}) -if lang.IsTruthy(v6) { -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("re-groups")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v3}) -v4 = v10 -} else { -v4 = nil -} -return v4 +v8 := args[0] +v9 := lang.Apply(lang1.ResetThreadBindingFrame, []any{v4}) +_ = v9 +v10 := lang.Apply(v3, []any{v8}) +return v10 case 2: -v3 := args[0] -v4 := args[1] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("re-matcher")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v3, v4}) -var v5 any = v9 -_ = v5 -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("re-find")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v5}) -return v14 +v8 := args[0] +v9 := args[1] +v10 := lang.Apply(lang1.ResetThreadBindingFrame, []any{v4}) +_ = v10 +v11 := lang.Apply(v3, []any{v8, v9}) +return v11 + case 3: +v8 := args[0] +v9 := args[1] +v10 := args[2] +v11 := lang.Apply(lang1.ResetThreadBindingFrame, []any{v4}) +_ = v11 +v12 := lang.Apply(v3, []any{v8, v9, v10}) +return v12 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v8 := args[0] +v9 := args[1] +v10 := args[2] +v11 := lang.NewList(args[3:]...) +v12 := lang.Apply(lang1.ResetThreadBindingFrame, []any{v4}) +_ = v12 +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("apply")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v3, v8, v9, v10, v11}) +return v16 } }) +v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2025), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2040), lang.NewKeyword("end-column"), int(31)) +v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v9 +}) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// unchecked-subtract +// bit-and { var v1 lang.FnFunc -{ // function unchecked-subtract__inliner v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] + switch len(args) { + case 1: +v2 := args[0] +var v4 any v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) if v6.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("concat")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +if lang.IsTruthy(v7) { +v4 = closed7 +} else { +v4 = v3 } -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("list")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +var v3 any = v4 +_ = v3 +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("seq")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -v13 := v12.Get() -v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("concat")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v16 := v15.FindInternedVar(lang.NewSymbol("list")) if v16.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v20 := v19.FindInternedVar(lang.NewSymbol("list")) if v20.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("seq")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("concat")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("seq")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) } -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("list")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("concat")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) } -v30 := v29.Get() -v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/unchecked_minus")}) +v31 := v30.Get() v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v33 := v32.FindInternedVar(lang.NewSymbol("list")) if v33.IsMacro() { @@ -12678,800 +12453,415 @@ if v37.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) } v38 := v37.Get() -v39 := lang.Apply(v38, []any{v4}) -v40 := lang.Apply(v27, []any{v31, v35, v39}) -v41 := lang.Apply(v24, []any{v40}) -v42 := lang.Apply(v21, []any{v41}) -v43 := lang.Apply(v10, []any{v14, v18, v42}) -v44 := lang.Apply(v7, []any{v43}) +v39 := lang.Apply(v38, []any{v2}) +v40 := lang.Apply(v31, []any{v35, v39}) +v41 := lang.Apply(v28, []any{v40}) +v42 := lang.Apply(v25, []any{v41}) +v43 := lang.Apply(v14, []any{v18, v22, v42}) +v44 := lang.Apply(v11, []any{v43}) return v44 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("unchecked-subtract").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the difference of x and y, both long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1217), lang.NewKeyword("end-line"), int(1217))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6, _ := lang.FieldOrMethod(lang1.Numbers, "unchecked_minus") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_minus is not a function"))) -} -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// is-annotation? -{ -v0 := lang.NewSymbol("is-annotation?").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5471), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(5471), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("class?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -var v4 any = v8 -_ = v4 -var v10 any -if lang.IsTruthy(v4) { -v11, _ := lang.FieldOrMethod(java.lang.annotation17.Annotation, "isAssignableFrom") -if reflect.TypeOf(v11).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("isAssignableFrom is not a function"))) + case 2: +v2 := args[0] +v3 := args[1] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v12 := lang.Apply(v11, []any{v3}) -v10 = v12 +v8 := v7.Get() +if lang.IsTruthy(v8) { +v5 = closed7 } else { -v10 = v4 -} -return v10 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v5 = v4 } +var v4 any = v5 +_ = v4 +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("seq")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -// assoc -{ -v0 := lang.NewSymbol("assoc").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"), lang.NewSymbol("val"), lang.NewSymbol("&"), lang.NewSymbol("kvs"))), lang.NewKeyword("doc"), "assoc[iate]. When applied to a map, returns a new map of the\n same (hashed/sorted) type, that contains the mapping of key(s) to\n val(s). When applied to a vector, returns a new vector that\n contains val at index. Note - index must be <= (count vector).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(181), lang.NewKeyword("end-line"), int(188))).(*lang.Symbol) -var v2 lang.FnFunc -{ // function assoc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 3: -v4 := args[0] -v5 := args[1] -v6 := args[2] -v7 := lang.Apply(lang1.Assoc, []any{v4, v5, v6}) -return v7 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6 := args[2] -v7 := lang.NewList(args[3:]...) -recur_loop_24: -v9 := lang.Apply(lang1.Assoc, []any{v4, v5, v6}) -var v8 any = v9 -_ = v8 -var v11 any -if lang.IsTruthy(v7) { -var v12 any +v12 := v11.Get() v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("next")) +v14 := v13.FindInternedVar(lang.NewSymbol("concat")) if v14.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } v15 := v14.Get() -v16 := lang.Apply(v15, []any{v7}) -if lang.IsTruthy(v16) { -var v17 any = v8 -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("first")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("list")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v7}) -var v18 any = v22 -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("second")) -if v25.IsMacro() { +v18 := v17.Get() +v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("list")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("list")) +if v25.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } v26 := v25.Get() -v27 := lang.Apply(v26, []any{v7}) -var v23 any = v27 -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("nnext")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.Apply(v31, []any{v7}) -var v28 any = v32 -v4 = v17 -v5 = v18 -v6 = v23 -v7 = v28 -goto recur_loop_24 -} else { -v33 := lang.Apply(lang1.NewIllegalArgumentError, []any{"assoc expects even number of arguments after map/vector, found odd number"}) -panic(v33) -} -v11 = v12 -} else { -v11 = v8 -} -return v11 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(189), lang.NewKeyword("column"), int(2), lang.NewKeyword("end-line"), int(198), lang.NewKeyword("end-column"), int(15))).(lang.FnFunc) -v3 := v2 -_ = v3 -} -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// *3 -{ -v0 := lang.NewSymbol("*3").WithMeta(lang.NewMap()).(*lang.Symbol) -v1 := ns.Intern(v0) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("seq")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } +v29 := v28.Get() +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("concat")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) } -// coll? -{ -v0 := lang.NewSymbol("coll?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements IPersistentCollection", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6235), lang.NewKeyword("end-line"), int(6235))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("list")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) } -v6 := v5.Get() -v7 := lang.Apply(v6, []any{lang1.IPersistentCollection, v3}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v4}) +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("list")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v2}) +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("list")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } -// printf -{ -v0 := lang.NewSymbol("printf").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fmt"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Prints formatted output, as per format", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5768), lang.NewKeyword("end-line"), int(5768))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v3}) +v45 := lang.Apply(v32, []any{v36, v40, v44}) +v46 := lang.Apply(v29, []any{v45}) +v47 := lang.Apply(v26, []any{v46}) +v48 := lang.Apply(v15, []any{v19, v23, v47}) +v49 := lang.Apply(v12, []any{v48}) +return v49 default: - if len(args) < 1 { + if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := args[0] -v4 := lang.NewList(args[1:]...) -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("print")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v2 := args[0] +v3 := args[1] +v4 := lang.NewList(args[2:]...) +var v6 any +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("apply")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v9 := v8.Get() +if lang.IsTruthy(v9) { +v6 = closed7 +} else { +v6 = v5 } -v10 := v9.Get() +var v5 any = v6 +_ = v5 v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("format")) +v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) if v12.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } v13 := v12.Get() -v14 := lang.Apply(v10, []any{v13, v3, v4}) -v15 := lang.Apply(v7, []any{v14}) -return v15 +var v14 lang.FnFunc +v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v15 := args[0] +v16 := args[1] +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -// tapset -{ -v0 := lang.NewSymbol("tapset").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7925), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(7925), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v2 := lang.NewAtom(lang.CreatePersistentTreeSet()) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -// name -{ -v1 := reflect.TypeOf("") -v0 := lang.NewSymbol("name").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns the name String of a string, symbol or keyword.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1585), lang.NewKeyword("end-line"), int(1585))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("string?")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v4}) -if lang.IsTruthy(v9) { -v5 = v4 -} else { -v10, _ := lang.FieldOrMethod(v4, "Name") -if reflect.TypeOf(v10).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Name is not a function"))) +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } -v11 := lang.Apply(v10, []any{}) -v5 = v11 +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -return v5 -}) -v4 := reflect.TypeOf("") -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) } +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v5}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } -// iteration -{ -v0 := lang.NewSymbol("iteration").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("step"), lang.NewSymbol("&"), lang.NewMap(lang.NewKeyword("keys"), lang.NewVector(lang.NewSymbol("somef"), lang.NewSymbol("vf"), lang.NewSymbol("kf"), lang.NewSymbol("initk")), lang.NewKeyword("or"), lang.NewMap(lang.NewSymbol("vf"), lang.NewSymbol("identity"), lang.NewSymbol("kf"), lang.NewSymbol("identity"), lang.NewSymbol("somef"), lang.NewSymbol("some?"), lang.NewSymbol("initk"), nil)))), lang.NewKeyword("doc"), "Creates a seqable/reducible via repeated calls to step,\n a function of some (continuation token) 'k'. The first call to step\n will be passed initk, returning 'ret'. Iff (somef ret) is true,\n (vf ret) will be included in the iteration, else iteration will\n terminate and vf/kf will not be called. If (kf ret) is non-nil it\n will be passed to the next step call, else iteration will terminate.\n\n This can be used e.g. to consume APIs that return paginated or batched data.\n\n step - (possibly impure) fn of 'k' -> 'ret'\n\n :somef - fn of 'ret' -> logical true/false, default 'some?'\n :vf - fn of 'ret' -> 'v', a value produced by the iteration, default 'identity'\n :kf - fn of 'ret' -> 'next-k' or nil (signaling 'do not continue'), default 'identity'\n :initk - the first value passed to step, default 'nil'\n\n It is presumed that step with non-initk is unreproducible/non-idempotent.\n If step with initk is unreproducible it is on the consumer to not consume twice.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7759), lang.NewKeyword("end-line"), int(7759))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.NewList(args[1:]...) -var v5 any = v4 -_ = v5 -var v7 any -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("seq?")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v15}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) } -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v6}) -if lang.IsTruthy(v11) { -var v12 any -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("next")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v16}) +v52 := lang.Apply(v39, []any{v43, v47, v51}) +v53 := lang.Apply(v36, []any{v52}) +v54 := lang.Apply(v33, []any{v53}) +v55 := lang.Apply(v22, []any{v26, v30, v54}) +v56 := lang.Apply(v19, []any{v55}) +return v56 +}) +v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) +v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v6}) -if lang.IsTruthy(v16) { v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("to-array")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) if v18.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } v19 := v18.Get() -v20 := lang.Apply(v19, []any{v6}) -v21 := lang.Apply(lang1.NewPersistentArrayMapAsIfByAssoc, []any{v20}) -v12 = v21 -} else { -var v22 any +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("seq")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) if v24.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } v25 := v24.Get() -v26 := lang.Apply(v25, []any{v6}) -if lang.IsTruthy(v26) { +v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("first")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) if v28.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } v29 := v28.Get() -v30 := lang.Apply(v29, []any{v6}) -v22 = v30 -} else { -v22 = nil -} -v12 = v22 -} -v7 = v12 -} else { -v7 = v6 +v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -var v6 any = v7 -_ = v6 -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("get")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } -v34 := v33.Get() -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("some?")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -v37 := v36.Get() -v38 := lang.Apply(v34, []any{v6, lang.NewKeyword("somef"), v37}) -var v31 any = v38 -_ = v31 +v39 := v38.Get() v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("get")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) if v41.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) } v42 := v41.Get() -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("identity")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +v43 := lang.Apply(v42, []any{v5}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } -v45 := v44.Get() -v46 := lang.Apply(v42, []any{v6, lang.NewKeyword("vf"), v45}) -var v39 any = v46 -_ = v39 +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v2}) v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("get")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) if v49.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) } v50 := v49.Get() -v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v52 := v51.FindInternedVar(lang.NewSymbol("identity")) -if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) -} -v53 := v52.Get() -v54 := lang.Apply(v50, []any{v6, lang.NewKeyword("kf"), v53}) -var v47 any = v54 -_ = v47 -v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v57 := v56.FindInternedVar(lang.NewSymbol("get")) -if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) -} -v58 := v57.Get() -v59 := lang.Apply(v58, []any{v6, lang.NewKeyword("initk"), nil}) -var v55 any = v59 -_ = v55 -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("seq")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) -} -v63 := v62.Get() -v64 := lang.NewVector(nil) -v65 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7786), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(7786), lang.NewKeyword("end-column"), int(11)) -v66, err := lang.WithMeta(v64, v65.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v67 lang.FnFunc -{ // function next -v67 = lang.NewFnFunc(func(args ...any) any { +v51 := lang.Apply(v50, []any{v3}) +v52 := lang.Apply(v39, []any{v43, v47, v51}) +v53 := lang.Apply(v36, []any{v52}) +v54 := lang.Apply(v33, []any{v53}) +v55 := lang.Apply(v22, []any{v26, v30, v54}) +v56 := lang.Apply(v19, []any{v55}) +v57 := lang.Apply(v13, []any{v16, v56, v4}) +return v57 + } +}) +v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v69 := args[0] -var v70 any -v71 := lang.Apply(v31, []any{v69}) -if lang.IsTruthy(v71) { -v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v73 := v72.FindInternedVar(lang.NewSymbol("cons")) -if v73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) -} -v74 := v73.Get() -v75 := lang.Apply(v39, []any{v69}) -v77 := lang.Apply(v47, []any{v69}) -var v76 any = v77 -_ = v76 -var v79 any -v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v81 := v80.FindInternedVar(lang.NewSymbol("nil?")) -if v81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) +v3 := args[0] +v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } -v82 := v81.Get() -v83 := lang.Apply(v82, []any{v76}) -if lang.IsTruthy(v83) { -v79 = nil -} else { -var v84 any = v76 -_ = v84 -var v86 lang.FnFunc -v86 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v87 := lang.Apply(v3, []any{v84}) -v88 := lang.Apply(v68, []any{v87}) -return v88 +v5 := lang.Apply(v4, []any{v3, int64(1)}) +return v5 }) -v87 := lang.Apply(lang1.NewLazySeq, []any{v86}) -v79 = v87 +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v0 := lang.NewSymbol("bit-and").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Bitwise and", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1298), lang.NewKeyword("end-line"), int(1298))).(*lang.Symbol) +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v5 := args[0] +v6 := args[1] +v7, _ := lang.FieldOrMethod(lang1.Numbers, "and") +if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("and is not a function"))) } -v76 := lang.Apply(v74, []any{v75, v79}) -v70 = v76 -} else { -v70 = nil +v8 := lang.Apply(v7, []any{v5, v6}) +return v8 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +v6 := args[1] +v7 := lang.NewList(args[2:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -return v70 -}) -v68 := v67 -_ = v68 +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("bit-and")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v68 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7787), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(7791), lang.NewKeyword("end-column"), int(51)) -v69, err := lang.WithMeta(v67, v68.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v70 := lang.Apply(v3, []any{v55}) -v71 := lang.Apply(v69, []any{v70}) -v72 := lang.Apply(v63, []any{v66, v71}) -v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v74 := v73.FindInternedVar(lang.NewSymbol("reduce")) -if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) -} -v75 := v74.Get() -v76 := lang.NewVector(nil, nil, nil) -v77 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7794), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(7794), lang.NewKeyword("end-column"), int(22)) -v78, err := lang.WithMeta(v76, v77.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v79 any = nil -_ = v79 -v81 := lang.Apply(v3, []any{v55}) -var v80 any = v81 -_ = v80 -var v82 any -for { -var v83 any -v84 := lang.Apply(v31, []any{v80}) -if lang.IsTruthy(v84) { -v86 := lang.Apply(v39, []any{v80}) -v87 := lang.Apply(nil, []any{v85, v86}) -var v85 any = v87 -_ = v85 -var v89 any -v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v91 := v90.FindInternedVar(lang.NewSymbol("reduced?")) -if v91.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) -} -v92 := v91.Get() -v93 := lang.Apply(v92, []any{v85}) -if lang.IsTruthy(v93) { -v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v95 := v94.FindInternedVar(lang.NewSymbol("deref")) -if v95.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) -} -v96 := v95.Get() -v97 := lang.Apply(v96, []any{v85}) -v89 = v97 -} else { -v99 := lang.Apply(v47, []any{v80}) -var v98 any = v99 -_ = v98 -var v101 any -v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v103 := v102.FindInternedVar(lang.NewSymbol("nil?")) -if v103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) -} -v104 := v103.Get() -v105 := lang.Apply(v104, []any{v98}) -if lang.IsTruthy(v105) { -v101 = v85 -} else { -var v106 any = v98 -_ = v106 -var v108 any = v85 -v110 := lang.Apply(v3, []any{v106}) -var v109 any = v110 -v79 = v108 -v80 = v109 -continue -} -v89 = v101 -} -v83 = v89 -} else { -v83 = v79 -} -v82 = v83 - break -} -v79 := lang.Apply(v75, []any{v78, v82}) -v80 := lang.Apply(nil, []any{glojure.lang11.Seqable, v72, lang1.IReduceInit, v79}) -return v80 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// count -{ -var v1 lang.FnFunc -{ // function count__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/Count")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v3}) -v35 := lang.Apply(v26, []any{v30, v34}) -v36 := lang.Apply(v23, []any{v35}) -v37 := lang.Apply(v20, []any{v36}) -v38 := lang.Apply(v9, []any{v13, v17, v37}) -v39 := lang.Apply(v6, []any{v38}) -return v39 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("count").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the number of items in the collection. (count nil) returns\n 0. Also works on strings, arrays, and Java Collections and Maps", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(867), lang.NewKeyword("end-line"), int(867))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := lang.Apply(lang1.Count, []any{v4}) -return v5 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// >0? -{ -v0 := lang.NewSymbol(">0?").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(963), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(963), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) -} -v5 := lang.Apply(v4, []any{v3, int64(0)}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// reduced? -{ -var v1 lang.FnFunc -{ // function reduced?__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.IsReduced")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("bit-and")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } v16 := v15.Get() -v17 := lang.Apply(v16, []any{v3}) -v18 := lang.Apply(v9, []any{v13, v17}) -v19 := lang.Apply(v6, []any{v18}) -return v19 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("reduced?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns true if x is the result of a call to reduced", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)), lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2834), lang.NewKeyword("end-line"), int(2834))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) +v17 := lang.Apply(v16, []any{v5, v6}) +v18 := lang.Apply(v10, []any{v13, v17, v7}) +return v18 } -v4 := args[0] -v5 := lang.Apply(lang1.IsReduced, []any{v4}) -return v5 }) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) +v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v3 := ns.InternWithValue(v0, v4, true) if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + v3.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// unchecked-multiply-int +// bit-and-not { var v1 lang.FnFunc -{ // function unchecked-multiply-int__inliner v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] + switch len(args) { + case 1: +v2 := args[0] +var v4 any v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) if v6.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("concat")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +if lang.IsTruthy(v7) { +v4 = closed8 +} else { +v4 = v3 } -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("list")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +var v3 any = v4 +_ = v3 +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("seq")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -v13 := v12.Get() -v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("concat")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v16 := v15.FindInternedVar(lang.NewSymbol("list")) if v16.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v20 := v19.FindInternedVar(lang.NewSymbol("list")) if v20.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("seq")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("concat")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("seq")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) } -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("list")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("concat")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) } -v30 := v29.Get() -v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/unchecked_int_multiply")}) +v31 := v30.Get() v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v33 := v32.FindInternedVar(lang.NewSymbol("list")) if v33.IsMacro() { @@ -13485,257 +12875,366 @@ if v37.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) } v38 := v37.Get() -v39 := lang.Apply(v38, []any{v4}) -v40 := lang.Apply(v27, []any{v31, v35, v39}) -v41 := lang.Apply(v24, []any{v40}) -v42 := lang.Apply(v21, []any{v41}) -v43 := lang.Apply(v10, []any{v14, v18, v42}) -v44 := lang.Apply(v7, []any{v43}) +v39 := lang.Apply(v38, []any{v2}) +v40 := lang.Apply(v31, []any{v35, v39}) +v41 := lang.Apply(v28, []any{v40}) +v42 := lang.Apply(v25, []any{v41}) +v43 := lang.Apply(v14, []any{v18, v22, v42}) +v44 := lang.Apply(v11, []any{v43}) return v44 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("unchecked-multiply-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the product of x and y, both int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1224), lang.NewKeyword("end-line"), int(1224))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6, _ := lang.FieldOrMethod(lang1.Numbers, "unchecked_int_multiply") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_multiply is not a function"))) -} -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} + case 2: +v2 := args[0] +v3 := args[1] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -// sync -{ -v0 := lang.NewSymbol("sync").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("flags-ignored-for-now"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "transaction-flags => TBD, pass nil for now\n\n Runs the exprs (in an implicit do) in a transaction that encompasses\n exprs and any nested calls. Starts a transaction if none is already\n running on this thread. Any uncaught exception will abort the\n transaction and flow out of sync. The exprs may be run more than\n once, but any effects on Refs will be atomic.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(2490), lang.NewKeyword("end-line"), int(2490))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("seq")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v8 := v7.Get() +if lang.IsTruthy(v8) { +v5 = closed8 +} else { +v5 = v4 } -v9 := v8.Get() +var v4 any = v5 +_ = v4 v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("concat")) +v11 := v10.FindInternedVar(lang.NewSymbol("seq")) if v11.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } v12 := v11.Get() v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("list")) +v14 := v13.FindInternedVar(lang.NewSymbol("concat")) if v14.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } v15 := v14.Get() -v16 := lang.Apply(v15, []any{lang.NewSymbol(".")}) -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("list")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("list")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -v19 := v18.Get() -v20 := lang.Apply(v19, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.LockingTransaction")}) -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("list")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +v18 := v17.Get() +v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("list")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v23 := v22.Get() +v22 := v21.Get() +v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("seq")) +v25 := v24.FindInternedVar(lang.NewSymbol("list")) if v25.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } v26 := v25.Get() v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("concat")) +v28 := v27.FindInternedVar(lang.NewSymbol("seq")) if v28.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } v29 := v28.Get() v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("list")) +v31 := v30.FindInternedVar(lang.NewSymbol("concat")) if v31.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) } v32 := v31.Get() -v33 := lang.Apply(v32, []any{lang.NewSymbol("glojure.core/RunInTransaction")}) -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("list")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("list")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) } -v36 := v35.Get() +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v4}) v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("seq")) +v38 := v37.FindInternedVar(lang.NewSymbol("list")) if v38.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("concat")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +v40 := lang.Apply(v39, []any{v2}) +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("list")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } -v42 := v41.Get() -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("list")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v3}) +v45 := lang.Apply(v32, []any{v36, v40, v44}) +v46 := lang.Apply(v29, []any{v45}) +v47 := lang.Apply(v26, []any{v46}) +v48 := lang.Apply(v15, []any{v19, v23, v47}) +v49 := lang.Apply(v12, []any{v48}) +return v49 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v2 := args[0] +v3 := args[1] +v4 := lang.NewList(args[2:]...) +var v6 any +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v45 := v44.Get() -v46 := lang.Apply(v45, []any{lang.NewSymbol("glojure.core/fn")}) -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("list")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +v9 := v8.Get() +if lang.IsTruthy(v9) { +v6 = closed8 +} else { +v6 = v5 } -v49 := v48.Get() -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("apply")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +var v5 any = v6 +_ = v5 +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v52 := v51.Get() -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("vector")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +v13 := v12.Get() +var v14 lang.FnFunc +v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v15 := args[0] +v16 := args[1] +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v55 := v54.Get() -v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v57 := v56.FindInternedVar(lang.NewSymbol("seq")) -if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v58 := v57.Get() -v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v60 := v59.FindInternedVar(lang.NewSymbol("concat")) -if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v61 := v60.Get() -v62 := lang.Apply(v61, nil) -v63 := lang.Apply(v58, []any{v62}) -v64 := lang.Apply(v52, []any{v55, v63}) -v65 := lang.Apply(v49, []any{v64}) -v66 := lang.Apply(v42, []any{v46, v65, v6}) -v67 := lang.Apply(v39, []any{v66}) -v68 := lang.Apply(v36, []any{v67}) -v69 := lang.Apply(v29, []any{v33, v68}) -v70 := lang.Apply(v26, []any{v69}) -v71 := lang.Apply(v23, []any{v70}) -v72 := lang.Apply(v12, []any{v16, v20, v71}) -v73 := lang.Apply(v9, []any{v72}) -return v73 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } -// keyword -{ -v1 := reflect.TypeOf((*lang1.Keyword)(nil)).Elem() -v0 := lang.NewSymbol("keyword").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name"))), lang.NewKeyword("doc"), "Returns a Keyword with the given namespace and name. Do not use :\n in the keyword strings, it will be added automatically.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(609), lang.NewKeyword("end-line"), int(609))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v4 := args[0] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("keyword?")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v4}) -if lang.IsTruthy(v9) { -v5 = v4 -} else { -var v10 any -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("symbol?")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v5}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v15}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v16}) +v52 := lang.Apply(v39, []any{v43, v47, v51}) +v53 := lang.Apply(v36, []any{v52}) +v54 := lang.Apply(v33, []any{v53}) +v55 := lang.Apply(v22, []any{v26, v30, v54}) +v56 := lang.Apply(v19, []any{v55}) +return v56 +}) +v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) +v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v4}) -if lang.IsTruthy(v14) { -v15 := lang.Apply(lang1.InternKeywordSymbol, []any{v4}) -v10 = v15 -} else { -var v16 any v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("string?")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) if v18.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } v19 := v18.Get() -v20 := lang.Apply(v19, []any{v4}) -if lang.IsTruthy(v20) { -v21 := lang.Apply(lang1.InternKeywordString, []any{v4}) -v16 = v21 -} else { -v16 = nil +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v10 = v16 +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v5 = v10 +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v5}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v2}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v3}) +v52 := lang.Apply(v39, []any{v43, v47, v51}) +v53 := lang.Apply(v36, []any{v52}) +v54 := lang.Apply(v33, []any{v53}) +v55 := lang.Apply(v22, []any{v26, v30, v54}) +v56 := lang.Apply(v19, []any{v55}) +v57 := lang.Apply(v13, []any{v16, v56, v4}) +return v57 + } +}) +v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } +v5 := lang.Apply(v4, []any{v3, int64(1)}) return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v0 := lang.NewSymbol("bit-and-not").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Bitwise and with complement", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1325), lang.NewKeyword("end-line"), int(1325))).(*lang.Symbol) +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { case 2: -v4 := args[0] -v5 := args[1] -v6 := lang.Apply(lang1.InternKeyword, []any{v4, v5}) -return v6 +v5 := args[0] +v6 := args[1] +v7, _ := lang.FieldOrMethod(lang1.Numbers, "andNot") +if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("andNot is not a function"))) +} +v8 := lang.Apply(v7, []any{v5, v6}) +return v8 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +v6 := args[1] +v7 := lang.NewList(args[2:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("bit-and-not")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("bit-and-not")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v5, v6}) +v18 := lang.Apply(v10, []any{v13, v17, v7}) +return v18 } }) -v4 := reflect.TypeOf((*lang1.Keyword)(nil)).Elem() -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) +v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v3 := ns.InternWithValue(v0, v4, true) if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + v3.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// number? +// bit-clear { -v0 := lang.NewSymbol("number?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is a Number", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3560), lang.NewKeyword("end-line"), int(3560))).(*lang.Symbol) +v0 := lang.NewSymbol("bit-clear").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Clear bit at index n", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1336), lang.NewKeyword("end-line"), int(1336))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { + if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := lang.Apply(lang1.IsNumber, []any{v3}) -return v4 +v4 := args[1] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "clearBit") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("clearBit is not a function"))) +} +v6 := lang.Apply(v5, []any{v3, v4}) +return v6 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -13743,9 +13242,9 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// print-throwable +// bit-flip { -v0 := lang.NewSymbol("print-throwable").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(478), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(478), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v0 := lang.NewSymbol("bit-flip").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Flip bit at index n", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1348), lang.NewKeyword("end-line"), int(1348))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { @@ -13753,674 +13252,554 @@ v2 = lang.NewFnFunc(func(args ...any) any { } v3 := args[0] v4 := args[1] -v5 := lang.Apply(lang1.WriteWriter, []any{v4, "#error {\n :cause "}) -_ = v5 +v5, _ := lang.FieldOrMethod(lang1.Numbers, "flipBit") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("flipBit is not a function"))) +} +v6 := lang.Apply(v5, []any{v3, v4}) +return v6 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// bit-not +{ +var v1 lang.FnFunc +{ // function bit-not__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("Throwable->map")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) if v8.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } v9 := v8.Get() -v10 := lang.Apply(v9, []any{v3}) -var v6 any = v10 -_ = v6 -var v12 any -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("seq?")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v11}) -if lang.IsTruthy(v16) { -var v17 any +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("next")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) if v19.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } v20 := v19.Get() -v21 := lang.Apply(v20, []any{v11}) -if lang.IsTruthy(v21) { -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("to-array")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v11}) -v26 := lang.Apply(lang1.NewPersistentArrayMapAsIfByAssoc, []any{v25}) -v17 = v26 -} else { -var v27 any -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("seq")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{v11}) -if lang.IsTruthy(v31) { -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("first")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v11}) -v27 = v35 -} else { -v27 = nil -} -v17 = v27 -} -v12 = v17 -} else { -v12 = v11 +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -var v11 any = v12 -_ = v11 -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("get")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v11, lang.NewKeyword("cause")}) -var v36 any = v40 -_ = v36 -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("get")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v44 := v43.Get() -v45 := lang.Apply(v44, []any{v11, lang.NewKeyword("data")}) -var v41 any = v45 -_ = v41 -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("get")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/not")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -v49 := v48.Get() -v50 := lang.Apply(v49, []any{v11, lang.NewKeyword("via")}) -var v46 any = v50 -_ = v46 -v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("get")) -if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v3}) +v35 := lang.Apply(v26, []any{v30, v34}) +v36 := lang.Apply(v23, []any{v35}) +v37 := lang.Apply(v20, []any{v36}) +v38 := lang.Apply(v9, []any{v13, v17, v37}) +v39 := lang.Apply(v6, []any{v38}) +return v39 +}) +v2 := v1 +_ = v2 } -v54 := v53.Get() -v55 := lang.Apply(v54, []any{v11, lang.NewKeyword("trace")}) -var v51 any = v55 -_ = v51 -var v57 lang.FnFunc -v57 = lang.NewFnFunc(func(args ...any) any { +v0 := lang.NewSymbol("bit-not").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Bitwise complement", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1291), lang.NewKeyword("end-line"), int(1291))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v58 := args[0] -v59 := lang.Apply(lang1.WriteWriter, []any{v4, "{:type "}) -_ = v59 -v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v61 := v60.FindInternedVar(lang.NewSymbol("print-method")) -if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "not") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("not is not a function"))) } -v62 := v61.Get() -v63 := lang.Apply(lang.NewKeyword("type"), []any{v58}) -v64 := lang.Apply(v62, []any{v63, v4}) -_ = v64 -v65 := lang.Apply(lang1.WriteWriter, []any{v4, "\n :message "}) -_ = v65 -v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v67 := v66.FindInternedVar(lang.NewSymbol("print-method")) -if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v68 := v67.Get() -v69 := lang.Apply(lang.NewKeyword("message"), []any{v58}) -v70 := lang.Apply(v68, []any{v69, v4}) -_ = v70 -v72 := lang.Apply(lang.NewKeyword("data"), []any{v58}) -var v71 any = v72 -_ = v71 -var v74 any -if lang.IsTruthy(v71) { -var v75 any = v71 -_ = v75 -v77 := lang.Apply(lang1.WriteWriter, []any{v4, "\n :data "}) -_ = v77 -v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v79 := v78.FindInternedVar(lang.NewSymbol("print-method")) -if v79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) } -v80 := v79.Get() -v81 := lang.Apply(v80, []any{v75, v4}) -v74 = v81 -} else { -v74 = nil -} -_ = v74 -v72 := lang.Apply(lang.NewKeyword("at"), []any{v58}) -var v71 any = v72 -_ = v71 -var v74 any -if lang.IsTruthy(v71) { -var v75 any = v71 -_ = v75 -v77 := lang.Apply(lang1.WriteWriter, []any{v4, "\n :at "}) -_ = v77 -v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v79 := v78.FindInternedVar(lang.NewSymbol("print-method")) -if v79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) +// bit-or +{ +var v1 lang.FnFunc +v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v2 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v80 := v79.Get() -v81 := lang.Apply(lang.NewKeyword("at"), []any{v58}) -v82 := lang.Apply(v80, []any{v81, v4}) -v74 = v82 +v7 := v6.Get() +if lang.IsTruthy(v7) { +v4 = closed9 } else { -v74 = nil +v4 = v3 } -_ = v74 -v71 := lang.Apply(lang1.WriteWriter, []any{v4, "}"}) -return v71 -}) -v58 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(481), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(491), lang.NewKeyword("end-column"), int(73)) -v59, err := lang.WithMeta(v57, v58.(lang.IPersistentMap)) -if err != nil { - panic(err) +var v3 any = v4 +_ = v3 +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("seq")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -var v56 any = v59 -_ = v56 -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("print-method")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("concat")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } -v63 := v62.Get() -v64 := lang.Apply(v63, []any{v36, v4}) -_ = v64 -var v65 any -if lang.IsTruthy(v41) { -v66 := lang.Apply(lang1.WriteWriter, []any{v4, "\n :data "}) -_ = v66 -v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v68 := v67.FindInternedVar(lang.NewSymbol("print-method")) -if v68.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } -v69 := v68.Get() -v70 := lang.Apply(v69, []any{v41, v4}) -v65 = v70 -} else { -v65 = nil +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -_ = v65 -var v71 any -if lang.IsTruthy(v46) { -v72 := lang.Apply(lang1.WriteWriter, []any{v4, "\n :via\n ["}) -_ = v72 -v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v75 := v74.FindInternedVar(lang.NewSymbol("first")) -if v75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) +v21 := v20.Get() +v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v76 := v75.Get() -v77 := lang.Apply(v76, []any{v46}) -var v73 any = v77 -_ = v73 -var v79 any -if lang.IsTruthy(v73) { -var v80 any = v73 -_ = v80 -v82 := lang.Apply(v56, []any{v80}) -_ = v82 -v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v85 := v84.FindInternedVar(lang.NewSymbol("seq")) -if v85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("seq")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) } -v86 := v85.Get() -v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v88 := v87.FindInternedVar(lang.NewSymbol("rest")) -if v88.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("concat")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) } -v89 := v88.Get() -v90 := lang.Apply(v89, []any{v46}) -v91 := lang.Apply(v86, []any{v90}) -var v83 any = v91 -_ = v83 -var v92 any = nil -_ = v92 -var v93 any = int64(0) -_ = v93 -var v94 any = int64(0) -_ = v94 -var v95 any -for { -var v96 any -v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v98 := v97.FindInternedVar(lang.NewSymbol("<")) -if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) +v31 := v30.Get() +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) } -v99 := v98.Get() -v100 := lang.Apply(v99, []any{v94, v93}) -if lang.IsTruthy(v100) { -v102, _ := lang.FieldOrMethod(v92, "nth") -if reflect.TypeOf(v102).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) } -v103 := lang.Apply(v102, []any{v94}) -var v101 any = v103 -_ = v101 -v105 := lang.Apply(lang1.WriteWriter, []any{v4, "\n "}) -_ = v105 -v106 := lang.Apply(v56, []any{v101}) -_ = v106 -var v107 any = v83 -var v108 any = v92 -var v109 any = v93 -v111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v112 := v111.FindInternedVar(lang.NewSymbol("unchecked-inc")) -if v112.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v112))) +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v2}) +v40 := lang.Apply(v31, []any{v35, v39}) +v41 := lang.Apply(v28, []any{v40}) +v42 := lang.Apply(v25, []any{v41}) +v43 := lang.Apply(v14, []any{v18, v22, v42}) +v44 := lang.Apply(v11, []any{v43}) +return v44 + case 2: +v2 := args[0] +v3 := args[1] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v113 := v112.Get() -v114 := lang.Apply(v113, []any{v94}) -var v110 any = v114 -v83 = v107 -v92 = v108 -v93 = v109 -v94 = v110 -continue +v8 := v7.Get() +if lang.IsTruthy(v8) { +v5 = closed9 } else { -v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v103 := v102.FindInternedVar(lang.NewSymbol("seq")) -if v103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) -} -v104 := v103.Get() -v105 := lang.Apply(v104, []any{v83}) -var v101 any = v105 -_ = v101 -var v107 any -if lang.IsTruthy(v101) { -var v108 any = v101 -_ = v108 -var v110 any -v111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v112 := v111.FindInternedVar(lang.NewSymbol("chunked-seq?")) -if v112.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v112))) +v5 = v4 } -v113 := v112.Get() -v114 := lang.Apply(v113, []any{v108}) -if lang.IsTruthy(v114) { -v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v117 := v116.FindInternedVar(lang.NewSymbol("chunk-first")) -if v117.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) +var v4 any = v5 +_ = v4 +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("seq")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v118 := v117.Get() -v119 := lang.Apply(v118, []any{v108}) -var v115 any = v119 -_ = v115 -v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v123 := v122.FindInternedVar(lang.NewSymbol("chunk-rest")) -if v123.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("concat")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } -v124 := v123.Get() -v125 := lang.Apply(v124, []any{v108}) -var v121 any = v125 -var v126 any = v115 -v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v129 := v128.FindInternedVar(lang.NewSymbol("int")) -if v129.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v129))) +v15 := v14.Get() +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("list")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -v130 := v129.Get() -v131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v132 := v131.FindInternedVar(lang.NewSymbol("count")) -if v132.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v132))) +v18 := v17.Get() +v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("list")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v133 := v132.Get() -v134 := lang.Apply(v133, []any{v115}) -v135 := lang.Apply(v130, []any{v134}) -var v127 any = v135 -v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v138 := v137.FindInternedVar(lang.NewSymbol("int")) -if v138.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) +v22 := v21.Get() +v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("list")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -v139 := v138.Get() -v140 := lang.Apply(v139, []any{int64(0)}) -var v136 any = v140 -v83 = v121 -v92 = v126 -v93 = v127 -v94 = v136 -continue -} else { -v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v117 := v116.FindInternedVar(lang.NewSymbol("first")) -if v117.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("seq")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v118 := v117.Get() -v119 := lang.Apply(v118, []any{v108}) -var v115 any = v119 -_ = v115 -v121 := lang.Apply(lang1.WriteWriter, []any{v4, "\n "}) -_ = v121 -v122 := lang.Apply(v56, []any{v115}) -_ = v122 -v124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v125 := v124.FindInternedVar(lang.NewSymbol("next")) -if v125.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v125))) +v29 := v28.Get() +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("concat")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) } -v126 := v125.Get() -v127 := lang.Apply(v126, []any{v108}) -var v123 any = v127 -var v128 any = nil -var v129 any = int64(0) -var v130 any = int64(0) -v83 = v123 -v92 = v128 -v93 = v129 -v94 = v130 -continue +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("list")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) } -v107 = v110 -} else { -v107 = nil +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v4}) +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("list")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -v96 = v107 +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v2}) +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("list")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } -v95 = v96 - break +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v3}) +v45 := lang.Apply(v32, []any{v36, v40, v44}) +v46 := lang.Apply(v29, []any{v45}) +v47 := lang.Apply(v26, []any{v46}) +v48 := lang.Apply(v15, []any{v19, v23, v47}) +v49 := lang.Apply(v12, []any{v48}) +return v49 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v2 := args[0] +v3 := args[1] +v4 := lang.NewList(args[2:]...) +var v6 any +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v79 = v95 +v9 := v8.Get() +if lang.IsTruthy(v9) { +v6 = closed9 } else { -v79 = nil +v6 = v5 } -_ = v79 -v73 := lang.Apply(lang1.WriteWriter, []any{v4, "]"}) -v71 = v73 -} else { -v71 = nil +var v5 any = v6 +_ = v5 +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -_ = v71 -var v74 any -if lang.IsTruthy(v51) { -v75 := lang.Apply(lang1.WriteWriter, []any{v4, "\n :trace\n ["}) -_ = v75 -v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v78 := v77.FindInternedVar(lang.NewSymbol("first")) -if v78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) +v13 := v12.Get() +var v14 lang.FnFunc +v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v15 := args[0] +v16 := args[1] +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v79 := v78.Get() -v80 := lang.Apply(v79, []any{v51}) -var v76 any = v80 -_ = v76 -var v82 any -if lang.IsTruthy(v76) { -var v83 any = v76 -_ = v83 -v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v86 := v85.FindInternedVar(lang.NewSymbol("print-method")) -if v86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v87 := v86.Get() -v88 := lang.Apply(v87, []any{v83, v4}) -_ = v88 -v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v91 := v90.FindInternedVar(lang.NewSymbol("seq")) -if v91.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v92 := v91.Get() -v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v94 := v93.FindInternedVar(lang.NewSymbol("rest")) -if v94.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v95 := v94.Get() -v96 := lang.Apply(v95, []any{v51}) -v97 := lang.Apply(v92, []any{v96}) -var v89 any = v97 -_ = v89 -var v98 any = nil -_ = v98 -var v99 any = int64(0) -_ = v99 -var v100 any = int64(0) -_ = v100 -var v101 any -for { -var v102 any -v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v104 := v103.FindInternedVar(lang.NewSymbol("<")) -if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -v105 := v104.Get() -v106 := lang.Apply(v105, []any{v100, v99}) -if lang.IsTruthy(v106) { -v108, _ := lang.FieldOrMethod(v98, "nth") -if reflect.TypeOf(v108).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } -v109 := lang.Apply(v108, []any{v100}) -var v107 any = v109 -_ = v107 -v111 := lang.Apply(lang1.WriteWriter, []any{v4, "\n "}) -_ = v111 -v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v113 := v112.FindInternedVar(lang.NewSymbol("print-method")) -if v113.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -v114 := v113.Get() -v115 := lang.Apply(v114, []any{v107, v4}) -_ = v115 -var v116 any = v89 -var v117 any = v98 -var v118 any = v99 -v120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v121 := v120.FindInternedVar(lang.NewSymbol("unchecked-inc")) -if v121.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v121))) -} -v122 := v121.Get() -v123 := lang.Apply(v122, []any{v100}) -var v119 any = v123 -v89 = v116 -v98 = v117 -v99 = v118 -v100 = v119 -continue -} else { -v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v109 := v108.FindInternedVar(lang.NewSymbol("seq")) -if v109.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) -} -v110 := v109.Get() -v111 := lang.Apply(v110, []any{v89}) -var v107 any = v111 -_ = v107 -var v113 any -if lang.IsTruthy(v107) { -var v114 any = v107 -_ = v114 -var v116 any -v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v118 := v117.FindInternedVar(lang.NewSymbol("chunked-seq?")) -if v118.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) -} -v119 := v118.Get() -v120 := lang.Apply(v119, []any{v114}) -if lang.IsTruthy(v120) { -v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v123 := v122.FindInternedVar(lang.NewSymbol("chunk-first")) -if v123.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) } -v124 := v123.Get() -v125 := lang.Apply(v124, []any{v114}) -var v121 any = v125 -_ = v121 -v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v129 := v128.FindInternedVar(lang.NewSymbol("chunk-rest")) -if v129.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v129))) +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v5}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } -v130 := v129.Get() -v131 := lang.Apply(v130, []any{v114}) -var v127 any = v131 -var v132 any = v121 -v134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v135 := v134.FindInternedVar(lang.NewSymbol("int")) -if v135.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v135))) +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v15}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) } -v136 := v135.Get() -v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v138 := v137.FindInternedVar(lang.NewSymbol("count")) -if v138.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v16}) +v52 := lang.Apply(v39, []any{v43, v47, v51}) +v53 := lang.Apply(v36, []any{v52}) +v54 := lang.Apply(v33, []any{v53}) +v55 := lang.Apply(v22, []any{v26, v30, v54}) +v56 := lang.Apply(v19, []any{v55}) +return v56 +}) +v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) +v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v139 := v138.Get() -v140 := lang.Apply(v139, []any{v121}) -v141 := lang.Apply(v136, []any{v140}) -var v133 any = v141 -v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v144 := v143.FindInternedVar(lang.NewSymbol("int")) -if v144.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v145 := v144.Get() -v146 := lang.Apply(v145, []any{int64(0)}) -var v142 any = v146 -v89 = v127 -v98 = v132 -v99 = v133 -v100 = v142 -continue -} else { -v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v123 := v122.FindInternedVar(lang.NewSymbol("first")) -if v123.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v124 := v123.Get() -v125 := lang.Apply(v124, []any{v114}) -var v121 any = v125 -_ = v121 -v127 := lang.Apply(lang1.WriteWriter, []any{v4, "\n "}) -_ = v127 -v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v129 := v128.FindInternedVar(lang.NewSymbol("print-method")) -if v129.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v129))) +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v130 := v129.Get() -v131 := lang.Apply(v130, []any{v121, v4}) -_ = v131 -v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v134 := v133.FindInternedVar(lang.NewSymbol("next")) -if v134.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v135 := v134.Get() -v136 := lang.Apply(v135, []any{v114}) -var v132 any = v136 -var v137 any = nil -var v138 any = int64(0) -var v139 any = int64(0) -v89 = v132 -v98 = v137 -v99 = v138 -v100 = v139 -continue +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -v113 = v116 -} else { -v113 = nil +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } -v102 = v113 +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -v101 = v102 - break +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) } -v82 = v101 -} else { -v82 = nil +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v5}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } -_ = v82 -v76 := lang.Apply(lang1.WriteWriter, []any{v4, "]"}) -v74 = v76 -} else { -v74 = nil +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v2}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) } -_ = v74 -v6 := lang.Apply(lang1.WriteWriter, []any{v4, "}"}) -return v6 +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v3}) +v52 := lang.Apply(v39, []any{v43, v47, v51}) +v53 := lang.Apply(v36, []any{v52}) +v54 := lang.Apply(v33, []any{v53}) +v55 := lang.Apply(v22, []any{v26, v30, v54}) +v56 := lang.Apply(v19, []any{v55}) +v57 := lang.Apply(v13, []any{v16, v56, v4}) +return v57 + } }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// read-string -{ -v0 := lang.NewSymbol("read-string").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s")), lang.NewVector(lang.NewSymbol("opts"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Reads one object from the string s. Optionally include reader\n options, as specified in read.\n\n Note that read-string can execute code (controlled by *read-eval*),\n and as such should be used only with trusted sources.\n\n For data structure interop use glojure.edn/read-string", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3806), lang.NewKeyword("end-line"), int(3806))).(*lang.Symbol) +v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -v4 := lang.Apply(runtime3.RTReadString, []any{v3}) -return v4 - case 2: + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] -v4 := args[1] -v5 := lang.Apply(runtime3.RTReadString, []any{v4, v3}) +v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) +} +v5 := lang.Apply(v4, []any{v3, int64(1)}) return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v0 := lang.NewSymbol("bit-or").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Bitwise or", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1307), lang.NewKeyword("end-line"), int(1307))).(*lang.Symbol) +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v5 := args[0] +v6 := args[1] +v7, _ := lang.FieldOrMethod(lang1.Numbers, "or") +if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("or is not a function"))) +} +v8 := lang.Apply(v7, []any{v5, v6}) +return v8 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +v6 := args[1] +v7 := lang.NewList(args[2:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("bit-or")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("bit-or")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v5, v6}) +v18 := lang.Apply(v10, []any{v13, v17, v7}) +return v18 } }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) +v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v3 := ns.InternWithValue(v0, v4, true) if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + v3.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// identity +// bit-set { -v0 := lang.NewSymbol("identity").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns its argument.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1446), lang.NewKeyword("end-line"), int(1446))).(*lang.Symbol) +v0 := lang.NewSymbol("bit-set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Set bit at index n", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1342), lang.NewKeyword("end-line"), int(1342))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { + if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -return v3 +v4 := args[1] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "setBit") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setBit is not a function"))) +} +v6 := lang.Apply(v5, []any{v3, v4}) +return v6 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -14428,1350 +13807,1676 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// split-at +// bit-shift-left { -v0 := lang.NewSymbol("split-at").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a vector of [(take n coll) (drop n coll)]", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2983), lang.NewKeyword("end-line"), int(2983))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { +var v1 lang.FnFunc +{ // function bit-shift-left__inliner +v1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] v4 := args[1] v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("take")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq")) if v6.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3, v4}) -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("drop")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("concat")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v3, v4}) -v13 := lang.NewVector(v8, v12) -v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2988), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2988), lang.NewKeyword("end-column"), int(33)) -v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) -if err != nil { - panic(err) +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("list")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -return v15 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v13 := v12.Get() +v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -// first -{ -v0 := lang.NewSymbol("first").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns the first item in the collection. Calls seq on its\n argument. If coll is nil, returns nil.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(47), lang.NewKeyword("end-line"), int(52))).(*lang.Symbol) -var v2 lang.FnFunc -{ // function first -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("seq")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("concat")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("list")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/shiftLeft")}) +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v4}) +v40 := lang.Apply(v27, []any{v31, v35, v39}) +v41 := lang.Apply(v24, []any{v40}) +v42 := lang.Apply(v21, []any{v41}) +v43 := lang.Apply(v10, []any{v14, v18, v42}) +v44 := lang.Apply(v7, []any{v43}) +return v44 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("bit-shift-left").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Bitwise shift left", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1361), lang.NewKeyword("end-line"), int(1361))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5 := lang.Apply(lang1.First, []any{v4}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(52), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(52), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) -v3 := v2 -_ = v3 +v5 := args[1] +v6, _ := lang.FieldOrMethod(lang1.Numbers, "shiftLeft") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("shiftLeft is not a function"))) } -v1 := ns.InternWithValue(v0, v2, true) +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// qualified-symbol? +// bit-shift-right { -v0 := lang.NewSymbol("qualified-symbol?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a symbol with a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1628), lang.NewKeyword("end-line"), int(1628))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { +var v1 lang.FnFunc +{ // function bit-shift-right__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("boolean")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v6 := v5.Get() +v7 := v6.Get() v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("symbol?")) +v9 := v8.FindInternedVar(lang.NewSymbol("concat")) if v9.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } v10 := v9.Get() -v11 := lang.Apply(v10, []any{v3}) -var v7 any = v11 -_ = v7 -var v13 any -if lang.IsTruthy(v7) { +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("list")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("namespace")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) if v16.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } v17 := v16.Get() -v18 := lang.Apply(v17, []any{v3}) -var v14 any = v18 -_ = v14 -var v20 any -if lang.IsTruthy(v14) { -v20 = true -} else { -v20 = v14 +v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v13 = v20 -} else { -v13 = v7 +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("seq")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -v7 := lang.Apply(v6, []any{v13}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("concat")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("list")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } -// var? -{ -v0 := lang.NewSymbol("var?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("v"))), lang.NewKeyword("doc"), "Returns true if v is of type glojure.lang.Var", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4999), lang.NewKeyword("end-line"), int(4999))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { +v30 := v29.Get() +v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/shiftRight")}) +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v4}) +v40 := lang.Apply(v27, []any{v31, v35, v39}) +v41 := lang.Apply(v24, []any{v40}) +v42 := lang.Apply(v21, []any{v41}) +v43 := lang.Apply(v10, []any{v14, v18, v42}) +v44 := lang.Apply(v7, []any{v43}) +return v44 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("bit-shift-right").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Bitwise shift right", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1367), lang.NewKeyword("end-line"), int(1367))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v4 := args[0] +v5 := args[1] +v6, _ := lang.FieldOrMethod(lang1.Numbers, "shiftRight") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("shiftRight is not a function"))) } -v6 := v5.Get() -v7 := lang.Apply(v6, []any{lang1.*Var, v3}) +v7 := lang.Apply(v6, []any{v4, v5}) return v7 }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// if-some +// bit-test { -v0 := lang.NewSymbol("if-some").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("then")), lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("then"), lang.NewSymbol("else"), lang.NewSymbol("&"), lang.NewSymbol("oldform"))), lang.NewKeyword("doc"), "bindings => binding-form test\n\n If test is not nil, evaluates then with binding-form bound to the\n value of test, if not, yields else", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1874), lang.NewKeyword("end-line"), int(1874))).(*lang.Symbol) +v0 := lang.NewSymbol("bit-test").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Test bit at index n", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1354), lang.NewKeyword("end-line"), int(1354))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 4: + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("seq")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v5, _ := lang.FieldOrMethod(lang1.Numbers, "testBit") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("testBit is not a function"))) } -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("concat")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v6 := lang.Apply(v5, []any{v3, v4}) +return v6 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("list")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } -v15 := v14.Get() -v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/if-some")}) -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("list")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +// bit-xor +{ +var v1 lang.FnFunc +v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v2 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v5}) -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("list")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +v7 := v6.Get() +if lang.IsTruthy(v7) { +v4 = closed10 +} else { +v4 = v3 } -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v6}) -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("list")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +var v3 any = v4 +_ = v3 +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("seq")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -v27 := v26.Get() -v28 := lang.Apply(v27, []any{nil}) -v29 := lang.Apply(v12, []any{v16, v20, v24, v28}) -v30 := lang.Apply(v9, []any{v29}) -return v30 - default: - if len(args) < 5 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := args[4] -v8 := lang.NewList(args[5:]...) -var v9 any -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("vector?")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("concat")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } -v12 := v11.Get() -v13 := lang.Apply(v12, []any{v5}) -if lang.IsTruthy(v13) { -v9 = nil -} else { -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("str")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } -v16 := v15.Get() -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("first")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v3}) -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("*ns*")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +v21 := v20.Get() +v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("meta")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("seq")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) } -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v3}) -v28 := lang.Apply(lang.NewKeyword("line"), []any{v27}) -v29 := lang.Apply(v16, []any{v20, " requires ", "a vector for its binding", " in ", v23, ":", v28}) -v30 := lang.Apply(lang1.NewIllegalArgumentError, []any{v29}) -panic(v30) +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("concat")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) } -_ = v9 -var v31 any +v31 := v30.Get() v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("nil?")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) if v33.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) } v34 := v33.Get() -v35 := lang.Apply(v34, []any{v8}) -if lang.IsTruthy(v35) { -v31 = nil -} else { +v35 := lang.Apply(v34, []any{v3}) v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("str")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) if v37.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) } v38 := v37.Get() -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("first")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) -} -v41 := v40.Get() -v42 := lang.Apply(v41, []any{v3}) -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("*ns*")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +v39 := lang.Apply(v38, []any{v2}) +v40 := lang.Apply(v31, []any{v35, v39}) +v41 := lang.Apply(v28, []any{v40}) +v42 := lang.Apply(v25, []any{v41}) +v43 := lang.Apply(v14, []any{v18, v22, v42}) +v44 := lang.Apply(v11, []any{v43}) +return v44 + case 2: +v2 := args[0] +v3 := args[1] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v45 := v44.Get() -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("meta")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +v8 := v7.Get() +if lang.IsTruthy(v8) { +v5 = closed10 +} else { +v5 = v4 } -v48 := v47.Get() -v49 := lang.Apply(v48, []any{v3}) -v50 := lang.Apply(lang.NewKeyword("line"), []any{v49}) -v51 := lang.Apply(v38, []any{v42, " requires ", "1 or 2 forms after binding vector", " in ", v45, ":", v50}) -v52 := lang.Apply(lang1.NewIllegalArgumentError, []any{v51}) -panic(v52) +var v4 any = v5 +_ = v4 +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("seq")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -_ = v31 -var v53 any -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("=")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("concat")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } -v56 := v55.Get() -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("count")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +v15 := v14.Get() +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("list")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -v59 := v58.Get() -v60 := lang.Apply(v59, []any{v5}) -v61 := lang.Apply(v56, []any{int64(2), v60}) -if lang.IsTruthy(v61) { -v53 = nil -} else { -v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v63 := v62.FindInternedVar(lang.NewSymbol("str")) -if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +v18 := v17.Get() +v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("list")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v64 := v63.Get() -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("first")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +v22 := v21.Get() +v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("list")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -v67 := v66.Get() -v68 := lang.Apply(v67, []any{v3}) -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("*ns*")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("seq")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v71 := v70.Get() -v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v73 := v72.FindInternedVar(lang.NewSymbol("meta")) -if v73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) +v29 := v28.Get() +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("concat")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) } -v74 := v73.Get() -v75 := lang.Apply(v74, []any{v3}) -v76 := lang.Apply(lang.NewKeyword("line"), []any{v75}) -v77 := lang.Apply(v64, []any{v68, " requires ", "exactly 2 forms in binding vector", " in ", v71, ":", v76}) -v78 := lang.Apply(lang1.NewIllegalArgumentError, []any{v77}) -panic(v78) +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("list")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) } -_ = v53 -_ = nil -v80 := lang.Apply(v5, []any{int64(0)}) -var v79 any = v80 -_ = v79 -v82 := lang.Apply(v5, []any{int64(1)}) -var v81 any = v82 -_ = v81 -v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v85 := v84.FindInternedVar(lang.NewSymbol("seq")) -if v85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v4}) +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("list")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -v86 := v85.Get() -v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v88 := v87.FindInternedVar(lang.NewSymbol("concat")) -if v88.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v2}) +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("list")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } -v89 := v88.Get() -v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v91 := v90.FindInternedVar(lang.NewSymbol("list")) -if v91.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v3}) +v45 := lang.Apply(v32, []any{v36, v40, v44}) +v46 := lang.Apply(v29, []any{v45}) +v47 := lang.Apply(v26, []any{v46}) +v48 := lang.Apply(v15, []any{v19, v23, v47}) +v49 := lang.Apply(v12, []any{v48}) +return v49 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v2 := args[0] +v3 := args[1] +v4 := lang.NewList(args[2:]...) +var v6 any +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v92 := v91.Get() -v93 := lang.Apply(v92, []any{lang.NewSymbol("glojure.core/let")}) -v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v95 := v94.FindInternedVar(lang.NewSymbol("list")) -if v95.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) +v9 := v8.Get() +if lang.IsTruthy(v9) { +v6 = closed10 +} else { +v6 = v5 } -v96 := v95.Get() -v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v98 := v97.FindInternedVar(lang.NewSymbol("apply")) -if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) +var v5 any = v6 +_ = v5 +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v99 := v98.Get() -v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v101 := v100.FindInternedVar(lang.NewSymbol("vector")) -if v101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) +v13 := v12.Get() +var v14 lang.FnFunc +v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v15 := args[0] +v16 := args[1] +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v102 := v101.Get() -v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v104 := v103.FindInternedVar(lang.NewSymbol("seq")) -if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v105 := v104.Get() -v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v107 := v106.FindInternedVar(lang.NewSymbol("concat")) -if v107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v108 := v107.Get() -v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v110 := v109.FindInternedVar(lang.NewSymbol("list")) -if v110.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v111 := v110.Get() -v112 := lang.Apply(v111, []any{lang.NewSymbol("temp__0__auto__")}) -v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v114 := v113.FindInternedVar(lang.NewSymbol("list")) -if v114.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -v115 := v114.Get() -v116 := lang.Apply(v115, []any{v81}) -v117 := lang.Apply(v108, []any{v112, v116}) -v118 := lang.Apply(v105, []any{v117}) -v119 := lang.Apply(v99, []any{v102, v118}) -v120 := lang.Apply(v96, []any{v119}) -v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v122 := v121.FindInternedVar(lang.NewSymbol("list")) -if v122.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } -v123 := v122.Get() -v124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v125 := v124.FindInternedVar(lang.NewSymbol("seq")) -if v125.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v125))) +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -v126 := v125.Get() -v127 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v128 := v127.FindInternedVar(lang.NewSymbol("concat")) -if v128.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v128))) -} -v129 := v128.Get() -v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v131 := v130.FindInternedVar(lang.NewSymbol("list")) -if v131.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) } -v132 := v131.Get() -v133 := lang.Apply(v132, []any{lang.NewSymbol("if")}) -v134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v135 := v134.FindInternedVar(lang.NewSymbol("list")) -if v135.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v135))) +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v5}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } -v136 := v135.Get() -v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v138 := v137.FindInternedVar(lang.NewSymbol("seq")) -if v138.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v15}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) } -v139 := v138.Get() -v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v141 := v140.FindInternedVar(lang.NewSymbol("concat")) -if v141.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v16}) +v52 := lang.Apply(v39, []any{v43, v47, v51}) +v53 := lang.Apply(v36, []any{v52}) +v54 := lang.Apply(v33, []any{v53}) +v55 := lang.Apply(v22, []any{v26, v30, v54}) +v56 := lang.Apply(v19, []any{v55}) +return v56 +}) +v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) +v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v142 := v141.Get() -v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v144 := v143.FindInternedVar(lang.NewSymbol("list")) -if v144.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v145 := v144.Get() -v146 := lang.Apply(v145, []any{lang.NewSymbol("glojure.core/nil?")}) -v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v148 := v147.FindInternedVar(lang.NewSymbol("list")) -if v148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v149 := v148.Get() -v150 := lang.Apply(v149, []any{lang.NewSymbol("temp__0__auto__")}) -v151 := lang.Apply(v142, []any{v146, v150}) -v152 := lang.Apply(v139, []any{v151}) -v153 := lang.Apply(v136, []any{v152}) -v154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v155 := v154.FindInternedVar(lang.NewSymbol("list")) -if v155.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v155))) +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v156 := v155.Get() -v157 := lang.Apply(v156, []any{v7}) -v158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v159 := v158.FindInternedVar(lang.NewSymbol("list")) -if v159.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v159))) +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v160 := v159.Get() -v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v162 := v161.FindInternedVar(lang.NewSymbol("seq")) -if v162.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -v163 := v162.Get() -v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v165 := v164.FindInternedVar(lang.NewSymbol("concat")) -if v165.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } -v166 := v165.Get() -v167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v168 := v167.FindInternedVar(lang.NewSymbol("list")) -if v168.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v168))) +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -v169 := v168.Get() -v170 := lang.Apply(v169, []any{lang.NewSymbol("glojure.core/let")}) -v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v172 := v171.FindInternedVar(lang.NewSymbol("list")) -if v172.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) } -v173 := v172.Get() -v174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v175 := v174.FindInternedVar(lang.NewSymbol("apply")) -if v175.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v175))) +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v5}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } -v176 := v175.Get() -v177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v178 := v177.FindInternedVar(lang.NewSymbol("vector")) -if v178.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v178))) +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v2}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) } -v179 := v178.Get() -v180 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v181 := v180.FindInternedVar(lang.NewSymbol("seq")) -if v181.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v181))) +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v3}) +v52 := lang.Apply(v39, []any{v43, v47, v51}) +v53 := lang.Apply(v36, []any{v52}) +v54 := lang.Apply(v33, []any{v53}) +v55 := lang.Apply(v22, []any{v26, v30, v54}) +v56 := lang.Apply(v19, []any{v55}) +v57 := lang.Apply(v13, []any{v16, v56, v4}) +return v57 + } +}) +v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } -v182 := v181.Get() -v183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v184 := v183.FindInternedVar(lang.NewSymbol("concat")) -if v184.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v184))) +v5 := lang.Apply(v4, []any{v3, int64(1)}) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v0 := lang.NewSymbol("bit-xor").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Bitwise exclusive or", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1316), lang.NewKeyword("end-line"), int(1316))).(*lang.Symbol) +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v5 := args[0] +v6 := args[1] +v7, _ := lang.FieldOrMethod(lang1.Numbers, "xor") +if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("xor is not a function"))) } -v185 := v184.Get() -v186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v187 := v186.FindInternedVar(lang.NewSymbol("list")) -if v187.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v187))) +v8 := lang.Apply(v7, []any{v5, v6}) +return v8 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +v6 := args[1] +v7 := lang.NewList(args[2:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v188 := v187.Get() -v189 := lang.Apply(v188, []any{v79}) -v190 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v191 := v190.FindInternedVar(lang.NewSymbol("list")) -if v191.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v191))) +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("bit-xor")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v192 := v191.Get() -v193 := lang.Apply(v192, []any{lang.NewSymbol("temp__0__auto__")}) -v194 := lang.Apply(v185, []any{v189, v193}) -v195 := lang.Apply(v182, []any{v194}) -v196 := lang.Apply(v176, []any{v179, v195}) -v197 := lang.Apply(v173, []any{v196}) -v198 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v199 := v198.FindInternedVar(lang.NewSymbol("list")) -if v199.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v199))) +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("bit-xor")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v200 := v199.Get() -v201 := lang.Apply(v200, []any{v6}) -v202 := lang.Apply(v166, []any{v170, v197, v201}) -v203 := lang.Apply(v163, []any{v202}) -v204 := lang.Apply(v160, []any{v203}) -v205 := lang.Apply(v129, []any{v133, v153, v157, v204}) -v206 := lang.Apply(v126, []any{v205}) -v207 := lang.Apply(v123, []any{v206}) -v208 := lang.Apply(v89, []any{v93, v120, v207}) -v209 := lang.Apply(v86, []any{v208}) -return v209 +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v5, v6}) +v18 := lang.Apply(v10, []any{v13, v17, v7}) +return v18 } }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) +v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v3 := ns.InternWithValue(v0, v4, true) if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + v3.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// hash-unordered-coll +// boolean { -v0 := lang.NewSymbol("hash-unordered-coll").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns the hash code, consistent with =, for an external unordered\n collection implementing Iterable. For maps, the iterator should\n return map entries whose hash is computed as\n (hash-ordered-coll [k v]).\n See http://glojure.org/data_structures#hash for full algorithms.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5219), lang.NewKeyword("end-line"), int(5219))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { +var v1 lang.FnFunc +{ // function boolean__inliner +v1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := lang.Apply(nil, []any{v3}) -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -// load-data-readers -{ -v0 := lang.NewSymbol("load-data-readers").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7908), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7908), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v4 := v3.FindInternedVar(lang.NewSymbol("alter-var-root")) -if v4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v5 := v4.Get() -v6 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*data-readers*")) -var v7 lang.FnFunc -v7 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v8 := args[0] -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("reduce")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("load-data-reader-file")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("data-reader-urls")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v17 := v16.Get() -v18 := lang.Apply(v17, nil) -v19 := lang.Apply(v11, []any{v14, v8, v18}) -return v19 -}) -v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7910), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(7912), lang.NewKeyword("end-column"), int(57)) -v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) -if err != nil { - panic(err) +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -v10 := lang.Apply(v5, []any{v6, v9}) -return v10 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/BooleanCast")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v3}) +v35 := lang.Apply(v26, []any{v30, v34}) +v36 := lang.Apply(v23, []any{v35}) +v37 := lang.Apply(v20, []any{v36}) +v38 := lang.Apply(v9, []any{v13, v17, v37}) +v39 := lang.Apply(v6, []any{v38}) +return v39 +}) +v2 := v1 +_ = v2 } -// rest -{ -v1 := reflect.TypeOf((*lang1.ISeq)(nil)).Elem() -v0 := lang.NewSymbol("rest").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a possibly empty seq of the items after the first. Calls seq on its\n argument.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(64), lang.NewKeyword("end-line"), int(70))).(*lang.Symbol) +v0 := lang.NewSymbol("boolean").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to boolean", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1601), lang.NewKeyword("end-line"), int(1601))).(*lang.Symbol) var v3 lang.FnFunc -{ // function rest v3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v5 := args[0] -v6 := lang.Apply(lang1.Rest, []any{v5}) +v4 := args[0] +v5, _ := lang.FieldOrMethod(runtime9.RT, "BooleanCast") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("BooleanCast is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) return v6 }) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(70), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(70), lang.NewKeyword("end-column"), int(77))).(lang.FnFunc) -v4 := v3 -_ = v4 -} +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// PrintWriter-on +// boolean-array { -v1 := reflect.TypeOf((*bytes18.Buffer)(nil)) -v0 := lang.NewSymbol("PrintWriter-on").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("flush-fn"), lang.NewSymbol("close-fn")), lang.NewVector(lang.NewSymbol("flush-fn"), lang.NewSymbol("close-fn"), lang.NewSymbol("autoflush?"))), lang.NewKeyword("doc"), "implements java.io.PrintWriter given flush-fn, which will be called\n when .flush() is called, with a string built up since the last call to .flush().\n if not nil, close-fn will be called with no arguments when .close is called.\n autoflush? determines if the PrintWriter will autoflush, false by default.", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(73), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(522), lang.NewKeyword("end-line"), int(522))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { +var v1 lang.FnFunc +{ // function boolean-array__inliner +v1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 2: -v4 := args[0] -v5 := args[1] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("PrintWriter-on")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v4, v5, false}) -return v9 - case 3: -v4 := args[0] -v5 := args[1] -v6 := args[2] -v8 := lang.Apply(StringBuilder19., nil) -var v7 any = v8 -_ = v7 -v10 := lang.NewVector(nil) -v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(532), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(532), lang.NewKeyword("end-column"), int(23)) -v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) -if err != nil { - panic(err) + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.NewList(args[0:]...) +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v13 := lang.NewVector() -v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(532), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(532), lang.NewKeyword("end-column"), int(26)) -v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) -if err != nil { - panic(err) +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("flush")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v18 := v17.Get() -v19 := lang.NewVector() -v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(533), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(533), lang.NewKeyword("end-column"), int(19)) -v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) -if err != nil { - panic(err) +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -var v22 any -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("pos?")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v25 := v24.Get() -v26, ok := lang.FieldOrMethod(v7, "length") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "length"))) +v20 := v19.Get() +v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/booleanArray")}) +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("list")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -var v27 any -switch reflect.TypeOf(v26).Kind() { -case reflect.Func: - v27 = lang.Apply(v26, nil) -default: - v27 = v26 +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("seq")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -v28 := lang.Apply(v25, []any{v27}) -if lang.IsTruthy(v28) { -v29 := lang.Apply(lang1.ToString, []any{v7}) -v30 := lang.Apply(v4, []any{v29}) -v22 = v30 -} else { -v22 = nil +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("concat")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } -v31, _ := lang.FieldOrMethod(v7, "setLength") -if reflect.TypeOf(v31).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setLength is not a function"))) +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -v32 := lang.Apply(v31, []any{int64(0)}) -v33 := lang.Apply(v18, []any{v21, v22, v32}) -v34 := lang.NewVector() -v35 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(537), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(537), lang.NewKeyword("end-column"), int(19)) -v36, err := lang.WithMeta(v34, v35.(lang.IPersistentMap)) -if err != nil { - panic(err) +v33 := v32.Get() +v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("list")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) } -v37, ok := lang.FieldOrMethod(nil, "flush") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "flush"))) +v37 := v36.Get() +v38 := lang.Apply(v37, []any{lang.NewSymbol("glojure.core/args")}) +v39 := lang.Apply(v30, []any{v34, v38}) +v40 := lang.Apply(v27, []any{v39}) +v41 := lang.Apply(v24, []any{v40}) +v42 := lang.Apply(v9, []any{v13, v17, v21, v41}) +v43 := lang.Apply(v6, []any{v42}) +return v43 + } +}) +v2 := v1 +_ = v2 } -var v38 any -switch reflect.TypeOf(v37).Kind() { -case reflect.Func: - v38 = lang.Apply(v37, nil) -default: - v38 = v37 +v0 := lang.NewSymbol("boolean-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Creates an array of booleans", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)int64(2)), lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5309), lang.NewKeyword("end-line"), int(5309))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "booleanArray") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("booleanArray is not a function"))) } -var v39 any -if lang.IsTruthy(v5) { -v40 := lang.Apply(v5, nil) -v39 = v40 -} else { -v39 = nil +v6 := lang.Apply(v5, []any{v4}) +return v6 + case 2: +v4 := args[0] +v5 := args[1] +v6, _ := lang.FieldOrMethod(lang1.Numbers, "booleanArrayInit") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("booleanArrayInit is not a function"))) } -v41 := lang.Apply(nil, []any{v36, v38, v39, nil}) -v42 := lang.NewVector(nil, nil, nil) -v43 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(541), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(541), lang.NewKeyword("end-column"), int(35)) -v44, err := lang.WithMeta(v42, v43.(lang.IPersistentMap)) -if err != nil { - panic(err) +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } -var v45 any -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("pos?")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) } -v48 := v47.Get() -v49 := lang.Apply(v48, []any{nil}) -if lang.IsTruthy(v49) { -var v50 any -v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v52 := v51.FindInternedVar(lang.NewSymbol("instance?")) -if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) +// boolean? +{ +v0 := lang.NewSymbol("boolean?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a Boolean", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(518), lang.NewKeyword("end-line"), int(518))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v53 := v52.Get() -v54 := lang.Apply(v53, []any{lang.Builtins["string"], nil}) -if lang.IsTruthy(v54) { -v55 := lang.Apply(lang1.AppendWriter, []any{v7, nil, nil, nil}) -v50 = v55 -} else { -v56 := lang.Apply(lang1.AppendWriter, []any{v7, nil, nil, nil}) -v50 = v56 +v6 := v5.Get() +v7 := lang.Apply(v6, []any{lang.Builtins["bool"], v3}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v45 = v50 -} else { -v45 = nil } -v57 := lang.Apply(nil, []any{v44, v45}) -v58 := lang.Apply(nil, []any{v12, v15, v33, v41, v57}) -v59 := lang.Apply(java.io.BufferedWriter21., []any{v58}) -v60 := lang.Apply(java.io.PrintWriter20., []any{v59, v6}) -return v60 - default: +// booleans +{ +var v1 lang.FnFunc +{ // function booleans +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/booleans")}) +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("list")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v3}) +v26 := lang.Apply(v9, []any{v13, v17, v21, v25}) +v27 := lang.Apply(v6, []any{v26}) +return v27 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("booleans").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Casts to boolean[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5372), lang.NewKeyword("end-line"), int(5372))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "booleans") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("booleans is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 }) -v4 := reflect.TypeOf((*bytes18.Buffer)(nil)) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// * +// bound-fn { -var v1 lang.FnFunc -v1 = lang.NewFnFunc(func(args ...any) any { +v0 := lang.NewSymbol("bound-fn").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("fntail"))), lang.NewKeyword("doc"), "Returns a function defined by the given fntail, which will install the\n same bindings in effect as in the thread at the time bound-fn was called.\n This may be used to define a helper function which runs on a different\n thread, but needs the same bindings in place.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(2004), lang.NewKeyword("end-line"), int(2004))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 1: -v2 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -if lang.IsTruthy(v7) { -v4 = closed3 -} else { -v4 = v3 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("seq")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -var v3 any = v4 -_ = v3 +v8 := v7.Get() v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("seq")) +v10 := v9.FindInternedVar(lang.NewSymbol("concat")) if v10.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } v11 := v10.Get() v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("concat")) +v13 := v12.FindInternedVar(lang.NewSymbol("list")) if v13.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +v15 := lang.Apply(v14, []any{lang.NewSymbol("glojure.core/bound-fn*")}) +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("list")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) +v18 := v17.Get() v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) +v20 := v19.FindInternedVar(lang.NewSymbol("seq")) if v20.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } v21 := v20.Get() -v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("concat")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("seq")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("list")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("concat")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +v27 := v26.Get() +v28 := lang.Apply(v27, []any{lang.NewSymbol("glojure.core/fn")}) +v29 := lang.Apply(v24, []any{v28, v5}) +v30 := lang.Apply(v21, []any{v29}) +v31 := lang.Apply(v18, []any{v30}) +v32 := lang.Apply(v11, []any{v15, v31}) +v33 := lang.Apply(v8, []any{v32}) +return v33 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) } -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +// bound-fn* +{ +v0 := lang.NewSymbol("bound-fn*").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Returns a function, which will install the same bindings in effect as in\n the thread at the time bound-fn* was called and then call f with any given\n arguments. This may be used to define a helper function which runs on a\n different thread, but needs the same bindings in place.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1992), lang.NewKeyword("end-line"), int(1992))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("get-thread-bindings")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v2}) -v40 := lang.Apply(v31, []any{v35, v39}) -v41 := lang.Apply(v28, []any{v40}) -v42 := lang.Apply(v25, []any{v41}) -v43 := lang.Apply(v14, []any{v18, v22, v42}) -v44 := lang.Apply(v11, []any{v43}) -return v44 - case 2: -v2 := args[0] -v3 := args[1] +v7 := v6.Get() +v8 := lang.Apply(v7, nil) +var v4 any = v8 +_ = v4 +var v10 lang.FnFunc +v10 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v11 := lang.NewList(args[0:]...) +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("apply")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("with-bindings*")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v14, []any{v17, v4, v3, v11}) +return v18 + } +}) +v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2001), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2002), lang.NewKeyword("end-column"), int(45)) +v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v12 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// bound? +{ +v0 := lang.NewSymbol("bound?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("vars"))), lang.NewKeyword("doc"), "Returns true if all of the vars provided as arguments have any bound value, root or thread-local.\n Implies that deref'ing the provided vars will succeed. Returns true if no vars are provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5534), lang.NewKeyword("end-line"), int(5534))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.NewList(args[0:]...) +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("every?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +var v7 lang.FnFunc +v7 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v8 := args[0] +v9, ok := lang.FieldOrMethod(v8, "isBound") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "isBound"))) +} +var v10 any +switch reflect.TypeOf(v9).Kind() { +case reflect.Func: + v10 = lang.Apply(v9, nil) +default: + v10 = v9 +} +return v10 +}) +v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5540), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5540), lang.NewKeyword("end-column"), int(69)) +v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v10 := lang.Apply(v6, []any{v9, v3}) +return v10 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// bounded-count +{ +v0 := lang.NewSymbol("bounded-count").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "If coll is counted? returns its count, else will count at most the first n\n elements of coll using its seq", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7453), lang.NewKeyword("end-line"), int(7453))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] var v5 any v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +v7 := v6.FindInternedVar(lang.NewSymbol("counted?")) if v7.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } v8 := v7.Get() -if lang.IsTruthy(v8) { -v5 = closed3 -} else { -v5 = v4 -} -var v4 any = v5 -_ = v4 +v9 := lang.Apply(v8, []any{v4}) +if lang.IsTruthy(v9) { v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("seq")) +v11 := v10.FindInternedVar(lang.NewSymbol("count")) if v11.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("concat")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() +v13 := lang.Apply(v12, []any{v4}) +v5 = v13 +} else { +var v14 any = int64(0) +_ = v14 v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("list")) +v17 := v16.FindInternedVar(lang.NewSymbol("seq")) if v17.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } v18 := v17.Get() -v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("list")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +v19 := lang.Apply(v18, []any{v4}) +var v15 any = v19 +_ = v15 +var v20 any +for { +var v21 any +var v22 any = v15 +_ = v22 +var v24 any +if lang.IsTruthy(v22) { +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("<")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -v22 := v21.Get() -v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("list")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +v27 := v26.Get() +v28 := lang.Apply(v27, []any{v14, v3}) +v24 = v28 +} else { +v24 = v22 } -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("seq")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +if lang.IsTruthy(v24) { +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("inc")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v29 := v28.Get() -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("concat")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("list")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +v25 := v24.Get() +v26 := lang.Apply(v25, []any{v14}) +var v22 any = v26 +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("next")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v4}) -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("list")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +v30 := v29.Get() +v31 := lang.Apply(v30, []any{v15}) +var v27 any = v31 +v14 = v22 +v15 = v27 +continue +} else { +v21 = v14 } -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v2}) -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("list")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +v20 = v21 + break } -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v3}) -v45 := lang.Apply(v32, []any{v36, v40, v44}) -v46 := lang.Apply(v29, []any{v45}) -v47 := lang.Apply(v26, []any{v46}) -v48 := lang.Apply(v15, []any{v19, v23, v47}) -v49 := lang.Apply(v12, []any{v48}) -return v49 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v2 := args[0] -v3 := args[1] -v4 := lang.NewList(args[2:]...) -var v6 any -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v5 = v20 } -v9 := v8.Get() -if lang.IsTruthy(v9) { -v6 = closed3 -} else { -v6 = v5 +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -var v5 any = v6 -_ = v5 -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v13 := v12.Get() -var v14 lang.FnFunc -v14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { +// butlast +{ +v0 := lang.NewSymbol("butlast").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return a seq of all but the last item in coll, in linear time", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(272), lang.NewKeyword("end-line"), int(276))).(*lang.Symbol) +var v2 lang.FnFunc +{ // function butlast +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v15 := args[0] -v16 := args[1] +v4 := args[0] +v6 := lang.NewVector() +v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(277), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(277), lang.NewKeyword("end-column"), int(24)) +v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v5 any = v8 +_ = v5 +var v9 any = v9 +_ = v9 +var v10 any +for { +var v11 any +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("next")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v9}) +if lang.IsTruthy(v15) { v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +v18 := v17.FindInternedVar(lang.NewSymbol("conj")) if v18.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } v19 := v18.Get() v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +v21 := v20.FindInternedVar(lang.NewSymbol("first")) if v21.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +v23 := lang.Apply(v22, []any{v9}) +v24 := lang.Apply(v19, []any{v5, v23}) +var v16 any = v24 +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("next")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) } -v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v28 := v27.Get() +v29 := lang.Apply(v28, []any{v9}) +var v25 any = v29 +v5 = v16 +v9 = v25 +continue +} else { +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("seq")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) } -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v32 := v31.Get() +v33 := lang.Apply(v32, []any{v5}) +v11 = v33 } -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +v10 = v11 + break } -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +return v10 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(276), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(280), lang.NewKeyword("end-column"), int(27))).(lang.FnFunc) +v3 := v2 +_ = v3 } -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v5}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v15}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +// byte +{ +var v1 lang.FnFunc +{ // function byte__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v16}) -v52 := lang.Apply(v39, []any{v43, v47, v51}) -v53 := lang.Apply(v36, []any{v52}) -v54 := lang.Apply(v33, []any{v53}) -v55 := lang.Apply(v22, []any{v26, v30, v54}) -v56 := lang.Apply(v19, []any{v55}) -return v56 -}) -v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) -v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) -if err != nil { - panic(err) +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("concat")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v28 := v27.FindInternedVar(lang.NewSymbol("list")) if v28.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +var v30 any v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) +v32 := v31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) if v32.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v5}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +if lang.IsTruthy(v33) { +v30 = lang.NewSymbol("uncheckedByteCast") +} else { +v30 = lang.NewSymbol("byteCast") } -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v2}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +v34 := lang.Apply(v29, []any{v30}) +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("list")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) } -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v3}) -v52 := lang.Apply(v39, []any{v43, v47, v51}) -v53 := lang.Apply(v36, []any{v52}) -v54 := lang.Apply(v33, []any{v53}) -v55 := lang.Apply(v22, []any{v26, v30, v54}) -v56 := lang.Apply(v19, []any{v55}) -v57 := lang.Apply(v13, []any{v16, v56, v4}) -return v57 - } +v37 := v36.Get() +v38 := lang.Apply(v37, []any{v3}) +v39 := lang.Apply(v26, []any{v34, v38}) +v40 := lang.Apply(v23, []any{v39}) +v41 := lang.Apply(v20, []any{v40}) +v42 := lang.Apply(v9, []any{v13, v17, v41}) +v43 := lang.Apply(v6, []any{v42}) +return v43 }) -v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("byte").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to byte", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3505), lang.NewKeyword("end-line"), int(3505))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := args[0] -v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) -} -v5 := lang.Apply(v4, []any{v3, int64(1)}) +v4 := args[0] +v5 := lang.Apply(lang1.ByteCast, []any{v4}) return v5 }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v0 := lang.NewSymbol("*").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the product of nums. (*) returns 1. Does not auto-promote\n longs, will throw on overflow. See also: *'", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1001), lang.NewKeyword("end-line"), int(1001))).(*lang.Symbol) -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -return int64(1) - case 1: -v5 := args[0] -v6 := lang.Apply(lang1.MustAsNumber, []any{v5}) -return v6 - case 2: -v5 := args[0] -v6 := args[1] -v7, _ := lang.FieldOrMethod(lang1.Numbers, "multiply") -if reflect.TypeOf(v7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("multiply is not a function"))) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v8 := lang.Apply(v7, []any{v5, v6}) -return v8 +} +// byte-array +{ +var v1 lang.FnFunc +{ // function byte-array__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { default: - if len(args) < 2 { + if len(args) < 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v5 := args[0] -v6 := args[1] -v7 := lang.NewList(args[2:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v3 := lang.NewList(args[0:]...) +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("*")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v13 := v12.Get() +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("*")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) if v15.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } v16 := v15.Get() -v17 := lang.Apply(v16, []any{v5, v6}) -v18 := lang.Apply(v10, []any{v13, v17, v7}) -return v18 +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/byteArray")}) +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("list")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("seq")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("concat")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("list")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v37, []any{lang.NewSymbol("glojure.core/args")}) +v39 := lang.Apply(v30, []any{v34, v38}) +v40 := lang.Apply(v27, []any{v39}) +v41 := lang.Apply(v24, []any{v40}) +v42 := lang.Apply(v9, []any{v13, v17, v21, v41}) +v43 := lang.Apply(v6, []any{v42}) +return v43 } }) -v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v3 := ns.InternWithValue(v0, v4, true) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("byte-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Creates an array of bytes", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)int64(2)), lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5317), lang.NewKeyword("end-line"), int(5317))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "byteArray") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("byteArray is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 + case 2: +v4 := args[0] +v5 := args[1] +v6, _ := lang.FieldOrMethod(lang1.Numbers, "byteArrayInit") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("byteArrayInit is not a function"))) +} +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { - v3.SetMeta(v0.Meta().(lang.IPersistentMap)) + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// map-indexed +// bytes { -v0 := lang.NewSymbol("map-indexed").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence consisting of the result of applying f to 0\n and the first item of coll, followed by applying f to 1 and the second\n item in coll, etc, until coll is exhausted. Thus function f should\n accept 2 arguments, index and item. Returns a stateful transducer when\n no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7352), lang.NewKeyword("end-line"), int(7352))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { +var v1 lang.FnFunc +{ // function bytes +v1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v5 := args[0] -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("volatile!")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} v9 := v8.Get() -v10 := lang.Apply(v9, []any{int64(-1)}) -var v6 any = v10 -_ = v6 -var v12 lang.FnFunc -v12 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v13 := lang.Apply(v5, nil) -return v13 - case 1: -v13 := args[0] -v14 := lang.Apply(v5, []any{v13}) -return v14 - case 2: -v13 := args[0] -v14 := args[1] -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("inc")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v17 := v16.Get() -v18, ok := lang.FieldOrMethod(v6, "Deref") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "Deref"))) +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -var v19 any -switch reflect.TypeOf(v18).Kind() { -case reflect.Func: - v19 = lang.Apply(v18, nil) -default: - v19 = v18 +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v20 := lang.Apply(v17, []any{v19}) -v21, _ := lang.FieldOrMethod(v6, "reset") -if reflect.TypeOf(v21).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) +v20 := v19.Get() +v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/bytes")}) +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("list")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -v22 := lang.Apply(v21, []any{v20}) -v23 := lang.Apply(v3, []any{v22, v14}) -v24 := lang.Apply(v5, []any{v13, v23}) -return v24 - default: +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v3}) +v26 := lang.Apply(v9, []any{v13, v17, v21, v25}) +v27 := lang.Apply(v6, []any{v26}) +return v27 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("bytes").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Casts to bytes[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5377), lang.NewKeyword("end-line"), int(5377))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -}) -v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7363), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7367), lang.NewKeyword("end-column"), int(48)) -v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) -if err != nil { - panic(err) +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "bytes") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("bytes is not a function"))) } -return v14 +v6 := lang.Apply(v5, []any{v4}) +return v6 }) -v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7361), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7367), lang.NewKeyword("end-column"), int(50)) -v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) -if err != nil { - panic(err) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } -return v6 - case 2: -v3 := args[0] -v4 := args[1] -return nil - default: +} +// bytes? +{ +v0 := lang.NewSymbol("bytes?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a byte array", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5412), lang.NewKeyword("end-line"), int(5412))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } +v3 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("nil?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +if lang.IsTruthy(v8) { +v4 = false +} else { +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("=")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("class")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v3}) +v16, ok := lang.FieldOrMethod(v15, "getComponentType") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v15, "getComponentType"))) +} +var v17 any +switch reflect.TypeOf(v16).Kind() { +case reflect.Func: + v17 = lang.Apply(v16, nil) +default: + v17 = v16 +} +v18 := lang.Apply(v11, []any{v17, nil}) +v4 = v18 +} +return v4 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -15779,1228 +15484,1140 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// mapcat +// case { -v0 := lang.NewSymbol("mapcat").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Returns the result of applying concat to the result of applying map\n to f and colls. Thus function f should return a collection. Returns\n a transducer when no collections are provided", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2775), lang.NewKeyword("end-line"), int(2775))).(*lang.Symbol) +v0 := lang.NewSymbol("case").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("e"), lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes an expression, and a set of clauses.\n\n Each clause can take the form of either:\n\n test-constant result-expr\n\n (test-constant1 ... test-constantN) result-expr\n\n The test-constants are not evaluated. They must be compile-time\n literals, and need not be quoted. If the expression is equal to a\n test-constant, the corresponding result-expr is returned. A single\n default expression can follow the clauses, and its value will be\n returned if no clause matches. If no default expression is provided\n and no clause matches, an IllegalArgumentException is thrown.\n\n Unlike cond and condp, case does a constant-time dispatch, the\n clauses are not considered sequentially. All manner of constant\n expressions are acceptable in case, including numbers, strings,\n symbols, keywords, and (Clojure) composites thereof. Note that since\n lists are used to group multiple constants that map to the same\n expression, a vector can be used to match a list if needed. The\n test-constants need not be all of the same type.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6755), lang.NewKeyword("end-line"), int(6755))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 1: -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("comp")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("map")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v3}) -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("cat")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v6, []any{v10, v13}) -return v14 default: - if len(args) < 1 { + if len(args) < 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := lang.NewList(args[1:]...) -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("apply")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("concat")) +v9 := v8.FindInternedVar(lang.NewSymbol("with-meta")) if v9.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } v10 := v9.Get() v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("apply")) +v12 := v11.FindInternedVar(lang.NewSymbol("gensym")) if v12.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("map")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v13, []any{v16, v3, v4}) -v18 := lang.Apply(v7, []any{v10, v17}) -return v18 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// sigs -{ -v0 := lang.NewSymbol("sigs").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(223), lang.NewKeyword("column"), int(2), lang.NewKeyword("end-line"), int(224), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("assert-valid-fdecl")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v14 := lang.Apply(v13, nil) +v15 := lang.NewMap(lang.NewKeyword("tag"), lang1.Object) +v16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6781), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(6781), lang.NewKeyword("end-column"), int(84)) +v17, err := lang.WithMeta(v15, v16.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v6 := v5.Get() -v7 := lang.Apply(v6, []any{v3}) +v18 := lang.Apply(v10, []any{v14, v17}) +var v7 any = v18 _ = v7 -var v9 lang.FnFunc -v9 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v10 := args[0] -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("first")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +var v20 any +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("odd?")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v10}) -var v11 any = v15 -_ = v11 -var v17 any -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("first")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("count")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -v20 := v19.Get() -v21 := lang.Apply(v20, []any{v16}) -v22 := lang.Apply(lang1.Equals, []any{lang.NewSymbol("&form"), v21}) -if lang.IsTruthy(v22) { -v23 := lang.Apply(lang1.Count, []any{v16}) -v24 := lang.Apply(lang1.Subvec, []any{v16, int64(2), v23}) -v17 = v24 -} else { -v17 = v16 +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v6}) +v28 := lang.Apply(v23, []any{v27}) +if lang.IsTruthy(v28) { +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("last")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) } -var v16 any = v17 -_ = v16 -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("next")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +v31 := v30.Get() +v32 := lang.Apply(v31, []any{v6}) +v20 = v32 +} else { +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("seq")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) } -v28 := v27.Get() -v29 := lang.Apply(v28, []any{v10}) -var v25 any = v29 -_ = v25 -var v31 any -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("map?")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +v35 := v34.Get() +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("concat")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) } -v34 := v33.Get() -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("first")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +v38 := v37.Get() +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("list")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) } -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v25}) -v39 := lang.Apply(v34, []any{v38}) -if lang.IsTruthy(v39) { -var v40 any -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("next")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +v41 := v40.Get() +v42 := lang.Apply(v41, []any{lang.NewSymbol("throw")}) +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("list")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) } -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v25}) -if lang.IsTruthy(v44) { -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("with-meta")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +v45 := v44.Get() +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("seq")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) } -v47 := v46.Get() -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("conj")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +v48 := v47.Get() +v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v50 := v49.FindInternedVar(lang.NewSymbol("concat")) +if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) } -v50 := v49.Get() -var v51 any +v51 := v50.Get() v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("meta")) +v53 := v52.FindInternedVar(lang.NewSymbol("list")) if v53.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) } v54 := v53.Get() -v55 := lang.Apply(v54, []any{v16}) -if lang.IsTruthy(v55) { +v55 := lang.Apply(v54, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewIllegalArgumentError")}) v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v57 := v56.FindInternedVar(lang.NewSymbol("meta")) +v57 := v56.FindInternedVar(lang.NewSymbol("list")) if v57.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) } v58 := v57.Get() -v59 := lang.Apply(v58, []any{v16}) -v51 = v59 -} else { -v60 := lang.NewMap() -v61 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(237), lang.NewKeyword("column"), int(77), lang.NewKeyword("end-line"), int(237), lang.NewKeyword("end-column"), int(78)) -v62, err := lang.WithMeta(v60, v61.(lang.IPersistentMap)) -if err != nil { - panic(err) +v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v60 := v59.FindInternedVar(lang.NewSymbol("seq")) +if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) } -v51 = v62 +v61 := v60.Get() +v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v63 := v62.FindInternedVar(lang.NewSymbol("concat")) +if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) } -v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v64 := v63.FindInternedVar(lang.NewSymbol("first")) -if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) +v64 := v63.Get() +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("list")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) } -v65 := v64.Get() -v66 := lang.Apply(v65, []any{v25}) -v67 := lang.Apply(v50, []any{v51, v66}) -v68 := lang.Apply(v47, []any{v16, v67}) -v40 = v68 -} else { -v40 = v16 +v67 := v66.Get() +v68 := lang.Apply(v67, []any{lang.NewSymbol("glojure.core/str")}) +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("list")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) } -v31 = v40 -} else { -v31 = v16 +v71 := v70.Get() +v72 := lang.Apply(v71, []any{"No matching clause: "}) +v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v74 := v73.FindInternedVar(lang.NewSymbol("list")) +if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) } -return v31 -}) -v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(228), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(239), lang.NewKeyword("end-column"), int(25)) -v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) -if err != nil { - panic(err) +v75 := v74.Get() +v76 := lang.Apply(v75, []any{v7}) +v77 := lang.Apply(v64, []any{v68, v72, v76}) +v78 := lang.Apply(v61, []any{v77}) +v79 := lang.Apply(v58, []any{v78}) +v80 := lang.Apply(v51, []any{v55, v79}) +v81 := lang.Apply(v48, []any{v80}) +v82 := lang.Apply(v45, []any{v81}) +v83 := lang.Apply(v38, []any{v42, v82}) +v84 := lang.Apply(v35, []any{v83}) +v20 = v84 } -var v8 any = v11 -_ = v8 -var v13 lang.FnFunc -v13 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v14 := args[0] -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("meta")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +var v19 any = v20 +_ = v19 +var v86 any +v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v88 := v87.FindInternedVar(lang.NewSymbol(">")) +if v88.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) } -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v14}) -var v15 any = v19 -_ = v15 -v21 := lang.Apply(lang.NewKeyword("tag"), []any{v15}) -var v20 any = v21 -_ = v20 -var v23 any -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("instance?")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +v89 := v88.Get() +v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v91 := v90.FindInternedVar(lang.NewSymbol("count")) +if v91.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) } -v26 := v25.Get() -v27 := lang.Apply(v26, []any{lang1.*Symbol, v20}) -if lang.IsTruthy(v27) { -var v28 any -v29, ok := lang.FieldOrMethod(v20, "Name") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v20, "Name"))) +v92 := v91.Get() +v93 := lang.Apply(v92, []any{v6}) +v94 := lang.Apply(v89, []any{int64(2), v93}) +if lang.IsTruthy(v94) { +v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v96 := v95.FindInternedVar(lang.NewSymbol("seq")) +if v96.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) } -var v30 any -switch reflect.TypeOf(v29).Kind() { -case reflect.Func: - v30 = lang.Apply(v29, nil) -default: - v30 = v29 +v97 := v96.Get() +v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v99 := v98.FindInternedVar(lang.NewSymbol("concat")) +if v99.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) } -v31 := lang.Apply(strings22.Index, []any{v30, "."}) -v32 := lang.Apply(lang1.Equiv, []any{v31, int64(-1)}) -if lang.IsTruthy(v32) { -var v33 any -v34 := lang.Apply(lang1.Equals, []any{nil, nil}) -if lang.IsTruthy(v34) { -var v35 any = nil -_ = v35 -var v37 any -if lang.IsTruthy(v35) { -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("with-meta")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("assoc")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44, ok := lang.FieldOrMethod(v35, "Name") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v35, "Name"))) -} -var v45 any -switch reflect.TypeOf(v44).Kind() { -case reflect.Func: - v45 = lang.Apply(v44, nil) -default: - v45 = v44 -} -v46 := lang.Apply(lang1.NewSymbol, []any{v45}) -v47 := lang.Apply(v43, []any{v15, lang.NewKeyword("tag"), v46}) -v48 := lang.Apply(v40, []any{v14, v47}) -v37 = v48 -} else { -v37 = v14 -} -v33 = v37 -} else { -v33 = v14 -} -v28 = v33 -} else { -v28 = v14 +v100 := v99.Get() +v101 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v102 := v101.FindInternedVar(lang.NewSymbol("list")) +if v102.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v102))) } -v23 = v28 -} else { -v23 = v14 +v103 := v102.Get() +v104 := lang.Apply(v103, []any{lang.NewSymbol("glojure.core/let")}) +v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v106 := v105.FindInternedVar(lang.NewSymbol("list")) +if v106.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) } -return v23 -}) -v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(240), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(252), lang.NewKeyword("end-column"), int(37)) -v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) -if err != nil { - panic(err) +v107 := v106.Get() +v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v109 := v108.FindInternedVar(lang.NewSymbol("apply")) +if v109.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) } -var v12 any = v15 -_ = v12 -var v17 any -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("seq?")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v110 := v109.Get() +v111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v112 := v111.FindInternedVar(lang.NewSymbol("vector")) +if v112.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v112))) } -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("first")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +v113 := v112.Get() +v114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v115 := v114.FindInternedVar(lang.NewSymbol("seq")) +if v115.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v115))) } -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v3}) -v25 := lang.Apply(v20, []any{v24}) -if lang.IsTruthy(v25) { -v27 := lang.NewVector() -v28 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(254), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(254), lang.NewKeyword("end-column"), int(20)) -v29, err := lang.WithMeta(v27, v28.(lang.IPersistentMap)) -if err != nil { - panic(err) +v116 := v115.Get() +v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v118 := v117.FindInternedVar(lang.NewSymbol("concat")) +if v118.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) } -var v26 any = v29 -_ = v26 -var v30 any = v3 -_ = v30 -var v31 any -for { -var v32 any -if lang.IsTruthy(v30) { -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("conj")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +v119 := v118.Get() +v120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v121 := v120.FindInternedVar(lang.NewSymbol("list")) +if v121.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v121))) } -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("first")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +v122 := v121.Get() +v123 := lang.Apply(v122, []any{v7}) +v124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v125 := v124.FindInternedVar(lang.NewSymbol("list")) +if v125.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v125))) } -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v30}) -v41 := lang.Apply(v8, []any{v40}) -v42 := lang.Apply(v12, []any{v41}) -v43 := lang.Apply(v36, []any{v26, v42}) -var v33 any = v43 -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("next")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +v126 := v125.Get() +v127 := lang.Apply(v126, []any{v5}) +v128 := lang.Apply(v119, []any{v123, v127}) +v129 := lang.Apply(v116, []any{v128}) +v130 := lang.Apply(v110, []any{v113, v129}) +v131 := lang.Apply(v107, []any{v130}) +v132 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v133 := v132.FindInternedVar(lang.NewSymbol("list")) +if v133.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v133))) } -v47 := v46.Get() -v48 := lang.Apply(v47, []any{v30}) -var v44 any = v48 -v26 = v33 -v30 = v44 -continue +v134 := v133.Get() +v135 := lang.Apply(v134, []any{v19}) +v136 := lang.Apply(v100, []any{v104, v131, v135}) +v137 := lang.Apply(v97, []any{v136}) +v86 = v137 } else { -v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v50 := v49.FindInternedVar(lang.NewSymbol("seq")) -if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) +v139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v140 := v139.FindInternedVar(lang.NewSymbol("partition")) +if v140.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v140))) } -v51 := v50.Get() -v52 := lang.Apply(v51, []any{v26}) -v32 = v52 +v141 := v140.Get() +v142 := lang.Apply(v141, []any{int64(2), v6}) +var v138 any = v142 +_ = v138 +var v144 lang.FnFunc +{ // function assoc-test +v144 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v146 := args[0] +v147 := args[1] +v148 := args[2] +var v149 any +v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v151 := v150.FindInternedVar(lang.NewSymbol("contains?")) +if v151.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) } -v31 = v32 - break +v152 := v151.Get() +v153 := lang.Apply(v152, []any{v146, v147}) +if lang.IsTruthy(v153) { +v154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v155 := v154.FindInternedVar(lang.NewSymbol("str")) +if v155.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v155))) } -v17 = v31 +v156 := v155.Get() +v157 := lang.Apply(v156, []any{"Duplicate case test constant: ", v147}) +v158 := lang.Apply(lang1.NewIllegalArgumentError, []any{v157}) +panic(v158) } else { -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("list")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +v159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v160 := v159.FindInternedVar(lang.NewSymbol("assoc")) +if v160.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v160))) } -v28 := v27.Get() -v29 := lang.Apply(v8, []any{v3}) -v30 := lang.Apply(v12, []any{v29}) -v31 := lang.Apply(v28, []any{v30}) -v17 = v31 +v161 := v160.Get() +v162 := lang.Apply(v161, []any{v146, v147, v148}) +v149 = v162 } -return v17 +return v149 }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(225), lang.NewKeyword("column"), int(2), lang.NewKeyword("end-line"), int(258), lang.NewKeyword("end-column"), int(43))).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} +v145 := v144 +_ = v145 } -// chunk-buffer -{ -v0 := lang.NewSymbol("chunk-buffer").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(685), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(685), lang.NewKeyword("end-column"), int(53), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("capacity"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.Apply(lang1.NewChunkBuffer, []any{v3}) -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v145 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6788), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(6791), lang.NewKeyword("end-column"), int(48)) +v146, err := lang.WithMeta(v144, v145.(lang.IPersistentMap)) +if err != nil { + panic(err) } +var v143 any = v146 +_ = v143 +v148 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v149 := v148.FindInternedVar(lang.NewSymbol("reduce1")) +if v149.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v149))) } -// contains? -{ -v0 := lang.NewSymbol("contains?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("key"))), lang.NewKeyword("doc"), "Returns true if key is present in the given collection, otherwise\n returns false. Note that for numerically indexed collections like\n vectors and Java arrays, this tests if the numeric key is within the\n range of indexes. 'contains?' operates constant or logarithmic time;\n it will not perform a linear search for a value. See also 'some'.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1479), lang.NewKeyword("end-line"), int(1479))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { +v150 := v149.Get() +var v151 lang.FnFunc +v151 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := args[0] -v4 := args[1] -v5, _ := lang.FieldOrMethod(runtime3.RT, "Contains") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Contains is not a function"))) +v152 := args[0] +v153 := args[1] +var v154 any = v153 +_ = v154 +v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v157 := v156.FindInternedVar(lang.NewSymbol("nth")) +if v157.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) } -v6 := lang.Apply(v5, []any{v3, v4}) -return v6 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v158 := v157.Get() +v159 := lang.Apply(v158, []any{v154, int64(0), nil}) +var v155 any = v159 +_ = v155 +v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v162 := v161.FindInternedVar(lang.NewSymbol("nth")) +if v162.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) } +v163 := v162.Get() +v164 := lang.Apply(v163, []any{v154, int64(1), nil}) +var v160 any = v164 +_ = v160 +var v166 any +v167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v168 := v167.FindInternedVar(lang.NewSymbol("seq?")) +if v168.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v168))) } -// thread-bound? -{ -v0 := lang.NewSymbol("thread-bound?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("vars"))), lang.NewKeyword("doc"), "Returns true if all of the vars provided as arguments have thread-local bindings.\n Implies that set!'ing the provided vars will succeed. Returns true if no vars are provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5542), lang.NewKeyword("end-line"), int(5542))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewList(args[0:]...) -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("every?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v169 := v168.Get() +v170 := lang.Apply(v169, []any{v155}) +if lang.IsTruthy(v170) { +v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v172 := v171.FindInternedVar(lang.NewSymbol("reduce1")) +if v172.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) } -v6 := v5.Get() -var v7 lang.FnFunc -v7 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { +v173 := v172.Get() +var v174 lang.FnFunc +v174 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v8 := args[0] -v9, ok := lang.FieldOrMethod(v8, "getThreadBinding") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "getThreadBinding"))) +v175 := args[0] +v176 := args[1] +v177 := lang.Apply(v143, []any{v175, v176, v160}) +return v177 +}) +v175 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6795), lang.NewKeyword("column"), int(37), lang.NewKeyword("end-line"), int(6795), lang.NewKeyword("end-column"), int(60)) +v176, err := lang.WithMeta(v174, v175.(lang.IPersistentMap)) +if err != nil { + panic(err) } -var v10 any -switch reflect.TypeOf(v9).Kind() { -case reflect.Func: - v10 = lang.Apply(v9, nil) -default: - v10 = v9 +v177 := lang.Apply(v173, []any{v176, v152, v155}) +v166 = v177 +} else { +v178 := lang.Apply(v143, []any{v152, v155, v160}) +v166 = v178 } -return v10 +return v166 }) -v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5548), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5548), lang.NewKeyword("end-column"), int(78)) -v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) +v152 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6793), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(6796), lang.NewKeyword("end-column"), int(53)) +v153, err := lang.WithMeta(v151, v152.(lang.IPersistentMap)) if err != nil { panic(err) } -v10 := lang.Apply(v6, []any{v9, v3}) -return v10 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v154 := lang.NewMap() +v155 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6797), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(6797), lang.NewKeyword("end-column"), int(25)) +v156, err := lang.WithMeta(v154, v155.(lang.IPersistentMap)) +if err != nil { + panic(err) } +v157 := lang.Apply(v150, []any{v153, v156, v147}) +var v147 any = v157 +_ = v147 +v159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v160 := v159.FindInternedVar(lang.NewSymbol("keys")) +if v160.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v160))) } -// struct-map -{ -v0 := lang.NewSymbol("struct-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("&"), lang.NewSymbol("inits"))), lang.NewKeyword("doc"), "Returns a new structmap instance with the keys of the\n structure-basis. keyvals may contain all, some or none of the basis\n keys - where values are not supplied they will default to nil.\n keyvals can also contain keys not in the basis.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4051), lang.NewKeyword("end-line"), int(4051))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.NewList(args[1:]...) -v5 := lang.Apply(lang1.CreatePersistentStructMap, []any{v3, v4}) -return v5 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v161 := v160.Get() +v162 := lang.Apply(v161, []any{v147}) +var v158 any = v162 +_ = v158 +v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v165 := v164.FindInternedVar(lang.NewSymbol("vals")) +if v165.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) } +v166 := v165.Get() +v167 := lang.Apply(v166, []any{v147}) +var v163 any = v167 +_ = v163 +var v169 any +v170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v171 := v170.FindInternedVar(lang.NewSymbol("every?")) +if v171.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v171))) } -// distinct? -{ -v1 := reflect.TypeOf(false) -v0 := lang.NewSymbol("distinct?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Returns true if no two of the arguments are =", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5707), lang.NewKeyword("end-line"), int(5707))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v4 := args[0] -return true - case 2: -v4 := args[0] -v5 := args[1] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("not")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +v172 := v171.Get() +var v173 lang.FnFunc +v173 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v174 := args[0] +v176 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v177 := v176.FindInternedVar(lang.NewSymbol("integer?")) +if v177.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v177))) } -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("=")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +v178 := v177.Get() +v179 := lang.Apply(v178, []any{v174}) +var v175 any = v179 +_ = v175 +var v181 any +if lang.IsTruthy(v175) { +v182 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v183 := v182.FindInternedVar(lang.NewSymbol("<=")) +if v183.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v183))) } -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v4, v5}) -v13 := lang.Apply(v8, []any{v12}) -return v13 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6 := lang.NewList(args[2:]...) -var v7 any -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("not=")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v184 := v183.Get() +v185 := lang.Apply(v184, []any{math3.MinInt, v174, math3.MaxInt}) +v181 = v185 +} else { +v181 = v175 } -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v4, v5}) -if lang.IsTruthy(v11) { -v13 := lang.CreatePersistentTreeSet(v4, v5) -v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5716), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(5716), lang.NewKeyword("end-column"), int(20)) -v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) +return v181 +}) +v174 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6801), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(6801), lang.NewKeyword("end-column"), int(77)) +v175, err := lang.WithMeta(v173, v174.(lang.IPersistentMap)) if err != nil { panic(err) } -var v12 any = v15 -_ = v12 -var v16 any = v6 -_ = v16 -var v17 any = v16 -_ = v17 -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("seq")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v17}) -var v18 any = v22 -_ = v18 -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("first")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +v176 := lang.Apply(v172, []any{v175, v158}) +if lang.IsTruthy(v176) { +v169 = lang.NewKeyword("ints") +} else { +var v177 any +v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v179 := v178.FindInternedVar(lang.NewSymbol("every?")) +if v179.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) } -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v18}) -var v23 any = v27 -_ = v23 -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("next")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +v180 := v179.Get() +v181 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v182 := v181.FindInternedVar(lang.NewSymbol("keyword?")) +if v182.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v182))) } -v31 := v30.Get() -v32 := lang.Apply(v31, []any{v28}) -var v28 any = v32 -_ = v28 -var v33 any = v23 -_ = v33 -var v34 any = v28 -_ = v34 -var v35 any = v17 -_ = v35 -var v37 any = v37 -_ = v37 -var v38 any = v38 -_ = v38 -var v39 any -for { -var v40 any = v40 -_ = v40 -var v41 any = v38 -_ = v41 -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("seq")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +v183 := v182.Get() +v184 := lang.Apply(v180, []any{v183, v158}) +if lang.IsTruthy(v184) { +v177 = lang.NewKeyword("identity") +} else { +var v185 any +if lang.IsTruthy(lang.NewKeyword("else")) { +v185 = lang.NewKeyword("hashes") +} else { +v185 = nil } -v45 := v44.Get() -v46 := lang.Apply(v45, []any{v41}) -var v42 any = v46 -_ = v42 -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("first")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +v177 = v185 } -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v42}) -var v47 any = v51 -_ = v47 -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("next")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +v169 = v177 } -v55 := v54.Get() -v56 := lang.Apply(v55, []any{v52}) -var v52 any = v56 -_ = v52 -var v57 any = v47 -_ = v57 -var v58 any = v52 -_ = v58 -var v59 any = v41 -_ = v59 -var v61 any -if lang.IsTruthy(v59) { -var v62 any -v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v64 := v63.FindInternedVar(lang.NewSymbol("contains?")) -if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) +var v168 any = v169 +_ = v168 +v188 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v189 := v188.FindInternedVar(lang.NewSymbol("=")) +if v189.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v189))) } -v65 := v64.Get() -v66 := lang.Apply(v65, []any{v40, v57}) -if lang.IsTruthy(v66) { -v62 = false -} else { -v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v69 := v68.FindInternedVar(lang.NewSymbol("conj")) -if v69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) +v190 := v189.Get() +var v187 any = v190 +_ = v187 +var v191 any = v168 +_ = v191 +var v193 any +v194 := lang.Apply(v187, []any{lang.NewKeyword("ints"), v191}) +if lang.IsTruthy(v194) { +v196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v197 := v196.FindInternedVar(lang.NewSymbol("prep-ints")) +if v197.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v197))) } -v70 := v69.Get() -v71 := lang.Apply(v70, []any{v40, v57}) -var v67 any = v71 -var v72 any = v58 -v37 = v67 -v38 = v72 -continue +v198 := v197.Get() +v199 := lang.Apply(v198, []any{v158, v163}) +var v195 any = v199 +_ = v195 +v201 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v202 := v201.FindInternedVar(lang.NewSymbol("nth")) +if v202.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v202))) } -v61 = v62 -} else { -v61 = true +v203 := v202.Get() +v204 := lang.Apply(v203, []any{v195, int64(0), nil}) +var v200 any = v204 +_ = v200 +v206 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v207 := v206.FindInternedVar(lang.NewSymbol("nth")) +if v207.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v207))) } -v39 = v61 - break +v208 := v207.Get() +v209 := lang.Apply(v208, []any{v195, int64(1), nil}) +var v205 any = v209 +_ = v205 +v211 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v212 := v211.FindInternedVar(lang.NewSymbol("nth")) +if v212.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v212))) } -v7 = v39 -} else { -v7 = false +v213 := v212.Get() +v214 := lang.Apply(v213, []any{v195, int64(2), nil}) +var v210 any = v214 +_ = v210 +v216 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v217 := v216.FindInternedVar(lang.NewSymbol("nth")) +if v217.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v217))) } -return v7 - } -}) -v4 := reflect.TypeOf(false) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +v218 := v217.Get() +v219 := lang.Apply(v218, []any{v195, int64(3), nil}) +var v215 any = v219 +_ = v215 +v221 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v222 := v221.FindInternedVar(lang.NewSymbol("seq")) +if v222.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v222))) } +v223 := v222.Get() +v224 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v225 := v224.FindInternedVar(lang.NewSymbol("concat")) +if v225.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v225))) } -// keep-indexed -{ -v0 := lang.NewSymbol("keep-indexed").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the non-nil results of (f index item). Note,\n this means false return values will be included. f must be free of\n side-effects. Returns a stateful transducer when no collection is\n provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7415), lang.NewKeyword("end-line"), int(7415))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := args[0] -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("volatile!")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v226 := v225.Get() +v227 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v228 := v227.FindInternedVar(lang.NewSymbol("list")) +if v228.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v228))) } -v9 := v8.Get() -v10 := lang.Apply(v9, []any{int64(-1)}) -var v6 any = v10 -_ = v6 -var v12 lang.FnFunc -v12 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v13 := lang.Apply(v5, nil) -return v13 - case 1: -v13 := args[0] -v14 := lang.Apply(v5, []any{v13}) -return v14 - case 2: -v13 := args[0] -v14 := args[1] -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("inc")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +v229 := v228.Get() +v230 := lang.Apply(v229, []any{lang.NewSymbol("glojure.core/let")}) +v231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v232 := v231.FindInternedVar(lang.NewSymbol("list")) +if v232.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v232))) } -v18 := v17.Get() -v19, ok := lang.FieldOrMethod(v6, "Deref") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "Deref"))) +v233 := v232.Get() +v234 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v235 := v234.FindInternedVar(lang.NewSymbol("apply")) +if v235.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v235))) } -var v20 any -switch reflect.TypeOf(v19).Kind() { -case reflect.Func: - v20 = lang.Apply(v19, nil) -default: - v20 = v19 +v236 := v235.Get() +v237 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v238 := v237.FindInternedVar(lang.NewSymbol("vector")) +if v238.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v238))) } -v21 := lang.Apply(v18, []any{v20}) -v22, _ := lang.FieldOrMethod(v6, "reset") -if reflect.TypeOf(v22).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) +v239 := v238.Get() +v240 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v241 := v240.FindInternedVar(lang.NewSymbol("seq")) +if v241.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v241))) } -v23 := lang.Apply(v22, []any{v21}) -var v15 any = v23 -_ = v15 -v25 := lang.Apply(v3, []any{v15, v14}) -var v24 any = v25 -_ = v24 -var v27 any -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("nil?")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +v242 := v241.Get() +v243 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v244 := v243.FindInternedVar(lang.NewSymbol("concat")) +if v244.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v244))) } -v30 := v29.Get() -v31 := lang.Apply(v30, []any{v24}) -if lang.IsTruthy(v31) { -v27 = v13 -} else { -v32 := lang.Apply(v5, []any{v13, v24}) -v27 = v32 +v245 := v244.Get() +v246 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v247 := v246.FindInternedVar(lang.NewSymbol("list")) +if v247.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v247))) } -return v27 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7425), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7433), lang.NewKeyword("end-column"), int(33)) -v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) -if err != nil { - panic(err) +v248 := v247.Get() +v249 := lang.Apply(v248, []any{v7}) +v250 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v251 := v250.FindInternedVar(lang.NewSymbol("list")) +if v251.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v251))) } -return v14 -}) -v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7423), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7433), lang.NewKeyword("end-column"), int(35)) -v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) -if err != nil { - panic(err) +v252 := v251.Get() +v253 := lang.Apply(v252, []any{v5}) +v254 := lang.Apply(v245, []any{v249, v253}) +v255 := lang.Apply(v242, []any{v254}) +v256 := lang.Apply(v236, []any{v239, v255}) +v257 := lang.Apply(v233, []any{v256}) +v258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v259 := v258.FindInternedVar(lang.NewSymbol("list")) +if v259.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v259))) } -return v6 - case 2: -v3 := args[0] -v4 := args[1] -return nil - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v260 := v259.Get() +v261 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v262 := v261.FindInternedVar(lang.NewSymbol("seq")) +if v262.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v262))) } +v263 := v262.Get() +v264 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v265 := v264.FindInternedVar(lang.NewSymbol("concat")) +if v265.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v265))) } -// *print-dup* -{ -v0 := lang.NewSymbol("*print-dup*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "When set to logical true, objects will be printed in a way that preserves\n their type when read in later.\n\n Defaults to false.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, nil, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v266 := v265.Get() +v267 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v268 := v267.FindInternedVar(lang.NewSymbol("list")) +if v268.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v268))) } +v269 := v268.Get() +v270 := lang.Apply(v269, []any{lang.NewSymbol("case*")}) +v271 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v272 := v271.FindInternedVar(lang.NewSymbol("list")) +if v272.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v272))) } -// reduce1 -{ -v0 := lang.NewSymbol("reduce1").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(923), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(924), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("val"), lang.NewSymbol("coll"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v3 := args[0] -v4 := args[1] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("seq")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +v273 := v272.Get() +v274 := lang.Apply(v273, []any{v7}) +v275 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v276 := v275.FindInternedVar(lang.NewSymbol("list")) +if v276.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v276))) } -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v4}) -var v5 any = v9 -_ = v5 -var v11 any -if lang.IsTruthy(v5) { -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("reduce1")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +v277 := v276.Get() +v278 := lang.Apply(v277, []any{v200}) +v279 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v280 := v279.FindInternedVar(lang.NewSymbol("list")) +if v280.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v280))) } -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("first")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +v281 := v280.Get() +v282 := lang.Apply(v281, []any{v205}) +v283 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v284 := v283.FindInternedVar(lang.NewSymbol("list")) +if v284.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v284))) } -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v5}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("next")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v285 := v284.Get() +v286 := lang.Apply(v285, []any{v19}) +v287 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v288 := v287.FindInternedVar(lang.NewSymbol("list")) +if v288.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v288))) } -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v5}) -v23 := lang.Apply(v14, []any{v3, v18, v22}) -v11 = v23 -} else { -v24 := lang.Apply(v3, nil) -v11 = v24 +v289 := v288.Get() +v290 := lang.Apply(v289, []any{v210}) +v291 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v292 := v291.FindInternedVar(lang.NewSymbol("list")) +if v292.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v292))) } -return v11 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -recur_loop_156: -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("seq")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v293 := v292.Get() +v294 := lang.Apply(v293, []any{v215}) +v295 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v296 := v295.FindInternedVar(lang.NewSymbol("list")) +if v296.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v296))) } -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v5}) -var v6 any = v10 -_ = v6 -var v12 any -if lang.IsTruthy(v6) { -var v13 any -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("chunked-seq?")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v297 := v296.Get() +v298 := lang.Apply(v297, []any{lang.NewKeyword("int")}) +v299 := lang.Apply(v266, []any{v270, v274, v278, v282, v286, v290, v294, v298}) +v300 := lang.Apply(v263, []any{v299}) +v301 := lang.Apply(v260, []any{v300}) +v302 := lang.Apply(v226, []any{v230, v257, v301}) +v303 := lang.Apply(v223, []any{v302}) +v193 = v303 +} else { +var v195 any +v196 := lang.Apply(v187, []any{lang.NewKeyword("hashes"), v191}) +if lang.IsTruthy(v196) { +v198 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v199 := v198.FindInternedVar(lang.NewSymbol("prep-hashes")) +if v199.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v199))) } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v6}) -if lang.IsTruthy(v17) { -var v18 any = v3 -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("chunk-first")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +v200 := v199.Get() +v201 := lang.Apply(v200, []any{v7, v19, v158, v163}) +var v197 any = v201 +_ = v197 +v203 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v204 := v203.FindInternedVar(lang.NewSymbol("nth")) +if v204.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v204))) } -v22 := v21.Get() -v23 := lang.Apply(v22, []any{v6}) -v24, _ := lang.FieldOrMethod(v23, "ReduceInit") -if reflect.TypeOf(v24).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) +v205 := v204.Get() +v206 := lang.Apply(v205, []any{v197, int64(0), nil}) +var v202 any = v206 +_ = v202 +v208 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v209 := v208.FindInternedVar(lang.NewSymbol("nth")) +if v209.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v209))) } -v25 := lang.Apply(v24, []any{v3, v4}) -var v19 any = v25 -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("chunk-next")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v210 := v209.Get() +v211 := lang.Apply(v210, []any{v197, int64(1), nil}) +var v207 any = v211 +_ = v207 +v213 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v214 := v213.FindInternedVar(lang.NewSymbol("nth")) +if v214.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v214))) } -v29 := v28.Get() -v30 := lang.Apply(v29, []any{v6}) -var v26 any = v30 -v3 = v18 -v4 = v19 -v5 = v26 -goto recur_loop_156 -} else { -var v31 any = v3 -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("first")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v6}) -v37 := lang.Apply(v3, []any{v4, v36}) -var v32 any = v37 -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("next")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +v215 := v214.Get() +v216 := lang.Apply(v215, []any{v197, int64(2), nil}) +var v212 any = v216 +_ = v212 +v218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v219 := v218.FindInternedVar(lang.NewSymbol("nth")) +if v219.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v219))) } -v41 := v40.Get() -v42 := lang.Apply(v41, []any{v6}) -var v38 any = v42 -v3 = v31 -v4 = v32 -v5 = v38 -goto recur_loop_156 +v220 := v219.Get() +v221 := lang.Apply(v220, []any{v197, int64(3), nil}) +var v217 any = v221 +_ = v217 +v223 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v224 := v223.FindInternedVar(lang.NewSymbol("nth")) +if v224.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v224))) } -v12 = v13 -} else { -v12 = v4 +v225 := v224.Get() +v226 := lang.Apply(v225, []any{v197, int64(4), nil}) +var v222 any = v226 +_ = v222 +v228 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v229 := v228.FindInternedVar(lang.NewSymbol("seq")) +if v229.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v229))) } -return v12 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v230 := v229.Get() +v231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v232 := v231.FindInternedVar(lang.NewSymbol("concat")) +if v232.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v232))) } +v233 := v232.Get() +v234 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v235 := v234.FindInternedVar(lang.NewSymbol("list")) +if v235.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v235))) } -// ensure-reduced -{ -v0 := lang.NewSymbol("ensure-reduced").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "If x is already reduced?, returns it, else returns (reduced x)", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2841), lang.NewKeyword("end-line"), int(2841))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("reduced?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v236 := v235.Get() +v237 := lang.Apply(v236, []any{lang.NewSymbol("glojure.core/let")}) +v238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v239 := v238.FindInternedVar(lang.NewSymbol("list")) +if v239.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v239))) } -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -if lang.IsTruthy(v8) { -v4 = v3 -} else { -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("reduced")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +v240 := v239.Get() +v241 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v242 := v241.FindInternedVar(lang.NewSymbol("apply")) +if v242.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v242))) } -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v3}) -v4 = v12 +v243 := v242.Get() +v244 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v245 := v244.FindInternedVar(lang.NewSymbol("vector")) +if v245.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v245))) } -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v246 := v245.Get() +v247 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v248 := v247.FindInternedVar(lang.NewSymbol("seq")) +if v248.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v248))) } +v249 := v248.Get() +v250 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v251 := v250.FindInternedVar(lang.NewSymbol("concat")) +if v251.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v251))) } -// data-reader-urls -{ -v0 := lang.NewSymbol("data-reader-urls").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7873), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7873), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -return lang.NewList() -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v252 := v251.Get() +v253 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v254 := v253.FindInternedVar(lang.NewSymbol("list")) +if v254.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v254))) } +v255 := v254.Get() +v256 := lang.Apply(v255, []any{v7}) +v257 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v258 := v257.FindInternedVar(lang.NewSymbol("list")) +if v258.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v258))) } -// repeatedly -{ -v0 := lang.NewSymbol("repeatedly").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Takes a function of no args, presumably with side effects, and\n returns an infinite (or length n if supplied) lazy sequence of calls\n to it", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5167), lang.NewKeyword("end-line"), int(5167))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("cons")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v259 := v258.Get() +v260 := lang.Apply(v259, []any{v5}) +v261 := lang.Apply(v252, []any{v256, v260}) +v262 := lang.Apply(v249, []any{v261}) +v263 := lang.Apply(v243, []any{v246, v262}) +v264 := lang.Apply(v240, []any{v263}) +v265 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v266 := v265.FindInternedVar(lang.NewSymbol("list")) +if v266.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v266))) } -v7 := v6.Get() -v8 := lang.Apply(v3, nil) -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("repeatedly")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +v267 := v266.Get() +v268 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v269 := v268.FindInternedVar(lang.NewSymbol("seq")) +if v269.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v269))) } -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v3}) -v13 := lang.Apply(v7, []any{v8, v12}) -return v13 -}) -v5 := lang.Apply(lang1.NewLazySeq, []any{v4}) -return v5 - case 2: -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("take")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v270 := v269.Get() +v271 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v272 := v271.FindInternedVar(lang.NewSymbol("concat")) +if v272.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v272))) } -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("repeatedly")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v273 := v272.Get() +v274 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v275 := v274.FindInternedVar(lang.NewSymbol("list")) +if v275.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v275))) } -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v4}) -v12 := lang.Apply(v7, []any{v3, v11}) -return v12 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v276 := v275.Get() +v277 := lang.Apply(v276, []any{lang.NewSymbol("case*")}) +v278 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v279 := v278.FindInternedVar(lang.NewSymbol("list")) +if v279.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v279))) } +v280 := v279.Get() +v281 := lang.Apply(v280, []any{v7}) +v282 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v283 := v282.FindInternedVar(lang.NewSymbol("list")) +if v283.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v283))) } -// find-ns -{ -v0 := lang.NewSymbol("find-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Returns the namespace named by the symbol or nil if it doesn't exist.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4125), lang.NewKeyword("end-line"), int(4125))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.Apply(lang1.FindNamespace, []any{v3}) -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v284 := v283.Get() +v285 := lang.Apply(v284, []any{v202}) +v286 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v287 := v286.FindInternedVar(lang.NewSymbol("list")) +if v287.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v287))) } +v288 := v287.Get() +v289 := lang.Apply(v288, []any{v207}) +v290 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v291 := v290.FindInternedVar(lang.NewSymbol("list")) +if v291.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v291))) } -// *print-meta* -{ -v0 := lang.NewSymbol("*print-meta*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "If set to logical true, when printing an object, its metadata will also\n be printed in a form that can be read back by the reader.\n\n Defaults to false.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, nil, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v292 := v291.Get() +v293 := lang.Apply(v292, []any{v19}) +v294 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v295 := v294.FindInternedVar(lang.NewSymbol("list")) +if v295.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v295))) } +v296 := v295.Get() +v297 := lang.Apply(v296, []any{v212}) +v298 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v299 := v298.FindInternedVar(lang.NewSymbol("list")) +if v299.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v299))) } -// set-error-handler! -{ -v0 := lang.NewSymbol("set-error-handler!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("handler-fn"))), lang.NewKeyword("doc"), "Sets the error-handler of agent a to handler-fn. If an action\n being run by the agent throws an exception or doesn't pass the\n validator fn, handler-fn will be called with two arguments: the\n agent and the exception.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2192), lang.NewKeyword("end-line"), int(2192))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5, _ := lang.FieldOrMethod(v3, "setErrorHandler") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorHandler is not a function"))) +v300 := v299.Get() +v301 := lang.Apply(v300, []any{v217}) +v302 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v303 := v302.FindInternedVar(lang.NewSymbol("list")) +if v303.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v303))) } -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v304 := v303.Get() +v305 := lang.Apply(v304, []any{lang.NewKeyword("hash-equiv")}) +v306 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v307 := v306.FindInternedVar(lang.NewSymbol("list")) +if v307.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v307))) } +v308 := v307.Get() +v309 := lang.Apply(v308, []any{v222}) +v310 := lang.Apply(v273, []any{v277, v281, v285, v289, v293, v297, v301, v305, v309}) +v311 := lang.Apply(v270, []any{v310}) +v312 := lang.Apply(v267, []any{v311}) +v313 := lang.Apply(v233, []any{v237, v264, v312}) +v314 := lang.Apply(v230, []any{v313}) +v195 = v314 +} else { +var v197 any +v198 := lang.Apply(v187, []any{lang.NewKeyword("identity"), v191}) +if lang.IsTruthy(v198) { +v200 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v201 := v200.FindInternedVar(lang.NewSymbol("prep-hashes")) +if v201.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v201))) } -// add-classpath -{ -v0 := lang.NewSymbol("add-classpath").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("url"))), lang.NewKeyword("doc"), "DEPRECATED \n\n Adds the url (String or URL object) to the classpath per\n URLClassLoader.addURL", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("deprecated"), "1.1", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5176), lang.NewKeyword("end-line"), int(5176))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("println")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v202 := v201.Get() +v203 := lang.Apply(v202, []any{v7, v19, v158, v163}) +var v199 any = v203 +_ = v199 +v205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v206 := v205.FindInternedVar(lang.NewSymbol("nth")) +if v206.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v206))) } -v6 := v5.Get() -v7 := lang.Apply(v6, []any{"WARNING: add-classpath is deprecated"}) -_ = v7 -v8 := lang.Apply(nil, []any{v3}) -return v8 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v207 := v206.Get() +v208 := lang.Apply(v207, []any{v199, int64(0), nil}) +var v204 any = v208 +_ = v204 +v210 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v211 := v210.FindInternedVar(lang.NewSymbol("nth")) +if v211.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v211))) } +v212 := v211.Get() +v213 := lang.Apply(v212, []any{v199, int64(1), nil}) +var v209 any = v213 +_ = v209 +v215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v216 := v215.FindInternedVar(lang.NewSymbol("nth")) +if v216.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v216))) } -// ns-unmap -{ -v0 := lang.NewSymbol("ns-unmap").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Removes the mappings for the symbol from the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4177), lang.NewKeyword("end-line"), int(4177))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("the-ns")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v217 := v216.Get() +v218 := lang.Apply(v217, []any{v199, int64(2), nil}) +var v214 any = v218 +_ = v214 +v220 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v221 := v220.FindInternedVar(lang.NewSymbol("nth")) +if v221.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v221))) } -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -v9, _ := lang.FieldOrMethod(v8, "unmap") -if reflect.TypeOf(v9).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("unmap is not a function"))) +v222 := v221.Get() +v223 := lang.Apply(v222, []any{v199, int64(3), nil}) +var v219 any = v223 +_ = v219 +v225 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v226 := v225.FindInternedVar(lang.NewSymbol("nth")) +if v226.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v226))) } -v10 := lang.Apply(v9, []any{v4}) -return v10 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v227 := v226.Get() +v228 := lang.Apply(v227, []any{v199, int64(4), nil}) +var v224 any = v228 +_ = v224 +v230 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v231 := v230.FindInternedVar(lang.NewSymbol("seq")) +if v231.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v231))) } +v232 := v231.Get() +v233 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v234 := v233.FindInternedVar(lang.NewSymbol("concat")) +if v234.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v234))) } -// even? -{ -v0 := lang.NewSymbol("even?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is even, throws an exception if n is not an integer", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1381), lang.NewKeyword("end-line"), int(1381))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("integer?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v235 := v234.Get() +v236 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v237 := v236.FindInternedVar(lang.NewSymbol("list")) +if v237.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v237))) } -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -if lang.IsTruthy(v8) { -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("zero?")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +v238 := v237.Get() +v239 := lang.Apply(v238, []any{lang.NewSymbol("glojure.core/let")}) +v240 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v241 := v240.FindInternedVar(lang.NewSymbol("list")) +if v241.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v241))) } -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("bit-and")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +v242 := v241.Get() +v243 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v244 := v243.FindInternedVar(lang.NewSymbol("apply")) +if v244.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v244))) } -v14 := v13.Get() -v15 := lang.Apply(lang1.UncheckedLongCast, []any{v3}) -v16 := lang.Apply(v14, []any{v15, int64(1)}) -v17 := lang.Apply(v11, []any{v16}) -v4 = v17 -} else { -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("str")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v245 := v244.Get() +v246 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v247 := v246.FindInternedVar(lang.NewSymbol("vector")) +if v247.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v247))) } -v20 := v19.Get() -v21 := lang.Apply(v20, []any{"Argument must be an integer: ", v3}) -v22 := lang.Apply(lang1.NewIllegalArgumentError, []any{v21}) -panic(v22) +v248 := v247.Get() +v249 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v250 := v249.FindInternedVar(lang.NewSymbol("seq")) +if v250.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v250))) } -return v4 +v251 := v250.Get() +v252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v253 := v252.FindInternedVar(lang.NewSymbol("concat")) +if v253.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v253))) +} +v254 := v253.Get() +v255 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v256 := v255.FindInternedVar(lang.NewSymbol("list")) +if v256.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v256))) +} +v257 := v256.Get() +v258 := lang.Apply(v257, []any{v7}) +v259 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v260 := v259.FindInternedVar(lang.NewSymbol("list")) +if v260.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v260))) +} +v261 := v260.Get() +v262 := lang.Apply(v261, []any{v5}) +v263 := lang.Apply(v254, []any{v258, v262}) +v264 := lang.Apply(v251, []any{v263}) +v265 := lang.Apply(v245, []any{v248, v264}) +v266 := lang.Apply(v242, []any{v265}) +v267 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v268 := v267.FindInternedVar(lang.NewSymbol("list")) +if v268.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v268))) +} +v269 := v268.Get() +v270 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v271 := v270.FindInternedVar(lang.NewSymbol("seq")) +if v271.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v271))) +} +v272 := v271.Get() +v273 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v274 := v273.FindInternedVar(lang.NewSymbol("concat")) +if v274.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v274))) +} +v275 := v274.Get() +v276 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v277 := v276.FindInternedVar(lang.NewSymbol("list")) +if v277.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v277))) +} +v278 := v277.Get() +v279 := lang.Apply(v278, []any{lang.NewSymbol("case*")}) +v280 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v281 := v280.FindInternedVar(lang.NewSymbol("list")) +if v281.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v281))) +} +v282 := v281.Get() +v283 := lang.Apply(v282, []any{v7}) +v284 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v285 := v284.FindInternedVar(lang.NewSymbol("list")) +if v285.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v285))) +} +v286 := v285.Get() +v287 := lang.Apply(v286, []any{v204}) +v288 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v289 := v288.FindInternedVar(lang.NewSymbol("list")) +if v289.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v289))) +} +v290 := v289.Get() +v291 := lang.Apply(v290, []any{v209}) +v292 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v293 := v292.FindInternedVar(lang.NewSymbol("list")) +if v293.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v293))) +} +v294 := v293.Get() +v295 := lang.Apply(v294, []any{v19}) +v296 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v297 := v296.FindInternedVar(lang.NewSymbol("list")) +if v297.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v297))) +} +v298 := v297.Get() +v299 := lang.Apply(v298, []any{v214}) +v300 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v301 := v300.FindInternedVar(lang.NewSymbol("list")) +if v301.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v301))) +} +v302 := v301.Get() +v303 := lang.Apply(v302, []any{v219}) +v304 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v305 := v304.FindInternedVar(lang.NewSymbol("list")) +if v305.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v305))) +} +v306 := v305.Get() +v307 := lang.Apply(v306, []any{lang.NewKeyword("hash-identity")}) +v308 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v309 := v308.FindInternedVar(lang.NewSymbol("list")) +if v309.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v309))) +} +v310 := v309.Get() +v311 := lang.Apply(v310, []any{v224}) +v312 := lang.Apply(v275, []any{v279, v283, v287, v291, v295, v299, v303, v307, v311}) +v313 := lang.Apply(v272, []any{v312}) +v314 := lang.Apply(v269, []any{v313}) +v315 := lang.Apply(v235, []any{v239, v266, v314}) +v316 := lang.Apply(v232, []any{v315}) +v197 = v316 +} else { +v199 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v200 := v199.FindInternedVar(lang.NewSymbol("str")) +if v200.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v200))) +} +v201 := v200.Get() +v202 := lang.Apply(v201, []any{"No matching clause: ", v191}) +v203 := lang.Apply(lang1.NewIllegalArgumentError, []any{v202}) +panic(v203) +} +v195 = v197 +} +v193 = v195 +} +v86 = v193 +} +return v86 + } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -17008,86 +16625,157 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// booleans +// case-map { -var v1 lang.FnFunc -{ // function booleans -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { +v0 := lang.NewSymbol("case-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("case-f"), lang.NewSymbol("test-f"), lang.NewSymbol("tests"), lang.NewSymbol("thens"))), lang.NewKeyword("doc"), "Transforms a sequence of test constants and a corresponding sequence of then\n expressions into a sorted map to be consumed by case*. The form of the map\n entries are {(case-f test) [(test-f test) then]}.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6657), lang.NewKeyword("end-line"), int(6657), lang.NewKeyword("private"), true)).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 4 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() +v4 := args[1] +v5 := args[2] +v6 := args[3] v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +v8 := v7.FindInternedVar(lang.NewSymbol("into1")) if v8.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } v9 := v8.Get() v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) +v11 := v10.FindInternedVar(lang.NewSymbol("sorted-map")) if v11.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v13 := lang.Apply(v12, nil) v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) +v15 := v14.FindInternedVar(lang.NewSymbol("zipmap")) if v15.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("map")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v20 := v19.Get() -v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/booleans")}) -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("list")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v3, v5}) +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("map")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v26 := lang.Apply(v9, []any{v13, v17, v21, v25}) -v27 := lang.Apply(v6, []any{v26}) -return v27 +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("vector")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("map")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{v4, v5}) +v31 := lang.Apply(v23, []any{v26, v30, v6}) +v32 := lang.Apply(v16, []any{v20, v31}) +v33 := lang.Apply(v9, []any{v13, v32}) +return v33 }) -v2 := v1 -_ = v2 +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v0 := lang.NewSymbol("booleans").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Casts to boolean[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5372), lang.NewKeyword("end-line"), int(5372))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { +} +// cast +{ +v0 := lang.NewSymbol("cast").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Throws a ClassCastException if x is not a c, else returns x.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(345), lang.NewKeyword("end-line"), int(345))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "booleans") +v3 := args[0] +v4 := args[1] +v5, _ := lang.FieldOrMethod(v3, "cast") if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("booleans is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("cast is not a function"))) } v6 := lang.Apply(v5, []any{v4}) return v6 }) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// unchecked-negate-int +// cat +{ +v0 := lang.NewSymbol("cat").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rf"))), lang.NewKeyword("doc"), "A transducer which concatenates the contents of each input, which must be a\n collection, into the reduction.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7688), lang.NewKeyword("end-line"), int(7688))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("preserving-reduced")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +var v4 any = v8 +_ = v4 +var v10 lang.FnFunc +v10 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v11 := lang.Apply(v3, nil) +return v11 + case 1: +v11 := args[0] +v12 := lang.Apply(v3, []any{v11}) +return v12 + case 2: +v11 := args[0] +v12 := args[1] +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("reduce")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v4, v11, v12}) +return v16 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7694), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(7698), lang.NewKeyword("end-column"), int(36)) +v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v12 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// char { var v1 lang.FnFunc -{ // function unchecked-negate-int__inliner +{ // function char__inliner v1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -17118,7 +16806,7 @@ if v15.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v19 := v18.FindInternedVar(lang.NewSymbol("list")) if v19.IsMacro() { @@ -17143,34 +16831,46 @@ if v28.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/unchecked_int_negate")}) +var v30 any v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) +v32 := v31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) if v32.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } v33 := v32.Get() -v34 := lang.Apply(v33, []any{v3}) -v35 := lang.Apply(v26, []any{v30, v34}) -v36 := lang.Apply(v23, []any{v35}) -v37 := lang.Apply(v20, []any{v36}) -v38 := lang.Apply(v9, []any{v13, v17, v37}) -v39 := lang.Apply(v6, []any{v38}) -return v39 +if lang.IsTruthy(v33) { +v30 = lang.NewSymbol("uncheckedCharCast") +} else { +v30 = lang.NewSymbol("charCast") +} +v34 := lang.Apply(v29, []any{v30}) +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("list")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v37, []any{v3}) +v39 := lang.Apply(v26, []any{v34, v38}) +v40 := lang.Apply(v23, []any{v39}) +v41 := lang.Apply(v20, []any{v40}) +v42 := lang.Apply(v9, []any{v13, v17, v41}) +v43 := lang.Apply(v6, []any{v42}) +return v43 }) v2 := v1 _ = v2 } -v0 := lang.NewSymbol("unchecked-negate-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the negation of x, an int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(26), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1182), lang.NewKeyword("end-line"), int(1182))).(*lang.Symbol) +v0 := lang.NewSymbol("char").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to char", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3511), lang.NewKeyword("end-line"), int(3511))).(*lang.Symbol) var v3 lang.FnFunc v3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "unchecked_int_negate") +v5, _ := lang.FieldOrMethod(runtime9.RT, "CharCast") if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_negate is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("CharCast is not a function"))) } v6 := lang.Apply(v5, []any{v4}) return v6 @@ -17181,237 +16881,238 @@ if v0.Meta() != nil { v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// print-prefix-map +// char-array { -v0 := lang.NewSymbol("print-prefix-map").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(243), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(243), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("prefix"), lang.NewSymbol("kvs"), lang.NewSymbol("print-one"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] +var v1 lang.FnFunc +{ // function char-array__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.NewList(args[0:]...) +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("print-sequential")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) if v8.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } v9 := v8.Get() v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("str")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) if v11.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } v12 := v11.Get() -v13 := lang.Apply(v12, []any{v3, "{"}) -var v14 lang.FnFunc -v14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v15 := args[0] -v16 := args[1] -var v17 any = v15 -_ = v17 -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("nth")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v17, int64(0), nil}) -var v18 any = v22 -_ = v18 -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("nth")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v17, int64(1), nil}) -var v23 any = v27 -_ = v23 -v29 := lang.Apply(v5, []any{v18, v16}) -_ = v29 -v30 := lang.Apply(lang1.AppendWriter, []any{v16, lang.NewChar(32)}) -_ = v30 -v31 := lang.Apply(v5, []any{v23, v16}) -return v31 +v20 := v19.Get() +v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/charArray")}) +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("list")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("seq")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("concat")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("list")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v37, []any{lang.NewSymbol("glojure.core/args")}) +v39 := lang.Apply(v30, []any{v34, v38}) +v40 := lang.Apply(v27, []any{v39}) +v41 := lang.Apply(v24, []any{v40}) +v42 := lang.Apply(v9, []any{v13, v17, v21, v41}) +v43 := lang.Apply(v6, []any{v42}) +return v43 + } }) -v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(246), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(247), lang.NewKeyword("end-column"), int(107)) -v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) -if err != nil { - panic(err) +v2 := v1 +_ = v2 } -v17 := lang.Apply(v9, []any{v13, v16, ", ", "}", v4, v6}) -return v17 +v0 := lang.NewSymbol("char-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Creates an array of chars", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)int64(2)), lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5325), lang.NewKeyword("end-line"), int(5325))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "charArray") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("charArray is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 + case 2: +v4 := args[0] +v5 := args[1] +v6, _ := lang.FieldOrMethod(lang1.Numbers, "charArrayInit") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("charArrayInit is not a function"))) +} +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// compile +// char-escape-string { -v0 := lang.NewSymbol("compile").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"))), lang.NewKeyword("doc"), "Compiles the namespace named by the symbol lib into a set of\n classfiles. The source for the lib must be in a proper\n classpath-relative directory. The output files will go into the\n directory specified by *compile-path*, and that directory too must\n be in the classpath.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6157), lang.NewKeyword("end-line"), int(6157))).(*lang.Symbol) +v1 := reflect.TypeOf("") +v0 := lang.NewSymbol("char-escape-string").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("doc"), "Returns escape string for char or nil if none", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(6), lang.NewKeyword("line"), int(214), lang.NewKeyword("end-line"), int(217))).(*lang.Symbol) +v2 := ns.InternWithValue(v0, lang.NewMap(lang.NewChar(10), "\\n", lang.NewChar(9), "\\t", lang.NewChar(13), "\\r", lang.NewChar(34), "\\\"", lang.NewChar(92), "\\\\", lang.NewChar(12), "\\f", lang.NewChar(8), "\\b"), true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// char-name-string +{ +v1 := reflect.TypeOf("") +v0 := lang.NewSymbol("char-name-string").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("doc"), "Returns name string for char or nil if none", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(6), lang.NewKeyword("line"), int(335), lang.NewKeyword("end-line"), int(338))).(*lang.Symbol) +v2 := ns.InternWithValue(v0, lang.NewMap(lang.NewChar(10), "newline", lang.NewChar(9), "tab", lang.NewChar(32), "space", lang.NewChar(8), "backspace", lang.NewChar(12), "formfeed", lang.NewChar(13), "return"), true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// char? +{ +v0 := lang.NewSymbol("char?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a Character", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(153), lang.NewKeyword("end-line"), int(157))).(*lang.Symbol) var v2 lang.FnFunc +{ // function char? v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := args[0] +v4 := args[0] v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("push-thread-bindings")) +v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) if v6.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("hash-map")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*compile-files*")) -v12 := lang.Apply(v10, []any{v11, true}) -v13 := lang.Apply(v7, []any{v12}) -_ = v13 -var v14 any -func() { -defer func() { -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, nil) -}() -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("load-one")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v3, true, true}) -v14 = v22 -}() -_ = v14 -return v3 +v8 := lang.Apply(v7, []any{lang1.Char, v4}) +return v8 }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// unquote -{ -v0 := lang.NewSymbol("unquote").WithMeta(lang.NewMap()).(*lang.Symbol) -v1 := ns.Intern(v0) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// ref-set -{ -v0 := lang.NewSymbol("ref-set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Must be called in a transaction. Sets the value of ref.\n Returns val.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2447), lang.NewKeyword("end-line"), int(2447))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5, _ := lang.FieldOrMethod(v3, "set") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("set is not a function"))) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(157), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(157), lang.NewKeyword("end-column"), int(89))).(lang.FnFunc) +v3 := v2 +_ = v3 } -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// identical? +// chars { var v1 lang.FnFunc -{ // function identical?__inliner +{ // function chars v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("concat")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("list")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v13 := v12.Get() -v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol("glojure.lang.Util")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v21 := v20.Get() -v22 := lang.Apply(v21, []any{lang.NewSymbol("glojure.core/identical")}) -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v25 := v24.Get() -v26 := lang.Apply(v25, []any{v3}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v20 := v19.Get() +v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/chars")}) +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("list")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -v29 := v28.Get() -v30 := lang.Apply(v29, []any{v4}) -v31 := lang.Apply(v10, []any{v14, v18, v22, v26, v30}) -v32 := lang.Apply(v7, []any{v31}) -return v32 +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v3}) +v26 := lang.Apply(v9, []any{v13, v17, v21, v25}) +v27 := lang.Apply(v6, []any{v26}) +return v27 }) v2 := v1 _ = v2 } -v0 := lang.NewSymbol("identical?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Tests if 2 arguments are the same object", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(768), lang.NewKeyword("end-line"), int(768))).(*lang.Symbol) +v0 := lang.NewSymbol("chars").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Casts to chars[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5382), lang.NewKeyword("end-line"), int(5382))).(*lang.Symbol) var v3 lang.FnFunc v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5 := args[1] -v6 := lang.Apply(lang1.Identical, []any{v4, v5}) +v5, _ := lang.FieldOrMethod(lang1.Numbers, "chars") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("chars is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) return v6 }) v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -17420,90 +17121,132 @@ if v0.Meta() != nil { v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// type +// check-cyclic-dependency { -v0 := lang.NewSymbol("type").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns the :type metadata of x, or its Class if none", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3467), lang.NewKeyword("end-line"), int(3467))).(*lang.Symbol) +v0 := lang.NewSymbol("check-cyclic-dependency").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("path"))), lang.NewKeyword("doc"), "Detects and rejects non-trivial cyclic load dependencies. The\n exception message shows the dependency chain with the cycle\n highlighted. Ignores the trivial case of a file attempting to load\n itself because that can occur when a gen-class'd class loads its\n implementation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(30), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6017), lang.NewKeyword("end-line"), int(6017), lang.NewKeyword("private"), true)).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] +var v4 any v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("get")) +v6 := v5.FindInternedVar(lang.NewSymbol("some")) if v6.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("meta")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v3}) -v12 := lang.Apply(v7, []any{v11, lang.NewKeyword("type")}) -var v4 any = v12 -_ = v4 -var v14 any -if lang.IsTruthy(v4) { -v14 = v4 -} else { -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("class")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +v8 := lang.CreatePersistentTreeSet(v3) +v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6024), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(6024), lang.NewKeyword("end-column"), int(21)) +v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v3}) -v14 = v18 +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("rest")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -return v14 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("*pending-paths*")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } +v16 := v15.Get() +v17 := lang.Apply(v13, []any{v16}) +v18 := lang.Apply(v7, []any{v10, v17}) +if lang.IsTruthy(v18) { +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("map")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -// prefer-method -{ -v0 := lang.NewSymbol("prefer-method").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"), lang.NewSymbol("dispatch-val-x"), lang.NewSymbol("dispatch-val-y"))), lang.NewKeyword("doc"), "Causes the multimethod to prefer matches of dispatch-val-x over dispatch-val-y \n when there is a conflict", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1801), lang.NewKeyword("end-line"), int(1801))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { +v22 := v21.Get() +var v23 lang.FnFunc +v23 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6, _ := lang.FieldOrMethod(v3, "PreferMethod") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("PreferMethod is not a function"))) +v24 := args[0] +var v25 any +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("=")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) } -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 +v28 := v27.Get() +v29 := lang.Apply(v28, []any{v24, v3}) +if lang.IsTruthy(v29) { +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("str")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.Apply(v32, []any{"[ ", v24, " ]"}) +v25 = v33 +} else { +v25 = v24 +} +return v25 }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v24 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6025), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(6025), lang.NewKeyword("end-column"), int(59)) +v25, err := lang.WithMeta(v23, v24.(lang.IPersistentMap)) +if err != nil { + panic(err) } +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("cons")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("*pending-paths*")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.Apply(v28, []any{v3, v31}) +v33 := lang.Apply(v22, []any{v25, v32}) +var v19 any = v33 +_ = v19 +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("apply")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("str")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("interpose")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v43, []any{"->", v19}) +v45 := lang.Apply(v37, []any{v40, v44}) +var v34 any = v45 +_ = v34 +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("throw-if")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +} +v49 := v48.Get() +v50 := lang.Apply(v49, []any{true, "Cyclic load dependency: %s", v34}) +v4 = v50 +} else { +v4 = nil } -// sorted-set -{ -v0 := lang.NewSymbol("sorted-set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keys"))), lang.NewKeyword("doc"), "Returns a new sorted set with supplied keys. Any equal keys are\n handled as if by repeated uses of conj.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(416), lang.NewKeyword("end-line"), int(416))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewList(args[0:]...) -v4 := lang.Apply(lang1.CreatePersistentTreeSet, []any{v3}) return v4 - } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -17511,103 +17254,120 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// get-in +// check-valid-options { -v0 := lang.NewSymbol("get-in").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("ks")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("ks"), lang.NewSymbol("not-found"))), lang.NewKeyword("doc"), "Returns the value in a nested associative structure,\n where ks is a sequence of keys. Returns nil if the key\n is not present, or the not-found value if supplied.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6171), lang.NewKeyword("end-line"), int(6171))).(*lang.Symbol) +v0 := lang.NewSymbol("check-valid-options").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("options"), lang.NewSymbol("&"), lang.NewSymbol("valid-keys"))), lang.NewKeyword("doc"), "Throws an exception if the given option map contains keys not listed\n as valid, else returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(35), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1709), lang.NewKeyword("end-line"), int(1709), lang.NewKeyword("private"), true)).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 2: + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("reduce1")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v4 := lang.NewList(args[1:]...) +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("seq")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("get")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("apply")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -v10 := v9.Get() -v11 := lang.Apply(v7, []any{v10, v3, v4}) -return v11 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v7 := lang.Apply(Object23., nil) -var v6 any = v7 -_ = v6 -var v8 any = v8 -_ = v8 -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("seq")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("disj")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } -v12 := v11.Get() -v13 := lang.Apply(v12, []any{v9}) -var v9 any = v13 -_ = v9 -var v14 any -for { -var v15 any -if lang.IsTruthy(v9) { -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("get")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("apply")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("first")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +v17 := v16.Get() +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("hash-set")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v22 := v21.Get() -v23 := lang.Apply(v22, []any{v9}) -v24 := lang.Apply(v19, []any{v16, v23, v6}) -var v16 any = v24 -_ = v16 -var v26 any -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("identical?")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("keys")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v29 := v28.Get() -v30 := lang.Apply(v29, []any{v6, v16}) -if lang.IsTruthy(v30) { -v26 = v5 -} else { -var v31 any = v6 -var v32 any = v16 +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v3}) +v25 := lang.Apply(v17, []any{v20, v24}) +v26 := lang.Apply(v11, []any{v14, v25, v4}) +v27 := lang.Apply(v8, []any{v26}) +if lang.IsTruthy(v27) { +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("apply")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("str")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("next")) +v35 := v34.FindInternedVar(lang.NewSymbol("first")) if v35.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } v36 := v35.Get() -v37 := lang.Apply(v36, []any{v9}) -var v33 any = v37 -v6 = v31 -v8 = v32 -v9 = v33 -continue +v37 := lang.Apply(v36, []any{v4}) +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("map")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) } -v15 = v26 -} else { -v15 = v8 +v40 := v39.Get() +var v41 lang.FnFunc +v41 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v42 := args[0] +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("str")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) } -v14 = v15 - break +v45 := v44.Get() +v46 := lang.Apply(v45, []any{", ", v42}) +return v46 +}) +v42 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1718), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(1718), lang.NewKeyword("end-column"), int(28)) +v43, err := lang.WithMeta(v41, v42.(lang.IPersistentMap)) +if err != nil { + panic(err) } -return v14 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("rest")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v4}) +v48 := lang.Apply(v40, []any{v43, v47}) +v49 := lang.Apply(v30, []any{v33, "Only these options are valid: ", v37, v48}) +v50 := lang.Apply(lang1.NewIllegalArgumentError, []any{v49}) +panic(v50) +} else { +v5 = nil +} +return v5 } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -17616,55 +17376,94 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// nfirst +// chunk { -v0 := lang.NewSymbol("nfirst").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Same as (next (first x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(105), lang.NewKeyword("end-line"), int(109))).(*lang.Symbol) +v0 := lang.NewSymbol("chunk").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(691), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(691), lang.NewKeyword("end-column"), int(41), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("b"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) var v2 lang.FnFunc -{ // function nfirst v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v4 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("next")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("first")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v3 := args[0] +v4, ok := lang.FieldOrMethod(v3, "chunk") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "chunk"))) } -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v4}) -v12 := lang.Apply(v7, []any{v11}) -return v12 +var v5 any +switch reflect.TypeOf(v4).Kind() { +case reflect.Func: + v5 = lang.Apply(v4, nil) +default: + v5 = v4 +} +return v5 }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(109), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(109), lang.NewKeyword("end-column"), int(49))).(lang.FnFunc) -v3 := v2 -_ = v3 +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// chunk-append +{ +v0 := lang.NewSymbol("chunk-append").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(688), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(688), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("b"), lang.NewSymbol("x"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5, _ := lang.FieldOrMethod(v3, "add") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) } +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// var-get +// chunk-buffer { -v0 := lang.NewSymbol("var-get").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Gets the value in the var object", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4326), lang.NewKeyword("end-line"), int(4326))).(*lang.Symbol) +v0 := lang.NewSymbol("chunk-buffer").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(685), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(685), lang.NewKeyword("end-column"), int(53), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("capacity"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4, _ := lang.FieldOrMethod(v3, "Get") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Get is not a function"))) +v4 := lang.Apply(lang1.NewChunkBuffer, []any{v3}) +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// chunk-cons +{ +v0 := lang.NewSymbol("chunk-cons").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(703), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(703), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("chunk"), lang.NewSymbol("rest"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +var v5 any +v6 := lang.Apply(lang1.Count, []any{v3}) +v7 := lang.Apply(lang1.IsZero, []any{v6}) +if lang.IsTruthy(v7) { +v5 = v4 +} else { +v8 := lang.Apply(lang1.NewChunkedCons, []any{v3, v4}) +v5 = v8 } -v5 := lang.Apply(v4, []any{}) return v5 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -17673,466 +17472,375 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// load +// chunk-first { -v0 := lang.NewSymbol("load").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("paths"))), lang.NewKeyword("doc"), "Loads Clojure code from resources in classpath. A path is interpreted as\n classpath-relative if it begins with a slash or relative to the root\n directory for the current namespace otherwise.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("redef"), true, lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6138), lang.NewKeyword("end-line"), int(6138))).(*lang.Symbol) +v0 := lang.NewSymbol("chunk-first").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(694), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(694), lang.NewKeyword("end-column"), int(48), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewList(args[0:]...) -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, ok := lang.FieldOrMethod(v3, "chunkedFirst") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "chunkedFirst"))) } -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -var v4 any = v8 -_ = v4 -var v9 any = nil -_ = v9 -var v10 any = int64(0) -_ = v10 -var v11 any = int64(0) -_ = v11 -var v12 any -for { -var v13 any -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("<")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +var v5 any +switch reflect.TypeOf(v4).Kind() { +case reflect.Func: + v5 = lang.Apply(v4, nil) +default: + v5 = v4 } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v11, v10}) -if lang.IsTruthy(v17) { -v19, _ := lang.FieldOrMethod(v9, "nth") -if reflect.TypeOf(v19).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v20 := lang.Apply(v19, []any{v11}) -var v18 any = v20 -_ = v18 -var v23 any -v24 := lang.Apply(strings22.HasPrefix, []any{v22, "/"}) -if lang.IsTruthy(v24) { -v23 = v22 -} else { -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("str")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("root-directory")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +// chunk-next +{ +v0 := lang.NewSymbol("chunk-next").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(700), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(700), lang.NewKeyword("end-column"), int(71), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, ok := lang.FieldOrMethod(v3, "chunkedNext") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "chunkedNext"))) } -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("ns-name")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +var v5 any +switch reflect.TypeOf(v4).Kind() { +case reflect.Func: + v5 = lang.Apply(v4, nil) +default: + v5 = v4 } -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("*ns*")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v36 := v35.Get() -v37 := lang.Apply(v33, []any{v36}) -v38 := lang.Apply(v30, []any{v37}) -v39 := lang.Apply(v27, []any{v38, lang.NewChar(47), v22}) -v23 = v39 } -var v22 any = v23 -_ = v22 -var v41 any -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +// chunk-rest +{ +v0 := lang.NewSymbol("chunk-rest").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(697), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(697), lang.NewKeyword("end-column"), int(71), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, ok := lang.FieldOrMethod(v3, "chunkedMore") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "chunkedMore"))) } -v44 := v43.Get() -if lang.IsTruthy(v44) { -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("printf")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +var v5 any +switch reflect.TypeOf(v4).Kind() { +case reflect.Func: + v5 = lang.Apply(v4, nil) +default: + v5 = v4 } -v47 := v46.Get() -v48 := lang.Apply(v47, []any{"(glojure.core/load \"%s\")\n", v22}) -_ = v48 -v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v50 := v49.FindInternedVar(lang.NewSymbol("flush")) -if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v51 := v50.Get() -v52 := lang.Apply(v51, nil) -v41 = v52 -} else { -v41 = nil } -_ = v41 -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("check-cyclic-dependency")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +// chunked-seq? +{ +v0 := lang.NewSymbol("chunked-seq?").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(708), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(708), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v55 := v54.Get() -v56 := lang.Apply(v55, []any{v22}) -_ = v56 -var v57 any -v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v59 := v58.FindInternedVar(lang.NewSymbol("=")) -if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) +v6 := v5.Get() +v7 := lang.Apply(v6, []any{lang1.IChunkedSeq, v3}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v60 := v59.Get() -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("first")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) } -v63 := v62.Get() -v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v65 := v64.FindInternedVar(lang.NewSymbol("*pending-paths*")) -if v65.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) +// class +{ +v0 := lang.NewSymbol("class").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns the Class of x", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3461), lang.NewKeyword("end-line"), int(3461))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("nil?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v66 := v65.Get() -v67 := lang.Apply(v63, []any{v66}) -v68 := lang.Apply(v60, []any{v22, v67}) -if lang.IsTruthy(v68) { -v57 = nil +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +if lang.IsTruthy(v8) { +v4 = v3 } else { -v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v71 := v70.FindInternedVar(lang.NewSymbol("push-thread-bindings")) -if v71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) -} -v72 := v71.Get() -v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v74 := v73.FindInternedVar(lang.NewSymbol("hash-map")) -if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) +v9 := lang.Apply(lang1.TypeOf, []any{v3}) +v4 = v9 } -v75 := v74.Get() -v76 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*pending-paths*")) -v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v78 := v77.FindInternedVar(lang.NewSymbol("conj")) -if v78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v79 := v78.Get() -v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v81 := v80.FindInternedVar(lang.NewSymbol("*pending-paths*")) -if v81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) } -v82 := v81.Get() -v83 := lang.Apply(v79, []any{v82, v22}) -v84 := lang.Apply(v75, []any{v76, v83}) -v85 := lang.Apply(v72, []any{v84}) -_ = v85 -var v86 any -func() { -defer func() { -v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v88 := v87.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) -if v88.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) +// class? +{ +v0 := lang.NewSymbol("class?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is an instance of Class", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5465), lang.NewKeyword("end-line"), int(5465))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v89 := v88.Get() -v90 := lang.Apply(v89, nil) -}() -v91 := lang.Apply(strings22.TrimPrefix, []any{v22, "/"}) -v92, _ := lang.FieldOrMethod(runtime3.RT, "Load") -if reflect.TypeOf(v92).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Load is not a function"))) +v6 := v5.Get() +v7 := lang.Apply(v6, []any{reflect.Type, v3}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v93 := lang.Apply(v92, []any{v91}) -v86 = v93 -}() -v57 = v86 } -_ = v57 -var v22 any = v4 -var v23 any = v9 -var v24 any = v10 -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("unchecked-inc")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +// clear-agent-errors +{ +v0 := lang.NewSymbol("clear-agent-errors").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("doc"), "DEPRECATED: Use 'restart-agent' instead.\n Clears any exceptions thrown during asynchronous actions of the\n agent, allowing subsequent actions to occur.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("deprecated"), "1.2", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2244), lang.NewKeyword("end-line"), int(2244))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("restart-agent")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v28 := v27.Get() -v29 := lang.Apply(v28, []any{v11}) -var v25 any = v29 -v4 = v22 -v9 = v23 -v10 = v24 -v11 = v25 -continue -} else { -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("seq")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v6 := v5.Get() +v7, ok := lang.FieldOrMethod(v3, "Deref") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "Deref"))) } -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v4}) -var v18 any = v22 -_ = v18 -var v24 any -if lang.IsTruthy(v18) { -var v25 any = v18 -_ = v25 -var v27 any -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("chunked-seq?")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +var v8 any +switch reflect.TypeOf(v7).Kind() { +case reflect.Func: + v8 = lang.Apply(v7, nil) +default: + v8 = v7 } -v30 := v29.Get() -v31 := lang.Apply(v30, []any{v25}) -if lang.IsTruthy(v31) { -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("chunk-first")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +v9 := lang.Apply(v6, []any{v3, v8}) +return v9 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v25}) -var v32 any = v36 -_ = v32 -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("chunk-rest")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) } -v41 := v40.Get() -v42 := lang.Apply(v41, []any{v25}) -var v38 any = v42 -var v43 any = v32 -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("int")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +// coll? +{ +v0 := lang.NewSymbol("coll?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements IPersistentCollection", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6235), lang.NewKeyword("end-line"), int(6235))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v47 := v46.Get() -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("count")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +v6 := v5.Get() +v7 := lang.Apply(v6, []any{lang1.IPersistentCollection, v3}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v32}) -v52 := lang.Apply(v47, []any{v51}) -var v44 any = v52 -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("int")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) } -v56 := v55.Get() -v57 := lang.Apply(v56, []any{int64(0)}) -var v53 any = v57 -v4 = v38 -v9 = v43 -v10 = v44 -v11 = v53 -continue -} else { -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("first")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v25}) -var v32 any = v36 -_ = v32 -var v39 any -v40 := lang.Apply(strings22.HasPrefix, []any{v38, "/"}) -if lang.IsTruthy(v40) { -v39 = v38 -} else { -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("str")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("root-directory")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("ns-name")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) -} -v49 := v48.Get() -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("*ns*")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.Apply(v49, []any{v52}) -v54 := lang.Apply(v46, []any{v53}) -v55 := lang.Apply(v43, []any{v54, lang.NewChar(47), v38}) -v39 = v55 -} -var v38 any = v39 -_ = v38 -var v57 any -v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v59 := v58.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) -if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) -} -v60 := v59.Get() -if lang.IsTruthy(v60) { -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("printf")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) -} -v63 := v62.Get() -v64 := lang.Apply(v63, []any{"(glojure.core/load \"%s\")\n", v38}) -_ = v64 -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("flush")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) -} -v67 := v66.Get() -v68 := lang.Apply(v67, nil) -v57 = v68 -} else { -v57 = nil -} -_ = v57 -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("check-cyclic-dependency")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) -} -v71 := v70.Get() -v72 := lang.Apply(v71, []any{v38}) -_ = v72 -var v73 any -v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v75 := v74.FindInternedVar(lang.NewSymbol("=")) -if v75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) -} -v76 := v75.Get() -v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v78 := v77.FindInternedVar(lang.NewSymbol("first")) -if v78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) -} -v79 := v78.Get() -v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v81 := v80.FindInternedVar(lang.NewSymbol("*pending-paths*")) -if v81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) -} -v82 := v81.Get() -v83 := lang.Apply(v79, []any{v82}) -v84 := lang.Apply(v76, []any{v38, v83}) -if lang.IsTruthy(v84) { -v73 = nil -} else { -v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v87 := v86.FindInternedVar(lang.NewSymbol("push-thread-bindings")) -if v87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) -} -v88 := v87.Get() -v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v90 := v89.FindInternedVar(lang.NewSymbol("hash-map")) -if v90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) +// comment +{ +v0 := lang.NewSymbol("comment").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Ignores body, yields nil", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4733), lang.NewKeyword("end-line"), int(4733))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +return nil + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v91 := v90.Get() -v92 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*pending-paths*")) -v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v94 := v93.FindInternedVar(lang.NewSymbol("conj")) -if v94.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) } -v95 := v94.Get() -v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v97 := v96.FindInternedVar(lang.NewSymbol("*pending-paths*")) -if v97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) +// commute +{ +v0 := lang.NewSymbol("commute").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("fun"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Must be called in a transaction. Sets the in-transaction-value of\n ref to:\n\n (apply fun in-transaction-value-of-ref args)\n\n and returns the in-transaction-value of ref.\n\n At the commit point of the transaction, sets the value of ref to be:\n\n (apply fun most-recently-committed-value-of-ref args)\n\n Thus fun should be commutative, or, failing that, you must accept\n last-one-in-wins behavior. commute allows for more concurrency than\n ref-set.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2414), lang.NewKeyword("end-line"), int(2414))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +v6, _ := lang.FieldOrMethod(v3, "Commute") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Commute is not a function"))) } -v98 := v97.Get() -v99 := lang.Apply(v95, []any{v98, v38}) -v100 := lang.Apply(v91, []any{v92, v99}) -v101 := lang.Apply(v88, []any{v100}) -_ = v101 -var v102 any -func() { -defer func() { -v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v104 := v103.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) -if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v105 := v104.Get() -v106 := lang.Apply(v105, nil) -}() -v107 := lang.Apply(strings22.TrimPrefix, []any{v38, "/"}) -v108, _ := lang.FieldOrMethod(runtime3.RT, "Load") -if reflect.TypeOf(v108).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Load is not a function"))) } -v109 := lang.Apply(v108, []any{v107}) -v102 = v109 -}() -v73 = v102 +// comp +{ +v0 := lang.NewSymbol("comp").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("g")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("g"), lang.NewSymbol("&"), lang.NewSymbol("fs"))), lang.NewKeyword("doc"), "Takes a set of functions and returns a fn that is the composition\n of those fns. The returned fn takes a variable number of args,\n applies the rightmost of fns to the args, the next\n fn (right-to-left) to the result, etc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2549), lang.NewKeyword("end-line"), int(2549))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v4 := v3.FindInternedVar(lang.NewSymbol("identity")) +if v4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) } -_ = v73 -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("next")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +v5 := v4.Get() +return v5 + case 1: +v3 := args[0] +return v3 + case 2: +v3 := args[0] +v4 := args[1] +var v5 lang.FnFunc +v5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v6 := lang.Apply(v4, nil) +v7 := lang.Apply(v3, []any{v6}) +return v7 + case 1: +v6 := args[0] +v7 := lang.Apply(v4, []any{v6}) +v8 := lang.Apply(v3, []any{v7}) +return v8 + case 2: +v6 := args[0] +v7 := args[1] +v8 := lang.Apply(v4, []any{v6, v7}) +v9 := lang.Apply(v3, []any{v8}) +return v9 + case 3: +v6 := args[0] +v7 := args[1] +v8 := args[2] +v9 := lang.Apply(v4, []any{v6, v7, v8}) +v10 := lang.Apply(v3, []any{v9}) +return v10 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v6 := args[0] +v7 := args[1] +v8 := args[2] +v9 := lang.NewList(args[3:]...) +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("apply")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v41 := v40.Get() -v42 := lang.Apply(v41, []any{v25}) -var v38 any = v42 -var v43 any = nil -var v44 any = int64(0) -var v45 any = int64(0) -v4 = v38 -v9 = v43 -v10 = v44 -v11 = v45 -continue +v12 := v11.Get() +v13 := lang.Apply(v12, []any{v4, v6, v7, v8, v9}) +v14 := lang.Apply(v3, []any{v13}) +return v14 + } +}) +v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2559), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2564), lang.NewKeyword("end-column"), int(49)) +v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v24 = v27 -} else { -v24 = nil +return v7 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("reduce1")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v13 = v24 +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("comp")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -v12 = v13 - break +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("list*")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } -return v12 +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v3, v4, v5}) +v16 := lang.Apply(v8, []any{v11, v15}) +return v16 } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -18141,37 +17849,50 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// rand-nth +// comparator { -v0 := lang.NewSymbol("rand-nth").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return a random element of the (sequential) collection. Will have\n the same performance characteristics as nth for the given\n collection.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7256), lang.NewKeyword("end-line"), int(7256))).(*lang.Symbol) +v0 := lang.NewSymbol("comparator").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"))), lang.NewKeyword("doc"), "Returns an implementation of java.util.Comparator based upon pred.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3077), lang.NewKeyword("end-line"), int(3077))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("nth")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +v6 := args[1] +var v7 any +v8 := lang.Apply(v3, []any{v5, v6}) +if lang.IsTruthy(v8) { +v7 = int64(-1) +} else { +var v9 any +v10 := lang.Apply(v3, []any{v6, v5}) +if lang.IsTruthy(v10) { +v9 = int64(1) +} else { +var v11 any +if lang.IsTruthy(lang.NewKeyword("else")) { +v11 = int64(0) +} else { +v11 = nil } -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("rand-int")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v9 = v11 } -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("count")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v7 = v9 } -v12 := v11.Get() -v13 := lang.Apply(v12, []any{v3}) -v14 := lang.Apply(v9, []any{v13}) -v15 := lang.Apply(v6, []any{v3, v14}) -return v15 +return v7 +}) +v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3082), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(3083), lang.NewKeyword("end-column"), int(48)) +v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v6 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -18179,48 +17900,104 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// class +// compare { -v0 := lang.NewSymbol("class").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns the Class of x", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3461), lang.NewKeyword("end-line"), int(3461))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { +var v1 lang.FnFunc +{ // function compare__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -var v4 any +v4 := args[1] v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("nil?")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq")) if v6.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -if lang.IsTruthy(v8) { -v4 = v3 -} else { -v9 := lang.Apply(lang1.TypeOf, []any{v3}) -v4 = v9 +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("concat")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -return v4 +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("list")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol("glojure.lang.Util")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{lang.NewSymbol("glojure.core/compare")}) +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{v3}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{v4}) +v31 := lang.Apply(v10, []any{v14, v18, v22, v26, v30}) +v32 := lang.Apply(v7, []any{v31}) +return v32 }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("compare").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Comparator. Returns a negative number, zero, or a positive number\n when x is logically 'less than', 'equal to', or 'greater than'\n y. Same as Java x.compareTo(y) except it also works for nil, and\n compares numbers and collections in a type-independent manner. x\n must implement Comparable", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(824), lang.NewKeyword("end-line"), int(824))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := args[1] +v6 := lang.Apply(lang1.Compare, []any{v4, v5}) +return v6 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// seqable? +// compare-and-set! { -v0 := lang.NewSymbol("seqable?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if the seq function is supported for x", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6247), lang.NewKeyword("end-line"), int(6247))).(*lang.Symbol) +v0 := lang.NewSymbol("compare-and-set!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atom"), lang.NewSymbol("oldval"), lang.NewSymbol("newval"))), lang.NewKeyword("doc"), "Atomically sets the value of atom to newval if and only if the\n current value of the atom is identical to oldval. Returns true if\n set happened, else false", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2360), lang.NewKeyword("end-line"), int(2360))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { + if len(args) != 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := lang.Apply(nil, []any{v3}) -return v4 +v4 := args[1] +v5 := args[2] +v6, _ := lang.FieldOrMethod(v3, "compareAndSet") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("compareAndSet is not a function"))) +} +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -18228,23 +18005,53 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// future? +// compile { -v0 := lang.NewSymbol("future?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is a future", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6575), lang.NewKeyword("end-line"), int(6575))).(*lang.Symbol) +v0 := lang.NewSymbol("compile").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"))), lang.NewKeyword("doc"), "Compiles the namespace named by the symbol lib into a set of\n classfiles. The source for the lib must be in a proper\n classpath-relative directory. The output files will go into the\n directory specified by *compile-path*, and that directory too must\n be in the classpath.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6157), lang.NewKeyword("end-line"), int(6157))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("push-thread-bindings")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v6 := v5.Get() -v7 := lang.Apply(v6, []any{java.util.concurrent15.Future, v3}) -return v7 +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("hash-map")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*compile-files*")) +v12 := lang.Apply(v10, []any{v11, true}) +v13 := lang.Apply(v7, []any{v12}) +_ = v13 +var v14 any +func() { +defer func() { +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, nil) +}() +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("load-one")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v3, true, true}) +v14 = v22 +}() +_ = v14 +return v3 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -18252,333 +18059,82 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// denominator +// complement { -v1 := reflect.TypeOf((*big9.Int)(nil)) -v0 := lang.NewSymbol("denominator").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("r"))), lang.NewKeyword("doc"), "Returns the denominator part of a Ratio.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3591), lang.NewKeyword("end-line"), int(3591))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { +v0 := lang.NewSymbol("complement").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Takes a fn f and returns a fn that takes the same arguments as f,\n has the same effects, if any, and returns the opposite truth value.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1428), lang.NewKeyword("end-line"), int(1428))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v4 := args[0] -v5, ok := lang.FieldOrMethod(v4, "denominator") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "denominator"))) -} -var v6 any -switch reflect.TypeOf(v5).Kind() { -case reflect.Func: - v6 = lang.Apply(v5, nil) -default: - v6 = v5 +v3 := args[0] +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("not")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -return v6 -}) -v4 := reflect.TypeOf((*big9.Int)(nil)) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +v7 := v6.Get() +v8 := lang.Apply(v3, nil) +v9 := lang.Apply(v7, []any{v8}) +return v9 + case 1: +v5 := args[0] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("not")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } +v8 := v7.Get() +v9 := lang.Apply(v3, []any{v5}) +v10 := lang.Apply(v8, []any{v9}) +return v10 + case 2: +v5 := args[0] +v6 := args[1] +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("not")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -// when-let -{ -v0 := lang.NewSymbol("when-let").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "bindings => binding-form test\n\n When test is true, evaluates body with binding-form bound to the value of test", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1859), lang.NewKeyword("end-line"), int(1859))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { +v9 := v8.Get() +v10 := lang.Apply(v3, []any{v5, v6}) +v11 := lang.Apply(v9, []any{v10}) +return v11 default: - if len(args) < 3 { + if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -var v7 any +v5 := args[0] +v6 := args[1] +v7 := lang.NewList(args[2:]...) v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) +v9 := v8.FindInternedVar(lang.NewSymbol("not")) if v9.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } v10 := v9.Get() -v11 := lang.Apply(v10, []any{v5}) -if lang.IsTruthy(v11) { -v7 = nil -} else { -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("str")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("first")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v3}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("meta")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) -v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) -v28 := lang.Apply(lang1.NewIllegalArgumentError, []any{v27}) -panic(v28) -} -_ = v7 -var v29 any -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("=")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("count")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v5}) -v37 := lang.Apply(v32, []any{int64(2), v36}) -if lang.IsTruthy(v37) { -v29 = nil -} else { -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("str")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("first")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v3}) -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("meta")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v3}) -v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) -v53 := lang.Apply(v40, []any{v44, " requires ", "exactly 2 forms in binding vector", " in ", v47, ":", v52}) -v54 := lang.Apply(lang1.NewIllegalArgumentError, []any{v53}) -panic(v54) -} -_ = v29 -_ = nil -v56 := lang.Apply(v5, []any{int64(0)}) -var v55 any = v56 -_ = v55 -v58 := lang.Apply(v5, []any{int64(1)}) -var v57 any = v58 -_ = v57 -v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v61 := v60.FindInternedVar(lang.NewSymbol("seq")) -if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) -} -v62 := v61.Get() -v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v64 := v63.FindInternedVar(lang.NewSymbol("concat")) -if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) -} -v65 := v64.Get() -v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v67 := v66.FindInternedVar(lang.NewSymbol("list")) -if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) -} -v68 := v67.Get() -v69 := lang.Apply(v68, []any{lang.NewSymbol("glojure.core/let")}) -v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v71 := v70.FindInternedVar(lang.NewSymbol("list")) -if v71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) -} -v72 := v71.Get() -v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v74 := v73.FindInternedVar(lang.NewSymbol("apply")) -if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) -} -v75 := v74.Get() -v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v77 := v76.FindInternedVar(lang.NewSymbol("vector")) -if v77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) -} -v78 := v77.Get() -v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v80 := v79.FindInternedVar(lang.NewSymbol("seq")) -if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) -} -v81 := v80.Get() -v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v83 := v82.FindInternedVar(lang.NewSymbol("concat")) -if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) -} -v84 := v83.Get() -v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v86 := v85.FindInternedVar(lang.NewSymbol("list")) -if v86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) -} -v87 := v86.Get() -v88 := lang.Apply(v87, []any{lang.NewSymbol("temp__0__auto__")}) -v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v90 := v89.FindInternedVar(lang.NewSymbol("list")) -if v90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) -} -v91 := v90.Get() -v92 := lang.Apply(v91, []any{v57}) -v93 := lang.Apply(v84, []any{v88, v92}) -v94 := lang.Apply(v81, []any{v93}) -v95 := lang.Apply(v75, []any{v78, v94}) -v96 := lang.Apply(v72, []any{v95}) -v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v98 := v97.FindInternedVar(lang.NewSymbol("list")) -if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) -} -v99 := v98.Get() -v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v101 := v100.FindInternedVar(lang.NewSymbol("seq")) -if v101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) -} -v102 := v101.Get() -v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v104 := v103.FindInternedVar(lang.NewSymbol("concat")) -if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) -} -v105 := v104.Get() -v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v107 := v106.FindInternedVar(lang.NewSymbol("list")) -if v107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) -} -v108 := v107.Get() -v109 := lang.Apply(v108, []any{lang.NewSymbol("glojure.core/when")}) -v110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v111 := v110.FindInternedVar(lang.NewSymbol("list")) -if v111.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v111))) -} -v112 := v111.Get() -v113 := lang.Apply(v112, []any{lang.NewSymbol("temp__0__auto__")}) -v114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v115 := v114.FindInternedVar(lang.NewSymbol("list")) -if v115.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v115))) -} -v116 := v115.Get() -v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v118 := v117.FindInternedVar(lang.NewSymbol("seq")) -if v118.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) -} -v119 := v118.Get() -v120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v121 := v120.FindInternedVar(lang.NewSymbol("concat")) -if v121.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v121))) -} -v122 := v121.Get() -v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v124 := v123.FindInternedVar(lang.NewSymbol("list")) -if v124.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) -} -v125 := v124.Get() -v126 := lang.Apply(v125, []any{lang.NewSymbol("glojure.core/let")}) -v127 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v128 := v127.FindInternedVar(lang.NewSymbol("list")) -if v128.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v128))) -} -v129 := v128.Get() -v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v131 := v130.FindInternedVar(lang.NewSymbol("apply")) -if v131.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) -} -v132 := v131.Get() -v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v134 := v133.FindInternedVar(lang.NewSymbol("vector")) -if v134.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) -} -v135 := v134.Get() -v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v137 := v136.FindInternedVar(lang.NewSymbol("seq")) -if v137.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) -} -v138 := v137.Get() -v139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v140 := v139.FindInternedVar(lang.NewSymbol("concat")) -if v140.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v140))) -} -v141 := v140.Get() -v142 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v143 := v142.FindInternedVar(lang.NewSymbol("list")) -if v143.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v143))) -} -v144 := v143.Get() -v145 := lang.Apply(v144, []any{v55}) -v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v147 := v146.FindInternedVar(lang.NewSymbol("list")) -if v147.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("apply")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v148 := v147.Get() -v149 := lang.Apply(v148, []any{lang.NewSymbol("temp__0__auto__")}) -v150 := lang.Apply(v141, []any{v145, v149}) -v151 := lang.Apply(v138, []any{v150}) -v152 := lang.Apply(v132, []any{v135, v151}) -v153 := lang.Apply(v129, []any{v152}) -v154 := lang.Apply(v122, []any{v126, v153, v6}) -v155 := lang.Apply(v119, []any{v154}) -v156 := lang.Apply(v116, []any{v155}) -v157 := lang.Apply(v105, []any{v109, v113, v156}) -v158 := lang.Apply(v102, []any{v157}) -v159 := lang.Apply(v99, []any{v158}) -v160 := lang.Apply(v65, []any{v69, v96, v159}) -v161 := lang.Apply(v62, []any{v160}) -return v161 +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v3, v5, v6, v7}) +v15 := lang.Apply(v10, []any{v14}) +return v15 } }) +v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1434), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(1438), lang.NewKeyword("end-column"), int(40)) +v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v6 +}) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { @@ -18645,364 +18201,266 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// resolve +// concat { -v0 := lang.NewSymbol("resolve").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym")), lang.NewVector(lang.NewSymbol("env"), lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "same as (ns-resolve *ns* symbol) or (ns-resolve *ns* &env symbol)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4371), lang.NewKeyword("end-line"), int(4371))).(*lang.Symbol) +v0 := lang.NewSymbol("concat").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("zs"))), lang.NewKeyword("doc"), "Returns a lazy seq representing the concatenation of the elements in the supplied colls.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(711), lang.NewKeyword("end-line"), int(711))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { + case 0: +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +return nil +}) +v4 := lang.Apply(lang1.NewLazySeq, []any{v3}) +return v4 case 1: v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("ns-resolve")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +return v3 +}) +v5 := lang.Apply(lang1.NewLazySeq, []any{v4}) +return v5 + case 2: +v3 := args[0] +v4 := args[1] +var v5 lang.FnFunc +v5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("*ns*")) +v8 := v7.FindInternedVar(lang.NewSymbol("seq")) if v8.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } v9 := v8.Get() -v10 := lang.Apply(v6, []any{v9, v3}) -return v10 - case 2: -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("ns-resolve")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("*ns*")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v10 := lang.Apply(v9, []any{v3}) +var v6 any = v10 +_ = v6 +var v12 any +if lang.IsTruthy(v6) { +var v13 any +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("chunked-seq?")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v10 := v9.Get() -v11 := lang.Apply(v7, []any{v10, v3, v4}) -return v11 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v6}) +if lang.IsTruthy(v17) { +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("chunk-cons")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("chunk-first")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -// set-agent-send-off-executor! -{ -v0 := lang.NewSymbol("set-agent-send-off-executor!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("executor"))), lang.NewKeyword("doc"), "Sets the ExecutorService to be used by send-off", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(34), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2093), lang.NewKeyword("end-line"), int(2093))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -return nil -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v6}) +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("concat")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("chunk-rest")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } -// nil? -{ -v1 := reflect.TypeOf(false) -var v2 lang.FnFunc -{ // function nil?__inliner -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("list")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v30 := v29.Get() +v31 := lang.Apply(v30, []any{v6}) +v32 := lang.Apply(v27, []any{v31, v4}) +v33 := lang.Apply(v20, []any{v24, v32}) +v13 = v33 +} else { +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("cons")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } -v7 := v6.Get() -v8 := lang.Apply(v7, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Identical"), v4, nil}) -return v8 -}) -v3 := v2 -_ = v3 -} -v0 := lang.NewSymbol("nil?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v2, lang.NewKeyword("doc"), "Returns true if x is nil, false otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(435), lang.NewKeyword("end-line"), int(435))).(*lang.Symbol) -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := args[0] -v6 := lang.Apply(lang1.IsNil, []any{v5}) -return v6 -}) -v5 := reflect.TypeOf(false) -v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v5)).(lang.FnFunc) -v3 := ns.InternWithValue(v0, v4, true) -if v0.Meta() != nil { - v3.SetMeta(v0.Meta().(lang.IPersistentMap)) +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("first")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v6}) +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("concat")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } -// *loading-verbosely* -{ -v0 := lang.NewSymbol("*loading-verbosely*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5870), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(5873), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, false, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v43 := v42.Get() +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("rest")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v6}) +v48 := lang.Apply(v43, []any{v47, v4}) +v49 := lang.Apply(v36, []any{v40, v48}) +v13 = v49 } -// vector? -{ -v0 := lang.NewSymbol("vector?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x implements IPersistentVector", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(174), lang.NewKeyword("end-line"), int(178))).(*lang.Symbol) -var v2 lang.FnFunc -{ // function vector? -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v12 = v13 +} else { +v12 = v4 } -v7 := v6.Get() -v8 := lang.Apply(v7, []any{lang1.IPersistentVector, v4}) -return v8 +return v12 }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(178), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(178), lang.NewKeyword("end-column"), int(106))).(lang.FnFunc) -v3 := v2 -_ = v3 -} -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// doto -{ -v0 := lang.NewSymbol("doto").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "Evaluates x then calls all of the methods and functions with the\n value of x supplied at the front of the given arguments. The forms\n are evaluated in order. Returns x.\n\n (doto (new java.util.HashMap) (.put \"a\" 1) (.put \"b\" 2))", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3853), lang.NewKeyword("end-line"), int(3853))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { +v6 := lang.Apply(lang1.NewLazySeq, []any{v5}) +return v6 default: - if len(args) < 3 { + if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("gensym")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, nil) -var v7 any = v11 -_ = v7 +v5 := lang.NewList(args[2:]...) +var v7 lang.FnFunc +{ // function cat +v7 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v9 := args[0] +v10 := args[1] +var v11 lang.FnFunc +v11 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v14 := v13.FindInternedVar(lang.NewSymbol("seq")) if v14.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("concat")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v16 := lang.Apply(v15, []any{v12}) +var v12 any = v16 +_ = v12 +var v18 any +if lang.IsTruthy(v12) { +var v19 any +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("chunked-seq?")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v21 := v20.Get() -v22 := lang.Apply(v21, []any{lang.NewSymbol("glojure.core/let")}) -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +v22 := v21.Get() +v23 := lang.Apply(v22, []any{v12}) +if lang.IsTruthy(v23) { +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("chunk-cons")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("apply")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("chunk-first")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("vector")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +v29 := v28.Get() +v30 := lang.Apply(v29, []any{v12}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("chunk-rest")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("seq")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v12}) +v35 := lang.Apply(v8, []any{v34, v10}) +v36 := lang.Apply(v26, []any{v30, v35}) +v19 = v36 +} else { +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("cons")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -v34 := v33.Get() -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("concat")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("first")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) } -v37 := v36.Get() -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("list")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v12}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("rest")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } -v40 := v39.Get() -v41 := lang.Apply(v40, []any{v7}) -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("list")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v12}) +v48 := lang.Apply(v8, []any{v47, v10}) +v49 := lang.Apply(v39, []any{v43, v48}) +v19 = v49 } -v44 := v43.Get() -v45 := lang.Apply(v44, []any{v5}) -v46 := lang.Apply(v37, []any{v41, v45}) -v47 := lang.Apply(v34, []any{v46}) -v48 := lang.Apply(v28, []any{v31, v47}) -v49 := lang.Apply(v25, []any{v48}) -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("map")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +v18 = v19 +} else { +var v50 any +if lang.IsTruthy(v10) { +v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v52 := v51.FindInternedVar(lang.NewSymbol("first")) +if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) } -v52 := v51.Get() -var v53 lang.FnFunc -v53 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v54 := args[0] +v53 := v52.Get() +v54 := lang.Apply(v53, []any{v10}) v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v56 := v55.FindInternedVar(lang.NewSymbol("with-meta")) +v56 := v55.FindInternedVar(lang.NewSymbol("next")) if v56.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) } v57 := v56.Get() -var v58 any -v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v60 := v59.FindInternedVar(lang.NewSymbol("seq?")) -if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) -} -v61 := v60.Get() -v62 := lang.Apply(v61, []any{v54}) -if lang.IsTruthy(v62) { -v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v64 := v63.FindInternedVar(lang.NewSymbol("seq")) -if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) -} -v65 := v64.Get() -v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v67 := v66.FindInternedVar(lang.NewSymbol("concat")) -if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) -} -v68 := v67.Get() -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("list")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) -} -v71 := v70.Get() -v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v73 := v72.FindInternedVar(lang.NewSymbol("first")) -if v73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) -} -v74 := v73.Get() -v75 := lang.Apply(v74, []any{v54}) -v76 := lang.Apply(v71, []any{v75}) -v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v78 := v77.FindInternedVar(lang.NewSymbol("list")) -if v78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) -} -v79 := v78.Get() -v80 := lang.Apply(v79, []any{v7}) -v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v82 := v81.FindInternedVar(lang.NewSymbol("next")) -if v82.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) -} -v83 := v82.Get() -v84 := lang.Apply(v83, []any{v54}) -v85 := lang.Apply(v68, []any{v76, v80, v84}) -v86 := lang.Apply(v65, []any{v85}) -v58 = v86 +v58 := lang.Apply(v57, []any{v10}) +v59 := lang.Apply(v8, []any{v54, v58}) +v50 = v59 } else { -v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v88 := v87.FindInternedVar(lang.NewSymbol("seq")) -if v88.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) -} -v89 := v88.Get() -v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v91 := v90.FindInternedVar(lang.NewSymbol("concat")) -if v91.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) -} -v92 := v91.Get() -v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v94 := v93.FindInternedVar(lang.NewSymbol("list")) -if v94.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) -} -v95 := v94.Get() -v96 := lang.Apply(v95, []any{v54}) -v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v98 := v97.FindInternedVar(lang.NewSymbol("list")) -if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) -} -v99 := v98.Get() -v100 := lang.Apply(v99, []any{v7}) -v101 := lang.Apply(v92, []any{v96, v100}) -v102 := lang.Apply(v89, []any{v101}) -v58 = v102 +v50 = nil } -v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v104 := v103.FindInternedVar(lang.NewSymbol("meta")) -if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) +v18 = v50 } -v105 := v104.Get() -v106 := lang.Apply(v105, []any{v54}) -v107 := lang.Apply(v57, []any{v58, v106}) -return v107 +return v18 }) -v54 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3863), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(3868), lang.NewKeyword("end-column"), int(30)) -v55, err := lang.WithMeta(v53, v54.(lang.IPersistentMap)) +v12 := lang.Apply(lang1.NewLazySeq, []any{v11}) +return v12 +}) +v8 := v7 +_ = v8 +} +v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(726), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(735), lang.NewKeyword("end-column"), int(56)) +v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) if err != nil { panic(err) } -v56 := lang.Apply(v52, []any{v55, v6}) -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("list")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +var v6 any = v9 +_ = v6 +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("concat")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v59 := v58.Get() -v60 := lang.Apply(v59, []any{v7}) -v61 := lang.Apply(v18, []any{v22, v49, v56, v60}) -v62 := lang.Apply(v15, []any{v61}) -return v62 +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v3, v4}) +v15 := lang.Apply(v6, []any{v14, v5}) +return v15 } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -19011,103 +18469,82 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// *loaded-libs* -{ -v0 := lang.NewSymbol("*loaded-libs*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5860), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(5863), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, nil, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// intern +// cond { -v0 := lang.NewSymbol("intern").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name"), lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Finds or creates a var named by the symbol name in the namespace\n ns (which can be a symbol or a namespace), setting its root binding\n to val if supplied. The namespace must exist. The var will adopt any\n metadata from the name symbol. Returns the var.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6354), lang.NewKeyword("end-line"), int(6354))).(*lang.Symbol) +v0 := lang.NewSymbol("cond").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes a set of test/expr pairs. It evaluates each test one at a\n time. If a test returns logical true, cond evaluates and returns\n the value of the corresponding expr and doesn't evaluate any of the\n other tests or exprs. (cond) returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(569), lang.NewKeyword("end-line"), int(569))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 2: + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] v4 := args[1] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("the-ns")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +v5 := lang.NewList(args[2:]...) +var v6 any +if lang.IsTruthy(v5) { +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("list")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v3}) -v10 := lang.Apply(nil, []any{v9, v4}) -var v5 any = v10 -_ = v5 -var v12 any -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("meta")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("first")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v4}) -if lang.IsTruthy(v16) { -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("meta")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +v12 := v11.Get() +v13 := lang.Apply(v12, []any{v5}) +var v14 any +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("next")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v4}) -v21, _ := lang.FieldOrMethod(v5, "setMeta") -if reflect.TypeOf(v21).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMeta is not a function"))) +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v5}) +if lang.IsTruthy(v18) { +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("second")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v22 := lang.Apply(v21, []any{v20}) -v12 = v22 +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v5}) +v14 = v22 } else { -v12 = nil -} -_ = v12 -return v5 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("the-ns")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v23 := lang.Apply(lang1.NewIllegalArgumentError, []any{"cond requires an even number of forms"}) +panic(v23) } -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v3}) -v11 := lang.Apply(nil, []any{v10, v4, v5}) -var v6 any = v11 -_ = v6 -var v13 any -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("meta")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("cons")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v4}) -if lang.IsTruthy(v17) { -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("meta")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("next")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v20 := v19.Get() -v21 := lang.Apply(v20, []any{v4}) -v22, _ := lang.FieldOrMethod(v6, "setMeta") -if reflect.TypeOf(v22).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMeta is not a function"))) +v29 := v28.Get() +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("next")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) } -v23 := lang.Apply(v22, []any{v21}) -v13 = v23 +v32 := v31.Get() +v33 := lang.Apply(v32, []any{v5}) +v34 := lang.Apply(v29, []any{v33}) +v35 := lang.Apply(v26, []any{lang.NewSymbol("glojure.core/cond"), v34}) +v36 := lang.Apply(v9, []any{lang.NewSymbol("if"), v13, v14, v35}) +v6 = v36 } else { -v13 = nil +v6 = nil } -_ = v13 return v6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -19116,325 +18553,274 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// prep-ints +// cond-> { -v0 := lang.NewSymbol("prep-ints").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tests"), lang.NewSymbol("thens"))), lang.NewKeyword("doc"), "Takes a sequence of int-sized test constants and a corresponding sequence of\n then expressions. Returns a tuple of [shift mask case-map switch-type] where\n case-map is a map of int case values to [test then] tuples, and switch-type\n is either :sparse or :compact.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6674), lang.NewKeyword("end-line"), int(6674), lang.NewKeyword("private"), true)).(*lang.Symbol) +v0 := lang.NewSymbol("cond->").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes an expression and a set of test/form pairs. Threads expr (via ->)\n through each form for which the corresponding test\n expression is true. Note that, unlike cond branching, cond-> threading does\n not short circuit after the first true test expression.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7607), lang.NewKeyword("end-line"), int(7607))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] v4 := args[1] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("fits-table?")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v3}) -if lang.IsTruthy(v9) { -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("case-map")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v5 := args[2] +v6 := lang.NewList(args[3:]...) +_ = nil +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("gensym")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v12 := v11.Get() +v10 := v9.Get() +v11 := lang.Apply(v10, nil) +var v7 any = v11 +_ = v7 v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("int")) +v14 := v13.FindInternedVar(lang.NewSymbol("map")) if v14.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("int")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v12, []any{v15, v18, v3, v4}) -v20 := lang.NewVector(int64(0), int64(0), v19, lang.NewKeyword("compact")) -v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6682), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(6682), lang.NewKeyword("end-column"), int(49)) -v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v5 = v22 -} else { -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("maybe-min-hash")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("map")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("int")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v30, []any{v33, v3}) -v35 := lang.Apply(v27, []any{v34}) -var v24 any = v35 -_ = v24 -var v37 any -if lang.IsTruthy(v24) { -v37 = v24 -} else { -v38 := lang.NewVector(int64(0), int64(0)) -v39 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6683), lang.NewKeyword("column"), int(61), lang.NewKeyword("end-line"), int(6683), lang.NewKeyword("end-column"), int(65)) -v40, err := lang.WithMeta(v38, v39.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v37 = v40 +var v16 lang.FnFunc +v16 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v17 := args[0] +var v18 any = v17 +_ = v18 +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("nth")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -var v23 any = v37 -_ = v23 +v22 := v21.Get() +v23 := lang.Apply(v22, []any{v18, int64(0), nil}) +var v19 any = v23 +_ = v19 v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v26 := v25.FindInternedVar(lang.NewSymbol("nth")) if v26.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } v27 := v26.Get() -v28 := lang.Apply(v27, []any{v23, int64(0), nil}) +v28 := lang.Apply(v27, []any{v18, int64(1), nil}) var v24 any = v28 _ = v24 v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("nth")) +v31 := v30.FindInternedVar(lang.NewSymbol("seq")) if v31.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) } v32 := v31.Get() -v33 := lang.Apply(v32, []any{v23, int64(1), nil}) -var v29 any = v33 -_ = v29 -var v35 any +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("concat")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("zero?")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) if v37.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) } v38 := v37.Get() -v39 := lang.Apply(v38, []any{v29}) -if lang.IsTruthy(v39) { +v39 := lang.Apply(v38, []any{lang.NewSymbol("if")}) v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("case-map")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) if v41.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) } v42 := v41.Get() -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("int")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +v43 := lang.Apply(v42, []any{v19}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } -v45 := v44.Get() -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("int")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +v46 := v45.Get() +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("seq")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) } -v48 := v47.Get() -v49 := lang.Apply(v42, []any{v45, v48, v3, v4}) -v50 := lang.NewVector(int64(0), int64(0), v49, lang.NewKeyword("sparse")) -v51 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6686), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(6686), lang.NewKeyword("end-column"), int(52)) -v52, err := lang.WithMeta(v50, v51.(lang.IPersistentMap)) -if err != nil { - panic(err) +v49 := v48.Get() +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("concat")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) } -v35 = v52 -} else { +v52 := v51.Get() v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("case-map")) +v54 := v53.FindInternedVar(lang.NewSymbol("list")) if v54.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) } v55 := v54.Get() -var v56 lang.FnFunc -v56 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v57 := args[0] -v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v59 := v58.FindInternedVar(lang.NewSymbol("shift-mask")) -if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) +v56 := lang.Apply(v55, []any{lang.NewSymbol("glojure.core/->")}) +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("list")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) } -v60 := v59.Get() +v59 := v58.Get() +v60 := lang.Apply(v59, []any{v7}) v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("int")) +v62 := v61.FindInternedVar(lang.NewSymbol("list")) if v62.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) } v63 := v62.Get() -v64 := lang.Apply(v63, []any{v57}) -v65 := lang.Apply(v60, []any{v24, v29, v64}) -return v65 -}) -v57 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6688), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(6688), lang.NewKeyword("end-column"), int(62)) -v58, err := lang.WithMeta(v56, v57.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v60 := v59.FindInternedVar(lang.NewSymbol("int")) -if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) +v64 := lang.Apply(v63, []any{v24}) +v65 := lang.Apply(v52, []any{v56, v60, v64}) +v66 := lang.Apply(v49, []any{v65}) +v67 := lang.Apply(v46, []any{v66}) +v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v69 := v68.FindInternedVar(lang.NewSymbol("list")) +if v69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) } -v61 := v60.Get() -v62 := lang.Apply(v55, []any{v58, v61, v3, v4}) -v63 := lang.NewVector(v24, v29, v62, lang.NewKeyword("compact")) -v64 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6688), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(6688), lang.NewKeyword("end-column"), int(89)) -v65, err := lang.WithMeta(v63, v64.(lang.IPersistentMap)) +v70 := v69.Get() +v71 := lang.Apply(v70, []any{v7}) +v72 := lang.Apply(v35, []any{v39, v43, v67, v71}) +v73 := lang.Apply(v32, []any{v72}) +return v73 +}) +v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7616), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7616), lang.NewKeyword("end-column"), int(66)) +v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) if err != nil { panic(err) } -v35 = v65 -} -v5 = v35 +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("partition")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v21 := v20.Get() +v22 := lang.Apply(v21, []any{int64(2), v6}) +v23 := lang.Apply(v15, []any{v18, v22}) +var v12 any = v23 +_ = v12 +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("seq")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("concat")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } -// persistent! -{ -v0 := lang.NewSymbol("persistent!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a new, persistent version of the transient collection, in\n constant time. The transient collection cannot be used after this\n call, any such use will throw an exception.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3350), lang.NewKeyword("end-line"), int(3350))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, ok := lang.FieldOrMethod(v3, "Persistent") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "Persistent"))) +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -var v5 any -switch reflect.TypeOf(v4).Kind() { -case reflect.Func: - v5 = lang.Apply(v4, nil) -default: - v5 = v4 +v33 := v32.Get() +v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/let")}) +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("list")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) } -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v37 := v36.Get() +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("apply")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) } +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("vector")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } -// print-simple -{ -v0 := lang.NewSymbol("print-simple").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(81), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(81), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("print-meta")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v43 := v42.Get() +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("seq")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3, v4}) -_ = v8 -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("str")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +v46 := v45.Get() +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("concat")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) } -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v3}) -v13 := lang.Apply(lang1.WriteWriter, []any{v4, v12}) -return v13 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v49 := v48.Get() +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("list")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) } +v52 := v51.Get() +v53 := lang.Apply(v52, []any{v7}) +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("list")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) } -// bound-fn -{ -v0 := lang.NewSymbol("bound-fn").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("fntail"))), lang.NewKeyword("doc"), "Returns a function defined by the given fntail, which will install the\n same bindings in effect as in the thread at the time bound-fn was called.\n This may be used to define a helper function which runs on a different\n thread, but needs the same bindings in place.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(2004), lang.NewKeyword("end-line"), int(2004))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("seq")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +v56 := v55.Get() +v57 := lang.Apply(v56, []any{v5}) +v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v59 := v58.FindInternedVar(lang.NewSymbol("interleave")) +if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) } -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("concat")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +v60 := v59.Get() +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("repeat")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) } -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("list")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +v63 := v62.Get() +v64 := lang.Apply(v63, []any{v7}) +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("butlast")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) } -v14 := v13.Get() -v15 := lang.Apply(v14, []any{lang.NewSymbol("glojure.core/bound-fn*")}) -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("list")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +v67 := v66.Get() +v68 := lang.Apply(v67, []any{v12}) +v69 := lang.Apply(v60, []any{v64, v68}) +v70 := lang.Apply(v49, []any{v53, v57, v69}) +v71 := lang.Apply(v46, []any{v70}) +v72 := lang.Apply(v40, []any{v43, v71}) +v73 := lang.Apply(v37, []any{v72}) +v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v75 := v74.FindInternedVar(lang.NewSymbol("list")) +if v75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) } -v18 := v17.Get() -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("seq")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v76 := v75.Get() +var v77 any +v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v79 := v78.FindInternedVar(lang.NewSymbol("empty?")) +if v79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) } -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("concat")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v80 := v79.Get() +v81 := lang.Apply(v80, []any{v12}) +if lang.IsTruthy(v81) { +v77 = v7 +} else { +v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v83 := v82.FindInternedVar(lang.NewSymbol("last")) +if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) } -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("list")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +v84 := v83.Get() +v85 := lang.Apply(v84, []any{v12}) +v77 = v85 } -v27 := v26.Get() -v28 := lang.Apply(v27, []any{lang.NewSymbol("glojure.core/fn")}) -v29 := lang.Apply(v24, []any{v28, v5}) -v30 := lang.Apply(v21, []any{v29}) -v31 := lang.Apply(v18, []any{v30}) -v32 := lang.Apply(v11, []any{v15, v31}) -v33 := lang.Apply(v8, []any{v32}) -return v33 +v86 := lang.Apply(v76, []any{v77}) +v87 := lang.Apply(v30, []any{v34, v73, v86}) +v88 := lang.Apply(v27, []any{v87}) +return v88 } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -19443,428 +18829,274 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// volatile! -{ -v1 := reflect.TypeOf((*lang1.Volatile)(nil)).Elem() -v0 := lang.NewSymbol("volatile!").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Creates and returns a Volatile with an initial value of val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2517), lang.NewKeyword("end-line"), int(2517))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := lang.Apply(lang1.NewVolatile, []any{v4}) -return v5 -}) -v4 := reflect.TypeOf((*lang1.Volatile)(nil)).Elem() -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// if-let +// cond->> { -v0 := lang.NewSymbol("if-let").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("then")), lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("then"), lang.NewSymbol("else"), lang.NewSymbol("&"), lang.NewSymbol("oldform"))), lang.NewKeyword("doc"), "bindings => binding-form test\n\n If test is true, evaluates then with binding-form bound to the value of \n test, if not, yields else", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1839), lang.NewKeyword("end-line"), int(1839))).(*lang.Symbol) +v0 := lang.NewSymbol("cond->>").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes an expression and a set of test/form pairs. Threads expr (via ->>)\n through each form for which the corresponding test expression\n is true. Note that, unlike cond branching, cond->> threading does not short circuit\n after the first true test expression.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7624), lang.NewKeyword("end-line"), int(7624))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 4: + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] v4 := args[1] v5 := args[2] -v6 := args[3] -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("seq")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("concat")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v6 := lang.NewList(args[3:]...) +_ = nil +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("gensym")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v12 := v11.Get() +v10 := v9.Get() +v11 := lang.Apply(v10, nil) +var v7 any = v11 +_ = v7 v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("list")) +v14 := v13.FindInternedVar(lang.NewSymbol("map")) if v14.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } v15 := v14.Get() -v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/if-let")}) -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("list")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v5}) -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("list")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +var v16 lang.FnFunc +v16 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v17 := args[0] +var v18 any = v17 +_ = v18 +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("nth")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v6}) +v22 := v21.Get() +v23 := lang.Apply(v22, []any{v18, int64(0), nil}) +var v19 any = v23 +_ = v19 v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("list")) +v26 := v25.FindInternedVar(lang.NewSymbol("nth")) if v26.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } v27 := v26.Get() -v28 := lang.Apply(v27, []any{nil}) -v29 := lang.Apply(v12, []any{v16, v20, v24, v28}) -v30 := lang.Apply(v9, []any{v29}) -return v30 - default: - if len(args) < 5 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := args[4] -v8 := lang.NewList(args[5:]...) -var v9 any -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("vector?")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{v5}) -if lang.IsTruthy(v13) { -v9 = nil -} else { -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("str")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("first")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v3}) -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("*ns*")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("meta")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v3}) -v28 := lang.Apply(lang.NewKeyword("line"), []any{v27}) -v29 := lang.Apply(v16, []any{v20, " requires ", "a vector for its binding", " in ", v23, ":", v28}) -v30 := lang.Apply(lang1.NewIllegalArgumentError, []any{v29}) -panic(v30) +v28 := lang.Apply(v27, []any{v18, int64(1), nil}) +var v24 any = v28 +_ = v24 +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("seq")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) } -_ = v9 -var v31 any -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("nil?")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("concat")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) } -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v8}) -if lang.IsTruthy(v35) { -v31 = nil -} else { +v35 := v34.Get() v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("str")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) if v37.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) } v38 := v37.Get() -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("first")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +v39 := lang.Apply(v38, []any{lang.NewSymbol("if")}) +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) } -v41 := v40.Get() -v42 := lang.Apply(v41, []any{v3}) -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("*ns*")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v19}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } -v45 := v44.Get() -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("meta")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +v46 := v45.Get() +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("seq")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) } -v48 := v47.Get() -v49 := lang.Apply(v48, []any{v3}) -v50 := lang.Apply(lang.NewKeyword("line"), []any{v49}) -v51 := lang.Apply(v38, []any{v42, " requires ", "1 or 2 forms after binding vector", " in ", v45, ":", v50}) -v52 := lang.Apply(lang1.NewIllegalArgumentError, []any{v51}) -panic(v52) +v49 := v48.Get() +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("concat")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) } -_ = v31 -var v53 any -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("=")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +v52 := v51.Get() +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("list")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) } -v56 := v55.Get() +v55 := v54.Get() +v56 := lang.Apply(v55, []any{lang.NewSymbol("glojure.core/->>")}) v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("count")) +v58 := v57.FindInternedVar(lang.NewSymbol("list")) if v58.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) } v59 := v58.Get() -v60 := lang.Apply(v59, []any{v5}) -v61 := lang.Apply(v56, []any{int64(2), v60}) -if lang.IsTruthy(v61) { -v53 = nil -} else { -v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v63 := v62.FindInternedVar(lang.NewSymbol("str")) -if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) -} -v64 := v63.Get() -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("first")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) -} -v67 := v66.Get() -v68 := lang.Apply(v67, []any{v3}) -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("*ns*")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) -} -v71 := v70.Get() -v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v73 := v72.FindInternedVar(lang.NewSymbol("meta")) -if v73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) -} -v74 := v73.Get() -v75 := lang.Apply(v74, []any{v3}) -v76 := lang.Apply(lang.NewKeyword("line"), []any{v75}) -v77 := lang.Apply(v64, []any{v68, " requires ", "exactly 2 forms in binding vector", " in ", v71, ":", v76}) -v78 := lang.Apply(lang1.NewIllegalArgumentError, []any{v77}) -panic(v78) -} -_ = v53 -_ = nil -v80 := lang.Apply(v5, []any{int64(0)}) -var v79 any = v80 -_ = v79 -v82 := lang.Apply(v5, []any{int64(1)}) -var v81 any = v82 -_ = v81 -v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v85 := v84.FindInternedVar(lang.NewSymbol("seq")) -if v85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) -} -v86 := v85.Get() -v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v88 := v87.FindInternedVar(lang.NewSymbol("concat")) -if v88.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) -} -v89 := v88.Get() -v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v91 := v90.FindInternedVar(lang.NewSymbol("list")) -if v91.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) -} -v92 := v91.Get() -v93 := lang.Apply(v92, []any{lang.NewSymbol("glojure.core/let")}) -v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v95 := v94.FindInternedVar(lang.NewSymbol("list")) -if v95.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) -} -v96 := v95.Get() -v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v98 := v97.FindInternedVar(lang.NewSymbol("apply")) -if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) -} -v99 := v98.Get() -v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v101 := v100.FindInternedVar(lang.NewSymbol("vector")) -if v101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) -} -v102 := v101.Get() -v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v104 := v103.FindInternedVar(lang.NewSymbol("seq")) -if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) -} -v105 := v104.Get() -v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v107 := v106.FindInternedVar(lang.NewSymbol("concat")) -if v107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) +v60 := lang.Apply(v59, []any{v7}) +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("list")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) } -v108 := v107.Get() -v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v110 := v109.FindInternedVar(lang.NewSymbol("list")) -if v110.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) +v63 := v62.Get() +v64 := lang.Apply(v63, []any{v24}) +v65 := lang.Apply(v52, []any{v56, v60, v64}) +v66 := lang.Apply(v49, []any{v65}) +v67 := lang.Apply(v46, []any{v66}) +v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v69 := v68.FindInternedVar(lang.NewSymbol("list")) +if v69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) } -v111 := v110.Get() -v112 := lang.Apply(v111, []any{lang.NewSymbol("temp__0__auto__")}) -v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v114 := v113.FindInternedVar(lang.NewSymbol("list")) -if v114.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) +v70 := v69.Get() +v71 := lang.Apply(v70, []any{v7}) +v72 := lang.Apply(v35, []any{v39, v43, v67, v71}) +v73 := lang.Apply(v32, []any{v72}) +return v73 +}) +v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7633), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7633), lang.NewKeyword("end-column"), int(67)) +v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v115 := v114.Get() -v116 := lang.Apply(v115, []any{v81}) -v117 := lang.Apply(v108, []any{v112, v116}) -v118 := lang.Apply(v105, []any{v117}) -v119 := lang.Apply(v99, []any{v102, v118}) -v120 := lang.Apply(v96, []any{v119}) -v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v122 := v121.FindInternedVar(lang.NewSymbol("list")) -if v122.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("partition")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v123 := v122.Get() -v124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v125 := v124.FindInternedVar(lang.NewSymbol("seq")) -if v125.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v125))) +v21 := v20.Get() +v22 := lang.Apply(v21, []any{int64(2), v6}) +v23 := lang.Apply(v15, []any{v18, v22}) +var v12 any = v23 +_ = v12 +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("seq")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -v126 := v125.Get() -v127 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v128 := v127.FindInternedVar(lang.NewSymbol("concat")) -if v128.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v128))) +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("concat")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } -v129 := v128.Get() -v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v131 := v130.FindInternedVar(lang.NewSymbol("list")) -if v131.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -v132 := v131.Get() -v133 := lang.Apply(v132, []any{lang.NewSymbol("if")}) -v134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v135 := v134.FindInternedVar(lang.NewSymbol("list")) -if v135.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v135))) +v33 := v32.Get() +v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/let")}) +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("list")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) } -v136 := v135.Get() -v137 := lang.Apply(v136, []any{lang.NewSymbol("temp__0__auto__")}) -v138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v139 := v138.FindInternedVar(lang.NewSymbol("list")) -if v139.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v139))) +v37 := v36.Get() +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("apply")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) } -v140 := v139.Get() -v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v142 := v141.FindInternedVar(lang.NewSymbol("seq")) -if v142.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("vector")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } -v143 := v142.Get() -v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v145 := v144.FindInternedVar(lang.NewSymbol("concat")) -if v145.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) +v43 := v42.Get() +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("seq")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } -v146 := v145.Get() -v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v148 := v147.FindInternedVar(lang.NewSymbol("list")) -if v148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) +v46 := v45.Get() +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("concat")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) } -v149 := v148.Get() -v150 := lang.Apply(v149, []any{lang.NewSymbol("glojure.core/let")}) -v151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v152 := v151.FindInternedVar(lang.NewSymbol("list")) -if v152.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v152))) +v49 := v48.Get() +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("list")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) } -v153 := v152.Get() -v154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v155 := v154.FindInternedVar(lang.NewSymbol("apply")) -if v155.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v155))) +v52 := v51.Get() +v53 := lang.Apply(v52, []any{v7}) +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("list")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) } -v156 := v155.Get() -v157 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v158 := v157.FindInternedVar(lang.NewSymbol("vector")) -if v158.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v158))) +v56 := v55.Get() +v57 := lang.Apply(v56, []any{v5}) +v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v59 := v58.FindInternedVar(lang.NewSymbol("interleave")) +if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) } -v159 := v158.Get() -v160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v161 := v160.FindInternedVar(lang.NewSymbol("seq")) -if v161.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v161))) +v60 := v59.Get() +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("repeat")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) } -v162 := v161.Get() -v163 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v164 := v163.FindInternedVar(lang.NewSymbol("concat")) -if v164.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v164))) +v63 := v62.Get() +v64 := lang.Apply(v63, []any{v7}) +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("butlast")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) } -v165 := v164.Get() -v166 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v167 := v166.FindInternedVar(lang.NewSymbol("list")) -if v167.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v167))) +v67 := v66.Get() +v68 := lang.Apply(v67, []any{v12}) +v69 := lang.Apply(v60, []any{v64, v68}) +v70 := lang.Apply(v49, []any{v53, v57, v69}) +v71 := lang.Apply(v46, []any{v70}) +v72 := lang.Apply(v40, []any{v43, v71}) +v73 := lang.Apply(v37, []any{v72}) +v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v75 := v74.FindInternedVar(lang.NewSymbol("list")) +if v75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) } -v168 := v167.Get() -v169 := lang.Apply(v168, []any{v79}) -v170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v171 := v170.FindInternedVar(lang.NewSymbol("list")) -if v171.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v171))) +v76 := v75.Get() +var v77 any +v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v79 := v78.FindInternedVar(lang.NewSymbol("empty?")) +if v79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) } -v172 := v171.Get() -v173 := lang.Apply(v172, []any{lang.NewSymbol("temp__0__auto__")}) -v174 := lang.Apply(v165, []any{v169, v173}) -v175 := lang.Apply(v162, []any{v174}) -v176 := lang.Apply(v156, []any{v159, v175}) -v177 := lang.Apply(v153, []any{v176}) -v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v179 := v178.FindInternedVar(lang.NewSymbol("list")) -if v179.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) +v80 := v79.Get() +v81 := lang.Apply(v80, []any{v12}) +if lang.IsTruthy(v81) { +v77 = v7 +} else { +v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v83 := v82.FindInternedVar(lang.NewSymbol("last")) +if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) } -v180 := v179.Get() -v181 := lang.Apply(v180, []any{v6}) -v182 := lang.Apply(v146, []any{v150, v177, v181}) -v183 := lang.Apply(v143, []any{v182}) -v184 := lang.Apply(v140, []any{v183}) -v185 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v186 := v185.FindInternedVar(lang.NewSymbol("list")) -if v186.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v186))) +v84 := v83.Get() +v85 := lang.Apply(v84, []any{v12}) +v77 = v85 } -v187 := v186.Get() -v188 := lang.Apply(v187, []any{v7}) -v189 := lang.Apply(v129, []any{v133, v137, v184, v188}) -v190 := lang.Apply(v126, []any{v189}) -v191 := lang.Apply(v123, []any{v190}) -v192 := lang.Apply(v89, []any{v93, v120, v191}) -v193 := lang.Apply(v86, []any{v192}) -return v193 +v86 := lang.Apply(v76, []any{v77}) +v87 := lang.Apply(v30, []any{v34, v73, v86}) +v88 := lang.Apply(v27, []any{v87}) +return v88 } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -19873,780 +19105,713 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// *repl* -{ -v0 := lang.NewSymbol("*repl*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6331), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(6334), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, false, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// send-via +// condp { -v0 := lang.NewSymbol("send-via").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("executor"), lang.NewSymbol("a"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Dispatch an action to an agent. Returns the agent immediately.\n Subsequently, in a thread supplied by executor, the state of the agent\n will be set to the value of:\n\n (apply action-fn state-of-agent args)", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2099), lang.NewKeyword("end-line"), int(2099))).(*lang.Symbol) +v0 := lang.NewSymbol("condp").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes a binary predicate, an expression, and a set of clauses.\n Each clause can take the form of either:\n\n test-expr result-expr\n\n test-expr :>> result-fn\n\n Note :>> is an ordinary keyword.\n\n For each clause, (pred test-expr expr) is evaluated. If it returns\n logical true, the clause is a match. If a binary clause matches, the\n result-expr is returned, if a ternary clause matches, its result-fn,\n which must be a unary function, is called with the result of the\n predicate as its argument, the result of that call being the return\n value of condp. A single default expression can follow the clauses,\n and its value will be returned if no clause matches. If no default\n expression is provided and no clause matches, an\n IllegalArgumentException is thrown.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6396), lang.NewKeyword("end-line"), int(6396))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 3 { + if len(args) < 4 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] v4 := args[1] v5 := args[2] -v6 := lang.NewList(args[3:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("push-thread-bindings")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("hash-map")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*agent*")) -v15 := lang.Apply(v13, []any{v14, v4}) -v16 := lang.Apply(v10, []any{v15}) -_ = v16 -var v17 any -func() { -defer func() { -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v20, nil) -}() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("binding-conveyor-fn")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v5}) -v17 = v25 -}() -v7, _ := lang.FieldOrMethod(v4, "dispatch") -if reflect.TypeOf(v7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("dispatch is not a function"))) -} -v8 := lang.Apply(v7, []any{v17, v6, v3}) -return v8 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} +v6 := args[3] +v7 := lang.NewList(args[4:]...) +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("gensym")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -// ->> -{ -v0 := lang.NewSymbol("->>").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "Threads the expr through the forms. Inserts x as the\n last item in the first form, making a list of it if it is not a\n list already. If there are more forms, inserts the first form as the\n last item in second form, etc.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1691), lang.NewKeyword("end-line"), int(1691))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -var v7 any = v7 -_ = v7 -var v8 any = v8 +v11 := v10.Get() +v12 := lang.Apply(v11, []any{"pred__"}) +var v8 any = v12 _ = v8 -var v9 any -for { -var v10 any -if lang.IsTruthy(v8) { -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("first")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v8}) -var v11 any = v15 -_ = v11 -var v17 any -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("seq?")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v20, []any{v11}) -if lang.IsTruthy(v21) { -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("with-meta")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("gensym")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v24 := v23.Get() +v16 := v15.Get() +v17 := lang.Apply(v16, []any{"expr__"}) +var v13 any = v17 +_ = v13 +var v19 lang.FnFunc +{ // function emit +v19 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v21 := args[0] +v22 := args[1] +v23 := args[2] v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("seq")) +v26 := v25.FindInternedVar(lang.NewSymbol("split-at")) if v26.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("concat")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +var v28 any +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("=")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) } -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v31 := v30.Get() +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("second")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) } -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("first")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v23}) +v36 := lang.Apply(v31, []any{lang.NewKeyword(">>"), v35}) +if lang.IsTruthy(v36) { +v28 = int64(3) +} else { +v28 = int64(2) } -v36 := v35.Get() -v37 := lang.Apply(v36, []any{v11}) -v38 := lang.Apply(v33, []any{v37}) +v37 := lang.Apply(v27, []any{v28, v23}) +var v24 any = v37 +_ = v24 v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("next")) +v40 := v39.FindInternedVar(lang.NewSymbol("nth")) if v40.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) } v41 := v40.Get() -v42 := lang.Apply(v41, []any{v11}) -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("list")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +v42 := lang.Apply(v41, []any{v24, int64(0), nil}) +var v38 any = v42 +_ = v38 +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("nth")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } -v45 := v44.Get() -v46 := lang.Apply(v45, []any{v7}) -v47 := lang.Apply(v30, []any{v38, v42, v46}) -v48 := lang.Apply(v27, []any{v47}) +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v38, int64(0), nil}) +var v43 any = v47 +_ = v43 v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v50 := v49.FindInternedVar(lang.NewSymbol("meta")) +v50 := v49.FindInternedVar(lang.NewSymbol("nth")) if v50.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) } v51 := v50.Get() -v52 := lang.Apply(v51, []any{v11}) -v53 := lang.Apply(v24, []any{v48, v52}) -v17 = v53 -} else { +v52 := lang.Apply(v51, []any{v38, int64(1), nil}) +var v48 any = v52 +_ = v48 v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("list")) +v55 := v54.FindInternedVar(lang.NewSymbol("nth")) if v55.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) } v56 := v55.Get() -v57 := lang.Apply(v56, []any{v11, v7}) -v17 = v57 -} -var v16 any = v17 -_ = v16 -var v59 any = v16 -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("next")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) -} -v63 := v62.Get() -v64 := lang.Apply(v63, []any{v8}) -var v60 any = v64 -v7 = v59 -v8 = v60 -continue -} else { -v10 = v7 -} -v9 = v10 - break +v57 := lang.Apply(v56, []any{v38, int64(2), nil}) +var v53 any = v57 +_ = v53 +var v58 any = v38 +_ = v58 +v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v61 := v60.FindInternedVar(lang.NewSymbol("nth")) +if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) } -return v9 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v62 := v61.Get() +v63 := lang.Apply(v62, []any{v24, int64(1), nil}) +var v59 any = v63 +_ = v59 +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("count")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) } +v67 := v66.Get() +v68 := lang.Apply(v67, []any{v58}) +var v64 any = v68 +_ = v64 +var v70 any +v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v72 := v71.FindInternedVar(lang.NewSymbol("=")) +if v72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) } -// unchecked-char -{ -var v1 lang.FnFunc -{ // function unchecked-char__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v73 := v72.Get() +v74 := lang.Apply(v73, []any{int64(0), v64}) +if lang.IsTruthy(v74) { +v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v76 := v75.FindInternedVar(lang.NewSymbol("seq")) +if v76.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) } -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v77 := v76.Get() +v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v79 := v78.FindInternedVar(lang.NewSymbol("concat")) +if v79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) } -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v80 := v79.Get() +v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v82 := v81.FindInternedVar(lang.NewSymbol("list")) +if v82.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) } -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v83 := v82.Get() +v84 := lang.Apply(v83, []any{lang.NewSymbol("throw")}) +v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v86 := v85.FindInternedVar(lang.NewSymbol("list")) +if v86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v87 := v86.Get() +v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v89 := v88.FindInternedVar(lang.NewSymbol("seq")) +if v89.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) } -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +v90 := v89.Get() +v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v92 := v91.FindInternedVar(lang.NewSymbol("concat")) +if v92.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) } -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +v93 := v92.Get() +v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v95 := v94.FindInternedVar(lang.NewSymbol("list")) +if v95.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) } -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v96 := v95.Get() +v97 := lang.Apply(v96, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewIllegalArgumentError")}) +v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v99 := v98.FindInternedVar(lang.NewSymbol("list")) +if v99.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) } -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/UncheckedCharCast")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v100 := v99.Get() +v101 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v102 := v101.FindInternedVar(lang.NewSymbol("seq")) +if v102.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v102))) } -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v3}) -v35 := lang.Apply(v26, []any{v30, v34}) -v36 := lang.Apply(v23, []any{v35}) -v37 := lang.Apply(v20, []any{v36}) -v38 := lang.Apply(v9, []any{v13, v17, v37}) -v39 := lang.Apply(v6, []any{v38}) -return v39 -}) -v2 := v1 -_ = v2 +v103 := v102.Get() +v104 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v105 := v104.FindInternedVar(lang.NewSymbol("concat")) +if v105.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v105))) } -v0 := lang.NewSymbol("unchecked-char").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to char. Subject to rounding or truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3529), lang.NewKeyword("end-line"), int(3529))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5, _ := lang.FieldOrMethod(runtime3.RT, "UncheckedCharCast") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedCharCast is not a function"))) +v106 := v105.Get() +v107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v108 := v107.FindInternedVar(lang.NewSymbol("list")) +if v108.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v108))) } -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +v109 := v108.Get() +v110 := lang.Apply(v109, []any{lang.NewSymbol("glojure.core/str")}) +v111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v112 := v111.FindInternedVar(lang.NewSymbol("list")) +if v112.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v112))) } +v113 := v112.Get() +v114 := lang.Apply(v113, []any{"No matching clause: "}) +v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v116 := v115.FindInternedVar(lang.NewSymbol("list")) +if v116.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) } -// bit-or -{ -var v1 lang.FnFunc -v1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v2 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v117 := v116.Get() +v118 := lang.Apply(v117, []any{v22}) +v119 := lang.Apply(v106, []any{v110, v114, v118}) +v120 := lang.Apply(v103, []any{v119}) +v121 := lang.Apply(v100, []any{v120}) +v122 := lang.Apply(v93, []any{v97, v121}) +v123 := lang.Apply(v90, []any{v122}) +v124 := lang.Apply(v87, []any{v123}) +v125 := lang.Apply(v80, []any{v84, v124}) +v126 := lang.Apply(v77, []any{v125}) +v70 = v126 +} else { +var v127 any +v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v129 := v128.FindInternedVar(lang.NewSymbol("=")) +if v129.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v129))) } -v7 := v6.Get() -if lang.IsTruthy(v7) { -v4 = closed4 +v130 := v129.Get() +v131 := lang.Apply(v130, []any{int64(1), v64}) +if lang.IsTruthy(v131) { +v127 = v43 } else { -v4 = v3 +var v132 any +v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v134 := v133.FindInternedVar(lang.NewSymbol("=")) +if v134.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) } -var v3 any = v4 -_ = v3 -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("seq")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +v135 := v134.Get() +v136 := lang.Apply(v135, []any{int64(2), v64}) +if lang.IsTruthy(v136) { +v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v138 := v137.FindInternedVar(lang.NewSymbol("seq")) +if v138.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) } -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("concat")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +v139 := v138.Get() +v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v141 := v140.FindInternedVar(lang.NewSymbol("concat")) +if v141.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) } -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +v142 := v141.Get() +v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v144 := v143.FindInternedVar(lang.NewSymbol("list")) +if v144.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) } -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v145 := v144.Get() +v146 := lang.Apply(v145, []any{lang.NewSymbol("if")}) +v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v148 := v147.FindInternedVar(lang.NewSymbol("list")) +if v148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) } -v21 := v20.Get() -v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +v149 := v148.Get() +v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v151 := v150.FindInternedVar(lang.NewSymbol("seq")) +if v151.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) } -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("seq")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +v152 := v151.Get() +v153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v154 := v153.FindInternedVar(lang.NewSymbol("concat")) +if v154.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v154))) } -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("concat")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +v155 := v154.Get() +v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v157 := v156.FindInternedVar(lang.NewSymbol("list")) +if v157.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) } -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +v158 := v157.Get() +v159 := lang.Apply(v158, []any{v21}) +v160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v161 := v160.FindInternedVar(lang.NewSymbol("list")) +if v161.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v161))) } -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +v162 := v161.Get() +v163 := lang.Apply(v162, []any{v43}) +v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v165 := v164.FindInternedVar(lang.NewSymbol("list")) +if v165.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) } -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v2}) -v40 := lang.Apply(v31, []any{v35, v39}) -v41 := lang.Apply(v28, []any{v40}) -v42 := lang.Apply(v25, []any{v41}) -v43 := lang.Apply(v14, []any{v18, v22, v42}) -v44 := lang.Apply(v11, []any{v43}) -return v44 - case 2: -v2 := args[0] -v3 := args[1] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +v166 := v165.Get() +v167 := lang.Apply(v166, []any{v22}) +v168 := lang.Apply(v155, []any{v159, v163, v167}) +v169 := lang.Apply(v152, []any{v168}) +v170 := lang.Apply(v149, []any{v169}) +v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v172 := v171.FindInternedVar(lang.NewSymbol("list")) +if v172.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) } -v8 := v7.Get() -if lang.IsTruthy(v8) { -v5 = closed4 +v173 := v172.Get() +v174 := lang.Apply(v173, []any{v48}) +v175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v176 := v175.FindInternedVar(lang.NewSymbol("list")) +if v176.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v176))) +} +v177 := v176.Get() +v178 := lang.Apply(v20, []any{v21, v22, v59}) +v179 := lang.Apply(v177, []any{v178}) +v180 := lang.Apply(v142, []any{v146, v170, v174, v179}) +v181 := lang.Apply(v139, []any{v180}) +v132 = v181 } else { -v5 = v4 +var v182 any +if lang.IsTruthy(lang.NewKeyword("else")) { +v183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v184 := v183.FindInternedVar(lang.NewSymbol("seq")) +if v184.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v184))) } -var v4 any = v5 -_ = v4 -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("seq")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v185 := v184.Get() +v186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v187 := v186.FindInternedVar(lang.NewSymbol("concat")) +if v187.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v187))) } -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("concat")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +v188 := v187.Get() +v189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v190 := v189.FindInternedVar(lang.NewSymbol("list")) +if v190.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v190))) } -v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("list")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +v191 := v190.Get() +v192 := lang.Apply(v191, []any{lang.NewSymbol("glojure.core/if-let")}) +v193 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v194 := v193.FindInternedVar(lang.NewSymbol("list")) +if v194.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v194))) } -v18 := v17.Get() -v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("list")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +v195 := v194.Get() +v196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v197 := v196.FindInternedVar(lang.NewSymbol("apply")) +if v197.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v197))) } -v22 := v21.Get() -v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("list")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +v198 := v197.Get() +v199 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v200 := v199.FindInternedVar(lang.NewSymbol("vector")) +if v200.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v200))) } -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("seq")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v201 := v200.Get() +v202 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v203 := v202.FindInternedVar(lang.NewSymbol("seq")) +if v203.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v203))) } -v29 := v28.Get() -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("concat")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +v204 := v203.Get() +v205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v206 := v205.FindInternedVar(lang.NewSymbol("concat")) +if v206.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v206))) } -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("list")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +v207 := v206.Get() +v208 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v209 := v208.FindInternedVar(lang.NewSymbol("list")) +if v209.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v209))) } -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v4}) -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("list")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +v210 := v209.Get() +v211 := lang.Apply(v210, []any{lang.NewSymbol("p__0__auto__")}) +v212 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v213 := v212.FindInternedVar(lang.NewSymbol("list")) +if v213.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v213))) } -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v2}) -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("list")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +v214 := v213.Get() +v215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v216 := v215.FindInternedVar(lang.NewSymbol("seq")) +if v216.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v216))) } -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v3}) -v45 := lang.Apply(v32, []any{v36, v40, v44}) -v46 := lang.Apply(v29, []any{v45}) -v47 := lang.Apply(v26, []any{v46}) -v48 := lang.Apply(v15, []any{v19, v23, v47}) -v49 := lang.Apply(v12, []any{v48}) -return v49 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v2 := args[0] -v3 := args[1] -v4 := lang.NewList(args[2:]...) -var v6 any -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v217 := v216.Get() +v218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v219 := v218.FindInternedVar(lang.NewSymbol("concat")) +if v219.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v219))) } -v9 := v8.Get() -if lang.IsTruthy(v9) { -v6 = closed4 -} else { -v6 = v5 +v220 := v219.Get() +v221 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v222 := v221.FindInternedVar(lang.NewSymbol("list")) +if v222.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v222))) } -var v5 any = v6 -_ = v5 -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v223 := v222.Get() +v224 := lang.Apply(v223, []any{v21}) +v225 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v226 := v225.FindInternedVar(lang.NewSymbol("list")) +if v226.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v226))) } -v13 := v12.Get() -var v14 lang.FnFunc -v14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v15 := args[0] -v16 := args[1] -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +v227 := v226.Get() +v228 := lang.Apply(v227, []any{v43}) +v229 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v230 := v229.FindInternedVar(lang.NewSymbol("list")) +if v230.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v230))) } -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("concat")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +v231 := v230.Get() +v232 := lang.Apply(v231, []any{v22}) +v233 := lang.Apply(v220, []any{v224, v228, v232}) +v234 := lang.Apply(v217, []any{v233}) +v235 := lang.Apply(v214, []any{v234}) +v236 := lang.Apply(v207, []any{v211, v235}) +v237 := lang.Apply(v204, []any{v236}) +v238 := lang.Apply(v198, []any{v201, v237}) +v239 := lang.Apply(v195, []any{v238}) +v240 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v241 := v240.FindInternedVar(lang.NewSymbol("list")) +if v241.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v241))) } -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +v242 := v241.Get() +v243 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v244 := v243.FindInternedVar(lang.NewSymbol("seq")) +if v244.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v244))) } -v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v245 := v244.Get() +v246 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v247 := v246.FindInternedVar(lang.NewSymbol("concat")) +if v247.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v247))) } -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v248 := v247.Get() +v249 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v250 := v249.FindInternedVar(lang.NewSymbol("list")) +if v250.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v250))) } -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +v251 := v250.Get() +v252 := lang.Apply(v251, []any{v53}) +v253 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v254 := v253.FindInternedVar(lang.NewSymbol("list")) +if v254.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v254))) } -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +v255 := v254.Get() +v256 := lang.Apply(v255, []any{lang.NewSymbol("p__0__auto__")}) +v257 := lang.Apply(v248, []any{v252, v256}) +v258 := lang.Apply(v245, []any{v257}) +v259 := lang.Apply(v242, []any{v258}) +v260 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v261 := v260.FindInternedVar(lang.NewSymbol("list")) +if v261.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v261))) } -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +v262 := v261.Get() +v263 := lang.Apply(v20, []any{v21, v22, v59}) +v264 := lang.Apply(v262, []any{v263}) +v265 := lang.Apply(v188, []any{v192, v239, v259, v264}) +v266 := lang.Apply(v185, []any{v265}) +v182 = v266 +} else { +v182 = nil } -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v5}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +v132 = v182 } -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v15}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +v127 = v132 } -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v16}) -v52 := lang.Apply(v39, []any{v43, v47, v51}) -v53 := lang.Apply(v36, []any{v52}) -v54 := lang.Apply(v33, []any{v53}) -v55 := lang.Apply(v22, []any{v26, v30, v54}) -v56 := lang.Apply(v19, []any{v55}) -return v56 +v70 = v127 +} +return v70 }) -v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) -v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) +v20 := v19 +_ = v20 +} +v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6420), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(6432), lang.NewKeyword("end-column"), int(53)) +v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) if err != nil { panic(err) } -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("concat")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() +var v18 any = v21 +_ = v18 v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) +v24 := v23.FindInternedVar(lang.NewSymbol("seq")) if v24.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("concat")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) } -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("list")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) } -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +v31 := v30.Get() +v32 := lang.Apply(v31, []any{lang.NewSymbol("glojure.core/let")}) +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("list")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) } -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +v35 := v34.Get() +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("apply")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) } -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +v38 := v37.Get() +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("vector")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) } -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v5}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +v41 := v40.Get() +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("seq")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) } -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v2}) +v44 := v43.Get() +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("concat")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +} +v47 := v46.Get() v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v49 := v48.FindInternedVar(lang.NewSymbol("list")) if v49.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) } v50 := v49.Get() -v51 := lang.Apply(v50, []any{v3}) -v52 := lang.Apply(v39, []any{v43, v47, v51}) -v53 := lang.Apply(v36, []any{v52}) -v54 := lang.Apply(v33, []any{v53}) -v55 := lang.Apply(v22, []any{v26, v30, v54}) -v56 := lang.Apply(v19, []any{v55}) -v57 := lang.Apply(v13, []any{v16, v56, v4}) -return v57 +v51 := lang.Apply(v50, []any{v8}) +v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v53 := v52.FindInternedVar(lang.NewSymbol("list")) +if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) +} +v54 := v53.Get() +v55 := lang.Apply(v54, []any{v5}) +v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v57 := v56.FindInternedVar(lang.NewSymbol("list")) +if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) +} +v58 := v57.Get() +v59 := lang.Apply(v58, []any{v13}) +v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v61 := v60.FindInternedVar(lang.NewSymbol("list")) +if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) +} +v62 := v61.Get() +v63 := lang.Apply(v62, []any{v6}) +v64 := lang.Apply(v47, []any{v51, v55, v59, v63}) +v65 := lang.Apply(v44, []any{v64}) +v66 := lang.Apply(v38, []any{v41, v65}) +v67 := lang.Apply(v35, []any{v66}) +v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v69 := v68.FindInternedVar(lang.NewSymbol("list")) +if v69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) +} +v70 := v69.Get() +v71 := lang.Apply(v18, []any{v8, v13, v7}) +v72 := lang.Apply(v70, []any{v71}) +v73 := lang.Apply(v28, []any{v32, v67, v72}) +v74 := lang.Apply(v25, []any{v73}) +return v74 } }) -v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// conj +{ +v0 := lang.NewSymbol("conj").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("xs"))), lang.NewKeyword("doc"), "conj[oin]. Returns a new collection with the xs\n 'added'. (conj nil item) returns (item).\n (conj coll) returns coll. (conj) returns [].\n The 'addition' may happen at different 'places' depending\n on the concrete type.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(73), lang.NewKeyword("end-line"), int(81))).(*lang.Symbol) var v2 lang.FnFunc +{ // function conj v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) -} -v5 := lang.Apply(v4, []any{v3, int64(1)}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v0 := lang.NewSymbol("bit-or").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Bitwise or", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1307), lang.NewKeyword("end-line"), int(1307))).(*lang.Symbol) -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 2: -v5 := args[0] -v6 := args[1] -v7, _ := lang.FieldOrMethod(lang1.Numbers, "or") -if reflect.TypeOf(v7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("or is not a function"))) + case 0: +v4 := lang.NewVector() +v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(82), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(82), lang.NewKeyword("end-column"), int(14)) +v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v8 := lang.Apply(v7, []any{v5, v6}) -return v8 +return v6 + case 1: +v4 := args[0] +return v4 + case 2: +v4 := args[0] +v5 := args[1] +v6 := lang.Apply(lang1.Conj, []any{v4, v5}) +return v6 default: if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v5 := args[0] -v6 := args[1] -v7 := lang.NewList(args[2:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() +v4 := args[0] +v5 := args[1] +v6 := lang.NewList(args[2:]...) +recur_loop_10: +var v7 any +if lang.IsTruthy(v6) { +v9 := lang.Apply(lang1.Conj, []any{v4, v5}) +var v8 any = v9 v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("bit-or")) +v12 := v11.FindInternedVar(lang.NewSymbol("first")) if v12.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("bit-or")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v14 := lang.Apply(v13, []any{v6}) +var v10 any = v14 +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("next")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v5, v6}) -v18 := lang.Apply(v10, []any{v13, v17, v7}) -return v18 +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v6}) +var v15 any = v19 +v4 = v8 +v5 = v10 +v6 = v15 +goto recur_loop_10 +} else { +v20 := lang.Apply(lang1.Conj, []any{v4, v5}) +v7 = v20 +} +return v7 } }) -v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v3 := ns.InternWithValue(v0, v4, true) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(81), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(88), lang.NewKeyword("end-column"), int(67))).(lang.FnFunc) +v3 := v2 +_ = v3 +} +v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { - v3.SetMeta(v0.Meta().(lang.IPersistentMap)) + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// rational? +// conj! { -v0 := lang.NewSymbol("rational?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is a rational number", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3613), lang.NewKeyword("end-line"), int(3613))).(*lang.Symbol) +v0 := lang.NewSymbol("conj!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Adds x to the transient collection, and return coll. The 'addition'\n may happen at different 'places' depending on the concrete type.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3359), lang.NewKeyword("end-line"), int(3359))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("integer?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -var v4 any = v8 -_ = v4 -var v10 any -if lang.IsTruthy(v4) { -v10 = v4 -} else { -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("ratio?")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v3}) -var v11 any = v15 -_ = v11 -var v17 any -if lang.IsTruthy(v11) { -v17 = v11 -} else { -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("decimal?")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + switch len(args) { + case 0: +v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v4 := v3.FindInternedVar(lang.NewSymbol("transient")) +if v4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) } -v20 := v19.Get() -v21 := lang.Apply(v20, []any{v3}) -v17 = v21 +v5 := v4.Get() +v6 := lang.NewVector() +v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3364), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(3364), lang.NewKeyword("end-column"), int(19)) +v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v10 = v17 +v9 := lang.Apply(v5, []any{v8}) +return v9 + case 1: +v3 := args[0] +return v3 + case 2: +v3 := args[0] +v4 := args[1] +v5, _ := lang.FieldOrMethod(v3, "Conj") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Conj is not a function"))) } -return v10 +v6 := lang.Apply(v5, []any{v4}) +return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -20654,602 +19819,574 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// bigint +// cons { -v1 := reflect.TypeOf((*lang1.BigInt)(nil)) -v0 := lang.NewSymbol("bigint").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Coerce to BigInt", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3620), lang.NewKeyword("end-line"), int(3620))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { +v0 := lang.NewSymbol("cons").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("seq"))), lang.NewKeyword("doc"), "Returns a new seq where x is the first element and seq is\n the rest.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(21), lang.NewKeyword("end-line"), int(27))).(*lang.Symbol) +var v2 lang.FnFunc +{ // function cons +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{lang1.*BigInt, v4}) -if lang.IsTruthy(v9) { -v5 = v4 -} else { -var v10 any -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("instance?")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{big9.*Int, v4}) -if lang.IsTruthy(v14) { -v15 := lang.Apply(lang1.NewBigIntFromGoBigInt, []any{v4}) -v10 = v15 -} else { -var v16 any -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("decimal?")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v4}) -if lang.IsTruthy(v20) { -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("bigint")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24, ok := lang.FieldOrMethod(v4, "toBigInteger") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "toBigInteger"))) +v5 := args[1] +v6 := lang.Apply(lang1.NewCons, []any{v4, v5}) +return v6 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(27), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(27), lang.NewKeyword("end-column"), int(89))).(lang.FnFunc) +v3 := v2 +_ = v3 } -var v25 any -switch reflect.TypeOf(v24).Kind() { -case reflect.Func: - v25 = lang.Apply(v24, nil) -default: - v25 = v24 +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v26 := lang.Apply(v23, []any{v25}) -v16 = v26 -} else { -var v27 any -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("float?")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } -v30 := v29.Get() -v31 := lang.Apply(v30, []any{v4}) -if lang.IsTruthy(v31) { -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("bigint")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +// constantly +{ +v0 := lang.NewSymbol("constantly").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns a function that takes any number of arguments and returns x.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1440), lang.NewKeyword("end-line"), int(1440))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := lang.NewList(args[0:]...) +return v3 + } +}) +v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1444), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(1444), lang.NewKeyword("end-column"), int(21)) +v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v34 := v33.Get() -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("double")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +return v6 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v4}) -v39 := lang.Apply(lang1.NewBigDecimalFromFloat64, []any{v38}) -v40 := lang.Apply(v34, []any{v39}) -v27 = v40 -} else { -var v41 any -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("ratio?")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) } -v44 := v43.Get() -v45 := lang.Apply(v44, []any{v4}) -if lang.IsTruthy(v45) { -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("bigint")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +// contains? +{ +v0 := lang.NewSymbol("contains?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("key"))), lang.NewKeyword("doc"), "Returns true if key is present in the given collection, otherwise\n returns false. Note that for numerically indexed collections like\n vectors and Java arrays, this tests if the numeric key is within the\n range of indexes. 'contains?' operates constant or logarithmic time;\n it will not perform a linear search for a value. See also 'some'.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1479), lang.NewKeyword("end-line"), int(1479))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5, _ := lang.FieldOrMethod(runtime9.RT, "Contains") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Contains is not a function"))) } -v48 := v47.Get() -v49, ok := lang.FieldOrMethod(v4, "bigIntegerValue") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "bigIntegerValue"))) +v6 := lang.Apply(v5, []any{v3, v4}) +return v6 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -var v50 any -switch reflect.TypeOf(v49).Kind() { -case reflect.Func: - v50 = lang.Apply(v49, nil) -default: - v50 = v49 } -v51 := lang.Apply(v48, []any{v50}) -v41 = v51 -} else { -var v52 any -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("number?")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +// count +{ +var v1 lang.FnFunc +{ // function count__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v55 := v54.Get() -v56 := lang.Apply(v55, []any{v4}) -if lang.IsTruthy(v56) { -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("long")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v59 := v58.Get() -v60 := lang.Apply(v59, []any{v4}) -v61 := lang.Apply(lang1.NewBigIntFromInt64, []any{v60}) -v52 = v61 -} else { -var v62 any -if lang.IsTruthy(lang.NewKeyword("else")) { -v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v64 := v63.FindInternedVar(lang.NewSymbol("bigint")) -if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v65 := v64.Get() -v66 := lang.Apply(BigInteger12., []any{v4}) -v67 := lang.Apply(v65, []any{v66}) -v62 = v67 -} else { -v62 = nil +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v52 = v62 +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v41 = v52 +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v27 = v41 +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -v16 = v27 +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v10 = v16 +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/Count")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -v5 = v10 +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v3}) +v35 := lang.Apply(v26, []any{v30, v34}) +v36 := lang.Apply(v23, []any{v35}) +v37 := lang.Apply(v20, []any{v36}) +v38 := lang.Apply(v9, []any{v13, v17, v37}) +v39 := lang.Apply(v6, []any{v38}) +return v39 +}) +v2 := v1 +_ = v2 } +v0 := lang.NewSymbol("count").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the number of items in the collection. (count nil) returns\n 0. Also works on strings, arrays, and Java Collections and Maps", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(867), lang.NewKeyword("end-line"), int(867))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := lang.Apply(lang1.Count, []any{v4}) return v5 }) -v4 := reflect.TypeOf((*lang1.BigInt)(nil)) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// bit-and-not +// counted? { -var v1 lang.FnFunc -v1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v2 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -if lang.IsTruthy(v7) { -v4 = closed5 -} else { -v4 = v3 +v0 := lang.NewSymbol("counted?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements count in constant time", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6284), lang.NewKeyword("end-line"), int(6284))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -var v3 any = v4 -_ = v3 -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("seq")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +v6 := v5.Get() +v7 := lang.Apply(v6, []any{lang1.Counted, v3}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("concat")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +// create-ns +{ +v0 := lang.NewSymbol("create-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Create a new namespace named by the symbol if one doesn't already\n exist, returns it or the already-existing namespace of the same\n name.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4131), lang.NewKeyword("end-line"), int(4131))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.Apply(nil, []any{v3}) +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v21 := v20.Get() -v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +// create-struct +{ +v0 := lang.NewSymbol("create-struct").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keys"))), lang.NewKeyword("doc"), "Returns a structure basis object.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4037), lang.NewKeyword("end-line"), int(4037))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.NewList(args[0:]...) +v4 := lang.Apply(lang1.CreatePersistentStructMapSlotMap, []any{v3}) +return v4 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("seq")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) } -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("concat")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +// cycle +{ +v0 := lang.NewSymbol("cycle").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy (infinite!) sequence of repetitions of the items in coll.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2977), lang.NewKeyword("end-line"), int(2977))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +v6 := v5.Get() +v7 := lang.Apply(v6, []any{v3}) +v8 := lang.Apply(lang1.NewCycle, []any{v7}) +return v8 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) } -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v2}) -v40 := lang.Apply(v31, []any{v35, v39}) -v41 := lang.Apply(v28, []any{v40}) -v42 := lang.Apply(v25, []any{v41}) -v43 := lang.Apply(v14, []any{v18, v22, v42}) -v44 := lang.Apply(v11, []any{v43}) -return v44 - case 2: -v2 := args[0] -v3 := args[1] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +// data-reader-urls +{ +v0 := lang.NewSymbol("data-reader-urls").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7873), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7873), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +return lang.NewList() +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v8 := v7.Get() -if lang.IsTruthy(v8) { -v5 = closed5 -} else { -v5 = v4 } -var v4 any = v5 -_ = v4 +// data-reader-var +{ +v0 := lang.NewSymbol("data-reader-var").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7875), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7875), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("intern")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("create-ns")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("seq")) +v11 := v10.FindInternedVar(lang.NewSymbol("symbol")) if v11.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } v12 := v11.Get() v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("concat")) +v14 := v13.FindInternedVar(lang.NewSymbol("namespace")) if v14.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("list")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("list")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("list")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("seq")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v16 := lang.Apply(v15, []any{v3}) +v17 := lang.Apply(v12, []any{v16}) +v18 := lang.Apply(v9, []any{v17}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("symbol")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v29 := v28.Get() -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("concat")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("name")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("list")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v3}) +v26 := lang.Apply(v21, []any{v25}) +v27 := lang.Apply(v6, []any{v18, v26}) +return v27 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v4}) -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("list")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v2}) -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("list")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +// dec +{ +var v1 lang.FnFunc +{ // function dec__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v3}) -v45 := lang.Apply(v32, []any{v36, v40, v44}) -v46 := lang.Apply(v29, []any{v45}) -v47 := lang.Apply(v26, []any{v46}) -v48 := lang.Apply(v15, []any{v19, v23, v47}) -v49 := lang.Apply(v12, []any{v48}) -return v49 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v2 := args[0] -v3 := args[1] -v4 := lang.NewList(args[2:]...) -var v6 any +v6 := v5.Get() v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) if v8.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } v9 := v8.Get() -if lang.IsTruthy(v9) { -v6 = closed5 -} else { -v6 = v5 +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -var v5 any = v6 -_ = v5 -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v13 := v12.Get() -var v14 lang.FnFunc -v14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v15 := args[0] -v16 := args[1] -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("concat")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) +v26 := v25.Get() v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v28 := v27.FindInternedVar(lang.NewSymbol("list")) if v28.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +var v30 any v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) +v32 := v31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) if v32.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +if lang.IsTruthy(v33) { +v30 = lang.NewSymbol("unchecked_dec") +} else { +v30 = lang.NewSymbol("dec") } -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +v34 := lang.Apply(v29, []any{v30}) +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("list")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) } -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v5}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +v37 := v36.Get() +v38 := lang.Apply(v37, []any{v3}) +v39 := lang.Apply(v26, []any{v34, v38}) +v40 := lang.Apply(v23, []any{v39}) +v41 := lang.Apply(v20, []any{v40}) +v42 := lang.Apply(v9, []any{v13, v17, v41}) +v43 := lang.Apply(v6, []any{v42}) +return v43 +}) +v2 := v1 +_ = v2 } -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v15}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +v0 := lang.NewSymbol("dec").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns a number one less than num. Does not auto-promote\n longs, will throw on overflow. See also: dec'", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1147), lang.NewKeyword("end-line"), int(1147))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "dec") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("dec is not a function"))) } -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v16}) -v52 := lang.Apply(v39, []any{v43, v47, v51}) -v53 := lang.Apply(v36, []any{v52}) -v54 := lang.Apply(v33, []any{v53}) -v55 := lang.Apply(v22, []any{v26, v30, v54}) -v56 := lang.Apply(v19, []any{v55}) -return v56 +v6 := lang.Apply(v5, []any{v4}) +return v6 }) -v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) -v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) -if err != nil { - panic(err) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("concat")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +// dec' +{ +var v1 lang.FnFunc +{ // function dec'__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v28 := v27.FindInternedVar(lang.NewSymbol("list")) if v28.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/decP")}) v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v32 := v31.FindInternedVar(lang.NewSymbol("list")) if v32.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +v34 := lang.Apply(v33, []any{v3}) +v35 := lang.Apply(v26, []any{v30, v34}) +v36 := lang.Apply(v23, []any{v35}) +v37 := lang.Apply(v20, []any{v36}) +v38 := lang.Apply(v9, []any{v13, v17, v37}) +v39 := lang.Apply(v6, []any{v38}) +return v39 +}) +v2 := v1 +_ = v2 } -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +v0 := lang.NewSymbol("dec'").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns a number one less than num. Supports arbitrary precision.\n See also: dec", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1140), lang.NewKeyword("end-line"), int(1140))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "decP") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("decP is not a function"))) } -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v5}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v2}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) } -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v3}) -v52 := lang.Apply(v39, []any{v43, v47, v51}) -v53 := lang.Apply(v36, []any{v52}) -v54 := lang.Apply(v33, []any{v53}) -v55 := lang.Apply(v22, []any{v26, v30, v54}) -v56 := lang.Apply(v19, []any{v55}) -v57 := lang.Apply(v13, []any{v16, v56, v4}) -return v57 - } -}) -v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) +// decimal? +{ +v0 := lang.NewSymbol("decimal?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is a BigDecimal", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3599), lang.NewKeyword("end-line"), int(3599))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) -} -v5 := lang.Apply(v4, []any{v3, int64(1)}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v0 := lang.NewSymbol("bit-and-not").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Bitwise and with complement", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1325), lang.NewKeyword("end-line"), int(1325))).(*lang.Symbol) -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v5 := args[0] -v6 := args[1] -v7, _ := lang.FieldOrMethod(lang1.Numbers, "andNot") -if reflect.TypeOf(v7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("andNot is not a function"))) -} -v8 := lang.Apply(v7, []any{v5, v6}) -return v8 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := args[0] -v6 := args[1] -v7 := lang.NewList(args[2:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("bit-and-not")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("bit-and-not")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v5, v6}) -v18 := lang.Apply(v10, []any{v13, v17, v7}) -return v18 - } +v6 := v5.Get() +v7 := lang.Apply(v6, []any{lang1.*BigDecimal, v3}) +return v7 }) -v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v3 := ns.InternWithValue(v0, v4, true) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { - v3.SetMeta(v0.Meta().(lang.IPersistentMap)) + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// refer-glojure +// declare { -v0 := lang.NewSymbol("refer-glojure").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("filters"))), lang.NewKeyword("doc"), "Same as (refer 'glojure.core )", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5843), lang.NewKeyword("end-line"), int(5843))).(*lang.Symbol) +v0 := lang.NewSymbol("declare").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("names"))), lang.NewKeyword("doc"), "defs the supplied var names with no bindings, useful for making forward declarations.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(2768), lang.NewKeyword("end-line"), int(2768))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -21278,45 +20415,50 @@ if v13.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } v14 := v13.Get() -v15 := lang.Apply(v14, []any{lang.NewSymbol("glojure.core/refer")}) +v15 := lang.Apply(v14, []any{lang.NewSymbol("do")}) v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("list")) +v17 := v16.FindInternedVar(lang.NewSymbol("map")) if v17.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } v18 := v17.Get() -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("seq")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +var v19 lang.FnFunc +v19 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v20 := args[0] +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("list")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("concat")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("vary-meta")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("list")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("assoc")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v27 := v26.Get() -v28 := lang.Apply(v27, []any{lang.NewSymbol("quote")}) -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("list")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +v29 := v28.Get() +v30 := lang.Apply(v26, []any{v20, v29, lang.NewKeyword("declared"), true}) +v31 := lang.Apply(v23, []any{lang.NewSymbol("def"), v30}) +return v31 +}) +v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2771), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(2771), lang.NewKeyword("end-column"), int(71)) +v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v31 := v30.Get() -v32 := lang.Apply(v31, []any{lang.NewSymbol("glojure.core")}) -v33 := lang.Apply(v24, []any{v28, v32}) -v34 := lang.Apply(v21, []any{v33}) -v35 := lang.Apply(v18, []any{v34}) -v36 := lang.Apply(v11, []any{v15, v35, v5}) -v37 := lang.Apply(v8, []any{v36}) -return v37 +v22 := lang.Apply(v18, []any{v21, v5}) +v23 := lang.Apply(v11, []any{v15, v22}) +v24 := lang.Apply(v8, []any{v23}) +return v24 } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -21325,838 +20467,749 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// unreduced +// dedupe { -v0 := lang.NewSymbol("unreduced").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "If x is reduced?, returns (deref x), else returns x", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2847), lang.NewKeyword("end-line"), int(2847))).(*lang.Symbol) +v0 := lang.NewSymbol("dedupe").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence removing consecutive duplicates in coll.\n Returns a transducer when no collection is provided.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7724), lang.NewKeyword("end-line"), int(7724))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("reduced?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -if lang.IsTruthy(v8) { -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("deref")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v3}) -v4 = v12 -} else { -v4 = v3 -} -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// str -{ -v1 := reflect.TypeOf("") -v0 := lang.NewSymbol("str").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("ys"))), lang.NewKeyword("doc"), "With no args, returns the empty string. With one arg x, returns\n x.toString(). (str nil) returns the empty string. With more than\n one arg, returns the concatenation of the str values of the args.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(543), lang.NewKeyword("end-line"), int(543))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -return "" - case 1: v4 := args[0] -var v5 any v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("nil?")) +v7 := v6.FindInternedVar(lang.NewSymbol("volatile!")) if v7.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } v8 := v7.Get() -v9 := lang.Apply(v8, []any{v4}) -if lang.IsTruthy(v9) { -v5 = "" -} else { -v10 := lang.Apply(lang1.ToString, []any{v4}) -v5 = v10 -} -return v5 - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := lang.NewList(args[1:]...) -var v6 lang.FnFunc -v6 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v7 := args[0] -v8 := args[1] -recur_loop_74: -var v9 any -if lang.IsTruthy(v8) { -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("str")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("first")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v9 := lang.Apply(v8, []any{lang.NewKeyword("glojure.core/none")}) +var v5 any = v9 +_ = v5 +var v11 lang.FnFunc +v11 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v12 := lang.Apply(v4, nil) +return v12 + case 1: +v12 := args[0] +v13 := lang.Apply(v4, []any{v12}) +return v13 + case 2: +v12 := args[0] +v13 := args[1] +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("deref")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v8}) -v18 := lang.Apply(v13, []any{v17}) -v19, _ := lang.FieldOrMethod(v7, "WriteString") -if reflect.TypeOf(v19).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("WriteString is not a function"))) +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v5}) +var v14 any = v18 +_ = v14 +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("vreset!")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v20 := lang.Apply(v19, []any{v18}) -_ = v20 -var v10 any = v7 -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("next")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v22 := v21.Get() +v23 := lang.Apply(v22, []any{v5, v13}) +_ = v23 +var v24 any +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("=")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v8}) -var v21 any = v25 -v7 = v10 -v8 = v21 -goto recur_loop_74 +v27 := v26.Get() +v28 := lang.Apply(v27, []any{v14, v13}) +if lang.IsTruthy(v28) { +v24 = v12 } else { -v26, ok := lang.FieldOrMethod(v7, "String") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "String"))) -} -var v27 any -switch reflect.TypeOf(v26).Kind() { -case reflect.Func: - v27 = lang.Apply(v26, nil) -default: - v27 = v26 -} -v9 = v27 +v29 := lang.Apply(v4, []any{v12, v13}) +v24 = v29 } -return v9 +return v24 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } }) -v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(554), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(554), lang.NewKeyword("end-column"), int(127)) -v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) +v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7731), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7739), lang.NewKeyword("end-column"), int(37)) +v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) if err != nil { panic(err) } -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("cons")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v4, v5}) -v13 := lang.Apply(v8, []any{"unimplemented: new with non-constant class type", v12}) return v13 - } }) -v4 := reflect.TypeOf("") -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} +v4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7729), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7739), lang.NewKeyword("end-column"), int(39)) +v5, err := lang.WithMeta(v3, v4.(lang.IPersistentMap)) +if err != nil { + panic(err) } -// shorts -{ -var v1 lang.FnFunc -{ // function shorts -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } +return v5 + case 1: v3 := args[0] v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +v5 := v4.FindInternedVar(lang.NewSymbol("sequence")) if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +v8 := v7.FindInternedVar(lang.NewSymbol("dedupe")) if v8.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v10 := lang.Apply(v9, nil) +v11 := lang.Apply(v6, []any{v10, v3}) +return v11 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +} +// def-aset +{ +v0 := lang.NewSymbol("def-aset").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("method"), lang.NewSymbol("coerce"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3935), lang.NewKeyword("end-line"), int(3936), lang.NewKeyword("private"), true)).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 5 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := args[4] +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("seq")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("concat")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v15 := v14.FindInternedVar(lang.NewSymbol("list")) if v15.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v17 := lang.Apply(v16, []any{lang.NewSymbol("glojure.core/defn")}) v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v19 := v18.FindInternedVar(lang.NewSymbol("list")) if v19.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } v20 := v19.Get() -v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/shorts")}) +v21 := lang.Apply(v20, []any{v5}) v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v23 := v22.FindInternedVar(lang.NewSymbol("list")) if v23.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v26 := lang.Apply(v9, []any{v13, v17, v21, v25}) -v27 := lang.Apply(v6, []any{v26}) -return v27 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("shorts").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Casts to shorts[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5387), lang.NewKeyword("end-line"), int(5387))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "shorts") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("shorts is not a function"))) +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("apply")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("hash-map")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("seq")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -// delay -{ -v0 := lang.NewSymbol("delay").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Takes a body of expressions and yields a Delay object that will\n invoke the body only the first time it is forced (with force or deref/@), and\n will cache the result and return it on all subsequent force\n calls. See also - realized?", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(739), lang.NewKeyword("end-line"), int(739))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("list")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("concat")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("list*")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("list")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -v11 := v10.Get() -v12 := lang.NewVector() -v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(746), lang.NewKeyword("column"), int(62), lang.NewKeyword("end-line"), int(746), lang.NewKeyword("end-column"), int(63)) -v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) -if err != nil { - panic(err) +v39 := v38.Get() +v40 := lang.Apply(v39, []any{lang.NewKeyword("arglists")}) +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("list")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } -v15 := lang.Apply(v11, []any{lang.NewSymbol("fn*"), v14, v5}) -v16 := lang.Apply(v8, []any{lang.NewSymbol("new"), lang.NewSymbol("glojure.lang.Delay"), v15}) -return v16 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v43 := v42.Get() +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("seq")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } +v46 := v45.Get() +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("concat")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) } -// tagged-literal? -{ -v0 := lang.NewSymbol("tagged-literal?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("value"))), lang.NewKeyword("doc"), "Return true if the value is the data representation of a tagged literal", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7806), lang.NewKeyword("end-line"), int(7806))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v49 := v48.Get() +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("list")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) } -v6 := v5.Get() -v7 := lang.Apply(v6, []any{glojure.lang11.TaggedLiteral, v3}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v52 := v51.Get() +v53 := lang.Apply(v52, []any{lang.NewSymbol("quote")}) +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("list")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) } +v56 := v55.Get() +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("seq")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) } -// pop-thread-bindings -{ -v0 := lang.NewSymbol("pop-thread-bindings").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Pop one set of bindings pushed with push-binding before. It is an error to\n pop bindings without pushing before.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1929), lang.NewKeyword("end-line"), int(1929))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.Apply(lang1.PopThreadBindings, nil) -return v3 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v59 := v58.Get() +v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v61 := v60.FindInternedVar(lang.NewSymbol("concat")) +if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) } +v62 := v61.Get() +v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v64 := v63.FindInternedVar(lang.NewSymbol("list")) +if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) } -// unquote-splicing -{ -v0 := lang.NewSymbol("unquote-splicing").WithMeta(lang.NewMap()).(*lang.Symbol) -v1 := ns.Intern(v0) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v65 := v64.Get() +v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v67 := v66.FindInternedVar(lang.NewSymbol("apply")) +if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) } +v68 := v67.Get() +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("vector")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) } -// *unchecked-math* -{ -v0 := lang.NewSymbol("*unchecked-math*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.3", lang.NewKeyword("doc"), "While bound to true, compilations of +, -, *, inc, dec and the\n coercions will be done without overflow checks. While bound\n to :warn-on-boxed, same behavior as true, and a warning is emitted\n when compilation uses boxed math. Default: false.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, nil, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v71 := v70.Get() +v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v73 := v72.FindInternedVar(lang.NewSymbol("seq")) +if v73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) } +v74 := v73.Get() +v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v76 := v75.FindInternedVar(lang.NewSymbol("concat")) +if v76.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) } -// ref-max-history -{ -v0 := lang.NewSymbol("ref-max-history").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref")), lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Gets the max-history of a ref, or sets it and returns the ref", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2471), lang.NewKeyword("end-line"), int(2471))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -v4, ok := lang.FieldOrMethod(v3, "getMaxHistory") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getMaxHistory"))) +v77 := v76.Get() +v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v79 := v78.FindInternedVar(lang.NewSymbol("list")) +if v79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) } -var v5 any -switch reflect.TypeOf(v4).Kind() { -case reflect.Func: - v5 = lang.Apply(v4, nil) -default: - v5 = v4 +v80 := v79.Get() +v81 := lang.Apply(v80, []any{lang.NewSymbol("array")}) +v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v83 := v82.FindInternedVar(lang.NewSymbol("list")) +if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) } -return v5 - case 2: -v3 := args[0] -v4 := args[1] -v5, _ := lang.FieldOrMethod(v3, "setMaxHistory") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMaxHistory is not a function"))) +v84 := v83.Get() +v85 := lang.Apply(v84, []any{lang.NewSymbol("idx")}) +v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v87 := v86.FindInternedVar(lang.NewSymbol("list")) +if v87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) } -v6 := lang.Apply(v5, []any{v4}) -return v6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v88 := v87.Get() +v89 := lang.Apply(v88, []any{lang.NewSymbol("val")}) +v90 := lang.Apply(v77, []any{v81, v85, v89}) +v91 := lang.Apply(v74, []any{v90}) +v92 := lang.Apply(v68, []any{v71, v91}) +v93 := lang.Apply(v65, []any{v92}) +v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v95 := v94.FindInternedVar(lang.NewSymbol("list")) +if v95.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) } +v96 := v95.Get() +v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v98 := v97.FindInternedVar(lang.NewSymbol("apply")) +if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) } -// as-> -{ -v0 := lang.NewSymbol("as->").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "Binds name to expr, evaluates the first form in the lexical context\n of that binding, then binds name to that result, repeating for each\n successive form, returning the result of the last form.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7641), lang.NewKeyword("end-line"), int(7641))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := lang.NewList(args[4:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("seq")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v99 := v98.Get() +v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v101 := v100.FindInternedVar(lang.NewSymbol("vector")) +if v101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) } -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("concat")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v102 := v101.Get() +v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v104 := v103.FindInternedVar(lang.NewSymbol("seq")) +if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) } -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v105 := v104.Get() +v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v107 := v106.FindInternedVar(lang.NewSymbol("concat")) +if v107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("glojure.core/let")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v108 := v107.Get() +v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v110 := v109.FindInternedVar(lang.NewSymbol("list")) +if v110.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) } -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("apply")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +v111 := v110.Get() +v112 := lang.Apply(v111, []any{lang.NewSymbol("array")}) +v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v114 := v113.FindInternedVar(lang.NewSymbol("list")) +if v114.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) } -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("vector")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +v115 := v114.Get() +v116 := lang.Apply(v115, []any{lang.NewSymbol("idx")}) +v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v118 := v117.FindInternedVar(lang.NewSymbol("list")) +if v118.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) } -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("seq")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v119 := v118.Get() +v120 := lang.Apply(v119, []any{lang.NewSymbol("idx2")}) +v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v122 := v121.FindInternedVar(lang.NewSymbol("list")) +if v122.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) } -v29 := v28.Get() -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("concat")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +v123 := v122.Get() +v124 := lang.Apply(v123, []any{lang.NewSymbol("&")}) +v125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v126 := v125.FindInternedVar(lang.NewSymbol("list")) +if v126.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v126))) } -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("list")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +v127 := v126.Get() +v128 := lang.Apply(v127, []any{lang.NewSymbol("idxv")}) +v129 := lang.Apply(v108, []any{v112, v116, v120, v124, v128}) +v130 := lang.Apply(v105, []any{v129}) +v131 := lang.Apply(v99, []any{v102, v130}) +v132 := lang.Apply(v96, []any{v131}) +v133 := lang.Apply(v62, []any{v93, v132}) +v134 := lang.Apply(v59, []any{v133}) +v135 := lang.Apply(v56, []any{v134}) +v136 := lang.Apply(v49, []any{v53, v135}) +v137 := lang.Apply(v46, []any{v136}) +v138 := lang.Apply(v43, []any{v137}) +v139 := lang.Apply(v36, []any{v40, v138}) +v140 := lang.Apply(v33, []any{v139}) +v141 := lang.Apply(v27, []any{v30, v140}) +v142 := lang.Apply(v24, []any{v141}) +v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v144 := v143.FindInternedVar(lang.NewSymbol("list")) +if v144.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) } -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v6}) -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("list")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +v145 := v144.Get() +v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v147 := v146.FindInternedVar(lang.NewSymbol("seq")) +if v147.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) } -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v5}) -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("interleave")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +v148 := v147.Get() +v149 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v150 := v149.FindInternedVar(lang.NewSymbol("concat")) +if v150.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v150))) } -v43 := v42.Get() -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("repeat")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +v151 := v150.Get() +v152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v153 := v152.FindInternedVar(lang.NewSymbol("list")) +if v153.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v153))) } -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v6}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("butlast")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +v154 := v153.Get() +v155 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v156 := v155.FindInternedVar(lang.NewSymbol("apply")) +if v156.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v156))) } -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v7}) -v52 := lang.Apply(v43, []any{v47, v51}) -v53 := lang.Apply(v32, []any{v36, v40, v52}) -v54 := lang.Apply(v29, []any{v53}) -v55 := lang.Apply(v23, []any{v26, v54}) -v56 := lang.Apply(v20, []any{v55}) -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("list")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +v157 := v156.Get() +v158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v159 := v158.FindInternedVar(lang.NewSymbol("vector")) +if v159.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v159))) } -v59 := v58.Get() -var v60 any -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("empty?")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +v160 := v159.Get() +v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v162 := v161.FindInternedVar(lang.NewSymbol("seq")) +if v162.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) } -v63 := v62.Get() -v64 := lang.Apply(v63, []any{v7}) -if lang.IsTruthy(v64) { -v60 = v6 -} else { -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("last")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +v163 := v162.Get() +v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v165 := v164.FindInternedVar(lang.NewSymbol("concat")) +if v165.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) } -v67 := v66.Get() -v68 := lang.Apply(v67, []any{v7}) -v60 = v68 +v166 := v165.Get() +v167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v168 := v167.FindInternedVar(lang.NewSymbol("list")) +if v168.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v168))) } -v69 := lang.Apply(v59, []any{v60}) -v70 := lang.Apply(v13, []any{v17, v56, v69}) -v71 := lang.Apply(v10, []any{v70}) -return v71 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v169 := v168.Get() +v170 := lang.Apply(v169, []any{lang.NewSymbol("array__0__auto__")}) +v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v172 := v171.FindInternedVar(lang.NewSymbol("list")) +if v172.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) } +v173 := v172.Get() +v174 := lang.Apply(v173, []any{lang.NewSymbol("idx__1__auto__")}) +v175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v176 := v175.FindInternedVar(lang.NewSymbol("list")) +if v176.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v176))) } -// unchecked-float -{ -var v1 lang.FnFunc -{ // function unchecked-float__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v177 := v176.Get() +v178 := lang.Apply(v177, []any{lang.NewSymbol("val__2__auto__")}) +v179 := lang.Apply(v166, []any{v170, v174, v178}) +v180 := lang.Apply(v163, []any{v179}) +v181 := lang.Apply(v157, []any{v160, v180}) +v182 := lang.Apply(v154, []any{v181}) +v183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v184 := v183.FindInternedVar(lang.NewSymbol("list")) +if v184.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v184))) } -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v185 := v184.Get() +v186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v187 := v186.FindInternedVar(lang.NewSymbol("seq")) +if v187.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v187))) } -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v188 := v187.Get() +v189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v190 := v189.FindInternedVar(lang.NewSymbol("concat")) +if v190.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v190))) } -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v191 := v190.Get() +v192 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v193 := v192.FindInternedVar(lang.NewSymbol("list")) +if v193.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v193))) } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v194 := v193.Get() +v195 := lang.Apply(v194, []any{lang.NewSymbol(".")}) +v196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v197 := v196.FindInternedVar(lang.NewSymbol("list")) +if v197.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v197))) } -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +v198 := v197.Get() +v199 := lang.Apply(v198, []any{lang.NewSymbol("glojure.core/Array")}) +v200 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v201 := v200.FindInternedVar(lang.NewSymbol("list")) +if v201.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v201))) } -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +v202 := v201.Get() +v203 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v204 := v203.FindInternedVar(lang.NewSymbol("seq")) +if v204.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v204))) } -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v205 := v204.Get() +v206 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v207 := v206.FindInternedVar(lang.NewSymbol("concat")) +if v207.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v207))) } -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/UncheckedFloatCast")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v208 := v207.Get() +v209 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v210 := v209.FindInternedVar(lang.NewSymbol("list")) +if v210.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v210))) } -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v3}) -v35 := lang.Apply(v26, []any{v30, v34}) -v36 := lang.Apply(v23, []any{v35}) -v37 := lang.Apply(v20, []any{v36}) -v38 := lang.Apply(v9, []any{v13, v17, v37}) -v39 := lang.Apply(v6, []any{v38}) -return v39 -}) -v2 := v1 -_ = v2 +v211 := v210.Get() +v212 := lang.Apply(v211, []any{v6}) +v213 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v214 := v213.FindInternedVar(lang.NewSymbol("list")) +if v214.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v214))) } -v0 := lang.NewSymbol("unchecked-float").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to float. Subject to rounding.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3547), lang.NewKeyword("end-line"), int(3547))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := lang.Apply(lang1.UncheckedFloatCast, []any{v4}) -return v5 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +v215 := v214.Get() +v216 := lang.Apply(v215, []any{lang.NewSymbol("array__0__auto__")}) +v217 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v218 := v217.FindInternedVar(lang.NewSymbol("list")) +if v218.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v218))) } +v219 := v218.Get() +v220 := lang.Apply(v219, []any{lang.NewSymbol("idx__1__auto__")}) +v221 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v222 := v221.FindInternedVar(lang.NewSymbol("list")) +if v222.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v222))) } -// select-keys -{ -v0 := lang.NewSymbol("select-keys").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("keyseq"))), lang.NewKeyword("doc"), "Returns a map containing only those entries in map whose key is in keys", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1536), lang.NewKeyword("end-line"), int(1536))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v6 := lang.NewMap() -v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1541), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(1541), lang.NewKeyword("end-column"), int(17)) -v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) -if err != nil { - panic(err) +v223 := v222.Get() +v224 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v225 := v224.FindInternedVar(lang.NewSymbol("seq")) +if v225.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v225))) } -var v5 any = v8 -_ = v5 -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("seq")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v226 := v225.Get() +v227 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v228 := v227.FindInternedVar(lang.NewSymbol("concat")) +if v228.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v228))) } -v12 := v11.Get() -v13 := lang.Apply(v12, []any{v4}) -var v9 any = v13 -_ = v9 -var v14 any -for { -var v15 any -if lang.IsTruthy(v9) { -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("first")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +v229 := v228.Get() +v230 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v231 := v230.FindInternedVar(lang.NewSymbol("list")) +if v231.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v231))) } -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v9}) -v21, _ := lang.FieldOrMethod(runtime3.RT, "Find") -if reflect.TypeOf(v21).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Find is not a function"))) +v232 := v231.Get() +v233 := lang.Apply(v232, []any{v7}) +v234 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v235 := v234.FindInternedVar(lang.NewSymbol("list")) +if v235.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v235))) } -v22 := lang.Apply(v21, []any{v3, v20}) -var v16 any = v22 -_ = v16 -var v25 any -if lang.IsTruthy(v16) { -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("conj")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +v236 := v235.Get() +v237 := lang.Apply(v236, []any{lang.NewSymbol("val__2__auto__")}) +v238 := lang.Apply(v229, []any{v233, v237}) +v239 := lang.Apply(v226, []any{v238}) +v240 := lang.Apply(v223, []any{v239}) +v241 := lang.Apply(v208, []any{v212, v216, v220, v240}) +v242 := lang.Apply(v205, []any{v241}) +v243 := lang.Apply(v202, []any{v242}) +v244 := lang.Apply(v191, []any{v195, v199, v243}) +v245 := lang.Apply(v188, []any{v244}) +v246 := lang.Apply(v185, []any{v245}) +v247 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v248 := v247.FindInternedVar(lang.NewSymbol("list")) +if v248.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v248))) } -v28 := v27.Get() -v29 := lang.Apply(v28, []any{v5, v16}) -v25 = v29 -} else { -v25 = v5 +v249 := v248.Get() +v250 := lang.Apply(v249, []any{lang.NewSymbol("val__2__auto__")}) +v251 := lang.Apply(v151, []any{v182, v246, v250}) +v252 := lang.Apply(v148, []any{v251}) +v253 := lang.Apply(v145, []any{v252}) +v254 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v255 := v254.FindInternedVar(lang.NewSymbol("list")) +if v255.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v255))) } -var v24 any = v25 -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("next")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v256 := v255.Get() +v257 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v258 := v257.FindInternedVar(lang.NewSymbol("seq")) +if v258.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v258))) } -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v9}) -var v30 any = v34 -v5 = v24 -v9 = v30 -continue -} else { -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("with-meta")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +v259 := v258.Get() +v260 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v261 := v260.FindInternedVar(lang.NewSymbol("concat")) +if v261.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v261))) } -v18 := v17.Get() -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("meta")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v262 := v261.Get() +v263 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v264 := v263.FindInternedVar(lang.NewSymbol("list")) +if v264.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v264))) } -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v3}) -v23 := lang.Apply(v18, []any{v5, v22}) -v15 = v23 +v265 := v264.Get() +v266 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v267 := v266.FindInternedVar(lang.NewSymbol("apply")) +if v267.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v267))) } -v14 = v15 - break +v268 := v267.Get() +v269 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v270 := v269.FindInternedVar(lang.NewSymbol("vector")) +if v270.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v270))) } -return v14 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v271 := v270.Get() +v272 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v273 := v272.FindInternedVar(lang.NewSymbol("seq")) +if v273.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v273))) } +v274 := v273.Get() +v275 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v276 := v275.FindInternedVar(lang.NewSymbol("concat")) +if v276.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v276))) } -// longs -{ -var v1 lang.FnFunc -{ // function longs -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v277 := v276.Get() +v278 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v279 := v278.FindInternedVar(lang.NewSymbol("list")) +if v279.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v279))) } -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v280 := v279.Get() +v281 := lang.Apply(v280, []any{lang.NewSymbol("array__0__auto__")}) +v282 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v283 := v282.FindInternedVar(lang.NewSymbol("list")) +if v283.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v283))) } -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v284 := v283.Get() +v285 := lang.Apply(v284, []any{lang.NewSymbol("idx__1__auto__")}) +v286 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v287 := v286.FindInternedVar(lang.NewSymbol("list")) +if v287.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v287))) } -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v288 := v287.Get() +v289 := lang.Apply(v288, []any{lang.NewSymbol("idx2__3__auto__")}) +v290 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v291 := v290.FindInternedVar(lang.NewSymbol("list")) +if v291.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v291))) } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v292 := v291.Get() +v293 := lang.Apply(v292, []any{lang.NewSymbol("&")}) +v294 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v295 := v294.FindInternedVar(lang.NewSymbol("list")) +if v295.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v295))) } -v20 := v19.Get() -v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/longs")}) -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("list")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v296 := v295.Get() +v297 := lang.Apply(v296, []any{lang.NewSymbol("idxv__4__auto__")}) +v298 := lang.Apply(v277, []any{v281, v285, v289, v293, v297}) +v299 := lang.Apply(v274, []any{v298}) +v300 := lang.Apply(v268, []any{v271, v299}) +v301 := lang.Apply(v265, []any{v300}) +v302 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v303 := v302.FindInternedVar(lang.NewSymbol("list")) +if v303.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v303))) } -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v26 := lang.Apply(v9, []any{v13, v17, v21, v25}) -v27 := lang.Apply(v6, []any{v26}) -return v27 -}) -v2 := v1 -_ = v2 +v304 := v303.Get() +v305 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v306 := v305.FindInternedVar(lang.NewSymbol("seq")) +if v306.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v306))) } -v0 := lang.NewSymbol("longs").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Casts to long[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5407), lang.NewKeyword("end-line"), int(5407))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "longs") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("longs is not a function"))) +v307 := v306.Get() +v308 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v309 := v308.FindInternedVar(lang.NewSymbol("concat")) +if v309.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v309))) } -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +v310 := v309.Get() +v311 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v312 := v311.FindInternedVar(lang.NewSymbol("list")) +if v312.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v312))) } +v313 := v312.Get() +v314 := lang.Apply(v313, []any{lang.NewSymbol("glojure.core/apply")}) +v315 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v316 := v315.FindInternedVar(lang.NewSymbol("list")) +if v316.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v316))) } -// realized? -{ -v0 := lang.NewSymbol("realized?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if a value has been produced for a promise, delay, future or lazy sequence.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7602), lang.NewKeyword("end-line"), int(7602))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, ok := lang.FieldOrMethod(v3, "isRealized") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "isRealized"))) +v317 := v316.Get() +v318 := lang.Apply(v317, []any{v5}) +v319 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v320 := v319.FindInternedVar(lang.NewSymbol("list")) +if v320.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v320))) } -var v5 any -switch reflect.TypeOf(v4).Kind() { -case reflect.Func: - v5 = lang.Apply(v4, nil) -default: - v5 = v4 +v321 := v320.Get() +v322 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v323 := v322.FindInternedVar(lang.NewSymbol("seq")) +if v323.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v323))) } -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v324 := v323.Get() +v325 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v326 := v325.FindInternedVar(lang.NewSymbol("concat")) +if v326.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v326))) } +v327 := v326.Get() +v328 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v329 := v328.FindInternedVar(lang.NewSymbol("list")) +if v329.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v329))) } -// float? -{ -v0 := lang.NewSymbol("float?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is a floating point number", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3605), lang.NewKeyword("end-line"), int(3605))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v330 := v329.Get() +v331 := lang.Apply(v330, []any{lang.NewSymbol("glojure.core/aget")}) +v332 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v333 := v332.FindInternedVar(lang.NewSymbol("list")) +if v333.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v333))) } -v7 := v6.Get() -v8 := lang.Apply(v7, []any{lang.Builtins["float64"], v3}) -var v4 any = v8 -_ = v4 -var v10 any -if lang.IsTruthy(v4) { -v10 = v4 -} else { -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("instance?")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v334 := v333.Get() +v335 := lang.Apply(v334, []any{lang.NewSymbol("array__0__auto__")}) +v336 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v337 := v336.FindInternedVar(lang.NewSymbol("list")) +if v337.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v337))) } -v13 := v12.Get() -v14 := lang.Apply(v13, []any{lang.Builtins["float32"], v3}) -v10 = v14 +v338 := v337.Get() +v339 := lang.Apply(v338, []any{lang.NewSymbol("idx__1__auto__")}) +v340 := lang.Apply(v327, []any{v331, v335, v339}) +v341 := lang.Apply(v324, []any{v340}) +v342 := lang.Apply(v321, []any{v341}) +v343 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v344 := v343.FindInternedVar(lang.NewSymbol("list")) +if v344.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v344))) } -return v10 +v345 := v344.Get() +v346 := lang.Apply(v345, []any{lang.NewSymbol("idx2__3__auto__")}) +v347 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v348 := v347.FindInternedVar(lang.NewSymbol("list")) +if v348.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v348))) +} +v349 := v348.Get() +v350 := lang.Apply(v349, []any{lang.NewSymbol("idxv__4__auto__")}) +v351 := lang.Apply(v310, []any{v314, v318, v342, v346, v350}) +v352 := lang.Apply(v307, []any{v351}) +v353 := lang.Apply(v304, []any{v352}) +v354 := lang.Apply(v262, []any{v301, v353}) +v355 := lang.Apply(v259, []any{v354}) +v356 := lang.Apply(v256, []any{v355}) +v357 := lang.Apply(v13, []any{v17, v21, v142, v253, v356}) +v358 := lang.Apply(v10, []any{v357}) +return v358 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -22164,551 +21217,338 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// interpose +// definline { -v0 := lang.NewSymbol("interpose").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sep")), lang.NewVector(lang.NewSymbol("sep"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy seq of the elements of coll separated by sep.\n Returns a stateful transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5230), lang.NewKeyword("end-line"), int(5230))).(*lang.Symbol) +v0 := lang.NewSymbol("definline").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("decl"))), lang.NewKeyword("doc"), "Experimental - like defmacro, except defines a named function whose\n body is the expansion, calls to which may be expanded inline as if\n it were a macro. Cannot be used with variadic (&) args.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5253), lang.NewKeyword("end-line"), int(5253))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 1: -v3 := args[0] -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := args[0] -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("volatile!")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{false}) -var v6 any = v10 -_ = v6 -var v12 lang.FnFunc -v12 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v13 := lang.Apply(v5, nil) -return v13 - case 1: -v13 := args[0] -v14 := lang.Apply(v5, []any{v13}) -return v14 - case 2: -v13 := args[0] -v14 := args[1] -var v15 any -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("deref")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v6}) -if lang.IsTruthy(v19) { -v21 := lang.Apply(v5, []any{v13, v3}) -var v20 any = v21 -_ = v20 -var v23 any -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("reduced?")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v20}) -if lang.IsTruthy(v27) { -v23 = v20 -} else { -v28 := lang.Apply(v5, []any{v20, v14}) -v23 = v28 -} -v15 = v23 -} else { -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("vreset!")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.Apply(v22, []any{v6, true}) -_ = v23 -v24 := lang.Apply(v5, []any{v13, v14}) -v15 = v24 -} -return v15 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5238), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(5249), lang.NewKeyword("end-column"), int(35)) -v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v14 -}) -v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5236), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(5249), lang.NewKeyword("end-column"), int(37)) -v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v6 - case 2: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("drop")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() +v5 := args[2] +v6 := lang.NewList(args[3:]...) v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("interleave")) +v9 := v8.FindInternedVar(lang.NewSymbol("split-with")) if v9.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } v10 := v9.Get() v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("repeat")) +v12 := v11.FindInternedVar(lang.NewSymbol("comp")) if v12.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } v13 := v12.Get() -v14 := lang.Apply(v13, []any{v3}) -v15 := lang.Apply(v10, []any{v14, v4}) -v16 := lang.Apply(v7, []any{int64(1), v15}) -return v16 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// get-validator -{ -v0 := lang.NewSymbol("get-validator").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("iref"))), lang.NewKeyword("doc"), "Gets the validator-fn for a var/ref/agent/atom.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2392), lang.NewKeyword("end-line"), int(2392))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, _ := lang.FieldOrMethod(v3, "getValidator") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("getValidator is not a function"))) -} -v5 := lang.Apply(v4, []any{}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// flush -{ -v0 := lang.NewSymbol("flush").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Flushes the output stream that is the current value of\n *out*", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3706), lang.NewKeyword("end-line"), int(3706))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v4 := v3.FindInternedVar(lang.NewSymbol("*out*")) -if v4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) -} -v5 := v4.Get() -v6, _ := lang.FieldOrMethod(v5, "Sync") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Sync is not a function"))) -} -v7 := lang.Apply(v6, []any{}) -_ = v7 -return nil -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// load-all -{ -v0 := lang.NewSymbol("load-all").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"), lang.NewSymbol("need-ns"), lang.NewSymbol("require"))), lang.NewKeyword("doc"), "Loads a lib given its name and forces a load of any libs it directly or\n indirectly loads. If need-ns, ensures that the associated namespace\n exists after loading. If require, records the load so any duplicate loads\n can be skipped.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5935), lang.NewKeyword("end-line"), int(5935), lang.NewKeyword("private"), true)).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -var v6 lang.FnFunc -v6 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("commute")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("*loaded-libs*")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -var v13 lang.FnFunc -v13 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v14 := args[0] -v15 := args[1] -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("reduce1")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("conj")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v18, []any{v21, v14, v15}) -return v22 -}) -v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5942), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(5942), lang.NewKeyword("end-column"), int(47)) -v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) -if err != nil { - panic(err) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("not")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } +v16 := v15.Get() v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("push-thread-bindings")) +v18 := v17.FindInternedVar(lang.NewSymbol("vector?")) if v18.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("hash-map")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*loaded-libs*")) -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("ref")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +v20 := lang.Apply(v13, []any{v16, v19}) +v21 := lang.Apply(v10, []any{v20, v6}) +var v7 any = v21 +_ = v7 +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("nth")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("sorted-set")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v25 := v24.Get() +v26 := lang.Apply(v25, []any{v7, int64(0), nil}) +var v22 any = v26 +_ = v22 +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("nth")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } -v29 := v28.Get() -v30 := lang.Apply(v29, nil) -v31 := lang.Apply(v26, []any{v30}) -v32 := lang.Apply(v22, []any{v23, v31}) -v33 := lang.Apply(v19, []any{v32}) -_ = v33 -var v34 any -func() { -defer func() { -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +v30 := v29.Get() +v31 := lang.Apply(v30, []any{v7, int64(1), nil}) +var v27 any = v31 +_ = v27 +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("nth")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) } -v37 := v36.Get() -v38 := lang.Apply(v37, nil) -}() -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("load-one")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v27, int64(0), nil}) +var v32 any = v36 +_ = v32 +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("nth")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) } -v41 := v40.Get() -v42 := lang.Apply(v41, []any{v3, v4, v5}) -_ = v42 +v40 := v39.Get() +v41 := lang.Apply(v40, []any{v27, int64(1), nil}) +var v37 any = v41 +_ = v37 v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("deref")) +v44 := v43.FindInternedVar(lang.NewSymbol("seq")) if v44.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) } v45 := v44.Get() v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("*loaded-libs*")) +v47 := v46.FindInternedVar(lang.NewSymbol("concat")) if v47.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) } v48 := v47.Get() -v49 := lang.Apply(v45, []any{v48}) -v34 = v49 -}() -v16 := lang.Apply(v9, []any{v12, v15, v34}) -return v16 -}) -v7, _ := lang.FieldOrMethod(lang1.LockingTransaction, "RunInTransaction") -if reflect.TypeOf(v7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("RunInTransaction is not a function"))) +v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v50 := v49.FindInternedVar(lang.NewSymbol("list")) +if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) } -v8 := lang.Apply(v7, []any{v6}) -return v8 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v51 := v50.Get() +v52 := lang.Apply(v51, []any{lang.NewSymbol("do")}) +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("list")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) } +v55 := v54.Get() +v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v57 := v56.FindInternedVar(lang.NewSymbol("seq")) +if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) } -// byte-array -{ -var v1 lang.FnFunc -{ // function byte-array__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewList(args[0:]...) -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v58 := v57.Get() +v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v60 := v59.FindInternedVar(lang.NewSymbol("concat")) +if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) } -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v61 := v60.Get() +v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v63 := v62.FindInternedVar(lang.NewSymbol("list")) +if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) } -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v64 := v63.Get() +v65 := lang.Apply(v64, []any{lang.NewSymbol("glojure.core/defn")}) +v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v67 := v66.FindInternedVar(lang.NewSymbol("list")) +if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) } -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v68 := v67.Get() +v69 := lang.Apply(v68, []any{v5}) +v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v71 := v70.FindInternedVar(lang.NewSymbol("list")) +if v71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v72 := v71.Get() +v73 := lang.Apply(v72, []any{v32}) +v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v75 := v74.FindInternedVar(lang.NewSymbol("list")) +if v75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) } -v20 := v19.Get() -v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/byteArray")}) -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("list")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v76 := v75.Get() +v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v78 := v77.FindInternedVar(lang.NewSymbol("apply")) +if v78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) } -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("seq")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +v79 := v78.Get() +v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v81 := v80.FindInternedVar(lang.NewSymbol("eval")) +if v81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) } -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("concat")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +v82 := v81.Get() +v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v84 := v83.FindInternedVar(lang.NewSymbol("list")) +if v84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) } -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v85 := v84.Get() +v86 := lang.Apply(v85, []any{lang.NewSymbol("glojure.core/fn"), v32, v37}) +v87 := lang.Apply(v82, []any{v86}) +v88 := lang.Apply(v79, []any{v87, v32}) +v89 := lang.Apply(v76, []any{v88}) +v90 := lang.Apply(v61, []any{v65, v69, v22, v73, v89}) +v91 := lang.Apply(v58, []any{v90}) +v92 := lang.Apply(v55, []any{v91}) +v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v94 := v93.FindInternedVar(lang.NewSymbol("list")) +if v94.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) } -v33 := v32.Get() -v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("list")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +v95 := v94.Get() +v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v97 := v96.FindInternedVar(lang.NewSymbol("seq")) +if v97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) } -v37 := v36.Get() -v38 := lang.Apply(v37, []any{lang.NewSymbol("glojure.core/args")}) -v39 := lang.Apply(v30, []any{v34, v38}) -v40 := lang.Apply(v27, []any{v39}) -v41 := lang.Apply(v24, []any{v40}) -v42 := lang.Apply(v9, []any{v13, v17, v21, v41}) -v43 := lang.Apply(v6, []any{v42}) -return v43 - } -}) -v2 := v1 -_ = v2 +v98 := v97.Get() +v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v100 := v99.FindInternedVar(lang.NewSymbol("concat")) +if v100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) } -v0 := lang.NewSymbol("byte-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Creates an array of bytes", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)int64(2)), lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5317), lang.NewKeyword("end-line"), int(5317))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "byteArray") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("byteArray is not a function"))) +v101 := v100.Get() +v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v103 := v102.FindInternedVar(lang.NewSymbol("list")) +if v103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) } -v6 := lang.Apply(v5, []any{v4}) -return v6 - case 2: -v4 := args[0] -v5 := args[1] -v6, _ := lang.FieldOrMethod(lang1.Numbers, "byteArrayInit") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("byteArrayInit is not a function"))) +v104 := v103.Get() +v105 := lang.Apply(v104, []any{lang.NewSymbol("glojure.core/alter-meta!")}) +v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v107 := v106.FindInternedVar(lang.NewSymbol("list")) +if v107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) } -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +v108 := v107.Get() +v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v110 := v109.FindInternedVar(lang.NewSymbol("seq")) +if v110.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) } +v111 := v110.Get() +v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v113 := v112.FindInternedVar(lang.NewSymbol("concat")) +if v113.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) } -// sorted? -{ -v0 := lang.NewSymbol("sorted?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements Sorted", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6278), lang.NewKeyword("end-line"), int(6278))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v114 := v113.Get() +v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v116 := v115.FindInternedVar(lang.NewSymbol("list")) +if v116.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) } -v6 := v5.Get() -v7 := lang.Apply(v6, []any{glojure.lang11.Sorted, v3}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v117 := v116.Get() +v118 := lang.Apply(v117, []any{lang.NewSymbol("var")}) +v119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v120 := v119.FindInternedVar(lang.NewSymbol("list")) +if v120.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v120))) } +v121 := v120.Get() +v122 := lang.Apply(v121, []any{v5}) +v123 := lang.Apply(v114, []any{v118, v122}) +v124 := lang.Apply(v111, []any{v123}) +v125 := lang.Apply(v108, []any{v124}) +v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v127 := v126.FindInternedVar(lang.NewSymbol("list")) +if v127.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) } -// chunk-rest -{ -v0 := lang.NewSymbol("chunk-rest").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(697), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(697), lang.NewKeyword("end-column"), int(71), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, ok := lang.FieldOrMethod(v3, "chunkedMore") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "chunkedMore"))) +v128 := v127.Get() +v129 := lang.Apply(v128, []any{lang.NewSymbol("glojure.core/assoc")}) +v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v131 := v130.FindInternedVar(lang.NewSymbol("list")) +if v131.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) } -var v5 any -switch reflect.TypeOf(v4).Kind() { -case reflect.Func: - v5 = lang.Apply(v4, nil) -default: - v5 = v4 +v132 := v131.Get() +v133 := lang.Apply(v132, []any{lang.NewKeyword("inline")}) +v134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v135 := v134.FindInternedVar(lang.NewSymbol("list")) +if v135.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v135))) } -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v136 := v135.Get() +v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v138 := v137.FindInternedVar(lang.NewSymbol("seq")) +if v138.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) } +v139 := v138.Get() +v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v141 := v140.FindInternedVar(lang.NewSymbol("concat")) +if v141.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) } -// int? -{ -v0 := lang.NewSymbol("int?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a fixed precision integer", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1395), lang.NewKeyword("end-line"), int(1395))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v142 := v141.Get() +v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v144 := v143.FindInternedVar(lang.NewSymbol("list")) +if v144.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) } -v7 := v6.Get() -v8 := lang.Apply(v7, []any{lang.Builtins["int64"], v3}) -var v4 any = v8 -_ = v4 -var v10 any -if lang.IsTruthy(v4) { -v10 = v4 -} else { -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("instance?")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +v145 := v144.Get() +v146 := lang.Apply(v145, []any{lang.NewSymbol("glojure.core/fn")}) +v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v148 := v147.FindInternedVar(lang.NewSymbol("list")) +if v148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) } -v14 := v13.Get() -v15 := lang.Apply(v14, []any{nil, v3}) -var v11 any = v15 -_ = v11 -var v17 any -if lang.IsTruthy(v11) { -v17 = v11 -} else { -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("instance?")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v149 := v148.Get() +v150 := lang.Apply(v149, []any{v5}) +v151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v152 := v151.FindInternedVar(lang.NewSymbol("list")) +if v152.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v152))) } -v21 := v20.Get() -v22 := lang.Apply(v21, []any{nil, v3}) -var v18 any = v22 -_ = v18 -var v24 any -if lang.IsTruthy(v18) { -v24 = v18 -} else { -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("instance?")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +v153 := v152.Get() +v154 := lang.Apply(v153, []any{v32}) +v155 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v156 := v155.FindInternedVar(lang.NewSymbol("list")) +if v156.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v156))) } -v27 := v26.Get() -v28 := lang.Apply(v27, []any{nil, v3}) -v24 = v28 +v157 := v156.Get() +v158 := lang.Apply(v157, []any{v37}) +v159 := lang.Apply(v142, []any{v146, v150, v154, v158}) +v160 := lang.Apply(v139, []any{v159}) +v161 := lang.Apply(v136, []any{v160}) +v162 := lang.Apply(v101, []any{v105, v125, v129, v133, v161}) +v163 := lang.Apply(v98, []any{v162}) +v164 := lang.Apply(v95, []any{v163}) +v165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v166 := v165.FindInternedVar(lang.NewSymbol("list")) +if v166.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v166))) } -v17 = v24 +v167 := v166.Get() +v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v169 := v168.FindInternedVar(lang.NewSymbol("seq")) +if v169.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) } -v10 = v17 +v170 := v169.Get() +v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v172 := v171.FindInternedVar(lang.NewSymbol("concat")) +if v172.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) } -return v10 +v173 := v172.Get() +v174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v175 := v174.FindInternedVar(lang.NewSymbol("list")) +if v175.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v175))) +} +v176 := v175.Get() +v177 := lang.Apply(v176, []any{lang.NewSymbol("var")}) +v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v179 := v178.FindInternedVar(lang.NewSymbol("list")) +if v179.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) +} +v180 := v179.Get() +v181 := lang.Apply(v180, []any{v5}) +v182 := lang.Apply(v173, []any{v177, v181}) +v183 := lang.Apply(v170, []any{v182}) +v184 := lang.Apply(v167, []any{v183}) +v185 := lang.Apply(v48, []any{v52, v92, v164, v184}) +v186 := lang.Apply(v45, []any{v185}) +return v186 + } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -22716,420 +21556,544 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// spit +// defmacro { -v0 := lang.NewSymbol("spit").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("content"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Opposite of slurp. Opens f with writer, writes content, then\n closes f. Options passed to glojure.java.io/writer.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7037), lang.NewKeyword("end-line"), int(7037))).(*lang.Symbol) +v0 := lang.NewSymbol("defmacro").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("doc-string?"), lang.NewSymbol("attr-map?"), lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("body")), lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("doc-string?"), lang.NewSymbol("attr-map?"), lang.NewList(lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("body")), lang.NewSymbol("+"), lang.NewSymbol("attr-map?"))), lang.NewKeyword("doc"), "Like defn, but the resulting function name is declared as a\n macro and will be used as a macro by the compiler when it is\n called.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(445), lang.NewKeyword("end-line"), int(451))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 2 { + if len(args) < 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] v4 := args[1] -v5 := lang.NewList(args[2:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("apply")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{nil, v3, v5}) -var v6 any = v10 -_ = v6 -var v12 any -func() { -defer func() { -v13, ok := lang.FieldOrMethod(v6, "close") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "close"))) +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("list")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v5}) +var v8 any = v12 +_ = v8 +var v13 any = v13 +_ = v13 var v14 any -switch reflect.TypeOf(v13).Kind() { -case reflect.Func: - v14 = lang.Apply(v13, nil) -default: - v14 = v13 +for { +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("first")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -}() +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v13}) +var v15 any = v19 +_ = v15 +var v21 any +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("string?")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v15}) +if lang.IsTruthy(v25) { +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("cons")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{v15, v8}) +var v26 any = v30 +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("next")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v13}) +var v31 any = v35 +v8 = v26 +v13 = v31 +continue +} else { +var v36 any +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("map?")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v15}) +if lang.IsTruthy(v40) { +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("cons")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +} +v44 := v43.Get() +v45 := lang.Apply(v44, []any{v15, v8}) +var v41 any = v45 +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("next")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +} +v49 := v48.Get() +v50 := lang.Apply(v49, []any{v13}) +var v46 any = v50 +v8 = v41 +v13 = v46 +continue +} else { +v36 = v8 +} +v21 = v36 +} +v14 = v21 + break +} +var v7 any = v14 +_ = v7 +var v9 any = v6 +_ = v9 +var v10 any +for { +var v11 any +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("string?")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("str")) +v16 := v15.FindInternedVar(lang.NewSymbol("first")) if v16.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } v17 := v16.Get() -v18 := lang.Apply(v17, []any{v4}) -v19 := lang.Apply(lang1.WriteWriter, []any{v6, v18}) -v12 = v19 -}() -return v12 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v18 := lang.Apply(v17, []any{v9}) +v19 := lang.Apply(v14, []any{v18}) +if lang.IsTruthy(v19) { +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("next")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v9}) +var v20 any = v24 +v9 = v20 +continue +} else { +var v25 any +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("map?")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) } -// unchecked-add -{ -var v1 lang.FnFunc -{ // function unchecked-add__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("first")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) } -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("concat")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v31 := v30.Get() +v32 := lang.Apply(v31, []any{v9}) +v33 := lang.Apply(v28, []any{v32}) +if lang.IsTruthy(v33) { +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("next")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) } -v10 := v9.Get() +v37 := v36.Get() +v38 := lang.Apply(v37, []any{v9}) +var v34 any = v38 +v9 = v34 +continue +} else { +v25 = v9 +} +v11 = v25 +} +v10 = v11 + break +} +var v8 any = v10 +_ = v8 +var v10 any v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("list")) +v12 := v11.FindInternedVar(lang.NewSymbol("vector?")) if v12.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } v13 := v12.Get() -v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("first")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v9}) +v18 := lang.Apply(v13, []any{v17}) +if lang.IsTruthy(v18) { v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v20 := v19.FindInternedVar(lang.NewSymbol("list")) if v20.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("seq")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("concat")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +v22 := lang.Apply(v21, []any{v9}) +v10 = v22 +} else { +v10 = v9 } -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("list")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +var v9 any = v10 +_ = v9 +var v24 lang.FnFunc +v24 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v25 := args[0] +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("first")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v30 := v29.Get() -v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/unchecked_add")}) +v29 := v28.Get() +v30 := lang.Apply(v29, []any{v25}) +var v26 any = v30 +_ = v26 v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) +v33 := v32.FindInternedVar(lang.NewSymbol("cons")) if v33.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) } v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("vec")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) } -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v4}) -v40 := lang.Apply(v27, []any{v31, v35, v39}) -v41 := lang.Apply(v24, []any{v40}) -v42 := lang.Apply(v21, []any{v41}) -v43 := lang.Apply(v10, []any{v14, v18, v42}) -v44 := lang.Apply(v7, []any{v43}) -return v44 +v37 := v36.Get() +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("cons")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("cons")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v43, []any{lang.NewSymbol("&env"), v26}) +v45 := lang.Apply(v40, []any{lang.NewSymbol("&form"), v44}) +v46 := lang.Apply(v37, []any{v45}) +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("next")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +} +v49 := v48.Get() +v50 := lang.Apply(v49, []any{v25}) +v51 := lang.Apply(v34, []any{v46, v50}) +return v51 }) -v2 := v1 -_ = v2 +v25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(469), lang.NewKeyword("column"), int(38), lang.NewKeyword("end-line"), int(471), lang.NewKeyword("end-column"), int(87)) +v26, err := lang.WithMeta(v24, v25.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v0 := lang.NewSymbol("unchecked-add").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the sum of x and y, both long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1203), lang.NewKeyword("end-line"), int(1203))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { +var v23 any = v26 +_ = v23 +var v28 lang.FnFunc +v28 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v4 := args[0] -v5 := args[1] -v6, _ := lang.FieldOrMethod(lang1.Numbers, "unchecked_add") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_add is not a function"))) -} -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +v29 := args[0] +v30 := args[1] +recur_loop_61: +var v31 any +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("nil?")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) } +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v30}) +if lang.IsTruthy(v35) { +v31 = v29 +} else { +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("first")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -// float-array -{ -var v1 lang.FnFunc -{ // function float-array__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewList(args[0:]...) -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v30}) +var v36 any = v40 +_ = v36 +var v42 any +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("map?")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) } -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v45 := v44.Get() +v46 := lang.Apply(v45, []any{v36}) +if lang.IsTruthy(v46) { +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("conj")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) } -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v49 := v48.Get() +v50 := lang.Apply(v49, []any{v29, v36}) +v42 = v50 +} else { +v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v53 := v52.FindInternedVar(lang.NewSymbol("conj")) +if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) } -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v54 := v53.Get() +v55 := lang.Apply(v23, []any{v36}) +v56 := lang.Apply(v54, []any{v29, v55}) +var v51 any = v56 +v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v59 := v58.FindInternedVar(lang.NewSymbol("next")) +if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v60 := v59.Get() +v61 := lang.Apply(v60, []any{v30}) +var v57 any = v61 +v29 = v51 +v30 = v57 +goto recur_loop_61 } -v20 := v19.Get() -v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/floatArray")}) -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("list")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v31 = v42 } -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("seq")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +return v31 +}) +v29 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(472), lang.NewKeyword("column"), int(29), lang.NewKeyword("end-line"), int(478), lang.NewKeyword("end-column"), int(90)) +v30, err := lang.WithMeta(v28, v29.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("concat")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +var v27 any = v30 +_ = v27 +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("seq")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) } -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v34 := v33.Get() +v35 := lang.NewVector() +v36 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(479), lang.NewKeyword("column"), int(41), lang.NewKeyword("end-line"), int(479), lang.NewKeyword("end-column"), int(42)) +v37, err := lang.WithMeta(v35, v36.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v33 := v32.Get() -v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("list")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +v38 := lang.Apply(v27, []any{v37, v31}) +v39 := lang.Apply(v34, []any{v38}) +var v31 any = v39 +_ = v31 +var v41 any = v7 +_ = v41 +var v42 any = v31 +_ = v42 +var v43 any +for { +var v44 any +if lang.IsTruthy(v41) { +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("next")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) } -v37 := v36.Get() -v38 := lang.Apply(v37, []any{lang.NewSymbol("glojure.core/args")}) -v39 := lang.Apply(v30, []any{v34, v38}) -v40 := lang.Apply(v27, []any{v39}) -v41 := lang.Apply(v24, []any{v40}) -v42 := lang.Apply(v9, []any{v13, v17, v21, v41}) -v43 := lang.Apply(v6, []any{v42}) -return v43 - } -}) -v2 := v1 -_ = v2 +v48 := v47.Get() +v49 := lang.Apply(v48, []any{v41}) +var v45 any = v49 +v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v52 := v51.FindInternedVar(lang.NewSymbol("cons")) +if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) } -v0 := lang.NewSymbol("float-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Creates an array of floats", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5301), lang.NewKeyword("end-line"), int(5301))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "floatArray") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("floatArray is not a function"))) +v53 := v52.Get() +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("first")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) } -v6 := lang.Apply(v5, []any{v4}) -return v6 - case 2: -v4 := args[0] -v5 := args[1] -v6, _ := lang.FieldOrMethod(lang1.Numbers, "floatArrayInit") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("floatArrayInit is not a function"))) +v56 := v55.Get() +v57 := lang.Apply(v56, []any{v41}) +v58 := lang.Apply(v53, []any{v57, v42}) +var v50 any = v58 +v41 = v45 +v42 = v50 +continue +} else { +v44 = v42 } -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +v43 = v44 + break } +var v40 any = v43 +_ = v40 +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("list")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) } -// reduced -{ -v0 := lang.NewSymbol("reduced").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Wraps x in a way such that a reduce will terminate with the value x", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2828), lang.NewKeyword("end-line"), int(2828))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) +v44 := v43.Get() +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("cons")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +} +v47 := v46.Get() +v48 := lang.Apply(v47, []any{lang.NewSymbol("glojure.core/defn"), v40}) +v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v50 := v49.FindInternedVar(lang.NewSymbol("list")) +if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) +} +v51 := v50.Get() +v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v53 := v52.FindInternedVar(lang.NewSymbol("list")) +if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) +} +v54 := v53.Get() +v55 := lang.Apply(v54, []any{lang.NewSymbol("var"), v5}) +v56 := lang.Apply(v51, []any{lang.NewSymbol("."), v55, lang.NewList(lang.NewSymbol("SetMacro"))}) +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("list")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +} +v59 := v58.Get() +v60 := lang.Apply(v59, []any{lang.NewSymbol("var"), v5}) +v61 := lang.Apply(v44, []any{lang.NewSymbol("do"), v48, v56, v60}) +return v61 } -v3 := args[0] -v4 := lang.Apply(lang1.NewReduced, []any{v3}) -return v4 }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(451), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(487), lang.NewKeyword("end-column"), int(40))).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// doubles +// defmethod { -var v1 lang.FnFunc -{ // function doubles -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } +v0 := lang.NewSymbol("defmethod").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"), lang.NewSymbol("dispatch-val"), lang.NewSymbol("&"), lang.NewSymbol("fn-tail"))), lang.NewKeyword("doc"), "Creates and installs a new method of multimethod associated with dispatch-value. ", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1781), lang.NewKeyword("end-line"), int(1781))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := lang.NewList(args[4:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("seq")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("concat")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v13 := v12.Get() v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v15 := v14.FindInternedVar(lang.NewSymbol("list")) if v15.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v17 := lang.Apply(v16, []any{lang.NewSymbol(".")}) v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v19 := v18.FindInternedVar(lang.NewSymbol("list")) if v19.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } v20 := v19.Get() -v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/doubles")}) -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("list")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v26 := lang.Apply(v9, []any{v13, v17, v21, v25}) -v27 := lang.Apply(v6, []any{v26}) -return v27 -}) -v2 := v1 -_ = v2 +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("with-meta")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v0 := lang.NewSymbol("doubles").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Casts to double[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5402), lang.NewKeyword("end-line"), int(5402))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "doubles") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("doubles is not a function"))) +v23 := v22.Get() +v24 := lang.NewMap(lang.NewKeyword("tag"), lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.*MultiFn")) +v25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1785), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(1785), lang.NewKeyword("end-column"), int(82)) +v26, err := lang.WithMeta(v24, v25.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +v27 := lang.Apply(v23, []any{v5, v26}) +v28 := lang.Apply(v20, []any{v27}) +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("list")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) } +v31 := v30.Get() +v32 := lang.Apply(v31, []any{lang.NewSymbol("glojure.core/AddMethod")}) +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("list")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) } -// bases -{ -v0 := lang.NewSymbol("bases").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"))), lang.NewKeyword("doc"), "Returns the immediate superclass and direct interfaces of c, if any", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5565), lang.NewKeyword("end-line"), int(5565))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -var v4 any -if lang.IsTruthy(v3) { -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("seq")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v6}) +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("list")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -v8 := v7.Get() -v9 := lang.Apply(v8, []any{nil}) -var v5 any = v9 -_ = v5 -var v10 any = nil -_ = v10 -var v12 any -if lang.IsTruthy(v10) { -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("cons")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("seq")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) } -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v10, v5}) -v12 = v16 -} else { -v12 = v5 +v42 := v41.Get() +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("concat")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) } -v4 = v12 -} else { -v4 = nil +v45 := v44.Get() +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("list")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) } -return v4 +v48 := v47.Get() +v49 := lang.Apply(v48, []any{lang.NewSymbol("glojure.core/fn")}) +v50 := lang.Apply(v45, []any{v49, v7}) +v51 := lang.Apply(v42, []any{v50}) +v52 := lang.Apply(v39, []any{v51}) +v53 := lang.Apply(v13, []any{v17, v28, v32, v36, v52}) +v54 := lang.Apply(v10, []any{v53}) +return v54 + } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -23137,705 +22101,634 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// get-method +// defmulti { -v0 := lang.NewSymbol("get-method").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"), lang.NewSymbol("dispatch-val"))), lang.NewKeyword("doc"), "Given a multimethod and a dispatch value, returns the dispatch fn\n that would apply to that value, or nil if none apply and no default", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1815), lang.NewKeyword("end-line"), int(1815))).(*lang.Symbol) +v0 := lang.NewSymbol("defmulti").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("docstring?"), lang.NewSymbol("attr-map?"), lang.NewSymbol("dispatch-fn"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Creates a new multimethod with the associated dispatch function.\n The docstring and attr-map are optional.\n\n Options are key-value pairs and may be one of:\n\n :default\n\n The default dispatch value, defaults to :default\n\n :hierarchy\n\n The value used for hierarchical dispatch (e.g. ::square is-a ::shape)\n\n Hierarchies are type-like relationships that do not depend upon type\n inheritance. By default Clojure's multimethods dispatch off of a\n global hierarchy map. However, a hierarchy relationship can be\n created with the derive function used to augment the root ancestor\n created with make-hierarchy.\n\n Multimethods expect the value of the hierarchy option to be supplied as\n a reference type e.g. a var (i.e. via the Var-quote dispatch macro #'\n or the var special form).", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1723), lang.NewKeyword("end-line"), int(1723))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] v4 := args[1] -v5, _ := lang.FieldOrMethod(v3, "getMethod") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("getMethod is not a function"))) +v5 := args[2] +v6 := lang.NewList(args[3:]...) +var v8 any +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("string?")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("first")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v6}) +v16 := lang.Apply(v11, []any{v15}) +if lang.IsTruthy(v16) { +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("first")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -// cycle -{ -v0 := lang.NewSymbol("cycle").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy (infinite!) sequence of repetitions of the items in coll.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2977), lang.NewKeyword("end-line"), int(2977))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v6}) +v8 = v20 +} else { +v8 = nil } -v6 := v5.Get() -v7 := lang.Apply(v6, []any{v3}) -v8 := lang.Apply(lang1.NewCycle, []any{v7}) -return v8 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +var v7 any = v8 +_ = v7 +var v22 any +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("string?")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("first")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) } -// iterate -{ -v0 := lang.NewSymbol("iterate").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns a lazy (infinite!) sequence of x, (f x), (f (f x)) etc.\n f must be free of side-effects", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3011), lang.NewKeyword("end-line"), int(3011))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.Apply(nil, []any{v3, v4}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v28 := v27.Get() +v29 := lang.Apply(v28, []any{v21}) +v30 := lang.Apply(v25, []any{v29}) +if lang.IsTruthy(v30) { +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("next")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v21}) +v22 = v34 +} else { +v22 = v21 } -// check-cyclic-dependency -{ -v0 := lang.NewSymbol("check-cyclic-dependency").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("path"))), lang.NewKeyword("doc"), "Detects and rejects non-trivial cyclic load dependencies. The\n exception message shows the dependency chain with the cycle\n highlighted. Ignores the trivial case of a file attempting to load\n itself because that can occur when a gen-class'd class loads its\n implementation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(30), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6017), lang.NewKeyword("end-line"), int(6017), lang.NewKeyword("private"), true)).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("some")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +var v21 any = v22 +_ = v21 +var v36 any +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("map?")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -v7 := v6.Get() -v8 := lang.CreatePersistentTreeSet(v3) -v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6024), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(6024), lang.NewKeyword("end-column"), int(21)) -v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) -if err != nil { - panic(err) +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("first")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) } -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("rest")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("*pending-paths*")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v13, []any{v16}) -v18 := lang.Apply(v7, []any{v10, v17}) -if lang.IsTruthy(v18) { -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("map")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -var v23 lang.FnFunc -v23 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v24 := args[0] -var v25 any -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("=")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.Apply(v28, []any{v24, v3}) -if lang.IsTruthy(v29) { -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("str")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v21}) +v44 := lang.Apply(v39, []any{v43}) +if lang.IsTruthy(v44) { +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("first")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) } -v32 := v31.Get() -v33 := lang.Apply(v32, []any{"[ ", v24, " ]"}) -v25 = v33 +v47 := v46.Get() +v48 := lang.Apply(v47, []any{v21}) +v36 = v48 } else { -v25 = v24 -} -return v25 -}) -v24 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6025), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(6025), lang.NewKeyword("end-column"), int(59)) -v25, err := lang.WithMeta(v23, v24.(lang.IPersistentMap)) +v49 := lang.NewMap() +v50 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1757), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(1757), lang.NewKeyword("end-column"), int(24)) +v51, err := lang.WithMeta(v49, v50.(lang.IPersistentMap)) if err != nil { panic(err) } -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("cons")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("*pending-paths*")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.Apply(v28, []any{v3, v31}) -v33 := lang.Apply(v22, []any{v25, v32}) -var v19 any = v33 -_ = v19 -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("apply")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +v36 = v51 } -v37 := v36.Get() -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("str")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +var v35 any = v36 +_ = v35 +var v53 any +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("map?")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) } -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("interpose")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +v56 := v55.Get() +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("first")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) } -v43 := v42.Get() -v44 := lang.Apply(v43, []any{"->", v19}) -v45 := lang.Apply(v37, []any{v40, v44}) -var v34 any = v45 -_ = v34 -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("throw-if")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +v59 := v58.Get() +v60 := lang.Apply(v59, []any{v52}) +v61 := lang.Apply(v56, []any{v60}) +if lang.IsTruthy(v61) { +v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v63 := v62.FindInternedVar(lang.NewSymbol("next")) +if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) } -v49 := v48.Get() -v50 := lang.Apply(v49, []any{true, "Cyclic load dependency: %s", v34}) -v4 = v50 +v64 := v63.Get() +v65 := lang.Apply(v64, []any{v52}) +v53 = v65 } else { -v4 = nil +v53 = v52 } -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +var v52 any = v53 +_ = v52 +v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v68 := v67.FindInternedVar(lang.NewSymbol("first")) +if v68.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) } +v69 := v68.Get() +v70 := lang.Apply(v69, []any{v52}) +var v66 any = v70 +_ = v66 +v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v73 := v72.FindInternedVar(lang.NewSymbol("next")) +if v73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) } -// create-struct -{ -v0 := lang.NewSymbol("create-struct").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keys"))), lang.NewKeyword("doc"), "Returns a structure basis object.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4037), lang.NewKeyword("end-line"), int(4037))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewList(args[0:]...) -v4 := lang.Apply(lang1.CreatePersistentStructMapSlotMap, []any{v3}) -return v4 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v74 := v73.Get() +v75 := lang.Apply(v74, []any{v71}) +var v71 any = v75 +_ = v71 +var v77 any +if lang.IsTruthy(v7) { +v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v79 := v78.FindInternedVar(lang.NewSymbol("assoc")) +if v79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) } +v80 := v79.Get() +v81 := lang.Apply(v80, []any{v76, lang.NewKeyword("doc"), v7}) +v77 = v81 +} else { +v77 = v76 } -// string? -{ -v0 := lang.NewSymbol("string?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a String", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(160), lang.NewKeyword("end-line"), int(164))).(*lang.Symbol) -var v2 lang.FnFunc -{ // function string? -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +var v76 any = v77 +_ = v76 +var v83 any +v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v85 := v84.FindInternedVar(lang.NewSymbol("meta")) +if v85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) } -v7 := v6.Get() -v8 := lang.Apply(v7, []any{lang.Builtins["string"], v4}) -return v8 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(164), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(164), lang.NewKeyword("end-column"), int(58))).(lang.FnFunc) -v3 := v2 -_ = v3 +v86 := v85.Get() +v87 := lang.Apply(v86, []any{v5}) +if lang.IsTruthy(v87) { +v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v89 := v88.FindInternedVar(lang.NewSymbol("conj")) +if v89.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) } -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v90 := v89.Get() +v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v92 := v91.FindInternedVar(lang.NewSymbol("meta")) +if v92.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) } +v93 := v92.Get() +v94 := lang.Apply(v93, []any{v5}) +v95 := lang.Apply(v90, []any{v94, v82}) +v83 = v95 +} else { +v83 = v82 } -// strip-ns -{ -v0 := lang.NewSymbol("strip-ns").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(255), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(255), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("named"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("symbol?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +var v82 any = v83 +_ = v82 +v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v98 := v97.FindInternedVar(lang.NewSymbol("with-meta")) +if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) } -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -if lang.IsTruthy(v8) { -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("symbol")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +v99 := v98.Get() +v100 := lang.Apply(v99, []any{v96, v82}) +var v96 any = v100 +_ = v96 +var v102 any +v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v104 := v103.FindInternedVar(lang.NewSymbol("=")) +if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) } -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("name")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +v105 := v104.Get() +v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v107 := v106.FindInternedVar(lang.NewSymbol("count")) +if v107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) } -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v3}) -v16 := lang.Apply(v11, []any{nil, v15}) -v4 = v16 +v108 := v107.Get() +v109 := lang.Apply(v108, []any{v71}) +v110 := lang.Apply(v105, []any{v109, int64(1)}) +if lang.IsTruthy(v110) { +v111 := lang.Apply(Exception16., []any{"The syntax for defmulti has changed. Example: (defmulti name dispatch-fn :default dispatch-value)"}) +panic(v111) } else { -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("keyword")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +v102 = nil } -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("name")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +_ = v102 +v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v114 := v113.FindInternedVar(lang.NewSymbol("apply")) +if v114.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) } -v22 := v21.Get() -v23 := lang.Apply(v22, []any{v3}) -v24 := lang.Apply(v19, []any{nil, v23}) -v4 = v24 +v115 := v114.Get() +v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v117 := v116.FindInternedVar(lang.NewSymbol("hash-map")) +if v117.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) } -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v118 := v117.Get() +v119 := lang.Apply(v115, []any{v118, v112}) +var v112 any = v119 +_ = v112 +v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v122 := v121.FindInternedVar(lang.NewSymbol("get")) +if v122.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) } +v123 := v122.Get() +v124 := lang.Apply(v123, []any{v112, lang.NewKeyword("default"), lang.NewKeyword("default")}) +var v120 any = v124 +_ = v120 +v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v127 := v126.FindInternedVar(lang.NewSymbol("get")) +if v127.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) } -// defstruct -{ -v0 := lang.NewSymbol("defstruct").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("keys"))), lang.NewKeyword("doc"), "Same as (def name (create-struct keys...))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4044), lang.NewKeyword("end-line"), int(4044))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("seq")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v128 := v127.Get() +v129 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("global-hierarchy")) +v130 := lang.Apply(v128, []any{v112, lang.NewKeyword("hierarchy"), v129}) +var v125 any = v130 +_ = v125 +v132 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v133 := v132.FindInternedVar(lang.NewSymbol("check-valid-options")) +if v133.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v133))) } -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("concat")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v134 := v133.Get() +v135 := lang.Apply(v134, []any{v112, lang.NewKeyword("default"), lang.NewKeyword("hierarchy")}) +_ = v135 +v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v137 := v136.FindInternedVar(lang.NewSymbol("seq")) +if v137.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) } -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("list")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +v138 := v137.Get() +v139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v140 := v139.FindInternedVar(lang.NewSymbol("concat")) +if v140.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v140))) } -v15 := v14.Get() -v16 := lang.Apply(v15, []any{lang.NewSymbol("def")}) -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("list")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +v141 := v140.Get() +v142 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v143 := v142.FindInternedVar(lang.NewSymbol("list")) +if v143.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v143))) } -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v5}) -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("list")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +v144 := v143.Get() +v145 := lang.Apply(v144, []any{lang.NewSymbol("glojure.core/let")}) +v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v147 := v146.FindInternedVar(lang.NewSymbol("list")) +if v147.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) } -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("seq")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +v148 := v147.Get() +v149 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v150 := v149.FindInternedVar(lang.NewSymbol("apply")) +if v150.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v150))) } -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("concat")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v151 := v150.Get() +v152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v153 := v152.FindInternedVar(lang.NewSymbol("vector")) +if v153.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v153))) } -v29 := v28.Get() -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("list")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +v154 := v153.Get() +v155 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v156 := v155.FindInternedVar(lang.NewSymbol("seq")) +if v156.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v156))) } -v32 := v31.Get() -v33 := lang.Apply(v32, []any{lang.NewSymbol("glojure.core/create-struct")}) -v34 := lang.Apply(v29, []any{v33, v6}) -v35 := lang.Apply(v26, []any{v34}) -v36 := lang.Apply(v23, []any{v35}) -v37 := lang.Apply(v12, []any{v16, v20, v36}) -v38 := lang.Apply(v9, []any{v37}) -return v38 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v157 := v156.Get() +v158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v159 := v158.FindInternedVar(lang.NewSymbol("concat")) +if v159.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v159))) } +v160 := v159.Get() +v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v162 := v161.FindInternedVar(lang.NewSymbol("list")) +if v162.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) } -// reset-meta! -{ -v0 := lang.NewSymbol("reset-meta!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("iref"), lang.NewSymbol("metadata-map"))), lang.NewKeyword("doc"), "Atomically resets the metadata for a namespace/var/ref/agent/atom", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2408), lang.NewKeyword("end-line"), int(2408))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5, _ := lang.FieldOrMethod(v3, "ResetMeta") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ResetMeta is not a function"))) +v163 := v162.Get() +v164 := lang.Apply(v163, []any{lang.NewSymbol("v__0__auto__")}) +v165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v166 := v165.FindInternedVar(lang.NewSymbol("list")) +if v166.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v166))) } -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v167 := v166.Get() +v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v169 := v168.FindInternedVar(lang.NewSymbol("seq")) +if v169.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) } +v170 := v169.Get() +v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v172 := v171.FindInternedVar(lang.NewSymbol("concat")) +if v172.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) } -// reset! -{ -v0 := lang.NewSymbol("reset!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atom"), lang.NewSymbol("newval"))), lang.NewKeyword("doc"), "Sets the value of atom to newval without regard for the\n current value. Returns newval.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2368), lang.NewKeyword("end-line"), int(2368))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5, _ := lang.FieldOrMethod(v3, "reset") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) +v173 := v172.Get() +v174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v175 := v174.FindInternedVar(lang.NewSymbol("list")) +if v175.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v175))) } -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v176 := v175.Get() +v177 := lang.Apply(v176, []any{lang.NewSymbol("def")}) +v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v179 := v178.FindInternedVar(lang.NewSymbol("list")) +if v179.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) } +v180 := v179.Get() +v181 := lang.Apply(v180, []any{v96}) +v182 := lang.Apply(v173, []any{v177, v181}) +v183 := lang.Apply(v170, []any{v182}) +v184 := lang.Apply(v167, []any{v183}) +v185 := lang.Apply(v160, []any{v164, v184}) +v186 := lang.Apply(v157, []any{v185}) +v187 := lang.Apply(v151, []any{v154, v186}) +v188 := lang.Apply(v148, []any{v187}) +v189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v190 := v189.FindInternedVar(lang.NewSymbol("list")) +if v190.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v190))) } -// add-doc-and-meta -{ -v0 := lang.NewSymbol("add-doc-and-meta").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("docstring"), lang.NewSymbol("meta"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(26), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6443), lang.NewKeyword("end-line"), int(6443), lang.NewKeyword("private"), true)).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 5 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := args[4] -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("seq")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v191 := v190.Get() +v192 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v193 := v192.FindInternedVar(lang.NewSymbol("seq")) +if v193.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v193))) } -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("concat")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v194 := v193.Get() +v195 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v196 := v195.FindInternedVar(lang.NewSymbol("concat")) +if v196.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v196))) } -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v197 := v196.Get() +v198 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v199 := v198.FindInternedVar(lang.NewSymbol("list")) +if v199.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v199))) } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("glojure.core/alter-meta!")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v200 := v199.Get() +v201 := lang.Apply(v200, []any{lang.NewSymbol("glojure.core/when-not")}) +v202 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v203 := v202.FindInternedVar(lang.NewSymbol("list")) +if v203.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v203))) } -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +v204 := v203.Get() +v205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v206 := v205.FindInternedVar(lang.NewSymbol("seq")) +if v206.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v206))) } -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +v207 := v206.Get() +v208 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v209 := v208.FindInternedVar(lang.NewSymbol("concat")) +if v209.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v209))) } -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v210 := v209.Get() +v211 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v212 := v211.FindInternedVar(lang.NewSymbol("list")) +if v212.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v212))) } -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("var")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v213 := v212.Get() +v214 := lang.Apply(v213, []any{lang.NewSymbol("glojure.core/and")}) +v215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v216 := v215.FindInternedVar(lang.NewSymbol("list")) +if v216.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v216))) } -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v5}) -v35 := lang.Apply(v26, []any{v30, v34}) -v36 := lang.Apply(v23, []any{v35}) -v37 := lang.Apply(v20, []any{v36}) -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("list")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +v217 := v216.Get() +v218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v219 := v218.FindInternedVar(lang.NewSymbol("seq")) +if v219.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v219))) } -v40 := v39.Get() -v41 := lang.Apply(v40, []any{lang.NewSymbol("glojure.core/merge")}) -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("list")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +v220 := v219.Get() +v221 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v222 := v221.FindInternedVar(lang.NewSymbol("concat")) +if v222.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v222))) } -v44 := v43.Get() -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("seq")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +v223 := v222.Get() +v224 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v225 := v224.FindInternedVar(lang.NewSymbol("list")) +if v225.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v225))) } -v47 := v46.Get() -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("concat")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +v226 := v225.Get() +v227 := lang.Apply(v226, []any{lang.NewSymbol(".HasRoot")}) +v228 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v229 := v228.FindInternedVar(lang.NewSymbol("list")) +if v229.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v229))) } -v50 := v49.Get() -v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v52 := v51.FindInternedVar(lang.NewSymbol("list")) -if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) +v230 := v229.Get() +v231 := lang.Apply(v230, []any{lang.NewSymbol("v__0__auto__")}) +v232 := lang.Apply(v223, []any{v227, v231}) +v233 := lang.Apply(v220, []any{v232}) +v234 := lang.Apply(v217, []any{v233}) +v235 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v236 := v235.FindInternedVar(lang.NewSymbol("list")) +if v236.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v236))) } -v53 := v52.Get() -v54 := lang.Apply(v53, []any{lang.NewSymbol("glojure.core/assoc")}) -v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v56 := v55.FindInternedVar(lang.NewSymbol("list")) -if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) +v237 := v236.Get() +v238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v239 := v238.FindInternedVar(lang.NewSymbol("seq")) +if v239.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v239))) } -v57 := v56.Get() -v58 := lang.Apply(v57, []any{v7}) -v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v60 := v59.FindInternedVar(lang.NewSymbol("list")) -if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) +v240 := v239.Get() +v241 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v242 := v241.FindInternedVar(lang.NewSymbol("concat")) +if v242.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v242))) } -v61 := v60.Get() -v62 := lang.Apply(v61, []any{lang.NewKeyword("doc")}) -v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v64 := v63.FindInternedVar(lang.NewSymbol("list")) -if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) +v243 := v242.Get() +v244 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v245 := v244.FindInternedVar(lang.NewSymbol("list")) +if v245.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v245))) } -v65 := v64.Get() -v66 := lang.Apply(v65, []any{v6}) -v67 := lang.Apply(v50, []any{v54, v58, v62, v66}) -v68 := lang.Apply(v47, []any{v67}) -v69 := lang.Apply(v44, []any{v68}) -v70 := lang.Apply(v13, []any{v17, v37, v41, v69}) -v71 := lang.Apply(v10, []any{v70}) -return v71 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v246 := v245.Get() +v247 := lang.Apply(v246, []any{lang.NewSymbol("glojure.core/instance?")}) +v248 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v249 := v248.FindInternedVar(lang.NewSymbol("list")) +if v249.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v249))) } +v250 := v249.Get() +v251 := lang.Apply(v250, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.*MultiFn")}) +v252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v253 := v252.FindInternedVar(lang.NewSymbol("list")) +if v253.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v253))) } -// eval -{ -v0 := lang.NewSymbol("eval").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("form"))), lang.NewKeyword("doc"), "Evaluates the form data structure (not text!) and returns the result.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3203), lang.NewKeyword("end-line"), int(3203))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, _ := lang.FieldOrMethod(runtime3.Compiler, "Eval") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Eval is not a function"))) +v254 := v253.Get() +v255 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v256 := v255.FindInternedVar(lang.NewSymbol("seq")) +if v256.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v256))) } -v5 := lang.Apply(v4, []any{v3}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v257 := v256.Get() +v258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v259 := v258.FindInternedVar(lang.NewSymbol("concat")) +if v259.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v259))) } +v260 := v259.Get() +v261 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v262 := v261.FindInternedVar(lang.NewSymbol("list")) +if v262.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v262))) } -// unchecked-byte -{ -var v1 lang.FnFunc -{ // function unchecked-byte__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v263 := v262.Get() +v264 := lang.Apply(v263, []any{lang.NewSymbol("glojure.core/deref")}) +v265 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v266 := v265.FindInternedVar(lang.NewSymbol("list")) +if v266.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v266))) } -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v267 := v266.Get() +v268 := lang.Apply(v267, []any{lang.NewSymbol("v__0__auto__")}) +v269 := lang.Apply(v260, []any{v264, v268}) +v270 := lang.Apply(v257, []any{v269}) +v271 := lang.Apply(v254, []any{v270}) +v272 := lang.Apply(v243, []any{v247, v251, v271}) +v273 := lang.Apply(v240, []any{v272}) +v274 := lang.Apply(v237, []any{v273}) +v275 := lang.Apply(v210, []any{v214, v234, v274}) +v276 := lang.Apply(v207, []any{v275}) +v277 := lang.Apply(v204, []any{v276}) +v278 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v279 := v278.FindInternedVar(lang.NewSymbol("list")) +if v279.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v279))) } -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v280 := v279.Get() +v281 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v282 := v281.FindInternedVar(lang.NewSymbol("seq")) +if v282.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v282))) } -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v283 := v282.Get() +v284 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v285 := v284.FindInternedVar(lang.NewSymbol("concat")) +if v285.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v285))) } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v286 := v285.Get() +v287 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v288 := v287.FindInternedVar(lang.NewSymbol("list")) +if v288.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v288))) } -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +v289 := v288.Get() +v290 := lang.Apply(v289, []any{lang.NewSymbol("def")}) +v291 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v292 := v291.FindInternedVar(lang.NewSymbol("list")) +if v292.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v292))) } -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +v293 := v292.Get() +v294 := lang.Apply(v293, []any{v96}) +v295 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v296 := v295.FindInternedVar(lang.NewSymbol("list")) +if v296.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v296))) } -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v297 := v296.Get() +v298 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v299 := v298.FindInternedVar(lang.NewSymbol("seq")) +if v299.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v299))) } -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/UncheckedByteCast")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v300 := v299.Get() +v301 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v302 := v301.FindInternedVar(lang.NewSymbol("concat")) +if v302.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v302))) } -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v3}) -v35 := lang.Apply(v26, []any{v30, v34}) -v36 := lang.Apply(v23, []any{v35}) -v37 := lang.Apply(v20, []any{v36}) -v38 := lang.Apply(v9, []any{v13, v17, v37}) -v39 := lang.Apply(v6, []any{v38}) -return v39 -}) -v2 := v1 -_ = v2 +v303 := v302.Get() +v304 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v305 := v304.FindInternedVar(lang.NewSymbol("list")) +if v305.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v305))) } -v0 := lang.NewSymbol("unchecked-byte").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to byte. Subject to rounding or truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3517), lang.NewKeyword("end-line"), int(3517))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := lang.Apply(lang1.UncheckedByteCast, []any{v4}) -return v5 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +v306 := v305.Get() +v307 := lang.Apply(v306, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewMultiFn")}) +v308 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v309 := v308.FindInternedVar(lang.NewSymbol("list")) +if v309.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v309))) } +v310 := v309.Get() +v311 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v312 := v311.FindInternedVar(lang.NewSymbol("name")) +if v312.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v312))) } -// swap-vals! -{ -v0 := lang.NewSymbol("swap-vals!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atom"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Atomically swaps the value of atom to be:\n (apply f current-value-of-atom args). Note that f may be called\n multiple times, and thus should be free of side effects.\n Returns [old new], the value of the atom before and after the swap.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2352), lang.NewKeyword("end-line"), int(2352))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -v6, _ := lang.FieldOrMethod(v3, "swapVals") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("swapVals is not a function"))) +v313 := v312.Get() +v314 := lang.Apply(v313, []any{v96}) +v315 := lang.Apply(v310, []any{v314}) +v316 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v317 := v316.FindInternedVar(lang.NewSymbol("list")) +if v317.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v317))) } -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 +v318 := v317.Get() +v319 := lang.Apply(v318, []any{v66}) +v320 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v321 := v320.FindInternedVar(lang.NewSymbol("list")) +if v321.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v321))) +} +v322 := v321.Get() +v323 := lang.Apply(v322, []any{v120}) +v324 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v325 := v324.FindInternedVar(lang.NewSymbol("list")) +if v325.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v325))) +} +v326 := v325.Get() +v327 := lang.Apply(v326, []any{v125}) +v328 := lang.Apply(v303, []any{v307, v315, v319, v323, v327}) +v329 := lang.Apply(v300, []any{v328}) +v330 := lang.Apply(v297, []any{v329}) +v331 := lang.Apply(v286, []any{v290, v294, v330}) +v332 := lang.Apply(v283, []any{v331}) +v333 := lang.Apply(v280, []any{v332}) +v334 := lang.Apply(v197, []any{v201, v277, v333}) +v335 := lang.Apply(v194, []any{v334}) +v336 := lang.Apply(v191, []any{v335}) +v337 := lang.Apply(v141, []any{v145, v188, v336}) +v338 := lang.Apply(v138, []any{v337}) +return v338 } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -23844,616 +22737,510 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// comment +// defn { -v0 := lang.NewSymbol("comment").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Ignores body, yields nil", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4733), lang.NewKeyword("end-line"), int(4733))).(*lang.Symbol) +v0 := lang.NewSymbol("defn").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("doc-string?"), lang.NewSymbol("attr-map?"), lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("prepost-map?"), lang.NewSymbol("body")), lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("doc-string?"), lang.NewSymbol("attr-map?"), lang.NewList(lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("prepost-map?"), lang.NewSymbol("body")), lang.NewSymbol("+"), lang.NewSymbol("attr-map?"))), lang.NewKeyword("doc"), "Same as (def name (fn [params* ] exprs*)) or (def\n name (fn ([params* ] exprs*)+)) with any doc-string or attrs added\n to the var metadata. prepost-map defines a map with optional keys\n :pre and :post that contain collections of pre or post conditions.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(284), lang.NewKeyword("end-line"), int(291))).(*lang.Symbol) var v2 lang.FnFunc +{ // function defn v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 2 { + if len(args) < 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -return nil - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} +v4 := args[0] +v5 := args[1] +v6 := args[2] +v7 := lang.NewList(args[3:]...) +var v8 any +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("instance?")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -// next -{ -v1 := reflect.TypeOf((*lang1.ISeq)(nil)).Elem() -v0 := lang.NewSymbol("next").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a seq of the items after the first. Calls seq on its\n argument. If there are no more items, returns nil.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(55), lang.NewKeyword("end-line"), int(61))).(*lang.Symbol) -var v3 lang.FnFunc -{ // function next -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := args[0] -v6 := lang.Apply(lang1.Next, []any{v5}) -return v6 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(61), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(61), lang.NewKeyword("end-column"), int(77))).(lang.FnFunc) -v4 := v3 -_ = v4 -} -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// quot -{ -var v1 lang.FnFunc -{ // function quot__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("concat")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("list")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v11 := v10.Get() +v12 := lang.Apply(v11, []any{lang1.*Symbol, v6}) +if lang.IsTruthy(v12) { +v8 = nil +} else { +v13 := lang.Apply(lang1.NewIllegalArgumentError, []any{"First argument to defn must be a symbol"}) +panic(v13) } -v13 := v12.Get() -v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +_ = v8 +var v15 any +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("string?")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := v17.Get() v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) +v20 := v19.FindInternedVar(lang.NewSymbol("first")) if v20.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("seq")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v22 := lang.Apply(v21, []any{v7}) +v23 := lang.Apply(v18, []any{v22}) +if lang.IsTruthy(v23) { +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("first")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("concat")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v7}) +v28 := lang.NewMap(lang.NewKeyword("doc"), v27) +v29 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(297), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(297), lang.NewKeyword("end-column"), int(38)) +v30, err := lang.WithMeta(v28, v29.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("list")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +v15 = v30 +} else { +v31 := lang.NewMap() +v32 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(298), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(298), lang.NewKeyword("end-column"), int(20)) +v33, err := lang.WithMeta(v31, v32.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v30 := v29.Get() -v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/quotient")}) -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +v15 = v33 } -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) +var v14 any = v15 +_ = v14 +var v35 any v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) +v37 := v36.FindInternedVar(lang.NewSymbol("string?")) if v37.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) } v38 := v37.Get() -v39 := lang.Apply(v38, []any{v4}) -v40 := lang.Apply(v27, []any{v31, v35, v39}) -v41 := lang.Apply(v24, []any{v40}) -v42 := lang.Apply(v21, []any{v41}) -v43 := lang.Apply(v10, []any{v14, v18, v42}) -v44 := lang.Apply(v7, []any{v43}) -return v44 -}) -v2 := v1 -_ = v2 +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("first")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) } -v0 := lang.NewSymbol("quot").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"), lang.NewSymbol("div"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "quot[ient] of dividing numerator by denominator.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1266), lang.NewKeyword("end-line"), int(1266))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6, _ := lang.FieldOrMethod(lang1.Numbers, "quotient") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("quotient is not a function"))) +v41 := v40.Get() +v42 := lang.Apply(v41, []any{v34}) +v43 := lang.Apply(v38, []any{v42}) +if lang.IsTruthy(v43) { +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("next")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v34}) +v35 = v47 +} else { +v35 = v34 } +var v34 any = v35 +_ = v34 +var v49 any +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("map?")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) } -// with-redefs-fn -{ -v0 := lang.NewSymbol("with-redefs-fn").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("binding-map"), lang.NewSymbol("func"))), lang.NewKeyword("doc"), "Temporarily redefines Vars during a call to func. Each val of\n binding-map will replace the root value of its key which must be\n a Var. After func is called with no args, the root values of all\n the Vars will be set back to their old values. These temporary\n changes will be visible in all threads. Useful for mocking out\n functions during testing.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7567), lang.NewKeyword("end-line"), int(7567))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -var v6 lang.FnFunc -v6 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v7 := args[0] -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("seq")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +v52 := v51.Get() +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("first")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) } -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v7}) -var v8 any = v12 -_ = v8 -var v13 any = nil -_ = v13 -var v14 any = int64(0) -_ = v14 -var v15 any = int64(0) -_ = v15 -var v16 any -for { -var v17 any -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("<")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v55 := v54.Get() +v56 := lang.Apply(v55, []any{v34}) +v57 := lang.Apply(v52, []any{v56}) +if lang.IsTruthy(v57) { +v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v59 := v58.FindInternedVar(lang.NewSymbol("conj")) +if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) } -v20 := v19.Get() -v21 := lang.Apply(v20, []any{v15, v14}) -if lang.IsTruthy(v21) { -v23, _ := lang.FieldOrMethod(v13, "nth") -if reflect.TypeOf(v23).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) +v60 := v59.Get() +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("first")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) } -v24 := lang.Apply(v23, []any{v15}) -var v22 any = v24 -_ = v22 -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("nth")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +v63 := v62.Get() +v64 := lang.Apply(v63, []any{v34}) +v65 := lang.Apply(v60, []any{v48, v64}) +v49 = v65 +} else { +v49 = v48 } -v28 := v27.Get() -v29 := lang.Apply(v28, []any{v22, int64(0), nil}) -var v25 any = v29 -_ = v25 -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("nth")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +var v48 any = v49 +_ = v48 +var v67 any +v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v69 := v68.FindInternedVar(lang.NewSymbol("map?")) +if v69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) } -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v22, int64(1), nil}) -var v30 any = v34 -_ = v30 -v36, _ := lang.FieldOrMethod(v25, "bindRoot") -if reflect.TypeOf(v36).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("bindRoot is not a function"))) +v70 := v69.Get() +v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v72 := v71.FindInternedVar(lang.NewSymbol("first")) +if v72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) } -v37 := lang.Apply(v36, []any{v30}) -_ = v37 -var v38 any = v8 -var v39 any = v13 -var v40 any = v14 -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("unchecked-inc")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +v73 := v72.Get() +v74 := lang.Apply(v73, []any{v66}) +v75 := lang.Apply(v70, []any{v74}) +if lang.IsTruthy(v75) { +v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v77 := v76.FindInternedVar(lang.NewSymbol("next")) +if v77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) } -v44 := v43.Get() -v45 := lang.Apply(v44, []any{v15}) -var v41 any = v45 -v8 = v38 -v13 = v39 -v14 = v40 -v15 = v41 -continue +v78 := v77.Get() +v79 := lang.Apply(v78, []any{v66}) +v67 = v79 } else { -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("seq")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +v67 = v66 } -v25 := v24.Get() -v26 := lang.Apply(v25, []any{v8}) -var v22 any = v26 -_ = v22 -var v28 any -if lang.IsTruthy(v22) { -var v29 any = v22 -_ = v29 -var v31 any -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("chunked-seq?")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +var v66 any = v67 +_ = v66 +var v81 any +v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v83 := v82.FindInternedVar(lang.NewSymbol("vector?")) +if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) } -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v29}) -if lang.IsTruthy(v35) { -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("chunk-first")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +v84 := v83.Get() +v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v86 := v85.FindInternedVar(lang.NewSymbol("first")) +if v86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) } -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v29}) -var v36 any = v40 -_ = v36 -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("chunk-rest")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +v87 := v86.Get() +v88 := lang.Apply(v87, []any{v80}) +v89 := lang.Apply(v84, []any{v88}) +if lang.IsTruthy(v89) { +v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v91 := v90.FindInternedVar(lang.NewSymbol("list")) +if v91.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) } -v45 := v44.Get() -v46 := lang.Apply(v45, []any{v29}) -var v42 any = v46 -var v47 any = v36 -v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v50 := v49.FindInternedVar(lang.NewSymbol("int")) -if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) +v92 := v91.Get() +v93 := lang.Apply(v92, []any{v80}) +v81 = v93 +} else { +v81 = v80 } -v51 := v50.Get() -v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("count")) -if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) +var v80 any = v81 +_ = v80 +var v95 any +v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v97 := v96.FindInternedVar(lang.NewSymbol("map?")) +if v97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) } -v54 := v53.Get() -v55 := lang.Apply(v54, []any{v36}) -v56 := lang.Apply(v51, []any{v55}) -var v48 any = v56 -v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v59 := v58.FindInternedVar(lang.NewSymbol("int")) -if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) +v98 := v97.Get() +v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v100 := v99.FindInternedVar(lang.NewSymbol("last")) +if v100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) } -v60 := v59.Get() -v61 := lang.Apply(v60, []any{int64(0)}) -var v57 any = v61 -v8 = v42 -v13 = v47 -v14 = v48 -v15 = v57 -continue -} else { -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("first")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +v101 := v100.Get() +v102 := lang.Apply(v101, []any{v80}) +v103 := lang.Apply(v98, []any{v102}) +if lang.IsTruthy(v103) { +v104 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v105 := v104.FindInternedVar(lang.NewSymbol("conj")) +if v105.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v105))) } -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v29}) -var v36 any = v40 -_ = v36 -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("nth")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +v106 := v105.Get() +v107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v108 := v107.FindInternedVar(lang.NewSymbol("last")) +if v108.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v108))) } -v44 := v43.Get() -v45 := lang.Apply(v44, []any{v36, int64(0), nil}) -var v41 any = v45 -_ = v41 -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("nth")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +v109 := v108.Get() +v110 := lang.Apply(v109, []any{v80}) +v111 := lang.Apply(v106, []any{v94, v110}) +v95 = v111 +} else { +v95 = v94 } -v49 := v48.Get() -v50 := lang.Apply(v49, []any{v36, int64(1), nil}) -var v46 any = v50 -_ = v46 -v52, _ := lang.FieldOrMethod(v41, "bindRoot") -if reflect.TypeOf(v52).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("bindRoot is not a function"))) +var v94 any = v95 +_ = v94 +var v113 any +v114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v115 := v114.FindInternedVar(lang.NewSymbol("map?")) +if v115.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v115))) } -v53 := lang.Apply(v52, []any{v46}) -_ = v53 -v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v56 := v55.FindInternedVar(lang.NewSymbol("next")) -if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) +v116 := v115.Get() +v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v118 := v117.FindInternedVar(lang.NewSymbol("last")) +if v118.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) } -v57 := v56.Get() -v58 := lang.Apply(v57, []any{v29}) -var v54 any = v58 -var v59 any = nil -var v60 any = int64(0) -var v61 any = int64(0) -v8 = v54 -v13 = v59 -v14 = v60 -v15 = v61 -continue +v119 := v118.Get() +v120 := lang.Apply(v119, []any{v112}) +v121 := lang.Apply(v116, []any{v120}) +if lang.IsTruthy(v121) { +v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v123 := v122.FindInternedVar(lang.NewSymbol("butlast")) +if v123.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) } -v28 = v31 +v124 := v123.Get() +v125 := lang.Apply(v124, []any{v112}) +v113 = v125 } else { -v28 = nil -} -v17 = v28 +v113 = v112 } -v16 = v17 - break +var v112 any = v113 +_ = v112 +v127 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v128 := v127.FindInternedVar(lang.NewSymbol("conj")) +if v128.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v128))) } -return v16 -}) -v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7576), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(7578), lang.NewKeyword("end-column"), int(93)) -v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) -if err != nil { - panic(err) +v129 := v128.Get() +v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v131 := v130.FindInternedVar(lang.NewSymbol("list")) +if v131.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) } -var v5 any = v8 -_ = v5 -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("zipmap")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v132 := v131.Get() +v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v134 := v133.FindInternedVar(lang.NewSymbol("sigs")) +if v134.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) } -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("keys")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +v135 := v134.Get() +v136 := lang.Apply(v135, []any{v112}) +v137 := lang.Apply(v132, []any{lang.NewSymbol("quote"), v136}) +v138 := lang.NewMap(lang.NewKeyword("arglists"), v137) +v139 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(317), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(317), lang.NewKeyword("end-column"), int(60)) +v140, err := lang.WithMeta(v138, v139.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v3}) -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("map")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +v141 := lang.Apply(v129, []any{v140, v126}) +var v126 any = v141 +_ = v126 +v144 := lang.Apply(lang.NewKeyword("inline"), []any{v142}) +var v143 any = v144 +_ = v143 +v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v147 := v146.FindInternedVar(lang.NewSymbol("first")) +if v147.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) } -v19 := v18.Get() -var v20 lang.FnFunc -v20 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v21 := args[0] -v22, ok := lang.FieldOrMethod(v21, "getRawRoot") +v148 := v147.Get() +v149 := lang.Apply(v148, []any{v143}) +var v145 any = v149 +_ = v145 +v151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v152 := v151.FindInternedVar(lang.NewSymbol("second")) +if v152.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v152))) +} +v153 := v152.Get() +v154 := lang.Apply(v153, []any{v143}) +var v150 any = v154 +_ = v150 +var v156 any +var v157 any +v158 := lang.Apply(lang1.Equiv, []any{lang.NewSymbol("fn"), v145}) +if lang.IsTruthy(v158) { +var v159 any +v160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v161 := v160.FindInternedVar(lang.NewSymbol("instance?")) +if v161.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v161))) +} +v162 := v161.Get() +v163 := lang.Apply(v162, []any{lang1.*Symbol, v150}) +if lang.IsTruthy(v163) { +v159 = false +} else { +v159 = true +} +v157 = v159 +} else { +v157 = nil +} +if lang.IsTruthy(v157) { +v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v165 := v164.FindInternedVar(lang.NewSymbol("assoc")) +if v165.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) +} +v166 := v165.Get() +v167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v168 := v167.FindInternedVar(lang.NewSymbol("cons")) +if v168.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v168))) +} +v169 := v168.Get() +v170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v171 := v170.FindInternedVar(lang.NewSymbol("cons")) +if v171.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v171))) +} +v172 := v171.Get() +v173, ok := lang.FieldOrMethod(v6, "Name") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v21, "getRawRoot"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "Name"))) } -var v23 any -switch reflect.TypeOf(v22).Kind() { +var v174 any +switch reflect.TypeOf(v173).Kind() { case reflect.Func: - v23 = lang.Apply(v22, nil) + v174 = lang.Apply(v173, nil) default: - v23 = v22 -} -return v23 -}) -v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7580), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(7580), lang.NewKeyword("end-column"), int(92)) -v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("keys")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + v174 = v173 } -v25 := v24.Get() -v26 := lang.Apply(v25, []any{v3}) -v27 := lang.Apply(v19, []any{v22, v26}) -v28 := lang.Apply(v12, []any{v16, v27}) -var v9 any = v28 -_ = v9 -var v30 any -func() { -defer func() { -v31 := lang.Apply(v5, []any{v9}) -}() -v32 := lang.Apply(v5, []any{v3}) -_ = v32 -v33 := lang.Apply(v4, nil) -v30 = v33 -}() -return v30 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v175 := lang.Apply(lang1.ConcatStrings, []any{v174, "__inliner"}) +v176 := lang.Apply(lang1.NewSymbol, []any{v175}) +v177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v178 := v177.FindInternedVar(lang.NewSymbol("next")) +if v178.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v178))) } +v179 := v178.Get() +v180 := lang.Apply(v179, []any{v143}) +v181 := lang.Apply(v172, []any{v176, v180}) +v182 := lang.Apply(v169, []any{v145, v181}) +v183 := lang.Apply(v166, []any{v142, lang.NewKeyword("inline"), v182}) +v156 = v183 +} else { +v156 = v142 } -// inc' -{ -var v1 lang.FnFunc -{ // function inc'__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +var v142 any = v156 +_ = v142 +v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v145 := v144.FindInternedVar(lang.NewSymbol("conj")) +if v145.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) } -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v146 := v145.Get() +var v147 any +v148 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v149 := v148.FindInternedVar(lang.NewSymbol("meta")) +if v149.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v149))) } -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v150 := v149.Get() +v151 := lang.Apply(v150, []any{v6}) +if lang.IsTruthy(v151) { +v152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v153 := v152.FindInternedVar(lang.NewSymbol("meta")) +if v153.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v153))) } -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v154 := v153.Get() +v155 := lang.Apply(v154, []any{v6}) +v147 = v155 +} else { +v156 := lang.NewMap() +v157 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(328), lang.NewKeyword("column"), int(51), lang.NewKeyword("end-line"), int(328), lang.NewKeyword("end-column"), int(52)) +v158, err := lang.WithMeta(v156, v157.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v147 = v158 } -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +v159 := lang.Apply(v146, []any{v147, v143}) +var v143 any = v159 +_ = v143 +v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v162 := v161.FindInternedVar(lang.NewSymbol("list")) +if v162.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) } -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +v163 := v162.Get() +v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v165 := v164.FindInternedVar(lang.NewSymbol("with-meta")) +if v165.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) } -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v166 := v165.Get() +v167 := lang.Apply(v166, []any{v6, v143}) +v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v169 := v168.FindInternedVar(lang.NewSymbol("with-meta")) +if v169.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) } -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/incP")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v170 := v169.Get() +v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v172 := v171.FindInternedVar(lang.NewSymbol("cons")) +if v172.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) } -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v3}) -v35 := lang.Apply(v26, []any{v30, v34}) -v36 := lang.Apply(v23, []any{v35}) -v37 := lang.Apply(v20, []any{v36}) -v38 := lang.Apply(v9, []any{v13, v17, v37}) -v39 := lang.Apply(v6, []any{v38}) -return v39 -}) -v2 := v1 -_ = v2 +v173 := v172.Get() +v174 := lang.Apply(v173, []any{lang.NewSymbol("glojure.core/fn"), v112}) +v175 := lang.Apply(lang.NewKeyword("tag"), []any{v143}) +v176 := lang.NewMap(lang.NewKeyword("rettag"), v175) +v177 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(333), lang.NewKeyword("column"), int(37), lang.NewKeyword("end-line"), int(333), lang.NewKeyword("end-column"), int(54)) +v178, err := lang.WithMeta(v176, v177.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v0 := lang.NewSymbol("inc'").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns a number one greater than num. Supports arbitrary precision.\n See also: inc", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(908), lang.NewKeyword("end-line"), int(908))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) +v179 := lang.Apply(v170, []any{v174, v178}) +v180 := lang.Apply(v163, []any{lang.NewSymbol("def"), v167, v179}) +return v180 } -v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "incP") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("incP is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 }) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(291), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(333), lang.NewKeyword("end-column"), int(58))).(lang.FnFunc) +v3 := v2 +_ = v3 +} +v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// gensym +// defn- { -v0 := lang.NewSymbol("gensym").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("prefix-string"))), lang.NewKeyword("doc"), "Returns a new symbol with a unique name. If a prefix string is\n supplied, the name is prefix# where # is some unique number. If\n prefix is not supplied, the prefix is 'G__'.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(599), lang.NewKeyword("end-line"), int(599))).(*lang.Symbol) +v0 := lang.NewSymbol("defn-").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("decls"))), lang.NewKeyword("doc"), "same as defn, yielding non-public def", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4949), lang.NewKeyword("end-line"), int(4949))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 0: -v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v4 := v3.FindInternedVar(lang.NewSymbol("gensym")) -if v4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) -} -v5 := v4.Get() -v6 := lang.Apply(v5, []any{"G__"}) -return v6 - case 1: + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("str")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("str")) +v8 := v7.FindInternedVar(lang.NewSymbol("list*")) if v8.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } v9 := v8.Get() -v10, _ := lang.FieldOrMethod(runtime3.RT, "NextID") -if reflect.TypeOf(v10).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("NextID is not a function"))) +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("with-meta")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v11 := lang.Apply(v10, []any{}) -v12 := lang.Apply(v9, []any{v11}) -v13 := lang.Apply(v6, []any{v3, v12}) -v14 := lang.Apply(lang1.NewSymbol, []any{v13}) -return v14 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("assoc")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } +v15 := v14.Get() +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("meta")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -// rseq -{ -v0 := lang.NewSymbol("rseq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rev"))), lang.NewKeyword("doc"), "Returns, in constant time, a seq of the items in rev (which\n can be a vector or sorted-map), in reverse order. If rev is empty returns nil", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1577), lang.NewKeyword("end-line"), int(1577))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v5}) +v20 := lang.Apply(v15, []any{v19, lang.NewKeyword("private"), true}) +v21 := lang.Apply(v12, []any{v5, v20}) +v22 := lang.Apply(v9, []any{lang.NewSymbol("glojure.core/defn"), v21, v6}) +return v22 } -v3 := args[0] -v4, _ := lang.FieldOrMethod(v3, "rseq") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("rseq is not a function"))) -} -v5 := lang.Apply(v4, []any{}) -return v5 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -24461,184 +23248,231 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// emit-extend-type +// defonce { -v0 := lang.NewSymbol("emit-extend-type").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(175), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(175), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"), lang.NewSymbol("specs"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v0 := lang.NewSymbol("defonce").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("expr"))), lang.NewKeyword("doc"), "defs name to have the root value of the expr iff the named var has no root value,\n else expr is unevaluated", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5849), lang.NewKeyword("end-line"), int(5849))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { + if len(args) != 4 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] v4 := args[1] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("parse-impls")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +v5 := args[2] +v6 := args[3] +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("seq")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v4}) -var v5 any = v9 -_ = v5 -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("seq")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("concat")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("concat")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("list")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } -v16 := v15.Get() +v15 := v14.Get() +v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/let")}) v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v18 := v17.FindInternedVar(lang.NewSymbol("list")) if v18.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } v19 := v18.Get() -v20 := lang.Apply(v19, []any{lang.NewSymbol("glojure.core/extend")}) -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("list")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("apply")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v3}) -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("mapcat")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("vector")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("partial")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("seq")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) } -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("emit-hinted-impl")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("concat")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) } -v33 := v32.Get() -v34 := lang.Apply(v30, []any{v33, v3}) -v35 := lang.Apply(v27, []any{v34, v5}) -v36 := lang.Apply(v16, []any{v20, v24, v35}) -v37 := lang.Apply(v13, []any{v36}) -return v37 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v31 := v30.Get() +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) } +v34 := v33.Get() +v35 := lang.Apply(v34, []any{lang.NewSymbol("v__0__auto__")}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) } -// class? -{ -v0 := lang.NewSymbol("class?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is an instance of Class", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5465), lang.NewKeyword("end-line"), int(5465))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v38 := v37.Get() +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("seq")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) } -v6 := v5.Get() -v7 := lang.Apply(v6, []any{reflect.Type, v3}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v41 := v40.Get() +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("concat")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) } +v44 := v43.Get() +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("list")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) } -// chars -{ -var v1 lang.FnFunc -{ // function chars -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v47 := v46.Get() +v48 := lang.Apply(v47, []any{lang.NewSymbol("def")}) +v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v50 := v49.FindInternedVar(lang.NewSymbol("list")) +if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) } -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v51 := v50.Get() +v52 := lang.Apply(v51, []any{v5}) +v53 := lang.Apply(v44, []any{v48, v52}) +v54 := lang.Apply(v41, []any{v53}) +v55 := lang.Apply(v38, []any{v54}) +v56 := lang.Apply(v31, []any{v35, v55}) +v57 := lang.Apply(v28, []any{v56}) +v58 := lang.Apply(v22, []any{v25, v57}) +v59 := lang.Apply(v19, []any{v58}) +v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v61 := v60.FindInternedVar(lang.NewSymbol("list")) +if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) } -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v62 := v61.Get() +v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v64 := v63.FindInternedVar(lang.NewSymbol("seq")) +if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) } -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v65 := v64.Get() +v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v67 := v66.FindInternedVar(lang.NewSymbol("concat")) +if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v68 := v67.Get() +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("list")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) } -v20 := v19.Get() -v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/chars")}) -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("list")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v71 := v70.Get() +v72 := lang.Apply(v71, []any{lang.NewSymbol("glojure.core/when-not")}) +v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v74 := v73.FindInternedVar(lang.NewSymbol("list")) +if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) } -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v26 := lang.Apply(v9, []any{v13, v17, v21, v25}) -v27 := lang.Apply(v6, []any{v26}) -return v27 -}) -v2 := v1 -_ = v2 +v75 := v74.Get() +v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v77 := v76.FindInternedVar(lang.NewSymbol("seq")) +if v77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) } -v0 := lang.NewSymbol("chars").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Casts to chars[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5382), lang.NewKeyword("end-line"), int(5382))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "chars") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("chars is not a function"))) +v78 := v77.Get() +v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v80 := v79.FindInternedVar(lang.NewSymbol("concat")) +if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) } -v6 := lang.Apply(v5, []any{v4}) -return v6 +v81 := v80.Get() +v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v83 := v82.FindInternedVar(lang.NewSymbol("list")) +if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) +} +v84 := v83.Get() +v85 := lang.Apply(v84, []any{lang.NewSymbol(".HasRoot")}) +v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v87 := v86.FindInternedVar(lang.NewSymbol("list")) +if v87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) +} +v88 := v87.Get() +v89 := lang.Apply(v88, []any{lang.NewSymbol("v__0__auto__")}) +v90 := lang.Apply(v81, []any{v85, v89}) +v91 := lang.Apply(v78, []any{v90}) +v92 := lang.Apply(v75, []any{v91}) +v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v94 := v93.FindInternedVar(lang.NewSymbol("list")) +if v94.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) +} +v95 := v94.Get() +v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v97 := v96.FindInternedVar(lang.NewSymbol("seq")) +if v97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) +} +v98 := v97.Get() +v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v100 := v99.FindInternedVar(lang.NewSymbol("concat")) +if v100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) +} +v101 := v100.Get() +v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v103 := v102.FindInternedVar(lang.NewSymbol("list")) +if v103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) +} +v104 := v103.Get() +v105 := lang.Apply(v104, []any{lang.NewSymbol("def")}) +v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v107 := v106.FindInternedVar(lang.NewSymbol("list")) +if v107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) +} +v108 := v107.Get() +v109 := lang.Apply(v108, []any{v5}) +v110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v111 := v110.FindInternedVar(lang.NewSymbol("list")) +if v111.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v111))) +} +v112 := v111.Get() +v113 := lang.Apply(v112, []any{v6}) +v114 := lang.Apply(v101, []any{v105, v109, v113}) +v115 := lang.Apply(v98, []any{v114}) +v116 := lang.Apply(v95, []any{v115}) +v117 := lang.Apply(v68, []any{v72, v92, v116}) +v118 := lang.Apply(v65, []any{v117}) +v119 := lang.Apply(v62, []any{v118}) +v120 := lang.Apply(v12, []any{v16, v59, v119}) +v121 := lang.Apply(v9, []any{v120}) +return v121 }) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// with-bindings +// defprotocol { -v0 := lang.NewSymbol("with-bindings").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("binding-map"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Takes a map of Var/value pairs. Installs for the given Vars the associated\n values as thread-local bindings. Then executes body. Pops the installed\n bindings after body was evaluated. Returns the value of body.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1984), lang.NewKeyword("end-line"), int(1984))).(*lang.Symbol) +v0 := lang.NewSymbol("defprotocol").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("opts+sigs"))), lang.NewKeyword("doc"), "A protocol is a named set of named methods and their signatures:\n (defprotocol AProtocolName\n\n ;optional doc string\n \"A doc string for AProtocol abstraction\"\n\n ;options\n :extend-via-metadata true\n\n ;method signatures\n (bar [this a b] \"bar docs\")\n (baz [this a] [this a b] [this a b c] \"baz docs\"))\n\n No implementations are provided. Docs can be specified for the\n protocol overall and for each method. The above yields a set of\n polymorphic functions and a protocol object. All are\n namespace-qualified by the ns enclosing the definition The resulting\n functions dispatch on the type of their first argument, which is\n required and corresponds to the implicit target object ('this' in \n Java parlance). defprotocol is dynamic, has no special compile-time \n effect, and defines no new types or classes. Implementations of \n the protocol methods can be provided using extend.\n\n When :extend-via-metadata is true, values can extend protocols by\n adding metadata where keys are fully-qualified protocol function\n symbols and values are function implementations. Protocol\n implementations are checked first for direct definitions (defrecord,\n deftype, reify), then metadata definitions, then external\n extensions (extend, extend-type, extend-protocol)\n\n defprotocol will automatically generate a corresponding interface,\n with the same name as the protocol, i.e. given a protocol:\n my.ns/Protocol, an interface: my.ns.Protocol. The interface will\n have methods corresponding to the protocol functions, and the\n protocol will automatically work with instances of the interface.\n\n Note that you should not use this interface with deftype or\n reify, as they support the protocol directly:\n\n (defprotocol P \n (foo [this]) \n (bar-me [this] [this y]))\n\n (deftype Foo [a b c] \n P\n (foo [this] a)\n (bar-me [this] b)\n (bar-me [this y] (+ c y)))\n \n (bar-me (Foo. 1 2 3) 42)\n => 45\n\n (foo \n (let [x 42]\n (reify P \n (foo [this] 17)\n (bar-me [this] x)\n (bar-me [this y] x))))\n => 17", lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(28), lang.NewKeyword("end-line"), int(28))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -24650,1219 +23484,919 @@ v3 := args[0] v4 := args[1] v5 := args[2] v6 := lang.NewList(args[3:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("seq")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("concat")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +var v8 any +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("string?")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("list")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("first")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } -v15 := v14.Get() -v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/with-bindings*")}) +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v6}) +v16 := lang.Apply(v11, []any{v15}) +if lang.IsTruthy(v16) { v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("list")) +v18 := v17.FindInternedVar(lang.NewSymbol("first")) if v18.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } v19 := v18.Get() -v20 := lang.Apply(v19, []any{v5}) -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("list")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("seq")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("concat")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("list")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.Apply(v32, []any{lang.NewSymbol("glojure.core/fn")}) -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("list")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("apply")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("vector")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("seq")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +v20 := lang.Apply(v19, []any{v6}) +v8 = v20 +} else { +v8 = nil } -v45 := v44.Get() -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("concat")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +var v7 any = v8 +_ = v7 +var v22 any +if lang.IsTruthy(v7) { +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("rest")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v48 := v47.Get() -v49 := lang.Apply(v48, nil) -v50 := lang.Apply(v45, []any{v49}) -v51 := lang.Apply(v39, []any{v42, v50}) -v52 := lang.Apply(v36, []any{v51}) -v53 := lang.Apply(v29, []any{v33, v52, v6}) -v54 := lang.Apply(v26, []any{v53}) -v55 := lang.Apply(v23, []any{v54}) -v56 := lang.Apply(v12, []any{v16, v20, v55}) -v57 := lang.Apply(v9, []any{v56}) -return v57 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v25 := v24.Get() +v26 := lang.Apply(v25, []any{v21}) +v22 = v26 +} else { +v22 = v21 } +var v21 any = v22 +_ = v21 +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("take-while")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } -// stream-seq! -{ -v0 := lang.NewSymbol("stream-seq!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Takes a java.util.stream.BaseStream instance s and returns a seq of its\n contents. This is a terminal operation on the stream.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6836), lang.NewKeyword("end-line"), int(6836))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { +v30 := v29.Get() +var v31 lang.FnFunc +v31 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("iterator-seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7, ok := lang.FieldOrMethod(v3, "iterator") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "iterator"))) -} -var v8 any -switch reflect.TypeOf(v7).Kind() { -case reflect.Func: - v8 = lang.Apply(v7, nil) -default: - v8 = v7 -} -v9 := lang.Apply(v6, []any{v8}) -return v9 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v32 := args[0] +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("not")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) } +v35 := v34.Get() +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("seq?")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) } -// hash-ordered-coll -{ -v0 := lang.NewSymbol("hash-ordered-coll").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns the hash code, consistent with =, for an external ordered\n collection implementing Iterable.\n See http://glojure.org/data_structures#hash for full algorithms.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5210), lang.NewKeyword("end-line"), int(5210))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.Apply(nil, []any{v3}) -return v4 +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v32}) +v40 := lang.Apply(v35, []any{v39}) +return v40 }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} +v32 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(92), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(92), lang.NewKeyword("end-column"), int(40)) +v33, err := lang.WithMeta(v31, v32.(lang.IPersistentMap)) +if err != nil { + panic(err) } -// import -{ -v0 := lang.NewSymbol("import").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("import-symbols-or-lists"))), lang.NewKeyword("doc"), "import-list => (package-symbol class-name-symbols*)\n\n For each name in class-name-symbols, adds a mapping from name to the\n class named by package.name to the current namespace. Use :import in the ns\n macro in preference to calling this directly.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3426), lang.NewKeyword("end-line"), int(3426))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("map")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v34 := lang.Apply(v30, []any{v33, v21}) +var v27 any = v34 +_ = v27 +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("drop-while")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) } -v9 := v8.Get() -var v10 lang.FnFunc -v10 = lang.NewFnFunc(func(args ...any) any { +v38 := v37.Get() +var v39 lang.FnFunc +v39 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v11 := args[0] -var v12 any -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("seq?")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v11}) -var v13 any = v17 -_ = v13 -var v19 any -if lang.IsTruthy(v13) { -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("=")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("first")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{v11}) -v27 := lang.Apply(v22, []any{lang.NewSymbol("quote"), v26}) -v19 = v27 -} else { -v19 = v13 -} -if lang.IsTruthy(v19) { -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("second")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +v40 := args[0] +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("not")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v11}) -v12 = v16 -} else { -v12 = v11 +v43 := v42.Get() +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("seq?")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } -return v12 +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v40}) +v48 := lang.Apply(v43, []any{v47}) +return v48 }) -v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3434), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(3434), lang.NewKeyword("end-column"), int(73)) -v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) +v40 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(93), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(93), lang.NewKeyword("end-column"), int(40)) +v41, err := lang.WithMeta(v39, v40.(lang.IPersistentMap)) if err != nil { panic(err) } -v13 := lang.Apply(v9, []any{v12, v5}) -var v6 any = v13 -_ = v6 -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("seq")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +v42 := lang.Apply(v38, []any{v41, v21}) +var v35 any = v42 +_ = v35 +var v44 any +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("=")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) } -v17 := v16.Get() -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("concat")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v47 := v46.Get() +v48 := lang.Apply(v47, []any{v35, v43}) +if lang.IsTruthy(v48) { +v44 = nil +} else { +v44 = v43 } -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("list")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v23, []any{lang.NewSymbol("do")}) -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("map")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -var v28 lang.FnFunc -v28 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v29 := args[0] -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("list")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.Apply(v32, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Import"), v29}) -return v33 -}) -v29 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3436), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(3436), lang.NewKeyword("end-column"), int(73)) -v30, err := lang.WithMeta(v28, v29.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("reduce1")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -var v34 lang.FnFunc -v34 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v35 := args[0] -v36 := args[1] -var v37 any -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("symbol?")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.Apply(v40, []any{v36}) -if lang.IsTruthy(v41) { -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("conj")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) -} -v44 := v43.Get() -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("name")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +var v43 any = v44 +_ = v43 +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("seq")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) } -v47 := v46.Get() -v48 := lang.Apply(v47, []any{v36}) -v49 := lang.Apply(v44, []any{v35, v48}) -v37 = v49 -} else { -v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v52 := v51.FindInternedVar(lang.NewSymbol("first")) -if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) +v52 := v51.Get() +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("concat")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) } -v53 := v52.Get() -v54 := lang.Apply(v53, []any{v36}) -var v50 any = v54 -_ = v50 +v55 := v54.Get() v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v57 := v56.FindInternedVar(lang.NewSymbol("rest")) +v57 := v56.FindInternedVar(lang.NewSymbol("list")) if v57.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) } v58 := v57.Get() -v59 := lang.Apply(v58, []any{v36}) -var v55 any = v59 -_ = v55 -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("into1")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +v59 := lang.Apply(v58, []any{lang.NewSymbol("do")}) +v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v61 := v60.FindInternedVar(lang.NewSymbol("list")) +if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) } -v63 := v62.Get() -v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v65 := v64.FindInternedVar(lang.NewSymbol("map")) -if v65.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) +v62 := v61.Get() +v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v64 := v63.FindInternedVar(lang.NewSymbol("seq")) +if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) } -v66 := v65.Get() -var v67 lang.FnFunc -v67 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v68 := args[0] +v65 := v64.Get() +v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v67 := v66.FindInternedVar(lang.NewSymbol("concat")) +if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) +} +v68 := v67.Get() v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("str")) +v70 := v69.FindInternedVar(lang.NewSymbol("list")) if v70.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) } v71 := v70.Get() -v72 := lang.Apply(v71, []any{v50, ".", v68}) -return v72 -}) -v68 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3441), lang.NewKeyword("column"), int(45), lang.NewKeyword("end-line"), int(3441), lang.NewKeyword("end-column"), int(58)) -v69, err := lang.WithMeta(v67, v68.(lang.IPersistentMap)) -if err != nil { - panic(err) +v72 := lang.Apply(v71, []any{lang.NewSymbol("def")}) +v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v74 := v73.FindInternedVar(lang.NewSymbol("list")) +if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) } -v70 := lang.Apply(v66, []any{v69, v55}) -v71 := lang.Apply(v63, []any{v35, v70}) -v37 = v71 +v75 := v74.Get() +v76 := lang.Apply(v75, []any{v5}) +v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v78 := v77.FindInternedVar(lang.NewSymbol("list")) +if v78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) } -return v37 -}) -v35 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3437), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(3441), lang.NewKeyword("end-column"), int(66)) -v36, err := lang.WithMeta(v34, v35.(lang.IPersistentMap)) -if err != nil { - panic(err) +v79 := v78.Get() +v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v81 := v80.FindInternedVar(lang.NewSymbol("seq")) +if v81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) } -v37 := lang.NewVector() -v38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3442), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(3442), lang.NewKeyword("end-column"), int(26)) -v39, err := lang.WithMeta(v37, v38.(lang.IPersistentMap)) -if err != nil { - panic(err) +v82 := v81.Get() +v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v84 := v83.FindInternedVar(lang.NewSymbol("concat")) +if v84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) } -v40 := lang.Apply(v33, []any{v36, v39, v6}) -v41 := lang.Apply(v27, []any{v30, v40}) -v42 := lang.Apply(v20, []any{v24, v41}) -v43 := lang.Apply(v17, []any{v42}) -return v43 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v85 := v84.Get() +v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v87 := v86.FindInternedVar(lang.NewSymbol("list")) +if v87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) } +v88 := v87.Get() +v89 := lang.Apply(v88, []any{lang.NewSymbol("glojure.core/atom")}) +v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v91 := v90.FindInternedVar(lang.NewSymbol("list")) +if v91.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) } -// requiring-resolve -{ -v0 := lang.NewSymbol("requiring-resolve").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Resolves namespace-qualified sym per 'resolve'. If initial resolve\nfails, attempts to require sym's namespace and retries.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6111), lang.NewKeyword("end-line"), int(6111))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("qualified-symbol?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v92 := v91.Get() +v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v94 := v93.FindInternedVar(lang.NewSymbol("apply")) +if v94.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) } -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -if lang.IsTruthy(v8) { -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("resolve")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v95 := v94.Get() +v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v97 := v96.FindInternedVar(lang.NewSymbol("hash-map")) +if v97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) } -v12 := v11.Get() -v13 := lang.Apply(v12, []any{v3}) -var v9 any = v13 -_ = v9 -var v15 any -if lang.IsTruthy(v9) { -v15 = v9 -} else { -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("serialized-require")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +v98 := v97.Get() +v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v100 := v99.FindInternedVar(lang.NewSymbol("seq")) +if v100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) } -v18 := v17.Get() -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("symbol")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v101 := v100.Get() +v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v103 := v102.FindInternedVar(lang.NewSymbol("concat")) +if v103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) } -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("namespace")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v104 := v103.Get() +v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v106 := v105.FindInternedVar(lang.NewSymbol("list")) +if v106.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) } -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v26 := lang.Apply(v21, []any{v25}) -v27 := lang.Apply(v18, []any{v26}) -_ = v27 -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("resolve")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +v107 := v106.Get() +v108 := lang.Apply(v107, []any{lang.NewKeyword("on-interface")}) +v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v110 := v109.FindInternedVar(lang.NewSymbol("list")) +if v110.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) } -v30 := v29.Get() -v31 := lang.Apply(v30, []any{v3}) -v15 = v31 +v111 := v110.Get() +v112 := lang.Apply(v111, []any{true}) +v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v114 := v113.FindInternedVar(lang.NewSymbol("list")) +if v114.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) } -v4 = v15 -} else { -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("str")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +v115 := v114.Get() +v116 := lang.Apply(v115, []any{lang.NewKeyword("sigs")}) +v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v118 := v117.FindInternedVar(lang.NewSymbol("list")) +if v118.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) } -v11 := v10.Get() -v12 := lang.Apply(v11, []any{"Not a qualified symbol: ", v3}) -v13 := lang.Apply(lang1.NewIllegalArgumentError, []any{v12}) -panic(v13) +v119 := v118.Get() +v120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v121 := v120.FindInternedVar(lang.NewSymbol("seq")) +if v121.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v121))) } -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v122 := v121.Get() +v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v124 := v123.FindInternedVar(lang.NewSymbol("concat")) +if v124.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) } +v125 := v124.Get() +v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v127 := v126.FindInternedVar(lang.NewSymbol("list")) +if v127.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) } -// empty -{ -v0 := lang.NewSymbol("empty").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns an empty collection of the same category as coll, or nil", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5265), lang.NewKeyword("end-line"), int(5265))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v128 := v127.Get() +v129 := lang.Apply(v128, []any{lang.NewSymbol("quote")}) +v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v131 := v130.FindInternedVar(lang.NewSymbol("list")) +if v131.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) } -v7 := v6.Get() -v8 := lang.Apply(v7, []any{lang1.IPersistentCollection, v3}) -if lang.IsTruthy(v8) { -v9, ok := lang.FieldOrMethod(v3, "empty") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "empty"))) +v132 := v131.Get() +v133 := lang.Apply(v132, []any{v35}) +v134 := lang.Apply(v125, []any{v129, v133}) +v135 := lang.Apply(v122, []any{v134}) +v136 := lang.Apply(v119, []any{v135}) +v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v138 := v137.FindInternedVar(lang.NewSymbol("list")) +if v138.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) } -var v10 any -switch reflect.TypeOf(v9).Kind() { -case reflect.Func: - v10 = lang.Apply(v9, nil) -default: - v10 = v9 +v139 := v138.Get() +v140 := lang.Apply(v139, []any{lang.NewKeyword("multis")}) +v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v142 := v141.FindInternedVar(lang.NewSymbol("list")) +if v142.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) } -v4 = v10 -} else { -v4 = nil +v143 := v142.Get() +v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v145 := v144.FindInternedVar(lang.NewSymbol("apply")) +if v145.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) } -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v146 := v145.Get() +v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v148 := v147.FindInternedVar(lang.NewSymbol("hash-map")) +if v148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) } +v149 := v148.Get() +v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v151 := v150.FindInternedVar(lang.NewSymbol("seq")) +if v151.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) } -// vals -{ -v0 := lang.NewSymbol("vals").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"))), lang.NewKeyword("doc"), "Returns a sequence of the map's values, in the same order as (seq map).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1557), lang.NewKeyword("end-line"), int(1557))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.Apply(lang1.Vals, []any{v3}) -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v152 := v151.Get() +v153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v154 := v153.FindInternedVar(lang.NewSymbol("concat")) +if v154.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v154))) } +v155 := v154.Get() +v156 := lang.Apply(v155, nil) +v157 := lang.Apply(v152, []any{v156}) +v158 := lang.Apply(v146, []any{v149, v157}) +v159 := lang.Apply(v143, []any{v158}) +v160 := lang.Apply(v104, []any{v108, v112, v116, v136, v140, v159}) +v161 := lang.Apply(v101, []any{v160}) +v162 := lang.Apply(v95, []any{v98, v161}) +v163 := lang.Apply(v92, []any{v162}) +v164 := lang.Apply(v85, []any{v89, v163}) +v165 := lang.Apply(v82, []any{v164}) +v166 := lang.Apply(v79, []any{v165}) +v167 := lang.Apply(v68, []any{v72, v76, v166}) +v168 := lang.Apply(v65, []any{v167}) +v169 := lang.Apply(v62, []any{v168}) +v170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v171 := v170.FindInternedVar(lang.NewSymbol("list")) +if v171.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v171))) } -// print-initialized -{ -v0 := lang.NewSymbol("print-initialized").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(520), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(520), lang.NewKeyword("end-column"), int(39), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, true, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v172 := v171.Get() +v173 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v174 := v173.FindInternedVar(lang.NewSymbol("seq")) +if v174.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v174))) } +v175 := v174.Get() +v176 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v177 := v176.FindInternedVar(lang.NewSymbol("concat")) +if v177.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v177))) } -// fn -{ -v0 := lang.NewSymbol("fn").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("sigs"))), lang.NewKeyword("doc"), "params => positional-params*, or positional-params* & rest-param\n positional-param => binding-form\n rest-param => binding-form\n binding-form => name, or destructuring-form\n\n Defines a function.\n\n See https://glojure.org/reference/special_forms#fn for more information", lang.NewKeyword("forms"), lang.NewVector(lang.NewList(lang.NewSymbol("fn"), lang.NewSymbol("name?"), lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("exprs*")), lang.NewList(lang.NewSymbol("fn"), lang.NewSymbol("name?"), lang.NewList(lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("exprs*")), lang.NewSymbol("+"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4533), lang.NewKeyword("end-line"), int(4533), lang.NewKeyword("special-form"), true)).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -var v7 any -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("symbol?")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v178 := v177.Get() +v179 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v180 := v179.FindInternedVar(lang.NewSymbol("list")) +if v180.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v180))) } -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("first")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v181 := v180.Get() +v182 := lang.Apply(v181, []any{lang.NewSymbol("glojure.core/swap!")}) +v183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v184 := v183.FindInternedVar(lang.NewSymbol("list")) +if v184.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v184))) } -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v5}) -v15 := lang.Apply(v10, []any{v14}) -if lang.IsTruthy(v15) { -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("first")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +v185 := v184.Get() +v186 := lang.Apply(v185, []any{lang.NewSymbol("glojure.core/-protocols")}) +v187 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v188 := v187.FindInternedVar(lang.NewSymbol("list")) +if v188.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v188))) } -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v5}) -v7 = v19 -} else { -v7 = nil +v189 := v188.Get() +v190 := lang.Apply(v189, []any{lang.NewSymbol("glojure.core/assoc")}) +v191 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v192 := v191.FindInternedVar(lang.NewSymbol("list")) +if v192.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v192))) } -var v6 any = v7 -_ = v6 -var v21 any -if lang.IsTruthy(v6) { -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("next")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v193 := v192.Get() +v194 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v195 := v194.FindInternedVar(lang.NewSymbol("seq")) +if v195.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v195))) } -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v20}) -v21 = v25 -} else { -v21 = v20 +v196 := v195.Get() +v197 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v198 := v197.FindInternedVar(lang.NewSymbol("concat")) +if v198.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v198))) } -var v20 any = v21 -_ = v20 -var v27 any -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("vector?")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +v199 := v198.Get() +v200 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v201 := v200.FindInternedVar(lang.NewSymbol("list")) +if v201.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v201))) } -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("first")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v202 := v201.Get() +v203 := lang.Apply(v202, []any{lang.NewSymbol("quote")}) +v204 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v205 := v204.FindInternedVar(lang.NewSymbol("list")) +if v205.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v205))) } -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v26}) -v35 := lang.Apply(v30, []any{v34}) -if lang.IsTruthy(v35) { -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +v206 := v205.Get() +v207 := lang.Apply(v206, []any{v5}) +v208 := lang.Apply(v199, []any{v203, v207}) +v209 := lang.Apply(v196, []any{v208}) +v210 := lang.Apply(v193, []any{v209}) +v211 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v212 := v211.FindInternedVar(lang.NewSymbol("list")) +if v212.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v212))) } -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v26}) -v27 = v39 -} else { -var v40 any -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("seq?")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +v213 := v212.Get() +v214 := lang.Apply(v213, []any{v5}) +v215 := lang.Apply(v178, []any{v182, v186, v190, v210, v214}) +v216 := lang.Apply(v175, []any{v215}) +v217 := lang.Apply(v172, []any{v216}) +v218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v219 := v218.FindInternedVar(lang.NewSymbol("map")) +if v219.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v219))) } -v43 := v42.Get() -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("first")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +v220 := v219.Get() +var v221 lang.FnFunc +v221 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v222 := args[0] +v223 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v224 := v223.FindInternedVar(lang.NewSymbol("seq")) +if v224.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v224))) } -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v26}) -v48 := lang.Apply(v43, []any{v47}) -if lang.IsTruthy(v48) { -v40 = v26 -} else { -var v49 any -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("seq")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +v225 := v224.Get() +v226 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v227 := v226.FindInternedVar(lang.NewSymbol("concat")) +if v227.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v227))) } -v52 := v51.Get() -v53 := lang.Apply(v52, []any{v26}) -if lang.IsTruthy(v53) { -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("str")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +v228 := v227.Get() +v229 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v230 := v229.FindInternedVar(lang.NewSymbol("list")) +if v230.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v230))) } -v56 := v55.Get() -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("first")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +v231 := v230.Get() +v232 := lang.Apply(v231, []any{lang.NewSymbol("do")}) +v233 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v234 := v233.FindInternedVar(lang.NewSymbol("list")) +if v234.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v234))) } -v59 := v58.Get() -v60 := lang.Apply(v59, []any{v26}) -v61 := lang.Apply(v56, []any{"Parameter declaration ", v60, " should be a vector"}) -v49 = v61 -} else { -v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v63 := v62.FindInternedVar(lang.NewSymbol("str")) -if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +v235 := v234.Get() +v236 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v237 := v236.FindInternedVar(lang.NewSymbol("seq")) +if v237.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v237))) } -v64 := v63.Get() -v65 := lang.Apply(v64, []any{"Parameter declaration missing"}) -v49 = v65 +v238 := v237.Get() +v239 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v240 := v239.FindInternedVar(lang.NewSymbol("concat")) +if v240.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v240))) } -v66 := lang.Apply(lang1.NewIllegalArgumentError, []any{v49}) -panic(v66) +v241 := v240.Get() +v242 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v243 := v242.FindInternedVar(lang.NewSymbol("list")) +if v243.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v243))) } -v27 = v40 +v244 := v243.Get() +v245 := lang.Apply(v244, []any{lang.NewSymbol("glojure.core/defmulti")}) +v246 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v247 := v246.FindInternedVar(lang.NewSymbol("list")) +if v247.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v247))) } -var v26 any = v27 -_ = v26 -var v68 lang.FnFunc -v68 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v69 := args[0] -var v70 any -v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v72 := v71.FindInternedVar(lang.NewSymbol("not")) -if v72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) +v248 := v247.Get() +v249 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v250 := v249.FindInternedVar(lang.NewSymbol("first")) +if v250.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v250))) } -v73 := v72.Get() -v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v75 := v74.FindInternedVar(lang.NewSymbol("seq?")) -if v75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) +v251 := v250.Get() +v252 := lang.Apply(v251, []any{v222}) +v253 := lang.Apply(v248, []any{v252}) +v254 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v255 := v254.FindInternedVar(lang.NewSymbol("list")) +if v255.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v255))) } -v76 := v75.Get() -v77 := lang.Apply(v76, []any{v69}) -v78 := lang.Apply(v73, []any{v77}) -if lang.IsTruthy(v78) { -v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v80 := v79.FindInternedVar(lang.NewSymbol("str")) -if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) +v256 := v255.Get() +v257 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v258 := v257.FindInternedVar(lang.NewSymbol("seq")) +if v258.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v258))) } -v81 := v80.Get() -v82 := lang.Apply(v81, []any{"Invalid signature ", v69, " should be a list"}) -v83 := lang.Apply(lang1.NewIllegalArgumentError, []any{v82}) -panic(v83) -} else { -v70 = nil +v259 := v258.Get() +v260 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v261 := v260.FindInternedVar(lang.NewSymbol("concat")) +if v261.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v261))) } -_ = v70 -var v84 any = v69 -_ = v84 -v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v87 := v86.FindInternedVar(lang.NewSymbol("seq")) -if v87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) +v262 := v261.Get() +v263 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v264 := v263.FindInternedVar(lang.NewSymbol("list")) +if v264.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v264))) } -v88 := v87.Get() -v89 := lang.Apply(v88, []any{v84}) -var v85 any = v89 -_ = v85 -v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v92 := v91.FindInternedVar(lang.NewSymbol("first")) -if v92.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) +v265 := v264.Get() +v266 := lang.Apply(v265, []any{lang.NewSymbol("glojure.core/fn")}) +v267 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v268 := v267.FindInternedVar(lang.NewSymbol("list")) +if v268.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v268))) } -v93 := v92.Get() -v94 := lang.Apply(v93, []any{v85}) -var v90 any = v94 -_ = v90 -v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v97 := v96.FindInternedVar(lang.NewSymbol("next")) -if v97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) +v269 := v268.Get() +v270 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v271 := v270.FindInternedVar(lang.NewSymbol("apply")) +if v271.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v271))) } -v98 := v97.Get() -v99 := lang.Apply(v98, []any{v95}) -var v95 any = v99 -_ = v95 -var v100 any = v90 -_ = v100 -var v101 any = v95 -_ = v101 -var v103 any -v104 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v105 := v104.FindInternedVar(lang.NewSymbol("not")) -if v105.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v105))) +v272 := v271.Get() +v273 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v274 := v273.FindInternedVar(lang.NewSymbol("vector")) +if v274.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v274))) } -v106 := v105.Get() -v107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v108 := v107.FindInternedVar(lang.NewSymbol("vector?")) -if v108.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v108))) +v275 := v274.Get() +v276 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v277 := v276.FindInternedVar(lang.NewSymbol("seq")) +if v277.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v277))) } -v109 := v108.Get() -v110 := lang.Apply(v109, []any{v100}) -v111 := lang.Apply(v106, []any{v110}) -if lang.IsTruthy(v111) { -var v112 any -v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v114 := v113.FindInternedVar(lang.NewSymbol("seq?")) -if v114.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) +v278 := v277.Get() +v279 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v280 := v279.FindInternedVar(lang.NewSymbol("concat")) +if v280.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v280))) } -v115 := v114.Get() -v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v117 := v116.FindInternedVar(lang.NewSymbol("first")) -if v117.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) +v281 := v280.Get() +v282 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v283 := v282.FindInternedVar(lang.NewSymbol("list")) +if v283.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v283))) } -v118 := v117.Get() -v119 := lang.Apply(v118, []any{v26}) -v120 := lang.Apply(v115, []any{v119}) -if lang.IsTruthy(v120) { -v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v122 := v121.FindInternedVar(lang.NewSymbol("str")) -if v122.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) +v284 := v283.Get() +v285 := lang.Apply(v284, []any{lang.NewSymbol("this")}) +v286 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v287 := v286.FindInternedVar(lang.NewSymbol("list")) +if v287.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v287))) } -v123 := v122.Get() -v124 := lang.Apply(v123, []any{"Parameter declaration ", v100, " should be a vector"}) -v112 = v124 -} else { -v125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v126 := v125.FindInternedVar(lang.NewSymbol("str")) -if v126.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v126))) +v288 := v287.Get() +v289 := lang.Apply(v288, []any{lang.NewSymbol("&")}) +v290 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v291 := v290.FindInternedVar(lang.NewSymbol("list")) +if v291.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v291))) } -v127 := v126.Get() -v128 := lang.Apply(v127, []any{"Invalid signature ", v69, " should be a list"}) -v112 = v128 +v292 := v291.Get() +v293 := lang.Apply(v292, []any{lang.NewSymbol("args")}) +v294 := lang.Apply(v281, []any{v285, v289, v293}) +v295 := lang.Apply(v278, []any{v294}) +v296 := lang.Apply(v272, []any{v275, v295}) +v297 := lang.Apply(v269, []any{v296}) +v298 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v299 := v298.FindInternedVar(lang.NewSymbol("list")) +if v299.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v299))) } -v129 := lang.Apply(lang1.NewIllegalArgumentError, []any{v112}) -panic(v129) -} else { -v103 = nil +v300 := v299.Get() +v301 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v302 := v301.FindInternedVar(lang.NewSymbol("seq")) +if v302.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v302))) } -var v102 any = v103 -_ = v102 -var v131 any -v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v134 := v133.FindInternedVar(lang.NewSymbol("next")) -if v134.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) +v303 := v302.Get() +v304 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v305 := v304.FindInternedVar(lang.NewSymbol("concat")) +if v305.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v305))) } -v135 := v134.Get() -v136 := lang.Apply(v135, []any{v101}) -var v132 any = v136 -_ = v132 -var v138 any -if lang.IsTruthy(v132) { -v139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v140 := v139.FindInternedVar(lang.NewSymbol("map?")) -if v140.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v140))) +v306 := v305.Get() +v307 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v308 := v307.FindInternedVar(lang.NewSymbol("list")) +if v308.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v308))) } -v141 := v140.Get() -v142 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v143 := v142.FindInternedVar(lang.NewSymbol("first")) -if v143.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v143))) +v309 := v308.Get() +v310 := lang.Apply(v309, []any{lang.NewSymbol("glojure.core/class")}) +v311 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v312 := v311.FindInternedVar(lang.NewSymbol("list")) +if v312.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v312))) } -v144 := v143.Get() -v145 := lang.Apply(v144, []any{v101}) -v146 := lang.Apply(v141, []any{v145}) -v138 = v146 -} else { -v138 = v132 +v313 := v312.Get() +v314 := lang.Apply(v313, []any{lang.NewSymbol("this")}) +v315 := lang.Apply(v306, []any{v310, v314}) +v316 := lang.Apply(v303, []any{v315}) +v317 := lang.Apply(v300, []any{v316}) +v318 := lang.Apply(v262, []any{v266, v297, v317}) +v319 := lang.Apply(v259, []any{v318}) +v320 := lang.Apply(v256, []any{v319}) +v321 := lang.Apply(v241, []any{v245, v253, v320}) +v322 := lang.Apply(v238, []any{v321}) +v323 := lang.Apply(v235, []any{v322}) +v324 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v325 := v324.FindInternedVar(lang.NewSymbol("list")) +if v325.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v325))) } -if lang.IsTruthy(v138) { -v132 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v133 := v132.FindInternedVar(lang.NewSymbol("first")) -if v133.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v133))) +v326 := v325.Get() +v327 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v328 := v327.FindInternedVar(lang.NewSymbol("seq")) +if v328.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v328))) } -v134 := v133.Get() -v135 := lang.Apply(v134, []any{v101}) -v131 = v135 -} else { -v131 = nil +v329 := v328.Get() +v330 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v331 := v330.FindInternedVar(lang.NewSymbol("concat")) +if v331.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v331))) } -var v130 any = v131 -_ = v130 -var v137 any -if lang.IsTruthy(v130) { -v138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v139 := v138.FindInternedVar(lang.NewSymbol("next")) -if v139.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v139))) +v332 := v331.Get() +v333 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v334 := v333.FindInternedVar(lang.NewSymbol("list")) +if v334.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v334))) } -v140 := v139.Get() -v141 := lang.Apply(v140, []any{v136}) -v137 = v141 -} else { -v137 = v136 +v335 := v334.Get() +v336 := lang.Apply(v335, []any{lang.NewSymbol("glojure.core/swap!")}) +v337 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v338 := v337.FindInternedVar(lang.NewSymbol("list")) +if v338.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v338))) } -var v136 any = v137 -_ = v136 -var v143 any = v142 -_ = v143 -var v145 any -if lang.IsTruthy(v143) { -v145 = v143 -} else { -v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v147 := v146.FindInternedVar(lang.NewSymbol("meta")) -if v147.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) +v339 := v338.Get() +v340 := lang.Apply(v339, []any{v5}) +v341 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v342 := v341.FindInternedVar(lang.NewSymbol("list")) +if v342.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v342))) } -v148 := v147.Get() -v149 := lang.Apply(v148, []any{v100}) -v145 = v149 +v343 := v342.Get() +v344 := lang.Apply(v343, []any{lang.NewSymbol("glojure.core/assoc-in")}) +v345 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v346 := v345.FindInternedVar(lang.NewSymbol("list")) +if v346.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v346))) } -var v142 any = v145 -_ = v142 -v144 := lang.Apply(lang.NewKeyword("pre"), []any{v142}) -var v143 any = v144 -_ = v143 -v146 := lang.Apply(lang.NewKeyword("post"), []any{v142}) -var v145 any = v146 -_ = v145 -var v148 any -if lang.IsTruthy(v145) { -v149 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v150 := v149.FindInternedVar(lang.NewSymbol("seq")) -if v150.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v150))) +v347 := v346.Get() +v348 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v349 := v348.FindInternedVar(lang.NewSymbol("apply")) +if v349.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v349))) } -v151 := v150.Get() -v152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v153 := v152.FindInternedVar(lang.NewSymbol("concat")) -if v153.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v153))) -} -v154 := v153.Get() -v155 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v156 := v155.FindInternedVar(lang.NewSymbol("list")) -if v156.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v156))) -} -v157 := v156.Get() -v158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v159 := v158.FindInternedVar(lang.NewSymbol("seq")) -if v159.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v159))) -} -v160 := v159.Get() -v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v162 := v161.FindInternedVar(lang.NewSymbol("concat")) -if v162.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) +v350 := v349.Get() +v351 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v352 := v351.FindInternedVar(lang.NewSymbol("vector")) +if v352.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v352))) } -v163 := v162.Get() -v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v165 := v164.FindInternedVar(lang.NewSymbol("list")) -if v165.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) +v353 := v352.Get() +v354 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v355 := v354.FindInternedVar(lang.NewSymbol("seq")) +if v355.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v355))) } -v166 := v165.Get() -v167 := lang.Apply(v166, []any{lang.NewSymbol("glojure.core/let")}) -v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v169 := v168.FindInternedVar(lang.NewSymbol("list")) -if v169.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) +v356 := v355.Get() +v357 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v358 := v357.FindInternedVar(lang.NewSymbol("concat")) +if v358.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v358))) } -v170 := v169.Get() -v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v172 := v171.FindInternedVar(lang.NewSymbol("apply")) -if v172.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) +v359 := v358.Get() +v360 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v361 := v360.FindInternedVar(lang.NewSymbol("list")) +if v361.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v361))) } -v173 := v172.Get() -v174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v175 := v174.FindInternedVar(lang.NewSymbol("vector")) -if v175.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v175))) +v362 := v361.Get() +v363 := lang.Apply(v362, []any{lang.NewKeyword("multis")}) +v364 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v365 := v364.FindInternedVar(lang.NewSymbol("list")) +if v365.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v365))) } -v176 := v175.Get() -v177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v178 := v177.FindInternedVar(lang.NewSymbol("seq")) -if v178.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v178))) +v366 := v365.Get() +v367 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v368 := v367.FindInternedVar(lang.NewSymbol("seq")) +if v368.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v368))) } -v179 := v178.Get() -v180 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v181 := v180.FindInternedVar(lang.NewSymbol("concat")) -if v181.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v181))) +v369 := v368.Get() +v370 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v371 := v370.FindInternedVar(lang.NewSymbol("concat")) +if v371.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v371))) } -v182 := v181.Get() -v183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v184 := v183.FindInternedVar(lang.NewSymbol("list")) -if v184.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v184))) +v372 := v371.Get() +v373 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v374 := v373.FindInternedVar(lang.NewSymbol("list")) +if v374.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v374))) } -v185 := v184.Get() -v186 := lang.Apply(v185, []any{lang.NewSymbol("%")}) -v187 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v188 := v187.FindInternedVar(lang.NewSymbol("list")) -if v188.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v188))) +v375 := v374.Get() +v376 := lang.Apply(v375, []any{lang.NewSymbol("glojure.core/keyword")}) +v377 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v378 := v377.FindInternedVar(lang.NewSymbol("list")) +if v378.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v378))) } -v189 := v188.Get() -var v190 any -v191 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v192 := v191.FindInternedVar(lang.NewSymbol("<")) -if v192.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v192))) +v379 := v378.Get() +v380 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v381 := v380.FindInternedVar(lang.NewSymbol("seq")) +if v381.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v381))) } -v193 := v192.Get() -v194 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v195 := v194.FindInternedVar(lang.NewSymbol("count")) -if v195.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v195))) +v382 := v381.Get() +v383 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v384 := v383.FindInternedVar(lang.NewSymbol("concat")) +if v384.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v384))) } -v196 := v195.Get() -v197 := lang.Apply(v196, []any{v147}) -v198 := lang.Apply(v193, []any{int64(1), v197}) -if lang.IsTruthy(v198) { -v199 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v200 := v199.FindInternedVar(lang.NewSymbol("seq")) -if v200.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v200))) +v385 := v384.Get() +v386 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v387 := v386.FindInternedVar(lang.NewSymbol("list")) +if v387.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v387))) } -v201 := v200.Get() -v202 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v203 := v202.FindInternedVar(lang.NewSymbol("concat")) -if v203.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v203))) +v388 := v387.Get() +v389 := lang.Apply(v388, []any{lang.NewSymbol("quote")}) +v390 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v391 := v390.FindInternedVar(lang.NewSymbol("list")) +if v391.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v391))) } -v204 := v203.Get() -v205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v206 := v205.FindInternedVar(lang.NewSymbol("list")) -if v206.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v206))) +v392 := v391.Get() +v393 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v394 := v393.FindInternedVar(lang.NewSymbol("first")) +if v394.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v394))) } -v207 := v206.Get() -v208 := lang.Apply(v207, []any{lang.NewSymbol("do")}) -v209 := lang.Apply(v204, []any{v208, v147}) -v210 := lang.Apply(v201, []any{v209}) -v190 = v210 -} else { -v211 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v212 := v211.FindInternedVar(lang.NewSymbol("first")) -if v212.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v212))) +v395 := v394.Get() +v396 := lang.Apply(v395, []any{v222}) +v397 := lang.Apply(v392, []any{v396}) +v398 := lang.Apply(v385, []any{v389, v397}) +v399 := lang.Apply(v382, []any{v398}) +v400 := lang.Apply(v379, []any{v399}) +v401 := lang.Apply(v372, []any{v376, v400}) +v402 := lang.Apply(v369, []any{v401}) +v403 := lang.Apply(v366, []any{v402}) +v404 := lang.Apply(v359, []any{v363, v403}) +v405 := lang.Apply(v356, []any{v404}) +v406 := lang.Apply(v350, []any{v353, v405}) +v407 := lang.Apply(v347, []any{v406}) +v408 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v409 := v408.FindInternedVar(lang.NewSymbol("list")) +if v409.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v409))) } -v213 := v212.Get() -v214 := lang.Apply(v213, []any{v147}) -v190 = v214 +v410 := v409.Get() +v411 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v412 := v411.FindInternedVar(lang.NewSymbol("first")) +if v412.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v412))) } -v215 := lang.Apply(v189, []any{v190}) -v216 := lang.Apply(v182, []any{v186, v215}) -v217 := lang.Apply(v179, []any{v216}) -v218 := lang.Apply(v173, []any{v176, v217}) -v219 := lang.Apply(v170, []any{v218}) -v220 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v221 := v220.FindInternedVar(lang.NewSymbol("map")) -if v221.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v221))) +v413 := v412.Get() +v414 := lang.Apply(v413, []any{v222}) +v415 := lang.Apply(v410, []any{v414}) +v416 := lang.Apply(v332, []any{v336, v340, v344, v407, v415}) +v417 := lang.Apply(v329, []any{v416}) +v418 := lang.Apply(v326, []any{v417}) +v419 := lang.Apply(v228, []any{v232, v323, v418}) +v420 := lang.Apply(v225, []any{v419}) +return v420 +}) +v222 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(102), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(104), lang.NewKeyword("end-column"), int(90)) +v223, err := lang.WithMeta(v221, v222.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v222 := v221.Get() -var v223 lang.FnFunc -v223 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v224 := args[0] +v224 := lang.Apply(v220, []any{v223, v35}) v225 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v226 := v225.FindInternedVar(lang.NewSymbol("seq")) +v226 := v225.FindInternedVar(lang.NewSymbol("list")) if v226.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v226))) } v227 := v226.Get() v228 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v229 := v228.FindInternedVar(lang.NewSymbol("concat")) +v229 := v228.FindInternedVar(lang.NewSymbol("seq")) if v229.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v229))) } v230 := v229.Get() v231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v232 := v231.FindInternedVar(lang.NewSymbol("list")) +v232 := v231.FindInternedVar(lang.NewSymbol("concat")) if v232.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v232))) } v233 := v232.Get() -v234 := lang.Apply(v233, []any{lang.NewSymbol("glojure.core/assert")}) -v235 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v236 := v235.FindInternedVar(lang.NewSymbol("list")) -if v236.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v236))) -} -v237 := v236.Get() -v238 := lang.Apply(v237, []any{v224}) -v239 := lang.Apply(v230, []any{v234, v238}) -v240 := lang.Apply(v227, []any{v239}) -return v240 -}) -v224 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4582), lang.NewKeyword("column"), int(41), lang.NewKeyword("end-line"), int(4582), lang.NewKeyword("end-column"), int(62)) -v225, err := lang.WithMeta(v223, v224.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v226 := lang.Apply(v222, []any{v225, v145}) -v227 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v228 := v227.FindInternedVar(lang.NewSymbol("list")) -if v228.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v228))) -} -v229 := v228.Get() -v230 := lang.Apply(v229, []any{lang.NewSymbol("%")}) -v231 := lang.Apply(v163, []any{v167, v219, v226, v230}) -v232 := lang.Apply(v160, []any{v231}) -v233 := lang.Apply(v157, []any{v232}) -v234 := lang.Apply(v154, []any{v233}) -v235 := lang.Apply(v151, []any{v234}) -v148 = v235 -} else { -v148 = v147 +v234 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v235 := v234.FindInternedVar(lang.NewSymbol("list")) +if v235.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v235))) } -var v147 any = v148 -_ = v147 -var v237 any -if lang.IsTruthy(v143) { +v236 := v235.Get() +v237 := lang.Apply(v236, []any{lang.NewSymbol("var")}) v238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v239 := v238.FindInternedVar(lang.NewSymbol("concat")) +v239 := v238.FindInternedVar(lang.NewSymbol("list")) if v239.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v239))) } v240 := v239.Get() -v241 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v242 := v241.FindInternedVar(lang.NewSymbol("map")) -if v242.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v242))) -} -v243 := v242.Get() -var v244 lang.FnFunc -v244 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) +v241 := lang.Apply(v240, []any{v5}) +v242 := lang.Apply(v233, []any{v237, v241}) +v243 := lang.Apply(v230, []any{v242}) +v244 := lang.Apply(v227, []any{v243}) +v245 := lang.Apply(v55, []any{v59, v169, v217, v224, v244}) +v246 := lang.Apply(v52, []any{v245}) +return v246 } -v245 := args[0] -v246 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v247 := v246.FindInternedVar(lang.NewSymbol("seq")) -if v247.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v247))) -} -v248 := v247.Get() -v249 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v250 := v249.FindInternedVar(lang.NewSymbol("concat")) -if v250.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v250))) -} -v251 := v250.Get() -v252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v253 := v252.FindInternedVar(lang.NewSymbol("list")) -if v253.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v253))) -} -v254 := v253.Get() -v255 := lang.Apply(v254, []any{lang.NewSymbol("glojure.core/assert")}) -v256 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v257 := v256.FindInternedVar(lang.NewSymbol("list")) -if v257.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v257))) -} -v258 := v257.Get() -v259 := lang.Apply(v258, []any{v245}) -v260 := lang.Apply(v251, []any{v255, v259}) -v261 := lang.Apply(v248, []any{v260}) -return v261 }) -v245 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4586), lang.NewKeyword("column"), int(44), lang.NewKeyword("end-line"), int(4586), lang.NewKeyword("end-column"), int(65)) -v246, err := lang.WithMeta(v244, v245.(lang.IPersistentMap)) -if err != nil { - panic(err) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v247 := lang.Apply(v243, []any{v246, v143}) -v248 := lang.Apply(v240, []any{v247, v236}) -v237 = v248 -} else { -v237 = v236 } -var v236 any = v237 -_ = v236 -v250 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v251 := v250.FindInternedVar(lang.NewSymbol("maybe-destructured")) -if v251.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v251))) +// defstruct +{ +v0 := lang.NewSymbol("defstruct").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("keys"))), lang.NewKeyword("doc"), "Same as (def name (create-struct keys...))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4044), lang.NewKeyword("end-line"), int(4044))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("seq")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v252 := v251.Get() -v253 := lang.Apply(v252, []any{v100, v236}) -return v253 -}) -v69 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4558), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(4589), lang.NewKeyword("end-column"), int(53)) -v70, err := lang.WithMeta(v68, v69.(lang.IPersistentMap)) -if err != nil { - panic(err) +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("concat")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -var v67 any = v70 -_ = v67 -v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v73 := v72.FindInternedVar(lang.NewSymbol("map")) -if v73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("list")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } -v74 := v73.Get() -v75 := lang.Apply(v74, []any{v67, v26}) -var v71 any = v75 -_ = v71 -v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v78 := v77.FindInternedVar(lang.NewSymbol("with-meta")) -if v78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) +v15 := v14.Get() +v16 := lang.Apply(v15, []any{lang.NewSymbol("def")}) +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("list")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v79 := v78.Get() -var v80 any -if lang.IsTruthy(v6) { -v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v82 := v81.FindInternedVar(lang.NewSymbol("list*")) -if v82.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v5}) +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("list")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v83 := v82.Get() -v84 := lang.Apply(v83, []any{lang.NewSymbol("fn*"), v6, v71}) -v80 = v84 -} else { -v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v86 := v85.FindInternedVar(lang.NewSymbol("cons")) -if v86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("seq")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -v87 := v86.Get() -v88 := lang.Apply(v87, []any{lang.NewSymbol("fn*"), v71}) -v80 = v88 +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("concat")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v90 := v89.FindInternedVar(lang.NewSymbol("meta")) -if v90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) +v29 := v28.Get() +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("list")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) } -v91 := v90.Get() -v92 := lang.Apply(v91, []any{v3}) -v93 := lang.Apply(v79, []any{v80, v92}) -return v93 +v32 := v31.Get() +v33 := lang.Apply(v32, []any{lang.NewSymbol("glojure.core/create-struct")}) +v34 := lang.Apply(v29, []any{v33, v6}) +v35 := lang.Apply(v26, []any{v34}) +v36 := lang.Apply(v23, []any{v35}) +v37 := lang.Apply(v12, []any{v16, v20, v36}) +v38 := lang.Apply(v9, []any{v37}) +return v38 } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -25871,81 +24405,41 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// complement +// delay { -v0 := lang.NewSymbol("complement").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Takes a fn f and returns a fn that takes the same arguments as f,\n has the same effects, if any, and returns the opposite truth value.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1428), lang.NewKeyword("end-line"), int(1428))).(*lang.Symbol) +v0 := lang.NewSymbol("delay").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Takes a body of expressions and yields a Delay object that will\n invoke the body only the first time it is forced (with force or deref/@), and\n will cache the result and return it on all subsequent force\n calls. See also - realized?", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(739), lang.NewKeyword("end-line"), int(739))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 0: -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("not")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v3, nil) -v9 := lang.Apply(v7, []any{v8}) -return v9 - case 1: -v5 := args[0] + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("not")) +v7 := v6.FindInternedVar(lang.NewSymbol("list")) if v7.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } v8 := v7.Get() -v9 := lang.Apply(v3, []any{v5}) -v10 := lang.Apply(v8, []any{v9}) -return v10 - case 2: -v5 := args[0] -v6 := args[1] -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("not")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("list*")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -v9 := v8.Get() -v10 := lang.Apply(v3, []any{v5, v6}) -v11 := lang.Apply(v9, []any{v10}) -return v11 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := args[0] -v6 := args[1] -v7 := lang.NewList(args[2:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("not")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("apply")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v3, v5, v6, v7}) -v15 := lang.Apply(v10, []any{v14}) -return v15 - } -}) -v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1434), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(1438), lang.NewKeyword("end-column"), int(40)) -v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) +v11 := v10.Get() +v12 := lang.NewVector() +v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(746), lang.NewKeyword("column"), int(62), lang.NewKeyword("end-line"), int(746), lang.NewKeyword("end-column"), int(63)) +v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) if err != nil { panic(err) } -return v6 +v15 := lang.Apply(v11, []any{lang.NewSymbol("fn*"), v14, v5}) +v16 := lang.Apply(v8, []any{lang.NewSymbol("new"), lang.NewSymbol("glojure.lang.Delay"), v15}) +return v16 + } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -25953,9 +24447,9 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// remove-tap +// delay? { -v0 := lang.NewSymbol("remove-tap").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Remove f from the tap set.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7926), lang.NewKeyword("end-line"), int(7926))).(*lang.Symbol) +v0 := lang.NewSymbol("delay?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "returns true if x is a Delay created with delay", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(748), lang.NewKeyword("end-line"), int(748))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -25963,26 +24457,13 @@ v2 = lang.NewFnFunc(func(args ...any) any { } v3 := args[0] v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("swap!")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("tapset")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("disj")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v6, []any{v9, v12, v3}) -_ = v13 -return nil +v7 := lang.Apply(v6, []any{glojure.lang8.Delay, v3}) +return v7 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -25990,25 +24471,18 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// print-map +// deliver { -v0 := lang.NewSymbol("print-map").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(252), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(252), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("print-one"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v0 := lang.NewSymbol("deliver").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("promise"), lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Delivers the supplied value to the promise, releasing any pending\n derefs. A subsequent call to deliver on a promise will have no effect.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7152), lang.NewKeyword("end-line"), int(7152))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { + if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] v4 := args[1] -v5 := args[2] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("print-prefix-map")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{nil, v3, v4, v5}) -return v9 +v5 := lang.Apply(v3, []any{v4}) +return v5 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -26016,216 +24490,108 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// prn +// denominator { -v0 := lang.NewSymbol("prn").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Same as pr followed by (newline). Observes *flush-on-newline*", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3715), lang.NewKeyword("end-line"), int(3715))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewList(args[0:]...) -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("apply")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("pr")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v6, []any{v9, v3}) -_ = v10 -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("newline")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, nil) -_ = v14 -var v15 any -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("*flush-on-newline*")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -if lang.IsTruthy(v18) { -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("flush")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v1 := reflect.TypeOf((*big14.Int)(nil)) +v0 := lang.NewSymbol("denominator").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("r"))), lang.NewKeyword("doc"), "Returns the denominator part of a Ratio.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3591), lang.NewKeyword("end-line"), int(3591))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5, ok := lang.FieldOrMethod(v4, "denominator") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "denominator"))) } -v21 := v20.Get() -v22 := lang.Apply(v21, nil) -v15 = v22 -} else { -v15 = nil +var v6 any +switch reflect.TypeOf(v5).Kind() { +case reflect.Func: + v6 = lang.Apply(v5, nil) +default: + v6 = v5 } -return v15 - } +return v6 }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) +v4 := reflect.TypeOf((*big14.Int)(nil)) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// parse-long +// deref { -v0 := lang.NewSymbol("parse-long").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse string of decimal digits with optional leading -/+ and return a\n Long value, or nil if parse fails", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7969), lang.NewKeyword("end-line"), int(7969))).(*lang.Symbol) +v0 := lang.NewSymbol("deref").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref")), lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("timeout-ms"), lang.NewSymbol("timeout-val"))), lang.NewKeyword("doc"), "Also reader macro: @ref/@agent/@var/@atom/@delay/@future/@promise. Within a transaction,\n returns the in-transaction-value of ref, else returns the\n most-recently-committed value of ref. When applied to a var, agent\n or atom, returns its current state. When applied to a delay, forces\n it if not already forced. When applied to a future, will block if\n computation not complete. When applied to a promise, will block\n until a value is delivered. The variant taking a timeout can be\n used for blocking references (futures and promises), and will return\n timeout-val if the timeout (in milliseconds) is reached before a\n value is available. See also - realized?.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2304), lang.NewKeyword("end-line"), int(2304))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + switch len(args) { + case 1: v3 := args[0] var v4 any v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("string?")) +v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) if v6.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) +v8 := lang.Apply(v7, []any{lang1.IDeref, v3}) if lang.IsTruthy(v8) { -v10 := lang.Apply(strconv4.ParseInt, []any{v3, int64(10), int64(64)}) -var v9 any = v10 -_ = v9 -var v12 any -v13 := lang.Apply(v9, []any{int64(1)}) -if lang.IsTruthy(v13) { -v12 = nil -} else { -v14 := lang.Apply(v9, []any{int64(0)}) -v12 = v14 +v9, ok := lang.FieldOrMethod(v3, "Deref") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "Deref"))) } -v4 = v12 +var v10 any +switch reflect.TypeOf(v9).Kind() { +case reflect.Func: + v10 = lang.Apply(v9, nil) +default: + v10 = v9 +} +v4 = v10 } else { -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("parsing-err")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("deref-future")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v3}) -v13 := lang.Apply(lang1.NewIllegalArgumentError, []any{v12}) -panic(v13) +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v3}) +v4 = v14 } return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// map-entry? -{ -v0 := lang.NewSymbol("map-entry?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a map entry", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.8", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1473), lang.NewKeyword("end-line"), int(1473))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{java.util13.Map$Entry, v3}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// cond -{ -v0 := lang.NewSymbol("cond").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes a set of test/expr pairs. It evaluates each test one at a\n time. If a test returns logical true, cond evaluates and returns\n the value of the corresponding expr and doesn't evaluate any of the\n other tests or exprs. (cond) returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(569), lang.NewKeyword("end-line"), int(569))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + case 3: v3 := args[0] v4 := args[1] -v5 := lang.NewList(args[2:]...) +v5 := args[2] var v6 any -if lang.IsTruthy(v5) { v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("list")) +v8 := v7.FindInternedVar(lang.NewSymbol("instance?")) if v8.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("first")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{v5}) -var v14 any -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("next")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v5}) -if lang.IsTruthy(v18) { -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("second")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v10 := lang.Apply(v9, []any{lang1.IBlockingDeref, v3}) +if lang.IsTruthy(v10) { +v11, _ := lang.FieldOrMethod(v3, "DerefWithTimeout") +if reflect.TypeOf(v11).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("DerefWithTimeout is not a function"))) } -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v5}) -v14 = v22 +v12 := lang.Apply(v11, []any{v4, v5}) +v6 = v12 } else { -v23 := lang.Apply(lang1.NewIllegalArgumentError, []any{"cond requires an even number of forms"}) -panic(v23) -} -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("cons")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("next")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("next")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("deref-future")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } -v32 := v31.Get() -v33 := lang.Apply(v32, []any{v5}) -v34 := lang.Apply(v29, []any{v33}) -v35 := lang.Apply(v26, []any{lang.NewSymbol("glojure.core/cond"), v34}) -v36 := lang.Apply(v9, []any{lang.NewSymbol("if"), v13, v14, v35}) -v6 = v36 -} else { -v6 = nil +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v3, v4, v5}) +v6 = v16 } return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -26234,128 +24600,165 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// reduce-kv +// deref-as-map { -v0 := lang.NewSymbol("reduce-kv").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Reduces an associative collection. f should be a function of 3\n arguments. Returns the result of applying f to init, the first key\n and the first value in coll, then applying f to that result and the\n 2nd key and value, etc. If coll contains no entries, returns init\n and f is not called. Note that reduce-kv is supported on vectors,\n where the keys will be the ordinals.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6925), lang.NewKeyword("end-line"), int(6925))).(*lang.Symbol) +v0 := lang.NewSymbol("deref-as-map").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(408), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(408), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core.protocols")) -v7 := v6.FindInternedVar(lang.NewSymbol("kv-reduce")) +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) if v7.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } v8 := v7.Get() -v9 := lang.Apply(v8, []any{v5, v3, v4}) -return v9 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v9 := lang.Apply(v8, []any{lang1.IPending, v3}) +var v5 any = v9 +_ = v5 +var v11 any +if lang.IsTruthy(v5) { +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("not")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } +v14 := v13.Get() +v15, ok := lang.FieldOrMethod(v3, "isRealized") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "isRealized"))) } -// supers -{ -v0 := lang.NewSymbol("supers").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("class"))), lang.NewKeyword("doc"), "Returns the immediate and indirect superclasses and interfaces of c, if any", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5575), lang.NewKeyword("end-line"), int(5575))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("set")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +var v16 any +switch reflect.TypeOf(v15).Kind() { +case reflect.Func: + v16 = lang.Apply(v15, nil) +default: + v16 = v15 } -v7 := v6.Get() +v17 := lang.Apply(v14, []any{v16}) +v11 = v17 +} else { +v11 = v5 +} +var v4 any = v11 +_ = v4 +var v6 any +if lang.IsTruthy(v4) { +v6 = nil +} else { +var v7 any +func() { +defer func() { +if r := recover(); r != nil { +if lang.CatchMatches(r, lang1.Throwable) { +v8 := r +_ = v8 +v9 := lang.NewVector(true, v8) +v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(415), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(415), lang.NewKeyword("end-column"), int(25)) +v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v7 = v11 +} else { +panic(r) +} +} +}() v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("bases")) +v9 := v8.FindInternedVar(lang.NewSymbol("deref")) if v9.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } v10 := v9.Get() v11 := lang.Apply(v10, []any{v3}) -v12 := lang.Apply(v7, []any{v11}) -var v4 any = v12 -_ = v4 -var v13 any = v4 -_ = v13 -var v14 any -for { -var v15 any +v12 := lang.NewVector(false, v11) +v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(413), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(413), lang.NewKeyword("end-column"), int(32)) +v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v7 = v14 +}() +v6 = v7 +} +var v5 any = v6 +_ = v5 v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("seq")) +v17 := v16.FindInternedVar(lang.NewSymbol("nth")) if v17.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } v18 := v17.Get() -v19 := lang.Apply(v18, []any{v13}) -if lang.IsTruthy(v19) { +v19 := lang.Apply(v18, []any{v5, int64(0), nil}) +var v15 any = v19 +_ = v15 v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("first")) +v22 := v21.FindInternedVar(lang.NewSymbol("nth")) if v22.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } v23 := v22.Get() -v24 := lang.Apply(v23, []any{v13}) +v24 := lang.Apply(v23, []any{v5, int64(1), nil}) var v20 any = v24 _ = v20 -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("bases")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.Apply(v28, []any{v20}) -var v25 any = v29 -_ = v25 -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("into1")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +var v26 any +var v27 any = v15 +_ = v27 +var v29 any +if lang.IsTruthy(v27) { +v29 = v27 +} else { +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("instance?")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v4, v25}) -var v31 any = v35 +v33 := v32.Get() +v34 := lang.Apply(v33, []any{lang1.*Agent, v3}) +var v30 any = v34 +_ = v30 +var v36 any +if lang.IsTruthy(v30) { v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("into1")) +v38 := v37.FindInternedVar(lang.NewSymbol("agent-error")) if v38.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("disj")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +v40 := lang.Apply(v39, []any{v3}) +v36 = v40 +} else { +v36 = v30 } -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v13, v20}) -v44 := lang.Apply(v39, []any{v43, v25}) -var v36 any = v44 -v4 = v31 -v13 = v36 -continue +v29 = v36 +} +if lang.IsTruthy(v29) { +v26 = lang.NewKeyword("failed") } else { -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("not-empty")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +var v27 any +if lang.IsTruthy(v4) { +v27 = lang.NewKeyword("pending") +} else { +var v28 any +if lang.IsTruthy(lang.NewKeyword("else")) { +v28 = lang.NewKeyword("ready") +} else { +v28 = nil } -v22 := v21.Get() -v23 := lang.Apply(v22, []any{v4}) -v15 = v23 +v27 = v28 } -v14 = v15 - break +v26 = v27 } -return v14 +v29 := lang.NewMap(lang.NewKeyword("status"), v26, lang.NewKeyword("val"), v20) +v30 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(416), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(429), lang.NewKeyword("end-column"), int(14)) +v31, err := lang.WithMeta(v29, v30.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v31 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -26363,101 +24766,54 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// update-vals +// deref-future { -v0 := lang.NewSymbol("update-vals").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("f"))), lang.NewKeyword("doc"), "m f => {k (f v) ...}\n\n Given a map m and a function f of 1-argument, returns a new map where the keys of m\n are mapped to result of applying f to the corresponding values of m.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7933), lang.NewKeyword("end-line"), int(7933))).(*lang.Symbol) +v0 := lang.NewSymbol("deref-future").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2296), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(2296), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fut")), lang.NewVector(lang.NewSymbol("fut"), lang.NewSymbol("timeout-ms"), lang.NewSymbol("timeout-val"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + switch len(args) { + case 1: v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("with-meta")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("persistent!")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("reduce-kv")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -var v14 lang.FnFunc -v14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v15 := args[0] -v16 := args[1] -v17 := args[2] -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("assoc!")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v4, []any{v17}) -v22 := lang.Apply(v20, []any{v15, v16, v21}) -return v22 -}) -v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7942), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(7942), lang.NewKeyword("end-column"), int(51)) -v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v17 any -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("instance?")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v4, ok := lang.FieldOrMethod(v3, "Get") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "Get"))) } -v20 := v19.Get() -v21 := lang.Apply(v20, []any{lang1.IEditableCollection, v3}) -if lang.IsTruthy(v21) { -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("transient")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +var v5 any +switch reflect.TypeOf(v4).Kind() { +case reflect.Func: + v5 = lang.Apply(v4, nil) +default: + v5 = v4 } -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v17 = v25 +return v5 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +var v6 any +func() { +defer func() { +if r := recover(); r != nil { +if lang.CatchMatches(r, lang1.TimeoutError) { +v7 := r +_ = v7 +v6 = v5 } else { -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("transient")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.NewMap() -v30 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7945), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(7945), lang.NewKeyword("end-column"), int(31)) -v31, err := lang.WithMeta(v29, v30.(lang.IPersistentMap)) -if err != nil { - panic(err) +panic(r) } -v32 := lang.Apply(v28, []any{v31}) -v17 = v32 } -v33 := lang.Apply(v13, []any{v16, v17, v3}) -v34 := lang.Apply(v10, []any{v33}) -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("meta")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +}() +v7, _ := lang.FieldOrMethod(v3, "Get") +if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Get is not a function"))) } -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v3}) -v39 := lang.Apply(v7, []any{v34, v38}) -return v39 +v8 := lang.Apply(v7, []any{v4, time17.Millisecond}) +v6 = v8 +}() +return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -26465,366 +24821,331 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// vreset! +// derive { -v0 := lang.NewSymbol("vreset!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("vol"), lang.NewSymbol("newval"))), lang.NewKeyword("doc"), "Sets the value of volatile to newval without regard for the\n current value. Returns newval.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2524), lang.NewKeyword("end-line"), int(2524))).(*lang.Symbol) +v0 := lang.NewSymbol("derive").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag"), lang.NewSymbol("parent")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"), lang.NewSymbol("parent"))), lang.NewKeyword("doc"), "Establishes a parent/child relationship between parent and\n tag. Parent must be a namespace-qualified symbol or keyword and\n child can be either a namespace-qualified symbol or keyword or a\n class. h must be a hierarchy obtained from make-hierarchy, if not\n supplied defaults to, and modifies, the global hierarchy.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5648), lang.NewKeyword("end-line"), int(5648))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + switch len(args) { + case 2: v3 := args[0] v4 := args[1] -v5, _ := lang.FieldOrMethod(v3, "reset") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +_ = nil +_ = nil +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("alter-var-root")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } +v7 := v6.Get() +v8 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("global-hierarchy")) +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("derive")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -// deref-as-map -{ -v0 := lang.NewSymbol("deref-as-map").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(408), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(408), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { +v11 := v10.Get() +v12 := lang.Apply(v7, []any{v8, v11, v3, v4}) +_ = v12 +return nil + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +_ = nil +_ = nil +_ = nil +v7 := lang.Apply(lang.NewKeyword("parents"), []any{v3}) +var v6 any = v7 +_ = v6 +v9 := lang.Apply(lang.NewKeyword("descendants"), []any{v3}) +var v8 any = v9 +_ = v8 +v11 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) +var v10 any = v11 +_ = v10 +var v13 lang.FnFunc +v13 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 5 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := args[0] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +v14 := args[0] +v15 := args[1] +v16 := args[2] +v17 := args[3] +v18 := args[4] +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("reduce1")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v8 := v7.Get() -v9 := lang.Apply(v8, []any{lang1.IPending, v3}) -var v5 any = v9 -_ = v5 -var v11 any -if lang.IsTruthy(v5) { -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("not")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +v21 := v20.Get() +var v22 lang.FnFunc +v22 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v23 := args[0] +v24 := args[1] +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("assoc")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -v14 := v13.Get() -v15, ok := lang.FieldOrMethod(v3, "isRealized") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "isRealized"))) +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("reduce1")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } -var v16 any -switch reflect.TypeOf(v15).Kind() { -case reflect.Func: - v16 = lang.Apply(v15, nil) -default: - v16 = v15 +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("conj")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -v17 := lang.Apply(v14, []any{v16}) -v11 = v17 -} else { -v11 = v5 +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("get")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } -var v4 any = v11 -_ = v4 -var v6 any -if lang.IsTruthy(v4) { -v6 = nil -} else { -var v7 any -func() { -defer func() { -if r := recover(); r != nil { -if lang.CatchMatches(r, lang1.Throwable) { -v8 := r -_ = v8 -v9 := lang.NewVector(true, v8) -v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(415), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(415), lang.NewKeyword("end-column"), int(25)) -v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) +v36 := v35.Get() +v37 := lang.CreatePersistentTreeSet() +v38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5671), lang.NewKeyword("column"), int(61), lang.NewKeyword("end-line"), int(5671), lang.NewKeyword("end-column"), int(63)) +v39, err := lang.WithMeta(v37, v38.(lang.IPersistentMap)) if err != nil { panic(err) } -v7 = v11 -} else { -panic(r) -} -} -}() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("deref")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v40 := lang.Apply(v36, []any{v18, v24, v39}) +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("cons")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v3}) -v12 := lang.NewVector(false, v11) -v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(413), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(413), lang.NewKeyword("end-column"), int(32)) -v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) +v43 := v42.Get() +v44 := lang.Apply(v18, []any{v17}) +v45 := lang.Apply(v43, []any{v17, v44}) +v46 := lang.Apply(v30, []any{v33, v40, v45}) +v47 := lang.Apply(v27, []any{v23, v24, v46}) +return v47 +}) +v23 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5669), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(5671), lang.NewKeyword("end-column"), int(98)) +v24, err := lang.WithMeta(v22, v23.(lang.IPersistentMap)) if err != nil { panic(err) } -v7 = v14 -}() -v6 = v7 +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("cons")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -var v5 any = v6 -_ = v5 -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("nth")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +v27 := v26.Get() +v28 := lang.Apply(v16, []any{v15}) +v29 := lang.Apply(v27, []any{v15, v28}) +v30 := lang.Apply(v21, []any{v24, v14, v29}) +return v30 +}) +v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5668), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(5672), lang.NewKeyword("end-column"), int(56)) +v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v5, int64(0), nil}) -var v15 any = v19 -_ = v15 -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("nth")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +var v12 any = v15 +_ = v12 +var v18 any +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("contains?")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v5, int64(1), nil}) -var v20 any = v24 -_ = v20 -var v26 any -var v27 any = v15 -_ = v27 -var v29 any -if lang.IsTruthy(v27) { -v29 = v27 +v21 := v20.Get() +v22 := lang.Apply(v6, []any{v4}) +v23 := lang.Apply(v21, []any{v22, v5}) +if lang.IsTruthy(v23) { +v18 = nil } else { -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("instance?")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +var v24 any +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("contains?")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -v33 := v32.Get() -v34 := lang.Apply(v33, []any{lang1.*Agent, v3}) -var v30 any = v34 -_ = v30 -var v36 any -if lang.IsTruthy(v30) { -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("agent-error")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +v27 := v26.Get() +v28 := lang.Apply(v10, []any{v4}) +v29 := lang.Apply(v27, []any{v28, v5}) +if lang.IsTruthy(v29) { +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("print-str")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) } -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v3}) -v36 = v40 +v32 := v31.Get() +v33 := lang.Apply(v32, []any{v4, "already has", v5, "as ancestor"}) +v34 := lang.Apply(Exception16., []any{v33}) +panic(v34) } else { -v36 = v30 +v24 = nil } -v29 = v36 +_ = v24 +var v35 any +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("contains?")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) } -if lang.IsTruthy(v29) { -v26 = lang.NewKeyword("failed") -} else { -var v27 any -if lang.IsTruthy(v4) { -v27 = lang.NewKeyword("pending") -} else { -var v28 any -if lang.IsTruthy(lang.NewKeyword("else")) { -v28 = lang.NewKeyword("ready") +v38 := v37.Get() +v39 := lang.Apply(v10, []any{v5}) +v40 := lang.Apply(v38, []any{v39, v4}) +if lang.IsTruthy(v40) { +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("print-str")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v43, []any{"Cyclic derivation:", v5, "has", v4, "as ancestor"}) +v45 := lang.Apply(Exception16., []any{v44}) +panic(v45) } else { -v28 = nil +v35 = nil } -v27 = v28 +_ = v35 +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("assoc")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) } -v26 = v27 +v48 := v47.Get() +v49 := lang.Apply(lang.NewKeyword("parents"), []any{v3}) +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("conj")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) } -v29 := lang.NewMap(lang.NewKeyword("status"), v26, lang.NewKeyword("val"), v20) -v30 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(416), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(429), lang.NewKeyword("end-column"), int(14)) -v31, err := lang.WithMeta(v29, v30.(lang.IPersistentMap)) +v52 := v51.Get() +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("get")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +} +v55 := v54.Get() +v56 := lang.CreatePersistentTreeSet() +v57 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5679), lang.NewKeyword("column"), int(61), lang.NewKeyword("end-line"), int(5679), lang.NewKeyword("end-column"), int(63)) +v58, err := lang.WithMeta(v56, v57.(lang.IPersistentMap)) if err != nil { panic(err) } -return v31 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} +v59 := lang.Apply(v55, []any{v6, v4, v58}) +v60 := lang.Apply(v52, []any{v59, v5}) +v61 := lang.Apply(v48, []any{v49, v4, v60}) +v62 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) +v63 := lang.Apply(v12, []any{v62, v4, v8, v5, v10}) +v64 := lang.Apply(lang.NewKeyword("descendants"), []any{v3}) +v65 := lang.Apply(v12, []any{v64, v5, v10, v4, v8}) +v66 := lang.NewMap(lang.NewKeyword("parents"), v61, lang.NewKeyword("ancestors"), v63, lang.NewKeyword("descendants"), v65) +v67 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5679), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(5681), lang.NewKeyword("end-column"), int(61)) +v68, err := lang.WithMeta(v66, v67.(lang.IPersistentMap)) +if err != nil { + panic(err) } -// cat -{ -v0 := lang.NewSymbol("cat").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rf"))), lang.NewKeyword("doc"), "A transducer which concatenates the contents of each input, which must be a\n collection, into the reduction.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7688), lang.NewKeyword("end-line"), int(7688))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("preserving-reduced")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v18 = v68 } -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -var v4 any = v8 -_ = v4 -var v10 lang.FnFunc -v10 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v11 := lang.Apply(v3, nil) -return v11 - case 1: -v11 := args[0] -v12 := lang.Apply(v3, []any{v11}) -return v12 - case 2: -v11 := args[0] -v12 := args[1] -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("reduce")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +var v17 any = v18 +_ = v17 +var v70 any +if lang.IsTruthy(v17) { +v70 = v17 +} else { +v70 = v3 } -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v4, v11, v12}) -return v16 +return v70 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) -v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7694), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(7698), lang.NewKeyword("end-column"), int(36)) -v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v12 -}) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// ex-data +// descendants { -v0 := lang.NewSymbol("ex-data").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ex"))), lang.NewKeyword("doc"), "Returns exception data (a map) if ex is an IExceptionInfo.\n Otherwise returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4812), lang.NewKeyword("end-line"), int(4812))).(*lang.Symbol) +v0 := lang.NewSymbol("descendants").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"))), lang.NewKeyword("doc"), "Returns the immediate and indirect children of tag, through a\n relationship established via derive. h must be a hierarchy obtained\n from make-hierarchy, if not supplied defaults to the global\n hierarchy. Note: does not work on Java type inheritance\n relationships.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5636), lang.NewKeyword("end-line"), int(5636))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + switch len(args) { + case 1: v3 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{nil, v3}) -if lang.IsTruthy(v8) { -v9, ok := lang.FieldOrMethod(v3, "getData") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getData"))) -} -var v10 any -switch reflect.TypeOf(v9).Kind() { -case reflect.Func: - v10 = lang.Apply(v9, nil) -default: - v10 = v9 -} -v4 = v10 -} else { -v4 = nil -} -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("descendants")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("global-hierarchy")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -// last -{ -v0 := lang.NewSymbol("last").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return the last item in coll, in linear time", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(262), lang.NewKeyword("end-line"), int(266))).(*lang.Symbol) -var v2 lang.FnFunc -{ // function last -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -recur_loop_32: +v9 := v8.Get() +v10 := lang.Apply(v6, []any{v9, v3}) +return v10 + case 2: +v3 := args[0] +v4 := args[1] var v5 any v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("next")) +v7 := v6.FindInternedVar(lang.NewSymbol("class?")) if v7.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } v8 := v7.Get() v9 := lang.Apply(v8, []any{v4}) if lang.IsTruthy(v9) { +v10 := lang.Apply(java.lang.UnsupportedOperationException18., []any{"Can't get descendants of classes"}) +panic(v10) +} else { v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("next")) +v12 := v11.FindInternedVar(lang.NewSymbol("not-empty")) if v12.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } v13 := v12.Get() -v14 := lang.Apply(v13, []any{v4}) -var v10 any = v14 -v4 = v10 -goto recur_loop_32 -} else { -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("first")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("get")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v4}) -v5 = v18 +v16 := v15.Get() +v17 := lang.Apply(lang.NewKeyword("descendants"), []any{v3}) +v18 := lang.Apply(v16, []any{v17, v4}) +v19 := lang.Apply(v13, []any{v18}) +v5 = v19 } return v5 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(266), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(269), lang.NewKeyword("end-column"), int(21))).(lang.FnFunc) -v3 := v2 -_ = v3 -} +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// newline +// descriptor { -v0 := lang.NewSymbol("newline").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Writes a platform-specific newline to *out*", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3698), lang.NewKeyword("end-line"), int(3698))).(*lang.Symbol) +v0 := lang.NewSymbol("descriptor").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5482), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(5482), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v4 := v3.FindInternedVar(lang.NewSymbol("*out*")) -if v4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) -} -v5 := v4.Get() -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("system-newline")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(lang1.AppendWriter, []any{v5, v8}) -_ = v9 -return nil +v3 := args[0] +v4 := lang.Apply(nil, []any{v3}) +return v4 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -26832,1508 +25153,1359 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// not= -{ -v1 := reflect.TypeOf(false) -v0 := lang.NewSymbol("not=").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Same as (not (= obj1 obj2))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(812), lang.NewKeyword("end-line"), int(812))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v4 := args[0] -return false - case 2: -v4 := args[0] -v5 := args[1] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("not")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("=")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v4, v5}) -v13 := lang.Apply(v8, []any{v12}) -return v13 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6 := lang.NewList(args[2:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("not")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("apply")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("=")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v12, []any{v15, v4, v5, v6}) -v17 := lang.Apply(v9, []any{v16}) -return v17 - } -}) -v4 := reflect.TypeOf(false) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// char +// destructure { -var v1 lang.FnFunc -{ // function char__inliner -v1 = lang.NewFnFunc(func(args ...any) any { +v0 := lang.NewSymbol("destructure").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4400), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(4400), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("partition")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v20 := v19.Get() +v7 := v6.Get() +v8 := lang.Apply(v7, []any{int64(2), v3}) +var v4 any = v8 +_ = v4 +var v10 lang.FnFunc +{ // function pb +v10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v12 := args[0] +v13 := args[1] +v14 := args[2] +var v16 lang.FnFunc +v16 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v17 := args[0] +v18 := args[1] +v19 := args[2] v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +v22 := v21.FindInternedVar(lang.NewSymbol("gensym")) if v22.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v24 := lang.Apply(v23, []any{"vec__"}) +var v20 any = v24 +_ = v20 +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("gensym")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) } -v29 := v28.Get() -var v30 any +v28 := v27.Get() +v29 := lang.Apply(v28, []any{"seq__"}) +var v25 any = v29 +_ = v25 v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +v32 := v31.FindInternedVar(lang.NewSymbol("gensym")) if v32.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } v33 := v32.Get() -if lang.IsTruthy(v33) { -v30 = lang.NewSymbol("uncheckedCharCast") -} else { -v30 = lang.NewSymbol("charCast") -} -v34 := lang.Apply(v29, []any{v30}) -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("list")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +v34 := lang.Apply(v33, []any{"first__"}) +var v30 any = v34 +_ = v30 +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("some")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) } -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v3}) -v39 := lang.Apply(v26, []any{v34, v38}) -v40 := lang.Apply(v23, []any{v39}) -v41 := lang.Apply(v20, []any{v40}) -v42 := lang.Apply(v9, []any{v13, v17, v41}) -v43 := lang.Apply(v6, []any{v42}) -return v43 -}) -v2 := v1 -_ = v2 +v38 := v37.Get() +v39 := lang.CreatePersistentTreeSet(lang.NewSymbol("&")) +v40 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4408), lang.NewKeyword("column"), int(43), lang.NewKeyword("end-line"), int(4408), lang.NewKeyword("end-column"), int(47)) +v41, err := lang.WithMeta(v39, v40.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v0 := lang.NewSymbol("char").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to char", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3511), lang.NewKeyword("end-line"), int(3511))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5, _ := lang.FieldOrMethod(runtime3.RT, "CharCast") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("CharCast is not a function"))) +v42 := lang.Apply(v38, []any{v41, v18}) +var v35 any = v42 +_ = v35 +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("conj")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) } -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +v48 := v47.Get() +v49 := lang.Apply(v48, []any{v17, v20, v19}) +var v45 any = v49 +_ = v45 +var v51 any +if lang.IsTruthy(v35) { +v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v53 := v52.FindInternedVar(lang.NewSymbol("conj")) +if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) } +v54 := v53.Get() +v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v56 := v55.FindInternedVar(lang.NewSymbol("list")) +if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) } -// read+string -{ -v0 := lang.NewSymbol("read+string").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("stream")), lang.NewVector(lang.NewSymbol("stream"), lang.NewSymbol("eof-error?"), lang.NewSymbol("eof-value")), lang.NewVector(lang.NewSymbol("stream"), lang.NewSymbol("eof-error?"), lang.NewSymbol("eof-value"), lang.NewSymbol("recursive?")), lang.NewVector(lang.NewSymbol("opts"), lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Like read, and taking the same args. stream must be a LineNumberingPushbackReader.\n Returns a vector containing the object read and the (whitespace-trimmed) string read.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3771), lang.NewKeyword("end-line"), int(3771))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v4 := v3.FindInternedVar(lang.NewSymbol("read+string")) -if v4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) +v57 := v56.Get() +v58 := lang.Apply(v57, []any{lang.NewSymbol("glojure.core/seq"), v20}) +v59 := lang.Apply(v54, []any{v45, v25, v58}) +v51 = v59 +} else { +v51 = v45 } -v5 := v4.Get() -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("*in*")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +var v44 any = v51 +_ = v44 +var v45 any = int64(0) +_ = v45 +var v46 any = v18 +_ = v46 +var v47 any = false +_ = v47 +var v48 any +for { +var v49 any +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("seq")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) } -v8 := v7.Get() -v9 := lang.Apply(v5, []any{v8}) -return v9 - case 1: -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("read+string")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v52 := v51.Get() +v53 := lang.Apply(v52, []any{v46}) +if lang.IsTruthy(v53) { +v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v56 := v55.FindInternedVar(lang.NewSymbol("first")) +if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) } -v6 := v5.Get() -v7 := lang.Apply(v6, []any{v3, true, nil}) -return v7 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("read+string")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +v57 := v56.Get() +v58 := lang.Apply(v57, []any{v46}) +var v54 any = v58 +_ = v54 +var v60 any +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("=")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) } -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v3, v4, v5, false}) -return v9 - case 4: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -var v7 any -func() { -defer func() { -if r := recover(); r != nil { -if lang.CatchMatches(r, lang1.Throwable) { -v8 := r -_ = v8 -v9, ok := lang.FieldOrMethod(v3, "getString") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getString"))) +v63 := v62.Get() +v64 := lang.Apply(v63, []any{v54, lang.NewSymbol("&")}) +if lang.IsTruthy(v64) { +v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v67 := v66.FindInternedVar(lang.NewSymbol("second")) +if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) } -var v10 any -switch reflect.TypeOf(v9).Kind() { -case reflect.Func: - v10 = lang.Apply(v9, nil) -default: - v10 = v9 +v68 := v67.Get() +v69 := lang.Apply(v68, []any{v46}) +v70 := lang.Apply(v11, []any{v44, v69, v25}) +var v65 any = v70 +var v71 any = v45 +v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v74 := v73.FindInternedVar(lang.NewSymbol("nnext")) +if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) } -_ = v10 -panic(v8) +v75 := v74.Get() +v76 := lang.Apply(v75, []any{v46}) +var v72 any = v76 +var v77 any = true +v44 = v65 +v45 = v71 +v46 = v72 +v47 = v77 +continue } else { -panic(r) -} +var v78 any +v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v80 := v79.FindInternedVar(lang.NewSymbol("=")) +if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) } -}() -v8, ok := lang.FieldOrMethod(v3, "captureString") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "captureString"))) +v81 := v80.Get() +v82 := lang.Apply(v81, []any{v54, lang.NewKeyword("as")}) +if lang.IsTruthy(v82) { +v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v84 := v83.FindInternedVar(lang.NewSymbol("second")) +if v84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) } -var v9 any -switch reflect.TypeOf(v8).Kind() { -case reflect.Func: - v9 = lang.Apply(v8, nil) -default: - v9 = v8 +v85 := v84.Get() +v86 := lang.Apply(v85, []any{v46}) +v87 := lang.Apply(v11, []any{v44, v86, v20}) +v78 = v87 +} else { +var v88 any +if lang.IsTruthy(lang.NewKeyword("else")) { +var v89 any +if lang.IsTruthy(v47) { +v90 := lang.Apply(errors11.New, []any{"Unsupported binding form, only :as can follow & parameter"}) +panic(v90) +} else { +var v92 any +if lang.IsTruthy(v35) { +v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v94 := v93.FindInternedVar(lang.NewSymbol("conj")) +if v94.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) } -_ = v9 -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("read")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v95 := v94.Get() +v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v97 := v96.FindInternedVar(lang.NewSymbol("seq")) +if v97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) } -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v3, v4, v5, v6}) -var v10 any = v14 -_ = v10 -v16, ok := lang.FieldOrMethod(v3, "getString") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getString"))) +v98 := v97.Get() +v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v100 := v99.FindInternedVar(lang.NewSymbol("concat")) +if v100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) } -var v17 any -switch reflect.TypeOf(v16).Kind() { -case reflect.Func: - v17 = lang.Apply(v16, nil) -default: - v17 = v16 +v101 := v100.Get() +v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v103 := v102.FindInternedVar(lang.NewSymbol("list")) +if v103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) } -v18, ok := lang.FieldOrMethod(v17, "trim") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v17, "trim"))) +v104 := v103.Get() +v105 := lang.Apply(v104, []any{lang.NewSymbol("glojure.core/first")}) +v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v107 := v106.FindInternedVar(lang.NewSymbol("list")) +if v107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) } -var v19 any -switch reflect.TypeOf(v18).Kind() { -case reflect.Func: - v19 = lang.Apply(v18, nil) -default: - v19 = v18 +v108 := v107.Get() +v109 := lang.Apply(v108, []any{v25}) +v110 := lang.Apply(v101, []any{v105, v109}) +v111 := lang.Apply(v98, []any{v110}) +v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v113 := v112.FindInternedVar(lang.NewSymbol("seq")) +if v113.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) } -var v15 any = v19 -_ = v15 -v21 := lang.NewVector(v10, v15) -v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3783), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(3783), lang.NewKeyword("end-column"), int(12)) -v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) -if err != nil { - panic(err) +v114 := v113.Get() +v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v116 := v115.FindInternedVar(lang.NewSymbol("concat")) +if v116.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) } -v7 = v23 -}() -return v7 - case 2: -v3 := args[0] -v4 := args[1] -var v5 any -func() { -defer func() { -if r := recover(); r != nil { -if lang.CatchMatches(r, lang1.Throwable) { -v6 := r -_ = v6 -v7, ok := lang.FieldOrMethod(v4, "getString") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "getString"))) +v117 := v116.Get() +v118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v119 := v118.FindInternedVar(lang.NewSymbol("list")) +if v119.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v119))) } -var v8 any -switch reflect.TypeOf(v7).Kind() { -case reflect.Func: - v8 = lang.Apply(v7, nil) -default: - v8 = v7 +v120 := v119.Get() +v121 := lang.Apply(v120, []any{lang.NewSymbol("glojure.core/next")}) +v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v123 := v122.FindInternedVar(lang.NewSymbol("list")) +if v123.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) } -_ = v8 -panic(v6) +v124 := v123.Get() +v125 := lang.Apply(v124, []any{v25}) +v126 := lang.Apply(v117, []any{v121, v125}) +v127 := lang.Apply(v114, []any{v126}) +v128 := lang.Apply(v95, []any{v44, v30, v111, v25, v127}) +v92 = v128 } else { -panic(r) +v92 = v44 } +var v129 any +if lang.IsTruthy(v35) { +v129 = v30 +} else { +v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v131 := v130.FindInternedVar(lang.NewSymbol("list")) +if v131.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) } -}() -v6, ok := lang.FieldOrMethod(v4, "captureString") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "captureString"))) +v132 := v131.Get() +v133 := lang.Apply(v132, []any{lang.NewSymbol("glojure.core/nth"), v20, v45, nil}) +v129 = v133 } -var v7 any -switch reflect.TypeOf(v6).Kind() { -case reflect.Func: - v7 = lang.Apply(v6, nil) -default: - v7 = v6 +v134 := lang.Apply(v11, []any{v92, v54, v129}) +var v91 any = v134 +v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v137 := v136.FindInternedVar(lang.NewSymbol("inc")) +if v137.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) } -_ = v7 -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("read")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +v138 := v137.Get() +v139 := lang.Apply(v138, []any{v45}) +var v135 any = v139 +v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v142 := v141.FindInternedVar(lang.NewSymbol("next")) +if v142.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) } -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v3, v4}) -var v8 any = v12 -_ = v8 -v14, ok := lang.FieldOrMethod(v4, "getString") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "getString"))) +v143 := v142.Get() +v144 := lang.Apply(v143, []any{v46}) +var v140 any = v144 +var v145 any = v47 +v44 = v91 +v45 = v135 +v46 = v140 +v47 = v145 +continue } -var v15 any -switch reflect.TypeOf(v14).Kind() { -case reflect.Func: - v15 = lang.Apply(v14, nil) -default: - v15 = v14 +v88 = v89 +} else { +v88 = nil } -v16, ok := lang.FieldOrMethod(v15, "trim") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v15, "trim"))) +v78 = v88 } -var v17 any -switch reflect.TypeOf(v16).Kind() { -case reflect.Func: - v17 = lang.Apply(v16, nil) -default: - v17 = v16 +v60 = v78 } -var v13 any = v17 -_ = v13 -v19 := lang.NewVector(v8, v13) -v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3792), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(3792), lang.NewKeyword("end-column"), int(12)) -v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) +v49 = v60 +} else { +v49 = v44 +} +v48 = v49 + break +} +return v48 +}) +v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4404), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(4438), lang.NewKeyword("end-column"), int(34)) +v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) if err != nil { panic(err) } -v5 = v21 -}() -return v5 - default: +var v15 any = v18 +_ = v15 +var v20 lang.FnFunc +v20 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v21 := args[0] +v22 := args[1] +v23 := args[2] +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("gensym")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.Apply(v27, []any{"map__"}) +var v24 any = v28 +_ = v24 +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("with-meta")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) } +v32 := v31.Get() +v33 := lang.NewMap(lang.NewKeyword("tag"), lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.ISeq")) +v34 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4442), lang.NewKeyword("column"), int(52), lang.NewKeyword("end-line"), int(4442), lang.NewKeyword("end-column"), int(103)) +v35, err := lang.WithMeta(v33, v34.(lang.IPersistentMap)) +if err != nil { + panic(err) } -// root-resource -{ -v1 := reflect.TypeOf("") -v0 := lang.NewSymbol("root-resource").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"))), lang.NewKeyword("doc"), "Returns the root directory path for a lib", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5907), lang.NewKeyword("end-line"), int(5907), lang.NewKeyword("private"), true)).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { +v36 := lang.Apply(v32, []any{v24, v35}) +var v29 any = v36 +_ = v29 +v38 := lang.Apply(lang.NewKeyword("or"), []any{v22}) +var v37 any = v38 +_ = v37 +var v41 lang.FnFunc +v41 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v4 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("str")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v42 := args[0] +var v43 any +v44 := lang.Apply(lang.NewKeyword("as"), []any{v22}) +if lang.IsTruthy(v44) { +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("conj")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) } -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("name")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v47 := v46.Get() +v48 := lang.Apply(lang.NewKeyword("as"), []any{v22}) +v49 := lang.Apply(v47, []any{v42, v48, v24}) +v43 = v49 +} else { +v43 = v42 } -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v4}) -v12 := lang.Apply(strings22.ReplaceAll, []any{v11, "-", "_"}) -v13 := lang.Apply(strings22.ReplaceAll, []any{v12, ".", "/"}) -v14 := lang.Apply(v7, []any{lang.NewChar(47), v13}) -return v14 +return v43 }) -v4 := reflect.TypeOf("") -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// vector -{ -v0 := lang.NewSymbol("vector").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("a")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d"), lang.NewSymbol("e")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d"), lang.NewSymbol("e"), lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d"), lang.NewSymbol("e"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Creates a new vector containing the args.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(352), lang.NewKeyword("end-line"), int(352))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v3 := lang.NewVector() -v4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(356), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(356), lang.NewKeyword("end-column"), int(8)) -v5, err := lang.WithMeta(v3, v4.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v5 - case 1: -v3 := args[0] -v4 := lang.NewVector(v3) -v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(357), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(357), lang.NewKeyword("end-column"), int(10)) -v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) +v42 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4450), lang.NewKeyword("column"), int(40), lang.NewKeyword("end-line"), int(4453), lang.NewKeyword("end-column"), int(48)) +v43, err := lang.WithMeta(v41, v42.(lang.IPersistentMap)) if err != nil { panic(err) } -return v6 - case 2: -v3 := args[0] -v4 := args[1] -v5 := lang.NewVector(v3, v4) -v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(358), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(358), lang.NewKeyword("end-column"), int(14)) -v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) -if err != nil { - panic(err) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("conj")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } -return v7 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewVector(v3, v4, v5) -v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(359), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(359), lang.NewKeyword("end-column"), int(18)) -v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) -if err != nil { - panic(err) +v46 := v45.Get() +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("conj")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) } -return v8 - case 4: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := lang.NewVector(v3, v4, v5, v6) -v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(360), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(360), lang.NewKeyword("end-column"), int(22)) -v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) -if err != nil { - panic(err) +v49 := v48.Get() +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("conj")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) } -return v9 - case 5: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := args[4] -v8 := lang.NewVector(v3, v4, v5, v6, v7) -v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(361), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(361), lang.NewKeyword("end-column"), int(25)) -v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) -if err != nil { - panic(err) +v52 := v51.Get() +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("conj")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) } -return v10 - case 6: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := args[4] -v8 := args[5] -v9 := lang.NewVector(v3, v4, v5, v6, v7, v8) -v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(362), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(362), lang.NewKeyword("end-column"), int(29)) -v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) -if err != nil { - panic(err) +v55 := v54.Get() +v56 := lang.Apply(v55, []any{v21, v24}) +v57 := lang.Apply(v52, []any{v56, v23}) +v58 := lang.Apply(v49, []any{v57, v24}) +v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v60 := v59.FindInternedVar(lang.NewSymbol("seq")) +if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) } -return v11 - default: - if len(args) < 6 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := args[4] -v8 := args[5] -v9 := lang.NewList(args[6:]...) -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("cons")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v61 := v60.Get() +v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v63 := v62.FindInternedVar(lang.NewSymbol("concat")) +if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) } -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("cons")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +v64 := v63.Get() +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("list")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) } -v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("cons")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +v67 := v66.Get() +v68 := lang.Apply(v67, []any{lang.NewSymbol("if")}) +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("list")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) } -v18 := v17.Get() -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("cons")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v71 := v70.Get() +v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v73 := v72.FindInternedVar(lang.NewSymbol("seq")) +if v73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) } -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("cons")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v74 := v73.Get() +v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v76 := v75.FindInternedVar(lang.NewSymbol("concat")) +if v76.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) } -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("cons")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +v77 := v76.Get() +v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v79 := v78.FindInternedVar(lang.NewSymbol("list")) +if v79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) } -v27 := v26.Get() -v28 := lang.Apply(v27, []any{v8, v9}) -v29 := lang.Apply(v24, []any{v7, v28}) -v30 := lang.Apply(v21, []any{v6, v29}) -v31 := lang.Apply(v18, []any{v5, v30}) -v32 := lang.Apply(v15, []any{v4, v31}) -v33 := lang.Apply(v12, []any{v3, v32}) -v34 := lang.Apply(lang1.CreateLazilyPersistentVector, []any{v33}) -return v34 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v80 := v79.Get() +v81 := lang.Apply(v80, []any{lang.NewSymbol("glojure.core/seq?")}) +v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v83 := v82.FindInternedVar(lang.NewSymbol("list")) +if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) } +v84 := v83.Get() +v85 := lang.Apply(v84, []any{v24}) +v86 := lang.Apply(v77, []any{v81, v85}) +v87 := lang.Apply(v74, []any{v86}) +v88 := lang.Apply(v71, []any{v87}) +v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v90 := v89.FindInternedVar(lang.NewSymbol("list")) +if v90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) } -// gen-class -{ -v0 := lang.NewSymbol("gen-class").WithMeta(lang.NewMap()).(*lang.Symbol) -v1 := ns.Intern(v0) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v91 := v90.Get() +v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v93 := v92.FindInternedVar(lang.NewSymbol("seq")) +if v93.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) } +v94 := v93.Get() +v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v96 := v95.FindInternedVar(lang.NewSymbol("concat")) +if v96.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) } -// lazy-cat -{ -v0 := lang.NewSymbol("lazy-cat").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Expands to code which yields a lazy sequence of the concatenation\n of the supplied colls. Each coll expr is not evaluated until it is\n needed. \n\n (lazy-cat xs ys zs) === (concat (lazy-seq xs) (lazy-seq ys) (lazy-seq zs))", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4636), lang.NewKeyword("end-line"), int(4636))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("seq")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +v97 := v96.Get() +v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v99 := v98.FindInternedVar(lang.NewSymbol("list")) +if v99.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) } -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("concat")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +v100 := v99.Get() +v101 := lang.Apply(v100, []any{lang.NewSymbol("if")}) +v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v103 := v102.FindInternedVar(lang.NewSymbol("list")) +if v103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) } -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("list")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +v104 := v103.Get() +v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v106 := v105.FindInternedVar(lang.NewSymbol("seq")) +if v106.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) } -v14 := v13.Get() -v15 := lang.Apply(v14, []any{lang.NewSymbol("glojure.core/concat")}) -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("map")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +v107 := v106.Get() +v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v109 := v108.FindInternedVar(lang.NewSymbol("concat")) +if v109.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) } -v18 := v17.Get() -var v19 lang.FnFunc -v19 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v20 := args[0] -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("list")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +v110 := v109.Get() +v111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v112 := v111.FindInternedVar(lang.NewSymbol("list")) +if v112.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v112))) } -v23 := v22.Get() -v24 := lang.Apply(v23, []any{lang.NewSymbol("glojure.core/lazy-seq"), v20}) -return v24 -}) -v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4644), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(4644), lang.NewKeyword("end-column"), int(37)) -v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) -if err != nil { - panic(err) +v113 := v112.Get() +v114 := lang.Apply(v113, []any{lang.NewSymbol("glojure.core/next")}) +v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v116 := v115.FindInternedVar(lang.NewSymbol("list")) +if v116.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) } -v22 := lang.Apply(v18, []any{v21, v5}) -v23 := lang.Apply(v11, []any{v15, v22}) -v24 := lang.Apply(v8, []any{v23}) -return v24 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v117 := v116.Get() +v118 := lang.Apply(v117, []any{v29}) +v119 := lang.Apply(v110, []any{v114, v118}) +v120 := lang.Apply(v107, []any{v119}) +v121 := lang.Apply(v104, []any{v120}) +v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v123 := v122.FindInternedVar(lang.NewSymbol("list")) +if v123.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) } +v124 := v123.Get() +v125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v126 := v125.FindInternedVar(lang.NewSymbol("seq")) +if v126.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v126))) } -// -> -{ -v0 := lang.NewSymbol("->").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "Threads the expr through the forms. Inserts x as the\n second item in the first form, making a list of it if it is not a\n list already. If there are more forms, inserts the first form as the\n second item in second form, etc.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1675), lang.NewKeyword("end-line"), int(1675))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -var v7 any = v7 -_ = v7 -var v8 any = v8 -_ = v8 -var v9 any -for { -var v10 any -if lang.IsTruthy(v8) { -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("first")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +v127 := v126.Get() +v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v129 := v128.FindInternedVar(lang.NewSymbol("concat")) +if v129.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v129))) } -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v8}) -var v11 any = v15 -_ = v11 -var v17 any -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("seq?")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v130 := v129.Get() +v131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v132 := v131.FindInternedVar(lang.NewSymbol("list")) +if v132.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v132))) } -v20 := v19.Get() -v21 := lang.Apply(v20, []any{v11}) -if lang.IsTruthy(v21) { -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("with-meta")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v133 := v132.Get() +v134 := lang.Apply(v133, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewPersistentArrayMapAsIfByAssoc")}) +v135 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v136 := v135.FindInternedVar(lang.NewSymbol("list")) +if v136.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v136))) } -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("seq")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +v137 := v136.Get() +v138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v139 := v138.FindInternedVar(lang.NewSymbol("seq")) +if v139.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v139))) } -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("concat")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +v140 := v139.Get() +v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v142 := v141.FindInternedVar(lang.NewSymbol("concat")) +if v142.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) } -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v143 := v142.Get() +v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v145 := v144.FindInternedVar(lang.NewSymbol("list")) +if v145.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) } -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("first")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +v146 := v145.Get() +v147 := lang.Apply(v146, []any{lang.NewSymbol("glojure.core/to-array")}) +v148 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v149 := v148.FindInternedVar(lang.NewSymbol("list")) +if v149.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v149))) } -v36 := v35.Get() -v37 := lang.Apply(v36, []any{v11}) -v38 := lang.Apply(v33, []any{v37}) -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("list")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +v150 := v149.Get() +v151 := lang.Apply(v150, []any{v29}) +v152 := lang.Apply(v143, []any{v147, v151}) +v153 := lang.Apply(v140, []any{v152}) +v154 := lang.Apply(v137, []any{v153}) +v155 := lang.Apply(v130, []any{v134, v154}) +v156 := lang.Apply(v127, []any{v155}) +v157 := lang.Apply(v124, []any{v156}) +v158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v159 := v158.FindInternedVar(lang.NewSymbol("list")) +if v159.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v159))) } -v41 := v40.Get() -v42 := lang.Apply(v41, []any{v7}) -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("next")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +v160 := v159.Get() +v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v162 := v161.FindInternedVar(lang.NewSymbol("seq")) +if v162.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) } -v45 := v44.Get() -v46 := lang.Apply(v45, []any{v11}) -v47 := lang.Apply(v30, []any{v38, v42, v46}) -v48 := lang.Apply(v27, []any{v47}) -v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v50 := v49.FindInternedVar(lang.NewSymbol("meta")) -if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) +v163 := v162.Get() +v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v165 := v164.FindInternedVar(lang.NewSymbol("concat")) +if v165.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) } -v51 := v50.Get() -v52 := lang.Apply(v51, []any{v11}) -v53 := lang.Apply(v24, []any{v48, v52}) -v17 = v53 -} else { -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("list")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +v166 := v165.Get() +v167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v168 := v167.FindInternedVar(lang.NewSymbol("list")) +if v168.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v168))) } -v56 := v55.Get() -v57 := lang.Apply(v56, []any{v11, v7}) -v17 = v57 +v169 := v168.Get() +v170 := lang.Apply(v169, []any{lang.NewSymbol("if")}) +v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v172 := v171.FindInternedVar(lang.NewSymbol("list")) +if v172.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) } -var v16 any = v17 -_ = v16 -var v59 any = v16 -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("next")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +v173 := v172.Get() +v174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v175 := v174.FindInternedVar(lang.NewSymbol("seq")) +if v175.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v175))) } -v63 := v62.Get() -v64 := lang.Apply(v63, []any{v8}) -var v60 any = v64 -v7 = v59 -v8 = v60 -continue -} else { -v10 = v7 +v176 := v175.Get() +v177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v178 := v177.FindInternedVar(lang.NewSymbol("concat")) +if v178.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v178))) } -v9 = v10 - break +v179 := v178.Get() +v180 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v181 := v180.FindInternedVar(lang.NewSymbol("list")) +if v181.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v181))) } -return v9 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v182 := v181.Get() +v183 := lang.Apply(v182, []any{lang.NewSymbol("glojure.core/seq")}) +v184 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v185 := v184.FindInternedVar(lang.NewSymbol("list")) +if v185.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v185))) } +v186 := v185.Get() +v187 := lang.Apply(v186, []any{v29}) +v188 := lang.Apply(v179, []any{v183, v187}) +v189 := lang.Apply(v176, []any{v188}) +v190 := lang.Apply(v173, []any{v189}) +v191 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v192 := v191.FindInternedVar(lang.NewSymbol("list")) +if v192.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v192))) } -// Throwable->map -{ -v0 := lang.NewSymbol("Throwable->map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"))), lang.NewKeyword("doc"), "Constructs a data representation for a Throwable with keys:\n :cause - root cause message\n :phase - error phase\n :via - cause chain, with cause keys:\n :type - exception class symbol\n :message - exception message\n :data - ex-data\n :at - top stack element\n :trace - root cause stack elements", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(442), lang.NewKeyword("end-line"), int(442))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -var v5 lang.FnFunc -v5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v6 := args[0] -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("merge")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v193 := v192.Get() +v194 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v195 := v194.FindInternedVar(lang.NewSymbol("seq")) +if v195.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v195))) } -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("symbol")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v196 := v195.Get() +v197 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v198 := v197.FindInternedVar(lang.NewSymbol("concat")) +if v198.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v198))) } -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("class")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +v199 := v198.Get() +v200 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v201 := v200.FindInternedVar(lang.NewSymbol("list")) +if v201.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v201))) } -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v6}) -v17, ok := lang.FieldOrMethod(v16, "Name") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v16, "Name"))) +v202 := v201.Get() +v203 := lang.Apply(v202, []any{lang.NewSymbol("glojure.core/first")}) +v204 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v205 := v204.FindInternedVar(lang.NewSymbol("list")) +if v205.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v205))) } -var v18 any -switch reflect.TypeOf(v17).Kind() { -case reflect.Func: - v18 = lang.Apply(v17, nil) -default: - v18 = v17 +v206 := v205.Get() +v207 := lang.Apply(v206, []any{v29}) +v208 := lang.Apply(v199, []any{v203, v207}) +v209 := lang.Apply(v196, []any{v208}) +v210 := lang.Apply(v193, []any{v209}) +v211 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v212 := v211.FindInternedVar(lang.NewSymbol("list")) +if v212.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v212))) } -v19 := lang.Apply(v12, []any{v18}) -v20 := lang.NewMap(lang.NewKeyword("type"), v19) -v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(455), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(455), lang.NewKeyword("end-column"), int(56)) -v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) -if err != nil { - panic(err) +v213 := v212.Get() +v214 := lang.Apply(v213, []any{lang.NewSymbol("glojure.lang.PersistentArrayMap/EMPTY")}) +v215 := lang.Apply(v166, []any{v170, v190, v210, v214}) +v216 := lang.Apply(v163, []any{v215}) +v217 := lang.Apply(v160, []any{v216}) +v218 := lang.Apply(v97, []any{v101, v121, v157, v217}) +v219 := lang.Apply(v94, []any{v218}) +v220 := lang.Apply(v91, []any{v219}) +v221 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v222 := v221.FindInternedVar(lang.NewSymbol("list")) +if v222.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v222))) } -v24, ok := lang.FieldOrMethod(v6, "getLocalizedMessage") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "getLocalizedMessage"))) +v223 := v222.Get() +v224 := lang.Apply(v223, []any{v24}) +v225 := lang.Apply(v64, []any{v68, v88, v220, v224}) +v226 := lang.Apply(v61, []any{v225}) +v227 := lang.Apply(v46, []any{v58, v226}) +v228 := lang.Apply(v43, []any{v227}) +var v40 any = v228 +_ = v40 +v231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v232 := v231.FindInternedVar(lang.NewSymbol("reduce1")) +if v232.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v232))) } -var v25 any -switch reflect.TypeOf(v24).Kind() { -case reflect.Func: - v25 = lang.Apply(v24, nil) -default: - v25 = v24 +v233 := v232.Get() +var v234 lang.FnFunc +v234 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v235 := args[0] +v236 := args[1] +var v237 any +v238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v239 := v238.FindInternedVar(lang.NewSymbol("keyword?")) +if v239.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v239))) } -var v23 any = v25 -_ = v23 -var v27 any -if lang.IsTruthy(v23) { -var v28 any = v23 -_ = v28 -v30 := lang.NewMap(lang.NewKeyword("message"), v28) -v31 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(457), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(457), lang.NewKeyword("end-column"), int(33)) -v32, err := lang.WithMeta(v30, v31.(lang.IPersistentMap)) -if err != nil { - panic(err) +v240 := v239.Get() +v241 := lang.Apply(v240, []any{v236}) +if lang.IsTruthy(v241) { +v243 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v244 := v243.FindInternedVar(lang.NewSymbol("namespace")) +if v244.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v244))) } -v27 = v32 -} else { -v27 = nil +v245 := v244.Get() +v246 := lang.Apply(v245, []any{v236}) +var v242 any = v246 +_ = v242 +v248 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v249 := v248.FindInternedVar(lang.NewSymbol("name")) +if v249.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v249))) } -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("ex-data")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +v250 := v249.Get() +v251 := lang.Apply(v250, []any{v236}) +var v247 any = v251 +_ = v247 +var v253 any +v254 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v255 := v254.FindInternedVar(lang.NewSymbol("=")) +if v255.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v255))) } -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v6}) -var v23 any = v27 -_ = v23 -var v29 any -if lang.IsTruthy(v23) { -var v30 any = v23 -_ = v30 -v32 := lang.NewMap(lang.NewKeyword("data"), v30) -v33 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(459), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(459), lang.NewKeyword("end-column"), int(29)) -v34, err := lang.WithMeta(v32, v33.(lang.IPersistentMap)) -if err != nil { - panic(err) +v256 := v255.Get() +v257 := lang.Apply(v256, []any{v247, "keys"}) +if lang.IsTruthy(v257) { +v258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v259 := v258.FindInternedVar(lang.NewSymbol("assoc")) +if v259.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v259))) } -v29 = v34 -} else { -v29 = nil -} -v24, ok := lang.FieldOrMethod(v6, "getStackTrace") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "getStackTrace"))) -} -var v25 any -switch reflect.TypeOf(v24).Kind() { -case reflect.Func: - v25 = lang.Apply(v24, nil) -default: - v25 = v24 -} -var v23 any = v25 -_ = v23 -var v27 any -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("pos?")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("alength")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v23}) -v35 := lang.Apply(v30, []any{v34}) -if lang.IsTruthy(v35) { -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("StackTraceElement->vec")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +v260 := v259.Get() +var v261 lang.FnFunc +v261 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v262 := args[0] +v263 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v264 := v263.FindInternedVar(lang.NewSymbol("keyword")) +if v264.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v264))) } -v38 := v37.Get() -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("aget")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +v265 := v264.Get() +var v266 any = v242 +_ = v266 +var v268 any +if lang.IsTruthy(v266) { +v268 = v266 +} else { +v269 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v270 := v269.FindInternedVar(lang.NewSymbol("namespace")) +if v270.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v270))) } -v41 := v40.Get() -v42 := lang.Apply(v41, []any{v23, int64(0)}) -v43 := lang.Apply(v38, []any{v42}) -v44 := lang.NewMap(lang.NewKeyword("at"), v43) -v45 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(462), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(462), lang.NewKeyword("end-column"), int(63)) -v46, err := lang.WithMeta(v44, v45.(lang.IPersistentMap)) -if err != nil { - panic(err) +v271 := v270.Get() +v272 := lang.Apply(v271, []any{v262}) +v268 = v272 } -v27 = v46 -} else { -v27 = nil +v266 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v267 := v266.FindInternedVar(lang.NewSymbol("name")) +if v267.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v267))) } -v23 := lang.Apply(v9, []any{v22, v27, v29, v27}) -return v23 +v268 := v267.Get() +v269 := lang.Apply(v268, []any{v262}) +v270 := lang.Apply(v265, []any{v268, v269}) +return v270 }) -v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(454), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(462), lang.NewKeyword("end-column"), int(67)) -v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v4 any = v7 -_ = v4 -v10 := lang.NewVector() -v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(463), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(463), lang.NewKeyword("end-column"), int(25)) -v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) +v262 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4460), lang.NewKeyword("column"), int(93), lang.NewKeyword("end-line"), int(4460), lang.NewKeyword("end-column"), int(135)) +v263, err := lang.WithMeta(v261, v262.(lang.IPersistentMap)) if err != nil { panic(err) } -var v9 any = v12 -_ = v9 -var v13 any = v3 -_ = v13 -var v14 any -for { -var v15 any -if lang.IsTruthy(v13) { -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("conj")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v9, v13}) -var v16 any = v20 -v22, ok := lang.FieldOrMethod(v13, "getCause") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v13, "getCause"))) -} -var v23 any -switch reflect.TypeOf(v22).Kind() { -case reflect.Func: - v23 = lang.Apply(v22, nil) -default: - v23 = v22 -} -var v21 any = v23 -v9 = v16 -v13 = v21 -continue +v264 := lang.Apply(v260, []any{v235, v236, v263}) +v253 = v264 } else { -v15 = v9 -} -v14 = v15 - break -} -var v8 any = v14 -_ = v8 -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("peek")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{v8}) -var v9 any = v13 -_ = v9 -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("merge")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("vec")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("map")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +var v265 any +v266 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v267 := v266.FindInternedVar(lang.NewSymbol("=")) +if v267.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v267))) } -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v4, v8}) -v25 := lang.Apply(v20, []any{v24}) -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("vec")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +v268 := v267.Get() +v269 := lang.Apply(v268, []any{v247, "syms"}) +if lang.IsTruthy(v269) { +v270 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v271 := v270.FindInternedVar(lang.NewSymbol("assoc")) +if v271.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v271))) } -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("map")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +v272 := v271.Get() +var v273 lang.FnFunc +v273 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v274 := args[0] +v275 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v276 := v275.FindInternedVar(lang.NewSymbol("list")) +if v276.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v276))) } -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("StackTraceElement->vec")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +v277 := v276.Get() +v278 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v279 := v278.FindInternedVar(lang.NewSymbol("symbol")) +if v279.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v279))) } -v34 := v33.Get() -var v35 any = v9 -_ = v35 -var v37 any -if lang.IsTruthy(v35) { -v37 = v35 +v280 := v279.Get() +var v281 any = v242 +_ = v281 +var v283 any +if lang.IsTruthy(v281) { +v283 = v281 } else { -v37 = v3 +v284 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v285 := v284.FindInternedVar(lang.NewSymbol("namespace")) +if v285.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v285))) } -v35, ok := lang.FieldOrMethod(v37, "getStackTrace") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v37, "getStackTrace"))) +v286 := v285.Get() +v287 := lang.Apply(v286, []any{v274}) +v283 = v287 } -var v36 any -switch reflect.TypeOf(v35).Kind() { -case reflect.Func: - v36 = lang.Apply(v35, nil) -default: - v36 = v35 +v281 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v282 := v281.FindInternedVar(lang.NewSymbol("name")) +if v282.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v282))) } -v37 := lang.Apply(v31, []any{v34, v36}) -v38 := lang.Apply(v28, []any{v37}) -v39 := lang.NewMap(lang.NewKeyword("via"), v25, lang.NewKeyword("trace"), v38) -v40 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(468), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(470), lang.NewKeyword("end-column"), int(111)) -v41, err := lang.WithMeta(v39, v40.(lang.IPersistentMap)) +v283 := v282.Get() +v284 := lang.Apply(v283, []any{v274}) +v285 := lang.Apply(v280, []any{v283, v284}) +v286 := lang.Apply(v277, []any{lang.NewSymbol("quote"), v285}) +return v286 +}) +v274 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4461), lang.NewKeyword("column"), int(93), lang.NewKeyword("end-line"), int(4461), lang.NewKeyword("end-column"), int(148)) +v275, err := lang.WithMeta(v273, v274.(lang.IPersistentMap)) if err != nil { panic(err) } -v43, ok := lang.FieldOrMethod(v9, "getLocalizedMessage") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v9, "getLocalizedMessage"))) +v276 := lang.Apply(v272, []any{v235, v236, v275}) +v265 = v276 +} else { +var v277 any +v278 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v279 := v278.FindInternedVar(lang.NewSymbol("=")) +if v279.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v279))) } -var v44 any -switch reflect.TypeOf(v43).Kind() { -case reflect.Func: - v44 = lang.Apply(v43, nil) -default: - v44 = v43 +v280 := v279.Get() +v281 := lang.Apply(v280, []any{v247, "strs"}) +if lang.IsTruthy(v281) { +v282 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v283 := v282.FindInternedVar(lang.NewSymbol("assoc")) +if v283.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v283))) } -var v42 any = v44 -_ = v42 -var v46 any -if lang.IsTruthy(v42) { -var v47 any = v42 -_ = v47 -v49 := lang.NewMap(lang.NewKeyword("cause"), v47) -v50 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(472), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(472), lang.NewKeyword("end-column"), int(25)) -v51, err := lang.WithMeta(v49, v50.(lang.IPersistentMap)) -if err != nil { - panic(err) +v284 := v283.Get() +v285 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v286 := v285.FindInternedVar(lang.NewSymbol("str")) +if v286.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v286))) } -v46 = v51 +v287 := v286.Get() +v288 := lang.Apply(v284, []any{v235, v236, v287}) +v277 = v288 } else { -v46 = nil +var v289 any +if lang.IsTruthy(lang.NewKeyword("else")) { +v289 = v235 +} else { +v289 = nil } -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("ex-data")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +v277 = v289 } -v45 := v44.Get() -v46 := lang.Apply(v45, []any{v9}) -var v42 any = v46 -_ = v42 -var v48 any -if lang.IsTruthy(v42) { -var v49 any = v42 -_ = v49 -v51 := lang.NewMap(lang.NewKeyword("data"), v49) -v52 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(474), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(474), lang.NewKeyword("end-column"), int(20)) -v53, err := lang.WithMeta(v51, v52.(lang.IPersistentMap)) -if err != nil { - panic(err) +v265 = v277 } -v48 = v53 +v253 = v265 +} +v237 = v253 } else { -v48 = nil +v237 = v235 } -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("ex-data")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +return v237 +}) +v235 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4456), lang.NewKeyword("column"), int(45), lang.NewKeyword("end-line"), int(4464), lang.NewKeyword("end-column"), int(60)) +v236, err := lang.WithMeta(v234, v235.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v45 := v44.Get() -v46 := lang.Apply(v45, []any{v3}) -v47 := lang.Apply(lang.NewKeyword("glojure.error/phase"), []any{v46}) -var v42 any = v47 -_ = v42 -var v49 any -if lang.IsTruthy(v42) { -var v50 any = v42 -_ = v50 -v52 := lang.NewMap(lang.NewKeyword("phase"), v50) -v53 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(476), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(476), lang.NewKeyword("end-column"), int(22)) -v54, err := lang.WithMeta(v52, v53.(lang.IPersistentMap)) +v237 := lang.NewMap() +v238 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4465), lang.NewKeyword("column"), int(45), lang.NewKeyword("end-line"), int(4465), lang.NewKeyword("end-column"), int(46)) +v239, err := lang.WithMeta(v237, v238.(lang.IPersistentMap)) if err != nil { panic(err) } -v49 = v54 -} else { -v49 = nil +v240 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v241 := v240.FindInternedVar(lang.NewSymbol("keys")) +if v241.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v241))) } -v42 := lang.Apply(v17, []any{v41, v46, v48, v49}) -return v42 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v242 := v241.Get() +v243 := lang.Apply(v242, []any{v22}) +v244 := lang.Apply(v233, []any{v236, v239, v243}) +var v230 any = v244 +_ = v230 +v246 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v247 := v246.FindInternedVar(lang.NewSymbol("reduce1")) +if v247.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v247))) } +v248 := v247.Get() +var v249 lang.FnFunc +v249 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v250 := args[0] +v251 := args[1] +v252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v253 := v252.FindInternedVar(lang.NewSymbol("reduce1")) +if v253.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v253))) } -// unsigned-bit-shift-right -{ -var v1 lang.FnFunc -{ // function unsigned-bit-shift-right__inliner -v1 = lang.NewFnFunc(func(args ...any) any { +v254 := v253.Get() +var v255 lang.FnFunc +v255 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v256 := args[0] +v257 := args[1] +v258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v259 := v258.FindInternedVar(lang.NewSymbol("assoc")) +if v259.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v259))) } -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("concat")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v260 := v259.Get() +v261 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v262 := v261.FindInternedVar(lang.NewSymbol("val")) +if v262.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v262))) } -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("list")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v263 := v262.Get() +v264 := lang.Apply(v263, []any{v251}) +v265 := lang.Apply(v264, []any{v257}) +v266 := lang.Apply(v260, []any{v256, v257, v265}) +return v266 +}) +v256 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4469), lang.NewKeyword("column"), int(52), lang.NewKeyword("end-line"), int(4469), lang.NewKeyword("end-column"), int(82)) +v257, err := lang.WithMeta(v255, v256.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v13 := v12.Get() -v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +v258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v259 := v258.FindInternedVar(lang.NewSymbol("dissoc")) +if v259.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v259))) } -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v260 := v259.Get() +v261 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v262 := v261.FindInternedVar(lang.NewSymbol("key")) +if v262.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v262))) } -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("seq")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v263 := v262.Get() +v264 := lang.Apply(v263, []any{v251}) +v265 := lang.Apply(v260, []any{v250, v264}) +v266 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v267 := v266.FindInternedVar(lang.NewSymbol("key")) +if v267.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v267))) } -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("concat")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +v268 := v267.Get() +v269 := lang.Apply(v268, []any{v251}) +v270 := lang.Apply(v269, []any{v250}) +v271 := lang.Apply(v254, []any{v257, v265, v270}) +return v271 +}) +v250 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4468), lang.NewKeyword("column"), int(41), lang.NewKeyword("end-line"), int(4471), lang.NewKeyword("end-column"), int(70)) +v251, err := lang.WithMeta(v249, v250.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("list")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +v252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v253 := v252.FindInternedVar(lang.NewSymbol("dissoc")) +if v253.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v253))) } -v30 := v29.Get() -v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/unsignedShiftRight")}) -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +v254 := v253.Get() +v255 := lang.Apply(v254, []any{v22, lang.NewKeyword("as"), lang.NewKeyword("or")}) +v256 := lang.Apply(v248, []any{v251, v255, v230}) +var v229 any = v256 +_ = v229 +var v230 any +for { +var v231 any +v232 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v233 := v232.FindInternedVar(lang.NewSymbol("seq")) +if v233.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v233))) } -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +v234 := v233.Get() +v235 := lang.Apply(v234, []any{v229}) +if lang.IsTruthy(v235) { +v237 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v238 := v237.FindInternedVar(lang.NewSymbol("key")) +if v238.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v238))) } -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v4}) -v40 := lang.Apply(v27, []any{v31, v35, v39}) -v41 := lang.Apply(v24, []any{v40}) -v42 := lang.Apply(v21, []any{v41}) -v43 := lang.Apply(v10, []any{v14, v18, v42}) -v44 := lang.Apply(v7, []any{v43}) -return v44 -}) -v2 := v1 -_ = v2 +v239 := v238.Get() +v240 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v241 := v240.FindInternedVar(lang.NewSymbol("first")) +if v241.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v241))) } -v0 := lang.NewSymbol("unsigned-bit-shift-right").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Bitwise shift right, without sign-extension.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(30), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1373), lang.NewKeyword("end-line"), int(1373))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6, _ := lang.FieldOrMethod(lang1.Numbers, "unsignedShiftRight") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("unsignedShiftRight is not a function"))) +v242 := v241.Get() +v243 := lang.Apply(v242, []any{v229}) +v244 := lang.Apply(v239, []any{v243}) +var v236 any = v244 +_ = v236 +v246 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v247 := v246.FindInternedVar(lang.NewSymbol("val")) +if v247.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v247))) } -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +v248 := v247.Get() +v249 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v250 := v249.FindInternedVar(lang.NewSymbol("first")) +if v250.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v250))) } +v251 := v250.Get() +v252 := lang.Apply(v251, []any{v229}) +v253 := lang.Apply(v248, []any{v252}) +var v245 any = v253 +_ = v245 +var v255 any +v256 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v257 := v256.FindInternedVar(lang.NewSymbol("instance?")) +if v257.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v257))) } -// extend-type -{ -v0 := lang.NewSymbol("extend-type").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("t"), lang.NewSymbol("&"), lang.NewSymbol("specs"))), lang.NewKeyword("doc"), "A macro that expands into an extend call. Useful when you are\n supplying the definitions explicitly inline, extend-type\n automatically creates the maps required by extend. Propagates the\n class as a type hint on the first argument of all fns.\n\n (extend-type MyType \n Countable\n (cnt [c] ...)\n Foo\n (bar [x y] ...)\n (baz ([x] ...) ([x y & zs] ...)))\n\n expands into:\n\n (extend MyType\n Countable\n {:cnt (fn [c] ...)}\n Foo\n {:baz (fn ([x] ...) ([x y & zs] ...))\n :bar (fn [x y] ...)})", lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(180), lang.NewKeyword("end-line"), int(180))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("emit-extend-type")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v258 := v257.Get() +v259 := lang.Apply(v258, []any{lang1.Named, v236}) +if lang.IsTruthy(v259) { +v260 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v261 := v260.FindInternedVar(lang.NewSymbol("with-meta")) +if v261.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v261))) } -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v5, v6}) -return v10 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v262 := v261.Get() +v263 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v264 := v263.FindInternedVar(lang.NewSymbol("symbol")) +if v264.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v264))) } +v265 := v264.Get() +v266 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v267 := v266.FindInternedVar(lang.NewSymbol("name")) +if v267.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v267))) } -// take -{ -v0 := lang.NewSymbol("take").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the first n items in coll, or all items if\n there are fewer than n. Returns a stateful transducer when\n no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2853), lang.NewKeyword("end-line"), int(2853))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := args[0] -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("volatile!")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v268 := v267.Get() +v269 := lang.Apply(v268, []any{v236}) +v270 := lang.Apply(v265, []any{nil, v269}) +v271 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v272 := v271.FindInternedVar(lang.NewSymbol("meta")) +if v272.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v272))) } -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v3}) -var v6 any = v10 -_ = v6 -var v12 lang.FnFunc -v12 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v13 := lang.Apply(v5, nil) -return v13 - case 1: -v13 := args[0] -v14 := lang.Apply(v5, []any{v13}) -return v14 - case 2: -v13 := args[0] -v14 := args[1] -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("deref")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +v273 := v272.Get() +v274 := lang.Apply(v273, []any{v236}) +v275 := lang.Apply(v262, []any{v270, v274}) +v255 = v275 +} else { +v255 = v236 } -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v6}) -var v15 any = v19 -_ = v15 -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("dec")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +var v254 any = v255 +_ = v254 +var v277 any +v278 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v279 := v278.FindInternedVar(lang.NewSymbol("contains?")) +if v279.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v279))) } -v23 := v22.Get() -v24, ok := lang.FieldOrMethod(v6, "Deref") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "Deref"))) +v280 := v279.Get() +v281 := lang.Apply(v280, []any{v37, v254}) +if lang.IsTruthy(v281) { +v282 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v283 := v282.FindInternedVar(lang.NewSymbol("list")) +if v283.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v283))) } -var v25 any -switch reflect.TypeOf(v24).Kind() { -case reflect.Func: - v25 = lang.Apply(v24, nil) -default: - v25 = v24 +v284 := v283.Get() +v285 := lang.Apply(v37, []any{v254}) +v286 := lang.Apply(v284, []any{lang.NewSymbol("glojure.core/get"), v24, v245, v285}) +v277 = v286 +} else { +v287 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v288 := v287.FindInternedVar(lang.NewSymbol("list")) +if v288.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v288))) } -v26 := lang.Apply(v23, []any{v25}) -v27, _ := lang.FieldOrMethod(v6, "reset") -if reflect.TypeOf(v27).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) +v289 := v288.Get() +v290 := lang.Apply(v289, []any{lang.NewSymbol("glojure.core/get"), v24, v245}) +v277 = v290 } -v28 := lang.Apply(v27, []any{v26}) -var v20 any = v28 -_ = v20 -var v30 any -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("pos?")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +var v276 any = v277 +_ = v276 +var v293 any +v294 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v295 := v294.FindInternedVar(lang.NewSymbol("ident?")) +if v295.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v295))) } -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v15}) -if lang.IsTruthy(v34) { -v35 := lang.Apply(v5, []any{v29, v14}) -v30 = v35 +v296 := v295.Get() +v297 := lang.Apply(v296, []any{v236}) +if lang.IsTruthy(v297) { +v298 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v299 := v298.FindInternedVar(lang.NewSymbol("conj")) +if v299.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v299))) +} +v300 := v299.Get() +v301 := lang.Apply(v300, []any{v40, v254, v276}) +v293 = v301 } else { -v30 = v29 +v302 := lang.Apply(v11, []any{v40, v236, v276}) +v293 = v302 } -var v29 any = v30 -_ = v29 +var v292 any = v293 +v304 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v305 := v304.FindInternedVar(lang.NewSymbol("next")) +if v305.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v305))) +} +v306 := v305.Get() +v307 := lang.Apply(v306, []any{v229}) +var v303 any = v307 +v40 = v292 +v229 = v303 +continue +} else { +v231 = v40 +} +v230 = v231 + break +} +return v230 +}) +v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4440), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(4485), lang.NewKeyword("end-column"), int(34)) +v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v19 any = v22 +_ = v19 +var v24 any +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("symbol?")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.Apply(v27, []any{v13}) +if lang.IsTruthy(v28) { +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("conj")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("conj")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v12, v13}) +v36 := lang.Apply(v31, []any{v35, v14}) +v24 = v36 +} else { var v37 any v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("not")) +v39 := v38.FindInternedVar(lang.NewSymbol("vector?")) if v39.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) } v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("pos?")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +v41 := lang.Apply(v40, []any{v13}) +if lang.IsTruthy(v41) { +v42 := lang.Apply(v15, []any{v12, v13, v14}) +v37 = v42 +} else { +var v43 any +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("map?")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v20}) -v45 := lang.Apply(v40, []any{v44}) -if lang.IsTruthy(v45) { -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("ensure-reduced")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v13}) +if lang.IsTruthy(v47) { +v48 := lang.Apply(v19, []any{v12, v13, v14}) +v43 = v48 +} else { +var v49 any +if lang.IsTruthy(lang.NewKeyword("else")) { +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("str")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) } -v48 := v47.Get() -v49 := lang.Apply(v48, []any{v29}) -v37 = v49 +v52 := v51.Get() +v53 := lang.Apply(v52, []any{"Unsupported binding form: ", v13}) +v54 := lang.Apply(errors11.New, []any{v53}) +panic(v54) } else { -v37 = v29 +v49 = nil } -return v37 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2862), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(2873), lang.NewKeyword("end-column"), int(28)) -v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) -if err != nil { - panic(err) +v43 = v49 } -return v14 +v37 = v43 +} +v24 = v37 +} +return v24 }) -v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2860), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2873), lang.NewKeyword("end-column"), int(30)) -v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) +v11 := v10 +_ = v11 +} +v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4402), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(4490), lang.NewKeyword("end-column"), int(82)) +v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) if err != nil { panic(err) } -return v6 - case 2: -v3 := args[0] -v4 := args[1] -var v5 lang.FnFunc -v5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { +var v9 any = v12 +_ = v9 +var v14 lang.FnFunc +v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -var v6 any -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("pos?")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v15 := args[0] +v16 := args[1] +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("first")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v3}) -if lang.IsTruthy(v10) { -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("seq")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v16}) +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("second")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v4}) -var v11 any = v15 -_ = v11 -var v17 any -if lang.IsTruthy(v11) { -var v18 any = v11 -_ = v18 -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("cons")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v16}) +v25 := lang.Apply(v9, []any{v15, v20, v24}) +return v25 +}) +v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4491), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(4491), lang.NewKeyword("end-column"), int(66)) +v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("first")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +var v13 any = v16 +_ = v13 +var v18 any +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("every?")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v25 := v24.Get() -v26 := lang.Apply(v25, []any{v18}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("take")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("symbol?")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -v29 := v28.Get() -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("dec")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("map")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -v32 := v31.Get() -v33 := lang.Apply(v32, []any{v3}) -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("rest")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("first")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } -v36 := v35.Get() -v37 := lang.Apply(v36, []any{v18}) -v38 := lang.Apply(v29, []any{v33, v37}) -v39 := lang.Apply(v22, []any{v26, v38}) -v17 = v39 +v30 := v29.Get() +v31 := lang.Apply(v27, []any{v30, v4}) +v32 := lang.Apply(v21, []any{v24, v31}) +if lang.IsTruthy(v32) { +v18 = v3 } else { -v17 = nil +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("reduce1")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) } -v6 = v17 -} else { -v6 = nil +v35 := v34.Get() +v36 := lang.NewVector() +v37 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4494), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(4494), lang.NewKeyword("end-column"), int(31)) +v38, err := lang.WithMeta(v36, v37.(lang.IPersistentMap)) +if err != nil { + panic(err) } -return v6 -}) -v6 := lang.Apply(lang1.NewLazySeq, []any{v5}) -return v6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } +v39 := lang.Apply(v35, []any{v13, v38, v4}) +v18 = v39 +} +return v18 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -28341,75 +26513,80 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// *read-eval* +// disj { -v0 := lang.NewSymbol("*read-eval*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "Defaults to true (or value specified by system property, see below)\n ***This setting implies that the full power of the reader is in play,\n including syntax that can cause code to execute. It should never be\n used with untrusted sources. See also: glojure.edn/read.***\n\n When set to logical false in the thread-local binding,\n the eval reader (#=) and record/type literal syntax are disabled in read/load.\n Example (will fail): (binding [*read-eval* false] (read-string \"#=(* 2 21)\"))\n\n The default binding can be controlled by the system property\n 'glojure.read.eval' System properties can be set on the command line\n like this:\n\n java -Dglojure.read.eval=false ...\n\n The system property can also be set to 'unknown' via\n -Dglojure.read.eval=unknown, in which case the default binding\n is :unknown and all reads will fail in contexts where *read-eval*\n has not been explicitly bound to either true or false. This setting\n can be a useful diagnostic tool to ensure that all of your reads\n occur in considered contexts. You can also accomplish this in a\n particular scope by binding *read-eval* to :unknown\n ", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, nil, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// trampoline -{ -v0 := lang.NewSymbol("trampoline").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "trampoline can be used to convert algorithms requiring mutual\n recursion without stack consumption. Calls f with supplied args, if\n any. If f returns a fn, calls that fn with no arguments, and\n continues to repeat, until the return value is not a fn, then\n returns that non-fn value. Note that if you want to return a fn as a\n final value, you must wrap it in some data structure and unpack it\n after trampoline returns.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6336), lang.NewKeyword("end-line"), int(6336))).(*lang.Symbol) +v0 := lang.NewSymbol("disj").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("set")), lang.NewVector(lang.NewSymbol("set"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("set"), lang.NewSymbol("key"), lang.NewSymbol("&"), lang.NewSymbol("ks"))), lang.NewKeyword("doc"), "disj[oin]. Returns a new set of the same (hashed/sorted) type, that\n does not contain key(s).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1514), lang.NewKeyword("end-line"), int(1514))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] -recur_loop_1083: -v5 := lang.Apply(v3, nil) -var v4 any = v5 -_ = v4 -var v7 any -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("fn?")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +return v3 + case 2: +v3 := args[0] +v4 := args[1] +var v5 any +if lang.IsTruthy(v3) { +v6, _ := lang.FieldOrMethod(v3, "Disjoin") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Disjoin is not a function"))) } -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v4}) -if lang.IsTruthy(v11) { -var v12 any = v4 -v3 = v12 -goto recur_loop_1083 +v7 := lang.Apply(v6, []any{v4}) +v5 = v7 } else { -v7 = v4 +v5 = nil } -return v7 +return v5 default: - if len(args) < 1 { + if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := lang.NewList(args[1:]...) -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("trampoline")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v4 := args[1] +v5 := lang.NewList(args[2:]...) +recur_loop_304: +var v6 any +if lang.IsTruthy(v3) { +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("disj")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v7 := v6.Get() -var v8 lang.FnFunc -v8 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("apply")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v3, v4}) +var v7 any = v11 +_ = v7 +var v13 any +if lang.IsTruthy(v5) { +var v14 any = v7 +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("first")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v3, v4}) -return v12 -}) -v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6352), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(6352), lang.NewKeyword("end-column"), int(32)) -v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) -if err != nil { - panic(err) +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v5}) +var v15 any = v19 +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("next")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v11 := lang.Apply(v7, []any{v10}) -return v11 +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v5}) +var v20 any = v24 +v3 = v14 +v4 = v15 +v5 = v20 +goto recur_loop_304 +} else { +v13 = v7 +} +v6 = v13 +} else { +v6 = nil +} +return v6 } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -28418,21 +26595,67 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// val +// disj! { -v0 := lang.NewSymbol("val").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("e"))), lang.NewKeyword("doc"), "Returns the value in the map entry.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1570), lang.NewKeyword("end-line"), int(1570))).(*lang.Symbol) +v0 := lang.NewSymbol("disj!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("set")), lang.NewVector(lang.NewSymbol("set"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("set"), lang.NewSymbol("key"), lang.NewSymbol("&"), lang.NewSymbol("ks"))), lang.NewKeyword("doc"), "disj[oin]. Returns a transient set of the same (hashed/sorted) type, that\n does not contain key(s).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3401), lang.NewKeyword("end-line"), int(3401))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + switch len(args) { + case 1: v3 := args[0] -v4, _ := lang.FieldOrMethod(v3, "GetValue") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("GetValue is not a function"))) +return v3 + case 2: +v3 := args[0] +v4 := args[1] +v5, _ := lang.FieldOrMethod(v3, "Disjoin") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Disjoin is not a function"))) } -v5 := lang.Apply(v4, []any{}) -return v5 +v6 := lang.Apply(v5, []any{v4}) +return v6 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +recur_loop_615: +v7, _ := lang.FieldOrMethod(v3, "Disjoin") +if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Disjoin is not a function"))) +} +v8 := lang.Apply(v7, []any{v4}) +var v6 any = v8 +_ = v6 +var v10 any +if lang.IsTruthy(v5) { +var v11 any = v6 +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("first")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v5}) +var v12 any = v16 +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("next")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, []any{v5}) +var v17 any = v21 +v3 = v11 +v4 = v12 +v5 = v17 +goto recur_loop_615 +} else { +v10 = v6 +} +return v10 + } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -28440,37 +26663,69 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// split-with +// dissoc { -v0 := lang.NewSymbol("split-with").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a vector of [(take-while pred coll) (drop-while pred coll)]", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2990), lang.NewKeyword("end-line"), int(2990))).(*lang.Symbol) +v0 := lang.NewSymbol("dissoc").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map")), lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"), lang.NewSymbol("&"), lang.NewSymbol("ks"))), lang.NewKeyword("doc"), "dissoc[iate]. Returns a new map of the same (hashed/sorted) type,\n that does not contain a mapping for key(s).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1500), lang.NewKeyword("end-line"), int(1500))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + switch len(args) { + case 1: +v3 := args[0] +return v3 + case 2: v3 := args[0] v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("take-while")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v5, _ := lang.FieldOrMethod(runtime9.RT, "Dissoc") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Dissoc is not a function"))) } -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3, v4}) -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("drop-while")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +v6 := lang.Apply(v5, []any{v3, v4}) +return v6 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +recur_loop_301: +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("dissoc")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v3, v4}) -v13 := lang.NewVector(v8, v12) -v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2995), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2995), lang.NewKeyword("end-column"), int(51)) -v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) -if err != nil { - panic(err) +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v3, v4}) +var v6 any = v10 +_ = v6 +var v12 any +if lang.IsTruthy(v5) { +var v13 any = v6 +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("first")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } -return v15 +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v5}) +var v14 any = v18 +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("next")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.Apply(v22, []any{v5}) +var v19 any = v23 +v3 = v13 +v4 = v14 +v5 = v19 +goto recur_loop_301 +} else { +v12 = v6 +} +return v12 + } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -28478,3173 +26733,3177 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// for +// dissoc! { -v0 := lang.NewSymbol("for").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("seq-exprs"), lang.NewSymbol("body-expr"))), lang.NewKeyword("doc"), "List comprehension. Takes a vector of one or more\n binding-form/collection-expr pairs, each followed by zero or more\n modifiers, and yields a lazy sequence of evaluations of expr.\n Collections are iterated in a nested fashion, rightmost fastest,\n and nested coll-exprs can refer to bindings created in prior\n binding-forms. Supported modifiers are: :let [binding-form expr ...],\n :while test, :when test.\n\n (take 100 (for [x (range 100000000) y (range 1000000) :while (< y x)] [x y]))", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4646), lang.NewKeyword("end-line"), int(4646))).(*lang.Symbol) +v0 := lang.NewSymbol("dissoc!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"), lang.NewSymbol("&"), lang.NewSymbol("ks"))), lang.NewKeyword("doc"), "Returns a transient map that doesn't contain a mapping for key(s).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3382), lang.NewKeyword("end-line"), int(3382))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + switch len(args) { + case 2: v3 := args[0] v4 := args[1] -v5 := args[2] -v6 := args[3] -var v7 any -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v5, _ := lang.FieldOrMethod(v3, "without") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("without is not a function"))) } -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v5}) -if lang.IsTruthy(v11) { -v7 = nil +v6 := lang.Apply(v5, []any{v4}) +return v6 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +recur_loop_611: +v7, _ := lang.FieldOrMethod(v3, "without") +if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("without is not a function"))) +} +v8 := lang.Apply(v7, []any{v4}) +var v6 any = v8 +_ = v6 +var v10 any +if lang.IsTruthy(v5) { +var v11 any = v6 +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("first")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v5}) +var v12 any = v16 +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("next")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, []any{v5}) +var v17 any = v21 +v3 = v11 +v4 = v12 +v5 = v17 +goto recur_loop_611 } else { -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("str")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +v10 = v6 } -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("first")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +return v10 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v3}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("meta")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +// distinct +{ +v0 := lang.NewSymbol("distinct").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the elements of coll with duplicates removed.\n Returns a stateful transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5053), lang.NewKeyword("end-line"), int(5053))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("volatile!")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) -v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) -v28 := lang.Apply(lang1.NewIllegalArgumentError, []any{v27}) -panic(v28) +v8 := v7.Get() +v9 := lang.CreatePersistentTreeSet() +v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5060), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(5060), lang.NewKeyword("end-column"), int(30)) +v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) +if err != nil { + panic(err) } -_ = v7 -var v29 any -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("even?")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +v12 := lang.Apply(v8, []any{v11}) +var v5 any = v12 +_ = v5 +var v14 lang.FnFunc +v14 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v15 := lang.Apply(v4, nil) +return v15 + case 1: +v15 := args[0] +v16 := lang.Apply(v4, []any{v15}) +return v16 + case 2: +v15 := args[0] +v16 := args[1] +var v17 any +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("contains?")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("count")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("deref")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v5}) -v37 := lang.Apply(v32, []any{v36}) -if lang.IsTruthy(v37) { -v29 = nil +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v5}) +v25 := lang.Apply(v20, []any{v24, v16}) +if lang.IsTruthy(v25) { +v17 = v15 } else { -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("str")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("conj")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) } -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("first")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +v28 := v27.Get() +v29, ok := lang.FieldOrMethod(v5, "Deref") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "Deref"))) } -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v3}) -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +var v30 any +switch reflect.TypeOf(v29).Kind() { +case reflect.Func: + v30 = lang.Apply(v29, nil) +default: + v30 = v29 } -v47 := v46.Get() -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("meta")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +v31 := lang.Apply(v28, []any{v30, v16}) +v32, _ := lang.FieldOrMethod(v5, "reset") +if reflect.TypeOf(v32).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) } -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v3}) -v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) -v53 := lang.Apply(v40, []any{v44, " requires ", "an even number of forms in binding vector", " in ", v47, ":", v52}) -v54 := lang.Apply(lang1.NewIllegalArgumentError, []any{v53}) -panic(v54) +v33 := lang.Apply(v32, []any{v31}) +_ = v33 +v34 := lang.Apply(v4, []any{v15, v16}) +v17 = v34 } -_ = v29 -_ = nil -var v56 lang.FnFunc -v56 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { +return v17 + default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v57 := args[0] -v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v59 := v58.FindInternedVar(lang.NewSymbol("reduce1")) -if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) +}) +v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5061), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(5068), lang.NewKeyword("end-column"), int(37)) +v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v60 := v59.Get() -var v61 lang.FnFunc -v61 = lang.NewFnFunc(func(args ...any) any { +return v16 +}) +v4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5059), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(5068), lang.NewKeyword("end-column"), int(39)) +v5, err := lang.WithMeta(v3, v4.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v5 + case 1: +v3 := args[0] +var v5 lang.FnFunc +{ // function step +v5 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v62 := args[0] -v63 := args[1] -var v64 any = v63 -_ = v64 -v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v67 := v66.FindInternedVar(lang.NewSymbol("nth")) -if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) -} -v68 := v67.Get() -v69 := lang.Apply(v68, []any{v64, int64(0), nil}) -var v65 any = v69 -_ = v65 -v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v72 := v71.FindInternedVar(lang.NewSymbol("nth")) -if v72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) -} -v73 := v72.Get() -v74 := lang.Apply(v73, []any{v64, int64(1), nil}) -var v70 any = v74 -_ = v70 -var v76 any -v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v78 := v77.FindInternedVar(lang.NewSymbol("keyword?")) -if v78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) +v7 := args[0] +v8 := args[1] +var v9 lang.FnFunc +v9 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +var v10 lang.FnFunc +v10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v11 := args[0] +v12 := args[1] +recur_loop_877: +var v13 any = v11 +_ = v13 +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("nth")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } -v79 := v78.Get() -v80 := lang.Apply(v79, []any{v65}) -if lang.IsTruthy(v80) { -v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v82 := v81.FindInternedVar(lang.NewSymbol("conj")) -if v82.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v13, int64(0), nil}) +var v14 any = v18 +_ = v14 +var v19 any = v13 +_ = v19 +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("seq")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -v83 := v82.Get() -v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v85 := v84.FindInternedVar(lang.NewSymbol("pop")) -if v85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v19}) +var v21 any = v25 +_ = v21 +var v27 any +if lang.IsTruthy(v21) { +var v28 any = v21 +_ = v28 +var v30 any +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("contains?")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -v86 := v85.Get() -v87 := lang.Apply(v86, []any{v62}) -v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v89 := v88.FindInternedVar(lang.NewSymbol("conj")) -if v89.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v12, v14}) +if lang.IsTruthy(v34) { +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("rest")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) } -v90 := v89.Get() -v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v92 := v91.FindInternedVar(lang.NewSymbol("peek")) -if v92.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v28}) +var v35 any = v39 +var v40 any = v12 +v11 = v35 +v12 = v40 +goto recur_loop_877 +} else { +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("cons")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } -v93 := v92.Get() -v94 := lang.Apply(v93, []any{v62}) -v95 := lang.NewVector(v65, v70) -v96 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4664), lang.NewKeyword("column"), int(72), lang.NewKeyword("end-line"), int(4664), lang.NewKeyword("end-column"), int(76)) -v97, err := lang.WithMeta(v95, v96.(lang.IPersistentMap)) -if err != nil { - panic(err) +v43 := v42.Get() +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("rest")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } -v98 := lang.Apply(v90, []any{v94, v97}) -v99 := lang.Apply(v83, []any{v87, v98}) -v76 = v99 +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v28}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("conj")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v12, v14}) +v52 := lang.Apply(v6, []any{v47, v51}) +v53 := lang.Apply(v43, []any{v14, v52}) +v30 = v53 +} +v27 = v30 } else { -v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v101 := v100.FindInternedVar(lang.NewSymbol("conj")) -if v101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) +v27 = nil } -v102 := v101.Get() -v103 := lang.NewVector(v65, v70) -v104 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4665), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(4665), lang.NewKeyword("end-column"), int(50)) -v105, err := lang.WithMeta(v103, v104.(lang.IPersistentMap)) +return v27 +}) +v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5072), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(5076), lang.NewKeyword("end-column"), int(66)) +v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) if err != nil { panic(err) } -v106 := lang.Apply(v102, []any{v62, v105}) -v76 = v106 -} -return v76 +v13 := lang.Apply(v12, []any{v7, v8}) +return v13 }) -v62 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4662), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(4665), lang.NewKeyword("end-column"), int(53)) -v63, err := lang.WithMeta(v61, v62.(lang.IPersistentMap)) +v10 := lang.Apply(lang1.NewLazySeq, []any{v9}) +return v10 +}) +v6 := v5 +_ = v6 +} +v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5070), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(5077), lang.NewKeyword("end-column"), int(29)) +v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) if err != nil { panic(err) } -v64 := lang.NewVector() -v65 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4666), lang.NewKeyword("column"), int(29), lang.NewKeyword("end-line"), int(4666), lang.NewKeyword("end-column"), int(30)) -v66, err := lang.WithMeta(v64, v65.(lang.IPersistentMap)) +var v4 any = v7 +_ = v4 +v9 := lang.CreatePersistentTreeSet() +v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5078), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(5078), lang.NewKeyword("end-column"), int(19)) +v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) if err != nil { panic(err) } -v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v68 := v67.FindInternedVar(lang.NewSymbol("partition")) -if v68.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) -} -v69 := v68.Get() -v70 := lang.Apply(v69, []any{int64(2), v57}) -v71 := lang.Apply(v60, []any{v63, v66, v70}) -return v71 +v12 := lang.Apply(v4, []any{v3, v11}) +return v12 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } }) -v57 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4661), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(4666), lang.NewKeyword("end-column"), int(56)) -v58, err := lang.WithMeta(v56, v57.(lang.IPersistentMap)) -if err != nil { - panic(err) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -var v55 any = v58 -_ = v55 -var v60 lang.FnFunc -v60 = lang.NewFnFunc(func(args ...any) any { +} +// distinct? +{ +v1 := reflect.TypeOf(false) +v0 := lang.NewSymbol("distinct?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Returns true if no two of the arguments are =", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5707), lang.NewKeyword("end-line"), int(5707))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { + case 1: +v4 := args[0] +return true + case 2: +v4 := args[0] +v5 := args[1] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("not")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("=")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v4, v5}) +v13 := lang.Apply(v8, []any{v12}) +return v13 default: - if len(args) < 0 { + if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v61 := lang.NewList(args[0:]...) -v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v63 := v62.FindInternedVar(lang.NewSymbol("apply")) -if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) -} -v64 := v63.Get() -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("str")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +v4 := args[0] +v5 := args[1] +v6 := lang.NewList(args[2:]...) +var v7 any +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("not=")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v67 := v66.Get() -v68 := lang.Apply(v64, []any{v67, v61}) -v69 := lang.Apply(lang1.NewIllegalArgumentError, []any{v68}) -panic(v69) - } -}) -v61 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4667), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(4667), lang.NewKeyword("end-column"), int(125)) -v62, err := lang.WithMeta(v60, v61.(lang.IPersistentMap)) +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v4, v5}) +if lang.IsTruthy(v11) { +v13 := lang.CreatePersistentTreeSet(v4, v5) +v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5716), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(5716), lang.NewKeyword("end-column"), int(20)) +v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) if err != nil { panic(err) } -var v59 any = v62 -_ = v59 -var v64 lang.FnFunc -{ // function emit-bind -v64 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v66 := args[0] -var v67 any = v66 -_ = v67 -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("seq")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) -} -v71 := v70.Get() -v72 := lang.Apply(v71, []any{v67}) -var v68 any = v72 -_ = v68 -v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v75 := v74.FindInternedVar(lang.NewSymbol("first")) -if v75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) +var v12 any = v15 +_ = v12 +var v16 any = v6 +_ = v16 +var v17 any = v16 +_ = v17 +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("seq")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v76 := v75.Get() -v77 := lang.Apply(v76, []any{v68}) -var v73 any = v77 -_ = v73 -v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v80 := v79.FindInternedVar(lang.NewSymbol("next")) -if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v17}) +var v18 any = v22 +_ = v18 +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("first")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -v81 := v80.Get() -v82 := lang.Apply(v81, []any{v78}) -var v78 any = v82 -_ = v78 -var v83 any = v73 -_ = v83 -v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v86 := v85.FindInternedVar(lang.NewSymbol("seq")) -if v86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v18}) +var v23 any = v27 +_ = v23 +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("next")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) } -v87 := v86.Get() -v88 := lang.Apply(v87, []any{v83}) -var v84 any = v88 -_ = v84 -v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v91 := v90.FindInternedVar(lang.NewSymbol("first")) -if v91.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) +v31 := v30.Get() +v32 := lang.Apply(v31, []any{v28}) +var v28 any = v32 +_ = v28 +var v33 any = v23 +_ = v33 +var v34 any = v28 +_ = v34 +var v35 any = v17 +_ = v35 +var v37 any = v37 +_ = v37 +var v38 any = v38 +_ = v38 +var v39 any +for { +var v40 any = v40 +_ = v40 +var v41 any = v38 +_ = v41 +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("seq")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) } -v92 := v91.Get() -v93 := lang.Apply(v92, []any{v84}) -var v89 any = v93 -_ = v89 -v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v96 := v95.FindInternedVar(lang.NewSymbol("next")) -if v96.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) +v45 := v44.Get() +v46 := lang.Apply(v45, []any{v41}) +var v42 any = v46 +_ = v42 +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("first")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) } -v97 := v96.Get() -v98 := lang.Apply(v97, []any{v94}) -var v94 any = v98 -_ = v94 -var v99 any = v89 -_ = v99 -v101 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v102 := v101.FindInternedVar(lang.NewSymbol("first")) -if v102.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v102))) +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v42}) +var v47 any = v51 +_ = v47 +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("next")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) } -v103 := v102.Get() -v104 := lang.Apply(v103, []any{v94}) -var v100 any = v104 -_ = v100 -v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v107 := v106.FindInternedVar(lang.NewSymbol("next")) -if v107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) +v55 := v54.Get() +v56 := lang.Apply(v55, []any{v52}) +var v52 any = v56 +_ = v52 +var v57 any = v47 +_ = v57 +var v58 any = v52 +_ = v58 +var v59 any = v41 +_ = v59 +var v61 any +if lang.IsTruthy(v59) { +var v62 any +v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v64 := v63.FindInternedVar(lang.NewSymbol("contains?")) +if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) } -v108 := v107.Get() -v109 := lang.Apply(v108, []any{v105}) -var v105 any = v109 -_ = v105 -var v110 any = v100 -_ = v110 -var v111 any = v105 -_ = v111 -var v112 any = v78 -_ = v112 -v114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v115 := v114.FindInternedVar(lang.NewSymbol("nth")) -if v115.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v115))) +v65 := v64.Get() +v66 := lang.Apply(v65, []any{v40, v57}) +if lang.IsTruthy(v66) { +v62 = false +} else { +v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v69 := v68.FindInternedVar(lang.NewSymbol("conj")) +if v69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) } -v116 := v115.Get() -v117 := lang.Apply(v116, []any{v112, int64(0), nil}) -var v113 any = v117 -_ = v113 -v119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v120 := v119.FindInternedVar(lang.NewSymbol("nth")) -if v120.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v120))) +v70 := v69.Get() +v71 := lang.Apply(v70, []any{v40, v57}) +var v67 any = v71 +var v72 any = v58 +v37 = v67 +v38 = v72 +continue } -v121 := v120.Get() -v122 := lang.Apply(v121, []any{v113, int64(0), nil}) -var v118 any = v122 -_ = v118 -v124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v125 := v124.FindInternedVar(lang.NewSymbol("nth")) -if v125.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v125))) +v61 = v62 +} else { +v61 = true } -v126 := v125.Get() -v127 := lang.Apply(v126, []any{v113, int64(1), nil}) -var v123 any = v127 -_ = v123 -var v128 any = v112 -_ = v128 -v131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v132 := v131.FindInternedVar(lang.NewSymbol("gensym")) -if v132.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v132))) +v39 = v61 + break } -v133 := v132.Get() -v134 := lang.Apply(v133, []any{"iter__"}) -var v130 any = v134 -_ = v130 -v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v137 := v136.FindInternedVar(lang.NewSymbol("gensym")) -if v137.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) +v7 = v39 +} else { +v7 = false } -v138 := v137.Get() -v139 := lang.Apply(v138, []any{"s__"}) -var v135 any = v139 -_ = v135 -var v141 lang.FnFunc -{ // function do-mod -v141 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) +return v7 } -v143 := args[0] -var v144 any = v143 -_ = v144 -v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v147 := v146.FindInternedVar(lang.NewSymbol("seq")) -if v147.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) +}) +v4 := reflect.TypeOf(false) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v148 := v147.Get() -v149 := lang.Apply(v148, []any{v144}) -var v145 any = v149 -_ = v145 -v151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v152 := v151.FindInternedVar(lang.NewSymbol("first")) -if v152.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v152))) } -v153 := v152.Get() -v154 := lang.Apply(v153, []any{v145}) -var v150 any = v154 -_ = v150 -v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v157 := v156.FindInternedVar(lang.NewSymbol("next")) -if v157.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) +// doall +{ +v0 := lang.NewSymbol("doall").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "When lazy sequences are produced via functions that have side\n effects, any effects other than those needed to produce the first\n element in the seq do not occur until the seq is consumed. doall can\n be used to force any effects. Walks through the successive nexts of\n the seq, retains the head and returns it, thus causing the entire\n seq to reside in memory at one time.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3131), lang.NewKeyword("end-line"), int(3131))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("dorun")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v158 := v157.Get() -v159 := lang.Apply(v158, []any{v155}) -var v155 any = v159 -_ = v155 -var v160 any = v150 -_ = v160 -v162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v163 := v162.FindInternedVar(lang.NewSymbol("nth")) -if v163.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v163))) +v6 := v5.Get() +v7 := lang.Apply(v6, []any{v3}) +_ = v7 +return v3 + case 2: +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("dorun")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v164 := v163.Get() -v165 := lang.Apply(v164, []any{v160, int64(0), nil}) -var v161 any = v165 -_ = v161 -v167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v168 := v167.FindInternedVar(lang.NewSymbol("nth")) -if v168.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v168))) +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3, v4}) +_ = v8 +return v4 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v169 := v168.Get() -v170 := lang.Apply(v169, []any{v160, int64(1), nil}) -var v166 any = v170 -_ = v166 -var v171 any = v160 -_ = v171 -var v172 any = v155 -_ = v172 -var v174 any -v175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v176 := v175.FindInternedVar(lang.NewSymbol("=")) -if v176.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v176))) } -v177 := v176.Get() -v178 := lang.Apply(v177, []any{v161, lang.NewKeyword("let")}) -if lang.IsTruthy(v178) { -v179 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v180 := v179.FindInternedVar(lang.NewSymbol("seq")) -if v180.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v180))) +// dorun +{ +v0 := lang.NewSymbol("dorun").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "When lazy sequences are produced via functions that have side\n effects, any effects other than those needed to produce the first\n element in the seq do not occur until the seq is consumed. dorun can\n be used to force any effects. Walks through the successive nexts of\n the seq, does not retain the head and returns nil.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3116), lang.NewKeyword("end-line"), int(3116))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +recur_loop_579: +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v181 := v180.Get() -v182 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v183 := v182.FindInternedVar(lang.NewSymbol("concat")) -if v183.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v183))) +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +var v4 any = v8 +_ = v4 +var v10 any +if lang.IsTruthy(v4) { +var v11 any = v4 +_ = v11 +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("next")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v184 := v183.Get() -v185 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v186 := v185.FindInternedVar(lang.NewSymbol("list")) -if v186.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v186))) +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v11}) +var v13 any = v17 +v3 = v13 +goto recur_loop_579 +} else { +v10 = nil } -v187 := v186.Get() -v188 := lang.Apply(v187, []any{lang.NewSymbol("glojure.core/let")}) -v189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v190 := v189.FindInternedVar(lang.NewSymbol("list")) -if v190.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v190))) +return v10 + case 2: +v3 := args[0] +v4 := args[1] +recur_loop_580: +var v5 any +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("seq")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v191 := v190.Get() -v192 := lang.Apply(v191, []any{v166}) -v193 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v194 := v193.FindInternedVar(lang.NewSymbol("list")) -if v194.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v194))) +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v4}) +var v6 any = v10 +_ = v6 +var v12 any +if lang.IsTruthy(v6) { +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("pos?")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } -v195 := v194.Get() -v196 := lang.Apply(v142, []any{v172}) -v197 := lang.Apply(v195, []any{v196}) -v198 := lang.Apply(v184, []any{v188, v192, v197}) -v199 := lang.Apply(v181, []any{v198}) -v174 = v199 +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v3}) +v12 = v16 } else { -var v200 any -v201 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v202 := v201.FindInternedVar(lang.NewSymbol("=")) -if v202.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v202))) +v12 = v6 } -v203 := v202.Get() -v204 := lang.Apply(v203, []any{v161, lang.NewKeyword("while")}) -if lang.IsTruthy(v204) { -v205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v206 := v205.FindInternedVar(lang.NewSymbol("seq")) -if v206.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v206))) +if lang.IsTruthy(v12) { +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("dec")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v207 := v206.Get() -v208 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v209 := v208.FindInternedVar(lang.NewSymbol("concat")) -if v209.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v209))) +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v3}) +var v6 any = v10 +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("next")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } -v210 := v209.Get() -v211 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v212 := v211.FindInternedVar(lang.NewSymbol("list")) -if v212.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v212))) +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v4}) +var v11 any = v15 +v3 = v6 +v4 = v11 +goto recur_loop_580 +} else { +v5 = nil } -v213 := v212.Get() -v214 := lang.Apply(v213, []any{lang.NewSymbol("glojure.core/when")}) -v215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v216 := v215.FindInternedVar(lang.NewSymbol("list")) -if v216.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v216))) +return v5 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v217 := v216.Get() -v218 := lang.Apply(v217, []any{v166}) -v219 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v220 := v219.FindInternedVar(lang.NewSymbol("list")) -if v220.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v220))) } -v221 := v220.Get() -v222 := lang.Apply(v142, []any{v172}) -v223 := lang.Apply(v221, []any{v222}) -v224 := lang.Apply(v210, []any{v214, v218, v223}) -v225 := lang.Apply(v207, []any{v224}) -v200 = v225 +// doseq +{ +v0 := lang.NewSymbol("doseq").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("seq-exprs"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Repeatedly executes body (presumably for side-effects) with\n bindings and filtering as provided by \"for\". Does not retain\n the head of the sequence. Returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3209), lang.NewKeyword("end-line"), int(3209))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +var v7 any +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v5}) +if lang.IsTruthy(v11) { +v7 = nil } else { -var v226 any -v227 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v228 := v227.FindInternedVar(lang.NewSymbol("=")) -if v228.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v228))) +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("str")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } -v229 := v228.Get() -v230 := lang.Apply(v229, []any{v161, lang.NewKeyword("when")}) -if lang.IsTruthy(v230) { -v231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v232 := v231.FindInternedVar(lang.NewSymbol("seq")) -if v232.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v232))) +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("first")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } -v233 := v232.Get() -v234 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v235 := v234.FindInternedVar(lang.NewSymbol("concat")) -if v235.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v235))) +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v3}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v236 := v235.Get() -v237 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v238 := v237.FindInternedVar(lang.NewSymbol("list")) -if v238.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v238))) +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("meta")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -v239 := v238.Get() -v240 := lang.Apply(v239, []any{lang.NewSymbol("if")}) -v241 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v242 := v241.FindInternedVar(lang.NewSymbol("list")) -if v242.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v242))) +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v3}) +v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) +v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) +v28 := lang.Apply(lang1.NewIllegalArgumentError, []any{v27}) +panic(v28) } -v243 := v242.Get() -v244 := lang.Apply(v243, []any{v166}) -v245 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v246 := v245.FindInternedVar(lang.NewSymbol("list")) -if v246.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v246))) +_ = v7 +var v29 any +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("even?")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) } -v247 := v246.Get() -v248 := lang.Apply(v142, []any{v172}) -v249 := lang.Apply(v247, []any{v248}) -v250 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v251 := v250.FindInternedVar(lang.NewSymbol("list")) -if v251.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v251))) +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("count")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) } -v252 := v251.Get() -v253 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v254 := v253.FindInternedVar(lang.NewSymbol("seq")) -if v254.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v254))) +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v5}) +v37 := lang.Apply(v32, []any{v36}) +if lang.IsTruthy(v37) { +v29 = nil +} else { +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("str")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) } -v255 := v254.Get() -v256 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v257 := v256.FindInternedVar(lang.NewSymbol("concat")) -if v257.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v257))) +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("first")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } -v258 := v257.Get() -v259 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v260 := v259.FindInternedVar(lang.NewSymbol("list")) -if v260.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v260))) +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v3}) +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) } -v261 := v260.Get() -v262 := lang.Apply(v261, []any{lang.NewSymbol("recur")}) -v263 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v264 := v263.FindInternedVar(lang.NewSymbol("list")) -if v264.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v264))) +v47 := v46.Get() +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("meta")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) } -v265 := v264.Get() -v266 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v267 := v266.FindInternedVar(lang.NewSymbol("seq")) -if v267.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v267))) +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v3}) +v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) +v53 := lang.Apply(v40, []any{v44, " requires ", "an even number of forms in binding vector", " in ", v47, ":", v52}) +v54 := lang.Apply(lang1.NewIllegalArgumentError, []any{v53}) +panic(v54) } -v268 := v267.Get() -v269 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v270 := v269.FindInternedVar(lang.NewSymbol("concat")) -if v270.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v270))) +_ = v29 +_ = nil +var v56 lang.FnFunc +{ // function step +v56 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v58 := args[0] +v59 := args[1] +var v60 any +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("not")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) } -v271 := v270.Get() -v272 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v273 := v272.FindInternedVar(lang.NewSymbol("list")) -if v273.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v273))) +v63 := v62.Get() +v64 := lang.Apply(v63, []any{v59}) +if lang.IsTruthy(v64) { +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("seq")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) } -v274 := v273.Get() -v275 := lang.Apply(v274, []any{lang.NewSymbol("glojure.core/rest")}) -v276 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v277 := v276.FindInternedVar(lang.NewSymbol("list")) -if v277.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v277))) +v67 := v66.Get() +v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v69 := v68.FindInternedVar(lang.NewSymbol("concat")) +if v69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) } -v278 := v277.Get() -v279 := lang.Apply(v278, []any{v135}) -v280 := lang.Apply(v271, []any{v275, v279}) -v281 := lang.Apply(v268, []any{v280}) -v282 := lang.Apply(v265, []any{v281}) -v283 := lang.Apply(v258, []any{v262, v282}) -v284 := lang.Apply(v255, []any{v283}) -v285 := lang.Apply(v252, []any{v284}) -v286 := lang.Apply(v236, []any{v240, v244, v249, v285}) -v287 := lang.Apply(v233, []any{v286}) -v226 = v287 -} else { -var v288 any -v289 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v290 := v289.FindInternedVar(lang.NewSymbol("keyword?")) -if v290.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v290))) +v70 := v69.Get() +v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v72 := v71.FindInternedVar(lang.NewSymbol("list")) +if v72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) } -v291 := v290.Get() -v292 := lang.Apply(v291, []any{v161}) -if lang.IsTruthy(v292) { -v293 := lang.Apply(v59, []any{"Invalid 'for' keyword ", v161}) -v288 = v293 +v73 := v72.Get() +v74 := lang.Apply(v73, []any{lang.NewSymbol("do")}) +v75 := lang.Apply(v70, []any{v74, v6}) +v76 := lang.Apply(v67, []any{v75}) +v77 := lang.NewVector(true, v76) +v78 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3220), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(3220), lang.NewKeyword("end-column"), int(36)) +v79, err := lang.WithMeta(v77, v78.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v60 = v79 } else { -var v294 any -if lang.IsTruthy(v128) { -v295 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v296 := v295.FindInternedVar(lang.NewSymbol("seq")) -if v296.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v296))) +v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v82 := v81.FindInternedVar(lang.NewSymbol("first")) +if v82.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) } -v297 := v296.Get() -v298 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v299 := v298.FindInternedVar(lang.NewSymbol("concat")) -if v299.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v299))) +v83 := v82.Get() +v84 := lang.Apply(v83, []any{v59}) +var v80 any = v84 +_ = v80 +v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v87 := v86.FindInternedVar(lang.NewSymbol("second")) +if v87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) } -v300 := v299.Get() -v301 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v302 := v301.FindInternedVar(lang.NewSymbol("list")) -if v302.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v302))) +v88 := v87.Get() +v89 := lang.Apply(v88, []any{v59}) +var v85 any = v89 +_ = v85 +var v91 any +v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v93 := v92.FindInternedVar(lang.NewSymbol("keyword?")) +if v93.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) } -v303 := v302.Get() -v304 := lang.Apply(v303, []any{lang.NewSymbol("glojure.core/let")}) -v305 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v306 := v305.FindInternedVar(lang.NewSymbol("list")) -if v306.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v306))) -} -v307 := v306.Get() -v308 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v309 := v308.FindInternedVar(lang.NewSymbol("apply")) -if v309.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v309))) +v94 := v93.Get() +v95 := lang.Apply(v94, []any{v80}) +if lang.IsTruthy(v95) { +v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v98 := v97.FindInternedVar(lang.NewSymbol("nnext")) +if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) } -v310 := v309.Get() -v311 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v312 := v311.FindInternedVar(lang.NewSymbol("vector")) -if v312.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v312))) +v99 := v98.Get() +v100 := lang.Apply(v99, []any{v59}) +v101 := lang.Apply(v57, []any{v58, v100}) +var v96 any = v101 +_ = v96 +v103 := lang.Apply(v96, []any{int64(0)}) +var v102 any = v103 +_ = v102 +v105 := lang.Apply(v96, []any{int64(1)}) +var v104 any = v105 +_ = v104 +var v107 any +v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v109 := v108.FindInternedVar(lang.NewSymbol("=")) +if v109.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) } -v313 := v312.Get() -v314 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v315 := v314.FindInternedVar(lang.NewSymbol("seq")) -if v315.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v315))) +v110 := v109.Get() +v111 := lang.Apply(v110, []any{v80, lang.NewKeyword("let")}) +if lang.IsTruthy(v111) { +v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v113 := v112.FindInternedVar(lang.NewSymbol("seq")) +if v113.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) } -v316 := v315.Get() -v317 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v318 := v317.FindInternedVar(lang.NewSymbol("concat")) -if v318.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v318))) +v114 := v113.Get() +v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v116 := v115.FindInternedVar(lang.NewSymbol("concat")) +if v116.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) } -v319 := v318.Get() -v320 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v321 := v320.FindInternedVar(lang.NewSymbol("list")) -if v321.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v321))) +v117 := v116.Get() +v118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v119 := v118.FindInternedVar(lang.NewSymbol("list")) +if v119.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v119))) } -v322 := v321.Get() -v323 := lang.Apply(v322, []any{lang.NewSymbol("iterys__0__auto__")}) -v324 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v325 := v324.FindInternedVar(lang.NewSymbol("list")) -if v325.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v325))) +v120 := v119.Get() +v121 := lang.Apply(v120, []any{lang.NewSymbol("glojure.core/let")}) +v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v123 := v122.FindInternedVar(lang.NewSymbol("list")) +if v123.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) } -v326 := v325.Get() -v327 := lang.Apply(v65, []any{v128}) -v328 := lang.Apply(v326, []any{v327}) -v329 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v330 := v329.FindInternedVar(lang.NewSymbol("list")) -if v330.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v330))) +v124 := v123.Get() +v125 := lang.Apply(v124, []any{v85}) +v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v127 := v126.FindInternedVar(lang.NewSymbol("list")) +if v127.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) } -v331 := v330.Get() -v332 := lang.Apply(v331, []any{lang.NewSymbol("fs__1__auto__")}) -v333 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v334 := v333.FindInternedVar(lang.NewSymbol("list")) -if v334.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v334))) +v128 := v127.Get() +v129 := lang.Apply(v128, []any{v104}) +v130 := lang.Apply(v117, []any{v121, v125, v129}) +v131 := lang.Apply(v114, []any{v130}) +v132 := lang.NewVector(v102, v131) +v133 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3228), lang.NewKeyword("column"), int(37), lang.NewKeyword("end-line"), int(3228), lang.NewKeyword("end-column"), int(64)) +v134, err := lang.WithMeta(v132, v133.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v335 := v334.Get() -v336 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v337 := v336.FindInternedVar(lang.NewSymbol("seq")) -if v337.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v337))) +v107 = v134 +} else { +var v135 any +v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v137 := v136.FindInternedVar(lang.NewSymbol("=")) +if v137.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) } -v338 := v337.Get() -v339 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v340 := v339.FindInternedVar(lang.NewSymbol("concat")) -if v340.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v340))) +v138 := v137.Get() +v139 := lang.Apply(v138, []any{v80, lang.NewKeyword("while")}) +if lang.IsTruthy(v139) { +v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v141 := v140.FindInternedVar(lang.NewSymbol("seq")) +if v141.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) } -v341 := v340.Get() -v342 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v343 := v342.FindInternedVar(lang.NewSymbol("list")) -if v343.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v343))) +v142 := v141.Get() +v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v144 := v143.FindInternedVar(lang.NewSymbol("concat")) +if v144.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) } -v344 := v343.Get() -v345 := lang.Apply(v344, []any{lang.NewSymbol("glojure.core/seq")}) -v346 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v347 := v346.FindInternedVar(lang.NewSymbol("list")) -if v347.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v347))) +v145 := v144.Get() +v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v147 := v146.FindInternedVar(lang.NewSymbol("list")) +if v147.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) } -v348 := v347.Get() -v349 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v350 := v349.FindInternedVar(lang.NewSymbol("seq")) -if v350.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v350))) +v148 := v147.Get() +v149 := lang.Apply(v148, []any{lang.NewSymbol("glojure.core/when")}) +v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v151 := v150.FindInternedVar(lang.NewSymbol("list")) +if v151.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) } -v351 := v350.Get() -v352 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v353 := v352.FindInternedVar(lang.NewSymbol("concat")) -if v353.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v353))) +v152 := v151.Get() +v153 := lang.Apply(v152, []any{v85}) +v154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v155 := v154.FindInternedVar(lang.NewSymbol("list")) +if v155.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v155))) } -v354 := v353.Get() -v355 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v356 := v355.FindInternedVar(lang.NewSymbol("list")) -if v356.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v356))) +v156 := v155.Get() +v157 := lang.Apply(v156, []any{v104}) +var v158 any +if lang.IsTruthy(v102) { +v159 := lang.NewVector(v58) +v160 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3231), lang.NewKeyword("column"), int(65), lang.NewKeyword("end-line"), int(3231), lang.NewKeyword("end-column"), int(73)) +v161, err := lang.WithMeta(v159, v160.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v357 := v356.Get() -v358 := lang.Apply(v357, []any{lang.NewSymbol("iterys__0__auto__")}) -v359 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v360 := v359.FindInternedVar(lang.NewSymbol("list")) -if v360.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v360))) +v158 = v161 +} else { +v158 = nil } -v361 := v360.Get() -v362 := lang.Apply(v361, []any{v123}) -v363 := lang.Apply(v354, []any{v358, v362}) -v364 := lang.Apply(v351, []any{v363}) -v365 := lang.Apply(v348, []any{v364}) -v366 := lang.Apply(v341, []any{v345, v365}) -v367 := lang.Apply(v338, []any{v366}) -v368 := lang.Apply(v335, []any{v367}) -v369 := lang.Apply(v319, []any{v323, v328, v332, v368}) -v370 := lang.Apply(v316, []any{v369}) -v371 := lang.Apply(v310, []any{v313, v370}) -v372 := lang.Apply(v307, []any{v371}) -v373 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v374 := v373.FindInternedVar(lang.NewSymbol("list")) -if v374.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v374))) +v162 := lang.Apply(v145, []any{v149, v153, v157, v158}) +v163 := lang.Apply(v142, []any{v162}) +v164 := lang.NewVector(false, v163) +v165 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3229), lang.NewKeyword("column"), int(39), lang.NewKeyword("end-line"), int(3231), lang.NewKeyword("end-column"), int(76)) +v166, err := lang.WithMeta(v164, v165.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v375 := v374.Get() -v376 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v377 := v376.FindInternedVar(lang.NewSymbol("seq")) -if v377.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v377))) +v135 = v166 +} else { +var v167 any +v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v169 := v168.FindInternedVar(lang.NewSymbol("=")) +if v169.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) } -v378 := v377.Get() -v379 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v380 := v379.FindInternedVar(lang.NewSymbol("concat")) -if v380.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v380))) +v170 := v169.Get() +v171 := lang.Apply(v170, []any{v80, lang.NewKeyword("when")}) +if lang.IsTruthy(v171) { +v172 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v173 := v172.FindInternedVar(lang.NewSymbol("seq")) +if v173.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v173))) } -v381 := v380.Get() -v382 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v383 := v382.FindInternedVar(lang.NewSymbol("list")) -if v383.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v383))) +v174 := v173.Get() +v175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v176 := v175.FindInternedVar(lang.NewSymbol("concat")) +if v176.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v176))) } -v384 := v383.Get() -v385 := lang.Apply(v384, []any{lang.NewSymbol("if")}) -v386 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v387 := v386.FindInternedVar(lang.NewSymbol("list")) -if v387.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v387))) +v177 := v176.Get() +v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v179 := v178.FindInternedVar(lang.NewSymbol("list")) +if v179.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) } -v388 := v387.Get() -v389 := lang.Apply(v388, []any{lang.NewSymbol("fs__1__auto__")}) -v390 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v391 := v390.FindInternedVar(lang.NewSymbol("list")) -if v391.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v391))) +v180 := v179.Get() +v181 := lang.Apply(v180, []any{lang.NewSymbol("if")}) +v182 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v183 := v182.FindInternedVar(lang.NewSymbol("list")) +if v183.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v183))) } -v392 := v391.Get() -v393 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v394 := v393.FindInternedVar(lang.NewSymbol("seq")) -if v394.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v394))) +v184 := v183.Get() +v185 := lang.Apply(v184, []any{v85}) +v186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v187 := v186.FindInternedVar(lang.NewSymbol("list")) +if v187.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v187))) } -v395 := v394.Get() -v396 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v397 := v396.FindInternedVar(lang.NewSymbol("concat")) -if v397.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v397))) +v188 := v187.Get() +v189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v190 := v189.FindInternedVar(lang.NewSymbol("seq")) +if v190.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v190))) } -v398 := v397.Get() -v399 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v400 := v399.FindInternedVar(lang.NewSymbol("list")) -if v400.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v400))) +v191 := v190.Get() +v192 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v193 := v192.FindInternedVar(lang.NewSymbol("concat")) +if v193.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v193))) } -v401 := v400.Get() -v402 := lang.Apply(v401, []any{lang.NewSymbol("glojure.core/concat")}) -v403 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v404 := v403.FindInternedVar(lang.NewSymbol("list")) -if v404.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v404))) +v194 := v193.Get() +v195 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v196 := v195.FindInternedVar(lang.NewSymbol("list")) +if v196.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v196))) } -v405 := v404.Get() -v406 := lang.Apply(v405, []any{lang.NewSymbol("fs__1__auto__")}) -v407 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v408 := v407.FindInternedVar(lang.NewSymbol("list")) -if v408.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v408))) +v197 := v196.Get() +v198 := lang.Apply(v197, []any{lang.NewSymbol("do")}) +v199 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v200 := v199.FindInternedVar(lang.NewSymbol("list")) +if v200.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v200))) } -v409 := v408.Get() -v410 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v411 := v410.FindInternedVar(lang.NewSymbol("seq")) -if v411.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v411))) +v201 := v200.Get() +v202 := lang.Apply(v201, []any{v104}) +var v203 any +if lang.IsTruthy(v102) { +v204 := lang.NewVector(v58) +v205 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3235), lang.NewKeyword("column"), int(66), lang.NewKeyword("end-line"), int(3235), lang.NewKeyword("end-column"), int(74)) +v206, err := lang.WithMeta(v204, v205.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v412 := v411.Get() -v413 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v414 := v413.FindInternedVar(lang.NewSymbol("concat")) -if v414.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v414))) +v203 = v206 +} else { +v203 = nil } -v415 := v414.Get() -v416 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v417 := v416.FindInternedVar(lang.NewSymbol("list")) -if v417.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v417))) +v207 := lang.Apply(v194, []any{v198, v202, v203}) +v208 := lang.Apply(v191, []any{v207}) +v209 := lang.Apply(v188, []any{v208}) +v210 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v211 := v210.FindInternedVar(lang.NewSymbol("list")) +if v211.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v211))) } -v418 := v417.Get() -v419 := lang.Apply(v418, []any{v130}) -v420 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v421 := v420.FindInternedVar(lang.NewSymbol("list")) -if v421.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v421))) +v212 := v211.Get() +v213 := lang.Apply(v212, []any{v58}) +v214 := lang.Apply(v177, []any{v181, v185, v209, v213}) +v215 := lang.Apply(v174, []any{v214}) +v216 := lang.NewVector(false, v215) +v217 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3232), lang.NewKeyword("column"), int(38), lang.NewKeyword("end-line"), int(3236), lang.NewKeyword("end-column"), int(57)) +v218, err := lang.WithMeta(v216, v217.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v422 := v421.Get() -v423 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v424 := v423.FindInternedVar(lang.NewSymbol("seq")) -if v424.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v424))) +v167 = v218 +} else { +v167 = nil } -v425 := v424.Get() -v426 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v427 := v426.FindInternedVar(lang.NewSymbol("concat")) -if v427.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v427))) +v135 = v167 } -v428 := v427.Get() -v429 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v430 := v429.FindInternedVar(lang.NewSymbol("list")) -if v430.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v430))) +v107 = v135 } -v431 := v430.Get() -v432 := lang.Apply(v431, []any{lang.NewSymbol("glojure.core/rest")}) -v433 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v434 := v433.FindInternedVar(lang.NewSymbol("list")) -if v434.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v434))) +v91 = v107 +} else { +v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v98 := v97.FindInternedVar(lang.NewSymbol("gensym")) +if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) } -v435 := v434.Get() -v436 := lang.Apply(v435, []any{v135}) -v437 := lang.Apply(v428, []any{v432, v436}) -v438 := lang.Apply(v425, []any{v437}) -v439 := lang.Apply(v422, []any{v438}) -v440 := lang.Apply(v415, []any{v419, v439}) -v441 := lang.Apply(v412, []any{v440}) -v442 := lang.Apply(v409, []any{v441}) -v443 := lang.Apply(v398, []any{v402, v406, v442}) -v444 := lang.Apply(v395, []any{v443}) -v445 := lang.Apply(v392, []any{v444}) -v446 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v447 := v446.FindInternedVar(lang.NewSymbol("list")) -if v447.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v447))) +v99 := v98.Get() +v100 := lang.Apply(v99, []any{"seq_"}) +var v96 any = v100 +_ = v96 +v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v103 := v102.FindInternedVar(lang.NewSymbol("with-meta")) +if v103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) } -v448 := v447.Get() -v449 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v450 := v449.FindInternedVar(lang.NewSymbol("seq")) -if v450.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v450))) +v104 := v103.Get() +v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v106 := v105.FindInternedVar(lang.NewSymbol("gensym")) +if v106.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) } -v451 := v450.Get() -v452 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v453 := v452.FindInternedVar(lang.NewSymbol("concat")) -if v453.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v453))) +v107 := v106.Get() +v108 := lang.Apply(v107, []any{"chunk_"}) +v109 := lang.NewMap(lang.NewKeyword("tag"), lang.NewSymbol("glojure.lang.IChunk")) +v110 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3239), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(3239), lang.NewKeyword("end-column"), int(72)) +v111, err := lang.WithMeta(v109, v110.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v454 := v453.Get() -v455 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v456 := v455.FindInternedVar(lang.NewSymbol("list")) -if v456.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v456))) +v112 := lang.Apply(v104, []any{v108, v111}) +var v101 any = v112 +_ = v101 +v114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v115 := v114.FindInternedVar(lang.NewSymbol("gensym")) +if v115.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v115))) } -v457 := v456.Get() -v458 := lang.Apply(v457, []any{lang.NewSymbol("recur")}) -v459 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v460 := v459.FindInternedVar(lang.NewSymbol("list")) -if v460.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v460))) +v116 := v115.Get() +v117 := lang.Apply(v116, []any{"count_"}) +var v113 any = v117 +_ = v113 +v119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v120 := v119.FindInternedVar(lang.NewSymbol("gensym")) +if v120.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v120))) } -v461 := v460.Get() -v462 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v463 := v462.FindInternedVar(lang.NewSymbol("seq")) -if v463.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v463))) +v121 := v120.Get() +v122 := lang.Apply(v121, []any{"i_"}) +var v118 any = v122 +_ = v118 +v124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v125 := v124.FindInternedVar(lang.NewSymbol("seq")) +if v125.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v125))) } -v464 := v463.Get() -v465 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v466 := v465.FindInternedVar(lang.NewSymbol("concat")) -if v466.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v466))) +v126 := v125.Get() +v127 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v128 := v127.FindInternedVar(lang.NewSymbol("concat")) +if v128.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v128))) } -v467 := v466.Get() -v468 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v469 := v468.FindInternedVar(lang.NewSymbol("list")) -if v469.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v469))) -} -v470 := v469.Get() -v471 := lang.Apply(v470, []any{lang.NewSymbol("glojure.core/rest")}) -v472 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v473 := v472.FindInternedVar(lang.NewSymbol("list")) -if v473.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v473))) -} -v474 := v473.Get() -v475 := lang.Apply(v474, []any{v135}) -v476 := lang.Apply(v467, []any{v471, v475}) -v477 := lang.Apply(v464, []any{v476}) -v478 := lang.Apply(v461, []any{v477}) -v479 := lang.Apply(v454, []any{v458, v478}) -v480 := lang.Apply(v451, []any{v479}) -v481 := lang.Apply(v448, []any{v480}) -v482 := lang.Apply(v381, []any{v385, v389, v445, v481}) -v483 := lang.Apply(v378, []any{v482}) -v484 := lang.Apply(v375, []any{v483}) -v485 := lang.Apply(v300, []any{v304, v372, v484}) -v486 := lang.Apply(v297, []any{v485}) -v294 = v486 -} else { -var v487 any -if lang.IsTruthy(lang.NewKeyword("else")) { -v488 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v489 := v488.FindInternedVar(lang.NewSymbol("seq")) -if v489.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v489))) -} -v490 := v489.Get() -v491 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v492 := v491.FindInternedVar(lang.NewSymbol("concat")) -if v492.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v492))) -} -v493 := v492.Get() -v494 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v495 := v494.FindInternedVar(lang.NewSymbol("list")) -if v495.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v495))) -} -v496 := v495.Get() -v497 := lang.Apply(v496, []any{lang.NewSymbol("glojure.core/cons")}) -v498 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v499 := v498.FindInternedVar(lang.NewSymbol("list")) -if v499.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v499))) -} -v500 := v499.Get() -v501 := lang.Apply(v500, []any{v6}) -v502 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v503 := v502.FindInternedVar(lang.NewSymbol("list")) -if v503.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v503))) -} -v504 := v503.Get() -v505 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v506 := v505.FindInternedVar(lang.NewSymbol("seq")) -if v506.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v506))) -} -v507 := v506.Get() -v508 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v509 := v508.FindInternedVar(lang.NewSymbol("concat")) -if v509.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v509))) -} -v510 := v509.Get() -v511 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v512 := v511.FindInternedVar(lang.NewSymbol("list")) -if v512.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v512))) -} -v513 := v512.Get() -v514 := lang.Apply(v513, []any{v130}) -v515 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v516 := v515.FindInternedVar(lang.NewSymbol("list")) -if v516.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v516))) -} -v517 := v516.Get() -v518 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v519 := v518.FindInternedVar(lang.NewSymbol("seq")) -if v519.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v519))) -} -v520 := v519.Get() -v521 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v522 := v521.FindInternedVar(lang.NewSymbol("concat")) -if v522.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v522))) -} -v523 := v522.Get() -v524 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v525 := v524.FindInternedVar(lang.NewSymbol("list")) -if v525.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v525))) -} -v526 := v525.Get() -v527 := lang.Apply(v526, []any{lang.NewSymbol("glojure.core/rest")}) -v528 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v529 := v528.FindInternedVar(lang.NewSymbol("list")) -if v529.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v529))) -} -v530 := v529.Get() -v531 := lang.Apply(v530, []any{v135}) -v532 := lang.Apply(v523, []any{v527, v531}) -v533 := lang.Apply(v520, []any{v532}) -v534 := lang.Apply(v517, []any{v533}) -v535 := lang.Apply(v510, []any{v514, v534}) -v536 := lang.Apply(v507, []any{v535}) -v537 := lang.Apply(v504, []any{v536}) -v538 := lang.Apply(v493, []any{v497, v501, v537}) -v539 := lang.Apply(v490, []any{v538}) -v487 = v539 -} else { -v487 = nil -} -v294 = v487 -} -v288 = v294 -} -v226 = v288 -} -v200 = v226 -} -v174 = v200 -} -return v174 -}) -v142 := v141 -_ = v142 +v129 := v128.Get() +v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v131 := v130.FindInternedVar(lang.NewSymbol("list")) +if v131.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) } -v142 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4672), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(4687), lang.NewKeyword("end-column"), int(73)) -v143, err := lang.WithMeta(v141, v142.(lang.IPersistentMap)) -if err != nil { - panic(err) +v132 := v131.Get() +v133 := lang.Apply(v132, []any{lang.NewSymbol("recur")}) +v134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v135 := v134.FindInternedVar(lang.NewSymbol("list")) +if v135.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v135))) } -var v140 any = v143 -_ = v140 -var v145 any -if lang.IsTruthy(v128) { -v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v147 := v146.FindInternedVar(lang.NewSymbol("seq")) -if v147.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) +v136 := v135.Get() +v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v138 := v137.FindInternedVar(lang.NewSymbol("seq")) +if v138.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) } -v148 := v147.Get() -v149 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v150 := v149.FindInternedVar(lang.NewSymbol("concat")) -if v150.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v150))) +v139 := v138.Get() +v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v141 := v140.FindInternedVar(lang.NewSymbol("concat")) +if v141.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) } -v151 := v150.Get() -v152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v153 := v152.FindInternedVar(lang.NewSymbol("list")) -if v153.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v153))) +v142 := v141.Get() +v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v144 := v143.FindInternedVar(lang.NewSymbol("list")) +if v144.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) } -v154 := v153.Get() -v155 := lang.Apply(v154, []any{lang.NewSymbol("glojure.core/fn")}) -v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v157 := v156.FindInternedVar(lang.NewSymbol("list")) -if v157.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) +v145 := v144.Get() +v146 := lang.Apply(v145, []any{lang.NewSymbol("glojure.core/next")}) +v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v148 := v147.FindInternedVar(lang.NewSymbol("list")) +if v148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) } -v158 := v157.Get() -v159 := lang.Apply(v158, []any{v130}) -v160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v161 := v160.FindInternedVar(lang.NewSymbol("list")) -if v161.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v161))) +v149 := v148.Get() +v150 := lang.Apply(v149, []any{v96}) +v151 := lang.Apply(v142, []any{v146, v150}) +v152 := lang.Apply(v139, []any{v151}) +v153 := lang.Apply(v136, []any{v152}) +v154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v155 := v154.FindInternedVar(lang.NewSymbol("list")) +if v155.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v155))) } -v162 := v161.Get() -v163 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v164 := v163.FindInternedVar(lang.NewSymbol("apply")) -if v164.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v164))) +v156 := v155.Get() +v157 := lang.Apply(v156, []any{nil}) +v158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v159 := v158.FindInternedVar(lang.NewSymbol("list")) +if v159.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v159))) } -v165 := v164.Get() -v166 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v167 := v166.FindInternedVar(lang.NewSymbol("vector")) -if v167.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v167))) +v160 := v159.Get() +v161 := lang.Apply(v160, []any{int64(0)}) +v162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v163 := v162.FindInternedVar(lang.NewSymbol("list")) +if v163.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v163))) } -v168 := v167.Get() +v164 := v163.Get() +v165 := lang.Apply(v164, []any{int64(0)}) +v166 := lang.Apply(v129, []any{v133, v153, v157, v161, v165}) +v167 := lang.Apply(v126, []any{v166}) +var v123 any = v167 +_ = v123 v169 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v170 := v169.FindInternedVar(lang.NewSymbol("seq")) +v170 := v169.FindInternedVar(lang.NewSymbol("nnext")) if v170.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v170))) } v171 := v170.Get() -v172 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v173 := v172.FindInternedVar(lang.NewSymbol("concat")) -if v173.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v173))) -} -v174 := v173.Get() -v175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v176 := v175.FindInternedVar(lang.NewSymbol("list")) -if v176.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v176))) +v172 := lang.Apply(v171, []any{v59}) +v173 := lang.Apply(v57, []any{v123, v172}) +var v168 any = v173 +_ = v168 +v175 := lang.Apply(v168, []any{int64(0)}) +var v174 any = v175 +_ = v174 +v177 := lang.Apply(v168, []any{int64(1)}) +var v176 any = v177 +_ = v176 +v179 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v180 := v179.FindInternedVar(lang.NewSymbol("seq")) +if v180.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v180))) } -v177 := v176.Get() -v178 := lang.Apply(v177, []any{v135}) -v179 := lang.Apply(v174, []any{v178}) -v180 := lang.Apply(v171, []any{v179}) -v181 := lang.Apply(v165, []any{v168, v180}) -v182 := lang.Apply(v162, []any{v181}) -v183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v184 := v183.FindInternedVar(lang.NewSymbol("list")) -if v184.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v184))) +v181 := v180.Get() +v182 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v183 := v182.FindInternedVar(lang.NewSymbol("concat")) +if v183.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v183))) } -v185 := v184.Get() -v186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v187 := v186.FindInternedVar(lang.NewSymbol("seq")) -if v187.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v187))) +v184 := v183.Get() +v185 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v186 := v185.FindInternedVar(lang.NewSymbol("list")) +if v186.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v186))) } -v188 := v187.Get() +v187 := v186.Get() +v188 := lang.Apply(v187, []any{lang.NewSymbol("recur")}) v189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v190 := v189.FindInternedVar(lang.NewSymbol("concat")) +v190 := v189.FindInternedVar(lang.NewSymbol("list")) if v190.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v190))) } v191 := v190.Get() -v192 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v193 := v192.FindInternedVar(lang.NewSymbol("list")) -if v193.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v193))) -} -v194 := v193.Get() -v195 := lang.Apply(v194, []any{lang.NewSymbol("glojure.core/lazy-seq")}) -v196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v197 := v196.FindInternedVar(lang.NewSymbol("list")) -if v197.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v197))) -} -v198 := v197.Get() -v199 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v200 := v199.FindInternedVar(lang.NewSymbol("seq")) -if v200.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v200))) -} -v201 := v200.Get() -v202 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v203 := v202.FindInternedVar(lang.NewSymbol("concat")) -if v203.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v203))) +v192 := lang.Apply(v191, []any{v96}) +v193 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v194 := v193.FindInternedVar(lang.NewSymbol("list")) +if v194.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v194))) } -v204 := v203.Get() -v205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v206 := v205.FindInternedVar(lang.NewSymbol("list")) -if v206.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v206))) +v195 := v194.Get() +v196 := lang.Apply(v195, []any{v101}) +v197 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v198 := v197.FindInternedVar(lang.NewSymbol("list")) +if v198.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v198))) } -v207 := v206.Get() -v208 := lang.Apply(v207, []any{lang.NewSymbol("glojure.core/loop")}) -v209 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v210 := v209.FindInternedVar(lang.NewSymbol("list")) -if v210.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v210))) +v199 := v198.Get() +v200 := lang.Apply(v199, []any{v113}) +v201 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v202 := v201.FindInternedVar(lang.NewSymbol("list")) +if v202.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v202))) } -v211 := v210.Get() -v212 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v213 := v212.FindInternedVar(lang.NewSymbol("apply")) -if v213.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v213))) +v203 := v202.Get() +v204 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v205 := v204.FindInternedVar(lang.NewSymbol("seq")) +if v205.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v205))) } -v214 := v213.Get() -v215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v216 := v215.FindInternedVar(lang.NewSymbol("vector")) -if v216.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v216))) +v206 := v205.Get() +v207 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v208 := v207.FindInternedVar(lang.NewSymbol("concat")) +if v208.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v208))) } -v217 := v216.Get() -v218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v219 := v218.FindInternedVar(lang.NewSymbol("seq")) -if v219.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v219))) +v209 := v208.Get() +v210 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v211 := v210.FindInternedVar(lang.NewSymbol("list")) +if v211.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v211))) } -v220 := v219.Get() -v221 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v222 := v221.FindInternedVar(lang.NewSymbol("concat")) -if v222.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v222))) +v212 := v211.Get() +v213 := lang.Apply(v212, []any{lang.NewSymbol("glojure.core/unchecked-inc")}) +v214 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v215 := v214.FindInternedVar(lang.NewSymbol("list")) +if v215.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v215))) } -v223 := v222.Get() +v216 := v215.Get() +v217 := lang.Apply(v216, []any{v118}) +v218 := lang.Apply(v209, []any{v213, v217}) +v219 := lang.Apply(v206, []any{v218}) +v220 := lang.Apply(v203, []any{v219}) +v221 := lang.Apply(v184, []any{v188, v192, v196, v200, v220}) +v222 := lang.Apply(v181, []any{v221}) +var v178 any = v222 +_ = v178 v224 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v225 := v224.FindInternedVar(lang.NewSymbol("list")) +v225 := v224.FindInternedVar(lang.NewSymbol("nnext")) if v225.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v225))) } v226 := v225.Get() -v227 := lang.Apply(v226, []any{v135}) -v228 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v229 := v228.FindInternedVar(lang.NewSymbol("list")) -if v229.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v229))) +v227 := lang.Apply(v226, []any{v59}) +v228 := lang.Apply(v57, []any{v178, v227}) +var v223 any = v228 +_ = v223 +v230 := lang.Apply(v223, []any{int64(1)}) +var v229 any = v230 +_ = v229 +v232 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v233 := v232.FindInternedVar(lang.NewSymbol("seq")) +if v233.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v233))) } -v230 := v229.Get() -v231 := lang.Apply(v230, []any{v135}) -v232 := lang.Apply(v223, []any{v227, v231}) -v233 := lang.Apply(v220, []any{v232}) -v234 := lang.Apply(v214, []any{v217, v233}) -v235 := lang.Apply(v211, []any{v234}) -v236 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v237 := v236.FindInternedVar(lang.NewSymbol("list")) -if v237.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v237))) +v234 := v233.Get() +v235 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v236 := v235.FindInternedVar(lang.NewSymbol("concat")) +if v236.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v236))) } -v238 := v237.Get() -v239 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v240 := v239.FindInternedVar(lang.NewSymbol("seq")) -if v240.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v240))) +v237 := v236.Get() +v238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v239 := v238.FindInternedVar(lang.NewSymbol("list")) +if v239.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v239))) } -v241 := v240.Get() +v240 := v239.Get() +v241 := lang.Apply(v240, []any{lang.NewSymbol("glojure.core/loop")}) v242 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v243 := v242.FindInternedVar(lang.NewSymbol("concat")) +v243 := v242.FindInternedVar(lang.NewSymbol("list")) if v243.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v243))) } v244 := v243.Get() v245 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v246 := v245.FindInternedVar(lang.NewSymbol("list")) +v246 := v245.FindInternedVar(lang.NewSymbol("apply")) if v246.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v246))) } v247 := v246.Get() -v248 := lang.Apply(v247, []any{lang.NewSymbol("glojure.core/when-first")}) -v249 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v250 := v249.FindInternedVar(lang.NewSymbol("list")) -if v250.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v250))) +v248 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v249 := v248.FindInternedVar(lang.NewSymbol("vector")) +if v249.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v249))) } -v251 := v250.Get() -v252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v253 := v252.FindInternedVar(lang.NewSymbol("apply")) -if v253.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v253))) +v250 := v249.Get() +v251 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v252 := v251.FindInternedVar(lang.NewSymbol("seq")) +if v252.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v252))) } -v254 := v253.Get() -v255 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v256 := v255.FindInternedVar(lang.NewSymbol("vector")) -if v256.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v256))) +v253 := v252.Get() +v254 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v255 := v254.FindInternedVar(lang.NewSymbol("concat")) +if v255.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v255))) } -v257 := v256.Get() -v258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v259 := v258.FindInternedVar(lang.NewSymbol("seq")) -if v259.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v259))) +v256 := v255.Get() +v257 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v258 := v257.FindInternedVar(lang.NewSymbol("list")) +if v258.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v258))) } -v260 := v259.Get() +v259 := v258.Get() +v260 := lang.Apply(v259, []any{v96}) v261 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v262 := v261.FindInternedVar(lang.NewSymbol("concat")) +v262 := v261.FindInternedVar(lang.NewSymbol("list")) if v262.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v262))) } v263 := v262.Get() v264 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v265 := v264.FindInternedVar(lang.NewSymbol("list")) +v265 := v264.FindInternedVar(lang.NewSymbol("seq")) if v265.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v265))) } v266 := v265.Get() -v267 := lang.Apply(v266, []any{v99}) -v268 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v269 := v268.FindInternedVar(lang.NewSymbol("list")) -if v269.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v269))) +v267 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v268 := v267.FindInternedVar(lang.NewSymbol("concat")) +if v268.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v268))) } -v270 := v269.Get() -v271 := lang.Apply(v270, []any{v135}) -v272 := lang.Apply(v263, []any{v267, v271}) -v273 := lang.Apply(v260, []any{v272}) -v274 := lang.Apply(v254, []any{v257, v273}) -v275 := lang.Apply(v251, []any{v274}) -v276 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v277 := v276.FindInternedVar(lang.NewSymbol("list")) -if v277.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v277))) +v269 := v268.Get() +v270 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v271 := v270.FindInternedVar(lang.NewSymbol("list")) +if v271.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v271))) } -v278 := v277.Get() -v279 := lang.Apply(v140, []any{v111}) -v280 := lang.Apply(v278, []any{v279}) -v281 := lang.Apply(v244, []any{v248, v275, v280}) -v282 := lang.Apply(v241, []any{v281}) -v283 := lang.Apply(v238, []any{v282}) -v284 := lang.Apply(v204, []any{v208, v235, v283}) -v285 := lang.Apply(v201, []any{v284}) -v286 := lang.Apply(v198, []any{v285}) -v287 := lang.Apply(v191, []any{v195, v286}) -v288 := lang.Apply(v188, []any{v287}) -v289 := lang.Apply(v185, []any{v288}) -v290 := lang.Apply(v151, []any{v155, v159, v182, v289}) -v291 := lang.Apply(v148, []any{v290}) -v145 = v291 -} else { +v272 := v271.Get() +v273 := lang.Apply(v272, []any{lang.NewSymbol("glojure.core/seq")}) +v274 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v275 := v274.FindInternedVar(lang.NewSymbol("list")) +if v275.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v275))) +} +v276 := v275.Get() +v277 := lang.Apply(v276, []any{v85}) +v278 := lang.Apply(v269, []any{v273, v277}) +v279 := lang.Apply(v266, []any{v278}) +v280 := lang.Apply(v263, []any{v279}) +v281 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v282 := v281.FindInternedVar(lang.NewSymbol("list")) +if v282.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v282))) +} +v283 := v282.Get() +v284 := lang.Apply(v283, []any{v101}) +v285 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v286 := v285.FindInternedVar(lang.NewSymbol("list")) +if v286.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v286))) +} +v287 := v286.Get() +v288 := lang.Apply(v287, []any{nil}) +v289 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v290 := v289.FindInternedVar(lang.NewSymbol("list")) +if v290.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v290))) +} +v291 := v290.Get() +v292 := lang.Apply(v291, []any{v113}) v293 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v294 := v293.FindInternedVar(lang.NewSymbol("gensym")) +v294 := v293.FindInternedVar(lang.NewSymbol("list")) if v294.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v294))) } v295 := v294.Get() -v296 := lang.Apply(v295, []any{"i__"}) -var v292 any = v296 -_ = v292 -v298 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v299 := v298.FindInternedVar(lang.NewSymbol("gensym")) -if v299.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v299))) +v296 := lang.Apply(v295, []any{int64(0)}) +v297 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v298 := v297.FindInternedVar(lang.NewSymbol("list")) +if v298.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v298))) } -v300 := v299.Get() -v301 := lang.Apply(v300, []any{"b__"}) -var v297 any = v301 -_ = v297 -var v303 lang.FnFunc -{ // function do-cmod -v303 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v305 := args[0] -var v306 any = v305 -_ = v306 -v308 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v309 := v308.FindInternedVar(lang.NewSymbol("seq")) -if v309.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v309))) +v299 := v298.Get() +v300 := lang.Apply(v299, []any{v118}) +v301 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v302 := v301.FindInternedVar(lang.NewSymbol("list")) +if v302.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v302))) } -v310 := v309.Get() -v311 := lang.Apply(v310, []any{v306}) -var v307 any = v311 -_ = v307 -v313 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v314 := v313.FindInternedVar(lang.NewSymbol("first")) -if v314.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v314))) +v303 := v302.Get() +v304 := lang.Apply(v303, []any{int64(0)}) +v305 := lang.Apply(v256, []any{v260, v280, v284, v288, v292, v296, v300, v304}) +v306 := lang.Apply(v253, []any{v305}) +v307 := lang.Apply(v247, []any{v250, v306}) +v308 := lang.Apply(v244, []any{v307}) +v309 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v310 := v309.FindInternedVar(lang.NewSymbol("list")) +if v310.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v310))) } -v315 := v314.Get() -v316 := lang.Apply(v315, []any{v307}) -var v312 any = v316 -_ = v312 +v311 := v310.Get() +v312 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v313 := v312.FindInternedVar(lang.NewSymbol("seq")) +if v313.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v313))) +} +v314 := v313.Get() +v315 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v316 := v315.FindInternedVar(lang.NewSymbol("concat")) +if v316.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v316))) +} +v317 := v316.Get() v318 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v319 := v318.FindInternedVar(lang.NewSymbol("next")) +v319 := v318.FindInternedVar(lang.NewSymbol("list")) if v319.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v319))) } v320 := v319.Get() -v321 := lang.Apply(v320, []any{v317}) -var v317 any = v321 -_ = v317 -var v322 any = v312 -_ = v322 -v324 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v325 := v324.FindInternedVar(lang.NewSymbol("nth")) -if v325.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v325))) +v321 := lang.Apply(v320, []any{lang.NewSymbol("if")}) +v322 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v323 := v322.FindInternedVar(lang.NewSymbol("list")) +if v323.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v323))) } -v326 := v325.Get() -v327 := lang.Apply(v326, []any{v322, int64(0), nil}) -var v323 any = v327 -_ = v323 -v329 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v330 := v329.FindInternedVar(lang.NewSymbol("nth")) -if v330.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v330))) +v324 := v323.Get() +v325 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v326 := v325.FindInternedVar(lang.NewSymbol("seq")) +if v326.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v326))) } -v331 := v330.Get() -v332 := lang.Apply(v331, []any{v322, int64(1), nil}) -var v328 any = v332 -_ = v328 -var v333 any = v322 -_ = v333 -var v334 any = v317 -_ = v334 -var v336 any -v337 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v338 := v337.FindInternedVar(lang.NewSymbol("=")) -if v338.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v338))) +v327 := v326.Get() +v328 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v329 := v328.FindInternedVar(lang.NewSymbol("concat")) +if v329.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v329))) } -v339 := v338.Get() -v340 := lang.Apply(v339, []any{v323, lang.NewKeyword("let")}) -if lang.IsTruthy(v340) { -v341 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v342 := v341.FindInternedVar(lang.NewSymbol("seq")) -if v342.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v342))) +v330 := v329.Get() +v331 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v332 := v331.FindInternedVar(lang.NewSymbol("list")) +if v332.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v332))) } -v343 := v342.Get() -v344 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v345 := v344.FindInternedVar(lang.NewSymbol("concat")) -if v345.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v345))) +v333 := v332.Get() +v334 := lang.Apply(v333, []any{lang.NewSymbol("glojure.core/<")}) +v335 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v336 := v335.FindInternedVar(lang.NewSymbol("list")) +if v336.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v336))) } -v346 := v345.Get() -v347 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v348 := v347.FindInternedVar(lang.NewSymbol("list")) -if v348.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v348))) +v337 := v336.Get() +v338 := lang.Apply(v337, []any{v118}) +v339 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v340 := v339.FindInternedVar(lang.NewSymbol("list")) +if v340.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v340))) } -v349 := v348.Get() -v350 := lang.Apply(v349, []any{lang.NewSymbol("glojure.core/let")}) -v351 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v352 := v351.FindInternedVar(lang.NewSymbol("list")) -if v352.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v352))) +v341 := v340.Get() +v342 := lang.Apply(v341, []any{v113}) +v343 := lang.Apply(v330, []any{v334, v338, v342}) +v344 := lang.Apply(v327, []any{v343}) +v345 := lang.Apply(v324, []any{v344}) +v346 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v347 := v346.FindInternedVar(lang.NewSymbol("list")) +if v347.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v347))) } -v353 := v352.Get() -v354 := lang.Apply(v353, []any{v328}) +v348 := v347.Get() +v349 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v350 := v349.FindInternedVar(lang.NewSymbol("seq")) +if v350.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v350))) +} +v351 := v350.Get() +v352 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v353 := v352.FindInternedVar(lang.NewSymbol("concat")) +if v353.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v353))) +} +v354 := v353.Get() v355 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v356 := v355.FindInternedVar(lang.NewSymbol("list")) if v356.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v356))) } v357 := v356.Get() -v358 := lang.Apply(v304, []any{v334}) -v359 := lang.Apply(v357, []any{v358}) -v360 := lang.Apply(v346, []any{v350, v354, v359}) -v361 := lang.Apply(v343, []any{v360}) -v336 = v361 -} else { -var v362 any -v363 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v364 := v363.FindInternedVar(lang.NewSymbol("=")) -if v364.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v364))) +v358 := lang.Apply(v357, []any{lang.NewSymbol("glojure.core/let")}) +v359 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v360 := v359.FindInternedVar(lang.NewSymbol("list")) +if v360.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v360))) } -v365 := v364.Get() -v366 := lang.Apply(v365, []any{v323, lang.NewKeyword("while")}) -if lang.IsTruthy(v366) { -v367 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v368 := v367.FindInternedVar(lang.NewSymbol("seq")) -if v368.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v368))) +v361 := v360.Get() +v362 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v363 := v362.FindInternedVar(lang.NewSymbol("apply")) +if v363.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v363))) } -v369 := v368.Get() -v370 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v371 := v370.FindInternedVar(lang.NewSymbol("concat")) -if v371.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v371))) +v364 := v363.Get() +v365 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v366 := v365.FindInternedVar(lang.NewSymbol("vector")) +if v366.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v366))) } -v372 := v371.Get() -v373 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v374 := v373.FindInternedVar(lang.NewSymbol("list")) -if v374.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v374))) +v367 := v366.Get() +v368 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v369 := v368.FindInternedVar(lang.NewSymbol("seq")) +if v369.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v369))) } -v375 := v374.Get() -v376 := lang.Apply(v375, []any{lang.NewSymbol("glojure.core/when")}) -v377 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v378 := v377.FindInternedVar(lang.NewSymbol("list")) -if v378.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v378))) +v370 := v369.Get() +v371 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v372 := v371.FindInternedVar(lang.NewSymbol("concat")) +if v372.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v372))) } -v379 := v378.Get() -v380 := lang.Apply(v379, []any{v328}) +v373 := v372.Get() +v374 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v375 := v374.FindInternedVar(lang.NewSymbol("list")) +if v375.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v375))) +} +v376 := v375.Get() +v377 := lang.Apply(v376, []any{v80}) +v378 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v379 := v378.FindInternedVar(lang.NewSymbol("list")) +if v379.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v379))) +} +v380 := v379.Get() v381 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v382 := v381.FindInternedVar(lang.NewSymbol("list")) +v382 := v381.FindInternedVar(lang.NewSymbol("seq")) if v382.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v382))) } v383 := v382.Get() -v384 := lang.Apply(v304, []any{v334}) -v385 := lang.Apply(v383, []any{v384}) -v386 := lang.Apply(v372, []any{v376, v380, v385}) -v387 := lang.Apply(v369, []any{v386}) -v362 = v387 -} else { -var v388 any -v389 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v390 := v389.FindInternedVar(lang.NewSymbol("=")) -if v390.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v390))) -} -v391 := v390.Get() -v392 := lang.Apply(v391, []any{v323, lang.NewKeyword("when")}) -if lang.IsTruthy(v392) { -v393 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v394 := v393.FindInternedVar(lang.NewSymbol("seq")) -if v394.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v394))) +v384 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v385 := v384.FindInternedVar(lang.NewSymbol("concat")) +if v385.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v385))) } -v395 := v394.Get() -v396 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v397 := v396.FindInternedVar(lang.NewSymbol("concat")) -if v397.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v397))) +v386 := v385.Get() +v387 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v388 := v387.FindInternedVar(lang.NewSymbol("list")) +if v388.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v388))) } -v398 := v397.Get() -v399 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v400 := v399.FindInternedVar(lang.NewSymbol("list")) -if v400.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v400))) +v389 := v388.Get() +v390 := lang.Apply(v389, []any{lang.NewSymbol(".nth")}) +v391 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v392 := v391.FindInternedVar(lang.NewSymbol("list")) +if v392.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v392))) } -v401 := v400.Get() -v402 := lang.Apply(v401, []any{lang.NewSymbol("if")}) -v403 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v404 := v403.FindInternedVar(lang.NewSymbol("list")) -if v404.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v404))) +v393 := v392.Get() +v394 := lang.Apply(v393, []any{v101}) +v395 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v396 := v395.FindInternedVar(lang.NewSymbol("list")) +if v396.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v396))) } -v405 := v404.Get() -v406 := lang.Apply(v405, []any{v328}) -v407 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v408 := v407.FindInternedVar(lang.NewSymbol("list")) -if v408.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v408))) +v397 := v396.Get() +v398 := lang.Apply(v397, []any{v118}) +v399 := lang.Apply(v386, []any{v390, v394, v398}) +v400 := lang.Apply(v383, []any{v399}) +v401 := lang.Apply(v380, []any{v400}) +v402 := lang.Apply(v373, []any{v377, v401}) +v403 := lang.Apply(v370, []any{v402}) +v404 := lang.Apply(v364, []any{v367, v403}) +v405 := lang.Apply(v361, []any{v404}) +v406 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v407 := v406.FindInternedVar(lang.NewSymbol("list")) +if v407.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v407))) } -v409 := v408.Get() -v410 := lang.Apply(v304, []any{v334}) -v411 := lang.Apply(v409, []any{v410}) -v412 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v413 := v412.FindInternedVar(lang.NewSymbol("list")) -if v413.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v413))) +v408 := v407.Get() +v409 := lang.Apply(v408, []any{v229}) +var v410 any +if lang.IsTruthy(v174) { +v411 := lang.NewVector(v178) +v412 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3256), lang.NewKeyword("column"), int(48), lang.NewKeyword("end-line"), int(3256), lang.NewKeyword("end-column"), int(62)) +v413, err := lang.WithMeta(v411, v412.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v414 := v413.Get() -v415 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v416 := v415.FindInternedVar(lang.NewSymbol("seq")) -if v416.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v416))) +v410 = v413 +} else { +v410 = nil } -v417 := v416.Get() -v418 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v419 := v418.FindInternedVar(lang.NewSymbol("concat")) -if v419.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v419))) +v414 := lang.Apply(v354, []any{v358, v405, v409, v410}) +v415 := lang.Apply(v351, []any{v414}) +v416 := lang.Apply(v348, []any{v415}) +v417 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v418 := v417.FindInternedVar(lang.NewSymbol("list")) +if v418.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v418))) } -v420 := v419.Get() -v421 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v422 := v421.FindInternedVar(lang.NewSymbol("list")) -if v422.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v422))) +v419 := v418.Get() +v420 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v421 := v420.FindInternedVar(lang.NewSymbol("seq")) +if v421.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v421))) } -v423 := v422.Get() -v424 := lang.Apply(v423, []any{lang.NewSymbol("recur")}) -v425 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v426 := v425.FindInternedVar(lang.NewSymbol("list")) -if v426.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v426))) +v422 := v421.Get() +v423 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v424 := v423.FindInternedVar(lang.NewSymbol("concat")) +if v424.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v424))) } -v427 := v426.Get() -v428 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v429 := v428.FindInternedVar(lang.NewSymbol("seq")) -if v429.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v429))) +v425 := v424.Get() +v426 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v427 := v426.FindInternedVar(lang.NewSymbol("list")) +if v427.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v427))) } -v430 := v429.Get() -v431 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v432 := v431.FindInternedVar(lang.NewSymbol("concat")) -if v432.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v432))) +v428 := v427.Get() +v429 := lang.Apply(v428, []any{lang.NewSymbol("glojure.core/when-let")}) +v430 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v431 := v430.FindInternedVar(lang.NewSymbol("list")) +if v431.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v431))) } -v433 := v432.Get() -v434 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v435 := v434.FindInternedVar(lang.NewSymbol("list")) -if v435.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v435))) +v432 := v431.Get() +v433 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v434 := v433.FindInternedVar(lang.NewSymbol("apply")) +if v434.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v434))) } -v436 := v435.Get() -v437 := lang.Apply(v436, []any{lang.NewSymbol("glojure.core/unchecked-inc")}) -v438 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v439 := v438.FindInternedVar(lang.NewSymbol("list")) -if v439.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v439))) +v435 := v434.Get() +v436 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v437 := v436.FindInternedVar(lang.NewSymbol("vector")) +if v437.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v437))) } -v440 := v439.Get() -v441 := lang.Apply(v440, []any{v292}) -v442 := lang.Apply(v433, []any{v437, v441}) -v443 := lang.Apply(v430, []any{v442}) -v444 := lang.Apply(v427, []any{v443}) -v445 := lang.Apply(v420, []any{v424, v444}) -v446 := lang.Apply(v417, []any{v445}) -v447 := lang.Apply(v414, []any{v446}) -v448 := lang.Apply(v398, []any{v402, v406, v411, v447}) -v449 := lang.Apply(v395, []any{v448}) -v388 = v449 -} else { -var v450 any -v451 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v452 := v451.FindInternedVar(lang.NewSymbol("keyword?")) -if v452.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v452))) +v438 := v437.Get() +v439 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v440 := v439.FindInternedVar(lang.NewSymbol("seq")) +if v440.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v440))) } -v453 := v452.Get() -v454 := lang.Apply(v453, []any{v323}) -if lang.IsTruthy(v454) { -v455 := lang.Apply(v59, []any{"Invalid 'for' keyword ", v323}) -v450 = v455 -} else { -var v456 any -if lang.IsTruthy(lang.NewKeyword("else")) { -v457 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v458 := v457.FindInternedVar(lang.NewSymbol("seq")) -if v458.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v458))) +v441 := v440.Get() +v442 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v443 := v442.FindInternedVar(lang.NewSymbol("concat")) +if v443.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v443))) } -v459 := v458.Get() -v460 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v461 := v460.FindInternedVar(lang.NewSymbol("concat")) -if v461.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v461))) +v444 := v443.Get() +v445 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v446 := v445.FindInternedVar(lang.NewSymbol("list")) +if v446.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v446))) } -v462 := v461.Get() -v463 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v464 := v463.FindInternedVar(lang.NewSymbol("list")) -if v464.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v464))) +v447 := v446.Get() +v448 := lang.Apply(v447, []any{v96}) +v449 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v450 := v449.FindInternedVar(lang.NewSymbol("list")) +if v450.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v450))) } -v465 := v464.Get() -v466 := lang.Apply(v465, []any{lang.NewSymbol("do")}) -v467 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v468 := v467.FindInternedVar(lang.NewSymbol("list")) -if v468.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v468))) +v451 := v450.Get() +v452 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v453 := v452.FindInternedVar(lang.NewSymbol("seq")) +if v453.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v453))) } -v469 := v468.Get() -v470 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v471 := v470.FindInternedVar(lang.NewSymbol("seq")) -if v471.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v471))) +v454 := v453.Get() +v455 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v456 := v455.FindInternedVar(lang.NewSymbol("concat")) +if v456.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v456))) } -v472 := v471.Get() +v457 := v456.Get() +v458 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v459 := v458.FindInternedVar(lang.NewSymbol("list")) +if v459.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v459))) +} +v460 := v459.Get() +v461 := lang.Apply(v460, []any{lang.NewSymbol("glojure.core/seq")}) +v462 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v463 := v462.FindInternedVar(lang.NewSymbol("list")) +if v463.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v463))) +} +v464 := v463.Get() +v465 := lang.Apply(v464, []any{v96}) +v466 := lang.Apply(v457, []any{v461, v465}) +v467 := lang.Apply(v454, []any{v466}) +v468 := lang.Apply(v451, []any{v467}) +v469 := lang.Apply(v444, []any{v448, v468}) +v470 := lang.Apply(v441, []any{v469}) +v471 := lang.Apply(v435, []any{v438, v470}) +v472 := lang.Apply(v432, []any{v471}) v473 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v474 := v473.FindInternedVar(lang.NewSymbol("concat")) +v474 := v473.FindInternedVar(lang.NewSymbol("list")) if v474.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v474))) } v475 := v474.Get() v476 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v477 := v476.FindInternedVar(lang.NewSymbol("list")) +v477 := v476.FindInternedVar(lang.NewSymbol("seq")) if v477.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v477))) } v478 := v477.Get() -v479 := lang.Apply(v478, []any{lang.NewSymbol("glojure.core/chunk-append")}) -v480 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v481 := v480.FindInternedVar(lang.NewSymbol("list")) -if v481.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v481))) +v479 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v480 := v479.FindInternedVar(lang.NewSymbol("concat")) +if v480.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v480))) } -v482 := v481.Get() -v483 := lang.Apply(v482, []any{v297}) -v484 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v485 := v484.FindInternedVar(lang.NewSymbol("list")) -if v485.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v485))) +v481 := v480.Get() +v482 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v483 := v482.FindInternedVar(lang.NewSymbol("list")) +if v483.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v483))) } -v486 := v485.Get() -v487 := lang.Apply(v486, []any{v6}) -v488 := lang.Apply(v475, []any{v479, v483, v487}) -v489 := lang.Apply(v472, []any{v488}) -v490 := lang.Apply(v469, []any{v489}) -v491 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v492 := v491.FindInternedVar(lang.NewSymbol("list")) -if v492.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v492))) +v484 := v483.Get() +v485 := lang.Apply(v484, []any{lang.NewSymbol("if")}) +v486 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v487 := v486.FindInternedVar(lang.NewSymbol("list")) +if v487.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v487))) } -v493 := v492.Get() -v494 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v495 := v494.FindInternedVar(lang.NewSymbol("seq")) -if v495.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v495))) +v488 := v487.Get() +v489 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v490 := v489.FindInternedVar(lang.NewSymbol("seq")) +if v490.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v490))) } -v496 := v495.Get() -v497 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v498 := v497.FindInternedVar(lang.NewSymbol("concat")) -if v498.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v498))) +v491 := v490.Get() +v492 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v493 := v492.FindInternedVar(lang.NewSymbol("concat")) +if v493.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v493))) } -v499 := v498.Get() -v500 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v501 := v500.FindInternedVar(lang.NewSymbol("list")) -if v501.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v501))) +v494 := v493.Get() +v495 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v496 := v495.FindInternedVar(lang.NewSymbol("list")) +if v496.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v496))) } -v502 := v501.Get() -v503 := lang.Apply(v502, []any{lang.NewSymbol("recur")}) -v504 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v505 := v504.FindInternedVar(lang.NewSymbol("list")) -if v505.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v505))) +v497 := v496.Get() +v498 := lang.Apply(v497, []any{lang.NewSymbol("glojure.core/chunked-seq?")}) +v499 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v500 := v499.FindInternedVar(lang.NewSymbol("list")) +if v500.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v500))) } -v506 := v505.Get() -v507 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v508 := v507.FindInternedVar(lang.NewSymbol("seq")) -if v508.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v508))) +v501 := v500.Get() +v502 := lang.Apply(v501, []any{v96}) +v503 := lang.Apply(v494, []any{v498, v502}) +v504 := lang.Apply(v491, []any{v503}) +v505 := lang.Apply(v488, []any{v504}) +v506 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v507 := v506.FindInternedVar(lang.NewSymbol("list")) +if v507.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v507))) } -v509 := v508.Get() -v510 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v511 := v510.FindInternedVar(lang.NewSymbol("concat")) -if v511.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v511))) +v508 := v507.Get() +v509 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v510 := v509.FindInternedVar(lang.NewSymbol("seq")) +if v510.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v510))) } -v512 := v511.Get() -v513 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v514 := v513.FindInternedVar(lang.NewSymbol("list")) -if v514.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v514))) +v511 := v510.Get() +v512 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v513 := v512.FindInternedVar(lang.NewSymbol("concat")) +if v513.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v513))) } -v515 := v514.Get() -v516 := lang.Apply(v515, []any{lang.NewSymbol("glojure.core/unchecked-inc")}) -v517 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v518 := v517.FindInternedVar(lang.NewSymbol("list")) -if v518.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v518))) +v514 := v513.Get() +v515 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v516 := v515.FindInternedVar(lang.NewSymbol("list")) +if v516.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v516))) } -v519 := v518.Get() -v520 := lang.Apply(v519, []any{v292}) -v521 := lang.Apply(v512, []any{v516, v520}) -v522 := lang.Apply(v509, []any{v521}) -v523 := lang.Apply(v506, []any{v522}) -v524 := lang.Apply(v499, []any{v503, v523}) -v525 := lang.Apply(v496, []any{v524}) -v526 := lang.Apply(v493, []any{v525}) -v527 := lang.Apply(v462, []any{v466, v490, v526}) -v528 := lang.Apply(v459, []any{v527}) -v456 = v528 -} else { -v456 = nil +v517 := v516.Get() +v518 := lang.Apply(v517, []any{lang.NewSymbol("glojure.core/let")}) +v519 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v520 := v519.FindInternedVar(lang.NewSymbol("list")) +if v520.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v520))) } -v450 = v456 +v521 := v520.Get() +v522 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v523 := v522.FindInternedVar(lang.NewSymbol("apply")) +if v523.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v523))) } -v388 = v450 +v524 := v523.Get() +v525 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v526 := v525.FindInternedVar(lang.NewSymbol("vector")) +if v526.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v526))) } -v362 = v388 +v527 := v526.Get() +v528 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v529 := v528.FindInternedVar(lang.NewSymbol("seq")) +if v529.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v529))) } -v336 = v362 +v530 := v529.Get() +v531 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v532 := v531.FindInternedVar(lang.NewSymbol("concat")) +if v532.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v532))) } -return v336 -}) -v304 := v303 -_ = v304 +v533 := v532.Get() +v534 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v535 := v534.FindInternedVar(lang.NewSymbol("list")) +if v535.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v535))) } -v304 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4698), lang.NewKeyword("column"), int(39), lang.NewKeyword("end-line"), int(4710), lang.NewKeyword("end-column"), int(79)) -v305, err := lang.WithMeta(v303, v304.(lang.IPersistentMap)) -if err != nil { - panic(err) +v536 := v535.Get() +v537 := lang.Apply(v536, []any{lang.NewSymbol("c__0__auto__")}) +v538 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v539 := v538.FindInternedVar(lang.NewSymbol("list")) +if v539.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v539))) } -var v302 any = v305 -_ = v302 -v307 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v308 := v307.FindInternedVar(lang.NewSymbol("seq")) -if v308.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v308))) +v540 := v539.Get() +v541 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v542 := v541.FindInternedVar(lang.NewSymbol("seq")) +if v542.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v542))) } -v309 := v308.Get() -v310 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v311 := v310.FindInternedVar(lang.NewSymbol("concat")) -if v311.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v311))) +v543 := v542.Get() +v544 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v545 := v544.FindInternedVar(lang.NewSymbol("concat")) +if v545.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v545))) } -v312 := v311.Get() -v313 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v314 := v313.FindInternedVar(lang.NewSymbol("list")) -if v314.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v314))) +v546 := v545.Get() +v547 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v548 := v547.FindInternedVar(lang.NewSymbol("list")) +if v548.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v548))) } -v315 := v314.Get() -v316 := lang.Apply(v315, []any{lang.NewSymbol("glojure.core/fn")}) -v317 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v318 := v317.FindInternedVar(lang.NewSymbol("list")) -if v318.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v318))) +v549 := v548.Get() +v550 := lang.Apply(v549, []any{lang.NewSymbol("glojure.core/chunk-first")}) +v551 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v552 := v551.FindInternedVar(lang.NewSymbol("list")) +if v552.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v552))) } -v319 := v318.Get() -v320 := lang.Apply(v319, []any{v130}) -v321 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v322 := v321.FindInternedVar(lang.NewSymbol("list")) -if v322.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v322))) +v553 := v552.Get() +v554 := lang.Apply(v553, []any{v96}) +v555 := lang.Apply(v546, []any{v550, v554}) +v556 := lang.Apply(v543, []any{v555}) +v557 := lang.Apply(v540, []any{v556}) +v558 := lang.Apply(v533, []any{v537, v557}) +v559 := lang.Apply(v530, []any{v558}) +v560 := lang.Apply(v524, []any{v527, v559}) +v561 := lang.Apply(v521, []any{v560}) +v562 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v563 := v562.FindInternedVar(lang.NewSymbol("list")) +if v563.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v563))) } -v323 := v322.Get() -v324 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v325 := v324.FindInternedVar(lang.NewSymbol("apply")) -if v325.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v325))) +v564 := v563.Get() +v565 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v566 := v565.FindInternedVar(lang.NewSymbol("seq")) +if v566.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v566))) } -v326 := v325.Get() -v327 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v328 := v327.FindInternedVar(lang.NewSymbol("vector")) -if v328.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v328))) +v567 := v566.Get() +v568 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v569 := v568.FindInternedVar(lang.NewSymbol("concat")) +if v569.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v569))) } -v329 := v328.Get() -v330 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v331 := v330.FindInternedVar(lang.NewSymbol("seq")) -if v331.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v331))) +v570 := v569.Get() +v571 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v572 := v571.FindInternedVar(lang.NewSymbol("list")) +if v572.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v572))) } -v332 := v331.Get() -v333 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v334 := v333.FindInternedVar(lang.NewSymbol("concat")) -if v334.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v334))) +v573 := v572.Get() +v574 := lang.Apply(v573, []any{lang.NewSymbol("recur")}) +v575 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v576 := v575.FindInternedVar(lang.NewSymbol("list")) +if v576.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v576))) } -v335 := v334.Get() -v336 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v337 := v336.FindInternedVar(lang.NewSymbol("list")) -if v337.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v337))) +v577 := v576.Get() +v578 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v579 := v578.FindInternedVar(lang.NewSymbol("seq")) +if v579.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v579))) } -v338 := v337.Get() -v339 := lang.Apply(v338, []any{v135}) -v340 := lang.Apply(v335, []any{v339}) -v341 := lang.Apply(v332, []any{v340}) -v342 := lang.Apply(v326, []any{v329, v341}) -v343 := lang.Apply(v323, []any{v342}) -v344 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v345 := v344.FindInternedVar(lang.NewSymbol("list")) -if v345.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v345))) +v580 := v579.Get() +v581 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v582 := v581.FindInternedVar(lang.NewSymbol("concat")) +if v582.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v582))) } -v346 := v345.Get() -v347 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v348 := v347.FindInternedVar(lang.NewSymbol("seq")) -if v348.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v348))) +v583 := v582.Get() +v584 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v585 := v584.FindInternedVar(lang.NewSymbol("list")) +if v585.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v585))) } -v349 := v348.Get() -v350 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v351 := v350.FindInternedVar(lang.NewSymbol("concat")) -if v351.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v351))) +v586 := v585.Get() +v587 := lang.Apply(v586, []any{lang.NewSymbol("glojure.core/chunk-rest")}) +v588 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v589 := v588.FindInternedVar(lang.NewSymbol("list")) +if v589.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v589))) } -v352 := v351.Get() -v353 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v354 := v353.FindInternedVar(lang.NewSymbol("list")) -if v354.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v354))) +v590 := v589.Get() +v591 := lang.Apply(v590, []any{v96}) +v592 := lang.Apply(v583, []any{v587, v591}) +v593 := lang.Apply(v580, []any{v592}) +v594 := lang.Apply(v577, []any{v593}) +v595 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v596 := v595.FindInternedVar(lang.NewSymbol("list")) +if v596.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v596))) } -v355 := v354.Get() -v356 := lang.Apply(v355, []any{lang.NewSymbol("glojure.core/lazy-seq")}) -v357 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v358 := v357.FindInternedVar(lang.NewSymbol("list")) -if v358.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v358))) +v597 := v596.Get() +v598 := lang.Apply(v597, []any{lang.NewSymbol("c__0__auto__")}) +v599 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v600 := v599.FindInternedVar(lang.NewSymbol("list")) +if v600.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v600))) } -v359 := v358.Get() -v360 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v361 := v360.FindInternedVar(lang.NewSymbol("seq")) -if v361.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v361))) +v601 := v600.Get() +v602 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v603 := v602.FindInternedVar(lang.NewSymbol("seq")) +if v603.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v603))) } -v362 := v361.Get() -v363 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v364 := v363.FindInternedVar(lang.NewSymbol("concat")) -if v364.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v364))) +v604 := v603.Get() +v605 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v606 := v605.FindInternedVar(lang.NewSymbol("concat")) +if v606.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v606))) } -v365 := v364.Get() -v366 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v367 := v366.FindInternedVar(lang.NewSymbol("list")) -if v367.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v367))) +v607 := v606.Get() +v608 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v609 := v608.FindInternedVar(lang.NewSymbol("list")) +if v609.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v609))) } -v368 := v367.Get() -v369 := lang.Apply(v368, []any{lang.NewSymbol("glojure.core/loop")}) -v370 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v371 := v370.FindInternedVar(lang.NewSymbol("list")) -if v371.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v371))) +v610 := v609.Get() +v611 := lang.Apply(v610, []any{lang.NewSymbol("glojure.core/int")}) +v612 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v613 := v612.FindInternedVar(lang.NewSymbol("list")) +if v613.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v613))) } -v372 := v371.Get() -v373 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v374 := v373.FindInternedVar(lang.NewSymbol("apply")) -if v374.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v374))) +v614 := v613.Get() +v615 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v616 := v615.FindInternedVar(lang.NewSymbol("seq")) +if v616.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v616))) } -v375 := v374.Get() -v376 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v377 := v376.FindInternedVar(lang.NewSymbol("vector")) -if v377.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v377))) +v617 := v616.Get() +v618 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v619 := v618.FindInternedVar(lang.NewSymbol("concat")) +if v619.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v619))) } -v378 := v377.Get() -v379 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v380 := v379.FindInternedVar(lang.NewSymbol("seq")) -if v380.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v380))) +v620 := v619.Get() +v621 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v622 := v621.FindInternedVar(lang.NewSymbol("list")) +if v622.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v622))) } -v381 := v380.Get() -v382 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v383 := v382.FindInternedVar(lang.NewSymbol("concat")) -if v383.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v383))) +v623 := v622.Get() +v624 := lang.Apply(v623, []any{lang.NewSymbol("glojure.core/count")}) +v625 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v626 := v625.FindInternedVar(lang.NewSymbol("list")) +if v626.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v626))) } -v384 := v383.Get() -v385 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v386 := v385.FindInternedVar(lang.NewSymbol("list")) -if v386.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v386))) +v627 := v626.Get() +v628 := lang.Apply(v627, []any{lang.NewSymbol("c__0__auto__")}) +v629 := lang.Apply(v620, []any{v624, v628}) +v630 := lang.Apply(v617, []any{v629}) +v631 := lang.Apply(v614, []any{v630}) +v632 := lang.Apply(v607, []any{v611, v631}) +v633 := lang.Apply(v604, []any{v632}) +v634 := lang.Apply(v601, []any{v633}) +v635 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v636 := v635.FindInternedVar(lang.NewSymbol("list")) +if v636.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v636))) } -v387 := v386.Get() -v388 := lang.Apply(v387, []any{v135}) -v389 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v390 := v389.FindInternedVar(lang.NewSymbol("list")) -if v390.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v390))) +v637 := v636.Get() +v638 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v639 := v638.FindInternedVar(lang.NewSymbol("seq")) +if v639.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v639))) } -v391 := v390.Get() -v392 := lang.Apply(v391, []any{v135}) -v393 := lang.Apply(v384, []any{v388, v392}) -v394 := lang.Apply(v381, []any{v393}) -v395 := lang.Apply(v375, []any{v378, v394}) -v396 := lang.Apply(v372, []any{v395}) -v397 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v398 := v397.FindInternedVar(lang.NewSymbol("list")) -if v398.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v398))) +v640 := v639.Get() +v641 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v642 := v641.FindInternedVar(lang.NewSymbol("concat")) +if v642.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v642))) } -v399 := v398.Get() -v400 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v401 := v400.FindInternedVar(lang.NewSymbol("seq")) -if v401.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v401))) +v643 := v642.Get() +v644 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v645 := v644.FindInternedVar(lang.NewSymbol("list")) +if v645.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v645))) } -v402 := v401.Get() -v403 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v404 := v403.FindInternedVar(lang.NewSymbol("concat")) -if v404.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v404))) +v646 := v645.Get() +v647 := lang.Apply(v646, []any{lang.NewSymbol("glojure.core/int")}) +v648 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v649 := v648.FindInternedVar(lang.NewSymbol("list")) +if v649.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v649))) } -v405 := v404.Get() -v406 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v407 := v406.FindInternedVar(lang.NewSymbol("list")) -if v407.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v407))) +v650 := v649.Get() +v651 := lang.Apply(v650, []any{int64(0)}) +v652 := lang.Apply(v643, []any{v647, v651}) +v653 := lang.Apply(v640, []any{v652}) +v654 := lang.Apply(v637, []any{v653}) +v655 := lang.Apply(v570, []any{v574, v594, v598, v634, v654}) +v656 := lang.Apply(v567, []any{v655}) +v657 := lang.Apply(v564, []any{v656}) +v658 := lang.Apply(v514, []any{v518, v561, v657}) +v659 := lang.Apply(v511, []any{v658}) +v660 := lang.Apply(v508, []any{v659}) +v661 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v662 := v661.FindInternedVar(lang.NewSymbol("list")) +if v662.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v662))) } -v408 := v407.Get() -v409 := lang.Apply(v408, []any{lang.NewSymbol("glojure.core/when-let")}) -v410 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v411 := v410.FindInternedVar(lang.NewSymbol("list")) -if v411.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v411))) +v663 := v662.Get() +v664 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v665 := v664.FindInternedVar(lang.NewSymbol("seq")) +if v665.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v665))) } -v412 := v411.Get() -v413 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v414 := v413.FindInternedVar(lang.NewSymbol("apply")) -if v414.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v414))) +v666 := v665.Get() +v667 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v668 := v667.FindInternedVar(lang.NewSymbol("concat")) +if v668.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v668))) } -v415 := v414.Get() -v416 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v417 := v416.FindInternedVar(lang.NewSymbol("vector")) -if v417.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v417))) +v669 := v668.Get() +v670 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v671 := v670.FindInternedVar(lang.NewSymbol("list")) +if v671.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v671))) } -v418 := v417.Get() -v419 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v420 := v419.FindInternedVar(lang.NewSymbol("seq")) -if v420.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v420))) +v672 := v671.Get() +v673 := lang.Apply(v672, []any{lang.NewSymbol("glojure.core/let")}) +v674 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v675 := v674.FindInternedVar(lang.NewSymbol("list")) +if v675.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v675))) } -v421 := v420.Get() -v422 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v423 := v422.FindInternedVar(lang.NewSymbol("concat")) -if v423.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v423))) +v676 := v675.Get() +v677 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v678 := v677.FindInternedVar(lang.NewSymbol("apply")) +if v678.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v678))) } -v424 := v423.Get() -v425 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v426 := v425.FindInternedVar(lang.NewSymbol("list")) -if v426.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v426))) +v679 := v678.Get() +v680 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v681 := v680.FindInternedVar(lang.NewSymbol("vector")) +if v681.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v681))) } -v427 := v426.Get() -v428 := lang.Apply(v427, []any{v135}) -v429 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v430 := v429.FindInternedVar(lang.NewSymbol("list")) -if v430.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v430))) +v682 := v681.Get() +v683 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v684 := v683.FindInternedVar(lang.NewSymbol("seq")) +if v684.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v684))) } -v431 := v430.Get() -v432 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v433 := v432.FindInternedVar(lang.NewSymbol("seq")) -if v433.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v433))) +v685 := v684.Get() +v686 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v687 := v686.FindInternedVar(lang.NewSymbol("concat")) +if v687.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v687))) } -v434 := v433.Get() -v435 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v436 := v435.FindInternedVar(lang.NewSymbol("concat")) -if v436.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v436))) +v688 := v687.Get() +v689 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v690 := v689.FindInternedVar(lang.NewSymbol("list")) +if v690.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v690))) } -v437 := v436.Get() -v438 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v439 := v438.FindInternedVar(lang.NewSymbol("list")) -if v439.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v439))) +v691 := v690.Get() +v692 := lang.Apply(v691, []any{v80}) +v693 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v694 := v693.FindInternedVar(lang.NewSymbol("list")) +if v694.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v694))) } -v440 := v439.Get() -v441 := lang.Apply(v440, []any{lang.NewSymbol("glojure.core/seq")}) -v442 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v443 := v442.FindInternedVar(lang.NewSymbol("list")) -if v443.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v443))) +v695 := v694.Get() +v696 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v697 := v696.FindInternedVar(lang.NewSymbol("seq")) +if v697.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v697))) } -v444 := v443.Get() -v445 := lang.Apply(v444, []any{v135}) -v446 := lang.Apply(v437, []any{v441, v445}) -v447 := lang.Apply(v434, []any{v446}) -v448 := lang.Apply(v431, []any{v447}) -v449 := lang.Apply(v424, []any{v428, v448}) -v450 := lang.Apply(v421, []any{v449}) -v451 := lang.Apply(v415, []any{v418, v450}) -v452 := lang.Apply(v412, []any{v451}) -v453 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v454 := v453.FindInternedVar(lang.NewSymbol("list")) -if v454.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v454))) +v698 := v697.Get() +v699 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v700 := v699.FindInternedVar(lang.NewSymbol("concat")) +if v700.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v700))) } -v455 := v454.Get() -v456 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v457 := v456.FindInternedVar(lang.NewSymbol("seq")) -if v457.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v457))) +v701 := v700.Get() +v702 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v703 := v702.FindInternedVar(lang.NewSymbol("list")) +if v703.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v703))) } -v458 := v457.Get() -v459 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v460 := v459.FindInternedVar(lang.NewSymbol("concat")) -if v460.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v460))) +v704 := v703.Get() +v705 := lang.Apply(v704, []any{lang.NewSymbol("glojure.core/first")}) +v706 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v707 := v706.FindInternedVar(lang.NewSymbol("list")) +if v707.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v707))) } -v461 := v460.Get() -v462 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v463 := v462.FindInternedVar(lang.NewSymbol("list")) -if v463.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v463))) +v708 := v707.Get() +v709 := lang.Apply(v708, []any{v96}) +v710 := lang.Apply(v701, []any{v705, v709}) +v711 := lang.Apply(v698, []any{v710}) +v712 := lang.Apply(v695, []any{v711}) +v713 := lang.Apply(v688, []any{v692, v712}) +v714 := lang.Apply(v685, []any{v713}) +v715 := lang.Apply(v679, []any{v682, v714}) +v716 := lang.Apply(v676, []any{v715}) +v717 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v718 := v717.FindInternedVar(lang.NewSymbol("list")) +if v718.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v718))) } -v464 := v463.Get() -v465 := lang.Apply(v464, []any{lang.NewSymbol("if")}) -v466 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v467 := v466.FindInternedVar(lang.NewSymbol("list")) -if v467.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v467))) +v719 := v718.Get() +v720 := lang.Apply(v719, []any{v176}) +var v721 any +if lang.IsTruthy(v174) { +v722 := lang.NewVector(v123) +v723 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3264), lang.NewKeyword("column"), int(52), lang.NewKeyword("end-line"), int(3264), lang.NewKeyword("end-column"), int(60)) +v724, err := lang.WithMeta(v722, v723.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v468 := v467.Get() -v469 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v470 := v469.FindInternedVar(lang.NewSymbol("seq")) -if v470.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v470))) +v721 = v724 +} else { +v721 = nil } -v471 := v470.Get() -v472 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v473 := v472.FindInternedVar(lang.NewSymbol("concat")) -if v473.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v473))) +v725 := lang.Apply(v669, []any{v673, v716, v720, v721}) +v726 := lang.Apply(v666, []any{v725}) +v727 := lang.Apply(v663, []any{v726}) +v728 := lang.Apply(v481, []any{v485, v505, v660, v727}) +v729 := lang.Apply(v478, []any{v728}) +v730 := lang.Apply(v475, []any{v729}) +v731 := lang.Apply(v425, []any{v429, v472, v730}) +v732 := lang.Apply(v422, []any{v731}) +v733 := lang.Apply(v419, []any{v732}) +v734 := lang.Apply(v317, []any{v321, v345, v416, v733}) +v735 := lang.Apply(v314, []any{v734}) +v736 := lang.Apply(v311, []any{v735}) +v737 := lang.Apply(v237, []any{v241, v308, v736}) +v738 := lang.Apply(v234, []any{v737}) +v739 := lang.NewVector(true, v738) +v740 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3250), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(3264), lang.NewKeyword("end-column"), int(67)) +v741, err := lang.WithMeta(v739, v740.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v474 := v473.Get() -v475 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v476 := v475.FindInternedVar(lang.NewSymbol("list")) -if v476.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v476))) +v91 = v741 } -v477 := v476.Get() -v478 := lang.Apply(v477, []any{lang.NewSymbol("glojure.core/chunked-seq?")}) -v479 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v480 := v479.FindInternedVar(lang.NewSymbol("list")) -if v480.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v480))) +v60 = v91 } -v481 := v480.Get() -v482 := lang.Apply(v481, []any{v135}) -v483 := lang.Apply(v474, []any{v478, v482}) -v484 := lang.Apply(v471, []any{v483}) -v485 := lang.Apply(v468, []any{v484}) -v486 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v487 := v486.FindInternedVar(lang.NewSymbol("list")) -if v487.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v487))) +return v60 +}) +v57 := v56 +_ = v57 } -v488 := v487.Get() -v489 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v490 := v489.FindInternedVar(lang.NewSymbol("seq")) -if v490.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v490))) +v57 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3218), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(3264), lang.NewKeyword("end-column"), int(72)) +v58, err := lang.WithMeta(v56, v57.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v491 := v490.Get() -v492 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v493 := v492.FindInternedVar(lang.NewSymbol("concat")) -if v493.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v493))) +var v55 any = v58 +_ = v55 +v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v61 := v60.FindInternedVar(lang.NewSymbol("nth")) +if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) } -v494 := v493.Get() -v495 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v496 := v495.FindInternedVar(lang.NewSymbol("list")) -if v496.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v496))) +v62 := v61.Get() +v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v64 := v63.FindInternedVar(lang.NewSymbol("seq")) +if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) } -v497 := v496.Get() -v498 := lang.Apply(v497, []any{lang.NewSymbol("glojure.core/let")}) -v499 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v500 := v499.FindInternedVar(lang.NewSymbol("list")) -if v500.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v500))) +v65 := v64.Get() +v66 := lang.Apply(v65, []any{v5}) +v67 := lang.Apply(v55, []any{nil, v66}) +v68 := lang.Apply(v62, []any{v67, int64(1)}) +return v68 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v501 := v500.Get() -v502 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v503 := v502.FindInternedVar(lang.NewSymbol("apply")) -if v503.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v503))) } -v504 := v503.Get() -v505 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v506 := v505.FindInternedVar(lang.NewSymbol("vector")) -if v506.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v506))) +// dosync +{ +v0 := lang.NewSymbol("dosync").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("exprs"))), lang.NewKeyword("doc"), "Runs the exprs (in an implicit do) in a transaction that encompasses\n exprs and any nested calls. Starts a transaction if none is already\n running on this thread. Any uncaught exception will abort the\n transaction and flow out of dosync. The exprs may be run more than\n once, but any effects on Refs will be atomic.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5100), lang.NewKeyword("end-line"), int(5100))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("seq")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v507 := v506.Get() -v508 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v509 := v508.FindInternedVar(lang.NewSymbol("seq")) -if v509.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v509))) +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("concat")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -v510 := v509.Get() -v511 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v512 := v511.FindInternedVar(lang.NewSymbol("concat")) -if v512.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v512))) +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("list")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } -v513 := v512.Get() -v514 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v515 := v514.FindInternedVar(lang.NewSymbol("list")) -if v515.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v515))) +v14 := v13.Get() +v15 := lang.Apply(v14, []any{lang.NewSymbol("glojure.core/sync")}) +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("list")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -v516 := v515.Get() -v517 := lang.Apply(v516, []any{lang.NewSymbol("c__0__auto__")}) -v518 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v519 := v518.FindInternedVar(lang.NewSymbol("list")) -if v519.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v519))) +v18 := v17.Get() +v19 := lang.Apply(v18, []any{nil}) +v20 := lang.Apply(v11, []any{v15, v19, v5}) +v21 := lang.Apply(v8, []any{v20}) +return v21 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v520 := v519.Get() -v521 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v522 := v521.FindInternedVar(lang.NewSymbol("seq")) -if v522.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v522))) } -v523 := v522.Get() -v524 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v525 := v524.FindInternedVar(lang.NewSymbol("concat")) -if v525.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v525))) +// dotimes +{ +v0 := lang.NewSymbol("dotimes").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "bindings => name n\n\n Repeatedly executes body (presumably for side-effects) with name\n bound to integers from 0 through n-1.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3306), lang.NewKeyword("end-line"), int(3306))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +var v7 any +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v526 := v525.Get() -v527 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v528 := v527.FindInternedVar(lang.NewSymbol("list")) -if v528.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v528))) +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v5}) +if lang.IsTruthy(v11) { +v7 = nil +} else { +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("str")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } -v529 := v528.Get() -v530 := lang.Apply(v529, []any{lang.NewSymbol("glojure.core/chunk-first")}) -v531 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v532 := v531.FindInternedVar(lang.NewSymbol("list")) -if v532.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v532))) +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("first")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } -v533 := v532.Get() -v534 := lang.Apply(v533, []any{v135}) -v535 := lang.Apply(v526, []any{v530, v534}) -v536 := lang.Apply(v523, []any{v535}) -v537 := lang.Apply(v520, []any{v536}) -v538 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v539 := v538.FindInternedVar(lang.NewSymbol("list")) -if v539.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v539))) +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v3}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v540 := v539.Get() -v541 := lang.Apply(v540, []any{lang.NewSymbol("size__1__auto__")}) -v542 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v543 := v542.FindInternedVar(lang.NewSymbol("list")) -if v543.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v543))) +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("meta")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -v544 := v543.Get() -v545 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v546 := v545.FindInternedVar(lang.NewSymbol("seq")) -if v546.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v546))) +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v3}) +v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) +v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) +v28 := lang.Apply(lang1.NewIllegalArgumentError, []any{v27}) +panic(v28) } -v547 := v546.Get() -v548 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v549 := v548.FindInternedVar(lang.NewSymbol("concat")) -if v549.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v549))) +_ = v7 +var v29 any +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("=")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) } -v550 := v549.Get() -v551 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v552 := v551.FindInternedVar(lang.NewSymbol("list")) -if v552.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v552))) +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("count")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) } -v553 := v552.Get() -v554 := lang.Apply(v553, []any{lang.NewSymbol("glojure.core/int")}) -v555 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v556 := v555.FindInternedVar(lang.NewSymbol("list")) -if v556.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v556))) +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v5}) +v37 := lang.Apply(v32, []any{int64(2), v36}) +if lang.IsTruthy(v37) { +v29 = nil +} else { +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("str")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) } -v557 := v556.Get() -v558 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v559 := v558.FindInternedVar(lang.NewSymbol("seq")) -if v559.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v559))) +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("first")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } -v560 := v559.Get() -v561 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v562 := v561.FindInternedVar(lang.NewSymbol("concat")) -if v562.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v562))) +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v3}) +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) } -v563 := v562.Get() -v564 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v565 := v564.FindInternedVar(lang.NewSymbol("list")) -if v565.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v565))) +v47 := v46.Get() +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("meta")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) } -v566 := v565.Get() -v567 := lang.Apply(v566, []any{lang.NewSymbol("glojure.core/count")}) -v568 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v569 := v568.FindInternedVar(lang.NewSymbol("list")) -if v569.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v569))) +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v3}) +v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) +v53 := lang.Apply(v40, []any{v44, " requires ", "exactly 2 forms in binding vector", " in ", v47, ":", v52}) +v54 := lang.Apply(lang1.NewIllegalArgumentError, []any{v53}) +panic(v54) } -v570 := v569.Get() -v571 := lang.Apply(v570, []any{lang.NewSymbol("c__0__auto__")}) -v572 := lang.Apply(v563, []any{v567, v571}) -v573 := lang.Apply(v560, []any{v572}) -v574 := lang.Apply(v557, []any{v573}) -v575 := lang.Apply(v550, []any{v554, v574}) -v576 := lang.Apply(v547, []any{v575}) -v577 := lang.Apply(v544, []any{v576}) -v578 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v579 := v578.FindInternedVar(lang.NewSymbol("list")) -if v579.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v579))) +_ = v29 +_ = nil +v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v57 := v56.FindInternedVar(lang.NewSymbol("first")) +if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) } -v580 := v579.Get() -v581 := lang.Apply(v580, []any{v297}) -v582 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v583 := v582.FindInternedVar(lang.NewSymbol("list")) -if v583.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v583))) +v58 := v57.Get() +v59 := lang.Apply(v58, []any{v5}) +var v55 any = v59 +_ = v55 +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("second")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) } -v584 := v583.Get() -v585 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v586 := v585.FindInternedVar(lang.NewSymbol("seq")) -if v586.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v586))) +v63 := v62.Get() +v64 := lang.Apply(v63, []any{v5}) +var v60 any = v64 +_ = v60 +v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v67 := v66.FindInternedVar(lang.NewSymbol("seq")) +if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) } -v587 := v586.Get() -v588 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v589 := v588.FindInternedVar(lang.NewSymbol("concat")) -if v589.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v589))) +v68 := v67.Get() +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("concat")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) } -v590 := v589.Get() -v591 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v592 := v591.FindInternedVar(lang.NewSymbol("list")) -if v592.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v592))) +v71 := v70.Get() +v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v73 := v72.FindInternedVar(lang.NewSymbol("list")) +if v73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) } -v593 := v592.Get() -v594 := lang.Apply(v593, []any{lang.NewSymbol("glojure.core/chunk-buffer")}) -v595 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v596 := v595.FindInternedVar(lang.NewSymbol("list")) -if v596.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v596))) +v74 := v73.Get() +v75 := lang.Apply(v74, []any{lang.NewSymbol("glojure.core/let")}) +v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v77 := v76.FindInternedVar(lang.NewSymbol("list")) +if v77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) } -v597 := v596.Get() -v598 := lang.Apply(v597, []any{lang.NewSymbol("size__1__auto__")}) -v599 := lang.Apply(v590, []any{v594, v598}) -v600 := lang.Apply(v587, []any{v599}) -v601 := lang.Apply(v584, []any{v600}) -v602 := lang.Apply(v513, []any{v517, v537, v541, v577, v581, v601}) -v603 := lang.Apply(v510, []any{v602}) -v604 := lang.Apply(v504, []any{v507, v603}) -v605 := lang.Apply(v501, []any{v604}) -v606 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v607 := v606.FindInternedVar(lang.NewSymbol("list")) -if v607.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v607))) +v78 := v77.Get() +v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v80 := v79.FindInternedVar(lang.NewSymbol("apply")) +if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) } -v608 := v607.Get() -v609 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v610 := v609.FindInternedVar(lang.NewSymbol("seq")) -if v610.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v610))) +v81 := v80.Get() +v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v83 := v82.FindInternedVar(lang.NewSymbol("vector")) +if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) } -v611 := v610.Get() -v612 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v613 := v612.FindInternedVar(lang.NewSymbol("concat")) -if v613.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v613))) +v84 := v83.Get() +v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v86 := v85.FindInternedVar(lang.NewSymbol("seq")) +if v86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) } -v614 := v613.Get() -v615 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v616 := v615.FindInternedVar(lang.NewSymbol("list")) -if v616.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v616))) +v87 := v86.Get() +v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v89 := v88.FindInternedVar(lang.NewSymbol("concat")) +if v89.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) } -v617 := v616.Get() -v618 := lang.Apply(v617, []any{lang.NewSymbol("if")}) -v619 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v620 := v619.FindInternedVar(lang.NewSymbol("list")) -if v620.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v620))) +v90 := v89.Get() +v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v92 := v91.FindInternedVar(lang.NewSymbol("list")) +if v92.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) } -v621 := v620.Get() -v622 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v623 := v622.FindInternedVar(lang.NewSymbol("seq")) -if v623.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v623))) +v93 := v92.Get() +v94 := lang.Apply(v93, []any{lang.NewSymbol("n__0__auto__")}) +v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v96 := v95.FindInternedVar(lang.NewSymbol("list")) +if v96.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) } -v624 := v623.Get() -v625 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v626 := v625.FindInternedVar(lang.NewSymbol("concat")) -if v626.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v626))) +v97 := v96.Get() +v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v99 := v98.FindInternedVar(lang.NewSymbol("seq")) +if v99.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) } -v627 := v626.Get() -v628 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v629 := v628.FindInternedVar(lang.NewSymbol("list")) -if v629.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v629))) +v100 := v99.Get() +v101 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v102 := v101.FindInternedVar(lang.NewSymbol("concat")) +if v102.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v102))) } -v630 := v629.Get() -v631 := lang.Apply(v630, []any{lang.NewSymbol("glojure.core/loop")}) -v632 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v633 := v632.FindInternedVar(lang.NewSymbol("list")) -if v633.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v633))) +v103 := v102.Get() +v104 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v105 := v104.FindInternedVar(lang.NewSymbol("list")) +if v105.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v105))) } -v634 := v633.Get() -v635 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v636 := v635.FindInternedVar(lang.NewSymbol("apply")) -if v636.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v636))) +v106 := v105.Get() +v107 := lang.Apply(v106, []any{lang.NewSymbol("glojure.core/long")}) +v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v109 := v108.FindInternedVar(lang.NewSymbol("list")) +if v109.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) } -v637 := v636.Get() -v638 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v639 := v638.FindInternedVar(lang.NewSymbol("vector")) -if v639.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v639))) +v110 := v109.Get() +v111 := lang.Apply(v110, []any{v60}) +v112 := lang.Apply(v103, []any{v107, v111}) +v113 := lang.Apply(v100, []any{v112}) +v114 := lang.Apply(v97, []any{v113}) +v115 := lang.Apply(v90, []any{v94, v114}) +v116 := lang.Apply(v87, []any{v115}) +v117 := lang.Apply(v81, []any{v84, v116}) +v118 := lang.Apply(v78, []any{v117}) +v119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v120 := v119.FindInternedVar(lang.NewSymbol("list")) +if v120.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v120))) } -v640 := v639.Get() -v641 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v642 := v641.FindInternedVar(lang.NewSymbol("seq")) -if v642.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v642))) +v121 := v120.Get() +v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v123 := v122.FindInternedVar(lang.NewSymbol("seq")) +if v123.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) } -v643 := v642.Get() -v644 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v645 := v644.FindInternedVar(lang.NewSymbol("concat")) -if v645.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v645))) +v124 := v123.Get() +v125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v126 := v125.FindInternedVar(lang.NewSymbol("concat")) +if v126.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v126))) } -v646 := v645.Get() -v647 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v648 := v647.FindInternedVar(lang.NewSymbol("list")) -if v648.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v648))) +v127 := v126.Get() +v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v129 := v128.FindInternedVar(lang.NewSymbol("list")) +if v129.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v129))) } -v649 := v648.Get() -v650 := lang.Apply(v649, []any{v292}) -v651 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v652 := v651.FindInternedVar(lang.NewSymbol("list")) -if v652.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v652))) +v130 := v129.Get() +v131 := lang.Apply(v130, []any{lang.NewSymbol("glojure.core/loop")}) +v132 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v133 := v132.FindInternedVar(lang.NewSymbol("list")) +if v133.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v133))) } -v653 := v652.Get() -v654 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v655 := v654.FindInternedVar(lang.NewSymbol("seq")) -if v655.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v655))) +v134 := v133.Get() +v135 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v136 := v135.FindInternedVar(lang.NewSymbol("apply")) +if v136.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v136))) } -v656 := v655.Get() -v657 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v658 := v657.FindInternedVar(lang.NewSymbol("concat")) -if v658.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v658))) +v137 := v136.Get() +v138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v139 := v138.FindInternedVar(lang.NewSymbol("vector")) +if v139.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v139))) } -v659 := v658.Get() -v660 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v661 := v660.FindInternedVar(lang.NewSymbol("list")) -if v661.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v661))) +v140 := v139.Get() +v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v142 := v141.FindInternedVar(lang.NewSymbol("seq")) +if v142.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) } -v662 := v661.Get() -v663 := lang.Apply(v662, []any{lang.NewSymbol("glojure.core/int")}) -v664 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v665 := v664.FindInternedVar(lang.NewSymbol("list")) -if v665.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v665))) +v143 := v142.Get() +v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v145 := v144.FindInternedVar(lang.NewSymbol("concat")) +if v145.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) } -v666 := v665.Get() -v667 := lang.Apply(v666, []any{int64(0)}) -v668 := lang.Apply(v659, []any{v663, v667}) -v669 := lang.Apply(v656, []any{v668}) -v670 := lang.Apply(v653, []any{v669}) -v671 := lang.Apply(v646, []any{v650, v670}) -v672 := lang.Apply(v643, []any{v671}) -v673 := lang.Apply(v637, []any{v640, v672}) -v674 := lang.Apply(v634, []any{v673}) -v675 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v676 := v675.FindInternedVar(lang.NewSymbol("list")) -if v676.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v676))) +v146 := v145.Get() +v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v148 := v147.FindInternedVar(lang.NewSymbol("list")) +if v148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) } -v677 := v676.Get() -v678 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v679 := v678.FindInternedVar(lang.NewSymbol("seq")) -if v679.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v679))) +v149 := v148.Get() +v150 := lang.Apply(v149, []any{v55}) +v151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v152 := v151.FindInternedVar(lang.NewSymbol("list")) +if v152.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v152))) } -v680 := v679.Get() -v681 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v682 := v681.FindInternedVar(lang.NewSymbol("concat")) -if v682.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v682))) +v153 := v152.Get() +v154 := lang.Apply(v153, []any{int64(0)}) +v155 := lang.Apply(v146, []any{v150, v154}) +v156 := lang.Apply(v143, []any{v155}) +v157 := lang.Apply(v137, []any{v140, v156}) +v158 := lang.Apply(v134, []any{v157}) +v159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v160 := v159.FindInternedVar(lang.NewSymbol("list")) +if v160.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v160))) } -v683 := v682.Get() -v684 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v685 := v684.FindInternedVar(lang.NewSymbol("list")) -if v685.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v685))) +v161 := v160.Get() +v162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v163 := v162.FindInternedVar(lang.NewSymbol("seq")) +if v163.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v163))) } -v686 := v685.Get() -v687 := lang.Apply(v686, []any{lang.NewSymbol("if")}) -v688 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v689 := v688.FindInternedVar(lang.NewSymbol("list")) -if v689.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v689))) +v164 := v163.Get() +v165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v166 := v165.FindInternedVar(lang.NewSymbol("concat")) +if v166.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v166))) } -v690 := v689.Get() -v691 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v692 := v691.FindInternedVar(lang.NewSymbol("seq")) -if v692.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v692))) +v167 := v166.Get() +v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v169 := v168.FindInternedVar(lang.NewSymbol("list")) +if v169.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) } -v693 := v692.Get() -v694 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v695 := v694.FindInternedVar(lang.NewSymbol("concat")) -if v695.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v695))) +v170 := v169.Get() +v171 := lang.Apply(v170, []any{lang.NewSymbol("glojure.core/when")}) +v172 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v173 := v172.FindInternedVar(lang.NewSymbol("list")) +if v173.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v173))) } -v696 := v695.Get() -v697 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v698 := v697.FindInternedVar(lang.NewSymbol("list")) -if v698.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v698))) +v174 := v173.Get() +v175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v176 := v175.FindInternedVar(lang.NewSymbol("seq")) +if v176.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v176))) } -v699 := v698.Get() -v700 := lang.Apply(v699, []any{lang.NewSymbol("glojure.core/<")}) -v701 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v702 := v701.FindInternedVar(lang.NewSymbol("list")) -if v702.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v702))) +v177 := v176.Get() +v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v179 := v178.FindInternedVar(lang.NewSymbol("concat")) +if v179.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) } -v703 := v702.Get() -v704 := lang.Apply(v703, []any{v292}) -v705 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v706 := v705.FindInternedVar(lang.NewSymbol("list")) -if v706.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v706))) +v180 := v179.Get() +v181 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v182 := v181.FindInternedVar(lang.NewSymbol("list")) +if v182.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v182))) } -v707 := v706.Get() -v708 := lang.Apply(v707, []any{lang.NewSymbol("size__1__auto__")}) -v709 := lang.Apply(v696, []any{v700, v704, v708}) -v710 := lang.Apply(v693, []any{v709}) -v711 := lang.Apply(v690, []any{v710}) -v712 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v713 := v712.FindInternedVar(lang.NewSymbol("list")) -if v713.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v713))) +v183 := v182.Get() +v184 := lang.Apply(v183, []any{lang.NewSymbol("glojure.core/<")}) +v185 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v186 := v185.FindInternedVar(lang.NewSymbol("list")) +if v186.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v186))) } -v714 := v713.Get() -v715 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v716 := v715.FindInternedVar(lang.NewSymbol("seq")) -if v716.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v716))) +v187 := v186.Get() +v188 := lang.Apply(v187, []any{v55}) +v189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v190 := v189.FindInternedVar(lang.NewSymbol("list")) +if v190.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v190))) } -v717 := v716.Get() -v718 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v719 := v718.FindInternedVar(lang.NewSymbol("concat")) -if v719.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v719))) +v191 := v190.Get() +v192 := lang.Apply(v191, []any{lang.NewSymbol("n__0__auto__")}) +v193 := lang.Apply(v180, []any{v184, v188, v192}) +v194 := lang.Apply(v177, []any{v193}) +v195 := lang.Apply(v174, []any{v194}) +v196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v197 := v196.FindInternedVar(lang.NewSymbol("list")) +if v197.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v197))) } -v720 := v719.Get() -v721 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v722 := v721.FindInternedVar(lang.NewSymbol("list")) -if v722.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v722))) +v198 := v197.Get() +v199 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v200 := v199.FindInternedVar(lang.NewSymbol("seq")) +if v200.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v200))) } -v723 := v722.Get() -v724 := lang.Apply(v723, []any{lang.NewSymbol("glojure.core/let")}) -v725 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v726 := v725.FindInternedVar(lang.NewSymbol("list")) -if v726.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v726))) +v201 := v200.Get() +v202 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v203 := v202.FindInternedVar(lang.NewSymbol("concat")) +if v203.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v203))) } -v727 := v726.Get() -v728 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v729 := v728.FindInternedVar(lang.NewSymbol("apply")) -if v729.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v729))) +v204 := v203.Get() +v205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v206 := v205.FindInternedVar(lang.NewSymbol("list")) +if v206.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v206))) } -v730 := v729.Get() -v731 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v732 := v731.FindInternedVar(lang.NewSymbol("vector")) -if v732.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v732))) +v207 := v206.Get() +v208 := lang.Apply(v207, []any{lang.NewSymbol("recur")}) +v209 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v210 := v209.FindInternedVar(lang.NewSymbol("list")) +if v210.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v210))) } -v733 := v732.Get() -v734 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v735 := v734.FindInternedVar(lang.NewSymbol("seq")) -if v735.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v735))) +v211 := v210.Get() +v212 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v213 := v212.FindInternedVar(lang.NewSymbol("seq")) +if v213.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v213))) } -v736 := v735.Get() -v737 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v738 := v737.FindInternedVar(lang.NewSymbol("concat")) -if v738.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v738))) +v214 := v213.Get() +v215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v216 := v215.FindInternedVar(lang.NewSymbol("concat")) +if v216.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v216))) } -v739 := v738.Get() -v740 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v741 := v740.FindInternedVar(lang.NewSymbol("list")) -if v741.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v741))) +v217 := v216.Get() +v218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v219 := v218.FindInternedVar(lang.NewSymbol("list")) +if v219.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v219))) } -v742 := v741.Get() -v743 := lang.Apply(v742, []any{v99}) -v744 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v745 := v744.FindInternedVar(lang.NewSymbol("list")) -if v745.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v745))) +v220 := v219.Get() +v221 := lang.Apply(v220, []any{lang.NewSymbol("glojure.core/unchecked-inc")}) +v222 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v223 := v222.FindInternedVar(lang.NewSymbol("list")) +if v223.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v223))) } -v746 := v745.Get() -v747 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v748 := v747.FindInternedVar(lang.NewSymbol("seq")) -if v748.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v748))) +v224 := v223.Get() +v225 := lang.Apply(v224, []any{v55}) +v226 := lang.Apply(v217, []any{v221, v225}) +v227 := lang.Apply(v214, []any{v226}) +v228 := lang.Apply(v211, []any{v227}) +v229 := lang.Apply(v204, []any{v208, v228}) +v230 := lang.Apply(v201, []any{v229}) +v231 := lang.Apply(v198, []any{v230}) +v232 := lang.Apply(v167, []any{v171, v195, v6, v231}) +v233 := lang.Apply(v164, []any{v232}) +v234 := lang.Apply(v161, []any{v233}) +v235 := lang.Apply(v127, []any{v131, v158, v234}) +v236 := lang.Apply(v124, []any{v235}) +v237 := lang.Apply(v121, []any{v236}) +v238 := lang.Apply(v71, []any{v75, v118, v237}) +v239 := lang.Apply(v68, []any{v238}) +return v239 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v749 := v748.Get() -v750 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v751 := v750.FindInternedVar(lang.NewSymbol("concat")) -if v751.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v751))) } -v752 := v751.Get() -v753 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v754 := v753.FindInternedVar(lang.NewSymbol("list")) -if v754.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v754))) +// doto +{ +v0 := lang.NewSymbol("doto").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "Evaluates x then calls all of the methods and functions with the\n value of x supplied at the front of the given arguments. The forms\n are evaluated in order. Returns x.\n\n (doto (new java.util.HashMap) (.put \"a\" 1) (.put \"b\" 2))", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3853), lang.NewKeyword("end-line"), int(3853))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("gensym")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v755 := v754.Get() -v756 := lang.Apply(v755, []any{lang.NewSymbol(".nth")}) -v757 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v758 := v757.FindInternedVar(lang.NewSymbol("list")) -if v758.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v758))) +v10 := v9.Get() +v11 := lang.Apply(v10, nil) +var v7 any = v11 +_ = v7 +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("seq")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } -v759 := v758.Get() -v760 := lang.Apply(v759, []any{lang.NewSymbol("c__0__auto__")}) -v761 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v762 := v761.FindInternedVar(lang.NewSymbol("list")) -if v762.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v762))) +v15 := v14.Get() +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("concat")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -v763 := v762.Get() -v764 := lang.Apply(v763, []any{v292}) -v765 := lang.Apply(v752, []any{v756, v760, v764}) -v766 := lang.Apply(v749, []any{v765}) -v767 := lang.Apply(v746, []any{v766}) -v768 := lang.Apply(v739, []any{v743, v767}) -v769 := lang.Apply(v736, []any{v768}) -v770 := lang.Apply(v730, []any{v733, v769}) -v771 := lang.Apply(v727, []any{v770}) -v772 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v773 := v772.FindInternedVar(lang.NewSymbol("list")) -if v773.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v773))) +v18 := v17.Get() +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v774 := v773.Get() -v775 := lang.Apply(v302, []any{v111}) -v776 := lang.Apply(v774, []any{v775}) -v777 := lang.Apply(v720, []any{v724, v771, v776}) -v778 := lang.Apply(v717, []any{v777}) -v779 := lang.Apply(v714, []any{v778}) -v780 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v781 := v780.FindInternedVar(lang.NewSymbol("list")) -if v781.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v781))) +v21 := v20.Get() +v22 := lang.Apply(v21, []any{lang.NewSymbol("glojure.core/let")}) +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v782 := v781.Get() -v783 := lang.Apply(v782, []any{true}) -v784 := lang.Apply(v683, []any{v687, v711, v779, v783}) -v785 := lang.Apply(v680, []any{v784}) -v786 := lang.Apply(v677, []any{v785}) -v787 := lang.Apply(v627, []any{v631, v674, v786}) -v788 := lang.Apply(v624, []any{v787}) -v789 := lang.Apply(v621, []any{v788}) -v790 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v791 := v790.FindInternedVar(lang.NewSymbol("list")) -if v791.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v791))) +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("apply")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) } -v792 := v791.Get() -v793 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v794 := v793.FindInternedVar(lang.NewSymbol("seq")) -if v794.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v794))) +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("vector")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) } -v795 := v794.Get() -v796 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v797 := v796.FindInternedVar(lang.NewSymbol("concat")) -if v797.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v797))) +v31 := v30.Get() +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("seq")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) } -v798 := v797.Get() -v799 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v800 := v799.FindInternedVar(lang.NewSymbol("list")) -if v800.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v800))) +v34 := v33.Get() +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("concat")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) } -v801 := v800.Get() -v802 := lang.Apply(v801, []any{lang.NewSymbol("glojure.core/chunk-cons")}) -v803 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v804 := v803.FindInternedVar(lang.NewSymbol("list")) -if v804.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v804))) +v37 := v36.Get() +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("list")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) } -v805 := v804.Get() -v806 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v807 := v806.FindInternedVar(lang.NewSymbol("seq")) -if v807.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v807))) +v40 := v39.Get() +v41 := lang.Apply(v40, []any{v7}) +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("list")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) } -v808 := v807.Get() -v809 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v810 := v809.FindInternedVar(lang.NewSymbol("concat")) -if v810.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v810))) +v44 := v43.Get() +v45 := lang.Apply(v44, []any{v5}) +v46 := lang.Apply(v37, []any{v41, v45}) +v47 := lang.Apply(v34, []any{v46}) +v48 := lang.Apply(v28, []any{v31, v47}) +v49 := lang.Apply(v25, []any{v48}) +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("map")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) } -v811 := v810.Get() -v812 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v813 := v812.FindInternedVar(lang.NewSymbol("list")) -if v813.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v813))) +v52 := v51.Get() +var v53 lang.FnFunc +v53 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v54 := args[0] +v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v56 := v55.FindInternedVar(lang.NewSymbol("with-meta")) +if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) } -v814 := v813.Get() -v815 := lang.Apply(v814, []any{lang.NewSymbol("glojure.core/chunk")}) -v816 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v817 := v816.FindInternedVar(lang.NewSymbol("list")) -if v817.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v817))) +v57 := v56.Get() +var v58 any +v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v60 := v59.FindInternedVar(lang.NewSymbol("seq?")) +if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) } -v818 := v817.Get() -v819 := lang.Apply(v818, []any{v297}) -v820 := lang.Apply(v811, []any{v815, v819}) -v821 := lang.Apply(v808, []any{v820}) -v822 := lang.Apply(v805, []any{v821}) -v823 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v824 := v823.FindInternedVar(lang.NewSymbol("list")) -if v824.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v824))) +v61 := v60.Get() +v62 := lang.Apply(v61, []any{v54}) +if lang.IsTruthy(v62) { +v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v64 := v63.FindInternedVar(lang.NewSymbol("seq")) +if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) } -v825 := v824.Get() -v826 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v827 := v826.FindInternedVar(lang.NewSymbol("seq")) -if v827.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v827))) +v65 := v64.Get() +v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v67 := v66.FindInternedVar(lang.NewSymbol("concat")) +if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) } -v828 := v827.Get() -v829 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v830 := v829.FindInternedVar(lang.NewSymbol("concat")) -if v830.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v830))) +v68 := v67.Get() +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("list")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) } -v831 := v830.Get() -v832 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v833 := v832.FindInternedVar(lang.NewSymbol("list")) -if v833.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v833))) +v71 := v70.Get() +v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v73 := v72.FindInternedVar(lang.NewSymbol("first")) +if v73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) } -v834 := v833.Get() -v835 := lang.Apply(v834, []any{v130}) -v836 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v837 := v836.FindInternedVar(lang.NewSymbol("list")) -if v837.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v837))) +v74 := v73.Get() +v75 := lang.Apply(v74, []any{v54}) +v76 := lang.Apply(v71, []any{v75}) +v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v78 := v77.FindInternedVar(lang.NewSymbol("list")) +if v78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) } -v838 := v837.Get() -v839 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v840 := v839.FindInternedVar(lang.NewSymbol("seq")) -if v840.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v840))) +v79 := v78.Get() +v80 := lang.Apply(v79, []any{v7}) +v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v82 := v81.FindInternedVar(lang.NewSymbol("next")) +if v82.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) } -v841 := v840.Get() -v842 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v843 := v842.FindInternedVar(lang.NewSymbol("concat")) -if v843.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v843))) +v83 := v82.Get() +v84 := lang.Apply(v83, []any{v54}) +v85 := lang.Apply(v68, []any{v76, v80, v84}) +v86 := lang.Apply(v65, []any{v85}) +v58 = v86 +} else { +v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v88 := v87.FindInternedVar(lang.NewSymbol("seq")) +if v88.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) } -v844 := v843.Get() -v845 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v846 := v845.FindInternedVar(lang.NewSymbol("list")) -if v846.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v846))) +v89 := v88.Get() +v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v91 := v90.FindInternedVar(lang.NewSymbol("concat")) +if v91.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) } -v847 := v846.Get() -v848 := lang.Apply(v847, []any{lang.NewSymbol("glojure.core/chunk-rest")}) -v849 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v850 := v849.FindInternedVar(lang.NewSymbol("list")) -if v850.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v850))) +v92 := v91.Get() +v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v94 := v93.FindInternedVar(lang.NewSymbol("list")) +if v94.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) } -v851 := v850.Get() -v852 := lang.Apply(v851, []any{v135}) -v853 := lang.Apply(v844, []any{v848, v852}) -v854 := lang.Apply(v841, []any{v853}) -v855 := lang.Apply(v838, []any{v854}) -v856 := lang.Apply(v831, []any{v835, v855}) -v857 := lang.Apply(v828, []any{v856}) -v858 := lang.Apply(v825, []any{v857}) -v859 := lang.Apply(v798, []any{v802, v822, v858}) -v860 := lang.Apply(v795, []any{v859}) -v861 := lang.Apply(v792, []any{v860}) -v862 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v863 := v862.FindInternedVar(lang.NewSymbol("list")) -if v863.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v863))) +v95 := v94.Get() +v96 := lang.Apply(v95, []any{v54}) +v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v98 := v97.FindInternedVar(lang.NewSymbol("list")) +if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) } -v864 := v863.Get() -v865 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v866 := v865.FindInternedVar(lang.NewSymbol("seq")) -if v866.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v866))) +v99 := v98.Get() +v100 := lang.Apply(v99, []any{v7}) +v101 := lang.Apply(v92, []any{v96, v100}) +v102 := lang.Apply(v89, []any{v101}) +v58 = v102 } -v867 := v866.Get() -v868 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v869 := v868.FindInternedVar(lang.NewSymbol("concat")) -if v869.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v869))) -} -v870 := v869.Get() -v871 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v872 := v871.FindInternedVar(lang.NewSymbol("list")) -if v872.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v872))) -} -v873 := v872.Get() -v874 := lang.Apply(v873, []any{lang.NewSymbol("glojure.core/chunk-cons")}) -v875 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v876 := v875.FindInternedVar(lang.NewSymbol("list")) -if v876.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v876))) -} -v877 := v876.Get() -v878 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v879 := v878.FindInternedVar(lang.NewSymbol("seq")) -if v879.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v879))) -} -v880 := v879.Get() -v881 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v882 := v881.FindInternedVar(lang.NewSymbol("concat")) -if v882.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v882))) -} -v883 := v882.Get() -v884 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v885 := v884.FindInternedVar(lang.NewSymbol("list")) -if v885.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v885))) -} -v886 := v885.Get() -v887 := lang.Apply(v886, []any{lang.NewSymbol("glojure.core/chunk")}) -v888 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v889 := v888.FindInternedVar(lang.NewSymbol("list")) -if v889.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v889))) -} -v890 := v889.Get() -v891 := lang.Apply(v890, []any{v297}) -v892 := lang.Apply(v883, []any{v887, v891}) -v893 := lang.Apply(v880, []any{v892}) -v894 := lang.Apply(v877, []any{v893}) -v895 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v896 := v895.FindInternedVar(lang.NewSymbol("list")) -if v896.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v896))) -} -v897 := v896.Get() -v898 := lang.Apply(v897, []any{nil}) -v899 := lang.Apply(v870, []any{v874, v894, v898}) -v900 := lang.Apply(v867, []any{v899}) -v901 := lang.Apply(v864, []any{v900}) -v902 := lang.Apply(v614, []any{v618, v789, v861, v901}) -v903 := lang.Apply(v611, []any{v902}) -v904 := lang.Apply(v608, []any{v903}) -v905 := lang.Apply(v494, []any{v498, v605, v904}) -v906 := lang.Apply(v491, []any{v905}) -v907 := lang.Apply(v488, []any{v906}) -v908 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v909 := v908.FindInternedVar(lang.NewSymbol("list")) -if v909.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v909))) -} -v910 := v909.Get() -v911 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v912 := v911.FindInternedVar(lang.NewSymbol("seq")) -if v912.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v912))) -} -v913 := v912.Get() -v914 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v915 := v914.FindInternedVar(lang.NewSymbol("concat")) -if v915.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v915))) +v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v104 := v103.FindInternedVar(lang.NewSymbol("meta")) +if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) } -v916 := v915.Get() -v917 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v918 := v917.FindInternedVar(lang.NewSymbol("list")) -if v918.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v918))) +v105 := v104.Get() +v106 := lang.Apply(v105, []any{v54}) +v107 := lang.Apply(v57, []any{v58, v106}) +return v107 +}) +v54 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3863), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(3868), lang.NewKeyword("end-column"), int(30)) +v55, err := lang.WithMeta(v53, v54.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v919 := v918.Get() -v920 := lang.Apply(v919, []any{lang.NewSymbol("glojure.core/let")}) -v921 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v922 := v921.FindInternedVar(lang.NewSymbol("list")) -if v922.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v922))) +v56 := lang.Apply(v52, []any{v55, v6}) +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("list")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) } -v923 := v922.Get() -v924 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v925 := v924.FindInternedVar(lang.NewSymbol("apply")) -if v925.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v925))) +v59 := v58.Get() +v60 := lang.Apply(v59, []any{v7}) +v61 := lang.Apply(v18, []any{v22, v49, v56, v60}) +v62 := lang.Apply(v15, []any{v61}) +return v62 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v926 := v925.Get() -v927 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v928 := v927.FindInternedVar(lang.NewSymbol("vector")) -if v928.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v928))) } -v929 := v928.Get() -v930 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v931 := v930.FindInternedVar(lang.NewSymbol("seq")) -if v931.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v931))) +// double +{ +var v1 lang.FnFunc +{ // function double__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v932 := v931.Get() -v933 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v934 := v933.FindInternedVar(lang.NewSymbol("concat")) -if v934.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v934))) +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v935 := v934.Get() -v936 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v937 := v936.FindInternedVar(lang.NewSymbol("list")) -if v937.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v937))) +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v938 := v937.Get() -v939 := lang.Apply(v938, []any{v99}) -v940 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v941 := v940.FindInternedVar(lang.NewSymbol("list")) -if v941.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v941))) +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v942 := v941.Get() -v943 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v944 := v943.FindInternedVar(lang.NewSymbol("seq")) -if v944.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v944))) +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v945 := v944.Get() -v946 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v947 := v946.FindInternedVar(lang.NewSymbol("concat")) -if v947.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v947))) +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v948 := v947.Get() -v949 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v950 := v949.FindInternedVar(lang.NewSymbol("list")) -if v950.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v950))) +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -v951 := v950.Get() -v952 := lang.Apply(v951, []any{lang.NewSymbol("glojure.core/first")}) -v953 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v954 := v953.FindInternedVar(lang.NewSymbol("list")) -if v954.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v954))) +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v955 := v954.Get() -v956 := lang.Apply(v955, []any{v135}) -v957 := lang.Apply(v948, []any{v952, v956}) -v958 := lang.Apply(v945, []any{v957}) -v959 := lang.Apply(v942, []any{v958}) -v960 := lang.Apply(v935, []any{v939, v959}) -v961 := lang.Apply(v932, []any{v960}) -v962 := lang.Apply(v926, []any{v929, v961}) -v963 := lang.Apply(v923, []any{v962}) -v964 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v965 := v964.FindInternedVar(lang.NewSymbol("list")) -if v965.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v965))) +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/DoubleCast")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -v966 := v965.Get() -v967 := lang.Apply(v140, []any{v111}) -v968 := lang.Apply(v966, []any{v967}) -v969 := lang.Apply(v916, []any{v920, v963, v968}) -v970 := lang.Apply(v913, []any{v969}) -v971 := lang.Apply(v910, []any{v970}) -v972 := lang.Apply(v461, []any{v465, v485, v907, v971}) -v973 := lang.Apply(v458, []any{v972}) -v974 := lang.Apply(v455, []any{v973}) -v975 := lang.Apply(v405, []any{v409, v452, v974}) -v976 := lang.Apply(v402, []any{v975}) -v977 := lang.Apply(v399, []any{v976}) -v978 := lang.Apply(v365, []any{v369, v396, v977}) -v979 := lang.Apply(v362, []any{v978}) -v980 := lang.Apply(v359, []any{v979}) -v981 := lang.Apply(v352, []any{v356, v980}) -v982 := lang.Apply(v349, []any{v981}) -v983 := lang.Apply(v346, []any{v982}) -v984 := lang.Apply(v312, []any{v316, v320, v343, v983}) -v985 := lang.Apply(v309, []any{v984}) -v145 = v985 +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v3}) +v35 := lang.Apply(v26, []any{v30, v34}) +v36 := lang.Apply(v23, []any{v35}) +v37 := lang.Apply(v20, []any{v36}) +v38 := lang.Apply(v9, []any{v13, v17, v37}) +v39 := lang.Apply(v6, []any{v38}) +return v39 +}) +v2 := v1 +_ = v2 } -return v145 +v0 := lang.NewSymbol("double").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to double", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3493), lang.NewKeyword("end-line"), int(3493))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := lang.Apply(lang1.AsFloat64, []any{v4}) +return v5 }) -v65 := v64 -_ = v65 +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v65 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4668), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(4729), lang.NewKeyword("end-column"), int(68)) -v66, err := lang.WithMeta(v64, v65.(lang.IPersistentMap)) -if err != nil { - panic(err) } -var v63 any = v66 -_ = v63 -v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v69 := v68.FindInternedVar(lang.NewSymbol("seq")) -if v69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) +// double-array +{ +var v1 lang.FnFunc +{ // function double-array__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.NewList(args[0:]...) +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v70 := v69.Get() -v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v72 := v71.FindInternedVar(lang.NewSymbol("concat")) -if v72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v73 := v72.Get() -v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v75 := v74.FindInternedVar(lang.NewSymbol("list")) -if v75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v76 := v75.Get() -v77 := lang.Apply(v76, []any{lang.NewSymbol("glojure.core/let")}) -v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v79 := v78.FindInternedVar(lang.NewSymbol("list")) -if v79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v80 := v79.Get() -v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v82 := v81.FindInternedVar(lang.NewSymbol("apply")) -if v82.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v83 := v82.Get() -v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v85 := v84.FindInternedVar(lang.NewSymbol("vector")) -if v85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) +v20 := v19.Get() +v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/doubleArray")}) +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("list")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -v86 := v85.Get() -v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v88 := v87.FindInternedVar(lang.NewSymbol("seq")) -if v88.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("seq")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -v89 := v88.Get() -v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v91 := v90.FindInternedVar(lang.NewSymbol("concat")) -if v91.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("concat")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } -v92 := v91.Get() -v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v94 := v93.FindInternedVar(lang.NewSymbol("list")) -if v94.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -v95 := v94.Get() -v96 := lang.Apply(v95, []any{lang.NewSymbol("iter__0__auto__")}) -v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v98 := v97.FindInternedVar(lang.NewSymbol("list")) -if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) +v33 := v32.Get() +v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("list")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) } -v99 := v98.Get() -v100 := lang.Apply(v55, []any{v5}) -v101 := lang.Apply(v63, []any{v100}) -v102 := lang.Apply(v99, []any{v101}) -v103 := lang.Apply(v92, []any{v96, v102}) -v104 := lang.Apply(v89, []any{v103}) -v105 := lang.Apply(v83, []any{v86, v104}) -v106 := lang.Apply(v80, []any{v105}) -v107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v108 := v107.FindInternedVar(lang.NewSymbol("list")) -if v108.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v108))) +v37 := v36.Get() +v38 := lang.Apply(v37, []any{lang.NewSymbol("glojure.core/args")}) +v39 := lang.Apply(v30, []any{v34, v38}) +v40 := lang.Apply(v27, []any{v39}) +v41 := lang.Apply(v24, []any{v40}) +v42 := lang.Apply(v9, []any{v13, v17, v21, v41}) +v43 := lang.Apply(v6, []any{v42}) +return v43 + } +}) +v2 := v1 +_ = v2 } -v109 := v108.Get() -v110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v111 := v110.FindInternedVar(lang.NewSymbol("seq")) -if v111.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v111))) +v0 := lang.NewSymbol("double-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Creates an array of doubles", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5341), lang.NewKeyword("end-line"), int(5341))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "doubleArray") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("doubleArray is not a function"))) } -v112 := v111.Get() -v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v114 := v113.FindInternedVar(lang.NewSymbol("concat")) -if v114.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) +v6 := lang.Apply(v5, []any{v4}) +return v6 + case 2: +v4 := args[0] +v5 := args[1] +v6, _ := lang.FieldOrMethod(lang1.Numbers, "doubleArrayInit") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("doubleArrayInit is not a function"))) } -v115 := v114.Get() -v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v117 := v116.FindInternedVar(lang.NewSymbol("list")) -if v117.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v118 := v117.Get() -v119 := lang.Apply(v118, []any{lang.NewSymbol("iter__0__auto__")}) -v120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v121 := v120.FindInternedVar(lang.NewSymbol("list")) -if v121.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v121))) } -v122 := v121.Get() -v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v124 := v123.FindInternedVar(lang.NewSymbol("second")) -if v124.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) +// double? +{ +v0 := lang.NewSymbol("double?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a Double", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1421), lang.NewKeyword("end-line"), int(1421))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v125 := v124.Get() -v126 := lang.Apply(v125, []any{v5}) -v127 := lang.Apply(v122, []any{v126}) -v128 := lang.Apply(v115, []any{v119, v127}) -v129 := lang.Apply(v112, []any{v128}) -v130 := lang.Apply(v109, []any{v129}) -v131 := lang.Apply(v73, []any{v77, v106, v130}) -v132 := lang.Apply(v70, []any{v131}) -return v132 +v6 := v5.Get() +v7 := lang.Apply(v6, []any{lang.Builtins["float64"], v3}) +return v7 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -31652,245 +29911,321 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// derive +// doubles { -v0 := lang.NewSymbol("derive").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag"), lang.NewSymbol("parent")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"), lang.NewSymbol("parent"))), lang.NewKeyword("doc"), "Establishes a parent/child relationship between parent and\n tag. Parent must be a namespace-qualified symbol or keyword and\n child can be either a namespace-qualified symbol or keyword or a\n class. h must be a hierarchy obtained from make-hierarchy, if not\n supplied defaults to, and modifies, the global hierarchy.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5648), lang.NewKeyword("end-line"), int(5648))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: +var v1 lang.FnFunc +{ // function doubles +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] -v4 := args[1] -_ = nil -_ = nil -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("alter-var-root")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v7 := v6.Get() -v8 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("global-hierarchy")) -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("derive")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v11 := v10.Get() -v12 := lang.Apply(v7, []any{v8, v11, v3, v4}) -_ = v12 -return nil - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -_ = nil -_ = nil -_ = nil -v7 := lang.Apply(lang.NewKeyword("parents"), []any{v3}) -var v6 any = v7 -_ = v6 -v9 := lang.Apply(lang.NewKeyword("descendants"), []any{v3}) -var v8 any = v9 -_ = v8 -v11 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) -var v10 any = v11 -_ = v10 -var v13 lang.FnFunc -v13 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 5 { +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/doubles")}) +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("list")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v3}) +v26 := lang.Apply(v9, []any{v13, v17, v21, v25}) +v27 := lang.Apply(v6, []any{v26}) +return v27 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("doubles").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Casts to double[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5402), lang.NewKeyword("end-line"), int(5402))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v14 := args[0] -v15 := args[1] -v16 := args[2] -v17 := args[3] -v18 := args[4] -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("reduce1")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "doubles") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("doubles is not a function"))) } -v21 := v20.Get() -var v22 lang.FnFunc -v22 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// drop +{ +v0 := lang.NewSymbol("drop").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a laziness-preserving sequence of all but the first n items in coll.\n Returns a stateful transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2901), lang.NewKeyword("end-line"), int(2901))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v23 := args[0] -v24 := args[1] -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("assoc")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +v5 := args[0] +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("volatile!")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("reduce1")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v3}) +var v6 any = v10 +_ = v6 +var v12 lang.FnFunc +v12 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v13 := lang.Apply(v5, nil) +return v13 + case 1: +v13 := args[0] +v14 := lang.Apply(v5, []any{v13}) +return v14 + case 2: +v13 := args[0] +v14 := args[1] +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("deref")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("conj")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v6}) +var v15 any = v19 +_ = v15 +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("dec")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("get")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +v23 := v22.Get() +v24, ok := lang.FieldOrMethod(v6, "Deref") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "Deref"))) } -v36 := v35.Get() -v37 := lang.CreatePersistentTreeSet() -v38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5671), lang.NewKeyword("column"), int(61), lang.NewKeyword("end-line"), int(5671), lang.NewKeyword("end-column"), int(63)) -v39, err := lang.WithMeta(v37, v38.(lang.IPersistentMap)) -if err != nil { - panic(err) +var v25 any +switch reflect.TypeOf(v24).Kind() { +case reflect.Func: + v25 = lang.Apply(v24, nil) +default: + v25 = v24 } -v40 := lang.Apply(v36, []any{v18, v24, v39}) -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("cons")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +v26 := lang.Apply(v23, []any{v25}) +v27, _ := lang.FieldOrMethod(v6, "reset") +if reflect.TypeOf(v27).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) } -v43 := v42.Get() -v44 := lang.Apply(v18, []any{v17}) -v45 := lang.Apply(v43, []any{v17, v44}) -v46 := lang.Apply(v30, []any{v33, v40, v45}) -v47 := lang.Apply(v27, []any{v23, v24, v46}) -return v47 +v28 := lang.Apply(v27, []any{v26}) +_ = v28 +var v29 any +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("pos?")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.Apply(v32, []any{v15}) +if lang.IsTruthy(v33) { +v29 = v13 +} else { +v34 := lang.Apply(v5, []any{v13, v14}) +v29 = v34 +} +return v29 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } }) -v23 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5669), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(5671), lang.NewKeyword("end-column"), int(98)) -v24, err := lang.WithMeta(v22, v23.(lang.IPersistentMap)) +v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2909), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(2917), lang.NewKeyword("end-column"), int(39)) +v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) if err != nil { panic(err) } -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("cons")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.Apply(v16, []any{v15}) -v29 := lang.Apply(v27, []any{v15, v28}) -v30 := lang.Apply(v21, []any{v24, v14, v29}) -return v30 +return v14 }) -v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5668), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(5672), lang.NewKeyword("end-column"), int(56)) -v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) +v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2907), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2917), lang.NewKeyword("end-column"), int(41)) +v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) if err != nil { panic(err) } -var v12 any = v15 -_ = v12 -var v18 any -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("contains?")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +return v6 + case 2: +v3 := args[0] +v4 := args[1] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v21 := v20.Get() -v22 := lang.Apply(v6, []any{v4}) -v23 := lang.Apply(v21, []any{v22, v5}) -if lang.IsTruthy(v23) { -v18 = nil +v8 := v7.Get() +v9 := lang.Apply(v8, []any{lang1.IDrop, v4}) +if lang.IsTruthy(v9) { +var v11 any +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("pos?")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v3}) +if lang.IsTruthy(v15) { +var v16 any +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("int?")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v3}) +if lang.IsTruthy(v20) { +v16 = v3 } else { -var v24 any -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("contains?")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +v21 := lang.Apply(nil, []any{v3}) +v16 = v21 } -v27 := v26.Get() -v28 := lang.Apply(v10, []any{v4}) -v29 := lang.Apply(v27, []any{v28, v5}) -if lang.IsTruthy(v29) { -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("print-str")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +v22, _ := lang.FieldOrMethod(v4, "drop") +if reflect.TypeOf(v22).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("drop is not a function"))) } -v32 := v31.Get() -v33 := lang.Apply(v32, []any{v4, "already has", v5, "as ancestor"}) -v34 := lang.Apply(Exception24., []any{v33}) -panic(v34) +v23 := lang.Apply(v22, []any{v16}) +v11 = v23 } else { -v24 = nil +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("seq")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -_ = v24 -var v35 any -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("contains?")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v4}) +v11 = v27 } -v38 := v37.Get() -v39 := lang.Apply(v10, []any{v5}) -v40 := lang.Apply(v38, []any{v39, v4}) -if lang.IsTruthy(v40) { -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("print-str")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +var v10 any = v11 +_ = v10 +var v29 any +if lang.IsTruthy(v10) { +v29 = v10 +} else { +v29 = lang.NewList() } -v43 := v42.Get() -v44 := lang.Apply(v43, []any{"Cyclic derivation:", v5, "has", v4, "as ancestor"}) -v45 := lang.Apply(Exception24., []any{v44}) -panic(v45) +v5 = v29 } else { -v35 = nil +var v11 lang.FnFunc +v11 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v12 := args[0] +v13 := args[1] +recur_loop_539: +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("seq")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } -_ = v35 -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("assoc")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v13}) +var v14 any = v18 +_ = v14 +var v20 any +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("pos?")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -v48 := v47.Get() -v49 := lang.Apply(lang.NewKeyword("parents"), []any{v3}) -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("conj")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v12}) +var v21 any = v25 +_ = v21 +var v27 any +if lang.IsTruthy(v21) { +v27 = v14 +} else { +v27 = v21 } -v52 := v51.Get() -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("get")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +if lang.IsTruthy(v27) { +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("dec")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -v55 := v54.Get() -v56 := lang.CreatePersistentTreeSet() -v57 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5679), lang.NewKeyword("column"), int(61), lang.NewKeyword("end-line"), int(5679), lang.NewKeyword("end-column"), int(63)) -v58, err := lang.WithMeta(v56, v57.(lang.IPersistentMap)) -if err != nil { - panic(err) +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v12}) +var v21 any = v25 +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("rest")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v59 := lang.Apply(v55, []any{v6, v4, v58}) -v60 := lang.Apply(v52, []any{v59, v5}) -v61 := lang.Apply(v48, []any{v49, v4, v60}) -v62 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) -v63 := lang.Apply(v12, []any{v62, v4, v8, v5, v10}) -v64 := lang.Apply(lang.NewKeyword("descendants"), []any{v3}) -v65 := lang.Apply(v12, []any{v64, v5, v10, v4, v8}) -v66 := lang.NewMap(lang.NewKeyword("parents"), v61, lang.NewKeyword("ancestors"), v63, lang.NewKeyword("descendants"), v65) -v67 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5679), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(5681), lang.NewKeyword("end-column"), int(61)) -v68, err := lang.WithMeta(v66, v67.(lang.IPersistentMap)) +v29 := v28.Get() +v30 := lang.Apply(v29, []any{v14}) +var v26 any = v30 +v12 = v21 +v13 = v26 +goto recur_loop_539 +} else { +v20 = v14 +} +return v20 +}) +v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2925), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(2929), lang.NewKeyword("end-column"), int(28)) +v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) if err != nil { panic(err) } -v18 = v68 -} -var v17 any = v18 -_ = v17 -var v70 any -if lang.IsTruthy(v17) { -v70 = v17 -} else { -v70 = v3 +var v10 any = v13 +_ = v10 +var v15 lang.FnFunc +v15 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v16 := lang.Apply(v10, []any{v3, v4}) +return v16 +}) +v16 := lang.Apply(lang1.NewLazySeq, []any{v15}) +v5 = v16 } -return v70 +return v5 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -31901,103 +30236,225 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// future +// drop-last { -v0 := lang.NewSymbol("future").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Takes a body of expressions and yields a future object that will\n invoke the body in another thread, and will cache the result and\n return it on all subsequent calls to deref/@. If the computation has\n not yet finished, calls to deref/@ will block, unless the variant of\n deref with timeout is used. See also - realized?.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7052), lang.NewKeyword("end-line"), int(7052))).(*lang.Symbol) +v0 := lang.NewSymbol("drop-last").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return a lazy sequence of all but the last n (default 1) items in coll", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2932), lang.NewKeyword("end-line"), int(2932))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + case 1: v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("seq")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("concat")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("drop-last")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("list")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +v6 := v5.Get() +v7 := lang.Apply(v6, []any{int64(1), v3}) +return v7 + case 2: +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("map")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v14 := v13.Get() -v15 := lang.Apply(v14, []any{lang.NewSymbol("glojure.core/future-call")}) -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("list")) +v7 := v6.Get() +var v8 lang.FnFunc +v8 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v9 := args[0] +v10 := args[1] +return v9 +}) +v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2937), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(2937), lang.NewKeyword("end-column"), int(29)) +v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("drop")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v3, v4}) +v15 := lang.Apply(v7, []any{v10, v4, v14}) +return v15 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// drop-while +{ +v0 := lang.NewSymbol("drop-while").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred")), lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the items in coll starting from the\n first item for which (pred item) returns logical false. Returns a\n stateful transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2950), lang.NewKeyword("end-line"), int(2950))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("volatile!")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{true}) +var v6 any = v10 +_ = v6 +var v12 lang.FnFunc +v12 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v13 := lang.Apply(v5, nil) +return v13 + case 1: +v13 := args[0] +v14 := lang.Apply(v5, []any{v13}) +return v14 + case 2: +v13 := args[0] +v14 := args[1] +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("deref")) if v17.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } v18 := v17.Get() -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("seq")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v19 := lang.Apply(v18, []any{v6}) +var v15 any = v19 +_ = v15 +var v21 any +var v22 any = v15 +_ = v22 +var v24 any +if lang.IsTruthy(v22) { +v25 := lang.Apply(v3, []any{v14}) +v24 = v25 +} else { +v24 = v22 } -v21 := v20.Get() +if lang.IsTruthy(v24) { +v21 = v13 +} else { v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("concat")) +v23 := v22.FindInternedVar(lang.NewSymbol("vreset!")) if v23.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("list")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +v25 := lang.Apply(v24, []any{v6, nil}) +_ = v25 +v26 := lang.Apply(v5, []any{v13, v14}) +v21 = v26 } -v27 := v26.Get() -v28 := lang.Apply(v27, []any{lang.NewSymbol("fn*")}) -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("list")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +return v21 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2959), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(2968), lang.NewKeyword("end-column"), int(42)) +v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("apply")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +return v14 +}) +v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2957), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2968), lang.NewKeyword("end-column"), int(44)) +v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v34 := v33.Get() -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("vector")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +return v6 + case 2: +v3 := args[0] +v4 := args[1] +var v6 lang.FnFunc +v6 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v7 := args[0] +v8 := args[1] +recur_loop_552: +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("seq")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v37 := v36.Get() -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("seq")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +v12 := v11.Get() +v13 := lang.Apply(v12, []any{v8}) +var v9 any = v13 +_ = v9 +var v15 any +var v16 any = v9 +_ = v16 +var v18 any +if lang.IsTruthy(v16) { +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("first")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("concat")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v9}) +v23 := lang.Apply(v7, []any{v22}) +v18 = v23 +} else { +v18 = v16 } -v43 := v42.Get() -v44 := lang.Apply(v43, nil) -v45 := lang.Apply(v40, []any{v44}) -v46 := lang.Apply(v34, []any{v37, v45}) -v47 := lang.Apply(v31, []any{v46}) -v48 := lang.Apply(v24, []any{v28, v47, v5}) -v49 := lang.Apply(v21, []any{v48}) -v50 := lang.Apply(v18, []any{v49}) -v51 := lang.Apply(v11, []any{v15, v50}) -v52 := lang.Apply(v8, []any{v51}) -return v52 +if lang.IsTruthy(v18) { +var v16 any = v7 +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("rest")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, []any{v9}) +var v17 any = v21 +v7 = v16 +v8 = v17 +goto recur_loop_552 +} else { +v15 = v9 +} +return v15 +}) +v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2970), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(2974), lang.NewKeyword("end-column"), int(26)) +v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v5 any = v8 +_ = v5 +var v10 lang.FnFunc +v10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v11 := lang.Apply(v5, []any{v3, v4}) +return v11 +}) +v11 := lang.Apply(lang1.NewLazySeq, []any{v10}) +return v11 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -32006,275 +30463,212 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// cond->> +// elide-top-frames { -v0 := lang.NewSymbol("cond->>").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes an expression and a set of test/form pairs. Threads expr (via ->>)\n through each form for which the corresponding test expression\n is true. Note that, unlike cond branching, cond->> threading does not short circuit\n after the first true test expression.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7624), lang.NewKeyword("end-line"), int(7624))).(*lang.Symbol) +v0 := lang.NewSymbol("elide-top-frames").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4794), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(4794), lang.NewKeyword("end-column"), int(32), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ex"), lang.NewSymbol("class-name"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -_ = nil -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("gensym")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v6, ok := lang.FieldOrMethod(v3, "getStackTrace") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getStackTrace"))) } -v10 := v9.Get() -v11 := lang.Apply(v10, nil) -var v7 any = v11 -_ = v7 -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("map")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +var v7 any +switch reflect.TypeOf(v6).Kind() { +case reflect.Func: + v7 = lang.Apply(v6, nil) +default: + v7 = v6 } -v15 := v14.Get() -var v16 lang.FnFunc -v16 = lang.NewFnFunc(func(args ...any) any { +var v5 any = v7 +_ = v5 +var v9 any = v3 +_ = v9 +var v11 any +if lang.IsTruthy(v5) { +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("into-array")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("drop-while")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +var v18 lang.FnFunc +v18 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v17 := args[0] -var v18 any = v17 -_ = v18 +v19 := args[0] v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("nth")) +v21 := v20.FindInternedVar(lang.NewSymbol("=")) if v21.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } v22 := v21.Get() -v23 := lang.Apply(v22, []any{v18, int64(0), nil}) -var v19 any = v23 -_ = v19 -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("nth")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.Apply(v27, []any{v18, int64(1), nil}) -var v24 any = v28 -_ = v24 -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("seq")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("concat")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +v23, ok := lang.FieldOrMethod(v19, "getClassName") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v19, "getClassName"))) } -v38 := v37.Get() -v39 := lang.Apply(v38, []any{lang.NewSymbol("if")}) -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +var v24 any +switch reflect.TypeOf(v23).Kind() { +case reflect.Func: + v24 = lang.Apply(v23, nil) +default: + v24 = v23 } -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v19}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +v25 := lang.Apply(v22, []any{v4, v24}) +return v25 +}) +v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4801), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(4801), lang.NewKeyword("end-column"), int(77)) +v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v46 := v45.Get() -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("seq")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +v21 := lang.Apply(v17, []any{v20, v5}) +v22 := lang.Apply(v14, []any{nil, v21}) +v11 = v22 +} else { +v11 = nil } -v49 := v48.Get() -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("concat")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +v23, _ := lang.FieldOrMethod(v9, "setStackTrace") +if reflect.TypeOf(v23).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setStackTrace is not a function"))) } -v52 := v51.Get() -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("list")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +v24 := lang.Apply(v23, []any{v11}) +_ = v24 +return v9 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v55 := v54.Get() -v56 := lang.Apply(v55, []any{lang.NewSymbol("glojure.core/->>")}) -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("list")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) } -v59 := v58.Get() -v60 := lang.Apply(v59, []any{v7}) -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("list")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +// emit-extend-protocol +{ +v0 := lang.NewSymbol("emit-extend-protocol").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(205), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(205), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("p"), lang.NewSymbol("specs"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("parse-impls")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v63 := v62.Get() -v64 := lang.Apply(v63, []any{v24}) -v65 := lang.Apply(v52, []any{v56, v60, v64}) -v66 := lang.Apply(v49, []any{v65}) -v67 := lang.Apply(v46, []any{v66}) -v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v69 := v68.FindInternedVar(lang.NewSymbol("list")) -if v69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v4}) +var v5 any = v9 +_ = v5 +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("seq")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v70 := v69.Get() -v71 := lang.Apply(v70, []any{v7}) -v72 := lang.Apply(v35, []any{v39, v43, v67, v71}) -v73 := lang.Apply(v32, []any{v72}) -return v73 -}) -v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7633), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7633), lang.NewKeyword("end-column"), int(67)) -v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) -if err != nil { - panic(err) +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("concat")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("partition")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v16 := v15.Get() +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("list")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v21 := v20.Get() -v22 := lang.Apply(v21, []any{int64(2), v6}) -v23 := lang.Apply(v15, []any{v18, v22}) -var v12 any = v23 -_ = v12 -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("seq")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +v19 := v18.Get() +v20 := lang.Apply(v19, []any{lang.NewSymbol("do")}) +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("map")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v27 := v26.Get() +v23 := v22.Get() +var v24 lang.FnFunc +v24 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v25 := args[0] +var v26 any = v25 +_ = v26 v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("concat")) +v29 := v28.FindInternedVar(lang.NewSymbol("nth")) if v29.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/let")}) -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("list")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +v31 := lang.Apply(v30, []any{v26, int64(0), nil}) +var v27 any = v31 +_ = v27 +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("nth")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) } -v37 := v36.Get() +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v26, int64(1), nil}) +var v32 any = v36 +_ = v32 v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("apply")) +v39 := v38.FindInternedVar(lang.NewSymbol("seq")) if v39.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) } v40 := v39.Get() v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("vector")) +v42 := v41.FindInternedVar(lang.NewSymbol("concat")) if v42.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } v43 := v42.Get() v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("seq")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) if v45.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } v46 := v45.Get() -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("concat")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +v47 := lang.Apply(v46, []any{lang.NewSymbol("glojure.core/extend-type")}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) } -v49 := v48.Get() -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("list")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.Apply(v52, []any{v7}) -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("list")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) -} -v56 := v55.Get() -v57 := lang.Apply(v56, []any{v5}) -v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v59 := v58.FindInternedVar(lang.NewSymbol("interleave")) -if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) -} -v60 := v59.Get() -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("repeat")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) -} -v63 := v62.Get() -v64 := lang.Apply(v63, []any{v7}) -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("butlast")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) -} -v67 := v66.Get() -v68 := lang.Apply(v67, []any{v12}) -v69 := lang.Apply(v60, []any{v64, v68}) -v70 := lang.Apply(v49, []any{v53, v57, v69}) -v71 := lang.Apply(v46, []any{v70}) -v72 := lang.Apply(v40, []any{v43, v71}) -v73 := lang.Apply(v37, []any{v72}) -v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v75 := v74.FindInternedVar(lang.NewSymbol("list")) -if v75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) -} -v76 := v75.Get() -var v77 any -v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v79 := v78.FindInternedVar(lang.NewSymbol("empty?")) -if v79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) -} -v80 := v79.Get() -v81 := lang.Apply(v80, []any{v12}) -if lang.IsTruthy(v81) { -v77 = v7 -} else { -v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v83 := v82.FindInternedVar(lang.NewSymbol("last")) -if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v27}) +v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v53 := v52.FindInternedVar(lang.NewSymbol("list")) +if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) } -v84 := v83.Get() -v85 := lang.Apply(v84, []any{v12}) -v77 = v85 +v54 := v53.Get() +v55 := lang.Apply(v54, []any{v3}) +v56 := lang.Apply(v43, []any{v47, v51, v55, v32}) +v57 := lang.Apply(v40, []any{v56}) +return v57 +}) +v25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(208), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(209), lang.NewKeyword("end-column"), int(42)) +v26, err := lang.WithMeta(v24, v25.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v86 := lang.Apply(v76, []any{v77}) -v87 := lang.Apply(v30, []any{v34, v73, v86}) -v88 := lang.Apply(v27, []any{v87}) -return v88 - } +v27 := lang.Apply(v23, []any{v26, v5}) +v28 := lang.Apply(v16, []any{v20, v27}) +v29 := lang.Apply(v13, []any{v28}) +return v29 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -32282,325 +30676,74 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// pmap +// emit-extend-type { -v0 := lang.NewSymbol("pmap").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Like map, except f is applied in parallel. Semi-lazy in that the\n parallel computation stays ahead of the consumption, but doesn't\n realize the entire result unless required. Only useful for\n computationally intensive functions where the time of f dominates\n the coordination overhead.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7074), lang.NewKeyword("end-line"), int(7074))).(*lang.Symbol) +v0 := lang.NewSymbol("emit-extend-type").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(175), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(175), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"), lang.NewSymbol("specs"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] v4 := args[1] v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("+")) +v7 := v6.FindInternedVar(lang.NewSymbol("parse-impls")) if v7.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } v8 := v7.Get() -v9 := lang.Apply(runtime25.NumCPU, nil) -v10 := lang.Apply(v8, []any{int64(2), v9}) -var v5 any = v10 +v9 := lang.Apply(v8, []any{v4}) +var v5 any = v9 _ = v5 -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("map")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("seq")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v14 := v13.Get() -var v15 lang.FnFunc -v15 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v16 := args[0] +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("concat")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("future-call")) +v18 := v17.FindInternedVar(lang.NewSymbol("list")) if v18.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } v19 := v18.Get() -var v20 lang.FnFunc -v20 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v21 := lang.Apply(v3, []any{v16}) -return v21 -}) -v21 := lang.Apply(v19, []any{v20}) -return v21 -}) -v16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7084), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7084), lang.NewKeyword("end-column"), int(34)) -v17, err := lang.WithMeta(v15, v16.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v18 := lang.Apply(v14, []any{v17, v4}) -var v11 any = v18 -_ = v11 -var v20 lang.FnFunc -{ // function step -v20 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v22 := args[0] -v23 := args[1] -var v24 any = v22 -_ = v24 -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("seq")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.Apply(v28, []any{v24}) -var v25 any = v29 -_ = v25 -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("first")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v25}) -var v30 any = v34 -_ = v30 -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("next")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v35}) -var v35 any = v39 -_ = v35 -var v40 any = v30 -_ = v40 -var v41 any = v35 -_ = v41 -var v42 any = v24 -_ = v42 -var v44 lang.FnFunc -v44 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("seq")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) -} -v48 := v47.Get() -v49 := lang.Apply(v48, []any{v23}) -var v45 any = v49 -_ = v45 -var v51 any -if lang.IsTruthy(v45) { -var v52 any = v45 -_ = v52 -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("cons")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) -} -v56 := v55.Get() -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("deref")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) -} -v59 := v58.Get() -v60 := lang.Apply(v59, []any{v40}) -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("rest")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) -} -v63 := v62.Get() -v64 := lang.Apply(v63, []any{v52}) -v65 := lang.Apply(v21, []any{v41, v64}) -v66 := lang.Apply(v56, []any{v60, v65}) -v51 = v66 -} else { -v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("map")) -if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) -} -v54 := v53.Get() -v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v56 := v55.FindInternedVar(lang.NewSymbol("deref")) -if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) -} -v57 := v56.Get() -v58 := lang.Apply(v54, []any{v57, v42}) -v51 = v58 -} -return v51 -}) -v45 := lang.Apply(lang1.NewLazySeq, []any{v44}) -return v45 -}) -v21 := v20 -_ = v21 -} -v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7085), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(7089), lang.NewKeyword("end-column"), int(36)) -v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v19 any = v22 -_ = v19 -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("drop")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v5, v11}) -v28 := lang.Apply(v19, []any{v11, v27}) -return v28 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -var v7 lang.FnFunc -{ // function step -v7 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v9 := args[0] -var v10 lang.FnFunc -v10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("map")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("seq")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v14, []any{v17, v9}) -var v11 any = v18 -_ = v11 -var v20 any +v20 := lang.Apply(v19, []any{lang.NewSymbol("glojure.core/extend")}) v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("every?")) +v22 := v21.FindInternedVar(lang.NewSymbol("list")) if v22.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("identity")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +v24 := lang.Apply(v23, []any{v3}) +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("mapcat")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -v26 := v25.Get() -v27 := lang.Apply(v23, []any{v26, v11}) -if lang.IsTruthy(v27) { +v27 := v26.Get() v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("cons")) +v29 := v28.FindInternedVar(lang.NewSymbol("partial")) if v29.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } v30 := v29.Get() v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("map")) +v32 := v31.FindInternedVar(lang.NewSymbol("emit-hinted-impl")) if v32.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("first")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.Apply(v33, []any{v36, v11}) -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("map")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("rest")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v40, []any{v43, v11}) -v45 := lang.Apply(v8, []any{v44}) -v46 := lang.Apply(v30, []any{v37, v45}) -v20 = v46 -} else { -v20 = nil -} -return v20 -}) -v11 := lang.Apply(lang1.NewLazySeq, []any{v10}) -return v11 -}) -v8 := v7 -_ = v8 -} -v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7092), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(7096), lang.NewKeyword("end-column"), int(67)) -v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v6 any = v9 -_ = v6 -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("pmap")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -var v14 lang.FnFunc -v14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v15 := args[0] -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("apply")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v3, v15}) -return v19 -}) -v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7097), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(7097), lang.NewKeyword("end-column"), int(23)) -v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("cons")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v4, v5}) -v21 := lang.Apply(v6, []any{v20}) -v22 := lang.Apply(v13, []any{v16, v21}) -return v22 - } +v34 := lang.Apply(v30, []any{v33, v3}) +v35 := lang.Apply(v27, []any{v34, v5}) +v36 := lang.Apply(v16, []any{v20, v24, v35}) +v37 := lang.Apply(v13, []any{v36}) +return v37 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -32608,221 +30751,287 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// defonce +// emit-hinted-impl { -v0 := lang.NewSymbol("defonce").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("expr"))), lang.NewKeyword("doc"), "defs name to have the root value of the expr iff the named var has no root value,\n else expr is unevaluated", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5849), lang.NewKeyword("end-line"), int(5849))).(*lang.Symbol) +v0 := lang.NewSymbol("emit-hinted-impl").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(163), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(163), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"), lang.NewVector(lang.NewSymbol("p"), lang.NewSymbol("fs")))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 4 { + if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] v4 := args[1] -v5 := args[2] -v6 := args[3] +var v5 any = v4 +_ = v5 v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("seq")) +v8 := v7.FindInternedVar(lang.NewSymbol("nth")) if v8.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("concat")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("list")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/let")}) -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("list")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +v10 := lang.Apply(v9, []any{v5, int64(0), nil}) +var v6 any = v10 +_ = v6 +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("nth")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("apply")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v5, int64(1), nil}) +var v11 any = v15 +_ = v11 +var v18 lang.FnFunc +v18 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v19 := args[0] +var v21 any +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("vector?")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("vector")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("first")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("seq")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +v27 := v26.Get() +v28 := lang.Apply(v27, []any{v20}) +v29 := lang.Apply(v24, []any{v28}) +if lang.IsTruthy(v29) { +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("list")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) } -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("concat")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +v32 := v31.Get() +v33 := lang.Apply(v32, []any{v20}) +v21 = v33 +} else { +v21 = v20 } -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +var v20 any = v21 +_ = v20 +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("map")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) } -v34 := v33.Get() -v35 := lang.Apply(v34, []any{lang.NewSymbol("v__0__auto__")}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("seq")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) -} -v41 := v40.Get() +v37 := v36.Get() +var v38 lang.FnFunc +v38 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v39 := args[0] +var v40 any = v39 +_ = v40 v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("concat")) +v43 := v42.FindInternedVar(lang.NewSymbol("seq")) if v43.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) } v44 := v43.Get() -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("list")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +v45 := lang.Apply(v44, []any{v40}) +var v41 any = v45 +_ = v41 +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("first")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) } -v47 := v46.Get() -v48 := lang.Apply(v47, []any{lang.NewSymbol("def")}) -v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v50 := v49.FindInternedVar(lang.NewSymbol("list")) -if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) +v49 := v48.Get() +v50 := lang.Apply(v49, []any{v41}) +var v46 any = v50 +_ = v46 +v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v53 := v52.FindInternedVar(lang.NewSymbol("next")) +if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) } -v51 := v50.Get() -v52 := lang.Apply(v51, []any{v5}) -v53 := lang.Apply(v44, []any{v48, v52}) -v54 := lang.Apply(v41, []any{v53}) -v55 := lang.Apply(v38, []any{v54}) -v56 := lang.Apply(v31, []any{v35, v55}) -v57 := lang.Apply(v28, []any{v56}) -v58 := lang.Apply(v22, []any{v25, v57}) -v59 := lang.Apply(v19, []any{v58}) -v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v61 := v60.FindInternedVar(lang.NewSymbol("list")) -if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) +v54 := v53.Get() +v55 := lang.Apply(v54, []any{v51}) +var v51 any = v55 +_ = v51 +var v56 any = v46 +_ = v56 +v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v59 := v58.FindInternedVar(lang.NewSymbol("seq")) +if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) } -v62 := v61.Get() +v60 := v59.Get() +v61 := lang.Apply(v60, []any{v56}) +var v57 any = v61 +_ = v57 v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v64 := v63.FindInternedVar(lang.NewSymbol("seq")) +v64 := v63.FindInternedVar(lang.NewSymbol("first")) if v64.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) } v65 := v64.Get() -v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v67 := v66.FindInternedVar(lang.NewSymbol("concat")) -if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) -} -v68 := v67.Get() -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("list")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) -} -v71 := v70.Get() -v72 := lang.Apply(v71, []any{lang.NewSymbol("glojure.core/when-not")}) -v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v74 := v73.FindInternedVar(lang.NewSymbol("list")) -if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) +v66 := lang.Apply(v65, []any{v57}) +var v62 any = v66 +_ = v62 +v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v69 := v68.FindInternedVar(lang.NewSymbol("next")) +if v69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) } -v75 := v74.Get() +v70 := v69.Get() +v71 := lang.Apply(v70, []any{v67}) +var v67 any = v71 +_ = v67 +var v72 any = v62 +_ = v72 +var v73 any = v67 +_ = v73 +var v74 any = v51 +_ = v74 v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v77 := v76.FindInternedVar(lang.NewSymbol("seq")) +v77 := v76.FindInternedVar(lang.NewSymbol("cons")) if v77.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) } v78 := v77.Get() v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v80 := v79.FindInternedVar(lang.NewSymbol("concat")) +v80 := v79.FindInternedVar(lang.NewSymbol("apply")) if v80.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) } v81 := v80.Get() v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v83 := v82.FindInternedVar(lang.NewSymbol("list")) +v83 := v82.FindInternedVar(lang.NewSymbol("vector")) if v83.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) } v84 := v83.Get() -v85 := lang.Apply(v84, []any{lang.NewSymbol(".HasRoot")}) -v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v87 := v86.FindInternedVar(lang.NewSymbol("list")) -if v87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) +v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v86 := v85.FindInternedVar(lang.NewSymbol("vary-meta")) +if v86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) } -v88 := v87.Get() -v89 := lang.Apply(v88, []any{lang.NewSymbol("v__0__auto__")}) -v90 := lang.Apply(v81, []any{v85, v89}) -v91 := lang.Apply(v78, []any{v90}) -v92 := lang.Apply(v75, []any{v91}) -v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v94 := v93.FindInternedVar(lang.NewSymbol("list")) -if v94.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) +v87 := v86.Get() +v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v89 := v88.FindInternedVar(lang.NewSymbol("assoc")) +if v89.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) } -v95 := v94.Get() -v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v97 := v96.FindInternedVar(lang.NewSymbol("seq")) -if v97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) +v90 := v89.Get() +v91 := lang.Apply(v87, []any{v72, v90, lang.NewKeyword("tag"), v3}) +v92 := lang.Apply(v81, []any{v84, v91, v73}) +v93 := lang.Apply(v78, []any{v92, v74}) +return v93 +}) +v39 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(168), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(170), lang.NewKeyword("end-column"), int(36)) +v40, err := lang.WithMeta(v38, v39.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v98 := v97.Get() -v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v100 := v99.FindInternedVar(lang.NewSymbol("concat")) -if v100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) +v41 := lang.Apply(v37, []any{v40, v20}) +return v41 +}) +v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(164), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(171), lang.NewKeyword("end-column"), int(30)) +v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v101 := v100.Get() -v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v103 := v102.FindInternedVar(lang.NewSymbol("list")) -if v103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) +var v17 any = v20 +_ = v17 +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("zipmap")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -v104 := v103.Get() -v105 := lang.Apply(v104, []any{lang.NewSymbol("def")}) -v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v107 := v106.FindInternedVar(lang.NewSymbol("list")) -if v107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("map")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -v108 := v107.Get() -v109 := lang.Apply(v108, []any{v5}) -v110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v111 := v110.FindInternedVar(lang.NewSymbol("list")) -if v111.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v111))) +v27 := v26.Get() +var v28 lang.FnFunc +v28 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v29 := args[0] +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("keyword")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) } -v112 := v111.Get() -v113 := lang.Apply(v112, []any{v6}) -v114 := lang.Apply(v101, []any{v105, v109, v113}) -v115 := lang.Apply(v98, []any{v114}) -v116 := lang.Apply(v95, []any{v115}) -v117 := lang.Apply(v68, []any{v72, v92, v116}) -v118 := lang.Apply(v65, []any{v117}) -v119 := lang.Apply(v62, []any{v118}) -v120 := lang.Apply(v12, []any{v16, v59, v119}) -v121 := lang.Apply(v9, []any{v120}) -return v121 +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("name")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("first")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v29}) +v40 := lang.Apply(v35, []any{v39}) +v41 := lang.Apply(v32, []any{v40}) +return v41 +}) +v29 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(172), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(172), lang.NewKeyword("end-column"), int(46)) +v30, err := lang.WithMeta(v28, v29.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v31 := lang.Apply(v27, []any{v30, v11}) +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("map")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +var v35 lang.FnFunc +v35 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v36 := args[0] +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("cons")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("drop")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{int64(1), v36}) +v44 := lang.Apply(v17, []any{v43}) +v45 := lang.Apply(v39, []any{lang.NewSymbol("glojure.core/fn"), v44}) +return v45 +}) +v36 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(173), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(173), lang.NewKeyword("end-column"), int(49)) +v37, err := lang.WithMeta(v35, v36.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v38 := lang.Apply(v34, []any{v37, v11}) +v39 := lang.Apply(v24, []any{v31, v38}) +v40 := lang.NewVector(v6, v39) +v41 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(172), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(173), lang.NewKeyword("end-column"), int(55)) +v42, err := lang.WithMeta(v40, v41.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v42 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -32830,96 +31039,98 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// dorun +// empty { -v0 := lang.NewSymbol("dorun").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "When lazy sequences are produced via functions that have side\n effects, any effects other than those needed to produce the first\n element in the seq do not occur until the seq is consumed. dorun can\n be used to force any effects. Walks through the successive nexts of\n the seq, does not retain the head and returns nil.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3116), lang.NewKeyword("end-line"), int(3116))).(*lang.Symbol) +v0 := lang.NewSymbol("empty").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns an empty collection of the same category as coll, or nil", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5265), lang.NewKeyword("end-line"), int(5265))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] -recur_loop_579: +var v4 any v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) if v6.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -var v4 any = v8 -_ = v4 +v8 := lang.Apply(v7, []any{lang1.IPersistentCollection, v3}) +if lang.IsTruthy(v8) { +v9, ok := lang.FieldOrMethod(v3, "empty") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "empty"))) +} var v10 any -if lang.IsTruthy(v4) { -var v11 any = v4 -_ = v11 -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("next")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +switch reflect.TypeOf(v9).Kind() { +case reflect.Func: + v10 = lang.Apply(v9, nil) +default: + v10 = v9 } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v11}) -var v13 any = v17 -v3 = v13 -goto recur_loop_579 +v4 = v10 } else { -v10 = nil +v4 = nil } -return v10 - case 2: -v3 := args[0] -v4 := args[1] -recur_loop_580: -var v5 any -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("seq")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v4}) -var v6 any = v10 -_ = v6 -var v12 any -if lang.IsTruthy(v6) { -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("pos?")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v3}) -v12 = v16 -} else { -v12 = v6 +// empty? +{ +v0 := lang.NewSymbol("empty?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll has no items. To check the emptiness of a seq,\n please use the idiom (seq x) rather than (not (empty? x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6290), lang.NewKeyword("end-line"), int(6290))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("counted?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -if lang.IsTruthy(v12) { -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("dec")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +if lang.IsTruthy(v8) { +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("zero?")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v3}) -var v6 any = v10 +v11 := v10.Get() v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("next")) +v13 := v12.FindInternedVar(lang.NewSymbol("count")) if v13.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } v14 := v13.Get() -v15 := lang.Apply(v14, []any{v4}) -var v11 any = v15 -v3 = v6 -v4 = v11 -goto recur_loop_580 +v15 := lang.Apply(v14, []any{v3}) +v16 := lang.Apply(v11, []any{v15}) +v4 = v16 } else { -v5 = nil +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("not")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -return v5 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("seq")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.Apply(v22, []any{v3}) +v24 := lang.Apply(v19, []any{v23}) +v4 = v24 +} +return v4 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -32927,450 +31138,82 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// max-switch-table-size +// ensure { -v0 := lang.NewSymbol("max-switch-table-size").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6645), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(6645), lang.NewKeyword("end-column"), int(36), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, int64(8192), true) +v0 := lang.NewSymbol("ensure").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref"))), lang.NewKeyword("doc"), "Must be called in a transaction. Protects the ref from modification\n by other transactions. Returns the in-transaction-value of\n ref. Allows for more concurrency than (ref-set ref @ref)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2480), lang.NewKeyword("end-line"), int(2480))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, _ := lang.FieldOrMethod(v3, "touch") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("touch is not a function"))) +} +v5 := lang.Apply(v4, []any{}) +_ = v5 +v6, _ := lang.FieldOrMethod(v3, "deref") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("deref is not a function"))) +} +v7 := lang.Apply(v6, []any{}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// assert +// ensure-reduced { -v0 := lang.NewSymbol("assert").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("message"))), lang.NewKeyword("doc"), "Evaluates expression x and throws an AssertionError with optional\n message if x does not evaluate to logical true.\n\n Assertion checks are omitted from compiled code if '*assert*' is\n false.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4837), lang.NewKeyword("end-line"), int(4837))).(*lang.Symbol) +v0 := lang.NewSymbol("ensure-reduced").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "If x is already reduced?, returns it, else returns (reduced x)", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2841), lang.NewKeyword("end-line"), int(2841))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 3: + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] -v4 := args[1] -v5 := args[2] -var v6 any -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("*assert*")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -if lang.IsTruthy(v9) { -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("seq")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("reduced?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("concat")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +if lang.IsTruthy(v8) { +v4 = v3 +} else { +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("reduced")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("list")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v3}) +v4 = v12 } -v18 := v17.Get() -v19 := lang.Apply(v18, []any{lang.NewSymbol("glojure.core/when-not")}) -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("list")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v22 := v21.Get() -v23 := lang.Apply(v22, []any{v5}) -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("list")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("seq")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("concat")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("list")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{lang.NewSymbol("throw")}) -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("list")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("seq")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("concat")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("list")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) -} -v48 := v47.Get() -v49 := lang.Apply(v48, []any{lang.NewSymbol("new")}) -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("list")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.Apply(v52, []any{lang.NewSymbol("glojure.core/AssertionError")}) -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("list")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) -} -v56 := v55.Get() -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("seq")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) -} -v59 := v58.Get() -v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v61 := v60.FindInternedVar(lang.NewSymbol("concat")) -if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) -} -v62 := v61.Get() -v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v64 := v63.FindInternedVar(lang.NewSymbol("list")) -if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) -} -v65 := v64.Get() -v66 := lang.Apply(v65, []any{lang.NewSymbol("glojure.core/str")}) -v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v68 := v67.FindInternedVar(lang.NewSymbol("list")) -if v68.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) -} -v69 := v68.Get() -v70 := lang.Apply(v69, []any{"Assert failed: "}) -v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v72 := v71.FindInternedVar(lang.NewSymbol("list")) -if v72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) -} -v73 := v72.Get() -v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v75 := v74.FindInternedVar(lang.NewSymbol("seq")) -if v75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) -} -v76 := v75.Get() -v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v78 := v77.FindInternedVar(lang.NewSymbol("concat")) -if v78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) -} -v79 := v78.Get() -v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v81 := v80.FindInternedVar(lang.NewSymbol("list")) -if v81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) -} -v82 := v81.Get() -v83 := lang.Apply(v82, []any{lang.NewSymbol("glojure.core/pr-str")}) -v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v85 := v84.FindInternedVar(lang.NewSymbol("list")) -if v85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) -} -v86 := v85.Get() -v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v88 := v87.FindInternedVar(lang.NewSymbol("seq")) -if v88.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) -} -v89 := v88.Get() -v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v91 := v90.FindInternedVar(lang.NewSymbol("concat")) -if v91.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) -} -v92 := v91.Get() -v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v94 := v93.FindInternedVar(lang.NewSymbol("list")) -if v94.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) -} -v95 := v94.Get() -v96 := lang.Apply(v95, []any{lang.NewSymbol("quote")}) -v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v98 := v97.FindInternedVar(lang.NewSymbol("list")) -if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) -} -v99 := v98.Get() -v100 := lang.Apply(v99, []any{v5}) -v101 := lang.Apply(v92, []any{v96, v100}) -v102 := lang.Apply(v89, []any{v101}) -v103 := lang.Apply(v86, []any{v102}) -v104 := lang.Apply(v79, []any{v83, v103}) -v105 := lang.Apply(v76, []any{v104}) -v106 := lang.Apply(v73, []any{v105}) -v107 := lang.Apply(v62, []any{v66, v70, v106}) -v108 := lang.Apply(v59, []any{v107}) -v109 := lang.Apply(v56, []any{v108}) -v110 := lang.Apply(v45, []any{v49, v53, v109}) -v111 := lang.Apply(v42, []any{v110}) -v112 := lang.Apply(v39, []any{v111}) -v113 := lang.Apply(v32, []any{v36, v112}) -v114 := lang.Apply(v29, []any{v113}) -v115 := lang.Apply(v26, []any{v114}) -v116 := lang.Apply(v15, []any{v19, v23, v115}) -v117 := lang.Apply(v12, []any{v116}) -v6 = v117 -} else { -v6 = nil -} -return v6 - case 4: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -var v7 any -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("*assert*")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -if lang.IsTruthy(v10) { -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("seq")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("concat")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("list")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{lang.NewSymbol("glojure.core/when-not")}) -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("list")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v5}) -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("list")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("seq")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("concat")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("list")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.Apply(v36, []any{lang.NewSymbol("throw")}) -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("list")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("seq")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("concat")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("list")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) -} -v49 := v48.Get() -v50 := lang.Apply(v49, []any{lang.NewSymbol("new")}) -v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v52 := v51.FindInternedVar(lang.NewSymbol("list")) -if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) -} -v53 := v52.Get() -v54 := lang.Apply(v53, []any{lang.NewSymbol("glojure.core/AssertionError")}) -v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v56 := v55.FindInternedVar(lang.NewSymbol("list")) -if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) -} -v57 := v56.Get() -v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v59 := v58.FindInternedVar(lang.NewSymbol("seq")) -if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) -} -v60 := v59.Get() -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("concat")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) -} -v63 := v62.Get() -v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v65 := v64.FindInternedVar(lang.NewSymbol("list")) -if v65.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) -} -v66 := v65.Get() -v67 := lang.Apply(v66, []any{lang.NewSymbol("glojure.core/str")}) -v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v69 := v68.FindInternedVar(lang.NewSymbol("list")) -if v69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) -} -v70 := v69.Get() -v71 := lang.Apply(v70, []any{"Assert failed: "}) -v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v73 := v72.FindInternedVar(lang.NewSymbol("list")) -if v73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) -} -v74 := v73.Get() -v75 := lang.Apply(v74, []any{v6}) -v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v77 := v76.FindInternedVar(lang.NewSymbol("list")) -if v77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) -} -v78 := v77.Get() -v79 := lang.Apply(v78, []any{"\n"}) -v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v81 := v80.FindInternedVar(lang.NewSymbol("list")) -if v81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) -} -v82 := v81.Get() -v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v84 := v83.FindInternedVar(lang.NewSymbol("seq")) -if v84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) -} -v85 := v84.Get() -v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v87 := v86.FindInternedVar(lang.NewSymbol("concat")) -if v87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) -} -v88 := v87.Get() -v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v90 := v89.FindInternedVar(lang.NewSymbol("list")) -if v90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) -} -v91 := v90.Get() -v92 := lang.Apply(v91, []any{lang.NewSymbol("glojure.core/pr-str")}) -v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v94 := v93.FindInternedVar(lang.NewSymbol("list")) -if v94.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) -} -v95 := v94.Get() -v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v97 := v96.FindInternedVar(lang.NewSymbol("seq")) -if v97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) -} -v98 := v97.Get() -v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v100 := v99.FindInternedVar(lang.NewSymbol("concat")) -if v100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) -} -v101 := v100.Get() -v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v103 := v102.FindInternedVar(lang.NewSymbol("list")) -if v103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) -} -v104 := v103.Get() -v105 := lang.Apply(v104, []any{lang.NewSymbol("quote")}) -v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v107 := v106.FindInternedVar(lang.NewSymbol("list")) -if v107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) -} -v108 := v107.Get() -v109 := lang.Apply(v108, []any{v5}) -v110 := lang.Apply(v101, []any{v105, v109}) -v111 := lang.Apply(v98, []any{v110}) -v112 := lang.Apply(v95, []any{v111}) -v113 := lang.Apply(v88, []any{v92, v112}) -v114 := lang.Apply(v85, []any{v113}) -v115 := lang.Apply(v82, []any{v114}) -v116 := lang.Apply(v63, []any{v67, v71, v75, v79, v115}) -v117 := lang.Apply(v60, []any{v116}) -v118 := lang.Apply(v57, []any{v117}) -v119 := lang.Apply(v46, []any{v50, v54, v118}) -v120 := lang.Apply(v43, []any{v119}) -v121 := lang.Apply(v40, []any{v120}) -v122 := lang.Apply(v33, []any{v37, v121}) -v123 := lang.Apply(v30, []any{v122}) -v124 := lang.Apply(v27, []any{v123}) -v125 := lang.Apply(v16, []any{v20, v24, v124}) -v126 := lang.Apply(v13, []any{v125}) -v7 = v126 -} else { -v7 = nil -} -return v7 - default: +// enumeration-seq +{ +v0 := lang.NewSymbol("enumeration-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("e"))), lang.NewKeyword("doc"), "Returns a seq on a java.util.Enumeration", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5753), lang.NewKeyword("end-line"), int(5753))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } +v3 := args[0] +v4 := lang.Apply(nil, []any{v3}) +return v4 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -33378,75 +31221,55 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// assoc! +// error-handler { -v0 := lang.NewSymbol("assoc!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("key"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("key"), lang.NewSymbol("val"), lang.NewSymbol("&"), lang.NewSymbol("kvs"))), lang.NewKeyword("doc"), "When applied to a transient map, adds mapping of key(s) to\n val(s). When applied to a transient vector, sets the val at index.\n Note - index must be <= (count vector). Returns coll.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3369), lang.NewKeyword("end-line"), int(3369))).(*lang.Symbol) +v0 := lang.NewSymbol("error-handler").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("doc"), "Returns the error-handler of agent a, or nil if there is none.\n See set-error-handler!", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2202), lang.NewKeyword("end-line"), int(2202))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 3: + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] -v4 := args[1] -v5 := args[2] -v6, _ := lang.FieldOrMethod(v3, "Assoc") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Assoc is not a function"))) +v4, ok := lang.FieldOrMethod(v3, "getErrorHandler") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getErrorHandler"))) } -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -recur_loop_609: -v8, _ := lang.FieldOrMethod(v3, "Assoc") -if reflect.TypeOf(v8).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Assoc is not a function"))) +var v5 any +switch reflect.TypeOf(v4).Kind() { +case reflect.Func: + v5 = lang.Apply(v4, nil) +default: + v5 = v4 } -v9 := lang.Apply(v8, []any{v4, v5}) -var v7 any = v9 -_ = v7 -var v11 any -if lang.IsTruthy(v6) { -var v12 any = v7 -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("first")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v6}) -var v13 any = v17 -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("second")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v6}) -var v18 any = v22 -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("nnext")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +// error-mode +{ +v0 := lang.NewSymbol("error-mode").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("doc"), "Returns the error-mode of agent a. See set-error-mode!", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2227), lang.NewKeyword("end-line"), int(2227))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, ok := lang.FieldOrMethod(v3, "getErrorMode") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getErrorMode"))) } -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v6}) -var v23 any = v27 -v3 = v12 -v4 = v13 -v5 = v18 -v6 = v23 -goto recur_loop_609 -} else { -v11 = v7 +var v5 any +switch reflect.TypeOf(v4).Kind() { +case reflect.Func: + v5 = lang.Apply(v4, nil) +default: + v5 = v4 } -return v11 - } +return v5 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -33454,17 +31277,20 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// tagged-literal +// eval { -v0 := lang.NewSymbol("tagged-literal").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag"), lang.NewSymbol("form"))), lang.NewKeyword("doc"), "Construct a data representation of a tagged literal from a\n tag symbol and a form.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7812), lang.NewKeyword("end-line"), int(7812))).(*lang.Symbol) +v0 := lang.NewSymbol("eval").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("form"))), lang.NewKeyword("doc"), "Evaluates the form data structure (not text!) and returns the result.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3203), lang.NewKeyword("end-line"), int(3203))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := args[1] -v5 := lang.Apply(nil, []any{v3, v4}) +v4, _ := lang.FieldOrMethod(runtime9.Compiler, "Eval") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Eval is not a function"))) +} +v5 := lang.Apply(v4, []any{v3}) return v5 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -33473,9 +31299,9 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// assert-valid-fdecl +// even? { -v0 := lang.NewSymbol("assert-valid-fdecl").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fdecl"))), lang.NewKeyword("doc"), "A good fdecl looks like (([a] ...) ([a b] ...)) near the end of defn.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(42), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(7545), lang.NewKeyword("end-line"), int(7545), lang.NewKeyword("private"), true, lang.NewKeyword("dynamic"), true)).(*lang.Symbol) +v0 := lang.NewSymbol("even?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is even, throws an exception if n is not an integer", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1381), lang.NewKeyword("end-line"), int(1381))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -33484,154 +31310,41 @@ v2 = lang.NewFnFunc(func(args ...any) any { v3 := args[0] var v4 any v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("empty?")) +v6 := v5.FindInternedVar(lang.NewSymbol("integer?")) if v6.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } v7 := v6.Get() v8 := lang.Apply(v7, []any{v3}) if lang.IsTruthy(v8) { -v9 := lang.Apply(lang1.NewIllegalArgumentError, []any{"Parameter declaration missing"}) -panic(v9) -} else { -v4 = nil -} -_ = v4 -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("map")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -var v14 lang.FnFunc -v14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v15 := args[0] -var v16 any -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq?")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v15}) -if lang.IsTruthy(v20) { -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("first")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v15}) -v16 = v24 -} else { -var v25 any -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("seq?")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("first")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("zero?")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -v31 := v30.Get() -v32 := lang.Apply(v31, []any{v3}) -v33 := lang.Apply(v28, []any{v32}) -if lang.IsTruthy(v33) { -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("str")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("bit-and")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } -v36 := v35.Get() -v37 := lang.Apply(v36, []any{"Invalid signature \"", v15, "\" should be a list"}) -v25 = v37 +v14 := v13.Get() +v15 := lang.Apply(lang1.UncheckedLongCast, []any{v3}) +v16 := lang.Apply(v14, []any{v15, int64(1)}) +v17 := lang.Apply(v11, []any{v16}) +v4 = v17 } else { -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("str")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.Apply(v40, []any{"Parameter declaration \"", v15, "\" should be a vector"}) -v25 = v41 -} -v42 := lang.Apply(lang1.NewIllegalArgumentError, []any{v25}) -panic(v42) -} -return v16 -}) -v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7551), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7560), lang.NewKeyword("end-column"), int(59)) -v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v17 := lang.Apply(v13, []any{v16, v3}) -var v10 any = v17 -_ = v10 -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("seq")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("remove")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -var v25 lang.FnFunc -v25 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v26 := args[0] -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("vector?")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{v26}) -return v30 -}) -v26 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7562), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(7562), lang.NewKeyword("end-column"), int(42)) -v27, err := lang.WithMeta(v25, v26.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v28 := lang.Apply(v24, []any{v27, v10}) -v29 := lang.Apply(v21, []any{v28}) -var v18 any = v29 -_ = v18 -var v31 any -if lang.IsTruthy(v18) { -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("str")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("first")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("str")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v18}) -v39 := lang.Apply(v34, []any{"Parameter declaration \"", v38, "\" should be a vector"}) -v40 := lang.Apply(lang1.NewIllegalArgumentError, []any{v39}) -panic(v40) -} else { -v31 = nil +v20 := v19.Get() +v21 := lang.Apply(v20, []any{"Argument must be an integer: ", v3}) +v22 := lang.Apply(lang1.NewIllegalArgumentError, []any{v21}) +panic(v22) } -return v31 +return v4 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -33639,571 +31352,763 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// pop! +// every-pred { -v0 := lang.NewSymbol("pop!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Removes the last item from a transient vector. If\n the collection is empty, throws an exception. Returns coll", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3393), lang.NewKeyword("end-line"), int(3393))).(*lang.Symbol) +v0 := lang.NewSymbol("every-pred").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("p")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2"), lang.NewSymbol("p3")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2"), lang.NewSymbol("p3"), lang.NewSymbol("&"), lang.NewSymbol("ps"))), lang.NewKeyword("doc"), "Takes a set of predicates and returns a function f that returns true if all of its\n composing predicates return a logical true value against all of its arguments, else it returns\n false. Note that f is short-circuiting in that it will stop execution on the first\n argument that triggers a logical false result against the original predicates.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7465), lang.NewKeyword("end-line"), int(7465))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + switch len(args) { + case 1: v3 := args[0] -v4, ok := lang.FieldOrMethod(v3, "pop") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "pop"))) +var v4 lang.FnFunc +{ // function ep1 +v4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +return true + case 1: +v6 := args[0] +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("boolean")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -var v5 any -switch reflect.TypeOf(v4).Kind() { -case reflect.Func: - v5 = lang.Apply(v4, nil) -default: - v5 = v4 +v9 := v8.Get() +v10 := lang.Apply(v3, []any{v6}) +v11 := lang.Apply(v9, []any{v10}) +return v11 + case 2: +v6 := args[0] +v7 := args[1] +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("boolean")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v10 := v9.Get() +v12 := lang.Apply(v3, []any{v6}) +var v11 any = v12 +_ = v11 +var v14 any +if lang.IsTruthy(v11) { +v15 := lang.Apply(v3, []any{v7}) +v14 = v15 +} else { +v14 = v11 } +v11 := lang.Apply(v10, []any{v14}) +return v11 + case 3: +v6 := args[0] +v7 := args[1] +v8 := args[2] +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("boolean")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -// into-array -{ -v0 := lang.NewSymbol("into-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("aseq")), lang.NewVector(lang.NewSymbol("type"), lang.NewSymbol("aseq"))), lang.NewKeyword("doc"), "Returns an array with components set to the values in aseq. The array's\n component type is type if provided, or the type of the first value in\n aseq if present, or Object. All values in aseq must be compatible with\n the component type. Class objects for the primitive types can be obtained\n using, e.g., Integer/TYPE.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3444), lang.NewKeyword("end-line"), int(3444))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v11 := v10.Get() +v13 := lang.Apply(v3, []any{v6}) +var v12 any = v13 +_ = v12 +var v15 any +if lang.IsTruthy(v12) { +v17 := lang.Apply(v3, []any{v7}) +var v16 any = v17 +_ = v16 +var v19 any +if lang.IsTruthy(v16) { +v20 := lang.Apply(v3, []any{v8}) +v19 = v20 +} else { +v19 = v16 } -v6 := v5.Get() -v7 := lang.Apply(v6, []any{v3}) -v8 := lang.Apply(nil, []any{v7}) -return v8 - case 2: -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v15 = v19 +} else { +v15 = v12 } -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v4}) -v9 := lang.Apply(nil, []any{v3, v8}) -return v9 +v12 := lang.Apply(v11, []any{v15}) +return v12 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v6 := args[0] +v7 := args[1] +v8 := args[2] +v9 := lang.NewList(args[3:]...) +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("boolean")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } +v12 := v11.Get() +v14 := lang.Apply(v5, []any{v6, v7, v8}) +var v13 any = v14 +_ = v13 +var v16 any +if lang.IsTruthy(v13) { +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("every?")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -// set-validator! -{ -v0 := lang.NewSymbol("set-validator!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("iref"), lang.NewSymbol("validator-fn"))), lang.NewKeyword("doc"), "Sets the validator-fn for a var/ref/agent/atom. validator-fn must be nil or a\n side-effect-free fn of one argument, which will be passed the intended\n new state on any state change. If the new state is unacceptable, the\n validator-fn should return false or throw an exception. If the current state (root\n value if var) is not acceptable to the new validator, an exception\n will be thrown and the validator will not be changed.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2381), lang.NewKeyword("end-line"), int(2381))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5, _ := lang.FieldOrMethod(v3, "setValidator") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setValidator is not a function"))) +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v3, v9}) +v16 = v20 +} else { +v16 = v13 } -v6 := lang.Apply(v5, []any{v4}) -return v6 +v13 := lang.Apply(v12, []any{v16}) +return v13 + } }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v5 := v4 +_ = v5 } +v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7472), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7478), lang.NewKeyword("end-column"), int(56)) +v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) +if err != nil { + panic(err) } -// char-name-string -{ -v1 := reflect.TypeOf("") -v0 := lang.NewSymbol("char-name-string").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("doc"), "Returns name string for char or nil if none", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(6), lang.NewKeyword("line"), int(335), lang.NewKeyword("end-line"), int(338))).(*lang.Symbol) -v2 := ns.InternWithValue(v0, lang.NewMap(lang.NewChar(10), "newline", lang.NewChar(9), "tab", lang.NewChar(32), "space", lang.NewChar(8), "backspace", lang.NewChar(12), "formfeed", lang.NewChar(13), "return"), true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +return v6 + case 2: +v3 := args[0] +v4 := args[1] +var v5 lang.FnFunc +{ // function ep2 +v5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +return true + case 1: +v7 := args[0] +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("boolean")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } +v10 := v9.Get() +v12 := lang.Apply(v3, []any{v7}) +var v11 any = v12 +_ = v11 +var v14 any +if lang.IsTruthy(v11) { +v15 := lang.Apply(v4, []any{v7}) +v14 = v15 +} else { +v14 = v11 } -// char-escape-string -{ -v1 := reflect.TypeOf("") -v0 := lang.NewSymbol("char-escape-string").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("doc"), "Returns escape string for char or nil if none", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(6), lang.NewKeyword("line"), int(214), lang.NewKeyword("end-line"), int(217))).(*lang.Symbol) -v2 := ns.InternWithValue(v0, lang.NewMap(lang.NewChar(10), "\\n", lang.NewChar(9), "\\t", lang.NewChar(13), "\\r", lang.NewChar(34), "\\\"", lang.NewChar(92), "\\\\", lang.NewChar(12), "\\f", lang.NewChar(8), "\\b"), true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +v11 := lang.Apply(v10, []any{v14}) +return v11 + case 2: +v7 := args[0] +v8 := args[1] +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("boolean")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } +v11 := v10.Get() +v13 := lang.Apply(v3, []any{v7}) +var v12 any = v13 +_ = v12 +var v15 any +if lang.IsTruthy(v12) { +v17 := lang.Apply(v3, []any{v8}) +var v16 any = v17 +_ = v16 +var v19 any +if lang.IsTruthy(v16) { +v21 := lang.Apply(v4, []any{v7}) +var v20 any = v21 +_ = v20 +var v23 any +if lang.IsTruthy(v20) { +v24 := lang.Apply(v4, []any{v8}) +v23 = v24 +} else { +v23 = v20 } -// byte -{ -var v1 lang.FnFunc -{ // function byte__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v19 = v23 +} else { +v19 = v16 } -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v15 = v19 +} else { +v15 = v12 } -v9 := v8.Get() +v12 := lang.Apply(v11, []any{v15}) +return v12 + case 3: +v7 := args[0] +v8 := args[1] +v9 := args[2] v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) +v11 := v10.FindInternedVar(lang.NewSymbol("boolean")) if v11.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +v14 := lang.Apply(v3, []any{v7}) +var v13 any = v14 +_ = v13 +var v16 any +if lang.IsTruthy(v13) { +v18 := lang.Apply(v3, []any{v8}) +var v17 any = v18 +_ = v17 +var v20 any +if lang.IsTruthy(v17) { +v22 := lang.Apply(v3, []any{v9}) +var v21 any = v22 +_ = v21 +var v24 any +if lang.IsTruthy(v21) { +v26 := lang.Apply(v4, []any{v7}) +var v25 any = v26 +_ = v25 +var v28 any +if lang.IsTruthy(v25) { +v30 := lang.Apply(v4, []any{v8}) +var v29 any = v30 +_ = v29 +var v32 any +if lang.IsTruthy(v29) { +v33 := lang.Apply(v4, []any{v9}) +v32 = v33 +} else { +v32 = v29 } -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +v28 = v32 +} else { +v28 = v25 } -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v24 = v28 +} else { +v24 = v21 } -v29 := v28.Get() -var v30 any -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v20 = v24 +} else { +v20 = v17 } -v33 := v32.Get() -if lang.IsTruthy(v33) { -v30 = lang.NewSymbol("uncheckedByteCast") +v16 = v20 } else { -v30 = lang.NewSymbol("byteCast") +v16 = v13 } -v34 := lang.Apply(v29, []any{v30}) -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("list")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +v13 := lang.Apply(v12, []any{v16}) +return v13 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v7 := args[0] +v8 := args[1] +v9 := args[2] +v10 := lang.NewList(args[3:]...) +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("boolean")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v3}) -v39 := lang.Apply(v26, []any{v34, v38}) -v40 := lang.Apply(v23, []any{v39}) -v41 := lang.Apply(v20, []any{v40}) -v42 := lang.Apply(v9, []any{v13, v17, v41}) -v43 := lang.Apply(v6, []any{v42}) -return v43 -}) -v2 := v1 -_ = v2 +v13 := v12.Get() +v15 := lang.Apply(v6, []any{v7, v8, v9}) +var v14 any = v15 +_ = v14 +var v17 any +if lang.IsTruthy(v14) { +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("every?")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v0 := lang.NewSymbol("byte").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to byte", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3505), lang.NewKeyword("end-line"), int(3505))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { +v20 := v19.Get() +var v21 lang.FnFunc +v21 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v4 := args[0] -v5 := lang.Apply(lang1.ByteCast, []any{v4}) -return v5 +v22 := args[0] +v24 := lang.Apply(v3, []any{v22}) +var v23 any = v24 +_ = v23 +var v26 any +if lang.IsTruthy(v23) { +v27 := lang.Apply(v4, []any{v22}) +v26 = v27 +} else { +v26 = v23 +} +return v26 }) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7486), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(7486), lang.NewKeyword("end-column"), int(65)) +v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) +if err != nil { + panic(err) } +v24 := lang.Apply(v20, []any{v23, v10}) +v17 = v24 +} else { +v17 = v14 } -// >1? -{ -v0 := lang.NewSymbol(">1?").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(962), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(962), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) +v14 := lang.Apply(v13, []any{v17}) +return v14 } -v3 := args[0] -v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) -} -v5 := lang.Apply(v4, []any{v3, int64(1)}) -return v5 }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v6 := v5 +_ = v6 } +v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7480), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7486), lang.NewKeyword("end-column"), int(75)) +v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) +if err != nil { + panic(err) } -// ints -{ -var v1 lang.FnFunc -{ // function ints -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } +return v7 + case 3: v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v4 := args[1] +v5 := args[2] +var v6 lang.FnFunc +{ // function ep3 +v6 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +return true + case 1: +v8 := args[0] +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("boolean")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v11 := v10.Get() +v13 := lang.Apply(v3, []any{v8}) +var v12 any = v13 +_ = v12 +var v15 any +if lang.IsTruthy(v12) { +v17 := lang.Apply(v4, []any{v8}) +var v16 any = v17 +_ = v16 +var v19 any +if lang.IsTruthy(v16) { +v20 := lang.Apply(v5, []any{v8}) +v19 = v20 +} else { +v19 = v16 } -v9 := v8.Get() +v15 = v19 +} else { +v15 = v12 +} +v12 := lang.Apply(v11, []any{v15}) +return v12 + case 2: +v8 := args[0] +v9 := args[1] v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) +v11 := v10.FindInternedVar(lang.NewSymbol("boolean")) if v11.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v14 := lang.Apply(v3, []any{v8}) +var v13 any = v14 +_ = v13 +var v16 any +if lang.IsTruthy(v13) { +v18 := lang.Apply(v3, []any{v9}) +var v17 any = v18 +_ = v17 +var v20 any +if lang.IsTruthy(v17) { +v22 := lang.Apply(v4, []any{v8}) +var v21 any = v22 +_ = v21 +var v24 any +if lang.IsTruthy(v21) { +v26 := lang.Apply(v4, []any{v9}) +var v25 any = v26 +_ = v25 +var v28 any +if lang.IsTruthy(v25) { +v30 := lang.Apply(v5, []any{v8}) +var v29 any = v30 +_ = v29 +var v32 any +if lang.IsTruthy(v29) { +v33 := lang.Apply(v5, []any{v9}) +v32 = v33 +} else { +v32 = v29 } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v28 = v32 +} else { +v28 = v25 } -v20 := v19.Get() -v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/ints")}) -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("list")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v24 = v28 +} else { +v24 = v21 } -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v26 := lang.Apply(v9, []any{v13, v17, v21, v25}) -v27 := lang.Apply(v6, []any{v26}) -return v27 -}) -v2 := v1 -_ = v2 +v20 = v24 +} else { +v20 = v17 } -v0 := lang.NewSymbol("ints").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Casts to int[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5397), lang.NewKeyword("end-line"), int(5397))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "ints") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ints is not a function"))) +v16 = v20 +} else { +v16 = v13 } -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +v13 := lang.Apply(v12, []any{v16}) +return v13 + case 3: +v8 := args[0] +v9 := args[1] +v10 := args[2] +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("boolean")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v15 := lang.Apply(v3, []any{v8}) +var v14 any = v15 +_ = v14 +var v17 any +if lang.IsTruthy(v14) { +v19 := lang.Apply(v3, []any{v9}) +var v18 any = v19 +_ = v18 +var v21 any +if lang.IsTruthy(v18) { +v23 := lang.Apply(v3, []any{v10}) +var v22 any = v23 +_ = v22 +var v25 any +if lang.IsTruthy(v22) { +v27 := lang.Apply(v4, []any{v8}) +var v26 any = v27 +_ = v26 +var v29 any +if lang.IsTruthy(v26) { +v31 := lang.Apply(v4, []any{v9}) +var v30 any = v31 +_ = v30 +var v33 any +if lang.IsTruthy(v30) { +v35 := lang.Apply(v4, []any{v10}) +var v34 any = v35 +_ = v34 +var v37 any +if lang.IsTruthy(v34) { +v39 := lang.Apply(v5, []any{v8}) +var v38 any = v39 +_ = v38 +var v41 any +if lang.IsTruthy(v38) { +v43 := lang.Apply(v5, []any{v9}) +var v42 any = v43 +_ = v42 +var v45 any +if lang.IsTruthy(v42) { +v46 := lang.Apply(v5, []any{v10}) +v45 = v46 +} else { +v45 = v42 } +v41 = v45 +} else { +v41 = v38 } -// *print-length* -{ -v0 := lang.NewSymbol("*print-length*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(14), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(23), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, nil, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v37 = v41 +} else { +v37 = v34 } +v33 = v37 +} else { +v33 = v30 } -// reduce -{ -v0 := lang.NewSymbol("reduce").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("val"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "f should be a function of 2 arguments. If val is not supplied,\n returns the result of applying f to the first 2 items in coll, then\n applying f to that result and the 3rd item, etc. If coll contains no\n items, f must accept no arguments as well, and reduce returns the\n result of calling f with no arguments. If coll has only 1 item, it\n is returned and f is not called. If val is supplied, returns the\n result of applying f to val and the first item in coll, then\n applying f to that result and the 2nd item, etc. If coll contains no\n items, returns val and f is not called.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6903), lang.NewKeyword("end-line"), int(6903))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v3 := args[0] -v4 := args[1] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +v29 = v33 +} else { +v29 = v26 } -v8 := v7.Get() -v9 := lang.Apply(v8, []any{lang1.IReduce, v4}) -if lang.IsTruthy(v9) { -v10, _ := lang.FieldOrMethod(v4, "Reduce") -if reflect.TypeOf(v10).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Reduce is not a function"))) +v25 = v29 +} else { +v25 = v22 } -v11 := lang.Apply(v10, []any{v3}) -v5 = v11 +v21 = v25 } else { -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core.protocols")) -v13 := v12.FindInternedVar(lang.NewSymbol("coll-reduce")) +v21 = v18 +} +v17 = v21 +} else { +v17 = v14 +} +v14 := lang.Apply(v13, []any{v17}) +return v14 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v8 := args[0] +v9 := args[1] +v10 := args[2] +v11 := lang.NewList(args[3:]...) +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("boolean")) if v13.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } v14 := v13.Get() -v15 := lang.Apply(v14, []any{v4, v3}) -v5 = v15 -} -return v5 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -var v6 any -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("instance?")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v16 := lang.Apply(v7, []any{v8, v9, v10}) +var v15 any = v16 +_ = v15 +var v18 any +if lang.IsTruthy(v15) { +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("every?")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v9 := v8.Get() -v10 := lang.Apply(v9, []any{lang1.IReduceInit, v5}) -if lang.IsTruthy(v10) { -v11, _ := lang.FieldOrMethod(v5, "ReduceInit") -if reflect.TypeOf(v11).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) +v21 := v20.Get() +var v22 lang.FnFunc +v22 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v23 := args[0] +v25 := lang.Apply(v3, []any{v23}) +var v24 any = v25 +_ = v24 +var v27 any +if lang.IsTruthy(v24) { +v29 := lang.Apply(v4, []any{v23}) +var v28 any = v29 +_ = v28 +var v31 any +if lang.IsTruthy(v28) { +v32 := lang.Apply(v5, []any{v23}) +v31 = v32 +} else { +v31 = v28 } -v12 := lang.Apply(v11, []any{v3, v4}) -v6 = v12 +v27 = v31 } else { -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core.protocols")) -v14 := v13.FindInternedVar(lang.NewSymbol("coll-reduce")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +v27 = v24 } -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v5, v3, v4}) -v6 = v16 +return v27 +}) +v23 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7494), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(7494), lang.NewKeyword("end-column"), int(72)) +v24, err := lang.WithMeta(v22, v23.(lang.IPersistentMap)) +if err != nil { + panic(err) } -return v6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) +v25 := lang.Apply(v21, []any{v24, v11}) +v18 = v25 +} else { +v18 = v15 +} +v15 := lang.Apply(v14, []any{v18}) +return v15 } }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v7 := v6 +_ = v7 } +v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7488), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7494), lang.NewKeyword("end-column"), int(82)) +v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) +if err != nil { + panic(err) } -// qualified-ident? -{ -v0 := lang.NewSymbol("qualified-ident?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a symbol or keyword with a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1618), lang.NewKeyword("end-line"), int(1618))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } +return v8 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("boolean")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("ident?")) +v9 := v8.FindInternedVar(lang.NewSymbol("list*")) if v9.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } v10 := v9.Get() -v11 := lang.Apply(v10, []any{v3}) +v11 := lang.Apply(v10, []any{v3, v4, v5, v7}) var v7 any = v11 _ = v7 -var v13 any -if lang.IsTruthy(v7) { -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("namespace")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v3}) -var v14 any = v18 -_ = v14 -var v20 any -if lang.IsTruthy(v14) { -v20 = true -} else { -v20 = v14 -} -v13 = v20 -} else { -v13 = v7 +var v13 lang.FnFunc +{ // function epn +v13 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +return true + case 1: +v15 := args[0] +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("every?")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -v7 := lang.Apply(v6, []any{v13}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v18 := v17.Get() +var v19 lang.FnFunc +v19 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v20 := args[0] +v21 := lang.Apply(v20, []any{v15}) +return v21 +}) +v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7499), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(7499), lang.NewKeyword("end-column"), int(28)) +v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) +if err != nil { + panic(err) } +v22 := lang.Apply(v18, []any{v21, v7}) +return v22 + case 2: +v15 := args[0] +v16 := args[1] +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("every?")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -// double? -{ -v0 := lang.NewSymbol("double?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a Double", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1421), lang.NewKeyword("end-line"), int(1421))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { +v19 := v18.Get() +var v20 lang.FnFunc +v20 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v21 := args[0] +v23 := lang.Apply(v21, []any{v15}) +var v22 any = v23 +_ = v22 +var v25 any +if lang.IsTruthy(v22) { +v26 := lang.Apply(v21, []any{v16}) +v25 = v26 +} else { +v25 = v22 } -v6 := v5.Get() -v7 := lang.Apply(v6, []any{lang.Builtins["float64"], v3}) -return v7 +return v25 }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7500), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7500), lang.NewKeyword("end-column"), int(42)) +v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) +if err != nil { + panic(err) } +v23 := lang.Apply(v19, []any{v22, v7}) +return v23 + case 3: +v15 := args[0] +v16 := args[1] +v17 := args[2] +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("every?")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -// agent-error -{ -v0 := lang.NewSymbol("agent-error").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("doc"), "Returns the exception thrown during an asynchronous action of the\n agent if the agent is failed. Returns nil if the agent is not\n failed.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2167), lang.NewKeyword("end-line"), int(2167))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { +v20 := v19.Get() +var v21 lang.FnFunc +v21 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := args[0] -v4, ok := lang.FieldOrMethod(v3, "getError") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getError"))) +v22 := args[0] +v24 := lang.Apply(v22, []any{v15}) +var v23 any = v24 +_ = v23 +var v26 any +if lang.IsTruthy(v23) { +v28 := lang.Apply(v22, []any{v16}) +var v27 any = v28 +_ = v27 +var v30 any +if lang.IsTruthy(v27) { +v31 := lang.Apply(v22, []any{v17}) +v30 = v31 +} else { +v30 = v27 } -var v5 any -switch reflect.TypeOf(v4).Kind() { -case reflect.Func: - v5 = lang.Apply(v4, nil) -default: - v5 = v4 +v26 = v30 +} else { +v26 = v23 } -return v5 +return v26 }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7501), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(7501), lang.NewKeyword("end-column"), int(50)) +v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v24 := lang.Apply(v20, []any{v23, v7}) +return v24 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v15 := args[0] +v16 := args[1] +v17 := args[2] +v18 := lang.NewList(args[3:]...) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("boolean")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } +v21 := v20.Get() +v23 := lang.Apply(v14, []any{v15, v16, v17}) +var v22 any = v23 +_ = v22 +var v25 any +if lang.IsTruthy(v22) { +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("every?")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) } -// is-runtime-annotation? -{ -v0 := lang.NewSymbol("is-runtime-annotation?").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5475), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(5475), lang.NewKeyword("end-column"), int(29), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { +v28 := v27.Get() +var v29 lang.FnFunc +v29 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("boolean")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v30 := args[0] +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("every?")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -v6 := v5.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("is-annotation?")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v30, v18}) +return v34 +}) +v30 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7503), lang.NewKeyword("column"), int(48), lang.NewKeyword("end-line"), int(7503), lang.NewKeyword("end-column"), int(63)) +v31, err := lang.WithMeta(v29, v30.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v3}) -var v7 any = v11 -_ = v7 -var v13 any -if lang.IsTruthy(v7) { -v15, _ := lang.FieldOrMethod(v3, "getAnnotation") -if reflect.TypeOf(v15).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("getAnnotation is not a function"))) +v32 := lang.Apply(v28, []any{v31, v7}) +v25 = v32 +} else { +v25 = v22 } -v16 := lang.Apply(v15, []any{java.lang.annotation17.Retention}) -var v14 any = v16 +v22 := lang.Apply(v21, []any{v25}) +return v22 + } +}) +v14 := v13 _ = v14 -var v18 any -if lang.IsTruthy(v14) { -var v19 any = v14 -_ = v19 -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("=")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24, ok := lang.FieldOrMethod(v19, "value") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v19, "value"))) -} -var v25 any -switch reflect.TypeOf(v24).Kind() { -case reflect.Func: - v25 = lang.Apply(v24, nil) -default: - v25 = v24 -} -v26 := lang.Apply(v23, []any{v25, nil}) -v18 = v26 -} else { -v18 = nil } -v13 = v18 -} else { -v13 = v7 +v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7497), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7503), lang.NewKeyword("end-column"), int(71)) +v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v7 := lang.Apply(v6, []any{v13}) -return v7 +return v15 + } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -34211,131 +32116,112 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// float +// every? { -var v1 lang.FnFunc -{ // function float__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { +v1 := reflect.TypeOf(false) +v0 := lang.NewSymbol("every?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if (pred x) is logical true for every x in coll, else\n false.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2664), lang.NewKeyword("end-line"), int(2664))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() +v4 := args[0] +v5 := args[1] +recur_loop_480: +var v6 any v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +v8 := v7.FindInternedVar(lang.NewSymbol("nil?")) if v8.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } v9 := v8.Get() v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) +v11 := v10.FindInternedVar(lang.NewSymbol("seq")) if v11.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v13 := lang.Apply(v12, []any{v5}) +v14 := lang.Apply(v9, []any{v13}) +if lang.IsTruthy(v14) { +v6 = true +} else { +var v15 any +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("first")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -v29 := v28.Get() -var v30 any -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v5}) +v20 := lang.Apply(v4, []any{v19}) +if lang.IsTruthy(v20) { +var v21 any = v4 +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("next")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v33 := v32.Get() -if lang.IsTruthy(v33) { -v30 = lang.NewSymbol("uncheckedFloatCast") +v25 := v24.Get() +v26 := lang.Apply(v25, []any{v5}) +var v22 any = v26 +v4 = v21 +v5 = v22 +goto recur_loop_480 } else { -v30 = lang.NewSymbol("floatCast") +var v27 any +if lang.IsTruthy(lang.NewKeyword("else")) { +v27 = false +} else { +v27 = nil } -v34 := lang.Apply(v29, []any{v30}) -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("list")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +v15 = v27 } -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v3}) -v39 := lang.Apply(v26, []any{v34, v38}) -v40 := lang.Apply(v23, []any{v39}) -v41 := lang.Apply(v20, []any{v40}) -v42 := lang.Apply(v9, []any{v13, v17, v41}) -v43 := lang.Apply(v6, []any{v42}) -return v43 -}) -v2 := v1 -_ = v2 +v6 = v15 } -v0 := lang.NewSymbol("float").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to float", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3487), lang.NewKeyword("end-line"), int(3487))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := lang.Apply(lang1.FloatCast, []any{v4}) -return v5 +return v6 }) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v4 := reflect.TypeOf(false) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// alter-meta! +// ex-cause { -v0 := lang.NewSymbol("alter-meta!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("iref"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Atomically sets the metadata for a namespace/var/ref/agent/atom to be:\n\n (apply f its-current-meta args)\n\n f must be free of side-effects", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2398), lang.NewKeyword("end-line"), int(2398))).(*lang.Symbol) +v0 := lang.NewSymbol("ex-cause").WithMeta(lang.NewMap(lang.NewKeyword("tag"), nil, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ex"))), lang.NewKeyword("doc"), "Returns the cause of ex if ex is a Throwable.\n Otherwise returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4828), lang.NewKeyword("end-line"), int(4828))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -v6, _ := lang.FieldOrMethod(v3, "AlterMeta") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("AlterMeta is not a function"))) +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 - } +v7 := v6.Get() +v8 := lang.Apply(v7, []any{lang1.Throwable, v3}) +if lang.IsTruthy(v8) { +v9, ok := lang.FieldOrMethod(v3, "getCause") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getCause"))) +} +var v10 any +switch reflect.TypeOf(v9).Kind() { +case reflect.Func: + v10 = lang.Apply(v9, nil) +default: + v10 = v9 +} +v4 = v10 +} else { +v4 = nil +} +return v4 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -34343,34 +32229,40 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// ns-name +// ex-data { -v0 := lang.NewSymbol("ns-name").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns the name of the namespace, a symbol.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4163), lang.NewKeyword("end-line"), int(4163))).(*lang.Symbol) +v0 := lang.NewSymbol("ex-data").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ex"))), lang.NewKeyword("doc"), "Returns exception data (a map) if ex is an IExceptionInfo.\n Otherwise returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4812), lang.NewKeyword("end-line"), int(4812))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("the-ns")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v6 := v5.Get() -v7 := lang.Apply(v6, []any{v3}) -v8, ok := lang.FieldOrMethod(v7, "Name") +v7 := v6.Get() +v8 := lang.Apply(v7, []any{nil, v3}) +if lang.IsTruthy(v8) { +v9, ok := lang.FieldOrMethod(v3, "getData") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "Name"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getData"))) } -var v9 any -switch reflect.TypeOf(v8).Kind() { +var v10 any +switch reflect.TypeOf(v9).Kind() { case reflect.Func: - v9 = lang.Apply(v8, nil) + v10 = lang.Apply(v9, nil) default: - v9 = v8 + v10 = v9 } -return v9 +v4 = v10 +} else { +v4 = nil +} +return v4 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -34378,84 +32270,100 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// find-keyword +// ex-info { -v1 := reflect.TypeOf((*lang1.Keyword)(nil)).Elem() -v0 := lang.NewSymbol("find-keyword").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name"))), lang.NewKeyword("doc"), "Returns a Keyword with the given namespace and name if one already\n exists. This function will not intern a new keyword. If the keyword\n has not already been interned, it will return nil. Do not use :\n in the keyword strings, it will be added automatically.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(618), lang.NewKeyword("end-line"), int(618))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { +v0 := lang.NewSymbol("ex-info").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("msg"), lang.NewSymbol("map")), lang.NewVector(lang.NewSymbol("msg"), lang.NewSymbol("map"), lang.NewSymbol("cause"))), lang.NewKeyword("doc"), "Create an instance of ExceptionInfo, a RuntimeException subclass\n that carries a map of additional data.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4803), lang.NewKeyword("end-line"), int(4803))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 1: -v4 := args[0] -var v5 any + case 2: +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("elide-top-frames")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(ExceptionInfo19., []any{v3, v4}) +v9 := lang.Apply(v7, []any{v8, "glojure.core$ex_info"}) +return v9 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("keyword?")) +v7 := v6.FindInternedVar(lang.NewSymbol("elide-top-frames")) if v7.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } v8 := v7.Get() -v9 := lang.Apply(v8, []any{v4}) -if lang.IsTruthy(v9) { -v5 = v4 -} else { -var v10 any -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("symbol?")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v4}) -if lang.IsTruthy(v14) { -v15 := lang.Apply(nil, []any{v4}) -v10 = v15 -} else { -var v16 any -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("string?")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v4}) -if lang.IsTruthy(v20) { -v21 := lang.Apply(nil, []any{v4}) -v16 = v21 -} else { -v16 = nil -} -v10 = v16 -} -v5 = v10 -} -return v5 - case 2: -v4 := args[0] -v5 := args[1] -v6 := lang.Apply(nil, []any{v4, v5}) -return v6 +v9 := lang.Apply(ExceptionInfo19., []any{v3, v4, v5}) +v10 := lang.Apply(v8, []any{v9, "glojure.core$ex_info"}) +return v10 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) -v4 := reflect.TypeOf((*lang1.Keyword)(nil)).Elem() -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// time +// ex-message { -v0 := lang.NewSymbol("time").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"))), lang.NewKeyword("doc"), "Evaluates expr and prints the time it took. Returns the value of\n expr.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3885), lang.NewKeyword("end-line"), int(3885))).(*lang.Symbol) +v0 := lang.NewSymbol("ex-message").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ex"))), lang.NewKeyword("doc"), "Returns the message attached to ex if ex is a Throwable.\n Otherwise returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4820), lang.NewKeyword("end-line"), int(4820))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := args[1] -v5 := args[2] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{lang1.Throwable, v3}) +if lang.IsTruthy(v8) { +v9, ok := lang.FieldOrMethod(v3, "getMessage") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getMessage"))) +} +var v10 any +switch reflect.TypeOf(v9).Kind() { +case reflect.Func: + v10 = lang.Apply(v9, nil) +default: + v10 = v9 +} +v4 = v10 +} else { +v4 = nil +} +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// extend +{ +v0 := lang.NewSymbol("extend").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atype"), lang.NewSymbol("&"), lang.NewSymbol("proto+mmaps"))), lang.NewKeyword("doc"), "Implementations of protocol methods can be provided using the extend construct:\n\n (extend AType\n AProtocol\n {:foo an-existing-fn\n :bar (fn [a b] ...)\n :baz (fn ([a]...) ([a b] ...)...)}\n BProtocol \n {...} \n ...)\n \n extend takes a type/class (or interface, see below), and one or more\n protocol + method map pairs. It will extend the polymorphism of the\n protocol's methods to call the supplied methods when an AType is\n provided as the first argument. \n\n Method maps are maps of the keyword-ized method names to ordinary\n fns. This facilitates easy reuse of existing fns and fn maps, for\n code reuse/mixins without derivation or composition. You can extend\n an interface to a protocol. This is primarily to facilitate interop\n with the host (e.g. Java) but opens the door to incidental multiple\n inheritance of implementation since a class can inherit from more\n than one interface, both of which extend the protocol. It is TBD how\n to specify which impl to use. You can extend a protocol on nil.\n\n If you are supplying the definitions explicitly (i.e. not reusing\n exsting functions or mixin maps), you may find it more convenient to\n use the extend-type or extend-protocol macros.\n\n Note that multiple independent extend clauses can exist for the same\n type, not all protocols need be defined in a single extend call.\n\n See also:\n extends?, satisfies?, extenders", lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(116), lang.NewKeyword("end-line"), int(116))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.NewList(args[1:]...) v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v7 := v6.FindInternedVar(lang.NewSymbol("seq")) if v7.IsMacro() { @@ -34463,363 +32371,610 @@ if v7.IsMacro() { } v8 := v7.Get() v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("concat")) +v10 := v9.FindInternedVar(lang.NewSymbol("partition")) if v10.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("list")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{lang.NewSymbol("glojure.core/let")}) -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("list")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() +v12 := lang.Apply(v11, []any{int64(2), v4}) +v13 := lang.Apply(v8, []any{v12}) +var v5 any = v13 +_ = v5 +var v14 any = nil +_ = v14 +var v15 any = int64(0) +_ = v15 +var v16 any = int64(0) +_ = v16 +var v17 any +for { +var v18 any v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("apply")) +v20 := v19.FindInternedVar(lang.NewSymbol("<")) if v20.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("vector")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v22 := lang.Apply(v21, []any{v16, v15}) +if lang.IsTruthy(v22) { +v24, _ := lang.FieldOrMethod(v14, "nth") +if reflect.TypeOf(v24).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) } -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("seq")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +v25 := lang.Apply(v24, []any{v16}) +var v23 any = v25 +_ = v23 +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("nth")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("concat")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +v29 := v28.Get() +v30 := lang.Apply(v29, []any{v23, int64(0), nil}) +var v26 any = v30 +_ = v26 +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("nth")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) } -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v23, int64(1), nil}) +var v31 any = v35 +_ = v31 +var v37 any +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("protocol?")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) } -v33 := v32.Get() -v34 := lang.Apply(v33, []any{lang.NewSymbol("start__0__auto__")}) -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("list")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +v40 := v39.Get() +v41 := lang.Apply(v40, []any{v26}) +if lang.IsTruthy(v41) { +v37 = nil +} else { +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("str")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) } -v37 := v36.Get() +v44 := v43.Get() +v45 := lang.Apply(v44, []any{v26, " is not a protocol"}) +v46 := lang.Apply(errors11.New, []any{v45}) +panic(v46) +} +_ = v37 +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("reduce1")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +} +v49 := v48.Get() +var v50 lang.FnFunc +v50 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v51 := args[0] +v52 := args[1] +var v53 any = v52 +_ = v53 +v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v56 := v55.FindInternedVar(lang.NewSymbol("nth")) +if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) +} +v57 := v56.Get() +v58 := lang.Apply(v57, []any{v53, int64(0), nil}) +var v54 any = v58 +_ = v54 +v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v61 := v60.FindInternedVar(lang.NewSymbol("nth")) +if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) +} +v62 := v61.Get() +v63 := lang.Apply(v62, []any{v53, int64(1), nil}) +var v59 any = v63 +_ = v59 +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("get-in")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +} +v67 := v66.Get() +v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v69 := v68.FindInternedVar(lang.NewSymbol("deref")) +if v69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) +} +v70 := v69.Get() +v71 := lang.Apply(v70, []any{v26}) +v72 := lang.NewVector(lang.NewKeyword("multis"), v54) +v73 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(158), lang.NewKeyword("column"), int(33), lang.NewKeyword("end-line"), int(158), lang.NewKeyword("end-column"), int(43)) +v74, err := lang.WithMeta(v72, v73.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v75 := lang.Apply(v67, []any{v71, v74}) +var v76 lang.FnFunc +v76 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v77 := args[0] +v78 := lang.NewList(args[1:]...) +v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v80 := v79.FindInternedVar(lang.NewSymbol("apply")) +if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) +} +v81 := v80.Get() +v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v83 := v82.FindInternedVar(lang.NewSymbol("cons")) +if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) +} +v84 := v83.Get() +v85 := lang.Apply(v84, []any{v77, v78}) +v86 := lang.Apply(v81, []any{v59, v85}) +return v86 + } +}) +v77, _ := lang.FieldOrMethod(v75, "AddMethod") +if reflect.TypeOf(v77).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("AddMethod is not a function"))) +} +v78 := lang.Apply(v77, []any{v3, v76}) +return v78 +}) +v51 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(156), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(160), lang.NewKeyword("end-column"), int(45)) +v52, err := lang.WithMeta(v50, v51.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v53 := lang.Apply(v49, []any{v52, nil, v31}) +_ = v53 +var v54 any = v5 +var v55 any = v14 +var v56 any = v15 +v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v59 := v58.FindInternedVar(lang.NewSymbol("unchecked-inc")) +if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) +} +v60 := v59.Get() +v61 := lang.Apply(v60, []any{v16}) +var v57 any = v61 +v5 = v54 +v14 = v55 +v15 = v56 +v16 = v57 +continue +} else { +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("seq")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v5}) +var v23 any = v27 +_ = v23 +var v29 any +if lang.IsTruthy(v23) { +var v30 any = v23 +_ = v30 +var v32 any +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("chunked-seq?")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v30}) +if lang.IsTruthy(v36) { v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("seq")) +v39 := v38.FindInternedVar(lang.NewSymbol("chunk-first")) if v39.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) } v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("concat")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() +v41 := lang.Apply(v40, []any{v30}) +var v37 any = v41 +_ = v37 v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) +v45 := v44.FindInternedVar(lang.NewSymbol("chunk-rest")) if v45.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } v46 := v45.Get() -v47 := lang.Apply(v46, []any{lang.NewSymbol(".UnixNano")}) +v47 := lang.Apply(v46, []any{v30}) +var v43 any = v47 +var v48 any = v37 +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("int")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +} +v52 := v51.Get() +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("count")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +} +v55 := v54.Get() +v56 := lang.Apply(v55, []any{v37}) +v57 := lang.Apply(v52, []any{v56}) +var v49 any = v57 +v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v60 := v59.FindInternedVar(lang.NewSymbol("int")) +if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) +} +v61 := v60.Get() +v62 := lang.Apply(v61, []any{int64(0)}) +var v58 any = v62 +v5 = v43 +v14 = v48 +v15 = v49 +v16 = v58 +continue +} else { +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("first")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.Apply(v40, []any{v30}) +var v37 any = v41 +_ = v37 +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("nth")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +} +v45 := v44.Get() +v46 := lang.Apply(v45, []any{v37, int64(0), nil}) +var v42 any = v46 +_ = v42 v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) +v49 := v48.FindInternedVar(lang.NewSymbol("nth")) if v49.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) } v50 := v49.Get() -v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v52 := v51.FindInternedVar(lang.NewSymbol("seq")) -if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) -} -v53 := v52.Get() +v51 := lang.Apply(v50, []any{v37, int64(1), nil}) +var v47 any = v51 +_ = v47 +var v53 any v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("concat")) +v55 := v54.FindInternedVar(lang.NewSymbol("protocol?")) if v55.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) } v56 := v55.Get() -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("list")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +v57 := lang.Apply(v56, []any{v42}) +if lang.IsTruthy(v57) { +v53 = nil +} else { +v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v59 := v58.FindInternedVar(lang.NewSymbol("str")) +if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) } -v59 := v58.Get() -v60 := lang.Apply(v59, []any{lang.NewSymbol("time.Now")}) -v61 := lang.Apply(v56, []any{v60}) -v62 := lang.Apply(v53, []any{v61}) -v63 := lang.Apply(v50, []any{v62}) -v64 := lang.Apply(v43, []any{v47, v63}) -v65 := lang.Apply(v40, []any{v64}) -v66 := lang.Apply(v37, []any{v65}) -v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v68 := v67.FindInternedVar(lang.NewSymbol("list")) -if v68.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) +v60 := v59.Get() +v61 := lang.Apply(v60, []any{v42, " is not a protocol"}) +v62 := lang.Apply(errors11.New, []any{v61}) +panic(v62) } -v69 := v68.Get() -v70 := lang.Apply(v69, []any{lang.NewSymbol("ret__1__auto__")}) +_ = v53 +v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v64 := v63.FindInternedVar(lang.NewSymbol("reduce1")) +if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) +} +v65 := v64.Get() +var v66 lang.FnFunc +v66 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v67 := args[0] +v68 := args[1] +var v69 any = v68 +_ = v69 v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v72 := v71.FindInternedVar(lang.NewSymbol("list")) +v72 := v71.FindInternedVar(lang.NewSymbol("nth")) if v72.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) } v73 := v72.Get() -v74 := lang.Apply(v73, []any{v5}) -v75 := lang.Apply(v30, []any{v34, v66, v70, v74}) -v76 := lang.Apply(v27, []any{v75}) -v77 := lang.Apply(v21, []any{v24, v76}) -v78 := lang.Apply(v18, []any{v77}) -v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v80 := v79.FindInternedVar(lang.NewSymbol("list")) -if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) -} -v81 := v80.Get() -v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v83 := v82.FindInternedVar(lang.NewSymbol("seq")) -if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) +v74 := lang.Apply(v73, []any{v69, int64(0), nil}) +var v70 any = v74 +_ = v70 +v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v77 := v76.FindInternedVar(lang.NewSymbol("nth")) +if v77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) } -v84 := v83.Get() -v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v86 := v85.FindInternedVar(lang.NewSymbol("concat")) -if v86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) +v78 := v77.Get() +v79 := lang.Apply(v78, []any{v69, int64(1), nil}) +var v75 any = v79 +_ = v75 +v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v82 := v81.FindInternedVar(lang.NewSymbol("get-in")) +if v82.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) } -v87 := v86.Get() -v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v89 := v88.FindInternedVar(lang.NewSymbol("list")) -if v89.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) +v83 := v82.Get() +v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v85 := v84.FindInternedVar(lang.NewSymbol("deref")) +if v85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) } -v90 := v89.Get() -v91 := lang.Apply(v90, []any{lang.NewSymbol("glojure.core/prn")}) -v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v93 := v92.FindInternedVar(lang.NewSymbol("list")) -if v93.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) +v86 := v85.Get() +v87 := lang.Apply(v86, []any{v42}) +v88 := lang.NewVector(lang.NewKeyword("multis"), v70) +v89 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(158), lang.NewKeyword("column"), int(33), lang.NewKeyword("end-line"), int(158), lang.NewKeyword("end-column"), int(43)) +v90, err := lang.WithMeta(v88, v89.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v94 := v93.Get() +v91 := lang.Apply(v83, []any{v87, v90}) +var v92 lang.FnFunc +v92 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v93 := args[0] +v94 := lang.NewList(args[1:]...) v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v96 := v95.FindInternedVar(lang.NewSymbol("seq")) +v96 := v95.FindInternedVar(lang.NewSymbol("apply")) if v96.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) } v97 := v96.Get() v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v99 := v98.FindInternedVar(lang.NewSymbol("concat")) +v99 := v98.FindInternedVar(lang.NewSymbol("cons")) if v99.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) } v100 := v99.Get() -v101 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v102 := v101.FindInternedVar(lang.NewSymbol("list")) -if v102.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v102))) -} -v103 := v102.Get() -v104 := lang.Apply(v103, []any{lang.NewSymbol("glojure.core/str")}) -v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v106 := v105.FindInternedVar(lang.NewSymbol("list")) -if v106.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) +v101 := lang.Apply(v100, []any{v93, v94}) +v102 := lang.Apply(v97, []any{v75, v101}) +return v102 + } +}) +v93, _ := lang.FieldOrMethod(v91, "AddMethod") +if reflect.TypeOf(v93).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("AddMethod is not a function"))) } -v107 := v106.Get() -v108 := lang.Apply(v107, []any{"Elapsed time: "}) -v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v110 := v109.FindInternedVar(lang.NewSymbol("list")) -if v110.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) +v94 := lang.Apply(v93, []any{v3, v92}) +return v94 +}) +v67 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(156), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(160), lang.NewKeyword("end-column"), int(45)) +v68, err := lang.WithMeta(v66, v67.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v111 := v110.Get() -v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v113 := v112.FindInternedVar(lang.NewSymbol("seq")) -if v113.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) +v69 := lang.Apply(v65, []any{v68, nil, v47}) +_ = v69 +v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v72 := v71.FindInternedVar(lang.NewSymbol("next")) +if v72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) } -v114 := v113.Get() -v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v116 := v115.FindInternedVar(lang.NewSymbol("concat")) -if v116.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) +v73 := v72.Get() +v74 := lang.Apply(v73, []any{v30}) +var v70 any = v74 +var v75 any = nil +var v76 any = int64(0) +var v77 any = int64(0) +v5 = v70 +v14 = v75 +v15 = v76 +v16 = v77 +continue } -v117 := v116.Get() -v118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v119 := v118.FindInternedVar(lang.NewSymbol("list")) -if v119.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v119))) +v29 = v32 +} else { +v29 = nil } -v120 := v119.Get() -v121 := lang.Apply(v120, []any{lang.NewSymbol("glojure.core//")}) -v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v123 := v122.FindInternedVar(lang.NewSymbol("list")) -if v123.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) +v18 = v29 } -v124 := v123.Get() -v125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v126 := v125.FindInternedVar(lang.NewSymbol("seq")) -if v126.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v126))) +v17 = v18 + break } -v127 := v126.Get() -v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v129 := v128.FindInternedVar(lang.NewSymbol("concat")) -if v129.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v129))) +return v17 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v130 := v129.Get() -v131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v132 := v131.FindInternedVar(lang.NewSymbol("list")) -if v132.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v132))) } -v133 := v132.Get() -v134 := lang.Apply(v133, []any{lang.NewSymbol("glojure.core/double")}) -v135 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v136 := v135.FindInternedVar(lang.NewSymbol("list")) -if v136.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v136))) +// extend-protocol +{ +v0 := lang.NewSymbol("extend-protocol").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("p"), lang.NewSymbol("&"), lang.NewSymbol("specs"))), lang.NewKeyword("doc"), "Useful when you want to provide several implementations of the same\n protocol all at once. Takes a single protocol and the implementation\n of that protocol for one or more types.\n\n (extend-protocol Protocol\n AType\n (foo [x] ...)\n (bar [x y] ...)\n BType\n (foo [x] ...)\n (bar [x y] ...)\n AClass\n (foo [x] ...)\n (bar [x y] ...)\n nil\n (foo [x] ...)\n (bar [x y] ...))\n\n expands into:\n\n (do\n (clojure.core/extend-type AType Protocol \n (foo [x] ...) \n (bar [x y] ...))\n (clojure.core/extend-type BType Protocol \n (foo [x] ...) \n (bar [x y] ...))\n (clojure.core/extend-type AClass Protocol \n (foo [x] ...) \n (bar [x y] ...))\n (clojure.core/extend-type nil Protocol \n (foo [x] ...) \n (bar [x y] ...)))", lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(212), lang.NewKeyword("end-line"), int(212))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("emit-extend-protocol")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v137 := v136.Get() -v138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v139 := v138.FindInternedVar(lang.NewSymbol("seq")) -if v139.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v139))) +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v5, v6}) +return v10 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v140 := v139.Get() -v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v142 := v141.FindInternedVar(lang.NewSymbol("concat")) -if v142.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) } -v143 := v142.Get() -v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v145 := v144.FindInternedVar(lang.NewSymbol("list")) -if v145.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) +// extend-type +{ +v0 := lang.NewSymbol("extend-type").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("t"), lang.NewSymbol("&"), lang.NewSymbol("specs"))), lang.NewKeyword("doc"), "A macro that expands into an extend call. Useful when you are\n supplying the definitions explicitly inline, extend-type\n automatically creates the maps required by extend. Propagates the\n class as a type hint on the first argument of all fns.\n\n (extend-type MyType \n Countable\n (cnt [c] ...)\n Foo\n (bar [x y] ...)\n (baz ([x] ...) ([x y & zs] ...)))\n\n expands into:\n\n (extend MyType\n Countable\n {:cnt (fn [c] ...)}\n Foo\n {:baz (fn ([x] ...) ([x y & zs] ...))\n :bar (fn [x y] ...)})", lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(180), lang.NewKeyword("end-line"), int(180))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("emit-extend-type")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v146 := v145.Get() -v147 := lang.Apply(v146, []any{lang.NewSymbol("glojure.core/-")}) -v148 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v149 := v148.FindInternedVar(lang.NewSymbol("list")) -if v149.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v149))) +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v5, v6}) +return v10 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v150 := v149.Get() -v151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v152 := v151.FindInternedVar(lang.NewSymbol("seq")) -if v152.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v152))) } -v153 := v152.Get() -v154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v155 := v154.FindInternedVar(lang.NewSymbol("concat")) -if v155.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v155))) +// false? +{ +v1 := reflect.TypeOf(false) +v0 := lang.NewSymbol("false?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is the value false, false otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(504), lang.NewKeyword("end-line"), int(504))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := lang.Apply(lang1.Identical, []any{v4, false}) +return v5 +}) +v4 := reflect.TypeOf(false) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v156 := v155.Get() -v157 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v158 := v157.FindInternedVar(lang.NewSymbol("list")) -if v158.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v158))) } -v159 := v158.Get() -v160 := lang.Apply(v159, []any{lang.NewSymbol(".UnixNano")}) -v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v162 := v161.FindInternedVar(lang.NewSymbol("list")) -if v162.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) +// ffirst +{ +v0 := lang.NewSymbol("ffirst").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Same as (first (first x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(98), lang.NewKeyword("end-line"), int(102))).(*lang.Symbol) +var v2 lang.FnFunc +{ // function ffirst +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("first")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v163 := v162.Get() -v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v165 := v164.FindInternedVar(lang.NewSymbol("seq")) -if v165.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("first")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v166 := v165.Get() -v167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v168 := v167.FindInternedVar(lang.NewSymbol("concat")) -if v168.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v168))) +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v4}) +v12 := lang.Apply(v7, []any{v11}) +return v12 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(102), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(102), lang.NewKeyword("end-column"), int(50))).(lang.FnFunc) +v3 := v2 +_ = v3 } -v169 := v168.Get() -v170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v171 := v170.FindInternedVar(lang.NewSymbol("list")) -if v171.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v171))) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v172 := v171.Get() -v173 := lang.Apply(v172, []any{lang.NewSymbol("time.Now")}) -v174 := lang.Apply(v169, []any{v173}) -v175 := lang.Apply(v166, []any{v174}) -v176 := lang.Apply(v163, []any{v175}) -v177 := lang.Apply(v156, []any{v160, v176}) -v178 := lang.Apply(v153, []any{v177}) -v179 := lang.Apply(v150, []any{v178}) -v180 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v181 := v180.FindInternedVar(lang.NewSymbol("list")) -if v181.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v181))) } -v182 := v181.Get() -v183 := lang.Apply(v182, []any{lang.NewSymbol("start__0__auto__")}) -v184 := lang.Apply(v143, []any{v147, v179, v183}) -v185 := lang.Apply(v140, []any{v184}) -v186 := lang.Apply(v137, []any{v185}) -v187 := lang.Apply(v130, []any{v134, v186}) -v188 := lang.Apply(v127, []any{v187}) -v189 := lang.Apply(v124, []any{v188}) -v190 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v191 := v190.FindInternedVar(lang.NewSymbol("list")) -if v191.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v191))) +// file-seq +{ +v0 := lang.NewSymbol("file-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("dir"))), lang.NewKeyword("doc"), "A tree seq on java.io.Files", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4972), lang.NewKeyword("end-line"), int(4972))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("tree-seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v192 := v191.Get() -v193 := lang.Apply(v192, []any{nil}) -v194 := lang.Apply(v117, []any{v121, v189, v193}) -v195 := lang.Apply(v114, []any{v194}) -v196 := lang.Apply(v111, []any{v195}) -v197 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v198 := v197.FindInternedVar(lang.NewSymbol("list")) -if v198.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v198))) +v6 := v5.Get() +var v7 lang.FnFunc +v7 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v8 := args[0] +v9, _ := lang.FieldOrMethod(v8, "isDirectory") +if reflect.TypeOf(v9).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("isDirectory is not a function"))) } -v199 := v198.Get() -v200 := lang.Apply(v199, []any{" msecs"}) -v201 := lang.Apply(v100, []any{v104, v108, v196, v200}) -v202 := lang.Apply(v97, []any{v201}) -v203 := lang.Apply(v94, []any{v202}) -v204 := lang.Apply(v87, []any{v91, v203}) -v205 := lang.Apply(v84, []any{v204}) -v206 := lang.Apply(v81, []any{v205}) -v207 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v208 := v207.FindInternedVar(lang.NewSymbol("list")) -if v208.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v208))) +v10 := lang.Apply(v9, []any{}) +return v10 +}) +v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4978), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(4978), lang.NewKeyword("end-column"), int(47)) +v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v209 := v208.Get() -v210 := lang.Apply(v209, []any{lang.NewSymbol("ret__1__auto__")}) -v211 := lang.Apply(v11, []any{v15, v78, v206, v210}) -v212 := lang.Apply(v8, []any{v211}) -return v212 +var v10 lang.FnFunc +v10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v11 := args[0] +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("seq")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15, _ := lang.FieldOrMethod(v11, "listFiles") +if reflect.TypeOf(v15).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("listFiles is not a function"))) +} +v16 := lang.Apply(v15, []any{}) +v17 := lang.Apply(v14, []any{v16}) +return v17 +}) +v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4979), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(4979), lang.NewKeyword("end-column"), int(51)) +v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v13 := lang.Apply(v6, []any{v9, v12, v3}) +return v13 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -34827,588 +32982,257 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// partial +// filter { -v0 := lang.NewSymbol("partial").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("arg1")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("arg1"), lang.NewSymbol("arg2")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("arg1"), lang.NewSymbol("arg2"), lang.NewSymbol("arg3")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("arg1"), lang.NewSymbol("arg2"), lang.NewSymbol("arg3"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Takes a function f and fewer than the normal arguments to f, and\n returns a fn that takes a variable number of additional args. When\n called, the returned function calls f with args + additional args.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2606), lang.NewKeyword("end-line"), int(2606))).(*lang.Symbol) +v0 := lang.NewSymbol("filter").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred")), lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the items in coll for which\n (pred item) returns logical true. pred must be free of side-effects.\n Returns a transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2785), lang.NewKeyword("end-line"), int(2785))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] -return v3 - case 2: -v3 := args[0] -v4 := args[1] -var v5 lang.FnFunc -v5 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v6 := lang.Apply(v3, []any{v4}) -return v6 - case 1: -v6 := args[0] -v7 := lang.Apply(v3, []any{v4, v6}) -return v7 - case 2: -v6 := args[0] -v7 := args[1] -v8 := lang.Apply(v3, []any{v4, v6, v7}) -return v8 - case 3: -v6 := args[0] -v7 := args[1] -v8 := args[2] -v9 := lang.Apply(v3, []any{v4, v6, v7, v8}) -return v9 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v6 := args[0] -v7 := args[1] -v8 := args[2] -v9 := lang.NewList(args[3:]...) -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("apply")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{v3, v4, v6, v7, v8, v9}) -return v13 +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -}) -v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2614), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(2619), lang.NewKeyword("end-column"), int(48)) -v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v7 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] +v5 := args[0] var v6 lang.FnFunc v6 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: -v7 := lang.Apply(v3, []any{v4, v5}) +v7 := lang.Apply(v5, nil) return v7 case 1: v7 := args[0] -v8 := lang.Apply(v3, []any{v4, v5, v7}) +v8 := lang.Apply(v5, []any{v7}) return v8 case 2: v7 := args[0] v8 := args[1] -v9 := lang.Apply(v3, []any{v4, v5, v7, v8}) +var v9 any +v10 := lang.Apply(v3, []any{v8}) +if lang.IsTruthy(v10) { +v11 := lang.Apply(v5, []any{v7, v8}) +v9 = v11 +} else { +v9 = v7 +} return v9 - case 3: -v7 := args[0] -v8 := args[1] -v9 := args[2] -v10 := lang.Apply(v3, []any{v4, v5, v7, v8, v9}) -return v10 default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v7 := args[0] -v8 := args[1] -v9 := args[2] -v10 := lang.NewList(args[3:]...) -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("apply")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v3, v4, v5, v7, v8, v9, v10}) -return v14 + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) -v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2621), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(2626), lang.NewKeyword("end-column"), int(53)) +v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2793), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(2799), lang.NewKeyword("end-column"), int(22)) v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) if err != nil { panic(err) } return v8 - case 4: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -var v7 lang.FnFunc -v7 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v8 := lang.Apply(v3, []any{v4, v5, v6}) -return v8 - case 1: -v8 := args[0] -v9 := lang.Apply(v3, []any{v4, v5, v6, v8}) -return v9 - case 2: -v8 := args[0] -v9 := args[1] -v10 := lang.Apply(v3, []any{v4, v5, v6, v8, v9}) -return v10 - case 3: -v8 := args[0] -v9 := args[1] -v10 := args[2] -v11 := lang.Apply(v3, []any{v4, v5, v6, v8, v9, v10}) -return v11 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v8 := args[0] -v9 := args[1] -v10 := args[2] -v11 := lang.NewList(args[3:]...) -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("apply")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v3, v4, v5, v6, v8, v9, v10, v11}) -return v15 - } }) -v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2628), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(2633), lang.NewKeyword("end-column"), int(58)) -v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) +v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2792), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2799), lang.NewKeyword("end-column"), int(23)) +v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) if err != nil { panic(err) } -return v9 - default: - if len(args) < 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := lang.NewList(args[4:]...) -var v8 lang.FnFunc -v8 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v9 := lang.NewList(args[0:]...) -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("apply")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("concat")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v7, v9}) -v17 := lang.Apply(v12, []any{v3, v4, v5, v6, v16}) -return v17 - } -}) -v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2635), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(2635), lang.NewKeyword("end-column"), int(60)) -v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v10 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// *1 -{ -v0 := lang.NewSymbol("*1").WithMeta(lang.NewMap()).(*lang.Symbol) -v1 := ns.Intern(v0) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// fnil -{ -v0 := lang.NewSymbol("fnil").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("z"))), lang.NewKeyword("doc"), "Takes a function f, and returns a function that calls f, replacing\n a nil first argument to f with the supplied value x. Higher arity\n versions can replace arguments in the second and third\n positions (y, z). Note that the function f can take any number of\n arguments, not just the one(s) being nil-patched.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6601), lang.NewKeyword("end-line"), int(6601))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: +return v6 + case 2: v3 := args[0] v4 := args[1] var v5 lang.FnFunc v5 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v6 := args[0] -var v7 any -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("nil?")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v6}) -if lang.IsTruthy(v11) { -v7 = v4 -} else { -v7 = v6 -} -v12 := lang.Apply(v3, []any{v7}) -return v12 - case 2: -v6 := args[0] -v7 := args[1] -var v8 any -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("nil?")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v6}) -if lang.IsTruthy(v12) { -v8 = v4 -} else { -v8 = v6 -} -v13 := lang.Apply(v3, []any{v8, v7}) -return v13 - case 3: -v6 := args[0] -v7 := args[1] -v8 := args[2] -var v9 any -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("nil?")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{v6}) -if lang.IsTruthy(v13) { -v9 = v4 -} else { -v9 = v6 -} -v14 := lang.Apply(v3, []any{v9, v7, v8}) -return v14 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v6 := args[0] -v7 := args[1] -v8 := args[2] -v9 := lang.NewList(args[3:]...) -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("apply")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -var v13 any -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("nil?")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v6}) -if lang.IsTruthy(v17) { -v13 = v4 -} else { -v13 = v6 -} -v18 := lang.Apply(v12, []any{v3, v13, v7, v8, v9}) -return v18 + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -}) -v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6610), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(6614), lang.NewKeyword("end-column"), int(55)) -v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v7 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -var v6 lang.FnFunc -v6 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v7 := args[0] -v8 := args[1] -var v9 any -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("nil?")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{v7}) -if lang.IsTruthy(v13) { -v9 = v4 -} else { -v9 = v7 -} -var v14 any -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("nil?")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v8}) -if lang.IsTruthy(v18) { -v14 = v5 -} else { -v14 = v8 -} -v19 := lang.Apply(v3, []any{v9, v14}) -return v19 - case 3: -v7 := args[0] -v8 := args[1] -v9 := args[2] -var v10 any -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("nil?")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v7}) -if lang.IsTruthy(v14) { -v10 = v4 -} else { -v10 = v7 +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("seq")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v4}) +var v6 any = v10 +_ = v6 +var v12 any +if lang.IsTruthy(v6) { +var v13 any = v6 +_ = v13 var v15 any v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("nil?")) +v17 := v16.FindInternedVar(lang.NewSymbol("chunked-seq?")) if v17.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } v18 := v17.Get() -v19 := lang.Apply(v18, []any{v8}) +v19 := lang.Apply(v18, []any{v13}) if lang.IsTruthy(v19) { -v15 = v5 -} else { -v15 = v8 -} -v20 := lang.Apply(v3, []any{v10, v15, v9}) -return v20 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v7 := args[0] -v8 := args[1] -v9 := args[2] -v10 := lang.NewList(args[3:]...) -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("apply")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -var v14 any -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("nil?")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v7}) -if lang.IsTruthy(v18) { -v14 = v4 -} else { -v14 = v7 -} -var v19 any -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("nil?")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("chunk-first")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v22 := v21.Get() -v23 := lang.Apply(v22, []any{v8}) -if lang.IsTruthy(v23) { -v19 = v5 -} else { -v19 = v8 +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v13}) +var v20 any = v24 +_ = v20 +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("count")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) } -v24 := lang.Apply(v13, []any{v3, v14, v19, v9, v10}) -return v24 - } -}) -v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6616), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(6619), lang.NewKeyword("end-column"), int(71)) -v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) -if err != nil { - panic(err) +v28 := v27.Get() +v29 := lang.Apply(v28, []any{v20}) +var v25 any = v29 +_ = v25 +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("chunk-buffer")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -return v8 - case 4: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -var v7 lang.FnFunc -v7 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v8 := args[0] -v9 := args[1] -var v10 any -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("nil?")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v25}) +var v30 any = v34 +_ = v30 +v37 := lang.Apply(lang1.LongCast, []any{v25}) +var v36 any = v37 +_ = v36 +var v39 any = int64(0) +_ = v39 +var v40 any +for { +var v41 any +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("<")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) } -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v8}) -if lang.IsTruthy(v14) { -v10 = v4 -} else { -v10 = v8 +v44 := v43.Get() +v45 := lang.Apply(v44, []any{v39, v36}) +if lang.IsTruthy(v45) { +v47, _ := lang.FieldOrMethod(v20, "nth") +if reflect.TypeOf(v47).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) } -var v15 any -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("nil?")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +v48 := lang.Apply(v47, []any{v39}) +var v46 any = v48 +_ = v46 +var v50 any +v51 := lang.Apply(v3, []any{v46}) +if lang.IsTruthy(v51) { +v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v53 := v52.FindInternedVar(lang.NewSymbol("chunk-append")) +if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) } -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v9}) -if lang.IsTruthy(v19) { -v15 = v5 +v54 := v53.Get() +v55 := lang.Apply(v54, []any{v30, v46}) +v50 = v55 } else { -v15 = v9 +v50 = nil } -v20 := lang.Apply(v3, []any{v10, v15}) -return v20 - case 3: -v8 := args[0] -v9 := args[1] -v10 := args[2] -var v11 any -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("nil?")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +_ = v50 +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("unchecked-inc")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) } -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v8}) -if lang.IsTruthy(v15) { -v11 = v4 +v49 := v48.Get() +v50 := lang.Apply(v49, []any{v39}) +var v46 any = v50 +v39 = v46 +continue } else { -v11 = v8 -} -var v16 any -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("nil?")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +v41 = nil } -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v9}) -if lang.IsTruthy(v20) { -v16 = v5 -} else { -v16 = v9 +v40 = v41 + break } -var v21 any -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("nil?")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +_ = v40 +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("chunk-cons")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) } -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v10}) -if lang.IsTruthy(v25) { -v21 = v6 -} else { -v21 = v10 +v38 := v37.Get() +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("chunk")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) } -v26 := lang.Apply(v3, []any{v11, v16, v21}) -return v26 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v8 := args[0] -v9 := args[1] -v10 := args[2] -v11 := lang.NewList(args[3:]...) -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("apply")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +v41 := v40.Get() +v42 := lang.Apply(v41, []any{v30}) +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("filter")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) } -v14 := v13.Get() -var v15 any -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("nil?")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +v45 := v44.Get() +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("chunk-rest")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) } -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v8}) -if lang.IsTruthy(v19) { -v15 = v4 +v48 := v47.Get() +v49 := lang.Apply(v48, []any{v13}) +v50 := lang.Apply(v45, []any{v3, v49}) +v51 := lang.Apply(v38, []any{v42, v50}) +v15 = v51 } else { -v15 = v8 -} -var v20 any v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("nil?")) +v22 := v21.FindInternedVar(lang.NewSymbol("first")) if v22.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } v23 := v22.Get() -v24 := lang.Apply(v23, []any{v9}) -if lang.IsTruthy(v24) { -v20 = v5 -} else { -v20 = v9 -} -var v25 any +v24 := lang.Apply(v23, []any{v13}) +var v20 any = v24 +_ = v20 v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("nil?")) +v27 := v26.FindInternedVar(lang.NewSymbol("rest")) if v27.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) } v28 := v27.Get() -v29 := lang.Apply(v28, []any{v10}) -if lang.IsTruthy(v29) { -v25 = v6 +v29 := lang.Apply(v28, []any{v13}) +var v25 any = v29 +_ = v25 +var v31 any +v32 := lang.Apply(v3, []any{v20}) +if lang.IsTruthy(v32) { +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("cons")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("filter")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v3, v25}) +v40 := lang.Apply(v35, []any{v20, v39}) +v31 = v40 } else { -v25 = v10 +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("filter")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } -v30 := lang.Apply(v14, []any{v3, v15, v20, v25, v11}) -return v30 - } -}) -v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6621), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(6624), lang.NewKeyword("end-column"), int(87)) -v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) -if err != nil { - panic(err) +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v3, v25}) +v31 = v44 } -return v9 +v15 = v31 +} +v12 = v15 +} else { +v12 = nil +} +return v12 +}) +v6 := lang.Apply(lang1.NewLazySeq, []any{v5}) +return v6 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -35419,395 +33243,118 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// print-sequential +// filter-key { -v0 := lang.NewSymbol("print-sequential").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(46), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(46), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("begin"), lang.NewSymbol("print-one"), lang.NewSymbol("sep"), lang.NewSymbol("end"), lang.NewSymbol("sequence"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v0 := lang.NewSymbol("filter-key").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("keyfn"), lang.NewSymbol("pred"), lang.NewSymbol("amap"))), lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4115), lang.NewKeyword("end-line"), int(4117), lang.NewKeyword("private"), true)).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 6 { + if len(args) != 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] v4 := args[1] v5 := args[2] -v6 := args[3] -v7 := args[4] -v8 := args[5] -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("push-thread-bindings")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v7 := lang.NewMap() +v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4118), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(4118), lang.NewKeyword("end-column"), int(17)) +v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("hash-map")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +var v6 any = v9 +_ = v6 +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("seq")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v15 := v14.Get() -v16 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*print-level*")) +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v5}) +var v10 any = v14 +_ = v10 +var v15 any +for { +var v16 any +if lang.IsTruthy(v10) { +var v17 any v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("not")) +v19 := v18.FindInternedVar(lang.NewSymbol("first")) if v19.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("*print-dup*")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +v21 := lang.Apply(v20, []any{v10}) +v22 := lang.Apply(v3, []any{v21}) +v23 := lang.Apply(v4, []any{v22}) +if lang.IsTruthy(v23) { +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("assoc")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -v23 := v22.Get() -v24 := lang.Apply(v20, []any{v23}) -var v17 any = v24 -_ = v17 -var v26 any -if lang.IsTruthy(v17) { +v27 := v26.Get() v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("*print-level*")) +v29 := v28.FindInternedVar(lang.NewSymbol("key")) if v29.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } v30 := v29.Get() -var v27 any = v30 -_ = v27 -var v32 any -if lang.IsTruthy(v27) { -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("dec")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("*print-level*")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v35, []any{v38}) -v32 = v39 -} else { -v32 = v27 -} -v26 = v32 -} else { -v26 = v17 -} -v17 := lang.Apply(v15, []any{v16, v26}) -v18 := lang.Apply(v12, []any{v17}) -_ = v18 -var v19 any -func() { -defer func() { -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.Apply(v22, nil) -}() -var v24 any -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("*print-level*")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -var v25 any = v28 -_ = v25 -var v30 any -if lang.IsTruthy(v25) { v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("neg?")) +v32 := v31.FindInternedVar(lang.NewSymbol("first")) if v32.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("*print-level*")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.Apply(v33, []any{v36}) -v30 = v37 -} else { -v30 = v25 -} -if lang.IsTruthy(v30) { -v25 := lang.Apply(lang1.WriteWriter, []any{v8, "#"}) -v24 = v25 -} else { -v26 := lang.Apply(lang1.WriteWriter, []any{v8, v3}) -_ = v26 -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("seq")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{v7}) -var v27 any = v31 -_ = v27 -var v33 any -if lang.IsTruthy(v27) { -var v34 any = v27 -_ = v34 -var v36 any -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("not")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("*print-dup*")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v40, []any{v43}) -var v37 any = v44 -_ = v37 -var v46 any -if lang.IsTruthy(v37) { -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("*print-length*")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) -} -v49 := v48.Get() -v46 = v49 -} else { -v46 = v37 -} -if lang.IsTruthy(v46) { -var v37 any = v34 -_ = v37 -var v38 any = v37 -_ = v38 -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("seq")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v38}) -var v39 any = v43 -_ = v39 -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("first")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.Apply(v47, []any{v39}) -var v44 any = v48 -_ = v44 -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("next")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.Apply(v52, []any{v49}) -var v49 any = v53 -_ = v49 -var v54 any = v44 -_ = v54 -var v55 any = v49 -_ = v55 -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("*print-length*")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) -} -v59 := v58.Get() -var v56 any = v59 -_ = v56 -var v61 any = v61 -_ = v61 -var v62 any = v62 -_ = v62 -var v63 any -for { -var v64 any = v61 -_ = v64 -v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v67 := v66.FindInternedVar(lang.NewSymbol("seq")) -if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) -} -v68 := v67.Get() -v69 := lang.Apply(v68, []any{v64}) -var v65 any = v69 -_ = v65 -v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v72 := v71.FindInternedVar(lang.NewSymbol("first")) -if v72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) -} -v73 := v72.Get() -v74 := lang.Apply(v73, []any{v65}) -var v70 any = v74 -_ = v70 -v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v77 := v76.FindInternedVar(lang.NewSymbol("next")) -if v77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) +v34 := lang.Apply(v33, []any{v10}) +v35 := lang.Apply(v30, []any{v34}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("val")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) } -v78 := v77.Get() -v79 := lang.Apply(v78, []any{v75}) -var v75 any = v79 -_ = v75 -var v80 any = v70 -_ = v80 -var v81 any = v75 -_ = v81 -var v82 any = v82 -_ = v82 -var v84 any -v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v86 := v85.FindInternedVar(lang.NewSymbol("zero?")) -if v86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) +v38 := v37.Get() +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("first")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) } -v87 := v86.Get() -v88 := lang.Apply(v87, []any{v82}) -if lang.IsTruthy(v88) { -v89 := lang.Apply(lang1.WriteWriter, []any{v8, "..."}) -v84 = v89 -} else { -v90 := lang.Apply(v4, []any{v80, v8}) -_ = v90 -var v91 any -if lang.IsTruthy(v81) { -v92 := lang.Apply(lang1.WriteWriter, []any{v8, v5}) -_ = v92 -var v93 any = v81 -v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v96 := v95.FindInternedVar(lang.NewSymbol("dec")) -if v96.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) +v41 := v40.Get() +v42 := lang.Apply(v41, []any{v10}) +v43 := lang.Apply(v38, []any{v42}) +v44 := lang.Apply(v27, []any{v6, v35, v43}) +var v24 any = v44 +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("next")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) } -v97 := v96.Get() -v98 := lang.Apply(v97, []any{v82}) -var v94 any = v98 -v61 = v93 -v62 = v94 +v48 := v47.Get() +v49 := lang.Apply(v48, []any{v10}) +var v45 any = v49 +v6 = v24 +v10 = v45 continue } else { -v91 = nil -} -v84 = v91 -} -v63 = v84 - break -} -v36 = v63 -} else { -var v37 any = v34 -_ = v37 -var v38 any = v37 -_ = v38 -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("seq")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v38}) -var v39 any = v43 -_ = v39 -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("first")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.Apply(v47, []any{v39}) -var v44 any = v48 -_ = v44 -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("next")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.Apply(v52, []any{v49}) -var v49 any = v53 -_ = v49 -var v54 any = v44 -_ = v54 -var v55 any = v49 -_ = v55 -var v57 any = v57 -_ = v57 -var v58 any -for { -var v59 any = v57 -_ = v59 -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("seq")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) -} -v63 := v62.Get() -v64 := lang.Apply(v63, []any{v59}) -var v60 any = v64 -_ = v60 -v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v67 := v66.FindInternedVar(lang.NewSymbol("first")) -if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) -} -v68 := v67.Get() -v69 := lang.Apply(v68, []any{v60}) -var v65 any = v69 -_ = v65 -v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v72 := v71.FindInternedVar(lang.NewSymbol("next")) -if v72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) +var v50 any = v6 +v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v53 := v52.FindInternedVar(lang.NewSymbol("next")) +if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) } -v73 := v72.Get() -v74 := lang.Apply(v73, []any{v70}) -var v70 any = v74 -_ = v70 -var v75 any = v65 -_ = v75 -var v76 any = v70 -_ = v76 -v78 := lang.Apply(v4, []any{v75, v8}) -_ = v78 -var v79 any -if lang.IsTruthy(v76) { -v80 := lang.Apply(lang1.WriteWriter, []any{v8, v5}) -_ = v80 -var v81 any = v76 -v57 = v81 +v54 := v53.Get() +v55 := lang.Apply(v54, []any{v10}) +var v51 any = v55 +v6 = v50 +v10 = v51 continue -} else { -v79 = nil } -v58 = v79 - break -} -v36 = v58 -} -v33 = v36 +v16 = v17 } else { -v33 = nil +v16 = v6 } -_ = v33 -v27 := lang.Apply(lang1.WriteWriter, []any{v8, v6}) -v24 = v27 +v15 = v16 + break } -v19 = v24 -}() -return v19 +return v15 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -35815,9 +33362,9 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// chunk-cons +// filterv { -v0 := lang.NewSymbol("chunk-cons").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(703), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(703), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("chunk"), lang.NewSymbol("rest"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v0 := lang.NewSymbol("filterv").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a vector of the items in coll for which\n (pred item) returns logical true. pred must be free of side-effects.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7004), lang.NewKeyword("end-line"), int(7004))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { @@ -35825,16 +33372,62 @@ v2 = lang.NewFnFunc(func(args ...any) any { } v3 := args[0] v4 := args[1] -var v5 any -v6 := lang.Apply(lang1.Count, []any{v3}) -v7 := lang.Apply(lang1.IsZero, []any{v6}) -if lang.IsTruthy(v7) { -v5 = v4 +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("persistent!")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("reduce")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +var v11 lang.FnFunc +v11 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v12 := args[0] +v13 := args[1] +var v14 any +v15 := lang.Apply(v3, []any{v13}) +if lang.IsTruthy(v15) { +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("conj!")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v12, v13}) +v14 = v19 } else { -v8 := lang.Apply(lang1.NewChunkedCons, []any{v3, v4}) -v5 = v8 +v14 = v12 } -return v5 +return v14 +}) +v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7010), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(7010), lang.NewKeyword("end-column"), int(52)) +v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("transient")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.NewVector() +v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7011), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(7011), lang.NewKeyword("end-column"), int(27)) +v19, err := lang.WithMeta(v17, v18.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v20 := lang.Apply(v16, []any{v19}) +v21 := lang.Apply(v10, []any{v13, v20, v4}) +v22 := lang.Apply(v7, []any{v21}) +return v22 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -35842,9 +33435,9 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// setup-reference +// find { -v0 := lang.NewSymbol("setup-reference").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2043), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(2044), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("r"), lang.NewSymbol("options"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v0 := lang.NewSymbol("find").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"))), lang.NewKeyword("doc"), "Returns the map entry for key, or nil if key not present.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1530), lang.NewKeyword("end-line"), int(1530))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { @@ -35852,50 +33445,97 @@ v2 = lang.NewFnFunc(func(args ...any) any { } v3 := args[0] v4 := args[1] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("apply")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("hash-map")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +v5, _ := lang.FieldOrMethod(runtime9.RT, "Find") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Find is not a function"))) } -v11 := v10.Get() -v12 := lang.Apply(v8, []any{v11, v4}) -var v5 any = v12 -_ = v5 -var v14 any -v15 := lang.Apply(lang.NewKeyword("meta"), []any{v5}) -if lang.IsTruthy(v15) { -v16 := lang.Apply(lang.NewKeyword("meta"), []any{v5}) -v17, _ := lang.FieldOrMethod(v3, "ResetMeta") -if reflect.TypeOf(v17).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ResetMeta is not a function"))) +v6 := lang.Apply(v5, []any{v3, v4}) +return v6 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v18 := lang.Apply(v17, []any{v16}) -v14 = v18 +} +// find-keyword +{ +v1 := reflect.TypeOf((*lang1.Keyword)(nil)).Elem() +v0 := lang.NewSymbol("find-keyword").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name"))), lang.NewKeyword("doc"), "Returns a Keyword with the given namespace and name if one already\n exists. This function will not intern a new keyword. If the keyword\n has not already been interned, it will return nil. Do not use :\n in the keyword strings, it will be added automatically.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(618), lang.NewKeyword("end-line"), int(618))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v4 := args[0] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("keyword?")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v4}) +if lang.IsTruthy(v9) { +v5 = v4 } else { -v14 = nil +var v10 any +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("symbol?")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -_ = v14 -var v19 any -v20 := lang.Apply(lang.NewKeyword("validator"), []any{v5}) -if lang.IsTruthy(v20) { -v21 := lang.Apply(lang.NewKeyword("validator"), []any{v5}) -v22, _ := lang.FieldOrMethod(v3, "setValidator") -if reflect.TypeOf(v22).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setValidator is not a function"))) +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v4}) +if lang.IsTruthy(v14) { +v15 := lang.Apply(nil, []any{v4}) +v10 = v15 +} else { +var v16 any +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("string?")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v23 := lang.Apply(v22, []any{v21}) -v19 = v23 +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v4}) +if lang.IsTruthy(v20) { +v21 := lang.Apply(nil, []any{v4}) +v16 = v21 } else { -v19 = nil +v16 = nil } -_ = v19 -return v3 +v10 = v16 +} +v5 = v10 +} +return v5 + case 2: +v4 := args[0] +v5 := args[1] +v6 := lang.Apply(nil, []any{v4, v5}) +return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v4 := reflect.TypeOf((*lang1.Keyword)(nil)).Elem() +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// find-ns +{ +v0 := lang.NewSymbol("find-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Returns the namespace named by the symbol or nil if it doesn't exist.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4125), lang.NewKeyword("end-line"), int(4125))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.Apply(lang1.FindNamespace, []any{v3}) +return v4 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -35903,10 +33543,194 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// unchecked-negate +// find-var +{ +v0 := lang.NewSymbol("find-var").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Returns the global var named by the namespace-qualified symbol, or\n nil if no var with that name.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2013), lang.NewKeyword("end-line"), int(2013))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, _ := lang.FieldOrMethod(runtime9.RT, "FindVar") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("FindVar is not a function"))) +} +v5 := lang.Apply(v4, []any{v3}) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// first +{ +v0 := lang.NewSymbol("first").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns the first item in the collection. Calls seq on its\n argument. If coll is nil, returns nil.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(47), lang.NewKeyword("end-line"), int(52))).(*lang.Symbol) +var v2 lang.FnFunc +{ // function first +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := lang.Apply(lang1.First, []any{v4}) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(52), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(52), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) +v3 := v2 +_ = v3 +} +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// fits-table? +{ +v0 := lang.NewSymbol("fits-table?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ints"))), lang.NewKeyword("doc"), "Returns true if the collection of ints can fit within the\n max-table-switch-size, false otherwise.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6668), lang.NewKeyword("end-line"), int(6668), lang.NewKeyword("private"), true)).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("<")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("-")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("apply")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("max")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("seq")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v3}) +v20 := lang.Apply(v12, []any{v15, v19}) +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("apply")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("min")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("seq")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{v3}) +v31 := lang.Apply(v23, []any{v26, v30}) +v32 := lang.Apply(v9, []any{v20, v31}) +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("max-switch-table-size")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v6, []any{v32, v35}) +return v36 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// flatten +{ +v0 := lang.NewSymbol("flatten").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Takes any nested combination of sequential things (lists, vectors,\n etc.) and returns their contents as a single, flat lazy sequence.\n (flatten nil) returns an empty sequence.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7161), lang.NewKeyword("end-line"), int(7161))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("filter")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("complement")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("sequential?")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v9, []any{v12}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("rest")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("tree-seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("sequential?")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("seq")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v19, []any{v22, v25, v3}) +v27 := lang.Apply(v16, []any{v26}) +v28 := lang.Apply(v6, []any{v13, v27}) +return v28 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// float { var v1 lang.FnFunc -{ // function unchecked-negate__inliner +{ // function float__inliner v1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -35937,7 +33761,7 @@ if v15.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v19 := v18.FindInternedVar(lang.NewSymbol("list")) if v19.IsMacro() { @@ -35962,37 +33786,163 @@ if v28.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/unchecked_minus")}) +var v30 any v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) +v32 := v31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) if v32.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } v33 := v32.Get() -v34 := lang.Apply(v33, []any{v3}) -v35 := lang.Apply(v26, []any{v30, v34}) -v36 := lang.Apply(v23, []any{v35}) -v37 := lang.Apply(v20, []any{v36}) -v38 := lang.Apply(v9, []any{v13, v17, v37}) -v39 := lang.Apply(v6, []any{v38}) -return v39 +if lang.IsTruthy(v33) { +v30 = lang.NewSymbol("uncheckedFloatCast") +} else { +v30 = lang.NewSymbol("floatCast") +} +v34 := lang.Apply(v29, []any{v30}) +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("list")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v37, []any{v3}) +v39 := lang.Apply(v26, []any{v34, v38}) +v40 := lang.Apply(v23, []any{v39}) +v41 := lang.Apply(v20, []any{v40}) +v42 := lang.Apply(v9, []any{v13, v17, v41}) +v43 := lang.Apply(v6, []any{v42}) +return v43 }) v2 := v1 _ = v2 } -v0 := lang.NewSymbol("unchecked-negate").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the negation of x, a long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1189), lang.NewKeyword("end-line"), int(1189))).(*lang.Symbol) +v0 := lang.NewSymbol("float").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to float", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3487), lang.NewKeyword("end-line"), int(3487))).(*lang.Symbol) var v3 lang.FnFunc v3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "Unchecked_negate") +v5 := lang.Apply(lang1.FloatCast, []any{v4}) +return v5 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// float-array +{ +var v1 lang.FnFunc +{ // function float-array__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.NewList(args[0:]...) +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/floatArray")}) +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("list")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("seq")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("concat")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("list")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v37, []any{lang.NewSymbol("glojure.core/args")}) +v39 := lang.Apply(v30, []any{v34, v38}) +v40 := lang.Apply(v27, []any{v39}) +v41 := lang.Apply(v24, []any{v40}) +v42 := lang.Apply(v9, []any{v13, v17, v21, v41}) +v43 := lang.Apply(v6, []any{v42}) +return v43 + } +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("float-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Creates an array of floats", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5301), lang.NewKeyword("end-line"), int(5301))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "floatArray") if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_negate is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("floatArray is not a function"))) } v6 := lang.Apply(v5, []any{v4}) return v6 + case 2: +v4 := args[0] +v5 := args[1] +v6, _ := lang.FieldOrMethod(lang1.Numbers, "floatArrayInit") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("floatArrayInit is not a function"))) +} +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } }) v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v2 := ns.InternWithValue(v0, v3, true) @@ -36000,142 +33950,142 @@ if v0.Meta() != nil { v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// char? +// float? { -v0 := lang.NewSymbol("char?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a Character", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(153), lang.NewKeyword("end-line"), int(157))).(*lang.Symbol) +v0 := lang.NewSymbol("float?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is a floating point number", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3605), lang.NewKeyword("end-line"), int(3605))).(*lang.Symbol) var v2 lang.FnFunc -{ // function char? v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v4 := args[0] +v3 := args[0] v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) if v6.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } v7 := v6.Get() -v8 := lang.Apply(v7, []any{lang1.Char, v4}) -return v8 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(157), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(157), lang.NewKeyword("end-column"), int(89))).(lang.FnFunc) -v3 := v2 -_ = v3 +v8 := lang.Apply(v7, []any{lang.Builtins["float64"], v3}) +var v4 any = v8 +_ = v4 +var v10 any +if lang.IsTruthy(v4) { +v10 = v4 +} else { +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("instance?")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{lang.Builtins["float32"], v3}) +v10 = v14 } +return v10 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// fn? +// floats { -v0 := lang.NewSymbol("fn?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements Fn, i.e. is an object created via fn.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6259), lang.NewKeyword("end-line"), int(6259))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { +var v1 lang.FnFunc +{ // function floats +v1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -v7 := lang.Apply(v6, []any{runtime3.*Fn, v3}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -// true? -{ -v1 := reflect.TypeOf(false) -v0 := lang.NewSymbol("true?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is the value true, false otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(511), lang.NewKeyword("end-line"), int(511))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := lang.Apply(lang1.Identical, []any{v4, true}) -return v5 -}) -v4 := reflect.TypeOf(false) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// in-ns -{ -v0 := lang.NewSymbol("in-ns").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, nil, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -// ref-min-history -{ -v0 := lang.NewSymbol("ref-min-history").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref")), lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Gets the min-history of a ref, or sets it and returns the ref", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2462), lang.NewKeyword("end-line"), int(2462))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -v4, ok := lang.FieldOrMethod(v3, "getMinHistory") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getMinHistory"))) +v20 := v19.Get() +v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/floats")}) +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("list")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -var v5 any -switch reflect.TypeOf(v4).Kind() { -case reflect.Func: - v5 = lang.Apply(v4, nil) -default: - v5 = v4 +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v3}) +v26 := lang.Apply(v9, []any{v13, v17, v21, v25}) +v27 := lang.Apply(v6, []any{v26}) +return v27 +}) +v2 := v1 +_ = v2 } -return v5 - case 2: -v3 := args[0] -v4 := args[1] -v5, _ := lang.FieldOrMethod(v3, "setMinHistory") +v0 := lang.NewSymbol("floats").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Casts to float[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5392), lang.NewKeyword("end-line"), int(5392))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "floats") if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMinHistory is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("floats is not a function"))) } v6 := lang.Apply(v5, []any{v4}) return v6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// decimal? +// flush { -v0 := lang.NewSymbol("decimal?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is a BigDecimal", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3599), lang.NewKeyword("end-line"), int(3599))).(*lang.Symbol) +v0 := lang.NewSymbol("flush").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Flushes the output stream that is the current value of\n *out*", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3706), lang.NewKeyword("end-line"), int(3706))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { + if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v4 := v3.FindInternedVar(lang.NewSymbol("*out*")) +if v4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) } -v6 := v5.Get() -v7 := lang.Apply(v6, []any{lang1.*BigDecimal, v3}) -return v7 +v5 := v4.Get() +v6, _ := lang.FieldOrMethod(v5, "Sync") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Sync is not a function"))) +} +v7 := lang.Apply(v6, []any{}) +_ = v7 +return nil }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -36143,834 +34093,678 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// create-ns +// fn { -v0 := lang.NewSymbol("create-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Create a new namespace named by the symbol if one doesn't already\n exist, returns it or the already-existing namespace of the same\n name.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4131), lang.NewKeyword("end-line"), int(4131))).(*lang.Symbol) +v0 := lang.NewSymbol("fn").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("sigs"))), lang.NewKeyword("doc"), "params => positional-params*, or positional-params* & rest-param\n positional-param => binding-form\n rest-param => binding-form\n binding-form => name, or destructuring-form\n\n Defines a function.\n\n See https://glojure.org/reference/special_forms#fn for more information", lang.NewKeyword("forms"), lang.NewVector(lang.NewList(lang.NewSymbol("fn"), lang.NewSymbol("name?"), lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("exprs*")), lang.NewList(lang.NewSymbol("fn"), lang.NewSymbol("name?"), lang.NewList(lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("exprs*")), lang.NewSymbol("+"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4533), lang.NewKeyword("end-line"), int(4533), lang.NewKeyword("special-form"), true)).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.Apply(nil, []any{v3}) -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// symbol -{ -v1 := reflect.TypeOf((*lang1.Symbol)(nil)) -v0 := lang.NewSymbol("symbol").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name"))), lang.NewKeyword("doc"), "Returns a Symbol with the given namespace and name. Arity-1 works\n on strings, keywords, and vars.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(584), lang.NewKeyword("end-line"), int(584))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 1: -v4 := args[0] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("symbol?")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v4}) -if lang.IsTruthy(v9) { -v5 = v4 -} else { -var v10 any -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("instance?")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{lang.Builtins["string"], v4}) -if lang.IsTruthy(v14) { -v15 := lang.Apply(lang1.NewSymbol, []any{v4}) -v10 = v15 -} else { -var v16 any -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("instance?")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{lang1.*Var, v4}) -if lang.IsTruthy(v20) { -v21, ok := lang.FieldOrMethod(v4, "toSymbol") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "toSymbol"))) -} -var v22 any -switch reflect.TypeOf(v21).Kind() { -case reflect.Func: - v22 = lang.Apply(v21, nil) -default: - v22 = v21 -} -v16 = v22 -} else { -var v23 any -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("instance?")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v26, []any{lang1.Keyword, v4}) -if lang.IsTruthy(v27) { -v28, ok := lang.FieldOrMethod(v4, "sym") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "sym"))) -} -var v29 any -switch reflect.TypeOf(v28).Kind() { -case reflect.Func: - v29 = lang.Apply(v28, nil) -default: - v29 = v28 -} -v23 = v29 -} else { -var v30 any -if lang.IsTruthy(lang.NewKeyword("else")) { -v31 := lang.Apply(lang1.NewIllegalArgumentError, []any{"no conversion to symbol"}) -panic(v31) -} else { -v30 = nil -} -v23 = v30 -} -v16 = v23 -} -v10 = v16 -} -v5 = v10 -} -return v5 - case 2: -v4 := args[0] -v5 := args[1] -v6 := lang.Apply(lang1.InternSymbol, []any{v4, v5}) -return v6 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v4 := reflect.TypeOf((*lang1.Symbol)(nil)) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// bit-shift-left -{ -var v1 lang.FnFunc -{ // function bit-shift-left__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() +v5 := lang.NewList(args[2:]...) +var v7 any v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("concat")) +v9 := v8.FindInternedVar(lang.NewSymbol("symbol?")) if v9.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } v10 := v9.Get() v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("list")) +v12 := v11.FindInternedVar(lang.NewSymbol("first")) if v12.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } v13 := v12.Get() -v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +v14 := lang.Apply(v13, []any{v5}) +v15 := lang.Apply(v10, []any{v14}) +if lang.IsTruthy(v15) { +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("first")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v5}) +v7 = v19 +} else { +v7 = nil } -v21 := v20.Get() +var v6 any = v7 +_ = v6 +var v21 any +if lang.IsTruthy(v6) { v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("seq")) +v23 := v22.FindInternedVar(lang.NewSymbol("next")) if v23.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("concat")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +v25 := lang.Apply(v24, []any{v20}) +v21 = v25 +} else { +v21 = v20 } -v27 := v26.Get() +var v20 any = v21 +_ = v20 +var v27 any v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("list")) +v29 := v28.FindInternedVar(lang.NewSymbol("vector?")) if v29.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } v30 := v29.Get() -v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/shiftLeft")}) -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("first")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v26}) +v35 := lang.Apply(v30, []any{v34}) +if lang.IsTruthy(v35) { v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v37 := v36.FindInternedVar(lang.NewSymbol("list")) if v37.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) } v38 := v37.Get() -v39 := lang.Apply(v38, []any{v4}) -v40 := lang.Apply(v27, []any{v31, v35, v39}) -v41 := lang.Apply(v24, []any{v40}) -v42 := lang.Apply(v21, []any{v41}) -v43 := lang.Apply(v10, []any{v14, v18, v42}) -v44 := lang.Apply(v7, []any{v43}) -return v44 -}) -v2 := v1 -_ = v2 +v39 := lang.Apply(v38, []any{v26}) +v27 = v39 +} else { +var v40 any +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("seq?")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } -v0 := lang.NewSymbol("bit-shift-left").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Bitwise shift left", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1361), lang.NewKeyword("end-line"), int(1361))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6, _ := lang.FieldOrMethod(lang1.Numbers, "shiftLeft") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("shiftLeft is not a function"))) +v43 := v42.Get() +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("first")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v26}) +v48 := lang.Apply(v43, []any{v47}) +if lang.IsTruthy(v48) { +v40 = v26 +} else { +var v49 any +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("seq")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) } +v52 := v51.Get() +v53 := lang.Apply(v52, []any{v26}) +if lang.IsTruthy(v53) { +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("str")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) } -// random-sample -{ -v0 := lang.NewSymbol("random-sample").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("prob")), lang.NewVector(lang.NewSymbol("prob"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns items from coll with random probability of prob (0.0 -\n 1.0). Returns a transducer when no collection is provided.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7742), lang.NewKeyword("end-line"), int(7742))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("filter")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v56 := v55.Get() +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("first")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) } -v6 := v5.Get() -var v7 lang.FnFunc -v7 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v8 := args[0] -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("<")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +v59 := v58.Get() +v60 := lang.Apply(v59, []any{v26}) +v61 := lang.Apply(v56, []any{"Parameter declaration ", v60, " should be a vector"}) +v49 = v61 +} else { +v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v63 := v62.FindInternedVar(lang.NewSymbol("str")) +if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) } -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("rand")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +v64 := v63.Get() +v65 := lang.Apply(v64, []any{"Parameter declaration missing"}) +v49 = v65 } -v14 := v13.Get() -v15 := lang.Apply(v14, nil) -v16 := lang.Apply(v11, []any{v15, v3}) -return v16 -}) -v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7747), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(7747), lang.NewKeyword("end-column"), int(37)) -v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) -if err != nil { - panic(err) +v66 := lang.Apply(lang1.NewIllegalArgumentError, []any{v49}) +panic(v66) } -v10 := lang.Apply(v6, []any{v9}) -return v10 - case 2: -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("filter")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v27 = v40 } -v7 := v6.Get() -var v8 lang.FnFunc -v8 = lang.NewFnFunc(func(args ...any) any { +var v26 any = v27 +_ = v26 +var v68 lang.FnFunc +v68 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v9 := args[0] -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("<")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v69 := args[0] +var v70 any +v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v72 := v71.FindInternedVar(lang.NewSymbol("not")) +if v72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) } -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("rand")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +v73 := v72.Get() +v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v75 := v74.FindInternedVar(lang.NewSymbol("seq?")) +if v75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) } -v15 := v14.Get() -v16 := lang.Apply(v15, nil) -v17 := lang.Apply(v12, []any{v16, v3}) -return v17 -}) -v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7749), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(7749), lang.NewKeyword("end-column"), int(37)) -v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) -if err != nil { - panic(err) +v76 := v75.Get() +v77 := lang.Apply(v76, []any{v69}) +v78 := lang.Apply(v73, []any{v77}) +if lang.IsTruthy(v78) { +v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v80 := v79.FindInternedVar(lang.NewSymbol("str")) +if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) } -v11 := lang.Apply(v7, []any{v10, v4}) -return v11 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v81 := v80.Get() +v82 := lang.Apply(v81, []any{"Invalid signature ", v69, " should be a list"}) +v83 := lang.Apply(lang1.NewIllegalArgumentError, []any{v82}) +panic(v83) +} else { +v70 = nil } +_ = v70 +var v84 any = v69 +_ = v84 +v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v87 := v86.FindInternedVar(lang.NewSymbol("seq")) +if v87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) } -// subvec -{ -v0 := lang.NewSymbol("subvec").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("v"), lang.NewSymbol("start")), lang.NewVector(lang.NewSymbol("v"), lang.NewSymbol("start"), lang.NewSymbol("end"))), lang.NewKeyword("doc"), "Returns a persistent vector of the items in vector from\n start (inclusive) to end (exclusive). If end is not supplied,\n defaults to (count vector). This operation is O(1) and very fast, as\n the resulting vector shares structure with the original and no\n trimming is done.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3819), lang.NewKeyword("end-line"), int(3819))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("subvec")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v88 := v87.Get() +v89 := lang.Apply(v88, []any{v84}) +var v85 any = v89 +_ = v85 +v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v92 := v91.FindInternedVar(lang.NewSymbol("first")) +if v92.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) } -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("count")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v93 := v92.Get() +v94 := lang.Apply(v93, []any{v85}) +var v90 any = v94 +_ = v90 +v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v97 := v96.FindInternedVar(lang.NewSymbol("next")) +if v97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) } -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v3}) -v12 := lang.Apply(v7, []any{v3, v4, v11}) -return v12 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6, _ := lang.FieldOrMethod(runtime3.RT, "Subvec") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Subvec is not a function"))) +v98 := v97.Get() +v99 := lang.Apply(v98, []any{v95}) +var v95 any = v99 +_ = v95 +var v100 any = v90 +_ = v100 +var v101 any = v95 +_ = v101 +var v103 any +v104 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v105 := v104.FindInternedVar(lang.NewSymbol("not")) +if v105.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v105))) } -v7 := lang.Apply(v6, []any{v3, v4, v5}) -return v7 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v106 := v105.Get() +v107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v108 := v107.FindInternedVar(lang.NewSymbol("vector?")) +if v108.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v108))) } +v109 := v108.Get() +v110 := lang.Apply(v109, []any{v100}) +v111 := lang.Apply(v106, []any{v110}) +if lang.IsTruthy(v111) { +var v112 any +v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v114 := v113.FindInternedVar(lang.NewSymbol("seq?")) +if v114.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) } -// ffirst -{ -v0 := lang.NewSymbol("ffirst").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Same as (first (first x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(98), lang.NewKeyword("end-line"), int(102))).(*lang.Symbol) -var v2 lang.FnFunc -{ // function ffirst -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("first")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v115 := v114.Get() +v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v117 := v116.FindInternedVar(lang.NewSymbol("first")) +if v117.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) } -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("first")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v118 := v117.Get() +v119 := lang.Apply(v118, []any{v26}) +v120 := lang.Apply(v115, []any{v119}) +if lang.IsTruthy(v120) { +v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v122 := v121.FindInternedVar(lang.NewSymbol("str")) +if v122.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) } -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v4}) -v12 := lang.Apply(v7, []any{v11}) -return v12 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(102), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(102), lang.NewKeyword("end-column"), int(50))).(lang.FnFunc) -v3 := v2 -_ = v3 +v123 := v122.Get() +v124 := lang.Apply(v123, []any{"Parameter declaration ", v100, " should be a vector"}) +v112 = v124 +} else { +v125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v126 := v125.FindInternedVar(lang.NewSymbol("str")) +if v126.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v126))) } -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v127 := v126.Get() +v128 := lang.Apply(v127, []any{"Invalid signature ", v69, " should be a list"}) +v112 = v128 } +v129 := lang.Apply(lang1.NewIllegalArgumentError, []any{v112}) +panic(v129) +} else { +v103 = nil } -// read -{ -v0 := lang.NewSymbol("read").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("stream")), lang.NewVector(lang.NewSymbol("stream"), lang.NewSymbol("eof-error?"), lang.NewSymbol("eof-value")), lang.NewVector(lang.NewSymbol("stream"), lang.NewSymbol("eof-error?"), lang.NewSymbol("eof-value"), lang.NewSymbol("recursive?")), lang.NewVector(lang.NewSymbol("opts"), lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Reads the next object from stream, which must be an instance of\n java.io.PushbackReader or some derivee. stream defaults to the\n current value of *in*.\n\n Opts is a persistent map with valid keys:\n :read-cond - :allow to process reader conditionals, or\n :preserve to keep all branches\n :features - persistent set of feature keywords for reader conditionals\n :eof - on eof, return value unless :eofthrow, then throw.\n if not specified, will throw\n\n Note that read can execute code (controlled by *read-eval*),\n and as such should be used only with trusted sources.\n\n For data structure interop use glojure.edn/read", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3742), lang.NewKeyword("end-line"), int(3742))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v4 := v3.FindInternedVar(lang.NewSymbol("read")) -if v4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) +var v102 any = v103 +_ = v102 +var v131 any +v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v134 := v133.FindInternedVar(lang.NewSymbol("next")) +if v134.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) } -v5 := v4.Get() -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("*in*")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +v135 := v134.Get() +v136 := lang.Apply(v135, []any{v101}) +var v132 any = v136 +_ = v132 +var v138 any +if lang.IsTruthy(v132) { +v139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v140 := v139.FindInternedVar(lang.NewSymbol("map?")) +if v140.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v140))) } -v8 := v7.Get() -v9 := lang.Apply(v5, []any{v8}) -return v9 - case 1: -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("read")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v141 := v140.Get() +v142 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v143 := v142.FindInternedVar(lang.NewSymbol("first")) +if v143.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v143))) } -v6 := v5.Get() -v7 := lang.Apply(v6, []any{v3, true, nil}) -return v7 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("read")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +v144 := v143.Get() +v145 := lang.Apply(v144, []any{v101}) +v146 := lang.Apply(v141, []any{v145}) +v138 = v146 +} else { +v138 = v132 } -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v3, v4, v5, false}) -return v9 - case 4: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("boolean")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +if lang.IsTruthy(v138) { +v132 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v133 := v132.FindInternedVar(lang.NewSymbol("first")) +if v133.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v133))) } -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v4}) -v11, _ := lang.FieldOrMethod(glojure.lang11.LispReader, "read") -if reflect.TypeOf(v11).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("read is not a function"))) +v134 := v133.Get() +v135 := lang.Apply(v134, []any{v101}) +v131 = v135 +} else { +v131 = nil } -v12 := lang.Apply(v11, []any{v3, v10, v5, v6}) -return v12 - case 2: -v3 := args[0] -v4 := args[1] -v5, _ := lang.FieldOrMethod(glojure.lang11.LispReader, "read") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("read is not a function"))) +var v130 any = v131 +_ = v130 +var v137 any +if lang.IsTruthy(v130) { +v138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v139 := v138.FindInternedVar(lang.NewSymbol("next")) +if v139.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v139))) } -v6 := lang.Apply(v5, []any{v4, v3}) -return v6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v140 := v139.Get() +v141 := lang.Apply(v140, []any{v136}) +v137 = v141 +} else { +v137 = v136 } +var v136 any = v137 +_ = v136 +var v143 any = v142 +_ = v143 +var v145 any +if lang.IsTruthy(v143) { +v145 = v143 +} else { +v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v147 := v146.FindInternedVar(lang.NewSymbol("meta")) +if v147.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) } -// partition-by -{ -v0 := lang.NewSymbol("partition-by").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Applies f to each value in coll, splitting it each time f returns a\n new value. Returns a lazy seq of partitions. Returns a stateful\n transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7185), lang.NewKeyword("end-line"), int(7185))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := args[0] -var v6 any = "unimplemented: new with non-constant class type" -_ = v6 -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("volatile!")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v148 := v147.Get() +v149 := lang.Apply(v148, []any{v100}) +v145 = v149 } -v10 := v9.Get() -v11 := lang.Apply(v10, []any{lang.NewKeyword("glojure.core/none")}) -var v7 any = v11 -_ = v7 -var v13 lang.FnFunc -v13 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v14 := lang.Apply(v5, nil) -return v14 - case 1: -v14 := args[0] -var v16 any -v17, ok := lang.FieldOrMethod(v6, "isEmpty") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "isEmpty"))) +var v142 any = v145 +_ = v142 +v144 := lang.Apply(lang.NewKeyword("pre"), []any{v142}) +var v143 any = v144 +_ = v143 +v146 := lang.Apply(lang.NewKeyword("post"), []any{v142}) +var v145 any = v146 +_ = v145 +var v148 any +if lang.IsTruthy(v145) { +v149 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v150 := v149.FindInternedVar(lang.NewSymbol("seq")) +if v150.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v150))) } -var v18 any -switch reflect.TypeOf(v17).Kind() { -case reflect.Func: - v18 = lang.Apply(v17, nil) -default: - v18 = v17 +v151 := v150.Get() +v152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v153 := v152.FindInternedVar(lang.NewSymbol("concat")) +if v153.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v153))) } -if lang.IsTruthy(v18) { -v16 = v15 -} else { -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("vec")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +v154 := v153.Get() +v155 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v156 := v155.FindInternedVar(lang.NewSymbol("list")) +if v156.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v156))) } -v22 := v21.Get() -v23, ok := lang.FieldOrMethod(v6, "toArray") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "toArray"))) +v157 := v156.Get() +v158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v159 := v158.FindInternedVar(lang.NewSymbol("seq")) +if v159.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v159))) } -var v24 any -switch reflect.TypeOf(v23).Kind() { -case reflect.Func: - v24 = lang.Apply(v23, nil) -default: - v24 = v23 +v160 := v159.Get() +v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v162 := v161.FindInternedVar(lang.NewSymbol("concat")) +if v162.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) } -v25 := lang.Apply(v22, []any{v24}) -var v19 any = v25 -_ = v19 -v27, ok := lang.FieldOrMethod(v6, "clear") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "clear"))) +v163 := v162.Get() +v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v165 := v164.FindInternedVar(lang.NewSymbol("list")) +if v165.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) } -var v28 any -switch reflect.TypeOf(v27).Kind() { -case reflect.Func: - v28 = lang.Apply(v27, nil) -default: - v28 = v27 +v166 := v165.Get() +v167 := lang.Apply(v166, []any{lang.NewSymbol("glojure.core/let")}) +v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v169 := v168.FindInternedVar(lang.NewSymbol("list")) +if v169.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) } -_ = v28 -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("unreduced")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +v170 := v169.Get() +v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v172 := v171.FindInternedVar(lang.NewSymbol("apply")) +if v172.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) } -v31 := v30.Get() -v32 := lang.Apply(v5, []any{v15, v19}) -v33 := lang.Apply(v31, []any{v32}) -v16 = v33 +v173 := v172.Get() +v174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v175 := v174.FindInternedVar(lang.NewSymbol("vector")) +if v175.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v175))) } -var v15 any = v16 -_ = v15 -v20 := lang.Apply(v5, []any{v15}) -return v20 - case 2: -v14 := args[0] -v15 := args[1] -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("deref")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +v176 := v175.Get() +v177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v178 := v177.FindInternedVar(lang.NewSymbol("seq")) +if v178.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v178))) } -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v7}) -var v16 any = v20 -_ = v16 -v22 := lang.Apply(v3, []any{v15}) -var v21 any = v22 -_ = v21 -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("vreset!")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +v179 := v178.Get() +v180 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v181 := v180.FindInternedVar(lang.NewSymbol("concat")) +if v181.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v181))) } -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v7, v21}) -_ = v27 -var v28 any -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("identical?")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +v182 := v181.Get() +v183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v184 := v183.FindInternedVar(lang.NewSymbol("list")) +if v184.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v184))) } -v32 := v31.Get() -v33 := lang.Apply(v32, []any{v16, lang.NewKeyword("glojure.core/none")}) -var v29 any = v33 -_ = v29 -var v35 any -if lang.IsTruthy(v29) { -v35 = v29 -} else { -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("=")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +v185 := v184.Get() +v186 := lang.Apply(v185, []any{lang.NewSymbol("%")}) +v187 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v188 := v187.FindInternedVar(lang.NewSymbol("list")) +if v188.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v188))) } -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v21, v16}) -v35 = v39 +v189 := v188.Get() +var v190 any +v191 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v192 := v191.FindInternedVar(lang.NewSymbol("<")) +if v192.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v192))) } -if lang.IsTruthy(v35) { -v29, _ := lang.FieldOrMethod(v6, "add") -if reflect.TypeOf(v29).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) +v193 := v192.Get() +v194 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v195 := v194.FindInternedVar(lang.NewSymbol("count")) +if v195.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v195))) } -v30 := lang.Apply(v29, []any{v15}) -_ = v30 -v28 = v14 -} else { -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("vec")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +v196 := v195.Get() +v197 := lang.Apply(v196, []any{v147}) +v198 := lang.Apply(v193, []any{int64(1), v197}) +if lang.IsTruthy(v198) { +v199 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v200 := v199.FindInternedVar(lang.NewSymbol("seq")) +if v200.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v200))) } -v34 := v33.Get() -v35, ok := lang.FieldOrMethod(v6, "toArray") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "toArray"))) +v201 := v200.Get() +v202 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v203 := v202.FindInternedVar(lang.NewSymbol("concat")) +if v203.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v203))) } -var v36 any -switch reflect.TypeOf(v35).Kind() { -case reflect.Func: - v36 = lang.Apply(v35, nil) -default: - v36 = v35 -} -v37 := lang.Apply(v34, []any{v36}) -var v31 any = v37 -_ = v31 -v39, ok := lang.FieldOrMethod(v6, "clear") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "clear"))) -} -var v40 any -switch reflect.TypeOf(v39).Kind() { -case reflect.Func: - v40 = lang.Apply(v39, nil) -default: - v40 = v39 -} -_ = v40 -v42 := lang.Apply(v5, []any{v14, v31}) -var v41 any = v42 -_ = v41 -var v44 any -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("reduced?")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +v204 := v203.Get() +v205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v206 := v205.FindInternedVar(lang.NewSymbol("list")) +if v206.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v206))) } -v47 := v46.Get() -v48 := lang.Apply(v47, []any{v41}) -if lang.IsTruthy(v48) { -v44 = nil +v207 := v206.Get() +v208 := lang.Apply(v207, []any{lang.NewSymbol("do")}) +v209 := lang.Apply(v204, []any{v208, v147}) +v210 := lang.Apply(v201, []any{v209}) +v190 = v210 } else { -v49, _ := lang.FieldOrMethod(v6, "add") -if reflect.TypeOf(v49).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) +v211 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v212 := v211.FindInternedVar(lang.NewSymbol("first")) +if v212.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v212))) } -v50 := lang.Apply(v49, []any{v15}) -v44 = v50 +v213 := v212.Get() +v214 := lang.Apply(v213, []any{v147}) +v190 = v214 } -_ = v44 -v28 = v41 +v215 := lang.Apply(v189, []any{v190}) +v216 := lang.Apply(v182, []any{v186, v215}) +v217 := lang.Apply(v179, []any{v216}) +v218 := lang.Apply(v173, []any{v176, v217}) +v219 := lang.Apply(v170, []any{v218}) +v220 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v221 := v220.FindInternedVar(lang.NewSymbol("map")) +if v221.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v221))) } -return v28 - default: +v222 := v221.Get() +var v223 lang.FnFunc +v223 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -}) -v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7195), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(7219), lang.NewKeyword("end-column"), int(28)) -v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) -if err != nil { - panic(err) +v224 := args[0] +v225 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v226 := v225.FindInternedVar(lang.NewSymbol("seq")) +if v226.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v226))) } -return v15 +v227 := v226.Get() +v228 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v229 := v228.FindInternedVar(lang.NewSymbol("concat")) +if v229.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v229))) +} +v230 := v229.Get() +v231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v232 := v231.FindInternedVar(lang.NewSymbol("list")) +if v232.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v232))) +} +v233 := v232.Get() +v234 := lang.Apply(v233, []any{lang.NewSymbol("glojure.core/assert")}) +v235 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v236 := v235.FindInternedVar(lang.NewSymbol("list")) +if v236.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v236))) +} +v237 := v236.Get() +v238 := lang.Apply(v237, []any{v224}) +v239 := lang.Apply(v230, []any{v234, v238}) +v240 := lang.Apply(v227, []any{v239}) +return v240 }) -v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7192), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(7219), lang.NewKeyword("end-column"), int(30)) -v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) +v224 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4582), lang.NewKeyword("column"), int(41), lang.NewKeyword("end-line"), int(4582), lang.NewKeyword("end-column"), int(62)) +v225, err := lang.WithMeta(v223, v224.(lang.IPersistentMap)) if err != nil { panic(err) } -return v6 - case 2: -v3 := args[0] -v4 := args[1] -var v5 lang.FnFunc -v5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("seq")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v226 := lang.Apply(v222, []any{v225, v145}) +v227 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v228 := v227.FindInternedVar(lang.NewSymbol("list")) +if v228.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v228))) } -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v4}) -var v6 any = v10 -_ = v6 -var v12 any -if lang.IsTruthy(v6) { -var v13 any = v6 -_ = v13 -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("first")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +v229 := v228.Get() +v230 := lang.Apply(v229, []any{lang.NewSymbol("%")}) +v231 := lang.Apply(v163, []any{v167, v219, v226, v230}) +v232 := lang.Apply(v160, []any{v231}) +v233 := lang.Apply(v157, []any{v232}) +v234 := lang.Apply(v154, []any{v233}) +v235 := lang.Apply(v151, []any{v234}) +v148 = v235 +} else { +v148 = v147 } -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v13}) -var v15 any = v19 -_ = v15 -v21 := lang.Apply(v3, []any{v15}) -var v20 any = v21 -_ = v20 -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("cons")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +var v147 any = v148 +_ = v147 +var v237 any +if lang.IsTruthy(v143) { +v238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v239 := v238.FindInternedVar(lang.NewSymbol("concat")) +if v239.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v239))) } -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("take-while")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +v240 := v239.Get() +v241 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v242 := v241.FindInternedVar(lang.NewSymbol("map")) +if v242.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v242))) } -v28 := v27.Get() -var v29 lang.FnFunc -v29 = lang.NewFnFunc(func(args ...any) any { +v243 := v242.Get() +var v244 lang.FnFunc +v244 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v30 := args[0] -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("=")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v245 := args[0] +v246 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v247 := v246.FindInternedVar(lang.NewSymbol("seq")) +if v247.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v247))) } -v33 := v32.Get() -v34 := lang.Apply(v3, []any{v30}) -v35 := lang.Apply(v33, []any{v20, v34}) -return v35 +v248 := v247.Get() +v249 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v250 := v249.FindInternedVar(lang.NewSymbol("concat")) +if v250.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v250))) +} +v251 := v250.Get() +v252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v253 := v252.FindInternedVar(lang.NewSymbol("list")) +if v253.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v253))) +} +v254 := v253.Get() +v255 := lang.Apply(v254, []any{lang.NewSymbol("glojure.core/assert")}) +v256 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v257 := v256.FindInternedVar(lang.NewSymbol("list")) +if v257.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v257))) +} +v258 := v257.Get() +v259 := lang.Apply(v258, []any{v245}) +v260 := lang.Apply(v251, []any{v255, v259}) +v261 := lang.Apply(v248, []any{v260}) +return v261 }) -v30 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7225), lang.NewKeyword("column"), int(41), lang.NewKeyword("end-line"), int(7225), lang.NewKeyword("end-column"), int(53)) -v31, err := lang.WithMeta(v29, v30.(lang.IPersistentMap)) +v245 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4586), lang.NewKeyword("column"), int(44), lang.NewKeyword("end-line"), int(4586), lang.NewKeyword("end-column"), int(65)) +v246, err := lang.WithMeta(v244, v245.(lang.IPersistentMap)) if err != nil { panic(err) } -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("next")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +v247 := lang.Apply(v243, []any{v246, v143}) +v248 := lang.Apply(v240, []any{v247, v236}) +v237 = v248 +} else { +v237 = v236 } -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v13}) -v36 := lang.Apply(v28, []any{v31, v35}) -v37 := lang.Apply(v25, []any{v15, v36}) -var v22 any = v37 -_ = v22 -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("cons")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +var v236 any = v237 +_ = v236 +v250 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v251 := v250.FindInternedVar(lang.NewSymbol("maybe-destructured")) +if v251.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v251))) } -v41 := v40.Get() -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("partition-by")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +v252 := v251.Get() +v253 := lang.Apply(v252, []any{v100, v236}) +return v253 +}) +v69 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4558), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(4589), lang.NewKeyword("end-column"), int(53)) +v70, err := lang.WithMeta(v68, v69.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v44 := v43.Get() -var v45 lang.FnFunc -v45 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("drop")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +var v67 any = v70 +_ = v67 +v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v73 := v72.FindInternedVar(lang.NewSymbol("map")) +if v73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) } -v48 := v47.Get() -v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v50 := v49.FindInternedVar(lang.NewSymbol("count")) -if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) +v74 := v73.Get() +v75 := lang.Apply(v74, []any{v67, v26}) +var v71 any = v75 +_ = v71 +v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v78 := v77.FindInternedVar(lang.NewSymbol("with-meta")) +if v78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) } -v51 := v50.Get() -v52 := lang.Apply(v51, []any{v22}) -v53 := lang.Apply(v48, []any{v52, v13}) -return v53 -}) -v46 := lang.Apply(lang1.NewLazySeq, []any{v45}) -v47 := lang.Apply(v44, []any{v3, v46}) -v48 := lang.Apply(v41, []any{v22, v47}) -v12 = v48 +v79 := v78.Get() +var v80 any +if lang.IsTruthy(v6) { +v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v82 := v81.FindInternedVar(lang.NewSymbol("list*")) +if v82.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) +} +v83 := v82.Get() +v84 := lang.Apply(v83, []any{lang.NewSymbol("fn*"), v6, v71}) +v80 = v84 } else { -v12 = nil +v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v86 := v85.FindInternedVar(lang.NewSymbol("cons")) +if v86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) } -return v12 -}) -v6 := lang.Apply(lang1.NewLazySeq, []any{v5}) -return v6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) +v87 := v86.Get() +v88 := lang.Apply(v87, []any{lang.NewSymbol("fn*"), v71}) +v80 = v88 +} +v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v90 := v89.FindInternedVar(lang.NewSymbol("meta")) +if v90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) +} +v91 := v90.Get() +v92 := lang.Apply(v91, []any{v3}) +v93 := lang.Apply(v79, []any{v80, v92}) +return v93 } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -36979,394 +34773,438 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// num +// fn? { -var v1 lang.FnFunc -{ // function num__inliner -v1 = lang.NewFnFunc(func(args ...any) any { +v0 := lang.NewSymbol("fn?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements Fn, i.e. is an object created via fn.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6259), lang.NewKeyword("end-line"), int(6259))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/num")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v3}) -v35 := lang.Apply(v26, []any{v30, v34}) -v36 := lang.Apply(v23, []any{v35}) -v37 := lang.Apply(v20, []any{v36}) -v38 := lang.Apply(v9, []any{v13, v17, v37}) -v39 := lang.Apply(v6, []any{v38}) -return v39 +v7 := lang.Apply(v6, []any{runtime9.*Fn, v3}) +return v7 }) -v2 := v1 -_ = v2 +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v0 := lang.NewSymbol("num").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to Number", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3474), lang.NewKeyword("end-line"), int(3474))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { +} +// fnext +{ +v0 := lang.NewSymbol("fnext").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Same as (first (next x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(112), lang.NewKeyword("end-line"), int(116))).(*lang.Symbol) +var v2 lang.FnFunc +{ // function fnext +v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "num") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("num is not a function"))) +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("first")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v6 := lang.Apply(v5, []any{v4}) -return v6 +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("next")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v4}) +v12 := lang.Apply(v7, []any{v11}) +return v12 }) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(116), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(116), lang.NewKeyword("end-column"), int(47))).(lang.FnFunc) +v3 := v2 +_ = v3 +} +v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// check-valid-options +// fnil { -v0 := lang.NewSymbol("check-valid-options").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("options"), lang.NewSymbol("&"), lang.NewSymbol("valid-keys"))), lang.NewKeyword("doc"), "Throws an exception if the given option map contains keys not listed\n as valid, else returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(35), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1709), lang.NewKeyword("end-line"), int(1709), lang.NewKeyword("private"), true)).(*lang.Symbol) +v0 := lang.NewSymbol("fnil").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("z"))), lang.NewKeyword("doc"), "Takes a function f, and returns a function that calls f, replacing\n a nil first argument to f with the supplied value x. Higher arity\n versions can replace arguments in the second and third\n positions (y, z). Note that the function f can take any number of\n arguments, not just the one(s) being nil-patched.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6601), lang.NewKeyword("end-line"), int(6601))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + case 2: v3 := args[0] -v4 := lang.NewList(args[1:]...) -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("seq")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +v4 := args[1] +var v5 lang.FnFunc +v5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v6 := args[0] +var v7 any +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("nil?")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v8 := v7.Get() +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v6}) +if lang.IsTruthy(v11) { +v7 = v4 +} else { +v7 = v6 +} +v12 := lang.Apply(v3, []any{v7}) +return v12 + case 2: +v6 := args[0] +v7 := args[1] +var v8 any v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("apply")) +v10 := v9.FindInternedVar(lang.NewSymbol("nil?")) if v10.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("disj")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("apply")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("hash-set")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v12 := lang.Apply(v11, []any{v6}) +if lang.IsTruthy(v12) { +v8 = v4 +} else { +v8 = v6 } -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("keys")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +v13 := lang.Apply(v3, []any{v8, v7}) +return v13 + case 3: +v6 := args[0] +v7 := args[1] +v8 := args[2] +var v9 any +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("nil?")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v3}) -v25 := lang.Apply(v17, []any{v20, v24}) -v26 := lang.Apply(v11, []any{v14, v25, v4}) -v27 := lang.Apply(v8, []any{v26}) -if lang.IsTruthy(v27) { -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("apply")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +v12 := v11.Get() +v13 := lang.Apply(v12, []any{v6}) +if lang.IsTruthy(v13) { +v9 = v4 +} else { +v9 = v6 } -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("str")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v14 := lang.Apply(v3, []any{v9, v7, v8}) +return v14 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v6 := args[0] +v7 := args[1] +v8 := args[2] +v9 := lang.NewList(args[3:]...) +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("apply")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("first")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +v12 := v11.Get() +var v13 any +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("nil?")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v36 := v35.Get() -v37 := lang.Apply(v36, []any{v4}) -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("map")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v6}) +if lang.IsTruthy(v17) { +v13 = v4 +} else { +v13 = v6 } -v40 := v39.Get() -var v41 lang.FnFunc -v41 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) +v18 := lang.Apply(v12, []any{v3, v13, v7, v8, v9}) +return v18 } -v42 := args[0] -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("str")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.Apply(v45, []any{", ", v42}) -return v46 }) -v42 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1718), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(1718), lang.NewKeyword("end-column"), int(28)) -v43, err := lang.WithMeta(v41, v42.(lang.IPersistentMap)) +v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6610), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(6614), lang.NewKeyword("end-column"), int(55)) +v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) if err != nil { panic(err) } -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("rest")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v4}) -v48 := lang.Apply(v40, []any{v43, v47}) -v49 := lang.Apply(v30, []any{v33, "Only these options are valid: ", v37, v48}) -v50 := lang.Apply(lang1.NewIllegalArgumentError, []any{v49}) -panic(v50) -} else { -v5 = nil -} -return v5 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// dec -{ -var v1 lang.FnFunc -{ // function dec__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } +return v7 + case 3: v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() +v4 := args[1] +v5 := args[2] +var v6 lang.FnFunc +v6 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v7 := args[0] +v8 := args[1] +var v9 any v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) +v11 := v10.FindInternedVar(lang.NewSymbol("nil?")) if v11.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v13 := lang.Apply(v12, []any{v7}) +if lang.IsTruthy(v13) { +v9 = v4 +} else { +v9 = v7 } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +var v14 any +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("nil?")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v8}) +if lang.IsTruthy(v18) { +v14 = v5 +} else { +v14 = v8 } -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +v19 := lang.Apply(v3, []any{v9, v14}) +return v19 + case 3: +v7 := args[0] +v8 := args[1] +v9 := args[2] +var v10 any +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("nil?")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v7}) +if lang.IsTruthy(v14) { +v10 = v4 +} else { +v10 = v7 } -v29 := v28.Get() -var v30 any -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +var v15 any +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("nil?")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -v33 := v32.Get() -if lang.IsTruthy(v33) { -v30 = lang.NewSymbol("unchecked_dec") +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v8}) +if lang.IsTruthy(v19) { +v15 = v5 } else { -v30 = lang.NewSymbol("dec") +v15 = v8 } -v34 := lang.Apply(v29, []any{v30}) -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("list")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +v20 := lang.Apply(v3, []any{v10, v15, v9}) +return v20 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v7 := args[0] +v8 := args[1] +v9 := args[2] +v10 := lang.NewList(args[3:]...) +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("apply")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v3}) -v39 := lang.Apply(v26, []any{v34, v38}) -v40 := lang.Apply(v23, []any{v39}) -v41 := lang.Apply(v20, []any{v40}) -v42 := lang.Apply(v9, []any{v13, v17, v41}) -v43 := lang.Apply(v6, []any{v42}) -return v43 -}) -v2 := v1 -_ = v2 +v13 := v12.Get() +var v14 any +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("nil?")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } -v0 := lang.NewSymbol("dec").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns a number one less than num. Does not auto-promote\n longs, will throw on overflow. See also: dec'", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1147), lang.NewKeyword("end-line"), int(1147))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "dec") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("dec is not a function"))) +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v7}) +if lang.IsTruthy(v18) { +v14 = v4 +} else { +v14 = v7 } -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +var v19 any +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("nil?")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } +v22 := v21.Get() +v23 := lang.Apply(v22, []any{v8}) +if lang.IsTruthy(v23) { +v19 = v5 +} else { +v19 = v8 } -// file-seq -{ -v0 := lang.NewSymbol("file-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("dir"))), lang.NewKeyword("doc"), "A tree seq on java.io.Files", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4972), lang.NewKeyword("end-line"), int(4972))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) +v24 := lang.Apply(v13, []any{v3, v14, v19, v9, v10}) +return v24 } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("tree-seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +}) +v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6616), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(6619), lang.NewKeyword("end-column"), int(71)) +v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v6 := v5.Get() +return v8 + case 4: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] var v7 lang.FnFunc v7 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + switch len(args) { + case 2: v8 := args[0] -v9, _ := lang.FieldOrMethod(v8, "isDirectory") -if reflect.TypeOf(v9).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("isDirectory is not a function"))) +v9 := args[1] +var v10 any +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("nil?")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v10 := lang.Apply(v9, []any{}) -return v10 -}) -v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4978), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(4978), lang.NewKeyword("end-column"), int(47)) -v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) -if err != nil { - panic(err) +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v8}) +if lang.IsTruthy(v14) { +v10 = v4 +} else { +v10 = v8 } -var v10 lang.FnFunc -v10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v11 := args[0] +var v15 any +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("nil?")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v9}) +if lang.IsTruthy(v19) { +v15 = v5 +} else { +v15 = v9 +} +v20 := lang.Apply(v3, []any{v10, v15}) +return v20 + case 3: +v8 := args[0] +v9 := args[1] +v10 := args[2] +var v11 any v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("seq")) +v13 := v12.FindInternedVar(lang.NewSymbol("nil?")) if v13.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } v14 := v13.Get() -v15, _ := lang.FieldOrMethod(v11, "listFiles") -if reflect.TypeOf(v15).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("listFiles is not a function"))) +v15 := lang.Apply(v14, []any{v8}) +if lang.IsTruthy(v15) { +v11 = v4 +} else { +v11 = v8 } -v16 := lang.Apply(v15, []any{}) -v17 := lang.Apply(v14, []any{v16}) -return v17 +var v16 any +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("nil?")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v9}) +if lang.IsTruthy(v20) { +v16 = v5 +} else { +v16 = v9 +} +var v21 any +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("nil?")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v10}) +if lang.IsTruthy(v25) { +v21 = v6 +} else { +v21 = v10 +} +v26 := lang.Apply(v3, []any{v11, v16, v21}) +return v26 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v8 := args[0] +v9 := args[1] +v10 := args[2] +v11 := lang.NewList(args[3:]...) +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("apply")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +var v15 any +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("nil?")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v8}) +if lang.IsTruthy(v19) { +v15 = v4 +} else { +v15 = v8 +} +var v20 any +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("nil?")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v9}) +if lang.IsTruthy(v24) { +v20 = v5 +} else { +v20 = v9 +} +var v25 any +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("nil?")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.Apply(v28, []any{v10}) +if lang.IsTruthy(v29) { +v25 = v6 +} else { +v25 = v10 +} +v30 := lang.Apply(v14, []any{v3, v15, v20, v25, v11}) +return v30 + } }) -v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4979), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(4979), lang.NewKeyword("end-column"), int(51)) -v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) +v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6621), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(6624), lang.NewKeyword("end-column"), int(87)) +v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) if err != nil { panic(err) } -v13 := lang.Apply(v6, []any{v9, v12, v3}) -return v13 +return v9 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -37374,3312 +35212,3222 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// aset-char +// for { -v0 := lang.NewSymbol("aset-char").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of char. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3981), lang.NewKeyword("end-line"), int(3983))).(*lang.Symbol) +v0 := lang.NewSymbol("for").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("seq-exprs"), lang.NewSymbol("body-expr"))), lang.NewKeyword("doc"), "List comprehension. Takes a vector of one or more\n binding-form/collection-expr pairs, each followed by zero or more\n modifiers, and yields a lazy sequence of evaluations of expr.\n Collections are iterated in a nested fashion, rightmost fastest,\n and nested coll-exprs can refer to bindings created in prior\n binding-forms. Supported modifiers are: :let [binding-form expr ...],\n :while test, :when test.\n\n (take 100 (for [x (range 100000000) y (range 1000000) :while (< y x)] [x y]))", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4646), lang.NewKeyword("end-line"), int(4646))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 3: + if len(args) != 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] v4 := args[1] v5 := args[2] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("char")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v5}) -v10, _ := lang.FieldOrMethod(nil, "setChar") -if reflect.TypeOf(v10).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setChar is not a function"))) +v6 := args[3] +var v7 any +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v11 := lang.Apply(v10, []any{v3, v4, v9}) -_ = v11 -return v5 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("apply")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("aset-char")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("aget")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v5}) +if lang.IsTruthy(v11) { +v7 = nil +} else { +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("str")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v3, v4}) -v17 := lang.Apply(v9, []any{v12, v16, v5, v6}) -return v17 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("first")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v3}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -// every? -{ -v1 := reflect.TypeOf(false) -v0 := lang.NewSymbol("every?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if (pred x) is logical true for every x in coll, else\n false.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2664), lang.NewKeyword("end-line"), int(2664))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -recur_loop_480: -var v6 any -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("nil?")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("meta")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("seq")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v3}) +v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) +v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) +v28 := lang.Apply(lang1.NewIllegalArgumentError, []any{v27}) +panic(v28) } -v12 := v11.Get() -v13 := lang.Apply(v12, []any{v5}) -v14 := lang.Apply(v9, []any{v13}) -if lang.IsTruthy(v14) { -v6 = true -} else { -var v15 any -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("first")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +_ = v7 +var v29 any +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("even?")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) } -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v5}) -v20 := lang.Apply(v4, []any{v19}) -if lang.IsTruthy(v20) { -var v21 any = v4 -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("next")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("count")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) } -v25 := v24.Get() -v26 := lang.Apply(v25, []any{v5}) -var v22 any = v26 -v4 = v21 -v5 = v22 -goto recur_loop_480 -} else { -var v27 any -if lang.IsTruthy(lang.NewKeyword("else")) { -v27 = false +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v5}) +v37 := lang.Apply(v32, []any{v36}) +if lang.IsTruthy(v37) { +v29 = nil } else { -v27 = nil +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("str")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) } -v15 = v27 +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("first")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } -v6 = v15 +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v3}) +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) } -return v6 -}) -v4 := reflect.TypeOf(false) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +v47 := v46.Get() +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("meta")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) } +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v3}) +v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) +v53 := lang.Apply(v40, []any{v44, " requires ", "an even number of forms in binding vector", " in ", v47, ":", v52}) +v54 := lang.Apply(lang1.NewIllegalArgumentError, []any{v53}) +panic(v54) } -// chunk-append -{ -v0 := lang.NewSymbol("chunk-append").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(688), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(688), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("b"), lang.NewSymbol("x"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { +_ = v29 +_ = nil +var v56 lang.FnFunc +v56 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := args[0] -v4 := args[1] -v5, _ := lang.FieldOrMethod(v3, "add") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} +v57 := args[0] +v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v59 := v58.FindInternedVar(lang.NewSymbol("reduce1")) +if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) } -// remove-ns -{ -v0 := lang.NewSymbol("remove-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Removes the namespace named by the symbol. Use with caution.\n Cannot be used to remove the glojure namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4139), lang.NewKeyword("end-line"), int(4139))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { +v60 := v59.Get() +var v61 lang.FnFunc +v61 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := args[0] -v4 := lang.Apply(lang1.RemoveNamespace, []any{v3}) -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v62 := args[0] +v63 := args[1] +var v64 any = v63 +_ = v64 +v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v67 := v66.FindInternedVar(lang.NewSymbol("nth")) +if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) } +v68 := v67.Get() +v69 := lang.Apply(v68, []any{v64, int64(0), nil}) +var v65 any = v69 +_ = v65 +v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v72 := v71.FindInternedVar(lang.NewSymbol("nth")) +if v72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) } -// boolean -{ -var v1 lang.FnFunc -{ // function boolean__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v73 := v72.Get() +v74 := lang.Apply(v73, []any{v64, int64(1), nil}) +var v70 any = v74 +_ = v70 +var v76 any +v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v78 := v77.FindInternedVar(lang.NewSymbol("keyword?")) +if v78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) } -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v79 := v78.Get() +v80 := lang.Apply(v79, []any{v65}) +if lang.IsTruthy(v80) { +v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v82 := v81.FindInternedVar(lang.NewSymbol("conj")) +if v82.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) } -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v83 := v82.Get() +v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v85 := v84.FindInternedVar(lang.NewSymbol("pop")) +if v85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) } -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v86 := v85.Get() +v87 := lang.Apply(v86, []any{v62}) +v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v89 := v88.FindInternedVar(lang.NewSymbol("conj")) +if v89.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v90 := v89.Get() +v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v92 := v91.FindInternedVar(lang.NewSymbol("peek")) +if v92.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) } -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +v93 := v92.Get() +v94 := lang.Apply(v93, []any{v62}) +v95 := lang.NewVector(v65, v70) +v96 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4664), lang.NewKeyword("column"), int(72), lang.NewKeyword("end-line"), int(4664), lang.NewKeyword("end-column"), int(76)) +v97, err := lang.WithMeta(v95, v96.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +v98 := lang.Apply(v90, []any{v94, v97}) +v99 := lang.Apply(v83, []any{v87, v98}) +v76 = v99 +} else { +v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v101 := v100.FindInternedVar(lang.NewSymbol("conj")) +if v101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) } -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v102 := v101.Get() +v103 := lang.NewVector(v65, v70) +v104 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4665), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(4665), lang.NewKeyword("end-column"), int(50)) +v105, err := lang.WithMeta(v103, v104.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/BooleanCast")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v106 := lang.Apply(v102, []any{v62, v105}) +v76 = v106 } -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v3}) -v35 := lang.Apply(v26, []any{v30, v34}) -v36 := lang.Apply(v23, []any{v35}) -v37 := lang.Apply(v20, []any{v36}) -v38 := lang.Apply(v9, []any{v13, v17, v37}) -v39 := lang.Apply(v6, []any{v38}) -return v39 +return v76 }) -v2 := v1 -_ = v2 +v62 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4662), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(4665), lang.NewKeyword("end-column"), int(53)) +v63, err := lang.WithMeta(v61, v62.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v0 := lang.NewSymbol("boolean").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to boolean", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1601), lang.NewKeyword("end-line"), int(1601))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5, _ := lang.FieldOrMethod(runtime3.RT, "BooleanCast") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("BooleanCast is not a function"))) +v64 := lang.NewVector() +v65 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4666), lang.NewKeyword("column"), int(29), lang.NewKeyword("end-line"), int(4666), lang.NewKeyword("end-column"), int(30)) +v66, err := lang.WithMeta(v64, v65.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v6 := lang.Apply(v5, []any{v4}) -return v6 +v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v68 := v67.FindInternedVar(lang.NewSymbol("partition")) +if v68.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) +} +v69 := v68.Get() +v70 := lang.Apply(v69, []any{int64(2), v57}) +v71 := lang.Apply(v60, []any{v63, v66, v70}) +return v71 }) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +v57 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4661), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(4666), lang.NewKeyword("end-column"), int(56)) +v58, err := lang.WithMeta(v56, v57.(lang.IPersistentMap)) +if err != nil { + panic(err) } +var v55 any = v58 +_ = v55 +var v60 lang.FnFunc +v60 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v61 := lang.NewList(args[0:]...) +v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v63 := v62.FindInternedVar(lang.NewSymbol("apply")) +if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) } -// filter-key -{ -v0 := lang.NewSymbol("filter-key").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("keyfn"), lang.NewSymbol("pred"), lang.NewSymbol("amap"))), lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4115), lang.NewKeyword("end-line"), int(4117), lang.NewKeyword("private"), true)).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) +v64 := v63.Get() +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("str")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +} +v67 := v66.Get() +v68 := lang.Apply(v64, []any{v67, v61}) +v69 := lang.Apply(lang1.NewIllegalArgumentError, []any{v68}) +panic(v69) } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v7 := lang.NewMap() -v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4118), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(4118), lang.NewKeyword("end-column"), int(17)) -v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) +}) +v61 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4667), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(4667), lang.NewKeyword("end-column"), int(125)) +v62, err := lang.WithMeta(v60, v61.(lang.IPersistentMap)) if err != nil { panic(err) } -var v6 any = v9 -_ = v6 -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("seq")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v5}) -var v10 any = v14 -_ = v10 -var v15 any -for { -var v16 any -if lang.IsTruthy(v10) { -var v17 any -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("first")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +var v59 any = v62 +_ = v59 +var v64 lang.FnFunc +{ // function emit-bind +v64 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v66 := args[0] +var v67 any = v66 +_ = v67 +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("seq")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) } -v20 := v19.Get() -v21 := lang.Apply(v20, []any{v10}) -v22 := lang.Apply(v3, []any{v21}) -v23 := lang.Apply(v4, []any{v22}) -if lang.IsTruthy(v23) { -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("assoc")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +v71 := v70.Get() +v72 := lang.Apply(v71, []any{v67}) +var v68 any = v72 +_ = v68 +v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v75 := v74.FindInternedVar(lang.NewSymbol("first")) +if v75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) } -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("key")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +v76 := v75.Get() +v77 := lang.Apply(v76, []any{v68}) +var v73 any = v77 +_ = v73 +v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v80 := v79.FindInternedVar(lang.NewSymbol("next")) +if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) } -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("first")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v81 := v80.Get() +v82 := lang.Apply(v81, []any{v78}) +var v78 any = v82 +_ = v78 +var v83 any = v73 +_ = v83 +v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v86 := v85.FindInternedVar(lang.NewSymbol("seq")) +if v86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) } -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v10}) -v35 := lang.Apply(v30, []any{v34}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("val")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +v87 := v86.Get() +v88 := lang.Apply(v87, []any{v83}) +var v84 any = v88 +_ = v84 +v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v91 := v90.FindInternedVar(lang.NewSymbol("first")) +if v91.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) } -v38 := v37.Get() -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("first")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +v92 := v91.Get() +v93 := lang.Apply(v92, []any{v84}) +var v89 any = v93 +_ = v89 +v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v96 := v95.FindInternedVar(lang.NewSymbol("next")) +if v96.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) } -v41 := v40.Get() -v42 := lang.Apply(v41, []any{v10}) -v43 := lang.Apply(v38, []any{v42}) -v44 := lang.Apply(v27, []any{v6, v35, v43}) -var v24 any = v44 -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("next")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +v97 := v96.Get() +v98 := lang.Apply(v97, []any{v94}) +var v94 any = v98 +_ = v94 +var v99 any = v89 +_ = v99 +v101 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v102 := v101.FindInternedVar(lang.NewSymbol("first")) +if v102.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v102))) } -v48 := v47.Get() -v49 := lang.Apply(v48, []any{v10}) -var v45 any = v49 -v6 = v24 -v10 = v45 -continue -} else { -var v50 any = v6 -v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("next")) -if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) +v103 := v102.Get() +v104 := lang.Apply(v103, []any{v94}) +var v100 any = v104 +_ = v100 +v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v107 := v106.FindInternedVar(lang.NewSymbol("next")) +if v107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) } -v54 := v53.Get() -v55 := lang.Apply(v54, []any{v10}) -var v51 any = v55 -v6 = v50 -v10 = v51 -continue +v108 := v107.Get() +v109 := lang.Apply(v108, []any{v105}) +var v105 any = v109 +_ = v105 +var v110 any = v100 +_ = v110 +var v111 any = v105 +_ = v111 +var v112 any = v78 +_ = v112 +v114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v115 := v114.FindInternedVar(lang.NewSymbol("nth")) +if v115.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v115))) } -v16 = v17 -} else { -v16 = v6 +v116 := v115.Get() +v117 := lang.Apply(v116, []any{v112, int64(0), nil}) +var v113 any = v117 +_ = v113 +v119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v120 := v119.FindInternedVar(lang.NewSymbol("nth")) +if v120.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v120))) } -v15 = v16 - break +v121 := v120.Get() +v122 := lang.Apply(v121, []any{v113, int64(0), nil}) +var v118 any = v122 +_ = v118 +v124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v125 := v124.FindInternedVar(lang.NewSymbol("nth")) +if v125.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v125))) } -return v15 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v126 := v125.Get() +v127 := lang.Apply(v126, []any{v113, int64(1), nil}) +var v123 any = v127 +_ = v123 +var v128 any = v112 +_ = v128 +v131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v132 := v131.FindInternedVar(lang.NewSymbol("gensym")) +if v132.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v132))) } +v133 := v132.Get() +v134 := lang.Apply(v133, []any{"iter__"}) +var v130 any = v134 +_ = v130 +v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v137 := v136.FindInternedVar(lang.NewSymbol("gensym")) +if v137.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) } -// deref -{ -v0 := lang.NewSymbol("deref").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref")), lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("timeout-ms"), lang.NewSymbol("timeout-val"))), lang.NewKeyword("doc"), "Also reader macro: @ref/@agent/@var/@atom/@delay/@future/@promise. Within a transaction,\n returns the in-transaction-value of ref, else returns the\n most-recently-committed value of ref. When applied to a var, agent\n or atom, returns its current state. When applied to a delay, forces\n it if not already forced. When applied to a future, will block if\n computation not complete. When applied to a promise, will block\n until a value is delivered. The variant taking a timeout can be\n used for blocking references (futures and promises), and will return\n timeout-val if the timeout (in milliseconds) is reached before a\n value is available. See also - realized?.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2304), lang.NewKeyword("end-line"), int(2304))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v138 := v137.Get() +v139 := lang.Apply(v138, []any{"s__"}) +var v135 any = v139 +_ = v135 +var v141 lang.FnFunc +{ // function do-mod +v141 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v143 := args[0] +var v144 any = v143 +_ = v144 +v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v147 := v146.FindInternedVar(lang.NewSymbol("seq")) +if v147.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) } -v7 := v6.Get() -v8 := lang.Apply(v7, []any{lang1.IDeref, v3}) -if lang.IsTruthy(v8) { -v9, ok := lang.FieldOrMethod(v3, "Deref") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "Deref"))) +v148 := v147.Get() +v149 := lang.Apply(v148, []any{v144}) +var v145 any = v149 +_ = v145 +v151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v152 := v151.FindInternedVar(lang.NewSymbol("first")) +if v152.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v152))) } -var v10 any -switch reflect.TypeOf(v9).Kind() { -case reflect.Func: - v10 = lang.Apply(v9, nil) -default: - v10 = v9 +v153 := v152.Get() +v154 := lang.Apply(v153, []any{v145}) +var v150 any = v154 +_ = v150 +v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v157 := v156.FindInternedVar(lang.NewSymbol("next")) +if v157.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) } -v4 = v10 -} else { -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("deref-future")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v158 := v157.Get() +v159 := lang.Apply(v158, []any{v155}) +var v155 any = v159 +_ = v155 +var v160 any = v150 +_ = v160 +v162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v163 := v162.FindInternedVar(lang.NewSymbol("nth")) +if v163.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v163))) } -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v3}) -v4 = v14 +v164 := v163.Get() +v165 := lang.Apply(v164, []any{v160, int64(0), nil}) +var v161 any = v165 +_ = v161 +v167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v168 := v167.FindInternedVar(lang.NewSymbol("nth")) +if v168.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v168))) } -return v4 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -var v6 any -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("instance?")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v169 := v168.Get() +v170 := lang.Apply(v169, []any{v160, int64(1), nil}) +var v166 any = v170 +_ = v166 +var v171 any = v160 +_ = v171 +var v172 any = v155 +_ = v172 +var v174 any +v175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v176 := v175.FindInternedVar(lang.NewSymbol("=")) +if v176.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v176))) } -v9 := v8.Get() -v10 := lang.Apply(v9, []any{lang1.IBlockingDeref, v3}) -if lang.IsTruthy(v10) { -v11, _ := lang.FieldOrMethod(v3, "DerefWithTimeout") -if reflect.TypeOf(v11).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("DerefWithTimeout is not a function"))) +v177 := v176.Get() +v178 := lang.Apply(v177, []any{v161, lang.NewKeyword("let")}) +if lang.IsTruthy(v178) { +v179 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v180 := v179.FindInternedVar(lang.NewSymbol("seq")) +if v180.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v180))) } -v12 := lang.Apply(v11, []any{v4, v5}) -v6 = v12 -} else { -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("deref-future")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +v181 := v180.Get() +v182 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v183 := v182.FindInternedVar(lang.NewSymbol("concat")) +if v183.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v183))) } -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v3, v4, v5}) -v6 = v16 +v184 := v183.Get() +v185 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v186 := v185.FindInternedVar(lang.NewSymbol("list")) +if v186.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v186))) } -return v6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v187 := v186.Get() +v188 := lang.Apply(v187, []any{lang.NewSymbol("glojure.core/let")}) +v189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v190 := v189.FindInternedVar(lang.NewSymbol("list")) +if v190.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v190))) } +v191 := v190.Get() +v192 := lang.Apply(v191, []any{v166}) +v193 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v194 := v193.FindInternedVar(lang.NewSymbol("list")) +if v194.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v194))) } -// reversible? -{ -v0 := lang.NewSymbol("reversible?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements Reversible", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6300), lang.NewKeyword("end-line"), int(6300))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v195 := v194.Get() +v196 := lang.Apply(v142, []any{v172}) +v197 := lang.Apply(v195, []any{v196}) +v198 := lang.Apply(v184, []any{v188, v192, v197}) +v199 := lang.Apply(v181, []any{v198}) +v174 = v199 +} else { +var v200 any +v201 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v202 := v201.FindInternedVar(lang.NewSymbol("=")) +if v202.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v202))) } -v6 := v5.Get() -v7 := lang.Apply(v6, []any{glojure.lang11.Reversible, v3}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v203 := v202.Get() +v204 := lang.Apply(v203, []any{v161, lang.NewKeyword("while")}) +if lang.IsTruthy(v204) { +v205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v206 := v205.FindInternedVar(lang.NewSymbol("seq")) +if v206.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v206))) } +v207 := v206.Get() +v208 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v209 := v208.FindInternedVar(lang.NewSymbol("concat")) +if v209.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v209))) } -// partitionv -{ -v0 := lang.NewSymbol("partitionv").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("pad"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of vectors of n items each, at offsets step\n apart. If step is not supplied, defaults to n, i.e. the partitions\n do not overlap. If a pad collection is supplied, use its elements as\n necessary to complete last partition upto n items. In case there are\n not enough padding elements, return a partition with less than n items.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7305), lang.NewKeyword("end-line"), int(7305))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("partitionv")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v210 := v209.Get() +v211 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v212 := v211.FindInternedVar(lang.NewSymbol("list")) +if v212.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v212))) } -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3, v3, v4}) -return v8 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -var v6 lang.FnFunc -v6 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("seq")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v213 := v212.Get() +v214 := lang.Apply(v213, []any{lang.NewSymbol("glojure.core/when")}) +v215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v216 := v215.FindInternedVar(lang.NewSymbol("list")) +if v216.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v216))) } -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v5}) -var v7 any = v11 -_ = v7 -var v13 any -if lang.IsTruthy(v7) { -var v14 any = v7 -_ = v14 -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("into")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +v217 := v216.Get() +v218 := lang.Apply(v217, []any{v166}) +v219 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v220 := v219.FindInternedVar(lang.NewSymbol("list")) +if v220.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v220))) } -v19 := v18.Get() -v20 := lang.NewVector() -v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7317), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(7317), lang.NewKeyword("end-column"), int(23)) -v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) -if err != nil { - panic(err) +v221 := v220.Get() +v222 := lang.Apply(v142, []any{v172}) +v223 := lang.Apply(v221, []any{v222}) +v224 := lang.Apply(v210, []any{v214, v218, v223}) +v225 := lang.Apply(v207, []any{v224}) +v200 = v225 +} else { +var v226 any +v227 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v228 := v227.FindInternedVar(lang.NewSymbol("=")) +if v228.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v228))) } -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("take")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +v229 := v228.Get() +v230 := lang.Apply(v229, []any{v161, lang.NewKeyword("when")}) +if lang.IsTruthy(v230) { +v231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v232 := v231.FindInternedVar(lang.NewSymbol("seq")) +if v232.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v232))) } -v25 := v24.Get() -v26 := lang.Apply(v25, []any{v3}) -v27 := lang.Apply(v19, []any{v22, v26, v14}) -var v16 any = v27 -_ = v16 -var v29 any -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("=")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +v233 := v232.Get() +v234 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v235 := v234.FindInternedVar(lang.NewSymbol("concat")) +if v235.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v235))) } -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("count")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +v236 := v235.Get() +v237 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v238 := v237.FindInternedVar(lang.NewSymbol("list")) +if v238.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v238))) } -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v16}) -v37 := lang.Apply(v32, []any{v3, v36}) -if lang.IsTruthy(v37) { -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("cons")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +v239 := v238.Get() +v240 := lang.Apply(v239, []any{lang.NewSymbol("if")}) +v241 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v242 := v241.FindInternedVar(lang.NewSymbol("list")) +if v242.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v242))) } -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("partitionv")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +v243 := v242.Get() +v244 := lang.Apply(v243, []any{v166}) +v245 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v246 := v245.FindInternedVar(lang.NewSymbol("list")) +if v246.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v246))) } -v43 := v42.Get() -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("nthrest")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +v247 := v246.Get() +v248 := lang.Apply(v142, []any{v172}) +v249 := lang.Apply(v247, []any{v248}) +v250 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v251 := v250.FindInternedVar(lang.NewSymbol("list")) +if v251.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v251))) } -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v14, v4}) -v48 := lang.Apply(v43, []any{v3, v4, v47}) -v49 := lang.Apply(v40, []any{v16, v48}) -v29 = v49 -} else { -v29 = nil +v252 := v251.Get() +v253 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v254 := v253.FindInternedVar(lang.NewSymbol("seq")) +if v254.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v254))) } -v13 = v29 -} else { -v13 = nil +v255 := v254.Get() +v256 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v257 := v256.FindInternedVar(lang.NewSymbol("concat")) +if v257.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v257))) } -return v13 -}) -v7 := lang.Apply(lang1.NewLazySeq, []any{v6}) -return v7 - case 4: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -var v7 lang.FnFunc -v7 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("seq")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v6}) -var v8 any = v12 -_ = v8 -var v14 any -if lang.IsTruthy(v8) { -var v15 any = v8 -_ = v15 -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("into")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.NewVector() -v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7323), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(7323), lang.NewKeyword("end-column"), int(23)) -v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("take")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +v258 := v257.Get() +v259 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v260 := v259.FindInternedVar(lang.NewSymbol("list")) +if v260.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v260))) } -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v3}) -v28 := lang.Apply(v20, []any{v23, v27, v15}) -var v17 any = v28 -_ = v17 -var v30 any -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("=")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v261 := v260.Get() +v262 := lang.Apply(v261, []any{lang.NewSymbol("recur")}) +v263 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v264 := v263.FindInternedVar(lang.NewSymbol("list")) +if v264.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v264))) } -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("count")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +v265 := v264.Get() +v266 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v267 := v266.FindInternedVar(lang.NewSymbol("seq")) +if v267.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v267))) } -v36 := v35.Get() -v37 := lang.Apply(v36, []any{v17}) -v38 := lang.Apply(v33, []any{v3, v37}) -if lang.IsTruthy(v38) { -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("cons")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +v268 := v267.Get() +v269 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v270 := v269.FindInternedVar(lang.NewSymbol("concat")) +if v270.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v270))) } -v41 := v40.Get() -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("partitionv")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +v271 := v270.Get() +v272 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v273 := v272.FindInternedVar(lang.NewSymbol("list")) +if v273.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v273))) } -v44 := v43.Get() -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("nthrest")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +v274 := v273.Get() +v275 := lang.Apply(v274, []any{lang.NewSymbol("glojure.core/rest")}) +v276 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v277 := v276.FindInternedVar(lang.NewSymbol("list")) +if v277.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v277))) } -v47 := v46.Get() -v48 := lang.Apply(v47, []any{v15, v4}) -v49 := lang.Apply(v44, []any{v3, v4, v5, v48}) -v50 := lang.Apply(v41, []any{v17, v49}) -v30 = v50 +v278 := v277.Get() +v279 := lang.Apply(v278, []any{v135}) +v280 := lang.Apply(v271, []any{v275, v279}) +v281 := lang.Apply(v268, []any{v280}) +v282 := lang.Apply(v265, []any{v281}) +v283 := lang.Apply(v258, []any{v262, v282}) +v284 := lang.Apply(v255, []any{v283}) +v285 := lang.Apply(v252, []any{v284}) +v286 := lang.Apply(v236, []any{v240, v244, v249, v285}) +v287 := lang.Apply(v233, []any{v286}) +v226 = v287 } else { -v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v52 := v51.FindInternedVar(lang.NewSymbol("list")) -if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) +var v288 any +v289 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v290 := v289.FindInternedVar(lang.NewSymbol("keyword?")) +if v290.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v290))) } -v53 := v52.Get() -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("into")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +v291 := v290.Get() +v292 := lang.Apply(v291, []any{v161}) +if lang.IsTruthy(v292) { +v293 := lang.Apply(v59, []any{"Invalid 'for' keyword ", v161}) +v288 = v293 +} else { +var v294 any +if lang.IsTruthy(v128) { +v295 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v296 := v295.FindInternedVar(lang.NewSymbol("seq")) +if v296.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v296))) } -v56 := v55.Get() -v57 := lang.NewVector() -v58 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7326), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(7326), lang.NewKeyword("end-column"), int(25)) -v59, err := lang.WithMeta(v57, v58.(lang.IPersistentMap)) -if err != nil { - panic(err) +v297 := v296.Get() +v298 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v299 := v298.FindInternedVar(lang.NewSymbol("concat")) +if v299.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v299))) } -v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v61 := v60.FindInternedVar(lang.NewSymbol("take")) -if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) +v300 := v299.Get() +v301 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v302 := v301.FindInternedVar(lang.NewSymbol("list")) +if v302.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v302))) } -v62 := v61.Get() -v63 := lang.Apply(v62, []any{v3}) -v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v65 := v64.FindInternedVar(lang.NewSymbol("concat")) -if v65.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) +v303 := v302.Get() +v304 := lang.Apply(v303, []any{lang.NewSymbol("glojure.core/let")}) +v305 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v306 := v305.FindInternedVar(lang.NewSymbol("list")) +if v306.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v306))) } -v66 := v65.Get() -v67 := lang.Apply(v66, []any{v17, v5}) -v68 := lang.Apply(v56, []any{v59, v63, v67}) -v69 := lang.Apply(v53, []any{v68}) -v30 = v69 +v307 := v306.Get() +v308 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v309 := v308.FindInternedVar(lang.NewSymbol("apply")) +if v309.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v309))) } -v14 = v30 -} else { -v14 = nil +v310 := v309.Get() +v311 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v312 := v311.FindInternedVar(lang.NewSymbol("vector")) +if v312.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v312))) } -return v14 -}) -v8 := lang.Apply(lang1.NewLazySeq, []any{v7}) -return v8 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v313 := v312.Get() +v314 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v315 := v314.FindInternedVar(lang.NewSymbol("seq")) +if v315.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v315))) } +v316 := v315.Get() +v317 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v318 := v317.FindInternedVar(lang.NewSymbol("concat")) +if v318.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v318))) } -// alter -{ -v0 := lang.NewSymbol("alter").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("fun"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Must be called in a transaction. Sets the in-transaction-value of\n ref to:\n\n (apply fun in-transaction-value-of-ref args)\n\n and returns the in-transaction-value of ref.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2435), lang.NewKeyword("end-line"), int(2435))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -v6, _ := lang.FieldOrMethod(v3, "alter") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("alter is not a function"))) +v319 := v318.Get() +v320 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v321 := v320.FindInternedVar(lang.NewSymbol("list")) +if v321.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v321))) } -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v322 := v321.Get() +v323 := lang.Apply(v322, []any{lang.NewSymbol("iterys__0__auto__")}) +v324 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v325 := v324.FindInternedVar(lang.NewSymbol("list")) +if v325.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v325))) } +v326 := v325.Get() +v327 := lang.Apply(v65, []any{v128}) +v328 := lang.Apply(v326, []any{v327}) +v329 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v330 := v329.FindInternedVar(lang.NewSymbol("list")) +if v330.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v330))) } -// require -{ -v0 := lang.NewSymbol("require").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Loads libs, skipping any that are already loaded. Each argument is\n either a libspec that identifies a lib, a prefix list that identifies\n multiple libs whose names share a common prefix, or a flag that modifies\n how all the identified libs are loaded. Use :require in the ns macro\n in preference to calling this directly.\n\n Libs\n\n A 'lib' is a named set of resources in classpath whose contents define a\n library of Clojure code. Lib names are symbols and each lib is associated\n with a Clojure namespace and a Java package that share its name. A lib's\n name also locates its root directory within classpath using Java's\n package name to classpath-relative path mapping. All resources in a lib\n should be contained in the directory structure under its root directory.\n All definitions a lib makes should be in its associated namespace.\n\n 'require loads a lib by loading its root resource. The root resource path\n is derived from the lib name in the following manner:\n Consider a lib named by the symbol 'x.y.z; it has the root directory\n /x/y/, and its root resource is /x/y/z.clj, or\n /x/y/z.cljc if /x/y/z.clj does not exist. The\n root resource should contain code to create the lib's\n namespace (usually by using the ns macro) and load any additional\n lib resources.\n\n Libspecs\n\n A libspec is a lib name or a vector containing a lib name followed by\n options expressed as sequential keywords and arguments.\n\n Recognized options:\n :as takes a symbol as its argument and makes that symbol an alias to the\n lib's namespace in the current namespace.\n :as-alias takes a symbol as its argument and aliases like :as, however\n the lib will not be loaded. If the lib has not been loaded, a new\n empty namespace will be created (as with create-ns).\n :refer takes a list of symbols to refer from the namespace or the :all\n keyword to bring in all public vars.\n\n Prefix Lists\n\n It's common for Clojure code to depend on several libs whose names have\n the same prefix. When specifying libs, prefix lists can be used to reduce\n repetition. A prefix list contains the shared prefix followed by libspecs\n with the shared prefix removed from the lib names. After removing the\n prefix, the names that remain must not contain any periods.\n\n Flags\n\n A flag is a keyword.\n Recognized flags: :reload, :reload-all, :verbose\n :reload forces loading of all the identified libs even if they are\n already loaded (has no effect on libspecs using :as-alias)\n :reload-all implies :reload and also forces loading of all libs that the\n identified libs directly or indirectly load via require or use\n (has no effect on libspecs using :as-alias)\n :verbose triggers printing information about each load, alias, and refer\n\n Example:\n\n The following would load the libraries glojure.zip and glojure.set\n abbreviated as 's'.\n\n (require '(glojure zip [set :as s]))", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6032), lang.NewKeyword("end-line"), int(6032))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewList(args[0:]...) -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("apply")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v331 := v330.Get() +v332 := lang.Apply(v331, []any{lang.NewSymbol("fs__1__auto__")}) +v333 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v334 := v333.FindInternedVar(lang.NewSymbol("list")) +if v334.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v334))) } -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("load-libs")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v335 := v334.Get() +v336 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v337 := v336.FindInternedVar(lang.NewSymbol("seq")) +if v337.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v337))) } -v9 := v8.Get() -v10 := lang.Apply(v6, []any{v9, lang.NewKeyword("require"), v3}) -return v10 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v338 := v337.Get() +v339 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v340 := v339.FindInternedVar(lang.NewSymbol("concat")) +if v340.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v340))) } +v341 := v340.Get() +v342 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v343 := v342.FindInternedVar(lang.NewSymbol("list")) +if v343.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v343))) } -// case-map -{ -v0 := lang.NewSymbol("case-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("case-f"), lang.NewSymbol("test-f"), lang.NewSymbol("tests"), lang.NewSymbol("thens"))), lang.NewKeyword("doc"), "Transforms a sequence of test constants and a corresponding sequence of then\n expressions into a sorted map to be consumed by case*. The form of the map\n entries are {(case-f test) [(test-f test) then]}.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6657), lang.NewKeyword("end-line"), int(6657), lang.NewKeyword("private"), true)).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("into1")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v344 := v343.Get() +v345 := lang.Apply(v344, []any{lang.NewSymbol("glojure.core/seq")}) +v346 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v347 := v346.FindInternedVar(lang.NewSymbol("list")) +if v347.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v347))) } -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("sorted-map")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v348 := v347.Get() +v349 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v350 := v349.FindInternedVar(lang.NewSymbol("seq")) +if v350.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v350))) } -v12 := v11.Get() -v13 := lang.Apply(v12, nil) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("zipmap")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v351 := v350.Get() +v352 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v353 := v352.FindInternedVar(lang.NewSymbol("concat")) +if v353.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v353))) } -v16 := v15.Get() -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("map")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +v354 := v353.Get() +v355 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v356 := v355.FindInternedVar(lang.NewSymbol("list")) +if v356.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v356))) } -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v3, v5}) -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("map")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +v357 := v356.Get() +v358 := lang.Apply(v357, []any{lang.NewSymbol("iterys__0__auto__")}) +v359 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v360 := v359.FindInternedVar(lang.NewSymbol("list")) +if v360.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v360))) } -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("vector")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +v361 := v360.Get() +v362 := lang.Apply(v361, []any{v123}) +v363 := lang.Apply(v354, []any{v358, v362}) +v364 := lang.Apply(v351, []any{v363}) +v365 := lang.Apply(v348, []any{v364}) +v366 := lang.Apply(v341, []any{v345, v365}) +v367 := lang.Apply(v338, []any{v366}) +v368 := lang.Apply(v335, []any{v367}) +v369 := lang.Apply(v319, []any{v323, v328, v332, v368}) +v370 := lang.Apply(v316, []any{v369}) +v371 := lang.Apply(v310, []any{v313, v370}) +v372 := lang.Apply(v307, []any{v371}) +v373 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v374 := v373.FindInternedVar(lang.NewSymbol("list")) +if v374.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v374))) } -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("map")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v375 := v374.Get() +v376 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v377 := v376.FindInternedVar(lang.NewSymbol("seq")) +if v377.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v377))) } -v29 := v28.Get() -v30 := lang.Apply(v29, []any{v4, v5}) -v31 := lang.Apply(v23, []any{v26, v30, v6}) -v32 := lang.Apply(v16, []any{v20, v31}) -v33 := lang.Apply(v9, []any{v13, v32}) -return v33 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v378 := v377.Get() +v379 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v380 := v379.FindInternedVar(lang.NewSymbol("concat")) +if v380.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v380))) } +v381 := v380.Get() +v382 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v383 := v382.FindInternedVar(lang.NewSymbol("list")) +if v383.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v383))) } -// hash-map -{ -v0 := lang.NewSymbol("hash-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keyvals"))), lang.NewKeyword("doc"), "keyval => key val\n Returns a new hash map with supplied mappings. If any keys are\n equal, they are handled as if by repeated uses of assoc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(378), lang.NewKeyword("end-line"), int(378))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v3 := lang.NewMap() -v4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(384), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(384), lang.NewKeyword("end-column"), int(8)) -v5, err := lang.WithMeta(v3, v4.(lang.IPersistentMap)) -if err != nil { - panic(err) +v384 := v383.Get() +v385 := lang.Apply(v384, []any{lang.NewSymbol("if")}) +v386 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v387 := v386.FindInternedVar(lang.NewSymbol("list")) +if v387.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v387))) } -return v5 - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewList(args[0:]...) -v4 := lang.Apply(lang1.CreatePersistentHashMap, []any{v3}) -return v4 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v388 := v387.Get() +v389 := lang.Apply(v388, []any{lang.NewSymbol("fs__1__auto__")}) +v390 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v391 := v390.FindInternedVar(lang.NewSymbol("list")) +if v391.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v391))) } +v392 := v391.Get() +v393 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v394 := v393.FindInternedVar(lang.NewSymbol("seq")) +if v394.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v394))) } -// zipmap -{ -v0 := lang.NewSymbol("zipmap").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("keys"), lang.NewSymbol("vals"))), lang.NewKeyword("doc"), "Returns a map with the keys mapped to the corresponding vals.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6626), lang.NewKeyword("end-line"), int(6626))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("transient")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +v395 := v394.Get() +v396 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v397 := v396.FindInternedVar(lang.NewSymbol("concat")) +if v397.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v397))) } -v8 := v7.Get() -v9 := lang.NewMap() -v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6631), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(6631), lang.NewKeyword("end-column"), int(28)) -v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) -if err != nil { - panic(err) +v398 := v397.Get() +v399 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v400 := v399.FindInternedVar(lang.NewSymbol("list")) +if v400.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v400))) } -v12 := lang.Apply(v8, []any{v11}) -var v5 any = v12 -_ = v5 -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("seq")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v401 := v400.Get() +v402 := lang.Apply(v401, []any{lang.NewSymbol("glojure.core/concat")}) +v403 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v404 := v403.FindInternedVar(lang.NewSymbol("list")) +if v404.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v404))) } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v3}) -var v13 any = v17 -_ = v13 -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("seq")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v405 := v404.Get() +v406 := lang.Apply(v405, []any{lang.NewSymbol("fs__1__auto__")}) +v407 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v408 := v407.FindInternedVar(lang.NewSymbol("list")) +if v408.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v408))) } -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v4}) -var v18 any = v22 -_ = v18 -var v23 any -for { -var v24 any -var v25 any = v13 -_ = v25 -var v27 any -if lang.IsTruthy(v25) { -v27 = v18 -} else { -v27 = v25 +v409 := v408.Get() +v410 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v411 := v410.FindInternedVar(lang.NewSymbol("seq")) +if v411.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v411))) } -if lang.IsTruthy(v27) { -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("assoc!")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +v412 := v411.Get() +v413 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v414 := v413.FindInternedVar(lang.NewSymbol("concat")) +if v414.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v414))) } -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("first")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +v415 := v414.Get() +v416 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v417 := v416.FindInternedVar(lang.NewSymbol("list")) +if v417.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v417))) } -v31 := v30.Get() -v32 := lang.Apply(v31, []any{v13}) -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("first")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +v418 := v417.Get() +v419 := lang.Apply(v418, []any{v130}) +v420 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v421 := v420.FindInternedVar(lang.NewSymbol("list")) +if v421.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v421))) } -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v18}) -v37 := lang.Apply(v28, []any{v5, v32, v36}) -var v25 any = v37 -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("next")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +v422 := v421.Get() +v423 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v424 := v423.FindInternedVar(lang.NewSymbol("seq")) +if v424.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v424))) } -v41 := v40.Get() -v42 := lang.Apply(v41, []any{v13}) -var v38 any = v42 -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("next")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +v425 := v424.Get() +v426 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v427 := v426.FindInternedVar(lang.NewSymbol("concat")) +if v427.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v427))) } -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v18}) -var v43 any = v47 -v5 = v25 -v13 = v38 -v18 = v43 -continue -} else { -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("persistent!")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +v428 := v427.Get() +v429 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v430 := v429.FindInternedVar(lang.NewSymbol("list")) +if v430.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v430))) } -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v5}) -v24 = v51 +v431 := v430.Get() +v432 := lang.Apply(v431, []any{lang.NewSymbol("glojure.core/rest")}) +v433 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v434 := v433.FindInternedVar(lang.NewSymbol("list")) +if v434.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v434))) } -v23 = v24 - break +v435 := v434.Get() +v436 := lang.Apply(v435, []any{v135}) +v437 := lang.Apply(v428, []any{v432, v436}) +v438 := lang.Apply(v425, []any{v437}) +v439 := lang.Apply(v422, []any{v438}) +v440 := lang.Apply(v415, []any{v419, v439}) +v441 := lang.Apply(v412, []any{v440}) +v442 := lang.Apply(v409, []any{v441}) +v443 := lang.Apply(v398, []any{v402, v406, v442}) +v444 := lang.Apply(v395, []any{v443}) +v445 := lang.Apply(v392, []any{v444}) +v446 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v447 := v446.FindInternedVar(lang.NewSymbol("list")) +if v447.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v447))) } -return v23 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v448 := v447.Get() +v449 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v450 := v449.FindInternedVar(lang.NewSymbol("seq")) +if v450.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v450))) } +v451 := v450.Get() +v452 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v453 := v452.FindInternedVar(lang.NewSymbol("concat")) +if v453.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v453))) } -// cond-> -{ -v0 := lang.NewSymbol("cond->").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes an expression and a set of test/form pairs. Threads expr (via ->)\n through each form for which the corresponding test\n expression is true. Note that, unlike cond branching, cond-> threading does\n not short circuit after the first true test expression.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7607), lang.NewKeyword("end-line"), int(7607))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -_ = nil -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("gensym")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v454 := v453.Get() +v455 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v456 := v455.FindInternedVar(lang.NewSymbol("list")) +if v456.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v456))) } -v10 := v9.Get() -v11 := lang.Apply(v10, nil) -var v7 any = v11 -_ = v7 -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("map")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +v457 := v456.Get() +v458 := lang.Apply(v457, []any{lang.NewSymbol("recur")}) +v459 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v460 := v459.FindInternedVar(lang.NewSymbol("list")) +if v460.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v460))) } -v15 := v14.Get() -var v16 lang.FnFunc -v16 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v17 := args[0] -var v18 any = v17 -_ = v18 -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("nth")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +v461 := v460.Get() +v462 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v463 := v462.FindInternedVar(lang.NewSymbol("seq")) +if v463.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v463))) } -v22 := v21.Get() -v23 := lang.Apply(v22, []any{v18, int64(0), nil}) -var v19 any = v23 -_ = v19 -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("nth")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +v464 := v463.Get() +v465 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v466 := v465.FindInternedVar(lang.NewSymbol("concat")) +if v466.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v466))) } -v27 := v26.Get() -v28 := lang.Apply(v27, []any{v18, int64(1), nil}) -var v24 any = v28 -_ = v24 -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("seq")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +v467 := v466.Get() +v468 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v469 := v468.FindInternedVar(lang.NewSymbol("list")) +if v469.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v469))) } -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("concat")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +v470 := v469.Get() +v471 := lang.Apply(v470, []any{lang.NewSymbol("glojure.core/rest")}) +v472 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v473 := v472.FindInternedVar(lang.NewSymbol("list")) +if v473.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v473))) } -v35 := v34.Get() -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +v474 := v473.Get() +v475 := lang.Apply(v474, []any{v135}) +v476 := lang.Apply(v467, []any{v471, v475}) +v477 := lang.Apply(v464, []any{v476}) +v478 := lang.Apply(v461, []any{v477}) +v479 := lang.Apply(v454, []any{v458, v478}) +v480 := lang.Apply(v451, []any{v479}) +v481 := lang.Apply(v448, []any{v480}) +v482 := lang.Apply(v381, []any{v385, v389, v445, v481}) +v483 := lang.Apply(v378, []any{v482}) +v484 := lang.Apply(v375, []any{v483}) +v485 := lang.Apply(v300, []any{v304, v372, v484}) +v486 := lang.Apply(v297, []any{v485}) +v294 = v486 +} else { +var v487 any +if lang.IsTruthy(lang.NewKeyword("else")) { +v488 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v489 := v488.FindInternedVar(lang.NewSymbol("seq")) +if v489.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v489))) } -v38 := v37.Get() -v39 := lang.Apply(v38, []any{lang.NewSymbol("if")}) -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +v490 := v489.Get() +v491 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v492 := v491.FindInternedVar(lang.NewSymbol("concat")) +if v492.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v492))) } -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v19}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +v493 := v492.Get() +v494 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v495 := v494.FindInternedVar(lang.NewSymbol("list")) +if v495.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v495))) } -v46 := v45.Get() -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("seq")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +v496 := v495.Get() +v497 := lang.Apply(v496, []any{lang.NewSymbol("glojure.core/cons")}) +v498 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v499 := v498.FindInternedVar(lang.NewSymbol("list")) +if v499.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v499))) } -v49 := v48.Get() -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("concat")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +v500 := v499.Get() +v501 := lang.Apply(v500, []any{v6}) +v502 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v503 := v502.FindInternedVar(lang.NewSymbol("list")) +if v503.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v503))) } -v52 := v51.Get() -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("list")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +v504 := v503.Get() +v505 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v506 := v505.FindInternedVar(lang.NewSymbol("seq")) +if v506.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v506))) } -v55 := v54.Get() -v56 := lang.Apply(v55, []any{lang.NewSymbol("glojure.core/->")}) -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("list")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +v507 := v506.Get() +v508 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v509 := v508.FindInternedVar(lang.NewSymbol("concat")) +if v509.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v509))) } -v59 := v58.Get() -v60 := lang.Apply(v59, []any{v7}) -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("list")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +v510 := v509.Get() +v511 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v512 := v511.FindInternedVar(lang.NewSymbol("list")) +if v512.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v512))) } -v63 := v62.Get() -v64 := lang.Apply(v63, []any{v24}) -v65 := lang.Apply(v52, []any{v56, v60, v64}) -v66 := lang.Apply(v49, []any{v65}) -v67 := lang.Apply(v46, []any{v66}) -v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v69 := v68.FindInternedVar(lang.NewSymbol("list")) -if v69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) +v513 := v512.Get() +v514 := lang.Apply(v513, []any{v130}) +v515 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v516 := v515.FindInternedVar(lang.NewSymbol("list")) +if v516.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v516))) } -v70 := v69.Get() -v71 := lang.Apply(v70, []any{v7}) -v72 := lang.Apply(v35, []any{v39, v43, v67, v71}) -v73 := lang.Apply(v32, []any{v72}) -return v73 -}) -v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7616), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7616), lang.NewKeyword("end-column"), int(66)) -v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) -if err != nil { - panic(err) +v517 := v516.Get() +v518 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v519 := v518.FindInternedVar(lang.NewSymbol("seq")) +if v519.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v519))) } -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("partition")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v520 := v519.Get() +v521 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v522 := v521.FindInternedVar(lang.NewSymbol("concat")) +if v522.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v522))) } -v21 := v20.Get() -v22 := lang.Apply(v21, []any{int64(2), v6}) -v23 := lang.Apply(v15, []any{v18, v22}) -var v12 any = v23 -_ = v12 -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("seq")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +v523 := v522.Get() +v524 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v525 := v524.FindInternedVar(lang.NewSymbol("list")) +if v525.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v525))) } -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("concat")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +v526 := v525.Get() +v527 := lang.Apply(v526, []any{lang.NewSymbol("glojure.core/rest")}) +v528 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v529 := v528.FindInternedVar(lang.NewSymbol("list")) +if v529.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v529))) } -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v530 := v529.Get() +v531 := lang.Apply(v530, []any{v135}) +v532 := lang.Apply(v523, []any{v527, v531}) +v533 := lang.Apply(v520, []any{v532}) +v534 := lang.Apply(v517, []any{v533}) +v535 := lang.Apply(v510, []any{v514, v534}) +v536 := lang.Apply(v507, []any{v535}) +v537 := lang.Apply(v504, []any{v536}) +v538 := lang.Apply(v493, []any{v497, v501, v537}) +v539 := lang.Apply(v490, []any{v538}) +v487 = v539 +} else { +v487 = nil } -v33 := v32.Get() -v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/let")}) -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("list")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +v294 = v487 } -v37 := v36.Get() -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("apply")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +v288 = v294 } -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("vector")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +v226 = v288 } -v43 := v42.Get() -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("seq")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +v200 = v226 } -v46 := v45.Get() -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("concat")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +v174 = v200 } -v49 := v48.Get() -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("list")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +return v174 +}) +v142 := v141 +_ = v142 } -v52 := v51.Get() -v53 := lang.Apply(v52, []any{v7}) -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("list")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +v142 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4672), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(4687), lang.NewKeyword("end-column"), int(73)) +v143, err := lang.WithMeta(v141, v142.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v56 := v55.Get() -v57 := lang.Apply(v56, []any{v5}) -v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v59 := v58.FindInternedVar(lang.NewSymbol("interleave")) -if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) +var v140 any = v143 +_ = v140 +var v145 any +if lang.IsTruthy(v128) { +v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v147 := v146.FindInternedVar(lang.NewSymbol("seq")) +if v147.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) } -v60 := v59.Get() -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("repeat")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +v148 := v147.Get() +v149 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v150 := v149.FindInternedVar(lang.NewSymbol("concat")) +if v150.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v150))) } -v63 := v62.Get() -v64 := lang.Apply(v63, []any{v7}) -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("butlast")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +v151 := v150.Get() +v152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v153 := v152.FindInternedVar(lang.NewSymbol("list")) +if v153.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v153))) } -v67 := v66.Get() -v68 := lang.Apply(v67, []any{v12}) -v69 := lang.Apply(v60, []any{v64, v68}) -v70 := lang.Apply(v49, []any{v53, v57, v69}) -v71 := lang.Apply(v46, []any{v70}) -v72 := lang.Apply(v40, []any{v43, v71}) -v73 := lang.Apply(v37, []any{v72}) -v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v75 := v74.FindInternedVar(lang.NewSymbol("list")) -if v75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) +v154 := v153.Get() +v155 := lang.Apply(v154, []any{lang.NewSymbol("glojure.core/fn")}) +v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v157 := v156.FindInternedVar(lang.NewSymbol("list")) +if v157.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) } -v76 := v75.Get() -var v77 any -v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v79 := v78.FindInternedVar(lang.NewSymbol("empty?")) -if v79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) +v158 := v157.Get() +v159 := lang.Apply(v158, []any{v130}) +v160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v161 := v160.FindInternedVar(lang.NewSymbol("list")) +if v161.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v161))) } -v80 := v79.Get() -v81 := lang.Apply(v80, []any{v12}) -if lang.IsTruthy(v81) { -v77 = v7 -} else { -v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v83 := v82.FindInternedVar(lang.NewSymbol("last")) -if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) +v162 := v161.Get() +v163 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v164 := v163.FindInternedVar(lang.NewSymbol("apply")) +if v164.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v164))) } -v84 := v83.Get() -v85 := lang.Apply(v84, []any{v12}) -v77 = v85 +v165 := v164.Get() +v166 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v167 := v166.FindInternedVar(lang.NewSymbol("vector")) +if v167.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v167))) } -v86 := lang.Apply(v76, []any{v77}) -v87 := lang.Apply(v30, []any{v34, v73, v86}) -v88 := lang.Apply(v27, []any{v87}) -return v88 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v168 := v167.Get() +v169 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v170 := v169.FindInternedVar(lang.NewSymbol("seq")) +if v170.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v170))) } +v171 := v170.Get() +v172 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v173 := v172.FindInternedVar(lang.NewSymbol("concat")) +if v173.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v173))) } -// with-out-str -{ -v0 := lang.NewSymbol("with-out-str").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Evaluates exprs in a context in which *out* is bound to a fresh\n StringWriter. Returns the string created by any nested printing\n calls.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4738), lang.NewKeyword("end-line"), int(4738))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("seq")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +v174 := v173.Get() +v175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v176 := v175.FindInternedVar(lang.NewSymbol("list")) +if v176.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v176))) } -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("concat")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +v177 := v176.Get() +v178 := lang.Apply(v177, []any{v135}) +v179 := lang.Apply(v174, []any{v178}) +v180 := lang.Apply(v171, []any{v179}) +v181 := lang.Apply(v165, []any{v168, v180}) +v182 := lang.Apply(v162, []any{v181}) +v183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v184 := v183.FindInternedVar(lang.NewSymbol("list")) +if v184.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v184))) } -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("list")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +v185 := v184.Get() +v186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v187 := v186.FindInternedVar(lang.NewSymbol("seq")) +if v187.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v187))) } -v14 := v13.Get() -v15 := lang.Apply(v14, []any{lang.NewSymbol("glojure.core/let")}) -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("list")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +v188 := v187.Get() +v189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v190 := v189.FindInternedVar(lang.NewSymbol("concat")) +if v190.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v190))) } -v18 := v17.Get() -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("apply")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v191 := v190.Get() +v192 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v193 := v192.FindInternedVar(lang.NewSymbol("list")) +if v193.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v193))) } -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("vector")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v194 := v193.Get() +v195 := lang.Apply(v194, []any{lang.NewSymbol("glojure.core/lazy-seq")}) +v196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v197 := v196.FindInternedVar(lang.NewSymbol("list")) +if v197.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v197))) } -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("seq")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +v198 := v197.Get() +v199 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v200 := v199.FindInternedVar(lang.NewSymbol("seq")) +if v200.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v200))) } -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("concat")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +v201 := v200.Get() +v202 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v203 := v202.FindInternedVar(lang.NewSymbol("concat")) +if v203.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v203))) } -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v204 := v203.Get() +v205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v206 := v205.FindInternedVar(lang.NewSymbol("list")) +if v206.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v206))) } -v33 := v32.Get() -v34 := lang.Apply(v33, []any{lang.NewSymbol("s__0__auto__")}) -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("list")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +v207 := v206.Get() +v208 := lang.Apply(v207, []any{lang.NewSymbol("glojure.core/loop")}) +v209 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v210 := v209.FindInternedVar(lang.NewSymbol("list")) +if v210.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v210))) } -v37 := v36.Get() -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("seq")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +v211 := v210.Get() +v212 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v213 := v212.FindInternedVar(lang.NewSymbol("apply")) +if v213.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v213))) } -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("concat")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +v214 := v213.Get() +v215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v216 := v215.FindInternedVar(lang.NewSymbol("vector")) +if v216.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v216))) } -v43 := v42.Get() -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +v217 := v216.Get() +v218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v219 := v218.FindInternedVar(lang.NewSymbol("seq")) +if v219.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v219))) } -v46 := v45.Get() -v47 := lang.Apply(v46, []any{lang.NewSymbol("new")}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +v220 := v219.Get() +v221 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v222 := v221.FindInternedVar(lang.NewSymbol("concat")) +if v222.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v222))) } -v50 := v49.Get() -v51 := lang.Apply(v50, []any{lang.NewSymbol("strings.Builder")}) -v52 := lang.Apply(v43, []any{v47, v51}) -v53 := lang.Apply(v40, []any{v52}) -v54 := lang.Apply(v37, []any{v53}) -v55 := lang.Apply(v30, []any{v34, v54}) -v56 := lang.Apply(v27, []any{v55}) -v57 := lang.Apply(v21, []any{v24, v56}) -v58 := lang.Apply(v18, []any{v57}) -v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v60 := v59.FindInternedVar(lang.NewSymbol("list")) -if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) +v223 := v222.Get() +v224 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v225 := v224.FindInternedVar(lang.NewSymbol("list")) +if v225.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v225))) } -v61 := v60.Get() -v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v63 := v62.FindInternedVar(lang.NewSymbol("seq")) -if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +v226 := v225.Get() +v227 := lang.Apply(v226, []any{v135}) +v228 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v229 := v228.FindInternedVar(lang.NewSymbol("list")) +if v229.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v229))) } -v64 := v63.Get() -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("concat")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +v230 := v229.Get() +v231 := lang.Apply(v230, []any{v135}) +v232 := lang.Apply(v223, []any{v227, v231}) +v233 := lang.Apply(v220, []any{v232}) +v234 := lang.Apply(v214, []any{v217, v233}) +v235 := lang.Apply(v211, []any{v234}) +v236 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v237 := v236.FindInternedVar(lang.NewSymbol("list")) +if v237.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v237))) } -v67 := v66.Get() -v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v69 := v68.FindInternedVar(lang.NewSymbol("list")) -if v69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) +v238 := v237.Get() +v239 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v240 := v239.FindInternedVar(lang.NewSymbol("seq")) +if v240.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v240))) } -v70 := v69.Get() -v71 := lang.Apply(v70, []any{lang.NewSymbol("glojure.core/binding")}) -v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v73 := v72.FindInternedVar(lang.NewSymbol("list")) -if v73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) +v241 := v240.Get() +v242 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v243 := v242.FindInternedVar(lang.NewSymbol("concat")) +if v243.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v243))) } -v74 := v73.Get() -v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v76 := v75.FindInternedVar(lang.NewSymbol("apply")) -if v76.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) +v244 := v243.Get() +v245 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v246 := v245.FindInternedVar(lang.NewSymbol("list")) +if v246.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v246))) } -v77 := v76.Get() -v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v79 := v78.FindInternedVar(lang.NewSymbol("vector")) -if v79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) +v247 := v246.Get() +v248 := lang.Apply(v247, []any{lang.NewSymbol("glojure.core/when-first")}) +v249 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v250 := v249.FindInternedVar(lang.NewSymbol("list")) +if v250.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v250))) } -v80 := v79.Get() -v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v82 := v81.FindInternedVar(lang.NewSymbol("seq")) -if v82.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) +v251 := v250.Get() +v252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v253 := v252.FindInternedVar(lang.NewSymbol("apply")) +if v253.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v253))) } -v83 := v82.Get() -v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v85 := v84.FindInternedVar(lang.NewSymbol("concat")) -if v85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) +v254 := v253.Get() +v255 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v256 := v255.FindInternedVar(lang.NewSymbol("vector")) +if v256.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v256))) } -v86 := v85.Get() -v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v88 := v87.FindInternedVar(lang.NewSymbol("list")) -if v88.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) +v257 := v256.Get() +v258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v259 := v258.FindInternedVar(lang.NewSymbol("seq")) +if v259.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v259))) } -v89 := v88.Get() -v90 := lang.Apply(v89, []any{lang.NewSymbol("glojure.core/*out*")}) -v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v92 := v91.FindInternedVar(lang.NewSymbol("list")) -if v92.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) +v260 := v259.Get() +v261 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v262 := v261.FindInternedVar(lang.NewSymbol("concat")) +if v262.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v262))) } -v93 := v92.Get() -v94 := lang.Apply(v93, []any{lang.NewSymbol("s__0__auto__")}) -v95 := lang.Apply(v86, []any{v90, v94}) -v96 := lang.Apply(v83, []any{v95}) -v97 := lang.Apply(v77, []any{v80, v96}) -v98 := lang.Apply(v74, []any{v97}) -v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v100 := v99.FindInternedVar(lang.NewSymbol("list")) -if v100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) +v263 := v262.Get() +v264 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v265 := v264.FindInternedVar(lang.NewSymbol("list")) +if v265.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v265))) } -v101 := v100.Get() -v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v103 := v102.FindInternedVar(lang.NewSymbol("seq")) -if v103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) +v266 := v265.Get() +v267 := lang.Apply(v266, []any{v99}) +v268 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v269 := v268.FindInternedVar(lang.NewSymbol("list")) +if v269.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v269))) } -v104 := v103.Get() -v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v106 := v105.FindInternedVar(lang.NewSymbol("concat")) -if v106.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) +v270 := v269.Get() +v271 := lang.Apply(v270, []any{v135}) +v272 := lang.Apply(v263, []any{v267, v271}) +v273 := lang.Apply(v260, []any{v272}) +v274 := lang.Apply(v254, []any{v257, v273}) +v275 := lang.Apply(v251, []any{v274}) +v276 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v277 := v276.FindInternedVar(lang.NewSymbol("list")) +if v277.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v277))) } -v107 := v106.Get() -v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v109 := v108.FindInternedVar(lang.NewSymbol("list")) -if v109.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) +v278 := v277.Get() +v279 := lang.Apply(v140, []any{v111}) +v280 := lang.Apply(v278, []any{v279}) +v281 := lang.Apply(v244, []any{v248, v275, v280}) +v282 := lang.Apply(v241, []any{v281}) +v283 := lang.Apply(v238, []any{v282}) +v284 := lang.Apply(v204, []any{v208, v235, v283}) +v285 := lang.Apply(v201, []any{v284}) +v286 := lang.Apply(v198, []any{v285}) +v287 := lang.Apply(v191, []any{v195, v286}) +v288 := lang.Apply(v188, []any{v287}) +v289 := lang.Apply(v185, []any{v288}) +v290 := lang.Apply(v151, []any{v155, v159, v182, v289}) +v291 := lang.Apply(v148, []any{v290}) +v145 = v291 +} else { +v293 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v294 := v293.FindInternedVar(lang.NewSymbol("gensym")) +if v294.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v294))) } -v110 := v109.Get() -v111 := lang.Apply(v110, []any{lang.NewSymbol("glojure.core/str")}) -v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v113 := v112.FindInternedVar(lang.NewSymbol("list")) -if v113.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) +v295 := v294.Get() +v296 := lang.Apply(v295, []any{"i__"}) +var v292 any = v296 +_ = v292 +v298 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v299 := v298.FindInternedVar(lang.NewSymbol("gensym")) +if v299.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v299))) } -v114 := v113.Get() -v115 := lang.Apply(v114, []any{lang.NewSymbol("s__0__auto__")}) -v116 := lang.Apply(v107, []any{v111, v115}) -v117 := lang.Apply(v104, []any{v116}) -v118 := lang.Apply(v101, []any{v117}) -v119 := lang.Apply(v67, []any{v71, v98, v5, v118}) -v120 := lang.Apply(v64, []any{v119}) -v121 := lang.Apply(v61, []any{v120}) -v122 := lang.Apply(v11, []any{v15, v58, v121}) -v123 := lang.Apply(v8, []any{v122}) -return v123 +v300 := v299.Get() +v301 := lang.Apply(v300, []any{"b__"}) +var v297 any = v301 +_ = v297 +var v303 lang.FnFunc +{ // function do-cmod +v303 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} +v305 := args[0] +var v306 any = v305 +_ = v306 +v308 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v309 := v308.FindInternedVar(lang.NewSymbol("seq")) +if v309.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v309))) } -// with-loading-context -{ -v0 := lang.NewSymbol("with-loading-context").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5777), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5777), lang.NewKeyword("end-column"), int(30), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("macro"), true)).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("seq")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +v310 := v309.Get() +v311 := lang.Apply(v310, []any{v306}) +var v307 any = v311 +_ = v307 +v313 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v314 := v313.FindInternedVar(lang.NewSymbol("first")) +if v314.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v314))) } -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("concat")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +v315 := v314.Get() +v316 := lang.Apply(v315, []any{v307}) +var v312 any = v316 +_ = v312 +v318 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v319 := v318.FindInternedVar(lang.NewSymbol("next")) +if v319.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v319))) } -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("list")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("seq")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +v320 := v319.Get() +v321 := lang.Apply(v320, []any{v317}) +var v317 any = v321 +_ = v317 +var v322 any = v312 +_ = v322 +v324 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v325 := v324.FindInternedVar(lang.NewSymbol("nth")) +if v325.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v325))) } -v17 := v16.Get() -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("concat")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v326 := v325.Get() +v327 := lang.Apply(v326, []any{v322, int64(0), nil}) +var v323 any = v327 +_ = v323 +v329 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v330 := v329.FindInternedVar(lang.NewSymbol("nth")) +if v330.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v330))) } -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("list")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +v331 := v330.Get() +v332 := lang.Apply(v331, []any{v322, int64(1), nil}) +var v328 any = v332 +_ = v328 +var v333 any = v322 +_ = v333 +var v334 any = v317 +_ = v334 +var v336 any +v337 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v338 := v337.FindInternedVar(lang.NewSymbol("=")) +if v338.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v338))) } -v23 := v22.Get() -v24 := lang.Apply(v23, []any{lang.NewSymbol("glojure.core/fn")}) -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("list")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +v339 := v338.Get() +v340 := lang.Apply(v339, []any{v323, lang.NewKeyword("let")}) +if lang.IsTruthy(v340) { +v341 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v342 := v341.FindInternedVar(lang.NewSymbol("seq")) +if v342.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v342))) } -v27 := v26.Get() -v28 := lang.Apply(v27, []any{lang.NewSymbol("loading__0__auto__")}) -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("list")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +v343 := v342.Get() +v344 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v345 := v344.FindInternedVar(lang.NewSymbol("concat")) +if v345.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v345))) } -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("apply")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +v346 := v345.Get() +v347 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v348 := v347.FindInternedVar(lang.NewSymbol("list")) +if v348.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v348))) } -v34 := v33.Get() -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("vector")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +v349 := v348.Get() +v350 := lang.Apply(v349, []any{lang.NewSymbol("glojure.core/let")}) +v351 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v352 := v351.FindInternedVar(lang.NewSymbol("list")) +if v352.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v352))) } -v37 := v36.Get() -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("seq")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +v353 := v352.Get() +v354 := lang.Apply(v353, []any{v328}) +v355 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v356 := v355.FindInternedVar(lang.NewSymbol("list")) +if v356.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v356))) } -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("concat")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +v357 := v356.Get() +v358 := lang.Apply(v304, []any{v334}) +v359 := lang.Apply(v357, []any{v358}) +v360 := lang.Apply(v346, []any{v350, v354, v359}) +v361 := lang.Apply(v343, []any{v360}) +v336 = v361 +} else { +var v362 any +v363 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v364 := v363.FindInternedVar(lang.NewSymbol("=")) +if v364.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v364))) } -v43 := v42.Get() -v44 := lang.Apply(v43, nil) -v45 := lang.Apply(v40, []any{v44}) -v46 := lang.Apply(v34, []any{v37, v45}) -v47 := lang.Apply(v31, []any{v46}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +v365 := v364.Get() +v366 := lang.Apply(v365, []any{v323, lang.NewKeyword("while")}) +if lang.IsTruthy(v366) { +v367 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v368 := v367.FindInternedVar(lang.NewSymbol("seq")) +if v368.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v368))) } -v50 := v49.Get() -v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v52 := v51.FindInternedVar(lang.NewSymbol("seq")) -if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) +v369 := v368.Get() +v370 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v371 := v370.FindInternedVar(lang.NewSymbol("concat")) +if v371.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v371))) } -v53 := v52.Get() -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("concat")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +v372 := v371.Get() +v373 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v374 := v373.FindInternedVar(lang.NewSymbol("list")) +if v374.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v374))) } -v56 := v55.Get() -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("list")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +v375 := v374.Get() +v376 := lang.Apply(v375, []any{lang.NewSymbol("glojure.core/when")}) +v377 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v378 := v377.FindInternedVar(lang.NewSymbol("list")) +if v378.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v378))) } -v59 := v58.Get() -v60 := lang.Apply(v59, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.PushThreadBindings")}) -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("list")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +v379 := v378.Get() +v380 := lang.Apply(v379, []any{v328}) +v381 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v382 := v381.FindInternedVar(lang.NewSymbol("list")) +if v382.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v382))) } -v63 := v62.Get() -v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v65 := v64.FindInternedVar(lang.NewSymbol("apply")) -if v65.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) +v383 := v382.Get() +v384 := lang.Apply(v304, []any{v334}) +v385 := lang.Apply(v383, []any{v384}) +v386 := lang.Apply(v372, []any{v376, v380, v385}) +v387 := lang.Apply(v369, []any{v386}) +v362 = v387 +} else { +var v388 any +v389 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v390 := v389.FindInternedVar(lang.NewSymbol("=")) +if v390.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v390))) } -v66 := v65.Get() -v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v68 := v67.FindInternedVar(lang.NewSymbol("hash-map")) -if v68.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) +v391 := v390.Get() +v392 := lang.Apply(v391, []any{v323, lang.NewKeyword("when")}) +if lang.IsTruthy(v392) { +v393 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v394 := v393.FindInternedVar(lang.NewSymbol("seq")) +if v394.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v394))) } -v69 := v68.Get() -v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v71 := v70.FindInternedVar(lang.NewSymbol("seq")) -if v71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) +v395 := v394.Get() +v396 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v397 := v396.FindInternedVar(lang.NewSymbol("concat")) +if v397.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v397))) } -v72 := v71.Get() -v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v74 := v73.FindInternedVar(lang.NewSymbol("concat")) -if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) +v398 := v397.Get() +v399 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v400 := v399.FindInternedVar(lang.NewSymbol("list")) +if v400.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v400))) } -v75 := v74.Get() -v76 := lang.Apply(v75, nil) -v77 := lang.Apply(v72, []any{v76}) -v78 := lang.Apply(v66, []any{v69, v77}) -v79 := lang.Apply(v63, []any{v78}) -v80 := lang.Apply(v56, []any{v60, v79}) -v81 := lang.Apply(v53, []any{v80}) -v82 := lang.Apply(v50, []any{v81}) -v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v84 := v83.FindInternedVar(lang.NewSymbol("list")) -if v84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) +v401 := v400.Get() +v402 := lang.Apply(v401, []any{lang.NewSymbol("if")}) +v403 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v404 := v403.FindInternedVar(lang.NewSymbol("list")) +if v404.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v404))) } -v85 := v84.Get() -v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v87 := v86.FindInternedVar(lang.NewSymbol("seq")) -if v87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) +v405 := v404.Get() +v406 := lang.Apply(v405, []any{v328}) +v407 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v408 := v407.FindInternedVar(lang.NewSymbol("list")) +if v408.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v408))) } -v88 := v87.Get() -v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v90 := v89.FindInternedVar(lang.NewSymbol("concat")) -if v90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) +v409 := v408.Get() +v410 := lang.Apply(v304, []any{v334}) +v411 := lang.Apply(v409, []any{v410}) +v412 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v413 := v412.FindInternedVar(lang.NewSymbol("list")) +if v413.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v413))) } -v91 := v90.Get() -v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v93 := v92.FindInternedVar(lang.NewSymbol("list")) -if v93.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) +v414 := v413.Get() +v415 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v416 := v415.FindInternedVar(lang.NewSymbol("seq")) +if v416.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v416))) } -v94 := v93.Get() -v95 := lang.Apply(v94, []any{lang.NewSymbol("try")}) -v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v97 := v96.FindInternedVar(lang.NewSymbol("list")) -if v97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) +v417 := v416.Get() +v418 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v419 := v418.FindInternedVar(lang.NewSymbol("concat")) +if v419.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v419))) } -v98 := v97.Get() -v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v100 := v99.FindInternedVar(lang.NewSymbol("seq")) -if v100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) +v420 := v419.Get() +v421 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v422 := v421.FindInternedVar(lang.NewSymbol("list")) +if v422.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v422))) } -v101 := v100.Get() -v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v103 := v102.FindInternedVar(lang.NewSymbol("concat")) -if v103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) +v423 := v422.Get() +v424 := lang.Apply(v423, []any{lang.NewSymbol("recur")}) +v425 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v426 := v425.FindInternedVar(lang.NewSymbol("list")) +if v426.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v426))) } -v104 := v103.Get() -v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v106 := v105.FindInternedVar(lang.NewSymbol("list")) -if v106.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) +v427 := v426.Get() +v428 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v429 := v428.FindInternedVar(lang.NewSymbol("seq")) +if v429.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v429))) } -v107 := v106.Get() -v108 := lang.Apply(v107, []any{lang.NewSymbol("finally")}) -v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v110 := v109.FindInternedVar(lang.NewSymbol("list")) -if v110.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) +v430 := v429.Get() +v431 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v432 := v431.FindInternedVar(lang.NewSymbol("concat")) +if v432.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v432))) } -v111 := v110.Get() -v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v113 := v112.FindInternedVar(lang.NewSymbol("seq")) -if v113.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) +v433 := v432.Get() +v434 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v435 := v434.FindInternedVar(lang.NewSymbol("list")) +if v435.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v435))) } -v114 := v113.Get() -v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v116 := v115.FindInternedVar(lang.NewSymbol("concat")) -if v116.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) +v436 := v435.Get() +v437 := lang.Apply(v436, []any{lang.NewSymbol("glojure.core/unchecked-inc")}) +v438 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v439 := v438.FindInternedVar(lang.NewSymbol("list")) +if v439.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v439))) } -v117 := v116.Get() -v118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v119 := v118.FindInternedVar(lang.NewSymbol("list")) -if v119.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v119))) +v440 := v439.Get() +v441 := lang.Apply(v440, []any{v292}) +v442 := lang.Apply(v433, []any{v437, v441}) +v443 := lang.Apply(v430, []any{v442}) +v444 := lang.Apply(v427, []any{v443}) +v445 := lang.Apply(v420, []any{v424, v444}) +v446 := lang.Apply(v417, []any{v445}) +v447 := lang.Apply(v414, []any{v446}) +v448 := lang.Apply(v398, []any{v402, v406, v411, v447}) +v449 := lang.Apply(v395, []any{v448}) +v388 = v449 +} else { +var v450 any +v451 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v452 := v451.FindInternedVar(lang.NewSymbol("keyword?")) +if v452.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v452))) } -v120 := v119.Get() -v121 := lang.Apply(v120, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.PopThreadBindings")}) -v122 := lang.Apply(v117, []any{v121}) -v123 := lang.Apply(v114, []any{v122}) -v124 := lang.Apply(v111, []any{v123}) -v125 := lang.Apply(v104, []any{v108, v124}) -v126 := lang.Apply(v101, []any{v125}) -v127 := lang.Apply(v98, []any{v126}) -v128 := lang.Apply(v91, []any{v95, v5, v127}) -v129 := lang.Apply(v88, []any{v128}) -v130 := lang.Apply(v85, []any{v129}) -v131 := lang.Apply(v20, []any{v24, v28, v47, v82, v130}) -v132 := lang.Apply(v17, []any{v131}) -v133 := lang.Apply(v14, []any{v132}) -v134 := lang.Apply(v11, []any{v133}) -v135 := lang.Apply(v8, []any{v134}) -return v135 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v453 := v452.Get() +v454 := lang.Apply(v453, []any{v323}) +if lang.IsTruthy(v454) { +v455 := lang.Apply(v59, []any{"Invalid 'for' keyword ", v323}) +v450 = v455 +} else { +var v456 any +if lang.IsTruthy(lang.NewKeyword("else")) { +v457 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v458 := v457.FindInternedVar(lang.NewSymbol("seq")) +if v458.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v458))) } +v459 := v458.Get() +v460 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v461 := v460.FindInternedVar(lang.NewSymbol("concat")) +if v461.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v461))) } -// print -{ -v0 := lang.NewSymbol("print").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Prints the object(s) to the output stream that is the current value\n of *out*. print and println produce output for human consumption.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3725), lang.NewKeyword("end-line"), int(3725))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewList(args[0:]...) -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("push-thread-bindings")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v462 := v461.Get() +v463 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v464 := v463.FindInternedVar(lang.NewSymbol("list")) +if v464.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v464))) } -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("hash-map")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v465 := v464.Get() +v466 := lang.Apply(v465, []any{lang.NewSymbol("do")}) +v467 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v468 := v467.FindInternedVar(lang.NewSymbol("list")) +if v468.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v468))) } -v10 := v9.Get() -v11 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*print-readably*")) -v12 := lang.Apply(v10, []any{v11, nil}) -v13 := lang.Apply(v7, []any{v12}) -_ = v13 -var v14 any -func() { -defer func() { -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +v469 := v468.Get() +v470 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v471 := v470.FindInternedVar(lang.NewSymbol("seq")) +if v471.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v471))) } -v17 := v16.Get() -v18 := lang.Apply(v17, nil) -}() -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("apply")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v472 := v471.Get() +v473 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v474 := v473.FindInternedVar(lang.NewSymbol("concat")) +if v474.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v474))) } -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("pr")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v475 := v474.Get() +v476 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v477 := v476.FindInternedVar(lang.NewSymbol("list")) +if v477.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v477))) } -v24 := v23.Get() -v25 := lang.Apply(v21, []any{v24, v3}) -v14 = v25 -}() -return v14 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v478 := v477.Get() +v479 := lang.Apply(v478, []any{lang.NewSymbol("glojure.core/chunk-append")}) +v480 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v481 := v480.FindInternedVar(lang.NewSymbol("list")) +if v481.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v481))) } +v482 := v481.Get() +v483 := lang.Apply(v482, []any{v297}) +v484 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v485 := v484.FindInternedVar(lang.NewSymbol("list")) +if v485.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v485))) } -// ex-message -{ -v0 := lang.NewSymbol("ex-message").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ex"))), lang.NewKeyword("doc"), "Returns the message attached to ex if ex is a Throwable.\n Otherwise returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4820), lang.NewKeyword("end-line"), int(4820))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v486 := v485.Get() +v487 := lang.Apply(v486, []any{v6}) +v488 := lang.Apply(v475, []any{v479, v483, v487}) +v489 := lang.Apply(v472, []any{v488}) +v490 := lang.Apply(v469, []any{v489}) +v491 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v492 := v491.FindInternedVar(lang.NewSymbol("list")) +if v492.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v492))) } -v7 := v6.Get() -v8 := lang.Apply(v7, []any{lang1.Throwable, v3}) -if lang.IsTruthy(v8) { -v9, ok := lang.FieldOrMethod(v3, "getMessage") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getMessage"))) +v493 := v492.Get() +v494 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v495 := v494.FindInternedVar(lang.NewSymbol("seq")) +if v495.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v495))) } -var v10 any -switch reflect.TypeOf(v9).Kind() { -case reflect.Func: - v10 = lang.Apply(v9, nil) -default: - v10 = v9 +v496 := v495.Get() +v497 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v498 := v497.FindInternedVar(lang.NewSymbol("concat")) +if v498.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v498))) } -v4 = v10 -} else { -v4 = nil +v499 := v498.Get() +v500 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v501 := v500.FindInternedVar(lang.NewSymbol("list")) +if v501.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v501))) } -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v502 := v501.Get() +v503 := lang.Apply(v502, []any{lang.NewSymbol("recur")}) +v504 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v505 := v504.FindInternedVar(lang.NewSymbol("list")) +if v505.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v505))) } +v506 := v505.Get() +v507 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v508 := v507.FindInternedVar(lang.NewSymbol("seq")) +if v508.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v508))) } -// load-libs -{ -v0 := lang.NewSymbol("load-libs").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Loads libs, interpreting libspecs, prefix lists, and flags for\n forwarding to load-lib", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5994), lang.NewKeyword("end-line"), int(5994), lang.NewKeyword("private"), true)).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewList(args[0:]...) -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("filter")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v509 := v508.Get() +v510 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v511 := v510.FindInternedVar(lang.NewSymbol("concat")) +if v511.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v511))) } -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("keyword?")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v512 := v511.Get() +v513 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v514 := v513.FindInternedVar(lang.NewSymbol("list")) +if v514.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v514))) } -v10 := v9.Get() -v11 := lang.Apply(v7, []any{v10, v3}) -var v4 any = v11 -_ = v4 -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("interleave")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +v515 := v514.Get() +v516 := lang.Apply(v515, []any{lang.NewSymbol("glojure.core/unchecked-inc")}) +v517 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v518 := v517.FindInternedVar(lang.NewSymbol("list")) +if v518.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v518))) } -v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("repeat")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +v519 := v518.Get() +v520 := lang.Apply(v519, []any{v292}) +v521 := lang.Apply(v512, []any{v516, v520}) +v522 := lang.Apply(v509, []any{v521}) +v523 := lang.Apply(v506, []any{v522}) +v524 := lang.Apply(v499, []any{v503, v523}) +v525 := lang.Apply(v496, []any{v524}) +v526 := lang.Apply(v493, []any{v525}) +v527 := lang.Apply(v462, []any{v466, v490, v526}) +v528 := lang.Apply(v459, []any{v527}) +v456 = v528 +} else { +v456 = nil } -v18 := v17.Get() -v19 := lang.Apply(v18, []any{true}) -v20 := lang.Apply(v15, []any{v4, v19}) -var v12 any = v20 -_ = v12 -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("filter")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v450 = v456 } -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("complement")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +v388 = v450 } -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("keyword?")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +v362 = v388 } -v30 := v29.Get() -v31 := lang.Apply(v27, []any{v30}) -v32 := lang.Apply(v24, []any{v31, v21}) -var v21 any = v32 -_ = v21 -v35 := lang.CreatePersistentTreeSet(lang.NewKeyword("as"), lang.NewKeyword("reload"), lang.NewKeyword("reload-all"), lang.NewKeyword("require"), lang.NewKeyword("use"), lang.NewKeyword("verbose"), lang.NewKeyword("refer"), lang.NewKeyword("as-alias")) -v36 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6002), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(6002), lang.NewKeyword("end-column"), int(86)) -v37, err := lang.WithMeta(v35, v36.(lang.IPersistentMap)) -if err != nil { - panic(err) +v336 = v362 } -var v34 any = v37 -_ = v34 -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("seq")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +return v336 +}) +v304 := v303 +_ = v304 } -v41 := v40.Get() -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("remove")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +v304 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4698), lang.NewKeyword("column"), int(39), lang.NewKeyword("end-line"), int(4710), lang.NewKeyword("end-column"), int(79)) +v305, err := lang.WithMeta(v303, v304.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v44 := v43.Get() -v45 := lang.Apply(v44, []any{v34, v4}) -v46 := lang.Apply(v41, []any{v45}) -var v38 any = v46 -_ = v38 -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("throw-if")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +var v302 any = v305 +_ = v302 +v307 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v308 := v307.FindInternedVar(lang.NewSymbol("seq")) +if v308.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v308))) } -v50 := v49.Get() -v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v52 := v51.FindInternedVar(lang.NewSymbol("apply")) -if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) +v309 := v308.Get() +v310 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v311 := v310.FindInternedVar(lang.NewSymbol("concat")) +if v311.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v311))) } -v53 := v52.Get() -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("str")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +v312 := v311.Get() +v313 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v314 := v313.FindInternedVar(lang.NewSymbol("list")) +if v314.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v314))) } -v56 := v55.Get() -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("interpose")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +v315 := v314.Get() +v316 := lang.Apply(v315, []any{lang.NewSymbol("glojure.core/fn")}) +v317 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v318 := v317.FindInternedVar(lang.NewSymbol("list")) +if v318.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v318))) } -v59 := v58.Get() -v60 := lang.Apply(v59, []any{lang.NewChar(44), v38}) -v61 := lang.Apply(v53, []any{v56, "Unsupported option(s) supplied: ", v60}) -v62 := lang.Apply(v50, []any{v38, v61}) -_ = v62 -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("throw-if")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +v319 := v318.Get() +v320 := lang.Apply(v319, []any{v130}) +v321 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v322 := v321.FindInternedVar(lang.NewSymbol("list")) +if v322.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v322))) } -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("not")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +v323 := v322.Get() +v324 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v325 := v324.FindInternedVar(lang.NewSymbol("apply")) +if v325.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v325))) } -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("seq")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +v326 := v325.Get() +v327 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v328 := v327.FindInternedVar(lang.NewSymbol("vector")) +if v328.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v328))) } -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v21}) -v44 := lang.Apply(v39, []any{v43}) -v45 := lang.Apply(v36, []any{v44, "Nothing specified to load"}) -_ = v45 -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("seq")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +v329 := v328.Get() +v330 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v331 := v330.FindInternedVar(lang.NewSymbol("seq")) +if v331.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v331))) } -v49 := v48.Get() -v50 := lang.Apply(v49, []any{v21}) -var v46 any = v50 -_ = v46 -var v51 any = nil -_ = v51 -var v52 any = int64(0) -_ = v52 -var v53 any = int64(0) -_ = v53 -var v54 any -for { -var v55 any -v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v57 := v56.FindInternedVar(lang.NewSymbol("<")) -if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) +v332 := v331.Get() +v333 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v334 := v333.FindInternedVar(lang.NewSymbol("concat")) +if v334.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v334))) } -v58 := v57.Get() -v59 := lang.Apply(v58, []any{v53, v52}) -if lang.IsTruthy(v59) { -v61, _ := lang.FieldOrMethod(v51, "nth") -if reflect.TypeOf(v61).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) +v335 := v334.Get() +v336 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v337 := v336.FindInternedVar(lang.NewSymbol("list")) +if v337.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v337))) } -v62 := lang.Apply(v61, []any{v53}) -var v60 any = v62 -_ = v60 -var v64 any -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("libspec?")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +v338 := v337.Get() +v339 := lang.Apply(v338, []any{v135}) +v340 := lang.Apply(v335, []any{v339}) +v341 := lang.Apply(v332, []any{v340}) +v342 := lang.Apply(v326, []any{v329, v341}) +v343 := lang.Apply(v323, []any{v342}) +v344 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v345 := v344.FindInternedVar(lang.NewSymbol("list")) +if v345.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v345))) } -v67 := v66.Get() -v68 := lang.Apply(v67, []any{v60}) -if lang.IsTruthy(v68) { -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("apply")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +v346 := v345.Get() +v347 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v348 := v347.FindInternedVar(lang.NewSymbol("seq")) +if v348.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v348))) } -v71 := v70.Get() -v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v73 := v72.FindInternedVar(lang.NewSymbol("load-lib")) -if v73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) +v349 := v348.Get() +v350 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v351 := v350.FindInternedVar(lang.NewSymbol("concat")) +if v351.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v351))) } -v74 := v73.Get() -v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v76 := v75.FindInternedVar(lang.NewSymbol("prependss")) -if v76.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) +v352 := v351.Get() +v353 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v354 := v353.FindInternedVar(lang.NewSymbol("list")) +if v354.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v354))) } -v77 := v76.Get() -v78 := lang.Apply(v77, []any{v60, v12}) -v79 := lang.Apply(v71, []any{v74, nil, v78}) -v64 = v79 -} else { -var v80 any = v60 -_ = v80 -v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v83 := v82.FindInternedVar(lang.NewSymbol("seq")) -if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) +v355 := v354.Get() +v356 := lang.Apply(v355, []any{lang.NewSymbol("glojure.core/lazy-seq")}) +v357 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v358 := v357.FindInternedVar(lang.NewSymbol("list")) +if v358.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v358))) } -v84 := v83.Get() -v85 := lang.Apply(v84, []any{v80}) -var v81 any = v85 -_ = v81 -v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v88 := v87.FindInternedVar(lang.NewSymbol("first")) -if v88.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) +v359 := v358.Get() +v360 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v361 := v360.FindInternedVar(lang.NewSymbol("seq")) +if v361.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v361))) } -v89 := v88.Get() -v90 := lang.Apply(v89, []any{v81}) -var v86 any = v90 -_ = v86 -v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v93 := v92.FindInternedVar(lang.NewSymbol("next")) -if v93.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) +v362 := v361.Get() +v363 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v364 := v363.FindInternedVar(lang.NewSymbol("concat")) +if v364.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v364))) } -v94 := v93.Get() -v95 := lang.Apply(v94, []any{v91}) -var v91 any = v95 -_ = v91 -var v96 any = v86 -_ = v96 -var v97 any = v91 -_ = v97 -v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v100 := v99.FindInternedVar(lang.NewSymbol("throw-if")) -if v100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) +v365 := v364.Get() +v366 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v367 := v366.FindInternedVar(lang.NewSymbol("list")) +if v367.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v367))) } -v101 := v100.Get() -v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v103 := v102.FindInternedVar(lang.NewSymbol("nil?")) -if v103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) +v368 := v367.Get() +v369 := lang.Apply(v368, []any{lang.NewSymbol("glojure.core/loop")}) +v370 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v371 := v370.FindInternedVar(lang.NewSymbol("list")) +if v371.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v371))) } -v104 := v103.Get() -v105 := lang.Apply(v104, []any{v96}) -v106 := lang.Apply(v101, []any{v105, "prefix cannot be nil"}) -_ = v106 -v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v109 := v108.FindInternedVar(lang.NewSymbol("seq")) -if v109.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) +v372 := v371.Get() +v373 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v374 := v373.FindInternedVar(lang.NewSymbol("apply")) +if v374.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v374))) } -v110 := v109.Get() -v111 := lang.Apply(v110, []any{v97}) -var v107 any = v111 -_ = v107 -var v112 any = nil -_ = v112 -var v113 any = int64(0) -_ = v113 -var v114 any = int64(0) -_ = v114 -var v115 any -for { -var v116 any -v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v118 := v117.FindInternedVar(lang.NewSymbol("<")) -if v118.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) +v375 := v374.Get() +v376 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v377 := v376.FindInternedVar(lang.NewSymbol("vector")) +if v377.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v377))) } -v119 := v118.Get() -v120 := lang.Apply(v119, []any{v114, v113}) -if lang.IsTruthy(v120) { -v122, _ := lang.FieldOrMethod(v112, "nth") -if reflect.TypeOf(v122).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) +v378 := v377.Get() +v379 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v380 := v379.FindInternedVar(lang.NewSymbol("seq")) +if v380.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v380))) } -v123 := lang.Apply(v122, []any{v114}) -var v121 any = v123 -_ = v121 -v125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v126 := v125.FindInternedVar(lang.NewSymbol("apply")) -if v126.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v126))) +v381 := v380.Get() +v382 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v383 := v382.FindInternedVar(lang.NewSymbol("concat")) +if v383.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v383))) } -v127 := v126.Get() -v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v129 := v128.FindInternedVar(lang.NewSymbol("load-lib")) -if v129.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v129))) +v384 := v383.Get() +v385 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v386 := v385.FindInternedVar(lang.NewSymbol("list")) +if v386.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v386))) } -v130 := v129.Get() -v131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v132 := v131.FindInternedVar(lang.NewSymbol("prependss")) -if v132.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v132))) +v387 := v386.Get() +v388 := lang.Apply(v387, []any{v135}) +v389 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v390 := v389.FindInternedVar(lang.NewSymbol("list")) +if v390.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v390))) } -v133 := v132.Get() -v134 := lang.Apply(v133, []any{v121, v12}) -v135 := lang.Apply(v127, []any{v130, v96, v134}) -_ = v135 -var v136 any = v107 -var v137 any = v112 -var v138 any = v113 -v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v141 := v140.FindInternedVar(lang.NewSymbol("unchecked-inc")) -if v141.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) +v391 := v390.Get() +v392 := lang.Apply(v391, []any{v135}) +v393 := lang.Apply(v384, []any{v388, v392}) +v394 := lang.Apply(v381, []any{v393}) +v395 := lang.Apply(v375, []any{v378, v394}) +v396 := lang.Apply(v372, []any{v395}) +v397 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v398 := v397.FindInternedVar(lang.NewSymbol("list")) +if v398.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v398))) } -v142 := v141.Get() -v143 := lang.Apply(v142, []any{v114}) -var v139 any = v143 -v107 = v136 -v112 = v137 -v113 = v138 -v114 = v139 -continue -} else { -v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v123 := v122.FindInternedVar(lang.NewSymbol("seq")) -if v123.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) +v399 := v398.Get() +v400 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v401 := v400.FindInternedVar(lang.NewSymbol("seq")) +if v401.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v401))) } -v124 := v123.Get() -v125 := lang.Apply(v124, []any{v107}) -var v121 any = v125 -_ = v121 -var v127 any -if lang.IsTruthy(v121) { -var v128 any = v121 -_ = v128 -var v130 any -v131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v132 := v131.FindInternedVar(lang.NewSymbol("chunked-seq?")) -if v132.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v132))) +v402 := v401.Get() +v403 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v404 := v403.FindInternedVar(lang.NewSymbol("concat")) +if v404.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v404))) } -v133 := v132.Get() -v134 := lang.Apply(v133, []any{v128}) -if lang.IsTruthy(v134) { -v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v137 := v136.FindInternedVar(lang.NewSymbol("chunk-first")) -if v137.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) +v405 := v404.Get() +v406 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v407 := v406.FindInternedVar(lang.NewSymbol("list")) +if v407.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v407))) } -v138 := v137.Get() -v139 := lang.Apply(v138, []any{v128}) -var v135 any = v139 -_ = v135 -v142 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v143 := v142.FindInternedVar(lang.NewSymbol("chunk-rest")) -if v143.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v143))) +v408 := v407.Get() +v409 := lang.Apply(v408, []any{lang.NewSymbol("glojure.core/when-let")}) +v410 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v411 := v410.FindInternedVar(lang.NewSymbol("list")) +if v411.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v411))) } -v144 := v143.Get() -v145 := lang.Apply(v144, []any{v128}) -var v141 any = v145 -var v146 any = v135 -v148 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v149 := v148.FindInternedVar(lang.NewSymbol("int")) -if v149.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v149))) +v412 := v411.Get() +v413 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v414 := v413.FindInternedVar(lang.NewSymbol("apply")) +if v414.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v414))) } -v150 := v149.Get() -v151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v152 := v151.FindInternedVar(lang.NewSymbol("count")) -if v152.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v152))) +v415 := v414.Get() +v416 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v417 := v416.FindInternedVar(lang.NewSymbol("vector")) +if v417.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v417))) } -v153 := v152.Get() -v154 := lang.Apply(v153, []any{v135}) -v155 := lang.Apply(v150, []any{v154}) -var v147 any = v155 -v157 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v158 := v157.FindInternedVar(lang.NewSymbol("int")) -if v158.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v158))) +v418 := v417.Get() +v419 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v420 := v419.FindInternedVar(lang.NewSymbol("seq")) +if v420.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v420))) } -v159 := v158.Get() -v160 := lang.Apply(v159, []any{int64(0)}) -var v156 any = v160 -v107 = v141 -v112 = v146 -v113 = v147 -v114 = v156 -continue -} else { -v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v137 := v136.FindInternedVar(lang.NewSymbol("first")) -if v137.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) +v421 := v420.Get() +v422 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v423 := v422.FindInternedVar(lang.NewSymbol("concat")) +if v423.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v423))) } -v138 := v137.Get() -v139 := lang.Apply(v138, []any{v128}) -var v135 any = v139 -_ = v135 -v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v142 := v141.FindInternedVar(lang.NewSymbol("apply")) -if v142.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) +v424 := v423.Get() +v425 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v426 := v425.FindInternedVar(lang.NewSymbol("list")) +if v426.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v426))) } -v143 := v142.Get() -v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v145 := v144.FindInternedVar(lang.NewSymbol("load-lib")) -if v145.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) +v427 := v426.Get() +v428 := lang.Apply(v427, []any{v135}) +v429 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v430 := v429.FindInternedVar(lang.NewSymbol("list")) +if v430.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v430))) } -v146 := v145.Get() -v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v148 := v147.FindInternedVar(lang.NewSymbol("prependss")) -if v148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) +v431 := v430.Get() +v432 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v433 := v432.FindInternedVar(lang.NewSymbol("seq")) +if v433.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v433))) } -v149 := v148.Get() -v150 := lang.Apply(v149, []any{v135, v12}) -v151 := lang.Apply(v143, []any{v146, v96, v150}) -_ = v151 -v153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v154 := v153.FindInternedVar(lang.NewSymbol("next")) -if v154.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v154))) +v434 := v433.Get() +v435 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v436 := v435.FindInternedVar(lang.NewSymbol("concat")) +if v436.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v436))) } -v155 := v154.Get() -v156 := lang.Apply(v155, []any{v128}) -var v152 any = v156 -var v157 any = nil -var v158 any = int64(0) -var v159 any = int64(0) -v107 = v152 -v112 = v157 -v113 = v158 -v114 = v159 -continue +v437 := v436.Get() +v438 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v439 := v438.FindInternedVar(lang.NewSymbol("list")) +if v439.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v439))) } -v127 = v130 -} else { -v127 = nil +v440 := v439.Get() +v441 := lang.Apply(v440, []any{lang.NewSymbol("glojure.core/seq")}) +v442 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v443 := v442.FindInternedVar(lang.NewSymbol("list")) +if v443.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v443))) } -v116 = v127 +v444 := v443.Get() +v445 := lang.Apply(v444, []any{v135}) +v446 := lang.Apply(v437, []any{v441, v445}) +v447 := lang.Apply(v434, []any{v446}) +v448 := lang.Apply(v431, []any{v447}) +v449 := lang.Apply(v424, []any{v428, v448}) +v450 := lang.Apply(v421, []any{v449}) +v451 := lang.Apply(v415, []any{v418, v450}) +v452 := lang.Apply(v412, []any{v451}) +v453 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v454 := v453.FindInternedVar(lang.NewSymbol("list")) +if v454.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v454))) } -v115 = v116 - break +v455 := v454.Get() +v456 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v457 := v456.FindInternedVar(lang.NewSymbol("seq")) +if v457.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v457))) } -v64 = v115 +v458 := v457.Get() +v459 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v460 := v459.FindInternedVar(lang.NewSymbol("concat")) +if v460.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v460))) } -_ = v64 -var v80 any = v46 -var v81 any = v51 -var v82 any = v52 -v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v85 := v84.FindInternedVar(lang.NewSymbol("unchecked-inc")) -if v85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) +v461 := v460.Get() +v462 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v463 := v462.FindInternedVar(lang.NewSymbol("list")) +if v463.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v463))) } -v86 := v85.Get() -v87 := lang.Apply(v86, []any{v53}) -var v83 any = v87 -v46 = v80 -v51 = v81 -v52 = v82 -v53 = v83 -continue -} else { -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("seq")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +v464 := v463.Get() +v465 := lang.Apply(v464, []any{lang.NewSymbol("if")}) +v466 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v467 := v466.FindInternedVar(lang.NewSymbol("list")) +if v467.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v467))) } -v63 := v62.Get() -v64 := lang.Apply(v63, []any{v46}) -var v60 any = v64 -_ = v60 -var v66 any -if lang.IsTruthy(v60) { -var v67 any = v60 -_ = v67 -var v69 any -v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v71 := v70.FindInternedVar(lang.NewSymbol("chunked-seq?")) -if v71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) +v468 := v467.Get() +v469 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v470 := v469.FindInternedVar(lang.NewSymbol("seq")) +if v470.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v470))) } -v72 := v71.Get() -v73 := lang.Apply(v72, []any{v67}) -if lang.IsTruthy(v73) { -v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v76 := v75.FindInternedVar(lang.NewSymbol("chunk-first")) -if v76.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) +v471 := v470.Get() +v472 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v473 := v472.FindInternedVar(lang.NewSymbol("concat")) +if v473.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v473))) } -v77 := v76.Get() -v78 := lang.Apply(v77, []any{v67}) -var v74 any = v78 -_ = v74 -v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v82 := v81.FindInternedVar(lang.NewSymbol("chunk-rest")) -if v82.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) +v474 := v473.Get() +v475 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v476 := v475.FindInternedVar(lang.NewSymbol("list")) +if v476.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v476))) } -v83 := v82.Get() -v84 := lang.Apply(v83, []any{v67}) -var v80 any = v84 -var v85 any = v74 -v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v88 := v87.FindInternedVar(lang.NewSymbol("int")) -if v88.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) +v477 := v476.Get() +v478 := lang.Apply(v477, []any{lang.NewSymbol("glojure.core/chunked-seq?")}) +v479 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v480 := v479.FindInternedVar(lang.NewSymbol("list")) +if v480.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v480))) } -v89 := v88.Get() -v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v91 := v90.FindInternedVar(lang.NewSymbol("count")) -if v91.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) +v481 := v480.Get() +v482 := lang.Apply(v481, []any{v135}) +v483 := lang.Apply(v474, []any{v478, v482}) +v484 := lang.Apply(v471, []any{v483}) +v485 := lang.Apply(v468, []any{v484}) +v486 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v487 := v486.FindInternedVar(lang.NewSymbol("list")) +if v487.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v487))) } -v92 := v91.Get() -v93 := lang.Apply(v92, []any{v74}) -v94 := lang.Apply(v89, []any{v93}) -var v86 any = v94 -v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v97 := v96.FindInternedVar(lang.NewSymbol("int")) -if v97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) +v488 := v487.Get() +v489 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v490 := v489.FindInternedVar(lang.NewSymbol("seq")) +if v490.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v490))) } -v98 := v97.Get() -v99 := lang.Apply(v98, []any{int64(0)}) -var v95 any = v99 -v46 = v80 -v51 = v85 -v52 = v86 -v53 = v95 -continue -} else { -v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v76 := v75.FindInternedVar(lang.NewSymbol("first")) -if v76.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) +v491 := v490.Get() +v492 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v493 := v492.FindInternedVar(lang.NewSymbol("concat")) +if v493.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v493))) } -v77 := v76.Get() -v78 := lang.Apply(v77, []any{v67}) -var v74 any = v78 -_ = v74 -var v80 any -v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v82 := v81.FindInternedVar(lang.NewSymbol("libspec?")) -if v82.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) +v494 := v493.Get() +v495 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v496 := v495.FindInternedVar(lang.NewSymbol("list")) +if v496.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v496))) } -v83 := v82.Get() -v84 := lang.Apply(v83, []any{v74}) -if lang.IsTruthy(v84) { -v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v86 := v85.FindInternedVar(lang.NewSymbol("apply")) -if v86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) +v497 := v496.Get() +v498 := lang.Apply(v497, []any{lang.NewSymbol("glojure.core/let")}) +v499 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v500 := v499.FindInternedVar(lang.NewSymbol("list")) +if v500.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v500))) } -v87 := v86.Get() -v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v89 := v88.FindInternedVar(lang.NewSymbol("load-lib")) -if v89.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) +v501 := v500.Get() +v502 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v503 := v502.FindInternedVar(lang.NewSymbol("apply")) +if v503.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v503))) } -v90 := v89.Get() -v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v92 := v91.FindInternedVar(lang.NewSymbol("prependss")) -if v92.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) +v504 := v503.Get() +v505 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v506 := v505.FindInternedVar(lang.NewSymbol("vector")) +if v506.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v506))) } -v93 := v92.Get() -v94 := lang.Apply(v93, []any{v74, v12}) -v95 := lang.Apply(v87, []any{v90, nil, v94}) -v80 = v95 -} else { -var v96 any = v74 -_ = v96 -v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v99 := v98.FindInternedVar(lang.NewSymbol("seq")) -if v99.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) +v507 := v506.Get() +v508 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v509 := v508.FindInternedVar(lang.NewSymbol("seq")) +if v509.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v509))) } -v100 := v99.Get() -v101 := lang.Apply(v100, []any{v96}) -var v97 any = v101 -_ = v97 -v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v104 := v103.FindInternedVar(lang.NewSymbol("first")) -if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) +v510 := v509.Get() +v511 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v512 := v511.FindInternedVar(lang.NewSymbol("concat")) +if v512.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v512))) } -v105 := v104.Get() -v106 := lang.Apply(v105, []any{v97}) -var v102 any = v106 -_ = v102 -v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v109 := v108.FindInternedVar(lang.NewSymbol("next")) -if v109.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) +v513 := v512.Get() +v514 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v515 := v514.FindInternedVar(lang.NewSymbol("list")) +if v515.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v515))) } -v110 := v109.Get() -v111 := lang.Apply(v110, []any{v107}) -var v107 any = v111 -_ = v107 -var v112 any = v102 -_ = v112 -var v113 any = v107 -_ = v113 -v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v116 := v115.FindInternedVar(lang.NewSymbol("throw-if")) -if v116.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) +v516 := v515.Get() +v517 := lang.Apply(v516, []any{lang.NewSymbol("c__0__auto__")}) +v518 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v519 := v518.FindInternedVar(lang.NewSymbol("list")) +if v519.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v519))) } -v117 := v116.Get() -v118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v119 := v118.FindInternedVar(lang.NewSymbol("nil?")) -if v119.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v119))) +v520 := v519.Get() +v521 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v522 := v521.FindInternedVar(lang.NewSymbol("seq")) +if v522.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v522))) } -v120 := v119.Get() -v121 := lang.Apply(v120, []any{v112}) -v122 := lang.Apply(v117, []any{v121, "prefix cannot be nil"}) -_ = v122 -v124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v125 := v124.FindInternedVar(lang.NewSymbol("seq")) -if v125.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v125))) +v523 := v522.Get() +v524 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v525 := v524.FindInternedVar(lang.NewSymbol("concat")) +if v525.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v525))) } -v126 := v125.Get() -v127 := lang.Apply(v126, []any{v113}) -var v123 any = v127 -_ = v123 -var v128 any = nil -_ = v128 -var v129 any = int64(0) -_ = v129 -var v130 any = int64(0) -_ = v130 -var v131 any -for { -var v132 any -v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v134 := v133.FindInternedVar(lang.NewSymbol("<")) -if v134.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) -} -v135 := v134.Get() -v136 := lang.Apply(v135, []any{v130, v129}) -if lang.IsTruthy(v136) { -v138, _ := lang.FieldOrMethod(v128, "nth") -if reflect.TypeOf(v138).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) +v526 := v525.Get() +v527 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v528 := v527.FindInternedVar(lang.NewSymbol("list")) +if v528.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v528))) } -v139 := lang.Apply(v138, []any{v130}) -var v137 any = v139 -_ = v137 -v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v142 := v141.FindInternedVar(lang.NewSymbol("apply")) -if v142.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) +v529 := v528.Get() +v530 := lang.Apply(v529, []any{lang.NewSymbol("glojure.core/chunk-first")}) +v531 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v532 := v531.FindInternedVar(lang.NewSymbol("list")) +if v532.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v532))) } -v143 := v142.Get() -v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v145 := v144.FindInternedVar(lang.NewSymbol("load-lib")) -if v145.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) +v533 := v532.Get() +v534 := lang.Apply(v533, []any{v135}) +v535 := lang.Apply(v526, []any{v530, v534}) +v536 := lang.Apply(v523, []any{v535}) +v537 := lang.Apply(v520, []any{v536}) +v538 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v539 := v538.FindInternedVar(lang.NewSymbol("list")) +if v539.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v539))) } -v146 := v145.Get() -v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v148 := v147.FindInternedVar(lang.NewSymbol("prependss")) -if v148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) +v540 := v539.Get() +v541 := lang.Apply(v540, []any{lang.NewSymbol("size__1__auto__")}) +v542 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v543 := v542.FindInternedVar(lang.NewSymbol("list")) +if v543.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v543))) } -v149 := v148.Get() -v150 := lang.Apply(v149, []any{v137, v12}) -v151 := lang.Apply(v143, []any{v146, v112, v150}) -_ = v151 -var v152 any = v123 -var v153 any = v128 -var v154 any = v129 -v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v157 := v156.FindInternedVar(lang.NewSymbol("unchecked-inc")) -if v157.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) +v544 := v543.Get() +v545 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v546 := v545.FindInternedVar(lang.NewSymbol("seq")) +if v546.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v546))) } -v158 := v157.Get() -v159 := lang.Apply(v158, []any{v130}) -var v155 any = v159 -v123 = v152 -v128 = v153 -v129 = v154 -v130 = v155 -continue -} else { -v138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v139 := v138.FindInternedVar(lang.NewSymbol("seq")) -if v139.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v139))) +v547 := v546.Get() +v548 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v549 := v548.FindInternedVar(lang.NewSymbol("concat")) +if v549.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v549))) } -v140 := v139.Get() -v141 := lang.Apply(v140, []any{v123}) -var v137 any = v141 -_ = v137 -var v143 any -if lang.IsTruthy(v137) { -var v144 any = v137 -_ = v144 -var v146 any -v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v148 := v147.FindInternedVar(lang.NewSymbol("chunked-seq?")) -if v148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) +v550 := v549.Get() +v551 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v552 := v551.FindInternedVar(lang.NewSymbol("list")) +if v552.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v552))) } -v149 := v148.Get() -v150 := lang.Apply(v149, []any{v144}) -if lang.IsTruthy(v150) { -v152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v153 := v152.FindInternedVar(lang.NewSymbol("chunk-first")) -if v153.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v153))) +v553 := v552.Get() +v554 := lang.Apply(v553, []any{lang.NewSymbol("glojure.core/int")}) +v555 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v556 := v555.FindInternedVar(lang.NewSymbol("list")) +if v556.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v556))) } -v154 := v153.Get() -v155 := lang.Apply(v154, []any{v144}) -var v151 any = v155 -_ = v151 -v158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v159 := v158.FindInternedVar(lang.NewSymbol("chunk-rest")) -if v159.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v159))) +v557 := v556.Get() +v558 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v559 := v558.FindInternedVar(lang.NewSymbol("seq")) +if v559.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v559))) } -v160 := v159.Get() -v161 := lang.Apply(v160, []any{v144}) -var v157 any = v161 -var v162 any = v151 -v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v165 := v164.FindInternedVar(lang.NewSymbol("int")) -if v165.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) +v560 := v559.Get() +v561 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v562 := v561.FindInternedVar(lang.NewSymbol("concat")) +if v562.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v562))) } -v166 := v165.Get() -v167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v168 := v167.FindInternedVar(lang.NewSymbol("count")) -if v168.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v168))) +v563 := v562.Get() +v564 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v565 := v564.FindInternedVar(lang.NewSymbol("list")) +if v565.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v565))) } -v169 := v168.Get() -v170 := lang.Apply(v169, []any{v151}) -v171 := lang.Apply(v166, []any{v170}) -var v163 any = v171 -v173 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v174 := v173.FindInternedVar(lang.NewSymbol("int")) -if v174.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v174))) +v566 := v565.Get() +v567 := lang.Apply(v566, []any{lang.NewSymbol("glojure.core/count")}) +v568 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v569 := v568.FindInternedVar(lang.NewSymbol("list")) +if v569.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v569))) } -v175 := v174.Get() -v176 := lang.Apply(v175, []any{int64(0)}) -var v172 any = v176 -v123 = v157 -v128 = v162 -v129 = v163 -v130 = v172 -continue -} else { -v152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v153 := v152.FindInternedVar(lang.NewSymbol("first")) -if v153.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v153))) +v570 := v569.Get() +v571 := lang.Apply(v570, []any{lang.NewSymbol("c__0__auto__")}) +v572 := lang.Apply(v563, []any{v567, v571}) +v573 := lang.Apply(v560, []any{v572}) +v574 := lang.Apply(v557, []any{v573}) +v575 := lang.Apply(v550, []any{v554, v574}) +v576 := lang.Apply(v547, []any{v575}) +v577 := lang.Apply(v544, []any{v576}) +v578 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v579 := v578.FindInternedVar(lang.NewSymbol("list")) +if v579.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v579))) } -v154 := v153.Get() -v155 := lang.Apply(v154, []any{v144}) -var v151 any = v155 -_ = v151 -v157 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v158 := v157.FindInternedVar(lang.NewSymbol("apply")) -if v158.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v158))) +v580 := v579.Get() +v581 := lang.Apply(v580, []any{v297}) +v582 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v583 := v582.FindInternedVar(lang.NewSymbol("list")) +if v583.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v583))) } -v159 := v158.Get() -v160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v161 := v160.FindInternedVar(lang.NewSymbol("load-lib")) -if v161.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v161))) +v584 := v583.Get() +v585 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v586 := v585.FindInternedVar(lang.NewSymbol("seq")) +if v586.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v586))) } -v162 := v161.Get() -v163 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v164 := v163.FindInternedVar(lang.NewSymbol("prependss")) -if v164.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v164))) +v587 := v586.Get() +v588 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v589 := v588.FindInternedVar(lang.NewSymbol("concat")) +if v589.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v589))) } -v165 := v164.Get() -v166 := lang.Apply(v165, []any{v151, v12}) -v167 := lang.Apply(v159, []any{v162, v112, v166}) -_ = v167 -v169 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v170 := v169.FindInternedVar(lang.NewSymbol("next")) -if v170.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v170))) +v590 := v589.Get() +v591 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v592 := v591.FindInternedVar(lang.NewSymbol("list")) +if v592.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v592))) } -v171 := v170.Get() -v172 := lang.Apply(v171, []any{v144}) -var v168 any = v172 -var v173 any = nil -var v174 any = int64(0) -var v175 any = int64(0) -v123 = v168 -v128 = v173 -v129 = v174 -v130 = v175 -continue +v593 := v592.Get() +v594 := lang.Apply(v593, []any{lang.NewSymbol("glojure.core/chunk-buffer")}) +v595 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v596 := v595.FindInternedVar(lang.NewSymbol("list")) +if v596.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v596))) } -v143 = v146 -} else { -v143 = nil +v597 := v596.Get() +v598 := lang.Apply(v597, []any{lang.NewSymbol("size__1__auto__")}) +v599 := lang.Apply(v590, []any{v594, v598}) +v600 := lang.Apply(v587, []any{v599}) +v601 := lang.Apply(v584, []any{v600}) +v602 := lang.Apply(v513, []any{v517, v537, v541, v577, v581, v601}) +v603 := lang.Apply(v510, []any{v602}) +v604 := lang.Apply(v504, []any{v507, v603}) +v605 := lang.Apply(v501, []any{v604}) +v606 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v607 := v606.FindInternedVar(lang.NewSymbol("list")) +if v607.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v607))) } -v132 = v143 +v608 := v607.Get() +v609 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v610 := v609.FindInternedVar(lang.NewSymbol("seq")) +if v610.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v610))) } -v131 = v132 - break +v611 := v610.Get() +v612 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v613 := v612.FindInternedVar(lang.NewSymbol("concat")) +if v613.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v613))) } -v80 = v131 +v614 := v613.Get() +v615 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v616 := v615.FindInternedVar(lang.NewSymbol("list")) +if v616.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v616))) } -_ = v80 -v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v98 := v97.FindInternedVar(lang.NewSymbol("next")) -if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) +v617 := v616.Get() +v618 := lang.Apply(v617, []any{lang.NewSymbol("if")}) +v619 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v620 := v619.FindInternedVar(lang.NewSymbol("list")) +if v620.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v620))) } -v99 := v98.Get() -v100 := lang.Apply(v99, []any{v67}) -var v96 any = v100 -var v101 any = nil -var v102 any = int64(0) -var v103 any = int64(0) -v46 = v96 -v51 = v101 -v52 = v102 -v53 = v103 -continue +v621 := v620.Get() +v622 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v623 := v622.FindInternedVar(lang.NewSymbol("seq")) +if v623.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v623))) } -v66 = v69 -} else { -v66 = nil +v624 := v623.Get() +v625 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v626 := v625.FindInternedVar(lang.NewSymbol("concat")) +if v626.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v626))) } -v55 = v66 +v627 := v626.Get() +v628 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v629 := v628.FindInternedVar(lang.NewSymbol("list")) +if v629.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v629))) } -v54 = v55 - break +v630 := v629.Get() +v631 := lang.Apply(v630, []any{lang.NewSymbol("glojure.core/loop")}) +v632 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v633 := v632.FindInternedVar(lang.NewSymbol("list")) +if v633.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v633))) } -return v54 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v634 := v633.Get() +v635 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v636 := v635.FindInternedVar(lang.NewSymbol("apply")) +if v636.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v636))) } +v637 := v636.Get() +v638 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v639 := v638.FindInternedVar(lang.NewSymbol("vector")) +if v639.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v639))) } -// replicate -{ -v0 := lang.NewSymbol("replicate").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "DEPRECATED: Use 'repeat' instead.\n Returns a lazy seq of n xs.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("deprecated"), "1.3", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3004), lang.NewKeyword("end-line"), int(3004))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("take")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v640 := v639.Get() +v641 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v642 := v641.FindInternedVar(lang.NewSymbol("seq")) +if v642.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v642))) } -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("repeat")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v643 := v642.Get() +v644 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v645 := v644.FindInternedVar(lang.NewSymbol("concat")) +if v645.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v645))) } -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v4}) -v12 := lang.Apply(v7, []any{v3, v11}) -return v12 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v646 := v645.Get() +v647 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v648 := v647.FindInternedVar(lang.NewSymbol("list")) +if v648.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v648))) } +v649 := v648.Get() +v650 := lang.Apply(v649, []any{v292}) +v651 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v652 := v651.FindInternedVar(lang.NewSymbol("list")) +if v652.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v652))) } -// prefers -{ -v0 := lang.NewSymbol("prefers").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"))), lang.NewKeyword("doc"), "Given a multimethod, returns a map of preferred value -> set of other values", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1822), lang.NewKeyword("end-line"), int(1822))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, ok := lang.FieldOrMethod(v3, "getPreferTable") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getPreferTable"))) +v653 := v652.Get() +v654 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v655 := v654.FindInternedVar(lang.NewSymbol("seq")) +if v655.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v655))) } -var v5 any -switch reflect.TypeOf(v4).Kind() { -case reflect.Func: - v5 = lang.Apply(v4, nil) -default: - v5 = v4 +v656 := v655.Get() +v657 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v658 := v657.FindInternedVar(lang.NewSymbol("concat")) +if v658.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v658))) } -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v659 := v658.Get() +v660 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v661 := v660.FindInternedVar(lang.NewSymbol("list")) +if v661.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v661))) } +v662 := v661.Get() +v663 := lang.Apply(v662, []any{lang.NewSymbol("glojure.core/int")}) +v664 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v665 := v664.FindInternedVar(lang.NewSymbol("list")) +if v665.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v665))) } -// - -{ -var v1 lang.FnFunc -v1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v2 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v666 := v665.Get() +v667 := lang.Apply(v666, []any{int64(0)}) +v668 := lang.Apply(v659, []any{v663, v667}) +v669 := lang.Apply(v656, []any{v668}) +v670 := lang.Apply(v653, []any{v669}) +v671 := lang.Apply(v646, []any{v650, v670}) +v672 := lang.Apply(v643, []any{v671}) +v673 := lang.Apply(v637, []any{v640, v672}) +v674 := lang.Apply(v634, []any{v673}) +v675 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v676 := v675.FindInternedVar(lang.NewSymbol("list")) +if v676.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v676))) } -v7 := v6.Get() -if lang.IsTruthy(v7) { -v4 = closed6 -} else { -v4 = v3 +v677 := v676.Get() +v678 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v679 := v678.FindInternedVar(lang.NewSymbol("seq")) +if v679.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v679))) } -var v3 any = v4 -_ = v3 -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("seq")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +v680 := v679.Get() +v681 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v682 := v681.FindInternedVar(lang.NewSymbol("concat")) +if v682.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v682))) } -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("concat")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +v683 := v682.Get() +v684 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v685 := v684.FindInternedVar(lang.NewSymbol("list")) +if v685.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v685))) } -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +v686 := v685.Get() +v687 := lang.Apply(v686, []any{lang.NewSymbol("if")}) +v688 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v689 := v688.FindInternedVar(lang.NewSymbol("list")) +if v689.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v689))) } -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v690 := v689.Get() +v691 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v692 := v691.FindInternedVar(lang.NewSymbol("seq")) +if v692.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v692))) } -v21 := v20.Get() -v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +v693 := v692.Get() +v694 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v695 := v694.FindInternedVar(lang.NewSymbol("concat")) +if v695.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v695))) } -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("seq")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +v696 := v695.Get() +v697 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v698 := v697.FindInternedVar(lang.NewSymbol("list")) +if v698.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v698))) } -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("concat")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +v699 := v698.Get() +v700 := lang.Apply(v699, []any{lang.NewSymbol("glojure.core/<")}) +v701 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v702 := v701.FindInternedVar(lang.NewSymbol("list")) +if v702.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v702))) } -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +v703 := v702.Get() +v704 := lang.Apply(v703, []any{v292}) +v705 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v706 := v705.FindInternedVar(lang.NewSymbol("list")) +if v706.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v706))) } -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +v707 := v706.Get() +v708 := lang.Apply(v707, []any{lang.NewSymbol("size__1__auto__")}) +v709 := lang.Apply(v696, []any{v700, v704, v708}) +v710 := lang.Apply(v693, []any{v709}) +v711 := lang.Apply(v690, []any{v710}) +v712 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v713 := v712.FindInternedVar(lang.NewSymbol("list")) +if v713.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v713))) } -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v2}) -v40 := lang.Apply(v31, []any{v35, v39}) -v41 := lang.Apply(v28, []any{v40}) -v42 := lang.Apply(v25, []any{v41}) -v43 := lang.Apply(v14, []any{v18, v22, v42}) -v44 := lang.Apply(v11, []any{v43}) -return v44 - case 2: -v2 := args[0] -v3 := args[1] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +v714 := v713.Get() +v715 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v716 := v715.FindInternedVar(lang.NewSymbol("seq")) +if v716.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v716))) } -v8 := v7.Get() -if lang.IsTruthy(v8) { -v5 = closed6 -} else { -v5 = v4 +v717 := v716.Get() +v718 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v719 := v718.FindInternedVar(lang.NewSymbol("concat")) +if v719.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v719))) } -var v4 any = v5 -_ = v4 -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("seq")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v720 := v719.Get() +v721 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v722 := v721.FindInternedVar(lang.NewSymbol("list")) +if v722.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v722))) } -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("concat")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +v723 := v722.Get() +v724 := lang.Apply(v723, []any{lang.NewSymbol("glojure.core/let")}) +v725 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v726 := v725.FindInternedVar(lang.NewSymbol("list")) +if v726.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v726))) } -v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("list")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +v727 := v726.Get() +v728 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v729 := v728.FindInternedVar(lang.NewSymbol("apply")) +if v729.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v729))) } -v18 := v17.Get() -v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("list")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +v730 := v729.Get() +v731 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v732 := v731.FindInternedVar(lang.NewSymbol("vector")) +if v732.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v732))) } -v22 := v21.Get() -v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("list")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +v733 := v732.Get() +v734 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v735 := v734.FindInternedVar(lang.NewSymbol("seq")) +if v735.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v735))) } -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("seq")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v736 := v735.Get() +v737 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v738 := v737.FindInternedVar(lang.NewSymbol("concat")) +if v738.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v738))) } -v29 := v28.Get() -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("concat")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +v739 := v738.Get() +v740 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v741 := v740.FindInternedVar(lang.NewSymbol("list")) +if v741.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v741))) } -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("list")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +v742 := v741.Get() +v743 := lang.Apply(v742, []any{v99}) +v744 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v745 := v744.FindInternedVar(lang.NewSymbol("list")) +if v745.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v745))) } -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v4}) -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("list")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +v746 := v745.Get() +v747 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v748 := v747.FindInternedVar(lang.NewSymbol("seq")) +if v748.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v748))) } -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v2}) -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("list")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +v749 := v748.Get() +v750 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v751 := v750.FindInternedVar(lang.NewSymbol("concat")) +if v751.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v751))) } -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v3}) -v45 := lang.Apply(v32, []any{v36, v40, v44}) -v46 := lang.Apply(v29, []any{v45}) -v47 := lang.Apply(v26, []any{v46}) -v48 := lang.Apply(v15, []any{v19, v23, v47}) -v49 := lang.Apply(v12, []any{v48}) -return v49 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v2 := args[0] -v3 := args[1] -v4 := lang.NewList(args[2:]...) -var v6 any -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v752 := v751.Get() +v753 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v754 := v753.FindInternedVar(lang.NewSymbol("list")) +if v754.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v754))) } -v9 := v8.Get() -if lang.IsTruthy(v9) { -v6 = closed6 -} else { -v6 = v5 +v755 := v754.Get() +v756 := lang.Apply(v755, []any{lang.NewSymbol(".nth")}) +v757 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v758 := v757.FindInternedVar(lang.NewSymbol("list")) +if v758.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v758))) } -var v5 any = v6 -_ = v5 -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v759 := v758.Get() +v760 := lang.Apply(v759, []any{lang.NewSymbol("c__0__auto__")}) +v761 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v762 := v761.FindInternedVar(lang.NewSymbol("list")) +if v762.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v762))) } -v13 := v12.Get() -var v14 lang.FnFunc -v14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v15 := args[0] -v16 := args[1] -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +v763 := v762.Get() +v764 := lang.Apply(v763, []any{v292}) +v765 := lang.Apply(v752, []any{v756, v760, v764}) +v766 := lang.Apply(v749, []any{v765}) +v767 := lang.Apply(v746, []any{v766}) +v768 := lang.Apply(v739, []any{v743, v767}) +v769 := lang.Apply(v736, []any{v768}) +v770 := lang.Apply(v730, []any{v733, v769}) +v771 := lang.Apply(v727, []any{v770}) +v772 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v773 := v772.FindInternedVar(lang.NewSymbol("list")) +if v773.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v773))) } -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("concat")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +v774 := v773.Get() +v775 := lang.Apply(v302, []any{v111}) +v776 := lang.Apply(v774, []any{v775}) +v777 := lang.Apply(v720, []any{v724, v771, v776}) +v778 := lang.Apply(v717, []any{v777}) +v779 := lang.Apply(v714, []any{v778}) +v780 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v781 := v780.FindInternedVar(lang.NewSymbol("list")) +if v781.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v781))) } -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +v782 := v781.Get() +v783 := lang.Apply(v782, []any{true}) +v784 := lang.Apply(v683, []any{v687, v711, v779, v783}) +v785 := lang.Apply(v680, []any{v784}) +v786 := lang.Apply(v677, []any{v785}) +v787 := lang.Apply(v627, []any{v631, v674, v786}) +v788 := lang.Apply(v624, []any{v787}) +v789 := lang.Apply(v621, []any{v788}) +v790 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v791 := v790.FindInternedVar(lang.NewSymbol("list")) +if v791.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v791))) } -v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v792 := v791.Get() +v793 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v794 := v793.FindInternedVar(lang.NewSymbol("seq")) +if v794.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v794))) } -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v795 := v794.Get() +v796 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v797 := v796.FindInternedVar(lang.NewSymbol("concat")) +if v797.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v797))) } -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +v798 := v797.Get() +v799 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v800 := v799.FindInternedVar(lang.NewSymbol("list")) +if v800.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v800))) } -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +v801 := v800.Get() +v802 := lang.Apply(v801, []any{lang.NewSymbol("glojure.core/chunk-cons")}) +v803 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v804 := v803.FindInternedVar(lang.NewSymbol("list")) +if v804.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v804))) } -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +v805 := v804.Get() +v806 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v807 := v806.FindInternedVar(lang.NewSymbol("seq")) +if v807.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v807))) } -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v5}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +v808 := v807.Get() +v809 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v810 := v809.FindInternedVar(lang.NewSymbol("concat")) +if v810.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v810))) } -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v15}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +v811 := v810.Get() +v812 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v813 := v812.FindInternedVar(lang.NewSymbol("list")) +if v813.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v813))) } -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v16}) -v52 := lang.Apply(v39, []any{v43, v47, v51}) -v53 := lang.Apply(v36, []any{v52}) -v54 := lang.Apply(v33, []any{v53}) -v55 := lang.Apply(v22, []any{v26, v30, v54}) -v56 := lang.Apply(v19, []any{v55}) -return v56 -}) -v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) -v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) -if err != nil { - panic(err) +v814 := v813.Get() +v815 := lang.Apply(v814, []any{lang.NewSymbol("glojure.core/chunk")}) +v816 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v817 := v816.FindInternedVar(lang.NewSymbol("list")) +if v817.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v817))) } -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +v818 := v817.Get() +v819 := lang.Apply(v818, []any{v297}) +v820 := lang.Apply(v811, []any{v815, v819}) +v821 := lang.Apply(v808, []any{v820}) +v822 := lang.Apply(v805, []any{v821}) +v823 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v824 := v823.FindInternedVar(lang.NewSymbol("list")) +if v824.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v824))) } -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("concat")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +v825 := v824.Get() +v826 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v827 := v826.FindInternedVar(lang.NewSymbol("seq")) +if v827.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v827))) } -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +v828 := v827.Get() +v829 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v830 := v829.FindInternedVar(lang.NewSymbol("concat")) +if v830.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v830))) } -v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v831 := v830.Get() +v832 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v833 := v832.FindInternedVar(lang.NewSymbol("list")) +if v833.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v833))) } -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v834 := v833.Get() +v835 := lang.Apply(v834, []any{v130}) +v836 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v837 := v836.FindInternedVar(lang.NewSymbol("list")) +if v837.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v837))) } -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +v838 := v837.Get() +v839 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v840 := v839.FindInternedVar(lang.NewSymbol("seq")) +if v840.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v840))) } -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +v841 := v840.Get() +v842 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v843 := v842.FindInternedVar(lang.NewSymbol("concat")) +if v843.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v843))) } -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +v844 := v843.Get() +v845 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v846 := v845.FindInternedVar(lang.NewSymbol("list")) +if v846.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v846))) } -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v5}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +v847 := v846.Get() +v848 := lang.Apply(v847, []any{lang.NewSymbol("glojure.core/chunk-rest")}) +v849 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v850 := v849.FindInternedVar(lang.NewSymbol("list")) +if v850.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v850))) } -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v2}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +v851 := v850.Get() +v852 := lang.Apply(v851, []any{v135}) +v853 := lang.Apply(v844, []any{v848, v852}) +v854 := lang.Apply(v841, []any{v853}) +v855 := lang.Apply(v838, []any{v854}) +v856 := lang.Apply(v831, []any{v835, v855}) +v857 := lang.Apply(v828, []any{v856}) +v858 := lang.Apply(v825, []any{v857}) +v859 := lang.Apply(v798, []any{v802, v822, v858}) +v860 := lang.Apply(v795, []any{v859}) +v861 := lang.Apply(v792, []any{v860}) +v862 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v863 := v862.FindInternedVar(lang.NewSymbol("list")) +if v863.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v863))) } -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v3}) -v52 := lang.Apply(v39, []any{v43, v47, v51}) -v53 := lang.Apply(v36, []any{v52}) -v54 := lang.Apply(v33, []any{v53}) -v55 := lang.Apply(v22, []any{v26, v30, v54}) -v56 := lang.Apply(v19, []any{v55}) -v57 := lang.Apply(v13, []any{v16, v56, v4}) -return v57 - } -}) -v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) +v864 := v863.Get() +v865 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v866 := v865.FindInternedVar(lang.NewSymbol("seq")) +if v866.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v866))) } -v5 := lang.Apply(v4, []any{v3, int64(0)}) -return v5 +v867 := v866.Get() +v868 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v869 := v868.FindInternedVar(lang.NewSymbol("concat")) +if v869.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v869))) +} +v870 := v869.Get() +v871 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v872 := v871.FindInternedVar(lang.NewSymbol("list")) +if v872.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v872))) +} +v873 := v872.Get() +v874 := lang.Apply(v873, []any{lang.NewSymbol("glojure.core/chunk-cons")}) +v875 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v876 := v875.FindInternedVar(lang.NewSymbol("list")) +if v876.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v876))) +} +v877 := v876.Get() +v878 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v879 := v878.FindInternedVar(lang.NewSymbol("seq")) +if v879.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v879))) +} +v880 := v879.Get() +v881 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v882 := v881.FindInternedVar(lang.NewSymbol("concat")) +if v882.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v882))) +} +v883 := v882.Get() +v884 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v885 := v884.FindInternedVar(lang.NewSymbol("list")) +if v885.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v885))) +} +v886 := v885.Get() +v887 := lang.Apply(v886, []any{lang.NewSymbol("glojure.core/chunk")}) +v888 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v889 := v888.FindInternedVar(lang.NewSymbol("list")) +if v889.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v889))) +} +v890 := v889.Get() +v891 := lang.Apply(v890, []any{v297}) +v892 := lang.Apply(v883, []any{v887, v891}) +v893 := lang.Apply(v880, []any{v892}) +v894 := lang.Apply(v877, []any{v893}) +v895 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v896 := v895.FindInternedVar(lang.NewSymbol("list")) +if v896.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v896))) +} +v897 := v896.Get() +v898 := lang.Apply(v897, []any{nil}) +v899 := lang.Apply(v870, []any{v874, v894, v898}) +v900 := lang.Apply(v867, []any{v899}) +v901 := lang.Apply(v864, []any{v900}) +v902 := lang.Apply(v614, []any{v618, v789, v861, v901}) +v903 := lang.Apply(v611, []any{v902}) +v904 := lang.Apply(v608, []any{v903}) +v905 := lang.Apply(v494, []any{v498, v605, v904}) +v906 := lang.Apply(v491, []any{v905}) +v907 := lang.Apply(v488, []any{v906}) +v908 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v909 := v908.FindInternedVar(lang.NewSymbol("list")) +if v909.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v909))) +} +v910 := v909.Get() +v911 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v912 := v911.FindInternedVar(lang.NewSymbol("seq")) +if v912.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v912))) +} +v913 := v912.Get() +v914 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v915 := v914.FindInternedVar(lang.NewSymbol("concat")) +if v915.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v915))) +} +v916 := v915.Get() +v917 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v918 := v917.FindInternedVar(lang.NewSymbol("list")) +if v918.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v918))) +} +v919 := v918.Get() +v920 := lang.Apply(v919, []any{lang.NewSymbol("glojure.core/let")}) +v921 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v922 := v921.FindInternedVar(lang.NewSymbol("list")) +if v922.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v922))) +} +v923 := v922.Get() +v924 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v925 := v924.FindInternedVar(lang.NewSymbol("apply")) +if v925.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v925))) +} +v926 := v925.Get() +v927 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v928 := v927.FindInternedVar(lang.NewSymbol("vector")) +if v928.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v928))) +} +v929 := v928.Get() +v930 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v931 := v930.FindInternedVar(lang.NewSymbol("seq")) +if v931.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v931))) +} +v932 := v931.Get() +v933 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v934 := v933.FindInternedVar(lang.NewSymbol("concat")) +if v934.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v934))) +} +v935 := v934.Get() +v936 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v937 := v936.FindInternedVar(lang.NewSymbol("list")) +if v937.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v937))) +} +v938 := v937.Get() +v939 := lang.Apply(v938, []any{v99}) +v940 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v941 := v940.FindInternedVar(lang.NewSymbol("list")) +if v941.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v941))) +} +v942 := v941.Get() +v943 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v944 := v943.FindInternedVar(lang.NewSymbol("seq")) +if v944.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v944))) +} +v945 := v944.Get() +v946 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v947 := v946.FindInternedVar(lang.NewSymbol("concat")) +if v947.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v947))) +} +v948 := v947.Get() +v949 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v950 := v949.FindInternedVar(lang.NewSymbol("list")) +if v950.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v950))) +} +v951 := v950.Get() +v952 := lang.Apply(v951, []any{lang.NewSymbol("glojure.core/first")}) +v953 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v954 := v953.FindInternedVar(lang.NewSymbol("list")) +if v954.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v954))) +} +v955 := v954.Get() +v956 := lang.Apply(v955, []any{v135}) +v957 := lang.Apply(v948, []any{v952, v956}) +v958 := lang.Apply(v945, []any{v957}) +v959 := lang.Apply(v942, []any{v958}) +v960 := lang.Apply(v935, []any{v939, v959}) +v961 := lang.Apply(v932, []any{v960}) +v962 := lang.Apply(v926, []any{v929, v961}) +v963 := lang.Apply(v923, []any{v962}) +v964 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v965 := v964.FindInternedVar(lang.NewSymbol("list")) +if v965.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v965))) +} +v966 := v965.Get() +v967 := lang.Apply(v140, []any{v111}) +v968 := lang.Apply(v966, []any{v967}) +v969 := lang.Apply(v916, []any{v920, v963, v968}) +v970 := lang.Apply(v913, []any{v969}) +v971 := lang.Apply(v910, []any{v970}) +v972 := lang.Apply(v461, []any{v465, v485, v907, v971}) +v973 := lang.Apply(v458, []any{v972}) +v974 := lang.Apply(v455, []any{v973}) +v975 := lang.Apply(v405, []any{v409, v452, v974}) +v976 := lang.Apply(v402, []any{v975}) +v977 := lang.Apply(v399, []any{v976}) +v978 := lang.Apply(v365, []any{v369, v396, v977}) +v979 := lang.Apply(v362, []any{v978}) +v980 := lang.Apply(v359, []any{v979}) +v981 := lang.Apply(v352, []any{v356, v980}) +v982 := lang.Apply(v349, []any{v981}) +v983 := lang.Apply(v346, []any{v982}) +v984 := lang.Apply(v312, []any{v316, v320, v343, v983}) +v985 := lang.Apply(v309, []any{v984}) +v145 = v985 +} +return v145 }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v0 := lang.NewSymbol("-").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "If no ys are supplied, returns the negation of x, else subtracts\n the ys from x and returns the result. Does not auto-promote\n longs, will throw on overflow. See also: -'", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1036), lang.NewKeyword("end-line"), int(1036))).(*lang.Symbol) -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v5 := args[0] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("*")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +v65 := v64 +_ = v65 } -v8 := v7.Get() -v9 := lang.Apply(v8, []any{int64(-1), v5}) -return v9 - case 2: -v5 := args[0] -v6 := args[1] -v7, _ := lang.FieldOrMethod(lang1.Numbers, "minus") -if reflect.TypeOf(v7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("minus is not a function"))) +v65 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4668), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(4729), lang.NewKeyword("end-column"), int(68)) +v66, err := lang.WithMeta(v64, v65.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v8 := lang.Apply(v7, []any{v5, v6}) -return v8 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := args[0] -v6 := args[1] -v7 := lang.NewList(args[2:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +var v63 any = v66 +_ = v63 +v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v69 := v68.FindInternedVar(lang.NewSymbol("seq")) +if v69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) } -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("-")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v70 := v69.Get() +v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v72 := v71.FindInternedVar(lang.NewSymbol("concat")) +if v72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) } -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("-")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v73 := v72.Get() +v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v75 := v74.FindInternedVar(lang.NewSymbol("list")) +if v75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v5, v6}) -v18 := lang.Apply(v10, []any{v13, v17, v7}) -return v18 - } +v76 := v75.Get() +v77 := lang.Apply(v76, []any{lang.NewSymbol("glojure.core/let")}) +v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v79 := v78.FindInternedVar(lang.NewSymbol("list")) +if v79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) +} +v80 := v79.Get() +v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v82 := v81.FindInternedVar(lang.NewSymbol("apply")) +if v82.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) +} +v83 := v82.Get() +v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v85 := v84.FindInternedVar(lang.NewSymbol("vector")) +if v85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) +} +v86 := v85.Get() +v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v88 := v87.FindInternedVar(lang.NewSymbol("seq")) +if v88.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) +} +v89 := v88.Get() +v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v91 := v90.FindInternedVar(lang.NewSymbol("concat")) +if v91.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) +} +v92 := v91.Get() +v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v94 := v93.FindInternedVar(lang.NewSymbol("list")) +if v94.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) +} +v95 := v94.Get() +v96 := lang.Apply(v95, []any{lang.NewSymbol("iter__0__auto__")}) +v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v98 := v97.FindInternedVar(lang.NewSymbol("list")) +if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) +} +v99 := v98.Get() +v100 := lang.Apply(v55, []any{v5}) +v101 := lang.Apply(v63, []any{v100}) +v102 := lang.Apply(v99, []any{v101}) +v103 := lang.Apply(v92, []any{v96, v102}) +v104 := lang.Apply(v89, []any{v103}) +v105 := lang.Apply(v83, []any{v86, v104}) +v106 := lang.Apply(v80, []any{v105}) +v107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v108 := v107.FindInternedVar(lang.NewSymbol("list")) +if v108.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v108))) +} +v109 := v108.Get() +v110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v111 := v110.FindInternedVar(lang.NewSymbol("seq")) +if v111.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v111))) +} +v112 := v111.Get() +v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v114 := v113.FindInternedVar(lang.NewSymbol("concat")) +if v114.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) +} +v115 := v114.Get() +v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v117 := v116.FindInternedVar(lang.NewSymbol("list")) +if v117.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) +} +v118 := v117.Get() +v119 := lang.Apply(v118, []any{lang.NewSymbol("iter__0__auto__")}) +v120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v121 := v120.FindInternedVar(lang.NewSymbol("list")) +if v121.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v121))) +} +v122 := v121.Get() +v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v124 := v123.FindInternedVar(lang.NewSymbol("second")) +if v124.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) +} +v125 := v124.Get() +v126 := lang.Apply(v125, []any{v5}) +v127 := lang.Apply(v122, []any{v126}) +v128 := lang.Apply(v115, []any{v119, v127}) +v129 := lang.Apply(v112, []any{v128}) +v130 := lang.Apply(v109, []any{v129}) +v131 := lang.Apply(v73, []any{v77, v106, v130}) +v132 := lang.Apply(v70, []any{v131}) +return v132 }) -v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v3 := ns.InternWithValue(v0, v4, true) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { - v3.SetMeta(v0.Meta().(lang.IPersistentMap)) + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// with-meta +// force { -v0 := lang.NewSymbol("with-meta").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("obj"), lang.NewSymbol("m"))), lang.NewKeyword("doc"), "Returns an object of the same type and value as obj, with\n map m as its metadata.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(211), lang.NewKeyword("end-line"), int(216))).(*lang.Symbol) +v0 := lang.NewSymbol("force").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "If x is a Delay, returns the (possibly cached) value of its expression, else returns x", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(754), lang.NewKeyword("end-line"), int(754))).(*lang.Symbol) var v2 lang.FnFunc -{ // function with-meta v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v4 := args[0] -v5 := args[1] -v6, _ := lang.FieldOrMethod(v4, "WithMeta") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("WithMeta is not a function"))) +v3 := args[0] +v4, _ := lang.FieldOrMethod(glojure.lang8.Delay, "force") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("force is not a function"))) } -v7 := lang.Apply(v6, []any{v5}) -return v7 +v5 := lang.Apply(v4, []any{v3}) +return v5 }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(216), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(217), lang.NewKeyword("end-column"), int(32))).(lang.FnFunc) -v3 := v2 -_ = v3 -} +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// aset-byte +// format { -v0 := lang.NewSymbol("aset-byte").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of byte. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3976), lang.NewKeyword("end-line"), int(3978))).(*lang.Symbol) +v0 := lang.NewSymbol("format").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fmt"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Formats a string using java.lang.String.format, see java.util.Formatter for format\n string syntax", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5760), lang.NewKeyword("end-line"), int(5760))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("byte")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v5}) -v10, _ := lang.FieldOrMethod(nil, "setByte") -if reflect.TypeOf(v10).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setByte is not a function"))) -} -v11 := lang.Apply(v10, []any{v3, v4, v9}) -_ = v11 -return v5 default: - if len(args) < 3 { + if len(args) < 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("apply")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("aset-byte")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("aget")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +v4 := lang.NewList(args[1:]...) +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("apply")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v3, v4}) -v17 := lang.Apply(v9, []any{v12, v16, v5, v6}) -return v17 +v7 := v6.Get() +v8 := lang.Apply(v7, []any{fmt.Sprintf, v3, v4}) +return v8 } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -40688,9 +38436,9 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// flatten +// frequencies { -v0 := lang.NewSymbol("flatten").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Takes any nested combination of sequential things (lists, vectors,\n etc.) and returns their contents as a single, flat lazy sequence.\n (flatten nil) returns an empty sequence.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7161), lang.NewKeyword("end-line"), int(7161))).(*lang.Symbol) +v0 := lang.NewSymbol("frequencies").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a map from distinct items in coll to the number of times\n they appear.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7228), lang.NewKeyword("end-line"), int(7228))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -40698,81 +38446,68 @@ v2 = lang.NewFnFunc(func(args ...any) any { } v3 := args[0] v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("filter")) +v5 := v4.FindInternedVar(lang.NewSymbol("persistent!")) if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("complement")) +v8 := v7.FindInternedVar(lang.NewSymbol("reduce")) if v8.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("sequential?")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v9, []any{v12}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("rest")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("tree-seq")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +var v10 lang.FnFunc +v10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v11 := args[0] +v12 := args[1] +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("assoc!")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("sequential?")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +v15 := v14.Get() +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("inc")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("seq")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +v18 := v17.Get() +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("get")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v25 := v24.Get() -v26 := lang.Apply(v19, []any{v22, v25, v3}) -v27 := lang.Apply(v16, []any{v26}) -v28 := lang.Apply(v6, []any{v13, v27}) -return v28 +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v11, v12, int64(0)}) +v23 := lang.Apply(v18, []any{v22}) +v24 := lang.Apply(v15, []any{v11, v12, v23}) +return v24 }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7235), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(7236), lang.NewKeyword("end-column"), int(54)) +v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) +if err != nil { + panic(err) } +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("transient")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } -// future-call -{ -v0 := lang.NewSymbol("future-call").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Takes a function of no args and yields a future object that will\n invoke the function in another thread, and will cache the result and\n return it on all subsequent calls to deref/@. If the computation has\n not yet finished, calls to deref/@ will block, unless the variant\n of deref with timeout is used. See also - realized?.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7046), lang.NewKeyword("end-line"), int(7046))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("binding-conveyor-fn")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v15 := v14.Get() +v16 := lang.NewMap() +v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7237), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(7237), lang.NewKeyword("end-column"), int(24)) +v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v4}) -var v4 any = v8 -_ = v4 -v10 := lang.Apply(lang1.AgentSubmit, []any{v4}) -var v9 any = v10 -_ = v9 -return v9 +v19 := lang.Apply(v15, []any{v18}) +v20 := lang.Apply(v9, []any{v12, v19, v3}) +v21 := lang.Apply(v6, []any{v20}) +return v21 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -40780,95 +38515,103 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// pr +// future { -v0 := lang.NewSymbol("pr").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Prints the object(s) to the output stream that is the current value\n of *out*. Prints the object(s), separated by spaces if there is\n more than one. By default, pr and prn print in a way that objects\n can be read by the reader", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3678), lang.NewKeyword("end-line"), int(3678), lang.NewKeyword("dynamic"), true)).(*lang.Symbol) +v0 := lang.NewSymbol("future").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Takes a body of expressions and yields a future object that will\n invoke the body in another thread, and will cache the result and\n return it on all subsequent calls to deref/@. If the computation has\n not yet finished, calls to deref/@ will block, unless the variant of\n deref with timeout is used. See also - realized?.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7052), lang.NewKeyword("end-line"), int(7052))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 0: -return nil - case 1: -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("pr-on")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("*out*")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v6, []any{v3, v9}) -return v10 default: - if len(args) < 1 { + if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := lang.NewList(args[1:]...) -recur_loop_671: -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("pr")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v4 := args[1] +v5 := lang.NewList(args[2:]...) +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("seq")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -_ = v8 +v8 := v7.Get() v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("*out*")) +v10 := v9.FindInternedVar(lang.NewSymbol("concat")) if v10.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } v11 := v10.Get() -v12 := lang.Apply(lang1.AppendWriter, []any{v11, lang.NewChar(32)}) -_ = v12 -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("next")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("list")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v4}) -var v13 any = v17 -_ = v13 -var v19 any -if lang.IsTruthy(v13) { -var v20 any = v13 -_ = v20 -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("first")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +v14 := v13.Get() +v15 := lang.Apply(v14, []any{lang.NewSymbol("glojure.core/future-call")}) +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("list")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -v25 := v24.Get() -v26 := lang.Apply(v25, []any{v4}) -var v22 any = v26 -var v27 any = v20 -v3 = v22 -v4 = v27 -goto recur_loop_671 -} else { -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("apply")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +v18 := v17.Get() +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("seq")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("pr")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("concat")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -v25 := v24.Get() -v26 := lang.Apply(v22, []any{v25, v4}) -v19 = v26 +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("list")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -return v19 +v27 := v26.Get() +v28 := lang.Apply(v27, []any{lang.NewSymbol("fn*")}) +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("list")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("apply")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("vector")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("seq")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("concat")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v43, nil) +v45 := lang.Apply(v40, []any{v44}) +v46 := lang.Apply(v34, []any{v37, v45}) +v47 := lang.Apply(v31, []any{v46}) +v48 := lang.Apply(v24, []any{v28, v47, v5}) +v49 := lang.Apply(v21, []any{v48}) +v50 := lang.Apply(v18, []any{v49}) +v51 := lang.Apply(v11, []any{v15, v50}) +v52 := lang.Apply(v8, []any{v51}) +return v52 } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -40877,92 +38620,50 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// re-matcher +// future-call { -v1 := reflect.TypeOf((*lang1.RegexpMatcher)(nil)) -v0 := lang.NewSymbol("re-matcher").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("re"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns an instance of java.util.regex.Matcher, for use, e.g. in\n re-find.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4873), lang.NewKeyword("end-line"), int(4873))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { +v0 := lang.NewSymbol("future-call").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Takes a function of no args and yields a future object that will\n invoke the function in another thread, and will cache the result and\n return it on all subsequent calls to deref/@. If the computation has\n not yet finished, calls to deref/@ will block, unless the variant\n of deref with timeout is used. See also - realized?.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7046), lang.NewKeyword("end-line"), int(7046))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v4 := args[0] -v5 := args[1] -v6 := lang.Apply(lang1.NewRegexpMatcher, []any{v4, v5}) -return v6 +v3 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("binding-conveyor-fn")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v4}) +var v4 any = v8 +_ = v4 +v10 := lang.Apply(lang1.AgentSubmit, []any{v4}) +var v9 any = v10 +_ = v9 +return v9 }) -v4 := reflect.TypeOf((*lang1.RegexpMatcher)(nil)) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// take-last +// future-cancel { -v0 := lang.NewSymbol("take-last").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a seq of the last n items in coll. Depending on the type\n of coll may be no better than linear time. For vectors, see also subvec.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2939), lang.NewKeyword("end-line"), int(2939))).(*lang.Symbol) +v0 := lang.NewSymbol("future-cancel").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Cancels the future, if possible.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7062), lang.NewKeyword("end-line"), int(7062))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := args[1] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("seq")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v4}) -var v5 any = v9 -_ = v5 -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("seq")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("drop")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v3, v4}) -v18 := lang.Apply(v13, []any{v17}) -var v10 any = v18 -_ = v10 -var v19 any -for { -var v20 any -if lang.IsTruthy(v10) { -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("next")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v5}) -var v21 any = v25 -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("next")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{v10}) -var v26 any = v30 -v5 = v21 -v10 = v26 -continue -} else { -v20 = v5 -} -v19 = v20 - break +v4, _ := lang.FieldOrMethod(v3, "cancel") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("cancel is not a function"))) } -return v19 +v5 := lang.Apply(v4, []any{true}) +return v5 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -40970,61 +38671,27 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// sort-by +// future-cancelled? { -v0 := lang.NewSymbol("sort-by").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("keyfn"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("keyfn"), lang.NewSymbol("comp"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a sorted sequence of the items in coll, where the sort\n order is determined by comparing (keyfn item). If no comparator is\n supplied, uses compare. comparator must implement\n java.util.Comparator. Guaranteed to be stable: equal elements will\n not be reordered. If coll is a Java array, it will be modified. To\n avoid this, sort a copy of the array.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3102), lang.NewKeyword("end-line"), int(3102))).(*lang.Symbol) +v0 := lang.NewSymbol("future-cancelled?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Returns true if future f is cancelled", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7068), lang.NewKeyword("end-line"), int(7068))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("sort-by")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("compare")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v7, []any{v3, v10, v4}) -return v11 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("sort")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -var v9 lang.FnFunc -v9 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v10 := args[0] -v11 := args[1] -v12 := lang.Apply(v3, []any{v10}) -v13 := lang.Apply(v3, []any{v11}) -v14 := lang.Apply(v4, []any{v12, v13}) -return v14 -}) -v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3114), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(3114), lang.NewKeyword("end-column"), int(46)) -v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) -if err != nil { - panic(err) +v3 := args[0] +v4, ok := lang.FieldOrMethod(v3, "isCancelled") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "isCancelled"))) } -v12 := lang.Apply(v8, []any{v11, v5}) -return v12 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } +var v5 any +switch reflect.TypeOf(v4).Kind() { +case reflect.Func: + v5 = lang.Apply(v4, nil) +default: + v5 = v4 +} +return v5 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -41032,33 +38699,27 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// root-directory +// future-done? { -v0 := lang.NewSymbol("root-directory").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"))), lang.NewKeyword("doc"), "Returns the root resource path for a lib", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5914), lang.NewKeyword("end-line"), int(5914), lang.NewKeyword("private"), true)).(*lang.Symbol) +v0 := lang.NewSymbol("future-done?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Returns true if future f is done", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6581), lang.NewKeyword("end-line"), int(6581))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("root-resource")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v4, ok := lang.FieldOrMethod(v3, "isDone") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "isDone"))) } -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -var v4 any = v8 -_ = v4 -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("subs")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +var v5 any +switch reflect.TypeOf(v4).Kind() { +case reflect.Func: + v5 = lang.Apply(v4, nil) +default: + v5 = v4 } -v12 := v11.Get() -v13 := lang.Apply(strings22.LastIndex, []any{v4, "/"}) -v14 := lang.Apply(v12, []any{v4, int64(0), v13}) -return v14 +return v5 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -41066,38 +38727,79 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// *pending-paths* +// future? { -v0 := lang.NewSymbol("*pending-paths*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5865), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(5868), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, lang.NewList(), true) +v0 := lang.NewSymbol("future?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is a future", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6575), lang.NewKeyword("end-line"), int(6575))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{java.util.concurrent12.Future, v3}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// *print-readably* +// gen-class { -v0 := lang.NewSymbol("*print-readably*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "When set to logical false, strings and characters will be printed with\n non-alphanumeric characters converted to the appropriate escape sequences.\n\n Defaults to true", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, true, true) +v0 := lang.NewSymbol("gen-class").WithMeta(lang.NewMap()).(*lang.Symbol) +v1 := ns.Intern(v0) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// bit-test +// gensym { -v0 := lang.NewSymbol("bit-test").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Test bit at index n", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1354), lang.NewKeyword("end-line"), int(1354))).(*lang.Symbol) +v0 := lang.NewSymbol("gensym").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("prefix-string"))), lang.NewKeyword("doc"), "Returns a new symbol with a unique name. If a prefix string is\n supplied, the name is prefix# where # is some unique number. If\n prefix is not supplied, the prefix is 'G__'.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(599), lang.NewKeyword("end-line"), int(599))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "testBit") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("testBit is not a function"))) + switch len(args) { + case 0: +v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v4 := v3.FindInternedVar(lang.NewSymbol("gensym")) +if v4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) } -v6 := lang.Apply(v5, []any{v3, v4}) +v5 := v4.Get() +v6 := lang.Apply(v5, []any{"G__"}) return v6 + case 1: +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("str")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("str")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10, _ := lang.FieldOrMethod(runtime9.RT, "NextID") +if reflect.TypeOf(v10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("NextID is not a function"))) +} +v11 := lang.Apply(v10, []any{}) +v12 := lang.Apply(v9, []any{v11}) +v13 := lang.Apply(v6, []any{v3, v12}) +v14 := lang.Apply(lang1.NewSymbol, []any{v13}) +return v14 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -41105,117 +38807,11 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// unchecked-add-int +// get { var v1 lang.FnFunc -{ // function unchecked-add-int__inliner +{ // function get__inliner v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("concat")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("list")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("seq")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("concat")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("list")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/unchecked_int_add")}) -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v4}) -v40 := lang.Apply(v27, []any{v31, v35, v39}) -v41 := lang.Apply(v24, []any{v40}) -v42 := lang.Apply(v21, []any{v41}) -v43 := lang.Apply(v10, []any{v14, v18, v42}) -v44 := lang.Apply(v7, []any{v43}) -return v44 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("unchecked-add-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the sum of x and y, both int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1196), lang.NewKeyword("end-line"), int(1196))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6, _ := lang.FieldOrMethod(lang1.Numbers, "unchecked_int_add") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_add is not a function"))) -} -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// declare -{ -v0 := lang.NewSymbol("declare").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("names"))), lang.NewKeyword("doc"), "defs the supplied var names with no bindings, useful for making forward declarations.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(2768), lang.NewKeyword("end-line"), int(2768))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 2 { @@ -41242,160 +38838,210 @@ if v13.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } v14 := v13.Get() -v15 := lang.Apply(v14, []any{lang.NewSymbol("do")}) +v15 := lang.Apply(v14, []any{lang.NewSymbol(".")}) v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("map")) +v17 := v16.FindInternedVar(lang.NewSymbol("list")) if v17.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } v18 := v17.Get() -var v19 lang.FnFunc -v19 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v20 := args[0] -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("list")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +v19 := lang.Apply(v18, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("list")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("vary-meta")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("seq")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("assoc")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("concat")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) } -v29 := v28.Get() -v30 := lang.Apply(v26, []any{v20, v29, lang.NewKeyword("declared"), true}) -v31 := lang.Apply(v23, []any{lang.NewSymbol("def"), v30}) -return v31 +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("list")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.Apply(v31, []any{lang.NewSymbol("glojure.core/Get")}) +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("list")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v3}) +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("list")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v4}) +v41 := lang.Apply(v28, []any{v32, v36, v40, v5}) +v42 := lang.Apply(v25, []any{v41}) +v43 := lang.Apply(v22, []any{v42}) +v44 := lang.Apply(v11, []any{v15, v19, v43}) +v45 := lang.Apply(v8, []any{v44}) +return v45 + } }) -v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2771), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(2771), lang.NewKeyword("end-column"), int(71)) -v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) -if err != nil { - panic(err) +v2 := v1 +_ = v2 } -v22 := lang.Apply(v18, []any{v21, v5}) -v23 := lang.Apply(v11, []any{v15, v22}) -v24 := lang.Apply(v8, []any{v23}) -return v24 +v0 := lang.NewSymbol("get").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"), lang.NewSymbol("not-found"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the value mapped to key, not-found or nil if key not present\n in associative collection, set, string, array, or ILookup instance.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)int64(3)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1489), lang.NewKeyword("end-line"), int(1489))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v4 := args[0] +v5 := args[1] +v6 := lang.Apply(lang1.Get, []any{v4, v5}) +return v6 + case 3: +v4 := args[0] +v5 := args[1] +v6 := args[2] +v7 := lang.Apply(lang1.GetDefault, []any{v4, v5, v6}) +return v7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// prn-str +// get-in { -v1 := reflect.TypeOf("") -v0 := lang.NewSymbol("prn-str").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("xs"))), lang.NewKeyword("doc"), "prn to a string, returning it", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4767), lang.NewKeyword("end-line"), int(4767))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { +v0 := lang.NewSymbol("get-in").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("ks")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("ks"), lang.NewSymbol("not-found"))), lang.NewKeyword("doc"), "Returns the value in a nested associative structure,\n where ks is a sequence of keys. Returns nil if the key\n is not present, or the not-found value if supplied.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6171), lang.NewKeyword("end-line"), int(6171))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := lang.NewList(args[0:]...) -var v5 any = "unimplemented: new with non-constant class type" -_ = v5 + case 2: +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("reduce1")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("push-thread-bindings")) +v9 := v8.FindInternedVar(lang.NewSymbol("get")) if v9.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("hash-map")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v11 := lang.Apply(v7, []any{v10, v3, v4}) +return v11 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v7 := lang.Apply(Object20., nil) +var v6 any = v7 +_ = v6 +var v8 any = v8 +_ = v8 +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("seq")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v13 := v12.Get() -v14 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*out*")) -v15 := lang.Apply(v13, []any{v14, v5}) -v16 := lang.Apply(v10, []any{v15}) +v12 := v11.Get() +v13 := lang.Apply(v12, []any{v9}) +var v9 any = v13 +_ = v9 +var v14 any +for { +var v15 any +if lang.IsTruthy(v9) { +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("get")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("first")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.Apply(v22, []any{v9}) +v24 := lang.Apply(v19, []any{v16, v23, v6}) +var v16 any = v24 _ = v16 -var v17 any -func() { -defer func() { -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +var v26 any +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("identical?")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v20 := v19.Get() -v21 := lang.Apply(v20, nil) -}() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("apply")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v29 := v28.Get() +v30 := lang.Apply(v29, []any{v6, v16}) +if lang.IsTruthy(v30) { +v26 = v5 +} else { +var v31 any = v6 +var v32 any = v16 +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("next")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("prn")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +v36 := v35.Get() +v37 := lang.Apply(v36, []any{v9}) +var v33 any = v37 +v6 = v31 +v8 = v32 +v9 = v33 +continue } -v27 := v26.Get() -v28 := lang.Apply(v24, []any{v27, v4}) -_ = v28 -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("str")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +v15 = v26 +} else { +v15 = v8 } -v31 := v30.Get() -v32 := lang.Apply(v31, []any{v5}) -v17 = v32 -}() -return v17 +v14 = v15 + break +} +return v14 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) -v4 := reflect.TypeOf("") -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// send-off +// get-method { -v0 := lang.NewSymbol("send-off").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Dispatch a potentially blocking action to an agent. Returns the\n agent immediately. Subsequently, in a separate thread, the state of\n the agent will be set to the value of:\n\n (apply action-fn state-of-agent args)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2120), lang.NewKeyword("end-line"), int(2120))).(*lang.Symbol) +v0 := lang.NewSymbol("get-method").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"), lang.NewSymbol("dispatch-val"))), lang.NewKeyword("doc"), "Given a multimethod and a dispatch value, returns the dispatch fn\n that would apply to that value, or nil if none apply and no default", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1815), lang.NewKeyword("end-line"), int(1815))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] v4 := args[1] -v5 := lang.NewList(args[2:]...) -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("apply")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("send-via")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +v5, _ := lang.FieldOrMethod(v3, "getMethod") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getMethod is not a function"))) } -v11 := v10.Get() -v12 := lang.Apply(v8, []any{v11, nil, v3, v4, v5}) -return v12 - } +v6 := lang.Apply(v5, []any{v4}) +return v6 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -41403,26 +39049,16 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// swap! +// get-thread-bindings { -v0 := lang.NewSymbol("swap!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atom"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Atomically swaps the value of atom to be:\n (apply f current-value-of-atom args). Note that f may be called\n multiple times, and thus should be free of side effects. Returns\n the value that was swapped in.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2343), lang.NewKeyword("end-line"), int(2343))).(*lang.Symbol) +v0 := lang.NewSymbol("get-thread-bindings").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Get a map with the Var/value pairs which is currently in effect for the\n current thread.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1937), lang.NewKeyword("end-line"), int(1937))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -v6, _ := lang.FieldOrMethod(v3, "swap") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("swap is not a function"))) -} -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } +v3 := lang.Apply(nil, nil) +return v3 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -41430,126 +39066,239 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// ancestors +// get-validator { -v0 := lang.NewSymbol("ancestors").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"))), lang.NewKeyword("doc"), "Returns the immediate and indirect parents of tag, either via a Java type\n inheritance relationship or a relationship established via derive. h\n must be a hierarchy obtained from make-hierarchy, if not supplied\n defaults to the global hierarchy", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5620), lang.NewKeyword("end-line"), int(5620))).(*lang.Symbol) +v0 := lang.NewSymbol("get-validator").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("iref"))), lang.NewKeyword("doc"), "Gets the validator-fn for a var/ref/agent/atom.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2392), lang.NewKeyword("end-line"), int(2392))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("ancestors")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v4, _ := lang.FieldOrMethod(v3, "getValidator") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getValidator is not a function"))) } -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("global-hierarchy")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v5 := lang.Apply(v4, []any{}) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v9 := v8.Get() -v10 := lang.Apply(v6, []any{v9, v3}) -return v10 - case 2: +} +// global-hierarchy +{ +v0 := lang.NewSymbol("global-hierarchy").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5556), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(5557), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, lang.NewMap(lang.NewKeyword("parents"), lang.NewMap(), lang.NewKeyword("descendants"), lang.NewMap(), lang.NewKeyword("ancestors"), lang.NewMap()), true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// group-by +{ +v0 := lang.NewSymbol("group-by").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a map of the elements of coll keyed by the result of\n f on each element. The value at each key will be a vector of the\n corresponding elements, in the order they appeared in coll.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7171), lang.NewKeyword("end-line"), int(7171))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] v4 := args[1] v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("not-empty")) +v6 := v5.FindInternedVar(lang.NewSymbol("persistent!")) if v6.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } v7 := v6.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("get")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) -v13 := lang.Apply(v11, []any{v12, v4}) -var v8 any = v13 -_ = v8 -var v15 any -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("class?")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("reduce")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v4}) -if lang.IsTruthy(v19) { -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("set")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +v10 := v9.Get() +var v11 lang.FnFunc +v11 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v12 := args[0] +v13 := args[1] +v15 := lang.Apply(v3, []any{v13}) +var v14 any = v15 +_ = v14 +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("assoc!")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("supers")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("conj")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v4}) -v28 := lang.Apply(v23, []any{v27}) -var v20 any = v28 -_ = v20 -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("reduce1")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("get")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("into1")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +v25 := v24.Get() +v26 := lang.NewVector() +v27 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7182), lang.NewKeyword("column"), int(40), lang.NewKeyword("end-line"), int(7182), lang.NewKeyword("end-column"), int(41)) +v28, err := lang.WithMeta(v26, v27.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v35 := v34.Get() -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("cons")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +v29 := lang.Apply(v25, []any{v12, v14, v28}) +v30 := lang.Apply(v22, []any{v29, v13}) +v31 := lang.Apply(v19, []any{v12, v14, v30}) +return v31 +}) +v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7180), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(7182), lang.NewKeyword("end-column"), int(48)) +v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v38 := v37.Get() -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("map")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("transient")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v41 := v40.Get() -var v42 lang.FnFunc -v42 = lang.NewFnFunc(func(args ...any) any { +v16 := v15.Get() +v17 := lang.NewMap() +v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7183), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(7183), lang.NewKeyword("end-column"), int(17)) +v19, err := lang.WithMeta(v17, v18.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v20 := lang.Apply(v16, []any{v19}) +v21 := lang.Apply(v10, []any{v13, v20, v4}) +v22 := lang.Apply(v7, []any{v21}) +return v22 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// halt-when +{ +v0 := lang.NewSymbol("halt-when").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred")), lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("retf"))), lang.NewKeyword("doc"), "Returns a transducer that ends transduction when pred returns true\n for an input. When retf is supplied it must be a fn of 2 arguments -\n it will be passed the (completed) result so far and the input that\n triggered the predicate, and its return value (if it does not throw\n an exception) will be the return value of the transducer. If retf\n is not supplied, the input that triggered the predicate will be\n returned. If the predicate never returns true the transduction is\n unaffected.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7700), lang.NewKeyword("end-line"), int(7700))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("halt-when")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{v3, nil}) +return v7 + case 2: +v3 := args[0] +v4 := args[1] +var v5 lang.FnFunc +v5 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v43 := args[0] -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("get")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +v6 := args[0] +var v7 lang.FnFunc +v7 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v8 := lang.Apply(v6, nil) +return v8 + case 1: +v8 := args[0] +var v9 any +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("map?")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v46 := v45.Get() -v47 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) -v48 := lang.Apply(v46, []any{v47, v43}) -return v48 -}) -v43 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5633), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(5633), lang.NewKeyword("end-column"), int(54)) -v44, err := lang.WithMeta(v42, v43.(lang.IPersistentMap)) +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v8}) +var v10 any = v14 +_ = v10 +var v16 any +if lang.IsTruthy(v10) { +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("contains?")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v8, lang.NewKeyword("glojure.core/halt")}) +v16 = v20 +} else { +v16 = v10 +} +if lang.IsTruthy(v16) { +v10 := lang.Apply(lang.NewKeyword("glojure.core/halt"), []any{v8}) +v9 = v10 +} else { +v11 := lang.Apply(v6, []any{v8}) +v9 = v11 +} +return v9 + case 2: +v8 := args[0] +v9 := args[1] +var v10 any +v11 := lang.Apply(v3, []any{v9}) +if lang.IsTruthy(v11) { +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("reduced")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +var v15 any +if lang.IsTruthy(v4) { +v16 := lang.Apply(v6, []any{v8}) +v17 := lang.Apply(v4, []any{v16, v9}) +v15 = v17 +} else { +v15 = v9 +} +v18 := lang.NewMap(lang.NewKeyword("glojure.core/halt"), v15) +v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7721), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(7721), lang.NewKeyword("end-column"), int(72)) +v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) if err != nil { panic(err) } -v45 := lang.Apply(v41, []any{v44, v20}) -v46 := lang.Apply(v38, []any{v8, v45}) -v47 := lang.Apply(v32, []any{v35, v20, v46}) -v15 = v47 +v21 := lang.Apply(v14, []any{v20}) +v10 = v21 } else { -v15 = v8 +v22 := lang.Apply(v6, []any{v8, v9}) +v10 = v22 } -v8 := lang.Apply(v7, []any{v15}) -return v8 +return v10 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7713), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7722), lang.NewKeyword("end-column"), int(34)) +v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v9 +}) +v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7712), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7722), lang.NewKeyword("end-column"), int(35)) +v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v7 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -41560,15 +39309,33 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// hash-set +// hash { -v0 := lang.NewSymbol("hash-set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keys"))), lang.NewKeyword("doc"), "Returns a new hash set with supplied keys. Any equal keys are\n handled as if by repeated uses of conj.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(388), lang.NewKeyword("end-line"), int(388))).(*lang.Symbol) +v0 := lang.NewSymbol("hash").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns the hash code of its argument. Note this is the hash code\n consistent with =, and thus is different than .hashCode for Integer,\n Short, Byte and Clojure collections.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5189), lang.NewKeyword("end-line"), int(5189))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.Apply(lang1.HashEq, []any{v3}) +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// hash-map +{ +v0 := lang.NewSymbol("hash-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keyvals"))), lang.NewKeyword("doc"), "keyval => key val\n Returns a new hash map with supplied mappings. If any keys are\n equal, they are handled as if by repeated uses of assoc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(378), lang.NewKeyword("end-line"), int(378))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: -v3 := lang.CreatePersistentTreeSet() -v4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(393), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(393), lang.NewKeyword("end-column"), int(9)) +v3 := lang.NewMap() +v4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(384), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(384), lang.NewKeyword("end-column"), int(8)) v5, err := lang.WithMeta(v3, v4.(lang.IPersistentMap)) if err != nil { panic(err) @@ -41579,7 +39346,7 @@ return v5 panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := lang.NewList(args[0:]...) -v4 := lang.Apply(nil, []any{v3}) +v4 := lang.Apply(lang1.CreatePersistentHashMap, []any{v3}) return v4 } }) @@ -41589,22 +39356,17 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// reset-vals! +// hash-ordered-coll { -v0 := lang.NewSymbol("reset-vals!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atom"), lang.NewSymbol("newval"))), lang.NewKeyword("doc"), "Sets the value of atom to newval. Returns [old new], the value of the\n atom before and after the reset.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2375), lang.NewKeyword("end-line"), int(2375))).(*lang.Symbol) +v0 := lang.NewSymbol("hash-ordered-coll").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns the hash code, consistent with =, for an external ordered\n collection implementing Iterable.\n See http://glojure.org/data_structures#hash for full algorithms.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5210), lang.NewKeyword("end-line"), int(5210))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := args[1] -v5, _ := lang.FieldOrMethod(v3, "resetVals") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("resetVals is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 +v4 := lang.Apply(nil, []any{v3}) +return v4 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -41612,222 +39374,85 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// interleave +// hash-set { -v0 := lang.NewSymbol("interleave").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("c1")), lang.NewVector(lang.NewSymbol("c1"), lang.NewSymbol("c2")), lang.NewVector(lang.NewSymbol("c1"), lang.NewSymbol("c2"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Returns a lazy seq of the first item in each coll, then the second etc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4308), lang.NewKeyword("end-line"), int(4308))).(*lang.Symbol) +v0 := lang.NewSymbol("hash-set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keys"))), lang.NewKeyword("doc"), "Returns a new hash set with supplied keys. Any equal keys are\n handled as if by repeated uses of conj.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(388), lang.NewKeyword("end-line"), int(388))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: -return lang.NewList() - case 1: -v3 := args[0] -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -return v3 -}) -v5 := lang.Apply(lang1.NewLazySeq, []any{v4}) +v3 := lang.CreatePersistentTreeSet() +v4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(393), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(393), lang.NewKeyword("end-column"), int(9)) +v5, err := lang.WithMeta(v3, v4.(lang.IPersistentMap)) +if err != nil { + panic(err) +} return v5 - case 2: -v3 := args[0] -v4 := args[1] -var v5 lang.FnFunc -v5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.NewList(args[0:]...) +v4 := lang.Apply(nil, []any{v3}) +return v4 } -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("seq")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v3}) -var v6 any = v10 -_ = v6 -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("seq")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v4}) -var v11 any = v15 -_ = v11 -var v17 any -var v18 any = v6 -_ = v18 -var v20 any -if lang.IsTruthy(v18) { -v20 = v11 -} else { -v20 = v18 -} -if lang.IsTruthy(v20) { -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("cons")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("first")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v6}) -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("cons")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("first")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{v11}) -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("interleave")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v34 := v33.Get() -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("rest")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) } -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v6}) -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("rest")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +// hash-unordered-coll +{ +v0 := lang.NewSymbol("hash-unordered-coll").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns the hash code, consistent with =, for an external unordered\n collection implementing Iterable. For maps, the iterator should\n return map entries whose hash is computed as\n (hash-ordered-coll [k v]).\n See http://glojure.org/data_structures#hash for full algorithms.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5219), lang.NewKeyword("end-line"), int(5219))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.Apply(nil, []any{v3}) +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v41 := v40.Get() -v42 := lang.Apply(v41, []any{v11}) -v43 := lang.Apply(v34, []any{v38, v42}) -v44 := lang.Apply(v27, []any{v31, v43}) -v45 := lang.Apply(v20, []any{v24, v44}) -v17 = v45 -} else { -v17 = nil } -return v17 -}) -v6 := lang.Apply(lang1.NewLazySeq, []any{v5}) -return v6 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -var v6 lang.FnFunc -v6 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { +// ident? +{ +v0 := lang.NewSymbol("ident?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a symbol or keyword", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1608), lang.NewKeyword("end-line"), int(1608))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("map")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v3 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("keyword?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v10 := v9.Get() +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +var v4 any = v8 +_ = v4 +var v10 any +if lang.IsTruthy(v4) { +v10 = v4 +} else { v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("seq")) +v12 := v11.FindInternedVar(lang.NewSymbol("symbol?")) if v12.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("conj")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v5, v4, v3}) -v18 := lang.Apply(v10, []any{v13, v17}) -var v7 any = v18 -_ = v7 -var v20 any -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("every?")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("identity")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v23, []any{v26, v7}) -if lang.IsTruthy(v27) { -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("concat")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("map")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("first")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.Apply(v33, []any{v36, v7}) -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("apply")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("interleave")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("map")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("rest")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) -} -v49 := v48.Get() -v50 := lang.Apply(v46, []any{v49, v7}) -v51 := lang.Apply(v40, []any{v43, v50}) -v52 := lang.Apply(v30, []any{v37, v51}) -v20 = v52 -} else { -v20 = nil +v14 := lang.Apply(v13, []any{v3}) +v10 = v14 } -return v20 -}) -v7 := lang.Apply(lang1.NewLazySeq, []any{v6}) -return v7 - } +return v10 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -41835,10 +39460,10 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// bit-shift-right +// identical? { var v1 lang.FnFunc -{ // function bit-shift-right__inliner +{ // function identical?__inliner v1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -41870,57 +39495,36 @@ if v16.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.Apply(v17, []any{lang.NewSymbol("glojure.lang.Util")}) v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v20 := v19.FindInternedVar(lang.NewSymbol("list")) if v20.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("seq")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("concat")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +v22 := lang.Apply(v21, []any{lang.NewSymbol("glojure.core/identical")}) +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("list")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/shiftRight")}) -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +v25 := v24.Get() +v26 := lang.Apply(v25, []any{v3}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v4}) -v40 := lang.Apply(v27, []any{v31, v35, v39}) -v41 := lang.Apply(v24, []any{v40}) -v42 := lang.Apply(v21, []any{v41}) -v43 := lang.Apply(v10, []any{v14, v18, v42}) -v44 := lang.Apply(v7, []any{v43}) -return v44 +v29 := v28.Get() +v30 := lang.Apply(v29, []any{v4}) +v31 := lang.Apply(v10, []any{v14, v18, v22, v26, v30}) +v32 := lang.Apply(v7, []any{v31}) +return v32 }) v2 := v1 _ = v2 } -v0 := lang.NewSymbol("bit-shift-right").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Bitwise shift right", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1367), lang.NewKeyword("end-line"), int(1367))).(*lang.Symbol) +v0 := lang.NewSymbol("identical?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Tests if 2 arguments are the same object", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(768), lang.NewKeyword("end-line"), int(768))).(*lang.Symbol) var v3 lang.FnFunc v3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { @@ -41928,12 +39532,8 @@ v3 = lang.NewFnFunc(func(args ...any) any { } v4 := args[0] v5 := args[1] -v6, _ := lang.FieldOrMethod(lang1.Numbers, "shiftRight") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("shiftRight is not a function"))) -} -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 +v6 := lang.Apply(lang1.Identical, []any{v4, v5}) +return v6 }) v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v2 := ns.InternWithValue(v0, v3, true) @@ -41941,79 +39541,16 @@ if v0.Meta() != nil { v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// symbol? -{ -v0 := lang.NewSymbol("symbol?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a Symbol", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(557), lang.NewKeyword("end-line"), int(557))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{lang1.*Symbol, v3}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// chunk -{ -v0 := lang.NewSymbol("chunk").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(691), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(691), lang.NewKeyword("end-column"), int(41), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("b"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, ok := lang.FieldOrMethod(v3, "chunk") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "chunk"))) -} -var v5 any -switch reflect.TypeOf(v4).Kind() { -case reflect.Func: - v5 = lang.Apply(v4, nil) -default: - v5 = v4 -} -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// remove-all-methods +// identity { -v0 := lang.NewSymbol("remove-all-methods").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"))), lang.NewKeyword("doc"), "Removes all of the methods of multimethod.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1787), lang.NewKeyword("end-line"), int(1787))).(*lang.Symbol) +v0 := lang.NewSymbol("identity").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns its argument.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1446), lang.NewKeyword("end-line"), int(1446))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4, ok := lang.FieldOrMethod(v3, "reset") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "reset"))) -} -var v5 any -switch reflect.TypeOf(v4).Kind() { -case reflect.Func: - v5 = lang.Apply(v4, nil) -default: - v5 = v4 -} -return v5 +return v3 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -42021,360 +39558,409 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// ns-refers +// if-let { -v0 := lang.NewSymbol("ns-refers").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of the refer mappings for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4253), lang.NewKeyword("end-line"), int(4253))).(*lang.Symbol) +v0 := lang.NewSymbol("if-let").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("then")), lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("then"), lang.NewSymbol("else"), lang.NewSymbol("&"), lang.NewSymbol("oldform"))), lang.NewKeyword("doc"), "bindings => binding-form test\n\n If test is true, evaluates then with binding-form bound to the value of \n test, if not, yields else", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1839), lang.NewKeyword("end-line"), int(1839))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + switch len(args) { + case 4: v3 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("the-ns")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("seq")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v4}) -var v4 any = v8 -_ = v4 +v9 := v8.Get() v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("filter-key")) +v11 := v10.FindInternedVar(lang.NewSymbol("concat")) if v11.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } v12 := v11.Get() v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("val")) +v14 := v13.FindInternedVar(lang.NewSymbol("list")) if v14.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } v15 := v14.Get() -var v16 lang.FnFunc -v16 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v17 := args[0] -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("instance?")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/if-let")}) +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("list")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v21 := v20.Get() -v22 := lang.Apply(v21, []any{lang1.*Var, v17}) -var v18 any = v22 -_ = v18 -var v24 any -if lang.IsTruthy(v18) { +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v5}) +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("list")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v6}) v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("not=")) +v26 := v25.FindInternedVar(lang.NewSymbol("list")) if v26.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } v27 := v26.Get() -v28, ok := lang.FieldOrMethod(v17, "Namespace") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v17, "Namespace"))) -} -var v29 any -switch reflect.TypeOf(v28).Kind() { -case reflect.Func: - v29 = lang.Apply(v28, nil) -default: - v29 = v28 -} -v30 := lang.Apply(v27, []any{v4, v29}) -v24 = v30 -} else { -v24 = v18 -} -return v24 -}) -v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4259), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(4260), lang.NewKeyword("end-column"), int(59)) -v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("ns-map")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v4}) -v23 := lang.Apply(v12, []any{v15, v18, v22}) -return v23 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// subseq -{ -v0 := lang.NewSymbol("subseq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sc"), lang.NewSymbol("test"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("sc"), lang.NewSymbol("start-test"), lang.NewSymbol("start-key"), lang.NewSymbol("end-test"), lang.NewSymbol("end-key"))), lang.NewKeyword("doc"), "sc must be a sorted collection, test(s) one of <, <=, > or\n >=. Returns a seq of those entries with keys ek for\n which (test (.. sc comparator (compare ek key)) 0) is true", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5133), lang.NewKeyword("end-line"), int(5133))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("mk-bound-fn")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v3, v4, v5}) -var v6 any = v10 -_ = v6 -var v12 any -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol(">")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol(">=")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.CreatePersistentTreeSet(v15, v18) -v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5141), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5141), lang.NewKeyword("end-column"), int(17)) -v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v22 := lang.Apply(v21, []any{v4}) -if lang.IsTruthy(v22) { -v24, _ := lang.FieldOrMethod(v3, "seqFrom") -if reflect.TypeOf(v24).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("seqFrom is not a function"))) -} -v25 := lang.Apply(v24, []any{v5, true}) -var v23 any = v25 -_ = v23 -var v27 any -if lang.IsTruthy(v23) { -var v28 any = v23 -_ = v28 -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("nth")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.Apply(v32, []any{v28, int64(0), nil}) -var v29 any = v33 -_ = v29 -var v34 any = v28 -_ = v34 -var v36 any -v37 := lang.Apply(v6, []any{v29}) -if lang.IsTruthy(v37) { -v36 = v34 -} else { -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("next")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.Apply(v40, []any{v34}) -v36 = v41 -} -v27 = v36 -} else { -v27 = nil -} -v12 = v27 -} else { -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("take-while")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26, _ := lang.FieldOrMethod(v3, "seq") -if reflect.TypeOf(v26).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("seq is not a function"))) -} -v27 := lang.Apply(v26, []any{true}) -v28 := lang.Apply(v25, []any{v6, v27}) -v12 = v28 -} -return v12 - case 5: +v28 := lang.Apply(v27, []any{nil}) +v29 := lang.Apply(v12, []any{v16, v20, v24, v28}) +v30 := lang.Apply(v9, []any{v29}) +return v30 + default: + if len(args) < 5 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] v4 := args[1] v5 := args[2] v6 := args[3] v7 := args[4] -v9, _ := lang.FieldOrMethod(v3, "seqFrom") -if reflect.TypeOf(v9).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("seqFrom is not a function"))) +v8 := lang.NewList(args[5:]...) +var v9 any +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("vector?")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v10 := lang.Apply(v9, []any{v5, true}) -var v8 any = v10 -_ = v8 -var v12 any -if lang.IsTruthy(v8) { -var v13 any = v8 -_ = v13 -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("nth")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +v12 := v11.Get() +v13 := lang.Apply(v12, []any{v5}) +if lang.IsTruthy(v13) { +v9 = nil +} else { +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("str")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v13, int64(0), nil}) -var v14 any = v18 -_ = v14 -var v19 any = v13 -_ = v19 +v16 := v15.Get() +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("first")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v3}) v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("take-while")) +v22 := v21.FindInternedVar(lang.NewSymbol("*ns*")) if v22.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } v23 := v22.Get() v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("mk-bound-fn")) +v25 := v24.FindInternedVar(lang.NewSymbol("meta")) if v25.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } v26 := v25.Get() -v27 := lang.Apply(v26, []any{v3, v6, v7}) -var v28 any -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("mk-bound-fn")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.Apply(v31, []any{v3, v4, v5}) -v33 := lang.Apply(v32, []any{v14}) -if lang.IsTruthy(v33) { -v28 = v19 -} else { -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("next")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +v27 := lang.Apply(v26, []any{v3}) +v28 := lang.Apply(lang.NewKeyword("line"), []any{v27}) +v29 := lang.Apply(v16, []any{v20, " requires ", "a vector for its binding", " in ", v23, ":", v28}) +v30 := lang.Apply(lang1.NewIllegalArgumentError, []any{v29}) +panic(v30) } -v36 := v35.Get() -v37 := lang.Apply(v36, []any{v19}) -v28 = v37 +_ = v9 +var v31 any +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("nil?")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) } -v38 := lang.Apply(v23, []any{v27, v28}) -v12 = v38 +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v8}) +if lang.IsTruthy(v35) { +v31 = nil } else { -v12 = nil +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("str")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) } -return v12 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v38 := v37.Get() +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("first")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) } +v41 := v40.Get() +v42 := lang.Apply(v41, []any{v3}) +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("*ns*")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) } -// protocol? -{ -v0 := lang.NewSymbol("protocol?").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(110), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(110), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("maybe-p"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v45 := v44.Get() +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("meta")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) } -v7 := v6.Get() -v8 := lang.Apply(v7, []any{lang1.IAtom, v3}) -if lang.IsTruthy(v8) { -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("boolean")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +v48 := v47.Get() +v49 := lang.Apply(v48, []any{v3}) +v50 := lang.Apply(lang.NewKeyword("line"), []any{v49}) +v51 := lang.Apply(v38, []any{v42, " requires ", "1 or 2 forms after binding vector", " in ", v45, ":", v50}) +v52 := lang.Apply(lang1.NewIllegalArgumentError, []any{v51}) +panic(v52) } -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("deref")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +_ = v31 +var v53 any +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("=")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) } -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v3}) -v16 := lang.Apply(lang.NewKeyword("on-interface"), []any{v15}) -v17 := lang.Apply(v11, []any{v16}) -v4 = v17 +v56 := v55.Get() +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("count")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +} +v59 := v58.Get() +v60 := lang.Apply(v59, []any{v5}) +v61 := lang.Apply(v56, []any{int64(2), v60}) +if lang.IsTruthy(v61) { +v53 = nil } else { -v4 = false +v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v63 := v62.FindInternedVar(lang.NewSymbol("str")) +if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) } -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v64 := v63.Get() +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("first")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) } +v67 := v66.Get() +v68 := lang.Apply(v67, []any{v3}) +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("*ns*")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) } -// await1 -{ -v0 := lang.NewSymbol("await1").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3284), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3284), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("pos?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v71 := v70.Get() +v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v73 := v72.FindInternedVar(lang.NewSymbol("meta")) +if v73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) } -v7 := v6.Get() -v8, ok := lang.FieldOrMethod(v3, "getQueueCount") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getQueueCount"))) +v74 := v73.Get() +v75 := lang.Apply(v74, []any{v3}) +v76 := lang.Apply(lang.NewKeyword("line"), []any{v75}) +v77 := lang.Apply(v64, []any{v68, " requires ", "exactly 2 forms in binding vector", " in ", v71, ":", v76}) +v78 := lang.Apply(lang1.NewIllegalArgumentError, []any{v77}) +panic(v78) } -var v9 any -switch reflect.TypeOf(v8).Kind() { -case reflect.Func: - v9 = lang.Apply(v8, nil) -default: - v9 = v8 +_ = v53 +_ = nil +v80 := lang.Apply(v5, []any{int64(0)}) +var v79 any = v80 +_ = v79 +v82 := lang.Apply(v5, []any{int64(1)}) +var v81 any = v82 +_ = v81 +v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v85 := v84.FindInternedVar(lang.NewSymbol("seq")) +if v85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) } -v10 := lang.Apply(v7, []any{v9}) -if lang.IsTruthy(v10) { -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("await")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v86 := v85.Get() +v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v88 := v87.FindInternedVar(lang.NewSymbol("concat")) +if v88.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) } -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v3}) -v4 = v14 -} else { -v4 = nil +v89 := v88.Get() +v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v91 := v90.FindInternedVar(lang.NewSymbol("list")) +if v91.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) } -_ = v4 -return v3 +v92 := v91.Get() +v93 := lang.Apply(v92, []any{lang.NewSymbol("glojure.core/let")}) +v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v95 := v94.FindInternedVar(lang.NewSymbol("list")) +if v95.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) +} +v96 := v95.Get() +v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v98 := v97.FindInternedVar(lang.NewSymbol("apply")) +if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) +} +v99 := v98.Get() +v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v101 := v100.FindInternedVar(lang.NewSymbol("vector")) +if v101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) +} +v102 := v101.Get() +v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v104 := v103.FindInternedVar(lang.NewSymbol("seq")) +if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) +} +v105 := v104.Get() +v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v107 := v106.FindInternedVar(lang.NewSymbol("concat")) +if v107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) +} +v108 := v107.Get() +v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v110 := v109.FindInternedVar(lang.NewSymbol("list")) +if v110.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) +} +v111 := v110.Get() +v112 := lang.Apply(v111, []any{lang.NewSymbol("temp__0__auto__")}) +v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v114 := v113.FindInternedVar(lang.NewSymbol("list")) +if v114.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) +} +v115 := v114.Get() +v116 := lang.Apply(v115, []any{v81}) +v117 := lang.Apply(v108, []any{v112, v116}) +v118 := lang.Apply(v105, []any{v117}) +v119 := lang.Apply(v99, []any{v102, v118}) +v120 := lang.Apply(v96, []any{v119}) +v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v122 := v121.FindInternedVar(lang.NewSymbol("list")) +if v122.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) +} +v123 := v122.Get() +v124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v125 := v124.FindInternedVar(lang.NewSymbol("seq")) +if v125.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v125))) +} +v126 := v125.Get() +v127 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v128 := v127.FindInternedVar(lang.NewSymbol("concat")) +if v128.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v128))) +} +v129 := v128.Get() +v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v131 := v130.FindInternedVar(lang.NewSymbol("list")) +if v131.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) +} +v132 := v131.Get() +v133 := lang.Apply(v132, []any{lang.NewSymbol("if")}) +v134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v135 := v134.FindInternedVar(lang.NewSymbol("list")) +if v135.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v135))) +} +v136 := v135.Get() +v137 := lang.Apply(v136, []any{lang.NewSymbol("temp__0__auto__")}) +v138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v139 := v138.FindInternedVar(lang.NewSymbol("list")) +if v139.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v139))) +} +v140 := v139.Get() +v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v142 := v141.FindInternedVar(lang.NewSymbol("seq")) +if v142.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) +} +v143 := v142.Get() +v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v145 := v144.FindInternedVar(lang.NewSymbol("concat")) +if v145.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) +} +v146 := v145.Get() +v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v148 := v147.FindInternedVar(lang.NewSymbol("list")) +if v148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) +} +v149 := v148.Get() +v150 := lang.Apply(v149, []any{lang.NewSymbol("glojure.core/let")}) +v151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v152 := v151.FindInternedVar(lang.NewSymbol("list")) +if v152.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v152))) +} +v153 := v152.Get() +v154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v155 := v154.FindInternedVar(lang.NewSymbol("apply")) +if v155.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v155))) +} +v156 := v155.Get() +v157 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v158 := v157.FindInternedVar(lang.NewSymbol("vector")) +if v158.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v158))) +} +v159 := v158.Get() +v160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v161 := v160.FindInternedVar(lang.NewSymbol("seq")) +if v161.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v161))) +} +v162 := v161.Get() +v163 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v164 := v163.FindInternedVar(lang.NewSymbol("concat")) +if v164.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v164))) +} +v165 := v164.Get() +v166 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v167 := v166.FindInternedVar(lang.NewSymbol("list")) +if v167.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v167))) +} +v168 := v167.Get() +v169 := lang.Apply(v168, []any{v79}) +v170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v171 := v170.FindInternedVar(lang.NewSymbol("list")) +if v171.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v171))) +} +v172 := v171.Get() +v173 := lang.Apply(v172, []any{lang.NewSymbol("temp__0__auto__")}) +v174 := lang.Apply(v165, []any{v169, v173}) +v175 := lang.Apply(v162, []any{v174}) +v176 := lang.Apply(v156, []any{v159, v175}) +v177 := lang.Apply(v153, []any{v176}) +v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v179 := v178.FindInternedVar(lang.NewSymbol("list")) +if v179.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) +} +v180 := v179.Get() +v181 := lang.Apply(v180, []any{v6}) +v182 := lang.Apply(v146, []any{v150, v177, v181}) +v183 := lang.Apply(v143, []any{v182}) +v184 := lang.Apply(v140, []any{v183}) +v185 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v186 := v185.FindInternedVar(lang.NewSymbol("list")) +if v186.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v186))) +} +v187 := v186.Get() +v188 := lang.Apply(v187, []any{v7}) +v189 := lang.Apply(v129, []any{v133, v137, v184, v188}) +v190 := lang.Apply(v126, []any{v189}) +v191 := lang.Apply(v123, []any{v190}) +v192 := lang.Apply(v89, []any{v93, v120, v191}) +v193 := lang.Apply(v86, []any{v192}) +return v193 + } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -42382,41 +39968,85 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// unchecked-inc-int +// if-not { -var v1 lang.FnFunc -{ // function unchecked-inc-int__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } +v0 := lang.NewSymbol("if-not").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("test"), lang.NewSymbol("then")), lang.NewVector(lang.NewSymbol("test"), lang.NewSymbol("then"), lang.NewSymbol("else"))), lang.NewKeyword("doc"), "Evaluates test. If logical false, evaluates and returns then expr, \n otherwise else expr, if supplied, else nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(760), lang.NewKeyword("end-line"), int(760))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 4: v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() +v4 := args[1] +v5 := args[2] +v6 := args[3] v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +v8 := v7.FindInternedVar(lang.NewSymbol("seq")) if v8.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } v9 := v8.Get() v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) +v11 := v10.FindInternedVar(lang.NewSymbol("concat")) if v11.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("list")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/if-not")}) +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("list")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v5}) +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("list")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v6}) +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("list")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.Apply(v27, []any{nil}) +v29 := lang.Apply(v12, []any{v16, v20, v24, v28}) +v30 := lang.Apply(v9, []any{v29}) +return v30 + case 5: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := args[4] +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("seq")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("concat")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v15 := v14.FindInternedVar(lang.NewSymbol("list")) if v15.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v17 := lang.Apply(v16, []any{lang.NewSymbol("if")}) v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v19 := v18.FindInternedVar(lang.NewSymbol("list")) if v19.IsMacro() { @@ -42441,191 +40071,474 @@ if v28.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/unchecked_int_inc")}) +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/not")}) v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v32 := v31.FindInternedVar(lang.NewSymbol("list")) if v32.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } v33 := v32.Get() -v34 := lang.Apply(v33, []any{v3}) +v34 := lang.Apply(v33, []any{v5}) v35 := lang.Apply(v26, []any{v30, v34}) v36 := lang.Apply(v23, []any{v35}) v37 := lang.Apply(v20, []any{v36}) -v38 := lang.Apply(v9, []any{v13, v17, v37}) -v39 := lang.Apply(v6, []any{v38}) -return v39 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("unchecked-inc-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns a number one greater than x, an int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1154), lang.NewKeyword("end-line"), int(1154))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "unchecked_int_inc") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_inc is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("list")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) } +v40 := v39.Get() +v41 := lang.Apply(v40, []any{v6}) +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("list")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) } -// to-array -{ -v0 := lang.NewSymbol("to-array").WithMeta(lang.NewMap(lang.NewKeyword("tag"), "[Ljava.lang.Object;", lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns an array of Objects containing the contents of coll, which\n can be any Collection. Maps to java.util.Collection.toArray().", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(337), lang.NewKeyword("end-line"), int(337))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { +v44 := v43.Get() +v45 := lang.Apply(v44, []any{v7}) +v46 := lang.Apply(v13, []any{v17, v37, v41, v45}) +v47 := lang.Apply(v10, []any{v46}) +return v47 + default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := args[0] -v4, _ := lang.FieldOrMethod(runtime3.RT, "ToArray") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ToArray is not a function"))) -} -v5 := lang.Apply(v4, []any{v3}) -return v5 }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), "[Ljava.lang.Object;")).(lang.FnFunc) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// range +// if-some { -v0 := lang.NewSymbol("range").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("end")), lang.NewVector(lang.NewSymbol("start"), lang.NewSymbol("end")), lang.NewVector(lang.NewSymbol("start"), lang.NewSymbol("end"), lang.NewSymbol("step"))), lang.NewKeyword("doc"), "Returns a lazy seq of nums from start (inclusive) to end\n (exclusive), by step, where start defaults to 0, step to 1, and end to\n infinity. When step is equal to 0, returns an infinite sequence of\n start. When start is equal to end, returns empty list.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3018), lang.NewKeyword("end-line"), int(3018))).(*lang.Symbol) +v0 := lang.NewSymbol("if-some").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("then")), lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("then"), lang.NewSymbol("else"), lang.NewSymbol("&"), lang.NewSymbol("oldform"))), lang.NewKeyword("doc"), "bindings => binding-form test\n\n If test is not nil, evaluates then with binding-form bound to the\n value of test, if not, yields else", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1874), lang.NewKeyword("end-line"), int(1874))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 0: -v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v4 := v3.FindInternedVar(lang.NewSymbol("iterate")) -if v4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) -} -v5 := v4.Get() -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("inc'")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v5, []any{v8, int64(0)}) -return v9 - case 1: -v3 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("int?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -if lang.IsTruthy(v8) { -v9 := lang.Apply(lang1.NewLongRange, []any{int64(0), v3, int64(1)}) -v4 = v9 -} else { -v10 := lang.Apply(lang1.NewRange, []any{int64(0), v3, int64(1)}) -v4 = v10 -} -return v4 - case 2: + case 4: v3 := args[0] v4 := args[1] -var v5 any +v5 := args[2] +v6 := args[3] v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("int?")) +v8 := v7.FindInternedVar(lang.NewSymbol("seq")) if v8.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } v9 := v8.Get() -v10 := lang.Apply(v9, []any{v3}) -var v6 any = v10 -_ = v6 -var v12 any -if lang.IsTruthy(v6) { +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("concat")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("int?")) +v14 := v13.FindInternedVar(lang.NewSymbol("list")) if v14.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } v15 := v14.Get() -v16 := lang.Apply(v15, []any{v4}) -v12 = v16 -} else { -v12 = v6 -} -if lang.IsTruthy(v12) { -v6 := lang.Apply(lang1.NewLongRange, []any{v3, v4, int64(1)}) -v5 = v6 -} else { -v7 := lang.Apply(lang1.NewRange, []any{v3, v4, int64(1)}) -v5 = v7 -} -return v5 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -var v6 any -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("int?")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v3}) -var v7 any = v11 -_ = v7 -var v13 any -if lang.IsTruthy(v7) { -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("int?")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/if-some")}) +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("list")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v4}) -var v14 any = v18 -_ = v14 -var v20 any -if lang.IsTruthy(v14) { +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v5}) v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("int?")) +v22 := v21.FindInternedVar(lang.NewSymbol("list")) if v22.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } v23 := v22.Get() -v24 := lang.Apply(v23, []any{v5}) -v20 = v24 -} else { -v20 = v14 -} -v13 = v20 -} else { -v13 = v7 -} -if lang.IsTruthy(v13) { -v7 := lang.Apply(lang1.NewLongRange, []any{v3, v4, v5}) -v6 = v7 -} else { -v8 := lang.Apply(lang1.NewRange, []any{v3, v4, v5}) -v6 = v8 +v24 := lang.Apply(v23, []any{v6}) +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("list")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -return v6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) +v27 := v26.Get() +v28 := lang.Apply(v27, []any{nil}) +v29 := lang.Apply(v12, []any{v16, v20, v24, v28}) +v30 := lang.Apply(v9, []any{v29}) +return v30 + default: + if len(args) < 5 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := args[4] +v8 := lang.NewList(args[5:]...) +var v9 any +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("vector?")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{v5}) +if lang.IsTruthy(v13) { +v9 = nil +} else { +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("str")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("first")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v3}) +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("*ns*")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("meta")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v3}) +v28 := lang.Apply(lang.NewKeyword("line"), []any{v27}) +v29 := lang.Apply(v16, []any{v20, " requires ", "a vector for its binding", " in ", v23, ":", v28}) +v30 := lang.Apply(lang1.NewIllegalArgumentError, []any{v29}) +panic(v30) +} +_ = v9 +var v31 any +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("nil?")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v8}) +if lang.IsTruthy(v35) { +v31 = nil +} else { +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("str")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("first")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +} +v41 := v40.Get() +v42 := lang.Apply(v41, []any{v3}) +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("*ns*")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +} +v45 := v44.Get() +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("meta")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +} +v48 := v47.Get() +v49 := lang.Apply(v48, []any{v3}) +v50 := lang.Apply(lang.NewKeyword("line"), []any{v49}) +v51 := lang.Apply(v38, []any{v42, " requires ", "1 or 2 forms after binding vector", " in ", v45, ":", v50}) +v52 := lang.Apply(lang1.NewIllegalArgumentError, []any{v51}) +panic(v52) +} +_ = v31 +var v53 any +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("=")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +} +v56 := v55.Get() +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("count")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +} +v59 := v58.Get() +v60 := lang.Apply(v59, []any{v5}) +v61 := lang.Apply(v56, []any{int64(2), v60}) +if lang.IsTruthy(v61) { +v53 = nil +} else { +v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v63 := v62.FindInternedVar(lang.NewSymbol("str")) +if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +} +v64 := v63.Get() +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("first")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +} +v67 := v66.Get() +v68 := lang.Apply(v67, []any{v3}) +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("*ns*")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +} +v71 := v70.Get() +v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v73 := v72.FindInternedVar(lang.NewSymbol("meta")) +if v73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) +} +v74 := v73.Get() +v75 := lang.Apply(v74, []any{v3}) +v76 := lang.Apply(lang.NewKeyword("line"), []any{v75}) +v77 := lang.Apply(v64, []any{v68, " requires ", "exactly 2 forms in binding vector", " in ", v71, ":", v76}) +v78 := lang.Apply(lang1.NewIllegalArgumentError, []any{v77}) +panic(v78) +} +_ = v53 +_ = nil +v80 := lang.Apply(v5, []any{int64(0)}) +var v79 any = v80 +_ = v79 +v82 := lang.Apply(v5, []any{int64(1)}) +var v81 any = v82 +_ = v81 +v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v85 := v84.FindInternedVar(lang.NewSymbol("seq")) +if v85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) +} +v86 := v85.Get() +v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v88 := v87.FindInternedVar(lang.NewSymbol("concat")) +if v88.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) +} +v89 := v88.Get() +v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v91 := v90.FindInternedVar(lang.NewSymbol("list")) +if v91.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) +} +v92 := v91.Get() +v93 := lang.Apply(v92, []any{lang.NewSymbol("glojure.core/let")}) +v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v95 := v94.FindInternedVar(lang.NewSymbol("list")) +if v95.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) +} +v96 := v95.Get() +v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v98 := v97.FindInternedVar(lang.NewSymbol("apply")) +if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) +} +v99 := v98.Get() +v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v101 := v100.FindInternedVar(lang.NewSymbol("vector")) +if v101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) +} +v102 := v101.Get() +v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v104 := v103.FindInternedVar(lang.NewSymbol("seq")) +if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) +} +v105 := v104.Get() +v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v107 := v106.FindInternedVar(lang.NewSymbol("concat")) +if v107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) +} +v108 := v107.Get() +v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v110 := v109.FindInternedVar(lang.NewSymbol("list")) +if v110.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) +} +v111 := v110.Get() +v112 := lang.Apply(v111, []any{lang.NewSymbol("temp__0__auto__")}) +v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v114 := v113.FindInternedVar(lang.NewSymbol("list")) +if v114.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) +} +v115 := v114.Get() +v116 := lang.Apply(v115, []any{v81}) +v117 := lang.Apply(v108, []any{v112, v116}) +v118 := lang.Apply(v105, []any{v117}) +v119 := lang.Apply(v99, []any{v102, v118}) +v120 := lang.Apply(v96, []any{v119}) +v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v122 := v121.FindInternedVar(lang.NewSymbol("list")) +if v122.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) +} +v123 := v122.Get() +v124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v125 := v124.FindInternedVar(lang.NewSymbol("seq")) +if v125.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v125))) +} +v126 := v125.Get() +v127 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v128 := v127.FindInternedVar(lang.NewSymbol("concat")) +if v128.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v128))) +} +v129 := v128.Get() +v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v131 := v130.FindInternedVar(lang.NewSymbol("list")) +if v131.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) +} +v132 := v131.Get() +v133 := lang.Apply(v132, []any{lang.NewSymbol("if")}) +v134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v135 := v134.FindInternedVar(lang.NewSymbol("list")) +if v135.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v135))) +} +v136 := v135.Get() +v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v138 := v137.FindInternedVar(lang.NewSymbol("seq")) +if v138.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) +} +v139 := v138.Get() +v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v141 := v140.FindInternedVar(lang.NewSymbol("concat")) +if v141.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) +} +v142 := v141.Get() +v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v144 := v143.FindInternedVar(lang.NewSymbol("list")) +if v144.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) +} +v145 := v144.Get() +v146 := lang.Apply(v145, []any{lang.NewSymbol("glojure.core/nil?")}) +v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v148 := v147.FindInternedVar(lang.NewSymbol("list")) +if v148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) +} +v149 := v148.Get() +v150 := lang.Apply(v149, []any{lang.NewSymbol("temp__0__auto__")}) +v151 := lang.Apply(v142, []any{v146, v150}) +v152 := lang.Apply(v139, []any{v151}) +v153 := lang.Apply(v136, []any{v152}) +v154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v155 := v154.FindInternedVar(lang.NewSymbol("list")) +if v155.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v155))) +} +v156 := v155.Get() +v157 := lang.Apply(v156, []any{v7}) +v158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v159 := v158.FindInternedVar(lang.NewSymbol("list")) +if v159.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v159))) +} +v160 := v159.Get() +v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v162 := v161.FindInternedVar(lang.NewSymbol("seq")) +if v162.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) +} +v163 := v162.Get() +v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v165 := v164.FindInternedVar(lang.NewSymbol("concat")) +if v165.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) +} +v166 := v165.Get() +v167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v168 := v167.FindInternedVar(lang.NewSymbol("list")) +if v168.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v168))) +} +v169 := v168.Get() +v170 := lang.Apply(v169, []any{lang.NewSymbol("glojure.core/let")}) +v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v172 := v171.FindInternedVar(lang.NewSymbol("list")) +if v172.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) +} +v173 := v172.Get() +v174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v175 := v174.FindInternedVar(lang.NewSymbol("apply")) +if v175.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v175))) +} +v176 := v175.Get() +v177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v178 := v177.FindInternedVar(lang.NewSymbol("vector")) +if v178.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v178))) +} +v179 := v178.Get() +v180 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v181 := v180.FindInternedVar(lang.NewSymbol("seq")) +if v181.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v181))) +} +v182 := v181.Get() +v183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v184 := v183.FindInternedVar(lang.NewSymbol("concat")) +if v184.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v184))) +} +v185 := v184.Get() +v186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v187 := v186.FindInternedVar(lang.NewSymbol("list")) +if v187.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v187))) +} +v188 := v187.Get() +v189 := lang.Apply(v188, []any{v79}) +v190 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v191 := v190.FindInternedVar(lang.NewSymbol("list")) +if v191.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v191))) +} +v192 := v191.Get() +v193 := lang.Apply(v192, []any{lang.NewSymbol("temp__0__auto__")}) +v194 := lang.Apply(v185, []any{v189, v193}) +v195 := lang.Apply(v182, []any{v194}) +v196 := lang.Apply(v176, []any{v179, v195}) +v197 := lang.Apply(v173, []any{v196}) +v198 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v199 := v198.FindInternedVar(lang.NewSymbol("list")) +if v199.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v199))) +} +v200 := v199.Get() +v201 := lang.Apply(v200, []any{v6}) +v202 := lang.Apply(v166, []any{v170, v197, v201}) +v203 := lang.Apply(v163, []any{v202}) +v204 := lang.Apply(v160, []any{v203}) +v205 := lang.Apply(v129, []any{v133, v153, v157, v204}) +v206 := lang.Apply(v126, []any{v205}) +v207 := lang.Apply(v123, []any{v206}) +v208 := lang.Apply(v89, []any{v93, v120, v207}) +v209 := lang.Apply(v86, []any{v208}) +return v209 } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -42634,9 +40547,9 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// qualified-keyword? +// ifn? { -v0 := lang.NewSymbol("qualified-keyword?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a keyword with a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1638), lang.NewKeyword("end-line"), int(1638))).(*lang.Symbol) +v0 := lang.NewSymbol("ifn?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements IFn. Note that many data structures\n (e.g. sets and maps) implement IFn", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6252), lang.NewKeyword("end-line"), int(6252))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -42644,42 +40557,12 @@ v2 = lang.NewFnFunc(func(args ...any) any { } v3 := args[0] v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("boolean")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("keyword?")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v3}) -var v7 any = v11 -_ = v7 -var v13 any -if lang.IsTruthy(v7) { -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("namespace")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v3}) -var v14 any = v18 -_ = v14 -var v20 any -if lang.IsTruthy(v14) { -v20 = true -} else { -v20 = v14 -} -v13 = v20 -} else { -v13 = v7 -} -v7 := lang.Apply(v6, []any{v13}) +v7 := lang.Apply(v6, []any{glojure.lang8.IFn, v3}) return v7 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -42688,98 +40571,239 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// agent +// import { -v0 := lang.NewSymbol("agent").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("state"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Creates and returns an agent with an initial value of state and\n zero or more options (in any order):\n\n :meta metadata-map\n\n :validator validate-fn\n\n :error-handler handler-fn\n\n :error-mode mode-keyword\n\n If metadata-map is supplied, it will become the metadata on the\n agent. validate-fn must be nil or a side-effect-free fn of one\n argument, which will be passed the intended new state on any state\n change. If the new state is unacceptable, the validate-fn should\n return false or throw an exception. handler-fn is called if an\n action throws an exception or if validate-fn rejects a new state --\n see set-error-handler! for details. The mode-keyword may be either\n :continue (the default if an error-handler is given) or :fail (the\n default if no error-handler is given) -- see set-error-mode! for\n details.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2052), lang.NewKeyword("end-line"), int(2052))).(*lang.Symbol) +v0 := lang.NewSymbol("import").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("import-symbols-or-lists"))), lang.NewKeyword("doc"), "import-list => (package-symbol class-name-symbols*)\n\n For each name in class-name-symbols, adds a mapping from name to the\n class named by package.name to the current namespace. Use :import in the ns\n macro in preference to calling this directly.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3426), lang.NewKeyword("end-line"), int(3426))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 1 { + if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := lang.NewList(args[1:]...) -var v5 any = "unimplemented: new with non-constant class type" -_ = v5 +v4 := args[1] +v5 := lang.NewList(args[2:]...) v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("apply")) +v8 := v7.FindInternedVar(lang.NewSymbol("map")) if v8.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("hash-map")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +var v10 lang.FnFunc +v10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v11 := args[0] +var v12 any +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("seq?")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v12 := v11.Get() -v13 := lang.Apply(v9, []any{v12, v4}) +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v11}) +var v13 any = v17 +_ = v13 +var v19 any +if lang.IsTruthy(v13) { +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("=")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("first")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{v11}) +v27 := lang.Apply(v22, []any{lang.NewSymbol("quote"), v26}) +v19 = v27 +} else { +v19 = v13 +} +if lang.IsTruthy(v19) { +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("second")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v11}) +v12 = v16 +} else { +v12 = v11 +} +return v12 +}) +v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3434), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(3434), lang.NewKeyword("end-column"), int(73)) +v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v13 := lang.Apply(v9, []any{v12, v5}) var v6 any = v13 _ = v6 v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("setup-reference")) +v16 := v15.FindInternedVar(lang.NewSymbol("seq")) if v16.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } v17 := v16.Get() -v18 := lang.Apply(v17, []any{v5, v4}) -_ = v18 -var v19 any -v20 := lang.Apply(lang.NewKeyword("error-handler"), []any{v6}) -if lang.IsTruthy(v20) { -v21 := lang.Apply(lang.NewKeyword("error-handler"), []any{v6}) -v22, _ := lang.FieldOrMethod(v5, "setErrorHandler") -if reflect.TypeOf(v22).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorHandler is not a function"))) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("concat")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v23 := lang.Apply(v22, []any{v21}) -v19 = v23 -} else { -v19 = nil +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("list")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -_ = v19 -v25 := lang.Apply(lang.NewKeyword("error-mode"), []any{v6}) -var v24 any = v25 -_ = v24 -var v27 any -if lang.IsTruthy(v24) { -v27 = v24 -} else { -var v28 any -v29 := lang.Apply(lang.NewKeyword("error-handler"), []any{v6}) -if lang.IsTruthy(v29) { -v28 = lang.NewKeyword("continue") +v23 := v22.Get() +v24 := lang.Apply(v23, []any{lang.NewSymbol("do")}) +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("map")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +var v28 lang.FnFunc +v28 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v29 := args[0] +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("list")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.Apply(v32, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Import"), v29}) +return v33 +}) +v29 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3436), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(3436), lang.NewKeyword("end-column"), int(73)) +v30, err := lang.WithMeta(v28, v29.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("reduce1")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +var v34 lang.FnFunc +v34 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v35 := args[0] +v36 := args[1] +var v37 any +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("symbol?")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.Apply(v40, []any{v36}) +if lang.IsTruthy(v41) { +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("conj")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +} +v44 := v43.Get() +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("name")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +} +v47 := v46.Get() +v48 := lang.Apply(v47, []any{v36}) +v49 := lang.Apply(v44, []any{v35, v48}) +v37 = v49 } else { -v28 = lang.NewKeyword("fail") +v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v52 := v51.FindInternedVar(lang.NewSymbol("first")) +if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) } -v27 = v28 +v53 := v52.Get() +v54 := lang.Apply(v53, []any{v36}) +var v50 any = v54 +_ = v50 +v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v57 := v56.FindInternedVar(lang.NewSymbol("rest")) +if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) } -v24, _ := lang.FieldOrMethod(v5, "setErrorMode") -if reflect.TypeOf(v24).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorMode is not a function"))) +v58 := v57.Get() +v59 := lang.Apply(v58, []any{v36}) +var v55 any = v59 +_ = v55 +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("into1")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) } -v25 := lang.Apply(v24, []any{v27}) -_ = v25 -return v5 +v63 := v62.Get() +v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v65 := v64.FindInternedVar(lang.NewSymbol("map")) +if v65.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) +} +v66 := v65.Get() +var v67 lang.FnFunc +v67 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } +v68 := args[0] +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("str")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +} +v71 := v70.Get() +v72 := lang.Apply(v71, []any{v50, ".", v68}) +return v72 }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v68 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3441), lang.NewKeyword("column"), int(45), lang.NewKeyword("end-line"), int(3441), lang.NewKeyword("end-column"), int(58)) +v69, err := lang.WithMeta(v67, v68.(lang.IPersistentMap)) +if err != nil { + panic(err) } +v70 := lang.Apply(v66, []any{v69, v55}) +v71 := lang.Apply(v63, []any{v35, v70}) +v37 = v71 } -// release-pending-sends -{ -v0 := lang.NewSymbol("release-pending-sends").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Normally, actions sent directly or indirectly during another action\n are held until the action completes (changes the agent's\n state). This function can be used to dispatch any pending sent\n actions immediately. This has no impact on actions sent during a\n transaction, which are still held until commit. If no action is\n occurring, does nothing. Returns the number of actions dispatched.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2131), lang.NewKeyword("end-line"), int(2131))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) +return v37 +}) +v35 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3437), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(3441), lang.NewKeyword("end-column"), int(66)) +v36, err := lang.WithMeta(v34, v35.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v37 := lang.NewVector() +v38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3442), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(3442), lang.NewKeyword("end-column"), int(26)) +v39, err := lang.WithMeta(v37, v38.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v40 := lang.Apply(v33, []any{v36, v39, v6}) +v41 := lang.Apply(v27, []any{v30, v40}) +v42 := lang.Apply(v20, []any{v24, v41}) +v43 := lang.Apply(v17, []any{v42}) +return v43 } -v3 := lang.Apply(nil, nil) -return v3 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -42787,25 +40811,23 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// *print-namespace-maps* +// in-ns { -v0 := lang.NewSymbol("*print-namespace-maps*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(39), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(44), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, false, true) +v0 := lang.NewSymbol("in-ns").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, nil, true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// double-array +// inc { var v1 lang.FnFunc -{ // function double-array__inliner +{ // function inc__inliner v1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewList(args[0:]...) + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v5 := v4.FindInternedVar(lang.NewSymbol("seq")) if v5.IsMacro() { @@ -42838,74 +40860,67 @@ if v19.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } v20 := v19.Get() -v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/doubleArray")}) -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("list")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("seq")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("concat")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v30 := v29.Get() +v29 := v28.Get() +var v30 any v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) +v32 := v31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) if v32.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } v33 := v32.Get() -v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) +if lang.IsTruthy(v33) { +v30 = lang.NewSymbol("unchecked_inc") +} else { +v30 = lang.NewSymbol("inc") +} +v34 := lang.Apply(v29, []any{v30}) v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v36 := v35.FindInternedVar(lang.NewSymbol("list")) if v36.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) } v37 := v36.Get() -v38 := lang.Apply(v37, []any{lang.NewSymbol("glojure.core/args")}) -v39 := lang.Apply(v30, []any{v34, v38}) -v40 := lang.Apply(v27, []any{v39}) -v41 := lang.Apply(v24, []any{v40}) -v42 := lang.Apply(v9, []any{v13, v17, v21, v41}) +v38 := lang.Apply(v37, []any{v3}) +v39 := lang.Apply(v26, []any{v34, v38}) +v40 := lang.Apply(v23, []any{v39}) +v41 := lang.Apply(v20, []any{v40}) +v42 := lang.Apply(v9, []any{v13, v17, v41}) v43 := lang.Apply(v6, []any{v42}) return v43 - } }) v2 := v1 _ = v2 } -v0 := lang.NewSymbol("double-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Creates an array of doubles", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5341), lang.NewKeyword("end-line"), int(5341))).(*lang.Symbol) +v0 := lang.NewSymbol("inc").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns a number one greater than num. Does not auto-promote\n longs, will throw on overflow. See also: inc'", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(915), lang.NewKeyword("end-line"), int(915))).(*lang.Symbol) var v3 lang.FnFunc v3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "doubleArray") +v5, _ := lang.FieldOrMethod(lang1.Numbers, "inc") if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("doubleArray is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("inc is not a function"))) } v6 := lang.Apply(v5, []any{v4}) return v6 - case 2: -v4 := args[0] -v5 := args[1] -v6, _ := lang.FieldOrMethod(lang1.Numbers, "doubleArrayInit") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("doubleArrayInit is not a function"))) -} -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } }) v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v2 := ns.InternWithValue(v0, v3, true) @@ -42913,61 +40928,10 @@ if v0.Meta() != nil { v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// bound? -{ -v0 := lang.NewSymbol("bound?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("vars"))), lang.NewKeyword("doc"), "Returns true if all of the vars provided as arguments have any bound value, root or thread-local.\n Implies that deref'ing the provided vars will succeed. Returns true if no vars are provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5534), lang.NewKeyword("end-line"), int(5534))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewList(args[0:]...) -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("every?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -var v7 lang.FnFunc -v7 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v8 := args[0] -v9, ok := lang.FieldOrMethod(v8, "isBound") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "isBound"))) -} -var v10 any -switch reflect.TypeOf(v9).Kind() { -case reflect.Func: - v10 = lang.Apply(v9, nil) -default: - v10 = v9 -} -return v10 -}) -v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5540), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5540), lang.NewKeyword("end-column"), int(69)) -v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v10 := lang.Apply(v6, []any{v9, v3}) -return v10 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// unchecked-inc +// inc' { var v1 lang.FnFunc -{ // function unchecked-inc__inliner +{ // function inc'__inliner v1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -43023,7 +40987,7 @@ if v28.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/unchecked_inc")}) +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/incP")}) v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v32 := v31.FindInternedVar(lang.NewSymbol("list")) if v32.IsMacro() { @@ -43041,16 +41005,16 @@ return v39 v2 := v1 _ = v2 } -v0 := lang.NewSymbol("unchecked-inc").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns a number one greater than x, a long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1161), lang.NewKeyword("end-line"), int(1161))).(*lang.Symbol) +v0 := lang.NewSymbol("inc'").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns a number one greater than num. Supports arbitrary precision.\n See also: inc", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(908), lang.NewKeyword("end-line"), int(908))).(*lang.Symbol) var v3 lang.FnFunc v3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "unchecked_inc") +v5, _ := lang.FieldOrMethod(lang1.Numbers, "incP") if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_inc is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("incP is not a function"))) } v6 := lang.Apply(v5, []any{v4}) return v6 @@ -43061,21 +41025,23 @@ if v0.Meta() != nil { v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// struct +// indexed? { -v0 := lang.NewSymbol("struct").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("&"), lang.NewSymbol("vals"))), lang.NewKeyword("doc"), "Returns a new structmap instance with the keys of the\n structure-basis. vals must be supplied for basis keys in order -\n where values are not supplied they will default to nil.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4061), lang.NewKeyword("end-line"), int(4061))).(*lang.Symbol) +v0 := lang.NewSymbol("indexed?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return true if coll implements Indexed, indicating efficient lookup by index", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6306), lang.NewKeyword("end-line"), int(6306))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.NewList(args[1:]...) -v5 := lang.Apply(lang1.ConstructPersistentStructMap, []any{v3, v4}) -return v5 + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{glojure.lang8.Indexed, v3}) +return v7 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -43083,82 +41049,75 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// libspec? +// infinite? { -v0 := lang.NewSymbol("libspec?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is a libspec", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5891), lang.NewKeyword("end-line"), int(5891), lang.NewKeyword("private"), true)).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { +var v1 lang.FnFunc +{ // function infinite?__inliner +v1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("symbol?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -var v4 any = v8 -_ = v4 -var v10 any -if lang.IsTruthy(v4) { -v10 = v4 -} else { -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("vector?")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v3}) -var v11 any = v15 -_ = v11 -var v17 any -if lang.IsTruthy(v11) { -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("nil?")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("second")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v26 := lang.Apply(v21, []any{v25}) -var v18 any = v26 -_ = v18 -var v28 any -if lang.IsTruthy(v18) { -v28 = v18 -} else { -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("keyword?")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("second")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol("Double/isInfinite")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.Apply(v31, []any{v35}) -v28 = v36 +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v3}) +v18 := lang.Apply(v9, []any{v13, v17}) +v19 := lang.Apply(v6, []any{v18}) +return v19 +}) +v2 := v1 +_ = v2 } -v17 = v28 -} else { -v17 = v11 +v0 := lang.NewSymbol("infinite?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns true if num is negative or positive infinity, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)), lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(8020), lang.NewKeyword("end-line"), int(8020))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := lang.Apply(nil, []any{v4}) +return v5 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v10 = v17 } -return v10 +// inst-ms +{ +v0 := lang.NewSymbol("inst-ms").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("inst"))), lang.NewKeyword("doc"), "Return the number of milliseconds since January 1, 1970, 00:00:00 GMT", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6874), lang.NewKeyword("end-line"), int(6874))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.Apply(nil, []any{v3}) +return v4 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -43166,23 +41125,16 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// boolean? +// inst? { -v0 := lang.NewSymbol("boolean?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a Boolean", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(518), lang.NewKeyword("end-line"), int(518))).(*lang.Symbol) +v0 := lang.NewSymbol("inst?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x satisfies Inst", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6880), lang.NewKeyword("end-line"), int(6880))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{lang.Builtins["bool"], v3}) -return v7 +return nil }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -43190,305 +41142,318 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// print-str +// instance? { -v1 := reflect.TypeOf("") -v0 := lang.NewSymbol("print-str").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("xs"))), lang.NewKeyword("doc"), "print to a string, returning it", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4776), lang.NewKeyword("end-line"), int(4776))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := lang.NewList(args[0:]...) -var v5 any = "unimplemented: new with non-constant class type" -_ = v5 -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("push-thread-bindings")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("hash-map")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*out*")) -v15 := lang.Apply(v13, []any{v14, v5}) -v16 := lang.Apply(v10, []any{v15}) -_ = v16 -var v17 any -func() { -defer func() { -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v20, nil) -}() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("apply")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("print")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.Apply(v24, []any{v27, v4}) -_ = v28 -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("str")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.Apply(v31, []any{v5}) -v17 = v32 -}() -return v17 +v0 := lang.NewSymbol("instance?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Evaluates x and tests if it is an instance of the type\n t. Returns true or false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(139), lang.NewKeyword("end-line"), int(143))).(*lang.Symbol) +var v2 lang.FnFunc +{ // function instance? +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } +v4 := args[0] +v5 := args[1] +v6 := lang.Apply(lang1.HasType, []any{v4, v5}) +return v6 }) -v4 := reflect.TypeOf("") -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(143), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(143), lang.NewKeyword("end-column"), int(85))).(lang.FnFunc) +v3 := v2 +_ = v3 +} +v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// stream-into! +// int { -v0 := lang.NewSymbol("stream-into!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("stream")), lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("xform"), lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Returns a new coll consisting of coll with all of the items of the\n stream conjoined. This is a terminal operation on the stream.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6853), lang.NewKeyword("end-line"), int(6853))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: +var v1 lang.FnFunc +{ // function int__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] -v4 := args[1] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v8 := v7.Get() -v9 := lang.Apply(v8, []any{lang1.IEditableCollection, v3}) -if lang.IsTruthy(v9) { +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("with-meta")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) if v11.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("persistent!")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("stream-reduce!")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v18 := v17.Get() -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("conj!")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("transient")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v26 := lang.Apply(v18, []any{v21, v25, v4}) -v27 := lang.Apply(v15, []any{v26}) -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("meta")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v30 := v29.Get() -v31 := lang.Apply(v30, []any{v3}) -v32 := lang.Apply(v12, []any{v27, v31}) -v5 = v32 +v29 := v28.Get() +var v30 any +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +if lang.IsTruthy(v33) { +v30 = lang.NewSymbol("uncheckedIntCast") } else { -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("stream-reduce!")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +v30 = lang.NewSymbol("intCast") } -v35 := v34.Get() -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("conj")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +v34 := lang.Apply(v29, []any{v30}) +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("list")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) } -v38 := v37.Get() -v39 := lang.Apply(v35, []any{v38, v3, v4}) -v5 = v39 +v37 := v36.Get() +v38 := lang.Apply(v37, []any{v3}) +v39 := lang.Apply(v26, []any{v34, v38}) +v40 := lang.Apply(v23, []any{v39}) +v41 := lang.Apply(v20, []any{v40}) +v42 := lang.Apply(v9, []any{v13, v17, v41}) +v43 := lang.Apply(v6, []any{v42}) +return v43 +}) +v2 := v1 +_ = v2 } -return v5 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -var v6 any +v0 := lang.NewSymbol("int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to int", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(875), lang.NewKeyword("end-line"), int(875))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5, _ := lang.FieldOrMethod(runtime9.RT, "IntCast") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("IntCast is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// int-array +{ +var v1 lang.FnFunc +{ // function int-array__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.NewList(args[0:]...) +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("instance?")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) if v8.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } v9 := v8.Get() -v10 := lang.Apply(v9, []any{lang1.IEditableCollection, v3}) -if lang.IsTruthy(v10) { -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("with-meta")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v13 := v12.Get() +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("persistent!")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) if v15.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } v16 := v15.Get() -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("stream-transduce!")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("conj!")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +v20 := v19.Get() +v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/intArray")}) +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("list")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("transient")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("seq")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -v25 := v24.Get() -v26 := lang.Apply(v25, []any{v3}) -v27 := lang.Apply(v19, []any{v4, v22, v26, v5}) -v28 := lang.Apply(v16, []any{v27}) -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("meta")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("concat")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } -v31 := v30.Get() -v32 := lang.Apply(v31, []any{v3}) -v33 := lang.Apply(v13, []any{v28, v32}) -v6 = v33 -} else { -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("stream-transduce!")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("conj")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +v33 := v32.Get() +v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("list")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) } -v39 := v38.Get() -v40 := lang.Apply(v36, []any{v4, v39, v3, v5}) -v6 = v40 +v37 := v36.Get() +v38 := lang.Apply(v37, []any{lang.NewSymbol("glojure.core/args")}) +v39 := lang.Apply(v30, []any{v34, v38}) +v40 := lang.Apply(v27, []any{v39}) +v41 := lang.Apply(v24, []any{v40}) +v42 := lang.Apply(v9, []any{v13, v17, v21, v41}) +v43 := lang.Apply(v6, []any{v42}) +return v43 + } +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("int-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Creates an array of ints", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5356), lang.NewKeyword("end-line"), int(5356))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "intArray") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("intArray is not a function"))) } +v6 := lang.Apply(v5, []any{v4}) return v6 + case 2: +v4 := args[0] +v5 := args[1] +v6, _ := lang.FieldOrMethod(lang1.Numbers, "intArrayInit") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("intArrayInit is not a function"))) +} +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// filterv +// int? { -v0 := lang.NewSymbol("filterv").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a vector of the items in coll for which\n (pred item) returns logical true. pred must be free of side-effects.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7004), lang.NewKeyword("end-line"), int(7004))).(*lang.Symbol) +v0 := lang.NewSymbol("int?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a fixed precision integer", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1395), lang.NewKeyword("end-line"), int(1395))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := args[1] v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("persistent!")) +v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) if v6.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("reduce")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v8 := lang.Apply(v7, []any{lang.Builtins["int64"], v3}) +var v4 any = v8 +_ = v4 +var v10 any +if lang.IsTruthy(v4) { +v10 = v4 +} else { +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("instance?")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } -v10 := v9.Get() -var v11 lang.FnFunc -v11 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v12 := args[0] -v13 := args[1] -var v14 any -v15 := lang.Apply(v3, []any{v13}) -if lang.IsTruthy(v15) { -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("conj!")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +v14 := v13.Get() +v15 := lang.Apply(v14, []any{nil, v3}) +var v11 any = v15 +_ = v11 +var v17 any +if lang.IsTruthy(v11) { +v17 = v11 +} else { +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("instance?")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v12, v13}) -v14 = v19 +v21 := v20.Get() +v22 := lang.Apply(v21, []any{nil, v3}) +var v18 any = v22 +_ = v18 +var v24 any +if lang.IsTruthy(v18) { +v24 = v18 } else { -v14 = v12 +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("instance?")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -return v14 -}) -v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7010), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(7010), lang.NewKeyword("end-column"), int(52)) -v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) -if err != nil { - panic(err) +v27 := v26.Get() +v28 := lang.Apply(v27, []any{nil, v3}) +v24 = v28 } -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("transient")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v17 = v24 } -v16 := v15.Get() -v17 := lang.NewVector() -v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7011), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(7011), lang.NewKeyword("end-column"), int(27)) -v19, err := lang.WithMeta(v17, v18.(lang.IPersistentMap)) -if err != nil { - panic(err) +v10 = v17 } -v20 := lang.Apply(v16, []any{v19}) -v21 := lang.Apply(v10, []any{v13, v20, v4}) -v22 := lang.Apply(v7, []any{v21}) -return v22 +return v10 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -43496,465 +41461,464 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// min +// integer? { -var v1 lang.FnFunc -v1 = lang.NewFnFunc(func(args ...any) any { +v0 := lang.NewSymbol("integer?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is an integer", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1379), lang.NewKeyword("end-line"), int(1379))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.Apply(lang1.IsInteger, []any{v3}) +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// interleave +{ +v0 := lang.NewSymbol("interleave").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("c1")), lang.NewVector(lang.NewSymbol("c1"), lang.NewSymbol("c2")), lang.NewVector(lang.NewSymbol("c1"), lang.NewSymbol("c2"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Returns a lazy seq of the first item in each coll, then the second etc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4308), lang.NewKeyword("end-line"), int(4308))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { + case 0: +return lang.NewList() case 1: -v2 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -if lang.IsTruthy(v7) { -v4 = closed7 -} else { -v4 = v3 +v3 := args[0] +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +return v3 +}) +v5 := lang.Apply(lang1.NewLazySeq, []any{v4}) +return v5 + case 2: +v3 := args[0] +v4 := args[1] +var v5 lang.FnFunc +v5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("seq")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -var v3 any = v4 -_ = v3 -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("seq")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v3}) +var v6 any = v10 +_ = v6 v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("concat")) +v13 := v12.FindInternedVar(lang.NewSymbol("seq")) if v13.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +v15 := lang.Apply(v14, []any{v4}) +var v11 any = v15 +_ = v11 +var v17 any +var v18 any = v6 +_ = v18 +var v20 any +if lang.IsTruthy(v18) { +v20 = v11 +} else { +v20 = v18 } -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +if lang.IsTruthy(v20) { +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("cons")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v21 := v20.Get() -v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("first")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("seq")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v6}) +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("cons")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("concat")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("first")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } -v31 := v30.Get() +v30 := v29.Get() +v31 := lang.Apply(v30, []any{v11}) v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) +v33 := v32.FindInternedVar(lang.NewSymbol("interleave")) if v33.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) } v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("rest")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) } -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v2}) -v40 := lang.Apply(v31, []any{v35, v39}) -v41 := lang.Apply(v28, []any{v40}) -v42 := lang.Apply(v25, []any{v41}) -v43 := lang.Apply(v14, []any{v18, v22, v42}) -v44 := lang.Apply(v11, []any{v43}) -return v44 - case 2: -v2 := args[0] -v3 := args[1] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +v37 := v36.Get() +v38 := lang.Apply(v37, []any{v6}) +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("rest")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) } -v8 := v7.Get() -if lang.IsTruthy(v8) { -v5 = closed7 +v41 := v40.Get() +v42 := lang.Apply(v41, []any{v11}) +v43 := lang.Apply(v34, []any{v38, v42}) +v44 := lang.Apply(v27, []any{v31, v43}) +v45 := lang.Apply(v20, []any{v24, v44}) +v17 = v45 } else { -v5 = v4 -} -var v4 any = v5 -_ = v4 -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("seq")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("concat")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("list")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("list")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("list")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("seq")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("concat")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("list")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v4}) -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("list")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v2}) -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("list")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +v17 = nil } -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v3}) -v45 := lang.Apply(v32, []any{v36, v40, v44}) -v46 := lang.Apply(v29, []any{v45}) -v47 := lang.Apply(v26, []any{v46}) -v48 := lang.Apply(v15, []any{v19, v23, v47}) -v49 := lang.Apply(v12, []any{v48}) -return v49 +return v17 +}) +v6 := lang.Apply(lang1.NewLazySeq, []any{v5}) +return v6 default: if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v2 := args[0] -v3 := args[1] -v4 := lang.NewList(args[2:]...) -var v6 any -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -if lang.IsTruthy(v9) { -v6 = closed7 -} else { -v6 = v5 +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +var v6 lang.FnFunc +v6 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("map")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -var v5 any = v6 -_ = v5 +v10 := v9.Get() v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) +v12 := v11.FindInternedVar(lang.NewSymbol("seq")) if v12.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } v13 := v12.Get() -var v14 lang.FnFunc -v14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v15 := args[0] -v16 := args[1] -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("conj")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("concat")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v5, v4, v3}) +v18 := lang.Apply(v10, []any{v13, v17}) +var v7 any = v18 +_ = v7 +var v20 any +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("every?")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("identity")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v26 := v25.Get() +v27 := lang.Apply(v23, []any{v26, v7}) +if lang.IsTruthy(v27) { +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("concat")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v30 := v29.Get() v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) +v32 := v31.FindInternedVar(lang.NewSymbol("map")) if v32.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } v33 := v32.Get() v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +v35 := v34.FindInternedVar(lang.NewSymbol("first")) if v35.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +v37 := lang.Apply(v33, []any{v36, v7}) +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("apply")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) } -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("interleave")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v5}) +v43 := v42.Get() v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) +v45 := v44.FindInternedVar(lang.NewSymbol("map")) if v45.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } v46 := v45.Get() -v47 := lang.Apply(v46, []any{v15}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("rest")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) } -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v16}) -v52 := lang.Apply(v39, []any{v43, v47, v51}) -v53 := lang.Apply(v36, []any{v52}) -v54 := lang.Apply(v33, []any{v53}) -v55 := lang.Apply(v22, []any{v26, v30, v54}) -v56 := lang.Apply(v19, []any{v55}) -return v56 +v49 := v48.Get() +v50 := lang.Apply(v46, []any{v49, v7}) +v51 := lang.Apply(v40, []any{v43, v50}) +v52 := lang.Apply(v30, []any{v37, v51}) +v20 = v52 +} else { +v20 = nil +} +return v20 }) -v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) -v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) -if err != nil { - panic(err) +v7 := lang.Apply(lang1.NewLazySeq, []any{v6}) +return v7 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// intern +{ +v0 := lang.NewSymbol("intern").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name"), lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Finds or creates a var named by the symbol name in the namespace\n ns (which can be a symbol or a namespace), setting its root binding\n to val if supplied. The namespace must exist. The var will adopt any\n metadata from the name symbol. Returns the var.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6354), lang.NewKeyword("end-line"), int(6354))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v3 := args[0] +v4 := args[1] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("the-ns")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v3}) +v10 := lang.Apply(nil, []any{v9, v4}) +var v5 any = v10 +_ = v5 +var v12 any +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("meta")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v4}) +if lang.IsTruthy(v16) { v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +v18 := v17.FindInternedVar(lang.NewSymbol("meta")) if v18.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("concat")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v20 := lang.Apply(v19, []any{v4}) +v21, _ := lang.FieldOrMethod(v5, "setMeta") +if reflect.TypeOf(v21).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMeta is not a function"))) } -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v22 := lang.Apply(v21, []any{v20}) +v12 = v22 +} else { +v12 = nil } -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +_ = v12 +return v5 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("the-ns")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v3}) +v11 := lang.Apply(nil, []any{v10, v4, v5}) +var v6 any = v11 +_ = v6 +var v13 any +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("meta")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v4}) +if lang.IsTruthy(v17) { +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("meta")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v5}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +v20 := v19.Get() +v21 := lang.Apply(v20, []any{v4}) +v22, _ := lang.FieldOrMethod(v6, "setMeta") +if reflect.TypeOf(v22).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMeta is not a function"))) } -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v2}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +v23 := lang.Apply(v22, []any{v21}) +v13 = v23 +} else { +v13 = nil } -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v3}) -v52 := lang.Apply(v39, []any{v43, v47, v51}) -v53 := lang.Apply(v36, []any{v52}) -v54 := lang.Apply(v33, []any{v53}) -v55 := lang.Apply(v22, []any{v26, v30, v54}) -v56 := lang.Apply(v19, []any{v55}) -v57 := lang.Apply(v13, []any{v16, v56, v4}) -return v57 +_ = v13 +return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) -v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// interpose +{ +v0 := lang.NewSymbol("interpose").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sep")), lang.NewVector(lang.NewSymbol("sep"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy seq of the elements of coll separated by sep.\n Returns a stateful transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5230), lang.NewKeyword("end-line"), int(5230))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + switch len(args) { + case 1: v3 := args[0] -v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) -} -v5 := lang.Apply(v4, []any{v3, int64(1)}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v0 := lang.NewSymbol("min").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the least of the nums.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1118), lang.NewKeyword("end-line"), int(1118))).(*lang.Symbol) var v4 lang.FnFunc v4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v5 := args[0] -return v5 +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("volatile!")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{false}) +var v6 any = v10 +_ = v6 +var v12 lang.FnFunc +v12 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v13 := lang.Apply(v5, nil) +return v13 + case 1: +v13 := args[0] +v14 := lang.Apply(v5, []any{v13}) +return v14 case 2: -v5 := args[0] -v6 := args[1] -v7, _ := lang.FieldOrMethod(lang1.Numbers, "min") -if reflect.TypeOf(v7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("min is not a function"))) +v13 := args[0] +v14 := args[1] +var v15 any +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("deref")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -v8 := lang.Apply(v7, []any{v5, v6}) -return v8 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := args[0] -v6 := args[1] -v7 := lang.NewList(args[2:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v6}) +if lang.IsTruthy(v19) { +v21 := lang.Apply(v5, []any{v13, v3}) +var v20 any = v21 +_ = v20 +var v23 any +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("reduced?")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("min")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v20}) +if lang.IsTruthy(v27) { +v23 = v20 +} else { +v28 := lang.Apply(v5, []any{v20, v14}) +v23 = v28 } -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("min")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v15 = v23 +} else { +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("vreset!")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v5, v6}) -v18 := lang.Apply(v10, []any{v13, v17, v7}) -return v18 +v22 := v21.Get() +v23 := lang.Apply(v22, []any{v6, true}) +_ = v23 +v24 := lang.Apply(v5, []any{v13, v14}) +v15 = v24 +} +return v15 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) -v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v3 := ns.InternWithValue(v0, v4, true) -if v0.Meta() != nil { - v3.SetMeta(v0.Meta().(lang.IPersistentMap)) +v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5238), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(5249), lang.NewKeyword("end-column"), int(35)) +v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) +if err != nil { + panic(err) } +return v14 +}) +v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5236), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(5249), lang.NewKeyword("end-column"), int(37)) +v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) +if err != nil { + panic(err) } -// lazy-seq -{ -v0 := lang.NewSymbol("lazy-seq").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Takes a body of expressions that returns an ISeq or nil, and yields\n a Seqable object that will invoke the body only the first time seq\n is called, and will cache the result and return it on all subsequent\n seq calls. See also - realized?", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(676), lang.NewKeyword("end-line"), int(676))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } +return v6 + case 2: v3 := args[0] v4 := args[1] -v5 := lang.NewList(args[2:]...) -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("list")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("drop")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("list*")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("interleave")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v11 := v10.Get() -v12 := lang.NewVector() -v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(683), lang.NewKeyword("column"), int(101), lang.NewKeyword("end-line"), int(683), lang.NewKeyword("end-column"), int(102)) -v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) -if err != nil { - panic(err) +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("repeat")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v15 := lang.Apply(v11, []any{lang.NewSymbol("fn*"), v14, v5}) -v16 := lang.Apply(v8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewLazySeq"), v15}) +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v3}) +v15 := lang.Apply(v10, []any{v14, v4}) +v16 := lang.Apply(v7, []any{int64(1), v15}) return v16 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -43963,206 +41927,190 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// nthrest +// into { -v0 := lang.NewSymbol("nthrest").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns the nth rest of coll, coll when n is 0.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3161), lang.NewKeyword("end-line"), int(3161))).(*lang.Symbol) +v0 := lang.NewSymbol("into").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("to")), lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("from")), lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("xform"), lang.NewSymbol("from"))), lang.NewKeyword("doc"), "Returns a new coll consisting of to with all of the items of\n from conjoined. A transducer may be supplied.\n (into x) returns x. (into) returns [].", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6965), lang.NewKeyword("end-line"), int(6965))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + switch len(args) { + case 0: +v3 := lang.NewVector() +v4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6971), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(6971), lang.NewKeyword("end-column"), int(8)) +v5, err := lang.WithMeta(v3, v4.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v5 + case 1: +v3 := args[0] +return v3 + case 2: v3 := args[0] v4 := args[1] var v5 any v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("pos?")) +v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) if v7.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } v8 := v7.Get() -v9 := lang.Apply(v8, []any{v4}) +v9 := lang.Apply(v8, []any{lang1.IEditableCollection, v3}) if lang.IsTruthy(v9) { -var v11 any -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("instance?")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("with-meta")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v14 := v13.Get() -v15 := lang.Apply(v14, []any{lang1.IDrop, v3}) -if lang.IsTruthy(v15) { -var v16 any -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("int?")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("persistent!")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v4}) -if lang.IsTruthy(v20) { -v16 = v4 -} else { -v21 := lang.Apply(nil, []any{v4}) -v16 = v21 +v15 := v14.Get() +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("reduce")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -v22, _ := lang.FieldOrMethod(v3, "drop") -if reflect.TypeOf(v22).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("drop is not a function"))) +v18 := v17.Get() +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("conj!")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v23 := lang.Apply(v22, []any{v16}) -v11 = v23 -} else { -var v24 any = v24 -_ = v24 -var v25 any = v3 -_ = v25 -var v26 any -for { -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("pos?")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("transient")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -v31 := v30.Get() -v32 := lang.Apply(v31, []any{v24}) -var v28 any = v32 -_ = v28 -var v34 any -if lang.IsTruthy(v28) { -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("seq")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v3}) +v26 := lang.Apply(v18, []any{v21, v25, v4}) +v27 := lang.Apply(v15, []any{v26}) +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("meta")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v25}) -v34 = v38 +v30 := v29.Get() +v31 := lang.Apply(v30, []any{v3}) +v32 := lang.Apply(v12, []any{v27, v31}) +v5 = v32 } else { -v34 = v28 -} -var v27 any = v34 -_ = v27 -var v29 any -if lang.IsTruthy(v27) { -var v30 any = v27 -_ = v30 v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("dec")) +v34 := v33.FindInternedVar(lang.NewSymbol("reduce")) if v34.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) } v35 := v34.Get() -v36 := lang.Apply(v35, []any{v24}) -var v32 any = v36 -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("rest")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.Apply(v40, []any{v30}) -var v37 any = v41 -v24 = v32 -v25 = v37 -continue -} else { -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("seq")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.Apply(v32, []any{v25}) -v29 = v33 -} -v26 = v29 - break -} -v11 = v26 -} -var v10 any = v11 -_ = v10 -var v25 any -if lang.IsTruthy(v10) { -v25 = v10 -} else { -v25 = lang.NewList() +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("conj")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) } -v5 = v25 -} else { -v5 = v3 +v38 := v37.Get() +v39 := lang.Apply(v35, []any{v38, v3, v4}) +v5 = v39 } return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// *command-line-args* -{ -v0 := lang.NewSymbol("*command-line-args*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "A sequence of the supplied command line arguments, or nil if\n none were supplied", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, nil, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// descendants -{ -v0 := lang.NewSymbol("descendants").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"))), lang.NewKeyword("doc"), "Returns the immediate and indirect children of tag, through a\n relationship established via derive. h must be a hierarchy obtained\n from make-hierarchy, if not supplied defaults to the global\n hierarchy. Note: does not work on Java type inheritance\n relationships.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5636), lang.NewKeyword("end-line"), int(5636))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: + case 3: v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("descendants")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() +v4 := args[1] +v5 := args[2] +var v6 any v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("global-hierarchy")) +v8 := v7.FindInternedVar(lang.NewSymbol("instance?")) if v8.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } v9 := v8.Get() -v10 := lang.Apply(v6, []any{v9, v3}) -return v10 +v10 := lang.Apply(v9, []any{lang1.IEditableCollection, v3}) +if lang.IsTruthy(v10) { +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("meta")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v3}) +var v11 any = v15 +_ = v11 +var v17 lang.FnFunc +v17 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v18 := args[0] +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("with-meta")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("persistent!")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v18}) +v26 := lang.Apply(v21, []any{v25, v11}) +return v26 case 2: -v3 := args[0] -v4 := args[1] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("class?")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +v18 := args[0] +v19 := args[1] +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("conj!")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v4}) -if lang.IsTruthy(v9) { -v10 := lang.Apply(java.lang.UnsupportedOperationException26., []any{"Can't get descendants of classes"}) -panic(v10) +v22 := v21.Get() +v23 := lang.Apply(v22, []any{v18, v19}) +return v23 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6980), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(6982), lang.NewKeyword("end-column"), int(44)) +v19, err := lang.WithMeta(v17, v18.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v16 any = v19 +_ = v16 +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("transduce")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("transient")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v3}) +v28 := lang.Apply(v23, []any{v4, v16, v27, v5}) +v6 = v28 } else { v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("not-empty")) +v12 := v11.FindInternedVar(lang.NewSymbol("transduce")) if v12.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } v13 := v12.Get() v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("get")) +v15 := v14.FindInternedVar(lang.NewSymbol("conj")) if v15.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } v16 := v15.Get() -v17 := lang.Apply(lang.NewKeyword("descendants"), []any{v3}) -v18 := lang.Apply(v16, []any{v17, v4}) -v19 := lang.Apply(v13, []any{v18}) -v5 = v19 +v17 := lang.Apply(v13, []any{v4, v16, v3, v5}) +v6 = v17 } -return v5 +return v6 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -44173,1756 +42121,2974 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// mapv +// into-array { -v0 := lang.NewSymbol("mapv").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2"), lang.NewSymbol("c3")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2"), lang.NewSymbol("c3"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Returns a vector consisting of the result of applying f to the\n set of first items of each coll, followed by applying f to the set\n of second items in each coll, until any one of the colls is\n exhausted. Any remaining items in other colls are ignored. Function\n f should accept number-of-colls arguments.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6986), lang.NewKeyword("end-line"), int(6986))).(*lang.Symbol) +v0 := lang.NewSymbol("into-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("aseq")), lang.NewVector(lang.NewSymbol("type"), lang.NewSymbol("aseq"))), lang.NewKeyword("doc"), "Returns an array with components set to the values in aseq. The array's\n component type is type if provided, or the type of the first value in\n aseq if present, or Object. All values in aseq must be compatible with\n the component type. Class objects for the primitive types can be obtained\n using, e.g., Integer/TYPE.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3444), lang.NewKeyword("end-line"), int(3444))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { + case 1: +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{v3}) +v8 := lang.Apply(nil, []any{v7}) +return v8 case 2: v3 := args[0] v4 := args[1] v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("persistent!")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq")) if v6.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("reduce")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -var v11 lang.FnFunc -v11 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { +v8 := lang.Apply(v7, []any{v4}) +v9 := lang.Apply(nil, []any{v3, v8}) +return v9 + default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v12 := args[0] -v13 := args[1] -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("conj!")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v3, []any{v13}) -v18 := lang.Apply(v16, []any{v12, v17}) -return v18 }) -v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6995), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(6995), lang.NewKeyword("end-column"), int(43)) -v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("transient")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v16 := v15.Get() -v17 := lang.NewVector() -v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6995), lang.NewKeyword("column"), int(56), lang.NewKeyword("end-line"), int(6995), lang.NewKeyword("end-column"), int(57)) -v19, err := lang.WithMeta(v17, v18.(lang.IPersistentMap)) -if err != nil { - panic(err) } -v20 := lang.Apply(v16, []any{v19}) -v21 := lang.Apply(v10, []any{v13, v20, v4}) -v22 := lang.Apply(v7, []any{v21}) -return v22 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] +// into1 +{ +v0 := lang.NewSymbol("into1").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("from"))), lang.NewKeyword("doc"), "Returns a new coll consisting of to-coll with all of the items of\n from-coll conjoined.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3416), lang.NewKeyword("end-line"), int(3416), lang.NewKeyword("private"), true)).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +var v5 any v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("into")) +v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) if v7.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } v8 := v7.Get() -v9 := lang.NewVector() -v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6998), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(6998), lang.NewKeyword("end-column"), int(13)) -v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("map")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v3, v4, v5}) -v16 := lang.Apply(v8, []any{v11, v15}) -return v16 - case 4: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("into")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.NewVector() -v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7000), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(7000), lang.NewKeyword("end-column"), int(13)) -v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) -if err != nil { - panic(err) +v9 := lang.Apply(v8, []any{lang1.IEditableCollection, v3}) +if lang.IsTruthy(v9) { +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("persistent!")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } +v12 := v11.Get() v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("map")) +v14 := v13.FindInternedVar(lang.NewSymbol("reduce1")) if v14.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } v15 := v14.Get() -v16 := lang.Apply(v15, []any{v3, v4, v5, v6}) -v17 := lang.Apply(v9, []any{v12, v16}) -return v17 - default: - if len(args) < 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("conj!")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("transient")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v3}) +v23 := lang.Apply(v15, []any{v18, v22, v4}) +v24 := lang.Apply(v12, []any{v23}) +v5 = v24 +} else { +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("reduce1")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("conj")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v27, []any{v30, v3, v4}) +v5 = v31 +} +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// ints +{ +var v1 lang.FnFunc +{ // function ints +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := lang.NewList(args[4:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("into")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v10 := v9.Get() -v11 := lang.NewVector() -v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7002), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(7002), lang.NewKeyword("end-column"), int(13)) -v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) -if err != nil { - panic(err) +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("apply")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) if v15.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } v16 := v15.Get() -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("map")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v19 := v18.Get() -v20 := lang.Apply(v16, []any{v19, v3, v4, v5, v6, v7}) -v21 := lang.Apply(v10, []any{v13, v20}) -return v21 +v20 := v19.Get() +v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/ints")}) +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("list")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v3}) +v26 := lang.Apply(v9, []any{v13, v17, v21, v25}) +v27 := lang.Apply(v6, []any{v26}) +return v27 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("ints").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Casts to int[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5397), lang.NewKeyword("end-line"), int(5397))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "ints") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ints is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// doseq +// io! { -v0 := lang.NewSymbol("doseq").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("seq-exprs"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Repeatedly executes body (presumably for side-effects) with\n bindings and filtering as provided by \"for\". Does not retain\n the head of the sequence. Returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3209), lang.NewKeyword("end-line"), int(3209))).(*lang.Symbol) +v0 := lang.NewSymbol("io!").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "If an io! block occurs in a transaction, throws an\n IllegalStateException, else runs body in an implicit do. If the\n first expression in body is a literal string, will use that as the\n exception message.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(2504), lang.NewKeyword("end-line"), int(2504))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 3 { + if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) +v5 := lang.NewList(args[2:]...) var v7 any v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) +v9 := v8.FindInternedVar(lang.NewSymbol("string?")) if v9.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } v10 := v9.Get() -v11 := lang.Apply(v10, []any{v5}) -if lang.IsTruthy(v11) { -v7 = nil -} else { -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("str")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("first")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("first")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v5}) +v15 := lang.Apply(v10, []any{v14}) +if lang.IsTruthy(v15) { +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("first")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v3}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v5}) +v7 = v19 +} else { +v7 = nil } -v21 := v20.Get() +var v6 any = v7 +_ = v6 +var v21 any +if lang.IsTruthy(v6) { v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("meta")) +v23 := v22.FindInternedVar(lang.NewSymbol("next")) if v23.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) -v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) -v28 := lang.Apply(lang1.NewIllegalArgumentError, []any{v27}) -panic(v28) +v25 := lang.Apply(v24, []any{v20}) +v21 = v25 +} else { +v21 = v20 } -_ = v7 -var v29 any +var v20 any = v21 +_ = v20 +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("seq")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("even?")) +v31 := v30.FindInternedVar(lang.NewSymbol("concat")) if v31.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) } v32 := v31.Get() v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("count")) +v34 := v33.FindInternedVar(lang.NewSymbol("list")) if v34.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) } v35 := v34.Get() -v36 := lang.Apply(v35, []any{v5}) -v37 := lang.Apply(v32, []any{v36}) -if lang.IsTruthy(v37) { -v29 = nil -} else { -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("str")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +v36 := lang.Apply(v35, []any{lang.NewSymbol("if")}) +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("list")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("first")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("seq")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) } -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v3}) -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +v42 := v41.Get() +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("concat")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) } -v47 := v46.Get() -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("meta")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +v45 := v44.Get() +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("list")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) } -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v3}) -v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) -v53 := lang.Apply(v40, []any{v44, " requires ", "an even number of forms in binding vector", " in ", v47, ":", v52}) -v54 := lang.Apply(lang1.NewIllegalArgumentError, []any{v53}) -panic(v54) +v48 := v47.Get() +v49 := lang.Apply(v48, []any{lang.NewSymbol("glojure.lang.LockingTransaction/isRunning")}) +v50 := lang.Apply(v45, []any{v49}) +v51 := lang.Apply(v42, []any{v50}) +v52 := lang.Apply(v39, []any{v51}) +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("list")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) } -_ = v29 -_ = nil -var v56 lang.FnFunc -{ // function step -v56 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v58 := args[0] -v59 := args[1] -var v60 any -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("not")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +v55 := v54.Get() +v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v57 := v56.FindInternedVar(lang.NewSymbol("seq")) +if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) } -v63 := v62.Get() -v64 := lang.Apply(v63, []any{v59}) -if lang.IsTruthy(v64) { -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("seq")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +v58 := v57.Get() +v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v60 := v59.FindInternedVar(lang.NewSymbol("concat")) +if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) } -v67 := v66.Get() -v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v69 := v68.FindInternedVar(lang.NewSymbol("concat")) -if v69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) +v61 := v60.Get() +v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v63 := v62.FindInternedVar(lang.NewSymbol("list")) +if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) } -v70 := v69.Get() -v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v72 := v71.FindInternedVar(lang.NewSymbol("list")) -if v72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) +v64 := v63.Get() +v65 := lang.Apply(v64, []any{lang.NewSymbol("throw")}) +v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v67 := v66.FindInternedVar(lang.NewSymbol("list")) +if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) } -v73 := v72.Get() -v74 := lang.Apply(v73, []any{lang.NewSymbol("do")}) -v75 := lang.Apply(v70, []any{v74, v6}) -v76 := lang.Apply(v67, []any{v75}) -v77 := lang.NewVector(true, v76) -v78 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3220), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(3220), lang.NewKeyword("end-column"), int(36)) -v79, err := lang.WithMeta(v77, v78.(lang.IPersistentMap)) -if err != nil { - panic(err) +v68 := v67.Get() +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("seq")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) } -v60 = v79 -} else { -v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v82 := v81.FindInternedVar(lang.NewSymbol("first")) -if v82.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) +v71 := v70.Get() +v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v73 := v72.FindInternedVar(lang.NewSymbol("concat")) +if v73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) } -v83 := v82.Get() -v84 := lang.Apply(v83, []any{v59}) -var v80 any = v84 -_ = v80 -v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v87 := v86.FindInternedVar(lang.NewSymbol("second")) -if v87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) +v74 := v73.Get() +v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v76 := v75.FindInternedVar(lang.NewSymbol("list")) +if v76.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) } -v88 := v87.Get() -v89 := lang.Apply(v88, []any{v59}) -var v85 any = v89 -_ = v85 -var v91 any -v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v93 := v92.FindInternedVar(lang.NewSymbol("keyword?")) -if v93.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) +v77 := v76.Get() +v78 := lang.Apply(v77, []any{lang.NewSymbol("new")}) +v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v80 := v79.FindInternedVar(lang.NewSymbol("list")) +if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) } -v94 := v93.Get() -v95 := lang.Apply(v94, []any{v80}) -if lang.IsTruthy(v95) { -v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v98 := v97.FindInternedVar(lang.NewSymbol("nnext")) -if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) +v81 := v80.Get() +v82 := lang.Apply(v81, []any{lang.NewSymbol("glojure.core/IllegalStateException")}) +v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v84 := v83.FindInternedVar(lang.NewSymbol("list")) +if v84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) } -v99 := v98.Get() -v100 := lang.Apply(v99, []any{v59}) -v101 := lang.Apply(v57, []any{v58, v100}) -var v96 any = v101 -_ = v96 -v103 := lang.Apply(v96, []any{int64(0)}) -var v102 any = v103 -_ = v102 -v105 := lang.Apply(v96, []any{int64(1)}) -var v104 any = v105 -_ = v104 -var v107 any -v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v109 := v108.FindInternedVar(lang.NewSymbol("=")) -if v109.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) +v85 := v84.Get() +var v86 any = v6 +_ = v86 +var v88 any +if lang.IsTruthy(v86) { +v88 = v86 +} else { +v88 = "I/O in transaction" } -v110 := v109.Get() -v111 := lang.Apply(v110, []any{v80, lang.NewKeyword("let")}) -if lang.IsTruthy(v111) { -v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v113 := v112.FindInternedVar(lang.NewSymbol("seq")) -if v113.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) +v86 := lang.Apply(v85, []any{v88}) +v87 := lang.Apply(v74, []any{v78, v82, v86}) +v88 := lang.Apply(v71, []any{v87}) +v89 := lang.Apply(v68, []any{v88}) +v90 := lang.Apply(v61, []any{v65, v89}) +v91 := lang.Apply(v58, []any{v90}) +v92 := lang.Apply(v55, []any{v91}) +v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v94 := v93.FindInternedVar(lang.NewSymbol("list")) +if v94.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) } -v114 := v113.Get() -v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v116 := v115.FindInternedVar(lang.NewSymbol("concat")) -if v116.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) +v95 := v94.Get() +v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v97 := v96.FindInternedVar(lang.NewSymbol("seq")) +if v97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) } -v117 := v116.Get() -v118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v119 := v118.FindInternedVar(lang.NewSymbol("list")) -if v119.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v119))) +v98 := v97.Get() +v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v100 := v99.FindInternedVar(lang.NewSymbol("concat")) +if v100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) } -v120 := v119.Get() -v121 := lang.Apply(v120, []any{lang.NewSymbol("glojure.core/let")}) -v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v123 := v122.FindInternedVar(lang.NewSymbol("list")) -if v123.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) -} -v124 := v123.Get() -v125 := lang.Apply(v124, []any{v85}) -v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v127 := v126.FindInternedVar(lang.NewSymbol("list")) -if v127.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) -} -v128 := v127.Get() -v129 := lang.Apply(v128, []any{v104}) -v130 := lang.Apply(v117, []any{v121, v125, v129}) -v131 := lang.Apply(v114, []any{v130}) -v132 := lang.NewVector(v102, v131) -v133 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3228), lang.NewKeyword("column"), int(37), lang.NewKeyword("end-line"), int(3228), lang.NewKeyword("end-column"), int(64)) -v134, err := lang.WithMeta(v132, v133.(lang.IPersistentMap)) -if err != nil { - panic(err) +v101 := v100.Get() +v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v103 := v102.FindInternedVar(lang.NewSymbol("list")) +if v103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) } -v107 = v134 -} else { -var v135 any -v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v137 := v136.FindInternedVar(lang.NewSymbol("=")) -if v137.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) +v104 := v103.Get() +v105 := lang.Apply(v104, []any{lang.NewSymbol("do")}) +v106 := lang.Apply(v101, []any{v105, v20}) +v107 := lang.Apply(v98, []any{v106}) +v108 := lang.Apply(v95, []any{v107}) +v109 := lang.Apply(v32, []any{v36, v52, v92, v108}) +v110 := lang.Apply(v29, []any{v109}) +return v110 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v138 := v137.Get() -v139 := lang.Apply(v138, []any{v80, lang.NewKeyword("while")}) -if lang.IsTruthy(v139) { -v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v141 := v140.FindInternedVar(lang.NewSymbol("seq")) -if v141.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) } -v142 := v141.Get() -v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v144 := v143.FindInternedVar(lang.NewSymbol("concat")) -if v144.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) +// is-annotation? +{ +v0 := lang.NewSymbol("is-annotation?").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5471), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(5471), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("class?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v145 := v144.Get() -v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v147 := v146.FindInternedVar(lang.NewSymbol("list")) -if v147.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +var v4 any = v8 +_ = v4 +var v10 any +if lang.IsTruthy(v4) { +v11, _ := lang.FieldOrMethod(java.lang.annotation21.Annotation, "isAssignableFrom") +if reflect.TypeOf(v11).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("isAssignableFrom is not a function"))) } -v148 := v147.Get() -v149 := lang.Apply(v148, []any{lang.NewSymbol("glojure.core/when")}) -v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v151 := v150.FindInternedVar(lang.NewSymbol("list")) -if v151.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) +v12 := lang.Apply(v11, []any{v3}) +v10 = v12 +} else { +v10 = v4 } -v152 := v151.Get() -v153 := lang.Apply(v152, []any{v85}) -v154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v155 := v154.FindInternedVar(lang.NewSymbol("list")) -if v155.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v155))) +return v10 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v156 := v155.Get() -v157 := lang.Apply(v156, []any{v104}) -var v158 any -if lang.IsTruthy(v102) { -v159 := lang.NewVector(v58) -v160 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3231), lang.NewKeyword("column"), int(65), lang.NewKeyword("end-line"), int(3231), lang.NewKeyword("end-column"), int(73)) -v161, err := lang.WithMeta(v159, v160.(lang.IPersistentMap)) -if err != nil { - panic(err) } -v158 = v161 -} else { -v158 = nil +// is-runtime-annotation? +{ +v0 := lang.NewSymbol("is-runtime-annotation?").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5475), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(5475), lang.NewKeyword("end-column"), int(29), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("boolean")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v162 := lang.Apply(v145, []any{v149, v153, v157, v158}) -v163 := lang.Apply(v142, []any{v162}) -v164 := lang.NewVector(false, v163) -v165 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3229), lang.NewKeyword("column"), int(39), lang.NewKeyword("end-line"), int(3231), lang.NewKeyword("end-column"), int(76)) -v166, err := lang.WithMeta(v164, v165.(lang.IPersistentMap)) -if err != nil { - panic(err) +v6 := v5.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("is-annotation?")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v135 = v166 -} else { -var v167 any -v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v169 := v168.FindInternedVar(lang.NewSymbol("=")) -if v169.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v3}) +var v7 any = v11 +_ = v7 +var v13 any +if lang.IsTruthy(v7) { +v15, _ := lang.FieldOrMethod(v3, "getAnnotation") +if reflect.TypeOf(v15).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getAnnotation is not a function"))) } -v170 := v169.Get() -v171 := lang.Apply(v170, []any{v80, lang.NewKeyword("when")}) -if lang.IsTruthy(v171) { -v172 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v173 := v172.FindInternedVar(lang.NewSymbol("seq")) -if v173.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v173))) +v16 := lang.Apply(v15, []any{java.lang.annotation21.Retention}) +var v14 any = v16 +_ = v14 +var v18 any +if lang.IsTruthy(v14) { +var v19 any = v14 +_ = v19 +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("=")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v174 := v173.Get() -v175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v176 := v175.FindInternedVar(lang.NewSymbol("concat")) -if v176.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v176))) +v23 := v22.Get() +v24, ok := lang.FieldOrMethod(v19, "value") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v19, "value"))) } -v177 := v176.Get() -v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v179 := v178.FindInternedVar(lang.NewSymbol("list")) -if v179.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) +var v25 any +switch reflect.TypeOf(v24).Kind() { +case reflect.Func: + v25 = lang.Apply(v24, nil) +default: + v25 = v24 } -v180 := v179.Get() -v181 := lang.Apply(v180, []any{lang.NewSymbol("if")}) -v182 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v183 := v182.FindInternedVar(lang.NewSymbol("list")) -if v183.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v183))) +v26 := lang.Apply(v23, []any{v25, nil}) +v18 = v26 +} else { +v18 = nil } -v184 := v183.Get() -v185 := lang.Apply(v184, []any{v85}) -v186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v187 := v186.FindInternedVar(lang.NewSymbol("list")) -if v187.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v187))) +v13 = v18 +} else { +v13 = v7 } -v188 := v187.Get() -v189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v190 := v189.FindInternedVar(lang.NewSymbol("seq")) -if v190.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v190))) +v7 := lang.Apply(v6, []any{v13}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v191 := v190.Get() -v192 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v193 := v192.FindInternedVar(lang.NewSymbol("concat")) -if v193.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v193))) } -v194 := v193.Get() -v195 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v196 := v195.FindInternedVar(lang.NewSymbol("list")) -if v196.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v196))) +// isa? +{ +v0 := lang.NewSymbol("isa?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("child"), lang.NewSymbol("parent")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("child"), lang.NewSymbol("parent"))), lang.NewKeyword("doc"), "Returns true if (= child parent), or child is directly or indirectly derived from\n parent, either via a Java type inheritance relationship or a\n relationship established via derive. h must be a hierarchy obtained\n from make-hierarchy, if not supplied defaults to the global\n hierarchy", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5586), lang.NewKeyword("end-line"), int(5586))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("isa?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v197 := v196.Get() -v198 := lang.Apply(v197, []any{lang.NewSymbol("do")}) -v199 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v200 := v199.FindInternedVar(lang.NewSymbol("list")) -if v200.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v200))) +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("global-hierarchy")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v201 := v200.Get() -v202 := lang.Apply(v201, []any{v104}) -var v203 any -if lang.IsTruthy(v102) { -v204 := lang.NewVector(v58) -v205 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3235), lang.NewKeyword("column"), int(66), lang.NewKeyword("end-line"), int(3235), lang.NewKeyword("end-column"), int(74)) -v206, err := lang.WithMeta(v204, v205.(lang.IPersistentMap)) -if err != nil { - panic(err) +v10 := v9.Get() +v11 := lang.Apply(v7, []any{v10, v3, v4}) +return v11 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("=")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v203 = v206 +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v4, v5}) +var v6 any = v10 +_ = v6 +var v12 any +if lang.IsTruthy(v6) { +v12 = v6 } else { -v203 = nil +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("class?")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } -v207 := lang.Apply(v194, []any{v198, v202, v203}) -v208 := lang.Apply(v191, []any{v207}) -v209 := lang.Apply(v188, []any{v208}) -v210 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v211 := v210.FindInternedVar(lang.NewSymbol("list")) -if v211.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v211))) +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v5}) +var v14 any = v18 +_ = v14 +var v20 any +if lang.IsTruthy(v14) { +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("class?")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -v212 := v211.Get() -v213 := lang.Apply(v212, []any{v58}) -v214 := lang.Apply(v177, []any{v181, v185, v209, v213}) -v215 := lang.Apply(v174, []any{v214}) -v216 := lang.NewVector(false, v215) -v217 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3232), lang.NewKeyword("column"), int(38), lang.NewKeyword("end-line"), int(3236), lang.NewKeyword("end-column"), int(57)) -v218, err := lang.WithMeta(v216, v217.(lang.IPersistentMap)) -if err != nil { - panic(err) +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v4}) +var v21 any = v25 +_ = v21 +var v27 any +if lang.IsTruthy(v21) { +v28, _ := lang.FieldOrMethod(v4, "AssignableTo") +if reflect.TypeOf(v28).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("AssignableTo is not a function"))) } -v167 = v218 +v29 := lang.Apply(v28, []any{v5}) +v27 = v29 } else { -v167 = nil +v27 = v21 } -v135 = v167 +v20 = v27 +} else { +v20 = v14 } -v107 = v135 +var v13 any = v20 +_ = v13 +var v15 any +if lang.IsTruthy(v13) { +v15 = v13 +} else { +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("contains?")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v91 = v107 +v19 := v18.Get() +v20 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) +v21 := lang.Apply(v20, []any{v4}) +v22 := lang.Apply(v19, []any{v21, v5}) +var v16 any = v22 +_ = v16 +var v24 any +if lang.IsTruthy(v16) { +v24 = v16 } else { -v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v98 := v97.FindInternedVar(lang.NewSymbol("gensym")) -if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("class?")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v99 := v98.Get() -v100 := lang.Apply(v99, []any{"seq_"}) -var v96 any = v100 -_ = v96 -v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v103 := v102.FindInternedVar(lang.NewSymbol("with-meta")) -if v103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) +v29 := v28.Get() +v30 := lang.Apply(v29, []any{v4}) +var v26 any = v30 +_ = v26 +var v32 any +if lang.IsTruthy(v26) { +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("some")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) } -v104 := v103.Get() -v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v106 := v105.FindInternedVar(lang.NewSymbol("gensym")) -if v106.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) +v35 := v34.Get() +var v36 lang.FnFunc +v36 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v37 := args[0] +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("contains?")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) } -v107 := v106.Get() -v108 := lang.Apply(v107, []any{"chunk_"}) -v109 := lang.NewMap(lang.NewKeyword("tag"), lang.NewSymbol("glojure.lang.IChunk")) -v110 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3239), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(3239), lang.NewKeyword("end-column"), int(72)) -v111, err := lang.WithMeta(v109, v110.(lang.IPersistentMap)) +v40 := v39.Get() +v41 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) +v42 := lang.Apply(v41, []any{v37}) +v43 := lang.Apply(v40, []any{v42, v5}) +return v43 +}) +v37 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5599), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(5599), lang.NewKeyword("end-column"), int(71)) +v38, err := lang.WithMeta(v36, v37.(lang.IPersistentMap)) if err != nil { panic(err) } -v112 := lang.Apply(v104, []any{v108, v111}) -var v101 any = v112 -_ = v101 -v114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v115 := v114.FindInternedVar(lang.NewSymbol("gensym")) -if v115.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v115))) +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("supers")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) } -v116 := v115.Get() -v117 := lang.Apply(v116, []any{"count_"}) -var v113 any = v117 -_ = v113 -v119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v120 := v119.FindInternedVar(lang.NewSymbol("gensym")) -if v120.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v120))) +v41 := v40.Get() +v42 := lang.Apply(v41, []any{v4}) +v43 := lang.Apply(v35, []any{v38, v42}) +v32 = v43 +} else { +v32 = v26 } -v121 := v120.Get() -v122 := lang.Apply(v121, []any{"i_"}) -var v118 any = v122 -_ = v118 -v124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v125 := v124.FindInternedVar(lang.NewSymbol("seq")) -if v125.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v125))) +var v25 any = v32 +_ = v25 +var v27 any +if lang.IsTruthy(v25) { +v27 = v25 +} else { +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("vector?")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) } -v126 := v125.Get() -v127 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v128 := v127.FindInternedVar(lang.NewSymbol("concat")) -if v128.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v128))) +v31 := v30.Get() +v32 := lang.Apply(v31, []any{v5}) +var v28 any = v32 +_ = v28 +var v34 any +if lang.IsTruthy(v28) { +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("vector?")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) } -v129 := v128.Get() -v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v131 := v130.FindInternedVar(lang.NewSymbol("list")) -if v131.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v4}) +var v35 any = v39 +_ = v35 +var v41 any +if lang.IsTruthy(v35) { +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("=")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) } -v132 := v131.Get() -v133 := lang.Apply(v132, []any{lang.NewSymbol("recur")}) -v134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v135 := v134.FindInternedVar(lang.NewSymbol("list")) -if v135.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v135))) +v45 := v44.Get() +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("count")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) } -v136 := v135.Get() -v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v138 := v137.FindInternedVar(lang.NewSymbol("seq")) -if v138.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) +v48 := v47.Get() +v49 := lang.Apply(v48, []any{v5}) +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("count")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) } -v139 := v138.Get() -v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v141 := v140.FindInternedVar(lang.NewSymbol("concat")) -if v141.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) +v52 := v51.Get() +v53 := lang.Apply(v52, []any{v4}) +v54 := lang.Apply(v45, []any{v49, v53}) +var v42 any = v54 +_ = v42 +var v56 any +if lang.IsTruthy(v42) { +var v57 any = true +_ = v57 +var v58 any = int64(0) +_ = v58 +var v59 any +for { +var v60 any +v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v63 := v62.FindInternedVar(lang.NewSymbol("not")) +if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) } -v142 := v141.Get() -v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v144 := v143.FindInternedVar(lang.NewSymbol("list")) -if v144.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) +v64 := v63.Get() +v65 := lang.Apply(v64, []any{v57}) +var v61 any = v65 +_ = v61 +var v67 any +if lang.IsTruthy(v61) { +v67 = v61 +} else { +v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v69 := v68.FindInternedVar(lang.NewSymbol("=")) +if v69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) } -v145 := v144.Get() -v146 := lang.Apply(v145, []any{lang.NewSymbol("glojure.core/next")}) -v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v148 := v147.FindInternedVar(lang.NewSymbol("list")) -if v148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) +v70 := v69.Get() +v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v72 := v71.FindInternedVar(lang.NewSymbol("count")) +if v72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) } -v149 := v148.Get() -v150 := lang.Apply(v149, []any{v96}) -v151 := lang.Apply(v142, []any{v146, v150}) -v152 := lang.Apply(v139, []any{v151}) -v153 := lang.Apply(v136, []any{v152}) -v154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v155 := v154.FindInternedVar(lang.NewSymbol("list")) -if v155.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v155))) +v73 := v72.Get() +v74 := lang.Apply(v73, []any{v5}) +v75 := lang.Apply(v70, []any{v58, v74}) +v67 = v75 } -v156 := v155.Get() -v157 := lang.Apply(v156, []any{nil}) -v158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v159 := v158.FindInternedVar(lang.NewSymbol("list")) -if v159.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v159))) +if lang.IsTruthy(v67) { +v60 = v57 +} else { +v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v63 := v62.FindInternedVar(lang.NewSymbol("isa?")) +if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) } -v160 := v159.Get() -v161 := lang.Apply(v160, []any{int64(0)}) -v162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v163 := v162.FindInternedVar(lang.NewSymbol("list")) -if v163.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v163))) +v64 := v63.Get() +v65 := lang.Apply(v4, []any{v58}) +v66 := lang.Apply(v5, []any{v58}) +v67 := lang.Apply(v64, []any{v3, v65, v66}) +var v61 any = v67 +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("inc")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) } -v164 := v163.Get() -v165 := lang.Apply(v164, []any{int64(0)}) -v166 := lang.Apply(v129, []any{v133, v153, v157, v161, v165}) -v167 := lang.Apply(v126, []any{v166}) -var v123 any = v167 -_ = v123 -v169 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v170 := v169.FindInternedVar(lang.NewSymbol("nnext")) -if v170.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v170))) +v71 := v70.Get() +v72 := lang.Apply(v71, []any{v58}) +var v68 any = v72 +v57 = v61 +v58 = v68 +continue } -v171 := v170.Get() -v172 := lang.Apply(v171, []any{v59}) -v173 := lang.Apply(v57, []any{v123, v172}) -var v168 any = v173 -_ = v168 -v175 := lang.Apply(v168, []any{int64(0)}) -var v174 any = v175 -_ = v174 -v177 := lang.Apply(v168, []any{int64(1)}) -var v176 any = v177 -_ = v176 -v179 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v180 := v179.FindInternedVar(lang.NewSymbol("seq")) -if v180.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v180))) +v59 = v60 + break } -v181 := v180.Get() -v182 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v183 := v182.FindInternedVar(lang.NewSymbol("concat")) -if v183.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v183))) +v56 = v59 +} else { +v56 = v42 } -v184 := v183.Get() -v185 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v186 := v185.FindInternedVar(lang.NewSymbol("list")) -if v186.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v186))) +v41 = v56 +} else { +v41 = v35 } -v187 := v186.Get() -v188 := lang.Apply(v187, []any{lang.NewSymbol("recur")}) -v189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v190 := v189.FindInternedVar(lang.NewSymbol("list")) -if v190.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v190))) +v34 = v41 +} else { +v34 = v28 } -v191 := v190.Get() -v192 := lang.Apply(v191, []any{v96}) -v193 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v194 := v193.FindInternedVar(lang.NewSymbol("list")) -if v194.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v194))) +v27 = v34 } -v195 := v194.Get() -v196 := lang.Apply(v195, []any{v101}) -v197 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v198 := v197.FindInternedVar(lang.NewSymbol("list")) -if v198.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v198))) +v24 = v27 } -v199 := v198.Get() -v200 := lang.Apply(v199, []any{v113}) -v201 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v202 := v201.FindInternedVar(lang.NewSymbol("list")) -if v202.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v202))) +v15 = v24 } -v203 := v202.Get() -v204 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v205 := v204.FindInternedVar(lang.NewSymbol("seq")) -if v205.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v205))) +v12 = v15 } -v206 := v205.Get() -v207 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v208 := v207.FindInternedVar(lang.NewSymbol("concat")) -if v208.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v208))) +return v12 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v209 := v208.Get() -v210 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v211 := v210.FindInternedVar(lang.NewSymbol("list")) -if v211.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v211))) } -v212 := v211.Get() -v213 := lang.Apply(v212, []any{lang.NewSymbol("glojure.core/unchecked-inc")}) -v214 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v215 := v214.FindInternedVar(lang.NewSymbol("list")) -if v215.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v215))) +// iterate +{ +v0 := lang.NewSymbol("iterate").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns a lazy (infinite!) sequence of x, (f x), (f (f x)) etc.\n f must be free of side-effects", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3011), lang.NewKeyword("end-line"), int(3011))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.Apply(nil, []any{v3, v4}) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v216 := v215.Get() -v217 := lang.Apply(v216, []any{v118}) -v218 := lang.Apply(v209, []any{v213, v217}) -v219 := lang.Apply(v206, []any{v218}) -v220 := lang.Apply(v203, []any{v219}) -v221 := lang.Apply(v184, []any{v188, v192, v196, v200, v220}) -v222 := lang.Apply(v181, []any{v221}) -var v178 any = v222 -_ = v178 -v224 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v225 := v224.FindInternedVar(lang.NewSymbol("nnext")) -if v225.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v225))) } -v226 := v225.Get() -v227 := lang.Apply(v226, []any{v59}) -v228 := lang.Apply(v57, []any{v178, v227}) -var v223 any = v228 -_ = v223 -v230 := lang.Apply(v223, []any{int64(1)}) -var v229 any = v230 -_ = v229 -v232 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v233 := v232.FindInternedVar(lang.NewSymbol("seq")) -if v233.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v233))) +// iteration +{ +v0 := lang.NewSymbol("iteration").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("step"), lang.NewSymbol("&"), lang.NewMap(lang.NewKeyword("keys"), lang.NewVector(lang.NewSymbol("somef"), lang.NewSymbol("vf"), lang.NewSymbol("kf"), lang.NewSymbol("initk")), lang.NewKeyword("or"), lang.NewMap(lang.NewSymbol("vf"), lang.NewSymbol("identity"), lang.NewSymbol("kf"), lang.NewSymbol("identity"), lang.NewSymbol("somef"), lang.NewSymbol("some?"), lang.NewSymbol("initk"), nil)))), lang.NewKeyword("doc"), "Creates a seqable/reducible via repeated calls to step,\n a function of some (continuation token) 'k'. The first call to step\n will be passed initk, returning 'ret'. Iff (somef ret) is true,\n (vf ret) will be included in the iteration, else iteration will\n terminate and vf/kf will not be called. If (kf ret) is non-nil it\n will be passed to the next step call, else iteration will terminate.\n\n This can be used e.g. to consume APIs that return paginated or batched data.\n\n step - (possibly impure) fn of 'k' -> 'ret'\n\n :somef - fn of 'ret' -> logical true/false, default 'some?'\n :vf - fn of 'ret' -> 'v', a value produced by the iteration, default 'identity'\n :kf - fn of 'ret' -> 'next-k' or nil (signaling 'do not continue'), default 'identity'\n :initk - the first value passed to step, default 'nil'\n\n It is presumed that step with non-initk is unreproducible/non-idempotent.\n If step with initk is unreproducible it is on the consumer to not consume twice.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7759), lang.NewKeyword("end-line"), int(7759))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.NewList(args[1:]...) +var v5 any = v4 +_ = v5 +var v7 any +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("seq?")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v234 := v233.Get() -v235 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v236 := v235.FindInternedVar(lang.NewSymbol("concat")) -if v236.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v236))) +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v6}) +if lang.IsTruthy(v11) { +var v12 any +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("next")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } -v237 := v236.Get() -v238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v239 := v238.FindInternedVar(lang.NewSymbol("list")) -if v239.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v239))) +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v6}) +if lang.IsTruthy(v16) { +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("to-array")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v240 := v239.Get() -v241 := lang.Apply(v240, []any{lang.NewSymbol("glojure.core/loop")}) -v242 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v243 := v242.FindInternedVar(lang.NewSymbol("list")) -if v243.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v243))) +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v6}) +v21 := lang.Apply(lang1.NewPersistentArrayMapAsIfByAssoc, []any{v20}) +v12 = v21 +} else { +var v22 any +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("seq")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v244 := v243.Get() -v245 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v246 := v245.FindInternedVar(lang.NewSymbol("apply")) -if v246.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v246))) +v25 := v24.Get() +v26 := lang.Apply(v25, []any{v6}) +if lang.IsTruthy(v26) { +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("first")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v247 := v246.Get() -v248 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v249 := v248.FindInternedVar(lang.NewSymbol("vector")) -if v249.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v249))) +v29 := v28.Get() +v30 := lang.Apply(v29, []any{v6}) +v22 = v30 +} else { +v22 = nil } -v250 := v249.Get() -v251 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v252 := v251.FindInternedVar(lang.NewSymbol("seq")) -if v252.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v252))) +v12 = v22 } -v253 := v252.Get() -v254 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v255 := v254.FindInternedVar(lang.NewSymbol("concat")) -if v255.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v255))) +v7 = v12 +} else { +v7 = v6 } -v256 := v255.Get() -v257 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v258 := v257.FindInternedVar(lang.NewSymbol("list")) -if v258.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v258))) +var v6 any = v7 +_ = v6 +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("get")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) } -v259 := v258.Get() -v260 := lang.Apply(v259, []any{v96}) -v261 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v262 := v261.FindInternedVar(lang.NewSymbol("list")) -if v262.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v262))) +v34 := v33.Get() +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("some?")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) } -v263 := v262.Get() -v264 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v265 := v264.FindInternedVar(lang.NewSymbol("seq")) -if v265.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v265))) +v37 := v36.Get() +v38 := lang.Apply(v34, []any{v6, lang.NewKeyword("somef"), v37}) +var v31 any = v38 +_ = v31 +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("get")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) } -v266 := v265.Get() -v267 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v268 := v267.FindInternedVar(lang.NewSymbol("concat")) -if v268.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v268))) +v42 := v41.Get() +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("identity")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) } -v269 := v268.Get() -v270 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v271 := v270.FindInternedVar(lang.NewSymbol("list")) -if v271.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v271))) +v45 := v44.Get() +v46 := lang.Apply(v42, []any{v6, lang.NewKeyword("vf"), v45}) +var v39 any = v46 +_ = v39 +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("get")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) } -v272 := v271.Get() -v273 := lang.Apply(v272, []any{lang.NewSymbol("glojure.core/seq")}) -v274 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v275 := v274.FindInternedVar(lang.NewSymbol("list")) -if v275.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v275))) +v50 := v49.Get() +v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v52 := v51.FindInternedVar(lang.NewSymbol("identity")) +if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) } -v276 := v275.Get() -v277 := lang.Apply(v276, []any{v85}) -v278 := lang.Apply(v269, []any{v273, v277}) -v279 := lang.Apply(v266, []any{v278}) -v280 := lang.Apply(v263, []any{v279}) -v281 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v282 := v281.FindInternedVar(lang.NewSymbol("list")) -if v282.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v282))) +v53 := v52.Get() +v54 := lang.Apply(v50, []any{v6, lang.NewKeyword("kf"), v53}) +var v47 any = v54 +_ = v47 +v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v57 := v56.FindInternedVar(lang.NewSymbol("get")) +if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) } -v283 := v282.Get() -v284 := lang.Apply(v283, []any{v101}) -v285 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v286 := v285.FindInternedVar(lang.NewSymbol("list")) -if v286.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v286))) +v58 := v57.Get() +v59 := lang.Apply(v58, []any{v6, lang.NewKeyword("initk"), nil}) +var v55 any = v59 +_ = v55 +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("seq")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) } -v287 := v286.Get() -v288 := lang.Apply(v287, []any{nil}) -v289 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v290 := v289.FindInternedVar(lang.NewSymbol("list")) -if v290.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v290))) +v63 := v62.Get() +v64 := lang.NewVector(nil) +v65 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7786), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(7786), lang.NewKeyword("end-column"), int(11)) +v66, err := lang.WithMeta(v64, v65.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v291 := v290.Get() -v292 := lang.Apply(v291, []any{v113}) -v293 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v294 := v293.FindInternedVar(lang.NewSymbol("list")) -if v294.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v294))) +var v67 lang.FnFunc +{ // function next +v67 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v69 := args[0] +var v70 any +v71 := lang.Apply(v31, []any{v69}) +if lang.IsTruthy(v71) { +v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v73 := v72.FindInternedVar(lang.NewSymbol("cons")) +if v73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) } -v295 := v294.Get() -v296 := lang.Apply(v295, []any{int64(0)}) -v297 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v298 := v297.FindInternedVar(lang.NewSymbol("list")) -if v298.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v298))) +v74 := v73.Get() +v75 := lang.Apply(v39, []any{v69}) +v77 := lang.Apply(v47, []any{v69}) +var v76 any = v77 +_ = v76 +var v79 any +v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v81 := v80.FindInternedVar(lang.NewSymbol("nil?")) +if v81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) } -v299 := v298.Get() -v300 := lang.Apply(v299, []any{v118}) -v301 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v302 := v301.FindInternedVar(lang.NewSymbol("list")) -if v302.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v302))) +v82 := v81.Get() +v83 := lang.Apply(v82, []any{v76}) +if lang.IsTruthy(v83) { +v79 = nil +} else { +var v84 any = v76 +_ = v84 +var v86 lang.FnFunc +v86 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v87 := lang.Apply(v3, []any{v84}) +v88 := lang.Apply(v68, []any{v87}) +return v88 +}) +v87 := lang.Apply(lang1.NewLazySeq, []any{v86}) +v79 = v87 } -v303 := v302.Get() -v304 := lang.Apply(v303, []any{int64(0)}) -v305 := lang.Apply(v256, []any{v260, v280, v284, v288, v292, v296, v300, v304}) -v306 := lang.Apply(v253, []any{v305}) -v307 := lang.Apply(v247, []any{v250, v306}) -v308 := lang.Apply(v244, []any{v307}) -v309 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v310 := v309.FindInternedVar(lang.NewSymbol("list")) -if v310.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v310))) -} -v311 := v310.Get() -v312 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v313 := v312.FindInternedVar(lang.NewSymbol("seq")) -if v313.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v313))) -} -v314 := v313.Get() -v315 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v316 := v315.FindInternedVar(lang.NewSymbol("concat")) -if v316.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v316))) -} -v317 := v316.Get() -v318 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v319 := v318.FindInternedVar(lang.NewSymbol("list")) -if v319.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v319))) +v76 := lang.Apply(v74, []any{v75, v79}) +v70 = v76 +} else { +v70 = nil } -v320 := v319.Get() -v321 := lang.Apply(v320, []any{lang.NewSymbol("if")}) -v322 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v323 := v322.FindInternedVar(lang.NewSymbol("list")) -if v323.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v323))) +return v70 +}) +v68 := v67 +_ = v68 } -v324 := v323.Get() -v325 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v326 := v325.FindInternedVar(lang.NewSymbol("seq")) -if v326.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v326))) +v68 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7787), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(7791), lang.NewKeyword("end-column"), int(51)) +v69, err := lang.WithMeta(v67, v68.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v327 := v326.Get() -v328 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v329 := v328.FindInternedVar(lang.NewSymbol("concat")) -if v329.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v329))) +v70 := lang.Apply(v3, []any{v55}) +v71 := lang.Apply(v69, []any{v70}) +v72 := lang.Apply(v63, []any{v66, v71}) +v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v74 := v73.FindInternedVar(lang.NewSymbol("reduce")) +if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) } -v330 := v329.Get() -v331 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v332 := v331.FindInternedVar(lang.NewSymbol("list")) -if v332.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v332))) +v75 := v74.Get() +v76 := lang.NewVector(nil, nil, nil) +v77 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7794), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(7794), lang.NewKeyword("end-column"), int(22)) +v78, err := lang.WithMeta(v76, v77.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v333 := v332.Get() -v334 := lang.Apply(v333, []any{lang.NewSymbol("glojure.core/<")}) -v335 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v336 := v335.FindInternedVar(lang.NewSymbol("list")) -if v336.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v336))) +var v79 any = nil +_ = v79 +v81 := lang.Apply(v3, []any{v55}) +var v80 any = v81 +_ = v80 +var v82 any +for { +var v83 any +v84 := lang.Apply(v31, []any{v80}) +if lang.IsTruthy(v84) { +v86 := lang.Apply(v39, []any{v80}) +v87 := lang.Apply(nil, []any{v85, v86}) +var v85 any = v87 +_ = v85 +var v89 any +v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v91 := v90.FindInternedVar(lang.NewSymbol("reduced?")) +if v91.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) } -v337 := v336.Get() -v338 := lang.Apply(v337, []any{v118}) -v339 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v340 := v339.FindInternedVar(lang.NewSymbol("list")) -if v340.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v340))) +v92 := v91.Get() +v93 := lang.Apply(v92, []any{v85}) +if lang.IsTruthy(v93) { +v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v95 := v94.FindInternedVar(lang.NewSymbol("deref")) +if v95.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) } -v341 := v340.Get() -v342 := lang.Apply(v341, []any{v113}) -v343 := lang.Apply(v330, []any{v334, v338, v342}) -v344 := lang.Apply(v327, []any{v343}) -v345 := lang.Apply(v324, []any{v344}) -v346 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v347 := v346.FindInternedVar(lang.NewSymbol("list")) -if v347.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v347))) +v96 := v95.Get() +v97 := lang.Apply(v96, []any{v85}) +v89 = v97 +} else { +v99 := lang.Apply(v47, []any{v80}) +var v98 any = v99 +_ = v98 +var v101 any +v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v103 := v102.FindInternedVar(lang.NewSymbol("nil?")) +if v103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) } -v348 := v347.Get() -v349 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v350 := v349.FindInternedVar(lang.NewSymbol("seq")) -if v350.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v350))) +v104 := v103.Get() +v105 := lang.Apply(v104, []any{v98}) +if lang.IsTruthy(v105) { +v101 = v85 +} else { +var v106 any = v98 +_ = v106 +var v108 any = v85 +v110 := lang.Apply(v3, []any{v106}) +var v109 any = v110 +v79 = v108 +v80 = v109 +continue } -v351 := v350.Get() -v352 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v353 := v352.FindInternedVar(lang.NewSymbol("concat")) -if v353.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v353))) +v89 = v101 } -v354 := v353.Get() -v355 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v356 := v355.FindInternedVar(lang.NewSymbol("list")) -if v356.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v356))) +v83 = v89 +} else { +v83 = v79 } -v357 := v356.Get() -v358 := lang.Apply(v357, []any{lang.NewSymbol("glojure.core/let")}) -v359 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v360 := v359.FindInternedVar(lang.NewSymbol("list")) -if v360.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v360))) +v82 = v83 + break } -v361 := v360.Get() -v362 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v363 := v362.FindInternedVar(lang.NewSymbol("apply")) -if v363.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v363))) +v79 := lang.Apply(v75, []any{v78, v82}) +v80 := lang.Apply(nil, []any{glojure.lang8.Seqable, v72, lang1.IReduceInit, v79}) +return v80 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v364 := v363.Get() -v365 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v366 := v365.FindInternedVar(lang.NewSymbol("vector")) -if v366.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v366))) } -v367 := v366.Get() -v368 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v369 := v368.FindInternedVar(lang.NewSymbol("seq")) -if v369.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v369))) +// iterator-seq +{ +v0 := lang.NewSymbol("iterator-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("iter"))), lang.NewKeyword("doc"), "Returns a seq on a java.util.Iterator. Note that most collections\n providing iterators implement Iterable and thus support seq directly.\n Seqs cache values, thus iterator-seq should not be used on any\n iterator that repeatedly returns the same mutable object.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5743), lang.NewKeyword("end-line"), int(5743))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.Apply(nil, []any{v3}) +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v370 := v369.Get() -v371 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v372 := v371.FindInternedVar(lang.NewSymbol("concat")) -if v372.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v372))) } -v373 := v372.Get() -v374 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v375 := v374.FindInternedVar(lang.NewSymbol("list")) -if v375.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v375))) +// juxt +{ +v0 := lang.NewSymbol("juxt").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("g")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("g"), lang.NewSymbol("h")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("g"), lang.NewSymbol("h"), lang.NewSymbol("&"), lang.NewSymbol("fs"))), lang.NewKeyword("doc"), "Takes a set of functions and returns a fn that is the juxtaposition\n of those fns. The returned fn takes a variable number of args, and\n returns a vector containing the result of applying each fn to the\n args (left-to-right).\n ((juxt a b c) x) => [(a x) (b x) (c x)]", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2568), lang.NewKeyword("end-line"), int(2568))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v5 := lang.Apply(v3, nil) +v6 := lang.NewVector(v5) +v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2578), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(2578), lang.NewKeyword("end-column"), int(16)) +v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v376 := v375.Get() -v377 := lang.Apply(v376, []any{v80}) -v378 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v379 := v378.FindInternedVar(lang.NewSymbol("list")) -if v379.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v379))) +return v8 + case 1: +v5 := args[0] +v6 := lang.Apply(v3, []any{v5}) +v7 := lang.NewVector(v6) +v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2579), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(2579), lang.NewKeyword("end-column"), int(19)) +v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v380 := v379.Get() -v381 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v382 := v381.FindInternedVar(lang.NewSymbol("seq")) -if v382.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v382))) +return v9 + case 2: +v5 := args[0] +v6 := args[1] +v7 := lang.Apply(v3, []any{v5, v6}) +v8 := lang.NewVector(v7) +v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2580), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(2580), lang.NewKeyword("end-column"), int(23)) +v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v383 := v382.Get() -v384 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v385 := v384.FindInternedVar(lang.NewSymbol("concat")) -if v385.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v385))) +return v10 + case 3: +v5 := args[0] +v6 := args[1] +v7 := args[2] +v8 := lang.Apply(v3, []any{v5, v6, v7}) +v9 := lang.NewVector(v8) +v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2581), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(2581), lang.NewKeyword("end-column"), int(27)) +v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v386 := v385.Get() -v387 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v388 := v387.FindInternedVar(lang.NewSymbol("list")) -if v388.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v388))) +return v11 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +v6 := args[1] +v7 := args[2] +v8 := lang.NewList(args[3:]...) +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("apply")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -v389 := v388.Get() -v390 := lang.Apply(v389, []any{lang.NewSymbol(".nth")}) -v391 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v392 := v391.FindInternedVar(lang.NewSymbol("list")) -if v392.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v392))) +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v3, v5, v6, v7, v8}) +v13 := lang.NewVector(v12) +v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2582), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(2582), lang.NewKeyword("end-column"), int(45)) +v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v393 := v392.Get() -v394 := lang.Apply(v393, []any{v101}) -v395 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v396 := v395.FindInternedVar(lang.NewSymbol("list")) -if v396.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v396))) +return v15 + } +}) +v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2577), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2582), lang.NewKeyword("end-column"), int(47)) +v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v397 := v396.Get() -v398 := lang.Apply(v397, []any{v118}) -v399 := lang.Apply(v386, []any{v390, v394, v398}) -v400 := lang.Apply(v383, []any{v399}) -v401 := lang.Apply(v380, []any{v400}) -v402 := lang.Apply(v373, []any{v377, v401}) -v403 := lang.Apply(v370, []any{v402}) -v404 := lang.Apply(v364, []any{v367, v403}) -v405 := lang.Apply(v361, []any{v404}) -v406 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v407 := v406.FindInternedVar(lang.NewSymbol("list")) -if v407.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v407))) +return v6 + case 2: +v3 := args[0] +v4 := args[1] +var v5 lang.FnFunc +v5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v6 := lang.Apply(v3, nil) +v7 := lang.Apply(v4, nil) +v8 := lang.NewVector(v6, v7) +v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2585), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(2585), lang.NewKeyword("end-column"), int(20)) +v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v408 := v407.Get() -v409 := lang.Apply(v408, []any{v229}) -var v410 any -if lang.IsTruthy(v174) { -v411 := lang.NewVector(v178) -v412 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3256), lang.NewKeyword("column"), int(48), lang.NewKeyword("end-line"), int(3256), lang.NewKeyword("end-column"), int(62)) -v413, err := lang.WithMeta(v411, v412.(lang.IPersistentMap)) +return v10 + case 1: +v6 := args[0] +v7 := lang.Apply(v3, []any{v6}) +v8 := lang.Apply(v4, []any{v6}) +v9 := lang.NewVector(v7, v8) +v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2586), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(2586), lang.NewKeyword("end-column"), int(25)) +v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) if err != nil { panic(err) } -v410 = v413 -} else { -v410 = nil +return v11 + case 2: +v6 := args[0] +v7 := args[1] +v8 := lang.Apply(v3, []any{v6, v7}) +v9 := lang.Apply(v4, []any{v6, v7}) +v10 := lang.NewVector(v8, v9) +v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2587), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(2587), lang.NewKeyword("end-column"), int(31)) +v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v414 := lang.Apply(v354, []any{v358, v405, v409, v410}) -v415 := lang.Apply(v351, []any{v414}) -v416 := lang.Apply(v348, []any{v415}) -v417 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v418 := v417.FindInternedVar(lang.NewSymbol("list")) -if v418.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v418))) +return v12 + case 3: +v6 := args[0] +v7 := args[1] +v8 := args[2] +v9 := lang.Apply(v3, []any{v6, v7, v8}) +v10 := lang.Apply(v4, []any{v6, v7, v8}) +v11 := lang.NewVector(v9, v10) +v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2588), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(2588), lang.NewKeyword("end-column"), int(37)) +v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v419 := v418.Get() -v420 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v421 := v420.FindInternedVar(lang.NewSymbol("seq")) -if v421.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v421))) +return v13 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v6 := args[0] +v7 := args[1] +v8 := args[2] +v9 := lang.NewList(args[3:]...) +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("apply")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v422 := v421.Get() -v423 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v424 := v423.FindInternedVar(lang.NewSymbol("concat")) -if v424.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v424))) +v12 := v11.Get() +v13 := lang.Apply(v12, []any{v3, v6, v7, v8, v9}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("apply")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v425 := v424.Get() -v426 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v427 := v426.FindInternedVar(lang.NewSymbol("list")) -if v427.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v427))) +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v4, v6, v7, v8, v9}) +v18 := lang.NewVector(v13, v17) +v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2589), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(2589), lang.NewKeyword("end-column"), int(66)) +v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v428 := v427.Get() -v429 := lang.Apply(v428, []any{lang.NewSymbol("glojure.core/when-let")}) -v430 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v431 := v430.FindInternedVar(lang.NewSymbol("list")) -if v431.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v431))) +return v20 + } +}) +v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2584), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2589), lang.NewKeyword("end-column"), int(68)) +v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v432 := v431.Get() -v433 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v434 := v433.FindInternedVar(lang.NewSymbol("apply")) -if v434.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v434))) +return v7 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +var v6 lang.FnFunc +v6 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v7 := lang.Apply(v3, nil) +v8 := lang.Apply(v4, nil) +v9 := lang.Apply(v5, nil) +v10 := lang.NewVector(v7, v8, v9) +v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2592), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(2592), lang.NewKeyword("end-column"), int(24)) +v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v435 := v434.Get() -v436 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v437 := v436.FindInternedVar(lang.NewSymbol("vector")) -if v437.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v437))) +return v12 + case 1: +v7 := args[0] +v8 := lang.Apply(v3, []any{v7}) +v9 := lang.Apply(v4, []any{v7}) +v10 := lang.Apply(v5, []any{v7}) +v11 := lang.NewVector(v8, v9, v10) +v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2593), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(2593), lang.NewKeyword("end-column"), int(31)) +v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v438 := v437.Get() -v439 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v440 := v439.FindInternedVar(lang.NewSymbol("seq")) -if v440.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v440))) +return v13 + case 2: +v7 := args[0] +v8 := args[1] +v9 := lang.Apply(v3, []any{v7, v8}) +v10 := lang.Apply(v4, []any{v7, v8}) +v11 := lang.Apply(v5, []any{v7, v8}) +v12 := lang.NewVector(v9, v10, v11) +v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2594), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(2594), lang.NewKeyword("end-column"), int(39)) +v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v441 := v440.Get() -v442 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v443 := v442.FindInternedVar(lang.NewSymbol("concat")) -if v443.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v443))) +return v14 + case 3: +v7 := args[0] +v8 := args[1] +v9 := args[2] +v10 := lang.Apply(v3, []any{v7, v8, v9}) +v11 := lang.Apply(v4, []any{v7, v8, v9}) +v12 := lang.Apply(v5, []any{v7, v8, v9}) +v13 := lang.NewVector(v10, v11, v12) +v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2595), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(2595), lang.NewKeyword("end-column"), int(47)) +v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v15 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v7 := args[0] +v8 := args[1] +v9 := args[2] +v10 := lang.NewList(args[3:]...) +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("apply")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v3, v7, v8, v9, v10}) +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("apply")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v4, v7, v8, v9, v10}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("apply")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v5, v7, v8, v9, v10}) +v23 := lang.NewVector(v14, v18, v22) +v24 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2596), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(2596), lang.NewKeyword("end-column"), int(87)) +v25, err := lang.WithMeta(v23, v24.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v25 + } +}) +v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2591), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2596), lang.NewKeyword("end-column"), int(89)) +v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v8 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("list*")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v3, v4, v5, v7}) +var v7 any = v11 +_ = v7 +var v13 lang.FnFunc +v13 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("reduce1")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +var v17 lang.FnFunc +v17 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v18 := args[0] +v19 := args[1] +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("conj")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.Apply(v19, nil) +v24 := lang.Apply(v22, []any{v18, v23}) +return v24 +}) +v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2600), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(2600), lang.NewKeyword("end-column"), int(37)) +v19, err := lang.WithMeta(v17, v18.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v20 := lang.NewVector() +v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2600), lang.NewKeyword("column"), int(39), lang.NewKeyword("end-line"), int(2600), lang.NewKeyword("end-column"), int(40)) +v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v23 := lang.Apply(v16, []any{v19, v22, v7}) +return v23 + case 1: +v14 := args[0] +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("reduce1")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +var v18 lang.FnFunc +v18 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v19 := args[0] +v20 := args[1] +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("conj")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(v20, []any{v14}) +v25 := lang.Apply(v23, []any{v19, v24}) +return v25 +}) +v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2601), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(2601), lang.NewKeyword("end-column"), int(40)) +v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v21 := lang.NewVector() +v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2601), lang.NewKeyword("column"), int(42), lang.NewKeyword("end-line"), int(2601), lang.NewKeyword("end-column"), int(43)) +v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v24 := lang.Apply(v17, []any{v20, v23, v7}) +return v24 + case 2: +v14 := args[0] +v15 := args[1] +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("reduce1")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +var v19 lang.FnFunc +v19 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v20 := args[0] +v21 := args[1] +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("conj")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v21, []any{v14, v15}) +v26 := lang.Apply(v24, []any{v20, v25}) +return v26 +}) +v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2602), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(2602), lang.NewKeyword("end-column"), int(44)) +v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v22 := lang.NewVector() +v23 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2602), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(2602), lang.NewKeyword("end-column"), int(47)) +v24, err := lang.WithMeta(v22, v23.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v25 := lang.Apply(v18, []any{v21, v24, v7}) +return v25 + case 3: +v14 := args[0] +v15 := args[1] +v16 := args[2] +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("reduce1")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +var v20 lang.FnFunc +v20 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v21 := args[0] +v22 := args[1] +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("conj")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v22, []any{v14, v15, v16}) +v27 := lang.Apply(v25, []any{v21, v26}) +return v27 +}) +v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2603), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(2603), lang.NewKeyword("end-column"), int(48)) +v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v23 := lang.NewVector() +v24 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2603), lang.NewKeyword("column"), int(50), lang.NewKeyword("end-line"), int(2603), lang.NewKeyword("end-column"), int(51)) +v25, err := lang.WithMeta(v23, v24.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v26 := lang.Apply(v19, []any{v22, v25, v7}) +return v26 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v14 := args[0] +v15 := args[1] +v16 := args[2] +v17 := lang.NewList(args[3:]...) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("reduce1")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +var v21 lang.FnFunc +v21 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v22 := args[0] +v23 := args[1] +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("conj")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("apply")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{v23, v14, v15, v16, v17}) +v31 := lang.Apply(v26, []any{v22, v30}) +return v31 +}) +v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2604), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(2604), lang.NewKeyword("end-column"), int(66)) +v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v24 := lang.NewVector() +v25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2604), lang.NewKeyword("column"), int(68), lang.NewKeyword("end-line"), int(2604), lang.NewKeyword("end-column"), int(69)) +v26, err := lang.WithMeta(v24, v25.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v27 := lang.Apply(v20, []any{v23, v26, v7}) +return v27 + } +}) +v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2599), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(2604), lang.NewKeyword("end-column"), int(75)) +v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v15 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// keep +{ +v0 := lang.NewSymbol("keep").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the non-nil results of (f item). Note,\n this means false return values will be included. f must be free of\n side-effects. Returns a transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7382), lang.NewKeyword("end-line"), int(7382))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +var v6 lang.FnFunc +v6 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v7 := lang.Apply(v5, nil) +return v7 + case 1: +v7 := args[0] +v8 := lang.Apply(v5, []any{v7}) +return v8 + case 2: +v7 := args[0] +v8 := args[1] +v10 := lang.Apply(v3, []any{v8}) +var v9 any = v10 +_ = v9 +var v12 any +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("nil?")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v9}) +if lang.IsTruthy(v16) { +v12 = v7 +} else { +v17 := lang.Apply(v5, []any{v7, v9}) +v12 = v17 +} +return v12 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7390), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7397), lang.NewKeyword("end-column"), int(31)) +v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v8 +}) +v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7389), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7397), lang.NewKeyword("end-column"), int(32)) +v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v6 + case 2: +v3 := args[0] +v4 := args[1] +var v5 lang.FnFunc +v5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("seq")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v4}) +var v6 any = v10 +_ = v6 +var v12 any +if lang.IsTruthy(v6) { +var v13 any = v6 +_ = v13 +var v15 any +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("chunked-seq?")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v13}) +if lang.IsTruthy(v19) { +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("chunk-first")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v13}) +var v20 any = v24 +_ = v20 +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("count")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.Apply(v28, []any{v20}) +var v25 any = v29 +_ = v25 +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("chunk-buffer")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v25}) +var v30 any = v34 +_ = v30 +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("long")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v25}) +var v36 any = v40 +_ = v36 +var v42 any = int64(0) +_ = v42 +var v43 any +for { +var v44 any +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("<")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +} +v47 := v46.Get() +v48 := lang.Apply(v47, []any{v42, v36}) +if lang.IsTruthy(v48) { +v50, _ := lang.FieldOrMethod(v20, "nth") +if reflect.TypeOf(v50).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) +} +v51 := lang.Apply(v50, []any{v42}) +v52 := lang.Apply(v3, []any{v51}) +var v49 any = v52 +_ = v49 +var v54 any +v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v56 := v55.FindInternedVar(lang.NewSymbol("nil?")) +if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) +} +v57 := v56.Get() +v58 := lang.Apply(v57, []any{v49}) +if lang.IsTruthy(v58) { +v54 = nil +} else { +v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v60 := v59.FindInternedVar(lang.NewSymbol("chunk-append")) +if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) +} +v61 := v60.Get() +v62 := lang.Apply(v61, []any{v30, v49}) +v54 = v62 +} +_ = v54 +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("unchecked-inc")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +} +v52 := v51.Get() +v53 := lang.Apply(v52, []any{v42}) +var v49 any = v53 +v42 = v49 +continue +} else { +v44 = nil +} +v43 = v44 + break +} +_ = v43 +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("chunk-cons")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("chunk")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +} +v41 := v40.Get() +v42 := lang.Apply(v41, []any{v30}) +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("keep")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +} +v45 := v44.Get() +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("chunk-rest")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +} +v48 := v47.Get() +v49 := lang.Apply(v48, []any{v13}) +v50 := lang.Apply(v45, []any{v3, v49}) +v51 := lang.Apply(v38, []any{v42, v50}) +v15 = v51 +} else { +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("first")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v13}) +v25 := lang.Apply(v3, []any{v24}) +var v20 any = v25 +_ = v20 +var v27 any +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("nil?")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{v20}) +if lang.IsTruthy(v31) { +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("keep")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("rest")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v37, []any{v13}) +v39 := lang.Apply(v34, []any{v3, v38}) +v27 = v39 +} else { +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("cons")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("keep")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +} +v45 := v44.Get() +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("rest")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +} +v48 := v47.Get() +v49 := lang.Apply(v48, []any{v13}) +v50 := lang.Apply(v45, []any{v3, v49}) +v51 := lang.Apply(v42, []any{v20, v50}) +v27 = v51 +} +v15 = v27 +} +v12 = v15 +} else { +v12 = nil +} +return v12 +}) +v6 := lang.Apply(lang1.NewLazySeq, []any{v5}) +return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// keep-indexed +{ +v0 := lang.NewSymbol("keep-indexed").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the non-nil results of (f index item). Note,\n this means false return values will be included. f must be free of\n side-effects. Returns a stateful transducer when no collection is\n provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7415), lang.NewKeyword("end-line"), int(7415))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("volatile!")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v444 := v443.Get() -v445 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v446 := v445.FindInternedVar(lang.NewSymbol("list")) -if v446.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v446))) +v9 := v8.Get() +v10 := lang.Apply(v9, []any{int64(-1)}) +var v6 any = v10 +_ = v6 +var v12 lang.FnFunc +v12 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v13 := lang.Apply(v5, nil) +return v13 + case 1: +v13 := args[0] +v14 := lang.Apply(v5, []any{v13}) +return v14 + case 2: +v13 := args[0] +v14 := args[1] +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("inc")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -v447 := v446.Get() -v448 := lang.Apply(v447, []any{v96}) -v449 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v450 := v449.FindInternedVar(lang.NewSymbol("list")) -if v450.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v450))) +v18 := v17.Get() +v19, ok := lang.FieldOrMethod(v6, "Deref") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "Deref"))) } -v451 := v450.Get() -v452 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v453 := v452.FindInternedVar(lang.NewSymbol("seq")) -if v453.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v453))) +var v20 any +switch reflect.TypeOf(v19).Kind() { +case reflect.Func: + v20 = lang.Apply(v19, nil) +default: + v20 = v19 } -v454 := v453.Get() -v455 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v456 := v455.FindInternedVar(lang.NewSymbol("concat")) -if v456.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v456))) +v21 := lang.Apply(v18, []any{v20}) +v22, _ := lang.FieldOrMethod(v6, "reset") +if reflect.TypeOf(v22).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) } -v457 := v456.Get() -v458 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v459 := v458.FindInternedVar(lang.NewSymbol("list")) -if v459.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v459))) +v23 := lang.Apply(v22, []any{v21}) +var v15 any = v23 +_ = v15 +v25 := lang.Apply(v3, []any{v15, v14}) +var v24 any = v25 +_ = v24 +var v27 any +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("nil?")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } -v460 := v459.Get() -v461 := lang.Apply(v460, []any{lang.NewSymbol("glojure.core/seq")}) -v462 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v463 := v462.FindInternedVar(lang.NewSymbol("list")) -if v463.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v463))) +v30 := v29.Get() +v31 := lang.Apply(v30, []any{v24}) +if lang.IsTruthy(v31) { +v27 = v13 +} else { +v32 := lang.Apply(v5, []any{v13, v24}) +v27 = v32 } -v464 := v463.Get() -v465 := lang.Apply(v464, []any{v96}) -v466 := lang.Apply(v457, []any{v461, v465}) -v467 := lang.Apply(v454, []any{v466}) -v468 := lang.Apply(v451, []any{v467}) -v469 := lang.Apply(v444, []any{v448, v468}) -v470 := lang.Apply(v441, []any{v469}) -v471 := lang.Apply(v435, []any{v438, v470}) -v472 := lang.Apply(v432, []any{v471}) -v473 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v474 := v473.FindInternedVar(lang.NewSymbol("list")) -if v474.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v474))) +return v27 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7425), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7433), lang.NewKeyword("end-column"), int(33)) +v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v475 := v474.Get() -v476 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v477 := v476.FindInternedVar(lang.NewSymbol("seq")) -if v477.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v477))) +return v14 +}) +v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7423), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7433), lang.NewKeyword("end-column"), int(35)) +v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v478 := v477.Get() -v479 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v480 := v479.FindInternedVar(lang.NewSymbol("concat")) -if v480.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v480))) +return v6 + case 2: +v3 := args[0] +v4 := args[1] +return nil + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v481 := v480.Get() -v482 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v483 := v482.FindInternedVar(lang.NewSymbol("list")) -if v483.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v483))) } -v484 := v483.Get() -v485 := lang.Apply(v484, []any{lang.NewSymbol("if")}) -v486 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v487 := v486.FindInternedVar(lang.NewSymbol("list")) -if v487.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v487))) +// key +{ +v0 := lang.NewSymbol("key").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("e"))), lang.NewKeyword("doc"), "Returns the key of the map entry.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1563), lang.NewKeyword("end-line"), int(1563))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, _ := lang.FieldOrMethod(v3, "GetKey") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("GetKey is not a function"))) } -v488 := v487.Get() -v489 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v490 := v489.FindInternedVar(lang.NewSymbol("seq")) -if v490.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v490))) +v5 := lang.Apply(v4, []any{}) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v491 := v490.Get() -v492 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v493 := v492.FindInternedVar(lang.NewSymbol("concat")) -if v493.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v493))) } -v494 := v493.Get() -v495 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v496 := v495.FindInternedVar(lang.NewSymbol("list")) -if v496.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v496))) +// keys +{ +v0 := lang.NewSymbol("keys").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"))), lang.NewKeyword("doc"), "Returns a sequence of the map's keys, in the same order as (seq map).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1551), lang.NewKeyword("end-line"), int(1551))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.Apply(lang1.Keys, []any{v3}) +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v497 := v496.Get() -v498 := lang.Apply(v497, []any{lang.NewSymbol("glojure.core/chunked-seq?")}) -v499 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v500 := v499.FindInternedVar(lang.NewSymbol("list")) -if v500.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v500))) } -v501 := v500.Get() -v502 := lang.Apply(v501, []any{v96}) -v503 := lang.Apply(v494, []any{v498, v502}) -v504 := lang.Apply(v491, []any{v503}) -v505 := lang.Apply(v488, []any{v504}) -v506 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v507 := v506.FindInternedVar(lang.NewSymbol("list")) -if v507.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v507))) +// keyword +{ +v1 := reflect.TypeOf((*lang1.Keyword)(nil)).Elem() +v0 := lang.NewSymbol("keyword").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name"))), lang.NewKeyword("doc"), "Returns a Keyword with the given namespace and name. Do not use :\n in the keyword strings, it will be added automatically.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(609), lang.NewKeyword("end-line"), int(609))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v4 := args[0] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("keyword?")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v4}) +if lang.IsTruthy(v9) { +v5 = v4 +} else { +var v10 any +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("symbol?")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v4}) +if lang.IsTruthy(v14) { +v15 := lang.Apply(lang1.InternKeywordSymbol, []any{v4}) +v10 = v15 +} else { +var v16 any +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("string?")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v4}) +if lang.IsTruthy(v20) { +v21 := lang.Apply(lang1.InternKeywordString, []any{v4}) +v16 = v21 +} else { +v16 = nil +} +v10 = v16 +} +v5 = v10 +} +return v5 + case 2: +v4 := args[0] +v5 := args[1] +v6 := lang.Apply(lang1.InternKeyword, []any{v4, v5}) +return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v4 := reflect.TypeOf((*lang1.Keyword)(nil)).Elem() +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// keyword? +{ +v0 := lang.NewSymbol("keyword?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a Keyword", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(563), lang.NewKeyword("end-line"), int(563))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{lang1.Keyword, v3}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// last +{ +v0 := lang.NewSymbol("last").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return the last item in coll, in linear time", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(262), lang.NewKeyword("end-line"), int(266))).(*lang.Symbol) +var v2 lang.FnFunc +{ // function last +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +recur_loop_32: +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("next")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v4}) +if lang.IsTruthy(v9) { +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("next")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v4}) +var v10 any = v14 +v4 = v10 +goto recur_loop_32 +} else { +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("first")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v4}) +v5 = v18 +} +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(266), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(269), lang.NewKeyword("end-column"), int(21))).(lang.FnFunc) +v3 := v2 +_ = v3 +} +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// lazy-cat +{ +v0 := lang.NewSymbol("lazy-cat").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Expands to code which yields a lazy sequence of the concatenation\n of the supplied colls. Each coll expr is not evaluated until it is\n needed. \n\n (lazy-cat xs ys zs) === (concat (lazy-seq xs) (lazy-seq ys) (lazy-seq zs))", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4636), lang.NewKeyword("end-line"), int(4636))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("seq")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("concat")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("list")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{lang.NewSymbol("glojure.core/concat")}) +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("map")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +var v19 lang.FnFunc +v19 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v20 := args[0] +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("list")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(v23, []any{lang.NewSymbol("glojure.core/lazy-seq"), v20}) +return v24 +}) +v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4644), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(4644), lang.NewKeyword("end-column"), int(37)) +v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v22 := lang.Apply(v18, []any{v21, v5}) +v23 := lang.Apply(v11, []any{v15, v22}) +v24 := lang.Apply(v8, []any{v23}) +return v24 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// lazy-seq +{ +v0 := lang.NewSymbol("lazy-seq").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Takes a body of expressions that returns an ISeq or nil, and yields\n a Seqable object that will invoke the body only the first time seq\n is called, and will cache the result and return it on all subsequent\n seq calls. See also - realized?", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(676), lang.NewKeyword("end-line"), int(676))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("list")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("list*")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.NewVector() +v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(683), lang.NewKeyword("column"), int(101), lang.NewKeyword("end-line"), int(683), lang.NewKeyword("end-column"), int(102)) +v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v15 := lang.Apply(v11, []any{lang.NewSymbol("fn*"), v14, v5}) +v16 := lang.Apply(v8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewLazySeq"), v15}) +return v16 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// let +{ +v0 := lang.NewSymbol("let").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "binding => binding-form init-expr\n binding-form => name, or destructuring-form\n destructuring-form => map-destructure-form, or seq-destructure-form\n\n Evaluates the exprs in a lexical context in which the symbols in\n the binding-forms are bound to their respective init-exprs or parts\n therein.\n\n See https://glojure.org/reference/special_forms#binding-forms for\n more information about destructuring.", lang.NewKeyword("forms"), lang.NewVector(lang.NewList(lang.NewSymbol("let"), lang.NewVector(lang.NewSymbol("bindings*")), lang.NewSymbol("exprs*"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4496), lang.NewKeyword("end-line"), int(4496), lang.NewKeyword("special-form"), true)).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +var v7 any +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v5}) +if lang.IsTruthy(v11) { +v7 = nil +} else { +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("str")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("first")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v3}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("meta")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v3}) +v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) +v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) +v28 := lang.Apply(lang1.NewIllegalArgumentError, []any{v27}) +panic(v28) +} +_ = v7 +var v29 any +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("even?")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) } -v508 := v507.Get() -v509 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v510 := v509.FindInternedVar(lang.NewSymbol("seq")) -if v510.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v510))) +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("count")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) } -v511 := v510.Get() -v512 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v513 := v512.FindInternedVar(lang.NewSymbol("concat")) -if v513.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v513))) +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v5}) +v37 := lang.Apply(v32, []any{v36}) +if lang.IsTruthy(v37) { +v29 = nil +} else { +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("str")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) } -v514 := v513.Get() -v515 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v516 := v515.FindInternedVar(lang.NewSymbol("list")) -if v516.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v516))) +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("first")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } -v517 := v516.Get() -v518 := lang.Apply(v517, []any{lang.NewSymbol("glojure.core/let")}) -v519 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v520 := v519.FindInternedVar(lang.NewSymbol("list")) -if v520.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v520))) +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v3}) +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) } -v521 := v520.Get() -v522 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v523 := v522.FindInternedVar(lang.NewSymbol("apply")) -if v523.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v523))) +v47 := v46.Get() +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("meta")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) } -v524 := v523.Get() -v525 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v526 := v525.FindInternedVar(lang.NewSymbol("vector")) -if v526.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v526))) +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v3}) +v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) +v53 := lang.Apply(v40, []any{v44, " requires ", "an even number of forms in binding vector", " in ", v47, ":", v52}) +v54 := lang.Apply(lang1.NewIllegalArgumentError, []any{v53}) +panic(v54) } -v527 := v526.Get() -v528 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v529 := v528.FindInternedVar(lang.NewSymbol("seq")) -if v529.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v529))) +_ = v29 +_ = nil +v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v56 := v55.FindInternedVar(lang.NewSymbol("seq")) +if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) } -v530 := v529.Get() -v531 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v532 := v531.FindInternedVar(lang.NewSymbol("concat")) -if v532.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v532))) +v57 := v56.Get() +v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v59 := v58.FindInternedVar(lang.NewSymbol("concat")) +if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) } -v533 := v532.Get() -v534 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v535 := v534.FindInternedVar(lang.NewSymbol("list")) -if v535.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v535))) +v60 := v59.Get() +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("list")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) } -v536 := v535.Get() -v537 := lang.Apply(v536, []any{lang.NewSymbol("c__0__auto__")}) -v538 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v539 := v538.FindInternedVar(lang.NewSymbol("list")) -if v539.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v539))) +v63 := v62.Get() +v64 := lang.Apply(v63, []any{lang.NewSymbol("let*")}) +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("list")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) } -v540 := v539.Get() -v541 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v542 := v541.FindInternedVar(lang.NewSymbol("seq")) -if v542.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v542))) +v67 := v66.Get() +v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v69 := v68.FindInternedVar(lang.NewSymbol("destructure")) +if v69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) } -v543 := v542.Get() -v544 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v545 := v544.FindInternedVar(lang.NewSymbol("concat")) -if v545.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v545))) +v70 := v69.Get() +v71 := lang.Apply(v70, []any{v5}) +v72 := lang.Apply(v67, []any{v71}) +v73 := lang.Apply(v60, []any{v64, v72, v6}) +v74 := lang.Apply(v57, []any{v73}) +return v74 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v546 := v545.Get() -v547 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v548 := v547.FindInternedVar(lang.NewSymbol("list")) -if v548.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v548))) } -v549 := v548.Get() -v550 := lang.Apply(v549, []any{lang.NewSymbol("glojure.core/chunk-first")}) -v551 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v552 := v551.FindInternedVar(lang.NewSymbol("list")) -if v552.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v552))) +// letfn +{ +v0 := lang.NewSymbol("letfn").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fnspecs"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "fnspec ==> (fname [params*] exprs) or (fname ([params*] exprs)+)\n\n Takes a vector of function specs and a body, and generates a set of\n bindings of functions to their names. All of the names are available\n in all of the definitions of the functions, as well as the body.", lang.NewKeyword("forms"), lang.NewVector(lang.NewList(lang.NewSymbol("letfn"), lang.NewVector(lang.NewSymbol("fnspecs*")), lang.NewSymbol("exprs*"))), lang.NewKeyword("url"), nil, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6588), lang.NewKeyword("end-line"), int(6588), lang.NewKeyword("special-form"), true)).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("seq")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v553 := v552.Get() -v554 := lang.Apply(v553, []any{v96}) -v555 := lang.Apply(v546, []any{v550, v554}) -v556 := lang.Apply(v543, []any{v555}) -v557 := lang.Apply(v540, []any{v556}) -v558 := lang.Apply(v533, []any{v537, v557}) -v559 := lang.Apply(v530, []any{v558}) -v560 := lang.Apply(v524, []any{v527, v559}) -v561 := lang.Apply(v521, []any{v560}) -v562 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v563 := v562.FindInternedVar(lang.NewSymbol("list")) -if v563.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v563))) +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("concat")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v564 := v563.Get() -v565 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v566 := v565.FindInternedVar(lang.NewSymbol("seq")) -if v566.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v566))) +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("list")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } -v567 := v566.Get() -v568 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v569 := v568.FindInternedVar(lang.NewSymbol("concat")) -if v569.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v569))) +v15 := v14.Get() +v16 := lang.Apply(v15, []any{lang.NewSymbol("letfn*")}) +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("list")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v570 := v569.Get() -v571 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v572 := v571.FindInternedVar(lang.NewSymbol("list")) -if v572.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v572))) +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("vec")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v573 := v572.Get() -v574 := lang.Apply(v573, []any{lang.NewSymbol("recur")}) -v575 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v576 := v575.FindInternedVar(lang.NewSymbol("list")) -if v576.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v576))) +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("interleave")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v577 := v576.Get() -v578 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v579 := v578.FindInternedVar(lang.NewSymbol("seq")) -if v579.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v579))) +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("map")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) } -v580 := v579.Get() -v581 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v582 := v581.FindInternedVar(lang.NewSymbol("concat")) -if v582.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v582))) +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("first")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) } -v583 := v582.Get() -v584 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v585 := v584.FindInternedVar(lang.NewSymbol("list")) -if v585.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v585))) +v31 := v30.Get() +v32 := lang.Apply(v28, []any{v31, v5}) +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("map")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) } -v586 := v585.Get() -v587 := lang.Apply(v586, []any{lang.NewSymbol("glojure.core/chunk-rest")}) -v588 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v589 := v588.FindInternedVar(lang.NewSymbol("list")) -if v589.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v589))) +v35 := v34.Get() +var v36 lang.FnFunc +v36 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v37 := args[0] +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("cons")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) } -v590 := v589.Get() -v591 := lang.Apply(v590, []any{v96}) -v592 := lang.Apply(v583, []any{v587, v591}) -v593 := lang.Apply(v580, []any{v592}) -v594 := lang.Apply(v577, []any{v593}) -v595 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v596 := v595.FindInternedVar(lang.NewSymbol("list")) -if v596.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v596))) +v40 := v39.Get() +v41 := lang.Apply(v40, []any{lang.NewSymbol("glojure.core/fn"), v37}) +return v41 +}) +v37 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6598), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(6598), lang.NewKeyword("end-column"), int(47)) +v38, err := lang.WithMeta(v36, v37.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v597 := v596.Get() -v598 := lang.Apply(v597, []any{lang.NewSymbol("c__0__auto__")}) -v599 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v600 := v599.FindInternedVar(lang.NewSymbol("list")) -if v600.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v600))) +v39 := lang.Apply(v35, []any{v38, v5}) +v40 := lang.Apply(v25, []any{v32, v39}) +v41 := lang.Apply(v22, []any{v40}) +v42 := lang.Apply(v19, []any{v41}) +v43 := lang.Apply(v12, []any{v16, v42, v6}) +v44 := lang.Apply(v9, []any{v43}) +return v44 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v601 := v600.Get() -v602 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v603 := v602.FindInternedVar(lang.NewSymbol("seq")) -if v603.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v603))) } -v604 := v603.Get() -v605 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v606 := v605.FindInternedVar(lang.NewSymbol("concat")) -if v606.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v606))) +// libspec? +{ +v0 := lang.NewSymbol("libspec?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is a libspec", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5891), lang.NewKeyword("end-line"), int(5891), lang.NewKeyword("private"), true)).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("symbol?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v607 := v606.Get() -v608 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v609 := v608.FindInternedVar(lang.NewSymbol("list")) -if v609.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v609))) +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +var v4 any = v8 +_ = v4 +var v10 any +if lang.IsTruthy(v4) { +v10 = v4 +} else { +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("vector?")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } -v610 := v609.Get() -v611 := lang.Apply(v610, []any{lang.NewSymbol("glojure.core/int")}) -v612 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v613 := v612.FindInternedVar(lang.NewSymbol("list")) -if v613.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v613))) +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v3}) +var v11 any = v15 +_ = v11 +var v17 any +if lang.IsTruthy(v11) { +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("nil?")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v614 := v613.Get() -v615 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v616 := v615.FindInternedVar(lang.NewSymbol("seq")) -if v616.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v616))) +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("second")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -v617 := v616.Get() -v618 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v619 := v618.FindInternedVar(lang.NewSymbol("concat")) -if v619.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v619))) +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v3}) +v26 := lang.Apply(v21, []any{v25}) +var v18 any = v26 +_ = v18 +var v28 any +if lang.IsTruthy(v18) { +v28 = v18 +} else { +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("keyword?")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) } -v620 := v619.Get() -v621 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v622 := v621.FindInternedVar(lang.NewSymbol("list")) -if v622.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v622))) +v31 := v30.Get() +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("second")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) } -v623 := v622.Get() -v624 := lang.Apply(v623, []any{lang.NewSymbol("glojure.core/count")}) -v625 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v626 := v625.FindInternedVar(lang.NewSymbol("list")) -if v626.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v626))) +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.Apply(v31, []any{v35}) +v28 = v36 } -v627 := v626.Get() -v628 := lang.Apply(v627, []any{lang.NewSymbol("c__0__auto__")}) -v629 := lang.Apply(v620, []any{v624, v628}) -v630 := lang.Apply(v617, []any{v629}) -v631 := lang.Apply(v614, []any{v630}) -v632 := lang.Apply(v607, []any{v611, v631}) -v633 := lang.Apply(v604, []any{v632}) -v634 := lang.Apply(v601, []any{v633}) -v635 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v636 := v635.FindInternedVar(lang.NewSymbol("list")) -if v636.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v636))) +v17 = v28 +} else { +v17 = v11 } -v637 := v636.Get() -v638 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v639 := v638.FindInternedVar(lang.NewSymbol("seq")) -if v639.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v639))) +v10 = v17 } -v640 := v639.Get() -v641 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v642 := v641.FindInternedVar(lang.NewSymbol("concat")) -if v642.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v642))) +return v10 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v643 := v642.Get() -v644 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v645 := v644.FindInternedVar(lang.NewSymbol("list")) -if v645.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v645))) } -v646 := v645.Get() -v647 := lang.Apply(v646, []any{lang.NewSymbol("glojure.core/int")}) -v648 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v649 := v648.FindInternedVar(lang.NewSymbol("list")) -if v649.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v649))) +// lift-ns +{ +v0 := lang.NewSymbol("lift-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"))), lang.NewKeyword("doc"), "Returns [lifted-ns lifted-kvs] or nil if m can't be lifted.", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(261), lang.NewKeyword("end-line"), int(261), lang.NewKeyword("private"), true)).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("*print-namespace-maps*")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v650 := v649.Get() -v651 := lang.Apply(v650, []any{int64(0)}) -v652 := lang.Apply(v643, []any{v647, v651}) -v653 := lang.Apply(v640, []any{v652}) -v654 := lang.Apply(v637, []any{v653}) -v655 := lang.Apply(v570, []any{v574, v594, v598, v634, v654}) -v656 := lang.Apply(v567, []any{v655}) -v657 := lang.Apply(v564, []any{v656}) -v658 := lang.Apply(v514, []any{v518, v561, v657}) -v659 := lang.Apply(v511, []any{v658}) -v660 := lang.Apply(v508, []any{v659}) -v661 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v662 := v661.FindInternedVar(lang.NewSymbol("list")) -if v662.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v662))) +v7 := v6.Get() +if lang.IsTruthy(v7) { +var v8 any = nil +_ = v8 +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("seq")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v663 := v662.Get() -v664 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v665 := v664.FindInternedVar(lang.NewSymbol("seq")) -if v665.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v665))) +v12 := v11.Get() +v13 := lang.Apply(v12, []any{v3}) +var v9 any = v13 +_ = v9 +var v14 any = v9 +_ = v14 +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("seq")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -v666 := v665.Get() -v667 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v668 := v667.FindInternedVar(lang.NewSymbol("concat")) -if v668.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v668))) +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v14}) +var v15 any = v19 +_ = v15 +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("first")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v669 := v668.Get() -v670 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v671 := v670.FindInternedVar(lang.NewSymbol("list")) -if v671.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v671))) +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v15}) +var v20 any = v24 +_ = v20 +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("next")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) } -v672 := v671.Get() -v673 := lang.Apply(v672, []any{lang.NewSymbol("glojure.core/let")}) -v674 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v675 := v674.FindInternedVar(lang.NewSymbol("list")) -if v675.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v675))) +v28 := v27.Get() +v29 := lang.Apply(v28, []any{v25}) +var v25 any = v29 +_ = v25 +var v30 any = v20 +_ = v30 +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("nth")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) } -v676 := v675.Get() -v677 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v678 := v677.FindInternedVar(lang.NewSymbol("apply")) -if v678.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v678))) +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v30, int64(0), nil}) +var v31 any = v35 +_ = v31 +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("nth")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -v679 := v678.Get() -v680 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v681 := v680.FindInternedVar(lang.NewSymbol("vector")) -if v681.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v681))) +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v30, int64(1), nil}) +var v36 any = v40 +_ = v36 +var v41 any = v30 +_ = v41 +var v42 any = v25 +_ = v42 +v44 := lang.NewVector() +v45 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(267), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(267), lang.NewKeyword("end-column"), int(17)) +v46, err := lang.WithMeta(v44, v45.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v682 := v681.Get() -v683 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v684 := v683.FindInternedVar(lang.NewSymbol("seq")) -if v684.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v684))) +var v43 any = v46 +_ = v43 +var v48 any = v48 +_ = v48 +var v49 any = v49 +_ = v49 +var v50 any = v50 +_ = v50 +var v51 any +for { +var v52 any = v52 +_ = v52 +var v53 any = v49 +_ = v53 +v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v56 := v55.FindInternedVar(lang.NewSymbol("seq")) +if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) } -v685 := v684.Get() -v686 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v687 := v686.FindInternedVar(lang.NewSymbol("concat")) -if v687.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v687))) +v57 := v56.Get() +v58 := lang.Apply(v57, []any{v53}) +var v54 any = v58 +_ = v54 +v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v61 := v60.FindInternedVar(lang.NewSymbol("first")) +if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) } -v688 := v687.Get() -v689 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v690 := v689.FindInternedVar(lang.NewSymbol("list")) -if v690.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v690))) +v62 := v61.Get() +v63 := lang.Apply(v62, []any{v54}) +var v59 any = v63 +_ = v59 +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("next")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) } -v691 := v690.Get() -v692 := lang.Apply(v691, []any{v80}) -v693 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v694 := v693.FindInternedVar(lang.NewSymbol("list")) -if v694.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v694))) +v67 := v66.Get() +v68 := lang.Apply(v67, []any{v64}) +var v64 any = v68 +_ = v64 +var v69 any = v59 +_ = v69 +v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v72 := v71.FindInternedVar(lang.NewSymbol("nth")) +if v72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) } -v695 := v694.Get() -v696 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v697 := v696.FindInternedVar(lang.NewSymbol("seq")) -if v697.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v697))) +v73 := v72.Get() +v74 := lang.Apply(v73, []any{v69, int64(0), nil}) +var v70 any = v74 +_ = v70 +v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v77 := v76.FindInternedVar(lang.NewSymbol("nth")) +if v77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) } -v698 := v697.Get() -v699 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v700 := v699.FindInternedVar(lang.NewSymbol("concat")) -if v700.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v700))) +v78 := v77.Get() +v79 := lang.Apply(v78, []any{v69, int64(1), nil}) +var v75 any = v79 +_ = v75 +var v80 any = v69 +_ = v80 +var v81 any = v64 +_ = v81 +var v82 any = v82 +_ = v82 +var v84 any +if lang.IsTruthy(v80) { +var v85 any +v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v87 := v86.FindInternedVar(lang.NewSymbol("qualified-ident?")) +if v87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) } -v701 := v700.Get() -v702 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v703 := v702.FindInternedVar(lang.NewSymbol("list")) -if v703.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v703))) +v88 := v87.Get() +v89 := lang.Apply(v88, []any{v70}) +if lang.IsTruthy(v89) { +var v90 any +if lang.IsTruthy(v52) { +var v91 any +v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v93 := v92.FindInternedVar(lang.NewSymbol("=")) +if v93.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) } -v704 := v703.Get() -v705 := lang.Apply(v704, []any{lang.NewSymbol("glojure.core/first")}) -v706 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v707 := v706.FindInternedVar(lang.NewSymbol("list")) -if v707.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v707))) +v94 := v93.Get() +v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v96 := v95.FindInternedVar(lang.NewSymbol("namespace")) +if v96.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) } -v708 := v707.Get() -v709 := lang.Apply(v708, []any{v96}) -v710 := lang.Apply(v701, []any{v705, v709}) -v711 := lang.Apply(v698, []any{v710}) -v712 := lang.Apply(v695, []any{v711}) -v713 := lang.Apply(v688, []any{v692, v712}) -v714 := lang.Apply(v685, []any{v713}) -v715 := lang.Apply(v679, []any{v682, v714}) -v716 := lang.Apply(v676, []any{v715}) -v717 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v718 := v717.FindInternedVar(lang.NewSymbol("list")) -if v718.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v718))) +v97 := v96.Get() +v98 := lang.Apply(v97, []any{v70}) +v99 := lang.Apply(v94, []any{v52, v98}) +if lang.IsTruthy(v99) { +var v100 any = v52 +var v101 any = v81 +v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v104 := v103.FindInternedVar(lang.NewSymbol("conj")) +if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) } -v719 := v718.Get() -v720 := lang.Apply(v719, []any{v176}) -var v721 any -if lang.IsTruthy(v174) { -v722 := lang.NewVector(v123) -v723 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3264), lang.NewKeyword("column"), int(52), lang.NewKeyword("end-line"), int(3264), lang.NewKeyword("end-column"), int(60)) -v724, err := lang.WithMeta(v722, v723.(lang.IPersistentMap)) +v105 := v104.Get() +v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v107 := v106.FindInternedVar(lang.NewSymbol("strip-ns")) +if v107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) +} +v108 := v107.Get() +v109 := lang.Apply(v108, []any{v70}) +v110 := lang.NewVector(v109, v75) +v111 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(272), lang.NewKeyword("column"), int(43), lang.NewKeyword("end-line"), int(272), lang.NewKeyword("end-column"), int(58)) +v112, err := lang.WithMeta(v110, v111.(lang.IPersistentMap)) if err != nil { panic(err) } -v721 = v724 +v113 := lang.Apply(v105, []any{v82, v112}) +var v102 any = v113 +v48 = v100 +v49 = v101 +v50 = v102 +continue } else { -v721 = nil +v91 = nil } -v725 := lang.Apply(v669, []any{v673, v716, v720, v721}) -v726 := lang.Apply(v666, []any{v725}) -v727 := lang.Apply(v663, []any{v726}) -v728 := lang.Apply(v481, []any{v485, v505, v660, v727}) -v729 := lang.Apply(v478, []any{v728}) -v730 := lang.Apply(v475, []any{v729}) -v731 := lang.Apply(v425, []any{v429, v472, v730}) -v732 := lang.Apply(v422, []any{v731}) -v733 := lang.Apply(v419, []any{v732}) -v734 := lang.Apply(v317, []any{v321, v345, v416, v733}) -v735 := lang.Apply(v314, []any{v734}) -v736 := lang.Apply(v311, []any{v735}) -v737 := lang.Apply(v237, []any{v241, v308, v736}) -v738 := lang.Apply(v234, []any{v737}) -v739 := lang.NewVector(true, v738) -v740 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3250), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(3264), lang.NewKeyword("end-column"), int(67)) -v741, err := lang.WithMeta(v739, v740.(lang.IPersistentMap)) +v90 = v91 +} else { +v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v116 := v115.FindInternedVar(lang.NewSymbol("namespace")) +if v116.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) +} +v117 := v116.Get() +v118 := lang.Apply(v117, []any{v70}) +var v114 any = v118 +_ = v114 +var v120 any +if lang.IsTruthy(v114) { +var v121 any = v114 +_ = v121 +var v123 any = v121 +var v124 any = v81 +v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v127 := v126.FindInternedVar(lang.NewSymbol("conj")) +if v127.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) +} +v128 := v127.Get() +v129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v130 := v129.FindInternedVar(lang.NewSymbol("strip-ns")) +if v130.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v130))) +} +v131 := v130.Get() +v132 := lang.Apply(v131, []any{v70}) +v133 := lang.NewVector(v132, v75) +v134 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(274), lang.NewKeyword("column"), int(47), lang.NewKeyword("end-line"), int(274), lang.NewKeyword("end-column"), int(62)) +v135, err := lang.WithMeta(v133, v134.(lang.IPersistentMap)) if err != nil { panic(err) } -v91 = v741 +v136 := lang.Apply(v128, []any{v82, v135}) +var v125 any = v136 +v48 = v123 +v49 = v124 +v50 = v125 +continue +} else { +v120 = nil } -v60 = v91 +v90 = v120 } -return v60 -}) -v57 := v56 -_ = v57 +v85 = v90 +} else { +v85 = nil } -v57 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3218), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(3264), lang.NewKeyword("end-column"), int(72)) -v58, err := lang.WithMeta(v56, v57.(lang.IPersistentMap)) +v84 = v85 +} else { +v114 := lang.NewVector(v52, v82) +v115 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(275), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(275), lang.NewKeyword("end-column"), int(16)) +v116, err := lang.WithMeta(v114, v115.(lang.IPersistentMap)) if err != nil { panic(err) } -var v55 any = v58 -_ = v55 -v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v61 := v60.FindInternedVar(lang.NewSymbol("nth")) -if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) +v84 = v116 } -v62 := v61.Get() -v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v64 := v63.FindInternedVar(lang.NewSymbol("seq")) -if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) +v51 = v84 + break } -v65 := v64.Get() -v66 := lang.Apply(v65, []any{v5}) -v67 := lang.Apply(v55, []any{nil, v66}) -v68 := lang.Apply(v62, []any{v67, int64(1)}) -return v68 - } +v4 = v51 +} else { +v4 = nil +} +return v4 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -45930,203 +45096,684 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// abs +// line-seq { -var v1 lang.FnFunc -{ // function abs__inliner -v1 = lang.NewFnFunc(func(args ...any) any { +v0 := lang.NewSymbol("line-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rdr"))), lang.NewKeyword("doc"), "Returns the lines of text from rdr as a lazy sequence of strings.\n rdr must implement java.io.BufferedReader.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3068), lang.NewKeyword("end-line"), int(3068))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] +v5, ok := lang.FieldOrMethod(v3, "readLine") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "readLine"))) +} +var v6 any +switch reflect.TypeOf(v5).Kind() { +case reflect.Func: + v6 = lang.Apply(v5, nil) +default: + v6 = v5 +} +var v4 any = v6 +_ = v4 +var v8 any +if lang.IsTruthy(v4) { +var v9 any = v4 +_ = v9 +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("cons")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +var v14 lang.FnFunc +v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("line-seq")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v3}) +return v18 +}) +v15 := lang.Apply(lang1.NewLazySeq, []any{v14}) +v16 := lang.Apply(v13, []any{v9, v15}) +v8 = v16 +} else { +v8 = nil +} +return v8 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// list +{ +v0 := lang.NewSymbol("list").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("items"))), lang.NewKeyword("doc"), "Creates a new list containing the items.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(15), lang.NewKeyword("end-line"), int(18))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, nil, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// list* +{ +v0 := lang.NewSymbol("list*").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Creates a new seq containing the items prepended to the rest, the\n last of which will be treated as a sequence.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(641), lang.NewKeyword("end-line"), int(641))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v5 := v4.FindInternedVar(lang.NewSymbol("seq")) if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() +v7 := lang.Apply(v6, []any{v3}) +return v7 + case 2: +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("cons")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3, v4}) +return v8 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("cons")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("cons")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v4, v5}) +v13 := lang.Apply(v8, []any{v3, v12}) +return v13 + case 4: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +v8 := v7.FindInternedVar(lang.NewSymbol("cons")) if v8.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("cons")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("cons")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v5, v6}) +v17 := lang.Apply(v12, []any{v4, v16}) +v18 := lang.Apply(v9, []any{v3, v17}) +return v18 + default: + if len(args) < 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := lang.NewList(args[4:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("cons")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("cons")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Abs")}) +v13 := v12.Get() v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) +v15 := v14.FindInternedVar(lang.NewSymbol("cons")) if v15.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } v16 := v15.Get() -v17 := lang.Apply(v16, []any{v3}) -v18 := lang.Apply(v9, []any{v13, v17}) -v19 := lang.Apply(v6, []any{v18}) -return v19 -}) -v2 := v1 -_ = v2 +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("cons")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v0 := lang.NewSymbol("abs").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the absolute value of a.\n If a is Long/MIN_VALUE => Long/MIN_VALUE\n If a is a double and zero => +0.0\n If a is a double and ##Inf or ##-Inf => ##Inf\n If a is a double and ##NaN => ##NaN", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)), lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1128), lang.NewKeyword("end-line"), int(1128))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("spread")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.Apply(v22, []any{v7}) +v24 := lang.Apply(v19, []any{v6, v23}) +v25 := lang.Apply(v16, []any{v5, v24}) +v26 := lang.Apply(v13, []any{v4, v25}) +v27 := lang.Apply(v10, []any{v3, v26}) +return v27 } -v4 := args[0] -v5 := lang.Apply(lang1.Abs, []any{v4}) -return v5 }) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// aclone +// list? { -var v1 lang.FnFunc -{ // function aclone__inliner -v1 = lang.NewFnFunc(func(args ...any) any { +v0 := lang.NewSymbol("list?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements IPersistentList", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6241), lang.NewKeyword("end-line"), int(6241))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v7 := lang.Apply(v6, []any{lang1.IPersistentList, v3}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +// load +{ +v0 := lang.NewSymbol("load").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("paths"))), lang.NewKeyword("doc"), "Loads Clojure code from resources in classpath. A path is interpreted as\n classpath-relative if it begins with a slash or relative to the root\n directory for the current namespace otherwise.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("redef"), true, lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6138), lang.NewKeyword("end-line"), int(6138))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.NewList(args[0:]...) +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +var v4 any = v8 +_ = v4 +var v9 any = nil +_ = v9 +var v10 any = int64(0) +_ = v10 +var v11 any = int64(0) +_ = v11 +var v12 any +for { +var v13 any v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) +v15 := v14.FindInternedVar(lang.NewSymbol("<")) if v15.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +v17 := lang.Apply(v16, []any{v11, v10}) +if lang.IsTruthy(v17) { +v19, _ := lang.FieldOrMethod(v9, "nth") +if reflect.TypeOf(v19).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) } -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +v20 := lang.Apply(v19, []any{v11}) +var v18 any = v20 +_ = v18 +var v23 any +v24 := lang.Apply(strings22.HasPrefix, []any{v22, "/"}) +if lang.IsTruthy(v24) { +v23 = v22 +} else { +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("str")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("root-directory")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/Aclone")}) +v30 := v29.Get() v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) +v32 := v31.FindInternedVar(lang.NewSymbol("ns-name")) if v32.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } v33 := v32.Get() -v34 := lang.Apply(v33, []any{v3}) -v35 := lang.Apply(v26, []any{v30, v34}) -v36 := lang.Apply(v23, []any{v35}) -v37 := lang.Apply(v20, []any{v36}) -v38 := lang.Apply(v9, []any{v13, v17, v37}) -v39 := lang.Apply(v6, []any{v38}) -return v39 -}) -v2 := v1 -_ = v2 +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("*ns*")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } -v0 := lang.NewSymbol("aclone").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns a clone of the Java array. Works on arrays of known\n types.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3904), lang.NewKeyword("end-line"), int(3904))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5, _ := lang.FieldOrMethod(runtime3.RT, "Aclone") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Aclone is not a function"))) +v36 := v35.Get() +v37 := lang.Apply(v33, []any{v36}) +v38 := lang.Apply(v30, []any{v37}) +v39 := lang.Apply(v27, []any{v38, lang.NewChar(47), v22}) +v23 = v39 } -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +var v22 any = v23 +_ = v22 +var v41 any +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +} +v44 := v43.Get() +if lang.IsTruthy(v44) { +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("printf")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +} +v47 := v46.Get() +v48 := lang.Apply(v47, []any{"(glojure.core/load \"%s\")\n", v22}) +_ = v48 +v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v50 := v49.FindInternedVar(lang.NewSymbol("flush")) +if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) +} +v51 := v50.Get() +v52 := lang.Apply(v51, nil) +v41 = v52 +} else { +v41 = nil +} +_ = v41 +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("check-cyclic-dependency")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +} +v55 := v54.Get() +v56 := lang.Apply(v55, []any{v22}) +_ = v56 +var v57 any +v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v59 := v58.FindInternedVar(lang.NewSymbol("=")) +if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) +} +v60 := v59.Get() +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("first")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +} +v63 := v62.Get() +v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v65 := v64.FindInternedVar(lang.NewSymbol("*pending-paths*")) +if v65.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) +} +v66 := v65.Get() +v67 := lang.Apply(v63, []any{v66}) +v68 := lang.Apply(v60, []any{v22, v67}) +if lang.IsTruthy(v68) { +v57 = nil +} else { +v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v71 := v70.FindInternedVar(lang.NewSymbol("push-thread-bindings")) +if v71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) +} +v72 := v71.Get() +v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v74 := v73.FindInternedVar(lang.NewSymbol("hash-map")) +if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) +} +v75 := v74.Get() +v76 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*pending-paths*")) +v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v78 := v77.FindInternedVar(lang.NewSymbol("conj")) +if v78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) +} +v79 := v78.Get() +v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v81 := v80.FindInternedVar(lang.NewSymbol("*pending-paths*")) +if v81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) +} +v82 := v81.Get() +v83 := lang.Apply(v79, []any{v82, v22}) +v84 := lang.Apply(v75, []any{v76, v83}) +v85 := lang.Apply(v72, []any{v84}) +_ = v85 +var v86 any +func() { +defer func() { +v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v88 := v87.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) +if v88.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) +} +v89 := v88.Get() +v90 := lang.Apply(v89, nil) +}() +v91 := lang.Apply(strings22.TrimPrefix, []any{v22, "/"}) +v92, _ := lang.FieldOrMethod(runtime9.RT, "Load") +if reflect.TypeOf(v92).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Load is not a function"))) +} +v93 := lang.Apply(v92, []any{v91}) +v86 = v93 +}() +v57 = v86 +} +_ = v57 +var v22 any = v4 +var v23 any = v9 +var v24 any = v10 +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("unchecked-inc")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.Apply(v28, []any{v11}) +var v25 any = v29 +v4 = v22 +v9 = v23 +v10 = v24 +v11 = v25 +continue +} else { +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("seq")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v4}) +var v18 any = v22 +_ = v18 +var v24 any +if lang.IsTruthy(v18) { +var v25 any = v18 +_ = v25 +var v27 any +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("chunked-seq?")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{v25}) +if lang.IsTruthy(v31) { +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("chunk-first")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v25}) +var v32 any = v36 +_ = v32 +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("chunk-rest")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +} +v41 := v40.Get() +v42 := lang.Apply(v41, []any{v25}) +var v38 any = v42 +var v43 any = v32 +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("int")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +} +v47 := v46.Get() +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("count")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v32}) +v52 := lang.Apply(v47, []any{v51}) +var v44 any = v52 +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("int")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +} +v56 := v55.Get() +v57 := lang.Apply(v56, []any{int64(0)}) +var v53 any = v57 +v4 = v38 +v9 = v43 +v10 = v44 +v11 = v53 +continue +} else { +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("first")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v25}) +var v32 any = v36 +_ = v32 +var v39 any +v40 := lang.Apply(strings22.HasPrefix, []any{v38, "/"}) +if lang.IsTruthy(v40) { +v39 = v38 +} else { +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("str")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("root-directory")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("ns-name")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +} +v49 := v48.Get() +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("*ns*")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +} +v52 := v51.Get() +v53 := lang.Apply(v49, []any{v52}) +v54 := lang.Apply(v46, []any{v53}) +v55 := lang.Apply(v43, []any{v54, lang.NewChar(47), v38}) +v39 = v55 +} +var v38 any = v39 +_ = v38 +var v57 any +v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v59 := v58.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) +if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) +} +v60 := v59.Get() +if lang.IsTruthy(v60) { +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("printf")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +} +v63 := v62.Get() +v64 := lang.Apply(v63, []any{"(glojure.core/load \"%s\")\n", v38}) +_ = v64 +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("flush")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +} +v67 := v66.Get() +v68 := lang.Apply(v67, nil) +v57 = v68 +} else { +v57 = nil +} +_ = v57 +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("check-cyclic-dependency")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +} +v71 := v70.Get() +v72 := lang.Apply(v71, []any{v38}) +_ = v72 +var v73 any +v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v75 := v74.FindInternedVar(lang.NewSymbol("=")) +if v75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) +} +v76 := v75.Get() +v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v78 := v77.FindInternedVar(lang.NewSymbol("first")) +if v78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) +} +v79 := v78.Get() +v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v81 := v80.FindInternedVar(lang.NewSymbol("*pending-paths*")) +if v81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) +} +v82 := v81.Get() +v83 := lang.Apply(v79, []any{v82}) +v84 := lang.Apply(v76, []any{v38, v83}) +if lang.IsTruthy(v84) { +v73 = nil +} else { +v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v87 := v86.FindInternedVar(lang.NewSymbol("push-thread-bindings")) +if v87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) +} +v88 := v87.Get() +v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v90 := v89.FindInternedVar(lang.NewSymbol("hash-map")) +if v90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) +} +v91 := v90.Get() +v92 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*pending-paths*")) +v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v94 := v93.FindInternedVar(lang.NewSymbol("conj")) +if v94.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) } +v95 := v94.Get() +v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v97 := v96.FindInternedVar(lang.NewSymbol("*pending-paths*")) +if v97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) } -// serialized-require -{ -v0 := lang.NewSymbol("serialized-require").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Like 'require', but serializes loading.\n Interim function preferred over 'require' for known asynchronous loads.\n Future changes may make these equivalent.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6102), lang.NewKeyword("end-line"), int(6102), lang.NewKeyword("private"), true)).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewList(args[0:]...) -var v4 any = nil -_ = v4 -var v6 any -func() { -var v7 any = v4 -_ = v7 -v9 := lang.Apply(nil, []any{v7}) -_ = v9 -var v10 any +v98 := v97.Get() +v99 := lang.Apply(v95, []any{v98, v38}) +v100 := lang.Apply(v91, []any{v92, v99}) +v101 := lang.Apply(v88, []any{v100}) +_ = v101 +var v102 any func() { defer func() { -v11 := lang.Apply(nil, []any{v7}) -}() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("apply")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("require")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v104 := v103.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) +if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) } -v17 := v16.Get() -v18 := lang.Apply(v14, []any{v17, v3}) -v10 = v18 +v105 := v104.Get() +v106 := lang.Apply(v105, nil) }() -v6 = v10 +v107 := lang.Apply(strings22.TrimPrefix, []any{v38, "/"}) +v108, _ := lang.FieldOrMethod(runtime9.RT, "Load") +if reflect.TypeOf(v108).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Load is not a function"))) +} +v109 := lang.Apply(v108, []any{v107}) +v102 = v109 }() -return v6 +v73 = v102 +} +_ = v73 +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("next")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +} +v41 := v40.Get() +v42 := lang.Apply(v41, []any{v25}) +var v38 any = v42 +var v43 any = nil +var v44 any = int64(0) +var v45 any = int64(0) +v4 = v38 +v9 = v43 +v10 = v44 +v11 = v45 +continue +} +v24 = v27 +} else { +v24 = nil +} +v13 = v24 +} +v12 = v13 + break +} +return v12 } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -46135,146 +45782,134 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// ns-publics +// load-all { -v0 := lang.NewSymbol("ns-publics").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of the public intern mappings for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4188), lang.NewKeyword("end-line"), int(4188))).(*lang.Symbol) +v0 := lang.NewSymbol("load-all").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"), lang.NewSymbol("need-ns"), lang.NewSymbol("require"))), lang.NewKeyword("doc"), "Loads a lib given its name and forces a load of any libs it directly or\n indirectly loads. If need-ns, ensures that the associated namespace\n exists after loading. If require, records the load so any duplicate loads\n can be skipped.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5935), lang.NewKeyword("end-line"), int(5935), lang.NewKeyword("private"), true)).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { + if len(args) != 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("the-ns")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v4 := args[1] +v5 := args[2] +var v6 lang.FnFunc +v6 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("commute")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v4}) -var v4 any = v8 -_ = v4 +v9 := v8.Get() v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("filter-key")) +v11 := v10.FindInternedVar(lang.NewSymbol("*loaded-libs*")) if v11.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("val")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -var v16 lang.FnFunc -v16 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { +var v13 lang.FnFunc +v13 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v17 := args[0] +v14 := args[0] +v15 := args[1] +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("reduce1")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("instance?")) +v20 := v19.FindInternedVar(lang.NewSymbol("conj")) if v20.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } v21 := v20.Get() -v22 := lang.Apply(v21, []any{lang1.*Var, v17}) -var v18 any = v22 -_ = v18 -var v24 any -if lang.IsTruthy(v18) { -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("=")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +v22 := lang.Apply(v18, []any{v21, v14, v15}) +return v22 +}) +v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5942), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(5942), lang.NewKeyword("end-column"), int(47)) +v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v28 := v27.Get() -v29, ok := lang.FieldOrMethod(v17, "Namespace") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v17, "Namespace"))) +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("push-thread-bindings")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -var v30 any -switch reflect.TypeOf(v29).Kind() { -case reflect.Func: - v30 = lang.Apply(v29, nil) -default: - v30 = v29 +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("hash-map")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v31 := lang.Apply(v28, []any{v4, v30}) -var v25 any = v31 -_ = v25 -var v33 any -if lang.IsTruthy(v25) { -v34, ok := lang.FieldOrMethod(v17, "IsPublic") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v17, "IsPublic"))) +v22 := v21.Get() +v23 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*loaded-libs*")) +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("ref")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -var v35 any -switch reflect.TypeOf(v34).Kind() { -case reflect.Func: - v35 = lang.Apply(v34, nil) -default: - v35 = v34 +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("sorted-set")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v33 = v35 -} else { -v33 = v25 +v29 := v28.Get() +v30 := lang.Apply(v29, nil) +v31 := lang.Apply(v26, []any{v30}) +v32 := lang.Apply(v22, []any{v23, v31}) +v33 := lang.Apply(v19, []any{v32}) +_ = v33 +var v34 any +func() { +defer func() { +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) } -v24 = v33 -} else { -v24 = v18 +v37 := v36.Get() +v38 := lang.Apply(v37, nil) +}() +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("load-one")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) } -return v24 -}) -v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4194), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(4196), lang.NewKeyword("end-column"), int(48)) -v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) -if err != nil { - panic(err) +v41 := v40.Get() +v42 := lang.Apply(v41, []any{v3, v4, v5}) +_ = v42 +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("deref")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) } -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("ns-map")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v45 := v44.Get() +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("*loaded-libs*")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) } -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v4}) -v23 := lang.Apply(v12, []any{v15, v18, v22}) -return v23 +v48 := v47.Get() +v49 := lang.Apply(v45, []any{v48}) +v34 = v49 +}() +v16 := lang.Apply(v9, []any{v12, v15, v34}) +return v16 }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// alias -{ -v0 := lang.NewSymbol("alias").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("alias"), lang.NewSymbol("namespace-sym"))), lang.NewKeyword("doc"), "Add an alias in the current namespace to another\n namespace. Arguments are two symbols: the alias to be used, and\n the symbolic name of the target namespace. Use :as in the ns macro in preference\n to calling this directly.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4263), lang.NewKeyword("end-line"), int(4263))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("*ns*")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("the-ns")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v4}) -v12, _ := lang.FieldOrMethod(v7, "AddAlias") -if reflect.TypeOf(v12).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("AddAlias is not a function"))) +v7, _ := lang.FieldOrMethod(lang1.LockingTransaction, "RunInTransaction") +if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("RunInTransaction is not a function"))) } -v13 := lang.Apply(v12, []any{v3, v11}) -return v13 +v8 := lang.Apply(v7, []any{v6}) +return v8 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -46282,2109 +45917,2110 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// set-agent-send-executor! +// load-data-reader-file { -v0 := lang.NewSymbol("set-agent-send-executor!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("executor"))), lang.NewKeyword("doc"), "Sets the ExecutorService to be used by send", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(30), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2087), lang.NewKeyword("end-line"), int(2087))).(*lang.Symbol) +v0 := lang.NewSymbol("load-data-reader-file").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7879), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7879), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("mappings"), lang.NewSymbol("url"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { + if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -return nil -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// get -{ -var v1 lang.FnFunc -{ // function get__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] v4 := args[1] -v5 := lang.NewList(args[2:]...) -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("seq")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("concat")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("list")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{lang.NewSymbol(".")}) -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("list")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("list")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +v6, ok := lang.FieldOrMethod(v4, "openStream") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "openStream"))) } -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("seq")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +var v7 any +switch reflect.TypeOf(v6).Kind() { +case reflect.Func: + v7 = lang.Apply(v6, nil) +default: + v7 = v6 } -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("concat")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +v8 := lang.Apply(java.io.InputStreamReader24., []any{v7, "UTF-8"}) +v9 := lang.Apply(glojure.lang.LineNumberingPushbackReader23., []any{v8}) +var v5 any = v9 +_ = v5 +var v11 any +func() { +defer func() { +v12, ok := lang.FieldOrMethod(v5, "close") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "close"))) } -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("list")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +var v13 any +switch reflect.TypeOf(v12).Kind() { +case reflect.Func: + v13 = lang.Apply(v12, nil) +default: + v13 = v12 } -v31 := v30.Get() -v32 := lang.Apply(v31, []any{lang.NewSymbol("glojure.core/Get")}) -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("list")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +}() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("push-thread-bindings")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v3}) -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("list")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +v17 := v16.Get() +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("hash-map")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v4}) -v41 := lang.Apply(v28, []any{v32, v36, v40, v5}) -v42 := lang.Apply(v25, []any{v41}) -v43 := lang.Apply(v22, []any{v42}) -v44 := lang.Apply(v11, []any{v15, v19, v43}) -v45 := lang.Apply(v8, []any{v44}) -return v45 - } -}) -v2 := v1 -_ = v2 +v20 := v19.Get() +v21 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*file*")) +v22, ok := lang.FieldOrMethod(v4, "getFile") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "getFile"))) } -v0 := lang.NewSymbol("get").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"), lang.NewSymbol("not-found"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the value mapped to key, not-found or nil if key not present\n in associative collection, set, string, array, or ILookup instance.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)int64(3)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1489), lang.NewKeyword("end-line"), int(1489))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v4 := args[0] -v5 := args[1] -v6 := lang.Apply(lang1.Get, []any{v4, v5}) -return v6 - case 3: -v4 := args[0] -v5 := args[1] -v6 := args[2] -v7 := lang.Apply(lang1.GetDefault, []any{v4, v5, v6}) -return v7 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +var v23 any +switch reflect.TypeOf(v22).Kind() { +case reflect.Func: + v23 = lang.Apply(v22, nil) +default: + v23 = v22 } +v24 := lang.Apply(v20, []any{v21, v23}) +v25 := lang.Apply(v17, []any{v24}) +_ = v25 +var v26 any +func() { +defer func() { +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -// mk-bound-fn -{ -v0 := lang.NewSymbol("mk-bound-fn").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5127), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(5127), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sc"), lang.NewSymbol("test"), lang.NewSymbol("key"))), lang.NewKeyword("private"), true, lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -var v6 lang.FnFunc -v6 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v7 := args[0] -v8, ok := lang.FieldOrMethod(v3, "comparator") +v29 := v28.Get() +v30 := lang.Apply(v29, nil) +}() +var v32 any +v33, ok := lang.FieldOrMethod(v4, "getPath") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "comparator"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "getPath"))) } -var v9 any -switch reflect.TypeOf(v8).Kind() { +var v34 any +switch reflect.TypeOf(v33).Kind() { case reflect.Func: - v9 = lang.Apply(v8, nil) + v34 = lang.Apply(v33, nil) default: - v9 = v8 + v34 = v33 } -v10, _ := lang.FieldOrMethod(v3, "entryKey") -if reflect.TypeOf(v10).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("entryKey is not a function"))) +v35, _ := lang.FieldOrMethod(v34, "endsWith") +if reflect.TypeOf(v35).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("endsWith is not a function"))) } -v11 := lang.Apply(v10, []any{v7}) -v12, _ := lang.FieldOrMethod(v9, "compare") -if reflect.TypeOf(v12).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("compare is not a function"))) +v36 := lang.Apply(v35, []any{"cljc"}) +if lang.IsTruthy(v36) { +v37 := lang.NewMap(lang.NewKeyword("eof"), nil, lang.NewKeyword("read-cond"), lang.NewKeyword("allow")) +v38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7885), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7885), lang.NewKeyword("end-column"), int(52)) +v39, err := lang.WithMeta(v37, v38.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v13 := lang.Apply(v12, []any{v11, v5}) -v14 := lang.Apply(v4, []any{v13, int64(0)}) -return v14 -}) -v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5130), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(5131), lang.NewKeyword("end-column"), int(64)) -v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) +v32 = v39 +} else { +v40 := lang.NewMap(lang.NewKeyword("eof"), nil) +v41 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7886), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7886), lang.NewKeyword("end-column"), int(34)) +v42, err := lang.WithMeta(v40, v41.(lang.IPersistentMap)) if err != nil { panic(err) } -return v8 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v32 = v42 } +var v31 any = v32 +_ = v31 +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("read")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } -// second -{ -v0 := lang.NewSymbol("second").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Same as (first (next x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(91), lang.NewKeyword("end-line"), int(95))).(*lang.Symbol) -var v2 lang.FnFunc -{ // function second -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("first")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v31, v5}) +var v43 any = v47 +_ = v43 +var v49 any +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("not")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) } -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("next")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v52 := v51.Get() +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("map?")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) } -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v4}) -v12 := lang.Apply(v7, []any{v11}) -return v12 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(95), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(95), lang.NewKeyword("end-column"), int(49))).(lang.FnFunc) -v3 := v2 -_ = v3 +v55 := v54.Get() +v56 := lang.Apply(v55, []any{v43}) +v57 := lang.Apply(v52, []any{v56}) +if lang.IsTruthy(v57) { +v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v59 := v58.FindInternedVar(lang.NewSymbol("ex-info")) +if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) } -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v60 := v59.Get() +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("str")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +} +v63 := v62.Get() +v64 := lang.Apply(v63, []any{"Not a valid data-reader map"}) +v65 := lang.NewMap(lang.NewKeyword("url"), v4) +v66 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7890), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(7890), lang.NewKeyword("end-column"), int(36)) +v67, err := lang.WithMeta(v65, v66.(lang.IPersistentMap)) +if err != nil { + panic(err) } +v68 := lang.Apply(v60, []any{v64, v67}) +panic(v68) +} else { +v49 = nil } -// delay? -{ -v0 := lang.NewSymbol("delay?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "returns true if x is a Delay created with delay", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(748), lang.NewKeyword("end-line"), int(748))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { +_ = v49 +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("reduce")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +} +v71 := v70.Get() +var v72 lang.FnFunc +v72 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{glojure.lang11.Delay, v3}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v73 := args[0] +v74 := args[1] +var v75 any = v74 +_ = v75 +v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v78 := v77.FindInternedVar(lang.NewSymbol("nth")) +if v78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) } +v79 := v78.Get() +v80 := lang.Apply(v79, []any{v75, int64(0), nil}) +var v76 any = v80 +_ = v76 +v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v83 := v82.FindInternedVar(lang.NewSymbol("nth")) +if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) } -// *2 -{ -v0 := lang.NewSymbol("*2").WithMeta(lang.NewMap()).(*lang.Symbol) -v1 := ns.Intern(v0) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v84 := v83.Get() +v85 := lang.Apply(v84, []any{v75, int64(1), nil}) +var v81 any = v85 +_ = v81 +var v87 any +v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v89 := v88.FindInternedVar(lang.NewSymbol("not")) +if v89.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) } +v90 := v89.Get() +v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v92 := v91.FindInternedVar(lang.NewSymbol("symbol?")) +if v92.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) } -// *warn-on-reflection* -{ -v0 := lang.NewSymbol("*warn-on-reflection*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "When set to true, the compiler will emit warnings when reflection is\n needed to resolve Java method calls or field accesses.\n\n Defaults to false.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, nil, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v93 := v92.Get() +v94 := lang.Apply(v93, []any{v76}) +v95 := lang.Apply(v90, []any{v94}) +if lang.IsTruthy(v95) { +v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v97 := v96.FindInternedVar(lang.NewSymbol("ex-info")) +if v97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) } +v98 := v97.Get() +v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v100 := v99.FindInternedVar(lang.NewSymbol("str")) +if v100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) } -// boolean-array -{ -var v1 lang.FnFunc -{ // function boolean-array__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewList(args[0:]...) -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v101 := v100.Get() +v102 := lang.Apply(v101, []any{"Invalid form in data-reader file"}) +v103 := lang.NewMap(lang.NewKeyword("url"), v4, lang.NewKeyword("form"), v76) +v104 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7895), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(7896), lang.NewKeyword("end-column"), int(38)) +v105, err := lang.WithMeta(v103, v104.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v106 := lang.Apply(v98, []any{v102, v105}) +panic(v106) +} else { +v87 = nil } -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +_ = v87 +v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v109 := v108.FindInternedVar(lang.NewSymbol("data-reader-var")) +if v109.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) } -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v110 := v109.Get() +v111 := lang.Apply(v110, []any{v81}) +var v107 any = v111 +_ = v107 +var v113 any +v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v116 := v115.FindInternedVar(lang.NewSymbol("contains?")) +if v116.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v117 := v116.Get() +v118 := lang.Apply(v117, []any{v3, v76}) +var v114 any = v118 +_ = v114 +var v120 any +if lang.IsTruthy(v114) { +v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v122 := v121.FindInternedVar(lang.NewSymbol("not=")) +if v122.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) } -v20 := v19.Get() -v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/booleanArray")}) -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("list")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v123 := v122.Get() +v124 := lang.Apply(v3, []any{v76}) +v125 := lang.Apply(v123, []any{v124, v107}) +v120 = v125 +} else { +v120 = v114 } -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("seq")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +if lang.IsTruthy(v120) { +v114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v115 := v114.FindInternedVar(lang.NewSymbol("ex-info")) +if v115.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v115))) } -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("concat")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +v116 := v115.Get() +v117 := lang.NewMap(lang.NewKeyword("url"), v4, lang.NewKeyword("conflict"), v76, lang.NewKeyword("mappings"), v73) +v118 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7901), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(7903), lang.NewKeyword("end-column"), int(44)) +v119, err := lang.WithMeta(v117, v118.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v120 := lang.Apply(v116, []any{"Conflicting data-reader mapping", v119}) +panic(v120) +} else { +v113 = nil } -v33 := v32.Get() -v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("list")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +_ = v113 +v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v122 := v121.FindInternedVar(lang.NewSymbol("assoc")) +if v122.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) } -v37 := v36.Get() -v38 := lang.Apply(v37, []any{lang.NewSymbol("glojure.core/args")}) -v39 := lang.Apply(v30, []any{v34, v38}) -v40 := lang.Apply(v27, []any{v39}) -v41 := lang.Apply(v24, []any{v40}) -v42 := lang.Apply(v9, []any{v13, v17, v21, v41}) -v43 := lang.Apply(v6, []any{v42}) -return v43 - } +v123 := v122.Get() +v124 := lang.Apply(v123, []any{v73, v76, v107}) +return v124 }) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("boolean-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Creates an array of booleans", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)int64(2)), lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5309), lang.NewKeyword("end-line"), int(5309))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "booleanArray") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("booleanArray is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 - case 2: -v4 := args[0] -v5 := args[1] -v6, _ := lang.FieldOrMethod(lang1.Numbers, "booleanArrayInit") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("booleanArrayInit is not a function"))) +v73 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7892), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(7904), lang.NewKeyword("end-column"), int(32)) +v74, err := lang.WithMeta(v72, v73.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } +v75 := lang.Apply(v71, []any{v74, v3, v43}) +v26 = v75 +}() +v11 = v26 +}() +return v11 }) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// list -{ -v0 := lang.NewSymbol("list").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("items"))), lang.NewKeyword("doc"), "Creates a new list containing the items.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(15), lang.NewKeyword("end-line"), int(18))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, nil, true) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// -' +// load-data-readers { -var v1 lang.FnFunc -v1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v2 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -if lang.IsTruthy(v7) { -v4 = closed8 -} else { -v4 = v3 +v0 := lang.NewSymbol("load-data-readers").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7908), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7908), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v4 := v3.FindInternedVar(lang.NewSymbol("alter-var-root")) +if v4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) } -var v3 any = v4 -_ = v3 +v5 := v4.Get() +v6 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*data-readers*")) +var v7 lang.FnFunc +v7 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v8 := args[0] v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("seq")) +v10 := v9.FindInternedVar(lang.NewSymbol("reduce")) if v10.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } v11 := v10.Get() v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("concat")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("seq")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("concat")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v2}) -v40 := lang.Apply(v31, []any{v35, v39}) -v41 := lang.Apply(v28, []any{v40}) -v42 := lang.Apply(v25, []any{v41}) -v43 := lang.Apply(v14, []any{v18, v22, v42}) -v44 := lang.Apply(v11, []any{v43}) -return v44 - case 2: -v2 := args[0] -v3 := args[1] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -if lang.IsTruthy(v8) { -v5 = closed8 -} else { -v5 = v4 -} -var v4 any = v5 -_ = v4 -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("seq")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("concat")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("list")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("list")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +v13 := v12.FindInternedVar(lang.NewSymbol("load-data-reader-file")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } -v22 := v21.Get() -v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("list")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("data-reader-urls")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("seq")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v17 := v16.Get() +v18 := lang.Apply(v17, nil) +v19 := lang.Apply(v11, []any{v14, v8, v18}) +return v19 +}) +v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7910), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(7912), lang.NewKeyword("end-column"), int(57)) +v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v29 := v28.Get() -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("concat")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +v10 := lang.Apply(v5, []any{v6, v9}) +return v10 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("list")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) } -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v4}) -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("list")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +// load-file +{ +v0 := lang.NewSymbol("load-file").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, nil, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v2}) -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("list")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v3}) -v45 := lang.Apply(v32, []any{v36, v40, v44}) -v46 := lang.Apply(v29, []any{v45}) -v47 := lang.Apply(v26, []any{v46}) -v48 := lang.Apply(v15, []any{v19, v23, v47}) -v49 := lang.Apply(v12, []any{v48}) -return v49 +// load-lib +{ +v0 := lang.NewSymbol("load-lib").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("prefix"), lang.NewSymbol("lib"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Loads a lib with options", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5947), lang.NewKeyword("end-line"), int(5947), lang.NewKeyword("private"), true)).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { default: if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v2 := args[0] -v3 := args[1] -v4 := lang.NewList(args[2:]...) -var v6 any -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("throw-if")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v9 := v8.Get() +v8 := v7.Get() +var v9 any = v3 +_ = v9 +var v11 any if lang.IsTruthy(v9) { -v6 = closed8 -} else { -v6 = v5 +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("pos?")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } -var v5 any = v6 -_ = v5 -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("name")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } -v13 := v12.Get() -var v14 lang.FnFunc -v14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v15 := args[0] -v16 := args[1] -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v4}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("int")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("concat")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +v21 := v20.Get() +v22 := lang.Apply(v21, []any{lang.NewChar(46)}) +v23 := lang.Apply(strings22.Index, []any{v18, v22}) +v24 := lang.Apply(v14, []any{v23}) +v11 = v24 +} else { +v11 = v9 } -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("name")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v4}) +v13 := lang.Apply(v8, []any{v11, "Found lib name '%s' containing period with prefix '%s'. lib names inside prefix lists must not contain periods", v12, v3}) +_ = v13 +var v15 any +if lang.IsTruthy(v3) { +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("symbol")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v18 := v17.Get() +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("str")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v3, lang.NewChar(46), v14}) +v23 := lang.Apply(v18, []any{v22}) +v15 = v23 +} else { +v15 = v14 } -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +var v14 any = v15 +_ = v14 +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("apply")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -v39 := v38.Get() +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("hash-map")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v27, []any{v30, v5}) +var v24 any = v31 +_ = v24 +var v32 any = v24 +_ = v32 +var v34 any +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("seq?")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v37, []any{v33}) +if lang.IsTruthy(v38) { +var v39 any v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) +v41 := v40.FindInternedVar(lang.NewSymbol("next")) if v41.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) } v42 := v41.Get() -v43 := lang.Apply(v42, []any{v5}) +v43 := lang.Apply(v42, []any{v33}) +if lang.IsTruthy(v43) { v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) +v45 := v44.FindInternedVar(lang.NewSymbol("to-array")) if v45.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } v46 := v45.Get() -v47 := lang.Apply(v46, []any{v15}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +v47 := lang.Apply(v46, []any{v33}) +v48 := lang.Apply(lang1.NewPersistentArrayMapAsIfByAssoc, []any{v47}) +v39 = v48 +} else { +var v49 any +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("seq")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) } -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v16}) -v52 := lang.Apply(v39, []any{v43, v47, v51}) -v53 := lang.Apply(v36, []any{v52}) -v54 := lang.Apply(v33, []any{v53}) -v55 := lang.Apply(v22, []any{v26, v30, v54}) -v56 := lang.Apply(v19, []any{v55}) -return v56 -}) -v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) -v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) -if err != nil { - panic(err) +v52 := v51.Get() +v53 := lang.Apply(v52, []any{v33}) +if lang.IsTruthy(v53) { +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("first")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) } -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +v56 := v55.Get() +v57 := lang.Apply(v56, []any{v33}) +v49 = v57 +} else { +v49 = nil } -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("concat")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +v39 = v49 } -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +v34 = v39 +} else { +v34 = v33 } -v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +var v33 any = v34 +_ = v33 +v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v60 := v59.FindInternedVar(lang.NewSymbol("get")) +if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) } -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v61 := v60.Get() +v62 := lang.Apply(v61, []any{v33, lang.NewKeyword("as")}) +var v58 any = v62 +_ = v58 +v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v65 := v64.FindInternedVar(lang.NewSymbol("get")) +if v65.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) } -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +v66 := v65.Get() +v67 := lang.Apply(v66, []any{v33, lang.NewKeyword("reload")}) +var v63 any = v67 +_ = v63 +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("get")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) } -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +v71 := v70.Get() +v72 := lang.Apply(v71, []any{v33, lang.NewKeyword("reload-all")}) +var v68 any = v72 +_ = v68 +v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v75 := v74.FindInternedVar(lang.NewSymbol("get")) +if v75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) } -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +v76 := v75.Get() +v77 := lang.Apply(v76, []any{v33, lang.NewKeyword("require")}) +var v73 any = v77 +_ = v73 +v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v80 := v79.FindInternedVar(lang.NewSymbol("get")) +if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) } -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v5}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +v81 := v80.Get() +v82 := lang.Apply(v81, []any{v33, lang.NewKeyword("use")}) +var v78 any = v82 +_ = v78 +v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v85 := v84.FindInternedVar(lang.NewSymbol("get")) +if v85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) } -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v2}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +v86 := v85.Get() +v87 := lang.Apply(v86, []any{v33, lang.NewKeyword("verbose")}) +var v83 any = v87 +_ = v83 +v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v90 := v89.FindInternedVar(lang.NewSymbol("get")) +if v90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) } -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v3}) -v52 := lang.Apply(v39, []any{v43, v47, v51}) -v53 := lang.Apply(v36, []any{v52}) -v54 := lang.Apply(v33, []any{v53}) -v55 := lang.Apply(v22, []any{v26, v30, v54}) -v56 := lang.Apply(v19, []any{v55}) -v57 := lang.Apply(v13, []any{v16, v56, v4}) -return v57 - } -}) -v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) +v91 := v90.Get() +v92 := lang.Apply(v91, []any{v33, lang.NewKeyword("as-alias")}) +var v88 any = v92 +_ = v88 +v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v95 := v94.FindInternedVar(lang.NewSymbol("contains?")) +if v95.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) } -v5 := lang.Apply(v4, []any{v3, int64(0)}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v0 := lang.NewSymbol("-'").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "If no ys are supplied, returns the negation of x, else subtracts\n the ys from x and returns the result. Supports arbitrary precision.\n See also: -", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1024), lang.NewKeyword("end-line"), int(1024))).(*lang.Symbol) -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v5 := args[0] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("*'")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +v96 := v95.Get() +v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v98 := v97.FindInternedVar(lang.NewSymbol("deref")) +if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) } -v8 := v7.Get() -v9 := lang.Apply(v8, []any{int64(-1), v5}) -return v9 - case 2: -v5 := args[0] -v6 := args[1] -v7, _ := lang.FieldOrMethod(lang1.Numbers, "minusP") -if reflect.TypeOf(v7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("minusP is not a function"))) +v99 := v98.Get() +v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v101 := v100.FindInternedVar(lang.NewSymbol("*loaded-libs*")) +if v101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) } -v8 := lang.Apply(v7, []any{v5, v6}) -return v8 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := args[0] -v6 := args[1] -v7 := lang.NewList(args[2:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v102 := v101.Get() +v103 := lang.Apply(v99, []any{v102}) +v104 := lang.Apply(v96, []any{v103, v14}) +var v93 any = v104 +_ = v93 +var v106 any = v58 +_ = v106 +var v108 any +if lang.IsTruthy(v106) { +v108 = v106 +} else { +v108 = v78 } -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("-'")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +var v105 any = v108 +_ = v105 +var v107 any +if lang.IsTruthy(v68) { +v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v109 := v108.FindInternedVar(lang.NewSymbol("load-all")) +if v109.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) } -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("-'")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v110 := v109.Get() +v107 = v110 +} else { +var v111 any +if lang.IsTruthy(v63) { +v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v113 := v112.FindInternedVar(lang.NewSymbol("load-one")) +if v113.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) +} +v114 := v113.Get() +v111 = v114 +} else { +var v115 any +v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v117 := v116.FindInternedVar(lang.NewSymbol("not")) +if v117.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) +} +v118 := v117.Get() +v119 := lang.Apply(v118, []any{v93}) +if lang.IsTruthy(v119) { +var v120 any +if lang.IsTruthy(v105) { +v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v122 := v121.FindInternedVar(lang.NewSymbol("load-one")) +if v122.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v5, v6}) -v18 := lang.Apply(v10, []any{v13, v17, v7}) -return v18 +v123 := v122.Get() +v120 = v123 +} else { +var v124 any +if lang.IsTruthy(v88) { +var v125 lang.FnFunc +v125 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } +v126 := args[0] +v127 := args[1] +v128 := args[2] +v129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v130 := v129.FindInternedVar(lang.NewSymbol("create-ns")) +if v130.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v130))) +} +v131 := v130.Get() +v132 := lang.Apply(v131, []any{v126}) +return v132 }) -v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v3 := ns.InternWithValue(v0, v4, true) -if v0.Meta() != nil { - v3.SetMeta(v0.Meta().(lang.IPersistentMap)) +v126 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5961), lang.NewKeyword("column"), int(48), lang.NewKeyword("end-line"), int(5961), lang.NewKeyword("end-column"), int(88)) +v127, err := lang.WithMeta(v125, v126.(lang.IPersistentMap)) +if err != nil { + panic(err) } +v124 = v127 +} else { +var v128 any +if lang.IsTruthy(lang.NewKeyword("else")) { +v129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v130 := v129.FindInternedVar(lang.NewSymbol("load-one")) +if v130.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v130))) } -// replace -{ -v0 := lang.NewSymbol("replace").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("smap")), lang.NewVector(lang.NewSymbol("smap"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Given a map of replacement pairs and a vector/collection, returns a\n vector/seq with any elements = a key in smap replaced with the\n corresponding val in smap. Returns a transducer when no collection\n is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5082), lang.NewKeyword("end-line"), int(5082))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("map")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v131 := v130.Get() +v128 = v131 +} else { +v128 = nil } -v6 := v5.Get() -var v7 lang.FnFunc -v7 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v8 := args[0] -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("find")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v124 = v128 } -v12 := v11.Get() -v13 := lang.Apply(v12, []any{v3, v8}) -var v9 any = v13 -_ = v9 -var v15 any -if lang.IsTruthy(v9) { -var v16 any = v9 -_ = v16 -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("val")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v120 = v124 } -v20 := v19.Get() -v21 := lang.Apply(v20, []any{v16}) -v15 = v21 +v115 = v120 } else { -v15 = v8 +v115 = nil } -return v15 -}) -v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5090), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5090), lang.NewKeyword("end-column"), int(47)) -v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) -if err != nil { - panic(err) +v111 = v115 } -v10 := lang.Apply(v6, []any{v9}) -return v10 - case 2: -v3 := args[0] -v4 := args[1] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("vector?")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +v107 = v111 } -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v4}) -if lang.IsTruthy(v9) { -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("reduce1")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +var v106 any = v107 +_ = v106 +v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v134 := v133.FindInternedVar(lang.NewSymbol("select-keys")) +if v134.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) } -v12 := v11.Get() -var v13 lang.FnFunc -v13 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v14 := args[0] -v15 := args[1] -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("find")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +v135 := v134.Get() +v136 := lang.Apply(v135, []any{v24, lang.NewList(lang.NewKeyword("exclude"), lang.NewKeyword("only"), lang.NewKeyword("rename"), lang.NewKeyword("refer"))}) +var v132 any = v136 +_ = v132 +v138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v139 := v138.FindInternedVar(lang.NewSymbol("not")) +if v139.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v139))) } -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("nth")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +v140 := v139.Get() +v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v142 := v141.FindInternedVar(lang.NewSymbol("find-ns")) +if v142.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) } -v22 := v21.Get() -v23 := lang.Apply(v22, []any{v14, v15}) -v24 := lang.Apply(v19, []any{v3, v23}) -var v16 any = v24 -_ = v16 -var v26 any -if lang.IsTruthy(v16) { -var v27 any = v16 -_ = v27 -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("assoc")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +v143 := v142.Get() +v144 := lang.Apply(v143, []any{v14}) +v145 := lang.Apply(v140, []any{v144}) +var v137 any = v145 +_ = v137 +v148 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v149 := v148.FindInternedVar(lang.NewSymbol("push-thread-bindings")) +if v149.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v149))) } -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("val")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +v150 := v149.Get() +v151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v152 := v151.FindInternedVar(lang.NewSymbol("hash-map")) +if v152.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v152))) } -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v27}) -v36 := lang.Apply(v31, []any{v14, v15, v35}) -v26 = v36 +v153 := v152.Get() +v154 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*loading-verbosely*")) +v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v157 := v156.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) +if v157.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) +} +v158 := v157.Get() +var v155 any = v158 +_ = v155 +var v160 any +if lang.IsTruthy(v155) { +v160 = v155 } else { -v26 = v14 +v160 = v83 } -return v26 -}) -v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5093), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(5096), lang.NewKeyword("end-column"), int(23)) -v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) -if err != nil { - panic(err) +v155 := lang.Apply(v153, []any{v154, v160}) +v156 := lang.Apply(v150, []any{v155}) +_ = v156 +var v157 any +func() { +defer func() { +v158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v159 := v158.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) +if v159.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v159))) } -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("range")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +v160 := v159.Get() +v161 := lang.Apply(v160, nil) +}() +var v162 any +if lang.IsTruthy(v106) { +var v163 any +func() { +defer func() { +if r := recover(); r != nil { +if lang.CatchMatches(r, lang.Builtins["any"]) { +v164 := r +_ = v164 +var v165 any +if lang.IsTruthy(v137) { +v166 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v167 := v166.FindInternedVar(lang.NewSymbol("remove-ns")) +if v167.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v167))) } -v18 := v17.Get() -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("count")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v168 := v167.Get() +v169 := lang.Apply(v168, []any{v14}) +v165 = v169 +} else { +v165 = nil } -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v4}) -v23 := lang.Apply(v18, []any{v22}) -v24 := lang.Apply(v12, []any{v15, v4, v23}) -v5 = v24 +_ = v165 +panic(v164) } else { -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("map")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +panic(r) } -v27 := v26.Get() -var v28 lang.FnFunc -v28 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v29 := args[0] -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("find")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v3, v29}) -var v30 any = v34 -_ = v30 -var v36 any -if lang.IsTruthy(v30) { -var v37 any = v30 -_ = v37 -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("val")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +}() +v164 := lang.Apply(v106, []any{v14, v105, v73}) +v163 = v164 +}() +v162 = v163 +} else { +v165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v166 := v165.FindInternedVar(lang.NewSymbol("throw-if")) +if v166.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v166))) } -v41 := v40.Get() -v42 := lang.Apply(v41, []any{v37}) -v36 = v42 +v167 := v166.Get() +var v168 any = v105 +_ = v168 +var v170 any +if lang.IsTruthy(v168) { +v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v172 := v171.FindInternedVar(lang.NewSymbol("not")) +if v172.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) +} +v173 := v172.Get() +v174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v175 := v174.FindInternedVar(lang.NewSymbol("find-ns")) +if v175.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v175))) +} +v176 := v175.Get() +v177 := lang.Apply(v176, []any{v14}) +v178 := lang.Apply(v173, []any{v177}) +v170 = v178 } else { -v36 = v29 +v170 = v168 } -return v36 -}) -v29 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5098), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(5098), lang.NewKeyword("end-column"), int(49)) -v30, err := lang.WithMeta(v28, v29.(lang.IPersistentMap)) -if err != nil { - panic(err) +v168 := lang.Apply(v167, []any{v170, "namespace '%s' not found", v14}) +v162 = v168 } -v31 := lang.Apply(v27, []any{v30, v4}) -v5 = v31 +_ = v162 +var v169 any +var v170 any = v105 +_ = v170 +var v172 any +if lang.IsTruthy(v170) { +v173 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v174 := v173.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) +if v174.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v174))) } -return v5 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v175 := v174.Get() +v172 = v175 +} else { +v172 = v170 } +if lang.IsTruthy(v172) { +v170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v171 := v170.FindInternedVar(lang.NewSymbol("printf")) +if v171.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v171))) } -// deref-future -{ -v0 := lang.NewSymbol("deref-future").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2296), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(2296), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fut")), lang.NewVector(lang.NewSymbol("fut"), lang.NewSymbol("timeout-ms"), lang.NewSymbol("timeout-val"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -v4, ok := lang.FieldOrMethod(v3, "Get") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "Get"))) +v172 := v171.Get() +v173 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v174 := v173.FindInternedVar(lang.NewSymbol("ns-name")) +if v174.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v174))) } -var v5 any -switch reflect.TypeOf(v4).Kind() { -case reflect.Func: - v5 = lang.Apply(v4, nil) -default: - v5 = v4 +v175 := v174.Get() +v176 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v177 := v176.FindInternedVar(lang.NewSymbol("*ns*")) +if v177.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v177))) } -return v5 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -var v6 any -func() { -defer func() { -if r := recover(); r != nil { -if lang.CatchMatches(r, lang1.TimeoutError) { -v7 := r -_ = v7 -v6 = v5 +v178 := v177.Get() +v179 := lang.Apply(v175, []any{v178}) +v180 := lang.Apply(v172, []any{"(glojure.core/in-ns '%s)\n", v179}) +v169 = v180 } else { -panic(r) +v169 = nil } +_ = v169 +var v181 any +if lang.IsTruthy(v58) { +var v182 any +v183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v184 := v183.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) +if v184.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v184))) } -}() -v7, _ := lang.FieldOrMethod(v3, "Get") -if reflect.TypeOf(v7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Get is not a function"))) +v185 := v184.Get() +if lang.IsTruthy(v185) { +v186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v187 := v186.FindInternedVar(lang.NewSymbol("printf")) +if v187.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v187))) } -v8 := lang.Apply(v7, []any{v4, time27.Millisecond}) -v6 = v8 -}() -return v6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v188 := v187.Get() +v189 := lang.Apply(v188, []any{"(glojure.core/alias '%s '%s)\n", v58, v14}) +v182 = v189 +} else { +v182 = nil } +_ = v182 +v190 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v191 := v190.FindInternedVar(lang.NewSymbol("alias")) +if v191.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v191))) } -// *agent* -{ -v0 := lang.NewSymbol("*agent*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, nil, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v192 := v191.Get() +v193 := lang.Apply(v192, []any{v58, v14}) +v181 = v193 +} else { +v181 = nil } +_ = v181 +var v194 any +if lang.IsTruthy(v88) { +var v195 any +v196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v197 := v196.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) +if v197.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v197))) } -// object-array -{ -var v1 lang.FnFunc -{ // function object-array__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v198 := v197.Get() +if lang.IsTruthy(v198) { +v199 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v200 := v199.FindInternedVar(lang.NewSymbol("printf")) +if v200.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v200))) } -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v201 := v200.Get() +v202 := lang.Apply(v201, []any{"(glojure.core/alias '%s '%s)\n", v88, v14}) +v195 = v202 +} else { +v195 = nil +} +_ = v195 +v203 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v204 := v203.FindInternedVar(lang.NewSymbol("alias")) +if v204.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v204))) +} +v205 := v204.Get() +v206 := lang.Apply(v205, []any{v88, v14}) +v194 = v206 +} else { +v194 = nil +} +_ = v194 +var v207 any +var v208 any = v78 +_ = v208 +var v210 any +if lang.IsTruthy(v208) { +v210 = v208 +} else { +v211 := lang.Apply(lang.NewKeyword("refer"), []any{v132}) +v210 = v211 } -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +if lang.IsTruthy(v210) { +var v208 any +v209 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v210 := v209.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) +if v210.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v210))) } -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v211 := v210.Get() +if lang.IsTruthy(v211) { +v212 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v213 := v212.FindInternedVar(lang.NewSymbol("printf")) +if v213.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v213))) } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v214 := v213.Get() +v215 := lang.Apply(v214, []any{"(glojure.core/refer '%s", v14}) +_ = v215 +v217 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v218 := v217.FindInternedVar(lang.NewSymbol("seq")) +if v218.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v218))) } -v20 := v19.Get() -v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/Object_array")}) -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("list")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v219 := v218.Get() +v220 := lang.Apply(v219, []any{v132}) +var v216 any = v220 +_ = v216 +var v221 any = nil +_ = v221 +var v222 any = int64(0) +_ = v222 +var v223 any = int64(0) +_ = v223 +var v224 any +for { +var v225 any +v226 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v227 := v226.FindInternedVar(lang.NewSymbol("<")) +if v227.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v227))) } -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v26 := lang.Apply(v9, []any{v13, v17, v21, v25}) -v27 := lang.Apply(v6, []any{v26}) -return v27 -}) -v2 := v1 -_ = v2 +v228 := v227.Get() +v229 := lang.Apply(v228, []any{v223, v222}) +if lang.IsTruthy(v229) { +v231, _ := lang.FieldOrMethod(v221, "nth") +if reflect.TypeOf(v231).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) } -v0 := lang.NewSymbol("object-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Creates an array of objects", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)), lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5349), lang.NewKeyword("end-line"), int(5349))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5, _ := lang.FieldOrMethod(runtime3.RT, "Object_array") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Object_array is not a function"))) +v232 := lang.Apply(v231, []any{v223}) +var v230 any = v232 +_ = v230 +v234 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v235 := v234.FindInternedVar(lang.NewSymbol("printf")) +if v235.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v235))) } -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +v236 := v235.Get() +v237 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v238 := v237.FindInternedVar(lang.NewSymbol("key")) +if v238.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v238))) } +v239 := v238.Get() +v240 := lang.Apply(v239, []any{v230}) +v241 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v242 := v241.FindInternedVar(lang.NewSymbol("print-str")) +if v242.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v242))) } -// find-var -{ -v0 := lang.NewSymbol("find-var").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Returns the global var named by the namespace-qualified symbol, or\n nil if no var with that name.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2013), lang.NewKeyword("end-line"), int(2013))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, _ := lang.FieldOrMethod(runtime3.RT, "FindVar") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("FindVar is not a function"))) +v243 := v242.Get() +v244 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v245 := v244.FindInternedVar(lang.NewSymbol("val")) +if v245.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v245))) } -v5 := lang.Apply(v4, []any{v3}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v246 := v245.Get() +v247 := lang.Apply(v246, []any{v230}) +v248 := lang.Apply(v243, []any{v247}) +v249 := lang.Apply(v236, []any{" %s '%s", v240, v248}) +_ = v249 +var v250 any = v216 +var v251 any = v221 +var v252 any = v222 +v254 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v255 := v254.FindInternedVar(lang.NewSymbol("unchecked-inc")) +if v255.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v255))) } +v256 := v255.Get() +v257 := lang.Apply(v256, []any{v223}) +var v253 any = v257 +v216 = v250 +v221 = v251 +v222 = v252 +v223 = v253 +continue +} else { +v231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v232 := v231.FindInternedVar(lang.NewSymbol("seq")) +if v232.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v232))) } -// bit-and -{ -var v1 lang.FnFunc -v1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v2 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v233 := v232.Get() +v234 := lang.Apply(v233, []any{v216}) +var v230 any = v234 +_ = v230 +var v236 any +if lang.IsTruthy(v230) { +var v237 any = v230 +_ = v237 +var v239 any +v240 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v241 := v240.FindInternedVar(lang.NewSymbol("chunked-seq?")) +if v241.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v241))) } -v7 := v6.Get() -if lang.IsTruthy(v7) { -v4 = closed9 -} else { -v4 = v3 +v242 := v241.Get() +v243 := lang.Apply(v242, []any{v237}) +if lang.IsTruthy(v243) { +v245 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v246 := v245.FindInternedVar(lang.NewSymbol("chunk-first")) +if v246.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v246))) } -var v3 any = v4 -_ = v3 -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("seq")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +v247 := v246.Get() +v248 := lang.Apply(v247, []any{v237}) +var v244 any = v248 +_ = v244 +v251 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v252 := v251.FindInternedVar(lang.NewSymbol("chunk-rest")) +if v252.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v252))) } -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("concat")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +v253 := v252.Get() +v254 := lang.Apply(v253, []any{v237}) +var v250 any = v254 +var v255 any = v244 +v257 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v258 := v257.FindInternedVar(lang.NewSymbol("int")) +if v258.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v258))) } -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +v259 := v258.Get() +v260 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v261 := v260.FindInternedVar(lang.NewSymbol("count")) +if v261.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v261))) } -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v262 := v261.Get() +v263 := lang.Apply(v262, []any{v244}) +v264 := lang.Apply(v259, []any{v263}) +var v256 any = v264 +v266 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v267 := v266.FindInternedVar(lang.NewSymbol("int")) +if v267.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v267))) } -v21 := v20.Get() -v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +v268 := v267.Get() +v269 := lang.Apply(v268, []any{int64(0)}) +var v265 any = v269 +v216 = v250 +v221 = v255 +v222 = v256 +v223 = v265 +continue +} else { +v245 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v246 := v245.FindInternedVar(lang.NewSymbol("first")) +if v246.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v246))) } -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("seq")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +v247 := v246.Get() +v248 := lang.Apply(v247, []any{v237}) +var v244 any = v248 +_ = v244 +v250 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v251 := v250.FindInternedVar(lang.NewSymbol("printf")) +if v251.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v251))) } -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("concat")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +v252 := v251.Get() +v253 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v254 := v253.FindInternedVar(lang.NewSymbol("key")) +if v254.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v254))) } -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +v255 := v254.Get() +v256 := lang.Apply(v255, []any{v244}) +v257 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v258 := v257.FindInternedVar(lang.NewSymbol("print-str")) +if v258.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v258))) } -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +v259 := v258.Get() +v260 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v261 := v260.FindInternedVar(lang.NewSymbol("val")) +if v261.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v261))) } -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v2}) -v40 := lang.Apply(v31, []any{v35, v39}) -v41 := lang.Apply(v28, []any{v40}) -v42 := lang.Apply(v25, []any{v41}) -v43 := lang.Apply(v14, []any{v18, v22, v42}) -v44 := lang.Apply(v11, []any{v43}) -return v44 - case 2: -v2 := args[0] -v3 := args[1] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +v262 := v261.Get() +v263 := lang.Apply(v262, []any{v244}) +v264 := lang.Apply(v259, []any{v263}) +v265 := lang.Apply(v252, []any{" %s '%s", v256, v264}) +_ = v265 +v267 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v268 := v267.FindInternedVar(lang.NewSymbol("next")) +if v268.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v268))) } -v8 := v7.Get() -if lang.IsTruthy(v8) { -v5 = closed9 +v269 := v268.Get() +v270 := lang.Apply(v269, []any{v237}) +var v266 any = v270 +var v271 any = nil +var v272 any = int64(0) +var v273 any = int64(0) +v216 = v266 +v221 = v271 +v222 = v272 +v223 = v273 +continue +} +v236 = v239 } else { -v5 = v4 +v236 = nil } -var v4 any = v5 -_ = v4 -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("seq")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v225 = v236 } -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("concat")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +v224 = v225 + break } -v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("list")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +_ = v224 +v216 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v217 := v216.FindInternedVar(lang.NewSymbol("printf")) +if v217.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v217))) } -v18 := v17.Get() -v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("list")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +v218 := v217.Get() +v219 := lang.Apply(v218, []any{")\n"}) +v208 = v219 +} else { +v208 = nil } -v22 := v21.Get() -v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("list")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +_ = v208 +v220 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v221 := v220.FindInternedVar(lang.NewSymbol("apply")) +if v221.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v221))) } -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("seq")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v222 := v221.Get() +v223 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v224 := v223.FindInternedVar(lang.NewSymbol("refer")) +if v224.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v224))) } -v29 := v28.Get() -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("concat")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +v225 := v224.Get() +v226 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v227 := v226.FindInternedVar(lang.NewSymbol("mapcat")) +if v227.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v227))) } -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("list")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +v228 := v227.Get() +v229 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v230 := v229.FindInternedVar(lang.NewSymbol("seq")) +if v230.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v230))) } -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v4}) -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("list")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +v231 := v230.Get() +v232 := lang.Apply(v228, []any{v231, v132}) +v233 := lang.Apply(v222, []any{v225, v14, v232}) +v207 = v233 +} else { +v207 = nil } -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v2}) -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("list")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +v157 = v207 +}() +return v157 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v3}) -v45 := lang.Apply(v32, []any{v36, v40, v44}) -v46 := lang.Apply(v29, []any{v45}) -v47 := lang.Apply(v26, []any{v46}) -v48 := lang.Apply(v15, []any{v19, v23, v47}) -v49 := lang.Apply(v12, []any{v48}) -return v49 +} +// load-libs +{ +v0 := lang.NewSymbol("load-libs").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Loads libs, interpreting libspecs, prefix lists, and flags for\n forwarding to load-lib", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5994), lang.NewKeyword("end-line"), int(5994), lang.NewKeyword("private"), true)).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { default: - if len(args) < 2 { + if len(args) < 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v2 := args[0] -v3 := args[1] -v4 := lang.NewList(args[2:]...) -var v6 any -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -if lang.IsTruthy(v9) { -v6 = closed9 -} else { -v6 = v5 -} -var v5 any = v6 -_ = v5 -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v3 := lang.NewList(args[0:]...) +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("filter")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v13 := v12.Get() -var v14 lang.FnFunc -v14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v15 := args[0] -v16 := args[1] -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("keyword?")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("concat")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +v10 := v9.Get() +v11 := lang.Apply(v7, []any{v10, v3}) +var v4 any = v11 +_ = v4 +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("interleave")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +v15 := v14.Get() +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("repeat")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v18 := v17.Get() +v19 := lang.Apply(v18, []any{true}) +v20 := lang.Apply(v15, []any{v4, v19}) +var v12 any = v20 +_ = v12 +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("filter")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("complement")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("keyword?")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +v30 := v29.Get() +v31 := lang.Apply(v27, []any{v30}) +v32 := lang.Apply(v24, []any{v31, v21}) +var v21 any = v32 +_ = v21 +v35 := lang.CreatePersistentTreeSet(lang.NewKeyword("as"), lang.NewKeyword("reload"), lang.NewKeyword("reload-all"), lang.NewKeyword("require"), lang.NewKeyword("use"), lang.NewKeyword("verbose"), lang.NewKeyword("refer"), lang.NewKeyword("as-alias")) +v36 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6002), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(6002), lang.NewKeyword("end-column"), int(86)) +v37, err := lang.WithMeta(v35, v36.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +var v34 any = v37 +_ = v34 +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("seq")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) } -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v5}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +v41 := v40.Get() +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("remove")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) } -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v15}) +v44 := v43.Get() +v45 := lang.Apply(v44, []any{v34, v4}) +v46 := lang.Apply(v41, []any{v45}) +var v38 any = v46 +_ = v38 v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) +v49 := v48.FindInternedVar(lang.NewSymbol("throw-if")) if v49.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) } v50 := v49.Get() -v51 := lang.Apply(v50, []any{v16}) -v52 := lang.Apply(v39, []any{v43, v47, v51}) -v53 := lang.Apply(v36, []any{v52}) -v54 := lang.Apply(v33, []any{v53}) -v55 := lang.Apply(v22, []any{v26, v30, v54}) -v56 := lang.Apply(v19, []any{v55}) -return v56 -}) -v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) -v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("concat")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v52 := v51.FindInternedVar(lang.NewSymbol("apply")) +if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) } -v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v53 := v52.Get() +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("str")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) } -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v56 := v55.Get() +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("interpose")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) } -v33 := v32.Get() +v59 := v58.Get() +v60 := lang.Apply(v59, []any{lang.NewChar(44), v38}) +v61 := lang.Apply(v53, []any{v56, "Unsupported option(s) supplied: ", v60}) +v62 := lang.Apply(v50, []any{v38, v61}) +_ = v62 v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +v35 := v34.FindInternedVar(lang.NewSymbol("throw-if")) if v35.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } v36 := v35.Get() v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +v38 := v37.FindInternedVar(lang.NewSymbol("not")) if v38.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } v39 := v38.Get() v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) +v41 := v40.FindInternedVar(lang.NewSymbol("seq")) if v41.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) } v42 := v41.Get() -v43 := lang.Apply(v42, []any{v5}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +v43 := lang.Apply(v42, []any{v21}) +v44 := lang.Apply(v39, []any{v43}) +v45 := lang.Apply(v36, []any{v44, "Nothing specified to load"}) +_ = v45 +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("seq")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) } -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v2}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +v49 := v48.Get() +v50 := lang.Apply(v49, []any{v21}) +var v46 any = v50 +_ = v46 +var v51 any = nil +_ = v51 +var v52 any = int64(0) +_ = v52 +var v53 any = int64(0) +_ = v53 +var v54 any +for { +var v55 any +v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v57 := v56.FindInternedVar(lang.NewSymbol("<")) +if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) } -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v3}) -v52 := lang.Apply(v39, []any{v43, v47, v51}) -v53 := lang.Apply(v36, []any{v52}) -v54 := lang.Apply(v33, []any{v53}) -v55 := lang.Apply(v22, []any{v26, v30, v54}) -v56 := lang.Apply(v19, []any{v55}) -v57 := lang.Apply(v13, []any{v16, v56, v4}) -return v57 - } -}) -v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) +v58 := v57.Get() +v59 := lang.Apply(v58, []any{v53, v52}) +if lang.IsTruthy(v59) { +v61, _ := lang.FieldOrMethod(v51, "nth") +if reflect.TypeOf(v61).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) } -v5 := lang.Apply(v4, []any{v3, int64(1)}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v0 := lang.NewSymbol("bit-and").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Bitwise and", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1298), lang.NewKeyword("end-line"), int(1298))).(*lang.Symbol) -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v5 := args[0] -v6 := args[1] -v7, _ := lang.FieldOrMethod(lang1.Numbers, "and") -if reflect.TypeOf(v7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("and is not a function"))) +v62 := lang.Apply(v61, []any{v53}) +var v60 any = v62 +_ = v60 +var v64 any +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("libspec?")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) } -v8 := lang.Apply(v7, []any{v5, v6}) -return v8 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := args[0] -v6 := args[1] -v7 := lang.NewList(args[2:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v67 := v66.Get() +v68 := lang.Apply(v67, []any{v60}) +if lang.IsTruthy(v68) { +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("apply")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) } -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("bit-and")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v71 := v70.Get() +v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v73 := v72.FindInternedVar(lang.NewSymbol("load-lib")) +if v73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) } -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("bit-and")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v74 := v73.Get() +v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v76 := v75.FindInternedVar(lang.NewSymbol("prependss")) +if v76.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v5, v6}) -v18 := lang.Apply(v10, []any{v13, v17, v7}) -return v18 - } -}) -v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v3 := ns.InternWithValue(v0, v4, true) -if v0.Meta() != nil { - v3.SetMeta(v0.Meta().(lang.IPersistentMap)) +v77 := v76.Get() +v78 := lang.Apply(v77, []any{v60, v12}) +v79 := lang.Apply(v71, []any{v74, nil, v78}) +v64 = v79 +} else { +var v80 any = v60 +_ = v80 +v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v83 := v82.FindInternedVar(lang.NewSymbol("seq")) +if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) } +v84 := v83.Get() +v85 := lang.Apply(v84, []any{v80}) +var v81 any = v85 +_ = v81 +v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v88 := v87.FindInternedVar(lang.NewSymbol("first")) +if v88.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) } -// ident? -{ -v0 := lang.NewSymbol("ident?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a symbol or keyword", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1608), lang.NewKeyword("end-line"), int(1608))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("keyword?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v89 := v88.Get() +v90 := lang.Apply(v89, []any{v81}) +var v86 any = v90 +_ = v86 +v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v93 := v92.FindInternedVar(lang.NewSymbol("next")) +if v93.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) } -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -var v4 any = v8 -_ = v4 -var v10 any -if lang.IsTruthy(v4) { -v10 = v4 +v94 := v93.Get() +v95 := lang.Apply(v94, []any{v91}) +var v91 any = v95 +_ = v91 +var v96 any = v86 +_ = v96 +var v97 any = v91 +_ = v97 +v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v100 := v99.FindInternedVar(lang.NewSymbol("throw-if")) +if v100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) +} +v101 := v100.Get() +v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v103 := v102.FindInternedVar(lang.NewSymbol("nil?")) +if v103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) +} +v104 := v103.Get() +v105 := lang.Apply(v104, []any{v96}) +v106 := lang.Apply(v101, []any{v105, "prefix cannot be nil"}) +_ = v106 +v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v109 := v108.FindInternedVar(lang.NewSymbol("seq")) +if v109.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) +} +v110 := v109.Get() +v111 := lang.Apply(v110, []any{v97}) +var v107 any = v111 +_ = v107 +var v112 any = nil +_ = v112 +var v113 any = int64(0) +_ = v113 +var v114 any = int64(0) +_ = v114 +var v115 any +for { +var v116 any +v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v118 := v117.FindInternedVar(lang.NewSymbol("<")) +if v118.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) +} +v119 := v118.Get() +v120 := lang.Apply(v119, []any{v114, v113}) +if lang.IsTruthy(v120) { +v122, _ := lang.FieldOrMethod(v112, "nth") +if reflect.TypeOf(v122).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) +} +v123 := lang.Apply(v122, []any{v114}) +var v121 any = v123 +_ = v121 +v125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v126 := v125.FindInternedVar(lang.NewSymbol("apply")) +if v126.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v126))) +} +v127 := v126.Get() +v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v129 := v128.FindInternedVar(lang.NewSymbol("load-lib")) +if v129.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v129))) +} +v130 := v129.Get() +v131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v132 := v131.FindInternedVar(lang.NewSymbol("prependss")) +if v132.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v132))) +} +v133 := v132.Get() +v134 := lang.Apply(v133, []any{v121, v12}) +v135 := lang.Apply(v127, []any{v130, v96, v134}) +_ = v135 +var v136 any = v107 +var v137 any = v112 +var v138 any = v113 +v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v141 := v140.FindInternedVar(lang.NewSymbol("unchecked-inc")) +if v141.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) +} +v142 := v141.Get() +v143 := lang.Apply(v142, []any{v114}) +var v139 any = v143 +v107 = v136 +v112 = v137 +v113 = v138 +v114 = v139 +continue } else { -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("symbol?")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v123 := v122.FindInternedVar(lang.NewSymbol("seq")) +if v123.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) } -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v3}) -v10 = v14 +v124 := v123.Get() +v125 := lang.Apply(v124, []any{v107}) +var v121 any = v125 +_ = v121 +var v127 any +if lang.IsTruthy(v121) { +var v128 any = v121 +_ = v128 +var v130 any +v131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v132 := v131.FindInternedVar(lang.NewSymbol("chunked-seq?")) +if v132.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v132))) } -return v10 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v133 := v132.Get() +v134 := lang.Apply(v133, []any{v128}) +if lang.IsTruthy(v134) { +v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v137 := v136.FindInternedVar(lang.NewSymbol("chunk-first")) +if v137.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) } +v138 := v137.Get() +v139 := lang.Apply(v138, []any{v128}) +var v135 any = v139 +_ = v135 +v142 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v143 := v142.FindInternedVar(lang.NewSymbol("chunk-rest")) +if v143.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v143))) } -// any? -{ -v1 := reflect.TypeOf(false) -v0 := lang.NewSymbol("any?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true given any argument.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(537), lang.NewKeyword("end-line"), int(537))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -return true -}) -v4 := reflect.TypeOf(false) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +v144 := v143.Get() +v145 := lang.Apply(v144, []any{v128}) +var v141 any = v145 +var v146 any = v135 +v148 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v149 := v148.FindInternedVar(lang.NewSymbol("int")) +if v149.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v149))) } +v150 := v149.Get() +v151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v152 := v151.FindInternedVar(lang.NewSymbol("count")) +if v152.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v152))) } -// merge-with -{ -v0 := lang.NewSymbol("merge-with").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("maps"))), lang.NewKeyword("doc"), "Returns a map that consists of the rest of the maps conj-ed onto\n the first. If a key occurs in more than one map, the mapping(s)\n from the latter (left-to-right) will be combined with the mapping in\n the result by calling (f val-in-result val-in-latter).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3050), lang.NewKeyword("end-line"), int(3050))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.NewList(args[1:]...) -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("some")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +v153 := v152.Get() +v154 := lang.Apply(v153, []any{v135}) +v155 := lang.Apply(v150, []any{v154}) +var v147 any = v155 +v157 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v158 := v157.FindInternedVar(lang.NewSymbol("int")) +if v158.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v158))) } -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("identity")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +v159 := v158.Get() +v160 := lang.Apply(v159, []any{int64(0)}) +var v156 any = v160 +v107 = v141 +v112 = v146 +v113 = v147 +v114 = v156 +continue +} else { +v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v137 := v136.FindInternedVar(lang.NewSymbol("first")) +if v137.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) } -v11 := v10.Get() -v12 := lang.Apply(v8, []any{v11, v4}) -if lang.IsTruthy(v12) { -var v14 lang.FnFunc -v14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v15 := args[0] -v16 := args[1] -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("key")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v138 := v137.Get() +v139 := lang.Apply(v138, []any{v128}) +var v135 any = v139 +_ = v135 +v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v142 := v141.FindInternedVar(lang.NewSymbol("apply")) +if v142.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) } -v20 := v19.Get() -v21 := lang.Apply(v20, []any{v16}) -var v17 any = v21 -_ = v17 -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("val")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +v143 := v142.Get() +v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v145 := v144.FindInternedVar(lang.NewSymbol("load-lib")) +if v145.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) } -v25 := v24.Get() -v26 := lang.Apply(v25, []any{v16}) -var v22 any = v26 -_ = v22 -var v28 any -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("contains?")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +v146 := v145.Get() +v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v148 := v147.FindInternedVar(lang.NewSymbol("prependss")) +if v148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) } -v31 := v30.Get() -v32 := lang.Apply(v31, []any{v15, v17}) -if lang.IsTruthy(v32) { -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("assoc")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +v149 := v148.Get() +v150 := lang.Apply(v149, []any{v135, v12}) +v151 := lang.Apply(v143, []any{v146, v96, v150}) +_ = v151 +v153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v154 := v153.FindInternedVar(lang.NewSymbol("next")) +if v154.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v154))) } -v35 := v34.Get() -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("get")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +v155 := v154.Get() +v156 := lang.Apply(v155, []any{v128}) +var v152 any = v156 +var v157 any = nil +var v158 any = int64(0) +var v159 any = int64(0) +v107 = v152 +v112 = v157 +v113 = v158 +v114 = v159 +continue } -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v15, v17}) -v40 := lang.Apply(v3, []any{v39, v22}) -v41 := lang.Apply(v35, []any{v15, v17, v40}) -v28 = v41 +v127 = v130 } else { -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("assoc")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +v127 = nil } -v44 := v43.Get() -v45 := lang.Apply(v44, []any{v15, v17, v22}) -v28 = v45 +v116 = v127 } -return v28 -}) -v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3059), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(3063), lang.NewKeyword("end-column"), int(23)) -v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) -if err != nil { - panic(err) +v115 = v116 + break } -var v13 any = v16 -_ = v13 -var v18 lang.FnFunc -v18 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v19 := args[0] -v20 := args[1] -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("reduce1")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +v64 = v115 } -v23 := v22.Get() -var v24 any = v19 -_ = v24 -var v26 any -if lang.IsTruthy(v24) { -v26 = v24 +_ = v64 +var v80 any = v46 +var v81 any = v51 +var v82 any = v52 +v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v85 := v84.FindInternedVar(lang.NewSymbol("unchecked-inc")) +if v85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) +} +v86 := v85.Get() +v87 := lang.Apply(v86, []any{v53}) +var v83 any = v87 +v46 = v80 +v51 = v81 +v52 = v82 +v53 = v83 +continue } else { -v27 := lang.NewMap() -v28 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3065), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(3065), lang.NewKeyword("end-column"), int(35)) -v29, err := lang.WithMeta(v27, v28.(lang.IPersistentMap)) -if err != nil { - panic(err) +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("seq")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) } -v26 = v29 +v63 := v62.Get() +v64 := lang.Apply(v63, []any{v46}) +var v60 any = v64 +_ = v60 +var v66 any +if lang.IsTruthy(v60) { +var v67 any = v60 +_ = v67 +var v69 any +v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v71 := v70.FindInternedVar(lang.NewSymbol("chunked-seq?")) +if v71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) } -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("seq")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +v72 := v71.Get() +v73 := lang.Apply(v72, []any{v67}) +if lang.IsTruthy(v73) { +v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v76 := v75.FindInternedVar(lang.NewSymbol("chunk-first")) +if v76.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) } -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v20}) -v28 := lang.Apply(v23, []any{v13, v26, v27}) -return v28 -}) -v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3064), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(3065), lang.NewKeyword("end-column"), int(47)) -v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) -if err != nil { - panic(err) +v77 := v76.Get() +v78 := lang.Apply(v77, []any{v67}) +var v74 any = v78 +_ = v74 +v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v82 := v81.FindInternedVar(lang.NewSymbol("chunk-rest")) +if v82.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) } -var v17 any = v20 -_ = v17 -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("reduce1")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v83 := v82.Get() +v84 := lang.Apply(v83, []any{v67}) +var v80 any = v84 +var v85 any = v74 +v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v88 := v87.FindInternedVar(lang.NewSymbol("int")) +if v88.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) } -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v17, v4}) -v5 = v25 +v89 := v88.Get() +v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v91 := v90.FindInternedVar(lang.NewSymbol("count")) +if v91.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) +} +v92 := v91.Get() +v93 := lang.Apply(v92, []any{v74}) +v94 := lang.Apply(v89, []any{v93}) +var v86 any = v94 +v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v97 := v96.FindInternedVar(lang.NewSymbol("int")) +if v97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) +} +v98 := v97.Get() +v99 := lang.Apply(v98, []any{int64(0)}) +var v95 any = v99 +v46 = v80 +v51 = v85 +v52 = v86 +v53 = v95 +continue } else { -v5 = nil +v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v76 := v75.FindInternedVar(lang.NewSymbol("first")) +if v76.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) } -return v5 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v77 := v76.Get() +v78 := lang.Apply(v77, []any{v67}) +var v74 any = v78 +_ = v74 +var v80 any +v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v82 := v81.FindInternedVar(lang.NewSymbol("libspec?")) +if v82.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) } +v83 := v82.Get() +v84 := lang.Apply(v83, []any{v74}) +if lang.IsTruthy(v84) { +v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v86 := v85.FindInternedVar(lang.NewSymbol("apply")) +if v86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) } -// if-not -{ -v0 := lang.NewSymbol("if-not").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("test"), lang.NewSymbol("then")), lang.NewVector(lang.NewSymbol("test"), lang.NewSymbol("then"), lang.NewSymbol("else"))), lang.NewKeyword("doc"), "Evaluates test. If logical false, evaluates and returns then expr, \n otherwise else expr, if supplied, else nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(760), lang.NewKeyword("end-line"), int(760))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 4: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("seq")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v87 := v86.Get() +v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v89 := v88.FindInternedVar(lang.NewSymbol("load-lib")) +if v89.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) } -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("concat")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v90 := v89.Get() +v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v92 := v91.FindInternedVar(lang.NewSymbol("prependss")) +if v92.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) } -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("list")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +v93 := v92.Get() +v94 := lang.Apply(v93, []any{v74, v12}) +v95 := lang.Apply(v87, []any{v90, nil, v94}) +v80 = v95 +} else { +var v96 any = v74 +_ = v96 +v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v99 := v98.FindInternedVar(lang.NewSymbol("seq")) +if v99.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) } -v15 := v14.Get() -v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/if-not")}) -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("list")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +v100 := v99.Get() +v101 := lang.Apply(v100, []any{v96}) +var v97 any = v101 +_ = v97 +v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v104 := v103.FindInternedVar(lang.NewSymbol("first")) +if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) } -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v5}) -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("list")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +v105 := v104.Get() +v106 := lang.Apply(v105, []any{v97}) +var v102 any = v106 +_ = v102 +v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v109 := v108.FindInternedVar(lang.NewSymbol("next")) +if v109.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) } -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v6}) -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("list")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +v110 := v109.Get() +v111 := lang.Apply(v110, []any{v107}) +var v107 any = v111 +_ = v107 +var v112 any = v102 +_ = v112 +var v113 any = v107 +_ = v113 +v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v116 := v115.FindInternedVar(lang.NewSymbol("throw-if")) +if v116.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) } -v27 := v26.Get() -v28 := lang.Apply(v27, []any{nil}) -v29 := lang.Apply(v12, []any{v16, v20, v24, v28}) -v30 := lang.Apply(v9, []any{v29}) -return v30 - case 5: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := args[4] -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("seq")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v117 := v116.Get() +v118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v119 := v118.FindInternedVar(lang.NewSymbol("nil?")) +if v119.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v119))) } -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("concat")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v120 := v119.Get() +v121 := lang.Apply(v120, []any{v112}) +v122 := lang.Apply(v117, []any{v121, "prefix cannot be nil"}) +_ = v122 +v124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v125 := v124.FindInternedVar(lang.NewSymbol("seq")) +if v125.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v125))) } -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v126 := v125.Get() +v127 := lang.Apply(v126, []any{v113}) +var v123 any = v127 +_ = v123 +var v128 any = nil +_ = v128 +var v129 any = int64(0) +_ = v129 +var v130 any = int64(0) +_ = v130 +var v131 any +for { +var v132 any +v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v134 := v133.FindInternedVar(lang.NewSymbol("<")) +if v134.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("if")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v135 := v134.Get() +v136 := lang.Apply(v135, []any{v130, v129}) +if lang.IsTruthy(v136) { +v138, _ := lang.FieldOrMethod(v128, "nth") +if reflect.TypeOf(v138).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) } -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +v139 := lang.Apply(v138, []any{v130}) +var v137 any = v139 +_ = v137 +v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v142 := v141.FindInternedVar(lang.NewSymbol("apply")) +if v142.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) } -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +v143 := v142.Get() +v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v145 := v144.FindInternedVar(lang.NewSymbol("load-lib")) +if v145.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) +} +v146 := v145.Get() +v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v148 := v147.FindInternedVar(lang.NewSymbol("prependss")) +if v148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) +} +v149 := v148.Get() +v150 := lang.Apply(v149, []any{v137, v12}) +v151 := lang.Apply(v143, []any{v146, v112, v150}) +_ = v151 +var v152 any = v123 +var v153 any = v128 +var v154 any = v129 +v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v157 := v156.FindInternedVar(lang.NewSymbol("unchecked-inc")) +if v157.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) } -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v158 := v157.Get() +v159 := lang.Apply(v158, []any{v130}) +var v155 any = v159 +v123 = v152 +v128 = v153 +v129 = v154 +v130 = v155 +continue +} else { +v138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v139 := v138.FindInternedVar(lang.NewSymbol("seq")) +if v139.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v139))) } -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/not")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v140 := v139.Get() +v141 := lang.Apply(v140, []any{v123}) +var v137 any = v141 +_ = v137 +var v143 any +if lang.IsTruthy(v137) { +var v144 any = v137 +_ = v144 +var v146 any +v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v148 := v147.FindInternedVar(lang.NewSymbol("chunked-seq?")) +if v148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) } -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v5}) -v35 := lang.Apply(v26, []any{v30, v34}) -v36 := lang.Apply(v23, []any{v35}) -v37 := lang.Apply(v20, []any{v36}) -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("list")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +v149 := v148.Get() +v150 := lang.Apply(v149, []any{v144}) +if lang.IsTruthy(v150) { +v152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v153 := v152.FindInternedVar(lang.NewSymbol("chunk-first")) +if v153.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v153))) } -v40 := v39.Get() -v41 := lang.Apply(v40, []any{v6}) -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("list")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +v154 := v153.Get() +v155 := lang.Apply(v154, []any{v144}) +var v151 any = v155 +_ = v151 +v158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v159 := v158.FindInternedVar(lang.NewSymbol("chunk-rest")) +if v159.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v159))) } -v44 := v43.Get() -v45 := lang.Apply(v44, []any{v7}) -v46 := lang.Apply(v13, []any{v17, v37, v41, v45}) -v47 := lang.Apply(v10, []any{v46}) -return v47 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v160 := v159.Get() +v161 := lang.Apply(v160, []any{v144}) +var v157 any = v161 +var v162 any = v151 +v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v165 := v164.FindInternedVar(lang.NewSymbol("int")) +if v165.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) } +v166 := v165.Get() +v167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v168 := v167.FindInternedVar(lang.NewSymbol("count")) +if v168.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v168))) } -// extend-protocol -{ -v0 := lang.NewSymbol("extend-protocol").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("p"), lang.NewSymbol("&"), lang.NewSymbol("specs"))), lang.NewKeyword("doc"), "Useful when you want to provide several implementations of the same\n protocol all at once. Takes a single protocol and the implementation\n of that protocol for one or more types.\n\n (extend-protocol Protocol\n AType\n (foo [x] ...)\n (bar [x y] ...)\n BType\n (foo [x] ...)\n (bar [x y] ...)\n AClass\n (foo [x] ...)\n (bar [x y] ...)\n nil\n (foo [x] ...)\n (bar [x y] ...))\n\n expands into:\n\n (do\n (clojure.core/extend-type AType Protocol \n (foo [x] ...) \n (bar [x y] ...))\n (clojure.core/extend-type BType Protocol \n (foo [x] ...) \n (bar [x y] ...))\n (clojure.core/extend-type AClass Protocol \n (foo [x] ...) \n (bar [x y] ...))\n (clojure.core/extend-type nil Protocol \n (foo [x] ...) \n (bar [x y] ...)))", lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(212), lang.NewKeyword("end-line"), int(212))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("emit-extend-protocol")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v169 := v168.Get() +v170 := lang.Apply(v169, []any{v151}) +v171 := lang.Apply(v166, []any{v170}) +var v163 any = v171 +v173 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v174 := v173.FindInternedVar(lang.NewSymbol("int")) +if v174.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v174))) } -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v5, v6}) -return v10 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v175 := v174.Get() +v176 := lang.Apply(v175, []any{int64(0)}) +var v172 any = v176 +v123 = v157 +v128 = v162 +v129 = v163 +v130 = v172 +continue +} else { +v152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v153 := v152.FindInternedVar(lang.NewSymbol("first")) +if v153.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v153))) } +v154 := v153.Get() +v155 := lang.Apply(v154, []any{v144}) +var v151 any = v155 +_ = v151 +v157 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v158 := v157.FindInternedVar(lang.NewSymbol("apply")) +if v158.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v158))) } -// bit-not -{ -var v1 lang.FnFunc -{ // function bit-not__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v159 := v158.Get() +v160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v161 := v160.FindInternedVar(lang.NewSymbol("load-lib")) +if v161.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v161))) } -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v162 := v161.Get() +v163 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v164 := v163.FindInternedVar(lang.NewSymbol("prependss")) +if v164.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v164))) } -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v165 := v164.Get() +v166 := lang.Apply(v165, []any{v151, v12}) +v167 := lang.Apply(v159, []any{v162, v112, v166}) +_ = v167 +v169 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v170 := v169.FindInternedVar(lang.NewSymbol("next")) +if v170.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v170))) } -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v171 := v170.Get() +v172 := lang.Apply(v171, []any{v144}) +var v168 any = v172 +var v173 any = nil +var v174 any = int64(0) +var v175 any = int64(0) +v123 = v168 +v128 = v173 +v129 = v174 +v130 = v175 +continue } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v143 = v146 +} else { +v143 = nil } -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +v132 = v143 } -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +v131 = v132 + break } -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v80 = v131 } -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/not")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +_ = v80 +v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v98 := v97.FindInternedVar(lang.NewSymbol("next")) +if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) } -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v3}) -v35 := lang.Apply(v26, []any{v30, v34}) -v36 := lang.Apply(v23, []any{v35}) -v37 := lang.Apply(v20, []any{v36}) -v38 := lang.Apply(v9, []any{v13, v17, v37}) -v39 := lang.Apply(v6, []any{v38}) -return v39 -}) -v2 := v1 -_ = v2 +v99 := v98.Get() +v100 := lang.Apply(v99, []any{v67}) +var v96 any = v100 +var v101 any = nil +var v102 any = int64(0) +var v103 any = int64(0) +v46 = v96 +v51 = v101 +v52 = v102 +v53 = v103 +continue } -v0 := lang.NewSymbol("bit-not").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Bitwise complement", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1291), lang.NewKeyword("end-line"), int(1291))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "not") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("not is not a function"))) +v66 = v69 +} else { +v66 = nil } -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +v55 = v66 } +v54 = v55 + break } -// subs -{ -v0 := lang.NewSymbol("subs").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("start")), lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("start"), lang.NewSymbol("end"))), lang.NewKeyword("doc"), "Returns the substring of s beginning at start inclusive, and ending\n at end (defaults to length of string), exclusive.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5005), lang.NewKeyword("end-line"), int(5005))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v3 := args[0] -v4 := args[1] -v5 := lang.Apply(lang.Builtins["slice"], []any{v3, v4}) -return v5 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.Apply(lang.Builtins["slice"], []any{v3, v4, v5}) -return v6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) +return v54 } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -48393,207 +48029,107 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// alength +// load-one { -var v1 lang.FnFunc -{ // function alength__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { +v0 := lang.NewSymbol("load-one").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"), lang.NewSymbol("need-ns"), lang.NewSymbol("require"))), lang.NewKeyword("doc"), "Loads a lib given its name. If need-ns, ensures that the associated\n namespace exists after loading. If require, records the load so any\n duplicate loads can be skipped.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5922), lang.NewKeyword("end-line"), int(5922), lang.NewKeyword("private"), true)).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v4 := args[1] +v5 := args[2] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("load")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("root-resource")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v3}) +v13 := lang.Apply(v8, []any{v12}) +_ = v13 v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) +v15 := v14.FindInternedVar(lang.NewSymbol("throw-if")) if v15.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +var v17 any = v4 +_ = v17 +var v19 any +if lang.IsTruthy(v17) { +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("not")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("find-ns")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v23 := v22.Get() +v25 := v24.Get() +v26 := lang.Apply(v25, []any{v3}) +v27 := lang.Apply(v22, []any{v26}) +v19 = v27 +} else { +v19 = v17 +} +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("root-resource")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v3}) +v21 := lang.Apply(v16, []any{v19, "namespace '%s' not found after loading '%s'", v3, v20}) +_ = v21 +var v22 any +if lang.IsTruthy(v5) { +var v23 lang.FnFunc +v23 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +v25 := v24.FindInternedVar(lang.NewSymbol("commute")) if v25.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } v26 := v25.Get() v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) +v28 := v27.FindInternedVar(lang.NewSymbol("*loaded-libs*")) if v28.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/Alength")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v3}) -v35 := lang.Apply(v26, []any{v30, v34}) -v36 := lang.Apply(v23, []any{v35}) -v37 := lang.Apply(v20, []any{v36}) -v38 := lang.Apply(v9, []any{v13, v17, v37}) -v39 := lang.Apply(v6, []any{v38}) -return v39 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("alength").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the length of the Java array. Works on arrays of all\n types.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3897), lang.NewKeyword("end-line"), int(3897))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5, _ := lang.FieldOrMethod(runtime3.RT, "Alength") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Alength is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// dedupe -{ -v0 := lang.NewSymbol("dedupe").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence removing consecutive duplicates in coll.\n Returns a transducer when no collection is provided.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7724), lang.NewKeyword("end-line"), int(7724))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("volatile!")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{lang.NewKeyword("glojure.core/none")}) -var v5 any = v9 -_ = v5 -var v11 lang.FnFunc -v11 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v12 := lang.Apply(v4, nil) -return v12 - case 1: -v12 := args[0] -v13 := lang.Apply(v4, []any{v12}) -return v13 - case 2: -v12 := args[0] -v13 := args[1] -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("deref")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v5}) -var v14 any = v18 -_ = v14 -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("vreset!")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.Apply(v22, []any{v5, v13}) -_ = v23 -var v24 any -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("=")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.Apply(v27, []any{v14, v13}) -if lang.IsTruthy(v28) { -v24 = v12 -} else { -v29 := lang.Apply(v4, []any{v12, v13}) -v24 = v29 -} -return v24 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7731), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7739), lang.NewKeyword("end-column"), int(37)) -v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) -if err != nil { - panic(err) +v29 := v28.Get() +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("conj")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) } -return v13 +v32 := v31.Get() +v33 := lang.Apply(v26, []any{v29, v32, v3}) +return v33 }) -v4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7729), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7739), lang.NewKeyword("end-column"), int(39)) -v5, err := lang.WithMeta(v3, v4.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v5 - case 1: -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("sequence")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v24, _ := lang.FieldOrMethod(lang1.LockingTransaction, "RunInTransaction") +if reflect.TypeOf(v24).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("RunInTransaction is not a function"))) } -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("dedupe")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v25 := lang.Apply(v24, []any{v23}) +v22 = v25 +} else { +v22 = nil } -v9 := v8.Get() -v10 := lang.Apply(v9, nil) -v11 := lang.Apply(v6, []any{v10, v3}) -return v11 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } +return v22 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -48601,91 +48137,20 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// bounded-count +// load-reader { -v0 := lang.NewSymbol("bounded-count").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "If coll is counted? returns its count, else will count at most the first n\n elements of coll using its seq", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7453), lang.NewKeyword("end-line"), int(7453))).(*lang.Symbol) +v0 := lang.NewSymbol("load-reader").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rdr"))), lang.NewKeyword("doc"), "Sequentially read and evaluate the set of forms contained in the\n stream/file", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4081), lang.NewKeyword("end-line"), int(4081))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := args[1] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("counted?")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v4}) -if lang.IsTruthy(v9) { -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("count")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{v4}) -v5 = v13 -} else { -var v14 any = int64(0) -_ = v14 -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("seq")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v4}) -var v15 any = v19 -_ = v15 -var v20 any -for { -var v21 any -var v22 any = v15 -_ = v22 -var v24 any -if lang.IsTruthy(v22) { -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("<")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.Apply(v27, []any{v14, v3}) -v24 = v28 -} else { -v24 = v22 -} -if lang.IsTruthy(v24) { -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("inc")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{v14}) -var v22 any = v26 -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("next")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{v15}) -var v27 any = v31 -v14 = v22 -v15 = v27 -continue -} else { -v21 = v14 -} -v20 = v21 - break -} -v5 = v20 +v4, _ := lang.FieldOrMethod(runtime9.Compiler, "load") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("load is not a function"))) } +v5 := lang.Apply(v4, []any{v3}) return v5 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -48694,38 +48159,56 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// neg-int? +// load-string { -v0 := lang.NewSymbol("neg-int?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a negative fixed precision integer", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1409), lang.NewKeyword("end-line"), int(1409))).(*lang.Symbol) +v0 := lang.NewSymbol("load-string").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Sequentially read and evaluate the set of forms contained in the\n string", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4088), lang.NewKeyword("end-line"), int(4088))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("int?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -var v4 any = v8 +v5 := lang.Apply(java.io.StringReader25., []any{v3}) +v6 := lang.Apply(glojure.lang.LineNumberingPushbackReader23., []any{v5}) +var v4 any = v6 _ = v4 -var v10 any -if lang.IsTruthy(v4) { -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("neg?")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("load-reader")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v3}) -v10 = v14 -} else { -v10 = v4 +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v4}) +return v11 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -return v10 +} +// loaded-libs +{ +v0 := lang.NewSymbol("loaded-libs").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Returns a sorted set of symbols naming the currently loaded libs", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6133), lang.NewKeyword("end-line"), int(6133))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v4 := v3.FindInternedVar(lang.NewSymbol("deref")) +if v4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) +} +v5 := v4.Get() +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("*loaded-libs*")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v5, []any{v8}) +return v9 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -48733,9 +48216,9 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// when-first +// locking { -v0 := lang.NewSymbol("when-first").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "bindings => x xs\n\n Roughly the same as (when (seq xs) (let [x (first xs)] body)) but xs is evaluated only once", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4622), lang.NewKeyword("end-line"), int(4622))).(*lang.Symbol) +v0 := lang.NewSymbol("locking").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Executes exprs in an implicit do, while holding the monitor of x.\n Will release the monitor of x in all circumstances.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1643), lang.NewKeyword("end-line"), int(1643))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -48747,322 +48230,306 @@ v3 := args[0] v4 := args[1] v5 := args[2] v6 := lang.NewList(args[3:]...) -var v7 any -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("seq")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v5}) -if lang.IsTruthy(v11) { -v7 = nil -} else { -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("str")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("concat")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("first")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("list")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v3}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v15 := v14.Get() +v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/let")}) +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("list")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("meta")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("apply")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) -v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) -v28 := lang.Apply(lang1.NewIllegalArgumentError, []any{v27}) -panic(v28) +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("vector")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -_ = v7 -var v29 any -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("=")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("seq")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) } -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("count")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("concat")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) } -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v5}) -v37 := lang.Apply(v32, []any{int64(2), v36}) -if lang.IsTruthy(v37) { -v29 = nil -} else { -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("str")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +v31 := v30.Get() +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) } -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("first")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +v34 := v33.Get() +v35 := lang.Apply(v34, []any{lang.NewSymbol("lockee__0__auto__")}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) } -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v3}) -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v5}) +v40 := lang.Apply(v31, []any{v35, v39}) +v41 := lang.Apply(v28, []any{v40}) +v42 := lang.Apply(v22, []any{v25, v41}) +v43 := lang.Apply(v19, []any{v42}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } -v47 := v46.Get() -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("meta")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +v46 := v45.Get() +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("seq")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) } -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v3}) -v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) -v53 := lang.Apply(v40, []any{v44, " requires ", "exactly 2 forms in binding vector", " in ", v47, ":", v52}) -v54 := lang.Apply(lang1.NewIllegalArgumentError, []any{v53}) -panic(v54) +v49 := v48.Get() +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("concat")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) } -_ = v29 -_ = nil -var v55 any = v5 -_ = v55 +v52 := v51.Get() +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("list")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +} +v55 := v54.Get() +v56 := lang.Apply(v55, []any{lang.NewSymbol("try")}) v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("nth")) +v58 := v57.FindInternedVar(lang.NewSymbol("list")) if v58.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) } v59 := v58.Get() -v60 := lang.Apply(v59, []any{v55, int64(0), nil}) -var v56 any = v60 -_ = v56 -v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v63 := v62.FindInternedVar(lang.NewSymbol("nth")) -if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v61 := v60.FindInternedVar(lang.NewSymbol("seq")) +if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) } -v64 := v63.Get() -v65 := lang.Apply(v64, []any{v55, int64(1), nil}) -var v61 any = v65 -_ = v61 -v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v68 := v67.FindInternedVar(lang.NewSymbol("seq")) -if v68.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) +v62 := v61.Get() +v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v64 := v63.FindInternedVar(lang.NewSymbol("concat")) +if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) } -v69 := v68.Get() +v65 := v64.Get() +v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v67 := v66.FindInternedVar(lang.NewSymbol("list")) +if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) +} +v68 := v67.Get() +v69 := lang.Apply(v68, []any{lang.NewSymbol("glojure.core/let")}) v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v71 := v70.FindInternedVar(lang.NewSymbol("concat")) +v71 := v70.FindInternedVar(lang.NewSymbol("list")) if v71.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) } v72 := v71.Get() v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v74 := v73.FindInternedVar(lang.NewSymbol("list")) +v74 := v73.FindInternedVar(lang.NewSymbol("apply")) if v74.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) } v75 := v74.Get() -v76 := lang.Apply(v75, []any{lang.NewSymbol("glojure.core/when-let")}) -v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v78 := v77.FindInternedVar(lang.NewSymbol("list")) -if v78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) +v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v77 := v76.FindInternedVar(lang.NewSymbol("vector")) +if v77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) } -v79 := v78.Get() -v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v81 := v80.FindInternedVar(lang.NewSymbol("apply")) -if v81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) +v78 := v77.Get() +v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v80 := v79.FindInternedVar(lang.NewSymbol("seq")) +if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) } -v82 := v81.Get() -v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v84 := v83.FindInternedVar(lang.NewSymbol("vector")) -if v84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) +v81 := v80.Get() +v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v83 := v82.FindInternedVar(lang.NewSymbol("concat")) +if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) } -v85 := v84.Get() -v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v87 := v86.FindInternedVar(lang.NewSymbol("seq")) -if v87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) +v84 := v83.Get() +v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v86 := v85.FindInternedVar(lang.NewSymbol("list")) +if v86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) } -v88 := v87.Get() +v87 := v86.Get() +v88 := lang.Apply(v87, []any{lang.NewSymbol("locklocal__1__auto__")}) v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v90 := v89.FindInternedVar(lang.NewSymbol("concat")) +v90 := v89.FindInternedVar(lang.NewSymbol("list")) if v90.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) } v91 := v90.Get() -v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v93 := v92.FindInternedVar(lang.NewSymbol("list")) -if v93.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) +v92 := lang.Apply(v91, []any{lang.NewSymbol("lockee__0__auto__")}) +v93 := lang.Apply(v84, []any{v88, v92}) +v94 := lang.Apply(v81, []any{v93}) +v95 := lang.Apply(v75, []any{v78, v94}) +v96 := lang.Apply(v72, []any{v95}) +v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v98 := v97.FindInternedVar(lang.NewSymbol("list")) +if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) } -v94 := v93.Get() -v95 := lang.Apply(v94, []any{lang.NewSymbol("xs__0__auto__")}) -v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v97 := v96.FindInternedVar(lang.NewSymbol("list")) -if v97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) +v99 := v98.Get() +v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v101 := v100.FindInternedVar(lang.NewSymbol("seq")) +if v101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) } -v98 := v97.Get() -v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v100 := v99.FindInternedVar(lang.NewSymbol("seq")) -if v100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) +v102 := v101.Get() +v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v104 := v103.FindInternedVar(lang.NewSymbol("concat")) +if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) } -v101 := v100.Get() -v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v103 := v102.FindInternedVar(lang.NewSymbol("concat")) -if v103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) +v105 := v104.Get() +v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v107 := v106.FindInternedVar(lang.NewSymbol("list")) +if v107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) } -v104 := v103.Get() -v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v106 := v105.FindInternedVar(lang.NewSymbol("list")) -if v106.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) +v108 := v107.Get() +v109 := lang.Apply(v108, []any{lang.NewSymbol("monitor-enter")}) +v110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v111 := v110.FindInternedVar(lang.NewSymbol("list")) +if v111.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v111))) } -v107 := v106.Get() -v108 := lang.Apply(v107, []any{lang.NewSymbol("glojure.core/seq")}) -v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v110 := v109.FindInternedVar(lang.NewSymbol("list")) -if v110.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) +v112 := v111.Get() +v113 := lang.Apply(v112, []any{lang.NewSymbol("locklocal__1__auto__")}) +v114 := lang.Apply(v105, []any{v109, v113}) +v115 := lang.Apply(v102, []any{v114}) +v116 := lang.Apply(v99, []any{v115}) +v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v118 := v117.FindInternedVar(lang.NewSymbol("list")) +if v118.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) } -v111 := v110.Get() -v112 := lang.Apply(v111, []any{v61}) -v113 := lang.Apply(v104, []any{v108, v112}) -v114 := lang.Apply(v101, []any{v113}) -v115 := lang.Apply(v98, []any{v114}) -v116 := lang.Apply(v91, []any{v95, v115}) -v117 := lang.Apply(v88, []any{v116}) -v118 := lang.Apply(v82, []any{v85, v117}) -v119 := lang.Apply(v79, []any{v118}) +v119 := v118.Get() v120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v121 := v120.FindInternedVar(lang.NewSymbol("list")) +v121 := v120.FindInternedVar(lang.NewSymbol("seq")) if v121.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v121))) } v122 := v121.Get() v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v124 := v123.FindInternedVar(lang.NewSymbol("seq")) +v124 := v123.FindInternedVar(lang.NewSymbol("concat")) if v124.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) } v125 := v124.Get() v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v127 := v126.FindInternedVar(lang.NewSymbol("concat")) +v127 := v126.FindInternedVar(lang.NewSymbol("list")) if v127.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) } v128 := v127.Get() -v129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v130 := v129.FindInternedVar(lang.NewSymbol("list")) -if v130.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v130))) +v129 := lang.Apply(v128, []any{lang.NewSymbol("try")}) +v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v131 := v130.FindInternedVar(lang.NewSymbol("list")) +if v131.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) } -v131 := v130.Get() -v132 := lang.Apply(v131, []any{lang.NewSymbol("glojure.core/let")}) +v132 := v131.Get() v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v134 := v133.FindInternedVar(lang.NewSymbol("list")) +v134 := v133.FindInternedVar(lang.NewSymbol("seq")) if v134.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) } v135 := v134.Get() v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v137 := v136.FindInternedVar(lang.NewSymbol("apply")) +v137 := v136.FindInternedVar(lang.NewSymbol("concat")) if v137.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) } v138 := v137.Get() v139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v140 := v139.FindInternedVar(lang.NewSymbol("vector")) +v140 := v139.FindInternedVar(lang.NewSymbol("list")) if v140.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v140))) } v141 := v140.Get() -v142 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v143 := v142.FindInternedVar(lang.NewSymbol("seq")) -if v143.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v143))) +v142 := lang.Apply(v141, []any{lang.NewSymbol("finally")}) +v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v144 := v143.FindInternedVar(lang.NewSymbol("list")) +if v144.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) } -v144 := v143.Get() -v145 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v146 := v145.FindInternedVar(lang.NewSymbol("concat")) -if v146.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v146))) +v145 := v144.Get() +v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v147 := v146.FindInternedVar(lang.NewSymbol("seq")) +if v147.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) } -v147 := v146.Get() -v148 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v149 := v148.FindInternedVar(lang.NewSymbol("list")) -if v149.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v149))) +v148 := v147.Get() +v149 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v150 := v149.FindInternedVar(lang.NewSymbol("concat")) +if v150.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v150))) } -v150 := v149.Get() -v151 := lang.Apply(v150, []any{v56}) +v151 := v150.Get() v152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v153 := v152.FindInternedVar(lang.NewSymbol("list")) if v153.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v153))) } v154 := v153.Get() -v155 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v156 := v155.FindInternedVar(lang.NewSymbol("seq")) -if v156.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v156))) -} -v157 := v156.Get() -v158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v159 := v158.FindInternedVar(lang.NewSymbol("concat")) -if v159.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v159))) -} -v160 := v159.Get() -v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v162 := v161.FindInternedVar(lang.NewSymbol("list")) -if v162.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) -} -v163 := v162.Get() -v164 := lang.Apply(v163, []any{lang.NewSymbol("glojure.core/first")}) -v165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v166 := v165.FindInternedVar(lang.NewSymbol("list")) -if v166.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v166))) +v155 := lang.Apply(v154, []any{lang.NewSymbol("monitor-exit")}) +v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v157 := v156.FindInternedVar(lang.NewSymbol("list")) +if v157.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) } -v167 := v166.Get() -v168 := lang.Apply(v167, []any{lang.NewSymbol("xs__0__auto__")}) -v169 := lang.Apply(v160, []any{v164, v168}) -v170 := lang.Apply(v157, []any{v169}) -v171 := lang.Apply(v154, []any{v170}) -v172 := lang.Apply(v147, []any{v151, v171}) -v173 := lang.Apply(v144, []any{v172}) -v174 := lang.Apply(v138, []any{v141, v173}) -v175 := lang.Apply(v135, []any{v174}) -v176 := lang.Apply(v128, []any{v132, v175, v6}) -v177 := lang.Apply(v125, []any{v176}) -v178 := lang.Apply(v122, []any{v177}) -v179 := lang.Apply(v72, []any{v76, v119, v178}) -v180 := lang.Apply(v69, []any{v179}) -return v180 +v158 := v157.Get() +v159 := lang.Apply(v158, []any{lang.NewSymbol("locklocal__1__auto__")}) +v160 := lang.Apply(v151, []any{v155, v159}) +v161 := lang.Apply(v148, []any{v160}) +v162 := lang.Apply(v145, []any{v161}) +v163 := lang.Apply(v138, []any{v142, v162}) +v164 := lang.Apply(v135, []any{v163}) +v165 := lang.Apply(v132, []any{v164}) +v166 := lang.Apply(v125, []any{v129, v6, v165}) +v167 := lang.Apply(v122, []any{v166}) +v168 := lang.Apply(v119, []any{v167}) +v169 := lang.Apply(v65, []any{v69, v96, v116, v168}) +v170 := lang.Apply(v62, []any{v169}) +v171 := lang.Apply(v59, []any{v170}) +v172 := lang.Apply(v52, []any{v56, v171}) +v173 := lang.Apply(v49, []any{v172}) +v174 := lang.Apply(v46, []any{v173}) +v175 := lang.Apply(v12, []any{v16, v43, v174}) +v176 := lang.Apply(v9, []any{v175}) +return v176 } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -49071,785 +48538,812 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// comp +// long { -v0 := lang.NewSymbol("comp").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("g")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("g"), lang.NewSymbol("&"), lang.NewSymbol("fs"))), lang.NewKeyword("doc"), "Takes a set of functions and returns a fn that is the composition\n of those fns. The returned fn takes a variable number of args,\n applies the rightmost of fns to the args, the next\n fn (right-to-left) to the result, etc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2549), lang.NewKeyword("end-line"), int(2549))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v4 := v3.FindInternedVar(lang.NewSymbol("identity")) -if v4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) -} -v5 := v4.Get() -return v5 - case 1: -v3 := args[0] -return v3 - case 2: +var v1 lang.FnFunc +{ // function long__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] -v4 := args[1] -var v5 lang.FnFunc -v5 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v6 := lang.Apply(v4, nil) -v7 := lang.Apply(v3, []any{v6}) -return v7 - case 1: -v6 := args[0] -v7 := lang.Apply(v4, []any{v6}) -v8 := lang.Apply(v3, []any{v7}) -return v8 - case 2: -v6 := args[0] -v7 := args[1] -v8 := lang.Apply(v4, []any{v6, v7}) -v9 := lang.Apply(v3, []any{v8}) -return v9 - case 3: -v6 := args[0] -v7 := args[1] -v8 := args[2] -v9 := lang.Apply(v4, []any{v6, v7, v8}) -v10 := lang.Apply(v3, []any{v9}) -return v10 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v6 := args[0] -v7 := args[1] -v8 := args[2] -v9 := lang.NewList(args[3:]...) +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("apply")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) if v11.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } v12 := v11.Get() -v13 := lang.Apply(v12, []any{v4, v6, v7, v8, v9}) -v14 := lang.Apply(v3, []any{v13}) -return v14 - } -}) -v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2559), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2564), lang.NewKeyword("end-column"), int(49)) -v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) -if err != nil { - panic(err) +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -return v7 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("reduce1")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("comp")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("list*")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v3, v4, v5}) -v16 := lang.Apply(v8, []any{v11, v15}) -return v16 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/LongCast")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -// namespace -{ -v1 := reflect.TypeOf("") -v0 := lang.NewSymbol("namespace").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns the namespace String of a symbol or keyword, or nil if not present.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1593), lang.NewKeyword("end-line"), int(1593))).(*lang.Symbol) +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v3}) +v35 := lang.Apply(v26, []any{v30, v34}) +v36 := lang.Apply(v23, []any{v35}) +v37 := lang.Apply(v20, []any{v36}) +v38 := lang.Apply(v9, []any{v13, v17, v37}) +v39 := lang.Apply(v6, []any{v38}) +return v39 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("long").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to long", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3481), lang.NewKeyword("end-line"), int(3481))).(*lang.Symbol) var v3 lang.FnFunc v3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5, _ := lang.FieldOrMethod(v4, "Namespace") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Namespace is not a function"))) -} -v6 := lang.Apply(v5, []any{}) -return v6 +v5 := lang.Apply(lang1.LongCast, []any{v4}) +return v5 }) -v4 := reflect.TypeOf("") -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// format +// long-array { -v0 := lang.NewSymbol("format").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fmt"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Formats a string using java.lang.String.format, see java.util.Formatter for format\n string syntax", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5760), lang.NewKeyword("end-line"), int(5760))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { +var v1 lang.FnFunc +{ // function long-array__inliner +v1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 1 { + if len(args) < 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := args[0] -v4 := lang.NewList(args[1:]...) -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("apply")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v3 := lang.NewList(args[0:]...) +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v7 := v6.Get() -v8 := lang.Apply(v7, []any{fmt.Sprintf, v3, v4}) -return v8 +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/longArray")}) +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("list")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("seq")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("concat")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("list")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v37, []any{lang.NewSymbol("glojure.core/args")}) +v39 := lang.Apply(v30, []any{v34, v38}) +v40 := lang.Apply(v27, []any{v39}) +v41 := lang.Apply(v24, []any{v40}) +v42 := lang.Apply(v9, []any{v13, v17, v21, v41}) +v43 := lang.Apply(v6, []any{v42}) +return v43 } }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("long-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Creates an array of longs", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5364), lang.NewKeyword("end-line"), int(5364))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "longArray") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("longArray is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 + case 2: +v4 := args[0] +v5 := args[1] +v6, _ := lang.FieldOrMethod(lang1.Numbers, "longArrayInit") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("longArrayInit is not a function"))) +} +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// vary-meta +// longs { -v0 := lang.NewSymbol("vary-meta").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("obj"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Returns an object of the same type and value as obj, with\n (apply f (meta obj) args) as its metadata.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(668), lang.NewKeyword("end-line"), int(668))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } +var v1 lang.FnFunc +{ // function longs +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("with-meta")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("apply")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("meta")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v3}) -v16 := lang.Apply(v11, []any{v4, v15, v5}) -v17 := lang.Apply(v8, []any{v3, v16}) -return v17 +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/longs")}) +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("list")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v3}) +v26 := lang.Apply(v9, []any{v13, v17, v21, v25}) +v27 := lang.Apply(v6, []any{v26}) +return v27 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("longs").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Casts to long[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5407), lang.NewKeyword("end-line"), int(5407))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "longs") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("longs is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// nth +// loop { -var v1 lang.FnFunc -{ // function nth__inliner -v1 = lang.NewFnFunc(func(args ...any) any { +v0 := lang.NewSymbol("loop").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Evaluates the exprs in a lexical context in which the symbols in\n the binding-forms are bound to their respective init-exprs or parts\n therein. Acts as a recur target.", lang.NewKeyword("forms"), lang.NewVector(lang.NewList(lang.NewSymbol("loop"), lang.NewVector(lang.NewSymbol("bindings*")), lang.NewSymbol("exprs*"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4597), lang.NewKeyword("end-line"), int(4597), lang.NewKeyword("special-form"), true)).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 2 { + if len(args) < 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] v4 := args[1] -v5 := lang.NewList(args[2:]...) -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("seq")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("concat")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +v5 := args[2] +v6 := lang.NewList(args[3:]...) +var v7 any +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v11 := v10.Get() +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v5}) +if lang.IsTruthy(v11) { +v7 = nil +} else { v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("list")) +v13 := v12.FindInternedVar(lang.NewSymbol("str")) if v13.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } v14 := v13.Get() -v15 := lang.Apply(v14, []any{lang.NewSymbol(".")}) -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("list")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("first")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } -v18 := v17.Get() -v19 := lang.Apply(v18, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("list")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v3}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("seq")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("meta")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("concat")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v3}) +v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) +v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) +v28 := lang.Apply(lang1.NewIllegalArgumentError, []any{v27}) +panic(v28) } -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("list")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +_ = v7 +var v29 any +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("even?")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) } -v31 := v30.Get() -v32 := lang.Apply(v31, []any{lang.NewSymbol("glojure.core/Nth")}) +v32 := v31.Get() v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("list")) +v34 := v33.FindInternedVar(lang.NewSymbol("count")) if v34.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) } v35 := v34.Get() -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("seq")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +v36 := lang.Apply(v35, []any{v5}) +v37 := lang.Apply(v32, []any{v36}) +if lang.IsTruthy(v37) { +v29 = nil +} else { +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("str")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) } -v38 := v37.Get() -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("concat")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("first")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } -v41 := v40.Get() -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("list")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v3}) +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) } -v44 := v43.Get() -v45 := lang.Apply(v44, []any{lang.NewSymbol("glojure.core/unquote")}) -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("list")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +v47 := v46.Get() +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("meta")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) } -v48 := v47.Get() -v49 := lang.Apply(v48, []any{lang.NewSymbol("glojure.core/c")}) -v50 := lang.Apply(v41, []any{v45, v49}) -v51 := lang.Apply(v38, []any{v50}) -v52 := lang.Apply(v35, []any{v51}) -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("list")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v3}) +v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) +v53 := lang.Apply(v40, []any{v44, " requires ", "an even number of forms in binding vector", " in ", v47, ":", v52}) +v54 := lang.Apply(lang1.NewIllegalArgumentError, []any{v53}) +panic(v54) } -v55 := v54.Get() +_ = v29 +_ = nil v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v57 := v56.FindInternedVar(lang.NewSymbol("seq")) +v57 := v56.FindInternedVar(lang.NewSymbol("destructure")) if v57.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) } v58 := v57.Get() -v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v60 := v59.FindInternedVar(lang.NewSymbol("concat")) -if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) -} -v61 := v60.Get() +v59 := lang.Apply(v58, []any{v5}) +var v55 any = v59 +_ = v55 +var v61 any v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v63 := v62.FindInternedVar(lang.NewSymbol("list")) +v63 := v62.FindInternedVar(lang.NewSymbol("=")) if v63.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) } v64 := v63.Get() -v65 := lang.Apply(v64, []any{lang.NewSymbol("glojure.core/unquote")}) +v65 := lang.Apply(v64, []any{v55, v5}) +if lang.IsTruthy(v65) { v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v67 := v66.FindInternedVar(lang.NewSymbol("list")) +v67 := v66.FindInternedVar(lang.NewSymbol("seq")) if v67.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) } v68 := v67.Get() -v69 := lang.Apply(v68, []any{lang.NewSymbol("glojure.core/i")}) -v70 := lang.Apply(v61, []any{v65, v69}) -v71 := lang.Apply(v58, []any{v70}) -v72 := lang.Apply(v55, []any{v71}) -v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v74 := v73.FindInternedVar(lang.NewSymbol("list")) -if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("concat")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) } -v75 := v74.Get() +v71 := v70.Get() +v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v73 := v72.FindInternedVar(lang.NewSymbol("list")) +if v73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) +} +v74 := v73.Get() +v75 := lang.Apply(v74, []any{lang.NewSymbol("loop*")}) v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v77 := v76.FindInternedVar(lang.NewSymbol("seq")) +v77 := v76.FindInternedVar(lang.NewSymbol("list")) if v77.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) } v78 := v77.Get() -v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v80 := v79.FindInternedVar(lang.NewSymbol("concat")) -if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) -} -v81 := v80.Get() -v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v83 := v82.FindInternedVar(lang.NewSymbol("list")) -if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) +v79 := lang.Apply(v78, []any{v5}) +v80 := lang.Apply(v71, []any{v75, v79, v6}) +v81 := lang.Apply(v68, []any{v80}) +v61 = v81 +} else { +v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v84 := v83.FindInternedVar(lang.NewSymbol("take-nth")) +if v84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) } -v84 := v83.Get() -v85 := lang.Apply(v84, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) +v85 := v84.Get() v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v87 := v86.FindInternedVar(lang.NewSymbol("list")) +v87 := v86.FindInternedVar(lang.NewSymbol("drop")) if v87.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) } v88 := v87.Get() -v89 := lang.Apply(v88, []any{lang.NewSymbol("glojure.core/nf")}) -v90 := lang.Apply(v81, []any{v85, v89}) -v91 := lang.Apply(v78, []any{v90}) -v92 := lang.Apply(v75, []any{v91}) -v93 := lang.Apply(v28, []any{v32, v52, v72, v92}) -v94 := lang.Apply(v25, []any{v93}) -v95 := lang.Apply(v22, []any{v94}) -v96 := lang.Apply(v11, []any{v15, v19, v95}) -v97 := lang.Apply(v8, []any{v96}) -return v97 - } -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("nth").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("index")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("index"), lang.NewSymbol("not-found"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the value at the index. get returns nil if index out of\n bounds, nth throws an exception unless not-found is supplied. nth\n also works for strings, Java arrays, regex Matchers and Lists, and,\n in O(n) time, for sequences.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)int64(3)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(882), lang.NewKeyword("end-line"), int(882))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v4 := args[0] -v5 := args[1] -v6, _ := lang.FieldOrMethod(runtime3.RT, "Nth") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Nth is not a function"))) -} -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 - case 3: -v4 := args[0] -v5 := args[1] -v6 := args[2] -v7, _ := lang.FieldOrMethod(runtime3.RT, "NthDefault") -if reflect.TypeOf(v7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("NthDefault is not a function"))) -} -v8 := lang.Apply(v7, []any{v4, v5, v6}) -return v8 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +v89 := lang.Apply(v88, []any{int64(1), v5}) +v90 := lang.Apply(v85, []any{int64(2), v89}) +var v82 any = v90 +_ = v82 +v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v93 := v92.FindInternedVar(lang.NewSymbol("take-nth")) +if v93.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) } +v94 := v93.Get() +v95 := lang.Apply(v94, []any{int64(2), v5}) +var v91 any = v95 +_ = v91 +v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v98 := v97.FindInternedVar(lang.NewSymbol("map")) +if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) } -// prep-hashes -{ -v0 := lang.NewSymbol("prep-hashes").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr-sym"), lang.NewSymbol("default"), lang.NewSymbol("tests"), lang.NewSymbol("thens"))), lang.NewKeyword("doc"), "Takes a sequence of test constants and a corresponding sequence of then\n expressions. Returns a tuple of [shift mask case-map switch-type skip-check]\n where case-map is a map of int case values to [test then] tuples, switch-type\n is either :sparse or :compact, and skip-check is a set of case ints for which\n post-switch equivalence checking must not be done (occurs with hash\n collisions).", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6726), lang.NewKeyword("end-line"), int(6726), lang.NewKeyword("private"), true)).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -var v8 lang.FnFunc -v8 = lang.NewFnFunc(func(args ...any) any { +v99 := v98.Get() +var v100 lang.FnFunc +v100 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v9 := args[0] -v10 := lang.Apply(lang1.Hash, []any{v9}) -return v10 -}) -v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6734), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(6734), lang.NewKeyword("end-column"), int(66)) -v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v7 any = v10 -_ = v7 -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("into1")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.CreatePersistentTreeSet() -v16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6735), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(6735), lang.NewKeyword("end-column"), int(25)) -v17, err := lang.WithMeta(v15, v16.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("map")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v20, []any{v7, v5}) -v22 := lang.Apply(v14, []any{v17, v21}) -var v11 any = v22 -_ = v11 -var v24 any -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("==")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("count")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{v5}) -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("count")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v11}) -v36 := lang.Apply(v27, []any{v31, v35}) -if lang.IsTruthy(v36) { -var v37 any -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("fits-table?")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.Apply(v40, []any{v11}) -if lang.IsTruthy(v41) { -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("case-map")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) -} -v44 := v43.Get() -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("identity")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.Apply(v44, []any{v7, v47, v5, v6}) -v49 := lang.NewVector(int64(0), int64(0), v48, lang.NewKeyword("compact")) -v50 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6739), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(6739), lang.NewKeyword("end-column"), int(63)) -v51, err := lang.WithMeta(v49, v50.(lang.IPersistentMap)) -if err != nil { - panic(err) +v101 := args[0] +var v102 any +v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v104 := v103.FindInternedVar(lang.NewSymbol("symbol?")) +if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) } -v37 = v51 +v105 := v104.Get() +v106 := lang.Apply(v105, []any{v101}) +if lang.IsTruthy(v106) { +v102 = v101 } else { -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("maybe-min-hash")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +v107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v108 := v107.FindInternedVar(lang.NewSymbol("gensym")) +if v108.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v108))) } -v56 := v55.Get() -v57 := lang.Apply(v56, []any{v11}) -var v53 any = v57 -_ = v53 -var v59 any -if lang.IsTruthy(v53) { -v59 = v53 -} else { -v60 := lang.NewVector(int64(0), int64(0)) -v61 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6740), lang.NewKeyword("column"), int(56), lang.NewKeyword("end-line"), int(6740), lang.NewKeyword("end-column"), int(60)) -v62, err := lang.WithMeta(v60, v61.(lang.IPersistentMap)) +v109 := v108.Get() +v110 := lang.Apply(v109, nil) +v102 = v110 +} +return v102 +}) +v101 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4611), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(4611), lang.NewKeyword("end-column"), int(58)) +v102, err := lang.WithMeta(v100, v101.(lang.IPersistentMap)) if err != nil { panic(err) } -v59 = v62 -} -var v52 any = v59 -_ = v52 -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("nth")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +v103 := lang.Apply(v99, []any{v102, v91}) +var v96 any = v103 +_ = v96 +v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v106 := v105.FindInternedVar(lang.NewSymbol("reduce1")) +if v106.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) } -v56 := v55.Get() -v57 := lang.Apply(v56, []any{v52, int64(0), nil}) -var v53 any = v57 -_ = v53 -v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v60 := v59.FindInternedVar(lang.NewSymbol("nth")) -if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) +v107 := v106.Get() +var v108 lang.FnFunc +v108 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v109 := args[0] +v110 := args[1] +var v111 any = v110 +_ = v111 +v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v114 := v113.FindInternedVar(lang.NewSymbol("nth")) +if v114.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) } -v61 := v60.Get() -v62 := lang.Apply(v61, []any{v52, int64(1), nil}) -var v58 any = v62 -_ = v58 -var v64 any -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("zero?")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +v115 := v114.Get() +v116 := lang.Apply(v115, []any{v111, int64(0), nil}) +var v112 any = v116 +_ = v112 +v118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v119 := v118.FindInternedVar(lang.NewSymbol("nth")) +if v119.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v119))) } -v67 := v66.Get() -v68 := lang.Apply(v67, []any{v58}) -if lang.IsTruthy(v68) { -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("case-map")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +v120 := v119.Get() +v121 := lang.Apply(v120, []any{v111, int64(1), nil}) +var v117 any = v121 +_ = v117 +v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v124 := v123.FindInternedVar(lang.NewSymbol("nth")) +if v124.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) } -v71 := v70.Get() -v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v73 := v72.FindInternedVar(lang.NewSymbol("identity")) -if v73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) +v125 := v124.Get() +v126 := lang.Apply(v125, []any{v111, int64(2), nil}) +var v122 any = v126 +_ = v122 +var v128 any +v129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v130 := v129.FindInternedVar(lang.NewSymbol("symbol?")) +if v130.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v130))) } -v74 := v73.Get() -v75 := lang.Apply(v71, []any{v7, v74, v5, v6}) -v76 := lang.NewVector(int64(0), int64(0), v75, lang.NewKeyword("sparse")) -v77 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6743), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(6743), lang.NewKeyword("end-column"), int(66)) -v78, err := lang.WithMeta(v76, v77.(lang.IPersistentMap)) -if err != nil { - panic(err) +v131 := v130.Get() +v132 := lang.Apply(v131, []any{v112}) +if lang.IsTruthy(v132) { +v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v134 := v133.FindInternedVar(lang.NewSymbol("conj")) +if v134.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) } -v64 = v78 +v135 := v134.Get() +v136 := lang.Apply(v135, []any{v109, v122, v117}) +v128 = v136 } else { -v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v80 := v79.FindInternedVar(lang.NewSymbol("case-map")) -if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) +v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v138 := v137.FindInternedVar(lang.NewSymbol("conj")) +if v138.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) } -v81 := v80.Get() -var v82 lang.FnFunc -v82 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v83 := args[0] -v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v85 := v84.FindInternedVar(lang.NewSymbol("shift-mask")) -if v85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) +v139 := v138.Get() +v140 := lang.Apply(v139, []any{v109, v122, v117, v112, v122}) +v128 = v140 } -v86 := v85.Get() -v87 := lang.Apply(v7, []any{v83}) -v88 := lang.Apply(v86, []any{v53, v58, v87}) -return v88 +return v128 }) -v83 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6745), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(6745), lang.NewKeyword("end-column"), int(71)) -v84, err := lang.WithMeta(v82, v83.(lang.IPersistentMap)) +v109 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4612), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(4615), lang.NewKeyword("end-column"), int(50)) +v110, err := lang.WithMeta(v108, v109.(lang.IPersistentMap)) if err != nil { panic(err) } -v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v86 := v85.FindInternedVar(lang.NewSymbol("identity")) -if v86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) -} -v87 := v86.Get() -v88 := lang.Apply(v81, []any{v84, v87, v5, v6}) -v89 := lang.NewVector(v53, v58, v88, lang.NewKeyword("compact")) -v90 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6745), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(6745), lang.NewKeyword("end-column"), int(103)) -v91, err := lang.WithMeta(v89, v90.(lang.IPersistentMap)) +v111 := lang.NewVector() +v112 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4616), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(4616), lang.NewKeyword("end-column"), int(28)) +v113, err := lang.WithMeta(v111, v112.(lang.IPersistentMap)) if err != nil { panic(err) } -v64 = v91 +v114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v115 := v114.FindInternedVar(lang.NewSymbol("map")) +if v115.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v115))) } -v37 = v64 +v116 := v115.Get() +v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v118 := v117.FindInternedVar(lang.NewSymbol("vector")) +if v118.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) } -v24 = v37 -} else { -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("merge-hash-collisions")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +v119 := v118.Get() +v120 := lang.Apply(v116, []any{v119, v91, v82, v96}) +v121 := lang.Apply(v107, []any{v110, v113, v120}) +var v104 any = v121 +_ = v104 +v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v124 := v123.FindInternedVar(lang.NewSymbol("seq")) +if v124.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) } -v55 := v54.Get() -v56 := lang.Apply(v55, []any{v3, v4, v5, v6}) -var v52 any = v56 -_ = v52 -v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v59 := v58.FindInternedVar(lang.NewSymbol("nth")) -if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) +v125 := v124.Get() +v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v127 := v126.FindInternedVar(lang.NewSymbol("concat")) +if v127.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) } -v60 := v59.Get() -v61 := lang.Apply(v60, []any{v52, int64(0), nil}) -var v57 any = v61 -_ = v57 -v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v64 := v63.FindInternedVar(lang.NewSymbol("nth")) -if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) +v128 := v127.Get() +v129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v130 := v129.FindInternedVar(lang.NewSymbol("list")) +if v130.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v130))) } -v65 := v64.Get() -v66 := lang.Apply(v65, []any{v52, int64(1), nil}) -var v62 any = v66 -_ = v62 -v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v69 := v68.FindInternedVar(lang.NewSymbol("nth")) -if v69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) +v131 := v130.Get() +v132 := lang.Apply(v131, []any{lang.NewSymbol("glojure.core/let")}) +v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v134 := v133.FindInternedVar(lang.NewSymbol("list")) +if v134.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) } -v70 := v69.Get() -v71 := lang.Apply(v70, []any{v52, int64(2), nil}) -var v67 any = v71 -_ = v67 -v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v74 := v73.FindInternedVar(lang.NewSymbol("prep-hashes")) -if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) +v135 := v134.Get() +v136 := lang.Apply(v135, []any{v104}) +v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v138 := v137.FindInternedVar(lang.NewSymbol("list")) +if v138.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) } -v75 := v74.Get() -v76 := lang.Apply(v75, []any{v3, v4, v57, v62}) -var v72 any = v76 -_ = v72 -v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v79 := v78.FindInternedVar(lang.NewSymbol("nth")) -if v79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) +v139 := v138.Get() +v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v141 := v140.FindInternedVar(lang.NewSymbol("seq")) +if v141.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) } -v80 := v79.Get() -v81 := lang.Apply(v80, []any{v72, int64(0), nil}) -var v77 any = v81 -_ = v77 -v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v84 := v83.FindInternedVar(lang.NewSymbol("nth")) -if v84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) +v142 := v141.Get() +v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v144 := v143.FindInternedVar(lang.NewSymbol("concat")) +if v144.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) } -v85 := v84.Get() -v86 := lang.Apply(v85, []any{v72, int64(1), nil}) -var v82 any = v86 -_ = v82 -v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v89 := v88.FindInternedVar(lang.NewSymbol("nth")) -if v89.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) +v145 := v144.Get() +v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v147 := v146.FindInternedVar(lang.NewSymbol("list")) +if v147.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) } -v90 := v89.Get() -v91 := lang.Apply(v90, []any{v72, int64(2), nil}) -var v87 any = v91 -_ = v87 -v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v94 := v93.FindInternedVar(lang.NewSymbol("nth")) -if v94.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) +v148 := v147.Get() +v149 := lang.Apply(v148, []any{lang.NewSymbol("loop*")}) +v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v151 := v150.FindInternedVar(lang.NewSymbol("list")) +if v151.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) } -v95 := v94.Get() -v96 := lang.Apply(v95, []any{v72, int64(3), nil}) -var v92 any = v96 -_ = v92 -var v98 any -v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v100 := v99.FindInternedVar(lang.NewSymbol("zero?")) -if v100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) +v152 := v151.Get() +v153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v154 := v153.FindInternedVar(lang.NewSymbol("vec")) +if v154.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v154))) } -v101 := v100.Get() -v102 := lang.Apply(v101, []any{v82}) -if lang.IsTruthy(v102) { -v98 = v97 -} else { -v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v104 := v103.FindInternedVar(lang.NewSymbol("into1")) -if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) +v155 := v154.Get() +v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v157 := v156.FindInternedVar(lang.NewSymbol("interleave")) +if v157.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) } -v105 := v104.Get() -v106 := lang.CreatePersistentTreeSet() -v107 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6751), lang.NewKeyword("column"), int(33), lang.NewKeyword("end-line"), int(6751), lang.NewKeyword("end-column"), int(35)) -v108, err := lang.WithMeta(v106, v107.(lang.IPersistentMap)) -if err != nil { - panic(err) +v158 := v157.Get() +v159 := lang.Apply(v158, []any{v96, v96}) +v160 := lang.Apply(v155, []any{v159}) +v161 := lang.Apply(v152, []any{v160}) +v162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v163 := v162.FindInternedVar(lang.NewSymbol("list")) +if v163.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v163))) } -v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v110 := v109.FindInternedVar(lang.NewSymbol("map")) -if v110.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) +v164 := v163.Get() +v165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v166 := v165.FindInternedVar(lang.NewSymbol("seq")) +if v166.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v166))) } -v111 := v110.Get() -var v112 lang.FnFunc -v112 = lang.NewFnFunc(func(args ...any) any { +v167 := v166.Get() +v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v169 := v168.FindInternedVar(lang.NewSymbol("concat")) +if v169.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) +} +v170 := v169.Get() +v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v172 := v171.FindInternedVar(lang.NewSymbol("list")) +if v172.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) +} +v173 := v172.Get() +v174 := lang.Apply(v173, []any{lang.NewSymbol("glojure.core/let")}) +v175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v176 := v175.FindInternedVar(lang.NewSymbol("list")) +if v176.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v176))) +} +v177 := v176.Get() +v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v179 := v178.FindInternedVar(lang.NewSymbol("vec")) +if v179.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) +} +v180 := v179.Get() +v181 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v182 := v181.FindInternedVar(lang.NewSymbol("interleave")) +if v182.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v182))) +} +v183 := v182.Get() +v184 := lang.Apply(v183, []any{v91, v96}) +v185 := lang.Apply(v180, []any{v184}) +v186 := lang.Apply(v177, []any{v185}) +v187 := lang.Apply(v170, []any{v174, v186, v6}) +v188 := lang.Apply(v167, []any{v187}) +v189 := lang.Apply(v164, []any{v188}) +v190 := lang.Apply(v145, []any{v149, v161, v189}) +v191 := lang.Apply(v142, []any{v190}) +v192 := lang.Apply(v139, []any{v191}) +v193 := lang.Apply(v128, []any{v132, v136, v192}) +v194 := lang.Apply(v125, []any{v193}) +v61 = v194 +} +return v61 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// macroexpand +{ +v0 := lang.NewSymbol("macroexpand").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("form"))), lang.NewKeyword("doc"), "Repeatedly calls macroexpand-1 on form until it no longer\n represents a macro form, then returns it. Note neither\n macroexpand-1 nor macroexpand expand macros in subforms.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4025), lang.NewKeyword("end-line"), int(4025))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v113 := args[0] -v114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v115 := v114.FindInternedVar(lang.NewSymbol("shift-mask")) -if v115.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v115))) +v3 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("macroexpand-1")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v116 := v115.Get() -v117 := lang.Apply(v116, []any{v77, v82, v113}) -return v117 -}) -v113 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6751), lang.NewKeyword("column"), int(42), lang.NewKeyword("end-line"), int(6751), lang.NewKeyword("end-column"), int(67)) -v114, err := lang.WithMeta(v112, v113.(lang.IPersistentMap)) -if err != nil { - panic(err) +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +var v4 any = v8 +_ = v4 +var v10 any +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("identical?")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v115 := lang.Apply(v111, []any{v114, v97}) -v116 := lang.Apply(v105, []any{v108, v115}) -v98 = v116 +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v4, v3}) +if lang.IsTruthy(v14) { +v10 = v3 +} else { +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("macroexpand")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } -var v97 any = v98 -_ = v97 -v118 := lang.NewVector(v77, v82, v87, v92, v97) -v119 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6752), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(6752), lang.NewKeyword("end-column"), int(52)) -v120, err := lang.WithMeta(v118, v119.(lang.IPersistentMap)) -if err != nil { - panic(err) +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v4}) +v10 = v18 } -v24 = v120 +return v10 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -return v24 +} +// macroexpand-1 +{ +v0 := lang.NewSymbol("macroexpand-1").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("form"))), lang.NewKeyword("doc"), "If form represents a macro form, returns its expansion,\n else returns form.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4017), lang.NewKeyword("end-line"), int(4017))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, _ := lang.FieldOrMethod(runtime9.Compiler, "macroexpand1") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("macroexpand1 is not a function"))) +} +v5 := lang.Apply(v4, []any{v3}) +return v5 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -49857,164 +49351,138 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// min-key +// make-array { -v0 := lang.NewSymbol("min-key").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Returns the x for which (k x), a number, is least.\n\n If there are multiple such xs, the last one is returned.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5033), lang.NewKeyword("end-line"), int(5033))).(*lang.Symbol) +v0 := lang.NewSymbol("make-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("type"), lang.NewSymbol("len")), lang.NewVector(lang.NewSymbol("type"), lang.NewSymbol("dim"), lang.NewSymbol("&"), lang.NewSymbol("more-dims"))), lang.NewKeyword("doc"), "Creates and returns an array of instances of the specified class of\n the specified dimension(s). Note that a class object is required.\n Class objects can be obtained by using their imported or\n fully-qualified name. Class objects for the primitive types can be\n obtained using, e.g., Integer/TYPE.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3985), lang.NewKeyword("end-line"), int(3985))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 2: v3 := args[0] v4 := args[1] -return v4 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -var v6 any -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("<")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("int")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v9 := v8.Get() -v10 := lang.Apply(v3, []any{v4}) -v11 := lang.Apply(v3, []any{v5}) -v12 := lang.Apply(v9, []any{v10, v11}) -if lang.IsTruthy(v12) { -v6 = v4 -} else { -v6 = v5 +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v4}) +v9, _ := lang.FieldOrMethod(nil, "newInstance") +if reflect.TypeOf(v9).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("newInstance is not a function"))) } -return v6 +v10 := lang.Apply(v9, []any{v3, v8}) +return v10 default: - if len(args) < 3 { + if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v8 := lang.Apply(v3, []any{v4}) -var v7 any = v8 -_ = v7 -v10 := lang.Apply(v3, []any{v5}) -var v9 any = v10 -_ = v9 -var v12 any -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("<")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +v5 := lang.NewList(args[2:]...) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("cons")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v7, v9}) -if lang.IsTruthy(v16) { -v17 := lang.NewVector(v4, v7) -v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5043), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(5043), lang.NewKeyword("end-column"), int(36)) -v19, err := lang.WithMeta(v17, v18.(lang.IPersistentMap)) -if err != nil { - panic(err) +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v4, v5}) +var v6 any = v10 +_ = v6 +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("make-array")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } -v12 = v19 -} else { -v20 := lang.NewVector(v5, v9) -v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5043), lang.NewKeyword("column"), int(38), lang.NewKeyword("end-line"), int(5043), lang.NewKeyword("end-column"), int(43)) -v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) -if err != nil { - panic(err) +v14 := v13.Get() +v15, ok := lang.FieldOrMethod(nil, "TYPE") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "TYPE"))) } -v12 = v22 +var v16 any +switch reflect.TypeOf(v15).Kind() { +case reflect.Func: + v16 = lang.Apply(v15, nil) +default: + v16 = v15 } -var v11 any = v12 +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("count")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v6}) +v21 := lang.Apply(v14, []any{v16, v20}) +var v11 any = v21 _ = v11 v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("nth")) +v25 := v24.FindInternedVar(lang.NewSymbol("long")) if v25.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } v26 := v25.Get() -v27 := lang.Apply(v26, []any{v11, int64(0), nil}) -var v23 any = v27 -_ = v23 -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("nth")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("alength")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v31 := v30.Get() -v32 := lang.Apply(v31, []any{v11, int64(1), nil}) -var v28 any = v32 -_ = v28 -var v34 any = v34 -_ = v34 -var v35 any = v35 -_ = v35 -var v36 any = v36 -_ = v36 -var v37 any +v29 := v28.Get() +v30 := lang.Apply(v29, []any{v11}) +v31 := lang.Apply(v26, []any{v30}) +var v23 any = v31 +_ = v23 +var v33 any = int64(0) +_ = v33 +var v34 any for { -var v38 any -if lang.IsTruthy(v36) { +var v35 any +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("<")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v33, v23}) +if lang.IsTruthy(v39) { v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("first")) +v41 := v40.FindInternedVar(lang.NewSymbol("aset-int")) if v41.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) } v42 := v41.Get() -v43 := lang.Apply(v42, []any{v36}) -var v39 any = v43 -_ = v39 -v45 := lang.Apply(v3, []any{v39}) -var v44 any = v45 -_ = v44 -var v47 any -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("<=")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v44, v35}) -if lang.IsTruthy(v51) { -var v52 any = v39 -var v53 any = v44 -v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v56 := v55.FindInternedVar(lang.NewSymbol("next")) -if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("nth")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) } -v57 := v56.Get() -v58 := lang.Apply(v57, []any{v36}) -var v54 any = v58 -v34 = v52 -v35 = v53 -v36 = v54 -continue -} else { -var v59 any = v34 -var v60 any = v35 -v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v63 := v62.FindInternedVar(lang.NewSymbol("next")) -if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +v45 := v44.Get() +v46 := lang.Apply(v45, []any{v6, v33}) +v47 := lang.Apply(v42, []any{v11, v33, v46}) +_ = v47 +v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v50 := v49.FindInternedVar(lang.NewSymbol("unchecked-inc")) +if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) } -v64 := v63.Get() -v65 := lang.Apply(v64, []any{v36}) -var v61 any = v65 -v34 = v59 -v35 = v60 -v36 = v61 +v51 := v50.Get() +v52 := lang.Apply(v51, []any{v33}) +var v48 any = v52 +v33 = v48 continue -} -v38 = v47 } else { -v38 = v34 +v35 = nil } -v37 = v38 +v34 = v35 break } -return v37 +_ = v34 +v23, _ := lang.FieldOrMethod(nil, "newInstance") +if reflect.TypeOf(v23).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("newInstance is not a function"))) +} +v24 := lang.Apply(v23, []any{v3, v11}) +return v24 } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -50023,27 +49491,39 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// future-cancelled? +// make-hierarchy { -v0 := lang.NewSymbol("future-cancelled?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Returns true if future f is cancelled", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7068), lang.NewKeyword("end-line"), int(7068))).(*lang.Symbol) +v0 := lang.NewSymbol("make-hierarchy").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Creates a hierarchy object for use with derive, isa? etc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5550), lang.NewKeyword("end-line"), int(5550))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { + if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := args[0] -v4, ok := lang.FieldOrMethod(v3, "isCancelled") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "isCancelled"))) +v3 := lang.NewMap() +v4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5554), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(5554), lang.NewKeyword("end-column"), int(17)) +v5, err := lang.WithMeta(v3, v4.(lang.IPersistentMap)) +if err != nil { + panic(err) } -var v5 any -switch reflect.TypeOf(v4).Kind() { -case reflect.Func: - v5 = lang.Apply(v4, nil) -default: - v5 = v4 +v6 := lang.NewMap() +v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5554), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(5554), lang.NewKeyword("end-column"), int(33)) +v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) +if err != nil { + panic(err) } -return v5 +v9 := lang.NewMap() +v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5554), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(5554), lang.NewKeyword("end-column"), int(47)) +v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v12 := lang.NewMap(lang.NewKeyword("parents"), v5, lang.NewKeyword("descendants"), v8, lang.NewKeyword("ancestors"), v11) +v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5554), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(5554), lang.NewKeyword("end-column"), int(48)) +v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v14 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -50051,489 +49531,712 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// long-array +// map { -var v1 lang.FnFunc -{ // function long-array__inliner -v1 = lang.NewFnFunc(func(args ...any) any { +v0 := lang.NewSymbol("map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2"), lang.NewSymbol("c3")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2"), lang.NewSymbol("c3"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Returns a lazy sequence consisting of the result of applying f to\n the set of first items of each coll, followed by applying f to the\n set of second items in each coll, until any one of the colls is\n exhausted. Any remaining items in other colls are ignored. Function\n f should accept number-of-colls arguments. Returns a transducer when\n no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2719), lang.NewKeyword("end-line"), int(2719))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +var v6 lang.FnFunc +v6 = lang.NewFnFunc(func(args ...any) any { switch len(args) { + case 0: +v7 := lang.Apply(v5, nil) +return v7 + case 1: +v7 := args[0] +v8 := lang.Apply(v5, []any{v7}) +return v8 + case 2: +v7 := args[0] +v8 := args[1] +v9 := lang.Apply(v3, []any{v8}) +v10 := lang.Apply(v5, []any{v7, v9}) +return v10 default: - if len(args) < 0 { + if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := lang.NewList(args[0:]...) -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v7 := args[0] +v8 := args[1] +v9 := lang.NewList(args[2:]...) +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("apply")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v6 := v5.Get() +v12 := v11.Get() +v13 := lang.Apply(v12, []any{v3, v8, v9}) +v14 := lang.Apply(v5, []any{v7, v13}) +return v14 + } +}) +v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2730), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(2736), lang.NewKeyword("end-column"), int(47)) +v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v8 +}) +v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2729), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2736), lang.NewKeyword("end-column"), int(48)) +v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v6 + case 2: +v3 := args[0] +v4 := args[1] +var v5 lang.FnFunc +v5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +v8 := v7.FindInternedVar(lang.NewSymbol("seq")) if v8.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v10 := lang.Apply(v9, []any{v4}) +var v6 any = v10 +_ = v6 +var v12 any +if lang.IsTruthy(v6) { +var v13 any = v6 +_ = v13 +var v15 any +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("chunked-seq?")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v13}) +if lang.IsTruthy(v19) { +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("chunk-first")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v13}) +var v20 any = v24 +_ = v20 +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("int")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) } -v20 := v19.Get() -v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/longArray")}) -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("list")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("count")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) } -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("seq")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +v31 := v30.Get() +v32 := lang.Apply(v31, []any{v20}) +v33 := lang.Apply(v28, []any{v32}) +var v25 any = v33 +_ = v25 +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("chunk-buffer")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) } -v27 := v26.Get() +v37 := v36.Get() +v38 := lang.Apply(v37, []any{v25}) +var v34 any = v38 +_ = v34 +v41 := lang.Apply(lang1.LongCast, []any{v25}) +var v40 any = v41 +_ = v40 +var v43 any = int64(0) +_ = v43 +var v44 any +for { +var v45 any +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("<")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +} +v48 := v47.Get() +v49 := lang.Apply(v48, []any{v43, v40}) +if lang.IsTruthy(v49) { +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("chunk-append")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +} +v52 := v51.Get() +v53, _ := lang.FieldOrMethod(v20, "nth") +if reflect.TypeOf(v53).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) +} +v54 := lang.Apply(v53, []any{v43}) +v55 := lang.Apply(v3, []any{v54}) +v56 := lang.Apply(v52, []any{v34, v55}) +_ = v56 +v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v59 := v58.FindInternedVar(lang.NewSymbol("unchecked-inc")) +if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) +} +v60 := v59.Get() +v61 := lang.Apply(v60, []any{v43}) +var v57 any = v61 +v43 = v57 +continue +} else { +v45 = nil +} +v44 = v45 + break +} +_ = v44 +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("chunk-cons")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("chunk")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +} +v45 := v44.Get() +v46 := lang.Apply(v45, []any{v34}) +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("map")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +} +v49 := v48.Get() +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("chunk-rest")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +} +v52 := v51.Get() +v53 := lang.Apply(v52, []any{v13}) +v54 := lang.Apply(v49, []any{v3, v53}) +v55 := lang.Apply(v42, []any{v46, v54}) +v15 = v55 +} else { +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("cons")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("first")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{v13}) +v27 := lang.Apply(v3, []any{v26}) v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("concat")) +v29 := v28.FindInternedVar(lang.NewSymbol("map")) if v29.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } v30 := v29.Get() v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) +v32 := v31.FindInternedVar(lang.NewSymbol("rest")) if v32.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } v33 := v32.Get() -v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("list")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.Apply(v37, []any{lang.NewSymbol("glojure.core/args")}) -v39 := lang.Apply(v30, []any{v34, v38}) -v40 := lang.Apply(v27, []any{v39}) -v41 := lang.Apply(v24, []any{v40}) -v42 := lang.Apply(v9, []any{v13, v17, v21, v41}) -v43 := lang.Apply(v6, []any{v42}) -return v43 - } -}) -v2 := v1 -_ = v2 +v34 := lang.Apply(v33, []any{v13}) +v35 := lang.Apply(v30, []any{v3, v34}) +v36 := lang.Apply(v22, []any{v27, v35}) +v15 = v36 } -v0 := lang.NewSymbol("long-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Creates an array of longs", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5364), lang.NewKeyword("end-line"), int(5364))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "longArray") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("longArray is not a function"))) +v12 = v15 +} else { +v12 = nil } -v6 := lang.Apply(v5, []any{v4}) +return v12 +}) +v6 := lang.Apply(lang1.NewLazySeq, []any{v5}) return v6 - case 2: -v4 := args[0] -v5 := args[1] -v6, _ := lang.FieldOrMethod(lang1.Numbers, "longArrayInit") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("longArrayInit is not a function"))) -} -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 - default: + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +var v6 lang.FnFunc +v6 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("seq")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v4}) +var v7 any = v11 +_ = v7 +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("seq")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } -// unchecked-remainder-int -{ -var v1 lang.FnFunc -{ // function unchecked-remainder-int__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v5}) +var v12 any = v16 +_ = v12 +var v18 any +var v19 any = v7 +_ = v19 +var v21 any +if lang.IsTruthy(v19) { +v21 = v12 +} else { +v21 = v19 +} +if lang.IsTruthy(v21) { +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("cons")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("first")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v7}) +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("first")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.Apply(v28, []any{v12}) +v30 := lang.Apply(v3, []any{v25, v29}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("map")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("rest")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.Apply(v36, []any{v7}) +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("rest")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.Apply(v40, []any{v12}) +v42 := lang.Apply(v33, []any{v3, v37, v41}) +v43 := lang.Apply(v21, []any{v30, v42}) +v18 = v43 +} else { +v18 = nil +} +return v18 +}) +v7 := lang.Apply(lang1.NewLazySeq, []any{v6}) +return v7 + case 4: v3 := args[0] v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("concat")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("list")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v5 := args[2] +v6 := args[3] +var v7 lang.FnFunc +v7 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("seq")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -v13 := v12.Get() -v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v4}) +var v8 any = v12 +_ = v8 +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("seq")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v5}) +var v13 any = v17 +_ = v13 v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) +v20 := v19.FindInternedVar(lang.NewSymbol("seq")) if v20.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("seq")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v22 := lang.Apply(v21, []any{v6}) +var v18 any = v22 +_ = v18 +var v24 any +var v25 any = v8 +_ = v25 +var v27 any +if lang.IsTruthy(v25) { +var v28 any = v13 +_ = v28 +var v30 any +if lang.IsTruthy(v28) { +v30 = v18 +} else { +v30 = v28 } -v24 := v23.Get() +v27 = v30 +} else { +v27 = v25 +} +if lang.IsTruthy(v27) { v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("concat")) +v26 := v25.FindInternedVar(lang.NewSymbol("cons")) if v26.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } v27 := v26.Get() v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("list")) +v29 := v28.FindInternedVar(lang.NewSymbol("first")) if v29.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } v30 := v29.Get() -v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/unchecked_int_remainder")}) +v31 := lang.Apply(v30, []any{v8}) v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) +v33 := v32.FindInternedVar(lang.NewSymbol("first")) if v33.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) } v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) +v35 := lang.Apply(v34, []any{v13}) v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) +v37 := v36.FindInternedVar(lang.NewSymbol("first")) if v37.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) } v38 := v37.Get() -v39 := lang.Apply(v38, []any{v4}) -v40 := lang.Apply(v27, []any{v31, v35, v39}) -v41 := lang.Apply(v24, []any{v40}) -v42 := lang.Apply(v21, []any{v41}) -v43 := lang.Apply(v10, []any{v14, v18, v42}) -v44 := lang.Apply(v7, []any{v43}) -return v44 -}) -v2 := v1 -_ = v2 +v39 := lang.Apply(v38, []any{v18}) +v40 := lang.Apply(v3, []any{v31, v35, v39}) +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("map")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } -v0 := lang.NewSymbol("unchecked-remainder-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the remainder of division of x by y, both int.\n Note - uses a primitive operator subject to truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(29), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1245), lang.NewKeyword("end-line"), int(1245))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6, _ := lang.FieldOrMethod(lang1.Numbers, "unchecked_int_remainder") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_remainder is not a function"))) +v43 := v42.Get() +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("rest")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v8}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("rest")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) } +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v13}) +v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v53 := v52.FindInternedVar(lang.NewSymbol("rest")) +if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) } -// to-array-2d -{ -v0 := lang.NewSymbol("to-array-2d").WithMeta(lang.NewMap(lang.NewKeyword("tag"), "[[Ljava.lang.Object;", lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a (potentially-ragged) 2-dimensional array of Objects\n containing the contents of coll, which can be any Collection of any\n Collection.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4002), lang.NewKeyword("end-line"), int(4002))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { +v54 := v53.Get() +v55 := lang.Apply(v54, []any{v18}) +v56 := lang.Apply(v43, []any{v3, v47, v51, v55}) +v57 := lang.Apply(v27, []any{v40, v56}) +v24 = v57 +} else { +v24 = nil +} +return v24 +}) +v8 := lang.Apply(lang1.NewLazySeq, []any{v7}) +return v8 + default: + if len(args) < 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := lang.NewList(args[4:]...) +var v9 lang.FnFunc +{ // function step +v9 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("make-array")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8, _ := lang.FieldOrMethod(reflect.Type, "forName") -if reflect.TypeOf(v8).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("forName is not a function"))) +v11 := args[0] +var v12 lang.FnFunc +v12 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("map")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v9 := lang.Apply(v8, []any{"[Ljava.lang.Object;"}) -v10, _ := lang.FieldOrMethod(v3, "size") -if reflect.TypeOf(v10).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("size is not a function"))) +v16 := v15.Get() +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v11 := lang.Apply(v10, []any{}) -v12 := lang.Apply(v7, []any{v9, v11}) -var v4 any = v12 -_ = v4 -var v14 any = int64(0) -_ = v14 -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("seq")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +v19 := v18.Get() +v20 := lang.Apply(v16, []any{v19, v11}) +var v13 any = v20 +_ = v13 +var v22 any +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("every?")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v3}) -var v15 any = v19 -_ = v15 -var v20 any -for { -var v21 any -if lang.IsTruthy(v15) { -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("aset")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("identity")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) } -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("to-array")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +v28 := v27.Get() +v29 := lang.Apply(v25, []any{v28, v13}) +if lang.IsTruthy(v29) { +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("cons")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) } -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("first")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("map")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) } -v30 := v29.Get() -v31 := lang.Apply(v30, []any{v15}) -v32 := lang.Apply(v27, []any{v31}) -v33 := lang.Apply(v24, []any{v4, v14, v32}) -_ = v33 -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("inc")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +v35 := v34.Get() +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("first")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) } -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v14}) -var v34 any = v38 +v38 := v37.Get() +v39 := lang.Apply(v35, []any{v38, v13}) v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("next")) +v41 := v40.FindInternedVar(lang.NewSymbol("map")) if v41.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) } v42 := v41.Get() -v43 := lang.Apply(v42, []any{v15}) -var v39 any = v43 -v14 = v34 -v15 = v39 -continue -} else { -v21 = nil +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("rest")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) } -v20 = v21 - break +v45 := v44.Get() +v46 := lang.Apply(v42, []any{v45, v13}) +v47 := lang.Apply(v10, []any{v46}) +v48 := lang.Apply(v32, []any{v39, v47}) +v22 = v48 +} else { +v22 = nil } -_ = v20 -return v4 +return v22 }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), "[[Ljava.lang.Object;")).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// with-redefs -{ -v0 := lang.NewSymbol("with-redefs").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "binding => var-symbol temp-value-expr\n\n Temporarily redefines Vars while executing the body. The\n temp-value-exprs will be evaluated and each resulting value will\n replace in parallel the root value of its Var. After the body is\n executed, the root values of all the Vars will be set back to their\n old values. These temporary changes will be visible in all threads.\n Useful for mocking out functions during testing.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7587), lang.NewKeyword("end-line"), int(7587))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("seq")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v13 := lang.Apply(lang1.NewLazySeq, []any{v12}) +return v13 +}) +v10 := v9 +_ = v10 } -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("concat")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2761), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(2765), lang.NewKeyword("end-column"), int(68)) +v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v12 := v11.Get() +var v8 any = v11 +_ = v8 v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("list")) +v14 := v13.FindInternedVar(lang.NewSymbol("map")) if v14.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } v15 := v14.Get() -v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/with-redefs-fn")}) -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("list")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("zipmap")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("map")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -var v26 lang.FnFunc -v26 = lang.NewFnFunc(func(args ...any) any { +var v16 lang.FnFunc +v16 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v27 := args[0] -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("list")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +v17 := args[0] +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("apply")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v30 := v29.Get() -v31 := lang.Apply(v30, []any{lang.NewSymbol("var"), v27}) -return v31 +v20 := v19.Get() +v21 := lang.Apply(v20, []any{v3, v17}) +return v21 }) -v27 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7598), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(7598), lang.NewKeyword("end-column"), int(47)) -v28, err := lang.WithMeta(v26, v27.(lang.IPersistentMap)) +v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2766), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(2766), lang.NewKeyword("end-column"), int(22)) +v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) if err != nil { panic(err) } -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("take-nth")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("conj")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v31 := v30.Get() -v32 := lang.Apply(v31, []any{int64(2), v5}) -v33 := lang.Apply(v25, []any{v28, v32}) -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("take-nth")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v7, v6, v5, v4}) +v23 := lang.Apply(v8, []any{v22}) +v24 := lang.Apply(v15, []any{v18, v23}) +return v24 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("next")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v5}) -v41 := lang.Apply(v36, []any{int64(2), v40}) -v42 := lang.Apply(v22, []any{v33, v41}) -v43 := lang.Apply(v19, []any{v42}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +// map-entry? +{ +v0 := lang.NewSymbol("map-entry?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a map entry", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.8", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1473), lang.NewKeyword("end-line"), int(1473))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v46 := v45.Get() -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("seq")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +v6 := v5.Get() +v7 := lang.Apply(v6, []any{java.util26.Map$Entry, v3}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v49 := v48.Get() -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("concat")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) } -v52 := v51.Get() -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("list")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +// map-indexed +{ +v0 := lang.NewSymbol("map-indexed").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence consisting of the result of applying f to 0\n and the first item of coll, followed by applying f to 1 and the second\n item in coll, etc, until coll is exhausted. Thus function f should\n accept 2 arguments, index and item. Returns a stateful transducer when\n no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7352), lang.NewKeyword("end-line"), int(7352))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("volatile!")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v55 := v54.Get() -v56 := lang.Apply(v55, []any{lang.NewSymbol("glojure.core/fn")}) -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("list")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +v9 := v8.Get() +v10 := lang.Apply(v9, []any{int64(-1)}) +var v6 any = v10 +_ = v6 +var v12 lang.FnFunc +v12 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v13 := lang.Apply(v5, nil) +return v13 + case 1: +v13 := args[0] +v14 := lang.Apply(v5, []any{v13}) +return v14 + case 2: +v13 := args[0] +v14 := args[1] +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("inc")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18, ok := lang.FieldOrMethod(v6, "Deref") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "Deref"))) } -v59 := v58.Get() -v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v61 := v60.FindInternedVar(lang.NewSymbol("apply")) -if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) +var v19 any +switch reflect.TypeOf(v18).Kind() { +case reflect.Func: + v19 = lang.Apply(v18, nil) +default: + v19 = v18 } -v62 := v61.Get() -v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v64 := v63.FindInternedVar(lang.NewSymbol("vector")) -if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) +v20 := lang.Apply(v17, []any{v19}) +v21, _ := lang.FieldOrMethod(v6, "reset") +if reflect.TypeOf(v21).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) } -v65 := v64.Get() -v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v67 := v66.FindInternedVar(lang.NewSymbol("seq")) -if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) +v22 := lang.Apply(v21, []any{v20}) +v23 := lang.Apply(v3, []any{v22, v14}) +v24 := lang.Apply(v5, []any{v13, v23}) +return v24 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7363), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7367), lang.NewKeyword("end-column"), int(48)) +v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v68 := v67.Get() -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("concat")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +return v14 +}) +v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7361), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7367), lang.NewKeyword("end-column"), int(50)) +v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v71 := v70.Get() -v72 := lang.Apply(v71, nil) -v73 := lang.Apply(v68, []any{v72}) -v74 := lang.Apply(v62, []any{v65, v73}) -v75 := lang.Apply(v59, []any{v74}) -v76 := lang.Apply(v52, []any{v56, v75, v6}) -v77 := lang.Apply(v49, []any{v76}) -v78 := lang.Apply(v46, []any{v77}) -v79 := lang.Apply(v12, []any{v16, v43, v78}) -v80 := lang.Apply(v9, []any{v79}) -return v80 +return v6 + case 2: +v3 := args[0] +v4 := args[1] +return nil + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -50542,86 +50245,97 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// vec +// map? { -v0 := lang.NewSymbol("vec").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Creates a new vector containing the contents of coll. Java arrays\n will be aliased and should not be modified.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(366), lang.NewKeyword("end-line"), int(366))).(*lang.Symbol) +v0 := lang.NewSymbol("map?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x implements IPersistentMap", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(167), lang.NewKeyword("end-line"), int(171))).(*lang.Symbol) var v2 lang.FnFunc +{ // function map? v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := args[0] -var v4 any +v4 := args[0] v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("vector?")) +v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) if v6.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -if lang.IsTruthy(v8) { -var v9 any -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("instance?")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang1.IObj, v3}) -if lang.IsTruthy(v13) { -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("with-meta")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v3, nil}) -v9 = v17 -} else { -v18 := lang.Apply(lang1.CreateLazilyPersistentVector, []any{v3}) -v9 = v18 -} -v4 = v9 -} else { -v19 := lang.Apply(lang1.CreateLazilyPersistentVector, []any{v3}) -v4 = v19 -} -return v4 +v8 := lang.Apply(v7, []any{lang1.IPersistentMap, v4}) +return v8 }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(171), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(171), lang.NewKeyword("end-column"), int(97))).(lang.FnFunc) +v3 := v2 +_ = v3 +} v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// ns-aliases +// mapcat { -v0 := lang.NewSymbol("ns-aliases").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of the aliases for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4273), lang.NewKeyword("end-line"), int(4273))).(*lang.Symbol) +v0 := lang.NewSymbol("mapcat").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Returns the result of applying concat to the result of applying map\n to f and colls. Thus function f should return a collection. Returns\n a transducer when no collections are provided", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2775), lang.NewKeyword("end-line"), int(2775))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + switch len(args) { + case 1: v3 := args[0] v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("the-ns")) +v5 := v4.FindInternedVar(lang.NewSymbol("comp")) if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -v7 := lang.Apply(v6, []any{v3}) -v8, ok := lang.FieldOrMethod(v7, "getAliases") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "getAliases"))) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("map")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -var v9 any -switch reflect.TypeOf(v8).Kind() { -case reflect.Func: - v9 = lang.Apply(v8, nil) -default: - v9 = v8 +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v3}) +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("cat")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -return v9 +v13 := v12.Get() +v14 := lang.Apply(v6, []any{v10, v13}) +return v14 + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.NewList(args[1:]...) +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("apply")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("concat")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("apply")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("map")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v13, []any{v16, v3, v4}) +v18 := lang.Apply(v7, []any{v10, v17}) +return v18 + } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -50629,59 +50343,152 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// aset-long +// mapv { -v0 := lang.NewSymbol("aset-long").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of long. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3951), lang.NewKeyword("end-line"), int(3953))).(*lang.Symbol) +v0 := lang.NewSymbol("mapv").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2"), lang.NewSymbol("c3")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2"), lang.NewSymbol("c3"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Returns a vector consisting of the result of applying f to the\n set of first items of each coll, followed by applying f to the set\n of second items in each coll, until any one of the colls is\n exhausted. Any remaining items in other colls are ignored. Function\n f should accept number-of-colls arguments.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6986), lang.NewKeyword("end-line"), int(6986))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { + case 2: +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("persistent!")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("reduce")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +var v11 lang.FnFunc +v11 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v12 := args[0] +v13 := args[1] +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("conj!")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v3, []any{v13}) +v18 := lang.Apply(v16, []any{v12, v17}) +return v18 +}) +v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6995), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(6995), lang.NewKeyword("end-column"), int(43)) +v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("transient")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.NewVector() +v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6995), lang.NewKeyword("column"), int(56), lang.NewKeyword("end-line"), int(6995), lang.NewKeyword("end-column"), int(57)) +v19, err := lang.WithMeta(v17, v18.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v20 := lang.Apply(v16, []any{v19}) +v21 := lang.Apply(v10, []any{v13, v20, v4}) +v22 := lang.Apply(v7, []any{v21}) +return v22 case 3: v3 := args[0] v4 := args[1] v5 := args[2] v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("long")) +v7 := v6.FindInternedVar(lang.NewSymbol("into")) if v7.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } v8 := v7.Get() -v9 := lang.Apply(v8, []any{v5}) -v10, _ := lang.FieldOrMethod(nil, "setLong") -if reflect.TypeOf(v10).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setLong is not a function"))) +v9 := lang.NewVector() +v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6998), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(6998), lang.NewKeyword("end-column"), int(13)) +v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v11 := lang.Apply(v10, []any{v3, v4, v9}) -_ = v11 -return v5 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("map")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v3, v4, v5}) +v16 := lang.Apply(v8, []any{v11, v15}) +return v16 + case 4: v3 := args[0] v4 := args[1] v5 := args[2] -v6 := lang.NewList(args[3:]...) +v6 := args[3] v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("apply")) +v8 := v7.FindInternedVar(lang.NewSymbol("into")) if v8.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("aset-long")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v10 := lang.NewVector() +v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7000), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(7000), lang.NewKeyword("end-column"), int(13)) +v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v12 := v11.Get() v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("aget")) +v14 := v13.FindInternedVar(lang.NewSymbol("map")) if v14.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } v15 := v14.Get() -v16 := lang.Apply(v15, []any{v3, v4}) -v17 := lang.Apply(v9, []any{v12, v16, v5, v6}) +v16 := lang.Apply(v15, []any{v3, v4, v5, v6}) +v17 := lang.Apply(v9, []any{v12, v16}) return v17 + default: + if len(args) < 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := lang.NewList(args[4:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("into")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.NewVector() +v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7002), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(7002), lang.NewKeyword("end-column"), int(13)) +v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("apply")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("map")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v16, []any{v19, v3, v4, v5, v6, v7}) +v21 := lang.Apply(v10, []any{v13, v20}) +return v21 } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -50690,67 +50497,71 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// == +// max { var v1 lang.FnFunc -{ // function ==__inliner v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] + switch len(args) { + case 1: +v2 := args[0] +var v4 any v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) if v6.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("concat")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +if lang.IsTruthy(v7) { +v4 = closed11 +} else { +v4 = v3 } -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("list")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +var v3 any = v4 +_ = v3 +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("seq")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -v13 := v12.Get() -v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("concat")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v16 := v15.FindInternedVar(lang.NewSymbol("list")) if v16.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v20 := v19.FindInternedVar(lang.NewSymbol("list")) if v20.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("seq")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("concat")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("seq")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) } -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("list")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("concat")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) } -v30 := v29.Get() -v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/equiv")}) +v31 := v30.Get() v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v33 := v32.FindInternedVar(lang.NewSymbol("list")) if v33.IsMacro() { @@ -50764,347 +50575,511 @@ if v37.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) } v38 := v37.Get() -v39 := lang.Apply(v38, []any{v4}) -v40 := lang.Apply(v27, []any{v31, v35, v39}) -v41 := lang.Apply(v24, []any{v40}) -v42 := lang.Apply(v21, []any{v41}) -v43 := lang.Apply(v10, []any{v14, v18, v42}) -v44 := lang.Apply(v7, []any{v43}) +v39 := lang.Apply(v38, []any{v2}) +v40 := lang.Apply(v31, []any{v35, v39}) +v41 := lang.Apply(v28, []any{v40}) +v42 := lang.Apply(v25, []any{v41}) +v43 := lang.Apply(v14, []any{v18, v22, v42}) +v44 := lang.Apply(v11, []any{v43}) return v44 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("==").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns non-nil if nums all have the equivalent\n value (type-independent), otherwise false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1093), lang.NewKeyword("end-line"), int(1093))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v4 := args[0] -return true case 2: -v4 := args[0] -v5 := args[1] -v6, _ := lang.FieldOrMethod(lang1.Numbers, "equiv") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("equiv is not a function"))) +v2 := args[0] +v3 := args[1] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6 := lang.NewList(args[2:]...) -recur_loop_206: -var v7 any -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("==")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v8 := v7.Get() +if lang.IsTruthy(v8) { +v5 = closed11 +} else { +v5 = v4 } -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v4, v5}) -if lang.IsTruthy(v11) { -var v12 any +var v4 any = v5 +_ = v4 +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("seq")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("next")) +v14 := v13.FindInternedVar(lang.NewSymbol("concat")) if v14.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } v15 := v14.Get() -v16 := lang.Apply(v15, []any{v6}) -if lang.IsTruthy(v16) { -var v17 any = v5 -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("first")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v6}) -var v18 any = v22 -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("next")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v6}) -var v23 any = v27 -v4 = v17 -v5 = v18 -v6 = v23 -goto recur_loop_206 -} else { -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("==")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("first")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("list")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v6}) -v35 := lang.Apply(v30, []any{v5, v34}) -v12 = v35 +v18 := v17.Get() +v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("list")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v7 = v12 -} else { -v7 = false +v22 := v21.Get() +v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("list")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -return v7 - } -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("seq")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } +v29 := v28.Get() +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("concat")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) } -// *assert* -{ -v0 := lang.NewSymbol("*assert*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "When set to logical false, 'assert' will omit assertion checks in\n compiled code. Defaults to true.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, false, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("list")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) } +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v4}) +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("list")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -// *verbose-defrecords* -{ -v0 := lang.NewSymbol("*verbose-defrecords*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(37), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(37), lang.NewKeyword("end-column"), int(35), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, false, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v2}) +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("list")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v3}) +v45 := lang.Apply(v32, []any{v36, v40, v44}) +v46 := lang.Apply(v29, []any{v45}) +v47 := lang.Apply(v26, []any{v46}) +v48 := lang.Apply(v15, []any{v19, v23, v47}) +v49 := lang.Apply(v12, []any{v48}) +return v49 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v2 := args[0] +v3 := args[1] +v4 := lang.NewList(args[2:]...) +var v6 any +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -// simple-symbol? -{ -v0 := lang.NewSymbol("simple-symbol?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a symbol without a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1623), lang.NewKeyword("end-line"), int(1623))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("symbol?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v9 := v8.Get() +if lang.IsTruthy(v9) { +v6 = closed11 +} else { +v6 = v5 } -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -var v4 any = v8 -_ = v4 -var v10 any -if lang.IsTruthy(v4) { +var v5 any = v6 +_ = v5 v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("nil?")) +v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) if v12.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("namespace")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +var v14 lang.FnFunc +v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v15 := args[0] +v16 := args[1] +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v3}) -v18 := lang.Apply(v13, []any{v17}) -v10 = v18 -} else { -v10 = v4 +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -return v10 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -// short-array -{ -var v1 lang.FnFunc -{ // function short-array__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewList(args[0:]...) -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v5}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } -v20 := v19.Get() -v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/shortArray")}) -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("list")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v15}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) } -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("seq")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v16}) +v52 := lang.Apply(v39, []any{v43, v47, v51}) +v53 := lang.Apply(v36, []any{v52}) +v54 := lang.Apply(v33, []any{v53}) +v55 := lang.Apply(v22, []any{v26, v30, v54}) +v56 := lang.Apply(v19, []any{v55}) +return v56 +}) +v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) +v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("concat")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v30 := v29.Get() +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v32 := v31.FindInternedVar(lang.NewSymbol("list")) if v32.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } v33 := v32.Get() -v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("list")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } -v37 := v36.Get() -v38 := lang.Apply(v37, []any{lang.NewSymbol("glojure.core/args")}) -v39 := lang.Apply(v30, []any{v34, v38}) -v40 := lang.Apply(v27, []any{v39}) -v41 := lang.Apply(v24, []any{v40}) -v42 := lang.Apply(v9, []any{v13, v17, v21, v41}) -v43 := lang.Apply(v6, []any{v42}) -return v43 +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v5}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v2}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v3}) +v52 := lang.Apply(v39, []any{v43, v47, v51}) +v53 := lang.Apply(v36, []any{v52}) +v54 := lang.Apply(v33, []any{v53}) +v55 := lang.Apply(v22, []any{v26, v30, v54}) +v56 := lang.Apply(v19, []any{v55}) +v57 := lang.Apply(v13, []any{v16, v56, v4}) +return v57 } }) -v2 := v1 -_ = v2 +v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } -v0 := lang.NewSymbol("short-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Creates an array of shorts", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)int64(2)), lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5333), lang.NewKeyword("end-line"), int(5333))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { +v5 := lang.Apply(v4, []any{v3, int64(1)}) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v0 := lang.NewSymbol("max").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the greatest of the nums.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1108), lang.NewKeyword("end-line"), int(1108))).(*lang.Symbol) +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: -v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "shortArray") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("shortArray is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 +v5 := args[0] +return v5 case 2: -v4 := args[0] -v5 := args[1] -v6, _ := lang.FieldOrMethod(lang1.Numbers, "shortArrayInit") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("shortArrayInit is not a function"))) +v5 := args[0] +v6 := args[1] +v7, _ := lang.FieldOrMethod(lang1.Numbers, "max") +if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("max is not a function"))) } -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 +v8 := lang.Apply(v7, []any{v5, v6}) +return v8 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +v6 := args[1] +v7 := lang.NewList(args[2:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("max")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("max")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v5, v6}) +v18 := lang.Apply(v10, []any{v13, v17, v7}) +return v18 } }) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) +v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v3 := ns.InternWithValue(v0, v4, true) if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + v3.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// dissoc! +// max-key { -v0 := lang.NewSymbol("dissoc!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"), lang.NewSymbol("&"), lang.NewSymbol("ks"))), lang.NewKeyword("doc"), "Returns a transient map that doesn't contain a mapping for key(s).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3382), lang.NewKeyword("end-line"), int(3382))).(*lang.Symbol) +v0 := lang.NewSymbol("max-key").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Returns the x for which (k x), a number, is greatest.\n\n If there are multiple such xs, the last one is returned.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5013), lang.NewKeyword("end-line"), int(5013))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 2: v3 := args[0] v4 := args[1] -v5, _ := lang.FieldOrMethod(v3, "without") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("without is not a function"))) +return v4 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +var v6 any +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol(">")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v3, []any{v4}) +v11 := lang.Apply(v3, []any{v5}) +v12 := lang.Apply(v9, []any{v10, v11}) +if lang.IsTruthy(v12) { +v6 = v4 +} else { +v6 = v5 } -v6 := lang.Apply(v5, []any{v4}) return v6 default: - if len(args) < 2 { + if len(args) < 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] v4 := args[1] -v5 := lang.NewList(args[2:]...) -recur_loop_611: -v7, _ := lang.FieldOrMethod(v3, "without") -if reflect.TypeOf(v7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("without is not a function"))) +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v8 := lang.Apply(v3, []any{v4}) +var v7 any = v8 +_ = v7 +v10 := lang.Apply(v3, []any{v5}) +var v9 any = v10 +_ = v9 +var v12 any +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol(">")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v7, v9}) +if lang.IsTruthy(v16) { +v17 := lang.NewVector(v4, v7) +v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5023), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(5023), lang.NewKeyword("end-column"), int(36)) +v19, err := lang.WithMeta(v17, v18.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v12 = v19 +} else { +v20 := lang.NewVector(v5, v9) +v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5023), lang.NewKeyword("column"), int(38), lang.NewKeyword("end-line"), int(5023), lang.NewKeyword("end-column"), int(43)) +v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v12 = v22 +} +var v11 any = v12 +_ = v11 +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("nth")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v11, int64(0), nil}) +var v23 any = v27 +_ = v23 +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("nth")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.Apply(v31, []any{v11, int64(1), nil}) +var v28 any = v32 +_ = v28 +var v34 any = v34 +_ = v34 +var v35 any = v35 +_ = v35 +var v36 any = v36 +_ = v36 +var v37 any +for { +var v38 any +if lang.IsTruthy(v36) { +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("first")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v36}) +var v39 any = v43 +_ = v39 +v45 := lang.Apply(v3, []any{v39}) +var v44 any = v45 +_ = v44 +var v47 any +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol(">=")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) } -v8 := lang.Apply(v7, []any{v4}) -var v6 any = v8 -_ = v6 -var v10 any -if lang.IsTruthy(v5) { -var v11 any = v6 -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("first")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v44, v35}) +if lang.IsTruthy(v51) { +var v52 any = v39 +var v53 any = v44 +v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v56 := v55.FindInternedVar(lang.NewSymbol("next")) +if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) } -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v5}) -var v12 any = v16 -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("next")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v57 := v56.Get() +v58 := lang.Apply(v57, []any{v36}) +var v54 any = v58 +v34 = v52 +v35 = v53 +v36 = v54 +continue +} else { +var v59 any = v34 +var v60 any = v35 +v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v63 := v62.FindInternedVar(lang.NewSymbol("next")) +if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) } -v20 := v19.Get() -v21 := lang.Apply(v20, []any{v5}) -var v17 any = v21 -v3 = v11 -v4 = v12 -v5 = v17 -goto recur_loop_611 +v64 := v63.Get() +v65 := lang.Apply(v64, []any{v36}) +var v61 any = v65 +v34 = v59 +v35 = v60 +v36 = v61 +continue +} +v38 = v47 } else { -v10 = v6 +v38 = v34 } -return v10 +v37 = v38 + break +} +return v37 } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -51113,454 +51088,255 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// ref +// max-mask-bits { -v0 := lang.NewSymbol("ref").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Creates and returns a Ref with an initial value of x and zero or\n more options (in any order):\n\n :meta metadata-map\n\n :validator validate-fn\n\n :min-history (default 0)\n :max-history (default 10)\n\n If metadata-map is supplied, it will become the metadata on the\n ref. validate-fn must be nil or a side-effect-free fn of one\n argument, which will be passed the intended new state on any state\n change. If the new state is unacceptable, the validate-fn should\n return false or throw an exception. validate-fn will be called on\n transaction commit, when all refs have their final values.\n\n Normally refs accumulate history dynamically as needed to deal with\n read demands. If you know in advance you will need history you can\n set :min-history to ensure it will be available when first needed (instead\n of after a read fault). History is limited, and the limit can be set\n with :max-history.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2260), lang.NewKeyword("end-line"), int(2260))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -v4 := lang.Apply(lang1.NewRef, []any{v3}) -return v4 - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.NewList(args[1:]...) -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("setup-reference")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("ref")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v3}) -v13 := lang.Apply(v8, []any{v12, v4}) -var v5 any = v13 -_ = v5 -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("apply")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("hash-map")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v17, []any{v20, v4}) -var v14 any = v21 -_ = v14 -var v23 any -v24 := lang.Apply(lang.NewKeyword("max-history"), []any{v14}) -if lang.IsTruthy(v24) { -v25 := lang.Apply(lang.NewKeyword("max-history"), []any{v14}) -v26, _ := lang.FieldOrMethod(v5, "setMaxHistory") -if reflect.TypeOf(v26).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMaxHistory is not a function"))) -} -v27 := lang.Apply(v26, []any{v25}) -v23 = v27 -} else { -v23 = nil -} -_ = v23 -var v28 any -v29 := lang.Apply(lang.NewKeyword("min-history"), []any{v14}) -if lang.IsTruthy(v29) { -v30 := lang.Apply(lang.NewKeyword("min-history"), []any{v14}) -v31, _ := lang.FieldOrMethod(v5, "setMinHistory") -if reflect.TypeOf(v31).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMinHistory is not a function"))) +v0 := lang.NewSymbol("max-mask-bits").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6644), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(6644), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, int64(13), true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v32 := lang.Apply(v31, []any{v30}) -v28 = v32 -} else { -v28 = nil } -_ = v28 -return v5 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) +// max-switch-table-size +{ +v0 := lang.NewSymbol("max-switch-table-size").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6645), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(6645), lang.NewKeyword("end-column"), int(36), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, int64(8192), true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// areduce +// maybe-destructured { -v0 := lang.NewSymbol("areduce").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("idx"), lang.NewSymbol("ret"), lang.NewSymbol("init"), lang.NewSymbol("expr"))), lang.NewKeyword("doc"), "Reduces an expression across an array a, using an index named idx,\n and return value named ret, initialized to init, setting ret to the \n evaluation of expr at each step, returning ret.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5289), lang.NewKeyword("end-line"), int(5289))).(*lang.Symbol) +v0 := lang.NewSymbol("maybe-destructured").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4514), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(4515), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("params"), lang.NewSymbol("body"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 7 { + if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := args[4] -v8 := args[5] -v9 := args[6] -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("seq")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("every?")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v12 := v11.Get() +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("symbol?")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v8, []any{v11, v3}) +if lang.IsTruthy(v12) { v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("concat")) +v14 := v13.FindInternedVar(lang.NewSymbol("cons")) if v14.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("list")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{lang.NewSymbol("glojure.core/let")}) -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("list")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("apply")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("vector")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("seq")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +v16 := lang.Apply(v15, []any{v3, v4}) +v5 = v16 +} else { +var v17 any = v17 +_ = v17 +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("with-meta")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("concat")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +v21 := v20.Get() +v22 := lang.NewVector() +v23 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4520), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(4520), lang.NewKeyword("end-column"), int(35)) +v24, err := lang.WithMeta(v22, v23.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v34 := v33.Get() -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("list")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("meta")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -v37 := v36.Get() -v38 := lang.Apply(v37, []any{lang.NewSymbol("a__0__auto__")}) -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("list")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +v27 := v26.Get() +v28 := lang.Apply(v27, []any{v17}) +v29 := lang.Apply(v21, []any{v24, v28}) +var v18 any = v29 +_ = v18 +v31 := lang.NewVector() +v32 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4521), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(4521), lang.NewKeyword("end-column"), int(18)) +v33, err := lang.WithMeta(v31, v32.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v41 := v40.Get() -v42 := lang.Apply(v41, []any{v5}) -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("list")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +var v30 any = v33 +_ = v30 +var v34 any +for { +var v35 any +if lang.IsTruthy(v17) { +var v36 any +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("symbol?")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -v45 := v44.Get() -v46 := lang.Apply(v45, []any{lang.NewSymbol("l__1__auto__")}) -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("list")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("first")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) } -v49 := v48.Get() -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("seq")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v17}) +v44 := lang.Apply(v39, []any{v43}) +if lang.IsTruthy(v44) { +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("next")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) } -v52 := v51.Get() -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("concat")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +v48 := v47.Get() +v49 := lang.Apply(v48, []any{v17}) +var v45 any = v49 +v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v52 := v51.FindInternedVar(lang.NewSymbol("conj")) +if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) } -v55 := v54.Get() -v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v57 := v56.FindInternedVar(lang.NewSymbol("list")) -if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) +v53 := v52.Get() +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("first")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) } -v58 := v57.Get() -v59 := lang.Apply(v58, []any{lang.NewSymbol("glojure.core/alength")}) -v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v61 := v60.FindInternedVar(lang.NewSymbol("list")) -if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) +v56 := v55.Get() +v57 := lang.Apply(v56, []any{v17}) +v58 := lang.Apply(v53, []any{v18, v57}) +var v50 any = v58 +var v59 any = v30 +v17 = v45 +v18 = v50 +v30 = v59 +continue +} else { +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("gensym")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) } -v62 := v61.Get() -v63 := lang.Apply(v62, []any{lang.NewSymbol("a__0__auto__")}) -v64 := lang.Apply(v55, []any{v59, v63}) -v65 := lang.Apply(v52, []any{v64}) -v66 := lang.Apply(v49, []any{v65}) -v67 := lang.Apply(v34, []any{v38, v42, v46, v66}) -v68 := lang.Apply(v31, []any{v67}) -v69 := lang.Apply(v25, []any{v28, v68}) -v70 := lang.Apply(v22, []any{v69}) -v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v72 := v71.FindInternedVar(lang.NewSymbol("list")) -if v72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) +v63 := v62.Get() +v64 := lang.Apply(v63, []any{"p__"}) +var v60 any = v64 +_ = v60 +v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v68 := v67.FindInternedVar(lang.NewSymbol("next")) +if v68.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) } -v73 := v72.Get() -v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v75 := v74.FindInternedVar(lang.NewSymbol("seq")) -if v75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) +v69 := v68.Get() +v70 := lang.Apply(v69, []any{v17}) +var v66 any = v70 +v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v73 := v72.FindInternedVar(lang.NewSymbol("conj")) +if v73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) } -v76 := v75.Get() +v74 := v73.Get() +v75 := lang.Apply(v74, []any{v18, v60}) +var v71 any = v75 v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v78 := v77.FindInternedVar(lang.NewSymbol("concat")) +v78 := v77.FindInternedVar(lang.NewSymbol("conj")) if v78.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) } v79 := v78.Get() v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v81 := v80.FindInternedVar(lang.NewSymbol("list")) +v81 := v80.FindInternedVar(lang.NewSymbol("conj")) if v81.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) } v82 := v81.Get() -v83 := lang.Apply(v82, []any{lang.NewSymbol("glojure.core/loop")}) -v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v85 := v84.FindInternedVar(lang.NewSymbol("list")) -if v85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) -} -v86 := v85.Get() -v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v88 := v87.FindInternedVar(lang.NewSymbol("apply")) -if v88.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) -} -v89 := v88.Get() -v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v91 := v90.FindInternedVar(lang.NewSymbol("vector")) -if v91.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) -} -v92 := v91.Get() -v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v94 := v93.FindInternedVar(lang.NewSymbol("seq")) -if v94.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) -} -v95 := v94.Get() -v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v97 := v96.FindInternedVar(lang.NewSymbol("concat")) -if v97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) -} -v98 := v97.Get() -v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v100 := v99.FindInternedVar(lang.NewSymbol("list")) -if v100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) -} -v101 := v100.Get() -v102 := lang.Apply(v101, []any{v6}) -v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v104 := v103.FindInternedVar(lang.NewSymbol("list")) -if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) -} -v105 := v104.Get() -v106 := lang.Apply(v105, []any{int64(0)}) -v107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v108 := v107.FindInternedVar(lang.NewSymbol("list")) -if v108.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v108))) -} -v109 := v108.Get() -v110 := lang.Apply(v109, []any{v7}) -v111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v112 := v111.FindInternedVar(lang.NewSymbol("list")) -if v112.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v112))) -} -v113 := v112.Get() -v114 := lang.Apply(v113, []any{v8}) -v115 := lang.Apply(v98, []any{v102, v106, v110, v114}) -v116 := lang.Apply(v95, []any{v115}) -v117 := lang.Apply(v89, []any{v92, v116}) -v118 := lang.Apply(v86, []any{v117}) -v119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v120 := v119.FindInternedVar(lang.NewSymbol("list")) -if v120.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v120))) -} -v121 := v120.Get() -v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v123 := v122.FindInternedVar(lang.NewSymbol("seq")) -if v123.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) -} -v124 := v123.Get() -v125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v126 := v125.FindInternedVar(lang.NewSymbol("concat")) -if v126.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v126))) -} -v127 := v126.Get() -v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v129 := v128.FindInternedVar(lang.NewSymbol("list")) -if v129.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v129))) -} -v130 := v129.Get() -v131 := lang.Apply(v130, []any{lang.NewSymbol("if")}) -v132 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v133 := v132.FindInternedVar(lang.NewSymbol("list")) -if v133.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v133))) -} -v134 := v133.Get() -v135 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v136 := v135.FindInternedVar(lang.NewSymbol("seq")) -if v136.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v136))) -} -v137 := v136.Get() -v138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v139 := v138.FindInternedVar(lang.NewSymbol("concat")) -if v139.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v139))) -} -v140 := v139.Get() -v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v142 := v141.FindInternedVar(lang.NewSymbol("list")) -if v142.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) -} -v143 := v142.Get() -v144 := lang.Apply(v143, []any{lang.NewSymbol("glojure.core/<")}) -v145 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v146 := v145.FindInternedVar(lang.NewSymbol("list")) -if v146.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v146))) -} -v147 := v146.Get() -v148 := lang.Apply(v147, []any{v6}) -v149 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v150 := v149.FindInternedVar(lang.NewSymbol("list")) -if v150.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v150))) +v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v84 := v83.FindInternedVar(lang.NewSymbol("first")) +if v84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) } -v151 := v150.Get() -v152 := lang.Apply(v151, []any{lang.NewSymbol("l__1__auto__")}) -v153 := lang.Apply(v140, []any{v144, v148, v152}) -v154 := lang.Apply(v137, []any{v153}) -v155 := lang.Apply(v134, []any{v154}) -v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v157 := v156.FindInternedVar(lang.NewSymbol("list")) -if v157.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) +v85 := v84.Get() +v86 := lang.Apply(v85, []any{v17}) +v87 := lang.Apply(v82, []any{v30, v86}) +v88 := lang.Apply(v79, []any{v87, v60}) +var v76 any = v88 +v17 = v66 +v18 = v71 +v30 = v76 +continue } -v158 := v157.Get() -v159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v160 := v159.FindInternedVar(lang.NewSymbol("seq")) -if v160.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v160))) +v35 = v36 +} else { +v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v61 := v60.FindInternedVar(lang.NewSymbol("seq")) +if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) } -v161 := v160.Get() -v162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v163 := v162.FindInternedVar(lang.NewSymbol("concat")) -if v163.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v163))) +v62 := v61.Get() +v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v64 := v63.FindInternedVar(lang.NewSymbol("concat")) +if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) } -v164 := v163.Get() -v165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v166 := v165.FindInternedVar(lang.NewSymbol("list")) -if v166.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v166))) +v65 := v64.Get() +v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v67 := v66.FindInternedVar(lang.NewSymbol("list")) +if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) } -v167 := v166.Get() -v168 := lang.Apply(v167, []any{lang.NewSymbol("recur")}) -v169 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v170 := v169.FindInternedVar(lang.NewSymbol("list")) -if v170.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v170))) +v68 := v67.Get() +v69 := lang.Apply(v68, []any{v18}) +v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v71 := v70.FindInternedVar(lang.NewSymbol("list")) +if v71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) } -v171 := v170.Get() -v172 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v173 := v172.FindInternedVar(lang.NewSymbol("seq")) -if v173.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v173))) +v72 := v71.Get() +v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v74 := v73.FindInternedVar(lang.NewSymbol("seq")) +if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) } -v174 := v173.Get() -v175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v176 := v175.FindInternedVar(lang.NewSymbol("concat")) -if v176.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v176))) +v75 := v74.Get() +v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v77 := v76.FindInternedVar(lang.NewSymbol("concat")) +if v77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) } -v177 := v176.Get() -v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v179 := v178.FindInternedVar(lang.NewSymbol("list")) -if v179.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) +v78 := v77.Get() +v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v80 := v79.FindInternedVar(lang.NewSymbol("list")) +if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) } -v180 := v179.Get() -v181 := lang.Apply(v180, []any{lang.NewSymbol("glojure.core/unchecked-inc-int")}) -v182 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v183 := v182.FindInternedVar(lang.NewSymbol("list")) -if v183.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v183))) +v81 := v80.Get() +v82 := lang.Apply(v81, []any{lang.NewSymbol("glojure.core/let")}) +v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v84 := v83.FindInternedVar(lang.NewSymbol("list")) +if v84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) } -v184 := v183.Get() -v185 := lang.Apply(v184, []any{v6}) -v186 := lang.Apply(v177, []any{v181, v185}) -v187 := lang.Apply(v174, []any{v186}) -v188 := lang.Apply(v171, []any{v187}) -v189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v190 := v189.FindInternedVar(lang.NewSymbol("list")) -if v190.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v190))) +v85 := v84.Get() +v86 := lang.Apply(v85, []any{v30}) +v87 := lang.Apply(v78, []any{v82, v86, v4}) +v88 := lang.Apply(v75, []any{v87}) +v89 := lang.Apply(v72, []any{v88}) +v90 := lang.Apply(v65, []any{v69, v89}) +v91 := lang.Apply(v62, []any{v90}) +v35 = v91 } -v191 := v190.Get() -v192 := lang.Apply(v191, []any{v9}) -v193 := lang.Apply(v164, []any{v168, v188, v192}) -v194 := lang.Apply(v161, []any{v193}) -v195 := lang.Apply(v158, []any{v194}) -v196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v197 := v196.FindInternedVar(lang.NewSymbol("list")) -if v197.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v197))) +v34 = v35 + break } -v198 := v197.Get() -v199 := lang.Apply(v198, []any{v7}) -v200 := lang.Apply(v127, []any{v131, v155, v195, v199}) -v201 := lang.Apply(v124, []any{v200}) -v202 := lang.Apply(v121, []any{v201}) -v203 := lang.Apply(v79, []any{v83, v118, v202}) -v204 := lang.Apply(v76, []any{v203}) -v205 := lang.Apply(v73, []any{v204}) -v206 := lang.Apply(v15, []any{v19, v70, v205}) -v207 := lang.Apply(v12, []any{v206}) -return v207 +v5 = v34 +} +return v5 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -51568,348 +51344,545 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// int +// maybe-min-hash { -var v1 lang.FnFunc -{ // function int__inliner -v1 = lang.NewFnFunc(func(args ...any) any { +v0 := lang.NewSymbol("maybe-min-hash").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("hashes"))), lang.NewKeyword("doc"), "takes a collection of hashes and returns [shift mask] or nil if none found", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6647), lang.NewKeyword("end-line"), int(6647), lang.NewKeyword("private"), true)).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +v5 := v4.FindInternedVar(lang.NewSymbol("first")) if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +v8 := v7.FindInternedVar(lang.NewSymbol("filter")) if v8.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +var v10 lang.FnFunc +v10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v11 := args[0] +var v12 any = v11 +_ = v12 v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) +v15 := v14.FindInternedVar(lang.NewSymbol("nth")) if v15.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +v17 := lang.Apply(v16, []any{v12, int64(0), nil}) +var v13 any = v17 +_ = v13 +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("nth")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v23 := v22.Get() +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v12, int64(1), nil}) +var v18 any = v22 +_ = v18 v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +v25 := v24.FindInternedVar(lang.NewSymbol("apply")) if v25.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } v26 := v25.Get() v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) +v28 := v27.FindInternedVar(lang.NewSymbol("distinct?")) if v28.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } v29 := v28.Get() -var v30 any -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -if lang.IsTruthy(v33) { -v30 = lang.NewSymbol("uncheckedIntCast") -} else { -v30 = lang.NewSymbol("intCast") +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("map")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) } -v34 := lang.Apply(v29, []any{v30}) +v32 := v31.Get() +var v33 lang.FnFunc +v33 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v34 := args[0] v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("list")) +v36 := v35.FindInternedVar(lang.NewSymbol("shift-mask")) if v36.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) } v37 := v36.Get() -v38 := lang.Apply(v37, []any{v3}) -v39 := lang.Apply(v26, []any{v34, v38}) -v40 := lang.Apply(v23, []any{v39}) -v41 := lang.Apply(v20, []any{v40}) -v42 := lang.Apply(v9, []any{v13, v17, v41}) -v43 := lang.Apply(v6, []any{v42}) -return v43 +v38 := lang.Apply(v37, []any{v13, v18, v34}) +return v38 }) -v2 := v1 -_ = v2 +v34 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6652), lang.NewKeyword("column"), int(37), lang.NewKeyword("end-line"), int(6652), lang.NewKeyword("end-column"), int(55)) +v35, err := lang.WithMeta(v33, v34.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v0 := lang.NewSymbol("int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to int", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(875), lang.NewKeyword("end-line"), int(875))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { +v36 := lang.Apply(v32, []any{v35, v3}) +v37 := lang.Apply(v26, []any{v29, v36}) +return v37 +}) +v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6651), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(6652), lang.NewKeyword("end-column"), int(65)) +v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v14 lang.FnFunc +{ // function iter__181 +v14 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v4 := args[0] -v5, _ := lang.FieldOrMethod(runtime3.RT, "IntCast") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("IntCast is not a function"))) +v16 := args[0] +var v17 lang.FnFunc +v17 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +var v18 any = v18 +_ = v18 +var v19 any +for { +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v18}) +var v20 any = v24 +_ = v20 +var v26 any +if lang.IsTruthy(v20) { +var v27 any = v20 +_ = v27 +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("first")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) } +v32 := v31.Get() +v33 := lang.Apply(v32, []any{v27}) +var v29 any = v33 +_ = v29 +var v36 lang.FnFunc +{ // function iter__183 +v36 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v38 := args[0] +var v39 lang.FnFunc +v39 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +var v40 any = v40 +_ = v40 +var v41 any +for { +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("seq")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) } -// + -{ -var v1 lang.FnFunc -v1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v2 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v45 := v44.Get() +v46 := lang.Apply(v45, []any{v40}) +var v42 any = v46 +_ = v42 +var v48 any +if lang.IsTruthy(v42) { +var v49 any = v42 +_ = v49 +var v51 any +v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v53 := v52.FindInternedVar(lang.NewSymbol("chunked-seq?")) +if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) } -v7 := v6.Get() -if lang.IsTruthy(v7) { -v4 = closed10 +v54 := v53.Get() +v55 := lang.Apply(v54, []any{v49}) +if lang.IsTruthy(v55) { +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("chunk-first")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +} +v59 := v58.Get() +v60 := lang.Apply(v59, []any{v49}) +var v56 any = v60 +_ = v56 +v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v63 := v62.FindInternedVar(lang.NewSymbol("int")) +if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +} +v64 := v63.Get() +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("count")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +} +v67 := v66.Get() +v68 := lang.Apply(v67, []any{v56}) +v69 := lang.Apply(v64, []any{v68}) +var v61 any = v69 +_ = v61 +v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v72 := v71.FindInternedVar(lang.NewSymbol("chunk-buffer")) +if v72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) +} +v73 := v72.Get() +v74 := lang.Apply(v73, []any{v61}) +var v70 any = v74 +_ = v70 +var v76 any +v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v79 := v78.FindInternedVar(lang.NewSymbol("int")) +if v79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) +} +v80 := v79.Get() +v81 := lang.Apply(v80, []any{int64(0)}) +var v77 any = v81 +_ = v77 +var v82 any +for { +var v83 any +v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v85 := v84.FindInternedVar(lang.NewSymbol("<")) +if v85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) +} +v86 := v85.Get() +v87 := lang.Apply(v86, []any{v77, v61}) +if lang.IsTruthy(v87) { +v89, _ := lang.FieldOrMethod(v56, "nth") +if reflect.TypeOf(v89).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) +} +v90 := lang.Apply(v89, []any{v77}) +var v88 any = v90 +_ = v88 +v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v93 := v92.FindInternedVar(lang.NewSymbol("chunk-append")) +if v93.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) +} +v94 := v93.Get() +v95 := lang.NewVector(v88, v29) +v96 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6655), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(6655), lang.NewKeyword("end-column"), int(26)) +v97, err := lang.WithMeta(v95, v96.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v98 := lang.Apply(v94, []any{v70, v97}) +_ = v98 +v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v101 := v100.FindInternedVar(lang.NewSymbol("unchecked-inc")) +if v101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) +} +v102 := v101.Get() +v103 := lang.Apply(v102, []any{v77}) +var v99 any = v103 +v77 = v99 +continue } else { -v4 = v3 +v83 = true } -var v3 any = v4 -_ = v3 -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("seq")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +v82 = v83 + break +} +if lang.IsTruthy(v82) { +v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v78 := v77.FindInternedVar(lang.NewSymbol("chunk-cons")) +if v78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) +} +v79 := v78.Get() +v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v81 := v80.FindInternedVar(lang.NewSymbol("chunk")) +if v81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) +} +v82 := v81.Get() +v83 := lang.Apply(v82, []any{v70}) +v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v85 := v84.FindInternedVar(lang.NewSymbol("chunk-rest")) +if v85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) +} +v86 := v85.Get() +v87 := lang.Apply(v86, []any{v49}) +v88 := lang.Apply(v37, []any{v87}) +v89 := lang.Apply(v79, []any{v83, v88}) +v76 = v89 +} else { +v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v91 := v90.FindInternedVar(lang.NewSymbol("chunk-cons")) +if v91.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) +} +v92 := v91.Get() +v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v94 := v93.FindInternedVar(lang.NewSymbol("chunk")) +if v94.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) +} +v95 := v94.Get() +v96 := lang.Apply(v95, []any{v70}) +v97 := lang.Apply(v92, []any{v96, nil}) +v76 = v97 +} +v51 = v76 +} else { +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("first")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +} +v59 := v58.Get() +v60 := lang.Apply(v59, []any{v49}) +var v56 any = v60 +_ = v56 +v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v63 := v62.FindInternedVar(lang.NewSymbol("cons")) +if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +} +v64 := v63.Get() +v65 := lang.NewVector(v56, v29) +v66 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6655), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(6655), lang.NewKeyword("end-column"), int(26)) +v67, err := lang.WithMeta(v65, v66.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v69 := v68.FindInternedVar(lang.NewSymbol("rest")) +if v69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) } -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("concat")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +v70 := v69.Get() +v71 := lang.Apply(v70, []any{v49}) +v72 := lang.Apply(v37, []any{v71}) +v73 := lang.Apply(v64, []any{v67, v72}) +v51 = v73 } -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +v48 = v51 +} else { +v48 = nil } -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v41 = v48 + break } -v21 := v20.Get() -v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +return v41 +}) +v40 := lang.Apply(lang1.NewLazySeq, []any{v39}) +return v40 +}) +v37 := v36 +_ = v37 } -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("seq")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +var v35 any = v36 +_ = v35 +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("seq")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) } -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("concat")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("range")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +v43 := v42.Get() +v44 := lang.Apply(v43, []any{int64(0), int64(31)}) +v45 := lang.Apply(v35, []any{v44}) +v46 := lang.Apply(v40, []any{v45}) +var v37 any = v46 +_ = v37 +var v48 any +if lang.IsTruthy(v37) { +v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v50 := v49.FindInternedVar(lang.NewSymbol("concat")) +if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) } -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +v51 := v50.Get() +v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v53 := v52.FindInternedVar(lang.NewSymbol("rest")) +if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) } -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v2}) -v40 := lang.Apply(v31, []any{v35, v39}) -v41 := lang.Apply(v28, []any{v40}) -v42 := lang.Apply(v25, []any{v41}) -v43 := lang.Apply(v14, []any{v18, v22, v42}) -v44 := lang.Apply(v11, []any{v43}) -return v44 - case 2: -v2 := args[0] -v3 := args[1] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +v54 := v53.Get() +v55 := lang.Apply(v54, []any{v18}) +v56 := lang.Apply(v15, []any{v55}) +v57 := lang.Apply(v51, []any{v37, v56}) +v48 = v57 +} else { +v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v60 := v59.FindInternedVar(lang.NewSymbol("rest")) +if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) } -v8 := v7.Get() -if lang.IsTruthy(v8) { -v5 = closed10 +v61 := v60.Get() +v62 := lang.Apply(v61, []any{v18}) +var v58 any = v62 +v18 = v58 +continue +} +v26 = v48 } else { -v5 = v4 +v26 = nil } -var v4 any = v5 -_ = v4 -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("seq")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v19 = v26 + break } -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("concat")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +return v19 +}) +v18 := lang.Apply(lang1.NewLazySeq, []any{v17}) +return v18 +}) +v15 := v14 +_ = v15 } -v15 := v14.Get() +var v13 any = v14 +_ = v13 v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("list")) +v17 := v16.FindInternedVar(lang.NewSymbol("map")) if v17.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } v18 := v17.Get() -v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("list")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +var v19 lang.FnFunc +v19 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v20 := args[0] +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("dec")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v22 := v21.Get() -v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v23 := v22.Get() v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("list")) +v25 := v24.FindInternedVar(lang.NewSymbol("bit-shift-left")) if v25.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("seq")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v27 := lang.Apply(v26, []any{int64(1), v20}) +v28 := lang.Apply(v23, []any{v27}) +return v28 +}) +v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6653), lang.NewKeyword("column"), int(29), lang.NewKeyword("end-line"), int(6653), lang.NewKeyword("end-column"), int(55)) +v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v29 := v28.Get() -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("concat")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("range")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("list")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("inc")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v4}) -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("list")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("max-mask-bits")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v2}) -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("list")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +v30 := v29.Get() +v31 := lang.Apply(v27, []any{v30}) +v32 := lang.Apply(v24, []any{int64(1), v31}) +v33 := lang.Apply(v18, []any{v21, v32}) +v34 := lang.Apply(v13, []any{v33}) +v13 := lang.Apply(v9, []any{v12, v34}) +v14 := lang.Apply(v6, []any{v13}) +return v14 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v3}) -v45 := lang.Apply(v32, []any{v36, v40, v44}) -v46 := lang.Apply(v29, []any{v45}) -v47 := lang.Apply(v26, []any{v46}) -v48 := lang.Apply(v15, []any{v19, v23, v47}) -v49 := lang.Apply(v12, []any{v48}) -return v49 +} +// memfn +{ +v0 := lang.NewSymbol("memfn").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Expands into code that creates a fn that expects to be passed an\n object and any args and calls the named instance method on the\n object passing the args. Use when you want to treat a Java method as\n a first-class fn. name may be type-hinted with the method receiver's\n type in order to avoid reflective calls.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3872), lang.NewKeyword("end-line"), int(3872))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { default: - if len(args) < 2 { + if len(args) < 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v2 := args[0] -v3 := args[1] -v4 := lang.NewList(args[2:]...) -var v6 any -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -if lang.IsTruthy(v9) { -v6 = closed10 -} else { -v6 = v5 +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("with-meta")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -var v5 any = v6 -_ = v5 +v10 := v9.Get() v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) +v12 := v11.FindInternedVar(lang.NewSymbol("gensym")) if v12.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } v13 := v12.Get() -var v14 lang.FnFunc -v14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v15 := args[0] -v16 := args[1] -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +v14 := lang.Apply(v13, []any{"target"}) +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("meta")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("concat")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v5}) +v19 := lang.Apply(v10, []any{v14, v18}) +var v7 any = v19 +_ = v7 +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) +v26 := v25.Get() v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v28 := v27.FindInternedVar(lang.NewSymbol("list")) if v28.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/fn")}) v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v32 := v31.FindInternedVar(lang.NewSymbol("list")) if v32.IsMacro() { @@ -51917,273 +51890,290 @@ if v32.IsMacro() { } v33 := v32.Get() v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +v35 := v34.FindInternedVar(lang.NewSymbol("apply")) if v35.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } v36 := v35.Get() v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +v38 := v37.FindInternedVar(lang.NewSymbol("vector")) if v38.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } v39 := v38.Get() v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) +v41 := v40.FindInternedVar(lang.NewSymbol("seq")) if v41.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) } v42 := v41.Get() -v43 := lang.Apply(v42, []any{v5}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v15}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v16}) -v52 := lang.Apply(v39, []any{v43, v47, v51}) -v53 := lang.Apply(v36, []any{v52}) -v54 := lang.Apply(v33, []any{v53}) -v55 := lang.Apply(v22, []any{v26, v30, v54}) -v56 := lang.Apply(v19, []any{v55}) -return v56 -}) -v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) -v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) -if err != nil { - panic(err) +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("concat")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) } -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +v45 := v44.Get() +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("list")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) } -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("concat")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +v48 := v47.Get() +v49 := lang.Apply(v48, []any{v7}) +v50 := lang.Apply(v45, []any{v49, v6}) +v51 := lang.Apply(v42, []any{v50}) +v52 := lang.Apply(v36, []any{v39, v51}) +v53 := lang.Apply(v33, []any{v52}) +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("list")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) } -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +v56 := v55.Get() +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("seq")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) } -v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v59 := v58.Get() +v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v61 := v60.FindInternedVar(lang.NewSymbol("concat")) +if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) } -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v62 := v61.Get() +v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v64 := v63.FindInternedVar(lang.NewSymbol("list")) +if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) } -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +v65 := v64.Get() +v66 := lang.Apply(v65, []any{lang.NewSymbol(".")}) +v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v68 := v67.FindInternedVar(lang.NewSymbol("list")) +if v68.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) } -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +v69 := v68.Get() +v70 := lang.Apply(v69, []any{v7}) +v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v72 := v71.FindInternedVar(lang.NewSymbol("list")) +if v72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) } -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +v73 := v72.Get() +v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v75 := v74.FindInternedVar(lang.NewSymbol("seq")) +if v75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) } -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v5}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +v76 := v75.Get() +v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v78 := v77.FindInternedVar(lang.NewSymbol("concat")) +if v78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) } -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v2}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +v79 := v78.Get() +v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v81 := v80.FindInternedVar(lang.NewSymbol("list")) +if v81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) } -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v3}) -v52 := lang.Apply(v39, []any{v43, v47, v51}) -v53 := lang.Apply(v36, []any{v52}) -v54 := lang.Apply(v33, []any{v53}) -v55 := lang.Apply(v22, []any{v26, v30, v54}) -v56 := lang.Apply(v19, []any{v55}) -v57 := lang.Apply(v13, []any{v16, v56, v4}) -return v57 +v82 := v81.Get() +v83 := lang.Apply(v82, []any{v5}) +v84 := lang.Apply(v79, []any{v83, v6}) +v85 := lang.Apply(v76, []any{v84}) +v86 := lang.Apply(v73, []any{v85}) +v87 := lang.Apply(v62, []any{v66, v70, v86}) +v88 := lang.Apply(v59, []any{v87}) +v89 := lang.Apply(v56, []any{v88}) +v90 := lang.Apply(v26, []any{v30, v53, v89}) +v91 := lang.Apply(v23, []any{v90}) +return v91 } }) -v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// memoize +{ +v0 := lang.NewSymbol("memoize").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Returns a memoized version of a referentially transparent function. The\n memoized version of the function keeps a cache of the mapping from arguments\n to results and, when calls with the same arguments are repeated often, has\n higher performance at the expense of higher memory use.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6380), lang.NewKeyword("end-line"), int(6380))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("atom")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.NewMap() +v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6388), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(6388), lang.NewKeyword("end-column"), int(20)) +v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v5 := lang.Apply(v4, []any{v3, int64(1)}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v0 := lang.NewSymbol("+").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the sum of nums. (+) returns 0. Does not auto-promote\n longs, will throw on overflow. See also: +'", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(977), lang.NewKeyword("end-line"), int(977))).(*lang.Symbol) -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { +v11 := lang.Apply(v7, []any{v10}) +var v4 any = v11 +_ = v4 +var v13 lang.FnFunc +v13 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 0: -return int64(0) - case 1: -v5 := args[0] -v6 := lang.Apply(lang1.MustAsNumber, []any{v5}) -return v6 - case 2: -v5 := args[0] -v6 := args[1] -v7, _ := lang.FieldOrMethod(lang1.Numbers, "add") -if reflect.TypeOf(v7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) -} -v8 := lang.Apply(v7, []any{v5, v6}) -return v8 default: - if len(args) < 2 { + if len(args) < 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v5 := args[0] -v6 := args[1] -v7 := lang.NewList(args[2:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v14 := lang.NewList(args[0:]...) +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("find")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("+")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v18 := v17.Get() +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("deref")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("+")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v4}) +v23 := lang.Apply(v18, []any{v22, v14}) +var v15 any = v23 +_ = v15 +var v25 any +if lang.IsTruthy(v15) { +var v26 any = v15 +_ = v26 +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("val")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v5, v6}) -v18 := lang.Apply(v10, []any{v13, v17, v7}) -return v18 +v30 := v29.Get() +v31 := lang.Apply(v30, []any{v26}) +v25 = v31 +} else { +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("apply")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{v3, v14}) +var v26 any = v30 +_ = v26 +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("swap!")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("assoc")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v34, []any{v4, v37, v14, v26}) +_ = v38 +v25 = v26 +} +return v25 } }) -v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v3 := ns.InternWithValue(v0, v4, true) +v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6389), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(6394), lang.NewKeyword("end-column"), int(16)) +v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v15 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { - v3.SetMeta(v0.Meta().(lang.IPersistentMap)) + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// assoc-in +// merge { -v0 := lang.NewSymbol("assoc-in").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("&"), lang.NewSymbol("ks")), lang.NewSymbol("v"))), lang.NewKeyword("doc"), "Associates a value in a nested associative structure, where ks is a\n sequence of keys and v is the new value and returns a new nested structure.\n If any levels do not exist, hash-maps will be created.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6190), lang.NewKeyword("end-line"), int(6190))).(*lang.Symbol) +v0 := lang.NewSymbol("merge").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("maps"))), lang.NewKeyword("doc"), "Returns a map that consists of the rest of the maps conj-ed onto\n the first. If a key occurs in more than one map, the mapping from\n the latter (left-to-right) will be the mapping in the result.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3040), lang.NewKeyword("end-line"), int(3040))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -var v6 any = v4 -_ = v6 + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.NewList(args[0:]...) +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("some")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("seq")) +v9 := v8.FindInternedVar(lang.NewSymbol("identity")) if v9.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } v10 := v9.Get() -v11 := lang.Apply(v10, []any{v6}) -var v7 any = v11 -_ = v7 -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("first")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +v11 := lang.Apply(v7, []any{v10, v3}) +if lang.IsTruthy(v11) { +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("reduce1")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v7}) -var v12 any = v16 -_ = v12 +v14 := v13.Get() +var v15 lang.FnFunc +v15 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v16 := args[0] +v17 := args[1] v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("next")) +v19 := v18.FindInternedVar(lang.NewSymbol("conj")) if v19.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } v20 := v19.Get() -v21 := lang.Apply(v20, []any{v17}) -var v17 any = v21 -_ = v17 -var v22 any = v12 -_ = v22 -var v23 any = v17 -_ = v23 -var v25 any -if lang.IsTruthy(v23) { -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("assoc")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +var v21 any = v16 +_ = v21 +var v23 any +if lang.IsTruthy(v21) { +v23 = v21 +} else { +v24 := lang.NewMap() +v25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3048), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(3048), lang.NewKeyword("end-column"), int(29)) +v26, err := lang.WithMeta(v24, v25.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("assoc-in")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +v23 = v26 } -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("get")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +v21 := lang.Apply(v20, []any{v23, v17}) +return v21 +}) +v16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3048), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(3048), lang.NewKeyword("end-column"), int(34)) +v17, err := lang.WithMeta(v15, v16.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3, v22}) -v36 := lang.Apply(v31, []any{v35, v23, v5}) -v37 := lang.Apply(v28, []any{v3, v22, v36}) -v25 = v37 +v18 := lang.Apply(v14, []any{v17, v3}) +v4 = v18 } else { -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("assoc")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.Apply(v40, []any{v3, v22, v5}) -v25 = v41 +v4 = nil } -return v25 +return v4 + } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -52191,385 +52181,430 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// seque +// merge-hash-collisions { -v0 := lang.NewSymbol("seque").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s")), lang.NewVector(lang.NewSymbol("n-or-q"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Creates a queued seq on another (presumably lazy) seq s. The queued\n seq will produce a concrete seq in the background, and can get up to\n n items ahead of the consumer. n-or-q can be an integer n buffer\n size, or an instance of java.util.concurrent BlockingQueue. Note\n that reading from a seque can block if the reader gets ahead of the\n producer.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5419), lang.NewKeyword("end-line"), int(5419))).(*lang.Symbol) +v0 := lang.NewSymbol("merge-hash-collisions").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr-sym"), lang.NewSymbol("default"), lang.NewSymbol("tests"), lang.NewSymbol("thens"))), lang.NewKeyword("doc"), "Takes a case expression, default expression, and a sequence of test constants\n and a corresponding sequence of then expressions. Returns a tuple of\n [tests thens skip-check-set] where no tests have the same hash. Each set of\n input test constants with the same hash is replaced with a single test\n constant (the case int), and their respective thens are combined into:\n (condp = expr\n test-1 then-1\n ...\n test-n then-n\n default).\n The skip-check is a set of case ints for which post-switch equivalence\n checking must not be done (the cases holding the above condp thens).", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6690), lang.NewKeyword("end-line"), int(6690), lang.NewKeyword("private"), true)).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seque")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{int64(100), v3}) -return v7 - case 2: + if len(args) != 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] v4 := args[1] -var v6 any -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("instance?")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v5 := args[2] +v6 := args[3] +v9 := lang.NewMap() +v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6704), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(6704), lang.NewKeyword("end-column"), int(27)) +v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v9 := v8.Get() -v10 := lang.Apply(v9, []any{nil, v3}) -if lang.IsTruthy(v10) { -v6 = v3 +var v8 any = v11 +_ = v8 +var v12 any = v5 +_ = v12 +var v13 any = v6 +_ = v13 +var v14 any +for { +var v15 any +var v16 any = v12 +_ = v16 +var v18 any +if lang.IsTruthy(v16) { +v18 = v13 } else { -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("int")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v18 = v16 } -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v3}) -v15 := lang.Apply(LinkedBlockingQueue28., []any{v14}) -v6 = v15 +if lang.IsTruthy(v18) { +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("update")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -var v5 any = v6 -_ = v5 -v17 := lang.Apply(Object23., nil) -var v16 any = v17 -_ = v16 -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("agent")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("first")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v21 := v20.Get() -var v22 lang.FnFunc -v22 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { +v22 := v21.Get() +v23 := lang.Apply(v22, []any{v12}) +v24 := lang.Apply(lang1.Hash, []any{v23}) +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("fnil")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("conj")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.NewVector() +v32 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6707), lang.NewKeyword("column"), int(102), lang.NewKeyword("end-line"), int(6707), lang.NewKeyword("end-column"), int(103)) +v33, err := lang.WithMeta(v31, v32.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v34 := lang.Apply(v27, []any{v30, v33}) +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("first")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v37, []any{v12}) +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("first")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +} +v41 := v40.Get() +v42 := lang.Apply(v41, []any{v13}) +v43 := lang.NewVector(v38, v42) +v44 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6707), lang.NewKeyword("column"), int(106), lang.NewKeyword("end-line"), int(6707), lang.NewKeyword("end-column"), int(128)) +v45, err := lang.WithMeta(v43, v44.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v46 := lang.Apply(v19, []any{v8, v24, v34, v45}) +var v16 any = v46 +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("next")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v12}) +var v47 any = v51 +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("next")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +} +v55 := v54.Get() +v56 := lang.Apply(v55, []any{v13}) +var v52 any = v56 +v8 = v16 +v12 = v47 +v13 = v52 +continue +} else { +v15 = v8 +} +v14 = v15 + break +} +var v7 any = v14 +_ = v7 +var v9 lang.FnFunc +v9 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -return v4 -}) -v23 := lang.Apply(lang1.NewLazySeq, []any{v22}) -v24 := lang.Apply(v21, []any{v23}) -var v18 any = v24 -_ = v18 -var v26 lang.FnFunc -v26 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { +v10 := args[0] +v11 := args[1] +v12 := args[2] +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("mapcat")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +var v17 lang.FnFunc +v17 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v27 := args[0] -v28 := args[1] -var v29 any -v30, _ := lang.FieldOrMethod(v27, "offer") -if reflect.TypeOf(v30).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("offer is not a function"))) +v18 := args[0] +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v31 := lang.Apply(v30, []any{v27}) -if lang.IsTruthy(v31) { -panic(v28) -} else { -v29 = v28 +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("first")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -return v29 +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v18}) +v26 := lang.Apply(v21, []any{lang.NewSymbol("quote"), v25}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("second")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{v18}) +v31 := lang.NewVector(v26, v30) +v32 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6711), lang.NewKeyword("column"), int(56), lang.NewKeyword("end-line"), int(6711), lang.NewKeyword("end-column"), int(93)) +v33, err := lang.WithMeta(v31, v32.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v33 }) -v27 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5435), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(5438), lang.NewKeyword("end-column"), int(26)) -v28, err := lang.WithMeta(v26, v27.(lang.IPersistentMap)) +v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6711), lang.NewKeyword("column"), int(47), lang.NewKeyword("end-line"), int(6711), lang.NewKeyword("end-column"), int(94)) +v19, err := lang.WithMeta(v17, v18.(lang.IPersistentMap)) if err != nil { panic(err) } -var v25 any = v28 -_ = v25 -var v30 lang.FnFunc -v30 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v31 := args[0] -var v32 any -if lang.IsTruthy(v31) { -var v33 any -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("instance?")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +v20 := lang.Apply(v16, []any{v19, v12}) +var v13 any = v20 +_ = v13 +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("seq")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -v36 := v35.Get() -v37 := lang.Apply(v36, []any{nil, v31}) -if lang.IsTruthy(v37) { -v38 := lang.Apply(v25, []any{v5, v31}) -v33 = v38 -} else { -var v39 any -func() { -defer func() { -if r := recover(); r != nil { -if lang.CatchMatches(r, lang.Builtins["any"]) { -v40 := r -_ = v40 -v41 := lang.Apply(v25, []any{v5, v40}) -v39 = v41 -} else { -panic(r) +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("concat")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("list")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/condp")}) +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) } +v34 := v33.Get() +v35 := lang.Apply(v34, []any{lang.NewSymbol("glojure.core/=")}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) } -}() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("seq")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v3}) +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) } -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v31}) -var v40 any = v44 -_ = v40 -var v45 any = v40 -_ = v45 +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v4}) +v44 := lang.Apply(v27, []any{v31, v35, v39, v13, v43}) +v45 := lang.Apply(v24, []any{v44}) +var v21 any = v45 +_ = v21 v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("seq")) +v48 := v47.FindInternedVar(lang.NewSymbol("assoc")) if v48.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) } v49 := v48.Get() -v50 := lang.Apply(v49, []any{v45}) -var v46 any = v50 -_ = v46 -v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("first")) -if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) +v50 := lang.Apply(v49, []any{v10, v11, v21}) +return v50 +}) +v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6710), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(6713), lang.NewKeyword("end-column"), int(42)) +v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v54 := v53.Get() -v55 := lang.Apply(v54, []any{v46}) -var v51 any = v55 -_ = v51 -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("next")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +var v8 any = v11 +_ = v8 +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("reduce1")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } -v59 := v58.Get() -v60 := lang.Apply(v59, []any{v56}) -var v56 any = v60 -_ = v56 -var v61 any = v51 -_ = v61 -var v62 any = v56 -_ = v62 -var v63 any = v45 -_ = v63 -var v65 any = v65 -_ = v65 -var v66 any -for { -var v67 any = v65 -_ = v67 -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("seq")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +v15 := v14.Get() +var v16 lang.FnFunc +v16 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v17 := args[0] +v18 := args[1] +var v19 any = v18 +_ = v19 +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("nth")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v71 := v70.Get() -v72 := lang.Apply(v71, []any{v67}) -var v68 any = v72 -_ = v68 -v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v75 := v74.FindInternedVar(lang.NewSymbol("first")) -if v75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v19, int64(0), nil}) +var v20 any = v24 +_ = v20 +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("nth")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) } -v76 := v75.Get() -v77 := lang.Apply(v76, []any{v68}) -var v73 any = v77 -_ = v73 -v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v80 := v79.FindInternedVar(lang.NewSymbol("next")) -if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) +v28 := v27.Get() +v29 := lang.Apply(v28, []any{v19, int64(1), nil}) +var v25 any = v29 +_ = v25 +var v31 any +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("==")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) } -v81 := v80.Get() -v82 := lang.Apply(v81, []any{v78}) -var v78 any = v82 -_ = v78 -var v83 any = v73 -_ = v83 -var v84 any = v78 -_ = v84 -var v85 any = v67 -_ = v85 -var v87 any -if lang.IsTruthy(v85) { -var v88 any -var v89 any -v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v91 := v90.FindInternedVar(lang.NewSymbol("nil?")) -if v91.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) +v34 := v33.Get() +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("count")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) } -v92 := v91.Get() -v93 := lang.Apply(v92, []any{v83}) -if lang.IsTruthy(v93) { -v89 = v16 -} else { -v89 = v83 +v37 := v36.Get() +v38 := lang.Apply(v37, []any{v25}) +v39 := lang.Apply(v34, []any{int64(1), v38}) +if lang.IsTruthy(v39) { +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("assoc")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) } -v94, _ := lang.FieldOrMethod(v5, "offer") -if reflect.TypeOf(v94).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("offer is not a function"))) +v42 := v41.Get() +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("ffirst")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) } -v95 := lang.Apply(v94, []any{v89}) -if lang.IsTruthy(v95) { -var v96 any = v84 -v65 = v96 -continue -} else { -v88 = v85 +v45 := v44.Get() +v46 := lang.Apply(v45, []any{v25}) +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("second")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) } -v87 = v88 -} else { -var v97 any -v98, _ := lang.FieldOrMethod(v5, "offer") -if reflect.TypeOf(v98).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("offer is not a function"))) +v49 := v48.Get() +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("first")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) } -v99 := lang.Apply(v98, []any{v5}) -if lang.IsTruthy(v99) { -v97 = nil +v52 := v51.Get() +v53 := lang.Apply(v52, []any{v25}) +v54 := lang.Apply(v49, []any{v53}) +v55 := lang.Apply(v42, []any{v17, v46, v54}) +v31 = v55 } else { -v97 = lang.NewList() -} -v87 = v97 +v56 := lang.Apply(v8, []any{v17, v20, v25}) +v31 = v56 } -v66 = v87 - break +return v31 +}) +v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6715), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(6718), lang.NewKeyword("end-column"), int(45)) +v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v39 = v66 -}() -v33 = v39 +v19 := lang.NewMap() +v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6719), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(6719), lang.NewKeyword("end-column"), int(17)) +v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v32 = v33 -} else { -v32 = nil +v22 := lang.Apply(v15, []any{v18, v21, v7}) +var v12 any = v22 +_ = v12 +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("into1")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -return v32 -}) -v31 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5439), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(5452), lang.NewKeyword("end-column"), int(44)) -v32, err := lang.WithMeta(v30, v31.(lang.IPersistentMap)) +v26 := v25.Get() +v27 := lang.CreatePersistentTreeSet() +v28 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6723), lang.NewKeyword("column"), int(29), lang.NewKeyword("end-line"), int(6723), lang.NewKeyword("end-column"), int(31)) +v29, err := lang.WithMeta(v27, v28.(lang.IPersistentMap)) if err != nil { panic(err) } -var v29 any = v32 -_ = v29 -var v34 lang.FnFunc -{ // function drain -v34 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -var v36 lang.FnFunc -v36 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("map")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("first")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("filter")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +var v39 lang.FnFunc +v39 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v38, ok := lang.FieldOrMethod(v5, "take") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "take"))) +v40 := args[0] +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("<")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } -var v39 any -switch reflect.TypeOf(v38).Kind() { -case reflect.Func: - v39 = lang.Apply(v38, nil) -default: - v39 = v38 +v43 := v42.Get() +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("count")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } -var v37 any = v39 -_ = v37 -var v41 any -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("identical?")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +v46 := v45.Get() +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("second")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) } -v44 := v43.Get() -v45 := lang.Apply(v44, []any{v37, v5}) -if lang.IsTruthy(v45) { +v49 := v48.Get() +v50 := lang.Apply(v49, []any{v40}) +v51 := lang.Apply(v46, []any{v50}) +v52 := lang.Apply(v43, []any{int64(1), v51}) +return v52 +}) +v40 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6721), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(6721), lang.NewKeyword("end-column"), int(54)) +v41, err := lang.WithMeta(v39, v40.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v42 := lang.Apply(v38, []any{v41, v7}) +v43 := lang.Apply(v32, []any{v35, v42}) +v44 := lang.Apply(v26, []any{v29, v43}) +var v23 any = v44 +_ = v23 v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("deref")) +v47 := v46.FindInternedVar(lang.NewSymbol("keys")) if v47.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) } v48 := v47.Get() -v49 := lang.Apply(v48, []any{v18}) -_ = v49 -v41 = nil -} else { +v49 := lang.Apply(v48, []any{v12}) v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("send-off")) +v51 := v50.FindInternedVar(lang.NewSymbol("vals")) if v51.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) } v52 := v51.Get() -v53 := lang.Apply(v52, []any{v18, v29}) -_ = v53 -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("release-pending-sends")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) -} -v56 := v55.Get() -v57 := lang.Apply(v56, nil) -_ = v57 -v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v59 := v58.FindInternedVar(lang.NewSymbol("cons")) -if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) -} -v60 := v59.Get() -var v61 any -v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v63 := v62.FindInternedVar(lang.NewSymbol("identical?")) -if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) -} -v64 := v63.Get() -v65 := lang.Apply(v64, []any{v37, v16}) -if lang.IsTruthy(v65) { -v61 = nil -} else { -v61 = v37 -} -v66 := lang.Apply(v35, nil) -v67 := lang.Apply(v60, []any{v61, v66}) -v41 = v67 -} -return v41 -}) -v37 := lang.Apply(lang1.NewLazySeq, []any{v36}) -return v37 -}) -v35 := v34 -_ = v35 -} -v35 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5453), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(5461), lang.NewKeyword("end-column"), int(73)) -v36, err := lang.WithMeta(v34, v35.(lang.IPersistentMap)) +v53 := lang.Apply(v52, []any{v12}) +v54 := lang.NewVector(v49, v53, v23) +v55 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6724), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(6724), lang.NewKeyword("end-column"), int(40)) +v56, err := lang.WithMeta(v54, v55.(lang.IPersistentMap)) if err != nil { panic(err) } -var v33 any = v36 -_ = v33 -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("send-off")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.Apply(v40, []any{v18, v29}) -_ = v41 -v42 := lang.Apply(v33, nil) -return v42 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } +return v56 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -52577,161 +52612,232 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// load-file +// merge-with { -v0 := lang.NewSymbol("load-file").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, nil, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v0 := lang.NewSymbol("merge-with").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("maps"))), lang.NewKeyword("doc"), "Returns a map that consists of the rest of the maps conj-ed onto\n the first. If a key occurs in more than one map, the mapping(s)\n from the latter (left-to-right) will be combined with the mapping in\n the result by calling (f val-in-result val-in-latter).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3050), lang.NewKeyword("end-line"), int(3050))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.NewList(args[1:]...) +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("some")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("identity")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -// unchecked-dec -{ -var v1 lang.FnFunc -{ // function unchecked-dec__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { +v11 := v10.Get() +v12 := lang.Apply(v8, []any{v11, v4}) +if lang.IsTruthy(v12) { +var v14 lang.FnFunc +v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v15 := args[0] +v16 := args[1] +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("key")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v20 := v19.Get() +v21 := lang.Apply(v20, []any{v16}) +var v17 any = v21 +_ = v17 +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("val")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v25 := v24.Get() +v26 := lang.Apply(v25, []any{v16}) +var v22 any = v26 +_ = v22 +var v28 any +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("contains?")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) } -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v31 := v30.Get() +v32 := lang.Apply(v31, []any{v15, v17}) +if lang.IsTruthy(v32) { +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("assoc")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v35 := v34.Get() +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("get")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v15, v17}) +v40 := lang.Apply(v3, []any{v39, v22}) +v41 := lang.Apply(v35, []any{v15, v17, v40}) +v28 = v41 +} else { +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("assoc")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +} +v44 := v43.Get() +v45 := lang.Apply(v44, []any{v15, v17, v22}) +v28 = v45 +} +return v28 +}) +v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3059), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(3063), lang.NewKeyword("end-column"), int(23)) +v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v20 := v19.Get() +var v13 any = v16 +_ = v13 +var v18 lang.FnFunc +v18 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v19 := args[0] +v20 := args[1] v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +v22 := v21.FindInternedVar(lang.NewSymbol("reduce1")) if v22.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } v23 := v22.Get() +var v24 any = v19 +_ = v24 +var v26 any +if lang.IsTruthy(v24) { +v26 = v24 +} else { +v27 := lang.NewMap() +v28 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3065), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(3065), lang.NewKeyword("end-column"), int(35)) +v29, err := lang.WithMeta(v27, v28.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v26 = v29 +} v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +v25 := v24.FindInternedVar(lang.NewSymbol("seq")) if v25.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v27 := lang.Apply(v26, []any{v20}) +v28 := lang.Apply(v23, []any{v13, v26, v27}) +return v28 +}) +v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3064), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(3065), lang.NewKeyword("end-column"), int(47)) +v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/unchecked_dec")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +var v17 any = v20 +_ = v17 +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("reduce1")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v3}) -v35 := lang.Apply(v26, []any{v30, v34}) -v36 := lang.Apply(v23, []any{v35}) -v37 := lang.Apply(v20, []any{v36}) -v38 := lang.Apply(v9, []any{v13, v17, v37}) -v39 := lang.Apply(v6, []any{v38}) -return v39 -}) -v2 := v1 -_ = v2 +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v17, v4}) +v5 = v25 +} else { +v5 = nil } -v0 := lang.NewSymbol("unchecked-dec").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns a number one less than x, a long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1175), lang.NewKeyword("end-line"), int(1175))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) +return v5 } -v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "unchecked_dec") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_dec is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 }) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// volatile? +// meta { -v0 := lang.NewSymbol("volatile?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is a volatile.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2540), lang.NewKeyword("end-line"), int(2540))).(*lang.Symbol) +v0 := lang.NewSymbol("meta").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("obj"))), lang.NewKeyword("doc"), "Returns the metadata of obj, returns nil if there is no metadata.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(202), lang.NewKeyword("end-line"), int(206))).(*lang.Symbol) var v2 lang.FnFunc +{ // function meta v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v4 := args[0] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v6 := v5.Get() -v7 := lang.Apply(v6, []any{lang1.Volatile, v3}) -return v7 +v8 := v7.Get() +v9 := lang.Apply(v8, []any{lang1.IMeta, v4}) +if lang.IsTruthy(v9) { +v10, ok := lang.FieldOrMethod(v4, "Meta") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "Meta"))) +} +var v11 any +switch reflect.TypeOf(v10).Kind() { +case reflect.Func: + v11 = lang.Apply(v10, nil) +default: + v11 = v10 +} +v5 = v11 +} else { +v5 = nil +} +return v5 }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(206), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(208), lang.NewKeyword("end-column"), int(21))).(lang.FnFunc) +v3 := v2 +_ = v3 +} v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// parse-uuid +// methods { -v0 := lang.NewSymbol("parse-uuid").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse a string representing a UUID and return a java.util.UUID instance,\n or nil if parse fails.\n\n Grammar: https://docs.oracle.com/javase/8/docs/api/java/util/UUID.html#toString--", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7989), lang.NewKeyword("end-line"), int(7989))).(*lang.Symbol) +v0 := lang.NewSymbol("methods").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"))), lang.NewKeyword("doc"), "Given a multimethod, returns a map of dispatch values -> dispatch fns", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1809), lang.NewKeyword("end-line"), int(1809))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -var v4 any -func() { -defer func() { -if r := recover(); r != nil { -if lang.CatchMatches(r, nil) { -v5 := r -_ = v5 -v4 = nil -} else { -panic(r) +v4, ok := lang.FieldOrMethod(v3, "getMethodTable") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getMethodTable"))) } +var v5 any +switch reflect.TypeOf(v4).Kind() { +case reflect.Func: + v5 = lang.Apply(v4, nil) +default: + v5 = v4 } -}() -v5 := lang.Apply(nil, []any{v3}) -v4 = v5 -}() -return v4 +return v5 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -52739,525 +52845,609 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// *ns* +// min { -v0 := lang.NewSymbol("*ns*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "A glojure.lang.Namespace object representing the current namespace.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} +var v1 lang.FnFunc +v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v2 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -// resultset-seq -{ -v0 := lang.NewSymbol("resultset-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rs"))), lang.NewKeyword("doc"), "Creates and returns a lazy sequence of structmaps corresponding to\n the rows in the java.sql.ResultSet rs", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5724), lang.NewKeyword("end-line"), int(5724))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v5, _ := lang.FieldOrMethod(v3, "getMetaData") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("getMetaData is not a function"))) +v7 := v6.Get() +if lang.IsTruthy(v7) { +v4 = closed12 +} else { +v4 = v3 } -v6 := lang.Apply(v5, []any{}) -var v4 any = v6 -_ = v4 -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("range")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +var v3 any = v4 +_ = v3 +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("seq")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("inc")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("concat")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } -v13 := v12.Get() -v14, _ := lang.FieldOrMethod(v4, "getColumnCount") -if reflect.TypeOf(v14).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("getColumnCount is not a function"))) +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } -v15 := lang.Apply(v14, []any{}) -v16 := lang.Apply(v13, []any{v15}) -v17 := lang.Apply(v10, []any{int64(1), v16}) -var v7 any = v17 -_ = v7 +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("map")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) if v20.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("comp")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("keyword")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -var v28 lang.FnFunc -v28 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v29 := args[0] -v30, ok := lang.FieldOrMethod(v29, "toLowerCase") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v29, "toLowerCase"))) +v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -var v31 any -switch reflect.TypeOf(v30).Kind() { -case reflect.Func: - v31 = lang.Apply(v30, nil) -default: - v31 = v30 +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("seq")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) } -return v31 -}) -v29 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5731), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(5731), lang.NewKeyword("end-column"), int(62)) -v30, err := lang.WithMeta(v28, v29.(lang.IPersistentMap)) -if err != nil { - panic(err) +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("concat")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) } -v31 := lang.Apply(v24, []any{v27, v30}) +v31 := v30.Get() v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("map")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) if v33.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) } v34 := v33.Get() -var v35 lang.FnFunc -v35 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v36 := args[0] -v37, _ := lang.FieldOrMethod(v4, "getColumnLabel") -if reflect.TypeOf(v37).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("getColumnLabel is not a function"))) +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) } -v38 := lang.Apply(v37, []any{v36}) -return v38 -}) -v36 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5732), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(5732), lang.NewKeyword("end-column"), int(63)) -v37, err := lang.WithMeta(v35, v36.(lang.IPersistentMap)) -if err != nil { - panic(err) +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v2}) +v40 := lang.Apply(v31, []any{v35, v39}) +v41 := lang.Apply(v28, []any{v40}) +v42 := lang.Apply(v25, []any{v41}) +v43 := lang.Apply(v14, []any{v18, v22, v42}) +v44 := lang.Apply(v11, []any{v43}) +return v44 + case 2: +v2 := args[0] +v3 := args[1] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v38 := lang.Apply(v34, []any{v37, v7}) -v39 := lang.Apply(v21, []any{v31, v38}) -var v18 any = v39 -_ = v18 -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("apply")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +v8 := v7.Get() +if lang.IsTruthy(v8) { +v5 = closed12 +} else { +v5 = v4 } -v44 := v43.Get() -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("distinct?")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +var v4 any = v5 +_ = v4 +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("seq")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v47 := v46.Get() -v48 := lang.Apply(v44, []any{v47, v18}) -var v41 any = v48 -_ = v41 -var v50 any -if lang.IsTruthy(v41) { -v50 = v41 -} else { -v51 := lang.Apply(Exception24., []any{"ResultSet must have unique column labels"}) -panic(v51) +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("concat")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } -var v40 any = v50 -_ = v40 -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("apply")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +v15 := v14.Get() +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("list")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -v44 := v43.Get() -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("create-struct")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +v18 := v17.Get() +v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("list")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v47 := v46.Get() -v48 := lang.Apply(v44, []any{v47, v18}) -var v41 any = v48 -_ = v41 -var v50 lang.FnFunc -v50 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { +v22 := v21.Get() +v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("list")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("seq")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("concat")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("list")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v4}) +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("list")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v2}) +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("list")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v3}) +v45 := lang.Apply(v32, []any{v36, v40, v44}) +v46 := lang.Apply(v29, []any{v45}) +v47 := lang.Apply(v26, []any{v46}) +v48 := lang.Apply(v15, []any{v19, v23, v47}) +v49 := lang.Apply(v12, []any{v48}) +return v49 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v2 := args[0] +v3 := args[1] +v4 := lang.NewList(args[2:]...) +var v6 any +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +if lang.IsTruthy(v9) { +v6 = closed12 +} else { +v6 = v5 +} +var v5 any = v6 +_ = v5 +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +var v14 lang.FnFunc +v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v52 := v51.FindInternedVar(lang.NewSymbol("map")) -if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) +v15 := args[0] +v16 := args[1] +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -v53 := v52.Get() -var v54 lang.FnFunc -v54 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v55 := args[0] -v56, _ := lang.FieldOrMethod(v3, "getObject") -if reflect.TypeOf(v56).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("getObject is not a function"))) +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) } -v57 := lang.Apply(v56, []any{v55}) -return v57 -}) -v55 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5737), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(5737), lang.NewKeyword("end-column"), int(71)) -v56, err := lang.WithMeta(v54, v55.(lang.IPersistentMap)) -if err != nil { - panic(err) +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v5}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } -v57 := lang.Apply(v53, []any{v56, v7}) -return v57 +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v15}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v16}) +v52 := lang.Apply(v39, []any{v43, v47, v51}) +v53 := lang.Apply(v36, []any{v52}) +v54 := lang.Apply(v33, []any{v53}) +v55 := lang.Apply(v22, []any{v26, v30, v54}) +v56 := lang.Apply(v19, []any{v55}) +return v56 }) -v51 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5737), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(5737), lang.NewKeyword("end-column"), int(78)) -v52, err := lang.WithMeta(v50, v51.(lang.IPersistentMap)) +v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) +v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) if err != nil { panic(err) } -var v49 any = v52 -_ = v49 -var v54 lang.FnFunc -{ // function thisfn -v54 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -var v56 any -v57, _ := lang.FieldOrMethod(v3, "next") -if reflect.TypeOf(v57).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("next is not a function"))) +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v58 := lang.Apply(v57, []any{}) -if lang.IsTruthy(v58) { -v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v60 := v59.FindInternedVar(lang.NewSymbol("cons")) -if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v61 := v60.Get() -v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v63 := v62.FindInternedVar(lang.NewSymbol("apply")) -if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v64 := v63.Get() -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("struct")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v67 := v66.Get() -v68 := lang.Apply(v49, nil) -v69 := lang.Apply(v64, []any{v67, v41, v68}) -var v70 lang.FnFunc -v70 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v71 := lang.Apply(v55, nil) -return v71 -}) -v71 := lang.Apply(lang1.NewLazySeq, []any{v70}) -v72 := lang.Apply(v61, []any{v69, v71}) -v56 = v72 -} else { -v56 = nil +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -return v56 -}) -v55 := v54 -_ = v55 +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } -v55 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5738), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(5740), lang.NewKeyword("end-column"), int(86)) -v56, err := lang.WithMeta(v54, v55.(lang.IPersistentMap)) -if err != nil { - panic(err) +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -var v53 any = v56 -_ = v53 -v58 := lang.Apply(v53, nil) -return v58 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v5}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v2}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) } -// aget -{ -var v1 lang.FnFunc -{ // function aget__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v3}) +v52 := lang.Apply(v39, []any{v43, v47, v51}) +v53 := lang.Apply(v36, []any{v52}) +v54 := lang.Apply(v33, []any{v53}) +v55 := lang.Apply(v22, []any{v26, v30, v54}) +v56 := lang.Apply(v19, []any{v55}) +v57 := lang.Apply(v13, []any{v16, v56, v4}) +return v57 + } +}) +v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } -v7 := v6.Get() +v5 := lang.Apply(v4, []any{v3, int64(1)}) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v0 := lang.NewSymbol("min").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the least of the nums.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1118), lang.NewKeyword("end-line"), int(1118))).(*lang.Symbol) +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v5 := args[0] +return v5 + case 2: +v5 := args[0] +v6 := args[1] +v7, _ := lang.FieldOrMethod(lang1.Numbers, "min") +if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("min is not a function"))) +} +v8 := lang.Apply(v7, []any{v5, v6}) +return v8 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +v6 := args[1] +v7 := lang.NewList(args[2:]...) v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("concat")) +v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) if v9.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } v10 := v9.Get() v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("list")) +v12 := v11.FindInternedVar(lang.NewSymbol("min")) if v12.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } v13 := v12.Get() -v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("seq")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("concat")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("list")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/Aget")}) -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("seq")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) -} -v41 := v40.Get() -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("concat")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) -} -v44 := v43.Get() -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("list")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.Apply(v47, []any{lang.NewSymbol("glojure.core/int")}) -v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v50 := v49.FindInternedVar(lang.NewSymbol("list")) -if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("min")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v51 := v50.Get() -v52 := lang.Apply(v51, []any{v4}) -v53 := lang.Apply(v44, []any{v48, v52}) -v54 := lang.Apply(v41, []any{v53}) -v55 := lang.Apply(v38, []any{v54}) -v56 := lang.Apply(v27, []any{v31, v35, v55}) -v57 := lang.Apply(v24, []any{v56}) -v58 := lang.Apply(v21, []any{v57}) -v59 := lang.Apply(v10, []any{v14, v18, v58}) -v60 := lang.Apply(v7, []any{v59}) -return v60 +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v5, v6}) +v18 := lang.Apply(v10, []any{v13, v17, v7}) +return v18 + } }) -v2 := v1 -_ = v2 +v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v3 := ns.InternWithValue(v0, v4, true) +if v0.Meta() != nil { + v3.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v0 := lang.NewSymbol("aget").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("&"), lang.NewSymbol("idxs"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the value at the index/indices. Works on Java arrays of all\n types.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3911), lang.NewKeyword("end-line"), int(3911))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { +} +// min-key +{ +v0 := lang.NewSymbol("min-key").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Returns the x for which (k x), a number, is least.\n\n If there are multiple such xs, the last one is returned.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5033), lang.NewKeyword("end-line"), int(5033))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 2: -v4 := args[0] -v5 := args[1] -v6 := lang.Apply(lang1.Get, []any{v4, v5}) -return v6 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6 := lang.NewList(args[2:]...) +v3 := args[0] +v4 := args[1] +return v4 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +var v6 any v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("apply")) +v8 := v7.FindInternedVar(lang.NewSymbol("<")) if v8.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("aget")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v10 := lang.Apply(v3, []any{v4}) +v11 := lang.Apply(v3, []any{v5}) +v12 := lang.Apply(v9, []any{v10, v11}) +if lang.IsTruthy(v12) { +v6 = v4 +} else { +v6 = v5 } -v12 := v11.Get() +return v6 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v8 := lang.Apply(v3, []any{v4}) +var v7 any = v8 +_ = v7 +v10 := lang.Apply(v3, []any{v5}) +var v9 any = v10 +_ = v9 +var v12 any v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("aget")) +v14 := v13.FindInternedVar(lang.NewSymbol("<")) if v14.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } v15 := v14.Get() -v16 := lang.Apply(v15, []any{v4, v5}) -v17 := lang.Apply(v9, []any{v12, v16, v6}) -return v17 - } -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +v16 := lang.Apply(v15, []any{v7, v9}) +if lang.IsTruthy(v16) { +v17 := lang.NewVector(v4, v7) +v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5043), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(5043), lang.NewKeyword("end-column"), int(36)) +v19, err := lang.WithMeta(v17, v18.(lang.IPersistentMap)) +if err != nil { + panic(err) } +v12 = v19 +} else { +v20 := lang.NewVector(v5, v9) +v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5043), lang.NewKeyword("column"), int(38), lang.NewKeyword("end-line"), int(5043), lang.NewKeyword("end-column"), int(43)) +v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) +if err != nil { + panic(err) } -// sequence -{ -v0 := lang.NewSymbol("sequence").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("coll"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Coerces coll to a (possibly empty) sequence, if it is not already\n one. Will not force a lazy seq. (sequence nil) yields (), When a\n transducer is supplied, returns a lazy sequence of applications of\n the transform to the items in coll(s), i.e. to the set of first\n items of each coll, followed by the set of second\n items in each coll, until any one of the colls is exhausted. Any\n remaining items in other colls are ignored. The transform should accept\n number-of-colls arguments", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2639), lang.NewKeyword("end-line"), int(2639))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v12 = v22 } -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -if lang.IsTruthy(v8) { -v4 = v3 -} else { -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("seq")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +var v11 any = v12 +_ = v11 +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("nth")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -v12 := v11.Get() -v13 := lang.Apply(v12, []any{v3}) -var v9 any = v13 -_ = v9 -var v15 any -if lang.IsTruthy(v9) { -v15 = v9 +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v11, int64(0), nil}) +var v23 any = v27 +_ = v23 +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("nth")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.Apply(v31, []any{v11, int64(1), nil}) +var v28 any = v32 +_ = v28 +var v34 any = v34 +_ = v34 +var v35 any = v35 +_ = v35 +var v36 any = v36 +_ = v36 +var v37 any +for { +var v38 any +if lang.IsTruthy(v36) { +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("first")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v36}) +var v39 any = v43 +_ = v39 +v45 := lang.Apply(v3, []any{v39}) +var v44 any = v45 +_ = v44 +var v47 any +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("<=")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v44, v35}) +if lang.IsTruthy(v51) { +var v52 any = v39 +var v53 any = v44 +v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v56 := v55.FindInternedVar(lang.NewSymbol("next")) +if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) +} +v57 := v56.Get() +v58 := lang.Apply(v57, []any{v36}) +var v54 any = v58 +v34 = v52 +v35 = v53 +v36 = v54 +continue } else { -v15 = lang.NewList() +var v59 any = v34 +var v60 any = v35 +v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v63 := v62.FindInternedVar(lang.NewSymbol("next")) +if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) } -v4 = v15 +v64 := v63.Get() +v65 := lang.Apply(v64, []any{v36}) +var v61 any = v65 +v34 = v59 +v35 = v60 +v36 = v61 +continue } -return v4 - case 2: -v3 := args[0] -v4 := args[1] -v6 := lang.Apply(nil, []any{v4}) -v7 := lang.Apply(nil, []any{v3, v6}) -v8 := lang.Apply(nil, []any{v7}) -var v5 any = v8 -_ = v5 -var v10 any -if lang.IsTruthy(v5) { -v10 = v5 +v38 = v47 } else { -v10 = lang.NewList() +v38 = v34 } -return v10 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("map")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v37 = v38 + break } -v9 := v8.Get() -var v10 lang.FnFunc -v10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) +return v37 } -v11 := args[0] -v12 := lang.Apply(nil, []any{v11}) -return v12 }) -v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2661), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(2661), lang.NewKeyword("end-column"), int(41)) -v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("cons")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v4, v5}) -v17 := lang.Apply(v9, []any{v12, v16}) -v18 := lang.Apply(nil, []any{v3, v17}) -v19 := lang.Apply(nil, []any{v18}) -var v6 any = v19 -_ = v6 -var v21 any -if lang.IsTruthy(v6) { -v21 = v6 -} else { -v21 = lang.NewList() } -return v21 +// mix-collection-hash +{ +v0 := lang.NewSymbol("mix-collection-hash").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("hash-basis"), lang.NewSymbol("count"))), lang.NewKeyword("doc"), "Mix final collection hash for ordered or unordered collections.\n hash-basis is the combined collection hash, count is the number\n of elements included in the basis. Note this is the hash code\n consistent with =, different from .hashCode.\n See http://glojure.org/data_structures#hash for full algorithms.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5199), lang.NewKeyword("end-line"), int(5199))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } +v3 := args[0] +v4 := args[1] +v5 := lang.Apply(nil, []any{v3, v4}) +return v5 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -53265,168 +53455,129 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// drop-while +// mk-bound-fn { -v0 := lang.NewSymbol("drop-while").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred")), lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the items in coll starting from the\n first item for which (pred item) returns logical false. Returns a\n stateful transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2950), lang.NewKeyword("end-line"), int(2950))).(*lang.Symbol) +v0 := lang.NewSymbol("mk-bound-fn").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5127), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(5127), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sc"), lang.NewSymbol("test"), lang.NewSymbol("key"))), lang.NewKeyword("private"), true, lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { +v4 := args[1] +v5 := args[2] +var v6 lang.FnFunc +v6 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v5 := args[0] -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("volatile!")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{true}) -var v6 any = v10 -_ = v6 -var v12 lang.FnFunc -v12 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v13 := lang.Apply(v5, nil) -return v13 - case 1: -v13 := args[0] -v14 := lang.Apply(v5, []any{v13}) -return v14 - case 2: -v13 := args[0] -v14 := args[1] -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("deref")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +v7 := args[0] +v8, ok := lang.FieldOrMethod(v3, "comparator") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "comparator"))) } -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v6}) -var v15 any = v19 -_ = v15 -var v21 any -var v22 any = v15 -_ = v22 -var v24 any -if lang.IsTruthy(v22) { -v25 := lang.Apply(v3, []any{v14}) -v24 = v25 -} else { -v24 = v22 +var v9 any +switch reflect.TypeOf(v8).Kind() { +case reflect.Func: + v9 = lang.Apply(v8, nil) +default: + v9 = v8 } -if lang.IsTruthy(v24) { -v21 = v13 -} else { -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("vreset!")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v10, _ := lang.FieldOrMethod(v3, "entryKey") +if reflect.TypeOf(v10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("entryKey is not a function"))) } -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v6, nil}) -_ = v25 -v26 := lang.Apply(v5, []any{v13, v14}) -v21 = v26 +v11 := lang.Apply(v10, []any{v7}) +v12, _ := lang.FieldOrMethod(v9, "compare") +if reflect.TypeOf(v12).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("compare is not a function"))) } -return v21 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } +v13 := lang.Apply(v12, []any{v11, v5}) +v14 := lang.Apply(v4, []any{v13, int64(0)}) +return v14 }) -v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2959), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(2968), lang.NewKeyword("end-column"), int(42)) -v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) +v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5130), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(5131), lang.NewKeyword("end-column"), int(64)) +v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) if err != nil { panic(err) } -return v14 +return v8 }) -v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2957), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2968), lang.NewKeyword("end-column"), int(44)) -v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) -if err != nil { - panic(err) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -return v6 - case 2: -v3 := args[0] -v4 := args[1] -var v6 lang.FnFunc -v6 = lang.NewFnFunc(func(args ...any) any { +} +// mod +{ +v0 := lang.NewSymbol("mod").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"), lang.NewSymbol("div"))), lang.NewKeyword("doc"), "Modulus of num and div. Truncates toward negative infinity.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3567), lang.NewKeyword("end-line"), int(3567))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v7 := args[0] -v8 := args[1] -recur_loop_552: -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("seq")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v3 := args[0] +v4 := args[1] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("rem")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v12 := v11.Get() -v13 := lang.Apply(v12, []any{v8}) -var v9 any = v13 -_ = v9 -var v15 any -var v16 any = v9 -_ = v16 +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v3, v4}) +var v5 any = v9 +_ = v5 +var v11 any +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("zero?")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v5}) +var v12 any = v16 +_ = v12 var v18 any -if lang.IsTruthy(v16) { +if lang.IsTruthy(v12) { +v18 = v12 +} else { v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("first")) +v20 := v19.FindInternedVar(lang.NewSymbol("=")) if v20.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } v21 := v20.Get() -v22 := lang.Apply(v21, []any{v9}) -v23 := lang.Apply(v7, []any{v22}) -v18 = v23 -} else { -v18 = v16 +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("pos?")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -if lang.IsTruthy(v18) { -var v16 any = v7 -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("rest")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v3}) +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("pos?")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) } -v20 := v19.Get() -v21 := lang.Apply(v20, []any{v9}) -var v17 any = v21 -v7 = v16 -v8 = v17 -goto recur_loop_552 +v28 := v27.Get() +v29 := lang.Apply(v28, []any{v4}) +v30 := lang.Apply(v21, []any{v25, v29}) +v18 = v30 +} +if lang.IsTruthy(v18) { +v11 = v5 } else { -v15 = v9 +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("+")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } -return v15 -}) -v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2970), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(2974), lang.NewKeyword("end-column"), int(26)) -v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) -if err != nil { - panic(err) +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v5, v4}) +v11 = v15 } -var v5 any = v8 -_ = v5 -var v10 lang.FnFunc -v10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v11 := lang.Apply(v5, []any{v3, v4}) -return v11 -}) -v11 := lang.Apply(lang1.NewLazySeq, []any{v10}) return v11 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -53434,254 +53585,323 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// chunk-next +// name { -v0 := lang.NewSymbol("chunk-next").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(700), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(700), lang.NewKeyword("end-column"), int(71), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { +v1 := reflect.TypeOf("") +v0 := lang.NewSymbol("name").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns the name String of a string, symbol or keyword.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1585), lang.NewKeyword("end-line"), int(1585))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := args[0] -v4, ok := lang.FieldOrMethod(v3, "chunkedNext") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "chunkedNext"))) -} +v4 := args[0] var v5 any -switch reflect.TypeOf(v4).Kind() { -case reflect.Func: - v5 = lang.Apply(v4, nil) -default: - v5 = v4 +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("string?")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v4}) +if lang.IsTruthy(v9) { +v5 = v4 +} else { +v10, _ := lang.FieldOrMethod(v4, "Name") +if reflect.TypeOf(v10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Name is not a function"))) +} +v11 := lang.Apply(v10, []any{}) +v5 = v11 } return v5 }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) +v4 := reflect.TypeOf("") +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// list? +// namespace { -v0 := lang.NewSymbol("list?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements IPersistentList", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6241), lang.NewKeyword("end-line"), int(6241))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { +v1 := reflect.TypeOf("") +v0 := lang.NewSymbol("namespace").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns the namespace String of a symbol or keyword, or nil if not present.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1593), lang.NewKeyword("end-line"), int(1593))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v4 := args[0] +v5, _ := lang.FieldOrMethod(v4, "Namespace") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Namespace is not a function"))) } -v6 := v5.Get() -v7 := lang.Apply(v6, []any{lang1.IPersistentList, v3}) -return v7 +v6 := lang.Apply(v5, []any{}) +return v6 }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// global-hierarchy -{ -v0 := lang.NewSymbol("global-hierarchy").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5556), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(5557), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, lang.NewMap(lang.NewKeyword("parents"), lang.NewMap(), lang.NewKeyword("descendants"), lang.NewMap(), lang.NewKeyword("ancestors"), lang.NewMap()), true) +v4 := reflect.TypeOf("") +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// int-array +// nary-inline { -var v1 lang.FnFunc -{ // function int-array__inliner -v1 = lang.NewFnFunc(func(args ...any) any { +v0 := lang.NewSymbol("nary-inline").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(948), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(948), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("op")), lang.NewVector(lang.NewSymbol("op"), lang.NewSymbol("unchecked-op"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewList(args[0:]...) + case 1: +v3 := args[0] v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +v5 := v4.FindInternedVar(lang.NewSymbol("nary-inline")) if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v7 := lang.Apply(v6, []any{v3, v3}) +return v7 + case 2: +v3 := args[0] +v4 := args[1] +var v5 lang.FnFunc +v5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v6 := args[0] +var v8 any +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -v9 := v8.Get() +v11 := v10.Get() +if lang.IsTruthy(v11) { +v8 = v4 +} else { +v8 = v7 +} +var v7 any = v8 +_ = v7 +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("seq")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("concat")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{lang.NewSymbol(".")}) +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("seq")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("concat")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v7}) +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v6}) +v44 := lang.Apply(v35, []any{v39, v43}) +v45 := lang.Apply(v32, []any{v44}) +v46 := lang.Apply(v29, []any{v45}) +v47 := lang.Apply(v18, []any{v22, v26, v46}) +v48 := lang.Apply(v15, []any{v47}) +return v48 + case 2: +v6 := args[0] +v7 := args[1] +var v9 any v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) +v11 := v10.FindInternedVar(lang.NewSymbol("*unchecked-math*")) if v11.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +if lang.IsTruthy(v12) { +v9 = v4 +} else { +v9 = v8 +} +var v8 any = v9 +_ = v8 v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) +v15 := v14.FindInternedVar(lang.NewSymbol("seq")) if v15.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("concat")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v20 := v19.Get() -v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/intArray")}) -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("list")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("list")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("seq")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +v22 := v21.Get() +v23 := lang.Apply(v22, []any{lang.NewSymbol(".")}) +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("list")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -v27 := v26.Get() +v26 := v25.Get() +v27 := lang.Apply(v26, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("concat")) +v29 := v28.FindInternedVar(lang.NewSymbol("list")) if v29.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } v30 := v29.Get() v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) +v32 := v31.FindInternedVar(lang.NewSymbol("seq")) if v32.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } v33 := v32.Get() -v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("list")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("concat")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } -v37 := v36.Get() -v38 := lang.Apply(v37, []any{lang.NewSymbol("glojure.core/args")}) -v39 := lang.Apply(v30, []any{v34, v38}) -v40 := lang.Apply(v27, []any{v39}) -v41 := lang.Apply(v24, []any{v40}) -v42 := lang.Apply(v9, []any{v13, v17, v21, v41}) -v43 := lang.Apply(v6, []any{v42}) -return v43 - } -}) -v2 := v1 -_ = v2 +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("list")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -v0 := lang.NewSymbol("int-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Creates an array of ints", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5356), lang.NewKeyword("end-line"), int(5356))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "intArray") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("intArray is not a function"))) +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v8}) +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("list")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } -v6 := lang.Apply(v5, []any{v4}) -return v6 - case 2: -v4 := args[0] -v5 := args[1] -v6, _ := lang.FieldOrMethod(lang1.Numbers, "intArrayInit") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("intArrayInit is not a function"))) +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v6}) +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("list")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) } -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 +v47 := v46.Get() +v48 := lang.Apply(v47, []any{v7}) +v49 := lang.Apply(v36, []any{v40, v44, v48}) +v50 := lang.Apply(v33, []any{v49}) +v51 := lang.Apply(v30, []any{v50}) +v52 := lang.Apply(v19, []any{v23, v27, v51}) +v53 := lang.Apply(v16, []any{v52}) +return v53 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// emit-extend-protocol -{ -v0 := lang.NewSymbol("emit-extend-protocol").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(205), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(205), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("p"), lang.NewSymbol("specs"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("parse-impls")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v4}) -var v5 any = v9 -_ = v5 + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v6 := args[0] +v7 := args[1] +v8 := lang.NewList(args[2:]...) +var v10 any v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("seq")) +v12 := v11.FindInternedVar(lang.NewSymbol("*unchecked-math*")) if v12.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("concat")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +if lang.IsTruthy(v13) { +v10 = v4 +} else { +v10 = v9 } -v16 := v15.Get() -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("list")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +var v9 any = v10 +_ = v9 +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("reduce1")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } -v19 := v18.Get() -v20 := lang.Apply(v19, []any{lang.NewSymbol("do")}) +v17 := v16.Get() +var v18 lang.FnFunc +v18 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v19 := args[0] +v20 := args[1] v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("map")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) if v22.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } v23 := v22.Get() -var v24 lang.FnFunc -v24 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v25 := args[0] -var v26 any = v25 -_ = v26 -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("nth")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -v30 := v29.Get() -v31 := lang.Apply(v30, []any{v26, int64(0), nil}) -var v27 any = v31 -_ = v27 -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("nth")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v26, int64(1), nil}) -var v32 any = v36 -_ = v32 +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol(".")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("list")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v39 := v38.FindInternedVar(lang.NewSymbol("seq")) if v39.IsMacro() { @@ -53700,94 +53920,115 @@ if v45.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } v46 := v45.Get() -v47 := lang.Apply(v46, []any{lang.NewSymbol("glojure.core/extend-type")}) +v47 := lang.Apply(v46, []any{v9}) v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v49 := v48.FindInternedVar(lang.NewSymbol("list")) if v49.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) } v50 := v49.Get() -v51 := lang.Apply(v50, []any{v27}) +v51 := lang.Apply(v50, []any{v19}) v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v53 := v52.FindInternedVar(lang.NewSymbol("list")) if v53.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) } v54 := v53.Get() -v55 := lang.Apply(v54, []any{v3}) -v56 := lang.Apply(v43, []any{v47, v51, v55, v32}) +v55 := lang.Apply(v54, []any{v20}) +v56 := lang.Apply(v43, []any{v47, v51, v55}) v57 := lang.Apply(v40, []any{v56}) -return v57 +v58 := lang.Apply(v37, []any{v57}) +v59 := lang.Apply(v26, []any{v30, v34, v58}) +v60 := lang.Apply(v23, []any{v59}) +return v60 }) -v25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(208), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(209), lang.NewKeyword("end-column"), int(42)) -v26, err := lang.WithMeta(v24, v25.(lang.IPersistentMap)) +v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) +v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) if err != nil { panic(err) } -v27 := lang.Apply(v23, []any{v26, v5}) -v28 := lang.Apply(v16, []any{v20, v27}) -v29 := lang.Apply(v13, []any{v28}) -return v29 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -// aset-double -{ -v0 := lang.NewSymbol("aset-double").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of double. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3966), lang.NewKeyword("end-line"), int(3968))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("double")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v5}) -v10, _ := lang.FieldOrMethod(nil, "setDouble") -if reflect.TypeOf(v10).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setDouble is not a function"))) +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol(".")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -v11 := lang.Apply(v10, []any{v3, v4, v9}) -_ = v11 -return v5 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("apply")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v33 := v32.Get() +v34 := lang.Apply(v33, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("list")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) } -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("aset-double")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v37 := v36.Get() +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("seq")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) } -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("aget")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("concat")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v3, v4}) -v17 := lang.Apply(v9, []any{v12, v16, v5, v6}) -return v17 +v43 := v42.Get() +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v9}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v6}) +v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v53 := v52.FindInternedVar(lang.NewSymbol("list")) +if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) +} +v54 := v53.Get() +v55 := lang.Apply(v54, []any{v7}) +v56 := lang.Apply(v43, []any{v47, v51, v55}) +v57 := lang.Apply(v40, []any{v56}) +v58 := lang.Apply(v37, []any{v57}) +v59 := lang.Apply(v26, []any{v30, v34, v58}) +v60 := lang.Apply(v23, []any{v59}) +v61 := lang.Apply(v17, []any{v20, v60, v8}) +return v61 + } +}) +v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86)) +v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -53796,173 +54037,84 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// promise +// nat-int? { -v0 := lang.NewSymbol("promise").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Returns a promise object that can be read with deref/@, and set,\n once only, with deliver. Calls to deref/@ prior to delivery will\n block, unless the variant of deref with timeout is used. All\n subsequent derefs will return the same delivered value without\n blocking. See also - realized?.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7121), lang.NewKeyword("end-line"), int(7121))).(*lang.Symbol) +v0 := lang.NewSymbol("nat-int?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a non-negative fixed precision integer", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1415), lang.NewKeyword("end-line"), int(1415))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v4 := lang.Apply(java.util.concurrent.CountDownLatch29., []any{int64(1)}) -var v3 any = v4 -_ = v3 -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("atom")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +v3 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("int?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v3}) -var v5 any = v9 -_ = v5 +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +var v4 any = v8 +_ = v4 +var v10 any +if lang.IsTruthy(v4) { v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("deref")) +v12 := v11.FindInternedVar(lang.NewSymbol("not")) if v12.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } v13 := v12.Get() -v14 := lang.NewVector(nil) -v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7134), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(7134), lang.NewKeyword("end-column"), int(17)) -v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v17, ok := lang.FieldOrMethod(v3, "await") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "await"))) -} -var v18 any -switch reflect.TypeOf(v17).Kind() { -case reflect.Func: - v18 = lang.Apply(v17, nil) -default: - v18 = v17 -} -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("deref")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v5}) -v23 := lang.Apply(v13, []any{v16, v18, v22}) -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("deref")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.NewVector(nil, nil, nil) -v28 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7137), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(7137), lang.NewKeyword("end-column"), int(34)) -v29, err := lang.WithMeta(v27, v28.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v30 any -v31, _ := lang.FieldOrMethod(v3, "await") -if reflect.TypeOf(v31).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) -} -v32 := lang.Apply(v31, []any{nil, time27.Millisecond}) -if lang.IsTruthy(v32) { -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("deref")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v5}) -v30 = v36 -} else { -v30 = nil -} -v37 := lang.Apply(v26, []any{v29, v30}) -v38 := lang.NewVector(nil) -v39 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7142), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(7142), lang.NewKeyword("end-column"), int(24)) -v40, err := lang.WithMeta(v38, v39.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("zero?")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44, ok := lang.FieldOrMethod(v3, "getCount") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getCount"))) -} -var v45 any -switch reflect.TypeOf(v44).Kind() { -case reflect.Func: - v45 = lang.Apply(v44, nil) -default: - v45 = v44 -} -v46 := lang.Apply(v43, []any{v45}) -v47 := lang.Apply(nil, []any{v40, v46}) -v48 := lang.NewVector(nil, nil) -v49 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7146), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(7146), lang.NewKeyword("end-column"), int(14)) -v50, err := lang.WithMeta(v48, v49.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v51 any -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("pos?")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) -} -v55 := v54.Get() -v56, ok := lang.FieldOrMethod(v3, "getCount") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getCount"))) -} -var v57 any -switch reflect.TypeOf(v56).Kind() { -case reflect.Func: - v57 = lang.Apply(v56, nil) -default: - v57 = v56 -} -v58 := lang.Apply(v55, []any{v57}) -var v52 any = v58 -_ = v52 -var v60 any -if lang.IsTruthy(v52) { -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("compare-and-set!")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("neg?")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v63 := v62.Get() -v64 := lang.Apply(v63, []any{v5, v3, nil}) -v60 = v64 +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v3}) +v18 := lang.Apply(v13, []any{v17}) +v10 = v18 } else { -v60 = v52 +v10 = v4 } -if lang.IsTruthy(v60) { -v52, ok := lang.FieldOrMethod(v3, "countDown") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "countDown"))) +return v10 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -var v53 any -switch reflect.TypeOf(v52).Kind() { -case reflect.Func: - v53 = lang.Apply(v52, nil) -default: - v53 = v52 } -_ = v53 -v51 = nil +// neg-int? +{ +v0 := lang.NewSymbol("neg-int?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a negative fixed precision integer", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1409), lang.NewKeyword("end-line"), int(1409))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("int?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +var v4 any = v8 +_ = v4 +var v10 any +if lang.IsTruthy(v4) { +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("neg?")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v3}) +v10 = v14 } else { -v51 = nil +v10 = v4 } -v54 := lang.Apply(nil, []any{v50, v51}) -v55 := lang.Apply(nil, []any{lang1.IDeref, v23, lang1.IBlockingDeref, v37, lang1.IPending, v47, glojure.lang11.IFn, v54}) -return v55 +return v10 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -53970,23 +54122,126 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// associative? +// neg? { -v0 := lang.NewSymbol("associative?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements Associative", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6266), lang.NewKeyword("end-line"), int(6266))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { +var v1 lang.FnFunc +{ // function neg?__inliner +v1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -v7 := lang.Apply(v6, []any{glojure.lang11.Associative, v3}) -return v7 +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/isNeg")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v3}) +v35 := lang.Apply(v26, []any{v30, v34}) +v36 := lang.Apply(v23, []any{v35}) +v37 := lang.Apply(v20, []any{v36}) +v38 := lang.Apply(v9, []any{v13, v17, v37}) +v39 := lang.Apply(v6, []any{v38}) +return v39 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("neg?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns true if num is less than zero, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1259), lang.NewKeyword("end-line"), int(1259))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "isNeg") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("isNeg is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// newline +{ +v0 := lang.NewSymbol("newline").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Writes a platform-specific newline to *out*", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3698), lang.NewKeyword("end-line"), int(3698))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v4 := v3.FindInternedVar(lang.NewSymbol("*out*")) +if v4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) +} +v5 := v4.Get() +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("system-newline")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(lang1.AppendWriter, []any{v5, v8}) +_ = v9 +return nil }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -53994,1345 +54249,1512 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// push-thread-bindings +// next { -v0 := lang.NewSymbol("push-thread-bindings").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"))), lang.NewKeyword("doc"), "WARNING: This is a low-level function. Prefer high-level macros like\n binding where ever possible.\n\n Takes a map of Var/value pairs. Binds each Var to the associated value for\n the current thread. Each call *MUST* be accompanied by a matching call to\n pop-thread-bindings wrapped in a try-finally!\n \n (push-thread-bindings bindings)\n (try\n ...\n (finally\n (pop-thread-bindings)))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(26), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1911), lang.NewKeyword("end-line"), int(1911))).(*lang.Symbol) +v1 := reflect.TypeOf((*lang1.ISeq)(nil)).Elem() +v0 := lang.NewSymbol("next").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a seq of the items after the first. Calls seq on its\n argument. If there are no more items, returns nil.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(55), lang.NewKeyword("end-line"), int(61))).(*lang.Symbol) +var v3 lang.FnFunc +{ // function next +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +v6 := lang.Apply(lang1.Next, []any{v5}) +return v6 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(61), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(61), lang.NewKeyword("end-column"), int(77))).(lang.FnFunc) +v4 := v3 +_ = v4 +} +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// nfirst +{ +v0 := lang.NewSymbol("nfirst").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Same as (next (first x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(105), lang.NewKeyword("end-line"), int(109))).(*lang.Symbol) var v2 lang.FnFunc +{ // function nfirst v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := args[0] -v4 := lang.Apply(lang1.PushThreadBindings, []any{v3}) -return v4 +v4 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("next")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("first")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v4}) +v12 := lang.Apply(v7, []any{v11}) +return v12 }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(109), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(109), lang.NewKeyword("end-column"), int(49))).(lang.FnFunc) +v3 := v2 +_ = v3 +} v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// comparator +// nil? { -v0 := lang.NewSymbol("comparator").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"))), lang.NewKeyword("doc"), "Returns an implementation of java.util.Comparator based upon pred.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3077), lang.NewKeyword("end-line"), int(3077))).(*lang.Symbol) +v1 := reflect.TypeOf(false) var v2 lang.FnFunc +{ // function nil?__inliner v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := args[0] +v4 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("list")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Identical"), v4, nil}) +return v8 +}) +v3 := v2 +_ = v3 +} +v0 := lang.NewSymbol("nil?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v2, lang.NewKeyword("doc"), "Returns true if x is nil, false otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(435), lang.NewKeyword("end-line"), int(435))).(*lang.Symbol) var v4 lang.FnFunc v4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v5 := args[0] -v6 := args[1] -var v7 any -v8 := lang.Apply(v3, []any{v5, v6}) -if lang.IsTruthy(v8) { -v7 = int64(-1) -} else { -var v9 any -v10 := lang.Apply(v3, []any{v6, v5}) -if lang.IsTruthy(v10) { -v9 = int64(1) -} else { -var v11 any -if lang.IsTruthy(lang.NewKeyword("else")) { -v11 = int64(0) -} else { -v11 = nil +v6 := lang.Apply(lang1.IsNil, []any{v5}) +return v6 +}) +v5 := reflect.TypeOf(false) +v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v5)).(lang.FnFunc) +v3 := ns.InternWithValue(v0, v4, true) +if v0.Meta() != nil { + v3.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v9 = v11 } -v7 = v9 +// nnext +{ +v0 := lang.NewSymbol("nnext").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Same as (next (next x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(119), lang.NewKeyword("end-line"), int(123))).(*lang.Symbol) +var v2 lang.FnFunc +{ // function nnext +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("next")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -return v7 -}) -v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3082), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(3083), lang.NewKeyword("end-column"), int(48)) -v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) -if err != nil { - panic(err) +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("next")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -return v6 +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v4}) +v12 := lang.Apply(v7, []any{v11}) +return v12 }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(123), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(123), lang.NewKeyword("end-column"), int(46))).(lang.FnFunc) +v3 := v2 +_ = v3 +} v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// partition-all +// normalize-slurp-opts { -v0 := lang.NewSymbol("partition-all").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of lists like partition, but may include\n partitions with fewer than n items at the end. Returns a stateful\n transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7265), lang.NewKeyword("end-line"), int(7265))).(*lang.Symbol) +v0 := lang.NewSymbol("normalize-slurp-opts").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7017), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7017), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("opts"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v5 := args[0] -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("to-array")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v3 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("string?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v3}) -v11 := lang.Apply(lang1.NewArrayList, []any{v10}) -var v6 any = v11 -_ = v6 -var v13 lang.FnFunc -v13 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v14 := lang.Apply(v5, nil) -return v14 - case 1: -v14 := args[0] -var v16 any -v17, ok := lang.FieldOrMethod(v6, "isEmpty") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "isEmpty"))) +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("first")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -var v18 any -switch reflect.TypeOf(v17).Kind() { -case reflect.Func: - v18 = lang.Apply(v17, nil) -default: - v18 = v17 +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v3}) +v12 := lang.Apply(v7, []any{v11}) +if lang.IsTruthy(v12) { +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("println")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } -if lang.IsTruthy(v18) { -v16 = v15 -} else { -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("vec")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +v15 := v14.Get() +v16 := lang.Apply(v15, []any{"WARNING: (slurp f enc) is deprecated, use (slurp f :encoding enc)."}) +_ = v16 +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("first")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v22 := v21.Get() -v23, ok := lang.FieldOrMethod(v6, "toArray") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "toArray"))) +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v3}) +v21 := lang.NewVector(lang.NewKeyword("encoding"), v20) +v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7022), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(7022), lang.NewKeyword("end-column"), int(30)) +v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) +if err != nil { + panic(err) } -var v24 any -switch reflect.TypeOf(v23).Kind() { -case reflect.Func: - v24 = lang.Apply(v23, nil) -default: - v24 = v23 +v4 = v23 +} else { +v4 = v3 } -v25 := lang.Apply(v22, []any{v24}) -var v19 any = v25 -_ = v19 -v27, ok := lang.FieldOrMethod(v6, "clear") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "clear"))) +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -var v28 any -switch reflect.TypeOf(v27).Kind() { -case reflect.Func: - v28 = lang.Apply(v27, nil) -default: - v28 = v27 } -_ = v28 -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("unreduced")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +// not +{ +v1 := reflect.TypeOf(false) +v0 := lang.NewSymbol("not").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is logical false, false otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(523), lang.NewKeyword("end-line"), int(523))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +var v5 any +if lang.IsTruthy(v4) { +v5 = false +} else { +v5 = true } -v31 := v30.Get() -v32 := lang.Apply(v5, []any{v15, v19}) -v33 := lang.Apply(v31, []any{v32}) -v16 = v33 +return v5 +}) +v4 := reflect.TypeOf(false) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } -var v15 any = v16 -_ = v15 -v20 := lang.Apply(v5, []any{v15}) -return v20 +} +// not-any? +{ +v1 := reflect.TypeOf(false) +v0 := lang.NewSymbol("not-any?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns false if (pred x) is logical true for any x in coll,\n else true.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(2696), lang.NewKeyword("end-line"), int(2701))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v4 := lang.Apply(closed14, nil) +v5 := lang.Apply(closed13, []any{v4}) +return v5 + case 1: +v4 := args[0] +v5 := lang.Apply(closed14, []any{v4}) +v6 := lang.Apply(closed13, []any{v5}) +return v6 case 2: -v14 := args[0] -v15 := args[1] -v16, _ := lang.FieldOrMethod(v6, "add") -if reflect.TypeOf(v16).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) +v4 := args[0] +v5 := args[1] +v6 := lang.Apply(closed14, []any{v4, v5}) +v7 := lang.Apply(closed13, []any{v6}) +return v7 + case 3: +v4 := args[0] +v5 := args[1] +v6 := args[2] +v7 := lang.Apply(closed14, []any{v4, v5, v6}) +v8 := lang.Apply(closed13, []any{v7}) +return v8 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := args[1] +v6 := args[2] +v7 := lang.NewList(args[3:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("apply")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v17 := lang.Apply(v16, []any{v15}) -_ = v17 -var v18 any -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("=")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v10 := v9.Get() +v11 := lang.Apply(v10, []any{closed14, v4, v5, v6, v7}) +v12 := lang.Apply(closed13, []any{v11}) +return v12 + } +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2559), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2564), lang.NewKeyword("end-column"), int(49))).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// not-empty +{ +v0 := lang.NewSymbol("not-empty").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "If coll is empty, returns nil, else coll", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5559), lang.NewKeyword("end-line"), int(5559))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v21 := v20.Get() -v22, ok := lang.FieldOrMethod(v6, "size") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "size"))) +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +if lang.IsTruthy(v8) { +v4 = v3 +} else { +v4 = nil } -var v23 any -switch reflect.TypeOf(v22).Kind() { -case reflect.Func: - v23 = lang.Apply(v22, nil) -default: - v23 = v22 +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v24 := lang.Apply(v21, []any{v3, v23}) -if lang.IsTruthy(v24) { -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("vec")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) } -v28 := v27.Get() -v29, ok := lang.FieldOrMethod(v6, "toArray") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "toArray"))) +// not-every? +{ +v1 := reflect.TypeOf(false) +v0 := lang.NewSymbol("not-every?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns false if (pred x) is logical true for every x in\n coll, else true.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(2677), lang.NewKeyword("end-line"), int(2682))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v4 := lang.Apply(closed15, nil) +v5 := lang.Apply(closed13, []any{v4}) +return v5 + case 1: +v4 := args[0] +v5 := lang.Apply(closed15, []any{v4}) +v6 := lang.Apply(closed13, []any{v5}) +return v6 + case 2: +v4 := args[0] +v5 := args[1] +v6 := lang.Apply(closed15, []any{v4, v5}) +v7 := lang.Apply(closed13, []any{v6}) +return v7 + case 3: +v4 := args[0] +v5 := args[1] +v6 := args[2] +v7 := lang.Apply(closed15, []any{v4, v5, v6}) +v8 := lang.Apply(closed13, []any{v7}) +return v8 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := args[1] +v6 := args[2] +v7 := lang.NewList(args[3:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("apply")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -var v30 any -switch reflect.TypeOf(v29).Kind() { -case reflect.Func: - v30 = lang.Apply(v29, nil) -default: - v30 = v29 +v10 := v9.Get() +v11 := lang.Apply(v10, []any{closed15, v4, v5, v6, v7}) +v12 := lang.Apply(closed13, []any{v11}) +return v12 + } +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2559), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2564), lang.NewKeyword("end-column"), int(49))).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v31 := lang.Apply(v28, []any{v30}) -var v25 any = v31 -_ = v25 -v33, ok := lang.FieldOrMethod(v6, "clear") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "clear"))) } -var v34 any -switch reflect.TypeOf(v33).Kind() { -case reflect.Func: - v34 = lang.Apply(v33, nil) -default: - v34 = v33 +// not= +{ +v1 := reflect.TypeOf(false) +v0 := lang.NewSymbol("not=").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Same as (not (= obj1 obj2))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(812), lang.NewKeyword("end-line"), int(812))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v4 := args[0] +return false + case 2: +v4 := args[0] +v5 := args[1] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("not")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -_ = v34 -v35 := lang.Apply(v5, []any{v14, v25}) -v18 = v35 -} else { -v18 = v14 +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("=")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -return v18 +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v4, v5}) +v13 := lang.Apply(v8, []any{v12}) +return v13 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7274), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7290), lang.NewKeyword("end-column"), int(23)) -v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) -if err != nil { - panic(err) + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := args[1] +v6 := lang.NewList(args[2:]...) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("not")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -return v15 +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("apply")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("=")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v12, []any{v15, v4, v5, v6}) +v17 := lang.Apply(v9, []any{v16}) +return v17 + } }) -v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7272), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7290), lang.NewKeyword("end-column"), int(25)) -v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) -if err != nil { - panic(err) +v4 := reflect.TypeOf(false) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } -return v6 - case 2: -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("partition-all")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3, v3, v4}) -return v8 - case 3: +// ns +{ +v0 := lang.NewSymbol("ns").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("docstring?"), lang.NewSymbol("attr-map?"), lang.NewSymbol("references*"))), lang.NewKeyword("doc"), "Sets *ns* to the namespace named by name (unevaluated), creating it\n if needed. references can be zero or more of: (:refer-glojure ...)\n (:require ...) (:use ...) (:import ...) (:load ...) (:gen-class)\n with the syntax of refer-glojure/require/use/import/load/gen-class\n respectively, except the arguments are unevaluated and need not be\n quoted. (:gen-class ...), when supplied, defaults to :name\n corresponding to the ns name, :main true, :impl-ns same as ns, and\n :init-impl-ns true. All options of gen-class are\n supported. The :gen-class directive is ignored when not\n compiling. If :gen-class is not supplied, when compiled only an\n nsname__init.class will be generated. If :refer-glojure is not used, a\n default (refer 'glojure.core) is used. Use of ns is preferred to\n individual calls to in-ns/require/use/import:\n\n (ns foo.bar\n (:refer-glojure :exclude [ancestors printf])\n (:require (glojure.contrib sql combinatorics))\n (:use (my.lib this that))\n (:import (java.util Date Timer Random)\n (java.sql Connection Statement)))", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5785), lang.NewKeyword("end-line"), int(5785))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] v4 := args[1] v5 := args[2] -var v6 lang.FnFunc -v6 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { +v6 := lang.NewList(args[3:]...) +var v8 lang.FnFunc +v8 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("seq")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v9 := args[0] +var v10 any = v9 +_ = v10 +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("seq")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v5}) -var v7 any = v11 -_ = v7 -var v13 any -if lang.IsTruthy(v7) { -var v14 any = v7 -_ = v14 +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v10}) +var v11 any = v15 +_ = v11 v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("doall")) +v18 := v17.FindInternedVar(lang.NewSymbol("first")) if v18.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("take")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.Apply(v22, []any{v3, v14}) -v24 := lang.Apply(v19, []any{v23}) -var v16 any = v24 +v20 := lang.Apply(v19, []any{v11}) +var v16 any = v20 _ = v16 -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("cons")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("next")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -v28 := v27.Get() +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v21}) +var v21 any = v25 +_ = v21 +var v26 any = v16 +_ = v26 +var v27 any = v21 +_ = v27 v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("partition-all")) +v30 := v29.FindInternedVar(lang.NewSymbol("seq")) if v30.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) } v31 := v30.Get() v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("nthrest")) +v33 := v32.FindInternedVar(lang.NewSymbol("concat")) if v33.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) } v34 := v33.Get() -v35 := lang.Apply(v34, []any{v14, v4}) -v36 := lang.Apply(v31, []any{v3, v4, v35}) -v37 := lang.Apply(v28, []any{v16, v36}) -v13 = v37 -} else { -v13 = nil +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("list")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) } -return v13 -}) -v7 := lang.Apply(lang1.NewLazySeq, []any{v6}) -return v7 - default: +v37 := v36.Get() +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("symbol")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("name")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v26}) +v45 := lang.Apply(v40, []any{"glojure.core", v44}) +v46 := lang.Apply(v37, []any{v45}) +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("map")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +} +v49 := v48.Get() +var v50 lang.FnFunc +v50 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } +v51 := args[0] +v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v53 := v52.FindInternedVar(lang.NewSymbol("list")) +if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) +} +v54 := v53.Get() +v55 := lang.Apply(v54, []any{lang.NewSymbol("quote"), v51}) +return v55 }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v51 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5812), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(5812), lang.NewKeyword("end-column"), int(36)) +v52, err := lang.WithMeta(v50, v51.(lang.IPersistentMap)) +if err != nil { + panic(err) } +v53 := lang.Apply(v49, []any{v52, v27}) +v54 := lang.Apply(v34, []any{v46, v53}) +v55 := lang.Apply(v31, []any{v54}) +return v55 +}) +v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5810), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(5812), lang.NewKeyword("end-column"), int(44)) +v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) +if err != nil { + panic(err) } -// *print-level* -{ -v0 := lang.NewSymbol("*print-level*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(25), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(35), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, nil, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +var v7 any = v10 +_ = v7 +var v12 any +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("string?")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } +v15 := v14.Get() +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("first")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -// merge -{ -v0 := lang.NewSymbol("merge").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("maps"))), lang.NewKeyword("doc"), "Returns a map that consists of the rest of the maps conj-ed onto\n the first. If a key occurs in more than one map, the mapping from\n the latter (left-to-right) will be the mapping in the result.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3040), lang.NewKeyword("end-line"), int(3040))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewList(args[0:]...) -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("some")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v6}) +v20 := lang.Apply(v15, []any{v19}) +if lang.IsTruthy(v20) { +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("first")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("identity")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v6}) +v12 = v24 +} else { +v12 = nil } -v10 := v9.Get() -v11 := lang.Apply(v7, []any{v10, v3}) +var v11 any = v12 +_ = v11 +var v26 any if lang.IsTruthy(v11) { -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("reduce1")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("next")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v14 := v13.Get() -var v15 lang.FnFunc -v15 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v16 := args[0] -v17 := args[1] -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("conj")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v29 := v28.Get() +v30 := lang.Apply(v29, []any{v25}) +v26 = v30 +} else { +v26 = v25 } -v20 := v19.Get() -var v21 any = v16 -_ = v21 -var v23 any -if lang.IsTruthy(v21) { -v23 = v21 +var v25 any = v26 +_ = v25 +var v32 any +if lang.IsTruthy(v11) { +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("vary-meta")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("assoc")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v35, []any{v31, v38, lang.NewKeyword("doc"), v11}) +v32 = v39 } else { -v24 := lang.NewMap() -v25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3048), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(3048), lang.NewKeyword("end-column"), int(29)) -v26, err := lang.WithMeta(v24, v25.(lang.IPersistentMap)) -if err != nil { - panic(err) +v32 = v31 } -v23 = v26 +var v31 any = v32 +_ = v31 +var v41 any +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("map?")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) } -v21 := lang.Apply(v20, []any{v23, v17}) -return v21 -}) -v16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3048), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(3048), lang.NewKeyword("end-column"), int(34)) -v17, err := lang.WithMeta(v15, v16.(lang.IPersistentMap)) -if err != nil { - panic(err) +v44 := v43.Get() +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("first")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) } -v18 := lang.Apply(v14, []any{v17, v3}) -v4 = v18 +v47 := v46.Get() +v48 := lang.Apply(v47, []any{v25}) +v49 := lang.Apply(v44, []any{v48}) +if lang.IsTruthy(v49) { +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("first")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +} +v52 := v51.Get() +v53 := lang.Apply(v52, []any{v25}) +v41 = v53 } else { -v4 = nil +v41 = nil } -return v4 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +var v40 any = v41 +_ = v40 +var v55 any +if lang.IsTruthy(v40) { +v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v57 := v56.FindInternedVar(lang.NewSymbol("next")) +if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) +} +v58 := v57.Get() +v59 := lang.Apply(v58, []any{v54}) +v55 = v59 +} else { +v55 = v54 +} +var v54 any = v55 +_ = v54 +var v61 any +if lang.IsTruthy(v40) { +v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v63 := v62.FindInternedVar(lang.NewSymbol("vary-meta")) +if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +} +v64 := v63.Get() +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("merge")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +} +v67 := v66.Get() +v68 := lang.Apply(v64, []any{v60, v67, v40}) +v61 = v68 +} else { +v61 = v60 } +var v60 any = v61 +_ = v60 +v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v71 := v70.FindInternedVar(lang.NewSymbol("first")) +if v71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) } -// take-nth -{ -v0 := lang.NewSymbol("take-nth").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy seq of every nth item in coll. Returns a stateful\n transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4287), lang.NewKeyword("end-line"), int(4287))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { +v72 := v71.Get() +v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v74 := v73.FindInternedVar(lang.NewSymbol("filter")) +if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) +} +v75 := v74.Get() +var v76 lang.FnFunc +v76 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v5 := args[0] -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("volatile!")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v77 := args[0] +v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v79 := v78.FindInternedVar(lang.NewSymbol("=")) +if v79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) } -v9 := v8.Get() -v10 := lang.Apply(v9, []any{int64(-1)}) -var v6 any = v10 -_ = v6 -var v12 lang.FnFunc -v12 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v13 := lang.Apply(v5, nil) -return v13 - case 1: -v13 := args[0] -v14 := lang.Apply(v5, []any{v13}) -return v14 - case 2: -v13 := args[0] -v14 := args[1] -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("inc")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +v80 := v79.Get() +v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v82 := v81.FindInternedVar(lang.NewSymbol("first")) +if v82.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) } -v18 := v17.Get() -v19, ok := lang.FieldOrMethod(v6, "Deref") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "Deref"))) +v83 := v82.Get() +v84 := lang.Apply(v83, []any{v77}) +v85 := lang.Apply(v80, []any{lang.NewKeyword("gen-class"), v84}) +return v85 +}) +v77 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5823), lang.NewKeyword("column"), int(41), lang.NewKeyword("end-line"), int(5823), lang.NewKeyword("end-column"), int(65)) +v78, err := lang.WithMeta(v76, v77.(lang.IPersistentMap)) +if err != nil { + panic(err) } -var v20 any -switch reflect.TypeOf(v19).Kind() { -case reflect.Func: - v20 = lang.Apply(v19, nil) -default: - v20 = v19 +v79 := lang.Apply(v75, []any{v78, v54}) +v80 := lang.Apply(v72, []any{v79}) +var v69 any = v80 +_ = v69 +var v82 any +if lang.IsTruthy(v69) { +v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v84 := v83.FindInternedVar(lang.NewSymbol("list*")) +if v84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) } -v21 := lang.Apply(v18, []any{v20}) -v22, _ := lang.FieldOrMethod(v6, "reset") -if reflect.TypeOf(v22).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) +v85 := v84.Get() +v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v87 := v86.FindInternedVar(lang.NewSymbol("str")) +if v87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) } -v23 := lang.Apply(v22, []any{v21}) -var v15 any = v23 -_ = v15 -var v25 any -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("zero?")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +v88 := v87.Get() +v89 := lang.Apply(v88, []any{v60}) +v90, _ := lang.FieldOrMethod(v89, "replace") +if reflect.TypeOf(v90).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("replace is not a function"))) } -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("rem")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +v91 := lang.Apply(v90, []any{lang.NewChar(45), lang.NewChar(95)}) +v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v93 := v92.FindInternedVar(lang.NewSymbol("next")) +if v93.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) } -v31 := v30.Get() -v32 := lang.Apply(v31, []any{v15, v3}) -v33 := lang.Apply(v28, []any{v32}) -if lang.IsTruthy(v33) { -v34 := lang.Apply(v5, []any{v13, v14}) -v25 = v34 +v94 := v93.Get() +v95 := lang.Apply(v94, []any{v69}) +v96 := lang.Apply(v85, []any{lang.NewSymbol("glojure.core/gen-class"), lang.NewKeyword("name"), v91, lang.NewKeyword("impl-ns"), v60, lang.NewKeyword("main"), true, v95}) +v82 = v96 } else { -v25 = v13 +v82 = nil } -return v25 - default: +var v81 any = v82 +_ = v81 +v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v99 := v98.FindInternedVar(lang.NewSymbol("remove")) +if v99.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) +} +v100 := v99.Get() +var v101 lang.FnFunc +v101 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -}) -v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4295), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(4302), lang.NewKeyword("end-column"), int(28)) -v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) -if err != nil { - panic(err) +v102 := args[0] +v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v104 := v103.FindInternedVar(lang.NewSymbol("=")) +if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) } -return v14 +v105 := v104.Get() +v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v107 := v106.FindInternedVar(lang.NewSymbol("first")) +if v107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) +} +v108 := v107.Get() +v109 := lang.Apply(v108, []any{v102}) +v110 := lang.Apply(v105, []any{lang.NewKeyword("gen-class"), v109}) +return v110 }) -v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4293), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(4302), lang.NewKeyword("end-column"), int(30)) -v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) +v102 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5827), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(5827), lang.NewKeyword("end-column"), int(52)) +v103, err := lang.WithMeta(v101, v102.(lang.IPersistentMap)) if err != nil { panic(err) } -return v6 - case 2: -v3 := args[0] -v4 := args[1] -var v5 lang.FnFunc -v5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("seq")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v104 := lang.Apply(v100, []any{v103, v97}) +var v97 any = v104 +_ = v97 +v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v107 := v106.FindInternedVar(lang.NewSymbol("meta")) +if v107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) } -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v4}) -var v6 any = v10 -_ = v6 -var v12 any -if lang.IsTruthy(v6) { -var v13 any = v6 -_ = v13 -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("cons")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +v108 := v107.Get() +v109 := lang.Apply(v108, []any{v60}) +var v105 any = v109 +_ = v105 +v111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v112 := v111.FindInternedVar(lang.NewSymbol("seq")) +if v112.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v112))) } -v17 := v16.Get() -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("first")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v113 := v112.Get() +v114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v115 := v114.FindInternedVar(lang.NewSymbol("concat")) +if v115.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v115))) } -v20 := v19.Get() -v21 := lang.Apply(v20, []any{v13}) -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("take-nth")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v116 := v115.Get() +v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v118 := v117.FindInternedVar(lang.NewSymbol("list")) +if v118.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) } -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("drop")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +v119 := v118.Get() +v120 := lang.Apply(v119, []any{lang.NewSymbol("do")}) +v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v122 := v121.FindInternedVar(lang.NewSymbol("list")) +if v122.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) } -v27 := v26.Get() -v28 := lang.Apply(v27, []any{v3, v13}) -v29 := lang.Apply(v24, []any{v3, v28}) -v30 := lang.Apply(v17, []any{v21, v29}) -v12 = v30 -} else { -v12 = nil +v123 := v122.Get() +v124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v125 := v124.FindInternedVar(lang.NewSymbol("seq")) +if v125.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v125))) } -return v12 -}) -v6 := lang.Apply(lang1.NewLazySeq, []any{v5}) -return v6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v126 := v125.Get() +v127 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v128 := v127.FindInternedVar(lang.NewSymbol("concat")) +if v128.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v128))) } +v129 := v128.Get() +v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v131 := v130.FindInternedVar(lang.NewSymbol("list")) +if v131.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) } -// false? -{ -v1 := reflect.TypeOf(false) -v0 := lang.NewSymbol("false?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is the value false, false otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(504), lang.NewKeyword("end-line"), int(504))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := lang.Apply(lang1.Identical, []any{v4, false}) -return v5 -}) -v4 := reflect.TypeOf(false) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +v132 := v131.Get() +v133 := lang.Apply(v132, []any{lang.NewSymbol("glojure.core/in-ns")}) +v134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v135 := v134.FindInternedVar(lang.NewSymbol("list")) +if v135.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v135))) } +v136 := v135.Get() +v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v138 := v137.FindInternedVar(lang.NewSymbol("seq")) +if v138.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) } -// sort -{ -v0 := lang.NewSymbol("sort").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("comp"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a sorted sequence of the items in coll. If no comparator is\n supplied, uses compare. comparator must implement\n java.util.Comparator. Guaranteed to be stable: equal elements will\n not be reordered. If coll is a Java array, it will be modified. To\n avoid this, sort a copy of the array.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3085), lang.NewKeyword("end-line"), int(3085))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("sort")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v139 := v138.Get() +v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v141 := v140.FindInternedVar(lang.NewSymbol("concat")) +if v141.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) } -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("compare")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v142 := v141.Get() +v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v144 := v143.FindInternedVar(lang.NewSymbol("list")) +if v144.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) } -v9 := v8.Get() -v10 := lang.Apply(v6, []any{v9, v3}) -return v10 - case 2: -v3 := args[0] -v4 := args[1] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("seq")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +v145 := v144.Get() +v146 := lang.Apply(v145, []any{lang.NewSymbol("quote")}) +v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v148 := v147.FindInternedVar(lang.NewSymbol("list")) +if v148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) } -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v4}) -if lang.IsTruthy(v9) { -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("to-array")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v149 := v148.Get() +v150 := lang.Apply(v149, []any{v60}) +v151 := lang.Apply(v142, []any{v146, v150}) +v152 := lang.Apply(v139, []any{v151}) +v153 := lang.Apply(v136, []any{v152}) +v154 := lang.Apply(v129, []any{v133, v153}) +v155 := lang.Apply(v126, []any{v154}) +v156 := lang.Apply(v123, []any{v155}) +var v157 any +if lang.IsTruthy(v105) { +v158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v159 := v158.FindInternedVar(lang.NewSymbol("seq")) +if v159.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v159))) } -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v4}) -var v10 any = v14 -_ = v10 -v16 := lang.Apply(lang1.SortSlice, []any{v10, v3}) -_ = v16 -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("with-meta")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +v160 := v159.Get() +v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v162 := v161.FindInternedVar(lang.NewSymbol("concat")) +if v162.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) } -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("seq")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +v163 := v162.Get() +v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v165 := v164.FindInternedVar(lang.NewSymbol("list")) +if v165.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) } -v22 := v21.Get() -v23 := lang.Apply(v22, []any{v10}) -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("meta")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +v166 := v165.Get() +v167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v168 := v167.FindInternedVar(lang.NewSymbol("seq")) +if v168.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v168))) } -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v4}) -v28 := lang.Apply(v19, []any{v23, v27}) -v5 = v28 -} else { -v5 = lang.NewList() +v169 := v168.Get() +v170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v171 := v170.FindInternedVar(lang.NewSymbol("concat")) +if v171.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v171))) } -return v5 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v172 := v171.Get() +v173 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v174 := v173.FindInternedVar(lang.NewSymbol("list")) +if v174.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v174))) } +v175 := v174.Get() +v176 := lang.Apply(v175, []any{lang.NewSymbol(".ResetMeta")}) +v177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v178 := v177.FindInternedVar(lang.NewSymbol("list")) +if v178.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v178))) } -// max-key -{ -v0 := lang.NewSymbol("max-key").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Returns the x for which (k x), a number, is greatest.\n\n If there are multiple such xs, the last one is returned.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5013), lang.NewKeyword("end-line"), int(5013))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v3 := args[0] -v4 := args[1] -return v4 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -var v6 any -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol(">")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v179 := v178.Get() +v180 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v181 := v180.FindInternedVar(lang.NewSymbol("seq")) +if v181.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v181))) } -v9 := v8.Get() -v10 := lang.Apply(v3, []any{v4}) -v11 := lang.Apply(v3, []any{v5}) -v12 := lang.Apply(v9, []any{v10, v11}) -if lang.IsTruthy(v12) { -v6 = v4 -} else { -v6 = v5 +v182 := v181.Get() +v183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v184 := v183.FindInternedVar(lang.NewSymbol("concat")) +if v184.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v184))) } -return v6 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v8 := lang.Apply(v3, []any{v4}) -var v7 any = v8 -_ = v7 -v10 := lang.Apply(v3, []any{v5}) -var v9 any = v10 -_ = v9 -var v12 any -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol(">")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +v185 := v184.Get() +v186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v187 := v186.FindInternedVar(lang.NewSymbol("list")) +if v187.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v187))) +} +v188 := v187.Get() +v189 := lang.Apply(v188, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.FindNamespace")}) +v190 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v191 := v190.FindInternedVar(lang.NewSymbol("list")) +if v191.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v191))) +} +v192 := v191.Get() +v193 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v194 := v193.FindInternedVar(lang.NewSymbol("seq")) +if v194.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v194))) } -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v7, v9}) -if lang.IsTruthy(v16) { -v17 := lang.NewVector(v4, v7) -v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5023), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(5023), lang.NewKeyword("end-column"), int(36)) -v19, err := lang.WithMeta(v17, v18.(lang.IPersistentMap)) -if err != nil { - panic(err) +v195 := v194.Get() +v196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v197 := v196.FindInternedVar(lang.NewSymbol("concat")) +if v197.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v197))) } -v12 = v19 -} else { -v20 := lang.NewVector(v5, v9) -v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5023), lang.NewKeyword("column"), int(38), lang.NewKeyword("end-line"), int(5023), lang.NewKeyword("end-column"), int(43)) -v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) -if err != nil { - panic(err) +v198 := v197.Get() +v199 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v200 := v199.FindInternedVar(lang.NewSymbol("list")) +if v200.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v200))) } -v12 = v22 +v201 := v200.Get() +v202 := lang.Apply(v201, []any{lang.NewSymbol("quote")}) +v203 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v204 := v203.FindInternedVar(lang.NewSymbol("list")) +if v204.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v204))) } -var v11 any = v12 -_ = v11 -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("nth")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +v205 := v204.Get() +v206 := lang.Apply(v205, []any{v60}) +v207 := lang.Apply(v198, []any{v202, v206}) +v208 := lang.Apply(v195, []any{v207}) +v209 := lang.Apply(v192, []any{v208}) +v210 := lang.Apply(v185, []any{v189, v209}) +v211 := lang.Apply(v182, []any{v210}) +v212 := lang.Apply(v179, []any{v211}) +v213 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v214 := v213.FindInternedVar(lang.NewSymbol("list")) +if v214.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v214))) } -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v11, int64(0), nil}) -var v23 any = v27 -_ = v23 -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("nth")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +v215 := v214.Get() +v216 := lang.Apply(v215, []any{v105}) +v217 := lang.Apply(v172, []any{v176, v212, v216}) +v218 := lang.Apply(v169, []any{v217}) +v219 := lang.Apply(v166, []any{v218}) +v220 := lang.Apply(v163, []any{v219}) +v221 := lang.Apply(v160, []any{v220}) +v157 = v221 +} else { +v157 = nil } -v31 := v30.Get() -v32 := lang.Apply(v31, []any{v11, int64(1), nil}) -var v28 any = v32 -_ = v28 -var v34 any = v34 -_ = v34 -var v35 any = v35 -_ = v35 -var v36 any = v36 -_ = v36 -var v37 any -for { -var v38 any -if lang.IsTruthy(v36) { -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("first")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +v222 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v223 := v222.FindInternedVar(lang.NewSymbol("list")) +if v223.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v223))) } -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v36}) -var v39 any = v43 -_ = v39 -v45 := lang.Apply(v3, []any{v39}) -var v44 any = v45 -_ = v44 -var v47 any -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol(">=")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +v224 := v223.Get() +v225 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v226 := v225.FindInternedVar(lang.NewSymbol("seq")) +if v226.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v226))) } -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v44, v35}) -if lang.IsTruthy(v51) { -var v52 any = v39 -var v53 any = v44 -v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v56 := v55.FindInternedVar(lang.NewSymbol("next")) -if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) +v227 := v226.Get() +v228 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v229 := v228.FindInternedVar(lang.NewSymbol("concat")) +if v229.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v229))) } -v57 := v56.Get() -v58 := lang.Apply(v57, []any{v36}) -var v54 any = v58 -v34 = v52 -v35 = v53 -v36 = v54 -continue -} else { -var v59 any = v34 -var v60 any = v35 -v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v63 := v62.FindInternedVar(lang.NewSymbol("next")) -if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +v230 := v229.Get() +v231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v232 := v231.FindInternedVar(lang.NewSymbol("list")) +if v232.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v232))) } -v64 := v63.Get() -v65 := lang.Apply(v64, []any{v36}) -var v61 any = v65 -v34 = v59 -v35 = v60 -v36 = v61 -continue +v233 := v232.Get() +v234 := lang.Apply(v233, []any{lang.NewSymbol("glojure.core/with-loading-context")}) +var v235 any +if lang.IsTruthy(v81) { +v236 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v237 := v236.FindInternedVar(lang.NewSymbol("list")) +if v237.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v237))) } -v38 = v47 +v238 := v237.Get() +v239 := lang.Apply(v238, []any{v81}) +v235 = v239 } else { -v38 = v34 -} -v37 = v38 - break +v235 = nil } -return v37 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +var v240 any +v242 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v243 := v242.FindInternedVar(lang.NewSymbol("not=")) +if v243.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v243))) } +v244 := v243.Get() +v245 := lang.Apply(v244, []any{v60, lang.NewSymbol("glojure.core")}) +var v241 any = v245 +_ = v241 +var v247 any +if lang.IsTruthy(v241) { +v248 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v249 := v248.FindInternedVar(lang.NewSymbol("not-any?")) +if v249.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v249))) } -// some -{ -v0 := lang.NewSymbol("some").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns the first logical true value of (pred x) for any x in coll,\n else nil. One common idiom is to use a set as pred, for example\n this will return :fred if :fred is in the sequence, otherwise nil:\n (some #{:fred} coll)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2684), lang.NewKeyword("end-line"), int(2684))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { +v250 := v249.Get() +var v251 lang.FnFunc +v251 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := args[0] -v4 := args[1] -recur_loop_481: -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("seq")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v4}) -var v5 any = v9 -_ = v5 -var v11 any -if lang.IsTruthy(v5) { -var v12 any = v5 -_ = v12 -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("first")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +v252 := args[0] +v253 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v254 := v253.FindInternedVar(lang.NewSymbol("=")) +if v254.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v254))) } -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v12}) -v19 := lang.Apply(v3, []any{v18}) -var v14 any = v19 -_ = v14 -var v21 any -if lang.IsTruthy(v14) { -v21 = v14 -} else { -var v22 any = v3 -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("next")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +v255 := v254.Get() +v256 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v257 := v256.FindInternedVar(lang.NewSymbol("first")) +if v257.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v257))) } -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v12}) -var v23 any = v27 -v3 = v22 -v4 = v23 -goto recur_loop_481 +v258 := v257.Get() +v259 := lang.Apply(v258, []any{v252}) +v260 := lang.Apply(v255, []any{lang.NewKeyword("refer-glojure"), v259}) +return v260 +}) +v252 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5836), lang.NewKeyword("column"), int(58), lang.NewKeyword("end-line"), int(5836), lang.NewKeyword("end-column"), int(86)) +v253, err := lang.WithMeta(v251, v252.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v11 = v21 +v254 := lang.Apply(v250, []any{v253, v97}) +v247 = v254 } else { -v11 = nil +v247 = v241 } -return v11 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +if lang.IsTruthy(v247) { +v241 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v242 := v241.FindInternedVar(lang.NewSymbol("seq")) +if v242.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v242))) } +v243 := v242.Get() +v244 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v245 := v244.FindInternedVar(lang.NewSymbol("concat")) +if v245.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v245))) } -// make-hierarchy -{ -v0 := lang.NewSymbol("make-hierarchy").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Creates a hierarchy object for use with derive, isa? etc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5550), lang.NewKeyword("end-line"), int(5550))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewMap() -v4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5554), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(5554), lang.NewKeyword("end-column"), int(17)) -v5, err := lang.WithMeta(v3, v4.(lang.IPersistentMap)) -if err != nil { - panic(err) +v246 := v245.Get() +v247 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v248 := v247.FindInternedVar(lang.NewSymbol("list")) +if v248.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v248))) } -v6 := lang.NewMap() -v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5554), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(5554), lang.NewKeyword("end-column"), int(33)) -v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) -if err != nil { - panic(err) +v249 := v248.Get() +v250 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v251 := v250.FindInternedVar(lang.NewSymbol("seq")) +if v251.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v251))) } -v9 := lang.NewMap() -v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5554), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(5554), lang.NewKeyword("end-column"), int(47)) -v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) -if err != nil { - panic(err) +v252 := v251.Get() +v253 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v254 := v253.FindInternedVar(lang.NewSymbol("concat")) +if v254.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v254))) } -v12 := lang.NewMap(lang.NewKeyword("parents"), v5, lang.NewKeyword("descendants"), v8, lang.NewKeyword("ancestors"), v11) -v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5554), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(5554), lang.NewKeyword("end-column"), int(48)) -v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) -if err != nil { - panic(err) +v255 := v254.Get() +v256 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v257 := v256.FindInternedVar(lang.NewSymbol("list")) +if v257.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v257))) } -return v14 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v258 := v257.Get() +v259 := lang.Apply(v258, []any{lang.NewSymbol("glojure.core/refer")}) +v260 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v261 := v260.FindInternedVar(lang.NewSymbol("list")) +if v261.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v261))) } +v262 := v261.Get() +v263 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v264 := v263.FindInternedVar(lang.NewSymbol("seq")) +if v264.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v264))) } -// assert-args -{ -v0 := lang.NewSymbol("assert-args").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("pairs"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(38), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1830), lang.NewKeyword("end-line"), int(1830), lang.NewKeyword("private"), true)).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("seq")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +v265 := v264.Get() +v266 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v267 := v266.FindInternedVar(lang.NewSymbol("concat")) +if v267.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v267))) } -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("concat")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +v268 := v267.Get() +v269 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v270 := v269.FindInternedVar(lang.NewSymbol("list")) +if v270.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v270))) } -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("list")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +v271 := v270.Get() +v272 := lang.Apply(v271, []any{lang.NewSymbol("quote")}) +v273 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v274 := v273.FindInternedVar(lang.NewSymbol("list")) +if v274.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v274))) } -v14 := v13.Get() -v15 := lang.Apply(v14, []any{lang.NewSymbol("do")}) -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("list")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +v275 := v274.Get() +v276 := lang.Apply(v275, []any{lang.NewSymbol("glojure.core")}) +v277 := lang.Apply(v268, []any{v272, v276}) +v278 := lang.Apply(v265, []any{v277}) +v279 := lang.Apply(v262, []any{v278}) +v280 := lang.Apply(v255, []any{v259, v279}) +v281 := lang.Apply(v252, []any{v280}) +v282 := lang.Apply(v249, []any{v281}) +v283 := lang.Apply(v246, []any{v282}) +v284 := lang.Apply(v243, []any{v283}) +v240 = v284 +} else { +v240 = nil } -v18 := v17.Get() -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("seq")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v285 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v286 := v285.FindInternedVar(lang.NewSymbol("map")) +if v286.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v286))) } -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("concat")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v287 := v286.Get() +v288 := lang.Apply(v287, []any{v7, v97}) +v289 := lang.Apply(v230, []any{v234, v235, v240, v288}) +v290 := lang.Apply(v227, []any{v289}) +v291 := lang.Apply(v224, []any{v290}) +v292 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v293 := v292.FindInternedVar(lang.NewSymbol("list")) +if v293.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v293))) } -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("list")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +v294 := v293.Get() +v295 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v296 := v295.FindInternedVar(lang.NewSymbol("seq")) +if v296.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v296))) } -v27 := v26.Get() -v28 := lang.Apply(v27, []any{lang.NewSymbol("glojure.core/when-not")}) -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("list")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +v297 := v296.Get() +v298 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v299 := v298.FindInternedVar(lang.NewSymbol("concat")) +if v299.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v299))) } -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("first")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +v300 := v299.Get() +v301 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v302 := v301.FindInternedVar(lang.NewSymbol("list")) +if v302.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v302))) } -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v5}) -v36 := lang.Apply(v31, []any{v35}) -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("list")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +v303 := v302.Get() +v304 := lang.Apply(v303, []any{lang.NewSymbol("if")}) +v305 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v306 := v305.FindInternedVar(lang.NewSymbol("list")) +if v306.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v306))) } -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("seq")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +v307 := v306.Get() +v308 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v309 := v308.FindInternedVar(lang.NewSymbol("seq")) +if v309.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v309))) } -v42 := v41.Get() -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("concat")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +v310 := v309.Get() +v311 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v312 := v311.FindInternedVar(lang.NewSymbol("concat")) +if v312.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v312))) } -v45 := v44.Get() -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("list")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +v313 := v312.Get() +v314 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v315 := v314.FindInternedVar(lang.NewSymbol("list")) +if v315.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v315))) } -v48 := v47.Get() -v49 := lang.Apply(v48, []any{lang.NewSymbol("throw")}) -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("list")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +v316 := v315.Get() +v317 := lang.Apply(v316, []any{lang.NewSymbol(".Equals")}) +v318 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v319 := v318.FindInternedVar(lang.NewSymbol("list")) +if v319.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v319))) } -v52 := v51.Get() -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("seq")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +v320 := v319.Get() +v321 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v322 := v321.FindInternedVar(lang.NewSymbol("seq")) +if v322.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v322))) } -v55 := v54.Get() -v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v57 := v56.FindInternedVar(lang.NewSymbol("concat")) -if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) +v323 := v322.Get() +v324 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v325 := v324.FindInternedVar(lang.NewSymbol("concat")) +if v325.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v325))) } -v58 := v57.Get() -v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v60 := v59.FindInternedVar(lang.NewSymbol("list")) -if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) +v326 := v325.Get() +v327 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v328 := v327.FindInternedVar(lang.NewSymbol("list")) +if v328.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v328))) } -v61 := v60.Get() -v62 := lang.Apply(v61, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewIllegalArgumentError")}) -v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v64 := v63.FindInternedVar(lang.NewSymbol("list")) -if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) +v329 := v328.Get() +v330 := lang.Apply(v329, []any{lang.NewSymbol("quote")}) +v331 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v332 := v331.FindInternedVar(lang.NewSymbol("list")) +if v332.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v332))) } -v65 := v64.Get() -v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v67 := v66.FindInternedVar(lang.NewSymbol("seq")) -if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) +v333 := v332.Get() +v334 := lang.Apply(v333, []any{v60}) +v335 := lang.Apply(v326, []any{v330, v334}) +v336 := lang.Apply(v323, []any{v335}) +v337 := lang.Apply(v320, []any{v336}) +v338 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v339 := v338.FindInternedVar(lang.NewSymbol("list")) +if v339.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v339))) } -v68 := v67.Get() -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("concat")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +v340 := v339.Get() +v341 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v342 := v341.FindInternedVar(lang.NewSymbol("seq")) +if v342.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v342))) } -v71 := v70.Get() -v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v73 := v72.FindInternedVar(lang.NewSymbol("list")) -if v73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) +v343 := v342.Get() +v344 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v345 := v344.FindInternedVar(lang.NewSymbol("concat")) +if v345.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v345))) } -v74 := v73.Get() -v75 := lang.Apply(v74, []any{lang.NewSymbol("glojure.core/str")}) -v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v77 := v76.FindInternedVar(lang.NewSymbol("list")) -if v77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) +v346 := v345.Get() +v347 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v348 := v347.FindInternedVar(lang.NewSymbol("list")) +if v348.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v348))) } -v78 := v77.Get() -v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v80 := v79.FindInternedVar(lang.NewSymbol("seq")) -if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) +v349 := v348.Get() +v350 := lang.Apply(v349, []any{lang.NewSymbol("quote")}) +v351 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v352 := v351.FindInternedVar(lang.NewSymbol("list")) +if v352.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v352))) } -v81 := v80.Get() -v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v83 := v82.FindInternedVar(lang.NewSymbol("concat")) -if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) +v353 := v352.Get() +v354 := lang.Apply(v353, []any{lang.NewSymbol("glojure.core")}) +v355 := lang.Apply(v346, []any{v350, v354}) +v356 := lang.Apply(v343, []any{v355}) +v357 := lang.Apply(v340, []any{v356}) +v358 := lang.Apply(v313, []any{v317, v337, v357}) +v359 := lang.Apply(v310, []any{v358}) +v360 := lang.Apply(v307, []any{v359}) +v361 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v362 := v361.FindInternedVar(lang.NewSymbol("list")) +if v362.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v362))) } -v84 := v83.Get() -v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v86 := v85.FindInternedVar(lang.NewSymbol("list")) -if v86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) +v363 := v362.Get() +v364 := lang.Apply(v363, []any{nil}) +v365 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v366 := v365.FindInternedVar(lang.NewSymbol("list")) +if v366.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v366))) } -v87 := v86.Get() -v88 := lang.Apply(v87, []any{lang.NewSymbol("glojure.core/first")}) -v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v90 := v89.FindInternedVar(lang.NewSymbol("list")) -if v90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) +v367 := v366.Get() +v368 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v369 := v368.FindInternedVar(lang.NewSymbol("seq")) +if v369.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v369))) } -v91 := v90.Get() -v92 := lang.Apply(v91, []any{lang.NewSymbol("&form")}) -v93 := lang.Apply(v84, []any{v88, v92}) -v94 := lang.Apply(v81, []any{v93}) -v95 := lang.Apply(v78, []any{v94}) -v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v97 := v96.FindInternedVar(lang.NewSymbol("list")) -if v97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) +v370 := v369.Get() +v371 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v372 := v371.FindInternedVar(lang.NewSymbol("concat")) +if v372.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v372))) } -v98 := v97.Get() -v99 := lang.Apply(v98, []any{" requires "}) -v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v101 := v100.FindInternedVar(lang.NewSymbol("list")) -if v101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) +v373 := v372.Get() +v374 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v375 := v374.FindInternedVar(lang.NewSymbol("list")) +if v375.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v375))) } -v102 := v101.Get() -v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v104 := v103.FindInternedVar(lang.NewSymbol("second")) -if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) +v376 := v375.Get() +v377 := lang.Apply(v376, []any{lang.NewSymbol("do")}) +v378 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v379 := v378.FindInternedVar(lang.NewSymbol("list")) +if v379.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v379))) } -v105 := v104.Get() -v106 := lang.Apply(v105, []any{v5}) -v107 := lang.Apply(v102, []any{v106}) -v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v109 := v108.FindInternedVar(lang.NewSymbol("list")) -if v109.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) +v380 := v379.Get() +v381 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v382 := v381.FindInternedVar(lang.NewSymbol("seq")) +if v382.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v382))) } -v110 := v109.Get() -v111 := lang.Apply(v110, []any{" in "}) -v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v113 := v112.FindInternedVar(lang.NewSymbol("list")) -if v113.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) +v383 := v382.Get() +v384 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v385 := v384.FindInternedVar(lang.NewSymbol("concat")) +if v385.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v385))) } -v114 := v113.Get() -v115 := lang.Apply(v114, []any{lang.NewSymbol("*ns*")}) -v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v117 := v116.FindInternedVar(lang.NewSymbol("list")) -if v117.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) +v386 := v385.Get() +v387 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v388 := v387.FindInternedVar(lang.NewSymbol("list")) +if v388.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v388))) } -v118 := v117.Get() -v119 := lang.Apply(v118, []any{":"}) -v120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v121 := v120.FindInternedVar(lang.NewSymbol("list")) -if v121.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v121))) +v389 := v388.Get() +v390 := lang.Apply(v389, []any{lang.NewSymbol("glojure.core/dosync")}) +v391 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v392 := v391.FindInternedVar(lang.NewSymbol("list")) +if v392.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v392))) } -v122 := v121.Get() -v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v124 := v123.FindInternedVar(lang.NewSymbol("seq")) -if v124.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) +v393 := v392.Get() +v394 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v395 := v394.FindInternedVar(lang.NewSymbol("seq")) +if v395.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v395))) } -v125 := v124.Get() -v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v127 := v126.FindInternedVar(lang.NewSymbol("concat")) -if v127.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) +v396 := v395.Get() +v397 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v398 := v397.FindInternedVar(lang.NewSymbol("concat")) +if v398.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v398))) } -v128 := v127.Get() -v129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v130 := v129.FindInternedVar(lang.NewSymbol("list")) -if v130.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v130))) +v399 := v398.Get() +v400 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v401 := v400.FindInternedVar(lang.NewSymbol("list")) +if v401.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v401))) } -v131 := v130.Get() -v132 := lang.Apply(v131, []any{lang.NewKeyword("line")}) -v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v134 := v133.FindInternedVar(lang.NewSymbol("list")) -if v134.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) +v402 := v401.Get() +v403 := lang.Apply(v402, []any{lang.NewSymbol("glojure.core/commute")}) +v404 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v405 := v404.FindInternedVar(lang.NewSymbol("list")) +if v405.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v405))) } -v135 := v134.Get() -v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v137 := v136.FindInternedVar(lang.NewSymbol("seq")) -if v137.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) +v406 := v405.Get() +v407 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v408 := v407.FindInternedVar(lang.NewSymbol("seq")) +if v408.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v408))) } -v138 := v137.Get() -v139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v140 := v139.FindInternedVar(lang.NewSymbol("concat")) -if v140.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v140))) +v409 := v408.Get() +v410 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v411 := v410.FindInternedVar(lang.NewSymbol("concat")) +if v411.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v411))) } -v141 := v140.Get() -v142 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v143 := v142.FindInternedVar(lang.NewSymbol("list")) -if v143.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v143))) +v412 := v411.Get() +v413 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v414 := v413.FindInternedVar(lang.NewSymbol("list")) +if v414.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v414))) } -v144 := v143.Get() -v145 := lang.Apply(v144, []any{lang.NewSymbol("glojure.core/meta")}) -v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v147 := v146.FindInternedVar(lang.NewSymbol("list")) -if v147.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) +v415 := v414.Get() +v416 := lang.Apply(v415, []any{lang.NewSymbol("glojure.core/deref")}) +v417 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v418 := v417.FindInternedVar(lang.NewSymbol("list")) +if v418.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v418))) } -v148 := v147.Get() -v149 := lang.Apply(v148, []any{lang.NewSymbol("&form")}) -v150 := lang.Apply(v141, []any{v145, v149}) -v151 := lang.Apply(v138, []any{v150}) -v152 := lang.Apply(v135, []any{v151}) -v153 := lang.Apply(v128, []any{v132, v152}) -v154 := lang.Apply(v125, []any{v153}) -v155 := lang.Apply(v122, []any{v154}) -v156 := lang.Apply(v71, []any{v75, v95, v99, v107, v111, v115, v119, v155}) -v157 := lang.Apply(v68, []any{v156}) -v158 := lang.Apply(v65, []any{v157}) -v159 := lang.Apply(v58, []any{v62, v158}) -v160 := lang.Apply(v55, []any{v159}) -v161 := lang.Apply(v52, []any{v160}) -v162 := lang.Apply(v45, []any{v49, v161}) -v163 := lang.Apply(v42, []any{v162}) -v164 := lang.Apply(v39, []any{v163}) -v165 := lang.Apply(v24, []any{v28, v36, v164}) -v166 := lang.Apply(v21, []any{v165}) -v167 := lang.Apply(v18, []any{v166}) -v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v169 := v168.FindInternedVar(lang.NewSymbol("list")) -if v169.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) +v419 := v418.Get() +v420 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v421 := v420.FindInternedVar(lang.NewSymbol("seq")) +if v421.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v421))) } -v170 := v169.Get() -v172 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v173 := v172.FindInternedVar(lang.NewSymbol("nnext")) -if v173.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v173))) +v422 := v421.Get() +v423 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v424 := v423.FindInternedVar(lang.NewSymbol("concat")) +if v424.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v424))) } -v174 := v173.Get() -v175 := lang.Apply(v174, []any{v5}) -var v171 any = v175 -_ = v171 -var v177 any -if lang.IsTruthy(v171) { -v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v179 := v178.FindInternedVar(lang.NewSymbol("list*")) -if v179.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) +v425 := v424.Get() +v426 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v427 := v426.FindInternedVar(lang.NewSymbol("list")) +if v427.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v427))) } -v180 := v179.Get() -v181 := lang.Apply(v180, []any{lang.NewSymbol("glojure.core/assert-args"), v171}) -v177 = v181 -} else { -v177 = nil +v428 := v427.Get() +v429 := lang.Apply(v428, []any{lang.NewSymbol("var")}) +v430 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v431 := v430.FindInternedVar(lang.NewSymbol("list")) +if v431.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v431))) } -v171 := lang.Apply(v170, []any{v177}) -v172 := lang.Apply(v11, []any{v15, v167, v171}) -v173 := lang.Apply(v8, []any{v172}) -return v173 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v432 := v431.Get() +v433 := lang.Apply(v432, []any{lang.NewSymbol("glojure.core/*loaded-libs*")}) +v434 := lang.Apply(v425, []any{v429, v433}) +v435 := lang.Apply(v422, []any{v434}) +v436 := lang.Apply(v419, []any{v435}) +v437 := lang.Apply(v412, []any{v416, v436}) +v438 := lang.Apply(v409, []any{v437}) +v439 := lang.Apply(v406, []any{v438}) +v440 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v441 := v440.FindInternedVar(lang.NewSymbol("list")) +if v441.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v441))) } +v442 := v441.Get() +v443 := lang.Apply(v442, []any{lang.NewSymbol("glojure.core/conj")}) +v444 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v445 := v444.FindInternedVar(lang.NewSymbol("list")) +if v445.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v445))) } -// stream-reduce! -{ -v0 := lang.NewSymbol("stream-reduce!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("s")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Works like reduce but takes a java.util.stream.BaseStream as its source.\n Honors 'reduced', is a terminal operation on the stream", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6827), lang.NewKeyword("end-line"), int(6827))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v3 := args[0] -v4 := args[1] -v5, ok := lang.FieldOrMethod(v4, "iterator") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "iterator"))) +v446 := v445.Get() +v447 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v448 := v447.FindInternedVar(lang.NewSymbol("seq")) +if v448.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v448))) } -var v6 any -switch reflect.TypeOf(v5).Kind() { -case reflect.Func: - v6 = lang.Apply(v5, nil) -default: - v6 = v5 +v449 := v448.Get() +v450 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v451 := v450.FindInternedVar(lang.NewSymbol("concat")) +if v451.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v451))) } -v7 := lang.Apply(nil, []any{v6, v3}) -return v7 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6, ok := lang.FieldOrMethod(v5, "iterator") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "iterator"))) +v452 := v451.Get() +v453 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v454 := v453.FindInternedVar(lang.NewSymbol("list")) +if v454.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v454))) } -var v7 any -switch reflect.TypeOf(v6).Kind() { -case reflect.Func: - v7 = lang.Apply(v6, nil) -default: - v7 = v6 +v455 := v454.Get() +v456 := lang.Apply(v455, []any{lang.NewSymbol("quote")}) +v457 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v458 := v457.FindInternedVar(lang.NewSymbol("list")) +if v458.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v458))) } -v8 := lang.Apply(nil, []any{v7, v3, v4}) -return v8 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) +v459 := v458.Get() +v460 := lang.Apply(v459, []any{v60}) +v461 := lang.Apply(v452, []any{v456, v460}) +v462 := lang.Apply(v449, []any{v461}) +v463 := lang.Apply(v446, []any{v462}) +v464 := lang.Apply(v399, []any{v403, v439, v443, v463}) +v465 := lang.Apply(v396, []any{v464}) +v466 := lang.Apply(v393, []any{v465}) +v467 := lang.Apply(v386, []any{v390, v466}) +v468 := lang.Apply(v383, []any{v467}) +v469 := lang.Apply(v380, []any{v468}) +v470 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v471 := v470.FindInternedVar(lang.NewSymbol("list")) +if v471.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v471))) +} +v472 := v471.Get() +v473 := lang.Apply(v472, []any{nil}) +v474 := lang.Apply(v373, []any{v377, v469, v473}) +v475 := lang.Apply(v370, []any{v474}) +v476 := lang.Apply(v367, []any{v475}) +v477 := lang.Apply(v300, []any{v304, v360, v364, v476}) +v478 := lang.Apply(v297, []any{v477}) +v479 := lang.Apply(v294, []any{v478}) +v480 := lang.Apply(v116, []any{v120, v156, v157, v291, v479}) +v481 := lang.Apply(v113, []any{v480}) +return v481 } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -55341,54 +55763,34 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// bytes? +// ns-aliases { -v0 := lang.NewSymbol("bytes?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a byte array", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5412), lang.NewKeyword("end-line"), int(5412))).(*lang.Symbol) +v0 := lang.NewSymbol("ns-aliases").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of the aliases for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4273), lang.NewKeyword("end-line"), int(4273))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("nil?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -if lang.IsTruthy(v8) { -v4 = false -} else { -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("=")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("class")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("the-ns")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v3}) -v16, ok := lang.FieldOrMethod(v15, "getComponentType") +v6 := v5.Get() +v7 := lang.Apply(v6, []any{v3}) +v8, ok := lang.FieldOrMethod(v7, "getAliases") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v15, "getComponentType"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "getAliases"))) } -var v17 any -switch reflect.TypeOf(v16).Kind() { +var v9 any +switch reflect.TypeOf(v8).Kind() { case reflect.Func: - v17 = lang.Apply(v16, nil) + v9 = lang.Apply(v8, nil) default: - v17 = v16 -} -v18 := lang.Apply(v11, []any{v17, nil}) -v4 = v18 + v9 = v8 } -return v4 +return v9 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -55396,36 +55798,49 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// when-not +// ns-imports { -v0 := lang.NewSymbol("when-not").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("test"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Evaluates test. If logical false, evaluates body in an implicit do.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(498), lang.NewKeyword("end-line"), int(498))).(*lang.Symbol) +v0 := lang.NewSymbol("ns-imports").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of the import mappings for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4199), lang.NewKeyword("end-line"), int(4199))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("filter-key")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("list")) +v8 := v7.FindInternedVar(lang.NewSymbol("val")) if v8.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } v9 := v8.Get() v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("cons")) +v11 := v10.FindInternedVar(lang.NewSymbol("partial")) if v11.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol("do"), v6}) -v14 := lang.Apply(v9, []any{lang.NewSymbol("if"), v5, nil, v13}) -return v14 - } +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("instance?")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v12, []any{v15, reflect.Type}) +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("ns-map")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v3}) +v21 := lang.Apply(v6, []any{v9, v16, v20}) +return v21 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -55433,255 +55848,91 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// seq? +// ns-interns { -v0 := lang.NewSymbol("seq?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x implements ISeq", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(146), lang.NewKeyword("end-line"), int(150))).(*lang.Symbol) +v0 := lang.NewSymbol("ns-interns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of the intern mappings for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4206), lang.NewKeyword("end-line"), int(4206))).(*lang.Symbol) var v2 lang.FnFunc -{ // function seq? v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v4 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{lang1.ISeq, v4}) -return v8 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(150), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(150), lang.NewKeyword("end-column"), int(87))).(lang.FnFunc) -v3 := v2 -_ = v3 -} -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// underive -{ -v0 := lang.NewSymbol("underive").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag"), lang.NewSymbol("parent")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"), lang.NewSymbol("parent"))), lang.NewKeyword("doc"), "Removes a parent/child relationship between parent and\n tag. h must be a hierarchy obtained from make-hierarchy, if not\n supplied defaults to, and modifies, the global hierarchy.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5686), lang.NewKeyword("end-line"), int(5686))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: v3 := args[0] -v4 := args[1] v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("alter-var-root")) +v6 := v5.FindInternedVar(lang.NewSymbol("the-ns")) if v6.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } v7 := v6.Get() -v8 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("global-hierarchy")) -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("underive")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v7, []any{v8, v11, v3, v4}) -_ = v12 -return nil - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v7 := lang.Apply(lang.NewKeyword("parents"), []any{v3}) -var v6 any = v7 -_ = v6 -var v9 any -v10 := lang.Apply(v6, []any{v4}) -if lang.IsTruthy(v10) { -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("disj")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v6, []any{v4}) -v15 := lang.Apply(v13, []any{v14, v5}) -v9 = v15 -} else { -v16 := lang.CreatePersistentTreeSet() -v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5695), lang.NewKeyword("column"), int(36), lang.NewKeyword("end-line"), int(5695), lang.NewKeyword("end-column"), int(38)) -v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) -if err != nil { - panic(err) +v8 := lang.Apply(v7, []any{v4}) +var v4 any = v8 +_ = v4 +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("filter-key")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v9 = v18 +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("val")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } -var v8 any = v9 -_ = v8 -var v20 any -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("not-empty")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +v15 := v14.Get() +var v16 lang.FnFunc +v16 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v17 := args[0] +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("instance?")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v8}) -if lang.IsTruthy(v24) { +v21 := v20.Get() +v22 := lang.Apply(v21, []any{lang1.*Var, v17}) +var v18 any = v22 +_ = v18 +var v24 any +if lang.IsTruthy(v18) { v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("assoc")) +v26 := v25.FindInternedVar(lang.NewSymbol("=")) if v26.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } v27 := v26.Get() -v28 := lang.Apply(v27, []any{v6, v4, v8}) -v20 = v28 -} else { -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("dissoc")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.Apply(v31, []any{v6, v4}) -v20 = v32 -} -var v19 any = v20 -_ = v19 -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("flatten")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("map")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -var v40 lang.FnFunc -v40 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v41 := args[0] -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("cons")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) -} -v44 := v43.Get() -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("key")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.Apply(v47, []any{v41}) -v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v50 := v49.FindInternedVar(lang.NewSymbol("interpose")) -if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) -} -v51 := v50.Get() -v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("key")) -if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) -} -v54 := v53.Get() -v55 := lang.Apply(v54, []any{v41}) -v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v57 := v56.FindInternedVar(lang.NewSymbol("val")) -if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) -} -v58 := v57.Get() -v59 := lang.Apply(v58, []any{v41}) -v60 := lang.Apply(v51, []any{v55, v59}) -v61 := lang.Apply(v44, []any{v48, v60}) -return v61 -}) -v41 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5699), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(5699), lang.NewKeyword("end-column"), int(70)) -v42, err := lang.WithMeta(v40, v41.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("seq")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.Apply(v45, []any{v19}) -v47 := lang.Apply(v39, []any{v42, v46}) -v48 := lang.Apply(v36, []any{v47}) -var v33 any = v48 -_ = v33 -var v50 any -v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v52 := v51.FindInternedVar(lang.NewSymbol("contains?")) -if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) -} -v53 := v52.Get() -v54 := lang.Apply(v6, []any{v4}) -v55 := lang.Apply(v53, []any{v54, v5}) -if lang.IsTruthy(v55) { -v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v57 := v56.FindInternedVar(lang.NewSymbol("reduce1")) -if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) +v28, ok := lang.FieldOrMethod(v17, "Namespace") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v17, "Namespace"))) } -v58 := v57.Get() -var v59 lang.FnFunc -v59 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v60 := args[0] -v61 := args[1] -v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v63 := v62.FindInternedVar(lang.NewSymbol("apply")) -if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +var v29 any +switch reflect.TypeOf(v28).Kind() { +case reflect.Func: + v29 = lang.Apply(v28, nil) +default: + v29 = v28 } -v64 := v63.Get() -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("derive")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +v30 := lang.Apply(v27, []any{v4, v29}) +v24 = v30 +} else { +v24 = v18 } -v67 := v66.Get() -v68 := lang.Apply(v64, []any{v67, v60, v61}) -return v68 +return v24 }) -v60 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5702), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5702), lang.NewKeyword("end-column"), int(31)) -v61, err := lang.WithMeta(v59, v60.(lang.IPersistentMap)) +v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4212), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(4213), lang.NewKeyword("end-column"), int(56)) +v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) if err != nil { panic(err) } -v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v63 := v62.FindInternedVar(lang.NewSymbol("make-hierarchy")) -if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) -} -v64 := v63.Get() -v65 := lang.Apply(v64, nil) -v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v67 := v66.FindInternedVar(lang.NewSymbol("partition")) -if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) -} -v68 := v67.Get() -v69 := lang.Apply(v68, []any{int64(2), v33}) -v70 := lang.Apply(v58, []any{v61, v65, v69}) -v50 = v70 -} else { -v50 = v3 +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("ns-map")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -return v50 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v4}) +v23 := lang.Apply(v12, []any{v15, v18, v22}) +return v23 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -55689,129 +55940,34 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// vswap! +// ns-map { -v0 := lang.NewSymbol("vswap!").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("vol"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Non-atomically swaps the value of the volatile as if:\n (apply f current-value-of-vol args). Returns the value that\n was swapped in.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(2531), lang.NewKeyword("end-line"), int(2531))).(*lang.Symbol) +v0 := lang.NewSymbol("ns-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of all the mappings for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4170), lang.NewKeyword("end-line"), int(4170))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := lang.NewList(args[4:]...) -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("with-meta")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.NewMap(lang.NewKeyword("tag"), lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Volatile")) -v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2537), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(2537), lang.NewKeyword("end-column"), int(81)) -v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v15 := lang.Apply(v11, []any{v5, v14}) -var v8 any = v15 -_ = v8 -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("concat")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol(".reset")}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{v8}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v6}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("seq")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) -} -v49 := v48.Get() -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("concat")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("the-ns")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v52 := v51.Get() -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("list")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +v6 := v5.Get() +v7 := lang.Apply(v6, []any{v3}) +v8, ok := lang.FieldOrMethod(v7, "Mappings") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "Mappings"))) } -v55 := v54.Get() -v56 := lang.Apply(v55, []any{lang.NewSymbol(".Deref")}) -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("list")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +var v9 any +switch reflect.TypeOf(v8).Kind() { +case reflect.Func: + v9 = lang.Apply(v8, nil) +default: + v9 = v8 } -v59 := v58.Get() -v60 := lang.Apply(v59, []any{v8}) -v61 := lang.Apply(v52, []any{v56, v60}) -v62 := lang.Apply(v49, []any{v61}) -v63 := lang.Apply(v46, []any{v62}) -v64 := lang.Apply(v39, []any{v43, v63, v7}) -v65 := lang.Apply(v36, []any{v64}) -v66 := lang.Apply(v33, []any{v65}) -v67 := lang.Apply(v22, []any{v26, v30, v66}) -v68 := lang.Apply(v19, []any{v67}) -return v68 - } +return v9 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -55819,22 +55975,34 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// set-error-mode! +// ns-name { -v0 := lang.NewSymbol("set-error-mode!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("mode-keyword"))), lang.NewKeyword("doc"), "Sets the error-mode of agent a to mode-keyword, which must be\n either :fail or :continue. If an action being run by the agent\n throws an exception or doesn't pass the validator fn, an\n error-handler may be called (see set-error-handler!), after which,\n if the mode is :continue, the agent will continue as if neither the\n action that caused the error nor the error itself ever happened.\n \n If the mode is :fail, the agent will become failed and will stop\n accepting new 'send' and 'send-off' actions, and any previously\n queued actions will be held until a 'restart-agent'. Deref will\n still work, returning the state of the agent before the error.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2210), lang.NewKeyword("end-line"), int(2210))).(*lang.Symbol) +v0 := lang.NewSymbol("ns-name").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns the name of the namespace, a symbol.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4163), lang.NewKeyword("end-line"), int(4163))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := args[1] -v5, _ := lang.FieldOrMethod(v3, "setErrorMode") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorMode is not a function"))) +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("the-ns")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{v3}) +v8, ok := lang.FieldOrMethod(v7, "Name") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "Name"))) +} +var v9 any +switch reflect.TypeOf(v8).Kind() { +case reflect.Func: + v9 = lang.Apply(v8, nil) +default: + v9 = v8 } -v6 := lang.Apply(v5, []any{v4}) -return v6 +return v9 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -55842,127 +56010,120 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// char-array +// ns-publics { -var v1 lang.FnFunc -{ // function char-array__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewList(args[0:]...) -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v0 := lang.NewSymbol("ns-publics").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of the public intern mappings for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4188), lang.NewKeyword("end-line"), int(4188))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("the-ns")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v9 := v8.Get() +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v4}) +var v4 any = v8 +_ = v4 v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) +v11 := v10.FindInternedVar(lang.NewSymbol("filter-key")) if v11.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("val")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v15 := v14.Get() +var v16 lang.FnFunc +v16 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v17 := args[0] +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("instance?")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v20 := v19.Get() -v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/charArray")}) -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("list")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v21 := v20.Get() +v22 := lang.Apply(v21, []any{lang1.*Var, v17}) +var v18 any = v22 +_ = v18 +var v24 any +if lang.IsTruthy(v18) { +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("=")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) } -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("seq")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +v28 := v27.Get() +v29, ok := lang.FieldOrMethod(v17, "Namespace") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v17, "Namespace"))) } -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("concat")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +var v30 any +switch reflect.TypeOf(v29).Kind() { +case reflect.Func: + v30 = lang.Apply(v29, nil) +default: + v30 = v29 } -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v31 := lang.Apply(v28, []any{v4, v30}) +var v25 any = v31 +_ = v25 +var v33 any +if lang.IsTruthy(v25) { +v34, ok := lang.FieldOrMethod(v17, "IsPublic") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v17, "IsPublic"))) } -v33 := v32.Get() -v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("list")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +var v35 any +switch reflect.TypeOf(v34).Kind() { +case reflect.Func: + v35 = lang.Apply(v34, nil) +default: + v35 = v34 } -v37 := v36.Get() -v38 := lang.Apply(v37, []any{lang.NewSymbol("glojure.core/args")}) -v39 := lang.Apply(v30, []any{v34, v38}) -v40 := lang.Apply(v27, []any{v39}) -v41 := lang.Apply(v24, []any{v40}) -v42 := lang.Apply(v9, []any{v13, v17, v21, v41}) -v43 := lang.Apply(v6, []any{v42}) -return v43 - } -}) -v2 := v1 -_ = v2 +v33 = v35 +} else { +v33 = v25 } -v0 := lang.NewSymbol("char-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Creates an array of chars", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)int64(2)), lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5325), lang.NewKeyword("end-line"), int(5325))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "charArray") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("charArray is not a function"))) +v24 = v33 +} else { +v24 = v18 } -v6 := lang.Apply(v5, []any{v4}) -return v6 - case 2: -v4 := args[0] -v5 := args[1] -v6, _ := lang.FieldOrMethod(lang1.Numbers, "charArrayInit") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("charArrayInit is not a function"))) +return v24 +}) +v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4194), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(4196), lang.NewKeyword("end-column"), int(48)) +v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("ns-map")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v4}) +v23 := lang.Apply(v12, []any{v15, v18, v22}) +return v23 }) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// memoize +// ns-refers { -v0 := lang.NewSymbol("memoize").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Returns a memoized version of a referentially transparent function. The\n memoized version of the function keeps a cache of the mapping from arguments\n to results and, when calls with the same arguments are repeated often, has\n higher performance at the expense of higher memory use.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6380), lang.NewKeyword("end-line"), int(6380))).(*lang.Symbol) +v0 := lang.NewSymbol("ns-refers").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of the refer mappings for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4253), lang.NewKeyword("end-line"), int(4253))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -55970,91 +56131,81 @@ v2 = lang.NewFnFunc(func(args ...any) any { } v3 := args[0] v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("atom")) +v6 := v5.FindInternedVar(lang.NewSymbol("the-ns")) if v6.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } v7 := v6.Get() -v8 := lang.NewMap() -v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6388), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(6388), lang.NewKeyword("end-column"), int(20)) -v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v11 := lang.Apply(v7, []any{v10}) -var v4 any = v11 +v8 := lang.Apply(v7, []any{v4}) +var v4 any = v8 _ = v4 -var v13 lang.FnFunc -v13 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v14 := lang.NewList(args[0:]...) -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("find")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("filter-key")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v18 := v17.Get() +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("val")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +var v16 lang.FnFunc +v16 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v17 := args[0] v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("deref")) +v20 := v19.FindInternedVar(lang.NewSymbol("instance?")) if v20.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } v21 := v20.Get() -v22 := lang.Apply(v21, []any{v4}) -v23 := lang.Apply(v18, []any{v22, v14}) -var v15 any = v23 -_ = v15 -var v25 any -if lang.IsTruthy(v15) { -var v26 any = v15 -_ = v26 -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("val")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{v26}) -v25 = v31 -} else { -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("apply")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v22 := lang.Apply(v21, []any{lang1.*Var, v17}) +var v18 any = v22 +_ = v18 +var v24 any +if lang.IsTruthy(v18) { +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("not=")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -v29 := v28.Get() -v30 := lang.Apply(v29, []any{v3, v14}) -var v26 any = v30 -_ = v26 -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("swap!")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +v27 := v26.Get() +v28, ok := lang.FieldOrMethod(v17, "Namespace") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v17, "Namespace"))) } -v34 := v33.Get() -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("assoc")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +var v29 any +switch reflect.TypeOf(v28).Kind() { +case reflect.Func: + v29 = lang.Apply(v28, nil) +default: + v29 = v28 } -v37 := v36.Get() -v38 := lang.Apply(v34, []any{v4, v37, v14, v26}) -_ = v38 -v25 = v26 +v30 := lang.Apply(v27, []any{v4, v29}) +v24 = v30 +} else { +v24 = v18 } -return v25 - } +return v24 }) -v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6389), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(6394), lang.NewKeyword("end-column"), int(16)) -v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) +v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4259), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(4260), lang.NewKeyword("end-column"), int(59)) +v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) if err != nil { panic(err) } -return v15 +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("ns-map")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v4}) +v23 := lang.Apply(v12, []any{v15, v18, v22}) +return v23 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -56062,35 +56213,55 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// when +// ns-resolve { -v0 := lang.NewSymbol("when").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("test"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Evaluates test. If logical true, evaluates body in an implicit do.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(492), lang.NewKeyword("end-line"), int(492))).(*lang.Symbol) +v0 := lang.NewSymbol("ns-resolve").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("sym")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("env"), lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Returns the var or Class to which a symbol will be resolved in the\n namespace (unless found in the environment), else nil. Note that\n if the symbol is fully qualified, the var/Class to which it resolves\n need not be present in the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4358), lang.NewKeyword("end-line"), int(4358))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + case 2: +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("ns-resolve")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3, nil, v4}) +return v8 + case 3: v3 := args[0] v4 := args[1] v5 := args[2] -v6 := lang.NewList(args[3:]...) +var v6 any v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("list")) +v8 := v7.FindInternedVar(lang.NewSymbol("contains?")) if v8.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("cons")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v10 := lang.Apply(v9, []any{v4, v5}) +if lang.IsTruthy(v10) { +v6 = nil +} else { +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("the-ns")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol("do"), v6}) -v14 := lang.Apply(v9, []any{lang.NewSymbol("if"), v5, v13}) -return v14 +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v3}) +v15, _ := lang.FieldOrMethod(runtime9.Compiler, "maybeResolveIn") +if reflect.TypeOf(v15).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("maybeResolveIn is not a function"))) +} +v16 := lang.Apply(v15, []any{v14, v5}) +v6 = v16 +} +return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -56099,23 +56270,29 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// ratio? +// ns-unalias { -v0 := lang.NewSymbol("ratio?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is a Ratio", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3577), lang.NewKeyword("end-line"), int(3577))).(*lang.Symbol) +v0 := lang.NewSymbol("ns-unalias").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Removes the alias for the symbol from the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4280), lang.NewKeyword("end-line"), int(4280))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { + if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("the-ns")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v6 := v5.Get() -v7 := lang.Apply(v6, []any{lang1.*Ratio, v3}) -return v7 +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +v9, _ := lang.FieldOrMethod(v8, "removeAlias") +if reflect.TypeOf(v9).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("removeAlias is not a function"))) +} +v10 := lang.Apply(v9, []any{v4}) +return v10 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -56123,310 +56300,504 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// slurp +// ns-unmap { -v1 := reflect.TypeOf("") -v0 := lang.NewSymbol("slurp").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("opts"))), lang.NewKeyword("doc"), "Opens a reader on f and reads all its contents, returning a string.\n See glojure.java.io/reader for a complete list of supported arguments.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7025), lang.NewKeyword("end-line"), int(7025))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { +v0 := lang.NewSymbol("ns-unmap").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Removes the mappings for the symbol from the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4177), lang.NewKeyword("end-line"), int(4177))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("the-ns")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +v9, _ := lang.FieldOrMethod(v8, "unmap") +if reflect.TypeOf(v9).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unmap is not a function"))) +} +v10 := lang.Apply(v9, []any{v4}) +return v10 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// nth +{ +var v1 lang.FnFunc +{ // function nth__inliner +v1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 1 { + if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v4 := args[0] -v5 := lang.NewList(args[1:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("normalize-slurp-opts")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("seq")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("concat")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("list")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{lang.NewSymbol(".")}) +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("list")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("list")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("seq")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("concat")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("list")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.Apply(v31, []any{lang.NewSymbol("glojure.core/Nth")}) +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("list")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("seq")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("concat")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) } -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v6}) -var v6 any = v10 -_ = v6 -var v11 any = "unimplemented: new with non-constant class type" -_ = v11 -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("apply")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v41 := v40.Get() +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("list")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) } -v16 := v15.Get() -v17 := lang.FindNamespace(lang.NewSymbol("glojure.go.io")) -v18 := v17.FindInternedVar(lang.NewSymbol("reader")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +v44 := v43.Get() +v45 := lang.Apply(v44, []any{lang.NewSymbol("glojure.core/unquote")}) +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("list")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) } -v19 := v18.Get() -v20 := lang.Apply(v16, []any{v19, v4, v6}) -var v13 any = v20 -_ = v13 -var v22 any -func() { -defer func() { -v23, ok := lang.FieldOrMethod(v13, "close") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v13, "close"))) +v48 := v47.Get() +v49 := lang.Apply(v48, []any{lang.NewSymbol("glojure.core/c")}) +v50 := lang.Apply(v41, []any{v45, v49}) +v51 := lang.Apply(v38, []any{v50}) +v52 := lang.Apply(v35, []any{v51}) +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("list")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) } -var v24 any -switch reflect.TypeOf(v23).Kind() { -case reflect.Func: - v24 = lang.Apply(v23, nil) -default: - v24 = v23 +v55 := v54.Get() +v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v57 := v56.FindInternedVar(lang.NewSymbol("seq")) +if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) } -}() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.go.io")) -v26 := v25.FindInternedVar(lang.NewSymbol("copy")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +v58 := v57.Get() +v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v60 := v59.FindInternedVar(lang.NewSymbol("concat")) +if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) } -v27 := v26.Get() -v28 := lang.Apply(v27, []any{v13, v11}) -_ = v28 -v29 := lang.Apply(lang1.ToString, []any{v11}) -v22 = v29 -}() -return v22 - } -}) -v4 := reflect.TypeOf("") -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +v61 := v60.Get() +v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v63 := v62.FindInternedVar(lang.NewSymbol("list")) +if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) } +v64 := v63.Get() +v65 := lang.Apply(v64, []any{lang.NewSymbol("glojure.core/unquote")}) +v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v67 := v66.FindInternedVar(lang.NewSymbol("list")) +if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) } -// ifn? -{ -v0 := lang.NewSymbol("ifn?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements IFn. Note that many data structures\n (e.g. sets and maps) implement IFn", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6252), lang.NewKeyword("end-line"), int(6252))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v68 := v67.Get() +v69 := lang.Apply(v68, []any{lang.NewSymbol("glojure.core/i")}) +v70 := lang.Apply(v61, []any{v65, v69}) +v71 := lang.Apply(v58, []any{v70}) +v72 := lang.Apply(v55, []any{v71}) +v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v74 := v73.FindInternedVar(lang.NewSymbol("list")) +if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) } -v6 := v5.Get() -v7 := lang.Apply(v6, []any{glojure.lang11.IFn, v3}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v75 := v74.Get() +v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v77 := v76.FindInternedVar(lang.NewSymbol("seq")) +if v77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) } +v78 := v77.Get() +v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v80 := v79.FindInternedVar(lang.NewSymbol("concat")) +if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) } -// drop-last -{ -v0 := lang.NewSymbol("drop-last").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return a lazy sequence of all but the last n (default 1) items in coll", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2932), lang.NewKeyword("end-line"), int(2932))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("drop-last")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v81 := v80.Get() +v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v83 := v82.FindInternedVar(lang.NewSymbol("list")) +if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) } -v6 := v5.Get() -v7 := lang.Apply(v6, []any{int64(1), v3}) -return v7 - case 2: -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("map")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v84 := v83.Get() +v85 := lang.Apply(v84, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) +v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v87 := v86.FindInternedVar(lang.NewSymbol("list")) +if v87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) } -v7 := v6.Get() -var v8 lang.FnFunc -v8 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) +v88 := v87.Get() +v89 := lang.Apply(v88, []any{lang.NewSymbol("glojure.core/nf")}) +v90 := lang.Apply(v81, []any{v85, v89}) +v91 := lang.Apply(v78, []any{v90}) +v92 := lang.Apply(v75, []any{v91}) +v93 := lang.Apply(v28, []any{v32, v52, v72, v92}) +v94 := lang.Apply(v25, []any{v93}) +v95 := lang.Apply(v22, []any{v94}) +v96 := lang.Apply(v11, []any{v15, v19, v95}) +v97 := lang.Apply(v8, []any{v96}) +return v97 } -v9 := args[0] -v10 := args[1] -return v9 }) -v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2937), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(2937), lang.NewKeyword("end-column"), int(29)) -v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) -if err != nil { - panic(err) +v2 := v1 +_ = v2 } -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("drop")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v0 := lang.NewSymbol("nth").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("index")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("index"), lang.NewSymbol("not-found"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the value at the index. get returns nil if index out of\n bounds, nth throws an exception unless not-found is supplied. nth\n also works for strings, Java arrays, regex Matchers and Lists, and,\n in O(n) time, for sequences.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)int64(3)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(882), lang.NewKeyword("end-line"), int(882))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v4 := args[0] +v5 := args[1] +v6, _ := lang.FieldOrMethod(runtime9.RT, "Nth") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Nth is not a function"))) } -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v3, v4}) -v15 := lang.Apply(v7, []any{v10, v4, v14}) -return v15 +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 + case 3: +v4 := args[0] +v5 := args[1] +v6 := args[2] +v7, _ := lang.FieldOrMethod(runtime9.RT, "NthDefault") +if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("NthDefault is not a function"))) +} +v8 := lang.Apply(v7, []any{v4, v5, v6}) +return v8 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// unchecked-subtract-int +// nthnext { -var v1 lang.FnFunc -{ // function unchecked-subtract-int__inliner -v1 = lang.NewFnFunc(func(args ...any) any { +v0 := lang.NewSymbol("nthnext").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns the nth next of coll, (seq coll) when n is 0.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3147), lang.NewKeyword("end-line"), int(3147))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("concat")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v10 := v9.Get() +v8 := v7.Get() +v9 := lang.Apply(v8, []any{lang1.IDrop, v3}) +if lang.IsTruthy(v9) { +var v10 any v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("list")) +v12 := v11.FindInternedVar(lang.NewSymbol("pos?")) if v12.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } v13 := v12.Get() -v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +v14 := lang.Apply(v13, []any{v4}) +if lang.IsTruthy(v14) { +var v15 any +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("int?")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v4}) +if lang.IsTruthy(v19) { +v15 = v4 +} else { +v20 := lang.Apply(nil, []any{v4}) +v15 = v20 } -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("seq")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v21, _ := lang.FieldOrMethod(v3, "drop") +if reflect.TypeOf(v21).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("drop is not a function"))) } -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("concat")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +v22 := lang.Apply(v21, []any{v15}) +v10 = v22 +} else { +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("seq")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("list")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +v25 := v24.Get() +v26 := lang.Apply(v25, []any{v3}) +v10 = v26 } -v30 := v29.Get() -v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/unchecked_int_subtract")}) -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +v5 = v10 +} else { +var v27 any = v27 +_ = v27 +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("seq")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) } -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) +v31 := v30.Get() +v32 := lang.Apply(v31, []any{v3}) +var v28 any = v32 +_ = v28 +var v33 any +for { +var v34 any +var v35 any = v28 +_ = v35 +var v37 any +if lang.IsTruthy(v35) { +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("pos?")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.Apply(v40, []any{v27}) +v37 = v41 +} else { +v37 = v35 +} +if lang.IsTruthy(v37) { v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) +v37 := v36.FindInternedVar(lang.NewSymbol("dec")) if v37.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) } v38 := v37.Get() -v39 := lang.Apply(v38, []any{v4}) -v40 := lang.Apply(v27, []any{v31, v35, v39}) -v41 := lang.Apply(v24, []any{v40}) -v42 := lang.Apply(v21, []any{v41}) -v43 := lang.Apply(v10, []any{v14, v18, v42}) -v44 := lang.Apply(v7, []any{v43}) -return v44 -}) -v2 := v1 -_ = v2 +v39 := lang.Apply(v38, []any{v27}) +var v35 any = v39 +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("next")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } -v0 := lang.NewSymbol("unchecked-subtract-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the difference of x and y, both int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1210), lang.NewKeyword("end-line"), int(1210))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6, _ := lang.FieldOrMethod(lang1.Numbers, "unchecked_int_subtract") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_subtract is not a function"))) +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v28}) +var v40 any = v44 +v27 = v35 +v28 = v40 +continue +} else { +v34 = v28 } -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 +v33 = v34 + break +} +v5 = v33 +} +return v5 }) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// stream-transduce! +// nthrest { -v0 := lang.NewSymbol("stream-transduce!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("f"), lang.NewSymbol("stream")), lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Works like transduce but takes a java.util.stream.BaseStream as its source.\n This is a terminal operation on the stream.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6843), lang.NewKeyword("end-line"), int(6843))).(*lang.Symbol) +v0 := lang.NewSymbol("nthrest").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns the nth rest of coll, coll when n is 0.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3161), lang.NewKeyword("end-line"), int(3161))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 3: + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] v4 := args[1] -v5 := args[2] +var v5 any v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("stream-transduce!")) +v7 := v6.FindInternedVar(lang.NewSymbol("pos?")) if v7.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v8 := v7.Get() -v9 := lang.Apply(v4, nil) -v10 := lang.Apply(v8, []any{v3, v4, v9, v5}) -return v10 - case 4: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v8 := lang.Apply(v3, []any{v7}) -var v7 any = v8 -_ = v7 -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("stream-reduce!")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v4}) +if lang.IsTruthy(v9) { +var v11 any +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("instance?")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{lang1.IDrop, v3}) +if lang.IsTruthy(v15) { +var v16 any +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("int?")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v4}) +if lang.IsTruthy(v20) { +v16 = v4 +} else { +v21 := lang.Apply(nil, []any{v4}) +v16 = v21 +} +v22, _ := lang.FieldOrMethod(v3, "drop") +if reflect.TypeOf(v22).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("drop is not a function"))) +} +v23 := lang.Apply(v22, []any{v16}) +v11 = v23 +} else { +var v24 any = v24 +_ = v24 +var v25 any = v3 +_ = v25 +var v26 any +for { +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("pos?")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.Apply(v31, []any{v24}) +var v28 any = v32 +_ = v28 +var v34 any +if lang.IsTruthy(v28) { +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("seq")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v37, []any{v25}) +v34 = v38 +} else { +v34 = v28 +} +var v27 any = v34 +_ = v27 +var v29 any +if lang.IsTruthy(v27) { +var v30 any = v27 +_ = v30 +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("dec")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v24}) +var v32 any = v36 +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("rest")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.Apply(v40, []any{v30}) +var v37 any = v41 +v24 = v32 +v25 = v37 +continue +} else { +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("seq")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.Apply(v32, []any{v25}) +v29 = v33 +} +v26 = v29 + break +} +v11 = v26 +} +var v10 any = v11 +_ = v10 +var v25 any +if lang.IsTruthy(v10) { +v25 = v10 +} else { +v25 = lang.NewList() +} +v5 = v25 +} else { +v5 = v3 } -v12 := v11.Get() -v13 := lang.Apply(v12, []any{v7, v5, v6}) -var v9 any = v13 -_ = v9 -v15 := lang.Apply(v7, []any{v9}) -return v15 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } +return v5 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -56434,10 +56805,10 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// unchecked-short +// num { var v1 lang.FnFunc -{ // function unchecked-short__inliner +{ // function num__inliner v1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -56468,7 +56839,7 @@ if v15.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v19 := v18.FindInternedVar(lang.NewSymbol("list")) if v19.IsMacro() { @@ -56493,7 +56864,7 @@ if v28.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/UncheckedShortCast")}) +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/num")}) v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v32 := v31.FindInternedVar(lang.NewSymbol("list")) if v32.IsMacro() { @@ -56511,513 +56882,37 @@ return v39 v2 := v1 _ = v2 } -v0 := lang.NewSymbol("unchecked-short").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to short. Subject to rounding or truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3523), lang.NewKeyword("end-line"), int(3523))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := lang.Apply(lang1.UncheckedShortCast, []any{v4}) -return v5 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// bit-clear -{ -v0 := lang.NewSymbol("bit-clear").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Clear bit at index n", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1336), lang.NewKeyword("end-line"), int(1336))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "clearBit") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("clearBit is not a function"))) -} -v6 := lang.Apply(v5, []any{v3, v4}) -return v6 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// some->> -{ -v0 := lang.NewSymbol("some->>").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "When expr is not nil, threads it into the first form (via ->>),\n and when that result is not nil, through the next etc", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7667), lang.NewKeyword("end-line"), int(7667))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("gensym")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, nil) -var v7 any = v11 -_ = v7 -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("map")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -var v16 lang.FnFunc -v16 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v17 := args[0] -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("seq")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("concat")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("list")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v26, []any{lang.NewSymbol("if")}) -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("list")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("seq")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("concat")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("list")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.Apply(v39, []any{lang.NewSymbol("glojure.core/nil?")}) -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("list")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v7}) -v45 := lang.Apply(v36, []any{v40, v44}) -v46 := lang.Apply(v33, []any{v45}) -v47 := lang.Apply(v30, []any{v46}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{nil}) -v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("list")) -if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) -} -v54 := v53.Get() -v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v56 := v55.FindInternedVar(lang.NewSymbol("seq")) -if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) -} -v57 := v56.Get() -v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v59 := v58.FindInternedVar(lang.NewSymbol("concat")) -if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) -} -v60 := v59.Get() -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("list")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) -} -v63 := v62.Get() -v64 := lang.Apply(v63, []any{lang.NewSymbol("glojure.core/->>")}) -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("list")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) -} -v67 := v66.Get() -v68 := lang.Apply(v67, []any{v7}) -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("list")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) -} -v71 := v70.Get() -v72 := lang.Apply(v71, []any{v17}) -v73 := lang.Apply(v60, []any{v64, v68, v72}) -v74 := lang.Apply(v57, []any{v73}) -v75 := lang.Apply(v54, []any{v74}) -v76 := lang.Apply(v23, []any{v27, v47, v51, v75}) -v77 := lang.Apply(v20, []any{v76}) -return v77 -}) -v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7673), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7673), lang.NewKeyword("end-column"), int(65)) -v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v19 := lang.Apply(v15, []any{v18, v6}) -var v12 any = v19 -_ = v12 -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/let")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("apply")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("vector")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("seq")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("concat")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("list")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) -} -v48 := v47.Get() -v49 := lang.Apply(v48, []any{v7}) -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("list")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.Apply(v52, []any{v5}) -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("interleave")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) -} -v56 := v55.Get() -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("repeat")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) -} -v59 := v58.Get() -v60 := lang.Apply(v59, []any{v7}) -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("butlast")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) -} -v63 := v62.Get() -v64 := lang.Apply(v63, []any{v12}) -v65 := lang.Apply(v56, []any{v60, v64}) -v66 := lang.Apply(v45, []any{v49, v53, v65}) -v67 := lang.Apply(v42, []any{v66}) -v68 := lang.Apply(v36, []any{v39, v67}) -v69 := lang.Apply(v33, []any{v68}) -v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v71 := v70.FindInternedVar(lang.NewSymbol("list")) -if v71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) -} -v72 := v71.Get() -var v73 any -v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v75 := v74.FindInternedVar(lang.NewSymbol("empty?")) -if v75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) -} -v76 := v75.Get() -v77 := lang.Apply(v76, []any{v12}) -if lang.IsTruthy(v77) { -v73 = v7 -} else { -v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v79 := v78.FindInternedVar(lang.NewSymbol("last")) -if v79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) -} -v80 := v79.Get() -v81 := lang.Apply(v80, []any{v12}) -v73 = v81 -} -v82 := lang.Apply(v72, []any{v73}) -v83 := lang.Apply(v26, []any{v30, v69, v82}) -v84 := lang.Apply(v23, []any{v83}) -return v84 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// update-in -{ -v0 := lang.NewSymbol("update-in").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("ks"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "'Updates' a value in a nested associative structure, where ks is a\n sequence of keys and f is a function that will take the old value\n and any supplied args and return the new value, and returns a new\n nested structure. If any levels do not exist, hash-maps will be\n created.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6201), lang.NewKeyword("end-line"), int(6201))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -var v8 lang.FnFunc -{ // function up -v8 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v10 := args[0] -v11 := args[1] -v12 := args[2] -v13 := args[3] -var v14 any = v11 -_ = v14 -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("seq")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v14}) -var v15 any = v19 -_ = v15 -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("first")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v15}) -var v20 any = v24 -_ = v20 -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("next")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.Apply(v28, []any{v25}) -var v25 any = v29 -_ = v25 -var v30 any = v20 -_ = v30 -var v31 any = v25 -_ = v31 -var v33 any -if lang.IsTruthy(v31) { -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("assoc")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("get")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v10, v30}) -v41 := lang.Apply(v9, []any{v40, v31, v12, v13}) -v42 := lang.Apply(v36, []any{v10, v30, v41}) -v33 = v42 -} else { -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("assoc")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("apply")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) -} -v48 := v47.Get() -v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v50 := v49.FindInternedVar(lang.NewSymbol("get")) -if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) -} -v51 := v50.Get() -v52 := lang.Apply(v51, []any{v10, v30}) -v53 := lang.Apply(v48, []any{v12, v52, v13}) -v54 := lang.Apply(v45, []any{v10, v30, v53}) -v33 = v54 -} -return v33 -}) -v9 := v8 -_ = v9 -} -v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6210), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(6214), lang.NewKeyword("end-column"), int(59)) -v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v7 any = v10 -_ = v7 -v12 := lang.Apply(v7, []any{v3, v4, v5, v6}) -return v12 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// not-any? -{ -v1 := reflect.TypeOf(false) -v0 := lang.NewSymbol("not-any?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns false if (pred x) is logical true for any x in coll,\n else true.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(2696), lang.NewKeyword("end-line"), int(2701))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v4 := lang.Apply(closed11, nil) -v5 := lang.Apply(closed1, []any{v4}) -return v5 - case 1: -v4 := args[0] -v5 := lang.Apply(closed11, []any{v4}) -v6 := lang.Apply(closed1, []any{v5}) -return v6 - case 2: -v4 := args[0] -v5 := args[1] -v6 := lang.Apply(closed11, []any{v4, v5}) -v7 := lang.Apply(closed1, []any{v6}) -return v7 - case 3: -v4 := args[0] -v5 := args[1] -v6 := args[2] -v7 := lang.Apply(closed11, []any{v4, v5, v6}) -v8 := lang.Apply(closed1, []any{v7}) -return v8 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6 := args[2] -v7 := lang.NewList(args[3:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("apply")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{closed11, v4, v5, v6, v7}) -v12 := lang.Apply(closed1, []any{v11}) -return v12 +v0 := lang.NewSymbol("num").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to Number", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3474), lang.NewKeyword("end-line"), int(3474))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "num") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("num is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 }) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2559), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2564), lang.NewKeyword("end-column"), int(49))).(lang.FnFunc) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// reader-conditional? +// number? { -v0 := lang.NewSymbol("reader-conditional?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("value"))), lang.NewKeyword("doc"), "Return true if the value is the data representation of a reader conditional", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7819), lang.NewKeyword("end-line"), int(7819))).(*lang.Symbol) +v0 := lang.NewSymbol("number?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is a Number", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3560), lang.NewKeyword("end-line"), int(3560))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{glojure.lang11.ReaderConditional, v3}) -return v7 +v4 := lang.Apply(lang1.IsNumber, []any{v3}) +return v4 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -57025,667 +56920,586 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// xml-seq +// numerator { -v0 := lang.NewSymbol("xml-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("root"))), lang.NewKeyword("doc"), "A tree seq on the xml elements as per xml/parse", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4982), lang.NewKeyword("end-line"), int(4982))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { +v1 := reflect.TypeOf((*big14.Int)(nil)) +v0 := lang.NewSymbol("numerator").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("r"))), lang.NewKeyword("doc"), "Returns the numerator part of a Ratio.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3583), lang.NewKeyword("end-line"), int(3583))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5, ok := lang.FieldOrMethod(v4, "numerator") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "numerator"))) +} +var v6 any +switch reflect.TypeOf(v5).Kind() { +case reflect.Func: + v6 = lang.Apply(v5, nil) +default: + v6 = v5 +} +return v6 +}) +v4 := reflect.TypeOf((*big14.Int)(nil)) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// object-array +{ +var v1 lang.FnFunc +{ // function object-array__inliner +v1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("tree-seq")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("complement")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) if v8.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } v9 := v8.Get() v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("string?")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) if v11.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } v12 := v11.Get() -v13 := lang.Apply(v9, []any{v12}) +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("comp")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) if v15.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } v16 := v15.Get() -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v16, []any{v19, lang.NewKeyword("content")}) -v21 := lang.Apply(v6, []any{v13, v20, v3}) -return v21 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -// group-by -{ -v0 := lang.NewSymbol("group-by").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a map of the elements of coll keyed by the result of\n f on each element. The value at each key will be a vector of the\n corresponding elements, in the order they appeared in coll.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7171), lang.NewKeyword("end-line"), int(7171))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("persistent!")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v20 := v19.Get() +v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/Object_array")}) +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("list")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("reduce")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v3}) +v26 := lang.Apply(v9, []any{v13, v17, v21, v25}) +v27 := lang.Apply(v6, []any{v26}) +return v27 +}) +v2 := v1 +_ = v2 } -v10 := v9.Get() -var v11 lang.FnFunc -v11 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { +v0 := lang.NewSymbol("object-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Creates an array of objects", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)), lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5349), lang.NewKeyword("end-line"), int(5349))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v12 := args[0] -v13 := args[1] -v15 := lang.Apply(v3, []any{v13}) -var v14 any = v15 -_ = v14 -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("assoc!")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("conj")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("get")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.NewVector() -v27 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7182), lang.NewKeyword("column"), int(40), lang.NewKeyword("end-line"), int(7182), lang.NewKeyword("end-column"), int(41)) -v28, err := lang.WithMeta(v26, v27.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v29 := lang.Apply(v25, []any{v12, v14, v28}) -v30 := lang.Apply(v22, []any{v29, v13}) -v31 := lang.Apply(v19, []any{v12, v14, v30}) -return v31 -}) -v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7180), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(7182), lang.NewKeyword("end-column"), int(48)) -v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("transient")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.NewMap() -v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7183), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(7183), lang.NewKeyword("end-column"), int(17)) -v19, err := lang.WithMeta(v17, v18.(lang.IPersistentMap)) -if err != nil { - panic(err) +v4 := args[0] +v5, _ := lang.FieldOrMethod(runtime9.RT, "Object_array") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Object_array is not a function"))) } -v20 := lang.Apply(v16, []any{v19}) -v21 := lang.Apply(v10, []any{v13, v20, v4}) -v22 := lang.Apply(v7, []any{v21}) -return v22 +v6 := lang.Apply(v5, []any{v4}) +return v6 }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// numerator +// odd? { -v1 := reflect.TypeOf((*big9.Int)(nil)) -v0 := lang.NewSymbol("numerator").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("r"))), lang.NewKeyword("doc"), "Returns the numerator part of a Ratio.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3583), lang.NewKeyword("end-line"), int(3583))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { +v0 := lang.NewSymbol("odd?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is odd, throws an exception if n is not an integer", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1389), lang.NewKeyword("end-line"), int(1389))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v4 := args[0] -v5, ok := lang.FieldOrMethod(v4, "numerator") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "numerator"))) +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("not")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -var v6 any -switch reflect.TypeOf(v5).Kind() { -case reflect.Func: - v6 = lang.Apply(v5, nil) -default: - v6 = v5 +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("even?")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -return v6 +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v3}) +v11 := lang.Apply(v6, []any{v10}) +return v11 }) -v4 := reflect.TypeOf((*big9.Int)(nil)) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// defn +// or { -v0 := lang.NewSymbol("defn").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("doc-string?"), lang.NewSymbol("attr-map?"), lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("prepost-map?"), lang.NewSymbol("body")), lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("doc-string?"), lang.NewSymbol("attr-map?"), lang.NewList(lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("prepost-map?"), lang.NewSymbol("body")), lang.NewSymbol("+"), lang.NewSymbol("attr-map?"))), lang.NewKeyword("doc"), "Same as (def name (fn [params* ] exprs*)) or (def\n name (fn ([params* ] exprs*)+)) with any doc-string or attrs added\n to the var metadata. prepost-map defines a map with optional keys\n :pre and :post that contain collections of pre or post conditions.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(284), lang.NewKeyword("end-line"), int(291))).(*lang.Symbol) +v0 := lang.NewSymbol("or").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("next"))), lang.NewKeyword("doc"), "Evaluates exprs one at a time, from left to right. If a form\n returns a logical true value, or returns that value and doesn't\n evaluate any of the other expressions, otherwise it returns the\n value of the last expression. (or) returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(847), lang.NewKeyword("end-line"), int(847))).(*lang.Symbol) var v2 lang.FnFunc -{ // function defn v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { + case 2: +v3 := args[0] +v4 := args[1] +return nil + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +return v5 default: if len(args) < 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v4 := args[0] -v5 := args[1] -v6 := args[2] -v7 := lang.NewList(args[3:]...) -var v8 any -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("instance?")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v11, []any{lang1.*Symbol, v6}) -if lang.IsTruthy(v12) { -v8 = nil -} else { -v13 := lang.Apply(lang1.NewIllegalArgumentError, []any{"First argument to defn must be a symbol"}) -panic(v13) -} -_ = v8 -var v15 any -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("string?")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("first")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v7}) -v23 := lang.Apply(v18, []any{v22}) -if lang.IsTruthy(v23) { -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("first")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v7}) -v28 := lang.NewMap(lang.NewKeyword("doc"), v27) -v29 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(297), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(297), lang.NewKeyword("end-column"), int(38)) -v30, err := lang.WithMeta(v28, v29.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v15 = v30 -} else { -v31 := lang.NewMap() -v32 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(298), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(298), lang.NewKeyword("end-column"), int(20)) -v33, err := lang.WithMeta(v31, v32.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v15 = v33 -} -var v14 any = v15 -_ = v14 -var v35 any -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("string?")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("first")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) -} -v41 := v40.Get() -v42 := lang.Apply(v41, []any{v34}) -v43 := lang.Apply(v38, []any{v42}) -if lang.IsTruthy(v43) { -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("next")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v34}) -v35 = v47 -} else { -v35 = v34 -} -var v34 any = v35 -_ = v34 -var v49 any -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("map?")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("first")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) -} -v55 := v54.Get() -v56 := lang.Apply(v55, []any{v34}) -v57 := lang.Apply(v52, []any{v56}) -if lang.IsTruthy(v57) { -v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v59 := v58.FindInternedVar(lang.NewSymbol("conj")) -if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) -} -v60 := v59.Get() -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("first")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) -} -v63 := v62.Get() -v64 := lang.Apply(v63, []any{v34}) -v65 := lang.Apply(v60, []any{v48, v64}) -v49 = v65 -} else { -v49 = v48 -} -var v48 any = v49 -_ = v48 -var v67 any -v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v69 := v68.FindInternedVar(lang.NewSymbol("map?")) -if v69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) -} -v70 := v69.Get() -v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v72 := v71.FindInternedVar(lang.NewSymbol("first")) -if v72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) -} -v73 := v72.Get() -v74 := lang.Apply(v73, []any{v66}) -v75 := lang.Apply(v70, []any{v74}) -if lang.IsTruthy(v75) { -v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v77 := v76.FindInternedVar(lang.NewSymbol("next")) -if v77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) -} -v78 := v77.Get() -v79 := lang.Apply(v78, []any{v66}) -v67 = v79 -} else { -v67 = v66 -} -var v66 any = v67 -_ = v66 -var v81 any -v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v83 := v82.FindInternedVar(lang.NewSymbol("vector?")) -if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) -} -v84 := v83.Get() -v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v86 := v85.FindInternedVar(lang.NewSymbol("first")) -if v86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) -} -v87 := v86.Get() -v88 := lang.Apply(v87, []any{v80}) -v89 := lang.Apply(v84, []any{v88}) -if lang.IsTruthy(v89) { -v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v91 := v90.FindInternedVar(lang.NewSymbol("list")) -if v91.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) -} -v92 := v91.Get() -v93 := lang.Apply(v92, []any{v80}) -v81 = v93 -} else { -v81 = v80 -} -var v80 any = v81 -_ = v80 -var v95 any -v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v97 := v96.FindInternedVar(lang.NewSymbol("map?")) -if v97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) -} -v98 := v97.Get() -v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v100 := v99.FindInternedVar(lang.NewSymbol("last")) -if v100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) -} -v101 := v100.Get() -v102 := lang.Apply(v101, []any{v80}) -v103 := lang.Apply(v98, []any{v102}) -if lang.IsTruthy(v103) { -v104 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v105 := v104.FindInternedVar(lang.NewSymbol("conj")) -if v105.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v105))) -} -v106 := v105.Get() -v107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v108 := v107.FindInternedVar(lang.NewSymbol("last")) -if v108.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v108))) -} -v109 := v108.Get() -v110 := lang.Apply(v109, []any{v80}) -v111 := lang.Apply(v106, []any{v94, v110}) -v95 = v111 -} else { -v95 = v94 +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("seq")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -var v94 any = v95 -_ = v94 -var v113 any -v114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v115 := v114.FindInternedVar(lang.NewSymbol("map?")) -if v115.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v115))) +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("concat")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v116 := v115.Get() -v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v118 := v117.FindInternedVar(lang.NewSymbol("last")) -if v118.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("list")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } -v119 := v118.Get() -v120 := lang.Apply(v119, []any{v112}) -v121 := lang.Apply(v116, []any{v120}) -if lang.IsTruthy(v121) { -v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v123 := v122.FindInternedVar(lang.NewSymbol("butlast")) -if v123.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) +v15 := v14.Get() +v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/let")}) +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("list")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v124 := v123.Get() -v125 := lang.Apply(v124, []any{v112}) -v113 = v125 -} else { -v113 = v112 +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("apply")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -var v112 any = v113 -_ = v112 -v127 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v128 := v127.FindInternedVar(lang.NewSymbol("conj")) -if v128.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v128))) +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("vector")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v129 := v128.Get() -v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v131 := v130.FindInternedVar(lang.NewSymbol("list")) -if v131.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("seq")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) } -v132 := v131.Get() -v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v134 := v133.FindInternedVar(lang.NewSymbol("sigs")) -if v134.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("concat")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) } -v135 := v134.Get() -v136 := lang.Apply(v135, []any{v112}) -v137 := lang.Apply(v132, []any{lang.NewSymbol("quote"), v136}) -v138 := lang.NewMap(lang.NewKeyword("arglists"), v137) -v139 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(317), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(317), lang.NewKeyword("end-column"), int(60)) -v140, err := lang.WithMeta(v138, v139.(lang.IPersistentMap)) -if err != nil { - panic(err) +v31 := v30.Get() +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) } -v141 := lang.Apply(v129, []any{v140, v126}) -var v126 any = v141 -_ = v126 -v144 := lang.Apply(lang.NewKeyword("inline"), []any{v142}) -var v143 any = v144 -_ = v143 -v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v147 := v146.FindInternedVar(lang.NewSymbol("first")) -if v147.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) +v34 := v33.Get() +v35 := lang.Apply(v34, []any{lang.NewSymbol("or__0__auto__")}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) } -v148 := v147.Get() -v149 := lang.Apply(v148, []any{v143}) -var v145 any = v149 -_ = v145 -v151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v152 := v151.FindInternedVar(lang.NewSymbol("second")) -if v152.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v152))) +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v5}) +v40 := lang.Apply(v31, []any{v35, v39}) +v41 := lang.Apply(v28, []any{v40}) +v42 := lang.Apply(v22, []any{v25, v41}) +v43 := lang.Apply(v19, []any{v42}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } -v153 := v152.Get() -v154 := lang.Apply(v153, []any{v143}) -var v150 any = v154 -_ = v150 -var v156 any -var v157 any -v158 := lang.Apply(lang1.Equiv, []any{lang.NewSymbol("fn"), v145}) -if lang.IsTruthy(v158) { -var v159 any -v160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v161 := v160.FindInternedVar(lang.NewSymbol("instance?")) -if v161.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v161))) +v46 := v45.Get() +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("seq")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) } -v162 := v161.Get() -v163 := lang.Apply(v162, []any{lang1.*Symbol, v150}) -if lang.IsTruthy(v163) { -v159 = false -} else { -v159 = true +v49 := v48.Get() +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("concat")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) } -v157 = v159 -} else { -v157 = nil +v52 := v51.Get() +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("list")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) } -if lang.IsTruthy(v157) { -v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v165 := v164.FindInternedVar(lang.NewSymbol("assoc")) -if v165.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) +v55 := v54.Get() +v56 := lang.Apply(v55, []any{lang.NewSymbol("if")}) +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("list")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) } -v166 := v165.Get() -v167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v168 := v167.FindInternedVar(lang.NewSymbol("cons")) -if v168.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v168))) +v59 := v58.Get() +v60 := lang.Apply(v59, []any{lang.NewSymbol("or__0__auto__")}) +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("list")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) } -v169 := v168.Get() -v170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v171 := v170.FindInternedVar(lang.NewSymbol("cons")) -if v171.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v171))) +v63 := v62.Get() +v64 := lang.Apply(v63, []any{lang.NewSymbol("or__0__auto__")}) +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("list")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) } -v172 := v171.Get() -v173, ok := lang.FieldOrMethod(v6, "Name") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "Name"))) +v67 := v66.Get() +v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v69 := v68.FindInternedVar(lang.NewSymbol("seq")) +if v69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) } -var v174 any -switch reflect.TypeOf(v173).Kind() { -case reflect.Func: - v174 = lang.Apply(v173, nil) -default: - v174 = v173 +v70 := v69.Get() +v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v72 := v71.FindInternedVar(lang.NewSymbol("concat")) +if v72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) } -v175 := lang.Apply(lang1.ConcatStrings, []any{v174, "__inliner"}) -v176 := lang.Apply(lang1.NewSymbol, []any{v175}) -v177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v178 := v177.FindInternedVar(lang.NewSymbol("next")) -if v178.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v178))) +v73 := v72.Get() +v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v75 := v74.FindInternedVar(lang.NewSymbol("list")) +if v75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) } -v179 := v178.Get() -v180 := lang.Apply(v179, []any{v143}) -v181 := lang.Apply(v172, []any{v176, v180}) -v182 := lang.Apply(v169, []any{v145, v181}) -v183 := lang.Apply(v166, []any{v142, lang.NewKeyword("inline"), v182}) -v156 = v183 -} else { -v156 = v142 +v76 := v75.Get() +v77 := lang.Apply(v76, []any{lang.NewSymbol("glojure.core/or")}) +v78 := lang.Apply(v73, []any{v77, v6}) +v79 := lang.Apply(v70, []any{v78}) +v80 := lang.Apply(v67, []any{v79}) +v81 := lang.Apply(v52, []any{v56, v60, v64, v80}) +v82 := lang.Apply(v49, []any{v81}) +v83 := lang.Apply(v46, []any{v82}) +v84 := lang.Apply(v12, []any{v16, v43, v83}) +v85 := lang.Apply(v9, []any{v84}) +return v85 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -var v142 any = v156 -_ = v142 -v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v145 := v144.FindInternedVar(lang.NewSymbol("conj")) -if v145.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) } -v146 := v145.Get() -var v147 any -v148 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v149 := v148.FindInternedVar(lang.NewSymbol("meta")) -if v149.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v149))) +// parents +{ +v0 := lang.NewSymbol("parents").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"))), lang.NewKeyword("doc"), "Returns the immediate parents of tag, either via a Java type\n inheritance relationship or a relationship established via derive. h\n must be a hierarchy obtained from make-hierarchy, if not supplied\n defaults to the global hierarchy", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5607), lang.NewKeyword("end-line"), int(5607))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("parents")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v150 := v149.Get() -v151 := lang.Apply(v150, []any{v6}) -if lang.IsTruthy(v151) { -v152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v153 := v152.FindInternedVar(lang.NewSymbol("meta")) -if v153.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v153))) +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("global-hierarchy")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v154 := v153.Get() -v155 := lang.Apply(v154, []any{v6}) -v147 = v155 -} else { -v156 := lang.NewMap() -v157 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(328), lang.NewKeyword("column"), int(51), lang.NewKeyword("end-line"), int(328), lang.NewKeyword("end-column"), int(52)) -v158, err := lang.WithMeta(v156, v157.(lang.IPersistentMap)) -if err != nil { - panic(err) +v9 := v8.Get() +v10 := lang.Apply(v6, []any{v9, v3}) +return v10 + case 2: +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("not-empty")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v147 = v158 +v7 := v6.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("get")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -v159 := lang.Apply(v146, []any{v147, v143}) -var v143 any = v159 -_ = v143 -v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v162 := v161.FindInternedVar(lang.NewSymbol("list")) -if v162.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) +v11 := v10.Get() +v12 := lang.Apply(lang.NewKeyword("parents"), []any{v3}) +v13 := lang.Apply(v11, []any{v12, v4}) +var v8 any = v13 +_ = v8 +var v15 any +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("class?")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -v163 := v162.Get() -v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v165 := v164.FindInternedVar(lang.NewSymbol("with-meta")) -if v165.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v4}) +if lang.IsTruthy(v19) { +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("into1")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v166 := v165.Get() -v167 := lang.Apply(v166, []any{v6, v143}) -v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v169 := v168.FindInternedVar(lang.NewSymbol("with-meta")) -if v169.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("set")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v170 := v169.Get() -v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v172 := v171.FindInternedVar(lang.NewSymbol("cons")) -if v172.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("bases")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) } -v173 := v172.Get() -v174 := lang.Apply(v173, []any{lang.NewSymbol("glojure.core/fn"), v112}) -v175 := lang.Apply(lang.NewKeyword("tag"), []any{v143}) -v176 := lang.NewMap(lang.NewKeyword("rettag"), v175) -v177 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(333), lang.NewKeyword("column"), int(37), lang.NewKeyword("end-line"), int(333), lang.NewKeyword("end-column"), int(54)) -v178, err := lang.WithMeta(v176, v177.(lang.IPersistentMap)) -if err != nil { - panic(err) +v28 := v27.Get() +v29 := lang.Apply(v28, []any{v4}) +v30 := lang.Apply(v25, []any{v29}) +v31 := lang.Apply(v22, []any{v30, v8}) +v15 = v31 +} else { +v15 = v8 } -v179 := lang.Apply(v170, []any{v174, v178}) -v180 := lang.Apply(v163, []any{lang.NewSymbol("def"), v167, v179}) -return v180 +v8 := lang.Apply(v7, []any{v15}) +return v8 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(291), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(333), lang.NewKeyword("end-column"), int(58))).(lang.FnFunc) -v3 := v2 -_ = v3 +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// parse-boolean +{ +v0 := lang.NewSymbol("parse-boolean").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse strings \"true\" or \"false\" and return a boolean, or nil if invalid", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(8000), lang.NewKeyword("end-line"), int(8000))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("string?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +if lang.IsTruthy(v8) { +var v9 any = v3 +_ = v9 +v4 = nil +} else { +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("parsing-err")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v3}) +v13 := lang.Apply(lang1.NewIllegalArgumentError, []any{v12}) +panic(v13) +} +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// pos-int? +// parse-double { -v0 := lang.NewSymbol("pos-int?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a positive fixed precision integer", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1403), lang.NewKeyword("end-line"), int(1403))).(*lang.Symbol) +v0 := lang.NewSymbol("parse-double").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse string with floating point components and return a Double value,\n or nil if parse fails.\n\n Grammar: https://docs.oracle.com/javase/8/docs/api/java/lang/Double.html#valueOf-java.lang.String-", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7978), lang.NewKeyword("end-line"), int(7978))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] +var v4 any v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("int?")) +v6 := v5.FindInternedVar(lang.NewSymbol("string?")) if v6.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } v7 := v6.Get() v8 := lang.Apply(v7, []any{v3}) -var v4 any = v8 +if lang.IsTruthy(v8) { +v10 := lang.Apply(strconv27.ParseFloat, []any{v3, int64(64)}) +var v9 any = v10 +_ = v9 +var v12 any +v13 := lang.Apply(v9, []any{int64(1)}) +if lang.IsTruthy(v13) { +v12 = nil +} else { +v14 := lang.Apply(v9, []any{int64(0)}) +v12 = v14 +} +v4 = v12 +} else { +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("parsing-err")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v3}) +v13 := lang.Apply(lang1.NewIllegalArgumentError, []any{v12}) +panic(v13) +} +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// parse-impls +{ +v0 := lang.NewSymbol("parse-impls").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(13), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(13), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("specs"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v5 := lang.NewMap() +v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(14), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(14), lang.NewKeyword("end-column"), int(15)) +v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v4 any = v7 _ = v4 +var v8 any = v3 +_ = v8 +var v9 any +for { var v10 any -if lang.IsTruthy(v4) { v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("pos?")) +v12 := v11.FindInternedVar(lang.NewSymbol("seq")) if v12.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } v13 := v12.Get() -v14 := lang.Apply(v13, []any{v3}) -v10 = v14 +v14 := lang.Apply(v13, []any{v8}) +if lang.IsTruthy(v14) { +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("assoc")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("first")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v8}) +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("take-while")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("seq?")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("next")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.Apply(v31, []any{v8}) +v33 := lang.Apply(v25, []any{v28, v32}) +v34 := lang.Apply(v18, []any{v4, v22, v33}) +var v15 any = v34 +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("drop-while")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("seq?")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +} +v41 := v40.Get() +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("next")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +} +v44 := v43.Get() +v45 := lang.Apply(v44, []any{v8}) +v46 := lang.Apply(v38, []any{v41, v45}) +var v35 any = v46 +v4 = v15 +v8 = v35 +continue } else { v10 = v4 } -return v10 +v9 = v10 + break +} +return v9 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -57693,34 +57507,48 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// special-symbol? +// parse-long { -v0 := lang.NewSymbol("special-symbol?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns true if s names a special form", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4992), lang.NewKeyword("end-line"), int(4992))).(*lang.Symbol) +v0 := lang.NewSymbol("parse-long").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse string of decimal digits with optional leading -/+ and return a\n Long value, or nil if parse fails", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7969), lang.NewKeyword("end-line"), int(7969))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("contains?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("string?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v6 := v5.Get() -v7, ok := lang.FieldOrMethod(runtime3.Compiler, "specials") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", runtime3.Compiler, "specials"))) +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +if lang.IsTruthy(v8) { +v10 := lang.Apply(strconv27.ParseInt, []any{v3, int64(10), int64(64)}) +var v9 any = v10 +_ = v9 +var v12 any +v13 := lang.Apply(v9, []any{int64(1)}) +if lang.IsTruthy(v13) { +v12 = nil +} else { +v14 := lang.Apply(v9, []any{int64(0)}) +v12 = v14 } -var v8 any -switch reflect.TypeOf(v7).Kind() { -case reflect.Func: - v8 = lang.Apply(v7, nil) -default: - v8 = v7 +v4 = v12 +} else { +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("parsing-err")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -v9 := lang.Apply(v6, []any{v8, v3}) -return v9 +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v3}) +v13 := lang.Apply(lang1.NewIllegalArgumentError, []any{v12}) +panic(v13) +} +return v4 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -57728,91 +57556,32 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// ns-interns +// parse-uuid { -v0 := lang.NewSymbol("ns-interns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of the intern mappings for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4206), lang.NewKeyword("end-line"), int(4206))).(*lang.Symbol) +v0 := lang.NewSymbol("parse-uuid").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse a string representing a UUID and return a java.util.UUID instance,\n or nil if parse fails.\n\n Grammar: https://docs.oracle.com/javase/8/docs/api/java/util/UUID.html#toString--", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7989), lang.NewKeyword("end-line"), int(7989))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("the-ns")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v4}) -var v4 any = v8 -_ = v4 -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("filter-key")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("val")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -var v16 lang.FnFunc -v16 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v17 := args[0] -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("instance?")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{lang1.*Var, v17}) -var v18 any = v22 -_ = v18 -var v24 any -if lang.IsTruthy(v18) { -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("=")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28, ok := lang.FieldOrMethod(v17, "Namespace") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v17, "Namespace"))) -} -var v29 any -switch reflect.TypeOf(v28).Kind() { -case reflect.Func: - v29 = lang.Apply(v28, nil) -default: - v29 = v28 -} -v30 := lang.Apply(v27, []any{v4, v29}) -v24 = v30 +var v4 any +func() { +defer func() { +if r := recover(); r != nil { +if lang.CatchMatches(r, nil) { +v5 := r +_ = v5 +v4 = nil } else { -v24 = v18 -} -return v24 -}) -v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4212), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(4213), lang.NewKeyword("end-column"), int(56)) -v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) -if err != nil { - panic(err) +panic(r) } -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("ns-map")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v4}) -v23 := lang.Apply(v12, []any{v15, v18, v22}) -return v23 +}() +v5 := lang.Apply(nil, []any{v3}) +v4 = v5 +}() +return v4 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -57820,287 +57589,236 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// pos? +// parsing-err { -var v1 lang.FnFunc -{ // function pos?__inliner -v1 = lang.NewFnFunc(func(args ...any) any { +v0 := lang.NewSymbol("parsing-err").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Construct message for parsing for non-string parsing error", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(7964), lang.NewKeyword("end-line"), int(7964), lang.NewKeyword("private"), true)).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +v5 := v4.FindInternedVar(lang.NewSymbol("str")) if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +var v7 any +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("nil?")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v3}) +if lang.IsTruthy(v11) { +v7 = "nil" +} else { +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("class")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/isPos")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v3}) +v16, ok := lang.FieldOrMethod(v15, "Name") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v15, "Name"))) } -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v3}) -v35 := lang.Apply(v26, []any{v30, v34}) -v36 := lang.Apply(v23, []any{v35}) -v37 := lang.Apply(v20, []any{v36}) -v38 := lang.Apply(v9, []any{v13, v17, v37}) -v39 := lang.Apply(v6, []any{v38}) -return v39 -}) -v2 := v1 -_ = v2 +var v17 any +switch reflect.TypeOf(v16).Kind() { +case reflect.Func: + v17 = lang.Apply(v16, nil) +default: + v17 = v16 } -v0 := lang.NewSymbol("pos?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns true if num is greater than zero, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1252), lang.NewKeyword("end-line"), int(1252))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "isPos") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("isPos is not a function"))) +v7 = v17 } -v6 := lang.Apply(v5, []any{v4}) -return v6 +v18 := lang.Apply(v6, []any{"Expected string, got ", v7}) +return v18 }) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// repeat +// partial { -v0 := lang.NewSymbol("repeat").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns a lazy (infinite!, or length n if supplied) sequence of xs.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2997), lang.NewKeyword("end-line"), int(2997))).(*lang.Symbol) +v0 := lang.NewSymbol("partial").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("arg1")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("arg1"), lang.NewSymbol("arg2")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("arg1"), lang.NewSymbol("arg2"), lang.NewSymbol("arg3")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("arg1"), lang.NewSymbol("arg2"), lang.NewSymbol("arg3"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Takes a function f and fewer than the normal arguments to f, and\n returns a fn that takes a variable number of additional args. When\n called, the returned function calls f with args + additional args.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2606), lang.NewKeyword("end-line"), int(2606))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] -v4 := lang.Apply(lang1.NewRepeat, []any{v3}) -return v4 +return v3 case 2: v3 := args[0] v4 := args[1] -v5 := lang.Apply(lang1.NewRepeatN, []any{v3, v4}) -return v5 +var v5 lang.FnFunc +v5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v6 := lang.Apply(v3, []any{v4}) +return v6 + case 1: +v6 := args[0] +v7 := lang.Apply(v3, []any{v4, v6}) +return v7 + case 2: +v6 := args[0] +v7 := args[1] +v8 := lang.Apply(v3, []any{v4, v6, v7}) +return v8 + case 3: +v6 := args[0] +v7 := args[1] +v8 := args[2] +v9 := lang.Apply(v3, []any{v4, v6, v7, v8}) +return v9 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v6 := args[0] +v7 := args[1] +v8 := args[2] +v9 := lang.NewList(args[3:]...) +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("apply")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{v3, v4, v6, v7, v8, v9}) +return v13 } }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} +v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2614), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(2619), lang.NewKeyword("end-column"), int(48)) +v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) +if err != nil { + panic(err) } -// bound-fn* -{ -v0 := lang.NewSymbol("bound-fn*").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Returns a function, which will install the same bindings in effect as in\n the thread at the time bound-fn* was called and then call f with any given\n arguments. This may be used to define a helper function which runs on a\n different thread, but needs the same bindings in place.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1992), lang.NewKeyword("end-line"), int(1992))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } +return v7 + case 3: v3 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("get-thread-bindings")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, nil) -var v4 any = v8 -_ = v4 -var v10 lang.FnFunc -v10 = lang.NewFnFunc(func(args ...any) any { +v4 := args[1] +v5 := args[2] +var v6 lang.FnFunc +v6 = lang.NewFnFunc(func(args ...any) any { switch len(args) { + case 0: +v7 := lang.Apply(v3, []any{v4, v5}) +return v7 + case 1: +v7 := args[0] +v8 := lang.Apply(v3, []any{v4, v5, v7}) +return v8 + case 2: +v7 := args[0] +v8 := args[1] +v9 := lang.Apply(v3, []any{v4, v5, v7, v8}) +return v9 + case 3: +v7 := args[0] +v8 := args[1] +v9 := args[2] +v10 := lang.Apply(v3, []any{v4, v5, v7, v8, v9}) +return v10 default: - if len(args) < 0 { + if len(args) < 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v11 := lang.NewList(args[0:]...) -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("apply")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("with-bindings*")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +v7 := args[0] +v8 := args[1] +v9 := args[2] +v10 := lang.NewList(args[3:]...) +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("apply")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v17 := v16.Get() -v18 := lang.Apply(v14, []any{v17, v4, v3, v11}) -return v18 +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v3, v4, v5, v7, v8, v9, v10}) +return v14 } }) -v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2001), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2002), lang.NewKeyword("end-column"), int(45)) -v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) +v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2621), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(2626), lang.NewKeyword("end-column"), int(53)) +v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) if err != nil { panic(err) } -return v12 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// *' -{ -var v1 lang.FnFunc -v1 = lang.NewFnFunc(func(args ...any) any { +return v8 + case 4: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +var v7 lang.FnFunc +v7 = lang.NewFnFunc(func(args ...any) any { switch len(args) { + case 0: +v8 := lang.Apply(v3, []any{v4, v5, v6}) +return v8 case 1: -v2 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -if lang.IsTruthy(v7) { -v4 = closed12 -} else { -v4 = v3 -} -var v3 any = v4 -_ = v3 -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("seq")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("concat")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("seq")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("concat")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v2}) -v40 := lang.Apply(v31, []any{v35, v39}) -v41 := lang.Apply(v28, []any{v40}) -v42 := lang.Apply(v25, []any{v41}) -v43 := lang.Apply(v14, []any{v18, v22, v42}) -v44 := lang.Apply(v11, []any{v43}) -return v44 +v8 := args[0] +v9 := lang.Apply(v3, []any{v4, v5, v6, v8}) +return v9 case 2: -v2 := args[0] -v3 := args[1] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +v8 := args[0] +v9 := args[1] +v10 := lang.Apply(v3, []any{v4, v5, v6, v8, v9}) +return v10 + case 3: +v8 := args[0] +v9 := args[1] +v10 := args[2] +v11 := lang.Apply(v3, []any{v4, v5, v6, v8, v9, v10}) +return v11 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v8 := args[0] +v9 := args[1] +v10 := args[2] +v11 := lang.NewList(args[3:]...) +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("apply")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } -v8 := v7.Get() -if lang.IsTruthy(v8) { -v5 = closed12 -} else { -v5 = v4 +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v3, v4, v5, v6, v8, v9, v10, v11}) +return v15 + } +}) +v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2628), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(2633), lang.NewKeyword("end-column"), int(58)) +v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) +if err != nil { + panic(err) } -var v4 any = v5 -_ = v4 +return v9 + default: + if len(args) < 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := lang.NewList(args[4:]...) +var v8 lang.FnFunc +v8 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v9 := lang.NewList(args[0:]...) v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("seq")) +v11 := v10.FindInternedVar(lang.NewSymbol("apply")) if v11.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } @@ -58111,886 +57829,1108 @@ if v14.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("list")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +v16 := lang.Apply(v15, []any{v7, v9}) +v17 := lang.Apply(v12, []any{v3, v4, v5, v6, v16}) +return v17 + } +}) +v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2635), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(2635), lang.NewKeyword("end-column"), int(60)) +v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v18 := v17.Get() -v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) +return v10 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// partition +{ +v0 := lang.NewSymbol("partition").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("pad"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of lists of n items each, at offsets step\n apart. If step is not supplied, defaults to n, i.e. the partitions\n do not overlap. If a pad collection is supplied, use its elements as\n necessary to complete last partition upto n items. In case there are\n not enough padding elements, return a partition with less than n items.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3177), lang.NewKeyword("end-line"), int(3177))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("partition")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3, v3, v4}) +return v8 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +var v6 lang.FnFunc +v6 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("seq")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v5}) +var v7 any = v11 +_ = v7 +var v13 any +if lang.IsTruthy(v7) { +var v14 any = v7 +_ = v14 +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("doall")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("list")) +v21 := v20.FindInternedVar(lang.NewSymbol("take")) if v21.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } v22 := v21.Get() -v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("list")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() +v23 := lang.Apply(v22, []any{v3, v14}) +v24 := lang.Apply(v19, []any{v23}) +var v16 any = v24 +_ = v16 +var v26 any v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("seq")) +v28 := v27.FindInternedVar(lang.NewSymbol("=")) if v28.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } v29 := v28.Get() v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("concat")) +v31 := v30.FindInternedVar(lang.NewSymbol("count")) if v31.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) } v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("list")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +v33 := lang.Apply(v32, []any{v16}) +v34 := lang.Apply(v29, []any{v3, v33}) +if lang.IsTruthy(v34) { +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("cons")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) } -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v4}) -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("list")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +v37 := v36.Get() +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("partition")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) } -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v2}) +v40 := v39.Get() v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("list")) +v42 := v41.FindInternedVar(lang.NewSymbol("nthrest")) if v42.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } v43 := v42.Get() -v44 := lang.Apply(v43, []any{v3}) -v45 := lang.Apply(v32, []any{v36, v40, v44}) -v46 := lang.Apply(v29, []any{v45}) -v47 := lang.Apply(v26, []any{v46}) -v48 := lang.Apply(v15, []any{v19, v23, v47}) -v49 := lang.Apply(v12, []any{v48}) -return v49 +v44 := lang.Apply(v43, []any{v14, v4}) +v45 := lang.Apply(v40, []any{v3, v4, v44}) +v46 := lang.Apply(v37, []any{v16, v45}) +v26 = v46 +} else { +v26 = nil +} +v13 = v26 +} else { +v13 = nil +} +return v13 +}) +v7 := lang.Apply(lang1.NewLazySeq, []any{v6}) +return v7 + case 4: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +var v7 lang.FnFunc +v7 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("seq")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v6}) +var v8 any = v12 +_ = v8 +var v14 any +if lang.IsTruthy(v8) { +var v15 any = v8 +_ = v15 +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("doall")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("take")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v3, v15}) +v25 := lang.Apply(v20, []any{v24}) +var v17 any = v25 +_ = v17 +var v27 any +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("=")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("count")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v17}) +v35 := lang.Apply(v30, []any{v3, v34}) +if lang.IsTruthy(v35) { +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("cons")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("partition")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +} +v41 := v40.Get() +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("nthrest")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +} +v44 := v43.Get() +v45 := lang.Apply(v44, []any{v15, v4}) +v46 := lang.Apply(v41, []any{v3, v4, v5, v45}) +v47 := lang.Apply(v38, []any{v17, v46}) +v27 = v47 +} else { +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +} +v50 := v49.Get() +v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v52 := v51.FindInternedVar(lang.NewSymbol("take")) +if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) +} +v53 := v52.Get() +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("concat")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +} +v56 := v55.Get() +v57 := lang.Apply(v56, []any{v17, v5}) +v58 := lang.Apply(v53, []any{v3, v57}) +v59 := lang.Apply(v50, []any{v58}) +v27 = v59 +} +v14 = v27 +} else { +v14 = nil +} +return v14 +}) +v8 := lang.Apply(lang1.NewLazySeq, []any{v7}) +return v8 default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v2 := args[0] -v3 := args[1] -v4 := lang.NewList(args[2:]...) -var v6 any + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// partition-all +{ +v0 := lang.NewSymbol("partition-all").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of lists like partition, but may include\n partitions with fewer than n items at the end. Returns a stateful\n transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7265), lang.NewKeyword("end-line"), int(7265))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +v8 := v7.FindInternedVar(lang.NewSymbol("to-array")) if v8.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } v9 := v8.Get() -if lang.IsTruthy(v9) { -v6 = closed12 -} else { -v6 = v5 -} -var v5 any = v6 -_ = v5 -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v10 := lang.Apply(v9, []any{v3}) +v11 := lang.Apply(lang1.NewArrayList, []any{v10}) +var v6 any = v11 +_ = v6 +var v13 lang.FnFunc +v13 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v14 := lang.Apply(v5, nil) +return v14 + case 1: +v14 := args[0] +var v16 any +v17, ok := lang.FieldOrMethod(v6, "isEmpty") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "isEmpty"))) } -v13 := v12.Get() -var v14 lang.FnFunc -v14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v15 := args[0] -v16 := args[1] -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +var v18 any +switch reflect.TypeOf(v17).Kind() { +case reflect.Func: + v18 = lang.Apply(v17, nil) +default: + v18 = v17 } -v19 := v18.Get() +if lang.IsTruthy(v18) { +v16 = v15 +} else { v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +v21 := v20.FindInternedVar(lang.NewSymbol("vec")) if v21.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +v23, ok := lang.FieldOrMethod(v6, "toArray") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "toArray"))) } -v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +var v24 any +switch reflect.TypeOf(v23).Kind() { +case reflect.Func: + v24 = lang.Apply(v23, nil) +default: + v24 = v23 } -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v25 := lang.Apply(v22, []any{v24}) +var v19 any = v25 +_ = v19 +v27, ok := lang.FieldOrMethod(v6, "clear") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "clear"))) } -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +var v28 any +switch reflect.TypeOf(v27).Kind() { +case reflect.Func: + v28 = lang.Apply(v27, nil) +default: + v28 = v27 } -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +_ = v28 +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("unreduced")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) } -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +v31 := v30.Get() +v32 := lang.Apply(v5, []any{v15, v19}) +v33 := lang.Apply(v31, []any{v32}) +v16 = v33 } -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v5}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +var v15 any = v16 +_ = v15 +v20 := lang.Apply(v5, []any{v15}) +return v20 + case 2: +v14 := args[0] +v15 := args[1] +v16, _ := lang.FieldOrMethod(v6, "add") +if reflect.TypeOf(v16).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) +} +v17 := lang.Apply(v16, []any{v15}) +_ = v17 +var v18 any +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("=")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22, ok := lang.FieldOrMethod(v6, "size") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "size"))) +} +var v23 any +switch reflect.TypeOf(v22).Kind() { +case reflect.Func: + v23 = lang.Apply(v22, nil) +default: + v23 = v22 +} +v24 := lang.Apply(v21, []any{v3, v23}) +if lang.IsTruthy(v24) { +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("vec")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29, ok := lang.FieldOrMethod(v6, "toArray") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "toArray"))) +} +var v30 any +switch reflect.TypeOf(v29).Kind() { +case reflect.Func: + v30 = lang.Apply(v29, nil) +default: + v30 = v29 +} +v31 := lang.Apply(v28, []any{v30}) +var v25 any = v31 +_ = v25 +v33, ok := lang.FieldOrMethod(v6, "clear") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "clear"))) +} +var v34 any +switch reflect.TypeOf(v33).Kind() { +case reflect.Func: + v34 = lang.Apply(v33, nil) +default: + v34 = v33 +} +_ = v34 +v35 := lang.Apply(v5, []any{v14, v25}) +v18 = v35 +} else { +v18 = v14 } -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v15}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +return v18 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7274), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7290), lang.NewKeyword("end-column"), int(23)) +v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v16}) -v52 := lang.Apply(v39, []any{v43, v47, v51}) -v53 := lang.Apply(v36, []any{v52}) -v54 := lang.Apply(v33, []any{v53}) -v55 := lang.Apply(v22, []any{v26, v30, v54}) -v56 := lang.Apply(v19, []any{v55}) -return v56 +return v15 }) -v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) -v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) +v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7272), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7290), lang.NewKeyword("end-column"), int(25)) +v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) if err != nil { panic(err) } +return v6 + case 2: +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("partition-all")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3, v3, v4}) +return v8 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +var v6 lang.FnFunc +v6 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("seq")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v5}) +var v7 any = v11 +_ = v7 +var v13 any +if lang.IsTruthy(v7) { +var v14 any = v7 +_ = v14 v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +v18 := v17.FindInternedVar(lang.NewSymbol("doall")) if v18.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } v19 := v18.Get() v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +v21 := v20.FindInternedVar(lang.NewSymbol("take")) if v21.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +v23 := lang.Apply(v22, []any{v3, v14}) +v24 := lang.Apply(v19, []any{v23}) +var v16 any = v24 +_ = v16 +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("cons")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) } -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("partition-all")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) } -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v5}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +v31 := v30.Get() +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("nthrest")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) } -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v2}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v14, v4}) +v36 := lang.Apply(v31, []any{v3, v4, v35}) +v37 := lang.Apply(v28, []any{v16, v36}) +v13 = v37 +} else { +v13 = nil } -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v3}) -v52 := lang.Apply(v39, []any{v43, v47, v51}) -v53 := lang.Apply(v36, []any{v52}) -v54 := lang.Apply(v33, []any{v53}) -v55 := lang.Apply(v22, []any{v26, v30, v54}) -v56 := lang.Apply(v19, []any{v55}) -v57 := lang.Apply(v13, []any{v16, v56, v4}) -return v57 - } +return v13 }) -v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { +v7 := lang.Apply(lang1.NewLazySeq, []any{v6}) +return v7 + default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := args[0] -v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) -} -v5 := lang.Apply(v4, []any{v3, int64(1)}) -return v5 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v0 := lang.NewSymbol("*'").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the product of nums. (*') returns 1. Supports arbitrary precision.\n See also: *", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(989), lang.NewKeyword("end-line"), int(989))).(*lang.Symbol) -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// partition-by +{ +v0 := lang.NewSymbol("partition-by").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Applies f to each value in coll, splitting it each time f returns a\n new value. Returns a lazy seq of partitions. Returns a stateful\n transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7185), lang.NewKeyword("end-line"), int(7185))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 0: -return int64(1) case 1: +v3 := args[0] +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v5 := args[0] -v6 := lang.Apply(lang1.MustAsNumber, []any{v5}) -return v6 - case 2: -v5 := args[0] -v6 := args[1] -v7, _ := lang.FieldOrMethod(lang1.Numbers, "multiplyP") -if reflect.TypeOf(v7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("multiplyP is not a function"))) -} -v8 := lang.Apply(v7, []any{v5, v6}) -return v8 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := args[0] -v6 := args[1] -v7 := lang.NewList(args[2:]...) +var v6 any = "unimplemented: new with non-constant class type" +_ = v6 v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) +v9 := v8.FindInternedVar(lang.NewSymbol("volatile!")) if v9.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("*'")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("*'")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v11 := lang.Apply(v10, []any{lang.NewKeyword("glojure.core/none")}) +var v7 any = v11 +_ = v7 +var v13 lang.FnFunc +v13 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v14 := lang.Apply(v5, nil) +return v14 + case 1: +v14 := args[0] +var v16 any +v17, ok := lang.FieldOrMethod(v6, "isEmpty") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "isEmpty"))) } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v5, v6}) -v18 := lang.Apply(v10, []any{v13, v17, v7}) -return v18 - } -}) -v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v3 := ns.InternWithValue(v0, v4, true) -if v0.Meta() != nil { - v3.SetMeta(v0.Meta().(lang.IPersistentMap)) +var v18 any +switch reflect.TypeOf(v17).Kind() { +case reflect.Func: + v18 = lang.Apply(v17, nil) +default: + v18 = v17 } +if lang.IsTruthy(v18) { +v16 = v15 +} else { +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("vec")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -// unchecked-multiply -{ -var v1 lang.FnFunc -{ // function unchecked-multiply__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v22 := v21.Get() +v23, ok := lang.FieldOrMethod(v6, "toArray") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "toArray"))) } -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("concat")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +var v24 any +switch reflect.TypeOf(v23).Kind() { +case reflect.Func: + v24 = lang.Apply(v23, nil) +default: + v24 = v23 } -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("list")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v25 := lang.Apply(v22, []any{v24}) +var v19 any = v25 +_ = v19 +v27, ok := lang.FieldOrMethod(v6, "clear") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "clear"))) } -v13 := v12.Get() -v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +var v28 any +switch reflect.TypeOf(v27).Kind() { +case reflect.Func: + v28 = lang.Apply(v27, nil) +default: + v28 = v27 } -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +_ = v28 +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("unreduced")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) } -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("seq")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v31 := v30.Get() +v32 := lang.Apply(v5, []any{v15, v19}) +v33 := lang.Apply(v31, []any{v32}) +v16 = v33 } -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("concat")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +var v15 any = v16 +_ = v15 +v20 := lang.Apply(v5, []any{v15}) +return v20 + case 2: +v14 := args[0] +v15 := args[1] +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("deref")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("list")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v7}) +var v16 any = v20 +_ = v16 +v22 := lang.Apply(v3, []any{v15}) +var v21 any = v22 +_ = v21 +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("vreset!")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -v30 := v29.Get() -v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/unchecked_multiply")}) -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v7, v21}) +_ = v27 +var v28 any +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("identical?")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) } -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) +v32 := v31.Get() +v33 := lang.Apply(v32, []any{v16, lang.NewKeyword("glojure.core/none")}) +var v29 any = v33 +_ = v29 +var v35 any +if lang.IsTruthy(v29) { +v35 = v29 +} else { v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) +v37 := v36.FindInternedVar(lang.NewSymbol("=")) if v37.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) } v38 := v37.Get() -v39 := lang.Apply(v38, []any{v4}) -v40 := lang.Apply(v27, []any{v31, v35, v39}) -v41 := lang.Apply(v24, []any{v40}) -v42 := lang.Apply(v21, []any{v41}) -v43 := lang.Apply(v10, []any{v14, v18, v42}) -v44 := lang.Apply(v7, []any{v43}) -return v44 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("unchecked-multiply").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the product of x and y, both long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1231), lang.NewKeyword("end-line"), int(1231))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6, _ := lang.FieldOrMethod(lang1.Numbers, "unchecked_multiply") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_multiply is not a function"))) -} -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +v39 := lang.Apply(v38, []any{v21, v16}) +v35 = v39 } +if lang.IsTruthy(v35) { +v29, _ := lang.FieldOrMethod(v6, "add") +if reflect.TypeOf(v29).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) } -// <= -{ -var v1 lang.FnFunc -{ // function <=__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v30 := lang.Apply(v29, []any{v15}) +_ = v30 +v28 = v14 +} else { +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("vec")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) } -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("concat")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v34 := v33.Get() +v35, ok := lang.FieldOrMethod(v6, "toArray") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "toArray"))) } -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("list")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +var v36 any +switch reflect.TypeOf(v35).Kind() { +case reflect.Func: + v36 = lang.Apply(v35, nil) +default: + v36 = v35 } -v13 := v12.Get() -v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +v37 := lang.Apply(v34, []any{v36}) +var v31 any = v37 +_ = v31 +v39, ok := lang.FieldOrMethod(v6, "clear") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "clear"))) } -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +var v40 any +switch reflect.TypeOf(v39).Kind() { +case reflect.Func: + v40 = lang.Apply(v39, nil) +default: + v40 = v39 } -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("seq")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +_ = v40 +v42 := lang.Apply(v5, []any{v14, v31}) +var v41 any = v42 +_ = v41 +var v44 any +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("reduced?")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) } -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("concat")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +v47 := v46.Get() +v48 := lang.Apply(v47, []any{v41}) +if lang.IsTruthy(v48) { +v44 = nil +} else { +v49, _ := lang.FieldOrMethod(v6, "add") +if reflect.TypeOf(v49).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) } -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("list")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +v50 := lang.Apply(v49, []any{v15}) +v44 = v50 } -v30 := v29.Get() -v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/lte")}) -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +_ = v44 +v28 = v41 } -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +return v28 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7195), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(7219), lang.NewKeyword("end-column"), int(28)) +v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v4}) -v40 := lang.Apply(v27, []any{v31, v35, v39}) -v41 := lang.Apply(v24, []any{v40}) -v42 := lang.Apply(v21, []any{v41}) -v43 := lang.Apply(v10, []any{v14, v18, v42}) -v44 := lang.Apply(v7, []any{v43}) -return v44 +return v15 }) -v2 := v1 -_ = v2 +v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7192), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(7219), lang.NewKeyword("end-column"), int(30)) +v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v0 := lang.NewSymbol("<=").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns non-nil if nums are in monotonically non-decreasing order,\n otherwise false.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1048), lang.NewKeyword("end-line"), int(1048))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v4 := args[0] -return true +return v6 case 2: -v4 := args[0] -v5 := args[1] -v6, _ := lang.FieldOrMethod(lang1.Numbers, "lte") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("lte is not a function"))) -} -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6 := lang.NewList(args[2:]...) -recur_loop_194: -var v7 any -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("<=")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v3 := args[0] +v4 := args[1] +var v5 lang.FnFunc +v5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("seq")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v4, v5}) -if lang.IsTruthy(v11) { +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v4}) +var v6 any = v10 +_ = v6 var v12 any -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("next")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v6}) -if lang.IsTruthy(v16) { -var v17 any = v5 -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("first")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +if lang.IsTruthy(v6) { +var v13 any = v6 +_ = v13 +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("first")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v6}) -var v18 any = v22 -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("next")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v13}) +var v15 any = v19 +_ = v15 +v21 := lang.Apply(v3, []any{v15}) +var v20 any = v21 +_ = v20 +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("cons")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v6}) -var v23 any = v27 -v4 = v17 -v5 = v18 -v6 = v23 -goto recur_loop_194 -} else { -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("<=")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("take-while")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) } -v30 := v29.Get() +v28 := v27.Get() +var v29 lang.FnFunc +v29 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v30 := args[0] v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("first")) +v32 := v31.FindInternedVar(lang.NewSymbol("=")) if v32.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } v33 := v32.Get() -v34 := lang.Apply(v33, []any{v6}) -v35 := lang.Apply(v30, []any{v5, v34}) -v12 = v35 +v34 := lang.Apply(v3, []any{v30}) +v35 := lang.Apply(v33, []any{v20, v34}) +return v35 +}) +v30 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7225), lang.NewKeyword("column"), int(41), lang.NewKeyword("end-line"), int(7225), lang.NewKeyword("end-column"), int(53)) +v31, err := lang.WithMeta(v29, v30.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v7 = v12 +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("next")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v13}) +v36 := lang.Apply(v28, []any{v31, v35}) +v37 := lang.Apply(v25, []any{v15, v36}) +var v22 any = v37 +_ = v22 +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("cons")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +} +v41 := v40.Get() +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("partition-by")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +} +v44 := v43.Get() +var v45 lang.FnFunc +v45 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("drop")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +} +v48 := v47.Get() +v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v50 := v49.FindInternedVar(lang.NewSymbol("count")) +if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) +} +v51 := v50.Get() +v52 := lang.Apply(v51, []any{v22}) +v53 := lang.Apply(v48, []any{v52, v13}) +return v53 +}) +v46 := lang.Apply(lang1.NewLazySeq, []any{v45}) +v47 := lang.Apply(v44, []any{v3, v46}) +v48 := lang.Apply(v41, []any{v22, v47}) +v12 = v48 } else { -v7 = false +v12 = nil } -return v7 +return v12 +}) +v6 := lang.Apply(lang1.NewLazySeq, []any{v5}) +return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// lift-ns +// partitionv { -v0 := lang.NewSymbol("lift-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"))), lang.NewKeyword("doc"), "Returns [lifted-ns lifted-kvs] or nil if m can't be lifted.", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(261), lang.NewKeyword("end-line"), int(261), lang.NewKeyword("private"), true)).(*lang.Symbol) +v0 := lang.NewSymbol("partitionv").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("pad"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of vectors of n items each, at offsets step\n apart. If step is not supplied, defaults to n, i.e. the partitions\n do not overlap. If a pad collection is supplied, use its elements as\n necessary to complete last partition upto n items. In case there are\n not enough padding elements, return a partition with less than n items.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7305), lang.NewKeyword("end-line"), int(7305))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + switch len(args) { + case 2: v3 := args[0] -var v4 any +v4 := args[1] v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("*print-namespace-maps*")) +v6 := v5.FindInternedVar(lang.NewSymbol("partitionv")) if v6.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } v7 := v6.Get() -if lang.IsTruthy(v7) { -var v8 any = nil -_ = v8 -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("seq")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v8 := lang.Apply(v7, []any{v3, v3, v4}) +return v8 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +var v6 lang.FnFunc +v6 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("seq")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v12 := v11.Get() -v13 := lang.Apply(v12, []any{v3}) -var v9 any = v13 -_ = v9 -var v14 any = v9 +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v5}) +var v7 any = v11 +_ = v7 +var v13 any +if lang.IsTruthy(v7) { +var v14 any = v7 _ = v14 -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("seq")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v14}) -var v15 any = v19 -_ = v15 -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("first")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v15}) -var v20 any = v24 -_ = v20 -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("next")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.Apply(v28, []any{v25}) -var v25 any = v29 -_ = v25 -var v30 any = v20 -_ = v30 -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("nth")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v30, int64(0), nil}) -var v31 any = v35 -_ = v31 -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("nth")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("into")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v30, int64(1), nil}) -var v36 any = v40 -_ = v36 -var v41 any = v30 -_ = v41 -var v42 any = v25 -_ = v42 -v44 := lang.NewVector() -v45 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(267), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(267), lang.NewKeyword("end-column"), int(17)) -v46, err := lang.WithMeta(v44, v45.(lang.IPersistentMap)) +v19 := v18.Get() +v20 := lang.NewVector() +v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7317), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(7317), lang.NewKeyword("end-column"), int(23)) +v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) if err != nil { panic(err) } -var v43 any = v46 -_ = v43 -var v48 any = v48 -_ = v48 -var v49 any = v49 -_ = v49 -var v50 any = v50 -_ = v50 -var v51 any -for { -var v52 any = v52 -_ = v52 -var v53 any = v49 -_ = v53 -v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v56 := v55.FindInternedVar(lang.NewSymbol("seq")) -if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("take")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v57 := v56.Get() -v58 := lang.Apply(v57, []any{v53}) -var v54 any = v58 -_ = v54 -v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v61 := v60.FindInternedVar(lang.NewSymbol("first")) -if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) +v25 := v24.Get() +v26 := lang.Apply(v25, []any{v3}) +v27 := lang.Apply(v19, []any{v22, v26, v14}) +var v16 any = v27 +_ = v16 +var v29 any +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("=")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) } -v62 := v61.Get() -v63 := lang.Apply(v62, []any{v54}) -var v59 any = v63 -_ = v59 -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("next")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("count")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) } -v67 := v66.Get() -v68 := lang.Apply(v67, []any{v64}) -var v64 any = v68 -_ = v64 -var v69 any = v59 -_ = v69 -v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v72 := v71.FindInternedVar(lang.NewSymbol("nth")) -if v72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v16}) +v37 := lang.Apply(v32, []any{v3, v36}) +if lang.IsTruthy(v37) { +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("cons")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) } -v73 := v72.Get() -v74 := lang.Apply(v73, []any{v69, int64(0), nil}) -var v70 any = v74 -_ = v70 -v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v77 := v76.FindInternedVar(lang.NewSymbol("nth")) -if v77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("partitionv")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } -v78 := v77.Get() -v79 := lang.Apply(v78, []any{v69, int64(1), nil}) -var v75 any = v79 -_ = v75 -var v80 any = v69 -_ = v80 -var v81 any = v64 -_ = v81 -var v82 any = v82 -_ = v82 -var v84 any -if lang.IsTruthy(v80) { -var v85 any -v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v87 := v86.FindInternedVar(lang.NewSymbol("qualified-ident?")) -if v87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) +v43 := v42.Get() +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("nthrest")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } -v88 := v87.Get() -v89 := lang.Apply(v88, []any{v70}) -if lang.IsTruthy(v89) { -var v90 any -if lang.IsTruthy(v52) { -var v91 any -v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v93 := v92.FindInternedVar(lang.NewSymbol("=")) -if v93.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v14, v4}) +v48 := lang.Apply(v43, []any{v3, v4, v47}) +v49 := lang.Apply(v40, []any{v16, v48}) +v29 = v49 +} else { +v29 = nil } -v94 := v93.Get() -v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v96 := v95.FindInternedVar(lang.NewSymbol("namespace")) -if v96.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) +v13 = v29 +} else { +v13 = nil } -v97 := v96.Get() -v98 := lang.Apply(v97, []any{v70}) -v99 := lang.Apply(v94, []any{v52, v98}) -if lang.IsTruthy(v99) { -var v100 any = v52 -var v101 any = v81 -v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v104 := v103.FindInternedVar(lang.NewSymbol("conj")) -if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) +return v13 +}) +v7 := lang.Apply(lang1.NewLazySeq, []any{v6}) +return v7 + case 4: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +var v7 lang.FnFunc +v7 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("seq")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -v105 := v104.Get() -v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v107 := v106.FindInternedVar(lang.NewSymbol("strip-ns")) -if v107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v6}) +var v8 any = v12 +_ = v8 +var v14 any +if lang.IsTruthy(v8) { +var v15 any = v8 +_ = v15 +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("into")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v108 := v107.Get() -v109 := lang.Apply(v108, []any{v70}) -v110 := lang.NewVector(v109, v75) -v111 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(272), lang.NewKeyword("column"), int(43), lang.NewKeyword("end-line"), int(272), lang.NewKeyword("end-column"), int(58)) -v112, err := lang.WithMeta(v110, v111.(lang.IPersistentMap)) +v20 := v19.Get() +v21 := lang.NewVector() +v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7323), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(7323), lang.NewKeyword("end-column"), int(23)) +v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) if err != nil { panic(err) } -v113 := lang.Apply(v105, []any{v82, v112}) -var v102 any = v113 -v48 = v100 -v49 = v101 -v50 = v102 -continue -} else { -v91 = nil -} -v90 = v91 -} else { -v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v116 := v115.FindInternedVar(lang.NewSymbol("namespace")) -if v116.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("take")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -v117 := v116.Get() -v118 := lang.Apply(v117, []any{v70}) -var v114 any = v118 -_ = v114 -var v120 any -if lang.IsTruthy(v114) { -var v121 any = v114 -_ = v121 -var v123 any = v121 -var v124 any = v81 -v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v127 := v126.FindInternedVar(lang.NewSymbol("conj")) -if v127.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v3}) +v28 := lang.Apply(v20, []any{v23, v27, v15}) +var v17 any = v28 +_ = v17 +var v30 any +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("=")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -v128 := v127.Get() -v129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v130 := v129.FindInternedVar(lang.NewSymbol("strip-ns")) -if v130.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v130))) +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("count")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } -v131 := v130.Get() -v132 := lang.Apply(v131, []any{v70}) -v133 := lang.NewVector(v132, v75) -v134 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(274), lang.NewKeyword("column"), int(47), lang.NewKeyword("end-line"), int(274), lang.NewKeyword("end-column"), int(62)) -v135, err := lang.WithMeta(v133, v134.(lang.IPersistentMap)) -if err != nil { - panic(err) +v36 := v35.Get() +v37 := lang.Apply(v36, []any{v17}) +v38 := lang.Apply(v33, []any{v3, v37}) +if lang.IsTruthy(v38) { +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("cons")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) } -v136 := lang.Apply(v128, []any{v82, v135}) -var v125 any = v136 -v48 = v123 -v49 = v124 -v50 = v125 -continue -} else { -v120 = nil +v41 := v40.Get() +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("partitionv")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) } -v90 = v120 +v44 := v43.Get() +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("nthrest")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) } -v85 = v90 +v47 := v46.Get() +v48 := lang.Apply(v47, []any{v15, v4}) +v49 := lang.Apply(v44, []any{v3, v4, v5, v48}) +v50 := lang.Apply(v41, []any{v17, v49}) +v30 = v50 } else { -v85 = nil +v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v52 := v51.FindInternedVar(lang.NewSymbol("list")) +if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) } -v84 = v85 -} else { -v114 := lang.NewVector(v52, v82) -v115 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(275), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(275), lang.NewKeyword("end-column"), int(16)) -v116, err := lang.WithMeta(v114, v115.(lang.IPersistentMap)) +v53 := v52.Get() +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("into")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +} +v56 := v55.Get() +v57 := lang.NewVector() +v58 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7326), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(7326), lang.NewKeyword("end-column"), int(25)) +v59, err := lang.WithMeta(v57, v58.(lang.IPersistentMap)) if err != nil { panic(err) } -v84 = v116 +v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v61 := v60.FindInternedVar(lang.NewSymbol("take")) +if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) } -v51 = v84 - break +v62 := v61.Get() +v63 := lang.Apply(v62, []any{v3}) +v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v65 := v64.FindInternedVar(lang.NewSymbol("concat")) +if v65.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) } -v4 = v51 +v66 := v65.Get() +v67 := lang.Apply(v66, []any{v17, v5}) +v68 := lang.Apply(v56, []any{v59, v63, v67}) +v69 := lang.Apply(v53, []any{v68}) +v30 = v69 +} +v14 = v30 } else { -v4 = nil +v14 = nil } -return v4 +return v14 +}) +v8 := lang.Apply(lang1.NewLazySeq, []any{v7}) +return v8 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -58998,75 +58938,150 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// nnext +// partitionv-all { -v0 := lang.NewSymbol("nnext").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Same as (next (next x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(119), lang.NewKeyword("end-line"), int(123))).(*lang.Symbol) +v0 := lang.NewSymbol("partitionv-all").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of vector partitions, but may include\n partitions with fewer than n items at the end.\n Returns a stateful transducer when no collection is provided.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7328), lang.NewKeyword("end-line"), int(7328))).(*lang.Symbol) var v2 lang.FnFunc -{ // function nnext v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] + switch len(args) { + case 1: +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("partition-all")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{v3}) +return v7 + case 2: +v3 := args[0] +v4 := args[1] v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("next")) +v6 := v5.FindInternedVar(lang.NewSymbol("partitionv-all")) if v6.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3, v3, v4}) +return v8 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +var v6 lang.FnFunc +v6 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("next")) +v9 := v8.FindInternedVar(lang.NewSymbol("seq")) if v9.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } v10 := v9.Get() -v11 := lang.Apply(v10, []any{v4}) -v12 := lang.Apply(v7, []any{v11}) -return v12 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(123), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(123), lang.NewKeyword("end-column"), int(46))).(lang.FnFunc) -v3 := v2 -_ = v3 +v11 := lang.Apply(v10, []any{v5}) +var v7 any = v11 +_ = v7 +var v13 any +if lang.IsTruthy(v7) { +var v14 any = v7 +_ = v14 +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("into")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.NewVector() +v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7340), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(7340), lang.NewKeyword("end-column"), int(25)) +v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("take")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{v3}) +v27 := lang.Apply(v19, []any{v22, v26, v5}) +var v16 any = v27 +_ = v16 +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("cons")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("partitionv-all")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("drop")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v37, []any{v4, v14}) +v39 := lang.Apply(v34, []any{v3, v4, v38}) +v40 := lang.Apply(v31, []any{v16, v39}) +v13 = v40 +} else { +v13 = nil } +return v13 +}) +v7 := lang.Apply(lang1.NewLazySeq, []any{v6}) +return v7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// ex-cause +// pcalls { -v0 := lang.NewSymbol("ex-cause").WithMeta(lang.NewMap(lang.NewKeyword("tag"), nil, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ex"))), lang.NewKeyword("doc"), "Returns the cause of ex if ex is a Throwable.\n Otherwise returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4828), lang.NewKeyword("end-line"), int(4828))).(*lang.Symbol) +v0 := lang.NewSymbol("pcalls").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("fns"))), lang.NewKeyword("doc"), "Executes the no-arg fns in parallel, returning a lazy sequence of\n their values", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7099), lang.NewKeyword("end-line"), int(7099))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.NewList(args[0:]...) +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("pmap")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +var v7 lang.FnFunc +v7 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{lang1.Throwable, v3}) -if lang.IsTruthy(v8) { -v9, ok := lang.FieldOrMethod(v3, "getCause") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getCause"))) -} -var v10 any -switch reflect.TypeOf(v9).Kind() { -case reflect.Func: - v10 = lang.Apply(v9, nil) -default: - v10 = v9 -} -v4 = v10 -} else { -v4 = nil +v8 := args[0] +v9 := lang.Apply(v8, nil) +return v9 +}) +v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7104), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(7104), lang.NewKeyword("end-column"), int(20)) +v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) +if err != nil { + panic(err) } -return v4 +v10 := lang.Apply(v6, []any{v9, v3}) +return v10 + } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -59074,23 +59089,21 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// counted? +// peek { -v0 := lang.NewSymbol("counted?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements count in constant time", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6284), lang.NewKeyword("end-line"), int(6284))).(*lang.Symbol) +v0 := lang.NewSymbol("peek").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "For a list or queue, same as first, for a vector, same as, but much\n more efficient than, last. If the collection is empty, returns nil.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1455), lang.NewKeyword("end-line"), int(1455))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v4, _ := lang.FieldOrMethod(runtime9.RT, "Peek") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Peek is not a function"))) } -v6 := v5.Get() -v7 := lang.Apply(v6, []any{lang1.Counted, v3}) -return v7 +v5 := lang.Apply(v4, []any{v3}) +return v5 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -59098,499 +59111,403 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// bit-xor +// persistent! { -var v1 lang.FnFunc -v1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v2 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -if lang.IsTruthy(v7) { -v4 = closed13 -} else { -v4 = v3 -} -var v3 any = v4 -_ = v3 -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("seq")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("concat")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("seq")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("concat")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +v0 := lang.NewSymbol("persistent!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a new, persistent version of the transient collection, in\n constant time. The transient collection cannot be used after this\n call, any such use will throw an exception.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3350), lang.NewKeyword("end-line"), int(3350))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, ok := lang.FieldOrMethod(v3, "Persistent") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "Persistent"))) } -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v2}) -v40 := lang.Apply(v31, []any{v35, v39}) -v41 := lang.Apply(v28, []any{v40}) -v42 := lang.Apply(v25, []any{v41}) -v43 := lang.Apply(v14, []any{v18, v22, v42}) -v44 := lang.Apply(v11, []any{v43}) -return v44 - case 2: -v2 := args[0] -v3 := args[1] var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -if lang.IsTruthy(v8) { -v5 = closed13 -} else { -v5 = v4 -} -var v4 any = v5 -_ = v4 -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("seq")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("concat")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("list")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("list")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("list")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("seq")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("concat")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("list")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v4}) -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("list")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +switch reflect.TypeOf(v4).Kind() { +case reflect.Func: + v5 = lang.Apply(v4, nil) +default: + v5 = v4 } -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v2}) -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("list")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v3}) -v45 := lang.Apply(v32, []any{v36, v40, v44}) -v46 := lang.Apply(v29, []any{v45}) -v47 := lang.Apply(v26, []any{v46}) -v48 := lang.Apply(v15, []any{v19, v23, v47}) -v49 := lang.Apply(v12, []any{v48}) -return v49 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v2 := args[0] -v3 := args[1] -v4 := lang.NewList(args[2:]...) -var v6 any -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v9 := v8.Get() -if lang.IsTruthy(v9) { -v6 = closed13 -} else { -v6 = v5 +// pmap +{ +v0 := lang.NewSymbol("pmap").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Like map, except f is applied in parallel. Semi-lazy in that the\n parallel computation stays ahead of the consumption, but doesn't\n realize the entire result unless required. Only useful for\n computationally intensive functions where the time of f dominates\n the coordination overhead.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7074), lang.NewKeyword("end-line"), int(7074))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v3 := args[0] +v4 := args[1] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("+")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -var v5 any = v6 +v8 := v7.Get() +v9 := lang.Apply(runtime28.NumCPU, nil) +v10 := lang.Apply(v8, []any{int64(2), v9}) +var v5 any = v10 _ = v5 -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("map")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } -v13 := v12.Get() -var v14 lang.FnFunc -v14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { +v14 := v13.Get() +var v15 lang.FnFunc +v15 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v15 := args[0] -v16 := args[1] +v16 := args[0] v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +v18 := v17.FindInternedVar(lang.NewSymbol("future-call")) if v18.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("concat")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +var v20 lang.FnFunc +v20 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v21 := lang.Apply(v3, []any{v16}) +return v21 +}) +v21 := lang.Apply(v19, []any{v20}) +return v21 +}) +v16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7084), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7084), lang.NewKeyword("end-column"), int(34)) +v17, err := lang.WithMeta(v15, v16.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v18 := lang.Apply(v14, []any{v17, v4}) +var v11 any = v18 +_ = v11 +var v20 lang.FnFunc +{ // function step +v20 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v22 := args[0] +v23 := args[1] +var v24 any = v22 +_ = v24 +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("seq")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) } -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v28 := v27.Get() +v29 := lang.Apply(v28, []any{v24}) +var v25 any = v29 +_ = v25 v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) +v32 := v31.FindInternedVar(lang.NewSymbol("first")) if v32.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +v34 := lang.Apply(v33, []any{v25}) +var v30 any = v34 +_ = v30 +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("next")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) } -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v35}) +var v35 any = v39 +_ = v35 +var v40 any = v30 +_ = v40 +var v41 any = v35 +_ = v41 +var v42 any = v24 +_ = v42 +var v44 lang.FnFunc +v44 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("seq")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) } -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +v48 := v47.Get() +v49 := lang.Apply(v48, []any{v23}) +var v45 any = v49 +_ = v45 +var v51 any +if lang.IsTruthy(v45) { +var v52 any = v45 +_ = v52 +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("cons")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) } -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v5}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +v56 := v55.Get() +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("deref")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) } -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v15}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +v59 := v58.Get() +v60 := lang.Apply(v59, []any{v40}) +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("rest")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) } -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v16}) -v52 := lang.Apply(v39, []any{v43, v47, v51}) -v53 := lang.Apply(v36, []any{v52}) -v54 := lang.Apply(v33, []any{v53}) -v55 := lang.Apply(v22, []any{v26, v30, v54}) -v56 := lang.Apply(v19, []any{v55}) -return v56 +v63 := v62.Get() +v64 := lang.Apply(v63, []any{v52}) +v65 := lang.Apply(v21, []any{v41, v64}) +v66 := lang.Apply(v56, []any{v60, v65}) +v51 = v66 +} else { +v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v53 := v52.FindInternedVar(lang.NewSymbol("map")) +if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) +} +v54 := v53.Get() +v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v56 := v55.FindInternedVar(lang.NewSymbol("deref")) +if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) +} +v57 := v56.Get() +v58 := lang.Apply(v54, []any{v57, v42}) +v51 = v58 +} +return v51 }) -v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) -v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) +v45 := lang.Apply(lang1.NewLazySeq, []any{v44}) +return v45 +}) +v21 := v20 +_ = v21 +} +v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7085), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(7089), lang.NewKeyword("end-column"), int(36)) +v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) if err != nil { panic(err) } -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +var v19 any = v22 +_ = v19 +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("drop")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("concat")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v5, v11}) +v28 := lang.Apply(v19, []any{v11, v27}) +return v28 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +var v7 lang.FnFunc +{ // function step +v7 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v9 := args[0] +var v10 lang.FnFunc +v10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("map")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("seq")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } -v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v17 := v16.Get() +v18 := lang.Apply(v14, []any{v17, v9}) +var v11 any = v18 +_ = v11 +var v20 any +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("every?")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("identity")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.Apply(v23, []any{v26, v11}) +if lang.IsTruthy(v27) { +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("cons")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) +v32 := v31.FindInternedVar(lang.NewSymbol("map")) if v32.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } v33 := v32.Get() v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +v35 := v34.FindInternedVar(lang.NewSymbol("first")) if v35.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +v37 := lang.Apply(v33, []any{v36, v11}) +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("map")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) } -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v5}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("rest")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v2}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +v43 := v42.Get() +v44 := lang.Apply(v40, []any{v43, v11}) +v45 := lang.Apply(v8, []any{v44}) +v46 := lang.Apply(v30, []any{v37, v45}) +v20 = v46 +} else { +v20 = nil } -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v3}) -v52 := lang.Apply(v39, []any{v43, v47, v51}) -v53 := lang.Apply(v36, []any{v52}) -v54 := lang.Apply(v33, []any{v53}) -v55 := lang.Apply(v22, []any{v26, v30, v54}) -v56 := lang.Apply(v19, []any{v55}) -v57 := lang.Apply(v13, []any{v16, v56, v4}) -return v57 - } +return v20 }) -v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) -} -v5 := lang.Apply(v4, []any{v3, int64(1)}) -return v5 +v11 := lang.Apply(lang1.NewLazySeq, []any{v10}) +return v11 }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v0 := lang.NewSymbol("bit-xor").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Bitwise exclusive or", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1316), lang.NewKeyword("end-line"), int(1316))).(*lang.Symbol) -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v5 := args[0] -v6 := args[1] -v7, _ := lang.FieldOrMethod(lang1.Numbers, "xor") -if reflect.TypeOf(v7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("xor is not a function"))) +v8 := v7 +_ = v8 } -v8 := lang.Apply(v7, []any{v5, v6}) -return v8 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := args[0] -v6 := args[1] -v7 := lang.NewList(args[2:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7092), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(7096), lang.NewKeyword("end-column"), int(67)) +v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v10 := v9.Get() +var v6 any = v9 +_ = v6 v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("bit-xor")) +v12 := v11.FindInternedVar(lang.NewSymbol("pmap")) if v12.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("bit-xor")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v5, v6}) -v18 := lang.Apply(v10, []any{v13, v17, v7}) -return v18 - } -}) -v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v3 := ns.InternWithValue(v0, v4, true) -if v0.Meta() != nil { - v3.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// re-seq -{ -v0 := lang.NewSymbol("re-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("re"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns a lazy sequence of successive matches of pattern in string,\n using java.util.regex.Matcher.find(), each such match processed with\n re-groups.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4898), lang.NewKeyword("end-line"), int(4898))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("re-matcher")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v3, v4}) -var v5 any = v9 -_ = v5 -var v11 lang.FnFunc -{ // function step -v11 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { +var v14 lang.FnFunc +v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -var v13 any -v14, _ := lang.FieldOrMethod(v5, "find") -if reflect.TypeOf(v14).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("find is not a function"))) -} -v15 := lang.Apply(v14, []any{}) -if lang.IsTruthy(v15) { +v15 := args[0] v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("cons")) +v17 := v16.FindInternedVar(lang.NewSymbol("apply")) if v17.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } v18 := v17.Get() -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("re-groups")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v19 := lang.Apply(v18, []any{v3, v15}) +return v19 +}) +v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7097), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(7097), lang.NewKeyword("end-column"), int(23)) +v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v5}) -var v23 lang.FnFunc -v23 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("cons")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v4, v5}) +v21 := lang.Apply(v6, []any{v20}) +v22 := lang.Apply(v13, []any{v16, v21}) +return v22 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// pop +{ +v0 := lang.NewSymbol("pop").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "For a list or queue, returns a new list/queue without the first\n item, for a vector, returns a new vector without the last item. If\n the collection is empty, throws an exception. Note - not the same\n as next/butlast.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1462), lang.NewKeyword("end-line"), int(1462))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v24 := lang.Apply(v12, nil) -return v24 -}) -v24 := lang.Apply(lang1.NewLazySeq, []any{v23}) -v25 := lang.Apply(v18, []any{v22, v24}) -v13 = v25 -} else { -v13 = nil +v3 := args[0] +v4, _ := lang.FieldOrMethod(runtime9.RT, "Pop") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Pop is not a function"))) } -return v13 +v5 := lang.Apply(v4, []any{v3}) +return v5 }) -v12 := v11 -_ = v12 +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4906), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(4908), lang.NewKeyword("end-column"), int(49)) -v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) -if err != nil { - panic(err) } -v14 := lang.Apply(v13, nil) -return v14 +// pop! +{ +v0 := lang.NewSymbol("pop!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Removes the last item from a transient vector. If\n the collection is empty, throws an exception. Returns coll", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3393), lang.NewKeyword("end-line"), int(3393))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, ok := lang.FieldOrMethod(v3, "pop") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "pop"))) +} +var v5 any +switch reflect.TypeOf(v4).Kind() { +case reflect.Func: + v5 = lang.Apply(v4, nil) +default: + v5 = v4 +} +return v5 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -59598,22 +59515,16 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// remove-method +// pop-thread-bindings { -v0 := lang.NewSymbol("remove-method").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"), lang.NewSymbol("dispatch-val"))), lang.NewKeyword("doc"), "Removes the method of multimethod associated with dispatch-value.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1794), lang.NewKeyword("end-line"), int(1794))).(*lang.Symbol) +v0 := lang.NewSymbol("pop-thread-bindings").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Pop one set of bindings pushed with push-binding before. It is an error to\n pop bindings without pushing before.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1929), lang.NewKeyword("end-line"), int(1929))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { + if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := args[0] -v4 := args[1] -v5, _ := lang.FieldOrMethod(v3, "removeMethod") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("removeMethod is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 +v3 := lang.Apply(lang1.PopThreadBindings, nil) +return v3 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -59621,39 +59532,38 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// parse-boolean +// pos-int? { -v0 := lang.NewSymbol("parse-boolean").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse strings \"true\" or \"false\" and return a boolean, or nil if invalid", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(8000), lang.NewKeyword("end-line"), int(8000))).(*lang.Symbol) +v0 := lang.NewSymbol("pos-int?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a positive fixed precision integer", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1403), lang.NewKeyword("end-line"), int(1403))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -var v4 any v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("string?")) +v6 := v5.FindInternedVar(lang.NewSymbol("int?")) if v6.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } v7 := v6.Get() v8 := lang.Apply(v7, []any{v3}) -if lang.IsTruthy(v8) { -var v9 any = v3 -_ = v9 -v4 = nil -} else { -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("parsing-err")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +var v4 any = v8 +_ = v4 +var v10 any +if lang.IsTruthy(v4) { +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("pos?")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v3}) -v13 := lang.Apply(lang1.NewIllegalArgumentError, []any{v12}) -panic(v13) +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v3}) +v10 = v14 +} else { +v10 = v4 } -return v4 +return v10 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -59661,868 +59571,930 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// max +// pos? { var v1 lang.FnFunc +{ // function pos?__inliner v1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v2 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -if lang.IsTruthy(v7) { -v4 = closed14 -} else { -v4 = v3 -} -var v3 any = v4 -_ = v3 -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("seq")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("concat")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("seq")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("concat")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v2}) -v40 := lang.Apply(v31, []any{v35, v39}) -v41 := lang.Apply(v28, []any{v40}) -v42 := lang.Apply(v25, []any{v41}) -v43 := lang.Apply(v14, []any{v18, v22, v42}) -v44 := lang.Apply(v11, []any{v43}) -return v44 - case 2: -v2 := args[0] -v3 := args[1] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v8 := v7.Get() -if lang.IsTruthy(v8) { -v5 = closed14 -} else { -v5 = v4 +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -var v4 any = v5 -_ = v4 +v9 := v8.Get() v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("seq")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) if v11.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("concat")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("list")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v18 := v17.Get() -v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("list")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v22 := v21.Get() -v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v23 := v22.Get() v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("list")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) if v25.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } v26 := v25.Get() v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("seq")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("concat")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("list")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v4}) -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("list")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v2}) -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("list")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v3}) -v45 := lang.Apply(v32, []any{v36, v40, v44}) -v46 := lang.Apply(v29, []any{v45}) -v47 := lang.Apply(v26, []any{v46}) -v48 := lang.Apply(v15, []any{v19, v23, v47}) -v49 := lang.Apply(v12, []any{v48}) -return v49 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v2 := args[0] -v3 := args[1] -v4 := lang.NewList(args[2:]...) -var v6 any -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -if lang.IsTruthy(v9) { -v6 = closed14 -} else { -v6 = v5 -} -var v5 any = v6 -_ = v5 -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -var v14 lang.FnFunc -v14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v15 := args[0] -v16 := args[1] -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("concat")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v28 := v27.FindInternedVar(lang.NewSymbol("list")) if v28.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/isPos")}) v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v32 := v31.FindInternedVar(lang.NewSymbol("list")) if v32.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +v34 := lang.Apply(v33, []any{v3}) +v35 := lang.Apply(v26, []any{v30, v34}) +v36 := lang.Apply(v23, []any{v35}) +v37 := lang.Apply(v20, []any{v36}) +v38 := lang.Apply(v9, []any{v13, v17, v37}) +v39 := lang.Apply(v6, []any{v38}) +return v39 +}) +v2 := v1 +_ = v2 } -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +v0 := lang.NewSymbol("pos?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns true if num is greater than zero, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1252), lang.NewKeyword("end-line"), int(1252))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "isPos") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("isPos is not a function"))) } -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v5}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v15}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +// pr +{ +v0 := lang.NewSymbol("pr").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Prints the object(s) to the output stream that is the current value\n of *out*. Prints the object(s), separated by spaces if there is\n more than one. By default, pr and prn print in a way that objects\n can be read by the reader", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3678), lang.NewKeyword("end-line"), int(3678), lang.NewKeyword("dynamic"), true)).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +return nil + case 1: +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("pr-on")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v16}) -v52 := lang.Apply(v39, []any{v43, v47, v51}) -v53 := lang.Apply(v36, []any{v52}) -v54 := lang.Apply(v33, []any{v53}) -v55 := lang.Apply(v22, []any{v26, v30, v54}) -v56 := lang.Apply(v19, []any{v55}) -return v56 -}) -v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) -v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) -if err != nil { - panic(err) +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("*out*")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +v9 := v8.Get() +v10 := lang.Apply(v6, []any{v3, v9}) +return v10 + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.NewList(args[1:]...) +recur_loop_671: +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("pr")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("concat")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +_ = v8 +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("*out*")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -v22 := v21.Get() +v11 := v10.Get() +v12 := lang.Apply(lang1.AppendWriter, []any{v11, lang.NewChar(32)}) +_ = v12 +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("next")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v4}) +var v13 any = v17 +_ = v13 +var v19 any +if lang.IsTruthy(v13) { +var v20 any = v13 +_ = v20 v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) +v24 := v23.FindInternedVar(lang.NewSymbol("first")) if v24.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +v26 := lang.Apply(v25, []any{v4}) +var v22 any = v26 +var v27 any = v20 +v3 = v22 +v4 = v27 +goto recur_loop_671 +} else { +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("apply")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v5}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("pr")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v2}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +v25 := v24.Get() +v26 := lang.Apply(v22, []any{v25, v4}) +v19 = v26 } -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v3}) -v52 := lang.Apply(v39, []any{v43, v47, v51}) -v53 := lang.Apply(v36, []any{v52}) -v54 := lang.Apply(v33, []any{v53}) -v55 := lang.Apply(v22, []any{v26, v30, v54}) -v56 := lang.Apply(v19, []any{v55}) -v57 := lang.Apply(v13, []any{v16, v56, v4}) -return v57 +return v19 } }) -v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// pr-on +{ +v0 := lang.NewSymbol("pr-on").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("w"))), lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3669), lang.NewKeyword("end-line"), int(3669), lang.NewKeyword("private"), true)).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { + if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) +v4 := args[1] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("*print-dup*")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v5 := lang.Apply(v4, []any{v3, int64(1)}) -return v5 +v8 := v7.Get() +if lang.IsTruthy(v8) { +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("print-dup")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v3, v4}) +v5 = v12 +} else { +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("print-method")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v3, v4}) +v5 = v16 +} +_ = v5 +return nil }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v0 := lang.NewSymbol("max").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the greatest of the nums.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1108), lang.NewKeyword("end-line"), int(1108))).(*lang.Symbol) -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v5 := args[0] -return v5 - case 2: -v5 := args[0] -v6 := args[1] -v7, _ := lang.FieldOrMethod(lang1.Numbers, "max") -if reflect.TypeOf(v7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("max is not a function"))) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v8 := lang.Apply(v7, []any{v5, v6}) -return v8 +} +// pr-str +{ +v1 := reflect.TypeOf("") +v0 := lang.NewSymbol("pr-str").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("xs"))), lang.NewKeyword("doc"), "pr to a string, returning it", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4758), lang.NewKeyword("end-line"), int(4758))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { default: - if len(args) < 2 { + if len(args) < 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v5 := args[0] -v6 := args[1] -v7 := lang.NewList(args[2:]...) +v4 := lang.NewList(args[0:]...) +var v5 any = "unimplemented: new with non-constant class type" +_ = v5 v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) +v9 := v8.FindInternedVar(lang.NewSymbol("push-thread-bindings")) if v9.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } v10 := v9.Get() v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("max")) +v12 := v11.FindInternedVar(lang.NewSymbol("hash-map")) if v12.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("max")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v14 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*out*")) +v15 := lang.Apply(v13, []any{v14, v5}) +v16 := lang.Apply(v10, []any{v15}) +_ = v16 +var v17 any +func() { +defer func() { +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v5, v6}) -v18 := lang.Apply(v10, []any{v13, v17, v7}) -return v18 +v20 := v19.Get() +v21 := lang.Apply(v20, nil) +}() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("apply")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("pr")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.Apply(v24, []any{v27, v4}) +_ = v28 +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("str")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.Apply(v31, []any{v5}) +v17 = v32 +}() +return v17 } }) -v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v3 := ns.InternWithValue(v0, v4, true) +v4 := reflect.TypeOf("") +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { - v3.SetMeta(v0.Meta().(lang.IPersistentMap)) + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// *compiler-options* +// prefer-method { -v0 := lang.NewSymbol("*compiler-options*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.4", lang.NewKeyword("doc"), "A map of keys to options.\n Note, when binding dynamically make sure to merge with previous value.\n Supported options:\n :elide-meta - a collection of metadata keys to elide during compilation.\n :disable-locals-clearing - set to true to disable clearing, useful for using a debugger\n :direct-linking - set to true to use direct static invocation of functions, rather than vars\n Note that call sites compiled with direct linking will not be affected by var redefinition.\n Use ^:redef (or ^:dynamic) on a var to prevent direct linking and allow redefinition.\n See https://glojure.org/reference/compilation for more information.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, nil, true) +v0 := lang.NewSymbol("prefer-method").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"), lang.NewSymbol("dispatch-val-x"), lang.NewSymbol("dispatch-val-y"))), lang.NewKeyword("doc"), "Causes the multimethod to prefer matches of dispatch-val-x over dispatch-val-y \n when there is a conflict", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1801), lang.NewKeyword("end-line"), int(1801))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6, _ := lang.FieldOrMethod(v3, "PreferMethod") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("PreferMethod is not a function"))) +} +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// > +// prefers { -var v1 lang.FnFunc -{ // function >__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { +v0 := lang.NewSymbol("prefers").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"))), lang.NewKeyword("doc"), "Given a multimethod, returns a map of preferred value -> set of other values", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1822), lang.NewKeyword("end-line"), int(1822))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v4, ok := lang.FieldOrMethod(v3, "getPreferTable") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getPreferTable"))) } -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("concat")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +var v5 any +switch reflect.TypeOf(v4).Kind() { +case reflect.Func: + v5 = lang.Apply(v4, nil) +default: + v5 = v4 } -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("list")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v13 := v12.Get() -v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +// prep-hashes +{ +v0 := lang.NewSymbol("prep-hashes").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr-sym"), lang.NewSymbol("default"), lang.NewSymbol("tests"), lang.NewSymbol("thens"))), lang.NewKeyword("doc"), "Takes a sequence of test constants and a corresponding sequence of then\n expressions. Returns a tuple of [shift mask case-map switch-type skip-check]\n where case-map is a map of int case values to [test then] tuples, switch-type\n is either :sparse or :compact, and skip-check is a set of case ints for which\n post-switch equivalence checking must not be done (occurs with hash\n collisions).", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6726), lang.NewKeyword("end-line"), int(6726), lang.NewKeyword("private"), true)).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +var v8 lang.FnFunc +v8 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v9 := args[0] +v10 := lang.Apply(lang1.Hash, []any{v9}) +return v10 +}) +v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6734), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(6734), lang.NewKeyword("end-column"), int(66)) +v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("seq")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +var v7 any = v10 +_ = v7 +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("into1")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } -v24 := v23.Get() +v14 := v13.Get() +v15 := lang.CreatePersistentTreeSet() +v16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6735), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(6735), lang.NewKeyword("end-column"), int(25)) +v17, err := lang.WithMeta(v15, v16.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("map")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, []any{v7, v5}) +v22 := lang.Apply(v14, []any{v17, v21}) +var v11 any = v22 +_ = v11 +var v24 any v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("concat")) +v26 := v25.FindInternedVar(lang.NewSymbol("==")) if v26.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } v27 := v26.Get() v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("list")) +v29 := v28.FindInternedVar(lang.NewSymbol("count")) if v29.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } -v30 := v29.Get() -v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/gt")}) -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +v30 := v29.Get() +v31 := lang.Apply(v30, []any{v5}) +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("count")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v11}) +v36 := lang.Apply(v27, []any{v31, v35}) +if lang.IsTruthy(v36) { +var v37 any +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("fits-table?")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.Apply(v40, []any{v11}) +if lang.IsTruthy(v41) { +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("case-map")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +} +v44 := v43.Get() +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("identity")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +} +v47 := v46.Get() +v48 := lang.Apply(v44, []any{v7, v47, v5, v6}) +v49 := lang.NewVector(int64(0), int64(0), v48, lang.NewKeyword("compact")) +v50 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6739), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(6739), lang.NewKeyword("end-column"), int(63)) +v51, err := lang.WithMeta(v49, v50.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v37 = v51 +} else { +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("maybe-min-hash")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +} +v56 := v55.Get() +v57 := lang.Apply(v56, []any{v11}) +var v53 any = v57 +_ = v53 +var v59 any +if lang.IsTruthy(v53) { +v59 = v53 +} else { +v60 := lang.NewVector(int64(0), int64(0)) +v61 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6740), lang.NewKeyword("column"), int(56), lang.NewKeyword("end-line"), int(6740), lang.NewKeyword("end-column"), int(60)) +v62, err := lang.WithMeta(v60, v61.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v59 = v62 +} +var v52 any = v59 +_ = v52 +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("nth")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +} +v56 := v55.Get() +v57 := lang.Apply(v56, []any{v52, int64(0), nil}) +var v53 any = v57 +_ = v53 +v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v60 := v59.FindInternedVar(lang.NewSymbol("nth")) +if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) +} +v61 := v60.Get() +v62 := lang.Apply(v61, []any{v52, int64(1), nil}) +var v58 any = v62 +_ = v58 +var v64 any +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("zero?")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +} +v67 := v66.Get() +v68 := lang.Apply(v67, []any{v58}) +if lang.IsTruthy(v68) { +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("case-map")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +} +v71 := v70.Get() +v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v73 := v72.FindInternedVar(lang.NewSymbol("identity")) +if v73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) +} +v74 := v73.Get() +v75 := lang.Apply(v71, []any{v7, v74, v5, v6}) +v76 := lang.NewVector(int64(0), int64(0), v75, lang.NewKeyword("sparse")) +v77 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6743), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(6743), lang.NewKeyword("end-column"), int(66)) +v78, err := lang.WithMeta(v76, v77.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v64 = v78 +} else { +v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v80 := v79.FindInternedVar(lang.NewSymbol("case-map")) +if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) +} +v81 := v80.Get() +var v82 lang.FnFunc +v82 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v83 := args[0] +v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v85 := v84.FindInternedVar(lang.NewSymbol("shift-mask")) +if v85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) +} +v86 := v85.Get() +v87 := lang.Apply(v7, []any{v83}) +v88 := lang.Apply(v86, []any{v53, v58, v87}) +return v88 +}) +v83 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6745), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(6745), lang.NewKeyword("end-column"), int(71)) +v84, err := lang.WithMeta(v82, v83.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v86 := v85.FindInternedVar(lang.NewSymbol("identity")) +if v86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) +} +v87 := v86.Get() +v88 := lang.Apply(v81, []any{v84, v87, v5, v6}) +v89 := lang.NewVector(v53, v58, v88, lang.NewKeyword("compact")) +v90 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6745), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(6745), lang.NewKeyword("end-column"), int(103)) +v91, err := lang.WithMeta(v89, v90.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v64 = v91 +} +v37 = v64 +} +v24 = v37 +} else { +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("merge-hash-collisions")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +} +v55 := v54.Get() +v56 := lang.Apply(v55, []any{v3, v4, v5, v6}) +var v52 any = v56 +_ = v52 +v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v59 := v58.FindInternedVar(lang.NewSymbol("nth")) +if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) +} +v60 := v59.Get() +v61 := lang.Apply(v60, []any{v52, int64(0), nil}) +var v57 any = v61 +_ = v57 +v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v64 := v63.FindInternedVar(lang.NewSymbol("nth")) +if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) +} +v65 := v64.Get() +v66 := lang.Apply(v65, []any{v52, int64(1), nil}) +var v62 any = v66 +_ = v62 +v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v69 := v68.FindInternedVar(lang.NewSymbol("nth")) +if v69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) +} +v70 := v69.Get() +v71 := lang.Apply(v70, []any{v52, int64(2), nil}) +var v67 any = v71 +_ = v67 +v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v74 := v73.FindInternedVar(lang.NewSymbol("prep-hashes")) +if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) +} +v75 := v74.Get() +v76 := lang.Apply(v75, []any{v3, v4, v57, v62}) +var v72 any = v76 +_ = v72 +v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v79 := v78.FindInternedVar(lang.NewSymbol("nth")) +if v79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) +} +v80 := v79.Get() +v81 := lang.Apply(v80, []any{v72, int64(0), nil}) +var v77 any = v81 +_ = v77 +v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v84 := v83.FindInternedVar(lang.NewSymbol("nth")) +if v84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) } -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +v85 := v84.Get() +v86 := lang.Apply(v85, []any{v72, int64(1), nil}) +var v82 any = v86 +_ = v82 +v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v89 := v88.FindInternedVar(lang.NewSymbol("nth")) +if v89.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) } -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v4}) -v40 := lang.Apply(v27, []any{v31, v35, v39}) -v41 := lang.Apply(v24, []any{v40}) -v42 := lang.Apply(v21, []any{v41}) -v43 := lang.Apply(v10, []any{v14, v18, v42}) -v44 := lang.Apply(v7, []any{v43}) -return v44 -}) -v2 := v1 -_ = v2 +v90 := v89.Get() +v91 := lang.Apply(v90, []any{v72, int64(2), nil}) +var v87 any = v91 +_ = v87 +v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v94 := v93.FindInternedVar(lang.NewSymbol("nth")) +if v94.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) } -v0 := lang.NewSymbol(">").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns non-nil if nums are in monotonically decreasing order,\n otherwise false.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1063), lang.NewKeyword("end-line"), int(1063))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v4 := args[0] -return true - case 2: -v4 := args[0] -v5 := args[1] -v6, _ := lang.FieldOrMethod(lang1.Numbers, "gt") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("gt is not a function"))) +v95 := v94.Get() +v96 := lang.Apply(v95, []any{v72, int64(3), nil}) +var v92 any = v96 +_ = v92 +var v98 any +v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v100 := v99.FindInternedVar(lang.NewSymbol("zero?")) +if v100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) } -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6 := lang.NewList(args[2:]...) -recur_loop_198: -var v7 any -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol(">")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v101 := v100.Get() +v102 := lang.Apply(v101, []any{v82}) +if lang.IsTruthy(v102) { +v98 = v97 +} else { +v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v104 := v103.FindInternedVar(lang.NewSymbol("into1")) +if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) } -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v4, v5}) -if lang.IsTruthy(v11) { -var v12 any -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("next")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +v105 := v104.Get() +v106 := lang.CreatePersistentTreeSet() +v107 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6751), lang.NewKeyword("column"), int(33), lang.NewKeyword("end-line"), int(6751), lang.NewKeyword("end-column"), int(35)) +v108, err := lang.WithMeta(v106, v107.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v6}) -if lang.IsTruthy(v16) { -var v17 any = v5 -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("first")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v110 := v109.FindInternedVar(lang.NewSymbol("map")) +if v110.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) } -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v6}) -var v18 any = v22 -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("next")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +v111 := v110.Get() +var v112 lang.FnFunc +v112 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v113 := args[0] +v114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v115 := v114.FindInternedVar(lang.NewSymbol("shift-mask")) +if v115.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v115))) } -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v6}) -var v23 any = v27 -v4 = v17 -v5 = v18 -v6 = v23 -goto recur_loop_198 -} else { -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol(">")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +v116 := v115.Get() +v117 := lang.Apply(v116, []any{v77, v82, v113}) +return v117 +}) +v113 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6751), lang.NewKeyword("column"), int(42), lang.NewKeyword("end-line"), int(6751), lang.NewKeyword("end-column"), int(67)) +v114, err := lang.WithMeta(v112, v113.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("first")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v115 := lang.Apply(v111, []any{v114, v97}) +v116 := lang.Apply(v105, []any{v108, v115}) +v98 = v116 } -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v6}) -v35 := lang.Apply(v30, []any{v5, v34}) -v12 = v35 +var v97 any = v98 +_ = v97 +v118 := lang.NewVector(v77, v82, v87, v92, v97) +v119 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6752), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(6752), lang.NewKeyword("end-column"), int(52)) +v120, err := lang.WithMeta(v118, v119.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v7 = v12 -} else { -v7 = false +v24 = v120 } -return v7 - } +return v24 }) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// aset-float +// prep-ints { -v0 := lang.NewSymbol("aset-float").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of float. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3961), lang.NewKeyword("end-line"), int(3963))).(*lang.Symbol) +v0 := lang.NewSymbol("prep-ints").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tests"), lang.NewSymbol("thens"))), lang.NewKeyword("doc"), "Takes a sequence of int-sized test constants and a corresponding sequence of\n then expressions. Returns a tuple of [shift mask case-map switch-type] where\n case-map is a map of int case values to [test then] tuples, and switch-type\n is either :sparse or :compact.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6674), lang.NewKeyword("end-line"), int(6674), lang.NewKeyword("private"), true)).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 3: + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] v4 := args[1] -v5 := args[2] +var v5 any v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("float")) +v7 := v6.FindInternedVar(lang.NewSymbol("fits-table?")) if v7.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } v8 := v7.Get() -v9 := lang.Apply(v8, []any{v5}) -v10, _ := lang.FieldOrMethod(nil, "setFloat") -if reflect.TypeOf(v10).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setFloat is not a function"))) -} -v11 := lang.Apply(v10, []any{v3, v4, v9}) -_ = v11 -return v5 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("apply")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() +v9 := lang.Apply(v8, []any{v3}) +if lang.IsTruthy(v9) { v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("aset-float")) +v11 := v10.FindInternedVar(lang.NewSymbol("case-map")) if v11.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } v12 := v11.Get() v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("aget")) +v14 := v13.FindInternedVar(lang.NewSymbol("int")) if v14.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } v15 := v14.Get() -v16 := lang.Apply(v15, []any{v3, v4}) -v17 := lang.Apply(v9, []any{v12, v16, v5, v6}) -return v17 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// defmethod -{ -v0 := lang.NewSymbol("defmethod").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"), lang.NewSymbol("dispatch-val"), lang.NewSymbol("&"), lang.NewSymbol("fn-tail"))), lang.NewKeyword("doc"), "Creates and installs a new method of multimethod associated with dispatch-value. ", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1781), lang.NewKeyword("end-line"), int(1781))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := lang.NewList(args[4:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("seq")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("int")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("concat")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v18 := v17.Get() +v19 := lang.Apply(v12, []any{v15, v18, v3, v4}) +v20 := lang.NewVector(int64(0), int64(0), v19, lang.NewKeyword("compact")) +v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6682), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(6682), lang.NewKeyword("end-column"), int(49)) +v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v5 = v22 +} else { +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("maybe-min-hash")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol(".")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("map")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("with-meta")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("int")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -v23 := v22.Get() -v24 := lang.NewMap(lang.NewKeyword("tag"), lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.*MultiFn")) -v25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1785), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(1785), lang.NewKeyword("end-column"), int(82)) -v26, err := lang.WithMeta(v24, v25.(lang.IPersistentMap)) +v33 := v32.Get() +v34 := lang.Apply(v30, []any{v33, v3}) +v35 := lang.Apply(v27, []any{v34}) +var v24 any = v35 +_ = v24 +var v37 any +if lang.IsTruthy(v24) { +v37 = v24 +} else { +v38 := lang.NewVector(int64(0), int64(0)) +v39 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6683), lang.NewKeyword("column"), int(61), lang.NewKeyword("end-line"), int(6683), lang.NewKeyword("end-column"), int(65)) +v40, err := lang.WithMeta(v38, v39.(lang.IPersistentMap)) if err != nil { panic(err) } -v27 := lang.Apply(v23, []any{v5, v26}) -v28 := lang.Apply(v20, []any{v27}) -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("list")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +v37 = v40 } -v31 := v30.Get() -v32 := lang.Apply(v31, []any{lang.NewSymbol("glojure.core/AddMethod")}) -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("list")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +var v23 any = v37 +_ = v23 +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("nth")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v6}) -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("list")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +v27 := v26.Get() +v28 := lang.Apply(v27, []any{v23, int64(0), nil}) +var v24 any = v28 +_ = v24 +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("nth")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) } -v39 := v38.Get() +v32 := v31.Get() +v33 := lang.Apply(v32, []any{v23, int64(1), nil}) +var v29 any = v33 +_ = v29 +var v35 any +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("zero?")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v29}) +if lang.IsTruthy(v39) { v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("seq")) +v41 := v40.FindInternedVar(lang.NewSymbol("case-map")) if v41.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) } v42 := v41.Get() v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("concat")) +v44 := v43.FindInternedVar(lang.NewSymbol("int")) if v44.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) } v45 := v44.Get() v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("list")) +v47 := v46.FindInternedVar(lang.NewSymbol("int")) if v47.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) } v48 := v47.Get() -v49 := lang.Apply(v48, []any{lang.NewSymbol("glojure.core/fn")}) -v50 := lang.Apply(v45, []any{v49, v7}) -v51 := lang.Apply(v42, []any{v50}) -v52 := lang.Apply(v39, []any{v51}) -v53 := lang.Apply(v13, []any{v17, v28, v32, v36, v52}) -v54 := lang.Apply(v10, []any{v53}) -return v54 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// elide-top-frames -{ -v0 := lang.NewSymbol("elide-top-frames").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4794), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(4794), lang.NewKeyword("end-column"), int(32), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ex"), lang.NewSymbol("class-name"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v6, ok := lang.FieldOrMethod(v3, "getStackTrace") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getStackTrace"))) -} -var v7 any -switch reflect.TypeOf(v6).Kind() { -case reflect.Func: - v7 = lang.Apply(v6, nil) -default: - v7 = v6 -} -var v5 any = v7 -_ = v5 -var v9 any = v3 -_ = v9 -var v11 any -if lang.IsTruthy(v5) { -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("into-array")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +v49 := lang.Apply(v42, []any{v45, v48, v3, v4}) +v50 := lang.NewVector(int64(0), int64(0), v49, lang.NewKeyword("sparse")) +v51 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6686), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(6686), lang.NewKeyword("end-column"), int(52)) +v52, err := lang.WithMeta(v50, v51.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("drop-while")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +v35 = v52 +} else { +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("case-map")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) } -v17 := v16.Get() -var v18 lang.FnFunc -v18 = lang.NewFnFunc(func(args ...any) any { +v55 := v54.Get() +var v56 lang.FnFunc +v56 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v19 := args[0] -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("=")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23, ok := lang.FieldOrMethod(v19, "getClassName") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v19, "getClassName"))) +v57 := args[0] +v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v59 := v58.FindInternedVar(lang.NewSymbol("shift-mask")) +if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) } -var v24 any -switch reflect.TypeOf(v23).Kind() { -case reflect.Func: - v24 = lang.Apply(v23, nil) -default: - v24 = v23 +v60 := v59.Get() +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("int")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) } -v25 := lang.Apply(v22, []any{v4, v24}) -return v25 +v63 := v62.Get() +v64 := lang.Apply(v63, []any{v57}) +v65 := lang.Apply(v60, []any{v24, v29, v64}) +return v65 }) -v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4801), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(4801), lang.NewKeyword("end-column"), int(77)) -v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) +v57 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6688), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(6688), lang.NewKeyword("end-column"), int(62)) +v58, err := lang.WithMeta(v56, v57.(lang.IPersistentMap)) if err != nil { panic(err) } -v21 := lang.Apply(v17, []any{v20, v5}) -v22 := lang.Apply(v14, []any{nil, v21}) -v11 = v22 -} else { -v11 = nil +v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v60 := v59.FindInternedVar(lang.NewSymbol("int")) +if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) } -v23, _ := lang.FieldOrMethod(v9, "setStackTrace") -if reflect.TypeOf(v23).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setStackTrace is not a function"))) +v61 := v60.Get() +v62 := lang.Apply(v55, []any{v58, v61, v3, v4}) +v63 := lang.NewVector(v24, v29, v62, lang.NewKeyword("compact")) +v64 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6688), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(6688), lang.NewKeyword("end-column"), int(89)) +v65, err := lang.WithMeta(v63, v64.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v24 := lang.Apply(v23, []any{v11}) -_ = v24 -return v9 +v35 = v65 +} +v5 = v35 +} +return v5 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -60530,20 +60502,44 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// sorted-map +// prependss { -v0 := lang.NewSymbol("sorted-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keyvals"))), lang.NewKeyword("doc"), "keyval => key val\n Returns a new sorted map with supplied mappings. If any keys are\n equal, they are handled as if by repeated uses of assoc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(397), lang.NewKeyword("end-line"), int(397))).(*lang.Symbol) +v0 := lang.NewSymbol("prependss").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Prepends a symbol or a seq to coll", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5900), lang.NewKeyword("end-line"), int(5900), lang.NewKeyword("private"), true)).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewList(args[0:]...) -v4 := lang.Apply(lang1.CreatePersistentTreeMap, []any{v3}) -return v4 + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } +v3 := args[0] +v4 := args[1] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("symbol?")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v3}) +if lang.IsTruthy(v9) { +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("cons")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{v3, v4}) +v5 = v13 +} else { +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("concat")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v3, v4}) +v5 = v17 +} +return v5 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -60551,158 +60547,114 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// reductions +// preserving-reduced { -v0 := lang.NewSymbol("reductions").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy seq of the intermediate values of the reduction (as\n per reduce) of coll by f, starting with init.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7239), lang.NewKeyword("end-line"), int(7239))).(*lang.Symbol) +v0 := lang.NewSymbol("preserving-reduced").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7681), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(7681), lang.NewKeyword("end-column"), int(34), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rf"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] -v4 := args[1] -var v5 lang.FnFunc -v5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("seq")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v5 := args[0] +v6 := args[1] +v8 := lang.Apply(v3, []any{v5, v6}) +var v7 any = v8 +_ = v7 +var v10 any +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("reduced?")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v4}) -var v6 any = v10 -_ = v6 -var v12 any -if lang.IsTruthy(v6) { -var v13 any = v6 -_ = v13 +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v7}) +if lang.IsTruthy(v14) { v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("reductions")) +v16 := v15.FindInternedVar(lang.NewSymbol("reduced")) if v16.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } v17 := v16.Get() -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("first")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v20, []any{v13}) -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("rest")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v13}) -v26 := lang.Apply(v17, []any{v3, v21, v25}) -v12 = v26 +v18 := lang.Apply(v17, []any{v7}) +v10 = v18 } else { -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("list")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v3, nil) -v17 := lang.Apply(v15, []any{v16}) -v12 = v17 +v10 = v7 } -return v12 +return v10 }) -v6 := lang.Apply(lang1.NewLazySeq, []any{v5}) +v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7683), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(7686), lang.NewKeyword("end-column"), int(12)) +v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) +if err != nil { + panic(err) +} return v6 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -var v6 any -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("reduced?")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v4}) -if lang.IsTruthy(v10) { -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("list")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("deref")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +// print +{ +v0 := lang.NewSymbol("print").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Prints the object(s) to the output stream that is the current value\n of *out*. print and println produce output for human consumption.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3725), lang.NewKeyword("end-line"), int(3725))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.NewList(args[0:]...) +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("push-thread-bindings")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v4}) -v18 := lang.Apply(v13, []any{v17}) -v6 = v18 -} else { +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("hash-map")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*print-readably*")) +v12 := lang.Apply(v10, []any{v11, nil}) +v13 := lang.Apply(v7, []any{v12}) +_ = v13 +var v14 any +func() { +defer func() { +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, nil) +}() v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("cons")) +v20 := v19.FindInternedVar(lang.NewSymbol("apply")) if v20.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } v21 := v20.Get() -var v22 lang.FnFunc -v22 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("seq")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v5}) -var v23 any = v27 -_ = v23 -var v29 any -if lang.IsTruthy(v23) { -var v30 any = v23 -_ = v30 -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("reductions")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("first")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v30}) -v39 := lang.Apply(v3, []any{v4, v38}) -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("rest")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v30}) -v44 := lang.Apply(v34, []any{v3, v39, v43}) -v29 = v44 -} else { -v29 = nil -} -return v29 -}) -v23 := lang.Apply(lang1.NewLazySeq, []any{v22}) -v24 := lang.Apply(v21, []any{v4, v23}) -v6 = v24 +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("pr")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -return v6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) +v24 := v23.Get() +v25 := lang.Apply(v21, []any{v24, v3}) +v14 = v25 +}() +return v14 } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -60711,29 +60663,45 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// reverse +// print-ctor { -v0 := lang.NewSymbol("reverse").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a seq of the items in coll in reverse order. Not lazy.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(940), lang.NewKeyword("end-line"), int(940))).(*lang.Symbol) +v0 := lang.NewSymbol("print-ctor").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(95), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(95), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("print-args"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { + if len(args) != 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("reduce1")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() +v4 := args[1] +v5 := args[2] +v6 := lang.Apply(lang1.WriteWriter, []any{v5, "#=("}) +_ = v6 v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("conj")) +v8 := v7.FindInternedVar(lang.NewSymbol("class")) if v8.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } v9 := v8.Get() -v10 := lang.Apply(v6, []any{v9, lang.NewList(), v3}) -return v10 +v10 := lang.Apply(v9, []any{v3}) +v11, ok := lang.FieldOrMethod(v10, "Name") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v10, "Name"))) +} +var v12 any +switch reflect.TypeOf(v11).Kind() { +case reflect.Func: + v12 = lang.Apply(v11, nil) +default: + v12 = v11 +} +v13 := lang.Apply(lang1.WriteWriter, []any{v5, v12}) +_ = v13 +v14 := lang.Apply(lang1.WriteWriter, []any{v5, ". "}) +_ = v14 +v15 := lang.Apply(v4, []any{v3, v5}) +_ = v15 +v16 := lang.Apply(lang1.WriteWriter, []any{v5, ")"}) +return v16 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -60741,27 +60709,41 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// ref-history-count +// print-dup { -v0 := lang.NewSymbol("ref-history-count").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref"))), lang.NewKeyword("doc"), "Returns the history count of a ref", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2455), lang.NewKeyword("end-line"), int(2455))).(*lang.Symbol) +v0 := lang.NewSymbol("print-dup").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3667), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(3667), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, nil, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// print-initialized +{ +v0 := lang.NewSymbol("print-initialized").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(520), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(520), lang.NewKeyword("end-column"), int(39), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, true, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// print-map +{ +v0 := lang.NewSymbol("print-map").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(252), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(252), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("print-one"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { + if len(args) != 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4, ok := lang.FieldOrMethod(v3, "getHistoryCount") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getHistoryCount"))) -} -var v5 any -switch reflect.TypeOf(v4).Kind() { -case reflect.Func: - v5 = lang.Apply(v4, nil) -default: - v5 = v4 +v4 := args[1] +v5 := args[2] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("print-prefix-map")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -return v5 +v8 := v7.Get() +v9 := lang.Apply(v8, []any{nil, v3, v4, v5}) +return v9 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -60769,147 +60751,144 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// *file* -{ -v0 := lang.NewSymbol("*file*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "The path of the file being evaluated, as a String.\n\n When there is no file, e.g. in the REPL, the value is not defined.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, "NO_SOURCE_FILE", true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// make-array +// print-meta { -v0 := lang.NewSymbol("make-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("type"), lang.NewSymbol("len")), lang.NewVector(lang.NewSymbol("type"), lang.NewSymbol("dim"), lang.NewSymbol("&"), lang.NewSymbol("more-dims"))), lang.NewKeyword("doc"), "Creates and returns an array of instances of the specified class of\n the specified dimension(s). Note that a class object is required.\n Class objects can be obtained by using their imported or\n fully-qualified name. Class objects for the primitive types can be\n obtained using, e.g., Integer/TYPE.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3985), lang.NewKeyword("end-line"), int(3985))).(*lang.Symbol) +v0 := lang.NewSymbol("print-meta").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(70), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(70), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("int")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("meta")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v4}) -v9, _ := lang.FieldOrMethod(nil, "newInstance") -if reflect.TypeOf(v9).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("newInstance is not a function"))) +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v3}) +var v5 any = v9 +_ = v5 +var v11 any +if lang.IsTruthy(v5) { +var v12 any = v5 +_ = v12 +var v14 any +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("pos?")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -v10 := lang.Apply(v9, []any{v3, v8}) -return v10 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("cons")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v18 := v17.Get() +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("count")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v4, v5}) -var v6 any = v10 -_ = v6 -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("make-array")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v12}) +v23 := lang.Apply(v18, []any{v22}) +var v15 any = v23 +_ = v15 +var v25 any +if lang.IsTruthy(v15) { +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("*print-dup*")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v14 := v13.Get() -v15, ok := lang.FieldOrMethod(nil, "TYPE") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "TYPE"))) +v29 := v28.Get() +var v26 any = v29 +_ = v26 +var v31 any +if lang.IsTruthy(v26) { +v31 = v26 +} else { +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("*print-meta*")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) } -var v16 any -switch reflect.TypeOf(v15).Kind() { -case reflect.Func: - v16 = lang.Apply(v15, nil) -default: - v16 = v15 +v35 := v34.Get() +var v32 any = v35 +_ = v32 +var v37 any +if lang.IsTruthy(v32) { +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("*print-readably*")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) } -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("count")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +v40 := v39.Get() +v37 = v40 +} else { +v37 = v32 } -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v6}) -v21 := lang.Apply(v14, []any{v16, v20}) -var v11 any = v21 -_ = v11 -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("long")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +v31 = v37 } -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("alength")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v25 = v31 +} else { +v25 = v15 } -v29 := v28.Get() -v30 := lang.Apply(v29, []any{v11}) -v31 := lang.Apply(v26, []any{v30}) -var v23 any = v31 -_ = v23 -var v33 any = int64(0) -_ = v33 -var v34 any -for { -var v35 any -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("<")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +if lang.IsTruthy(v25) { +v15 := lang.Apply(lang1.WriteWriter, []any{v4, "^"}) +_ = v15 +var v16 any +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("=")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v33, v23}) -if lang.IsTruthy(v39) { -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("aset-int")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("count")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v42 := v41.Get() -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("nth")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v12}) +v25 := lang.Apply(v20, []any{v24, int64(1)}) +var v17 any = v25 +_ = v17 +var v27 any +if lang.IsTruthy(v17) { +v28 := lang.Apply(lang.NewKeyword("tag"), []any{v12}) +v27 = v28 +} else { +v27 = v17 } -v45 := v44.Get() -v46 := lang.Apply(v45, []any{v6, v33}) -v47 := lang.Apply(v42, []any{v11, v33, v46}) -_ = v47 -v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v50 := v49.FindInternedVar(lang.NewSymbol("unchecked-inc")) -if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) +if lang.IsTruthy(v27) { +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("pr-on")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v51 := v50.Get() -v52 := lang.Apply(v51, []any{v33}) -var v48 any = v52 -v33 = v48 -continue +v19 := v18.Get() +v20 := lang.Apply(lang.NewKeyword("tag"), []any{v12}) +v21 := lang.Apply(v19, []any{v20, v4}) +v16 = v21 } else { -v35 = nil +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("pr-on")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -v34 = v35 - break +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v12, v4}) +v16 = v25 } -_ = v34 -v23, _ := lang.FieldOrMethod(nil, "newInstance") -if reflect.TypeOf(v23).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("newInstance is not a function"))) +_ = v16 +v26 := lang.Apply(lang1.WriteWriter, []any{v4, " "}) +v14 = v26 +} else { +v14 = nil } -v24 := lang.Apply(v23, []any{v3, v11}) -return v24 - } +v11 = v14 +} else { +v11 = nil +} +return v11 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -60917,226 +60896,508 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// re-pattern +// print-method { -v1 := reflect.TypeOf((*regexp30.Regexp)(nil)) -v0 := lang.NewSymbol("re-pattern").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns an instance of java.util.regex.Pattern, for use, e.g. in\n re-matcher.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4863), lang.NewKeyword("end-line"), int(4863))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { +v0 := lang.NewSymbol("print-method").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3664), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(3664), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, nil, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// print-object +{ +v0 := lang.NewSymbol("print-object").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(115), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(115), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v4 := args[0] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("print-tagged-object")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v8 := v7.Get() -v9 := lang.Apply(v8, []any{regexp30.*Regexp, v4}) -if lang.IsTruthy(v9) { -v5 = v4 -} else { -v10 := lang.Apply(regexp30.MustCompile, []any{v4}) -v5 = v10 +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("str")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -return v5 +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v3}) +v12 := lang.Apply(v7, []any{v3, v11, v4}) +return v12 }) -v4 := reflect.TypeOf((*regexp30.Regexp)(nil)) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// into +// print-prefix-map { -v0 := lang.NewSymbol("into").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("to")), lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("from")), lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("xform"), lang.NewSymbol("from"))), lang.NewKeyword("doc"), "Returns a new coll consisting of to with all of the items of\n from conjoined. A transducer may be supplied.\n (into x) returns x. (into) returns [].", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6965), lang.NewKeyword("end-line"), int(6965))).(*lang.Symbol) +v0 := lang.NewSymbol("print-prefix-map").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(243), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(243), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("prefix"), lang.NewSymbol("kvs"), lang.NewSymbol("print-one"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v3 := lang.NewVector() -v4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6971), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(6971), lang.NewKeyword("end-column"), int(8)) -v5, err := lang.WithMeta(v3, v4.(lang.IPersistentMap)) + if len(args) != 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("print-sequential")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("str")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{v3, "{"}) +var v14 lang.FnFunc +v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v15 := args[0] +v16 := args[1] +var v17 any = v15 +_ = v17 +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("nth")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v17, int64(0), nil}) +var v18 any = v22 +_ = v18 +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("nth")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v17, int64(1), nil}) +var v23 any = v27 +_ = v23 +v29 := lang.Apply(v5, []any{v18, v16}) +_ = v29 +v30 := lang.Apply(lang1.AppendWriter, []any{v16, lang.NewChar(32)}) +_ = v30 +v31 := lang.Apply(v5, []any{v23, v16}) +return v31 +}) +v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(246), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(247), lang.NewKeyword("end-column"), int(107)) +v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) if err != nil { panic(err) } -return v5 - case 1: -v3 := args[0] -return v3 - case 2: +v17 := lang.Apply(v9, []any{v13, v16, ", ", "}", v4, v6}) +return v17 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// print-sequential +{ +v0 := lang.NewSymbol("print-sequential").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(46), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(46), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("begin"), lang.NewSymbol("print-one"), lang.NewSymbol("sep"), lang.NewSymbol("end"), lang.NewSymbol("sequence"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 6 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] v4 := args[1] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{lang1.IEditableCollection, v3}) -if lang.IsTruthy(v9) { +v5 := args[2] +v6 := args[3] +v7 := args[4] +v8 := args[5] v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("with-meta")) +v11 := v10.FindInternedVar(lang.NewSymbol("push-thread-bindings")) if v11.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } v12 := v11.Get() v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("persistent!")) +v14 := v13.FindInternedVar(lang.NewSymbol("hash-map")) if v14.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("reduce")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("conj!")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v16 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*print-level*")) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("not")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("transient")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("*print-dup*")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v26 := lang.Apply(v18, []any{v21, v25, v4}) -v27 := lang.Apply(v15, []any{v26}) +v23 := v22.Get() +v24 := lang.Apply(v20, []any{v23}) +var v17 any = v24 +_ = v17 +var v26 any +if lang.IsTruthy(v17) { v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("meta")) +v29 := v28.FindInternedVar(lang.NewSymbol("*print-level*")) if v29.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } v30 := v29.Get() -v31 := lang.Apply(v30, []any{v3}) -v32 := lang.Apply(v12, []any{v27, v31}) -v5 = v32 -} else { +var v27 any = v30 +_ = v27 +var v32 any +if lang.IsTruthy(v27) { v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("reduce")) +v34 := v33.FindInternedVar(lang.NewSymbol("dec")) if v34.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) } v35 := v34.Get() v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("conj")) +v37 := v36.FindInternedVar(lang.NewSymbol("*print-level*")) if v37.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) } v38 := v37.Get() -v39 := lang.Apply(v35, []any{v38, v3, v4}) -v5 = v39 +v39 := lang.Apply(v35, []any{v38}) +v32 = v39 +} else { +v32 = v27 } -return v5 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -var v6 any -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("instance?")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v26 = v32 +} else { +v26 = v17 +} +v17 := lang.Apply(v15, []any{v16, v26}) +v18 := lang.Apply(v12, []any{v17}) +_ = v18 +var v19 any +func() { +defer func() { +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.Apply(v22, nil) +}() +var v24 any +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("*print-level*")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +var v25 any = v28 +_ = v25 +var v30 any +if lang.IsTruthy(v25) { +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("neg?")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("*print-level*")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.Apply(v33, []any{v36}) +v30 = v37 +} else { +v30 = v25 +} +if lang.IsTruthy(v30) { +v25 := lang.Apply(lang1.WriteWriter, []any{v8, "#"}) +v24 = v25 +} else { +v26 := lang.Apply(lang1.WriteWriter, []any{v8, v3}) +_ = v26 +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("seq")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{v7}) +var v27 any = v31 +_ = v27 +var v33 any +if lang.IsTruthy(v27) { +var v34 any = v27 +_ = v34 +var v36 any +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("not")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("*print-dup*")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v40, []any{v43}) +var v37 any = v44 +_ = v37 +var v46 any +if lang.IsTruthy(v37) { +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("*print-length*")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +} +v49 := v48.Get() +v46 = v49 +} else { +v46 = v37 +} +if lang.IsTruthy(v46) { +var v37 any = v34 +_ = v37 +var v38 any = v37 +_ = v38 +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("seq")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v38}) +var v39 any = v43 +_ = v39 +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("first")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +} +v47 := v46.Get() +v48 := lang.Apply(v47, []any{v39}) +var v44 any = v48 +_ = v44 +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("next")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +} +v52 := v51.Get() +v53 := lang.Apply(v52, []any{v49}) +var v49 any = v53 +_ = v49 +var v54 any = v44 +_ = v54 +var v55 any = v49 +_ = v55 +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("*print-length*")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +} +v59 := v58.Get() +var v56 any = v59 +_ = v56 +var v61 any = v61 +_ = v61 +var v62 any = v62 +_ = v62 +var v63 any +for { +var v64 any = v61 +_ = v64 +v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v67 := v66.FindInternedVar(lang.NewSymbol("seq")) +if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) +} +v68 := v67.Get() +v69 := lang.Apply(v68, []any{v64}) +var v65 any = v69 +_ = v65 +v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v72 := v71.FindInternedVar(lang.NewSymbol("first")) +if v72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) +} +v73 := v72.Get() +v74 := lang.Apply(v73, []any{v65}) +var v70 any = v74 +_ = v70 +v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v77 := v76.FindInternedVar(lang.NewSymbol("next")) +if v77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) +} +v78 := v77.Get() +v79 := lang.Apply(v78, []any{v75}) +var v75 any = v79 +_ = v75 +var v80 any = v70 +_ = v80 +var v81 any = v75 +_ = v81 +var v82 any = v82 +_ = v82 +var v84 any +v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v86 := v85.FindInternedVar(lang.NewSymbol("zero?")) +if v86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) +} +v87 := v86.Get() +v88 := lang.Apply(v87, []any{v82}) +if lang.IsTruthy(v88) { +v89 := lang.Apply(lang1.WriteWriter, []any{v8, "..."}) +v84 = v89 +} else { +v90 := lang.Apply(v4, []any{v80, v8}) +_ = v90 +var v91 any +if lang.IsTruthy(v81) { +v92 := lang.Apply(lang1.WriteWriter, []any{v8, v5}) +_ = v92 +var v93 any = v81 +v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v96 := v95.FindInternedVar(lang.NewSymbol("dec")) +if v96.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) +} +v97 := v96.Get() +v98 := lang.Apply(v97, []any{v82}) +var v94 any = v98 +v61 = v93 +v62 = v94 +continue +} else { +v91 = nil +} +v84 = v91 +} +v63 = v84 + break +} +v36 = v63 +} else { +var v37 any = v34 +_ = v37 +var v38 any = v37 +_ = v38 +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("seq")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v38}) +var v39 any = v43 +_ = v39 +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("first")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) } -v9 := v8.Get() -v10 := lang.Apply(v9, []any{lang1.IEditableCollection, v3}) -if lang.IsTruthy(v10) { -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("meta")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +v47 := v46.Get() +v48 := lang.Apply(v47, []any{v39}) +var v44 any = v48 +_ = v44 +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("next")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) } -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v3}) -var v11 any = v15 -_ = v11 -var v17 lang.FnFunc -v17 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v18 := args[0] -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("with-meta")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v52 := v51.Get() +v53 := lang.Apply(v52, []any{v49}) +var v49 any = v53 +_ = v49 +var v54 any = v44 +_ = v54 +var v55 any = v49 +_ = v55 +var v57 any = v57 +_ = v57 +var v58 any +for { +var v59 any = v57 +_ = v59 +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("seq")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) } -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("persistent!")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v63 := v62.Get() +v64 := lang.Apply(v63, []any{v59}) +var v60 any = v64 +_ = v60 +v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v67 := v66.FindInternedVar(lang.NewSymbol("first")) +if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) } -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v18}) -v26 := lang.Apply(v21, []any{v25, v11}) -return v26 - case 2: -v18 := args[0] -v19 := args[1] -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("conj!")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +v68 := v67.Get() +v69 := lang.Apply(v68, []any{v60}) +var v65 any = v69 +_ = v65 +v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v72 := v71.FindInternedVar(lang.NewSymbol("next")) +if v72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) } -v22 := v21.Get() -v23 := lang.Apply(v22, []any{v18, v19}) -return v23 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6980), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(6982), lang.NewKeyword("end-column"), int(44)) -v19, err := lang.WithMeta(v17, v18.(lang.IPersistentMap)) -if err != nil { - panic(err) +v73 := v72.Get() +v74 := lang.Apply(v73, []any{v70}) +var v70 any = v74 +_ = v70 +var v75 any = v65 +_ = v75 +var v76 any = v70 +_ = v76 +v78 := lang.Apply(v4, []any{v75, v8}) +_ = v78 +var v79 any +if lang.IsTruthy(v76) { +v80 := lang.Apply(lang1.WriteWriter, []any{v8, v5}) +_ = v80 +var v81 any = v76 +v57 = v81 +continue +} else { +v79 = nil } -var v16 any = v19 -_ = v16 -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("transduce")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +v58 = v79 + break } -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("transient")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +v36 = v58 } -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v3}) -v28 := lang.Apply(v23, []any{v4, v16, v27, v5}) -v6 = v28 +v33 = v36 } else { -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("transduce")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("conj")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v33 = nil } -v16 := v15.Get() -v17 := lang.Apply(v13, []any{v4, v16, v3, v5}) -v6 = v17 +_ = v33 +v27 := lang.Apply(lang1.WriteWriter, []any{v8, v6}) +v24 = v27 } -return v6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } +v19 = v24 +}() +return v19 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -61144,998 +61405,859 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// list* +// print-simple { -v0 := lang.NewSymbol("list*").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Creates a new seq containing the items prepended to the rest, the\n last of which will be treated as a sequence.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(641), lang.NewKeyword("end-line"), int(641))).(*lang.Symbol) +v0 := lang.NewSymbol("print-simple").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(81), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(81), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{v3}) -return v7 - case 2: + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] v4 := args[1] v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("cons")) +v6 := v5.FindInternedVar(lang.NewSymbol("print-meta")) if v6.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } v7 := v6.Get() v8 := lang.Apply(v7, []any{v3, v4}) -return v8 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("cons")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() +_ = v8 v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("cons")) +v10 := v9.FindInternedVar(lang.NewSymbol("str")) if v10.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } v11 := v10.Get() -v12 := lang.Apply(v11, []any{v4, v5}) -v13 := lang.Apply(v8, []any{v3, v12}) +v12 := lang.Apply(v11, []any{v3}) +v13 := lang.Apply(lang1.WriteWriter, []any{v4, v12}) return v13 - case 4: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("cons")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("cons")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("cons")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v5, v6}) -v17 := lang.Apply(v12, []any{v4, v16}) -v18 := lang.Apply(v9, []any{v3, v17}) -return v18 +// print-str +{ +v1 := reflect.TypeOf("") +v0 := lang.NewSymbol("print-str").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("xs"))), lang.NewKeyword("doc"), "print to a string, returning it", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4776), lang.NewKeyword("end-line"), int(4776))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { default: - if len(args) < 4 { + if len(args) < 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := lang.NewList(args[4:]...) +v4 := lang.NewList(args[0:]...) +var v5 any = "unimplemented: new with non-constant class type" +_ = v5 v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("cons")) +v9 := v8.FindInternedVar(lang.NewSymbol("push-thread-bindings")) if v9.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } v10 := v9.Get() v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("cons")) +v12 := v11.FindInternedVar(lang.NewSymbol("hash-map")) if v12.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("cons")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("cons")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("spread")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.Apply(v22, []any{v7}) -v24 := lang.Apply(v19, []any{v6, v23}) -v25 := lang.Apply(v16, []any{v5, v24}) -v26 := lang.Apply(v13, []any{v4, v25}) -v27 := lang.Apply(v10, []any{v3, v26}) -return v27 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// load-lib -{ -v0 := lang.NewSymbol("load-lib").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("prefix"), lang.NewSymbol("lib"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Loads a lib with options", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5947), lang.NewKeyword("end-line"), int(5947), lang.NewKeyword("private"), true)).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("throw-if")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -var v9 any = v3 -_ = v9 -var v11 any -if lang.IsTruthy(v9) { -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("pos?")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("name")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v4}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("int")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{lang.NewChar(46)}) -v23 := lang.Apply(strings22.Index, []any{v18, v22}) -v24 := lang.Apply(v14, []any{v23}) -v11 = v24 -} else { -v11 = v9 -} -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("name")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v4}) -v13 := lang.Apply(v8, []any{v11, "Found lib name '%s' containing period with prefix '%s'. lib names inside prefix lists must not contain periods", v12, v3}) -_ = v13 -var v15 any -if lang.IsTruthy(v3) { -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("symbol")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("str")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v3, lang.NewChar(46), v14}) -v23 := lang.Apply(v18, []any{v22}) -v15 = v23 -} else { -v15 = v14 -} -var v14 any = v15 -_ = v14 -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("apply")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("hash-map")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v27, []any{v30, v5}) -var v24 any = v31 -_ = v24 -var v32 any = v24 -_ = v32 -var v34 any -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("seq?")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v33}) -if lang.IsTruthy(v38) { -var v39 any -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("next")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v33}) -if lang.IsTruthy(v43) { -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("to-array")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v33}) -v48 := lang.Apply(lang1.NewPersistentArrayMapAsIfByAssoc, []any{v47}) -v39 = v48 -} else { -var v49 any -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("seq")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.Apply(v52, []any{v33}) -if lang.IsTruthy(v53) { -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("first")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) -} -v56 := v55.Get() -v57 := lang.Apply(v56, []any{v33}) -v49 = v57 -} else { -v49 = nil -} -v39 = v49 -} -v34 = v39 -} else { -v34 = v33 -} -var v33 any = v34 -_ = v33 -v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v60 := v59.FindInternedVar(lang.NewSymbol("get")) -if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) -} -v61 := v60.Get() -v62 := lang.Apply(v61, []any{v33, lang.NewKeyword("as")}) -var v58 any = v62 -_ = v58 -v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v65 := v64.FindInternedVar(lang.NewSymbol("get")) -if v65.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) -} -v66 := v65.Get() -v67 := lang.Apply(v66, []any{v33, lang.NewKeyword("reload")}) -var v63 any = v67 -_ = v63 -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("get")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) -} -v71 := v70.Get() -v72 := lang.Apply(v71, []any{v33, lang.NewKeyword("reload-all")}) -var v68 any = v72 -_ = v68 -v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v75 := v74.FindInternedVar(lang.NewSymbol("get")) -if v75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) -} -v76 := v75.Get() -v77 := lang.Apply(v76, []any{v33, lang.NewKeyword("require")}) -var v73 any = v77 -_ = v73 -v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v80 := v79.FindInternedVar(lang.NewSymbol("get")) -if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) -} -v81 := v80.Get() -v82 := lang.Apply(v81, []any{v33, lang.NewKeyword("use")}) -var v78 any = v82 -_ = v78 -v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v85 := v84.FindInternedVar(lang.NewSymbol("get")) -if v85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) -} -v86 := v85.Get() -v87 := lang.Apply(v86, []any{v33, lang.NewKeyword("verbose")}) -var v83 any = v87 -_ = v83 -v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v90 := v89.FindInternedVar(lang.NewSymbol("get")) -if v90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) -} -v91 := v90.Get() -v92 := lang.Apply(v91, []any{v33, lang.NewKeyword("as-alias")}) -var v88 any = v92 -_ = v88 -v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v95 := v94.FindInternedVar(lang.NewSymbol("contains?")) -if v95.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) -} -v96 := v95.Get() -v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v98 := v97.FindInternedVar(lang.NewSymbol("deref")) -if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) -} -v99 := v98.Get() -v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v101 := v100.FindInternedVar(lang.NewSymbol("*loaded-libs*")) -if v101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) +v14 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*out*")) +v15 := lang.Apply(v13, []any{v14, v5}) +v16 := lang.Apply(v10, []any{v15}) +_ = v16 +var v17 any +func() { +defer func() { +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v102 := v101.Get() -v103 := lang.Apply(v99, []any{v102}) -v104 := lang.Apply(v96, []any{v103, v14}) -var v93 any = v104 -_ = v93 -var v106 any = v58 -_ = v106 -var v108 any -if lang.IsTruthy(v106) { -v108 = v106 -} else { -v108 = v78 +v20 := v19.Get() +v21 := lang.Apply(v20, nil) +}() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("apply")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -var v105 any = v108 -_ = v105 -var v107 any -if lang.IsTruthy(v68) { -v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v109 := v108.FindInternedVar(lang.NewSymbol("load-all")) -if v109.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("print")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -v110 := v109.Get() -v107 = v110 -} else { -var v111 any -if lang.IsTruthy(v63) { -v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v113 := v112.FindInternedVar(lang.NewSymbol("load-one")) -if v113.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) +v27 := v26.Get() +v28 := lang.Apply(v24, []any{v27, v4}) +_ = v28 +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("str")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) } -v114 := v113.Get() -v111 = v114 -} else { -var v115 any -v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v117 := v116.FindInternedVar(lang.NewSymbol("not")) -if v117.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) +v31 := v30.Get() +v32 := lang.Apply(v31, []any{v5}) +v17 = v32 +}() +return v17 + } +}) +v4 := reflect.TypeOf("") +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v118 := v117.Get() -v119 := lang.Apply(v118, []any{v93}) -if lang.IsTruthy(v119) { -var v120 any -if lang.IsTruthy(v105) { -v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v122 := v121.FindInternedVar(lang.NewSymbol("load-one")) -if v122.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) } -v123 := v122.Get() -v120 = v123 -} else { -var v124 any -if lang.IsTruthy(v88) { -var v125 lang.FnFunc -v125 = lang.NewFnFunc(func(args ...any) any { +// print-tagged-object +{ +v0 := lang.NewSymbol("print-tagged-object").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(102), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(102), lang.NewKeyword("end-column"), int(26), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("rep"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v126 := args[0] -v127 := args[1] -v128 := args[2] -v129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v130 := v129.FindInternedVar(lang.NewSymbol("create-ns")) -if v130.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v130))) +v3 := args[0] +v4 := args[1] +v5 := args[2] +var v6 any +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("instance?")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v131 := v130.Get() -v132 := lang.Apply(v131, []any{v126}) -return v132 -}) -v126 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5961), lang.NewKeyword("column"), int(48), lang.NewKeyword("end-line"), int(5961), lang.NewKeyword("end-column"), int(88)) -v127, err := lang.WithMeta(v125, v126.(lang.IPersistentMap)) -if err != nil { - panic(err) +v9 := v8.Get() +v10 := lang.Apply(v9, []any{lang1.IMeta, v3}) +if lang.IsTruthy(v10) { +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("print-meta")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v124 = v127 +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v3, v5}) +v6 = v14 } else { -var v128 any -if lang.IsTruthy(lang.NewKeyword("else")) { -v129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v130 := v129.FindInternedVar(lang.NewSymbol("load-one")) -if v130.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v130))) +v6 = nil } -v131 := v130.Get() -v128 = v131 -} else { -v128 = nil +_ = v6 +v15 := lang.Apply(lang1.WriteWriter, []any{v5, "#object["}) +_ = v15 +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("class")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v124 = v128 +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v3}) +var v16 any = v20 +_ = v16 +var v22 any +if lang.IsTruthy(false) { +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("print-method")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v120 = v124 +v25 := v24.Get() +v26, ok := lang.FieldOrMethod(v16, "Name") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v16, "Name"))) } -v115 = v120 -} else { -v115 = nil +var v27 any +switch reflect.TypeOf(v26).Kind() { +case reflect.Func: + v27 = lang.Apply(v26, nil) +default: + v27 = v26 } -v111 = v115 +v28 := lang.Apply(v25, []any{v27, v5}) +v22 = v28 +} else { +v29, ok := lang.FieldOrMethod(v16, "Name") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v16, "Name"))) } -v107 = v111 +var v30 any +switch reflect.TypeOf(v29).Kind() { +case reflect.Func: + v30 = lang.Apply(v29, nil) +default: + v30 = v29 } -var v106 any = v107 -_ = v106 -v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v134 := v133.FindInternedVar(lang.NewSymbol("select-keys")) -if v134.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) +v31 := lang.Apply(lang1.WriteWriter, []any{v5, v30}) +v22 = v31 } -v135 := v134.Get() -v136 := lang.Apply(v135, []any{v24, lang.NewList(lang.NewKeyword("exclude"), lang.NewKeyword("only"), lang.NewKeyword("rename"), lang.NewKeyword("refer"))}) -var v132 any = v136 -_ = v132 -v138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v139 := v138.FindInternedVar(lang.NewSymbol("not")) -if v139.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v139))) +_ = v22 +v16 := lang.Apply(lang1.WriteWriter, []any{v5, " "}) +_ = v16 +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("format")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v140 := v139.Get() -v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v142 := v141.FindInternedVar(lang.NewSymbol("find-ns")) -if v142.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) +v19 := v18.Get() +v20 := lang.Apply(lang1.IdentityHash, []any{v3}) +v21 := lang.Apply(v19, []any{"0x%x ", v20}) +v22 := lang.Apply(lang1.WriteWriter, []any{v5, v21}) +_ = v22 +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("print-method")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v143 := v142.Get() -v144 := lang.Apply(v143, []any{v14}) -v145 := lang.Apply(v140, []any{v144}) -var v137 any = v145 -_ = v137 -v148 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v149 := v148.FindInternedVar(lang.NewSymbol("push-thread-bindings")) -if v149.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v149))) +v25 := v24.Get() +v26 := lang.Apply(v25, []any{v4, v5}) +_ = v26 +v27 := lang.Apply(lang1.WriteWriter, []any{v5, "]"}) +return v27 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v150 := v149.Get() -v151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v152 := v151.FindInternedVar(lang.NewSymbol("hash-map")) -if v152.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v152))) } -v153 := v152.Get() -v154 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*loading-verbosely*")) -v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v157 := v156.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) -if v157.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) +// print-throwable +{ +v0 := lang.NewSymbol("print-throwable").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(478), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(478), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.Apply(lang1.WriteWriter, []any{v4, "#error {\n :cause "}) +_ = v5 +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("Throwable->map")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v158 := v157.Get() -var v155 any = v158 -_ = v155 -var v160 any -if lang.IsTruthy(v155) { -v160 = v155 -} else { -v160 = v83 +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v3}) +var v6 any = v10 +_ = v6 +var v12 any +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("seq?")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } -v155 := lang.Apply(v153, []any{v154, v160}) -v156 := lang.Apply(v150, []any{v155}) -_ = v156 -var v157 any -func() { -defer func() { -v158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v159 := v158.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) -if v159.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v159))) +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v11}) +if lang.IsTruthy(v16) { +var v17 any +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("next")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v160 := v159.Get() -v161 := lang.Apply(v160, nil) -}() -var v162 any -if lang.IsTruthy(v106) { -var v163 any -func() { -defer func() { -if r := recover(); r != nil { -if lang.CatchMatches(r, lang.Builtins["any"]) { -v164 := r -_ = v164 -var v165 any -if lang.IsTruthy(v137) { -v166 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v167 := v166.FindInternedVar(lang.NewSymbol("remove-ns")) -if v167.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v167))) +v20 := v19.Get() +v21 := lang.Apply(v20, []any{v11}) +if lang.IsTruthy(v21) { +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("to-array")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -v168 := v167.Get() -v169 := lang.Apply(v168, []any{v14}) -v165 = v169 +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v11}) +v26 := lang.Apply(lang1.NewPersistentArrayMapAsIfByAssoc, []any{v25}) +v17 = v26 } else { -v165 = nil +var v27 any +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("seq")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } -_ = v165 -panic(v164) +v30 := v29.Get() +v31 := lang.Apply(v30, []any{v11}) +if lang.IsTruthy(v31) { +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("first")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v11}) +v27 = v35 } else { -panic(r) +v27 = nil } +v17 = v27 } -}() -v164 := lang.Apply(v106, []any{v14, v105, v73}) -v163 = v164 -}() -v162 = v163 +v12 = v17 } else { -v165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v166 := v165.FindInternedVar(lang.NewSymbol("throw-if")) -if v166.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v166))) +v12 = v11 } -v167 := v166.Get() -var v168 any = v105 -_ = v168 -var v170 any -if lang.IsTruthy(v168) { -v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v172 := v171.FindInternedVar(lang.NewSymbol("not")) -if v172.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) +var v11 any = v12 +_ = v11 +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("get")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -v173 := v172.Get() -v174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v175 := v174.FindInternedVar(lang.NewSymbol("find-ns")) -if v175.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v175))) +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v11, lang.NewKeyword("cause")}) +var v36 any = v40 +_ = v36 +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("get")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) } -v176 := v175.Get() -v177 := lang.Apply(v176, []any{v14}) -v178 := lang.Apply(v173, []any{v177}) -v170 = v178 -} else { -v170 = v168 +v44 := v43.Get() +v45 := lang.Apply(v44, []any{v11, lang.NewKeyword("data")}) +var v41 any = v45 +_ = v41 +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("get")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) } -v168 := lang.Apply(v167, []any{v170, "namespace '%s' not found", v14}) -v162 = v168 +v49 := v48.Get() +v50 := lang.Apply(v49, []any{v11, lang.NewKeyword("via")}) +var v46 any = v50 +_ = v46 +v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v53 := v52.FindInternedVar(lang.NewSymbol("get")) +if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) } -_ = v162 -var v169 any -var v170 any = v105 -_ = v170 -var v172 any -if lang.IsTruthy(v170) { -v173 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v174 := v173.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) -if v174.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v174))) +v54 := v53.Get() +v55 := lang.Apply(v54, []any{v11, lang.NewKeyword("trace")}) +var v51 any = v55 +_ = v51 +var v57 lang.FnFunc +v57 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v58 := args[0] +v59 := lang.Apply(lang1.WriteWriter, []any{v4, "{:type "}) +_ = v59 +v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v61 := v60.FindInternedVar(lang.NewSymbol("print-method")) +if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) } -v175 := v174.Get() -v172 = v175 -} else { -v172 = v170 +v62 := v61.Get() +v63 := lang.Apply(lang.NewKeyword("type"), []any{v58}) +v64 := lang.Apply(v62, []any{v63, v4}) +_ = v64 +v65 := lang.Apply(lang1.WriteWriter, []any{v4, "\n :message "}) +_ = v65 +v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v67 := v66.FindInternedVar(lang.NewSymbol("print-method")) +if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) } -if lang.IsTruthy(v172) { -v170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v171 := v170.FindInternedVar(lang.NewSymbol("printf")) -if v171.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v171))) +v68 := v67.Get() +v69 := lang.Apply(lang.NewKeyword("message"), []any{v58}) +v70 := lang.Apply(v68, []any{v69, v4}) +_ = v70 +v72 := lang.Apply(lang.NewKeyword("data"), []any{v58}) +var v71 any = v72 +_ = v71 +var v74 any +if lang.IsTruthy(v71) { +var v75 any = v71 +_ = v75 +v77 := lang.Apply(lang1.WriteWriter, []any{v4, "\n :data "}) +_ = v77 +v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v79 := v78.FindInternedVar(lang.NewSymbol("print-method")) +if v79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) } -v172 := v171.Get() -v173 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v174 := v173.FindInternedVar(lang.NewSymbol("ns-name")) -if v174.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v174))) +v80 := v79.Get() +v81 := lang.Apply(v80, []any{v75, v4}) +v74 = v81 +} else { +v74 = nil } -v175 := v174.Get() -v176 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v177 := v176.FindInternedVar(lang.NewSymbol("*ns*")) -if v177.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v177))) +_ = v74 +v72 := lang.Apply(lang.NewKeyword("at"), []any{v58}) +var v71 any = v72 +_ = v71 +var v74 any +if lang.IsTruthy(v71) { +var v75 any = v71 +_ = v75 +v77 := lang.Apply(lang1.WriteWriter, []any{v4, "\n :at "}) +_ = v77 +v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v79 := v78.FindInternedVar(lang.NewSymbol("print-method")) +if v79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) } -v178 := v177.Get() -v179 := lang.Apply(v175, []any{v178}) -v180 := lang.Apply(v172, []any{"(glojure.core/in-ns '%s)\n", v179}) -v169 = v180 +v80 := v79.Get() +v81 := lang.Apply(lang.NewKeyword("at"), []any{v58}) +v82 := lang.Apply(v80, []any{v81, v4}) +v74 = v82 } else { -v169 = nil +v74 = nil } -_ = v169 -var v181 any -if lang.IsTruthy(v58) { -var v182 any -v183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v184 := v183.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) -if v184.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v184))) +_ = v74 +v71 := lang.Apply(lang1.WriteWriter, []any{v4, "}"}) +return v71 +}) +v58 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(481), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(491), lang.NewKeyword("end-column"), int(73)) +v59, err := lang.WithMeta(v57, v58.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v185 := v184.Get() -if lang.IsTruthy(v185) { -v186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v187 := v186.FindInternedVar(lang.NewSymbol("printf")) -if v187.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v187))) +var v56 any = v59 +_ = v56 +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("print-method")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) } -v188 := v187.Get() -v189 := lang.Apply(v188, []any{"(glojure.core/alias '%s '%s)\n", v58, v14}) -v182 = v189 +v63 := v62.Get() +v64 := lang.Apply(v63, []any{v36, v4}) +_ = v64 +var v65 any +if lang.IsTruthy(v41) { +v66 := lang.Apply(lang1.WriteWriter, []any{v4, "\n :data "}) +_ = v66 +v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v68 := v67.FindInternedVar(lang.NewSymbol("print-method")) +if v68.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) +} +v69 := v68.Get() +v70 := lang.Apply(v69, []any{v41, v4}) +v65 = v70 } else { -v182 = nil +v65 = nil } -_ = v182 -v190 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v191 := v190.FindInternedVar(lang.NewSymbol("alias")) -if v191.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v191))) +_ = v65 +var v71 any +if lang.IsTruthy(v46) { +v72 := lang.Apply(lang1.WriteWriter, []any{v4, "\n :via\n ["}) +_ = v72 +v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v75 := v74.FindInternedVar(lang.NewSymbol("first")) +if v75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) } -v192 := v191.Get() -v193 := lang.Apply(v192, []any{v58, v14}) -v181 = v193 -} else { -v181 = nil +v76 := v75.Get() +v77 := lang.Apply(v76, []any{v46}) +var v73 any = v77 +_ = v73 +var v79 any +if lang.IsTruthy(v73) { +var v80 any = v73 +_ = v80 +v82 := lang.Apply(v56, []any{v80}) +_ = v82 +v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v85 := v84.FindInternedVar(lang.NewSymbol("seq")) +if v85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) } -_ = v181 -var v194 any -if lang.IsTruthy(v88) { -var v195 any -v196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v197 := v196.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) -if v197.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v197))) +v86 := v85.Get() +v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v88 := v87.FindInternedVar(lang.NewSymbol("rest")) +if v88.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) } -v198 := v197.Get() -if lang.IsTruthy(v198) { -v199 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v200 := v199.FindInternedVar(lang.NewSymbol("printf")) -if v200.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v200))) +v89 := v88.Get() +v90 := lang.Apply(v89, []any{v46}) +v91 := lang.Apply(v86, []any{v90}) +var v83 any = v91 +_ = v83 +var v92 any = nil +_ = v92 +var v93 any = int64(0) +_ = v93 +var v94 any = int64(0) +_ = v94 +var v95 any +for { +var v96 any +v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v98 := v97.FindInternedVar(lang.NewSymbol("<")) +if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) } -v201 := v200.Get() -v202 := lang.Apply(v201, []any{"(glojure.core/alias '%s '%s)\n", v88, v14}) -v195 = v202 -} else { -v195 = nil +v99 := v98.Get() +v100 := lang.Apply(v99, []any{v94, v93}) +if lang.IsTruthy(v100) { +v102, _ := lang.FieldOrMethod(v92, "nth") +if reflect.TypeOf(v102).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) } -_ = v195 -v203 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v204 := v203.FindInternedVar(lang.NewSymbol("alias")) -if v204.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v204))) +v103 := lang.Apply(v102, []any{v94}) +var v101 any = v103 +_ = v101 +v105 := lang.Apply(lang1.WriteWriter, []any{v4, "\n "}) +_ = v105 +v106 := lang.Apply(v56, []any{v101}) +_ = v106 +var v107 any = v83 +var v108 any = v92 +var v109 any = v93 +v111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v112 := v111.FindInternedVar(lang.NewSymbol("unchecked-inc")) +if v112.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v112))) } -v205 := v204.Get() -v206 := lang.Apply(v205, []any{v88, v14}) -v194 = v206 +v113 := v112.Get() +v114 := lang.Apply(v113, []any{v94}) +var v110 any = v114 +v83 = v107 +v92 = v108 +v93 = v109 +v94 = v110 +continue } else { -v194 = nil +v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v103 := v102.FindInternedVar(lang.NewSymbol("seq")) +if v103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) } -_ = v194 -var v207 any -var v208 any = v78 -_ = v208 -var v210 any -if lang.IsTruthy(v208) { -v210 = v208 -} else { -v211 := lang.Apply(lang.NewKeyword("refer"), []any{v132}) -v210 = v211 +v104 := v103.Get() +v105 := lang.Apply(v104, []any{v83}) +var v101 any = v105 +_ = v101 +var v107 any +if lang.IsTruthy(v101) { +var v108 any = v101 +_ = v108 +var v110 any +v111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v112 := v111.FindInternedVar(lang.NewSymbol("chunked-seq?")) +if v112.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v112))) } -if lang.IsTruthy(v210) { -var v208 any -v209 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v210 := v209.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) -if v210.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v210))) +v113 := v112.Get() +v114 := lang.Apply(v113, []any{v108}) +if lang.IsTruthy(v114) { +v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v117 := v116.FindInternedVar(lang.NewSymbol("chunk-first")) +if v117.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) } -v211 := v210.Get() -if lang.IsTruthy(v211) { -v212 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v213 := v212.FindInternedVar(lang.NewSymbol("printf")) -if v213.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v213))) +v118 := v117.Get() +v119 := lang.Apply(v118, []any{v108}) +var v115 any = v119 +_ = v115 +v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v123 := v122.FindInternedVar(lang.NewSymbol("chunk-rest")) +if v123.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) } -v214 := v213.Get() -v215 := lang.Apply(v214, []any{"(glojure.core/refer '%s", v14}) -_ = v215 -v217 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v218 := v217.FindInternedVar(lang.NewSymbol("seq")) -if v218.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v218))) +v124 := v123.Get() +v125 := lang.Apply(v124, []any{v108}) +var v121 any = v125 +var v126 any = v115 +v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v129 := v128.FindInternedVar(lang.NewSymbol("int")) +if v129.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v129))) } -v219 := v218.Get() -v220 := lang.Apply(v219, []any{v132}) -var v216 any = v220 -_ = v216 -var v221 any = nil -_ = v221 -var v222 any = int64(0) -_ = v222 -var v223 any = int64(0) -_ = v223 -var v224 any -for { -var v225 any -v226 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v227 := v226.FindInternedVar(lang.NewSymbol("<")) -if v227.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v227))) +v130 := v129.Get() +v131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v132 := v131.FindInternedVar(lang.NewSymbol("count")) +if v132.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v132))) } -v228 := v227.Get() -v229 := lang.Apply(v228, []any{v223, v222}) -if lang.IsTruthy(v229) { -v231, _ := lang.FieldOrMethod(v221, "nth") -if reflect.TypeOf(v231).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) +v133 := v132.Get() +v134 := lang.Apply(v133, []any{v115}) +v135 := lang.Apply(v130, []any{v134}) +var v127 any = v135 +v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v138 := v137.FindInternedVar(lang.NewSymbol("int")) +if v138.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) } -v232 := lang.Apply(v231, []any{v223}) -var v230 any = v232 -_ = v230 -v234 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v235 := v234.FindInternedVar(lang.NewSymbol("printf")) -if v235.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v235))) +v139 := v138.Get() +v140 := lang.Apply(v139, []any{int64(0)}) +var v136 any = v140 +v83 = v121 +v92 = v126 +v93 = v127 +v94 = v136 +continue +} else { +v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v117 := v116.FindInternedVar(lang.NewSymbol("first")) +if v117.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) } -v236 := v235.Get() -v237 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v238 := v237.FindInternedVar(lang.NewSymbol("key")) -if v238.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v238))) +v118 := v117.Get() +v119 := lang.Apply(v118, []any{v108}) +var v115 any = v119 +_ = v115 +v121 := lang.Apply(lang1.WriteWriter, []any{v4, "\n "}) +_ = v121 +v122 := lang.Apply(v56, []any{v115}) +_ = v122 +v124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v125 := v124.FindInternedVar(lang.NewSymbol("next")) +if v125.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v125))) } -v239 := v238.Get() -v240 := lang.Apply(v239, []any{v230}) -v241 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v242 := v241.FindInternedVar(lang.NewSymbol("print-str")) -if v242.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v242))) +v126 := v125.Get() +v127 := lang.Apply(v126, []any{v108}) +var v123 any = v127 +var v128 any = nil +var v129 any = int64(0) +var v130 any = int64(0) +v83 = v123 +v92 = v128 +v93 = v129 +v94 = v130 +continue } -v243 := v242.Get() -v244 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v245 := v244.FindInternedVar(lang.NewSymbol("val")) -if v245.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v245))) +v107 = v110 +} else { +v107 = nil } -v246 := v245.Get() -v247 := lang.Apply(v246, []any{v230}) -v248 := lang.Apply(v243, []any{v247}) -v249 := lang.Apply(v236, []any{" %s '%s", v240, v248}) -_ = v249 -var v250 any = v216 -var v251 any = v221 -var v252 any = v222 -v254 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v255 := v254.FindInternedVar(lang.NewSymbol("unchecked-inc")) -if v255.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v255))) +v96 = v107 } -v256 := v255.Get() -v257 := lang.Apply(v256, []any{v223}) -var v253 any = v257 -v216 = v250 -v221 = v251 -v222 = v252 -v223 = v253 -continue +v95 = v96 + break +} +v79 = v95 } else { -v231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v232 := v231.FindInternedVar(lang.NewSymbol("seq")) -if v232.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v232))) +v79 = nil } -v233 := v232.Get() -v234 := lang.Apply(v233, []any{v216}) -var v230 any = v234 -_ = v230 -var v236 any -if lang.IsTruthy(v230) { -var v237 any = v230 -_ = v237 -var v239 any -v240 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v241 := v240.FindInternedVar(lang.NewSymbol("chunked-seq?")) -if v241.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v241))) +_ = v79 +v73 := lang.Apply(lang1.WriteWriter, []any{v4, "]"}) +v71 = v73 +} else { +v71 = nil } -v242 := v241.Get() -v243 := lang.Apply(v242, []any{v237}) -if lang.IsTruthy(v243) { -v245 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v246 := v245.FindInternedVar(lang.NewSymbol("chunk-first")) -if v246.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v246))) +_ = v71 +var v74 any +if lang.IsTruthy(v51) { +v75 := lang.Apply(lang1.WriteWriter, []any{v4, "\n :trace\n ["}) +_ = v75 +v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v78 := v77.FindInternedVar(lang.NewSymbol("first")) +if v78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) } -v247 := v246.Get() -v248 := lang.Apply(v247, []any{v237}) -var v244 any = v248 -_ = v244 -v251 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v252 := v251.FindInternedVar(lang.NewSymbol("chunk-rest")) -if v252.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v252))) +v79 := v78.Get() +v80 := lang.Apply(v79, []any{v51}) +var v76 any = v80 +_ = v76 +var v82 any +if lang.IsTruthy(v76) { +var v83 any = v76 +_ = v83 +v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v86 := v85.FindInternedVar(lang.NewSymbol("print-method")) +if v86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) } -v253 := v252.Get() -v254 := lang.Apply(v253, []any{v237}) -var v250 any = v254 -var v255 any = v244 -v257 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v258 := v257.FindInternedVar(lang.NewSymbol("int")) -if v258.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v258))) +v87 := v86.Get() +v88 := lang.Apply(v87, []any{v83, v4}) +_ = v88 +v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v91 := v90.FindInternedVar(lang.NewSymbol("seq")) +if v91.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) } -v259 := v258.Get() -v260 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v261 := v260.FindInternedVar(lang.NewSymbol("count")) -if v261.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v261))) +v92 := v91.Get() +v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v94 := v93.FindInternedVar(lang.NewSymbol("rest")) +if v94.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) } -v262 := v261.Get() -v263 := lang.Apply(v262, []any{v244}) -v264 := lang.Apply(v259, []any{v263}) -var v256 any = v264 -v266 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v267 := v266.FindInternedVar(lang.NewSymbol("int")) -if v267.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v267))) +v95 := v94.Get() +v96 := lang.Apply(v95, []any{v51}) +v97 := lang.Apply(v92, []any{v96}) +var v89 any = v97 +_ = v89 +var v98 any = nil +_ = v98 +var v99 any = int64(0) +_ = v99 +var v100 any = int64(0) +_ = v100 +var v101 any +for { +var v102 any +v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v104 := v103.FindInternedVar(lang.NewSymbol("<")) +if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) } -v268 := v267.Get() -v269 := lang.Apply(v268, []any{int64(0)}) -var v265 any = v269 -v216 = v250 -v221 = v255 -v222 = v256 -v223 = v265 +v105 := v104.Get() +v106 := lang.Apply(v105, []any{v100, v99}) +if lang.IsTruthy(v106) { +v108, _ := lang.FieldOrMethod(v98, "nth") +if reflect.TypeOf(v108).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) +} +v109 := lang.Apply(v108, []any{v100}) +var v107 any = v109 +_ = v107 +v111 := lang.Apply(lang1.WriteWriter, []any{v4, "\n "}) +_ = v111 +v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v113 := v112.FindInternedVar(lang.NewSymbol("print-method")) +if v113.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) +} +v114 := v113.Get() +v115 := lang.Apply(v114, []any{v107, v4}) +_ = v115 +var v116 any = v89 +var v117 any = v98 +var v118 any = v99 +v120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v121 := v120.FindInternedVar(lang.NewSymbol("unchecked-inc")) +if v121.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v121))) +} +v122 := v121.Get() +v123 := lang.Apply(v122, []any{v100}) +var v119 any = v123 +v89 = v116 +v98 = v117 +v99 = v118 +v100 = v119 continue } else { -v245 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v246 := v245.FindInternedVar(lang.NewSymbol("first")) -if v246.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v246))) +v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v109 := v108.FindInternedVar(lang.NewSymbol("seq")) +if v109.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) } -v247 := v246.Get() -v248 := lang.Apply(v247, []any{v237}) -var v244 any = v248 -_ = v244 -v250 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v251 := v250.FindInternedVar(lang.NewSymbol("printf")) -if v251.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v251))) +v110 := v109.Get() +v111 := lang.Apply(v110, []any{v89}) +var v107 any = v111 +_ = v107 +var v113 any +if lang.IsTruthy(v107) { +var v114 any = v107 +_ = v114 +var v116 any +v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v118 := v117.FindInternedVar(lang.NewSymbol("chunked-seq?")) +if v118.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) } -v252 := v251.Get() -v253 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v254 := v253.FindInternedVar(lang.NewSymbol("key")) -if v254.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v254))) +v119 := v118.Get() +v120 := lang.Apply(v119, []any{v114}) +if lang.IsTruthy(v120) { +v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v123 := v122.FindInternedVar(lang.NewSymbol("chunk-first")) +if v123.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) } -v255 := v254.Get() -v256 := lang.Apply(v255, []any{v244}) -v257 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v258 := v257.FindInternedVar(lang.NewSymbol("print-str")) -if v258.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v258))) +v124 := v123.Get() +v125 := lang.Apply(v124, []any{v114}) +var v121 any = v125 +_ = v121 +v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v129 := v128.FindInternedVar(lang.NewSymbol("chunk-rest")) +if v129.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v129))) } -v259 := v258.Get() -v260 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v261 := v260.FindInternedVar(lang.NewSymbol("val")) -if v261.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v261))) +v130 := v129.Get() +v131 := lang.Apply(v130, []any{v114}) +var v127 any = v131 +var v132 any = v121 +v134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v135 := v134.FindInternedVar(lang.NewSymbol("int")) +if v135.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v135))) } -v262 := v261.Get() -v263 := lang.Apply(v262, []any{v244}) -v264 := lang.Apply(v259, []any{v263}) -v265 := lang.Apply(v252, []any{" %s '%s", v256, v264}) -_ = v265 -v267 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v268 := v267.FindInternedVar(lang.NewSymbol("next")) -if v268.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v268))) +v136 := v135.Get() +v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v138 := v137.FindInternedVar(lang.NewSymbol("count")) +if v138.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) } -v269 := v268.Get() -v270 := lang.Apply(v269, []any{v237}) -var v266 any = v270 -var v271 any = nil -var v272 any = int64(0) -var v273 any = int64(0) -v216 = v266 -v221 = v271 -v222 = v272 -v223 = v273 -continue +v139 := v138.Get() +v140 := lang.Apply(v139, []any{v121}) +v141 := lang.Apply(v136, []any{v140}) +var v133 any = v141 +v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v144 := v143.FindInternedVar(lang.NewSymbol("int")) +if v144.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) } -v236 = v239 +v145 := v144.Get() +v146 := lang.Apply(v145, []any{int64(0)}) +var v142 any = v146 +v89 = v127 +v98 = v132 +v99 = v133 +v100 = v142 +continue } else { -v236 = nil +v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v123 := v122.FindInternedVar(lang.NewSymbol("first")) +if v123.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) } -v225 = v236 +v124 := v123.Get() +v125 := lang.Apply(v124, []any{v114}) +var v121 any = v125 +_ = v121 +v127 := lang.Apply(lang1.WriteWriter, []any{v4, "\n "}) +_ = v127 +v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v129 := v128.FindInternedVar(lang.NewSymbol("print-method")) +if v129.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v129))) } -v224 = v225 - break +v130 := v129.Get() +v131 := lang.Apply(v130, []any{v121, v4}) +_ = v131 +v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v134 := v133.FindInternedVar(lang.NewSymbol("next")) +if v134.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) } -_ = v224 -v216 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v217 := v216.FindInternedVar(lang.NewSymbol("printf")) -if v217.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v217))) +v135 := v134.Get() +v136 := lang.Apply(v135, []any{v114}) +var v132 any = v136 +var v137 any = nil +var v138 any = int64(0) +var v139 any = int64(0) +v89 = v132 +v98 = v137 +v99 = v138 +v100 = v139 +continue } -v218 := v217.Get() -v219 := lang.Apply(v218, []any{")\n"}) -v208 = v219 +v113 = v116 } else { -v208 = nil -} -_ = v208 -v220 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v221 := v220.FindInternedVar(lang.NewSymbol("apply")) -if v221.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v221))) +v113 = nil } -v222 := v221.Get() -v223 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v224 := v223.FindInternedVar(lang.NewSymbol("refer")) -if v224.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v224))) +v102 = v113 } -v225 := v224.Get() -v226 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v227 := v226.FindInternedVar(lang.NewSymbol("mapcat")) -if v227.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v227))) +v101 = v102 + break } -v228 := v227.Get() -v229 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v230 := v229.FindInternedVar(lang.NewSymbol("seq")) -if v230.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v230))) +v82 = v101 +} else { +v82 = nil } -v231 := v230.Get() -v232 := lang.Apply(v228, []any{v231, v132}) -v233 := lang.Apply(v222, []any{v225, v14, v232}) -v207 = v233 +_ = v82 +v76 := lang.Apply(lang1.WriteWriter, []any{v4, "]"}) +v74 = v76 } else { -v207 = nil +v74 = nil } -v157 = v207 -}() -return v157 - } +_ = v74 +v6 := lang.Apply(lang1.WriteWriter, []any{v4, "}"}) +return v6 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -62143,74 +62265,39 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// pvalues +// printf { -v0 := lang.NewSymbol("pvalues").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("exprs"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the values of the exprs, which are\n evaluated in parallel", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7106), lang.NewKeyword("end-line"), int(7106))).(*lang.Symbol) +v0 := lang.NewSymbol("printf").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fmt"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Prints formatted output, as per format", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5768), lang.NewKeyword("end-line"), int(5768))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 2 { + if len(args) < 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("seq")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("concat")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("list")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{lang.NewSymbol("glojure.core/pcalls")}) -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("map")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -var v19 lang.FnFunc -v19 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v20 := args[0] -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("list")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +v4 := lang.NewList(args[1:]...) +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("print")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v23 := v22.Get() -v24 := lang.NewVector() -v25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7112), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(7112), lang.NewKeyword("end-column"), int(31)) -v26, err := lang.WithMeta(v24, v25.(lang.IPersistentMap)) -if err != nil { - panic(err) +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("apply")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v27 := lang.Apply(v23, []any{lang.NewSymbol("glojure.core/fn"), v26, v20}) -return v27 -}) -v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7112), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(7112), lang.NewKeyword("end-column"), int(34)) -v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) -if err != nil { - panic(err) +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("format")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v22 := lang.Apply(v18, []any{v21, v5}) -v23 := lang.Apply(v11, []any{v15, v22}) -v24 := lang.Apply(v8, []any{v23}) -return v24 +v13 := v12.Get() +v14 := lang.Apply(v10, []any{v13, v3, v4}) +v15 := lang.Apply(v7, []any{v14}) +return v15 } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -62219,49 +62306,61 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// macroexpand-1 +// println { -v0 := lang.NewSymbol("macroexpand-1").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("form"))), lang.NewKeyword("doc"), "If form represents a macro form, returns its expansion,\n else returns form.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4017), lang.NewKeyword("end-line"), int(4017))).(*lang.Symbol) +v0 := lang.NewSymbol("println").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Same as print followed by (newline)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3734), lang.NewKeyword("end-line"), int(3734))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, _ := lang.FieldOrMethod(runtime3.Compiler, "macroexpand1") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("macroexpand1 is not a function"))) + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.NewList(args[0:]...) +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("push-thread-bindings")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v5 := lang.Apply(v4, []any{v3}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("hash-map")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } +v10 := v9.Get() +v11 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*print-readably*")) +v12 := lang.Apply(v10, []any{v11, nil}) +v13 := lang.Apply(v7, []any{v12}) +_ = v13 +var v14 any +func() { +defer func() { +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } -// methods -{ -v0 := lang.NewSymbol("methods").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"))), lang.NewKeyword("doc"), "Given a multimethod, returns a map of dispatch values -> dispatch fns", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1809), lang.NewKeyword("end-line"), int(1809))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, ok := lang.FieldOrMethod(v3, "getMethodTable") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getMethodTable"))) +v17 := v16.Get() +v18 := lang.Apply(v17, nil) +}() +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("apply")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -var v5 any -switch reflect.TypeOf(v4).Kind() { -case reflect.Func: - v5 = lang.Apply(v4, nil) -default: - v5 = v4 +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("prn")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -return v5 +v24 := v23.Get() +v25 := lang.Apply(v21, []any{v24, v3}) +v14 = v25 +}() +return v14 + } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -62269,405 +62368,466 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// *compile-path* +// println-str { -v0 := lang.NewSymbol("*compile-path*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "Specifies the directory where 'compile' will write out .class\n files. This directory must be in the classpath for 'compile' to\n work.\n\n Defaults to \"classes\"", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, nil, true) +v1 := reflect.TypeOf("") +v0 := lang.NewSymbol("println-str").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("xs"))), lang.NewKeyword("doc"), "println to a string, returning it", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4785), lang.NewKeyword("end-line"), int(4785))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := lang.NewList(args[0:]...) +var v5 any = "unimplemented: new with non-constant class type" +_ = v5 +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("push-thread-bindings")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("hash-map")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*out*")) +v15 := lang.Apply(v13, []any{v14, v5}) +v16 := lang.Apply(v10, []any{v15}) +_ = v16 +var v17 any +func() { +defer func() { +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, nil) +}() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("apply")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("println")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.Apply(v24, []any{v27, v4}) +_ = v28 +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("str")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.Apply(v31, []any{v5}) +v17 = v32 +}() +return v17 + } +}) +v4 := reflect.TypeOf("") +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// keep +// prn { -v0 := lang.NewSymbol("keep").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the non-nil results of (f item). Note,\n this means false return values will be included. f must be free of\n side-effects. Returns a transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7382), lang.NewKeyword("end-line"), int(7382))).(*lang.Symbol) +v0 := lang.NewSymbol("prn").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Same as pr followed by (newline). Observes *flush-on-newline*", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3715), lang.NewKeyword("end-line"), int(3715))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 1: -v3 := args[0] -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := args[0] -var v6 lang.FnFunc -v6 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v7 := lang.Apply(v5, nil) -return v7 - case 1: -v7 := args[0] -v8 := lang.Apply(v5, []any{v7}) -return v8 - case 2: -v7 := args[0] -v8 := args[1] -v10 := lang.Apply(v3, []any{v8}) -var v9 any = v10 -_ = v9 -var v12 any -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("nil?")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v9}) -if lang.IsTruthy(v16) { -v12 = v7 -} else { -v17 := lang.Apply(v5, []any{v7, v9}) -v12 = v17 -} -return v12 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7390), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7397), lang.NewKeyword("end-column"), int(31)) -v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v8 -}) -v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7389), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7397), lang.NewKeyword("end-column"), int(32)) -v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) -if err != nil { - panic(err) + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.NewList(args[0:]...) +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("apply")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -return v6 - case 2: -v3 := args[0] -v4 := args[1] -var v5 lang.FnFunc -v5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } +v6 := v5.Get() v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("seq")) +v8 := v7.FindInternedVar(lang.NewSymbol("pr")) if v8.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } v9 := v8.Get() -v10 := lang.Apply(v9, []any{v4}) -var v6 any = v10 -_ = v6 -var v12 any -if lang.IsTruthy(v6) { -var v13 any = v6 -_ = v13 +v10 := lang.Apply(v6, []any{v9, v3}) +_ = v10 +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("newline")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, nil) +_ = v14 var v15 any v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("chunked-seq?")) +v17 := v16.FindInternedVar(lang.NewSymbol("*flush-on-newline*")) if v17.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } v18 := v17.Get() -v19 := lang.Apply(v18, []any{v13}) -if lang.IsTruthy(v19) { -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("chunk-first")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v13}) -var v20 any = v24 -_ = v20 -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("count")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +if lang.IsTruthy(v18) { +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("flush")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v28 := v27.Get() -v29 := lang.Apply(v28, []any{v20}) -var v25 any = v29 -_ = v25 -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("chunk-buffer")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v21 := v20.Get() +v22 := lang.Apply(v21, nil) +v15 = v22 +} else { +v15 = nil } -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v25}) -var v30 any = v34 -_ = v30 -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("long")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +return v15 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v25}) -var v36 any = v40 -_ = v36 -var v42 any = int64(0) -_ = v42 -var v43 any -for { -var v44 any -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("<")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) } -v47 := v46.Get() -v48 := lang.Apply(v47, []any{v42, v36}) -if lang.IsTruthy(v48) { -v50, _ := lang.FieldOrMethod(v20, "nth") -if reflect.TypeOf(v50).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) +// prn-str +{ +v1 := reflect.TypeOf("") +v0 := lang.NewSymbol("prn-str").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("xs"))), lang.NewKeyword("doc"), "prn to a string, returning it", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4767), lang.NewKeyword("end-line"), int(4767))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := lang.NewList(args[0:]...) +var v5 any = "unimplemented: new with non-constant class type" +_ = v5 +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("push-thread-bindings")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v51 := lang.Apply(v50, []any{v42}) -v52 := lang.Apply(v3, []any{v51}) -var v49 any = v52 -_ = v49 -var v54 any -v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v56 := v55.FindInternedVar(lang.NewSymbol("nil?")) -if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("hash-map")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v57 := v56.Get() -v58 := lang.Apply(v57, []any{v49}) -if lang.IsTruthy(v58) { -v54 = nil -} else { -v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v60 := v59.FindInternedVar(lang.NewSymbol("chunk-append")) -if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) +v13 := v12.Get() +v14 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*out*")) +v15 := lang.Apply(v13, []any{v14, v5}) +v16 := lang.Apply(v10, []any{v15}) +_ = v16 +var v17 any +func() { +defer func() { +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v61 := v60.Get() -v62 := lang.Apply(v61, []any{v30, v49}) -v54 = v62 +v20 := v19.Get() +v21 := lang.Apply(v20, nil) +}() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("apply")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -_ = v54 -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("unchecked-inc")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("prn")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -v52 := v51.Get() -v53 := lang.Apply(v52, []any{v42}) -var v49 any = v53 -v42 = v49 -continue -} else { -v44 = nil +v27 := v26.Get() +v28 := lang.Apply(v24, []any{v27, v4}) +_ = v28 +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("str")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) } -v43 = v44 - break +v31 := v30.Get() +v32 := lang.Apply(v31, []any{v5}) +v17 = v32 +}() +return v17 + } +}) +v4 := reflect.TypeOf("") +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } -_ = v43 -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("chunk-cons")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) } -v38 := v37.Get() -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("chunk")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +// process-annotation +{ +v0 := lang.NewSymbol("process-annotation").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5505), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(5505), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("av"), lang.NewSymbol("v"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("map?")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v41 := v40.Get() -v42 := lang.Apply(v41, []any{v30}) -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("keep")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v4}) +if lang.IsTruthy(v9) { +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("seq")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v45 := v44.Get() -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("chunk-rest")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v4}) +var v10 any = v14 +_ = v10 +var v15 any = nil +_ = v15 +var v16 any = int64(0) +_ = v16 +var v17 any = int64(0) +_ = v17 +var v18 any +for { +var v19 any +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("<")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v48 := v47.Get() -v49 := lang.Apply(v48, []any{v13}) -v50 := lang.Apply(v45, []any{v3, v49}) -v51 := lang.Apply(v38, []any{v42, v50}) -v15 = v51 -} else { -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("first")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +v22 := v21.Get() +v23 := lang.Apply(v22, []any{v17, v16}) +if lang.IsTruthy(v23) { +v25, _ := lang.FieldOrMethod(v15, "nth") +if reflect.TypeOf(v25).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) } -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v13}) -v25 := lang.Apply(v3, []any{v24}) -var v20 any = v25 -_ = v20 -var v27 any +v26 := lang.Apply(v25, []any{v17}) +var v24 any = v26 +_ = v24 v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("nil?")) +v29 := v28.FindInternedVar(lang.NewSymbol("nth")) if v29.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } v30 := v29.Get() -v31 := lang.Apply(v30, []any{v20}) -if lang.IsTruthy(v31) { -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("keep")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("rest")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v13}) -v39 := lang.Apply(v34, []any{v3, v38}) -v27 = v39 -} else { -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("cons")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("keep")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +v31 := lang.Apply(v30, []any{v24, int64(0), nil}) +var v27 any = v31 +_ = v27 +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("nth")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) } -v45 := v44.Get() -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("rest")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v24, int64(1), nil}) +var v32 any = v36 +_ = v32 +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("add-annotation")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) } -v48 := v47.Get() -v49 := lang.Apply(v48, []any{v13}) -v50 := lang.Apply(v45, []any{v3, v49}) -v51 := lang.Apply(v42, []any{v20, v50}) -v27 = v51 +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("name")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } -v15 = v27 +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v27}) +v45 := lang.Apply(v40, []any{v3, v44, v32}) +_ = v45 +var v46 any = v10 +var v47 any = v15 +var v48 any = v16 +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("unchecked-inc")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) } -v12 = v15 +v52 := v51.Get() +v53 := lang.Apply(v52, []any{v17}) +var v49 any = v53 +v10 = v46 +v15 = v47 +v16 = v48 +v17 = v49 +continue } else { -v12 = nil +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("seq")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -return v12 -}) -v6 := lang.Apply(lang1.NewLazySeq, []any{v5}) -return v6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v27 := v26.Get() +v28 := lang.Apply(v27, []any{v10}) +var v24 any = v28 +_ = v24 +var v30 any +if lang.IsTruthy(v24) { +var v31 any = v24 +_ = v31 +var v33 any +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("chunked-seq?")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } +v36 := v35.Get() +v37 := lang.Apply(v36, []any{v31}) +if lang.IsTruthy(v37) { +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("chunk-first")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) } -// parse-impls -{ -v0 := lang.NewSymbol("parse-impls").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(13), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(13), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("specs"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v5 := lang.NewMap() -v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(14), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(14), lang.NewKeyword("end-column"), int(15)) -v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) -if err != nil { - panic(err) +v41 := v40.Get() +v42 := lang.Apply(v41, []any{v31}) +var v38 any = v42 +_ = v38 +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("chunk-rest")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) } -var v4 any = v7 -_ = v4 -var v8 any = v3 -_ = v8 -var v9 any -for { -var v10 any -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("seq")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v47 := v46.Get() +v48 := lang.Apply(v47, []any{v31}) +var v44 any = v48 +var v49 any = v38 +v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v52 := v51.FindInternedVar(lang.NewSymbol("int")) +if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) } -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v8}) -if lang.IsTruthy(v14) { -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("assoc")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +v53 := v52.Get() +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("count")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) } -v18 := v17.Get() -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("first")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v56 := v55.Get() +v57 := lang.Apply(v56, []any{v38}) +v58 := lang.Apply(v53, []any{v57}) +var v50 any = v58 +v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v61 := v60.FindInternedVar(lang.NewSymbol("int")) +if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) } -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v8}) -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("take-while")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +v62 := v61.Get() +v63 := lang.Apply(v62, []any{int64(0)}) +var v59 any = v63 +v10 = v44 +v15 = v49 +v16 = v50 +v17 = v59 +continue +} else { +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("first")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) } -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("seq?")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +v41 := v40.Get() +v42 := lang.Apply(v41, []any{v31}) +var v38 any = v42 +_ = v38 +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("nth")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("next")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v38, int64(0), nil}) +var v43 any = v47 +_ = v43 +v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v50 := v49.FindInternedVar(lang.NewSymbol("nth")) +if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) } -v31 := v30.Get() -v32 := lang.Apply(v31, []any{v8}) -v33 := lang.Apply(v25, []any{v28, v32}) -v34 := lang.Apply(v18, []any{v4, v22, v33}) -var v15 any = v34 -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("drop-while")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +v51 := v50.Get() +v52 := lang.Apply(v51, []any{v38, int64(1), nil}) +var v48 any = v52 +_ = v48 +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("add-annotation")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) } -v38 := v37.Get() -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("seq?")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +v56 := v55.Get() +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("name")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) } -v41 := v40.Get() -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("next")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +v59 := v58.Get() +v60 := lang.Apply(v59, []any{v43}) +v61 := lang.Apply(v56, []any{v3, v60, v48}) +_ = v61 +v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v64 := v63.FindInternedVar(lang.NewSymbol("next")) +if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) } -v44 := v43.Get() -v45 := lang.Apply(v44, []any{v8}) -v46 := lang.Apply(v38, []any{v41, v45}) -var v35 any = v46 -v4 = v15 -v8 = v35 +v65 := v64.Get() +v66 := lang.Apply(v65, []any{v31}) +var v62 any = v66 +var v67 any = nil +var v68 any = int64(0) +var v69 any = int64(0) +v10 = v62 +v15 = v67 +v16 = v68 +v17 = v69 continue +} +v30 = v33 } else { -v10 = v4 +v30 = nil } -v9 = v10 +v19 = v30 +} +v18 = v19 break } -return v9 +v5 = v18 +} else { +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("add-annotation")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{v3, "value", v4}) +v5 = v13 +} +return v5 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -62675,170 +62835,173 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// or +// promise { -v0 := lang.NewSymbol("or").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("next"))), lang.NewKeyword("doc"), "Evaluates exprs one at a time, from left to right. If a form\n returns a logical true value, or returns that value and doesn't\n evaluate any of the other expressions, otherwise it returns the\n value of the last expression. (or) returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(847), lang.NewKeyword("end-line"), int(847))).(*lang.Symbol) +v0 := lang.NewSymbol("promise").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Returns a promise object that can be read with deref/@, and set,\n once only, with deliver. Calls to deref/@ prior to delivery will\n block, unless the variant of deref with timeout is used. All\n subsequent derefs will return the same delivered value without\n blocking. See also - realized?.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7121), lang.NewKeyword("end-line"), int(7121))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v3 := args[0] -v4 := args[1] -return nil - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -return v5 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("seq")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := lang.Apply(java.util.concurrent.CountDownLatch29., []any{int64(1)}) +var v3 any = v4 +_ = v3 +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("atom")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("concat")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v3}) +var v5 any = v9 +_ = v5 +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("deref")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("list")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +v13 := v12.Get() +v14 := lang.NewVector(nil) +v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7134), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(7134), lang.NewKeyword("end-column"), int(17)) +v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v15 := v14.Get() -v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/let")}) -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("list")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +v17, ok := lang.FieldOrMethod(v3, "await") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "await"))) } -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("apply")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +var v18 any +switch reflect.TypeOf(v17).Kind() { +case reflect.Func: + v18 = lang.Apply(v17, nil) +default: + v18 = v17 } -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("vector")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("deref")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("seq")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v5}) +v23 := lang.Apply(v13, []any{v16, v18, v22}) +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("deref")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("concat")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +v26 := v25.Get() +v27 := lang.NewVector(nil, nil, nil) +v28 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7137), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(7137), lang.NewKeyword("end-column"), int(34)) +v29, err := lang.WithMeta(v27, v28.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +var v30 any +v31, _ := lang.FieldOrMethod(v3, "await") +if reflect.TypeOf(v31).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) } -v34 := v33.Get() -v35 := lang.Apply(v34, []any{lang.NewSymbol("or__0__auto__")}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +v32 := lang.Apply(v31, []any{nil, time17.Millisecond}) +if lang.IsTruthy(v32) { +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("deref")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) } -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v5}) -v40 := lang.Apply(v31, []any{v35, v39}) -v41 := lang.Apply(v28, []any{v40}) -v42 := lang.Apply(v22, []any{v25, v41}) -v43 := lang.Apply(v19, []any{v42}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v5}) +v30 = v36 +} else { +v30 = nil } -v46 := v45.Get() -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("seq")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +v37 := lang.Apply(v26, []any{v29, v30}) +v38 := lang.NewVector(nil) +v39 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7142), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(7142), lang.NewKeyword("end-column"), int(24)) +v40, err := lang.WithMeta(v38, v39.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v49 := v48.Get() -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("concat")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("zero?")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } -v52 := v51.Get() +v43 := v42.Get() +v44, ok := lang.FieldOrMethod(v3, "getCount") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getCount"))) +} +var v45 any +switch reflect.TypeOf(v44).Kind() { +case reflect.Func: + v45 = lang.Apply(v44, nil) +default: + v45 = v44 +} +v46 := lang.Apply(v43, []any{v45}) +v47 := lang.Apply(nil, []any{v40, v46}) +v48 := lang.NewVector(nil, nil) +v49 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7146), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(7146), lang.NewKeyword("end-column"), int(14)) +v50, err := lang.WithMeta(v48, v49.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v51 any v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("list")) +v54 := v53.FindInternedVar(lang.NewSymbol("pos?")) if v54.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) } v55 := v54.Get() -v56 := lang.Apply(v55, []any{lang.NewSymbol("if")}) -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("list")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +v56, ok := lang.FieldOrMethod(v3, "getCount") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getCount"))) } -v59 := v58.Get() -v60 := lang.Apply(v59, []any{lang.NewSymbol("or__0__auto__")}) +var v57 any +switch reflect.TypeOf(v56).Kind() { +case reflect.Func: + v57 = lang.Apply(v56, nil) +default: + v57 = v56 +} +v58 := lang.Apply(v55, []any{v57}) +var v52 any = v58 +_ = v52 +var v60 any +if lang.IsTruthy(v52) { v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("list")) +v62 := v61.FindInternedVar(lang.NewSymbol("compare-and-set!")) if v62.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) } v63 := v62.Get() -v64 := lang.Apply(v63, []any{lang.NewSymbol("or__0__auto__")}) -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("list")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +v64 := lang.Apply(v63, []any{v5, v3, nil}) +v60 = v64 +} else { +v60 = v52 } -v67 := v66.Get() -v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v69 := v68.FindInternedVar(lang.NewSymbol("seq")) -if v69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) +if lang.IsTruthy(v60) { +v52, ok := lang.FieldOrMethod(v3, "countDown") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "countDown"))) } -v70 := v69.Get() -v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v72 := v71.FindInternedVar(lang.NewSymbol("concat")) -if v72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) +var v53 any +switch reflect.TypeOf(v52).Kind() { +case reflect.Func: + v53 = lang.Apply(v52, nil) +default: + v53 = v52 } -v73 := v72.Get() -v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v75 := v74.FindInternedVar(lang.NewSymbol("list")) -if v75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) +_ = v53 +v51 = nil +} else { +v51 = nil } -v76 := v75.Get() -v77 := lang.Apply(v76, []any{lang.NewSymbol("glojure.core/or")}) -v78 := lang.Apply(v73, []any{v77, v6}) -v79 := lang.Apply(v70, []any{v78}) -v80 := lang.Apply(v67, []any{v79}) -v81 := lang.Apply(v52, []any{v56, v60, v64, v80}) -v82 := lang.Apply(v49, []any{v81}) -v83 := lang.Apply(v46, []any{v82}) -v84 := lang.Apply(v12, []any{v16, v43, v83}) -v85 := lang.Apply(v9, []any{v84}) -return v85 - } +v54 := lang.Apply(nil, []any{v50, v51}) +v55 := lang.Apply(nil, []any{lang1.IDeref, v23, lang1.IBlockingDeref, v37, lang1.IPending, v47, glojure.lang8.IFn, v54}) +return v55 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -62846,18 +63009,44 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// deliver +// protocol? { -v0 := lang.NewSymbol("deliver").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("promise"), lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Delivers the supplied value to the promise, releasing any pending\n derefs. A subsequent call to deliver on a promise will have no effect.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7152), lang.NewKeyword("end-line"), int(7152))).(*lang.Symbol) +v0 := lang.NewSymbol("protocol?").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(110), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(110), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("maybe-p"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := args[1] -v5 := lang.Apply(v3, []any{v4}) -return v5 +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{lang1.IAtom, v3}) +if lang.IsTruthy(v8) { +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("boolean")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("deref")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v3}) +v16 := lang.Apply(lang.NewKeyword("on-interface"), []any{v15}) +v17 := lang.Apply(v11, []any{v16}) +v4 = v17 +} else { +v4 = false +} +return v4 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -62865,140 +63054,147 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// some? +// push-thread-bindings { -v1 := reflect.TypeOf(false) -v0 := lang.NewSymbol("some?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is not nil, false otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(530), lang.NewKeyword("end-line"), int(530))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { +v0 := lang.NewSymbol("push-thread-bindings").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"))), lang.NewKeyword("doc"), "WARNING: This is a low-level function. Prefer high-level macros like\n binding where ever possible.\n\n Takes a map of Var/value pairs. Binds each Var to the associated value for\n the current thread. Each call *MUST* be accompanied by a matching call to\n pop-thread-bindings wrapped in a try-finally!\n \n (push-thread-bindings bindings)\n (try\n ...\n (finally\n (pop-thread-bindings)))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(26), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1911), lang.NewKeyword("end-line"), int(1911))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v4 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("not")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("nil?")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v4}) -v12 := lang.Apply(v7, []any{v11}) -return v12 +v3 := args[0] +v4 := lang.Apply(lang1.PushThreadBindings, []any{v3}) +return v4 }) -v4 := reflect.TypeOf(false) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// load-one +// pvalues { -v0 := lang.NewSymbol("load-one").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"), lang.NewSymbol("need-ns"), lang.NewSymbol("require"))), lang.NewKeyword("doc"), "Loads a lib given its name. If need-ns, ensures that the associated\n namespace exists after loading. If require, records the load so any\n duplicate loads can be skipped.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5922), lang.NewKeyword("end-line"), int(5922), lang.NewKeyword("private"), true)).(*lang.Symbol) +v0 := lang.NewSymbol("pvalues").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("exprs"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the values of the exprs, which are\n evaluated in parallel", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7106), lang.NewKeyword("end-line"), int(7106))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] v4 := args[1] -v5 := args[2] +v5 := lang.NewList(args[2:]...) v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("load")) +v7 := v6.FindInternedVar(lang.NewSymbol("seq")) if v7.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } v8 := v7.Get() v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("root-resource")) +v10 := v9.FindInternedVar(lang.NewSymbol("concat")) if v10.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } v11 := v10.Get() -v12 := lang.Apply(v11, []any{v3}) -v13 := lang.Apply(v8, []any{v12}) -_ = v13 -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("throw-if")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("list")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } -v16 := v15.Get() -var v17 any = v4 -_ = v17 -var v19 any -if lang.IsTruthy(v17) { -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("not")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +v14 := v13.Get() +v15 := lang.Apply(v14, []any{lang.NewSymbol("glojure.core/pcalls")}) +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("map")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("find-ns")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +v18 := v17.Get() +var v19 lang.FnFunc +v19 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v20 := args[0] +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("list")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v25 := v24.Get() -v26 := lang.Apply(v25, []any{v3}) -v27 := lang.Apply(v22, []any{v26}) -v19 = v27 -} else { -v19 = v17 +v23 := v22.Get() +v24 := lang.NewVector() +v25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7112), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(7112), lang.NewKeyword("end-column"), int(31)) +v26, err := lang.WithMeta(v24, v25.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("root-resource")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +v27 := lang.Apply(v23, []any{lang.NewSymbol("glojure.core/fn"), v26, v20}) +return v27 +}) +v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7112), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(7112), lang.NewKeyword("end-column"), int(34)) +v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v3}) -v21 := lang.Apply(v16, []any{v19, "namespace '%s' not found after loading '%s'", v3, v20}) -_ = v21 -var v22 any -if lang.IsTruthy(v5) { -var v23 lang.FnFunc -v23 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { +v22 := lang.Apply(v18, []any{v21, v5}) +v23 := lang.Apply(v11, []any{v15, v22}) +v24 := lang.Apply(v8, []any{v23}) +return v24 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// qualified-ident? +{ +v0 := lang.NewSymbol("qualified-ident?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a symbol or keyword with a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1618), lang.NewKeyword("end-line"), int(1618))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("commute")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("boolean")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("*loaded-libs*")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v6 := v5.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("ident?")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v29 := v28.Get() -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("conj")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v3}) +var v7 any = v11 +_ = v7 +var v13 any +if lang.IsTruthy(v7) { +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("namespace")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } -v32 := v31.Get() -v33 := lang.Apply(v26, []any{v29, v32, v3}) -return v33 -}) -v24, _ := lang.FieldOrMethod(lang1.LockingTransaction, "RunInTransaction") -if reflect.TypeOf(v24).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("RunInTransaction is not a function"))) +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v3}) +var v14 any = v18 +_ = v14 +var v20 any +if lang.IsTruthy(v14) { +v20 = true +} else { +v20 = v14 } -v25 := lang.Apply(v24, []any{v23}) -v22 = v25 +v13 = v20 } else { -v22 = nil +v13 = v7 } -return v22 +v7 := lang.Apply(v6, []any{v13}) +return v7 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -63006,38 +63202,53 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// atom +// qualified-keyword? { -v0 := lang.NewSymbol("atom").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Creates and returns an Atom with an initial value of x and zero or\n more options (in any order):\n\n :meta metadata-map\n\n :validator validate-fn\n\n If metadata-map is supplied, it will become the metadata on the\n atom. validate-fn must be nil or a side-effect-free fn of one\n argument, which will be passed the intended new state on any state\n change. If the new state is unacceptable, the validate-fn should\n return false or throw an exception.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2325), lang.NewKeyword("end-line"), int(2325))).(*lang.Symbol) +v0 := lang.NewSymbol("qualified-keyword?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a keyword with a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1638), lang.NewKeyword("end-line"), int(1638))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -v4 := lang.Apply(lang1.NewAtom, []any{v3}) -return v4 - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] -v4 := lang.NewList(args[1:]...) -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("setup-reference")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("boolean")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v7 := v6.Get() +v6 := v5.Get() v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("atom")) +v9 := v8.FindInternedVar(lang.NewSymbol("keyword?")) if v9.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } v10 := v9.Get() v11 := lang.Apply(v10, []any{v3}) -v12 := lang.Apply(v7, []any{v11, v4}) -return v12 - } +var v7 any = v11 +_ = v7 +var v13 any +if lang.IsTruthy(v7) { +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("namespace")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v3}) +var v14 any = v18 +_ = v14 +var v20 any +if lang.IsTruthy(v14) { +v20 = true +} else { +v20 = v14 +} +v13 = v20 +} else { +v13 = v7 +} +v7 := lang.Apply(v6, []any{v13}) +return v7 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -63045,25 +63256,53 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// *err* -{ -v0 := lang.NewSymbol("*err*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "A java.io.Writer object representing standard error for print operations.\n\n Defaults to System/err, wrapped in a PrintWriter", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, nil, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// enumeration-seq +// qualified-symbol? { -v0 := lang.NewSymbol("enumeration-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("e"))), lang.NewKeyword("doc"), "Returns a seq on a java.util.Enumeration", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5753), lang.NewKeyword("end-line"), int(5753))).(*lang.Symbol) +v0 := lang.NewSymbol("qualified-symbol?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a symbol with a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1628), lang.NewKeyword("end-line"), int(1628))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := lang.Apply(nil, []any{v3}) -return v4 +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("boolean")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("symbol?")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v3}) +var v7 any = v11 +_ = v7 +var v13 any +if lang.IsTruthy(v7) { +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("namespace")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v3}) +var v14 any = v18 +_ = v14 +var v20 any +if lang.IsTruthy(v14) { +v20 = true +} else { +v20 = v14 +} +v13 = v20 +} else { +v13 = v7 +} +v7 := lang.Apply(v6, []any{v13}) +return v7 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -63071,353 +63310,210 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// while +// quot { -v0 := lang.NewSymbol("while").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("test"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Repeatedly executes body while test expression is true. Presumes\n some side-effect will cause test to become false/nil. Returns nil", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6370), lang.NewKeyword("end-line"), int(6370))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } +var v1 lang.FnFunc +{ // function quot__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("seq")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("concat")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("concat")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("list")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("list")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v15 := v14.Get() -v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/loop")}) -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("list")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +v13 := v12.Get() +v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("apply")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("vector")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("seq")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("seq")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("concat")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("concat")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("list")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } -v31 := v30.Get() -v32 := lang.Apply(v31, nil) -v33 := lang.Apply(v28, []any{v32}) -v34 := lang.Apply(v22, []any{v25, v33}) -v35 := lang.Apply(v19, []any{v34}) +v30 := v29.Get() +v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/quotient")}) +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v37 := v36.FindInternedVar(lang.NewSymbol("list")) if v37.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) } v38 := v37.Get() -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("seq")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) -} -v41 := v40.Get() -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("concat")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) -} -v44 := v43.Get() -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("list")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.Apply(v47, []any{lang.NewSymbol("glojure.core/when")}) -v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v50 := v49.FindInternedVar(lang.NewSymbol("list")) -if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) -} -v51 := v50.Get() -v52 := lang.Apply(v51, []any{v5}) -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("list")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) -} -v55 := v54.Get() -v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v57 := v56.FindInternedVar(lang.NewSymbol("seq")) -if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) -} -v58 := v57.Get() -v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v60 := v59.FindInternedVar(lang.NewSymbol("concat")) -if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) -} -v61 := v60.Get() -v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v63 := v62.FindInternedVar(lang.NewSymbol("list")) -if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +v39 := lang.Apply(v38, []any{v4}) +v40 := lang.Apply(v27, []any{v31, v35, v39}) +v41 := lang.Apply(v24, []any{v40}) +v42 := lang.Apply(v21, []any{v41}) +v43 := lang.Apply(v10, []any{v14, v18, v42}) +v44 := lang.Apply(v7, []any{v43}) +return v44 +}) +v2 := v1 +_ = v2 } -v64 := v63.Get() -v65 := lang.Apply(v64, []any{lang.NewSymbol("recur")}) -v66 := lang.Apply(v61, []any{v65}) -v67 := lang.Apply(v58, []any{v66}) -v68 := lang.Apply(v55, []any{v67}) -v69 := lang.Apply(v44, []any{v48, v52, v6, v68}) -v70 := lang.Apply(v41, []any{v69}) -v71 := lang.Apply(v38, []any{v70}) -v72 := lang.Apply(v12, []any{v16, v35, v71}) -v73 := lang.Apply(v9, []any{v72}) -return v73 +v0 := lang.NewSymbol("quot").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"), lang.NewSymbol("div"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "quot[ient] of dividing numerator by denominator.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1266), lang.NewKeyword("end-line"), int(1266))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } +v4 := args[0] +v5 := args[1] +v6, _ := lang.FieldOrMethod(lang1.Numbers, "quotient") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("quotient is not a function"))) +} +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// meta +// rand { -v0 := lang.NewSymbol("meta").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("obj"))), lang.NewKeyword("doc"), "Returns the metadata of obj, returns nil if there is no metadata.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(202), lang.NewKeyword("end-line"), int(206))).(*lang.Symbol) +v0 := lang.NewSymbol("rand").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns a random floating point number between 0 (inclusive) and\n n (default 1) (exclusive).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4935), lang.NewKeyword("end-line"), int(4935))).(*lang.Symbol) var v2 lang.FnFunc -{ // function meta v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{lang1.IMeta, v4}) -if lang.IsTruthy(v9) { -v10, ok := lang.FieldOrMethod(v4, "Meta") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "Meta"))) -} -var v11 any -switch reflect.TypeOf(v10).Kind() { -case reflect.Func: - v11 = lang.Apply(v10, nil) -default: - v11 = v10 + switch len(args) { + case 0: +v3 := lang.Apply(rand30.Float64, nil) +return v3 + case 1: +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("*")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v5 = v11 -} else { -v5 = nil +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("rand")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -return v5 +v9 := v8.Get() +v10 := lang.Apply(v9, nil) +v11 := lang.Apply(v6, []any{v3, v10}) +return v11 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(206), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(208), lang.NewKeyword("end-column"), int(21))).(lang.FnFunc) -v3 := v2 -_ = v3 -} +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// dec' +// rand-int { -var v1 lang.FnFunc -{ // function dec'__inliner -v1 = lang.NewFnFunc(func(args ...any) any { +v0 := lang.NewSymbol("rand-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns a random integer between 0 (inclusive) and n (exclusive).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4943), lang.NewKeyword("end-line"), int(4943))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +v5 := v4.FindInternedVar(lang.NewSymbol("int")) if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +v8 := v7.FindInternedVar(lang.NewSymbol("rand")) if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/decP")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v3}) -v35 := lang.Apply(v26, []any{v30, v34}) -v36 := lang.Apply(v23, []any{v35}) -v37 := lang.Apply(v20, []any{v36}) -v38 := lang.Apply(v9, []any{v13, v17, v37}) -v39 := lang.Apply(v6, []any{v38}) -return v39 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("dec'").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns a number one less than num. Supports arbitrary precision.\n See also: dec", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1140), lang.NewKeyword("end-line"), int(1140))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "decP") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("decP is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v6 := lang.Apply(v5, []any{v4}) -return v6 +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v3}) +v11 := lang.Apply(v6, []any{v10}) +return v11 }) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// into1 +// rand-nth { -v0 := lang.NewSymbol("into1").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("from"))), lang.NewKeyword("doc"), "Returns a new coll consisting of to-coll with all of the items of\n from-coll conjoined.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3416), lang.NewKeyword("end-line"), int(3416), lang.NewKeyword("private"), true)).(*lang.Symbol) +v0 := lang.NewSymbol("rand-nth").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return a random element of the (sequential) collection. Will have\n the same performance characteristics as nth for the given\n collection.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7256), lang.NewKeyword("end-line"), int(7256))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := args[1] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("nth")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v8 := v7.Get() -v9 := lang.Apply(v8, []any{lang1.IEditableCollection, v3}) -if lang.IsTruthy(v9) { +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("rand-int")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("persistent!")) +v11 := v10.FindInternedVar(lang.NewSymbol("count")) if v11.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("reduce1")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("conj!")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("transient")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v3}) -v23 := lang.Apply(v15, []any{v18, v22, v4}) -v24 := lang.Apply(v12, []any{v23}) -v5 = v24 -} else { -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("reduce1")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("conj")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v27, []any{v30, v3, v4}) -v5 = v31 -} -return v5 +v13 := lang.Apply(v12, []any{v3}) +v14 := lang.Apply(v9, []any{v13}) +v15 := lang.Apply(v6, []any{v3, v14}) +return v15 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -63425,60 +63521,89 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// println +// random-sample { -v0 := lang.NewSymbol("println").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Same as print followed by (newline)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3734), lang.NewKeyword("end-line"), int(3734))).(*lang.Symbol) +v0 := lang.NewSymbol("random-sample").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("prob")), lang.NewVector(lang.NewSymbol("prob"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns items from coll with random probability of prob (0.0 -\n 1.0). Returns a transducer when no collection is provided.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7742), lang.NewKeyword("end-line"), int(7742))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewList(args[0:]...) + case 1: +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("filter")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +var v7 lang.FnFunc +v7 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v8 := args[0] +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("<")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("rand")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, nil) +v16 := lang.Apply(v11, []any{v15, v3}) +return v16 +}) +v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7747), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(7747), lang.NewKeyword("end-column"), int(37)) +v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v10 := lang.Apply(v6, []any{v9}) +return v10 + case 2: +v3 := args[0] +v4 := args[1] v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("push-thread-bindings")) +v6 := v5.FindInternedVar(lang.NewSymbol("filter")) if v6.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("hash-map")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*print-readably*")) -v12 := lang.Apply(v10, []any{v11, nil}) -v13 := lang.Apply(v7, []any{v12}) -_ = v13 -var v14 any -func() { -defer func() { -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +var v8 lang.FnFunc +v8 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v9 := args[0] +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("<")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v17 := v16.Get() -v18 := lang.Apply(v17, nil) -}() -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("apply")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("rand")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("prn")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v15 := v14.Get() +v16 := lang.Apply(v15, nil) +v17 := lang.Apply(v12, []any{v16, v3}) +return v17 +}) +v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7749), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(7749), lang.NewKeyword("end-column"), int(37)) +v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v24 := v23.Get() -v25 := lang.Apply(v21, []any{v24, v3}) -v14 = v25 -}() -return v14 +v11 := lang.Apply(v7, []any{v10, v4}) +return v11 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -63487,248 +63612,173 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// drop +// random-uuid { -v0 := lang.NewSymbol("drop").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a laziness-preserving sequence of all but the first n items in coll.\n Returns a stateful transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2901), lang.NewKeyword("end-line"), int(2901))).(*lang.Symbol) +v0 := lang.NewSymbol("random-uuid").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Returns a pseudo-randomly generated java.util.UUID instance (i.e. type 4).\n\n See: https://docs.oracle.com/javase/8/docs/api/java/util/UUID.html#randomUUID--", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6895), lang.NewKeyword("end-line"), int(6895))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { + if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v5 := args[0] -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("volatile!")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v3 := lang.Apply(nil, nil) +return v3 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v3}) -var v6 any = v10 -_ = v6 -var v12 lang.FnFunc -v12 = lang.NewFnFunc(func(args ...any) any { +} +// range +{ +v0 := lang.NewSymbol("range").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("end")), lang.NewVector(lang.NewSymbol("start"), lang.NewSymbol("end")), lang.NewVector(lang.NewSymbol("start"), lang.NewSymbol("end"), lang.NewSymbol("step"))), lang.NewKeyword("doc"), "Returns a lazy seq of nums from start (inclusive) to end\n (exclusive), by step, where start defaults to 0, step to 1, and end to\n infinity. When step is equal to 0, returns an infinite sequence of\n start. When start is equal to end, returns empty list.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3018), lang.NewKeyword("end-line"), int(3018))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: -v13 := lang.Apply(v5, nil) -return v13 - case 1: -v13 := args[0] -v14 := lang.Apply(v5, []any{v13}) -return v14 - case 2: -v13 := args[0] -v14 := args[1] -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("deref")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v6}) -var v15 any = v19 -_ = v15 -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("dec")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24, ok := lang.FieldOrMethod(v6, "Deref") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "Deref"))) -} -var v25 any -switch reflect.TypeOf(v24).Kind() { -case reflect.Func: - v25 = lang.Apply(v24, nil) -default: - v25 = v24 +v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v4 := v3.FindInternedVar(lang.NewSymbol("iterate")) +if v4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) } -v26 := lang.Apply(v23, []any{v25}) -v27, _ := lang.FieldOrMethod(v6, "reset") -if reflect.TypeOf(v27).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) +v5 := v4.Get() +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("inc'")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v28 := lang.Apply(v27, []any{v26}) -_ = v28 -var v29 any -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("pos?")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +v8 := v7.Get() +v9 := lang.Apply(v5, []any{v8, int64(0)}) +return v9 + case 1: +v3 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("int?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v32 := v31.Get() -v33 := lang.Apply(v32, []any{v15}) -if lang.IsTruthy(v33) { -v29 = v13 +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +if lang.IsTruthy(v8) { +v9 := lang.Apply(lang1.NewLongRange, []any{int64(0), v3, int64(1)}) +v4 = v9 } else { -v34 := lang.Apply(v5, []any{v13, v14}) -v29 = v34 -} -return v29 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2909), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(2917), lang.NewKeyword("end-column"), int(39)) -v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v14 -}) -v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2907), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2917), lang.NewKeyword("end-column"), int(41)) -v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) -if err != nil { - panic(err) +v10 := lang.Apply(lang1.NewRange, []any{int64(0), v3, int64(1)}) +v4 = v10 } -return v6 +return v4 case 2: v3 := args[0] v4 := args[1] var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{lang1.IDrop, v4}) -if lang.IsTruthy(v9) { -var v11 any -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("pos?")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("int?")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v3}) -if lang.IsTruthy(v15) { -var v16 any -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("int?")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v3}) +var v6 any = v10 +_ = v6 +var v12 any +if lang.IsTruthy(v6) { +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("int?")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v3}) -if lang.IsTruthy(v20) { -v16 = v3 +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v4}) +v12 = v16 } else { -v21 := lang.Apply(nil, []any{v3}) -v16 = v21 -} -v22, _ := lang.FieldOrMethod(v4, "drop") -if reflect.TypeOf(v22).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("drop is not a function"))) +v12 = v6 } -v23 := lang.Apply(v22, []any{v16}) -v11 = v23 +if lang.IsTruthy(v12) { +v6 := lang.Apply(lang1.NewLongRange, []any{v3, v4, int64(1)}) +v5 = v6 } else { -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("seq")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v4}) -v11 = v27 +v7 := lang.Apply(lang1.NewRange, []any{v3, v4, int64(1)}) +v5 = v7 } -var v10 any = v11 -_ = v10 -var v29 any -if lang.IsTruthy(v10) { -v29 = v10 -} else { -v29 = lang.NewList() +return v5 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +var v6 any +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("int?")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v5 = v29 -} else { -var v11 lang.FnFunc -v11 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v12 := args[0] -v13 := args[1] -recur_loop_539: +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v3}) +var v7 any = v11 +_ = v7 +var v13 any +if lang.IsTruthy(v7) { v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("seq")) +v16 := v15.FindInternedVar(lang.NewSymbol("int?")) if v16.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } v17 := v16.Get() -v18 := lang.Apply(v17, []any{v13}) +v18 := lang.Apply(v17, []any{v4}) var v14 any = v18 _ = v14 var v20 any -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("pos?")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +if lang.IsTruthy(v14) { +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("int?")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v12}) -var v21 any = v25 -_ = v21 -var v27 any -if lang.IsTruthy(v21) { -v27 = v14 +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v5}) +v20 = v24 } else { -v27 = v21 -} -if lang.IsTruthy(v27) { -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("dec")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v20 = v14 } -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v12}) -var v21 any = v25 -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("rest")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v13 = v20 +} else { +v13 = v7 } -v29 := v28.Get() -v30 := lang.Apply(v29, []any{v14}) -var v26 any = v30 -v12 = v21 -v13 = v26 -goto recur_loop_539 +if lang.IsTruthy(v13) { +v7 := lang.Apply(lang1.NewLongRange, []any{v3, v4, v5}) +v6 = v7 } else { -v20 = v14 +v8 := lang.Apply(lang1.NewRange, []any{v3, v4, v5}) +v6 = v8 } -return v20 +return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } }) -v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2925), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(2929), lang.NewKeyword("end-column"), int(28)) -v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) -if err != nil { - panic(err) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -var v10 any = v13 -_ = v10 -var v15 lang.FnFunc -v15 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { +} +// ratio? +{ +v0 := lang.NewSymbol("ratio?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is a Ratio", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3577), lang.NewKeyword("end-line"), int(3577))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v16 := lang.Apply(v10, []any{v3, v4}) -return v16 -}) -v16 := lang.Apply(lang1.NewLazySeq, []any{v15}) -v5 = v16 +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -return v5 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } +v6 := v5.Get() +v7 := lang.Apply(v6, []any{lang1.*Ratio, v3}) +return v7 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -63736,52 +63786,53 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// the-ns +// rational? { -v0 := lang.NewSymbol("the-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "If passed a namespace, returns it. Else, when passed a symbol,\n returns the namespace named by it, throwing an exception if not\n found.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4152), lang.NewKeyword("end-line"), int(4152))).(*lang.Symbol) +v0 := lang.NewSymbol("rational?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is a rational number", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3613), lang.NewKeyword("end-line"), int(3613))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -var v4 any v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) +v6 := v5.FindInternedVar(lang.NewSymbol("integer?")) if v6.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } v7 := v6.Get() -v8 := lang.Apply(v7, []any{lang1.*Namespace, v3}) -if lang.IsTruthy(v8) { -v4 = v3 +v8 := lang.Apply(v7, []any{v3}) +var v4 any = v8 +_ = v4 +var v10 any +if lang.IsTruthy(v4) { +v10 = v4 } else { -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("find-ns")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("ratio?")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } -v12 := v11.Get() -v13 := lang.Apply(v12, []any{v3}) -var v9 any = v13 -_ = v9 -var v15 any -if lang.IsTruthy(v9) { -v15 = v9 +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v3}) +var v11 any = v15 +_ = v11 +var v17 any +if lang.IsTruthy(v11) { +v17 = v11 } else { -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("str")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("decimal?")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v18 := v17.Get() -v19 := lang.Apply(v18, []any{"No namespace: ", v3, " found"}) -v20 := lang.Apply(Exception24., []any{v19}) -panic(v20) +v20 := v19.Get() +v21 := lang.Apply(v20, []any{v3}) +v17 = v21 } -v4 = v15 +v10 = v17 } -return v4 +return v10 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -63789,17 +63840,21 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// descriptor +// rationalize { -v0 := lang.NewSymbol("descriptor").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5482), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(5482), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v0 := lang.NewSymbol("rationalize").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("doc"), "returns the rational value of num", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1282), lang.NewKeyword("end-line"), int(1282))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := lang.Apply(nil, []any{v3}) -return v4 +v4, _ := lang.FieldOrMethod(lang1.Numbers, "rationalize") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("rationalize is not a function"))) +} +v5 := lang.Apply(v4, []any{v3}) +return v5 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -63807,257 +63862,326 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// process-annotation +// re-find { -v0 := lang.NewSymbol("process-annotation").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5505), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(5505), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("av"), lang.NewSymbol("v"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v0 := lang.NewSymbol("re-find").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m")), lang.NewVector(lang.NewSymbol("re"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns the next regex match, if any, of string to pattern, using\n java.util.regex.Matcher.find(). Uses re-groups to return the\n groups.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4922), lang.NewKeyword("end-line"), int(4922))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + switch len(args) { + case 1: +v3 := args[0] +var v4 any +v5, _ := lang.FieldOrMethod(v3, "find") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("find is not a function"))) +} +v6 := lang.Apply(v5, []any{}) +if lang.IsTruthy(v6) { +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("re-groups")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v3}) +v4 = v10 +} else { +v4 = nil +} +return v4 + case 2: v3 := args[0] v4 := args[1] -var v5 any v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("map?")) +v7 := v6.FindInternedVar(lang.NewSymbol("re-matcher")) if v7.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } v8 := v7.Get() -v9 := lang.Apply(v8, []any{v4}) -if lang.IsTruthy(v9) { +v9 := lang.Apply(v8, []any{v3, v4}) +var v5 any = v9 +_ = v5 v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("seq")) +v12 := v11.FindInternedVar(lang.NewSymbol("re-find")) if v12.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } v13 := v12.Get() -v14 := lang.Apply(v13, []any{v4}) -var v10 any = v14 -_ = v10 -var v15 any = nil -_ = v15 -var v16 any = int64(0) -_ = v16 -var v17 any = int64(0) -_ = v17 -var v18 any -for { -var v19 any -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("<")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +v14 := lang.Apply(v13, []any{v5}) +return v14 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v22 := v21.Get() -v23 := lang.Apply(v22, []any{v17, v16}) -if lang.IsTruthy(v23) { -v25, _ := lang.FieldOrMethod(v15, "nth") -if reflect.TypeOf(v25).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) } -v26 := lang.Apply(v25, []any{v17}) -var v24 any = v26 -_ = v24 -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("nth")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +// re-groups +{ +v0 := lang.NewSymbol("re-groups").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"))), lang.NewKeyword("doc"), "Returns the groups from the most recent match/find. If there are no\n nested groups, returns a string of the entire match. If there are\n nested groups, returns a vector of the groups, the first element\n being the entire match.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4882), lang.NewKeyword("end-line"), int(4882))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v5, _ := lang.FieldOrMethod(v3, "groupCount") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("groupCount is not a function"))) } -v30 := v29.Get() -v31 := lang.Apply(v30, []any{v24, int64(0), nil}) -var v27 any = v31 -_ = v27 -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("nth")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +v6 := lang.Apply(v5, []any{}) +var v4 any = v6 +_ = v4 +var v8 any +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("zero?")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v24, int64(1), nil}) -var v32 any = v36 -_ = v32 -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("add-annotation")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v4}) +if lang.IsTruthy(v12) { +v13, _ := lang.FieldOrMethod(v3, "group") +if reflect.TypeOf(v13).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("group is not a function"))) } -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("name")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +v14 := lang.Apply(v13, []any{}) +v8 = v14 +} else { +v16 := lang.NewVector() +v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4893), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(4893), lang.NewKeyword("end-column"), int(21)) +v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v27}) -v45 := lang.Apply(v40, []any{v3, v44, v32}) -_ = v45 -var v46 any = v10 -var v47 any = v15 -var v48 any = v16 -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("unchecked-inc")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +var v15 any = v18 +_ = v15 +var v19 any = int64(0) +_ = v19 +var v20 any +for { +var v21 any +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("<=")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -v52 := v51.Get() -v53 := lang.Apply(v52, []any{v17}) -var v49 any = v53 -v10 = v46 -v15 = v47 -v16 = v48 -v17 = v49 -continue -} else { -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("seq")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v19, v4}) +if lang.IsTruthy(v25) { +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("conj")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v27 := v26.Get() -v28 := lang.Apply(v27, []any{v10}) -var v24 any = v28 -_ = v24 -var v30 any -if lang.IsTruthy(v24) { -var v31 any = v24 -_ = v31 -var v33 any +v29 := v28.Get() +v30, _ := lang.FieldOrMethod(v3, "groupInt") +if reflect.TypeOf(v30).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("groupInt is not a function"))) +} +v31 := lang.Apply(v30, []any{v19}) +v32 := lang.Apply(v29, []any{v15, v31}) +var v26 any = v32 v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("chunked-seq?")) +v35 := v34.FindInternedVar(lang.NewSymbol("inc")) if v35.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } v36 := v35.Get() -v37 := lang.Apply(v36, []any{v31}) -if lang.IsTruthy(v37) { -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("chunk-first")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +v37 := lang.Apply(v36, []any{v19}) +var v33 any = v37 +v15 = v26 +v19 = v33 +continue +} else { +v21 = v15 } -v41 := v40.Get() -v42 := lang.Apply(v41, []any{v31}) -var v38 any = v42 -_ = v38 -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("chunk-rest")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +v20 = v21 + break } -v47 := v46.Get() -v48 := lang.Apply(v47, []any{v31}) -var v44 any = v48 -var v49 any = v38 -v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v52 := v51.FindInternedVar(lang.NewSymbol("int")) -if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) +v8 = v20 } -v53 := v52.Get() -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("count")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +return v8 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v56 := v55.Get() -v57 := lang.Apply(v56, []any{v38}) -v58 := lang.Apply(v53, []any{v57}) -var v50 any = v58 -v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v61 := v60.FindInternedVar(lang.NewSymbol("int")) -if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) } -v62 := v61.Get() -v63 := lang.Apply(v62, []any{int64(0)}) -var v59 any = v63 -v10 = v44 -v15 = v49 -v16 = v50 -v17 = v59 -continue -} else { -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("first")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +// re-matcher +{ +v1 := reflect.TypeOf((*lang1.RegexpMatcher)(nil)) +v0 := lang.NewSymbol("re-matcher").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("re"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns an instance of java.util.regex.Matcher, for use, e.g. in\n re-find.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4873), lang.NewKeyword("end-line"), int(4873))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := args[1] +v6 := lang.Apply(lang1.NewRegexpMatcher, []any{v4, v5}) +return v6 +}) +v4 := reflect.TypeOf((*lang1.RegexpMatcher)(nil)) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v41 := v40.Get() -v42 := lang.Apply(v41, []any{v31}) -var v38 any = v42 -_ = v38 -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("nth")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v38, int64(0), nil}) -var v43 any = v47 -_ = v43 -v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v50 := v49.FindInternedVar(lang.NewSymbol("nth")) -if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) +// re-matches +{ +v0 := lang.NewSymbol("re-matches").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("re"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns the match, if any, of string to pattern, using\n java.util.regex.Matcher.matches(). Uses re-groups to return the\n groups.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4910), lang.NewKeyword("end-line"), int(4910))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("re-matcher")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v51 := v50.Get() -v52 := lang.Apply(v51, []any{v38, int64(1), nil}) -var v48 any = v52 -_ = v48 -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("add-annotation")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v3, v4}) +var v5 any = v9 +_ = v5 +var v11 any +v12, _ := lang.FieldOrMethod(v5, "matches") +if reflect.TypeOf(v12).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("matches is not a function"))) } -v56 := v55.Get() -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("name")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +v13 := lang.Apply(v12, []any{}) +if lang.IsTruthy(v13) { +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("re-groups")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v59 := v58.Get() -v60 := lang.Apply(v59, []any{v43}) -v61 := lang.Apply(v56, []any{v3, v60, v48}) -_ = v61 -v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v64 := v63.FindInternedVar(lang.NewSymbol("next")) -if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v5}) +v11 = v17 +} else { +v11 = nil } -v65 := v64.Get() -v66 := lang.Apply(v65, []any{v31}) -var v62 any = v66 -var v67 any = nil -var v68 any = int64(0) -var v69 any = int64(0) -v10 = v62 -v15 = v67 -v16 = v68 -v17 = v69 -continue +return v11 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v30 = v33 +} +// re-pattern +{ +v1 := reflect.TypeOf((*regexp31.Regexp)(nil)) +v0 := lang.NewSymbol("re-pattern").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns an instance of java.util.regex.Pattern, for use, e.g. in\n re-matcher.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4863), lang.NewKeyword("end-line"), int(4863))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{regexp31.*Regexp, v4}) +if lang.IsTruthy(v9) { +v5 = v4 } else { -v30 = nil +v10 := lang.Apply(regexp31.MustCompile, []any{v4}) +v5 = v10 } -v19 = v30 +return v5 +}) +v4 := reflect.TypeOf((*regexp31.Regexp)(nil)) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v18 = v19 - break } -v5 = v18 +// re-seq +{ +v0 := lang.NewSymbol("re-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("re"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns a lazy sequence of successive matches of pattern in string,\n using java.util.regex.Matcher.find(), each such match processed with\n re-groups.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4898), lang.NewKeyword("end-line"), int(4898))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("re-matcher")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v3, v4}) +var v5 any = v9 +_ = v5 +var v11 lang.FnFunc +{ // function step +v11 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +var v13 any +v14, _ := lang.FieldOrMethod(v5, "find") +if reflect.TypeOf(v14).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("find is not a function"))) +} +v15 := lang.Apply(v14, []any{}) +if lang.IsTruthy(v15) { +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("cons")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("re-groups")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v5}) +var v23 lang.FnFunc +v23 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v24 := lang.Apply(v12, nil) +return v24 +}) +v24 := lang.Apply(lang1.NewLazySeq, []any{v23}) +v25 := lang.Apply(v18, []any{v22, v24}) +v13 = v25 } else { -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("add-annotation")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v13 = nil } -v12 := v11.Get() -v13 := lang.Apply(v12, []any{v3, "value", v4}) -v5 = v13 +return v13 +}) +v12 := v11 +_ = v12 } -return v5 +v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4906), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(4908), lang.NewKeyword("end-column"), int(49)) +v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v14 := lang.Apply(v13, nil) +return v14 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -64065,868 +64189,719 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// / +// read { -var v1 lang.FnFunc -v1 = lang.NewFnFunc(func(args ...any) any { +v0 := lang.NewSymbol("read").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("stream")), lang.NewVector(lang.NewSymbol("stream"), lang.NewSymbol("eof-error?"), lang.NewSymbol("eof-value")), lang.NewVector(lang.NewSymbol("stream"), lang.NewSymbol("eof-error?"), lang.NewSymbol("eof-value"), lang.NewSymbol("recursive?")), lang.NewVector(lang.NewSymbol("opts"), lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Reads the next object from stream, which must be an instance of\n java.io.PushbackReader or some derivee. stream defaults to the\n current value of *in*.\n\n Opts is a persistent map with valid keys:\n :read-cond - :allow to process reader conditionals, or\n :preserve to keep all branches\n :features - persistent set of feature keywords for reader conditionals\n :eof - on eof, return value unless :eofthrow, then throw.\n if not specified, will throw\n\n Note that read can execute code (controlled by *read-eval*),\n and as such should be used only with trusted sources.\n\n For data structure interop use glojure.edn/read", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3742), lang.NewKeyword("end-line"), int(3742))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 1: -v2 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -if lang.IsTruthy(v7) { -v4 = closed15 -} else { -v4 = v3 + case 0: +v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v4 := v3.FindInternedVar(lang.NewSymbol("read")) +if v4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) } -var v3 any = v4 -_ = v3 -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("seq")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +v5 := v4.Get() +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("*in*")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("concat")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +v8 := v7.Get() +v9 := lang.Apply(v5, []any{v8}) +return v9 + case 1: +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("read")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +v6 := v5.Get() +v7 := lang.Apply(v6, []any{v3, true, nil}) +return v7 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("read")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v3, v4, v5, false}) +return v9 + case 4: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("boolean")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v21 := v20.Get() -v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v4}) +v11, _ := lang.FieldOrMethod(glojure.lang8.LispReader, "read") +if reflect.TypeOf(v11).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("read is not a function"))) } -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("seq")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +v12 := lang.Apply(v11, []any{v3, v10, v5, v6}) +return v12 + case 2: +v3 := args[0] +v4 := args[1] +v5, _ := lang.FieldOrMethod(glojure.lang8.LispReader, "read") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("read is not a function"))) } -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("concat")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +v6 := lang.Apply(v5, []any{v4, v3}) +return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) } -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +// read+string +{ +v0 := lang.NewSymbol("read+string").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("stream")), lang.NewVector(lang.NewSymbol("stream"), lang.NewSymbol("eof-error?"), lang.NewSymbol("eof-value")), lang.NewVector(lang.NewSymbol("stream"), lang.NewSymbol("eof-error?"), lang.NewSymbol("eof-value"), lang.NewSymbol("recursive?")), lang.NewVector(lang.NewSymbol("opts"), lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Like read, and taking the same args. stream must be a LineNumberingPushbackReader.\n Returns a vector containing the object read and the (whitespace-trimmed) string read.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3771), lang.NewKeyword("end-line"), int(3771))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v4 := v3.FindInternedVar(lang.NewSymbol("read+string")) +if v4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) } -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v2}) -v40 := lang.Apply(v31, []any{v35, v39}) -v41 := lang.Apply(v28, []any{v40}) -v42 := lang.Apply(v25, []any{v41}) -v43 := lang.Apply(v14, []any{v18, v22, v42}) -v44 := lang.Apply(v11, []any{v43}) -return v44 - case 2: -v2 := args[0] -v3 := args[1] -var v5 any +v5 := v4.Get() v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +v7 := v6.FindInternedVar(lang.NewSymbol("*in*")) if v7.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } v8 := v7.Get() -if lang.IsTruthy(v8) { -v5 = closed15 -} else { -v5 = v4 -} -var v4 any = v5 -_ = v4 -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("seq")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("concat")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("list")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("list")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("list")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +v9 := lang.Apply(v5, []any{v8}) +return v9 + case 1: +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("read+string")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("seq")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v6 := v5.Get() +v7 := lang.Apply(v6, []any{v3, true, nil}) +return v7 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("read+string")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v29 := v28.Get() -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("concat")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v3, v4, v5, false}) +return v9 + case 4: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +var v7 any +func() { +defer func() { +if r := recover(); r != nil { +if lang.CatchMatches(r, lang1.Throwable) { +v8 := r +_ = v8 +v9, ok := lang.FieldOrMethod(v3, "getString") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getString"))) } -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("list")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +var v10 any +switch reflect.TypeOf(v9).Kind() { +case reflect.Func: + v10 = lang.Apply(v9, nil) +default: + v10 = v9 } -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v4}) -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("list")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +_ = v10 +panic(v8) +} else { +panic(r) } -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v2}) -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("list")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v3}) -v45 := lang.Apply(v32, []any{v36, v40, v44}) -v46 := lang.Apply(v29, []any{v45}) -v47 := lang.Apply(v26, []any{v46}) -v48 := lang.Apply(v15, []any{v19, v23, v47}) -v49 := lang.Apply(v12, []any{v48}) -return v49 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v2 := args[0] -v3 := args[1] -v4 := lang.NewList(args[2:]...) -var v6 any -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +}() +v8, ok := lang.FieldOrMethod(v3, "captureString") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "captureString"))) } -v9 := v8.Get() -if lang.IsTruthy(v9) { -v6 = closed15 -} else { -v6 = v5 +var v9 any +switch reflect.TypeOf(v8).Kind() { +case reflect.Func: + v9 = lang.Apply(v8, nil) +default: + v9 = v8 } -var v5 any = v6 -_ = v5 +_ = v9 v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) +v12 := v11.FindInternedVar(lang.NewSymbol("read")) if v12.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } v13 := v12.Get() -var v14 lang.FnFunc -v14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v15 := args[0] -v16 := args[1] -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("concat")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +v14 := lang.Apply(v13, []any{v3, v4, v5, v6}) +var v10 any = v14 +_ = v10 +v16, ok := lang.FieldOrMethod(v3, "getString") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getString"))) } -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +var v17 any +switch reflect.TypeOf(v16).Kind() { +case reflect.Func: + v17 = lang.Apply(v16, nil) +default: + v17 = v16 } -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v5}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +v18, ok := lang.FieldOrMethod(v17, "trim") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v17, "trim"))) } -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v15}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +var v19 any +switch reflect.TypeOf(v18).Kind() { +case reflect.Func: + v19 = lang.Apply(v18, nil) +default: + v19 = v18 } -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v16}) -v52 := lang.Apply(v39, []any{v43, v47, v51}) -v53 := lang.Apply(v36, []any{v52}) -v54 := lang.Apply(v33, []any{v53}) -v55 := lang.Apply(v22, []any{v26, v30, v54}) -v56 := lang.Apply(v19, []any{v55}) -return v56 -}) -v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) -v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) +var v15 any = v19 +_ = v15 +v21 := lang.NewVector(v10, v15) +v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3783), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(3783), lang.NewKeyword("end-column"), int(12)) +v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) if err != nil { panic(err) } -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +v7 = v23 +}() +return v7 + case 2: +v3 := args[0] +v4 := args[1] +var v5 any +func() { +defer func() { +if r := recover(); r != nil { +if lang.CatchMatches(r, lang1.Throwable) { +v6 := r +_ = v6 +v7, ok := lang.FieldOrMethod(v4, "getString") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "getString"))) } -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("concat")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +var v8 any +switch reflect.TypeOf(v7).Kind() { +case reflect.Func: + v8 = lang.Apply(v7, nil) +default: + v8 = v7 } -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +_ = v8 +panic(v6) +} else { +panic(r) } -v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +}() +v6, ok := lang.FieldOrMethod(v4, "captureString") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "captureString"))) +} +var v7 any +switch reflect.TypeOf(v6).Kind() { +case reflect.Func: + v7 = lang.Apply(v6, nil) +default: + v7 = v6 +} +_ = v7 +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("read")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v3, v4}) +var v8 any = v12 +_ = v8 +v14, ok := lang.FieldOrMethod(v4, "getString") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "getString"))) } -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +var v15 any +switch reflect.TypeOf(v14).Kind() { +case reflect.Func: + v15 = lang.Apply(v14, nil) +default: + v15 = v14 } -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +v16, ok := lang.FieldOrMethod(v15, "trim") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v15, "trim"))) } -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v5}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +var v17 any +switch reflect.TypeOf(v16).Kind() { +case reflect.Func: + v17 = lang.Apply(v16, nil) +default: + v17 = v16 } -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v2}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +var v13 any = v17 +_ = v13 +v19 := lang.NewVector(v8, v13) +v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3792), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(3792), lang.NewKeyword("end-column"), int(12)) +v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v3}) -v52 := lang.Apply(v39, []any{v43, v47, v51}) -v53 := lang.Apply(v36, []any{v52}) -v54 := lang.Apply(v33, []any{v53}) -v55 := lang.Apply(v22, []any{v26, v30, v54}) -v56 := lang.Apply(v19, []any{v55}) -v57 := lang.Apply(v13, []any{v16, v56, v4}) -return v57 +v5 = v21 +}() +return v5 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) -v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// read-line +{ +v0 := lang.NewSymbol("read-line").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Reads the next line from stream that is the current value of *in* .", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3797), lang.NewKeyword("end-line"), int(3797))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { + if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := args[0] -v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) -} -v5 := lang.Apply(v4, []any{v3, int64(1)}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v0 := lang.NewSymbol("/").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "If no denominators are supplied, returns 1/numerator,\n else returns numerator divided by all of the denominators.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1013), lang.NewKeyword("end-line"), int(1013))).(*lang.Symbol) -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v5 := args[0] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("/")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{int64(1), v5}) -return v9 - case 2: -v5 := args[0] -v6 := args[1] -v7, _ := lang.FieldOrMethod(lang1.Numbers, "divide") -if reflect.TypeOf(v7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("divide is not a function"))) +var v3 any +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v8 := lang.Apply(v7, []any{v5, v6}) -return v8 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := args[0] -v6 := args[1] -v7 := lang.NewList(args[2:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("*in*")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v10 := v9.Get() +v9 := v8.Get() +v10 := lang.Apply(v6, []any{glojure.lang8.LineNumberingPushbackReader, v9}) +if lang.IsTruthy(v10) { v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("/")) +v12 := v11.FindInternedVar(lang.NewSymbol("*in*")) if v12.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("/")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v14, ok := lang.FieldOrMethod(v13, "readLine") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v13, "readLine"))) } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v5, v6}) -v18 := lang.Apply(v10, []any{v13, v17, v7}) -return v18 - } +var v15 any +switch reflect.TypeOf(v14).Kind() { +case reflect.Func: + v15 = lang.Apply(v14, nil) +default: + v15 = v14 +} +v3 = v15 +} else { +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("*in*")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19, ok := lang.FieldOrMethod(v18, "readLine") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v18, "readLine"))) +} +var v20 any +switch reflect.TypeOf(v19).Kind() { +case reflect.Func: + v20 = lang.Apply(v19, nil) +default: + v20 = v19 +} +v3 = v20 +} +return v3 }) -v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v3 := ns.InternWithValue(v0, v4, true) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { - v3.SetMeta(v0.Meta().(lang.IPersistentMap)) + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// binding +// read-string { -v0 := lang.NewSymbol("binding").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "binding => var-symbol init-expr\n\n Creates new bindings for the (already-existing) vars, with the\n supplied initial values, executes the exprs in an implicit do, then\n re-establishes the bindings that existed before. The new bindings\n are made in parallel (unlike let); all init-exprs are evaluated\n before the vars are bound to their new values.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1945), lang.NewKeyword("end-line"), int(1945))).(*lang.Symbol) +v0 := lang.NewSymbol("read-string").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s")), lang.NewVector(lang.NewSymbol("opts"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Reads one object from the string s. Optionally include reader\n options, as specified in read.\n\n Note that read-string can execute code (controlled by *read-eval*),\n and as such should be used only with trusted sources.\n\n For data structure interop use glojure.edn/read-string", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3806), lang.NewKeyword("end-line"), int(3806))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + case 1: +v3 := args[0] +v4 := lang.Apply(runtime9.RTReadString, []any{v3}) +return v4 + case 2: v3 := args[0] v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -var v7 any -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v5}) -if lang.IsTruthy(v11) { -v7 = nil -} else { -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("str")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("first")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v3}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("meta")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) -v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) -v28 := lang.Apply(lang1.NewIllegalArgumentError, []any{v27}) -panic(v28) -} -_ = v7 -var v29 any -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("even?")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("count")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v5}) -v37 := lang.Apply(v32, []any{v36}) -if lang.IsTruthy(v37) { -v29 = nil -} else { -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("str")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("first")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +v5 := lang.Apply(runtime9.RTReadString, []any{v4, v3}) +return v5 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v3}) -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) } -v47 := v46.Get() -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("meta")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +// reader-conditional +{ +v0 := lang.NewSymbol("reader-conditional").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("form"), lang.NewSymbol("splicing?"))), lang.NewKeyword("doc"), "Construct a data representation of a reader conditional.\n If true, splicing? indicates read-cond-splicing.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7825), lang.NewKeyword("end-line"), int(7825))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.Apply(nil, []any{v3, v4}) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v3}) -v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) -v53 := lang.Apply(v40, []any{v44, " requires ", "an even number of forms in binding vector", " in ", v47, ":", v52}) -v54 := lang.Apply(lang1.NewIllegalArgumentError, []any{v53}) -panic(v54) } -_ = v29 -_ = nil -var v56 lang.FnFunc -v56 = lang.NewFnFunc(func(args ...any) any { +// reader-conditional? +{ +v0 := lang.NewSymbol("reader-conditional?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("value"))), lang.NewKeyword("doc"), "Return true if the value is the data representation of a reader conditional", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7819), lang.NewKeyword("end-line"), int(7819))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v57 := args[0] -v59 := lang.NewVector() -v60 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1959), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(1959), lang.NewKeyword("end-column"), int(31)) -v61, err := lang.WithMeta(v59, v60.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v58 any = v61 -_ = v58 -v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v64 := v63.FindInternedVar(lang.NewSymbol("seq")) -if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) -} -v65 := v64.Get() -v66 := lang.Apply(v65, []any{v57}) -var v62 any = v66 -_ = v62 -var v67 any -for { -var v68 any -if lang.IsTruthy(v62) { -v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v71 := v70.FindInternedVar(lang.NewSymbol("conj")) -if v71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) -} -v72 := v71.Get() -v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v74 := v73.FindInternedVar(lang.NewSymbol("conj")) -if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v75 := v74.Get() -v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v77 := v76.FindInternedVar(lang.NewSymbol("seq")) -if v77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) +v6 := v5.Get() +v7 := lang.Apply(v6, []any{glojure.lang8.ReaderConditional, v3}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v78 := v77.Get() -v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v80 := v79.FindInternedVar(lang.NewSymbol("concat")) -if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) } -v81 := v80.Get() -v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v83 := v82.FindInternedVar(lang.NewSymbol("list")) -if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) +// realized? +{ +v0 := lang.NewSymbol("realized?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if a value has been produced for a promise, delay, future or lazy sequence.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7602), lang.NewKeyword("end-line"), int(7602))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, ok := lang.FieldOrMethod(v3, "isRealized") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "isRealized"))) } -v84 := v83.Get() -v85 := lang.Apply(v84, []any{lang.NewSymbol("var")}) -v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v87 := v86.FindInternedVar(lang.NewSymbol("list")) -if v87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) +var v5 any +switch reflect.TypeOf(v4).Kind() { +case reflect.Func: + v5 = lang.Apply(v4, nil) +default: + v5 = v4 } -v88 := v87.Get() -v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v90 := v89.FindInternedVar(lang.NewSymbol("first")) -if v90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v91 := v90.Get() -v92 := lang.Apply(v91, []any{v62}) -v93 := lang.Apply(v88, []any{v92}) -v94 := lang.Apply(v81, []any{v85, v93}) -v95 := lang.Apply(v78, []any{v94}) -v96 := lang.Apply(v75, []any{v58, v95}) -v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v98 := v97.FindInternedVar(lang.NewSymbol("second")) -if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) } -v99 := v98.Get() -v100 := lang.Apply(v99, []any{v62}) -v101 := lang.Apply(v72, []any{v96, v100}) -var v69 any = v101 -v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v104 := v103.FindInternedVar(lang.NewSymbol("next")) -if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) +// reduce +{ +v0 := lang.NewSymbol("reduce").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("val"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "f should be a function of 2 arguments. If val is not supplied,\n returns the result of applying f to the first 2 items in coll, then\n applying f to that result and the 3rd item, etc. If coll contains no\n items, f must accept no arguments as well, and reduce returns the\n result of calling f with no arguments. If coll has only 1 item, it\n is returned and f is not called. If val is supplied, returns the\n result of applying f to val and the first item in coll, then\n applying f to that result and the 2nd item, etc. If coll contains no\n items, returns val and f is not called.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6903), lang.NewKeyword("end-line"), int(6903))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v3 := args[0] +v4 := args[1] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v105 := v104.Get() -v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v107 := v106.FindInternedVar(lang.NewSymbol("next")) -if v107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) +v8 := v7.Get() +v9 := lang.Apply(v8, []any{lang1.IReduce, v4}) +if lang.IsTruthy(v9) { +v10, _ := lang.FieldOrMethod(v4, "Reduce") +if reflect.TypeOf(v10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Reduce is not a function"))) } -v108 := v107.Get() -v109 := lang.Apply(v108, []any{v62}) -v110 := lang.Apply(v105, []any{v109}) -var v102 any = v110 -v58 = v69 -v62 = v102 -continue +v11 := lang.Apply(v10, []any{v3}) +v5 = v11 } else { -v111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v112 := v111.FindInternedVar(lang.NewSymbol("seq")) -if v112.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v112))) -} -v113 := v112.Get() -v114 := lang.Apply(v113, []any{v58}) -v68 = v114 -} -v67 = v68 - break -} -return v67 -}) -v57 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1958), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(1963), lang.NewKeyword("end-column"), int(34)) -v58, err := lang.WithMeta(v56, v57.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v55 any = v58 -_ = v55 -v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v61 := v60.FindInternedVar(lang.NewSymbol("seq")) -if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) -} -v62 := v61.Get() -v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v64 := v63.FindInternedVar(lang.NewSymbol("concat")) -if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) -} -v65 := v64.Get() -v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v67 := v66.FindInternedVar(lang.NewSymbol("list")) -if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core.protocols")) +v13 := v12.FindInternedVar(lang.NewSymbol("coll-reduce")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } -v68 := v67.Get() -v69 := lang.Apply(v68, []any{lang.NewSymbol("glojure.core/let")}) -v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v71 := v70.FindInternedVar(lang.NewSymbol("list")) -if v71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v4, v3}) +v5 = v15 } -v72 := v71.Get() -v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v74 := v73.FindInternedVar(lang.NewSymbol("apply")) -if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) +return v5 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +var v6 any +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("instance?")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v75 := v74.Get() -v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v77 := v76.FindInternedVar(lang.NewSymbol("vector")) -if v77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) +v9 := v8.Get() +v10 := lang.Apply(v9, []any{lang1.IReduceInit, v5}) +if lang.IsTruthy(v10) { +v11, _ := lang.FieldOrMethod(v5, "ReduceInit") +if reflect.TypeOf(v11).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) } -v78 := v77.Get() -v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v80 := v79.FindInternedVar(lang.NewSymbol("seq")) -if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) +v12 := lang.Apply(v11, []any{v3, v4}) +v6 = v12 +} else { +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core.protocols")) +v14 := v13.FindInternedVar(lang.NewSymbol("coll-reduce")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } -v81 := v80.Get() -v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v83 := v82.FindInternedVar(lang.NewSymbol("concat")) -if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v5, v3, v4}) +v6 = v16 } -v84 := v83.Get() -v85 := lang.Apply(v84, nil) -v86 := lang.Apply(v81, []any{v85}) -v87 := lang.Apply(v75, []any{v78, v86}) -v88 := lang.Apply(v72, []any{v87}) -v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v90 := v89.FindInternedVar(lang.NewSymbol("list")) -if v90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) +return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v91 := v90.Get() -v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v93 := v92.FindInternedVar(lang.NewSymbol("seq")) -if v93.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) } -v94 := v93.Get() -v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v96 := v95.FindInternedVar(lang.NewSymbol("concat")) -if v96.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) +// reduce-kv +{ +v0 := lang.NewSymbol("reduce-kv").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Reduces an associative collection. f should be a function of 3\n arguments. Returns the result of applying f to init, the first key\n and the first value in coll, then applying f to that result and the\n 2nd key and value, etc. If coll contains no entries, returns init\n and f is not called. Note that reduce-kv is supported on vectors,\n where the keys will be the ordinals.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6925), lang.NewKeyword("end-line"), int(6925))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core.protocols")) +v7 := v6.FindInternedVar(lang.NewSymbol("kv-reduce")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v97 := v96.Get() -v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v99 := v98.FindInternedVar(lang.NewSymbol("list")) -if v99.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v5, v3, v4}) +return v9 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v100 := v99.Get() -v101 := lang.Apply(v100, []any{lang.NewSymbol("glojure.core/push-thread-bindings")}) -v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v103 := v102.FindInternedVar(lang.NewSymbol("list")) -if v103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) } -v104 := v103.Get() -v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v106 := v105.FindInternedVar(lang.NewSymbol("seq")) -if v106.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) +// reduce1 +{ +v0 := lang.NewSymbol("reduce1").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(923), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(924), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("val"), lang.NewSymbol("coll"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v3 := args[0] +v4 := args[1] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("seq")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v107 := v106.Get() -v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v109 := v108.FindInternedVar(lang.NewSymbol("concat")) -if v109.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v4}) +var v5 any = v9 +_ = v5 +var v11 any +if lang.IsTruthy(v5) { +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("reduce1")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } -v110 := v109.Get() -v111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v112 := v111.FindInternedVar(lang.NewSymbol("list")) -if v112.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v112))) +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("first")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } -v113 := v112.Get() -v114 := lang.Apply(v113, []any{lang.NewSymbol("glojure.core/hash-map")}) -v115 := lang.Apply(v55, []any{v5}) -v116 := lang.Apply(v110, []any{v114, v115}) -v117 := lang.Apply(v107, []any{v116}) -v118 := lang.Apply(v104, []any{v117}) -v119 := lang.Apply(v97, []any{v101, v118}) -v120 := lang.Apply(v94, []any{v119}) -v121 := lang.Apply(v91, []any{v120}) -v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v123 := v122.FindInternedVar(lang.NewSymbol("list")) -if v123.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v5}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("next")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v124 := v123.Get() -v125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v126 := v125.FindInternedVar(lang.NewSymbol("seq")) -if v126.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v126))) +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v5}) +v23 := lang.Apply(v14, []any{v3, v18, v22}) +v11 = v23 +} else { +v24 := lang.Apply(v3, nil) +v11 = v24 } -v127 := v126.Get() -v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v129 := v128.FindInternedVar(lang.NewSymbol("concat")) -if v129.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v129))) +return v11 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +recur_loop_156: +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("seq")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v130 := v129.Get() -v131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v132 := v131.FindInternedVar(lang.NewSymbol("list")) -if v132.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v132))) +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v5}) +var v6 any = v10 +_ = v6 +var v12 any +if lang.IsTruthy(v6) { +var v13 any +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("chunked-seq?")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v133 := v132.Get() -v134 := lang.Apply(v133, []any{lang.NewSymbol("try")}) -v135 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v136 := v135.FindInternedVar(lang.NewSymbol("list")) -if v136.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v136))) +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v6}) +if lang.IsTruthy(v17) { +var v18 any = v3 +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("chunk-first")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v137 := v136.Get() -v138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v139 := v138.FindInternedVar(lang.NewSymbol("seq")) -if v139.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v139))) +v22 := v21.Get() +v23 := lang.Apply(v22, []any{v6}) +v24, _ := lang.FieldOrMethod(v23, "ReduceInit") +if reflect.TypeOf(v24).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) } -v140 := v139.Get() -v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v142 := v141.FindInternedVar(lang.NewSymbol("concat")) -if v142.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) +v25 := lang.Apply(v24, []any{v3, v4}) +var v19 any = v25 +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("chunk-next")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v143 := v142.Get() -v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v145 := v144.FindInternedVar(lang.NewSymbol("list")) -if v145.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) +v29 := v28.Get() +v30 := lang.Apply(v29, []any{v6}) +var v26 any = v30 +v3 = v18 +v4 = v19 +v5 = v26 +goto recur_loop_156 +} else { +var v31 any = v3 +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("first")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) } -v146 := v145.Get() -v147 := lang.Apply(v146, []any{lang.NewSymbol("finally")}) -v148 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v149 := v148.FindInternedVar(lang.NewSymbol("list")) -if v149.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v149))) +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v6}) +v37 := lang.Apply(v3, []any{v4, v36}) +var v32 any = v37 +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("next")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) } -v150 := v149.Get() -v151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v152 := v151.FindInternedVar(lang.NewSymbol("seq")) -if v152.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v152))) +v41 := v40.Get() +v42 := lang.Apply(v41, []any{v6}) +var v38 any = v42 +v3 = v31 +v4 = v32 +v5 = v38 +goto recur_loop_156 } -v153 := v152.Get() -v154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v155 := v154.FindInternedVar(lang.NewSymbol("concat")) -if v155.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v155))) +v12 = v13 +} else { +v12 = v4 } -v156 := v155.Get() -v157 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v158 := v157.FindInternedVar(lang.NewSymbol("list")) -if v158.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v158))) +return v12 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v159 := v158.Get() -v160 := lang.Apply(v159, []any{lang.NewSymbol("glojure.core/pop-thread-bindings")}) -v161 := lang.Apply(v156, []any{v160}) -v162 := lang.Apply(v153, []any{v161}) -v163 := lang.Apply(v150, []any{v162}) -v164 := lang.Apply(v143, []any{v147, v163}) -v165 := lang.Apply(v140, []any{v164}) -v166 := lang.Apply(v137, []any{v165}) -v167 := lang.Apply(v130, []any{v134, v6, v166}) -v168 := lang.Apply(v127, []any{v167}) -v169 := lang.Apply(v124, []any{v168}) -v170 := lang.Apply(v65, []any{v69, v88, v121, v169}) -v171 := lang.Apply(v62, []any{v170}) -return v171 +} +// reduced +{ +v0 := lang.NewSymbol("reduced").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Wraps x in a way such that a reduce will terminate with the value x", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2828), lang.NewKeyword("end-line"), int(2828))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } +v3 := args[0] +v4 := lang.Apply(lang1.NewReduced, []any{v3}) +return v4 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -64934,10 +64909,10 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// double +// reduced? { var v1 lang.FnFunc -{ // function double__inliner +{ // function reduced?__inliner v1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -64961,585 +64936,274 @@ if v11.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v13 := lang.Apply(v12, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.IsReduced")}) v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v15 := v14.FindInternedVar(lang.NewSymbol("list")) if v15.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/DoubleCast")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v3}) -v35 := lang.Apply(v26, []any{v30, v34}) -v36 := lang.Apply(v23, []any{v35}) -v37 := lang.Apply(v20, []any{v36}) -v38 := lang.Apply(v9, []any{v13, v17, v37}) -v39 := lang.Apply(v6, []any{v38}) -return v39 +v17 := lang.Apply(v16, []any{v3}) +v18 := lang.Apply(v9, []any{v13, v17}) +v19 := lang.Apply(v6, []any{v18}) +return v19 }) v2 := v1 _ = v2 } -v0 := lang.NewSymbol("double").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to double", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3493), lang.NewKeyword("end-line"), int(3493))).(*lang.Symbol) +v0 := lang.NewSymbol("reduced?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns true if x is the result of a call to reduced", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)), lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2834), lang.NewKeyword("end-line"), int(2834))).(*lang.Symbol) var v3 lang.FnFunc v3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5 := lang.Apply(lang1.AsFloat64, []any{v4}) +v5 := lang.Apply(lang1.IsReduced, []any{v4}) return v5 }) v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// *compile-files* -{ -v0 := lang.NewSymbol("*compile-files*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "Set to true when compiling files, false otherwise.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, false, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// defmacro -{ -v0 := lang.NewSymbol("defmacro").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("doc-string?"), lang.NewSymbol("attr-map?"), lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("body")), lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("doc-string?"), lang.NewSymbol("attr-map?"), lang.NewList(lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("body")), lang.NewSymbol("+"), lang.NewSymbol("attr-map?"))), lang.NewKeyword("doc"), "Like defn, but the resulting function name is declared as a\n macro and will be used as a macro by the compiler when it is\n called.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(445), lang.NewKeyword("end-line"), int(451))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("list")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v5}) -var v8 any = v12 -_ = v8 -var v13 any = v13 -_ = v13 -var v14 any -for { -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("first")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v13}) -var v15 any = v19 -_ = v15 -var v21 any -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("string?")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v15}) -if lang.IsTruthy(v25) { -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("cons")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{v15, v8}) -var v26 any = v30 -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("next")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v13}) -var v31 any = v35 -v8 = v26 -v13 = v31 -continue -} else { -var v36 any -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("map?")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v15}) -if lang.IsTruthy(v40) { -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("cons")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) -} -v44 := v43.Get() -v45 := lang.Apply(v44, []any{v15, v8}) -var v41 any = v45 -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("next")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) -} -v49 := v48.Get() -v50 := lang.Apply(v49, []any{v13}) -var v46 any = v50 -v8 = v41 -v13 = v46 -continue -} else { -v36 = v8 -} -v21 = v36 +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v14 = v21 - break } -var v7 any = v14 -_ = v7 -var v9 any = v6 -_ = v9 -var v10 any -for { -var v11 any -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("string?")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +// reductions +{ +v0 := lang.NewSymbol("reductions").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy seq of the intermediate values of the reduction (as\n per reduce) of coll by f, starting with init.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7239), lang.NewKeyword("end-line"), int(7239))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v3 := args[0] +v4 := args[1] +var v5 lang.FnFunc +v5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("seq")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v14 := v13.Get() +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v4}) +var v6 any = v10 +_ = v6 +var v12 any +if lang.IsTruthy(v6) { +var v13 any = v6 +_ = v13 v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("first")) +v16 := v15.FindInternedVar(lang.NewSymbol("reductions")) if v16.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } v17 := v16.Get() -v18 := lang.Apply(v17, []any{v9}) -v19 := lang.Apply(v14, []any{v18}) -if lang.IsTruthy(v19) { -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("next")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v9}) -var v20 any = v24 -v9 = v20 -continue -} else { -var v25 any -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("map?")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("first")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("first")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v31 := v30.Get() -v32 := lang.Apply(v31, []any{v9}) -v33 := lang.Apply(v28, []any{v32}) -if lang.IsTruthy(v33) { -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("next")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +v20 := v19.Get() +v21 := lang.Apply(v20, []any{v13}) +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("rest")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v9}) -var v34 any = v38 -v9 = v34 -continue +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v13}) +v26 := lang.Apply(v17, []any{v3, v21, v25}) +v12 = v26 } else { -v25 = v9 +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("list")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } -v11 = v25 +v15 := v14.Get() +v16 := lang.Apply(v3, nil) +v17 := lang.Apply(v15, []any{v16}) +v12 = v17 } -v10 = v11 - break +return v12 +}) +v6 := lang.Apply(lang1.NewLazySeq, []any{v5}) +return v6 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +var v6 any +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("reduced?")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -var v8 any = v10 -_ = v8 -var v10 any +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v4}) +if lang.IsTruthy(v10) { v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("vector?")) +v12 := v11.FindInternedVar(lang.NewSymbol("list")) if v12.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } v13 := v12.Get() v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("first")) +v15 := v14.FindInternedVar(lang.NewSymbol("deref")) if v15.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } v16 := v15.Get() -v17 := lang.Apply(v16, []any{v9}) +v17 := lang.Apply(v16, []any{v4}) v18 := lang.Apply(v13, []any{v17}) -if lang.IsTruthy(v18) { +v6 = v18 +} else { v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) +v20 := v19.FindInternedVar(lang.NewSymbol("cons")) if v20.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } v21 := v20.Get() -v22 := lang.Apply(v21, []any{v9}) -v10 = v22 -} else { -v10 = v9 -} -var v9 any = v10 -_ = v9 -var v24 lang.FnFunc -v24 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { +var v22 lang.FnFunc +v22 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v25 := args[0] -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("first")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("seq")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -v29 := v28.Get() -v30 := lang.Apply(v29, []any{v25}) -var v26 any = v30 -_ = v26 +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v5}) +var v23 any = v27 +_ = v23 +var v29 any +if lang.IsTruthy(v23) { +var v30 any = v23 +_ = v30 v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("cons")) +v33 := v32.FindInternedVar(lang.NewSymbol("reductions")) if v33.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) } v34 := v33.Get() v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("vec")) +v36 := v35.FindInternedVar(lang.NewSymbol("first")) if v36.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) } v37 := v36.Get() -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("cons")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("cons")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{lang.NewSymbol("&env"), v26}) -v45 := lang.Apply(v40, []any{lang.NewSymbol("&form"), v44}) -v46 := lang.Apply(v37, []any{v45}) -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("next")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) -} -v49 := v48.Get() -v50 := lang.Apply(v49, []any{v25}) -v51 := lang.Apply(v34, []any{v46, v50}) -return v51 -}) -v25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(469), lang.NewKeyword("column"), int(38), lang.NewKeyword("end-line"), int(471), lang.NewKeyword("end-column"), int(87)) -v26, err := lang.WithMeta(v24, v25.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v23 any = v26 -_ = v23 -var v28 lang.FnFunc -v28 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v29 := args[0] -v30 := args[1] -recur_loop_61: -var v31 any -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("nil?")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v30}) -if lang.IsTruthy(v35) { -v31 = v29 -} else { -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("first")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v30}) -var v36 any = v40 -_ = v36 -var v42 any -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("map?")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.Apply(v45, []any{v36}) -if lang.IsTruthy(v46) { -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("conj")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +v38 := lang.Apply(v37, []any{v30}) +v39 := lang.Apply(v3, []any{v4, v38}) +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("rest")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) } -v49 := v48.Get() -v50 := lang.Apply(v49, []any{v29, v36}) -v42 = v50 +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v30}) +v44 := lang.Apply(v34, []any{v3, v39, v43}) +v29 = v44 } else { -v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("conj")) -if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) -} -v54 := v53.Get() -v55 := lang.Apply(v23, []any{v36}) -v56 := lang.Apply(v54, []any{v29, v55}) -var v51 any = v56 -v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v59 := v58.FindInternedVar(lang.NewSymbol("next")) -if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) -} -v60 := v59.Get() -v61 := lang.Apply(v60, []any{v30}) -var v57 any = v61 -v29 = v51 -v30 = v57 -goto recur_loop_61 -} -v31 = v42 +v29 = nil } -return v31 +return v29 }) -v29 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(472), lang.NewKeyword("column"), int(29), lang.NewKeyword("end-line"), int(478), lang.NewKeyword("end-column"), int(90)) -v30, err := lang.WithMeta(v28, v29.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v27 any = v30 -_ = v27 -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("seq")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.NewVector() -v36 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(479), lang.NewKeyword("column"), int(41), lang.NewKeyword("end-line"), int(479), lang.NewKeyword("end-column"), int(42)) -v37, err := lang.WithMeta(v35, v36.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v38 := lang.Apply(v27, []any{v37, v31}) -v39 := lang.Apply(v34, []any{v38}) -var v31 any = v39 -_ = v31 -var v41 any = v7 -_ = v41 -var v42 any = v31 -_ = v42 -var v43 any -for { -var v44 any -if lang.IsTruthy(v41) { -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("next")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) -} -v48 := v47.Get() -v49 := lang.Apply(v48, []any{v41}) -var v45 any = v49 -v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v52 := v51.FindInternedVar(lang.NewSymbol("cons")) -if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) -} -v53 := v52.Get() -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("first")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) -} -v56 := v55.Get() -v57 := lang.Apply(v56, []any{v41}) -v58 := lang.Apply(v53, []any{v57, v42}) -var v50 any = v58 -v41 = v45 -v42 = v50 -continue -} else { -v44 = v42 -} -v43 = v44 - break -} -var v40 any = v43 -_ = v40 -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("list")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) -} -v44 := v43.Get() -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("cons")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.Apply(v47, []any{lang.NewSymbol("glojure.core/defn"), v40}) -v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v50 := v49.FindInternedVar(lang.NewSymbol("list")) -if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) -} -v51 := v50.Get() -v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("list")) -if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) -} -v54 := v53.Get() -v55 := lang.Apply(v54, []any{lang.NewSymbol("var"), v5}) -v56 := lang.Apply(v51, []any{lang.NewSymbol("."), v55, lang.NewList(lang.NewSymbol("SetMacro"))}) -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("list")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +v23 := lang.Apply(lang1.NewLazySeq, []any{v22}) +v24 := lang.Apply(v21, []any{v4, v23}) +v6 = v24 } -v59 := v58.Get() -v60 := lang.Apply(v59, []any{lang.NewSymbol("var"), v5}) -v61 := lang.Apply(v44, []any{lang.NewSymbol("do"), v48, v56, v60}) -return v61 +return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(451), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(487), lang.NewKeyword("end-column"), int(40))).(lang.FnFunc) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// cons +// ref { -v0 := lang.NewSymbol("cons").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("seq"))), lang.NewKeyword("doc"), "Returns a new seq where x is the first element and seq is\n the rest.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(21), lang.NewKeyword("end-line"), int(27))).(*lang.Symbol) +v0 := lang.NewSymbol("ref").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Creates and returns a Ref with an initial value of x and zero or\n more options (in any order):\n\n :meta metadata-map\n\n :validator validate-fn\n\n :min-history (default 0)\n :max-history (default 10)\n\n If metadata-map is supplied, it will become the metadata on the\n ref. validate-fn must be nil or a side-effect-free fn of one\n argument, which will be passed the intended new state on any state\n change. If the new state is unacceptable, the validate-fn should\n return false or throw an exception. validate-fn will be called on\n transaction commit, when all refs have their final values.\n\n Normally refs accumulate history dynamically as needed to deal with\n read demands. If you know in advance you will need history you can\n set :min-history to ensure it will be available when first needed (instead\n of after a read fault). History is limited, and the limit can be set\n with :max-history.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2260), lang.NewKeyword("end-line"), int(2260))).(*lang.Symbol) var v2 lang.FnFunc -{ // function cons v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6 := lang.Apply(lang1.NewCons, []any{v4, v5}) -return v6 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(27), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(27), lang.NewKeyword("end-column"), int(89))).(lang.FnFunc) -v3 := v2 -_ = v3 + switch len(args) { + case 1: +v3 := args[0] +v4 := lang.Apply(lang1.NewRef, []any{v3}) +return v4 + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.NewList(args[1:]...) +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("setup-reference")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("ref")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v3}) +v13 := lang.Apply(v8, []any{v12, v4}) +var v5 any = v13 +_ = v5 +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("apply")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } -// splitv-at -{ -v0 := lang.NewSymbol("splitv-at").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a vector of [(into [] (take n) coll) (drop n coll)]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7299), lang.NewKeyword("end-line"), int(7299))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("into")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v17 := v16.Get() +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("hash-map")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v7 := v6.Get() -v8 := lang.NewVector() -v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7303), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(7303), lang.NewKeyword("end-column"), int(11)) -v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) -if err != nil { - panic(err) +v20 := v19.Get() +v21 := lang.Apply(v17, []any{v20, v4}) +var v14 any = v21 +_ = v14 +var v23 any +v24 := lang.Apply(lang.NewKeyword("max-history"), []any{v14}) +if lang.IsTruthy(v24) { +v25 := lang.Apply(lang.NewKeyword("max-history"), []any{v14}) +v26, _ := lang.FieldOrMethod(v5, "setMaxHistory") +if reflect.TypeOf(v26).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMaxHistory is not a function"))) } -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("take")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v27 := lang.Apply(v26, []any{v25}) +v23 = v27 +} else { +v23 = nil } -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v3}) -v15 := lang.Apply(v7, []any{v10, v14, v4}) -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("drop")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +_ = v23 +var v28 any +v29 := lang.Apply(lang.NewKeyword("min-history"), []any{v14}) +if lang.IsTruthy(v29) { +v30 := lang.Apply(lang.NewKeyword("min-history"), []any{v14}) +v31, _ := lang.FieldOrMethod(v5, "setMinHistory") +if reflect.TypeOf(v31).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMinHistory is not a function"))) } -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v3, v4}) -v20 := lang.NewVector(v15, v19) -v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7303), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(7303), lang.NewKeyword("end-column"), int(41)) -v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) -if err != nil { - panic(err) +v32 := lang.Apply(v31, []any{v30}) +v28 = v32 +} else { +v28 = nil } -return v22 +_ = v28 +return v5 + } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -65547,20 +65211,26 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// future-cancel +// ref-history-count { -v0 := lang.NewSymbol("future-cancel").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Cancels the future, if possible.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7062), lang.NewKeyword("end-line"), int(7062))).(*lang.Symbol) +v0 := lang.NewSymbol("ref-history-count").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref"))), lang.NewKeyword("doc"), "Returns the history count of a ref", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2455), lang.NewKeyword("end-line"), int(2455))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4, _ := lang.FieldOrMethod(v3, "cancel") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("cancel is not a function"))) +v4, ok := lang.FieldOrMethod(v3, "getHistoryCount") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getHistoryCount"))) +} +var v5 any +switch reflect.TypeOf(v4).Kind() { +case reflect.Func: + v5 = lang.Apply(v4, nil) +default: + v5 = v4 } -v5 := lang.Apply(v4, []any{true}) return v5 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -65569,17 +65239,38 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// iterator-seq +// ref-max-history { -v0 := lang.NewSymbol("iterator-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("iter"))), lang.NewKeyword("doc"), "Returns a seq on a java.util.Iterator. Note that most collections\n providing iterators implement Iterable and thus support seq directly.\n Seqs cache values, thus iterator-seq should not be used on any\n iterator that repeatedly returns the same mutable object.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5743), lang.NewKeyword("end-line"), int(5743))).(*lang.Symbol) +v0 := lang.NewSymbol("ref-max-history").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref")), lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Gets the max-history of a ref, or sets it and returns the ref", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2471), lang.NewKeyword("end-line"), int(2471))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { + switch len(args) { + case 1: +v3 := args[0] +v4, ok := lang.FieldOrMethod(v3, "getMaxHistory") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getMaxHistory"))) +} +var v5 any +switch reflect.TypeOf(v4).Kind() { +case reflect.Func: + v5 = lang.Apply(v4, nil) +default: + v5 = v4 +} +return v5 + case 2: +v3 := args[0] +v4 := args[1] +v5, _ := lang.FieldOrMethod(v3, "setMaxHistory") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMaxHistory is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 + default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := args[0] -v4 := lang.Apply(nil, []any{v3}) -return v4 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -65587,17 +65278,48 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// max-mask-bits +// ref-min-history { -v0 := lang.NewSymbol("max-mask-bits").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6644), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(6644), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, int64(13), true) +v0 := lang.NewSymbol("ref-min-history").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref")), lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Gets the min-history of a ref, or sets it and returns the ref", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2462), lang.NewKeyword("end-line"), int(2462))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +v4, ok := lang.FieldOrMethod(v3, "getMinHistory") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getMinHistory"))) +} +var v5 any +switch reflect.TypeOf(v4).Kind() { +case reflect.Func: + v5 = lang.Apply(v4, nil) +default: + v5 = v4 +} +return v5 + case 2: +v3 := args[0] +v4 := args[1] +v5, _ := lang.FieldOrMethod(v3, "setMinHistory") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMinHistory is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// var-set +// ref-set { -v0 := lang.NewSymbol("var-set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Sets the value in the var object to val. The var must be\n thread-locally bound.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4332), lang.NewKeyword("end-line"), int(4332))).(*lang.Symbol) +v0 := lang.NewSymbol("ref-set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Must be called in a transaction. Sets the value of ref.\n Returns val.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2447), lang.NewKeyword("end-line"), int(2447))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { @@ -65605,9 +65327,9 @@ v2 = lang.NewFnFunc(func(args ...any) any { } v3 := args[0] v4 := args[1] -v5, _ := lang.FieldOrMethod(v3, "Set") +v5, _ := lang.FieldOrMethod(v3, "set") if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Set is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("set is not a function"))) } v6 := lang.Apply(v5, []any{v4}) return v6 @@ -65618,83 +65340,482 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// update-keys +// refer { -v0 := lang.NewSymbol("update-keys").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("f"))), lang.NewKeyword("doc"), "m f => {(f k) v ...}\n\n Given a map m and a function f of 1-argument, returns a new map whose\n keys are the result of applying f to the keys of m, mapped to the\n corresponding values of m.\n f must return a unique key for each key of m, else the behavior is undefined.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7949), lang.NewKeyword("end-line"), int(7949))).(*lang.Symbol) +v0 := lang.NewSymbol("refer").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns-sym"), lang.NewSymbol("&"), lang.NewSymbol("filters"))), lang.NewKeyword("doc"), "refers to all public vars of ns, subject to filters.\n filters can include at most one each of:\n\n :exclude list-of-symbols\n :only list-of-symbols\n :rename map-of-fromsymbol-tosymbol\n\n For each public interned var in the namespace named by the symbol,\n adds a mapping from the name of the var to the var to the current\n namespace. Throws an exception if name is already mapped to\n something else in the current namespace. Filters can be used to\n select a subset, via inclusion or exclusion, or to provide a mapping\n to a symbol different from the var's name, in order to prevent\n clashes. Use :use in the ns macro in preference to calling this directly.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4216), lang.NewKeyword("end-line"), int(4216))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.NewList(args[1:]...) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("find-ns")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v3}) +var v6 any = v10 +_ = v6 +var v12 any +if lang.IsTruthy(v6) { +v12 = v6 +} else { +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("str")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{"No namespace: ", v3}) +v17 := lang.Apply(errors11.New, []any{v16}) +panic(v17) +} +var v5 any = v12 +_ = v5 +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("apply")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("hash-map")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v9, []any{v12, v4}) +var v6 any = v13 +_ = v6 +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("ns-publics")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v5}) +var v14 any = v18 +_ = v14 +v21 := lang.Apply(lang.NewKeyword("rename"), []any{v6}) +var v20 any = v21 +_ = v20 +var v23 any +if lang.IsTruthy(v20) { +v23 = v20 +} else { +v24 := lang.NewMap() +v25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4236), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(4236), lang.NewKeyword("end-column"), int(36)) +v26, err := lang.WithMeta(v24, v25.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v23 = v26 +} +var v19 any = v23 +_ = v19 +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("set")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.Apply(lang.NewKeyword("exclude"), []any{v6}) +v25 := lang.Apply(v23, []any{v24}) +var v20 any = v25 +_ = v20 +var v27 any +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("=")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(lang.NewKeyword("refer"), []any{v6}) +v32 := lang.Apply(v30, []any{lang.NewKeyword("all"), v31}) +if lang.IsTruthy(v32) { +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("keys")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +} +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v14}) +v27 = v36 +} else { +v38 := lang.Apply(lang.NewKeyword("refer"), []any{v6}) +var v37 any = v38 +_ = v37 +var v40 any +if lang.IsTruthy(v37) { +v40 = v37 +} else { +v42 := lang.Apply(lang.NewKeyword("only"), []any{v6}) +var v41 any = v42 +_ = v41 +var v44 any +if lang.IsTruthy(v41) { +v44 = v41 +} else { +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("keys")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +} +v47 := v46.Get() +v48 := lang.Apply(v47, []any{v14}) +v44 = v48 +} +v40 = v44 +} +v27 = v40 +} +var v26 any = v27 +_ = v26 +var v38 any +var v39 any = v26 +_ = v39 +var v41 any +if lang.IsTruthy(v39) { +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("not")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +} +v44 := v43.Get() +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("instance?")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +} +v47 := v46.Get() +v48 := lang.Apply(v47, []any{lang1.Sequential, v26}) +v49 := lang.Apply(v44, []any{v48}) +v41 = v49 +} else { +v41 = v39 +} +if lang.IsTruthy(v41) { +v39 := lang.Apply(errors11.New, []any{":only/:refer value must be a sequential collection of symbols"}) +panic(v39) +} else { +v38 = nil +} +_ = v38 +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("seq")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +} +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v26}) +var v40 any = v44 +_ = v40 +var v45 any = nil +_ = v45 +var v46 any = int64(0) +_ = v46 +var v47 any = int64(0) +_ = v47 +var v48 any +for { +var v49 any +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("<")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +} +v52 := v51.Get() +v53 := lang.Apply(v52, []any{v47, v46}) +if lang.IsTruthy(v53) { +v55, _ := lang.FieldOrMethod(v45, "nth") +if reflect.TypeOf(v55).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) +} +v56 := lang.Apply(v55, []any{v47}) +var v54 any = v56 +_ = v54 +var v58 any +v59 := lang.Apply(v20, []any{v54}) +if lang.IsTruthy(v59) { +v58 = nil +} else { +v61 := lang.Apply(v14, []any{v54}) +var v60 any = v61 +_ = v60 +var v63 any +if lang.IsTruthy(v60) { +v63 = nil +} else { +panic("unimplemented: new with non-constant class type") +} +_ = v63 +v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v65 := v64.FindInternedVar(lang.NewSymbol("*ns*")) +if v65.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) +} +v66 := v65.Get() +v68 := lang.Apply(v19, []any{v54}) +var v67 any = v68 +_ = v67 +var v70 any +if lang.IsTruthy(v67) { +v70 = v67 +} else { +v70 = v54 +} +v67, _ := lang.FieldOrMethod(v66, "Refer") +if reflect.TypeOf(v67).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Refer is not a function"))) +} +v68 := lang.Apply(v67, []any{v70, v60}) +v58 = v68 +} +_ = v58 +var v60 any = v40 +var v61 any = v45 +var v62 any = v46 +v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v65 := v64.FindInternedVar(lang.NewSymbol("unchecked-inc")) +if v65.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) +} +v66 := v65.Get() +v67 := lang.Apply(v66, []any{v47}) +var v63 any = v67 +v40 = v60 +v45 = v61 +v46 = v62 +v47 = v63 +continue +} else { +v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v56 := v55.FindInternedVar(lang.NewSymbol("seq")) +if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) +} +v57 := v56.Get() +v58 := lang.Apply(v57, []any{v40}) +var v54 any = v58 +_ = v54 +var v60 any +if lang.IsTruthy(v54) { +var v61 any = v54 +_ = v61 +var v63 any +v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v65 := v64.FindInternedVar(lang.NewSymbol("chunked-seq?")) +if v65.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) +} +v66 := v65.Get() +v67 := lang.Apply(v66, []any{v61}) +if lang.IsTruthy(v67) { +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("chunk-first")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +} +v71 := v70.Get() +v72 := lang.Apply(v71, []any{v61}) +var v68 any = v72 +_ = v68 +v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v76 := v75.FindInternedVar(lang.NewSymbol("chunk-rest")) +if v76.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) +} +v77 := v76.Get() +v78 := lang.Apply(v77, []any{v61}) +var v74 any = v78 +var v79 any = v68 +v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v82 := v81.FindInternedVar(lang.NewSymbol("int")) +if v82.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) +} +v83 := v82.Get() +v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v85 := v84.FindInternedVar(lang.NewSymbol("count")) +if v85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) +} +v86 := v85.Get() +v87 := lang.Apply(v86, []any{v68}) +v88 := lang.Apply(v83, []any{v87}) +var v80 any = v88 +v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v91 := v90.FindInternedVar(lang.NewSymbol("int")) +if v91.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) +} +v92 := v91.Get() +v93 := lang.Apply(v92, []any{int64(0)}) +var v89 any = v93 +v40 = v74 +v45 = v79 +v46 = v80 +v47 = v89 +continue +} else { +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("first")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +} +v71 := v70.Get() +v72 := lang.Apply(v71, []any{v61}) +var v68 any = v72 +_ = v68 +var v74 any +v75 := lang.Apply(v20, []any{v68}) +if lang.IsTruthy(v75) { +v74 = nil +} else { +v77 := lang.Apply(v14, []any{v68}) +var v76 any = v77 +_ = v76 +var v79 any +if lang.IsTruthy(v76) { +v79 = nil +} else { +panic("unimplemented: new with non-constant class type") +} +_ = v79 +v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v81 := v80.FindInternedVar(lang.NewSymbol("*ns*")) +if v81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) +} +v82 := v81.Get() +v84 := lang.Apply(v19, []any{v68}) +var v83 any = v84 +_ = v83 +var v86 any +if lang.IsTruthy(v83) { +v86 = v83 +} else { +v86 = v68 +} +v83, _ := lang.FieldOrMethod(v82, "Refer") +if reflect.TypeOf(v83).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Refer is not a function"))) +} +v84 := lang.Apply(v83, []any{v86, v76}) +v74 = v84 +} +_ = v74 +v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v78 := v77.FindInternedVar(lang.NewSymbol("next")) +if v78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) +} +v79 := v78.Get() +v80 := lang.Apply(v79, []any{v61}) +var v76 any = v80 +var v81 any = nil +var v82 any = int64(0) +var v83 any = int64(0) +v40 = v76 +v45 = v81 +v46 = v82 +v47 = v83 +continue +} +v60 = v63 +} else { +v60 = nil +} +v49 = v60 +} +v48 = v49 + break +} +return v48 } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// refer-glojure +{ +v0 := lang.NewSymbol("refer-glojure").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("filters"))), lang.NewKeyword("doc"), "Same as (refer 'glojure.core )", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5843), lang.NewKeyword("end-line"), int(5843))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] v4 := args[1] +v5 := lang.NewList(args[2:]...) v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("persistent!")) +v7 := v6.FindInternedVar(lang.NewSymbol("seq")) if v7.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } v8 := v7.Get() v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("reduce-kv")) +v10 := v9.FindInternedVar(lang.NewSymbol("concat")) if v10.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } v11 := v10.Get() -var v12 lang.FnFunc -v12 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v13 := args[0] -v14 := args[1] -v15 := args[2] +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("list")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{lang.NewSymbol("glojure.core/refer")}) v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("assoc!")) +v17 := v16.FindInternedVar(lang.NewSymbol("list")) if v17.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } v18 := v17.Get() -v19 := lang.Apply(v4, []any{v14}) -v20 := lang.Apply(v18, []any{v13, v19, v15}) -return v20 -}) -v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7959), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7959), lang.NewKeyword("end-column"), int(59)) -v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("transient")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("seq")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v17 := v16.Get() -v18 := lang.NewMap() -v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7960), lang.NewKeyword("column"), int(36), lang.NewKeyword("end-line"), int(7960), lang.NewKeyword("end-column"), int(37)) -v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) -if err != nil { - panic(err) +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("concat")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -v21 := lang.Apply(v17, []any{v20}) -v22 := lang.Apply(v11, []any{v14, v21, v3}) -v23 := lang.Apply(v8, []any{v22}) -var v5 any = v23 -_ = v5 +v24 := v23.Get() v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("with-meta")) +v26 := v25.FindInternedVar(lang.NewSymbol("list")) if v26.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("meta")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +v28 := lang.Apply(v27, []any{lang.NewSymbol("quote")}) +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("list")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) } -v30 := v29.Get() -v31 := lang.Apply(v30, []any{v3}) -v32 := lang.Apply(v27, []any{v5, v31}) -return v32 +v31 := v30.Get() +v32 := lang.Apply(v31, []any{lang.NewSymbol("glojure.core")}) +v33 := lang.Apply(v24, []any{v28, v32}) +v34 := lang.Apply(v21, []any{v33}) +v35 := lang.Apply(v18, []any{v34}) +v36 := lang.Apply(v11, []any{v15, v35, v5}) +v37 := lang.Apply(v8, []any{v36}) +return v37 + } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -65702,447 +65823,302 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// extend +// release-pending-sends { -v0 := lang.NewSymbol("extend").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atype"), lang.NewSymbol("&"), lang.NewSymbol("proto+mmaps"))), lang.NewKeyword("doc"), "Implementations of protocol methods can be provided using the extend construct:\n\n (extend AType\n AProtocol\n {:foo an-existing-fn\n :bar (fn [a b] ...)\n :baz (fn ([a]...) ([a b] ...)...)}\n BProtocol \n {...} \n ...)\n \n extend takes a type/class (or interface, see below), and one or more\n protocol + method map pairs. It will extend the polymorphism of the\n protocol's methods to call the supplied methods when an AType is\n provided as the first argument. \n\n Method maps are maps of the keyword-ized method names to ordinary\n fns. This facilitates easy reuse of existing fns and fn maps, for\n code reuse/mixins without derivation or composition. You can extend\n an interface to a protocol. This is primarily to facilitate interop\n with the host (e.g. Java) but opens the door to incidental multiple\n inheritance of implementation since a class can inherit from more\n than one interface, both of which extend the protocol. It is TBD how\n to specify which impl to use. You can extend a protocol on nil.\n\n If you are supplying the definitions explicitly (i.e. not reusing\n exsting functions or mixin maps), you may find it more convenient to\n use the extend-type or extend-protocol macros.\n\n Note that multiple independent extend clauses can exist for the same\n type, not all protocols need be defined in a single extend call.\n\n See also:\n extends?, satisfies?, extenders", lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(116), lang.NewKeyword("end-line"), int(116))).(*lang.Symbol) +v0 := lang.NewSymbol("release-pending-sends").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Normally, actions sent directly or indirectly during another action\n are held until the action completes (changes the agent's\n state). This function can be used to dispatch any pending sent\n actions immediately. This has no impact on actions sent during a\n transaction, which are still held until commit. If no action is\n occurring, does nothing. Returns the number of actions dispatched.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2131), lang.NewKeyword("end-line"), int(2131))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.Apply(nil, nil) +return v3 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// rem +{ +var v1 lang.FnFunc +{ // function rem__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] -v4 := lang.NewList(args[1:]...) -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("seq")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("partition")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("concat")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v11 := v10.Get() -v12 := lang.Apply(v11, []any{int64(2), v4}) -v13 := lang.Apply(v8, []any{v12}) -var v5 any = v13 -_ = v5 -var v14 any = nil -_ = v14 -var v15 any = int64(0) -_ = v15 -var v16 any = int64(0) -_ = v16 -var v17 any -for { -var v18 any +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("list")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("<")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) if v20.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } v21 := v20.Get() -v22 := lang.Apply(v21, []any{v16, v15}) -if lang.IsTruthy(v22) { -v24, _ := lang.FieldOrMethod(v14, "nth") -if reflect.TypeOf(v24).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("seq")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -v25 := lang.Apply(v24, []any{v16}) -var v23 any = v25 -_ = v23 -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("nth")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("concat")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -v29 := v28.Get() -v30 := lang.Apply(v29, []any{v23, int64(0), nil}) -var v26 any = v30 -_ = v26 +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("list")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/remainder")}) v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("nth")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) if v33.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) } v34 := v33.Get() -v35 := lang.Apply(v34, []any{v23, int64(1), nil}) -var v31 any = v35 -_ = v31 -var v37 any -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("protocol?")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.Apply(v40, []any{v26}) -if lang.IsTruthy(v41) { -v37 = nil -} else { -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("str")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) -} -v44 := v43.Get() -v45 := lang.Apply(v44, []any{v26, " is not a protocol"}) -v46 := lang.Apply(errors10.New, []any{v45}) -panic(v46) +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) } -_ = v37 -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("reduce1")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v4}) +v40 := lang.Apply(v27, []any{v31, v35, v39}) +v41 := lang.Apply(v24, []any{v40}) +v42 := lang.Apply(v21, []any{v41}) +v43 := lang.Apply(v10, []any{v14, v18, v42}) +v44 := lang.Apply(v7, []any{v43}) +return v44 +}) +v2 := v1 +_ = v2 } -v49 := v48.Get() -var v50 lang.FnFunc -v50 = lang.NewFnFunc(func(args ...any) any { +v0 := lang.NewSymbol("rem").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"), lang.NewSymbol("div"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "remainder of dividing numerator by denominator.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1274), lang.NewKeyword("end-line"), int(1274))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v51 := args[0] -v52 := args[1] -var v53 any = v52 -_ = v53 -v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v56 := v55.FindInternedVar(lang.NewSymbol("nth")) -if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) +v4 := args[0] +v5 := args[1] +v6, _ := lang.FieldOrMethod(lang1.Numbers, "remainder") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("remainder is not a function"))) } -v57 := v56.Get() -v58 := lang.Apply(v57, []any{v53, int64(0), nil}) -var v54 any = v58 -_ = v54 -v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v61 := v60.FindInternedVar(lang.NewSymbol("nth")) -if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v62 := v61.Get() -v63 := lang.Apply(v62, []any{v53, int64(1), nil}) -var v59 any = v63 -_ = v59 -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("get-in")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) } -v67 := v66.Get() -v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v69 := v68.FindInternedVar(lang.NewSymbol("deref")) -if v69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) +// remove +{ +v0 := lang.NewSymbol("remove").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred")), lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the items in coll for which\n (pred item) returns logical false. pred must be free of side-effects.\n Returns a transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2818), lang.NewKeyword("end-line"), int(2818))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("filter")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v70 := v69.Get() -v71 := lang.Apply(v70, []any{v26}) -v72 := lang.NewVector(lang.NewKeyword("multis"), v54) -v73 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(158), lang.NewKeyword("column"), int(33), lang.NewKeyword("end-line"), int(158), lang.NewKeyword("end-column"), int(43)) -v74, err := lang.WithMeta(v72, v73.(lang.IPersistentMap)) -if err != nil { - panic(err) +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("complement")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v75 := lang.Apply(v67, []any{v71, v74}) -var v76 lang.FnFunc -v76 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v77 := args[0] -v78 := lang.NewList(args[1:]...) -v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v80 := v79.FindInternedVar(lang.NewSymbol("apply")) -if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v3}) +v11 := lang.Apply(v6, []any{v10}) +return v11 + case 2: +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("filter")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v81 := v80.Get() -v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v83 := v82.FindInternedVar(lang.NewSymbol("cons")) -if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("complement")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v84 := v83.Get() -v85 := lang.Apply(v84, []any{v77, v78}) -v86 := lang.Apply(v81, []any{v59, v85}) -return v86 +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v3}) +v12 := lang.Apply(v7, []any{v11, v4}) +return v12 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) -v77, _ := lang.FieldOrMethod(v75, "AddMethod") -if reflect.TypeOf(v77).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("AddMethod is not a function"))) -} -v78 := lang.Apply(v77, []any{v3, v76}) -return v78 -}) -v51 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(156), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(160), lang.NewKeyword("end-column"), int(45)) -v52, err := lang.WithMeta(v50, v51.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v53 := lang.Apply(v49, []any{v52, nil, v31}) -_ = v53 -var v54 any = v5 -var v55 any = v14 -var v56 any = v15 -v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v59 := v58.FindInternedVar(lang.NewSymbol("unchecked-inc")) -if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) -} -v60 := v59.Get() -v61 := lang.Apply(v60, []any{v16}) -var v57 any = v61 -v5 = v54 -v14 = v55 -v15 = v56 -v16 = v57 -continue -} else { -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("seq")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v5}) -var v23 any = v27 -_ = v23 -var v29 any -if lang.IsTruthy(v23) { -var v30 any = v23 -_ = v30 -var v32 any -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("chunked-seq?")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v30}) -if lang.IsTruthy(v36) { -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("chunk-first")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.Apply(v40, []any{v30}) -var v37 any = v41 -_ = v37 -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("chunk-rest")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v30}) -var v43 any = v47 -var v48 any = v37 -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("int")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("count")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) -} -v55 := v54.Get() -v56 := lang.Apply(v55, []any{v37}) -v57 := lang.Apply(v52, []any{v56}) -var v49 any = v57 -v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v60 := v59.FindInternedVar(lang.NewSymbol("int")) -if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) -} -v61 := v60.Get() -v62 := lang.Apply(v61, []any{int64(0)}) -var v58 any = v62 -v5 = v43 -v14 = v48 -v15 = v49 -v16 = v58 -continue -} else { -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("first")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.Apply(v40, []any{v30}) -var v37 any = v41 -_ = v37 -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("nth")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.Apply(v45, []any{v37, int64(0), nil}) -var v42 any = v46 -_ = v42 -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("nth")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v37, int64(1), nil}) -var v47 any = v51 -_ = v47 -var v53 any -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("protocol?")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) -} -v56 := v55.Get() -v57 := lang.Apply(v56, []any{v42}) -if lang.IsTruthy(v57) { -v53 = nil -} else { -v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v59 := v58.FindInternedVar(lang.NewSymbol("str")) -if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) -} -v60 := v59.Get() -v61 := lang.Apply(v60, []any{v42, " is not a protocol"}) -v62 := lang.Apply(errors10.New, []any{v61}) -panic(v62) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -_ = v53 -v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v64 := v63.FindInternedVar(lang.NewSymbol("reduce1")) -if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) } -v65 := v64.Get() -var v66 lang.FnFunc -v66 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { +// remove-all-methods +{ +v0 := lang.NewSymbol("remove-all-methods").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"))), lang.NewKeyword("doc"), "Removes all of the methods of multimethod.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1787), lang.NewKeyword("end-line"), int(1787))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v67 := args[0] -v68 := args[1] -var v69 any = v68 -_ = v69 -v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v72 := v71.FindInternedVar(lang.NewSymbol("nth")) -if v72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) +v3 := args[0] +v4, ok := lang.FieldOrMethod(v3, "reset") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "reset"))) } -v73 := v72.Get() -v74 := lang.Apply(v73, []any{v69, int64(0), nil}) -var v70 any = v74 -_ = v70 -v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v77 := v76.FindInternedVar(lang.NewSymbol("nth")) -if v77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) +var v5 any +switch reflect.TypeOf(v4).Kind() { +case reflect.Func: + v5 = lang.Apply(v4, nil) +default: + v5 = v4 } -v78 := v77.Get() -v79 := lang.Apply(v78, []any{v69, int64(1), nil}) -var v75 any = v79 -_ = v75 -v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v82 := v81.FindInternedVar(lang.NewSymbol("get-in")) -if v82.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v83 := v82.Get() -v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v85 := v84.FindInternedVar(lang.NewSymbol("deref")) -if v85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) } -v86 := v85.Get() -v87 := lang.Apply(v86, []any{v42}) -v88 := lang.NewVector(lang.NewKeyword("multis"), v70) -v89 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(158), lang.NewKeyword("column"), int(33), lang.NewKeyword("end-line"), int(158), lang.NewKeyword("end-column"), int(43)) -v90, err := lang.WithMeta(v88, v89.(lang.IPersistentMap)) -if err != nil { - panic(err) +// remove-method +{ +v0 := lang.NewSymbol("remove-method").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"), lang.NewSymbol("dispatch-val"))), lang.NewKeyword("doc"), "Removes the method of multimethod associated with dispatch-value.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1794), lang.NewKeyword("end-line"), int(1794))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5, _ := lang.FieldOrMethod(v3, "removeMethod") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("removeMethod is not a function"))) } -v91 := lang.Apply(v83, []any{v87, v90}) -var v92 lang.FnFunc -v92 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v93 := args[0] -v94 := lang.NewList(args[1:]...) -v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v96 := v95.FindInternedVar(lang.NewSymbol("apply")) -if v96.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v97 := v96.Get() -v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v99 := v98.FindInternedVar(lang.NewSymbol("cons")) -if v99.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) } -v100 := v99.Get() -v101 := lang.Apply(v100, []any{v93, v94}) -v102 := lang.Apply(v97, []any{v75, v101}) -return v102 +// remove-ns +{ +v0 := lang.NewSymbol("remove-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Removes the namespace named by the symbol. Use with caution.\n Cannot be used to remove the glojure namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4139), lang.NewKeyword("end-line"), int(4139))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } +v3 := args[0] +v4 := lang.Apply(lang1.RemoveNamespace, []any{v3}) +return v4 }) -v93, _ := lang.FieldOrMethod(v91, "AddMethod") -if reflect.TypeOf(v93).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("AddMethod is not a function"))) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v94 := lang.Apply(v93, []any{v3, v92}) -return v94 -}) -v67 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(156), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(160), lang.NewKeyword("end-column"), int(45)) -v68, err := lang.WithMeta(v66, v67.(lang.IPersistentMap)) -if err != nil { - panic(err) } -v69 := lang.Apply(v65, []any{v68, nil, v47}) -_ = v69 -v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v72 := v71.FindInternedVar(lang.NewSymbol("next")) -if v72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) +// remove-tap +{ +v0 := lang.NewSymbol("remove-tap").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Remove f from the tap set.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7926), lang.NewKeyword("end-line"), int(7926))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("swap!")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v73 := v72.Get() -v74 := lang.Apply(v73, []any{v30}) -var v70 any = v74 -var v75 any = nil -var v76 any = int64(0) -var v77 any = int64(0) -v5 = v70 -v14 = v75 -v15 = v76 -v16 = v77 -continue +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("tapset")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v29 = v32 -} else { -v29 = nil +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("disj")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v18 = v29 +v12 := v11.Get() +v13 := lang.Apply(v6, []any{v9, v12, v3}) +_ = v13 +return nil +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v17 = v18 - break } -return v17 +// remove-watch +{ +v0 := lang.NewSymbol("remove-watch").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("reference"), lang.NewSymbol("key"))), lang.NewKeyword("doc"), "Removes a watch (set by add-watch) from a reference", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2160), lang.NewKeyword("end-line"), int(2160))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } +v3 := args[0] +v4 := args[1] +v5, _ := lang.FieldOrMethod(v3, "removeWatch") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("removeWatch is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -66150,20 +66126,23 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// sorted-map-by +// repeat { -v0 := lang.NewSymbol("sorted-map-by").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("comparator"), lang.NewSymbol("&"), lang.NewSymbol("keyvals"))), lang.NewKeyword("doc"), "keyval => key val\n Returns a new sorted map with supplied mappings, using the supplied\n comparator. If any keys are equal, they are handled as if by\n repeated uses of assoc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(406), lang.NewKeyword("end-line"), int(406))).(*lang.Symbol) +v0 := lang.NewSymbol("repeat").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns a lazy (infinite!, or length n if supplied) sequence of xs.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2997), lang.NewKeyword("end-line"), int(2997))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + case 1: v3 := args[0] -v4 := lang.NewList(args[1:]...) -v5 := lang.Apply(nil, []any{v3, v4}) +v4 := lang.Apply(lang1.NewRepeat, []any{v3}) +return v4 + case 2: +v3 := args[0] +v4 := args[1] +v5 := lang.Apply(lang1.NewRepeatN, []any{v3, v4}) return v5 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -66172,167 +66151,256 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// throw-if +// repeatedly { -v0 := lang.NewSymbol("throw-if").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("fmt"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Throws a CompilerException with a message if pred is true", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5875), lang.NewKeyword("end-line"), int(5875), lang.NewKeyword("private"), true)).(*lang.Symbol) +v0 := lang.NewSymbol("repeatedly").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Takes a function of no args, presumably with side effects, and\n returns an infinite (or length n if supplied) lazy sequence of calls\n to it", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5167), lang.NewKeyword("end-line"), int(5167))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + case 1: +v3 := args[0] +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("cons")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v3, nil) +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("repeatedly")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v3}) +v13 := lang.Apply(v7, []any{v8, v12}) +return v13 +}) +v5 := lang.Apply(lang1.NewLazySeq, []any{v4}) +return v5 + case 2: v3 := args[0] v4 := args[1] -v5 := lang.NewList(args[2:]...) -var v6 any -if lang.IsTruthy(v3) { +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("take")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("apply")) +v9 := v8.FindInternedVar(lang.NewSymbol("repeatedly")) if v9.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("format")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v11 := lang.Apply(v10, []any{v4}) +v12 := lang.Apply(v7, []any{v3, v11}) +return v12 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v13 := v12.Get() -v14 := lang.Apply(v10, []any{v13, v4, v5}) -var v7 any = v14 -_ = v7 -v16 := lang.Apply(Exception24., []any{v7}) -var v15 any = v16 -_ = v15 -v18, ok := lang.FieldOrMethod(v15, "getStackTrace") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v15, "getStackTrace"))) } -var v19 any -switch reflect.TypeOf(v18).Kind() { -case reflect.Func: - v19 = lang.Apply(v18, nil) -default: - v19 = v18 +// replace +{ +v0 := lang.NewSymbol("replace").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("smap")), lang.NewVector(lang.NewSymbol("smap"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Given a map of replacement pairs and a vector/collection, returns a\n vector/seq with any elements = a key in smap replaced with the\n corresponding val in smap. Returns a transducer when no collection\n is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5082), lang.NewKeyword("end-line"), int(5082))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("map")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -var v17 any = v19 -_ = v17 -var v21 lang.FnFunc -v21 = lang.NewFnFunc(func(args ...any) any { +v6 := v5.Get() +var v7 lang.FnFunc +v7 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v22 := args[0] -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("not=")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +v8 := args[0] +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("find")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v25 := v24.Get() -v26, ok := lang.FieldOrMethod(v22, "getMethodName") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v22, "getMethodName"))) +v12 := v11.Get() +v13 := lang.Apply(v12, []any{v3, v8}) +var v9 any = v13 +_ = v9 +var v15 any +if lang.IsTruthy(v9) { +var v16 any = v9 +_ = v16 +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("val")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -var v27 any -switch reflect.TypeOf(v26).Kind() { -case reflect.Func: - v27 = lang.Apply(v26, nil) -default: - v27 = v26 +v20 := v19.Get() +v21 := lang.Apply(v20, []any{v16}) +v15 = v21 +} else { +v15 = v8 } -v28 := lang.Apply(v25, []any{v27, "doInvoke"}) -return v28 +return v15 }) -v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5882), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(5882), lang.NewKeyword("end-column"), int(74)) -v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) +v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5090), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5090), lang.NewKeyword("end-column"), int(47)) +v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) if err != nil { panic(err) } -var v20 any = v23 -_ = v20 +v10 := lang.Apply(v6, []any{v9}) +return v10 + case 2: +v3 := args[0] +v4 := args[1] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("vector?")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v4}) +if lang.IsTruthy(v9) { +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("reduce1")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +var v13 lang.FnFunc +v13 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v14 := args[0] +v15 := args[1] +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("find")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("nth")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.Apply(v22, []any{v14, v15}) +v24 := lang.Apply(v19, []any{v3, v23}) +var v16 any = v24 +_ = v16 +var v26 any +if lang.IsTruthy(v16) { +var v27 any = v16 +_ = v27 +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("assoc")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("val")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v27}) +v36 := lang.Apply(v31, []any{v14, v15, v35}) +v26 = v36 +} else { +v26 = v14 +} +return v26 +}) +v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5093), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(5096), lang.NewKeyword("end-column"), int(23)) +v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("range")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("count")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v4}) +v23 := lang.Apply(v18, []any{v22}) +v24 := lang.Apply(v12, []any{v15, v4, v23}) +v5 = v24 +} else { v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("into-array")) +v26 := v25.FindInternedVar(lang.NewSymbol("map")) if v26.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("drop")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() +var v28 lang.FnFunc +v28 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v29 := args[0] v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("drop-while")) +v32 := v31.FindInternedVar(lang.NewSymbol("find")) if v32.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } v33 := v32.Get() -v34 := lang.Apply(v33, []any{v20, v17}) -v35 := lang.Apply(v30, []any{int64(2), v34}) -v36 := lang.Apply(v27, []any{nil, v35}) -var v24 any = v36 -_ = v24 -v38, _ := lang.FieldOrMethod(v15, "setStackTrace") -if reflect.TypeOf(v38).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setStackTrace is not a function"))) -} -v39 := lang.Apply(v38, []any{v24}) -_ = v39 -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("*file*")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43, ok := lang.FieldOrMethod(nil, "Deref") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "Deref"))) -} -var v44 any -switch reflect.TypeOf(v43).Kind() { -case reflect.Func: - v44 = lang.Apply(v43, nil) -default: - v44 = v43 -} -v45, ok := lang.FieldOrMethod(nil, "Deref") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "Deref"))) -} -var v46 any -switch reflect.TypeOf(v45).Kind() { -case reflect.Func: - v46 = lang.Apply(v45, nil) -default: - v46 = v45 +v34 := lang.Apply(v33, []any{v3, v29}) +var v30 any = v34 +_ = v30 +var v36 any +if lang.IsTruthy(v30) { +var v37 any = v30 +_ = v37 +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("val")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) } -v47 := lang.Apply(CompilerException31., []any{v42, v44, v46, v15}) -panic(v47) +v41 := v40.Get() +v42 := lang.Apply(v41, []any{v37}) +v36 = v42 } else { -v6 = nil +v36 = v29 } -return v6 - } +return v36 }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v29 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5098), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(5098), lang.NewKeyword("end-column"), int(49)) +v30, err := lang.WithMeta(v28, v29.(lang.IPersistentMap)) +if err != nil { + panic(err) } +v31 := lang.Apply(v27, []any{v30, v4}) +v5 = v31 } -// hash -{ -v0 := lang.NewSymbol("hash").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns the hash code of its argument. Note this is the hash code\n consistent with =, and thus is different than .hashCode for Integer,\n Short, Byte and Clojure collections.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5189), lang.NewKeyword("end-line"), int(5189))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { +return v5 + default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := args[0] -v4 := lang.Apply(lang1.HashEq, []any{v3}) -return v4 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -66340,9 +66408,9 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// run! +// replicate { -v0 := lang.NewSymbol("run!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("proc"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Runs the supplied procedure (via reduce), for purposes of side\n effects, on successive items in the collection. Returns nil", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7751), lang.NewKeyword("end-line"), int(7751))).(*lang.Symbol) +v0 := lang.NewSymbol("replicate").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "DEPRECATED: Use 'repeat' instead.\n Returns a lazy seq of n xs.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("deprecated"), "1.3", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3004), lang.NewKeyword("end-line"), int(3004))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { @@ -66351,29 +66419,20 @@ v2 = lang.NewFnFunc(func(args ...any) any { v3 := args[0] v4 := args[1] v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("reduce")) +v6 := v5.FindInternedVar(lang.NewSymbol("take")) if v6.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } v7 := v6.Get() -var v8 lang.FnFunc -v8 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v9 := args[0] -v10 := args[1] -v11 := lang.Apply(v3, []any{v10}) -return v11 -}) -v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7756), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(7756), lang.NewKeyword("end-column"), int(20)) -v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) -if err != nil { - panic(err) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("repeat")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v11 := lang.Apply(v7, []any{v10, nil, v4}) -_ = v11 -return nil +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v4}) +v12 := lang.Apply(v7, []any{v3, v11}) +return v12 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -66381,59 +66440,32 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// line-seq +// require { -v0 := lang.NewSymbol("line-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rdr"))), lang.NewKeyword("doc"), "Returns the lines of text from rdr as a lazy sequence of strings.\n rdr must implement java.io.BufferedReader.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3068), lang.NewKeyword("end-line"), int(3068))).(*lang.Symbol) +v0 := lang.NewSymbol("require").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Loads libs, skipping any that are already loaded. Each argument is\n either a libspec that identifies a lib, a prefix list that identifies\n multiple libs whose names share a common prefix, or a flag that modifies\n how all the identified libs are loaded. Use :require in the ns macro\n in preference to calling this directly.\n\n Libs\n\n A 'lib' is a named set of resources in classpath whose contents define a\n library of Clojure code. Lib names are symbols and each lib is associated\n with a Clojure namespace and a Java package that share its name. A lib's\n name also locates its root directory within classpath using Java's\n package name to classpath-relative path mapping. All resources in a lib\n should be contained in the directory structure under its root directory.\n All definitions a lib makes should be in its associated namespace.\n\n 'require loads a lib by loading its root resource. The root resource path\n is derived from the lib name in the following manner:\n Consider a lib named by the symbol 'x.y.z; it has the root directory\n /x/y/, and its root resource is /x/y/z.clj, or\n /x/y/z.cljc if /x/y/z.clj does not exist. The\n root resource should contain code to create the lib's\n namespace (usually by using the ns macro) and load any additional\n lib resources.\n\n Libspecs\n\n A libspec is a lib name or a vector containing a lib name followed by\n options expressed as sequential keywords and arguments.\n\n Recognized options:\n :as takes a symbol as its argument and makes that symbol an alias to the\n lib's namespace in the current namespace.\n :as-alias takes a symbol as its argument and aliases like :as, however\n the lib will not be loaded. If the lib has not been loaded, a new\n empty namespace will be created (as with create-ns).\n :refer takes a list of symbols to refer from the namespace or the :all\n keyword to bring in all public vars.\n\n Prefix Lists\n\n It's common for Clojure code to depend on several libs whose names have\n the same prefix. When specifying libs, prefix lists can be used to reduce\n repetition. A prefix list contains the shared prefix followed by libspecs\n with the shared prefix removed from the lib names. After removing the\n prefix, the names that remain must not contain any periods.\n\n Flags\n\n A flag is a keyword.\n Recognized flags: :reload, :reload-all, :verbose\n :reload forces loading of all the identified libs even if they are\n already loaded (has no effect on libspecs using :as-alias)\n :reload-all implies :reload and also forces loading of all libs that the\n identified libs directly or indirectly load via require or use\n (has no effect on libspecs using :as-alias)\n :verbose triggers printing information about each load, alias, and refer\n\n Example:\n\n The following would load the libraries glojure.zip and glojure.set\n abbreviated as 's'.\n\n (require '(glojure zip [set :as s]))", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6032), lang.NewKeyword("end-line"), int(6032))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v5, ok := lang.FieldOrMethod(v3, "readLine") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "readLine"))) -} -var v6 any -switch reflect.TypeOf(v5).Kind() { -case reflect.Func: - v6 = lang.Apply(v5, nil) -default: - v6 = v5 + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.NewList(args[0:]...) +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("apply")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -var v4 any = v6 -_ = v4 -var v8 any -if lang.IsTruthy(v4) { -var v9 any = v4 -_ = v9 -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("cons")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("load-libs")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v13 := v12.Get() -var v14 lang.FnFunc -v14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) +v9 := v8.Get() +v10 := lang.Apply(v6, []any{v9, lang.NewKeyword("require"), v3}) +return v10 } -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("line-seq")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v3}) -return v18 -}) -v15 := lang.Apply(lang1.NewLazySeq, []any{v14}) -v16 := lang.Apply(v13, []any{v9, v15}) -v8 = v16 -} else { -v8 = nil -} -return v8 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -66441,75 +66473,81 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// mod +// requiring-resolve { -v0 := lang.NewSymbol("mod").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"), lang.NewSymbol("div"))), lang.NewKeyword("doc"), "Modulus of num and div. Truncates toward negative infinity.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3567), lang.NewKeyword("end-line"), int(3567))).(*lang.Symbol) +v0 := lang.NewSymbol("requiring-resolve").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Resolves namespace-qualified sym per 'resolve'. If initial resolve\nfails, attempts to require sym's namespace and retries.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6111), lang.NewKeyword("end-line"), int(6111))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := args[1] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("rem")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("qualified-symbol?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v3, v4}) -var v5 any = v9 -_ = v5 -var v11 any -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("zero?")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +if lang.IsTruthy(v8) { +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("resolve")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v5}) -var v12 any = v16 -_ = v12 -var v18 any -if lang.IsTruthy(v12) { -v18 = v12 +v12 := v11.Get() +v13 := lang.Apply(v12, []any{v3}) +var v9 any = v13 +_ = v9 +var v15 any +if lang.IsTruthy(v9) { +v15 = v9 } else { +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("serialized-require")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("=")) +v20 := v19.FindInternedVar(lang.NewSymbol("symbol")) if v20.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } v21 := v20.Get() v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("pos?")) +v23 := v22.FindInternedVar(lang.NewSymbol("namespace")) if v23.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } v24 := v23.Get() v25 := lang.Apply(v24, []any{v3}) -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("pos?")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +v26 := lang.Apply(v21, []any{v25}) +v27 := lang.Apply(v18, []any{v26}) +_ = v27 +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("resolve")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } -v28 := v27.Get() -v29 := lang.Apply(v28, []any{v4}) -v30 := lang.Apply(v21, []any{v25, v29}) -v18 = v30 +v30 := v29.Get() +v31 := lang.Apply(v30, []any{v3}) +v15 = v31 } -if lang.IsTruthy(v18) { -v11 = v5 +v4 = v15 } else { -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("+")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("str")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v5, v4}) -v11 = v15 +v11 := v10.Get() +v12 := lang.Apply(v11, []any{"Not a qualified symbol: ", v3}) +v13 := lang.Apply(lang1.NewIllegalArgumentError, []any{v12}) +panic(v13) } -return v11 +return v4 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -66517,439 +66555,531 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// add-annotations +// reset! { -v0 := lang.NewSymbol("add-annotations").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5511), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(5511), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("visitor"), lang.NewSymbol("m")), lang.NewVector(lang.NewSymbol("visitor"), lang.NewSymbol("m"), lang.NewSymbol("i"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v0 := lang.NewSymbol("reset!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atom"), lang.NewSymbol("newval"))), lang.NewKeyword("doc"), "Sets the value of atom to newval without regard for the\n current value. Returns newval.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2368), lang.NewKeyword("end-line"), int(2368))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5, _ := lang.FieldOrMethod(v3, "reset") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// reset-meta! +{ +v0 := lang.NewSymbol("reset-meta!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("iref"), lang.NewSymbol("metadata-map"))), lang.NewKeyword("doc"), "Atomically resets the metadata for a namespace/var/ref/agent/atom", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2408), lang.NewKeyword("end-line"), int(2408))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5, _ := lang.FieldOrMethod(v3, "ResetMeta") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ResetMeta is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// reset-vals! +{ +v0 := lang.NewSymbol("reset-vals!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atom"), lang.NewSymbol("newval"))), lang.NewKeyword("doc"), "Sets the value of atom to newval. Returns [old new], the value of the\n atom before and after the reset.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2375), lang.NewKeyword("end-line"), int(2375))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5, _ := lang.FieldOrMethod(v3, "resetVals") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("resetVals is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// resolve +{ +v0 := lang.NewSymbol("resolve").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym")), lang.NewVector(lang.NewSymbol("env"), lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "same as (ns-resolve *ns* symbol) or (ns-resolve *ns* &env symbol)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4371), lang.NewKeyword("end-line"), int(4371))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { + case 1: +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("ns-resolve")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("*ns*")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v6, []any{v9, v3}) +return v10 case 2: v3 := args[0] v4 := args[1] v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("add-annotations")) +v6 := v5.FindInternedVar(lang.NewSymbol("ns-resolve")) if v6.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3, v4, nil}) -return v8 - case 3: +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("*ns*")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v7, []any{v10, v3, v4}) +return v11 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// rest +{ +v1 := reflect.TypeOf((*lang1.ISeq)(nil)).Elem() +v0 := lang.NewSymbol("rest").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a possibly empty seq of the items after the first. Calls seq on its\n argument.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(64), lang.NewKeyword("end-line"), int(70))).(*lang.Symbol) +var v3 lang.FnFunc +{ // function rest +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +v6 := lang.Apply(lang1.Rest, []any{v5}) +return v6 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(70), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(70), lang.NewKeyword("end-column"), int(77))).(lang.FnFunc) +v4 := v3 +_ = v4 +} +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// restart-agent +{ +v0 := lang.NewSymbol("restart-agent").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("new-state"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "When an agent is failed, changes the agent state to new-state and\n then un-fails the agent so that sends are allowed again. If\n a :clear-actions true option is given, any actions queued on the\n agent that were being held while it was failed will be discarded,\n otherwise those held actions will proceed. The new-state must pass\n the validator if any, or restart will throw an exception and the\n agent will remain failed with its old state and error. Watchers, if\n any, will NOT be notified of the new state. Throws an exception if\n the agent is not failed.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2175), lang.NewKeyword("end-line"), int(2175))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] v4 := args[1] -v5 := args[2] +v5 := lang.NewList(args[2:]...) v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("seq")) +v8 := v7.FindInternedVar(lang.NewSymbol("apply")) if v8.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } v9 := v8.Get() -v10 := lang.Apply(v9, []any{v4}) -var v6 any = v10 +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("hash-map")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v9, []any{v12, v5}) +var v6 any = v13 _ = v6 -var v11 any = nil -_ = v11 -var v12 any = int64(0) -_ = v12 -var v13 any = int64(0) -_ = v13 -var v14 any -for { var v15 any -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("<")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v13, v12}) -if lang.IsTruthy(v19) { -v21, _ := lang.FieldOrMethod(v11, "nth") -if reflect.TypeOf(v21).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) -} -v22 := lang.Apply(v21, []any{v13}) -var v20 any = v22 -_ = v20 -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("nth")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v20, int64(0), nil}) -var v23 any = v27 -_ = v23 -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("nth")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.Apply(v31, []any{v20, int64(1), nil}) -var v28 any = v32 -_ = v28 -var v34 any -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("symbol?")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +v16 := lang.Apply(lang.NewKeyword("clear-actions"), []any{v6}) +if lang.IsTruthy(v16) { +v15 = true +} else { +v15 = false } -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v23}) -if lang.IsTruthy(v38) { -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("resolve")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +v17, _ := lang.FieldOrMethod(v3, "restart") +if reflect.TypeOf(v17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("restart is not a function"))) } -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v23}) -var v39 any = v43 -_ = v39 -var v45 any -if lang.IsTruthy(v39) { -var v46 any = v39 -_ = v46 -var v48 any -v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v50 := v49.FindInternedVar(lang.NewSymbol("is-annotation?")) -if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) +v18 := lang.Apply(v17, []any{v4, v15}) +return v18 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v51 := v50.Get() -v52 := lang.Apply(v51, []any{v46}) -if lang.IsTruthy(v52) { -var v54 any -if lang.IsTruthy(v5) { -v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v56 := v55.FindInternedVar(lang.NewSymbol("descriptor")) -if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) } -v57 := v56.Get() -v58 := lang.Apply(v57, []any{v46}) -v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v60 := v59.FindInternedVar(lang.NewSymbol("is-runtime-annotation?")) -if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) +// resultset-seq +{ +v0 := lang.NewSymbol("resultset-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rs"))), lang.NewKeyword("doc"), "Creates and returns a lazy sequence of structmaps corresponding to\n the rows in the java.sql.ResultSet rs", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5724), lang.NewKeyword("end-line"), int(5724))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v5, _ := lang.FieldOrMethod(v3, "getMetaData") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getMetaData is not a function"))) } -v61 := v60.Get() -v62 := lang.Apply(v61, []any{v46}) -v63, _ := lang.FieldOrMethod(v3, "visitParameterAnnotation") -if reflect.TypeOf(v63).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("visitParameterAnnotation is not a function"))) +v6 := lang.Apply(v5, []any{}) +var v4 any = v6 +_ = v4 +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("range")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v64 := lang.Apply(v63, []any{v5, v58, v62}) -v54 = v64 -} else { -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("descriptor")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("inc")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v67 := v66.Get() -v68 := lang.Apply(v67, []any{v46}) -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("is-runtime-annotation?")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +v13 := v12.Get() +v14, _ := lang.FieldOrMethod(v4, "getColumnCount") +if reflect.TypeOf(v14).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getColumnCount is not a function"))) } -v71 := v70.Get() -v72 := lang.Apply(v71, []any{v46}) -v73, _ := lang.FieldOrMethod(v3, "visitAnnotation") -if reflect.TypeOf(v73).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("visitAnnotation is not a function"))) +v15 := lang.Apply(v14, []any{}) +v16 := lang.Apply(v13, []any{v15}) +v17 := lang.Apply(v10, []any{int64(1), v16}) +var v7 any = v17 +_ = v7 +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("map")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v74 := lang.Apply(v73, []any{v68, v72}) -v54 = v74 +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("comp")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -var v53 any = v54 -_ = v53 -v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v77 := v76.FindInternedVar(lang.NewSymbol("process-annotation")) -if v77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("keyword")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -v78 := v77.Get() -v79 := lang.Apply(v78, []any{v53, v28}) -_ = v79 -v80, ok := lang.FieldOrMethod(v53, "visitEnd") +v27 := v26.Get() +var v28 lang.FnFunc +v28 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v29 := args[0] +v30, ok := lang.FieldOrMethod(v29, "toLowerCase") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v53, "visitEnd"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v29, "toLowerCase"))) } -var v81 any -switch reflect.TypeOf(v80).Kind() { +var v31 any +switch reflect.TypeOf(v30).Kind() { case reflect.Func: - v81 = lang.Apply(v80, nil) + v31 = lang.Apply(v30, nil) default: - v81 = v80 -} -v48 = v81 -} else { -v48 = nil -} -v45 = v48 -} else { -v45 = nil -} -v34 = v45 -} else { -v34 = nil -} -_ = v34 -var v39 any = v6 -var v40 any = v11 -var v41 any = v12 -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("unchecked-inc")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.Apply(v45, []any{v13}) -var v42 any = v46 -v6 = v39 -v11 = v40 -v12 = v41 -v13 = v42 -continue -} else { -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + v31 = v30 } -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v6}) -var v20 any = v24 -_ = v20 -var v26 any -if lang.IsTruthy(v20) { -var v27 any = v20 -_ = v27 -var v29 any -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("chunked-seq?")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +return v31 +}) +v29 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5731), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(5731), lang.NewKeyword("end-column"), int(62)) +v30, err := lang.WithMeta(v28, v29.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v32 := v31.Get() -v33 := lang.Apply(v32, []any{v27}) -if lang.IsTruthy(v33) { -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("chunk-first")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +v31 := lang.Apply(v24, []any{v27, v30}) +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("map")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) } -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v27}) -var v34 any = v38 -_ = v34 -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("chunk-rest")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +v34 := v33.Get() +var v35 lang.FnFunc +v35 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v36 := args[0] +v37, _ := lang.FieldOrMethod(v4, "getColumnLabel") +if reflect.TypeOf(v37).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getColumnLabel is not a function"))) } -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v27}) -var v40 any = v44 -var v45 any = v34 -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("int")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +v38 := lang.Apply(v37, []any{v36}) +return v38 +}) +v36 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5732), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(5732), lang.NewKeyword("end-column"), int(63)) +v37, err := lang.WithMeta(v35, v36.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v49 := v48.Get() -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("count")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +v38 := lang.Apply(v34, []any{v37, v7}) +v39 := lang.Apply(v21, []any{v31, v38}) +var v18 any = v39 +_ = v18 +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("apply")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) } -v52 := v51.Get() -v53 := lang.Apply(v52, []any{v34}) -v54 := lang.Apply(v49, []any{v53}) -var v46 any = v54 -v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v57 := v56.FindInternedVar(lang.NewSymbol("int")) -if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) +v44 := v43.Get() +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("distinct?")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) } -v58 := v57.Get() -v59 := lang.Apply(v58, []any{int64(0)}) -var v55 any = v59 -v6 = v40 -v11 = v45 -v12 = v46 -v13 = v55 -continue +v47 := v46.Get() +v48 := lang.Apply(v44, []any{v47, v18}) +var v41 any = v48 +_ = v41 +var v50 any +if lang.IsTruthy(v41) { +v50 = v41 } else { -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("first")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +v51 := lang.Apply(Exception16., []any{"ResultSet must have unique column labels"}) +panic(v51) } -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v27}) -var v34 any = v38 -_ = v34 -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("nth")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +var v40 any = v50 +_ = v40 +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("apply")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) } -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v34, int64(0), nil}) -var v39 any = v43 -_ = v39 +v44 := v43.Get() v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("nth")) +v46 := v45.FindInternedVar(lang.NewSymbol("create-struct")) if v46.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) } v47 := v46.Get() -v48 := lang.Apply(v47, []any{v34, int64(1), nil}) -var v44 any = v48 -_ = v44 -var v50 any +v48 := lang.Apply(v44, []any{v47, v18}) +var v41 any = v48 +_ = v41 +var v50 lang.FnFunc +v50 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v52 := v51.FindInternedVar(lang.NewSymbol("symbol?")) +v52 := v51.FindInternedVar(lang.NewSymbol("map")) if v52.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) } v53 := v52.Get() -v54 := lang.Apply(v53, []any{v39}) -if lang.IsTruthy(v54) { -v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v57 := v56.FindInternedVar(lang.NewSymbol("resolve")) -if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) +var v54 lang.FnFunc +v54 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v55 := args[0] +v56, _ := lang.FieldOrMethod(v3, "getObject") +if reflect.TypeOf(v56).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getObject is not a function"))) } -v58 := v57.Get() -v59 := lang.Apply(v58, []any{v39}) -var v55 any = v59 -_ = v55 -var v61 any -if lang.IsTruthy(v55) { -var v62 any = v55 -_ = v62 -var v64 any +v57 := lang.Apply(v56, []any{v55}) +return v57 +}) +v55 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5737), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(5737), lang.NewKeyword("end-column"), int(71)) +v56, err := lang.WithMeta(v54, v55.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v57 := lang.Apply(v53, []any{v56, v7}) +return v57 +}) +v51 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5737), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(5737), lang.NewKeyword("end-column"), int(78)) +v52, err := lang.WithMeta(v50, v51.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v49 any = v52 +_ = v49 +var v54 lang.FnFunc +{ // function thisfn +v54 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +var v56 any +v57, _ := lang.FieldOrMethod(v3, "next") +if reflect.TypeOf(v57).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("next is not a function"))) +} +v58 := lang.Apply(v57, []any{}) +if lang.IsTruthy(v58) { +v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v60 := v59.FindInternedVar(lang.NewSymbol("cons")) +if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) +} +v61 := v60.Get() +v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v63 := v62.FindInternedVar(lang.NewSymbol("apply")) +if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +} +v64 := v63.Get() v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("is-annotation?")) +v66 := v65.FindInternedVar(lang.NewSymbol("struct")) if v66.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) } v67 := v66.Get() -v68 := lang.Apply(v67, []any{v62}) -if lang.IsTruthy(v68) { -var v70 any -if lang.IsTruthy(v5) { -v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v72 := v71.FindInternedVar(lang.NewSymbol("descriptor")) -if v72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) -} -v73 := v72.Get() -v74 := lang.Apply(v73, []any{v62}) -v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v76 := v75.FindInternedVar(lang.NewSymbol("is-runtime-annotation?")) -if v76.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) -} -v77 := v76.Get() -v78 := lang.Apply(v77, []any{v62}) -v79, _ := lang.FieldOrMethod(v3, "visitParameterAnnotation") -if reflect.TypeOf(v79).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("visitParameterAnnotation is not a function"))) -} -v80 := lang.Apply(v79, []any{v5, v74, v78}) -v70 = v80 +v68 := lang.Apply(v49, nil) +v69 := lang.Apply(v64, []any{v67, v41, v68}) +var v70 lang.FnFunc +v70 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v71 := lang.Apply(v55, nil) +return v71 +}) +v71 := lang.Apply(lang1.NewLazySeq, []any{v70}) +v72 := lang.Apply(v61, []any{v69, v71}) +v56 = v72 } else { -v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v82 := v81.FindInternedVar(lang.NewSymbol("descriptor")) -if v82.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) -} -v83 := v82.Get() -v84 := lang.Apply(v83, []any{v62}) -v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v86 := v85.FindInternedVar(lang.NewSymbol("is-runtime-annotation?")) -if v86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) +v56 = nil } -v87 := v86.Get() -v88 := lang.Apply(v87, []any{v62}) -v89, _ := lang.FieldOrMethod(v3, "visitAnnotation") -if reflect.TypeOf(v89).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("visitAnnotation is not a function"))) +return v56 +}) +v55 := v54 +_ = v55 } -v90 := lang.Apply(v89, []any{v84, v88}) -v70 = v90 +v55 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5738), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(5740), lang.NewKeyword("end-column"), int(86)) +v56, err := lang.WithMeta(v54, v55.(lang.IPersistentMap)) +if err != nil { + panic(err) } -var v69 any = v70 -_ = v69 -v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v93 := v92.FindInternedVar(lang.NewSymbol("process-annotation")) -if v93.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) +var v53 any = v56 +_ = v53 +v58 := lang.Apply(v53, nil) +return v58 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v94 := v93.Get() -v95 := lang.Apply(v94, []any{v69, v44}) -_ = v95 -v96, ok := lang.FieldOrMethod(v69, "visitEnd") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v69, "visitEnd"))) } -var v97 any -switch reflect.TypeOf(v96).Kind() { -case reflect.Func: - v97 = lang.Apply(v96, nil) -default: - v97 = v96 +// reverse +{ +v0 := lang.NewSymbol("reverse").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a seq of the items in coll in reverse order. Not lazy.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(940), lang.NewKeyword("end-line"), int(940))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("reduce1")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v64 = v97 -} else { -v64 = nil +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("conj")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v61 = v64 -} else { -v61 = nil +v9 := v8.Get() +v10 := lang.Apply(v6, []any{v9, lang.NewList(), v3}) +return v10 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v50 = v61 -} else { -v50 = nil } -_ = v50 -v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v57 := v56.FindInternedVar(lang.NewSymbol("next")) -if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) +// reversible? +{ +v0 := lang.NewSymbol("reversible?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements Reversible", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6300), lang.NewKeyword("end-line"), int(6300))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v58 := v57.Get() -v59 := lang.Apply(v58, []any{v27}) -var v55 any = v59 -var v60 any = nil -var v61 any = int64(0) -var v62 any = int64(0) -v6 = v55 -v11 = v60 -v12 = v61 -v13 = v62 -continue +v6 := v5.Get() +v7 := lang.Apply(v6, []any{glojure.lang8.Reversible, v3}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v26 = v29 -} else { -v26 = nil } -v15 = v26 +// root-directory +{ +v0 := lang.NewSymbol("root-directory").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"))), lang.NewKeyword("doc"), "Returns the root resource path for a lib", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5914), lang.NewKeyword("end-line"), int(5914), lang.NewKeyword("private"), true)).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("root-resource")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v14 = v15 - break +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +var v4 any = v8 +_ = v4 +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("subs")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } +v12 := v11.Get() +v13 := lang.Apply(strings22.LastIndex, []any{v4, "/"}) +v14 := lang.Apply(v12, []any{v4, int64(0), v13}) return v14 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -66957,23 +67087,56 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// sequential? +// root-resource { -v0 := lang.NewSymbol("sequential?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements Sequential", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6272), lang.NewKeyword("end-line"), int(6272))).(*lang.Symbol) +v1 := reflect.TypeOf("") +v0 := lang.NewSymbol("root-resource").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"))), lang.NewKeyword("doc"), "Returns the root directory path for a lib", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5907), lang.NewKeyword("end-line"), int(5907), lang.NewKeyword("private"), true)).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("str")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("name")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v4}) +v12 := lang.Apply(strings22.ReplaceAll, []any{v11, "-", "_"}) +v13 := lang.Apply(strings22.ReplaceAll, []any{v12, ".", "/"}) +v14 := lang.Apply(v7, []any{lang.NewChar(47), v13}) +return v14 +}) +v4 := reflect.TypeOf("") +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// rseq +{ +v0 := lang.NewSymbol("rseq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rev"))), lang.NewKeyword("doc"), "Returns, in constant time, a seq of the items in rev (which\n can be a vector or sorted-map), in reverse order. If rev is empty returns nil", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1577), lang.NewKeyword("end-line"), int(1577))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v4, _ := lang.FieldOrMethod(v3, "rseq") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("rseq is not a function"))) } -v6 := v5.Get() -v7 := lang.Apply(v6, []any{lang1.Sequential, v3}) -return v7 +v5 := lang.Apply(v4, []any{}) +return v5 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -66981,1140 +67144,1289 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// case +// rsubseq { -v0 := lang.NewSymbol("case").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("e"), lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes an expression, and a set of clauses.\n\n Each clause can take the form of either:\n\n test-constant result-expr\n\n (test-constant1 ... test-constantN) result-expr\n\n The test-constants are not evaluated. They must be compile-time\n literals, and need not be quoted. If the expression is equal to a\n test-constant, the corresponding result-expr is returned. A single\n default expression can follow the clauses, and its value will be\n returned if no clause matches. If no default expression is provided\n and no clause matches, an IllegalArgumentException is thrown.\n\n Unlike cond and condp, case does a constant-time dispatch, the\n clauses are not considered sequentially. All manner of constant\n expressions are acceptable in case, including numbers, strings,\n symbols, keywords, and (Clojure) composites thereof. Note that since\n lists are used to group multiple constants that map to the same\n expression, a vector can be used to match a list if needed. The\n test-constants need not be all of the same type.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6755), lang.NewKeyword("end-line"), int(6755))).(*lang.Symbol) +v0 := lang.NewSymbol("rsubseq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sc"), lang.NewSymbol("test"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("sc"), lang.NewSymbol("start-test"), lang.NewSymbol("start-key"), lang.NewSymbol("end-test"), lang.NewSymbol("end-key"))), lang.NewKeyword("doc"), "sc must be a sorted collection, test(s) one of <, <=, > or\n >=. Returns a reverse seq of those entries with keys ek for\n which (test (.. sc comparator (compare ek key)) 0) is true", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5150), lang.NewKeyword("end-line"), int(5150))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + case 3: v3 := args[0] v4 := args[1] v5 := args[2] -v6 := lang.NewList(args[3:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("with-meta")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("mk-bound-fn")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("gensym")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v3, v4, v5}) +var v6 any = v10 +_ = v6 +var v12 any +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("<")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } -v13 := v12.Get() -v14 := lang.Apply(v13, nil) -v15 := lang.NewMap(lang.NewKeyword("tag"), lang1.Object) -v16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6781), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(6781), lang.NewKeyword("end-column"), int(84)) -v17, err := lang.WithMeta(v15, v16.(lang.IPersistentMap)) +v15 := v14.Get() +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("<=")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.CreatePersistentTreeSet(v15, v18) +v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5158), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5158), lang.NewKeyword("end-column"), int(17)) +v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) if err != nil { panic(err) } -v18 := lang.Apply(v10, []any{v14, v17}) -var v7 any = v18 -_ = v7 -var v20 any +v22 := lang.Apply(v21, []any{v4}) +if lang.IsTruthy(v22) { +v24, _ := lang.FieldOrMethod(v3, "seqFrom") +if reflect.TypeOf(v24).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("seqFrom is not a function"))) +} +v25 := lang.Apply(v24, []any{v5, false}) +var v23 any = v25 +_ = v23 +var v27 any +if lang.IsTruthy(v23) { +var v28 any = v23 +_ = v28 +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("nth")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.Apply(v32, []any{v28, int64(0), nil}) +var v29 any = v33 +_ = v29 +var v34 any = v28 +_ = v34 +var v36 any +v37 := lang.Apply(v6, []any{v29}) +if lang.IsTruthy(v37) { +v36 = v34 +} else { +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("next")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.Apply(v40, []any{v34}) +v36 = v41 +} +v27 = v36 +} else { +v27 = nil +} +v12 = v27 +} else { +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("take-while")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26, _ := lang.FieldOrMethod(v3, "seq") +if reflect.TypeOf(v26).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("seq is not a function"))) +} +v27 := lang.Apply(v26, []any{false}) +v28 := lang.Apply(v25, []any{v6, v27}) +v12 = v28 +} +return v12 + case 5: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := args[4] +v9, _ := lang.FieldOrMethod(v3, "seqFrom") +if reflect.TypeOf(v9).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("seqFrom is not a function"))) +} +v10 := lang.Apply(v9, []any{v7, false}) +var v8 any = v10 +_ = v8 +var v12 any +if lang.IsTruthy(v8) { +var v13 any = v8 +_ = v13 +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("nth")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v13, int64(0), nil}) +var v14 any = v18 +_ = v14 +var v19 any = v13 +_ = v19 v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("odd?")) +v22 := v21.FindInternedVar(lang.NewSymbol("take-while")) if v22.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } v23 := v22.Get() v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("count")) +v25 := v24.FindInternedVar(lang.NewSymbol("mk-bound-fn")) if v25.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } v26 := v25.Get() -v27 := lang.Apply(v26, []any{v6}) -v28 := lang.Apply(v23, []any{v27}) -if lang.IsTruthy(v28) { +v27 := lang.Apply(v26, []any{v3, v4, v5}) +var v28 any v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("last")) +v30 := v29.FindInternedVar(lang.NewSymbol("mk-bound-fn")) if v30.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) } v31 := v30.Get() -v32 := lang.Apply(v31, []any{v6}) -v20 = v32 +v32 := lang.Apply(v31, []any{v3, v6, v7}) +v33 := lang.Apply(v32, []any{v14}) +if lang.IsTruthy(v33) { +v28 = v19 } else { -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("seq")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("concat")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("list")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) -} -v41 := v40.Get() -v42 := lang.Apply(v41, []any{lang.NewSymbol("throw")}) -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("list")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("seq")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) -} -v48 := v47.Get() -v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v50 := v49.FindInternedVar(lang.NewSymbol("concat")) -if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) -} -v51 := v50.Get() -v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("list")) -if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) -} -v54 := v53.Get() -v55 := lang.Apply(v54, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewIllegalArgumentError")}) -v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v57 := v56.FindInternedVar(lang.NewSymbol("list")) -if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) -} -v58 := v57.Get() -v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v60 := v59.FindInternedVar(lang.NewSymbol("seq")) -if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) -} -v61 := v60.Get() -v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v63 := v62.FindInternedVar(lang.NewSymbol("concat")) -if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("next")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } -v64 := v63.Get() -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("list")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +v36 := v35.Get() +v37 := lang.Apply(v36, []any{v19}) +v28 = v37 } -v67 := v66.Get() -v68 := lang.Apply(v67, []any{lang.NewSymbol("glojure.core/str")}) -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("list")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +v38 := lang.Apply(v23, []any{v27, v28}) +v12 = v38 +} else { +v12 = nil } -v71 := v70.Get() -v72 := lang.Apply(v71, []any{"No matching clause: "}) -v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v74 := v73.FindInternedVar(lang.NewSymbol("list")) -if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) +return v12 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v75 := v74.Get() -v76 := lang.Apply(v75, []any{v7}) -v77 := lang.Apply(v64, []any{v68, v72, v76}) -v78 := lang.Apply(v61, []any{v77}) -v79 := lang.Apply(v58, []any{v78}) -v80 := lang.Apply(v51, []any{v55, v79}) -v81 := lang.Apply(v48, []any{v80}) -v82 := lang.Apply(v45, []any{v81}) -v83 := lang.Apply(v38, []any{v42, v82}) -v84 := lang.Apply(v35, []any{v83}) -v20 = v84 } -var v19 any = v20 -_ = v19 -var v86 any -v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v88 := v87.FindInternedVar(lang.NewSymbol(">")) -if v88.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) +// run! +{ +v0 := lang.NewSymbol("run!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("proc"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Runs the supplied procedure (via reduce), for purposes of side\n effects, on successive items in the collection. Returns nil", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7751), lang.NewKeyword("end-line"), int(7751))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("reduce")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v89 := v88.Get() -v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v91 := v90.FindInternedVar(lang.NewSymbol("count")) -if v91.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) +v7 := v6.Get() +var v8 lang.FnFunc +v8 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v9 := args[0] +v10 := args[1] +v11 := lang.Apply(v3, []any{v10}) +return v11 +}) +v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7756), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(7756), lang.NewKeyword("end-column"), int(20)) +v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v92 := v91.Get() -v93 := lang.Apply(v92, []any{v6}) -v94 := lang.Apply(v89, []any{int64(2), v93}) -if lang.IsTruthy(v94) { -v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v96 := v95.FindInternedVar(lang.NewSymbol("seq")) -if v96.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) +v11 := lang.Apply(v7, []any{v10, nil, v4}) +_ = v11 +return nil +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v97 := v96.Get() -v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v99 := v98.FindInternedVar(lang.NewSymbol("concat")) -if v99.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) } -v100 := v99.Get() -v101 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v102 := v101.FindInternedVar(lang.NewSymbol("list")) -if v102.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v102))) +// second +{ +v0 := lang.NewSymbol("second").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Same as (first (next x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(91), lang.NewKeyword("end-line"), int(95))).(*lang.Symbol) +var v2 lang.FnFunc +{ // function second +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("first")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v103 := v102.Get() -v104 := lang.Apply(v103, []any{lang.NewSymbol("glojure.core/let")}) -v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v106 := v105.FindInternedVar(lang.NewSymbol("list")) -if v106.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("next")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v107 := v106.Get() -v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v109 := v108.FindInternedVar(lang.NewSymbol("apply")) -if v109.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v4}) +v12 := lang.Apply(v7, []any{v11}) +return v12 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(95), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(95), lang.NewKeyword("end-column"), int(49))).(lang.FnFunc) +v3 := v2 +_ = v3 } -v110 := v109.Get() -v111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v112 := v111.FindInternedVar(lang.NewSymbol("vector")) -if v112.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v112))) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v113 := v112.Get() -v114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v115 := v114.FindInternedVar(lang.NewSymbol("seq")) -if v115.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v115))) } -v116 := v115.Get() -v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v118 := v117.FindInternedVar(lang.NewSymbol("concat")) -if v118.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) +// select-keys +{ +v0 := lang.NewSymbol("select-keys").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("keyseq"))), lang.NewKeyword("doc"), "Returns a map containing only those entries in map whose key is in keys", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1536), lang.NewKeyword("end-line"), int(1536))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v6 := lang.NewMap() +v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1541), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(1541), lang.NewKeyword("end-column"), int(17)) +v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v119 := v118.Get() -v120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v121 := v120.FindInternedVar(lang.NewSymbol("list")) -if v121.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v121))) +var v5 any = v8 +_ = v5 +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("seq")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v122 := v121.Get() -v123 := lang.Apply(v122, []any{v7}) -v124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v125 := v124.FindInternedVar(lang.NewSymbol("list")) -if v125.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v125))) +v12 := v11.Get() +v13 := lang.Apply(v12, []any{v4}) +var v9 any = v13 +_ = v9 +var v14 any +for { +var v15 any +if lang.IsTruthy(v9) { +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("first")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v126 := v125.Get() -v127 := lang.Apply(v126, []any{v5}) -v128 := lang.Apply(v119, []any{v123, v127}) -v129 := lang.Apply(v116, []any{v128}) -v130 := lang.Apply(v110, []any{v113, v129}) -v131 := lang.Apply(v107, []any{v130}) -v132 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v133 := v132.FindInternedVar(lang.NewSymbol("list")) -if v133.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v133))) +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v9}) +v21, _ := lang.FieldOrMethod(runtime9.RT, "Find") +if reflect.TypeOf(v21).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Find is not a function"))) } -v134 := v133.Get() -v135 := lang.Apply(v134, []any{v19}) -v136 := lang.Apply(v100, []any{v104, v131, v135}) -v137 := lang.Apply(v97, []any{v136}) -v86 = v137 -} else { -v139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v140 := v139.FindInternedVar(lang.NewSymbol("partition")) -if v140.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v140))) +v22 := lang.Apply(v21, []any{v3, v20}) +var v16 any = v22 +_ = v16 +var v25 any +if lang.IsTruthy(v16) { +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("conj")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) } -v141 := v140.Get() -v142 := lang.Apply(v141, []any{int64(2), v6}) -var v138 any = v142 -_ = v138 -var v144 lang.FnFunc -{ // function assoc-test -v144 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v146 := args[0] -v147 := args[1] -v148 := args[2] -var v149 any -v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v151 := v150.FindInternedVar(lang.NewSymbol("contains?")) -if v151.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) +v28 := v27.Get() +v29 := lang.Apply(v28, []any{v5, v16}) +v25 = v29 +} else { +v25 = v5 } -v152 := v151.Get() -v153 := lang.Apply(v152, []any{v146, v147}) -if lang.IsTruthy(v153) { -v154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v155 := v154.FindInternedVar(lang.NewSymbol("str")) -if v155.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v155))) +var v24 any = v25 +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("next")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -v156 := v155.Get() -v157 := lang.Apply(v156, []any{"Duplicate case test constant: ", v147}) -v158 := lang.Apply(lang1.NewIllegalArgumentError, []any{v157}) -panic(v158) +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v9}) +var v30 any = v34 +v5 = v24 +v9 = v30 +continue } else { -v159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v160 := v159.FindInternedVar(lang.NewSymbol("assoc")) -if v160.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v160))) +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("with-meta")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -v161 := v160.Get() -v162 := lang.Apply(v161, []any{v146, v147, v148}) -v149 = v162 +v18 := v17.Get() +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("meta")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -return v149 +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v3}) +v23 := lang.Apply(v18, []any{v5, v22}) +v15 = v23 +} +v14 = v15 + break +} +return v14 }) -v145 := v144 -_ = v145 +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v145 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6788), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(6791), lang.NewKeyword("end-column"), int(48)) -v146, err := lang.WithMeta(v144, v145.(lang.IPersistentMap)) -if err != nil { - panic(err) } -var v143 any = v146 -_ = v143 -v148 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v149 := v148.FindInternedVar(lang.NewSymbol("reduce1")) -if v149.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v149))) +// send +{ +v0 := lang.NewSymbol("send").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Dispatch an action to an agent. Returns the agent immediately.\n Subsequently, in a thread from a thread pool, the state of the agent\n will be set to the value of:\n\n (apply action-fn state-of-agent args)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2109), lang.NewKeyword("end-line"), int(2109))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("apply")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v150 := v149.Get() -var v151 lang.FnFunc -v151 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("send-via")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v8, []any{v11, nil, v3, v4, v5}) +return v12 } -v152 := args[0] -v153 := args[1] -var v154 any = v153 -_ = v154 -v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v157 := v156.FindInternedVar(lang.NewSymbol("nth")) -if v157.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v158 := v157.Get() -v159 := lang.Apply(v158, []any{v154, int64(0), nil}) -var v155 any = v159 -_ = v155 -v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v162 := v161.FindInternedVar(lang.NewSymbol("nth")) -if v162.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) } -v163 := v162.Get() -v164 := lang.Apply(v163, []any{v154, int64(1), nil}) -var v160 any = v164 -_ = v160 -var v166 any -v167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v168 := v167.FindInternedVar(lang.NewSymbol("seq?")) -if v168.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v168))) +// send-off +{ +v0 := lang.NewSymbol("send-off").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Dispatch a potentially blocking action to an agent. Returns the\n agent immediately. Subsequently, in a separate thread, the state of\n the agent will be set to the value of:\n\n (apply action-fn state-of-agent args)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2120), lang.NewKeyword("end-line"), int(2120))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("apply")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v169 := v168.Get() -v170 := lang.Apply(v169, []any{v155}) -if lang.IsTruthy(v170) { -v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v172 := v171.FindInternedVar(lang.NewSymbol("reduce1")) -if v172.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("send-via")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -v173 := v172.Get() -var v174 lang.FnFunc -v174 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) +v11 := v10.Get() +v12 := lang.Apply(v8, []any{v11, nil, v3, v4, v5}) +return v12 } -v175 := args[0] -v176 := args[1] -v177 := lang.Apply(v143, []any{v175, v176, v160}) -return v177 }) -v175 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6795), lang.NewKeyword("column"), int(37), lang.NewKeyword("end-line"), int(6795), lang.NewKeyword("end-column"), int(60)) -v176, err := lang.WithMeta(v174, v175.(lang.IPersistentMap)) -if err != nil { - panic(err) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v177 := lang.Apply(v173, []any{v176, v152, v155}) -v166 = v177 -} else { -v178 := lang.Apply(v143, []any{v152, v155, v160}) -v166 = v178 } -return v166 -}) -v152 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6793), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(6796), lang.NewKeyword("end-column"), int(53)) -v153, err := lang.WithMeta(v151, v152.(lang.IPersistentMap)) -if err != nil { - panic(err) +// send-via +{ +v0 := lang.NewSymbol("send-via").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("executor"), lang.NewSymbol("a"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Dispatch an action to an agent. Returns the agent immediately.\n Subsequently, in a thread supplied by executor, the state of the agent\n will be set to the value of:\n\n (apply action-fn state-of-agent args)", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2099), lang.NewKeyword("end-line"), int(2099))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("push-thread-bindings")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v154 := lang.NewMap() -v155 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6797), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(6797), lang.NewKeyword("end-column"), int(25)) -v156, err := lang.WithMeta(v154, v155.(lang.IPersistentMap)) -if err != nil { - panic(err) +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("hash-map")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v157 := lang.Apply(v150, []any{v153, v156, v147}) -var v147 any = v157 -_ = v147 -v159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v160 := v159.FindInternedVar(lang.NewSymbol("keys")) -if v160.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v160))) +v13 := v12.Get() +v14 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*agent*")) +v15 := lang.Apply(v13, []any{v14, v4}) +v16 := lang.Apply(v10, []any{v15}) +_ = v16 +var v17 any +func() { +defer func() { +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v161 := v160.Get() -v162 := lang.Apply(v161, []any{v147}) -var v158 any = v162 -_ = v158 -v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v165 := v164.FindInternedVar(lang.NewSymbol("vals")) -if v165.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) +v20 := v19.Get() +v21 := lang.Apply(v20, nil) +}() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("binding-conveyor-fn")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -v166 := v165.Get() -v167 := lang.Apply(v166, []any{v147}) -var v163 any = v167 -_ = v163 -var v169 any -v170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v171 := v170.FindInternedVar(lang.NewSymbol("every?")) -if v171.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v171))) +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v5}) +v17 = v25 +}() +v7, _ := lang.FieldOrMethod(v4, "dispatch") +if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("dispatch is not a function"))) } -v172 := v171.Get() -var v173 lang.FnFunc -v173 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) +v8 := lang.Apply(v7, []any{v17, v6, v3}) +return v8 } -v174 := args[0] -v176 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v177 := v176.FindInternedVar(lang.NewSymbol("integer?")) -if v177.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v177))) -} -v178 := v177.Get() -v179 := lang.Apply(v178, []any{v174}) -var v175 any = v179 -_ = v175 -var v181 any -if lang.IsTruthy(v175) { -v182 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v183 := v182.FindInternedVar(lang.NewSymbol("<=")) -if v183.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v183))) -} -v184 := v183.Get() -v185 := lang.Apply(v184, []any{math7.MinInt, v174, math7.MaxInt}) -v181 = v185 -} else { -v181 = v175 -} -return v181 }) -v174 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6801), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(6801), lang.NewKeyword("end-column"), int(77)) -v175, err := lang.WithMeta(v173, v174.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v176 := lang.Apply(v172, []any{v175, v158}) -if lang.IsTruthy(v176) { -v169 = lang.NewKeyword("ints") -} else { -var v177 any -v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v179 := v178.FindInternedVar(lang.NewSymbol("every?")) -if v179.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) -} -v180 := v179.Get() -v181 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v182 := v181.FindInternedVar(lang.NewSymbol("keyword?")) -if v182.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v182))) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v183 := v182.Get() -v184 := lang.Apply(v180, []any{v183, v158}) -if lang.IsTruthy(v184) { -v177 = lang.NewKeyword("identity") -} else { -var v185 any -if lang.IsTruthy(lang.NewKeyword("else")) { -v185 = lang.NewKeyword("hashes") -} else { -v185 = nil } -v177 = v185 +// seq +{ +v1 := reflect.TypeOf((*lang1.ISeq)(nil)).Elem() +v0 := lang.NewSymbol("seq").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a seq on the collection. If the collection is\n empty, returns nil. (seq nil) returns nil. seq also works on\n Strings, native Java arrays (of reference types) and any objects\n that implement Iterable. Note that seqs cache values, thus seq\n should not be used on any Iterable whose iterator repeatedly\n returns the same mutable object.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(4), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(126), lang.NewKeyword("end-line"), int(136))).(*lang.Symbol) +var v3 lang.FnFunc +{ // function seq +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +v6 := lang.Apply(lang1.Seq, []any{v5}) +return v6 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(136), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(136), lang.NewKeyword("end-column"), int(126))).(lang.FnFunc) +v4 := v3 +_ = v4 } -v169 = v177 +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } -var v168 any = v169 -_ = v168 -v188 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v189 := v188.FindInternedVar(lang.NewSymbol("=")) -if v189.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v189))) } -v190 := v189.Get() -var v187 any = v190 -_ = v187 -var v191 any = v168 -_ = v191 -var v193 any -v194 := lang.Apply(v187, []any{lang.NewKeyword("ints"), v191}) -if lang.IsTruthy(v194) { -v196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v197 := v196.FindInternedVar(lang.NewSymbol("prep-ints")) -if v197.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v197))) +// seq-to-map-for-destructuring +{ +v0 := lang.NewSymbol("seq-to-map-for-destructuring").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Builds a map from a seq as described in\n https://glojure.org/reference/special_forms#keyword-arguments", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(34), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4390), lang.NewKeyword("end-line"), int(4390))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("next")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v198 := v197.Get() -v199 := lang.Apply(v198, []any{v158, v163}) -var v195 any = v199 -_ = v195 -v201 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v202 := v201.FindInternedVar(lang.NewSymbol("nth")) -if v202.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v202))) +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +if lang.IsTruthy(v8) { +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("to-array")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -v203 := v202.Get() -v204 := lang.Apply(v203, []any{v195, int64(0), nil}) -var v200 any = v204 -_ = v200 -v206 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v207 := v206.FindInternedVar(lang.NewSymbol("nth")) -if v207.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v207))) +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v3}) +v13 := lang.Apply(lang1.NewPersistentArrayMapAsIfByAssoc, []any{v12}) +v4 = v13 +} else { +var v14 any +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("seq")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } -v208 := v207.Get() -v209 := lang.Apply(v208, []any{v195, int64(1), nil}) -var v205 any = v209 -_ = v205 -v211 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v212 := v211.FindInternedVar(lang.NewSymbol("nth")) -if v212.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v212))) +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v3}) +if lang.IsTruthy(v18) { +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("first")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v213 := v212.Get() -v214 := lang.Apply(v213, []any{v195, int64(2), nil}) -var v210 any = v214 -_ = v210 -v216 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v217 := v216.FindInternedVar(lang.NewSymbol("nth")) -if v217.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v217))) +v21 := v20.Get() +v22 := lang.Apply(v21, []any{v3}) +v14 = v22 +} else { +v14 = nil } -v218 := v217.Get() -v219 := lang.Apply(v218, []any{v195, int64(3), nil}) -var v215 any = v219 -_ = v215 -v221 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v222 := v221.FindInternedVar(lang.NewSymbol("seq")) -if v222.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v222))) +v4 = v14 } -v223 := v222.Get() -v224 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v225 := v224.FindInternedVar(lang.NewSymbol("concat")) -if v225.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v225))) +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v226 := v225.Get() -v227 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v228 := v227.FindInternedVar(lang.NewSymbol("list")) -if v228.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v228))) } -v229 := v228.Get() -v230 := lang.Apply(v229, []any{lang.NewSymbol("glojure.core/let")}) -v231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v232 := v231.FindInternedVar(lang.NewSymbol("list")) -if v232.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v232))) +// seq? +{ +v0 := lang.NewSymbol("seq?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x implements ISeq", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(146), lang.NewKeyword("end-line"), int(150))).(*lang.Symbol) +var v2 lang.FnFunc +{ // function seq? +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v233 := v232.Get() -v234 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v235 := v234.FindInternedVar(lang.NewSymbol("apply")) -if v235.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v235))) +v7 := v6.Get() +v8 := lang.Apply(v7, []any{lang1.ISeq, v4}) +return v8 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(150), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(150), lang.NewKeyword("end-column"), int(87))).(lang.FnFunc) +v3 := v2 +_ = v3 } -v236 := v235.Get() -v237 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v238 := v237.FindInternedVar(lang.NewSymbol("vector")) -if v238.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v238))) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v239 := v238.Get() -v240 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v241 := v240.FindInternedVar(lang.NewSymbol("seq")) -if v241.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v241))) } -v242 := v241.Get() -v243 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v244 := v243.FindInternedVar(lang.NewSymbol("concat")) -if v244.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v244))) +// seqable? +{ +v0 := lang.NewSymbol("seqable?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if the seq function is supported for x", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6247), lang.NewKeyword("end-line"), int(6247))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.Apply(nil, []any{v3}) +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v245 := v244.Get() -v246 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v247 := v246.FindInternedVar(lang.NewSymbol("list")) -if v247.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v247))) } -v248 := v247.Get() -v249 := lang.Apply(v248, []any{v7}) -v250 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v251 := v250.FindInternedVar(lang.NewSymbol("list")) -if v251.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v251))) +// seque +{ +v0 := lang.NewSymbol("seque").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s")), lang.NewVector(lang.NewSymbol("n-or-q"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Creates a queued seq on another (presumably lazy) seq s. The queued\n seq will produce a concrete seq in the background, and can get up to\n n items ahead of the consumer. n-or-q can be an integer n buffer\n size, or an instance of java.util.concurrent BlockingQueue. Note\n that reading from a seque can block if the reader gets ahead of the\n producer.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5419), lang.NewKeyword("end-line"), int(5419))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seque")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v252 := v251.Get() -v253 := lang.Apply(v252, []any{v5}) -v254 := lang.Apply(v245, []any{v249, v253}) -v255 := lang.Apply(v242, []any{v254}) -v256 := lang.Apply(v236, []any{v239, v255}) -v257 := lang.Apply(v233, []any{v256}) -v258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v259 := v258.FindInternedVar(lang.NewSymbol("list")) -if v259.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v259))) +v6 := v5.Get() +v7 := lang.Apply(v6, []any{int64(100), v3}) +return v7 + case 2: +v3 := args[0] +v4 := args[1] +var v6 any +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("instance?")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v260 := v259.Get() -v261 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v262 := v261.FindInternedVar(lang.NewSymbol("seq")) -if v262.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v262))) +v9 := v8.Get() +v10 := lang.Apply(v9, []any{nil, v3}) +if lang.IsTruthy(v10) { +v6 = v3 +} else { +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("int")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v263 := v262.Get() -v264 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v265 := v264.FindInternedVar(lang.NewSymbol("concat")) -if v265.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v265))) +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v3}) +v15 := lang.Apply(LinkedBlockingQueue32., []any{v14}) +v6 = v15 } -v266 := v265.Get() -v267 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v268 := v267.FindInternedVar(lang.NewSymbol("list")) -if v268.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v268))) +var v5 any = v6 +_ = v5 +v17 := lang.Apply(Object20., nil) +var v16 any = v17 +_ = v16 +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("agent")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v269 := v268.Get() -v270 := lang.Apply(v269, []any{lang.NewSymbol("case*")}) -v271 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v272 := v271.FindInternedVar(lang.NewSymbol("list")) -if v272.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v272))) +v21 := v20.Get() +var v22 lang.FnFunc +v22 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +return v4 +}) +v23 := lang.Apply(lang1.NewLazySeq, []any{v22}) +v24 := lang.Apply(v21, []any{v23}) +var v18 any = v24 +_ = v18 +var v26 lang.FnFunc +v26 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v27 := args[0] +v28 := args[1] +var v29 any +v30, _ := lang.FieldOrMethod(v27, "offer") +if reflect.TypeOf(v30).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("offer is not a function"))) } -v273 := v272.Get() -v274 := lang.Apply(v273, []any{v7}) -v275 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v276 := v275.FindInternedVar(lang.NewSymbol("list")) -if v276.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v276))) +v31 := lang.Apply(v30, []any{v27}) +if lang.IsTruthy(v31) { +panic(v28) +} else { +v29 = v28 } -v277 := v276.Get() -v278 := lang.Apply(v277, []any{v200}) -v279 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v280 := v279.FindInternedVar(lang.NewSymbol("list")) -if v280.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v280))) +return v29 +}) +v27 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5435), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(5438), lang.NewKeyword("end-column"), int(26)) +v28, err := lang.WithMeta(v26, v27.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v281 := v280.Get() -v282 := lang.Apply(v281, []any{v205}) -v283 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v284 := v283.FindInternedVar(lang.NewSymbol("list")) -if v284.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v284))) +var v25 any = v28 +_ = v25 +var v30 lang.FnFunc +v30 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v31 := args[0] +var v32 any +if lang.IsTruthy(v31) { +var v33 any +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("instance?")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } -v285 := v284.Get() -v286 := lang.Apply(v285, []any{v19}) -v287 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v288 := v287.FindInternedVar(lang.NewSymbol("list")) -if v288.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v288))) +v36 := v35.Get() +v37 := lang.Apply(v36, []any{nil, v31}) +if lang.IsTruthy(v37) { +v38 := lang.Apply(v25, []any{v5, v31}) +v33 = v38 +} else { +var v39 any +func() { +defer func() { +if r := recover(); r != nil { +if lang.CatchMatches(r, lang.Builtins["any"]) { +v40 := r +_ = v40 +v41 := lang.Apply(v25, []any{v5, v40}) +v39 = v41 +} else { +panic(r) } -v289 := v288.Get() -v290 := lang.Apply(v289, []any{v210}) -v291 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v292 := v291.FindInternedVar(lang.NewSymbol("list")) -if v292.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v292))) } -v293 := v292.Get() -v294 := lang.Apply(v293, []any{v215}) -v295 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v296 := v295.FindInternedVar(lang.NewSymbol("list")) -if v296.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v296))) +}() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("seq")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } -v297 := v296.Get() -v298 := lang.Apply(v297, []any{lang.NewKeyword("int")}) -v299 := lang.Apply(v266, []any{v270, v274, v278, v282, v286, v290, v294, v298}) -v300 := lang.Apply(v263, []any{v299}) -v301 := lang.Apply(v260, []any{v300}) -v302 := lang.Apply(v226, []any{v230, v257, v301}) -v303 := lang.Apply(v223, []any{v302}) -v193 = v303 -} else { -var v195 any -v196 := lang.Apply(v187, []any{lang.NewKeyword("hashes"), v191}) -if lang.IsTruthy(v196) { -v198 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v199 := v198.FindInternedVar(lang.NewSymbol("prep-hashes")) -if v199.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v199))) +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v31}) +var v40 any = v44 +_ = v40 +var v45 any = v40 +_ = v45 +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("seq")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) } -v200 := v199.Get() -v201 := lang.Apply(v200, []any{v7, v19, v158, v163}) -var v197 any = v201 -_ = v197 -v203 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v204 := v203.FindInternedVar(lang.NewSymbol("nth")) -if v204.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v204))) +v49 := v48.Get() +v50 := lang.Apply(v49, []any{v45}) +var v46 any = v50 +_ = v46 +v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v53 := v52.FindInternedVar(lang.NewSymbol("first")) +if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) } -v205 := v204.Get() -v206 := lang.Apply(v205, []any{v197, int64(0), nil}) -var v202 any = v206 -_ = v202 -v208 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v209 := v208.FindInternedVar(lang.NewSymbol("nth")) -if v209.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v209))) +v54 := v53.Get() +v55 := lang.Apply(v54, []any{v46}) +var v51 any = v55 +_ = v51 +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("next")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) } -v210 := v209.Get() -v211 := lang.Apply(v210, []any{v197, int64(1), nil}) -var v207 any = v211 -_ = v207 -v213 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v214 := v213.FindInternedVar(lang.NewSymbol("nth")) -if v214.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v214))) +v59 := v58.Get() +v60 := lang.Apply(v59, []any{v56}) +var v56 any = v60 +_ = v56 +var v61 any = v51 +_ = v61 +var v62 any = v56 +_ = v62 +var v63 any = v45 +_ = v63 +var v65 any = v65 +_ = v65 +var v66 any +for { +var v67 any = v65 +_ = v67 +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("seq")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) } -v215 := v214.Get() -v216 := lang.Apply(v215, []any{v197, int64(2), nil}) -var v212 any = v216 -_ = v212 -v218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v219 := v218.FindInternedVar(lang.NewSymbol("nth")) -if v219.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v219))) +v71 := v70.Get() +v72 := lang.Apply(v71, []any{v67}) +var v68 any = v72 +_ = v68 +v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v75 := v74.FindInternedVar(lang.NewSymbol("first")) +if v75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) } -v220 := v219.Get() -v221 := lang.Apply(v220, []any{v197, int64(3), nil}) -var v217 any = v221 -_ = v217 -v223 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v224 := v223.FindInternedVar(lang.NewSymbol("nth")) -if v224.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v224))) +v76 := v75.Get() +v77 := lang.Apply(v76, []any{v68}) +var v73 any = v77 +_ = v73 +v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v80 := v79.FindInternedVar(lang.NewSymbol("next")) +if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) } -v225 := v224.Get() -v226 := lang.Apply(v225, []any{v197, int64(4), nil}) -var v222 any = v226 -_ = v222 -v228 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v229 := v228.FindInternedVar(lang.NewSymbol("seq")) -if v229.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v229))) +v81 := v80.Get() +v82 := lang.Apply(v81, []any{v78}) +var v78 any = v82 +_ = v78 +var v83 any = v73 +_ = v83 +var v84 any = v78 +_ = v84 +var v85 any = v67 +_ = v85 +var v87 any +if lang.IsTruthy(v85) { +var v88 any +var v89 any +v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v91 := v90.FindInternedVar(lang.NewSymbol("nil?")) +if v91.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) } -v230 := v229.Get() -v231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v232 := v231.FindInternedVar(lang.NewSymbol("concat")) -if v232.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v232))) +v92 := v91.Get() +v93 := lang.Apply(v92, []any{v83}) +if lang.IsTruthy(v93) { +v89 = v16 +} else { +v89 = v83 } -v233 := v232.Get() -v234 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v235 := v234.FindInternedVar(lang.NewSymbol("list")) -if v235.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v235))) +v94, _ := lang.FieldOrMethod(v5, "offer") +if reflect.TypeOf(v94).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("offer is not a function"))) } -v236 := v235.Get() -v237 := lang.Apply(v236, []any{lang.NewSymbol("glojure.core/let")}) -v238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v239 := v238.FindInternedVar(lang.NewSymbol("list")) -if v239.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v239))) +v95 := lang.Apply(v94, []any{v89}) +if lang.IsTruthy(v95) { +var v96 any = v84 +v65 = v96 +continue +} else { +v88 = v85 } -v240 := v239.Get() -v241 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v242 := v241.FindInternedVar(lang.NewSymbol("apply")) -if v242.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v242))) +v87 = v88 +} else { +var v97 any +v98, _ := lang.FieldOrMethod(v5, "offer") +if reflect.TypeOf(v98).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("offer is not a function"))) } -v243 := v242.Get() -v244 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v245 := v244.FindInternedVar(lang.NewSymbol("vector")) -if v245.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v245))) +v99 := lang.Apply(v98, []any{v5}) +if lang.IsTruthy(v99) { +v97 = nil +} else { +v97 = lang.NewList() } -v246 := v245.Get() -v247 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v248 := v247.FindInternedVar(lang.NewSymbol("seq")) -if v248.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v248))) +v87 = v97 } -v249 := v248.Get() -v250 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v251 := v250.FindInternedVar(lang.NewSymbol("concat")) -if v251.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v251))) +v66 = v87 + break } -v252 := v251.Get() -v253 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v254 := v253.FindInternedVar(lang.NewSymbol("list")) -if v254.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v254))) +v39 = v66 +}() +v33 = v39 } -v255 := v254.Get() -v256 := lang.Apply(v255, []any{v7}) -v257 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v258 := v257.FindInternedVar(lang.NewSymbol("list")) -if v258.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v258))) +v32 = v33 +} else { +v32 = nil } -v259 := v258.Get() -v260 := lang.Apply(v259, []any{v5}) -v261 := lang.Apply(v252, []any{v256, v260}) -v262 := lang.Apply(v249, []any{v261}) -v263 := lang.Apply(v243, []any{v246, v262}) -v264 := lang.Apply(v240, []any{v263}) -v265 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v266 := v265.FindInternedVar(lang.NewSymbol("list")) -if v266.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v266))) +return v32 +}) +v31 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5439), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(5452), lang.NewKeyword("end-column"), int(44)) +v32, err := lang.WithMeta(v30, v31.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v267 := v266.Get() -v268 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v269 := v268.FindInternedVar(lang.NewSymbol("seq")) -if v269.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v269))) +var v29 any = v32 +_ = v29 +var v34 lang.FnFunc +{ // function drain +v34 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +var v36 lang.FnFunc +v36 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v38, ok := lang.FieldOrMethod(v5, "take") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "take"))) } -v270 := v269.Get() -v271 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v272 := v271.FindInternedVar(lang.NewSymbol("concat")) -if v272.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v272))) +var v39 any +switch reflect.TypeOf(v38).Kind() { +case reflect.Func: + v39 = lang.Apply(v38, nil) +default: + v39 = v38 } -v273 := v272.Get() -v274 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v275 := v274.FindInternedVar(lang.NewSymbol("list")) -if v275.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v275))) +var v37 any = v39 +_ = v37 +var v41 any +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("identical?")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) } -v276 := v275.Get() -v277 := lang.Apply(v276, []any{lang.NewSymbol("case*")}) -v278 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v279 := v278.FindInternedVar(lang.NewSymbol("list")) -if v279.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v279))) +v44 := v43.Get() +v45 := lang.Apply(v44, []any{v37, v5}) +if lang.IsTruthy(v45) { +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("deref")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) } -v280 := v279.Get() -v281 := lang.Apply(v280, []any{v7}) -v282 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v283 := v282.FindInternedVar(lang.NewSymbol("list")) -if v283.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v283))) +v48 := v47.Get() +v49 := lang.Apply(v48, []any{v18}) +_ = v49 +v41 = nil +} else { +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("send-off")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) } -v284 := v283.Get() -v285 := lang.Apply(v284, []any{v202}) -v286 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v287 := v286.FindInternedVar(lang.NewSymbol("list")) -if v287.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v287))) +v52 := v51.Get() +v53 := lang.Apply(v52, []any{v18, v29}) +_ = v53 +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("release-pending-sends")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) } -v288 := v287.Get() -v289 := lang.Apply(v288, []any{v207}) -v290 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v291 := v290.FindInternedVar(lang.NewSymbol("list")) -if v291.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v291))) +v56 := v55.Get() +v57 := lang.Apply(v56, nil) +_ = v57 +v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v59 := v58.FindInternedVar(lang.NewSymbol("cons")) +if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) } -v292 := v291.Get() -v293 := lang.Apply(v292, []any{v19}) -v294 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v295 := v294.FindInternedVar(lang.NewSymbol("list")) -if v295.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v295))) +v60 := v59.Get() +var v61 any +v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v63 := v62.FindInternedVar(lang.NewSymbol("identical?")) +if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) } -v296 := v295.Get() -v297 := lang.Apply(v296, []any{v212}) -v298 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v299 := v298.FindInternedVar(lang.NewSymbol("list")) -if v299.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v299))) +v64 := v63.Get() +v65 := lang.Apply(v64, []any{v37, v16}) +if lang.IsTruthy(v65) { +v61 = nil +} else { +v61 = v37 } -v300 := v299.Get() -v301 := lang.Apply(v300, []any{v217}) -v302 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v303 := v302.FindInternedVar(lang.NewSymbol("list")) -if v303.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v303))) +v66 := lang.Apply(v35, nil) +v67 := lang.Apply(v60, []any{v61, v66}) +v41 = v67 } -v304 := v303.Get() -v305 := lang.Apply(v304, []any{lang.NewKeyword("hash-equiv")}) -v306 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v307 := v306.FindInternedVar(lang.NewSymbol("list")) -if v307.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v307))) +return v41 +}) +v37 := lang.Apply(lang1.NewLazySeq, []any{v36}) +return v37 +}) +v35 := v34 +_ = v35 } -v308 := v307.Get() -v309 := lang.Apply(v308, []any{v222}) -v310 := lang.Apply(v273, []any{v277, v281, v285, v289, v293, v297, v301, v305, v309}) -v311 := lang.Apply(v270, []any{v310}) -v312 := lang.Apply(v267, []any{v311}) -v313 := lang.Apply(v233, []any{v237, v264, v312}) -v314 := lang.Apply(v230, []any{v313}) -v195 = v314 -} else { -var v197 any -v198 := lang.Apply(v187, []any{lang.NewKeyword("identity"), v191}) -if lang.IsTruthy(v198) { -v200 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v201 := v200.FindInternedVar(lang.NewSymbol("prep-hashes")) -if v201.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v201))) +v35 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5453), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(5461), lang.NewKeyword("end-column"), int(73)) +v36, err := lang.WithMeta(v34, v35.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v202 := v201.Get() -v203 := lang.Apply(v202, []any{v7, v19, v158, v163}) -var v199 any = v203 -_ = v199 -v205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v206 := v205.FindInternedVar(lang.NewSymbol("nth")) -if v206.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v206))) +var v33 any = v36 +_ = v33 +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("send-off")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) } -v207 := v206.Get() -v208 := lang.Apply(v207, []any{v199, int64(0), nil}) -var v204 any = v208 -_ = v204 -v210 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v211 := v210.FindInternedVar(lang.NewSymbol("nth")) -if v211.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v211))) +v40 := v39.Get() +v41 := lang.Apply(v40, []any{v18, v29}) +_ = v41 +v42 := lang.Apply(v33, nil) +return v42 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v212 := v211.Get() -v213 := lang.Apply(v212, []any{v199, int64(1), nil}) -var v209 any = v213 -_ = v209 -v215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v216 := v215.FindInternedVar(lang.NewSymbol("nth")) -if v216.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v216))) } -v217 := v216.Get() -v218 := lang.Apply(v217, []any{v199, int64(2), nil}) -var v214 any = v218 -_ = v214 -v220 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v221 := v220.FindInternedVar(lang.NewSymbol("nth")) -if v221.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v221))) +// sequence +{ +v0 := lang.NewSymbol("sequence").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("coll"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Coerces coll to a (possibly empty) sequence, if it is not already\n one. Will not force a lazy seq. (sequence nil) yields (), When a\n transducer is supplied, returns a lazy sequence of applications of\n the transform to the items in coll(s), i.e. to the set of first\n items of each coll, followed by the set of second\n items in each coll, until any one of the colls is exhausted. Any\n remaining items in other colls are ignored. The transform should accept\n number-of-colls arguments", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2639), lang.NewKeyword("end-line"), int(2639))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v222 := v221.Get() -v223 := lang.Apply(v222, []any{v199, int64(3), nil}) -var v219 any = v223 -_ = v219 -v225 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v226 := v225.FindInternedVar(lang.NewSymbol("nth")) -if v226.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v226))) +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +if lang.IsTruthy(v8) { +v4 = v3 +} else { +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("seq")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v227 := v226.Get() -v228 := lang.Apply(v227, []any{v199, int64(4), nil}) -var v224 any = v228 -_ = v224 -v230 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v231 := v230.FindInternedVar(lang.NewSymbol("seq")) -if v231.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v231))) +v12 := v11.Get() +v13 := lang.Apply(v12, []any{v3}) +var v9 any = v13 +_ = v9 +var v15 any +if lang.IsTruthy(v9) { +v15 = v9 +} else { +v15 = lang.NewList() } -v232 := v231.Get() -v233 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v234 := v233.FindInternedVar(lang.NewSymbol("concat")) -if v234.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v234))) +v4 = v15 } -v235 := v234.Get() -v236 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v237 := v236.FindInternedVar(lang.NewSymbol("list")) -if v237.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v237))) +return v4 + case 2: +v3 := args[0] +v4 := args[1] +v6 := lang.Apply(nil, []any{v4}) +v7 := lang.Apply(nil, []any{v3, v6}) +v8 := lang.Apply(nil, []any{v7}) +var v5 any = v8 +_ = v5 +var v10 any +if lang.IsTruthy(v5) { +v10 = v5 +} else { +v10 = lang.NewList() } -v238 := v237.Get() -v239 := lang.Apply(v238, []any{lang.NewSymbol("glojure.core/let")}) -v240 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v241 := v240.FindInternedVar(lang.NewSymbol("list")) -if v241.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v241))) +return v10 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("map")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v242 := v241.Get() -v243 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v244 := v243.FindInternedVar(lang.NewSymbol("apply")) -if v244.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v244))) +v9 := v8.Get() +var v10 lang.FnFunc +v10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v11 := args[0] +v12 := lang.Apply(nil, []any{v11}) +return v12 +}) +v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2661), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(2661), lang.NewKeyword("end-column"), int(41)) +v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v245 := v244.Get() -v246 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v247 := v246.FindInternedVar(lang.NewSymbol("vector")) -if v247.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v247))) +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("cons")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } -v248 := v247.Get() -v249 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v250 := v249.FindInternedVar(lang.NewSymbol("seq")) -if v250.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v250))) +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v4, v5}) +v17 := lang.Apply(v9, []any{v12, v16}) +v18 := lang.Apply(nil, []any{v3, v17}) +v19 := lang.Apply(nil, []any{v18}) +var v6 any = v19 +_ = v6 +var v21 any +if lang.IsTruthy(v6) { +v21 = v6 +} else { +v21 = lang.NewList() } -v251 := v250.Get() -v252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v253 := v252.FindInternedVar(lang.NewSymbol("concat")) -if v253.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v253))) +return v21 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v254 := v253.Get() -v255 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v256 := v255.FindInternedVar(lang.NewSymbol("list")) -if v256.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v256))) } -v257 := v256.Get() -v258 := lang.Apply(v257, []any{v7}) -v259 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v260 := v259.FindInternedVar(lang.NewSymbol("list")) -if v260.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v260))) +// sequential? +{ +v0 := lang.NewSymbol("sequential?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements Sequential", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6272), lang.NewKeyword("end-line"), int(6272))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v261 := v260.Get() -v262 := lang.Apply(v261, []any{v5}) -v263 := lang.Apply(v254, []any{v258, v262}) -v264 := lang.Apply(v251, []any{v263}) -v265 := lang.Apply(v245, []any{v248, v264}) -v266 := lang.Apply(v242, []any{v265}) -v267 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v268 := v267.FindInternedVar(lang.NewSymbol("list")) -if v268.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v268))) +v6 := v5.Get() +v7 := lang.Apply(v6, []any{lang1.Sequential, v3}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v269 := v268.Get() -v270 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v271 := v270.FindInternedVar(lang.NewSymbol("seq")) -if v271.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v271))) } -v272 := v271.Get() -v273 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v274 := v273.FindInternedVar(lang.NewSymbol("concat")) -if v274.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v274))) +// serialized-require +{ +v0 := lang.NewSymbol("serialized-require").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Like 'require', but serializes loading.\n Interim function preferred over 'require' for known asynchronous loads.\n Future changes may make these equivalent.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6102), lang.NewKeyword("end-line"), int(6102), lang.NewKeyword("private"), true)).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.NewList(args[0:]...) +var v4 any = nil +_ = v4 +var v6 any +func() { +var v7 any = v4 +_ = v7 +v9 := lang.Apply(nil, []any{v7}) +_ = v9 +var v10 any +func() { +defer func() { +v11 := lang.Apply(nil, []any{v7}) +}() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("apply")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } -v275 := v274.Get() -v276 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v277 := v276.FindInternedVar(lang.NewSymbol("list")) -if v277.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v277))) +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("require")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } -v278 := v277.Get() -v279 := lang.Apply(v278, []any{lang.NewSymbol("case*")}) -v280 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v281 := v280.FindInternedVar(lang.NewSymbol("list")) -if v281.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v281))) +v17 := v16.Get() +v18 := lang.Apply(v14, []any{v17, v3}) +v10 = v18 +}() +v6 = v10 +}() +return v6 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v282 := v281.Get() -v283 := lang.Apply(v282, []any{v7}) -v284 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v285 := v284.FindInternedVar(lang.NewSymbol("list")) -if v285.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v285))) } -v286 := v285.Get() -v287 := lang.Apply(v286, []any{v204}) -v288 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v289 := v288.FindInternedVar(lang.NewSymbol("list")) -if v289.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v289))) +// set +{ +v0 := lang.NewSymbol("set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a set of the distinct elements of coll.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4104), lang.NewKeyword("end-line"), int(4104))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("set?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v290 := v289.Get() -v291 := lang.Apply(v290, []any{v209}) -v292 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v293 := v292.FindInternedVar(lang.NewSymbol("list")) -if v293.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v293))) +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +if lang.IsTruthy(v8) { +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("with-meta")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -v294 := v293.Get() -v295 := lang.Apply(v294, []any{v19}) -v296 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v297 := v296.FindInternedVar(lang.NewSymbol("list")) -if v297.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v297))) +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v3, nil}) +v4 = v12 +} else { +var v13 any +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("instance?")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v298 := v297.Get() -v299 := lang.Apply(v298, []any{v214}) -v300 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v301 := v300.FindInternedVar(lang.NewSymbol("list")) -if v301.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v301))) +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang1.IReduceInit, v3}) +if lang.IsTruthy(v17) { +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("persistent!")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("conj!")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v302 := v301.Get() -v303 := lang.Apply(v302, []any{v219}) -v304 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v305 := v304.FindInternedVar(lang.NewSymbol("list")) -if v305.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v305))) +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("transient")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -v306 := v305.Get() -v307 := lang.Apply(v306, []any{lang.NewKeyword("hash-identity")}) -v308 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v309 := v308.FindInternedVar(lang.NewSymbol("list")) -if v309.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v309))) +v26 := v25.Get() +v27 := lang.CreatePersistentTreeSet() +v28 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4112), lang.NewKeyword("column"), int(108), lang.NewKeyword("end-line"), int(4112), lang.NewKeyword("end-column"), int(110)) +v29, err := lang.WithMeta(v27, v28.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v310 := v309.Get() -v311 := lang.Apply(v310, []any{v224}) -v312 := lang.Apply(v275, []any{v279, v283, v287, v291, v295, v299, v303, v307, v311}) -v313 := lang.Apply(v272, []any{v312}) -v314 := lang.Apply(v269, []any{v313}) -v315 := lang.Apply(v235, []any{v239, v266, v314}) -v316 := lang.Apply(v232, []any{v315}) -v197 = v316 +v30 := lang.Apply(v26, []any{v29}) +v31, _ := lang.FieldOrMethod(v3, "ReduceInit") +if reflect.TypeOf(v31).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) +} +v32 := lang.Apply(v31, []any{v23, v30}) +v33 := lang.Apply(v20, []any{v32}) +v13 = v33 } else { -v199 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v200 := v199.FindInternedVar(lang.NewSymbol("str")) -if v200.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v200))) +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("persistent!")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } -v201 := v200.Get() -v202 := lang.Apply(v201, []any{"No matching clause: ", v191}) -v203 := lang.Apply(lang1.NewIllegalArgumentError, []any{v202}) -panic(v203) +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("reduce1")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -v195 = v197 +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("conj!")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) } -v193 = v195 +v42 := v41.Get() +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("transient")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) } -v86 = v193 +v45 := v44.Get() +v46 := lang.CreatePersistentTreeSet() +v47 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4113), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(4113), lang.NewKeyword("end-column"), int(48)) +v48, err := lang.WithMeta(v46, v47.(lang.IPersistentMap)) +if err != nil { + panic(err) } -return v86 - } +v49 := lang.Apply(v45, []any{v48}) +v50 := lang.Apply(v39, []any{v42, v49, v3}) +v51 := lang.Apply(v36, []any{v50}) +v13 = v51 +} +v4 = v13 +} +return v4 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -68122,317 +68434,187 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// instance? +// set-agent-send-executor! { -v0 := lang.NewSymbol("instance?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Evaluates x and tests if it is an instance of the type\n t. Returns true or false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(139), lang.NewKeyword("end-line"), int(143))).(*lang.Symbol) +v0 := lang.NewSymbol("set-agent-send-executor!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("executor"))), lang.NewKeyword("doc"), "Sets the ExecutorService to be used by send", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(30), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2087), lang.NewKeyword("end-line"), int(2087))).(*lang.Symbol) var v2 lang.FnFunc -{ // function instance? v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v4 := args[0] -v5 := args[1] -v6 := lang.Apply(lang1.HasType, []any{v4, v5}) -return v6 +v3 := args[0] +return nil }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(143), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(143), lang.NewKeyword("end-column"), int(85))).(lang.FnFunc) -v3 := v2 -_ = v3 -} +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// isa? +// set-agent-send-off-executor! { -v0 := lang.NewSymbol("isa?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("child"), lang.NewSymbol("parent")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("child"), lang.NewSymbol("parent"))), lang.NewKeyword("doc"), "Returns true if (= child parent), or child is directly or indirectly derived from\n parent, either via a Java type inheritance relationship or a\n relationship established via derive. h must be a hierarchy obtained\n from make-hierarchy, if not supplied defaults to the global\n hierarchy", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5586), lang.NewKeyword("end-line"), int(5586))).(*lang.Symbol) +v0 := lang.NewSymbol("set-agent-send-off-executor!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("executor"))), lang.NewKeyword("doc"), "Sets the ExecutorService to be used by send-off", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(34), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2093), lang.NewKeyword("end-line"), int(2093))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("isa?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +return nil +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("global-hierarchy")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v10 := v9.Get() -v11 := lang.Apply(v7, []any{v10, v3, v4}) -return v11 - case 3: +// set-error-handler! +{ +v0 := lang.NewSymbol("set-error-handler!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("handler-fn"))), lang.NewKeyword("doc"), "Sets the error-handler of agent a to handler-fn. If an action\n being run by the agent throws an exception or doesn't pass the\n validator fn, handler-fn will be called with two arguments: the\n agent and the exception.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2192), lang.NewKeyword("end-line"), int(2192))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] v4 := args[1] -v5 := args[2] -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("=")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v5, _ := lang.FieldOrMethod(v3, "setErrorHandler") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorHandler is not a function"))) } -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v4, v5}) -var v6 any = v10 -_ = v6 -var v12 any -if lang.IsTruthy(v6) { -v12 = v6 -} else { -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("class?")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v5}) -var v14 any = v18 -_ = v14 -var v20 any -if lang.IsTruthy(v14) { -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("class?")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v4}) -var v21 any = v25 -_ = v21 -var v27 any -if lang.IsTruthy(v21) { -v28, _ := lang.FieldOrMethod(v4, "AssignableTo") -if reflect.TypeOf(v28).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("AssignableTo is not a function"))) +// set-error-mode! +{ +v0 := lang.NewSymbol("set-error-mode!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("mode-keyword"))), lang.NewKeyword("doc"), "Sets the error-mode of agent a to mode-keyword, which must be\n either :fail or :continue. If an action being run by the agent\n throws an exception or doesn't pass the validator fn, an\n error-handler may be called (see set-error-handler!), after which,\n if the mode is :continue, the agent will continue as if neither the\n action that caused the error nor the error itself ever happened.\n \n If the mode is :fail, the agent will become failed and will stop\n accepting new 'send' and 'send-off' actions, and any previously\n queued actions will be held until a 'restart-agent'. Deref will\n still work, returning the state of the agent before the error.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2210), lang.NewKeyword("end-line"), int(2210))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5, _ := lang.FieldOrMethod(v3, "setErrorMode") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorMode is not a function"))) } -v29 := lang.Apply(v28, []any{v5}) -v27 = v29 -} else { -v27 = v21 +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v20 = v27 -} else { -v20 = v14 } -var v13 any = v20 -_ = v13 -var v15 any -if lang.IsTruthy(v13) { -v15 = v13 -} else { -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("contains?")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +// set-validator! +{ +v0 := lang.NewSymbol("set-validator!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("iref"), lang.NewSymbol("validator-fn"))), lang.NewKeyword("doc"), "Sets the validator-fn for a var/ref/agent/atom. validator-fn must be nil or a\n side-effect-free fn of one argument, which will be passed the intended\n new state on any state change. If the new state is unacceptable, the\n validator-fn should return false or throw an exception. If the current state (root\n value if var) is not acceptable to the new validator, an exception\n will be thrown and the validator will not be changed.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2381), lang.NewKeyword("end-line"), int(2381))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5, _ := lang.FieldOrMethod(v3, "setValidator") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setValidator is not a function"))) } -v19 := v18.Get() -v20 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) -v21 := lang.Apply(v20, []any{v4}) -v22 := lang.Apply(v19, []any{v21, v5}) -var v16 any = v22 -_ = v16 -var v24 any -if lang.IsTruthy(v16) { -v24 = v16 -} else { -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("class?")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v29 := v28.Get() -v30 := lang.Apply(v29, []any{v4}) -var v26 any = v30 -_ = v26 -var v32 any -if lang.IsTruthy(v26) { -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("some")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) } -v35 := v34.Get() -var v36 lang.FnFunc -v36 = lang.NewFnFunc(func(args ...any) any { +// set? +{ +v0 := lang.NewSymbol("set?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements IPersistentSet", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4098), lang.NewKeyword("end-line"), int(4098))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v37 := args[0] -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("contains?")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v40 := v39.Get() -v41 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) -v42 := lang.Apply(v41, []any{v37}) -v43 := lang.Apply(v40, []any{v42, v5}) -return v43 +v6 := v5.Get() +v7 := lang.Apply(v6, []any{lang1.IPersistentSet, v3}) +return v7 }) -v37 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5599), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(5599), lang.NewKeyword("end-column"), int(71)) -v38, err := lang.WithMeta(v36, v37.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("supers")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) -} -v41 := v40.Get() -v42 := lang.Apply(v41, []any{v4}) -v43 := lang.Apply(v35, []any{v38, v42}) -v32 = v43 -} else { -v32 = v26 -} -var v25 any = v32 -_ = v25 -var v27 any -if lang.IsTruthy(v25) { -v27 = v25 -} else { -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("vector?")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.Apply(v31, []any{v5}) -var v28 any = v32 -_ = v28 -var v34 any -if lang.IsTruthy(v28) { -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("vector?")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v4}) -var v35 any = v39 -_ = v35 -var v41 any -if lang.IsTruthy(v35) { -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("=")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("count")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) -} -v48 := v47.Get() -v49 := lang.Apply(v48, []any{v5}) -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("count")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.Apply(v52, []any{v4}) -v54 := lang.Apply(v45, []any{v49, v53}) -var v42 any = v54 -_ = v42 -var v56 any -if lang.IsTruthy(v42) { -var v57 any = true -_ = v57 -var v58 any = int64(0) -_ = v58 -var v59 any -for { -var v60 any -v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v63 := v62.FindInternedVar(lang.NewSymbol("not")) -if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) -} -v64 := v63.Get() -v65 := lang.Apply(v64, []any{v57}) -var v61 any = v65 -_ = v61 -var v67 any -if lang.IsTruthy(v61) { -v67 = v61 -} else { -v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v69 := v68.FindInternedVar(lang.NewSymbol("=")) -if v69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) -} -v70 := v69.Get() -v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v72 := v71.FindInternedVar(lang.NewSymbol("count")) -if v72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) -} -v73 := v72.Get() -v74 := lang.Apply(v73, []any{v5}) -v75 := lang.Apply(v70, []any{v58, v74}) -v67 = v75 +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -if lang.IsTruthy(v67) { -v60 = v57 -} else { -v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v63 := v62.FindInternedVar(lang.NewSymbol("isa?")) -if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) } -v64 := v63.Get() -v65 := lang.Apply(v4, []any{v58}) -v66 := lang.Apply(v5, []any{v58}) -v67 := lang.Apply(v64, []any{v3, v65, v66}) -var v61 any = v67 -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("inc")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +// setup-reference +{ +v0 := lang.NewSymbol("setup-reference").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2043), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(2044), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("r"), lang.NewSymbol("options"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("apply")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v71 := v70.Get() -v72 := lang.Apply(v71, []any{v58}) -var v68 any = v72 -v57 = v61 -v58 = v68 -continue +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("hash-map")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -v59 = v60 - break +v11 := v10.Get() +v12 := lang.Apply(v8, []any{v11, v4}) +var v5 any = v12 +_ = v5 +var v14 any +v15 := lang.Apply(lang.NewKeyword("meta"), []any{v5}) +if lang.IsTruthy(v15) { +v16 := lang.Apply(lang.NewKeyword("meta"), []any{v5}) +v17, _ := lang.FieldOrMethod(v3, "ResetMeta") +if reflect.TypeOf(v17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ResetMeta is not a function"))) } -v56 = v59 +v18 := lang.Apply(v17, []any{v16}) +v14 = v18 } else { -v56 = v42 +v14 = nil } -v41 = v56 -} else { -v41 = v35 +_ = v14 +var v19 any +v20 := lang.Apply(lang.NewKeyword("validator"), []any{v5}) +if lang.IsTruthy(v20) { +v21 := lang.Apply(lang.NewKeyword("validator"), []any{v5}) +v22, _ := lang.FieldOrMethod(v3, "setValidator") +if reflect.TypeOf(v22).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setValidator is not a function"))) } -v34 = v41 +v23 := lang.Apply(v22, []any{v21}) +v19 = v23 } else { -v34 = v28 -} -v27 = v34 -} -v24 = v27 -} -v15 = v24 -} -v12 = v15 +v19 = nil } -return v12 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } +_ = v19 +return v3 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -68440,17 +68622,32 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// keys +// shift-mask { -v0 := lang.NewSymbol("keys").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"))), lang.NewKeyword("doc"), "Returns a sequence of the map's keys, in the same order as (seq map).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1551), lang.NewKeyword("end-line"), int(1551))).(*lang.Symbol) +v0 := lang.NewSymbol("shift-mask").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6641), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(6641), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("shift"), lang.NewSymbol("mask"), lang.NewSymbol("x"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { + if len(args) != 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := lang.Apply(lang1.Keys, []any{v3}) -return v4 +v4 := args[1] +v5 := args[2] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("bit-and")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("bit-shift-right")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v5, v3}) +v13 := lang.Apply(v8, []any{v12, v4}) +return v13 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -68458,1434 +68655,1524 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// nat-int? +// short { -v0 := lang.NewSymbol("nat-int?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a non-negative fixed precision integer", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1415), lang.NewKeyword("end-line"), int(1415))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { +var v1 lang.FnFunc +{ // function short__inliner +v1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("int?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -var v4 any = v8 -_ = v4 -var v10 any -if lang.IsTruthy(v4) { -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("not")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v13 := v12.Get() +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("neg?")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) if v15.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } v16 := v15.Get() -v17 := lang.Apply(v16, []any{v3}) -v18 := lang.Apply(v13, []any{v17}) -v10 = v18 -} else { -v10 = v4 -} -return v10 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// destructure -{ -v0 := lang.NewSymbol("destructure").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4400), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(4400), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("partition")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v7 := v6.Get() -v8 := lang.Apply(v7, []any{int64(2), v3}) -var v4 any = v8 -_ = v4 -var v10 lang.FnFunc -{ // function pb -v10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v12 := args[0] -v13 := args[1] -v14 := args[2] -var v16 lang.FnFunc -v16 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v17 := args[0] -v18 := args[1] -v19 := args[2] +v20 := v19.Get() v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("gensym")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) if v22.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } v23 := v22.Get() -v24 := lang.Apply(v23, []any{"vec__"}) -var v20 any = v24 -_ = v20 -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("gensym")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -v28 := v27.Get() -v29 := lang.Apply(v28, []any{"seq__"}) -var v25 any = v29 -_ = v25 +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +var v30 any v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("gensym")) +v32 := v31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) if v32.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } v33 := v32.Get() -v34 := lang.Apply(v33, []any{"first__"}) -var v30 any = v34 -_ = v30 -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("some")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +if lang.IsTruthy(v33) { +v30 = lang.NewSymbol("uncheckedShortCast") +} else { +v30 = lang.NewSymbol("shortCast") } -v38 := v37.Get() -v39 := lang.CreatePersistentTreeSet(lang.NewSymbol("&")) -v40 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4408), lang.NewKeyword("column"), int(43), lang.NewKeyword("end-line"), int(4408), lang.NewKeyword("end-column"), int(47)) -v41, err := lang.WithMeta(v39, v40.(lang.IPersistentMap)) -if err != nil { - panic(err) +v34 := lang.Apply(v29, []any{v30}) +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("list")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) } -v42 := lang.Apply(v38, []any{v41, v18}) -var v35 any = v42 -_ = v35 -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("conj")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +v37 := v36.Get() +v38 := lang.Apply(v37, []any{v3}) +v39 := lang.Apply(v26, []any{v34, v38}) +v40 := lang.Apply(v23, []any{v39}) +v41 := lang.Apply(v20, []any{v40}) +v42 := lang.Apply(v9, []any{v13, v17, v41}) +v43 := lang.Apply(v6, []any{v42}) +return v43 +}) +v2 := v1 +_ = v2 } -v48 := v47.Get() -v49 := lang.Apply(v48, []any{v17, v20, v19}) -var v45 any = v49 -_ = v45 -var v51 any -if lang.IsTruthy(v35) { -v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("conj")) -if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) +v0 := lang.NewSymbol("short").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to short", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3499), lang.NewKeyword("end-line"), int(3499))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := lang.Apply(lang1.ShortCast, []any{v4}) +return v5 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v54 := v53.Get() -v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v56 := v55.FindInternedVar(lang.NewSymbol("list")) -if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) } -v57 := v56.Get() -v58 := lang.Apply(v57, []any{lang.NewSymbol("glojure.core/seq"), v20}) -v59 := lang.Apply(v54, []any{v45, v25, v58}) -v51 = v59 -} else { -v51 = v45 +// short-array +{ +var v1 lang.FnFunc +{ // function short-array__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.NewList(args[0:]...) +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -var v44 any = v51 -_ = v44 -var v45 any = int64(0) -_ = v45 -var v46 any = v18 -_ = v46 -var v47 any = false -_ = v47 -var v48 any -for { -var v49 any -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("seq")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v52 := v51.Get() -v53 := lang.Apply(v52, []any{v46}) -if lang.IsTruthy(v53) { -v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v56 := v55.FindInternedVar(lang.NewSymbol("first")) -if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v57 := v56.Get() -v58 := lang.Apply(v57, []any{v46}) -var v54 any = v58 -_ = v54 -var v60 any -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("=")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v63 := v62.Get() -v64 := lang.Apply(v63, []any{v54, lang.NewSymbol("&")}) -if lang.IsTruthy(v64) { -v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v67 := v66.FindInternedVar(lang.NewSymbol("second")) -if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v68 := v67.Get() -v69 := lang.Apply(v68, []any{v46}) -v70 := lang.Apply(v11, []any{v44, v69, v25}) -var v65 any = v70 -var v71 any = v45 -v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v74 := v73.FindInternedVar(lang.NewSymbol("nnext")) -if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) +v20 := v19.Get() +v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/shortArray")}) +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("list")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -v75 := v74.Get() -v76 := lang.Apply(v75, []any{v46}) -var v72 any = v76 -var v77 any = true -v44 = v65 -v45 = v71 -v46 = v72 -v47 = v77 -continue -} else { -var v78 any -v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v80 := v79.FindInternedVar(lang.NewSymbol("=")) -if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("seq")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -v81 := v80.Get() -v82 := lang.Apply(v81, []any{v54, lang.NewKeyword("as")}) -if lang.IsTruthy(v82) { -v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v84 := v83.FindInternedVar(lang.NewSymbol("second")) -if v84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("concat")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } -v85 := v84.Get() -v86 := lang.Apply(v85, []any{v46}) -v87 := lang.Apply(v11, []any{v44, v86, v20}) -v78 = v87 -} else { -var v88 any -if lang.IsTruthy(lang.NewKeyword("else")) { -var v89 any -if lang.IsTruthy(v47) { -v90 := lang.Apply(errors10.New, []any{"Unsupported binding form, only :as can follow & parameter"}) -panic(v90) -} else { -var v92 any -if lang.IsTruthy(v35) { -v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v94 := v93.FindInternedVar(lang.NewSymbol("conj")) -if v94.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -v95 := v94.Get() -v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v97 := v96.FindInternedVar(lang.NewSymbol("seq")) -if v97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) +v33 := v32.Get() +v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("list")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) } -v98 := v97.Get() -v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v100 := v99.FindInternedVar(lang.NewSymbol("concat")) -if v100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) +v37 := v36.Get() +v38 := lang.Apply(v37, []any{lang.NewSymbol("glojure.core/args")}) +v39 := lang.Apply(v30, []any{v34, v38}) +v40 := lang.Apply(v27, []any{v39}) +v41 := lang.Apply(v24, []any{v40}) +v42 := lang.Apply(v9, []any{v13, v17, v21, v41}) +v43 := lang.Apply(v6, []any{v42}) +return v43 + } +}) +v2 := v1 +_ = v2 } -v101 := v100.Get() -v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v103 := v102.FindInternedVar(lang.NewSymbol("list")) -if v103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) +v0 := lang.NewSymbol("short-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Creates an array of shorts", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)int64(2)), lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5333), lang.NewKeyword("end-line"), int(5333))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "shortArray") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("shortArray is not a function"))) } -v104 := v103.Get() -v105 := lang.Apply(v104, []any{lang.NewSymbol("glojure.core/first")}) -v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v107 := v106.FindInternedVar(lang.NewSymbol("list")) -if v107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) +v6 := lang.Apply(v5, []any{v4}) +return v6 + case 2: +v4 := args[0] +v5 := args[1] +v6, _ := lang.FieldOrMethod(lang1.Numbers, "shortArrayInit") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("shortArrayInit is not a function"))) } -v108 := v107.Get() -v109 := lang.Apply(v108, []any{v25}) -v110 := lang.Apply(v101, []any{v105, v109}) -v111 := lang.Apply(v98, []any{v110}) -v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v113 := v112.FindInternedVar(lang.NewSymbol("seq")) -if v113.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v114 := v113.Get() -v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v116 := v115.FindInternedVar(lang.NewSymbol("concat")) -if v116.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) } -v117 := v116.Get() -v118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v119 := v118.FindInternedVar(lang.NewSymbol("list")) -if v119.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v119))) +// shorts +{ +var v1 lang.FnFunc +{ // function shorts +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v120 := v119.Get() -v121 := lang.Apply(v120, []any{lang.NewSymbol("glojure.core/next")}) -v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v123 := v122.FindInternedVar(lang.NewSymbol("list")) -if v123.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v124 := v123.Get() -v125 := lang.Apply(v124, []any{v25}) -v126 := lang.Apply(v117, []any{v121, v125}) -v127 := lang.Apply(v114, []any{v126}) -v128 := lang.Apply(v95, []any{v44, v30, v111, v25, v127}) -v92 = v128 -} else { -v92 = v44 +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -var v129 any -if lang.IsTruthy(v35) { -v129 = v30 -} else { -v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v131 := v130.FindInternedVar(lang.NewSymbol("list")) -if v131.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v132 := v131.Get() -v133 := lang.Apply(v132, []any{lang.NewSymbol("glojure.core/nth"), v20, v45, nil}) -v129 = v133 +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v134 := lang.Apply(v11, []any{v92, v54, v129}) -var v91 any = v134 -v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v137 := v136.FindInternedVar(lang.NewSymbol("inc")) -if v137.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) +v20 := v19.Get() +v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/shorts")}) +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("list")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -v138 := v137.Get() -v139 := lang.Apply(v138, []any{v45}) -var v135 any = v139 -v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v142 := v141.FindInternedVar(lang.NewSymbol("next")) -if v142.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v3}) +v26 := lang.Apply(v9, []any{v13, v17, v21, v25}) +v27 := lang.Apply(v6, []any{v26}) +return v27 +}) +v2 := v1 +_ = v2 } -v143 := v142.Get() -v144 := lang.Apply(v143, []any{v46}) -var v140 any = v144 -var v145 any = v47 -v44 = v91 -v45 = v135 -v46 = v140 -v47 = v145 -continue +v0 := lang.NewSymbol("shorts").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Casts to shorts[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5387), lang.NewKeyword("end-line"), int(5387))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "shorts") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("shorts is not a function"))) } -v88 = v89 -} else { -v88 = nil +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v78 = v88 } -v60 = v78 +// shuffle +{ +v0 := lang.NewSymbol("shuffle").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return a random permutation of coll", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7343), lang.NewKeyword("end-line"), int(7343))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("to-array")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v49 = v60 -} else { -v49 = v44 +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +v9 := lang.Apply(lang1.NewArrayList, []any{v8}) +var v4 any = v9 +_ = v4 +v11 := lang.Apply(nil, []any{v4}) +_ = v11 +v12, ok := lang.FieldOrMethod(v4, "toArray") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "toArray"))) } -v48 = v49 - break +var v13 any +switch reflect.TypeOf(v12).Kind() { +case reflect.Func: + v13 = lang.Apply(v12, nil) +default: + v13 = v12 } -return v48 +v14 := lang.Apply(nil, []any{v13}) +return v14 }) -v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4404), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(4438), lang.NewKeyword("end-column"), int(34)) -v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) -if err != nil { - panic(err) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -var v15 any = v18 -_ = v15 -var v20 lang.FnFunc -v20 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { +} +// shutdown-agents +{ +v0 := lang.NewSymbol("shutdown-agents").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Initiates a shutdown of the thread pools that back the agent\n system. Running actions will complete, but no new actions will be\n accepted", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2252), lang.NewKeyword("end-line"), int(2252))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v21 := args[0] -v22 := args[1] -v23 := args[2] -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("gensym")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.Apply(v27, []any{"map__"}) -var v24 any = v28 -_ = v24 -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("with-meta")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +v3 := lang.Apply(lang1.ShutdownAgents, nil) +return v3 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v32 := v31.Get() -v33 := lang.NewMap(lang.NewKeyword("tag"), lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.ISeq")) -v34 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4442), lang.NewKeyword("column"), int(52), lang.NewKeyword("end-line"), int(4442), lang.NewKeyword("end-column"), int(103)) -v35, err := lang.WithMeta(v33, v34.(lang.IPersistentMap)) -if err != nil { - panic(err) } -v36 := lang.Apply(v32, []any{v24, v35}) -var v29 any = v36 -_ = v29 -v38 := lang.Apply(lang.NewKeyword("or"), []any{v22}) -var v37 any = v38 -_ = v37 -var v41 lang.FnFunc -v41 = lang.NewFnFunc(func(args ...any) any { +// sigs +{ +v0 := lang.NewSymbol("sigs").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(223), lang.NewKeyword("column"), int(2), lang.NewKeyword("end-line"), int(224), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v42 := args[0] -var v43 any -v44 := lang.Apply(lang.NewKeyword("as"), []any{v22}) -if lang.IsTruthy(v44) { -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("conj")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("assert-valid-fdecl")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v47 := v46.Get() -v48 := lang.Apply(lang.NewKeyword("as"), []any{v22}) -v49 := lang.Apply(v47, []any{v42, v48, v24}) -v43 = v49 -} else { -v43 = v42 +v6 := v5.Get() +v7 := lang.Apply(v6, []any{v3}) +_ = v7 +var v9 lang.FnFunc +v9 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v10 := args[0] +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("first")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } -return v43 -}) -v42 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4450), lang.NewKeyword("column"), int(40), lang.NewKeyword("end-line"), int(4453), lang.NewKeyword("end-column"), int(48)) -v43, err := lang.WithMeta(v41, v42.(lang.IPersistentMap)) -if err != nil { - panic(err) +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v10}) +var v11 any = v15 +_ = v11 +var v17 any +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("first")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("conj")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +v20 := v19.Get() +v21 := lang.Apply(v20, []any{v16}) +v22 := lang.Apply(lang1.Equals, []any{lang.NewSymbol("&form"), v21}) +if lang.IsTruthy(v22) { +v23 := lang.Apply(lang1.Count, []any{v16}) +v24 := lang.Apply(lang1.Subvec, []any{v16, int64(2), v23}) +v17 = v24 +} else { +v17 = v16 } -v46 := v45.Get() -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("conj")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +var v16 any = v17 +_ = v16 +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("next")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) } -v49 := v48.Get() -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("conj")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +v28 := v27.Get() +v29 := lang.Apply(v28, []any{v10}) +var v25 any = v29 +_ = v25 +var v31 any +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("map?")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) } -v52 := v51.Get() -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("conj")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +v34 := v33.Get() +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("first")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) } -v55 := v54.Get() -v56 := lang.Apply(v55, []any{v21, v24}) -v57 := lang.Apply(v52, []any{v56, v23}) -v58 := lang.Apply(v49, []any{v57, v24}) -v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v60 := v59.FindInternedVar(lang.NewSymbol("seq")) -if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) +v37 := v36.Get() +v38 := lang.Apply(v37, []any{v25}) +v39 := lang.Apply(v34, []any{v38}) +if lang.IsTruthy(v39) { +var v40 any +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("next")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } -v61 := v60.Get() -v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v63 := v62.FindInternedVar(lang.NewSymbol("concat")) -if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v25}) +if lang.IsTruthy(v44) { +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("with-meta")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) } -v64 := v63.Get() -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("list")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +v47 := v46.Get() +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("conj")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) } -v67 := v66.Get() -v68 := lang.Apply(v67, []any{lang.NewSymbol("if")}) -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("list")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +v50 := v49.Get() +var v51 any +v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v53 := v52.FindInternedVar(lang.NewSymbol("meta")) +if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) } -v71 := v70.Get() -v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v73 := v72.FindInternedVar(lang.NewSymbol("seq")) -if v73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) +v54 := v53.Get() +v55 := lang.Apply(v54, []any{v16}) +if lang.IsTruthy(v55) { +v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v57 := v56.FindInternedVar(lang.NewSymbol("meta")) +if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) } -v74 := v73.Get() -v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v76 := v75.FindInternedVar(lang.NewSymbol("concat")) -if v76.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) +v58 := v57.Get() +v59 := lang.Apply(v58, []any{v16}) +v51 = v59 +} else { +v60 := lang.NewMap() +v61 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(237), lang.NewKeyword("column"), int(77), lang.NewKeyword("end-line"), int(237), lang.NewKeyword("end-column"), int(78)) +v62, err := lang.WithMeta(v60, v61.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v77 := v76.Get() -v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v79 := v78.FindInternedVar(lang.NewSymbol("list")) -if v79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) +v51 = v62 } -v80 := v79.Get() -v81 := lang.Apply(v80, []any{lang.NewSymbol("glojure.core/seq?")}) -v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v83 := v82.FindInternedVar(lang.NewSymbol("list")) -if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) +v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v64 := v63.FindInternedVar(lang.NewSymbol("first")) +if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) } -v84 := v83.Get() -v85 := lang.Apply(v84, []any{v24}) -v86 := lang.Apply(v77, []any{v81, v85}) -v87 := lang.Apply(v74, []any{v86}) -v88 := lang.Apply(v71, []any{v87}) -v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v90 := v89.FindInternedVar(lang.NewSymbol("list")) -if v90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) +v65 := v64.Get() +v66 := lang.Apply(v65, []any{v25}) +v67 := lang.Apply(v50, []any{v51, v66}) +v68 := lang.Apply(v47, []any{v16, v67}) +v40 = v68 +} else { +v40 = v16 } -v91 := v90.Get() -v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v93 := v92.FindInternedVar(lang.NewSymbol("seq")) -if v93.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) +v31 = v40 +} else { +v31 = v16 } -v94 := v93.Get() -v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v96 := v95.FindInternedVar(lang.NewSymbol("concat")) -if v96.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) +return v31 +}) +v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(228), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(239), lang.NewKeyword("end-column"), int(25)) +v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v97 := v96.Get() -v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v99 := v98.FindInternedVar(lang.NewSymbol("list")) -if v99.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) +var v8 any = v11 +_ = v8 +var v13 lang.FnFunc +v13 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v14 := args[0] +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("meta")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -v100 := v99.Get() -v101 := lang.Apply(v100, []any{lang.NewSymbol("if")}) -v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v103 := v102.FindInternedVar(lang.NewSymbol("list")) -if v103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v14}) +var v15 any = v19 +_ = v15 +v21 := lang.Apply(lang.NewKeyword("tag"), []any{v15}) +var v20 any = v21 +_ = v20 +var v23 any +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("instance?")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -v104 := v103.Get() -v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v106 := v105.FindInternedVar(lang.NewSymbol("seq")) -if v106.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) +v26 := v25.Get() +v27 := lang.Apply(v26, []any{lang1.*Symbol, v20}) +if lang.IsTruthy(v27) { +var v28 any +v29, ok := lang.FieldOrMethod(v20, "Name") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v20, "Name"))) } -v107 := v106.Get() -v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v109 := v108.FindInternedVar(lang.NewSymbol("concat")) -if v109.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) +var v30 any +switch reflect.TypeOf(v29).Kind() { +case reflect.Func: + v30 = lang.Apply(v29, nil) +default: + v30 = v29 } -v110 := v109.Get() -v111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v112 := v111.FindInternedVar(lang.NewSymbol("list")) -if v112.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v112))) +v31 := lang.Apply(strings22.Index, []any{v30, "."}) +v32 := lang.Apply(lang1.Equiv, []any{v31, int64(-1)}) +if lang.IsTruthy(v32) { +var v33 any +v34 := lang.Apply(lang1.Equals, []any{nil, nil}) +if lang.IsTruthy(v34) { +var v35 any = nil +_ = v35 +var v37 any +if lang.IsTruthy(v35) { +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("with-meta")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) } -v113 := v112.Get() -v114 := lang.Apply(v113, []any{lang.NewSymbol("glojure.core/next")}) -v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v116 := v115.FindInternedVar(lang.NewSymbol("list")) -if v116.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("assoc")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } -v117 := v116.Get() -v118 := lang.Apply(v117, []any{v29}) -v119 := lang.Apply(v110, []any{v114, v118}) -v120 := lang.Apply(v107, []any{v119}) -v121 := lang.Apply(v104, []any{v120}) -v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v123 := v122.FindInternedVar(lang.NewSymbol("list")) -if v123.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) +v43 := v42.Get() +v44, ok := lang.FieldOrMethod(v35, "Name") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v35, "Name"))) } -v124 := v123.Get() -v125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v126 := v125.FindInternedVar(lang.NewSymbol("seq")) -if v126.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v126))) +var v45 any +switch reflect.TypeOf(v44).Kind() { +case reflect.Func: + v45 = lang.Apply(v44, nil) +default: + v45 = v44 } -v127 := v126.Get() -v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v129 := v128.FindInternedVar(lang.NewSymbol("concat")) -if v129.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v129))) +v46 := lang.Apply(lang1.NewSymbol, []any{v45}) +v47 := lang.Apply(v43, []any{v15, lang.NewKeyword("tag"), v46}) +v48 := lang.Apply(v40, []any{v14, v47}) +v37 = v48 +} else { +v37 = v14 } -v130 := v129.Get() -v131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v132 := v131.FindInternedVar(lang.NewSymbol("list")) -if v132.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v132))) +v33 = v37 +} else { +v33 = v14 } -v133 := v132.Get() -v134 := lang.Apply(v133, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewPersistentArrayMapAsIfByAssoc")}) -v135 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v136 := v135.FindInternedVar(lang.NewSymbol("list")) -if v136.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v136))) +v28 = v33 +} else { +v28 = v14 } -v137 := v136.Get() -v138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v139 := v138.FindInternedVar(lang.NewSymbol("seq")) -if v139.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v139))) +v23 = v28 +} else { +v23 = v14 } -v140 := v139.Get() -v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v142 := v141.FindInternedVar(lang.NewSymbol("concat")) -if v142.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) +return v23 +}) +v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(240), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(252), lang.NewKeyword("end-column"), int(37)) +v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v143 := v142.Get() -v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v145 := v144.FindInternedVar(lang.NewSymbol("list")) -if v145.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) +var v12 any = v15 +_ = v12 +var v17 any +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("seq?")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v146 := v145.Get() -v147 := lang.Apply(v146, []any{lang.NewSymbol("glojure.core/to-array")}) -v148 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v149 := v148.FindInternedVar(lang.NewSymbol("list")) -if v149.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v149))) +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("first")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v150 := v149.Get() -v151 := lang.Apply(v150, []any{v29}) -v152 := lang.Apply(v143, []any{v147, v151}) -v153 := lang.Apply(v140, []any{v152}) -v154 := lang.Apply(v137, []any{v153}) -v155 := lang.Apply(v130, []any{v134, v154}) -v156 := lang.Apply(v127, []any{v155}) -v157 := lang.Apply(v124, []any{v156}) -v158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v159 := v158.FindInternedVar(lang.NewSymbol("list")) -if v159.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v159))) +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v3}) +v25 := lang.Apply(v20, []any{v24}) +if lang.IsTruthy(v25) { +v27 := lang.NewVector() +v28 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(254), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(254), lang.NewKeyword("end-column"), int(20)) +v29, err := lang.WithMeta(v27, v28.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v160 := v159.Get() -v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v162 := v161.FindInternedVar(lang.NewSymbol("seq")) -if v162.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) +var v26 any = v29 +_ = v26 +var v30 any = v3 +_ = v30 +var v31 any +for { +var v32 any +if lang.IsTruthy(v30) { +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("conj")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } -v163 := v162.Get() -v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v165 := v164.FindInternedVar(lang.NewSymbol("concat")) -if v165.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("first")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -v166 := v165.Get() -v167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v168 := v167.FindInternedVar(lang.NewSymbol("list")) -if v168.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v168))) +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v30}) +v41 := lang.Apply(v8, []any{v40}) +v42 := lang.Apply(v12, []any{v41}) +v43 := lang.Apply(v36, []any{v26, v42}) +var v33 any = v43 +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("next")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) } -v169 := v168.Get() -v170 := lang.Apply(v169, []any{lang.NewSymbol("if")}) -v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v172 := v171.FindInternedVar(lang.NewSymbol("list")) -if v172.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) +v47 := v46.Get() +v48 := lang.Apply(v47, []any{v30}) +var v44 any = v48 +v26 = v33 +v30 = v44 +continue +} else { +v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v50 := v49.FindInternedVar(lang.NewSymbol("seq")) +if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) } -v173 := v172.Get() -v174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v175 := v174.FindInternedVar(lang.NewSymbol("seq")) -if v175.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v175))) +v51 := v50.Get() +v52 := lang.Apply(v51, []any{v26}) +v32 = v52 } -v176 := v175.Get() -v177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v178 := v177.FindInternedVar(lang.NewSymbol("concat")) -if v178.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v178))) +v31 = v32 + break } -v179 := v178.Get() -v180 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v181 := v180.FindInternedVar(lang.NewSymbol("list")) -if v181.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v181))) +v17 = v31 +} else { +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("list")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) } -v182 := v181.Get() -v183 := lang.Apply(v182, []any{lang.NewSymbol("glojure.core/seq")}) -v184 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v185 := v184.FindInternedVar(lang.NewSymbol("list")) -if v185.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v185))) +v28 := v27.Get() +v29 := lang.Apply(v8, []any{v3}) +v30 := lang.Apply(v12, []any{v29}) +v31 := lang.Apply(v28, []any{v30}) +v17 = v31 } -v186 := v185.Get() -v187 := lang.Apply(v186, []any{v29}) -v188 := lang.Apply(v179, []any{v183, v187}) -v189 := lang.Apply(v176, []any{v188}) -v190 := lang.Apply(v173, []any{v189}) -v191 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v192 := v191.FindInternedVar(lang.NewSymbol("list")) -if v192.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v192))) +return v17 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(225), lang.NewKeyword("column"), int(2), lang.NewKeyword("end-line"), int(258), lang.NewKeyword("end-column"), int(43))).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v193 := v192.Get() -v194 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v195 := v194.FindInternedVar(lang.NewSymbol("seq")) -if v195.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v195))) } -v196 := v195.Get() -v197 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v198 := v197.FindInternedVar(lang.NewSymbol("concat")) -if v198.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v198))) +// simple-ident? +{ +v0 := lang.NewSymbol("simple-ident?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a symbol or keyword without a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1613), lang.NewKeyword("end-line"), int(1613))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("ident?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v199 := v198.Get() -v200 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v201 := v200.FindInternedVar(lang.NewSymbol("list")) -if v201.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v201))) +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +var v4 any = v8 +_ = v4 +var v10 any +if lang.IsTruthy(v4) { +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("nil?")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v202 := v201.Get() -v203 := lang.Apply(v202, []any{lang.NewSymbol("glojure.core/first")}) -v204 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v205 := v204.FindInternedVar(lang.NewSymbol("list")) -if v205.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v205))) +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("namespace")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v206 := v205.Get() -v207 := lang.Apply(v206, []any{v29}) -v208 := lang.Apply(v199, []any{v203, v207}) -v209 := lang.Apply(v196, []any{v208}) -v210 := lang.Apply(v193, []any{v209}) -v211 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v212 := v211.FindInternedVar(lang.NewSymbol("list")) -if v212.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v212))) +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v3}) +v18 := lang.Apply(v13, []any{v17}) +v10 = v18 +} else { +v10 = v4 } -v213 := v212.Get() -v214 := lang.Apply(v213, []any{lang.NewSymbol("glojure.lang.PersistentArrayMap/EMPTY")}) -v215 := lang.Apply(v166, []any{v170, v190, v210, v214}) -v216 := lang.Apply(v163, []any{v215}) -v217 := lang.Apply(v160, []any{v216}) -v218 := lang.Apply(v97, []any{v101, v121, v157, v217}) -v219 := lang.Apply(v94, []any{v218}) -v220 := lang.Apply(v91, []any{v219}) -v221 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v222 := v221.FindInternedVar(lang.NewSymbol("list")) -if v222.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v222))) +return v10 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v223 := v222.Get() -v224 := lang.Apply(v223, []any{v24}) -v225 := lang.Apply(v64, []any{v68, v88, v220, v224}) -v226 := lang.Apply(v61, []any{v225}) -v227 := lang.Apply(v46, []any{v58, v226}) -v228 := lang.Apply(v43, []any{v227}) -var v40 any = v228 -_ = v40 -v231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v232 := v231.FindInternedVar(lang.NewSymbol("reduce1")) -if v232.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v232))) } -v233 := v232.Get() -var v234 lang.FnFunc -v234 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { +// simple-keyword? +{ +v0 := lang.NewSymbol("simple-keyword?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a keyword without a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1633), lang.NewKeyword("end-line"), int(1633))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v235 := args[0] -v236 := args[1] -var v237 any -v238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v239 := v238.FindInternedVar(lang.NewSymbol("keyword?")) -if v239.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v239))) +v3 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("keyword?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v240 := v239.Get() -v241 := lang.Apply(v240, []any{v236}) -if lang.IsTruthy(v241) { -v243 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v244 := v243.FindInternedVar(lang.NewSymbol("namespace")) -if v244.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v244))) +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +var v4 any = v8 +_ = v4 +var v10 any +if lang.IsTruthy(v4) { +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("nil?")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v245 := v244.Get() -v246 := lang.Apply(v245, []any{v236}) -var v242 any = v246 -_ = v242 -v248 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v249 := v248.FindInternedVar(lang.NewSymbol("name")) -if v249.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v249))) +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("namespace")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v250 := v249.Get() -v251 := lang.Apply(v250, []any{v236}) -var v247 any = v251 -_ = v247 -var v253 any -v254 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v255 := v254.FindInternedVar(lang.NewSymbol("=")) -if v255.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v255))) +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v3}) +v18 := lang.Apply(v13, []any{v17}) +v10 = v18 +} else { +v10 = v4 } -v256 := v255.Get() -v257 := lang.Apply(v256, []any{v247, "keys"}) -if lang.IsTruthy(v257) { -v258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v259 := v258.FindInternedVar(lang.NewSymbol("assoc")) -if v259.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v259))) +return v10 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v260 := v259.Get() -var v261 lang.FnFunc -v261 = lang.NewFnFunc(func(args ...any) any { +} +// simple-symbol? +{ +v0 := lang.NewSymbol("simple-symbol?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a symbol without a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1623), lang.NewKeyword("end-line"), int(1623))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v262 := args[0] -v263 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v264 := v263.FindInternedVar(lang.NewSymbol("keyword")) -if v264.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v264))) +v3 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("symbol?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v265 := v264.Get() -var v266 any = v242 -_ = v266 -var v268 any -if lang.IsTruthy(v266) { -v268 = v266 -} else { -v269 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v270 := v269.FindInternedVar(lang.NewSymbol("namespace")) -if v270.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v270))) +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +var v4 any = v8 +_ = v4 +var v10 any +if lang.IsTruthy(v4) { +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("nil?")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v271 := v270.Get() -v272 := lang.Apply(v271, []any{v262}) -v268 = v272 +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("namespace")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v266 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v267 := v266.FindInternedVar(lang.NewSymbol("name")) -if v267.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v267))) +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v3}) +v18 := lang.Apply(v13, []any{v17}) +v10 = v18 +} else { +v10 = v4 } -v268 := v267.Get() -v269 := lang.Apply(v268, []any{v262}) -v270 := lang.Apply(v265, []any{v268, v269}) -return v270 +return v10 }) -v262 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4460), lang.NewKeyword("column"), int(93), lang.NewKeyword("end-line"), int(4460), lang.NewKeyword("end-column"), int(135)) -v263, err := lang.WithMeta(v261, v262.(lang.IPersistentMap)) -if err != nil { - panic(err) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v264 := lang.Apply(v260, []any{v235, v236, v263}) -v253 = v264 -} else { -var v265 any -v266 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v267 := v266.FindInternedVar(lang.NewSymbol("=")) -if v267.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v267))) } -v268 := v267.Get() -v269 := lang.Apply(v268, []any{v247, "syms"}) -if lang.IsTruthy(v269) { -v270 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v271 := v270.FindInternedVar(lang.NewSymbol("assoc")) -if v271.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v271))) +// slurp +{ +v1 := reflect.TypeOf("") +v0 := lang.NewSymbol("slurp").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("opts"))), lang.NewKeyword("doc"), "Opens a reader on f and reads all its contents, returning a string.\n See glojure.java.io/reader for a complete list of supported arguments.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7025), lang.NewKeyword("end-line"), int(7025))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := lang.NewList(args[1:]...) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("normalize-slurp-opts")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v272 := v271.Get() -var v273 lang.FnFunc -v273 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v6}) +var v6 any = v10 +_ = v6 +var v11 any = "unimplemented: new with non-constant class type" +_ = v11 +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("apply")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.FindNamespace(lang.NewSymbol("glojure.go.io")) +v18 := v17.FindInternedVar(lang.NewSymbol("reader")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v16, []any{v19, v4, v6}) +var v13 any = v20 +_ = v13 +var v22 any +func() { +defer func() { +v23, ok := lang.FieldOrMethod(v13, "close") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v13, "close"))) +} +var v24 any +switch reflect.TypeOf(v23).Kind() { +case reflect.Func: + v24 = lang.Apply(v23, nil) +default: + v24 = v23 +} +}() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.go.io")) +v26 := v25.FindInternedVar(lang.NewSymbol("copy")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.Apply(v27, []any{v13, v11}) +_ = v28 +v29 := lang.Apply(lang1.ToString, []any{v11}) +v22 = v29 +}() +return v22 + } +}) +v4 := reflect.TypeOf("") +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// some +{ +v0 := lang.NewSymbol("some").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns the first logical true value of (pred x) for any x in coll,\n else nil. One common idiom is to use a set as pred, for example\n this will return :fred if :fred is in the sequence, otherwise nil:\n (some #{:fred} coll)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2684), lang.NewKeyword("end-line"), int(2684))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v274 := args[0] -v275 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v276 := v275.FindInternedVar(lang.NewSymbol("list")) -if v276.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v276))) +v3 := args[0] +v4 := args[1] +recur_loop_481: +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("seq")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v277 := v276.Get() -v278 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v279 := v278.FindInternedVar(lang.NewSymbol("symbol")) -if v279.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v279))) +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v4}) +var v5 any = v9 +_ = v5 +var v11 any +if lang.IsTruthy(v5) { +var v12 any = v5 +_ = v12 +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("first")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } -v280 := v279.Get() -var v281 any = v242 -_ = v281 -var v283 any -if lang.IsTruthy(v281) { -v283 = v281 +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v12}) +v19 := lang.Apply(v3, []any{v18}) +var v14 any = v19 +_ = v14 +var v21 any +if lang.IsTruthy(v14) { +v21 = v14 } else { -v284 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v285 := v284.FindInternedVar(lang.NewSymbol("namespace")) -if v285.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v285))) +var v22 any = v3 +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("next")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -v286 := v285.Get() -v287 := lang.Apply(v286, []any{v274}) -v283 = v287 +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v12}) +var v23 any = v27 +v3 = v22 +v4 = v23 +goto recur_loop_481 } -v281 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v282 := v281.FindInternedVar(lang.NewSymbol("name")) -if v282.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v282))) +v11 = v21 +} else { +v11 = nil } -v283 := v282.Get() -v284 := lang.Apply(v283, []any{v274}) -v285 := lang.Apply(v280, []any{v283, v284}) -v286 := lang.Apply(v277, []any{lang.NewSymbol("quote"), v285}) -return v286 +return v11 }) -v274 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4461), lang.NewKeyword("column"), int(93), lang.NewKeyword("end-line"), int(4461), lang.NewKeyword("end-column"), int(148)) -v275, err := lang.WithMeta(v273, v274.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v276 := lang.Apply(v272, []any{v235, v236, v275}) -v265 = v276 -} else { -var v277 any -v278 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v279 := v278.FindInternedVar(lang.NewSymbol("=")) -if v279.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v279))) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v280 := v279.Get() -v281 := lang.Apply(v280, []any{v247, "strs"}) -if lang.IsTruthy(v281) { -v282 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v283 := v282.FindInternedVar(lang.NewSymbol("assoc")) -if v283.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v283))) } -v284 := v283.Get() -v285 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v286 := v285.FindInternedVar(lang.NewSymbol("str")) -if v286.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v286))) +// some-> +{ +v0 := lang.NewSymbol("some->").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "When expr is not nil, threads it into the first form (via ->),\n and when that result is not nil, through the next etc", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7653), lang.NewKeyword("end-line"), int(7653))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("gensym")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v287 := v286.Get() -v288 := lang.Apply(v284, []any{v235, v236, v287}) -v277 = v288 -} else { -var v289 any -if lang.IsTruthy(lang.NewKeyword("else")) { -v289 = v235 -} else { -v289 = nil +v10 := v9.Get() +v11 := lang.Apply(v10, nil) +var v7 any = v11 +_ = v7 +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("map")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } -v277 = v289 +v15 := v14.Get() +var v16 lang.FnFunc +v16 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v17 := args[0] +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("seq")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v265 = v277 +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("concat")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v253 = v265 +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("list")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -v237 = v253 -} else { -v237 = v235 +v26 := v25.Get() +v27 := lang.Apply(v26, []any{lang.NewSymbol("if")}) +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("list")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } -return v237 -}) -v235 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4456), lang.NewKeyword("column"), int(45), lang.NewKeyword("end-line"), int(4464), lang.NewKeyword("end-column"), int(60)) -v236, err := lang.WithMeta(v234, v235.(lang.IPersistentMap)) -if err != nil { - panic(err) +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("seq")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -v237 := lang.NewMap() -v238 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4465), lang.NewKeyword("column"), int(45), lang.NewKeyword("end-line"), int(4465), lang.NewKeyword("end-column"), int(46)) -v239, err := lang.WithMeta(v237, v238.(lang.IPersistentMap)) -if err != nil { - panic(err) +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("concat")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } -v240 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v241 := v240.FindInternedVar(lang.NewSymbol("keys")) -if v241.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v241))) +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("list")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -v242 := v241.Get() -v243 := lang.Apply(v242, []any{v22}) -v244 := lang.Apply(v233, []any{v236, v239, v243}) -var v230 any = v244 -_ = v230 -v246 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v247 := v246.FindInternedVar(lang.NewSymbol("reduce1")) -if v247.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v247))) +v39 := v38.Get() +v40 := lang.Apply(v39, []any{lang.NewSymbol("glojure.core/nil?")}) +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("list")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } -v248 := v247.Get() -var v249 lang.FnFunc -v249 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v250 := args[0] -v251 := args[1] -v252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v253 := v252.FindInternedVar(lang.NewSymbol("reduce1")) -if v253.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v253))) +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v7}) +v45 := lang.Apply(v36, []any{v40, v44}) +v46 := lang.Apply(v33, []any{v45}) +v47 := lang.Apply(v30, []any{v46}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) } -v254 := v253.Get() -var v255 lang.FnFunc -v255 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v256 := args[0] -v257 := args[1] -v258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v259 := v258.FindInternedVar(lang.NewSymbol("assoc")) -if v259.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v259))) +v50 := v49.Get() +v51 := lang.Apply(v50, []any{nil}) +v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v53 := v52.FindInternedVar(lang.NewSymbol("list")) +if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) } -v260 := v259.Get() -v261 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v262 := v261.FindInternedVar(lang.NewSymbol("val")) -if v262.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v262))) +v54 := v53.Get() +v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v56 := v55.FindInternedVar(lang.NewSymbol("seq")) +if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) } -v263 := v262.Get() -v264 := lang.Apply(v263, []any{v251}) -v265 := lang.Apply(v264, []any{v257}) -v266 := lang.Apply(v260, []any{v256, v257, v265}) -return v266 -}) -v256 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4469), lang.NewKeyword("column"), int(52), lang.NewKeyword("end-line"), int(4469), lang.NewKeyword("end-column"), int(82)) -v257, err := lang.WithMeta(v255, v256.(lang.IPersistentMap)) -if err != nil { - panic(err) +v57 := v56.Get() +v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v59 := v58.FindInternedVar(lang.NewSymbol("concat")) +if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) } -v258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v259 := v258.FindInternedVar(lang.NewSymbol("dissoc")) -if v259.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v259))) +v60 := v59.Get() +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("list")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) } -v260 := v259.Get() -v261 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v262 := v261.FindInternedVar(lang.NewSymbol("key")) -if v262.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v262))) +v63 := v62.Get() +v64 := lang.Apply(v63, []any{lang.NewSymbol("glojure.core/->")}) +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("list")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) } -v263 := v262.Get() -v264 := lang.Apply(v263, []any{v251}) -v265 := lang.Apply(v260, []any{v250, v264}) -v266 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v267 := v266.FindInternedVar(lang.NewSymbol("key")) -if v267.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v267))) +v67 := v66.Get() +v68 := lang.Apply(v67, []any{v7}) +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("list")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) } -v268 := v267.Get() -v269 := lang.Apply(v268, []any{v251}) -v270 := lang.Apply(v269, []any{v250}) -v271 := lang.Apply(v254, []any{v257, v265, v270}) -return v271 +v71 := v70.Get() +v72 := lang.Apply(v71, []any{v17}) +v73 := lang.Apply(v60, []any{v64, v68, v72}) +v74 := lang.Apply(v57, []any{v73}) +v75 := lang.Apply(v54, []any{v74}) +v76 := lang.Apply(v23, []any{v27, v47, v51, v75}) +v77 := lang.Apply(v20, []any{v76}) +return v77 }) -v250 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4468), lang.NewKeyword("column"), int(41), lang.NewKeyword("end-line"), int(4471), lang.NewKeyword("end-column"), int(70)) -v251, err := lang.WithMeta(v249, v250.(lang.IPersistentMap)) +v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7659), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7659), lang.NewKeyword("end-column"), int(64)) +v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) if err != nil { panic(err) } -v252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v253 := v252.FindInternedVar(lang.NewSymbol("dissoc")) -if v253.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v253))) +v19 := lang.Apply(v15, []any{v18, v6}) +var v12 any = v19 +_ = v12 +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v254 := v253.Get() -v255 := lang.Apply(v254, []any{v22, lang.NewKeyword("as"), lang.NewKeyword("or")}) -v256 := lang.Apply(v248, []any{v251, v255, v230}) -var v229 any = v256 -_ = v229 -var v230 any -for { -var v231 any -v232 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v233 := v232.FindInternedVar(lang.NewSymbol("seq")) -if v233.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v233))) +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -v234 := v233.Get() -v235 := lang.Apply(v234, []any{v229}) -if lang.IsTruthy(v235) { -v237 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v238 := v237.FindInternedVar(lang.NewSymbol("key")) -if v238.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v238))) +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v239 := v238.Get() -v240 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v241 := v240.FindInternedVar(lang.NewSymbol("first")) -if v241.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v241))) +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/let")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -v242 := v241.Get() -v243 := lang.Apply(v242, []any{v229}) -v244 := lang.Apply(v239, []any{v243}) -var v236 any = v244 -_ = v236 -v246 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v247 := v246.FindInternedVar(lang.NewSymbol("val")) -if v247.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v247))) +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("apply")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } -v248 := v247.Get() -v249 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v250 := v249.FindInternedVar(lang.NewSymbol("first")) -if v250.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v250))) +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("vector")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -v251 := v250.Get() -v252 := lang.Apply(v251, []any{v229}) -v253 := lang.Apply(v248, []any{v252}) -var v245 any = v253 -_ = v245 -var v255 any -v256 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v257 := v256.FindInternedVar(lang.NewSymbol("instance?")) -if v257.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v257))) +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("seq")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) } -v258 := v257.Get() -v259 := lang.Apply(v258, []any{lang1.Named, v236}) -if lang.IsTruthy(v259) { -v260 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v261 := v260.FindInternedVar(lang.NewSymbol("with-meta")) -if v261.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v261))) +v42 := v41.Get() +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("concat")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) } -v262 := v261.Get() -v263 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v264 := v263.FindInternedVar(lang.NewSymbol("symbol")) -if v264.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v264))) +v45 := v44.Get() +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("list")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) } -v265 := v264.Get() -v266 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v267 := v266.FindInternedVar(lang.NewSymbol("name")) -if v267.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v267))) +v48 := v47.Get() +v49 := lang.Apply(v48, []any{v7}) +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("list")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) } -v268 := v267.Get() -v269 := lang.Apply(v268, []any{v236}) -v270 := lang.Apply(v265, []any{nil, v269}) -v271 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v272 := v271.FindInternedVar(lang.NewSymbol("meta")) -if v272.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v272))) +v52 := v51.Get() +v53 := lang.Apply(v52, []any{v5}) +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("interleave")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) } -v273 := v272.Get() -v274 := lang.Apply(v273, []any{v236}) -v275 := lang.Apply(v262, []any{v270, v274}) -v255 = v275 -} else { -v255 = v236 +v56 := v55.Get() +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("repeat")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) } -var v254 any = v255 -_ = v254 -var v277 any -v278 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v279 := v278.FindInternedVar(lang.NewSymbol("contains?")) -if v279.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v279))) +v59 := v58.Get() +v60 := lang.Apply(v59, []any{v7}) +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("butlast")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) } -v280 := v279.Get() -v281 := lang.Apply(v280, []any{v37, v254}) -if lang.IsTruthy(v281) { -v282 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v283 := v282.FindInternedVar(lang.NewSymbol("list")) -if v283.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v283))) +v63 := v62.Get() +v64 := lang.Apply(v63, []any{v12}) +v65 := lang.Apply(v56, []any{v60, v64}) +v66 := lang.Apply(v45, []any{v49, v53, v65}) +v67 := lang.Apply(v42, []any{v66}) +v68 := lang.Apply(v36, []any{v39, v67}) +v69 := lang.Apply(v33, []any{v68}) +v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v71 := v70.FindInternedVar(lang.NewSymbol("list")) +if v71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) } -v284 := v283.Get() -v285 := lang.Apply(v37, []any{v254}) -v286 := lang.Apply(v284, []any{lang.NewSymbol("glojure.core/get"), v24, v245, v285}) -v277 = v286 +v72 := v71.Get() +var v73 any +v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v75 := v74.FindInternedVar(lang.NewSymbol("empty?")) +if v75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) +} +v76 := v75.Get() +v77 := lang.Apply(v76, []any{v12}) +if lang.IsTruthy(v77) { +v73 = v7 } else { -v287 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v288 := v287.FindInternedVar(lang.NewSymbol("list")) -if v288.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v288))) +v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v79 := v78.FindInternedVar(lang.NewSymbol("last")) +if v79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) } -v289 := v288.Get() -v290 := lang.Apply(v289, []any{lang.NewSymbol("glojure.core/get"), v24, v245}) -v277 = v290 +v80 := v79.Get() +v81 := lang.Apply(v80, []any{v12}) +v73 = v81 } -var v276 any = v277 -_ = v276 -var v293 any -v294 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v295 := v294.FindInternedVar(lang.NewSymbol("ident?")) -if v295.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v295))) +v82 := lang.Apply(v72, []any{v73}) +v83 := lang.Apply(v26, []any{v30, v69, v82}) +v84 := lang.Apply(v23, []any{v83}) +return v84 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v296 := v295.Get() -v297 := lang.Apply(v296, []any{v236}) -if lang.IsTruthy(v297) { -v298 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v299 := v298.FindInternedVar(lang.NewSymbol("conj")) -if v299.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v299))) } -v300 := v299.Get() -v301 := lang.Apply(v300, []any{v40, v254, v276}) -v293 = v301 -} else { -v302 := lang.Apply(v11, []any{v40, v236, v276}) -v293 = v302 +// some->> +{ +v0 := lang.NewSymbol("some->>").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "When expr is not nil, threads it into the first form (via ->>),\n and when that result is not nil, through the next etc", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7667), lang.NewKeyword("end-line"), int(7667))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("gensym")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -var v292 any = v293 -v304 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v305 := v304.FindInternedVar(lang.NewSymbol("next")) -if v305.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v305))) +v10 := v9.Get() +v11 := lang.Apply(v10, nil) +var v7 any = v11 +_ = v7 +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("map")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } -v306 := v305.Get() -v307 := lang.Apply(v306, []any{v229}) -var v303 any = v307 -v40 = v292 -v229 = v303 -continue -} else { -v231 = v40 +v15 := v14.Get() +var v16 lang.FnFunc +v16 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v17 := args[0] +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("seq")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v230 = v231 - break +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("concat")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -return v230 -}) -v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4440), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(4485), lang.NewKeyword("end-column"), int(34)) -v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) -if err != nil { - panic(err) +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("list")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -var v19 any = v22 -_ = v19 -var v24 any -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("symbol?")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +v26 := v25.Get() +v27 := lang.Apply(v26, []any{lang.NewSymbol("if")}) +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("list")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } -v27 := v26.Get() -v28 := lang.Apply(v27, []any{v13}) -if lang.IsTruthy(v28) { -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("conj")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("seq")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("conj")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("concat")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v12, v13}) -v36 := lang.Apply(v31, []any{v35, v14}) -v24 = v36 -} else { -var v37 any -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("vector?")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("list")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -v40 := v39.Get() -v41 := lang.Apply(v40, []any{v13}) -if lang.IsTruthy(v41) { -v42 := lang.Apply(v15, []any{v12, v13, v14}) -v37 = v42 -} else { -var v43 any -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("map?")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +v39 := v38.Get() +v40 := lang.Apply(v39, []any{lang.NewSymbol("glojure.core/nil?")}) +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("list")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v13}) -if lang.IsTruthy(v47) { -v48 := lang.Apply(v19, []any{v12, v13, v14}) -v43 = v48 -} else { -var v49 any -if lang.IsTruthy(lang.NewKeyword("else")) { -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("str")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v7}) +v45 := lang.Apply(v36, []any{v40, v44}) +v46 := lang.Apply(v33, []any{v45}) +v47 := lang.Apply(v30, []any{v46}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) } -v52 := v51.Get() -v53 := lang.Apply(v52, []any{"Unsupported binding form: ", v13}) -v54 := lang.Apply(errors10.New, []any{v53}) -panic(v54) -} else { -v49 = nil +v50 := v49.Get() +v51 := lang.Apply(v50, []any{nil}) +v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v53 := v52.FindInternedVar(lang.NewSymbol("list")) +if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) } -v43 = v49 +v54 := v53.Get() +v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v56 := v55.FindInternedVar(lang.NewSymbol("seq")) +if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) } -v37 = v43 +v57 := v56.Get() +v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v59 := v58.FindInternedVar(lang.NewSymbol("concat")) +if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) } -v24 = v37 +v60 := v59.Get() +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("list")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) } -return v24 -}) -v11 := v10 -_ = v11 +v63 := v62.Get() +v64 := lang.Apply(v63, []any{lang.NewSymbol("glojure.core/->>")}) +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("list")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) } -v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4402), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(4490), lang.NewKeyword("end-column"), int(82)) -v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) +v67 := v66.Get() +v68 := lang.Apply(v67, []any{v7}) +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("list")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +} +v71 := v70.Get() +v72 := lang.Apply(v71, []any{v17}) +v73 := lang.Apply(v60, []any{v64, v68, v72}) +v74 := lang.Apply(v57, []any{v73}) +v75 := lang.Apply(v54, []any{v74}) +v76 := lang.Apply(v23, []any{v27, v47, v51, v75}) +v77 := lang.Apply(v20, []any{v76}) +return v77 +}) +v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7673), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7673), lang.NewKeyword("end-column"), int(65)) +v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) if err != nil { panic(err) } -var v9 any = v12 -_ = v9 -var v14 lang.FnFunc -v14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v15 := args[0] -v16 := args[1] -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("first")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v16}) +v19 := lang.Apply(v15, []any{v18, v6}) +var v12 any = v19 +_ = v12 v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("second")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) if v22.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } v23 := v22.Get() -v24 := lang.Apply(v23, []any{v16}) -v25 := lang.Apply(v9, []any{v15, v20, v24}) -return v25 -}) -v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4491), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(4491), lang.NewKeyword("end-column"), int(66)) -v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) -if err != nil { - panic(err) +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -var v13 any = v16 -_ = v13 -var v18 any -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("every?")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("symbol?")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/let")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("map")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("apply")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("first")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("vector")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -v30 := v29.Get() -v31 := lang.Apply(v27, []any{v30, v4}) -v32 := lang.Apply(v21, []any{v24, v31}) -if lang.IsTruthy(v32) { -v18 = v3 -} else { -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("reduce1")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("seq")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) } -v35 := v34.Get() -v36 := lang.NewVector() -v37 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4494), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(4494), lang.NewKeyword("end-column"), int(31)) -v38, err := lang.WithMeta(v36, v37.(lang.IPersistentMap)) -if err != nil { - panic(err) +v42 := v41.Get() +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("concat")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) } -v39 := lang.Apply(v35, []any{v13, v38, v4}) -v18 = v39 +v45 := v44.Get() +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("list")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) } -return v18 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v48 := v47.Get() +v49 := lang.Apply(v48, []any{v7}) +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("list")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) } +v52 := v51.Get() +v53 := lang.Apply(v52, []any{v5}) +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("interleave")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) } -// loaded-libs -{ -v0 := lang.NewSymbol("loaded-libs").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Returns a sorted set of symbols naming the currently loaded libs", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6133), lang.NewKeyword("end-line"), int(6133))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v4 := v3.FindInternedVar(lang.NewSymbol("deref")) -if v4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) +v56 := v55.Get() +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("repeat")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) } -v5 := v4.Get() -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("*loaded-libs*")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +v59 := v58.Get() +v60 := lang.Apply(v59, []any{v7}) +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("butlast")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) } -v8 := v7.Get() -v9 := lang.Apply(v5, []any{v8}) -return v9 +v63 := v62.Get() +v64 := lang.Apply(v63, []any{v12}) +v65 := lang.Apply(v56, []any{v60, v64}) +v66 := lang.Apply(v45, []any{v49, v53, v65}) +v67 := lang.Apply(v42, []any{v66}) +v68 := lang.Apply(v36, []any{v39, v67}) +v69 := lang.Apply(v33, []any{v68}) +v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v71 := v70.FindInternedVar(lang.NewSymbol("list")) +if v71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) +} +v72 := v71.Get() +var v73 any +v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v75 := v74.FindInternedVar(lang.NewSymbol("empty?")) +if v75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) +} +v76 := v75.Get() +v77 := lang.Apply(v76, []any{v12}) +if lang.IsTruthy(v77) { +v73 = v7 +} else { +v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v79 := v78.FindInternedVar(lang.NewSymbol("last")) +if v79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) +} +v80 := v79.Get() +v81 := lang.Apply(v80, []any{v12}) +v73 = v81 +} +v82 := lang.Apply(v72, []any{v73}) +v83 := lang.Apply(v26, []any{v30, v69, v82}) +v84 := lang.Apply(v23, []any{v83}) +return v84 + } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -69893,656 +70180,933 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// load-reader +// some-fn { -v0 := lang.NewSymbol("load-reader").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rdr"))), lang.NewKeyword("doc"), "Sequentially read and evaluate the set of forms contained in the\n stream/file", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4081), lang.NewKeyword("end-line"), int(4081))).(*lang.Symbol) +v0 := lang.NewSymbol("some-fn").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("p")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2"), lang.NewSymbol("p3")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2"), lang.NewSymbol("p3"), lang.NewSymbol("&"), lang.NewSymbol("ps"))), lang.NewKeyword("doc"), "Takes a set of predicates and returns a function f that returns the first logical true value\n returned by one of its composing predicates against any of its arguments, else it returns\n logical false. Note that f is short-circuiting in that it will stop execution on the first\n argument that triggers a logical true result against the original predicates.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7505), lang.NewKeyword("end-line"), int(7505))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + switch len(args) { + case 1: v3 := args[0] -v4, _ := lang.FieldOrMethod(runtime3.Compiler, "load") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("load is not a function"))) +var v4 lang.FnFunc +{ // function sp1 +v4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +return nil + case 1: +v6 := args[0] +v7 := lang.Apply(v3, []any{v6}) +return v7 + case 2: +v6 := args[0] +v7 := args[1] +v9 := lang.Apply(v3, []any{v6}) +var v8 any = v9 +_ = v8 +var v11 any +if lang.IsTruthy(v8) { +v11 = v8 +} else { +v12 := lang.Apply(v3, []any{v7}) +v11 = v12 } -v5 := lang.Apply(v4, []any{v3}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +return v11 + case 3: +v6 := args[0] +v7 := args[1] +v8 := args[2] +v10 := lang.Apply(v3, []any{v6}) +var v9 any = v10 +_ = v9 +var v12 any +if lang.IsTruthy(v9) { +v12 = v9 +} else { +v14 := lang.Apply(v3, []any{v7}) +var v13 any = v14 +_ = v13 +var v16 any +if lang.IsTruthy(v13) { +v16 = v13 +} else { +v17 := lang.Apply(v3, []any{v8}) +v16 = v17 } +v12 = v16 } -// defmulti -{ -v0 := lang.NewSymbol("defmulti").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("docstring?"), lang.NewSymbol("attr-map?"), lang.NewSymbol("dispatch-fn"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Creates a new multimethod with the associated dispatch function.\n The docstring and attr-map are optional.\n\n Options are key-value pairs and may be one of:\n\n :default\n\n The default dispatch value, defaults to :default\n\n :hierarchy\n\n The value used for hierarchical dispatch (e.g. ::square is-a ::shape)\n\n Hierarchies are type-like relationships that do not depend upon type\n inheritance. By default Clojure's multimethods dispatch off of a\n global hierarchy map. However, a hierarchy relationship can be\n created with the derive function used to augment the root ancestor\n created with make-hierarchy.\n\n Multimethods expect the value of the hierarchy option to be supplied as\n a reference type e.g. a var (i.e. via the Var-quote dispatch macro #'\n or the var special form).", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1723), lang.NewKeyword("end-line"), int(1723))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { +return v12 default: if len(args) < 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -var v8 any -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("string?")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("first")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v6}) -v16 := lang.Apply(v11, []any{v15}) -if lang.IsTruthy(v16) { -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("first")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v6}) -v8 = v20 +v6 := args[0] +v7 := args[1] +v8 := args[2] +v9 := lang.NewList(args[3:]...) +v11 := lang.Apply(v5, []any{v6, v7, v8}) +var v10 any = v11 +_ = v10 +var v13 any +if lang.IsTruthy(v10) { +v13 = v10 } else { -v8 = nil +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("some")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -var v7 any = v8 -_ = v7 -var v22 any -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("string?")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v3, v9}) +v13 = v17 } -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("first")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +return v13 + } +}) +v5 := v4 +_ = v5 } -v28 := v27.Get() -v29 := lang.Apply(v28, []any{v21}) -v30 := lang.Apply(v25, []any{v29}) -if lang.IsTruthy(v30) { -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("next")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7512), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7518), lang.NewKeyword("end-column"), int(43)) +v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v21}) -v22 = v34 +return v6 + case 2: +v3 := args[0] +v4 := args[1] +var v5 lang.FnFunc +{ // function sp2 +v5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +return nil + case 1: +v7 := args[0] +v9 := lang.Apply(v3, []any{v7}) +var v8 any = v9 +_ = v8 +var v11 any +if lang.IsTruthy(v8) { +v11 = v8 } else { -v22 = v21 +v12 := lang.Apply(v4, []any{v7}) +v11 = v12 } -var v21 any = v22 -_ = v21 -var v36 any -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("map?")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +return v11 + case 2: +v7 := args[0] +v8 := args[1] +v10 := lang.Apply(v3, []any{v7}) +var v9 any = v10 +_ = v9 +var v12 any +if lang.IsTruthy(v9) { +v12 = v9 +} else { +v14 := lang.Apply(v3, []any{v8}) +var v13 any = v14 +_ = v13 +var v16 any +if lang.IsTruthy(v13) { +v16 = v13 +} else { +v18 := lang.Apply(v4, []any{v7}) +var v17 any = v18 +_ = v17 +var v20 any +if lang.IsTruthy(v17) { +v20 = v17 +} else { +v21 := lang.Apply(v4, []any{v8}) +v20 = v21 } -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("first")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +v16 = v20 } -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v21}) -v44 := lang.Apply(v39, []any{v43}) -if lang.IsTruthy(v44) { -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("first")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +v12 = v16 } -v47 := v46.Get() -v48 := lang.Apply(v47, []any{v21}) -v36 = v48 +return v12 + case 3: +v7 := args[0] +v8 := args[1] +v9 := args[2] +v11 := lang.Apply(v3, []any{v7}) +var v10 any = v11 +_ = v10 +var v13 any +if lang.IsTruthy(v10) { +v13 = v10 } else { -v49 := lang.NewMap() -v50 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1757), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(1757), lang.NewKeyword("end-column"), int(24)) -v51, err := lang.WithMeta(v49, v50.(lang.IPersistentMap)) -if err != nil { - panic(err) +v15 := lang.Apply(v3, []any{v8}) +var v14 any = v15 +_ = v14 +var v17 any +if lang.IsTruthy(v14) { +v17 = v14 +} else { +v19 := lang.Apply(v3, []any{v9}) +var v18 any = v19 +_ = v18 +var v21 any +if lang.IsTruthy(v18) { +v21 = v18 +} else { +v23 := lang.Apply(v4, []any{v7}) +var v22 any = v23 +_ = v22 +var v25 any +if lang.IsTruthy(v22) { +v25 = v22 +} else { +v27 := lang.Apply(v4, []any{v8}) +var v26 any = v27 +_ = v26 +var v29 any +if lang.IsTruthy(v26) { +v29 = v26 +} else { +v30 := lang.Apply(v4, []any{v9}) +v29 = v30 } -v36 = v51 +v25 = v29 } -var v35 any = v36 -_ = v35 -var v53 any -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("map?")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +v21 = v25 } -v56 := v55.Get() -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("first")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +v17 = v21 } -v59 := v58.Get() -v60 := lang.Apply(v59, []any{v52}) -v61 := lang.Apply(v56, []any{v60}) -if lang.IsTruthy(v61) { -v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v63 := v62.FindInternedVar(lang.NewSymbol("next")) -if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +v13 = v17 } -v64 := v63.Get() -v65 := lang.Apply(v64, []any{v52}) -v53 = v65 +return v13 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v7 := args[0] +v8 := args[1] +v9 := args[2] +v10 := lang.NewList(args[3:]...) +v12 := lang.Apply(v6, []any{v7, v8, v9}) +var v11 any = v12 +_ = v11 +var v14 any +if lang.IsTruthy(v11) { +v14 = v11 } else { -v53 = v52 +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("some")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } -var v52 any = v53 -_ = v52 -v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v68 := v67.FindInternedVar(lang.NewSymbol("first")) -if v68.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) +v17 := v16.Get() +var v18 lang.FnFunc +v18 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v19 := args[0] +v21 := lang.Apply(v3, []any{v19}) +var v20 any = v21 +_ = v20 +var v23 any +if lang.IsTruthy(v20) { +v23 = v20 +} else { +v24 := lang.Apply(v4, []any{v19}) +v23 = v24 } -v69 := v68.Get() -v70 := lang.Apply(v69, []any{v52}) -var v66 any = v70 -_ = v66 -v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v73 := v72.FindInternedVar(lang.NewSymbol("next")) -if v73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) +return v23 +}) +v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7526), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(7526), lang.NewKeyword("end-column"), int(52)) +v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v74 := v73.Get() -v75 := lang.Apply(v74, []any{v71}) -var v71 any = v75 -_ = v71 -var v77 any -if lang.IsTruthy(v7) { -v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v79 := v78.FindInternedVar(lang.NewSymbol("assoc")) -if v79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) +v21 := lang.Apply(v17, []any{v20, v10}) +v14 = v21 } -v80 := v79.Get() -v81 := lang.Apply(v80, []any{v76, lang.NewKeyword("doc"), v7}) -v77 = v81 -} else { -v77 = v76 +return v14 + } +}) +v6 := v5 +_ = v6 } -var v76 any = v77 -_ = v76 -var v83 any -v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v85 := v84.FindInternedVar(lang.NewSymbol("meta")) -if v85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) +v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7520), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7526), lang.NewKeyword("end-column"), int(61)) +v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v86 := v85.Get() -v87 := lang.Apply(v86, []any{v5}) -if lang.IsTruthy(v87) { -v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v89 := v88.FindInternedVar(lang.NewSymbol("conj")) -if v89.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) +return v7 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +var v6 lang.FnFunc +{ // function sp3 +v6 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +return nil + case 1: +v8 := args[0] +v10 := lang.Apply(v3, []any{v8}) +var v9 any = v10 +_ = v9 +var v12 any +if lang.IsTruthy(v9) { +v12 = v9 +} else { +v14 := lang.Apply(v4, []any{v8}) +var v13 any = v14 +_ = v13 +var v16 any +if lang.IsTruthy(v13) { +v16 = v13 +} else { +v17 := lang.Apply(v5, []any{v8}) +v16 = v17 } -v90 := v89.Get() -v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v92 := v91.FindInternedVar(lang.NewSymbol("meta")) -if v92.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) +v12 = v16 } -v93 := v92.Get() -v94 := lang.Apply(v93, []any{v5}) -v95 := lang.Apply(v90, []any{v94, v82}) -v83 = v95 +return v12 + case 2: +v8 := args[0] +v9 := args[1] +v11 := lang.Apply(v3, []any{v8}) +var v10 any = v11 +_ = v10 +var v13 any +if lang.IsTruthy(v10) { +v13 = v10 } else { -v83 = v82 +v15 := lang.Apply(v3, []any{v9}) +var v14 any = v15 +_ = v14 +var v17 any +if lang.IsTruthy(v14) { +v17 = v14 +} else { +v19 := lang.Apply(v4, []any{v8}) +var v18 any = v19 +_ = v18 +var v21 any +if lang.IsTruthy(v18) { +v21 = v18 +} else { +v23 := lang.Apply(v4, []any{v9}) +var v22 any = v23 +_ = v22 +var v25 any +if lang.IsTruthy(v22) { +v25 = v22 +} else { +v27 := lang.Apply(v5, []any{v8}) +var v26 any = v27 +_ = v26 +var v29 any +if lang.IsTruthy(v26) { +v29 = v26 +} else { +v30 := lang.Apply(v5, []any{v9}) +v29 = v30 } -var v82 any = v83 -_ = v82 -v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v98 := v97.FindInternedVar(lang.NewSymbol("with-meta")) -if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) +v25 = v29 } -v99 := v98.Get() -v100 := lang.Apply(v99, []any{v96, v82}) -var v96 any = v100 -_ = v96 -var v102 any -v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v104 := v103.FindInternedVar(lang.NewSymbol("=")) -if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) +v21 = v25 } -v105 := v104.Get() -v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v107 := v106.FindInternedVar(lang.NewSymbol("count")) -if v107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) +v17 = v21 } -v108 := v107.Get() -v109 := lang.Apply(v108, []any{v71}) -v110 := lang.Apply(v105, []any{v109, int64(1)}) -if lang.IsTruthy(v110) { -v111 := lang.Apply(Exception24., []any{"The syntax for defmulti has changed. Example: (defmulti name dispatch-fn :default dispatch-value)"}) -panic(v111) +v13 = v17 +} +return v13 + case 3: +v8 := args[0] +v9 := args[1] +v10 := args[2] +v12 := lang.Apply(v3, []any{v8}) +var v11 any = v12 +_ = v11 +var v14 any +if lang.IsTruthy(v11) { +v14 = v11 } else { -v102 = nil +v16 := lang.Apply(v3, []any{v9}) +var v15 any = v16 +_ = v15 +var v18 any +if lang.IsTruthy(v15) { +v18 = v15 +} else { +v20 := lang.Apply(v3, []any{v10}) +var v19 any = v20 +_ = v19 +var v22 any +if lang.IsTruthy(v19) { +v22 = v19 +} else { +v24 := lang.Apply(v4, []any{v8}) +var v23 any = v24 +_ = v23 +var v26 any +if lang.IsTruthy(v23) { +v26 = v23 +} else { +v28 := lang.Apply(v4, []any{v9}) +var v27 any = v28 +_ = v27 +var v30 any +if lang.IsTruthy(v27) { +v30 = v27 +} else { +v32 := lang.Apply(v4, []any{v10}) +var v31 any = v32 +_ = v31 +var v34 any +if lang.IsTruthy(v31) { +v34 = v31 +} else { +v36 := lang.Apply(v5, []any{v8}) +var v35 any = v36 +_ = v35 +var v38 any +if lang.IsTruthy(v35) { +v38 = v35 +} else { +v40 := lang.Apply(v5, []any{v9}) +var v39 any = v40 +_ = v39 +var v42 any +if lang.IsTruthy(v39) { +v42 = v39 +} else { +v43 := lang.Apply(v5, []any{v10}) +v42 = v43 +} +v38 = v42 } -_ = v102 -v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v114 := v113.FindInternedVar(lang.NewSymbol("apply")) -if v114.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) +v34 = v38 } -v115 := v114.Get() -v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v117 := v116.FindInternedVar(lang.NewSymbol("hash-map")) -if v117.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) +v30 = v34 } -v118 := v117.Get() -v119 := lang.Apply(v115, []any{v118, v112}) -var v112 any = v119 -_ = v112 -v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v122 := v121.FindInternedVar(lang.NewSymbol("get")) -if v122.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) +v26 = v30 } -v123 := v122.Get() -v124 := lang.Apply(v123, []any{v112, lang.NewKeyword("default"), lang.NewKeyword("default")}) -var v120 any = v124 -_ = v120 -v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v127 := v126.FindInternedVar(lang.NewSymbol("get")) -if v127.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) +v22 = v26 } -v128 := v127.Get() -v129 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("global-hierarchy")) -v130 := lang.Apply(v128, []any{v112, lang.NewKeyword("hierarchy"), v129}) -var v125 any = v130 -_ = v125 -v132 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v133 := v132.FindInternedVar(lang.NewSymbol("check-valid-options")) -if v133.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v133))) +v18 = v22 } -v134 := v133.Get() -v135 := lang.Apply(v134, []any{v112, lang.NewKeyword("default"), lang.NewKeyword("hierarchy")}) -_ = v135 -v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v137 := v136.FindInternedVar(lang.NewSymbol("seq")) -if v137.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) +v14 = v18 } -v138 := v137.Get() -v139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v140 := v139.FindInternedVar(lang.NewSymbol("concat")) -if v140.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v140))) +return v14 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v8 := args[0] +v9 := args[1] +v10 := args[2] +v11 := lang.NewList(args[3:]...) +v13 := lang.Apply(v7, []any{v8, v9, v10}) +var v12 any = v13 +_ = v12 +var v15 any +if lang.IsTruthy(v12) { +v15 = v12 +} else { +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("some")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -v141 := v140.Get() -v142 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v143 := v142.FindInternedVar(lang.NewSymbol("list")) -if v143.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v143))) +v18 := v17.Get() +var v19 lang.FnFunc +v19 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v20 := args[0] +v22 := lang.Apply(v3, []any{v20}) +var v21 any = v22 +_ = v21 +var v24 any +if lang.IsTruthy(v21) { +v24 = v21 +} else { +v26 := lang.Apply(v4, []any{v20}) +var v25 any = v26 +_ = v25 +var v28 any +if lang.IsTruthy(v25) { +v28 = v25 +} else { +v29 := lang.Apply(v5, []any{v20}) +v28 = v29 } -v144 := v143.Get() -v145 := lang.Apply(v144, []any{lang.NewSymbol("glojure.core/let")}) -v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v147 := v146.FindInternedVar(lang.NewSymbol("list")) -if v147.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) +v24 = v28 } -v148 := v147.Get() -v149 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v150 := v149.FindInternedVar(lang.NewSymbol("apply")) -if v150.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v150))) +return v24 +}) +v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7534), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(7534), lang.NewKeyword("end-column"), int(59)) +v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v151 := v150.Get() -v152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v153 := v152.FindInternedVar(lang.NewSymbol("vector")) -if v153.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v153))) +v22 := lang.Apply(v18, []any{v21, v11}) +v15 = v22 } -v154 := v153.Get() -v155 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v156 := v155.FindInternedVar(lang.NewSymbol("seq")) -if v156.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v156))) +return v15 + } +}) +v7 := v6 +_ = v7 } -v157 := v156.Get() -v158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v159 := v158.FindInternedVar(lang.NewSymbol("concat")) -if v159.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v159))) +v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7528), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7534), lang.NewKeyword("end-column"), int(68)) +v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v160 := v159.Get() -v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v162 := v161.FindInternedVar(lang.NewSymbol("list")) -if v162.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) +return v8 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("list*")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v163 := v162.Get() -v164 := lang.Apply(v163, []any{lang.NewSymbol("v__0__auto__")}) -v165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v166 := v165.FindInternedVar(lang.NewSymbol("list")) -if v166.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v166))) +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v3, v4, v5, v7}) +var v7 any = v11 +_ = v7 +var v13 lang.FnFunc +{ // function spn +v13 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +return nil + case 1: +v15 := args[0] +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("some")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -v167 := v166.Get() -v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v169 := v168.FindInternedVar(lang.NewSymbol("seq")) -if v169.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) +v18 := v17.Get() +var v19 lang.FnFunc +v19 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v20 := args[0] +v21 := lang.Apply(v20, []any{v15}) +return v21 +}) +v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7539), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(7539), lang.NewKeyword("end-column"), int(26)) +v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v170 := v169.Get() -v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v172 := v171.FindInternedVar(lang.NewSymbol("concat")) -if v172.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) +v22 := lang.Apply(v18, []any{v21, v7}) +return v22 + case 2: +v15 := args[0] +v16 := args[1] +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("some")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v173 := v172.Get() -v174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v175 := v174.FindInternedVar(lang.NewSymbol("list")) -if v175.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v175))) +v19 := v18.Get() +var v20 lang.FnFunc +v20 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v21 := args[0] +v23 := lang.Apply(v21, []any{v15}) +var v22 any = v23 +_ = v22 +var v25 any +if lang.IsTruthy(v22) { +v25 = v22 +} else { +v26 := lang.Apply(v21, []any{v16}) +v25 = v26 } -v176 := v175.Get() -v177 := lang.Apply(v176, []any{lang.NewSymbol("def")}) -v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v179 := v178.FindInternedVar(lang.NewSymbol("list")) -if v179.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) +return v25 +}) +v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7540), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(7540), lang.NewKeyword("end-column"), int(39)) +v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v180 := v179.Get() -v181 := lang.Apply(v180, []any{v96}) -v182 := lang.Apply(v173, []any{v177, v181}) -v183 := lang.Apply(v170, []any{v182}) -v184 := lang.Apply(v167, []any{v183}) -v185 := lang.Apply(v160, []any{v164, v184}) -v186 := lang.Apply(v157, []any{v185}) -v187 := lang.Apply(v151, []any{v154, v186}) -v188 := lang.Apply(v148, []any{v187}) -v189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v190 := v189.FindInternedVar(lang.NewSymbol("list")) -if v190.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v190))) +v23 := lang.Apply(v19, []any{v22, v7}) +return v23 + case 3: +v15 := args[0] +v16 := args[1] +v17 := args[2] +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("some")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v191 := v190.Get() -v192 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v193 := v192.FindInternedVar(lang.NewSymbol("seq")) -if v193.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v193))) +v20 := v19.Get() +var v21 lang.FnFunc +v21 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v22 := args[0] +v24 := lang.Apply(v22, []any{v15}) +var v23 any = v24 +_ = v23 +var v26 any +if lang.IsTruthy(v23) { +v26 = v23 +} else { +v28 := lang.Apply(v22, []any{v16}) +var v27 any = v28 +_ = v27 +var v30 any +if lang.IsTruthy(v27) { +v30 = v27 +} else { +v31 := lang.Apply(v22, []any{v17}) +v30 = v31 } -v194 := v193.Get() -v195 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v196 := v195.FindInternedVar(lang.NewSymbol("concat")) -if v196.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v196))) +v26 = v30 } -v197 := v196.Get() -v198 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v199 := v198.FindInternedVar(lang.NewSymbol("list")) -if v199.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v199))) +return v26 +}) +v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7541), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7541), lang.NewKeyword("end-column"), int(47)) +v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v200 := v199.Get() -v201 := lang.Apply(v200, []any{lang.NewSymbol("glojure.core/when-not")}) -v202 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v203 := v202.FindInternedVar(lang.NewSymbol("list")) -if v203.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v203))) +v24 := lang.Apply(v20, []any{v23, v7}) +return v24 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v15 := args[0] +v16 := args[1] +v17 := args[2] +v18 := lang.NewList(args[3:]...) +v20 := lang.Apply(v14, []any{v15, v16, v17}) +var v19 any = v20 +_ = v19 +var v22 any +if lang.IsTruthy(v19) { +v22 = v19 +} else { +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("some")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v204 := v203.Get() -v205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v206 := v205.FindInternedVar(lang.NewSymbol("seq")) -if v206.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v206))) +v25 := v24.Get() +var v26 lang.FnFunc +v26 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v27 := args[0] +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("some")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } -v207 := v206.Get() -v208 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v209 := v208.FindInternedVar(lang.NewSymbol("concat")) -if v209.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v209))) +v30 := v29.Get() +v31 := lang.Apply(v30, []any{v27, v18}) +return v31 +}) +v27 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7543), lang.NewKeyword("column"), int(36), lang.NewKeyword("end-line"), int(7543), lang.NewKeyword("end-column"), int(49)) +v28, err := lang.WithMeta(v26, v27.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v210 := v209.Get() -v211 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v212 := v211.FindInternedVar(lang.NewSymbol("list")) -if v212.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v212))) +v29 := lang.Apply(v25, []any{v28, v7}) +v22 = v29 } -v213 := v212.Get() -v214 := lang.Apply(v213, []any{lang.NewSymbol("glojure.core/and")}) -v215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v216 := v215.FindInternedVar(lang.NewSymbol("list")) -if v216.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v216))) +return v22 + } +}) +v14 := v13 +_ = v14 } -v217 := v216.Get() -v218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v219 := v218.FindInternedVar(lang.NewSymbol("seq")) -if v219.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v219))) +v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7537), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7543), lang.NewKeyword("end-column"), int(56)) +v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v220 := v219.Get() -v221 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v222 := v221.FindInternedVar(lang.NewSymbol("concat")) -if v222.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v222))) +return v15 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v223 := v222.Get() -v224 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v225 := v224.FindInternedVar(lang.NewSymbol("list")) -if v225.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v225))) } -v226 := v225.Get() -v227 := lang.Apply(v226, []any{lang.NewSymbol(".HasRoot")}) -v228 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v229 := v228.FindInternedVar(lang.NewSymbol("list")) -if v229.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v229))) +// some? +{ +v1 := reflect.TypeOf(false) +v0 := lang.NewSymbol("some?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is not nil, false otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(530), lang.NewKeyword("end-line"), int(530))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("not")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v230 := v229.Get() -v231 := lang.Apply(v230, []any{lang.NewSymbol("v__0__auto__")}) -v232 := lang.Apply(v223, []any{v227, v231}) -v233 := lang.Apply(v220, []any{v232}) -v234 := lang.Apply(v217, []any{v233}) -v235 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v236 := v235.FindInternedVar(lang.NewSymbol("list")) -if v236.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v236))) +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("nil?")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v237 := v236.Get() -v238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v239 := v238.FindInternedVar(lang.NewSymbol("seq")) -if v239.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v239))) +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v4}) +v12 := lang.Apply(v7, []any{v11}) +return v12 +}) +v4 := reflect.TypeOf(false) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v240 := v239.Get() -v241 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v242 := v241.FindInternedVar(lang.NewSymbol("concat")) -if v242.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v242))) } -v243 := v242.Get() -v244 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v245 := v244.FindInternedVar(lang.NewSymbol("list")) -if v245.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v245))) +// sort +{ +v0 := lang.NewSymbol("sort").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("comp"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a sorted sequence of the items in coll. If no comparator is\n supplied, uses compare. comparator must implement\n java.util.Comparator. Guaranteed to be stable: equal elements will\n not be reordered. If coll is a Java array, it will be modified. To\n avoid this, sort a copy of the array.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3085), lang.NewKeyword("end-line"), int(3085))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("sort")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v246 := v245.Get() -v247 := lang.Apply(v246, []any{lang.NewSymbol("glojure.core/instance?")}) -v248 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v249 := v248.FindInternedVar(lang.NewSymbol("list")) -if v249.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v249))) +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("compare")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v6, []any{v9, v3}) +return v10 + case 2: +v3 := args[0] +v4 := args[1] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("seq")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v250 := v249.Get() -v251 := lang.Apply(v250, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.*MultiFn")}) -v252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v253 := v252.FindInternedVar(lang.NewSymbol("list")) -if v253.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v253))) +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v4}) +if lang.IsTruthy(v9) { +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("to-array")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v254 := v253.Get() -v255 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v256 := v255.FindInternedVar(lang.NewSymbol("seq")) -if v256.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v256))) +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v4}) +var v10 any = v14 +_ = v10 +v16 := lang.Apply(lang1.SortSlice, []any{v10, v3}) +_ = v16 +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("with-meta")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v257 := v256.Get() -v258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v259 := v258.FindInternedVar(lang.NewSymbol("concat")) -if v259.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v259))) +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("seq")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v260 := v259.Get() -v261 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v262 := v261.FindInternedVar(lang.NewSymbol("list")) -if v262.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v262))) +v22 := v21.Get() +v23 := lang.Apply(v22, []any{v10}) +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("meta")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -v263 := v262.Get() -v264 := lang.Apply(v263, []any{lang.NewSymbol("glojure.core/deref")}) -v265 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v266 := v265.FindInternedVar(lang.NewSymbol("list")) -if v266.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v266))) +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v4}) +v28 := lang.Apply(v19, []any{v23, v27}) +v5 = v28 +} else { +v5 = lang.NewList() } -v267 := v266.Get() -v268 := lang.Apply(v267, []any{lang.NewSymbol("v__0__auto__")}) -v269 := lang.Apply(v260, []any{v264, v268}) -v270 := lang.Apply(v257, []any{v269}) -v271 := lang.Apply(v254, []any{v270}) -v272 := lang.Apply(v243, []any{v247, v251, v271}) -v273 := lang.Apply(v240, []any{v272}) -v274 := lang.Apply(v237, []any{v273}) -v275 := lang.Apply(v210, []any{v214, v234, v274}) -v276 := lang.Apply(v207, []any{v275}) -v277 := lang.Apply(v204, []any{v276}) -v278 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v279 := v278.FindInternedVar(lang.NewSymbol("list")) -if v279.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v279))) +return v5 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v280 := v279.Get() -v281 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v282 := v281.FindInternedVar(lang.NewSymbol("seq")) -if v282.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v282))) } -v283 := v282.Get() -v284 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v285 := v284.FindInternedVar(lang.NewSymbol("concat")) -if v285.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v285))) +// sort-by +{ +v0 := lang.NewSymbol("sort-by").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("keyfn"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("keyfn"), lang.NewSymbol("comp"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a sorted sequence of the items in coll, where the sort\n order is determined by comparing (keyfn item). If no comparator is\n supplied, uses compare. comparator must implement\n java.util.Comparator. Guaranteed to be stable: equal elements will\n not be reordered. If coll is a Java array, it will be modified. To\n avoid this, sort a copy of the array.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3102), lang.NewKeyword("end-line"), int(3102))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("sort-by")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v286 := v285.Get() -v287 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v288 := v287.FindInternedVar(lang.NewSymbol("list")) -if v288.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v288))) +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("compare")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v289 := v288.Get() -v290 := lang.Apply(v289, []any{lang.NewSymbol("def")}) -v291 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v292 := v291.FindInternedVar(lang.NewSymbol("list")) -if v292.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v292))) +v10 := v9.Get() +v11 := lang.Apply(v7, []any{v3, v10, v4}) +return v11 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("sort")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v293 := v292.Get() -v294 := lang.Apply(v293, []any{v96}) -v295 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v296 := v295.FindInternedVar(lang.NewSymbol("list")) -if v296.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v296))) +v8 := v7.Get() +var v9 lang.FnFunc +v9 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v10 := args[0] +v11 := args[1] +v12 := lang.Apply(v3, []any{v10}) +v13 := lang.Apply(v3, []any{v11}) +v14 := lang.Apply(v4, []any{v12, v13}) +return v14 +}) +v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3114), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(3114), lang.NewKeyword("end-column"), int(46)) +v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v297 := v296.Get() -v298 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v299 := v298.FindInternedVar(lang.NewSymbol("seq")) -if v299.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v299))) +v12 := lang.Apply(v8, []any{v11, v5}) +return v12 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v300 := v299.Get() -v301 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v302 := v301.FindInternedVar(lang.NewSymbol("concat")) -if v302.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v302))) } -v303 := v302.Get() -v304 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v305 := v304.FindInternedVar(lang.NewSymbol("list")) -if v305.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v305))) +// sorted-map +{ +v0 := lang.NewSymbol("sorted-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keyvals"))), lang.NewKeyword("doc"), "keyval => key val\n Returns a new sorted map with supplied mappings. If any keys are\n equal, they are handled as if by repeated uses of assoc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(397), lang.NewKeyword("end-line"), int(397))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.NewList(args[0:]...) +v4 := lang.Apply(lang1.CreatePersistentTreeMap, []any{v3}) +return v4 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v306 := v305.Get() -v307 := lang.Apply(v306, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewMultiFn")}) -v308 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v309 := v308.FindInternedVar(lang.NewSymbol("list")) -if v309.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v309))) } -v310 := v309.Get() -v311 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v312 := v311.FindInternedVar(lang.NewSymbol("name")) -if v312.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v312))) +// sorted-map-by +{ +v0 := lang.NewSymbol("sorted-map-by").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("comparator"), lang.NewSymbol("&"), lang.NewSymbol("keyvals"))), lang.NewKeyword("doc"), "keyval => key val\n Returns a new sorted map with supplied mappings, using the supplied\n comparator. If any keys are equal, they are handled as if by\n repeated uses of assoc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(406), lang.NewKeyword("end-line"), int(406))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.NewList(args[1:]...) +v5 := lang.Apply(nil, []any{v3, v4}) +return v5 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v313 := v312.Get() -v314 := lang.Apply(v313, []any{v96}) -v315 := lang.Apply(v310, []any{v314}) -v316 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v317 := v316.FindInternedVar(lang.NewSymbol("list")) -if v317.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v317))) } -v318 := v317.Get() -v319 := lang.Apply(v318, []any{v66}) -v320 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v321 := v320.FindInternedVar(lang.NewSymbol("list")) -if v321.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v321))) +// sorted-set +{ +v0 := lang.NewSymbol("sorted-set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keys"))), lang.NewKeyword("doc"), "Returns a new sorted set with supplied keys. Any equal keys are\n handled as if by repeated uses of conj.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(416), lang.NewKeyword("end-line"), int(416))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.NewList(args[0:]...) +v4 := lang.Apply(lang1.CreatePersistentTreeSet, []any{v3}) +return v4 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v322 := v321.Get() -v323 := lang.Apply(v322, []any{v120}) -v324 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v325 := v324.FindInternedVar(lang.NewSymbol("list")) -if v325.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v325))) } -v326 := v325.Get() -v327 := lang.Apply(v326, []any{v125}) -v328 := lang.Apply(v303, []any{v307, v315, v319, v323, v327}) -v329 := lang.Apply(v300, []any{v328}) -v330 := lang.Apply(v297, []any{v329}) -v331 := lang.Apply(v286, []any{v290, v294, v330}) -v332 := lang.Apply(v283, []any{v331}) -v333 := lang.Apply(v280, []any{v332}) -v334 := lang.Apply(v197, []any{v201, v277, v333}) -v335 := lang.Apply(v194, []any{v334}) -v336 := lang.Apply(v191, []any{v335}) -v337 := lang.Apply(v141, []any{v145, v188, v336}) -v338 := lang.Apply(v138, []any{v337}) -return v338 +// sorted-set-by +{ +v0 := lang.NewSymbol("sorted-set-by").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("comparator"), lang.NewSymbol("&"), lang.NewSymbol("keys"))), lang.NewKeyword("doc"), "Returns a new sorted set with supplied keys, using the supplied\n comparator. Any equal keys are handled as if by repeated uses of\n conj.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(424), lang.NewKeyword("end-line"), int(424))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.NewList(args[1:]...) +v5 := lang.Apply(lang1.CreatePersistentTreeSetWithComparator, []any{v3, v4}) +return v5 } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -70551,53 +71115,152 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// preserving-reduced +// sorted? { -v0 := lang.NewSymbol("preserving-reduced").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7681), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(7681), lang.NewKeyword("end-column"), int(34), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rf"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v0 := lang.NewSymbol("sorted?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements Sorted", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6278), lang.NewKeyword("end-line"), int(6278))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{glojure.lang8.Sorted, v3}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// special-symbol? +{ +v0 := lang.NewSymbol("special-symbol?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns true if s names a special form", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4992), lang.NewKeyword("end-line"), int(4992))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v5 := args[0] -v6 := args[1] -v8 := lang.Apply(v3, []any{v5, v6}) -var v7 any = v8 -_ = v7 -var v10 any -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("reduced?")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("contains?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v7}) -if lang.IsTruthy(v14) { +v6 := v5.Get() +v7, ok := lang.FieldOrMethod(runtime9.Compiler, "specials") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", runtime9.Compiler, "specials"))) +} +var v8 any +switch reflect.TypeOf(v7).Kind() { +case reflect.Func: + v8 = lang.Apply(v7, nil) +default: + v8 = v7 +} +v9 := lang.Apply(v6, []any{v8, v3}) +return v9 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// spit +{ +v0 := lang.NewSymbol("spit").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("content"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Opposite of slurp. Opens f with writer, writes content, then\n closes f. Options passed to glojure.java.io/writer.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7037), lang.NewKeyword("end-line"), int(7037))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("apply")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.Apply(v9, []any{nil, v3, v5}) +var v6 any = v10 +_ = v6 +var v12 any +func() { +defer func() { +v13, ok := lang.FieldOrMethod(v6, "close") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "close"))) +} +var v14 any +switch reflect.TypeOf(v13).Kind() { +case reflect.Func: + v14 = lang.Apply(v13, nil) +default: + v14 = v13 +} +}() v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("reduced")) +v16 := v15.FindInternedVar(lang.NewSymbol("str")) if v16.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } v17 := v16.Get() -v18 := lang.Apply(v17, []any{v7}) -v10 = v18 -} else { -v10 = v7 -} -return v10 +v18 := lang.Apply(v17, []any{v4}) +v19 := lang.Apply(lang1.WriteWriter, []any{v6, v18}) +v12 = v19 +}() +return v12 + } }) -v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7683), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(7686), lang.NewKeyword("end-column"), int(12)) -v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// split-at +{ +v0 := lang.NewSymbol("split-at").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a vector of [(take n coll) (drop n coll)]", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2983), lang.NewKeyword("end-line"), int(2983))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("take")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3, v4}) +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("drop")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v3, v4}) +v13 := lang.NewVector(v8, v12) +v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2988), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2988), lang.NewKeyword("end-column"), int(33)) +v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) if err != nil { panic(err) } -return v6 +return v15 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -70605,34 +71268,37 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// ns-map +// split-with { -v0 := lang.NewSymbol("ns-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of all the mappings for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4170), lang.NewKeyword("end-line"), int(4170))).(*lang.Symbol) +v0 := lang.NewSymbol("split-with").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a vector of [(take-while pred coll) (drop-while pred coll)]", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2990), lang.NewKeyword("end-line"), int(2990))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { + if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("the-ns")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("take-while")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v6 := v5.Get() -v7 := lang.Apply(v6, []any{v3}) -v8, ok := lang.FieldOrMethod(v7, "Mappings") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "Mappings"))) +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3, v4}) +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("drop-while")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -var v9 any -switch reflect.TypeOf(v8).Kind() { -case reflect.Func: - v9 = lang.Apply(v8, nil) -default: - v9 = v8 +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v3, v4}) +v13 := lang.NewVector(v8, v12) +v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2995), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2995), lang.NewKeyword("end-column"), int(51)) +v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) +if err != nil { + panic(err) } -return v9 +return v15 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -70640,85 +71306,55 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// compare +// splitv-at { -var v1 lang.FnFunc -{ // function compare__inliner -v1 = lang.NewFnFunc(func(args ...any) any { +v0 := lang.NewSymbol("splitv-at").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a vector of [(into [] (take n) coll) (drop n coll)]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7299), lang.NewKeyword("end-line"), int(7299))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] v4 := args[1] v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +v6 := v5.FindInternedVar(lang.NewSymbol("into")) if v6.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("concat")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v8 := lang.NewVector() +v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7303), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(7303), lang.NewKeyword("end-column"), int(11)) +v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v10 := v9.Get() v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("list")) +v12 := v11.FindInternedVar(lang.NewSymbol("take")) if v12.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } v13 := v12.Get() -v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol("glojure.lang.Util")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{lang.NewSymbol("glojure.core/compare")}) -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{v3}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v14 := lang.Apply(v13, []any{v3}) +v15 := lang.Apply(v7, []any{v10, v14, v4}) +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("drop")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -v29 := v28.Get() -v30 := lang.Apply(v29, []any{v4}) -v31 := lang.Apply(v10, []any{v14, v18, v22, v26, v30}) -v32 := lang.Apply(v7, []any{v31}) -return v32 -}) -v2 := v1 -_ = v2 +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v3, v4}) +v20 := lang.NewVector(v15, v19) +v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7303), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(7303), lang.NewKeyword("end-column"), int(41)) +v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v0 := lang.NewSymbol("compare").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Comparator. Returns a negative number, zero, or a positive number\n when x is logically 'less than', 'equal to', or 'greater than'\n y. Same as Java x.compareTo(y) except it also works for nil, and\n compares numbers and collections in a type-independent manner. x\n must implement Comparable", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(824), lang.NewKeyword("end-line"), int(824))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6 := lang.Apply(lang1.Compare, []any{v4, v5}) -return v6 +return v22 }) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } // spread @@ -70819,453 +71455,271 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// future-done? +// str { -v0 := lang.NewSymbol("future-done?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Returns true if future f is done", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6581), lang.NewKeyword("end-line"), int(6581))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, ok := lang.FieldOrMethod(v3, "isDone") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "isDone"))) -} +v1 := reflect.TypeOf("") +v0 := lang.NewSymbol("str").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("ys"))), lang.NewKeyword("doc"), "With no args, returns the empty string. With one arg x, returns\n x.toString(). (str nil) returns the empty string. With more than\n one arg, returns the concatenation of the str values of the args.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(543), lang.NewKeyword("end-line"), int(543))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +return "" + case 1: +v4 := args[0] var v5 any -switch reflect.TypeOf(v4).Kind() { -case reflect.Func: - v5 = lang.Apply(v4, nil) -default: - v5 = v4 -} -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// inst-ms -{ -v0 := lang.NewSymbol("inst-ms").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("inst"))), lang.NewKeyword("doc"), "Return the number of milliseconds since January 1, 1970, 00:00:00 GMT", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6874), lang.NewKeyword("end-line"), int(6874))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.Apply(nil, []any{v3}) -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("nil?")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v4}) +if lang.IsTruthy(v9) { +v5 = "" +} else { +v10 := lang.Apply(lang1.ToString, []any{v4}) +v5 = v10 } -// add-annotation -{ -v0 := lang.NewSymbol("add-annotation").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5485), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(5485), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("av"), lang.NewSymbol("name"), lang.NewSymbol("v"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { +return v5 + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := lang.NewList(args[1:]...) +var v6 lang.FnFunc +v6 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := args[0] -v4 := args[1] -v5 := args[2] -var v6 any -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("vector?")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v7 := args[0] +v8 := args[1] +recur_loop_74: +var v9 any +if lang.IsTruthy(v8) { +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("str")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v5}) -if lang.IsTruthy(v10) { -v12, _ := lang.FieldOrMethod(v3, "visitArray") -if reflect.TypeOf(v12).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("visitArray is not a function"))) +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("first")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v13 := lang.Apply(v12, []any{v4}) -var v11 any = v13 -_ = v11 -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("seq")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v8}) +v18 := lang.Apply(v13, []any{v17}) +v19, _ := lang.FieldOrMethod(v7, "WriteString") +if reflect.TypeOf(v19).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("WriteString is not a function"))) } -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v5}) -var v15 any = v19 -_ = v15 -var v20 any = nil +v20 := lang.Apply(v19, []any{v18}) _ = v20 -var v21 any = int64(0) -_ = v21 -var v22 any = int64(0) -_ = v22 -var v23 any -for { -var v24 any -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("<")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.Apply(v27, []any{v22, v21}) -if lang.IsTruthy(v28) { -v30, _ := lang.FieldOrMethod(v20, "nth") -if reflect.TypeOf(v30).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) -} -v31 := lang.Apply(v30, []any{v22}) -var v29 any = v31 -_ = v29 -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("add-annotation")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v11, "value", v29}) -_ = v36 -var v37 any = v15 -var v38 any = v20 -var v39 any = v21 -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("unchecked-inc")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v22}) -var v40 any = v44 -v15 = v37 -v20 = v38 -v21 = v39 -v22 = v40 -continue -} else { -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("seq")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.Apply(v32, []any{v15}) -var v29 any = v33 -_ = v29 -var v35 any -if lang.IsTruthy(v29) { -var v36 any = v29 -_ = v36 -var v38 any -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("chunked-seq?")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) -} -v41 := v40.Get() -v42 := lang.Apply(v41, []any{v36}) -if lang.IsTruthy(v42) { -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("chunk-first")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v36}) -var v43 any = v47 -_ = v43 -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("chunk-rest")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.Apply(v52, []any{v36}) -var v49 any = v53 -var v54 any = v43 -v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v57 := v56.FindInternedVar(lang.NewSymbol("int")) -if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) -} -v58 := v57.Get() -v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v60 := v59.FindInternedVar(lang.NewSymbol("count")) -if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) -} -v61 := v60.Get() -v62 := lang.Apply(v61, []any{v43}) -v63 := lang.Apply(v58, []any{v62}) -var v55 any = v63 -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("int")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) -} -v67 := v66.Get() -v68 := lang.Apply(v67, []any{int64(0)}) -var v64 any = v68 -v15 = v49 -v20 = v54 -v21 = v55 -v22 = v64 -continue -} else { -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("first")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v36}) -var v43 any = v47 -_ = v43 -v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v50 := v49.FindInternedVar(lang.NewSymbol("add-annotation")) -if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) -} -v51 := v50.Get() -v52 := lang.Apply(v51, []any{v11, "value", v43}) -_ = v52 -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("next")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) -} -v56 := v55.Get() -v57 := lang.Apply(v56, []any{v36}) -var v53 any = v57 -var v58 any = nil -var v59 any = int64(0) -var v60 any = int64(0) -v15 = v53 -v20 = v58 -v21 = v59 -v22 = v60 -continue +var v10 any = v7 +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("next")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -v35 = v38 +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v8}) +var v21 any = v25 +v7 = v10 +v8 = v21 +goto recur_loop_74 } else { -v35 = nil -} -v24 = v35 -} -v23 = v24 - break -} -_ = v23 -v15, ok := lang.FieldOrMethod(v11, "visitEnd") +v26, ok := lang.FieldOrMethod(v7, "String") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v11, "visitEnd"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "String"))) } -var v16 any -switch reflect.TypeOf(v15).Kind() { +var v27 any +switch reflect.TypeOf(v26).Kind() { case reflect.Func: - v16 = lang.Apply(v15, nil) + v27 = lang.Apply(v26, nil) default: - v16 = v15 -} -v6 = v16 -} else { -var v11 any -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("symbol?")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v5}) -if lang.IsTruthy(v15) { -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("eval")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v5}) -var v16 any = v20 -_ = v16 -var v22 any -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("instance?")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{java.lang32.Enum, v16}) -if lang.IsTruthy(v26) { -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("descriptor")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("class")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + v27 = v26 } -v32 := v31.Get() -v33 := lang.Apply(v32, []any{v16}) -v34 := lang.Apply(v29, []any{v33}) -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("str")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +v9 = v27 } -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v16}) -v39, _ := lang.FieldOrMethod(v3, "visitEnum") -if reflect.TypeOf(v39).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("visitEnum is not a function"))) +return v9 +}) +v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(554), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(554), lang.NewKeyword("end-column"), int(127)) +v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v40 := lang.Apply(v39, []any{v4, v34, v38}) -v22 = v40 -} else { -var v41 any -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("class?")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("cons")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -v44 := v43.Get() -v45 := lang.Apply(v44, []any{v16}) -if lang.IsTruthy(v45) { -v46 := lang.Apply(nil, []any{v16}) -v47, _ := lang.FieldOrMethod(v3, "visit") -if reflect.TypeOf(v47).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("visit is not a function"))) +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v4, v5}) +v13 := lang.Apply(v8, []any{"unimplemented: new with non-constant class type", v12}) +return v13 + } +}) +v4 := reflect.TypeOf("") +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v48 := lang.Apply(v47, []any{v4, v46}) -v41 = v48 -} else { -var v49 any -if lang.IsTruthy(lang.NewKeyword("else")) { -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("str")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) } -v52 := v51.Get() -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("class")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +// stream-into! +{ +v0 := lang.NewSymbol("stream-into!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("stream")), lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("xform"), lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Returns a new coll consisting of coll with all of the items of the\n stream conjoined. This is a terminal operation on the stream.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6853), lang.NewKeyword("end-line"), int(6853))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v3 := args[0] +v4 := args[1] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v55 := v54.Get() -v56 := lang.Apply(v55, []any{v16}) -v57 := lang.Apply(v52, []any{"Unsupported annotation value: ", v5, " of class ", v56}) -v58 := lang.Apply(lang1.NewIllegalArgumentError, []any{v57}) -panic(v58) -} else { -v49 = nil +v8 := v7.Get() +v9 := lang.Apply(v8, []any{lang1.IEditableCollection, v3}) +if lang.IsTruthy(v9) { +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("with-meta")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v41 = v49 +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("persistent!")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } -v22 = v41 +v15 := v14.Get() +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("stream-reduce!")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -v11 = v22 -} else { -var v16 any -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq?")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +v18 := v17.Get() +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("conj!")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v5}) -if lang.IsTruthy(v20) { -var v21 any = v5 -_ = v21 -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("nth")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("transient")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -v25 := v24.Get() -v26 := lang.Apply(v25, []any{v21, int64(0), nil}) -var v22 any = v26 -_ = v22 +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v3}) +v26 := lang.Apply(v18, []any{v21, v25, v4}) +v27 := lang.Apply(v15, []any{v26}) v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("nth")) +v29 := v28.FindInternedVar(lang.NewSymbol("meta")) if v29.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } v30 := v29.Get() -v31 := lang.Apply(v30, []any{v21, int64(1), nil}) -var v27 any = v31 -_ = v27 +v31 := lang.Apply(v30, []any{v3}) +v32 := lang.Apply(v12, []any{v27, v31}) +v5 = v32 +} else { v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("resolve")) +v34 := v33.FindInternedVar(lang.NewSymbol("stream-reduce!")) if v34.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) } v35 := v34.Get() -v36 := lang.Apply(v35, []any{v22}) -var v32 any = v36 -_ = v32 -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("descriptor")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("conj")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) } -v40 := v39.Get() -v41 := lang.Apply(v40, []any{v32}) -v42, _ := lang.FieldOrMethod(v3, "visitAnnotation") -if reflect.TypeOf(v42).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("visitAnnotation is not a function"))) +v38 := v37.Get() +v39 := lang.Apply(v35, []any{v38, v3, v4}) +v5 = v39 } -v43 := lang.Apply(v42, []any{v4, v41}) -var v37 any = v43 -_ = v37 -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("process-annotation")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +return v5 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +var v6 any +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("instance?")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v47 := v46.Get() -v48 := lang.Apply(v47, []any{v37, v27}) -_ = v48 -v49, ok := lang.FieldOrMethod(v37, "visitEnd") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v37, "visitEnd"))) +v9 := v8.Get() +v10 := lang.Apply(v9, []any{lang1.IEditableCollection, v3}) +if lang.IsTruthy(v10) { +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("with-meta")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -var v50 any -switch reflect.TypeOf(v49).Kind() { -case reflect.Func: - v50 = lang.Apply(v49, nil) -default: - v50 = v49 +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("persistent!")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v16 = v50 -} else { -var v21 any -if lang.IsTruthy(lang.NewKeyword("else")) { -v22, _ := lang.FieldOrMethod(v3, "visit") -if reflect.TypeOf(v22).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("visit is not a function"))) +v16 := v15.Get() +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("stream-transduce!")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v23 := lang.Apply(v22, []any{v4, v5}) -v21 = v23 -} else { -v21 = nil +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("conj!")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v16 = v21 +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("transient")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v11 = v16 +v25 := v24.Get() +v26 := lang.Apply(v25, []any{v3}) +v27 := lang.Apply(v19, []any{v4, v22, v26, v5}) +v28 := lang.Apply(v16, []any{v27}) +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("meta")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) } -v6 = v11 +v31 := v30.Get() +v32 := lang.Apply(v31, []any{v3}) +v33 := lang.Apply(v13, []any{v28, v32}) +v6 = v33 +} else { +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("stream-transduce!")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("conj")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.Apply(v36, []any{v4, v39, v3, v5}) +v6 = v40 } return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -71273,22 +71727,48 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// accessor +// stream-reduce! { -v0 := lang.NewSymbol("accessor").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("key"))), lang.NewKeyword("doc"), "Returns a fn that, given an instance of a structmap with the basis,\n returns the value at the key. The key must be in the basis. The\n returned function should be (slightly) more efficient than using\n get, but such use of accessors should be limited to known\n performance-critical areas.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4070), lang.NewKeyword("end-line"), int(4070))).(*lang.Symbol) +v0 := lang.NewSymbol("stream-reduce!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("s")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Works like reduce but takes a java.util.stream.BaseStream as its source.\n Honors 'reduced', is a terminal operation on the stream", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6827), lang.NewKeyword("end-line"), int(6827))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + switch len(args) { + case 2: v3 := args[0] v4 := args[1] -v5, _ := lang.FieldOrMethod(glojure.lang11.PersistentStructMap, "getAccessor") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("getAccessor is not a function"))) +v5, ok := lang.FieldOrMethod(v4, "iterator") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "iterator"))) } -v6 := lang.Apply(v5, []any{v3, v4}) -return v6 +var v6 any +switch reflect.TypeOf(v5).Kind() { +case reflect.Func: + v6 = lang.Apply(v5, nil) +default: + v6 = v5 +} +v7 := lang.Apply(nil, []any{v6, v3}) +return v7 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6, ok := lang.FieldOrMethod(v5, "iterator") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "iterator"))) +} +var v7 any +switch reflect.TypeOf(v6).Kind() { +case reflect.Func: + v7 = lang.Apply(v6, nil) +default: + v7 = v6 +} +v8 := lang.Apply(nil, []any{v7, v3, v4}) +return v8 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -71296,40 +71776,34 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// agent-errors +// stream-seq! { -v0 := lang.NewSymbol("agent-errors").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("doc"), "DEPRECATED: Use 'agent-error' instead.\n Returns a sequence of the exceptions thrown during asynchronous\n actions of the agent.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("deprecated"), "1.2", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2234), lang.NewKeyword("end-line"), int(2234))).(*lang.Symbol) +v0 := lang.NewSymbol("stream-seq!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Takes a java.util.stream.BaseStream instance s and returns a seq of its\n contents. This is a terminal operation on the stream.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6836), lang.NewKeyword("end-line"), int(6836))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("agent-error")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("iterator-seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -var v4 any = v8 -_ = v4 -var v10 any -if lang.IsTruthy(v4) { -var v11 any = v4 -_ = v11 -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("list")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +v6 := v5.Get() +v7, ok := lang.FieldOrMethod(v3, "iterator") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "iterator"))) } -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v11}) -v10 = v16 -} else { -v10 = nil +var v8 any +switch reflect.TypeOf(v7).Kind() { +case reflect.Func: + v8 = lang.Apply(v7, nil) +default: + v8 = v7 } -return v10 +v9 := lang.Apply(v6, []any{v8}) +return v9 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -71337,287 +71811,133 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// emit-hinted-impl +// stream-transduce! { -v0 := lang.NewSymbol("emit-hinted-impl").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(163), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(163), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"), lang.NewVector(lang.NewSymbol("p"), lang.NewSymbol("fs")))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v0 := lang.NewSymbol("stream-transduce!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("f"), lang.NewSymbol("stream")), lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Works like transduce but takes a java.util.stream.BaseStream as its source.\n This is a terminal operation on the stream.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6843), lang.NewKeyword("end-line"), int(6843))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + switch len(args) { + case 3: v3 := args[0] v4 := args[1] -var v5 any = v4 -_ = v5 -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("nth")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v5, int64(0), nil}) -var v6 any = v10 -_ = v6 -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("nth")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v5, int64(1), nil}) -var v11 any = v15 -_ = v11 -var v18 lang.FnFunc -v18 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v19 := args[0] -var v21 any -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("vector?")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("first")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.Apply(v27, []any{v20}) -v29 := lang.Apply(v24, []any{v28}) -if lang.IsTruthy(v29) { -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("list")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.Apply(v32, []any{v20}) -v21 = v33 -} else { -v21 = v20 +v5 := args[2] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("stream-transduce!")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -var v20 any = v21 -_ = v20 -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("map")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +v8 := v7.Get() +v9 := lang.Apply(v4, nil) +v10 := lang.Apply(v8, []any{v3, v4, v9, v5}) +return v10 + case 4: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v8 := lang.Apply(v3, []any{v7}) +var v7 any = v8 +_ = v7 +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("stream-reduce!")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v37 := v36.Get() -var v38 lang.FnFunc -v38 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { +v12 := v11.Get() +v13 := lang.Apply(v12, []any{v7, v5, v6}) +var v9 any = v13 +_ = v9 +v15 := lang.Apply(v7, []any{v9}) +return v15 + default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v39 := args[0] -var v40 any = v39 -_ = v40 -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("seq")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) -} -v44 := v43.Get() -v45 := lang.Apply(v44, []any{v40}) -var v41 any = v45 -_ = v41 -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("first")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) -} -v49 := v48.Get() -v50 := lang.Apply(v49, []any{v41}) -var v46 any = v50 -_ = v46 -v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("next")) -if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) -} -v54 := v53.Get() -v55 := lang.Apply(v54, []any{v51}) -var v51 any = v55 -_ = v51 -var v56 any = v46 -_ = v56 -v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v59 := v58.FindInternedVar(lang.NewSymbol("seq")) -if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) -} -v60 := v59.Get() -v61 := lang.Apply(v60, []any{v56}) -var v57 any = v61 -_ = v57 -v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v64 := v63.FindInternedVar(lang.NewSymbol("first")) -if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) -} -v65 := v64.Get() -v66 := lang.Apply(v65, []any{v57}) -var v62 any = v66 -_ = v62 -v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v69 := v68.FindInternedVar(lang.NewSymbol("next")) -if v69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) -} -v70 := v69.Get() -v71 := lang.Apply(v70, []any{v67}) -var v67 any = v71 -_ = v67 -var v72 any = v62 -_ = v72 -var v73 any = v67 -_ = v73 -var v74 any = v51 -_ = v74 -v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v77 := v76.FindInternedVar(lang.NewSymbol("cons")) -if v77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) -} -v78 := v77.Get() -v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v80 := v79.FindInternedVar(lang.NewSymbol("apply")) -if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) -} -v81 := v80.Get() -v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v83 := v82.FindInternedVar(lang.NewSymbol("vector")) -if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) -} -v84 := v83.Get() -v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v86 := v85.FindInternedVar(lang.NewSymbol("vary-meta")) -if v86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) -} -v87 := v86.Get() -v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v89 := v88.FindInternedVar(lang.NewSymbol("assoc")) -if v89.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) -} -v90 := v89.Get() -v91 := lang.Apply(v87, []any{v72, v90, lang.NewKeyword("tag"), v3}) -v92 := lang.Apply(v81, []any{v84, v91, v73}) -v93 := lang.Apply(v78, []any{v92, v74}) -return v93 -}) -v39 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(168), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(170), lang.NewKeyword("end-column"), int(36)) -v40, err := lang.WithMeta(v38, v39.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v41 := lang.Apply(v37, []any{v40, v20}) -return v41 }) -v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(164), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(171), lang.NewKeyword("end-column"), int(30)) -v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v17 any = v20 -_ = v17 -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("zipmap")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("map")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -v27 := v26.Get() -var v28 lang.FnFunc -v28 = lang.NewFnFunc(func(args ...any) any { +// string? +{ +v0 := lang.NewSymbol("string?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a String", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(160), lang.NewKeyword("end-line"), int(164))).(*lang.Symbol) +var v2 lang.FnFunc +{ // function string? +v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v29 := args[0] -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("keyword")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("name")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("first")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +v4 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v29}) -v40 := lang.Apply(v35, []any{v39}) -v41 := lang.Apply(v32, []any{v40}) -return v41 +v7 := v6.Get() +v8 := lang.Apply(v7, []any{lang.Builtins["string"], v4}) +return v8 }) -v29 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(172), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(172), lang.NewKeyword("end-column"), int(46)) -v30, err := lang.WithMeta(v28, v29.(lang.IPersistentMap)) -if err != nil { - panic(err) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(164), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(164), lang.NewKeyword("end-column"), int(58))).(lang.FnFunc) +v3 := v2 +_ = v3 } -v31 := lang.Apply(v27, []any{v30, v11}) -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("map")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v34 := v33.Get() -var v35 lang.FnFunc -v35 = lang.NewFnFunc(func(args ...any) any { +} +// strip-ns +{ +v0 := lang.NewSymbol("strip-ns").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(255), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(255), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("named"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v36 := args[0] -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("cons")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +v3 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("symbol?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("drop")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +if lang.IsTruthy(v8) { +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("symbol")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -v42 := v41.Get() -v43 := lang.Apply(v42, []any{int64(1), v36}) -v44 := lang.Apply(v17, []any{v43}) -v45 := lang.Apply(v39, []any{lang.NewSymbol("glojure.core/fn"), v44}) -return v45 -}) -v36 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(173), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(173), lang.NewKeyword("end-column"), int(49)) -v37, err := lang.WithMeta(v35, v36.(lang.IPersistentMap)) -if err != nil { - panic(err) +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("name")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } -v38 := lang.Apply(v34, []any{v37, v11}) -v39 := lang.Apply(v24, []any{v31, v38}) -v40 := lang.NewVector(v6, v39) -v41 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(172), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(173), lang.NewKeyword("end-column"), int(55)) -v42, err := lang.WithMeta(v40, v41.(lang.IPersistentMap)) -if err != nil { - panic(err) +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v3}) +v16 := lang.Apply(v11, []any{nil, v15}) +v4 = v16 +} else { +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("keyword")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -return v42 +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("name")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.Apply(v22, []any{v3}) +v24 := lang.Apply(v19, []any{nil, v23}) +v4 = v24 +} +return v4 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -71625,34 +71945,20 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// rand +// struct { -v0 := lang.NewSymbol("rand").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns a random floating point number between 0 (inclusive) and\n n (default 1) (exclusive).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4935), lang.NewKeyword("end-line"), int(4935))).(*lang.Symbol) +v0 := lang.NewSymbol("struct").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("&"), lang.NewSymbol("vals"))), lang.NewKeyword("doc"), "Returns a new structmap instance with the keys of the\n structure-basis. vals must be supplied for basis keys in order -\n where values are not supplied they will default to nil.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4061), lang.NewKeyword("end-line"), int(4061))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 0: -v3 := lang.Apply(rand33.Float64, nil) -return v3 - case 1: -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("*")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("rand")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, nil) -v11 := lang.Apply(v6, []any{v3, v10}) -return v11 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.NewList(args[1:]...) +v5 := lang.Apply(lang1.ConstructPersistentStructMap, []any{v3, v4}) +return v5 } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -71661,32 +71967,21 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// shift-mask +// struct-map { -v0 := lang.NewSymbol("shift-mask").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6641), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(6641), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("shift"), lang.NewSymbol("mask"), lang.NewSymbol("x"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v0 := lang.NewSymbol("struct-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("&"), lang.NewSymbol("inits"))), lang.NewKeyword("doc"), "Returns a new structmap instance with the keys of the\n structure-basis. keyvals may contain all, some or none of the basis\n keys - where values are not supplied they will default to nil.\n keyvals can also contain keys not in the basis.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4051), lang.NewKeyword("end-line"), int(4051))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("bit-and")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("bit-shift-right")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v5, v3}) -v13 := lang.Apply(v8, []any{v12, v4}) -return v13 +v4 := lang.NewList(args[1:]...) +v5 := lang.Apply(lang1.CreatePersistentStructMap, []any{v3, v4}) +return v5 + } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -71694,17 +71989,26 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// integer? +// subs { -v0 := lang.NewSymbol("integer?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is an integer", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1379), lang.NewKeyword("end-line"), int(1379))).(*lang.Symbol) +v0 := lang.NewSymbol("subs").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("start")), lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("start"), lang.NewSymbol("end"))), lang.NewKeyword("doc"), "Returns the substring of s beginning at start inclusive, and ending\n at end (defaults to length of string), exclusive.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5005), lang.NewKeyword("end-line"), int(5005))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { + switch len(args) { + case 2: +v3 := args[0] +v4 := args[1] +v5 := lang.Apply(lang.Builtins["slice"], []any{v3, v4}) +return v5 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.Apply(lang.Builtins["slice"], []any{v3, v4, v5}) +return v6 + default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := args[0] -v4 := lang.Apply(lang1.IsInteger, []any{v3}) -return v4 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -71712,239 +72016,321 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// maybe-destructured +// subseq { -v0 := lang.NewSymbol("maybe-destructured").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4514), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(4515), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("params"), lang.NewSymbol("body"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v0 := lang.NewSymbol("subseq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sc"), lang.NewSymbol("test"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("sc"), lang.NewSymbol("start-test"), lang.NewSymbol("start-key"), lang.NewSymbol("end-test"), lang.NewSymbol("end-key"))), lang.NewKeyword("doc"), "sc must be a sorted collection, test(s) one of <, <=, > or\n >=. Returns a seq of those entries with keys ek for\n which (test (.. sc comparator (compare ek key)) 0) is true", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5133), lang.NewKeyword("end-line"), int(5133))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + switch len(args) { + case 3: v3 := args[0] v4 := args[1] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("every?")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("symbol?")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +v5 := args[2] +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("mk-bound-fn")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v11 := v10.Get() -v12 := lang.Apply(v8, []any{v11, v3}) -if lang.IsTruthy(v12) { +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v3, v4, v5}) +var v6 any = v10 +_ = v6 +var v12 any v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("cons")) +v14 := v13.FindInternedVar(lang.NewSymbol(">")) if v14.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } v15 := v14.Get() -v16 := lang.Apply(v15, []any{v3, v4}) -v5 = v16 -} else { -var v17 any = v17 -_ = v17 -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("with-meta")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol(">=")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -v21 := v20.Get() -v22 := lang.NewVector() -v23 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4520), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(4520), lang.NewKeyword("end-column"), int(35)) -v24, err := lang.WithMeta(v22, v23.(lang.IPersistentMap)) +v18 := v17.Get() +v19 := lang.CreatePersistentTreeSet(v15, v18) +v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5141), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5141), lang.NewKeyword("end-column"), int(17)) +v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) if err != nil { panic(err) } -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("meta")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +v22 := lang.Apply(v21, []any{v4}) +if lang.IsTruthy(v22) { +v24, _ := lang.FieldOrMethod(v3, "seqFrom") +if reflect.TypeOf(v24).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("seqFrom is not a function"))) } -v27 := v26.Get() -v28 := lang.Apply(v27, []any{v17}) -v29 := lang.Apply(v21, []any{v24, v28}) -var v18 any = v29 -_ = v18 -v31 := lang.NewVector() -v32 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4521), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(4521), lang.NewKeyword("end-column"), int(18)) -v33, err := lang.WithMeta(v31, v32.(lang.IPersistentMap)) -if err != nil { - panic(err) +v25 := lang.Apply(v24, []any{v5, true}) +var v23 any = v25 +_ = v23 +var v27 any +if lang.IsTruthy(v23) { +var v28 any = v23 +_ = v28 +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("nth")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) } -var v30 any = v33 -_ = v30 -var v34 any -for { -var v35 any -if lang.IsTruthy(v17) { +v32 := v31.Get() +v33 := lang.Apply(v32, []any{v28, int64(0), nil}) +var v29 any = v33 +_ = v29 +var v34 any = v28 +_ = v34 var v36 any -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("symbol?")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +v37 := lang.Apply(v6, []any{v29}) +if lang.IsTruthy(v37) { +v36 = v34 +} else { +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("next")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) } -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("first")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +v40 := v39.Get() +v41 := lang.Apply(v40, []any{v34}) +v36 = v41 } -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v17}) -v44 := lang.Apply(v39, []any{v43}) -if lang.IsTruthy(v44) { -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("next")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +v27 = v36 +} else { +v27 = nil } -v48 := v47.Get() -v49 := lang.Apply(v48, []any{v17}) -var v45 any = v49 -v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v52 := v51.FindInternedVar(lang.NewSymbol("conj")) -if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) +v12 = v27 +} else { +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("take-while")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v53 := v52.Get() -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("first")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +v25 := v24.Get() +v26, _ := lang.FieldOrMethod(v3, "seq") +if reflect.TypeOf(v26).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("seq is not a function"))) } -v56 := v55.Get() -v57 := lang.Apply(v56, []any{v17}) -v58 := lang.Apply(v53, []any{v18, v57}) -var v50 any = v58 -var v59 any = v30 -v17 = v45 -v18 = v50 -v30 = v59 -continue +v27 := lang.Apply(v26, []any{true}) +v28 := lang.Apply(v25, []any{v6, v27}) +v12 = v28 +} +return v12 + case 5: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := args[4] +v9, _ := lang.FieldOrMethod(v3, "seqFrom") +if reflect.TypeOf(v9).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("seqFrom is not a function"))) +} +v10 := lang.Apply(v9, []any{v5, true}) +var v8 any = v10 +_ = v8 +var v12 any +if lang.IsTruthy(v8) { +var v13 any = v8 +_ = v13 +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("nth")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v13, int64(0), nil}) +var v14 any = v18 +_ = v14 +var v19 any = v13 +_ = v19 +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("take-while")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("mk-bound-fn")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v3, v6, v7}) +var v28 any +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("mk-bound-fn")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.Apply(v31, []any{v3, v4, v5}) +v33 := lang.Apply(v32, []any{v14}) +if lang.IsTruthy(v33) { +v28 = v19 } else { -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("gensym")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("next")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } -v63 := v62.Get() -v64 := lang.Apply(v63, []any{"p__"}) -var v60 any = v64 -_ = v60 -v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v68 := v67.FindInternedVar(lang.NewSymbol("next")) -if v68.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) +v36 := v35.Get() +v37 := lang.Apply(v36, []any{v19}) +v28 = v37 } -v69 := v68.Get() -v70 := lang.Apply(v69, []any{v17}) -var v66 any = v70 -v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v73 := v72.FindInternedVar(lang.NewSymbol("conj")) -if v73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) +v38 := lang.Apply(v23, []any{v27, v28}) +v12 = v38 +} else { +v12 = nil } -v74 := v73.Get() -v75 := lang.Apply(v74, []any{v18, v60}) -var v71 any = v75 -v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v78 := v77.FindInternedVar(lang.NewSymbol("conj")) -if v78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) +return v12 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v79 := v78.Get() -v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v81 := v80.FindInternedVar(lang.NewSymbol("conj")) -if v81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) } -v82 := v81.Get() -v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v84 := v83.FindInternedVar(lang.NewSymbol("first")) -if v84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) +// subvec +{ +v0 := lang.NewSymbol("subvec").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("v"), lang.NewSymbol("start")), lang.NewVector(lang.NewSymbol("v"), lang.NewSymbol("start"), lang.NewSymbol("end"))), lang.NewKeyword("doc"), "Returns a persistent vector of the items in vector from\n start (inclusive) to end (exclusive). If end is not supplied,\n defaults to (count vector). This operation is O(1) and very fast, as\n the resulting vector shares structure with the original and no\n trimming is done.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3819), lang.NewKeyword("end-line"), int(3819))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("subvec")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v85 := v84.Get() -v86 := lang.Apply(v85, []any{v17}) -v87 := lang.Apply(v82, []any{v30, v86}) -v88 := lang.Apply(v79, []any{v87, v60}) -var v76 any = v88 -v17 = v66 -v18 = v71 -v30 = v76 -continue +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("count")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v3}) +v12 := lang.Apply(v7, []any{v3, v4, v11}) +return v12 + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6, _ := lang.FieldOrMethod(runtime9.RT, "Subvec") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Subvec is not a function"))) +} +v7 := lang.Apply(v6, []any{v3, v4, v5}) +return v7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// supers +{ +v0 := lang.NewSymbol("supers").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("class"))), lang.NewKeyword("doc"), "Returns the immediate and indirect superclasses and interfaces of c, if any", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5575), lang.NewKeyword("end-line"), int(5575))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("set")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v35 = v36 -} else { -v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v61 := v60.FindInternedVar(lang.NewSymbol("seq")) -if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("bases")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v62 := v61.Get() -v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v64 := v63.FindInternedVar(lang.NewSymbol("concat")) -if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v3}) +v12 := lang.Apply(v7, []any{v11}) +var v4 any = v12 +_ = v4 +var v13 any = v4 +_ = v13 +var v14 any +for { +var v15 any +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("seq")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -v65 := v64.Get() -v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v67 := v66.FindInternedVar(lang.NewSymbol("list")) -if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v13}) +if lang.IsTruthy(v19) { +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("first")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v68 := v67.Get() -v69 := lang.Apply(v68, []any{v18}) -v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v71 := v70.FindInternedVar(lang.NewSymbol("list")) -if v71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) +v23 := v22.Get() +v24 := lang.Apply(v23, []any{v13}) +var v20 any = v24 +_ = v20 +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("bases")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) } -v72 := v71.Get() -v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v74 := v73.FindInternedVar(lang.NewSymbol("seq")) -if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) +v28 := v27.Get() +v29 := lang.Apply(v28, []any{v20}) +var v25 any = v29 +_ = v25 +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("into1")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) } -v75 := v74.Get() -v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v77 := v76.FindInternedVar(lang.NewSymbol("concat")) -if v77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v4, v25}) +var v31 any = v35 +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("into1")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -v78 := v77.Get() -v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v80 := v79.FindInternedVar(lang.NewSymbol("list")) -if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("disj")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) } -v81 := v80.Get() -v82 := lang.Apply(v81, []any{lang.NewSymbol("glojure.core/let")}) -v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v84 := v83.FindInternedVar(lang.NewSymbol("list")) -if v84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v13, v20}) +v44 := lang.Apply(v39, []any{v43, v25}) +var v36 any = v44 +v4 = v31 +v13 = v36 +continue +} else { +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("not-empty")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v85 := v84.Get() -v86 := lang.Apply(v85, []any{v30}) -v87 := lang.Apply(v78, []any{v82, v86, v4}) -v88 := lang.Apply(v75, []any{v87}) -v89 := lang.Apply(v72, []any{v88}) -v90 := lang.Apply(v65, []any{v69, v89}) -v91 := lang.Apply(v62, []any{v90}) -v35 = v91 +v22 := v21.Get() +v23 := lang.Apply(v22, []any{v4}) +v15 = v23 } -v34 = v35 +v14 = v15 break } -v5 = v34 -} -return v5 +return v14 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -71952,22 +72338,26 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// cast +// swap! { -v0 := lang.NewSymbol("cast").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Throws a ClassCastException if x is not a c, else returns x.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(345), lang.NewKeyword("end-line"), int(345))).(*lang.Symbol) +v0 := lang.NewSymbol("swap!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atom"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Atomically swaps the value of atom to be:\n (apply f current-value-of-atom args). Note that f may be called\n multiple times, and thus should be free of side effects. Returns\n the value that was swapped in.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2343), lang.NewKeyword("end-line"), int(2343))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] v4 := args[1] -v5, _ := lang.FieldOrMethod(v3, "cast") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("cast is not a function"))) +v5 := lang.NewList(args[2:]...) +v6, _ := lang.FieldOrMethod(v3, "swap") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("swap is not a function"))) } -v6 := lang.Apply(v5, []any{v4}) -return v6 +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 + } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -71975,32 +72365,12 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// print-method -{ -v0 := lang.NewSymbol("print-method").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3664), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(3664), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, nil, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// dissoc +// swap-vals! { -v0 := lang.NewSymbol("dissoc").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map")), lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"), lang.NewSymbol("&"), lang.NewSymbol("ks"))), lang.NewKeyword("doc"), "dissoc[iate]. Returns a new map of the same (hashed/sorted) type,\n that does not contain a mapping for key(s).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1500), lang.NewKeyword("end-line"), int(1500))).(*lang.Symbol) +v0 := lang.NewSymbol("swap-vals!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atom"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Atomically swaps the value of atom to be:\n (apply f current-value-of-atom args). Note that f may be called\n multiple times, and thus should be free of side effects.\n Returns [old new], the value of the atom before and after the swap.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2352), lang.NewKeyword("end-line"), int(2352))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 1: -v3 := args[0] -return v3 - case 2: -v3 := args[0] -v4 := args[1] -v5, _ := lang.FieldOrMethod(runtime3.RT, "Dissoc") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Dissoc is not a function"))) -} -v6 := lang.Apply(v5, []any{v3, v4}) -return v6 default: if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -72008,90 +72378,155 @@ return v6 v3 := args[0] v4 := args[1] v5 := lang.NewList(args[2:]...) -recur_loop_301: -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("dissoc")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v6, _ := lang.FieldOrMethod(v3, "swapVals") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("swapVals is not a function"))) } -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v3, v4}) -var v6 any = v10 -_ = v6 -var v12 any -if lang.IsTruthy(v5) { -var v13 any = v6 -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("first")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v5}) -var v14 any = v18 -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("next")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v22 := v21.Get() -v23 := lang.Apply(v22, []any{v5}) -var v19 any = v23 -v3 = v13 -v4 = v14 -v5 = v19 -goto recur_loop_301 +// symbol +{ +v1 := reflect.TypeOf((*lang1.Symbol)(nil)) +v0 := lang.NewSymbol("symbol").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name"))), lang.NewKeyword("doc"), "Returns a Symbol with the given namespace and name. Arity-1 works\n on strings, keywords, and vars.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(584), lang.NewKeyword("end-line"), int(584))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v4 := args[0] +var v5 any +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("symbol?")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v4}) +if lang.IsTruthy(v9) { +v5 = v4 } else { -v12 = v6 +var v10 any +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("instance?")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -return v12 +v13 := v12.Get() +v14 := lang.Apply(v13, []any{lang.Builtins["string"], v4}) +if lang.IsTruthy(v14) { +v15 := lang.Apply(lang1.NewSymbol, []any{v4}) +v10 = v15 +} else { +var v16 any +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("instance?")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +} +v19 := v18.Get() +v20 := lang.Apply(v19, []any{lang1.*Var, v4}) +if lang.IsTruthy(v20) { +v21, ok := lang.FieldOrMethod(v4, "toSymbol") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "toSymbol"))) +} +var v22 any +switch reflect.TypeOf(v21).Kind() { +case reflect.Func: + v22 = lang.Apply(v21, nil) +default: + v22 = v21 +} +v16 = v22 +} else { +var v23 any +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("instance?")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.Apply(v26, []any{lang1.Keyword, v4}) +if lang.IsTruthy(v27) { +v28, ok := lang.FieldOrMethod(v4, "sym") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "sym"))) +} +var v29 any +switch reflect.TypeOf(v28).Kind() { +case reflect.Func: + v29 = lang.Apply(v28, nil) +default: + v29 = v28 +} +v23 = v29 +} else { +var v30 any +if lang.IsTruthy(lang.NewKeyword("else")) { +v31 := lang.Apply(lang1.NewIllegalArgumentError, []any{"no conversion to symbol"}) +panic(v31) +} else { +v30 = nil +} +v23 = v30 +} +v16 = v23 +} +v10 = v16 +} +v5 = v10 +} +return v5 + case 2: +v4 := args[0] +v5 := args[1] +v6 := lang.Apply(lang1.InternSymbol, []any{v4, v5}) +return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) +v4 := reflect.TypeOf((*lang1.Symbol)(nil)) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// map? +// symbol? { -v0 := lang.NewSymbol("map?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x implements IPersistentMap", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(167), lang.NewKeyword("end-line"), int(171))).(*lang.Symbol) +v0 := lang.NewSymbol("symbol?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a Symbol", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(557), lang.NewKeyword("end-line"), int(557))).(*lang.Symbol) var v2 lang.FnFunc -{ // function map? v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v4 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v7 := v6.Get() -v8 := lang.Apply(v7, []any{lang1.IPersistentMap, v4}) -return v8 +v6 := v5.Get() +v7 := lang.Apply(v6, []any{lang1.*Symbol, v3}) +return v7 }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(171), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(171), lang.NewKeyword("end-column"), int(97))).(lang.FnFunc) -v3 := v2 -_ = v3 -} +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// *flush-on-newline* -{ -v0 := lang.NewSymbol("*flush-on-newline*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "When set to true, output will be flushed whenever a newline is printed.\n\n Defaults to true.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, nil, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// defprotocol +// sync { -v0 := lang.NewSymbol("defprotocol").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("opts+sigs"))), lang.NewKeyword("doc"), "A protocol is a named set of named methods and their signatures:\n (defprotocol AProtocolName\n\n ;optional doc string\n \"A doc string for AProtocol abstraction\"\n\n ;options\n :extend-via-metadata true\n\n ;method signatures\n (bar [this a b] \"bar docs\")\n (baz [this a] [this a b] [this a b c] \"baz docs\"))\n\n No implementations are provided. Docs can be specified for the\n protocol overall and for each method. The above yields a set of\n polymorphic functions and a protocol object. All are\n namespace-qualified by the ns enclosing the definition The resulting\n functions dispatch on the type of their first argument, which is\n required and corresponds to the implicit target object ('this' in \n Java parlance). defprotocol is dynamic, has no special compile-time \n effect, and defines no new types or classes. Implementations of \n the protocol methods can be provided using extend.\n\n When :extend-via-metadata is true, values can extend protocols by\n adding metadata where keys are fully-qualified protocol function\n symbols and values are function implementations. Protocol\n implementations are checked first for direct definitions (defrecord,\n deftype, reify), then metadata definitions, then external\n extensions (extend, extend-type, extend-protocol)\n\n defprotocol will automatically generate a corresponding interface,\n with the same name as the protocol, i.e. given a protocol:\n my.ns/Protocol, an interface: my.ns.Protocol. The interface will\n have methods corresponding to the protocol functions, and the\n protocol will automatically work with instances of the interface.\n\n Note that you should not use this interface with deftype or\n reify, as they support the protocol directly:\n\n (defprotocol P \n (foo [this]) \n (bar-me [this] [this y]))\n\n (deftype Foo [a b c] \n P\n (foo [this] a)\n (bar-me [this] b)\n (bar-me [this y] (+ c y)))\n \n (bar-me (Foo. 1 2 3) 42)\n => 45\n\n (foo \n (let [x 42]\n (reify P \n (foo [this] 17)\n (bar-me [this] x)\n (bar-me [this y] x))))\n => 17", lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(28), lang.NewKeyword("end-line"), int(28))).(*lang.Symbol) +v0 := lang.NewSymbol("sync").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("flags-ignored-for-now"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "transaction-flags => TBD, pass nil for now\n\n Runs the exprs (in an implicit do) in a transaction that encompasses\n exprs and any nested calls. Starts a transaction if none is already\n running on this thread. Any uncaught exception will abort the\n transaction and flow out of sync. The exprs may be run more than\n once, but any effects on Refs will be atomic.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(2490), lang.NewKeyword("end-line"), int(2490))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -72103,841 +72538,819 @@ v3 := args[0] v4 := args[1] v5 := args[2] v6 := lang.NewList(args[3:]...) -var v8 any -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("string?")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("seq")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("first")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("concat")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v6}) -v16 := lang.Apply(v11, []any{v15}) -if lang.IsTruthy(v16) { +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("list")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{lang.NewSymbol(".")}) v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("first")) +v18 := v17.FindInternedVar(lang.NewSymbol("list")) if v18.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } v19 := v18.Get() -v20 := lang.Apply(v19, []any{v6}) -v8 = v20 -} else { -v8 = nil -} -var v7 any = v8 -_ = v7 -var v22 any -if lang.IsTruthy(v7) { -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("rest")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{v21}) -v22 = v26 -} else { -v22 = v21 -} -var v21 any = v22 -_ = v21 -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("take-while")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -var v31 lang.FnFunc -v31 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v32 := args[0] -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("not")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("seq?")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +v20 := lang.Apply(v19, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.LockingTransaction")}) +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("list")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v32}) -v40 := lang.Apply(v35, []any{v39}) -return v40 -}) -v32 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(92), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(92), lang.NewKeyword("end-column"), int(40)) -v33, err := lang.WithMeta(v31, v32.(lang.IPersistentMap)) -if err != nil { - panic(err) +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("seq")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -v34 := lang.Apply(v30, []any{v33, v21}) -var v27 any = v34 -_ = v27 -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("drop-while")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("concat")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v38 := v37.Get() -var v39 lang.FnFunc -v39 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v40 := args[0] -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("not")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +v29 := v28.Get() +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("list")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) } -v43 := v42.Get() -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("seq?")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +v32 := v31.Get() +v33 := lang.Apply(v32, []any{lang.NewSymbol("glojure.core/RunInTransaction")}) +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("list")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v40}) -v48 := lang.Apply(v43, []any{v47}) -return v48 -}) -v40 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(93), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(93), lang.NewKeyword("end-column"), int(40)) -v41, err := lang.WithMeta(v39, v40.(lang.IPersistentMap)) -if err != nil { - panic(err) +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("seq")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -v42 := lang.Apply(v38, []any{v41, v21}) -var v35 any = v42 -_ = v35 -var v44 any -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("=")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("concat")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) } -v47 := v46.Get() -v48 := lang.Apply(v47, []any{v35, v43}) -if lang.IsTruthy(v48) { -v44 = nil -} else { -v44 = v43 +v42 := v41.Get() +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("list")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) } -var v43 any = v44 -_ = v43 +v45 := v44.Get() +v46 := lang.Apply(v45, []any{lang.NewSymbol("glojure.core/fn")}) +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("list")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +} +v49 := v48.Get() v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("seq")) +v51 := v50.FindInternedVar(lang.NewSymbol("apply")) if v51.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) } v52 := v51.Get() v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("concat")) +v54 := v53.FindInternedVar(lang.NewSymbol("vector")) if v54.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) } v55 := v54.Get() v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v57 := v56.FindInternedVar(lang.NewSymbol("list")) +v57 := v56.FindInternedVar(lang.NewSymbol("seq")) if v57.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) } v58 := v57.Get() -v59 := lang.Apply(v58, []any{lang.NewSymbol("do")}) -v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v61 := v60.FindInternedVar(lang.NewSymbol("list")) -if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) -} -v62 := v61.Get() -v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v64 := v63.FindInternedVar(lang.NewSymbol("seq")) -if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) -} -v65 := v64.Get() -v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v67 := v66.FindInternedVar(lang.NewSymbol("concat")) -if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) -} -v68 := v67.Get() -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("list")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) -} -v71 := v70.Get() -v72 := lang.Apply(v71, []any{lang.NewSymbol("def")}) -v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v74 := v73.FindInternedVar(lang.NewSymbol("list")) -if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) -} -v75 := v74.Get() -v76 := lang.Apply(v75, []any{v5}) -v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v78 := v77.FindInternedVar(lang.NewSymbol("list")) -if v78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) -} -v79 := v78.Get() -v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v81 := v80.FindInternedVar(lang.NewSymbol("seq")) -if v81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) -} -v82 := v81.Get() -v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v84 := v83.FindInternedVar(lang.NewSymbol("concat")) -if v84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) -} -v85 := v84.Get() -v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v87 := v86.FindInternedVar(lang.NewSymbol("list")) -if v87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) -} -v88 := v87.Get() -v89 := lang.Apply(v88, []any{lang.NewSymbol("glojure.core/atom")}) -v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v91 := v90.FindInternedVar(lang.NewSymbol("list")) -if v91.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) -} -v92 := v91.Get() -v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v94 := v93.FindInternedVar(lang.NewSymbol("apply")) -if v94.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) -} -v95 := v94.Get() -v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v97 := v96.FindInternedVar(lang.NewSymbol("hash-map")) -if v97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) -} -v98 := v97.Get() -v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v100 := v99.FindInternedVar(lang.NewSymbol("seq")) -if v100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) -} -v101 := v100.Get() -v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v103 := v102.FindInternedVar(lang.NewSymbol("concat")) -if v103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) -} -v104 := v103.Get() -v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v106 := v105.FindInternedVar(lang.NewSymbol("list")) -if v106.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) -} -v107 := v106.Get() -v108 := lang.Apply(v107, []any{lang.NewKeyword("on-interface")}) -v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v110 := v109.FindInternedVar(lang.NewSymbol("list")) -if v110.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) -} -v111 := v110.Get() -v112 := lang.Apply(v111, []any{true}) -v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v114 := v113.FindInternedVar(lang.NewSymbol("list")) -if v114.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) -} -v115 := v114.Get() -v116 := lang.Apply(v115, []any{lang.NewKeyword("sigs")}) -v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v118 := v117.FindInternedVar(lang.NewSymbol("list")) -if v118.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) +v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v60 := v59.FindInternedVar(lang.NewSymbol("concat")) +if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) } -v119 := v118.Get() -v120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v121 := v120.FindInternedVar(lang.NewSymbol("seq")) -if v121.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v121))) +v61 := v60.Get() +v62 := lang.Apply(v61, nil) +v63 := lang.Apply(v58, []any{v62}) +v64 := lang.Apply(v52, []any{v55, v63}) +v65 := lang.Apply(v49, []any{v64}) +v66 := lang.Apply(v42, []any{v46, v65, v6}) +v67 := lang.Apply(v39, []any{v66}) +v68 := lang.Apply(v36, []any{v67}) +v69 := lang.Apply(v29, []any{v33, v68}) +v70 := lang.Apply(v26, []any{v69}) +v71 := lang.Apply(v23, []any{v70}) +v72 := lang.Apply(v12, []any{v16, v20, v71}) +v73 := lang.Apply(v9, []any{v72}) +return v73 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v122 := v121.Get() -v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v124 := v123.FindInternedVar(lang.NewSymbol("concat")) -if v124.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) } -v125 := v124.Get() -v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v127 := v126.FindInternedVar(lang.NewSymbol("list")) -if v127.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) +// system-newline +{ +v0 := lang.NewSymbol("system-newline").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3695), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(3695), lang.NewKeyword("end-column"), int(40), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v1 := ns.InternWithValue(v0, "\n", true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v128 := v127.Get() -v129 := lang.Apply(v128, []any{lang.NewSymbol("quote")}) -v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v131 := v130.FindInternedVar(lang.NewSymbol("list")) -if v131.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) } -v132 := v131.Get() -v133 := lang.Apply(v132, []any{v35}) -v134 := lang.Apply(v125, []any{v129, v133}) -v135 := lang.Apply(v122, []any{v134}) -v136 := lang.Apply(v119, []any{v135}) -v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v138 := v137.FindInternedVar(lang.NewSymbol("list")) -if v138.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) +// tagged-literal +{ +v0 := lang.NewSymbol("tagged-literal").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag"), lang.NewSymbol("form"))), lang.NewKeyword("doc"), "Construct a data representation of a tagged literal from a\n tag symbol and a form.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7812), lang.NewKeyword("end-line"), int(7812))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.Apply(nil, []any{v3, v4}) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v139 := v138.Get() -v140 := lang.Apply(v139, []any{lang.NewKeyword("multis")}) -v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v142 := v141.FindInternedVar(lang.NewSymbol("list")) -if v142.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) } -v143 := v142.Get() -v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v145 := v144.FindInternedVar(lang.NewSymbol("apply")) -if v145.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) +// tagged-literal? +{ +v0 := lang.NewSymbol("tagged-literal?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("value"))), lang.NewKeyword("doc"), "Return true if the value is the data representation of a tagged literal", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7806), lang.NewKeyword("end-line"), int(7806))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v146 := v145.Get() -v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v148 := v147.FindInternedVar(lang.NewSymbol("hash-map")) -if v148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) +v6 := v5.Get() +v7 := lang.Apply(v6, []any{glojure.lang8.TaggedLiteral, v3}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v149 := v148.Get() -v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v151 := v150.FindInternedVar(lang.NewSymbol("seq")) -if v151.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) } -v152 := v151.Get() -v153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v154 := v153.FindInternedVar(lang.NewSymbol("concat")) -if v154.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v154))) +// take +{ +v0 := lang.NewSymbol("take").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the first n items in coll, or all items if\n there are fewer than n. Returns a stateful transducer when\n no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2853), lang.NewKeyword("end-line"), int(2853))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("volatile!")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v155 := v154.Get() -v156 := lang.Apply(v155, nil) -v157 := lang.Apply(v152, []any{v156}) -v158 := lang.Apply(v146, []any{v149, v157}) -v159 := lang.Apply(v143, []any{v158}) -v160 := lang.Apply(v104, []any{v108, v112, v116, v136, v140, v159}) -v161 := lang.Apply(v101, []any{v160}) -v162 := lang.Apply(v95, []any{v98, v161}) -v163 := lang.Apply(v92, []any{v162}) -v164 := lang.Apply(v85, []any{v89, v163}) -v165 := lang.Apply(v82, []any{v164}) -v166 := lang.Apply(v79, []any{v165}) -v167 := lang.Apply(v68, []any{v72, v76, v166}) -v168 := lang.Apply(v65, []any{v167}) -v169 := lang.Apply(v62, []any{v168}) -v170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v171 := v170.FindInternedVar(lang.NewSymbol("list")) -if v171.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v171))) +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v3}) +var v6 any = v10 +_ = v6 +var v12 lang.FnFunc +v12 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v13 := lang.Apply(v5, nil) +return v13 + case 1: +v13 := args[0] +v14 := lang.Apply(v5, []any{v13}) +return v14 + case 2: +v13 := args[0] +v14 := args[1] +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("deref")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -v172 := v171.Get() -v173 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v174 := v173.FindInternedVar(lang.NewSymbol("seq")) -if v174.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v174))) +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v6}) +var v15 any = v19 +_ = v15 +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("dec")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v175 := v174.Get() -v176 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v177 := v176.FindInternedVar(lang.NewSymbol("concat")) -if v177.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v177))) +v23 := v22.Get() +v24, ok := lang.FieldOrMethod(v6, "Deref") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "Deref"))) } -v178 := v177.Get() -v179 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v180 := v179.FindInternedVar(lang.NewSymbol("list")) -if v180.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v180))) +var v25 any +switch reflect.TypeOf(v24).Kind() { +case reflect.Func: + v25 = lang.Apply(v24, nil) +default: + v25 = v24 } -v181 := v180.Get() -v182 := lang.Apply(v181, []any{lang.NewSymbol("glojure.core/swap!")}) -v183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v184 := v183.FindInternedVar(lang.NewSymbol("list")) -if v184.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v184))) +v26 := lang.Apply(v23, []any{v25}) +v27, _ := lang.FieldOrMethod(v6, "reset") +if reflect.TypeOf(v27).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) } -v185 := v184.Get() -v186 := lang.Apply(v185, []any{lang.NewSymbol("glojure.core/-protocols")}) -v187 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v188 := v187.FindInternedVar(lang.NewSymbol("list")) -if v188.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v188))) +v28 := lang.Apply(v27, []any{v26}) +var v20 any = v28 +_ = v20 +var v30 any +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("pos?")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -v189 := v188.Get() -v190 := lang.Apply(v189, []any{lang.NewSymbol("glojure.core/assoc")}) -v191 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v192 := v191.FindInternedVar(lang.NewSymbol("list")) -if v192.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v192))) +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v15}) +if lang.IsTruthy(v34) { +v35 := lang.Apply(v5, []any{v29, v14}) +v30 = v35 +} else { +v30 = v29 } -v193 := v192.Get() -v194 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v195 := v194.FindInternedVar(lang.NewSymbol("seq")) -if v195.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v195))) +var v29 any = v30 +_ = v29 +var v37 any +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("not")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) } -v196 := v195.Get() -v197 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v198 := v197.FindInternedVar(lang.NewSymbol("concat")) -if v198.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v198))) +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("pos?")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } -v199 := v198.Get() -v200 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v201 := v200.FindInternedVar(lang.NewSymbol("list")) -if v201.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v201))) +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v20}) +v45 := lang.Apply(v40, []any{v44}) +if lang.IsTruthy(v45) { +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("ensure-reduced")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) } -v202 := v201.Get() -v203 := lang.Apply(v202, []any{lang.NewSymbol("quote")}) -v204 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v205 := v204.FindInternedVar(lang.NewSymbol("list")) -if v205.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v205))) +v48 := v47.Get() +v49 := lang.Apply(v48, []any{v29}) +v37 = v49 +} else { +v37 = v29 } -v206 := v205.Get() -v207 := lang.Apply(v206, []any{v5}) -v208 := lang.Apply(v199, []any{v203, v207}) -v209 := lang.Apply(v196, []any{v208}) -v210 := lang.Apply(v193, []any{v209}) -v211 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v212 := v211.FindInternedVar(lang.NewSymbol("list")) -if v212.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v212))) +return v37 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2862), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(2873), lang.NewKeyword("end-column"), int(28)) +v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v213 := v212.Get() -v214 := lang.Apply(v213, []any{v5}) -v215 := lang.Apply(v178, []any{v182, v186, v190, v210, v214}) -v216 := lang.Apply(v175, []any{v215}) -v217 := lang.Apply(v172, []any{v216}) -v218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v219 := v218.FindInternedVar(lang.NewSymbol("map")) -if v219.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v219))) +return v14 +}) +v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2860), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2873), lang.NewKeyword("end-column"), int(30)) +v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v220 := v219.Get() -var v221 lang.FnFunc -v221 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { +return v6 + case 2: +v3 := args[0] +v4 := args[1] +var v5 lang.FnFunc +v5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v222 := args[0] -v223 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v224 := v223.FindInternedVar(lang.NewSymbol("seq")) -if v224.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v224))) -} -v225 := v224.Get() -v226 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v227 := v226.FindInternedVar(lang.NewSymbol("concat")) -if v227.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v227))) +var v6 any +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("pos?")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v228 := v227.Get() -v229 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v230 := v229.FindInternedVar(lang.NewSymbol("list")) -if v230.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v230))) +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v3}) +if lang.IsTruthy(v10) { +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("seq")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } -v231 := v230.Get() -v232 := lang.Apply(v231, []any{lang.NewSymbol("do")}) -v233 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v234 := v233.FindInternedVar(lang.NewSymbol("list")) -if v234.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v234))) +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v4}) +var v11 any = v15 +_ = v11 +var v17 any +if lang.IsTruthy(v11) { +var v18 any = v11 +_ = v18 +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("cons")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v235 := v234.Get() -v236 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v237 := v236.FindInternedVar(lang.NewSymbol("seq")) -if v237.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v237))) +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("first")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v238 := v237.Get() -v239 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v240 := v239.FindInternedVar(lang.NewSymbol("concat")) -if v240.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v240))) +v25 := v24.Get() +v26 := lang.Apply(v25, []any{v18}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("take")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v241 := v240.Get() -v242 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v243 := v242.FindInternedVar(lang.NewSymbol("list")) -if v243.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v243))) +v29 := v28.Get() +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("dec")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) } -v244 := v243.Get() -v245 := lang.Apply(v244, []any{lang.NewSymbol("glojure.core/defmulti")}) -v246 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v247 := v246.FindInternedVar(lang.NewSymbol("list")) -if v247.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v247))) +v32 := v31.Get() +v33 := lang.Apply(v32, []any{v3}) +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("rest")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } -v248 := v247.Get() -v249 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v250 := v249.FindInternedVar(lang.NewSymbol("first")) -if v250.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v250))) +v36 := v35.Get() +v37 := lang.Apply(v36, []any{v18}) +v38 := lang.Apply(v29, []any{v33, v37}) +v39 := lang.Apply(v22, []any{v26, v38}) +v17 = v39 +} else { +v17 = nil } -v251 := v250.Get() -v252 := lang.Apply(v251, []any{v222}) -v253 := lang.Apply(v248, []any{v252}) -v254 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v255 := v254.FindInternedVar(lang.NewSymbol("list")) -if v255.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v255))) +v6 = v17 +} else { +v6 = nil } -v256 := v255.Get() -v257 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v258 := v257.FindInternedVar(lang.NewSymbol("seq")) -if v258.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v258))) +return v6 +}) +v6 := lang.Apply(lang1.NewLazySeq, []any{v5}) +return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v259 := v258.Get() -v260 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v261 := v260.FindInternedVar(lang.NewSymbol("concat")) -if v261.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v261))) } -v262 := v261.Get() -v263 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v264 := v263.FindInternedVar(lang.NewSymbol("list")) -if v264.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v264))) +// take-last +{ +v0 := lang.NewSymbol("take-last").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a seq of the last n items in coll. Depending on the type\n of coll may be no better than linear time. For vectors, see also subvec.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2939), lang.NewKeyword("end-line"), int(2939))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("seq")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v265 := v264.Get() -v266 := lang.Apply(v265, []any{lang.NewSymbol("glojure.core/fn")}) -v267 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v268 := v267.FindInternedVar(lang.NewSymbol("list")) -if v268.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v268))) +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v4}) +var v5 any = v9 +_ = v5 +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("seq")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v269 := v268.Get() -v270 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v271 := v270.FindInternedVar(lang.NewSymbol("apply")) -if v271.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v271))) +v13 := v12.Get() +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("drop")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v272 := v271.Get() -v273 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v274 := v273.FindInternedVar(lang.NewSymbol("vector")) -if v274.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v274))) +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v3, v4}) +v18 := lang.Apply(v13, []any{v17}) +var v10 any = v18 +_ = v10 +var v19 any +for { +var v20 any +if lang.IsTruthy(v10) { +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("next")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -v275 := v274.Get() -v276 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v277 := v276.FindInternedVar(lang.NewSymbol("seq")) -if v277.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v277))) +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v5}) +var v21 any = v25 +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("next")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v278 := v277.Get() -v279 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v280 := v279.FindInternedVar(lang.NewSymbol("concat")) -if v280.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v280))) +v29 := v28.Get() +v30 := lang.Apply(v29, []any{v10}) +var v26 any = v30 +v5 = v21 +v10 = v26 +continue +} else { +v20 = v5 } -v281 := v280.Get() -v282 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v283 := v282.FindInternedVar(lang.NewSymbol("list")) -if v283.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v283))) +v19 = v20 + break } -v284 := v283.Get() -v285 := lang.Apply(v284, []any{lang.NewSymbol("this")}) -v286 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v287 := v286.FindInternedVar(lang.NewSymbol("list")) -if v287.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v287))) +return v19 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v288 := v287.Get() -v289 := lang.Apply(v288, []any{lang.NewSymbol("&")}) -v290 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v291 := v290.FindInternedVar(lang.NewSymbol("list")) -if v291.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v291))) } -v292 := v291.Get() -v293 := lang.Apply(v292, []any{lang.NewSymbol("args")}) -v294 := lang.Apply(v281, []any{v285, v289, v293}) -v295 := lang.Apply(v278, []any{v294}) -v296 := lang.Apply(v272, []any{v275, v295}) -v297 := lang.Apply(v269, []any{v296}) -v298 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v299 := v298.FindInternedVar(lang.NewSymbol("list")) -if v299.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v299))) +// take-nth +{ +v0 := lang.NewSymbol("take-nth").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy seq of every nth item in coll. Returns a stateful\n transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4287), lang.NewKeyword("end-line"), int(4287))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("volatile!")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v300 := v299.Get() -v301 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v302 := v301.FindInternedVar(lang.NewSymbol("seq")) -if v302.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v302))) +v9 := v8.Get() +v10 := lang.Apply(v9, []any{int64(-1)}) +var v6 any = v10 +_ = v6 +var v12 lang.FnFunc +v12 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v13 := lang.Apply(v5, nil) +return v13 + case 1: +v13 := args[0] +v14 := lang.Apply(v5, []any{v13}) +return v14 + case 2: +v13 := args[0] +v14 := args[1] +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("inc")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -v303 := v302.Get() -v304 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v305 := v304.FindInternedVar(lang.NewSymbol("concat")) -if v305.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v305))) +v18 := v17.Get() +v19, ok := lang.FieldOrMethod(v6, "Deref") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "Deref"))) } -v306 := v305.Get() -v307 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v308 := v307.FindInternedVar(lang.NewSymbol("list")) -if v308.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v308))) +var v20 any +switch reflect.TypeOf(v19).Kind() { +case reflect.Func: + v20 = lang.Apply(v19, nil) +default: + v20 = v19 } -v309 := v308.Get() -v310 := lang.Apply(v309, []any{lang.NewSymbol("glojure.core/class")}) -v311 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v312 := v311.FindInternedVar(lang.NewSymbol("list")) -if v312.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v312))) +v21 := lang.Apply(v18, []any{v20}) +v22, _ := lang.FieldOrMethod(v6, "reset") +if reflect.TypeOf(v22).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) } -v313 := v312.Get() -v314 := lang.Apply(v313, []any{lang.NewSymbol("this")}) -v315 := lang.Apply(v306, []any{v310, v314}) -v316 := lang.Apply(v303, []any{v315}) -v317 := lang.Apply(v300, []any{v316}) -v318 := lang.Apply(v262, []any{v266, v297, v317}) -v319 := lang.Apply(v259, []any{v318}) -v320 := lang.Apply(v256, []any{v319}) -v321 := lang.Apply(v241, []any{v245, v253, v320}) -v322 := lang.Apply(v238, []any{v321}) -v323 := lang.Apply(v235, []any{v322}) -v324 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v325 := v324.FindInternedVar(lang.NewSymbol("list")) -if v325.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v325))) +v23 := lang.Apply(v22, []any{v21}) +var v15 any = v23 +_ = v15 +var v25 any +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("zero?")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) } -v326 := v325.Get() -v327 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v328 := v327.FindInternedVar(lang.NewSymbol("seq")) -if v328.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v328))) +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("rem")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) } -v329 := v328.Get() -v330 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v331 := v330.FindInternedVar(lang.NewSymbol("concat")) -if v331.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v331))) +v31 := v30.Get() +v32 := lang.Apply(v31, []any{v15, v3}) +v33 := lang.Apply(v28, []any{v32}) +if lang.IsTruthy(v33) { +v34 := lang.Apply(v5, []any{v13, v14}) +v25 = v34 +} else { +v25 = v13 } -v332 := v331.Get() -v333 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v334 := v333.FindInternedVar(lang.NewSymbol("list")) -if v334.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v334))) +return v25 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4295), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(4302), lang.NewKeyword("end-column"), int(28)) +v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v335 := v334.Get() -v336 := lang.Apply(v335, []any{lang.NewSymbol("glojure.core/swap!")}) -v337 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v338 := v337.FindInternedVar(lang.NewSymbol("list")) -if v338.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v338))) +return v14 +}) +v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4293), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(4302), lang.NewKeyword("end-column"), int(30)) +v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v339 := v338.Get() -v340 := lang.Apply(v339, []any{v5}) -v341 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v342 := v341.FindInternedVar(lang.NewSymbol("list")) -if v342.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v342))) +return v6 + case 2: +v3 := args[0] +v4 := args[1] +var v5 lang.FnFunc +v5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("seq")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v343 := v342.Get() -v344 := lang.Apply(v343, []any{lang.NewSymbol("glojure.core/assoc-in")}) -v345 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v346 := v345.FindInternedVar(lang.NewSymbol("list")) -if v346.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v346))) +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v4}) +var v6 any = v10 +_ = v6 +var v12 any +if lang.IsTruthy(v6) { +var v13 any = v6 +_ = v13 +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("cons")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } -v347 := v346.Get() -v348 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v349 := v348.FindInternedVar(lang.NewSymbol("apply")) -if v349.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v349))) +v17 := v16.Get() +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("first")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v350 := v349.Get() -v351 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v352 := v351.FindInternedVar(lang.NewSymbol("vector")) -if v352.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v352))) +v20 := v19.Get() +v21 := lang.Apply(v20, []any{v13}) +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("take-nth")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -v353 := v352.Get() -v354 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v355 := v354.FindInternedVar(lang.NewSymbol("seq")) -if v355.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v355))) +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("drop")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -v356 := v355.Get() -v357 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v358 := v357.FindInternedVar(lang.NewSymbol("concat")) -if v358.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v358))) +v27 := v26.Get() +v28 := lang.Apply(v27, []any{v3, v13}) +v29 := lang.Apply(v24, []any{v3, v28}) +v30 := lang.Apply(v17, []any{v21, v29}) +v12 = v30 +} else { +v12 = nil } -v359 := v358.Get() -v360 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v361 := v360.FindInternedVar(lang.NewSymbol("list")) -if v361.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v361))) +return v12 +}) +v6 := lang.Apply(lang1.NewLazySeq, []any{v5}) +return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v362 := v361.Get() -v363 := lang.Apply(v362, []any{lang.NewKeyword("multis")}) -v364 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v365 := v364.FindInternedVar(lang.NewSymbol("list")) -if v365.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v365))) } -v366 := v365.Get() -v367 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v368 := v367.FindInternedVar(lang.NewSymbol("seq")) -if v368.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v368))) +// take-while +{ +v0 := lang.NewSymbol("take-while").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred")), lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of successive items from coll while\n (pred item) returns logical true. pred must be free of side-effects.\n Returns a transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2880), lang.NewKeyword("end-line"), int(2880))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +var v4 lang.FnFunc +v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v5 := args[0] +var v6 lang.FnFunc +v6 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: +v7 := lang.Apply(v5, nil) +return v7 + case 1: +v7 := args[0] +v8 := lang.Apply(v5, []any{v7}) +return v8 + case 2: +v7 := args[0] +v8 := args[1] +var v9 any +v10 := lang.Apply(v3, []any{v8}) +if lang.IsTruthy(v10) { +v11 := lang.Apply(v5, []any{v7, v8}) +v9 = v11 +} else { +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("reduced")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v7}) +v9 = v15 } -v369 := v368.Get() -v370 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v371 := v370.FindInternedVar(lang.NewSymbol("concat")) -if v371.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v371))) +return v9 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2888), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(2894), lang.NewKeyword("end-column"), int(33)) +v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v372 := v371.Get() -v373 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v374 := v373.FindInternedVar(lang.NewSymbol("list")) -if v374.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v374))) +return v8 +}) +v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2887), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2894), lang.NewKeyword("end-column"), int(34)) +v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v375 := v374.Get() -v376 := lang.Apply(v375, []any{lang.NewSymbol("glojure.core/keyword")}) -v377 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v378 := v377.FindInternedVar(lang.NewSymbol("list")) -if v378.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v378))) +return v6 + case 2: +v3 := args[0] +v4 := args[1] +var v5 lang.FnFunc +v5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("seq")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v379 := v378.Get() -v380 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v381 := v380.FindInternedVar(lang.NewSymbol("seq")) -if v381.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v381))) +v9 := v8.Get() +v10 := lang.Apply(v9, []any{v4}) +var v6 any = v10 +_ = v6 +var v12 any +if lang.IsTruthy(v6) { +var v13 any = v6 +_ = v13 +var v15 any +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("first")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -v382 := v381.Get() -v383 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v384 := v383.FindInternedVar(lang.NewSymbol("concat")) -if v384.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v384))) +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v13}) +v20 := lang.Apply(v3, []any{v19}) +if lang.IsTruthy(v20) { +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("cons")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v385 := v384.Get() -v386 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v387 := v386.FindInternedVar(lang.NewSymbol("list")) -if v387.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v387))) +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("first")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -v388 := v387.Get() -v389 := lang.Apply(v388, []any{lang.NewSymbol("quote")}) -v390 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v391 := v390.FindInternedVar(lang.NewSymbol("list")) -if v391.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v391))) +v26 := v25.Get() +v27 := lang.Apply(v26, []any{v13}) +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("take-while")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } -v392 := v391.Get() -v393 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v394 := v393.FindInternedVar(lang.NewSymbol("first")) -if v394.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v394))) +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("rest")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -v395 := v394.Get() -v396 := lang.Apply(v395, []any{v222}) -v397 := lang.Apply(v392, []any{v396}) -v398 := lang.Apply(v385, []any{v389, v397}) -v399 := lang.Apply(v382, []any{v398}) -v400 := lang.Apply(v379, []any{v399}) -v401 := lang.Apply(v372, []any{v376, v400}) -v402 := lang.Apply(v369, []any{v401}) -v403 := lang.Apply(v366, []any{v402}) -v404 := lang.Apply(v359, []any{v363, v403}) -v405 := lang.Apply(v356, []any{v404}) -v406 := lang.Apply(v350, []any{v353, v405}) -v407 := lang.Apply(v347, []any{v406}) -v408 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v409 := v408.FindInternedVar(lang.NewSymbol("list")) -if v409.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v409))) +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v13}) +v35 := lang.Apply(v30, []any{v3, v34}) +v36 := lang.Apply(v23, []any{v27, v35}) +v15 = v36 +} else { +v15 = nil } -v410 := v409.Get() -v411 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v412 := v411.FindInternedVar(lang.NewSymbol("first")) -if v412.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v412))) +v12 = v15 +} else { +v12 = nil } -v413 := v412.Get() -v414 := lang.Apply(v413, []any{v222}) -v415 := lang.Apply(v410, []any{v414}) -v416 := lang.Apply(v332, []any{v336, v340, v344, v407, v415}) -v417 := lang.Apply(v329, []any{v416}) -v418 := lang.Apply(v326, []any{v417}) -v419 := lang.Apply(v228, []any{v232, v323, v418}) -v420 := lang.Apply(v225, []any{v419}) -return v420 +return v12 }) -v222 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(102), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(104), lang.NewKeyword("end-column"), int(90)) -v223, err := lang.WithMeta(v221, v222.(lang.IPersistentMap)) -if err != nil { - panic(err) +v6 := lang.Apply(lang1.NewLazySeq, []any{v5}) +return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v224 := lang.Apply(v220, []any{v223, v35}) -v225 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v226 := v225.FindInternedVar(lang.NewSymbol("list")) -if v226.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v226))) } -v227 := v226.Get() -v228 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v229 := v228.FindInternedVar(lang.NewSymbol("seq")) -if v229.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v229))) +// tapset +{ +v0 := lang.NewSymbol("tapset").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7925), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(7925), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v2 := lang.NewAtom(lang.CreatePersistentTreeSet()) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v230 := v229.Get() -v231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v232 := v231.FindInternedVar(lang.NewSymbol("concat")) -if v232.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v232))) } -v233 := v232.Get() -v234 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v235 := v234.FindInternedVar(lang.NewSymbol("list")) -if v235.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v235))) +// test +{ +v0 := lang.NewSymbol("test").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("v"))), lang.NewKeyword("doc"), "test [v] finds fn at key :test in var metadata and calls it,\n presuming failure will throw exception", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4853), lang.NewKeyword("end-line"), int(4853))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("meta")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v236 := v235.Get() -v237 := lang.Apply(v236, []any{lang.NewSymbol("var")}) -v238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v239 := v238.FindInternedVar(lang.NewSymbol("list")) -if v239.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v239))) +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +v9 := lang.Apply(lang.NewKeyword("test"), []any{v8}) +var v4 any = v9 +_ = v4 +var v11 any +if lang.IsTruthy(v4) { +v12 := lang.Apply(v4, nil) +_ = v12 +v11 = lang.NewKeyword("ok") +} else { +v11 = lang.NewKeyword("no-test") } -v240 := v239.Get() -v241 := lang.Apply(v240, []any{v5}) -v242 := lang.Apply(v233, []any{v237, v241}) -v243 := lang.Apply(v230, []any{v242}) -v244 := lang.Apply(v227, []any{v243}) -v245 := lang.Apply(v55, []any{v59, v169, v217, v224, v244}) -v246 := lang.Apply(v52, []any{v245}) -return v246 - } +return v11 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -72945,29 +73358,103 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// print-dup +// the-ns { -v0 := lang.NewSymbol("print-dup").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3667), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(3667), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, nil, true) +v0 := lang.NewSymbol("the-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "If passed a namespace, returns it. Else, when passed a symbol,\n returns the namespace named by it, throwing an exception if not\n found.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4152), lang.NewKeyword("end-line"), int(4152))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.Apply(v7, []any{lang1.*Namespace, v3}) +if lang.IsTruthy(v8) { +v4 = v3 +} else { +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("find-ns")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{v3}) +var v9 any = v13 +_ = v9 +var v15 any +if lang.IsTruthy(v9) { +v15 = v9 +} else { +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("str")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{"No namespace: ", v3, " found"}) +v20 := lang.Apply(Exception16., []any{v19}) +panic(v20) +} +v4 = v15 +} +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// force +// thread-bound? { -v0 := lang.NewSymbol("force").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "If x is a Delay, returns the (possibly cached) value of its expression, else returns x", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(754), lang.NewKeyword("end-line"), int(754))).(*lang.Symbol) +v0 := lang.NewSymbol("thread-bound?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("vars"))), lang.NewKeyword("doc"), "Returns true if all of the vars provided as arguments have thread-local bindings.\n Implies that set!'ing the provided vars will succeed. Returns true if no vars are provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5542), lang.NewKeyword("end-line"), int(5542))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := lang.NewList(args[0:]...) +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("every?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +var v7 lang.FnFunc +v7 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := args[0] -v4, _ := lang.FieldOrMethod(glojure.lang11.Delay, "force") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("force is not a function"))) +v8 := args[0] +v9, ok := lang.FieldOrMethod(v8, "getThreadBinding") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "getThreadBinding"))) } -v5 := lang.Apply(v4, []any{v3}) -return v5 +var v10 any +switch reflect.TypeOf(v9).Kind() { +case reflect.Func: + v10 = lang.Apply(v9, nil) +default: + v10 = v9 +} +return v10 +}) +v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5548), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5548), lang.NewKeyword("end-column"), int(78)) +v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v10 := lang.Apply(v6, []any{v9, v3}) +return v10 + } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -72975,337 +73462,786 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// with-local-vars +// throw-if { -v0 := lang.NewSymbol("with-local-vars").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name-vals-vec"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "varbinding=> symbol init-expr\n\n Executes the exprs in a context in which the symbols are bound to\n vars with per-thread bindings to the init-exprs. The symbols refer\n to the var objects themselves, and must be accessed with var-get and\n var-set", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4339), lang.NewKeyword("end-line"), int(4339))).(*lang.Symbol) +v0 := lang.NewSymbol("throw-if").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("fmt"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Throws a CompilerException with a message if pred is true", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5875), lang.NewKeyword("end-line"), int(5875), lang.NewKeyword("private"), true)).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 3 { + if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -var v7 any +v5 := lang.NewList(args[2:]...) +var v6 any +if lang.IsTruthy(v3) { v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) +v9 := v8.FindInternedVar(lang.NewSymbol("apply")) if v9.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } v10 := v9.Get() -v11 := lang.Apply(v10, []any{v5}) -if lang.IsTruthy(v11) { -v7 = nil +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("format")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v10, []any{v13, v4, v5}) +var v7 any = v14 +_ = v7 +v16 := lang.Apply(Exception16., []any{v7}) +var v15 any = v16 +_ = v15 +v18, ok := lang.FieldOrMethod(v15, "getStackTrace") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v15, "getStackTrace"))) +} +var v19 any +switch reflect.TypeOf(v18).Kind() { +case reflect.Func: + v19 = lang.Apply(v18, nil) +default: + v19 = v18 +} +var v17 any = v19 +_ = v17 +var v21 lang.FnFunc +v21 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v22 := args[0] +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("not=")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26, ok := lang.FieldOrMethod(v22, "getMethodName") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v22, "getMethodName"))) +} +var v27 any +switch reflect.TypeOf(v26).Kind() { +case reflect.Func: + v27 = lang.Apply(v26, nil) +default: + v27 = v26 +} +v28 := lang.Apply(v25, []any{v27, "doInvoke"}) +return v28 +}) +v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5882), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(5882), lang.NewKeyword("end-column"), int(74)) +v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v20 any = v23 +_ = v20 +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("into-array")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("drop")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("drop-while")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v20, v17}) +v35 := lang.Apply(v30, []any{int64(2), v34}) +v36 := lang.Apply(v27, []any{nil, v35}) +var v24 any = v36 +_ = v24 +v38, _ := lang.FieldOrMethod(v15, "setStackTrace") +if reflect.TypeOf(v38).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setStackTrace is not a function"))) +} +v39 := lang.Apply(v38, []any{v24}) +_ = v39 +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("*file*")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43, ok := lang.FieldOrMethod(nil, "Deref") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "Deref"))) +} +var v44 any +switch reflect.TypeOf(v43).Kind() { +case reflect.Func: + v44 = lang.Apply(v43, nil) +default: + v44 = v43 +} +v45, ok := lang.FieldOrMethod(nil, "Deref") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "Deref"))) +} +var v46 any +switch reflect.TypeOf(v45).Kind() { +case reflect.Func: + v46 = lang.Apply(v45, nil) +default: + v46 = v45 +} +v47 := lang.Apply(CompilerException33., []any{v42, v44, v46, v15}) +panic(v47) } else { +v6 = nil +} +return v6 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// time +{ +v0 := lang.NewSymbol("time").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"))), lang.NewKeyword("doc"), "Evaluates expr and prints the time it took. Returns the value of\n expr.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3885), lang.NewKeyword("end-line"), int(3885))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("seq")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) +} +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("concat")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("str")) +v13 := v12.FindInternedVar(lang.NewSymbol("list")) if v13.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("first")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +v15 := lang.Apply(v14, []any{lang.NewSymbol("glojure.core/let")}) +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("list")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v3}) +v18 := v17.Get() v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) +v20 := v19.FindInternedVar(lang.NewSymbol("apply")) if v20.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } v21 := v20.Get() v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("meta")) +v23 := v22.FindInternedVar(lang.NewSymbol("vector")) if v23.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) -v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) -v28 := lang.Apply(lang1.NewIllegalArgumentError, []any{v27}) -panic(v28) +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("seq")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -_ = v7 -var v29 any -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("even?")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("concat")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("count")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v5}) -v37 := lang.Apply(v32, []any{v36}) -if lang.IsTruthy(v37) { -v29 = nil -} else { +v33 := v32.Get() +v34 := lang.Apply(v33, []any{lang.NewSymbol("start__0__auto__")}) +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("list")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("str")) +v39 := v38.FindInternedVar(lang.NewSymbol("seq")) if v39.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) } v40 := v39.Get() v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("first")) +v42 := v41.FindInternedVar(lang.NewSymbol("concat")) if v42.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } v43 := v42.Get() -v44 := lang.Apply(v43, []any{v3}) -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } -v47 := v46.Get() +v46 := v45.Get() +v47 := lang.Apply(v46, []any{lang.NewSymbol(".UnixNano")}) v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("meta")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) if v49.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) } v50 := v49.Get() -v51 := lang.Apply(v50, []any{v3}) -v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) -v53 := lang.Apply(v40, []any{v44, " requires ", "an even number of forms in binding vector", " in ", v47, ":", v52}) -v54 := lang.Apply(lang1.NewIllegalArgumentError, []any{v53}) -panic(v54) -} -_ = v29 -_ = nil -v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v56 := v55.FindInternedVar(lang.NewSymbol("seq")) -if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) -} -v57 := v56.Get() -v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v59 := v58.FindInternedVar(lang.NewSymbol("concat")) -if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) +v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v52 := v51.FindInternedVar(lang.NewSymbol("seq")) +if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) } -v60 := v59.Get() -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("list")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +v53 := v52.Get() +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("concat")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) } -v63 := v62.Get() -v64 := lang.Apply(v63, []any{lang.NewSymbol("glojure.core/let")}) -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("list")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +v56 := v55.Get() +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("list")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) } -v67 := v66.Get() -v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v69 := v68.FindInternedVar(lang.NewSymbol("apply")) -if v69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) +v59 := v58.Get() +v60 := lang.Apply(v59, []any{lang.NewSymbol("time.Now")}) +v61 := lang.Apply(v56, []any{v60}) +v62 := lang.Apply(v53, []any{v61}) +v63 := lang.Apply(v50, []any{v62}) +v64 := lang.Apply(v43, []any{v47, v63}) +v65 := lang.Apply(v40, []any{v64}) +v66 := lang.Apply(v37, []any{v65}) +v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v68 := v67.FindInternedVar(lang.NewSymbol("list")) +if v68.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) } -v70 := v69.Get() +v69 := v68.Get() +v70 := lang.Apply(v69, []any{lang.NewSymbol("ret__1__auto__")}) v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v72 := v71.FindInternedVar(lang.NewSymbol("vector")) +v72 := v71.FindInternedVar(lang.NewSymbol("list")) if v72.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) } v73 := v72.Get() -v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v75 := v74.FindInternedVar(lang.NewSymbol("seq")) -if v75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) +v74 := lang.Apply(v73, []any{v5}) +v75 := lang.Apply(v30, []any{v34, v66, v70, v74}) +v76 := lang.Apply(v27, []any{v75}) +v77 := lang.Apply(v21, []any{v24, v76}) +v78 := lang.Apply(v18, []any{v77}) +v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v80 := v79.FindInternedVar(lang.NewSymbol("list")) +if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) } -v76 := v75.Get() -v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v78 := v77.FindInternedVar(lang.NewSymbol("concat")) -if v78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) +v81 := v80.Get() +v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v83 := v82.FindInternedVar(lang.NewSymbol("seq")) +if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) } -v79 := v78.Get() -v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v81 := v80.FindInternedVar(lang.NewSymbol("interleave")) -if v81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) +v84 := v83.Get() +v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v86 := v85.FindInternedVar(lang.NewSymbol("concat")) +if v86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) } -v82 := v81.Get() -v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v84 := v83.FindInternedVar(lang.NewSymbol("take-nth")) -if v84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) +v87 := v86.Get() +v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v89 := v88.FindInternedVar(lang.NewSymbol("list")) +if v89.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) } -v85 := v84.Get() -v86 := lang.Apply(v85, []any{int64(2), v5}) -v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v88 := v87.FindInternedVar(lang.NewSymbol("repeat")) -if v88.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) +v90 := v89.Get() +v91 := lang.Apply(v90, []any{lang.NewSymbol("glojure.core/prn")}) +v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v93 := v92.FindInternedVar(lang.NewSymbol("list")) +if v93.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) } -v89 := v88.Get() -v90 := lang.Apply(v89, []any{lang.NewList(lang.NewSymbol(".."), lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.*Var"), lang.NewSymbol("create"), lang.NewSymbol("setDynamic"))}) -v91 := lang.Apply(v82, []any{v86, v90}) -v92 := lang.Apply(v79, []any{v91}) -v93 := lang.Apply(v76, []any{v92}) -v94 := lang.Apply(v70, []any{v73, v93}) -v95 := lang.Apply(v67, []any{v94}) -v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v97 := v96.FindInternedVar(lang.NewSymbol("list")) -if v97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) +v94 := v93.Get() +v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v96 := v95.FindInternedVar(lang.NewSymbol("seq")) +if v96.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) } -v98 := v97.Get() -v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v100 := v99.FindInternedVar(lang.NewSymbol("seq")) -if v100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) +v97 := v96.Get() +v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v99 := v98.FindInternedVar(lang.NewSymbol("concat")) +if v99.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) } -v101 := v100.Get() -v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v103 := v102.FindInternedVar(lang.NewSymbol("concat")) -if v103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) +v100 := v99.Get() +v101 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v102 := v101.FindInternedVar(lang.NewSymbol("list")) +if v102.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v102))) } -v104 := v103.Get() +v103 := v102.Get() +v104 := lang.Apply(v103, []any{lang.NewSymbol("glojure.core/str")}) v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v106 := v105.FindInternedVar(lang.NewSymbol("list")) if v106.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) } v107 := v106.Get() -v108 := lang.Apply(v107, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.PushThreadBindings")}) +v108 := lang.Apply(v107, []any{"Elapsed time: "}) v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v110 := v109.FindInternedVar(lang.NewSymbol("list")) if v110.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) } -v111 := v110.Get() -v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v113 := v112.FindInternedVar(lang.NewSymbol("apply")) -if v113.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) +v111 := v110.Get() +v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v113 := v112.FindInternedVar(lang.NewSymbol("seq")) +if v113.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) +} +v114 := v113.Get() +v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v116 := v115.FindInternedVar(lang.NewSymbol("concat")) +if v116.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) +} +v117 := v116.Get() +v118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v119 := v118.FindInternedVar(lang.NewSymbol("list")) +if v119.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v119))) +} +v120 := v119.Get() +v121 := lang.Apply(v120, []any{lang.NewSymbol("glojure.core//")}) +v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v123 := v122.FindInternedVar(lang.NewSymbol("list")) +if v123.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) +} +v124 := v123.Get() +v125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v126 := v125.FindInternedVar(lang.NewSymbol("seq")) +if v126.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v126))) +} +v127 := v126.Get() +v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v129 := v128.FindInternedVar(lang.NewSymbol("concat")) +if v129.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v129))) +} +v130 := v129.Get() +v131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v132 := v131.FindInternedVar(lang.NewSymbol("list")) +if v132.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v132))) +} +v133 := v132.Get() +v134 := lang.Apply(v133, []any{lang.NewSymbol("glojure.core/double")}) +v135 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v136 := v135.FindInternedVar(lang.NewSymbol("list")) +if v136.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v136))) +} +v137 := v136.Get() +v138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v139 := v138.FindInternedVar(lang.NewSymbol("seq")) +if v139.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v139))) +} +v140 := v139.Get() +v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v142 := v141.FindInternedVar(lang.NewSymbol("concat")) +if v142.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) +} +v143 := v142.Get() +v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v145 := v144.FindInternedVar(lang.NewSymbol("list")) +if v145.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) +} +v146 := v145.Get() +v147 := lang.Apply(v146, []any{lang.NewSymbol("glojure.core/-")}) +v148 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v149 := v148.FindInternedVar(lang.NewSymbol("list")) +if v149.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v149))) +} +v150 := v149.Get() +v151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v152 := v151.FindInternedVar(lang.NewSymbol("seq")) +if v152.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v152))) +} +v153 := v152.Get() +v154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v155 := v154.FindInternedVar(lang.NewSymbol("concat")) +if v155.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v155))) +} +v156 := v155.Get() +v157 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v158 := v157.FindInternedVar(lang.NewSymbol("list")) +if v158.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v158))) +} +v159 := v158.Get() +v160 := lang.Apply(v159, []any{lang.NewSymbol(".UnixNano")}) +v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v162 := v161.FindInternedVar(lang.NewSymbol("list")) +if v162.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) +} +v163 := v162.Get() +v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v165 := v164.FindInternedVar(lang.NewSymbol("seq")) +if v165.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) +} +v166 := v165.Get() +v167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v168 := v167.FindInternedVar(lang.NewSymbol("concat")) +if v168.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v168))) +} +v169 := v168.Get() +v170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v171 := v170.FindInternedVar(lang.NewSymbol("list")) +if v171.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v171))) +} +v172 := v171.Get() +v173 := lang.Apply(v172, []any{lang.NewSymbol("time.Now")}) +v174 := lang.Apply(v169, []any{v173}) +v175 := lang.Apply(v166, []any{v174}) +v176 := lang.Apply(v163, []any{v175}) +v177 := lang.Apply(v156, []any{v160, v176}) +v178 := lang.Apply(v153, []any{v177}) +v179 := lang.Apply(v150, []any{v178}) +v180 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v181 := v180.FindInternedVar(lang.NewSymbol("list")) +if v181.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v181))) +} +v182 := v181.Get() +v183 := lang.Apply(v182, []any{lang.NewSymbol("start__0__auto__")}) +v184 := lang.Apply(v143, []any{v147, v179, v183}) +v185 := lang.Apply(v140, []any{v184}) +v186 := lang.Apply(v137, []any{v185}) +v187 := lang.Apply(v130, []any{v134, v186}) +v188 := lang.Apply(v127, []any{v187}) +v189 := lang.Apply(v124, []any{v188}) +v190 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v191 := v190.FindInternedVar(lang.NewSymbol("list")) +if v191.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v191))) +} +v192 := v191.Get() +v193 := lang.Apply(v192, []any{nil}) +v194 := lang.Apply(v117, []any{v121, v189, v193}) +v195 := lang.Apply(v114, []any{v194}) +v196 := lang.Apply(v111, []any{v195}) +v197 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v198 := v197.FindInternedVar(lang.NewSymbol("list")) +if v198.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v198))) +} +v199 := v198.Get() +v200 := lang.Apply(v199, []any{" msecs"}) +v201 := lang.Apply(v100, []any{v104, v108, v196, v200}) +v202 := lang.Apply(v97, []any{v201}) +v203 := lang.Apply(v94, []any{v202}) +v204 := lang.Apply(v87, []any{v91, v203}) +v205 := lang.Apply(v84, []any{v204}) +v206 := lang.Apply(v81, []any{v205}) +v207 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v208 := v207.FindInternedVar(lang.NewSymbol("list")) +if v208.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v208))) +} +v209 := v208.Get() +v210 := lang.Apply(v209, []any{lang.NewSymbol("ret__1__auto__")}) +v211 := lang.Apply(v11, []any{v15, v78, v206, v210}) +v212 := lang.Apply(v8, []any{v211}) +return v212 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// to-array +{ +v0 := lang.NewSymbol("to-array").WithMeta(lang.NewMap(lang.NewKeyword("tag"), "[Ljava.lang.Object;", lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns an array of Objects containing the contents of coll, which\n can be any Collection. Maps to java.util.Collection.toArray().", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(337), lang.NewKeyword("end-line"), int(337))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, _ := lang.FieldOrMethod(runtime9.RT, "ToArray") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ToArray is not a function"))) +} +v5 := lang.Apply(v4, []any{v3}) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), "[Ljava.lang.Object;")).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// to-array-2d +{ +v0 := lang.NewSymbol("to-array-2d").WithMeta(lang.NewMap(lang.NewKeyword("tag"), "[[Ljava.lang.Object;", lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a (potentially-ragged) 2-dimensional array of Objects\n containing the contents of coll, which can be any Collection of any\n Collection.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4002), lang.NewKeyword("end-line"), int(4002))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("make-array")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8, _ := lang.FieldOrMethod(reflect.Type, "forName") +if reflect.TypeOf(v8).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("forName is not a function"))) +} +v9 := lang.Apply(v8, []any{"[Ljava.lang.Object;"}) +v10, _ := lang.FieldOrMethod(v3, "size") +if reflect.TypeOf(v10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("size is not a function"))) +} +v11 := lang.Apply(v10, []any{}) +v12 := lang.Apply(v7, []any{v9, v11}) +var v4 any = v12 +_ = v4 +var v14 any = int64(0) +_ = v14 +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("seq")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v3}) +var v15 any = v19 +_ = v15 +var v20 any +for { +var v21 any +if lang.IsTruthy(v15) { +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("aset")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("to-array")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("first")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{v15}) +v32 := lang.Apply(v27, []any{v31}) +v33 := lang.Apply(v24, []any{v4, v14, v32}) +_ = v33 +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("inc")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.Apply(v37, []any{v14}) +var v34 any = v38 +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("next")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) } -v114 := v113.Get() -v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v116 := v115.FindInternedVar(lang.NewSymbol("hash-map")) -if v116.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v15}) +var v39 any = v43 +v14 = v34 +v15 = v39 +continue +} else { +v21 = nil } -v117 := v116.Get() -v118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v119 := v118.FindInternedVar(lang.NewSymbol("seq")) -if v119.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v119))) +v20 = v21 + break } -v120 := v119.Get() -v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v122 := v121.FindInternedVar(lang.NewSymbol("concat")) -if v122.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) +_ = v20 +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), "[[Ljava.lang.Object;")).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v123 := v122.Get() -v124 := lang.Apply(v123, nil) -v125 := lang.Apply(v120, []any{v124}) -v126 := lang.Apply(v114, []any{v117, v125}) -v127 := lang.Apply(v111, []any{v126}) -v128 := lang.Apply(v104, []any{v108, v127}) -v129 := lang.Apply(v101, []any{v128}) -v130 := lang.Apply(v98, []any{v129}) -v131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v132 := v131.FindInternedVar(lang.NewSymbol("list")) -if v132.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v132))) } -v133 := v132.Get() -v134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v135 := v134.FindInternedVar(lang.NewSymbol("seq")) -if v135.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v135))) +// trampoline +{ +v0 := lang.NewSymbol("trampoline").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "trampoline can be used to convert algorithms requiring mutual\n recursion without stack consumption. Calls f with supplied args, if\n any. If f returns a fn, calls that fn with no arguments, and\n continues to repeat, until the return value is not a fn, then\n returns that non-fn value. Note that if you want to return a fn as a\n final value, you must wrap it in some data structure and unpack it\n after trampoline returns.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6336), lang.NewKeyword("end-line"), int(6336))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: +v3 := args[0] +recur_loop_1083: +v5 := lang.Apply(v3, nil) +var v4 any = v5 +_ = v4 +var v7 any +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("fn?")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v136 := v135.Get() -v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v138 := v137.FindInternedVar(lang.NewSymbol("concat")) -if v138.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v4}) +if lang.IsTruthy(v11) { +var v12 any = v4 +v3 = v12 +goto recur_loop_1083 +} else { +v7 = v4 } -v139 := v138.Get() -v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v141 := v140.FindInternedVar(lang.NewSymbol("list")) -if v141.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) +return v7 + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.NewList(args[1:]...) +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("trampoline")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v142 := v141.Get() -v143 := lang.Apply(v142, []any{lang.NewSymbol("try")}) -v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v145 := v144.FindInternedVar(lang.NewSymbol("list")) -if v145.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) +v7 := v6.Get() +var v8 lang.FnFunc +v8 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("apply")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -v146 := v145.Get() -v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v148 := v147.FindInternedVar(lang.NewSymbol("seq")) -if v148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v3, v4}) +return v12 +}) +v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6352), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(6352), lang.NewKeyword("end-column"), int(32)) +v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v149 := v148.Get() -v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v151 := v150.FindInternedVar(lang.NewSymbol("concat")) -if v151.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) +v11 := lang.Apply(v7, []any{v10}) +return v11 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v152 := v151.Get() -v153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v154 := v153.FindInternedVar(lang.NewSymbol("list")) -if v154.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v154))) } -v155 := v154.Get() -v156 := lang.Apply(v155, []any{lang.NewSymbol("finally")}) -v157 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v158 := v157.FindInternedVar(lang.NewSymbol("list")) -if v158.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v158))) +// transduce +{ +v0 := lang.NewSymbol("transduce").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "reduce with a transformation of f (xf). If init is not\n supplied, (f) will be called to produce it. f should be a reducing\n step function that accepts both 1 and 2 arguments, if it accepts\n only 2 you can add the arity-1 with 'completing'. Returns the result\n of applying (the transformed) xf to init and the first item in coll,\n then applying xf to that result and the 2nd item, etc. If coll\n contains no items, returns init and f is not called. Note that\n certain transforms may inject or skip items.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6948), lang.NewKeyword("end-line"), int(6948))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("transduce")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v159 := v158.Get() -v160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v161 := v160.FindInternedVar(lang.NewSymbol("seq")) -if v161.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v161))) +v8 := v7.Get() +v9 := lang.Apply(v4, nil) +v10 := lang.Apply(v8, []any{v3, v4, v9, v5}) +return v10 + case 4: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v8 := lang.Apply(v3, []any{v7}) +var v7 any = v8 +_ = v7 +var v10 any +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("instance?")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v162 := v161.Get() -v163 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v164 := v163.FindInternedVar(lang.NewSymbol("concat")) -if v164.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v164))) +v13 := v12.Get() +v14 := lang.Apply(v13, []any{lang1.IReduceInit, v6}) +if lang.IsTruthy(v14) { +v15, _ := lang.FieldOrMethod(v6, "ReduceInit") +if reflect.TypeOf(v15).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) } -v165 := v164.Get() -v166 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v167 := v166.FindInternedVar(lang.NewSymbol("list")) -if v167.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v167))) +v16 := lang.Apply(v15, []any{v7, v5}) +v10 = v16 +} else { +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core.protocols")) +v18 := v17.FindInternedVar(lang.NewSymbol("coll-reduce")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v168 := v167.Get() -v169 := lang.Apply(v168, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.PopThreadBindings")}) -v170 := lang.Apply(v165, []any{v169}) -v171 := lang.Apply(v162, []any{v170}) -v172 := lang.Apply(v159, []any{v171}) -v173 := lang.Apply(v152, []any{v156, v172}) -v174 := lang.Apply(v149, []any{v173}) -v175 := lang.Apply(v146, []any{v174}) -v176 := lang.Apply(v139, []any{v143, v6, v175}) -v177 := lang.Apply(v136, []any{v176}) -v178 := lang.Apply(v133, []any{v177}) -v179 := lang.Apply(v60, []any{v64, v95, v130, v178}) -v180 := lang.Apply(v57, []any{v179}) -return v180 +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v6, v7, v5}) +v10 = v20 +} +var v9 any = v10 +_ = v9 +v22 := lang.Apply(v7, []any{v9}) +return v22 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -73314,32 +74250,27 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// constantly +// transient { -v0 := lang.NewSymbol("constantly").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns a function that takes any number of arguments and returns x.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1440), lang.NewKeyword("end-line"), int(1440))).(*lang.Symbol) +v0 := lang.NewSymbol("transient").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a new, transient version of the collection, in constant time.\n\n Transients support a parallel set of 'changing' operations, with similar names\n followed by ! - assoc!, conj! etc. These do the same things as their persistent\n counterparts except the return values are themselves transient.\n\n Note in particular that transients are not designed to be bashed in-place. You\n must capture and use the return value in the next call. In this way, they support\n the same code structure as the functional persistent code they replace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3335), lang.NewKeyword("end-line"), int(3335))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := lang.NewList(args[0:]...) -return v3 - } -}) -v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1444), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(1444), lang.NewKeyword("end-column"), int(21)) -v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) -if err != nil { - panic(err) +v4, ok := lang.FieldOrMethod(v3, "AsTransient") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "AsTransient"))) } -return v6 +var v5 any +switch reflect.TypeOf(v4).Kind() { +case reflect.Func: + v5 = lang.Apply(v4, nil) +default: + v5 = v4 +} +return v5 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -73347,200 +74278,346 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// nthnext +// tree-seq { -v0 := lang.NewSymbol("nthnext").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns the nth next of coll, (seq coll) when n is 0.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3147), lang.NewKeyword("end-line"), int(3147))).(*lang.Symbol) +v0 := lang.NewSymbol("tree-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("branch?"), lang.NewSymbol("children"), lang.NewSymbol("root"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the nodes in a tree, via a depth-first walk.\n branch? must be a fn of one arg that returns true if passed a node\n that can have children (but may not). children must be a fn of one\n arg that returns a sequence of the children. Will only be called on\n nodes for which branch? returns true. Root is the root node of the\n tree.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4955), lang.NewKeyword("end-line"), int(4955))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { + if len(args) != 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] v4 := args[1] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{lang1.IDrop, v3}) -if lang.IsTruthy(v9) { -var v10 any +v5 := args[2] +var v7 lang.FnFunc +{ // function walk +v7 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v9 := args[0] +var v10 lang.FnFunc +v10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("pos?")) +v12 := v11.FindInternedVar(lang.NewSymbol("cons")) if v12.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } v13 := v12.Get() -v14 := lang.Apply(v13, []any{v4}) -if lang.IsTruthy(v14) { -var v15 any +var v14 any +v15 := lang.Apply(v3, []any{v9}) +if lang.IsTruthy(v15) { v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("int?")) +v17 := v16.FindInternedVar(lang.NewSymbol("mapcat")) if v17.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } v18 := v17.Get() -v19 := lang.Apply(v18, []any{v4}) -if lang.IsTruthy(v19) { -v15 = v4 +v19 := lang.Apply(v4, []any{v9}) +v20 := lang.Apply(v18, []any{v8, v19}) +v14 = v20 } else { -v20 := lang.Apply(nil, []any{v4}) -v15 = v20 +v14 = nil } -v21, _ := lang.FieldOrMethod(v3, "drop") -if reflect.TypeOf(v21).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("drop is not a function"))) +v21 := lang.Apply(v13, []any{v9, v14}) +return v21 +}) +v11 := lang.Apply(lang1.NewLazySeq, []any{v10}) +return v11 +}) +v8 := v7 +_ = v8 } -v22 := lang.Apply(v21, []any{v15}) -v10 = v22 -} else { -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("seq")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4965), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(4969), lang.NewKeyword("end-column"), int(53)) +v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v25 := v24.Get() -v26 := lang.Apply(v25, []any{v3}) -v10 = v26 +var v6 any = v9 +_ = v6 +v11 := lang.Apply(v6, []any{v5}) +return v11 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v5 = v10 -} else { -var v27 any = v27 -_ = v27 -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("seq")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) } -v31 := v30.Get() -v32 := lang.Apply(v31, []any{v3}) -var v28 any = v32 -_ = v28 -var v33 any -for { -var v34 any -var v35 any = v28 -_ = v35 -var v37 any -if lang.IsTruthy(v35) { -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("pos?")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +// true? +{ +v1 := reflect.TypeOf(false) +v0 := lang.NewSymbol("true?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is the value true, false otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(511), lang.NewKeyword("end-line"), int(511))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := lang.Apply(lang1.Identical, []any{v4, true}) +return v5 +}) +v4 := reflect.TypeOf(false) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v40 := v39.Get() -v41 := lang.Apply(v40, []any{v27}) -v37 = v41 +} +// type +{ +v0 := lang.NewSymbol("type").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns the :type metadata of x, or its Class if none", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3467), lang.NewKeyword("end-line"), int(3467))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("get")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("meta")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v3}) +v12 := lang.Apply(v7, []any{v11, lang.NewKeyword("type")}) +var v4 any = v12 +_ = v4 +var v14 any +if lang.IsTruthy(v4) { +v14 = v4 } else { -v37 = v35 +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("class")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v3}) +v14 = v18 +} +return v14 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// unchecked-add +{ +var v1 lang.FnFunc +{ // function unchecked-add__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("concat")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("list")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("seq")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("concat")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("list")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/unchecked_add")}) +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) } -if lang.IsTruthy(v37) { +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("dec")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) if v37.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) } v38 := v37.Get() -v39 := lang.Apply(v38, []any{v27}) -var v35 any = v39 -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("next")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v28}) -var v40 any = v44 -v27 = v35 -v28 = v40 -continue -} else { -v34 = v28 -} -v33 = v34 - break +v39 := lang.Apply(v38, []any{v4}) +v40 := lang.Apply(v27, []any{v31, v35, v39}) +v41 := lang.Apply(v24, []any{v40}) +v42 := lang.Apply(v21, []any{v41}) +v43 := lang.Apply(v10, []any{v14, v18, v42}) +v44 := lang.Apply(v7, []any{v43}) +return v44 +}) +v2 := v1 +_ = v2 } -v5 = v33 +v0 := lang.NewSymbol("unchecked-add").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the sum of x and y, both long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1203), lang.NewKeyword("end-line"), int(1203))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := args[1] +v6, _ := lang.FieldOrMethod(lang1.Numbers, "unchecked_add") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_add is not a function"))) } -return v5 +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// floats +// unchecked-add-int { var v1 lang.FnFunc -{ // function floats +{ // function unchecked-add-int__inliner v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { + if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("concat")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("list")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v13 := v12.Get() +v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v20 := v19.Get() -v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/floats")}) +v21 := v20.Get() v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("list")) +v23 := v22.FindInternedVar(lang.NewSymbol("seq")) if v23.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v26 := lang.Apply(v9, []any{v13, v17, v21, v25}) -v27 := lang.Apply(v6, []any{v26}) -return v27 +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("concat")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("list")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/unchecked_int_add")}) +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v4}) +v40 := lang.Apply(v27, []any{v31, v35, v39}) +v41 := lang.Apply(v24, []any{v40}) +v42 := lang.Apply(v21, []any{v41}) +v43 := lang.Apply(v10, []any{v14, v18, v42}) +v44 := lang.Apply(v7, []any{v43}) +return v44 }) v2 := v1 _ = v2 } -v0 := lang.NewSymbol("floats").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Casts to float[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5392), lang.NewKeyword("end-line"), int(5392))).(*lang.Symbol) +v0 := lang.NewSymbol("unchecked-add-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the sum of x and y, both int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1196), lang.NewKeyword("end-line"), int(1196))).(*lang.Symbol) var v3 lang.FnFunc v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { + if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "floats") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("floats is not a function"))) +v5 := args[1] +v6, _ := lang.FieldOrMethod(lang1.Numbers, "unchecked_int_add") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_add is not a function"))) } -v6 := lang.Apply(v5, []any{v4}) -return v6 +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 }) v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v2 := ns.InternWithValue(v0, v3, true) @@ -73548,10 +74625,10 @@ if v0.Meta() != nil { v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// neg? +// unchecked-byte { var v1 lang.FnFunc -{ // function neg?__inliner +{ // function unchecked-byte__inliner v1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -73582,7 +74659,7 @@ if v15.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v19 := v18.FindInternedVar(lang.NewSymbol("list")) if v19.IsMacro() { @@ -73607,7 +74684,7 @@ if v28.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/isNeg")}) +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/UncheckedByteCast")}) v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v32 := v31.FindInternedVar(lang.NewSymbol("list")) if v32.IsMacro() { @@ -73625,19 +74702,15 @@ return v39 v2 := v1 _ = v2 } -v0 := lang.NewSymbol("neg?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns true if num is less than zero, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1259), lang.NewKeyword("end-line"), int(1259))).(*lang.Symbol) +v0 := lang.NewSymbol("unchecked-byte").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to byte. Subject to rounding or truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3517), lang.NewKeyword("end-line"), int(3517))).(*lang.Symbol) var v3 lang.FnFunc v3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "isNeg") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("isNeg is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 +v5 := lang.Apply(lang1.UncheckedByteCast, []any{v4}) +return v5 }) v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v2 := ns.InternWithValue(v0, v3, true) @@ -73645,207 +74718,48 @@ if v0.Meta() != nil { v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// alter-var-root -{ -v0 := lang.NewSymbol("alter-var-root").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("v"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Atomically alters the root binding of var v by applying f to its\n current value plus any args", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5527), lang.NewKeyword("end-line"), int(5527))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -v6, _ := lang.FieldOrMethod(v3, "alterRoot") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("alterRoot is not a function"))) -} -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// seq +// unchecked-char { -v1 := reflect.TypeOf((*lang1.ISeq)(nil)).Elem() -v0 := lang.NewSymbol("seq").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a seq on the collection. If the collection is\n empty, returns nil. (seq nil) returns nil. seq also works on\n Strings, native Java arrays (of reference types) and any objects\n that implement Iterable. Note that seqs cache values, thus seq\n should not be used on any Iterable whose iterator repeatedly\n returns the same mutable object.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(4), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(126), lang.NewKeyword("end-line"), int(136))).(*lang.Symbol) -var v3 lang.FnFunc -{ // function seq -v3 = lang.NewFnFunc(func(args ...any) any { +var v1 lang.FnFunc +{ // function unchecked-char__inliner +v1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v5 := args[0] -v6 := lang.Apply(lang1.Seq, []any{v5}) -return v6 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(136), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(136), lang.NewKeyword("end-column"), int(126))).(lang.FnFunc) -v4 := v3 -_ = v4 -} -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -// some-> -{ -v0 := lang.NewSymbol("some->").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "When expr is not nil, threads it into the first form (via ->),\n and when that result is not nil, through the next etc", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7653), lang.NewKeyword("end-line"), int(7653))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("gensym")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v10 := v9.Get() -v11 := lang.Apply(v10, nil) -var v7 any = v11 -_ = v7 -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("map")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v15 := v14.Get() -var v16 lang.FnFunc -v16 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v17 := args[0] +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("seq")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) if v19.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } v20 := v19.Get() v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("concat")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("list")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v26, []any{lang.NewSymbol("if")}) -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("list")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("seq")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("concat")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("list")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.Apply(v39, []any{lang.NewSymbol("glojure.core/nil?")}) -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("list")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v7}) -v45 := lang.Apply(v36, []any{v40, v44}) -v46 := lang.Apply(v33, []any{v45}) -v47 := lang.Apply(v30, []any{v46}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{nil}) -v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("list")) -if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) -} -v54 := v53.Get() -v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v56 := v55.FindInternedVar(lang.NewSymbol("seq")) -if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) -} -v57 := v56.Get() -v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v59 := v58.FindInternedVar(lang.NewSymbol("concat")) -if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) -} -v60 := v59.Get() -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("list")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) -} -v63 := v62.Get() -v64 := lang.Apply(v63, []any{lang.NewSymbol("glojure.core/->")}) -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("list")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) -} -v67 := v66.Get() -v68 := lang.Apply(v67, []any{v7}) -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("list")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) -} -v71 := v70.Get() -v72 := lang.Apply(v71, []any{v17}) -v73 := lang.Apply(v60, []any{v64, v68, v72}) -v74 := lang.Apply(v57, []any{v73}) -v75 := lang.Apply(v54, []any{v74}) -v76 := lang.Apply(v23, []any{v27, v47, v51, v75}) -v77 := lang.Apply(v20, []any{v76}) -return v77 -}) -v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7659), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7659), lang.NewKeyword("end-column"), int(64)) -v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v19 := lang.Apply(v15, []any{v18, v6}) -var v12 any = v19 -_ = v12 -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v22 := v21.FindInternedVar(lang.NewSymbol("seq")) if v22.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) @@ -73863,118 +74777,48 @@ if v28.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/let")}) +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/UncheckedCharCast")}) v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v32 := v31.FindInternedVar(lang.NewSymbol("list")) if v32.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("apply")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("vector")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("seq")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("concat")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("list")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) -} -v48 := v47.Get() -v49 := lang.Apply(v48, []any{v7}) -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("list")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.Apply(v52, []any{v5}) -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("interleave")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) -} -v56 := v55.Get() -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("repeat")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) -} -v59 := v58.Get() -v60 := lang.Apply(v59, []any{v7}) -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("butlast")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) -} -v63 := v62.Get() -v64 := lang.Apply(v63, []any{v12}) -v65 := lang.Apply(v56, []any{v60, v64}) -v66 := lang.Apply(v45, []any{v49, v53, v65}) -v67 := lang.Apply(v42, []any{v66}) -v68 := lang.Apply(v36, []any{v39, v67}) -v69 := lang.Apply(v33, []any{v68}) -v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v71 := v70.FindInternedVar(lang.NewSymbol("list")) -if v71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) -} -v72 := v71.Get() -var v73 any -v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v75 := v74.FindInternedVar(lang.NewSymbol("empty?")) -if v75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) -} -v76 := v75.Get() -v77 := lang.Apply(v76, []any{v12}) -if lang.IsTruthy(v77) { -v73 = v7 -} else { -v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v79 := v78.FindInternedVar(lang.NewSymbol("last")) -if v79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) -} -v80 := v79.Get() -v81 := lang.Apply(v80, []any{v12}) -v73 = v81 +v34 := lang.Apply(v33, []any{v3}) +v35 := lang.Apply(v26, []any{v30, v34}) +v36 := lang.Apply(v23, []any{v35}) +v37 := lang.Apply(v20, []any{v36}) +v38 := lang.Apply(v9, []any{v13, v17, v37}) +v39 := lang.Apply(v6, []any{v38}) +return v39 +}) +v2 := v1 +_ = v2 } -v82 := lang.Apply(v72, []any{v73}) -v83 := lang.Apply(v26, []any{v30, v69, v82}) -v84 := lang.Apply(v23, []any{v83}) -return v84 +v0 := lang.NewSymbol("unchecked-char").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to char. Subject to rounding or truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3529), lang.NewKeyword("end-line"), int(3529))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } +v4 := args[0] +v5, _ := lang.FieldOrMethod(runtime9.RT, "UncheckedCharCast") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedCharCast is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// bytes +// unchecked-dec { var v1 lang.FnFunc -{ // function bytes +{ // function unchecked-dec__inliner v1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -74012,31 +74856,52 @@ if v19.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } v20 := v19.Get() -v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/bytes")}) -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("list")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v26 := lang.Apply(v9, []any{v13, v17, v21, v25}) -v27 := lang.Apply(v6, []any{v26}) -return v27 +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/unchecked_dec")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v3}) +v35 := lang.Apply(v26, []any{v30, v34}) +v36 := lang.Apply(v23, []any{v35}) +v37 := lang.Apply(v20, []any{v36}) +v38 := lang.Apply(v9, []any{v13, v17, v37}) +v39 := lang.Apply(v6, []any{v38}) +return v39 }) v2 := v1 _ = v2 } -v0 := lang.NewSymbol("bytes").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Casts to bytes[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5377), lang.NewKeyword("end-line"), int(5377))).(*lang.Symbol) +v0 := lang.NewSymbol("unchecked-dec").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns a number one less than x, a long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1175), lang.NewKeyword("end-line"), int(1175))).(*lang.Symbol) var v3 lang.FnFunc v3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "bytes") +v5, _ := lang.FieldOrMethod(lang1.Numbers, "unchecked_dec") if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("bytes is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_dec is not a function"))) } v6 := lang.Apply(v5, []any{v4}) return v6 @@ -74047,1062 +74912,779 @@ if v0.Meta() != nil { v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// key -{ -v0 := lang.NewSymbol("key").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("e"))), lang.NewKeyword("doc"), "Returns the key of the map entry.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1563), lang.NewKeyword("end-line"), int(1563))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, _ := lang.FieldOrMethod(v3, "GetKey") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("GetKey is not a function"))) -} -v5 := lang.Apply(v4, []any{}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// parsing-err +// unchecked-dec-int { -v0 := lang.NewSymbol("parsing-err").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Construct message for parsing for non-string parsing error", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(7964), lang.NewKeyword("end-line"), int(7964), lang.NewKeyword("private"), true)).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { +var v1 lang.FnFunc +{ // function unchecked-dec-int__inliner +v1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("str")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -var v7 any -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("nil?")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v3}) -if lang.IsTruthy(v11) { -v7 = "nil" -} else { -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("class")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v3}) -v16, ok := lang.FieldOrMethod(v15, "Name") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v15, "Name"))) -} -var v17 any -switch reflect.TypeOf(v16).Kind() { -case reflect.Func: - v17 = lang.Apply(v16, nil) -default: - v17 = v16 -} -v7 = v17 -} -v18 := lang.Apply(v6, []any{"Expected string, got ", v7}) -return v18 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// definline -{ -v0 := lang.NewSymbol("definline").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("decl"))), lang.NewKeyword("doc"), "Experimental - like defmacro, except defines a named function whose\n body is the expansion, calls to which may be expanded inline as if\n it were a macro. Cannot be used with variadic (&) args.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5253), lang.NewKeyword("end-line"), int(5253))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("split-with")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("comp")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v13 := v12.Get() +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("not")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) if v15.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } v16 := v15.Get() -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("vector?")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v13, []any{v16, v19}) -v21 := lang.Apply(v10, []any{v20, v6}) -var v7 any = v21 -_ = v7 -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("nth")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{v7, int64(0), nil}) -var v22 any = v26 -_ = v22 -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("nth")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{v7, int64(1), nil}) -var v27 any = v31 -_ = v27 -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("nth")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v27, int64(0), nil}) -var v32 any = v36 -_ = v32 -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("nth")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.Apply(v40, []any{v27, int64(1), nil}) -var v37 any = v41 -_ = v37 -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("seq")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("concat")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) -} -v48 := v47.Get() -v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v50 := v49.FindInternedVar(lang.NewSymbol("list")) -if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) -} -v51 := v50.Get() -v52 := lang.Apply(v51, []any{lang.NewSymbol("do")}) -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("list")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) -} -v55 := v54.Get() -v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v57 := v56.FindInternedVar(lang.NewSymbol("seq")) -if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) -} -v58 := v57.Get() -v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v60 := v59.FindInternedVar(lang.NewSymbol("concat")) -if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) -} -v61 := v60.Get() -v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v63 := v62.FindInternedVar(lang.NewSymbol("list")) -if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) -} -v64 := v63.Get() -v65 := lang.Apply(v64, []any{lang.NewSymbol("glojure.core/defn")}) -v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v67 := v66.FindInternedVar(lang.NewSymbol("list")) -if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) -} -v68 := v67.Get() -v69 := lang.Apply(v68, []any{v5}) -v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v71 := v70.FindInternedVar(lang.NewSymbol("list")) -if v71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) -} -v72 := v71.Get() -v73 := lang.Apply(v72, []any{v32}) -v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v75 := v74.FindInternedVar(lang.NewSymbol("list")) -if v75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) -} -v76 := v75.Get() -v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v78 := v77.FindInternedVar(lang.NewSymbol("apply")) -if v78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) -} -v79 := v78.Get() -v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v81 := v80.FindInternedVar(lang.NewSymbol("eval")) -if v81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) -} -v82 := v81.Get() -v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v84 := v83.FindInternedVar(lang.NewSymbol("list")) -if v84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) -} -v85 := v84.Get() -v86 := lang.Apply(v85, []any{lang.NewSymbol("glojure.core/fn"), v32, v37}) -v87 := lang.Apply(v82, []any{v86}) -v88 := lang.Apply(v79, []any{v87, v32}) -v89 := lang.Apply(v76, []any{v88}) -v90 := lang.Apply(v61, []any{v65, v69, v22, v73, v89}) -v91 := lang.Apply(v58, []any{v90}) -v92 := lang.Apply(v55, []any{v91}) -v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v94 := v93.FindInternedVar(lang.NewSymbol("list")) -if v94.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) -} -v95 := v94.Get() -v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v97 := v96.FindInternedVar(lang.NewSymbol("seq")) -if v97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) -} -v98 := v97.Get() -v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v100 := v99.FindInternedVar(lang.NewSymbol("concat")) -if v100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) -} -v101 := v100.Get() -v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v103 := v102.FindInternedVar(lang.NewSymbol("list")) -if v103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) -} -v104 := v103.Get() -v105 := lang.Apply(v104, []any{lang.NewSymbol("glojure.core/alter-meta!")}) -v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v107 := v106.FindInternedVar(lang.NewSymbol("list")) -if v107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) -} -v108 := v107.Get() -v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v110 := v109.FindInternedVar(lang.NewSymbol("seq")) -if v110.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) -} -v111 := v110.Get() -v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v113 := v112.FindInternedVar(lang.NewSymbol("concat")) -if v113.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) -} -v114 := v113.Get() -v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v116 := v115.FindInternedVar(lang.NewSymbol("list")) -if v116.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) -} -v117 := v116.Get() -v118 := lang.Apply(v117, []any{lang.NewSymbol("var")}) -v119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v120 := v119.FindInternedVar(lang.NewSymbol("list")) -if v120.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v120))) -} -v121 := v120.Get() -v122 := lang.Apply(v121, []any{v5}) -v123 := lang.Apply(v114, []any{v118, v122}) -v124 := lang.Apply(v111, []any{v123}) -v125 := lang.Apply(v108, []any{v124}) -v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v127 := v126.FindInternedVar(lang.NewSymbol("list")) -if v127.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) -} -v128 := v127.Get() -v129 := lang.Apply(v128, []any{lang.NewSymbol("glojure.core/assoc")}) -v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v131 := v130.FindInternedVar(lang.NewSymbol("list")) -if v131.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) -} -v132 := v131.Get() -v133 := lang.Apply(v132, []any{lang.NewKeyword("inline")}) -v134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v135 := v134.FindInternedVar(lang.NewSymbol("list")) -if v135.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v135))) -} -v136 := v135.Get() -v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v138 := v137.FindInternedVar(lang.NewSymbol("seq")) -if v138.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) -} -v139 := v138.Get() -v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v141 := v140.FindInternedVar(lang.NewSymbol("concat")) -if v141.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) -} -v142 := v141.Get() -v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v144 := v143.FindInternedVar(lang.NewSymbol("list")) -if v144.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) -} -v145 := v144.Get() -v146 := lang.Apply(v145, []any{lang.NewSymbol("glojure.core/fn")}) -v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v148 := v147.FindInternedVar(lang.NewSymbol("list")) -if v148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) -} -v149 := v148.Get() -v150 := lang.Apply(v149, []any{v5}) -v151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v152 := v151.FindInternedVar(lang.NewSymbol("list")) -if v152.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v152))) -} -v153 := v152.Get() -v154 := lang.Apply(v153, []any{v32}) -v155 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v156 := v155.FindInternedVar(lang.NewSymbol("list")) -if v156.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v156))) +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v157 := v156.Get() -v158 := lang.Apply(v157, []any{v37}) -v159 := lang.Apply(v142, []any{v146, v150, v154, v158}) -v160 := lang.Apply(v139, []any{v159}) -v161 := lang.Apply(v136, []any{v160}) -v162 := lang.Apply(v101, []any{v105, v125, v129, v133, v161}) -v163 := lang.Apply(v98, []any{v162}) -v164 := lang.Apply(v95, []any{v163}) -v165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v166 := v165.FindInternedVar(lang.NewSymbol("list")) -if v166.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v166))) +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v167 := v166.Get() -v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v169 := v168.FindInternedVar(lang.NewSymbol("seq")) -if v169.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -v170 := v169.Get() -v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v172 := v171.FindInternedVar(lang.NewSymbol("concat")) -if v172.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v173 := v172.Get() -v174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v175 := v174.FindInternedVar(lang.NewSymbol("list")) -if v175.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v175))) +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/unchecked_int_dec")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -v176 := v175.Get() -v177 := lang.Apply(v176, []any{lang.NewSymbol("var")}) -v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v179 := v178.FindInternedVar(lang.NewSymbol("list")) -if v179.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v3}) +v35 := lang.Apply(v26, []any{v30, v34}) +v36 := lang.Apply(v23, []any{v35}) +v37 := lang.Apply(v20, []any{v36}) +v38 := lang.Apply(v9, []any{v13, v17, v37}) +v39 := lang.Apply(v6, []any{v38}) +return v39 +}) +v2 := v1 +_ = v2 } -v180 := v179.Get() -v181 := lang.Apply(v180, []any{v5}) -v182 := lang.Apply(v173, []any{v177, v181}) -v183 := lang.Apply(v170, []any{v182}) -v184 := lang.Apply(v167, []any{v183}) -v185 := lang.Apply(v48, []any{v52, v92, v164, v184}) -v186 := lang.Apply(v45, []any{v185}) -return v186 +v0 := lang.NewSymbol("unchecked-dec-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns a number one less than x, an int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1168), lang.NewKeyword("end-line"), int(1168))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "unchecked_int_dec") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_dec is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// frequencies +// unchecked-divide-int { -v0 := lang.NewSymbol("frequencies").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a map from distinct items in coll to the number of times\n they appear.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7228), lang.NewKeyword("end-line"), int(7228))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { +var v1 lang.FnFunc +{ // function unchecked-divide-int__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("persistent!")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("reduce")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("concat")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v9 := v8.Get() -var v10 lang.FnFunc -v10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v11 := args[0] -v12 := args[1] -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("assoc!")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("list")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("inc")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +v13 := v12.Get() +v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } -v18 := v17.Get() +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("get")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) if v20.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } v21 := v20.Get() -v22 := lang.Apply(v21, []any{v11, v12, int64(0)}) -v23 := lang.Apply(v18, []any{v22}) -v24 := lang.Apply(v15, []any{v11, v12, v23}) -return v24 -}) -v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7235), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(7236), lang.NewKeyword("end-column"), int(54)) -v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) -if err != nil { - panic(err) +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("seq")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("transient")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("concat")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -v15 := v14.Get() -v16 := lang.NewMap() -v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7237), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(7237), lang.NewKeyword("end-column"), int(24)) -v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) -if err != nil { - panic(err) +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("list")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } -v19 := lang.Apply(v15, []any{v18}) -v20 := lang.Apply(v9, []any{v12, v19, v3}) -v21 := lang.Apply(v6, []any{v20}) -return v21 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v30 := v29.Get() +v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/unchecked_int_divide")}) +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) } +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) } -// load-string -{ -v0 := lang.NewSymbol("load-string").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Sequentially read and evaluate the set of forms contained in the\n string", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4088), lang.NewKeyword("end-line"), int(4088))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v4}) +v40 := lang.Apply(v27, []any{v31, v35, v39}) +v41 := lang.Apply(v24, []any{v40}) +v42 := lang.Apply(v21, []any{v41}) +v43 := lang.Apply(v10, []any{v14, v18, v42}) +v44 := lang.Apply(v7, []any{v43}) +return v44 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("unchecked-divide-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the division of x by y, both int.\n Note - uses a primitive operator subject to truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(26), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1238), lang.NewKeyword("end-line"), int(1238))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := args[0] -v5 := lang.Apply(java.io.StringReader34., []any{v3}) -v6 := lang.Apply(glojure.lang.LineNumberingPushbackReader5., []any{v5}) -var v4 any = v6 -_ = v4 -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("load-reader")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v4 := args[0] +v5 := args[1] +v6, _ := lang.FieldOrMethod(lang1.Numbers, "unchecked_int_divide") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_divide is not a function"))) } -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v4}) -return v11 +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// with-in-str +// unchecked-double { -v0 := lang.NewSymbol("with-in-str").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Evaluates body in a context in which *in* is bound to a fresh\n StringReader initialized with the string s.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4749), lang.NewKeyword("end-line"), int(4749))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } +var v1 lang.FnFunc +{ // function unchecked-double__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("seq")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) if v8.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } v9 := v8.Get() v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("concat")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) if v11.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("list")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/with-open")}) -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("list")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("apply")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("vector")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("seq")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("concat")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{lang.NewSymbol("s__0__auto__")}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("seq")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) -} -v41 := v40.Get() -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("concat")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v44 := v43.Get() -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("list")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v47 := v46.Get() -v48 := lang.Apply(v47, []any{lang.NewSymbol("glojure.core/->")}) -v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v50 := v49.FindInternedVar(lang.NewSymbol("list")) -if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v51 := v50.Get() -v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("seq")) -if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -v54 := v53.Get() -v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v56 := v55.FindInternedVar(lang.NewSymbol("concat")) -if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v57 := v56.Get() -v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v59 := v58.FindInternedVar(lang.NewSymbol("list")) -if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/UncheckedDoubleCast")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -v60 := v59.Get() -v61 := lang.Apply(v60, []any{lang.NewSymbol("java.io.StringReader.")}) -v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v63 := v62.FindInternedVar(lang.NewSymbol("list")) -if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v3}) +v35 := lang.Apply(v26, []any{v30, v34}) +v36 := lang.Apply(v23, []any{v35}) +v37 := lang.Apply(v20, []any{v36}) +v38 := lang.Apply(v9, []any{v13, v17, v37}) +v39 := lang.Apply(v6, []any{v38}) +return v39 +}) +v2 := v1 +_ = v2 } -v64 := v63.Get() -v65 := lang.Apply(v64, []any{v5}) -v66 := lang.Apply(v57, []any{v61, v65}) -v67 := lang.Apply(v54, []any{v66}) -v68 := lang.Apply(v51, []any{v67}) -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("list")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +v0 := lang.NewSymbol("unchecked-double").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to double. Subject to rounding.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3553), lang.NewKeyword("end-line"), int(3553))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := lang.Apply(lang1.AsFloat64, []any{v4}) +return v5 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v71 := v70.Get() -v72 := lang.Apply(v71, []any{lang.NewSymbol("glojure.lang.LineNumberingPushbackReader.")}) -v73 := lang.Apply(v44, []any{v48, v68, v72}) -v74 := lang.Apply(v41, []any{v73}) -v75 := lang.Apply(v38, []any{v74}) -v76 := lang.Apply(v31, []any{v35, v75}) -v77 := lang.Apply(v28, []any{v76}) -v78 := lang.Apply(v22, []any{v25, v77}) -v79 := lang.Apply(v19, []any{v78}) -v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v81 := v80.FindInternedVar(lang.NewSymbol("list")) -if v81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) } -v82 := v81.Get() -v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v84 := v83.FindInternedVar(lang.NewSymbol("seq")) -if v84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) +// unchecked-float +{ +var v1 lang.FnFunc +{ // function unchecked-float__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v85 := v84.Get() -v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v87 := v86.FindInternedVar(lang.NewSymbol("concat")) -if v87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v88 := v87.Get() -v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v90 := v89.FindInternedVar(lang.NewSymbol("list")) -if v90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v91 := v90.Get() -v92 := lang.Apply(v91, []any{lang.NewSymbol("glojure.core/binding")}) -v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v94 := v93.FindInternedVar(lang.NewSymbol("list")) -if v94.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v95 := v94.Get() -v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v97 := v96.FindInternedVar(lang.NewSymbol("apply")) -if v97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v98 := v97.Get() -v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v100 := v99.FindInternedVar(lang.NewSymbol("vector")) -if v100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v101 := v100.Get() -v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v103 := v102.FindInternedVar(lang.NewSymbol("seq")) -if v103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -v104 := v103.Get() -v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v106 := v105.FindInternedVar(lang.NewSymbol("concat")) -if v106.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v107 := v106.Get() -v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v109 := v108.FindInternedVar(lang.NewSymbol("list")) -if v109.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/UncheckedFloatCast")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -v110 := v109.Get() -v111 := lang.Apply(v110, []any{lang.NewSymbol("glojure.core/*in*")}) -v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v113 := v112.FindInternedVar(lang.NewSymbol("list")) -if v113.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v3}) +v35 := lang.Apply(v26, []any{v30, v34}) +v36 := lang.Apply(v23, []any{v35}) +v37 := lang.Apply(v20, []any{v36}) +v38 := lang.Apply(v9, []any{v13, v17, v37}) +v39 := lang.Apply(v6, []any{v38}) +return v39 +}) +v2 := v1 +_ = v2 } -v114 := v113.Get() -v115 := lang.Apply(v114, []any{lang.NewSymbol("s__0__auto__")}) -v116 := lang.Apply(v107, []any{v111, v115}) -v117 := lang.Apply(v104, []any{v116}) -v118 := lang.Apply(v98, []any{v101, v117}) -v119 := lang.Apply(v95, []any{v118}) -v120 := lang.Apply(v88, []any{v92, v119, v6}) -v121 := lang.Apply(v85, []any{v120}) -v122 := lang.Apply(v82, []any{v121}) -v123 := lang.Apply(v12, []any{v16, v79, v122}) -v124 := lang.Apply(v9, []any{v123}) -return v124 +v0 := lang.NewSymbol("unchecked-float").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to float. Subject to rounding.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3547), lang.NewKeyword("end-line"), int(3547))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } +v4 := args[0] +v5 := lang.Apply(lang1.UncheckedFloatCast, []any{v4}) +return v5 }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// simple-ident? +// unchecked-inc { -v0 := lang.NewSymbol("simple-ident?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a symbol or keyword without a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1613), lang.NewKeyword("end-line"), int(1613))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { +var v1 lang.FnFunc +{ // function unchecked-inc__inliner +v1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("ident?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -var v4 any = v8 -_ = v4 -var v10 any -if lang.IsTruthy(v4) { -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("nil?")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v13 := v12.Get() +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("namespace")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) if v15.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } v16 := v15.Get() -v17 := lang.Apply(v16, []any{v3}) -v18 := lang.Apply(v13, []any{v17}) -v10 = v18 -} else { -v10 = v4 +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -return v10 +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/unchecked_inc")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v3}) +v35 := lang.Apply(v26, []any{v30, v34}) +v36 := lang.Apply(v23, []any{v35}) +v37 := lang.Apply(v20, []any{v36}) +v38 := lang.Apply(v9, []any{v13, v17, v37}) +v39 := lang.Apply(v6, []any{v38}) +return v39 }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("unchecked-inc").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns a number one greater than x, a long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1161), lang.NewKeyword("end-line"), int(1161))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "unchecked_inc") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_inc is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// print-tagged-object +// unchecked-inc-int { -v0 := lang.NewSymbol("print-tagged-object").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(102), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(102), lang.NewKeyword("end-column"), int(26), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("rep"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { +var v1 lang.FnFunc +{ // function unchecked-inc-int__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := args[1] -v5 := args[2] -var v6 any +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("instance?")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) if v8.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } v9 := v8.Get() -v10 := lang.Apply(v9, []any{lang1.IMeta, v3}) -if lang.IsTruthy(v10) { -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("print-meta")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v3, v5}) -v6 = v14 -} else { -v6 = nil -} -_ = v6 -v15 := lang.Apply(lang1.WriteWriter, []any{v5, "#object["}) -_ = v15 -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("class")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v3}) -var v16 any = v20 -_ = v16 -var v22 any -if lang.IsTruthy(false) { -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("print-method")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v25 := v24.Get() -v26, ok := lang.FieldOrMethod(v16, "Name") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v16, "Name"))) +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -var v27 any -switch reflect.TypeOf(v26).Kind() { -case reflect.Func: - v27 = lang.Apply(v26, nil) -default: - v27 = v26 +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v28 := lang.Apply(v25, []any{v27, v5}) -v22 = v28 -} else { -v29, ok := lang.FieldOrMethod(v16, "Name") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v16, "Name"))) +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -var v30 any -switch reflect.TypeOf(v29).Kind() { -case reflect.Func: - v30 = lang.Apply(v29, nil) -default: - v30 = v29 +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v31 := lang.Apply(lang1.WriteWriter, []any{v5, v30}) -v22 = v31 +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/unchecked_int_inc")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -_ = v22 -v16 := lang.Apply(lang1.WriteWriter, []any{v5, " "}) -_ = v16 -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("format")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v3}) +v35 := lang.Apply(v26, []any{v30, v34}) +v36 := lang.Apply(v23, []any{v35}) +v37 := lang.Apply(v20, []any{v36}) +v38 := lang.Apply(v9, []any{v13, v17, v37}) +v39 := lang.Apply(v6, []any{v38}) +return v39 +}) +v2 := v1 +_ = v2 } -v19 := v18.Get() -v20 := lang.Apply(lang1.IdentityHash, []any{v3}) -v21 := lang.Apply(v19, []any{"0x%x ", v20}) -v22 := lang.Apply(lang1.WriteWriter, []any{v5, v21}) -_ = v22 -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("print-method")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +v0 := lang.NewSymbol("unchecked-inc-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns a number one greater than x, an int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1154), lang.NewKeyword("end-line"), int(1154))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "unchecked_int_inc") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_inc is not a function"))) } -v25 := v24.Get() -v26 := lang.Apply(v25, []any{v4, v5}) -_ = v26 -v27 := lang.Apply(lang1.WriteWriter, []any{v5, "]"}) -return v27 +v6 := lang.Apply(v5, []any{v4}) +return v6 }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// empty? +// unchecked-int { -v0 := lang.NewSymbol("empty?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll has no items. To check the emptiness of a seq,\n please use the idiom (seq x) rather than (not (empty? x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6290), lang.NewKeyword("end-line"), int(6290))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { +var v1 lang.FnFunc +{ // function unchecked-int__inliner +v1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("counted?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -if lang.IsTruthy(v8) { -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("zero?")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("count")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v3}) -v16 := lang.Apply(v11, []any{v15}) -v4 = v16 -} else { -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("not")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("seq")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v22 := v21.Get() -v23 := lang.Apply(v22, []any{v3}) -v24 := lang.Apply(v19, []any{v23}) -v4 = v24 +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -return v4 +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/UncheckedIntCast")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v3}) +v35 := lang.Apply(v26, []any{v30, v34}) +v36 := lang.Apply(v23, []any{v35}) +v37 := lang.Apply(v20, []any{v36}) +v38 := lang.Apply(v9, []any{v13, v17, v37}) +v39 := lang.Apply(v6, []any{v38}) +return v39 }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("unchecked-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to int. Subject to rounding or truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3535), lang.NewKeyword("end-line"), int(3535))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := lang.Apply(lang1.UncheckedIntCast, []any{v4}) +return v5 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// indexed? +// unchecked-long { -v0 := lang.NewSymbol("indexed?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return true if coll implements Indexed, indicating efficient lookup by index", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6306), lang.NewKeyword("end-line"), int(6306))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { +var v1 lang.FnFunc +{ // function unchecked-long__inliner +v1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -v7 := lang.Apply(v6, []any{glojure.lang11.Indexed, v3}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// aset-short -{ -v0 := lang.NewSymbol("aset-short").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of short. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3971), lang.NewKeyword("end-line"), int(3973))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("short")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v5}) -v10, _ := lang.FieldOrMethod(nil, "setShort") -if reflect.TypeOf(v10).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setShort is not a function"))) -} -v11 := lang.Apply(v10, []any{v3, v4, v9}) -_ = v11 -return v5 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("apply")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) if v8.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } v9 := v8.Get() v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("aset-short")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) if v11.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("aget")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v3, v4}) -v17 := lang.Apply(v9, []any{v12, v16, v5, v6}) -return v17 +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +} +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +} +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +} +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/UncheckedLongCast")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v3}) +v35 := lang.Apply(v26, []any{v30, v34}) +v36 := lang.Apply(v23, []any{v35}) +v37 := lang.Apply(v20, []any{v36}) +v38 := lang.Apply(v9, []any{v13, v17, v37}) +v39 := lang.Apply(v6, []any{v38}) +return v39 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("unchecked-long").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to long. Subject to rounding or truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3541), lang.NewKeyword("end-line"), int(3541))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } +v4 := args[0] +v5 := lang.Apply(lang1.UncheckedLongCast, []any{v4}) +return v5 }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// unchecked-divide-int +// unchecked-multiply { var v1 lang.FnFunc -{ // function unchecked-divide-int__inliner +{ // function unchecked-multiply__inliner v1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -75159,7 +75741,7 @@ if v29.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } v30 := v29.Get() -v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/unchecked_int_divide")}) +v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/unchecked_multiply")}) v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v33 := v32.FindInternedVar(lang.NewSymbol("list")) if v33.IsMacro() { @@ -75184,7 +75766,7 @@ return v44 v2 := v1 _ = v2 } -v0 := lang.NewSymbol("unchecked-divide-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the division of x by y, both int.\n Note - uses a primitive operator subject to truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(26), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1238), lang.NewKeyword("end-line"), int(1238))).(*lang.Symbol) +v0 := lang.NewSymbol("unchecked-multiply").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the product of x and y, both long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1231), lang.NewKeyword("end-line"), int(1231))).(*lang.Symbol) var v3 lang.FnFunc v3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { @@ -75192,9 +75774,9 @@ v3 = lang.NewFnFunc(func(args ...any) any { } v4 := args[0] v5 := args[1] -v6, _ := lang.FieldOrMethod(lang1.Numbers, "unchecked_int_divide") +v6, _ := lang.FieldOrMethod(lang1.Numbers, "unchecked_multiply") if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_divide is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_multiply is not a function"))) } v7 := lang.Apply(v6, []any{v4, v5}) return v7 @@ -75205,568 +75787,416 @@ if v0.Meta() != nil { v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// loop +// unchecked-multiply-int { -v0 := lang.NewSymbol("loop").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Evaluates the exprs in a lexical context in which the symbols in\n the binding-forms are bound to their respective init-exprs or parts\n therein. Acts as a recur target.", lang.NewKeyword("forms"), lang.NewVector(lang.NewList(lang.NewSymbol("loop"), lang.NewVector(lang.NewSymbol("bindings*")), lang.NewSymbol("exprs*"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4597), lang.NewKeyword("end-line"), int(4597), lang.NewKeyword("special-form"), true)).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } +var v1 lang.FnFunc +{ // function unchecked-multiply-int__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -var v7 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) +v9 := v8.FindInternedVar(lang.NewSymbol("concat")) if v9.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } v10 := v9.Get() -v11 := lang.Apply(v10, []any{v5}) -if lang.IsTruthy(v11) { -v7 = nil -} else { -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("str")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("list")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v14 := v13.Get() +v13 := v12.Get() +v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("first")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) if v16.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } v17 := v16.Get() -v18 := lang.Apply(v17, []any{v3}) +v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) if v20.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } v21 := v20.Get() v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("meta")) +v23 := v22.FindInternedVar(lang.NewSymbol("seq")) if v23.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) -v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) -v28 := lang.Apply(lang1.NewIllegalArgumentError, []any{v27}) -panic(v28) +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("concat")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -_ = v7 -var v29 any -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("even?")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("list")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("count")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +v30 := v29.Get() +v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/unchecked_int_multiply")}) +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) } -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v5}) -v37 := lang.Apply(v32, []any{v36}) -if lang.IsTruthy(v37) { -v29 = nil -} else { -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("str")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) } -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("first")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v4}) +v40 := lang.Apply(v27, []any{v31, v35, v39}) +v41 := lang.Apply(v24, []any{v40}) +v42 := lang.Apply(v21, []any{v41}) +v43 := lang.Apply(v10, []any{v14, v18, v42}) +v44 := lang.Apply(v7, []any{v43}) +return v44 +}) +v2 := v1 +_ = v2 } -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v3}) -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +v0 := lang.NewSymbol("unchecked-multiply-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the product of x and y, both int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1224), lang.NewKeyword("end-line"), int(1224))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := args[1] +v6, _ := lang.FieldOrMethod(lang1.Numbers, "unchecked_int_multiply") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_multiply is not a function"))) } -v47 := v46.Get() -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("meta")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v3}) -v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) -v53 := lang.Apply(v40, []any{v44, " requires ", "an even number of forms in binding vector", " in ", v47, ":", v52}) -v54 := lang.Apply(lang1.NewIllegalArgumentError, []any{v53}) -panic(v54) } -_ = v29 -_ = nil -v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v57 := v56.FindInternedVar(lang.NewSymbol("destructure")) -if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) +// unchecked-negate +{ +var v1 lang.FnFunc +{ // function unchecked-negate__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v58 := v57.Get() -v59 := lang.Apply(v58, []any{v5}) -var v55 any = v59 -_ = v55 -var v61 any -v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v63 := v62.FindInternedVar(lang.NewSymbol("=")) -if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v64 := v63.Get() -v65 := lang.Apply(v64, []any{v55, v5}) -if lang.IsTruthy(v65) { -v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v67 := v66.FindInternedVar(lang.NewSymbol("seq")) -if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v68 := v67.Get() -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("concat")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v71 := v70.Get() -v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v73 := v72.FindInternedVar(lang.NewSymbol("list")) -if v73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v74 := v73.Get() -v75 := lang.Apply(v74, []any{lang.NewSymbol("loop*")}) -v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v77 := v76.FindInternedVar(lang.NewSymbol("list")) -if v77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v78 := v77.Get() -v79 := lang.Apply(v78, []any{v5}) -v80 := lang.Apply(v71, []any{v75, v79, v6}) -v81 := lang.Apply(v68, []any{v80}) -v61 = v81 -} else { -v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v84 := v83.FindInternedVar(lang.NewSymbol("take-nth")) -if v84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -v85 := v84.Get() -v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v87 := v86.FindInternedVar(lang.NewSymbol("drop")) -if v87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v88 := v87.Get() -v89 := lang.Apply(v88, []any{int64(1), v5}) -v90 := lang.Apply(v85, []any{int64(2), v89}) -var v82 any = v90 -_ = v82 -v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v93 := v92.FindInternedVar(lang.NewSymbol("take-nth")) -if v93.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/unchecked_minus")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -v94 := v93.Get() -v95 := lang.Apply(v94, []any{int64(2), v5}) -var v91 any = v95 -_ = v91 -v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v98 := v97.FindInternedVar(lang.NewSymbol("map")) -if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v3}) +v35 := lang.Apply(v26, []any{v30, v34}) +v36 := lang.Apply(v23, []any{v35}) +v37 := lang.Apply(v20, []any{v36}) +v38 := lang.Apply(v9, []any{v13, v17, v37}) +v39 := lang.Apply(v6, []any{v38}) +return v39 +}) +v2 := v1 +_ = v2 } -v99 := v98.Get() -var v100 lang.FnFunc -v100 = lang.NewFnFunc(func(args ...any) any { +v0 := lang.NewSymbol("unchecked-negate").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the negation of x, a long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1189), lang.NewKeyword("end-line"), int(1189))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v101 := args[0] -var v102 any -v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v104 := v103.FindInternedVar(lang.NewSymbol("symbol?")) -if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) -} -v105 := v104.Get() -v106 := lang.Apply(v105, []any{v101}) -if lang.IsTruthy(v106) { -v102 = v101 -} else { -v107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v108 := v107.FindInternedVar(lang.NewSymbol("gensym")) -if v108.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v108))) -} -v109 := v108.Get() -v110 := lang.Apply(v109, nil) -v102 = v110 +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "Unchecked_negate") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_negate is not a function"))) } -return v102 +v6 := lang.Apply(v5, []any{v4}) +return v6 }) -v101 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4611), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(4611), lang.NewKeyword("end-column"), int(58)) -v102, err := lang.WithMeta(v100, v101.(lang.IPersistentMap)) -if err != nil { - panic(err) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v103 := lang.Apply(v99, []any{v102, v91}) -var v96 any = v103 -_ = v96 -v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v106 := v105.FindInternedVar(lang.NewSymbol("reduce1")) -if v106.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) } -v107 := v106.Get() -var v108 lang.FnFunc -v108 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { +// unchecked-negate-int +{ +var v1 lang.FnFunc +{ // function unchecked-negate-int__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v109 := args[0] -v110 := args[1] -var v111 any = v110 -_ = v111 -v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v114 := v113.FindInternedVar(lang.NewSymbol("nth")) -if v114.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) -} -v115 := v114.Get() -v116 := lang.Apply(v115, []any{v111, int64(0), nil}) -var v112 any = v116 -_ = v112 -v118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v119 := v118.FindInternedVar(lang.NewSymbol("nth")) -if v119.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v119))) -} -v120 := v119.Get() -v121 := lang.Apply(v120, []any{v111, int64(1), nil}) -var v117 any = v121 -_ = v117 -v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v124 := v123.FindInternedVar(lang.NewSymbol("nth")) -if v124.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) -} -v125 := v124.Get() -v126 := lang.Apply(v125, []any{v111, int64(2), nil}) -var v122 any = v126 -_ = v122 -var v128 any -v129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v130 := v129.FindInternedVar(lang.NewSymbol("symbol?")) -if v130.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v130))) -} -v131 := v130.Get() -v132 := lang.Apply(v131, []any{v112}) -if lang.IsTruthy(v132) { -v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v134 := v133.FindInternedVar(lang.NewSymbol("conj")) -if v134.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) -} -v135 := v134.Get() -v136 := lang.Apply(v135, []any{v109, v122, v117}) -v128 = v136 -} else { -v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v138 := v137.FindInternedVar(lang.NewSymbol("conj")) -if v138.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) -} -v139 := v138.Get() -v140 := lang.Apply(v139, []any{v109, v122, v117, v112, v122}) -v128 = v140 -} -return v128 -}) -v109 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4612), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(4615), lang.NewKeyword("end-column"), int(50)) -v110, err := lang.WithMeta(v108, v109.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v111 := lang.NewVector() -v112 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4616), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(4616), lang.NewKeyword("end-column"), int(28)) -v113, err := lang.WithMeta(v111, v112.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v115 := v114.FindInternedVar(lang.NewSymbol("map")) -if v115.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v115))) -} -v116 := v115.Get() -v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v118 := v117.FindInternedVar(lang.NewSymbol("vector")) -if v118.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) -} -v119 := v118.Get() -v120 := lang.Apply(v116, []any{v119, v91, v82, v96}) -v121 := lang.Apply(v107, []any{v110, v113, v120}) -var v104 any = v121 -_ = v104 -v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v124 := v123.FindInternedVar(lang.NewSymbol("seq")) -if v124.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) -} -v125 := v124.Get() -v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v127 := v126.FindInternedVar(lang.NewSymbol("concat")) -if v127.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) -} -v128 := v127.Get() -v129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v130 := v129.FindInternedVar(lang.NewSymbol("list")) -if v130.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v130))) -} -v131 := v130.Get() -v132 := lang.Apply(v131, []any{lang.NewSymbol("glojure.core/let")}) -v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v134 := v133.FindInternedVar(lang.NewSymbol("list")) -if v134.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) -} -v135 := v134.Get() -v136 := lang.Apply(v135, []any{v104}) -v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v138 := v137.FindInternedVar(lang.NewSymbol("list")) -if v138.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) -} -v139 := v138.Get() -v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v141 := v140.FindInternedVar(lang.NewSymbol("seq")) -if v141.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) -} -v142 := v141.Get() -v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v144 := v143.FindInternedVar(lang.NewSymbol("concat")) -if v144.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) -} -v145 := v144.Get() -v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v147 := v146.FindInternedVar(lang.NewSymbol("list")) -if v147.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) -} -v148 := v147.Get() -v149 := lang.Apply(v148, []any{lang.NewSymbol("loop*")}) -v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v151 := v150.FindInternedVar(lang.NewSymbol("list")) -if v151.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) -} -v152 := v151.Get() -v153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v154 := v153.FindInternedVar(lang.NewSymbol("vec")) -if v154.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v154))) +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v155 := v154.Get() -v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v157 := v156.FindInternedVar(lang.NewSymbol("interleave")) -if v157.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v158 := v157.Get() -v159 := lang.Apply(v158, []any{v96, v96}) -v160 := lang.Apply(v155, []any{v159}) -v161 := lang.Apply(v152, []any{v160}) -v162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v163 := v162.FindInternedVar(lang.NewSymbol("list")) -if v163.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v163))) +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("list")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v164 := v163.Get() -v165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v166 := v165.FindInternedVar(lang.NewSymbol("seq")) -if v166.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v166))) +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("list")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v167 := v166.Get() -v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v169 := v168.FindInternedVar(lang.NewSymbol("concat")) -if v169.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) +v16 := v15.Get() +v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("list")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v170 := v169.Get() -v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v172 := v171.FindInternedVar(lang.NewSymbol("list")) -if v172.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v173 := v172.Get() -v174 := lang.Apply(v173, []any{lang.NewSymbol("glojure.core/let")}) -v175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v176 := v175.FindInternedVar(lang.NewSymbol("list")) -if v176.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v176))) +v23 := v22.Get() +v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } -v177 := v176.Get() -v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v179 := v178.FindInternedVar(lang.NewSymbol("vec")) -if v179.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) +v26 := v25.Get() +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v180 := v179.Get() -v181 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v182 := v181.FindInternedVar(lang.NewSymbol("interleave")) -if v182.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v182))) +v29 := v28.Get() +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/unchecked_int_negate")}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -v183 := v182.Get() -v184 := lang.Apply(v183, []any{v91, v96}) -v185 := lang.Apply(v180, []any{v184}) -v186 := lang.Apply(v177, []any{v185}) -v187 := lang.Apply(v170, []any{v174, v186, v6}) -v188 := lang.Apply(v167, []any{v187}) -v189 := lang.Apply(v164, []any{v188}) -v190 := lang.Apply(v145, []any{v149, v161, v189}) -v191 := lang.Apply(v142, []any{v190}) -v192 := lang.Apply(v139, []any{v191}) -v193 := lang.Apply(v128, []any{v132, v136, v192}) -v194 := lang.Apply(v125, []any{v193}) -v61 = v194 +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v3}) +v35 := lang.Apply(v26, []any{v30, v34}) +v36 := lang.Apply(v23, []any{v35}) +v37 := lang.Apply(v20, []any{v36}) +v38 := lang.Apply(v9, []any{v13, v17, v37}) +v39 := lang.Apply(v6, []any{v38}) +return v39 +}) +v2 := v1 +_ = v2 } -return v61 +v0 := lang.NewSymbol("unchecked-negate-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the negation of x, an int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(26), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1182), lang.NewKeyword("end-line"), int(1182))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } +v4 := args[0] +v5, _ := lang.FieldOrMethod(lang1.Numbers, "unchecked_int_negate") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_negate is not a function"))) +} +v6 := lang.Apply(v5, []any{v4}) +return v6 }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// tree-seq +// unchecked-remainder-int { -v0 := lang.NewSymbol("tree-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("branch?"), lang.NewSymbol("children"), lang.NewSymbol("root"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the nodes in a tree, via a depth-first walk.\n branch? must be a fn of one arg that returns true if passed a node\n that can have children (but may not). children must be a fn of one\n arg that returns a sequence of the children. Will only be called on\n nodes for which branch? returns true. Root is the root node of the\n tree.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4955), lang.NewKeyword("end-line"), int(4955))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { +var v1 lang.FnFunc +{ // function unchecked-remainder-int__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] v4 := args[1] -v5 := args[2] -var v7 lang.FnFunc -{ // function walk -v7 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v9 := args[0] -var v10 lang.FnFunc -v10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("concat")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("cons")) +v12 := v11.FindInternedVar(lang.NewSymbol("list")) if v12.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } v13 := v12.Get() -var v14 any -v15 := lang.Apply(v3, []any{v9}) -if lang.IsTruthy(v15) { -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("mapcat")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } -v18 := v17.Get() -v19 := lang.Apply(v4, []any{v9}) -v20 := lang.Apply(v18, []any{v8, v19}) -v14 = v20 -} else { -v14 = nil +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v21 := lang.Apply(v13, []any{v9, v14}) -return v21 -}) -v11 := lang.Apply(lang1.NewLazySeq, []any{v10}) -return v11 -}) -v8 := v7 -_ = v8 +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("seq")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4965), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(4969), lang.NewKeyword("end-column"), int(53)) -v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) -if err != nil { - panic(err) +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("concat")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -var v6 any = v9 -_ = v6 -v11 := lang.Apply(v6, []any{v5}) -return v11 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("list")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } +v30 := v29.Get() +v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/unchecked_int_remainder")}) +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) } -// odd? -{ -v0 := lang.NewSymbol("odd?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is odd, throws an exception if n is not an integer", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1389), lang.NewKeyword("end-line"), int(1389))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v4}) +v40 := lang.Apply(v27, []any{v31, v35, v39}) +v41 := lang.Apply(v24, []any{v40}) +v42 := lang.Apply(v21, []any{v41}) +v43 := lang.Apply(v10, []any{v14, v18, v42}) +v44 := lang.Apply(v7, []any{v43}) +return v44 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("unchecked-remainder-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the remainder of division of x by y, both int.\n Note - uses a primitive operator subject to truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(29), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1245), lang.NewKeyword("end-line"), int(1245))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("not")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("even?")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v4 := args[0] +v5 := args[1] +v6, _ := lang.FieldOrMethod(lang1.Numbers, "unchecked_int_remainder") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_remainder is not a function"))) } -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v3}) -v11 := lang.Apply(v6, []any{v10}) -return v11 +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// unchecked-double +// unchecked-short { var v1 lang.FnFunc -{ // function unchecked-double__inliner +{ // function unchecked-short__inliner v1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -75822,7 +76252,7 @@ if v28.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/UncheckedDoubleCast")}) +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/UncheckedShortCast")}) v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v32 := v31.FindInternedVar(lang.NewSymbol("list")) if v32.IsMacro() { @@ -75840,14 +76270,14 @@ return v39 v2 := v1 _ = v2 } -v0 := lang.NewSymbol("unchecked-double").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to double. Subject to rounding.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3553), lang.NewKeyword("end-line"), int(3553))).(*lang.Symbol) +v0 := lang.NewSymbol("unchecked-short").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to short. Subject to rounding or truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3523), lang.NewKeyword("end-line"), int(3523))).(*lang.Symbol) var v3 lang.FnFunc v3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5 := lang.Apply(lang1.AsFloat64, []any{v4}) +v5 := lang.Apply(lang1.UncheckedShortCast, []any{v4}) return v5 }) v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -75856,219 +76286,436 @@ if v0.Meta() != nil { v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// partition +// unchecked-subtract { -v0 := lang.NewSymbol("partition").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("pad"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of lists of n items each, at offsets step\n apart. If step is not supplied, defaults to n, i.e. the partitions\n do not overlap. If a pad collection is supplied, use its elements as\n necessary to complete last partition upto n items. In case there are\n not enough padding elements, return a partition with less than n items.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3177), lang.NewKeyword("end-line"), int(3177))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: +var v1 lang.FnFunc +{ // function unchecked-subtract__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] v4 := args[1] v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("partition")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq")) if v6.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3, v3, v4}) -return v8 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -var v6 lang.FnFunc -v6 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("concat")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("list")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("seq")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("concat")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("list")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/unchecked_minus")}) +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v4}) +v40 := lang.Apply(v27, []any{v31, v35, v39}) +v41 := lang.Apply(v24, []any{v40}) +v42 := lang.Apply(v21, []any{v41}) +v43 := lang.Apply(v10, []any{v14, v18, v42}) +v44 := lang.Apply(v7, []any{v43}) +return v44 +}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("unchecked-subtract").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the difference of x and y, both long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1217), lang.NewKeyword("end-line"), int(1217))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := args[1] +v6, _ := lang.FieldOrMethod(lang1.Numbers, "unchecked_minus") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_minus is not a function"))) +} +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// unchecked-subtract-int +{ +var v1 lang.FnFunc +{ // function unchecked-subtract-int__inliner +v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } +v3 := args[0] +v4 := args[1] +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("seq")) +v9 := v8.FindInternedVar(lang.NewSymbol("concat")) if v9.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } v10 := v9.Get() -v11 := lang.Apply(v10, []any{v5}) -var v7 any = v11 -_ = v7 -var v13 any -if lang.IsTruthy(v7) { -var v14 any = v7 -_ = v14 -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("doall")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("take")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("list")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v22 := v21.Get() -v23 := lang.Apply(v22, []any{v3, v14}) -v24 := lang.Apply(v19, []any{v23}) -var v16 any = v24 -_ = v16 -var v26 any -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("=")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v13 := v12.Get() +v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } -v29 := v28.Get() -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("count")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v32 := v31.Get() -v33 := lang.Apply(v32, []any{v16}) -v34 := lang.Apply(v29, []any{v3, v33}) -if lang.IsTruthy(v34) { -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("cons")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("seq")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -v37 := v36.Get() -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("partition")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("concat")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("nthrest")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("list")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v14, v4}) -v45 := lang.Apply(v40, []any{v3, v4, v44}) -v46 := lang.Apply(v37, []any{v16, v45}) -v26 = v46 -} else { -v26 = nil +v30 := v29.Get() +v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/unchecked_int_subtract")}) +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) } -v13 = v26 -} else { -v13 = nil +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) } -return v13 +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v4}) +v40 := lang.Apply(v27, []any{v31, v35, v39}) +v41 := lang.Apply(v24, []any{v40}) +v42 := lang.Apply(v21, []any{v41}) +v43 := lang.Apply(v10, []any{v14, v18, v42}) +v44 := lang.Apply(v7, []any{v43}) +return v44 }) -v7 := lang.Apply(lang1.NewLazySeq, []any{v6}) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("unchecked-subtract-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the difference of x and y, both int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1210), lang.NewKeyword("end-line"), int(1210))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := args[1] +v6, _ := lang.FieldOrMethod(lang1.Numbers, "unchecked_int_subtract") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_subtract is not a function"))) +} +v7 := lang.Apply(v6, []any{v4, v5}) return v7 - case 4: +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// underive +{ +v0 := lang.NewSymbol("underive").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag"), lang.NewSymbol("parent")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"), lang.NewSymbol("parent"))), lang.NewKeyword("doc"), "Removes a parent/child relationship between parent and\n tag. h must be a hierarchy obtained from make-hierarchy, if not\n supplied defaults to, and modifies, the global hierarchy.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5686), lang.NewKeyword("end-line"), int(5686))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: v3 := args[0] v4 := args[1] -v5 := args[2] -v6 := args[3] -var v7 lang.FnFunc -v7 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("alter-var-root")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("global-hierarchy")) v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("seq")) +v10 := v9.FindInternedVar(lang.NewSymbol("underive")) if v10.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } v11 := v10.Get() -v12 := lang.Apply(v11, []any{v6}) -var v8 any = v12 -_ = v8 -var v14 any -if lang.IsTruthy(v8) { -var v15 any = v8 -_ = v15 -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("doall")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v12 := lang.Apply(v7, []any{v8, v11, v3, v4}) +_ = v12 +return nil + case 3: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v7 := lang.Apply(lang.NewKeyword("parents"), []any{v3}) +var v6 any = v7 +_ = v6 +var v9 any +v10 := lang.Apply(v6, []any{v4}) +if lang.IsTruthy(v10) { +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("disj")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } -v20 := v19.Get() +v13 := v12.Get() +v14 := lang.Apply(v6, []any{v4}) +v15 := lang.Apply(v13, []any{v14, v5}) +v9 = v15 +} else { +v16 := lang.CreatePersistentTreeSet() +v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5695), lang.NewKeyword("column"), int(36), lang.NewKeyword("end-line"), int(5695), lang.NewKeyword("end-column"), int(38)) +v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v9 = v18 +} +var v8 any = v9 +_ = v8 +var v20 any v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("take")) +v22 := v21.FindInternedVar(lang.NewSymbol("not-empty")) if v22.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } v23 := v22.Get() -v24 := lang.Apply(v23, []any{v3, v15}) -v25 := lang.Apply(v20, []any{v24}) -var v17 any = v25 -_ = v17 -var v27 any -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("=")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +v24 := lang.Apply(v23, []any{v8}) +if lang.IsTruthy(v24) { +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("assoc")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("count")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v27 := v26.Get() +v28 := lang.Apply(v27, []any{v6, v4, v8}) +v20 = v28 +} else { +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("dissoc")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) } -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v17}) -v35 := lang.Apply(v30, []any{v3, v34}) -if lang.IsTruthy(v35) { -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("cons")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +v31 := v30.Get() +v32 := lang.Apply(v31, []any{v6, v4}) +v20 = v32 } -v38 := v37.Get() -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("partition")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +var v19 any = v20 +_ = v19 +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("flatten")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } -v41 := v40.Get() +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("map")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +var v40 lang.FnFunc +v40 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v41 := args[0] v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("nthrest")) +v43 := v42.FindInternedVar(lang.NewSymbol("cons")) if v43.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) } v44 := v43.Get() -v45 := lang.Apply(v44, []any{v15, v4}) -v46 := lang.Apply(v41, []any{v3, v4, v5, v45}) -v47 := lang.Apply(v38, []any{v17, v46}) -v27 = v47 -} else { -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("key")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) } -v50 := v49.Get() +v47 := v46.Get() +v48 := lang.Apply(v47, []any{v41}) +v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v50 := v49.FindInternedVar(lang.NewSymbol("interpose")) +if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) +} +v51 := v50.Get() +v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v53 := v52.FindInternedVar(lang.NewSymbol("key")) +if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) +} +v54 := v53.Get() +v55 := lang.Apply(v54, []any{v41}) +v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v57 := v56.FindInternedVar(lang.NewSymbol("val")) +if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) +} +v58 := v57.Get() +v59 := lang.Apply(v58, []any{v41}) +v60 := lang.Apply(v51, []any{v55, v59}) +v61 := lang.Apply(v44, []any{v48, v60}) +return v61 +}) +v41 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5699), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(5699), lang.NewKeyword("end-column"), int(70)) +v42, err := lang.WithMeta(v40, v41.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("seq")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +} +v45 := v44.Get() +v46 := lang.Apply(v45, []any{v19}) +v47 := lang.Apply(v39, []any{v42, v46}) +v48 := lang.Apply(v36, []any{v47}) +var v33 any = v48 +_ = v33 +var v50 any v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v52 := v51.FindInternedVar(lang.NewSymbol("take")) +v52 := v51.FindInternedVar(lang.NewSymbol("contains?")) if v52.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) } v53 := v52.Get() -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("concat")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +v54 := lang.Apply(v6, []any{v4}) +v55 := lang.Apply(v53, []any{v54, v5}) +if lang.IsTruthy(v55) { +v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v57 := v56.FindInternedVar(lang.NewSymbol("reduce1")) +if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) } -v56 := v55.Get() -v57 := lang.Apply(v56, []any{v17, v5}) -v58 := lang.Apply(v53, []any{v3, v57}) -v59 := lang.Apply(v50, []any{v58}) -v27 = v59 +v58 := v57.Get() +var v59 lang.FnFunc +v59 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v60 := args[0] +v61 := args[1] +v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v63 := v62.FindInternedVar(lang.NewSymbol("apply")) +if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) } -v14 = v27 -} else { -v14 = nil +v64 := v63.Get() +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("derive")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) } -return v14 +v67 := v66.Get() +v68 := lang.Apply(v64, []any{v67, v60, v61}) +return v68 }) -v8 := lang.Apply(lang1.NewLazySeq, []any{v7}) -return v8 +v60 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5702), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5702), lang.NewKeyword("end-column"), int(31)) +v61, err := lang.WithMeta(v59, v60.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v63 := v62.FindInternedVar(lang.NewSymbol("make-hierarchy")) +if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +} +v64 := v63.Get() +v65 := lang.Apply(v64, nil) +v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v67 := v66.FindInternedVar(lang.NewSymbol("partition")) +if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) +} +v68 := v67.Get() +v69 := lang.Apply(v68, []any{int64(2), v33}) +v70 := lang.Apply(v58, []any{v61, v65, v69}) +v50 = v70 +} else { +v50 = v3 +} +return v50 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -76079,197 +76726,52 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// defn- +// unquote { -v0 := lang.NewSymbol("defn-").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("decls"))), lang.NewKeyword("doc"), "same as defn, yielding non-public def", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4949), lang.NewKeyword("end-line"), int(4949))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("list*")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("with-meta")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("assoc")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("meta")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v5}) -v20 := lang.Apply(v15, []any{v19, lang.NewKeyword("private"), true}) -v21 := lang.Apply(v12, []any{v5, v20}) -v22 := lang.Apply(v9, []any{lang.NewSymbol("glojure.core/defn"), v21, v6}) -return v22 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) +v0 := lang.NewSymbol("unquote").WithMeta(lang.NewMap()).(*lang.Symbol) +v1 := ns.Intern(v0) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// bit-set +// unquote-splicing { -v0 := lang.NewSymbol("bit-set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Set bit at index n", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1342), lang.NewKeyword("end-line"), int(1342))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "setBit") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setBit is not a function"))) -} -v6 := lang.Apply(v5, []any{v3, v4}) -return v6 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) +v0 := lang.NewSymbol("unquote-splicing").WithMeta(lang.NewMap()).(*lang.Symbol) +v1 := ns.Intern(v0) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// halt-when +// unreduced { -v0 := lang.NewSymbol("halt-when").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred")), lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("retf"))), lang.NewKeyword("doc"), "Returns a transducer that ends transduction when pred returns true\n for an input. When retf is supplied it must be a fn of 2 arguments -\n it will be passed the (completed) result so far and the input that\n triggered the predicate, and its return value (if it does not throw\n an exception) will be the return value of the transducer. If retf\n is not supplied, the input that triggered the predicate will be\n returned. If the predicate never returns true the transduction is\n unaffected.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7700), lang.NewKeyword("end-line"), int(7700))).(*lang.Symbol) +v0 := lang.NewSymbol("unreduced").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "If x is reduced?, returns (deref x), else returns x", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2847), lang.NewKeyword("end-line"), int(2847))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("halt-when")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{v3, nil}) -return v7 - case 2: -v3 := args[0] -v4 := args[1] -var v5 lang.FnFunc -v5 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v6 := args[0] -var v7 lang.FnFunc -v7 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v8 := lang.Apply(v6, nil) -return v8 - case 1: -v8 := args[0] -var v9 any -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("map?")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v8}) -var v10 any = v14 -_ = v10 -var v16 any -if lang.IsTruthy(v10) { -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("contains?")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v8, lang.NewKeyword("glojure.core/halt")}) -v16 = v20 -} else { -v16 = v10 -} -if lang.IsTruthy(v16) { -v10 := lang.Apply(lang.NewKeyword("glojure.core/halt"), []any{v8}) -v9 = v10 -} else { -v11 := lang.Apply(v6, []any{v8}) -v9 = v11 -} -return v9 - case 2: -v8 := args[0] -v9 := args[1] -var v10 any -v11 := lang.Apply(v3, []any{v9}) -if lang.IsTruthy(v11) { -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("reduced")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -var v15 any -if lang.IsTruthy(v4) { -v16 := lang.Apply(v6, []any{v8}) -v17 := lang.Apply(v4, []any{v16, v9}) -v15 = v17 -} else { -v15 = v9 -} -v18 := lang.NewMap(lang.NewKeyword("glojure.core/halt"), v15) -v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7721), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(7721), lang.NewKeyword("end-column"), int(72)) -v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v21 := lang.Apply(v14, []any{v20}) -v10 = v21 -} else { -v22 := lang.Apply(v6, []any{v8, v9}) -v10 = v22 +v3 := args[0] +var v4 any +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("reduced?")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } -return v10 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7713), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7722), lang.NewKeyword("end-column"), int(34)) -v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) -if err != nil { - panic(err) +v7 := v6.Get() +v8 := lang.Apply(v7, []any{v3}) +if lang.IsTruthy(v8) { +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("deref")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -return v9 -}) -v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7712), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7722), lang.NewKeyword("end-column"), int(35)) -v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) -if err != nil { - panic(err) +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v3}) +v4 = v12 +} else { +v4 = v3 } -return v7 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } +return v4 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -76277,66 +76779,236 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// reader-conditional +// unsigned-bit-shift-right { -v0 := lang.NewSymbol("reader-conditional").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("form"), lang.NewSymbol("splicing?"))), lang.NewKeyword("doc"), "Construct a data representation of a reader conditional.\n If true, splicing? indicates read-cond-splicing.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7825), lang.NewKeyword("end-line"), int(7825))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { +var v1 lang.FnFunc +{ // function unsigned-bit-shift-right__inliner +v1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] v4 := args[1] -v5 := lang.Apply(nil, []any{v3, v4}) -return v5 +v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +} +v7 := v6.Get() +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("concat")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("list")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("list")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("list")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("seq")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("concat")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("list")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/unsignedShiftRight")}) +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v3}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.Apply(v38, []any{v4}) +v40 := lang.Apply(v27, []any{v31, v35, v39}) +v41 := lang.Apply(v24, []any{v40}) +v42 := lang.Apply(v21, []any{v41}) +v43 := lang.Apply(v10, []any{v14, v18, v42}) +v44 := lang.Apply(v7, []any{v43}) +return v44 }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) +v2 := v1 +_ = v2 +} +v0 := lang.NewSymbol("unsigned-bit-shift-right").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Bitwise shift right, without sign-extension.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(30), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1373), lang.NewKeyword("end-line"), int(1373))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := args[1] +v6, _ := lang.FieldOrMethod(lang1.Numbers, "unsignedShiftRight") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unsignedShiftRight is not a function"))) +} +v7 := lang.Apply(v6, []any{v4, v5}) +return v7 +}) +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// dosync +// update { -v0 := lang.NewSymbol("dosync").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("exprs"))), lang.NewKeyword("doc"), "Runs the exprs (in an implicit do) in a transaction that encompasses\n exprs and any nested calls. Starts a transaction if none is already\n running on this thread. Any uncaught exception will abort the\n transaction and flow out of dosync. The exprs may be run more than\n once, but any effects on Refs will be atomic.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5100), lang.NewKeyword("end-line"), int(5100))).(*lang.Symbol) +v0 := lang.NewSymbol("update").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f"), lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("z")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("z"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "'Updates' a value in an associative structure, where k is a\n key and f is a function that will take the old value\n and any supplied args and return the new value, and returns a new\n structure. If the key does not exist, nil is passed as the old value.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6217), lang.NewKeyword("end-line"), int(6217))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + case 3: v3 := args[0] v4 := args[1] -v5 := lang.NewList(args[2:]...) +v5 := args[2] v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("seq")) +v7 := v6.FindInternedVar(lang.NewSymbol("assoc")) if v7.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } v8 := v7.Get() v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("concat")) +v10 := v9.FindInternedVar(lang.NewSymbol("get")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v3, v4}) +v13 := lang.Apply(v5, []any{v12}) +v14 := lang.Apply(v8, []any{v3, v4, v13}) +return v14 + case 4: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("assoc")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +} +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("get")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{v3, v4}) +v14 := lang.Apply(v5, []any{v13, v6}) +v15 := lang.Apply(v9, []any{v3, v4, v14}) +return v15 + case 5: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := args[4] +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("assoc")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("get")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, []any{v3, v4}) +v15 := lang.Apply(v5, []any{v14, v6, v7}) +v16 := lang.Apply(v10, []any{v3, v4, v15}) +return v16 + case 6: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := args[4] +v8 := args[5] +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("assoc")) if v10.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } v11 := v10.Get() v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("list")) +v13 := v12.FindInternedVar(lang.NewSymbol("get")) if v13.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } v14 := v13.Get() -v15 := lang.Apply(v14, []any{lang.NewSymbol("glojure.core/sync")}) +v15 := lang.Apply(v14, []any{v3, v4}) +v16 := lang.Apply(v5, []any{v15, v6, v7, v8}) +v17 := lang.Apply(v11, []any{v3, v4, v16}) +return v17 + default: + if len(args) < 6 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := args[4] +v8 := args[5] +v9 := lang.NewList(args[6:]...) +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("assoc")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("apply")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("list")) +v17 := v16.FindInternedVar(lang.NewSymbol("get")) if v17.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } v18 := v17.Get() -v19 := lang.Apply(v18, []any{nil}) -v20 := lang.Apply(v11, []any{v15, v19, v5}) -v21 := lang.Apply(v8, []any{v20}) +v19 := lang.Apply(v18, []any{v3, v4}) +v20 := lang.Apply(v15, []any{v5, v19, v6, v7, v8, v9}) +v21 := lang.Apply(v12, []any{v3, v4, v20}) return v21 } }) @@ -76346,439 +77018,204 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// send +// update-in { -v0 := lang.NewSymbol("send").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Dispatch an action to an agent. Returns the agent immediately.\n Subsequently, in a thread from a thread pool, the state of the agent\n will be set to the value of:\n\n (apply action-fn state-of-agent args)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2109), lang.NewKeyword("end-line"), int(2109))).(*lang.Symbol) +v0 := lang.NewSymbol("update-in").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("ks"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "'Updates' a value in a nested associative structure, where ks is a\n sequence of keys and f is a function that will take the old value\n and any supplied args and return the new value, and returns a new\n nested structure. If any levels do not exist, hash-maps will be\n created.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6201), lang.NewKeyword("end-line"), int(6201))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 2 { + if len(args) < 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] v4 := args[1] -v5 := lang.NewList(args[2:]...) -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("apply")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("send-via")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v8, []any{v11, nil, v3, v4, v5}) -return v12 +v5 := args[2] +v6 := lang.NewList(args[3:]...) +var v8 lang.FnFunc +{ // function up +v8 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// refer -{ -v0 := lang.NewSymbol("refer").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns-sym"), lang.NewSymbol("&"), lang.NewSymbol("filters"))), lang.NewKeyword("doc"), "refers to all public vars of ns, subject to filters.\n filters can include at most one each of:\n\n :exclude list-of-symbols\n :only list-of-symbols\n :rename map-of-fromsymbol-tosymbol\n\n For each public interned var in the namespace named by the symbol,\n adds a mapping from the name of the var to the var to the current\n namespace. Throws an exception if name is already mapped to\n something else in the current namespace. Filters can be used to\n select a subset, via inclusion or exclusion, or to provide a mapping\n to a symbol different from the var's name, in order to prevent\n clashes. Use :use in the ns macro in preference to calling this directly.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4216), lang.NewKeyword("end-line"), int(4216))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.NewList(args[1:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("find-ns")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v3}) -var v6 any = v10 -_ = v6 -var v12 any -if lang.IsTruthy(v6) { -v12 = v6 -} else { -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("str")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{"No namespace: ", v3}) -v17 := lang.Apply(errors10.New, []any{v16}) -panic(v17) -} -var v5 any = v12 -_ = v5 -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("apply")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("hash-map")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v9, []any{v12, v4}) -var v6 any = v13 -_ = v6 -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("ns-publics")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v5}) -var v14 any = v18 +v10 := args[0] +v11 := args[1] +v12 := args[2] +v13 := args[3] +var v14 any = v11 _ = v14 -v21 := lang.Apply(lang.NewKeyword("rename"), []any{v6}) -var v20 any = v21 -_ = v20 -var v23 any -if lang.IsTruthy(v20) { -v23 = v20 -} else { -v24 := lang.NewMap() -v25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4236), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(4236), lang.NewKeyword("end-column"), int(36)) -v26, err := lang.WithMeta(v24, v25.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v23 = v26 +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("seq")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -var v19 any = v23 -_ = v19 +v18 := v17.Get() +v19 := lang.Apply(v18, []any{v14}) +var v15 any = v19 +_ = v15 v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("set")) +v22 := v21.FindInternedVar(lang.NewSymbol("first")) if v22.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } v23 := v22.Get() -v24 := lang.Apply(lang.NewKeyword("exclude"), []any{v6}) -v25 := lang.Apply(v23, []any{v24}) -var v20 any = v25 -_ = v20 -var v27 any -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("=")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(lang.NewKeyword("refer"), []any{v6}) -v32 := lang.Apply(v30, []any{lang.NewKeyword("all"), v31}) -if lang.IsTruthy(v32) { -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("keys")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v14}) -v27 = v36 -} else { -v38 := lang.Apply(lang.NewKeyword("refer"), []any{v6}) -var v37 any = v38 -_ = v37 -var v40 any -if lang.IsTruthy(v37) { -v40 = v37 -} else { -v42 := lang.Apply(lang.NewKeyword("only"), []any{v6}) -var v41 any = v42 -_ = v41 -var v44 any -if lang.IsTruthy(v41) { -v44 = v41 -} else { -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("keys")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.Apply(v47, []any{v14}) -v44 = v48 -} -v40 = v44 -} -v27 = v40 -} -var v26 any = v27 -_ = v26 -var v38 any -var v39 any = v26 -_ = v39 -var v41 any -if lang.IsTruthy(v39) { -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("not")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) -} -v44 := v43.Get() -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("instance?")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.Apply(v47, []any{lang1.Sequential, v26}) -v49 := lang.Apply(v44, []any{v48}) -v41 = v49 -} else { -v41 = v39 -} -if lang.IsTruthy(v41) { -v39 := lang.Apply(errors10.New, []any{":only/:refer value must be a sequential collection of symbols"}) -panic(v39) -} else { -v38 = nil -} -_ = v38 -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("seq")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v26}) -var v40 any = v44 -_ = v40 -var v45 any = nil -_ = v45 -var v46 any = int64(0) -_ = v46 -var v47 any = int64(0) -_ = v47 -var v48 any -for { -var v49 any -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("<")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.Apply(v52, []any{v47, v46}) -if lang.IsTruthy(v53) { -v55, _ := lang.FieldOrMethod(v45, "nth") -if reflect.TypeOf(v55).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) -} -v56 := lang.Apply(v55, []any{v47}) -var v54 any = v56 -_ = v54 -var v58 any -v59 := lang.Apply(v20, []any{v54}) -if lang.IsTruthy(v59) { -v58 = nil -} else { -v61 := lang.Apply(v14, []any{v54}) -var v60 any = v61 -_ = v60 -var v63 any -if lang.IsTruthy(v60) { -v63 = nil -} else { -panic("unimplemented: new with non-constant class type") -} -_ = v63 -v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v65 := v64.FindInternedVar(lang.NewSymbol("*ns*")) -if v65.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) -} -v66 := v65.Get() -v68 := lang.Apply(v19, []any{v54}) -var v67 any = v68 -_ = v67 -var v70 any -if lang.IsTruthy(v67) { -v70 = v67 -} else { -v70 = v54 -} -v67, _ := lang.FieldOrMethod(v66, "Refer") -if reflect.TypeOf(v67).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Refer is not a function"))) -} -v68 := lang.Apply(v67, []any{v70, v60}) -v58 = v68 -} -_ = v58 -var v60 any = v40 -var v61 any = v45 -var v62 any = v46 -v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v65 := v64.FindInternedVar(lang.NewSymbol("unchecked-inc")) -if v65.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) +v24 := lang.Apply(v23, []any{v15}) +var v20 any = v24 +_ = v20 +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("next")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) } -v66 := v65.Get() -v67 := lang.Apply(v66, []any{v47}) -var v63 any = v67 -v40 = v60 -v45 = v61 -v46 = v62 -v47 = v63 -continue -} else { -v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v56 := v55.FindInternedVar(lang.NewSymbol("seq")) -if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) +v28 := v27.Get() +v29 := lang.Apply(v28, []any{v25}) +var v25 any = v29 +_ = v25 +var v30 any = v20 +_ = v30 +var v31 any = v25 +_ = v31 +var v33 any +if lang.IsTruthy(v31) { +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("assoc")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } -v57 := v56.Get() -v58 := lang.Apply(v57, []any{v40}) -var v54 any = v58 -_ = v54 -var v60 any -if lang.IsTruthy(v54) { -var v61 any = v54 -_ = v61 -var v63 any -v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v65 := v64.FindInternedVar(lang.NewSymbol("chunked-seq?")) -if v65.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("get")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -v66 := v65.Get() -v67 := lang.Apply(v66, []any{v61}) -if lang.IsTruthy(v67) { -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("chunk-first")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v10, v30}) +v41 := lang.Apply(v9, []any{v40, v31, v12, v13}) +v42 := lang.Apply(v36, []any{v10, v30, v41}) +v33 = v42 +} else { +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("assoc")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) } -v71 := v70.Get() -v72 := lang.Apply(v71, []any{v61}) -var v68 any = v72 -_ = v68 -v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v76 := v75.FindInternedVar(lang.NewSymbol("chunk-rest")) -if v76.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) +v45 := v44.Get() +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("apply")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) } -v77 := v76.Get() -v78 := lang.Apply(v77, []any{v61}) -var v74 any = v78 -var v79 any = v68 -v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v82 := v81.FindInternedVar(lang.NewSymbol("int")) -if v82.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) +v48 := v47.Get() +v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v50 := v49.FindInternedVar(lang.NewSymbol("get")) +if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) } -v83 := v82.Get() -v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v85 := v84.FindInternedVar(lang.NewSymbol("count")) -if v85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) +v51 := v50.Get() +v52 := lang.Apply(v51, []any{v10, v30}) +v53 := lang.Apply(v48, []any{v12, v52, v13}) +v54 := lang.Apply(v45, []any{v10, v30, v53}) +v33 = v54 } -v86 := v85.Get() -v87 := lang.Apply(v86, []any{v68}) -v88 := lang.Apply(v83, []any{v87}) -var v80 any = v88 -v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v91 := v90.FindInternedVar(lang.NewSymbol("int")) -if v91.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) +return v33 +}) +v9 := v8 +_ = v9 } -v92 := v91.Get() -v93 := lang.Apply(v92, []any{int64(0)}) -var v89 any = v93 -v40 = v74 -v45 = v79 -v46 = v80 -v47 = v89 -continue -} else { -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("first")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6210), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(6214), lang.NewKeyword("end-column"), int(59)) +v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v71 := v70.Get() -v72 := lang.Apply(v71, []any{v61}) -var v68 any = v72 -_ = v68 -var v74 any -v75 := lang.Apply(v20, []any{v68}) -if lang.IsTruthy(v75) { -v74 = nil -} else { -v77 := lang.Apply(v14, []any{v68}) -var v76 any = v77 -_ = v76 -var v79 any -if lang.IsTruthy(v76) { -v79 = nil -} else { -panic("unimplemented: new with non-constant class type") +var v7 any = v10 +_ = v7 +v12 := lang.Apply(v7, []any{v3, v4, v5, v6}) +return v12 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -_ = v79 -v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v81 := v80.FindInternedVar(lang.NewSymbol("*ns*")) -if v81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) } -v82 := v81.Get() -v84 := lang.Apply(v19, []any{v68}) -var v83 any = v84 -_ = v83 -var v86 any -if lang.IsTruthy(v83) { -v86 = v83 -} else { -v86 = v68 +// update-keys +{ +v0 := lang.NewSymbol("update-keys").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("f"))), lang.NewKeyword("doc"), "m f => {(f k) v ...}\n\n Given a map m and a function f of 1-argument, returns a new map whose\n keys are the result of applying f to the keys of m, mapped to the\n corresponding values of m.\n f must return a unique key for each key of m, else the behavior is undefined.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7949), lang.NewKeyword("end-line"), int(7949))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("persistent!")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v83, _ := lang.FieldOrMethod(v82, "Refer") -if reflect.TypeOf(v83).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Refer is not a function"))) +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("reduce-kv")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -v84 := lang.Apply(v83, []any{v86, v76}) -v74 = v84 +v11 := v10.Get() +var v12 lang.FnFunc +v12 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v13 := args[0] +v14 := args[1] +v15 := args[2] +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("assoc!")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -_ = v74 -v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v78 := v77.FindInternedVar(lang.NewSymbol("next")) -if v78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) +v18 := v17.Get() +v19 := lang.Apply(v4, []any{v14}) +v20 := lang.Apply(v18, []any{v13, v19, v15}) +return v20 +}) +v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7959), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7959), lang.NewKeyword("end-column"), int(59)) +v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v79 := v78.Get() -v80 := lang.Apply(v79, []any{v61}) -var v76 any = v80 -var v81 any = nil -var v82 any = int64(0) -var v83 any = int64(0) -v40 = v76 -v45 = v81 -v46 = v82 -v47 = v83 -continue +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("transient")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } -v60 = v63 -} else { -v60 = nil +v17 := v16.Get() +v18 := lang.NewMap() +v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7960), lang.NewKeyword("column"), int(36), lang.NewKeyword("end-line"), int(7960), lang.NewKeyword("end-column"), int(37)) +v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v49 = v60 +v21 := lang.Apply(v17, []any{v20}) +v22 := lang.Apply(v11, []any{v14, v21, v3}) +v23 := lang.Apply(v8, []any{v22}) +var v5 any = v23 +_ = v5 +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("with-meta")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -v48 = v49 - break +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("meta")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } -return v48 - } +v30 := v29.Get() +v31 := lang.Apply(v30, []any{v3}) +v32 := lang.Apply(v27, []any{v5, v31}) +return v32 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -76786,301 +77223,291 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// >= +// update-vals { -var v1 lang.FnFunc -{ // function >=__inliner -v1 = lang.NewFnFunc(func(args ...any) any { +v0 := lang.NewSymbol("update-vals").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("f"))), lang.NewKeyword("doc"), "m f => {k (f v) ...}\n\n Given a map m and a function f of 1-argument, returns a new map where the keys of m\n are mapped to result of applying f to the corresponding values of m.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7933), lang.NewKeyword("end-line"), int(7933))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] v4 := args[1] v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +v6 := v5.FindInternedVar(lang.NewSymbol("with-meta")) if v6.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } v7 := v6.Get() v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("concat")) +v9 := v8.FindInternedVar(lang.NewSymbol("persistent!")) if v9.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } v10 := v9.Get() v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("list")) +v12 := v11.FindInternedVar(lang.NewSymbol("reduce-kv")) if v12.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } v13 := v12.Get() -v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +var v14 lang.FnFunc +v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v15 := args[0] +v16 := args[1] +v17 := args[2] +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("assoc!")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v20 := v19.Get() +v21 := lang.Apply(v4, []any{v17}) +v22 := lang.Apply(v20, []any{v15, v16, v21}) +return v22 +}) +v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7942), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(7942), lang.NewKeyword("end-column"), int(51)) +v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v21 := v20.Get() +var v17 any +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("instance?")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +} +v20 := v19.Get() +v21 := lang.Apply(v20, []any{lang1.IEditableCollection, v3}) +if lang.IsTruthy(v21) { v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("seq")) +v23 := v22.FindInternedVar(lang.NewSymbol("transient")) if v23.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("concat")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +v25 := lang.Apply(v24, []any{v3}) +v17 = v25 +} else { +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("transient")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) } -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("list")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +v28 := v27.Get() +v29 := lang.NewMap() +v30 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7945), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(7945), lang.NewKeyword("end-column"), int(31)) +v31, err := lang.WithMeta(v29, v30.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v30 := v29.Get() -v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/gte")}) -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +v32 := lang.Apply(v28, []any{v31}) +v17 = v32 } -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +v33 := lang.Apply(v13, []any{v16, v17, v3}) +v34 := lang.Apply(v10, []any{v33}) +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("meta")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) } -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v4}) -v40 := lang.Apply(v27, []any{v31, v35, v39}) -v41 := lang.Apply(v24, []any{v40}) -v42 := lang.Apply(v21, []any{v41}) -v43 := lang.Apply(v10, []any{v14, v18, v42}) -v44 := lang.Apply(v7, []any{v43}) -return v44 +v37 := v36.Get() +v38 := lang.Apply(v37, []any{v3}) +v39 := lang.Apply(v7, []any{v34, v38}) +return v39 }) -v2 := v1 -_ = v2 +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v0 := lang.NewSymbol(">=").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns non-nil if nums are in monotonically non-increasing order,\n otherwise false.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1078), lang.NewKeyword("end-line"), int(1078))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v4 := args[0] -return true - case 2: -v4 := args[0] -v5 := args[1] -v6, _ := lang.FieldOrMethod(lang1.Numbers, "gte") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("gte is not a function"))) } -v7 := lang.Apply(v6, []any{v4, v5}) +// uri? +{ +v0 := lang.NewSymbol("uri?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a java.net.URI", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7920), lang.NewKeyword("end-line"), int(7920))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() +v7 := lang.Apply(v6, []any{java.net34.URI, v3}) return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// use +{ +v0 := lang.NewSymbol("use").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Like 'require, but also refers to each lib's namespace using\n glojure.core/refer. Use :use in the ns macro in preference to calling\n this directly.\n\n 'use accepts additional options in libspecs: :exclude, :only, :rename.\n The arguments and semantics for :exclude, :only, and :rename are the same\n as those documented for glojure.core/refer.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6122), lang.NewKeyword("end-line"), int(6122))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { default: - if len(args) < 2 { + if len(args) < 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v4 := args[0] -v5 := args[1] -v6 := lang.NewList(args[2:]...) -recur_loop_202: -var v7 any -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol(">=")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v4, v5}) -if lang.IsTruthy(v11) { -var v12 any -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("next")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v6}) -if lang.IsTruthy(v16) { -var v17 any = v5 -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("first")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v6}) -var v18 any = v22 -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("next")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v6}) -var v23 any = v27 -v4 = v17 -v5 = v18 -v6 = v23 -goto recur_loop_202 -} else { -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol(">=")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("first")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v6}) -v35 := lang.Apply(v30, []any{v5, v34}) -v12 = v35 +v3 := lang.NewList(args[0:]...) +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("apply")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v7 = v12 -} else { -v7 = false +v6 := v5.Get() +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("load-libs")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -return v7 +v9 := v8.Get() +v10 := lang.Apply(v6, []any{v9, lang.NewKeyword("require"), lang.NewKeyword("use"), v3}) +return v10 } }) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// unchecked-dec-int +// uuid? { -var v1 lang.FnFunc -{ // function unchecked-dec-int__inliner -v1 = lang.NewFnFunc(func(args ...any) any { +v0 := lang.NewSymbol("uuid?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a java.util.UUID", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6890), lang.NewKeyword("end-line"), int(6890))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v7 := lang.Apply(v6, []any{java.util26.UUID, v3}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +// val +{ +v0 := lang.NewSymbol("val").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("e"))), lang.NewKeyword("doc"), "Returns the value in the map entry.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1570), lang.NewKeyword("end-line"), int(1570))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, _ := lang.FieldOrMethod(v3, "GetValue") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("GetValue is not a function"))) } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v5 := lang.Apply(v4, []any{}) +return v5 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +// vals +{ +v0 := lang.NewSymbol("vals").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"))), lang.NewKeyword("doc"), "Returns a sequence of the map's values, in the same order as (seq map).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1557), lang.NewKeyword("end-line"), int(1557))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := lang.Apply(lang1.Vals, []any{v3}) +return v4 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/unchecked_int_dec")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +// var-get +{ +v0 := lang.NewSymbol("var-get").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Gets the value in the var object", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4326), lang.NewKeyword("end-line"), int(4326))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4, _ := lang.FieldOrMethod(v3, "Get") +if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Get is not a function"))) } -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v3}) -v35 := lang.Apply(v26, []any{v30, v34}) -v36 := lang.Apply(v23, []any{v35}) -v37 := lang.Apply(v20, []any{v36}) -v38 := lang.Apply(v9, []any{v13, v17, v37}) -v39 := lang.Apply(v6, []any{v38}) -return v39 +v5 := lang.Apply(v4, []any{}) +return v5 }) -v2 := v1 -_ = v2 +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v0 := lang.NewSymbol("unchecked-dec-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns a number one less than x, an int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1168), lang.NewKeyword("end-line"), int(1168))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { +} +// var-set +{ +v0 := lang.NewSymbol("var-set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Sets the value in the var object to val. The var must be\n thread-locally bound.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4332), lang.NewKeyword("end-line"), int(4332))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "unchecked_int_dec") +v3 := args[0] +v4 := args[1] +v5, _ := lang.FieldOrMethod(v3, "Set") if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_dec is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Set is not a function"))) } v6 := lang.Apply(v5, []any{v4}) return v6 }) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// array +// var? { -v0 := lang.NewSymbol("array").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3457), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3458), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("items"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v0 := lang.NewSymbol("var?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("v"))), lang.NewKeyword("doc"), "Returns true if v is of type glojure.lang.Var", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4999), lang.NewKeyword("end-line"), int(4999))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewList(args[0:]...) + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("into-array")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -v7 := lang.Apply(v6, []any{v3}) +v7 := lang.Apply(v6, []any{lang1.*Var, v3}) return v7 - } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -77088,150 +77515,41 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// let +// vary-meta { -v0 := lang.NewSymbol("let").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "binding => binding-form init-expr\n binding-form => name, or destructuring-form\n destructuring-form => map-destructure-form, or seq-destructure-form\n\n Evaluates the exprs in a lexical context in which the symbols in\n the binding-forms are bound to their respective init-exprs or parts\n therein.\n\n See https://glojure.org/reference/special_forms#binding-forms for\n more information about destructuring.", lang.NewKeyword("forms"), lang.NewVector(lang.NewList(lang.NewSymbol("let"), lang.NewVector(lang.NewSymbol("bindings*")), lang.NewSymbol("exprs*"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4496), lang.NewKeyword("end-line"), int(4496), lang.NewKeyword("special-form"), true)).(*lang.Symbol) +v0 := lang.NewSymbol("vary-meta").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("obj"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Returns an object of the same type and value as obj, with\n (apply f (meta obj) args) as its metadata.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(668), lang.NewKeyword("end-line"), int(668))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 3 { + if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -var v7 any -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v5 := lang.NewList(args[2:]...) +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("with-meta")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v5}) -if lang.IsTruthy(v11) { -v7 = nil -} else { +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("apply")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("str")) +v13 := v12.FindInternedVar(lang.NewSymbol("meta")) if v13.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("first")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v3}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("meta")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) -v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) -v28 := lang.Apply(lang1.NewIllegalArgumentError, []any{v27}) -panic(v28) -} -_ = v7 -var v29 any -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("even?")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("count")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v5}) -v37 := lang.Apply(v32, []any{v36}) -if lang.IsTruthy(v37) { -v29 = nil -} else { -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("str")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("first")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v3}) -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("meta")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v3}) -v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) -v53 := lang.Apply(v40, []any{v44, " requires ", "an even number of forms in binding vector", " in ", v47, ":", v52}) -v54 := lang.Apply(lang1.NewIllegalArgumentError, []any{v53}) -panic(v54) -} -_ = v29 -_ = nil -v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v56 := v55.FindInternedVar(lang.NewSymbol("seq")) -if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) -} -v57 := v56.Get() -v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v59 := v58.FindInternedVar(lang.NewSymbol("concat")) -if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) -} -v60 := v59.Get() -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("list")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) -} -v63 := v62.Get() -v64 := lang.Apply(v63, []any{lang.NewSymbol("let*")}) -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("list")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) -} -v67 := v66.Get() -v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v69 := v68.FindInternedVar(lang.NewSymbol("destructure")) -if v69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) -} -v70 := v69.Get() -v71 := lang.Apply(v70, []any{v5}) -v72 := lang.Apply(v67, []any{v71}) -v73 := lang.Apply(v60, []any{v64, v72, v6}) -v74 := lang.Apply(v57, []any{v73}) -return v74 +v15 := lang.Apply(v14, []any{v3}) +v16 := lang.Apply(v11, []any{v4, v15, v5}) +v17 := lang.Apply(v8, []any{v3, v16}) +return v17 } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -77240,9 +77558,9 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// not-empty +// vec { -v0 := lang.NewSymbol("not-empty").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "If coll is empty, returns nil, else coll", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5559), lang.NewKeyword("end-line"), int(5559))).(*lang.Symbol) +v0 := lang.NewSymbol("vec").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Creates a new vector containing the contents of coll. Java arrays\n will be aliased and should not be modified.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(366), lang.NewKeyword("end-line"), int(366))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -77251,16 +77569,38 @@ v2 = lang.NewFnFunc(func(args ...any) any { v3 := args[0] var v4 any v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq")) +v6 := v5.FindInternedVar(lang.NewSymbol("vector?")) if v6.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } v7 := v6.Get() v8 := lang.Apply(v7, []any{v3}) if lang.IsTruthy(v8) { -v4 = v3 +var v9 any +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("instance?")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +} +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang1.IObj, v3}) +if lang.IsTruthy(v13) { +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("with-meta")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +} +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v3, nil}) +v9 = v17 } else { -v4 = nil +v18 := lang.Apply(lang1.CreateLazilyPersistentVector, []any{v3}) +v9 = v18 +} +v4 = v9 +} else { +v19 := lang.Apply(lang1.CreateLazilyPersistentVector, []any{v3}) +v4 = v19 } return v4 }) @@ -77270,169 +77610,144 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// and +// vector { -v0 := lang.NewSymbol("and").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("next"))), lang.NewKeyword("doc"), "Evaluates exprs one at a time, from left to right. If a form\n returns logical false (nil or false), and returns that value and\n doesn't evaluate any of the other expressions, otherwise it returns\n the value of the last expr. (and) returns true.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(835), lang.NewKeyword("end-line"), int(835))).(*lang.Symbol) +v0 := lang.NewSymbol("vector").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("a")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d"), lang.NewSymbol("e")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d"), lang.NewSymbol("e"), lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d"), lang.NewSymbol("e"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Creates a new vector containing the args.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(352), lang.NewKeyword("end-line"), int(352))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { + case 0: +v3 := lang.NewVector() +v4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(356), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(356), lang.NewKeyword("end-column"), int(8)) +v5, err := lang.WithMeta(v3, v4.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v5 + case 1: +v3 := args[0] +v4 := lang.NewVector(v3) +v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(357), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(357), lang.NewKeyword("end-column"), int(10)) +v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v6 case 2: v3 := args[0] v4 := args[1] -return true +v5 := lang.NewVector(v3, v4) +v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(358), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(358), lang.NewKeyword("end-column"), int(14)) +v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v7 case 3: v3 := args[0] v4 := args[1] v5 := args[2] -return v5 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } +v6 := lang.NewVector(v3, v4, v5) +v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(359), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(359), lang.NewKeyword("end-column"), int(18)) +v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +return v8 + case 4: v3 := args[0] v4 := args[1] v5 := args[2] -v6 := lang.NewList(args[3:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("seq")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("concat")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("list")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/let")}) -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("list")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("apply")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("vector")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("seq")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("concat")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{lang.NewSymbol("and__0__auto__")}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v5}) -v40 := lang.Apply(v31, []any{v35, v39}) -v41 := lang.Apply(v28, []any{v40}) -v42 := lang.Apply(v22, []any{v25, v41}) -v43 := lang.Apply(v19, []any{v42}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("seq")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) -} -v49 := v48.Get() -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("concat")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +v6 := args[3] +v7 := lang.NewVector(v3, v4, v5, v6) +v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(360), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(360), lang.NewKeyword("end-column"), int(22)) +v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v52 := v51.Get() -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("list")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +return v9 + case 5: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := args[4] +v8 := lang.NewVector(v3, v4, v5, v6, v7) +v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(361), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(361), lang.NewKeyword("end-column"), int(25)) +v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v55 := v54.Get() -v56 := lang.Apply(v55, []any{lang.NewSymbol("if")}) -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("list")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +return v10 + case 6: +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := args[4] +v8 := args[5] +v9 := lang.NewVector(v3, v4, v5, v6, v7, v8) +v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(362), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(362), lang.NewKeyword("end-column"), int(29)) +v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v59 := v58.Get() -v60 := lang.Apply(v59, []any{lang.NewSymbol("and__0__auto__")}) -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("list")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) +return v11 + default: + if len(args) < 6 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := args[3] +v7 := args[4] +v8 := args[5] +v9 := lang.NewList(args[6:]...) +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("cons")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v63 := v62.Get() -v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v65 := v64.FindInternedVar(lang.NewSymbol("seq")) -if v65.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("cons")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } -v66 := v65.Get() -v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v68 := v67.FindInternedVar(lang.NewSymbol("concat")) -if v68.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) +v15 := v14.Get() +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("cons")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) } -v69 := v68.Get() -v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v71 := v70.FindInternedVar(lang.NewSymbol("list")) -if v71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) +v18 := v17.Get() +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("cons")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v72 := v71.Get() -v73 := lang.Apply(v72, []any{lang.NewSymbol("glojure.core/and")}) -v74 := lang.Apply(v69, []any{v73, v6}) -v75 := lang.Apply(v66, []any{v74}) -v76 := lang.Apply(v63, []any{v75}) -v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v78 := v77.FindInternedVar(lang.NewSymbol("list")) -if v78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("cons")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -v79 := v78.Get() -v80 := lang.Apply(v79, []any{lang.NewSymbol("and__0__auto__")}) -v81 := lang.Apply(v52, []any{v56, v60, v76, v80}) -v82 := lang.Apply(v49, []any{v81}) -v83 := lang.Apply(v46, []any{v82}) -v84 := lang.Apply(v12, []any{v16, v43, v83}) -v85 := lang.Apply(v9, []any{v84}) -return v85 +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("cons")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.Apply(v27, []any{v8, v9}) +v29 := lang.Apply(v24, []any{v7, v28}) +v30 := lang.Apply(v21, []any{v6, v29}) +v31 := lang.Apply(v18, []any{v5, v30}) +v32 := lang.Apply(v15, []any{v4, v31}) +v33 := lang.Apply(v12, []any{v3, v32}) +v34 := lang.Apply(lang1.CreateLazilyPersistentVector, []any{v33}) +return v34 } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -77441,828 +77756,599 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// shuffle +// vector? { -v0 := lang.NewSymbol("shuffle").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return a random permutation of coll", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7343), lang.NewKeyword("end-line"), int(7343))).(*lang.Symbol) +v0 := lang.NewSymbol("vector?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x implements IPersistentVector", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(174), lang.NewKeyword("end-line"), int(178))).(*lang.Symbol) var v2 lang.FnFunc +{ // function vector? v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := args[0] +v4 := args[0] v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("to-array")) +v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) if v6.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -v9 := lang.Apply(lang1.NewArrayList, []any{v8}) -var v4 any = v9 -_ = v4 -v11 := lang.Apply(nil, []any{v4}) -_ = v11 -v12, ok := lang.FieldOrMethod(v4, "toArray") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "toArray"))) -} -var v13 any -switch reflect.TypeOf(v12).Kind() { -case reflect.Func: - v13 = lang.Apply(v12, nil) -default: - v13 = v12 -} -v14 := lang.Apply(nil, []any{v13}) -return v14 +v8 := lang.Apply(v7, []any{lang1.IPersistentVector, v4}) +return v8 }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(178), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(178), lang.NewKeyword("end-column"), int(106))).(lang.FnFunc) +v3 := v2 +_ = v3 +} v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// every-pred +// volatile! { -v0 := lang.NewSymbol("every-pred").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("p")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2"), lang.NewSymbol("p3")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2"), lang.NewSymbol("p3"), lang.NewSymbol("&"), lang.NewSymbol("ps"))), lang.NewKeyword("doc"), "Takes a set of predicates and returns a function f that returns true if all of its\n composing predicates return a logical true value against all of its arguments, else it returns\n false. Note that f is short-circuiting in that it will stop execution on the first\n argument that triggers a logical false result against the original predicates.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7465), lang.NewKeyword("end-line"), int(7465))).(*lang.Symbol) +v1 := reflect.TypeOf((*lang1.Volatile)(nil)).Elem() +v0 := lang.NewSymbol("volatile!").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Creates and returns a Volatile with an initial value of val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2517), lang.NewKeyword("end-line"), int(2517))).(*lang.Symbol) +var v3 lang.FnFunc +v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v4 := args[0] +v5 := lang.Apply(lang1.NewVolatile, []any{v4}) +return v5 +}) +v4 := reflect.TypeOf((*lang1.Volatile)(nil)).Elem() +v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) +v2 := ns.InternWithValue(v0, v3, true) +if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +} +} +// volatile? +{ +v0 := lang.NewSymbol("volatile?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is a volatile.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2540), lang.NewKeyword("end-line"), int(2540))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] -var v4 lang.FnFunc -{ // function ep1 -v4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -return true - case 1: -v6 := args[0] -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("boolean")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } -v9 := v8.Get() -v10 := lang.Apply(v3, []any{v6}) -v11 := lang.Apply(v9, []any{v10}) -return v11 - case 2: -v6 := args[0] -v7 := args[1] -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("boolean")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v6 := v5.Get() +v7 := lang.Apply(v6, []any{lang1.Volatile, v3}) +return v7 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v10 := v9.Get() -v12 := lang.Apply(v3, []any{v6}) -var v11 any = v12 -_ = v11 -var v14 any -if lang.IsTruthy(v11) { -v15 := lang.Apply(v3, []any{v7}) -v14 = v15 -} else { -v14 = v11 } -v11 := lang.Apply(v10, []any{v14}) -return v11 - case 3: -v6 := args[0] -v7 := args[1] -v8 := args[2] -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("boolean")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +// vreset! +{ +v0 := lang.NewSymbol("vreset!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("vol"), lang.NewSymbol("newval"))), lang.NewKeyword("doc"), "Sets the value of volatile to newval without regard for the\n current value. Returns newval.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2524), lang.NewKeyword("end-line"), int(2524))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5, _ := lang.FieldOrMethod(v3, "reset") +if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) } -v11 := v10.Get() -v13 := lang.Apply(v3, []any{v6}) -var v12 any = v13 -_ = v12 -var v15 any -if lang.IsTruthy(v12) { -v17 := lang.Apply(v3, []any{v7}) -var v16 any = v17 -_ = v16 -var v19 any -if lang.IsTruthy(v16) { -v20 := lang.Apply(v3, []any{v8}) -v19 = v20 -} else { -v19 = v16 +v6 := lang.Apply(v5, []any{v4}) +return v6 +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v15 = v19 -} else { -v15 = v12 } -v12 := lang.Apply(v11, []any{v15}) -return v12 +// vswap! +{ +v0 := lang.NewSymbol("vswap!").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("vol"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Non-atomically swaps the value of the volatile as if:\n (apply f current-value-of-vol args). Returns the value that\n was swapped in.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(2531), lang.NewKeyword("end-line"), int(2531))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { default: - if len(args) < 3 { + if len(args) < 4 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v6 := args[0] -v7 := args[1] -v8 := args[2] -v9 := lang.NewList(args[3:]...) -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("boolean")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v14 := lang.Apply(v5, []any{v6, v7, v8}) -var v13 any = v14 -_ = v13 -var v16 any -if lang.IsTruthy(v13) { -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("every?")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v3, v9}) -v16 = v20 -} else { -v16 = v13 -} -v13 := lang.Apply(v12, []any{v16}) -return v13 - } -}) -v5 := v4 -_ = v5 -} -v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7472), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7478), lang.NewKeyword("end-column"), int(56)) -v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v6 - case 2: v3 := args[0] v4 := args[1] -var v5 lang.FnFunc -{ // function ep2 -v5 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -return true - case 1: -v7 := args[0] -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("boolean")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v12 := lang.Apply(v3, []any{v7}) -var v11 any = v12 -_ = v11 -var v14 any -if lang.IsTruthy(v11) { -v15 := lang.Apply(v4, []any{v7}) -v14 = v15 -} else { -v14 = v11 -} -v11 := lang.Apply(v10, []any{v14}) -return v11 - case 2: -v7 := args[0] -v8 := args[1] +v5 := args[2] +v6 := args[3] +v7 := lang.NewList(args[4:]...) v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("boolean")) +v10 := v9.FindInternedVar(lang.NewSymbol("with-meta")) if v10.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } v11 := v10.Get() -v13 := lang.Apply(v3, []any{v7}) -var v12 any = v13 -_ = v12 -var v15 any -if lang.IsTruthy(v12) { -v17 := lang.Apply(v3, []any{v8}) -var v16 any = v17 -_ = v16 -var v19 any -if lang.IsTruthy(v16) { -v21 := lang.Apply(v4, []any{v7}) -var v20 any = v21 -_ = v20 -var v23 any -if lang.IsTruthy(v20) { -v24 := lang.Apply(v4, []any{v8}) -v23 = v24 -} else { -v23 = v20 -} -v19 = v23 -} else { -v19 = v16 +v12 := lang.NewMap(lang.NewKeyword("tag"), lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Volatile")) +v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2537), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(2537), lang.NewKeyword("end-column"), int(81)) +v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v15 = v19 -} else { -v15 = v12 +v15 := lang.Apply(v11, []any{v5, v14}) +var v8 any = v15 +_ = v8 +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v12 := lang.Apply(v11, []any{v15}) -return v12 - case 3: -v7 := args[0] -v8 := args[1] -v9 := args[2] -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("boolean")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("concat")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v12 := v11.Get() -v14 := lang.Apply(v3, []any{v7}) -var v13 any = v14 -_ = v13 -var v16 any -if lang.IsTruthy(v13) { -v18 := lang.Apply(v3, []any{v8}) -var v17 any = v18 -_ = v17 -var v20 any -if lang.IsTruthy(v17) { -v22 := lang.Apply(v3, []any{v9}) -var v21 any = v22 -_ = v21 -var v24 any -if lang.IsTruthy(v21) { -v26 := lang.Apply(v4, []any{v7}) -var v25 any = v26 -_ = v25 -var v28 any -if lang.IsTruthy(v25) { -v30 := lang.Apply(v4, []any{v8}) -var v29 any = v30 -_ = v29 -var v32 any -if lang.IsTruthy(v29) { -v33 := lang.Apply(v4, []any{v9}) -v32 = v33 -} else { -v32 = v29 +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("list")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v28 = v32 -} else { -v28 = v25 +v25 := v24.Get() +v26 := lang.Apply(v25, []any{lang.NewSymbol(".reset")}) +v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v28 := v27.FindInternedVar(lang.NewSymbol("list")) +if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } -v24 = v28 -} else { -v24 = v21 +v29 := v28.Get() +v30 := lang.Apply(v29, []any{v8}) +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -v20 = v24 -} else { -v20 = v17 +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } -v16 = v20 -} else { -v16 = v13 +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -v13 := lang.Apply(v12, []any{v16}) -return v13 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v7 := args[0] -v8 := args[1] -v9 := args[2] -v10 := lang.NewList(args[3:]...) -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("boolean")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) } -v13 := v12.Get() -v15 := lang.Apply(v6, []any{v7, v8, v9}) -var v14 any = v15 -_ = v14 -var v17 any -if lang.IsTruthy(v14) { -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("every?")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v42 := v41.Get() +v43 := lang.Apply(v42, []any{v6}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } -v20 := v19.Get() -var v21 lang.FnFunc -v21 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v22 := args[0] -v24 := lang.Apply(v3, []any{v22}) -var v23 any = v24 -_ = v23 -var v26 any -if lang.IsTruthy(v23) { -v27 := lang.Apply(v4, []any{v22}) -v26 = v27 -} else { -v26 = v23 +v46 := v45.Get() +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("seq")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) } -return v26 -}) -v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7486), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(7486), lang.NewKeyword("end-column"), int(65)) -v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) -if err != nil { - panic(err) +v49 := v48.Get() +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("concat")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) } -v24 := lang.Apply(v20, []any{v23, v10}) -v17 = v24 -} else { -v17 = v14 +v52 := v51.Get() +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("list")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) } -v14 := lang.Apply(v13, []any{v17}) -return v14 +v55 := v54.Get() +v56 := lang.Apply(v55, []any{lang.NewSymbol(".Deref")}) +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("list")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +} +v59 := v58.Get() +v60 := lang.Apply(v59, []any{v8}) +v61 := lang.Apply(v52, []any{v56, v60}) +v62 := lang.Apply(v49, []any{v61}) +v63 := lang.Apply(v46, []any{v62}) +v64 := lang.Apply(v39, []any{v43, v63, v7}) +v65 := lang.Apply(v36, []any{v64}) +v66 := lang.Apply(v33, []any{v65}) +v67 := lang.Apply(v22, []any{v26, v30, v66}) +v68 := lang.Apply(v19, []any{v67}) +return v68 } }) -v6 := v5 -_ = v6 +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7480), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7486), lang.NewKeyword("end-column"), int(75)) -v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) -if err != nil { - panic(err) } -return v7 - case 3: +// when +{ +v0 := lang.NewSymbol("when").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("test"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Evaluates test. If logical true, evaluates body in an implicit do.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(492), lang.NewKeyword("end-line"), int(492))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] v4 := args[1] v5 := args[2] -var v6 lang.FnFunc -{ // function ep3 -v6 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -return true - case 1: -v8 := args[0] -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("boolean")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v13 := lang.Apply(v3, []any{v8}) -var v12 any = v13 -_ = v12 -var v15 any -if lang.IsTruthy(v12) { -v17 := lang.Apply(v4, []any{v8}) -var v16 any = v17 -_ = v16 -var v19 any -if lang.IsTruthy(v16) { -v20 := lang.Apply(v5, []any{v8}) -v19 = v20 -} else { -v19 = v16 -} -v15 = v19 -} else { -v15 = v12 +v6 := lang.NewList(args[3:]...) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("list")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v12 := lang.Apply(v11, []any{v15}) -return v12 - case 2: -v8 := args[0] -v9 := args[1] +v9 := v8.Get() v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("boolean")) +v11 := v10.FindInternedVar(lang.NewSymbol("cons")) if v11.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } v12 := v11.Get() -v14 := lang.Apply(v3, []any{v8}) -var v13 any = v14 -_ = v13 -var v16 any -if lang.IsTruthy(v13) { -v18 := lang.Apply(v3, []any{v9}) -var v17 any = v18 -_ = v17 -var v20 any -if lang.IsTruthy(v17) { -v22 := lang.Apply(v4, []any{v8}) -var v21 any = v22 -_ = v21 -var v24 any -if lang.IsTruthy(v21) { -v26 := lang.Apply(v4, []any{v9}) -var v25 any = v26 -_ = v25 -var v28 any -if lang.IsTruthy(v25) { -v30 := lang.Apply(v5, []any{v8}) -var v29 any = v30 -_ = v29 -var v32 any -if lang.IsTruthy(v29) { -v33 := lang.Apply(v5, []any{v9}) -v32 = v33 -} else { -v32 = v29 +v13 := lang.Apply(v12, []any{lang.NewSymbol("do"), v6}) +v14 := lang.Apply(v9, []any{lang.NewSymbol("if"), v5, v13}) +return v14 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v28 = v32 -} else { -v28 = v25 } -v24 = v28 -} else { -v24 = v21 +// when-first +{ +v0 := lang.NewSymbol("when-first").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "bindings => x xs\n\n Roughly the same as (when (seq xs) (let [x (first xs)] body)) but xs is evaluated only once", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4622), lang.NewKeyword("end-line"), int(4622))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +var v7 any +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v20 = v24 +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v5}) +if lang.IsTruthy(v11) { +v7 = nil } else { -v20 = v17 +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("str")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } -v16 = v20 -} else { -v16 = v13 +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("first")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } -v13 := lang.Apply(v12, []any{v16}) -return v13 - case 3: -v8 := args[0] -v9 := args[1] -v10 := args[2] -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("boolean")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v3}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v13 := v12.Get() -v15 := lang.Apply(v3, []any{v8}) -var v14 any = v15 -_ = v14 -var v17 any -if lang.IsTruthy(v14) { -v19 := lang.Apply(v3, []any{v9}) -var v18 any = v19 -_ = v18 -var v21 any -if lang.IsTruthy(v18) { -v23 := lang.Apply(v3, []any{v10}) -var v22 any = v23 -_ = v22 -var v25 any -if lang.IsTruthy(v22) { -v27 := lang.Apply(v4, []any{v8}) -var v26 any = v27 -_ = v26 +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("meta")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v3}) +v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) +v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) +v28 := lang.Apply(lang1.NewIllegalArgumentError, []any{v27}) +panic(v28) +} +_ = v7 var v29 any -if lang.IsTruthy(v26) { -v31 := lang.Apply(v4, []any{v9}) -var v30 any = v31 -_ = v30 -var v33 any -if lang.IsTruthy(v30) { -v35 := lang.Apply(v4, []any{v10}) -var v34 any = v35 -_ = v34 -var v37 any -if lang.IsTruthy(v34) { -v39 := lang.Apply(v5, []any{v8}) -var v38 any = v39 -_ = v38 -var v41 any -if lang.IsTruthy(v38) { -v43 := lang.Apply(v5, []any{v9}) -var v42 any = v43 -_ = v42 -var v45 any -if lang.IsTruthy(v42) { -v46 := lang.Apply(v5, []any{v10}) -v45 = v46 -} else { -v45 = v42 +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("=")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) } -v41 = v45 -} else { -v41 = v38 +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("count")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) } -v37 = v41 +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v5}) +v37 := lang.Apply(v32, []any{int64(2), v36}) +if lang.IsTruthy(v37) { +v29 = nil } else { -v37 = v34 +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("str")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) } -v33 = v37 -} else { -v33 = v30 +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("first")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } -v29 = v33 -} else { -v29 = v26 +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v3}) +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) } -v25 = v29 -} else { -v25 = v22 +v47 := v46.Get() +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("meta")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) } -v21 = v25 -} else { -v21 = v18 +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v3}) +v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) +v53 := lang.Apply(v40, []any{v44, " requires ", "exactly 2 forms in binding vector", " in ", v47, ":", v52}) +v54 := lang.Apply(lang1.NewIllegalArgumentError, []any{v53}) +panic(v54) } -v17 = v21 -} else { -v17 = v14 +_ = v29 +_ = nil +var v55 any = v5 +_ = v55 +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("nth")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) } -v14 := lang.Apply(v13, []any{v17}) -return v14 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v8 := args[0] -v9 := args[1] -v10 := args[2] -v11 := lang.NewList(args[3:]...) -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("boolean")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +v59 := v58.Get() +v60 := lang.Apply(v59, []any{v55, int64(0), nil}) +var v56 any = v60 +_ = v56 +v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v63 := v62.FindInternedVar(lang.NewSymbol("nth")) +if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) } -v14 := v13.Get() -v16 := lang.Apply(v7, []any{v8, v9, v10}) -var v15 any = v16 -_ = v15 -var v18 any -if lang.IsTruthy(v15) { -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("every?")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v64 := v63.Get() +v65 := lang.Apply(v64, []any{v55, int64(1), nil}) +var v61 any = v65 +_ = v61 +v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v68 := v67.FindInternedVar(lang.NewSymbol("seq")) +if v68.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) } -v21 := v20.Get() -var v22 lang.FnFunc -v22 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v23 := args[0] -v25 := lang.Apply(v3, []any{v23}) -var v24 any = v25 -_ = v24 -var v27 any -if lang.IsTruthy(v24) { -v29 := lang.Apply(v4, []any{v23}) -var v28 any = v29 -_ = v28 -var v31 any -if lang.IsTruthy(v28) { -v32 := lang.Apply(v5, []any{v23}) -v31 = v32 -} else { -v31 = v28 +v69 := v68.Get() +v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v71 := v70.FindInternedVar(lang.NewSymbol("concat")) +if v71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) } -v27 = v31 -} else { -v27 = v24 +v72 := v71.Get() +v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v74 := v73.FindInternedVar(lang.NewSymbol("list")) +if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) } -return v27 -}) -v23 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7494), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(7494), lang.NewKeyword("end-column"), int(72)) -v24, err := lang.WithMeta(v22, v23.(lang.IPersistentMap)) -if err != nil { - panic(err) +v75 := v74.Get() +v76 := lang.Apply(v75, []any{lang.NewSymbol("glojure.core/when-let")}) +v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v78 := v77.FindInternedVar(lang.NewSymbol("list")) +if v78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) } -v25 := lang.Apply(v21, []any{v24, v11}) -v18 = v25 -} else { -v18 = v15 +v79 := v78.Get() +v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v81 := v80.FindInternedVar(lang.NewSymbol("apply")) +if v81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) } -v15 := lang.Apply(v14, []any{v18}) -return v15 - } -}) -v7 := v6 -_ = v7 +v82 := v81.Get() +v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v84 := v83.FindInternedVar(lang.NewSymbol("vector")) +if v84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) } -v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7488), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7494), lang.NewKeyword("end-column"), int(82)) -v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) -if err != nil { - panic(err) +v85 := v84.Get() +v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v87 := v86.FindInternedVar(lang.NewSymbol("seq")) +if v87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) } -return v8 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("list*")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v88 := v87.Get() +v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v90 := v89.FindInternedVar(lang.NewSymbol("concat")) +if v90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) } -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v3, v4, v5, v7}) -var v7 any = v11 -_ = v7 -var v13 lang.FnFunc -{ // function epn -v13 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -return true - case 1: -v15 := args[0] -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("every?")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +v91 := v90.Get() +v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v93 := v92.FindInternedVar(lang.NewSymbol("list")) +if v93.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) } -v18 := v17.Get() -var v19 lang.FnFunc -v19 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v20 := args[0] -v21 := lang.Apply(v20, []any{v15}) -return v21 -}) -v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7499), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(7499), lang.NewKeyword("end-column"), int(28)) -v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) -if err != nil { - panic(err) +v94 := v93.Get() +v95 := lang.Apply(v94, []any{lang.NewSymbol("xs__0__auto__")}) +v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v97 := v96.FindInternedVar(lang.NewSymbol("list")) +if v97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) +} +v98 := v97.Get() +v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v100 := v99.FindInternedVar(lang.NewSymbol("seq")) +if v100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) +} +v101 := v100.Get() +v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v103 := v102.FindInternedVar(lang.NewSymbol("concat")) +if v103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) } -v22 := lang.Apply(v18, []any{v21, v7}) -return v22 - case 2: -v15 := args[0] -v16 := args[1] -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("every?")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +v104 := v103.Get() +v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v106 := v105.FindInternedVar(lang.NewSymbol("list")) +if v106.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) } -v19 := v18.Get() -var v20 lang.FnFunc -v20 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v21 := args[0] -v23 := lang.Apply(v21, []any{v15}) -var v22 any = v23 -_ = v22 -var v25 any -if lang.IsTruthy(v22) { -v26 := lang.Apply(v21, []any{v16}) -v25 = v26 -} else { -v25 = v22 +v107 := v106.Get() +v108 := lang.Apply(v107, []any{lang.NewSymbol("glojure.core/seq")}) +v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v110 := v109.FindInternedVar(lang.NewSymbol("list")) +if v110.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) } -return v25 -}) -v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7500), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7500), lang.NewKeyword("end-column"), int(42)) -v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) -if err != nil { - panic(err) +v111 := v110.Get() +v112 := lang.Apply(v111, []any{v61}) +v113 := lang.Apply(v104, []any{v108, v112}) +v114 := lang.Apply(v101, []any{v113}) +v115 := lang.Apply(v98, []any{v114}) +v116 := lang.Apply(v91, []any{v95, v115}) +v117 := lang.Apply(v88, []any{v116}) +v118 := lang.Apply(v82, []any{v85, v117}) +v119 := lang.Apply(v79, []any{v118}) +v120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v121 := v120.FindInternedVar(lang.NewSymbol("list")) +if v121.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v121))) } -v23 := lang.Apply(v19, []any{v22, v7}) -return v23 - case 3: -v15 := args[0] -v16 := args[1] -v17 := args[2] -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("every?")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v122 := v121.Get() +v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v124 := v123.FindInternedVar(lang.NewSymbol("seq")) +if v124.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) } -v20 := v19.Get() -var v21 lang.FnFunc -v21 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v22 := args[0] -v24 := lang.Apply(v22, []any{v15}) -var v23 any = v24 -_ = v23 -var v26 any -if lang.IsTruthy(v23) { -v28 := lang.Apply(v22, []any{v16}) -var v27 any = v28 -_ = v27 -var v30 any -if lang.IsTruthy(v27) { -v31 := lang.Apply(v22, []any{v17}) -v30 = v31 -} else { -v30 = v27 +v125 := v124.Get() +v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v127 := v126.FindInternedVar(lang.NewSymbol("concat")) +if v127.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) } -v26 = v30 -} else { -v26 = v23 +v128 := v127.Get() +v129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v130 := v129.FindInternedVar(lang.NewSymbol("list")) +if v130.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v130))) } -return v26 -}) -v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7501), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(7501), lang.NewKeyword("end-column"), int(50)) -v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) -if err != nil { - panic(err) +v131 := v130.Get() +v132 := lang.Apply(v131, []any{lang.NewSymbol("glojure.core/let")}) +v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v134 := v133.FindInternedVar(lang.NewSymbol("list")) +if v134.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) } -v24 := lang.Apply(v20, []any{v23, v7}) -return v24 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v15 := args[0] -v16 := args[1] -v17 := args[2] -v18 := lang.NewList(args[3:]...) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("boolean")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v135 := v134.Get() +v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v137 := v136.FindInternedVar(lang.NewSymbol("apply")) +if v137.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) } -v21 := v20.Get() -v23 := lang.Apply(v14, []any{v15, v16, v17}) -var v22 any = v23 -_ = v22 -var v25 any -if lang.IsTruthy(v22) { -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("every?")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +v138 := v137.Get() +v139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v140 := v139.FindInternedVar(lang.NewSymbol("vector")) +if v140.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v140))) } -v28 := v27.Get() -var v29 lang.FnFunc -v29 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v30 := args[0] -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("every?")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v141 := v140.Get() +v142 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v143 := v142.FindInternedVar(lang.NewSymbol("seq")) +if v143.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v143))) } -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v30, v18}) -return v34 -}) -v30 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7503), lang.NewKeyword("column"), int(48), lang.NewKeyword("end-line"), int(7503), lang.NewKeyword("end-column"), int(63)) -v31, err := lang.WithMeta(v29, v30.(lang.IPersistentMap)) -if err != nil { - panic(err) +v144 := v143.Get() +v145 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v146 := v145.FindInternedVar(lang.NewSymbol("concat")) +if v146.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v146))) } -v32 := lang.Apply(v28, []any{v31, v7}) -v25 = v32 -} else { -v25 = v22 +v147 := v146.Get() +v148 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v149 := v148.FindInternedVar(lang.NewSymbol("list")) +if v149.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v149))) } -v22 := lang.Apply(v21, []any{v25}) -return v22 - } -}) -v14 := v13 -_ = v14 +v150 := v149.Get() +v151 := lang.Apply(v150, []any{v56}) +v152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v153 := v152.FindInternedVar(lang.NewSymbol("list")) +if v153.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v153))) } -v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7497), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7503), lang.NewKeyword("end-column"), int(71)) -v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) -if err != nil { - panic(err) +v154 := v153.Get() +v155 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v156 := v155.FindInternedVar(lang.NewSymbol("seq")) +if v156.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v156))) } -return v15 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v157 := v156.Get() +v158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v159 := v158.FindInternedVar(lang.NewSymbol("concat")) +if v159.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v159))) } +v160 := v159.Get() +v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v162 := v161.FindInternedVar(lang.NewSymbol("list")) +if v162.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) } -// compare-and-set! -{ -v0 := lang.NewSymbol("compare-and-set!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atom"), lang.NewSymbol("oldval"), lang.NewSymbol("newval"))), lang.NewKeyword("doc"), "Atomically sets the value of atom to newval if and only if the\n current value of the atom is identical to oldval. Returns true if\n set happened, else false", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2360), lang.NewKeyword("end-line"), int(2360))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6, _ := lang.FieldOrMethod(v3, "compareAndSet") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("compareAndSet is not a function"))) +v163 := v162.Get() +v164 := lang.Apply(v163, []any{lang.NewSymbol("glojure.core/first")}) +v165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v166 := v165.FindInternedVar(lang.NewSymbol("list")) +if v166.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v166))) } -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 +v167 := v166.Get() +v168 := lang.Apply(v167, []any{lang.NewSymbol("xs__0__auto__")}) +v169 := lang.Apply(v160, []any{v164, v168}) +v170 := lang.Apply(v157, []any{v169}) +v171 := lang.Apply(v154, []any{v170}) +v172 := lang.Apply(v147, []any{v151, v171}) +v173 := lang.Apply(v144, []any{v172}) +v174 := lang.Apply(v138, []any{v141, v173}) +v175 := lang.Apply(v135, []any{v174}) +v176 := lang.Apply(v128, []any{v132, v175, v6}) +v177 := lang.Apply(v125, []any{v176}) +v178 := lang.Apply(v122, []any{v177}) +v179 := lang.Apply(v72, []any{v76, v119, v178}) +v180 := lang.Apply(v69, []any{v179}) +return v180 + } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -78270,9 +78356,9 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// with-precision +// when-let { -v0 := lang.NewSymbol("with-precision").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("precision"), lang.NewSymbol("&"), lang.NewSymbol("exprs"))), lang.NewKeyword("doc"), "Sets the precision and rounding mode to be used for BigDecimal operations.\n\n Usage: (with-precision 10 (/ 1M 3))\n or: (with-precision 10 :rounding HALF_DOWN (/ 1M 3))\n\n The rounding mode is one of CEILING, FLOOR, HALF_UP, HALF_DOWN,\n HALF_EVEN, UP, DOWN and UNNECESSARY; it defaults to HALF_UP.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5110), lang.NewKeyword("end-line"), int(5110))).(*lang.Symbol) +v0 := lang.NewSymbol("when-let").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "bindings => binding-form test\n\n When test is true, evaluates body with binding-form bound to the value of test", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1859), lang.NewKeyword("end-line"), int(1859))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -78284,233 +78370,287 @@ v3 := args[0] v4 := args[1] v5 := args[2] v6 := lang.NewList(args[3:]...) -var v8 any -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("=")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +var v7 any +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v11 := v10.Get() +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v5}) +if lang.IsTruthy(v11) { +v7 = nil +} else { v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("first")) +v13 := v12.FindInternedVar(lang.NewSymbol("str")) if v13.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } v14 := v13.Get() -v15 := lang.Apply(v14, []any{v6}) -v16 := lang.Apply(v11, []any{v15, lang.NewKeyword("rounding")}) -if lang.IsTruthy(v16) { -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("next")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("first")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("next")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v3}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v22 := v21.Get() -v23 := lang.Apply(v22, []any{v6}) -v24 := lang.Apply(v19, []any{v23}) -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("seq")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("meta")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("concat")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v3}) +v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) +v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) +v28 := lang.Apply(lang1.NewIllegalArgumentError, []any{v27}) +panic(v28) } -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +_ = v7 +var v29 any +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("=")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) } -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("count")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) } -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v5}) +v37 := lang.Apply(v32, []any{int64(2), v36}) +if lang.IsTruthy(v37) { +v29 = nil +} else { +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("str")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) } -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("first")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } -v42 := v41.Get() -v43 := lang.Apply(v42, []any{lang.NewSymbol(".")}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v3}) +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) } -v46 := v45.Get() -v47 := lang.Apply(v46, []any{lang.NewSymbol("java.math.RoundingMode")}) +v47 := v46.Get() v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) +v49 := v48.FindInternedVar(lang.NewSymbol("meta")) if v49.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) } v50 := v49.Get() -v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v52 := v51.FindInternedVar(lang.NewSymbol("second")) -if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) +v51 := lang.Apply(v50, []any{v3}) +v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) +v53 := lang.Apply(v40, []any{v44, " requires ", "exactly 2 forms in binding vector", " in ", v47, ":", v52}) +v54 := lang.Apply(lang1.NewIllegalArgumentError, []any{v53}) +panic(v54) } -v53 := v52.Get() -v54 := lang.Apply(v53, []any{v6}) -v55 := lang.Apply(v50, []any{v54}) -v56 := lang.Apply(v39, []any{v43, v47, v55}) -v57 := lang.Apply(v36, []any{v56}) -v58 := lang.Apply(v33, []any{v57}) -v59 := lang.Apply(v30, []any{v58}) -v60 := lang.Apply(v27, []any{v59}) -v61 := lang.NewVector(v24, v60) -v62 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5121), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(5122), lang.NewKeyword("end-column"), int(69)) -v63, err := lang.WithMeta(v61, v62.(lang.IPersistentMap)) -if err != nil { - panic(err) +_ = v29 +_ = nil +v56 := lang.Apply(v5, []any{int64(0)}) +var v55 any = v56 +_ = v55 +v58 := lang.Apply(v5, []any{int64(1)}) +var v57 any = v58 +_ = v57 +v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v61 := v60.FindInternedVar(lang.NewSymbol("seq")) +if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) } -v8 = v63 -} else { -v64 := lang.NewVector(v6, nil) -v65 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5123), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(5123), lang.NewKeyword("end-column"), int(33)) -v66, err := lang.WithMeta(v64, v65.(lang.IPersistentMap)) -if err != nil { - panic(err) +v62 := v61.Get() +v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v64 := v63.FindInternedVar(lang.NewSymbol("concat")) +if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) } -v8 = v66 +v65 := v64.Get() +v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v67 := v66.FindInternedVar(lang.NewSymbol("list")) +if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) } -var v7 any = v8 -_ = v7 -v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v69 := v68.FindInternedVar(lang.NewSymbol("nth")) -if v69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) +v68 := v67.Get() +v69 := lang.Apply(v68, []any{lang.NewSymbol("glojure.core/let")}) +v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v71 := v70.FindInternedVar(lang.NewSymbol("list")) +if v71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) } -v70 := v69.Get() -v71 := lang.Apply(v70, []any{v7, int64(0), nil}) -var v67 any = v71 -_ = v67 +v72 := v71.Get() v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v74 := v73.FindInternedVar(lang.NewSymbol("nth")) +v74 := v73.FindInternedVar(lang.NewSymbol("apply")) if v74.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) } v75 := v74.Get() -v76 := lang.Apply(v75, []any{v7, int64(1), nil}) -var v72 any = v76 -_ = v72 -v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v79 := v78.FindInternedVar(lang.NewSymbol("seq")) -if v79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) -} -v80 := v79.Get() -v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v82 := v81.FindInternedVar(lang.NewSymbol("concat")) -if v82.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) +v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v77 := v76.FindInternedVar(lang.NewSymbol("vector")) +if v77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) } -v83 := v82.Get() -v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v85 := v84.FindInternedVar(lang.NewSymbol("list")) -if v85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) +v78 := v77.Get() +v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v80 := v79.FindInternedVar(lang.NewSymbol("seq")) +if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) } -v86 := v85.Get() -v87 := lang.Apply(v86, []any{lang.NewSymbol("glojure.core/binding")}) -v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v89 := v88.FindInternedVar(lang.NewSymbol("list")) -if v89.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) +v81 := v80.Get() +v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v83 := v82.FindInternedVar(lang.NewSymbol("concat")) +if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) } -v90 := v89.Get() -v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v92 := v91.FindInternedVar(lang.NewSymbol("apply")) -if v92.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) +v84 := v83.Get() +v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v86 := v85.FindInternedVar(lang.NewSymbol("list")) +if v86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) } -v93 := v92.Get() -v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v95 := v94.FindInternedVar(lang.NewSymbol("vector")) -if v95.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) +v87 := v86.Get() +v88 := lang.Apply(v87, []any{lang.NewSymbol("temp__0__auto__")}) +v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v90 := v89.FindInternedVar(lang.NewSymbol("list")) +if v90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) } -v96 := v95.Get() +v91 := v90.Get() +v92 := lang.Apply(v91, []any{v57}) +v93 := lang.Apply(v84, []any{v88, v92}) +v94 := lang.Apply(v81, []any{v93}) +v95 := lang.Apply(v75, []any{v78, v94}) +v96 := lang.Apply(v72, []any{v95}) v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v98 := v97.FindInternedVar(lang.NewSymbol("seq")) +v98 := v97.FindInternedVar(lang.NewSymbol("list")) if v98.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) } v99 := v98.Get() v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v101 := v100.FindInternedVar(lang.NewSymbol("concat")) +v101 := v100.FindInternedVar(lang.NewSymbol("seq")) if v101.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) } v102 := v101.Get() v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v104 := v103.FindInternedVar(lang.NewSymbol("list")) +v104 := v103.FindInternedVar(lang.NewSymbol("concat")) if v104.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) } v105 := v104.Get() -v106 := lang.Apply(v105, []any{lang.NewSymbol("glojure.core/*math-context*")}) -v107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v108 := v107.FindInternedVar(lang.NewSymbol("list")) -if v108.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v108))) +v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v107 := v106.FindInternedVar(lang.NewSymbol("list")) +if v107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) } -v109 := v108.Get() +v108 := v107.Get() +v109 := lang.Apply(v108, []any{lang.NewSymbol("glojure.core/when")}) v110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v111 := v110.FindInternedVar(lang.NewSymbol("seq")) +v111 := v110.FindInternedVar(lang.NewSymbol("list")) if v111.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v111))) } v112 := v111.Get() -v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v114 := v113.FindInternedVar(lang.NewSymbol("concat")) -if v114.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) +v113 := lang.Apply(v112, []any{lang.NewSymbol("temp__0__auto__")}) +v114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v115 := v114.FindInternedVar(lang.NewSymbol("list")) +if v115.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v115))) } -v115 := v114.Get() -v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v117 := v116.FindInternedVar(lang.NewSymbol("list")) -if v117.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) +v116 := v115.Get() +v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v118 := v117.FindInternedVar(lang.NewSymbol("seq")) +if v118.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) } -v118 := v117.Get() -v119 := lang.Apply(v118, []any{lang.NewSymbol("java.math.MathContext.")}) +v119 := v118.Get() v120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v121 := v120.FindInternedVar(lang.NewSymbol("list")) +v121 := v120.FindInternedVar(lang.NewSymbol("concat")) if v121.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v121))) } v122 := v121.Get() -v123 := lang.Apply(v122, []any{v5}) -v124 := lang.Apply(v115, []any{v119, v123, v72}) -v125 := lang.Apply(v112, []any{v124}) -v126 := lang.Apply(v109, []any{v125}) -v127 := lang.Apply(v102, []any{v106, v126}) -v128 := lang.Apply(v99, []any{v127}) -v129 := lang.Apply(v93, []any{v96, v128}) -v130 := lang.Apply(v90, []any{v129}) -v131 := lang.Apply(v83, []any{v87, v130, v67}) -v132 := lang.Apply(v80, []any{v131}) -return v132 +v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v124 := v123.FindInternedVar(lang.NewSymbol("list")) +if v124.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) +} +v125 := v124.Get() +v126 := lang.Apply(v125, []any{lang.NewSymbol("glojure.core/let")}) +v127 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v128 := v127.FindInternedVar(lang.NewSymbol("list")) +if v128.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v128))) +} +v129 := v128.Get() +v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v131 := v130.FindInternedVar(lang.NewSymbol("apply")) +if v131.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) +} +v132 := v131.Get() +v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v134 := v133.FindInternedVar(lang.NewSymbol("vector")) +if v134.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) +} +v135 := v134.Get() +v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v137 := v136.FindInternedVar(lang.NewSymbol("seq")) +if v137.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) +} +v138 := v137.Get() +v139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v140 := v139.FindInternedVar(lang.NewSymbol("concat")) +if v140.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v140))) +} +v141 := v140.Get() +v142 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v143 := v142.FindInternedVar(lang.NewSymbol("list")) +if v143.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v143))) +} +v144 := v143.Get() +v145 := lang.Apply(v144, []any{v55}) +v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v147 := v146.FindInternedVar(lang.NewSymbol("list")) +if v147.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) +} +v148 := v147.Get() +v149 := lang.Apply(v148, []any{lang.NewSymbol("temp__0__auto__")}) +v150 := lang.Apply(v141, []any{v145, v149}) +v151 := lang.Apply(v138, []any{v150}) +v152 := lang.Apply(v132, []any{v135, v151}) +v153 := lang.Apply(v129, []any{v152}) +v154 := lang.Apply(v122, []any{v126, v153, v6}) +v155 := lang.Apply(v119, []any{v154}) +v156 := lang.Apply(v116, []any{v155}) +v157 := lang.Apply(v105, []any{v109, v113, v156}) +v158 := lang.Apply(v102, []any{v157}) +v159 := lang.Apply(v99, []any{v158}) +v160 := lang.Apply(v65, []any{v69, v96, v159}) +v161 := lang.Apply(v62, []any{v160}) +return v161 } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -78519,64 +78659,35 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// transduce +// when-not { -v0 := lang.NewSymbol("transduce").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "reduce with a transformation of f (xf). If init is not\n supplied, (f) will be called to produce it. f should be a reducing\n step function that accepts both 1 and 2 arguments, if it accepts\n only 2 you can add the arity-1 with 'completing'. Returns the result\n of applying (the transformed) xf to init and the first item in coll,\n then applying xf to that result and the 2nd item, etc. If coll\n contains no items, returns init and f is not called. Note that\n certain transforms may inject or skip items.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6948), lang.NewKeyword("end-line"), int(6948))).(*lang.Symbol) +v0 := lang.NewSymbol("when-not").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("test"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Evaluates test. If logical false, evaluates body in an implicit do.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(498), lang.NewKeyword("end-line"), int(498))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("transduce")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v4, nil) -v10 := lang.Apply(v8, []any{v3, v4, v9, v5}) -return v10 - case 4: + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] v4 := args[1] v5 := args[2] -v6 := args[3] -v8 := lang.Apply(v3, []any{v7}) -var v7 any = v8 -_ = v7 -var v10 any -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("instance?")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{lang1.IReduceInit, v6}) -if lang.IsTruthy(v14) { -v15, _ := lang.FieldOrMethod(v6, "ReduceInit") -if reflect.TypeOf(v15).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) -} -v16 := lang.Apply(v15, []any{v7, v5}) -v10 = v16 -} else { -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core.protocols")) -v18 := v17.FindInternedVar(lang.NewSymbol("coll-reduce")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +v6 := lang.NewList(args[3:]...) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("list")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v6, v7, v5}) -v10 = v20 +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("cons")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -var v9 any = v10 -_ = v9 -v22 := lang.Apply(v7, []any{v9}) -return v22 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) +v12 := v11.Get() +v13 := lang.Apply(v12, []any{lang.NewSymbol("do"), v6}) +v14 := lang.Apply(v9, []any{lang.NewSymbol("if"), v5, nil, v13}) +return v14 } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -78585,383 +78696,350 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// parents +// when-some { -v0 := lang.NewSymbol("parents").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"))), lang.NewKeyword("doc"), "Returns the immediate parents of tag, either via a Java type\n inheritance relationship or a relationship established via derive. h\n must be a hierarchy obtained from make-hierarchy, if not supplied\n defaults to the global hierarchy", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5607), lang.NewKeyword("end-line"), int(5607))).(*lang.Symbol) +v0 := lang.NewSymbol("when-some").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "bindings => binding-form test\n\n When test is not nil, evaluates body with binding-form bound to the\n value of test", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1894), lang.NewKeyword("end-line"), int(1894))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 1: + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("parents")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +var v7 any +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("global-hierarchy")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v5}) +if lang.IsTruthy(v11) { +v7 = nil +} else { +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("str")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } -v9 := v8.Get() -v10 := lang.Apply(v6, []any{v9, v3}) -return v10 - case 2: -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("not-empty")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("first")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } -v7 := v6.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("get")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v3}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v11 := v10.Get() -v12 := lang.Apply(lang.NewKeyword("parents"), []any{v3}) -v13 := lang.Apply(v11, []any{v12, v4}) -var v8 any = v13 -_ = v8 -var v15 any -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("class?")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("meta")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v4}) -if lang.IsTruthy(v19) { -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("into1")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v3}) +v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) +v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) +v28 := lang.Apply(lang1.NewIllegalArgumentError, []any{v27}) +panic(v28) } -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("set")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +_ = v7 +var v29 any +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("=")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) } -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("bases")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("count")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) } -v28 := v27.Get() -v29 := lang.Apply(v28, []any{v4}) -v30 := lang.Apply(v25, []any{v29}) -v31 := lang.Apply(v22, []any{v30, v8}) -v15 = v31 +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v5}) +v37 := lang.Apply(v32, []any{int64(2), v36}) +if lang.IsTruthy(v37) { +v29 = nil } else { -v15 = v8 +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("str")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) } -v8 := lang.Apply(v7, []any{v15}) -return v8 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("first")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v3}) +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) } -// random-uuid -{ -v0 := lang.NewSymbol("random-uuid").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Returns a pseudo-randomly generated java.util.UUID instance (i.e. type 4).\n\n See: https://docs.oracle.com/javase/8/docs/api/java/util/UUID.html#randomUUID--", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6895), lang.NewKeyword("end-line"), int(6895))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.Apply(nil, nil) -return v3 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v47 := v46.Get() +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("meta")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) } +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v3}) +v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) +v53 := lang.Apply(v40, []any{v44, " requires ", "exactly 2 forms in binding vector", " in ", v47, ":", v52}) +v54 := lang.Apply(lang1.NewIllegalArgumentError, []any{v53}) +panic(v54) } -// juxt -{ -v0 := lang.NewSymbol("juxt").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("g")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("g"), lang.NewSymbol("h")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("g"), lang.NewSymbol("h"), lang.NewSymbol("&"), lang.NewSymbol("fs"))), lang.NewKeyword("doc"), "Takes a set of functions and returns a fn that is the juxtaposition\n of those fns. The returned fn takes a variable number of args, and\n returns a vector containing the result of applying each fn to the\n args (left-to-right).\n ((juxt a b c) x) => [(a x) (b x) (c x)]", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2568), lang.NewKeyword("end-line"), int(2568))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v5 := lang.Apply(v3, nil) -v6 := lang.NewVector(v5) -v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2578), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(2578), lang.NewKeyword("end-column"), int(16)) -v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) -if err != nil { - panic(err) +_ = v29 +_ = nil +v56 := lang.Apply(v5, []any{int64(0)}) +var v55 any = v56 +_ = v55 +v58 := lang.Apply(v5, []any{int64(1)}) +var v57 any = v58 +_ = v57 +v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v61 := v60.FindInternedVar(lang.NewSymbol("seq")) +if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) } -return v8 - case 1: -v5 := args[0] -v6 := lang.Apply(v3, []any{v5}) -v7 := lang.NewVector(v6) -v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2579), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(2579), lang.NewKeyword("end-column"), int(19)) -v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) -if err != nil { - panic(err) +v62 := v61.Get() +v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v64 := v63.FindInternedVar(lang.NewSymbol("concat")) +if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) } -return v9 - case 2: -v5 := args[0] -v6 := args[1] -v7 := lang.Apply(v3, []any{v5, v6}) -v8 := lang.NewVector(v7) -v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2580), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(2580), lang.NewKeyword("end-column"), int(23)) -v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) -if err != nil { - panic(err) +v65 := v64.Get() +v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v67 := v66.FindInternedVar(lang.NewSymbol("list")) +if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) } -return v10 - case 3: -v5 := args[0] -v6 := args[1] -v7 := args[2] -v8 := lang.Apply(v3, []any{v5, v6, v7}) -v9 := lang.NewVector(v8) -v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2581), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(2581), lang.NewKeyword("end-column"), int(27)) -v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) -if err != nil { - panic(err) +v68 := v67.Get() +v69 := lang.Apply(v68, []any{lang.NewSymbol("glojure.core/let")}) +v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v71 := v70.FindInternedVar(lang.NewSymbol("list")) +if v71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) +} +v72 := v71.Get() +v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v74 := v73.FindInternedVar(lang.NewSymbol("apply")) +if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) +} +v75 := v74.Get() +v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v77 := v76.FindInternedVar(lang.NewSymbol("vector")) +if v77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) +} +v78 := v77.Get() +v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v80 := v79.FindInternedVar(lang.NewSymbol("seq")) +if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) +} +v81 := v80.Get() +v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v83 := v82.FindInternedVar(lang.NewSymbol("concat")) +if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) +} +v84 := v83.Get() +v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v86 := v85.FindInternedVar(lang.NewSymbol("list")) +if v86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) +} +v87 := v86.Get() +v88 := lang.Apply(v87, []any{lang.NewSymbol("temp__0__auto__")}) +v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v90 := v89.FindInternedVar(lang.NewSymbol("list")) +if v90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) +} +v91 := v90.Get() +v92 := lang.Apply(v91, []any{v57}) +v93 := lang.Apply(v84, []any{v88, v92}) +v94 := lang.Apply(v81, []any{v93}) +v95 := lang.Apply(v75, []any{v78, v94}) +v96 := lang.Apply(v72, []any{v95}) +v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v98 := v97.FindInternedVar(lang.NewSymbol("list")) +if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) +} +v99 := v98.Get() +v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v101 := v100.FindInternedVar(lang.NewSymbol("seq")) +if v101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) } -return v11 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := args[0] -v6 := args[1] -v7 := args[2] -v8 := lang.NewList(args[3:]...) -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("apply")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +v102 := v101.Get() +v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v104 := v103.FindInternedVar(lang.NewSymbol("concat")) +if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) } -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v3, v5, v6, v7, v8}) -v13 := lang.NewVector(v12) -v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2582), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(2582), lang.NewKeyword("end-column"), int(45)) -v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) -if err != nil { - panic(err) +v105 := v104.Get() +v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v107 := v106.FindInternedVar(lang.NewSymbol("list")) +if v107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) } -return v15 - } -}) -v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2577), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2582), lang.NewKeyword("end-column"), int(47)) -v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) -if err != nil { - panic(err) +v108 := v107.Get() +v109 := lang.Apply(v108, []any{lang.NewSymbol("if")}) +v110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v111 := v110.FindInternedVar(lang.NewSymbol("list")) +if v111.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v111))) } -return v6 - case 2: -v3 := args[0] -v4 := args[1] -var v5 lang.FnFunc -v5 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v6 := lang.Apply(v3, nil) -v7 := lang.Apply(v4, nil) -v8 := lang.NewVector(v6, v7) -v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2585), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(2585), lang.NewKeyword("end-column"), int(20)) -v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) -if err != nil { - panic(err) +v112 := v111.Get() +v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v114 := v113.FindInternedVar(lang.NewSymbol("seq")) +if v114.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) } -return v10 - case 1: -v6 := args[0] -v7 := lang.Apply(v3, []any{v6}) -v8 := lang.Apply(v4, []any{v6}) -v9 := lang.NewVector(v7, v8) -v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2586), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(2586), lang.NewKeyword("end-column"), int(25)) -v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) -if err != nil { - panic(err) +v115 := v114.Get() +v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v117 := v116.FindInternedVar(lang.NewSymbol("concat")) +if v117.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) } -return v11 - case 2: -v6 := args[0] -v7 := args[1] -v8 := lang.Apply(v3, []any{v6, v7}) -v9 := lang.Apply(v4, []any{v6, v7}) -v10 := lang.NewVector(v8, v9) -v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2587), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(2587), lang.NewKeyword("end-column"), int(31)) -v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) -if err != nil { - panic(err) +v118 := v117.Get() +v119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v120 := v119.FindInternedVar(lang.NewSymbol("list")) +if v120.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v120))) } -return v12 - case 3: -v6 := args[0] -v7 := args[1] -v8 := args[2] -v9 := lang.Apply(v3, []any{v6, v7, v8}) -v10 := lang.Apply(v4, []any{v6, v7, v8}) -v11 := lang.NewVector(v9, v10) -v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2588), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(2588), lang.NewKeyword("end-column"), int(37)) -v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) -if err != nil { - panic(err) +v121 := v120.Get() +v122 := lang.Apply(v121, []any{lang.NewSymbol("glojure.core/nil?")}) +v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v124 := v123.FindInternedVar(lang.NewSymbol("list")) +if v124.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) } -return v13 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v6 := args[0] -v7 := args[1] -v8 := args[2] -v9 := lang.NewList(args[3:]...) -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("apply")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v125 := v124.Get() +v126 := lang.Apply(v125, []any{lang.NewSymbol("temp__0__auto__")}) +v127 := lang.Apply(v118, []any{v122, v126}) +v128 := lang.Apply(v115, []any{v127}) +v129 := lang.Apply(v112, []any{v128}) +v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v131 := v130.FindInternedVar(lang.NewSymbol("list")) +if v131.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) } -v12 := v11.Get() -v13 := lang.Apply(v12, []any{v3, v6, v7, v8, v9}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("apply")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v132 := v131.Get() +v133 := lang.Apply(v132, []any{nil}) +v134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v135 := v134.FindInternedVar(lang.NewSymbol("list")) +if v135.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v135))) } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v4, v6, v7, v8, v9}) -v18 := lang.NewVector(v13, v17) -v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2589), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(2589), lang.NewKeyword("end-column"), int(66)) -v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) -if err != nil { - panic(err) +v136 := v135.Get() +v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v138 := v137.FindInternedVar(lang.NewSymbol("seq")) +if v138.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) } -return v20 - } -}) -v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2584), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2589), lang.NewKeyword("end-column"), int(68)) -v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) -if err != nil { - panic(err) +v139 := v138.Get() +v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v141 := v140.FindInternedVar(lang.NewSymbol("concat")) +if v141.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) } -return v7 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -var v6 lang.FnFunc -v6 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v7 := lang.Apply(v3, nil) -v8 := lang.Apply(v4, nil) -v9 := lang.Apply(v5, nil) -v10 := lang.NewVector(v7, v8, v9) -v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2592), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(2592), lang.NewKeyword("end-column"), int(24)) -v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) -if err != nil { - panic(err) +v142 := v141.Get() +v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v144 := v143.FindInternedVar(lang.NewSymbol("list")) +if v144.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) } -return v12 - case 1: -v7 := args[0] -v8 := lang.Apply(v3, []any{v7}) -v9 := lang.Apply(v4, []any{v7}) -v10 := lang.Apply(v5, []any{v7}) -v11 := lang.NewVector(v8, v9, v10) -v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2593), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(2593), lang.NewKeyword("end-column"), int(31)) -v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) -if err != nil { - panic(err) +v145 := v144.Get() +v146 := lang.Apply(v145, []any{lang.NewSymbol("glojure.core/let")}) +v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v148 := v147.FindInternedVar(lang.NewSymbol("list")) +if v148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) } -return v13 - case 2: -v7 := args[0] -v8 := args[1] -v9 := lang.Apply(v3, []any{v7, v8}) -v10 := lang.Apply(v4, []any{v7, v8}) -v11 := lang.Apply(v5, []any{v7, v8}) -v12 := lang.NewVector(v9, v10, v11) -v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2594), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(2594), lang.NewKeyword("end-column"), int(39)) -v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) -if err != nil { - panic(err) +v149 := v148.Get() +v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v151 := v150.FindInternedVar(lang.NewSymbol("apply")) +if v151.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) } -return v14 - case 3: -v7 := args[0] -v8 := args[1] -v9 := args[2] -v10 := lang.Apply(v3, []any{v7, v8, v9}) -v11 := lang.Apply(v4, []any{v7, v8, v9}) -v12 := lang.Apply(v5, []any{v7, v8, v9}) -v13 := lang.NewVector(v10, v11, v12) -v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2595), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(2595), lang.NewKeyword("end-column"), int(47)) -v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) -if err != nil { - panic(err) +v152 := v151.Get() +v153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v154 := v153.FindInternedVar(lang.NewSymbol("vector")) +if v154.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v154))) } -return v15 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v7 := args[0] -v8 := args[1] -v9 := args[2] -v10 := lang.NewList(args[3:]...) -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("apply")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v155 := v154.Get() +v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v157 := v156.FindInternedVar(lang.NewSymbol("seq")) +if v157.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) } -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v3, v7, v8, v9, v10}) -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("apply")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +v158 := v157.Get() +v159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v160 := v159.FindInternedVar(lang.NewSymbol("concat")) +if v160.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v160))) } -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v4, v7, v8, v9, v10}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("apply")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v161 := v160.Get() +v162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v163 := v162.FindInternedVar(lang.NewSymbol("list")) +if v163.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v163))) } -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v5, v7, v8, v9, v10}) -v23 := lang.NewVector(v14, v18, v22) -v24 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2596), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(2596), lang.NewKeyword("end-column"), int(87)) -v25, err := lang.WithMeta(v23, v24.(lang.IPersistentMap)) -if err != nil { - panic(err) +v164 := v163.Get() +v165 := lang.Apply(v164, []any{v55}) +v166 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v167 := v166.FindInternedVar(lang.NewSymbol("list")) +if v167.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v167))) } -return v25 +v168 := v167.Get() +v169 := lang.Apply(v168, []any{lang.NewSymbol("temp__0__auto__")}) +v170 := lang.Apply(v161, []any{v165, v169}) +v171 := lang.Apply(v158, []any{v170}) +v172 := lang.Apply(v152, []any{v155, v171}) +v173 := lang.Apply(v149, []any{v172}) +v174 := lang.Apply(v142, []any{v146, v173, v6}) +v175 := lang.Apply(v139, []any{v174}) +v176 := lang.Apply(v136, []any{v175}) +v177 := lang.Apply(v105, []any{v109, v129, v133, v176}) +v178 := lang.Apply(v102, []any{v177}) +v179 := lang.Apply(v99, []any{v178}) +v180 := lang.Apply(v65, []any{v69, v96, v179}) +v181 := lang.Apply(v62, []any{v180}) +return v181 } }) -v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2591), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2596), lang.NewKeyword("end-column"), int(89)) -v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) -if err != nil { - panic(err) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -return v8 +} +// while +{ +v0 := lang.NewSymbol("while").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("test"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Repeatedly executes body while test expression is true. Presumes\n some side-effect will cause test to become false/nil. Returns nil", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6370), lang.NewKeyword("end-line"), int(6370))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { default: if len(args) < 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -78970,230 +79048,125 @@ v3 := args[0] v4 := args[1] v5 := args[2] v6 := lang.NewList(args[3:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("list*")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v3, v4, v5, v7}) -var v7 any = v11 -_ = v7 -var v13 lang.FnFunc -v13 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("reduce1")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -var v17 lang.FnFunc -v17 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v18 := args[0] -v19 := args[1] -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("conj")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.Apply(v19, nil) -v24 := lang.Apply(v22, []any{v18, v23}) -return v24 -}) -v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2600), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(2600), lang.NewKeyword("end-column"), int(37)) -v19, err := lang.WithMeta(v17, v18.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v20 := lang.NewVector() -v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2600), lang.NewKeyword("column"), int(39), lang.NewKeyword("end-line"), int(2600), lang.NewKeyword("end-column"), int(40)) -v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v23 := lang.Apply(v16, []any{v19, v22, v7}) -return v23 - case 1: -v14 := args[0] -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("reduce1")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -var v18 lang.FnFunc -v18 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v19 := args[0] -v20 := args[1] -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("conj")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v20, []any{v14}) -v25 := lang.Apply(v23, []any{v19, v24}) -return v25 -}) -v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2601), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(2601), lang.NewKeyword("end-column"), int(40)) -v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v21 := lang.NewVector() -v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2601), lang.NewKeyword("column"), int(42), lang.NewKeyword("end-line"), int(2601), lang.NewKeyword("end-column"), int(43)) -v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v24 := lang.Apply(v17, []any{v20, v23, v7}) -return v24 - case 2: -v14 := args[0] -v15 := args[1] -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("reduce1")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -var v19 lang.FnFunc -v19 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v20 := args[0] -v21 := args[1] -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("conj")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v8 := v7.FindInternedVar(lang.NewSymbol("seq")) +if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } -v24 := v23.Get() -v25 := lang.Apply(v21, []any{v14, v15}) -v26 := lang.Apply(v24, []any{v20, v25}) -return v26 -}) -v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2602), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(2602), lang.NewKeyword("end-column"), int(44)) -v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) -if err != nil { - panic(err) +v9 := v8.Get() +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("concat")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v22 := lang.NewVector() -v23 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2602), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(2602), lang.NewKeyword("end-column"), int(47)) -v24, err := lang.WithMeta(v22, v23.(lang.IPersistentMap)) -if err != nil { - panic(err) +v12 := v11.Get() +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("list")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } -v25 := lang.Apply(v18, []any{v21, v24, v7}) -return v25 - case 3: -v14 := args[0] -v15 := args[1] -v16 := args[2] +v15 := v14.Get() +v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/loop")}) v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("reduce1")) +v18 := v17.FindInternedVar(lang.NewSymbol("list")) if v18.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } v19 := v18.Get() -var v20 lang.FnFunc -v20 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v21 := args[0] -v22 := args[1] +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("apply")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("conj")) +v24 := v23.FindInternedVar(lang.NewSymbol("vector")) if v24.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v25 := v24.Get() -v26 := lang.Apply(v22, []any{v14, v15, v16}) -v27 := lang.Apply(v25, []any{v21, v26}) -return v27 -}) -v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2603), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(2603), lang.NewKeyword("end-column"), int(48)) -v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) -if err != nil { - panic(err) +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("seq")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("concat")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.Apply(v31, nil) +v33 := lang.Apply(v28, []any{v32}) +v34 := lang.Apply(v22, []any{v25, v33}) +v35 := lang.Apply(v19, []any{v34}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("seq")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) } -v23 := lang.NewVector() -v24 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2603), lang.NewKeyword("column"), int(50), lang.NewKeyword("end-line"), int(2603), lang.NewKeyword("end-column"), int(51)) -v25, err := lang.WithMeta(v23, v24.(lang.IPersistentMap)) -if err != nil { - panic(err) +v41 := v40.Get() +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("concat")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) } -v26 := lang.Apply(v19, []any{v22, v25, v7}) -return v26 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v14 := args[0] -v15 := args[1] -v16 := args[2] -v17 := lang.NewList(args[3:]...) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("reduce1")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v44 := v43.Get() +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("list")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) } -v20 := v19.Get() -var v21 lang.FnFunc -v21 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v22 := args[0] -v23 := args[1] -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("conj")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +v47 := v46.Get() +v48 := lang.Apply(v47, []any{lang.NewSymbol("glojure.core/when")}) +v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v50 := v49.FindInternedVar(lang.NewSymbol("list")) +if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) } -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("apply")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v51 := v50.Get() +v52 := lang.Apply(v51, []any{v5}) +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("list")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) } -v29 := v28.Get() -v30 := lang.Apply(v29, []any{v23, v14, v15, v16, v17}) -v31 := lang.Apply(v26, []any{v22, v30}) -return v31 -}) -v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2604), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(2604), lang.NewKeyword("end-column"), int(66)) -v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) -if err != nil { - panic(err) +v55 := v54.Get() +v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v57 := v56.FindInternedVar(lang.NewSymbol("seq")) +if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) } -v24 := lang.NewVector() -v25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2604), lang.NewKeyword("column"), int(68), lang.NewKeyword("end-line"), int(2604), lang.NewKeyword("end-column"), int(69)) -v26, err := lang.WithMeta(v24, v25.(lang.IPersistentMap)) -if err != nil { - panic(err) +v58 := v57.Get() +v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v60 := v59.FindInternedVar(lang.NewSymbol("concat")) +if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) } -v27 := lang.Apply(v20, []any{v23, v26, v7}) -return v27 - } -}) -v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2599), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(2604), lang.NewKeyword("end-column"), int(75)) -v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) -if err != nil { - panic(err) +v61 := v60.Get() +v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v63 := v62.FindInternedVar(lang.NewSymbol("list")) +if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) } -return v15 +v64 := v63.Get() +v65 := lang.Apply(v64, []any{lang.NewSymbol("recur")}) +v66 := lang.Apply(v61, []any{v65}) +v67 := lang.Apply(v58, []any{v66}) +v68 := lang.Apply(v55, []any{v67}) +v69 := lang.Apply(v44, []any{v48, v52, v6, v68}) +v70 := lang.Apply(v41, []any{v69}) +v71 := lang.Apply(v38, []any{v70}) +v72 := lang.Apply(v12, []any{v16, v35, v71}) +v73 := lang.Apply(v9, []any{v72}) +return v73 } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -79202,115 +79175,162 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// unchecked-long +// with-bindings { -var v1 lang.FnFunc -{ // function unchecked-long__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } +v0 := lang.NewSymbol("with-bindings").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("binding-map"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Takes a map of Var/value pairs. Installs for the given Vars the associated\n values as thread-local bindings. Then executes body. Pops the installed\n bindings after body was evaluated. Returns the value of body.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1984), lang.NewKeyword("end-line"), int(1984))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +v8 := v7.FindInternedVar(lang.NewSymbol("seq")) if v8.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } v9 := v8.Get() v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) +v11 := v10.FindInternedVar(lang.NewSymbol("concat")) if v11.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("list")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v15 := v14.Get() +v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/with-bindings*")}) +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("list")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v20 := v19.Get() +v19 := v18.Get() +v20 := lang.Apply(v19, []any{v5}) v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) +v22 := v21.FindInternedVar(lang.NewSymbol("list")) if v22.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } v23 := v22.Get() v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) +v25 := v24.FindInternedVar(lang.NewSymbol("seq")) if v25.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } v26 := v25.Get() v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) +v28 := v27.FindInternedVar(lang.NewSymbol("concat")) if v28.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/UncheckedLongCast")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("list")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) } -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v3}) -v35 := lang.Apply(v26, []any{v30, v34}) -v36 := lang.Apply(v23, []any{v35}) -v37 := lang.Apply(v20, []any{v36}) -v38 := lang.Apply(v9, []any{v13, v17, v37}) -v39 := lang.Apply(v6, []any{v38}) -return v39 -}) -v2 := v1 -_ = v2 +v32 := v31.Get() +v33 := lang.Apply(v32, []any{lang.NewSymbol("glojure.core/fn")}) +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("list")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } -v0 := lang.NewSymbol("unchecked-long").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to long. Subject to rounding or truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3541), lang.NewKeyword("end-line"), int(3541))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("apply")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("vector")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("seq")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +} +v45 := v44.Get() +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("concat")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +} +v48 := v47.Get() +v49 := lang.Apply(v48, nil) +v50 := lang.Apply(v45, []any{v49}) +v51 := lang.Apply(v39, []any{v42, v50}) +v52 := lang.Apply(v36, []any{v51}) +v53 := lang.Apply(v29, []any{v33, v52, v6}) +v54 := lang.Apply(v26, []any{v53}) +v55 := lang.Apply(v23, []any{v54}) +v56 := lang.Apply(v12, []any{v16, v20, v55}) +v57 := lang.Apply(v9, []any{v56}) +return v57 } -v4 := args[0] -v5 := lang.Apply(lang1.UncheckedLongCast, []any{v4}) -return v5 }) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// bit-flip +// with-bindings* { -v0 := lang.NewSymbol("bit-flip").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Flip bit at index n", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1348), lang.NewKeyword("end-line"), int(1348))).(*lang.Symbol) +v0 := lang.NewSymbol("with-bindings*").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("binding-map"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Takes a map of Var/value pairs. Installs for the given Vars the associated\n values as thread-local bindings. Then calls f with the supplied arguments.\n Pops the installed bindings after f returned. Returns whatever f returns.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1971), lang.NewKeyword("end-line"), int(1971))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] v4 := args[1] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "flipBit") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("flipBit is not a function"))) +v5 := lang.NewList(args[2:]...) +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("push-thread-bindings")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v6 := lang.Apply(v5, []any{v3, v4}) -return v6 +v8 := v7.Get() +v9 := lang.Apply(v8, []any{v3}) +_ = v9 +var v10 any +func() { +defer func() { +v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v12 := v11.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) +if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +} +v13 := v12.Get() +v14 := lang.Apply(v13, nil) +}() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("apply")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +} +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v4, v5}) +v10 = v18 +}() +return v10 + } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -79318,97 +79338,229 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// infinite? +// with-in-str { -var v1 lang.FnFunc -{ // function infinite?__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } +v0 := lang.NewSymbol("with-in-str").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Evaluates body in a context in which *in* is bound to a fresh\n StringReader initialized with the string s.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4749), lang.NewKeyword("end-line"), int(4749))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) +v8 := v7.FindInternedVar(lang.NewSymbol("seq")) if v8.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } v9 := v8.Get() v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) +v11 := v10.FindInternedVar(lang.NewSymbol("concat")) if v11.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol("Double/isInfinite")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("list")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v3}) -v18 := lang.Apply(v9, []any{v13, v17}) -v19 := lang.Apply(v6, []any{v18}) -return v19 -}) -v2 := v1 -_ = v2 +v15 := v14.Get() +v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/with-open")}) +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("list")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v0 := lang.NewSymbol("infinite?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns true if num is negative or positive infinity, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)), lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(8020), lang.NewKeyword("end-line"), int(8020))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := lang.Apply(nil, []any{v4}) -return v5 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("apply")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +} +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("vector")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("seq")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("concat")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("list")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{lang.NewSymbol("s__0__auto__")}) +v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v37 := v36.FindInternedVar(lang.NewSymbol("list")) +if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +} +v38 := v37.Get() +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("seq")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +} +v41 := v40.Get() +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("concat")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +} +v44 := v43.Get() +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("list")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +} +v47 := v46.Get() +v48 := lang.Apply(v47, []any{lang.NewSymbol("glojure.core/->")}) +v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v50 := v49.FindInternedVar(lang.NewSymbol("list")) +if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) +} +v51 := v50.Get() +v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v53 := v52.FindInternedVar(lang.NewSymbol("seq")) +if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) +} +v54 := v53.Get() +v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v56 := v55.FindInternedVar(lang.NewSymbol("concat")) +if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) +} +v57 := v56.Get() +v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v59 := v58.FindInternedVar(lang.NewSymbol("list")) +if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) +} +v60 := v59.Get() +v61 := lang.Apply(v60, []any{lang.NewSymbol("java.io.StringReader.")}) +v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v63 := v62.FindInternedVar(lang.NewSymbol("list")) +if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +} +v64 := v63.Get() +v65 := lang.Apply(v64, []any{v5}) +v66 := lang.Apply(v57, []any{v61, v65}) +v67 := lang.Apply(v54, []any{v66}) +v68 := lang.Apply(v51, []any{v67}) +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("list")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +} +v71 := v70.Get() +v72 := lang.Apply(v71, []any{lang.NewSymbol("glojure.lang.LineNumberingPushbackReader.")}) +v73 := lang.Apply(v44, []any{v48, v68, v72}) +v74 := lang.Apply(v41, []any{v73}) +v75 := lang.Apply(v38, []any{v74}) +v76 := lang.Apply(v31, []any{v35, v75}) +v77 := lang.Apply(v28, []any{v76}) +v78 := lang.Apply(v22, []any{v25, v77}) +v79 := lang.Apply(v19, []any{v78}) +v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v81 := v80.FindInternedVar(lang.NewSymbol("list")) +if v81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) +} +v82 := v81.Get() +v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v84 := v83.FindInternedVar(lang.NewSymbol("seq")) +if v84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) +} +v85 := v84.Get() +v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v87 := v86.FindInternedVar(lang.NewSymbol("concat")) +if v87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) +} +v88 := v87.Get() +v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v90 := v89.FindInternedVar(lang.NewSymbol("list")) +if v90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) +} +v91 := v90.Get() +v92 := lang.Apply(v91, []any{lang.NewSymbol("glojure.core/binding")}) +v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v94 := v93.FindInternedVar(lang.NewSymbol("list")) +if v94.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) +} +v95 := v94.Get() +v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v97 := v96.FindInternedVar(lang.NewSymbol("apply")) +if v97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) +} +v98 := v97.Get() +v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v100 := v99.FindInternedVar(lang.NewSymbol("vector")) +if v100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) } +v101 := v100.Get() +v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v103 := v102.FindInternedVar(lang.NewSymbol("seq")) +if v103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) } -// pcalls -{ -v0 := lang.NewSymbol("pcalls").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("fns"))), lang.NewKeyword("doc"), "Executes the no-arg fns in parallel, returning a lazy sequence of\n their values", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7099), lang.NewKeyword("end-line"), int(7099))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewList(args[0:]...) -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("pmap")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v104 := v103.Get() +v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v106 := v105.FindInternedVar(lang.NewSymbol("concat")) +if v106.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) } -v6 := v5.Get() -var v7 lang.FnFunc -v7 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v8 := args[0] -v9 := lang.Apply(v8, nil) -return v9 -}) -v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7104), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(7104), lang.NewKeyword("end-column"), int(20)) -v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) -if err != nil { - panic(err) +v107 := v106.Get() +v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v109 := v108.FindInternedVar(lang.NewSymbol("list")) +if v109.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) } -v10 := lang.Apply(v6, []any{v9, v3}) -return v10 +v110 := v109.Get() +v111 := lang.Apply(v110, []any{lang.NewSymbol("glojure.core/*in*")}) +v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v113 := v112.FindInternedVar(lang.NewSymbol("list")) +if v113.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) +} +v114 := v113.Get() +v115 := lang.Apply(v114, []any{lang.NewSymbol("s__0__auto__")}) +v116 := lang.Apply(v107, []any{v111, v115}) +v117 := lang.Apply(v104, []any{v116}) +v118 := lang.Apply(v98, []any{v101, v117}) +v119 := lang.Apply(v95, []any{v118}) +v120 := lang.Apply(v88, []any{v92, v119, v6}) +v121 := lang.Apply(v85, []any{v120}) +v122 := lang.Apply(v82, []any{v121}) +v123 := lang.Apply(v12, []any{v16, v79, v122}) +v124 := lang.Apply(v9, []any{v123}) +return v124 } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -79417,453 +79569,249 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// locking +// with-loading-context { -v0 := lang.NewSymbol("locking").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Executes exprs in an implicit do, while holding the monitor of x.\n Will release the monitor of x in all circumstances.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1643), lang.NewKeyword("end-line"), int(1643))).(*lang.Symbol) +v0 := lang.NewSymbol("with-loading-context").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5777), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5777), lang.NewKeyword("end-column"), int(30), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("macro"), true)).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 3 { + if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("seq")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v5 := lang.NewList(args[2:]...) +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("seq")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("concat")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("concat")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("list")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("list")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } -v15 := v14.Get() -v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/let")}) -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("list")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("seq")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("apply")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +v17 := v16.Get() +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("concat")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("vector")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +v20 := v19.Get() +v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v22 := v21.FindInternedVar(lang.NewSymbol("list")) +if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) } -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("seq")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +v23 := v22.Get() +v24 := lang.Apply(v23, []any{lang.NewSymbol("glojure.core/fn")}) +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("list")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -v28 := v27.Get() +v27 := v26.Get() +v28 := lang.Apply(v27, []any{lang.NewSymbol("loading__0__auto__")}) v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("concat")) +v30 := v29.FindInternedVar(lang.NewSymbol("list")) if v30.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) } v31 := v30.Get() v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) +v33 := v32.FindInternedVar(lang.NewSymbol("apply")) if v33.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) } v34 := v33.Get() -v35 := lang.Apply(v34, []any{lang.NewSymbol("lockee__0__auto__")}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("vector")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) } -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v5}) -v40 := lang.Apply(v31, []any{v35, v39}) -v41 := lang.Apply(v28, []any{v40}) -v42 := lang.Apply(v22, []any{v25, v41}) -v43 := lang.Apply(v19, []any{v42}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +v37 := v36.Get() +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("seq")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) } -v46 := v45.Get() -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("seq")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("concat")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } -v49 := v48.Get() -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("concat")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +v43 := v42.Get() +v44 := lang.Apply(v43, nil) +v45 := lang.Apply(v40, []any{v44}) +v46 := lang.Apply(v34, []any{v37, v45}) +v47 := lang.Apply(v31, []any{v46}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) } -v52 := v51.Get() -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("list")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +v50 := v49.Get() +v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v52 := v51.FindInternedVar(lang.NewSymbol("seq")) +if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) } -v55 := v54.Get() -v56 := lang.Apply(v55, []any{lang.NewSymbol("try")}) +v53 := v52.Get() +v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v55 := v54.FindInternedVar(lang.NewSymbol("concat")) +if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +} +v56 := v55.Get() v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v58 := v57.FindInternedVar(lang.NewSymbol("list")) if v58.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) } v59 := v58.Get() -v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v61 := v60.FindInternedVar(lang.NewSymbol("seq")) -if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) +v60 := lang.Apply(v59, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.PushThreadBindings")}) +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("list")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) } -v62 := v61.Get() -v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v64 := v63.FindInternedVar(lang.NewSymbol("concat")) -if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) +v63 := v62.Get() +v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v65 := v64.FindInternedVar(lang.NewSymbol("apply")) +if v65.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) } -v65 := v64.Get() -v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v67 := v66.FindInternedVar(lang.NewSymbol("list")) -if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) +v66 := v65.Get() +v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v68 := v67.FindInternedVar(lang.NewSymbol("hash-map")) +if v68.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) } -v68 := v67.Get() -v69 := lang.Apply(v68, []any{lang.NewSymbol("glojure.core/let")}) +v69 := v68.Get() v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v71 := v70.FindInternedVar(lang.NewSymbol("list")) +v71 := v70.FindInternedVar(lang.NewSymbol("seq")) if v71.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) } v72 := v71.Get() v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v74 := v73.FindInternedVar(lang.NewSymbol("apply")) +v74 := v73.FindInternedVar(lang.NewSymbol("concat")) if v74.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) } v75 := v74.Get() -v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v77 := v76.FindInternedVar(lang.NewSymbol("vector")) -if v77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) -} -v78 := v77.Get() -v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v80 := v79.FindInternedVar(lang.NewSymbol("seq")) -if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) -} -v81 := v80.Get() -v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v83 := v82.FindInternedVar(lang.NewSymbol("concat")) -if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) +v76 := lang.Apply(v75, nil) +v77 := lang.Apply(v72, []any{v76}) +v78 := lang.Apply(v66, []any{v69, v77}) +v79 := lang.Apply(v63, []any{v78}) +v80 := lang.Apply(v56, []any{v60, v79}) +v81 := lang.Apply(v53, []any{v80}) +v82 := lang.Apply(v50, []any{v81}) +v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v84 := v83.FindInternedVar(lang.NewSymbol("list")) +if v84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) } -v84 := v83.Get() -v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v86 := v85.FindInternedVar(lang.NewSymbol("list")) -if v86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) +v85 := v84.Get() +v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v87 := v86.FindInternedVar(lang.NewSymbol("seq")) +if v87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) } -v87 := v86.Get() -v88 := lang.Apply(v87, []any{lang.NewSymbol("locklocal__1__auto__")}) +v88 := v87.Get() v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v90 := v89.FindInternedVar(lang.NewSymbol("list")) +v90 := v89.FindInternedVar(lang.NewSymbol("concat")) if v90.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) } v91 := v90.Get() -v92 := lang.Apply(v91, []any{lang.NewSymbol("lockee__0__auto__")}) -v93 := lang.Apply(v84, []any{v88, v92}) -v94 := lang.Apply(v81, []any{v93}) -v95 := lang.Apply(v75, []any{v78, v94}) -v96 := lang.Apply(v72, []any{v95}) -v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v98 := v97.FindInternedVar(lang.NewSymbol("list")) -if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) -} -v99 := v98.Get() -v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v101 := v100.FindInternedVar(lang.NewSymbol("seq")) -if v101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) -} -v102 := v101.Get() -v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v104 := v103.FindInternedVar(lang.NewSymbol("concat")) -if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) -} -v105 := v104.Get() -v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v107 := v106.FindInternedVar(lang.NewSymbol("list")) -if v107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) -} -v108 := v107.Get() -v109 := lang.Apply(v108, []any{lang.NewSymbol("monitor-enter")}) -v110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v111 := v110.FindInternedVar(lang.NewSymbol("list")) -if v111.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v111))) -} -v112 := v111.Get() -v113 := lang.Apply(v112, []any{lang.NewSymbol("locklocal__1__auto__")}) -v114 := lang.Apply(v105, []any{v109, v113}) -v115 := lang.Apply(v102, []any{v114}) -v116 := lang.Apply(v99, []any{v115}) -v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v118 := v117.FindInternedVar(lang.NewSymbol("list")) -if v118.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) -} -v119 := v118.Get() -v120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v121 := v120.FindInternedVar(lang.NewSymbol("seq")) -if v121.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v121))) -} -v122 := v121.Get() -v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v124 := v123.FindInternedVar(lang.NewSymbol("concat")) -if v124.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) -} -v125 := v124.Get() -v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v127 := v126.FindInternedVar(lang.NewSymbol("list")) -if v127.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) -} -v128 := v127.Get() -v129 := lang.Apply(v128, []any{lang.NewSymbol("try")}) -v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v131 := v130.FindInternedVar(lang.NewSymbol("list")) -if v131.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) -} -v132 := v131.Get() -v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v134 := v133.FindInternedVar(lang.NewSymbol("seq")) -if v134.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) -} -v135 := v134.Get() -v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v137 := v136.FindInternedVar(lang.NewSymbol("concat")) -if v137.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) -} -v138 := v137.Get() -v139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v140 := v139.FindInternedVar(lang.NewSymbol("list")) -if v140.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v140))) -} -v141 := v140.Get() -v142 := lang.Apply(v141, []any{lang.NewSymbol("finally")}) -v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v144 := v143.FindInternedVar(lang.NewSymbol("list")) -if v144.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) -} -v145 := v144.Get() -v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v147 := v146.FindInternedVar(lang.NewSymbol("seq")) -if v147.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) -} -v148 := v147.Get() -v149 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v150 := v149.FindInternedVar(lang.NewSymbol("concat")) -if v150.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v150))) -} -v151 := v150.Get() -v152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v153 := v152.FindInternedVar(lang.NewSymbol("list")) -if v153.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v153))) -} -v154 := v153.Get() -v155 := lang.Apply(v154, []any{lang.NewSymbol("monitor-exit")}) -v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v157 := v156.FindInternedVar(lang.NewSymbol("list")) -if v157.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) -} -v158 := v157.Get() -v159 := lang.Apply(v158, []any{lang.NewSymbol("locklocal__1__auto__")}) -v160 := lang.Apply(v151, []any{v155, v159}) -v161 := lang.Apply(v148, []any{v160}) -v162 := lang.Apply(v145, []any{v161}) -v163 := lang.Apply(v138, []any{v142, v162}) -v164 := lang.Apply(v135, []any{v163}) -v165 := lang.Apply(v132, []any{v164}) -v166 := lang.Apply(v125, []any{v129, v6, v165}) -v167 := lang.Apply(v122, []any{v166}) -v168 := lang.Apply(v119, []any{v167}) -v169 := lang.Apply(v65, []any{v69, v96, v116, v168}) -v170 := lang.Apply(v62, []any{v169}) -v171 := lang.Apply(v59, []any{v170}) -v172 := lang.Apply(v52, []any{v56, v171}) -v173 := lang.Apply(v49, []any{v172}) -v174 := lang.Apply(v46, []any{v173}) -v175 := lang.Apply(v12, []any{v16, v43, v174}) -v176 := lang.Apply(v9, []any{v175}) -return v176 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// update -{ -v0 := lang.NewSymbol("update").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f"), lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("z")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("z"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "'Updates' a value in an associative structure, where k is a\n key and f is a function that will take the old value\n and any supplied args and return the new value, and returns a new\n structure. If the key does not exist, nil is passed as the old value.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6217), lang.NewKeyword("end-line"), int(6217))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("assoc")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("get")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v3, v4}) -v13 := lang.Apply(v5, []any{v12}) -v14 := lang.Apply(v8, []any{v3, v4, v13}) -return v14 - case 4: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("assoc")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v93 := v92.FindInternedVar(lang.NewSymbol("list")) +if v93.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) } -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("get")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v94 := v93.Get() +v95 := lang.Apply(v94, []any{lang.NewSymbol("try")}) +v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v97 := v96.FindInternedVar(lang.NewSymbol("list")) +if v97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) } -v12 := v11.Get() -v13 := lang.Apply(v12, []any{v3, v4}) -v14 := lang.Apply(v5, []any{v13, v6}) -v15 := lang.Apply(v9, []any{v3, v4, v14}) -return v15 - case 5: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := args[4] -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("assoc")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v98 := v97.Get() +v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v100 := v99.FindInternedVar(lang.NewSymbol("seq")) +if v100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) } -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("get")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v101 := v100.Get() +v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v103 := v102.FindInternedVar(lang.NewSymbol("concat")) +if v103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) } -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v3, v4}) -v15 := lang.Apply(v5, []any{v14, v6, v7}) -v16 := lang.Apply(v10, []any{v3, v4, v15}) -return v16 - case 6: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := args[4] -v8 := args[5] -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("assoc")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +v104 := v103.Get() +v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v106 := v105.FindInternedVar(lang.NewSymbol("list")) +if v106.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) } -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("get")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +v107 := v106.Get() +v108 := lang.Apply(v107, []any{lang.NewSymbol("finally")}) +v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v110 := v109.FindInternedVar(lang.NewSymbol("list")) +if v110.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) } -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v3, v4}) -v16 := lang.Apply(v5, []any{v15, v6, v7, v8}) -v17 := lang.Apply(v11, []any{v3, v4, v16}) -return v17 - default: - if len(args) < 6 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := args[4] -v8 := args[5] -v9 := lang.NewList(args[6:]...) -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("assoc")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +v111 := v110.Get() +v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v113 := v112.FindInternedVar(lang.NewSymbol("seq")) +if v113.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) } -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("apply")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +v114 := v113.Get() +v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v116 := v115.FindInternedVar(lang.NewSymbol("concat")) +if v116.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) } -v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("get")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +v117 := v116.Get() +v118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v119 := v118.FindInternedVar(lang.NewSymbol("list")) +if v119.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v119))) } -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v3, v4}) -v20 := lang.Apply(v15, []any{v5, v19, v6, v7, v8, v9}) -v21 := lang.Apply(v12, []any{v3, v4, v20}) -return v21 +v120 := v119.Get() +v121 := lang.Apply(v120, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.PopThreadBindings")}) +v122 := lang.Apply(v117, []any{v121}) +v123 := lang.Apply(v114, []any{v122}) +v124 := lang.Apply(v111, []any{v123}) +v125 := lang.Apply(v104, []any{v108, v124}) +v126 := lang.Apply(v101, []any{v125}) +v127 := lang.Apply(v98, []any{v126}) +v128 := lang.Apply(v91, []any{v95, v5, v127}) +v129 := lang.Apply(v88, []any{v128}) +v130 := lang.Apply(v85, []any{v129}) +v131 := lang.Apply(v20, []any{v24, v28, v47, v82, v130}) +v132 := lang.Apply(v17, []any{v131}) +v133 := lang.Apply(v14, []any{v132}) +v134 := lang.Apply(v11, []any{v133}) +v135 := lang.Apply(v8, []any{v134}) +return v135 } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -79872,9 +79820,9 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// letfn +// with-local-vars { -v0 := lang.NewSymbol("letfn").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fnspecs"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "fnspec ==> (fname [params*] exprs) or (fname ([params*] exprs)+)\n\n Takes a vector of function specs and a body, and generates a set of\n bindings of functions to their names. All of the names are available\n in all of the definitions of the functions, as well as the body.", lang.NewKeyword("forms"), lang.NewVector(lang.NewList(lang.NewSymbol("letfn"), lang.NewVector(lang.NewSymbol("fnspecs*")), lang.NewSymbol("exprs*"))), lang.NewKeyword("url"), nil, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6588), lang.NewKeyword("end-line"), int(6588), lang.NewKeyword("special-form"), true)).(*lang.Symbol) +v0 := lang.NewSymbol("with-local-vars").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name-vals-vec"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "varbinding=> symbol init-expr\n\n Executes the exprs in a context in which the symbols are bound to\n vars with per-thread bindings to the init-exprs. The symbols refer\n to the var objects themselves, and must be accessed with var-get and\n var-set", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4339), lang.NewKeyword("end-line"), int(4339))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -79886,469 +79834,323 @@ v3 := args[0] v4 := args[1] v5 := args[2] v6 := lang.NewList(args[3:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("seq")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("concat")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +var v7 any +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("list")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v5}) +if lang.IsTruthy(v11) { +v7 = nil +} else { +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("str")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } -v15 := v14.Get() -v16 := lang.Apply(v15, []any{lang.NewSymbol("letfn*")}) -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("list")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("first")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("vec")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v3}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("interleave")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("meta")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("map")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +v24 := v23.Get() +v25 := lang.Apply(v24, []any{v3}) +v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) +v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) +v28 := lang.Apply(lang1.NewIllegalArgumentError, []any{v27}) +panic(v28) } -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("first")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +_ = v7 +var v29 any +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("even?")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) } -v31 := v30.Get() -v32 := lang.Apply(v28, []any{v31, v5}) +v32 := v31.Get() v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("map")) +v34 := v33.FindInternedVar(lang.NewSymbol("count")) if v34.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) } v35 := v34.Get() -var v36 lang.FnFunc -v36 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v37 := args[0] +v36 := lang.Apply(v35, []any{v5}) +v37 := lang.Apply(v32, []any{v36}) +if lang.IsTruthy(v37) { +v29 = nil +} else { v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("cons")) +v39 := v38.FindInternedVar(lang.NewSymbol("str")) if v39.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) } v40 := v39.Get() -v41 := lang.Apply(v40, []any{lang.NewSymbol("glojure.core/fn"), v37}) -return v41 -}) -v37 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6598), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(6598), lang.NewKeyword("end-column"), int(47)) -v38, err := lang.WithMeta(v36, v37.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v39 := lang.Apply(v35, []any{v38, v5}) -v40 := lang.Apply(v25, []any{v32, v39}) -v41 := lang.Apply(v22, []any{v40}) -v42 := lang.Apply(v19, []any{v41}) -v43 := lang.Apply(v12, []any{v16, v42, v6}) -v44 := lang.Apply(v9, []any{v43}) -return v44 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// commute -{ -v0 := lang.NewSymbol("commute").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("fun"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Must be called in a transaction. Sets the in-transaction-value of\n ref to:\n\n (apply fun in-transaction-value-of-ref args)\n\n and returns the in-transaction-value of ref.\n\n At the commit point of the transaction, sets the value of ref to be:\n\n (apply fun most-recently-committed-value-of-ref args)\n\n Thus fun should be commutative, or, failing that, you must accept\n last-one-in-wins behavior. commute allows for more concurrency than\n ref-set.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2414), lang.NewKeyword("end-line"), int(2414))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -v6, _ := lang.FieldOrMethod(v3, "Commute") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Commute is not a function"))) -} -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// keyword? -{ -v0 := lang.NewSymbol("keyword?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a Keyword", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(563), lang.NewKeyword("end-line"), int(563))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{lang1.Keyword, v3}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// -protocols -{ -v0 := lang.NewSymbol("-protocols").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("doc"), "Private store of protocols. Go's reflection capabilities\n don't yet support a native interface-based implementation, so\n protocols are implemented in Glojure as maps from type to protocol\n method implementations.", lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(21), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(26), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v3 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("coll-reduce"), nil), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("coll-reduce"), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("f"), lang.NewSymbol("val")))))) -v4 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("internal-reduce"), nil), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("internal-reduce"), lang.NewVector(lang.NewSymbol("seq"), lang.NewSymbol("f"), lang.NewSymbol("start")))))) -v5 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("kv-reduce"), nil), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("kv-reduce"), lang.NewVector(lang.NewSymbol("amap"), lang.NewSymbol("f"), lang.NewSymbol("init")))))) -v6 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("datafy"), nil), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("datafy"), lang.NewVector(lang.NewSymbol("o")), "return a representation of o as data (default identity)")))) -v7 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("nav"), nil), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("nav"), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("k"), lang.NewSymbol("v")), "return (possibly transformed) v in the context of coll and k (a key/index or nil),\ndefaults to returning v.")))) -v8 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("make-reader"), nil, lang.NewKeyword("make-writer"), nil, lang.NewKeyword("make-input-stream"), nil, lang.NewKeyword("make-output-stream"), nil), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("make-reader"), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("opts")), "Creates an io.Reader. See also IOFactory docs."), lang.NewList(lang.NewSymbol("make-writer"), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("opts")), "Creates an io.Reader. See also IOFactory docs."), lang.NewList(lang.NewSymbol("make-input-stream"), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("opts")), "Creates a BufferedInputStream. See also IOFactory docs."), lang.NewList(lang.NewSymbol("make-output-stream"), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("opts")), "Creates a BufferedOutputStream. See also IOFactory docs.")))) -v2 := lang.NewAtom(lang.NewMap(lang.NewSymbol("CollReduce"), v3, lang.NewSymbol("InternalReduce"), v4, lang.NewSymbol("IKVReduce"), v5, lang.NewSymbol("Datafiable"), v6, lang.NewSymbol("Navigable"), v7, lang.NewSymbol("IOFactory"), v8)) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("first")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } -// macroexpand -{ -v0 := lang.NewSymbol("macroexpand").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("form"))), lang.NewKeyword("doc"), "Repeatedly calls macroexpand-1 on form until it no longer\n represents a macro form, then returns it. Note neither\n macroexpand-1 nor macroexpand expand macros in subforms.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4025), lang.NewKeyword("end-line"), int(4025))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("macroexpand-1")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v3}) +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) } -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -var v4 any = v8 -_ = v4 -var v10 any -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("identical?")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v47 := v46.Get() +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("meta")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) } -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v4, v3}) -if lang.IsTruthy(v14) { -v10 = v3 -} else { -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("macroexpand")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v3}) +v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) +v53 := lang.Apply(v40, []any{v44, " requires ", "an even number of forms in binding vector", " in ", v47, ":", v52}) +v54 := lang.Apply(lang1.NewIllegalArgumentError, []any{v53}) +panic(v54) } -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v4}) -v10 = v18 +_ = v29 +_ = nil +v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v56 := v55.FindInternedVar(lang.NewSymbol("seq")) +if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) } -return v10 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) +v57 := v56.Get() +v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v59 := v58.FindInternedVar(lang.NewSymbol("concat")) +if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) } +v60 := v59.Get() +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("list")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) } -// concat -{ -v0 := lang.NewSymbol("concat").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("zs"))), lang.NewKeyword("doc"), "Returns a lazy seq representing the concatenation of the elements in the supplied colls.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(711), lang.NewKeyword("end-line"), int(711))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -return nil -}) -v4 := lang.Apply(lang1.NewLazySeq, []any{v3}) -return v4 - case 1: -v3 := args[0] -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -return v3 -}) -v5 := lang.Apply(lang1.NewLazySeq, []any{v4}) -return v5 - case 2: -v3 := args[0] -v4 := args[1] -var v5 lang.FnFunc -v5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("seq")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v63 := v62.Get() +v64 := lang.Apply(v63, []any{lang.NewSymbol("glojure.core/let")}) +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("list")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) } -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v3}) -var v6 any = v10 -_ = v6 -var v12 any -if lang.IsTruthy(v6) { -var v13 any -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("chunked-seq?")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v67 := v66.Get() +v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v69 := v68.FindInternedVar(lang.NewSymbol("apply")) +if v69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v6}) -if lang.IsTruthy(v17) { -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("chunk-cons")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v70 := v69.Get() +v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v72 := v71.FindInternedVar(lang.NewSymbol("vector")) +if v72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) } -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("chunk-first")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +v73 := v72.Get() +v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v75 := v74.FindInternedVar(lang.NewSymbol("seq")) +if v75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) } -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v6}) -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("concat")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +v76 := v75.Get() +v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v78 := v77.FindInternedVar(lang.NewSymbol("concat")) +if v78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) } -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("chunk-rest")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +v79 := v78.Get() +v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v81 := v80.FindInternedVar(lang.NewSymbol("interleave")) +if v81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) } -v30 := v29.Get() -v31 := lang.Apply(v30, []any{v6}) -v32 := lang.Apply(v27, []any{v31, v4}) -v33 := lang.Apply(v20, []any{v24, v32}) -v13 = v33 -} else { -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("cons")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +v82 := v81.Get() +v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v84 := v83.FindInternedVar(lang.NewSymbol("take-nth")) +if v84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) } -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("first")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +v85 := v84.Get() +v86 := lang.Apply(v85, []any{int64(2), v5}) +v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v88 := v87.FindInternedVar(lang.NewSymbol("repeat")) +if v88.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) } -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v6}) -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("concat")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +v89 := v88.Get() +v90 := lang.Apply(v89, []any{lang.NewList(lang.NewSymbol(".."), lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.*Var"), lang.NewSymbol("create"), lang.NewSymbol("setDynamic"))}) +v91 := lang.Apply(v82, []any{v86, v90}) +v92 := lang.Apply(v79, []any{v91}) +v93 := lang.Apply(v76, []any{v92}) +v94 := lang.Apply(v70, []any{v73, v93}) +v95 := lang.Apply(v67, []any{v94}) +v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v97 := v96.FindInternedVar(lang.NewSymbol("list")) +if v97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) } -v43 := v42.Get() -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("rest")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +v98 := v97.Get() +v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v100 := v99.FindInternedVar(lang.NewSymbol("seq")) +if v100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) } -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v6}) -v48 := lang.Apply(v43, []any{v47, v4}) -v49 := lang.Apply(v36, []any{v40, v48}) -v13 = v49 +v101 := v100.Get() +v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v103 := v102.FindInternedVar(lang.NewSymbol("concat")) +if v103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) } -v12 = v13 -} else { -v12 = v4 +v104 := v103.Get() +v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v106 := v105.FindInternedVar(lang.NewSymbol("list")) +if v106.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) } -return v12 -}) -v6 := lang.Apply(lang1.NewLazySeq, []any{v5}) -return v6 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -var v7 lang.FnFunc -{ // function cat -v7 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v9 := args[0] -v10 := args[1] -var v11 lang.FnFunc -v11 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("seq")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +v107 := v106.Get() +v108 := lang.Apply(v107, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.PushThreadBindings")}) +v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v110 := v109.FindInternedVar(lang.NewSymbol("list")) +if v110.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) } -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v12}) -var v12 any = v16 -_ = v12 -var v18 any -if lang.IsTruthy(v12) { -var v19 any -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("chunked-seq?")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) +v111 := v110.Get() +v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v113 := v112.FindInternedVar(lang.NewSymbol("apply")) +if v113.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) } -v22 := v21.Get() -v23 := lang.Apply(v22, []any{v12}) -if lang.IsTruthy(v23) { -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("chunk-cons")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +v114 := v113.Get() +v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v116 := v115.FindInternedVar(lang.NewSymbol("hash-map")) +if v116.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) } -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("chunk-first")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v117 := v116.Get() +v118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v119 := v118.FindInternedVar(lang.NewSymbol("seq")) +if v119.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v119))) } -v29 := v28.Get() -v30 := lang.Apply(v29, []any{v12}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("chunk-rest")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +v120 := v119.Get() +v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v122 := v121.FindInternedVar(lang.NewSymbol("concat")) +if v122.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) } -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v12}) -v35 := lang.Apply(v8, []any{v34, v10}) -v36 := lang.Apply(v26, []any{v30, v35}) -v19 = v36 -} else { -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("cons")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +v123 := v122.Get() +v124 := lang.Apply(v123, nil) +v125 := lang.Apply(v120, []any{v124}) +v126 := lang.Apply(v114, []any{v117, v125}) +v127 := lang.Apply(v111, []any{v126}) +v128 := lang.Apply(v104, []any{v108, v127}) +v129 := lang.Apply(v101, []any{v128}) +v130 := lang.Apply(v98, []any{v129}) +v131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v132 := v131.FindInternedVar(lang.NewSymbol("list")) +if v132.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v132))) } -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("first")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +v133 := v132.Get() +v134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v135 := v134.FindInternedVar(lang.NewSymbol("seq")) +if v135.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v135))) } -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v12}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("rest")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +v136 := v135.Get() +v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v138 := v137.FindInternedVar(lang.NewSymbol("concat")) +if v138.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) } -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v12}) -v48 := lang.Apply(v8, []any{v47, v10}) -v49 := lang.Apply(v39, []any{v43, v48}) -v19 = v49 +v139 := v138.Get() +v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v141 := v140.FindInternedVar(lang.NewSymbol("list")) +if v141.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) } -v18 = v19 -} else { -var v50 any -if lang.IsTruthy(v10) { -v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v52 := v51.FindInternedVar(lang.NewSymbol("first")) -if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) +v142 := v141.Get() +v143 := lang.Apply(v142, []any{lang.NewSymbol("try")}) +v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v145 := v144.FindInternedVar(lang.NewSymbol("list")) +if v145.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) } -v53 := v52.Get() -v54 := lang.Apply(v53, []any{v10}) -v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v56 := v55.FindInternedVar(lang.NewSymbol("next")) -if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) +v146 := v145.Get() +v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v148 := v147.FindInternedVar(lang.NewSymbol("seq")) +if v148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) } -v57 := v56.Get() -v58 := lang.Apply(v57, []any{v10}) -v59 := lang.Apply(v8, []any{v54, v58}) -v50 = v59 -} else { -v50 = nil +v149 := v148.Get() +v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v151 := v150.FindInternedVar(lang.NewSymbol("concat")) +if v151.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) } -v18 = v50 +v152 := v151.Get() +v153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v154 := v153.FindInternedVar(lang.NewSymbol("list")) +if v154.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v154))) } -return v18 -}) -v12 := lang.Apply(lang1.NewLazySeq, []any{v11}) -return v12 -}) -v8 := v7 -_ = v8 +v155 := v154.Get() +v156 := lang.Apply(v155, []any{lang.NewSymbol("finally")}) +v157 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v158 := v157.FindInternedVar(lang.NewSymbol("list")) +if v158.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v158))) } -v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(726), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(735), lang.NewKeyword("end-column"), int(56)) -v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) -if err != nil { - panic(err) +v159 := v158.Get() +v160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v161 := v160.FindInternedVar(lang.NewSymbol("seq")) +if v161.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v161))) } -var v6 any = v9 -_ = v6 -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("concat")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v162 := v161.Get() +v163 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v164 := v163.FindInternedVar(lang.NewSymbol("concat")) +if v164.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v164))) } -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v3, v4}) -v15 := lang.Apply(v6, []any{v14, v5}) -return v15 +v165 := v164.Get() +v166 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v167 := v166.FindInternedVar(lang.NewSymbol("list")) +if v167.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v167))) +} +v168 := v167.Get() +v169 := lang.Apply(v168, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.PopThreadBindings")}) +v170 := lang.Apply(v165, []any{v169}) +v171 := lang.Apply(v162, []any{v170}) +v172 := lang.Apply(v159, []any{v171}) +v173 := lang.Apply(v152, []any{v156, v172}) +v174 := lang.Apply(v149, []any{v173}) +v175 := lang.Apply(v146, []any{v174}) +v176 := lang.Apply(v139, []any{v143, v6, v175}) +v177 := lang.Apply(v136, []any{v176}) +v178 := lang.Apply(v133, []any{v177}) +v179 := lang.Apply(v60, []any{v64, v95, v130, v178}) +v180 := lang.Apply(v57, []any{v179}) +return v180 } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -80357,711 +80159,859 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// doall +// with-meta { -v0 := lang.NewSymbol("doall").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "When lazy sequences are produced via functions that have side\n effects, any effects other than those needed to produce the first\n element in the seq do not occur until the seq is consumed. doall can\n be used to force any effects. Walks through the successive nexts of\n the seq, retains the head and returns it, thus causing the entire\n seq to reside in memory at one time.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3131), lang.NewKeyword("end-line"), int(3131))).(*lang.Symbol) +v0 := lang.NewSymbol("with-meta").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("obj"), lang.NewSymbol("m"))), lang.NewKeyword("doc"), "Returns an object of the same type and value as obj, with\n map m as its metadata.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(211), lang.NewKeyword("end-line"), int(216))).(*lang.Symbol) var v2 lang.FnFunc +{ // function with-meta v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("dorun")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{v3}) -_ = v7 -return v3 - case 2: -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("dorun")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3, v4}) -_ = v8 -return v4 - default: + if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } +v4 := args[0] +v5 := args[1] +v6, _ := lang.FieldOrMethod(v4, "WithMeta") +if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("WithMeta is not a function"))) +} +v7 := lang.Apply(v6, []any{v5}) +return v7 }) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(216), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(217), lang.NewKeyword("end-column"), int(32))).(lang.FnFunc) +v3 := v2 +_ = v3 +} v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// pr-str +// with-open { -v1 := reflect.TypeOf("") -v0 := lang.NewSymbol("pr-str").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("xs"))), lang.NewKeyword("doc"), "pr to a string, returning it", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4758), lang.NewKeyword("end-line"), int(4758))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { +v0 := lang.NewSymbol("with-open").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "bindings => [name init ...]\n\n Evaluates body in a try expression with names bound to the values\n of the inits, and a finally clause that calls (.close name) on each\n name in reverse order.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3832), lang.NewKeyword("end-line"), int(3832))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 0 { + if len(args) < 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v4 := lang.NewList(args[0:]...) -var v5 any = "unimplemented: new with non-constant class type" -_ = v5 +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +var v7 any v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("push-thread-bindings")) +v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) if v9.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) } v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("hash-map")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) +v11 := lang.Apply(v10, []any{v5}) +if lang.IsTruthy(v11) { +v7 = nil +} else { +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("str")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } -v13 := v12.Get() -v14 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*out*")) -v15 := lang.Apply(v13, []any{v14, v5}) -v16 := lang.Apply(v10, []any{v15}) -_ = v16 -var v17 any -func() { -defer func() { -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v14 := v13.Get() +v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v16 := v15.FindInternedVar(lang.NewSymbol("first")) +if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) } -v20 := v19.Get() -v21 := lang.Apply(v20, nil) -}() +v17 := v16.Get() +v18 := lang.Apply(v17, []any{v3}) +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("apply")) +v23 := v22.FindInternedVar(lang.NewSymbol("meta")) if v23.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("pr")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.Apply(v24, []any{v27, v4}) -_ = v28 -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("str")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.Apply(v31, []any{v5}) -v17 = v32 -}() -return v17 - } -}) -v4 := reflect.TypeOf("") -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// condp -{ -v0 := lang.NewSymbol("condp").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes a binary predicate, an expression, and a set of clauses.\n Each clause can take the form of either:\n\n test-expr result-expr\n\n test-expr :>> result-fn\n\n Note :>> is an ordinary keyword.\n\n For each clause, (pred test-expr expr) is evaluated. If it returns\n logical true, the clause is a match. If a binary clause matches, the\n result-expr is returned, if a ternary clause matches, its result-fn,\n which must be a unary function, is called with the result of the\n predicate as its argument, the result of that call being the return\n value of condp. A single default expression can follow the clauses,\n and its value will be returned if no clause matches. If no default\n expression is provided and no clause matches, an\n IllegalArgumentException is thrown.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6396), lang.NewKeyword("end-line"), int(6396))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := lang.NewList(args[4:]...) -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("gensym")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v11, []any{"pred__"}) -var v8 any = v12 -_ = v8 -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("gensym")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{"expr__"}) -var v13 any = v17 -_ = v13 -var v19 lang.FnFunc -{ // function emit -v19 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v21 := args[0] -v22 := args[1] -v23 := args[2] -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("split-at")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +v25 := lang.Apply(v24, []any{v3}) +v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) +v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) +v28 := lang.Apply(lang1.NewIllegalArgumentError, []any{v27}) +panic(v28) } -v27 := v26.Get() -var v28 any -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("=")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +_ = v7 +var v29 any +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("even?")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) } -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("second")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +v32 := v31.Get() +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("count")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) } -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v23}) -v36 := lang.Apply(v31, []any{lang.NewKeyword(">>"), v35}) -if lang.IsTruthy(v36) { -v28 = int64(3) +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v5}) +v37 := lang.Apply(v32, []any{v36}) +if lang.IsTruthy(v37) { +v29 = nil } else { -v28 = int64(2) +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("str")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) } -v37 := lang.Apply(v27, []any{v28, v23}) -var v24 any = v37 -_ = v24 -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("nth")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("first")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } -v41 := v40.Get() -v42 := lang.Apply(v41, []any{v24, int64(0), nil}) -var v38 any = v42 -_ = v38 -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("nth")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v3}) +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) } -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v38, int64(0), nil}) -var v43 any = v47 -_ = v43 -v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v50 := v49.FindInternedVar(lang.NewSymbol("nth")) -if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) +v47 := v46.Get() +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("meta")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) } -v51 := v50.Get() -v52 := lang.Apply(v51, []any{v38, int64(1), nil}) -var v48 any = v52 -_ = v48 -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("nth")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v3}) +v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) +v53 := lang.Apply(v40, []any{v44, " requires ", "an even number of forms in binding vector", " in ", v47, ":", v52}) +v54 := lang.Apply(lang1.NewIllegalArgumentError, []any{v53}) +panic(v54) } -v56 := v55.Get() -v57 := lang.Apply(v56, []any{v38, int64(2), nil}) -var v53 any = v57 -_ = v53 -var v58 any = v38 -_ = v58 -v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v61 := v60.FindInternedVar(lang.NewSymbol("nth")) -if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) +_ = v29 +_ = nil +var v55 any +v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v57 := v56.FindInternedVar(lang.NewSymbol("=")) +if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) } -v62 := v61.Get() -v63 := lang.Apply(v62, []any{v24, int64(1), nil}) -var v59 any = v63 -_ = v59 -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("count")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) +v58 := v57.Get() +v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v60 := v59.FindInternedVar(lang.NewSymbol("count")) +if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) } -v67 := v66.Get() -v68 := lang.Apply(v67, []any{v58}) -var v64 any = v68 -_ = v64 -var v70 any -v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v72 := v71.FindInternedVar(lang.NewSymbol("=")) -if v72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) +v61 := v60.Get() +v62 := lang.Apply(v61, []any{v5}) +v63 := lang.Apply(v58, []any{v62, int64(0)}) +if lang.IsTruthy(v63) { +v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v65 := v64.FindInternedVar(lang.NewSymbol("seq")) +if v65.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) } -v73 := v72.Get() -v74 := lang.Apply(v73, []any{int64(0), v64}) -if lang.IsTruthy(v74) { -v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v76 := v75.FindInternedVar(lang.NewSymbol("seq")) -if v76.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) +v66 := v65.Get() +v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v68 := v67.FindInternedVar(lang.NewSymbol("concat")) +if v68.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) } -v77 := v76.Get() -v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v79 := v78.FindInternedVar(lang.NewSymbol("concat")) -if v79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) +v69 := v68.Get() +v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v71 := v70.FindInternedVar(lang.NewSymbol("list")) +if v71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) } -v80 := v79.Get() -v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v82 := v81.FindInternedVar(lang.NewSymbol("list")) -if v82.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) +v72 := v71.Get() +v73 := lang.Apply(v72, []any{lang.NewSymbol("do")}) +v74 := lang.Apply(v69, []any{v73, v6}) +v75 := lang.Apply(v66, []any{v74}) +v55 = v75 +} else { +var v76 any +v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v78 := v77.FindInternedVar(lang.NewSymbol("symbol?")) +if v78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) } -v83 := v82.Get() -v84 := lang.Apply(v83, []any{lang.NewSymbol("throw")}) +v79 := v78.Get() +v80 := lang.Apply(v5, []any{int64(0)}) +v81 := lang.Apply(v79, []any{v80}) +if lang.IsTruthy(v81) { +v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v83 := v82.FindInternedVar(lang.NewSymbol("seq")) +if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) +} +v84 := v83.Get() v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v86 := v85.FindInternedVar(lang.NewSymbol("list")) +v86 := v85.FindInternedVar(lang.NewSymbol("concat")) if v86.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) } v87 := v86.Get() v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v89 := v88.FindInternedVar(lang.NewSymbol("seq")) +v89 := v88.FindInternedVar(lang.NewSymbol("list")) if v89.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) } v90 := v89.Get() -v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v92 := v91.FindInternedVar(lang.NewSymbol("concat")) -if v92.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) +v91 := lang.Apply(v90, []any{lang.NewSymbol("glojure.core/let")}) +v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v93 := v92.FindInternedVar(lang.NewSymbol("list")) +if v93.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) } -v93 := v92.Get() -v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v95 := v94.FindInternedVar(lang.NewSymbol("list")) -if v95.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) +v94 := v93.Get() +v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v96 := v95.FindInternedVar(lang.NewSymbol("subvec")) +if v96.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) } -v96 := v95.Get() -v97 := lang.Apply(v96, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewIllegalArgumentError")}) -v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v99 := v98.FindInternedVar(lang.NewSymbol("list")) -if v99.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) +v97 := v96.Get() +v98 := lang.Apply(v97, []any{v5, int64(0), int64(2)}) +v99 := lang.Apply(v94, []any{v98}) +v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v101 := v100.FindInternedVar(lang.NewSymbol("list")) +if v101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) } -v100 := v99.Get() -v101 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v102 := v101.FindInternedVar(lang.NewSymbol("seq")) -if v102.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v102))) +v102 := v101.Get() +v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v104 := v103.FindInternedVar(lang.NewSymbol("seq")) +if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) } -v103 := v102.Get() -v104 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v105 := v104.FindInternedVar(lang.NewSymbol("concat")) -if v105.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v105))) +v105 := v104.Get() +v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v107 := v106.FindInternedVar(lang.NewSymbol("concat")) +if v107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) } -v106 := v105.Get() -v107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v108 := v107.FindInternedVar(lang.NewSymbol("list")) -if v108.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v108))) +v108 := v107.Get() +v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v110 := v109.FindInternedVar(lang.NewSymbol("list")) +if v110.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) } -v109 := v108.Get() -v110 := lang.Apply(v109, []any{lang.NewSymbol("glojure.core/str")}) -v111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v112 := v111.FindInternedVar(lang.NewSymbol("list")) -if v112.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v112))) +v111 := v110.Get() +v112 := lang.Apply(v111, []any{lang.NewSymbol("try")}) +v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v114 := v113.FindInternedVar(lang.NewSymbol("list")) +if v114.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) } -v113 := v112.Get() -v114 := lang.Apply(v113, []any{"No matching clause: "}) -v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v116 := v115.FindInternedVar(lang.NewSymbol("list")) -if v116.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) +v115 := v114.Get() +v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v117 := v116.FindInternedVar(lang.NewSymbol("seq")) +if v117.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) } -v117 := v116.Get() -v118 := lang.Apply(v117, []any{v22}) -v119 := lang.Apply(v106, []any{v110, v114, v118}) -v120 := lang.Apply(v103, []any{v119}) -v121 := lang.Apply(v100, []any{v120}) -v122 := lang.Apply(v93, []any{v97, v121}) -v123 := lang.Apply(v90, []any{v122}) -v124 := lang.Apply(v87, []any{v123}) -v125 := lang.Apply(v80, []any{v84, v124}) -v126 := lang.Apply(v77, []any{v125}) -v70 = v126 -} else { -var v127 any -v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v129 := v128.FindInternedVar(lang.NewSymbol("=")) -if v129.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v129))) +v118 := v117.Get() +v119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v120 := v119.FindInternedVar(lang.NewSymbol("concat")) +if v120.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v120))) } -v130 := v129.Get() -v131 := lang.Apply(v130, []any{int64(1), v64}) -if lang.IsTruthy(v131) { -v127 = v43 -} else { -var v132 any -v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v134 := v133.FindInternedVar(lang.NewSymbol("=")) -if v134.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) +v121 := v120.Get() +v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v123 := v122.FindInternedVar(lang.NewSymbol("list")) +if v123.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) } -v135 := v134.Get() -v136 := lang.Apply(v135, []any{int64(2), v64}) -if lang.IsTruthy(v136) { +v124 := v123.Get() +v125 := lang.Apply(v124, []any{lang.NewSymbol("glojure.core/with-open")}) +v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v127 := v126.FindInternedVar(lang.NewSymbol("list")) +if v127.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) +} +v128 := v127.Get() +v129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v130 := v129.FindInternedVar(lang.NewSymbol("subvec")) +if v130.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v130))) +} +v131 := v130.Get() +v132 := lang.Apply(v131, []any{v5, int64(2)}) +v133 := lang.Apply(v128, []any{v132}) +v134 := lang.Apply(v121, []any{v125, v133, v6}) +v135 := lang.Apply(v118, []any{v134}) +v136 := lang.Apply(v115, []any{v135}) v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v138 := v137.FindInternedVar(lang.NewSymbol("seq")) +v138 := v137.FindInternedVar(lang.NewSymbol("list")) if v138.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) } v139 := v138.Get() v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v141 := v140.FindInternedVar(lang.NewSymbol("concat")) +v141 := v140.FindInternedVar(lang.NewSymbol("seq")) if v141.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) } v142 := v141.Get() v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v144 := v143.FindInternedVar(lang.NewSymbol("list")) +v144 := v143.FindInternedVar(lang.NewSymbol("concat")) if v144.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) } v145 := v144.Get() -v146 := lang.Apply(v145, []any{lang.NewSymbol("if")}) -v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v148 := v147.FindInternedVar(lang.NewSymbol("list")) -if v148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) +v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v147 := v146.FindInternedVar(lang.NewSymbol("list")) +if v147.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) } -v149 := v148.Get() +v148 := v147.Get() +v149 := lang.Apply(v148, []any{lang.NewSymbol("finally")}) v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v151 := v150.FindInternedVar(lang.NewSymbol("seq")) +v151 := v150.FindInternedVar(lang.NewSymbol("list")) if v151.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) } v152 := v151.Get() v153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v154 := v153.FindInternedVar(lang.NewSymbol("concat")) +v154 := v153.FindInternedVar(lang.NewSymbol("seq")) if v154.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v154))) } v155 := v154.Get() v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v157 := v156.FindInternedVar(lang.NewSymbol("list")) +v157 := v156.FindInternedVar(lang.NewSymbol("concat")) if v157.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) } v158 := v157.Get() -v159 := lang.Apply(v158, []any{v21}) -v160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v161 := v160.FindInternedVar(lang.NewSymbol("list")) -if v161.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v161))) -} -v162 := v161.Get() -v163 := lang.Apply(v162, []any{v43}) -v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v165 := v164.FindInternedVar(lang.NewSymbol("list")) -if v165.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) +v159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v160 := v159.FindInternedVar(lang.NewSymbol("list")) +if v160.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v160))) } -v166 := v165.Get() -v167 := lang.Apply(v166, []any{v22}) -v168 := lang.Apply(v155, []any{v159, v163, v167}) -v169 := lang.Apply(v152, []any{v168}) -v170 := lang.Apply(v149, []any{v169}) -v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v172 := v171.FindInternedVar(lang.NewSymbol("list")) -if v172.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) +v161 := v160.Get() +v162 := lang.Apply(v161, []any{lang.NewSymbol(".")}) +v163 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v164 := v163.FindInternedVar(lang.NewSymbol("list")) +if v164.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v164))) } -v173 := v172.Get() -v174 := lang.Apply(v173, []any{v48}) -v175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v176 := v175.FindInternedVar(lang.NewSymbol("list")) -if v176.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v176))) +v165 := v164.Get() +v166 := lang.Apply(v5, []any{int64(0)}) +v167 := lang.Apply(v165, []any{v166}) +v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v169 := v168.FindInternedVar(lang.NewSymbol("list")) +if v169.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) } -v177 := v176.Get() -v178 := lang.Apply(v20, []any{v21, v22, v59}) -v179 := lang.Apply(v177, []any{v178}) -v180 := lang.Apply(v142, []any{v146, v170, v174, v179}) -v181 := lang.Apply(v139, []any{v180}) -v132 = v181 +v170 := v169.Get() +v171 := lang.Apply(v170, []any{lang.NewSymbol("close")}) +v172 := lang.Apply(v158, []any{v162, v167, v171}) +v173 := lang.Apply(v155, []any{v172}) +v174 := lang.Apply(v152, []any{v173}) +v175 := lang.Apply(v145, []any{v149, v174}) +v176 := lang.Apply(v142, []any{v175}) +v177 := lang.Apply(v139, []any{v176}) +v178 := lang.Apply(v108, []any{v112, v136, v177}) +v179 := lang.Apply(v105, []any{v178}) +v180 := lang.Apply(v102, []any{v179}) +v181 := lang.Apply(v87, []any{v91, v99, v180}) +v182 := lang.Apply(v84, []any{v181}) +v76 = v182 } else { -var v182 any +var v183 any if lang.IsTruthy(lang.NewKeyword("else")) { -v183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v184 := v183.FindInternedVar(lang.NewSymbol("seq")) -if v184.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v184))) +v184 := lang.Apply(lang1.NewIllegalArgumentError, []any{"with-open only allows Symbols in bindings"}) +panic(v184) +} else { +v183 = nil } -v185 := v184.Get() -v186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v187 := v186.FindInternedVar(lang.NewSymbol("concat")) -if v187.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v187))) +v76 = v183 } -v188 := v187.Get() -v189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v190 := v189.FindInternedVar(lang.NewSymbol("list")) -if v190.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v190))) +v55 = v76 } -v191 := v190.Get() -v192 := lang.Apply(v191, []any{lang.NewSymbol("glojure.core/if-let")}) -v193 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v194 := v193.FindInternedVar(lang.NewSymbol("list")) -if v194.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v194))) +return v55 + } +}) +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v195 := v194.Get() -v196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v197 := v196.FindInternedVar(lang.NewSymbol("apply")) -if v197.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v197))) } -v198 := v197.Get() -v199 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v200 := v199.FindInternedVar(lang.NewSymbol("vector")) -if v200.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v200))) +// with-out-str +{ +v0 := lang.NewSymbol("with-out-str").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Evaluates exprs in a context in which *out* is bound to a fresh\n StringWriter. Returns the string created by any nested printing\n calls.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4738), lang.NewKeyword("end-line"), int(4738))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := lang.NewList(args[2:]...) +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("seq")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v201 := v200.Get() -v202 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v203 := v202.FindInternedVar(lang.NewSymbol("seq")) -if v203.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v203))) +v8 := v7.Get() +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("concat")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) +} +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("list")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) +} +v14 := v13.Get() +v15 := lang.Apply(v14, []any{lang.NewSymbol("glojure.core/let")}) +v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v17 := v16.FindInternedVar(lang.NewSymbol("list")) +if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) +} +v18 := v17.Get() +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("apply")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("vector")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +} +v24 := v23.Get() +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("seq")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) +} +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("concat")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{lang.NewSymbol("s__0__auto__")}) +v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v36 := v35.FindInternedVar(lang.NewSymbol("list")) +if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +} +v37 := v36.Get() +v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v39 := v38.FindInternedVar(lang.NewSymbol("seq")) +if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +} +v40 := v39.Get() +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("concat")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } -v204 := v203.Get() -v205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v206 := v205.FindInternedVar(lang.NewSymbol("concat")) -if v206.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v206))) +v43 := v42.Get() +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } -v207 := v206.Get() -v208 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v209 := v208.FindInternedVar(lang.NewSymbol("list")) -if v209.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v209))) +v46 := v45.Get() +v47 := lang.Apply(v46, []any{lang.NewSymbol("new")}) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("list")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) } -v210 := v209.Get() -v211 := lang.Apply(v210, []any{lang.NewSymbol("p__0__auto__")}) -v212 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v213 := v212.FindInternedVar(lang.NewSymbol("list")) -if v213.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v213))) +v50 := v49.Get() +v51 := lang.Apply(v50, []any{lang.NewSymbol("strings.Builder")}) +v52 := lang.Apply(v43, []any{v47, v51}) +v53 := lang.Apply(v40, []any{v52}) +v54 := lang.Apply(v37, []any{v53}) +v55 := lang.Apply(v30, []any{v34, v54}) +v56 := lang.Apply(v27, []any{v55}) +v57 := lang.Apply(v21, []any{v24, v56}) +v58 := lang.Apply(v18, []any{v57}) +v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v60 := v59.FindInternedVar(lang.NewSymbol("list")) +if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) } -v214 := v213.Get() -v215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v216 := v215.FindInternedVar(lang.NewSymbol("seq")) -if v216.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v216))) +v61 := v60.Get() +v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v63 := v62.FindInternedVar(lang.NewSymbol("seq")) +if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) } -v217 := v216.Get() -v218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v219 := v218.FindInternedVar(lang.NewSymbol("concat")) -if v219.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v219))) +v64 := v63.Get() +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("concat")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) } -v220 := v219.Get() -v221 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v222 := v221.FindInternedVar(lang.NewSymbol("list")) -if v222.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v222))) +v67 := v66.Get() +v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v69 := v68.FindInternedVar(lang.NewSymbol("list")) +if v69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) } -v223 := v222.Get() -v224 := lang.Apply(v223, []any{v21}) -v225 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v226 := v225.FindInternedVar(lang.NewSymbol("list")) -if v226.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v226))) +v70 := v69.Get() +v71 := lang.Apply(v70, []any{lang.NewSymbol("glojure.core/binding")}) +v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v73 := v72.FindInternedVar(lang.NewSymbol("list")) +if v73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) } -v227 := v226.Get() -v228 := lang.Apply(v227, []any{v43}) -v229 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v230 := v229.FindInternedVar(lang.NewSymbol("list")) -if v230.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v230))) +v74 := v73.Get() +v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v76 := v75.FindInternedVar(lang.NewSymbol("apply")) +if v76.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) } -v231 := v230.Get() -v232 := lang.Apply(v231, []any{v22}) -v233 := lang.Apply(v220, []any{v224, v228, v232}) -v234 := lang.Apply(v217, []any{v233}) -v235 := lang.Apply(v214, []any{v234}) -v236 := lang.Apply(v207, []any{v211, v235}) -v237 := lang.Apply(v204, []any{v236}) -v238 := lang.Apply(v198, []any{v201, v237}) -v239 := lang.Apply(v195, []any{v238}) -v240 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v241 := v240.FindInternedVar(lang.NewSymbol("list")) -if v241.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v241))) +v77 := v76.Get() +v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v79 := v78.FindInternedVar(lang.NewSymbol("vector")) +if v79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) } -v242 := v241.Get() -v243 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v244 := v243.FindInternedVar(lang.NewSymbol("seq")) -if v244.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v244))) +v80 := v79.Get() +v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v82 := v81.FindInternedVar(lang.NewSymbol("seq")) +if v82.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) } -v245 := v244.Get() -v246 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v247 := v246.FindInternedVar(lang.NewSymbol("concat")) -if v247.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v247))) +v83 := v82.Get() +v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v85 := v84.FindInternedVar(lang.NewSymbol("concat")) +if v85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) } -v248 := v247.Get() -v249 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v250 := v249.FindInternedVar(lang.NewSymbol("list")) -if v250.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v250))) +v86 := v85.Get() +v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v88 := v87.FindInternedVar(lang.NewSymbol("list")) +if v88.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) } -v251 := v250.Get() -v252 := lang.Apply(v251, []any{v53}) -v253 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v254 := v253.FindInternedVar(lang.NewSymbol("list")) -if v254.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v254))) +v89 := v88.Get() +v90 := lang.Apply(v89, []any{lang.NewSymbol("glojure.core/*out*")}) +v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v92 := v91.FindInternedVar(lang.NewSymbol("list")) +if v92.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) } -v255 := v254.Get() -v256 := lang.Apply(v255, []any{lang.NewSymbol("p__0__auto__")}) -v257 := lang.Apply(v248, []any{v252, v256}) -v258 := lang.Apply(v245, []any{v257}) -v259 := lang.Apply(v242, []any{v258}) -v260 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v261 := v260.FindInternedVar(lang.NewSymbol("list")) -if v261.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v261))) +v93 := v92.Get() +v94 := lang.Apply(v93, []any{lang.NewSymbol("s__0__auto__")}) +v95 := lang.Apply(v86, []any{v90, v94}) +v96 := lang.Apply(v83, []any{v95}) +v97 := lang.Apply(v77, []any{v80, v96}) +v98 := lang.Apply(v74, []any{v97}) +v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v100 := v99.FindInternedVar(lang.NewSymbol("list")) +if v100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) } -v262 := v261.Get() -v263 := lang.Apply(v20, []any{v21, v22, v59}) -v264 := lang.Apply(v262, []any{v263}) -v265 := lang.Apply(v188, []any{v192, v239, v259, v264}) -v266 := lang.Apply(v185, []any{v265}) -v182 = v266 -} else { -v182 = nil +v101 := v100.Get() +v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v103 := v102.FindInternedVar(lang.NewSymbol("seq")) +if v103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) } -v132 = v182 +v104 := v103.Get() +v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v106 := v105.FindInternedVar(lang.NewSymbol("concat")) +if v106.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) } -v127 = v132 +v107 := v106.Get() +v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v109 := v108.FindInternedVar(lang.NewSymbol("list")) +if v109.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) } -v70 = v127 +v110 := v109.Get() +v111 := lang.Apply(v110, []any{lang.NewSymbol("glojure.core/str")}) +v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v113 := v112.FindInternedVar(lang.NewSymbol("list")) +if v113.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) } -return v70 +v114 := v113.Get() +v115 := lang.Apply(v114, []any{lang.NewSymbol("s__0__auto__")}) +v116 := lang.Apply(v107, []any{v111, v115}) +v117 := lang.Apply(v104, []any{v116}) +v118 := lang.Apply(v101, []any{v117}) +v119 := lang.Apply(v67, []any{v71, v98, v5, v118}) +v120 := lang.Apply(v64, []any{v119}) +v121 := lang.Apply(v61, []any{v120}) +v122 := lang.Apply(v11, []any{v15, v58, v121}) +v123 := lang.Apply(v8, []any{v122}) +return v123 + } }) -v20 := v19 -_ = v20 +v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) +v1 := ns.InternWithValue(v0, v2, true) +if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } -v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6420), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(6432), lang.NewKeyword("end-column"), int(53)) -v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) -if err != nil { - panic(err) } -var v18 any = v21 -_ = v18 -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("seq")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +// with-precision +{ +v0 := lang.NewSymbol("with-precision").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("precision"), lang.NewSymbol("&"), lang.NewSymbol("exprs"))), lang.NewKeyword("doc"), "Sets the precision and rounding mode to be used for BigDecimal operations.\n\n Usage: (with-precision 10 (/ 1M 3))\n or: (with-precision 10 :rounding HALF_DOWN (/ 1M 3))\n\n The rounding mode is one of CEILING, FLOOR, HALF_UP, HALF_DOWN,\n HALF_EVEN, UP, DOWN and UNNECESSARY; it defaults to HALF_UP.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5110), lang.NewKeyword("end-line"), int(5110))).(*lang.Symbol) +var v2 lang.FnFunc +v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v3 := args[0] +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) +var v8 any +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("=")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("concat")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +v11 := v10.Get() +v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v13 := v12.FindInternedVar(lang.NewSymbol("first")) +if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("list")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +v14 := v13.Get() +v15 := lang.Apply(v14, []any{v6}) +v16 := lang.Apply(v11, []any{v15, lang.NewKeyword("rounding")}) +if lang.IsTruthy(v16) { +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("next")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v31 := v30.Get() -v32 := lang.Apply(v31, []any{lang.NewSymbol("glojure.core/let")}) -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("list")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("next")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v35 := v34.Get() -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("apply")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) +v22 := v21.Get() +v23 := lang.Apply(v22, []any{v6}) +v24 := lang.Apply(v19, []any{v23}) +v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v26 := v25.FindInternedVar(lang.NewSymbol("seq")) +if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } -v38 := v37.Get() -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("vector")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) +v27 := v26.Get() +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("concat")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) } -v41 := v40.Get() -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("seq")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +v30 := v29.Get() +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } -v44 := v43.Get() -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("concat")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) +v33 := v32.Get() +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("seq")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) } -v47 := v46.Get() +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("concat")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("list")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) +} +v42 := v41.Get() +v43 := lang.Apply(v42, []any{lang.NewSymbol(".")}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.Apply(v46, []any{lang.NewSymbol("java.math.RoundingMode")}) v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v49 := v48.FindInternedVar(lang.NewSymbol("list")) if v49.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) } v50 := v49.Get() -v51 := lang.Apply(v50, []any{v8}) -v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("list")) -if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) +v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v52 := v51.FindInternedVar(lang.NewSymbol("second")) +if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) } -v54 := v53.Get() -v55 := lang.Apply(v54, []any{v5}) -v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v57 := v56.FindInternedVar(lang.NewSymbol("list")) -if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) +v53 := v52.Get() +v54 := lang.Apply(v53, []any{v6}) +v55 := lang.Apply(v50, []any{v54}) +v56 := lang.Apply(v39, []any{v43, v47, v55}) +v57 := lang.Apply(v36, []any{v56}) +v58 := lang.Apply(v33, []any{v57}) +v59 := lang.Apply(v30, []any{v58}) +v60 := lang.Apply(v27, []any{v59}) +v61 := lang.NewVector(v24, v60) +v62 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5121), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(5122), lang.NewKeyword("end-column"), int(69)) +v63, err := lang.WithMeta(v61, v62.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v58 := v57.Get() -v59 := lang.Apply(v58, []any{v13}) -v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v61 := v60.FindInternedVar(lang.NewSymbol("list")) -if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) +v8 = v63 +} else { +v64 := lang.NewVector(v6, nil) +v65 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5123), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(5123), lang.NewKeyword("end-column"), int(33)) +v66, err := lang.WithMeta(v64, v65.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v62 := v61.Get() -v63 := lang.Apply(v62, []any{v6}) -v64 := lang.Apply(v47, []any{v51, v55, v59, v63}) -v65 := lang.Apply(v44, []any{v64}) -v66 := lang.Apply(v38, []any{v41, v65}) -v67 := lang.Apply(v35, []any{v66}) +v8 = v66 +} +var v7 any = v8 +_ = v7 v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v69 := v68.FindInternedVar(lang.NewSymbol("list")) +v69 := v68.FindInternedVar(lang.NewSymbol("nth")) if v69.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) } v70 := v69.Get() -v71 := lang.Apply(v18, []any{v8, v13, v7}) -v72 := lang.Apply(v70, []any{v71}) -v73 := lang.Apply(v28, []any{v32, v67, v72}) -v74 := lang.Apply(v25, []any{v73}) -return v74 +v71 := lang.Apply(v70, []any{v7, int64(0), nil}) +var v67 any = v71 +_ = v67 +v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v74 := v73.FindInternedVar(lang.NewSymbol("nth")) +if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) +} +v75 := v74.Get() +v76 := lang.Apply(v75, []any{v7, int64(1), nil}) +var v72 any = v76 +_ = v72 +v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v79 := v78.FindInternedVar(lang.NewSymbol("seq")) +if v79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) +} +v80 := v79.Get() +v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v82 := v81.FindInternedVar(lang.NewSymbol("concat")) +if v82.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) +} +v83 := v82.Get() +v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v85 := v84.FindInternedVar(lang.NewSymbol("list")) +if v85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) +} +v86 := v85.Get() +v87 := lang.Apply(v86, []any{lang.NewSymbol("glojure.core/binding")}) +v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v89 := v88.FindInternedVar(lang.NewSymbol("list")) +if v89.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) +} +v90 := v89.Get() +v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v92 := v91.FindInternedVar(lang.NewSymbol("apply")) +if v92.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) +} +v93 := v92.Get() +v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v95 := v94.FindInternedVar(lang.NewSymbol("vector")) +if v95.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) +} +v96 := v95.Get() +v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v98 := v97.FindInternedVar(lang.NewSymbol("seq")) +if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) +} +v99 := v98.Get() +v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v101 := v100.FindInternedVar(lang.NewSymbol("concat")) +if v101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) +} +v102 := v101.Get() +v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v104 := v103.FindInternedVar(lang.NewSymbol("list")) +if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) +} +v105 := v104.Get() +v106 := lang.Apply(v105, []any{lang.NewSymbol("glojure.core/*math-context*")}) +v107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v108 := v107.FindInternedVar(lang.NewSymbol("list")) +if v108.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v108))) +} +v109 := v108.Get() +v110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v111 := v110.FindInternedVar(lang.NewSymbol("seq")) +if v111.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v111))) +} +v112 := v111.Get() +v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v114 := v113.FindInternedVar(lang.NewSymbol("concat")) +if v114.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) +} +v115 := v114.Get() +v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v117 := v116.FindInternedVar(lang.NewSymbol("list")) +if v117.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) +} +v118 := v117.Get() +v119 := lang.Apply(v118, []any{lang.NewSymbol("java.math.MathContext.")}) +v120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v121 := v120.FindInternedVar(lang.NewSymbol("list")) +if v121.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v121))) +} +v122 := v121.Get() +v123 := lang.Apply(v122, []any{v5}) +v124 := lang.Apply(v115, []any{v119, v123, v72}) +v125 := lang.Apply(v112, []any{v124}) +v126 := lang.Apply(v109, []any{v125}) +v127 := lang.Apply(v102, []any{v106, v126}) +v128 := lang.Apply(v99, []any{v127}) +v129 := lang.Apply(v93, []any{v96, v128}) +v130 := lang.Apply(v90, []any{v129}) +v131 := lang.Apply(v83, []any{v87, v130, v67}) +v132 := lang.Apply(v80, []any{v131}) +return v132 } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -81070,58 +81020,167 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// data-reader-var +// with-redefs { -v0 := lang.NewSymbol("data-reader-var").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7875), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7875), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v0 := lang.NewSymbol("with-redefs").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "binding => var-symbol temp-value-expr\n\n Temporarily redefines Vars while executing the body. The\n temp-value-exprs will be evaluated and each resulting value will\n replace in parallel the root value of its Var. After the body is\n executed, the root values of all the Vars will be set back to their\n old values. These temporary changes will be visible in all threads.\n Useful for mocking out functions during testing.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7587), lang.NewKeyword("end-line"), int(7587))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("intern")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() +v4 := args[1] +v5 := args[2] +v6 := lang.NewList(args[3:]...) v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("create-ns")) +v8 := v7.FindInternedVar(lang.NewSymbol("seq")) if v8.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } v9 := v8.Get() v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("symbol")) +v11 := v10.FindInternedVar(lang.NewSymbol("concat")) if v11.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } v12 := v11.Get() v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("namespace")) +v14 := v13.FindInternedVar(lang.NewSymbol("list")) if v14.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } v15 := v14.Get() -v16 := lang.Apply(v15, []any{v3}) -v17 := lang.Apply(v12, []any{v16}) -v18 := lang.Apply(v9, []any{v17}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("symbol")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/with-redefs-fn")}) +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("list")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("name")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) +v19 := v18.Get() +v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v21 := v20.FindInternedVar(lang.NewSymbol("zipmap")) +if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v26 := lang.Apply(v21, []any{v25}) -v27 := lang.Apply(v6, []any{v18, v26}) -return v27 +v22 := v21.Get() +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("map")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +var v26 lang.FnFunc +v26 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v27 := args[0] +v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v29 := v28.FindInternedVar(lang.NewSymbol("list")) +if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) +} +v30 := v29.Get() +v31 := lang.Apply(v30, []any{lang.NewSymbol("var"), v27}) +return v31 +}) +v27 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7598), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(7598), lang.NewKeyword("end-column"), int(47)) +v28, err := lang.WithMeta(v26, v27.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("take-nth")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) +} +v31 := v30.Get() +v32 := lang.Apply(v31, []any{int64(2), v5}) +v33 := lang.Apply(v25, []any{v28, v32}) +v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v35 := v34.FindInternedVar(lang.NewSymbol("take-nth")) +if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +} +v36 := v35.Get() +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("next")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v5}) +v41 := lang.Apply(v36, []any{int64(2), v40}) +v42 := lang.Apply(v22, []any{v33, v41}) +v43 := lang.Apply(v19, []any{v42}) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("list")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) +} +v46 := v45.Get() +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("seq")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +} +v49 := v48.Get() +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("concat")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +} +v52 := v51.Get() +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("list")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) +} +v55 := v54.Get() +v56 := lang.Apply(v55, []any{lang.NewSymbol("glojure.core/fn")}) +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("list")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +} +v59 := v58.Get() +v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v61 := v60.FindInternedVar(lang.NewSymbol("apply")) +if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) +} +v62 := v61.Get() +v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v64 := v63.FindInternedVar(lang.NewSymbol("vector")) +if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) +} +v65 := v64.Get() +v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v67 := v66.FindInternedVar(lang.NewSymbol("seq")) +if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) +} +v68 := v67.Get() +v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v70 := v69.FindInternedVar(lang.NewSymbol("concat")) +if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +} +v71 := v70.Get() +v72 := lang.Apply(v71, nil) +v73 := lang.Apply(v68, []any{v72}) +v74 := lang.Apply(v62, []any{v65, v73}) +v75 := lang.Apply(v59, []any{v74}) +v76 := lang.Apply(v52, []any{v56, v75, v6}) +v77 := lang.Apply(v49, []any{v76}) +v78 := lang.Apply(v46, []any{v77}) +v79 := lang.Apply(v12, []any{v16, v43, v78}) +v80 := lang.Apply(v9, []any{v79}) +return v80 + } }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -81129,71 +81188,298 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// ns-imports +// with-redefs-fn { -v0 := lang.NewSymbol("ns-imports").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of the import mappings for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4199), lang.NewKeyword("end-line"), int(4199))).(*lang.Symbol) +v0 := lang.NewSymbol("with-redefs-fn").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("binding-map"), lang.NewSymbol("func"))), lang.NewKeyword("doc"), "Temporarily redefines Vars during a call to func. Each val of\n binding-map will replace the root value of its key which must be\n a Var. After func is called with no args, the root values of all\n the Vars will be set back to their old values. These temporary\n changes will be visible in all threads. Useful for mocking out\n functions during testing.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7567), lang.NewKeyword("end-line"), int(7567))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { + if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("filter-key")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +v4 := args[1] +var v6 lang.FnFunc +v6 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +v7 := args[0] +v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v10 := v9.FindInternedVar(lang.NewSymbol("seq")) +if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("val")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) +v11 := v10.Get() +v12 := lang.Apply(v11, []any{v7}) +var v8 any = v12 +_ = v8 +var v13 any = nil +_ = v13 +var v14 any = int64(0) +_ = v14 +var v15 any = int64(0) +_ = v15 +var v16 any +for { +var v17 any +v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v19 := v18.FindInternedVar(lang.NewSymbol("<")) +if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } -v9 := v8.Get() +v20 := v19.Get() +v21 := lang.Apply(v20, []any{v15, v14}) +if lang.IsTruthy(v21) { +v23, _ := lang.FieldOrMethod(v13, "nth") +if reflect.TypeOf(v23).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) +} +v24 := lang.Apply(v23, []any{v15}) +var v22 any = v24 +_ = v22 +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("nth")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) +} +v28 := v27.Get() +v29 := lang.Apply(v28, []any{v22, int64(0), nil}) +var v25 any = v29 +_ = v25 +v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v32 := v31.FindInternedVar(lang.NewSymbol("nth")) +if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) +} +v33 := v32.Get() +v34 := lang.Apply(v33, []any{v22, int64(1), nil}) +var v30 any = v34 +_ = v30 +v36, _ := lang.FieldOrMethod(v25, "bindRoot") +if reflect.TypeOf(v36).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("bindRoot is not a function"))) +} +v37 := lang.Apply(v36, []any{v30}) +_ = v37 +var v38 any = v8 +var v39 any = v13 +var v40 any = v14 +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("unchecked-inc")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +} +v44 := v43.Get() +v45 := lang.Apply(v44, []any{v15}) +var v41 any = v45 +v8 = v38 +v13 = v39 +v14 = v40 +v15 = v41 +continue +} else { +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("seq")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{v8}) +var v22 any = v26 +_ = v22 +var v28 any +if lang.IsTruthy(v22) { +var v29 any = v22 +_ = v29 +var v31 any +v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v33 := v32.FindInternedVar(lang.NewSymbol("chunked-seq?")) +if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) +} +v34 := v33.Get() +v35 := lang.Apply(v34, []any{v29}) +if lang.IsTruthy(v35) { +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("chunk-first")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v29}) +var v36 any = v40 +_ = v36 +v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v44 := v43.FindInternedVar(lang.NewSymbol("chunk-rest")) +if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) +} +v45 := v44.Get() +v46 := lang.Apply(v45, []any{v29}) +var v42 any = v46 +var v47 any = v36 +v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v50 := v49.FindInternedVar(lang.NewSymbol("int")) +if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) +} +v51 := v50.Get() +v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v53 := v52.FindInternedVar(lang.NewSymbol("count")) +if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) +} +v54 := v53.Get() +v55 := lang.Apply(v54, []any{v36}) +v56 := lang.Apply(v51, []any{v55}) +var v48 any = v56 +v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v59 := v58.FindInternedVar(lang.NewSymbol("int")) +if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) +} +v60 := v59.Get() +v61 := lang.Apply(v60, []any{int64(0)}) +var v57 any = v61 +v8 = v42 +v13 = v47 +v14 = v48 +v15 = v57 +continue +} else { +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("first")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) +} +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v29}) +var v36 any = v40 +_ = v36 +v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v43 := v42.FindInternedVar(lang.NewSymbol("nth")) +if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +} +v44 := v43.Get() +v45 := lang.Apply(v44, []any{v36, int64(0), nil}) +var v41 any = v45 +_ = v41 +v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v48 := v47.FindInternedVar(lang.NewSymbol("nth")) +if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +} +v49 := v48.Get() +v50 := lang.Apply(v49, []any{v36, int64(1), nil}) +var v46 any = v50 +_ = v46 +v52, _ := lang.FieldOrMethod(v41, "bindRoot") +if reflect.TypeOf(v52).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("bindRoot is not a function"))) +} +v53 := lang.Apply(v52, []any{v46}) +_ = v53 +v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v56 := v55.FindInternedVar(lang.NewSymbol("next")) +if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) +} +v57 := v56.Get() +v58 := lang.Apply(v57, []any{v29}) +var v54 any = v58 +var v59 any = nil +var v60 any = int64(0) +var v61 any = int64(0) +v8 = v54 +v13 = v59 +v14 = v60 +v15 = v61 +continue +} +v28 = v31 +} else { +v28 = nil +} +v17 = v28 +} +v16 = v17 + break +} +return v16 +}) +v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7576), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(7578), lang.NewKeyword("end-column"), int(93)) +v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +var v5 any = v8 +_ = v5 v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("partial")) +v11 := v10.FindInternedVar(lang.NewSymbol("zipmap")) if v11.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } v12 := v11.Get() v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("instance?")) +v14 := v13.FindInternedVar(lang.NewSymbol("keys")) if v14.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } v15 := v14.Get() -v16 := lang.Apply(v12, []any{v15, reflect.Type}) +v16 := lang.Apply(v15, []any{v3}) v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("ns-map")) +v18 := v17.FindInternedVar(lang.NewSymbol("map")) if v18.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } v19 := v18.Get() -v20 := lang.Apply(v19, []any{v3}) -v21 := lang.Apply(v6, []any{v9, v16, v20}) -return v21 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// rationalize -{ -v0 := lang.NewSymbol("rationalize").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("doc"), "returns the rational value of num", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1282), lang.NewKeyword("end-line"), int(1282))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { +var v20 lang.FnFunc +v20 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := args[0] -v4, _ := lang.FieldOrMethod(lang1.Numbers, "rationalize") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("rationalize is not a function"))) +v21 := args[0] +v22, ok := lang.FieldOrMethod(v21, "getRawRoot") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v21, "getRawRoot"))) } -v5 := lang.Apply(v4, []any{v3}) -return v5 +var v23 any +switch reflect.TypeOf(v22).Kind() { +case reflect.Func: + v23 = lang.Apply(v22, nil) +default: + v23 = v22 +} +return v23 +}) +v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7580), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(7580), lang.NewKeyword("end-column"), int(92)) +v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) +if err != nil { + panic(err) +} +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("keys")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) +} +v25 := v24.Get() +v26 := lang.Apply(v25, []any{v3}) +v27 := lang.Apply(v19, []any{v22, v26}) +v28 := lang.Apply(v12, []any{v16, v27}) +var v9 any = v28 +_ = v9 +var v30 any +func() { +defer func() { +v31 := lang.Apply(v5, []any{v9}) +}() +v32 := lang.Apply(v5, []any{v3}) +_ = v32 +v33 := lang.Apply(v4, nil) +v30 = v33 +}() +return v30 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -81201,114 +81487,49 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// apply +// xml-seq { -v0 := lang.NewSymbol("apply").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("z"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Applies fn f to the argument list formed by prepending intervening arguments to args.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(653), lang.NewKeyword("end-line"), int(653))).(*lang.Symbol) +v0 := lang.NewSymbol("xml-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("root"))), lang.NewKeyword("doc"), "A tree seq on the xml elements as per xml/parse", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4982), lang.NewKeyword("end-line"), int(4982))).(*lang.Symbol) var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v4}) -v9 := lang.Apply(lang1.Apply, []any{v3, v8}) -return v9 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("list*")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v4, v5}) -v10 := lang.Apply(lang1.Apply, []any{v3, v9}) -return v10 - case 4: +v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] +v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v5 := v4.FindInternedVar(lang.NewSymbol("tree-seq")) +if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) +} +v6 := v5.Get() v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("list*")) +v8 := v7.FindInternedVar(lang.NewSymbol("complement")) if v8.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } v9 := v8.Get() -v10 := lang.Apply(v9, []any{v4, v5, v6}) -v11 := lang.Apply(lang1.Apply, []any{v3, v10}) -return v11 - case 5: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := args[4] -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("list*")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v4, v5, v6, v7}) -v12 := lang.Apply(lang1.Apply, []any{v3, v11}) -return v12 - default: - if len(args) < 5 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := args[4] -v8 := lang.NewList(args[5:]...) -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("cons")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("cons")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("cons")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) +v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v11 := v10.FindInternedVar(lang.NewSymbol("string?")) +if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } -v17 := v16.Get() -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("cons")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +v12 := v11.Get() +v13 := lang.Apply(v9, []any{v12}) +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("comp")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("spread")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +v16 := v15.Get() +v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v18 := v17.FindInternedVar(lang.NewSymbol("seq")) +if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v8}) -v25 := lang.Apply(v20, []any{v7, v24}) -v26 := lang.Apply(v17, []any{v6, v25}) -v27 := lang.Apply(v14, []any{v5, v26}) -v28 := lang.Apply(v11, []any{v4, v27}) -v29 := lang.Apply(lang1.Apply, []any{v3, v28}) -return v29 - } +v19 := v18.Get() +v20 := lang.Apply(v16, []any{v19, lang.NewKeyword("content")}) +v21 := lang.Apply(v6, []any{v13, v20, v3}) +return v21 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -81316,10 +81537,10 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// inc +// zero? { var v1 lang.FnFunc -{ // function inc__inliner +{ // function zero?__inliner v1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -81375,46 +81596,34 @@ if v28.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) } v29 := v28.Get() -var v30 any +v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/isZero")}) v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) +v32 := v31.FindInternedVar(lang.NewSymbol("list")) if v32.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } v33 := v32.Get() -if lang.IsTruthy(v33) { -v30 = lang.NewSymbol("unchecked_inc") -} else { -v30 = lang.NewSymbol("inc") -} -v34 := lang.Apply(v29, []any{v30}) -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("list")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v3}) -v39 := lang.Apply(v26, []any{v34, v38}) -v40 := lang.Apply(v23, []any{v39}) -v41 := lang.Apply(v20, []any{v40}) -v42 := lang.Apply(v9, []any{v13, v17, v41}) -v43 := lang.Apply(v6, []any{v42}) -return v43 +v34 := lang.Apply(v33, []any{v3}) +v35 := lang.Apply(v26, []any{v30, v34}) +v36 := lang.Apply(v23, []any{v35}) +v37 := lang.Apply(v20, []any{v36}) +v38 := lang.Apply(v9, []any{v13, v17, v37}) +v39 := lang.Apply(v6, []any{v38}) +return v39 }) v2 := v1 _ = v2 } -v0 := lang.NewSymbol("inc").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns a number one greater than num. Does not auto-promote\n longs, will throw on overflow. See also: inc'", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(915), lang.NewKeyword("end-line"), int(915))).(*lang.Symbol) +v0 := lang.NewSymbol("zero?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns true if num is zero, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(860), lang.NewKeyword("end-line"), int(860))).(*lang.Symbol) var v3 lang.FnFunc v3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "inc") +v5, _ := lang.FieldOrMethod(lang1.Numbers, "isZero") if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("inc is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("isZero is not a function"))) } v6 := lang.Apply(v5, []any{v4}) return v6 @@ -81425,326 +81634,117 @@ if v0.Meta() != nil { v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// test +// zipmap { -v0 := lang.NewSymbol("test").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("v"))), lang.NewKeyword("doc"), "test [v] finds fn at key :test in var metadata and calls it,\n presuming failure will throw exception", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4853), lang.NewKeyword("end-line"), int(4853))).(*lang.Symbol) +v0 := lang.NewSymbol("zipmap").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("keys"), lang.NewSymbol("vals"))), lang.NewKeyword("doc"), "Returns a map with the keys mapped to the corresponding vals.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6626), lang.NewKeyword("end-line"), int(6626))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("meta")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -v9 := lang.Apply(lang.NewKeyword("test"), []any{v8}) -var v4 any = v9 -_ = v4 -var v11 any -if lang.IsTruthy(v4) { -v12 := lang.Apply(v4, nil) -_ = v12 -v11 = lang.NewKeyword("ok") -} else { -v11 = lang.NewKeyword("no-test") -} -return v11 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// < -{ -var v1 lang.FnFunc -{ // function <__inliner -v1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("concat")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("list")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("seq")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("concat")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("list")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/lt")}) -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v4}) -v40 := lang.Apply(v27, []any{v31, v35, v39}) -v41 := lang.Apply(v24, []any{v40}) -v42 := lang.Apply(v21, []any{v41}) -v43 := lang.Apply(v10, []any{v14, v18, v42}) -v44 := lang.Apply(v7, []any{v43}) -return v44 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("<").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns non-nil if nums are in monotonically increasing order,\n otherwise false.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(893), lang.NewKeyword("end-line"), int(893))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v4 := args[0] -return true - case 2: -v4 := args[0] -v5 := args[1] -v6, _ := lang.FieldOrMethod(lang1.Numbers, "lt") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("lt is not a function"))) +v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v7 := v6.FindInternedVar(lang.NewSymbol("transient")) +if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6 := lang.NewList(args[2:]...) -recur_loop_150: -var v7 any -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("<")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +v8 := v7.Get() +v9 := lang.NewMap() +v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6631), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(6631), lang.NewKeyword("end-column"), int(28)) +v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) +if err != nil { + panic(err) } -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v4, v5}) -if lang.IsTruthy(v11) { -var v12 any -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("next")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +v12 := lang.Apply(v8, []any{v11}) +var v5 any = v12 +_ = v5 +v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v15 := v14.FindInternedVar(lang.NewSymbol("seq")) +if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v6}) -if lang.IsTruthy(v16) { -var v17 any = v5 +v16 := v15.Get() +v17 := lang.Apply(v16, []any{v3}) +var v13 any = v17 +_ = v13 v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("first")) +v20 := v19.FindInternedVar(lang.NewSymbol("seq")) if v20.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } v21 := v20.Get() -v22 := lang.Apply(v21, []any{v6}) +v22 := lang.Apply(v21, []any{v4}) var v18 any = v22 -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("next")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v6}) -var v23 any = v27 -v4 = v17 -v5 = v18 -v6 = v23 -goto recur_loop_150 -} else { -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("<")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("first")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v6}) -v35 := lang.Apply(v30, []any{v5, v34}) -v12 = v35 -} -v7 = v12 -} else { -v7 = false -} -return v7 - } -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// set -{ -v0 := lang.NewSymbol("set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a set of the distinct elements of coll.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4104), lang.NewKeyword("end-line"), int(4104))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("set?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -if lang.IsTruthy(v8) { -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("with-meta")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v3, nil}) -v4 = v12 +_ = v18 +var v23 any +for { +var v24 any +var v25 any = v13 +_ = v25 +var v27 any +if lang.IsTruthy(v25) { +v27 = v18 } else { -var v13 any -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("instance?")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) +v27 = v25 } -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang1.IReduceInit, v3}) -if lang.IsTruthy(v17) { -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("persistent!")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) +if lang.IsTruthy(v27) { +v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v27 := v26.FindInternedVar(lang.NewSymbol("assoc!")) +if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) } -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("conj!")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) +v28 := v27.Get() +v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v30 := v29.FindInternedVar(lang.NewSymbol("first")) +if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) } -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("transient")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) +v31 := v30.Get() +v32 := lang.Apply(v31, []any{v13}) +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("first")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) } -v26 := v25.Get() -v27 := lang.CreatePersistentTreeSet() -v28 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4112), lang.NewKeyword("column"), int(108), lang.NewKeyword("end-line"), int(4112), lang.NewKeyword("end-column"), int(110)) -v29, err := lang.WithMeta(v27, v28.(lang.IPersistentMap)) -if err != nil { - panic(err) +v35 := v34.Get() +v36 := lang.Apply(v35, []any{v18}) +v37 := lang.Apply(v28, []any{v5, v32, v36}) +var v25 any = v37 +v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v40 := v39.FindInternedVar(lang.NewSymbol("next")) +if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) } -v30 := lang.Apply(v26, []any{v29}) -v31, _ := lang.FieldOrMethod(v3, "ReduceInit") -if reflect.TypeOf(v31).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) +v41 := v40.Get() +v42 := lang.Apply(v41, []any{v13}) +var v38 any = v42 +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("next")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } -v32 := lang.Apply(v31, []any{v23, v30}) -v33 := lang.Apply(v20, []any{v32}) -v13 = v33 +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v18}) +var v43 any = v47 +v5 = v25 +v13 = v38 +v18 = v43 +continue } else { -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("persistent!")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("reduce1")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("conj!")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("transient")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.CreatePersistentTreeSet() -v47 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4113), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(4113), lang.NewKeyword("end-column"), int(48)) -v48, err := lang.WithMeta(v46, v47.(lang.IPersistentMap)) -if err != nil { - panic(err) +v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v49 := v48.FindInternedVar(lang.NewSymbol("persistent!")) +if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) } -v49 := lang.Apply(v45, []any{v48}) -v50 := lang.Apply(v39, []any{v42, v49, v3}) -v51 := lang.Apply(v36, []any{v50}) -v13 = v51 +v50 := v49.Get() +v51 := lang.Apply(v50, []any{v5}) +v24 = v51 } -v4 = v13 +v23 = v24 + break } -return v4 +return v23 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) diff --git a/pkg/codegen/testdata/codegen/test/fn_closure.go b/pkg/codegen/testdata/codegen/test/fn_closure.go index 3df055da..f9d656e0 100644 --- a/pkg/codegen/testdata/codegen/test/fn_closure.go +++ b/pkg/codegen/testdata/codegen/test/fn_closure.go @@ -9,64 +9,12 @@ import ( func init() { // Closed-over values + var closed0 = int64(42) v0 := lang.NewAtom(int64(0)) - var closed0 = v0 - var closed1 = int64(42) + var closed1 = v0 ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.fn-closure")) _ = ns - // get-atom - { - v0 := lang.NewSymbol("get-atom").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/fn_closure.glj", lang.NewKeyword("line"), int(10), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(10), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.fn-closure")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v4 := v3.FindInternedVar(lang.NewSymbol("deref")) - if v4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) - } - v5 := v4.Get() - v6 := lang.Apply(v5, []any{closed0}) - return v6 - }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) - } - } - // inc-atom - { - v0 := lang.NewSymbol("inc-atom").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/fn_closure.glj", lang.NewKeyword("line"), int(8), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(8), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.fn-closure")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v4 := v3.FindInternedVar(lang.NewSymbol("swap!")) - if v4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) - } - v5 := v4.Get() - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("inc")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v5, []any{closed0, v8}) - return v9 - }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) - } - } // -main { v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), lang.NewVector(int64(42), int64(1)), lang.NewKeyword("file"), "codegen/test/fn_closure.glj", lang.NewKeyword("line"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(13), lang.NewKeyword("end-column"), int(38), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.fn-closure")))).(*lang.Symbol) @@ -119,7 +67,7 @@ func init() { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - return closed1 + return closed0 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/fn_closure.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(49))).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -156,4 +104,56 @@ func init() { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } + // get-atom + { + v0 := lang.NewSymbol("get-atom").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/fn_closure.glj", lang.NewKeyword("line"), int(10), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(10), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.fn-closure")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v4 := v3.FindInternedVar(lang.NewSymbol("deref")) + if v4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) + } + v5 := v4.Get() + v6 := lang.Apply(v5, []any{closed1}) + return v6 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // inc-atom + { + v0 := lang.NewSymbol("inc-atom").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/fn_closure.glj", lang.NewKeyword("line"), int(8), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(8), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.fn-closure")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v4 := v3.FindInternedVar(lang.NewSymbol("swap!")) + if v4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) + } + v5 := v4.Get() + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("inc")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v5, []any{closed1, v8}) + return v9 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } } diff --git a/pkg/codegen/testdata/codegen/test/try_advanced.go b/pkg/codegen/testdata/codegen/test/try_advanced.go index ca833d3f..66672a45 100644 --- a/pkg/codegen/testdata/codegen/test/try_advanced.go +++ b/pkg/codegen/testdata/codegen/test/try_advanced.go @@ -10,71 +10,6 @@ import ( func init() { ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-advanced")) _ = ns - // try-custom-value - { - v0 := lang.NewSymbol("try-custom-value").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_advanced.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-advanced")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var v3 any - func() { - defer func() { - if r := recover(); r != nil { - if lang.CatchMatches(r, lang.Builtins["any"]) { - v4 := r - _ = v4 - v3 = v4 - } else { - panic(r) - } - } - }() - panic("custom error") - }() - return v3 - }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) - } - } - // catch-binding-scope-2 - { - v0 := lang.NewSymbol("catch-binding-scope-2").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_advanced.glj", lang.NewKeyword("line"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(16), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-advanced")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var v3 any = "outer" - _ = v3 - var v5 any - func() { - defer func() { - if r := recover(); r != nil { - if lang.CatchMatches(r, lang.Builtins["any"]) { - v6 := r - _ = v6 - v5 = v6 - } else { - panic(r) - } - } - }() - panic("test") - }() - _ = v5 - return v3 - }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) - } - } // -main { v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), "advanced tests passed", lang.NewKeyword("file"), "codegen/test/try_advanced.glj", lang.NewKeyword("line"), int(30), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(30), lang.NewKeyword("end-column"), int(55), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-advanced")))).(*lang.Symbol) @@ -175,21 +110,32 @@ func init() { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } - // finally-with-return + // catch-binding-scope { - v0 := lang.NewSymbol("finally-with-return").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_advanced.glj", lang.NewKeyword("line"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(24), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-advanced")))).(*lang.Symbol) + v0 := lang.NewSymbol("catch-binding-scope").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_advanced.glj", lang.NewKeyword("line"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(9), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-advanced")))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - var v3 any + var v3 any = "outer" + _ = v3 + var v5 any func() { defer func() { + if r := recover(); r != nil { + if lang.CatchMatches(r, lang.Builtins["any"]) { + v6 := r + _ = v6 + v5 = v6 + } else { + panic(r) + } + } }() - v3 = int64(42) + panic("test") }() - return v3 + return v5 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -197,9 +143,9 @@ func init() { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } - // catch-binding-scope + // catch-binding-scope-2 { - v0 := lang.NewSymbol("catch-binding-scope").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_advanced.glj", lang.NewKeyword("line"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(9), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-advanced")))).(*lang.Symbol) + v0 := lang.NewSymbol("catch-binding-scope-2").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_advanced.glj", lang.NewKeyword("line"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(16), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-advanced")))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { @@ -222,7 +168,61 @@ func init() { }() panic("test") }() - return v5 + _ = v5 + return v3 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // finally-with-return + { + v0 := lang.NewSymbol("finally-with-return").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_advanced.glj", lang.NewKeyword("line"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(24), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-advanced")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v3 any + func() { + defer func() { + }() + v3 = int64(42) + }() + return v3 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // try-custom-value + { + v0 := lang.NewSymbol("try-custom-value").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_advanced.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-advanced")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v3 any + func() { + defer func() { + if r := recover(); r != nil { + if lang.CatchMatches(r, lang.Builtins["any"]) { + v4 := r + _ = v4 + v3 = v4 + } else { + panic(r) + } + } + }() + panic("custom error") + }() + return v3 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) diff --git a/pkg/codegen/testdata/codegen/test/try_basic.go b/pkg/codegen/testdata/codegen/test/try_basic.go index 7ddd410e..afcba7eb 100644 --- a/pkg/codegen/testdata/codegen/test/try_basic.go +++ b/pkg/codegen/testdata/codegen/test/try_basic.go @@ -10,39 +10,6 @@ import ( func init() { ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")) _ = ns - // try-catch-finally - { - v0 := lang.NewSymbol("try-catch-finally").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(26), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(26), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var v3 any - func() { - defer func() { - }() - defer func() { - if r := recover(); r != nil { - if lang.CatchMatches(r, lang.Builtins["any"]) { - v4 := r - _ = v4 - v3 = "caught" - } else { - panic(r) - } - } - }() - panic("error") - }() - return v3 - }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) - } - } // -main { v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), "all tests passed", lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(43), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(43), lang.NewKeyword("end-column"), int(50), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")))).(*lang.Symbol) @@ -185,9 +152,9 @@ func init() { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } - // try-with-throw + // basic-try { - v0 := lang.NewSymbol("try-with-throw").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(9), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")))).(*lang.Symbol) + v0 := lang.NewSymbol("basic-try").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { @@ -200,36 +167,13 @@ func init() { if lang.CatchMatches(r, lang.Builtins["any"]) { v4 := r _ = v4 - v3 = "caught exception" + v3 = "caught" } else { panic(r) } } }() - panic("test error") - v3 = "not reached" - }() - return v3 - }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) - } - } - // try-finally-only - { - v0 := lang.NewSymbol("try-finally-only").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(20), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var v3 any - func() { - defer func() { - }() - v3 = "body" + v3 = "success" }() return v3 }) @@ -285,9 +229,9 @@ func init() { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } - // basic-try + // try-catch-finally { - v0 := lang.NewSymbol("basic-try").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")))).(*lang.Symbol) + v0 := lang.NewSymbol("try-catch-finally").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(26), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(26), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { @@ -295,6 +239,8 @@ func init() { } var v3 any func() { + defer func() { + }() defer func() { if r := recover(); r != nil { if lang.CatchMatches(r, lang.Builtins["any"]) { @@ -306,7 +252,29 @@ func init() { } } }() - v3 = "success" + panic("error") + }() + return v3 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // try-finally-only + { + v0 := lang.NewSymbol("try-finally-only").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(20), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v3 any + func() { + defer func() { + }() + v3 = "body" }() return v3 }) @@ -336,4 +304,36 @@ func init() { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } + // try-with-throw + { + v0 := lang.NewSymbol("try-with-throw").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(9), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v3 any + func() { + defer func() { + if r := recover(); r != nil { + if lang.CatchMatches(r, lang.Builtins["any"]) { + v4 := r + _ = v4 + v3 = "caught exception" + } else { + panic(r) + } + } + }() + panic("test error") + v3 = "not reached" + }() + return v3 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } } diff --git a/pkg/gen/gljimports/gljimports_darwin_amd64.go b/pkg/gen/gljimports/gljimports_darwin_amd64.go index 3d7dcfb9..467fcc35 100644 --- a/pkg/gen/gljimports/gljimports_darwin_amd64.go +++ b/pkg/gen/gljimports/gljimports_darwin_amd64.go @@ -3471,6 +3471,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.CloneThreadBindingFrame", github_com_glojurelang_glojure_pkg_lang.CloneThreadBindingFrame) _register("github.com/glojurelang/glojure/pkg/lang.Compare", github_com_glojurelang_glojure_pkg_lang.Compare) _register("github.com/glojurelang/glojure/pkg/lang.Comparer", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Comparer)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.CompilerError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.CompilerError)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.*CompilerError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.CompilerError)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.ConcatStrings", github_com_glojurelang_glojure_pkg_lang.ConcatStrings) _register("github.com/glojurelang/glojure/pkg/lang.Conj", github_com_glojurelang_glojure_pkg_lang.Conj) _register("github.com/glojurelang/glojure/pkg/lang.Conjer", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Conjer)(nil)).Elem()) @@ -3783,6 +3785,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewChar", github_com_glojurelang_glojure_pkg_lang.NewChar) _register("github.com/glojurelang/glojure/pkg/lang.NewChunkBuffer", github_com_glojurelang_glojure_pkg_lang.NewChunkBuffer) _register("github.com/glojurelang/glojure/pkg/lang.NewChunkedCons", github_com_glojurelang_glojure_pkg_lang.NewChunkedCons) + _register("github.com/glojurelang/glojure/pkg/lang.NewCompilerError", github_com_glojurelang_glojure_pkg_lang.NewCompilerError) _register("github.com/glojurelang/glojure/pkg/lang.NewCons", github_com_glojurelang_glojure_pkg_lang.NewCons) _register("github.com/glojurelang/glojure/pkg/lang.NewCycle", github_com_glojurelang_glojure_pkg_lang.NewCycle) _register("github.com/glojurelang/glojure/pkg/lang.NewError", github_com_glojurelang_glojure_pkg_lang.NewError) diff --git a/pkg/gen/gljimports/gljimports_darwin_arm64.go b/pkg/gen/gljimports/gljimports_darwin_arm64.go index ce8d350b..a80f9a62 100644 --- a/pkg/gen/gljimports/gljimports_darwin_arm64.go +++ b/pkg/gen/gljimports/gljimports_darwin_arm64.go @@ -3471,6 +3471,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.CloneThreadBindingFrame", github_com_glojurelang_glojure_pkg_lang.CloneThreadBindingFrame) _register("github.com/glojurelang/glojure/pkg/lang.Compare", github_com_glojurelang_glojure_pkg_lang.Compare) _register("github.com/glojurelang/glojure/pkg/lang.Comparer", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Comparer)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.CompilerError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.CompilerError)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.*CompilerError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.CompilerError)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.ConcatStrings", github_com_glojurelang_glojure_pkg_lang.ConcatStrings) _register("github.com/glojurelang/glojure/pkg/lang.Conj", github_com_glojurelang_glojure_pkg_lang.Conj) _register("github.com/glojurelang/glojure/pkg/lang.Conjer", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Conjer)(nil)).Elem()) @@ -3783,6 +3785,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewChar", github_com_glojurelang_glojure_pkg_lang.NewChar) _register("github.com/glojurelang/glojure/pkg/lang.NewChunkBuffer", github_com_glojurelang_glojure_pkg_lang.NewChunkBuffer) _register("github.com/glojurelang/glojure/pkg/lang.NewChunkedCons", github_com_glojurelang_glojure_pkg_lang.NewChunkedCons) + _register("github.com/glojurelang/glojure/pkg/lang.NewCompilerError", github_com_glojurelang_glojure_pkg_lang.NewCompilerError) _register("github.com/glojurelang/glojure/pkg/lang.NewCons", github_com_glojurelang_glojure_pkg_lang.NewCons) _register("github.com/glojurelang/glojure/pkg/lang.NewCycle", github_com_glojurelang_glojure_pkg_lang.NewCycle) _register("github.com/glojurelang/glojure/pkg/lang.NewError", github_com_glojurelang_glojure_pkg_lang.NewError) diff --git a/pkg/gen/gljimports/gljimports_js_wasm.go b/pkg/gen/gljimports/gljimports_js_wasm.go index 7df65a69..71eb456c 100644 --- a/pkg/gen/gljimports/gljimports_js_wasm.go +++ b/pkg/gen/gljimports/gljimports_js_wasm.go @@ -3471,6 +3471,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.CloneThreadBindingFrame", github_com_glojurelang_glojure_pkg_lang.CloneThreadBindingFrame) _register("github.com/glojurelang/glojure/pkg/lang.Compare", github_com_glojurelang_glojure_pkg_lang.Compare) _register("github.com/glojurelang/glojure/pkg/lang.Comparer", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Comparer)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.CompilerError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.CompilerError)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.*CompilerError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.CompilerError)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.ConcatStrings", github_com_glojurelang_glojure_pkg_lang.ConcatStrings) _register("github.com/glojurelang/glojure/pkg/lang.Conj", github_com_glojurelang_glojure_pkg_lang.Conj) _register("github.com/glojurelang/glojure/pkg/lang.Conjer", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Conjer)(nil)).Elem()) @@ -3783,6 +3785,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewChar", github_com_glojurelang_glojure_pkg_lang.NewChar) _register("github.com/glojurelang/glojure/pkg/lang.NewChunkBuffer", github_com_glojurelang_glojure_pkg_lang.NewChunkBuffer) _register("github.com/glojurelang/glojure/pkg/lang.NewChunkedCons", github_com_glojurelang_glojure_pkg_lang.NewChunkedCons) + _register("github.com/glojurelang/glojure/pkg/lang.NewCompilerError", github_com_glojurelang_glojure_pkg_lang.NewCompilerError) _register("github.com/glojurelang/glojure/pkg/lang.NewCons", github_com_glojurelang_glojure_pkg_lang.NewCons) _register("github.com/glojurelang/glojure/pkg/lang.NewCycle", github_com_glojurelang_glojure_pkg_lang.NewCycle) _register("github.com/glojurelang/glojure/pkg/lang.NewError", github_com_glojurelang_glojure_pkg_lang.NewError) diff --git a/pkg/gen/gljimports/gljimports_linux_amd64.go b/pkg/gen/gljimports/gljimports_linux_amd64.go index 8a89186d..e6dfabc9 100644 --- a/pkg/gen/gljimports/gljimports_linux_amd64.go +++ b/pkg/gen/gljimports/gljimports_linux_amd64.go @@ -3471,6 +3471,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.CloneThreadBindingFrame", github_com_glojurelang_glojure_pkg_lang.CloneThreadBindingFrame) _register("github.com/glojurelang/glojure/pkg/lang.Compare", github_com_glojurelang_glojure_pkg_lang.Compare) _register("github.com/glojurelang/glojure/pkg/lang.Comparer", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Comparer)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.CompilerError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.CompilerError)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.*CompilerError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.CompilerError)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.ConcatStrings", github_com_glojurelang_glojure_pkg_lang.ConcatStrings) _register("github.com/glojurelang/glojure/pkg/lang.Conj", github_com_glojurelang_glojure_pkg_lang.Conj) _register("github.com/glojurelang/glojure/pkg/lang.Conjer", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Conjer)(nil)).Elem()) @@ -3783,6 +3785,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewChar", github_com_glojurelang_glojure_pkg_lang.NewChar) _register("github.com/glojurelang/glojure/pkg/lang.NewChunkBuffer", github_com_glojurelang_glojure_pkg_lang.NewChunkBuffer) _register("github.com/glojurelang/glojure/pkg/lang.NewChunkedCons", github_com_glojurelang_glojure_pkg_lang.NewChunkedCons) + _register("github.com/glojurelang/glojure/pkg/lang.NewCompilerError", github_com_glojurelang_glojure_pkg_lang.NewCompilerError) _register("github.com/glojurelang/glojure/pkg/lang.NewCons", github_com_glojurelang_glojure_pkg_lang.NewCons) _register("github.com/glojurelang/glojure/pkg/lang.NewCycle", github_com_glojurelang_glojure_pkg_lang.NewCycle) _register("github.com/glojurelang/glojure/pkg/lang.NewError", github_com_glojurelang_glojure_pkg_lang.NewError) diff --git a/pkg/gen/gljimports/gljimports_linux_arm64.go b/pkg/gen/gljimports/gljimports_linux_arm64.go index ac133be0..86dbbd62 100644 --- a/pkg/gen/gljimports/gljimports_linux_arm64.go +++ b/pkg/gen/gljimports/gljimports_linux_arm64.go @@ -3471,6 +3471,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.CloneThreadBindingFrame", github_com_glojurelang_glojure_pkg_lang.CloneThreadBindingFrame) _register("github.com/glojurelang/glojure/pkg/lang.Compare", github_com_glojurelang_glojure_pkg_lang.Compare) _register("github.com/glojurelang/glojure/pkg/lang.Comparer", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Comparer)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.CompilerError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.CompilerError)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.*CompilerError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.CompilerError)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.ConcatStrings", github_com_glojurelang_glojure_pkg_lang.ConcatStrings) _register("github.com/glojurelang/glojure/pkg/lang.Conj", github_com_glojurelang_glojure_pkg_lang.Conj) _register("github.com/glojurelang/glojure/pkg/lang.Conjer", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Conjer)(nil)).Elem()) @@ -3783,6 +3785,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewChar", github_com_glojurelang_glojure_pkg_lang.NewChar) _register("github.com/glojurelang/glojure/pkg/lang.NewChunkBuffer", github_com_glojurelang_glojure_pkg_lang.NewChunkBuffer) _register("github.com/glojurelang/glojure/pkg/lang.NewChunkedCons", github_com_glojurelang_glojure_pkg_lang.NewChunkedCons) + _register("github.com/glojurelang/glojure/pkg/lang.NewCompilerError", github_com_glojurelang_glojure_pkg_lang.NewCompilerError) _register("github.com/glojurelang/glojure/pkg/lang.NewCons", github_com_glojurelang_glojure_pkg_lang.NewCons) _register("github.com/glojurelang/glojure/pkg/lang.NewCycle", github_com_glojurelang_glojure_pkg_lang.NewCycle) _register("github.com/glojurelang/glojure/pkg/lang.NewError", github_com_glojurelang_glojure_pkg_lang.NewError) diff --git a/pkg/gen/gljimports/gljimports_windows_amd64.go b/pkg/gen/gljimports/gljimports_windows_amd64.go index 3fa1ff3b..bbafad44 100644 --- a/pkg/gen/gljimports/gljimports_windows_amd64.go +++ b/pkg/gen/gljimports/gljimports_windows_amd64.go @@ -3471,6 +3471,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.CloneThreadBindingFrame", github_com_glojurelang_glojure_pkg_lang.CloneThreadBindingFrame) _register("github.com/glojurelang/glojure/pkg/lang.Compare", github_com_glojurelang_glojure_pkg_lang.Compare) _register("github.com/glojurelang/glojure/pkg/lang.Comparer", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Comparer)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.CompilerError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.CompilerError)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.*CompilerError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.CompilerError)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.ConcatStrings", github_com_glojurelang_glojure_pkg_lang.ConcatStrings) _register("github.com/glojurelang/glojure/pkg/lang.Conj", github_com_glojurelang_glojure_pkg_lang.Conj) _register("github.com/glojurelang/glojure/pkg/lang.Conjer", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Conjer)(nil)).Elem()) @@ -3783,6 +3785,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewChar", github_com_glojurelang_glojure_pkg_lang.NewChar) _register("github.com/glojurelang/glojure/pkg/lang.NewChunkBuffer", github_com_glojurelang_glojure_pkg_lang.NewChunkBuffer) _register("github.com/glojurelang/glojure/pkg/lang.NewChunkedCons", github_com_glojurelang_glojure_pkg_lang.NewChunkedCons) + _register("github.com/glojurelang/glojure/pkg/lang.NewCompilerError", github_com_glojurelang_glojure_pkg_lang.NewCompilerError) _register("github.com/glojurelang/glojure/pkg/lang.NewCons", github_com_glojurelang_glojure_pkg_lang.NewCons) _register("github.com/glojurelang/glojure/pkg/lang.NewCycle", github_com_glojurelang_glojure_pkg_lang.NewCycle) _register("github.com/glojurelang/glojure/pkg/lang.NewError", github_com_glojurelang_glojure_pkg_lang.NewError) diff --git a/pkg/gen/gljimports/gljimports_windows_arm.go b/pkg/gen/gljimports/gljimports_windows_arm.go index d57eb57e..b524a0e3 100644 --- a/pkg/gen/gljimports/gljimports_windows_arm.go +++ b/pkg/gen/gljimports/gljimports_windows_arm.go @@ -3471,6 +3471,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.CloneThreadBindingFrame", github_com_glojurelang_glojure_pkg_lang.CloneThreadBindingFrame) _register("github.com/glojurelang/glojure/pkg/lang.Compare", github_com_glojurelang_glojure_pkg_lang.Compare) _register("github.com/glojurelang/glojure/pkg/lang.Comparer", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Comparer)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.CompilerError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.CompilerError)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.*CompilerError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.CompilerError)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.ConcatStrings", github_com_glojurelang_glojure_pkg_lang.ConcatStrings) _register("github.com/glojurelang/glojure/pkg/lang.Conj", github_com_glojurelang_glojure_pkg_lang.Conj) _register("github.com/glojurelang/glojure/pkg/lang.Conjer", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Conjer)(nil)).Elem()) @@ -3783,6 +3785,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewChar", github_com_glojurelang_glojure_pkg_lang.NewChar) _register("github.com/glojurelang/glojure/pkg/lang.NewChunkBuffer", github_com_glojurelang_glojure_pkg_lang.NewChunkBuffer) _register("github.com/glojurelang/glojure/pkg/lang.NewChunkedCons", github_com_glojurelang_glojure_pkg_lang.NewChunkedCons) + _register("github.com/glojurelang/glojure/pkg/lang.NewCompilerError", github_com_glojurelang_glojure_pkg_lang.NewCompilerError) _register("github.com/glojurelang/glojure/pkg/lang.NewCons", github_com_glojurelang_glojure_pkg_lang.NewCons) _register("github.com/glojurelang/glojure/pkg/lang.NewCycle", github_com_glojurelang_glojure_pkg_lang.NewCycle) _register("github.com/glojurelang/glojure/pkg/lang.NewError", github_com_glojurelang_glojure_pkg_lang.NewError) diff --git a/pkg/lang/error.go b/pkg/lang/error.go index 62d86aa9..46b17178 100644 --- a/pkg/lang/error.go +++ b/pkg/lang/error.go @@ -25,6 +25,13 @@ type ( msg string } + CompilerError struct { + file string + line int + col int + err error + } + // Stacker is an interface for retrieving stack traces. Stacker interface { Stack() []StackFrame @@ -44,6 +51,8 @@ type ( } ) +//////////////////////////////////////////////////////////////////////////////// + // NewTimeoutError creates a new timeout error. func NewTimeoutError(msg string) error { return &TimeoutError{msg: msg} @@ -59,6 +68,8 @@ func (e *TimeoutError) Is(other error) bool { return ok } +//////////////////////////////////////////////////////////////////////////////// + func NewIndexOutOfBoundsError() error { return &IndexOutOfBoundsError{} } @@ -72,6 +83,8 @@ func (e *IndexOutOfBoundsError) Is(other error) bool { return ok } +//////////////////////////////////////////////////////////////////////////////// + func NewIllegalArgumentError(msg string) error { return &IllegalArgumentError{msg: msg} } @@ -85,6 +98,8 @@ func (e *IllegalArgumentError) Is(other error) bool { return ok } +//////////////////////////////////////////////////////////////////////////////// + func NewArithmeticError(msg string) error { return &ArithmeticError{msg: msg} } @@ -98,6 +113,8 @@ func (e *ArithmeticError) Is(other error) bool { return ok } +//////////////////////////////////////////////////////////////////////////////// + func NewIllegalStateError(msg string) error { return &IllegalStateError{msg: msg} } @@ -111,6 +128,21 @@ func (e *IllegalStateError) Is(other error) bool { return ok } +//////////////////////////////////////////////////////////////////////////////// + +func NewCompilerError(file string, line, col int, err error) error { + return &CompilerError{ + file: file, + line: line, + col: col, + err: err, + } +} + +func (e *CompilerError) Error() string { + return fmt.Sprintf("compiler error at %s:%d:%d: %v", e.file, e.line, e.col, e.err) +} + //////////////////////////////////////////////////////////////////////////////// // TODO: Revisit diff --git a/scripts/rewrite-core/rewrite.clj b/scripts/rewrite-core/rewrite.clj index e210290f..a92d953d 100644 --- a/scripts/rewrite-core/rewrite.clj +++ b/scripts/rewrite-core/rewrite.clj @@ -336,6 +336,9 @@ `(let [result# (strconv.ParseFloat ~s 64)] (if (result# 1) nil (result# 0))))))] + (sexpr-replace 'glojure.lang.Compiler$CompilerException. + 'github.com$glojurelang$glojure$pkg$lang.NewCompilerError) + ;; ===== Metadata Operations ===== ;; replace .withMeta [(fn select [zloc] (and (z/list? zloc) (= '.withMeta (first (z/sexpr zloc))))) From 492af96b84597c0af3d521c54db0196cfd7eff09 Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sat, 23 Aug 2025 12:19:56 -0700 Subject: [PATCH 35/67] Sort package imports in codegen Signed-off-by: James Hamlin --- pkg/codegen/TODO.txt | 22 + pkg/codegen/codegen.go | 12 +- pkg/codegen/testdata/codegen/test/core.go | 448 ++++++------------ pkg/codegen/testdata/codegen/test/fn_recur.go | 4 +- pkg/stdlib/glojure/core.glj | 4 +- pkg/stdlib/glojure/core_print.glj | 27 -- scripts/rewrite-core/rewrite.clj | 4 + 7 files changed, 185 insertions(+), 336 deletions(-) diff --git a/pkg/codegen/TODO.txt b/pkg/codegen/TODO.txt index e47bb77b..b0497ea6 100644 --- a/pkg/codegen/TODO.txt +++ b/pkg/codegen/TODO.txt @@ -3,3 +3,25 @@ - handle namespace requires/uses/etc. - handle let bindings that are shared across multiple vars - test repeated let bindings of the same name, where previous bindings are shadowed + + +Handle +- java.io.StringReader21 "java.io.StringReader" +- Exception12 "Exception" +- java.lang.annotation17 "java.lang.annotation" +- LinkedBlockingQueue28 "LinkedBlockingQueue" +- CompilerException29 "glojure.lang.Compiler/CompilerException" +- BigInteger11 "BigInteger" +- java.lang.UnsupportedOperationException14 "java.lang.UnsupportedOperationException" +- ExceptionInfo15 "ExceptionInfo" +- lang1 "github.com/glojurelang/glojure/pkg/lang" +- java.lang6 "java.lang" +- glojure.lang.LineNumberingPushbackReader19 "glojure.lang.LineNumberingPushbackReader" +- java.util.concurrent.CountDownLatch25 "java.util.concurrent.CountDownLatch" +- BigDecimal9 "BigDecimal" +- java.util.concurrent8 "java.util.concurrent" +- java.io.InputStreamReader20 "java.io.InputStreamReader" +- java.util22 "java.util" +- glojure.lang4 "glojure.lang" +- Object16 "Object" +- java.net30 "java.net" diff --git a/pkg/codegen/codegen.go b/pkg/codegen/codegen.go index 2a2cf811..0890ffff 100644 --- a/pkg/codegen/codegen.go +++ b/pkg/codegen/codegen.go @@ -1288,7 +1288,17 @@ import ( "github.com/glojurelang/glojure/pkg/lang" ` - for pkg, alias := range g.imports { + // sort the imports by their package name for deterministic output + keys := make([]string, 0, len(g.imports)) + for k := range g.imports { + keys = append(keys, k) + } + sort.Slice(keys, func(i, j int) bool { + return g.imports[keys[i]] < g.imports[keys[j]] + }) + + for _, pkg := range keys { + alias := g.imports[pkg] header += fmt.Sprintf(" %s \"%s\"\n", alias, pkg) } diff --git a/pkg/codegen/testdata/codegen/test/core.go b/pkg/codegen/testdata/codegen/test/core.go index 8595e086..ccffdceb 100644 --- a/pkg/codegen/testdata/codegen/test/core.go +++ b/pkg/codegen/testdata/codegen/test/core.go @@ -4,41 +4,37 @@ package generated import ( "github.com/glojurelang/glojure/pkg/lang" - reflect "reflect" - java.io.PrintWriter6 "java.io.PrintWriter" - java.lang10 "java.lang" - java.util26 "java.util" - java.net34 "java.net" + BigDecimal9 "BigDecimal" + BigInteger11 "BigInteger" + CompilerException29 "glojure.lang.Compiler/CompilerException" + Exception12 "Exception" + ExceptionInfo15 "ExceptionInfo" + LinkedBlockingQueue28 "LinkedBlockingQueue" + Object16 "Object" + big10 "math/big" + errors7 "errors" fmt "fmt" - StringBuilder5 "StringBuilder" - java.io.BufferedWriter7 "java.io.BufferedWriter" - time17 "time" - ExceptionInfo19 "ExceptionInfo" + glojure.lang.LineNumberingPushbackReader19 "glojure.lang.LineNumberingPushbackReader" + glojure.lang4 "glojure.lang" + java.io.InputStreamReader20 "java.io.InputStreamReader" + java.io.StringReader21 "java.io.StringReader" + java.lang.UnsupportedOperationException14 "java.lang.UnsupportedOperationException" + java.lang.annotation17 "java.lang.annotation" + java.lang6 "java.lang" + java.net30 "java.net" + java.util.concurrent.CountDownLatch25 "java.util.concurrent.CountDownLatch" + java.util.concurrent8 "java.util.concurrent" + java.util22 "java.util" lang1 "github.com/glojurelang/glojure/pkg/lang" - bytes4 "bytes" - glojure.lang8 "glojure.lang" - runtime9 "github.com/glojurelang/glojure/pkg/runtime" - Object20 "Object" - strconv27 "strconv" - rand30 "math/rand" - LinkedBlockingQueue32 "LinkedBlockingQueue" - regexp31 "regexp" - java.util.concurrent12 "java.util.concurrent" - BigDecimal13 "BigDecimal" - BigInteger15 "BigInteger" - java.lang.annotation21 "java.lang.annotation" - glojure.lang.LineNumberingPushbackReader23 "glojure.lang.LineNumberingPushbackReader" - java.io.StringReader25 "java.io.StringReader" - CompilerException33 "glojure.lang.Compiler/CompilerException" - errors11 "errors" math3 "math" - big14 "math/big" - Exception16 "Exception" - java.lang.UnsupportedOperationException18 "java.lang.UnsupportedOperationException" - strings22 "strings" - java.io.InputStreamReader24 "java.io.InputStreamReader" - runtime28 "runtime" - java.util.concurrent.CountDownLatch29 "java.util.concurrent.CountDownLatch" + rand26 "math/rand" + reflect "reflect" + regexp27 "regexp" + runtime24 "runtime" + runtime5 "github.com/glojurelang/glojure/pkg/runtime" + strconv23 "strconv" + strings18 "strings" + time13 "time" ) func init() { // Closed-over values @@ -4991,162 +4987,6 @@ if v0.Meta() != nil { v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// PrintWriter-on -{ -v1 := reflect.TypeOf((*bytes4.Buffer)(nil)) -v0 := lang.NewSymbol("PrintWriter-on").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("flush-fn"), lang.NewSymbol("close-fn")), lang.NewVector(lang.NewSymbol("flush-fn"), lang.NewSymbol("close-fn"), lang.NewSymbol("autoflush?"))), lang.NewKeyword("doc"), "implements java.io.PrintWriter given flush-fn, which will be called\n when .flush() is called, with a string built up since the last call to .flush().\n if not nil, close-fn will be called with no arguments when .close is called.\n autoflush? determines if the PrintWriter will autoflush, false by default.", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(73), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(522), lang.NewKeyword("end-line"), int(522))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v4 := args[0] -v5 := args[1] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("PrintWriter-on")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v4, v5, false}) -return v9 - case 3: -v4 := args[0] -v5 := args[1] -v6 := args[2] -v8 := lang.Apply(StringBuilder5., nil) -var v7 any = v8 -_ = v7 -v10 := lang.NewVector(nil) -v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(532), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(532), lang.NewKeyword("end-column"), int(23)) -v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v13 := lang.NewVector() -v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(532), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(532), lang.NewKeyword("end-column"), int(26)) -v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("flush")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.NewVector() -v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(533), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(533), lang.NewKeyword("end-column"), int(19)) -v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v22 any -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("pos?")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26, ok := lang.FieldOrMethod(v7, "length") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "length"))) -} -var v27 any -switch reflect.TypeOf(v26).Kind() { -case reflect.Func: - v27 = lang.Apply(v26, nil) -default: - v27 = v26 -} -v28 := lang.Apply(v25, []any{v27}) -if lang.IsTruthy(v28) { -v29 := lang.Apply(lang1.ToString, []any{v7}) -v30 := lang.Apply(v4, []any{v29}) -v22 = v30 -} else { -v22 = nil -} -v31, _ := lang.FieldOrMethod(v7, "setLength") -if reflect.TypeOf(v31).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setLength is not a function"))) -} -v32 := lang.Apply(v31, []any{int64(0)}) -v33 := lang.Apply(v18, []any{v21, v22, v32}) -v34 := lang.NewVector() -v35 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(537), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(537), lang.NewKeyword("end-column"), int(19)) -v36, err := lang.WithMeta(v34, v35.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v37, ok := lang.FieldOrMethod(nil, "flush") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "flush"))) -} -var v38 any -switch reflect.TypeOf(v37).Kind() { -case reflect.Func: - v38 = lang.Apply(v37, nil) -default: - v38 = v37 -} -var v39 any -if lang.IsTruthy(v5) { -v40 := lang.Apply(v5, nil) -v39 = v40 -} else { -v39 = nil -} -v41 := lang.Apply(nil, []any{v36, v38, v39, nil}) -v42 := lang.NewVector(nil, nil, nil) -v43 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(541), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(541), lang.NewKeyword("end-column"), int(35)) -v44, err := lang.WithMeta(v42, v43.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v45 any -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("pos?")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) -} -v48 := v47.Get() -v49 := lang.Apply(v48, []any{nil}) -if lang.IsTruthy(v49) { -var v50 any -v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v52 := v51.FindInternedVar(lang.NewSymbol("instance?")) -if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) -} -v53 := v52.Get() -v54 := lang.Apply(v53, []any{lang.Builtins["string"], nil}) -if lang.IsTruthy(v54) { -v55 := lang.Apply(lang1.AppendWriter, []any{v7, nil, nil, nil}) -v50 = v55 -} else { -v56 := lang.Apply(lang1.AppendWriter, []any{v7, nil, nil, nil}) -v50 = v56 -} -v45 = v50 -} else { -v45 = nil -} -v57 := lang.Apply(nil, []any{v44, v45}) -v58 := lang.Apply(nil, []any{v12, v15, v33, v41, v57}) -v59 := lang.Apply(java.io.BufferedWriter7., []any{v58}) -v60 := lang.Apply(java.io.PrintWriter6., []any{v59, v6}) -return v60 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v4 := reflect.TypeOf((*bytes4.Buffer)(nil)) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} // StackTraceElement->vec { v0 := lang.NewSymbol("StackTraceElement->vec").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"))), lang.NewKeyword("doc"), "Constructs a data representation for a StackTraceElement: [class method file line]", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(436), lang.NewKeyword("end-line"), int(436))).(*lang.Symbol) @@ -5663,7 +5503,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { } v3 := args[0] v4 := args[1] -v5, _ := lang.FieldOrMethod(glojure.lang8.PersistentStructMap, "getAccessor") +v5, _ := lang.FieldOrMethod(glojure.lang4.PersistentStructMap, "getAccessor") if reflect.TypeOf(v5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("getAccessor is not a function"))) } @@ -5760,7 +5600,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5, _ := lang.FieldOrMethod(runtime9.RT, "Aclone") +v5, _ := lang.FieldOrMethod(runtime5.RT, "Aclone") if reflect.TypeOf(v5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Aclone is not a function"))) } @@ -6009,7 +5849,7 @@ if v24.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } v25 := v24.Get() -v26 := lang.Apply(v25, []any{java.lang10.Enum, v16}) +v26 := lang.Apply(v25, []any{java.lang6.Enum, v16}) if lang.IsTruthy(v26) { v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v28 := v27.FindInternedVar(lang.NewSymbol("descriptor")) @@ -7197,7 +7037,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5, _ := lang.FieldOrMethod(runtime9.RT, "Alength") +v5, _ := lang.FieldOrMethod(runtime5.RT, "Alength") if reflect.TypeOf(v5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Alength is not a function"))) } @@ -8652,9 +8492,9 @@ var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: -v3, ok := lang.FieldOrMethod(glojure.lang8.PersistentArrayMap, "EMPTY") +v3, ok := lang.FieldOrMethod(glojure.lang4.PersistentArrayMap, "EMPTY") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", glojure.lang8.PersistentArrayMap, "EMPTY"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", glojure.lang4.PersistentArrayMap, "EMPTY"))) } var v4 any switch reflect.TypeOf(v3).Kind() { @@ -10731,7 +10571,7 @@ if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -v7 := lang.Apply(v6, []any{glojure.lang8.Associative, v3}) +v7 := lang.Apply(v6, []any{glojure.lang4.Associative, v3}) return v7 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -10803,7 +10643,7 @@ if v8.IsMacro() { } v9 := v8.Get() if lang.IsTruthy(v9) { -v10 := lang.Apply(errors11.New, []any{"Can't await in agent action"}) +v10 := lang.Apply(errors7.New, []any{"Can't await in agent action"}) panic(v10) } else { v6 = nil @@ -11044,7 +10884,7 @@ if v9.IsMacro() { } v10 := v9.Get() if lang.IsTruthy(v10) { -v11 := lang.Apply(errors11.New, []any{"Can't await in agent action"}) +v11 := lang.Apply(errors7.New, []any{"Can't await in agent action"}) panic(v11) } else { v7 = nil @@ -11244,9 +11084,9 @@ v26 = v27 break } _ = v26 -v18, ok := lang.FieldOrMethod(java.util.concurrent12.TimeUnit, "MILLISECONDS") +v18, ok := lang.FieldOrMethod(java.util.concurrent8.TimeUnit, "MILLISECONDS") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", java.util.concurrent12.TimeUnit, "MILLISECONDS"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", java.util.concurrent8.TimeUnit, "MILLISECONDS"))) } var v19 any switch reflect.TypeOf(v18).Kind() { @@ -11433,7 +11273,7 @@ case reflect.Func: default: v29 = v28 } -v30 := lang.Apply(BigDecimal13., []any{v29}) +v30 := lang.Apply(BigDecimal9., []any{v29}) v31, ok := lang.FieldOrMethod(v4, "denominator") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "denominator"))) @@ -11477,9 +11317,9 @@ if v43.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) } v44 := v43.Get() -v45 := lang.Apply(v44, []any{big14.*Int, v4}) +v45 := lang.Apply(v44, []any{big10.*Int, v4}) if lang.IsTruthy(v45) { -v46 := lang.Apply(BigDecimal13., []any{v4}) +v46 := lang.Apply(BigDecimal9., []any{v4}) v41 = v46 } else { var v47 any @@ -11503,7 +11343,7 @@ v47 = v56 } else { var v57 any if lang.IsTruthy(lang.NewKeyword("else")) { -v58 := lang.Apply(BigDecimal13., []any{v4}) +v58 := lang.Apply(BigDecimal9., []any{v4}) v57 = v58 } else { v57 = nil @@ -11557,7 +11397,7 @@ if v12.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } v13 := v12.Get() -v14 := lang.Apply(v13, []any{big14.*Int, v4}) +v14 := lang.Apply(v13, []any{big10.*Int, v4}) if lang.IsTruthy(v14) { v15 := lang.Apply(lang1.NewBigIntFromGoBigInt, []any{v4}) v10 = v15 @@ -11673,7 +11513,7 @@ if v64.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) } v65 := v64.Get() -v66 := lang.Apply(BigInteger15., []any{v4}) +v66 := lang.Apply(BigInteger11., []any{v4}) v67 := lang.Apply(v65, []any{v66}) v62 = v67 } else { @@ -11702,7 +11542,7 @@ if v0.Meta() != nil { } // biginteger { -v1 := reflect.TypeOf((*big14.Int)(nil)) +v1 := reflect.TypeOf((*big10.Int)(nil)) v0 := lang.NewSymbol("biginteger").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Coerce to BigInteger", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3634), lang.NewKeyword("end-line"), int(3634))).(*lang.Symbol) var v3 lang.FnFunc v3 = lang.NewFnFunc(func(args ...any) any { @@ -11717,7 +11557,7 @@ if v7.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } v8 := v7.Get() -v9 := lang.Apply(v8, []any{big14.*Int, v4}) +v9 := lang.Apply(v8, []any{big10.*Int, v4}) if lang.IsTruthy(v9) { v5 = v4 } else { @@ -11833,12 +11673,12 @@ if v49.IsMacro() { } v50 := v49.Get() v51 := lang.Apply(v50, []any{v4}) -v52 := lang.Apply(big14.NewInt, []any{v51}) +v52 := lang.Apply(big10.NewInt, []any{v51}) v43 = v52 } else { var v53 any if lang.IsTruthy(lang.NewKeyword("else")) { -v54 := lang.Apply(BigInteger15., []any{v4}) +v54 := lang.Apply(BigInteger11., []any{v4}) v53 = v54 } else { v53 = nil @@ -11857,7 +11697,7 @@ v5 = v10 } return v5 }) -v4 := reflect.TypeOf((*big14.Int)(nil)) +v4 := reflect.TypeOf((*big10.Int)(nil)) v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { @@ -14548,7 +14388,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5, _ := lang.FieldOrMethod(runtime9.RT, "BooleanCast") +v5, _ := lang.FieldOrMethod(runtime5.RT, "BooleanCast") if reflect.TypeOf(v5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("BooleanCast is not a function"))) } @@ -16868,7 +16708,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5, _ := lang.FieldOrMethod(runtime9.RT, "CharCast") +v5, _ := lang.FieldOrMethod(runtime5.RT, "CharCast") if reflect.TypeOf(v5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("CharCast is not a function"))) } @@ -19885,7 +19725,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { } v3 := args[0] v4 := args[1] -v5, _ := lang.FieldOrMethod(runtime9.RT, "Contains") +v5, _ := lang.FieldOrMethod(runtime5.RT, "Contains") if reflect.TypeOf(v5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Contains is not a function"))) } @@ -22324,7 +22164,7 @@ v108 := v107.Get() v109 := lang.Apply(v108, []any{v71}) v110 := lang.Apply(v105, []any{v109, int64(1)}) if lang.IsTruthy(v110) { -v111 := lang.Apply(Exception16., []any{"The syntax for defmulti has changed. Example: (defmulti name dispatch-fn :default dispatch-value)"}) +v111 := lang.Apply(Exception12., []any{"The syntax for defmulti has changed. Example: (defmulti name dispatch-fn :default dispatch-value)"}) panic(v111) } else { v102 = nil @@ -24462,7 +24302,7 @@ if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -v7 := lang.Apply(v6, []any{glojure.lang8.Delay, v3}) +v7 := lang.Apply(v6, []any{glojure.lang4.Delay, v3}) return v7 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -24492,7 +24332,7 @@ if v0.Meta() != nil { } // denominator { -v1 := reflect.TypeOf((*big14.Int)(nil)) +v1 := reflect.TypeOf((*big10.Int)(nil)) v0 := lang.NewSymbol("denominator").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("r"))), lang.NewKeyword("doc"), "Returns the denominator part of a Ratio.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3591), lang.NewKeyword("end-line"), int(3591))).(*lang.Symbol) var v3 lang.FnFunc v3 = lang.NewFnFunc(func(args ...any) any { @@ -24513,7 +24353,7 @@ default: } return v6 }) -v4 := reflect.TypeOf((*big14.Int)(nil)) +v4 := reflect.TypeOf((*big10.Int)(nil)) v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { @@ -24807,7 +24647,7 @@ v7, _ := lang.FieldOrMethod(v3, "Get") if reflect.TypeOf(v7).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Get is not a function"))) } -v8 := lang.Apply(v7, []any{v4, time17.Millisecond}) +v8 := lang.Apply(v7, []any{v4, time13.Millisecond}) v6 = v8 }() return v6 @@ -24982,7 +24822,7 @@ if v31.IsMacro() { } v32 := v31.Get() v33 := lang.Apply(v32, []any{v4, "already has", v5, "as ancestor"}) -v34 := lang.Apply(Exception16., []any{v33}) +v34 := lang.Apply(Exception12., []any{v33}) panic(v34) } else { v24 = nil @@ -25005,7 +24845,7 @@ if v42.IsMacro() { } v43 := v42.Get() v44 := lang.Apply(v43, []any{"Cyclic derivation:", v5, "has", v4, "as ancestor"}) -v45 := lang.Apply(Exception16., []any{v44}) +v45 := lang.Apply(Exception12., []any{v44}) panic(v45) } else { v35 = nil @@ -25104,7 +24944,7 @@ if v7.IsMacro() { v8 := v7.Get() v9 := lang.Apply(v8, []any{v4}) if lang.IsTruthy(v9) { -v10 := lang.Apply(java.lang.UnsupportedOperationException18., []any{"Can't get descendants of classes"}) +v10 := lang.Apply(java.lang.UnsupportedOperationException14., []any{"Can't get descendants of classes"}) panic(v10) } else { v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) @@ -25344,7 +25184,7 @@ var v88 any if lang.IsTruthy(lang.NewKeyword("else")) { var v89 any if lang.IsTruthy(v47) { -v90 := lang.Apply(errors11.New, []any{"Unsupported binding form, only :as can follow & parameter"}) +v90 := lang.Apply(errors7.New, []any{"Unsupported binding form, only :as can follow & parameter"}) panic(v90) } else { var v92 any @@ -26406,7 +26246,7 @@ if v51.IsMacro() { } v52 := v51.Get() v53 := lang.Apply(v52, []any{"Unsupported binding form: ", v13}) -v54 := lang.Apply(errors11.New, []any{v53}) +v54 := lang.Apply(errors7.New, []any{v53}) panic(v54) } else { v49 = nil @@ -26675,7 +26515,7 @@ return v3 case 2: v3 := args[0] v4 := args[1] -v5, _ := lang.FieldOrMethod(runtime9.RT, "Dissoc") +v5, _ := lang.FieldOrMethod(runtime5.RT, "Dissoc") if reflect.TypeOf(v5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Dissoc is not a function"))) } @@ -31286,7 +31126,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4, _ := lang.FieldOrMethod(runtime9.Compiler, "Eval") +v4, _ := lang.FieldOrMethod(runtime5.Compiler, "Eval") if reflect.TypeOf(v4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Eval is not a function"))) } @@ -32285,7 +32125,7 @@ if v6.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } v7 := v6.Get() -v8 := lang.Apply(ExceptionInfo19., []any{v3, v4}) +v8 := lang.Apply(ExceptionInfo15., []any{v3, v4}) v9 := lang.Apply(v7, []any{v8, "glojure.core$ex_info"}) return v9 case 3: @@ -32298,7 +32138,7 @@ if v7.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } v8 := v7.Get() -v9 := lang.Apply(ExceptionInfo19., []any{v3, v4, v5}) +v9 := lang.Apply(ExceptionInfo15., []any{v3, v4, v5}) v10 := lang.Apply(v8, []any{v9, "glojure.core$ex_info"}) return v10 default: @@ -32440,7 +32280,7 @@ if v43.IsMacro() { } v44 := v43.Get() v45 := lang.Apply(v44, []any{v26, " is not a protocol"}) -v46 := lang.Apply(errors11.New, []any{v45}) +v46 := lang.Apply(errors7.New, []any{v45}) panic(v46) } _ = v37 @@ -32668,7 +32508,7 @@ if v59.IsMacro() { } v60 := v59.Get() v61 := lang.Apply(v60, []any{v42, " is not a protocol"}) -v62 := lang.Apply(errors11.New, []any{v61}) +v62 := lang.Apply(errors7.New, []any{v61}) panic(v62) } _ = v53 @@ -33445,7 +33285,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { } v3 := args[0] v4 := args[1] -v5, _ := lang.FieldOrMethod(runtime9.RT, "Find") +v5, _ := lang.FieldOrMethod(runtime5.RT, "Find") if reflect.TypeOf(v5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Find is not a function"))) } @@ -33552,7 +33392,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4, _ := lang.FieldOrMethod(runtime9.RT, "FindVar") +v4, _ := lang.FieldOrMethod(runtime5.RT, "FindVar") if reflect.TypeOf(v4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("FindVar is not a function"))) } @@ -34788,7 +34628,7 @@ if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -v7 := lang.Apply(v6, []any{runtime9.*Fn, v3}) +v7 := lang.Apply(v6, []any{runtime5.*Fn, v3}) return v7 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -38395,7 +38235,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4, _ := lang.FieldOrMethod(glojure.lang8.Delay, "force") +v4, _ := lang.FieldOrMethod(glojure.lang4.Delay, "force") if reflect.TypeOf(v4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("force is not a function"))) } @@ -38742,7 +38582,7 @@ if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -v7 := lang.Apply(v6, []any{java.util.concurrent12.Future, v3}) +v7 := lang.Apply(v6, []any{java.util.concurrent8.Future, v3}) return v7 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -38788,7 +38628,7 @@ if v8.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } v9 := v8.Get() -v10, _ := lang.FieldOrMethod(runtime9.RT, "NextID") +v10, _ := lang.FieldOrMethod(runtime5.RT, "NextID") if reflect.TypeOf(v10).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("NextID is not a function"))) } @@ -38948,7 +38788,7 @@ return v11 v3 := args[0] v4 := args[1] v5 := args[2] -v7 := lang.Apply(Object20., nil) +v7 := lang.Apply(Object16., nil) var v6 any = v7 _ = v6 var v8 any = v8 @@ -40562,7 +40402,7 @@ if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -v7 := lang.Apply(v6, []any{glojure.lang8.IFn, v3}) +v7 := lang.Apply(v6, []any{glojure.lang4.IFn, v3}) return v7 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -41040,7 +40880,7 @@ if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -v7 := lang.Apply(v6, []any{glojure.lang8.Indexed, v3}) +v7 := lang.Apply(v6, []any{glojure.lang4.Indexed, v3}) return v7 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -41261,7 +41101,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5, _ := lang.FieldOrMethod(runtime9.RT, "IntCast") +v5, _ := lang.FieldOrMethod(runtime5.RT, "IntCast") if reflect.TypeOf(v5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("IntCast is not a function"))) } @@ -42548,7 +42388,7 @@ var v4 any = v8 _ = v4 var v10 any if lang.IsTruthy(v4) { -v11, _ := lang.FieldOrMethod(java.lang.annotation21.Annotation, "isAssignableFrom") +v11, _ := lang.FieldOrMethod(java.lang.annotation17.Annotation, "isAssignableFrom") if reflect.TypeOf(v11).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("isAssignableFrom is not a function"))) } @@ -42595,7 +42435,7 @@ v15, _ := lang.FieldOrMethod(v3, "getAnnotation") if reflect.TypeOf(v15).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("getAnnotation is not a function"))) } -v16 := lang.Apply(v15, []any{java.lang.annotation21.Retention}) +v16 := lang.Apply(v15, []any{java.lang.annotation17.Retention}) var v14 any = v16 _ = v14 var v18 any @@ -43227,7 +43067,7 @@ v82 = v83 break } v79 := lang.Apply(v75, []any{v78, v82}) -v80 := lang.Apply(nil, []any{glojure.lang8.Seqable, v72, lang1.IReduceInit, v79}) +v80 := lang.Apply(nil, []any{glojure.lang4.Seqable, v72, lang1.IReduceInit, v79}) return v80 } }) @@ -45359,7 +45199,7 @@ v20 := lang.Apply(v19, []any{v11}) var v18 any = v20 _ = v18 var v23 any -v24 := lang.Apply(strings22.HasPrefix, []any{v22, "/"}) +v24 := lang.Apply(strings18.HasPrefix, []any{v22, "/"}) if lang.IsTruthy(v24) { v23 = v22 } else { @@ -45494,8 +45334,8 @@ if v88.IsMacro() { v89 := v88.Get() v90 := lang.Apply(v89, nil) }() -v91 := lang.Apply(strings22.TrimPrefix, []any{v22, "/"}) -v92, _ := lang.FieldOrMethod(runtime9.RT, "Load") +v91 := lang.Apply(strings18.TrimPrefix, []any{v22, "/"}) +v92, _ := lang.FieldOrMethod(runtime5.RT, "Load") if reflect.TypeOf(v92).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Load is not a function"))) } @@ -45601,7 +45441,7 @@ v36 := lang.Apply(v35, []any{v25}) var v32 any = v36 _ = v32 var v39 any -v40 := lang.Apply(strings22.HasPrefix, []any{v38, "/"}) +v40 := lang.Apply(strings18.HasPrefix, []any{v38, "/"}) if lang.IsTruthy(v40) { v39 = v38 } else { @@ -45736,8 +45576,8 @@ if v104.IsMacro() { v105 := v104.Get() v106 := lang.Apply(v105, nil) }() -v107 := lang.Apply(strings22.TrimPrefix, []any{v38, "/"}) -v108, _ := lang.FieldOrMethod(runtime9.RT, "Load") +v107 := lang.Apply(strings18.TrimPrefix, []any{v38, "/"}) +v108, _ := lang.FieldOrMethod(runtime5.RT, "Load") if reflect.TypeOf(v108).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Load is not a function"))) } @@ -45938,8 +45778,8 @@ case reflect.Func: default: v7 = v6 } -v8 := lang.Apply(java.io.InputStreamReader24., []any{v7, "UTF-8"}) -v9 := lang.Apply(glojure.lang.LineNumberingPushbackReader23., []any{v8}) +v8 := lang.Apply(java.io.InputStreamReader20., []any{v7, "UTF-8"}) +v9 := lang.Apply(glojure.lang.LineNumberingPushbackReader19., []any{v8}) var v5 any = v9 _ = v5 var v11 any @@ -46342,7 +46182,7 @@ if v20.IsMacro() { } v21 := v20.Get() v22 := lang.Apply(v21, []any{lang.NewChar(46)}) -v23 := lang.Apply(strings22.Index, []any{v18, v22}) +v23 := lang.Apply(strings18.Index, []any{v18, v22}) v24 := lang.Apply(v14, []any{v23}) v11 = v24 } else { @@ -48146,7 +47986,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4, _ := lang.FieldOrMethod(runtime9.Compiler, "load") +v4, _ := lang.FieldOrMethod(runtime5.Compiler, "load") if reflect.TypeOf(v4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("load is not a function"))) } @@ -48168,8 +48008,8 @@ v2 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v5 := lang.Apply(java.io.StringReader25., []any{v3}) -v6 := lang.Apply(glojure.lang.LineNumberingPushbackReader23., []any{v5}) +v5 := lang.Apply(java.io.StringReader21., []any{v3}) +v6 := lang.Apply(glojure.lang.LineNumberingPushbackReader19., []any{v5}) var v4 any = v6 _ = v4 v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) @@ -49338,7 +49178,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4, _ := lang.FieldOrMethod(runtime9.Compiler, "macroexpand1") +v4, _ := lang.FieldOrMethod(runtime5.Compiler, "macroexpand1") if reflect.TypeOf(v4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("macroexpand1 is not a function"))) } @@ -50143,7 +49983,7 @@ if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -v7 := lang.Apply(v6, []any{java.util26.Map$Entry, v3}) +v7 := lang.Apply(v6, []any{java.util22.Map$Entry, v3}) return v7 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -56252,7 +56092,7 @@ if v12.IsMacro() { } v13 := v12.Get() v14 := lang.Apply(v13, []any{v3}) -v15, _ := lang.FieldOrMethod(runtime9.Compiler, "maybeResolveIn") +v15, _ := lang.FieldOrMethod(runtime5.Compiler, "maybeResolveIn") if reflect.TypeOf(v15).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("maybeResolveIn is not a function"))) } @@ -56517,7 +56357,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { case 2: v4 := args[0] v5 := args[1] -v6, _ := lang.FieldOrMethod(runtime9.RT, "Nth") +v6, _ := lang.FieldOrMethod(runtime5.RT, "Nth") if reflect.TypeOf(v6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Nth is not a function"))) } @@ -56527,7 +56367,7 @@ return v7 v4 := args[0] v5 := args[1] v6 := args[2] -v7, _ := lang.FieldOrMethod(runtime9.RT, "NthDefault") +v7, _ := lang.FieldOrMethod(runtime5.RT, "NthDefault") if reflect.TypeOf(v7).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("NthDefault is not a function"))) } @@ -56922,7 +56762,7 @@ if v0.Meta() != nil { } // numerator { -v1 := reflect.TypeOf((*big14.Int)(nil)) +v1 := reflect.TypeOf((*big10.Int)(nil)) v0 := lang.NewSymbol("numerator").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("r"))), lang.NewKeyword("doc"), "Returns the numerator part of a Ratio.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3583), lang.NewKeyword("end-line"), int(3583))).(*lang.Symbol) var v3 lang.FnFunc v3 = lang.NewFnFunc(func(args ...any) any { @@ -56943,7 +56783,7 @@ default: } return v6 }) -v4 := reflect.TypeOf((*big14.Int)(nil)) +v4 := reflect.TypeOf((*big10.Int)(nil)) v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { @@ -57013,7 +56853,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5, _ := lang.FieldOrMethod(runtime9.RT, "Object_array") +v5, _ := lang.FieldOrMethod(runtime5.RT, "Object_array") if reflect.TypeOf(v5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Object_array is not a function"))) } @@ -57373,7 +57213,7 @@ if v6.IsMacro() { v7 := v6.Get() v8 := lang.Apply(v7, []any{v3}) if lang.IsTruthy(v8) { -v10 := lang.Apply(strconv27.ParseFloat, []any{v3, int64(64)}) +v10 := lang.Apply(strconv23.ParseFloat, []any{v3, int64(64)}) var v9 any = v10 _ = v9 var v12 any @@ -57525,7 +57365,7 @@ if v6.IsMacro() { v7 := v6.Get() v8 := lang.Apply(v7, []any{v3}) if lang.IsTruthy(v8) { -v10 := lang.Apply(strconv27.ParseInt, []any{v3, int64(10), int64(64)}) +v10 := lang.Apply(strconv23.ParseInt, []any{v3, int64(10), int64(64)}) var v9 any = v10 _ = v9 var v12 any @@ -59098,7 +58938,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4, _ := lang.FieldOrMethod(runtime9.RT, "Peek") +v4, _ := lang.FieldOrMethod(runtime5.RT, "Peek") if reflect.TypeOf(v4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Peek is not a function"))) } @@ -59154,7 +58994,7 @@ if v7.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } v8 := v7.Get() -v9 := lang.Apply(runtime28.NumCPU, nil) +v9 := lang.Apply(runtime24.NumCPU, nil) v10 := lang.Apply(v8, []any{int64(2), v9}) var v5 any = v10 _ = v5 @@ -59474,7 +59314,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4, _ := lang.FieldOrMethod(runtime9.RT, "Pop") +v4, _ := lang.FieldOrMethod(runtime5.RT, "Pop") if reflect.TypeOf(v4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Pop is not a function"))) } @@ -62843,7 +62683,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v4 := lang.Apply(java.util.concurrent.CountDownLatch29., []any{int64(1)}) +v4 := lang.Apply(java.util.concurrent.CountDownLatch25., []any{int64(1)}) var v3 any = v4 _ = v3 v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) @@ -62903,7 +62743,7 @@ v31, _ := lang.FieldOrMethod(v3, "await") if reflect.TypeOf(v31).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) } -v32 := lang.Apply(v31, []any{nil, time17.Millisecond}) +v32 := lang.Apply(v31, []any{nil, time13.Millisecond}) if lang.IsTruthy(v32) { v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v34 := v33.FindInternedVar(lang.NewSymbol("deref")) @@ -63000,7 +62840,7 @@ v51 = nil v51 = nil } v54 := lang.Apply(nil, []any{v50, v51}) -v55 := lang.Apply(nil, []any{lang1.IDeref, v23, lang1.IBlockingDeref, v37, lang1.IPending, v47, glojure.lang8.IFn, v54}) +v55 := lang.Apply(nil, []any{lang1.IDeref, v23, lang1.IBlockingDeref, v37, lang1.IPending, v47, glojure.lang4.IFn, v54}) return v55 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -63423,7 +63263,7 @@ var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: -v3 := lang.Apply(rand30.Float64, nil) +v3 := lang.Apply(rand26.Float64, nil) return v3 case 1: v3 := args[0] @@ -64080,7 +63920,7 @@ if v0.Meta() != nil { } // re-pattern { -v1 := reflect.TypeOf((*regexp31.Regexp)(nil)) +v1 := reflect.TypeOf((*regexp27.Regexp)(nil)) v0 := lang.NewSymbol("re-pattern").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns an instance of java.util.regex.Pattern, for use, e.g. in\n re-matcher.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4863), lang.NewKeyword("end-line"), int(4863))).(*lang.Symbol) var v3 lang.FnFunc v3 = lang.NewFnFunc(func(args ...any) any { @@ -64095,16 +63935,16 @@ if v7.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } v8 := v7.Get() -v9 := lang.Apply(v8, []any{regexp31.*Regexp, v4}) +v9 := lang.Apply(v8, []any{regexp27.*Regexp, v4}) if lang.IsTruthy(v9) { v5 = v4 } else { -v10 := lang.Apply(regexp31.MustCompile, []any{v4}) +v10 := lang.Apply(regexp27.MustCompile, []any{v4}) v5 = v10 } return v5 }) -v4 := reflect.TypeOf((*regexp31.Regexp)(nil)) +v4 := reflect.TypeOf((*regexp27.Regexp)(nil)) v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { @@ -64244,7 +64084,7 @@ if v8.IsMacro() { } v9 := v8.Get() v10 := lang.Apply(v9, []any{v4}) -v11, _ := lang.FieldOrMethod(glojure.lang8.LispReader, "read") +v11, _ := lang.FieldOrMethod(glojure.lang4.LispReader, "read") if reflect.TypeOf(v11).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("read is not a function"))) } @@ -64253,7 +64093,7 @@ return v12 case 2: v3 := args[0] v4 := args[1] -v5, _ := lang.FieldOrMethod(glojure.lang8.LispReader, "read") +v5, _ := lang.FieldOrMethod(glojure.lang4.LispReader, "read") if reflect.TypeOf(v5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("read is not a function"))) } @@ -64509,7 +64349,7 @@ if v8.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } v9 := v8.Get() -v10 := lang.Apply(v6, []any{glojure.lang8.LineNumberingPushbackReader, v9}) +v10 := lang.Apply(v6, []any{glojure.lang4.LineNumberingPushbackReader, v9}) if lang.IsTruthy(v10) { v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v12 := v11.FindInternedVar(lang.NewSymbol("*in*")) @@ -64565,12 +64405,12 @@ v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] -v4 := lang.Apply(runtime9.RTReadString, []any{v3}) +v4 := lang.Apply(runtime5.RTReadString, []any{v3}) return v4 case 2: v3 := args[0] v4 := args[1] -v5 := lang.Apply(runtime9.RTReadString, []any{v4, v3}) +v5 := lang.Apply(runtime5.RTReadString, []any{v4, v3}) return v5 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -64616,7 +64456,7 @@ if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -v7 := lang.Apply(v6, []any{glojure.lang8.ReaderConditional, v3}) +v7 := lang.Apply(v6, []any{glojure.lang4.ReaderConditional, v3}) return v7 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -65372,7 +65212,7 @@ if v14.IsMacro() { } v15 := v14.Get() v16 := lang.Apply(v15, []any{"No namespace: ", v3}) -v17 := lang.Apply(errors11.New, []any{v16}) +v17 := lang.Apply(errors7.New, []any{v16}) panic(v17) } var v5 any = v12 @@ -65500,7 +65340,7 @@ v41 = v49 v41 = v39 } if lang.IsTruthy(v41) { -v39 := lang.Apply(errors11.New, []any{":only/:refer value must be a sequential collection of symbols"}) +v39 := lang.Apply(errors7.New, []any{":only/:refer value must be a sequential collection of symbols"}) panic(v39) } else { v38 = nil @@ -66872,7 +66712,7 @@ var v50 any if lang.IsTruthy(v41) { v50 = v41 } else { -v51 := lang.Apply(Exception16., []any{"ResultSet must have unique column labels"}) +v51 := lang.Apply(Exception12., []any{"ResultSet must have unique column labels"}) panic(v51) } var v40 any = v50 @@ -67044,7 +66884,7 @@ if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -v7 := lang.Apply(v6, []any{glojure.lang8.Reversible, v3}) +v7 := lang.Apply(v6, []any{glojure.lang4.Reversible, v3}) return v7 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -67077,7 +66917,7 @@ if v11.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } v12 := v11.Get() -v13 := lang.Apply(strings22.LastIndex, []any{v4, "/"}) +v13 := lang.Apply(strings18.LastIndex, []any{v4, "/"}) v14 := lang.Apply(v12, []any{v4, int64(0), v13}) return v14 }) @@ -67110,8 +66950,8 @@ if v9.IsMacro() { } v10 := v9.Get() v11 := lang.Apply(v10, []any{v4}) -v12 := lang.Apply(strings22.ReplaceAll, []any{v11, "-", "_"}) -v13 := lang.Apply(strings22.ReplaceAll, []any{v12, ".", "/"}) +v12 := lang.Apply(strings18.ReplaceAll, []any{v11, "-", "_"}) +v13 := lang.Apply(strings18.ReplaceAll, []any{v12, ".", "/"}) v14 := lang.Apply(v7, []any{lang.NewChar(47), v13}) return v14 }) @@ -67433,7 +67273,7 @@ if v18.IsMacro() { } v19 := v18.Get() v20 := lang.Apply(v19, []any{v9}) -v21, _ := lang.FieldOrMethod(runtime9.RT, "Find") +v21, _ := lang.FieldOrMethod(runtime5.RT, "Find") if reflect.TypeOf(v21).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Find is not a function"))) } @@ -67791,12 +67631,12 @@ if v12.IsMacro() { } v13 := v12.Get() v14 := lang.Apply(v13, []any{v3}) -v15 := lang.Apply(LinkedBlockingQueue32., []any{v14}) +v15 := lang.Apply(LinkedBlockingQueue28., []any{v14}) v6 = v15 } var v5 any = v6 _ = v5 -v17 := lang.Apply(Object20., nil) +v17 := lang.Apply(Object16., nil) var v16 any = v17 _ = v16 v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) @@ -69199,7 +69039,7 @@ case reflect.Func: default: v30 = v29 } -v31 := lang.Apply(strings22.Index, []any{v30, "."}) +v31 := lang.Apply(strings18.Index, []any{v30, "."}) v32 := lang.Apply(lang1.Equiv, []any{v31, int64(-1)}) if lang.IsTruthy(v32) { var v33 any @@ -71130,7 +70970,7 @@ if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -v7 := lang.Apply(v6, []any{glojure.lang8.Sorted, v3}) +v7 := lang.Apply(v6, []any{glojure.lang4.Sorted, v3}) return v7 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -71154,9 +70994,9 @@ if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -v7, ok := lang.FieldOrMethod(runtime9.Compiler, "specials") +v7, ok := lang.FieldOrMethod(runtime5.Compiler, "specials") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", runtime9.Compiler, "specials"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", runtime5.Compiler, "specials"))) } var v8 any switch reflect.TypeOf(v7).Kind() { @@ -72219,7 +72059,7 @@ return v12 v3 := args[0] v4 := args[1] v5 := args[2] -v6, _ := lang.FieldOrMethod(runtime9.RT, "Subvec") +v6, _ := lang.FieldOrMethod(runtime5.RT, "Subvec") if reflect.TypeOf(v6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Subvec is not a function"))) } @@ -72707,7 +72547,7 @@ if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -v7 := lang.Apply(v6, []any{glojure.lang8.TaggedLiteral, v3}) +v7 := lang.Apply(v6, []any{glojure.lang4.TaggedLiteral, v3}) return v7 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -73398,7 +73238,7 @@ if v17.IsMacro() { } v18 := v17.Get() v19 := lang.Apply(v18, []any{"No namespace: ", v3, " found"}) -v20 := lang.Apply(Exception16., []any{v19}) +v20 := lang.Apply(Exception12., []any{v19}) panic(v20) } v4 = v15 @@ -73492,7 +73332,7 @@ v13 := v12.Get() v14 := lang.Apply(v10, []any{v13, v4, v5}) var v7 any = v14 _ = v7 -v16 := lang.Apply(Exception16., []any{v7}) +v16 := lang.Apply(Exception12., []any{v7}) var v15 any = v16 _ = v15 v18, ok := lang.FieldOrMethod(v15, "getStackTrace") @@ -73598,7 +73438,7 @@ case reflect.Func: default: v46 = v45 } -v47 := lang.Apply(CompilerException33., []any{v42, v44, v46, v15}) +v47 := lang.Apply(CompilerException29., []any{v42, v44, v46, v15}) panic(v47) } else { v6 = nil @@ -74003,7 +73843,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4, _ := lang.FieldOrMethod(runtime9.RT, "ToArray") +v4, _ := lang.FieldOrMethod(runtime5.RT, "ToArray") if reflect.TypeOf(v4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("ToArray is not a function"))) } @@ -74802,7 +74642,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5, _ := lang.FieldOrMethod(runtime9.RT, "UncheckedCharCast") +v5, _ := lang.FieldOrMethod(runtime5.RT, "UncheckedCharCast") if reflect.TypeOf(v5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedCharCast is not a function"))) } @@ -77340,7 +77180,7 @@ if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -v7 := lang.Apply(v6, []any{java.net34.URI, v3}) +v7 := lang.Apply(v6, []any{java.net30.URI, v3}) return v7 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -77397,7 +77237,7 @@ if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -v7 := lang.Apply(v6, []any{java.util26.UUID, v3}) +v7 := lang.Apply(v6, []any{java.util22.UUID, v3}) return v7 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) diff --git a/pkg/codegen/testdata/codegen/test/fn_recur.go b/pkg/codegen/testdata/codegen/test/fn_recur.go index a6a322a9..18c97ab3 100644 --- a/pkg/codegen/testdata/codegen/test/fn_recur.go +++ b/pkg/codegen/testdata/codegen/test/fn_recur.go @@ -51,7 +51,7 @@ func init() { v7 := args[0] v8 := args[1] v9 := args[2] - recur_loop_1624: + recur_loop_1622: var v10 any v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v12 := v11.FindInternedVar(lang.NewSymbol("=")) @@ -83,7 +83,7 @@ func init() { v7 = v15 v8 = v16 v9 = v21 - goto recur_loop_1624 + goto recur_loop_1622 } return v10 }) diff --git a/pkg/stdlib/glojure/core.glj b/pkg/stdlib/glojure/core.glj index 350e0b85..cf338e54 100644 --- a/pkg/stdlib/glojure/core.glj +++ b/pkg/stdlib/glojure/core.glj @@ -7972,7 +7972,7 @@ fails, attempts to require sym's namespace and retries." :added "1.11"} ^go/int64 [^go/string s] (if (string? s) - (glojure.core/let [result__3647__auto__ (strconv.ParseInt s 10 64)] (if (result__3647__auto__ 1) nil (result__3647__auto__ 0))) + (glojure.core/let [result__3648__auto__ (strconv.ParseInt s 10 64)] (if (result__3648__auto__ 1) nil (result__3648__auto__ 0))) (throw (github.com$glojurelang$glojure$pkg$lang.NewIllegalArgumentError (parsing-err s))))) (defn parse-double @@ -7983,7 +7983,7 @@ fails, attempts to require sym's namespace and retries." :added "1.11"} ^go/float64 [^go/string s] (if (string? s) - (glojure.core/let [result__3648__auto__ (strconv.ParseFloat s 64)] (if (result__3648__auto__ 1) nil (result__3648__auto__ 0))) + (glojure.core/let [result__3649__auto__ (strconv.ParseFloat s 64)] (if (result__3649__auto__ 1) nil (result__3649__auto__ 0))) (throw (github.com$glojurelang$glojure$pkg$lang.NewIllegalArgumentError (parsing-err s))))) (defn parse-uuid diff --git a/pkg/stdlib/glojure/core_print.glj b/pkg/stdlib/glojure/core_print.glj index fc677038..61cc5144 100644 --- a/pkg/stdlib/glojure/core_print.glj +++ b/pkg/stdlib/glojure/core_print.glj @@ -518,30 +518,3 @@ (do) (def ^{:private true} print-initialized true) - -(defn ^github.com$glojurelang$glojure$pkg$lang.PrintWriter PrintWriter-on - "implements java.io.PrintWriter given flush-fn, which will be called - when .flush() is called, with a string built up since the last call to .flush(). - if not nil, close-fn will be called with no arguments when .close is called. - autoflush? determines if the PrintWriter will autoflush, false by default." - {:added "1.10"} - ([flush-fn close-fn] - (PrintWriter-on flush-fn close-fn false)) - ([flush-fn close-fn autoflush?] - (let [sb (StringBuilder.)] - (-> (proxy [Writer] [] - (flush [] - (when (pos? (.length sb)) - (flush-fn (github.com$glojurelang$glojure$pkg$lang.ToString sb))) - (.setLength sb 0)) - (close [] - (.flush ^Writer this) - (when close-fn (close-fn)) - nil) - (write [str-cbuf off len] - (when (pos? len) - (if (instance? go/string str-cbuf) - (github.com$glojurelang$glojure$pkg$lang.AppendWriter sb ^go/string str-cbuf ^int off ^int len) - (github.com$glojurelang$glojure$pkg$lang.AppendWriter sb ^chars str-cbuf ^int off ^int len))))) - java.io.BufferedWriter. - (java.io.PrintWriter. ^boolean autoflush?))))) diff --git a/scripts/rewrite-core/rewrite.clj b/scripts/rewrite-core/rewrite.clj index a92d953d..32c7d0ab 100644 --- a/scripts/rewrite-core/rewrite.clj +++ b/scripts/rewrite-core/rewrite.clj @@ -227,6 +227,10 @@ (sexpr-replace 'java.io.PrintWriter 'github.com$glojurelang$glojure$pkg$lang.PrintWriter) + ;; omit PrintWriter-on (defn PrintWriter-on ...) + (omitp #(and (z/list? %) + (= 'defn (first (z/sexpr %))) + (= 'PrintWriter-on (second (z/sexpr %))))) (sexpr-replace 'clojure.lang.IReduce 'github.com$glojurelang$glojure$pkg$lang.IReduce) From 9f8bc73a833e4f74189e572f3403cc1d1700ce7c Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sat, 23 Aug 2025 12:56:23 -0700 Subject: [PATCH 36/67] Fix a few more java references Signed-off-by: James Hamlin --- pkg/codegen/TODO.txt | 20 +- pkg/codegen/testdata/codegen/test/core.go | 2215 ++++------------- pkg/codegen/testdata/codegen/test/fn_recur.go | 4 +- pkg/stdlib/glojure/core.glj | 73 +- scripts/rewrite-core/rewrite.clj | 14 +- 5 files changed, 519 insertions(+), 1807 deletions(-) diff --git a/pkg/codegen/TODO.txt b/pkg/codegen/TODO.txt index b0497ea6..9d26b4ad 100644 --- a/pkg/codegen/TODO.txt +++ b/pkg/codegen/TODO.txt @@ -6,22 +6,18 @@ Handle -- java.io.StringReader21 "java.io.StringReader" - Exception12 "Exception" -- java.lang.annotation17 "java.lang.annotation" +- ExceptionInfo15 "ExceptionInfo" - LinkedBlockingQueue28 "LinkedBlockingQueue" -- CompilerException29 "glojure.lang.Compiler/CompilerException" -- BigInteger11 "BigInteger" +- Object16 "Object" +- glojure.lang.LineNumberingPushbackReader19 "glojure.lang.LineNumberingPushbackReader" +- glojure.lang4 "glojure.lang" +- java.io.InputStreamReader20 "java.io.InputStreamReader" +- java.io.StringReader21 "java.io.StringReader" - java.lang.UnsupportedOperationException14 "java.lang.UnsupportedOperationException" -- ExceptionInfo15 "ExceptionInfo" -- lang1 "github.com/glojurelang/glojure/pkg/lang" - java.lang6 "java.lang" -- glojure.lang.LineNumberingPushbackReader19 "glojure.lang.LineNumberingPushbackReader" +- java.net30 "java.net" - java.util.concurrent.CountDownLatch25 "java.util.concurrent.CountDownLatch" -- BigDecimal9 "BigDecimal" - java.util.concurrent8 "java.util.concurrent" -- java.io.InputStreamReader20 "java.io.InputStreamReader" - java.util22 "java.util" -- glojure.lang4 "glojure.lang" -- Object16 "Object" -- java.net30 "java.net" +- lang1 "github.com/glojurelang/glojure/pkg/lang" diff --git a/pkg/codegen/testdata/codegen/test/core.go b/pkg/codegen/testdata/codegen/test/core.go index ccffdceb..5dee10c2 100644 --- a/pkg/codegen/testdata/codegen/test/core.go +++ b/pkg/codegen/testdata/codegen/test/core.go @@ -4,37 +4,32 @@ package generated import ( "github.com/glojurelang/glojure/pkg/lang" - BigDecimal9 "BigDecimal" - BigInteger11 "BigInteger" - CompilerException29 "glojure.lang.Compiler/CompilerException" - Exception12 "Exception" - ExceptionInfo15 "ExceptionInfo" - LinkedBlockingQueue28 "LinkedBlockingQueue" - Object16 "Object" - big10 "math/big" - errors7 "errors" + Exception9 "Exception" + ExceptionInfo12 "ExceptionInfo" + LinkedBlockingQueue24 "LinkedBlockingQueue" + Object13 "Object" + big8 "math/big" + errors6 "errors" fmt "fmt" - glojure.lang.LineNumberingPushbackReader19 "glojure.lang.LineNumberingPushbackReader" + glojure.lang.LineNumberingPushbackReader15 "glojure.lang.LineNumberingPushbackReader" glojure.lang4 "glojure.lang" - java.io.InputStreamReader20 "java.io.InputStreamReader" - java.io.StringReader21 "java.io.StringReader" - java.lang.UnsupportedOperationException14 "java.lang.UnsupportedOperationException" - java.lang.annotation17 "java.lang.annotation" - java.lang6 "java.lang" - java.net30 "java.net" - java.util.concurrent.CountDownLatch25 "java.util.concurrent.CountDownLatch" - java.util.concurrent8 "java.util.concurrent" - java.util22 "java.util" + java.io.InputStreamReader16 "java.io.InputStreamReader" + java.io.StringReader17 "java.io.StringReader" + java.lang.UnsupportedOperationException11 "java.lang.UnsupportedOperationException" + java.net25 "java.net" + java.util.concurrent.CountDownLatch21 "java.util.concurrent.CountDownLatch" + java.util.concurrent7 "java.util.concurrent" + java.util18 "java.util" lang1 "github.com/glojurelang/glojure/pkg/lang" math3 "math" - rand26 "math/rand" + rand22 "math/rand" reflect "reflect" - regexp27 "regexp" - runtime24 "runtime" + regexp23 "regexp" + runtime20 "runtime" runtime5 "github.com/glojurelang/glojure/pkg/runtime" - strconv23 "strconv" - strings18 "strings" - time13 "time" + strconv19 "strconv" + strings14 "strings" + time10 "time" ) func init() { // Closed-over values @@ -1121,7 +1116,7 @@ if v0.Meta() != nil { } // *data-readers* { -v0 := lang.NewSymbol("*data-readers*").WithMeta(lang.NewMap(lang.NewKeyword("doc"), "Map from reader tag symbols to data reader Vars.\n\n When Clojure starts, it searches for files named 'data_readers.clj'\n and 'data_readers.cljc' at the root of the classpath. Each such file\n must contain a literal map of symbols, like this:\n\n {foo/bar my.project.foo/bar\n foo/baz my.project/baz}\n\n The first symbol in each pair is a tag that will be recognized by\n the Clojure reader. The second symbol in the pair is the\n fully-qualified name of a Var which will be invoked by the reader to\n parse the form following the tag. For example, given the\n data_readers.clj file above, the Clojure reader would parse this\n form:\n\n #foo/bar [1 2 3]\n\n by invoking the Var #'my.project.foo/bar on the vector [1 2 3]. The\n data reader function is invoked on the form AFTER it has been read\n as a normal Clojure data structure by the reader.\n\n Reader tags without namespace qualifiers are reserved for\n Clojure. Default reader tags are defined in\n glojure.core/default-data-readers but may be overridden in\n data_readers.clj, data_readers.cljc, or by rebinding this Var.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(49), lang.NewKeyword("column"), int(6), lang.NewKeyword("line"), int(7837), lang.NewKeyword("end-line"), int(7837), lang.NewKeyword("dynamic"), true)).(*lang.Symbol) +v0 := lang.NewSymbol("*data-readers*").WithMeta(lang.NewMap(lang.NewKeyword("doc"), "Map from reader tag symbols to data reader Vars.\n\n When Clojure starts, it searches for files named 'data_readers.clj'\n and 'data_readers.cljc' at the root of the classpath. Each such file\n must contain a literal map of symbols, like this:\n\n {foo/bar my.project.foo/bar\n foo/baz my.project/baz}\n\n The first symbol in each pair is a tag that will be recognized by\n the Clojure reader. The second symbol in the pair is the\n fully-qualified name of a Var which will be invoked by the reader to\n parse the form following the tag. For example, given the\n data_readers.clj file above, the Clojure reader would parse this\n form:\n\n #foo/bar [1 2 3]\n\n by invoking the Var #'my.project.foo/bar on the vector [1 2 3]. The\n data reader function is invoked on the form AFTER it has been read\n as a normal Clojure data structure by the reader.\n\n Reader tags without namespace qualifiers are reserved for\n Clojure. Default reader tags are defined in\n glojure.core/default-data-readers but may be overridden in\n data_readers.clj, data_readers.cljc, or by rebinding this Var.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(49), lang.NewKeyword("column"), int(6), lang.NewKeyword("line"), int(7794), lang.NewKeyword("end-line"), int(7794), lang.NewKeyword("dynamic"), true)).(*lang.Symbol) v1 := ns.InternWithValue(v0, lang.NewMap(), true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) @@ -1129,7 +1124,7 @@ if v0.Meta() != nil { } // *default-data-reader-fn* { -v0 := lang.NewSymbol("*default-data-reader-fn*").WithMeta(lang.NewMap(lang.NewKeyword("doc"), "When no data reader is found for a tag and *default-data-reader-fn*\n is non-nil, it will be called with two arguments,\n the tag and the value. If *default-data-reader-fn* is nil (the\n default), an exception will be thrown for the unknown tag.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(59), lang.NewKeyword("column"), int(6), lang.NewKeyword("line"), int(7866), lang.NewKeyword("end-line"), int(7866), lang.NewKeyword("dynamic"), true)).(*lang.Symbol) +v0 := lang.NewSymbol("*default-data-reader-fn*").WithMeta(lang.NewMap(lang.NewKeyword("doc"), "When no data reader is found for a tag and *default-data-reader-fn*\n is non-nil, it will be called with two arguments,\n the tag and the value. If *default-data-reader-fn* is nil (the\n default), an exception will be thrown for the unknown tag.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(59), lang.NewKeyword("column"), int(6), lang.NewKeyword("line"), int(7823), lang.NewKeyword("end-line"), int(7823), lang.NewKeyword("dynamic"), true)).(*lang.Symbol) v1 := ns.InternWithValue(v0, nil, true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) @@ -1169,7 +1164,7 @@ if v0.Meta() != nil { } // *loaded-libs* { -v0 := lang.NewSymbol("*loaded-libs*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5860), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(5863), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v0 := lang.NewSymbol("*loaded-libs*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5817), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(5820), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) v1 := ns.InternWithValue(v0, nil, true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) @@ -1177,7 +1172,7 @@ if v0.Meta() != nil { } // *loading-verbosely* { -v0 := lang.NewSymbol("*loading-verbosely*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5870), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(5873), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v0 := lang.NewSymbol("*loading-verbosely*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5827), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(5830), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) v1 := ns.InternWithValue(v0, false, true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) @@ -1193,7 +1188,7 @@ if v0.Meta() != nil { } // *pending-paths* { -v0 := lang.NewSymbol("*pending-paths*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5865), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(5868), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v0 := lang.NewSymbol("*pending-paths*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5822), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(5825), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) v1 := ns.InternWithValue(v0, lang.NewList(), true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) @@ -1257,7 +1252,7 @@ if v0.Meta() != nil { } // *repl* { -v0 := lang.NewSymbol("*repl*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6331), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(6334), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v0 := lang.NewSymbol("*repl*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6288), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(6291), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) v1 := ns.InternWithValue(v0, false, true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) @@ -4971,7 +4966,7 @@ return v19 v2 := v1 _ = v2 } -v0 := lang.NewSymbol("NaN?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns true if num is NaN, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)), lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(8011), lang.NewKeyword("end-line"), int(8011))).(*lang.Symbol) +v0 := lang.NewSymbol("NaN?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns true if num is NaN, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)), lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7968), lang.NewKeyword("end-line"), int(7968))).(*lang.Symbol) var v3 lang.FnFunc v3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -5613,854 +5608,6 @@ if v0.Meta() != nil { v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// add-annotation -{ -v0 := lang.NewSymbol("add-annotation").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5485), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(5485), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("av"), lang.NewSymbol("name"), lang.NewSymbol("v"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -var v6 any -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("vector?")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v5}) -if lang.IsTruthy(v10) { -v12, _ := lang.FieldOrMethod(v3, "visitArray") -if reflect.TypeOf(v12).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("visitArray is not a function"))) -} -v13 := lang.Apply(v12, []any{v4}) -var v11 any = v13 -_ = v11 -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("seq")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v5}) -var v15 any = v19 -_ = v15 -var v20 any = nil -_ = v20 -var v21 any = int64(0) -_ = v21 -var v22 any = int64(0) -_ = v22 -var v23 any -for { -var v24 any -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("<")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.Apply(v27, []any{v22, v21}) -if lang.IsTruthy(v28) { -v30, _ := lang.FieldOrMethod(v20, "nth") -if reflect.TypeOf(v30).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) -} -v31 := lang.Apply(v30, []any{v22}) -var v29 any = v31 -_ = v29 -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("add-annotation")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v11, "value", v29}) -_ = v36 -var v37 any = v15 -var v38 any = v20 -var v39 any = v21 -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("unchecked-inc")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v22}) -var v40 any = v44 -v15 = v37 -v20 = v38 -v21 = v39 -v22 = v40 -continue -} else { -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("seq")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.Apply(v32, []any{v15}) -var v29 any = v33 -_ = v29 -var v35 any -if lang.IsTruthy(v29) { -var v36 any = v29 -_ = v36 -var v38 any -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("chunked-seq?")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) -} -v41 := v40.Get() -v42 := lang.Apply(v41, []any{v36}) -if lang.IsTruthy(v42) { -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("chunk-first")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v36}) -var v43 any = v47 -_ = v43 -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("chunk-rest")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.Apply(v52, []any{v36}) -var v49 any = v53 -var v54 any = v43 -v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v57 := v56.FindInternedVar(lang.NewSymbol("int")) -if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) -} -v58 := v57.Get() -v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v60 := v59.FindInternedVar(lang.NewSymbol("count")) -if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) -} -v61 := v60.Get() -v62 := lang.Apply(v61, []any{v43}) -v63 := lang.Apply(v58, []any{v62}) -var v55 any = v63 -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("int")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) -} -v67 := v66.Get() -v68 := lang.Apply(v67, []any{int64(0)}) -var v64 any = v68 -v15 = v49 -v20 = v54 -v21 = v55 -v22 = v64 -continue -} else { -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("first")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v36}) -var v43 any = v47 -_ = v43 -v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v50 := v49.FindInternedVar(lang.NewSymbol("add-annotation")) -if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) -} -v51 := v50.Get() -v52 := lang.Apply(v51, []any{v11, "value", v43}) -_ = v52 -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("next")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) -} -v56 := v55.Get() -v57 := lang.Apply(v56, []any{v36}) -var v53 any = v57 -var v58 any = nil -var v59 any = int64(0) -var v60 any = int64(0) -v15 = v53 -v20 = v58 -v21 = v59 -v22 = v60 -continue -} -v35 = v38 -} else { -v35 = nil -} -v24 = v35 -} -v23 = v24 - break -} -_ = v23 -v15, ok := lang.FieldOrMethod(v11, "visitEnd") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v11, "visitEnd"))) -} -var v16 any -switch reflect.TypeOf(v15).Kind() { -case reflect.Func: - v16 = lang.Apply(v15, nil) -default: - v16 = v15 -} -v6 = v16 -} else { -var v11 any -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("symbol?")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v5}) -if lang.IsTruthy(v15) { -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("eval")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v5}) -var v16 any = v20 -_ = v16 -var v22 any -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("instance?")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{java.lang6.Enum, v16}) -if lang.IsTruthy(v26) { -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("descriptor")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("class")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.Apply(v32, []any{v16}) -v34 := lang.Apply(v29, []any{v33}) -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("str")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v16}) -v39, _ := lang.FieldOrMethod(v3, "visitEnum") -if reflect.TypeOf(v39).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("visitEnum is not a function"))) -} -v40 := lang.Apply(v39, []any{v4, v34, v38}) -v22 = v40 -} else { -var v41 any -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("class?")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) -} -v44 := v43.Get() -v45 := lang.Apply(v44, []any{v16}) -if lang.IsTruthy(v45) { -v46 := lang.Apply(nil, []any{v16}) -v47, _ := lang.FieldOrMethod(v3, "visit") -if reflect.TypeOf(v47).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("visit is not a function"))) -} -v48 := lang.Apply(v47, []any{v4, v46}) -v41 = v48 -} else { -var v49 any -if lang.IsTruthy(lang.NewKeyword("else")) { -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("str")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("class")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) -} -v55 := v54.Get() -v56 := lang.Apply(v55, []any{v16}) -v57 := lang.Apply(v52, []any{"Unsupported annotation value: ", v5, " of class ", v56}) -v58 := lang.Apply(lang1.NewIllegalArgumentError, []any{v57}) -panic(v58) -} else { -v49 = nil -} -v41 = v49 -} -v22 = v41 -} -v11 = v22 -} else { -var v16 any -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq?")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v5}) -if lang.IsTruthy(v20) { -var v21 any = v5 -_ = v21 -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("nth")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{v21, int64(0), nil}) -var v22 any = v26 -_ = v22 -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("nth")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{v21, int64(1), nil}) -var v27 any = v31 -_ = v27 -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("resolve")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v22}) -var v32 any = v36 -_ = v32 -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("descriptor")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.Apply(v40, []any{v32}) -v42, _ := lang.FieldOrMethod(v3, "visitAnnotation") -if reflect.TypeOf(v42).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("visitAnnotation is not a function"))) -} -v43 := lang.Apply(v42, []any{v4, v41}) -var v37 any = v43 -_ = v37 -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("process-annotation")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.Apply(v47, []any{v37, v27}) -_ = v48 -v49, ok := lang.FieldOrMethod(v37, "visitEnd") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v37, "visitEnd"))) -} -var v50 any -switch reflect.TypeOf(v49).Kind() { -case reflect.Func: - v50 = lang.Apply(v49, nil) -default: - v50 = v49 -} -v16 = v50 -} else { -var v21 any -if lang.IsTruthy(lang.NewKeyword("else")) { -v22, _ := lang.FieldOrMethod(v3, "visit") -if reflect.TypeOf(v22).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("visit is not a function"))) -} -v23 := lang.Apply(v22, []any{v4, v5}) -v21 = v23 -} else { -v21 = nil -} -v16 = v21 -} -v11 = v16 -} -v6 = v11 -} -return v6 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// add-annotations -{ -v0 := lang.NewSymbol("add-annotations").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5511), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(5511), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("visitor"), lang.NewSymbol("m")), lang.NewVector(lang.NewSymbol("visitor"), lang.NewSymbol("m"), lang.NewSymbol("i"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("add-annotations")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3, v4, nil}) -return v8 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("seq")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v4}) -var v6 any = v10 -_ = v6 -var v11 any = nil -_ = v11 -var v12 any = int64(0) -_ = v12 -var v13 any = int64(0) -_ = v13 -var v14 any -for { -var v15 any -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("<")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v13, v12}) -if lang.IsTruthy(v19) { -v21, _ := lang.FieldOrMethod(v11, "nth") -if reflect.TypeOf(v21).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) -} -v22 := lang.Apply(v21, []any{v13}) -var v20 any = v22 -_ = v20 -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("nth")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v20, int64(0), nil}) -var v23 any = v27 -_ = v23 -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("nth")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.Apply(v31, []any{v20, int64(1), nil}) -var v28 any = v32 -_ = v28 -var v34 any -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("symbol?")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v23}) -if lang.IsTruthy(v38) { -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("resolve")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v23}) -var v39 any = v43 -_ = v39 -var v45 any -if lang.IsTruthy(v39) { -var v46 any = v39 -_ = v46 -var v48 any -v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v50 := v49.FindInternedVar(lang.NewSymbol("is-annotation?")) -if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) -} -v51 := v50.Get() -v52 := lang.Apply(v51, []any{v46}) -if lang.IsTruthy(v52) { -var v54 any -if lang.IsTruthy(v5) { -v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v56 := v55.FindInternedVar(lang.NewSymbol("descriptor")) -if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) -} -v57 := v56.Get() -v58 := lang.Apply(v57, []any{v46}) -v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v60 := v59.FindInternedVar(lang.NewSymbol("is-runtime-annotation?")) -if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) -} -v61 := v60.Get() -v62 := lang.Apply(v61, []any{v46}) -v63, _ := lang.FieldOrMethod(v3, "visitParameterAnnotation") -if reflect.TypeOf(v63).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("visitParameterAnnotation is not a function"))) -} -v64 := lang.Apply(v63, []any{v5, v58, v62}) -v54 = v64 -} else { -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("descriptor")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) -} -v67 := v66.Get() -v68 := lang.Apply(v67, []any{v46}) -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("is-runtime-annotation?")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) -} -v71 := v70.Get() -v72 := lang.Apply(v71, []any{v46}) -v73, _ := lang.FieldOrMethod(v3, "visitAnnotation") -if reflect.TypeOf(v73).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("visitAnnotation is not a function"))) -} -v74 := lang.Apply(v73, []any{v68, v72}) -v54 = v74 -} -var v53 any = v54 -_ = v53 -v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v77 := v76.FindInternedVar(lang.NewSymbol("process-annotation")) -if v77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) -} -v78 := v77.Get() -v79 := lang.Apply(v78, []any{v53, v28}) -_ = v79 -v80, ok := lang.FieldOrMethod(v53, "visitEnd") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v53, "visitEnd"))) -} -var v81 any -switch reflect.TypeOf(v80).Kind() { -case reflect.Func: - v81 = lang.Apply(v80, nil) -default: - v81 = v80 -} -v48 = v81 -} else { -v48 = nil -} -v45 = v48 -} else { -v45 = nil -} -v34 = v45 -} else { -v34 = nil -} -_ = v34 -var v39 any = v6 -var v40 any = v11 -var v41 any = v12 -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("unchecked-inc")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.Apply(v45, []any{v13}) -var v42 any = v46 -v6 = v39 -v11 = v40 -v12 = v41 -v13 = v42 -continue -} else { -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v6}) -var v20 any = v24 -_ = v20 -var v26 any -if lang.IsTruthy(v20) { -var v27 any = v20 -_ = v27 -var v29 any -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("chunked-seq?")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.Apply(v32, []any{v27}) -if lang.IsTruthy(v33) { -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("chunk-first")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v27}) -var v34 any = v38 -_ = v34 -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("chunk-rest")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v27}) -var v40 any = v44 -var v45 any = v34 -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("int")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) -} -v49 := v48.Get() -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("count")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.Apply(v52, []any{v34}) -v54 := lang.Apply(v49, []any{v53}) -var v46 any = v54 -v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v57 := v56.FindInternedVar(lang.NewSymbol("int")) -if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) -} -v58 := v57.Get() -v59 := lang.Apply(v58, []any{int64(0)}) -var v55 any = v59 -v6 = v40 -v11 = v45 -v12 = v46 -v13 = v55 -continue -} else { -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("first")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v27}) -var v34 any = v38 -_ = v34 -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("nth")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v34, int64(0), nil}) -var v39 any = v43 -_ = v39 -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("nth")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.Apply(v47, []any{v34, int64(1), nil}) -var v44 any = v48 -_ = v44 -var v50 any -v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v52 := v51.FindInternedVar(lang.NewSymbol("symbol?")) -if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) -} -v53 := v52.Get() -v54 := lang.Apply(v53, []any{v39}) -if lang.IsTruthy(v54) { -v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v57 := v56.FindInternedVar(lang.NewSymbol("resolve")) -if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) -} -v58 := v57.Get() -v59 := lang.Apply(v58, []any{v39}) -var v55 any = v59 -_ = v55 -var v61 any -if lang.IsTruthy(v55) { -var v62 any = v55 -_ = v62 -var v64 any -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("is-annotation?")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) -} -v67 := v66.Get() -v68 := lang.Apply(v67, []any{v62}) -if lang.IsTruthy(v68) { -var v70 any -if lang.IsTruthy(v5) { -v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v72 := v71.FindInternedVar(lang.NewSymbol("descriptor")) -if v72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) -} -v73 := v72.Get() -v74 := lang.Apply(v73, []any{v62}) -v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v76 := v75.FindInternedVar(lang.NewSymbol("is-runtime-annotation?")) -if v76.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) -} -v77 := v76.Get() -v78 := lang.Apply(v77, []any{v62}) -v79, _ := lang.FieldOrMethod(v3, "visitParameterAnnotation") -if reflect.TypeOf(v79).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("visitParameterAnnotation is not a function"))) -} -v80 := lang.Apply(v79, []any{v5, v74, v78}) -v70 = v80 -} else { -v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v82 := v81.FindInternedVar(lang.NewSymbol("descriptor")) -if v82.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) -} -v83 := v82.Get() -v84 := lang.Apply(v83, []any{v62}) -v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v86 := v85.FindInternedVar(lang.NewSymbol("is-runtime-annotation?")) -if v86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) -} -v87 := v86.Get() -v88 := lang.Apply(v87, []any{v62}) -v89, _ := lang.FieldOrMethod(v3, "visitAnnotation") -if reflect.TypeOf(v89).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("visitAnnotation is not a function"))) -} -v90 := lang.Apply(v89, []any{v84, v88}) -v70 = v90 -} -var v69 any = v70 -_ = v69 -v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v93 := v92.FindInternedVar(lang.NewSymbol("process-annotation")) -if v93.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) -} -v94 := v93.Get() -v95 := lang.Apply(v94, []any{v69, v44}) -_ = v95 -v96, ok := lang.FieldOrMethod(v69, "visitEnd") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v69, "visitEnd"))) -} -var v97 any -switch reflect.TypeOf(v96).Kind() { -case reflect.Func: - v97 = lang.Apply(v96, nil) -default: - v97 = v96 -} -v64 = v97 -} else { -v64 = nil -} -v61 = v64 -} else { -v61 = nil -} -v50 = v61 -} else { -v50 = nil -} -_ = v50 -v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v57 := v56.FindInternedVar(lang.NewSymbol("next")) -if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) -} -v58 := v57.Get() -v59 := lang.Apply(v58, []any{v27}) -var v55 any = v59 -var v60 any = nil -var v61 any = int64(0) -var v62 any = int64(0) -v6 = v55 -v11 = v60 -v12 = v61 -v13 = v62 -continue -} -v26 = v29 -} else { -v26 = nil -} -v15 = v26 -} -v14 = v15 - break -} -return v14 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} // add-classpath { v0 := lang.NewSymbol("add-classpath").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("url"))), lang.NewKeyword("doc"), "DEPRECATED \n\n Adds the url (String or URL object) to the classpath per\n URLClassLoader.addURL", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("deprecated"), "1.1", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5176), lang.NewKeyword("end-line"), int(5176))).(*lang.Symbol) @@ -6489,7 +5636,7 @@ if v0.Meta() != nil { } // add-doc-and-meta { -v0 := lang.NewSymbol("add-doc-and-meta").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("docstring"), lang.NewSymbol("meta"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(26), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6443), lang.NewKeyword("end-line"), int(6443), lang.NewKeyword("private"), true)).(*lang.Symbol) +v0 := lang.NewSymbol("add-doc-and-meta").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("docstring"), lang.NewSymbol("meta"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(26), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6400), lang.NewKeyword("end-line"), int(6400), lang.NewKeyword("private"), true)).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 5 { @@ -7159,7 +6306,7 @@ if v0.Meta() != nil { } // alter-var-root { -v0 := lang.NewSymbol("alter-var-root").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("v"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Atomically alters the root binding of var v by applying f to its\n current value plus any args", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5527), lang.NewKeyword("end-line"), int(5527))).(*lang.Symbol) +v0 := lang.NewSymbol("alter-var-root").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("v"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Atomically alters the root binding of var v by applying f to its\n current value plus any args", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5484), lang.NewKeyword("end-line"), int(5484))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -7654,7 +6801,7 @@ if v0.Meta() != nil { } // ancestors { -v0 := lang.NewSymbol("ancestors").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"))), lang.NewKeyword("doc"), "Returns the immediate and indirect parents of tag, either via a Java type\n inheritance relationship or a relationship established via derive. h\n must be a hierarchy obtained from make-hierarchy, if not supplied\n defaults to the global hierarchy", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5620), lang.NewKeyword("end-line"), int(5620))).(*lang.Symbol) +v0 := lang.NewSymbol("ancestors").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"))), lang.NewKeyword("doc"), "Returns the immediate and indirect parents of tag, either via a Java type\n inheritance relationship or a relationship established via derive. h\n must be a hierarchy obtained from make-hierarchy, if not supplied\n defaults to the global hierarchy", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5577), lang.NewKeyword("end-line"), int(5577))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -7758,7 +6905,7 @@ v47 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) v48 := lang.Apply(v46, []any{v47, v43}) return v48 }) -v43 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5633), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(5633), lang.NewKeyword("end-column"), int(54)) +v43 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5590), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(5590), lang.NewKeyword("end-column"), int(54)) v44, err := lang.WithMeta(v42, v43.(lang.IPersistentMap)) if err != nil { panic(err) @@ -8565,7 +7712,7 @@ if v0.Meta() != nil { } // as-> { -v0 := lang.NewSymbol("as->").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "Binds name to expr, evaluates the first form in the lexical context\n of that binding, then binds name to that result, repeating for each\n successive form, returning the result of the last form.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7641), lang.NewKeyword("end-line"), int(7641))).(*lang.Symbol) +v0 := lang.NewSymbol("as->").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "Binds name to expr, evaluates the first form in the lexical context\n of that binding, then binds name to that result, repeating for each\n successive form, returning the result of the last form.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7598), lang.NewKeyword("end-line"), int(7598))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -10144,7 +9291,7 @@ if v0.Meta() != nil { } // assert-valid-fdecl { -v0 := lang.NewSymbol("assert-valid-fdecl").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fdecl"))), lang.NewKeyword("doc"), "A good fdecl looks like (([a] ...) ([a b] ...)) near the end of defn.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(42), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(7545), lang.NewKeyword("end-line"), int(7545), lang.NewKeyword("private"), true, lang.NewKeyword("dynamic"), true)).(*lang.Symbol) +v0 := lang.NewSymbol("assert-valid-fdecl").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fdecl"))), lang.NewKeyword("doc"), "A good fdecl looks like (([a] ...) ([a b] ...)) near the end of defn.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(42), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(7502), lang.NewKeyword("end-line"), int(7502), lang.NewKeyword("private"), true, lang.NewKeyword("dynamic"), true)).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -10235,7 +9382,7 @@ panic(v42) } return v16 }) -v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7551), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7560), lang.NewKeyword("end-column"), int(59)) +v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7508), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7517), lang.NewKeyword("end-column"), int(59)) v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) if err != nil { panic(err) @@ -10270,7 +9417,7 @@ v29 := v28.Get() v30 := lang.Apply(v29, []any{v26}) return v30 }) -v26 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7562), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(7562), lang.NewKeyword("end-column"), int(42)) +v26 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7519), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(7519), lang.NewKeyword("end-column"), int(42)) v27, err := lang.WithMeta(v25, v26.(lang.IPersistentMap)) if err != nil { panic(err) @@ -10472,7 +9619,7 @@ if v0.Meta() != nil { } // assoc-in { -v0 := lang.NewSymbol("assoc-in").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("&"), lang.NewSymbol("ks")), lang.NewSymbol("v"))), lang.NewKeyword("doc"), "Associates a value in a nested associative structure, where ks is a\n sequence of keys and v is the new value and returns a new nested structure.\n If any levels do not exist, hash-maps will be created.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6190), lang.NewKeyword("end-line"), int(6190))).(*lang.Symbol) +v0 := lang.NewSymbol("assoc-in").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("&"), lang.NewSymbol("ks")), lang.NewSymbol("v"))), lang.NewKeyword("doc"), "Associates a value in a nested associative structure, where ks is a\n sequence of keys and v is the new value and returns a new nested structure.\n If any levels do not exist, hash-maps will be created.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6147), lang.NewKeyword("end-line"), int(6147))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 3 { @@ -10558,7 +9705,7 @@ if v0.Meta() != nil { } // associative? { -v0 := lang.NewSymbol("associative?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements Associative", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6266), lang.NewKeyword("end-line"), int(6266))).(*lang.Symbol) +v0 := lang.NewSymbol("associative?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements Associative", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6223), lang.NewKeyword("end-line"), int(6223))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -10643,7 +9790,7 @@ if v8.IsMacro() { } v9 := v8.Get() if lang.IsTruthy(v9) { -v10 := lang.Apply(errors7.New, []any{"Can't await in agent action"}) +v10 := lang.Apply(errors6.New, []any{"Can't await in agent action"}) panic(v10) } else { v6 = nil @@ -10884,7 +10031,7 @@ if v9.IsMacro() { } v10 := v9.Get() if lang.IsTruthy(v10) { -v11 := lang.Apply(errors7.New, []any{"Can't await in agent action"}) +v11 := lang.Apply(errors6.New, []any{"Can't await in agent action"}) panic(v11) } else { v7 = nil @@ -11084,9 +10231,9 @@ v26 = v27 break } _ = v26 -v18, ok := lang.FieldOrMethod(java.util.concurrent8.TimeUnit, "MILLISECONDS") +v18, ok := lang.FieldOrMethod(java.util.concurrent7.TimeUnit, "MILLISECONDS") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", java.util.concurrent8.TimeUnit, "MILLISECONDS"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", java.util.concurrent7.TimeUnit, "MILLISECONDS"))) } var v19 any switch reflect.TypeOf(v18).Kind() { @@ -11162,7 +10309,7 @@ if v0.Meta() != nil { } // bases { -v0 := lang.NewSymbol("bases").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"))), lang.NewKeyword("doc"), "Returns the immediate superclass and direct interfaces of c, if any", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5565), lang.NewKeyword("end-line"), int(5565))).(*lang.Symbol) +v0 := lang.NewSymbol("bases").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"))), lang.NewKeyword("doc"), "Returns the immediate superclass and direct interfaces of c, if any", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5522), lang.NewKeyword("end-line"), int(5522))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -11262,99 +10409,88 @@ if v26.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } v27 := v26.Get() -v28, ok := lang.FieldOrMethod(v4, "numerator") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "numerator"))) -} -var v29 any -switch reflect.TypeOf(v28).Kind() { -case reflect.Func: - v29 = lang.Apply(v28, nil) -default: - v29 = v28 -} -v30 := lang.Apply(BigDecimal9., []any{v29}) -v31, ok := lang.FieldOrMethod(v4, "denominator") +v28 := lang.Apply(lang1.NewBigDecimalFromRatio, []any{v4}) +v29, ok := lang.FieldOrMethod(v4, "denominator") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "denominator"))) } -var v32 any -switch reflect.TypeOf(v31).Kind() { +var v30 any +switch reflect.TypeOf(v29).Kind() { case reflect.Func: - v32 = lang.Apply(v31, nil) + v30 = lang.Apply(v29, nil) default: - v32 = v31 + v30 = v29 } -v33 := lang.Apply(v27, []any{v30, v32}) -v20 = v33 +v31 := lang.Apply(v27, []any{v28, v30}) +v20 = v31 } else { -var v34 any -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("instance?")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) +var v32 any +v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v34 := v33.FindInternedVar(lang.NewSymbol("instance?")) +if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) } -v37 := v36.Get() -v38 := lang.Apply(v37, []any{lang1.*BigInt, v4}) -if lang.IsTruthy(v38) { -v39, ok := lang.FieldOrMethod(v4, "toBigDecimal") +v35 := v34.Get() +v36 := lang.Apply(v35, []any{lang1.*BigInt, v4}) +if lang.IsTruthy(v36) { +v37, ok := lang.FieldOrMethod(v4, "toBigDecimal") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "toBigDecimal"))) } -var v40 any -switch reflect.TypeOf(v39).Kind() { +var v38 any +switch reflect.TypeOf(v37).Kind() { case reflect.Func: - v40 = lang.Apply(v39, nil) + v38 = lang.Apply(v37, nil) default: - v40 = v39 + v38 = v37 } -v34 = v40 +v32 = v38 } else { -var v41 any -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("instance?")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +var v39 any +v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v41 := v40.FindInternedVar(lang.NewSymbol("instance?")) +if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) } -v44 := v43.Get() -v45 := lang.Apply(v44, []any{big10.*Int, v4}) -if lang.IsTruthy(v45) { -v46 := lang.Apply(BigDecimal9., []any{v4}) -v41 = v46 +v42 := v41.Get() +v43 := lang.Apply(v42, []any{big8.*Int, v4}) +if lang.IsTruthy(v43) { +v44 := lang.Apply(lang1.NewBigDecimal, []any{v4}) +v39 = v44 } else { -var v47 any -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("number?")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) +var v45 any +v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v47 := v46.FindInternedVar(lang.NewSymbol("number?")) +if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) } -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v4}) -if lang.IsTruthy(v51) { -v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("long")) -if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) +v48 := v47.Get() +v49 := lang.Apply(v48, []any{v4}) +if lang.IsTruthy(v49) { +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("long")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) } -v54 := v53.Get() -v55 := lang.Apply(v54, []any{v4}) -v56 := lang.Apply(lang1.NewBigDecimalFromInt64, []any{v55}) -v47 = v56 +v52 := v51.Get() +v53 := lang.Apply(v52, []any{v4}) +v54 := lang.Apply(lang1.NewBigDecimalFromInt64, []any{v53}) +v45 = v54 } else { -var v57 any +var v55 any if lang.IsTruthy(lang.NewKeyword("else")) { -v58 := lang.Apply(BigDecimal9., []any{v4}) -v57 = v58 +v56 := lang.Apply(lang1.NewBigDecimal, []any{v4}) +v55 = v56 } else { -v57 = nil +v55 = nil } -v47 = v57 +v45 = v55 } -v41 = v47 +v39 = v45 } -v34 = v41 +v32 = v39 } -v20 = v34 +v20 = v32 } v10 = v20 } @@ -11397,7 +10533,7 @@ if v12.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } v13 := v12.Get() -v14 := lang.Apply(v13, []any{big10.*Int, v4}) +v14 := lang.Apply(v13, []any{big8.*Int, v4}) if lang.IsTruthy(v14) { v15 := lang.Apply(lang1.NewBigIntFromGoBigInt, []any{v4}) v10 = v15 @@ -11513,7 +10649,7 @@ if v64.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) } v65 := v64.Get() -v66 := lang.Apply(BigInteger11., []any{v4}) +v66 := lang.Apply(lang1.NewBigInt, []any{v4}) v67 := lang.Apply(v65, []any{v66}) v62 = v67 } else { @@ -11542,7 +10678,7 @@ if v0.Meta() != nil { } // biginteger { -v1 := reflect.TypeOf((*big10.Int)(nil)) +v1 := reflect.TypeOf((*big8.Int)(nil)) v0 := lang.NewSymbol("biginteger").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Coerce to BigInteger", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3634), lang.NewKeyword("end-line"), int(3634))).(*lang.Symbol) var v3 lang.FnFunc v3 = lang.NewFnFunc(func(args ...any) any { @@ -11557,7 +10693,7 @@ if v7.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } v8 := v7.Get() -v9 := lang.Apply(v8, []any{big10.*Int, v4}) +v9 := lang.Apply(v8, []any{big8.*Int, v4}) if lang.IsTruthy(v9) { v5 = v4 } else { @@ -11673,12 +10809,12 @@ if v49.IsMacro() { } v50 := v49.Get() v51 := lang.Apply(v50, []any{v4}) -v52 := lang.Apply(big10.NewInt, []any{v51}) +v52 := lang.Apply(big8.NewInt, []any{v51}) v43 = v52 } else { var v53 any if lang.IsTruthy(lang.NewKeyword("else")) { -v54 := lang.Apply(BigInteger11., []any{v4}) +v54 := lang.Apply(lang1.NewBigInt, []any{v4}) v53 = v54 } else { v53 = nil @@ -11697,7 +10833,7 @@ v5 = v10 } return v5 }) -v4 := reflect.TypeOf((*big10.Int)(nil)) +v4 := reflect.TypeOf((*big8.Int)(nil)) v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { @@ -14747,7 +13883,7 @@ if v0.Meta() != nil { } // bound? { -v0 := lang.NewSymbol("bound?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("vars"))), lang.NewKeyword("doc"), "Returns true if all of the vars provided as arguments have any bound value, root or thread-local.\n Implies that deref'ing the provided vars will succeed. Returns true if no vars are provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5534), lang.NewKeyword("end-line"), int(5534))).(*lang.Symbol) +v0 := lang.NewSymbol("bound?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("vars"))), lang.NewKeyword("doc"), "Returns true if all of the vars provided as arguments have any bound value, root or thread-local.\n Implies that deref'ing the provided vars will succeed. Returns true if no vars are provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5491), lang.NewKeyword("end-line"), int(5491))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -14781,7 +13917,7 @@ default: } return v10 }) -v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5540), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5540), lang.NewKeyword("end-column"), int(69)) +v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5497), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5497), lang.NewKeyword("end-column"), int(69)) v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) if err != nil { panic(err) @@ -14798,7 +13934,7 @@ if v0.Meta() != nil { } // bounded-count { -v0 := lang.NewSymbol("bounded-count").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "If coll is counted? returns its count, else will count at most the first n\n elements of coll using its seq", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7453), lang.NewKeyword("end-line"), int(7453))).(*lang.Symbol) +v0 := lang.NewSymbol("bounded-count").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "If coll is counted? returns its count, else will count at most the first n\n elements of coll using its seq", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7410), lang.NewKeyword("end-line"), int(7410))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { @@ -15326,7 +14462,7 @@ if v0.Meta() != nil { } // case { -v0 := lang.NewSymbol("case").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("e"), lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes an expression, and a set of clauses.\n\n Each clause can take the form of either:\n\n test-constant result-expr\n\n (test-constant1 ... test-constantN) result-expr\n\n The test-constants are not evaluated. They must be compile-time\n literals, and need not be quoted. If the expression is equal to a\n test-constant, the corresponding result-expr is returned. A single\n default expression can follow the clauses, and its value will be\n returned if no clause matches. If no default expression is provided\n and no clause matches, an IllegalArgumentException is thrown.\n\n Unlike cond and condp, case does a constant-time dispatch, the\n clauses are not considered sequentially. All manner of constant\n expressions are acceptable in case, including numbers, strings,\n symbols, keywords, and (Clojure) composites thereof. Note that since\n lists are used to group multiple constants that map to the same\n expression, a vector can be used to match a list if needed. The\n test-constants need not be all of the same type.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6755), lang.NewKeyword("end-line"), int(6755))).(*lang.Symbol) +v0 := lang.NewSymbol("case").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("e"), lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes an expression, and a set of clauses.\n\n Each clause can take the form of either:\n\n test-constant result-expr\n\n (test-constant1 ... test-constantN) result-expr\n\n The test-constants are not evaluated. They must be compile-time\n literals, and need not be quoted. If the expression is equal to a\n test-constant, the corresponding result-expr is returned. A single\n default expression can follow the clauses, and its value will be\n returned if no clause matches. If no default expression is provided\n and no clause matches, an IllegalArgumentException is thrown.\n\n Unlike cond and condp, case does a constant-time dispatch, the\n clauses are not considered sequentially. All manner of constant\n expressions are acceptable in case, including numbers, strings,\n symbols, keywords, and (Clojure) composites thereof. Note that since\n lists are used to group multiple constants that map to the same\n expression, a vector can be used to match a list if needed. The\n test-constants need not be all of the same type.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6712), lang.NewKeyword("end-line"), int(6712))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -15352,7 +14488,7 @@ if v12.IsMacro() { v13 := v12.Get() v14 := lang.Apply(v13, nil) v15 := lang.NewMap(lang.NewKeyword("tag"), lang1.Object) -v16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6781), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(6781), lang.NewKeyword("end-column"), int(84)) +v16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6738), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(6738), lang.NewKeyword("end-column"), int(84)) v17, err := lang.WithMeta(v15, v16.(lang.IPersistentMap)) if err != nil { panic(err) @@ -15625,7 +14761,7 @@ return v149 v145 := v144 _ = v145 } -v145 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6788), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(6791), lang.NewKeyword("end-column"), int(48)) +v145 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6745), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(6748), lang.NewKeyword("end-column"), int(48)) v146, err := lang.WithMeta(v144, v145.(lang.IPersistentMap)) if err != nil { panic(err) @@ -15690,7 +14826,7 @@ v176 := args[1] v177 := lang.Apply(v143, []any{v175, v176, v160}) return v177 }) -v175 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6795), lang.NewKeyword("column"), int(37), lang.NewKeyword("end-line"), int(6795), lang.NewKeyword("end-column"), int(60)) +v175 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6752), lang.NewKeyword("column"), int(37), lang.NewKeyword("end-line"), int(6752), lang.NewKeyword("end-column"), int(60)) v176, err := lang.WithMeta(v174, v175.(lang.IPersistentMap)) if err != nil { panic(err) @@ -15703,13 +14839,13 @@ v166 = v178 } return v166 }) -v152 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6793), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(6796), lang.NewKeyword("end-column"), int(53)) +v152 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6750), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(6753), lang.NewKeyword("end-column"), int(53)) v153, err := lang.WithMeta(v151, v152.(lang.IPersistentMap)) if err != nil { panic(err) } v154 := lang.NewMap() -v155 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6797), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(6797), lang.NewKeyword("end-column"), int(25)) +v155 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6754), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(6754), lang.NewKeyword("end-column"), int(25)) v156, err := lang.WithMeta(v154, v155.(lang.IPersistentMap)) if err != nil { panic(err) @@ -15772,7 +14908,7 @@ v181 = v175 } return v181 }) -v174 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6801), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(6801), lang.NewKeyword("end-column"), int(77)) +v174 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6758), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(6758), lang.NewKeyword("end-column"), int(77)) v175, err := lang.WithMeta(v173, v174.(lang.IPersistentMap)) if err != nil { panic(err) @@ -16467,7 +15603,7 @@ if v0.Meta() != nil { } // case-map { -v0 := lang.NewSymbol("case-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("case-f"), lang.NewSymbol("test-f"), lang.NewSymbol("tests"), lang.NewSymbol("thens"))), lang.NewKeyword("doc"), "Transforms a sequence of test constants and a corresponding sequence of then\n expressions into a sorted map to be consumed by case*. The form of the map\n entries are {(case-f test) [(test-f test) then]}.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6657), lang.NewKeyword("end-line"), int(6657), lang.NewKeyword("private"), true)).(*lang.Symbol) +v0 := lang.NewSymbol("case-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("case-f"), lang.NewSymbol("test-f"), lang.NewSymbol("tests"), lang.NewSymbol("thens"))), lang.NewKeyword("doc"), "Transforms a sequence of test constants and a corresponding sequence of then\n expressions into a sorted map to be consumed by case*. The form of the map\n entries are {(case-f test) [(test-f test) then]}.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6614), lang.NewKeyword("end-line"), int(6614), lang.NewKeyword("private"), true)).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 4 { @@ -16558,7 +15694,7 @@ if v0.Meta() != nil { } // cat { -v0 := lang.NewSymbol("cat").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rf"))), lang.NewKeyword("doc"), "A transducer which concatenates the contents of each input, which must be a\n collection, into the reduction.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7688), lang.NewKeyword("end-line"), int(7688))).(*lang.Symbol) +v0 := lang.NewSymbol("cat").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rf"))), lang.NewKeyword("doc"), "A transducer which concatenates the contents of each input, which must be a\n collection, into the reduction.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7645), lang.NewKeyword("end-line"), int(7645))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -16599,7 +15735,7 @@ return v16 panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) -v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7694), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(7698), lang.NewKeyword("end-column"), int(36)) +v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7651), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(7655), lang.NewKeyword("end-column"), int(36)) v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) if err != nil { panic(err) @@ -16963,7 +16099,7 @@ if v0.Meta() != nil { } // check-cyclic-dependency { -v0 := lang.NewSymbol("check-cyclic-dependency").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("path"))), lang.NewKeyword("doc"), "Detects and rejects non-trivial cyclic load dependencies. The\n exception message shows the dependency chain with the cycle\n highlighted. Ignores the trivial case of a file attempting to load\n itself because that can occur when a gen-class'd class loads its\n implementation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(30), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6017), lang.NewKeyword("end-line"), int(6017), lang.NewKeyword("private"), true)).(*lang.Symbol) +v0 := lang.NewSymbol("check-cyclic-dependency").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("path"))), lang.NewKeyword("doc"), "Detects and rejects non-trivial cyclic load dependencies. The\n exception message shows the dependency chain with the cycle\n highlighted. Ignores the trivial case of a file attempting to load\n itself because that can occur when a gen-class'd class loads its\n implementation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(30), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5974), lang.NewKeyword("end-line"), int(5974), lang.NewKeyword("private"), true)).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -16978,7 +16114,7 @@ if v6.IsMacro() { } v7 := v6.Get() v8 := lang.CreatePersistentTreeSet(v3) -v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6024), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(6024), lang.NewKeyword("end-column"), int(21)) +v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5981), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(5981), lang.NewKeyword("end-column"), int(21)) v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) if err != nil { panic(err) @@ -17032,7 +16168,7 @@ v25 = v24 } return v25 }) -v24 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6025), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(6025), lang.NewKeyword("end-column"), int(59)) +v24 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5982), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(5982), lang.NewKeyword("end-column"), int(59)) v25, err := lang.WithMeta(v23, v24.(lang.IPersistentMap)) if err != nil { panic(err) @@ -17512,7 +16648,7 @@ if v0.Meta() != nil { } // coll? { -v0 := lang.NewSymbol("coll?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements IPersistentCollection", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6235), lang.NewKeyword("end-line"), int(6235))).(*lang.Symbol) +v0 := lang.NewSymbol("coll?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements IPersistentCollection", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6192), lang.NewKeyword("end-line"), int(6192))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -17847,7 +16983,7 @@ if v0.Meta() != nil { } // compile { -v0 := lang.NewSymbol("compile").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"))), lang.NewKeyword("doc"), "Compiles the namespace named by the symbol lib into a set of\n classfiles. The source for the lib must be in a proper\n classpath-relative directory. The output files will go into the\n directory specified by *compile-path*, and that directory too must\n be in the classpath.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6157), lang.NewKeyword("end-line"), int(6157))).(*lang.Symbol) +v0 := lang.NewSymbol("compile").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"))), lang.NewKeyword("doc"), "Compiles the namespace named by the symbol lib into a set of\n classfiles. The source for the lib must be in a proper\n classpath-relative directory. The output files will go into the\n directory specified by *compile-path*, and that directory too must\n be in the classpath.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6114), lang.NewKeyword("end-line"), int(6114))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -17983,7 +17119,7 @@ if v0.Meta() != nil { } // completing { -v0 := lang.NewSymbol("completing").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("cf"))), lang.NewKeyword("doc"), "Takes a reducing function f of 2 args and returns a fn suitable for\n transduce by adding an arity-1 signature that calls cf (default -\n identity) on the result argument.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6936), lang.NewKeyword("end-line"), int(6936))).(*lang.Symbol) +v0 := lang.NewSymbol("completing").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("cf"))), lang.NewKeyword("doc"), "Takes a reducing function f of 2 args and returns a fn suitable for\n transduce by adding an arity-1 signature that calls cf (default -\n identity) on the result argument.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6893), lang.NewKeyword("end-line"), int(6893))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -18025,7 +17161,7 @@ return v8 panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) -v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6943), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(6946), lang.NewKeyword("end-column"), int(23)) +v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6900), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(6903), lang.NewKeyword("end-column"), int(23)) v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) if err != nil { panic(err) @@ -18395,7 +17531,7 @@ if v0.Meta() != nil { } // cond-> { -v0 := lang.NewSymbol("cond->").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes an expression and a set of test/form pairs. Threads expr (via ->)\n through each form for which the corresponding test\n expression is true. Note that, unlike cond branching, cond-> threading does\n not short circuit after the first true test expression.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7607), lang.NewKeyword("end-line"), int(7607))).(*lang.Symbol) +v0 := lang.NewSymbol("cond->").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes an expression and a set of test/form pairs. Threads expr (via ->)\n through each form for which the corresponding test\n expression is true. Note that, unlike cond branching, cond-> threading does\n not short circuit after the first true test expression.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7564), lang.NewKeyword("end-line"), int(7564))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -18528,7 +17664,7 @@ v72 := lang.Apply(v35, []any{v39, v43, v67, v71}) v73 := lang.Apply(v32, []any{v72}) return v73 }) -v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7616), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7616), lang.NewKeyword("end-column"), int(66)) +v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7573), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7573), lang.NewKeyword("end-column"), int(66)) v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) if err != nil { panic(err) @@ -18671,7 +17807,7 @@ if v0.Meta() != nil { } // cond->> { -v0 := lang.NewSymbol("cond->>").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes an expression and a set of test/form pairs. Threads expr (via ->>)\n through each form for which the corresponding test expression\n is true. Note that, unlike cond branching, cond->> threading does not short circuit\n after the first true test expression.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7624), lang.NewKeyword("end-line"), int(7624))).(*lang.Symbol) +v0 := lang.NewSymbol("cond->>").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes an expression and a set of test/form pairs. Threads expr (via ->>)\n through each form for which the corresponding test expression\n is true. Note that, unlike cond branching, cond->> threading does not short circuit\n after the first true test expression.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7581), lang.NewKeyword("end-line"), int(7581))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -18804,7 +17940,7 @@ v72 := lang.Apply(v35, []any{v39, v43, v67, v71}) v73 := lang.Apply(v32, []any{v72}) return v73 }) -v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7633), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7633), lang.NewKeyword("end-column"), int(67)) +v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7590), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7590), lang.NewKeyword("end-column"), int(67)) v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) if err != nil { panic(err) @@ -18947,7 +18083,7 @@ if v0.Meta() != nil { } // condp { -v0 := lang.NewSymbol("condp").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes a binary predicate, an expression, and a set of clauses.\n Each clause can take the form of either:\n\n test-expr result-expr\n\n test-expr :>> result-fn\n\n Note :>> is an ordinary keyword.\n\n For each clause, (pred test-expr expr) is evaluated. If it returns\n logical true, the clause is a match. If a binary clause matches, the\n result-expr is returned, if a ternary clause matches, its result-fn,\n which must be a unary function, is called with the result of the\n predicate as its argument, the result of that call being the return\n value of condp. A single default expression can follow the clauses,\n and its value will be returned if no clause matches. If no default\n expression is provided and no clause matches, an\n IllegalArgumentException is thrown.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6396), lang.NewKeyword("end-line"), int(6396))).(*lang.Symbol) +v0 := lang.NewSymbol("condp").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes a binary predicate, an expression, and a set of clauses.\n Each clause can take the form of either:\n\n test-expr result-expr\n\n test-expr :>> result-fn\n\n Note :>> is an ordinary keyword.\n\n For each clause, (pred test-expr expr) is evaluated. If it returns\n logical true, the clause is a match. If a binary clause matches, the\n result-expr is returned, if a ternary clause matches, its result-fn,\n which must be a unary function, is called with the result of the\n predicate as its argument, the result of that call being the return\n value of condp. A single default expression can follow the clauses,\n and its value will be returned if no clause matches. If no default\n expression is provided and no clause matches, an\n IllegalArgumentException is thrown.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6353), lang.NewKeyword("end-line"), int(6353))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -19438,7 +18574,7 @@ return v70 v20 := v19 _ = v20 } -v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6420), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(6432), lang.NewKeyword("end-column"), int(53)) +v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6377), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(6389), lang.NewKeyword("end-column"), int(53)) v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) if err != nil { panic(err) @@ -19833,7 +18969,7 @@ if v0.Meta() != nil { } // counted? { -v0 := lang.NewSymbol("counted?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements count in constant time", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6284), lang.NewKeyword("end-line"), int(6284))).(*lang.Symbol) +v0 := lang.NewSymbol("counted?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements count in constant time", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6241), lang.NewKeyword("end-line"), int(6241))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -19921,7 +19057,7 @@ if v0.Meta() != nil { } // data-reader-urls { -v0 := lang.NewSymbol("data-reader-urls").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7873), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7873), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v0 := lang.NewSymbol("data-reader-urls").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7830), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7830), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { @@ -19937,7 +19073,7 @@ if v0.Meta() != nil { } // data-reader-var { -v0 := lang.NewSymbol("data-reader-var").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7875), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7875), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v0 := lang.NewSymbol("data-reader-var").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7832), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7832), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -20309,7 +19445,7 @@ if v0.Meta() != nil { } // dedupe { -v0 := lang.NewSymbol("dedupe").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence removing consecutive duplicates in coll.\n Returns a transducer when no collection is provided.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7724), lang.NewKeyword("end-line"), int(7724))).(*lang.Symbol) +v0 := lang.NewSymbol("dedupe").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence removing consecutive duplicates in coll.\n Returns a transducer when no collection is provided.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7681), lang.NewKeyword("end-line"), int(7681))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -20378,14 +19514,14 @@ return v24 panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) -v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7731), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7739), lang.NewKeyword("end-column"), int(37)) +v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7688), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7696), lang.NewKeyword("end-column"), int(37)) v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) if err != nil { panic(err) } return v13 }) -v4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7729), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7739), lang.NewKeyword("end-column"), int(39)) +v4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7686), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7696), lang.NewKeyword("end-column"), int(39)) v5, err := lang.WithMeta(v3, v4.(lang.IPersistentMap)) if err != nil { panic(err) @@ -22164,7 +21300,7 @@ v108 := v107.Get() v109 := lang.Apply(v108, []any{v71}) v110 := lang.Apply(v105, []any{v109, int64(1)}) if lang.IsTruthy(v110) { -v111 := lang.Apply(Exception12., []any{"The syntax for defmulti has changed. Example: (defmulti name dispatch-fn :default dispatch-value)"}) +v111 := lang.Apply(Exception9., []any{"The syntax for defmulti has changed. Example: (defmulti name dispatch-fn :default dispatch-value)"}) panic(v111) } else { v102 = nil @@ -23090,7 +22226,7 @@ if v0.Meta() != nil { } // defonce { -v0 := lang.NewSymbol("defonce").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("expr"))), lang.NewKeyword("doc"), "defs name to have the root value of the expr iff the named var has no root value,\n else expr is unevaluated", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5849), lang.NewKeyword("end-line"), int(5849))).(*lang.Symbol) +v0 := lang.NewSymbol("defonce").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("expr"))), lang.NewKeyword("doc"), "defs name to have the root value of the expr iff the named var has no root value,\n else expr is unevaluated", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5806), lang.NewKeyword("end-line"), int(5806))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 4 { @@ -24313,7 +23449,7 @@ if v0.Meta() != nil { } // deliver { -v0 := lang.NewSymbol("deliver").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("promise"), lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Delivers the supplied value to the promise, releasing any pending\n derefs. A subsequent call to deliver on a promise will have no effect.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7152), lang.NewKeyword("end-line"), int(7152))).(*lang.Symbol) +v0 := lang.NewSymbol("deliver").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("promise"), lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Delivers the supplied value to the promise, releasing any pending\n derefs. A subsequent call to deliver on a promise will have no effect.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7109), lang.NewKeyword("end-line"), int(7109))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { @@ -24332,7 +23468,7 @@ if v0.Meta() != nil { } // denominator { -v1 := reflect.TypeOf((*big10.Int)(nil)) +v1 := reflect.TypeOf((*big8.Int)(nil)) v0 := lang.NewSymbol("denominator").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("r"))), lang.NewKeyword("doc"), "Returns the denominator part of a Ratio.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3591), lang.NewKeyword("end-line"), int(3591))).(*lang.Symbol) var v3 lang.FnFunc v3 = lang.NewFnFunc(func(args ...any) any { @@ -24353,7 +23489,7 @@ default: } return v6 }) -v4 := reflect.TypeOf((*big10.Int)(nil)) +v4 := reflect.TypeOf((*big8.Int)(nil)) v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { @@ -24647,7 +23783,7 @@ v7, _ := lang.FieldOrMethod(v3, "Get") if reflect.TypeOf(v7).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Get is not a function"))) } -v8 := lang.Apply(v7, []any{v4, time13.Millisecond}) +v8 := lang.Apply(v7, []any{v4, time10.Millisecond}) v6 = v8 }() return v6 @@ -24663,7 +23799,7 @@ if v0.Meta() != nil { } // derive { -v0 := lang.NewSymbol("derive").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag"), lang.NewSymbol("parent")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"), lang.NewSymbol("parent"))), lang.NewKeyword("doc"), "Establishes a parent/child relationship between parent and\n tag. Parent must be a namespace-qualified symbol or keyword and\n child can be either a namespace-qualified symbol or keyword or a\n class. h must be a hierarchy obtained from make-hierarchy, if not\n supplied defaults to, and modifies, the global hierarchy.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5648), lang.NewKeyword("end-line"), int(5648))).(*lang.Symbol) +v0 := lang.NewSymbol("derive").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag"), lang.NewSymbol("parent")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"), lang.NewSymbol("parent"))), lang.NewKeyword("doc"), "Establishes a parent/child relationship between parent and\n tag. Parent must be a namespace-qualified symbol or keyword and\n child can be either a namespace-qualified symbol or keyword or a\n class. h must be a hierarchy obtained from make-hierarchy, if not\n supplied defaults to, and modifies, the global hierarchy.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5605), lang.NewKeyword("end-line"), int(5605))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -24752,7 +23888,7 @@ if v35.IsMacro() { } v36 := v35.Get() v37 := lang.CreatePersistentTreeSet() -v38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5671), lang.NewKeyword("column"), int(61), lang.NewKeyword("end-line"), int(5671), lang.NewKeyword("end-column"), int(63)) +v38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5628), lang.NewKeyword("column"), int(61), lang.NewKeyword("end-line"), int(5628), lang.NewKeyword("end-column"), int(63)) v39, err := lang.WithMeta(v37, v38.(lang.IPersistentMap)) if err != nil { panic(err) @@ -24770,7 +23906,7 @@ v46 := lang.Apply(v30, []any{v33, v40, v45}) v47 := lang.Apply(v27, []any{v23, v24, v46}) return v47 }) -v23 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5669), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(5671), lang.NewKeyword("end-column"), int(98)) +v23 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5626), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(5628), lang.NewKeyword("end-column"), int(98)) v24, err := lang.WithMeta(v22, v23.(lang.IPersistentMap)) if err != nil { panic(err) @@ -24786,7 +23922,7 @@ v29 := lang.Apply(v27, []any{v15, v28}) v30 := lang.Apply(v21, []any{v24, v14, v29}) return v30 }) -v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5668), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(5672), lang.NewKeyword("end-column"), int(56)) +v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5625), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(5629), lang.NewKeyword("end-column"), int(56)) v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) if err != nil { panic(err) @@ -24822,7 +23958,7 @@ if v31.IsMacro() { } v32 := v31.Get() v33 := lang.Apply(v32, []any{v4, "already has", v5, "as ancestor"}) -v34 := lang.Apply(Exception12., []any{v33}) +v34 := lang.Apply(Exception9., []any{v33}) panic(v34) } else { v24 = nil @@ -24845,7 +23981,7 @@ if v42.IsMacro() { } v43 := v42.Get() v44 := lang.Apply(v43, []any{"Cyclic derivation:", v5, "has", v4, "as ancestor"}) -v45 := lang.Apply(Exception12., []any{v44}) +v45 := lang.Apply(Exception9., []any{v44}) panic(v45) } else { v35 = nil @@ -24871,7 +24007,7 @@ if v54.IsMacro() { } v55 := v54.Get() v56 := lang.CreatePersistentTreeSet() -v57 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5679), lang.NewKeyword("column"), int(61), lang.NewKeyword("end-line"), int(5679), lang.NewKeyword("end-column"), int(63)) +v57 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5636), lang.NewKeyword("column"), int(61), lang.NewKeyword("end-line"), int(5636), lang.NewKeyword("end-column"), int(63)) v58, err := lang.WithMeta(v56, v57.(lang.IPersistentMap)) if err != nil { panic(err) @@ -24884,7 +24020,7 @@ v63 := lang.Apply(v12, []any{v62, v4, v8, v5, v10}) v64 := lang.Apply(lang.NewKeyword("descendants"), []any{v3}) v65 := lang.Apply(v12, []any{v64, v5, v10, v4, v8}) v66 := lang.NewMap(lang.NewKeyword("parents"), v61, lang.NewKeyword("ancestors"), v63, lang.NewKeyword("descendants"), v65) -v67 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5679), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(5681), lang.NewKeyword("end-column"), int(61)) +v67 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5636), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(5638), lang.NewKeyword("end-column"), int(61)) v68, err := lang.WithMeta(v66, v67.(lang.IPersistentMap)) if err != nil { panic(err) @@ -24912,7 +24048,7 @@ if v0.Meta() != nil { } // descendants { -v0 := lang.NewSymbol("descendants").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"))), lang.NewKeyword("doc"), "Returns the immediate and indirect children of tag, through a\n relationship established via derive. h must be a hierarchy obtained\n from make-hierarchy, if not supplied defaults to the global\n hierarchy. Note: does not work on Java type inheritance\n relationships.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5636), lang.NewKeyword("end-line"), int(5636))).(*lang.Symbol) +v0 := lang.NewSymbol("descendants").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"))), lang.NewKeyword("doc"), "Returns the immediate and indirect children of tag, through a\n relationship established via derive. h must be a hierarchy obtained\n from make-hierarchy, if not supplied defaults to the global\n hierarchy. Note: does not work on Java type inheritance\n relationships.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5593), lang.NewKeyword("end-line"), int(5593))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -24944,7 +24080,7 @@ if v7.IsMacro() { v8 := v7.Get() v9 := lang.Apply(v8, []any{v4}) if lang.IsTruthy(v9) { -v10 := lang.Apply(java.lang.UnsupportedOperationException14., []any{"Can't get descendants of classes"}) +v10 := lang.Apply(java.lang.UnsupportedOperationException11., []any{"Can't get descendants of classes"}) panic(v10) } else { v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) @@ -24975,24 +24111,6 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// descriptor -{ -v0 := lang.NewSymbol("descriptor").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5482), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(5482), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.Apply(nil, []any{v3}) -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} // destructure { v0 := lang.NewSymbol("destructure").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4400), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(4400), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) @@ -25184,7 +24302,7 @@ var v88 any if lang.IsTruthy(lang.NewKeyword("else")) { var v89 any if lang.IsTruthy(v47) { -v90 := lang.Apply(errors7.New, []any{"Unsupported binding form, only :as can follow & parameter"}) +v90 := lang.Apply(errors6.New, []any{"Unsupported binding form, only :as can follow & parameter"}) panic(v90) } else { var v92 any @@ -26246,7 +25364,7 @@ if v51.IsMacro() { } v52 := v51.Get() v53 := lang.Apply(v52, []any{"Unsupported binding form: ", v13}) -v54 := lang.Apply(errors7.New, []any{v53}) +v54 := lang.Apply(errors6.New, []any{v53}) panic(v54) } else { v49 = nil @@ -26885,7 +26003,7 @@ if v0.Meta() != nil { // distinct? { v1 := reflect.TypeOf(false) -v0 := lang.NewSymbol("distinct?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Returns true if no two of the arguments are =", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5707), lang.NewKeyword("end-line"), int(5707))).(*lang.Symbol) +v0 := lang.NewSymbol("distinct?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Returns true if no two of the arguments are =", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5664), lang.NewKeyword("end-line"), int(5664))).(*lang.Symbol) var v3 lang.FnFunc v3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -26927,7 +26045,7 @@ v10 := v9.Get() v11 := lang.Apply(v10, []any{v4, v5}) if lang.IsTruthy(v11) { v13 := lang.CreatePersistentTreeSet(v4, v5) -v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5716), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(5716), lang.NewKeyword("end-column"), int(20)) +v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5673), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(5673), lang.NewKeyword("end-column"), int(20)) v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) if err != nil { panic(err) @@ -30922,7 +30040,7 @@ if v0.Meta() != nil { } // empty? { -v0 := lang.NewSymbol("empty?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll has no items. To check the emptiness of a seq,\n please use the idiom (seq x) rather than (not (empty? x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6290), lang.NewKeyword("end-line"), int(6290))).(*lang.Symbol) +v0 := lang.NewSymbol("empty?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll has no items. To check the emptiness of a seq,\n please use the idiom (seq x) rather than (not (empty? x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6247), lang.NewKeyword("end-line"), int(6247))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -31045,7 +30163,7 @@ if v0.Meta() != nil { } // enumeration-seq { -v0 := lang.NewSymbol("enumeration-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("e"))), lang.NewKeyword("doc"), "Returns a seq on a java.util.Enumeration", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5753), lang.NewKeyword("end-line"), int(5753))).(*lang.Symbol) +v0 := lang.NewSymbol("enumeration-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("e"))), lang.NewKeyword("doc"), "Returns a seq on a java.util.Enumeration", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5710), lang.NewKeyword("end-line"), int(5710))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -31194,7 +30312,7 @@ if v0.Meta() != nil { } // every-pred { -v0 := lang.NewSymbol("every-pred").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("p")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2"), lang.NewSymbol("p3")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2"), lang.NewSymbol("p3"), lang.NewSymbol("&"), lang.NewSymbol("ps"))), lang.NewKeyword("doc"), "Takes a set of predicates and returns a function f that returns true if all of its\n composing predicates return a logical true value against all of its arguments, else it returns\n false. Note that f is short-circuiting in that it will stop execution on the first\n argument that triggers a logical false result against the original predicates.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7465), lang.NewKeyword("end-line"), int(7465))).(*lang.Symbol) +v0 := lang.NewSymbol("every-pred").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("p")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2"), lang.NewSymbol("p3")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2"), lang.NewSymbol("p3"), lang.NewSymbol("&"), lang.NewSymbol("ps"))), lang.NewKeyword("doc"), "Takes a set of predicates and returns a function f that returns true if all of its\n composing predicates return a logical true value against all of its arguments, else it returns\n false. Note that f is short-circuiting in that it will stop execution on the first\n argument that triggers a logical false result against the original predicates.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7422), lang.NewKeyword("end-line"), int(7422))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -31306,7 +30424,7 @@ return v13 v5 := v4 _ = v5 } -v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7472), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7478), lang.NewKeyword("end-column"), int(56)) +v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7429), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7435), lang.NewKeyword("end-column"), int(56)) v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) if err != nil { panic(err) @@ -31481,7 +30599,7 @@ v26 = v23 } return v26 }) -v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7486), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(7486), lang.NewKeyword("end-column"), int(65)) +v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7443), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(7443), lang.NewKeyword("end-column"), int(65)) v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) if err != nil { panic(err) @@ -31498,7 +30616,7 @@ return v14 v6 := v5 _ = v6 } -v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7480), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7486), lang.NewKeyword("end-column"), int(75)) +v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7437), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7443), lang.NewKeyword("end-column"), int(75)) v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) if err != nil { panic(err) @@ -31737,7 +30855,7 @@ v27 = v24 } return v27 }) -v23 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7494), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(7494), lang.NewKeyword("end-column"), int(72)) +v23 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7451), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(7451), lang.NewKeyword("end-column"), int(72)) v24, err := lang.WithMeta(v22, v23.(lang.IPersistentMap)) if err != nil { panic(err) @@ -31754,7 +30872,7 @@ return v15 v7 := v6 _ = v7 } -v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7488), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7494), lang.NewKeyword("end-column"), int(82)) +v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7445), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7451), lang.NewKeyword("end-column"), int(82)) v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) if err != nil { panic(err) @@ -31800,7 +30918,7 @@ v20 := args[0] v21 := lang.Apply(v20, []any{v15}) return v21 }) -v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7499), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(7499), lang.NewKeyword("end-column"), int(28)) +v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7456), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(7456), lang.NewKeyword("end-column"), int(28)) v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) if err != nil { panic(err) @@ -31834,7 +30952,7 @@ v25 = v22 } return v25 }) -v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7500), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7500), lang.NewKeyword("end-column"), int(42)) +v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7457), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7457), lang.NewKeyword("end-column"), int(42)) v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) if err != nil { panic(err) @@ -31878,7 +30996,7 @@ v26 = v23 } return v26 }) -v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7501), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(7501), lang.NewKeyword("end-column"), int(50)) +v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7458), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(7458), lang.NewKeyword("end-column"), int(50)) v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) if err != nil { panic(err) @@ -31925,7 +31043,7 @@ v33 := v32.Get() v34 := lang.Apply(v33, []any{v30, v18}) return v34 }) -v30 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7503), lang.NewKeyword("column"), int(48), lang.NewKeyword("end-line"), int(7503), lang.NewKeyword("end-column"), int(63)) +v30 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7460), lang.NewKeyword("column"), int(48), lang.NewKeyword("end-line"), int(7460), lang.NewKeyword("end-column"), int(63)) v31, err := lang.WithMeta(v29, v30.(lang.IPersistentMap)) if err != nil { panic(err) @@ -31942,7 +31060,7 @@ return v22 v14 := v13 _ = v14 } -v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7497), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7503), lang.NewKeyword("end-column"), int(71)) +v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7454), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7460), lang.NewKeyword("end-column"), int(71)) v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) if err != nil { panic(err) @@ -32125,7 +31243,7 @@ if v6.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } v7 := v6.Get() -v8 := lang.Apply(ExceptionInfo15., []any{v3, v4}) +v8 := lang.Apply(ExceptionInfo12., []any{v3, v4}) v9 := lang.Apply(v7, []any{v8, "glojure.core$ex_info"}) return v9 case 3: @@ -32138,7 +31256,7 @@ if v7.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } v8 := v7.Get() -v9 := lang.Apply(ExceptionInfo15., []any{v3, v4, v5}) +v9 := lang.Apply(ExceptionInfo12., []any{v3, v4, v5}) v10 := lang.Apply(v8, []any{v9, "glojure.core$ex_info"}) return v10 default: @@ -32280,7 +31398,7 @@ if v43.IsMacro() { } v44 := v43.Get() v45 := lang.Apply(v44, []any{v26, " is not a protocol"}) -v46 := lang.Apply(errors7.New, []any{v45}) +v46 := lang.Apply(errors6.New, []any{v45}) panic(v46) } _ = v37 @@ -32508,7 +31626,7 @@ if v59.IsMacro() { } v60 := v59.Get() v61 := lang.Apply(v60, []any{v42, " is not a protocol"}) -v62 := lang.Apply(errors7.New, []any{v61}) +v62 := lang.Apply(errors6.New, []any{v61}) panic(v62) } _ = v53 @@ -33204,7 +32322,7 @@ if v0.Meta() != nil { } // filterv { -v0 := lang.NewSymbol("filterv").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a vector of the items in coll for which\n (pred item) returns logical true. pred must be free of side-effects.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7004), lang.NewKeyword("end-line"), int(7004))).(*lang.Symbol) +v0 := lang.NewSymbol("filterv").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a vector of the items in coll for which\n (pred item) returns logical true. pred must be free of side-effects.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6961), lang.NewKeyword("end-line"), int(6961))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { @@ -33247,7 +32365,7 @@ v14 = v12 } return v14 }) -v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7010), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(7010), lang.NewKeyword("end-column"), int(52)) +v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6967), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(6967), lang.NewKeyword("end-column"), int(52)) v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) if err != nil { panic(err) @@ -33259,7 +32377,7 @@ if v15.IsMacro() { } v16 := v15.Get() v17 := lang.NewVector() -v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7011), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(7011), lang.NewKeyword("end-column"), int(27)) +v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6968), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(6968), lang.NewKeyword("end-column"), int(27)) v19, err := lang.WithMeta(v17, v18.(lang.IPersistentMap)) if err != nil { panic(err) @@ -33429,7 +32547,7 @@ if v0.Meta() != nil { } // fits-table? { -v0 := lang.NewSymbol("fits-table?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ints"))), lang.NewKeyword("doc"), "Returns true if the collection of ints can fit within the\n max-table-switch-size, false otherwise.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6668), lang.NewKeyword("end-line"), int(6668), lang.NewKeyword("private"), true)).(*lang.Symbol) +v0 := lang.NewSymbol("fits-table?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ints"))), lang.NewKeyword("doc"), "Returns true if the collection of ints can fit within the\n max-table-switch-size, false otherwise.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6625), lang.NewKeyword("end-line"), int(6625), lang.NewKeyword("private"), true)).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -33506,7 +32624,7 @@ if v0.Meta() != nil { } // flatten { -v0 := lang.NewSymbol("flatten").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Takes any nested combination of sequential things (lists, vectors,\n etc.) and returns their contents as a single, flat lazy sequence.\n (flatten nil) returns an empty sequence.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7161), lang.NewKeyword("end-line"), int(7161))).(*lang.Symbol) +v0 := lang.NewSymbol("flatten").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Takes any nested combination of sequential things (lists, vectors,\n etc.) and returns their contents as a single, flat lazy sequence.\n (flatten nil) returns an empty sequence.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7118), lang.NewKeyword("end-line"), int(7118))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -34615,7 +33733,7 @@ if v0.Meta() != nil { } // fn? { -v0 := lang.NewSymbol("fn?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements Fn, i.e. is an object created via fn.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6259), lang.NewKeyword("end-line"), int(6259))).(*lang.Symbol) +v0 := lang.NewSymbol("fn?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements Fn, i.e. is an object created via fn.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6216), lang.NewKeyword("end-line"), int(6216))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -34674,7 +33792,7 @@ if v0.Meta() != nil { } // fnil { -v0 := lang.NewSymbol("fnil").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("z"))), lang.NewKeyword("doc"), "Takes a function f, and returns a function that calls f, replacing\n a nil first argument to f with the supplied value x. Higher arity\n versions can replace arguments in the second and third\n positions (y, z). Note that the function f can take any number of\n arguments, not just the one(s) being nil-patched.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6601), lang.NewKeyword("end-line"), int(6601))).(*lang.Symbol) +v0 := lang.NewSymbol("fnil").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("z"))), lang.NewKeyword("doc"), "Takes a function f, and returns a function that calls f, replacing\n a nil first argument to f with the supplied value x. Higher arity\n versions can replace arguments in the second and third\n positions (y, z). Note that the function f can take any number of\n arguments, not just the one(s) being nil-patched.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6558), lang.NewKeyword("end-line"), int(6558))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -34769,7 +33887,7 @@ v18 := lang.Apply(v12, []any{v3, v13, v7, v8, v9}) return v18 } }) -v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6610), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(6614), lang.NewKeyword("end-column"), int(55)) +v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6567), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(6571), lang.NewKeyword("end-column"), int(55)) v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) if err != nil { panic(err) @@ -34889,7 +34007,7 @@ v24 := lang.Apply(v13, []any{v3, v14, v19, v9, v10}) return v24 } }) -v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6616), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(6619), lang.NewKeyword("end-column"), int(71)) +v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6573), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(6576), lang.NewKeyword("end-column"), int(71)) v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) if err != nil { panic(err) @@ -35036,7 +34154,7 @@ v30 := lang.Apply(v14, []any{v3, v15, v20, v25, v11}) return v30 } }) -v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6621), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(6624), lang.NewKeyword("end-column"), int(87)) +v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6578), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(6581), lang.NewKeyword("end-column"), int(87)) v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) if err != nil { panic(err) @@ -38250,7 +37368,7 @@ if v0.Meta() != nil { } // format { -v0 := lang.NewSymbol("format").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fmt"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Formats a string using java.lang.String.format, see java.util.Formatter for format\n string syntax", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5760), lang.NewKeyword("end-line"), int(5760))).(*lang.Symbol) +v0 := lang.NewSymbol("format").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fmt"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Formats a string using java.lang.String.format, see java.util.Formatter for format\n string syntax", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5717), lang.NewKeyword("end-line"), int(5717))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -38278,7 +37396,7 @@ if v0.Meta() != nil { } // frequencies { -v0 := lang.NewSymbol("frequencies").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a map from distinct items in coll to the number of times\n they appear.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7228), lang.NewKeyword("end-line"), int(7228))).(*lang.Symbol) +v0 := lang.NewSymbol("frequencies").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a map from distinct items in coll to the number of times\n they appear.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7185), lang.NewKeyword("end-line"), int(7185))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -38327,7 +37445,7 @@ v23 := lang.Apply(v18, []any{v22}) v24 := lang.Apply(v15, []any{v11, v12, v23}) return v24 }) -v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7235), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(7236), lang.NewKeyword("end-column"), int(54)) +v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7192), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(7193), lang.NewKeyword("end-column"), int(54)) v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) if err != nil { panic(err) @@ -38339,7 +37457,7 @@ if v14.IsMacro() { } v15 := v14.Get() v16 := lang.NewMap() -v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7237), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(7237), lang.NewKeyword("end-column"), int(24)) +v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7194), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(7194), lang.NewKeyword("end-column"), int(24)) v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) if err != nil { panic(err) @@ -38357,7 +37475,7 @@ if v0.Meta() != nil { } // future { -v0 := lang.NewSymbol("future").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Takes a body of expressions and yields a future object that will\n invoke the body in another thread, and will cache the result and\n return it on all subsequent calls to deref/@. If the computation has\n not yet finished, calls to deref/@ will block, unless the variant of\n deref with timeout is used. See also - realized?.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7052), lang.NewKeyword("end-line"), int(7052))).(*lang.Symbol) +v0 := lang.NewSymbol("future").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Takes a body of expressions and yields a future object that will\n invoke the body in another thread, and will cache the result and\n return it on all subsequent calls to deref/@. If the computation has\n not yet finished, calls to deref/@ will block, unless the variant of\n deref with timeout is used. See also - realized?.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7009), lang.NewKeyword("end-line"), int(7009))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -38462,7 +37580,7 @@ if v0.Meta() != nil { } // future-call { -v0 := lang.NewSymbol("future-call").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Takes a function of no args and yields a future object that will\n invoke the function in another thread, and will cache the result and\n return it on all subsequent calls to deref/@. If the computation has\n not yet finished, calls to deref/@ will block, unless the variant\n of deref with timeout is used. See also - realized?.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7046), lang.NewKeyword("end-line"), int(7046))).(*lang.Symbol) +v0 := lang.NewSymbol("future-call").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Takes a function of no args and yields a future object that will\n invoke the function in another thread, and will cache the result and\n return it on all subsequent calls to deref/@. If the computation has\n not yet finished, calls to deref/@ will block, unless the variant\n of deref with timeout is used. See also - realized?.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7003), lang.NewKeyword("end-line"), int(7003))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -38491,7 +37609,7 @@ if v0.Meta() != nil { } // future-cancel { -v0 := lang.NewSymbol("future-cancel").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Cancels the future, if possible.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7062), lang.NewKeyword("end-line"), int(7062))).(*lang.Symbol) +v0 := lang.NewSymbol("future-cancel").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Cancels the future, if possible.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7019), lang.NewKeyword("end-line"), int(7019))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -38513,7 +37631,7 @@ if v0.Meta() != nil { } // future-cancelled? { -v0 := lang.NewSymbol("future-cancelled?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Returns true if future f is cancelled", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7068), lang.NewKeyword("end-line"), int(7068))).(*lang.Symbol) +v0 := lang.NewSymbol("future-cancelled?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Returns true if future f is cancelled", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7025), lang.NewKeyword("end-line"), int(7025))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -38541,7 +37659,7 @@ if v0.Meta() != nil { } // future-done? { -v0 := lang.NewSymbol("future-done?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Returns true if future f is done", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6581), lang.NewKeyword("end-line"), int(6581))).(*lang.Symbol) +v0 := lang.NewSymbol("future-done?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Returns true if future f is done", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6538), lang.NewKeyword("end-line"), int(6538))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -38569,7 +37687,7 @@ if v0.Meta() != nil { } // future? { -v0 := lang.NewSymbol("future?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is a future", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6575), lang.NewKeyword("end-line"), int(6575))).(*lang.Symbol) +v0 := lang.NewSymbol("future?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is a future", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6532), lang.NewKeyword("end-line"), int(6532))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -38582,7 +37700,7 @@ if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -v7 := lang.Apply(v6, []any{java.util.concurrent8.Future, v3}) +v7 := lang.Apply(v6, []any{java.util.concurrent7.Future, v3}) return v7 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -38763,7 +37881,7 @@ if v0.Meta() != nil { } // get-in { -v0 := lang.NewSymbol("get-in").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("ks")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("ks"), lang.NewSymbol("not-found"))), lang.NewKeyword("doc"), "Returns the value in a nested associative structure,\n where ks is a sequence of keys. Returns nil if the key\n is not present, or the not-found value if supplied.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6171), lang.NewKeyword("end-line"), int(6171))).(*lang.Symbol) +v0 := lang.NewSymbol("get-in").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("ks")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("ks"), lang.NewSymbol("not-found"))), lang.NewKeyword("doc"), "Returns the value in a nested associative structure,\n where ks is a sequence of keys. Returns nil if the key\n is not present, or the not-found value if supplied.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6128), lang.NewKeyword("end-line"), int(6128))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -38788,7 +37906,7 @@ return v11 v3 := args[0] v4 := args[1] v5 := args[2] -v7 := lang.Apply(Object16., nil) +v7 := lang.Apply(Object13., nil) var v6 any = v7 _ = v6 var v8 any = v8 @@ -38930,7 +38048,7 @@ if v0.Meta() != nil { } // global-hierarchy { -v0 := lang.NewSymbol("global-hierarchy").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5556), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(5557), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v0 := lang.NewSymbol("global-hierarchy").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5513), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(5514), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) v1 := ns.InternWithValue(v0, lang.NewMap(lang.NewKeyword("parents"), lang.NewMap(), lang.NewKeyword("descendants"), lang.NewMap(), lang.NewKeyword("ancestors"), lang.NewMap()), true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) @@ -38938,7 +38056,7 @@ if v0.Meta() != nil { } // group-by { -v0 := lang.NewSymbol("group-by").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a map of the elements of coll keyed by the result of\n f on each element. The value at each key will be a vector of the\n corresponding elements, in the order they appeared in coll.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7171), lang.NewKeyword("end-line"), int(7171))).(*lang.Symbol) +v0 := lang.NewSymbol("group-by").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a map of the elements of coll keyed by the result of\n f on each element. The value at each key will be a vector of the\n corresponding elements, in the order they appeared in coll.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7128), lang.NewKeyword("end-line"), int(7128))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { @@ -38987,7 +38105,7 @@ if v24.IsMacro() { } v25 := v24.Get() v26 := lang.NewVector() -v27 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7182), lang.NewKeyword("column"), int(40), lang.NewKeyword("end-line"), int(7182), lang.NewKeyword("end-column"), int(41)) +v27 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7139), lang.NewKeyword("column"), int(40), lang.NewKeyword("end-line"), int(7139), lang.NewKeyword("end-column"), int(41)) v28, err := lang.WithMeta(v26, v27.(lang.IPersistentMap)) if err != nil { panic(err) @@ -38997,7 +38115,7 @@ v30 := lang.Apply(v22, []any{v29, v13}) v31 := lang.Apply(v19, []any{v12, v14, v30}) return v31 }) -v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7180), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(7182), lang.NewKeyword("end-column"), int(48)) +v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7137), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(7139), lang.NewKeyword("end-column"), int(48)) v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) if err != nil { panic(err) @@ -39009,7 +38127,7 @@ if v15.IsMacro() { } v16 := v15.Get() v17 := lang.NewMap() -v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7183), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(7183), lang.NewKeyword("end-column"), int(17)) +v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7140), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(7140), lang.NewKeyword("end-column"), int(17)) v19, err := lang.WithMeta(v17, v18.(lang.IPersistentMap)) if err != nil { panic(err) @@ -39027,7 +38145,7 @@ if v0.Meta() != nil { } // halt-when { -v0 := lang.NewSymbol("halt-when").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred")), lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("retf"))), lang.NewKeyword("doc"), "Returns a transducer that ends transduction when pred returns true\n for an input. When retf is supplied it must be a fn of 2 arguments -\n it will be passed the (completed) result so far and the input that\n triggered the predicate, and its return value (if it does not throw\n an exception) will be the return value of the transducer. If retf\n is not supplied, the input that triggered the predicate will be\n returned. If the predicate never returns true the transduction is\n unaffected.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7700), lang.NewKeyword("end-line"), int(7700))).(*lang.Symbol) +v0 := lang.NewSymbol("halt-when").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred")), lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("retf"))), lang.NewKeyword("doc"), "Returns a transducer that ends transduction when pred returns true\n for an input. When retf is supplied it must be a fn of 2 arguments -\n it will be passed the (completed) result so far and the input that\n triggered the predicate, and its return value (if it does not throw\n an exception) will be the return value of the transducer. If retf\n is not supplied, the input that triggered the predicate will be\n returned. If the predicate never returns true the transduction is\n unaffected.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7657), lang.NewKeyword("end-line"), int(7657))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -39110,7 +38228,7 @@ v15 = v17 v15 = v9 } v18 := lang.NewMap(lang.NewKeyword("glojure.core/halt"), v15) -v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7721), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(7721), lang.NewKeyword("end-column"), int(72)) +v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7678), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(7678), lang.NewKeyword("end-column"), int(72)) v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) if err != nil { panic(err) @@ -39126,14 +38244,14 @@ return v10 panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) -v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7713), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7722), lang.NewKeyword("end-column"), int(34)) +v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7670), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7679), lang.NewKeyword("end-column"), int(34)) v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) if err != nil { panic(err) } return v9 }) -v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7712), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7722), lang.NewKeyword("end-column"), int(35)) +v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7669), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7679), lang.NewKeyword("end-column"), int(35)) v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) if err != nil { panic(err) @@ -40389,7 +39507,7 @@ if v0.Meta() != nil { } // ifn? { -v0 := lang.NewSymbol("ifn?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements IFn. Note that many data structures\n (e.g. sets and maps) implement IFn", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6252), lang.NewKeyword("end-line"), int(6252))).(*lang.Symbol) +v0 := lang.NewSymbol("ifn?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements IFn. Note that many data structures\n (e.g. sets and maps) implement IFn", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6209), lang.NewKeyword("end-line"), int(6209))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -40867,7 +39985,7 @@ if v0.Meta() != nil { } // indexed? { -v0 := lang.NewSymbol("indexed?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return true if coll implements Indexed, indicating efficient lookup by index", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6306), lang.NewKeyword("end-line"), int(6306))).(*lang.Symbol) +v0 := lang.NewSymbol("indexed?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return true if coll implements Indexed, indicating efficient lookup by index", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6263), lang.NewKeyword("end-line"), int(6263))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -40931,7 +40049,7 @@ return v19 v2 := v1 _ = v2 } -v0 := lang.NewSymbol("infinite?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns true if num is negative or positive infinity, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)), lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(8020), lang.NewKeyword("end-line"), int(8020))).(*lang.Symbol) +v0 := lang.NewSymbol("infinite?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns true if num is negative or positive infinity, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)), lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7977), lang.NewKeyword("end-line"), int(7977))).(*lang.Symbol) var v3 lang.FnFunc v3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -40949,7 +40067,7 @@ if v0.Meta() != nil { } // inst-ms { -v0 := lang.NewSymbol("inst-ms").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("inst"))), lang.NewKeyword("doc"), "Return the number of milliseconds since January 1, 1970, 00:00:00 GMT", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6874), lang.NewKeyword("end-line"), int(6874))).(*lang.Symbol) +v0 := lang.NewSymbol("inst-ms").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("inst"))), lang.NewKeyword("doc"), "Return the number of milliseconds since January 1, 1970, 00:00:00 GMT", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6831), lang.NewKeyword("end-line"), int(6831))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -40967,7 +40085,7 @@ if v0.Meta() != nil { } // inst? { -v0 := lang.NewSymbol("inst?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x satisfies Inst", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6880), lang.NewKeyword("end-line"), int(6880))).(*lang.Symbol) +v0 := lang.NewSymbol("inst?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x satisfies Inst", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6837), lang.NewKeyword("end-line"), int(6837))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -41544,7 +40662,7 @@ if v0.Meta() != nil { } // intern { -v0 := lang.NewSymbol("intern").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name"), lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Finds or creates a var named by the symbol name in the namespace\n ns (which can be a symbol or a namespace), setting its root binding\n to val if supplied. The namespace must exist. The var will adopt any\n metadata from the name symbol. Returns the var.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6354), lang.NewKeyword("end-line"), int(6354))).(*lang.Symbol) +v0 := lang.NewSymbol("intern").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name"), lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Finds or creates a var named by the symbol name in the namespace\n ns (which can be a symbol or a namespace), setting its root binding\n to val if supplied. The namespace must exist. The var will adopt any\n metadata from the name symbol. Returns the var.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6311), lang.NewKeyword("end-line"), int(6311))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -41769,13 +40887,13 @@ if v0.Meta() != nil { } // into { -v0 := lang.NewSymbol("into").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("to")), lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("from")), lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("xform"), lang.NewSymbol("from"))), lang.NewKeyword("doc"), "Returns a new coll consisting of to with all of the items of\n from conjoined. A transducer may be supplied.\n (into x) returns x. (into) returns [].", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6965), lang.NewKeyword("end-line"), int(6965))).(*lang.Symbol) +v0 := lang.NewSymbol("into").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("to")), lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("from")), lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("xform"), lang.NewSymbol("from"))), lang.NewKeyword("doc"), "Returns a new coll consisting of to with all of the items of\n from conjoined. A transducer may be supplied.\n (into x) returns x. (into) returns [].", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6922), lang.NewKeyword("end-line"), int(6922))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: v3 := lang.NewVector() -v4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6971), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(6971), lang.NewKeyword("end-column"), int(8)) +v4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6928), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(6928), lang.NewKeyword("end-column"), int(8)) v5, err := lang.WithMeta(v3, v4.(lang.IPersistentMap)) if err != nil { panic(err) @@ -41912,7 +41030,7 @@ return v23 panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) -v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6980), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(6982), lang.NewKeyword("end-column"), int(44)) +v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6937), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(6939), lang.NewKeyword("end-column"), int(44)) v19, err := lang.WithMeta(v17, v18.(lang.IPersistentMap)) if err != nil { panic(err) @@ -42368,118 +41486,9 @@ if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// is-annotation? -{ -v0 := lang.NewSymbol("is-annotation?").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5471), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(5471), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("class?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -var v4 any = v8 -_ = v4 -var v10 any -if lang.IsTruthy(v4) { -v11, _ := lang.FieldOrMethod(java.lang.annotation17.Annotation, "isAssignableFrom") -if reflect.TypeOf(v11).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("isAssignableFrom is not a function"))) -} -v12 := lang.Apply(v11, []any{v3}) -v10 = v12 -} else { -v10 = v4 -} -return v10 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// is-runtime-annotation? -{ -v0 := lang.NewSymbol("is-runtime-annotation?").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5475), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(5475), lang.NewKeyword("end-column"), int(29), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("boolean")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("is-annotation?")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v3}) -var v7 any = v11 -_ = v7 -var v13 any -if lang.IsTruthy(v7) { -v15, _ := lang.FieldOrMethod(v3, "getAnnotation") -if reflect.TypeOf(v15).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("getAnnotation is not a function"))) -} -v16 := lang.Apply(v15, []any{java.lang.annotation17.Retention}) -var v14 any = v16 -_ = v14 -var v18 any -if lang.IsTruthy(v14) { -var v19 any = v14 -_ = v19 -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("=")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24, ok := lang.FieldOrMethod(v19, "value") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v19, "value"))) -} -var v25 any -switch reflect.TypeOf(v24).Kind() { -case reflect.Func: - v25 = lang.Apply(v24, nil) -default: - v25 = v24 -} -v26 := lang.Apply(v23, []any{v25, nil}) -v18 = v26 -} else { -v18 = nil -} -v13 = v18 -} else { -v13 = v7 -} -v7 := lang.Apply(v6, []any{v13}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} // isa? { -v0 := lang.NewSymbol("isa?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("child"), lang.NewSymbol("parent")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("child"), lang.NewSymbol("parent"))), lang.NewKeyword("doc"), "Returns true if (= child parent), or child is directly or indirectly derived from\n parent, either via a Java type inheritance relationship or a\n relationship established via derive. h must be a hierarchy obtained\n from make-hierarchy, if not supplied defaults to the global\n hierarchy", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5586), lang.NewKeyword("end-line"), int(5586))).(*lang.Symbol) +v0 := lang.NewSymbol("isa?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("child"), lang.NewSymbol("parent")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("child"), lang.NewSymbol("parent"))), lang.NewKeyword("doc"), "Returns true if (= child parent), or child is directly or indirectly derived from\n parent, either via a Java type inheritance relationship or a\n relationship established via derive. h must be a hierarchy obtained\n from make-hierarchy, if not supplied defaults to the global\n hierarchy", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5543), lang.NewKeyword("end-line"), int(5543))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -42607,7 +41616,7 @@ v42 := lang.Apply(v41, []any{v37}) v43 := lang.Apply(v40, []any{v42, v5}) return v43 }) -v37 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5599), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(5599), lang.NewKeyword("end-column"), int(71)) +v37 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5556), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(5556), lang.NewKeyword("end-column"), int(71)) v38, err := lang.WithMeta(v36, v37.(lang.IPersistentMap)) if err != nil { panic(err) @@ -42793,7 +41802,7 @@ if v0.Meta() != nil { } // iteration { -v0 := lang.NewSymbol("iteration").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("step"), lang.NewSymbol("&"), lang.NewMap(lang.NewKeyword("keys"), lang.NewVector(lang.NewSymbol("somef"), lang.NewSymbol("vf"), lang.NewSymbol("kf"), lang.NewSymbol("initk")), lang.NewKeyword("or"), lang.NewMap(lang.NewSymbol("vf"), lang.NewSymbol("identity"), lang.NewSymbol("kf"), lang.NewSymbol("identity"), lang.NewSymbol("somef"), lang.NewSymbol("some?"), lang.NewSymbol("initk"), nil)))), lang.NewKeyword("doc"), "Creates a seqable/reducible via repeated calls to step,\n a function of some (continuation token) 'k'. The first call to step\n will be passed initk, returning 'ret'. Iff (somef ret) is true,\n (vf ret) will be included in the iteration, else iteration will\n terminate and vf/kf will not be called. If (kf ret) is non-nil it\n will be passed to the next step call, else iteration will terminate.\n\n This can be used e.g. to consume APIs that return paginated or batched data.\n\n step - (possibly impure) fn of 'k' -> 'ret'\n\n :somef - fn of 'ret' -> logical true/false, default 'some?'\n :vf - fn of 'ret' -> 'v', a value produced by the iteration, default 'identity'\n :kf - fn of 'ret' -> 'next-k' or nil (signaling 'do not continue'), default 'identity'\n :initk - the first value passed to step, default 'nil'\n\n It is presumed that step with non-initk is unreproducible/non-idempotent.\n If step with initk is unreproducible it is on the consumer to not consume twice.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7759), lang.NewKeyword("end-line"), int(7759))).(*lang.Symbol) +v0 := lang.NewSymbol("iteration").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("step"), lang.NewSymbol("&"), lang.NewMap(lang.NewKeyword("keys"), lang.NewVector(lang.NewSymbol("somef"), lang.NewSymbol("vf"), lang.NewSymbol("kf"), lang.NewSymbol("initk")), lang.NewKeyword("or"), lang.NewMap(lang.NewSymbol("vf"), lang.NewSymbol("identity"), lang.NewSymbol("kf"), lang.NewSymbol("identity"), lang.NewSymbol("somef"), lang.NewSymbol("some?"), lang.NewSymbol("initk"), nil)))), lang.NewKeyword("doc"), "Creates a seqable/reducible via repeated calls to step,\n a function of some (continuation token) 'k'. The first call to step\n will be passed initk, returning 'ret'. Iff (somef ret) is true,\n (vf ret) will be included in the iteration, else iteration will\n terminate and vf/kf will not be called. If (kf ret) is non-nil it\n will be passed to the next step call, else iteration will terminate.\n\n This can be used e.g. to consume APIs that return paginated or batched data.\n\n step - (possibly impure) fn of 'k' -> 'ret'\n\n :somef - fn of 'ret' -> logical true/false, default 'some?'\n :vf - fn of 'ret' -> 'v', a value produced by the iteration, default 'identity'\n :kf - fn of 'ret' -> 'next-k' or nil (signaling 'do not continue'), default 'identity'\n :initk - the first value passed to step, default 'nil'\n\n It is presumed that step with non-initk is unreproducible/non-idempotent.\n If step with initk is unreproducible it is on the consumer to not consume twice.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7716), lang.NewKeyword("end-line"), int(7716))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -42922,7 +41931,7 @@ if v62.IsMacro() { } v63 := v62.Get() v64 := lang.NewVector(nil) -v65 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7786), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(7786), lang.NewKeyword("end-column"), int(11)) +v65 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7743), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(7743), lang.NewKeyword("end-column"), int(11)) v66, err := lang.WithMeta(v64, v65.(lang.IPersistentMap)) if err != nil { panic(err) @@ -42982,7 +41991,7 @@ return v70 v68 := v67 _ = v68 } -v68 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7787), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(7791), lang.NewKeyword("end-column"), int(51)) +v68 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7744), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(7748), lang.NewKeyword("end-column"), int(51)) v69, err := lang.WithMeta(v67, v68.(lang.IPersistentMap)) if err != nil { panic(err) @@ -42997,7 +42006,7 @@ if v74.IsMacro() { } v75 := v74.Get() v76 := lang.NewVector(nil, nil, nil) -v77 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7794), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(7794), lang.NewKeyword("end-column"), int(22)) +v77 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7751), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(7751), lang.NewKeyword("end-column"), int(22)) v78, err := lang.WithMeta(v76, v77.(lang.IPersistentMap)) if err != nil { panic(err) @@ -43079,7 +42088,7 @@ if v0.Meta() != nil { } // iterator-seq { -v0 := lang.NewSymbol("iterator-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("iter"))), lang.NewKeyword("doc"), "Returns a seq on a java.util.Iterator. Note that most collections\n providing iterators implement Iterable and thus support seq directly.\n Seqs cache values, thus iterator-seq should not be used on any\n iterator that repeatedly returns the same mutable object.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5743), lang.NewKeyword("end-line"), int(5743))).(*lang.Symbol) +v0 := lang.NewSymbol("iterator-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("iter"))), lang.NewKeyword("doc"), "Returns a seq on a java.util.Iterator. Note that most collections\n providing iterators implement Iterable and thus support seq directly.\n Seqs cache values, thus iterator-seq should not be used on any\n iterator that repeatedly returns the same mutable object.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5700), lang.NewKeyword("end-line"), int(5700))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -43610,7 +42619,7 @@ if v0.Meta() != nil { } // keep { -v0 := lang.NewSymbol("keep").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the non-nil results of (f item). Note,\n this means false return values will be included. f must be free of\n side-effects. Returns a transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7382), lang.NewKeyword("end-line"), int(7382))).(*lang.Symbol) +v0 := lang.NewSymbol("keep").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the non-nil results of (f item). Note,\n this means false return values will be included. f must be free of\n side-effects. Returns a transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7339), lang.NewKeyword("end-line"), int(7339))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -43657,14 +42666,14 @@ return v12 panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) -v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7390), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7397), lang.NewKeyword("end-column"), int(31)) +v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7347), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7354), lang.NewKeyword("end-column"), int(31)) v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) if err != nil { panic(err) } return v8 }) -v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7389), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7397), lang.NewKeyword("end-column"), int(32)) +v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7346), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7354), lang.NewKeyword("end-column"), int(32)) v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) if err != nil { panic(err) @@ -43905,7 +42914,7 @@ if v0.Meta() != nil { } // keep-indexed { -v0 := lang.NewSymbol("keep-indexed").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the non-nil results of (f index item). Note,\n this means false return values will be included. f must be free of\n side-effects. Returns a stateful transducer when no collection is\n provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7415), lang.NewKeyword("end-line"), int(7415))).(*lang.Symbol) +v0 := lang.NewSymbol("keep-indexed").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the non-nil results of (f index item). Note,\n this means false return values will be included. f must be free of\n side-effects. Returns a stateful transducer when no collection is\n provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7372), lang.NewKeyword("end-line"), int(7372))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -43986,14 +42995,14 @@ return v27 panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) -v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7425), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7433), lang.NewKeyword("end-column"), int(33)) +v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7382), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7390), lang.NewKeyword("end-column"), int(33)) v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) if err != nil { panic(err) } return v14 }) -v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7423), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7433), lang.NewKeyword("end-column"), int(35)) +v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7380), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7390), lang.NewKeyword("end-column"), int(35)) v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) if err != nil { panic(err) @@ -44461,7 +43470,7 @@ if v0.Meta() != nil { } // letfn { -v0 := lang.NewSymbol("letfn").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fnspecs"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "fnspec ==> (fname [params*] exprs) or (fname ([params*] exprs)+)\n\n Takes a vector of function specs and a body, and generates a set of\n bindings of functions to their names. All of the names are available\n in all of the definitions of the functions, as well as the body.", lang.NewKeyword("forms"), lang.NewVector(lang.NewList(lang.NewSymbol("letfn"), lang.NewVector(lang.NewSymbol("fnspecs*")), lang.NewSymbol("exprs*"))), lang.NewKeyword("url"), nil, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6588), lang.NewKeyword("end-line"), int(6588), lang.NewKeyword("special-form"), true)).(*lang.Symbol) +v0 := lang.NewSymbol("letfn").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fnspecs"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "fnspec ==> (fname [params*] exprs) or (fname ([params*] exprs)+)\n\n Takes a vector of function specs and a body, and generates a set of\n bindings of functions to their names. All of the names are available\n in all of the definitions of the functions, as well as the body.", lang.NewKeyword("forms"), lang.NewVector(lang.NewList(lang.NewSymbol("letfn"), lang.NewVector(lang.NewSymbol("fnspecs*")), lang.NewSymbol("exprs*"))), lang.NewKeyword("url"), nil, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6545), lang.NewKeyword("end-line"), int(6545), lang.NewKeyword("special-form"), true)).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -44544,7 +43553,7 @@ v40 := v39.Get() v41 := lang.Apply(v40, []any{lang.NewSymbol("glojure.core/fn"), v37}) return v41 }) -v37 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6598), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(6598), lang.NewKeyword("end-column"), int(47)) +v37 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6555), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(6555), lang.NewKeyword("end-column"), int(47)) v38, err := lang.WithMeta(v36, v37.(lang.IPersistentMap)) if err != nil { panic(err) @@ -44566,7 +43575,7 @@ if v0.Meta() != nil { } // libspec? { -v0 := lang.NewSymbol("libspec?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is a libspec", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5891), lang.NewKeyword("end-line"), int(5891), lang.NewKeyword("private"), true)).(*lang.Symbol) +v0 := lang.NewSymbol("libspec?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is a libspec", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5848), lang.NewKeyword("end-line"), int(5848), lang.NewKeyword("private"), true)).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -45132,7 +44141,7 @@ if v0.Meta() != nil { } // list? { -v0 := lang.NewSymbol("list?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements IPersistentList", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6241), lang.NewKeyword("end-line"), int(6241))).(*lang.Symbol) +v0 := lang.NewSymbol("list?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements IPersistentList", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6198), lang.NewKeyword("end-line"), int(6198))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -45156,7 +44165,7 @@ if v0.Meta() != nil { } // load { -v0 := lang.NewSymbol("load").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("paths"))), lang.NewKeyword("doc"), "Loads Clojure code from resources in classpath. A path is interpreted as\n classpath-relative if it begins with a slash or relative to the root\n directory for the current namespace otherwise.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("redef"), true, lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6138), lang.NewKeyword("end-line"), int(6138))).(*lang.Symbol) +v0 := lang.NewSymbol("load").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("paths"))), lang.NewKeyword("doc"), "Loads Clojure code from resources in classpath. A path is interpreted as\n classpath-relative if it begins with a slash or relative to the root\n directory for the current namespace otherwise.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("redef"), true, lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6095), lang.NewKeyword("end-line"), int(6095))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -45199,7 +44208,7 @@ v20 := lang.Apply(v19, []any{v11}) var v18 any = v20 _ = v18 var v23 any -v24 := lang.Apply(strings18.HasPrefix, []any{v22, "/"}) +v24 := lang.Apply(strings14.HasPrefix, []any{v22, "/"}) if lang.IsTruthy(v24) { v23 = v22 } else { @@ -45334,7 +44343,7 @@ if v88.IsMacro() { v89 := v88.Get() v90 := lang.Apply(v89, nil) }() -v91 := lang.Apply(strings18.TrimPrefix, []any{v22, "/"}) +v91 := lang.Apply(strings14.TrimPrefix, []any{v22, "/"}) v92, _ := lang.FieldOrMethod(runtime5.RT, "Load") if reflect.TypeOf(v92).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Load is not a function"))) @@ -45441,7 +44450,7 @@ v36 := lang.Apply(v35, []any{v25}) var v32 any = v36 _ = v32 var v39 any -v40 := lang.Apply(strings18.HasPrefix, []any{v38, "/"}) +v40 := lang.Apply(strings14.HasPrefix, []any{v38, "/"}) if lang.IsTruthy(v40) { v39 = v38 } else { @@ -45576,7 +44585,7 @@ if v104.IsMacro() { v105 := v104.Get() v106 := lang.Apply(v105, nil) }() -v107 := lang.Apply(strings18.TrimPrefix, []any{v38, "/"}) +v107 := lang.Apply(strings14.TrimPrefix, []any{v38, "/"}) v108, _ := lang.FieldOrMethod(runtime5.RT, "Load") if reflect.TypeOf(v108).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Load is not a function"))) @@ -45624,7 +44633,7 @@ if v0.Meta() != nil { } // load-all { -v0 := lang.NewSymbol("load-all").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"), lang.NewSymbol("need-ns"), lang.NewSymbol("require"))), lang.NewKeyword("doc"), "Loads a lib given its name and forces a load of any libs it directly or\n indirectly loads. If need-ns, ensures that the associated namespace\n exists after loading. If require, records the load so any duplicate loads\n can be skipped.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5935), lang.NewKeyword("end-line"), int(5935), lang.NewKeyword("private"), true)).(*lang.Symbol) +v0 := lang.NewSymbol("load-all").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"), lang.NewSymbol("need-ns"), lang.NewSymbol("require"))), lang.NewKeyword("doc"), "Loads a lib given its name and forces a load of any libs it directly or\n indirectly loads. If need-ns, ensures that the associated namespace\n exists after loading. If require, records the load so any duplicate loads\n can be skipped.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5892), lang.NewKeyword("end-line"), int(5892), lang.NewKeyword("private"), true)).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 3 { @@ -45672,7 +44681,7 @@ v21 := v20.Get() v22 := lang.Apply(v18, []any{v21, v14, v15}) return v22 }) -v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5942), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(5942), lang.NewKeyword("end-column"), int(47)) +v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5899), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(5899), lang.NewKeyword("end-column"), int(47)) v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) if err != nil { panic(err) @@ -45759,7 +44768,7 @@ if v0.Meta() != nil { } // load-data-reader-file { -v0 := lang.NewSymbol("load-data-reader-file").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7879), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7879), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("mappings"), lang.NewSymbol("url"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v0 := lang.NewSymbol("load-data-reader-file").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7836), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7836), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("mappings"), lang.NewSymbol("url"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { @@ -45778,8 +44787,8 @@ case reflect.Func: default: v7 = v6 } -v8 := lang.Apply(java.io.InputStreamReader20., []any{v7, "UTF-8"}) -v9 := lang.Apply(glojure.lang.LineNumberingPushbackReader19., []any{v8}) +v8 := lang.Apply(java.io.InputStreamReader16., []any{v7, "UTF-8"}) +v9 := lang.Apply(glojure.lang.LineNumberingPushbackReader15., []any{v8}) var v5 any = v9 _ = v5 var v11 any @@ -45854,7 +44863,7 @@ if reflect.TypeOf(v35).Kind() != reflect.Func { v36 := lang.Apply(v35, []any{"cljc"}) if lang.IsTruthy(v36) { v37 := lang.NewMap(lang.NewKeyword("eof"), nil, lang.NewKeyword("read-cond"), lang.NewKeyword("allow")) -v38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7885), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7885), lang.NewKeyword("end-column"), int(52)) +v38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7842), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7842), lang.NewKeyword("end-column"), int(52)) v39, err := lang.WithMeta(v37, v38.(lang.IPersistentMap)) if err != nil { panic(err) @@ -45862,7 +44871,7 @@ if err != nil { v32 = v39 } else { v40 := lang.NewMap(lang.NewKeyword("eof"), nil) -v41 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7886), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7886), lang.NewKeyword("end-column"), int(34)) +v41 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7843), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7843), lang.NewKeyword("end-column"), int(34)) v42, err := lang.WithMeta(v40, v41.(lang.IPersistentMap)) if err != nil { panic(err) @@ -45910,7 +44919,7 @@ if v62.IsMacro() { v63 := v62.Get() v64 := lang.Apply(v63, []any{"Not a valid data-reader map"}) v65 := lang.NewMap(lang.NewKeyword("url"), v4) -v66 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7890), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(7890), lang.NewKeyword("end-column"), int(36)) +v66 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7847), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(7847), lang.NewKeyword("end-column"), int(36)) v67, err := lang.WithMeta(v65, v66.(lang.IPersistentMap)) if err != nil { panic(err) @@ -45984,7 +44993,7 @@ if v100.IsMacro() { v101 := v100.Get() v102 := lang.Apply(v101, []any{"Invalid form in data-reader file"}) v103 := lang.NewMap(lang.NewKeyword("url"), v4, lang.NewKeyword("form"), v76) -v104 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7895), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(7896), lang.NewKeyword("end-column"), int(38)) +v104 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7852), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(7853), lang.NewKeyword("end-column"), int(38)) v105, err := lang.WithMeta(v103, v104.(lang.IPersistentMap)) if err != nil { panic(err) @@ -46036,7 +45045,7 @@ if v115.IsMacro() { } v116 := v115.Get() v117 := lang.NewMap(lang.NewKeyword("url"), v4, lang.NewKeyword("conflict"), v76, lang.NewKeyword("mappings"), v73) -v118 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7901), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(7903), lang.NewKeyword("end-column"), int(44)) +v118 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7858), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(7860), lang.NewKeyword("end-column"), int(44)) v119, err := lang.WithMeta(v117, v118.(lang.IPersistentMap)) if err != nil { panic(err) @@ -46056,7 +45065,7 @@ v123 := v122.Get() v124 := lang.Apply(v123, []any{v73, v76, v107}) return v124 }) -v73 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7892), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(7904), lang.NewKeyword("end-column"), int(32)) +v73 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7849), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(7861), lang.NewKeyword("end-column"), int(32)) v74, err := lang.WithMeta(v72, v73.(lang.IPersistentMap)) if err != nil { panic(err) @@ -46076,7 +45085,7 @@ if v0.Meta() != nil { } // load-data-readers { -v0 := lang.NewSymbol("load-data-readers").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7908), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7908), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v0 := lang.NewSymbol("load-data-readers").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7865), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7865), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { @@ -46117,7 +45126,7 @@ v18 := lang.Apply(v17, nil) v19 := lang.Apply(v11, []any{v14, v8, v18}) return v19 }) -v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7910), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(7912), lang.NewKeyword("end-column"), int(57)) +v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7867), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(7869), lang.NewKeyword("end-column"), int(57)) v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) if err != nil { panic(err) @@ -46141,7 +45150,7 @@ if v0.Meta() != nil { } // load-lib { -v0 := lang.NewSymbol("load-lib").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("prefix"), lang.NewSymbol("lib"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Loads a lib with options", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5947), lang.NewKeyword("end-line"), int(5947), lang.NewKeyword("private"), true)).(*lang.Symbol) +v0 := lang.NewSymbol("load-lib").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("prefix"), lang.NewSymbol("lib"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Loads a lib with options", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5904), lang.NewKeyword("end-line"), int(5904), lang.NewKeyword("private"), true)).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -46182,7 +45191,7 @@ if v20.IsMacro() { } v21 := v20.Get() v22 := lang.Apply(v21, []any{lang.NewChar(46)}) -v23 := lang.Apply(strings18.Index, []any{v18, v22}) +v23 := lang.Apply(strings14.Index, []any{v18, v22}) v24 := lang.Apply(v14, []any{v23}) v11 = v24 } else { @@ -46445,7 +45454,7 @@ v131 := v130.Get() v132 := lang.Apply(v131, []any{v126}) return v132 }) -v126 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5961), lang.NewKeyword("column"), int(48), lang.NewKeyword("end-line"), int(5961), lang.NewKeyword("end-column"), int(88)) +v126 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5918), lang.NewKeyword("column"), int(48), lang.NewKeyword("end-line"), int(5918), lang.NewKeyword("end-column"), int(88)) v127, err := lang.WithMeta(v125, v126.(lang.IPersistentMap)) if err != nil { panic(err) @@ -47014,7 +46023,7 @@ if v0.Meta() != nil { } // load-libs { -v0 := lang.NewSymbol("load-libs").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Loads libs, interpreting libspecs, prefix lists, and flags for\n forwarding to load-lib", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5994), lang.NewKeyword("end-line"), int(5994), lang.NewKeyword("private"), true)).(*lang.Symbol) +v0 := lang.NewSymbol("load-libs").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Loads libs, interpreting libspecs, prefix lists, and flags for\n forwarding to load-lib", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5951), lang.NewKeyword("end-line"), int(5951), lang.NewKeyword("private"), true)).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -47077,7 +46086,7 @@ v32 := lang.Apply(v24, []any{v31, v21}) var v21 any = v32 _ = v21 v35 := lang.CreatePersistentTreeSet(lang.NewKeyword("as"), lang.NewKeyword("reload"), lang.NewKeyword("reload-all"), lang.NewKeyword("require"), lang.NewKeyword("use"), lang.NewKeyword("verbose"), lang.NewKeyword("refer"), lang.NewKeyword("as-alias")) -v36 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6002), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(6002), lang.NewKeyword("end-column"), int(86)) +v36 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5959), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(5959), lang.NewKeyword("end-column"), int(86)) v37, err := lang.WithMeta(v35, v36.(lang.IPersistentMap)) if err != nil { panic(err) @@ -47871,7 +46880,7 @@ if v0.Meta() != nil { } // load-one { -v0 := lang.NewSymbol("load-one").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"), lang.NewSymbol("need-ns"), lang.NewSymbol("require"))), lang.NewKeyword("doc"), "Loads a lib given its name. If need-ns, ensures that the associated\n namespace exists after loading. If require, records the load so any\n duplicate loads can be skipped.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5922), lang.NewKeyword("end-line"), int(5922), lang.NewKeyword("private"), true)).(*lang.Symbol) +v0 := lang.NewSymbol("load-one").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"), lang.NewSymbol("need-ns"), lang.NewSymbol("require"))), lang.NewKeyword("doc"), "Loads a lib given its name. If need-ns, ensures that the associated\n namespace exists after loading. If require, records the load so any\n duplicate loads can be skipped.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5879), lang.NewKeyword("end-line"), int(5879), lang.NewKeyword("private"), true)).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 3 { @@ -48008,8 +47017,8 @@ v2 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v5 := lang.Apply(java.io.StringReader21., []any{v3}) -v6 := lang.Apply(glojure.lang.LineNumberingPushbackReader19., []any{v5}) +v5 := lang.Apply(java.io.StringReader17., []any{v3}) +v6 := lang.Apply(glojure.lang.LineNumberingPushbackReader15., []any{v5}) var v4 any = v6 _ = v4 v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) @@ -48029,7 +47038,7 @@ if v0.Meta() != nil { } // loaded-libs { -v0 := lang.NewSymbol("loaded-libs").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Returns a sorted set of symbols naming the currently loaded libs", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6133), lang.NewKeyword("end-line"), int(6133))).(*lang.Symbol) +v0 := lang.NewSymbol("loaded-libs").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Returns a sorted set of symbols naming the currently loaded libs", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6090), lang.NewKeyword("end-line"), int(6090))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { @@ -49333,32 +48342,32 @@ if v0.Meta() != nil { } // make-hierarchy { -v0 := lang.NewSymbol("make-hierarchy").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Creates a hierarchy object for use with derive, isa? etc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5550), lang.NewKeyword("end-line"), int(5550))).(*lang.Symbol) +v0 := lang.NewSymbol("make-hierarchy").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Creates a hierarchy object for use with derive, isa? etc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5507), lang.NewKeyword("end-line"), int(5507))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := lang.NewMap() -v4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5554), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(5554), lang.NewKeyword("end-column"), int(17)) +v4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5511), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(5511), lang.NewKeyword("end-column"), int(17)) v5, err := lang.WithMeta(v3, v4.(lang.IPersistentMap)) if err != nil { panic(err) } v6 := lang.NewMap() -v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5554), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(5554), lang.NewKeyword("end-column"), int(33)) +v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5511), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(5511), lang.NewKeyword("end-column"), int(33)) v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) if err != nil { panic(err) } v9 := lang.NewMap() -v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5554), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(5554), lang.NewKeyword("end-column"), int(47)) +v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5511), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(5511), lang.NewKeyword("end-column"), int(47)) v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) if err != nil { panic(err) } v12 := lang.NewMap(lang.NewKeyword("parents"), v5, lang.NewKeyword("descendants"), v8, lang.NewKeyword("ancestors"), v11) -v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5554), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(5554), lang.NewKeyword("end-column"), int(48)) +v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5511), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(5511), lang.NewKeyword("end-column"), int(48)) v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) if err != nil { panic(err) @@ -49983,7 +48992,7 @@ if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -v7 := lang.Apply(v6, []any{java.util22.Map$Entry, v3}) +v7 := lang.Apply(v6, []any{java.util18.Map$Entry, v3}) return v7 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -49994,7 +49003,7 @@ if v0.Meta() != nil { } // map-indexed { -v0 := lang.NewSymbol("map-indexed").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence consisting of the result of applying f to 0\n and the first item of coll, followed by applying f to 1 and the second\n item in coll, etc, until coll is exhausted. Thus function f should\n accept 2 arguments, index and item. Returns a stateful transducer when\n no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7352), lang.NewKeyword("end-line"), int(7352))).(*lang.Symbol) +v0 := lang.NewSymbol("map-indexed").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence consisting of the result of applying f to 0\n and the first item of coll, followed by applying f to 1 and the second\n item in coll, etc, until coll is exhausted. Thus function f should\n accept 2 arguments, index and item. Returns a stateful transducer when\n no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7309), lang.NewKeyword("end-line"), int(7309))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -50058,14 +49067,14 @@ return v24 panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) -v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7363), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7367), lang.NewKeyword("end-column"), int(48)) +v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7320), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7324), lang.NewKeyword("end-column"), int(48)) v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) if err != nil { panic(err) } return v14 }) -v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7361), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7367), lang.NewKeyword("end-column"), int(50)) +v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7318), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7324), lang.NewKeyword("end-column"), int(50)) v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) if err != nil { panic(err) @@ -50185,7 +49194,7 @@ if v0.Meta() != nil { } // mapv { -v0 := lang.NewSymbol("mapv").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2"), lang.NewSymbol("c3")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2"), lang.NewSymbol("c3"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Returns a vector consisting of the result of applying f to the\n set of first items of each coll, followed by applying f to the set\n of second items in each coll, until any one of the colls is\n exhausted. Any remaining items in other colls are ignored. Function\n f should accept number-of-colls arguments.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6986), lang.NewKeyword("end-line"), int(6986))).(*lang.Symbol) +v0 := lang.NewSymbol("mapv").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2"), lang.NewSymbol("c3")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2"), lang.NewSymbol("c3"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Returns a vector consisting of the result of applying f to the\n set of first items of each coll, followed by applying f to the set\n of second items in each coll, until any one of the colls is\n exhausted. Any remaining items in other colls are ignored. Function\n f should accept number-of-colls arguments.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6943), lang.NewKeyword("end-line"), int(6943))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -50221,7 +49230,7 @@ v17 := lang.Apply(v3, []any{v13}) v18 := lang.Apply(v16, []any{v12, v17}) return v18 }) -v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6995), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(6995), lang.NewKeyword("end-column"), int(43)) +v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6952), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(6952), lang.NewKeyword("end-column"), int(43)) v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) if err != nil { panic(err) @@ -50233,7 +49242,7 @@ if v15.IsMacro() { } v16 := v15.Get() v17 := lang.NewVector() -v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6995), lang.NewKeyword("column"), int(56), lang.NewKeyword("end-line"), int(6995), lang.NewKeyword("end-column"), int(57)) +v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6952), lang.NewKeyword("column"), int(56), lang.NewKeyword("end-line"), int(6952), lang.NewKeyword("end-column"), int(57)) v19, err := lang.WithMeta(v17, v18.(lang.IPersistentMap)) if err != nil { panic(err) @@ -50253,7 +49262,7 @@ if v7.IsMacro() { } v8 := v7.Get() v9 := lang.NewVector() -v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6998), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(6998), lang.NewKeyword("end-column"), int(13)) +v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6955), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(6955), lang.NewKeyword("end-column"), int(13)) v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) if err != nil { panic(err) @@ -50279,7 +49288,7 @@ if v8.IsMacro() { } v9 := v8.Get() v10 := lang.NewVector() -v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7000), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(7000), lang.NewKeyword("end-column"), int(13)) +v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6957), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(6957), lang.NewKeyword("end-column"), int(13)) v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) if err != nil { panic(err) @@ -50309,7 +49318,7 @@ if v9.IsMacro() { } v10 := v9.Get() v11 := lang.NewVector() -v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7002), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(7002), lang.NewKeyword("end-column"), int(13)) +v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6959), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(6959), lang.NewKeyword("end-column"), int(13)) v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) if err != nil { panic(err) @@ -50930,7 +49939,7 @@ if v0.Meta() != nil { } // max-mask-bits { -v0 := lang.NewSymbol("max-mask-bits").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6644), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(6644), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v0 := lang.NewSymbol("max-mask-bits").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6601), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(6601), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) v1 := ns.InternWithValue(v0, int64(13), true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) @@ -50938,7 +49947,7 @@ if v0.Meta() != nil { } // max-switch-table-size { -v0 := lang.NewSymbol("max-switch-table-size").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6645), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(6645), lang.NewKeyword("end-column"), int(36), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v0 := lang.NewSymbol("max-switch-table-size").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6602), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(6602), lang.NewKeyword("end-column"), int(36), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) v1 := ns.InternWithValue(v0, int64(8192), true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) @@ -51186,7 +50195,7 @@ if v0.Meta() != nil { } // maybe-min-hash { -v0 := lang.NewSymbol("maybe-min-hash").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("hashes"))), lang.NewKeyword("doc"), "takes a collection of hashes and returns [shift mask] or nil if none found", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6647), lang.NewKeyword("end-line"), int(6647), lang.NewKeyword("private"), true)).(*lang.Symbol) +v0 := lang.NewSymbol("maybe-min-hash").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("hashes"))), lang.NewKeyword("doc"), "takes a collection of hashes and returns [shift mask] or nil if none found", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6604), lang.NewKeyword("end-line"), int(6604), lang.NewKeyword("private"), true)).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -51264,7 +50273,7 @@ v37 := v36.Get() v38 := lang.Apply(v37, []any{v13, v18, v34}) return v38 }) -v34 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6652), lang.NewKeyword("column"), int(37), lang.NewKeyword("end-line"), int(6652), lang.NewKeyword("end-column"), int(55)) +v34 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6609), lang.NewKeyword("column"), int(37), lang.NewKeyword("end-line"), int(6609), lang.NewKeyword("end-column"), int(55)) v35, err := lang.WithMeta(v33, v34.(lang.IPersistentMap)) if err != nil { panic(err) @@ -51273,13 +50282,13 @@ v36 := lang.Apply(v32, []any{v35, v3}) v37 := lang.Apply(v26, []any{v29, v36}) return v37 }) -v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6651), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(6652), lang.NewKeyword("end-column"), int(65)) +v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6608), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(6609), lang.NewKeyword("end-column"), int(65)) v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) if err != nil { panic(err) } var v14 lang.FnFunc -{ // function iter__181 +{ // function iter__154 v14 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -51317,7 +50326,7 @@ v33 := lang.Apply(v32, []any{v27}) var v29 any = v33 _ = v29 var v36 lang.FnFunc -{ // function iter__183 +{ // function iter__156 v36 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -51423,7 +50432,7 @@ if v93.IsMacro() { } v94 := v93.Get() v95 := lang.NewVector(v88, v29) -v96 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6655), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(6655), lang.NewKeyword("end-column"), int(26)) +v96 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6612), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(6612), lang.NewKeyword("end-column"), int(26)) v97, err := lang.WithMeta(v95, v96.(lang.IPersistentMap)) if err != nil { panic(err) @@ -51505,7 +50514,7 @@ if v63.IsMacro() { } v64 := v63.Get() v65 := lang.NewVector(v56, v29) -v66 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6655), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(6655), lang.NewKeyword("end-column"), int(26)) +v66 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6612), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(6612), lang.NewKeyword("end-column"), int(26)) v67, err := lang.WithMeta(v65, v66.(lang.IPersistentMap)) if err != nil { panic(err) @@ -51630,7 +50639,7 @@ v27 := lang.Apply(v26, []any{int64(1), v20}) v28 := lang.Apply(v23, []any{v27}) return v28 }) -v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6653), lang.NewKeyword("column"), int(29), lang.NewKeyword("end-line"), int(6653), lang.NewKeyword("end-column"), int(55)) +v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6610), lang.NewKeyword("column"), int(29), lang.NewKeyword("end-line"), int(6610), lang.NewKeyword("end-column"), int(55)) v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) if err != nil { panic(err) @@ -51840,7 +50849,7 @@ if v0.Meta() != nil { } // memoize { -v0 := lang.NewSymbol("memoize").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Returns a memoized version of a referentially transparent function. The\n memoized version of the function keeps a cache of the mapping from arguments\n to results and, when calls with the same arguments are repeated often, has\n higher performance at the expense of higher memory use.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6380), lang.NewKeyword("end-line"), int(6380))).(*lang.Symbol) +v0 := lang.NewSymbol("memoize").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Returns a memoized version of a referentially transparent function. The\n memoized version of the function keeps a cache of the mapping from arguments\n to results and, when calls with the same arguments are repeated often, has\n higher performance at the expense of higher memory use.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6337), lang.NewKeyword("end-line"), int(6337))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -51854,7 +50863,7 @@ if v6.IsMacro() { } v7 := v6.Get() v8 := lang.NewMap() -v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6388), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(6388), lang.NewKeyword("end-column"), int(20)) +v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6345), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(6345), lang.NewKeyword("end-column"), int(20)) v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) if err != nil { panic(err) @@ -51927,7 +50936,7 @@ v25 = v26 return v25 } }) -v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6389), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(6394), lang.NewKeyword("end-column"), int(16)) +v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6346), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(6351), lang.NewKeyword("end-column"), int(16)) v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) if err != nil { panic(err) @@ -52023,7 +51032,7 @@ if v0.Meta() != nil { } // merge-hash-collisions { -v0 := lang.NewSymbol("merge-hash-collisions").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr-sym"), lang.NewSymbol("default"), lang.NewSymbol("tests"), lang.NewSymbol("thens"))), lang.NewKeyword("doc"), "Takes a case expression, default expression, and a sequence of test constants\n and a corresponding sequence of then expressions. Returns a tuple of\n [tests thens skip-check-set] where no tests have the same hash. Each set of\n input test constants with the same hash is replaced with a single test\n constant (the case int), and their respective thens are combined into:\n (condp = expr\n test-1 then-1\n ...\n test-n then-n\n default).\n The skip-check is a set of case ints for which post-switch equivalence\n checking must not be done (the cases holding the above condp thens).", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6690), lang.NewKeyword("end-line"), int(6690), lang.NewKeyword("private"), true)).(*lang.Symbol) +v0 := lang.NewSymbol("merge-hash-collisions").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr-sym"), lang.NewSymbol("default"), lang.NewSymbol("tests"), lang.NewSymbol("thens"))), lang.NewKeyword("doc"), "Takes a case expression, default expression, and a sequence of test constants\n and a corresponding sequence of then expressions. Returns a tuple of\n [tests thens skip-check-set] where no tests have the same hash. Each set of\n input test constants with the same hash is replaced with a single test\n constant (the case int), and their respective thens are combined into:\n (condp = expr\n test-1 then-1\n ...\n test-n then-n\n default).\n The skip-check is a set of case ints for which post-switch equivalence\n checking must not be done (the cases holding the above condp thens).", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6647), lang.NewKeyword("end-line"), int(6647), lang.NewKeyword("private"), true)).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 4 { @@ -52034,7 +51043,7 @@ v4 := args[1] v5 := args[2] v6 := args[3] v9 := lang.NewMap() -v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6704), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(6704), lang.NewKeyword("end-column"), int(27)) +v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6661), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(6661), lang.NewKeyword("end-column"), int(27)) v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) if err != nil { panic(err) @@ -52084,7 +51093,7 @@ if v29.IsMacro() { } v30 := v29.Get() v31 := lang.NewVector() -v32 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6707), lang.NewKeyword("column"), int(102), lang.NewKeyword("end-line"), int(6707), lang.NewKeyword("end-column"), int(103)) +v32 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6664), lang.NewKeyword("column"), int(102), lang.NewKeyword("end-line"), int(6664), lang.NewKeyword("end-column"), int(103)) v33, err := lang.WithMeta(v31, v32.(lang.IPersistentMap)) if err != nil { panic(err) @@ -52105,7 +51114,7 @@ if v40.IsMacro() { v41 := v40.Get() v42 := lang.Apply(v41, []any{v13}) v43 := lang.NewVector(v38, v42) -v44 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6707), lang.NewKeyword("column"), int(106), lang.NewKeyword("end-line"), int(6707), lang.NewKeyword("end-column"), int(128)) +v44 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6664), lang.NewKeyword("column"), int(106), lang.NewKeyword("end-line"), int(6664), lang.NewKeyword("end-column"), int(128)) v45, err := lang.WithMeta(v43, v44.(lang.IPersistentMap)) if err != nil { panic(err) @@ -52182,14 +51191,14 @@ if v28.IsMacro() { v29 := v28.Get() v30 := lang.Apply(v29, []any{v18}) v31 := lang.NewVector(v26, v30) -v32 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6711), lang.NewKeyword("column"), int(56), lang.NewKeyword("end-line"), int(6711), lang.NewKeyword("end-column"), int(93)) +v32 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6668), lang.NewKeyword("column"), int(56), lang.NewKeyword("end-line"), int(6668), lang.NewKeyword("end-column"), int(93)) v33, err := lang.WithMeta(v31, v32.(lang.IPersistentMap)) if err != nil { panic(err) } return v33 }) -v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6711), lang.NewKeyword("column"), int(47), lang.NewKeyword("end-line"), int(6711), lang.NewKeyword("end-column"), int(94)) +v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6668), lang.NewKeyword("column"), int(47), lang.NewKeyword("end-line"), int(6668), lang.NewKeyword("end-column"), int(94)) v19, err := lang.WithMeta(v17, v18.(lang.IPersistentMap)) if err != nil { panic(err) @@ -52250,7 +51259,7 @@ v49 := v48.Get() v50 := lang.Apply(v49, []any{v10, v11, v21}) return v50 }) -v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6710), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(6713), lang.NewKeyword("end-column"), int(42)) +v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6667), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(6670), lang.NewKeyword("end-column"), int(42)) v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) if err != nil { panic(err) @@ -52341,13 +51350,13 @@ v31 = v56 } return v31 }) -v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6715), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(6718), lang.NewKeyword("end-column"), int(45)) +v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6672), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(6675), lang.NewKeyword("end-column"), int(45)) v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) if err != nil { panic(err) } v19 := lang.NewMap() -v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6719), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(6719), lang.NewKeyword("end-column"), int(17)) +v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6676), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(6676), lang.NewKeyword("end-column"), int(17)) v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) if err != nil { panic(err) @@ -52362,7 +51371,7 @@ if v25.IsMacro() { } v26 := v25.Get() v27 := lang.CreatePersistentTreeSet() -v28 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6723), lang.NewKeyword("column"), int(29), lang.NewKeyword("end-line"), int(6723), lang.NewKeyword("end-column"), int(31)) +v28 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6680), lang.NewKeyword("column"), int(29), lang.NewKeyword("end-line"), int(6680), lang.NewKeyword("end-column"), int(31)) v29, err := lang.WithMeta(v27, v28.(lang.IPersistentMap)) if err != nil { panic(err) @@ -52414,7 +51423,7 @@ v51 := lang.Apply(v46, []any{v50}) v52 := lang.Apply(v43, []any{int64(1), v51}) return v52 }) -v40 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6721), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(6721), lang.NewKeyword("end-column"), int(54)) +v40 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6678), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(6678), lang.NewKeyword("end-column"), int(54)) v41, err := lang.WithMeta(v39, v40.(lang.IPersistentMap)) if err != nil { panic(err) @@ -52439,7 +51448,7 @@ if v51.IsMacro() { v52 := v51.Get() v53 := lang.Apply(v52, []any{v12}) v54 := lang.NewVector(v49, v53, v23) -v55 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6724), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(6724), lang.NewKeyword("end-column"), int(40)) +v55 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6681), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(6681), lang.NewKeyword("end-column"), int(40)) v56, err := lang.WithMeta(v54, v55.(lang.IPersistentMap)) if err != nil { panic(err) @@ -54223,7 +53232,7 @@ if v0.Meta() != nil { } // normalize-slurp-opts { -v0 := lang.NewSymbol("normalize-slurp-opts").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7017), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7017), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("opts"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v0 := lang.NewSymbol("normalize-slurp-opts").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6974), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(6974), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("opts"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -54262,7 +53271,7 @@ if v18.IsMacro() { v19 := v18.Get() v20 := lang.Apply(v19, []any{v3}) v21 := lang.NewVector(lang.NewKeyword("encoding"), v20) -v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7022), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(7022), lang.NewKeyword("end-column"), int(30)) +v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6979), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(6979), lang.NewKeyword("end-column"), int(30)) v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) if err != nil { panic(err) @@ -54360,7 +53369,7 @@ if v0.Meta() != nil { } // not-empty { -v0 := lang.NewSymbol("not-empty").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "If coll is empty, returns nil, else coll", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5559), lang.NewKeyword("end-line"), int(5559))).(*lang.Symbol) +v0 := lang.NewSymbol("not-empty").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "If coll is empty, returns nil, else coll", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5516), lang.NewKeyword("end-line"), int(5516))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -54509,7 +53518,7 @@ if v0.Meta() != nil { } // ns { -v0 := lang.NewSymbol("ns").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("docstring?"), lang.NewSymbol("attr-map?"), lang.NewSymbol("references*"))), lang.NewKeyword("doc"), "Sets *ns* to the namespace named by name (unevaluated), creating it\n if needed. references can be zero or more of: (:refer-glojure ...)\n (:require ...) (:use ...) (:import ...) (:load ...) (:gen-class)\n with the syntax of refer-glojure/require/use/import/load/gen-class\n respectively, except the arguments are unevaluated and need not be\n quoted. (:gen-class ...), when supplied, defaults to :name\n corresponding to the ns name, :main true, :impl-ns same as ns, and\n :init-impl-ns true. All options of gen-class are\n supported. The :gen-class directive is ignored when not\n compiling. If :gen-class is not supplied, when compiled only an\n nsname__init.class will be generated. If :refer-glojure is not used, a\n default (refer 'glojure.core) is used. Use of ns is preferred to\n individual calls to in-ns/require/use/import:\n\n (ns foo.bar\n (:refer-glojure :exclude [ancestors printf])\n (:require (glojure.contrib sql combinatorics))\n (:use (my.lib this that))\n (:import (java.util Date Timer Random)\n (java.sql Connection Statement)))", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5785), lang.NewKeyword("end-line"), int(5785))).(*lang.Symbol) +v0 := lang.NewSymbol("ns").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("docstring?"), lang.NewSymbol("attr-map?"), lang.NewSymbol("references*"))), lang.NewKeyword("doc"), "Sets *ns* to the namespace named by name (unevaluated), creating it\n if needed. references can be zero or more of: (:refer-glojure ...)\n (:require ...) (:use ...) (:import ...) (:load ...) (:gen-class)\n with the syntax of refer-glojure/require/use/import/load/gen-class\n respectively, except the arguments are unevaluated and need not be\n quoted. (:gen-class ...), when supplied, defaults to :name\n corresponding to the ns name, :main true, :impl-ns same as ns, and\n :init-impl-ns true. All options of gen-class are\n supported. The :gen-class directive is ignored when not\n compiling. If :gen-class is not supplied, when compiled only an\n nsname__init.class will be generated. If :refer-glojure is not used, a\n default (refer 'glojure.core) is used. Use of ns is preferred to\n individual calls to in-ns/require/use/import:\n\n (ns foo.bar\n (:refer-glojure :exclude [ancestors printf])\n (:require (glojure.contrib sql combinatorics))\n (:use (my.lib this that))\n (:import (java.util Date Timer Random)\n (java.sql Connection Statement)))", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5742), lang.NewKeyword("end-line"), int(5742))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -54614,7 +53623,7 @@ v54 := v53.Get() v55 := lang.Apply(v54, []any{lang.NewSymbol("quote"), v51}) return v55 }) -v51 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5812), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(5812), lang.NewKeyword("end-column"), int(36)) +v51 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5769), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(5769), lang.NewKeyword("end-column"), int(36)) v52, err := lang.WithMeta(v50, v51.(lang.IPersistentMap)) if err != nil { panic(err) @@ -54624,7 +53633,7 @@ v54 := lang.Apply(v34, []any{v46, v53}) v55 := lang.Apply(v31, []any{v54}) return v55 }) -v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5810), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(5812), lang.NewKeyword("end-column"), int(44)) +v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5767), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(5769), lang.NewKeyword("end-column"), int(44)) v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) if err != nil { panic(err) @@ -54795,7 +53804,7 @@ v84 := lang.Apply(v83, []any{v77}) v85 := lang.Apply(v80, []any{lang.NewKeyword("gen-class"), v84}) return v85 }) -v77 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5823), lang.NewKeyword("column"), int(41), lang.NewKeyword("end-line"), int(5823), lang.NewKeyword("end-column"), int(65)) +v77 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5780), lang.NewKeyword("column"), int(41), lang.NewKeyword("end-line"), int(5780), lang.NewKeyword("end-column"), int(65)) v78, err := lang.WithMeta(v76, v77.(lang.IPersistentMap)) if err != nil { panic(err) @@ -54866,7 +53875,7 @@ v109 := lang.Apply(v108, []any{v102}) v110 := lang.Apply(v105, []any{lang.NewKeyword("gen-class"), v109}) return v110 }) -v102 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5827), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(5827), lang.NewKeyword("end-column"), int(52)) +v102 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5784), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(5784), lang.NewKeyword("end-column"), int(52)) v103, err := lang.WithMeta(v101, v102.(lang.IPersistentMap)) if err != nil { panic(err) @@ -55161,7 +54170,7 @@ v259 := lang.Apply(v258, []any{v252}) v260 := lang.Apply(v255, []any{lang.NewKeyword("refer-glojure"), v259}) return v260 }) -v252 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5836), lang.NewKeyword("column"), int(58), lang.NewKeyword("end-line"), int(5836), lang.NewKeyword("end-column"), int(86)) +v252 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5793), lang.NewKeyword("column"), int(58), lang.NewKeyword("end-line"), int(5793), lang.NewKeyword("end-column"), int(86)) v253, err := lang.WithMeta(v251, v252.(lang.IPersistentMap)) if err != nil { panic(err) @@ -56762,7 +55771,7 @@ if v0.Meta() != nil { } // numerator { -v1 := reflect.TypeOf((*big10.Int)(nil)) +v1 := reflect.TypeOf((*big8.Int)(nil)) v0 := lang.NewSymbol("numerator").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("r"))), lang.NewKeyword("doc"), "Returns the numerator part of a Ratio.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3583), lang.NewKeyword("end-line"), int(3583))).(*lang.Symbol) var v3 lang.FnFunc v3 = lang.NewFnFunc(func(args ...any) any { @@ -56783,7 +55792,7 @@ default: } return v6 }) -v4 := reflect.TypeOf((*big10.Int)(nil)) +v4 := reflect.TypeOf((*big8.Int)(nil)) v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { @@ -57070,7 +56079,7 @@ if v0.Meta() != nil { } // parents { -v0 := lang.NewSymbol("parents").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"))), lang.NewKeyword("doc"), "Returns the immediate parents of tag, either via a Java type\n inheritance relationship or a relationship established via derive. h\n must be a hierarchy obtained from make-hierarchy, if not supplied\n defaults to the global hierarchy", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5607), lang.NewKeyword("end-line"), int(5607))).(*lang.Symbol) +v0 := lang.NewSymbol("parents").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"))), lang.NewKeyword("doc"), "Returns the immediate parents of tag, either via a Java type\n inheritance relationship or a relationship established via derive. h\n must be a hierarchy obtained from make-hierarchy, if not supplied\n defaults to the global hierarchy", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5564), lang.NewKeyword("end-line"), int(5564))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -57157,7 +56166,7 @@ if v0.Meta() != nil { } // parse-boolean { -v0 := lang.NewSymbol("parse-boolean").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse strings \"true\" or \"false\" and return a boolean, or nil if invalid", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(8000), lang.NewKeyword("end-line"), int(8000))).(*lang.Symbol) +v0 := lang.NewSymbol("parse-boolean").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse strings \"true\" or \"false\" and return a boolean, or nil if invalid", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7957), lang.NewKeyword("end-line"), int(7957))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -57197,7 +56206,7 @@ if v0.Meta() != nil { } // parse-double { -v0 := lang.NewSymbol("parse-double").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse string with floating point components and return a Double value,\n or nil if parse fails.\n\n Grammar: https://docs.oracle.com/javase/8/docs/api/java/lang/Double.html#valueOf-java.lang.String-", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7978), lang.NewKeyword("end-line"), int(7978))).(*lang.Symbol) +v0 := lang.NewSymbol("parse-double").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse string with floating point components and return a Double value,\n or nil if parse fails.\n\n Grammar: https://docs.oracle.com/javase/8/docs/api/java/lang/Double.html#valueOf-java.lang.String-", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7935), lang.NewKeyword("end-line"), int(7935))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -57213,7 +56222,7 @@ if v6.IsMacro() { v7 := v6.Get() v8 := lang.Apply(v7, []any{v3}) if lang.IsTruthy(v8) { -v10 := lang.Apply(strconv23.ParseFloat, []any{v3, int64(64)}) +v10 := lang.Apply(strconv19.ParseFloat, []any{v3, int64(64)}) var v9 any = v10 _ = v9 var v12 any @@ -57349,7 +56358,7 @@ if v0.Meta() != nil { } // parse-long { -v0 := lang.NewSymbol("parse-long").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse string of decimal digits with optional leading -/+ and return a\n Long value, or nil if parse fails", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7969), lang.NewKeyword("end-line"), int(7969))).(*lang.Symbol) +v0 := lang.NewSymbol("parse-long").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse string of decimal digits with optional leading -/+ and return a\n Long value, or nil if parse fails", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7926), lang.NewKeyword("end-line"), int(7926))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -57365,7 +56374,7 @@ if v6.IsMacro() { v7 := v6.Get() v8 := lang.Apply(v7, []any{v3}) if lang.IsTruthy(v8) { -v10 := lang.Apply(strconv23.ParseInt, []any{v3, int64(10), int64(64)}) +v10 := lang.Apply(strconv19.ParseInt, []any{v3, int64(10), int64(64)}) var v9 any = v10 _ = v9 var v12 any @@ -57398,7 +56407,7 @@ if v0.Meta() != nil { } // parse-uuid { -v0 := lang.NewSymbol("parse-uuid").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse a string representing a UUID and return a java.util.UUID instance,\n or nil if parse fails.\n\n Grammar: https://docs.oracle.com/javase/8/docs/api/java/util/UUID.html#toString--", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7989), lang.NewKeyword("end-line"), int(7989))).(*lang.Symbol) +v0 := lang.NewSymbol("parse-uuid").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse a string representing a UUID and return a java.util.UUID instance,\n or nil if parse fails.\n\n Grammar: https://docs.oracle.com/javase/8/docs/api/java/util/UUID.html#toString--", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7946), lang.NewKeyword("end-line"), int(7946))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -57431,7 +56440,7 @@ if v0.Meta() != nil { } // parsing-err { -v0 := lang.NewSymbol("parsing-err").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Construct message for parsing for non-string parsing error", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(7964), lang.NewKeyword("end-line"), int(7964), lang.NewKeyword("private"), true)).(*lang.Symbol) +v0 := lang.NewSymbol("parsing-err").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Construct message for parsing for non-string parsing error", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(7921), lang.NewKeyword("end-line"), int(7921), lang.NewKeyword("private"), true)).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -57913,7 +56922,7 @@ if v0.Meta() != nil { } // partition-all { -v0 := lang.NewSymbol("partition-all").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of lists like partition, but may include\n partitions with fewer than n items at the end. Returns a stateful\n transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7265), lang.NewKeyword("end-line"), int(7265))).(*lang.Symbol) +v0 := lang.NewSymbol("partition-all").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of lists like partition, but may include\n partitions with fewer than n items at the end. Returns a stateful\n transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7222), lang.NewKeyword("end-line"), int(7222))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -58075,14 +57084,14 @@ return v18 panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) -v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7274), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7290), lang.NewKeyword("end-column"), int(23)) +v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7231), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7247), lang.NewKeyword("end-column"), int(23)) v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) if err != nil { panic(err) } return v15 }) -v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7272), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7290), lang.NewKeyword("end-column"), int(25)) +v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7229), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7247), lang.NewKeyword("end-column"), int(25)) v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) if err != nil { panic(err) @@ -58178,7 +57187,7 @@ if v0.Meta() != nil { } // partition-by { -v0 := lang.NewSymbol("partition-by").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Applies f to each value in coll, splitting it each time f returns a\n new value. Returns a lazy seq of partitions. Returns a stateful\n transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7185), lang.NewKeyword("end-line"), int(7185))).(*lang.Symbol) +v0 := lang.NewSymbol("partition-by").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Applies f to each value in coll, splitting it each time f returns a\n new value. Returns a lazy seq of partitions. Returns a stateful\n transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7142), lang.NewKeyword("end-line"), int(7142))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -58386,14 +57395,14 @@ return v28 panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) -v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7195), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(7219), lang.NewKeyword("end-column"), int(28)) +v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7152), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(7176), lang.NewKeyword("end-column"), int(28)) v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) if err != nil { panic(err) } return v15 }) -v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7192), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(7219), lang.NewKeyword("end-column"), int(30)) +v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7149), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(7176), lang.NewKeyword("end-column"), int(30)) v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) if err != nil { panic(err) @@ -58460,7 +57469,7 @@ v34 := lang.Apply(v3, []any{v30}) v35 := lang.Apply(v33, []any{v20, v34}) return v35 }) -v30 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7225), lang.NewKeyword("column"), int(41), lang.NewKeyword("end-line"), int(7225), lang.NewKeyword("end-column"), int(53)) +v30 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7182), lang.NewKeyword("column"), int(41), lang.NewKeyword("end-line"), int(7182), lang.NewKeyword("end-column"), int(53)) v31, err := lang.WithMeta(v29, v30.(lang.IPersistentMap)) if err != nil { panic(err) @@ -58532,7 +57541,7 @@ if v0.Meta() != nil { } // partitionv { -v0 := lang.NewSymbol("partitionv").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("pad"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of vectors of n items each, at offsets step\n apart. If step is not supplied, defaults to n, i.e. the partitions\n do not overlap. If a pad collection is supplied, use its elements as\n necessary to complete last partition upto n items. In case there are\n not enough padding elements, return a partition with less than n items.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7305), lang.NewKeyword("end-line"), int(7305))).(*lang.Symbol) +v0 := lang.NewSymbol("partitionv").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("pad"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of vectors of n items each, at offsets step\n apart. If step is not supplied, defaults to n, i.e. the partitions\n do not overlap. If a pad collection is supplied, use its elements as\n necessary to complete last partition upto n items. In case there are\n not enough padding elements, return a partition with less than n items.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7262), lang.NewKeyword("end-line"), int(7262))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -58576,7 +57585,7 @@ if v18.IsMacro() { } v19 := v18.Get() v20 := lang.NewVector() -v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7317), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(7317), lang.NewKeyword("end-column"), int(23)) +v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7274), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(7274), lang.NewKeyword("end-column"), int(23)) v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) if err != nil { panic(err) @@ -58670,7 +57679,7 @@ if v19.IsMacro() { } v20 := v19.Get() v21 := lang.NewVector() -v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7323), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(7323), lang.NewKeyword("end-column"), int(23)) +v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7280), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(7280), lang.NewKeyword("end-column"), int(23)) v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) if err != nil { panic(err) @@ -58737,7 +57746,7 @@ if v55.IsMacro() { } v56 := v55.Get() v57 := lang.NewVector() -v58 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7326), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(7326), lang.NewKeyword("end-column"), int(25)) +v58 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7283), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(7283), lang.NewKeyword("end-column"), int(25)) v59, err := lang.WithMeta(v57, v58.(lang.IPersistentMap)) if err != nil { panic(err) @@ -58780,7 +57789,7 @@ if v0.Meta() != nil { } // partitionv-all { -v0 := lang.NewSymbol("partitionv-all").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of vector partitions, but may include\n partitions with fewer than n items at the end.\n Returns a stateful transducer when no collection is provided.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7328), lang.NewKeyword("end-line"), int(7328))).(*lang.Symbol) +v0 := lang.NewSymbol("partitionv-all").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of vector partitions, but may include\n partitions with fewer than n items at the end.\n Returns a stateful transducer when no collection is provided.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7285), lang.NewKeyword("end-line"), int(7285))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -58834,7 +57843,7 @@ if v18.IsMacro() { } v19 := v18.Get() v20 := lang.NewVector() -v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7340), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(7340), lang.NewKeyword("end-column"), int(25)) +v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7297), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(7297), lang.NewKeyword("end-column"), int(25)) v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) if err != nil { panic(err) @@ -58890,7 +57899,7 @@ if v0.Meta() != nil { } // pcalls { -v0 := lang.NewSymbol("pcalls").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("fns"))), lang.NewKeyword("doc"), "Executes the no-arg fns in parallel, returning a lazy sequence of\n their values", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7099), lang.NewKeyword("end-line"), int(7099))).(*lang.Symbol) +v0 := lang.NewSymbol("pcalls").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("fns"))), lang.NewKeyword("doc"), "Executes the no-arg fns in parallel, returning a lazy sequence of\n their values", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7056), lang.NewKeyword("end-line"), int(7056))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -58914,7 +57923,7 @@ v8 := args[0] v9 := lang.Apply(v8, nil) return v9 }) -v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7104), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(7104), lang.NewKeyword("end-column"), int(20)) +v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7061), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(7061), lang.NewKeyword("end-column"), int(20)) v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) if err != nil { panic(err) @@ -58981,7 +57990,7 @@ if v0.Meta() != nil { } // pmap { -v0 := lang.NewSymbol("pmap").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Like map, except f is applied in parallel. Semi-lazy in that the\n parallel computation stays ahead of the consumption, but doesn't\n realize the entire result unless required. Only useful for\n computationally intensive functions where the time of f dominates\n the coordination overhead.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7074), lang.NewKeyword("end-line"), int(7074))).(*lang.Symbol) +v0 := lang.NewSymbol("pmap").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Like map, except f is applied in parallel. Semi-lazy in that the\n parallel computation stays ahead of the consumption, but doesn't\n realize the entire result unless required. Only useful for\n computationally intensive functions where the time of f dominates\n the coordination overhead.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7031), lang.NewKeyword("end-line"), int(7031))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -58994,7 +58003,7 @@ if v7.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } v8 := v7.Get() -v9 := lang.Apply(runtime24.NumCPU, nil) +v9 := lang.Apply(runtime20.NumCPU, nil) v10 := lang.Apply(v8, []any{int64(2), v9}) var v5 any = v10 _ = v5 @@ -59027,7 +58036,7 @@ return v21 v21 := lang.Apply(v19, []any{v20}) return v21 }) -v16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7084), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7084), lang.NewKeyword("end-column"), int(34)) +v16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7041), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7041), lang.NewKeyword("end-column"), int(34)) v17, err := lang.WithMeta(v15, v16.(lang.IPersistentMap)) if err != nil { panic(err) @@ -59143,7 +58152,7 @@ return v45 v21 := v20 _ = v21 } -v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7085), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(7089), lang.NewKeyword("end-column"), int(36)) +v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7042), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(7046), lang.NewKeyword("end-column"), int(36)) v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) if err != nil { panic(err) @@ -59254,7 +58263,7 @@ return v11 v8 := v7 _ = v8 } -v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7092), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(7096), lang.NewKeyword("end-column"), int(67)) +v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7049), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(7053), lang.NewKeyword("end-column"), int(67)) v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) if err != nil { panic(err) @@ -59282,7 +58291,7 @@ v18 := v17.Get() v19 := lang.Apply(v18, []any{v3, v15}) return v19 }) -v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7097), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(7097), lang.NewKeyword("end-column"), int(23)) +v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7054), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(7054), lang.NewKeyword("end-column"), int(23)) v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) if err != nil { panic(err) @@ -59778,7 +58787,7 @@ if v0.Meta() != nil { } // prep-hashes { -v0 := lang.NewSymbol("prep-hashes").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr-sym"), lang.NewSymbol("default"), lang.NewSymbol("tests"), lang.NewSymbol("thens"))), lang.NewKeyword("doc"), "Takes a sequence of test constants and a corresponding sequence of then\n expressions. Returns a tuple of [shift mask case-map switch-type skip-check]\n where case-map is a map of int case values to [test then] tuples, switch-type\n is either :sparse or :compact, and skip-check is a set of case ints for which\n post-switch equivalence checking must not be done (occurs with hash\n collisions).", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6726), lang.NewKeyword("end-line"), int(6726), lang.NewKeyword("private"), true)).(*lang.Symbol) +v0 := lang.NewSymbol("prep-hashes").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr-sym"), lang.NewSymbol("default"), lang.NewSymbol("tests"), lang.NewSymbol("thens"))), lang.NewKeyword("doc"), "Takes a sequence of test constants and a corresponding sequence of then\n expressions. Returns a tuple of [shift mask case-map switch-type skip-check]\n where case-map is a map of int case values to [test then] tuples, switch-type\n is either :sparse or :compact, and skip-check is a set of case ints for which\n post-switch equivalence checking must not be done (occurs with hash\n collisions).", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6683), lang.NewKeyword("end-line"), int(6683), lang.NewKeyword("private"), true)).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 4 { @@ -59797,7 +58806,7 @@ v9 := args[0] v10 := lang.Apply(lang1.Hash, []any{v9}) return v10 }) -v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6734), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(6734), lang.NewKeyword("end-column"), int(66)) +v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6691), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(6691), lang.NewKeyword("end-column"), int(66)) v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) if err != nil { panic(err) @@ -59811,7 +58820,7 @@ if v13.IsMacro() { } v14 := v13.Get() v15 := lang.CreatePersistentTreeSet() -v16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6735), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(6735), lang.NewKeyword("end-column"), int(25)) +v16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6692), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(6692), lang.NewKeyword("end-column"), int(25)) v17, err := lang.WithMeta(v15, v16.(lang.IPersistentMap)) if err != nil { panic(err) @@ -59872,7 +58881,7 @@ if v46.IsMacro() { v47 := v46.Get() v48 := lang.Apply(v44, []any{v7, v47, v5, v6}) v49 := lang.NewVector(int64(0), int64(0), v48, lang.NewKeyword("compact")) -v50 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6739), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(6739), lang.NewKeyword("end-column"), int(63)) +v50 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6696), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(6696), lang.NewKeyword("end-column"), int(63)) v51, err := lang.WithMeta(v49, v50.(lang.IPersistentMap)) if err != nil { panic(err) @@ -59893,7 +58902,7 @@ if lang.IsTruthy(v53) { v59 = v53 } else { v60 := lang.NewVector(int64(0), int64(0)) -v61 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6740), lang.NewKeyword("column"), int(56), lang.NewKeyword("end-line"), int(6740), lang.NewKeyword("end-column"), int(60)) +v61 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6697), lang.NewKeyword("column"), int(56), lang.NewKeyword("end-line"), int(6697), lang.NewKeyword("end-column"), int(60)) v62, err := lang.WithMeta(v60, v61.(lang.IPersistentMap)) if err != nil { panic(err) @@ -59943,7 +58952,7 @@ if v73.IsMacro() { v74 := v73.Get() v75 := lang.Apply(v71, []any{v7, v74, v5, v6}) v76 := lang.NewVector(int64(0), int64(0), v75, lang.NewKeyword("sparse")) -v77 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6743), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(6743), lang.NewKeyword("end-column"), int(66)) +v77 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6700), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(6700), lang.NewKeyword("end-column"), int(66)) v78, err := lang.WithMeta(v76, v77.(lang.IPersistentMap)) if err != nil { panic(err) @@ -59972,7 +58981,7 @@ v87 := lang.Apply(v7, []any{v83}) v88 := lang.Apply(v86, []any{v53, v58, v87}) return v88 }) -v83 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6745), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(6745), lang.NewKeyword("end-column"), int(71)) +v83 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6702), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(6702), lang.NewKeyword("end-column"), int(71)) v84, err := lang.WithMeta(v82, v83.(lang.IPersistentMap)) if err != nil { panic(err) @@ -59985,7 +58994,7 @@ if v86.IsMacro() { v87 := v86.Get() v88 := lang.Apply(v81, []any{v84, v87, v5, v6}) v89 := lang.NewVector(v53, v58, v88, lang.NewKeyword("compact")) -v90 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6745), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(6745), lang.NewKeyword("end-column"), int(103)) +v90 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6702), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(6702), lang.NewKeyword("end-column"), int(103)) v91, err := lang.WithMeta(v89, v90.(lang.IPersistentMap)) if err != nil { panic(err) @@ -60095,7 +59104,7 @@ if v104.IsMacro() { } v105 := v104.Get() v106 := lang.CreatePersistentTreeSet() -v107 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6751), lang.NewKeyword("column"), int(33), lang.NewKeyword("end-line"), int(6751), lang.NewKeyword("end-column"), int(35)) +v107 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6708), lang.NewKeyword("column"), int(33), lang.NewKeyword("end-line"), int(6708), lang.NewKeyword("end-column"), int(35)) v108, err := lang.WithMeta(v106, v107.(lang.IPersistentMap)) if err != nil { panic(err) @@ -60121,7 +59130,7 @@ v116 := v115.Get() v117 := lang.Apply(v116, []any{v77, v82, v113}) return v117 }) -v113 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6751), lang.NewKeyword("column"), int(42), lang.NewKeyword("end-line"), int(6751), lang.NewKeyword("end-column"), int(67)) +v113 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6708), lang.NewKeyword("column"), int(42), lang.NewKeyword("end-line"), int(6708), lang.NewKeyword("end-column"), int(67)) v114, err := lang.WithMeta(v112, v113.(lang.IPersistentMap)) if err != nil { panic(err) @@ -60133,7 +59142,7 @@ v98 = v116 var v97 any = v98 _ = v97 v118 := lang.NewVector(v77, v82, v87, v92, v97) -v119 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6752), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(6752), lang.NewKeyword("end-column"), int(52)) +v119 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6709), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(6709), lang.NewKeyword("end-column"), int(52)) v120, err := lang.WithMeta(v118, v119.(lang.IPersistentMap)) if err != nil { panic(err) @@ -60150,7 +59159,7 @@ if v0.Meta() != nil { } // prep-ints { -v0 := lang.NewSymbol("prep-ints").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tests"), lang.NewSymbol("thens"))), lang.NewKeyword("doc"), "Takes a sequence of int-sized test constants and a corresponding sequence of\n then expressions. Returns a tuple of [shift mask case-map switch-type] where\n case-map is a map of int case values to [test then] tuples, and switch-type\n is either :sparse or :compact.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6674), lang.NewKeyword("end-line"), int(6674), lang.NewKeyword("private"), true)).(*lang.Symbol) +v0 := lang.NewSymbol("prep-ints").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tests"), lang.NewSymbol("thens"))), lang.NewKeyword("doc"), "Takes a sequence of int-sized test constants and a corresponding sequence of\n then expressions. Returns a tuple of [shift mask case-map switch-type] where\n case-map is a map of int case values to [test then] tuples, and switch-type\n is either :sparse or :compact.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6631), lang.NewKeyword("end-line"), int(6631), lang.NewKeyword("private"), true)).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { @@ -60187,7 +59196,7 @@ if v17.IsMacro() { v18 := v17.Get() v19 := lang.Apply(v12, []any{v15, v18, v3, v4}) v20 := lang.NewVector(int64(0), int64(0), v19, lang.NewKeyword("compact")) -v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6682), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(6682), lang.NewKeyword("end-column"), int(49)) +v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6639), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(6639), lang.NewKeyword("end-column"), int(49)) v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) if err != nil { panic(err) @@ -60221,7 +59230,7 @@ if lang.IsTruthy(v24) { v37 = v24 } else { v38 := lang.NewVector(int64(0), int64(0)) -v39 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6683), lang.NewKeyword("column"), int(61), lang.NewKeyword("end-line"), int(6683), lang.NewKeyword("end-column"), int(65)) +v39 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6640), lang.NewKeyword("column"), int(61), lang.NewKeyword("end-line"), int(6640), lang.NewKeyword("end-column"), int(65)) v40, err := lang.WithMeta(v38, v39.(lang.IPersistentMap)) if err != nil { panic(err) @@ -60277,7 +59286,7 @@ if v47.IsMacro() { v48 := v47.Get() v49 := lang.Apply(v42, []any{v45, v48, v3, v4}) v50 := lang.NewVector(int64(0), int64(0), v49, lang.NewKeyword("sparse")) -v51 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6686), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(6686), lang.NewKeyword("end-column"), int(52)) +v51 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6643), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(6643), lang.NewKeyword("end-column"), int(52)) v52, err := lang.WithMeta(v50, v51.(lang.IPersistentMap)) if err != nil { panic(err) @@ -60312,7 +59321,7 @@ v64 := lang.Apply(v63, []any{v57}) v65 := lang.Apply(v60, []any{v24, v29, v64}) return v65 }) -v57 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6688), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(6688), lang.NewKeyword("end-column"), int(62)) +v57 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6645), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(6645), lang.NewKeyword("end-column"), int(62)) v58, err := lang.WithMeta(v56, v57.(lang.IPersistentMap)) if err != nil { panic(err) @@ -60325,7 +59334,7 @@ if v60.IsMacro() { v61 := v60.Get() v62 := lang.Apply(v55, []any{v58, v61, v3, v4}) v63 := lang.NewVector(v24, v29, v62, lang.NewKeyword("compact")) -v64 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6688), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(6688), lang.NewKeyword("end-column"), int(89)) +v64 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6645), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(6645), lang.NewKeyword("end-column"), int(89)) v65, err := lang.WithMeta(v63, v64.(lang.IPersistentMap)) if err != nil { panic(err) @@ -60344,7 +59353,7 @@ if v0.Meta() != nil { } // prependss { -v0 := lang.NewSymbol("prependss").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Prepends a symbol or a seq to coll", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5900), lang.NewKeyword("end-line"), int(5900), lang.NewKeyword("private"), true)).(*lang.Symbol) +v0 := lang.NewSymbol("prependss").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Prepends a symbol or a seq to coll", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5857), lang.NewKeyword("end-line"), int(5857), lang.NewKeyword("private"), true)).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { @@ -60389,7 +59398,7 @@ if v0.Meta() != nil { } // preserving-reduced { -v0 := lang.NewSymbol("preserving-reduced").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7681), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(7681), lang.NewKeyword("end-column"), int(34), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rf"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v0 := lang.NewSymbol("preserving-reduced").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7638), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(7638), lang.NewKeyword("end-column"), int(34), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rf"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -60428,7 +59437,7 @@ v10 = v7 } return v10 }) -v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7683), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(7686), lang.NewKeyword("end-column"), int(12)) +v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7640), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(7643), lang.NewKeyword("end-column"), int(12)) v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) if err != nil { panic(err) @@ -62107,7 +61116,7 @@ if v0.Meta() != nil { } // printf { -v0 := lang.NewSymbol("printf").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fmt"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Prints formatted output, as per format", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5768), lang.NewKeyword("end-line"), int(5768))).(*lang.Symbol) +v0 := lang.NewSymbol("printf").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fmt"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Prints formatted output, as per format", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5725), lang.NewKeyword("end-line"), int(5725))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -62417,273 +61426,15 @@ if v0.Meta() != nil { v2.SetMeta(v0.Meta().(lang.IPersistentMap)) } } -// process-annotation -{ -v0 := lang.NewSymbol("process-annotation").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5505), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(5505), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("av"), lang.NewSymbol("v"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("map?")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v4}) -if lang.IsTruthy(v9) { -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("seq")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v4}) -var v10 any = v14 -_ = v10 -var v15 any = nil -_ = v15 -var v16 any = int64(0) -_ = v16 -var v17 any = int64(0) -_ = v17 -var v18 any -for { -var v19 any -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("<")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.Apply(v22, []any{v17, v16}) -if lang.IsTruthy(v23) { -v25, _ := lang.FieldOrMethod(v15, "nth") -if reflect.TypeOf(v25).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) -} -v26 := lang.Apply(v25, []any{v17}) -var v24 any = v26 -_ = v24 -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("nth")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{v24, int64(0), nil}) -var v27 any = v31 -_ = v27 -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("nth")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v24, int64(1), nil}) -var v32 any = v36 -_ = v32 -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("add-annotation")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("name")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v27}) -v45 := lang.Apply(v40, []any{v3, v44, v32}) -_ = v45 -var v46 any = v10 -var v47 any = v15 -var v48 any = v16 -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("unchecked-inc")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.Apply(v52, []any{v17}) -var v49 any = v53 -v10 = v46 -v15 = v47 -v16 = v48 -v17 = v49 -continue -} else { -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("seq")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.Apply(v27, []any{v10}) -var v24 any = v28 -_ = v24 -var v30 any -if lang.IsTruthy(v24) { -var v31 any = v24 -_ = v31 -var v33 any -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("chunked-seq?")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.Apply(v36, []any{v31}) -if lang.IsTruthy(v37) { -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("chunk-first")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) -} -v41 := v40.Get() -v42 := lang.Apply(v41, []any{v31}) -var v38 any = v42 -_ = v38 -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("chunk-rest")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.Apply(v47, []any{v31}) -var v44 any = v48 -var v49 any = v38 -v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v52 := v51.FindInternedVar(lang.NewSymbol("int")) -if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) -} -v53 := v52.Get() -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("count")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) -} -v56 := v55.Get() -v57 := lang.Apply(v56, []any{v38}) -v58 := lang.Apply(v53, []any{v57}) -var v50 any = v58 -v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v61 := v60.FindInternedVar(lang.NewSymbol("int")) -if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) -} -v62 := v61.Get() -v63 := lang.Apply(v62, []any{int64(0)}) -var v59 any = v63 -v10 = v44 -v15 = v49 -v16 = v50 -v17 = v59 -continue -} else { -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("first")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) -} -v41 := v40.Get() -v42 := lang.Apply(v41, []any{v31}) -var v38 any = v42 -_ = v38 -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("nth")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v38, int64(0), nil}) -var v43 any = v47 -_ = v43 -v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v50 := v49.FindInternedVar(lang.NewSymbol("nth")) -if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) -} -v51 := v50.Get() -v52 := lang.Apply(v51, []any{v38, int64(1), nil}) -var v48 any = v52 -_ = v48 -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("add-annotation")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) -} -v56 := v55.Get() -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("name")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) -} -v59 := v58.Get() -v60 := lang.Apply(v59, []any{v43}) -v61 := lang.Apply(v56, []any{v3, v60, v48}) -_ = v61 -v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v64 := v63.FindInternedVar(lang.NewSymbol("next")) -if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) -} -v65 := v64.Get() -v66 := lang.Apply(v65, []any{v31}) -var v62 any = v66 -var v67 any = nil -var v68 any = int64(0) -var v69 any = int64(0) -v10 = v62 -v15 = v67 -v16 = v68 -v17 = v69 -continue -} -v30 = v33 -} else { -v30 = nil -} -v19 = v30 -} -v18 = v19 - break -} -v5 = v18 -} else { -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("add-annotation")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{v3, "value", v4}) -v5 = v13 -} -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} // promise { -v0 := lang.NewSymbol("promise").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Returns a promise object that can be read with deref/@, and set,\n once only, with deliver. Calls to deref/@ prior to delivery will\n block, unless the variant of deref with timeout is used. All\n subsequent derefs will return the same delivered value without\n blocking. See also - realized?.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7121), lang.NewKeyword("end-line"), int(7121))).(*lang.Symbol) +v0 := lang.NewSymbol("promise").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Returns a promise object that can be read with deref/@, and set,\n once only, with deliver. Calls to deref/@ prior to delivery will\n block, unless the variant of deref with timeout is used. All\n subsequent derefs will return the same delivered value without\n blocking. See also - realized?.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7078), lang.NewKeyword("end-line"), int(7078))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v4 := lang.Apply(java.util.concurrent.CountDownLatch25., []any{int64(1)}) +v4 := lang.Apply(java.util.concurrent.CountDownLatch21., []any{int64(1)}) var v3 any = v4 _ = v3 v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) @@ -62702,7 +61453,7 @@ if v12.IsMacro() { } v13 := v12.Get() v14 := lang.NewVector(nil) -v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7134), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(7134), lang.NewKeyword("end-column"), int(17)) +v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7091), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(7091), lang.NewKeyword("end-column"), int(17)) v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) if err != nil { panic(err) @@ -62733,7 +61484,7 @@ if v25.IsMacro() { } v26 := v25.Get() v27 := lang.NewVector(nil, nil, nil) -v28 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7137), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(7137), lang.NewKeyword("end-column"), int(34)) +v28 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7094), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(7094), lang.NewKeyword("end-column"), int(34)) v29, err := lang.WithMeta(v27, v28.(lang.IPersistentMap)) if err != nil { panic(err) @@ -62743,7 +61494,7 @@ v31, _ := lang.FieldOrMethod(v3, "await") if reflect.TypeOf(v31).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) } -v32 := lang.Apply(v31, []any{nil, time13.Millisecond}) +v32 := lang.Apply(v31, []any{nil, time10.Millisecond}) if lang.IsTruthy(v32) { v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v34 := v33.FindInternedVar(lang.NewSymbol("deref")) @@ -62758,7 +61509,7 @@ v30 = nil } v37 := lang.Apply(v26, []any{v29, v30}) v38 := lang.NewVector(nil) -v39 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7142), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(7142), lang.NewKeyword("end-column"), int(24)) +v39 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7099), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(7099), lang.NewKeyword("end-column"), int(24)) v40, err := lang.WithMeta(v38, v39.(lang.IPersistentMap)) if err != nil { panic(err) @@ -62783,7 +61534,7 @@ default: v46 := lang.Apply(v43, []any{v45}) v47 := lang.Apply(nil, []any{v40, v46}) v48 := lang.NewVector(nil, nil) -v49 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7146), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(7146), lang.NewKeyword("end-column"), int(14)) +v49 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7103), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(7103), lang.NewKeyword("end-column"), int(14)) v50, err := lang.WithMeta(v48, v49.(lang.IPersistentMap)) if err != nil { panic(err) @@ -62914,7 +61665,7 @@ if v0.Meta() != nil { } // pvalues { -v0 := lang.NewSymbol("pvalues").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("exprs"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the values of the exprs, which are\n evaluated in parallel", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7106), lang.NewKeyword("end-line"), int(7106))).(*lang.Symbol) +v0 := lang.NewSymbol("pvalues").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("exprs"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the values of the exprs, which are\n evaluated in parallel", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7063), lang.NewKeyword("end-line"), int(7063))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -62963,7 +61714,7 @@ if v22.IsMacro() { } v23 := v22.Get() v24 := lang.NewVector() -v25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7112), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(7112), lang.NewKeyword("end-column"), int(31)) +v25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7069), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(7069), lang.NewKeyword("end-column"), int(31)) v26, err := lang.WithMeta(v24, v25.(lang.IPersistentMap)) if err != nil { panic(err) @@ -62971,7 +61722,7 @@ if err != nil { v27 := lang.Apply(v23, []any{lang.NewSymbol("glojure.core/fn"), v26, v20}) return v27 }) -v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7112), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(7112), lang.NewKeyword("end-column"), int(34)) +v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7069), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(7069), lang.NewKeyword("end-column"), int(34)) v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) if err != nil { panic(err) @@ -63263,7 +62014,7 @@ var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: -v3 := lang.Apply(rand26.Float64, nil) +v3 := lang.Apply(rand22.Float64, nil) return v3 case 1: v3 := args[0] @@ -63325,7 +62076,7 @@ if v0.Meta() != nil { } // rand-nth { -v0 := lang.NewSymbol("rand-nth").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return a random element of the (sequential) collection. Will have\n the same performance characteristics as nth for the given\n collection.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7256), lang.NewKeyword("end-line"), int(7256))).(*lang.Symbol) +v0 := lang.NewSymbol("rand-nth").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return a random element of the (sequential) collection. Will have\n the same performance characteristics as nth for the given\n collection.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7213), lang.NewKeyword("end-line"), int(7213))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -63363,7 +62114,7 @@ if v0.Meta() != nil { } // random-sample { -v0 := lang.NewSymbol("random-sample").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("prob")), lang.NewVector(lang.NewSymbol("prob"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns items from coll with random probability of prob (0.0 -\n 1.0). Returns a transducer when no collection is provided.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7742), lang.NewKeyword("end-line"), int(7742))).(*lang.Symbol) +v0 := lang.NewSymbol("random-sample").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("prob")), lang.NewVector(lang.NewSymbol("prob"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns items from coll with random probability of prob (0.0 -\n 1.0). Returns a transducer when no collection is provided.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7699), lang.NewKeyword("end-line"), int(7699))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -63397,7 +62148,7 @@ v15 := lang.Apply(v14, nil) v16 := lang.Apply(v11, []any{v15, v3}) return v16 }) -v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7747), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(7747), lang.NewKeyword("end-column"), int(37)) +v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7704), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(7704), lang.NewKeyword("end-column"), int(37)) v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) if err != nil { panic(err) @@ -63435,7 +62186,7 @@ v16 := lang.Apply(v15, nil) v17 := lang.Apply(v12, []any{v16, v3}) return v17 }) -v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7749), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(7749), lang.NewKeyword("end-column"), int(37)) +v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7706), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(7706), lang.NewKeyword("end-column"), int(37)) v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) if err != nil { panic(err) @@ -63454,7 +62205,7 @@ if v0.Meta() != nil { } // random-uuid { -v0 := lang.NewSymbol("random-uuid").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Returns a pseudo-randomly generated java.util.UUID instance (i.e. type 4).\n\n See: https://docs.oracle.com/javase/8/docs/api/java/util/UUID.html#randomUUID--", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6895), lang.NewKeyword("end-line"), int(6895))).(*lang.Symbol) +v0 := lang.NewSymbol("random-uuid").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Returns a pseudo-randomly generated java.util.UUID instance (i.e. type 4).\n\n See: https://docs.oracle.com/javase/8/docs/api/java/util/UUID.html#randomUUID--", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6852), lang.NewKeyword("end-line"), int(6852))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { @@ -63920,7 +62671,7 @@ if v0.Meta() != nil { } // re-pattern { -v1 := reflect.TypeOf((*regexp27.Regexp)(nil)) +v1 := reflect.TypeOf((*regexp23.Regexp)(nil)) v0 := lang.NewSymbol("re-pattern").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns an instance of java.util.regex.Pattern, for use, e.g. in\n re-matcher.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4863), lang.NewKeyword("end-line"), int(4863))).(*lang.Symbol) var v3 lang.FnFunc v3 = lang.NewFnFunc(func(args ...any) any { @@ -63935,16 +62686,16 @@ if v7.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } v8 := v7.Get() -v9 := lang.Apply(v8, []any{regexp27.*Regexp, v4}) +v9 := lang.Apply(v8, []any{regexp23.*Regexp, v4}) if lang.IsTruthy(v9) { v5 = v4 } else { -v10 := lang.Apply(regexp27.MustCompile, []any{v4}) +v10 := lang.Apply(regexp23.MustCompile, []any{v4}) v5 = v10 } return v5 }) -v4 := reflect.TypeOf((*regexp27.Regexp)(nil)) +v4 := reflect.TypeOf((*regexp23.Regexp)(nil)) v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { @@ -64424,7 +63175,7 @@ if v0.Meta() != nil { } // reader-conditional { -v0 := lang.NewSymbol("reader-conditional").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("form"), lang.NewSymbol("splicing?"))), lang.NewKeyword("doc"), "Construct a data representation of a reader conditional.\n If true, splicing? indicates read-cond-splicing.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7825), lang.NewKeyword("end-line"), int(7825))).(*lang.Symbol) +v0 := lang.NewSymbol("reader-conditional").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("form"), lang.NewSymbol("splicing?"))), lang.NewKeyword("doc"), "Construct a data representation of a reader conditional.\n If true, splicing? indicates read-cond-splicing.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7782), lang.NewKeyword("end-line"), int(7782))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { @@ -64443,7 +63194,7 @@ if v0.Meta() != nil { } // reader-conditional? { -v0 := lang.NewSymbol("reader-conditional?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("value"))), lang.NewKeyword("doc"), "Return true if the value is the data representation of a reader conditional", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7819), lang.NewKeyword("end-line"), int(7819))).(*lang.Symbol) +v0 := lang.NewSymbol("reader-conditional?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("value"))), lang.NewKeyword("doc"), "Return true if the value is the data representation of a reader conditional", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7776), lang.NewKeyword("end-line"), int(7776))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -64467,7 +63218,7 @@ if v0.Meta() != nil { } // realized? { -v0 := lang.NewSymbol("realized?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if a value has been produced for a promise, delay, future or lazy sequence.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7602), lang.NewKeyword("end-line"), int(7602))).(*lang.Symbol) +v0 := lang.NewSymbol("realized?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if a value has been produced for a promise, delay, future or lazy sequence.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7559), lang.NewKeyword("end-line"), int(7559))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -64495,7 +63246,7 @@ if v0.Meta() != nil { } // reduce { -v0 := lang.NewSymbol("reduce").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("val"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "f should be a function of 2 arguments. If val is not supplied,\n returns the result of applying f to the first 2 items in coll, then\n applying f to that result and the 3rd item, etc. If coll contains no\n items, f must accept no arguments as well, and reduce returns the\n result of calling f with no arguments. If coll has only 1 item, it\n is returned and f is not called. If val is supplied, returns the\n result of applying f to val and the first item in coll, then\n applying f to that result and the 2nd item, etc. If coll contains no\n items, returns val and f is not called.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6903), lang.NewKeyword("end-line"), int(6903))).(*lang.Symbol) +v0 := lang.NewSymbol("reduce").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("val"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "f should be a function of 2 arguments. If val is not supplied,\n returns the result of applying f to the first 2 items in coll, then\n applying f to that result and the 3rd item, etc. If coll contains no\n items, f must accept no arguments as well, and reduce returns the\n result of calling f with no arguments. If coll has only 1 item, it\n is returned and f is not called. If val is supplied, returns the\n result of applying f to val and the first item in coll, then\n applying f to that result and the 2nd item, etc. If coll contains no\n items, returns val and f is not called.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6860), lang.NewKeyword("end-line"), int(6860))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -64570,7 +63321,7 @@ if v0.Meta() != nil { } // reduce-kv { -v0 := lang.NewSymbol("reduce-kv").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Reduces an associative collection. f should be a function of 3\n arguments. Returns the result of applying f to init, the first key\n and the first value in coll, then applying f to that result and the\n 2nd key and value, etc. If coll contains no entries, returns init\n and f is not called. Note that reduce-kv is supported on vectors,\n where the keys will be the ordinals.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6925), lang.NewKeyword("end-line"), int(6925))).(*lang.Symbol) +v0 := lang.NewSymbol("reduce-kv").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Reduces an associative collection. f should be a function of 3\n arguments. Returns the result of applying f to init, the first key\n and the first value in coll, then applying f to that result and the\n 2nd key and value, etc. If coll contains no entries, returns init\n and f is not called. Note that reduce-kv is supported on vectors,\n where the keys will be the ordinals.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6882), lang.NewKeyword("end-line"), int(6882))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 3 { @@ -64809,7 +63560,7 @@ if v0.Meta() != nil { } // reductions { -v0 := lang.NewSymbol("reductions").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy seq of the intermediate values of the reduction (as\n per reduce) of coll by f, starting with init.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7239), lang.NewKeyword("end-line"), int(7239))).(*lang.Symbol) +v0 := lang.NewSymbol("reductions").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy seq of the intermediate values of the reduction (as\n per reduce) of coll by f, starting with init.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7196), lang.NewKeyword("end-line"), int(7196))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -65212,7 +63963,7 @@ if v14.IsMacro() { } v15 := v14.Get() v16 := lang.Apply(v15, []any{"No namespace: ", v3}) -v17 := lang.Apply(errors7.New, []any{v16}) +v17 := lang.Apply(errors6.New, []any{v16}) panic(v17) } var v5 any = v12 @@ -65340,7 +64091,7 @@ v41 = v49 v41 = v39 } if lang.IsTruthy(v41) { -v39 := lang.Apply(errors7.New, []any{":only/:refer value must be a sequential collection of symbols"}) +v39 := lang.Apply(errors6.New, []any{":only/:refer value must be a sequential collection of symbols"}) panic(v39) } else { v38 = nil @@ -65587,7 +64338,7 @@ if v0.Meta() != nil { } // refer-glojure { -v0 := lang.NewSymbol("refer-glojure").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("filters"))), lang.NewKeyword("doc"), "Same as (refer 'glojure.core )", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5843), lang.NewKeyword("end-line"), int(5843))).(*lang.Symbol) +v0 := lang.NewSymbol("refer-glojure").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("filters"))), lang.NewKeyword("doc"), "Same as (refer 'glojure.core )", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5800), lang.NewKeyword("end-line"), int(5800))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -65908,7 +64659,7 @@ if v0.Meta() != nil { } // remove-tap { -v0 := lang.NewSymbol("remove-tap").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Remove f from the tap set.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7926), lang.NewKeyword("end-line"), int(7926))).(*lang.Symbol) +v0 := lang.NewSymbol("remove-tap").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Remove f from the tap set.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7883), lang.NewKeyword("end-line"), int(7883))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -66282,7 +65033,7 @@ if v0.Meta() != nil { } // require { -v0 := lang.NewSymbol("require").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Loads libs, skipping any that are already loaded. Each argument is\n either a libspec that identifies a lib, a prefix list that identifies\n multiple libs whose names share a common prefix, or a flag that modifies\n how all the identified libs are loaded. Use :require in the ns macro\n in preference to calling this directly.\n\n Libs\n\n A 'lib' is a named set of resources in classpath whose contents define a\n library of Clojure code. Lib names are symbols and each lib is associated\n with a Clojure namespace and a Java package that share its name. A lib's\n name also locates its root directory within classpath using Java's\n package name to classpath-relative path mapping. All resources in a lib\n should be contained in the directory structure under its root directory.\n All definitions a lib makes should be in its associated namespace.\n\n 'require loads a lib by loading its root resource. The root resource path\n is derived from the lib name in the following manner:\n Consider a lib named by the symbol 'x.y.z; it has the root directory\n /x/y/, and its root resource is /x/y/z.clj, or\n /x/y/z.cljc if /x/y/z.clj does not exist. The\n root resource should contain code to create the lib's\n namespace (usually by using the ns macro) and load any additional\n lib resources.\n\n Libspecs\n\n A libspec is a lib name or a vector containing a lib name followed by\n options expressed as sequential keywords and arguments.\n\n Recognized options:\n :as takes a symbol as its argument and makes that symbol an alias to the\n lib's namespace in the current namespace.\n :as-alias takes a symbol as its argument and aliases like :as, however\n the lib will not be loaded. If the lib has not been loaded, a new\n empty namespace will be created (as with create-ns).\n :refer takes a list of symbols to refer from the namespace or the :all\n keyword to bring in all public vars.\n\n Prefix Lists\n\n It's common for Clojure code to depend on several libs whose names have\n the same prefix. When specifying libs, prefix lists can be used to reduce\n repetition. A prefix list contains the shared prefix followed by libspecs\n with the shared prefix removed from the lib names. After removing the\n prefix, the names that remain must not contain any periods.\n\n Flags\n\n A flag is a keyword.\n Recognized flags: :reload, :reload-all, :verbose\n :reload forces loading of all the identified libs even if they are\n already loaded (has no effect on libspecs using :as-alias)\n :reload-all implies :reload and also forces loading of all libs that the\n identified libs directly or indirectly load via require or use\n (has no effect on libspecs using :as-alias)\n :verbose triggers printing information about each load, alias, and refer\n\n Example:\n\n The following would load the libraries glojure.zip and glojure.set\n abbreviated as 's'.\n\n (require '(glojure zip [set :as s]))", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6032), lang.NewKeyword("end-line"), int(6032))).(*lang.Symbol) +v0 := lang.NewSymbol("require").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Loads libs, skipping any that are already loaded. Each argument is\n either a libspec that identifies a lib, a prefix list that identifies\n multiple libs whose names share a common prefix, or a flag that modifies\n how all the identified libs are loaded. Use :require in the ns macro\n in preference to calling this directly.\n\n Libs\n\n A 'lib' is a named set of resources in classpath whose contents define a\n library of Clojure code. Lib names are symbols and each lib is associated\n with a Clojure namespace and a Java package that share its name. A lib's\n name also locates its root directory within classpath using Java's\n package name to classpath-relative path mapping. All resources in a lib\n should be contained in the directory structure under its root directory.\n All definitions a lib makes should be in its associated namespace.\n\n 'require loads a lib by loading its root resource. The root resource path\n is derived from the lib name in the following manner:\n Consider a lib named by the symbol 'x.y.z; it has the root directory\n /x/y/, and its root resource is /x/y/z.clj, or\n /x/y/z.cljc if /x/y/z.clj does not exist. The\n root resource should contain code to create the lib's\n namespace (usually by using the ns macro) and load any additional\n lib resources.\n\n Libspecs\n\n A libspec is a lib name or a vector containing a lib name followed by\n options expressed as sequential keywords and arguments.\n\n Recognized options:\n :as takes a symbol as its argument and makes that symbol an alias to the\n lib's namespace in the current namespace.\n :as-alias takes a symbol as its argument and aliases like :as, however\n the lib will not be loaded. If the lib has not been loaded, a new\n empty namespace will be created (as with create-ns).\n :refer takes a list of symbols to refer from the namespace or the :all\n keyword to bring in all public vars.\n\n Prefix Lists\n\n It's common for Clojure code to depend on several libs whose names have\n the same prefix. When specifying libs, prefix lists can be used to reduce\n repetition. A prefix list contains the shared prefix followed by libspecs\n with the shared prefix removed from the lib names. After removing the\n prefix, the names that remain must not contain any periods.\n\n Flags\n\n A flag is a keyword.\n Recognized flags: :reload, :reload-all, :verbose\n :reload forces loading of all the identified libs even if they are\n already loaded (has no effect on libspecs using :as-alias)\n :reload-all implies :reload and also forces loading of all libs that the\n identified libs directly or indirectly load via require or use\n (has no effect on libspecs using :as-alias)\n :verbose triggers printing information about each load, alias, and refer\n\n Example:\n\n The following would load the libraries glojure.zip and glojure.set\n abbreviated as 's'.\n\n (require '(glojure zip [set :as s]))", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5989), lang.NewKeyword("end-line"), int(5989))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -66315,7 +65066,7 @@ if v0.Meta() != nil { } // requiring-resolve { -v0 := lang.NewSymbol("requiring-resolve").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Resolves namespace-qualified sym per 'resolve'. If initial resolve\nfails, attempts to require sym's namespace and retries.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6111), lang.NewKeyword("end-line"), int(6111))).(*lang.Symbol) +v0 := lang.NewSymbol("requiring-resolve").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Resolves namespace-qualified sym per 'resolve'. If initial resolve\nfails, attempts to require sym's namespace and retries.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6068), lang.NewKeyword("end-line"), int(6068))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -66587,7 +65338,7 @@ if v0.Meta() != nil { } // resultset-seq { -v0 := lang.NewSymbol("resultset-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rs"))), lang.NewKeyword("doc"), "Creates and returns a lazy sequence of structmaps corresponding to\n the rows in the java.sql.ResultSet rs", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5724), lang.NewKeyword("end-line"), int(5724))).(*lang.Symbol) +v0 := lang.NewSymbol("resultset-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rs"))), lang.NewKeyword("doc"), "Creates and returns a lazy sequence of structmaps corresponding to\n the rows in the java.sql.ResultSet rs", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5681), lang.NewKeyword("end-line"), int(5681))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -66659,7 +65410,7 @@ default: } return v31 }) -v29 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5731), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(5731), lang.NewKeyword("end-column"), int(62)) +v29 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5688), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(5688), lang.NewKeyword("end-column"), int(62)) v30, err := lang.WithMeta(v28, v29.(lang.IPersistentMap)) if err != nil { panic(err) @@ -66684,7 +65435,7 @@ if reflect.TypeOf(v37).Kind() != reflect.Func { v38 := lang.Apply(v37, []any{v36}) return v38 }) -v36 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5732), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(5732), lang.NewKeyword("end-column"), int(63)) +v36 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5689), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(5689), lang.NewKeyword("end-column"), int(63)) v37, err := lang.WithMeta(v35, v36.(lang.IPersistentMap)) if err != nil { panic(err) @@ -66712,7 +65463,7 @@ var v50 any if lang.IsTruthy(v41) { v50 = v41 } else { -v51 := lang.Apply(Exception12., []any{"ResultSet must have unique column labels"}) +v51 := lang.Apply(Exception9., []any{"ResultSet must have unique column labels"}) panic(v51) } var v40 any = v50 @@ -66756,7 +65507,7 @@ if reflect.TypeOf(v56).Kind() != reflect.Func { v57 := lang.Apply(v56, []any{v55}) return v57 }) -v55 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5737), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(5737), lang.NewKeyword("end-column"), int(71)) +v55 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5694), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(5694), lang.NewKeyword("end-column"), int(71)) v56, err := lang.WithMeta(v54, v55.(lang.IPersistentMap)) if err != nil { panic(err) @@ -66764,7 +65515,7 @@ if err != nil { v57 := lang.Apply(v53, []any{v56, v7}) return v57 }) -v51 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5737), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(5737), lang.NewKeyword("end-column"), int(78)) +v51 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5694), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(5694), lang.NewKeyword("end-column"), int(78)) v52, err := lang.WithMeta(v50, v51.(lang.IPersistentMap)) if err != nil { panic(err) @@ -66823,7 +65574,7 @@ return v56 v55 := v54 _ = v55 } -v55 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5738), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(5740), lang.NewKeyword("end-column"), int(86)) +v55 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5695), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(5697), lang.NewKeyword("end-column"), int(86)) v56, err := lang.WithMeta(v54, v55.(lang.IPersistentMap)) if err != nil { panic(err) @@ -66871,7 +65622,7 @@ if v0.Meta() != nil { } // reversible? { -v0 := lang.NewSymbol("reversible?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements Reversible", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6300), lang.NewKeyword("end-line"), int(6300))).(*lang.Symbol) +v0 := lang.NewSymbol("reversible?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements Reversible", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6257), lang.NewKeyword("end-line"), int(6257))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -66895,7 +65646,7 @@ if v0.Meta() != nil { } // root-directory { -v0 := lang.NewSymbol("root-directory").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"))), lang.NewKeyword("doc"), "Returns the root resource path for a lib", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5914), lang.NewKeyword("end-line"), int(5914), lang.NewKeyword("private"), true)).(*lang.Symbol) +v0 := lang.NewSymbol("root-directory").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"))), lang.NewKeyword("doc"), "Returns the root resource path for a lib", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5871), lang.NewKeyword("end-line"), int(5871), lang.NewKeyword("private"), true)).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -66917,7 +65668,7 @@ if v11.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } v12 := v11.Get() -v13 := lang.Apply(strings18.LastIndex, []any{v4, "/"}) +v13 := lang.Apply(strings14.LastIndex, []any{v4, "/"}) v14 := lang.Apply(v12, []any{v4, int64(0), v13}) return v14 }) @@ -66930,7 +65681,7 @@ if v0.Meta() != nil { // root-resource { v1 := reflect.TypeOf("") -v0 := lang.NewSymbol("root-resource").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"))), lang.NewKeyword("doc"), "Returns the root directory path for a lib", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5907), lang.NewKeyword("end-line"), int(5907), lang.NewKeyword("private"), true)).(*lang.Symbol) +v0 := lang.NewSymbol("root-resource").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"))), lang.NewKeyword("doc"), "Returns the root directory path for a lib", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5864), lang.NewKeyword("end-line"), int(5864), lang.NewKeyword("private"), true)).(*lang.Symbol) var v3 lang.FnFunc v3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -66950,8 +65701,8 @@ if v9.IsMacro() { } v10 := v9.Get() v11 := lang.Apply(v10, []any{v4}) -v12 := lang.Apply(strings18.ReplaceAll, []any{v11, "-", "_"}) -v13 := lang.Apply(strings18.ReplaceAll, []any{v12, ".", "/"}) +v12 := lang.Apply(strings14.ReplaceAll, []any{v11, "-", "_"}) +v13 := lang.Apply(strings14.ReplaceAll, []any{v12, ".", "/"}) v14 := lang.Apply(v7, []any{lang.NewChar(47), v13}) return v14 }) @@ -67161,7 +65912,7 @@ if v0.Meta() != nil { } // run! { -v0 := lang.NewSymbol("run!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("proc"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Runs the supplied procedure (via reduce), for purposes of side\n effects, on successive items in the collection. Returns nil", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7751), lang.NewKeyword("end-line"), int(7751))).(*lang.Symbol) +v0 := lang.NewSymbol("run!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("proc"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Runs the supplied procedure (via reduce), for purposes of side\n effects, on successive items in the collection. Returns nil", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7708), lang.NewKeyword("end-line"), int(7708))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { @@ -67185,7 +65936,7 @@ v10 := args[1] v11 := lang.Apply(v3, []any{v10}) return v11 }) -v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7756), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(7756), lang.NewKeyword("end-column"), int(20)) +v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7713), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(7713), lang.NewKeyword("end-column"), int(20)) v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) if err != nil { panic(err) @@ -67578,7 +66329,7 @@ if v0.Meta() != nil { } // seqable? { -v0 := lang.NewSymbol("seqable?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if the seq function is supported for x", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6247), lang.NewKeyword("end-line"), int(6247))).(*lang.Symbol) +v0 := lang.NewSymbol("seqable?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if the seq function is supported for x", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6204), lang.NewKeyword("end-line"), int(6204))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -67631,12 +66382,12 @@ if v12.IsMacro() { } v13 := v12.Get() v14 := lang.Apply(v13, []any{v3}) -v15 := lang.Apply(LinkedBlockingQueue28., []any{v14}) +v15 := lang.Apply(LinkedBlockingQueue24., []any{v14}) v6 = v15 } var v5 any = v6 _ = v5 -v17 := lang.Apply(Object16., nil) +v17 := lang.Apply(Object13., nil) var v16 any = v17 _ = v16 v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) @@ -68088,7 +66839,7 @@ if v0.Meta() != nil { } // sequential? { -v0 := lang.NewSymbol("sequential?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements Sequential", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6272), lang.NewKeyword("end-line"), int(6272))).(*lang.Symbol) +v0 := lang.NewSymbol("sequential?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements Sequential", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6229), lang.NewKeyword("end-line"), int(6229))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -68112,7 +66863,7 @@ if v0.Meta() != nil { } // serialized-require { -v0 := lang.NewSymbol("serialized-require").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Like 'require', but serializes loading.\n Interim function preferred over 'require' for known asynchronous loads.\n Future changes may make these equivalent.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6102), lang.NewKeyword("end-line"), int(6102), lang.NewKeyword("private"), true)).(*lang.Symbol) +v0 := lang.NewSymbol("serialized-require").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Like 'require', but serializes loading.\n Interim function preferred over 'require' for known asynchronous loads.\n Future changes may make these equivalent.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6059), lang.NewKeyword("end-line"), int(6059), lang.NewKeyword("private"), true)).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -68464,7 +67215,7 @@ if v0.Meta() != nil { } // shift-mask { -v0 := lang.NewSymbol("shift-mask").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6641), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(6641), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("shift"), lang.NewSymbol("mask"), lang.NewSymbol("x"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v0 := lang.NewSymbol("shift-mask").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6598), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(6598), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("shift"), lang.NewSymbol("mask"), lang.NewSymbol("x"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 3 { @@ -68796,7 +67547,7 @@ if v0.Meta() != nil { } // shuffle { -v0 := lang.NewSymbol("shuffle").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return a random permutation of coll", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7343), lang.NewKeyword("end-line"), int(7343))).(*lang.Symbol) +v0 := lang.NewSymbol("shuffle").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return a random permutation of coll", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7300), lang.NewKeyword("end-line"), int(7300))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -69039,7 +67790,7 @@ case reflect.Func: default: v30 = v29 } -v31 := lang.Apply(strings18.Index, []any{v30, "."}) +v31 := lang.Apply(strings14.Index, []any{v30, "."}) v32 := lang.Apply(lang1.Equiv, []any{v31, int64(-1)}) if lang.IsTruthy(v32) { var v33 any @@ -69333,7 +68084,7 @@ if v0.Meta() != nil { // slurp { v1 := reflect.TypeOf("") -v0 := lang.NewSymbol("slurp").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("opts"))), lang.NewKeyword("doc"), "Opens a reader on f and reads all its contents, returning a string.\n See glojure.java.io/reader for a complete list of supported arguments.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7025), lang.NewKeyword("end-line"), int(7025))).(*lang.Symbol) +v0 := lang.NewSymbol("slurp").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("opts"))), lang.NewKeyword("doc"), "Opens a reader on f and reads all its contents, returning a string.\n See glojure.java.io/reader for a complete list of supported arguments.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6982), lang.NewKeyword("end-line"), int(6982))).(*lang.Symbol) var v3 lang.FnFunc v3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -69470,7 +68221,7 @@ if v0.Meta() != nil { } // some-> { -v0 := lang.NewSymbol("some->").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "When expr is not nil, threads it into the first form (via ->),\n and when that result is not nil, through the next etc", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7653), lang.NewKeyword("end-line"), int(7653))).(*lang.Symbol) +v0 := lang.NewSymbol("some->").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "When expr is not nil, threads it into the first form (via ->),\n and when that result is not nil, through the next etc", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7610), lang.NewKeyword("end-line"), int(7610))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -69610,7 +68361,7 @@ v76 := lang.Apply(v23, []any{v27, v47, v51, v75}) v77 := lang.Apply(v20, []any{v76}) return v77 }) -v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7659), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7659), lang.NewKeyword("end-column"), int(64)) +v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7616), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7616), lang.NewKeyword("end-column"), int(64)) v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) if err != nil { panic(err) @@ -69746,7 +68497,7 @@ if v0.Meta() != nil { } // some->> { -v0 := lang.NewSymbol("some->>").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "When expr is not nil, threads it into the first form (via ->>),\n and when that result is not nil, through the next etc", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7667), lang.NewKeyword("end-line"), int(7667))).(*lang.Symbol) +v0 := lang.NewSymbol("some->>").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "When expr is not nil, threads it into the first form (via ->>),\n and when that result is not nil, through the next etc", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7624), lang.NewKeyword("end-line"), int(7624))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -69886,7 +68637,7 @@ v76 := lang.Apply(v23, []any{v27, v47, v51, v75}) v77 := lang.Apply(v20, []any{v76}) return v77 }) -v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7673), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7673), lang.NewKeyword("end-column"), int(65)) +v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7630), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7630), lang.NewKeyword("end-column"), int(65)) v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) if err != nil { panic(err) @@ -70022,7 +68773,7 @@ if v0.Meta() != nil { } // some-fn { -v0 := lang.NewSymbol("some-fn").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("p")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2"), lang.NewSymbol("p3")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2"), lang.NewSymbol("p3"), lang.NewSymbol("&"), lang.NewSymbol("ps"))), lang.NewKeyword("doc"), "Takes a set of predicates and returns a function f that returns the first logical true value\n returned by one of its composing predicates against any of its arguments, else it returns\n logical false. Note that f is short-circuiting in that it will stop execution on the first\n argument that triggers a logical true result against the original predicates.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7505), lang.NewKeyword("end-line"), int(7505))).(*lang.Symbol) +v0 := lang.NewSymbol("some-fn").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("p")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2"), lang.NewSymbol("p3")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2"), lang.NewSymbol("p3"), lang.NewSymbol("&"), lang.NewSymbol("ps"))), lang.NewKeyword("doc"), "Takes a set of predicates and returns a function f that returns the first logical true value\n returned by one of its composing predicates against any of its arguments, else it returns\n logical false. Note that f is short-circuiting in that it will stop execution on the first\n argument that triggers a logical true result against the original predicates.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7462), lang.NewKeyword("end-line"), int(7462))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -70106,7 +68857,7 @@ return v13 v5 := v4 _ = v5 } -v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7512), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7518), lang.NewKeyword("end-column"), int(43)) +v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7469), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7475), lang.NewKeyword("end-column"), int(43)) v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) if err != nil { panic(err) @@ -70256,7 +69007,7 @@ v23 = v24 } return v23 }) -v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7526), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(7526), lang.NewKeyword("end-column"), int(52)) +v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7483), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(7483), lang.NewKeyword("end-column"), int(52)) v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) if err != nil { panic(err) @@ -70270,7 +69021,7 @@ return v14 v6 := v5 _ = v6 } -v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7520), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7526), lang.NewKeyword("end-column"), int(61)) +v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7477), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7483), lang.NewKeyword("end-column"), int(61)) v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) if err != nil { panic(err) @@ -70484,7 +69235,7 @@ v24 = v28 } return v24 }) -v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7534), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(7534), lang.NewKeyword("end-column"), int(59)) +v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7491), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(7491), lang.NewKeyword("end-column"), int(59)) v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) if err != nil { panic(err) @@ -70498,7 +69249,7 @@ return v15 v7 := v6 _ = v7 } -v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7528), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7534), lang.NewKeyword("end-column"), int(68)) +v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7485), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7491), lang.NewKeyword("end-column"), int(68)) v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) if err != nil { panic(err) @@ -70544,7 +69295,7 @@ v20 := args[0] v21 := lang.Apply(v20, []any{v15}) return v21 }) -v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7539), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(7539), lang.NewKeyword("end-column"), int(26)) +v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7496), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(7496), lang.NewKeyword("end-column"), int(26)) v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) if err != nil { panic(err) @@ -70578,7 +69329,7 @@ v25 = v26 } return v25 }) -v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7540), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(7540), lang.NewKeyword("end-column"), int(39)) +v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7497), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(7497), lang.NewKeyword("end-column"), int(39)) v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) if err != nil { panic(err) @@ -70622,7 +69373,7 @@ v26 = v30 } return v26 }) -v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7541), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7541), lang.NewKeyword("end-column"), int(47)) +v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7498), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7498), lang.NewKeyword("end-column"), int(47)) v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) if err != nil { panic(err) @@ -70665,7 +69416,7 @@ v30 := v29.Get() v31 := lang.Apply(v30, []any{v27, v18}) return v31 }) -v27 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7543), lang.NewKeyword("column"), int(36), lang.NewKeyword("end-line"), int(7543), lang.NewKeyword("end-column"), int(49)) +v27 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7500), lang.NewKeyword("column"), int(36), lang.NewKeyword("end-line"), int(7500), lang.NewKeyword("end-column"), int(49)) v28, err := lang.WithMeta(v26, v27.(lang.IPersistentMap)) if err != nil { panic(err) @@ -70679,7 +69430,7 @@ return v22 v14 := v13 _ = v14 } -v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7537), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7543), lang.NewKeyword("end-column"), int(56)) +v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7494), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7500), lang.NewKeyword("end-column"), int(56)) v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) if err != nil { panic(err) @@ -70957,7 +69708,7 @@ if v0.Meta() != nil { } // sorted? { -v0 := lang.NewSymbol("sorted?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements Sorted", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6278), lang.NewKeyword("end-line"), int(6278))).(*lang.Symbol) +v0 := lang.NewSymbol("sorted?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements Sorted", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6235), lang.NewKeyword("end-line"), int(6235))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -71016,7 +69767,7 @@ if v0.Meta() != nil { } // spit { -v0 := lang.NewSymbol("spit").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("content"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Opposite of slurp. Opens f with writer, writes content, then\n closes f. Options passed to glojure.java.io/writer.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7037), lang.NewKeyword("end-line"), int(7037))).(*lang.Symbol) +v0 := lang.NewSymbol("spit").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("content"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Opposite of slurp. Opens f with writer, writes content, then\n closes f. Options passed to glojure.java.io/writer.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6994), lang.NewKeyword("end-line"), int(6994))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -71148,7 +69899,7 @@ if v0.Meta() != nil { } // splitv-at { -v0 := lang.NewSymbol("splitv-at").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a vector of [(into [] (take n) coll) (drop n coll)]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7299), lang.NewKeyword("end-line"), int(7299))).(*lang.Symbol) +v0 := lang.NewSymbol("splitv-at").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a vector of [(into [] (take n) coll) (drop n coll)]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7256), lang.NewKeyword("end-line"), int(7256))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { @@ -71163,7 +69914,7 @@ if v6.IsMacro() { } v7 := v6.Get() v8 := lang.NewVector() -v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7303), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(7303), lang.NewKeyword("end-column"), int(11)) +v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7260), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(7260), lang.NewKeyword("end-column"), int(11)) v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) if err != nil { panic(err) @@ -71184,7 +69935,7 @@ if v17.IsMacro() { v18 := v17.Get() v19 := lang.Apply(v18, []any{v3, v4}) v20 := lang.NewVector(v15, v19) -v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7303), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(7303), lang.NewKeyword("end-column"), int(41)) +v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7260), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(7260), lang.NewKeyword("end-column"), int(41)) v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) if err != nil { panic(err) @@ -71410,7 +70161,7 @@ if v0.Meta() != nil { } // stream-into! { -v0 := lang.NewSymbol("stream-into!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("stream")), lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("xform"), lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Returns a new coll consisting of coll with all of the items of the\n stream conjoined. This is a terminal operation on the stream.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6853), lang.NewKeyword("end-line"), int(6853))).(*lang.Symbol) +v0 := lang.NewSymbol("stream-into!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("stream")), lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("xform"), lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Returns a new coll consisting of coll with all of the items of the\n stream conjoined. This is a terminal operation on the stream.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6810), lang.NewKeyword("end-line"), int(6810))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -71569,7 +70320,7 @@ if v0.Meta() != nil { } // stream-reduce! { -v0 := lang.NewSymbol("stream-reduce!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("s")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Works like reduce but takes a java.util.stream.BaseStream as its source.\n Honors 'reduced', is a terminal operation on the stream", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6827), lang.NewKeyword("end-line"), int(6827))).(*lang.Symbol) +v0 := lang.NewSymbol("stream-reduce!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("s")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Works like reduce but takes a java.util.stream.BaseStream as its source.\n Honors 'reduced', is a terminal operation on the stream", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6784), lang.NewKeyword("end-line"), int(6784))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -71618,7 +70369,7 @@ if v0.Meta() != nil { } // stream-seq! { -v0 := lang.NewSymbol("stream-seq!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Takes a java.util.stream.BaseStream instance s and returns a seq of its\n contents. This is a terminal operation on the stream.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6836), lang.NewKeyword("end-line"), int(6836))).(*lang.Symbol) +v0 := lang.NewSymbol("stream-seq!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Takes a java.util.stream.BaseStream instance s and returns a seq of its\n contents. This is a terminal operation on the stream.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6793), lang.NewKeyword("end-line"), int(6793))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -71653,7 +70404,7 @@ if v0.Meta() != nil { } // stream-transduce! { -v0 := lang.NewSymbol("stream-transduce!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("f"), lang.NewSymbol("stream")), lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Works like transduce but takes a java.util.stream.BaseStream as its source.\n This is a terminal operation on the stream.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6843), lang.NewKeyword("end-line"), int(6843))).(*lang.Symbol) +v0 := lang.NewSymbol("stream-transduce!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("f"), lang.NewSymbol("stream")), lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Works like transduce but takes a java.util.stream.BaseStream as its source.\n This is a terminal operation on the stream.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6800), lang.NewKeyword("end-line"), int(6800))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -72077,7 +70828,7 @@ if v0.Meta() != nil { } // supers { -v0 := lang.NewSymbol("supers").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("class"))), lang.NewKeyword("doc"), "Returns the immediate and indirect superclasses and interfaces of c, if any", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5575), lang.NewKeyword("end-line"), int(5575))).(*lang.Symbol) +v0 := lang.NewSymbol("supers").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("class"))), lang.NewKeyword("doc"), "Returns the immediate and indirect superclasses and interfaces of c, if any", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5532), lang.NewKeyword("end-line"), int(5532))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -72515,7 +71266,7 @@ if v0.Meta() != nil { } // tagged-literal { -v0 := lang.NewSymbol("tagged-literal").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag"), lang.NewSymbol("form"))), lang.NewKeyword("doc"), "Construct a data representation of a tagged literal from a\n tag symbol and a form.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7812), lang.NewKeyword("end-line"), int(7812))).(*lang.Symbol) +v0 := lang.NewSymbol("tagged-literal").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag"), lang.NewSymbol("form"))), lang.NewKeyword("doc"), "Construct a data representation of a tagged literal from a\n tag symbol and a form.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7769), lang.NewKeyword("end-line"), int(7769))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { @@ -72534,7 +71285,7 @@ if v0.Meta() != nil { } // tagged-literal? { -v0 := lang.NewSymbol("tagged-literal?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("value"))), lang.NewKeyword("doc"), "Return true if the value is the data representation of a tagged literal", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7806), lang.NewKeyword("end-line"), int(7806))).(*lang.Symbol) +v0 := lang.NewSymbol("tagged-literal?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("value"))), lang.NewKeyword("doc"), "Return true if the value is the data representation of a tagged literal", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7763), lang.NewKeyword("end-line"), int(7763))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -73156,7 +71907,7 @@ if v0.Meta() != nil { } // tapset { -v0 := lang.NewSymbol("tapset").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7925), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(7925), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) +v0 := lang.NewSymbol("tapset").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7882), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(7882), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) v2 := lang.NewAtom(lang.CreatePersistentTreeSet()) v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { @@ -73238,7 +71989,7 @@ if v17.IsMacro() { } v18 := v17.Get() v19 := lang.Apply(v18, []any{"No namespace: ", v3, " found"}) -v20 := lang.Apply(Exception12., []any{v19}) +v20 := lang.Apply(Exception9., []any{v19}) panic(v20) } v4 = v15 @@ -73253,7 +72004,7 @@ if v0.Meta() != nil { } // thread-bound? { -v0 := lang.NewSymbol("thread-bound?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("vars"))), lang.NewKeyword("doc"), "Returns true if all of the vars provided as arguments have thread-local bindings.\n Implies that set!'ing the provided vars will succeed. Returns true if no vars are provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5542), lang.NewKeyword("end-line"), int(5542))).(*lang.Symbol) +v0 := lang.NewSymbol("thread-bound?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("vars"))), lang.NewKeyword("doc"), "Returns true if all of the vars provided as arguments have thread-local bindings.\n Implies that set!'ing the provided vars will succeed. Returns true if no vars are provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5499), lang.NewKeyword("end-line"), int(5499))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -73287,7 +72038,7 @@ default: } return v10 }) -v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5548), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5548), lang.NewKeyword("end-column"), int(78)) +v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5505), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5505), lang.NewKeyword("end-column"), int(78)) v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) if err != nil { panic(err) @@ -73304,7 +72055,7 @@ if v0.Meta() != nil { } // throw-if { -v0 := lang.NewSymbol("throw-if").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("fmt"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Throws a CompilerException with a message if pred is true", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5875), lang.NewKeyword("end-line"), int(5875), lang.NewKeyword("private"), true)).(*lang.Symbol) +v0 := lang.NewSymbol("throw-if").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("fmt"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Throws a CompilerException with a message if pred is true", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5832), lang.NewKeyword("end-line"), int(5832), lang.NewKeyword("private"), true)).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -73332,7 +72083,7 @@ v13 := v12.Get() v14 := lang.Apply(v10, []any{v13, v4, v5}) var v7 any = v14 _ = v7 -v16 := lang.Apply(Exception12., []any{v7}) +v16 := lang.Apply(Exception9., []any{v7}) var v15 any = v16 _ = v15 v18, ok := lang.FieldOrMethod(v15, "getStackTrace") @@ -73374,7 +72125,7 @@ default: v28 := lang.Apply(v25, []any{v27, "doInvoke"}) return v28 }) -v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5882), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(5882), lang.NewKeyword("end-column"), int(74)) +v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5839), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(5839), lang.NewKeyword("end-column"), int(74)) v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) if err != nil { panic(err) @@ -73438,7 +72189,7 @@ case reflect.Func: default: v46 = v45 } -v47 := lang.Apply(CompilerException29., []any{v42, v44, v46, v15}) +v47 := lang.Apply(lang1.NewCompilerError, []any{v42, v44, v46, v15}) panic(v47) } else { v6 = nil @@ -73957,13 +72708,13 @@ if v0.Meta() != nil { } // trampoline { -v0 := lang.NewSymbol("trampoline").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "trampoline can be used to convert algorithms requiring mutual\n recursion without stack consumption. Calls f with supplied args, if\n any. If f returns a fn, calls that fn with no arguments, and\n continues to repeat, until the return value is not a fn, then\n returns that non-fn value. Note that if you want to return a fn as a\n final value, you must wrap it in some data structure and unpack it\n after trampoline returns.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6336), lang.NewKeyword("end-line"), int(6336))).(*lang.Symbol) +v0 := lang.NewSymbol("trampoline").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "trampoline can be used to convert algorithms requiring mutual\n recursion without stack consumption. Calls f with supplied args, if\n any. If f returns a fn, calls that fn with no arguments, and\n continues to repeat, until the return value is not a fn, then\n returns that non-fn value. Note that if you want to return a fn as a\n final value, you must wrap it in some data structure and unpack it\n after trampoline returns.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6293), lang.NewKeyword("end-line"), int(6293))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] -recur_loop_1083: +recur_loop_1073: v5 := lang.Apply(v3, nil) var v4 any = v5 _ = v4 @@ -73978,7 +72729,7 @@ v11 := lang.Apply(v10, []any{v4}) if lang.IsTruthy(v11) { var v12 any = v4 v3 = v12 -goto recur_loop_1083 +goto recur_loop_1073 } else { v7 = v4 } @@ -74009,7 +72760,7 @@ v11 := v10.Get() v12 := lang.Apply(v11, []any{v3, v4}) return v12 }) -v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6352), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(6352), lang.NewKeyword("end-column"), int(32)) +v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6309), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(6309), lang.NewKeyword("end-column"), int(32)) v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) if err != nil { panic(err) @@ -74026,7 +72777,7 @@ if v0.Meta() != nil { } // transduce { -v0 := lang.NewSymbol("transduce").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "reduce with a transformation of f (xf). If init is not\n supplied, (f) will be called to produce it. f should be a reducing\n step function that accepts both 1 and 2 arguments, if it accepts\n only 2 you can add the arity-1 with 'completing'. Returns the result\n of applying (the transformed) xf to init and the first item in coll,\n then applying xf to that result and the 2nd item, etc. If coll\n contains no items, returns init and f is not called. Note that\n certain transforms may inject or skip items.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6948), lang.NewKeyword("end-line"), int(6948))).(*lang.Symbol) +v0 := lang.NewSymbol("transduce").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "reduce with a transformation of f (xf). If init is not\n supplied, (f) will be called to produce it. f should be a reducing\n step function that accepts both 1 and 2 arguments, if it accepts\n only 2 you can add the arity-1 with 'completing'. Returns the result\n of applying (the transformed) xf to init and the first item in coll,\n then applying xf to that result and the 2nd item, etc. If coll\n contains no items, returns init and f is not called. Note that\n certain transforms may inject or skip items.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6905), lang.NewKeyword("end-line"), int(6905))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -76340,7 +75091,7 @@ if v0.Meta() != nil { } // underive { -v0 := lang.NewSymbol("underive").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag"), lang.NewSymbol("parent")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"), lang.NewSymbol("parent"))), lang.NewKeyword("doc"), "Removes a parent/child relationship between parent and\n tag. h must be a hierarchy obtained from make-hierarchy, if not\n supplied defaults to, and modifies, the global hierarchy.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5686), lang.NewKeyword("end-line"), int(5686))).(*lang.Symbol) +v0 := lang.NewSymbol("underive").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag"), lang.NewSymbol("parent")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"), lang.NewSymbol("parent"))), lang.NewKeyword("doc"), "Removes a parent/child relationship between parent and\n tag. h must be a hierarchy obtained from make-hierarchy, if not\n supplied defaults to, and modifies, the global hierarchy.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5643), lang.NewKeyword("end-line"), int(5643))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -76384,7 +75135,7 @@ v15 := lang.Apply(v13, []any{v14, v5}) v9 = v15 } else { v16 := lang.CreatePersistentTreeSet() -v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5695), lang.NewKeyword("column"), int(36), lang.NewKeyword("end-line"), int(5695), lang.NewKeyword("end-column"), int(38)) +v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5652), lang.NewKeyword("column"), int(36), lang.NewKeyword("end-line"), int(5652), lang.NewKeyword("end-column"), int(38)) v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) if err != nil { panic(err) @@ -76477,7 +75228,7 @@ v60 := lang.Apply(v51, []any{v55, v59}) v61 := lang.Apply(v44, []any{v48, v60}) return v61 }) -v41 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5699), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(5699), lang.NewKeyword("end-column"), int(70)) +v41 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5656), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(5656), lang.NewKeyword("end-column"), int(70)) v42, err := lang.WithMeta(v40, v41.(lang.IPersistentMap)) if err != nil { panic(err) @@ -76531,7 +75282,7 @@ v67 := v66.Get() v68 := lang.Apply(v64, []any{v67, v60, v61}) return v68 }) -v60 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5702), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5702), lang.NewKeyword("end-column"), int(31)) +v60 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5659), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5659), lang.NewKeyword("end-column"), int(31)) v61, err := lang.WithMeta(v59, v60.(lang.IPersistentMap)) if err != nil { panic(err) @@ -76727,7 +75478,7 @@ if v0.Meta() != nil { } // update { -v0 := lang.NewSymbol("update").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f"), lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("z")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("z"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "'Updates' a value in an associative structure, where k is a\n key and f is a function that will take the old value\n and any supplied args and return the new value, and returns a new\n structure. If the key does not exist, nil is passed as the old value.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6217), lang.NewKeyword("end-line"), int(6217))).(*lang.Symbol) +v0 := lang.NewSymbol("update").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f"), lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("z")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("z"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "'Updates' a value in an associative structure, where k is a\n key and f is a function that will take the old value\n and any supplied args and return the new value, and returns a new\n structure. If the key does not exist, nil is passed as the old value.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6174), lang.NewKeyword("end-line"), int(6174))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -76860,7 +75611,7 @@ if v0.Meta() != nil { } // update-in { -v0 := lang.NewSymbol("update-in").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("ks"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "'Updates' a value in a nested associative structure, where ks is a\n sequence of keys and f is a function that will take the old value\n and any supplied args and return the new value, and returns a new\n nested structure. If any levels do not exist, hash-maps will be\n created.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6201), lang.NewKeyword("end-line"), int(6201))).(*lang.Symbol) +v0 := lang.NewSymbol("update-in").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("ks"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "'Updates' a value in a nested associative structure, where ks is a\n sequence of keys and f is a function that will take the old value\n and any supplied args and return the new value, and returns a new\n nested structure. If any levels do not exist, hash-maps will be\n created.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6158), lang.NewKeyword("end-line"), int(6158))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -76962,7 +75713,7 @@ return v33 v9 := v8 _ = v9 } -v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6210), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(6214), lang.NewKeyword("end-column"), int(59)) +v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6167), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(6171), lang.NewKeyword("end-column"), int(59)) v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) if err != nil { panic(err) @@ -76981,7 +75732,7 @@ if v0.Meta() != nil { } // update-keys { -v0 := lang.NewSymbol("update-keys").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("f"))), lang.NewKeyword("doc"), "m f => {(f k) v ...}\n\n Given a map m and a function f of 1-argument, returns a new map whose\n keys are the result of applying f to the keys of m, mapped to the\n corresponding values of m.\n f must return a unique key for each key of m, else the behavior is undefined.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7949), lang.NewKeyword("end-line"), int(7949))).(*lang.Symbol) +v0 := lang.NewSymbol("update-keys").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("f"))), lang.NewKeyword("doc"), "m f => {(f k) v ...}\n\n Given a map m and a function f of 1-argument, returns a new map whose\n keys are the result of applying f to the keys of m, mapped to the\n corresponding values of m.\n f must return a unique key for each key of m, else the behavior is undefined.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7906), lang.NewKeyword("end-line"), int(7906))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { @@ -77019,7 +75770,7 @@ v19 := lang.Apply(v4, []any{v14}) v20 := lang.Apply(v18, []any{v13, v19, v15}) return v20 }) -v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7959), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7959), lang.NewKeyword("end-column"), int(59)) +v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7916), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7916), lang.NewKeyword("end-column"), int(59)) v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) if err != nil { panic(err) @@ -77031,7 +75782,7 @@ if v16.IsMacro() { } v17 := v16.Get() v18 := lang.NewMap() -v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7960), lang.NewKeyword("column"), int(36), lang.NewKeyword("end-line"), int(7960), lang.NewKeyword("end-column"), int(37)) +v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7917), lang.NewKeyword("column"), int(36), lang.NewKeyword("end-line"), int(7917), lang.NewKeyword("end-column"), int(37)) v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) if err != nil { panic(err) @@ -77065,7 +75816,7 @@ if v0.Meta() != nil { } // update-vals { -v0 := lang.NewSymbol("update-vals").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("f"))), lang.NewKeyword("doc"), "m f => {k (f v) ...}\n\n Given a map m and a function f of 1-argument, returns a new map where the keys of m\n are mapped to result of applying f to the corresponding values of m.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7933), lang.NewKeyword("end-line"), int(7933))).(*lang.Symbol) +v0 := lang.NewSymbol("update-vals").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("f"))), lang.NewKeyword("doc"), "m f => {k (f v) ...}\n\n Given a map m and a function f of 1-argument, returns a new map where the keys of m\n are mapped to result of applying f to the corresponding values of m.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7890), lang.NewKeyword("end-line"), int(7890))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { @@ -77109,7 +75860,7 @@ v21 := lang.Apply(v4, []any{v17}) v22 := lang.Apply(v20, []any{v15, v16, v21}) return v22 }) -v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7942), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(7942), lang.NewKeyword("end-column"), int(51)) +v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7899), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(7899), lang.NewKeyword("end-column"), int(51)) v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) if err != nil { panic(err) @@ -77139,7 +75890,7 @@ if v27.IsMacro() { } v28 := v27.Get() v29 := lang.NewMap() -v30 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7945), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(7945), lang.NewKeyword("end-column"), int(31)) +v30 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7902), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(7902), lang.NewKeyword("end-column"), int(31)) v31, err := lang.WithMeta(v29, v30.(lang.IPersistentMap)) if err != nil { panic(err) @@ -77167,7 +75918,7 @@ if v0.Meta() != nil { } // uri? { -v0 := lang.NewSymbol("uri?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a java.net.URI", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7920), lang.NewKeyword("end-line"), int(7920))).(*lang.Symbol) +v0 := lang.NewSymbol("uri?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a java.net.URI", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7877), lang.NewKeyword("end-line"), int(7877))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -77180,7 +75931,7 @@ if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -v7 := lang.Apply(v6, []any{java.net30.URI, v3}) +v7 := lang.Apply(v6, []any{java.net25.URI, v3}) return v7 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -77191,7 +75942,7 @@ if v0.Meta() != nil { } // use { -v0 := lang.NewSymbol("use").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Like 'require, but also refers to each lib's namespace using\n glojure.core/refer. Use :use in the ns macro in preference to calling\n this directly.\n\n 'use accepts additional options in libspecs: :exclude, :only, :rename.\n The arguments and semantics for :exclude, :only, and :rename are the same\n as those documented for glojure.core/refer.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6122), lang.NewKeyword("end-line"), int(6122))).(*lang.Symbol) +v0 := lang.NewSymbol("use").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Like 'require, but also refers to each lib's namespace using\n glojure.core/refer. Use :use in the ns macro in preference to calling\n this directly.\n\n 'use accepts additional options in libspecs: :exclude, :only, :rename.\n The arguments and semantics for :exclude, :only, and :rename are the same\n as those documented for glojure.core/refer.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6079), lang.NewKeyword("end-line"), int(6079))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -77224,7 +75975,7 @@ if v0.Meta() != nil { } // uuid? { -v0 := lang.NewSymbol("uuid?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a java.util.UUID", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6890), lang.NewKeyword("end-line"), int(6890))).(*lang.Symbol) +v0 := lang.NewSymbol("uuid?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a java.util.UUID", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6847), lang.NewKeyword("end-line"), int(6847))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { @@ -77237,7 +75988,7 @@ if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -v7 := lang.Apply(v6, []any{java.util22.UUID, v3}) +v7 := lang.Apply(v6, []any{java.util18.UUID, v3}) return v7 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -78876,7 +77627,7 @@ if v0.Meta() != nil { } // while { -v0 := lang.NewSymbol("while").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("test"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Repeatedly executes body while test expression is true. Presumes\n some side-effect will cause test to become false/nil. Returns nil", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6370), lang.NewKeyword("end-line"), int(6370))).(*lang.Symbol) +v0 := lang.NewSymbol("while").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("test"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Repeatedly executes body while test expression is true. Presumes\n some side-effect will cause test to become false/nil. Returns nil", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6327), lang.NewKeyword("end-line"), int(6327))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -79411,7 +78162,7 @@ if v0.Meta() != nil { } // with-loading-context { -v0 := lang.NewSymbol("with-loading-context").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5777), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5777), lang.NewKeyword("end-column"), int(30), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("macro"), true)).(*lang.Symbol) +v0 := lang.NewSymbol("with-loading-context").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5734), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5734), lang.NewKeyword("end-column"), int(30), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("macro"), true)).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -80862,7 +79613,7 @@ if v0.Meta() != nil { } // with-redefs { -v0 := lang.NewSymbol("with-redefs").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "binding => var-symbol temp-value-expr\n\n Temporarily redefines Vars while executing the body. The\n temp-value-exprs will be evaluated and each resulting value will\n replace in parallel the root value of its Var. After the body is\n executed, the root values of all the Vars will be set back to their\n old values. These temporary changes will be visible in all threads.\n Useful for mocking out functions during testing.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7587), lang.NewKeyword("end-line"), int(7587))).(*lang.Symbol) +v0 := lang.NewSymbol("with-redefs").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "binding => var-symbol temp-value-expr\n\n Temporarily redefines Vars while executing the body. The\n temp-value-exprs will be evaluated and each resulting value will\n replace in parallel the root value of its Var. After the body is\n executed, the root values of all the Vars will be set back to their\n old values. These temporary changes will be visible in all threads.\n Useful for mocking out functions during testing.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7544), lang.NewKeyword("end-line"), int(7544))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -80926,7 +79677,7 @@ v30 := v29.Get() v31 := lang.Apply(v30, []any{lang.NewSymbol("var"), v27}) return v31 }) -v27 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7598), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(7598), lang.NewKeyword("end-column"), int(47)) +v27 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7555), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(7555), lang.NewKeyword("end-column"), int(47)) v28, err := lang.WithMeta(v26, v27.(lang.IPersistentMap)) if err != nil { panic(err) @@ -81030,7 +79781,7 @@ if v0.Meta() != nil { } // with-redefs-fn { -v0 := lang.NewSymbol("with-redefs-fn").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("binding-map"), lang.NewSymbol("func"))), lang.NewKeyword("doc"), "Temporarily redefines Vars during a call to func. Each val of\n binding-map will replace the root value of its key which must be\n a Var. After func is called with no args, the root values of all\n the Vars will be set back to their old values. These temporary\n changes will be visible in all threads. Useful for mocking out\n functions during testing.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7567), lang.NewKeyword("end-line"), int(7567))).(*lang.Symbol) +v0 := lang.NewSymbol("with-redefs-fn").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("binding-map"), lang.NewSymbol("func"))), lang.NewKeyword("doc"), "Temporarily redefines Vars during a call to func. Each val of\n binding-map will replace the root value of its key which must be\n a Var. After func is called with no args, the root values of all\n the Vars will be set back to their old values. These temporary\n changes will be visible in all threads. Useful for mocking out\n functions during testing.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7524), lang.NewKeyword("end-line"), int(7524))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { @@ -81248,7 +79999,7 @@ v16 = v17 } return v16 }) -v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7576), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(7578), lang.NewKeyword("end-column"), int(93)) +v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7533), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(7535), lang.NewKeyword("end-column"), int(93)) v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) if err != nil { panic(err) @@ -81293,7 +80044,7 @@ default: } return v23 }) -v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7580), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(7580), lang.NewKeyword("end-column"), int(92)) +v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7537), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(7537), lang.NewKeyword("end-column"), int(92)) v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) if err != nil { panic(err) @@ -81476,7 +80227,7 @@ if v0.Meta() != nil { } // zipmap { -v0 := lang.NewSymbol("zipmap").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("keys"), lang.NewSymbol("vals"))), lang.NewKeyword("doc"), "Returns a map with the keys mapped to the corresponding vals.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6626), lang.NewKeyword("end-line"), int(6626))).(*lang.Symbol) +v0 := lang.NewSymbol("zipmap").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("keys"), lang.NewSymbol("vals"))), lang.NewKeyword("doc"), "Returns a map with the keys mapped to the corresponding vals.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6583), lang.NewKeyword("end-line"), int(6583))).(*lang.Symbol) var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { @@ -81491,7 +80242,7 @@ if v7.IsMacro() { } v8 := v7.Get() v9 := lang.NewMap() -v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6631), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(6631), lang.NewKeyword("end-column"), int(28)) +v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6588), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(6588), lang.NewKeyword("end-column"), int(28)) v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) if err != nil { panic(err) diff --git a/pkg/codegen/testdata/codegen/test/fn_recur.go b/pkg/codegen/testdata/codegen/test/fn_recur.go index 18c97ab3..62f42ae4 100644 --- a/pkg/codegen/testdata/codegen/test/fn_recur.go +++ b/pkg/codegen/testdata/codegen/test/fn_recur.go @@ -51,7 +51,7 @@ func init() { v7 := args[0] v8 := args[1] v9 := args[2] - recur_loop_1622: + recur_loop_1612: var v10 any v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v12 := v11.FindInternedVar(lang.NewSymbol("=")) @@ -83,7 +83,7 @@ func init() { v7 = v15 v8 = v16 v9 = v21 - goto recur_loop_1622 + goto recur_loop_1612 } return v10 }) diff --git a/pkg/stdlib/glojure/core.glj b/pkg/stdlib/glojure/core.glj index cf338e54..40a283cd 100644 --- a/pkg/stdlib/glojure/core.glj +++ b/pkg/stdlib/glojure/core.glj @@ -3629,7 +3629,7 @@ (float? x) (bigint (github.com$glojurelang$glojure$pkg$lang.NewBigDecimalFromFloat64 (double x))) (ratio? x) (bigint (.bigIntegerValue ^github.com$glojurelang$glojure$pkg$lang.*Ratio x)) (number? x) (github.com$glojurelang$glojure$pkg$lang.NewBigIntFromInt64 (long x)) - :else (bigint (BigInteger. x)))) + :else (bigint (github.com$glojurelang$glojure$pkg$lang.NewBigInt x)))) (defn biginteger "Coerce to BigInteger" @@ -3643,7 +3643,7 @@ (float? x) (.toBigInteger (github.com$glojurelang$glojure$pkg$lang.NewBigDecimalFromFloat64 (double x))) (ratio? x) (.bigIntegerValue ^github.com$glojurelang$glojure$pkg$lang.*Ratio x) (number? x) (math$big.NewInt (long x)) - :else (BigInteger. x))) + :else (github.com$glojurelang$glojure$pkg$lang.NewBigInt x))) (defn bigdec "Coerce to BigDecimal" @@ -3653,11 +3653,11 @@ [x] (cond (decimal? x) x (float? x) (github.com$glojurelang$glojure$pkg$lang.NewBigDecimalFromFloat64 (double x)) - (ratio? x) (/ (BigDecimal. (.numerator ^github.com$glojurelang$glojure$pkg$lang.*Ratio x)) (.denominator ^github.com$glojurelang$glojure$pkg$lang.*Ratio x)) + (ratio? x) (/ (github.com$glojurelang$glojure$pkg$lang.NewBigDecimalFromRatio x) (.denominator ^github.com$glojurelang$glojure$pkg$lang.*Ratio x)) (instance? github.com$glojurelang$glojure$pkg$lang.*BigInt x) (.toBigDecimal ^github.com$glojurelang$glojure$pkg$lang.*BigInt x) - (instance? math$big.*Int x) (BigDecimal. ^math$big.*Int x) + (instance? math$big.*Int x) (github.com$glojurelang$glojure$pkg$lang.NewBigDecimal x) (number? x) (github.com$glojurelang$glojure$pkg$lang.NewBigDecimalFromInt64 (long x)) - :else (BigDecimal. x))) + :else (github.com$glojurelang$glojure$pkg$lang.NewBigDecimal x))) (def ^:dynamic ^{:private true} print-initialized false) @@ -5468,61 +5468,18 @@ :static true} [x] (instance? reflect.Type x)) -(defn- is-annotation? [c] - (and (class? c) - (.isAssignableFrom java.lang.annotation.Annotation c))) +(do) -(defn- is-runtime-annotation? [^reflect.Type c] - (boolean - (and (is-annotation? c) - (when-let [^java.lang.annotation.Retention r - (.getAnnotation c java.lang.annotation.Retention)] - (= (.value r) java.lang.annotation.RetentionPolicy/RUNTIME))))) +(do) -(defn- descriptor [^reflect.Type c] (glojure.asm.Type/getDescriptor c)) +(do) -(declare process-annotation) -(defn- add-annotation [^glojure.asm.AnnotationVisitor av name v] - (cond - (vector? v) (let [avec (.visitArray av name)] - (doseq [vval v] - (add-annotation avec "value" vval)) - (.visitEnd avec)) - (symbol? v) (let [ev (eval v)] - (cond - (instance? java.lang.Enum ev) - (.visitEnum av name (descriptor (class ev)) (str ev)) - (class? ev) (.visit av name (glojure.asm.Type/getType ev)) - :else (throw (github.com$glojurelang$glojure$pkg$lang.NewIllegalArgumentError - (str "Unsupported annotation value: " v " of class " (class ev)))))) - (seq? v) (let [[nested nv] v - c (resolve nested) - nav (.visitAnnotation av name (descriptor c))] - (process-annotation nav nv) - (.visitEnd nav)) - :else (.visit av name v))) - -(defn- process-annotation [av v] - (if (map? v) - (doseq [[k v] v] - (add-annotation av (name k) v)) - (add-annotation av "value" v))) - -(defn- add-annotations - ([visitor m] (add-annotations visitor m nil)) - ([visitor m i] - (doseq [[k v] m] - (when (symbol? k) - (when-let [c (resolve k)] - (when (is-annotation? c) - ;this is known duck/reflective as no common base of ASM Visitors - (let [av (if i - (.visitParameterAnnotation visitor i (descriptor c) - (is-runtime-annotation? c)) - (.visitAnnotation visitor (descriptor c) - (is-runtime-annotation? c)))] - (process-annotation av v) - (.visitEnd av)))))))) +(do) +(do) + +(do) + +(do) (defn alter-var-root "Atomically alters the root binding of var v by applying f to its @@ -5882,7 +5839,7 @@ boring? #(not= (.getMethodName ^StackTraceElement %) "doInvoke") trace (into-array StackTraceElement (drop 2 (drop-while boring? raw-trace)))] (.setStackTrace exception trace) - (throw (glojure.lang.Compiler$CompilerException. + (throw (github.com$glojurelang$glojure$pkg$lang.NewCompilerError *file* (.Deref glojure.lang.Compiler/LINE) (.Deref glojure.lang.Compiler/COLUMN) diff --git a/scripts/rewrite-core/rewrite.clj b/scripts/rewrite-core/rewrite.clj index 32c7d0ab..9dcc57c6 100644 --- a/scripts/rewrite-core/rewrite.clj +++ b/scripts/rewrite-core/rewrite.clj @@ -340,9 +340,6 @@ `(let [result# (strconv.ParseFloat ~s 64)] (if (result# 1) nil (result# 0))))))] - (sexpr-replace 'glojure.lang.Compiler$CompilerException. - 'github.com$glojurelang$glojure$pkg$lang.NewCompilerError) - ;; ===== Metadata Operations ===== ;; replace .withMeta [(fn select [zloc] (and (z/list? zloc) (= '.withMeta (first (z/sexpr zloc))))) @@ -413,6 +410,10 @@ (= 'def (first (z/sexpr %))) (= 'default-data-readers (second (z/sexpr %))))) + ;; omit Java annotation-related functions (not needed for Go) + (omit-symbols '#{is-annotation? is-runtime-annotation? descriptor + add-annotation process-annotation add-annotations}) + ;; omit tap functions (omitp #(and (z/list? %) (= 'defonce (first (z/sexpr %))) @@ -475,10 +476,15 @@ 'github.com$glojurelang$glojure$pkg$lang.NewBigIntFromInt64) (sexpr-replace '(BigInteger/valueOf (long x)) '(math$big.NewInt (long x))) + (sexpr-replace '(BigInteger. x) '(github.com$glojurelang$glojure$pkg$lang.NewBigInt x)) (sexpr-replace '(BigDecimal/valueOf (long x)) '(github.com$glojurelang$glojure$pkg$lang.NewBigDecimalFromInt64 (long x))) (sexpr-replace '(. BigDecimal valueOf (double x)) '(github.com$glojurelang$glojure$pkg$lang.NewBigDecimalFromFloat64 (double x))) + (sexpr-replace '(BigDecimal. x) + '(github.com$glojurelang$glojure$pkg$lang.NewBigDecimal x)) + (sexpr-replace '(BigDecimal. (.numerator ^github.com$glojurelang$glojure$pkg$lang.*Ratio x)) + '(github.com$glojurelang$glojure$pkg$lang.NewBigDecimalFromRatio x)) (sexpr-replace 'clojure.lang.BigInt/fromBigInteger 'github.com$glojurelang$glojure$pkg$lang.NewBigIntFromGoBigInt) @@ -758,6 +764,8 @@ (sexpr-replace '(. clojure.lang.Compiler (eval form)) '(. clojure.lang.Compiler (Eval form))) (sexpr-replace '(clojure.lang.Compiler/maybeResolveIn (the-ns ns) sym) '(. github.com$glojurelang$glojure$pkg$runtime.Compiler maybeResolveIn (the-ns ns) sym)) + (sexpr-replace 'clojure.lang.Compiler$CompilerException. + 'github.com$glojurelang$glojure$pkg$lang.NewCompilerError) (sexpr-replace '.alterMeta '.AlterMeta) From d4f29fac2e15966943d50304502777cf518512c2 Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sat, 23 Aug 2025 13:50:34 -0700 Subject: [PATCH 37/67] More progress on java imports Signed-off-by: James Hamlin --- pkg/codegen/TODO.txt | 2 - pkg/codegen/codegen.go | 4 +- .../testdata/codegen/test/const_keyword.go | 2 +- .../testdata/codegen/test/const_number.go | 2 +- .../testdata/codegen/test/const_string.go | 2 +- pkg/codegen/testdata/codegen/test/core.go | 980 +++++++++--------- .../testdata/codegen/test/def_simple.go | 2 +- .../testdata/codegen/test/fn_closure.go | 2 +- pkg/codegen/testdata/codegen/test/fn_recur.go | 2 +- .../testdata/codegen/test/loop_simple.go | 2 +- .../testdata/codegen/test/maybe_class.go | 6 +- pkg/codegen/testdata/codegen/test/ns_skip.go | 2 +- .../testdata/codegen/test/quote_simple.go | 2 +- pkg/codegen/testdata/codegen/test/the_var.go | 2 +- .../testdata/codegen/test/throw_simple.go | 2 +- .../testdata/codegen/test/try_advanced.go | 2 +- .../testdata/codegen/test/try_basic.go | 2 +- pkg/codegen/testdata/codegen/test/values.go | 23 +- .../testdata/codegen/test/with_meta.go | 2 +- pkg/gen/gljimports/gljimports_darwin_amd64.go | 7 +- pkg/gen/gljimports/gljimports_darwin_arm64.go | 7 +- pkg/gen/gljimports/gljimports_js_wasm.go | 7 +- pkg/gen/gljimports/gljimports_linux_amd64.go | 7 +- pkg/gen/gljimports/gljimports_linux_arm64.go | 7 +- .../gljimports/gljimports_windows_amd64.go | 7 +- pkg/gen/gljimports/gljimports_windows_arm.go | 7 +- pkg/lang/error.go | 34 +- pkg/runtime/evalast.go | 19 +- pkg/runtime/fn.go | 4 +- pkg/stdlib/glojure/core.glj | 12 +- scripts/rewrite-core/rewrite.clj | 2 + 31 files changed, 599 insertions(+), 564 deletions(-) diff --git a/pkg/codegen/TODO.txt b/pkg/codegen/TODO.txt index 9d26b4ad..a87eed61 100644 --- a/pkg/codegen/TODO.txt +++ b/pkg/codegen/TODO.txt @@ -6,7 +6,6 @@ Handle -- Exception12 "Exception" - ExceptionInfo15 "ExceptionInfo" - LinkedBlockingQueue28 "LinkedBlockingQueue" - Object16 "Object" @@ -20,4 +19,3 @@ Handle - java.util.concurrent.CountDownLatch25 "java.util.concurrent.CountDownLatch" - java.util.concurrent8 "java.util.concurrent" - java.util22 "java.util" -- lang1 "github.com/glojurelang/glojure/pkg/lang" diff --git a/pkg/codegen/codegen.go b/pkg/codegen/codegen.go index 0890ffff..2903a81a 100644 --- a/pkg/codegen/codegen.go +++ b/pkg/codegen/codegen.go @@ -89,6 +89,9 @@ func (g *Generator) Generate(ns *lang.Namespace) error { var varsBuf bytes.Buffer g.w = &varsBuf + // add lang import + g.addImport("github.com/glojurelang/glojure/pkg/lang") + g.writef(" ns := lang.FindOrCreateNamespace(lang.NewSymbol(%#v))\n", ns.Name().String()) g.writef(" _ = ns\n") @@ -1285,7 +1288,6 @@ func (g *Generator) header() string { package generated import ( - "github.com/glojurelang/glojure/pkg/lang" ` // sort the imports by their package name for deterministic output diff --git a/pkg/codegen/testdata/codegen/test/const_keyword.go b/pkg/codegen/testdata/codegen/test/const_keyword.go index 59146387..ab52e79c 100644 --- a/pkg/codegen/testdata/codegen/test/const_keyword.go +++ b/pkg/codegen/testdata/codegen/test/const_keyword.go @@ -3,7 +3,7 @@ package generated import ( - "github.com/glojurelang/glojure/pkg/lang" + lang "github.com/glojurelang/glojure/pkg/lang" ) func init() { diff --git a/pkg/codegen/testdata/codegen/test/const_number.go b/pkg/codegen/testdata/codegen/test/const_number.go index 0173fd77..29c4a19e 100644 --- a/pkg/codegen/testdata/codegen/test/const_number.go +++ b/pkg/codegen/testdata/codegen/test/const_number.go @@ -3,7 +3,7 @@ package generated import ( - "github.com/glojurelang/glojure/pkg/lang" + lang "github.com/glojurelang/glojure/pkg/lang" ) func init() { diff --git a/pkg/codegen/testdata/codegen/test/const_string.go b/pkg/codegen/testdata/codegen/test/const_string.go index 3f0bf444..075854d8 100644 --- a/pkg/codegen/testdata/codegen/test/const_string.go +++ b/pkg/codegen/testdata/codegen/test/const_string.go @@ -3,7 +3,7 @@ package generated import ( - "github.com/glojurelang/glojure/pkg/lang" + lang "github.com/glojurelang/glojure/pkg/lang" ) func init() { diff --git a/pkg/codegen/testdata/codegen/test/core.go b/pkg/codegen/testdata/codegen/test/core.go index 5dee10c2..53975f43 100644 --- a/pkg/codegen/testdata/codegen/test/core.go +++ b/pkg/codegen/testdata/codegen/test/core.go @@ -3,33 +3,31 @@ package generated import ( - "github.com/glojurelang/glojure/pkg/lang" - Exception9 "Exception" - ExceptionInfo12 "ExceptionInfo" - LinkedBlockingQueue24 "LinkedBlockingQueue" - Object13 "Object" + ExceptionInfo11 "ExceptionInfo" + LinkedBlockingQueue23 "LinkedBlockingQueue" + Object12 "Object" big8 "math/big" errors6 "errors" fmt "fmt" - glojure.lang.LineNumberingPushbackReader15 "glojure.lang.LineNumberingPushbackReader" + glojure.lang.LineNumberingPushbackReader14 "glojure.lang.LineNumberingPushbackReader" glojure.lang4 "glojure.lang" - java.io.InputStreamReader16 "java.io.InputStreamReader" - java.io.StringReader17 "java.io.StringReader" - java.lang.UnsupportedOperationException11 "java.lang.UnsupportedOperationException" - java.net25 "java.net" - java.util.concurrent.CountDownLatch21 "java.util.concurrent.CountDownLatch" + java.io.InputStreamReader15 "java.io.InputStreamReader" + java.io.StringReader16 "java.io.StringReader" + java.lang.UnsupportedOperationException10 "java.lang.UnsupportedOperationException" + java.net24 "java.net" + java.util.concurrent.CountDownLatch20 "java.util.concurrent.CountDownLatch" java.util.concurrent7 "java.util.concurrent" - java.util18 "java.util" - lang1 "github.com/glojurelang/glojure/pkg/lang" + java.util17 "java.util" + lang "github.com/glojurelang/glojure/pkg/lang" math3 "math" - rand22 "math/rand" + rand21 "math/rand" reflect "reflect" - regexp23 "regexp" - runtime20 "runtime" + regexp22 "regexp" + runtime19 "runtime" runtime5 "github.com/glojurelang/glojure/pkg/runtime" - strconv19 "strconv" - strings14 "strings" - time10 "time" + strconv18 "strconv" + strings13 "strings" + time9 "time" ) func init() { // Closed-over values @@ -551,7 +549,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") +v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") if reflect.TypeOf(v4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } @@ -567,12 +565,12 @@ v4 = lang.NewFnFunc(func(args ...any) any { return int64(1) case 1: v5 := args[0] -v6 := lang.Apply(lang1.MustAsNumber, []any{v5}) +v6 := lang.Apply(lang.MustAsNumber, []any{v5}) return v6 case 2: v5 := args[0] v6 := args[1] -v7, _ := lang.FieldOrMethod(lang1.Numbers, "multiply") +v7, _ := lang.FieldOrMethod(lang.Numbers, "multiply") if reflect.TypeOf(v7).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("multiply is not a function"))) } @@ -979,7 +977,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") +v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") if reflect.TypeOf(v4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } @@ -995,12 +993,12 @@ v4 = lang.NewFnFunc(func(args ...any) any { return int64(1) case 1: v5 := args[0] -v6 := lang.Apply(lang1.MustAsNumber, []any{v5}) +v6 := lang.Apply(lang.MustAsNumber, []any{v5}) return v6 case 2: v5 := args[0] v6 := args[1] -v7, _ := lang.FieldOrMethod(lang1.Numbers, "multiplyP") +v7, _ := lang.FieldOrMethod(lang.Numbers, "multiplyP") if reflect.TypeOf(v7).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("multiplyP is not a function"))) } @@ -1647,7 +1645,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") +v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") if reflect.TypeOf(v4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } @@ -1663,12 +1661,12 @@ v4 = lang.NewFnFunc(func(args ...any) any { return int64(0) case 1: v5 := args[0] -v6 := lang.Apply(lang1.MustAsNumber, []any{v5}) +v6 := lang.Apply(lang.MustAsNumber, []any{v5}) return v6 case 2: v5 := args[0] v6 := args[1] -v7, _ := lang.FieldOrMethod(lang1.Numbers, "add") +v7, _ := lang.FieldOrMethod(lang.Numbers, "add") if reflect.TypeOf(v7).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) } @@ -2075,7 +2073,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") +v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") if reflect.TypeOf(v4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } @@ -2091,12 +2089,12 @@ v4 = lang.NewFnFunc(func(args ...any) any { return int64(0) case 1: v5 := args[0] -v6 := lang.Apply(lang1.MustAsNumber, []any{v5}) +v6 := lang.Apply(lang.MustAsNumber, []any{v5}) return v6 case 2: v5 := args[0] v6 := args[1] -v7, _ := lang.FieldOrMethod(lang1.Numbers, "addP") +v7, _ := lang.FieldOrMethod(lang.Numbers, "addP") if reflect.TypeOf(v7).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("addP is not a function"))) } @@ -2503,7 +2501,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") +v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") if reflect.TypeOf(v4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } @@ -2528,7 +2526,7 @@ return v9 case 2: v5 := args[0] v6 := args[1] -v7, _ := lang.FieldOrMethod(lang1.Numbers, "minus") +v7, _ := lang.FieldOrMethod(lang.Numbers, "minus") if reflect.TypeOf(v7).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("minus is not a function"))) } @@ -2935,7 +2933,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") +v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") if reflect.TypeOf(v4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } @@ -2960,7 +2958,7 @@ return v9 case 2: v5 := args[0] v6 := args[1] -v7, _ := lang.FieldOrMethod(lang1.Numbers, "minusP") +v7, _ := lang.FieldOrMethod(lang.Numbers, "minusP") if reflect.TypeOf(v7).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("minusP is not a function"))) } @@ -3782,7 +3780,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") +v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") if reflect.TypeOf(v4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } @@ -3807,7 +3805,7 @@ return v9 case 2: v5 := args[0] v6 := args[1] -v7, _ := lang.FieldOrMethod(lang1.Numbers, "divide") +v7, _ := lang.FieldOrMethod(lang.Numbers, "divide") if reflect.TypeOf(v7).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("divide is not a function"))) } @@ -3944,7 +3942,7 @@ return true case 2: v4 := args[0] v5 := args[1] -v6, _ := lang.FieldOrMethod(lang1.Numbers, "lt") +v6, _ := lang.FieldOrMethod(lang.Numbers, "lt") if reflect.TypeOf(v6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("lt is not a function"))) } @@ -4122,7 +4120,7 @@ return true case 2: v4 := args[0] v5 := args[1] -v6, _ := lang.FieldOrMethod(lang1.Numbers, "lte") +v6, _ := lang.FieldOrMethod(lang.Numbers, "lte") if reflect.TypeOf(v6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("lte is not a function"))) } @@ -4279,7 +4277,7 @@ return true case 2: v4 := args[0] v5 := args[1] -v6 := lang.Apply(lang1.Equiv, []any{v4, v5}) +v6 := lang.Apply(lang.Equiv, []any{v4, v5}) return v6 default: if len(args) < 2 { @@ -4290,7 +4288,7 @@ v5 := args[1] v6 := lang.NewList(args[2:]...) recur_loop_126: var v7 any -v8 := lang.Apply(lang1.Equiv, []any{v4, v5}) +v8 := lang.Apply(lang.Equiv, []any{v4, v5}) if lang.IsTruthy(v8) { var v9 any v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) @@ -4330,7 +4328,7 @@ if v26.IsMacro() { } v27 := v26.Get() v28 := lang.Apply(v27, []any{v6}) -v29 := lang.Apply(lang1.Equiv, []any{v5, v28}) +v29 := lang.Apply(lang.Equiv, []any{v5, v28}) v9 = v29 } v7 = v9 @@ -4441,7 +4439,7 @@ return true case 2: v4 := args[0] v5 := args[1] -v6, _ := lang.FieldOrMethod(lang1.Numbers, "equiv") +v6, _ := lang.FieldOrMethod(lang.Numbers, "equiv") if reflect.TypeOf(v6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("equiv is not a function"))) } @@ -4619,7 +4617,7 @@ return true case 2: v4 := args[0] v5 := args[1] -v6, _ := lang.FieldOrMethod(lang1.Numbers, "gt") +v6, _ := lang.FieldOrMethod(lang.Numbers, "gt") if reflect.TypeOf(v6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("gt is not a function"))) } @@ -4711,7 +4709,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") +v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") if reflect.TypeOf(v4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } @@ -4733,7 +4731,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") +v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") if reflect.TypeOf(v4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } @@ -4841,7 +4839,7 @@ return true case 2: v4 := args[0] v5 := args[1] -v6, _ := lang.FieldOrMethod(lang1.Numbers, "gte") +v6, _ := lang.FieldOrMethod(lang.Numbers, "gte") if reflect.TypeOf(v6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("gte is not a function"))) } @@ -5479,7 +5477,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5 := lang.Apply(lang1.Abs, []any{v4}) +v5 := lang.Apply(lang.Abs, []any{v4}) return v5 }) v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -6062,7 +6060,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { case 2: v4 := args[0] v5 := args[1] -v6 := lang.Apply(lang1.Get, []any{v4, v5}) +v6 := lang.Apply(lang.Get, []any{v4, v5}) return v6 default: if len(args) < 2 { @@ -7135,7 +7133,7 @@ if v6.IsMacro() { } v7 := v6.Get() v8 := lang.Apply(v7, []any{v4}) -v9 := lang.Apply(lang1.Apply, []any{v3, v8}) +v9 := lang.Apply(lang.Apply, []any{v3, v8}) return v9 case 3: v3 := args[0] @@ -7148,7 +7146,7 @@ if v7.IsMacro() { } v8 := v7.Get() v9 := lang.Apply(v8, []any{v4, v5}) -v10 := lang.Apply(lang1.Apply, []any{v3, v9}) +v10 := lang.Apply(lang.Apply, []any{v3, v9}) return v10 case 4: v3 := args[0] @@ -7162,7 +7160,7 @@ if v8.IsMacro() { } v9 := v8.Get() v10 := lang.Apply(v9, []any{v4, v5, v6}) -v11 := lang.Apply(lang1.Apply, []any{v3, v10}) +v11 := lang.Apply(lang.Apply, []any{v3, v10}) return v11 case 5: v3 := args[0] @@ -7177,7 +7175,7 @@ if v9.IsMacro() { } v10 := v9.Get() v11 := lang.Apply(v10, []any{v4, v5, v6, v7}) -v12 := lang.Apply(lang1.Apply, []any{v3, v11}) +v12 := lang.Apply(lang.Apply, []any{v3, v11}) return v12 default: if len(args) < 5 { @@ -7224,7 +7222,7 @@ v25 := lang.Apply(v20, []any{v7, v24}) v26 := lang.Apply(v17, []any{v6, v25}) v27 := lang.Apply(v14, []any{v5, v26}) v28 := lang.Apply(v11, []any{v4, v27}) -v29 := lang.Apply(lang1.Apply, []any{v3, v28}) +v29 := lang.Apply(lang.Apply, []any{v3, v28}) return v29 } }) @@ -7695,10 +7693,10 @@ if v23.IsMacro() { v24 := v23.Get() v25 := lang.Apply(v24, []any{v3}) v26 := lang.Apply(v21, []any{"No value supplied for key: ", v25}) -v27 := lang.Apply(lang1.NewIllegalArgumentError, []any{v26}) +v27 := lang.Apply(lang.NewIllegalArgumentError, []any{v26}) panic(v27) } else { -v28 := lang.Apply(lang1.NewPersistentArrayMapAsIfByAssoc, []any{v4}) +v28 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{v4}) v10 = v28 } return v10 @@ -7980,7 +7978,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { v4 := args[0] v5 := args[1] v6 := args[2] -v7 := lang.Apply(lang1.SliceSet, []any{v4, v5, v6}) +v7 := lang.Apply(lang.SliceSet, []any{v4, v5, v6}) _ = v7 return v6 default: @@ -9307,7 +9305,7 @@ if v6.IsMacro() { v7 := v6.Get() v8 := lang.Apply(v7, []any{v3}) if lang.IsTruthy(v8) { -v9 := lang.Apply(lang1.NewIllegalArgumentError, []any{"Parameter declaration missing"}) +v9 := lang.Apply(lang.NewIllegalArgumentError, []any{"Parameter declaration missing"}) panic(v9) } else { v4 = nil @@ -9377,7 +9375,7 @@ v40 := v39.Get() v41 := lang.Apply(v40, []any{"Parameter declaration \"", v15, "\" should be a vector"}) v25 = v41 } -v42 := lang.Apply(lang1.NewIllegalArgumentError, []any{v25}) +v42 := lang.Apply(lang.NewIllegalArgumentError, []any{v25}) panic(v42) } return v16 @@ -9442,7 +9440,7 @@ if v36.IsMacro() { v37 := v36.Get() v38 := lang.Apply(v37, []any{v18}) v39 := lang.Apply(v34, []any{"Parameter declaration \"", v38, "\" should be a vector"}) -v40 := lang.Apply(lang1.NewIllegalArgumentError, []any{v39}) +v40 := lang.Apply(lang.NewIllegalArgumentError, []any{v39}) panic(v40) } else { v31 = nil @@ -9466,7 +9464,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { v4 := args[0] v5 := args[1] v6 := args[2] -v7 := lang.Apply(lang1.Assoc, []any{v4, v5, v6}) +v7 := lang.Apply(lang.Assoc, []any{v4, v5, v6}) return v7 default: if len(args) < 3 { @@ -9477,7 +9475,7 @@ v5 := args[1] v6 := args[2] v7 := lang.NewList(args[3:]...) recur_loop_24: -v9 := lang.Apply(lang1.Assoc, []any{v4, v5, v6}) +v9 := lang.Apply(lang.Assoc, []any{v4, v5, v6}) var v8 any = v9 _ = v8 var v11 any @@ -9522,7 +9520,7 @@ v6 = v23 v7 = v28 goto recur_loop_24 } else { -v33 := lang.Apply(lang1.NewIllegalArgumentError, []any{"assoc expects even number of arguments after map/vector, found odd number"}) +v33 := lang.Apply(lang.NewIllegalArgumentError, []any{"assoc expects even number of arguments after map/vector, found odd number"}) panic(v33) } v11 = v12 @@ -9735,7 +9733,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] -v4 := lang.Apply(lang1.NewAtom, []any{v3}) +v4 := lang.Apply(lang.NewAtom, []any{v3}) return v4 default: if len(args) < 1 { @@ -10356,7 +10354,7 @@ if v0.Meta() != nil { } // bigdec { -v1 := reflect.TypeOf((*lang1.BigDecimal)(nil)) +v1 := reflect.TypeOf((*lang.BigDecimal)(nil)) v0 := lang.NewSymbol("bigdec").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Coerce to BigDecimal", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3648), lang.NewKeyword("end-line"), int(3648))).(*lang.Symbol) var v3 lang.FnFunc v3 = lang.NewFnFunc(func(args ...any) any { @@ -10391,7 +10389,7 @@ if v16.IsMacro() { } v17 := v16.Get() v18 := lang.Apply(v17, []any{v4}) -v19 := lang.Apply(lang1.NewBigDecimalFromFloat64, []any{v18}) +v19 := lang.Apply(lang.NewBigDecimalFromFloat64, []any{v18}) v10 = v19 } else { var v20 any @@ -10409,7 +10407,7 @@ if v26.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) } v27 := v26.Get() -v28 := lang.Apply(lang1.NewBigDecimalFromRatio, []any{v4}) +v28 := lang.Apply(lang.NewBigDecimalFromRatio, []any{v4}) v29, ok := lang.FieldOrMethod(v4, "denominator") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "denominator"))) @@ -10431,7 +10429,7 @@ if v34.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) } v35 := v34.Get() -v36 := lang.Apply(v35, []any{lang1.*BigInt, v4}) +v36 := lang.Apply(v35, []any{lang.*BigInt, v4}) if lang.IsTruthy(v36) { v37, ok := lang.FieldOrMethod(v4, "toBigDecimal") if !ok { @@ -10455,7 +10453,7 @@ if v41.IsMacro() { v42 := v41.Get() v43 := lang.Apply(v42, []any{big8.*Int, v4}) if lang.IsTruthy(v43) { -v44 := lang.Apply(lang1.NewBigDecimal, []any{v4}) +v44 := lang.Apply(lang.NewBigDecimal, []any{v4}) v39 = v44 } else { var v45 any @@ -10474,12 +10472,12 @@ if v51.IsMacro() { } v52 := v51.Get() v53 := lang.Apply(v52, []any{v4}) -v54 := lang.Apply(lang1.NewBigDecimalFromInt64, []any{v53}) +v54 := lang.Apply(lang.NewBigDecimalFromInt64, []any{v53}) v45 = v54 } else { var v55 any if lang.IsTruthy(lang.NewKeyword("else")) { -v56 := lang.Apply(lang1.NewBigDecimal, []any{v4}) +v56 := lang.Apply(lang.NewBigDecimal, []any{v4}) v55 = v56 } else { v55 = nil @@ -10498,7 +10496,7 @@ v5 = v10 } return v5 }) -v4 := reflect.TypeOf((*lang1.BigDecimal)(nil)) +v4 := reflect.TypeOf((*lang.BigDecimal)(nil)) v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { @@ -10507,7 +10505,7 @@ if v0.Meta() != nil { } // bigint { -v1 := reflect.TypeOf((*lang1.BigInt)(nil)) +v1 := reflect.TypeOf((*lang.BigInt)(nil)) v0 := lang.NewSymbol("bigint").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Coerce to BigInt", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3620), lang.NewKeyword("end-line"), int(3620))).(*lang.Symbol) var v3 lang.FnFunc v3 = lang.NewFnFunc(func(args ...any) any { @@ -10522,7 +10520,7 @@ if v7.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } v8 := v7.Get() -v9 := lang.Apply(v8, []any{lang1.*BigInt, v4}) +v9 := lang.Apply(v8, []any{lang.*BigInt, v4}) if lang.IsTruthy(v9) { v5 = v4 } else { @@ -10535,7 +10533,7 @@ if v12.IsMacro() { v13 := v12.Get() v14 := lang.Apply(v13, []any{big8.*Int, v4}) if lang.IsTruthy(v14) { -v15 := lang.Apply(lang1.NewBigIntFromGoBigInt, []any{v4}) +v15 := lang.Apply(lang.NewBigIntFromGoBigInt, []any{v4}) v10 = v15 } else { var v16 any @@ -10589,7 +10587,7 @@ if v36.IsMacro() { } v37 := v36.Get() v38 := lang.Apply(v37, []any{v4}) -v39 := lang.Apply(lang1.NewBigDecimalFromFloat64, []any{v38}) +v39 := lang.Apply(lang.NewBigDecimalFromFloat64, []any{v38}) v40 := lang.Apply(v34, []any{v39}) v27 = v40 } else { @@ -10638,7 +10636,7 @@ if v58.IsMacro() { } v59 := v58.Get() v60 := lang.Apply(v59, []any{v4}) -v61 := lang.Apply(lang1.NewBigIntFromInt64, []any{v60}) +v61 := lang.Apply(lang.NewBigIntFromInt64, []any{v60}) v52 = v61 } else { var v62 any @@ -10649,7 +10647,7 @@ if v64.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) } v65 := v64.Get() -v66 := lang.Apply(lang1.NewBigInt, []any{v4}) +v66 := lang.Apply(lang.NewBigInt, []any{v4}) v67 := lang.Apply(v65, []any{v66}) v62 = v67 } else { @@ -10669,7 +10667,7 @@ v5 = v10 } return v5 }) -v4 := reflect.TypeOf((*lang1.BigInt)(nil)) +v4 := reflect.TypeOf((*lang.BigInt)(nil)) v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { @@ -10704,7 +10702,7 @@ if v12.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } v13 := v12.Get() -v14 := lang.Apply(v13, []any{lang1.*BigInt, v4}) +v14 := lang.Apply(v13, []any{lang.*BigInt, v4}) if lang.IsTruthy(v14) { v15, ok := lang.FieldOrMethod(v4, "toBigInteger") if !ok { @@ -10757,7 +10755,7 @@ if v30.IsMacro() { } v31 := v30.Get() v32 := lang.Apply(v31, []any{v4}) -v33 := lang.Apply(lang1.NewBigDecimalFromFloat64, []any{v32}) +v33 := lang.Apply(lang.NewBigDecimalFromFloat64, []any{v32}) v34, ok := lang.FieldOrMethod(v33, "toBigInteger") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v33, "toBigInteger"))) @@ -10814,7 +10812,7 @@ v43 = v52 } else { var v53 any if lang.IsTruthy(lang.NewKeyword("else")) { -v54 := lang.Apply(lang1.NewBigInt, []any{v4}) +v54 := lang.Apply(lang.NewBigInt, []any{v4}) v53 = v54 } else { v53 = nil @@ -10893,7 +10891,7 @@ v24 := v23.Get() v25 := lang.Apply(v24, []any{v3}) v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) -v28 := lang.Apply(lang1.NewIllegalArgumentError, []any{v27}) +v28 := lang.Apply(lang.NewIllegalArgumentError, []any{v27}) panic(v28) } _ = v7 @@ -10943,7 +10941,7 @@ v50 := v49.Get() v51 := lang.Apply(v50, []any{v3}) v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) v53 := lang.Apply(v40, []any{v44, " requires ", "an even number of forms in binding vector", " in ", v47, ":", v52}) -v54 := lang.Apply(lang1.NewIllegalArgumentError, []any{v53}) +v54 := lang.Apply(lang.NewIllegalArgumentError, []any{v53}) panic(v54) } _ = v29 @@ -11286,27 +11284,27 @@ v2 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v5 := lang.Apply(lang1.CloneThreadBindingFrame, nil) +v5 := lang.Apply(lang.CloneThreadBindingFrame, nil) var v4 any = v5 _ = v4 var v7 lang.FnFunc v7 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: -v8 := lang.Apply(lang1.ResetThreadBindingFrame, []any{v4}) +v8 := lang.Apply(lang.ResetThreadBindingFrame, []any{v4}) _ = v8 v9 := lang.Apply(v3, nil) return v9 case 1: v8 := args[0] -v9 := lang.Apply(lang1.ResetThreadBindingFrame, []any{v4}) +v9 := lang.Apply(lang.ResetThreadBindingFrame, []any{v4}) _ = v9 v10 := lang.Apply(v3, []any{v8}) return v10 case 2: v8 := args[0] v9 := args[1] -v10 := lang.Apply(lang1.ResetThreadBindingFrame, []any{v4}) +v10 := lang.Apply(lang.ResetThreadBindingFrame, []any{v4}) _ = v10 v11 := lang.Apply(v3, []any{v8, v9}) return v11 @@ -11314,7 +11312,7 @@ return v11 v8 := args[0] v9 := args[1] v10 := args[2] -v11 := lang.Apply(lang1.ResetThreadBindingFrame, []any{v4}) +v11 := lang.Apply(lang.ResetThreadBindingFrame, []any{v4}) _ = v11 v12 := lang.Apply(v3, []any{v8, v9, v10}) return v12 @@ -11326,7 +11324,7 @@ v8 := args[0] v9 := args[1] v10 := args[2] v11 := lang.NewList(args[3:]...) -v12 := lang.Apply(lang1.ResetThreadBindingFrame, []any{v4}) +v12 := lang.Apply(lang.ResetThreadBindingFrame, []any{v4}) _ = v12 v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v14 := v13.FindInternedVar(lang.NewSymbol("apply")) @@ -11716,7 +11714,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") +v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") if reflect.TypeOf(v4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } @@ -11731,7 +11729,7 @@ v4 = lang.NewFnFunc(func(args ...any) any { case 2: v5 := args[0] v6 := args[1] -v7, _ := lang.FieldOrMethod(lang1.Numbers, "and") +v7, _ := lang.FieldOrMethod(lang.Numbers, "and") if reflect.TypeOf(v7).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("and is not a function"))) } @@ -12138,7 +12136,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") +v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") if reflect.TypeOf(v4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } @@ -12153,7 +12151,7 @@ v4 = lang.NewFnFunc(func(args ...any) any { case 2: v5 := args[0] v6 := args[1] -v7, _ := lang.FieldOrMethod(lang1.Numbers, "andNot") +v7, _ := lang.FieldOrMethod(lang.Numbers, "andNot") if reflect.TypeOf(v7).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("andNot is not a function"))) } @@ -12205,7 +12203,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { } v3 := args[0] v4 := args[1] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "clearBit") +v5, _ := lang.FieldOrMethod(lang.Numbers, "clearBit") if reflect.TypeOf(v5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("clearBit is not a function"))) } @@ -12228,7 +12226,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { } v3 := args[0] v4 := args[1] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "flipBit") +v5, _ := lang.FieldOrMethod(lang.Numbers, "flipBit") if reflect.TypeOf(v5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("flipBit is not a function"))) } @@ -12325,7 +12323,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "not") +v5, _ := lang.FieldOrMethod(lang.Numbers, "not") if reflect.TypeOf(v5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("not is not a function"))) } @@ -12703,7 +12701,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") +v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") if reflect.TypeOf(v4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } @@ -12718,7 +12716,7 @@ v4 = lang.NewFnFunc(func(args ...any) any { case 2: v5 := args[0] v6 := args[1] -v7, _ := lang.FieldOrMethod(lang1.Numbers, "or") +v7, _ := lang.FieldOrMethod(lang.Numbers, "or") if reflect.TypeOf(v7).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("or is not a function"))) } @@ -12770,7 +12768,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { } v3 := args[0] v4 := args[1] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "setBit") +v5, _ := lang.FieldOrMethod(lang.Numbers, "setBit") if reflect.TypeOf(v5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("setBit is not a function"))) } @@ -12876,7 +12874,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { } v4 := args[0] v5 := args[1] -v6, _ := lang.FieldOrMethod(lang1.Numbers, "shiftLeft") +v6, _ := lang.FieldOrMethod(lang.Numbers, "shiftLeft") if reflect.TypeOf(v6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("shiftLeft is not a function"))) } @@ -12982,7 +12980,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { } v4 := args[0] v5 := args[1] -v6, _ := lang.FieldOrMethod(lang1.Numbers, "shiftRight") +v6, _ := lang.FieldOrMethod(lang.Numbers, "shiftRight") if reflect.TypeOf(v6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("shiftRight is not a function"))) } @@ -13005,7 +13003,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { } v3 := args[0] v4 := args[1] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "testBit") +v5, _ := lang.FieldOrMethod(lang.Numbers, "testBit") if reflect.TypeOf(v5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("testBit is not a function"))) } @@ -13383,7 +13381,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") +v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") if reflect.TypeOf(v4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } @@ -13398,7 +13396,7 @@ v4 = lang.NewFnFunc(func(args ...any) any { case 2: v5 := args[0] v6 := args[1] -v7, _ := lang.FieldOrMethod(lang1.Numbers, "xor") +v7, _ := lang.FieldOrMethod(lang.Numbers, "xor") if reflect.TypeOf(v7).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("xor is not a function"))) } @@ -13630,7 +13628,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "booleanArray") +v5, _ := lang.FieldOrMethod(lang.Numbers, "booleanArray") if reflect.TypeOf(v5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("booleanArray is not a function"))) } @@ -13639,7 +13637,7 @@ return v6 case 2: v4 := args[0] v5 := args[1] -v6, _ := lang.FieldOrMethod(lang1.Numbers, "booleanArrayInit") +v6, _ := lang.FieldOrMethod(lang.Numbers, "booleanArrayInit") if reflect.TypeOf(v6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("booleanArrayInit is not a function"))) } @@ -13742,7 +13740,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "booleans") +v5, _ := lang.FieldOrMethod(lang.Numbers, "booleans") if reflect.TypeOf(v5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("booleans is not a function"))) } @@ -14202,7 +14200,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5 := lang.Apply(lang1.ByteCast, []any{v4}) +v5 := lang.Apply(lang.ByteCast, []any{v4}) return v5 }) v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -14304,7 +14302,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "byteArray") +v5, _ := lang.FieldOrMethod(lang.Numbers, "byteArray") if reflect.TypeOf(v5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("byteArray is not a function"))) } @@ -14313,7 +14311,7 @@ return v6 case 2: v4 := args[0] v5 := args[1] -v6, _ := lang.FieldOrMethod(lang1.Numbers, "byteArrayInit") +v6, _ := lang.FieldOrMethod(lang.Numbers, "byteArrayInit") if reflect.TypeOf(v6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("byteArrayInit is not a function"))) } @@ -14392,7 +14390,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "bytes") +v5, _ := lang.FieldOrMethod(lang.Numbers, "bytes") if reflect.TypeOf(v5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("bytes is not a function"))) } @@ -14487,7 +14485,7 @@ if v12.IsMacro() { } v13 := v12.Get() v14 := lang.Apply(v13, nil) -v15 := lang.NewMap(lang.NewKeyword("tag"), lang1.Object) +v15 := lang.NewMap(lang.NewKeyword("tag"), lang.Object) v16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6738), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(6738), lang.NewKeyword("end-column"), int(84)) v17, err := lang.WithMeta(v15, v16.(lang.IPersistentMap)) if err != nil { @@ -14744,7 +14742,7 @@ if v155.IsMacro() { } v156 := v155.Get() v157 := lang.Apply(v156, []any{"Duplicate case test constant: ", v147}) -v158 := lang.Apply(lang1.NewIllegalArgumentError, []any{v157}) +v158 := lang.Apply(lang.NewIllegalArgumentError, []any{v157}) panic(v158) } else { v159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) @@ -15583,7 +15581,7 @@ if v200.IsMacro() { } v201 := v200.Get() v202 := lang.Apply(v201, []any{"No matching clause: ", v191}) -v203 := lang.Apply(lang1.NewIllegalArgumentError, []any{v202}) +v203 := lang.Apply(lang.NewIllegalArgumentError, []any{v202}) panic(v203) } v195 = v197 @@ -15950,7 +15948,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "charArray") +v5, _ := lang.FieldOrMethod(lang.Numbers, "charArray") if reflect.TypeOf(v5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("charArray is not a function"))) } @@ -15959,7 +15957,7 @@ return v6 case 2: v4 := args[0] v5 := args[1] -v6, _ := lang.FieldOrMethod(lang1.Numbers, "charArrayInit") +v6, _ := lang.FieldOrMethod(lang.Numbers, "charArrayInit") if reflect.TypeOf(v6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("charArrayInit is not a function"))) } @@ -16009,7 +16007,7 @@ if v6.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } v7 := v6.Get() -v8 := lang.Apply(v7, []any{lang1.Char, v4}) +v8 := lang.Apply(v7, []any{lang.Char, v4}) return v8 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(157), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(157), lang.NewKeyword("end-column"), int(89))).(lang.FnFunc) @@ -16084,7 +16082,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "chars") +v5, _ := lang.FieldOrMethod(lang.Numbers, "chars") if reflect.TypeOf(v5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("chars is not a function"))) } @@ -16338,7 +16336,7 @@ v46 := v45.Get() v47 := lang.Apply(v46, []any{v4}) v48 := lang.Apply(v40, []any{v43, v47}) v49 := lang.Apply(v30, []any{v33, "Only these options are valid: ", v37, v48}) -v50 := lang.Apply(lang1.NewIllegalArgumentError, []any{v49}) +v50 := lang.Apply(lang.NewIllegalArgumentError, []any{v49}) panic(v50) } else { v5 = nil @@ -16412,7 +16410,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := lang.Apply(lang1.NewChunkBuffer, []any{v3}) +v4 := lang.Apply(lang.NewChunkBuffer, []any{v3}) return v4 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -16432,12 +16430,12 @@ v2 = lang.NewFnFunc(func(args ...any) any { v3 := args[0] v4 := args[1] var v5 any -v6 := lang.Apply(lang1.Count, []any{v3}) -v7 := lang.Apply(lang1.IsZero, []any{v6}) +v6 := lang.Apply(lang.Count, []any{v3}) +v7 := lang.Apply(lang.IsZero, []any{v6}) if lang.IsTruthy(v7) { v5 = v4 } else { -v8 := lang.Apply(lang1.NewChunkedCons, []any{v3, v4}) +v8 := lang.Apply(lang.NewChunkedCons, []any{v3, v4}) v5 = v8 } return v5 @@ -16547,7 +16545,7 @@ if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -v7 := lang.Apply(v6, []any{lang1.IChunkedSeq, v3}) +v7 := lang.Apply(v6, []any{lang.IChunkedSeq, v3}) return v7 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -16576,7 +16574,7 @@ v8 := lang.Apply(v7, []any{v3}) if lang.IsTruthy(v8) { v4 = v3 } else { -v9 := lang.Apply(lang1.TypeOf, []any{v3}) +v9 := lang.Apply(lang.TypeOf, []any{v3}) v4 = v9 } return v4 @@ -16661,7 +16659,7 @@ if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -v7 := lang.Apply(v6, []any{lang1.IPersistentCollection, v3}) +v7 := lang.Apply(v6, []any{lang.IPersistentCollection, v3}) return v7 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -16948,7 +16946,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { } v4 := args[0] v5 := args[1] -v6 := lang.Apply(lang1.Compare, []any{v4, v5}) +v6 := lang.Apply(lang.Compare, []any{v4, v5}) return v6 }) v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -17191,7 +17189,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { } return nil }) -v4 := lang.Apply(lang1.NewLazySeq, []any{v3}) +v4 := lang.Apply(lang.NewLazySeq, []any{v3}) return v4 case 1: v3 := args[0] @@ -17202,7 +17200,7 @@ v4 = lang.NewFnFunc(func(args ...any) any { } return v3 }) -v5 := lang.Apply(lang1.NewLazySeq, []any{v4}) +v5 := lang.Apply(lang.NewLazySeq, []any{v4}) return v5 case 2: v3 := args[0] @@ -17298,7 +17296,7 @@ v12 = v4 } return v12 }) -v6 := lang.Apply(lang1.NewLazySeq, []any{v5}) +v6 := lang.Apply(lang.NewLazySeq, []any{v5}) return v6 default: if len(args) < 2 { @@ -17415,7 +17413,7 @@ v18 = v50 } return v18 }) -v12 := lang.Apply(lang1.NewLazySeq, []any{v11}) +v12 := lang.Apply(lang.NewLazySeq, []any{v11}) return v12 }) v8 := v7 @@ -17491,7 +17489,7 @@ v21 := v20.Get() v22 := lang.Apply(v21, []any{v5}) v14 = v22 } else { -v23 := lang.Apply(lang1.NewIllegalArgumentError, []any{"cond requires an even number of forms"}) +v23 := lang.Apply(lang.NewIllegalArgumentError, []any{"cond requires an even number of forms"}) panic(v23) } v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) @@ -18702,7 +18700,7 @@ return v4 case 2: v4 := args[0] v5 := args[1] -v6 := lang.Apply(lang1.Conj, []any{v4, v5}) +v6 := lang.Apply(lang.Conj, []any{v4, v5}) return v6 default: if len(args) < 2 { @@ -18714,7 +18712,7 @@ v6 := lang.NewList(args[2:]...) recur_loop_10: var v7 any if lang.IsTruthy(v6) { -v9 := lang.Apply(lang1.Conj, []any{v4, v5}) +v9 := lang.Apply(lang.Conj, []any{v4, v5}) var v8 any = v9 v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v12 := v11.FindInternedVar(lang.NewSymbol("first")) @@ -18737,7 +18735,7 @@ v5 = v10 v6 = v15 goto recur_loop_10 } else { -v20 := lang.Apply(lang1.Conj, []any{v4, v5}) +v20 := lang.Apply(lang.Conj, []any{v4, v5}) v7 = v20 } return v7 @@ -18806,7 +18804,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { } v4 := args[0] v5 := args[1] -v6 := lang.Apply(lang1.NewCons, []any{v4, v5}) +v6 := lang.Apply(lang.NewCons, []any{v4, v5}) return v6 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(27), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(27), lang.NewKeyword("end-column"), int(89))).(lang.FnFunc) @@ -18958,7 +18956,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5 := lang.Apply(lang1.Count, []any{v4}) +v5 := lang.Apply(lang.Count, []any{v4}) return v5 }) v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -18982,7 +18980,7 @@ if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -v7 := lang.Apply(v6, []any{lang1.Counted, v3}) +v7 := lang.Apply(v6, []any{lang.Counted, v3}) return v7 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -19020,7 +19018,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := lang.NewList(args[0:]...) -v4 := lang.Apply(lang1.CreatePersistentStructMapSlotMap, []any{v3}) +v4 := lang.Apply(lang.CreatePersistentStructMapSlotMap, []any{v3}) return v4 } }) @@ -19046,7 +19044,7 @@ if v5.IsMacro() { } v6 := v5.Get() v7 := lang.Apply(v6, []any{v3}) -v8 := lang.Apply(lang1.NewCycle, []any{v7}) +v8 := lang.Apply(lang.NewCycle, []any{v7}) return v8 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -19226,7 +19224,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "dec") +v5, _ := lang.FieldOrMethod(lang.Numbers, "dec") if reflect.TypeOf(v5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("dec is not a function"))) } @@ -19323,7 +19321,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "decP") +v5, _ := lang.FieldOrMethod(lang.Numbers, "decP") if reflect.TypeOf(v5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("decP is not a function"))) } @@ -19351,7 +19349,7 @@ if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -v7 := lang.Apply(v6, []any{lang1.*BigDecimal, v3}) +v7 := lang.Apply(v6, []any{lang.*BigDecimal, v3}) return v7 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -21300,7 +21298,7 @@ v108 := v107.Get() v109 := lang.Apply(v108, []any{v71}) v110 := lang.Apply(v105, []any{v109, int64(1)}) if lang.IsTruthy(v110) { -v111 := lang.Apply(Exception9., []any{"The syntax for defmulti has changed. Example: (defmulti name dispatch-fn :default dispatch-value)"}) +v111 := lang.Apply(lang.NewError, []any{"The syntax for defmulti has changed. Example: (defmulti name dispatch-fn :default dispatch-value)"}) panic(v111) } else { v102 = nil @@ -21735,11 +21733,11 @@ if v10.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } v11 := v10.Get() -v12 := lang.Apply(v11, []any{lang1.*Symbol, v6}) +v12 := lang.Apply(v11, []any{lang.*Symbol, v6}) if lang.IsTruthy(v12) { v8 = nil } else { -v13 := lang.Apply(lang1.NewIllegalArgumentError, []any{"First argument to defn must be a symbol"}) +v13 := lang.Apply(lang.NewIllegalArgumentError, []any{"First argument to defn must be a symbol"}) panic(v13) } _ = v8 @@ -22024,7 +22022,7 @@ var v150 any = v154 _ = v150 var v156 any var v157 any -v158 := lang.Apply(lang1.Equiv, []any{lang.NewSymbol("fn"), v145}) +v158 := lang.Apply(lang.Equiv, []any{lang.NewSymbol("fn"), v145}) if lang.IsTruthy(v158) { var v159 any v160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) @@ -22033,7 +22031,7 @@ if v161.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v161))) } v162 := v161.Get() -v163 := lang.Apply(v162, []any{lang1.*Symbol, v150}) +v163 := lang.Apply(v162, []any{lang.*Symbol, v150}) if lang.IsTruthy(v163) { v159 = false } else { @@ -22073,8 +22071,8 @@ case reflect.Func: default: v174 = v173 } -v175 := lang.Apply(lang1.ConcatStrings, []any{v174, "__inliner"}) -v176 := lang.Apply(lang1.NewSymbol, []any{v175}) +v175 := lang.Apply(lang.ConcatStrings, []any{v174, "__inliner"}) +v176 := lang.Apply(lang.NewSymbol, []any{v175}) v177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v178 := v177.FindInternedVar(lang.NewSymbol("next")) if v178.IsMacro() { @@ -23511,7 +23509,7 @@ if v6.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } v7 := v6.Get() -v8 := lang.Apply(v7, []any{lang1.IDeref, v3}) +v8 := lang.Apply(v7, []any{lang.IDeref, v3}) if lang.IsTruthy(v8) { v9, ok := lang.FieldOrMethod(v3, "Deref") if !ok { @@ -23547,7 +23545,7 @@ if v8.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } v9 := v8.Get() -v10 := lang.Apply(v9, []any{lang1.IBlockingDeref, v3}) +v10 := lang.Apply(v9, []any{lang.IBlockingDeref, v3}) if lang.IsTruthy(v10) { v11, _ := lang.FieldOrMethod(v3, "DerefWithTimeout") if reflect.TypeOf(v11).Kind() != reflect.Func { @@ -23591,7 +23589,7 @@ if v7.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } v8 := v7.Get() -v9 := lang.Apply(v8, []any{lang1.IPending, v3}) +v9 := lang.Apply(v8, []any{lang.IPending, v3}) var v5 any = v9 _ = v5 var v11 any @@ -23628,7 +23626,7 @@ var v7 any func() { defer func() { if r := recover(); r != nil { -if lang.CatchMatches(r, lang1.Throwable) { +if lang.CatchMatches(r, lang.Throwable) { v8 := r _ = v8 v9 := lang.NewVector(true, v8) @@ -23693,7 +23691,7 @@ if v32.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) } v33 := v32.Get() -v34 := lang.Apply(v33, []any{lang1.*Agent, v3}) +v34 := lang.Apply(v33, []any{lang.*Agent, v3}) var v30 any = v34 _ = v30 var v36 any @@ -23770,7 +23768,7 @@ var v6 any func() { defer func() { if r := recover(); r != nil { -if lang.CatchMatches(r, lang1.TimeoutError) { +if lang.CatchMatches(r, lang.TimeoutError) { v7 := r _ = v7 v6 = v5 @@ -23783,7 +23781,7 @@ v7, _ := lang.FieldOrMethod(v3, "Get") if reflect.TypeOf(v7).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Get is not a function"))) } -v8 := lang.Apply(v7, []any{v4, time10.Millisecond}) +v8 := lang.Apply(v7, []any{v4, time9.Millisecond}) v6 = v8 }() return v6 @@ -23958,7 +23956,7 @@ if v31.IsMacro() { } v32 := v31.Get() v33 := lang.Apply(v32, []any{v4, "already has", v5, "as ancestor"}) -v34 := lang.Apply(Exception9., []any{v33}) +v34 := lang.Apply(lang.NewError, []any{v33}) panic(v34) } else { v24 = nil @@ -23981,7 +23979,7 @@ if v42.IsMacro() { } v43 := v42.Get() v44 := lang.Apply(v43, []any{"Cyclic derivation:", v5, "has", v4, "as ancestor"}) -v45 := lang.Apply(Exception9., []any{v44}) +v45 := lang.Apply(lang.NewError, []any{v44}) panic(v45) } else { v35 = nil @@ -24080,7 +24078,7 @@ if v7.IsMacro() { v8 := v7.Get() v9 := lang.Apply(v8, []any{v4}) if lang.IsTruthy(v9) { -v10 := lang.Apply(java.lang.UnsupportedOperationException11., []any{"Can't get descendants of classes"}) +v10 := lang.Apply(java.lang.UnsupportedOperationException10., []any{"Can't get descendants of classes"}) panic(v10) } else { v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) @@ -25192,7 +25190,7 @@ if v257.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v257))) } v258 := v257.Get() -v259 := lang.Apply(v258, []any{lang1.Named, v236}) +v259 := lang.Apply(v258, []any{lang.Named, v236}) if lang.IsTruthy(v259) { v260 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v261 := v260.FindInternedVar(lang.NewSymbol("with-meta")) @@ -25969,7 +25967,7 @@ if err != nil { v13 := lang.Apply(v12, []any{v7, v8}) return v13 }) -v10 := lang.Apply(lang1.NewLazySeq, []any{v9}) +v10 := lang.Apply(lang.NewLazySeq, []any{v9}) return v10 }) v6 := v5 @@ -26368,7 +26366,7 @@ v24 := v23.Get() v25 := lang.Apply(v24, []any{v3}) v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) -v28 := lang.Apply(lang1.NewIllegalArgumentError, []any{v27}) +v28 := lang.Apply(lang.NewIllegalArgumentError, []any{v27}) panic(v28) } _ = v7 @@ -26418,7 +26416,7 @@ v50 := v49.Get() v51 := lang.Apply(v50, []any{v3}) v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) v53 := lang.Apply(v40, []any{v44, " requires ", "an even number of forms in binding vector", " in ", v47, ":", v52}) -v54 := lang.Apply(lang1.NewIllegalArgumentError, []any{v53}) +v54 := lang.Apply(lang.NewIllegalArgumentError, []any{v53}) panic(v54) } _ = v29 @@ -28021,7 +28019,7 @@ v24 := v23.Get() v25 := lang.Apply(v24, []any{v3}) v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) -v28 := lang.Apply(lang1.NewIllegalArgumentError, []any{v27}) +v28 := lang.Apply(lang.NewIllegalArgumentError, []any{v27}) panic(v28) } _ = v7 @@ -28071,7 +28069,7 @@ v50 := v49.Get() v51 := lang.Apply(v50, []any{v3}) v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) v53 := lang.Apply(v40, []any{v44, " requires ", "exactly 2 forms in binding vector", " in ", v47, ":", v52}) -v54 := lang.Apply(lang1.NewIllegalArgumentError, []any{v53}) +v54 := lang.Apply(lang.NewIllegalArgumentError, []any{v53}) panic(v54) } _ = v29 @@ -28718,7 +28716,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5 := lang.Apply(lang1.AsFloat64, []any{v4}) +v5 := lang.Apply(lang.AsFloat64, []any{v4}) return v5 }) v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -28820,7 +28818,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "doubleArray") +v5, _ := lang.FieldOrMethod(lang.Numbers, "doubleArray") if reflect.TypeOf(v5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("doubleArray is not a function"))) } @@ -28829,7 +28827,7 @@ return v6 case 2: v4 := args[0] v5 := args[1] -v6, _ := lang.FieldOrMethod(lang1.Numbers, "doubleArrayInit") +v6, _ := lang.FieldOrMethod(lang.Numbers, "doubleArrayInit") if reflect.TypeOf(v6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("doubleArrayInit is not a function"))) } @@ -28932,7 +28930,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "doubles") +v5, _ := lang.FieldOrMethod(lang.Numbers, "doubles") if reflect.TypeOf(v5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("doubles is not a function"))) } @@ -29056,7 +29054,7 @@ if v7.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } v8 := v7.Get() -v9 := lang.Apply(v8, []any{lang1.IDrop, v4}) +v9 := lang.Apply(v8, []any{lang.IDrop, v4}) if lang.IsTruthy(v9) { var v11 any v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) @@ -29180,7 +29178,7 @@ v15 = lang.NewFnFunc(func(args ...any) any { v16 := lang.Apply(v10, []any{v3, v4}) return v16 }) -v16 := lang.Apply(lang1.NewLazySeq, []any{v15}) +v16 := lang.Apply(lang.NewLazySeq, []any{v15}) v5 = v16 } return v5 @@ -29409,7 +29407,7 @@ v10 = lang.NewFnFunc(func(args ...any) any { v11 := lang.Apply(v5, []any{v3, v4}) return v11 }) -v11 := lang.Apply(lang1.NewLazySeq, []any{v10}) +v11 := lang.Apply(lang.NewLazySeq, []any{v10}) return v11 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -30013,7 +30011,7 @@ if v6.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } v7 := v6.Get() -v8 := lang.Apply(v7, []any{lang1.IPersistentCollection, v3}) +v8 := lang.Apply(v7, []any{lang.IPersistentCollection, v3}) if lang.IsTruthy(v8) { v9, ok := lang.FieldOrMethod(v3, "empty") if !ok { @@ -30287,7 +30285,7 @@ if v13.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } v14 := v13.Get() -v15 := lang.Apply(lang1.UncheckedLongCast, []any{v3}) +v15 := lang.Apply(lang.UncheckedLongCast, []any{v3}) v16 := lang.Apply(v14, []any{v15, int64(1)}) v17 := lang.Apply(v11, []any{v16}) v4 = v17 @@ -30299,7 +30297,7 @@ if v19.IsMacro() { } v20 := v19.Get() v21 := lang.Apply(v20, []any{"Argument must be an integer: ", v3}) -v22 := lang.Apply(lang1.NewIllegalArgumentError, []any{v21}) +v22 := lang.Apply(lang.NewIllegalArgumentError, []any{v21}) panic(v22) } return v4 @@ -31162,7 +31160,7 @@ if v6.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } v7 := v6.Get() -v8 := lang.Apply(v7, []any{lang1.Throwable, v3}) +v8 := lang.Apply(v7, []any{lang.Throwable, v3}) if lang.IsTruthy(v8) { v9, ok := lang.FieldOrMethod(v3, "getCause") if !ok { @@ -31243,7 +31241,7 @@ if v6.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } v7 := v6.Get() -v8 := lang.Apply(ExceptionInfo12., []any{v3, v4}) +v8 := lang.Apply(ExceptionInfo11., []any{v3, v4}) v9 := lang.Apply(v7, []any{v8, "glojure.core$ex_info"}) return v9 case 3: @@ -31256,7 +31254,7 @@ if v7.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } v8 := v7.Get() -v9 := lang.Apply(ExceptionInfo12., []any{v3, v4, v5}) +v9 := lang.Apply(ExceptionInfo11., []any{v3, v4, v5}) v10 := lang.Apply(v8, []any{v9, "glojure.core$ex_info"}) return v10 default: @@ -31285,7 +31283,7 @@ if v6.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } v7 := v6.Get() -v8 := lang.Apply(v7, []any{lang1.Throwable, v3}) +v8 := lang.Apply(v7, []any{lang.Throwable, v3}) if lang.IsTruthy(v8) { v9, ok := lang.FieldOrMethod(v3, "getMessage") if !ok { @@ -31828,7 +31826,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5 := lang.Apply(lang1.Identical, []any{v4, false}) +v5 := lang.Apply(lang.Identical, []any{v4, false}) return v5 }) v4 := reflect.TypeOf(false) @@ -32050,7 +32048,7 @@ v33 := v32.Get() v34 := lang.Apply(v33, []any{v25}) var v30 any = v34 _ = v30 -v37 := lang.Apply(lang1.LongCast, []any{v25}) +v37 := lang.Apply(lang.LongCast, []any{v25}) var v36 any = v37 _ = v36 var v39 any = int64(0) @@ -32189,7 +32187,7 @@ v12 = nil } return v12 }) -v6 := lang.Apply(lang1.NewLazySeq, []any{v5}) +v6 := lang.Apply(lang.NewLazySeq, []any{v5}) return v6 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -32418,7 +32416,7 @@ if v0.Meta() != nil { } // find-keyword { -v1 := reflect.TypeOf((*lang1.Keyword)(nil)).Elem() +v1 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() v0 := lang.NewSymbol("find-keyword").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name"))), lang.NewKeyword("doc"), "Returns a Keyword with the given namespace and name if one already\n exists. This function will not intern a new keyword. If the keyword\n has not already been interned, it will return nil. Do not use :\n in the keyword strings, it will be added automatically.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(618), lang.NewKeyword("end-line"), int(618))).(*lang.Symbol) var v3 lang.FnFunc v3 = lang.NewFnFunc(func(args ...any) any { @@ -32476,7 +32474,7 @@ return v6 panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) -v4 := reflect.TypeOf((*lang1.Keyword)(nil)).Elem() +v4 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { @@ -32492,7 +32490,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := lang.Apply(lang1.FindNamespace, []any{v3}) +v4 := lang.Apply(lang.FindNamespace, []any{v3}) return v4 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -32533,7 +32531,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5 := lang.Apply(lang1.First, []any{v4}) +v5 := lang.Apply(lang.First, []any{v4}) return v5 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(52), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(52), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) @@ -32781,7 +32779,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5 := lang.Apply(lang1.FloatCast, []any{v4}) +v5 := lang.Apply(lang.FloatCast, []any{v4}) return v5 }) v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -32883,7 +32881,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "floatArray") +v5, _ := lang.FieldOrMethod(lang.Numbers, "floatArray") if reflect.TypeOf(v5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("floatArray is not a function"))) } @@ -32892,7 +32890,7 @@ return v6 case 2: v4 := args[0] v5 := args[1] -v6, _ := lang.FieldOrMethod(lang1.Numbers, "floatArrayInit") +v6, _ := lang.FieldOrMethod(lang.Numbers, "floatArrayInit") if reflect.TypeOf(v6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("floatArrayInit is not a function"))) } @@ -33010,7 +33008,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "floats") +v5, _ := lang.FieldOrMethod(lang.Numbers, "floats") if reflect.TypeOf(v5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("floats is not a function"))) } @@ -33185,7 +33183,7 @@ v64 := v63.Get() v65 := lang.Apply(v64, []any{"Parameter declaration missing"}) v49 = v65 } -v66 := lang.Apply(lang1.NewIllegalArgumentError, []any{v49}) +v66 := lang.Apply(lang.NewIllegalArgumentError, []any{v49}) panic(v66) } v27 = v40 @@ -33221,7 +33219,7 @@ if v80.IsMacro() { } v81 := v80.Get() v82 := lang.Apply(v81, []any{"Invalid signature ", v69, " should be a list"}) -v83 := lang.Apply(lang1.NewIllegalArgumentError, []any{v82}) +v83 := lang.Apply(lang.NewIllegalArgumentError, []any{v82}) panic(v83) } else { v70 = nil @@ -33310,7 +33308,7 @@ v127 := v126.Get() v128 := lang.Apply(v127, []any{"Invalid signature ", v69, " should be a list"}) v112 = v128 } -v129 := lang.Apply(lang1.NewIllegalArgumentError, []any{v112}) +v129 := lang.Apply(lang.NewIllegalArgumentError, []any{v112}) panic(v129) } else { v103 = nil @@ -34221,7 +34219,7 @@ v24 := v23.Get() v25 := lang.Apply(v24, []any{v3}) v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) -v28 := lang.Apply(lang1.NewIllegalArgumentError, []any{v27}) +v28 := lang.Apply(lang.NewIllegalArgumentError, []any{v27}) panic(v28) } _ = v7 @@ -34271,7 +34269,7 @@ v50 := v49.Get() v51 := lang.Apply(v50, []any{v3}) v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) v53 := lang.Apply(v40, []any{v44, " requires ", "an even number of forms in binding vector", " in ", v47, ":", v52}) -v54 := lang.Apply(lang1.NewIllegalArgumentError, []any{v53}) +v54 := lang.Apply(lang.NewIllegalArgumentError, []any{v53}) panic(v54) } _ = v29 @@ -34426,7 +34424,7 @@ if v66.IsMacro() { } v67 := v66.Get() v68 := lang.Apply(v64, []any{v67, v61}) -v69 := lang.Apply(lang1.NewIllegalArgumentError, []any{v68}) +v69 := lang.Apply(lang.NewIllegalArgumentError, []any{v68}) panic(v69) } }) @@ -37596,7 +37594,7 @@ v7 := v6.Get() v8 := lang.Apply(v7, []any{v4}) var v4 any = v8 _ = v4 -v10 := lang.Apply(lang1.AgentSubmit, []any{v4}) +v10 := lang.Apply(lang.AgentSubmit, []any{v4}) var v9 any = v10 _ = v9 return v9 @@ -37753,7 +37751,7 @@ if reflect.TypeOf(v10).Kind() != reflect.Func { v11 := lang.Apply(v10, []any{}) v12 := lang.Apply(v9, []any{v11}) v13 := lang.Apply(v6, []any{v3, v12}) -v14 := lang.Apply(lang1.NewSymbol, []any{v13}) +v14 := lang.Apply(lang.NewSymbol, []any{v13}) return v14 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -37861,13 +37859,13 @@ v3 = lang.NewFnFunc(func(args ...any) any { case 2: v4 := args[0] v5 := args[1] -v6 := lang.Apply(lang1.Get, []any{v4, v5}) +v6 := lang.Apply(lang.Get, []any{v4, v5}) return v6 case 3: v4 := args[0] v5 := args[1] v6 := args[2] -v7 := lang.Apply(lang1.GetDefault, []any{v4, v5, v6}) +v7 := lang.Apply(lang.GetDefault, []any{v4, v5, v6}) return v7 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -37906,7 +37904,7 @@ return v11 v3 := args[0] v4 := args[1] v5 := args[2] -v7 := lang.Apply(Object13., nil) +v7 := lang.Apply(Object12., nil) var v6 any = v7 _ = v6 var v8 any = v8 @@ -38276,7 +38274,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := lang.Apply(lang1.HashEq, []any{v3}) +v4 := lang.Apply(lang.HashEq, []any{v3}) return v4 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -38304,7 +38302,7 @@ return v5 panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := lang.NewList(args[0:]...) -v4 := lang.Apply(lang1.CreatePersistentHashMap, []any{v3}) +v4 := lang.Apply(lang.CreatePersistentHashMap, []any{v3}) return v4 } }) @@ -38490,7 +38488,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { } v4 := args[0] v5 := args[1] -v6 := lang.Apply(lang1.Identical, []any{v4, v5}) +v6 := lang.Apply(lang.Identical, []any{v4, v5}) return v6 }) v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -38619,7 +38617,7 @@ v26 := v25.Get() v27 := lang.Apply(v26, []any{v3}) v28 := lang.Apply(lang.NewKeyword("line"), []any{v27}) v29 := lang.Apply(v16, []any{v20, " requires ", "a vector for its binding", " in ", v23, ":", v28}) -v30 := lang.Apply(lang1.NewIllegalArgumentError, []any{v29}) +v30 := lang.Apply(lang.NewIllegalArgumentError, []any{v29}) panic(v30) } _ = v9 @@ -38662,7 +38660,7 @@ v48 := v47.Get() v49 := lang.Apply(v48, []any{v3}) v50 := lang.Apply(lang.NewKeyword("line"), []any{v49}) v51 := lang.Apply(v38, []any{v42, " requires ", "1 or 2 forms after binding vector", " in ", v45, ":", v50}) -v52 := lang.Apply(lang1.NewIllegalArgumentError, []any{v51}) +v52 := lang.Apply(lang.NewIllegalArgumentError, []any{v51}) panic(v52) } _ = v31 @@ -38712,7 +38710,7 @@ v74 := v73.Get() v75 := lang.Apply(v74, []any{v3}) v76 := lang.Apply(lang.NewKeyword("line"), []any{v75}) v77 := lang.Apply(v64, []any{v68, " requires ", "exactly 2 forms in binding vector", " in ", v71, ":", v76}) -v78 := lang.Apply(lang1.NewIllegalArgumentError, []any{v77}) +v78 := lang.Apply(lang.NewIllegalArgumentError, []any{v77}) panic(v78) } _ = v53 @@ -39170,7 +39168,7 @@ v26 := v25.Get() v27 := lang.Apply(v26, []any{v3}) v28 := lang.Apply(lang.NewKeyword("line"), []any{v27}) v29 := lang.Apply(v16, []any{v20, " requires ", "a vector for its binding", " in ", v23, ":", v28}) -v30 := lang.Apply(lang1.NewIllegalArgumentError, []any{v29}) +v30 := lang.Apply(lang.NewIllegalArgumentError, []any{v29}) panic(v30) } _ = v9 @@ -39213,7 +39211,7 @@ v48 := v47.Get() v49 := lang.Apply(v48, []any{v3}) v50 := lang.Apply(lang.NewKeyword("line"), []any{v49}) v51 := lang.Apply(v38, []any{v42, " requires ", "1 or 2 forms after binding vector", " in ", v45, ":", v50}) -v52 := lang.Apply(lang1.NewIllegalArgumentError, []any{v51}) +v52 := lang.Apply(lang.NewIllegalArgumentError, []any{v51}) panic(v52) } _ = v31 @@ -39263,7 +39261,7 @@ v74 := v73.Get() v75 := lang.Apply(v74, []any{v3}) v76 := lang.Apply(lang.NewKeyword("line"), []any{v75}) v77 := lang.Apply(v64, []any{v68, " requires ", "exactly 2 forms in binding vector", " in ", v71, ":", v76}) -v78 := lang.Apply(lang1.NewIllegalArgumentError, []any{v77}) +v78 := lang.Apply(lang.NewIllegalArgumentError, []any{v77}) panic(v78) } _ = v53 @@ -39873,7 +39871,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "inc") +v5, _ := lang.FieldOrMethod(lang.Numbers, "inc") if reflect.TypeOf(v5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("inc is not a function"))) } @@ -39970,7 +39968,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "incP") +v5, _ := lang.FieldOrMethod(lang.Numbers, "incP") if reflect.TypeOf(v5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("incP is not a function"))) } @@ -40111,7 +40109,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { } v4 := args[0] v5 := args[1] -v6 := lang.Apply(lang1.HasType, []any{v4, v5}) +v6 := lang.Apply(lang.HasType, []any{v4, v5}) return v6 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(143), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(143), lang.NewKeyword("end-column"), int(85))).(lang.FnFunc) @@ -40325,7 +40323,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "intArray") +v5, _ := lang.FieldOrMethod(lang.Numbers, "intArray") if reflect.TypeOf(v5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("intArray is not a function"))) } @@ -40334,7 +40332,7 @@ return v6 case 2: v4 := args[0] v5 := args[1] -v6, _ := lang.FieldOrMethod(lang1.Numbers, "intArrayInit") +v6, _ := lang.FieldOrMethod(lang.Numbers, "intArrayInit") if reflect.TypeOf(v6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("intArrayInit is not a function"))) } @@ -40428,7 +40426,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := lang.Apply(lang1.IsInteger, []any{v3}) +v4 := lang.Apply(lang.IsInteger, []any{v3}) return v4 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -40454,7 +40452,7 @@ v4 = lang.NewFnFunc(func(args ...any) any { } return v3 }) -v5 := lang.Apply(lang1.NewLazySeq, []any{v4}) +v5 := lang.Apply(lang.NewLazySeq, []any{v4}) return v5 case 2: v3 := args[0] @@ -40547,7 +40545,7 @@ v17 = nil } return v17 }) -v6 := lang.Apply(lang1.NewLazySeq, []any{v5}) +v6 := lang.Apply(lang.NewLazySeq, []any{v5}) return v6 default: if len(args) < 2 { @@ -40650,7 +40648,7 @@ v20 = nil } return v20 }) -v7 := lang.Apply(lang1.NewLazySeq, []any{v6}) +v7 := lang.Apply(lang.NewLazySeq, []any{v6}) return v7 } }) @@ -40912,7 +40910,7 @@ if v7.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } v8 := v7.Get() -v9 := lang.Apply(v8, []any{lang1.IEditableCollection, v3}) +v9 := lang.Apply(v8, []any{lang.IEditableCollection, v3}) if lang.IsTruthy(v9) { v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v11 := v10.FindInternedVar(lang.NewSymbol("with-meta")) @@ -40984,7 +40982,7 @@ if v8.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } v9 := v8.Get() -v10 := lang.Apply(v9, []any{lang1.IEditableCollection, v3}) +v10 := lang.Apply(v9, []any{lang.IEditableCollection, v3}) if lang.IsTruthy(v10) { v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v13 := v12.FindInternedVar(lang.NewSymbol("meta")) @@ -41135,7 +41133,7 @@ if v7.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } v8 := v7.Get() -v9 := lang.Apply(v8, []any{lang1.IEditableCollection, v3}) +v9 := lang.Apply(v8, []any{lang.IEditableCollection, v3}) if lang.IsTruthy(v9) { v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v11 := v10.FindInternedVar(lang.NewSymbol("persistent!")) @@ -41252,7 +41250,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "ints") +v5, _ := lang.FieldOrMethod(lang.Numbers, "ints") if reflect.TypeOf(v5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("ints is not a function"))) } @@ -41839,7 +41837,7 @@ if v18.IsMacro() { } v19 := v18.Get() v20 := lang.Apply(v19, []any{v6}) -v21 := lang.Apply(lang1.NewPersistentArrayMapAsIfByAssoc, []any{v20}) +v21 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{v20}) v12 = v21 } else { var v22 any @@ -41978,7 +41976,7 @@ v87 := lang.Apply(v3, []any{v84}) v88 := lang.Apply(v68, []any{v87}) return v88 }) -v87 := lang.Apply(lang1.NewLazySeq, []any{v86}) +v87 := lang.Apply(lang.NewLazySeq, []any{v86}) v79 = v87 } v76 := lang.Apply(v74, []any{v75, v79}) @@ -42076,7 +42074,7 @@ v82 = v83 break } v79 := lang.Apply(v75, []any{v78, v82}) -v80 := lang.Apply(nil, []any{glojure.lang4.Seqable, v72, lang1.IReduceInit, v79}) +v80 := lang.Apply(nil, []any{glojure.lang4.Seqable, v72, lang.IReduceInit, v79}) return v80 } }) @@ -42900,7 +42898,7 @@ v12 = nil } return v12 }) -v6 := lang.Apply(lang1.NewLazySeq, []any{v5}) +v6 := lang.Apply(lang.NewLazySeq, []any{v5}) return v6 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -43053,7 +43051,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := lang.Apply(lang1.Keys, []any{v3}) +v4 := lang.Apply(lang.Keys, []any{v3}) return v4 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -43064,7 +43062,7 @@ if v0.Meta() != nil { } // keyword { -v1 := reflect.TypeOf((*lang1.Keyword)(nil)).Elem() +v1 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() v0 := lang.NewSymbol("keyword").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name"))), lang.NewKeyword("doc"), "Returns a Keyword with the given namespace and name. Do not use :\n in the keyword strings, it will be added automatically.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(609), lang.NewKeyword("end-line"), int(609))).(*lang.Symbol) var v3 lang.FnFunc v3 = lang.NewFnFunc(func(args ...any) any { @@ -43091,7 +43089,7 @@ if v12.IsMacro() { v13 := v12.Get() v14 := lang.Apply(v13, []any{v4}) if lang.IsTruthy(v14) { -v15 := lang.Apply(lang1.InternKeywordSymbol, []any{v4}) +v15 := lang.Apply(lang.InternKeywordSymbol, []any{v4}) v10 = v15 } else { var v16 any @@ -43103,7 +43101,7 @@ if v18.IsMacro() { v19 := v18.Get() v20 := lang.Apply(v19, []any{v4}) if lang.IsTruthy(v20) { -v21 := lang.Apply(lang1.InternKeywordString, []any{v4}) +v21 := lang.Apply(lang.InternKeywordString, []any{v4}) v16 = v21 } else { v16 = nil @@ -43116,13 +43114,13 @@ return v5 case 2: v4 := args[0] v5 := args[1] -v6 := lang.Apply(lang1.InternKeyword, []any{v4, v5}) +v6 := lang.Apply(lang.InternKeyword, []any{v4, v5}) return v6 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) -v4 := reflect.TypeOf((*lang1.Keyword)(nil)).Elem() +v4 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { @@ -43144,7 +43142,7 @@ if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -v7 := lang.Apply(v6, []any{lang1.Keyword, v3}) +v7 := lang.Apply(v6, []any{lang.Keyword, v3}) return v7 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -43369,7 +43367,7 @@ v24 := v23.Get() v25 := lang.Apply(v24, []any{v3}) v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) -v28 := lang.Apply(lang1.NewIllegalArgumentError, []any{v27}) +v28 := lang.Apply(lang.NewIllegalArgumentError, []any{v27}) panic(v28) } _ = v7 @@ -43419,7 +43417,7 @@ v50 := v49.Get() v51 := lang.Apply(v50, []any{v3}) v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) v53 := lang.Apply(v40, []any{v44, " requires ", "an even number of forms in binding vector", " in ", v47, ":", v52}) -v54 := lang.Apply(lang1.NewIllegalArgumentError, []any{v53}) +v54 := lang.Apply(lang.NewIllegalArgumentError, []any{v53}) panic(v54) } _ = v29 @@ -43991,7 +43989,7 @@ v17 := v16.Get() v18 := lang.Apply(v17, []any{v3}) return v18 }) -v15 := lang.Apply(lang1.NewLazySeq, []any{v14}) +v15 := lang.Apply(lang.NewLazySeq, []any{v14}) v16 := lang.Apply(v13, []any{v9, v15}) v8 = v16 } else { @@ -44154,7 +44152,7 @@ if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -v7 := lang.Apply(v6, []any{lang1.IPersistentList, v3}) +v7 := lang.Apply(v6, []any{lang.IPersistentList, v3}) return v7 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -44208,7 +44206,7 @@ v20 := lang.Apply(v19, []any{v11}) var v18 any = v20 _ = v18 var v23 any -v24 := lang.Apply(strings14.HasPrefix, []any{v22, "/"}) +v24 := lang.Apply(strings13.HasPrefix, []any{v22, "/"}) if lang.IsTruthy(v24) { v23 = v22 } else { @@ -44343,7 +44341,7 @@ if v88.IsMacro() { v89 := v88.Get() v90 := lang.Apply(v89, nil) }() -v91 := lang.Apply(strings14.TrimPrefix, []any{v22, "/"}) +v91 := lang.Apply(strings13.TrimPrefix, []any{v22, "/"}) v92, _ := lang.FieldOrMethod(runtime5.RT, "Load") if reflect.TypeOf(v92).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Load is not a function"))) @@ -44450,7 +44448,7 @@ v36 := lang.Apply(v35, []any{v25}) var v32 any = v36 _ = v32 var v39 any -v40 := lang.Apply(strings14.HasPrefix, []any{v38, "/"}) +v40 := lang.Apply(strings13.HasPrefix, []any{v38, "/"}) if lang.IsTruthy(v40) { v39 = v38 } else { @@ -44585,7 +44583,7 @@ if v104.IsMacro() { v105 := v104.Get() v106 := lang.Apply(v105, nil) }() -v107 := lang.Apply(strings14.TrimPrefix, []any{v38, "/"}) +v107 := lang.Apply(strings13.TrimPrefix, []any{v38, "/"}) v108, _ := lang.FieldOrMethod(runtime5.RT, "Load") if reflect.TypeOf(v108).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Load is not a function"))) @@ -44753,7 +44751,7 @@ v34 = v49 v16 := lang.Apply(v9, []any{v12, v15, v34}) return v16 }) -v7, _ := lang.FieldOrMethod(lang1.LockingTransaction, "RunInTransaction") +v7, _ := lang.FieldOrMethod(lang.LockingTransaction, "RunInTransaction") if reflect.TypeOf(v7).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("RunInTransaction is not a function"))) } @@ -44787,8 +44785,8 @@ case reflect.Func: default: v7 = v6 } -v8 := lang.Apply(java.io.InputStreamReader16., []any{v7, "UTF-8"}) -v9 := lang.Apply(glojure.lang.LineNumberingPushbackReader15., []any{v8}) +v8 := lang.Apply(java.io.InputStreamReader15., []any{v7, "UTF-8"}) +v9 := lang.Apply(glojure.lang.LineNumberingPushbackReader14., []any{v8}) var v5 any = v9 _ = v5 var v11 any @@ -45191,7 +45189,7 @@ if v20.IsMacro() { } v21 := v20.Get() v22 := lang.Apply(v21, []any{lang.NewChar(46)}) -v23 := lang.Apply(strings14.Index, []any{v18, v22}) +v23 := lang.Apply(strings13.Index, []any{v18, v22}) v24 := lang.Apply(v14, []any{v23}) v11 = v24 } else { @@ -45270,7 +45268,7 @@ if v45.IsMacro() { } v46 := v45.Get() v47 := lang.Apply(v46, []any{v33}) -v48 := lang.Apply(lang1.NewPersistentArrayMapAsIfByAssoc, []any{v47}) +v48 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{v47}) v39 = v48 } else { var v49 any @@ -46969,7 +46967,7 @@ v32 := v31.Get() v33 := lang.Apply(v26, []any{v29, v32, v3}) return v33 }) -v24, _ := lang.FieldOrMethod(lang1.LockingTransaction, "RunInTransaction") +v24, _ := lang.FieldOrMethod(lang.LockingTransaction, "RunInTransaction") if reflect.TypeOf(v24).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("RunInTransaction is not a function"))) } @@ -47017,8 +47015,8 @@ v2 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v5 := lang.Apply(java.io.StringReader17., []any{v3}) -v6 := lang.Apply(glojure.lang.LineNumberingPushbackReader15., []any{v5}) +v5 := lang.Apply(java.io.StringReader16., []any{v3}) +v6 := lang.Apply(glojure.lang.LineNumberingPushbackReader14., []any{v5}) var v4 any = v6 _ = v4 v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) @@ -47471,7 +47469,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5 := lang.Apply(lang1.LongCast, []any{v4}) +v5 := lang.Apply(lang.LongCast, []any{v4}) return v5 }) v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -47573,7 +47571,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "longArray") +v5, _ := lang.FieldOrMethod(lang.Numbers, "longArray") if reflect.TypeOf(v5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("longArray is not a function"))) } @@ -47582,7 +47580,7 @@ return v6 case 2: v4 := args[0] v5 := args[1] -v6, _ := lang.FieldOrMethod(lang1.Numbers, "longArrayInit") +v6, _ := lang.FieldOrMethod(lang.Numbers, "longArrayInit") if reflect.TypeOf(v6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("longArrayInit is not a function"))) } @@ -47661,7 +47659,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "longs") +v5, _ := lang.FieldOrMethod(lang.Numbers, "longs") if reflect.TypeOf(v5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("longs is not a function"))) } @@ -47727,7 +47725,7 @@ v24 := v23.Get() v25 := lang.Apply(v24, []any{v3}) v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) -v28 := lang.Apply(lang1.NewIllegalArgumentError, []any{v27}) +v28 := lang.Apply(lang.NewIllegalArgumentError, []any{v27}) panic(v28) } _ = v7 @@ -47777,7 +47775,7 @@ v50 := v49.Get() v51 := lang.Apply(v50, []any{v3}) v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) v53 := lang.Apply(v40, []any{v44, " requires ", "an even number of forms in binding vector", " in ", v47, ":", v52}) -v54 := lang.Apply(lang1.NewIllegalArgumentError, []any{v53}) +v54 := lang.Apply(lang.NewIllegalArgumentError, []any{v53}) panic(v54) } _ = v29 @@ -48505,7 +48503,7 @@ v37 := v36.Get() v38 := lang.Apply(v37, []any{v25}) var v34 any = v38 _ = v34 -v41 := lang.Apply(lang1.LongCast, []any{v25}) +v41 := lang.Apply(lang.LongCast, []any{v25}) var v40 any = v41 _ = v40 var v43 any = int64(0) @@ -48619,7 +48617,7 @@ v12 = nil } return v12 }) -v6 := lang.Apply(lang1.NewLazySeq, []any{v5}) +v6 := lang.Apply(lang.NewLazySeq, []any{v5}) return v6 case 3: v3 := args[0] @@ -48707,7 +48705,7 @@ v18 = nil } return v18 }) -v7 := lang.Apply(lang1.NewLazySeq, []any{v6}) +v7 := lang.Apply(lang.NewLazySeq, []any{v6}) return v7 case 4: v3 := args[0] @@ -48827,7 +48825,7 @@ v24 = nil } return v24 }) -v8 := lang.Apply(lang1.NewLazySeq, []any{v7}) +v8 := lang.Apply(lang.NewLazySeq, []any{v7}) return v8 default: if len(args) < 4 { @@ -48920,7 +48918,7 @@ v22 = nil } return v22 }) -v13 := lang.Apply(lang1.NewLazySeq, []any{v12}) +v13 := lang.Apply(lang.NewLazySeq, []any{v12}) return v13 }) v10 := v9 @@ -48992,7 +48990,7 @@ if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -v7 := lang.Apply(v6, []any{java.util18.Map$Entry, v3}) +v7 := lang.Apply(v6, []any{java.util17.Map$Entry, v3}) return v7 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -49110,7 +49108,7 @@ if v6.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } v7 := v6.Get() -v8 := lang.Apply(v7, []any{lang1.IPersistentMap, v4}) +v8 := lang.Apply(v7, []any{lang.IPersistentMap, v4}) return v8 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(171), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(171), lang.NewKeyword("end-column"), int(97))).(lang.FnFunc) @@ -49711,7 +49709,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") +v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") if reflect.TypeOf(v4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } @@ -49729,7 +49727,7 @@ return v5 case 2: v5 := args[0] v6 := args[1] -v7, _ := lang.FieldOrMethod(lang1.Numbers, "max") +v7, _ := lang.FieldOrMethod(lang.Numbers, "max") if reflect.TypeOf(v7).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("max is not a function"))) } @@ -50539,7 +50537,7 @@ v41 = v48 } return v41 }) -v40 := lang.Apply(lang1.NewLazySeq, []any{v39}) +v40 := lang.Apply(lang.NewLazySeq, []any{v39}) return v40 }) v37 := v36 @@ -50603,7 +50601,7 @@ v19 = v26 } return v19 }) -v18 := lang.Apply(lang1.NewLazySeq, []any{v17}) +v18 := lang.Apply(lang.NewLazySeq, []any{v17}) return v18 }) v15 := v14 @@ -51079,7 +51077,7 @@ if v21.IsMacro() { } v22 := v21.Get() v23 := lang.Apply(v22, []any{v12}) -v24 := lang.Apply(lang1.Hash, []any{v23}) +v24 := lang.Apply(lang.Hash, []any{v23}) v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v26 := v25.FindInternedVar(lang.NewSymbol("fnil")) if v26.IsMacro() { @@ -51638,7 +51636,7 @@ if v7.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } v8 := v7.Get() -v9 := lang.Apply(v8, []any{lang1.IMeta, v4}) +v9 := lang.Apply(v8, []any{lang.IMeta, v4}) if lang.IsTruthy(v9) { v10, ok := lang.FieldOrMethod(v4, "Meta") if !ok { @@ -52059,7 +52057,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4, _ := lang.FieldOrMethod(lang1.Numbers, "Gt") +v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") if reflect.TypeOf(v4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } @@ -52077,7 +52075,7 @@ return v5 case 2: v5 := args[0] v6 := args[1] -v7, _ := lang.FieldOrMethod(lang1.Numbers, "min") +v7, _ := lang.FieldOrMethod(lang.Numbers, "min") if reflect.TypeOf(v7).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("min is not a function"))) } @@ -53055,7 +53053,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "isNeg") +v5, _ := lang.FieldOrMethod(lang.Numbers, "isNeg") if reflect.TypeOf(v5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("isNeg is not a function"))) } @@ -53088,7 +53086,7 @@ if v7.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } v8 := v7.Get() -v9 := lang.Apply(lang1.AppendWriter, []any{v5, v8}) +v9 := lang.Apply(lang.AppendWriter, []any{v5, v8}) _ = v9 return nil }) @@ -53100,7 +53098,7 @@ if v0.Meta() != nil { } // next { -v1 := reflect.TypeOf((*lang1.ISeq)(nil)).Elem() +v1 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() v0 := lang.NewSymbol("next").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a seq of the items after the first. Calls seq on its\n argument. If there are no more items, returns nil.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(55), lang.NewKeyword("end-line"), int(61))).(*lang.Symbol) var v3 lang.FnFunc { // function next @@ -53109,7 +53107,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v5 := args[0] -v6 := lang.Apply(lang1.Next, []any{v5}) +v6 := lang.Apply(lang.Next, []any{v5}) return v6 }) v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(61), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(61), lang.NewKeyword("end-column"), int(77))).(lang.FnFunc) @@ -53185,7 +53183,7 @@ v4 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v5 := args[0] -v6 := lang.Apply(lang1.IsNil, []any{v5}) +v6 := lang.Apply(lang.IsNil, []any{v5}) return v6 }) v5 := reflect.TypeOf(false) @@ -54739,7 +54737,7 @@ if v20.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } v21 := v20.Get() -v22 := lang.Apply(v21, []any{lang1.*Var, v17}) +v22 := lang.Apply(v21, []any{lang.*Var, v17}) var v18 any = v22 _ = v18 var v24 any @@ -54901,7 +54899,7 @@ if v20.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } v21 := v20.Get() -v22 := lang.Apply(v21, []any{lang1.*Var, v17}) +v22 := lang.Apply(v21, []any{lang.*Var, v17}) var v18 any = v22 _ = v18 var v24 any @@ -55012,7 +55010,7 @@ if v20.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) } v21 := v20.Get() -v22 := lang.Apply(v21, []any{lang1.*Var, v17}) +v22 := lang.Apply(v21, []any{lang.*Var, v17}) var v18 any = v22 _ = v18 var v24 any @@ -55409,7 +55407,7 @@ if v7.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } v8 := v7.Get() -v9 := lang.Apply(v8, []any{lang1.IDrop, v3}) +v9 := lang.Apply(v8, []any{lang.IDrop, v3}) if lang.IsTruthy(v9) { var v10 any v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) @@ -55543,7 +55541,7 @@ if v13.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) } v14 := v13.Get() -v15 := lang.Apply(v14, []any{lang1.IDrop, v3}) +v15 := lang.Apply(v14, []any{lang.IDrop, v3}) if lang.IsTruthy(v15) { var v16 any v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) @@ -55738,7 +55736,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "num") +v5, _ := lang.FieldOrMethod(lang.Numbers, "num") if reflect.TypeOf(v5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("num is not a function"))) } @@ -55760,7 +55758,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := lang.Apply(lang1.IsNumber, []any{v3}) +v4 := lang.Apply(lang.IsNumber, []any{v3}) return v4 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -56193,7 +56191,7 @@ if v10.IsMacro() { } v11 := v10.Get() v12 := lang.Apply(v11, []any{v3}) -v13 := lang.Apply(lang1.NewIllegalArgumentError, []any{v12}) +v13 := lang.Apply(lang.NewIllegalArgumentError, []any{v12}) panic(v13) } return v4 @@ -56222,7 +56220,7 @@ if v6.IsMacro() { v7 := v6.Get() v8 := lang.Apply(v7, []any{v3}) if lang.IsTruthy(v8) { -v10 := lang.Apply(strconv19.ParseFloat, []any{v3, int64(64)}) +v10 := lang.Apply(strconv18.ParseFloat, []any{v3, int64(64)}) var v9 any = v10 _ = v9 var v12 any @@ -56242,7 +56240,7 @@ if v10.IsMacro() { } v11 := v10.Get() v12 := lang.Apply(v11, []any{v3}) -v13 := lang.Apply(lang1.NewIllegalArgumentError, []any{v12}) +v13 := lang.Apply(lang.NewIllegalArgumentError, []any{v12}) panic(v13) } return v4 @@ -56374,7 +56372,7 @@ if v6.IsMacro() { v7 := v6.Get() v8 := lang.Apply(v7, []any{v3}) if lang.IsTruthy(v8) { -v10 := lang.Apply(strconv19.ParseInt, []any{v3, int64(10), int64(64)}) +v10 := lang.Apply(strconv18.ParseInt, []any{v3, int64(10), int64(64)}) var v9 any = v10 _ = v9 var v12 any @@ -56394,7 +56392,7 @@ if v10.IsMacro() { } v11 := v10.Get() v12 := lang.Apply(v11, []any{v3}) -v13 := lang.Apply(lang1.NewIllegalArgumentError, []any{v12}) +v13 := lang.Apply(lang.NewIllegalArgumentError, []any{v12}) panic(v13) } return v4 @@ -56799,7 +56797,7 @@ v13 = nil } return v13 }) -v7 := lang.Apply(lang1.NewLazySeq, []any{v6}) +v7 := lang.Apply(lang.NewLazySeq, []any{v6}) return v7 case 4: v3 := args[0] @@ -56908,7 +56906,7 @@ v14 = nil } return v14 }) -v8 := lang.Apply(lang1.NewLazySeq, []any{v7}) +v8 := lang.Apply(lang.NewLazySeq, []any{v7}) return v8 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -56941,7 +56939,7 @@ if v8.IsMacro() { } v9 := v8.Get() v10 := lang.Apply(v9, []any{v3}) -v11 := lang.Apply(lang1.NewArrayList, []any{v10}) +v11 := lang.Apply(lang.NewArrayList, []any{v10}) var v6 any = v11 _ = v6 var v13 lang.FnFunc @@ -57173,7 +57171,7 @@ v13 = nil } return v13 }) -v7 := lang.Apply(lang1.NewLazySeq, []any{v6}) +v7 := lang.Apply(lang.NewLazySeq, []any{v6}) return v7 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -57518,7 +57516,7 @@ v52 := lang.Apply(v51, []any{v22}) v53 := lang.Apply(v48, []any{v52, v13}) return v53 }) -v46 := lang.Apply(lang1.NewLazySeq, []any{v45}) +v46 := lang.Apply(lang.NewLazySeq, []any{v45}) v47 := lang.Apply(v44, []any{v3, v46}) v48 := lang.Apply(v41, []any{v22, v47}) v12 = v48 @@ -57527,7 +57525,7 @@ v12 = nil } return v12 }) -v6 := lang.Apply(lang1.NewLazySeq, []any{v5}) +v6 := lang.Apply(lang.NewLazySeq, []any{v5}) return v6 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -57647,7 +57645,7 @@ v13 = nil } return v13 }) -v7 := lang.Apply(lang1.NewLazySeq, []any{v6}) +v7 := lang.Apply(lang.NewLazySeq, []any{v6}) return v7 case 4: v3 := args[0] @@ -57775,7 +57773,7 @@ v14 = nil } return v14 }) -v8 := lang.Apply(lang1.NewLazySeq, []any{v7}) +v8 := lang.Apply(lang.NewLazySeq, []any{v7}) return v8 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -57885,7 +57883,7 @@ v13 = nil } return v13 }) -v7 := lang.Apply(lang1.NewLazySeq, []any{v6}) +v7 := lang.Apply(lang.NewLazySeq, []any{v6}) return v7 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -58003,7 +58001,7 @@ if v7.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } v8 := v7.Get() -v9 := lang.Apply(runtime20.NumCPU, nil) +v9 := lang.Apply(runtime19.NumCPU, nil) v10 := lang.Apply(v8, []any{int64(2), v9}) var v5 any = v10 _ = v5 @@ -58146,7 +58144,7 @@ v51 = v58 } return v51 }) -v45 := lang.Apply(lang1.NewLazySeq, []any{v44}) +v45 := lang.Apply(lang.NewLazySeq, []any{v44}) return v45 }) v21 := v20 @@ -58257,7 +58255,7 @@ v20 = nil } return v20 }) -v11 := lang.Apply(lang1.NewLazySeq, []any{v10}) +v11 := lang.Apply(lang.NewLazySeq, []any{v10}) return v11 }) v8 := v7 @@ -58372,7 +58370,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := lang.Apply(lang1.PopThreadBindings, nil) +v3 := lang.Apply(lang.PopThreadBindings, nil) return v3 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -58504,7 +58502,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "isPos") +v5, _ := lang.FieldOrMethod(lang.Numbers, "isPos") if reflect.TypeOf(v5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("isPos is not a function"))) } @@ -58562,7 +58560,7 @@ if v10.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) } v11 := v10.Get() -v12 := lang.Apply(lang1.AppendWriter, []any{v11, lang.NewChar(32)}) +v12 := lang.Apply(lang.AppendWriter, []any{v11, lang.NewChar(32)}) _ = v12 v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v15 := v14.FindInternedVar(lang.NewSymbol("next")) @@ -58803,7 +58801,7 @@ v8 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v9 := args[0] -v10 := lang.Apply(lang1.Hash, []any{v9}) +v10 := lang.Apply(lang.Hash, []any{v9}) return v10 }) v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6691), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(6691), lang.NewKeyword("end-column"), int(66)) @@ -59523,7 +59521,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { v3 := args[0] v4 := args[1] v5 := args[2] -v6 := lang.Apply(lang1.WriteWriter, []any{v5, "#=("}) +v6 := lang.Apply(lang.WriteWriter, []any{v5, "#=("}) _ = v6 v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v8 := v7.FindInternedVar(lang.NewSymbol("class")) @@ -59543,13 +59541,13 @@ case reflect.Func: default: v12 = v11 } -v13 := lang.Apply(lang1.WriteWriter, []any{v5, v12}) +v13 := lang.Apply(lang.WriteWriter, []any{v5, v12}) _ = v13 -v14 := lang.Apply(lang1.WriteWriter, []any{v5, ". "}) +v14 := lang.Apply(lang.WriteWriter, []any{v5, ". "}) _ = v14 v15 := lang.Apply(v4, []any{v3, v5}) _ = v15 -v16 := lang.Apply(lang1.WriteWriter, []any{v5, ")"}) +v16 := lang.Apply(lang.WriteWriter, []any{v5, ")"}) return v16 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -59681,7 +59679,7 @@ v25 = v31 v25 = v15 } if lang.IsTruthy(v25) { -v15 := lang.Apply(lang1.WriteWriter, []any{v4, "^"}) +v15 := lang.Apply(lang.WriteWriter, []any{v4, "^"}) _ = v15 var v16 any v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) @@ -59728,7 +59726,7 @@ v25 := lang.Apply(v24, []any{v12, v4}) v16 = v25 } _ = v16 -v26 := lang.Apply(lang1.WriteWriter, []any{v4, " "}) +v26 := lang.Apply(lang.WriteWriter, []any{v4, " "}) v14 = v26 } else { v14 = nil @@ -59839,7 +59837,7 @@ var v23 any = v27 _ = v23 v29 := lang.Apply(v5, []any{v18, v16}) _ = v29 -v30 := lang.Apply(lang1.AppendWriter, []any{v16, lang.NewChar(32)}) +v30 := lang.Apply(lang.AppendWriter, []any{v16, lang.NewChar(32)}) _ = v30 v31 := lang.Apply(v5, []any{v23, v16}) return v31 @@ -59976,10 +59974,10 @@ v30 = v37 v30 = v25 } if lang.IsTruthy(v30) { -v25 := lang.Apply(lang1.WriteWriter, []any{v8, "#"}) +v25 := lang.Apply(lang.WriteWriter, []any{v8, "#"}) v24 = v25 } else { -v26 := lang.Apply(lang1.WriteWriter, []any{v8, v3}) +v26 := lang.Apply(lang.WriteWriter, []any{v8, v3}) _ = v26 v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v29 := v28.FindInternedVar(lang.NewSymbol("seq")) @@ -60116,14 +60114,14 @@ if v86.IsMacro() { v87 := v86.Get() v88 := lang.Apply(v87, []any{v82}) if lang.IsTruthy(v88) { -v89 := lang.Apply(lang1.WriteWriter, []any{v8, "..."}) +v89 := lang.Apply(lang.WriteWriter, []any{v8, "..."}) v84 = v89 } else { v90 := lang.Apply(v4, []any{v80, v8}) _ = v90 var v91 any if lang.IsTruthy(v81) { -v92 := lang.Apply(lang1.WriteWriter, []any{v8, v5}) +v92 := lang.Apply(lang.WriteWriter, []any{v8, v5}) _ = v92 var v93 any = v81 v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) @@ -60223,7 +60221,7 @@ v78 := lang.Apply(v4, []any{v75, v8}) _ = v78 var v79 any if lang.IsTruthy(v76) { -v80 := lang.Apply(lang1.WriteWriter, []any{v8, v5}) +v80 := lang.Apply(lang.WriteWriter, []any{v8, v5}) _ = v80 var v81 any = v76 v57 = v81 @@ -60241,7 +60239,7 @@ v33 = v36 v33 = nil } _ = v33 -v27 := lang.Apply(lang1.WriteWriter, []any{v8, v6}) +v27 := lang.Apply(lang.WriteWriter, []any{v8, v6}) v24 = v27 } v19 = v24 @@ -60279,7 +60277,7 @@ if v10.IsMacro() { } v11 := v10.Get() v12 := lang.Apply(v11, []any{v3}) -v13 := lang.Apply(lang1.WriteWriter, []any{v4, v12}) +v13 := lang.Apply(lang.WriteWriter, []any{v4, v12}) return v13 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -60380,7 +60378,7 @@ if v8.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } v9 := v8.Get() -v10 := lang.Apply(v9, []any{lang1.IMeta, v3}) +v10 := lang.Apply(v9, []any{lang.IMeta, v3}) if lang.IsTruthy(v10) { v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v12 := v11.FindInternedVar(lang.NewSymbol("print-meta")) @@ -60394,7 +60392,7 @@ v6 = v14 v6 = nil } _ = v6 -v15 := lang.Apply(lang1.WriteWriter, []any{v5, "#object["}) +v15 := lang.Apply(lang.WriteWriter, []any{v5, "#object["}) _ = v15 v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v18 := v17.FindInternedVar(lang.NewSymbol("class")) @@ -60438,11 +60436,11 @@ case reflect.Func: default: v30 = v29 } -v31 := lang.Apply(lang1.WriteWriter, []any{v5, v30}) +v31 := lang.Apply(lang.WriteWriter, []any{v5, v30}) v22 = v31 } _ = v22 -v16 := lang.Apply(lang1.WriteWriter, []any{v5, " "}) +v16 := lang.Apply(lang.WriteWriter, []any{v5, " "}) _ = v16 v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v18 := v17.FindInternedVar(lang.NewSymbol("format")) @@ -60450,9 +60448,9 @@ if v18.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } v19 := v18.Get() -v20 := lang.Apply(lang1.IdentityHash, []any{v3}) +v20 := lang.Apply(lang.IdentityHash, []any{v3}) v21 := lang.Apply(v19, []any{"0x%x ", v20}) -v22 := lang.Apply(lang1.WriteWriter, []any{v5, v21}) +v22 := lang.Apply(lang.WriteWriter, []any{v5, v21}) _ = v22 v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v24 := v23.FindInternedVar(lang.NewSymbol("print-method")) @@ -60462,7 +60460,7 @@ if v24.IsMacro() { v25 := v24.Get() v26 := lang.Apply(v25, []any{v4, v5}) _ = v26 -v27 := lang.Apply(lang1.WriteWriter, []any{v5, "]"}) +v27 := lang.Apply(lang.WriteWriter, []any{v5, "]"}) return v27 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -60481,7 +60479,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { } v3 := args[0] v4 := args[1] -v5 := lang.Apply(lang1.WriteWriter, []any{v4, "#error {\n :cause "}) +v5 := lang.Apply(lang.WriteWriter, []any{v4, "#error {\n :cause "}) _ = v5 v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v8 := v7.FindInternedVar(lang.NewSymbol("Throwable->map")) @@ -60517,7 +60515,7 @@ if v23.IsMacro() { } v24 := v23.Get() v25 := lang.Apply(v24, []any{v11}) -v26 := lang.Apply(lang1.NewPersistentArrayMapAsIfByAssoc, []any{v25}) +v26 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{v25}) v17 = v26 } else { var v27 any @@ -60590,7 +60588,7 @@ v57 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v58 := args[0] -v59 := lang.Apply(lang1.WriteWriter, []any{v4, "{:type "}) +v59 := lang.Apply(lang.WriteWriter, []any{v4, "{:type "}) _ = v59 v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v61 := v60.FindInternedVar(lang.NewSymbol("print-method")) @@ -60601,7 +60599,7 @@ v62 := v61.Get() v63 := lang.Apply(lang.NewKeyword("type"), []any{v58}) v64 := lang.Apply(v62, []any{v63, v4}) _ = v64 -v65 := lang.Apply(lang1.WriteWriter, []any{v4, "\n :message "}) +v65 := lang.Apply(lang.WriteWriter, []any{v4, "\n :message "}) _ = v65 v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v67 := v66.FindInternedVar(lang.NewSymbol("print-method")) @@ -60619,7 +60617,7 @@ var v74 any if lang.IsTruthy(v71) { var v75 any = v71 _ = v75 -v77 := lang.Apply(lang1.WriteWriter, []any{v4, "\n :data "}) +v77 := lang.Apply(lang.WriteWriter, []any{v4, "\n :data "}) _ = v77 v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v79 := v78.FindInternedVar(lang.NewSymbol("print-method")) @@ -60640,7 +60638,7 @@ var v74 any if lang.IsTruthy(v71) { var v75 any = v71 _ = v75 -v77 := lang.Apply(lang1.WriteWriter, []any{v4, "\n :at "}) +v77 := lang.Apply(lang.WriteWriter, []any{v4, "\n :at "}) _ = v77 v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v79 := v78.FindInternedVar(lang.NewSymbol("print-method")) @@ -60655,7 +60653,7 @@ v74 = v82 v74 = nil } _ = v74 -v71 := lang.Apply(lang1.WriteWriter, []any{v4, "}"}) +v71 := lang.Apply(lang.WriteWriter, []any{v4, "}"}) return v71 }) v58 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(481), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(491), lang.NewKeyword("end-column"), int(73)) @@ -60675,7 +60673,7 @@ v64 := lang.Apply(v63, []any{v36, v4}) _ = v64 var v65 any if lang.IsTruthy(v41) { -v66 := lang.Apply(lang1.WriteWriter, []any{v4, "\n :data "}) +v66 := lang.Apply(lang.WriteWriter, []any{v4, "\n :data "}) _ = v66 v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v68 := v67.FindInternedVar(lang.NewSymbol("print-method")) @@ -60691,7 +60689,7 @@ v65 = nil _ = v65 var v71 any if lang.IsTruthy(v46) { -v72 := lang.Apply(lang1.WriteWriter, []any{v4, "\n :via\n ["}) +v72 := lang.Apply(lang.WriteWriter, []any{v4, "\n :via\n ["}) _ = v72 v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v75 := v74.FindInternedVar(lang.NewSymbol("first")) @@ -60748,7 +60746,7 @@ if reflect.TypeOf(v102).Kind() != reflect.Func { v103 := lang.Apply(v102, []any{v94}) var v101 any = v103 _ = v101 -v105 := lang.Apply(lang1.WriteWriter, []any{v4, "\n "}) +v105 := lang.Apply(lang.WriteWriter, []any{v4, "\n "}) _ = v105 v106 := lang.Apply(v56, []any{v101}) _ = v106 @@ -60847,7 +60845,7 @@ v118 := v117.Get() v119 := lang.Apply(v118, []any{v108}) var v115 any = v119 _ = v115 -v121 := lang.Apply(lang1.WriteWriter, []any{v4, "\n "}) +v121 := lang.Apply(lang.WriteWriter, []any{v4, "\n "}) _ = v121 v122 := lang.Apply(v56, []any{v115}) _ = v122 @@ -60882,7 +60880,7 @@ v79 = v95 v79 = nil } _ = v79 -v73 := lang.Apply(lang1.WriteWriter, []any{v4, "]"}) +v73 := lang.Apply(lang.WriteWriter, []any{v4, "]"}) v71 = v73 } else { v71 = nil @@ -60890,7 +60888,7 @@ v71 = nil _ = v71 var v74 any if lang.IsTruthy(v51) { -v75 := lang.Apply(lang1.WriteWriter, []any{v4, "\n :trace\n ["}) +v75 := lang.Apply(lang.WriteWriter, []any{v4, "\n :trace\n ["}) _ = v75 v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v78 := v77.FindInternedVar(lang.NewSymbol("first")) @@ -60953,7 +60951,7 @@ if reflect.TypeOf(v108).Kind() != reflect.Func { v109 := lang.Apply(v108, []any{v100}) var v107 any = v109 _ = v107 -v111 := lang.Apply(lang1.WriteWriter, []any{v4, "\n "}) +v111 := lang.Apply(lang.WriteWriter, []any{v4, "\n "}) _ = v111 v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v113 := v112.FindInternedVar(lang.NewSymbol("print-method")) @@ -61058,7 +61056,7 @@ v124 := v123.Get() v125 := lang.Apply(v124, []any{v114}) var v121 any = v125 _ = v121 -v127 := lang.Apply(lang1.WriteWriter, []any{v4, "\n "}) +v127 := lang.Apply(lang.WriteWriter, []any{v4, "\n "}) _ = v127 v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v129 := v128.FindInternedVar(lang.NewSymbol("print-method")) @@ -61099,13 +61097,13 @@ v82 = v101 v82 = nil } _ = v82 -v76 := lang.Apply(lang1.WriteWriter, []any{v4, "]"}) +v76 := lang.Apply(lang.WriteWriter, []any{v4, "]"}) v74 = v76 } else { v74 = nil } _ = v74 -v6 := lang.Apply(lang1.WriteWriter, []any{v4, "}"}) +v6 := lang.Apply(lang.WriteWriter, []any{v4, "}"}) return v6 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -61434,7 +61432,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v4 := lang.Apply(java.util.concurrent.CountDownLatch21., []any{int64(1)}) +v4 := lang.Apply(java.util.concurrent.CountDownLatch20., []any{int64(1)}) var v3 any = v4 _ = v3 v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) @@ -61494,7 +61492,7 @@ v31, _ := lang.FieldOrMethod(v3, "await") if reflect.TypeOf(v31).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) } -v32 := lang.Apply(v31, []any{nil, time10.Millisecond}) +v32 := lang.Apply(v31, []any{nil, time9.Millisecond}) if lang.IsTruthy(v32) { v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v34 := v33.FindInternedVar(lang.NewSymbol("deref")) @@ -61591,7 +61589,7 @@ v51 = nil v51 = nil } v54 := lang.Apply(nil, []any{v50, v51}) -v55 := lang.Apply(nil, []any{lang1.IDeref, v23, lang1.IBlockingDeref, v37, lang1.IPending, v47, glojure.lang4.IFn, v54}) +v55 := lang.Apply(nil, []any{lang.IDeref, v23, lang.IBlockingDeref, v37, lang.IPending, v47, glojure.lang4.IFn, v54}) return v55 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -61616,7 +61614,7 @@ if v6.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } v7 := v6.Get() -v8 := lang.Apply(v7, []any{lang1.IAtom, v3}) +v8 := lang.Apply(v7, []any{lang.IAtom, v3}) if lang.IsTruthy(v8) { v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v10 := v9.FindInternedVar(lang.NewSymbol("boolean")) @@ -61654,7 +61652,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := lang.Apply(lang1.PushThreadBindings, []any{v3}) +v4 := lang.Apply(lang.PushThreadBindings, []any{v3}) return v4 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -61994,7 +61992,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { } v4 := args[0] v5 := args[1] -v6, _ := lang.FieldOrMethod(lang1.Numbers, "quotient") +v6, _ := lang.FieldOrMethod(lang.Numbers, "quotient") if reflect.TypeOf(v6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("quotient is not a function"))) } @@ -62014,7 +62012,7 @@ var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: -v3 := lang.Apply(rand22.Float64, nil) +v3 := lang.Apply(rand21.Float64, nil) return v3 case 1: v3 := args[0] @@ -62252,10 +62250,10 @@ if v6.IsMacro() { v7 := v6.Get() v8 := lang.Apply(v7, []any{v3}) if lang.IsTruthy(v8) { -v9 := lang.Apply(lang1.NewLongRange, []any{int64(0), v3, int64(1)}) +v9 := lang.Apply(lang.NewLongRange, []any{int64(0), v3, int64(1)}) v4 = v9 } else { -v10 := lang.Apply(lang1.NewRange, []any{int64(0), v3, int64(1)}) +v10 := lang.Apply(lang.NewRange, []any{int64(0), v3, int64(1)}) v4 = v10 } return v4 @@ -62286,10 +62284,10 @@ v12 = v16 v12 = v6 } if lang.IsTruthy(v12) { -v6 := lang.Apply(lang1.NewLongRange, []any{v3, v4, int64(1)}) +v6 := lang.Apply(lang.NewLongRange, []any{v3, v4, int64(1)}) v5 = v6 } else { -v7 := lang.Apply(lang1.NewRange, []any{v3, v4, int64(1)}) +v7 := lang.Apply(lang.NewRange, []any{v3, v4, int64(1)}) v5 = v7 } return v5 @@ -62336,10 +62334,10 @@ v13 = v20 v13 = v7 } if lang.IsTruthy(v13) { -v7 := lang.Apply(lang1.NewLongRange, []any{v3, v4, v5}) +v7 := lang.Apply(lang.NewLongRange, []any{v3, v4, v5}) v6 = v7 } else { -v8 := lang.Apply(lang1.NewRange, []any{v3, v4, v5}) +v8 := lang.Apply(lang.NewRange, []any{v3, v4, v5}) v6 = v8 } return v6 @@ -62368,7 +62366,7 @@ if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -v7 := lang.Apply(v6, []any{lang1.*Ratio, v3}) +v7 := lang.Apply(v6, []any{lang.*Ratio, v3}) return v7 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -62440,7 +62438,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4, _ := lang.FieldOrMethod(lang1.Numbers, "rationalize") +v4, _ := lang.FieldOrMethod(lang.Numbers, "rationalize") if reflect.TypeOf(v4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("rationalize is not a function"))) } @@ -62605,7 +62603,7 @@ if v0.Meta() != nil { } // re-matcher { -v1 := reflect.TypeOf((*lang1.RegexpMatcher)(nil)) +v1 := reflect.TypeOf((*lang.RegexpMatcher)(nil)) v0 := lang.NewSymbol("re-matcher").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("re"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns an instance of java.util.regex.Matcher, for use, e.g. in\n re-find.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4873), lang.NewKeyword("end-line"), int(4873))).(*lang.Symbol) var v3 lang.FnFunc v3 = lang.NewFnFunc(func(args ...any) any { @@ -62614,10 +62612,10 @@ v3 = lang.NewFnFunc(func(args ...any) any { } v4 := args[0] v5 := args[1] -v6 := lang.Apply(lang1.NewRegexpMatcher, []any{v4, v5}) +v6 := lang.Apply(lang.NewRegexpMatcher, []any{v4, v5}) return v6 }) -v4 := reflect.TypeOf((*lang1.RegexpMatcher)(nil)) +v4 := reflect.TypeOf((*lang.RegexpMatcher)(nil)) v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { @@ -62671,7 +62669,7 @@ if v0.Meta() != nil { } // re-pattern { -v1 := reflect.TypeOf((*regexp23.Regexp)(nil)) +v1 := reflect.TypeOf((*regexp22.Regexp)(nil)) v0 := lang.NewSymbol("re-pattern").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns an instance of java.util.regex.Pattern, for use, e.g. in\n re-matcher.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4863), lang.NewKeyword("end-line"), int(4863))).(*lang.Symbol) var v3 lang.FnFunc v3 = lang.NewFnFunc(func(args ...any) any { @@ -62686,16 +62684,16 @@ if v7.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } v8 := v7.Get() -v9 := lang.Apply(v8, []any{regexp23.*Regexp, v4}) +v9 := lang.Apply(v8, []any{regexp22.*Regexp, v4}) if lang.IsTruthy(v9) { v5 = v4 } else { -v10 := lang.Apply(regexp23.MustCompile, []any{v4}) +v10 := lang.Apply(regexp22.MustCompile, []any{v4}) v5 = v10 } return v5 }) -v4 := reflect.TypeOf((*regexp23.Regexp)(nil)) +v4 := reflect.TypeOf((*regexp22.Regexp)(nil)) v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { @@ -62755,7 +62753,7 @@ v23 = lang.NewFnFunc(func(args ...any) any { v24 := lang.Apply(v12, nil) return v24 }) -v24 := lang.Apply(lang1.NewLazySeq, []any{v23}) +v24 := lang.Apply(lang.NewLazySeq, []any{v23}) v25 := lang.Apply(v18, []any{v22, v24}) v13 = v25 } else { @@ -62912,7 +62910,7 @@ var v7 any func() { defer func() { if r := recover(); r != nil { -if lang.CatchMatches(r, lang1.Throwable) { +if lang.CatchMatches(r, lang.Throwable) { v8 := r _ = v8 v9, ok := lang.FieldOrMethod(v3, "getString") @@ -62994,7 +62992,7 @@ var v5 any func() { defer func() { if r := recover(); r != nil { -if lang.CatchMatches(r, lang1.Throwable) { +if lang.CatchMatches(r, lang.Throwable) { v6 := r _ = v6 v7, ok := lang.FieldOrMethod(v4, "getString") @@ -63260,7 +63258,7 @@ if v7.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } v8 := v7.Get() -v9 := lang.Apply(v8, []any{lang1.IReduce, v4}) +v9 := lang.Apply(v8, []any{lang.IReduce, v4}) if lang.IsTruthy(v9) { v10, _ := lang.FieldOrMethod(v4, "Reduce") if reflect.TypeOf(v10).Kind() != reflect.Func { @@ -63290,7 +63288,7 @@ if v8.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } v9 := v8.Get() -v10 := lang.Apply(v9, []any{lang1.IReduceInit, v5}) +v10 := lang.Apply(v9, []any{lang.IReduceInit, v5}) if lang.IsTruthy(v10) { v11, _ := lang.FieldOrMethod(v5, "ReduceInit") if reflect.TypeOf(v11).Kind() != reflect.Func { @@ -63491,7 +63489,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := lang.Apply(lang1.NewReduced, []any{v3}) +v4 := lang.Apply(lang.NewReduced, []any{v3}) return v4 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -63549,7 +63547,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5 := lang.Apply(lang1.IsReduced, []any{v4}) +v5 := lang.Apply(lang.IsReduced, []any{v4}) return v5 }) v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -63620,7 +63618,7 @@ v12 = v17 } return v12 }) -v6 := lang.Apply(lang1.NewLazySeq, []any{v5}) +v6 := lang.Apply(lang.NewLazySeq, []any{v5}) return v6 case 3: v3 := args[0] @@ -63703,7 +63701,7 @@ v29 = nil } return v29 }) -v23 := lang.Apply(lang1.NewLazySeq, []any{v22}) +v23 := lang.Apply(lang.NewLazySeq, []any{v22}) v24 := lang.Apply(v21, []any{v4, v23}) v6 = v24 } @@ -63726,7 +63724,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] -v4 := lang.Apply(lang1.NewRef, []any{v3}) +v4 := lang.Apply(lang.NewRef, []any{v3}) return v4 default: if len(args) < 1 { @@ -64084,7 +64082,7 @@ if v46.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) } v47 := v46.Get() -v48 := lang.Apply(v47, []any{lang1.Sequential, v26}) +v48 := lang.Apply(v47, []any{lang.Sequential, v26}) v49 := lang.Apply(v44, []any{v48}) v41 = v49 } else { @@ -64524,7 +64522,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { } v4 := args[0] v5 := args[1] -v6, _ := lang.FieldOrMethod(lang1.Numbers, "remainder") +v6, _ := lang.FieldOrMethod(lang.Numbers, "remainder") if reflect.TypeOf(v6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("remainder is not a function"))) } @@ -64648,7 +64646,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := lang.Apply(lang1.RemoveNamespace, []any{v3}) +v4 := lang.Apply(lang.RemoveNamespace, []any{v3}) return v4 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -64725,12 +64723,12 @@ v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] -v4 := lang.Apply(lang1.NewRepeat, []any{v3}) +v4 := lang.Apply(lang.NewRepeat, []any{v3}) return v4 case 2: v3 := args[0] v4 := args[1] -v5 := lang.Apply(lang1.NewRepeatN, []any{v3, v4}) +v5 := lang.Apply(lang.NewRepeatN, []any{v3, v4}) return v5 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -64772,7 +64770,7 @@ v12 := lang.Apply(v11, []any{v3}) v13 := lang.Apply(v7, []any{v8, v12}) return v13 }) -v5 := lang.Apply(lang1.NewLazySeq, []any{v4}) +v5 := lang.Apply(lang.NewLazySeq, []any{v4}) return v5 case 2: v3 := args[0] @@ -65135,7 +65133,7 @@ if v10.IsMacro() { } v11 := v10.Get() v12 := lang.Apply(v11, []any{"Not a qualified symbol: ", v3}) -v13 := lang.Apply(lang1.NewIllegalArgumentError, []any{v12}) +v13 := lang.Apply(lang.NewIllegalArgumentError, []any{v12}) panic(v13) } return v4 @@ -65266,7 +65264,7 @@ if v0.Meta() != nil { } // rest { -v1 := reflect.TypeOf((*lang1.ISeq)(nil)).Elem() +v1 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() v0 := lang.NewSymbol("rest").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a possibly empty seq of the items after the first. Calls seq on its\n argument.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(64), lang.NewKeyword("end-line"), int(70))).(*lang.Symbol) var v3 lang.FnFunc { // function rest @@ -65275,7 +65273,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v5 := args[0] -v6 := lang.Apply(lang1.Rest, []any{v5}) +v6 := lang.Apply(lang.Rest, []any{v5}) return v6 }) v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(70), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(70), lang.NewKeyword("end-column"), int(77))).(lang.FnFunc) @@ -65463,7 +65461,7 @@ var v50 any if lang.IsTruthy(v41) { v50 = v41 } else { -v51 := lang.Apply(Exception9., []any{"ResultSet must have unique column labels"}) +v51 := lang.Apply(lang.NewError, []any{"ResultSet must have unique column labels"}) panic(v51) } var v40 any = v50 @@ -65563,7 +65561,7 @@ v70 = lang.NewFnFunc(func(args ...any) any { v71 := lang.Apply(v55, nil) return v71 }) -v71 := lang.Apply(lang1.NewLazySeq, []any{v70}) +v71 := lang.Apply(lang.NewLazySeq, []any{v70}) v72 := lang.Apply(v61, []any{v69, v71}) v56 = v72 } else { @@ -65668,7 +65666,7 @@ if v11.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } v12 := v11.Get() -v13 := lang.Apply(strings14.LastIndex, []any{v4, "/"}) +v13 := lang.Apply(strings13.LastIndex, []any{v4, "/"}) v14 := lang.Apply(v12, []any{v4, int64(0), v13}) return v14 }) @@ -65701,8 +65699,8 @@ if v9.IsMacro() { } v10 := v9.Get() v11 := lang.Apply(v10, []any{v4}) -v12 := lang.Apply(strings14.ReplaceAll, []any{v11, "-", "_"}) -v13 := lang.Apply(strings14.ReplaceAll, []any{v12, ".", "/"}) +v12 := lang.Apply(strings13.ReplaceAll, []any{v11, "-", "_"}) +v13 := lang.Apply(strings13.ReplaceAll, []any{v12, ".", "/"}) v14 := lang.Apply(v7, []any{lang.NewChar(47), v13}) return v14 }) @@ -66220,7 +66218,7 @@ if v0.Meta() != nil { } // seq { -v1 := reflect.TypeOf((*lang1.ISeq)(nil)).Elem() +v1 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() v0 := lang.NewSymbol("seq").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a seq on the collection. If the collection is\n empty, returns nil. (seq nil) returns nil. seq also works on\n Strings, native Java arrays (of reference types) and any objects\n that implement Iterable. Note that seqs cache values, thus seq\n should not be used on any Iterable whose iterator repeatedly\n returns the same mutable object.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(4), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(126), lang.NewKeyword("end-line"), int(136))).(*lang.Symbol) var v3 lang.FnFunc { // function seq @@ -66229,7 +66227,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v5 := args[0] -v6 := lang.Apply(lang1.Seq, []any{v5}) +v6 := lang.Apply(lang.Seq, []any{v5}) return v6 }) v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(136), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(136), lang.NewKeyword("end-column"), int(126))).(lang.FnFunc) @@ -66266,7 +66264,7 @@ if v10.IsMacro() { } v11 := v10.Get() v12 := lang.Apply(v11, []any{v3}) -v13 := lang.Apply(lang1.NewPersistentArrayMapAsIfByAssoc, []any{v12}) +v13 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{v12}) v4 = v13 } else { var v14 any @@ -66315,7 +66313,7 @@ if v6.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } v7 := v6.Get() -v8 := lang.Apply(v7, []any{lang1.ISeq, v4}) +v8 := lang.Apply(v7, []any{lang.ISeq, v4}) return v8 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(150), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(150), lang.NewKeyword("end-column"), int(87))).(lang.FnFunc) @@ -66382,12 +66380,12 @@ if v12.IsMacro() { } v13 := v12.Get() v14 := lang.Apply(v13, []any{v3}) -v15 := lang.Apply(LinkedBlockingQueue24., []any{v14}) +v15 := lang.Apply(LinkedBlockingQueue23., []any{v14}) v6 = v15 } var v5 any = v6 _ = v5 -v17 := lang.Apply(Object13., nil) +v17 := lang.Apply(Object12., nil) var v16 any = v17 _ = v16 v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) @@ -66403,7 +66401,7 @@ v22 = lang.NewFnFunc(func(args ...any) any { } return v4 }) -v23 := lang.Apply(lang1.NewLazySeq, []any{v22}) +v23 := lang.Apply(lang.NewLazySeq, []any{v22}) v24 := lang.Apply(v21, []any{v23}) var v18 any = v24 _ = v18 @@ -66698,7 +66696,7 @@ v41 = v67 } return v41 }) -v37 := lang.Apply(lang1.NewLazySeq, []any{v36}) +v37 := lang.Apply(lang.NewLazySeq, []any{v36}) return v37 }) v35 := v34 @@ -66852,7 +66850,7 @@ if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -v7 := lang.Apply(v6, []any{lang1.Sequential, v3}) +v7 := lang.Apply(v6, []any{lang.Sequential, v3}) return v7 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -66945,7 +66943,7 @@ if v15.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) } v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang1.IReduceInit, v3}) +v17 := lang.Apply(v16, []any{lang.IReduceInit, v3}) if lang.IsTruthy(v17) { v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v19 := v18.FindInternedVar(lang.NewSymbol("persistent!")) @@ -67143,7 +67141,7 @@ if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -v7 := lang.Apply(v6, []any{lang1.IPersistentSet, v3}) +v7 := lang.Apply(v6, []any{lang.IPersistentSet, v3}) return v7 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -67342,7 +67340,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5 := lang.Apply(lang1.ShortCast, []any{v4}) +v5 := lang.Apply(lang.ShortCast, []any{v4}) return v5 }) v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -67444,7 +67442,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "shortArray") +v5, _ := lang.FieldOrMethod(lang.Numbers, "shortArray") if reflect.TypeOf(v5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("shortArray is not a function"))) } @@ -67453,7 +67451,7 @@ return v6 case 2: v4 := args[0] v5 := args[1] -v6, _ := lang.FieldOrMethod(lang1.Numbers, "shortArrayInit") +v6, _ := lang.FieldOrMethod(lang.Numbers, "shortArrayInit") if reflect.TypeOf(v6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("shortArrayInit is not a function"))) } @@ -67532,7 +67530,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "shorts") +v5, _ := lang.FieldOrMethod(lang.Numbers, "shorts") if reflect.TypeOf(v5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("shorts is not a function"))) } @@ -67561,7 +67559,7 @@ if v6.IsMacro() { } v7 := v6.Get() v8 := lang.Apply(v7, []any{v3}) -v9 := lang.Apply(lang1.NewArrayList, []any{v8}) +v9 := lang.Apply(lang.NewArrayList, []any{v8}) var v4 any = v9 _ = v4 v11 := lang.Apply(nil, []any{v4}) @@ -67594,7 +67592,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := lang.Apply(lang1.ShutdownAgents, nil) +v3 := lang.Apply(lang.ShutdownAgents, nil) return v3 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -67643,10 +67641,10 @@ if v19.IsMacro() { } v20 := v19.Get() v21 := lang.Apply(v20, []any{v16}) -v22 := lang.Apply(lang1.Equals, []any{lang.NewSymbol("&form"), v21}) +v22 := lang.Apply(lang.Equals, []any{lang.NewSymbol("&form"), v21}) if lang.IsTruthy(v22) { -v23 := lang.Apply(lang1.Count, []any{v16}) -v24 := lang.Apply(lang1.Subvec, []any{v16, int64(2), v23}) +v23 := lang.Apply(lang.Count, []any{v16}) +v24 := lang.Apply(lang.Subvec, []any{v16, int64(2), v23}) v17 = v24 } else { v17 = v16 @@ -67776,7 +67774,7 @@ if v25.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } v26 := v25.Get() -v27 := lang.Apply(v26, []any{lang1.*Symbol, v20}) +v27 := lang.Apply(v26, []any{lang.*Symbol, v20}) if lang.IsTruthy(v27) { var v28 any v29, ok := lang.FieldOrMethod(v20, "Name") @@ -67790,11 +67788,11 @@ case reflect.Func: default: v30 = v29 } -v31 := lang.Apply(strings14.Index, []any{v30, "."}) -v32 := lang.Apply(lang1.Equiv, []any{v31, int64(-1)}) +v31 := lang.Apply(strings13.Index, []any{v30, "."}) +v32 := lang.Apply(lang.Equiv, []any{v31, int64(-1)}) if lang.IsTruthy(v32) { var v33 any -v34 := lang.Apply(lang1.Equals, []any{nil, nil}) +v34 := lang.Apply(lang.Equals, []any{nil, nil}) if lang.IsTruthy(v34) { var v35 any = nil _ = v35 @@ -67823,7 +67821,7 @@ case reflect.Func: default: v45 = v44 } -v46 := lang.Apply(lang1.NewSymbol, []any{v45}) +v46 := lang.Apply(lang.NewSymbol, []any{v45}) v47 := lang.Apply(v43, []any{v15, lang.NewKeyword("tag"), v46}) v48 := lang.Apply(v40, []any{v14, v47}) v37 = v48 @@ -68143,7 +68141,7 @@ if v26.IsMacro() { v27 := v26.Get() v28 := lang.Apply(v27, []any{v13, v11}) _ = v28 -v29 := lang.Apply(lang1.ToString, []any{v11}) +v29 := lang.Apply(lang.ToString, []any{v11}) v22 = v29 }() return v22 @@ -69520,7 +69518,7 @@ v13 := v12.Get() v14 := lang.Apply(v13, []any{v4}) var v10 any = v14 _ = v10 -v16 := lang.Apply(lang1.SortSlice, []any{v10, v3}) +v16 := lang.Apply(lang.SortSlice, []any{v10, v3}) _ = v16 v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v18 := v17.FindInternedVar(lang.NewSymbol("with-meta")) @@ -69631,7 +69629,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := lang.NewList(args[0:]...) -v4 := lang.Apply(lang1.CreatePersistentTreeMap, []any{v3}) +v4 := lang.Apply(lang.CreatePersistentTreeMap, []any{v3}) return v4 } }) @@ -69674,7 +69672,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := lang.NewList(args[0:]...) -v4 := lang.Apply(lang1.CreatePersistentTreeSet, []any{v3}) +v4 := lang.Apply(lang.CreatePersistentTreeSet, []any{v3}) return v4 } }) @@ -69696,7 +69694,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { } v3 := args[0] v4 := lang.NewList(args[1:]...) -v5 := lang.Apply(lang1.CreatePersistentTreeSetWithComparator, []any{v3, v4}) +v5 := lang.Apply(lang.CreatePersistentTreeSetWithComparator, []any{v3, v4}) return v5 } }) @@ -69809,7 +69807,7 @@ if v16.IsMacro() { } v17 := v16.Get() v18 := lang.Apply(v17, []any{v4}) -v19 := lang.Apply(lang1.WriteWriter, []any{v6, v18}) +v19 := lang.Apply(lang.WriteWriter, []any{v6, v18}) v12 = v19 }() return v12 @@ -70068,7 +70066,7 @@ v9 := lang.Apply(v8, []any{v4}) if lang.IsTruthy(v9) { v5 = "" } else { -v10 := lang.Apply(lang1.ToString, []any{v4}) +v10 := lang.Apply(lang.ToString, []any{v4}) v5 = v10 } return v5 @@ -70175,7 +70173,7 @@ if v7.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } v8 := v7.Get() -v9 := lang.Apply(v8, []any{lang1.IEditableCollection, v3}) +v9 := lang.Apply(v8, []any{lang.IEditableCollection, v3}) if lang.IsTruthy(v9) { v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v11 := v10.FindInternedVar(lang.NewSymbol("with-meta")) @@ -70247,7 +70245,7 @@ if v8.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) } v9 := v8.Get() -v10 := lang.Apply(v9, []any{lang1.IEditableCollection, v3}) +v10 := lang.Apply(v9, []any{lang.IEditableCollection, v3}) if lang.IsTruthy(v10) { v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v12 := v11.FindInternedVar(lang.NewSymbol("with-meta")) @@ -70548,7 +70546,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { } v3 := args[0] v4 := lang.NewList(args[1:]...) -v5 := lang.Apply(lang1.ConstructPersistentStructMap, []any{v3, v4}) +v5 := lang.Apply(lang.ConstructPersistentStructMap, []any{v3, v4}) return v5 } }) @@ -70570,7 +70568,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { } v3 := args[0] v4 := lang.NewList(args[1:]...) -v5 := lang.Apply(lang1.CreatePersistentStructMap, []any{v3, v4}) +v5 := lang.Apply(lang.CreatePersistentStructMap, []any{v3, v4}) return v5 } }) @@ -70985,7 +70983,7 @@ if v0.Meta() != nil { } // symbol { -v1 := reflect.TypeOf((*lang1.Symbol)(nil)) +v1 := reflect.TypeOf((*lang.Symbol)(nil)) v0 := lang.NewSymbol("symbol").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name"))), lang.NewKeyword("doc"), "Returns a Symbol with the given namespace and name. Arity-1 works\n on strings, keywords, and vars.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(584), lang.NewKeyword("end-line"), int(584))).(*lang.Symbol) var v3 lang.FnFunc v3 = lang.NewFnFunc(func(args ...any) any { @@ -71012,7 +71010,7 @@ if v12.IsMacro() { v13 := v12.Get() v14 := lang.Apply(v13, []any{lang.Builtins["string"], v4}) if lang.IsTruthy(v14) { -v15 := lang.Apply(lang1.NewSymbol, []any{v4}) +v15 := lang.Apply(lang.NewSymbol, []any{v4}) v10 = v15 } else { var v16 any @@ -71022,7 +71020,7 @@ if v18.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) } v19 := v18.Get() -v20 := lang.Apply(v19, []any{lang1.*Var, v4}) +v20 := lang.Apply(v19, []any{lang.*Var, v4}) if lang.IsTruthy(v20) { v21, ok := lang.FieldOrMethod(v4, "toSymbol") if !ok { @@ -71044,7 +71042,7 @@ if v25.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) } v26 := v25.Get() -v27 := lang.Apply(v26, []any{lang1.Keyword, v4}) +v27 := lang.Apply(v26, []any{lang.Keyword, v4}) if lang.IsTruthy(v27) { v28, ok := lang.FieldOrMethod(v4, "sym") if !ok { @@ -71061,7 +71059,7 @@ v23 = v29 } else { var v30 any if lang.IsTruthy(lang.NewKeyword("else")) { -v31 := lang.Apply(lang1.NewIllegalArgumentError, []any{"no conversion to symbol"}) +v31 := lang.Apply(lang.NewIllegalArgumentError, []any{"no conversion to symbol"}) panic(v31) } else { v30 = nil @@ -71078,13 +71076,13 @@ return v5 case 2: v4 := args[0] v5 := args[1] -v6 := lang.Apply(lang1.InternSymbol, []any{v4, v5}) +v6 := lang.Apply(lang.InternSymbol, []any{v4, v5}) return v6 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) -v4 := reflect.TypeOf((*lang1.Symbol)(nil)) +v4 := reflect.TypeOf((*lang.Symbol)(nil)) v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { @@ -71106,7 +71104,7 @@ if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -v7 := lang.Apply(v6, []any{lang1.*Symbol, v3}) +v7 := lang.Apply(v6, []any{lang.*Symbol, v3}) return v7 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -71513,7 +71511,7 @@ v6 = nil } return v6 }) -v6 := lang.Apply(lang1.NewLazySeq, []any{v5}) +v6 := lang.Apply(lang.NewLazySeq, []any{v5}) return v6 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -71752,7 +71750,7 @@ v12 = nil } return v12 }) -v6 := lang.Apply(lang1.NewLazySeq, []any{v5}) +v6 := lang.Apply(lang.NewLazySeq, []any{v5}) return v6 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -71893,7 +71891,7 @@ v12 = nil } return v12 }) -v6 := lang.Apply(lang1.NewLazySeq, []any{v5}) +v6 := lang.Apply(lang.NewLazySeq, []any{v5}) return v6 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -71965,7 +71963,7 @@ if v6.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } v7 := v6.Get() -v8 := lang.Apply(v7, []any{lang1.*Namespace, v3}) +v8 := lang.Apply(v7, []any{lang.*Namespace, v3}) if lang.IsTruthy(v8) { v4 = v3 } else { @@ -71989,7 +71987,7 @@ if v17.IsMacro() { } v18 := v17.Get() v19 := lang.Apply(v18, []any{"No namespace: ", v3, " found"}) -v20 := lang.Apply(Exception9., []any{v19}) +v20 := lang.Apply(lang.NewError, []any{v19}) panic(v20) } v4 = v15 @@ -72083,7 +72081,7 @@ v13 := v12.Get() v14 := lang.Apply(v10, []any{v13, v4, v5}) var v7 any = v14 _ = v7 -v16 := lang.Apply(Exception9., []any{v7}) +v16 := lang.Apply(lang.NewError, []any{v7}) var v15 any = v16 _ = v15 v18, ok := lang.FieldOrMethod(v15, "getStackTrace") @@ -72189,7 +72187,7 @@ case reflect.Func: default: v46 = v45 } -v47 := lang.Apply(lang1.NewCompilerError, []any{v42, v44, v46, v15}) +v47 := lang.Apply(lang.NewCompilerError, []any{v42, v44, v46, v15}) panic(v47) } else { v6 = nil @@ -72809,7 +72807,7 @@ if v12.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } v13 := v12.Get() -v14 := lang.Apply(v13, []any{lang1.IReduceInit, v6}) +v14 := lang.Apply(v13, []any{lang.IReduceInit, v6}) if lang.IsTruthy(v14) { v15, _ := lang.FieldOrMethod(v6, "ReduceInit") if reflect.TypeOf(v15).Kind() != reflect.Func { @@ -72916,7 +72914,7 @@ v14 = nil v21 := lang.Apply(v13, []any{v9, v14}) return v21 }) -v11 := lang.Apply(lang1.NewLazySeq, []any{v10}) +v11 := lang.Apply(lang.NewLazySeq, []any{v10}) return v11 }) v8 := v7 @@ -72948,7 +72946,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5 := lang.Apply(lang1.Identical, []any{v4, true}) +v5 := lang.Apply(lang.Identical, []any{v4, true}) return v5 }) v4 := reflect.TypeOf(false) @@ -73097,7 +73095,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { } v4 := args[0] v5 := args[1] -v6, _ := lang.FieldOrMethod(lang1.Numbers, "unchecked_add") +v6, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_add") if reflect.TypeOf(v6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_add is not a function"))) } @@ -73203,7 +73201,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { } v4 := args[0] v5 := args[1] -v6, _ := lang.FieldOrMethod(lang1.Numbers, "unchecked_int_add") +v6, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_int_add") if reflect.TypeOf(v6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_add is not a function"))) } @@ -73300,7 +73298,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5 := lang.Apply(lang1.UncheckedByteCast, []any{v4}) +v5 := lang.Apply(lang.UncheckedByteCast, []any{v4}) return v5 }) v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -73490,7 +73488,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "unchecked_dec") +v5, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_dec") if reflect.TypeOf(v5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_dec is not a function"))) } @@ -73587,7 +73585,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "unchecked_int_dec") +v5, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_int_dec") if reflect.TypeOf(v5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_dec is not a function"))) } @@ -73693,7 +73691,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { } v4 := args[0] v5 := args[1] -v6, _ := lang.FieldOrMethod(lang1.Numbers, "unchecked_int_divide") +v6, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_int_divide") if reflect.TypeOf(v6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_divide is not a function"))) } @@ -73790,7 +73788,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5 := lang.Apply(lang1.AsFloat64, []any{v4}) +v5 := lang.Apply(lang.AsFloat64, []any{v4}) return v5 }) v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -73883,7 +73881,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5 := lang.Apply(lang1.UncheckedFloatCast, []any{v4}) +v5 := lang.Apply(lang.UncheckedFloatCast, []any{v4}) return v5 }) v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -73976,7 +73974,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "unchecked_inc") +v5, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_inc") if reflect.TypeOf(v5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_inc is not a function"))) } @@ -74073,7 +74071,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "unchecked_int_inc") +v5, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_int_inc") if reflect.TypeOf(v5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_inc is not a function"))) } @@ -74170,7 +74168,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5 := lang.Apply(lang1.UncheckedIntCast, []any{v4}) +v5 := lang.Apply(lang.UncheckedIntCast, []any{v4}) return v5 }) v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -74263,7 +74261,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5 := lang.Apply(lang1.UncheckedLongCast, []any{v4}) +v5 := lang.Apply(lang.UncheckedLongCast, []any{v4}) return v5 }) v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -74365,7 +74363,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { } v4 := args[0] v5 := args[1] -v6, _ := lang.FieldOrMethod(lang1.Numbers, "unchecked_multiply") +v6, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_multiply") if reflect.TypeOf(v6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_multiply is not a function"))) } @@ -74471,7 +74469,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { } v4 := args[0] v5 := args[1] -v6, _ := lang.FieldOrMethod(lang1.Numbers, "unchecked_int_multiply") +v6, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_int_multiply") if reflect.TypeOf(v6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_multiply is not a function"))) } @@ -74568,7 +74566,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "Unchecked_negate") +v5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_negate") if reflect.TypeOf(v5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_negate is not a function"))) } @@ -74665,7 +74663,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "unchecked_int_negate") +v5, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_int_negate") if reflect.TypeOf(v5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_negate is not a function"))) } @@ -74771,7 +74769,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { } v4 := args[0] v5 := args[1] -v6, _ := lang.FieldOrMethod(lang1.Numbers, "unchecked_int_remainder") +v6, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_int_remainder") if reflect.TypeOf(v6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_remainder is not a function"))) } @@ -74868,7 +74866,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5 := lang.Apply(lang1.UncheckedShortCast, []any{v4}) +v5 := lang.Apply(lang.UncheckedShortCast, []any{v4}) return v5 }) v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -74970,7 +74968,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { } v4 := args[0] v5 := args[1] -v6, _ := lang.FieldOrMethod(lang1.Numbers, "unchecked_minus") +v6, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_minus") if reflect.TypeOf(v6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_minus is not a function"))) } @@ -75076,7 +75074,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { } v4 := args[0] v5 := args[1] -v6, _ := lang.FieldOrMethod(lang1.Numbers, "unchecked_int_subtract") +v6, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_int_subtract") if reflect.TypeOf(v6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_subtract is not a function"))) } @@ -75463,7 +75461,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { } v4 := args[0] v5 := args[1] -v6, _ := lang.FieldOrMethod(lang1.Numbers, "unsignedShiftRight") +v6, _ := lang.FieldOrMethod(lang.Numbers, "unsignedShiftRight") if reflect.TypeOf(v6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("unsignedShiftRight is not a function"))) } @@ -75872,7 +75870,7 @@ if v19.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) } v20 := v19.Get() -v21 := lang.Apply(v20, []any{lang1.IEditableCollection, v3}) +v21 := lang.Apply(v20, []any{lang.IEditableCollection, v3}) if lang.IsTruthy(v21) { v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v23 := v22.FindInternedVar(lang.NewSymbol("transient")) @@ -75931,7 +75929,7 @@ if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -v7 := lang.Apply(v6, []any{java.net25.URI, v3}) +v7 := lang.Apply(v6, []any{java.net24.URI, v3}) return v7 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -75988,7 +75986,7 @@ if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -v7 := lang.Apply(v6, []any{java.util18.UUID, v3}) +v7 := lang.Apply(v6, []any{java.util17.UUID, v3}) return v7 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -76028,7 +76026,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v4 := lang.Apply(lang1.Vals, []any{v3}) +v4 := lang.Apply(lang.Vals, []any{v3}) return v4 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -76097,7 +76095,7 @@ if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -v7 := lang.Apply(v6, []any{lang1.*Var, v3}) +v7 := lang.Apply(v6, []any{lang.*Var, v3}) return v7 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -76174,7 +76172,7 @@ if v11.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang1.IObj, v3}) +v13 := lang.Apply(v12, []any{lang.IObj, v3}) if lang.IsTruthy(v13) { v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) v15 := v14.FindInternedVar(lang.NewSymbol("with-meta")) @@ -76185,12 +76183,12 @@ v16 := v15.Get() v17 := lang.Apply(v16, []any{v3, nil}) v9 = v17 } else { -v18 := lang.Apply(lang1.CreateLazilyPersistentVector, []any{v3}) +v18 := lang.Apply(lang.CreateLazilyPersistentVector, []any{v3}) v9 = v18 } v4 = v9 } else { -v19 := lang.Apply(lang1.CreateLazilyPersistentVector, []any{v3}) +v19 := lang.Apply(lang.CreateLazilyPersistentVector, []any{v3}) v4 = v19 } return v4 @@ -76337,7 +76335,7 @@ v30 := lang.Apply(v21, []any{v6, v29}) v31 := lang.Apply(v18, []any{v5, v30}) v32 := lang.Apply(v15, []any{v4, v31}) v33 := lang.Apply(v12, []any{v3, v32}) -v34 := lang.Apply(lang1.CreateLazilyPersistentVector, []any{v33}) +v34 := lang.Apply(lang.CreateLazilyPersistentVector, []any{v33}) return v34 } }) @@ -76363,7 +76361,7 @@ if v6.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } v7 := v6.Get() -v8 := lang.Apply(v7, []any{lang1.IPersistentVector, v4}) +v8 := lang.Apply(v7, []any{lang.IPersistentVector, v4}) return v8 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(178), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(178), lang.NewKeyword("end-column"), int(106))).(lang.FnFunc) @@ -76377,7 +76375,7 @@ if v0.Meta() != nil { } // volatile! { -v1 := reflect.TypeOf((*lang1.Volatile)(nil)).Elem() +v1 := reflect.TypeOf((*lang.Volatile)(nil)).Elem() v0 := lang.NewSymbol("volatile!").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Creates and returns a Volatile with an initial value of val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2517), lang.NewKeyword("end-line"), int(2517))).(*lang.Symbol) var v3 lang.FnFunc v3 = lang.NewFnFunc(func(args ...any) any { @@ -76385,10 +76383,10 @@ v3 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5 := lang.Apply(lang1.NewVolatile, []any{v4}) +v5 := lang.Apply(lang.NewVolatile, []any{v4}) return v5 }) -v4 := reflect.TypeOf((*lang1.Volatile)(nil)).Elem() +v4 := reflect.TypeOf((*lang.Volatile)(nil)).Elem() v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { @@ -76410,7 +76408,7 @@ if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -v7 := lang.Apply(v6, []any{lang1.Volatile, v3}) +v7 := lang.Apply(v6, []any{lang.Volatile, v3}) return v7 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -76662,7 +76660,7 @@ v24 := v23.Get() v25 := lang.Apply(v24, []any{v3}) v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) -v28 := lang.Apply(lang1.NewIllegalArgumentError, []any{v27}) +v28 := lang.Apply(lang.NewIllegalArgumentError, []any{v27}) panic(v28) } _ = v7 @@ -76712,7 +76710,7 @@ v50 := v49.Get() v51 := lang.Apply(v50, []any{v3}) v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) v53 := lang.Apply(v40, []any{v44, " requires ", "exactly 2 forms in binding vector", " in ", v47, ":", v52}) -v54 := lang.Apply(lang1.NewIllegalArgumentError, []any{v53}) +v54 := lang.Apply(lang.NewIllegalArgumentError, []any{v53}) panic(v54) } _ = v29 @@ -77000,7 +76998,7 @@ v24 := v23.Get() v25 := lang.Apply(v24, []any{v3}) v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) -v28 := lang.Apply(lang1.NewIllegalArgumentError, []any{v27}) +v28 := lang.Apply(lang.NewIllegalArgumentError, []any{v27}) panic(v28) } _ = v7 @@ -77050,7 +77048,7 @@ v50 := v49.Get() v51 := lang.Apply(v50, []any{v3}) v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) v53 := lang.Apply(v40, []any{v44, " requires ", "exactly 2 forms in binding vector", " in ", v47, ":", v52}) -v54 := lang.Apply(lang1.NewIllegalArgumentError, []any{v53}) +v54 := lang.Apply(lang.NewIllegalArgumentError, []any{v53}) panic(v54) } _ = v29 @@ -77340,7 +77338,7 @@ v24 := v23.Get() v25 := lang.Apply(v24, []any{v3}) v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) -v28 := lang.Apply(lang1.NewIllegalArgumentError, []any{v27}) +v28 := lang.Apply(lang.NewIllegalArgumentError, []any{v27}) panic(v28) } _ = v7 @@ -77390,7 +77388,7 @@ v50 := v49.Get() v51 := lang.Apply(v50, []any{v3}) v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) v53 := lang.Apply(v40, []any{v44, " requires ", "exactly 2 forms in binding vector", " in ", v47, ":", v52}) -v54 := lang.Apply(lang1.NewIllegalArgumentError, []any{v53}) +v54 := lang.Apply(lang.NewIllegalArgumentError, []any{v53}) panic(v54) } _ = v29 @@ -78464,7 +78462,7 @@ v24 := v23.Get() v25 := lang.Apply(v24, []any{v3}) v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) -v28 := lang.Apply(lang1.NewIllegalArgumentError, []any{v27}) +v28 := lang.Apply(lang.NewIllegalArgumentError, []any{v27}) panic(v28) } _ = v7 @@ -78514,7 +78512,7 @@ v50 := v49.Get() v51 := lang.Apply(v50, []any{v3}) v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) v53 := lang.Apply(v40, []any{v44, " requires ", "an even number of forms in binding vector", " in ", v47, ":", v52}) -v54 := lang.Apply(lang1.NewIllegalArgumentError, []any{v53}) +v54 := lang.Apply(lang.NewIllegalArgumentError, []any{v53}) panic(v54) } _ = v29 @@ -78830,7 +78828,7 @@ v24 := v23.Get() v25 := lang.Apply(v24, []any{v3}) v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) -v28 := lang.Apply(lang1.NewIllegalArgumentError, []any{v27}) +v28 := lang.Apply(lang.NewIllegalArgumentError, []any{v27}) panic(v28) } _ = v7 @@ -78880,7 +78878,7 @@ v50 := v49.Get() v51 := lang.Apply(v50, []any{v3}) v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) v53 := lang.Apply(v40, []any{v44, " requires ", "an even number of forms in binding vector", " in ", v47, ":", v52}) -v54 := lang.Apply(lang1.NewIllegalArgumentError, []any{v53}) +v54 := lang.Apply(lang.NewIllegalArgumentError, []any{v53}) panic(v54) } _ = v29 @@ -79114,7 +79112,7 @@ v76 = v182 } else { var v183 any if lang.IsTruthy(lang.NewKeyword("else")) { -v184 := lang.Apply(lang1.NewIllegalArgumentError, []any{"with-open only allows Symbols in bindings"}) +v184 := lang.Apply(lang.NewIllegalArgumentError, []any{"with-open only allows Symbols in bindings"}) panic(v184) } else { v183 = nil @@ -80212,7 +80210,7 @@ v3 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] -v5, _ := lang.FieldOrMethod(lang1.Numbers, "isZero") +v5, _ := lang.FieldOrMethod(lang.Numbers, "isZero") if reflect.TypeOf(v5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("isZero is not a function"))) } diff --git a/pkg/codegen/testdata/codegen/test/def_simple.go b/pkg/codegen/testdata/codegen/test/def_simple.go index 4e3cbb6c..dc09bc97 100644 --- a/pkg/codegen/testdata/codegen/test/def_simple.go +++ b/pkg/codegen/testdata/codegen/test/def_simple.go @@ -3,7 +3,7 @@ package generated import ( - "github.com/glojurelang/glojure/pkg/lang" + lang "github.com/glojurelang/glojure/pkg/lang" ) func init() { diff --git a/pkg/codegen/testdata/codegen/test/fn_closure.go b/pkg/codegen/testdata/codegen/test/fn_closure.go index f9d656e0..67daf554 100644 --- a/pkg/codegen/testdata/codegen/test/fn_closure.go +++ b/pkg/codegen/testdata/codegen/test/fn_closure.go @@ -4,7 +4,7 @@ package generated import ( fmt "fmt" - "github.com/glojurelang/glojure/pkg/lang" + lang "github.com/glojurelang/glojure/pkg/lang" ) func init() { diff --git a/pkg/codegen/testdata/codegen/test/fn_recur.go b/pkg/codegen/testdata/codegen/test/fn_recur.go index 62f42ae4..dcc7ceef 100644 --- a/pkg/codegen/testdata/codegen/test/fn_recur.go +++ b/pkg/codegen/testdata/codegen/test/fn_recur.go @@ -4,7 +4,7 @@ package generated import ( fmt "fmt" - "github.com/glojurelang/glojure/pkg/lang" + lang "github.com/glojurelang/glojure/pkg/lang" ) func init() { diff --git a/pkg/codegen/testdata/codegen/test/loop_simple.go b/pkg/codegen/testdata/codegen/test/loop_simple.go index d5d5d367..2645677d 100644 --- a/pkg/codegen/testdata/codegen/test/loop_simple.go +++ b/pkg/codegen/testdata/codegen/test/loop_simple.go @@ -4,7 +4,7 @@ package generated import ( fmt "fmt" - "github.com/glojurelang/glojure/pkg/lang" + lang "github.com/glojurelang/glojure/pkg/lang" ) func init() { diff --git a/pkg/codegen/testdata/codegen/test/maybe_class.go b/pkg/codegen/testdata/codegen/test/maybe_class.go index 8ca9010b..45b02008 100644 --- a/pkg/codegen/testdata/codegen/test/maybe_class.go +++ b/pkg/codegen/testdata/codegen/test/maybe_class.go @@ -4,8 +4,8 @@ package generated import ( fmt "fmt" - "github.com/glojurelang/glojure/pkg/lang" - strings1 "strings" + lang "github.com/glojurelang/glojure/pkg/lang" + strings2 "strings" ) func init() { @@ -25,7 +25,7 @@ func init() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) } v5 := v4.Get() - v6 := lang.Apply(strings1.Split, []any{"1,2,3", ","}) + v6 := lang.Apply(strings2.Split, []any{"1,2,3", ","}) v7 := lang.Apply(v5, []any{v6}) return v7 }) diff --git a/pkg/codegen/testdata/codegen/test/ns_skip.go b/pkg/codegen/testdata/codegen/test/ns_skip.go index d60d30b3..08024417 100644 --- a/pkg/codegen/testdata/codegen/test/ns_skip.go +++ b/pkg/codegen/testdata/codegen/test/ns_skip.go @@ -3,7 +3,7 @@ package generated import ( - "github.com/glojurelang/glojure/pkg/lang" + lang "github.com/glojurelang/glojure/pkg/lang" ) func init() { diff --git a/pkg/codegen/testdata/codegen/test/quote_simple.go b/pkg/codegen/testdata/codegen/test/quote_simple.go index 43d5d832..b8a62159 100644 --- a/pkg/codegen/testdata/codegen/test/quote_simple.go +++ b/pkg/codegen/testdata/codegen/test/quote_simple.go @@ -4,7 +4,7 @@ package generated import ( fmt "fmt" - "github.com/glojurelang/glojure/pkg/lang" + lang "github.com/glojurelang/glojure/pkg/lang" ) func init() { diff --git a/pkg/codegen/testdata/codegen/test/the_var.go b/pkg/codegen/testdata/codegen/test/the_var.go index 3e1e1d2d..36f0b19b 100644 --- a/pkg/codegen/testdata/codegen/test/the_var.go +++ b/pkg/codegen/testdata/codegen/test/the_var.go @@ -4,7 +4,7 @@ package generated import ( fmt "fmt" - "github.com/glojurelang/glojure/pkg/lang" + lang "github.com/glojurelang/glojure/pkg/lang" reflect "reflect" ) diff --git a/pkg/codegen/testdata/codegen/test/throw_simple.go b/pkg/codegen/testdata/codegen/test/throw_simple.go index b78e232b..176740b9 100644 --- a/pkg/codegen/testdata/codegen/test/throw_simple.go +++ b/pkg/codegen/testdata/codegen/test/throw_simple.go @@ -4,7 +4,7 @@ package generated import ( fmt "fmt" - "github.com/glojurelang/glojure/pkg/lang" + lang "github.com/glojurelang/glojure/pkg/lang" ) func init() { diff --git a/pkg/codegen/testdata/codegen/test/try_advanced.go b/pkg/codegen/testdata/codegen/test/try_advanced.go index 66672a45..95874b81 100644 --- a/pkg/codegen/testdata/codegen/test/try_advanced.go +++ b/pkg/codegen/testdata/codegen/test/try_advanced.go @@ -4,7 +4,7 @@ package generated import ( fmt "fmt" - "github.com/glojurelang/glojure/pkg/lang" + lang "github.com/glojurelang/glojure/pkg/lang" ) func init() { diff --git a/pkg/codegen/testdata/codegen/test/try_basic.go b/pkg/codegen/testdata/codegen/test/try_basic.go index afcba7eb..8c22b674 100644 --- a/pkg/codegen/testdata/codegen/test/try_basic.go +++ b/pkg/codegen/testdata/codegen/test/try_basic.go @@ -4,7 +4,7 @@ package generated import ( fmt "fmt" - "github.com/glojurelang/glojure/pkg/lang" + lang "github.com/glojurelang/glojure/pkg/lang" ) func init() { diff --git a/pkg/codegen/testdata/codegen/test/values.go b/pkg/codegen/testdata/codegen/test/values.go index eb9f4db1..97bff87f 100644 --- a/pkg/codegen/testdata/codegen/test/values.go +++ b/pkg/codegen/testdata/codegen/test/values.go @@ -3,11 +3,10 @@ package generated import ( - hex0 "encoding/hex" + hex1 "encoding/hex" fmt "fmt" - "github.com/glojurelang/glojure/pkg/lang" - lang3 "github.com/glojurelang/glojure/pkg/lang" - big1 "math/big" + lang "github.com/glojurelang/glojure/pkg/lang" + big2 "math/big" reflect "reflect" ) @@ -16,15 +15,15 @@ func init() { _ = ns // -main { - v1 := lang.NewBigDecimalFromBigFloat((func() *big1.Float { - var z big1.Float - b, _ := hex0.DecodeString("010a0000004000000004a000000000000000") + v1 := lang.NewBigDecimalFromBigFloat((func() *big2.Float { + var z big2.Float + b, _ := hex1.DecodeString("010a0000004000000004a000000000000000") if err := z.GobDecode(b); err != nil { panic(err) } return &z })()) - v2 := reflect.TypeOf((*lang3.BigDecimal)(nil)) + v2 := reflect.TypeOf((*lang.BigDecimal)(nil)) v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), lang.NewVector(v1, v2), lang.NewKeyword("file"), "codegen/test/values.glj", lang.NewKeyword("line"), int(6), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(6), lang.NewKeyword("end-column"), int(56), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.values")))).(*lang.Symbol) var v4 lang.FnFunc v4 = lang.NewFnFunc(func(args ...any) any { @@ -60,9 +59,9 @@ func init() { // big-decimal { v0 := lang.NewSymbol("big-decimal").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/values.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.values")))).(*lang.Symbol) - v2 := lang.NewBigDecimalFromBigFloat((func() *big1.Float { - var z big1.Float - b, _ := hex0.DecodeString("010a0000004000000004a000000000000000") + v2 := lang.NewBigDecimalFromBigFloat((func() *big2.Float { + var z big2.Float + b, _ := hex1.DecodeString("010a0000004000000004a000000000000000") if err := z.GobDecode(b); err != nil { panic(err) } @@ -76,7 +75,7 @@ func init() { // big-decimal-type { v0 := lang.NewSymbol("big-decimal-type").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/values.glj", lang.NewKeyword("line"), int(4), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(4), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.values")))).(*lang.Symbol) - v2 := reflect.TypeOf((*lang3.BigDecimal)(nil)) + v2 := reflect.TypeOf((*lang.BigDecimal)(nil)) v1 := ns.InternWithValue(v0, v2, true) if v0.Meta() != nil { v1.SetMeta(v0.Meta().(lang.IPersistentMap)) diff --git a/pkg/codegen/testdata/codegen/test/with_meta.go b/pkg/codegen/testdata/codegen/test/with_meta.go index f6938df9..9b2c6d19 100644 --- a/pkg/codegen/testdata/codegen/test/with_meta.go +++ b/pkg/codegen/testdata/codegen/test/with_meta.go @@ -4,7 +4,7 @@ package generated import ( fmt "fmt" - "github.com/glojurelang/glojure/pkg/lang" + lang "github.com/glojurelang/glojure/pkg/lang" ) func init() { diff --git a/pkg/gen/gljimports/gljimports_darwin_amd64.go b/pkg/gen/gljimports/gljimports_darwin_amd64.go index 467fcc35..f7bfc812 100644 --- a/pkg/gen/gljimports/gljimports_darwin_amd64.go +++ b/pkg/gen/gljimports/gljimports_darwin_amd64.go @@ -3506,6 +3506,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.ErrNoTransaction", github_com_glojurelang_glojure_pkg_lang.ErrNoTransaction) _register("github.com/glojurelang/glojure/pkg/lang.Error", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Error)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*Error", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Error)(nil))) + _register("github.com/glojurelang/glojure/pkg/lang.EvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.EvalError)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.*EvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.EvalError)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.FieldOrMethod", github_com_glojurelang_glojure_pkg_lang.FieldOrMethod) _register("github.com/glojurelang/glojure/pkg/lang.FindNamespace", github_com_glojurelang_glojure_pkg_lang.FindNamespace) _register("github.com/glojurelang/glojure/pkg/lang.FindOrCreateNamespace", github_com_glojurelang_glojure_pkg_lang.FindOrCreateNamespace) @@ -3789,6 +3791,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewCons", github_com_glojurelang_glojure_pkg_lang.NewCons) _register("github.com/glojurelang/glojure/pkg/lang.NewCycle", github_com_glojurelang_glojure_pkg_lang.NewCycle) _register("github.com/glojurelang/glojure/pkg/lang.NewError", github_com_glojurelang_glojure_pkg_lang.NewError) + _register("github.com/glojurelang/glojure/pkg/lang.NewEvalError", github_com_glojurelang_glojure_pkg_lang.NewEvalError) _register("github.com/glojurelang/glojure/pkg/lang.NewFnFunc", github_com_glojurelang_glojure_pkg_lang.NewFnFunc) _register("github.com/glojurelang/glojure/pkg/lang.NewGoMapSeq", github_com_glojurelang_glojure_pkg_lang.NewGoMapSeq) _register("github.com/glojurelang/glojure/pkg/lang.NewIllegalArgumentError", github_com_glojurelang_glojure_pkg_lang.NewIllegalArgumentError) @@ -3968,8 +3971,6 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/runtime.AddLoadPath", github_com_glojurelang_glojure_pkg_runtime.AddLoadPath) _register("github.com/glojurelang/glojure/pkg/runtime.Compiler", github_com_glojurelang_glojure_pkg_runtime.Compiler) _register("github.com/glojurelang/glojure/pkg/runtime.Debug", github_com_glojurelang_glojure_pkg_runtime.Debug) - _register("github.com/glojurelang/glojure/pkg/runtime.EvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.EvalError)(nil)).Elem()) - _register("github.com/glojurelang/glojure/pkg/runtime.*EvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.EvalError)(nil))) _register("github.com/glojurelang/glojure/pkg/runtime.EvalOption", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.EvalOption)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.Fn", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Fn)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.*Fn", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Fn)(nil))) @@ -3978,6 +3979,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/runtime.Program", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Program)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.*Program", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Program)(nil))) _register("github.com/glojurelang/glojure/pkg/runtime.RT", github_com_glojurelang_glojure_pkg_runtime.RT) + _register("github.com/glojurelang/glojure/pkg/runtime.RTEvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTEvalError)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/runtime.*RTEvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTEvalError)(nil))) _register("github.com/glojurelang/glojure/pkg/runtime.RTMethods", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTMethods)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.*RTMethods", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTMethods)(nil))) _register("github.com/glojurelang/glojure/pkg/runtime.RTReadString", github_com_glojurelang_glojure_pkg_runtime.RTReadString) diff --git a/pkg/gen/gljimports/gljimports_darwin_arm64.go b/pkg/gen/gljimports/gljimports_darwin_arm64.go index a80f9a62..275e0a3f 100644 --- a/pkg/gen/gljimports/gljimports_darwin_arm64.go +++ b/pkg/gen/gljimports/gljimports_darwin_arm64.go @@ -3506,6 +3506,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.ErrNoTransaction", github_com_glojurelang_glojure_pkg_lang.ErrNoTransaction) _register("github.com/glojurelang/glojure/pkg/lang.Error", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Error)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*Error", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Error)(nil))) + _register("github.com/glojurelang/glojure/pkg/lang.EvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.EvalError)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.*EvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.EvalError)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.FieldOrMethod", github_com_glojurelang_glojure_pkg_lang.FieldOrMethod) _register("github.com/glojurelang/glojure/pkg/lang.FindNamespace", github_com_glojurelang_glojure_pkg_lang.FindNamespace) _register("github.com/glojurelang/glojure/pkg/lang.FindOrCreateNamespace", github_com_glojurelang_glojure_pkg_lang.FindOrCreateNamespace) @@ -3789,6 +3791,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewCons", github_com_glojurelang_glojure_pkg_lang.NewCons) _register("github.com/glojurelang/glojure/pkg/lang.NewCycle", github_com_glojurelang_glojure_pkg_lang.NewCycle) _register("github.com/glojurelang/glojure/pkg/lang.NewError", github_com_glojurelang_glojure_pkg_lang.NewError) + _register("github.com/glojurelang/glojure/pkg/lang.NewEvalError", github_com_glojurelang_glojure_pkg_lang.NewEvalError) _register("github.com/glojurelang/glojure/pkg/lang.NewFnFunc", github_com_glojurelang_glojure_pkg_lang.NewFnFunc) _register("github.com/glojurelang/glojure/pkg/lang.NewGoMapSeq", github_com_glojurelang_glojure_pkg_lang.NewGoMapSeq) _register("github.com/glojurelang/glojure/pkg/lang.NewIllegalArgumentError", github_com_glojurelang_glojure_pkg_lang.NewIllegalArgumentError) @@ -3968,8 +3971,6 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/runtime.AddLoadPath", github_com_glojurelang_glojure_pkg_runtime.AddLoadPath) _register("github.com/glojurelang/glojure/pkg/runtime.Compiler", github_com_glojurelang_glojure_pkg_runtime.Compiler) _register("github.com/glojurelang/glojure/pkg/runtime.Debug", github_com_glojurelang_glojure_pkg_runtime.Debug) - _register("github.com/glojurelang/glojure/pkg/runtime.EvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.EvalError)(nil)).Elem()) - _register("github.com/glojurelang/glojure/pkg/runtime.*EvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.EvalError)(nil))) _register("github.com/glojurelang/glojure/pkg/runtime.EvalOption", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.EvalOption)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.Fn", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Fn)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.*Fn", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Fn)(nil))) @@ -3978,6 +3979,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/runtime.Program", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Program)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.*Program", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Program)(nil))) _register("github.com/glojurelang/glojure/pkg/runtime.RT", github_com_glojurelang_glojure_pkg_runtime.RT) + _register("github.com/glojurelang/glojure/pkg/runtime.RTEvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTEvalError)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/runtime.*RTEvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTEvalError)(nil))) _register("github.com/glojurelang/glojure/pkg/runtime.RTMethods", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTMethods)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.*RTMethods", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTMethods)(nil))) _register("github.com/glojurelang/glojure/pkg/runtime.RTReadString", github_com_glojurelang_glojure_pkg_runtime.RTReadString) diff --git a/pkg/gen/gljimports/gljimports_js_wasm.go b/pkg/gen/gljimports/gljimports_js_wasm.go index 71eb456c..cf521818 100644 --- a/pkg/gen/gljimports/gljimports_js_wasm.go +++ b/pkg/gen/gljimports/gljimports_js_wasm.go @@ -3506,6 +3506,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.ErrNoTransaction", github_com_glojurelang_glojure_pkg_lang.ErrNoTransaction) _register("github.com/glojurelang/glojure/pkg/lang.Error", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Error)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*Error", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Error)(nil))) + _register("github.com/glojurelang/glojure/pkg/lang.EvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.EvalError)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.*EvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.EvalError)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.FieldOrMethod", github_com_glojurelang_glojure_pkg_lang.FieldOrMethod) _register("github.com/glojurelang/glojure/pkg/lang.FindNamespace", github_com_glojurelang_glojure_pkg_lang.FindNamespace) _register("github.com/glojurelang/glojure/pkg/lang.FindOrCreateNamespace", github_com_glojurelang_glojure_pkg_lang.FindOrCreateNamespace) @@ -3789,6 +3791,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewCons", github_com_glojurelang_glojure_pkg_lang.NewCons) _register("github.com/glojurelang/glojure/pkg/lang.NewCycle", github_com_glojurelang_glojure_pkg_lang.NewCycle) _register("github.com/glojurelang/glojure/pkg/lang.NewError", github_com_glojurelang_glojure_pkg_lang.NewError) + _register("github.com/glojurelang/glojure/pkg/lang.NewEvalError", github_com_glojurelang_glojure_pkg_lang.NewEvalError) _register("github.com/glojurelang/glojure/pkg/lang.NewFnFunc", github_com_glojurelang_glojure_pkg_lang.NewFnFunc) _register("github.com/glojurelang/glojure/pkg/lang.NewGoMapSeq", github_com_glojurelang_glojure_pkg_lang.NewGoMapSeq) _register("github.com/glojurelang/glojure/pkg/lang.NewIllegalArgumentError", github_com_glojurelang_glojure_pkg_lang.NewIllegalArgumentError) @@ -3968,8 +3971,6 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/runtime.AddLoadPath", github_com_glojurelang_glojure_pkg_runtime.AddLoadPath) _register("github.com/glojurelang/glojure/pkg/runtime.Compiler", github_com_glojurelang_glojure_pkg_runtime.Compiler) _register("github.com/glojurelang/glojure/pkg/runtime.Debug", github_com_glojurelang_glojure_pkg_runtime.Debug) - _register("github.com/glojurelang/glojure/pkg/runtime.EvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.EvalError)(nil)).Elem()) - _register("github.com/glojurelang/glojure/pkg/runtime.*EvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.EvalError)(nil))) _register("github.com/glojurelang/glojure/pkg/runtime.EvalOption", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.EvalOption)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.Fn", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Fn)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.*Fn", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Fn)(nil))) @@ -3978,6 +3979,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/runtime.Program", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Program)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.*Program", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Program)(nil))) _register("github.com/glojurelang/glojure/pkg/runtime.RT", github_com_glojurelang_glojure_pkg_runtime.RT) + _register("github.com/glojurelang/glojure/pkg/runtime.RTEvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTEvalError)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/runtime.*RTEvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTEvalError)(nil))) _register("github.com/glojurelang/glojure/pkg/runtime.RTMethods", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTMethods)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.*RTMethods", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTMethods)(nil))) _register("github.com/glojurelang/glojure/pkg/runtime.RTReadString", github_com_glojurelang_glojure_pkg_runtime.RTReadString) diff --git a/pkg/gen/gljimports/gljimports_linux_amd64.go b/pkg/gen/gljimports/gljimports_linux_amd64.go index e6dfabc9..5a83a725 100644 --- a/pkg/gen/gljimports/gljimports_linux_amd64.go +++ b/pkg/gen/gljimports/gljimports_linux_amd64.go @@ -3506,6 +3506,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.ErrNoTransaction", github_com_glojurelang_glojure_pkg_lang.ErrNoTransaction) _register("github.com/glojurelang/glojure/pkg/lang.Error", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Error)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*Error", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Error)(nil))) + _register("github.com/glojurelang/glojure/pkg/lang.EvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.EvalError)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.*EvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.EvalError)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.FieldOrMethod", github_com_glojurelang_glojure_pkg_lang.FieldOrMethod) _register("github.com/glojurelang/glojure/pkg/lang.FindNamespace", github_com_glojurelang_glojure_pkg_lang.FindNamespace) _register("github.com/glojurelang/glojure/pkg/lang.FindOrCreateNamespace", github_com_glojurelang_glojure_pkg_lang.FindOrCreateNamespace) @@ -3789,6 +3791,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewCons", github_com_glojurelang_glojure_pkg_lang.NewCons) _register("github.com/glojurelang/glojure/pkg/lang.NewCycle", github_com_glojurelang_glojure_pkg_lang.NewCycle) _register("github.com/glojurelang/glojure/pkg/lang.NewError", github_com_glojurelang_glojure_pkg_lang.NewError) + _register("github.com/glojurelang/glojure/pkg/lang.NewEvalError", github_com_glojurelang_glojure_pkg_lang.NewEvalError) _register("github.com/glojurelang/glojure/pkg/lang.NewFnFunc", github_com_glojurelang_glojure_pkg_lang.NewFnFunc) _register("github.com/glojurelang/glojure/pkg/lang.NewGoMapSeq", github_com_glojurelang_glojure_pkg_lang.NewGoMapSeq) _register("github.com/glojurelang/glojure/pkg/lang.NewIllegalArgumentError", github_com_glojurelang_glojure_pkg_lang.NewIllegalArgumentError) @@ -3968,8 +3971,6 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/runtime.AddLoadPath", github_com_glojurelang_glojure_pkg_runtime.AddLoadPath) _register("github.com/glojurelang/glojure/pkg/runtime.Compiler", github_com_glojurelang_glojure_pkg_runtime.Compiler) _register("github.com/glojurelang/glojure/pkg/runtime.Debug", github_com_glojurelang_glojure_pkg_runtime.Debug) - _register("github.com/glojurelang/glojure/pkg/runtime.EvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.EvalError)(nil)).Elem()) - _register("github.com/glojurelang/glojure/pkg/runtime.*EvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.EvalError)(nil))) _register("github.com/glojurelang/glojure/pkg/runtime.EvalOption", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.EvalOption)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.Fn", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Fn)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.*Fn", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Fn)(nil))) @@ -3978,6 +3979,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/runtime.Program", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Program)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.*Program", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Program)(nil))) _register("github.com/glojurelang/glojure/pkg/runtime.RT", github_com_glojurelang_glojure_pkg_runtime.RT) + _register("github.com/glojurelang/glojure/pkg/runtime.RTEvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTEvalError)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/runtime.*RTEvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTEvalError)(nil))) _register("github.com/glojurelang/glojure/pkg/runtime.RTMethods", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTMethods)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.*RTMethods", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTMethods)(nil))) _register("github.com/glojurelang/glojure/pkg/runtime.RTReadString", github_com_glojurelang_glojure_pkg_runtime.RTReadString) diff --git a/pkg/gen/gljimports/gljimports_linux_arm64.go b/pkg/gen/gljimports/gljimports_linux_arm64.go index 86dbbd62..d8110114 100644 --- a/pkg/gen/gljimports/gljimports_linux_arm64.go +++ b/pkg/gen/gljimports/gljimports_linux_arm64.go @@ -3506,6 +3506,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.ErrNoTransaction", github_com_glojurelang_glojure_pkg_lang.ErrNoTransaction) _register("github.com/glojurelang/glojure/pkg/lang.Error", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Error)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*Error", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Error)(nil))) + _register("github.com/glojurelang/glojure/pkg/lang.EvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.EvalError)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.*EvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.EvalError)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.FieldOrMethod", github_com_glojurelang_glojure_pkg_lang.FieldOrMethod) _register("github.com/glojurelang/glojure/pkg/lang.FindNamespace", github_com_glojurelang_glojure_pkg_lang.FindNamespace) _register("github.com/glojurelang/glojure/pkg/lang.FindOrCreateNamespace", github_com_glojurelang_glojure_pkg_lang.FindOrCreateNamespace) @@ -3789,6 +3791,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewCons", github_com_glojurelang_glojure_pkg_lang.NewCons) _register("github.com/glojurelang/glojure/pkg/lang.NewCycle", github_com_glojurelang_glojure_pkg_lang.NewCycle) _register("github.com/glojurelang/glojure/pkg/lang.NewError", github_com_glojurelang_glojure_pkg_lang.NewError) + _register("github.com/glojurelang/glojure/pkg/lang.NewEvalError", github_com_glojurelang_glojure_pkg_lang.NewEvalError) _register("github.com/glojurelang/glojure/pkg/lang.NewFnFunc", github_com_glojurelang_glojure_pkg_lang.NewFnFunc) _register("github.com/glojurelang/glojure/pkg/lang.NewGoMapSeq", github_com_glojurelang_glojure_pkg_lang.NewGoMapSeq) _register("github.com/glojurelang/glojure/pkg/lang.NewIllegalArgumentError", github_com_glojurelang_glojure_pkg_lang.NewIllegalArgumentError) @@ -3968,8 +3971,6 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/runtime.AddLoadPath", github_com_glojurelang_glojure_pkg_runtime.AddLoadPath) _register("github.com/glojurelang/glojure/pkg/runtime.Compiler", github_com_glojurelang_glojure_pkg_runtime.Compiler) _register("github.com/glojurelang/glojure/pkg/runtime.Debug", github_com_glojurelang_glojure_pkg_runtime.Debug) - _register("github.com/glojurelang/glojure/pkg/runtime.EvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.EvalError)(nil)).Elem()) - _register("github.com/glojurelang/glojure/pkg/runtime.*EvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.EvalError)(nil))) _register("github.com/glojurelang/glojure/pkg/runtime.EvalOption", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.EvalOption)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.Fn", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Fn)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.*Fn", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Fn)(nil))) @@ -3978,6 +3979,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/runtime.Program", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Program)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.*Program", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Program)(nil))) _register("github.com/glojurelang/glojure/pkg/runtime.RT", github_com_glojurelang_glojure_pkg_runtime.RT) + _register("github.com/glojurelang/glojure/pkg/runtime.RTEvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTEvalError)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/runtime.*RTEvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTEvalError)(nil))) _register("github.com/glojurelang/glojure/pkg/runtime.RTMethods", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTMethods)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.*RTMethods", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTMethods)(nil))) _register("github.com/glojurelang/glojure/pkg/runtime.RTReadString", github_com_glojurelang_glojure_pkg_runtime.RTReadString) diff --git a/pkg/gen/gljimports/gljimports_windows_amd64.go b/pkg/gen/gljimports/gljimports_windows_amd64.go index bbafad44..9837a7d7 100644 --- a/pkg/gen/gljimports/gljimports_windows_amd64.go +++ b/pkg/gen/gljimports/gljimports_windows_amd64.go @@ -3506,6 +3506,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.ErrNoTransaction", github_com_glojurelang_glojure_pkg_lang.ErrNoTransaction) _register("github.com/glojurelang/glojure/pkg/lang.Error", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Error)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*Error", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Error)(nil))) + _register("github.com/glojurelang/glojure/pkg/lang.EvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.EvalError)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.*EvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.EvalError)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.FieldOrMethod", github_com_glojurelang_glojure_pkg_lang.FieldOrMethod) _register("github.com/glojurelang/glojure/pkg/lang.FindNamespace", github_com_glojurelang_glojure_pkg_lang.FindNamespace) _register("github.com/glojurelang/glojure/pkg/lang.FindOrCreateNamespace", github_com_glojurelang_glojure_pkg_lang.FindOrCreateNamespace) @@ -3789,6 +3791,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewCons", github_com_glojurelang_glojure_pkg_lang.NewCons) _register("github.com/glojurelang/glojure/pkg/lang.NewCycle", github_com_glojurelang_glojure_pkg_lang.NewCycle) _register("github.com/glojurelang/glojure/pkg/lang.NewError", github_com_glojurelang_glojure_pkg_lang.NewError) + _register("github.com/glojurelang/glojure/pkg/lang.NewEvalError", github_com_glojurelang_glojure_pkg_lang.NewEvalError) _register("github.com/glojurelang/glojure/pkg/lang.NewFnFunc", github_com_glojurelang_glojure_pkg_lang.NewFnFunc) _register("github.com/glojurelang/glojure/pkg/lang.NewGoMapSeq", github_com_glojurelang_glojure_pkg_lang.NewGoMapSeq) _register("github.com/glojurelang/glojure/pkg/lang.NewIllegalArgumentError", github_com_glojurelang_glojure_pkg_lang.NewIllegalArgumentError) @@ -3968,8 +3971,6 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/runtime.AddLoadPath", github_com_glojurelang_glojure_pkg_runtime.AddLoadPath) _register("github.com/glojurelang/glojure/pkg/runtime.Compiler", github_com_glojurelang_glojure_pkg_runtime.Compiler) _register("github.com/glojurelang/glojure/pkg/runtime.Debug", github_com_glojurelang_glojure_pkg_runtime.Debug) - _register("github.com/glojurelang/glojure/pkg/runtime.EvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.EvalError)(nil)).Elem()) - _register("github.com/glojurelang/glojure/pkg/runtime.*EvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.EvalError)(nil))) _register("github.com/glojurelang/glojure/pkg/runtime.EvalOption", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.EvalOption)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.Fn", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Fn)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.*Fn", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Fn)(nil))) @@ -3978,6 +3979,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/runtime.Program", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Program)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.*Program", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Program)(nil))) _register("github.com/glojurelang/glojure/pkg/runtime.RT", github_com_glojurelang_glojure_pkg_runtime.RT) + _register("github.com/glojurelang/glojure/pkg/runtime.RTEvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTEvalError)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/runtime.*RTEvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTEvalError)(nil))) _register("github.com/glojurelang/glojure/pkg/runtime.RTMethods", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTMethods)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.*RTMethods", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTMethods)(nil))) _register("github.com/glojurelang/glojure/pkg/runtime.RTReadString", github_com_glojurelang_glojure_pkg_runtime.RTReadString) diff --git a/pkg/gen/gljimports/gljimports_windows_arm.go b/pkg/gen/gljimports/gljimports_windows_arm.go index b524a0e3..191bf01b 100644 --- a/pkg/gen/gljimports/gljimports_windows_arm.go +++ b/pkg/gen/gljimports/gljimports_windows_arm.go @@ -3506,6 +3506,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.ErrNoTransaction", github_com_glojurelang_glojure_pkg_lang.ErrNoTransaction) _register("github.com/glojurelang/glojure/pkg/lang.Error", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Error)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*Error", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Error)(nil))) + _register("github.com/glojurelang/glojure/pkg/lang.EvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.EvalError)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.*EvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.EvalError)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.FieldOrMethod", github_com_glojurelang_glojure_pkg_lang.FieldOrMethod) _register("github.com/glojurelang/glojure/pkg/lang.FindNamespace", github_com_glojurelang_glojure_pkg_lang.FindNamespace) _register("github.com/glojurelang/glojure/pkg/lang.FindOrCreateNamespace", github_com_glojurelang_glojure_pkg_lang.FindOrCreateNamespace) @@ -3789,6 +3791,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewCons", github_com_glojurelang_glojure_pkg_lang.NewCons) _register("github.com/glojurelang/glojure/pkg/lang.NewCycle", github_com_glojurelang_glojure_pkg_lang.NewCycle) _register("github.com/glojurelang/glojure/pkg/lang.NewError", github_com_glojurelang_glojure_pkg_lang.NewError) + _register("github.com/glojurelang/glojure/pkg/lang.NewEvalError", github_com_glojurelang_glojure_pkg_lang.NewEvalError) _register("github.com/glojurelang/glojure/pkg/lang.NewFnFunc", github_com_glojurelang_glojure_pkg_lang.NewFnFunc) _register("github.com/glojurelang/glojure/pkg/lang.NewGoMapSeq", github_com_glojurelang_glojure_pkg_lang.NewGoMapSeq) _register("github.com/glojurelang/glojure/pkg/lang.NewIllegalArgumentError", github_com_glojurelang_glojure_pkg_lang.NewIllegalArgumentError) @@ -3968,8 +3971,6 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/runtime.AddLoadPath", github_com_glojurelang_glojure_pkg_runtime.AddLoadPath) _register("github.com/glojurelang/glojure/pkg/runtime.Compiler", github_com_glojurelang_glojure_pkg_runtime.Compiler) _register("github.com/glojurelang/glojure/pkg/runtime.Debug", github_com_glojurelang_glojure_pkg_runtime.Debug) - _register("github.com/glojurelang/glojure/pkg/runtime.EvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.EvalError)(nil)).Elem()) - _register("github.com/glojurelang/glojure/pkg/runtime.*EvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.EvalError)(nil))) _register("github.com/glojurelang/glojure/pkg/runtime.EvalOption", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.EvalOption)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.Fn", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Fn)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.*Fn", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Fn)(nil))) @@ -3978,6 +3979,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/runtime.Program", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Program)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.*Program", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Program)(nil))) _register("github.com/glojurelang/glojure/pkg/runtime.RT", github_com_glojurelang_glojure_pkg_runtime.RT) + _register("github.com/glojurelang/glojure/pkg/runtime.RTEvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTEvalError)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/runtime.*RTEvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTEvalError)(nil))) _register("github.com/glojurelang/glojure/pkg/runtime.RTMethods", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTMethods)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.*RTMethods", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTMethods)(nil))) _register("github.com/glojurelang/glojure/pkg/runtime.RTReadString", github_com_glojurelang_glojure_pkg_runtime.RTReadString) diff --git a/pkg/lang/error.go b/pkg/lang/error.go index 46b17178..020fbb33 100644 --- a/pkg/lang/error.go +++ b/pkg/lang/error.go @@ -7,6 +7,10 @@ import ( ) type ( + Error struct { + msg string + } + TimeoutError struct { msg string } @@ -37,8 +41,8 @@ type ( Stack() []StackFrame } - // Error is a value that represents an error. - Error struct { + // EvalError is a value that represents an evaluation error. + EvalError struct { err error stack []StackFrame } @@ -53,6 +57,18 @@ type ( //////////////////////////////////////////////////////////////////////////////// +// NewError creates a new error value. +func NewError(msg string) error { + return &Error{msg: msg} +} + +// Error returns the error message. +func (e *Error) Error() string { + return e.msg +} + +//////////////////////////////////////////////////////////////////////////////// + // NewTimeoutError creates a new timeout error. func NewTimeoutError(msg string) error { return &TimeoutError{msg: msg} @@ -146,16 +162,16 @@ func (e *CompilerError) Error() string { //////////////////////////////////////////////////////////////////////////////// // TODO: Revisit -// NewError creates a new error value. -func NewError(frame StackFrame, err error) *Error { - return &Error{ +// NewEvalError creates a new error value. +func NewEvalError(frame StackFrame, err error) *EvalError { + return &EvalError{ err: err, stack: []StackFrame{frame}, } } // Error returns the error message. -func (e *Error) Error() string { +func (e *EvalError) Error() string { var builder strings.Builder builder.WriteString(e.err.Error()) builder.WriteString("\nStack trace (most recent call first):\n") @@ -177,17 +193,17 @@ func (e *Error) Error() string { } // Stack returns the stack trace. -func (e *Error) Stack() []StackFrame { +func (e *EvalError) Stack() []StackFrame { return e.stack } // AddStack adds a new stack trace entry. -func (e *Error) AddStack(frame StackFrame) error { +func (e *EvalError) AddStack(frame StackFrame) error { e.stack = append(e.stack, frame) return e } // Unwrap returns the underlying error. -func (e *Error) Unwrap() error { +func (e *EvalError) Unwrap() error { return e.err } diff --git a/pkg/runtime/evalast.go b/pkg/runtime/evalast.go index cb7dda40..4cdbecd0 100644 --- a/pkg/runtime/evalast.go +++ b/pkg/runtime/evalast.go @@ -24,13 +24,13 @@ var ( SymInNS = lang.NewSymbol("in-ns") ) -type EvalError struct { +type RTEvalError struct { Err error GLJStack []string GoStack string } -func (e *EvalError) Error() string { +func (e *RTEvalError) Error() string { sb := strings.Builder{} sb.WriteString(e.Err.Error()) sb.WriteString("\n\n") @@ -47,12 +47,12 @@ func (e *EvalError) Error() string { return sb.String() } -func (e *EvalError) Unwrap() error { +func (e *RTEvalError) Unwrap() error { return e.Err } -func (e *EvalError) Is(err error) bool { - _, ok := err.(*EvalError) +func (e *RTEvalError) Is(err error) bool { + _, ok := err.(*RTEvalError) return ok } @@ -609,8 +609,8 @@ func (env *environment) EvalASTInvoke(n *ast.Node) (res interface{}, err error) // recursion; need to use go-only stringification for errors. gljFrame = fmt.Sprintf("%s:%d:%d:\t%s", lang.Get(meta, KWFile), lang.Get(meta, KWLine), lang.Get(meta, KWColumn), n.Form) if rErr, ok := r.(error); ok { - if errors.Is(rErr, &EvalError{}) { - var evalErr *EvalError + if errors.Is(rErr, &RTEvalError{}) { + var evalErr *RTEvalError errors.As(rErr, &evalErr) evalErr.GLJStack = append(evalErr.GLJStack, gljFrame) // TODO: copy if evalErr.GoStack == "" { @@ -618,14 +618,14 @@ func (env *environment) EvalASTInvoke(n *ast.Node) (res interface{}, err error) } err = evalErr } else { - err = &EvalError{ + err = &RTEvalError{ Err: rErr, GLJStack: []string{gljFrame}, GoStack: string(debug.Stack()), } } } else { - err = &EvalError{ + err = &RTEvalError{ Err: fmt.Errorf("%v", r), GLJStack: []string{gljFrame}, GoStack: string(debug.Stack()), @@ -689,7 +689,6 @@ func (env *environment) EvalASTNew(n *ast.Node) (interface{}, error) { return reflect.New(classValTyp).Interface(), nil } - func (env *environment) EvalASTTry(n *ast.Node) (res interface{}, err error) { tryNode := n.Sub.(*ast.TryNode) diff --git a/pkg/runtime/fn.go b/pkg/runtime/fn.go index 9b265735..4ea4e933 100644 --- a/pkg/runtime/fn.go +++ b/pkg/runtime/fn.go @@ -145,9 +145,9 @@ func errorWithStack(err error, stackFrame lang.StackFrame) error { if err == nil { return nil } - valErr, ok := err.(*lang.Error) + valErr, ok := err.(*lang.EvalError) if !ok { - return lang.NewError(stackFrame, err) + return lang.NewEvalError(stackFrame, err) } return valErr.AddStack(stackFrame) } diff --git a/pkg/stdlib/glojure/core.glj b/pkg/stdlib/glojure/core.glj index 40a283cd..3708f6fc 100644 --- a/pkg/stdlib/glojure/core.glj +++ b/pkg/stdlib/glojure/core.glj @@ -1768,7 +1768,7 @@ m) mm-name (with-meta mm-name m)] (when (= (count options) 1) - (throw (Exception. "The syntax for defmulti has changed. Example: (defmulti name dispatch-fn :default dispatch-value)"))) + (throw (github.com$glojurelang$glojure$pkg$lang.NewError "The syntax for defmulti has changed. Example: (defmulti name dispatch-fn :default dispatch-value)"))) (let [options (apply hash-map options) default (get options :default :default) hierarchy (get options :hierarchy #'global-hierarchy)] @@ -4158,7 +4158,7 @@ ^github.com$glojurelang$glojure$pkg$lang.*Namespace [x] (if (instance? github.com$glojurelang$glojure$pkg$lang.*Namespace x) x - (or (find-ns x) (throw (Exception. (str "No namespace: " x " found")))))) + (or (find-ns x) (throw (github.com$glojurelang$glojure$pkg$lang.NewError (str "No namespace: " x " found")))))) (defn ns-name "Returns the name of the namespace, a symbol." @@ -5630,9 +5630,9 @@ (or (when-not (contains? (tp tag) parent) (when (contains? (ta tag) parent) - (throw (Exception. (print-str tag "already has" parent "as ancestor")))) + (throw (github.com$glojurelang$glojure$pkg$lang.NewError (print-str tag "already has" parent "as ancestor")))) (when (contains? (ta parent) tag) - (throw (Exception. (print-str "Cyclic derivation:" parent "has" tag "as ancestor")))) + (throw (github.com$glojurelang$glojure$pkg$lang.NewError (print-str "Cyclic derivation:" parent "has" tag "as ancestor")))) {:parents (assoc (:parents h) tag (conj (get tp tag #{}) parent)) :ancestors (tf (:ancestors h) tag td parent ta) :descendants (tf (:descendants h) parent ta tag td)}) @@ -5689,7 +5689,7 @@ (map (fn [i] (. rsmeta (getColumnLabel i))) idxs)) check-keys (or (apply distinct? keys) - (throw (Exception. "ResultSet must have unique column labels"))) + (throw (github.com$glojurelang$glojure$pkg$lang.NewError "ResultSet must have unique column labels"))) row-struct (apply create-struct keys) row-values (fn [] (map (fn [^Integer i] (. rs (getObject i))) idxs)) rows (fn thisfn [] @@ -5834,7 +5834,7 @@ [pred fmt & args] (when pred (let [^go/string message (apply format fmt args) - exception (Exception. message) + exception (github.com$glojurelang$glojure$pkg$lang.NewError message) raw-trace (.getStackTrace exception) boring? #(not= (.getMethodName ^StackTraceElement %) "doInvoke") trace (into-array StackTraceElement (drop 2 (drop-while boring? raw-trace)))] diff --git a/scripts/rewrite-core/rewrite.clj b/scripts/rewrite-core/rewrite.clj index 9dcc57c6..47544af3 100644 --- a/scripts/rewrite-core/rewrite.clj +++ b/scripts/rewrite-core/rewrite.clj @@ -299,6 +299,8 @@ ;; ===== Exception Handling ===== + (sexpr-replace 'Exception. 'github.com$glojurelang$glojure$pkg$lang.NewError) + (sexpr-replace 'IllegalArgumentException. 'github.com$glojurelang$glojure$pkg$lang.NewIllegalArgumentError) ;; new Exception [(fn select [zloc] (and (z/list? zloc) From 45006e9f34f6896d6579d9a2fa616c25de629bdb Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sat, 23 Aug 2025 15:55:38 -0700 Subject: [PATCH 38/67] Replace Object. in stdlib Signed-off-by: James Hamlin --- pkg/codegen/TODO.txt | 1 - pkg/codegen/testdata/codegen/test/core.go | 681 +++++++++++----------- pkg/stdlib/glojure/core.glj | 4 +- scripts/rewrite-core/rewrite.clj | 7 +- 4 files changed, 360 insertions(+), 333 deletions(-) diff --git a/pkg/codegen/TODO.txt b/pkg/codegen/TODO.txt index a87eed61..463c0025 100644 --- a/pkg/codegen/TODO.txt +++ b/pkg/codegen/TODO.txt @@ -8,7 +8,6 @@ Handle - ExceptionInfo15 "ExceptionInfo" - LinkedBlockingQueue28 "LinkedBlockingQueue" -- Object16 "Object" - glojure.lang.LineNumberingPushbackReader19 "glojure.lang.LineNumberingPushbackReader" - glojure.lang4 "glojure.lang" - java.io.InputStreamReader20 "java.io.InputStreamReader" diff --git a/pkg/codegen/testdata/codegen/test/core.go b/pkg/codegen/testdata/codegen/test/core.go index 53975f43..951f9dc5 100644 --- a/pkg/codegen/testdata/codegen/test/core.go +++ b/pkg/codegen/testdata/codegen/test/core.go @@ -4,29 +4,28 @@ package generated import ( ExceptionInfo11 "ExceptionInfo" - LinkedBlockingQueue23 "LinkedBlockingQueue" - Object12 "Object" + LinkedBlockingQueue22 "LinkedBlockingQueue" big8 "math/big" errors6 "errors" fmt "fmt" - glojure.lang.LineNumberingPushbackReader14 "glojure.lang.LineNumberingPushbackReader" + glojure.lang.LineNumberingPushbackReader13 "glojure.lang.LineNumberingPushbackReader" glojure.lang4 "glojure.lang" - java.io.InputStreamReader15 "java.io.InputStreamReader" - java.io.StringReader16 "java.io.StringReader" + java.io.InputStreamReader14 "java.io.InputStreamReader" + java.io.StringReader15 "java.io.StringReader" java.lang.UnsupportedOperationException10 "java.lang.UnsupportedOperationException" - java.net24 "java.net" - java.util.concurrent.CountDownLatch20 "java.util.concurrent.CountDownLatch" + java.net23 "java.net" + java.util.concurrent.CountDownLatch19 "java.util.concurrent.CountDownLatch" java.util.concurrent7 "java.util.concurrent" - java.util17 "java.util" + java.util16 "java.util" lang "github.com/glojurelang/glojure/pkg/lang" math3 "math" - rand21 "math/rand" + rand20 "math/rand" reflect "reflect" - regexp22 "regexp" - runtime19 "runtime" + regexp21 "regexp" + runtime18 "runtime" runtime5 "github.com/glojurelang/glojure/pkg/runtime" - strconv18 "strconv" - strings13 "strings" + strconv17 "strconv" + strings12 "strings" time9 "time" ) func init() { @@ -37904,74 +37903,86 @@ return v11 v3 := args[0] v4 := args[1] v5 := args[2] -v7 := lang.Apply(Object12., nil) -var v6 any = v7 +v7 := lang.Apply(reflect.StructOf, []any{nil}) +v8 := lang.Apply(reflect.New, []any{v7}) +v9, ok := lang.FieldOrMethod(v8, "Interface") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "Interface"))) +} +var v10 any +switch reflect.TypeOf(v9).Kind() { +case reflect.Func: + v10 = lang.Apply(v9, nil) +default: + v10 = v9 +} +var v6 any = v10 _ = v6 -var v8 any = v8 -_ = v8 -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("seq")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) +var v11 any = v11 +_ = v11 +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("seq")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) } -v12 := v11.Get() -v13 := lang.Apply(v12, []any{v9}) -var v9 any = v13 -_ = v9 -var v14 any +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v12}) +var v12 any = v16 +_ = v12 +var v17 any for { -var v15 any -if lang.IsTruthy(v9) { -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("get")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() +var v18 any +if lang.IsTruthy(v12) { v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("first")) +v21 := v20.FindInternedVar(lang.NewSymbol("get")) if v21.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) } v22 := v21.Get() -v23 := lang.Apply(v22, []any{v9}) -v24 := lang.Apply(v19, []any{v16, v23, v6}) -var v16 any = v24 -_ = v16 -var v26 any -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("identical?")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) +v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v24 := v23.FindInternedVar(lang.NewSymbol("first")) +if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) } -v29 := v28.Get() -v30 := lang.Apply(v29, []any{v6, v16}) -if lang.IsTruthy(v30) { -v26 = v5 +v25 := v24.Get() +v26 := lang.Apply(v25, []any{v12}) +v27 := lang.Apply(v22, []any{v19, v26, v6}) +var v19 any = v27 +_ = v19 +var v29 any +v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v31 := v30.FindInternedVar(lang.NewSymbol("identical?")) +if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) +} +v32 := v31.Get() +v33 := lang.Apply(v32, []any{v6, v19}) +if lang.IsTruthy(v33) { +v29 = v5 } else { -var v31 any = v6 -var v32 any = v16 -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("next")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +var v34 any = v6 +var v35 any = v19 +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("next")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -v36 := v35.Get() -v37 := lang.Apply(v36, []any{v9}) -var v33 any = v37 -v6 = v31 -v8 = v32 -v9 = v33 +v39 := v38.Get() +v40 := lang.Apply(v39, []any{v12}) +var v36 any = v40 +v6 = v34 +v11 = v35 +v12 = v36 continue } -v15 = v26 +v18 = v29 } else { -v15 = v8 +v18 = v11 } -v14 = v15 +v17 = v18 break } -return v14 +return v17 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -44206,7 +44217,7 @@ v20 := lang.Apply(v19, []any{v11}) var v18 any = v20 _ = v18 var v23 any -v24 := lang.Apply(strings13.HasPrefix, []any{v22, "/"}) +v24 := lang.Apply(strings12.HasPrefix, []any{v22, "/"}) if lang.IsTruthy(v24) { v23 = v22 } else { @@ -44341,7 +44352,7 @@ if v88.IsMacro() { v89 := v88.Get() v90 := lang.Apply(v89, nil) }() -v91 := lang.Apply(strings13.TrimPrefix, []any{v22, "/"}) +v91 := lang.Apply(strings12.TrimPrefix, []any{v22, "/"}) v92, _ := lang.FieldOrMethod(runtime5.RT, "Load") if reflect.TypeOf(v92).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Load is not a function"))) @@ -44448,7 +44459,7 @@ v36 := lang.Apply(v35, []any{v25}) var v32 any = v36 _ = v32 var v39 any -v40 := lang.Apply(strings13.HasPrefix, []any{v38, "/"}) +v40 := lang.Apply(strings12.HasPrefix, []any{v38, "/"}) if lang.IsTruthy(v40) { v39 = v38 } else { @@ -44583,7 +44594,7 @@ if v104.IsMacro() { v105 := v104.Get() v106 := lang.Apply(v105, nil) }() -v107 := lang.Apply(strings13.TrimPrefix, []any{v38, "/"}) +v107 := lang.Apply(strings12.TrimPrefix, []any{v38, "/"}) v108, _ := lang.FieldOrMethod(runtime5.RT, "Load") if reflect.TypeOf(v108).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Load is not a function"))) @@ -44785,8 +44796,8 @@ case reflect.Func: default: v7 = v6 } -v8 := lang.Apply(java.io.InputStreamReader15., []any{v7, "UTF-8"}) -v9 := lang.Apply(glojure.lang.LineNumberingPushbackReader14., []any{v8}) +v8 := lang.Apply(java.io.InputStreamReader14., []any{v7, "UTF-8"}) +v9 := lang.Apply(glojure.lang.LineNumberingPushbackReader13., []any{v8}) var v5 any = v9 _ = v5 var v11 any @@ -45189,7 +45200,7 @@ if v20.IsMacro() { } v21 := v20.Get() v22 := lang.Apply(v21, []any{lang.NewChar(46)}) -v23 := lang.Apply(strings13.Index, []any{v18, v22}) +v23 := lang.Apply(strings12.Index, []any{v18, v22}) v24 := lang.Apply(v14, []any{v23}) v11 = v24 } else { @@ -47015,8 +47026,8 @@ v2 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v5 := lang.Apply(java.io.StringReader16., []any{v3}) -v6 := lang.Apply(glojure.lang.LineNumberingPushbackReader14., []any{v5}) +v5 := lang.Apply(java.io.StringReader15., []any{v3}) +v6 := lang.Apply(glojure.lang.LineNumberingPushbackReader13., []any{v5}) var v4 any = v6 _ = v4 v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) @@ -48990,7 +49001,7 @@ if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -v7 := lang.Apply(v6, []any{java.util17.Map$Entry, v3}) +v7 := lang.Apply(v6, []any{java.util16.Map$Entry, v3}) return v7 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -56220,7 +56231,7 @@ if v6.IsMacro() { v7 := v6.Get() v8 := lang.Apply(v7, []any{v3}) if lang.IsTruthy(v8) { -v10 := lang.Apply(strconv18.ParseFloat, []any{v3, int64(64)}) +v10 := lang.Apply(strconv17.ParseFloat, []any{v3, int64(64)}) var v9 any = v10 _ = v9 var v12 any @@ -56372,7 +56383,7 @@ if v6.IsMacro() { v7 := v6.Get() v8 := lang.Apply(v7, []any{v3}) if lang.IsTruthy(v8) { -v10 := lang.Apply(strconv18.ParseInt, []any{v3, int64(10), int64(64)}) +v10 := lang.Apply(strconv17.ParseInt, []any{v3, int64(10), int64(64)}) var v9 any = v10 _ = v9 var v12 any @@ -58001,7 +58012,7 @@ if v7.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } v8 := v7.Get() -v9 := lang.Apply(runtime19.NumCPU, nil) +v9 := lang.Apply(runtime18.NumCPU, nil) v10 := lang.Apply(v8, []any{int64(2), v9}) var v5 any = v10 _ = v5 @@ -61432,7 +61443,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v4 := lang.Apply(java.util.concurrent.CountDownLatch20., []any{int64(1)}) +v4 := lang.Apply(java.util.concurrent.CountDownLatch19., []any{int64(1)}) var v3 any = v4 _ = v3 v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) @@ -62012,7 +62023,7 @@ var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: -v3 := lang.Apply(rand21.Float64, nil) +v3 := lang.Apply(rand20.Float64, nil) return v3 case 1: v3 := args[0] @@ -62669,7 +62680,7 @@ if v0.Meta() != nil { } // re-pattern { -v1 := reflect.TypeOf((*regexp22.Regexp)(nil)) +v1 := reflect.TypeOf((*regexp21.Regexp)(nil)) v0 := lang.NewSymbol("re-pattern").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns an instance of java.util.regex.Pattern, for use, e.g. in\n re-matcher.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4863), lang.NewKeyword("end-line"), int(4863))).(*lang.Symbol) var v3 lang.FnFunc v3 = lang.NewFnFunc(func(args ...any) any { @@ -62684,16 +62695,16 @@ if v7.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } v8 := v7.Get() -v9 := lang.Apply(v8, []any{regexp22.*Regexp, v4}) +v9 := lang.Apply(v8, []any{regexp21.*Regexp, v4}) if lang.IsTruthy(v9) { v5 = v4 } else { -v10 := lang.Apply(regexp22.MustCompile, []any{v4}) +v10 := lang.Apply(regexp21.MustCompile, []any{v4}) v5 = v10 } return v5 }) -v4 := reflect.TypeOf((*regexp22.Regexp)(nil)) +v4 := reflect.TypeOf((*regexp21.Regexp)(nil)) v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { @@ -65666,7 +65677,7 @@ if v11.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } v12 := v11.Get() -v13 := lang.Apply(strings13.LastIndex, []any{v4, "/"}) +v13 := lang.Apply(strings12.LastIndex, []any{v4, "/"}) v14 := lang.Apply(v12, []any{v4, int64(0), v13}) return v14 }) @@ -65699,8 +65710,8 @@ if v9.IsMacro() { } v10 := v9.Get() v11 := lang.Apply(v10, []any{v4}) -v12 := lang.Apply(strings13.ReplaceAll, []any{v11, "-", "_"}) -v13 := lang.Apply(strings13.ReplaceAll, []any{v12, ".", "/"}) +v12 := lang.Apply(strings12.ReplaceAll, []any{v11, "-", "_"}) +v13 := lang.Apply(strings12.ReplaceAll, []any{v12, ".", "/"}) v14 := lang.Apply(v7, []any{lang.NewChar(47), v13}) return v14 }) @@ -66380,345 +66391,357 @@ if v12.IsMacro() { } v13 := v12.Get() v14 := lang.Apply(v13, []any{v3}) -v15 := lang.Apply(LinkedBlockingQueue23., []any{v14}) +v15 := lang.Apply(LinkedBlockingQueue22., []any{v14}) v6 = v15 } var v5 any = v6 _ = v5 -v17 := lang.Apply(Object12., nil) -var v16 any = v17 +v17 := lang.Apply(reflect.StructOf, []any{nil}) +v18 := lang.Apply(reflect.New, []any{v17}) +v19, ok := lang.FieldOrMethod(v18, "Interface") +if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v18, "Interface"))) +} +var v20 any +switch reflect.TypeOf(v19).Kind() { +case reflect.Func: + v20 = lang.Apply(v19, nil) +default: + v20 = v19 +} +var v16 any = v20 _ = v16 -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("agent")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v23 := v22.FindInternedVar(lang.NewSymbol("agent")) +if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) } -v21 := v20.Get() -var v22 lang.FnFunc -v22 = lang.NewFnFunc(func(args ...any) any { +v24 := v23.Get() +var v25 lang.FnFunc +v25 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } return v4 }) -v23 := lang.Apply(lang.NewLazySeq, []any{v22}) -v24 := lang.Apply(v21, []any{v23}) -var v18 any = v24 -_ = v18 -var v26 lang.FnFunc -v26 = lang.NewFnFunc(func(args ...any) any { +v26 := lang.Apply(lang.NewLazySeq, []any{v25}) +v27 := lang.Apply(v24, []any{v26}) +var v21 any = v27 +_ = v21 +var v29 lang.FnFunc +v29 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v27 := args[0] -v28 := args[1] -var v29 any -v30, _ := lang.FieldOrMethod(v27, "offer") -if reflect.TypeOf(v30).Kind() != reflect.Func { +v30 := args[0] +v31 := args[1] +var v32 any +v33, _ := lang.FieldOrMethod(v30, "offer") +if reflect.TypeOf(v33).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("offer is not a function"))) } -v31 := lang.Apply(v30, []any{v27}) -if lang.IsTruthy(v31) { -panic(v28) +v34 := lang.Apply(v33, []any{v30}) +if lang.IsTruthy(v34) { +panic(v31) } else { -v29 = v28 +v32 = v31 } -return v29 +return v32 }) -v27 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5435), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(5438), lang.NewKeyword("end-column"), int(26)) -v28, err := lang.WithMeta(v26, v27.(lang.IPersistentMap)) +v30 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5435), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(5438), lang.NewKeyword("end-column"), int(26)) +v31, err := lang.WithMeta(v29, v30.(lang.IPersistentMap)) if err != nil { panic(err) } -var v25 any = v28 -_ = v25 -var v30 lang.FnFunc -v30 = lang.NewFnFunc(func(args ...any) any { +var v28 any = v31 +_ = v28 +var v33 lang.FnFunc +v33 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v31 := args[0] -var v32 any -if lang.IsTruthy(v31) { -var v33 any -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("instance?")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) +v34 := args[0] +var v35 any +if lang.IsTruthy(v34) { +var v36 any +v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v38 := v37.FindInternedVar(lang.NewSymbol("instance?")) +if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) } -v36 := v35.Get() -v37 := lang.Apply(v36, []any{nil, v31}) -if lang.IsTruthy(v37) { -v38 := lang.Apply(v25, []any{v5, v31}) -v33 = v38 +v39 := v38.Get() +v40 := lang.Apply(v39, []any{nil, v34}) +if lang.IsTruthy(v40) { +v41 := lang.Apply(v28, []any{v5, v34}) +v36 = v41 } else { -var v39 any +var v42 any func() { defer func() { if r := recover(); r != nil { if lang.CatchMatches(r, lang.Builtins["any"]) { -v40 := r -_ = v40 -v41 := lang.Apply(v25, []any{v5, v40}) -v39 = v41 +v43 := r +_ = v43 +v44 := lang.Apply(v28, []any{v5, v43}) +v42 = v44 } else { panic(r) } } }() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("seq")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) +v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v45 := v44.FindInternedVar(lang.NewSymbol("seq")) +if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) } -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v31}) -var v40 any = v44 -_ = v40 -var v45 any = v40 -_ = v45 -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("seq")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) +v46 := v45.Get() +v47 := lang.Apply(v46, []any{v34}) +var v43 any = v47 +_ = v43 +var v48 any = v43 +_ = v48 +v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v51 := v50.FindInternedVar(lang.NewSymbol("seq")) +if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) } -v49 := v48.Get() -v50 := lang.Apply(v49, []any{v45}) -var v46 any = v50 -_ = v46 -v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("first")) -if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) +v52 := v51.Get() +v53 := lang.Apply(v52, []any{v48}) +var v49 any = v53 +_ = v49 +v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v56 := v55.FindInternedVar(lang.NewSymbol("first")) +if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) } -v54 := v53.Get() -v55 := lang.Apply(v54, []any{v46}) -var v51 any = v55 -_ = v51 -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("next")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) +v57 := v56.Get() +v58 := lang.Apply(v57, []any{v49}) +var v54 any = v58 +_ = v54 +v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v61 := v60.FindInternedVar(lang.NewSymbol("next")) +if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) } -v59 := v58.Get() -v60 := lang.Apply(v59, []any{v56}) -var v56 any = v60 -_ = v56 -var v61 any = v51 -_ = v61 -var v62 any = v56 -_ = v62 -var v63 any = v45 -_ = v63 -var v65 any = v65 +v62 := v61.Get() +v63 := lang.Apply(v62, []any{v59}) +var v59 any = v63 +_ = v59 +var v64 any = v54 +_ = v64 +var v65 any = v59 _ = v65 -var v66 any +var v66 any = v48 +_ = v66 +var v68 any = v68 +_ = v68 +var v69 any for { -var v67 any = v65 -_ = v67 -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("seq")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) +var v70 any = v68 +_ = v70 +v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v73 := v72.FindInternedVar(lang.NewSymbol("seq")) +if v73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) } -v71 := v70.Get() -v72 := lang.Apply(v71, []any{v67}) -var v68 any = v72 -_ = v68 -v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v75 := v74.FindInternedVar(lang.NewSymbol("first")) -if v75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) +v74 := v73.Get() +v75 := lang.Apply(v74, []any{v70}) +var v71 any = v75 +_ = v71 +v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v78 := v77.FindInternedVar(lang.NewSymbol("first")) +if v78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) } -v76 := v75.Get() -v77 := lang.Apply(v76, []any{v68}) -var v73 any = v77 -_ = v73 -v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v80 := v79.FindInternedVar(lang.NewSymbol("next")) -if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) +v79 := v78.Get() +v80 := lang.Apply(v79, []any{v71}) +var v76 any = v80 +_ = v76 +v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v83 := v82.FindInternedVar(lang.NewSymbol("next")) +if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) } -v81 := v80.Get() -v82 := lang.Apply(v81, []any{v78}) -var v78 any = v82 -_ = v78 -var v83 any = v73 -_ = v83 -var v84 any = v78 -_ = v84 -var v85 any = v67 -_ = v85 -var v87 any -if lang.IsTruthy(v85) { -var v88 any -var v89 any -v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v91 := v90.FindInternedVar(lang.NewSymbol("nil?")) -if v91.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) +v84 := v83.Get() +v85 := lang.Apply(v84, []any{v81}) +var v81 any = v85 +_ = v81 +var v86 any = v76 +_ = v86 +var v87 any = v81 +_ = v87 +var v88 any = v70 +_ = v88 +var v90 any +if lang.IsTruthy(v88) { +var v91 any +var v92 any +v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v94 := v93.FindInternedVar(lang.NewSymbol("nil?")) +if v94.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) } -v92 := v91.Get() -v93 := lang.Apply(v92, []any{v83}) -if lang.IsTruthy(v93) { -v89 = v16 +v95 := v94.Get() +v96 := lang.Apply(v95, []any{v86}) +if lang.IsTruthy(v96) { +v92 = v16 } else { -v89 = v83 +v92 = v86 } -v94, _ := lang.FieldOrMethod(v5, "offer") -if reflect.TypeOf(v94).Kind() != reflect.Func { +v97, _ := lang.FieldOrMethod(v5, "offer") +if reflect.TypeOf(v97).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("offer is not a function"))) } -v95 := lang.Apply(v94, []any{v89}) -if lang.IsTruthy(v95) { -var v96 any = v84 -v65 = v96 +v98 := lang.Apply(v97, []any{v92}) +if lang.IsTruthy(v98) { +var v99 any = v87 +v68 = v99 continue } else { -v88 = v85 +v91 = v88 } -v87 = v88 +v90 = v91 } else { -var v97 any -v98, _ := lang.FieldOrMethod(v5, "offer") -if reflect.TypeOf(v98).Kind() != reflect.Func { +var v100 any +v101, _ := lang.FieldOrMethod(v5, "offer") +if reflect.TypeOf(v101).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("offer is not a function"))) } -v99 := lang.Apply(v98, []any{v5}) -if lang.IsTruthy(v99) { -v97 = nil +v102 := lang.Apply(v101, []any{v5}) +if lang.IsTruthy(v102) { +v100 = nil } else { -v97 = lang.NewList() +v100 = lang.NewList() } -v87 = v97 +v90 = v100 } -v66 = v87 +v69 = v90 break } -v39 = v66 +v42 = v69 }() -v33 = v39 +v36 = v42 } -v32 = v33 +v35 = v36 } else { -v32 = nil +v35 = nil } -return v32 +return v35 }) -v31 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5439), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(5452), lang.NewKeyword("end-column"), int(44)) -v32, err := lang.WithMeta(v30, v31.(lang.IPersistentMap)) +v34 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5439), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(5452), lang.NewKeyword("end-column"), int(44)) +v35, err := lang.WithMeta(v33, v34.(lang.IPersistentMap)) if err != nil { panic(err) } -var v29 any = v32 -_ = v29 -var v34 lang.FnFunc +var v32 any = v35 +_ = v32 +var v37 lang.FnFunc { // function drain -v34 = lang.NewFnFunc(func(args ...any) any { +v37 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -var v36 lang.FnFunc -v36 = lang.NewFnFunc(func(args ...any) any { +var v39 lang.FnFunc +v39 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v38, ok := lang.FieldOrMethod(v5, "take") +v41, ok := lang.FieldOrMethod(v5, "take") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "take"))) } -var v39 any -switch reflect.TypeOf(v38).Kind() { +var v42 any +switch reflect.TypeOf(v41).Kind() { case reflect.Func: - v39 = lang.Apply(v38, nil) + v42 = lang.Apply(v41, nil) default: - v39 = v38 + v42 = v41 } -var v37 any = v39 -_ = v37 -var v41 any -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("identical?")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) +var v40 any = v42 +_ = v40 +var v44 any +v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v46 := v45.FindInternedVar(lang.NewSymbol("identical?")) +if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) } -v44 := v43.Get() -v45 := lang.Apply(v44, []any{v37, v5}) -if lang.IsTruthy(v45) { -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("deref")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) +v47 := v46.Get() +v48 := lang.Apply(v47, []any{v40, v5}) +if lang.IsTruthy(v48) { +v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v50 := v49.FindInternedVar(lang.NewSymbol("deref")) +if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) } -v48 := v47.Get() -v49 := lang.Apply(v48, []any{v18}) -_ = v49 -v41 = nil +v51 := v50.Get() +v52 := lang.Apply(v51, []any{v21}) +_ = v52 +v44 = nil } else { -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("send-off")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) +v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v54 := v53.FindInternedVar(lang.NewSymbol("send-off")) +if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) } -v52 := v51.Get() -v53 := lang.Apply(v52, []any{v18, v29}) -_ = v53 -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("release-pending-sends")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) +v55 := v54.Get() +v56 := lang.Apply(v55, []any{v21, v32}) +_ = v56 +v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v58 := v57.FindInternedVar(lang.NewSymbol("release-pending-sends")) +if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) } -v56 := v55.Get() -v57 := lang.Apply(v56, nil) -_ = v57 -v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v59 := v58.FindInternedVar(lang.NewSymbol("cons")) -if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) +v59 := v58.Get() +v60 := lang.Apply(v59, nil) +_ = v60 +v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v62 := v61.FindInternedVar(lang.NewSymbol("cons")) +if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) } -v60 := v59.Get() -var v61 any -v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v63 := v62.FindInternedVar(lang.NewSymbol("identical?")) -if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) +v63 := v62.Get() +var v64 any +v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v66 := v65.FindInternedVar(lang.NewSymbol("identical?")) +if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) } -v64 := v63.Get() -v65 := lang.Apply(v64, []any{v37, v16}) -if lang.IsTruthy(v65) { -v61 = nil +v67 := v66.Get() +v68 := lang.Apply(v67, []any{v40, v16}) +if lang.IsTruthy(v68) { +v64 = nil } else { -v61 = v37 +v64 = v40 } -v66 := lang.Apply(v35, nil) -v67 := lang.Apply(v60, []any{v61, v66}) -v41 = v67 +v69 := lang.Apply(v38, nil) +v70 := lang.Apply(v63, []any{v64, v69}) +v44 = v70 } -return v41 +return v44 }) -v37 := lang.Apply(lang.NewLazySeq, []any{v36}) -return v37 +v40 := lang.Apply(lang.NewLazySeq, []any{v39}) +return v40 }) -v35 := v34 -_ = v35 +v38 := v37 +_ = v38 } -v35 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5453), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(5461), lang.NewKeyword("end-column"), int(73)) -v36, err := lang.WithMeta(v34, v35.(lang.IPersistentMap)) +v38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5453), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(5461), lang.NewKeyword("end-column"), int(73)) +v39, err := lang.WithMeta(v37, v38.(lang.IPersistentMap)) if err != nil { panic(err) } -var v33 any = v36 -_ = v33 -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("send-off")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) +var v36 any = v39 +_ = v36 +v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v42 := v41.FindInternedVar(lang.NewSymbol("send-off")) +if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) } -v40 := v39.Get() -v41 := lang.Apply(v40, []any{v18, v29}) -_ = v41 -v42 := lang.Apply(v33, nil) -return v42 +v43 := v42.Get() +v44 := lang.Apply(v43, []any{v21, v32}) +_ = v44 +v45 := lang.Apply(v36, nil) +return v45 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -67788,7 +67811,7 @@ case reflect.Func: default: v30 = v29 } -v31 := lang.Apply(strings13.Index, []any{v30, "."}) +v31 := lang.Apply(strings12.Index, []any{v30, "."}) v32 := lang.Apply(lang.Equiv, []any{v31, int64(-1)}) if lang.IsTruthy(v32) { var v33 any @@ -75929,7 +75952,7 @@ if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -v7 := lang.Apply(v6, []any{java.net24.URI, v3}) +v7 := lang.Apply(v6, []any{java.net23.URI, v3}) return v7 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -75986,7 +76009,7 @@ if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -v7 := lang.Apply(v6, []any{java.util17.UUID, v3}) +v7 := lang.Apply(v6, []any{java.util16.UUID, v3}) return v7 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) diff --git a/pkg/stdlib/glojure/core.glj b/pkg/stdlib/glojure/core.glj index 3708f6fc..2efc5a3b 100644 --- a/pkg/stdlib/glojure/core.glj +++ b/pkg/stdlib/glojure/core.glj @@ -5430,7 +5430,7 @@ (let [^BlockingQueue q (if (instance? BlockingQueue n-or-q) n-or-q (LinkedBlockingQueue. (int n-or-q))) - NIL (Object.) ;nil sentinel since LBQ doesn't support nils + NIL (-> nil reflect.StructOf reflect.New .Interface) ;nil sentinel since LBQ doesn't support nils agt (agent (lazy-seq s)) ; never start with nil; that signifies we've already put eos log-error (fn [q e] (if (.offer q q) @@ -6134,7 +6134,7 @@ fails, attempts to require sym's namespace and retries." ([m ks] (reduce1 get m ks)) ([m ks not-found] - (loop [sentinel (Object.) + (loop [sentinel (-> nil reflect.StructOf reflect.New .Interface) m m ks (seq ks)] (if ks diff --git a/scripts/rewrite-core/rewrite.clj b/scripts/rewrite-core/rewrite.clj index 47544af3..d6f5a5af 100644 --- a/scripts/rewrite-core/rewrite.clj +++ b/scripts/rewrite-core/rewrite.clj @@ -217,6 +217,11 @@ (sexpr-replace '(java.util.ArrayList. coll) '(github.com$glojurelang$glojure$pkg$lang.NewArrayList (to-array coll))) (sexpr-replace '(java.util.ArrayList.) '(new github.com$glojurelang$glojure$pkg$lang.ArrayList)) + ;; ===== Other Constructors ===== + + (sexpr-replace '(Object.) + '(-> nil reflect.StructOf reflect.New .Interface)) + ;; ===== Java Type Mappings ===== ;; map a bunch of java types to go equivalent ;; TODO: once everything passes, see if we can replace with a blanket @@ -393,7 +398,7 @@ '(. github.com$glojurelang$glojure$pkg$runtime.RT (FindVar sym))) (sexpr-replace '(. x (get)) '(. x (Get))) - (sexpr-replace '(. x (set val)) '(. x (Set val))) + (sexpr-replace '(. x (set val)) '(. x (Set val))) ;; ===== Omissions and Deferrals ===== (omitp #(and (z/list? %) From 270be6947708545cb6d74ec5746cefddee584051 Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sat, 23 Aug 2025 16:11:59 -0700 Subject: [PATCH 39/67] Fix MapEntry Signed-off-by: James Hamlin --- pkg/codegen/testdata/codegen/test/core.go | 42 +++++++++++------------ pkg/stdlib/glojure/core.glj | 6 ++-- scripts/rewrite-core/rewrite.clj | 3 ++ 3 files changed, 27 insertions(+), 24 deletions(-) diff --git a/pkg/codegen/testdata/codegen/test/core.go b/pkg/codegen/testdata/codegen/test/core.go index 951f9dc5..61677ce0 100644 --- a/pkg/codegen/testdata/codegen/test/core.go +++ b/pkg/codegen/testdata/codegen/test/core.go @@ -4,7 +4,7 @@ package generated import ( ExceptionInfo11 "ExceptionInfo" - LinkedBlockingQueue22 "LinkedBlockingQueue" + LinkedBlockingQueue21 "LinkedBlockingQueue" big8 "math/big" errors6 "errors" fmt "fmt" @@ -13,18 +13,18 @@ import ( java.io.InputStreamReader14 "java.io.InputStreamReader" java.io.StringReader15 "java.io.StringReader" java.lang.UnsupportedOperationException10 "java.lang.UnsupportedOperationException" - java.net23 "java.net" - java.util.concurrent.CountDownLatch19 "java.util.concurrent.CountDownLatch" + java.net22 "java.net" + java.util.concurrent.CountDownLatch18 "java.util.concurrent.CountDownLatch" java.util.concurrent7 "java.util.concurrent" - java.util16 "java.util" + java.util23 "java.util" lang "github.com/glojurelang/glojure/pkg/lang" math3 "math" - rand20 "math/rand" + rand19 "math/rand" reflect "reflect" - regexp21 "regexp" - runtime18 "runtime" + regexp20 "regexp" + runtime17 "runtime" runtime5 "github.com/glojurelang/glojure/pkg/runtime" - strconv17 "strconv" + strconv16 "strconv" strings12 "strings" time9 "time" ) @@ -49001,7 +49001,7 @@ if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -v7 := lang.Apply(v6, []any{java.util16.Map$Entry, v3}) +v7 := lang.Apply(v6, []any{lang.MapEntry, v3}) return v7 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -56231,7 +56231,7 @@ if v6.IsMacro() { v7 := v6.Get() v8 := lang.Apply(v7, []any{v3}) if lang.IsTruthy(v8) { -v10 := lang.Apply(strconv17.ParseFloat, []any{v3, int64(64)}) +v10 := lang.Apply(strconv16.ParseFloat, []any{v3, int64(64)}) var v9 any = v10 _ = v9 var v12 any @@ -56383,7 +56383,7 @@ if v6.IsMacro() { v7 := v6.Get() v8 := lang.Apply(v7, []any{v3}) if lang.IsTruthy(v8) { -v10 := lang.Apply(strconv17.ParseInt, []any{v3, int64(10), int64(64)}) +v10 := lang.Apply(strconv16.ParseInt, []any{v3, int64(10), int64(64)}) var v9 any = v10 _ = v9 var v12 any @@ -58012,7 +58012,7 @@ if v7.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } v8 := v7.Get() -v9 := lang.Apply(runtime18.NumCPU, nil) +v9 := lang.Apply(runtime17.NumCPU, nil) v10 := lang.Apply(v8, []any{int64(2), v9}) var v5 any = v10 _ = v5 @@ -61443,7 +61443,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v4 := lang.Apply(java.util.concurrent.CountDownLatch19., []any{int64(1)}) +v4 := lang.Apply(java.util.concurrent.CountDownLatch18., []any{int64(1)}) var v3 any = v4 _ = v3 v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) @@ -62023,7 +62023,7 @@ var v2 lang.FnFunc v2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: -v3 := lang.Apply(rand20.Float64, nil) +v3 := lang.Apply(rand19.Float64, nil) return v3 case 1: v3 := args[0] @@ -62680,7 +62680,7 @@ if v0.Meta() != nil { } // re-pattern { -v1 := reflect.TypeOf((*regexp21.Regexp)(nil)) +v1 := reflect.TypeOf((*regexp20.Regexp)(nil)) v0 := lang.NewSymbol("re-pattern").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns an instance of java.util.regex.Pattern, for use, e.g. in\n re-matcher.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4863), lang.NewKeyword("end-line"), int(4863))).(*lang.Symbol) var v3 lang.FnFunc v3 = lang.NewFnFunc(func(args ...any) any { @@ -62695,16 +62695,16 @@ if v7.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } v8 := v7.Get() -v9 := lang.Apply(v8, []any{regexp21.*Regexp, v4}) +v9 := lang.Apply(v8, []any{regexp20.*Regexp, v4}) if lang.IsTruthy(v9) { v5 = v4 } else { -v10 := lang.Apply(regexp21.MustCompile, []any{v4}) +v10 := lang.Apply(regexp20.MustCompile, []any{v4}) v5 = v10 } return v5 }) -v4 := reflect.TypeOf((*regexp21.Regexp)(nil)) +v4 := reflect.TypeOf((*regexp20.Regexp)(nil)) v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { @@ -66391,7 +66391,7 @@ if v12.IsMacro() { } v13 := v12.Get() v14 := lang.Apply(v13, []any{v3}) -v15 := lang.Apply(LinkedBlockingQueue22., []any{v14}) +v15 := lang.Apply(LinkedBlockingQueue21., []any{v14}) v6 = v15 } var v5 any = v6 @@ -75952,7 +75952,7 @@ if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -v7 := lang.Apply(v6, []any{java.net23.URI, v3}) +v7 := lang.Apply(v6, []any{java.net22.URI, v3}) return v7 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -76009,7 +76009,7 @@ if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -v7 := lang.Apply(v6, []any{java.util16.UUID, v3}) +v7 := lang.Apply(v6, []any{java.util23.UUID, v3}) return v7 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) diff --git a/pkg/stdlib/glojure/core.glj b/pkg/stdlib/glojure/core.glj index 2efc5a3b..9ff53c8e 100644 --- a/pkg/stdlib/glojure/core.glj +++ b/pkg/stdlib/glojure/core.glj @@ -1474,7 +1474,7 @@ "Return true if x is a map entry" {:added "1.8"} [x] - (instance? java.util.Map$Entry x)) + (instance? github.com$glojurelang$glojure$pkg$lang.MapEntry x)) (defn contains? "Returns true if key is present in the given collection, otherwise @@ -1564,14 +1564,14 @@ "Returns the key of the map entry." {:added "1.0" :static true} - [^java.util.Map$Entry e] + [^github.com$glojurelang$glojure$pkg$lang.MapEntry e] (. e (GetKey))) (defn val "Returns the value in the map entry." {:added "1.0" :static true} - [^java.util.Map$Entry e] + [^github.com$glojurelang$glojure$pkg$lang.MapEntry e] (. e (GetValue))) (defn rseq diff --git a/scripts/rewrite-core/rewrite.clj b/scripts/rewrite-core/rewrite.clj index d6f5a5af..807a166e 100644 --- a/scripts/rewrite-core/rewrite.clj +++ b/scripts/rewrite-core/rewrite.clj @@ -274,6 +274,9 @@ (sexpr-replace 'clojure.lang.PersistentArrayMap/createAsIfByAssoc 'github.com$glojurelang$glojure$pkg$lang.NewPersistentArrayMapAsIfByAssoc) + + (sexpr-replace 'java.util.Map$Entry 'github.com$glojurelang$glojure$pkg$lang.MapEntry) + ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; struct map (sexpr-replace '(. clojure.lang.PersistentStructMap (createSlotMap keys)) From d1e28b707214dbdc6d183188a607e050245faab2 Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sat, 23 Aug 2025 17:58:37 -0700 Subject: [PATCH 40/67] Add UUID, more Signed-off-by: James Hamlin --- cmd/gen-import-interop/main.go | 1 + go.mod | 1 + go.sum | 2 + pkg/codegen/TODO.txt | 3 - pkg/codegen/testdata/codegen/test/core.go | 114 ++++++++++++------ pkg/gen/gljimports/gljimports_darwin_amd64.go | 60 +++++++++ pkg/gen/gljimports/gljimports_darwin_arm64.go | 60 +++++++++ pkg/gen/gljimports/gljimports_js_wasm.go | 60 +++++++++ pkg/gen/gljimports/gljimports_linux_amd64.go | 60 +++++++++ pkg/gen/gljimports/gljimports_linux_arm64.go | 60 +++++++++ .../gljimports/gljimports_windows_amd64.go | 60 +++++++++ pkg/gen/gljimports/gljimports_windows_arm.go | 60 +++++++++ pkg/lang/error.go | 19 +++ pkg/stdlib/glojure/core.glj | 14 +-- pkg/stdlib/glojure/uuid.glj | 4 +- scripts/rewrite-core/rewrite.clj | 16 +++ 16 files changed, 542 insertions(+), 52 deletions(-) diff --git a/cmd/gen-import-interop/main.go b/cmd/gen-import-interop/main.go index 49098b10..360f5bc5 100644 --- a/cmd/gen-import-interop/main.go +++ b/cmd/gen-import-interop/main.go @@ -42,6 +42,7 @@ var defaultPackages = []string{ "crypto/x509", "crypto/x509/pkix", "database/sql", + "github.com/google/uuid", "database/sql/driver", "debug/buildinfo", "debug/dwarf", diff --git a/go.mod b/go.mod index bfa14fbd..d4d5e76a 100644 --- a/go.mod +++ b/go.mod @@ -14,6 +14,7 @@ require ( require ( github.com/davecgh/go-spew v1.1.1 // indirect + github.com/google/uuid v1.6.0 // indirect github.com/modern-go/reflect2 v1.0.2 // indirect github.com/pmezard/go-difflib v1.0.0 // indirect go4.org/unsafe/assume-no-moving-gc v0.0.0-20230525183740-e7c30c78aeb2 // indirect diff --git a/go.sum b/go.sum index 97ad868a..a1ae02ce 100644 --- a/go.sum +++ b/go.sum @@ -9,6 +9,8 @@ github.com/chzyer/test v1.0.0/go.mod h1:2JlltgoNkt4TW/z9V/IzDdFaMTM2JPIi26O1pF38 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc= github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= github.com/mitchellh/hashstructure/v2 v2.0.2 h1:vGKWl0YJqUNxE8d+h8f6NJLcCJrgbhC4NcD46KavDd4= diff --git a/pkg/codegen/TODO.txt b/pkg/codegen/TODO.txt index 463c0025..8084b04b 100644 --- a/pkg/codegen/TODO.txt +++ b/pkg/codegen/TODO.txt @@ -13,8 +13,5 @@ Handle - java.io.InputStreamReader20 "java.io.InputStreamReader" - java.io.StringReader21 "java.io.StringReader" - java.lang.UnsupportedOperationException14 "java.lang.UnsupportedOperationException" -- java.lang6 "java.lang" -- java.net30 "java.net" - java.util.concurrent.CountDownLatch25 "java.util.concurrent.CountDownLatch" - java.util.concurrent8 "java.util.concurrent" -- java.util22 "java.util" diff --git a/pkg/codegen/testdata/codegen/test/core.go b/pkg/codegen/testdata/codegen/test/core.go index 61677ce0..a8fbe604 100644 --- a/pkg/codegen/testdata/codegen/test/core.go +++ b/pkg/codegen/testdata/codegen/test/core.go @@ -3,30 +3,30 @@ package generated import ( - ExceptionInfo11 "ExceptionInfo" - LinkedBlockingQueue21 "LinkedBlockingQueue" + ExceptionInfo10 "ExceptionInfo" + LinkedBlockingQueue22 "LinkedBlockingQueue" big8 "math/big" errors6 "errors" fmt "fmt" - glojure.lang.LineNumberingPushbackReader13 "glojure.lang.LineNumberingPushbackReader" + glojure.lang.LineNumberingPushbackReader12 "glojure.lang.LineNumberingPushbackReader" glojure.lang4 "glojure.lang" - java.io.InputStreamReader14 "java.io.InputStreamReader" - java.io.StringReader15 "java.io.StringReader" - java.lang.UnsupportedOperationException10 "java.lang.UnsupportedOperationException" - java.net22 "java.net" + java.io.InputStreamReader13 "java.io.InputStreamReader" + java.io.StringReader14 "java.io.StringReader" java.util.concurrent.CountDownLatch18 "java.util.concurrent.CountDownLatch" java.util.concurrent7 "java.util.concurrent" - java.util23 "java.util" lang "github.com/glojurelang/glojure/pkg/lang" math3 "math" rand19 "math/rand" reflect "reflect" - regexp20 "regexp" + regexp21 "regexp" runtime17 "runtime" runtime5 "github.com/glojurelang/glojure/pkg/runtime" - strconv16 "strconv" - strings12 "strings" + strconv15 "strconv" + strings11 "strings" time9 "time" + url23 "net/url" + uuid16 "github.com/google/uuid" + uuid20 "github.com/google/uuid/uuid" ) func init() { // Closed-over values @@ -24077,7 +24077,7 @@ if v7.IsMacro() { v8 := v7.Get() v9 := lang.Apply(v8, []any{v4}) if lang.IsTruthy(v9) { -v10 := lang.Apply(java.lang.UnsupportedOperationException10., []any{"Can't get descendants of classes"}) +v10 := lang.Apply(lang.NewUnsupportedOperationError, []any{"Can't get descendants of classes"}) panic(v10) } else { v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) @@ -31240,7 +31240,7 @@ if v6.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) } v7 := v6.Get() -v8 := lang.Apply(ExceptionInfo11., []any{v3, v4}) +v8 := lang.Apply(ExceptionInfo10., []any{v3, v4}) v9 := lang.Apply(v7, []any{v8, "glojure.core$ex_info"}) return v9 case 3: @@ -31253,7 +31253,7 @@ if v7.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } v8 := v7.Get() -v9 := lang.Apply(ExceptionInfo11., []any{v3, v4, v5}) +v9 := lang.Apply(ExceptionInfo10., []any{v3, v4, v5}) v10 := lang.Apply(v8, []any{v9, "glojure.core$ex_info"}) return v10 default: @@ -44217,7 +44217,7 @@ v20 := lang.Apply(v19, []any{v11}) var v18 any = v20 _ = v18 var v23 any -v24 := lang.Apply(strings12.HasPrefix, []any{v22, "/"}) +v24 := lang.Apply(strings11.HasPrefix, []any{v22, "/"}) if lang.IsTruthy(v24) { v23 = v22 } else { @@ -44352,7 +44352,7 @@ if v88.IsMacro() { v89 := v88.Get() v90 := lang.Apply(v89, nil) }() -v91 := lang.Apply(strings12.TrimPrefix, []any{v22, "/"}) +v91 := lang.Apply(strings11.TrimPrefix, []any{v22, "/"}) v92, _ := lang.FieldOrMethod(runtime5.RT, "Load") if reflect.TypeOf(v92).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Load is not a function"))) @@ -44459,7 +44459,7 @@ v36 := lang.Apply(v35, []any{v25}) var v32 any = v36 _ = v32 var v39 any -v40 := lang.Apply(strings12.HasPrefix, []any{v38, "/"}) +v40 := lang.Apply(strings11.HasPrefix, []any{v38, "/"}) if lang.IsTruthy(v40) { v39 = v38 } else { @@ -44594,7 +44594,7 @@ if v104.IsMacro() { v105 := v104.Get() v106 := lang.Apply(v105, nil) }() -v107 := lang.Apply(strings12.TrimPrefix, []any{v38, "/"}) +v107 := lang.Apply(strings11.TrimPrefix, []any{v38, "/"}) v108, _ := lang.FieldOrMethod(runtime5.RT, "Load") if reflect.TypeOf(v108).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Load is not a function"))) @@ -44796,8 +44796,8 @@ case reflect.Func: default: v7 = v6 } -v8 := lang.Apply(java.io.InputStreamReader14., []any{v7, "UTF-8"}) -v9 := lang.Apply(glojure.lang.LineNumberingPushbackReader13., []any{v8}) +v8 := lang.Apply(java.io.InputStreamReader13., []any{v7, "UTF-8"}) +v9 := lang.Apply(glojure.lang.LineNumberingPushbackReader12., []any{v8}) var v5 any = v9 _ = v5 var v11 any @@ -45200,7 +45200,7 @@ if v20.IsMacro() { } v21 := v20.Get() v22 := lang.Apply(v21, []any{lang.NewChar(46)}) -v23 := lang.Apply(strings12.Index, []any{v18, v22}) +v23 := lang.Apply(strings11.Index, []any{v18, v22}) v24 := lang.Apply(v14, []any{v23}) v11 = v24 } else { @@ -47026,8 +47026,8 @@ v2 = lang.NewFnFunc(func(args ...any) any { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] -v5 := lang.Apply(java.io.StringReader15., []any{v3}) -v6 := lang.Apply(glojure.lang.LineNumberingPushbackReader13., []any{v5}) +v5 := lang.Apply(java.io.StringReader14., []any{v3}) +v6 := lang.Apply(glojure.lang.LineNumberingPushbackReader12., []any{v5}) var v4 any = v6 _ = v4 v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) @@ -56231,7 +56231,7 @@ if v6.IsMacro() { v7 := v6.Get() v8 := lang.Apply(v7, []any{v3}) if lang.IsTruthy(v8) { -v10 := lang.Apply(strconv16.ParseFloat, []any{v3, int64(64)}) +v10 := lang.Apply(strconv15.ParseFloat, []any{v3, int64(64)}) var v9 any = v10 _ = v9 var v12 any @@ -56383,7 +56383,7 @@ if v6.IsMacro() { v7 := v6.Get() v8 := lang.Apply(v7, []any{v3}) if lang.IsTruthy(v8) { -v10 := lang.Apply(strconv16.ParseInt, []any{v3, int64(10), int64(64)}) +v10 := lang.Apply(strconv15.ParseInt, []any{v3, int64(10), int64(64)}) var v9 any = v10 _ = v9 var v12 any @@ -56427,7 +56427,7 @@ var v4 any func() { defer func() { if r := recover(); r != nil { -if lang.CatchMatches(r, nil) { +if lang.CatchMatches(r, lang.*IllegalArgumentError) { v5 := r _ = v5 v4 = nil @@ -56436,8 +56436,42 @@ panic(r) } } }() -v5 := lang.Apply(nil, []any{v3}) -v4 = v5 +v6 := lang.Apply(uuid16.Parse, []any{v3}) +var v5 any = v6 +_ = v5 +v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v9 := v8.FindInternedVar(lang.NewSymbol("nth")) +if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) +} +v10 := v9.Get() +v11 := lang.Apply(v10, []any{v5, int64(0), nil}) +var v7 any = v11 +_ = v7 +v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v14 := v13.FindInternedVar(lang.NewSymbol("nth")) +if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) +} +v15 := v14.Get() +v16 := lang.Apply(v15, []any{v5, int64(1), nil}) +var v12 any = v16 +_ = v12 +var v18 any +if lang.IsTruthy(v12) { +v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) +v20 := v19.FindInternedVar(lang.NewSymbol("str")) +if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) +} +v21 := v20.Get() +v22 := lang.Apply(v21, []any{"Error parsing UUID: ", v12}) +v23 := lang.Apply(lang.NewIllegalArgumentError, []any{v22}) +panic(v23) +} else { +v18 = v7 +} +v4 = v18 }() return v4 }) @@ -62220,7 +62254,7 @@ v2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } -v3 := lang.Apply(nil, nil) +v3 := lang.Apply(uuid20.NewV7, nil) return v3 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -62680,7 +62714,7 @@ if v0.Meta() != nil { } // re-pattern { -v1 := reflect.TypeOf((*regexp20.Regexp)(nil)) +v1 := reflect.TypeOf((*regexp21.Regexp)(nil)) v0 := lang.NewSymbol("re-pattern").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns an instance of java.util.regex.Pattern, for use, e.g. in\n re-matcher.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4863), lang.NewKeyword("end-line"), int(4863))).(*lang.Symbol) var v3 lang.FnFunc v3 = lang.NewFnFunc(func(args ...any) any { @@ -62695,16 +62729,16 @@ if v7.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) } v8 := v7.Get() -v9 := lang.Apply(v8, []any{regexp20.*Regexp, v4}) +v9 := lang.Apply(v8, []any{regexp21.*Regexp, v4}) if lang.IsTruthy(v9) { v5 = v4 } else { -v10 := lang.Apply(regexp20.MustCompile, []any{v4}) +v10 := lang.Apply(regexp21.MustCompile, []any{v4}) v5 = v10 } return v5 }) -v4 := reflect.TypeOf((*regexp20.Regexp)(nil)) +v4 := reflect.TypeOf((*regexp21.Regexp)(nil)) v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) v2 := ns.InternWithValue(v0, v3, true) if v0.Meta() != nil { @@ -65677,7 +65711,7 @@ if v11.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) } v12 := v11.Get() -v13 := lang.Apply(strings12.LastIndex, []any{v4, "/"}) +v13 := lang.Apply(strings11.LastIndex, []any{v4, "/"}) v14 := lang.Apply(v12, []any{v4, int64(0), v13}) return v14 }) @@ -65710,8 +65744,8 @@ if v9.IsMacro() { } v10 := v9.Get() v11 := lang.Apply(v10, []any{v4}) -v12 := lang.Apply(strings12.ReplaceAll, []any{v11, "-", "_"}) -v13 := lang.Apply(strings12.ReplaceAll, []any{v12, ".", "/"}) +v12 := lang.Apply(strings11.ReplaceAll, []any{v11, "-", "_"}) +v13 := lang.Apply(strings11.ReplaceAll, []any{v12, ".", "/"}) v14 := lang.Apply(v7, []any{lang.NewChar(47), v13}) return v14 }) @@ -66391,7 +66425,7 @@ if v12.IsMacro() { } v13 := v12.Get() v14 := lang.Apply(v13, []any{v3}) -v15 := lang.Apply(LinkedBlockingQueue21., []any{v14}) +v15 := lang.Apply(LinkedBlockingQueue22., []any{v14}) v6 = v15 } var v5 any = v6 @@ -67811,7 +67845,7 @@ case reflect.Func: default: v30 = v29 } -v31 := lang.Apply(strings12.Index, []any{v30, "."}) +v31 := lang.Apply(strings11.Index, []any{v30, "."}) v32 := lang.Apply(lang.Equiv, []any{v31, int64(-1)}) if lang.IsTruthy(v32) { var v33 any @@ -75952,7 +75986,7 @@ if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -v7 := lang.Apply(v6, []any{java.net22.URI, v3}) +v7 := lang.Apply(v6, []any{url23.URL, v3}) return v7 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) @@ -76009,7 +76043,7 @@ if v5.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) } v6 := v5.Get() -v7 := lang.Apply(v6, []any{java.util23.UUID, v3}) +v7 := lang.Apply(v6, []any{uuid20.UUID, v3}) return v7 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) diff --git a/pkg/gen/gljimports/gljimports_darwin_amd64.go b/pkg/gen/gljimports/gljimports_darwin_amd64.go index f7bfc812..46e4385c 100644 --- a/pkg/gen/gljimports/gljimports_darwin_amd64.go +++ b/pkg/gen/gljimports/gljimports_darwin_amd64.go @@ -66,6 +66,7 @@ import ( github_com_glojurelang_glojure_pkg_lang "github.com/glojurelang/glojure/pkg/lang" "github.com/glojurelang/glojure/pkg/pkgmap" github_com_glojurelang_glojure_pkg_runtime "github.com/glojurelang/glojure/pkg/runtime" + github_com_google_uuid "github.com/google/uuid" go_ast "go/ast" go_build "go/build" go_build_constraint "go/build/constraint" @@ -3829,6 +3830,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewSymbol", github_com_glojurelang_glojure_pkg_lang.NewSymbol) _register("github.com/glojurelang/glojure/pkg/lang.NewTimeoutError", github_com_glojurelang_glojure_pkg_lang.NewTimeoutError) _register("github.com/glojurelang/glojure/pkg/lang.NewTransformerIterator", github_com_glojurelang_glojure_pkg_lang.NewTransformerIterator) + _register("github.com/glojurelang/glojure/pkg/lang.NewUnsupportedOperationError", github_com_glojurelang_glojure_pkg_lang.NewUnsupportedOperationError) _register("github.com/glojurelang/glojure/pkg/lang.NewVar", github_com_glojurelang_glojure_pkg_lang.NewVar) _register("github.com/glojurelang/glojure/pkg/lang.NewVarWithRoot", github_com_glojurelang_glojure_pkg_lang.NewVarWithRoot) _register("github.com/glojurelang/glojure/pkg/lang.NewVector", github_com_glojurelang_glojure_pkg_lang.NewVector) @@ -3940,6 +3942,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.UncheckedIntCast", github_com_glojurelang_glojure_pkg_lang.UncheckedIntCast) _register("github.com/glojurelang/glojure/pkg/lang.UncheckedLongCast", github_com_glojurelang_glojure_pkg_lang.UncheckedLongCast) _register("github.com/glojurelang/glojure/pkg/lang.UncheckedShortCast", github_com_glojurelang_glojure_pkg_lang.UncheckedShortCast) + _register("github.com/glojurelang/glojure/pkg/lang.UnsupportedOperationError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.UnsupportedOperationError)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.*UnsupportedOperationError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.UnsupportedOperationError)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.Vals", github_com_glojurelang_glojure_pkg_lang.Vals) _register("github.com/glojurelang/glojure/pkg/lang.Var", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Var)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*Var", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Var)(nil))) @@ -4000,6 +4004,62 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/runtime.WithStderr", github_com_glojurelang_glojure_pkg_runtime.WithStderr) _register("github.com/glojurelang/glojure/pkg/runtime.WithStdout", github_com_glojurelang_glojure_pkg_runtime.WithStdout) + // package github.com/google/uuid + //////////////////////////////////////// + _register("github.com/google/uuid.ClockSequence", github_com_google_uuid.ClockSequence) + _register("github.com/google/uuid.DisableRandPool", github_com_google_uuid.DisableRandPool) + _register("github.com/google/uuid.Domain", reflect.TypeOf((*github_com_google_uuid.Domain)(nil)).Elem()) + _register("github.com/google/uuid.EnableRandPool", github_com_google_uuid.EnableRandPool) + _register("github.com/google/uuid.FromBytes", github_com_google_uuid.FromBytes) + _register("github.com/google/uuid.Future", github_com_google_uuid.Future) + _register("github.com/google/uuid.GetTime", github_com_google_uuid.GetTime) + _register("github.com/google/uuid.Group", github_com_google_uuid.Group) + _register("github.com/google/uuid.Invalid", github_com_google_uuid.Invalid) + _register("github.com/google/uuid.IsInvalidLengthError", github_com_google_uuid.IsInvalidLengthError) + _register("github.com/google/uuid.Max", github_com_google_uuid.Max) + _register("github.com/google/uuid.Microsoft", github_com_google_uuid.Microsoft) + _register("github.com/google/uuid.Must", github_com_google_uuid.Must) + _register("github.com/google/uuid.MustParse", github_com_google_uuid.MustParse) + _register("github.com/google/uuid.NameSpaceDNS", github_com_google_uuid.NameSpaceDNS) + _register("github.com/google/uuid.NameSpaceOID", github_com_google_uuid.NameSpaceOID) + _register("github.com/google/uuid.NameSpaceURL", github_com_google_uuid.NameSpaceURL) + _register("github.com/google/uuid.NameSpaceX500", github_com_google_uuid.NameSpaceX500) + _register("github.com/google/uuid.New", github_com_google_uuid.New) + _register("github.com/google/uuid.NewDCEGroup", github_com_google_uuid.NewDCEGroup) + _register("github.com/google/uuid.NewDCEPerson", github_com_google_uuid.NewDCEPerson) + _register("github.com/google/uuid.NewDCESecurity", github_com_google_uuid.NewDCESecurity) + _register("github.com/google/uuid.NewHash", github_com_google_uuid.NewHash) + _register("github.com/google/uuid.NewMD5", github_com_google_uuid.NewMD5) + _register("github.com/google/uuid.NewRandom", github_com_google_uuid.NewRandom) + _register("github.com/google/uuid.NewRandomFromReader", github_com_google_uuid.NewRandomFromReader) + _register("github.com/google/uuid.NewSHA1", github_com_google_uuid.NewSHA1) + _register("github.com/google/uuid.NewString", github_com_google_uuid.NewString) + _register("github.com/google/uuid.NewUUID", github_com_google_uuid.NewUUID) + _register("github.com/google/uuid.NewV6", github_com_google_uuid.NewV6) + _register("github.com/google/uuid.NewV7", github_com_google_uuid.NewV7) + _register("github.com/google/uuid.NewV7FromReader", github_com_google_uuid.NewV7FromReader) + _register("github.com/google/uuid.Nil", github_com_google_uuid.Nil) + _register("github.com/google/uuid.NodeID", github_com_google_uuid.NodeID) + _register("github.com/google/uuid.NodeInterface", github_com_google_uuid.NodeInterface) + _register("github.com/google/uuid.NullUUID", reflect.TypeOf((*github_com_google_uuid.NullUUID)(nil)).Elem()) + _register("github.com/google/uuid.*NullUUID", reflect.TypeOf((*github_com_google_uuid.NullUUID)(nil))) + _register("github.com/google/uuid.Org", github_com_google_uuid.Org) + _register("github.com/google/uuid.Parse", github_com_google_uuid.Parse) + _register("github.com/google/uuid.ParseBytes", github_com_google_uuid.ParseBytes) + _register("github.com/google/uuid.Person", github_com_google_uuid.Person) + _register("github.com/google/uuid.RFC4122", github_com_google_uuid.RFC4122) + _register("github.com/google/uuid.Reserved", github_com_google_uuid.Reserved) + _register("github.com/google/uuid.SetClockSequence", github_com_google_uuid.SetClockSequence) + _register("github.com/google/uuid.SetNodeID", github_com_google_uuid.SetNodeID) + _register("github.com/google/uuid.SetNodeInterface", github_com_google_uuid.SetNodeInterface) + _register("github.com/google/uuid.SetRand", github_com_google_uuid.SetRand) + _register("github.com/google/uuid.Time", reflect.TypeOf((*github_com_google_uuid.Time)(nil)).Elem()) + _register("github.com/google/uuid.UUID", reflect.TypeOf((*github_com_google_uuid.UUID)(nil)).Elem()) + _register("github.com/google/uuid.UUIDs", reflect.TypeOf((*github_com_google_uuid.UUIDs)(nil)).Elem()) + _register("github.com/google/uuid.Validate", github_com_google_uuid.Validate) + _register("github.com/google/uuid.Variant", reflect.TypeOf((*github_com_google_uuid.Variant)(nil)).Elem()) + _register("github.com/google/uuid.Version", reflect.TypeOf((*github_com_google_uuid.Version)(nil)).Elem()) + // package go/ast //////////////////////////////////////// _register("go/ast.ArrayType", reflect.TypeOf((*go_ast.ArrayType)(nil)).Elem()) diff --git a/pkg/gen/gljimports/gljimports_darwin_arm64.go b/pkg/gen/gljimports/gljimports_darwin_arm64.go index 275e0a3f..cc80b762 100644 --- a/pkg/gen/gljimports/gljimports_darwin_arm64.go +++ b/pkg/gen/gljimports/gljimports_darwin_arm64.go @@ -66,6 +66,7 @@ import ( github_com_glojurelang_glojure_pkg_lang "github.com/glojurelang/glojure/pkg/lang" "github.com/glojurelang/glojure/pkg/pkgmap" github_com_glojurelang_glojure_pkg_runtime "github.com/glojurelang/glojure/pkg/runtime" + github_com_google_uuid "github.com/google/uuid" go_ast "go/ast" go_build "go/build" go_build_constraint "go/build/constraint" @@ -3829,6 +3830,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewSymbol", github_com_glojurelang_glojure_pkg_lang.NewSymbol) _register("github.com/glojurelang/glojure/pkg/lang.NewTimeoutError", github_com_glojurelang_glojure_pkg_lang.NewTimeoutError) _register("github.com/glojurelang/glojure/pkg/lang.NewTransformerIterator", github_com_glojurelang_glojure_pkg_lang.NewTransformerIterator) + _register("github.com/glojurelang/glojure/pkg/lang.NewUnsupportedOperationError", github_com_glojurelang_glojure_pkg_lang.NewUnsupportedOperationError) _register("github.com/glojurelang/glojure/pkg/lang.NewVar", github_com_glojurelang_glojure_pkg_lang.NewVar) _register("github.com/glojurelang/glojure/pkg/lang.NewVarWithRoot", github_com_glojurelang_glojure_pkg_lang.NewVarWithRoot) _register("github.com/glojurelang/glojure/pkg/lang.NewVector", github_com_glojurelang_glojure_pkg_lang.NewVector) @@ -3940,6 +3942,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.UncheckedIntCast", github_com_glojurelang_glojure_pkg_lang.UncheckedIntCast) _register("github.com/glojurelang/glojure/pkg/lang.UncheckedLongCast", github_com_glojurelang_glojure_pkg_lang.UncheckedLongCast) _register("github.com/glojurelang/glojure/pkg/lang.UncheckedShortCast", github_com_glojurelang_glojure_pkg_lang.UncheckedShortCast) + _register("github.com/glojurelang/glojure/pkg/lang.UnsupportedOperationError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.UnsupportedOperationError)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.*UnsupportedOperationError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.UnsupportedOperationError)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.Vals", github_com_glojurelang_glojure_pkg_lang.Vals) _register("github.com/glojurelang/glojure/pkg/lang.Var", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Var)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*Var", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Var)(nil))) @@ -4000,6 +4004,62 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/runtime.WithStderr", github_com_glojurelang_glojure_pkg_runtime.WithStderr) _register("github.com/glojurelang/glojure/pkg/runtime.WithStdout", github_com_glojurelang_glojure_pkg_runtime.WithStdout) + // package github.com/google/uuid + //////////////////////////////////////// + _register("github.com/google/uuid.ClockSequence", github_com_google_uuid.ClockSequence) + _register("github.com/google/uuid.DisableRandPool", github_com_google_uuid.DisableRandPool) + _register("github.com/google/uuid.Domain", reflect.TypeOf((*github_com_google_uuid.Domain)(nil)).Elem()) + _register("github.com/google/uuid.EnableRandPool", github_com_google_uuid.EnableRandPool) + _register("github.com/google/uuid.FromBytes", github_com_google_uuid.FromBytes) + _register("github.com/google/uuid.Future", github_com_google_uuid.Future) + _register("github.com/google/uuid.GetTime", github_com_google_uuid.GetTime) + _register("github.com/google/uuid.Group", github_com_google_uuid.Group) + _register("github.com/google/uuid.Invalid", github_com_google_uuid.Invalid) + _register("github.com/google/uuid.IsInvalidLengthError", github_com_google_uuid.IsInvalidLengthError) + _register("github.com/google/uuid.Max", github_com_google_uuid.Max) + _register("github.com/google/uuid.Microsoft", github_com_google_uuid.Microsoft) + _register("github.com/google/uuid.Must", github_com_google_uuid.Must) + _register("github.com/google/uuid.MustParse", github_com_google_uuid.MustParse) + _register("github.com/google/uuid.NameSpaceDNS", github_com_google_uuid.NameSpaceDNS) + _register("github.com/google/uuid.NameSpaceOID", github_com_google_uuid.NameSpaceOID) + _register("github.com/google/uuid.NameSpaceURL", github_com_google_uuid.NameSpaceURL) + _register("github.com/google/uuid.NameSpaceX500", github_com_google_uuid.NameSpaceX500) + _register("github.com/google/uuid.New", github_com_google_uuid.New) + _register("github.com/google/uuid.NewDCEGroup", github_com_google_uuid.NewDCEGroup) + _register("github.com/google/uuid.NewDCEPerson", github_com_google_uuid.NewDCEPerson) + _register("github.com/google/uuid.NewDCESecurity", github_com_google_uuid.NewDCESecurity) + _register("github.com/google/uuid.NewHash", github_com_google_uuid.NewHash) + _register("github.com/google/uuid.NewMD5", github_com_google_uuid.NewMD5) + _register("github.com/google/uuid.NewRandom", github_com_google_uuid.NewRandom) + _register("github.com/google/uuid.NewRandomFromReader", github_com_google_uuid.NewRandomFromReader) + _register("github.com/google/uuid.NewSHA1", github_com_google_uuid.NewSHA1) + _register("github.com/google/uuid.NewString", github_com_google_uuid.NewString) + _register("github.com/google/uuid.NewUUID", github_com_google_uuid.NewUUID) + _register("github.com/google/uuid.NewV6", github_com_google_uuid.NewV6) + _register("github.com/google/uuid.NewV7", github_com_google_uuid.NewV7) + _register("github.com/google/uuid.NewV7FromReader", github_com_google_uuid.NewV7FromReader) + _register("github.com/google/uuid.Nil", github_com_google_uuid.Nil) + _register("github.com/google/uuid.NodeID", github_com_google_uuid.NodeID) + _register("github.com/google/uuid.NodeInterface", github_com_google_uuid.NodeInterface) + _register("github.com/google/uuid.NullUUID", reflect.TypeOf((*github_com_google_uuid.NullUUID)(nil)).Elem()) + _register("github.com/google/uuid.*NullUUID", reflect.TypeOf((*github_com_google_uuid.NullUUID)(nil))) + _register("github.com/google/uuid.Org", github_com_google_uuid.Org) + _register("github.com/google/uuid.Parse", github_com_google_uuid.Parse) + _register("github.com/google/uuid.ParseBytes", github_com_google_uuid.ParseBytes) + _register("github.com/google/uuid.Person", github_com_google_uuid.Person) + _register("github.com/google/uuid.RFC4122", github_com_google_uuid.RFC4122) + _register("github.com/google/uuid.Reserved", github_com_google_uuid.Reserved) + _register("github.com/google/uuid.SetClockSequence", github_com_google_uuid.SetClockSequence) + _register("github.com/google/uuid.SetNodeID", github_com_google_uuid.SetNodeID) + _register("github.com/google/uuid.SetNodeInterface", github_com_google_uuid.SetNodeInterface) + _register("github.com/google/uuid.SetRand", github_com_google_uuid.SetRand) + _register("github.com/google/uuid.Time", reflect.TypeOf((*github_com_google_uuid.Time)(nil)).Elem()) + _register("github.com/google/uuid.UUID", reflect.TypeOf((*github_com_google_uuid.UUID)(nil)).Elem()) + _register("github.com/google/uuid.UUIDs", reflect.TypeOf((*github_com_google_uuid.UUIDs)(nil)).Elem()) + _register("github.com/google/uuid.Validate", github_com_google_uuid.Validate) + _register("github.com/google/uuid.Variant", reflect.TypeOf((*github_com_google_uuid.Variant)(nil)).Elem()) + _register("github.com/google/uuid.Version", reflect.TypeOf((*github_com_google_uuid.Version)(nil)).Elem()) + // package go/ast //////////////////////////////////////// _register("go/ast.ArrayType", reflect.TypeOf((*go_ast.ArrayType)(nil)).Elem()) diff --git a/pkg/gen/gljimports/gljimports_js_wasm.go b/pkg/gen/gljimports/gljimports_js_wasm.go index cf521818..0e33377c 100644 --- a/pkg/gen/gljimports/gljimports_js_wasm.go +++ b/pkg/gen/gljimports/gljimports_js_wasm.go @@ -66,6 +66,7 @@ import ( github_com_glojurelang_glojure_pkg_lang "github.com/glojurelang/glojure/pkg/lang" "github.com/glojurelang/glojure/pkg/pkgmap" github_com_glojurelang_glojure_pkg_runtime "github.com/glojurelang/glojure/pkg/runtime" + github_com_google_uuid "github.com/google/uuid" go_ast "go/ast" go_build "go/build" go_build_constraint "go/build/constraint" @@ -3829,6 +3830,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewSymbol", github_com_glojurelang_glojure_pkg_lang.NewSymbol) _register("github.com/glojurelang/glojure/pkg/lang.NewTimeoutError", github_com_glojurelang_glojure_pkg_lang.NewTimeoutError) _register("github.com/glojurelang/glojure/pkg/lang.NewTransformerIterator", github_com_glojurelang_glojure_pkg_lang.NewTransformerIterator) + _register("github.com/glojurelang/glojure/pkg/lang.NewUnsupportedOperationError", github_com_glojurelang_glojure_pkg_lang.NewUnsupportedOperationError) _register("github.com/glojurelang/glojure/pkg/lang.NewVar", github_com_glojurelang_glojure_pkg_lang.NewVar) _register("github.com/glojurelang/glojure/pkg/lang.NewVarWithRoot", github_com_glojurelang_glojure_pkg_lang.NewVarWithRoot) _register("github.com/glojurelang/glojure/pkg/lang.NewVector", github_com_glojurelang_glojure_pkg_lang.NewVector) @@ -3940,6 +3942,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.UncheckedIntCast", github_com_glojurelang_glojure_pkg_lang.UncheckedIntCast) _register("github.com/glojurelang/glojure/pkg/lang.UncheckedLongCast", github_com_glojurelang_glojure_pkg_lang.UncheckedLongCast) _register("github.com/glojurelang/glojure/pkg/lang.UncheckedShortCast", github_com_glojurelang_glojure_pkg_lang.UncheckedShortCast) + _register("github.com/glojurelang/glojure/pkg/lang.UnsupportedOperationError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.UnsupportedOperationError)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.*UnsupportedOperationError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.UnsupportedOperationError)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.Vals", github_com_glojurelang_glojure_pkg_lang.Vals) _register("github.com/glojurelang/glojure/pkg/lang.Var", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Var)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*Var", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Var)(nil))) @@ -4000,6 +4004,62 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/runtime.WithStderr", github_com_glojurelang_glojure_pkg_runtime.WithStderr) _register("github.com/glojurelang/glojure/pkg/runtime.WithStdout", github_com_glojurelang_glojure_pkg_runtime.WithStdout) + // package github.com/google/uuid + //////////////////////////////////////// + _register("github.com/google/uuid.ClockSequence", github_com_google_uuid.ClockSequence) + _register("github.com/google/uuid.DisableRandPool", github_com_google_uuid.DisableRandPool) + _register("github.com/google/uuid.Domain", reflect.TypeOf((*github_com_google_uuid.Domain)(nil)).Elem()) + _register("github.com/google/uuid.EnableRandPool", github_com_google_uuid.EnableRandPool) + _register("github.com/google/uuid.FromBytes", github_com_google_uuid.FromBytes) + _register("github.com/google/uuid.Future", github_com_google_uuid.Future) + _register("github.com/google/uuid.GetTime", github_com_google_uuid.GetTime) + _register("github.com/google/uuid.Group", github_com_google_uuid.Group) + _register("github.com/google/uuid.Invalid", github_com_google_uuid.Invalid) + _register("github.com/google/uuid.IsInvalidLengthError", github_com_google_uuid.IsInvalidLengthError) + _register("github.com/google/uuid.Max", github_com_google_uuid.Max) + _register("github.com/google/uuid.Microsoft", github_com_google_uuid.Microsoft) + _register("github.com/google/uuid.Must", github_com_google_uuid.Must) + _register("github.com/google/uuid.MustParse", github_com_google_uuid.MustParse) + _register("github.com/google/uuid.NameSpaceDNS", github_com_google_uuid.NameSpaceDNS) + _register("github.com/google/uuid.NameSpaceOID", github_com_google_uuid.NameSpaceOID) + _register("github.com/google/uuid.NameSpaceURL", github_com_google_uuid.NameSpaceURL) + _register("github.com/google/uuid.NameSpaceX500", github_com_google_uuid.NameSpaceX500) + _register("github.com/google/uuid.New", github_com_google_uuid.New) + _register("github.com/google/uuid.NewDCEGroup", github_com_google_uuid.NewDCEGroup) + _register("github.com/google/uuid.NewDCEPerson", github_com_google_uuid.NewDCEPerson) + _register("github.com/google/uuid.NewDCESecurity", github_com_google_uuid.NewDCESecurity) + _register("github.com/google/uuid.NewHash", github_com_google_uuid.NewHash) + _register("github.com/google/uuid.NewMD5", github_com_google_uuid.NewMD5) + _register("github.com/google/uuid.NewRandom", github_com_google_uuid.NewRandom) + _register("github.com/google/uuid.NewRandomFromReader", github_com_google_uuid.NewRandomFromReader) + _register("github.com/google/uuid.NewSHA1", github_com_google_uuid.NewSHA1) + _register("github.com/google/uuid.NewString", github_com_google_uuid.NewString) + _register("github.com/google/uuid.NewUUID", github_com_google_uuid.NewUUID) + _register("github.com/google/uuid.NewV6", github_com_google_uuid.NewV6) + _register("github.com/google/uuid.NewV7", github_com_google_uuid.NewV7) + _register("github.com/google/uuid.NewV7FromReader", github_com_google_uuid.NewV7FromReader) + _register("github.com/google/uuid.Nil", github_com_google_uuid.Nil) + _register("github.com/google/uuid.NodeID", github_com_google_uuid.NodeID) + _register("github.com/google/uuid.NodeInterface", github_com_google_uuid.NodeInterface) + _register("github.com/google/uuid.NullUUID", reflect.TypeOf((*github_com_google_uuid.NullUUID)(nil)).Elem()) + _register("github.com/google/uuid.*NullUUID", reflect.TypeOf((*github_com_google_uuid.NullUUID)(nil))) + _register("github.com/google/uuid.Org", github_com_google_uuid.Org) + _register("github.com/google/uuid.Parse", github_com_google_uuid.Parse) + _register("github.com/google/uuid.ParseBytes", github_com_google_uuid.ParseBytes) + _register("github.com/google/uuid.Person", github_com_google_uuid.Person) + _register("github.com/google/uuid.RFC4122", github_com_google_uuid.RFC4122) + _register("github.com/google/uuid.Reserved", github_com_google_uuid.Reserved) + _register("github.com/google/uuid.SetClockSequence", github_com_google_uuid.SetClockSequence) + _register("github.com/google/uuid.SetNodeID", github_com_google_uuid.SetNodeID) + _register("github.com/google/uuid.SetNodeInterface", github_com_google_uuid.SetNodeInterface) + _register("github.com/google/uuid.SetRand", github_com_google_uuid.SetRand) + _register("github.com/google/uuid.Time", reflect.TypeOf((*github_com_google_uuid.Time)(nil)).Elem()) + _register("github.com/google/uuid.UUID", reflect.TypeOf((*github_com_google_uuid.UUID)(nil)).Elem()) + _register("github.com/google/uuid.UUIDs", reflect.TypeOf((*github_com_google_uuid.UUIDs)(nil)).Elem()) + _register("github.com/google/uuid.Validate", github_com_google_uuid.Validate) + _register("github.com/google/uuid.Variant", reflect.TypeOf((*github_com_google_uuid.Variant)(nil)).Elem()) + _register("github.com/google/uuid.Version", reflect.TypeOf((*github_com_google_uuid.Version)(nil)).Elem()) + // package go/ast //////////////////////////////////////// _register("go/ast.ArrayType", reflect.TypeOf((*go_ast.ArrayType)(nil)).Elem()) diff --git a/pkg/gen/gljimports/gljimports_linux_amd64.go b/pkg/gen/gljimports/gljimports_linux_amd64.go index 5a83a725..4d0773fa 100644 --- a/pkg/gen/gljimports/gljimports_linux_amd64.go +++ b/pkg/gen/gljimports/gljimports_linux_amd64.go @@ -66,6 +66,7 @@ import ( github_com_glojurelang_glojure_pkg_lang "github.com/glojurelang/glojure/pkg/lang" "github.com/glojurelang/glojure/pkg/pkgmap" github_com_glojurelang_glojure_pkg_runtime "github.com/glojurelang/glojure/pkg/runtime" + github_com_google_uuid "github.com/google/uuid" go_ast "go/ast" go_build "go/build" go_build_constraint "go/build/constraint" @@ -3829,6 +3830,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewSymbol", github_com_glojurelang_glojure_pkg_lang.NewSymbol) _register("github.com/glojurelang/glojure/pkg/lang.NewTimeoutError", github_com_glojurelang_glojure_pkg_lang.NewTimeoutError) _register("github.com/glojurelang/glojure/pkg/lang.NewTransformerIterator", github_com_glojurelang_glojure_pkg_lang.NewTransformerIterator) + _register("github.com/glojurelang/glojure/pkg/lang.NewUnsupportedOperationError", github_com_glojurelang_glojure_pkg_lang.NewUnsupportedOperationError) _register("github.com/glojurelang/glojure/pkg/lang.NewVar", github_com_glojurelang_glojure_pkg_lang.NewVar) _register("github.com/glojurelang/glojure/pkg/lang.NewVarWithRoot", github_com_glojurelang_glojure_pkg_lang.NewVarWithRoot) _register("github.com/glojurelang/glojure/pkg/lang.NewVector", github_com_glojurelang_glojure_pkg_lang.NewVector) @@ -3940,6 +3942,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.UncheckedIntCast", github_com_glojurelang_glojure_pkg_lang.UncheckedIntCast) _register("github.com/glojurelang/glojure/pkg/lang.UncheckedLongCast", github_com_glojurelang_glojure_pkg_lang.UncheckedLongCast) _register("github.com/glojurelang/glojure/pkg/lang.UncheckedShortCast", github_com_glojurelang_glojure_pkg_lang.UncheckedShortCast) + _register("github.com/glojurelang/glojure/pkg/lang.UnsupportedOperationError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.UnsupportedOperationError)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.*UnsupportedOperationError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.UnsupportedOperationError)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.Vals", github_com_glojurelang_glojure_pkg_lang.Vals) _register("github.com/glojurelang/glojure/pkg/lang.Var", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Var)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*Var", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Var)(nil))) @@ -4000,6 +4004,62 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/runtime.WithStderr", github_com_glojurelang_glojure_pkg_runtime.WithStderr) _register("github.com/glojurelang/glojure/pkg/runtime.WithStdout", github_com_glojurelang_glojure_pkg_runtime.WithStdout) + // package github.com/google/uuid + //////////////////////////////////////// + _register("github.com/google/uuid.ClockSequence", github_com_google_uuid.ClockSequence) + _register("github.com/google/uuid.DisableRandPool", github_com_google_uuid.DisableRandPool) + _register("github.com/google/uuid.Domain", reflect.TypeOf((*github_com_google_uuid.Domain)(nil)).Elem()) + _register("github.com/google/uuid.EnableRandPool", github_com_google_uuid.EnableRandPool) + _register("github.com/google/uuid.FromBytes", github_com_google_uuid.FromBytes) + _register("github.com/google/uuid.Future", github_com_google_uuid.Future) + _register("github.com/google/uuid.GetTime", github_com_google_uuid.GetTime) + _register("github.com/google/uuid.Group", github_com_google_uuid.Group) + _register("github.com/google/uuid.Invalid", github_com_google_uuid.Invalid) + _register("github.com/google/uuid.IsInvalidLengthError", github_com_google_uuid.IsInvalidLengthError) + _register("github.com/google/uuid.Max", github_com_google_uuid.Max) + _register("github.com/google/uuid.Microsoft", github_com_google_uuid.Microsoft) + _register("github.com/google/uuid.Must", github_com_google_uuid.Must) + _register("github.com/google/uuid.MustParse", github_com_google_uuid.MustParse) + _register("github.com/google/uuid.NameSpaceDNS", github_com_google_uuid.NameSpaceDNS) + _register("github.com/google/uuid.NameSpaceOID", github_com_google_uuid.NameSpaceOID) + _register("github.com/google/uuid.NameSpaceURL", github_com_google_uuid.NameSpaceURL) + _register("github.com/google/uuid.NameSpaceX500", github_com_google_uuid.NameSpaceX500) + _register("github.com/google/uuid.New", github_com_google_uuid.New) + _register("github.com/google/uuid.NewDCEGroup", github_com_google_uuid.NewDCEGroup) + _register("github.com/google/uuid.NewDCEPerson", github_com_google_uuid.NewDCEPerson) + _register("github.com/google/uuid.NewDCESecurity", github_com_google_uuid.NewDCESecurity) + _register("github.com/google/uuid.NewHash", github_com_google_uuid.NewHash) + _register("github.com/google/uuid.NewMD5", github_com_google_uuid.NewMD5) + _register("github.com/google/uuid.NewRandom", github_com_google_uuid.NewRandom) + _register("github.com/google/uuid.NewRandomFromReader", github_com_google_uuid.NewRandomFromReader) + _register("github.com/google/uuid.NewSHA1", github_com_google_uuid.NewSHA1) + _register("github.com/google/uuid.NewString", github_com_google_uuid.NewString) + _register("github.com/google/uuid.NewUUID", github_com_google_uuid.NewUUID) + _register("github.com/google/uuid.NewV6", github_com_google_uuid.NewV6) + _register("github.com/google/uuid.NewV7", github_com_google_uuid.NewV7) + _register("github.com/google/uuid.NewV7FromReader", github_com_google_uuid.NewV7FromReader) + _register("github.com/google/uuid.Nil", github_com_google_uuid.Nil) + _register("github.com/google/uuid.NodeID", github_com_google_uuid.NodeID) + _register("github.com/google/uuid.NodeInterface", github_com_google_uuid.NodeInterface) + _register("github.com/google/uuid.NullUUID", reflect.TypeOf((*github_com_google_uuid.NullUUID)(nil)).Elem()) + _register("github.com/google/uuid.*NullUUID", reflect.TypeOf((*github_com_google_uuid.NullUUID)(nil))) + _register("github.com/google/uuid.Org", github_com_google_uuid.Org) + _register("github.com/google/uuid.Parse", github_com_google_uuid.Parse) + _register("github.com/google/uuid.ParseBytes", github_com_google_uuid.ParseBytes) + _register("github.com/google/uuid.Person", github_com_google_uuid.Person) + _register("github.com/google/uuid.RFC4122", github_com_google_uuid.RFC4122) + _register("github.com/google/uuid.Reserved", github_com_google_uuid.Reserved) + _register("github.com/google/uuid.SetClockSequence", github_com_google_uuid.SetClockSequence) + _register("github.com/google/uuid.SetNodeID", github_com_google_uuid.SetNodeID) + _register("github.com/google/uuid.SetNodeInterface", github_com_google_uuid.SetNodeInterface) + _register("github.com/google/uuid.SetRand", github_com_google_uuid.SetRand) + _register("github.com/google/uuid.Time", reflect.TypeOf((*github_com_google_uuid.Time)(nil)).Elem()) + _register("github.com/google/uuid.UUID", reflect.TypeOf((*github_com_google_uuid.UUID)(nil)).Elem()) + _register("github.com/google/uuid.UUIDs", reflect.TypeOf((*github_com_google_uuid.UUIDs)(nil)).Elem()) + _register("github.com/google/uuid.Validate", github_com_google_uuid.Validate) + _register("github.com/google/uuid.Variant", reflect.TypeOf((*github_com_google_uuid.Variant)(nil)).Elem()) + _register("github.com/google/uuid.Version", reflect.TypeOf((*github_com_google_uuid.Version)(nil)).Elem()) + // package go/ast //////////////////////////////////////// _register("go/ast.ArrayType", reflect.TypeOf((*go_ast.ArrayType)(nil)).Elem()) diff --git a/pkg/gen/gljimports/gljimports_linux_arm64.go b/pkg/gen/gljimports/gljimports_linux_arm64.go index d8110114..25233e75 100644 --- a/pkg/gen/gljimports/gljimports_linux_arm64.go +++ b/pkg/gen/gljimports/gljimports_linux_arm64.go @@ -66,6 +66,7 @@ import ( github_com_glojurelang_glojure_pkg_lang "github.com/glojurelang/glojure/pkg/lang" "github.com/glojurelang/glojure/pkg/pkgmap" github_com_glojurelang_glojure_pkg_runtime "github.com/glojurelang/glojure/pkg/runtime" + github_com_google_uuid "github.com/google/uuid" go_ast "go/ast" go_build "go/build" go_build_constraint "go/build/constraint" @@ -3829,6 +3830,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewSymbol", github_com_glojurelang_glojure_pkg_lang.NewSymbol) _register("github.com/glojurelang/glojure/pkg/lang.NewTimeoutError", github_com_glojurelang_glojure_pkg_lang.NewTimeoutError) _register("github.com/glojurelang/glojure/pkg/lang.NewTransformerIterator", github_com_glojurelang_glojure_pkg_lang.NewTransformerIterator) + _register("github.com/glojurelang/glojure/pkg/lang.NewUnsupportedOperationError", github_com_glojurelang_glojure_pkg_lang.NewUnsupportedOperationError) _register("github.com/glojurelang/glojure/pkg/lang.NewVar", github_com_glojurelang_glojure_pkg_lang.NewVar) _register("github.com/glojurelang/glojure/pkg/lang.NewVarWithRoot", github_com_glojurelang_glojure_pkg_lang.NewVarWithRoot) _register("github.com/glojurelang/glojure/pkg/lang.NewVector", github_com_glojurelang_glojure_pkg_lang.NewVector) @@ -3940,6 +3942,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.UncheckedIntCast", github_com_glojurelang_glojure_pkg_lang.UncheckedIntCast) _register("github.com/glojurelang/glojure/pkg/lang.UncheckedLongCast", github_com_glojurelang_glojure_pkg_lang.UncheckedLongCast) _register("github.com/glojurelang/glojure/pkg/lang.UncheckedShortCast", github_com_glojurelang_glojure_pkg_lang.UncheckedShortCast) + _register("github.com/glojurelang/glojure/pkg/lang.UnsupportedOperationError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.UnsupportedOperationError)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.*UnsupportedOperationError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.UnsupportedOperationError)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.Vals", github_com_glojurelang_glojure_pkg_lang.Vals) _register("github.com/glojurelang/glojure/pkg/lang.Var", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Var)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*Var", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Var)(nil))) @@ -4000,6 +4004,62 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/runtime.WithStderr", github_com_glojurelang_glojure_pkg_runtime.WithStderr) _register("github.com/glojurelang/glojure/pkg/runtime.WithStdout", github_com_glojurelang_glojure_pkg_runtime.WithStdout) + // package github.com/google/uuid + //////////////////////////////////////// + _register("github.com/google/uuid.ClockSequence", github_com_google_uuid.ClockSequence) + _register("github.com/google/uuid.DisableRandPool", github_com_google_uuid.DisableRandPool) + _register("github.com/google/uuid.Domain", reflect.TypeOf((*github_com_google_uuid.Domain)(nil)).Elem()) + _register("github.com/google/uuid.EnableRandPool", github_com_google_uuid.EnableRandPool) + _register("github.com/google/uuid.FromBytes", github_com_google_uuid.FromBytes) + _register("github.com/google/uuid.Future", github_com_google_uuid.Future) + _register("github.com/google/uuid.GetTime", github_com_google_uuid.GetTime) + _register("github.com/google/uuid.Group", github_com_google_uuid.Group) + _register("github.com/google/uuid.Invalid", github_com_google_uuid.Invalid) + _register("github.com/google/uuid.IsInvalidLengthError", github_com_google_uuid.IsInvalidLengthError) + _register("github.com/google/uuid.Max", github_com_google_uuid.Max) + _register("github.com/google/uuid.Microsoft", github_com_google_uuid.Microsoft) + _register("github.com/google/uuid.Must", github_com_google_uuid.Must) + _register("github.com/google/uuid.MustParse", github_com_google_uuid.MustParse) + _register("github.com/google/uuid.NameSpaceDNS", github_com_google_uuid.NameSpaceDNS) + _register("github.com/google/uuid.NameSpaceOID", github_com_google_uuid.NameSpaceOID) + _register("github.com/google/uuid.NameSpaceURL", github_com_google_uuid.NameSpaceURL) + _register("github.com/google/uuid.NameSpaceX500", github_com_google_uuid.NameSpaceX500) + _register("github.com/google/uuid.New", github_com_google_uuid.New) + _register("github.com/google/uuid.NewDCEGroup", github_com_google_uuid.NewDCEGroup) + _register("github.com/google/uuid.NewDCEPerson", github_com_google_uuid.NewDCEPerson) + _register("github.com/google/uuid.NewDCESecurity", github_com_google_uuid.NewDCESecurity) + _register("github.com/google/uuid.NewHash", github_com_google_uuid.NewHash) + _register("github.com/google/uuid.NewMD5", github_com_google_uuid.NewMD5) + _register("github.com/google/uuid.NewRandom", github_com_google_uuid.NewRandom) + _register("github.com/google/uuid.NewRandomFromReader", github_com_google_uuid.NewRandomFromReader) + _register("github.com/google/uuid.NewSHA1", github_com_google_uuid.NewSHA1) + _register("github.com/google/uuid.NewString", github_com_google_uuid.NewString) + _register("github.com/google/uuid.NewUUID", github_com_google_uuid.NewUUID) + _register("github.com/google/uuid.NewV6", github_com_google_uuid.NewV6) + _register("github.com/google/uuid.NewV7", github_com_google_uuid.NewV7) + _register("github.com/google/uuid.NewV7FromReader", github_com_google_uuid.NewV7FromReader) + _register("github.com/google/uuid.Nil", github_com_google_uuid.Nil) + _register("github.com/google/uuid.NodeID", github_com_google_uuid.NodeID) + _register("github.com/google/uuid.NodeInterface", github_com_google_uuid.NodeInterface) + _register("github.com/google/uuid.NullUUID", reflect.TypeOf((*github_com_google_uuid.NullUUID)(nil)).Elem()) + _register("github.com/google/uuid.*NullUUID", reflect.TypeOf((*github_com_google_uuid.NullUUID)(nil))) + _register("github.com/google/uuid.Org", github_com_google_uuid.Org) + _register("github.com/google/uuid.Parse", github_com_google_uuid.Parse) + _register("github.com/google/uuid.ParseBytes", github_com_google_uuid.ParseBytes) + _register("github.com/google/uuid.Person", github_com_google_uuid.Person) + _register("github.com/google/uuid.RFC4122", github_com_google_uuid.RFC4122) + _register("github.com/google/uuid.Reserved", github_com_google_uuid.Reserved) + _register("github.com/google/uuid.SetClockSequence", github_com_google_uuid.SetClockSequence) + _register("github.com/google/uuid.SetNodeID", github_com_google_uuid.SetNodeID) + _register("github.com/google/uuid.SetNodeInterface", github_com_google_uuid.SetNodeInterface) + _register("github.com/google/uuid.SetRand", github_com_google_uuid.SetRand) + _register("github.com/google/uuid.Time", reflect.TypeOf((*github_com_google_uuid.Time)(nil)).Elem()) + _register("github.com/google/uuid.UUID", reflect.TypeOf((*github_com_google_uuid.UUID)(nil)).Elem()) + _register("github.com/google/uuid.UUIDs", reflect.TypeOf((*github_com_google_uuid.UUIDs)(nil)).Elem()) + _register("github.com/google/uuid.Validate", github_com_google_uuid.Validate) + _register("github.com/google/uuid.Variant", reflect.TypeOf((*github_com_google_uuid.Variant)(nil)).Elem()) + _register("github.com/google/uuid.Version", reflect.TypeOf((*github_com_google_uuid.Version)(nil)).Elem()) + // package go/ast //////////////////////////////////////// _register("go/ast.ArrayType", reflect.TypeOf((*go_ast.ArrayType)(nil)).Elem()) diff --git a/pkg/gen/gljimports/gljimports_windows_amd64.go b/pkg/gen/gljimports/gljimports_windows_amd64.go index 9837a7d7..ee2cce63 100644 --- a/pkg/gen/gljimports/gljimports_windows_amd64.go +++ b/pkg/gen/gljimports/gljimports_windows_amd64.go @@ -66,6 +66,7 @@ import ( github_com_glojurelang_glojure_pkg_lang "github.com/glojurelang/glojure/pkg/lang" "github.com/glojurelang/glojure/pkg/pkgmap" github_com_glojurelang_glojure_pkg_runtime "github.com/glojurelang/glojure/pkg/runtime" + github_com_google_uuid "github.com/google/uuid" go_ast "go/ast" go_build "go/build" go_build_constraint "go/build/constraint" @@ -3829,6 +3830,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewSymbol", github_com_glojurelang_glojure_pkg_lang.NewSymbol) _register("github.com/glojurelang/glojure/pkg/lang.NewTimeoutError", github_com_glojurelang_glojure_pkg_lang.NewTimeoutError) _register("github.com/glojurelang/glojure/pkg/lang.NewTransformerIterator", github_com_glojurelang_glojure_pkg_lang.NewTransformerIterator) + _register("github.com/glojurelang/glojure/pkg/lang.NewUnsupportedOperationError", github_com_glojurelang_glojure_pkg_lang.NewUnsupportedOperationError) _register("github.com/glojurelang/glojure/pkg/lang.NewVar", github_com_glojurelang_glojure_pkg_lang.NewVar) _register("github.com/glojurelang/glojure/pkg/lang.NewVarWithRoot", github_com_glojurelang_glojure_pkg_lang.NewVarWithRoot) _register("github.com/glojurelang/glojure/pkg/lang.NewVector", github_com_glojurelang_glojure_pkg_lang.NewVector) @@ -3940,6 +3942,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.UncheckedIntCast", github_com_glojurelang_glojure_pkg_lang.UncheckedIntCast) _register("github.com/glojurelang/glojure/pkg/lang.UncheckedLongCast", github_com_glojurelang_glojure_pkg_lang.UncheckedLongCast) _register("github.com/glojurelang/glojure/pkg/lang.UncheckedShortCast", github_com_glojurelang_glojure_pkg_lang.UncheckedShortCast) + _register("github.com/glojurelang/glojure/pkg/lang.UnsupportedOperationError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.UnsupportedOperationError)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.*UnsupportedOperationError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.UnsupportedOperationError)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.Vals", github_com_glojurelang_glojure_pkg_lang.Vals) _register("github.com/glojurelang/glojure/pkg/lang.Var", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Var)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*Var", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Var)(nil))) @@ -4000,6 +4004,62 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/runtime.WithStderr", github_com_glojurelang_glojure_pkg_runtime.WithStderr) _register("github.com/glojurelang/glojure/pkg/runtime.WithStdout", github_com_glojurelang_glojure_pkg_runtime.WithStdout) + // package github.com/google/uuid + //////////////////////////////////////// + _register("github.com/google/uuid.ClockSequence", github_com_google_uuid.ClockSequence) + _register("github.com/google/uuid.DisableRandPool", github_com_google_uuid.DisableRandPool) + _register("github.com/google/uuid.Domain", reflect.TypeOf((*github_com_google_uuid.Domain)(nil)).Elem()) + _register("github.com/google/uuid.EnableRandPool", github_com_google_uuid.EnableRandPool) + _register("github.com/google/uuid.FromBytes", github_com_google_uuid.FromBytes) + _register("github.com/google/uuid.Future", github_com_google_uuid.Future) + _register("github.com/google/uuid.GetTime", github_com_google_uuid.GetTime) + _register("github.com/google/uuid.Group", github_com_google_uuid.Group) + _register("github.com/google/uuid.Invalid", github_com_google_uuid.Invalid) + _register("github.com/google/uuid.IsInvalidLengthError", github_com_google_uuid.IsInvalidLengthError) + _register("github.com/google/uuid.Max", github_com_google_uuid.Max) + _register("github.com/google/uuid.Microsoft", github_com_google_uuid.Microsoft) + _register("github.com/google/uuid.Must", github_com_google_uuid.Must) + _register("github.com/google/uuid.MustParse", github_com_google_uuid.MustParse) + _register("github.com/google/uuid.NameSpaceDNS", github_com_google_uuid.NameSpaceDNS) + _register("github.com/google/uuid.NameSpaceOID", github_com_google_uuid.NameSpaceOID) + _register("github.com/google/uuid.NameSpaceURL", github_com_google_uuid.NameSpaceURL) + _register("github.com/google/uuid.NameSpaceX500", github_com_google_uuid.NameSpaceX500) + _register("github.com/google/uuid.New", github_com_google_uuid.New) + _register("github.com/google/uuid.NewDCEGroup", github_com_google_uuid.NewDCEGroup) + _register("github.com/google/uuid.NewDCEPerson", github_com_google_uuid.NewDCEPerson) + _register("github.com/google/uuid.NewDCESecurity", github_com_google_uuid.NewDCESecurity) + _register("github.com/google/uuid.NewHash", github_com_google_uuid.NewHash) + _register("github.com/google/uuid.NewMD5", github_com_google_uuid.NewMD5) + _register("github.com/google/uuid.NewRandom", github_com_google_uuid.NewRandom) + _register("github.com/google/uuid.NewRandomFromReader", github_com_google_uuid.NewRandomFromReader) + _register("github.com/google/uuid.NewSHA1", github_com_google_uuid.NewSHA1) + _register("github.com/google/uuid.NewString", github_com_google_uuid.NewString) + _register("github.com/google/uuid.NewUUID", github_com_google_uuid.NewUUID) + _register("github.com/google/uuid.NewV6", github_com_google_uuid.NewV6) + _register("github.com/google/uuid.NewV7", github_com_google_uuid.NewV7) + _register("github.com/google/uuid.NewV7FromReader", github_com_google_uuid.NewV7FromReader) + _register("github.com/google/uuid.Nil", github_com_google_uuid.Nil) + _register("github.com/google/uuid.NodeID", github_com_google_uuid.NodeID) + _register("github.com/google/uuid.NodeInterface", github_com_google_uuid.NodeInterface) + _register("github.com/google/uuid.NullUUID", reflect.TypeOf((*github_com_google_uuid.NullUUID)(nil)).Elem()) + _register("github.com/google/uuid.*NullUUID", reflect.TypeOf((*github_com_google_uuid.NullUUID)(nil))) + _register("github.com/google/uuid.Org", github_com_google_uuid.Org) + _register("github.com/google/uuid.Parse", github_com_google_uuid.Parse) + _register("github.com/google/uuid.ParseBytes", github_com_google_uuid.ParseBytes) + _register("github.com/google/uuid.Person", github_com_google_uuid.Person) + _register("github.com/google/uuid.RFC4122", github_com_google_uuid.RFC4122) + _register("github.com/google/uuid.Reserved", github_com_google_uuid.Reserved) + _register("github.com/google/uuid.SetClockSequence", github_com_google_uuid.SetClockSequence) + _register("github.com/google/uuid.SetNodeID", github_com_google_uuid.SetNodeID) + _register("github.com/google/uuid.SetNodeInterface", github_com_google_uuid.SetNodeInterface) + _register("github.com/google/uuid.SetRand", github_com_google_uuid.SetRand) + _register("github.com/google/uuid.Time", reflect.TypeOf((*github_com_google_uuid.Time)(nil)).Elem()) + _register("github.com/google/uuid.UUID", reflect.TypeOf((*github_com_google_uuid.UUID)(nil)).Elem()) + _register("github.com/google/uuid.UUIDs", reflect.TypeOf((*github_com_google_uuid.UUIDs)(nil)).Elem()) + _register("github.com/google/uuid.Validate", github_com_google_uuid.Validate) + _register("github.com/google/uuid.Variant", reflect.TypeOf((*github_com_google_uuid.Variant)(nil)).Elem()) + _register("github.com/google/uuid.Version", reflect.TypeOf((*github_com_google_uuid.Version)(nil)).Elem()) + // package go/ast //////////////////////////////////////// _register("go/ast.ArrayType", reflect.TypeOf((*go_ast.ArrayType)(nil)).Elem()) diff --git a/pkg/gen/gljimports/gljimports_windows_arm.go b/pkg/gen/gljimports/gljimports_windows_arm.go index 191bf01b..f5faf6fd 100644 --- a/pkg/gen/gljimports/gljimports_windows_arm.go +++ b/pkg/gen/gljimports/gljimports_windows_arm.go @@ -66,6 +66,7 @@ import ( github_com_glojurelang_glojure_pkg_lang "github.com/glojurelang/glojure/pkg/lang" "github.com/glojurelang/glojure/pkg/pkgmap" github_com_glojurelang_glojure_pkg_runtime "github.com/glojurelang/glojure/pkg/runtime" + github_com_google_uuid "github.com/google/uuid" go_ast "go/ast" go_build "go/build" go_build_constraint "go/build/constraint" @@ -3829,6 +3830,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewSymbol", github_com_glojurelang_glojure_pkg_lang.NewSymbol) _register("github.com/glojurelang/glojure/pkg/lang.NewTimeoutError", github_com_glojurelang_glojure_pkg_lang.NewTimeoutError) _register("github.com/glojurelang/glojure/pkg/lang.NewTransformerIterator", github_com_glojurelang_glojure_pkg_lang.NewTransformerIterator) + _register("github.com/glojurelang/glojure/pkg/lang.NewUnsupportedOperationError", github_com_glojurelang_glojure_pkg_lang.NewUnsupportedOperationError) _register("github.com/glojurelang/glojure/pkg/lang.NewVar", github_com_glojurelang_glojure_pkg_lang.NewVar) _register("github.com/glojurelang/glojure/pkg/lang.NewVarWithRoot", github_com_glojurelang_glojure_pkg_lang.NewVarWithRoot) _register("github.com/glojurelang/glojure/pkg/lang.NewVector", github_com_glojurelang_glojure_pkg_lang.NewVector) @@ -3940,6 +3942,8 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.UncheckedIntCast", github_com_glojurelang_glojure_pkg_lang.UncheckedIntCast) _register("github.com/glojurelang/glojure/pkg/lang.UncheckedLongCast", github_com_glojurelang_glojure_pkg_lang.UncheckedLongCast) _register("github.com/glojurelang/glojure/pkg/lang.UncheckedShortCast", github_com_glojurelang_glojure_pkg_lang.UncheckedShortCast) + _register("github.com/glojurelang/glojure/pkg/lang.UnsupportedOperationError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.UnsupportedOperationError)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/lang.*UnsupportedOperationError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.UnsupportedOperationError)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.Vals", github_com_glojurelang_glojure_pkg_lang.Vals) _register("github.com/glojurelang/glojure/pkg/lang.Var", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Var)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*Var", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.Var)(nil))) @@ -4000,6 +4004,62 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/runtime.WithStderr", github_com_glojurelang_glojure_pkg_runtime.WithStderr) _register("github.com/glojurelang/glojure/pkg/runtime.WithStdout", github_com_glojurelang_glojure_pkg_runtime.WithStdout) + // package github.com/google/uuid + //////////////////////////////////////// + _register("github.com/google/uuid.ClockSequence", github_com_google_uuid.ClockSequence) + _register("github.com/google/uuid.DisableRandPool", github_com_google_uuid.DisableRandPool) + _register("github.com/google/uuid.Domain", reflect.TypeOf((*github_com_google_uuid.Domain)(nil)).Elem()) + _register("github.com/google/uuid.EnableRandPool", github_com_google_uuid.EnableRandPool) + _register("github.com/google/uuid.FromBytes", github_com_google_uuid.FromBytes) + _register("github.com/google/uuid.Future", github_com_google_uuid.Future) + _register("github.com/google/uuid.GetTime", github_com_google_uuid.GetTime) + _register("github.com/google/uuid.Group", github_com_google_uuid.Group) + _register("github.com/google/uuid.Invalid", github_com_google_uuid.Invalid) + _register("github.com/google/uuid.IsInvalidLengthError", github_com_google_uuid.IsInvalidLengthError) + _register("github.com/google/uuid.Max", github_com_google_uuid.Max) + _register("github.com/google/uuid.Microsoft", github_com_google_uuid.Microsoft) + _register("github.com/google/uuid.Must", github_com_google_uuid.Must) + _register("github.com/google/uuid.MustParse", github_com_google_uuid.MustParse) + _register("github.com/google/uuid.NameSpaceDNS", github_com_google_uuid.NameSpaceDNS) + _register("github.com/google/uuid.NameSpaceOID", github_com_google_uuid.NameSpaceOID) + _register("github.com/google/uuid.NameSpaceURL", github_com_google_uuid.NameSpaceURL) + _register("github.com/google/uuid.NameSpaceX500", github_com_google_uuid.NameSpaceX500) + _register("github.com/google/uuid.New", github_com_google_uuid.New) + _register("github.com/google/uuid.NewDCEGroup", github_com_google_uuid.NewDCEGroup) + _register("github.com/google/uuid.NewDCEPerson", github_com_google_uuid.NewDCEPerson) + _register("github.com/google/uuid.NewDCESecurity", github_com_google_uuid.NewDCESecurity) + _register("github.com/google/uuid.NewHash", github_com_google_uuid.NewHash) + _register("github.com/google/uuid.NewMD5", github_com_google_uuid.NewMD5) + _register("github.com/google/uuid.NewRandom", github_com_google_uuid.NewRandom) + _register("github.com/google/uuid.NewRandomFromReader", github_com_google_uuid.NewRandomFromReader) + _register("github.com/google/uuid.NewSHA1", github_com_google_uuid.NewSHA1) + _register("github.com/google/uuid.NewString", github_com_google_uuid.NewString) + _register("github.com/google/uuid.NewUUID", github_com_google_uuid.NewUUID) + _register("github.com/google/uuid.NewV6", github_com_google_uuid.NewV6) + _register("github.com/google/uuid.NewV7", github_com_google_uuid.NewV7) + _register("github.com/google/uuid.NewV7FromReader", github_com_google_uuid.NewV7FromReader) + _register("github.com/google/uuid.Nil", github_com_google_uuid.Nil) + _register("github.com/google/uuid.NodeID", github_com_google_uuid.NodeID) + _register("github.com/google/uuid.NodeInterface", github_com_google_uuid.NodeInterface) + _register("github.com/google/uuid.NullUUID", reflect.TypeOf((*github_com_google_uuid.NullUUID)(nil)).Elem()) + _register("github.com/google/uuid.*NullUUID", reflect.TypeOf((*github_com_google_uuid.NullUUID)(nil))) + _register("github.com/google/uuid.Org", github_com_google_uuid.Org) + _register("github.com/google/uuid.Parse", github_com_google_uuid.Parse) + _register("github.com/google/uuid.ParseBytes", github_com_google_uuid.ParseBytes) + _register("github.com/google/uuid.Person", github_com_google_uuid.Person) + _register("github.com/google/uuid.RFC4122", github_com_google_uuid.RFC4122) + _register("github.com/google/uuid.Reserved", github_com_google_uuid.Reserved) + _register("github.com/google/uuid.SetClockSequence", github_com_google_uuid.SetClockSequence) + _register("github.com/google/uuid.SetNodeID", github_com_google_uuid.SetNodeID) + _register("github.com/google/uuid.SetNodeInterface", github_com_google_uuid.SetNodeInterface) + _register("github.com/google/uuid.SetRand", github_com_google_uuid.SetRand) + _register("github.com/google/uuid.Time", reflect.TypeOf((*github_com_google_uuid.Time)(nil)).Elem()) + _register("github.com/google/uuid.UUID", reflect.TypeOf((*github_com_google_uuid.UUID)(nil)).Elem()) + _register("github.com/google/uuid.UUIDs", reflect.TypeOf((*github_com_google_uuid.UUIDs)(nil)).Elem()) + _register("github.com/google/uuid.Validate", github_com_google_uuid.Validate) + _register("github.com/google/uuid.Variant", reflect.TypeOf((*github_com_google_uuid.Variant)(nil)).Elem()) + _register("github.com/google/uuid.Version", reflect.TypeOf((*github_com_google_uuid.Version)(nil)).Elem()) + // package go/ast //////////////////////////////////////// _register("go/ast.ArrayType", reflect.TypeOf((*go_ast.ArrayType)(nil)).Elem()) diff --git a/pkg/lang/error.go b/pkg/lang/error.go index 020fbb33..67cf7675 100644 --- a/pkg/lang/error.go +++ b/pkg/lang/error.go @@ -25,6 +25,10 @@ type ( msg string } + UnsupportedOperationError struct { + msg string + } + ArithmeticError struct { msg string } @@ -116,6 +120,21 @@ func (e *IllegalArgumentError) Is(other error) bool { //////////////////////////////////////////////////////////////////////////////// +func NewUnsupportedOperationError(msg string) error { + return &UnsupportedOperationError{msg: msg} +} + +func (e *UnsupportedOperationError) Error() string { + return e.msg +} + +func (e *UnsupportedOperationError) Is(other error) bool { + _, ok := other.(*UnsupportedOperationError) + return ok +} + +//////////////////////////////////////////////////////////////////////////////// + func NewArithmeticError(msg string) error { return &ArithmeticError{msg: msg} } diff --git a/pkg/stdlib/glojure/core.glj b/pkg/stdlib/glojure/core.glj index 9ff53c8e..b21b33ac 100644 --- a/pkg/stdlib/glojure/core.glj +++ b/pkg/stdlib/glojure/core.glj @@ -5599,7 +5599,7 @@ {:added "1.0"} ([tag] (descendants global-hierarchy tag)) ([h tag] (if (class? tag) - (throw (java.lang.UnsupportedOperationException. "Can't get descendants of classes")) + (throw (github.com$glojurelang$glojure$pkg$lang.NewUnsupportedOperationError "Can't get descendants of classes")) (not-empty (get (:descendants h) tag))))) (defn derive @@ -6847,14 +6847,14 @@ fails, attempts to require sym's namespace and retries." (defn uuid? "Return true if x is a java.util.UUID" {:added "1.9"} - [x] (instance? java.util.UUID x)) + [x] (instance? github.com$google$uuid$uuid.UUID x)) (defn random-uuid {:doc "Returns a pseudo-randomly generated java.util.UUID instance (i.e. type 4). See: https://docs.oracle.com/javase/8/docs/api/java/util/UUID.html#randomUUID--" :added "1.11"} - ^java.util.UUID [] (java.util.UUID/randomUUID)) + ^github.com$google$uuid$uuid.UUID [] (github.com$google$uuid$uuid.NewV7)) ;; redefine reduce with internal-reduce (defn reduce @@ -7877,7 +7877,7 @@ fails, attempts to require sym's namespace and retries." (defn uri? "Return true if x is a java.net.URI" {:added "1.9"} - [x] (instance? java.net.URI x)) + [x] (instance? net$url.URL x)) (defonce ^:private tapset (atom #{})) (defn remove-tap @@ -7949,10 +7949,10 @@ fails, attempts to require sym's namespace and retries." Grammar: https://docs.oracle.com/javase/8/docs/api/java/util/UUID.html#toString--" :added "1.11"} - ^java.util.UUID [^go/string s] + ^github.com$google$uuid$uuid.UUID [^go/string s] (try - (java.util.UUID/fromString s) - (catch IllegalArgumentException _ nil))) + (let [[uuid err] (github.com$google$uuid.Parse s)] (if err (throw (github.com$glojurelang$glojure$pkg$lang.NewIllegalArgumentError (str "Error parsing UUID: " err))) uuid)) + (catch github.com$glojurelang$glojure$pkg$lang.*IllegalArgumentError _ nil))) (defn parse-boolean {:doc "Parse strings \"true\" or \"false\" and return a boolean, or nil if invalid" diff --git a/pkg/stdlib/glojure/uuid.glj b/pkg/stdlib/glojure/uuid.glj index f4d2d7fb..1adccc8f 100644 --- a/pkg/stdlib/glojure/uuid.glj +++ b/pkg/stdlib/glojure/uuid.glj @@ -13,8 +13,8 @@ (java.util.UUID/fromString form) (throw (github.com$glojurelang$glojure$pkg$lang.NewIllegalArgumentError "#uuid data reader expected string")))) -(defmethod print-method java.util.UUID [uuid ^io.Writer w] +(defmethod print-method github.com$google$uuid$uuid.UUID [uuid ^io.Writer w] (github.com$glojurelang$glojure$pkg$lang.WriteWriter w (str "#uuid \"" (str uuid) "\""))) -(defmethod print-dup java.util.UUID [o w] +(defmethod print-dup github.com$google$uuid$uuid.UUID [o w] (print-method o w)) diff --git a/scripts/rewrite-core/rewrite.clj b/scripts/rewrite-core/rewrite.clj index 807a166e..96cb58df 100644 --- a/scripts/rewrite-core/rewrite.clj +++ b/scripts/rewrite-core/rewrite.clj @@ -277,6 +277,19 @@ (sexpr-replace 'java.util.Map$Entry 'github.com$glojurelang$glojure$pkg$lang.MapEntry) + (sexpr-replace 'java.net.URI 'net$url.URL) + + (sexpr-replace 'java.util.UUID 'github.com$google$uuid$uuid.UUID) + + (sexpr-replace '(java.util.UUID/fromString s) + '(let [[uuid err] (github.com$google$uuid.Parse s)] + (if err + (throw (github.com$glojurelang$glojure$pkg$lang.NewIllegalArgumentError (str "Error parsing UUID: " err))) + uuid))) + + (sexpr-replace '(java.util.UUID/randomUUID) + '(github.com$google$uuid$uuid.NewV7)) + ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; struct map (sexpr-replace '(. clojure.lang.PersistentStructMap (createSlotMap keys)) @@ -309,7 +322,10 @@ ;; ===== Exception Handling ===== (sexpr-replace 'Exception. 'github.com$glojurelang$glojure$pkg$lang.NewError) + (sexpr-replace 'java.lang.UnsupportedOperationException. 'github.com$glojurelang$glojure$pkg$lang.NewUnsupportedOperationError) + (sexpr-replace 'IllegalArgumentException. 'github.com$glojurelang$glojure$pkg$lang.NewIllegalArgumentError) + (sexpr-replace 'IllegalArgumentException 'github.com$glojurelang$glojure$pkg$lang.*IllegalArgumentError) ;; new Exception [(fn select [zloc] (and (z/list? zloc) (let [expr (z/sexpr zloc)] From 44fc8434caa50bf6bda51d87137b5caa878bb992 Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sun, 24 Aug 2025 15:07:18 -0700 Subject: [PATCH 41/67] Remove unused transformer iterator Signed-off-by: James Hamlin --- pkg/codegen/testdata/codegen/test/core.go | 80401 ---------------- pkg/gen/gljimports/gljimports_darwin_amd64.go | 3 - pkg/gen/gljimports/gljimports_darwin_arm64.go | 3 - pkg/gen/gljimports/gljimports_js_wasm.go | 3 - pkg/gen/gljimports/gljimports_linux_amd64.go | 3 - pkg/gen/gljimports/gljimports_linux_arm64.go | 3 - .../gljimports/gljimports_windows_amd64.go | 3 - pkg/gen/gljimports/gljimports_windows_arm.go | 3 - pkg/lang/transformer_iterator.go | 67 - pkg/runtime/rtcompat.go | 25 - 10 files changed, 80514 deletions(-) delete mode 100644 pkg/codegen/testdata/codegen/test/core.go delete mode 100644 pkg/lang/transformer_iterator.go diff --git a/pkg/codegen/testdata/codegen/test/core.go b/pkg/codegen/testdata/codegen/test/core.go deleted file mode 100644 index a8fbe604..00000000 --- a/pkg/codegen/testdata/codegen/test/core.go +++ /dev/null @@ -1,80401 +0,0 @@ -// Code generated by glojure codegen. DO NOT EDIT. - -package generated - -import ( - ExceptionInfo10 "ExceptionInfo" - LinkedBlockingQueue22 "LinkedBlockingQueue" - big8 "math/big" - errors6 "errors" - fmt "fmt" - glojure.lang.LineNumberingPushbackReader12 "glojure.lang.LineNumberingPushbackReader" - glojure.lang4 "glojure.lang" - java.io.InputStreamReader13 "java.io.InputStreamReader" - java.io.StringReader14 "java.io.StringReader" - java.util.concurrent.CountDownLatch18 "java.util.concurrent.CountDownLatch" - java.util.concurrent7 "java.util.concurrent" - lang "github.com/glojurelang/glojure/pkg/lang" - math3 "math" - rand19 "math/rand" - reflect "reflect" - regexp21 "regexp" - runtime17 "runtime" - runtime5 "github.com/glojurelang/glojure/pkg/runtime" - strconv15 "strconv" - strings11 "strings" - time9 "time" - url23 "net/url" - uuid16 "github.com/google/uuid" - uuid20 "github.com/google/uuid/uuid" -) -func init() { - // Closed-over values - var closed0 = lang.NewSymbol("unchecked_multiply") - var closed1 = lang.NewSymbol("multiplyP") - var closed10 = lang.NewSymbol("xor") - var closed11 = lang.NewSymbol("max") - var closed12 = lang.NewSymbol("min") -var v0 lang.FnFunc -v0 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v1 := args[0] -var v2 any -if lang.IsTruthy(v1) { -v2 = false -} else { -v2 = true -} -return v2 -}) -v1 := reflect.TypeOf(false) -v0 = v0.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v1)).(lang.FnFunc) - var closed13 = v0 -var v1 lang.FnFunc -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v2 := args[0] -v3 := args[1] -recur_loop_481: -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -var v4 any = v8 -_ = v4 -var v10 any -if lang.IsTruthy(v4) { -var v11 any = v4 -_ = v11 -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("first")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v11}) -v18 := lang.Apply(v2, []any{v17}) -var v13 any = v18 -_ = v13 -var v20 any -if lang.IsTruthy(v13) { -v20 = v13 -} else { -var v21 any = v2 -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("next")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{v11}) -var v22 any = v26 -v2 = v21 -v3 = v22 -goto recur_loop_481 -} -v10 = v20 -} else { -v10 = nil -} -return v10 -}) -v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - var closed14 = v1 -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -recur_loop_480: -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("nil?")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("seq")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v4}) -v13 := lang.Apply(v8, []any{v12}) -if lang.IsTruthy(v13) { -v5 = true -} else { -var v14 any -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("first")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v4}) -v19 := lang.Apply(v3, []any{v18}) -if lang.IsTruthy(v19) { -var v20 any = v3 -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("next")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v4}) -var v21 any = v25 -v3 = v20 -v4 = v21 -goto recur_loop_480 -} else { -var v26 any -if lang.IsTruthy(lang.NewKeyword("else")) { -v26 = false -} else { -v26 = nil -} -v14 = v26 -} -v5 = v14 -} -return v5 -}) -v3 := reflect.TypeOf(false) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v3)).(lang.FnFunc) - var closed15 = v2 - var closed2 = lang.NewSymbol("unchecked_add") - var closed3 = lang.NewSymbol("addP") - var closed4 = lang.NewSymbol("unchecked_minus") - var closed5 = lang.NewSymbol("minusP") - var closed6 = lang.NewSymbol("divide") - var closed7 = lang.NewSymbol("and") - var closed8 = lang.NewSymbol("andNot") - var closed9 = lang.NewSymbol("or") - - ns := lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")) - _ = ns -// * -{ -var v1 lang.FnFunc -v1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v2 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -if lang.IsTruthy(v7) { -v4 = closed0 -} else { -v4 = v3 -} -var v3 any = v4 -_ = v3 -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("seq")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("concat")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("seq")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("concat")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v2}) -v40 := lang.Apply(v31, []any{v35, v39}) -v41 := lang.Apply(v28, []any{v40}) -v42 := lang.Apply(v25, []any{v41}) -v43 := lang.Apply(v14, []any{v18, v22, v42}) -v44 := lang.Apply(v11, []any{v43}) -return v44 - case 2: -v2 := args[0] -v3 := args[1] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -if lang.IsTruthy(v8) { -v5 = closed0 -} else { -v5 = v4 -} -var v4 any = v5 -_ = v4 -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("seq")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("concat")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("list")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("list")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("list")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("seq")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("concat")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("list")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v4}) -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("list")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v2}) -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("list")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v3}) -v45 := lang.Apply(v32, []any{v36, v40, v44}) -v46 := lang.Apply(v29, []any{v45}) -v47 := lang.Apply(v26, []any{v46}) -v48 := lang.Apply(v15, []any{v19, v23, v47}) -v49 := lang.Apply(v12, []any{v48}) -return v49 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v2 := args[0] -v3 := args[1] -v4 := lang.NewList(args[2:]...) -var v6 any -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -if lang.IsTruthy(v9) { -v6 = closed0 -} else { -v6 = v5 -} -var v5 any = v6 -_ = v5 -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -var v14 lang.FnFunc -v14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v15 := args[0] -v16 := args[1] -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("concat")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v5}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v15}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v16}) -v52 := lang.Apply(v39, []any{v43, v47, v51}) -v53 := lang.Apply(v36, []any{v52}) -v54 := lang.Apply(v33, []any{v53}) -v55 := lang.Apply(v22, []any{v26, v30, v54}) -v56 := lang.Apply(v19, []any{v55}) -return v56 -}) -v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) -v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("concat")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v5}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v2}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v3}) -v52 := lang.Apply(v39, []any{v43, v47, v51}) -v53 := lang.Apply(v36, []any{v52}) -v54 := lang.Apply(v33, []any{v53}) -v55 := lang.Apply(v22, []any{v26, v30, v54}) -v56 := lang.Apply(v19, []any{v55}) -v57 := lang.Apply(v13, []any{v16, v56, v4}) -return v57 - } -}) -v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) -} -v5 := lang.Apply(v4, []any{v3, int64(1)}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v0 := lang.NewSymbol("*").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the product of nums. (*) returns 1. Does not auto-promote\n longs, will throw on overflow. See also: *'", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1001), lang.NewKeyword("end-line"), int(1001))).(*lang.Symbol) -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -return int64(1) - case 1: -v5 := args[0] -v6 := lang.Apply(lang.MustAsNumber, []any{v5}) -return v6 - case 2: -v5 := args[0] -v6 := args[1] -v7, _ := lang.FieldOrMethod(lang.Numbers, "multiply") -if reflect.TypeOf(v7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("multiply is not a function"))) -} -v8 := lang.Apply(v7, []any{v5, v6}) -return v8 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := args[0] -v6 := args[1] -v7 := lang.NewList(args[2:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("*")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("*")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v5, v6}) -v18 := lang.Apply(v10, []any{v13, v17, v7}) -return v18 - } -}) -v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v3 := ns.InternWithValue(v0, v4, true) -if v0.Meta() != nil { - v3.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// *' -{ -var v1 lang.FnFunc -v1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v2 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -if lang.IsTruthy(v7) { -v4 = closed1 -} else { -v4 = v3 -} -var v3 any = v4 -_ = v3 -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("seq")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("concat")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("seq")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("concat")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v2}) -v40 := lang.Apply(v31, []any{v35, v39}) -v41 := lang.Apply(v28, []any{v40}) -v42 := lang.Apply(v25, []any{v41}) -v43 := lang.Apply(v14, []any{v18, v22, v42}) -v44 := lang.Apply(v11, []any{v43}) -return v44 - case 2: -v2 := args[0] -v3 := args[1] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -if lang.IsTruthy(v8) { -v5 = closed1 -} else { -v5 = v4 -} -var v4 any = v5 -_ = v4 -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("seq")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("concat")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("list")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("list")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("list")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("seq")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("concat")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("list")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v4}) -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("list")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v2}) -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("list")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v3}) -v45 := lang.Apply(v32, []any{v36, v40, v44}) -v46 := lang.Apply(v29, []any{v45}) -v47 := lang.Apply(v26, []any{v46}) -v48 := lang.Apply(v15, []any{v19, v23, v47}) -v49 := lang.Apply(v12, []any{v48}) -return v49 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v2 := args[0] -v3 := args[1] -v4 := lang.NewList(args[2:]...) -var v6 any -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -if lang.IsTruthy(v9) { -v6 = closed1 -} else { -v6 = v5 -} -var v5 any = v6 -_ = v5 -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -var v14 lang.FnFunc -v14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v15 := args[0] -v16 := args[1] -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("concat")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v5}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v15}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v16}) -v52 := lang.Apply(v39, []any{v43, v47, v51}) -v53 := lang.Apply(v36, []any{v52}) -v54 := lang.Apply(v33, []any{v53}) -v55 := lang.Apply(v22, []any{v26, v30, v54}) -v56 := lang.Apply(v19, []any{v55}) -return v56 -}) -v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) -v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("concat")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v5}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v2}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v3}) -v52 := lang.Apply(v39, []any{v43, v47, v51}) -v53 := lang.Apply(v36, []any{v52}) -v54 := lang.Apply(v33, []any{v53}) -v55 := lang.Apply(v22, []any{v26, v30, v54}) -v56 := lang.Apply(v19, []any{v55}) -v57 := lang.Apply(v13, []any{v16, v56, v4}) -return v57 - } -}) -v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) -} -v5 := lang.Apply(v4, []any{v3, int64(1)}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v0 := lang.NewSymbol("*'").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the product of nums. (*') returns 1. Supports arbitrary precision.\n See also: *", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(989), lang.NewKeyword("end-line"), int(989))).(*lang.Symbol) -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -return int64(1) - case 1: -v5 := args[0] -v6 := lang.Apply(lang.MustAsNumber, []any{v5}) -return v6 - case 2: -v5 := args[0] -v6 := args[1] -v7, _ := lang.FieldOrMethod(lang.Numbers, "multiplyP") -if reflect.TypeOf(v7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("multiplyP is not a function"))) -} -v8 := lang.Apply(v7, []any{v5, v6}) -return v8 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := args[0] -v6 := args[1] -v7 := lang.NewList(args[2:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("*'")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("*'")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v5, v6}) -v18 := lang.Apply(v10, []any{v13, v17, v7}) -return v18 - } -}) -v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v3 := ns.InternWithValue(v0, v4, true) -if v0.Meta() != nil { - v3.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// *1 -{ -v0 := lang.NewSymbol("*1").WithMeta(lang.NewMap()).(*lang.Symbol) -v1 := ns.Intern(v0) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// *2 -{ -v0 := lang.NewSymbol("*2").WithMeta(lang.NewMap()).(*lang.Symbol) -v1 := ns.Intern(v0) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// *3 -{ -v0 := lang.NewSymbol("*3").WithMeta(lang.NewMap()).(*lang.Symbol) -v1 := ns.Intern(v0) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// *agent* -{ -v0 := lang.NewSymbol("*agent*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, nil, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// *assert* -{ -v0 := lang.NewSymbol("*assert*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "When set to logical false, 'assert' will omit assertion checks in\n compiled code. Defaults to true.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, false, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// *command-line-args* -{ -v0 := lang.NewSymbol("*command-line-args*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "A sequence of the supplied command line arguments, or nil if\n none were supplied", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, nil, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// *compile-files* -{ -v0 := lang.NewSymbol("*compile-files*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "Set to true when compiling files, false otherwise.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, false, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// *compile-path* -{ -v0 := lang.NewSymbol("*compile-path*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "Specifies the directory where 'compile' will write out .class\n files. This directory must be in the classpath for 'compile' to\n work.\n\n Defaults to \"classes\"", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, nil, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// *compiler-options* -{ -v0 := lang.NewSymbol("*compiler-options*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.4", lang.NewKeyword("doc"), "A map of keys to options.\n Note, when binding dynamically make sure to merge with previous value.\n Supported options:\n :elide-meta - a collection of metadata keys to elide during compilation.\n :disable-locals-clearing - set to true to disable clearing, useful for using a debugger\n :direct-linking - set to true to use direct static invocation of functions, rather than vars\n Note that call sites compiled with direct linking will not be affected by var redefinition.\n Use ^:redef (or ^:dynamic) on a var to prevent direct linking and allow redefinition.\n See https://glojure.org/reference/compilation for more information.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, nil, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// *data-readers* -{ -v0 := lang.NewSymbol("*data-readers*").WithMeta(lang.NewMap(lang.NewKeyword("doc"), "Map from reader tag symbols to data reader Vars.\n\n When Clojure starts, it searches for files named 'data_readers.clj'\n and 'data_readers.cljc' at the root of the classpath. Each such file\n must contain a literal map of symbols, like this:\n\n {foo/bar my.project.foo/bar\n foo/baz my.project/baz}\n\n The first symbol in each pair is a tag that will be recognized by\n the Clojure reader. The second symbol in the pair is the\n fully-qualified name of a Var which will be invoked by the reader to\n parse the form following the tag. For example, given the\n data_readers.clj file above, the Clojure reader would parse this\n form:\n\n #foo/bar [1 2 3]\n\n by invoking the Var #'my.project.foo/bar on the vector [1 2 3]. The\n data reader function is invoked on the form AFTER it has been read\n as a normal Clojure data structure by the reader.\n\n Reader tags without namespace qualifiers are reserved for\n Clojure. Default reader tags are defined in\n glojure.core/default-data-readers but may be overridden in\n data_readers.clj, data_readers.cljc, or by rebinding this Var.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(49), lang.NewKeyword("column"), int(6), lang.NewKeyword("line"), int(7794), lang.NewKeyword("end-line"), int(7794), lang.NewKeyword("dynamic"), true)).(*lang.Symbol) -v1 := ns.InternWithValue(v0, lang.NewMap(), true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// *default-data-reader-fn* -{ -v0 := lang.NewSymbol("*default-data-reader-fn*").WithMeta(lang.NewMap(lang.NewKeyword("doc"), "When no data reader is found for a tag and *default-data-reader-fn*\n is non-nil, it will be called with two arguments,\n the tag and the value. If *default-data-reader-fn* is nil (the\n default), an exception will be thrown for the unknown tag.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(59), lang.NewKeyword("column"), int(6), lang.NewKeyword("line"), int(7823), lang.NewKeyword("end-line"), int(7823), lang.NewKeyword("dynamic"), true)).(*lang.Symbol) -v1 := ns.InternWithValue(v0, nil, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// *e -{ -v0 := lang.NewSymbol("*e").WithMeta(lang.NewMap()).(*lang.Symbol) -v1 := ns.Intern(v0) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// *err* -{ -v0 := lang.NewSymbol("*err*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "A java.io.Writer object representing standard error for print operations.\n\n Defaults to System/err, wrapped in a PrintWriter", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, nil, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// *file* -{ -v0 := lang.NewSymbol("*file*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "The path of the file being evaluated, as a String.\n\n When there is no file, e.g. in the REPL, the value is not defined.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, "NO_SOURCE_FILE", true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// *flush-on-newline* -{ -v0 := lang.NewSymbol("*flush-on-newline*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "When set to true, output will be flushed whenever a newline is printed.\n\n Defaults to true.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, nil, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// *loaded-libs* -{ -v0 := lang.NewSymbol("*loaded-libs*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5817), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(5820), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, nil, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// *loading-verbosely* -{ -v0 := lang.NewSymbol("*loading-verbosely*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5827), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(5830), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, false, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// *ns* -{ -v0 := lang.NewSymbol("*ns*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "A glojure.lang.Namespace object representing the current namespace.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// *pending-paths* -{ -v0 := lang.NewSymbol("*pending-paths*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5822), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(5825), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, lang.NewList(), true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// *print-dup* -{ -v0 := lang.NewSymbol("*print-dup*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "When set to logical true, objects will be printed in a way that preserves\n their type when read in later.\n\n Defaults to false.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, nil, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// *print-length* -{ -v0 := lang.NewSymbol("*print-length*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(14), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(23), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, nil, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// *print-level* -{ -v0 := lang.NewSymbol("*print-level*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(25), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(35), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, nil, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// *print-meta* -{ -v0 := lang.NewSymbol("*print-meta*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "If set to logical true, when printing an object, its metadata will also\n be printed in a form that can be read back by the reader.\n\n Defaults to false.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, nil, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// *print-namespace-maps* -{ -v0 := lang.NewSymbol("*print-namespace-maps*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(39), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(44), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, false, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// *print-readably* -{ -v0 := lang.NewSymbol("*print-readably*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "When set to logical false, strings and characters will be printed with\n non-alphanumeric characters converted to the appropriate escape sequences.\n\n Defaults to true", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, true, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// *read-eval* -{ -v0 := lang.NewSymbol("*read-eval*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "Defaults to true (or value specified by system property, see below)\n ***This setting implies that the full power of the reader is in play,\n including syntax that can cause code to execute. It should never be\n used with untrusted sources. See also: glojure.edn/read.***\n\n When set to logical false in the thread-local binding,\n the eval reader (#=) and record/type literal syntax are disabled in read/load.\n Example (will fail): (binding [*read-eval* false] (read-string \"#=(* 2 21)\"))\n\n The default binding can be controlled by the system property\n 'glojure.read.eval' System properties can be set on the command line\n like this:\n\n java -Dglojure.read.eval=false ...\n\n The system property can also be set to 'unknown' via\n -Dglojure.read.eval=unknown, in which case the default binding\n is :unknown and all reads will fail in contexts where *read-eval*\n has not been explicitly bound to either true or false. This setting\n can be a useful diagnostic tool to ensure that all of your reads\n occur in considered contexts. You can also accomplish this in a\n particular scope by binding *read-eval* to :unknown\n ", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, nil, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// *repl* -{ -v0 := lang.NewSymbol("*repl*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6288), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(6291), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, false, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// *unchecked-math* -{ -v0 := lang.NewSymbol("*unchecked-math*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.3", lang.NewKeyword("doc"), "While bound to true, compilations of +, -, *, inc, dec and the\n coercions will be done without overflow checks. While bound\n to :warn-on-boxed, same behavior as true, and a warning is emitted\n when compilation uses boxed math. Default: false.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, nil, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// *verbose-defrecords* -{ -v0 := lang.NewSymbol("*verbose-defrecords*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(37), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(37), lang.NewKeyword("end-column"), int(35), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, false, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// *warn-on-reflection* -{ -v0 := lang.NewSymbol("*warn-on-reflection*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "When set to true, the compiler will emit warnings when reflection is\n needed to resolve Java method calls or field accesses.\n\n Defaults to false.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, nil, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// + -{ -var v1 lang.FnFunc -v1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v2 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -if lang.IsTruthy(v7) { -v4 = closed2 -} else { -v4 = v3 -} -var v3 any = v4 -_ = v3 -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("seq")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("concat")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("seq")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("concat")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v2}) -v40 := lang.Apply(v31, []any{v35, v39}) -v41 := lang.Apply(v28, []any{v40}) -v42 := lang.Apply(v25, []any{v41}) -v43 := lang.Apply(v14, []any{v18, v22, v42}) -v44 := lang.Apply(v11, []any{v43}) -return v44 - case 2: -v2 := args[0] -v3 := args[1] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -if lang.IsTruthy(v8) { -v5 = closed2 -} else { -v5 = v4 -} -var v4 any = v5 -_ = v4 -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("seq")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("concat")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("list")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("list")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("list")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("seq")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("concat")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("list")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v4}) -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("list")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v2}) -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("list")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v3}) -v45 := lang.Apply(v32, []any{v36, v40, v44}) -v46 := lang.Apply(v29, []any{v45}) -v47 := lang.Apply(v26, []any{v46}) -v48 := lang.Apply(v15, []any{v19, v23, v47}) -v49 := lang.Apply(v12, []any{v48}) -return v49 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v2 := args[0] -v3 := args[1] -v4 := lang.NewList(args[2:]...) -var v6 any -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -if lang.IsTruthy(v9) { -v6 = closed2 -} else { -v6 = v5 -} -var v5 any = v6 -_ = v5 -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -var v14 lang.FnFunc -v14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v15 := args[0] -v16 := args[1] -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("concat")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v5}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v15}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v16}) -v52 := lang.Apply(v39, []any{v43, v47, v51}) -v53 := lang.Apply(v36, []any{v52}) -v54 := lang.Apply(v33, []any{v53}) -v55 := lang.Apply(v22, []any{v26, v30, v54}) -v56 := lang.Apply(v19, []any{v55}) -return v56 -}) -v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) -v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("concat")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v5}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v2}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v3}) -v52 := lang.Apply(v39, []any{v43, v47, v51}) -v53 := lang.Apply(v36, []any{v52}) -v54 := lang.Apply(v33, []any{v53}) -v55 := lang.Apply(v22, []any{v26, v30, v54}) -v56 := lang.Apply(v19, []any{v55}) -v57 := lang.Apply(v13, []any{v16, v56, v4}) -return v57 - } -}) -v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) -} -v5 := lang.Apply(v4, []any{v3, int64(1)}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v0 := lang.NewSymbol("+").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the sum of nums. (+) returns 0. Does not auto-promote\n longs, will throw on overflow. See also: +'", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(977), lang.NewKeyword("end-line"), int(977))).(*lang.Symbol) -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -return int64(0) - case 1: -v5 := args[0] -v6 := lang.Apply(lang.MustAsNumber, []any{v5}) -return v6 - case 2: -v5 := args[0] -v6 := args[1] -v7, _ := lang.FieldOrMethod(lang.Numbers, "add") -if reflect.TypeOf(v7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) -} -v8 := lang.Apply(v7, []any{v5, v6}) -return v8 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := args[0] -v6 := args[1] -v7 := lang.NewList(args[2:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("+")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("+")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v5, v6}) -v18 := lang.Apply(v10, []any{v13, v17, v7}) -return v18 - } -}) -v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v3 := ns.InternWithValue(v0, v4, true) -if v0.Meta() != nil { - v3.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// +' -{ -var v1 lang.FnFunc -v1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v2 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -if lang.IsTruthy(v7) { -v4 = closed3 -} else { -v4 = v3 -} -var v3 any = v4 -_ = v3 -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("seq")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("concat")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("seq")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("concat")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v2}) -v40 := lang.Apply(v31, []any{v35, v39}) -v41 := lang.Apply(v28, []any{v40}) -v42 := lang.Apply(v25, []any{v41}) -v43 := lang.Apply(v14, []any{v18, v22, v42}) -v44 := lang.Apply(v11, []any{v43}) -return v44 - case 2: -v2 := args[0] -v3 := args[1] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -if lang.IsTruthy(v8) { -v5 = closed3 -} else { -v5 = v4 -} -var v4 any = v5 -_ = v4 -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("seq")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("concat")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("list")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("list")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("list")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("seq")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("concat")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("list")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v4}) -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("list")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v2}) -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("list")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v3}) -v45 := lang.Apply(v32, []any{v36, v40, v44}) -v46 := lang.Apply(v29, []any{v45}) -v47 := lang.Apply(v26, []any{v46}) -v48 := lang.Apply(v15, []any{v19, v23, v47}) -v49 := lang.Apply(v12, []any{v48}) -return v49 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v2 := args[0] -v3 := args[1] -v4 := lang.NewList(args[2:]...) -var v6 any -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -if lang.IsTruthy(v9) { -v6 = closed3 -} else { -v6 = v5 -} -var v5 any = v6 -_ = v5 -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -var v14 lang.FnFunc -v14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v15 := args[0] -v16 := args[1] -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("concat")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v5}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v15}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v16}) -v52 := lang.Apply(v39, []any{v43, v47, v51}) -v53 := lang.Apply(v36, []any{v52}) -v54 := lang.Apply(v33, []any{v53}) -v55 := lang.Apply(v22, []any{v26, v30, v54}) -v56 := lang.Apply(v19, []any{v55}) -return v56 -}) -v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) -v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("concat")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v5}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v2}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v3}) -v52 := lang.Apply(v39, []any{v43, v47, v51}) -v53 := lang.Apply(v36, []any{v52}) -v54 := lang.Apply(v33, []any{v53}) -v55 := lang.Apply(v22, []any{v26, v30, v54}) -v56 := lang.Apply(v19, []any{v55}) -v57 := lang.Apply(v13, []any{v16, v56, v4}) -return v57 - } -}) -v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) -} -v5 := lang.Apply(v4, []any{v3, int64(1)}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v0 := lang.NewSymbol("+'").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the sum of nums. (+') returns 0. Supports arbitrary precision.\n See also: +", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(965), lang.NewKeyword("end-line"), int(965))).(*lang.Symbol) -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -return int64(0) - case 1: -v5 := args[0] -v6 := lang.Apply(lang.MustAsNumber, []any{v5}) -return v6 - case 2: -v5 := args[0] -v6 := args[1] -v7, _ := lang.FieldOrMethod(lang.Numbers, "addP") -if reflect.TypeOf(v7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("addP is not a function"))) -} -v8 := lang.Apply(v7, []any{v5, v6}) -return v8 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := args[0] -v6 := args[1] -v7 := lang.NewList(args[2:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("+'")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("+'")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v5, v6}) -v18 := lang.Apply(v10, []any{v13, v17, v7}) -return v18 - } -}) -v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v3 := ns.InternWithValue(v0, v4, true) -if v0.Meta() != nil { - v3.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// - -{ -var v1 lang.FnFunc -v1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v2 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -if lang.IsTruthy(v7) { -v4 = closed4 -} else { -v4 = v3 -} -var v3 any = v4 -_ = v3 -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("seq")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("concat")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("seq")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("concat")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v2}) -v40 := lang.Apply(v31, []any{v35, v39}) -v41 := lang.Apply(v28, []any{v40}) -v42 := lang.Apply(v25, []any{v41}) -v43 := lang.Apply(v14, []any{v18, v22, v42}) -v44 := lang.Apply(v11, []any{v43}) -return v44 - case 2: -v2 := args[0] -v3 := args[1] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -if lang.IsTruthy(v8) { -v5 = closed4 -} else { -v5 = v4 -} -var v4 any = v5 -_ = v4 -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("seq")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("concat")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("list")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("list")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("list")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("seq")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("concat")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("list")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v4}) -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("list")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v2}) -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("list")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v3}) -v45 := lang.Apply(v32, []any{v36, v40, v44}) -v46 := lang.Apply(v29, []any{v45}) -v47 := lang.Apply(v26, []any{v46}) -v48 := lang.Apply(v15, []any{v19, v23, v47}) -v49 := lang.Apply(v12, []any{v48}) -return v49 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v2 := args[0] -v3 := args[1] -v4 := lang.NewList(args[2:]...) -var v6 any -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -if lang.IsTruthy(v9) { -v6 = closed4 -} else { -v6 = v5 -} -var v5 any = v6 -_ = v5 -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -var v14 lang.FnFunc -v14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v15 := args[0] -v16 := args[1] -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("concat")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v5}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v15}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v16}) -v52 := lang.Apply(v39, []any{v43, v47, v51}) -v53 := lang.Apply(v36, []any{v52}) -v54 := lang.Apply(v33, []any{v53}) -v55 := lang.Apply(v22, []any{v26, v30, v54}) -v56 := lang.Apply(v19, []any{v55}) -return v56 -}) -v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) -v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("concat")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v5}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v2}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v3}) -v52 := lang.Apply(v39, []any{v43, v47, v51}) -v53 := lang.Apply(v36, []any{v52}) -v54 := lang.Apply(v33, []any{v53}) -v55 := lang.Apply(v22, []any{v26, v30, v54}) -v56 := lang.Apply(v19, []any{v55}) -v57 := lang.Apply(v13, []any{v16, v56, v4}) -return v57 - } -}) -v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) -} -v5 := lang.Apply(v4, []any{v3, int64(0)}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v0 := lang.NewSymbol("-").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "If no ys are supplied, returns the negation of x, else subtracts\n the ys from x and returns the result. Does not auto-promote\n longs, will throw on overflow. See also: -'", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1036), lang.NewKeyword("end-line"), int(1036))).(*lang.Symbol) -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v5 := args[0] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("*")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{int64(-1), v5}) -return v9 - case 2: -v5 := args[0] -v6 := args[1] -v7, _ := lang.FieldOrMethod(lang.Numbers, "minus") -if reflect.TypeOf(v7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("minus is not a function"))) -} -v8 := lang.Apply(v7, []any{v5, v6}) -return v8 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := args[0] -v6 := args[1] -v7 := lang.NewList(args[2:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("-")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("-")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v5, v6}) -v18 := lang.Apply(v10, []any{v13, v17, v7}) -return v18 - } -}) -v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v3 := ns.InternWithValue(v0, v4, true) -if v0.Meta() != nil { - v3.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// -' -{ -var v1 lang.FnFunc -v1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v2 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -if lang.IsTruthy(v7) { -v4 = closed5 -} else { -v4 = v3 -} -var v3 any = v4 -_ = v3 -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("seq")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("concat")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("seq")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("concat")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v2}) -v40 := lang.Apply(v31, []any{v35, v39}) -v41 := lang.Apply(v28, []any{v40}) -v42 := lang.Apply(v25, []any{v41}) -v43 := lang.Apply(v14, []any{v18, v22, v42}) -v44 := lang.Apply(v11, []any{v43}) -return v44 - case 2: -v2 := args[0] -v3 := args[1] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -if lang.IsTruthy(v8) { -v5 = closed5 -} else { -v5 = v4 -} -var v4 any = v5 -_ = v4 -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("seq")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("concat")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("list")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("list")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("list")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("seq")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("concat")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("list")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v4}) -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("list")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v2}) -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("list")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v3}) -v45 := lang.Apply(v32, []any{v36, v40, v44}) -v46 := lang.Apply(v29, []any{v45}) -v47 := lang.Apply(v26, []any{v46}) -v48 := lang.Apply(v15, []any{v19, v23, v47}) -v49 := lang.Apply(v12, []any{v48}) -return v49 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v2 := args[0] -v3 := args[1] -v4 := lang.NewList(args[2:]...) -var v6 any -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -if lang.IsTruthy(v9) { -v6 = closed5 -} else { -v6 = v5 -} -var v5 any = v6 -_ = v5 -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -var v14 lang.FnFunc -v14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v15 := args[0] -v16 := args[1] -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("concat")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v5}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v15}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v16}) -v52 := lang.Apply(v39, []any{v43, v47, v51}) -v53 := lang.Apply(v36, []any{v52}) -v54 := lang.Apply(v33, []any{v53}) -v55 := lang.Apply(v22, []any{v26, v30, v54}) -v56 := lang.Apply(v19, []any{v55}) -return v56 -}) -v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) -v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("concat")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v5}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v2}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v3}) -v52 := lang.Apply(v39, []any{v43, v47, v51}) -v53 := lang.Apply(v36, []any{v52}) -v54 := lang.Apply(v33, []any{v53}) -v55 := lang.Apply(v22, []any{v26, v30, v54}) -v56 := lang.Apply(v19, []any{v55}) -v57 := lang.Apply(v13, []any{v16, v56, v4}) -return v57 - } -}) -v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) -} -v5 := lang.Apply(v4, []any{v3, int64(0)}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v0 := lang.NewSymbol("-'").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "If no ys are supplied, returns the negation of x, else subtracts\n the ys from x and returns the result. Supports arbitrary precision.\n See also: -", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1024), lang.NewKeyword("end-line"), int(1024))).(*lang.Symbol) -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v5 := args[0] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("*'")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{int64(-1), v5}) -return v9 - case 2: -v5 := args[0] -v6 := args[1] -v7, _ := lang.FieldOrMethod(lang.Numbers, "minusP") -if reflect.TypeOf(v7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("minusP is not a function"))) -} -v8 := lang.Apply(v7, []any{v5, v6}) -return v8 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := args[0] -v6 := args[1] -v7 := lang.NewList(args[2:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("-'")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("-'")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v5, v6}) -v18 := lang.Apply(v10, []any{v13, v17, v7}) -return v18 - } -}) -v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v3 := ns.InternWithValue(v0, v4, true) -if v0.Meta() != nil { - v3.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// -> -{ -v0 := lang.NewSymbol("->").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "Threads the expr through the forms. Inserts x as the\n second item in the first form, making a list of it if it is not a\n list already. If there are more forms, inserts the first form as the\n second item in second form, etc.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1675), lang.NewKeyword("end-line"), int(1675))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -var v7 any = v7 -_ = v7 -var v8 any = v8 -_ = v8 -var v9 any -for { -var v10 any -if lang.IsTruthy(v8) { -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("first")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v8}) -var v11 any = v15 -_ = v11 -var v17 any -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("seq?")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v20, []any{v11}) -if lang.IsTruthy(v21) { -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("with-meta")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("seq")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("concat")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("first")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.Apply(v36, []any{v11}) -v38 := lang.Apply(v33, []any{v37}) -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("list")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) -} -v41 := v40.Get() -v42 := lang.Apply(v41, []any{v7}) -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("next")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.Apply(v45, []any{v11}) -v47 := lang.Apply(v30, []any{v38, v42, v46}) -v48 := lang.Apply(v27, []any{v47}) -v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v50 := v49.FindInternedVar(lang.NewSymbol("meta")) -if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) -} -v51 := v50.Get() -v52 := lang.Apply(v51, []any{v11}) -v53 := lang.Apply(v24, []any{v48, v52}) -v17 = v53 -} else { -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("list")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) -} -v56 := v55.Get() -v57 := lang.Apply(v56, []any{v11, v7}) -v17 = v57 -} -var v16 any = v17 -_ = v16 -var v59 any = v16 -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("next")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) -} -v63 := v62.Get() -v64 := lang.Apply(v63, []any{v8}) -var v60 any = v64 -v7 = v59 -v8 = v60 -continue -} else { -v10 = v7 -} -v9 = v10 - break -} -return v9 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// ->> -{ -v0 := lang.NewSymbol("->>").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "Threads the expr through the forms. Inserts x as the\n last item in the first form, making a list of it if it is not a\n list already. If there are more forms, inserts the first form as the\n last item in second form, etc.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1691), lang.NewKeyword("end-line"), int(1691))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -var v7 any = v7 -_ = v7 -var v8 any = v8 -_ = v8 -var v9 any -for { -var v10 any -if lang.IsTruthy(v8) { -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("first")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v8}) -var v11 any = v15 -_ = v11 -var v17 any -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("seq?")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v20, []any{v11}) -if lang.IsTruthy(v21) { -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("with-meta")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("seq")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("concat")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("first")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.Apply(v36, []any{v11}) -v38 := lang.Apply(v33, []any{v37}) -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("next")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) -} -v41 := v40.Get() -v42 := lang.Apply(v41, []any{v11}) -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("list")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.Apply(v45, []any{v7}) -v47 := lang.Apply(v30, []any{v38, v42, v46}) -v48 := lang.Apply(v27, []any{v47}) -v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v50 := v49.FindInternedVar(lang.NewSymbol("meta")) -if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) -} -v51 := v50.Get() -v52 := lang.Apply(v51, []any{v11}) -v53 := lang.Apply(v24, []any{v48, v52}) -v17 = v53 -} else { -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("list")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) -} -v56 := v55.Get() -v57 := lang.Apply(v56, []any{v11, v7}) -v17 = v57 -} -var v16 any = v17 -_ = v16 -var v59 any = v16 -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("next")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) -} -v63 := v62.Get() -v64 := lang.Apply(v63, []any{v8}) -var v60 any = v64 -v7 = v59 -v8 = v60 -continue -} else { -v10 = v7 -} -v9 = v10 - break -} -return v9 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// -protocols -{ -v0 := lang.NewSymbol("-protocols").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("doc"), "Private store of protocols. Go's reflection capabilities\n don't yet support a native interface-based implementation, so\n protocols are implemented in Glojure as maps from type to protocol\n method implementations.", lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(21), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(26), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v3 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("coll-reduce"), nil), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("coll-reduce"), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("f"), lang.NewSymbol("val")))))) -v4 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("internal-reduce"), nil), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("internal-reduce"), lang.NewVector(lang.NewSymbol("seq"), lang.NewSymbol("f"), lang.NewSymbol("start")))))) -v5 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("kv-reduce"), nil), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("kv-reduce"), lang.NewVector(lang.NewSymbol("amap"), lang.NewSymbol("f"), lang.NewSymbol("init")))))) -v6 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("datafy"), nil), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("datafy"), lang.NewVector(lang.NewSymbol("o")), "return a representation of o as data (default identity)")))) -v7 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("nav"), nil), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("nav"), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("k"), lang.NewSymbol("v")), "return (possibly transformed) v in the context of coll and k (a key/index or nil),\ndefaults to returning v.")))) -v8 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("make-reader"), nil, lang.NewKeyword("make-writer"), nil, lang.NewKeyword("make-input-stream"), nil, lang.NewKeyword("make-output-stream"), nil), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("make-reader"), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("opts")), "Creates an io.Reader. See also IOFactory docs."), lang.NewList(lang.NewSymbol("make-writer"), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("opts")), "Creates an io.Reader. See also IOFactory docs."), lang.NewList(lang.NewSymbol("make-input-stream"), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("opts")), "Creates a BufferedInputStream. See also IOFactory docs."), lang.NewList(lang.NewSymbol("make-output-stream"), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("opts")), "Creates a BufferedOutputStream. See also IOFactory docs.")))) -v2 := lang.NewAtom(lang.NewMap(lang.NewSymbol("CollReduce"), v3, lang.NewSymbol("InternalReduce"), v4, lang.NewSymbol("IKVReduce"), v5, lang.NewSymbol("Datafiable"), v6, lang.NewSymbol("Navigable"), v7, lang.NewSymbol("IOFactory"), v8)) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// .. -{ -v0 := lang.NewSymbol("..").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("form")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("form"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "form => fieldName-symbol or (instanceMethodName-symbol args*)\n\n Expands into a member access (.) of the first member on the first\n argument, followed by the next member on the result, etc. For\n instance:\n\n (.. System (getProperties) (get \"os.name\"))\n\n expands to:\n\n (. (. System (getProperties)) (get \"os.name\"))\n\n but is easier to write, read, and understand.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1657), lang.NewKeyword("end-line"), int(1657))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 4: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("seq")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("concat")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("list")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{lang.NewSymbol(".")}) -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("list")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v5}) -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("list")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v6}) -v25 := lang.Apply(v12, []any{v16, v20, v24}) -v26 := lang.Apply(v9, []any{v25}) -return v26 - default: - if len(args) < 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := lang.NewList(args[4:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("seq")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("concat")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("..")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol(".")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v5}) -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("list")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v6}) -v39 := lang.Apply(v26, []any{v30, v34, v38}) -v40 := lang.Apply(v23, []any{v39}) -v41 := lang.Apply(v20, []any{v40}) -v42 := lang.Apply(v13, []any{v17, v41, v7}) -v43 := lang.Apply(v10, []any{v42}) -return v43 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// / -{ -var v1 lang.FnFunc -v1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v2 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -if lang.IsTruthy(v7) { -v4 = closed6 -} else { -v4 = v3 -} -var v3 any = v4 -_ = v3 -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("seq")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("concat")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("seq")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("concat")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v2}) -v40 := lang.Apply(v31, []any{v35, v39}) -v41 := lang.Apply(v28, []any{v40}) -v42 := lang.Apply(v25, []any{v41}) -v43 := lang.Apply(v14, []any{v18, v22, v42}) -v44 := lang.Apply(v11, []any{v43}) -return v44 - case 2: -v2 := args[0] -v3 := args[1] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -if lang.IsTruthy(v8) { -v5 = closed6 -} else { -v5 = v4 -} -var v4 any = v5 -_ = v4 -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("seq")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("concat")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("list")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("list")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("list")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("seq")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("concat")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("list")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v4}) -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("list")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v2}) -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("list")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v3}) -v45 := lang.Apply(v32, []any{v36, v40, v44}) -v46 := lang.Apply(v29, []any{v45}) -v47 := lang.Apply(v26, []any{v46}) -v48 := lang.Apply(v15, []any{v19, v23, v47}) -v49 := lang.Apply(v12, []any{v48}) -return v49 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v2 := args[0] -v3 := args[1] -v4 := lang.NewList(args[2:]...) -var v6 any -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -if lang.IsTruthy(v9) { -v6 = closed6 -} else { -v6 = v5 -} -var v5 any = v6 -_ = v5 -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -var v14 lang.FnFunc -v14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v15 := args[0] -v16 := args[1] -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("concat")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v5}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v15}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v16}) -v52 := lang.Apply(v39, []any{v43, v47, v51}) -v53 := lang.Apply(v36, []any{v52}) -v54 := lang.Apply(v33, []any{v53}) -v55 := lang.Apply(v22, []any{v26, v30, v54}) -v56 := lang.Apply(v19, []any{v55}) -return v56 -}) -v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) -v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("concat")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v5}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v2}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v3}) -v52 := lang.Apply(v39, []any{v43, v47, v51}) -v53 := lang.Apply(v36, []any{v52}) -v54 := lang.Apply(v33, []any{v53}) -v55 := lang.Apply(v22, []any{v26, v30, v54}) -v56 := lang.Apply(v19, []any{v55}) -v57 := lang.Apply(v13, []any{v16, v56, v4}) -return v57 - } -}) -v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) -} -v5 := lang.Apply(v4, []any{v3, int64(1)}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v0 := lang.NewSymbol("/").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "If no denominators are supplied, returns 1/numerator,\n else returns numerator divided by all of the denominators.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1013), lang.NewKeyword("end-line"), int(1013))).(*lang.Symbol) -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v5 := args[0] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("/")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{int64(1), v5}) -return v9 - case 2: -v5 := args[0] -v6 := args[1] -v7, _ := lang.FieldOrMethod(lang.Numbers, "divide") -if reflect.TypeOf(v7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("divide is not a function"))) -} -v8 := lang.Apply(v7, []any{v5, v6}) -return v8 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := args[0] -v6 := args[1] -v7 := lang.NewList(args[2:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("/")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("/")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v5, v6}) -v18 := lang.Apply(v10, []any{v13, v17, v7}) -return v18 - } -}) -v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v3 := ns.InternWithValue(v0, v4, true) -if v0.Meta() != nil { - v3.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// < -{ -var v1 lang.FnFunc -{ // function <__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("concat")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("list")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("seq")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("concat")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("list")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/lt")}) -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v4}) -v40 := lang.Apply(v27, []any{v31, v35, v39}) -v41 := lang.Apply(v24, []any{v40}) -v42 := lang.Apply(v21, []any{v41}) -v43 := lang.Apply(v10, []any{v14, v18, v42}) -v44 := lang.Apply(v7, []any{v43}) -return v44 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("<").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns non-nil if nums are in monotonically increasing order,\n otherwise false.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(893), lang.NewKeyword("end-line"), int(893))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v4 := args[0] -return true - case 2: -v4 := args[0] -v5 := args[1] -v6, _ := lang.FieldOrMethod(lang.Numbers, "lt") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("lt is not a function"))) -} -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6 := lang.NewList(args[2:]...) -recur_loop_150: -var v7 any -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("<")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v4, v5}) -if lang.IsTruthy(v11) { -var v12 any -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("next")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v6}) -if lang.IsTruthy(v16) { -var v17 any = v5 -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("first")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v6}) -var v18 any = v22 -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("next")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v6}) -var v23 any = v27 -v4 = v17 -v5 = v18 -v6 = v23 -goto recur_loop_150 -} else { -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("<")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("first")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v6}) -v35 := lang.Apply(v30, []any{v5, v34}) -v12 = v35 -} -v7 = v12 -} else { -v7 = false -} -return v7 - } -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// <= -{ -var v1 lang.FnFunc -{ // function <=__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("concat")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("list")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("seq")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("concat")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("list")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/lte")}) -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v4}) -v40 := lang.Apply(v27, []any{v31, v35, v39}) -v41 := lang.Apply(v24, []any{v40}) -v42 := lang.Apply(v21, []any{v41}) -v43 := lang.Apply(v10, []any{v14, v18, v42}) -v44 := lang.Apply(v7, []any{v43}) -return v44 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("<=").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns non-nil if nums are in monotonically non-decreasing order,\n otherwise false.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1048), lang.NewKeyword("end-line"), int(1048))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v4 := args[0] -return true - case 2: -v4 := args[0] -v5 := args[1] -v6, _ := lang.FieldOrMethod(lang.Numbers, "lte") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("lte is not a function"))) -} -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6 := lang.NewList(args[2:]...) -recur_loop_194: -var v7 any -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("<=")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v4, v5}) -if lang.IsTruthy(v11) { -var v12 any -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("next")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v6}) -if lang.IsTruthy(v16) { -var v17 any = v5 -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("first")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v6}) -var v18 any = v22 -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("next")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v6}) -var v23 any = v27 -v4 = v17 -v5 = v18 -v6 = v23 -goto recur_loop_194 -} else { -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("<=")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("first")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v6}) -v35 := lang.Apply(v30, []any{v5, v34}) -v12 = v35 -} -v7 = v12 -} else { -v7 = false -} -return v7 - } -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// = -{ -var v1 lang.FnFunc -{ // function =__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("concat")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("list")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol("glojure.lang.Util")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{lang.NewSymbol("glojure.core/equiv")}) -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{v3}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{v4}) -v31 := lang.Apply(v10, []any{v14, v18, v22, v26, v30}) -v32 := lang.Apply(v7, []any{v31}) -return v32 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("=").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Equality. Returns true if x equals y, false if not. Same as\n Java x.equals(y) except it also works for nil, and compares\n numbers and collections in a type-independent manner. Clojure's immutable data\n structures define equals() (and thus =) as a value, not an identity,\n comparison.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(776), lang.NewKeyword("end-line"), int(776))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v4 := args[0] -return true - case 2: -v4 := args[0] -v5 := args[1] -v6 := lang.Apply(lang.Equiv, []any{v4, v5}) -return v6 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6 := lang.NewList(args[2:]...) -recur_loop_126: -var v7 any -v8 := lang.Apply(lang.Equiv, []any{v4, v5}) -if lang.IsTruthy(v8) { -var v9 any -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("next")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{v6}) -if lang.IsTruthy(v13) { -var v14 any = v5 -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("first")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v6}) -var v15 any = v19 -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("next")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v6}) -var v20 any = v24 -v4 = v14 -v5 = v15 -v6 = v20 -goto recur_loop_126 -} else { -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("first")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.Apply(v27, []any{v6}) -v29 := lang.Apply(lang.Equiv, []any{v5, v28}) -v9 = v29 -} -v7 = v9 -} else { -v7 = false -} -return v7 - } -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// == -{ -var v1 lang.FnFunc -{ // function ==__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("concat")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("list")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("seq")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("concat")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("list")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/equiv")}) -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v4}) -v40 := lang.Apply(v27, []any{v31, v35, v39}) -v41 := lang.Apply(v24, []any{v40}) -v42 := lang.Apply(v21, []any{v41}) -v43 := lang.Apply(v10, []any{v14, v18, v42}) -v44 := lang.Apply(v7, []any{v43}) -return v44 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("==").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns non-nil if nums all have the equivalent\n value (type-independent), otherwise false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1093), lang.NewKeyword("end-line"), int(1093))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v4 := args[0] -return true - case 2: -v4 := args[0] -v5 := args[1] -v6, _ := lang.FieldOrMethod(lang.Numbers, "equiv") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("equiv is not a function"))) -} -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6 := lang.NewList(args[2:]...) -recur_loop_206: -var v7 any -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("==")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v4, v5}) -if lang.IsTruthy(v11) { -var v12 any -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("next")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v6}) -if lang.IsTruthy(v16) { -var v17 any = v5 -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("first")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v6}) -var v18 any = v22 -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("next")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v6}) -var v23 any = v27 -v4 = v17 -v5 = v18 -v6 = v23 -goto recur_loop_206 -} else { -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("==")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("first")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v6}) -v35 := lang.Apply(v30, []any{v5, v34}) -v12 = v35 -} -v7 = v12 -} else { -v7 = false -} -return v7 - } -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// > -{ -var v1 lang.FnFunc -{ // function >__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("concat")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("list")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("seq")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("concat")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("list")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/gt")}) -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v4}) -v40 := lang.Apply(v27, []any{v31, v35, v39}) -v41 := lang.Apply(v24, []any{v40}) -v42 := lang.Apply(v21, []any{v41}) -v43 := lang.Apply(v10, []any{v14, v18, v42}) -v44 := lang.Apply(v7, []any{v43}) -return v44 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol(">").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns non-nil if nums are in monotonically decreasing order,\n otherwise false.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1063), lang.NewKeyword("end-line"), int(1063))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v4 := args[0] -return true - case 2: -v4 := args[0] -v5 := args[1] -v6, _ := lang.FieldOrMethod(lang.Numbers, "gt") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("gt is not a function"))) -} -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6 := lang.NewList(args[2:]...) -recur_loop_198: -var v7 any -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol(">")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v4, v5}) -if lang.IsTruthy(v11) { -var v12 any -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("next")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v6}) -if lang.IsTruthy(v16) { -var v17 any = v5 -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("first")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v6}) -var v18 any = v22 -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("next")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v6}) -var v23 any = v27 -v4 = v17 -v5 = v18 -v6 = v23 -goto recur_loop_198 -} else { -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol(">")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("first")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v6}) -v35 := lang.Apply(v30, []any{v5, v34}) -v12 = v35 -} -v7 = v12 -} else { -v7 = false -} -return v7 - } -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// >0? -{ -v0 := lang.NewSymbol(">0?").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(963), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(963), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) -} -v5 := lang.Apply(v4, []any{v3, int64(0)}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// >1? -{ -v0 := lang.NewSymbol(">1?").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(962), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(962), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) -} -v5 := lang.Apply(v4, []any{v3, int64(1)}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// >= -{ -var v1 lang.FnFunc -{ // function >=__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("concat")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("list")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("seq")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("concat")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("list")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/gte")}) -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v4}) -v40 := lang.Apply(v27, []any{v31, v35, v39}) -v41 := lang.Apply(v24, []any{v40}) -v42 := lang.Apply(v21, []any{v41}) -v43 := lang.Apply(v10, []any{v14, v18, v42}) -v44 := lang.Apply(v7, []any{v43}) -return v44 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol(">=").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns non-nil if nums are in monotonically non-increasing order,\n otherwise false.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1078), lang.NewKeyword("end-line"), int(1078))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v4 := args[0] -return true - case 2: -v4 := args[0] -v5 := args[1] -v6, _ := lang.FieldOrMethod(lang.Numbers, "gte") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("gte is not a function"))) -} -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6 := lang.NewList(args[2:]...) -recur_loop_202: -var v7 any -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol(">=")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v4, v5}) -if lang.IsTruthy(v11) { -var v12 any -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("next")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v6}) -if lang.IsTruthy(v16) { -var v17 any = v5 -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("first")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v6}) -var v18 any = v22 -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("next")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v6}) -var v23 any = v27 -v4 = v17 -v5 = v18 -v6 = v23 -goto recur_loop_202 -} else { -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol(">=")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("first")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v6}) -v35 := lang.Apply(v30, []any{v5, v34}) -v12 = v35 -} -v7 = v12 -} else { -v7 = false -} -return v7 - } -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// NaN? -{ -var v1 lang.FnFunc -{ // function NaN?__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol("math.IsNaN")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v3}) -v18 := lang.Apply(v9, []any{v13, v17}) -v19 := lang.Apply(v6, []any{v18}) -return v19 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("NaN?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns true if num is NaN, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)), lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7968), lang.NewKeyword("end-line"), int(7968))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := lang.Apply(math3.IsNaN, []any{v4}) -return v5 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// StackTraceElement->vec -{ -v0 := lang.NewSymbol("StackTraceElement->vec").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"))), lang.NewKeyword("doc"), "Constructs a data representation for a StackTraceElement: [class method file line]", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(436), lang.NewKeyword("end-line"), int(436))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("symbol")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7, ok := lang.FieldOrMethod(v3, "getClassName") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getClassName"))) -} -var v8 any -switch reflect.TypeOf(v7).Kind() { -case reflect.Func: - v8 = lang.Apply(v7, nil) -default: - v8 = v7 -} -v9 := lang.Apply(v6, []any{v8}) -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("symbol")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13, ok := lang.FieldOrMethod(v3, "getMethodName") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getMethodName"))) -} -var v14 any -switch reflect.TypeOf(v13).Kind() { -case reflect.Func: - v14 = lang.Apply(v13, nil) -default: - v14 = v13 -} -v15 := lang.Apply(v12, []any{v14}) -v16, ok := lang.FieldOrMethod(v3, "getFileName") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getFileName"))) -} -var v17 any -switch reflect.TypeOf(v16).Kind() { -case reflect.Func: - v17 = lang.Apply(v16, nil) -default: - v17 = v16 -} -v18, ok := lang.FieldOrMethod(v3, "getLineNumber") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getLineNumber"))) -} -var v19 any -switch reflect.TypeOf(v18).Kind() { -case reflect.Func: - v19 = lang.Apply(v18, nil) -default: - v19 = v18 -} -v20 := lang.NewVector(v9, v15, v17, v19) -v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(440), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(440), lang.NewKeyword("end-column"), int(94)) -v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v22 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// Throwable->map -{ -v0 := lang.NewSymbol("Throwable->map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"))), lang.NewKeyword("doc"), "Constructs a data representation for a Throwable with keys:\n :cause - root cause message\n :phase - error phase\n :via - cause chain, with cause keys:\n :type - exception class symbol\n :message - exception message\n :data - ex-data\n :at - top stack element\n :trace - root cause stack elements", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(442), lang.NewKeyword("end-line"), int(442))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -var v5 lang.FnFunc -v5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v6 := args[0] -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("merge")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("symbol")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("class")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v6}) -v17, ok := lang.FieldOrMethod(v16, "Name") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v16, "Name"))) -} -var v18 any -switch reflect.TypeOf(v17).Kind() { -case reflect.Func: - v18 = lang.Apply(v17, nil) -default: - v18 = v17 -} -v19 := lang.Apply(v12, []any{v18}) -v20 := lang.NewMap(lang.NewKeyword("type"), v19) -v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(455), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(455), lang.NewKeyword("end-column"), int(56)) -v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v24, ok := lang.FieldOrMethod(v6, "getLocalizedMessage") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "getLocalizedMessage"))) -} -var v25 any -switch reflect.TypeOf(v24).Kind() { -case reflect.Func: - v25 = lang.Apply(v24, nil) -default: - v25 = v24 -} -var v23 any = v25 -_ = v23 -var v27 any -if lang.IsTruthy(v23) { -var v28 any = v23 -_ = v28 -v30 := lang.NewMap(lang.NewKeyword("message"), v28) -v31 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(457), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(457), lang.NewKeyword("end-column"), int(33)) -v32, err := lang.WithMeta(v30, v31.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v27 = v32 -} else { -v27 = nil -} -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("ex-data")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v6}) -var v23 any = v27 -_ = v23 -var v29 any -if lang.IsTruthy(v23) { -var v30 any = v23 -_ = v30 -v32 := lang.NewMap(lang.NewKeyword("data"), v30) -v33 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(459), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(459), lang.NewKeyword("end-column"), int(29)) -v34, err := lang.WithMeta(v32, v33.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v29 = v34 -} else { -v29 = nil -} -v24, ok := lang.FieldOrMethod(v6, "getStackTrace") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "getStackTrace"))) -} -var v25 any -switch reflect.TypeOf(v24).Kind() { -case reflect.Func: - v25 = lang.Apply(v24, nil) -default: - v25 = v24 -} -var v23 any = v25 -_ = v23 -var v27 any -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("pos?")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("alength")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v23}) -v35 := lang.Apply(v30, []any{v34}) -if lang.IsTruthy(v35) { -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("StackTraceElement->vec")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("aget")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) -} -v41 := v40.Get() -v42 := lang.Apply(v41, []any{v23, int64(0)}) -v43 := lang.Apply(v38, []any{v42}) -v44 := lang.NewMap(lang.NewKeyword("at"), v43) -v45 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(462), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(462), lang.NewKeyword("end-column"), int(63)) -v46, err := lang.WithMeta(v44, v45.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v27 = v46 -} else { -v27 = nil -} -v23 := lang.Apply(v9, []any{v22, v27, v29, v27}) -return v23 -}) -v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(454), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(462), lang.NewKeyword("end-column"), int(67)) -v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v4 any = v7 -_ = v4 -v10 := lang.NewVector() -v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(463), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(463), lang.NewKeyword("end-column"), int(25)) -v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v9 any = v12 -_ = v9 -var v13 any = v3 -_ = v13 -var v14 any -for { -var v15 any -if lang.IsTruthy(v13) { -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("conj")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v9, v13}) -var v16 any = v20 -v22, ok := lang.FieldOrMethod(v13, "getCause") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v13, "getCause"))) -} -var v23 any -switch reflect.TypeOf(v22).Kind() { -case reflect.Func: - v23 = lang.Apply(v22, nil) -default: - v23 = v22 -} -var v21 any = v23 -v9 = v16 -v13 = v21 -continue -} else { -v15 = v9 -} -v14 = v15 - break -} -var v8 any = v14 -_ = v8 -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("peek")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{v8}) -var v9 any = v13 -_ = v9 -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("merge")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("vec")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("map")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v4, v8}) -v25 := lang.Apply(v20, []any{v24}) -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("vec")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("map")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("StackTraceElement->vec")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -var v35 any = v9 -_ = v35 -var v37 any -if lang.IsTruthy(v35) { -v37 = v35 -} else { -v37 = v3 -} -v35, ok := lang.FieldOrMethod(v37, "getStackTrace") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v37, "getStackTrace"))) -} -var v36 any -switch reflect.TypeOf(v35).Kind() { -case reflect.Func: - v36 = lang.Apply(v35, nil) -default: - v36 = v35 -} -v37 := lang.Apply(v31, []any{v34, v36}) -v38 := lang.Apply(v28, []any{v37}) -v39 := lang.NewMap(lang.NewKeyword("via"), v25, lang.NewKeyword("trace"), v38) -v40 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(468), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(470), lang.NewKeyword("end-column"), int(111)) -v41, err := lang.WithMeta(v39, v40.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v43, ok := lang.FieldOrMethod(v9, "getLocalizedMessage") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v9, "getLocalizedMessage"))) -} -var v44 any -switch reflect.TypeOf(v43).Kind() { -case reflect.Func: - v44 = lang.Apply(v43, nil) -default: - v44 = v43 -} -var v42 any = v44 -_ = v42 -var v46 any -if lang.IsTruthy(v42) { -var v47 any = v42 -_ = v47 -v49 := lang.NewMap(lang.NewKeyword("cause"), v47) -v50 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(472), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(472), lang.NewKeyword("end-column"), int(25)) -v51, err := lang.WithMeta(v49, v50.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v46 = v51 -} else { -v46 = nil -} -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("ex-data")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.Apply(v45, []any{v9}) -var v42 any = v46 -_ = v42 -var v48 any -if lang.IsTruthy(v42) { -var v49 any = v42 -_ = v49 -v51 := lang.NewMap(lang.NewKeyword("data"), v49) -v52 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(474), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(474), lang.NewKeyword("end-column"), int(20)) -v53, err := lang.WithMeta(v51, v52.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v48 = v53 -} else { -v48 = nil -} -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("ex-data")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.Apply(v45, []any{v3}) -v47 := lang.Apply(lang.NewKeyword("glojure.error/phase"), []any{v46}) -var v42 any = v47 -_ = v42 -var v49 any -if lang.IsTruthy(v42) { -var v50 any = v42 -_ = v50 -v52 := lang.NewMap(lang.NewKeyword("phase"), v50) -v53 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(476), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(476), lang.NewKeyword("end-column"), int(22)) -v54, err := lang.WithMeta(v52, v53.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v49 = v54 -} else { -v49 = nil -} -v42 := lang.Apply(v17, []any{v41, v46, v48, v49}) -return v42 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// abs -{ -var v1 lang.FnFunc -{ // function abs__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Abs")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v3}) -v18 := lang.Apply(v9, []any{v13, v17}) -v19 := lang.Apply(v6, []any{v18}) -return v19 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("abs").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the absolute value of a.\n If a is Long/MIN_VALUE => Long/MIN_VALUE\n If a is a double and zero => +0.0\n If a is a double and ##Inf or ##-Inf => ##Inf\n If a is a double and ##NaN => ##NaN", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)), lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1128), lang.NewKeyword("end-line"), int(1128))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := lang.Apply(lang.Abs, []any{v4}) -return v5 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// accessor -{ -v0 := lang.NewSymbol("accessor").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("key"))), lang.NewKeyword("doc"), "Returns a fn that, given an instance of a structmap with the basis,\n returns the value at the key. The key must be in the basis. The\n returned function should be (slightly) more efficient than using\n get, but such use of accessors should be limited to known\n performance-critical areas.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4070), lang.NewKeyword("end-line"), int(4070))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5, _ := lang.FieldOrMethod(glojure.lang4.PersistentStructMap, "getAccessor") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("getAccessor is not a function"))) -} -v6 := lang.Apply(v5, []any{v3, v4}) -return v6 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// aclone -{ -var v1 lang.FnFunc -{ // function aclone__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/Aclone")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v3}) -v35 := lang.Apply(v26, []any{v30, v34}) -v36 := lang.Apply(v23, []any{v35}) -v37 := lang.Apply(v20, []any{v36}) -v38 := lang.Apply(v9, []any{v13, v17, v37}) -v39 := lang.Apply(v6, []any{v38}) -return v39 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("aclone").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns a clone of the Java array. Works on arrays of known\n types.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3904), lang.NewKeyword("end-line"), int(3904))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5, _ := lang.FieldOrMethod(runtime5.RT, "Aclone") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Aclone is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// add-classpath -{ -v0 := lang.NewSymbol("add-classpath").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("url"))), lang.NewKeyword("doc"), "DEPRECATED \n\n Adds the url (String or URL object) to the classpath per\n URLClassLoader.addURL", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("deprecated"), "1.1", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5176), lang.NewKeyword("end-line"), int(5176))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("println")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{"WARNING: add-classpath is deprecated"}) -_ = v7 -v8 := lang.Apply(nil, []any{v3}) -return v8 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// add-doc-and-meta -{ -v0 := lang.NewSymbol("add-doc-and-meta").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("docstring"), lang.NewSymbol("meta"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(26), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6400), lang.NewKeyword("end-line"), int(6400), lang.NewKeyword("private"), true)).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 5 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := args[4] -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("seq")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("concat")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("glojure.core/alter-meta!")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("var")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v5}) -v35 := lang.Apply(v26, []any{v30, v34}) -v36 := lang.Apply(v23, []any{v35}) -v37 := lang.Apply(v20, []any{v36}) -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("list")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.Apply(v40, []any{lang.NewSymbol("glojure.core/merge")}) -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("list")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) -} -v44 := v43.Get() -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("seq")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("concat")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v52 := v51.FindInternedVar(lang.NewSymbol("list")) -if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) -} -v53 := v52.Get() -v54 := lang.Apply(v53, []any{lang.NewSymbol("glojure.core/assoc")}) -v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v56 := v55.FindInternedVar(lang.NewSymbol("list")) -if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) -} -v57 := v56.Get() -v58 := lang.Apply(v57, []any{v7}) -v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v60 := v59.FindInternedVar(lang.NewSymbol("list")) -if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) -} -v61 := v60.Get() -v62 := lang.Apply(v61, []any{lang.NewKeyword("doc")}) -v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v64 := v63.FindInternedVar(lang.NewSymbol("list")) -if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) -} -v65 := v64.Get() -v66 := lang.Apply(v65, []any{v6}) -v67 := lang.Apply(v50, []any{v54, v58, v62, v66}) -v68 := lang.Apply(v47, []any{v67}) -v69 := lang.Apply(v44, []any{v68}) -v70 := lang.Apply(v13, []any{v17, v37, v41, v69}) -v71 := lang.Apply(v10, []any{v70}) -return v71 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// add-watch -{ -v0 := lang.NewSymbol("add-watch").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("reference"), lang.NewSymbol("key"), lang.NewSymbol("fn"))), lang.NewKeyword("doc"), "Adds a watch function to an agent/atom/var/ref reference. The watch\n fn must be a fn of 4 args: a key, the reference, its old-state, its\n new-state. Whenever the reference's state might have been changed,\n any registered watches will have their functions called. The watch fn\n will be called synchronously, on the agent's thread if an agent,\n before any pending sends if agent or ref. Note that an atom's or\n ref's state may have changed again prior to the fn call, so use\n old/new-state rather than derefing the reference. Note also that watch\n fns may be called from multiple threads simultaneously. Var watchers\n are triggered only by root binding changes, not thread-local\n set!s. Keys must be unique per reference, and can be used to remove\n the watch with remove-watch, but are otherwise considered opaque by\n the watch mechanism.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2142), lang.NewKeyword("end-line"), int(2142))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6, _ := lang.FieldOrMethod(v3, "addWatch") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("addWatch is not a function"))) -} -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// agent -{ -v0 := lang.NewSymbol("agent").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("state"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Creates and returns an agent with an initial value of state and\n zero or more options (in any order):\n\n :meta metadata-map\n\n :validator validate-fn\n\n :error-handler handler-fn\n\n :error-mode mode-keyword\n\n If metadata-map is supplied, it will become the metadata on the\n agent. validate-fn must be nil or a side-effect-free fn of one\n argument, which will be passed the intended new state on any state\n change. If the new state is unacceptable, the validate-fn should\n return false or throw an exception. handler-fn is called if an\n action throws an exception or if validate-fn rejects a new state --\n see set-error-handler! for details. The mode-keyword may be either\n :continue (the default if an error-handler is given) or :fail (the\n default if no error-handler is given) -- see set-error-mode! for\n details.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2052), lang.NewKeyword("end-line"), int(2052))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.NewList(args[1:]...) -var v5 any = "unimplemented: new with non-constant class type" -_ = v5 -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("apply")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("hash-map")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v9, []any{v12, v4}) -var v6 any = v13 -_ = v6 -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("setup-reference")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v5, v4}) -_ = v18 -var v19 any -v20 := lang.Apply(lang.NewKeyword("error-handler"), []any{v6}) -if lang.IsTruthy(v20) { -v21 := lang.Apply(lang.NewKeyword("error-handler"), []any{v6}) -v22, _ := lang.FieldOrMethod(v5, "setErrorHandler") -if reflect.TypeOf(v22).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorHandler is not a function"))) -} -v23 := lang.Apply(v22, []any{v21}) -v19 = v23 -} else { -v19 = nil -} -_ = v19 -v25 := lang.Apply(lang.NewKeyword("error-mode"), []any{v6}) -var v24 any = v25 -_ = v24 -var v27 any -if lang.IsTruthy(v24) { -v27 = v24 -} else { -var v28 any -v29 := lang.Apply(lang.NewKeyword("error-handler"), []any{v6}) -if lang.IsTruthy(v29) { -v28 = lang.NewKeyword("continue") -} else { -v28 = lang.NewKeyword("fail") -} -v27 = v28 -} -v24, _ := lang.FieldOrMethod(v5, "setErrorMode") -if reflect.TypeOf(v24).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorMode is not a function"))) -} -v25 := lang.Apply(v24, []any{v27}) -_ = v25 -return v5 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// agent-error -{ -v0 := lang.NewSymbol("agent-error").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("doc"), "Returns the exception thrown during an asynchronous action of the\n agent if the agent is failed. Returns nil if the agent is not\n failed.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2167), lang.NewKeyword("end-line"), int(2167))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, ok := lang.FieldOrMethod(v3, "getError") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getError"))) -} -var v5 any -switch reflect.TypeOf(v4).Kind() { -case reflect.Func: - v5 = lang.Apply(v4, nil) -default: - v5 = v4 -} -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// agent-errors -{ -v0 := lang.NewSymbol("agent-errors").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("doc"), "DEPRECATED: Use 'agent-error' instead.\n Returns a sequence of the exceptions thrown during asynchronous\n actions of the agent.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("deprecated"), "1.2", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2234), lang.NewKeyword("end-line"), int(2234))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("agent-error")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -var v4 any = v8 -_ = v4 -var v10 any -if lang.IsTruthy(v4) { -var v11 any = v4 -_ = v11 -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("list")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v11}) -v10 = v16 -} else { -v10 = nil -} -return v10 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// aget -{ -var v1 lang.FnFunc -{ // function aget__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("concat")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("list")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("seq")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("concat")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("list")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/Aget")}) -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("seq")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) -} -v41 := v40.Get() -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("concat")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) -} -v44 := v43.Get() -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("list")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.Apply(v47, []any{lang.NewSymbol("glojure.core/int")}) -v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v50 := v49.FindInternedVar(lang.NewSymbol("list")) -if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) -} -v51 := v50.Get() -v52 := lang.Apply(v51, []any{v4}) -v53 := lang.Apply(v44, []any{v48, v52}) -v54 := lang.Apply(v41, []any{v53}) -v55 := lang.Apply(v38, []any{v54}) -v56 := lang.Apply(v27, []any{v31, v35, v55}) -v57 := lang.Apply(v24, []any{v56}) -v58 := lang.Apply(v21, []any{v57}) -v59 := lang.Apply(v10, []any{v14, v18, v58}) -v60 := lang.Apply(v7, []any{v59}) -return v60 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("aget").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("&"), lang.NewSymbol("idxs"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the value at the index/indices. Works on Java arrays of all\n types.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3911), lang.NewKeyword("end-line"), int(3911))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v4 := args[0] -v5 := args[1] -v6 := lang.Apply(lang.Get, []any{v4, v5}) -return v6 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6 := lang.NewList(args[2:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("apply")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("aget")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("aget")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v4, v5}) -v17 := lang.Apply(v9, []any{v12, v16, v6}) -return v17 - } -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// alength -{ -var v1 lang.FnFunc -{ // function alength__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/Alength")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v3}) -v35 := lang.Apply(v26, []any{v30, v34}) -v36 := lang.Apply(v23, []any{v35}) -v37 := lang.Apply(v20, []any{v36}) -v38 := lang.Apply(v9, []any{v13, v17, v37}) -v39 := lang.Apply(v6, []any{v38}) -return v39 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("alength").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the length of the Java array. Works on arrays of all\n types.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3897), lang.NewKeyword("end-line"), int(3897))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5, _ := lang.FieldOrMethod(runtime5.RT, "Alength") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Alength is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// alias -{ -v0 := lang.NewSymbol("alias").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("alias"), lang.NewSymbol("namespace-sym"))), lang.NewKeyword("doc"), "Add an alias in the current namespace to another\n namespace. Arguments are two symbols: the alias to be used, and\n the symbolic name of the target namespace. Use :as in the ns macro in preference\n to calling this directly.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4263), lang.NewKeyword("end-line"), int(4263))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("*ns*")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("the-ns")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v4}) -v12, _ := lang.FieldOrMethod(v7, "AddAlias") -if reflect.TypeOf(v12).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("AddAlias is not a function"))) -} -v13 := lang.Apply(v12, []any{v3, v11}) -return v13 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// all-ns -{ -v0 := lang.NewSymbol("all-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Returns a sequence of all namespaces.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4146), lang.NewKeyword("end-line"), int(4146))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.Apply(nil, nil) -return v3 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// alter -{ -v0 := lang.NewSymbol("alter").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("fun"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Must be called in a transaction. Sets the in-transaction-value of\n ref to:\n\n (apply fun in-transaction-value-of-ref args)\n\n and returns the in-transaction-value of ref.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2435), lang.NewKeyword("end-line"), int(2435))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -v6, _ := lang.FieldOrMethod(v3, "alter") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("alter is not a function"))) -} -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// alter-meta! -{ -v0 := lang.NewSymbol("alter-meta!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("iref"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Atomically sets the metadata for a namespace/var/ref/agent/atom to be:\n\n (apply f its-current-meta args)\n\n f must be free of side-effects", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2398), lang.NewKeyword("end-line"), int(2398))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -v6, _ := lang.FieldOrMethod(v3, "AlterMeta") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("AlterMeta is not a function"))) -} -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// alter-var-root -{ -v0 := lang.NewSymbol("alter-var-root").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("v"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Atomically alters the root binding of var v by applying f to its\n current value plus any args", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5484), lang.NewKeyword("end-line"), int(5484))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -v6, _ := lang.FieldOrMethod(v3, "alterRoot") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("alterRoot is not a function"))) -} -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// amap -{ -v0 := lang.NewSymbol("amap").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("idx"), lang.NewSymbol("ret"), lang.NewSymbol("expr"))), lang.NewKeyword("doc"), "Maps an expression across an array a, using an index named idx, and\n return value named ret, initialized to a clone of a, then setting \n each element of ret to the evaluation of expr, returning the new \n array ret.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5273), lang.NewKeyword("end-line"), int(5273))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 6 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := args[4] -v8 := args[5] -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("seq")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("concat")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol("glojure.core/let")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("apply")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("vector")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("seq")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("concat")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("list")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.Apply(v36, []any{lang.NewSymbol("a__0__auto__")}) -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("list")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.Apply(v40, []any{v5}) -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("list")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) -} -v44 := v43.Get() -v45 := lang.Apply(v44, []any{lang.NewSymbol("l__1__auto__")}) -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("list")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) -} -v48 := v47.Get() -v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v50 := v49.FindInternedVar(lang.NewSymbol("seq")) -if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) -} -v51 := v50.Get() -v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("concat")) -if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) -} -v54 := v53.Get() -v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v56 := v55.FindInternedVar(lang.NewSymbol("list")) -if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) -} -v57 := v56.Get() -v58 := lang.Apply(v57, []any{lang.NewSymbol("glojure.core/alength")}) -v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v60 := v59.FindInternedVar(lang.NewSymbol("list")) -if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) -} -v61 := v60.Get() -v62 := lang.Apply(v61, []any{lang.NewSymbol("a__0__auto__")}) -v63 := lang.Apply(v54, []any{v58, v62}) -v64 := lang.Apply(v51, []any{v63}) -v65 := lang.Apply(v48, []any{v64}) -v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v67 := v66.FindInternedVar(lang.NewSymbol("list")) -if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) -} -v68 := v67.Get() -v69 := lang.Apply(v68, []any{v7}) -v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v71 := v70.FindInternedVar(lang.NewSymbol("list")) -if v71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) -} -v72 := v71.Get() -v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v74 := v73.FindInternedVar(lang.NewSymbol("seq")) -if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) -} -v75 := v74.Get() -v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v77 := v76.FindInternedVar(lang.NewSymbol("concat")) -if v77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) -} -v78 := v77.Get() -v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v80 := v79.FindInternedVar(lang.NewSymbol("list")) -if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) -} -v81 := v80.Get() -v82 := lang.Apply(v81, []any{lang.NewSymbol("glojure.core/aclone")}) -v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v84 := v83.FindInternedVar(lang.NewSymbol("list")) -if v84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) -} -v85 := v84.Get() -v86 := lang.Apply(v85, []any{lang.NewSymbol("a__0__auto__")}) -v87 := lang.Apply(v78, []any{v82, v86}) -v88 := lang.Apply(v75, []any{v87}) -v89 := lang.Apply(v72, []any{v88}) -v90 := lang.Apply(v33, []any{v37, v41, v45, v65, v69, v89}) -v91 := lang.Apply(v30, []any{v90}) -v92 := lang.Apply(v24, []any{v27, v91}) -v93 := lang.Apply(v21, []any{v92}) -v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v95 := v94.FindInternedVar(lang.NewSymbol("list")) -if v95.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) -} -v96 := v95.Get() -v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v98 := v97.FindInternedVar(lang.NewSymbol("seq")) -if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) -} -v99 := v98.Get() -v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v101 := v100.FindInternedVar(lang.NewSymbol("concat")) -if v101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) -} -v102 := v101.Get() -v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v104 := v103.FindInternedVar(lang.NewSymbol("list")) -if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) -} -v105 := v104.Get() -v106 := lang.Apply(v105, []any{lang.NewSymbol("glojure.core/loop")}) -v107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v108 := v107.FindInternedVar(lang.NewSymbol("list")) -if v108.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v108))) -} -v109 := v108.Get() -v110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v111 := v110.FindInternedVar(lang.NewSymbol("apply")) -if v111.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v111))) -} -v112 := v111.Get() -v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v114 := v113.FindInternedVar(lang.NewSymbol("vector")) -if v114.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) -} -v115 := v114.Get() -v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v117 := v116.FindInternedVar(lang.NewSymbol("seq")) -if v117.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) -} -v118 := v117.Get() -v119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v120 := v119.FindInternedVar(lang.NewSymbol("concat")) -if v120.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v120))) -} -v121 := v120.Get() -v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v123 := v122.FindInternedVar(lang.NewSymbol("list")) -if v123.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) -} -v124 := v123.Get() -v125 := lang.Apply(v124, []any{v6}) -v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v127 := v126.FindInternedVar(lang.NewSymbol("list")) -if v127.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) -} -v128 := v127.Get() -v129 := lang.Apply(v128, []any{int64(0)}) -v130 := lang.Apply(v121, []any{v125, v129}) -v131 := lang.Apply(v118, []any{v130}) -v132 := lang.Apply(v112, []any{v115, v131}) -v133 := lang.Apply(v109, []any{v132}) -v134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v135 := v134.FindInternedVar(lang.NewSymbol("list")) -if v135.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v135))) -} -v136 := v135.Get() -v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v138 := v137.FindInternedVar(lang.NewSymbol("seq")) -if v138.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) -} -v139 := v138.Get() -v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v141 := v140.FindInternedVar(lang.NewSymbol("concat")) -if v141.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) -} -v142 := v141.Get() -v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v144 := v143.FindInternedVar(lang.NewSymbol("list")) -if v144.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) -} -v145 := v144.Get() -v146 := lang.Apply(v145, []any{lang.NewSymbol("if")}) -v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v148 := v147.FindInternedVar(lang.NewSymbol("list")) -if v148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) -} -v149 := v148.Get() -v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v151 := v150.FindInternedVar(lang.NewSymbol("seq")) -if v151.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) -} -v152 := v151.Get() -v153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v154 := v153.FindInternedVar(lang.NewSymbol("concat")) -if v154.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v154))) -} -v155 := v154.Get() -v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v157 := v156.FindInternedVar(lang.NewSymbol("list")) -if v157.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) -} -v158 := v157.Get() -v159 := lang.Apply(v158, []any{lang.NewSymbol("glojure.core/<")}) -v160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v161 := v160.FindInternedVar(lang.NewSymbol("list")) -if v161.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v161))) -} -v162 := v161.Get() -v163 := lang.Apply(v162, []any{v6}) -v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v165 := v164.FindInternedVar(lang.NewSymbol("list")) -if v165.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) -} -v166 := v165.Get() -v167 := lang.Apply(v166, []any{lang.NewSymbol("l__1__auto__")}) -v168 := lang.Apply(v155, []any{v159, v163, v167}) -v169 := lang.Apply(v152, []any{v168}) -v170 := lang.Apply(v149, []any{v169}) -v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v172 := v171.FindInternedVar(lang.NewSymbol("list")) -if v172.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) -} -v173 := v172.Get() -v174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v175 := v174.FindInternedVar(lang.NewSymbol("seq")) -if v175.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v175))) -} -v176 := v175.Get() -v177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v178 := v177.FindInternedVar(lang.NewSymbol("concat")) -if v178.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v178))) -} -v179 := v178.Get() -v180 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v181 := v180.FindInternedVar(lang.NewSymbol("list")) -if v181.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v181))) -} -v182 := v181.Get() -v183 := lang.Apply(v182, []any{lang.NewSymbol("do")}) -v184 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v185 := v184.FindInternedVar(lang.NewSymbol("list")) -if v185.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v185))) -} -v186 := v185.Get() -v187 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v188 := v187.FindInternedVar(lang.NewSymbol("seq")) -if v188.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v188))) -} -v189 := v188.Get() -v190 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v191 := v190.FindInternedVar(lang.NewSymbol("concat")) -if v191.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v191))) -} -v192 := v191.Get() -v193 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v194 := v193.FindInternedVar(lang.NewSymbol("list")) -if v194.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v194))) -} -v195 := v194.Get() -v196 := lang.Apply(v195, []any{lang.NewSymbol("glojure.core/aset")}) -v197 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v198 := v197.FindInternedVar(lang.NewSymbol("list")) -if v198.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v198))) -} -v199 := v198.Get() -v200 := lang.Apply(v199, []any{v7}) -v201 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v202 := v201.FindInternedVar(lang.NewSymbol("list")) -if v202.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v202))) -} -v203 := v202.Get() -v204 := lang.Apply(v203, []any{v6}) -v205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v206 := v205.FindInternedVar(lang.NewSymbol("list")) -if v206.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v206))) -} -v207 := v206.Get() -v208 := lang.Apply(v207, []any{v8}) -v209 := lang.Apply(v192, []any{v196, v200, v204, v208}) -v210 := lang.Apply(v189, []any{v209}) -v211 := lang.Apply(v186, []any{v210}) -v212 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v213 := v212.FindInternedVar(lang.NewSymbol("list")) -if v213.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v213))) -} -v214 := v213.Get() -v215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v216 := v215.FindInternedVar(lang.NewSymbol("seq")) -if v216.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v216))) -} -v217 := v216.Get() -v218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v219 := v218.FindInternedVar(lang.NewSymbol("concat")) -if v219.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v219))) -} -v220 := v219.Get() -v221 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v222 := v221.FindInternedVar(lang.NewSymbol("list")) -if v222.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v222))) -} -v223 := v222.Get() -v224 := lang.Apply(v223, []any{lang.NewSymbol("recur")}) -v225 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v226 := v225.FindInternedVar(lang.NewSymbol("list")) -if v226.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v226))) -} -v227 := v226.Get() -v228 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v229 := v228.FindInternedVar(lang.NewSymbol("seq")) -if v229.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v229))) -} -v230 := v229.Get() -v231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v232 := v231.FindInternedVar(lang.NewSymbol("concat")) -if v232.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v232))) -} -v233 := v232.Get() -v234 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v235 := v234.FindInternedVar(lang.NewSymbol("list")) -if v235.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v235))) -} -v236 := v235.Get() -v237 := lang.Apply(v236, []any{lang.NewSymbol("glojure.core/unchecked-inc")}) -v238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v239 := v238.FindInternedVar(lang.NewSymbol("list")) -if v239.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v239))) -} -v240 := v239.Get() -v241 := lang.Apply(v240, []any{v6}) -v242 := lang.Apply(v233, []any{v237, v241}) -v243 := lang.Apply(v230, []any{v242}) -v244 := lang.Apply(v227, []any{v243}) -v245 := lang.Apply(v220, []any{v224, v244}) -v246 := lang.Apply(v217, []any{v245}) -v247 := lang.Apply(v214, []any{v246}) -v248 := lang.Apply(v179, []any{v183, v211, v247}) -v249 := lang.Apply(v176, []any{v248}) -v250 := lang.Apply(v173, []any{v249}) -v251 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v252 := v251.FindInternedVar(lang.NewSymbol("list")) -if v252.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v252))) -} -v253 := v252.Get() -v254 := lang.Apply(v253, []any{v7}) -v255 := lang.Apply(v142, []any{v146, v170, v250, v254}) -v256 := lang.Apply(v139, []any{v255}) -v257 := lang.Apply(v136, []any{v256}) -v258 := lang.Apply(v102, []any{v106, v133, v257}) -v259 := lang.Apply(v99, []any{v258}) -v260 := lang.Apply(v96, []any{v259}) -v261 := lang.Apply(v14, []any{v18, v93, v260}) -v262 := lang.Apply(v11, []any{v261}) -return v262 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// ancestors -{ -v0 := lang.NewSymbol("ancestors").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"))), lang.NewKeyword("doc"), "Returns the immediate and indirect parents of tag, either via a Java type\n inheritance relationship or a relationship established via derive. h\n must be a hierarchy obtained from make-hierarchy, if not supplied\n defaults to the global hierarchy", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5577), lang.NewKeyword("end-line"), int(5577))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("ancestors")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("global-hierarchy")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v6, []any{v9, v3}) -return v10 - case 2: -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("not-empty")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("get")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) -v13 := lang.Apply(v11, []any{v12, v4}) -var v8 any = v13 -_ = v8 -var v15 any -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("class?")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v4}) -if lang.IsTruthy(v19) { -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("set")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("supers")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v4}) -v28 := lang.Apply(v23, []any{v27}) -var v20 any = v28 -_ = v20 -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("reduce1")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("into1")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("cons")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("map")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) -} -v41 := v40.Get() -var v42 lang.FnFunc -v42 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v43 := args[0] -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("get")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) -v48 := lang.Apply(v46, []any{v47, v43}) -return v48 -}) -v43 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5590), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(5590), lang.NewKeyword("end-column"), int(54)) -v44, err := lang.WithMeta(v42, v43.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v45 := lang.Apply(v41, []any{v44, v20}) -v46 := lang.Apply(v38, []any{v8, v45}) -v47 := lang.Apply(v32, []any{v35, v20, v46}) -v15 = v47 -} else { -v15 = v8 -} -v8 := lang.Apply(v7, []any{v15}) -return v8 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// and -{ -v0 := lang.NewSymbol("and").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("next"))), lang.NewKeyword("doc"), "Evaluates exprs one at a time, from left to right. If a form\n returns logical false (nil or false), and returns that value and\n doesn't evaluate any of the other expressions, otherwise it returns\n the value of the last expr. (and) returns true.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(835), lang.NewKeyword("end-line"), int(835))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v3 := args[0] -v4 := args[1] -return true - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -return v5 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("seq")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("concat")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("list")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/let")}) -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("list")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("apply")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("vector")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("seq")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("concat")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{lang.NewSymbol("and__0__auto__")}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v5}) -v40 := lang.Apply(v31, []any{v35, v39}) -v41 := lang.Apply(v28, []any{v40}) -v42 := lang.Apply(v22, []any{v25, v41}) -v43 := lang.Apply(v19, []any{v42}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("seq")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) -} -v49 := v48.Get() -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("concat")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("list")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) -} -v55 := v54.Get() -v56 := lang.Apply(v55, []any{lang.NewSymbol("if")}) -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("list")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) -} -v59 := v58.Get() -v60 := lang.Apply(v59, []any{lang.NewSymbol("and__0__auto__")}) -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("list")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) -} -v63 := v62.Get() -v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v65 := v64.FindInternedVar(lang.NewSymbol("seq")) -if v65.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) -} -v66 := v65.Get() -v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v68 := v67.FindInternedVar(lang.NewSymbol("concat")) -if v68.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) -} -v69 := v68.Get() -v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v71 := v70.FindInternedVar(lang.NewSymbol("list")) -if v71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) -} -v72 := v71.Get() -v73 := lang.Apply(v72, []any{lang.NewSymbol("glojure.core/and")}) -v74 := lang.Apply(v69, []any{v73, v6}) -v75 := lang.Apply(v66, []any{v74}) -v76 := lang.Apply(v63, []any{v75}) -v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v78 := v77.FindInternedVar(lang.NewSymbol("list")) -if v78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) -} -v79 := v78.Get() -v80 := lang.Apply(v79, []any{lang.NewSymbol("and__0__auto__")}) -v81 := lang.Apply(v52, []any{v56, v60, v76, v80}) -v82 := lang.Apply(v49, []any{v81}) -v83 := lang.Apply(v46, []any{v82}) -v84 := lang.Apply(v12, []any{v16, v43, v83}) -v85 := lang.Apply(v9, []any{v84}) -return v85 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// any? -{ -v1 := reflect.TypeOf(false) -v0 := lang.NewSymbol("any?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true given any argument.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(537), lang.NewKeyword("end-line"), int(537))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -return true -}) -v4 := reflect.TypeOf(false) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// apply -{ -v0 := lang.NewSymbol("apply").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("z"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Applies fn f to the argument list formed by prepending intervening arguments to args.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(653), lang.NewKeyword("end-line"), int(653))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v4}) -v9 := lang.Apply(lang.Apply, []any{v3, v8}) -return v9 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("list*")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v4, v5}) -v10 := lang.Apply(lang.Apply, []any{v3, v9}) -return v10 - case 4: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("list*")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v4, v5, v6}) -v11 := lang.Apply(lang.Apply, []any{v3, v10}) -return v11 - case 5: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := args[4] -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("list*")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v4, v5, v6, v7}) -v12 := lang.Apply(lang.Apply, []any{v3, v11}) -return v12 - default: - if len(args) < 5 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := args[4] -v8 := lang.NewList(args[5:]...) -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("cons")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("cons")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("cons")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("cons")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("spread")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v8}) -v25 := lang.Apply(v20, []any{v7, v24}) -v26 := lang.Apply(v17, []any{v6, v25}) -v27 := lang.Apply(v14, []any{v5, v26}) -v28 := lang.Apply(v11, []any{v4, v27}) -v29 := lang.Apply(lang.Apply, []any{v3, v28}) -return v29 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// areduce -{ -v0 := lang.NewSymbol("areduce").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("idx"), lang.NewSymbol("ret"), lang.NewSymbol("init"), lang.NewSymbol("expr"))), lang.NewKeyword("doc"), "Reduces an expression across an array a, using an index named idx,\n and return value named ret, initialized to init, setting ret to the \n evaluation of expr at each step, returning ret.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5289), lang.NewKeyword("end-line"), int(5289))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 7 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := args[4] -v8 := args[5] -v9 := args[6] -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("seq")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("concat")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("list")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{lang.NewSymbol("glojure.core/let")}) -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("list")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("apply")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("vector")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("seq")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("concat")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("list")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.Apply(v37, []any{lang.NewSymbol("a__0__auto__")}) -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("list")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) -} -v41 := v40.Get() -v42 := lang.Apply(v41, []any{v5}) -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("list")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.Apply(v45, []any{lang.NewSymbol("l__1__auto__")}) -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("list")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) -} -v49 := v48.Get() -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("seq")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("concat")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) -} -v55 := v54.Get() -v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v57 := v56.FindInternedVar(lang.NewSymbol("list")) -if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) -} -v58 := v57.Get() -v59 := lang.Apply(v58, []any{lang.NewSymbol("glojure.core/alength")}) -v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v61 := v60.FindInternedVar(lang.NewSymbol("list")) -if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) -} -v62 := v61.Get() -v63 := lang.Apply(v62, []any{lang.NewSymbol("a__0__auto__")}) -v64 := lang.Apply(v55, []any{v59, v63}) -v65 := lang.Apply(v52, []any{v64}) -v66 := lang.Apply(v49, []any{v65}) -v67 := lang.Apply(v34, []any{v38, v42, v46, v66}) -v68 := lang.Apply(v31, []any{v67}) -v69 := lang.Apply(v25, []any{v28, v68}) -v70 := lang.Apply(v22, []any{v69}) -v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v72 := v71.FindInternedVar(lang.NewSymbol("list")) -if v72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) -} -v73 := v72.Get() -v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v75 := v74.FindInternedVar(lang.NewSymbol("seq")) -if v75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) -} -v76 := v75.Get() -v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v78 := v77.FindInternedVar(lang.NewSymbol("concat")) -if v78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) -} -v79 := v78.Get() -v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v81 := v80.FindInternedVar(lang.NewSymbol("list")) -if v81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) -} -v82 := v81.Get() -v83 := lang.Apply(v82, []any{lang.NewSymbol("glojure.core/loop")}) -v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v85 := v84.FindInternedVar(lang.NewSymbol("list")) -if v85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) -} -v86 := v85.Get() -v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v88 := v87.FindInternedVar(lang.NewSymbol("apply")) -if v88.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) -} -v89 := v88.Get() -v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v91 := v90.FindInternedVar(lang.NewSymbol("vector")) -if v91.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) -} -v92 := v91.Get() -v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v94 := v93.FindInternedVar(lang.NewSymbol("seq")) -if v94.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) -} -v95 := v94.Get() -v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v97 := v96.FindInternedVar(lang.NewSymbol("concat")) -if v97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) -} -v98 := v97.Get() -v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v100 := v99.FindInternedVar(lang.NewSymbol("list")) -if v100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) -} -v101 := v100.Get() -v102 := lang.Apply(v101, []any{v6}) -v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v104 := v103.FindInternedVar(lang.NewSymbol("list")) -if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) -} -v105 := v104.Get() -v106 := lang.Apply(v105, []any{int64(0)}) -v107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v108 := v107.FindInternedVar(lang.NewSymbol("list")) -if v108.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v108))) -} -v109 := v108.Get() -v110 := lang.Apply(v109, []any{v7}) -v111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v112 := v111.FindInternedVar(lang.NewSymbol("list")) -if v112.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v112))) -} -v113 := v112.Get() -v114 := lang.Apply(v113, []any{v8}) -v115 := lang.Apply(v98, []any{v102, v106, v110, v114}) -v116 := lang.Apply(v95, []any{v115}) -v117 := lang.Apply(v89, []any{v92, v116}) -v118 := lang.Apply(v86, []any{v117}) -v119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v120 := v119.FindInternedVar(lang.NewSymbol("list")) -if v120.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v120))) -} -v121 := v120.Get() -v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v123 := v122.FindInternedVar(lang.NewSymbol("seq")) -if v123.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) -} -v124 := v123.Get() -v125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v126 := v125.FindInternedVar(lang.NewSymbol("concat")) -if v126.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v126))) -} -v127 := v126.Get() -v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v129 := v128.FindInternedVar(lang.NewSymbol("list")) -if v129.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v129))) -} -v130 := v129.Get() -v131 := lang.Apply(v130, []any{lang.NewSymbol("if")}) -v132 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v133 := v132.FindInternedVar(lang.NewSymbol("list")) -if v133.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v133))) -} -v134 := v133.Get() -v135 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v136 := v135.FindInternedVar(lang.NewSymbol("seq")) -if v136.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v136))) -} -v137 := v136.Get() -v138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v139 := v138.FindInternedVar(lang.NewSymbol("concat")) -if v139.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v139))) -} -v140 := v139.Get() -v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v142 := v141.FindInternedVar(lang.NewSymbol("list")) -if v142.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) -} -v143 := v142.Get() -v144 := lang.Apply(v143, []any{lang.NewSymbol("glojure.core/<")}) -v145 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v146 := v145.FindInternedVar(lang.NewSymbol("list")) -if v146.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v146))) -} -v147 := v146.Get() -v148 := lang.Apply(v147, []any{v6}) -v149 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v150 := v149.FindInternedVar(lang.NewSymbol("list")) -if v150.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v150))) -} -v151 := v150.Get() -v152 := lang.Apply(v151, []any{lang.NewSymbol("l__1__auto__")}) -v153 := lang.Apply(v140, []any{v144, v148, v152}) -v154 := lang.Apply(v137, []any{v153}) -v155 := lang.Apply(v134, []any{v154}) -v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v157 := v156.FindInternedVar(lang.NewSymbol("list")) -if v157.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) -} -v158 := v157.Get() -v159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v160 := v159.FindInternedVar(lang.NewSymbol("seq")) -if v160.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v160))) -} -v161 := v160.Get() -v162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v163 := v162.FindInternedVar(lang.NewSymbol("concat")) -if v163.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v163))) -} -v164 := v163.Get() -v165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v166 := v165.FindInternedVar(lang.NewSymbol("list")) -if v166.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v166))) -} -v167 := v166.Get() -v168 := lang.Apply(v167, []any{lang.NewSymbol("recur")}) -v169 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v170 := v169.FindInternedVar(lang.NewSymbol("list")) -if v170.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v170))) -} -v171 := v170.Get() -v172 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v173 := v172.FindInternedVar(lang.NewSymbol("seq")) -if v173.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v173))) -} -v174 := v173.Get() -v175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v176 := v175.FindInternedVar(lang.NewSymbol("concat")) -if v176.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v176))) -} -v177 := v176.Get() -v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v179 := v178.FindInternedVar(lang.NewSymbol("list")) -if v179.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) -} -v180 := v179.Get() -v181 := lang.Apply(v180, []any{lang.NewSymbol("glojure.core/unchecked-inc-int")}) -v182 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v183 := v182.FindInternedVar(lang.NewSymbol("list")) -if v183.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v183))) -} -v184 := v183.Get() -v185 := lang.Apply(v184, []any{v6}) -v186 := lang.Apply(v177, []any{v181, v185}) -v187 := lang.Apply(v174, []any{v186}) -v188 := lang.Apply(v171, []any{v187}) -v189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v190 := v189.FindInternedVar(lang.NewSymbol("list")) -if v190.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v190))) -} -v191 := v190.Get() -v192 := lang.Apply(v191, []any{v9}) -v193 := lang.Apply(v164, []any{v168, v188, v192}) -v194 := lang.Apply(v161, []any{v193}) -v195 := lang.Apply(v158, []any{v194}) -v196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v197 := v196.FindInternedVar(lang.NewSymbol("list")) -if v197.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v197))) -} -v198 := v197.Get() -v199 := lang.Apply(v198, []any{v7}) -v200 := lang.Apply(v127, []any{v131, v155, v195, v199}) -v201 := lang.Apply(v124, []any{v200}) -v202 := lang.Apply(v121, []any{v201}) -v203 := lang.Apply(v79, []any{v83, v118, v202}) -v204 := lang.Apply(v76, []any{v203}) -v205 := lang.Apply(v73, []any{v204}) -v206 := lang.Apply(v15, []any{v19, v70, v205}) -v207 := lang.Apply(v12, []any{v206}) -return v207 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// array -{ -v0 := lang.NewSymbol("array").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3457), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3458), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("items"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewList(args[0:]...) -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("into-array")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{v3}) -return v7 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// array-map -{ -v0 := lang.NewSymbol("array-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keyvals"))), lang.NewKeyword("doc"), "Constructs an array-map. If any keys are equal, they are handled as\n if by repeated uses of assoc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4378), lang.NewKeyword("end-line"), int(4378))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v3, ok := lang.FieldOrMethod(glojure.lang4.PersistentArrayMap, "EMPTY") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", glojure.lang4.PersistentArrayMap, "EMPTY"))) -} -var v4 any -switch reflect.TypeOf(v3).Kind() { -case reflect.Func: - v4 = lang.Apply(v3, nil) -default: - v4 = v3 -} -return v4 - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewList(args[0:]...) -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("to-array")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -var v4 any = v8 -_ = v4 -var v10 any -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("odd?")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("alength")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v4}) -v18 := lang.Apply(v13, []any{v17}) -if lang.IsTruthy(v18) { -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("str")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("last")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v26 := lang.Apply(v21, []any{"No value supplied for key: ", v25}) -v27 := lang.Apply(lang.NewIllegalArgumentError, []any{v26}) -panic(v27) -} else { -v28 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{v4}) -v10 = v28 -} -return v10 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// as-> -{ -v0 := lang.NewSymbol("as->").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "Binds name to expr, evaluates the first form in the lexical context\n of that binding, then binds name to that result, repeating for each\n successive form, returning the result of the last form.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7598), lang.NewKeyword("end-line"), int(7598))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := lang.NewList(args[4:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("seq")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("concat")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("glojure.core/let")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("apply")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("vector")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("seq")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("concat")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("list")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v6}) -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("list")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v5}) -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("interleave")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("repeat")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v6}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("butlast")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v7}) -v52 := lang.Apply(v43, []any{v47, v51}) -v53 := lang.Apply(v32, []any{v36, v40, v52}) -v54 := lang.Apply(v29, []any{v53}) -v55 := lang.Apply(v23, []any{v26, v54}) -v56 := lang.Apply(v20, []any{v55}) -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("list")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) -} -v59 := v58.Get() -var v60 any -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("empty?")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) -} -v63 := v62.Get() -v64 := lang.Apply(v63, []any{v7}) -if lang.IsTruthy(v64) { -v60 = v6 -} else { -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("last")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) -} -v67 := v66.Get() -v68 := lang.Apply(v67, []any{v7}) -v60 = v68 -} -v69 := lang.Apply(v59, []any{v60}) -v70 := lang.Apply(v13, []any{v17, v56, v69}) -v71 := lang.Apply(v10, []any{v70}) -return v71 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// aset -{ -var v1 lang.FnFunc -{ // function aset__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("seq")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("concat")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("list")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{lang.NewSymbol(".")}) -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("list")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("list")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("seq")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("concat")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("list")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.Apply(v31, []any{lang.NewSymbol("glojure.core/Aset")}) -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("list")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v3}) -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("list")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("seq")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("concat")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("list")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) -} -v48 := v47.Get() -v49 := lang.Apply(v48, []any{lang.NewSymbol("glojure.core/int")}) -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("list")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.Apply(v52, []any{v4}) -v54 := lang.Apply(v45, []any{v49, v53}) -v55 := lang.Apply(v42, []any{v54}) -v56 := lang.Apply(v39, []any{v55}) -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("list")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) -} -v59 := v58.Get() -v60 := lang.Apply(v59, []any{v5}) -v61 := lang.Apply(v28, []any{v32, v36, v56, v60}) -v62 := lang.Apply(v25, []any{v61}) -v63 := lang.Apply(v22, []any{v62}) -v64 := lang.Apply(v11, []any{v15, v19, v63}) -v65 := lang.Apply(v8, []any{v64}) -return v65 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("aset").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on Java arrays of\n reference types. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(3)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3922), lang.NewKeyword("end-line"), int(3922))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 3: -v4 := args[0] -v5 := args[1] -v6 := args[2] -v7 := lang.Apply(lang.SliceSet, []any{v4, v5, v6}) -_ = v7 -return v6 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6 := args[2] -v7 := lang.NewList(args[3:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("apply")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("aset")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("aget")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v4, v5}) -v18 := lang.Apply(v10, []any{v13, v17, v6, v7}) -return v18 - } -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// aset-boolean -{ -v0 := lang.NewSymbol("aset-boolean").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of boolean. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3956), lang.NewKeyword("end-line"), int(3958))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("boolean")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v5}) -v10, _ := lang.FieldOrMethod(nil, "setBoolean") -if reflect.TypeOf(v10).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setBoolean is not a function"))) -} -v11 := lang.Apply(v10, []any{v3, v4, v9}) -_ = v11 -return v5 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("apply")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("aset-boolean")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("aget")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v3, v4}) -v17 := lang.Apply(v9, []any{v12, v16, v5, v6}) -return v17 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// aset-byte -{ -v0 := lang.NewSymbol("aset-byte").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of byte. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3976), lang.NewKeyword("end-line"), int(3978))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("byte")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v5}) -v10, _ := lang.FieldOrMethod(nil, "setByte") -if reflect.TypeOf(v10).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setByte is not a function"))) -} -v11 := lang.Apply(v10, []any{v3, v4, v9}) -_ = v11 -return v5 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("apply")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("aset-byte")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("aget")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v3, v4}) -v17 := lang.Apply(v9, []any{v12, v16, v5, v6}) -return v17 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// aset-char -{ -v0 := lang.NewSymbol("aset-char").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of char. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3981), lang.NewKeyword("end-line"), int(3983))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("char")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v5}) -v10, _ := lang.FieldOrMethod(nil, "setChar") -if reflect.TypeOf(v10).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setChar is not a function"))) -} -v11 := lang.Apply(v10, []any{v3, v4, v9}) -_ = v11 -return v5 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("apply")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("aset-char")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("aget")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v3, v4}) -v17 := lang.Apply(v9, []any{v12, v16, v5, v6}) -return v17 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// aset-double -{ -v0 := lang.NewSymbol("aset-double").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of double. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3966), lang.NewKeyword("end-line"), int(3968))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("double")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v5}) -v10, _ := lang.FieldOrMethod(nil, "setDouble") -if reflect.TypeOf(v10).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setDouble is not a function"))) -} -v11 := lang.Apply(v10, []any{v3, v4, v9}) -_ = v11 -return v5 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("apply")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("aset-double")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("aget")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v3, v4}) -v17 := lang.Apply(v9, []any{v12, v16, v5, v6}) -return v17 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// aset-float -{ -v0 := lang.NewSymbol("aset-float").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of float. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3961), lang.NewKeyword("end-line"), int(3963))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("float")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v5}) -v10, _ := lang.FieldOrMethod(nil, "setFloat") -if reflect.TypeOf(v10).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setFloat is not a function"))) -} -v11 := lang.Apply(v10, []any{v3, v4, v9}) -_ = v11 -return v5 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("apply")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("aset-float")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("aget")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v3, v4}) -v17 := lang.Apply(v9, []any{v12, v16, v5, v6}) -return v17 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// aset-int -{ -v0 := lang.NewSymbol("aset-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of int. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3946), lang.NewKeyword("end-line"), int(3948))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("int")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v5}) -v10, _ := lang.FieldOrMethod(nil, "setInt") -if reflect.TypeOf(v10).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setInt is not a function"))) -} -v11 := lang.Apply(v10, []any{v3, v4, v9}) -_ = v11 -return v5 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("apply")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("aset-int")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("aget")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v3, v4}) -v17 := lang.Apply(v9, []any{v12, v16, v5, v6}) -return v17 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// aset-long -{ -v0 := lang.NewSymbol("aset-long").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of long. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3951), lang.NewKeyword("end-line"), int(3953))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("long")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v5}) -v10, _ := lang.FieldOrMethod(nil, "setLong") -if reflect.TypeOf(v10).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setLong is not a function"))) -} -v11 := lang.Apply(v10, []any{v3, v4, v9}) -_ = v11 -return v5 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("apply")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("aset-long")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("aget")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v3, v4}) -v17 := lang.Apply(v9, []any{v12, v16, v5, v6}) -return v17 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// aset-short -{ -v0 := lang.NewSymbol("aset-short").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of short. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3971), lang.NewKeyword("end-line"), int(3973))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("short")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v5}) -v10, _ := lang.FieldOrMethod(nil, "setShort") -if reflect.TypeOf(v10).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setShort is not a function"))) -} -v11 := lang.Apply(v10, []any{v3, v4, v9}) -_ = v11 -return v5 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("apply")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("aset-short")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("aget")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v3, v4}) -v17 := lang.Apply(v9, []any{v12, v16, v5, v6}) -return v17 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// assert -{ -v0 := lang.NewSymbol("assert").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("message"))), lang.NewKeyword("doc"), "Evaluates expression x and throws an AssertionError with optional\n message if x does not evaluate to logical true.\n\n Assertion checks are omitted from compiled code if '*assert*' is\n false.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4837), lang.NewKeyword("end-line"), int(4837))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -var v6 any -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("*assert*")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -if lang.IsTruthy(v9) { -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("seq")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("concat")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("list")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{lang.NewSymbol("glojure.core/when-not")}) -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("list")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.Apply(v22, []any{v5}) -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("list")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("seq")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("concat")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("list")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{lang.NewSymbol("throw")}) -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("list")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("seq")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("concat")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("list")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) -} -v48 := v47.Get() -v49 := lang.Apply(v48, []any{lang.NewSymbol("new")}) -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("list")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.Apply(v52, []any{lang.NewSymbol("glojure.core/AssertionError")}) -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("list")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) -} -v56 := v55.Get() -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("seq")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) -} -v59 := v58.Get() -v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v61 := v60.FindInternedVar(lang.NewSymbol("concat")) -if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) -} -v62 := v61.Get() -v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v64 := v63.FindInternedVar(lang.NewSymbol("list")) -if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) -} -v65 := v64.Get() -v66 := lang.Apply(v65, []any{lang.NewSymbol("glojure.core/str")}) -v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v68 := v67.FindInternedVar(lang.NewSymbol("list")) -if v68.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) -} -v69 := v68.Get() -v70 := lang.Apply(v69, []any{"Assert failed: "}) -v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v72 := v71.FindInternedVar(lang.NewSymbol("list")) -if v72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) -} -v73 := v72.Get() -v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v75 := v74.FindInternedVar(lang.NewSymbol("seq")) -if v75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) -} -v76 := v75.Get() -v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v78 := v77.FindInternedVar(lang.NewSymbol("concat")) -if v78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) -} -v79 := v78.Get() -v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v81 := v80.FindInternedVar(lang.NewSymbol("list")) -if v81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) -} -v82 := v81.Get() -v83 := lang.Apply(v82, []any{lang.NewSymbol("glojure.core/pr-str")}) -v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v85 := v84.FindInternedVar(lang.NewSymbol("list")) -if v85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) -} -v86 := v85.Get() -v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v88 := v87.FindInternedVar(lang.NewSymbol("seq")) -if v88.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) -} -v89 := v88.Get() -v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v91 := v90.FindInternedVar(lang.NewSymbol("concat")) -if v91.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) -} -v92 := v91.Get() -v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v94 := v93.FindInternedVar(lang.NewSymbol("list")) -if v94.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) -} -v95 := v94.Get() -v96 := lang.Apply(v95, []any{lang.NewSymbol("quote")}) -v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v98 := v97.FindInternedVar(lang.NewSymbol("list")) -if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) -} -v99 := v98.Get() -v100 := lang.Apply(v99, []any{v5}) -v101 := lang.Apply(v92, []any{v96, v100}) -v102 := lang.Apply(v89, []any{v101}) -v103 := lang.Apply(v86, []any{v102}) -v104 := lang.Apply(v79, []any{v83, v103}) -v105 := lang.Apply(v76, []any{v104}) -v106 := lang.Apply(v73, []any{v105}) -v107 := lang.Apply(v62, []any{v66, v70, v106}) -v108 := lang.Apply(v59, []any{v107}) -v109 := lang.Apply(v56, []any{v108}) -v110 := lang.Apply(v45, []any{v49, v53, v109}) -v111 := lang.Apply(v42, []any{v110}) -v112 := lang.Apply(v39, []any{v111}) -v113 := lang.Apply(v32, []any{v36, v112}) -v114 := lang.Apply(v29, []any{v113}) -v115 := lang.Apply(v26, []any{v114}) -v116 := lang.Apply(v15, []any{v19, v23, v115}) -v117 := lang.Apply(v12, []any{v116}) -v6 = v117 -} else { -v6 = nil -} -return v6 - case 4: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -var v7 any -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("*assert*")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -if lang.IsTruthy(v10) { -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("seq")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("concat")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("list")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{lang.NewSymbol("glojure.core/when-not")}) -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("list")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v5}) -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("list")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("seq")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("concat")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("list")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.Apply(v36, []any{lang.NewSymbol("throw")}) -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("list")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("seq")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("concat")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("list")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) -} -v49 := v48.Get() -v50 := lang.Apply(v49, []any{lang.NewSymbol("new")}) -v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v52 := v51.FindInternedVar(lang.NewSymbol("list")) -if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) -} -v53 := v52.Get() -v54 := lang.Apply(v53, []any{lang.NewSymbol("glojure.core/AssertionError")}) -v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v56 := v55.FindInternedVar(lang.NewSymbol("list")) -if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) -} -v57 := v56.Get() -v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v59 := v58.FindInternedVar(lang.NewSymbol("seq")) -if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) -} -v60 := v59.Get() -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("concat")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) -} -v63 := v62.Get() -v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v65 := v64.FindInternedVar(lang.NewSymbol("list")) -if v65.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) -} -v66 := v65.Get() -v67 := lang.Apply(v66, []any{lang.NewSymbol("glojure.core/str")}) -v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v69 := v68.FindInternedVar(lang.NewSymbol("list")) -if v69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) -} -v70 := v69.Get() -v71 := lang.Apply(v70, []any{"Assert failed: "}) -v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v73 := v72.FindInternedVar(lang.NewSymbol("list")) -if v73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) -} -v74 := v73.Get() -v75 := lang.Apply(v74, []any{v6}) -v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v77 := v76.FindInternedVar(lang.NewSymbol("list")) -if v77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) -} -v78 := v77.Get() -v79 := lang.Apply(v78, []any{"\n"}) -v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v81 := v80.FindInternedVar(lang.NewSymbol("list")) -if v81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) -} -v82 := v81.Get() -v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v84 := v83.FindInternedVar(lang.NewSymbol("seq")) -if v84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) -} -v85 := v84.Get() -v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v87 := v86.FindInternedVar(lang.NewSymbol("concat")) -if v87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) -} -v88 := v87.Get() -v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v90 := v89.FindInternedVar(lang.NewSymbol("list")) -if v90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) -} -v91 := v90.Get() -v92 := lang.Apply(v91, []any{lang.NewSymbol("glojure.core/pr-str")}) -v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v94 := v93.FindInternedVar(lang.NewSymbol("list")) -if v94.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) -} -v95 := v94.Get() -v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v97 := v96.FindInternedVar(lang.NewSymbol("seq")) -if v97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) -} -v98 := v97.Get() -v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v100 := v99.FindInternedVar(lang.NewSymbol("concat")) -if v100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) -} -v101 := v100.Get() -v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v103 := v102.FindInternedVar(lang.NewSymbol("list")) -if v103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) -} -v104 := v103.Get() -v105 := lang.Apply(v104, []any{lang.NewSymbol("quote")}) -v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v107 := v106.FindInternedVar(lang.NewSymbol("list")) -if v107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) -} -v108 := v107.Get() -v109 := lang.Apply(v108, []any{v5}) -v110 := lang.Apply(v101, []any{v105, v109}) -v111 := lang.Apply(v98, []any{v110}) -v112 := lang.Apply(v95, []any{v111}) -v113 := lang.Apply(v88, []any{v92, v112}) -v114 := lang.Apply(v85, []any{v113}) -v115 := lang.Apply(v82, []any{v114}) -v116 := lang.Apply(v63, []any{v67, v71, v75, v79, v115}) -v117 := lang.Apply(v60, []any{v116}) -v118 := lang.Apply(v57, []any{v117}) -v119 := lang.Apply(v46, []any{v50, v54, v118}) -v120 := lang.Apply(v43, []any{v119}) -v121 := lang.Apply(v40, []any{v120}) -v122 := lang.Apply(v33, []any{v37, v121}) -v123 := lang.Apply(v30, []any{v122}) -v124 := lang.Apply(v27, []any{v123}) -v125 := lang.Apply(v16, []any{v20, v24, v124}) -v126 := lang.Apply(v13, []any{v125}) -v7 = v126 -} else { -v7 = nil -} -return v7 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// assert-args -{ -v0 := lang.NewSymbol("assert-args").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("pairs"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(38), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1830), lang.NewKeyword("end-line"), int(1830), lang.NewKeyword("private"), true)).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("seq")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("concat")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("list")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{lang.NewSymbol("do")}) -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("list")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("seq")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("concat")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("list")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.Apply(v27, []any{lang.NewSymbol("glojure.core/when-not")}) -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("list")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("first")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v5}) -v36 := lang.Apply(v31, []any{v35}) -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("list")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("seq")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("concat")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("list")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) -} -v48 := v47.Get() -v49 := lang.Apply(v48, []any{lang.NewSymbol("throw")}) -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("list")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("seq")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) -} -v55 := v54.Get() -v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v57 := v56.FindInternedVar(lang.NewSymbol("concat")) -if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) -} -v58 := v57.Get() -v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v60 := v59.FindInternedVar(lang.NewSymbol("list")) -if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) -} -v61 := v60.Get() -v62 := lang.Apply(v61, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewIllegalArgumentError")}) -v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v64 := v63.FindInternedVar(lang.NewSymbol("list")) -if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) -} -v65 := v64.Get() -v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v67 := v66.FindInternedVar(lang.NewSymbol("seq")) -if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) -} -v68 := v67.Get() -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("concat")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) -} -v71 := v70.Get() -v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v73 := v72.FindInternedVar(lang.NewSymbol("list")) -if v73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) -} -v74 := v73.Get() -v75 := lang.Apply(v74, []any{lang.NewSymbol("glojure.core/str")}) -v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v77 := v76.FindInternedVar(lang.NewSymbol("list")) -if v77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) -} -v78 := v77.Get() -v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v80 := v79.FindInternedVar(lang.NewSymbol("seq")) -if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) -} -v81 := v80.Get() -v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v83 := v82.FindInternedVar(lang.NewSymbol("concat")) -if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) -} -v84 := v83.Get() -v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v86 := v85.FindInternedVar(lang.NewSymbol("list")) -if v86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) -} -v87 := v86.Get() -v88 := lang.Apply(v87, []any{lang.NewSymbol("glojure.core/first")}) -v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v90 := v89.FindInternedVar(lang.NewSymbol("list")) -if v90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) -} -v91 := v90.Get() -v92 := lang.Apply(v91, []any{lang.NewSymbol("&form")}) -v93 := lang.Apply(v84, []any{v88, v92}) -v94 := lang.Apply(v81, []any{v93}) -v95 := lang.Apply(v78, []any{v94}) -v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v97 := v96.FindInternedVar(lang.NewSymbol("list")) -if v97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) -} -v98 := v97.Get() -v99 := lang.Apply(v98, []any{" requires "}) -v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v101 := v100.FindInternedVar(lang.NewSymbol("list")) -if v101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) -} -v102 := v101.Get() -v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v104 := v103.FindInternedVar(lang.NewSymbol("second")) -if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) -} -v105 := v104.Get() -v106 := lang.Apply(v105, []any{v5}) -v107 := lang.Apply(v102, []any{v106}) -v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v109 := v108.FindInternedVar(lang.NewSymbol("list")) -if v109.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) -} -v110 := v109.Get() -v111 := lang.Apply(v110, []any{" in "}) -v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v113 := v112.FindInternedVar(lang.NewSymbol("list")) -if v113.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) -} -v114 := v113.Get() -v115 := lang.Apply(v114, []any{lang.NewSymbol("*ns*")}) -v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v117 := v116.FindInternedVar(lang.NewSymbol("list")) -if v117.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) -} -v118 := v117.Get() -v119 := lang.Apply(v118, []any{":"}) -v120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v121 := v120.FindInternedVar(lang.NewSymbol("list")) -if v121.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v121))) -} -v122 := v121.Get() -v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v124 := v123.FindInternedVar(lang.NewSymbol("seq")) -if v124.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) -} -v125 := v124.Get() -v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v127 := v126.FindInternedVar(lang.NewSymbol("concat")) -if v127.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) -} -v128 := v127.Get() -v129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v130 := v129.FindInternedVar(lang.NewSymbol("list")) -if v130.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v130))) -} -v131 := v130.Get() -v132 := lang.Apply(v131, []any{lang.NewKeyword("line")}) -v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v134 := v133.FindInternedVar(lang.NewSymbol("list")) -if v134.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) -} -v135 := v134.Get() -v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v137 := v136.FindInternedVar(lang.NewSymbol("seq")) -if v137.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) -} -v138 := v137.Get() -v139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v140 := v139.FindInternedVar(lang.NewSymbol("concat")) -if v140.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v140))) -} -v141 := v140.Get() -v142 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v143 := v142.FindInternedVar(lang.NewSymbol("list")) -if v143.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v143))) -} -v144 := v143.Get() -v145 := lang.Apply(v144, []any{lang.NewSymbol("glojure.core/meta")}) -v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v147 := v146.FindInternedVar(lang.NewSymbol("list")) -if v147.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) -} -v148 := v147.Get() -v149 := lang.Apply(v148, []any{lang.NewSymbol("&form")}) -v150 := lang.Apply(v141, []any{v145, v149}) -v151 := lang.Apply(v138, []any{v150}) -v152 := lang.Apply(v135, []any{v151}) -v153 := lang.Apply(v128, []any{v132, v152}) -v154 := lang.Apply(v125, []any{v153}) -v155 := lang.Apply(v122, []any{v154}) -v156 := lang.Apply(v71, []any{v75, v95, v99, v107, v111, v115, v119, v155}) -v157 := lang.Apply(v68, []any{v156}) -v158 := lang.Apply(v65, []any{v157}) -v159 := lang.Apply(v58, []any{v62, v158}) -v160 := lang.Apply(v55, []any{v159}) -v161 := lang.Apply(v52, []any{v160}) -v162 := lang.Apply(v45, []any{v49, v161}) -v163 := lang.Apply(v42, []any{v162}) -v164 := lang.Apply(v39, []any{v163}) -v165 := lang.Apply(v24, []any{v28, v36, v164}) -v166 := lang.Apply(v21, []any{v165}) -v167 := lang.Apply(v18, []any{v166}) -v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v169 := v168.FindInternedVar(lang.NewSymbol("list")) -if v169.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) -} -v170 := v169.Get() -v172 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v173 := v172.FindInternedVar(lang.NewSymbol("nnext")) -if v173.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v173))) -} -v174 := v173.Get() -v175 := lang.Apply(v174, []any{v5}) -var v171 any = v175 -_ = v171 -var v177 any -if lang.IsTruthy(v171) { -v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v179 := v178.FindInternedVar(lang.NewSymbol("list*")) -if v179.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) -} -v180 := v179.Get() -v181 := lang.Apply(v180, []any{lang.NewSymbol("glojure.core/assert-args"), v171}) -v177 = v181 -} else { -v177 = nil -} -v171 := lang.Apply(v170, []any{v177}) -v172 := lang.Apply(v11, []any{v15, v167, v171}) -v173 := lang.Apply(v8, []any{v172}) -return v173 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// assert-valid-fdecl -{ -v0 := lang.NewSymbol("assert-valid-fdecl").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fdecl"))), lang.NewKeyword("doc"), "A good fdecl looks like (([a] ...) ([a b] ...)) near the end of defn.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(42), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(7502), lang.NewKeyword("end-line"), int(7502), lang.NewKeyword("private"), true, lang.NewKeyword("dynamic"), true)).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("empty?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -if lang.IsTruthy(v8) { -v9 := lang.Apply(lang.NewIllegalArgumentError, []any{"Parameter declaration missing"}) -panic(v9) -} else { -v4 = nil -} -_ = v4 -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("map")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -var v14 lang.FnFunc -v14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v15 := args[0] -var v16 any -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq?")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v15}) -if lang.IsTruthy(v20) { -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("first")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v15}) -v16 = v24 -} else { -var v25 any -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("seq?")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("first")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.Apply(v31, []any{v3}) -v33 := lang.Apply(v28, []any{v32}) -if lang.IsTruthy(v33) { -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("str")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.Apply(v36, []any{"Invalid signature \"", v15, "\" should be a list"}) -v25 = v37 -} else { -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("str")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.Apply(v40, []any{"Parameter declaration \"", v15, "\" should be a vector"}) -v25 = v41 -} -v42 := lang.Apply(lang.NewIllegalArgumentError, []any{v25}) -panic(v42) -} -return v16 -}) -v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7508), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7517), lang.NewKeyword("end-column"), int(59)) -v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v17 := lang.Apply(v13, []any{v16, v3}) -var v10 any = v17 -_ = v10 -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("seq")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("remove")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -var v25 lang.FnFunc -v25 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v26 := args[0] -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("vector?")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{v26}) -return v30 -}) -v26 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7519), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(7519), lang.NewKeyword("end-column"), int(42)) -v27, err := lang.WithMeta(v25, v26.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v28 := lang.Apply(v24, []any{v27, v10}) -v29 := lang.Apply(v21, []any{v28}) -var v18 any = v29 -_ = v18 -var v31 any -if lang.IsTruthy(v18) { -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("str")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("first")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v18}) -v39 := lang.Apply(v34, []any{"Parameter declaration \"", v38, "\" should be a vector"}) -v40 := lang.Apply(lang.NewIllegalArgumentError, []any{v39}) -panic(v40) -} else { -v31 = nil -} -return v31 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// assoc -{ -v0 := lang.NewSymbol("assoc").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"), lang.NewSymbol("val"), lang.NewSymbol("&"), lang.NewSymbol("kvs"))), lang.NewKeyword("doc"), "assoc[iate]. When applied to a map, returns a new map of the\n same (hashed/sorted) type, that contains the mapping of key(s) to\n val(s). When applied to a vector, returns a new vector that\n contains val at index. Note - index must be <= (count vector).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(181), lang.NewKeyword("end-line"), int(188))).(*lang.Symbol) -var v2 lang.FnFunc -{ // function assoc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 3: -v4 := args[0] -v5 := args[1] -v6 := args[2] -v7 := lang.Apply(lang.Assoc, []any{v4, v5, v6}) -return v7 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6 := args[2] -v7 := lang.NewList(args[3:]...) -recur_loop_24: -v9 := lang.Apply(lang.Assoc, []any{v4, v5, v6}) -var v8 any = v9 -_ = v8 -var v11 any -if lang.IsTruthy(v7) { -var v12 any -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("next")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v7}) -if lang.IsTruthy(v16) { -var v17 any = v8 -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("first")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v7}) -var v18 any = v22 -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("second")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v7}) -var v23 any = v27 -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("nnext")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.Apply(v31, []any{v7}) -var v28 any = v32 -v4 = v17 -v5 = v18 -v6 = v23 -v7 = v28 -goto recur_loop_24 -} else { -v33 := lang.Apply(lang.NewIllegalArgumentError, []any{"assoc expects even number of arguments after map/vector, found odd number"}) -panic(v33) -} -v11 = v12 -} else { -v11 = v8 -} -return v11 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(189), lang.NewKeyword("column"), int(2), lang.NewKeyword("end-line"), int(198), lang.NewKeyword("end-column"), int(15))).(lang.FnFunc) -v3 := v2 -_ = v3 -} -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// assoc! -{ -v0 := lang.NewSymbol("assoc!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("key"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("key"), lang.NewSymbol("val"), lang.NewSymbol("&"), lang.NewSymbol("kvs"))), lang.NewKeyword("doc"), "When applied to a transient map, adds mapping of key(s) to\n val(s). When applied to a transient vector, sets the val at index.\n Note - index must be <= (count vector). Returns coll.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3369), lang.NewKeyword("end-line"), int(3369))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6, _ := lang.FieldOrMethod(v3, "Assoc") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Assoc is not a function"))) -} -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -recur_loop_609: -v8, _ := lang.FieldOrMethod(v3, "Assoc") -if reflect.TypeOf(v8).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Assoc is not a function"))) -} -v9 := lang.Apply(v8, []any{v4, v5}) -var v7 any = v9 -_ = v7 -var v11 any -if lang.IsTruthy(v6) { -var v12 any = v7 -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("first")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v6}) -var v13 any = v17 -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("second")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v6}) -var v18 any = v22 -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("nnext")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v6}) -var v23 any = v27 -v3 = v12 -v4 = v13 -v5 = v18 -v6 = v23 -goto recur_loop_609 -} else { -v11 = v7 -} -return v11 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// assoc-in -{ -v0 := lang.NewSymbol("assoc-in").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("&"), lang.NewSymbol("ks")), lang.NewSymbol("v"))), lang.NewKeyword("doc"), "Associates a value in a nested associative structure, where ks is a\n sequence of keys and v is the new value and returns a new nested structure.\n If any levels do not exist, hash-maps will be created.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6147), lang.NewKeyword("end-line"), int(6147))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -var v6 any = v4 -_ = v6 -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("seq")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v6}) -var v7 any = v11 -_ = v7 -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("first")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v7}) -var v12 any = v16 -_ = v12 -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("next")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v20, []any{v17}) -var v17 any = v21 -_ = v17 -var v22 any = v12 -_ = v22 -var v23 any = v17 -_ = v23 -var v25 any -if lang.IsTruthy(v23) { -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("assoc")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("assoc-in")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("get")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3, v22}) -v36 := lang.Apply(v31, []any{v35, v23, v5}) -v37 := lang.Apply(v28, []any{v3, v22, v36}) -v25 = v37 -} else { -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("assoc")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.Apply(v40, []any{v3, v22, v5}) -v25 = v41 -} -return v25 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// associative? -{ -v0 := lang.NewSymbol("associative?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements Associative", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6223), lang.NewKeyword("end-line"), int(6223))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{glojure.lang4.Associative, v3}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// atom -{ -v0 := lang.NewSymbol("atom").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Creates and returns an Atom with an initial value of x and zero or\n more options (in any order):\n\n :meta metadata-map\n\n :validator validate-fn\n\n If metadata-map is supplied, it will become the metadata on the\n atom. validate-fn must be nil or a side-effect-free fn of one\n argument, which will be passed the intended new state on any state\n change. If the new state is unacceptable, the validate-fn should\n return false or throw an exception.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2325), lang.NewKeyword("end-line"), int(2325))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -v4 := lang.Apply(lang.NewAtom, []any{v3}) -return v4 - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.NewList(args[1:]...) -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("setup-reference")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("atom")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v3}) -v12 := lang.Apply(v7, []any{v11, v4}) -return v12 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// await -{ -v0 := lang.NewSymbol("await").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("agents"))), lang.NewKeyword("doc"), "Blocks the current thread (indefinitely!) until all actions\n dispatched thus far, from this thread or agent, to the agent(s) have\n occurred. Will block on failed agents. Will never return if\n a failed agent is restarted with :clear-actions true or shutdown-agents was called.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3267), lang.NewKeyword("end-line"), int(3267))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewList(args[0:]...) -var v4 any -v5 := lang.Apply(nil, nil) -if lang.IsTruthy(v5) { -panic("unimplemented: new with non-constant class type") -} else { -var v6 any -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("*agent*")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -if lang.IsTruthy(v9) { -v10 := lang.Apply(errors6.New, []any{"Can't await in agent action"}) -panic(v10) -} else { -v6 = nil -} -_ = v6 -var v11 any = "unimplemented: new with non-constant class type" -_ = v11 -var v13 lang.FnFunc -v13 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v14 := args[0] -v15, _ := lang.FieldOrMethod(v11, "countDown") -if reflect.TypeOf(v15).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("countDown is not a function"))) -} -v16 := lang.Apply(v15, []any{}) -_ = v16 -return v14 -}) -v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3279), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(3279), lang.NewKeyword("end-column"), int(61)) -v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v12 any = v15 -_ = v12 -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("seq")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v20, []any{v3}) -var v17 any = v21 -_ = v17 -var v22 any = nil -_ = v22 -var v23 any = int64(0) -_ = v23 -var v24 any = int64(0) -_ = v24 -var v25 any -for { -var v26 any -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("<")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{v24, v23}) -if lang.IsTruthy(v30) { -v32, _ := lang.FieldOrMethod(v22, "nth") -if reflect.TypeOf(v32).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) -} -v33 := lang.Apply(v32, []any{v24}) -var v31 any = v33 -_ = v31 -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("send")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v31, v12}) -_ = v38 -var v39 any = v17 -var v40 any = v22 -var v41 any = v23 -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("unchecked-inc")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.Apply(v45, []any{v24}) -var v42 any = v46 -v17 = v39 -v22 = v40 -v23 = v41 -v24 = v42 -continue -} else { -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("seq")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v17}) -var v31 any = v35 -_ = v31 -var v37 any -if lang.IsTruthy(v31) { -var v38 any = v31 -_ = v38 -var v40 any -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("chunked-seq?")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v38}) -if lang.IsTruthy(v44) { -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("chunk-first")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) -} -v48 := v47.Get() -v49 := lang.Apply(v48, []any{v38}) -var v45 any = v49 -_ = v45 -v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("chunk-rest")) -if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) -} -v54 := v53.Get() -v55 := lang.Apply(v54, []any{v38}) -var v51 any = v55 -var v56 any = v45 -v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v59 := v58.FindInternedVar(lang.NewSymbol("int")) -if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) -} -v60 := v59.Get() -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("count")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) -} -v63 := v62.Get() -v64 := lang.Apply(v63, []any{v45}) -v65 := lang.Apply(v60, []any{v64}) -var v57 any = v65 -v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v68 := v67.FindInternedVar(lang.NewSymbol("int")) -if v68.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) -} -v69 := v68.Get() -v70 := lang.Apply(v69, []any{int64(0)}) -var v66 any = v70 -v17 = v51 -v22 = v56 -v23 = v57 -v24 = v66 -continue -} else { -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("first")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) -} -v48 := v47.Get() -v49 := lang.Apply(v48, []any{v38}) -var v45 any = v49 -_ = v45 -v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v52 := v51.FindInternedVar(lang.NewSymbol("send")) -if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) -} -v53 := v52.Get() -v54 := lang.Apply(v53, []any{v45, v12}) -_ = v54 -v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v57 := v56.FindInternedVar(lang.NewSymbol("next")) -if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) -} -v58 := v57.Get() -v59 := lang.Apply(v58, []any{v38}) -var v55 any = v59 -var v60 any = nil -var v61 any = int64(0) -var v62 any = int64(0) -v17 = v55 -v22 = v60 -v23 = v61 -v24 = v62 -continue -} -v37 = v40 -} else { -v37 = nil -} -v26 = v37 -} -v25 = v26 - break -} -_ = v25 -v17, _ := lang.FieldOrMethod(v11, "await") -if reflect.TypeOf(v17).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) -} -v18 := lang.Apply(v17, []any{}) -v4 = v18 -} -return v4 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// await-for -{ -v0 := lang.NewSymbol("await-for").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("timeout-ms"), lang.NewSymbol("&"), lang.NewSymbol("agents"))), lang.NewKeyword("doc"), "Blocks the current thread until all actions dispatched thus\n far (from this thread or agent) to the agents have occurred, or the\n timeout (in milliseconds) has elapsed. Returns logical false if\n returning due to timeout, logical true otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3289), lang.NewKeyword("end-line"), int(3289))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.NewList(args[1:]...) -var v5 any -v6 := lang.Apply(nil, nil) -if lang.IsTruthy(v6) { -panic("unimplemented: new with non-constant class type") -} else { -var v7 any -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("*agent*")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -if lang.IsTruthy(v10) { -v11 := lang.Apply(errors6.New, []any{"Can't await in agent action"}) -panic(v11) -} else { -v7 = nil -} -_ = v7 -var v12 any = "unimplemented: new with non-constant class type" -_ = v12 -var v14 lang.FnFunc -v14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v15 := args[0] -v16, _ := lang.FieldOrMethod(v12, "countDown") -if reflect.TypeOf(v16).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("countDown is not a function"))) -} -v17 := lang.Apply(v16, []any{}) -_ = v17 -return v15 -}) -v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3301), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(3301), lang.NewKeyword("end-column"), int(62)) -v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v13 any = v16 -_ = v13 -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("seq")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v4}) -var v18 any = v22 -_ = v18 -var v23 any = nil -_ = v23 -var v24 any = int64(0) -_ = v24 -var v25 any = int64(0) -_ = v25 -var v26 any -for { -var v27 any -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("<")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{v25, v24}) -if lang.IsTruthy(v31) { -v33, _ := lang.FieldOrMethod(v23, "nth") -if reflect.TypeOf(v33).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) -} -v34 := lang.Apply(v33, []any{v25}) -var v32 any = v34 -_ = v32 -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("send")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v32, v13}) -_ = v39 -var v40 any = v18 -var v41 any = v23 -var v42 any = v24 -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("unchecked-inc")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v25}) -var v43 any = v47 -v18 = v40 -v23 = v41 -v24 = v42 -v25 = v43 -continue -} else { -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("seq")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v18}) -var v32 any = v36 -_ = v32 -var v38 any -if lang.IsTruthy(v32) { -var v39 any = v32 -_ = v39 -var v41 any -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("chunked-seq?")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) -} -v44 := v43.Get() -v45 := lang.Apply(v44, []any{v39}) -if lang.IsTruthy(v45) { -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("chunk-first")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) -} -v49 := v48.Get() -v50 := lang.Apply(v49, []any{v39}) -var v46 any = v50 -_ = v46 -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("chunk-rest")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) -} -v55 := v54.Get() -v56 := lang.Apply(v55, []any{v39}) -var v52 any = v56 -var v57 any = v46 -v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v60 := v59.FindInternedVar(lang.NewSymbol("int")) -if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) -} -v61 := v60.Get() -v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v63 := v62.FindInternedVar(lang.NewSymbol("count")) -if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) -} -v64 := v63.Get() -v65 := lang.Apply(v64, []any{v46}) -v66 := lang.Apply(v61, []any{v65}) -var v58 any = v66 -v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v69 := v68.FindInternedVar(lang.NewSymbol("int")) -if v69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) -} -v70 := v69.Get() -v71 := lang.Apply(v70, []any{int64(0)}) -var v67 any = v71 -v18 = v52 -v23 = v57 -v24 = v58 -v25 = v67 -continue -} else { -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("first")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) -} -v49 := v48.Get() -v50 := lang.Apply(v49, []any{v39}) -var v46 any = v50 -_ = v46 -v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("send")) -if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) -} -v54 := v53.Get() -v55 := lang.Apply(v54, []any{v46, v13}) -_ = v55 -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("next")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) -} -v59 := v58.Get() -v60 := lang.Apply(v59, []any{v39}) -var v56 any = v60 -var v61 any = nil -var v62 any = int64(0) -var v63 any = int64(0) -v18 = v56 -v23 = v61 -v24 = v62 -v25 = v63 -continue -} -v38 = v41 -} else { -v38 = nil -} -v27 = v38 -} -v26 = v27 - break -} -_ = v26 -v18, ok := lang.FieldOrMethod(java.util.concurrent7.TimeUnit, "MILLISECONDS") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", java.util.concurrent7.TimeUnit, "MILLISECONDS"))) -} -var v19 any -switch reflect.TypeOf(v18).Kind() { -case reflect.Func: - v19 = lang.Apply(v18, nil) -default: - v19 = v18 -} -v20, _ := lang.FieldOrMethod(v12, "await") -if reflect.TypeOf(v20).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) -} -v21 := lang.Apply(v20, []any{v3, v19}) -v5 = v21 -} -return v5 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// await1 -{ -v0 := lang.NewSymbol("await1").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3284), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3284), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("pos?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8, ok := lang.FieldOrMethod(v3, "getQueueCount") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getQueueCount"))) -} -var v9 any -switch reflect.TypeOf(v8).Kind() { -case reflect.Func: - v9 = lang.Apply(v8, nil) -default: - v9 = v8 -} -v10 := lang.Apply(v7, []any{v9}) -if lang.IsTruthy(v10) { -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("await")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v3}) -v4 = v14 -} else { -v4 = nil -} -_ = v4 -return v3 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// bases -{ -v0 := lang.NewSymbol("bases").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"))), lang.NewKeyword("doc"), "Returns the immediate superclass and direct interfaces of c, if any", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5522), lang.NewKeyword("end-line"), int(5522))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -var v4 any -if lang.IsTruthy(v3) { -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("seq")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{nil}) -var v5 any = v9 -_ = v5 -var v10 any = nil -_ = v10 -var v12 any -if lang.IsTruthy(v10) { -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("cons")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v10, v5}) -v12 = v16 -} else { -v12 = v5 -} -v4 = v12 -} else { -v4 = nil -} -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// bigdec -{ -v1 := reflect.TypeOf((*lang.BigDecimal)(nil)) -v0 := lang.NewSymbol("bigdec").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Coerce to BigDecimal", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3648), lang.NewKeyword("end-line"), int(3648))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("decimal?")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v4}) -if lang.IsTruthy(v9) { -v5 = v4 -} else { -var v10 any -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("float?")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v4}) -if lang.IsTruthy(v14) { -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("double")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v4}) -v19 := lang.Apply(lang.NewBigDecimalFromFloat64, []any{v18}) -v10 = v19 -} else { -var v20 any -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("ratio?")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v4}) -if lang.IsTruthy(v24) { -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("/")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.Apply(lang.NewBigDecimalFromRatio, []any{v4}) -v29, ok := lang.FieldOrMethod(v4, "denominator") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "denominator"))) -} -var v30 any -switch reflect.TypeOf(v29).Kind() { -case reflect.Func: - v30 = lang.Apply(v29, nil) -default: - v30 = v29 -} -v31 := lang.Apply(v27, []any{v28, v30}) -v20 = v31 -} else { -var v32 any -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("instance?")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{lang.*BigInt, v4}) -if lang.IsTruthy(v36) { -v37, ok := lang.FieldOrMethod(v4, "toBigDecimal") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "toBigDecimal"))) -} -var v38 any -switch reflect.TypeOf(v37).Kind() { -case reflect.Func: - v38 = lang.Apply(v37, nil) -default: - v38 = v37 -} -v32 = v38 -} else { -var v39 any -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("instance?")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{big8.*Int, v4}) -if lang.IsTruthy(v43) { -v44 := lang.Apply(lang.NewBigDecimal, []any{v4}) -v39 = v44 -} else { -var v45 any -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("number?")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) -} -v48 := v47.Get() -v49 := lang.Apply(v48, []any{v4}) -if lang.IsTruthy(v49) { -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("long")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.Apply(v52, []any{v4}) -v54 := lang.Apply(lang.NewBigDecimalFromInt64, []any{v53}) -v45 = v54 -} else { -var v55 any -if lang.IsTruthy(lang.NewKeyword("else")) { -v56 := lang.Apply(lang.NewBigDecimal, []any{v4}) -v55 = v56 -} else { -v55 = nil -} -v45 = v55 -} -v39 = v45 -} -v32 = v39 -} -v20 = v32 -} -v10 = v20 -} -v5 = v10 -} -return v5 -}) -v4 := reflect.TypeOf((*lang.BigDecimal)(nil)) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// bigint -{ -v1 := reflect.TypeOf((*lang.BigInt)(nil)) -v0 := lang.NewSymbol("bigint").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Coerce to BigInt", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3620), lang.NewKeyword("end-line"), int(3620))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{lang.*BigInt, v4}) -if lang.IsTruthy(v9) { -v5 = v4 -} else { -var v10 any -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("instance?")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{big8.*Int, v4}) -if lang.IsTruthy(v14) { -v15 := lang.Apply(lang.NewBigIntFromGoBigInt, []any{v4}) -v10 = v15 -} else { -var v16 any -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("decimal?")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v4}) -if lang.IsTruthy(v20) { -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("bigint")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24, ok := lang.FieldOrMethod(v4, "toBigInteger") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "toBigInteger"))) -} -var v25 any -switch reflect.TypeOf(v24).Kind() { -case reflect.Func: - v25 = lang.Apply(v24, nil) -default: - v25 = v24 -} -v26 := lang.Apply(v23, []any{v25}) -v16 = v26 -} else { -var v27 any -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("float?")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{v4}) -if lang.IsTruthy(v31) { -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("bigint")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("double")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v4}) -v39 := lang.Apply(lang.NewBigDecimalFromFloat64, []any{v38}) -v40 := lang.Apply(v34, []any{v39}) -v27 = v40 -} else { -var v41 any -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("ratio?")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) -} -v44 := v43.Get() -v45 := lang.Apply(v44, []any{v4}) -if lang.IsTruthy(v45) { -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("bigint")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) -} -v48 := v47.Get() -v49, ok := lang.FieldOrMethod(v4, "bigIntegerValue") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "bigIntegerValue"))) -} -var v50 any -switch reflect.TypeOf(v49).Kind() { -case reflect.Func: - v50 = lang.Apply(v49, nil) -default: - v50 = v49 -} -v51 := lang.Apply(v48, []any{v50}) -v41 = v51 -} else { -var v52 any -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("number?")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) -} -v55 := v54.Get() -v56 := lang.Apply(v55, []any{v4}) -if lang.IsTruthy(v56) { -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("long")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) -} -v59 := v58.Get() -v60 := lang.Apply(v59, []any{v4}) -v61 := lang.Apply(lang.NewBigIntFromInt64, []any{v60}) -v52 = v61 -} else { -var v62 any -if lang.IsTruthy(lang.NewKeyword("else")) { -v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v64 := v63.FindInternedVar(lang.NewSymbol("bigint")) -if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) -} -v65 := v64.Get() -v66 := lang.Apply(lang.NewBigInt, []any{v4}) -v67 := lang.Apply(v65, []any{v66}) -v62 = v67 -} else { -v62 = nil -} -v52 = v62 -} -v41 = v52 -} -v27 = v41 -} -v16 = v27 -} -v10 = v16 -} -v5 = v10 -} -return v5 -}) -v4 := reflect.TypeOf((*lang.BigInt)(nil)) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// biginteger -{ -v1 := reflect.TypeOf((*big8.Int)(nil)) -v0 := lang.NewSymbol("biginteger").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Coerce to BigInteger", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3634), lang.NewKeyword("end-line"), int(3634))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{big8.*Int, v4}) -if lang.IsTruthy(v9) { -v5 = v4 -} else { -var v10 any -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("instance?")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{lang.*BigInt, v4}) -if lang.IsTruthy(v14) { -v15, ok := lang.FieldOrMethod(v4, "toBigInteger") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "toBigInteger"))) -} -var v16 any -switch reflect.TypeOf(v15).Kind() { -case reflect.Func: - v16 = lang.Apply(v15, nil) -default: - v16 = v15 -} -v10 = v16 -} else { -var v17 any -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("decimal?")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v20, []any{v4}) -if lang.IsTruthy(v21) { -v22, ok := lang.FieldOrMethod(v4, "toBigInteger") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "toBigInteger"))) -} -var v23 any -switch reflect.TypeOf(v22).Kind() { -case reflect.Func: - v23 = lang.Apply(v22, nil) -default: - v23 = v22 -} -v17 = v23 -} else { -var v24 any -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("float?")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.Apply(v27, []any{v4}) -if lang.IsTruthy(v28) { -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("double")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.Apply(v31, []any{v4}) -v33 := lang.Apply(lang.NewBigDecimalFromFloat64, []any{v32}) -v34, ok := lang.FieldOrMethod(v33, "toBigInteger") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v33, "toBigInteger"))) -} -var v35 any -switch reflect.TypeOf(v34).Kind() { -case reflect.Func: - v35 = lang.Apply(v34, nil) -default: - v35 = v34 -} -v24 = v35 -} else { -var v36 any -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("ratio?")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v4}) -if lang.IsTruthy(v40) { -v41, ok := lang.FieldOrMethod(v4, "bigIntegerValue") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "bigIntegerValue"))) -} -var v42 any -switch reflect.TypeOf(v41).Kind() { -case reflect.Func: - v42 = lang.Apply(v41, nil) -default: - v42 = v41 -} -v36 = v42 -} else { -var v43 any -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("number?")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v4}) -if lang.IsTruthy(v47) { -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("long")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v4}) -v52 := lang.Apply(big8.NewInt, []any{v51}) -v43 = v52 -} else { -var v53 any -if lang.IsTruthy(lang.NewKeyword("else")) { -v54 := lang.Apply(lang.NewBigInt, []any{v4}) -v53 = v54 -} else { -v53 = nil -} -v43 = v53 -} -v36 = v43 -} -v24 = v36 -} -v17 = v24 -} -v10 = v17 -} -v5 = v10 -} -return v5 -}) -v4 := reflect.TypeOf((*big8.Int)(nil)) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// binding -{ -v0 := lang.NewSymbol("binding").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "binding => var-symbol init-expr\n\n Creates new bindings for the (already-existing) vars, with the\n supplied initial values, executes the exprs in an implicit do, then\n re-establishes the bindings that existed before. The new bindings\n are made in parallel (unlike let); all init-exprs are evaluated\n before the vars are bound to their new values.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1945), lang.NewKeyword("end-line"), int(1945))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -var v7 any -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v5}) -if lang.IsTruthy(v11) { -v7 = nil -} else { -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("str")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("first")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v3}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("meta")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) -v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) -v28 := lang.Apply(lang.NewIllegalArgumentError, []any{v27}) -panic(v28) -} -_ = v7 -var v29 any -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("even?")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("count")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v5}) -v37 := lang.Apply(v32, []any{v36}) -if lang.IsTruthy(v37) { -v29 = nil -} else { -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("str")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("first")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v3}) -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("meta")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v3}) -v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) -v53 := lang.Apply(v40, []any{v44, " requires ", "an even number of forms in binding vector", " in ", v47, ":", v52}) -v54 := lang.Apply(lang.NewIllegalArgumentError, []any{v53}) -panic(v54) -} -_ = v29 -_ = nil -var v56 lang.FnFunc -v56 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v57 := args[0] -v59 := lang.NewVector() -v60 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1959), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(1959), lang.NewKeyword("end-column"), int(31)) -v61, err := lang.WithMeta(v59, v60.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v58 any = v61 -_ = v58 -v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v64 := v63.FindInternedVar(lang.NewSymbol("seq")) -if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) -} -v65 := v64.Get() -v66 := lang.Apply(v65, []any{v57}) -var v62 any = v66 -_ = v62 -var v67 any -for { -var v68 any -if lang.IsTruthy(v62) { -v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v71 := v70.FindInternedVar(lang.NewSymbol("conj")) -if v71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) -} -v72 := v71.Get() -v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v74 := v73.FindInternedVar(lang.NewSymbol("conj")) -if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) -} -v75 := v74.Get() -v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v77 := v76.FindInternedVar(lang.NewSymbol("seq")) -if v77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) -} -v78 := v77.Get() -v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v80 := v79.FindInternedVar(lang.NewSymbol("concat")) -if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) -} -v81 := v80.Get() -v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v83 := v82.FindInternedVar(lang.NewSymbol("list")) -if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) -} -v84 := v83.Get() -v85 := lang.Apply(v84, []any{lang.NewSymbol("var")}) -v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v87 := v86.FindInternedVar(lang.NewSymbol("list")) -if v87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) -} -v88 := v87.Get() -v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v90 := v89.FindInternedVar(lang.NewSymbol("first")) -if v90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) -} -v91 := v90.Get() -v92 := lang.Apply(v91, []any{v62}) -v93 := lang.Apply(v88, []any{v92}) -v94 := lang.Apply(v81, []any{v85, v93}) -v95 := lang.Apply(v78, []any{v94}) -v96 := lang.Apply(v75, []any{v58, v95}) -v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v98 := v97.FindInternedVar(lang.NewSymbol("second")) -if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) -} -v99 := v98.Get() -v100 := lang.Apply(v99, []any{v62}) -v101 := lang.Apply(v72, []any{v96, v100}) -var v69 any = v101 -v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v104 := v103.FindInternedVar(lang.NewSymbol("next")) -if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) -} -v105 := v104.Get() -v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v107 := v106.FindInternedVar(lang.NewSymbol("next")) -if v107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) -} -v108 := v107.Get() -v109 := lang.Apply(v108, []any{v62}) -v110 := lang.Apply(v105, []any{v109}) -var v102 any = v110 -v58 = v69 -v62 = v102 -continue -} else { -v111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v112 := v111.FindInternedVar(lang.NewSymbol("seq")) -if v112.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v112))) -} -v113 := v112.Get() -v114 := lang.Apply(v113, []any{v58}) -v68 = v114 -} -v67 = v68 - break -} -return v67 -}) -v57 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1958), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(1963), lang.NewKeyword("end-column"), int(34)) -v58, err := lang.WithMeta(v56, v57.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v55 any = v58 -_ = v55 -v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v61 := v60.FindInternedVar(lang.NewSymbol("seq")) -if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) -} -v62 := v61.Get() -v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v64 := v63.FindInternedVar(lang.NewSymbol("concat")) -if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) -} -v65 := v64.Get() -v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v67 := v66.FindInternedVar(lang.NewSymbol("list")) -if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) -} -v68 := v67.Get() -v69 := lang.Apply(v68, []any{lang.NewSymbol("glojure.core/let")}) -v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v71 := v70.FindInternedVar(lang.NewSymbol("list")) -if v71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) -} -v72 := v71.Get() -v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v74 := v73.FindInternedVar(lang.NewSymbol("apply")) -if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) -} -v75 := v74.Get() -v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v77 := v76.FindInternedVar(lang.NewSymbol("vector")) -if v77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) -} -v78 := v77.Get() -v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v80 := v79.FindInternedVar(lang.NewSymbol("seq")) -if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) -} -v81 := v80.Get() -v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v83 := v82.FindInternedVar(lang.NewSymbol("concat")) -if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) -} -v84 := v83.Get() -v85 := lang.Apply(v84, nil) -v86 := lang.Apply(v81, []any{v85}) -v87 := lang.Apply(v75, []any{v78, v86}) -v88 := lang.Apply(v72, []any{v87}) -v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v90 := v89.FindInternedVar(lang.NewSymbol("list")) -if v90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) -} -v91 := v90.Get() -v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v93 := v92.FindInternedVar(lang.NewSymbol("seq")) -if v93.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) -} -v94 := v93.Get() -v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v96 := v95.FindInternedVar(lang.NewSymbol("concat")) -if v96.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) -} -v97 := v96.Get() -v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v99 := v98.FindInternedVar(lang.NewSymbol("list")) -if v99.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) -} -v100 := v99.Get() -v101 := lang.Apply(v100, []any{lang.NewSymbol("glojure.core/push-thread-bindings")}) -v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v103 := v102.FindInternedVar(lang.NewSymbol("list")) -if v103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) -} -v104 := v103.Get() -v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v106 := v105.FindInternedVar(lang.NewSymbol("seq")) -if v106.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) -} -v107 := v106.Get() -v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v109 := v108.FindInternedVar(lang.NewSymbol("concat")) -if v109.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) -} -v110 := v109.Get() -v111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v112 := v111.FindInternedVar(lang.NewSymbol("list")) -if v112.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v112))) -} -v113 := v112.Get() -v114 := lang.Apply(v113, []any{lang.NewSymbol("glojure.core/hash-map")}) -v115 := lang.Apply(v55, []any{v5}) -v116 := lang.Apply(v110, []any{v114, v115}) -v117 := lang.Apply(v107, []any{v116}) -v118 := lang.Apply(v104, []any{v117}) -v119 := lang.Apply(v97, []any{v101, v118}) -v120 := lang.Apply(v94, []any{v119}) -v121 := lang.Apply(v91, []any{v120}) -v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v123 := v122.FindInternedVar(lang.NewSymbol("list")) -if v123.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) -} -v124 := v123.Get() -v125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v126 := v125.FindInternedVar(lang.NewSymbol("seq")) -if v126.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v126))) -} -v127 := v126.Get() -v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v129 := v128.FindInternedVar(lang.NewSymbol("concat")) -if v129.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v129))) -} -v130 := v129.Get() -v131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v132 := v131.FindInternedVar(lang.NewSymbol("list")) -if v132.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v132))) -} -v133 := v132.Get() -v134 := lang.Apply(v133, []any{lang.NewSymbol("try")}) -v135 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v136 := v135.FindInternedVar(lang.NewSymbol("list")) -if v136.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v136))) -} -v137 := v136.Get() -v138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v139 := v138.FindInternedVar(lang.NewSymbol("seq")) -if v139.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v139))) -} -v140 := v139.Get() -v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v142 := v141.FindInternedVar(lang.NewSymbol("concat")) -if v142.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) -} -v143 := v142.Get() -v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v145 := v144.FindInternedVar(lang.NewSymbol("list")) -if v145.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) -} -v146 := v145.Get() -v147 := lang.Apply(v146, []any{lang.NewSymbol("finally")}) -v148 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v149 := v148.FindInternedVar(lang.NewSymbol("list")) -if v149.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v149))) -} -v150 := v149.Get() -v151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v152 := v151.FindInternedVar(lang.NewSymbol("seq")) -if v152.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v152))) -} -v153 := v152.Get() -v154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v155 := v154.FindInternedVar(lang.NewSymbol("concat")) -if v155.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v155))) -} -v156 := v155.Get() -v157 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v158 := v157.FindInternedVar(lang.NewSymbol("list")) -if v158.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v158))) -} -v159 := v158.Get() -v160 := lang.Apply(v159, []any{lang.NewSymbol("glojure.core/pop-thread-bindings")}) -v161 := lang.Apply(v156, []any{v160}) -v162 := lang.Apply(v153, []any{v161}) -v163 := lang.Apply(v150, []any{v162}) -v164 := lang.Apply(v143, []any{v147, v163}) -v165 := lang.Apply(v140, []any{v164}) -v166 := lang.Apply(v137, []any{v165}) -v167 := lang.Apply(v130, []any{v134, v6, v166}) -v168 := lang.Apply(v127, []any{v167}) -v169 := lang.Apply(v124, []any{v168}) -v170 := lang.Apply(v65, []any{v69, v88, v121, v169}) -v171 := lang.Apply(v62, []any{v170}) -return v171 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// binding-conveyor-fn -{ -v0 := lang.NewSymbol("binding-conveyor-fn").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2020), lang.NewKeyword("end-line"), int(2020), lang.NewKeyword("private"), true)).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v5 := lang.Apply(lang.CloneThreadBindingFrame, nil) -var v4 any = v5 -_ = v4 -var v7 lang.FnFunc -v7 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v8 := lang.Apply(lang.ResetThreadBindingFrame, []any{v4}) -_ = v8 -v9 := lang.Apply(v3, nil) -return v9 - case 1: -v8 := args[0] -v9 := lang.Apply(lang.ResetThreadBindingFrame, []any{v4}) -_ = v9 -v10 := lang.Apply(v3, []any{v8}) -return v10 - case 2: -v8 := args[0] -v9 := args[1] -v10 := lang.Apply(lang.ResetThreadBindingFrame, []any{v4}) -_ = v10 -v11 := lang.Apply(v3, []any{v8, v9}) -return v11 - case 3: -v8 := args[0] -v9 := args[1] -v10 := args[2] -v11 := lang.Apply(lang.ResetThreadBindingFrame, []any{v4}) -_ = v11 -v12 := lang.Apply(v3, []any{v8, v9, v10}) -return v12 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v8 := args[0] -v9 := args[1] -v10 := args[2] -v11 := lang.NewList(args[3:]...) -v12 := lang.Apply(lang.ResetThreadBindingFrame, []any{v4}) -_ = v12 -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("apply")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v3, v8, v9, v10, v11}) -return v16 - } -}) -v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2025), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2040), lang.NewKeyword("end-column"), int(31)) -v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v9 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// bit-and -{ -var v1 lang.FnFunc -v1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v2 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -if lang.IsTruthy(v7) { -v4 = closed7 -} else { -v4 = v3 -} -var v3 any = v4 -_ = v3 -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("seq")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("concat")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("seq")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("concat")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v2}) -v40 := lang.Apply(v31, []any{v35, v39}) -v41 := lang.Apply(v28, []any{v40}) -v42 := lang.Apply(v25, []any{v41}) -v43 := lang.Apply(v14, []any{v18, v22, v42}) -v44 := lang.Apply(v11, []any{v43}) -return v44 - case 2: -v2 := args[0] -v3 := args[1] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -if lang.IsTruthy(v8) { -v5 = closed7 -} else { -v5 = v4 -} -var v4 any = v5 -_ = v4 -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("seq")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("concat")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("list")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("list")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("list")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("seq")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("concat")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("list")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v4}) -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("list")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v2}) -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("list")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v3}) -v45 := lang.Apply(v32, []any{v36, v40, v44}) -v46 := lang.Apply(v29, []any{v45}) -v47 := lang.Apply(v26, []any{v46}) -v48 := lang.Apply(v15, []any{v19, v23, v47}) -v49 := lang.Apply(v12, []any{v48}) -return v49 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v2 := args[0] -v3 := args[1] -v4 := lang.NewList(args[2:]...) -var v6 any -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -if lang.IsTruthy(v9) { -v6 = closed7 -} else { -v6 = v5 -} -var v5 any = v6 -_ = v5 -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -var v14 lang.FnFunc -v14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v15 := args[0] -v16 := args[1] -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("concat")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v5}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v15}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v16}) -v52 := lang.Apply(v39, []any{v43, v47, v51}) -v53 := lang.Apply(v36, []any{v52}) -v54 := lang.Apply(v33, []any{v53}) -v55 := lang.Apply(v22, []any{v26, v30, v54}) -v56 := lang.Apply(v19, []any{v55}) -return v56 -}) -v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) -v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("concat")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v5}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v2}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v3}) -v52 := lang.Apply(v39, []any{v43, v47, v51}) -v53 := lang.Apply(v36, []any{v52}) -v54 := lang.Apply(v33, []any{v53}) -v55 := lang.Apply(v22, []any{v26, v30, v54}) -v56 := lang.Apply(v19, []any{v55}) -v57 := lang.Apply(v13, []any{v16, v56, v4}) -return v57 - } -}) -v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) -} -v5 := lang.Apply(v4, []any{v3, int64(1)}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v0 := lang.NewSymbol("bit-and").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Bitwise and", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1298), lang.NewKeyword("end-line"), int(1298))).(*lang.Symbol) -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v5 := args[0] -v6 := args[1] -v7, _ := lang.FieldOrMethod(lang.Numbers, "and") -if reflect.TypeOf(v7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("and is not a function"))) -} -v8 := lang.Apply(v7, []any{v5, v6}) -return v8 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := args[0] -v6 := args[1] -v7 := lang.NewList(args[2:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("bit-and")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("bit-and")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v5, v6}) -v18 := lang.Apply(v10, []any{v13, v17, v7}) -return v18 - } -}) -v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v3 := ns.InternWithValue(v0, v4, true) -if v0.Meta() != nil { - v3.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// bit-and-not -{ -var v1 lang.FnFunc -v1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v2 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -if lang.IsTruthy(v7) { -v4 = closed8 -} else { -v4 = v3 -} -var v3 any = v4 -_ = v3 -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("seq")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("concat")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("seq")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("concat")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v2}) -v40 := lang.Apply(v31, []any{v35, v39}) -v41 := lang.Apply(v28, []any{v40}) -v42 := lang.Apply(v25, []any{v41}) -v43 := lang.Apply(v14, []any{v18, v22, v42}) -v44 := lang.Apply(v11, []any{v43}) -return v44 - case 2: -v2 := args[0] -v3 := args[1] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -if lang.IsTruthy(v8) { -v5 = closed8 -} else { -v5 = v4 -} -var v4 any = v5 -_ = v4 -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("seq")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("concat")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("list")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("list")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("list")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("seq")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("concat")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("list")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v4}) -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("list")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v2}) -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("list")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v3}) -v45 := lang.Apply(v32, []any{v36, v40, v44}) -v46 := lang.Apply(v29, []any{v45}) -v47 := lang.Apply(v26, []any{v46}) -v48 := lang.Apply(v15, []any{v19, v23, v47}) -v49 := lang.Apply(v12, []any{v48}) -return v49 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v2 := args[0] -v3 := args[1] -v4 := lang.NewList(args[2:]...) -var v6 any -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -if lang.IsTruthy(v9) { -v6 = closed8 -} else { -v6 = v5 -} -var v5 any = v6 -_ = v5 -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -var v14 lang.FnFunc -v14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v15 := args[0] -v16 := args[1] -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("concat")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v5}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v15}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v16}) -v52 := lang.Apply(v39, []any{v43, v47, v51}) -v53 := lang.Apply(v36, []any{v52}) -v54 := lang.Apply(v33, []any{v53}) -v55 := lang.Apply(v22, []any{v26, v30, v54}) -v56 := lang.Apply(v19, []any{v55}) -return v56 -}) -v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) -v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("concat")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v5}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v2}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v3}) -v52 := lang.Apply(v39, []any{v43, v47, v51}) -v53 := lang.Apply(v36, []any{v52}) -v54 := lang.Apply(v33, []any{v53}) -v55 := lang.Apply(v22, []any{v26, v30, v54}) -v56 := lang.Apply(v19, []any{v55}) -v57 := lang.Apply(v13, []any{v16, v56, v4}) -return v57 - } -}) -v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) -} -v5 := lang.Apply(v4, []any{v3, int64(1)}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v0 := lang.NewSymbol("bit-and-not").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Bitwise and with complement", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1325), lang.NewKeyword("end-line"), int(1325))).(*lang.Symbol) -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v5 := args[0] -v6 := args[1] -v7, _ := lang.FieldOrMethod(lang.Numbers, "andNot") -if reflect.TypeOf(v7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("andNot is not a function"))) -} -v8 := lang.Apply(v7, []any{v5, v6}) -return v8 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := args[0] -v6 := args[1] -v7 := lang.NewList(args[2:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("bit-and-not")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("bit-and-not")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v5, v6}) -v18 := lang.Apply(v10, []any{v13, v17, v7}) -return v18 - } -}) -v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v3 := ns.InternWithValue(v0, v4, true) -if v0.Meta() != nil { - v3.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// bit-clear -{ -v0 := lang.NewSymbol("bit-clear").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Clear bit at index n", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1336), lang.NewKeyword("end-line"), int(1336))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5, _ := lang.FieldOrMethod(lang.Numbers, "clearBit") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("clearBit is not a function"))) -} -v6 := lang.Apply(v5, []any{v3, v4}) -return v6 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// bit-flip -{ -v0 := lang.NewSymbol("bit-flip").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Flip bit at index n", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1348), lang.NewKeyword("end-line"), int(1348))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5, _ := lang.FieldOrMethod(lang.Numbers, "flipBit") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("flipBit is not a function"))) -} -v6 := lang.Apply(v5, []any{v3, v4}) -return v6 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// bit-not -{ -var v1 lang.FnFunc -{ // function bit-not__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/not")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v3}) -v35 := lang.Apply(v26, []any{v30, v34}) -v36 := lang.Apply(v23, []any{v35}) -v37 := lang.Apply(v20, []any{v36}) -v38 := lang.Apply(v9, []any{v13, v17, v37}) -v39 := lang.Apply(v6, []any{v38}) -return v39 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("bit-not").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Bitwise complement", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1291), lang.NewKeyword("end-line"), int(1291))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5, _ := lang.FieldOrMethod(lang.Numbers, "not") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("not is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// bit-or -{ -var v1 lang.FnFunc -v1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v2 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -if lang.IsTruthy(v7) { -v4 = closed9 -} else { -v4 = v3 -} -var v3 any = v4 -_ = v3 -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("seq")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("concat")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("seq")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("concat")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v2}) -v40 := lang.Apply(v31, []any{v35, v39}) -v41 := lang.Apply(v28, []any{v40}) -v42 := lang.Apply(v25, []any{v41}) -v43 := lang.Apply(v14, []any{v18, v22, v42}) -v44 := lang.Apply(v11, []any{v43}) -return v44 - case 2: -v2 := args[0] -v3 := args[1] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -if lang.IsTruthy(v8) { -v5 = closed9 -} else { -v5 = v4 -} -var v4 any = v5 -_ = v4 -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("seq")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("concat")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("list")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("list")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("list")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("seq")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("concat")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("list")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v4}) -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("list")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v2}) -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("list")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v3}) -v45 := lang.Apply(v32, []any{v36, v40, v44}) -v46 := lang.Apply(v29, []any{v45}) -v47 := lang.Apply(v26, []any{v46}) -v48 := lang.Apply(v15, []any{v19, v23, v47}) -v49 := lang.Apply(v12, []any{v48}) -return v49 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v2 := args[0] -v3 := args[1] -v4 := lang.NewList(args[2:]...) -var v6 any -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -if lang.IsTruthy(v9) { -v6 = closed9 -} else { -v6 = v5 -} -var v5 any = v6 -_ = v5 -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -var v14 lang.FnFunc -v14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v15 := args[0] -v16 := args[1] -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("concat")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v5}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v15}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v16}) -v52 := lang.Apply(v39, []any{v43, v47, v51}) -v53 := lang.Apply(v36, []any{v52}) -v54 := lang.Apply(v33, []any{v53}) -v55 := lang.Apply(v22, []any{v26, v30, v54}) -v56 := lang.Apply(v19, []any{v55}) -return v56 -}) -v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) -v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("concat")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v5}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v2}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v3}) -v52 := lang.Apply(v39, []any{v43, v47, v51}) -v53 := lang.Apply(v36, []any{v52}) -v54 := lang.Apply(v33, []any{v53}) -v55 := lang.Apply(v22, []any{v26, v30, v54}) -v56 := lang.Apply(v19, []any{v55}) -v57 := lang.Apply(v13, []any{v16, v56, v4}) -return v57 - } -}) -v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) -} -v5 := lang.Apply(v4, []any{v3, int64(1)}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v0 := lang.NewSymbol("bit-or").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Bitwise or", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1307), lang.NewKeyword("end-line"), int(1307))).(*lang.Symbol) -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v5 := args[0] -v6 := args[1] -v7, _ := lang.FieldOrMethod(lang.Numbers, "or") -if reflect.TypeOf(v7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("or is not a function"))) -} -v8 := lang.Apply(v7, []any{v5, v6}) -return v8 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := args[0] -v6 := args[1] -v7 := lang.NewList(args[2:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("bit-or")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("bit-or")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v5, v6}) -v18 := lang.Apply(v10, []any{v13, v17, v7}) -return v18 - } -}) -v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v3 := ns.InternWithValue(v0, v4, true) -if v0.Meta() != nil { - v3.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// bit-set -{ -v0 := lang.NewSymbol("bit-set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Set bit at index n", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1342), lang.NewKeyword("end-line"), int(1342))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5, _ := lang.FieldOrMethod(lang.Numbers, "setBit") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setBit is not a function"))) -} -v6 := lang.Apply(v5, []any{v3, v4}) -return v6 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// bit-shift-left -{ -var v1 lang.FnFunc -{ // function bit-shift-left__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("concat")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("list")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("seq")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("concat")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("list")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/shiftLeft")}) -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v4}) -v40 := lang.Apply(v27, []any{v31, v35, v39}) -v41 := lang.Apply(v24, []any{v40}) -v42 := lang.Apply(v21, []any{v41}) -v43 := lang.Apply(v10, []any{v14, v18, v42}) -v44 := lang.Apply(v7, []any{v43}) -return v44 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("bit-shift-left").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Bitwise shift left", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1361), lang.NewKeyword("end-line"), int(1361))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6, _ := lang.FieldOrMethod(lang.Numbers, "shiftLeft") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("shiftLeft is not a function"))) -} -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// bit-shift-right -{ -var v1 lang.FnFunc -{ // function bit-shift-right__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("concat")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("list")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("seq")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("concat")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("list")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/shiftRight")}) -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v4}) -v40 := lang.Apply(v27, []any{v31, v35, v39}) -v41 := lang.Apply(v24, []any{v40}) -v42 := lang.Apply(v21, []any{v41}) -v43 := lang.Apply(v10, []any{v14, v18, v42}) -v44 := lang.Apply(v7, []any{v43}) -return v44 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("bit-shift-right").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Bitwise shift right", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1367), lang.NewKeyword("end-line"), int(1367))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6, _ := lang.FieldOrMethod(lang.Numbers, "shiftRight") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("shiftRight is not a function"))) -} -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// bit-test -{ -v0 := lang.NewSymbol("bit-test").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Test bit at index n", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1354), lang.NewKeyword("end-line"), int(1354))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5, _ := lang.FieldOrMethod(lang.Numbers, "testBit") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("testBit is not a function"))) -} -v6 := lang.Apply(v5, []any{v3, v4}) -return v6 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// bit-xor -{ -var v1 lang.FnFunc -v1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v2 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -if lang.IsTruthy(v7) { -v4 = closed10 -} else { -v4 = v3 -} -var v3 any = v4 -_ = v3 -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("seq")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("concat")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("seq")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("concat")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v2}) -v40 := lang.Apply(v31, []any{v35, v39}) -v41 := lang.Apply(v28, []any{v40}) -v42 := lang.Apply(v25, []any{v41}) -v43 := lang.Apply(v14, []any{v18, v22, v42}) -v44 := lang.Apply(v11, []any{v43}) -return v44 - case 2: -v2 := args[0] -v3 := args[1] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -if lang.IsTruthy(v8) { -v5 = closed10 -} else { -v5 = v4 -} -var v4 any = v5 -_ = v4 -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("seq")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("concat")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("list")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("list")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("list")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("seq")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("concat")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("list")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v4}) -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("list")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v2}) -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("list")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v3}) -v45 := lang.Apply(v32, []any{v36, v40, v44}) -v46 := lang.Apply(v29, []any{v45}) -v47 := lang.Apply(v26, []any{v46}) -v48 := lang.Apply(v15, []any{v19, v23, v47}) -v49 := lang.Apply(v12, []any{v48}) -return v49 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v2 := args[0] -v3 := args[1] -v4 := lang.NewList(args[2:]...) -var v6 any -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -if lang.IsTruthy(v9) { -v6 = closed10 -} else { -v6 = v5 -} -var v5 any = v6 -_ = v5 -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -var v14 lang.FnFunc -v14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v15 := args[0] -v16 := args[1] -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("concat")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v5}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v15}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v16}) -v52 := lang.Apply(v39, []any{v43, v47, v51}) -v53 := lang.Apply(v36, []any{v52}) -v54 := lang.Apply(v33, []any{v53}) -v55 := lang.Apply(v22, []any{v26, v30, v54}) -v56 := lang.Apply(v19, []any{v55}) -return v56 -}) -v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) -v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("concat")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v5}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v2}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v3}) -v52 := lang.Apply(v39, []any{v43, v47, v51}) -v53 := lang.Apply(v36, []any{v52}) -v54 := lang.Apply(v33, []any{v53}) -v55 := lang.Apply(v22, []any{v26, v30, v54}) -v56 := lang.Apply(v19, []any{v55}) -v57 := lang.Apply(v13, []any{v16, v56, v4}) -return v57 - } -}) -v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) -} -v5 := lang.Apply(v4, []any{v3, int64(1)}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v0 := lang.NewSymbol("bit-xor").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Bitwise exclusive or", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1316), lang.NewKeyword("end-line"), int(1316))).(*lang.Symbol) -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v5 := args[0] -v6 := args[1] -v7, _ := lang.FieldOrMethod(lang.Numbers, "xor") -if reflect.TypeOf(v7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("xor is not a function"))) -} -v8 := lang.Apply(v7, []any{v5, v6}) -return v8 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := args[0] -v6 := args[1] -v7 := lang.NewList(args[2:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("bit-xor")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("bit-xor")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v5, v6}) -v18 := lang.Apply(v10, []any{v13, v17, v7}) -return v18 - } -}) -v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v3 := ns.InternWithValue(v0, v4, true) -if v0.Meta() != nil { - v3.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// boolean -{ -var v1 lang.FnFunc -{ // function boolean__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/BooleanCast")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v3}) -v35 := lang.Apply(v26, []any{v30, v34}) -v36 := lang.Apply(v23, []any{v35}) -v37 := lang.Apply(v20, []any{v36}) -v38 := lang.Apply(v9, []any{v13, v17, v37}) -v39 := lang.Apply(v6, []any{v38}) -return v39 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("boolean").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to boolean", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1601), lang.NewKeyword("end-line"), int(1601))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5, _ := lang.FieldOrMethod(runtime5.RT, "BooleanCast") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("BooleanCast is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// boolean-array -{ -var v1 lang.FnFunc -{ // function boolean-array__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewList(args[0:]...) -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/booleanArray")}) -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("list")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("seq")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("concat")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("list")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.Apply(v37, []any{lang.NewSymbol("glojure.core/args")}) -v39 := lang.Apply(v30, []any{v34, v38}) -v40 := lang.Apply(v27, []any{v39}) -v41 := lang.Apply(v24, []any{v40}) -v42 := lang.Apply(v9, []any{v13, v17, v21, v41}) -v43 := lang.Apply(v6, []any{v42}) -return v43 - } -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("boolean-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Creates an array of booleans", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)int64(2)), lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5309), lang.NewKeyword("end-line"), int(5309))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v4 := args[0] -v5, _ := lang.FieldOrMethod(lang.Numbers, "booleanArray") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("booleanArray is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 - case 2: -v4 := args[0] -v5 := args[1] -v6, _ := lang.FieldOrMethod(lang.Numbers, "booleanArrayInit") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("booleanArrayInit is not a function"))) -} -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// boolean? -{ -v0 := lang.NewSymbol("boolean?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a Boolean", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(518), lang.NewKeyword("end-line"), int(518))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{lang.Builtins["bool"], v3}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// booleans -{ -var v1 lang.FnFunc -{ // function booleans -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/booleans")}) -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("list")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v26 := lang.Apply(v9, []any{v13, v17, v21, v25}) -v27 := lang.Apply(v6, []any{v26}) -return v27 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("booleans").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Casts to boolean[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5372), lang.NewKeyword("end-line"), int(5372))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5, _ := lang.FieldOrMethod(lang.Numbers, "booleans") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("booleans is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// bound-fn -{ -v0 := lang.NewSymbol("bound-fn").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("fntail"))), lang.NewKeyword("doc"), "Returns a function defined by the given fntail, which will install the\n same bindings in effect as in the thread at the time bound-fn was called.\n This may be used to define a helper function which runs on a different\n thread, but needs the same bindings in place.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(2004), lang.NewKeyword("end-line"), int(2004))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("seq")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("concat")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("list")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{lang.NewSymbol("glojure.core/bound-fn*")}) -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("list")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("seq")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("concat")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("list")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.Apply(v27, []any{lang.NewSymbol("glojure.core/fn")}) -v29 := lang.Apply(v24, []any{v28, v5}) -v30 := lang.Apply(v21, []any{v29}) -v31 := lang.Apply(v18, []any{v30}) -v32 := lang.Apply(v11, []any{v15, v31}) -v33 := lang.Apply(v8, []any{v32}) -return v33 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// bound-fn* -{ -v0 := lang.NewSymbol("bound-fn*").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Returns a function, which will install the same bindings in effect as in\n the thread at the time bound-fn* was called and then call f with any given\n arguments. This may be used to define a helper function which runs on a\n different thread, but needs the same bindings in place.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1992), lang.NewKeyword("end-line"), int(1992))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("get-thread-bindings")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, nil) -var v4 any = v8 -_ = v4 -var v10 lang.FnFunc -v10 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v11 := lang.NewList(args[0:]...) -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("apply")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("with-bindings*")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v14, []any{v17, v4, v3, v11}) -return v18 - } -}) -v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2001), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2002), lang.NewKeyword("end-column"), int(45)) -v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v12 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// bound? -{ -v0 := lang.NewSymbol("bound?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("vars"))), lang.NewKeyword("doc"), "Returns true if all of the vars provided as arguments have any bound value, root or thread-local.\n Implies that deref'ing the provided vars will succeed. Returns true if no vars are provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5491), lang.NewKeyword("end-line"), int(5491))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewList(args[0:]...) -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("every?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -var v7 lang.FnFunc -v7 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v8 := args[0] -v9, ok := lang.FieldOrMethod(v8, "isBound") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "isBound"))) -} -var v10 any -switch reflect.TypeOf(v9).Kind() { -case reflect.Func: - v10 = lang.Apply(v9, nil) -default: - v10 = v9 -} -return v10 -}) -v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5497), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5497), lang.NewKeyword("end-column"), int(69)) -v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v10 := lang.Apply(v6, []any{v9, v3}) -return v10 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// bounded-count -{ -v0 := lang.NewSymbol("bounded-count").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "If coll is counted? returns its count, else will count at most the first n\n elements of coll using its seq", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7410), lang.NewKeyword("end-line"), int(7410))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("counted?")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v4}) -if lang.IsTruthy(v9) { -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("count")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{v4}) -v5 = v13 -} else { -var v14 any = int64(0) -_ = v14 -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("seq")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v4}) -var v15 any = v19 -_ = v15 -var v20 any -for { -var v21 any -var v22 any = v15 -_ = v22 -var v24 any -if lang.IsTruthy(v22) { -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("<")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.Apply(v27, []any{v14, v3}) -v24 = v28 -} else { -v24 = v22 -} -if lang.IsTruthy(v24) { -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("inc")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{v14}) -var v22 any = v26 -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("next")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{v15}) -var v27 any = v31 -v14 = v22 -v15 = v27 -continue -} else { -v21 = v14 -} -v20 = v21 - break -} -v5 = v20 -} -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// butlast -{ -v0 := lang.NewSymbol("butlast").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return a seq of all but the last item in coll, in linear time", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(272), lang.NewKeyword("end-line"), int(276))).(*lang.Symbol) -var v2 lang.FnFunc -{ // function butlast -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v6 := lang.NewVector() -v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(277), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(277), lang.NewKeyword("end-column"), int(24)) -v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v5 any = v8 -_ = v5 -var v9 any = v9 -_ = v9 -var v10 any -for { -var v11 any -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("next")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v9}) -if lang.IsTruthy(v15) { -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("conj")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("first")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.Apply(v22, []any{v9}) -v24 := lang.Apply(v19, []any{v5, v23}) -var v16 any = v24 -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("next")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.Apply(v28, []any{v9}) -var v25 any = v29 -v5 = v16 -v9 = v25 -continue -} else { -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("seq")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.Apply(v32, []any{v5}) -v11 = v33 -} -v10 = v11 - break -} -return v10 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(276), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(280), lang.NewKeyword("end-column"), int(27))).(lang.FnFunc) -v3 := v2 -_ = v3 -} -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// byte -{ -var v1 lang.FnFunc -{ // function byte__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -var v30 any -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -if lang.IsTruthy(v33) { -v30 = lang.NewSymbol("uncheckedByteCast") -} else { -v30 = lang.NewSymbol("byteCast") -} -v34 := lang.Apply(v29, []any{v30}) -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("list")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v3}) -v39 := lang.Apply(v26, []any{v34, v38}) -v40 := lang.Apply(v23, []any{v39}) -v41 := lang.Apply(v20, []any{v40}) -v42 := lang.Apply(v9, []any{v13, v17, v41}) -v43 := lang.Apply(v6, []any{v42}) -return v43 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("byte").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to byte", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3505), lang.NewKeyword("end-line"), int(3505))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := lang.Apply(lang.ByteCast, []any{v4}) -return v5 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// byte-array -{ -var v1 lang.FnFunc -{ // function byte-array__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewList(args[0:]...) -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/byteArray")}) -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("list")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("seq")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("concat")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("list")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.Apply(v37, []any{lang.NewSymbol("glojure.core/args")}) -v39 := lang.Apply(v30, []any{v34, v38}) -v40 := lang.Apply(v27, []any{v39}) -v41 := lang.Apply(v24, []any{v40}) -v42 := lang.Apply(v9, []any{v13, v17, v21, v41}) -v43 := lang.Apply(v6, []any{v42}) -return v43 - } -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("byte-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Creates an array of bytes", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)int64(2)), lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5317), lang.NewKeyword("end-line"), int(5317))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v4 := args[0] -v5, _ := lang.FieldOrMethod(lang.Numbers, "byteArray") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("byteArray is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 - case 2: -v4 := args[0] -v5 := args[1] -v6, _ := lang.FieldOrMethod(lang.Numbers, "byteArrayInit") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("byteArrayInit is not a function"))) -} -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// bytes -{ -var v1 lang.FnFunc -{ // function bytes -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/bytes")}) -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("list")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v26 := lang.Apply(v9, []any{v13, v17, v21, v25}) -v27 := lang.Apply(v6, []any{v26}) -return v27 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("bytes").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Casts to bytes[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5377), lang.NewKeyword("end-line"), int(5377))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5, _ := lang.FieldOrMethod(lang.Numbers, "bytes") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("bytes is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// bytes? -{ -v0 := lang.NewSymbol("bytes?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a byte array", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5412), lang.NewKeyword("end-line"), int(5412))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("nil?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -if lang.IsTruthy(v8) { -v4 = false -} else { -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("=")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("class")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v3}) -v16, ok := lang.FieldOrMethod(v15, "getComponentType") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v15, "getComponentType"))) -} -var v17 any -switch reflect.TypeOf(v16).Kind() { -case reflect.Func: - v17 = lang.Apply(v16, nil) -default: - v17 = v16 -} -v18 := lang.Apply(v11, []any{v17, nil}) -v4 = v18 -} -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// case -{ -v0 := lang.NewSymbol("case").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("e"), lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes an expression, and a set of clauses.\n\n Each clause can take the form of either:\n\n test-constant result-expr\n\n (test-constant1 ... test-constantN) result-expr\n\n The test-constants are not evaluated. They must be compile-time\n literals, and need not be quoted. If the expression is equal to a\n test-constant, the corresponding result-expr is returned. A single\n default expression can follow the clauses, and its value will be\n returned if no clause matches. If no default expression is provided\n and no clause matches, an IllegalArgumentException is thrown.\n\n Unlike cond and condp, case does a constant-time dispatch, the\n clauses are not considered sequentially. All manner of constant\n expressions are acceptable in case, including numbers, strings,\n symbols, keywords, and (Clojure) composites thereof. Note that since\n lists are used to group multiple constants that map to the same\n expression, a vector can be used to match a list if needed. The\n test-constants need not be all of the same type.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6712), lang.NewKeyword("end-line"), int(6712))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("with-meta")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("gensym")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, nil) -v15 := lang.NewMap(lang.NewKeyword("tag"), lang.Object) -v16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6738), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(6738), lang.NewKeyword("end-column"), int(84)) -v17, err := lang.WithMeta(v15, v16.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v18 := lang.Apply(v10, []any{v14, v17}) -var v7 any = v18 -_ = v7 -var v20 any -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("odd?")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("count")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v6}) -v28 := lang.Apply(v23, []any{v27}) -if lang.IsTruthy(v28) { -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("last")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.Apply(v31, []any{v6}) -v20 = v32 -} else { -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("seq")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("concat")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("list")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) -} -v41 := v40.Get() -v42 := lang.Apply(v41, []any{lang.NewSymbol("throw")}) -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("list")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("seq")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) -} -v48 := v47.Get() -v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v50 := v49.FindInternedVar(lang.NewSymbol("concat")) -if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) -} -v51 := v50.Get() -v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("list")) -if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) -} -v54 := v53.Get() -v55 := lang.Apply(v54, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewIllegalArgumentError")}) -v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v57 := v56.FindInternedVar(lang.NewSymbol("list")) -if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) -} -v58 := v57.Get() -v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v60 := v59.FindInternedVar(lang.NewSymbol("seq")) -if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) -} -v61 := v60.Get() -v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v63 := v62.FindInternedVar(lang.NewSymbol("concat")) -if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) -} -v64 := v63.Get() -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("list")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) -} -v67 := v66.Get() -v68 := lang.Apply(v67, []any{lang.NewSymbol("glojure.core/str")}) -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("list")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) -} -v71 := v70.Get() -v72 := lang.Apply(v71, []any{"No matching clause: "}) -v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v74 := v73.FindInternedVar(lang.NewSymbol("list")) -if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) -} -v75 := v74.Get() -v76 := lang.Apply(v75, []any{v7}) -v77 := lang.Apply(v64, []any{v68, v72, v76}) -v78 := lang.Apply(v61, []any{v77}) -v79 := lang.Apply(v58, []any{v78}) -v80 := lang.Apply(v51, []any{v55, v79}) -v81 := lang.Apply(v48, []any{v80}) -v82 := lang.Apply(v45, []any{v81}) -v83 := lang.Apply(v38, []any{v42, v82}) -v84 := lang.Apply(v35, []any{v83}) -v20 = v84 -} -var v19 any = v20 -_ = v19 -var v86 any -v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v88 := v87.FindInternedVar(lang.NewSymbol(">")) -if v88.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) -} -v89 := v88.Get() -v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v91 := v90.FindInternedVar(lang.NewSymbol("count")) -if v91.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) -} -v92 := v91.Get() -v93 := lang.Apply(v92, []any{v6}) -v94 := lang.Apply(v89, []any{int64(2), v93}) -if lang.IsTruthy(v94) { -v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v96 := v95.FindInternedVar(lang.NewSymbol("seq")) -if v96.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) -} -v97 := v96.Get() -v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v99 := v98.FindInternedVar(lang.NewSymbol("concat")) -if v99.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) -} -v100 := v99.Get() -v101 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v102 := v101.FindInternedVar(lang.NewSymbol("list")) -if v102.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v102))) -} -v103 := v102.Get() -v104 := lang.Apply(v103, []any{lang.NewSymbol("glojure.core/let")}) -v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v106 := v105.FindInternedVar(lang.NewSymbol("list")) -if v106.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) -} -v107 := v106.Get() -v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v109 := v108.FindInternedVar(lang.NewSymbol("apply")) -if v109.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) -} -v110 := v109.Get() -v111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v112 := v111.FindInternedVar(lang.NewSymbol("vector")) -if v112.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v112))) -} -v113 := v112.Get() -v114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v115 := v114.FindInternedVar(lang.NewSymbol("seq")) -if v115.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v115))) -} -v116 := v115.Get() -v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v118 := v117.FindInternedVar(lang.NewSymbol("concat")) -if v118.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) -} -v119 := v118.Get() -v120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v121 := v120.FindInternedVar(lang.NewSymbol("list")) -if v121.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v121))) -} -v122 := v121.Get() -v123 := lang.Apply(v122, []any{v7}) -v124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v125 := v124.FindInternedVar(lang.NewSymbol("list")) -if v125.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v125))) -} -v126 := v125.Get() -v127 := lang.Apply(v126, []any{v5}) -v128 := lang.Apply(v119, []any{v123, v127}) -v129 := lang.Apply(v116, []any{v128}) -v130 := lang.Apply(v110, []any{v113, v129}) -v131 := lang.Apply(v107, []any{v130}) -v132 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v133 := v132.FindInternedVar(lang.NewSymbol("list")) -if v133.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v133))) -} -v134 := v133.Get() -v135 := lang.Apply(v134, []any{v19}) -v136 := lang.Apply(v100, []any{v104, v131, v135}) -v137 := lang.Apply(v97, []any{v136}) -v86 = v137 -} else { -v139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v140 := v139.FindInternedVar(lang.NewSymbol("partition")) -if v140.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v140))) -} -v141 := v140.Get() -v142 := lang.Apply(v141, []any{int64(2), v6}) -var v138 any = v142 -_ = v138 -var v144 lang.FnFunc -{ // function assoc-test -v144 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v146 := args[0] -v147 := args[1] -v148 := args[2] -var v149 any -v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v151 := v150.FindInternedVar(lang.NewSymbol("contains?")) -if v151.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) -} -v152 := v151.Get() -v153 := lang.Apply(v152, []any{v146, v147}) -if lang.IsTruthy(v153) { -v154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v155 := v154.FindInternedVar(lang.NewSymbol("str")) -if v155.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v155))) -} -v156 := v155.Get() -v157 := lang.Apply(v156, []any{"Duplicate case test constant: ", v147}) -v158 := lang.Apply(lang.NewIllegalArgumentError, []any{v157}) -panic(v158) -} else { -v159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v160 := v159.FindInternedVar(lang.NewSymbol("assoc")) -if v160.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v160))) -} -v161 := v160.Get() -v162 := lang.Apply(v161, []any{v146, v147, v148}) -v149 = v162 -} -return v149 -}) -v145 := v144 -_ = v145 -} -v145 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6745), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(6748), lang.NewKeyword("end-column"), int(48)) -v146, err := lang.WithMeta(v144, v145.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v143 any = v146 -_ = v143 -v148 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v149 := v148.FindInternedVar(lang.NewSymbol("reduce1")) -if v149.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v149))) -} -v150 := v149.Get() -var v151 lang.FnFunc -v151 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v152 := args[0] -v153 := args[1] -var v154 any = v153 -_ = v154 -v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v157 := v156.FindInternedVar(lang.NewSymbol("nth")) -if v157.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) -} -v158 := v157.Get() -v159 := lang.Apply(v158, []any{v154, int64(0), nil}) -var v155 any = v159 -_ = v155 -v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v162 := v161.FindInternedVar(lang.NewSymbol("nth")) -if v162.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) -} -v163 := v162.Get() -v164 := lang.Apply(v163, []any{v154, int64(1), nil}) -var v160 any = v164 -_ = v160 -var v166 any -v167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v168 := v167.FindInternedVar(lang.NewSymbol("seq?")) -if v168.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v168))) -} -v169 := v168.Get() -v170 := lang.Apply(v169, []any{v155}) -if lang.IsTruthy(v170) { -v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v172 := v171.FindInternedVar(lang.NewSymbol("reduce1")) -if v172.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) -} -v173 := v172.Get() -var v174 lang.FnFunc -v174 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v175 := args[0] -v176 := args[1] -v177 := lang.Apply(v143, []any{v175, v176, v160}) -return v177 -}) -v175 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6752), lang.NewKeyword("column"), int(37), lang.NewKeyword("end-line"), int(6752), lang.NewKeyword("end-column"), int(60)) -v176, err := lang.WithMeta(v174, v175.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v177 := lang.Apply(v173, []any{v176, v152, v155}) -v166 = v177 -} else { -v178 := lang.Apply(v143, []any{v152, v155, v160}) -v166 = v178 -} -return v166 -}) -v152 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6750), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(6753), lang.NewKeyword("end-column"), int(53)) -v153, err := lang.WithMeta(v151, v152.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v154 := lang.NewMap() -v155 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6754), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(6754), lang.NewKeyword("end-column"), int(25)) -v156, err := lang.WithMeta(v154, v155.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v157 := lang.Apply(v150, []any{v153, v156, v147}) -var v147 any = v157 -_ = v147 -v159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v160 := v159.FindInternedVar(lang.NewSymbol("keys")) -if v160.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v160))) -} -v161 := v160.Get() -v162 := lang.Apply(v161, []any{v147}) -var v158 any = v162 -_ = v158 -v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v165 := v164.FindInternedVar(lang.NewSymbol("vals")) -if v165.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) -} -v166 := v165.Get() -v167 := lang.Apply(v166, []any{v147}) -var v163 any = v167 -_ = v163 -var v169 any -v170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v171 := v170.FindInternedVar(lang.NewSymbol("every?")) -if v171.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v171))) -} -v172 := v171.Get() -var v173 lang.FnFunc -v173 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v174 := args[0] -v176 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v177 := v176.FindInternedVar(lang.NewSymbol("integer?")) -if v177.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v177))) -} -v178 := v177.Get() -v179 := lang.Apply(v178, []any{v174}) -var v175 any = v179 -_ = v175 -var v181 any -if lang.IsTruthy(v175) { -v182 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v183 := v182.FindInternedVar(lang.NewSymbol("<=")) -if v183.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v183))) -} -v184 := v183.Get() -v185 := lang.Apply(v184, []any{math3.MinInt, v174, math3.MaxInt}) -v181 = v185 -} else { -v181 = v175 -} -return v181 -}) -v174 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6758), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(6758), lang.NewKeyword("end-column"), int(77)) -v175, err := lang.WithMeta(v173, v174.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v176 := lang.Apply(v172, []any{v175, v158}) -if lang.IsTruthy(v176) { -v169 = lang.NewKeyword("ints") -} else { -var v177 any -v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v179 := v178.FindInternedVar(lang.NewSymbol("every?")) -if v179.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) -} -v180 := v179.Get() -v181 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v182 := v181.FindInternedVar(lang.NewSymbol("keyword?")) -if v182.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v182))) -} -v183 := v182.Get() -v184 := lang.Apply(v180, []any{v183, v158}) -if lang.IsTruthy(v184) { -v177 = lang.NewKeyword("identity") -} else { -var v185 any -if lang.IsTruthy(lang.NewKeyword("else")) { -v185 = lang.NewKeyword("hashes") -} else { -v185 = nil -} -v177 = v185 -} -v169 = v177 -} -var v168 any = v169 -_ = v168 -v188 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v189 := v188.FindInternedVar(lang.NewSymbol("=")) -if v189.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v189))) -} -v190 := v189.Get() -var v187 any = v190 -_ = v187 -var v191 any = v168 -_ = v191 -var v193 any -v194 := lang.Apply(v187, []any{lang.NewKeyword("ints"), v191}) -if lang.IsTruthy(v194) { -v196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v197 := v196.FindInternedVar(lang.NewSymbol("prep-ints")) -if v197.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v197))) -} -v198 := v197.Get() -v199 := lang.Apply(v198, []any{v158, v163}) -var v195 any = v199 -_ = v195 -v201 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v202 := v201.FindInternedVar(lang.NewSymbol("nth")) -if v202.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v202))) -} -v203 := v202.Get() -v204 := lang.Apply(v203, []any{v195, int64(0), nil}) -var v200 any = v204 -_ = v200 -v206 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v207 := v206.FindInternedVar(lang.NewSymbol("nth")) -if v207.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v207))) -} -v208 := v207.Get() -v209 := lang.Apply(v208, []any{v195, int64(1), nil}) -var v205 any = v209 -_ = v205 -v211 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v212 := v211.FindInternedVar(lang.NewSymbol("nth")) -if v212.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v212))) -} -v213 := v212.Get() -v214 := lang.Apply(v213, []any{v195, int64(2), nil}) -var v210 any = v214 -_ = v210 -v216 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v217 := v216.FindInternedVar(lang.NewSymbol("nth")) -if v217.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v217))) -} -v218 := v217.Get() -v219 := lang.Apply(v218, []any{v195, int64(3), nil}) -var v215 any = v219 -_ = v215 -v221 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v222 := v221.FindInternedVar(lang.NewSymbol("seq")) -if v222.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v222))) -} -v223 := v222.Get() -v224 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v225 := v224.FindInternedVar(lang.NewSymbol("concat")) -if v225.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v225))) -} -v226 := v225.Get() -v227 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v228 := v227.FindInternedVar(lang.NewSymbol("list")) -if v228.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v228))) -} -v229 := v228.Get() -v230 := lang.Apply(v229, []any{lang.NewSymbol("glojure.core/let")}) -v231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v232 := v231.FindInternedVar(lang.NewSymbol("list")) -if v232.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v232))) -} -v233 := v232.Get() -v234 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v235 := v234.FindInternedVar(lang.NewSymbol("apply")) -if v235.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v235))) -} -v236 := v235.Get() -v237 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v238 := v237.FindInternedVar(lang.NewSymbol("vector")) -if v238.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v238))) -} -v239 := v238.Get() -v240 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v241 := v240.FindInternedVar(lang.NewSymbol("seq")) -if v241.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v241))) -} -v242 := v241.Get() -v243 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v244 := v243.FindInternedVar(lang.NewSymbol("concat")) -if v244.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v244))) -} -v245 := v244.Get() -v246 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v247 := v246.FindInternedVar(lang.NewSymbol("list")) -if v247.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v247))) -} -v248 := v247.Get() -v249 := lang.Apply(v248, []any{v7}) -v250 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v251 := v250.FindInternedVar(lang.NewSymbol("list")) -if v251.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v251))) -} -v252 := v251.Get() -v253 := lang.Apply(v252, []any{v5}) -v254 := lang.Apply(v245, []any{v249, v253}) -v255 := lang.Apply(v242, []any{v254}) -v256 := lang.Apply(v236, []any{v239, v255}) -v257 := lang.Apply(v233, []any{v256}) -v258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v259 := v258.FindInternedVar(lang.NewSymbol("list")) -if v259.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v259))) -} -v260 := v259.Get() -v261 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v262 := v261.FindInternedVar(lang.NewSymbol("seq")) -if v262.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v262))) -} -v263 := v262.Get() -v264 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v265 := v264.FindInternedVar(lang.NewSymbol("concat")) -if v265.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v265))) -} -v266 := v265.Get() -v267 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v268 := v267.FindInternedVar(lang.NewSymbol("list")) -if v268.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v268))) -} -v269 := v268.Get() -v270 := lang.Apply(v269, []any{lang.NewSymbol("case*")}) -v271 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v272 := v271.FindInternedVar(lang.NewSymbol("list")) -if v272.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v272))) -} -v273 := v272.Get() -v274 := lang.Apply(v273, []any{v7}) -v275 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v276 := v275.FindInternedVar(lang.NewSymbol("list")) -if v276.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v276))) -} -v277 := v276.Get() -v278 := lang.Apply(v277, []any{v200}) -v279 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v280 := v279.FindInternedVar(lang.NewSymbol("list")) -if v280.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v280))) -} -v281 := v280.Get() -v282 := lang.Apply(v281, []any{v205}) -v283 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v284 := v283.FindInternedVar(lang.NewSymbol("list")) -if v284.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v284))) -} -v285 := v284.Get() -v286 := lang.Apply(v285, []any{v19}) -v287 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v288 := v287.FindInternedVar(lang.NewSymbol("list")) -if v288.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v288))) -} -v289 := v288.Get() -v290 := lang.Apply(v289, []any{v210}) -v291 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v292 := v291.FindInternedVar(lang.NewSymbol("list")) -if v292.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v292))) -} -v293 := v292.Get() -v294 := lang.Apply(v293, []any{v215}) -v295 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v296 := v295.FindInternedVar(lang.NewSymbol("list")) -if v296.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v296))) -} -v297 := v296.Get() -v298 := lang.Apply(v297, []any{lang.NewKeyword("int")}) -v299 := lang.Apply(v266, []any{v270, v274, v278, v282, v286, v290, v294, v298}) -v300 := lang.Apply(v263, []any{v299}) -v301 := lang.Apply(v260, []any{v300}) -v302 := lang.Apply(v226, []any{v230, v257, v301}) -v303 := lang.Apply(v223, []any{v302}) -v193 = v303 -} else { -var v195 any -v196 := lang.Apply(v187, []any{lang.NewKeyword("hashes"), v191}) -if lang.IsTruthy(v196) { -v198 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v199 := v198.FindInternedVar(lang.NewSymbol("prep-hashes")) -if v199.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v199))) -} -v200 := v199.Get() -v201 := lang.Apply(v200, []any{v7, v19, v158, v163}) -var v197 any = v201 -_ = v197 -v203 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v204 := v203.FindInternedVar(lang.NewSymbol("nth")) -if v204.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v204))) -} -v205 := v204.Get() -v206 := lang.Apply(v205, []any{v197, int64(0), nil}) -var v202 any = v206 -_ = v202 -v208 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v209 := v208.FindInternedVar(lang.NewSymbol("nth")) -if v209.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v209))) -} -v210 := v209.Get() -v211 := lang.Apply(v210, []any{v197, int64(1), nil}) -var v207 any = v211 -_ = v207 -v213 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v214 := v213.FindInternedVar(lang.NewSymbol("nth")) -if v214.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v214))) -} -v215 := v214.Get() -v216 := lang.Apply(v215, []any{v197, int64(2), nil}) -var v212 any = v216 -_ = v212 -v218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v219 := v218.FindInternedVar(lang.NewSymbol("nth")) -if v219.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v219))) -} -v220 := v219.Get() -v221 := lang.Apply(v220, []any{v197, int64(3), nil}) -var v217 any = v221 -_ = v217 -v223 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v224 := v223.FindInternedVar(lang.NewSymbol("nth")) -if v224.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v224))) -} -v225 := v224.Get() -v226 := lang.Apply(v225, []any{v197, int64(4), nil}) -var v222 any = v226 -_ = v222 -v228 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v229 := v228.FindInternedVar(lang.NewSymbol("seq")) -if v229.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v229))) -} -v230 := v229.Get() -v231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v232 := v231.FindInternedVar(lang.NewSymbol("concat")) -if v232.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v232))) -} -v233 := v232.Get() -v234 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v235 := v234.FindInternedVar(lang.NewSymbol("list")) -if v235.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v235))) -} -v236 := v235.Get() -v237 := lang.Apply(v236, []any{lang.NewSymbol("glojure.core/let")}) -v238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v239 := v238.FindInternedVar(lang.NewSymbol("list")) -if v239.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v239))) -} -v240 := v239.Get() -v241 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v242 := v241.FindInternedVar(lang.NewSymbol("apply")) -if v242.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v242))) -} -v243 := v242.Get() -v244 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v245 := v244.FindInternedVar(lang.NewSymbol("vector")) -if v245.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v245))) -} -v246 := v245.Get() -v247 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v248 := v247.FindInternedVar(lang.NewSymbol("seq")) -if v248.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v248))) -} -v249 := v248.Get() -v250 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v251 := v250.FindInternedVar(lang.NewSymbol("concat")) -if v251.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v251))) -} -v252 := v251.Get() -v253 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v254 := v253.FindInternedVar(lang.NewSymbol("list")) -if v254.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v254))) -} -v255 := v254.Get() -v256 := lang.Apply(v255, []any{v7}) -v257 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v258 := v257.FindInternedVar(lang.NewSymbol("list")) -if v258.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v258))) -} -v259 := v258.Get() -v260 := lang.Apply(v259, []any{v5}) -v261 := lang.Apply(v252, []any{v256, v260}) -v262 := lang.Apply(v249, []any{v261}) -v263 := lang.Apply(v243, []any{v246, v262}) -v264 := lang.Apply(v240, []any{v263}) -v265 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v266 := v265.FindInternedVar(lang.NewSymbol("list")) -if v266.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v266))) -} -v267 := v266.Get() -v268 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v269 := v268.FindInternedVar(lang.NewSymbol("seq")) -if v269.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v269))) -} -v270 := v269.Get() -v271 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v272 := v271.FindInternedVar(lang.NewSymbol("concat")) -if v272.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v272))) -} -v273 := v272.Get() -v274 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v275 := v274.FindInternedVar(lang.NewSymbol("list")) -if v275.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v275))) -} -v276 := v275.Get() -v277 := lang.Apply(v276, []any{lang.NewSymbol("case*")}) -v278 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v279 := v278.FindInternedVar(lang.NewSymbol("list")) -if v279.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v279))) -} -v280 := v279.Get() -v281 := lang.Apply(v280, []any{v7}) -v282 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v283 := v282.FindInternedVar(lang.NewSymbol("list")) -if v283.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v283))) -} -v284 := v283.Get() -v285 := lang.Apply(v284, []any{v202}) -v286 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v287 := v286.FindInternedVar(lang.NewSymbol("list")) -if v287.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v287))) -} -v288 := v287.Get() -v289 := lang.Apply(v288, []any{v207}) -v290 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v291 := v290.FindInternedVar(lang.NewSymbol("list")) -if v291.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v291))) -} -v292 := v291.Get() -v293 := lang.Apply(v292, []any{v19}) -v294 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v295 := v294.FindInternedVar(lang.NewSymbol("list")) -if v295.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v295))) -} -v296 := v295.Get() -v297 := lang.Apply(v296, []any{v212}) -v298 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v299 := v298.FindInternedVar(lang.NewSymbol("list")) -if v299.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v299))) -} -v300 := v299.Get() -v301 := lang.Apply(v300, []any{v217}) -v302 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v303 := v302.FindInternedVar(lang.NewSymbol("list")) -if v303.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v303))) -} -v304 := v303.Get() -v305 := lang.Apply(v304, []any{lang.NewKeyword("hash-equiv")}) -v306 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v307 := v306.FindInternedVar(lang.NewSymbol("list")) -if v307.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v307))) -} -v308 := v307.Get() -v309 := lang.Apply(v308, []any{v222}) -v310 := lang.Apply(v273, []any{v277, v281, v285, v289, v293, v297, v301, v305, v309}) -v311 := lang.Apply(v270, []any{v310}) -v312 := lang.Apply(v267, []any{v311}) -v313 := lang.Apply(v233, []any{v237, v264, v312}) -v314 := lang.Apply(v230, []any{v313}) -v195 = v314 -} else { -var v197 any -v198 := lang.Apply(v187, []any{lang.NewKeyword("identity"), v191}) -if lang.IsTruthy(v198) { -v200 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v201 := v200.FindInternedVar(lang.NewSymbol("prep-hashes")) -if v201.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v201))) -} -v202 := v201.Get() -v203 := lang.Apply(v202, []any{v7, v19, v158, v163}) -var v199 any = v203 -_ = v199 -v205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v206 := v205.FindInternedVar(lang.NewSymbol("nth")) -if v206.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v206))) -} -v207 := v206.Get() -v208 := lang.Apply(v207, []any{v199, int64(0), nil}) -var v204 any = v208 -_ = v204 -v210 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v211 := v210.FindInternedVar(lang.NewSymbol("nth")) -if v211.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v211))) -} -v212 := v211.Get() -v213 := lang.Apply(v212, []any{v199, int64(1), nil}) -var v209 any = v213 -_ = v209 -v215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v216 := v215.FindInternedVar(lang.NewSymbol("nth")) -if v216.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v216))) -} -v217 := v216.Get() -v218 := lang.Apply(v217, []any{v199, int64(2), nil}) -var v214 any = v218 -_ = v214 -v220 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v221 := v220.FindInternedVar(lang.NewSymbol("nth")) -if v221.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v221))) -} -v222 := v221.Get() -v223 := lang.Apply(v222, []any{v199, int64(3), nil}) -var v219 any = v223 -_ = v219 -v225 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v226 := v225.FindInternedVar(lang.NewSymbol("nth")) -if v226.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v226))) -} -v227 := v226.Get() -v228 := lang.Apply(v227, []any{v199, int64(4), nil}) -var v224 any = v228 -_ = v224 -v230 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v231 := v230.FindInternedVar(lang.NewSymbol("seq")) -if v231.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v231))) -} -v232 := v231.Get() -v233 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v234 := v233.FindInternedVar(lang.NewSymbol("concat")) -if v234.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v234))) -} -v235 := v234.Get() -v236 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v237 := v236.FindInternedVar(lang.NewSymbol("list")) -if v237.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v237))) -} -v238 := v237.Get() -v239 := lang.Apply(v238, []any{lang.NewSymbol("glojure.core/let")}) -v240 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v241 := v240.FindInternedVar(lang.NewSymbol("list")) -if v241.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v241))) -} -v242 := v241.Get() -v243 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v244 := v243.FindInternedVar(lang.NewSymbol("apply")) -if v244.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v244))) -} -v245 := v244.Get() -v246 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v247 := v246.FindInternedVar(lang.NewSymbol("vector")) -if v247.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v247))) -} -v248 := v247.Get() -v249 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v250 := v249.FindInternedVar(lang.NewSymbol("seq")) -if v250.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v250))) -} -v251 := v250.Get() -v252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v253 := v252.FindInternedVar(lang.NewSymbol("concat")) -if v253.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v253))) -} -v254 := v253.Get() -v255 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v256 := v255.FindInternedVar(lang.NewSymbol("list")) -if v256.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v256))) -} -v257 := v256.Get() -v258 := lang.Apply(v257, []any{v7}) -v259 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v260 := v259.FindInternedVar(lang.NewSymbol("list")) -if v260.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v260))) -} -v261 := v260.Get() -v262 := lang.Apply(v261, []any{v5}) -v263 := lang.Apply(v254, []any{v258, v262}) -v264 := lang.Apply(v251, []any{v263}) -v265 := lang.Apply(v245, []any{v248, v264}) -v266 := lang.Apply(v242, []any{v265}) -v267 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v268 := v267.FindInternedVar(lang.NewSymbol("list")) -if v268.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v268))) -} -v269 := v268.Get() -v270 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v271 := v270.FindInternedVar(lang.NewSymbol("seq")) -if v271.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v271))) -} -v272 := v271.Get() -v273 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v274 := v273.FindInternedVar(lang.NewSymbol("concat")) -if v274.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v274))) -} -v275 := v274.Get() -v276 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v277 := v276.FindInternedVar(lang.NewSymbol("list")) -if v277.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v277))) -} -v278 := v277.Get() -v279 := lang.Apply(v278, []any{lang.NewSymbol("case*")}) -v280 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v281 := v280.FindInternedVar(lang.NewSymbol("list")) -if v281.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v281))) -} -v282 := v281.Get() -v283 := lang.Apply(v282, []any{v7}) -v284 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v285 := v284.FindInternedVar(lang.NewSymbol("list")) -if v285.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v285))) -} -v286 := v285.Get() -v287 := lang.Apply(v286, []any{v204}) -v288 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v289 := v288.FindInternedVar(lang.NewSymbol("list")) -if v289.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v289))) -} -v290 := v289.Get() -v291 := lang.Apply(v290, []any{v209}) -v292 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v293 := v292.FindInternedVar(lang.NewSymbol("list")) -if v293.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v293))) -} -v294 := v293.Get() -v295 := lang.Apply(v294, []any{v19}) -v296 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v297 := v296.FindInternedVar(lang.NewSymbol("list")) -if v297.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v297))) -} -v298 := v297.Get() -v299 := lang.Apply(v298, []any{v214}) -v300 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v301 := v300.FindInternedVar(lang.NewSymbol("list")) -if v301.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v301))) -} -v302 := v301.Get() -v303 := lang.Apply(v302, []any{v219}) -v304 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v305 := v304.FindInternedVar(lang.NewSymbol("list")) -if v305.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v305))) -} -v306 := v305.Get() -v307 := lang.Apply(v306, []any{lang.NewKeyword("hash-identity")}) -v308 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v309 := v308.FindInternedVar(lang.NewSymbol("list")) -if v309.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v309))) -} -v310 := v309.Get() -v311 := lang.Apply(v310, []any{v224}) -v312 := lang.Apply(v275, []any{v279, v283, v287, v291, v295, v299, v303, v307, v311}) -v313 := lang.Apply(v272, []any{v312}) -v314 := lang.Apply(v269, []any{v313}) -v315 := lang.Apply(v235, []any{v239, v266, v314}) -v316 := lang.Apply(v232, []any{v315}) -v197 = v316 -} else { -v199 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v200 := v199.FindInternedVar(lang.NewSymbol("str")) -if v200.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v200))) -} -v201 := v200.Get() -v202 := lang.Apply(v201, []any{"No matching clause: ", v191}) -v203 := lang.Apply(lang.NewIllegalArgumentError, []any{v202}) -panic(v203) -} -v195 = v197 -} -v193 = v195 -} -v86 = v193 -} -return v86 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// case-map -{ -v0 := lang.NewSymbol("case-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("case-f"), lang.NewSymbol("test-f"), lang.NewSymbol("tests"), lang.NewSymbol("thens"))), lang.NewKeyword("doc"), "Transforms a sequence of test constants and a corresponding sequence of then\n expressions into a sorted map to be consumed by case*. The form of the map\n entries are {(case-f test) [(test-f test) then]}.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6614), lang.NewKeyword("end-line"), int(6614), lang.NewKeyword("private"), true)).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("into1")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("sorted-map")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, nil) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("zipmap")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("map")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v3, v5}) -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("map")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("vector")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("map")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{v4, v5}) -v31 := lang.Apply(v23, []any{v26, v30, v6}) -v32 := lang.Apply(v16, []any{v20, v31}) -v33 := lang.Apply(v9, []any{v13, v32}) -return v33 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// cast -{ -v0 := lang.NewSymbol("cast").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Throws a ClassCastException if x is not a c, else returns x.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(345), lang.NewKeyword("end-line"), int(345))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5, _ := lang.FieldOrMethod(v3, "cast") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("cast is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// cat -{ -v0 := lang.NewSymbol("cat").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rf"))), lang.NewKeyword("doc"), "A transducer which concatenates the contents of each input, which must be a\n collection, into the reduction.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7645), lang.NewKeyword("end-line"), int(7645))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("preserving-reduced")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -var v4 any = v8 -_ = v4 -var v10 lang.FnFunc -v10 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v11 := lang.Apply(v3, nil) -return v11 - case 1: -v11 := args[0] -v12 := lang.Apply(v3, []any{v11}) -return v12 - case 2: -v11 := args[0] -v12 := args[1] -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("reduce")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v4, v11, v12}) -return v16 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7651), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(7655), lang.NewKeyword("end-column"), int(36)) -v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v12 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// char -{ -var v1 lang.FnFunc -{ // function char__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -var v30 any -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -if lang.IsTruthy(v33) { -v30 = lang.NewSymbol("uncheckedCharCast") -} else { -v30 = lang.NewSymbol("charCast") -} -v34 := lang.Apply(v29, []any{v30}) -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("list")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v3}) -v39 := lang.Apply(v26, []any{v34, v38}) -v40 := lang.Apply(v23, []any{v39}) -v41 := lang.Apply(v20, []any{v40}) -v42 := lang.Apply(v9, []any{v13, v17, v41}) -v43 := lang.Apply(v6, []any{v42}) -return v43 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("char").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to char", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3511), lang.NewKeyword("end-line"), int(3511))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5, _ := lang.FieldOrMethod(runtime5.RT, "CharCast") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("CharCast is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// char-array -{ -var v1 lang.FnFunc -{ // function char-array__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewList(args[0:]...) -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/charArray")}) -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("list")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("seq")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("concat")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("list")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.Apply(v37, []any{lang.NewSymbol("glojure.core/args")}) -v39 := lang.Apply(v30, []any{v34, v38}) -v40 := lang.Apply(v27, []any{v39}) -v41 := lang.Apply(v24, []any{v40}) -v42 := lang.Apply(v9, []any{v13, v17, v21, v41}) -v43 := lang.Apply(v6, []any{v42}) -return v43 - } -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("char-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Creates an array of chars", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)int64(2)), lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5325), lang.NewKeyword("end-line"), int(5325))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v4 := args[0] -v5, _ := lang.FieldOrMethod(lang.Numbers, "charArray") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("charArray is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 - case 2: -v4 := args[0] -v5 := args[1] -v6, _ := lang.FieldOrMethod(lang.Numbers, "charArrayInit") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("charArrayInit is not a function"))) -} -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// char-escape-string -{ -v1 := reflect.TypeOf("") -v0 := lang.NewSymbol("char-escape-string").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("doc"), "Returns escape string for char or nil if none", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(6), lang.NewKeyword("line"), int(214), lang.NewKeyword("end-line"), int(217))).(*lang.Symbol) -v2 := ns.InternWithValue(v0, lang.NewMap(lang.NewChar(10), "\\n", lang.NewChar(9), "\\t", lang.NewChar(13), "\\r", lang.NewChar(34), "\\\"", lang.NewChar(92), "\\\\", lang.NewChar(12), "\\f", lang.NewChar(8), "\\b"), true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// char-name-string -{ -v1 := reflect.TypeOf("") -v0 := lang.NewSymbol("char-name-string").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("doc"), "Returns name string for char or nil if none", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(6), lang.NewKeyword("line"), int(335), lang.NewKeyword("end-line"), int(338))).(*lang.Symbol) -v2 := ns.InternWithValue(v0, lang.NewMap(lang.NewChar(10), "newline", lang.NewChar(9), "tab", lang.NewChar(32), "space", lang.NewChar(8), "backspace", lang.NewChar(12), "formfeed", lang.NewChar(13), "return"), true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// char? -{ -v0 := lang.NewSymbol("char?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a Character", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(153), lang.NewKeyword("end-line"), int(157))).(*lang.Symbol) -var v2 lang.FnFunc -{ // function char? -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{lang.Char, v4}) -return v8 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(157), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(157), lang.NewKeyword("end-column"), int(89))).(lang.FnFunc) -v3 := v2 -_ = v3 -} -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// chars -{ -var v1 lang.FnFunc -{ // function chars -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/chars")}) -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("list")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v26 := lang.Apply(v9, []any{v13, v17, v21, v25}) -v27 := lang.Apply(v6, []any{v26}) -return v27 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("chars").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Casts to chars[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5382), lang.NewKeyword("end-line"), int(5382))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5, _ := lang.FieldOrMethod(lang.Numbers, "chars") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("chars is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// check-cyclic-dependency -{ -v0 := lang.NewSymbol("check-cyclic-dependency").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("path"))), lang.NewKeyword("doc"), "Detects and rejects non-trivial cyclic load dependencies. The\n exception message shows the dependency chain with the cycle\n highlighted. Ignores the trivial case of a file attempting to load\n itself because that can occur when a gen-class'd class loads its\n implementation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(30), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5974), lang.NewKeyword("end-line"), int(5974), lang.NewKeyword("private"), true)).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("some")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.CreatePersistentTreeSet(v3) -v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5981), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(5981), lang.NewKeyword("end-column"), int(21)) -v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("rest")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("*pending-paths*")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v13, []any{v16}) -v18 := lang.Apply(v7, []any{v10, v17}) -if lang.IsTruthy(v18) { -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("map")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -var v23 lang.FnFunc -v23 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v24 := args[0] -var v25 any -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("=")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.Apply(v28, []any{v24, v3}) -if lang.IsTruthy(v29) { -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("str")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.Apply(v32, []any{"[ ", v24, " ]"}) -v25 = v33 -} else { -v25 = v24 -} -return v25 -}) -v24 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5982), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(5982), lang.NewKeyword("end-column"), int(59)) -v25, err := lang.WithMeta(v23, v24.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("cons")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("*pending-paths*")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.Apply(v28, []any{v3, v31}) -v33 := lang.Apply(v22, []any{v25, v32}) -var v19 any = v33 -_ = v19 -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("apply")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("str")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("interpose")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{"->", v19}) -v45 := lang.Apply(v37, []any{v40, v44}) -var v34 any = v45 -_ = v34 -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("throw-if")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) -} -v49 := v48.Get() -v50 := lang.Apply(v49, []any{true, "Cyclic load dependency: %s", v34}) -v4 = v50 -} else { -v4 = nil -} -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// check-valid-options -{ -v0 := lang.NewSymbol("check-valid-options").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("options"), lang.NewSymbol("&"), lang.NewSymbol("valid-keys"))), lang.NewKeyword("doc"), "Throws an exception if the given option map contains keys not listed\n as valid, else returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(35), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1709), lang.NewKeyword("end-line"), int(1709), lang.NewKeyword("private"), true)).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.NewList(args[1:]...) -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("seq")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("apply")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("disj")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("apply")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("hash-set")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("keys")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v3}) -v25 := lang.Apply(v17, []any{v20, v24}) -v26 := lang.Apply(v11, []any{v14, v25, v4}) -v27 := lang.Apply(v8, []any{v26}) -if lang.IsTruthy(v27) { -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("apply")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("str")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("first")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.Apply(v36, []any{v4}) -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("map")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -var v41 lang.FnFunc -v41 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v42 := args[0] -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("str")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.Apply(v45, []any{", ", v42}) -return v46 -}) -v42 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1718), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(1718), lang.NewKeyword("end-column"), int(28)) -v43, err := lang.WithMeta(v41, v42.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("rest")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v4}) -v48 := lang.Apply(v40, []any{v43, v47}) -v49 := lang.Apply(v30, []any{v33, "Only these options are valid: ", v37, v48}) -v50 := lang.Apply(lang.NewIllegalArgumentError, []any{v49}) -panic(v50) -} else { -v5 = nil -} -return v5 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// chunk -{ -v0 := lang.NewSymbol("chunk").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(691), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(691), lang.NewKeyword("end-column"), int(41), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("b"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, ok := lang.FieldOrMethod(v3, "chunk") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "chunk"))) -} -var v5 any -switch reflect.TypeOf(v4).Kind() { -case reflect.Func: - v5 = lang.Apply(v4, nil) -default: - v5 = v4 -} -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// chunk-append -{ -v0 := lang.NewSymbol("chunk-append").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(688), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(688), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("b"), lang.NewSymbol("x"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5, _ := lang.FieldOrMethod(v3, "add") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// chunk-buffer -{ -v0 := lang.NewSymbol("chunk-buffer").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(685), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(685), lang.NewKeyword("end-column"), int(53), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("capacity"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.Apply(lang.NewChunkBuffer, []any{v3}) -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// chunk-cons -{ -v0 := lang.NewSymbol("chunk-cons").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(703), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(703), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("chunk"), lang.NewSymbol("rest"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -var v5 any -v6 := lang.Apply(lang.Count, []any{v3}) -v7 := lang.Apply(lang.IsZero, []any{v6}) -if lang.IsTruthy(v7) { -v5 = v4 -} else { -v8 := lang.Apply(lang.NewChunkedCons, []any{v3, v4}) -v5 = v8 -} -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// chunk-first -{ -v0 := lang.NewSymbol("chunk-first").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(694), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(694), lang.NewKeyword("end-column"), int(48), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, ok := lang.FieldOrMethod(v3, "chunkedFirst") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "chunkedFirst"))) -} -var v5 any -switch reflect.TypeOf(v4).Kind() { -case reflect.Func: - v5 = lang.Apply(v4, nil) -default: - v5 = v4 -} -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// chunk-next -{ -v0 := lang.NewSymbol("chunk-next").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(700), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(700), lang.NewKeyword("end-column"), int(71), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, ok := lang.FieldOrMethod(v3, "chunkedNext") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "chunkedNext"))) -} -var v5 any -switch reflect.TypeOf(v4).Kind() { -case reflect.Func: - v5 = lang.Apply(v4, nil) -default: - v5 = v4 -} -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// chunk-rest -{ -v0 := lang.NewSymbol("chunk-rest").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(697), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(697), lang.NewKeyword("end-column"), int(71), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, ok := lang.FieldOrMethod(v3, "chunkedMore") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "chunkedMore"))) -} -var v5 any -switch reflect.TypeOf(v4).Kind() { -case reflect.Func: - v5 = lang.Apply(v4, nil) -default: - v5 = v4 -} -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// chunked-seq? -{ -v0 := lang.NewSymbol("chunked-seq?").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(708), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(708), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{lang.IChunkedSeq, v3}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// class -{ -v0 := lang.NewSymbol("class").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns the Class of x", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3461), lang.NewKeyword("end-line"), int(3461))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("nil?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -if lang.IsTruthy(v8) { -v4 = v3 -} else { -v9 := lang.Apply(lang.TypeOf, []any{v3}) -v4 = v9 -} -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// class? -{ -v0 := lang.NewSymbol("class?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is an instance of Class", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5465), lang.NewKeyword("end-line"), int(5465))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{reflect.Type, v3}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// clear-agent-errors -{ -v0 := lang.NewSymbol("clear-agent-errors").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("doc"), "DEPRECATED: Use 'restart-agent' instead.\n Clears any exceptions thrown during asynchronous actions of the\n agent, allowing subsequent actions to occur.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("deprecated"), "1.2", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2244), lang.NewKeyword("end-line"), int(2244))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("restart-agent")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7, ok := lang.FieldOrMethod(v3, "Deref") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "Deref"))) -} -var v8 any -switch reflect.TypeOf(v7).Kind() { -case reflect.Func: - v8 = lang.Apply(v7, nil) -default: - v8 = v7 -} -v9 := lang.Apply(v6, []any{v3, v8}) -return v9 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// coll? -{ -v0 := lang.NewSymbol("coll?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements IPersistentCollection", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6192), lang.NewKeyword("end-line"), int(6192))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{lang.IPersistentCollection, v3}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// comment -{ -v0 := lang.NewSymbol("comment").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Ignores body, yields nil", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4733), lang.NewKeyword("end-line"), int(4733))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -return nil - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// commute -{ -v0 := lang.NewSymbol("commute").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("fun"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Must be called in a transaction. Sets the in-transaction-value of\n ref to:\n\n (apply fun in-transaction-value-of-ref args)\n\n and returns the in-transaction-value of ref.\n\n At the commit point of the transaction, sets the value of ref to be:\n\n (apply fun most-recently-committed-value-of-ref args)\n\n Thus fun should be commutative, or, failing that, you must accept\n last-one-in-wins behavior. commute allows for more concurrency than\n ref-set.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2414), lang.NewKeyword("end-line"), int(2414))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -v6, _ := lang.FieldOrMethod(v3, "Commute") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Commute is not a function"))) -} -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// comp -{ -v0 := lang.NewSymbol("comp").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("g")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("g"), lang.NewSymbol("&"), lang.NewSymbol("fs"))), lang.NewKeyword("doc"), "Takes a set of functions and returns a fn that is the composition\n of those fns. The returned fn takes a variable number of args,\n applies the rightmost of fns to the args, the next\n fn (right-to-left) to the result, etc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2549), lang.NewKeyword("end-line"), int(2549))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v4 := v3.FindInternedVar(lang.NewSymbol("identity")) -if v4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) -} -v5 := v4.Get() -return v5 - case 1: -v3 := args[0] -return v3 - case 2: -v3 := args[0] -v4 := args[1] -var v5 lang.FnFunc -v5 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v6 := lang.Apply(v4, nil) -v7 := lang.Apply(v3, []any{v6}) -return v7 - case 1: -v6 := args[0] -v7 := lang.Apply(v4, []any{v6}) -v8 := lang.Apply(v3, []any{v7}) -return v8 - case 2: -v6 := args[0] -v7 := args[1] -v8 := lang.Apply(v4, []any{v6, v7}) -v9 := lang.Apply(v3, []any{v8}) -return v9 - case 3: -v6 := args[0] -v7 := args[1] -v8 := args[2] -v9 := lang.Apply(v4, []any{v6, v7, v8}) -v10 := lang.Apply(v3, []any{v9}) -return v10 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v6 := args[0] -v7 := args[1] -v8 := args[2] -v9 := lang.NewList(args[3:]...) -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("apply")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{v4, v6, v7, v8, v9}) -v14 := lang.Apply(v3, []any{v13}) -return v14 - } -}) -v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2559), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2564), lang.NewKeyword("end-column"), int(49)) -v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v7 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("reduce1")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("comp")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("list*")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v3, v4, v5}) -v16 := lang.Apply(v8, []any{v11, v15}) -return v16 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// comparator -{ -v0 := lang.NewSymbol("comparator").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"))), lang.NewKeyword("doc"), "Returns an implementation of java.util.Comparator based upon pred.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3077), lang.NewKeyword("end-line"), int(3077))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := args[0] -v6 := args[1] -var v7 any -v8 := lang.Apply(v3, []any{v5, v6}) -if lang.IsTruthy(v8) { -v7 = int64(-1) -} else { -var v9 any -v10 := lang.Apply(v3, []any{v6, v5}) -if lang.IsTruthy(v10) { -v9 = int64(1) -} else { -var v11 any -if lang.IsTruthy(lang.NewKeyword("else")) { -v11 = int64(0) -} else { -v11 = nil -} -v9 = v11 -} -v7 = v9 -} -return v7 -}) -v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3082), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(3083), lang.NewKeyword("end-column"), int(48)) -v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v6 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// compare -{ -var v1 lang.FnFunc -{ // function compare__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("concat")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("list")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol("glojure.lang.Util")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{lang.NewSymbol("glojure.core/compare")}) -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{v3}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{v4}) -v31 := lang.Apply(v10, []any{v14, v18, v22, v26, v30}) -v32 := lang.Apply(v7, []any{v31}) -return v32 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("compare").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Comparator. Returns a negative number, zero, or a positive number\n when x is logically 'less than', 'equal to', or 'greater than'\n y. Same as Java x.compareTo(y) except it also works for nil, and\n compares numbers and collections in a type-independent manner. x\n must implement Comparable", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(824), lang.NewKeyword("end-line"), int(824))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6 := lang.Apply(lang.Compare, []any{v4, v5}) -return v6 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// compare-and-set! -{ -v0 := lang.NewSymbol("compare-and-set!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atom"), lang.NewSymbol("oldval"), lang.NewSymbol("newval"))), lang.NewKeyword("doc"), "Atomically sets the value of atom to newval if and only if the\n current value of the atom is identical to oldval. Returns true if\n set happened, else false", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2360), lang.NewKeyword("end-line"), int(2360))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6, _ := lang.FieldOrMethod(v3, "compareAndSet") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("compareAndSet is not a function"))) -} -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// compile -{ -v0 := lang.NewSymbol("compile").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"))), lang.NewKeyword("doc"), "Compiles the namespace named by the symbol lib into a set of\n classfiles. The source for the lib must be in a proper\n classpath-relative directory. The output files will go into the\n directory specified by *compile-path*, and that directory too must\n be in the classpath.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6114), lang.NewKeyword("end-line"), int(6114))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("push-thread-bindings")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("hash-map")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*compile-files*")) -v12 := lang.Apply(v10, []any{v11, true}) -v13 := lang.Apply(v7, []any{v12}) -_ = v13 -var v14 any -func() { -defer func() { -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, nil) -}() -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("load-one")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v3, true, true}) -v14 = v22 -}() -_ = v14 -return v3 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// complement -{ -v0 := lang.NewSymbol("complement").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Takes a fn f and returns a fn that takes the same arguments as f,\n has the same effects, if any, and returns the opposite truth value.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1428), lang.NewKeyword("end-line"), int(1428))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("not")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v3, nil) -v9 := lang.Apply(v7, []any{v8}) -return v9 - case 1: -v5 := args[0] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("not")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v3, []any{v5}) -v10 := lang.Apply(v8, []any{v9}) -return v10 - case 2: -v5 := args[0] -v6 := args[1] -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("not")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v3, []any{v5, v6}) -v11 := lang.Apply(v9, []any{v10}) -return v11 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := args[0] -v6 := args[1] -v7 := lang.NewList(args[2:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("not")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("apply")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v3, v5, v6, v7}) -v15 := lang.Apply(v10, []any{v14}) -return v15 - } -}) -v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1434), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(1438), lang.NewKeyword("end-column"), int(40)) -v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v6 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// completing -{ -v0 := lang.NewSymbol("completing").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("cf"))), lang.NewKeyword("doc"), "Takes a reducing function f of 2 args and returns a fn suitable for\n transduce by adding an arity-1 signature that calls cf (default -\n identity) on the result argument.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6893), lang.NewKeyword("end-line"), int(6893))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("completing")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("identity")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v6, []any{v3, v9}) -return v10 - case 2: -v3 := args[0] -v4 := args[1] -var v5 lang.FnFunc -v5 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v6 := lang.Apply(v3, nil) -return v6 - case 1: -v6 := args[0] -v7 := lang.Apply(v4, []any{v6}) -return v7 - case 2: -v6 := args[0] -v7 := args[1] -v8 := lang.Apply(v3, []any{v6, v7}) -return v8 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6900), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(6903), lang.NewKeyword("end-column"), int(23)) -v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v7 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// concat -{ -v0 := lang.NewSymbol("concat").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("zs"))), lang.NewKeyword("doc"), "Returns a lazy seq representing the concatenation of the elements in the supplied colls.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(711), lang.NewKeyword("end-line"), int(711))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -return nil -}) -v4 := lang.Apply(lang.NewLazySeq, []any{v3}) -return v4 - case 1: -v3 := args[0] -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -return v3 -}) -v5 := lang.Apply(lang.NewLazySeq, []any{v4}) -return v5 - case 2: -v3 := args[0] -v4 := args[1] -var v5 lang.FnFunc -v5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("seq")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v3}) -var v6 any = v10 -_ = v6 -var v12 any -if lang.IsTruthy(v6) { -var v13 any -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("chunked-seq?")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v6}) -if lang.IsTruthy(v17) { -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("chunk-cons")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("chunk-first")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v6}) -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("concat")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("chunk-rest")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{v6}) -v32 := lang.Apply(v27, []any{v31, v4}) -v33 := lang.Apply(v20, []any{v24, v32}) -v13 = v33 -} else { -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("cons")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("first")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v6}) -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("concat")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("rest")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v6}) -v48 := lang.Apply(v43, []any{v47, v4}) -v49 := lang.Apply(v36, []any{v40, v48}) -v13 = v49 -} -v12 = v13 -} else { -v12 = v4 -} -return v12 -}) -v6 := lang.Apply(lang.NewLazySeq, []any{v5}) -return v6 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -var v7 lang.FnFunc -{ // function cat -v7 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v9 := args[0] -v10 := args[1] -var v11 lang.FnFunc -v11 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("seq")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v12}) -var v12 any = v16 -_ = v12 -var v18 any -if lang.IsTruthy(v12) { -var v19 any -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("chunked-seq?")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.Apply(v22, []any{v12}) -if lang.IsTruthy(v23) { -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("chunk-cons")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("chunk-first")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{v12}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("chunk-rest")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v12}) -v35 := lang.Apply(v8, []any{v34, v10}) -v36 := lang.Apply(v26, []any{v30, v35}) -v19 = v36 -} else { -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("cons")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("first")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v12}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("rest")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v12}) -v48 := lang.Apply(v8, []any{v47, v10}) -v49 := lang.Apply(v39, []any{v43, v48}) -v19 = v49 -} -v18 = v19 -} else { -var v50 any -if lang.IsTruthy(v10) { -v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v52 := v51.FindInternedVar(lang.NewSymbol("first")) -if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) -} -v53 := v52.Get() -v54 := lang.Apply(v53, []any{v10}) -v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v56 := v55.FindInternedVar(lang.NewSymbol("next")) -if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) -} -v57 := v56.Get() -v58 := lang.Apply(v57, []any{v10}) -v59 := lang.Apply(v8, []any{v54, v58}) -v50 = v59 -} else { -v50 = nil -} -v18 = v50 -} -return v18 -}) -v12 := lang.Apply(lang.NewLazySeq, []any{v11}) -return v12 -}) -v8 := v7 -_ = v8 -} -v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(726), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(735), lang.NewKeyword("end-column"), int(56)) -v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v6 any = v9 -_ = v6 -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("concat")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v3, v4}) -v15 := lang.Apply(v6, []any{v14, v5}) -return v15 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// cond -{ -v0 := lang.NewSymbol("cond").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes a set of test/expr pairs. It evaluates each test one at a\n time. If a test returns logical true, cond evaluates and returns\n the value of the corresponding expr and doesn't evaluate any of the\n other tests or exprs. (cond) returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(569), lang.NewKeyword("end-line"), int(569))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -var v6 any -if lang.IsTruthy(v5) { -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("list")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("first")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{v5}) -var v14 any -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("next")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v5}) -if lang.IsTruthy(v18) { -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("second")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v5}) -v14 = v22 -} else { -v23 := lang.Apply(lang.NewIllegalArgumentError, []any{"cond requires an even number of forms"}) -panic(v23) -} -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("cons")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("next")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("next")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.Apply(v32, []any{v5}) -v34 := lang.Apply(v29, []any{v33}) -v35 := lang.Apply(v26, []any{lang.NewSymbol("glojure.core/cond"), v34}) -v36 := lang.Apply(v9, []any{lang.NewSymbol("if"), v13, v14, v35}) -v6 = v36 -} else { -v6 = nil -} -return v6 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// cond-> -{ -v0 := lang.NewSymbol("cond->").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes an expression and a set of test/form pairs. Threads expr (via ->)\n through each form for which the corresponding test\n expression is true. Note that, unlike cond branching, cond-> threading does\n not short circuit after the first true test expression.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7564), lang.NewKeyword("end-line"), int(7564))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -_ = nil -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("gensym")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, nil) -var v7 any = v11 -_ = v7 -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("map")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -var v16 lang.FnFunc -v16 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v17 := args[0] -var v18 any = v17 -_ = v18 -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("nth")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.Apply(v22, []any{v18, int64(0), nil}) -var v19 any = v23 -_ = v19 -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("nth")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.Apply(v27, []any{v18, int64(1), nil}) -var v24 any = v28 -_ = v24 -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("seq")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("concat")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{lang.NewSymbol("if")}) -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v19}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("seq")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) -} -v49 := v48.Get() -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("concat")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("list")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) -} -v55 := v54.Get() -v56 := lang.Apply(v55, []any{lang.NewSymbol("glojure.core/->")}) -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("list")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) -} -v59 := v58.Get() -v60 := lang.Apply(v59, []any{v7}) -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("list")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) -} -v63 := v62.Get() -v64 := lang.Apply(v63, []any{v24}) -v65 := lang.Apply(v52, []any{v56, v60, v64}) -v66 := lang.Apply(v49, []any{v65}) -v67 := lang.Apply(v46, []any{v66}) -v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v69 := v68.FindInternedVar(lang.NewSymbol("list")) -if v69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) -} -v70 := v69.Get() -v71 := lang.Apply(v70, []any{v7}) -v72 := lang.Apply(v35, []any{v39, v43, v67, v71}) -v73 := lang.Apply(v32, []any{v72}) -return v73 -}) -v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7573), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7573), lang.NewKeyword("end-column"), int(66)) -v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("partition")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{int64(2), v6}) -v23 := lang.Apply(v15, []any{v18, v22}) -var v12 any = v23 -_ = v12 -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("seq")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("concat")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/let")}) -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("list")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("apply")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("vector")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("seq")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("concat")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) -} -v49 := v48.Get() -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("list")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.Apply(v52, []any{v7}) -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("list")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) -} -v56 := v55.Get() -v57 := lang.Apply(v56, []any{v5}) -v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v59 := v58.FindInternedVar(lang.NewSymbol("interleave")) -if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) -} -v60 := v59.Get() -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("repeat")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) -} -v63 := v62.Get() -v64 := lang.Apply(v63, []any{v7}) -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("butlast")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) -} -v67 := v66.Get() -v68 := lang.Apply(v67, []any{v12}) -v69 := lang.Apply(v60, []any{v64, v68}) -v70 := lang.Apply(v49, []any{v53, v57, v69}) -v71 := lang.Apply(v46, []any{v70}) -v72 := lang.Apply(v40, []any{v43, v71}) -v73 := lang.Apply(v37, []any{v72}) -v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v75 := v74.FindInternedVar(lang.NewSymbol("list")) -if v75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) -} -v76 := v75.Get() -var v77 any -v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v79 := v78.FindInternedVar(lang.NewSymbol("empty?")) -if v79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) -} -v80 := v79.Get() -v81 := lang.Apply(v80, []any{v12}) -if lang.IsTruthy(v81) { -v77 = v7 -} else { -v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v83 := v82.FindInternedVar(lang.NewSymbol("last")) -if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) -} -v84 := v83.Get() -v85 := lang.Apply(v84, []any{v12}) -v77 = v85 -} -v86 := lang.Apply(v76, []any{v77}) -v87 := lang.Apply(v30, []any{v34, v73, v86}) -v88 := lang.Apply(v27, []any{v87}) -return v88 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// cond->> -{ -v0 := lang.NewSymbol("cond->>").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes an expression and a set of test/form pairs. Threads expr (via ->>)\n through each form for which the corresponding test expression\n is true. Note that, unlike cond branching, cond->> threading does not short circuit\n after the first true test expression.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7581), lang.NewKeyword("end-line"), int(7581))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -_ = nil -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("gensym")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, nil) -var v7 any = v11 -_ = v7 -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("map")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -var v16 lang.FnFunc -v16 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v17 := args[0] -var v18 any = v17 -_ = v18 -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("nth")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.Apply(v22, []any{v18, int64(0), nil}) -var v19 any = v23 -_ = v19 -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("nth")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.Apply(v27, []any{v18, int64(1), nil}) -var v24 any = v28 -_ = v24 -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("seq")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("concat")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{lang.NewSymbol("if")}) -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v19}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("seq")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) -} -v49 := v48.Get() -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("concat")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("list")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) -} -v55 := v54.Get() -v56 := lang.Apply(v55, []any{lang.NewSymbol("glojure.core/->>")}) -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("list")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) -} -v59 := v58.Get() -v60 := lang.Apply(v59, []any{v7}) -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("list")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) -} -v63 := v62.Get() -v64 := lang.Apply(v63, []any{v24}) -v65 := lang.Apply(v52, []any{v56, v60, v64}) -v66 := lang.Apply(v49, []any{v65}) -v67 := lang.Apply(v46, []any{v66}) -v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v69 := v68.FindInternedVar(lang.NewSymbol("list")) -if v69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) -} -v70 := v69.Get() -v71 := lang.Apply(v70, []any{v7}) -v72 := lang.Apply(v35, []any{v39, v43, v67, v71}) -v73 := lang.Apply(v32, []any{v72}) -return v73 -}) -v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7590), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7590), lang.NewKeyword("end-column"), int(67)) -v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("partition")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{int64(2), v6}) -v23 := lang.Apply(v15, []any{v18, v22}) -var v12 any = v23 -_ = v12 -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("seq")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("concat")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/let")}) -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("list")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("apply")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("vector")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("seq")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("concat")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) -} -v49 := v48.Get() -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("list")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.Apply(v52, []any{v7}) -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("list")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) -} -v56 := v55.Get() -v57 := lang.Apply(v56, []any{v5}) -v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v59 := v58.FindInternedVar(lang.NewSymbol("interleave")) -if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) -} -v60 := v59.Get() -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("repeat")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) -} -v63 := v62.Get() -v64 := lang.Apply(v63, []any{v7}) -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("butlast")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) -} -v67 := v66.Get() -v68 := lang.Apply(v67, []any{v12}) -v69 := lang.Apply(v60, []any{v64, v68}) -v70 := lang.Apply(v49, []any{v53, v57, v69}) -v71 := lang.Apply(v46, []any{v70}) -v72 := lang.Apply(v40, []any{v43, v71}) -v73 := lang.Apply(v37, []any{v72}) -v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v75 := v74.FindInternedVar(lang.NewSymbol("list")) -if v75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) -} -v76 := v75.Get() -var v77 any -v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v79 := v78.FindInternedVar(lang.NewSymbol("empty?")) -if v79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) -} -v80 := v79.Get() -v81 := lang.Apply(v80, []any{v12}) -if lang.IsTruthy(v81) { -v77 = v7 -} else { -v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v83 := v82.FindInternedVar(lang.NewSymbol("last")) -if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) -} -v84 := v83.Get() -v85 := lang.Apply(v84, []any{v12}) -v77 = v85 -} -v86 := lang.Apply(v76, []any{v77}) -v87 := lang.Apply(v30, []any{v34, v73, v86}) -v88 := lang.Apply(v27, []any{v87}) -return v88 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// condp -{ -v0 := lang.NewSymbol("condp").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes a binary predicate, an expression, and a set of clauses.\n Each clause can take the form of either:\n\n test-expr result-expr\n\n test-expr :>> result-fn\n\n Note :>> is an ordinary keyword.\n\n For each clause, (pred test-expr expr) is evaluated. If it returns\n logical true, the clause is a match. If a binary clause matches, the\n result-expr is returned, if a ternary clause matches, its result-fn,\n which must be a unary function, is called with the result of the\n predicate as its argument, the result of that call being the return\n value of condp. A single default expression can follow the clauses,\n and its value will be returned if no clause matches. If no default\n expression is provided and no clause matches, an\n IllegalArgumentException is thrown.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6353), lang.NewKeyword("end-line"), int(6353))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := lang.NewList(args[4:]...) -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("gensym")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v11, []any{"pred__"}) -var v8 any = v12 -_ = v8 -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("gensym")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{"expr__"}) -var v13 any = v17 -_ = v13 -var v19 lang.FnFunc -{ // function emit -v19 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v21 := args[0] -v22 := args[1] -v23 := args[2] -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("split-at")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -var v28 any -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("=")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("second")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v23}) -v36 := lang.Apply(v31, []any{lang.NewKeyword(">>"), v35}) -if lang.IsTruthy(v36) { -v28 = int64(3) -} else { -v28 = int64(2) -} -v37 := lang.Apply(v27, []any{v28, v23}) -var v24 any = v37 -_ = v24 -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("nth")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) -} -v41 := v40.Get() -v42 := lang.Apply(v41, []any{v24, int64(0), nil}) -var v38 any = v42 -_ = v38 -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("nth")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v38, int64(0), nil}) -var v43 any = v47 -_ = v43 -v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v50 := v49.FindInternedVar(lang.NewSymbol("nth")) -if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) -} -v51 := v50.Get() -v52 := lang.Apply(v51, []any{v38, int64(1), nil}) -var v48 any = v52 -_ = v48 -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("nth")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) -} -v56 := v55.Get() -v57 := lang.Apply(v56, []any{v38, int64(2), nil}) -var v53 any = v57 -_ = v53 -var v58 any = v38 -_ = v58 -v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v61 := v60.FindInternedVar(lang.NewSymbol("nth")) -if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) -} -v62 := v61.Get() -v63 := lang.Apply(v62, []any{v24, int64(1), nil}) -var v59 any = v63 -_ = v59 -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("count")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) -} -v67 := v66.Get() -v68 := lang.Apply(v67, []any{v58}) -var v64 any = v68 -_ = v64 -var v70 any -v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v72 := v71.FindInternedVar(lang.NewSymbol("=")) -if v72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) -} -v73 := v72.Get() -v74 := lang.Apply(v73, []any{int64(0), v64}) -if lang.IsTruthy(v74) { -v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v76 := v75.FindInternedVar(lang.NewSymbol("seq")) -if v76.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) -} -v77 := v76.Get() -v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v79 := v78.FindInternedVar(lang.NewSymbol("concat")) -if v79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) -} -v80 := v79.Get() -v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v82 := v81.FindInternedVar(lang.NewSymbol("list")) -if v82.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) -} -v83 := v82.Get() -v84 := lang.Apply(v83, []any{lang.NewSymbol("throw")}) -v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v86 := v85.FindInternedVar(lang.NewSymbol("list")) -if v86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) -} -v87 := v86.Get() -v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v89 := v88.FindInternedVar(lang.NewSymbol("seq")) -if v89.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) -} -v90 := v89.Get() -v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v92 := v91.FindInternedVar(lang.NewSymbol("concat")) -if v92.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) -} -v93 := v92.Get() -v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v95 := v94.FindInternedVar(lang.NewSymbol("list")) -if v95.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) -} -v96 := v95.Get() -v97 := lang.Apply(v96, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewIllegalArgumentError")}) -v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v99 := v98.FindInternedVar(lang.NewSymbol("list")) -if v99.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) -} -v100 := v99.Get() -v101 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v102 := v101.FindInternedVar(lang.NewSymbol("seq")) -if v102.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v102))) -} -v103 := v102.Get() -v104 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v105 := v104.FindInternedVar(lang.NewSymbol("concat")) -if v105.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v105))) -} -v106 := v105.Get() -v107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v108 := v107.FindInternedVar(lang.NewSymbol("list")) -if v108.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v108))) -} -v109 := v108.Get() -v110 := lang.Apply(v109, []any{lang.NewSymbol("glojure.core/str")}) -v111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v112 := v111.FindInternedVar(lang.NewSymbol("list")) -if v112.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v112))) -} -v113 := v112.Get() -v114 := lang.Apply(v113, []any{"No matching clause: "}) -v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v116 := v115.FindInternedVar(lang.NewSymbol("list")) -if v116.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) -} -v117 := v116.Get() -v118 := lang.Apply(v117, []any{v22}) -v119 := lang.Apply(v106, []any{v110, v114, v118}) -v120 := lang.Apply(v103, []any{v119}) -v121 := lang.Apply(v100, []any{v120}) -v122 := lang.Apply(v93, []any{v97, v121}) -v123 := lang.Apply(v90, []any{v122}) -v124 := lang.Apply(v87, []any{v123}) -v125 := lang.Apply(v80, []any{v84, v124}) -v126 := lang.Apply(v77, []any{v125}) -v70 = v126 -} else { -var v127 any -v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v129 := v128.FindInternedVar(lang.NewSymbol("=")) -if v129.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v129))) -} -v130 := v129.Get() -v131 := lang.Apply(v130, []any{int64(1), v64}) -if lang.IsTruthy(v131) { -v127 = v43 -} else { -var v132 any -v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v134 := v133.FindInternedVar(lang.NewSymbol("=")) -if v134.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) -} -v135 := v134.Get() -v136 := lang.Apply(v135, []any{int64(2), v64}) -if lang.IsTruthy(v136) { -v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v138 := v137.FindInternedVar(lang.NewSymbol("seq")) -if v138.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) -} -v139 := v138.Get() -v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v141 := v140.FindInternedVar(lang.NewSymbol("concat")) -if v141.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) -} -v142 := v141.Get() -v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v144 := v143.FindInternedVar(lang.NewSymbol("list")) -if v144.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) -} -v145 := v144.Get() -v146 := lang.Apply(v145, []any{lang.NewSymbol("if")}) -v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v148 := v147.FindInternedVar(lang.NewSymbol("list")) -if v148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) -} -v149 := v148.Get() -v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v151 := v150.FindInternedVar(lang.NewSymbol("seq")) -if v151.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) -} -v152 := v151.Get() -v153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v154 := v153.FindInternedVar(lang.NewSymbol("concat")) -if v154.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v154))) -} -v155 := v154.Get() -v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v157 := v156.FindInternedVar(lang.NewSymbol("list")) -if v157.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) -} -v158 := v157.Get() -v159 := lang.Apply(v158, []any{v21}) -v160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v161 := v160.FindInternedVar(lang.NewSymbol("list")) -if v161.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v161))) -} -v162 := v161.Get() -v163 := lang.Apply(v162, []any{v43}) -v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v165 := v164.FindInternedVar(lang.NewSymbol("list")) -if v165.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) -} -v166 := v165.Get() -v167 := lang.Apply(v166, []any{v22}) -v168 := lang.Apply(v155, []any{v159, v163, v167}) -v169 := lang.Apply(v152, []any{v168}) -v170 := lang.Apply(v149, []any{v169}) -v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v172 := v171.FindInternedVar(lang.NewSymbol("list")) -if v172.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) -} -v173 := v172.Get() -v174 := lang.Apply(v173, []any{v48}) -v175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v176 := v175.FindInternedVar(lang.NewSymbol("list")) -if v176.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v176))) -} -v177 := v176.Get() -v178 := lang.Apply(v20, []any{v21, v22, v59}) -v179 := lang.Apply(v177, []any{v178}) -v180 := lang.Apply(v142, []any{v146, v170, v174, v179}) -v181 := lang.Apply(v139, []any{v180}) -v132 = v181 -} else { -var v182 any -if lang.IsTruthy(lang.NewKeyword("else")) { -v183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v184 := v183.FindInternedVar(lang.NewSymbol("seq")) -if v184.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v184))) -} -v185 := v184.Get() -v186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v187 := v186.FindInternedVar(lang.NewSymbol("concat")) -if v187.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v187))) -} -v188 := v187.Get() -v189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v190 := v189.FindInternedVar(lang.NewSymbol("list")) -if v190.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v190))) -} -v191 := v190.Get() -v192 := lang.Apply(v191, []any{lang.NewSymbol("glojure.core/if-let")}) -v193 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v194 := v193.FindInternedVar(lang.NewSymbol("list")) -if v194.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v194))) -} -v195 := v194.Get() -v196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v197 := v196.FindInternedVar(lang.NewSymbol("apply")) -if v197.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v197))) -} -v198 := v197.Get() -v199 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v200 := v199.FindInternedVar(lang.NewSymbol("vector")) -if v200.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v200))) -} -v201 := v200.Get() -v202 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v203 := v202.FindInternedVar(lang.NewSymbol("seq")) -if v203.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v203))) -} -v204 := v203.Get() -v205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v206 := v205.FindInternedVar(lang.NewSymbol("concat")) -if v206.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v206))) -} -v207 := v206.Get() -v208 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v209 := v208.FindInternedVar(lang.NewSymbol("list")) -if v209.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v209))) -} -v210 := v209.Get() -v211 := lang.Apply(v210, []any{lang.NewSymbol("p__0__auto__")}) -v212 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v213 := v212.FindInternedVar(lang.NewSymbol("list")) -if v213.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v213))) -} -v214 := v213.Get() -v215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v216 := v215.FindInternedVar(lang.NewSymbol("seq")) -if v216.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v216))) -} -v217 := v216.Get() -v218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v219 := v218.FindInternedVar(lang.NewSymbol("concat")) -if v219.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v219))) -} -v220 := v219.Get() -v221 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v222 := v221.FindInternedVar(lang.NewSymbol("list")) -if v222.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v222))) -} -v223 := v222.Get() -v224 := lang.Apply(v223, []any{v21}) -v225 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v226 := v225.FindInternedVar(lang.NewSymbol("list")) -if v226.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v226))) -} -v227 := v226.Get() -v228 := lang.Apply(v227, []any{v43}) -v229 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v230 := v229.FindInternedVar(lang.NewSymbol("list")) -if v230.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v230))) -} -v231 := v230.Get() -v232 := lang.Apply(v231, []any{v22}) -v233 := lang.Apply(v220, []any{v224, v228, v232}) -v234 := lang.Apply(v217, []any{v233}) -v235 := lang.Apply(v214, []any{v234}) -v236 := lang.Apply(v207, []any{v211, v235}) -v237 := lang.Apply(v204, []any{v236}) -v238 := lang.Apply(v198, []any{v201, v237}) -v239 := lang.Apply(v195, []any{v238}) -v240 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v241 := v240.FindInternedVar(lang.NewSymbol("list")) -if v241.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v241))) -} -v242 := v241.Get() -v243 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v244 := v243.FindInternedVar(lang.NewSymbol("seq")) -if v244.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v244))) -} -v245 := v244.Get() -v246 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v247 := v246.FindInternedVar(lang.NewSymbol("concat")) -if v247.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v247))) -} -v248 := v247.Get() -v249 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v250 := v249.FindInternedVar(lang.NewSymbol("list")) -if v250.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v250))) -} -v251 := v250.Get() -v252 := lang.Apply(v251, []any{v53}) -v253 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v254 := v253.FindInternedVar(lang.NewSymbol("list")) -if v254.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v254))) -} -v255 := v254.Get() -v256 := lang.Apply(v255, []any{lang.NewSymbol("p__0__auto__")}) -v257 := lang.Apply(v248, []any{v252, v256}) -v258 := lang.Apply(v245, []any{v257}) -v259 := lang.Apply(v242, []any{v258}) -v260 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v261 := v260.FindInternedVar(lang.NewSymbol("list")) -if v261.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v261))) -} -v262 := v261.Get() -v263 := lang.Apply(v20, []any{v21, v22, v59}) -v264 := lang.Apply(v262, []any{v263}) -v265 := lang.Apply(v188, []any{v192, v239, v259, v264}) -v266 := lang.Apply(v185, []any{v265}) -v182 = v266 -} else { -v182 = nil -} -v132 = v182 -} -v127 = v132 -} -v70 = v127 -} -return v70 -}) -v20 := v19 -_ = v20 -} -v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6377), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(6389), lang.NewKeyword("end-column"), int(53)) -v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v18 any = v21 -_ = v18 -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("seq")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("concat")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("list")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.Apply(v31, []any{lang.NewSymbol("glojure.core/let")}) -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("list")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("apply")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("vector")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) -} -v41 := v40.Get() -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("seq")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) -} -v44 := v43.Get() -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("concat")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v8}) -v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("list")) -if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) -} -v54 := v53.Get() -v55 := lang.Apply(v54, []any{v5}) -v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v57 := v56.FindInternedVar(lang.NewSymbol("list")) -if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) -} -v58 := v57.Get() -v59 := lang.Apply(v58, []any{v13}) -v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v61 := v60.FindInternedVar(lang.NewSymbol("list")) -if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) -} -v62 := v61.Get() -v63 := lang.Apply(v62, []any{v6}) -v64 := lang.Apply(v47, []any{v51, v55, v59, v63}) -v65 := lang.Apply(v44, []any{v64}) -v66 := lang.Apply(v38, []any{v41, v65}) -v67 := lang.Apply(v35, []any{v66}) -v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v69 := v68.FindInternedVar(lang.NewSymbol("list")) -if v69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) -} -v70 := v69.Get() -v71 := lang.Apply(v18, []any{v8, v13, v7}) -v72 := lang.Apply(v70, []any{v71}) -v73 := lang.Apply(v28, []any{v32, v67, v72}) -v74 := lang.Apply(v25, []any{v73}) -return v74 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// conj -{ -v0 := lang.NewSymbol("conj").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("xs"))), lang.NewKeyword("doc"), "conj[oin]. Returns a new collection with the xs\n 'added'. (conj nil item) returns (item).\n (conj coll) returns coll. (conj) returns [].\n The 'addition' may happen at different 'places' depending\n on the concrete type.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(73), lang.NewKeyword("end-line"), int(81))).(*lang.Symbol) -var v2 lang.FnFunc -{ // function conj -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v4 := lang.NewVector() -v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(82), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(82), lang.NewKeyword("end-column"), int(14)) -v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v6 - case 1: -v4 := args[0] -return v4 - case 2: -v4 := args[0] -v5 := args[1] -v6 := lang.Apply(lang.Conj, []any{v4, v5}) -return v6 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6 := lang.NewList(args[2:]...) -recur_loop_10: -var v7 any -if lang.IsTruthy(v6) { -v9 := lang.Apply(lang.Conj, []any{v4, v5}) -var v8 any = v9 -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("first")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v6}) -var v10 any = v14 -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("next")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v6}) -var v15 any = v19 -v4 = v8 -v5 = v10 -v6 = v15 -goto recur_loop_10 -} else { -v20 := lang.Apply(lang.Conj, []any{v4, v5}) -v7 = v20 -} -return v7 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(81), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(88), lang.NewKeyword("end-column"), int(67))).(lang.FnFunc) -v3 := v2 -_ = v3 -} -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// conj! -{ -v0 := lang.NewSymbol("conj!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Adds x to the transient collection, and return coll. The 'addition'\n may happen at different 'places' depending on the concrete type.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3359), lang.NewKeyword("end-line"), int(3359))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v4 := v3.FindInternedVar(lang.NewSymbol("transient")) -if v4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) -} -v5 := v4.Get() -v6 := lang.NewVector() -v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3364), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(3364), lang.NewKeyword("end-column"), int(19)) -v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v9 := lang.Apply(v5, []any{v8}) -return v9 - case 1: -v3 := args[0] -return v3 - case 2: -v3 := args[0] -v4 := args[1] -v5, _ := lang.FieldOrMethod(v3, "Conj") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Conj is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// cons -{ -v0 := lang.NewSymbol("cons").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("seq"))), lang.NewKeyword("doc"), "Returns a new seq where x is the first element and seq is\n the rest.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(21), lang.NewKeyword("end-line"), int(27))).(*lang.Symbol) -var v2 lang.FnFunc -{ // function cons -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6 := lang.Apply(lang.NewCons, []any{v4, v5}) -return v6 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(27), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(27), lang.NewKeyword("end-column"), int(89))).(lang.FnFunc) -v3 := v2 -_ = v3 -} -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// constantly -{ -v0 := lang.NewSymbol("constantly").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns a function that takes any number of arguments and returns x.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1440), lang.NewKeyword("end-line"), int(1440))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := lang.NewList(args[0:]...) -return v3 - } -}) -v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1444), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(1444), lang.NewKeyword("end-column"), int(21)) -v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v6 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// contains? -{ -v0 := lang.NewSymbol("contains?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("key"))), lang.NewKeyword("doc"), "Returns true if key is present in the given collection, otherwise\n returns false. Note that for numerically indexed collections like\n vectors and Java arrays, this tests if the numeric key is within the\n range of indexes. 'contains?' operates constant or logarithmic time;\n it will not perform a linear search for a value. See also 'some'.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1479), lang.NewKeyword("end-line"), int(1479))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5, _ := lang.FieldOrMethod(runtime5.RT, "Contains") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Contains is not a function"))) -} -v6 := lang.Apply(v5, []any{v3, v4}) -return v6 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// count -{ -var v1 lang.FnFunc -{ // function count__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/Count")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v3}) -v35 := lang.Apply(v26, []any{v30, v34}) -v36 := lang.Apply(v23, []any{v35}) -v37 := lang.Apply(v20, []any{v36}) -v38 := lang.Apply(v9, []any{v13, v17, v37}) -v39 := lang.Apply(v6, []any{v38}) -return v39 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("count").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the number of items in the collection. (count nil) returns\n 0. Also works on strings, arrays, and Java Collections and Maps", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(867), lang.NewKeyword("end-line"), int(867))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := lang.Apply(lang.Count, []any{v4}) -return v5 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// counted? -{ -v0 := lang.NewSymbol("counted?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements count in constant time", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6241), lang.NewKeyword("end-line"), int(6241))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{lang.Counted, v3}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// create-ns -{ -v0 := lang.NewSymbol("create-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Create a new namespace named by the symbol if one doesn't already\n exist, returns it or the already-existing namespace of the same\n name.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4131), lang.NewKeyword("end-line"), int(4131))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.Apply(nil, []any{v3}) -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// create-struct -{ -v0 := lang.NewSymbol("create-struct").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keys"))), lang.NewKeyword("doc"), "Returns a structure basis object.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4037), lang.NewKeyword("end-line"), int(4037))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewList(args[0:]...) -v4 := lang.Apply(lang.CreatePersistentStructMapSlotMap, []any{v3}) -return v4 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// cycle -{ -v0 := lang.NewSymbol("cycle").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy (infinite!) sequence of repetitions of the items in coll.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2977), lang.NewKeyword("end-line"), int(2977))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{v3}) -v8 := lang.Apply(lang.NewCycle, []any{v7}) -return v8 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// data-reader-urls -{ -v0 := lang.NewSymbol("data-reader-urls").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7830), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7830), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -return lang.NewList() -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// data-reader-var -{ -v0 := lang.NewSymbol("data-reader-var").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7832), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7832), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("intern")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("create-ns")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("symbol")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("namespace")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v3}) -v17 := lang.Apply(v12, []any{v16}) -v18 := lang.Apply(v9, []any{v17}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("symbol")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("name")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v26 := lang.Apply(v21, []any{v25}) -v27 := lang.Apply(v6, []any{v18, v26}) -return v27 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// dec -{ -var v1 lang.FnFunc -{ // function dec__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -var v30 any -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -if lang.IsTruthy(v33) { -v30 = lang.NewSymbol("unchecked_dec") -} else { -v30 = lang.NewSymbol("dec") -} -v34 := lang.Apply(v29, []any{v30}) -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("list")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v3}) -v39 := lang.Apply(v26, []any{v34, v38}) -v40 := lang.Apply(v23, []any{v39}) -v41 := lang.Apply(v20, []any{v40}) -v42 := lang.Apply(v9, []any{v13, v17, v41}) -v43 := lang.Apply(v6, []any{v42}) -return v43 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("dec").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns a number one less than num. Does not auto-promote\n longs, will throw on overflow. See also: dec'", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1147), lang.NewKeyword("end-line"), int(1147))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5, _ := lang.FieldOrMethod(lang.Numbers, "dec") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("dec is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// dec' -{ -var v1 lang.FnFunc -{ // function dec'__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/decP")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v3}) -v35 := lang.Apply(v26, []any{v30, v34}) -v36 := lang.Apply(v23, []any{v35}) -v37 := lang.Apply(v20, []any{v36}) -v38 := lang.Apply(v9, []any{v13, v17, v37}) -v39 := lang.Apply(v6, []any{v38}) -return v39 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("dec'").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns a number one less than num. Supports arbitrary precision.\n See also: dec", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1140), lang.NewKeyword("end-line"), int(1140))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5, _ := lang.FieldOrMethod(lang.Numbers, "decP") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("decP is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// decimal? -{ -v0 := lang.NewSymbol("decimal?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is a BigDecimal", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3599), lang.NewKeyword("end-line"), int(3599))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{lang.*BigDecimal, v3}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// declare -{ -v0 := lang.NewSymbol("declare").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("names"))), lang.NewKeyword("doc"), "defs the supplied var names with no bindings, useful for making forward declarations.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(2768), lang.NewKeyword("end-line"), int(2768))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("seq")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("concat")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("list")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{lang.NewSymbol("do")}) -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("map")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -var v19 lang.FnFunc -v19 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v20 := args[0] -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("list")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("vary-meta")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("assoc")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v26, []any{v20, v29, lang.NewKeyword("declared"), true}) -v31 := lang.Apply(v23, []any{lang.NewSymbol("def"), v30}) -return v31 -}) -v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2771), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(2771), lang.NewKeyword("end-column"), int(71)) -v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v22 := lang.Apply(v18, []any{v21, v5}) -v23 := lang.Apply(v11, []any{v15, v22}) -v24 := lang.Apply(v8, []any{v23}) -return v24 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// dedupe -{ -v0 := lang.NewSymbol("dedupe").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence removing consecutive duplicates in coll.\n Returns a transducer when no collection is provided.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7681), lang.NewKeyword("end-line"), int(7681))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("volatile!")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{lang.NewKeyword("glojure.core/none")}) -var v5 any = v9 -_ = v5 -var v11 lang.FnFunc -v11 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v12 := lang.Apply(v4, nil) -return v12 - case 1: -v12 := args[0] -v13 := lang.Apply(v4, []any{v12}) -return v13 - case 2: -v12 := args[0] -v13 := args[1] -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("deref")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v5}) -var v14 any = v18 -_ = v14 -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("vreset!")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.Apply(v22, []any{v5, v13}) -_ = v23 -var v24 any -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("=")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.Apply(v27, []any{v14, v13}) -if lang.IsTruthy(v28) { -v24 = v12 -} else { -v29 := lang.Apply(v4, []any{v12, v13}) -v24 = v29 -} -return v24 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7688), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7696), lang.NewKeyword("end-column"), int(37)) -v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v13 -}) -v4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7686), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7696), lang.NewKeyword("end-column"), int(39)) -v5, err := lang.WithMeta(v3, v4.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v5 - case 1: -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("sequence")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("dedupe")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, nil) -v11 := lang.Apply(v6, []any{v10, v3}) -return v11 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// def-aset -{ -v0 := lang.NewSymbol("def-aset").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("method"), lang.NewSymbol("coerce"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3935), lang.NewKeyword("end-line"), int(3936), lang.NewKeyword("private"), true)).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 5 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := args[4] -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("seq")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("concat")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("glojure.core/defn")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v20, []any{v5}) -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("list")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("apply")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("hash-map")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("seq")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("concat")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("list")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.Apply(v39, []any{lang.NewKeyword("arglists")}) -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("list")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("seq")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("concat")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) -} -v49 := v48.Get() -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("list")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.Apply(v52, []any{lang.NewSymbol("quote")}) -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("list")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) -} -v56 := v55.Get() -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("seq")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) -} -v59 := v58.Get() -v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v61 := v60.FindInternedVar(lang.NewSymbol("concat")) -if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) -} -v62 := v61.Get() -v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v64 := v63.FindInternedVar(lang.NewSymbol("list")) -if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) -} -v65 := v64.Get() -v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v67 := v66.FindInternedVar(lang.NewSymbol("apply")) -if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) -} -v68 := v67.Get() -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("vector")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) -} -v71 := v70.Get() -v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v73 := v72.FindInternedVar(lang.NewSymbol("seq")) -if v73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) -} -v74 := v73.Get() -v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v76 := v75.FindInternedVar(lang.NewSymbol("concat")) -if v76.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) -} -v77 := v76.Get() -v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v79 := v78.FindInternedVar(lang.NewSymbol("list")) -if v79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) -} -v80 := v79.Get() -v81 := lang.Apply(v80, []any{lang.NewSymbol("array")}) -v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v83 := v82.FindInternedVar(lang.NewSymbol("list")) -if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) -} -v84 := v83.Get() -v85 := lang.Apply(v84, []any{lang.NewSymbol("idx")}) -v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v87 := v86.FindInternedVar(lang.NewSymbol("list")) -if v87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) -} -v88 := v87.Get() -v89 := lang.Apply(v88, []any{lang.NewSymbol("val")}) -v90 := lang.Apply(v77, []any{v81, v85, v89}) -v91 := lang.Apply(v74, []any{v90}) -v92 := lang.Apply(v68, []any{v71, v91}) -v93 := lang.Apply(v65, []any{v92}) -v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v95 := v94.FindInternedVar(lang.NewSymbol("list")) -if v95.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) -} -v96 := v95.Get() -v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v98 := v97.FindInternedVar(lang.NewSymbol("apply")) -if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) -} -v99 := v98.Get() -v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v101 := v100.FindInternedVar(lang.NewSymbol("vector")) -if v101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) -} -v102 := v101.Get() -v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v104 := v103.FindInternedVar(lang.NewSymbol("seq")) -if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) -} -v105 := v104.Get() -v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v107 := v106.FindInternedVar(lang.NewSymbol("concat")) -if v107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) -} -v108 := v107.Get() -v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v110 := v109.FindInternedVar(lang.NewSymbol("list")) -if v110.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) -} -v111 := v110.Get() -v112 := lang.Apply(v111, []any{lang.NewSymbol("array")}) -v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v114 := v113.FindInternedVar(lang.NewSymbol("list")) -if v114.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) -} -v115 := v114.Get() -v116 := lang.Apply(v115, []any{lang.NewSymbol("idx")}) -v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v118 := v117.FindInternedVar(lang.NewSymbol("list")) -if v118.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) -} -v119 := v118.Get() -v120 := lang.Apply(v119, []any{lang.NewSymbol("idx2")}) -v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v122 := v121.FindInternedVar(lang.NewSymbol("list")) -if v122.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) -} -v123 := v122.Get() -v124 := lang.Apply(v123, []any{lang.NewSymbol("&")}) -v125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v126 := v125.FindInternedVar(lang.NewSymbol("list")) -if v126.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v126))) -} -v127 := v126.Get() -v128 := lang.Apply(v127, []any{lang.NewSymbol("idxv")}) -v129 := lang.Apply(v108, []any{v112, v116, v120, v124, v128}) -v130 := lang.Apply(v105, []any{v129}) -v131 := lang.Apply(v99, []any{v102, v130}) -v132 := lang.Apply(v96, []any{v131}) -v133 := lang.Apply(v62, []any{v93, v132}) -v134 := lang.Apply(v59, []any{v133}) -v135 := lang.Apply(v56, []any{v134}) -v136 := lang.Apply(v49, []any{v53, v135}) -v137 := lang.Apply(v46, []any{v136}) -v138 := lang.Apply(v43, []any{v137}) -v139 := lang.Apply(v36, []any{v40, v138}) -v140 := lang.Apply(v33, []any{v139}) -v141 := lang.Apply(v27, []any{v30, v140}) -v142 := lang.Apply(v24, []any{v141}) -v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v144 := v143.FindInternedVar(lang.NewSymbol("list")) -if v144.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) -} -v145 := v144.Get() -v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v147 := v146.FindInternedVar(lang.NewSymbol("seq")) -if v147.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) -} -v148 := v147.Get() -v149 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v150 := v149.FindInternedVar(lang.NewSymbol("concat")) -if v150.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v150))) -} -v151 := v150.Get() -v152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v153 := v152.FindInternedVar(lang.NewSymbol("list")) -if v153.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v153))) -} -v154 := v153.Get() -v155 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v156 := v155.FindInternedVar(lang.NewSymbol("apply")) -if v156.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v156))) -} -v157 := v156.Get() -v158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v159 := v158.FindInternedVar(lang.NewSymbol("vector")) -if v159.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v159))) -} -v160 := v159.Get() -v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v162 := v161.FindInternedVar(lang.NewSymbol("seq")) -if v162.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) -} -v163 := v162.Get() -v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v165 := v164.FindInternedVar(lang.NewSymbol("concat")) -if v165.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) -} -v166 := v165.Get() -v167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v168 := v167.FindInternedVar(lang.NewSymbol("list")) -if v168.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v168))) -} -v169 := v168.Get() -v170 := lang.Apply(v169, []any{lang.NewSymbol("array__0__auto__")}) -v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v172 := v171.FindInternedVar(lang.NewSymbol("list")) -if v172.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) -} -v173 := v172.Get() -v174 := lang.Apply(v173, []any{lang.NewSymbol("idx__1__auto__")}) -v175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v176 := v175.FindInternedVar(lang.NewSymbol("list")) -if v176.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v176))) -} -v177 := v176.Get() -v178 := lang.Apply(v177, []any{lang.NewSymbol("val__2__auto__")}) -v179 := lang.Apply(v166, []any{v170, v174, v178}) -v180 := lang.Apply(v163, []any{v179}) -v181 := lang.Apply(v157, []any{v160, v180}) -v182 := lang.Apply(v154, []any{v181}) -v183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v184 := v183.FindInternedVar(lang.NewSymbol("list")) -if v184.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v184))) -} -v185 := v184.Get() -v186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v187 := v186.FindInternedVar(lang.NewSymbol("seq")) -if v187.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v187))) -} -v188 := v187.Get() -v189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v190 := v189.FindInternedVar(lang.NewSymbol("concat")) -if v190.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v190))) -} -v191 := v190.Get() -v192 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v193 := v192.FindInternedVar(lang.NewSymbol("list")) -if v193.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v193))) -} -v194 := v193.Get() -v195 := lang.Apply(v194, []any{lang.NewSymbol(".")}) -v196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v197 := v196.FindInternedVar(lang.NewSymbol("list")) -if v197.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v197))) -} -v198 := v197.Get() -v199 := lang.Apply(v198, []any{lang.NewSymbol("glojure.core/Array")}) -v200 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v201 := v200.FindInternedVar(lang.NewSymbol("list")) -if v201.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v201))) -} -v202 := v201.Get() -v203 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v204 := v203.FindInternedVar(lang.NewSymbol("seq")) -if v204.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v204))) -} -v205 := v204.Get() -v206 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v207 := v206.FindInternedVar(lang.NewSymbol("concat")) -if v207.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v207))) -} -v208 := v207.Get() -v209 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v210 := v209.FindInternedVar(lang.NewSymbol("list")) -if v210.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v210))) -} -v211 := v210.Get() -v212 := lang.Apply(v211, []any{v6}) -v213 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v214 := v213.FindInternedVar(lang.NewSymbol("list")) -if v214.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v214))) -} -v215 := v214.Get() -v216 := lang.Apply(v215, []any{lang.NewSymbol("array__0__auto__")}) -v217 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v218 := v217.FindInternedVar(lang.NewSymbol("list")) -if v218.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v218))) -} -v219 := v218.Get() -v220 := lang.Apply(v219, []any{lang.NewSymbol("idx__1__auto__")}) -v221 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v222 := v221.FindInternedVar(lang.NewSymbol("list")) -if v222.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v222))) -} -v223 := v222.Get() -v224 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v225 := v224.FindInternedVar(lang.NewSymbol("seq")) -if v225.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v225))) -} -v226 := v225.Get() -v227 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v228 := v227.FindInternedVar(lang.NewSymbol("concat")) -if v228.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v228))) -} -v229 := v228.Get() -v230 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v231 := v230.FindInternedVar(lang.NewSymbol("list")) -if v231.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v231))) -} -v232 := v231.Get() -v233 := lang.Apply(v232, []any{v7}) -v234 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v235 := v234.FindInternedVar(lang.NewSymbol("list")) -if v235.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v235))) -} -v236 := v235.Get() -v237 := lang.Apply(v236, []any{lang.NewSymbol("val__2__auto__")}) -v238 := lang.Apply(v229, []any{v233, v237}) -v239 := lang.Apply(v226, []any{v238}) -v240 := lang.Apply(v223, []any{v239}) -v241 := lang.Apply(v208, []any{v212, v216, v220, v240}) -v242 := lang.Apply(v205, []any{v241}) -v243 := lang.Apply(v202, []any{v242}) -v244 := lang.Apply(v191, []any{v195, v199, v243}) -v245 := lang.Apply(v188, []any{v244}) -v246 := lang.Apply(v185, []any{v245}) -v247 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v248 := v247.FindInternedVar(lang.NewSymbol("list")) -if v248.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v248))) -} -v249 := v248.Get() -v250 := lang.Apply(v249, []any{lang.NewSymbol("val__2__auto__")}) -v251 := lang.Apply(v151, []any{v182, v246, v250}) -v252 := lang.Apply(v148, []any{v251}) -v253 := lang.Apply(v145, []any{v252}) -v254 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v255 := v254.FindInternedVar(lang.NewSymbol("list")) -if v255.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v255))) -} -v256 := v255.Get() -v257 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v258 := v257.FindInternedVar(lang.NewSymbol("seq")) -if v258.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v258))) -} -v259 := v258.Get() -v260 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v261 := v260.FindInternedVar(lang.NewSymbol("concat")) -if v261.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v261))) -} -v262 := v261.Get() -v263 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v264 := v263.FindInternedVar(lang.NewSymbol("list")) -if v264.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v264))) -} -v265 := v264.Get() -v266 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v267 := v266.FindInternedVar(lang.NewSymbol("apply")) -if v267.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v267))) -} -v268 := v267.Get() -v269 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v270 := v269.FindInternedVar(lang.NewSymbol("vector")) -if v270.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v270))) -} -v271 := v270.Get() -v272 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v273 := v272.FindInternedVar(lang.NewSymbol("seq")) -if v273.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v273))) -} -v274 := v273.Get() -v275 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v276 := v275.FindInternedVar(lang.NewSymbol("concat")) -if v276.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v276))) -} -v277 := v276.Get() -v278 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v279 := v278.FindInternedVar(lang.NewSymbol("list")) -if v279.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v279))) -} -v280 := v279.Get() -v281 := lang.Apply(v280, []any{lang.NewSymbol("array__0__auto__")}) -v282 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v283 := v282.FindInternedVar(lang.NewSymbol("list")) -if v283.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v283))) -} -v284 := v283.Get() -v285 := lang.Apply(v284, []any{lang.NewSymbol("idx__1__auto__")}) -v286 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v287 := v286.FindInternedVar(lang.NewSymbol("list")) -if v287.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v287))) -} -v288 := v287.Get() -v289 := lang.Apply(v288, []any{lang.NewSymbol("idx2__3__auto__")}) -v290 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v291 := v290.FindInternedVar(lang.NewSymbol("list")) -if v291.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v291))) -} -v292 := v291.Get() -v293 := lang.Apply(v292, []any{lang.NewSymbol("&")}) -v294 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v295 := v294.FindInternedVar(lang.NewSymbol("list")) -if v295.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v295))) -} -v296 := v295.Get() -v297 := lang.Apply(v296, []any{lang.NewSymbol("idxv__4__auto__")}) -v298 := lang.Apply(v277, []any{v281, v285, v289, v293, v297}) -v299 := lang.Apply(v274, []any{v298}) -v300 := lang.Apply(v268, []any{v271, v299}) -v301 := lang.Apply(v265, []any{v300}) -v302 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v303 := v302.FindInternedVar(lang.NewSymbol("list")) -if v303.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v303))) -} -v304 := v303.Get() -v305 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v306 := v305.FindInternedVar(lang.NewSymbol("seq")) -if v306.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v306))) -} -v307 := v306.Get() -v308 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v309 := v308.FindInternedVar(lang.NewSymbol("concat")) -if v309.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v309))) -} -v310 := v309.Get() -v311 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v312 := v311.FindInternedVar(lang.NewSymbol("list")) -if v312.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v312))) -} -v313 := v312.Get() -v314 := lang.Apply(v313, []any{lang.NewSymbol("glojure.core/apply")}) -v315 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v316 := v315.FindInternedVar(lang.NewSymbol("list")) -if v316.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v316))) -} -v317 := v316.Get() -v318 := lang.Apply(v317, []any{v5}) -v319 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v320 := v319.FindInternedVar(lang.NewSymbol("list")) -if v320.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v320))) -} -v321 := v320.Get() -v322 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v323 := v322.FindInternedVar(lang.NewSymbol("seq")) -if v323.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v323))) -} -v324 := v323.Get() -v325 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v326 := v325.FindInternedVar(lang.NewSymbol("concat")) -if v326.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v326))) -} -v327 := v326.Get() -v328 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v329 := v328.FindInternedVar(lang.NewSymbol("list")) -if v329.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v329))) -} -v330 := v329.Get() -v331 := lang.Apply(v330, []any{lang.NewSymbol("glojure.core/aget")}) -v332 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v333 := v332.FindInternedVar(lang.NewSymbol("list")) -if v333.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v333))) -} -v334 := v333.Get() -v335 := lang.Apply(v334, []any{lang.NewSymbol("array__0__auto__")}) -v336 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v337 := v336.FindInternedVar(lang.NewSymbol("list")) -if v337.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v337))) -} -v338 := v337.Get() -v339 := lang.Apply(v338, []any{lang.NewSymbol("idx__1__auto__")}) -v340 := lang.Apply(v327, []any{v331, v335, v339}) -v341 := lang.Apply(v324, []any{v340}) -v342 := lang.Apply(v321, []any{v341}) -v343 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v344 := v343.FindInternedVar(lang.NewSymbol("list")) -if v344.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v344))) -} -v345 := v344.Get() -v346 := lang.Apply(v345, []any{lang.NewSymbol("idx2__3__auto__")}) -v347 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v348 := v347.FindInternedVar(lang.NewSymbol("list")) -if v348.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v348))) -} -v349 := v348.Get() -v350 := lang.Apply(v349, []any{lang.NewSymbol("idxv__4__auto__")}) -v351 := lang.Apply(v310, []any{v314, v318, v342, v346, v350}) -v352 := lang.Apply(v307, []any{v351}) -v353 := lang.Apply(v304, []any{v352}) -v354 := lang.Apply(v262, []any{v301, v353}) -v355 := lang.Apply(v259, []any{v354}) -v356 := lang.Apply(v256, []any{v355}) -v357 := lang.Apply(v13, []any{v17, v21, v142, v253, v356}) -v358 := lang.Apply(v10, []any{v357}) -return v358 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// definline -{ -v0 := lang.NewSymbol("definline").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("decl"))), lang.NewKeyword("doc"), "Experimental - like defmacro, except defines a named function whose\n body is the expansion, calls to which may be expanded inline as if\n it were a macro. Cannot be used with variadic (&) args.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5253), lang.NewKeyword("end-line"), int(5253))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("split-with")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("comp")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("not")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("vector?")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v13, []any{v16, v19}) -v21 := lang.Apply(v10, []any{v20, v6}) -var v7 any = v21 -_ = v7 -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("nth")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{v7, int64(0), nil}) -var v22 any = v26 -_ = v22 -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("nth")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{v7, int64(1), nil}) -var v27 any = v31 -_ = v27 -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("nth")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v27, int64(0), nil}) -var v32 any = v36 -_ = v32 -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("nth")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.Apply(v40, []any{v27, int64(1), nil}) -var v37 any = v41 -_ = v37 -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("seq")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("concat")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) -} -v48 := v47.Get() -v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v50 := v49.FindInternedVar(lang.NewSymbol("list")) -if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) -} -v51 := v50.Get() -v52 := lang.Apply(v51, []any{lang.NewSymbol("do")}) -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("list")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) -} -v55 := v54.Get() -v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v57 := v56.FindInternedVar(lang.NewSymbol("seq")) -if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) -} -v58 := v57.Get() -v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v60 := v59.FindInternedVar(lang.NewSymbol("concat")) -if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) -} -v61 := v60.Get() -v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v63 := v62.FindInternedVar(lang.NewSymbol("list")) -if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) -} -v64 := v63.Get() -v65 := lang.Apply(v64, []any{lang.NewSymbol("glojure.core/defn")}) -v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v67 := v66.FindInternedVar(lang.NewSymbol("list")) -if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) -} -v68 := v67.Get() -v69 := lang.Apply(v68, []any{v5}) -v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v71 := v70.FindInternedVar(lang.NewSymbol("list")) -if v71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) -} -v72 := v71.Get() -v73 := lang.Apply(v72, []any{v32}) -v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v75 := v74.FindInternedVar(lang.NewSymbol("list")) -if v75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) -} -v76 := v75.Get() -v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v78 := v77.FindInternedVar(lang.NewSymbol("apply")) -if v78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) -} -v79 := v78.Get() -v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v81 := v80.FindInternedVar(lang.NewSymbol("eval")) -if v81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) -} -v82 := v81.Get() -v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v84 := v83.FindInternedVar(lang.NewSymbol("list")) -if v84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) -} -v85 := v84.Get() -v86 := lang.Apply(v85, []any{lang.NewSymbol("glojure.core/fn"), v32, v37}) -v87 := lang.Apply(v82, []any{v86}) -v88 := lang.Apply(v79, []any{v87, v32}) -v89 := lang.Apply(v76, []any{v88}) -v90 := lang.Apply(v61, []any{v65, v69, v22, v73, v89}) -v91 := lang.Apply(v58, []any{v90}) -v92 := lang.Apply(v55, []any{v91}) -v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v94 := v93.FindInternedVar(lang.NewSymbol("list")) -if v94.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) -} -v95 := v94.Get() -v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v97 := v96.FindInternedVar(lang.NewSymbol("seq")) -if v97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) -} -v98 := v97.Get() -v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v100 := v99.FindInternedVar(lang.NewSymbol("concat")) -if v100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) -} -v101 := v100.Get() -v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v103 := v102.FindInternedVar(lang.NewSymbol("list")) -if v103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) -} -v104 := v103.Get() -v105 := lang.Apply(v104, []any{lang.NewSymbol("glojure.core/alter-meta!")}) -v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v107 := v106.FindInternedVar(lang.NewSymbol("list")) -if v107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) -} -v108 := v107.Get() -v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v110 := v109.FindInternedVar(lang.NewSymbol("seq")) -if v110.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) -} -v111 := v110.Get() -v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v113 := v112.FindInternedVar(lang.NewSymbol("concat")) -if v113.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) -} -v114 := v113.Get() -v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v116 := v115.FindInternedVar(lang.NewSymbol("list")) -if v116.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) -} -v117 := v116.Get() -v118 := lang.Apply(v117, []any{lang.NewSymbol("var")}) -v119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v120 := v119.FindInternedVar(lang.NewSymbol("list")) -if v120.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v120))) -} -v121 := v120.Get() -v122 := lang.Apply(v121, []any{v5}) -v123 := lang.Apply(v114, []any{v118, v122}) -v124 := lang.Apply(v111, []any{v123}) -v125 := lang.Apply(v108, []any{v124}) -v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v127 := v126.FindInternedVar(lang.NewSymbol("list")) -if v127.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) -} -v128 := v127.Get() -v129 := lang.Apply(v128, []any{lang.NewSymbol("glojure.core/assoc")}) -v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v131 := v130.FindInternedVar(lang.NewSymbol("list")) -if v131.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) -} -v132 := v131.Get() -v133 := lang.Apply(v132, []any{lang.NewKeyword("inline")}) -v134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v135 := v134.FindInternedVar(lang.NewSymbol("list")) -if v135.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v135))) -} -v136 := v135.Get() -v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v138 := v137.FindInternedVar(lang.NewSymbol("seq")) -if v138.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) -} -v139 := v138.Get() -v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v141 := v140.FindInternedVar(lang.NewSymbol("concat")) -if v141.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) -} -v142 := v141.Get() -v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v144 := v143.FindInternedVar(lang.NewSymbol("list")) -if v144.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) -} -v145 := v144.Get() -v146 := lang.Apply(v145, []any{lang.NewSymbol("glojure.core/fn")}) -v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v148 := v147.FindInternedVar(lang.NewSymbol("list")) -if v148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) -} -v149 := v148.Get() -v150 := lang.Apply(v149, []any{v5}) -v151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v152 := v151.FindInternedVar(lang.NewSymbol("list")) -if v152.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v152))) -} -v153 := v152.Get() -v154 := lang.Apply(v153, []any{v32}) -v155 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v156 := v155.FindInternedVar(lang.NewSymbol("list")) -if v156.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v156))) -} -v157 := v156.Get() -v158 := lang.Apply(v157, []any{v37}) -v159 := lang.Apply(v142, []any{v146, v150, v154, v158}) -v160 := lang.Apply(v139, []any{v159}) -v161 := lang.Apply(v136, []any{v160}) -v162 := lang.Apply(v101, []any{v105, v125, v129, v133, v161}) -v163 := lang.Apply(v98, []any{v162}) -v164 := lang.Apply(v95, []any{v163}) -v165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v166 := v165.FindInternedVar(lang.NewSymbol("list")) -if v166.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v166))) -} -v167 := v166.Get() -v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v169 := v168.FindInternedVar(lang.NewSymbol("seq")) -if v169.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) -} -v170 := v169.Get() -v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v172 := v171.FindInternedVar(lang.NewSymbol("concat")) -if v172.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) -} -v173 := v172.Get() -v174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v175 := v174.FindInternedVar(lang.NewSymbol("list")) -if v175.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v175))) -} -v176 := v175.Get() -v177 := lang.Apply(v176, []any{lang.NewSymbol("var")}) -v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v179 := v178.FindInternedVar(lang.NewSymbol("list")) -if v179.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) -} -v180 := v179.Get() -v181 := lang.Apply(v180, []any{v5}) -v182 := lang.Apply(v173, []any{v177, v181}) -v183 := lang.Apply(v170, []any{v182}) -v184 := lang.Apply(v167, []any{v183}) -v185 := lang.Apply(v48, []any{v52, v92, v164, v184}) -v186 := lang.Apply(v45, []any{v185}) -return v186 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// defmacro -{ -v0 := lang.NewSymbol("defmacro").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("doc-string?"), lang.NewSymbol("attr-map?"), lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("body")), lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("doc-string?"), lang.NewSymbol("attr-map?"), lang.NewList(lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("body")), lang.NewSymbol("+"), lang.NewSymbol("attr-map?"))), lang.NewKeyword("doc"), "Like defn, but the resulting function name is declared as a\n macro and will be used as a macro by the compiler when it is\n called.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(445), lang.NewKeyword("end-line"), int(451))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("list")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v5}) -var v8 any = v12 -_ = v8 -var v13 any = v13 -_ = v13 -var v14 any -for { -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("first")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v13}) -var v15 any = v19 -_ = v15 -var v21 any -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("string?")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v15}) -if lang.IsTruthy(v25) { -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("cons")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{v15, v8}) -var v26 any = v30 -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("next")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v13}) -var v31 any = v35 -v8 = v26 -v13 = v31 -continue -} else { -var v36 any -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("map?")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v15}) -if lang.IsTruthy(v40) { -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("cons")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) -} -v44 := v43.Get() -v45 := lang.Apply(v44, []any{v15, v8}) -var v41 any = v45 -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("next")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) -} -v49 := v48.Get() -v50 := lang.Apply(v49, []any{v13}) -var v46 any = v50 -v8 = v41 -v13 = v46 -continue -} else { -v36 = v8 -} -v21 = v36 -} -v14 = v21 - break -} -var v7 any = v14 -_ = v7 -var v9 any = v6 -_ = v9 -var v10 any -for { -var v11 any -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("string?")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("first")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v9}) -v19 := lang.Apply(v14, []any{v18}) -if lang.IsTruthy(v19) { -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("next")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v9}) -var v20 any = v24 -v9 = v20 -continue -} else { -var v25 any -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("map?")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("first")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.Apply(v31, []any{v9}) -v33 := lang.Apply(v28, []any{v32}) -if lang.IsTruthy(v33) { -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("next")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v9}) -var v34 any = v38 -v9 = v34 -continue -} else { -v25 = v9 -} -v11 = v25 -} -v10 = v11 - break -} -var v8 any = v10 -_ = v8 -var v10 any -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("vector?")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("first")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v9}) -v18 := lang.Apply(v13, []any{v17}) -if lang.IsTruthy(v18) { -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v9}) -v10 = v22 -} else { -v10 = v9 -} -var v9 any = v10 -_ = v9 -var v24 lang.FnFunc -v24 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v25 := args[0] -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("first")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{v25}) -var v26 any = v30 -_ = v26 -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("cons")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("vec")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("cons")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("cons")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{lang.NewSymbol("&env"), v26}) -v45 := lang.Apply(v40, []any{lang.NewSymbol("&form"), v44}) -v46 := lang.Apply(v37, []any{v45}) -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("next")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) -} -v49 := v48.Get() -v50 := lang.Apply(v49, []any{v25}) -v51 := lang.Apply(v34, []any{v46, v50}) -return v51 -}) -v25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(469), lang.NewKeyword("column"), int(38), lang.NewKeyword("end-line"), int(471), lang.NewKeyword("end-column"), int(87)) -v26, err := lang.WithMeta(v24, v25.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v23 any = v26 -_ = v23 -var v28 lang.FnFunc -v28 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v29 := args[0] -v30 := args[1] -recur_loop_61: -var v31 any -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("nil?")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v30}) -if lang.IsTruthy(v35) { -v31 = v29 -} else { -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("first")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v30}) -var v36 any = v40 -_ = v36 -var v42 any -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("map?")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.Apply(v45, []any{v36}) -if lang.IsTruthy(v46) { -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("conj")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) -} -v49 := v48.Get() -v50 := lang.Apply(v49, []any{v29, v36}) -v42 = v50 -} else { -v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("conj")) -if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) -} -v54 := v53.Get() -v55 := lang.Apply(v23, []any{v36}) -v56 := lang.Apply(v54, []any{v29, v55}) -var v51 any = v56 -v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v59 := v58.FindInternedVar(lang.NewSymbol("next")) -if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) -} -v60 := v59.Get() -v61 := lang.Apply(v60, []any{v30}) -var v57 any = v61 -v29 = v51 -v30 = v57 -goto recur_loop_61 -} -v31 = v42 -} -return v31 -}) -v29 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(472), lang.NewKeyword("column"), int(29), lang.NewKeyword("end-line"), int(478), lang.NewKeyword("end-column"), int(90)) -v30, err := lang.WithMeta(v28, v29.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v27 any = v30 -_ = v27 -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("seq")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.NewVector() -v36 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(479), lang.NewKeyword("column"), int(41), lang.NewKeyword("end-line"), int(479), lang.NewKeyword("end-column"), int(42)) -v37, err := lang.WithMeta(v35, v36.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v38 := lang.Apply(v27, []any{v37, v31}) -v39 := lang.Apply(v34, []any{v38}) -var v31 any = v39 -_ = v31 -var v41 any = v7 -_ = v41 -var v42 any = v31 -_ = v42 -var v43 any -for { -var v44 any -if lang.IsTruthy(v41) { -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("next")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) -} -v48 := v47.Get() -v49 := lang.Apply(v48, []any{v41}) -var v45 any = v49 -v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v52 := v51.FindInternedVar(lang.NewSymbol("cons")) -if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) -} -v53 := v52.Get() -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("first")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) -} -v56 := v55.Get() -v57 := lang.Apply(v56, []any{v41}) -v58 := lang.Apply(v53, []any{v57, v42}) -var v50 any = v58 -v41 = v45 -v42 = v50 -continue -} else { -v44 = v42 -} -v43 = v44 - break -} -var v40 any = v43 -_ = v40 -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("list")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) -} -v44 := v43.Get() -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("cons")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.Apply(v47, []any{lang.NewSymbol("glojure.core/defn"), v40}) -v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v50 := v49.FindInternedVar(lang.NewSymbol("list")) -if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) -} -v51 := v50.Get() -v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("list")) -if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) -} -v54 := v53.Get() -v55 := lang.Apply(v54, []any{lang.NewSymbol("var"), v5}) -v56 := lang.Apply(v51, []any{lang.NewSymbol("."), v55, lang.NewList(lang.NewSymbol("SetMacro"))}) -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("list")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) -} -v59 := v58.Get() -v60 := lang.Apply(v59, []any{lang.NewSymbol("var"), v5}) -v61 := lang.Apply(v44, []any{lang.NewSymbol("do"), v48, v56, v60}) -return v61 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(451), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(487), lang.NewKeyword("end-column"), int(40))).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// defmethod -{ -v0 := lang.NewSymbol("defmethod").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"), lang.NewSymbol("dispatch-val"), lang.NewSymbol("&"), lang.NewSymbol("fn-tail"))), lang.NewKeyword("doc"), "Creates and installs a new method of multimethod associated with dispatch-value. ", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1781), lang.NewKeyword("end-line"), int(1781))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := lang.NewList(args[4:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("seq")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("concat")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol(".")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("with-meta")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.NewMap(lang.NewKeyword("tag"), lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.*MultiFn")) -v25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1785), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(1785), lang.NewKeyword("end-column"), int(82)) -v26, err := lang.WithMeta(v24, v25.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v27 := lang.Apply(v23, []any{v5, v26}) -v28 := lang.Apply(v20, []any{v27}) -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("list")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.Apply(v31, []any{lang.NewSymbol("glojure.core/AddMethod")}) -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("list")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v6}) -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("list")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("seq")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("concat")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("list")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) -} -v48 := v47.Get() -v49 := lang.Apply(v48, []any{lang.NewSymbol("glojure.core/fn")}) -v50 := lang.Apply(v45, []any{v49, v7}) -v51 := lang.Apply(v42, []any{v50}) -v52 := lang.Apply(v39, []any{v51}) -v53 := lang.Apply(v13, []any{v17, v28, v32, v36, v52}) -v54 := lang.Apply(v10, []any{v53}) -return v54 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// defmulti -{ -v0 := lang.NewSymbol("defmulti").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("docstring?"), lang.NewSymbol("attr-map?"), lang.NewSymbol("dispatch-fn"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Creates a new multimethod with the associated dispatch function.\n The docstring and attr-map are optional.\n\n Options are key-value pairs and may be one of:\n\n :default\n\n The default dispatch value, defaults to :default\n\n :hierarchy\n\n The value used for hierarchical dispatch (e.g. ::square is-a ::shape)\n\n Hierarchies are type-like relationships that do not depend upon type\n inheritance. By default Clojure's multimethods dispatch off of a\n global hierarchy map. However, a hierarchy relationship can be\n created with the derive function used to augment the root ancestor\n created with make-hierarchy.\n\n Multimethods expect the value of the hierarchy option to be supplied as\n a reference type e.g. a var (i.e. via the Var-quote dispatch macro #'\n or the var special form).", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1723), lang.NewKeyword("end-line"), int(1723))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -var v8 any -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("string?")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("first")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v6}) -v16 := lang.Apply(v11, []any{v15}) -if lang.IsTruthy(v16) { -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("first")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v6}) -v8 = v20 -} else { -v8 = nil -} -var v7 any = v8 -_ = v7 -var v22 any -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("string?")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("first")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.Apply(v28, []any{v21}) -v30 := lang.Apply(v25, []any{v29}) -if lang.IsTruthy(v30) { -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("next")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v21}) -v22 = v34 -} else { -v22 = v21 -} -var v21 any = v22 -_ = v21 -var v36 any -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("map?")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("first")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v21}) -v44 := lang.Apply(v39, []any{v43}) -if lang.IsTruthy(v44) { -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("first")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.Apply(v47, []any{v21}) -v36 = v48 -} else { -v49 := lang.NewMap() -v50 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1757), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(1757), lang.NewKeyword("end-column"), int(24)) -v51, err := lang.WithMeta(v49, v50.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v36 = v51 -} -var v35 any = v36 -_ = v35 -var v53 any -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("map?")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) -} -v56 := v55.Get() -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("first")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) -} -v59 := v58.Get() -v60 := lang.Apply(v59, []any{v52}) -v61 := lang.Apply(v56, []any{v60}) -if lang.IsTruthy(v61) { -v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v63 := v62.FindInternedVar(lang.NewSymbol("next")) -if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) -} -v64 := v63.Get() -v65 := lang.Apply(v64, []any{v52}) -v53 = v65 -} else { -v53 = v52 -} -var v52 any = v53 -_ = v52 -v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v68 := v67.FindInternedVar(lang.NewSymbol("first")) -if v68.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) -} -v69 := v68.Get() -v70 := lang.Apply(v69, []any{v52}) -var v66 any = v70 -_ = v66 -v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v73 := v72.FindInternedVar(lang.NewSymbol("next")) -if v73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) -} -v74 := v73.Get() -v75 := lang.Apply(v74, []any{v71}) -var v71 any = v75 -_ = v71 -var v77 any -if lang.IsTruthy(v7) { -v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v79 := v78.FindInternedVar(lang.NewSymbol("assoc")) -if v79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) -} -v80 := v79.Get() -v81 := lang.Apply(v80, []any{v76, lang.NewKeyword("doc"), v7}) -v77 = v81 -} else { -v77 = v76 -} -var v76 any = v77 -_ = v76 -var v83 any -v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v85 := v84.FindInternedVar(lang.NewSymbol("meta")) -if v85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) -} -v86 := v85.Get() -v87 := lang.Apply(v86, []any{v5}) -if lang.IsTruthy(v87) { -v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v89 := v88.FindInternedVar(lang.NewSymbol("conj")) -if v89.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) -} -v90 := v89.Get() -v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v92 := v91.FindInternedVar(lang.NewSymbol("meta")) -if v92.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) -} -v93 := v92.Get() -v94 := lang.Apply(v93, []any{v5}) -v95 := lang.Apply(v90, []any{v94, v82}) -v83 = v95 -} else { -v83 = v82 -} -var v82 any = v83 -_ = v82 -v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v98 := v97.FindInternedVar(lang.NewSymbol("with-meta")) -if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) -} -v99 := v98.Get() -v100 := lang.Apply(v99, []any{v96, v82}) -var v96 any = v100 -_ = v96 -var v102 any -v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v104 := v103.FindInternedVar(lang.NewSymbol("=")) -if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) -} -v105 := v104.Get() -v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v107 := v106.FindInternedVar(lang.NewSymbol("count")) -if v107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) -} -v108 := v107.Get() -v109 := lang.Apply(v108, []any{v71}) -v110 := lang.Apply(v105, []any{v109, int64(1)}) -if lang.IsTruthy(v110) { -v111 := lang.Apply(lang.NewError, []any{"The syntax for defmulti has changed. Example: (defmulti name dispatch-fn :default dispatch-value)"}) -panic(v111) -} else { -v102 = nil -} -_ = v102 -v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v114 := v113.FindInternedVar(lang.NewSymbol("apply")) -if v114.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) -} -v115 := v114.Get() -v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v117 := v116.FindInternedVar(lang.NewSymbol("hash-map")) -if v117.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) -} -v118 := v117.Get() -v119 := lang.Apply(v115, []any{v118, v112}) -var v112 any = v119 -_ = v112 -v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v122 := v121.FindInternedVar(lang.NewSymbol("get")) -if v122.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) -} -v123 := v122.Get() -v124 := lang.Apply(v123, []any{v112, lang.NewKeyword("default"), lang.NewKeyword("default")}) -var v120 any = v124 -_ = v120 -v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v127 := v126.FindInternedVar(lang.NewSymbol("get")) -if v127.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) -} -v128 := v127.Get() -v129 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("global-hierarchy")) -v130 := lang.Apply(v128, []any{v112, lang.NewKeyword("hierarchy"), v129}) -var v125 any = v130 -_ = v125 -v132 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v133 := v132.FindInternedVar(lang.NewSymbol("check-valid-options")) -if v133.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v133))) -} -v134 := v133.Get() -v135 := lang.Apply(v134, []any{v112, lang.NewKeyword("default"), lang.NewKeyword("hierarchy")}) -_ = v135 -v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v137 := v136.FindInternedVar(lang.NewSymbol("seq")) -if v137.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) -} -v138 := v137.Get() -v139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v140 := v139.FindInternedVar(lang.NewSymbol("concat")) -if v140.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v140))) -} -v141 := v140.Get() -v142 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v143 := v142.FindInternedVar(lang.NewSymbol("list")) -if v143.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v143))) -} -v144 := v143.Get() -v145 := lang.Apply(v144, []any{lang.NewSymbol("glojure.core/let")}) -v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v147 := v146.FindInternedVar(lang.NewSymbol("list")) -if v147.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) -} -v148 := v147.Get() -v149 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v150 := v149.FindInternedVar(lang.NewSymbol("apply")) -if v150.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v150))) -} -v151 := v150.Get() -v152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v153 := v152.FindInternedVar(lang.NewSymbol("vector")) -if v153.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v153))) -} -v154 := v153.Get() -v155 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v156 := v155.FindInternedVar(lang.NewSymbol("seq")) -if v156.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v156))) -} -v157 := v156.Get() -v158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v159 := v158.FindInternedVar(lang.NewSymbol("concat")) -if v159.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v159))) -} -v160 := v159.Get() -v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v162 := v161.FindInternedVar(lang.NewSymbol("list")) -if v162.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) -} -v163 := v162.Get() -v164 := lang.Apply(v163, []any{lang.NewSymbol("v__0__auto__")}) -v165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v166 := v165.FindInternedVar(lang.NewSymbol("list")) -if v166.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v166))) -} -v167 := v166.Get() -v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v169 := v168.FindInternedVar(lang.NewSymbol("seq")) -if v169.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) -} -v170 := v169.Get() -v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v172 := v171.FindInternedVar(lang.NewSymbol("concat")) -if v172.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) -} -v173 := v172.Get() -v174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v175 := v174.FindInternedVar(lang.NewSymbol("list")) -if v175.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v175))) -} -v176 := v175.Get() -v177 := lang.Apply(v176, []any{lang.NewSymbol("def")}) -v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v179 := v178.FindInternedVar(lang.NewSymbol("list")) -if v179.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) -} -v180 := v179.Get() -v181 := lang.Apply(v180, []any{v96}) -v182 := lang.Apply(v173, []any{v177, v181}) -v183 := lang.Apply(v170, []any{v182}) -v184 := lang.Apply(v167, []any{v183}) -v185 := lang.Apply(v160, []any{v164, v184}) -v186 := lang.Apply(v157, []any{v185}) -v187 := lang.Apply(v151, []any{v154, v186}) -v188 := lang.Apply(v148, []any{v187}) -v189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v190 := v189.FindInternedVar(lang.NewSymbol("list")) -if v190.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v190))) -} -v191 := v190.Get() -v192 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v193 := v192.FindInternedVar(lang.NewSymbol("seq")) -if v193.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v193))) -} -v194 := v193.Get() -v195 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v196 := v195.FindInternedVar(lang.NewSymbol("concat")) -if v196.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v196))) -} -v197 := v196.Get() -v198 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v199 := v198.FindInternedVar(lang.NewSymbol("list")) -if v199.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v199))) -} -v200 := v199.Get() -v201 := lang.Apply(v200, []any{lang.NewSymbol("glojure.core/when-not")}) -v202 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v203 := v202.FindInternedVar(lang.NewSymbol("list")) -if v203.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v203))) -} -v204 := v203.Get() -v205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v206 := v205.FindInternedVar(lang.NewSymbol("seq")) -if v206.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v206))) -} -v207 := v206.Get() -v208 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v209 := v208.FindInternedVar(lang.NewSymbol("concat")) -if v209.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v209))) -} -v210 := v209.Get() -v211 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v212 := v211.FindInternedVar(lang.NewSymbol("list")) -if v212.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v212))) -} -v213 := v212.Get() -v214 := lang.Apply(v213, []any{lang.NewSymbol("glojure.core/and")}) -v215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v216 := v215.FindInternedVar(lang.NewSymbol("list")) -if v216.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v216))) -} -v217 := v216.Get() -v218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v219 := v218.FindInternedVar(lang.NewSymbol("seq")) -if v219.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v219))) -} -v220 := v219.Get() -v221 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v222 := v221.FindInternedVar(lang.NewSymbol("concat")) -if v222.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v222))) -} -v223 := v222.Get() -v224 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v225 := v224.FindInternedVar(lang.NewSymbol("list")) -if v225.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v225))) -} -v226 := v225.Get() -v227 := lang.Apply(v226, []any{lang.NewSymbol(".HasRoot")}) -v228 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v229 := v228.FindInternedVar(lang.NewSymbol("list")) -if v229.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v229))) -} -v230 := v229.Get() -v231 := lang.Apply(v230, []any{lang.NewSymbol("v__0__auto__")}) -v232 := lang.Apply(v223, []any{v227, v231}) -v233 := lang.Apply(v220, []any{v232}) -v234 := lang.Apply(v217, []any{v233}) -v235 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v236 := v235.FindInternedVar(lang.NewSymbol("list")) -if v236.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v236))) -} -v237 := v236.Get() -v238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v239 := v238.FindInternedVar(lang.NewSymbol("seq")) -if v239.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v239))) -} -v240 := v239.Get() -v241 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v242 := v241.FindInternedVar(lang.NewSymbol("concat")) -if v242.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v242))) -} -v243 := v242.Get() -v244 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v245 := v244.FindInternedVar(lang.NewSymbol("list")) -if v245.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v245))) -} -v246 := v245.Get() -v247 := lang.Apply(v246, []any{lang.NewSymbol("glojure.core/instance?")}) -v248 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v249 := v248.FindInternedVar(lang.NewSymbol("list")) -if v249.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v249))) -} -v250 := v249.Get() -v251 := lang.Apply(v250, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.*MultiFn")}) -v252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v253 := v252.FindInternedVar(lang.NewSymbol("list")) -if v253.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v253))) -} -v254 := v253.Get() -v255 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v256 := v255.FindInternedVar(lang.NewSymbol("seq")) -if v256.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v256))) -} -v257 := v256.Get() -v258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v259 := v258.FindInternedVar(lang.NewSymbol("concat")) -if v259.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v259))) -} -v260 := v259.Get() -v261 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v262 := v261.FindInternedVar(lang.NewSymbol("list")) -if v262.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v262))) -} -v263 := v262.Get() -v264 := lang.Apply(v263, []any{lang.NewSymbol("glojure.core/deref")}) -v265 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v266 := v265.FindInternedVar(lang.NewSymbol("list")) -if v266.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v266))) -} -v267 := v266.Get() -v268 := lang.Apply(v267, []any{lang.NewSymbol("v__0__auto__")}) -v269 := lang.Apply(v260, []any{v264, v268}) -v270 := lang.Apply(v257, []any{v269}) -v271 := lang.Apply(v254, []any{v270}) -v272 := lang.Apply(v243, []any{v247, v251, v271}) -v273 := lang.Apply(v240, []any{v272}) -v274 := lang.Apply(v237, []any{v273}) -v275 := lang.Apply(v210, []any{v214, v234, v274}) -v276 := lang.Apply(v207, []any{v275}) -v277 := lang.Apply(v204, []any{v276}) -v278 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v279 := v278.FindInternedVar(lang.NewSymbol("list")) -if v279.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v279))) -} -v280 := v279.Get() -v281 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v282 := v281.FindInternedVar(lang.NewSymbol("seq")) -if v282.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v282))) -} -v283 := v282.Get() -v284 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v285 := v284.FindInternedVar(lang.NewSymbol("concat")) -if v285.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v285))) -} -v286 := v285.Get() -v287 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v288 := v287.FindInternedVar(lang.NewSymbol("list")) -if v288.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v288))) -} -v289 := v288.Get() -v290 := lang.Apply(v289, []any{lang.NewSymbol("def")}) -v291 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v292 := v291.FindInternedVar(lang.NewSymbol("list")) -if v292.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v292))) -} -v293 := v292.Get() -v294 := lang.Apply(v293, []any{v96}) -v295 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v296 := v295.FindInternedVar(lang.NewSymbol("list")) -if v296.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v296))) -} -v297 := v296.Get() -v298 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v299 := v298.FindInternedVar(lang.NewSymbol("seq")) -if v299.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v299))) -} -v300 := v299.Get() -v301 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v302 := v301.FindInternedVar(lang.NewSymbol("concat")) -if v302.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v302))) -} -v303 := v302.Get() -v304 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v305 := v304.FindInternedVar(lang.NewSymbol("list")) -if v305.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v305))) -} -v306 := v305.Get() -v307 := lang.Apply(v306, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewMultiFn")}) -v308 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v309 := v308.FindInternedVar(lang.NewSymbol("list")) -if v309.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v309))) -} -v310 := v309.Get() -v311 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v312 := v311.FindInternedVar(lang.NewSymbol("name")) -if v312.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v312))) -} -v313 := v312.Get() -v314 := lang.Apply(v313, []any{v96}) -v315 := lang.Apply(v310, []any{v314}) -v316 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v317 := v316.FindInternedVar(lang.NewSymbol("list")) -if v317.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v317))) -} -v318 := v317.Get() -v319 := lang.Apply(v318, []any{v66}) -v320 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v321 := v320.FindInternedVar(lang.NewSymbol("list")) -if v321.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v321))) -} -v322 := v321.Get() -v323 := lang.Apply(v322, []any{v120}) -v324 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v325 := v324.FindInternedVar(lang.NewSymbol("list")) -if v325.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v325))) -} -v326 := v325.Get() -v327 := lang.Apply(v326, []any{v125}) -v328 := lang.Apply(v303, []any{v307, v315, v319, v323, v327}) -v329 := lang.Apply(v300, []any{v328}) -v330 := lang.Apply(v297, []any{v329}) -v331 := lang.Apply(v286, []any{v290, v294, v330}) -v332 := lang.Apply(v283, []any{v331}) -v333 := lang.Apply(v280, []any{v332}) -v334 := lang.Apply(v197, []any{v201, v277, v333}) -v335 := lang.Apply(v194, []any{v334}) -v336 := lang.Apply(v191, []any{v335}) -v337 := lang.Apply(v141, []any{v145, v188, v336}) -v338 := lang.Apply(v138, []any{v337}) -return v338 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// defn -{ -v0 := lang.NewSymbol("defn").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("doc-string?"), lang.NewSymbol("attr-map?"), lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("prepost-map?"), lang.NewSymbol("body")), lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("doc-string?"), lang.NewSymbol("attr-map?"), lang.NewList(lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("prepost-map?"), lang.NewSymbol("body")), lang.NewSymbol("+"), lang.NewSymbol("attr-map?"))), lang.NewKeyword("doc"), "Same as (def name (fn [params* ] exprs*)) or (def\n name (fn ([params* ] exprs*)+)) with any doc-string or attrs added\n to the var metadata. prepost-map defines a map with optional keys\n :pre and :post that contain collections of pre or post conditions.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(284), lang.NewKeyword("end-line"), int(291))).(*lang.Symbol) -var v2 lang.FnFunc -{ // function defn -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6 := args[2] -v7 := lang.NewList(args[3:]...) -var v8 any -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("instance?")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v11, []any{lang.*Symbol, v6}) -if lang.IsTruthy(v12) { -v8 = nil -} else { -v13 := lang.Apply(lang.NewIllegalArgumentError, []any{"First argument to defn must be a symbol"}) -panic(v13) -} -_ = v8 -var v15 any -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("string?")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("first")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v7}) -v23 := lang.Apply(v18, []any{v22}) -if lang.IsTruthy(v23) { -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("first")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v7}) -v28 := lang.NewMap(lang.NewKeyword("doc"), v27) -v29 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(297), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(297), lang.NewKeyword("end-column"), int(38)) -v30, err := lang.WithMeta(v28, v29.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v15 = v30 -} else { -v31 := lang.NewMap() -v32 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(298), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(298), lang.NewKeyword("end-column"), int(20)) -v33, err := lang.WithMeta(v31, v32.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v15 = v33 -} -var v14 any = v15 -_ = v14 -var v35 any -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("string?")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("first")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) -} -v41 := v40.Get() -v42 := lang.Apply(v41, []any{v34}) -v43 := lang.Apply(v38, []any{v42}) -if lang.IsTruthy(v43) { -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("next")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v34}) -v35 = v47 -} else { -v35 = v34 -} -var v34 any = v35 -_ = v34 -var v49 any -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("map?")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("first")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) -} -v55 := v54.Get() -v56 := lang.Apply(v55, []any{v34}) -v57 := lang.Apply(v52, []any{v56}) -if lang.IsTruthy(v57) { -v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v59 := v58.FindInternedVar(lang.NewSymbol("conj")) -if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) -} -v60 := v59.Get() -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("first")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) -} -v63 := v62.Get() -v64 := lang.Apply(v63, []any{v34}) -v65 := lang.Apply(v60, []any{v48, v64}) -v49 = v65 -} else { -v49 = v48 -} -var v48 any = v49 -_ = v48 -var v67 any -v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v69 := v68.FindInternedVar(lang.NewSymbol("map?")) -if v69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) -} -v70 := v69.Get() -v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v72 := v71.FindInternedVar(lang.NewSymbol("first")) -if v72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) -} -v73 := v72.Get() -v74 := lang.Apply(v73, []any{v66}) -v75 := lang.Apply(v70, []any{v74}) -if lang.IsTruthy(v75) { -v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v77 := v76.FindInternedVar(lang.NewSymbol("next")) -if v77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) -} -v78 := v77.Get() -v79 := lang.Apply(v78, []any{v66}) -v67 = v79 -} else { -v67 = v66 -} -var v66 any = v67 -_ = v66 -var v81 any -v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v83 := v82.FindInternedVar(lang.NewSymbol("vector?")) -if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) -} -v84 := v83.Get() -v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v86 := v85.FindInternedVar(lang.NewSymbol("first")) -if v86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) -} -v87 := v86.Get() -v88 := lang.Apply(v87, []any{v80}) -v89 := lang.Apply(v84, []any{v88}) -if lang.IsTruthy(v89) { -v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v91 := v90.FindInternedVar(lang.NewSymbol("list")) -if v91.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) -} -v92 := v91.Get() -v93 := lang.Apply(v92, []any{v80}) -v81 = v93 -} else { -v81 = v80 -} -var v80 any = v81 -_ = v80 -var v95 any -v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v97 := v96.FindInternedVar(lang.NewSymbol("map?")) -if v97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) -} -v98 := v97.Get() -v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v100 := v99.FindInternedVar(lang.NewSymbol("last")) -if v100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) -} -v101 := v100.Get() -v102 := lang.Apply(v101, []any{v80}) -v103 := lang.Apply(v98, []any{v102}) -if lang.IsTruthy(v103) { -v104 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v105 := v104.FindInternedVar(lang.NewSymbol("conj")) -if v105.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v105))) -} -v106 := v105.Get() -v107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v108 := v107.FindInternedVar(lang.NewSymbol("last")) -if v108.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v108))) -} -v109 := v108.Get() -v110 := lang.Apply(v109, []any{v80}) -v111 := lang.Apply(v106, []any{v94, v110}) -v95 = v111 -} else { -v95 = v94 -} -var v94 any = v95 -_ = v94 -var v113 any -v114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v115 := v114.FindInternedVar(lang.NewSymbol("map?")) -if v115.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v115))) -} -v116 := v115.Get() -v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v118 := v117.FindInternedVar(lang.NewSymbol("last")) -if v118.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) -} -v119 := v118.Get() -v120 := lang.Apply(v119, []any{v112}) -v121 := lang.Apply(v116, []any{v120}) -if lang.IsTruthy(v121) { -v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v123 := v122.FindInternedVar(lang.NewSymbol("butlast")) -if v123.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) -} -v124 := v123.Get() -v125 := lang.Apply(v124, []any{v112}) -v113 = v125 -} else { -v113 = v112 -} -var v112 any = v113 -_ = v112 -v127 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v128 := v127.FindInternedVar(lang.NewSymbol("conj")) -if v128.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v128))) -} -v129 := v128.Get() -v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v131 := v130.FindInternedVar(lang.NewSymbol("list")) -if v131.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) -} -v132 := v131.Get() -v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v134 := v133.FindInternedVar(lang.NewSymbol("sigs")) -if v134.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) -} -v135 := v134.Get() -v136 := lang.Apply(v135, []any{v112}) -v137 := lang.Apply(v132, []any{lang.NewSymbol("quote"), v136}) -v138 := lang.NewMap(lang.NewKeyword("arglists"), v137) -v139 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(317), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(317), lang.NewKeyword("end-column"), int(60)) -v140, err := lang.WithMeta(v138, v139.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v141 := lang.Apply(v129, []any{v140, v126}) -var v126 any = v141 -_ = v126 -v144 := lang.Apply(lang.NewKeyword("inline"), []any{v142}) -var v143 any = v144 -_ = v143 -v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v147 := v146.FindInternedVar(lang.NewSymbol("first")) -if v147.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) -} -v148 := v147.Get() -v149 := lang.Apply(v148, []any{v143}) -var v145 any = v149 -_ = v145 -v151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v152 := v151.FindInternedVar(lang.NewSymbol("second")) -if v152.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v152))) -} -v153 := v152.Get() -v154 := lang.Apply(v153, []any{v143}) -var v150 any = v154 -_ = v150 -var v156 any -var v157 any -v158 := lang.Apply(lang.Equiv, []any{lang.NewSymbol("fn"), v145}) -if lang.IsTruthy(v158) { -var v159 any -v160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v161 := v160.FindInternedVar(lang.NewSymbol("instance?")) -if v161.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v161))) -} -v162 := v161.Get() -v163 := lang.Apply(v162, []any{lang.*Symbol, v150}) -if lang.IsTruthy(v163) { -v159 = false -} else { -v159 = true -} -v157 = v159 -} else { -v157 = nil -} -if lang.IsTruthy(v157) { -v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v165 := v164.FindInternedVar(lang.NewSymbol("assoc")) -if v165.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) -} -v166 := v165.Get() -v167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v168 := v167.FindInternedVar(lang.NewSymbol("cons")) -if v168.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v168))) -} -v169 := v168.Get() -v170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v171 := v170.FindInternedVar(lang.NewSymbol("cons")) -if v171.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v171))) -} -v172 := v171.Get() -v173, ok := lang.FieldOrMethod(v6, "Name") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "Name"))) -} -var v174 any -switch reflect.TypeOf(v173).Kind() { -case reflect.Func: - v174 = lang.Apply(v173, nil) -default: - v174 = v173 -} -v175 := lang.Apply(lang.ConcatStrings, []any{v174, "__inliner"}) -v176 := lang.Apply(lang.NewSymbol, []any{v175}) -v177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v178 := v177.FindInternedVar(lang.NewSymbol("next")) -if v178.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v178))) -} -v179 := v178.Get() -v180 := lang.Apply(v179, []any{v143}) -v181 := lang.Apply(v172, []any{v176, v180}) -v182 := lang.Apply(v169, []any{v145, v181}) -v183 := lang.Apply(v166, []any{v142, lang.NewKeyword("inline"), v182}) -v156 = v183 -} else { -v156 = v142 -} -var v142 any = v156 -_ = v142 -v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v145 := v144.FindInternedVar(lang.NewSymbol("conj")) -if v145.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) -} -v146 := v145.Get() -var v147 any -v148 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v149 := v148.FindInternedVar(lang.NewSymbol("meta")) -if v149.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v149))) -} -v150 := v149.Get() -v151 := lang.Apply(v150, []any{v6}) -if lang.IsTruthy(v151) { -v152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v153 := v152.FindInternedVar(lang.NewSymbol("meta")) -if v153.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v153))) -} -v154 := v153.Get() -v155 := lang.Apply(v154, []any{v6}) -v147 = v155 -} else { -v156 := lang.NewMap() -v157 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(328), lang.NewKeyword("column"), int(51), lang.NewKeyword("end-line"), int(328), lang.NewKeyword("end-column"), int(52)) -v158, err := lang.WithMeta(v156, v157.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v147 = v158 -} -v159 := lang.Apply(v146, []any{v147, v143}) -var v143 any = v159 -_ = v143 -v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v162 := v161.FindInternedVar(lang.NewSymbol("list")) -if v162.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) -} -v163 := v162.Get() -v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v165 := v164.FindInternedVar(lang.NewSymbol("with-meta")) -if v165.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) -} -v166 := v165.Get() -v167 := lang.Apply(v166, []any{v6, v143}) -v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v169 := v168.FindInternedVar(lang.NewSymbol("with-meta")) -if v169.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) -} -v170 := v169.Get() -v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v172 := v171.FindInternedVar(lang.NewSymbol("cons")) -if v172.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) -} -v173 := v172.Get() -v174 := lang.Apply(v173, []any{lang.NewSymbol("glojure.core/fn"), v112}) -v175 := lang.Apply(lang.NewKeyword("tag"), []any{v143}) -v176 := lang.NewMap(lang.NewKeyword("rettag"), v175) -v177 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(333), lang.NewKeyword("column"), int(37), lang.NewKeyword("end-line"), int(333), lang.NewKeyword("end-column"), int(54)) -v178, err := lang.WithMeta(v176, v177.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v179 := lang.Apply(v170, []any{v174, v178}) -v180 := lang.Apply(v163, []any{lang.NewSymbol("def"), v167, v179}) -return v180 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(291), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(333), lang.NewKeyword("end-column"), int(58))).(lang.FnFunc) -v3 := v2 -_ = v3 -} -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// defn- -{ -v0 := lang.NewSymbol("defn-").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("decls"))), lang.NewKeyword("doc"), "same as defn, yielding non-public def", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4949), lang.NewKeyword("end-line"), int(4949))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("list*")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("with-meta")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("assoc")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("meta")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v5}) -v20 := lang.Apply(v15, []any{v19, lang.NewKeyword("private"), true}) -v21 := lang.Apply(v12, []any{v5, v20}) -v22 := lang.Apply(v9, []any{lang.NewSymbol("glojure.core/defn"), v21, v6}) -return v22 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// defonce -{ -v0 := lang.NewSymbol("defonce").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("expr"))), lang.NewKeyword("doc"), "defs name to have the root value of the expr iff the named var has no root value,\n else expr is unevaluated", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5806), lang.NewKeyword("end-line"), int(5806))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("seq")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("concat")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("list")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/let")}) -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("list")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("apply")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("vector")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("seq")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("concat")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{lang.NewSymbol("v__0__auto__")}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("seq")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) -} -v41 := v40.Get() -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("concat")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) -} -v44 := v43.Get() -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("list")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.Apply(v47, []any{lang.NewSymbol("def")}) -v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v50 := v49.FindInternedVar(lang.NewSymbol("list")) -if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) -} -v51 := v50.Get() -v52 := lang.Apply(v51, []any{v5}) -v53 := lang.Apply(v44, []any{v48, v52}) -v54 := lang.Apply(v41, []any{v53}) -v55 := lang.Apply(v38, []any{v54}) -v56 := lang.Apply(v31, []any{v35, v55}) -v57 := lang.Apply(v28, []any{v56}) -v58 := lang.Apply(v22, []any{v25, v57}) -v59 := lang.Apply(v19, []any{v58}) -v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v61 := v60.FindInternedVar(lang.NewSymbol("list")) -if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) -} -v62 := v61.Get() -v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v64 := v63.FindInternedVar(lang.NewSymbol("seq")) -if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) -} -v65 := v64.Get() -v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v67 := v66.FindInternedVar(lang.NewSymbol("concat")) -if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) -} -v68 := v67.Get() -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("list")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) -} -v71 := v70.Get() -v72 := lang.Apply(v71, []any{lang.NewSymbol("glojure.core/when-not")}) -v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v74 := v73.FindInternedVar(lang.NewSymbol("list")) -if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) -} -v75 := v74.Get() -v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v77 := v76.FindInternedVar(lang.NewSymbol("seq")) -if v77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) -} -v78 := v77.Get() -v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v80 := v79.FindInternedVar(lang.NewSymbol("concat")) -if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) -} -v81 := v80.Get() -v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v83 := v82.FindInternedVar(lang.NewSymbol("list")) -if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) -} -v84 := v83.Get() -v85 := lang.Apply(v84, []any{lang.NewSymbol(".HasRoot")}) -v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v87 := v86.FindInternedVar(lang.NewSymbol("list")) -if v87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) -} -v88 := v87.Get() -v89 := lang.Apply(v88, []any{lang.NewSymbol("v__0__auto__")}) -v90 := lang.Apply(v81, []any{v85, v89}) -v91 := lang.Apply(v78, []any{v90}) -v92 := lang.Apply(v75, []any{v91}) -v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v94 := v93.FindInternedVar(lang.NewSymbol("list")) -if v94.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) -} -v95 := v94.Get() -v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v97 := v96.FindInternedVar(lang.NewSymbol("seq")) -if v97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) -} -v98 := v97.Get() -v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v100 := v99.FindInternedVar(lang.NewSymbol("concat")) -if v100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) -} -v101 := v100.Get() -v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v103 := v102.FindInternedVar(lang.NewSymbol("list")) -if v103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) -} -v104 := v103.Get() -v105 := lang.Apply(v104, []any{lang.NewSymbol("def")}) -v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v107 := v106.FindInternedVar(lang.NewSymbol("list")) -if v107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) -} -v108 := v107.Get() -v109 := lang.Apply(v108, []any{v5}) -v110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v111 := v110.FindInternedVar(lang.NewSymbol("list")) -if v111.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v111))) -} -v112 := v111.Get() -v113 := lang.Apply(v112, []any{v6}) -v114 := lang.Apply(v101, []any{v105, v109, v113}) -v115 := lang.Apply(v98, []any{v114}) -v116 := lang.Apply(v95, []any{v115}) -v117 := lang.Apply(v68, []any{v72, v92, v116}) -v118 := lang.Apply(v65, []any{v117}) -v119 := lang.Apply(v62, []any{v118}) -v120 := lang.Apply(v12, []any{v16, v59, v119}) -v121 := lang.Apply(v9, []any{v120}) -return v121 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// defprotocol -{ -v0 := lang.NewSymbol("defprotocol").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("opts+sigs"))), lang.NewKeyword("doc"), "A protocol is a named set of named methods and their signatures:\n (defprotocol AProtocolName\n\n ;optional doc string\n \"A doc string for AProtocol abstraction\"\n\n ;options\n :extend-via-metadata true\n\n ;method signatures\n (bar [this a b] \"bar docs\")\n (baz [this a] [this a b] [this a b c] \"baz docs\"))\n\n No implementations are provided. Docs can be specified for the\n protocol overall and for each method. The above yields a set of\n polymorphic functions and a protocol object. All are\n namespace-qualified by the ns enclosing the definition The resulting\n functions dispatch on the type of their first argument, which is\n required and corresponds to the implicit target object ('this' in \n Java parlance). defprotocol is dynamic, has no special compile-time \n effect, and defines no new types or classes. Implementations of \n the protocol methods can be provided using extend.\n\n When :extend-via-metadata is true, values can extend protocols by\n adding metadata where keys are fully-qualified protocol function\n symbols and values are function implementations. Protocol\n implementations are checked first for direct definitions (defrecord,\n deftype, reify), then metadata definitions, then external\n extensions (extend, extend-type, extend-protocol)\n\n defprotocol will automatically generate a corresponding interface,\n with the same name as the protocol, i.e. given a protocol:\n my.ns/Protocol, an interface: my.ns.Protocol. The interface will\n have methods corresponding to the protocol functions, and the\n protocol will automatically work with instances of the interface.\n\n Note that you should not use this interface with deftype or\n reify, as they support the protocol directly:\n\n (defprotocol P \n (foo [this]) \n (bar-me [this] [this y]))\n\n (deftype Foo [a b c] \n P\n (foo [this] a)\n (bar-me [this] b)\n (bar-me [this y] (+ c y)))\n \n (bar-me (Foo. 1 2 3) 42)\n => 45\n\n (foo \n (let [x 42]\n (reify P \n (foo [this] 17)\n (bar-me [this] x)\n (bar-me [this y] x))))\n => 17", lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(28), lang.NewKeyword("end-line"), int(28))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -var v8 any -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("string?")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("first")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v6}) -v16 := lang.Apply(v11, []any{v15}) -if lang.IsTruthy(v16) { -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("first")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v6}) -v8 = v20 -} else { -v8 = nil -} -var v7 any = v8 -_ = v7 -var v22 any -if lang.IsTruthy(v7) { -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("rest")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{v21}) -v22 = v26 -} else { -v22 = v21 -} -var v21 any = v22 -_ = v21 -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("take-while")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -var v31 lang.FnFunc -v31 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v32 := args[0] -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("not")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("seq?")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v32}) -v40 := lang.Apply(v35, []any{v39}) -return v40 -}) -v32 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(92), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(92), lang.NewKeyword("end-column"), int(40)) -v33, err := lang.WithMeta(v31, v32.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v34 := lang.Apply(v30, []any{v33, v21}) -var v27 any = v34 -_ = v27 -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("drop-while")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -var v39 lang.FnFunc -v39 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v40 := args[0] -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("not")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("seq?")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v40}) -v48 := lang.Apply(v43, []any{v47}) -return v48 -}) -v40 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(93), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(93), lang.NewKeyword("end-column"), int(40)) -v41, err := lang.WithMeta(v39, v40.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v42 := lang.Apply(v38, []any{v41, v21}) -var v35 any = v42 -_ = v35 -var v44 any -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("=")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.Apply(v47, []any{v35, v43}) -if lang.IsTruthy(v48) { -v44 = nil -} else { -v44 = v43 -} -var v43 any = v44 -_ = v43 -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("seq")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("concat")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) -} -v55 := v54.Get() -v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v57 := v56.FindInternedVar(lang.NewSymbol("list")) -if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) -} -v58 := v57.Get() -v59 := lang.Apply(v58, []any{lang.NewSymbol("do")}) -v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v61 := v60.FindInternedVar(lang.NewSymbol("list")) -if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) -} -v62 := v61.Get() -v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v64 := v63.FindInternedVar(lang.NewSymbol("seq")) -if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) -} -v65 := v64.Get() -v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v67 := v66.FindInternedVar(lang.NewSymbol("concat")) -if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) -} -v68 := v67.Get() -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("list")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) -} -v71 := v70.Get() -v72 := lang.Apply(v71, []any{lang.NewSymbol("def")}) -v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v74 := v73.FindInternedVar(lang.NewSymbol("list")) -if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) -} -v75 := v74.Get() -v76 := lang.Apply(v75, []any{v5}) -v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v78 := v77.FindInternedVar(lang.NewSymbol("list")) -if v78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) -} -v79 := v78.Get() -v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v81 := v80.FindInternedVar(lang.NewSymbol("seq")) -if v81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) -} -v82 := v81.Get() -v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v84 := v83.FindInternedVar(lang.NewSymbol("concat")) -if v84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) -} -v85 := v84.Get() -v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v87 := v86.FindInternedVar(lang.NewSymbol("list")) -if v87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) -} -v88 := v87.Get() -v89 := lang.Apply(v88, []any{lang.NewSymbol("glojure.core/atom")}) -v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v91 := v90.FindInternedVar(lang.NewSymbol("list")) -if v91.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) -} -v92 := v91.Get() -v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v94 := v93.FindInternedVar(lang.NewSymbol("apply")) -if v94.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) -} -v95 := v94.Get() -v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v97 := v96.FindInternedVar(lang.NewSymbol("hash-map")) -if v97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) -} -v98 := v97.Get() -v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v100 := v99.FindInternedVar(lang.NewSymbol("seq")) -if v100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) -} -v101 := v100.Get() -v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v103 := v102.FindInternedVar(lang.NewSymbol("concat")) -if v103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) -} -v104 := v103.Get() -v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v106 := v105.FindInternedVar(lang.NewSymbol("list")) -if v106.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) -} -v107 := v106.Get() -v108 := lang.Apply(v107, []any{lang.NewKeyword("on-interface")}) -v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v110 := v109.FindInternedVar(lang.NewSymbol("list")) -if v110.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) -} -v111 := v110.Get() -v112 := lang.Apply(v111, []any{true}) -v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v114 := v113.FindInternedVar(lang.NewSymbol("list")) -if v114.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) -} -v115 := v114.Get() -v116 := lang.Apply(v115, []any{lang.NewKeyword("sigs")}) -v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v118 := v117.FindInternedVar(lang.NewSymbol("list")) -if v118.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) -} -v119 := v118.Get() -v120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v121 := v120.FindInternedVar(lang.NewSymbol("seq")) -if v121.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v121))) -} -v122 := v121.Get() -v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v124 := v123.FindInternedVar(lang.NewSymbol("concat")) -if v124.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) -} -v125 := v124.Get() -v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v127 := v126.FindInternedVar(lang.NewSymbol("list")) -if v127.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) -} -v128 := v127.Get() -v129 := lang.Apply(v128, []any{lang.NewSymbol("quote")}) -v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v131 := v130.FindInternedVar(lang.NewSymbol("list")) -if v131.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) -} -v132 := v131.Get() -v133 := lang.Apply(v132, []any{v35}) -v134 := lang.Apply(v125, []any{v129, v133}) -v135 := lang.Apply(v122, []any{v134}) -v136 := lang.Apply(v119, []any{v135}) -v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v138 := v137.FindInternedVar(lang.NewSymbol("list")) -if v138.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) -} -v139 := v138.Get() -v140 := lang.Apply(v139, []any{lang.NewKeyword("multis")}) -v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v142 := v141.FindInternedVar(lang.NewSymbol("list")) -if v142.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) -} -v143 := v142.Get() -v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v145 := v144.FindInternedVar(lang.NewSymbol("apply")) -if v145.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) -} -v146 := v145.Get() -v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v148 := v147.FindInternedVar(lang.NewSymbol("hash-map")) -if v148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) -} -v149 := v148.Get() -v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v151 := v150.FindInternedVar(lang.NewSymbol("seq")) -if v151.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) -} -v152 := v151.Get() -v153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v154 := v153.FindInternedVar(lang.NewSymbol("concat")) -if v154.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v154))) -} -v155 := v154.Get() -v156 := lang.Apply(v155, nil) -v157 := lang.Apply(v152, []any{v156}) -v158 := lang.Apply(v146, []any{v149, v157}) -v159 := lang.Apply(v143, []any{v158}) -v160 := lang.Apply(v104, []any{v108, v112, v116, v136, v140, v159}) -v161 := lang.Apply(v101, []any{v160}) -v162 := lang.Apply(v95, []any{v98, v161}) -v163 := lang.Apply(v92, []any{v162}) -v164 := lang.Apply(v85, []any{v89, v163}) -v165 := lang.Apply(v82, []any{v164}) -v166 := lang.Apply(v79, []any{v165}) -v167 := lang.Apply(v68, []any{v72, v76, v166}) -v168 := lang.Apply(v65, []any{v167}) -v169 := lang.Apply(v62, []any{v168}) -v170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v171 := v170.FindInternedVar(lang.NewSymbol("list")) -if v171.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v171))) -} -v172 := v171.Get() -v173 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v174 := v173.FindInternedVar(lang.NewSymbol("seq")) -if v174.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v174))) -} -v175 := v174.Get() -v176 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v177 := v176.FindInternedVar(lang.NewSymbol("concat")) -if v177.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v177))) -} -v178 := v177.Get() -v179 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v180 := v179.FindInternedVar(lang.NewSymbol("list")) -if v180.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v180))) -} -v181 := v180.Get() -v182 := lang.Apply(v181, []any{lang.NewSymbol("glojure.core/swap!")}) -v183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v184 := v183.FindInternedVar(lang.NewSymbol("list")) -if v184.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v184))) -} -v185 := v184.Get() -v186 := lang.Apply(v185, []any{lang.NewSymbol("glojure.core/-protocols")}) -v187 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v188 := v187.FindInternedVar(lang.NewSymbol("list")) -if v188.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v188))) -} -v189 := v188.Get() -v190 := lang.Apply(v189, []any{lang.NewSymbol("glojure.core/assoc")}) -v191 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v192 := v191.FindInternedVar(lang.NewSymbol("list")) -if v192.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v192))) -} -v193 := v192.Get() -v194 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v195 := v194.FindInternedVar(lang.NewSymbol("seq")) -if v195.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v195))) -} -v196 := v195.Get() -v197 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v198 := v197.FindInternedVar(lang.NewSymbol("concat")) -if v198.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v198))) -} -v199 := v198.Get() -v200 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v201 := v200.FindInternedVar(lang.NewSymbol("list")) -if v201.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v201))) -} -v202 := v201.Get() -v203 := lang.Apply(v202, []any{lang.NewSymbol("quote")}) -v204 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v205 := v204.FindInternedVar(lang.NewSymbol("list")) -if v205.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v205))) -} -v206 := v205.Get() -v207 := lang.Apply(v206, []any{v5}) -v208 := lang.Apply(v199, []any{v203, v207}) -v209 := lang.Apply(v196, []any{v208}) -v210 := lang.Apply(v193, []any{v209}) -v211 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v212 := v211.FindInternedVar(lang.NewSymbol("list")) -if v212.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v212))) -} -v213 := v212.Get() -v214 := lang.Apply(v213, []any{v5}) -v215 := lang.Apply(v178, []any{v182, v186, v190, v210, v214}) -v216 := lang.Apply(v175, []any{v215}) -v217 := lang.Apply(v172, []any{v216}) -v218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v219 := v218.FindInternedVar(lang.NewSymbol("map")) -if v219.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v219))) -} -v220 := v219.Get() -var v221 lang.FnFunc -v221 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v222 := args[0] -v223 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v224 := v223.FindInternedVar(lang.NewSymbol("seq")) -if v224.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v224))) -} -v225 := v224.Get() -v226 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v227 := v226.FindInternedVar(lang.NewSymbol("concat")) -if v227.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v227))) -} -v228 := v227.Get() -v229 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v230 := v229.FindInternedVar(lang.NewSymbol("list")) -if v230.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v230))) -} -v231 := v230.Get() -v232 := lang.Apply(v231, []any{lang.NewSymbol("do")}) -v233 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v234 := v233.FindInternedVar(lang.NewSymbol("list")) -if v234.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v234))) -} -v235 := v234.Get() -v236 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v237 := v236.FindInternedVar(lang.NewSymbol("seq")) -if v237.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v237))) -} -v238 := v237.Get() -v239 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v240 := v239.FindInternedVar(lang.NewSymbol("concat")) -if v240.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v240))) -} -v241 := v240.Get() -v242 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v243 := v242.FindInternedVar(lang.NewSymbol("list")) -if v243.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v243))) -} -v244 := v243.Get() -v245 := lang.Apply(v244, []any{lang.NewSymbol("glojure.core/defmulti")}) -v246 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v247 := v246.FindInternedVar(lang.NewSymbol("list")) -if v247.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v247))) -} -v248 := v247.Get() -v249 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v250 := v249.FindInternedVar(lang.NewSymbol("first")) -if v250.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v250))) -} -v251 := v250.Get() -v252 := lang.Apply(v251, []any{v222}) -v253 := lang.Apply(v248, []any{v252}) -v254 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v255 := v254.FindInternedVar(lang.NewSymbol("list")) -if v255.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v255))) -} -v256 := v255.Get() -v257 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v258 := v257.FindInternedVar(lang.NewSymbol("seq")) -if v258.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v258))) -} -v259 := v258.Get() -v260 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v261 := v260.FindInternedVar(lang.NewSymbol("concat")) -if v261.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v261))) -} -v262 := v261.Get() -v263 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v264 := v263.FindInternedVar(lang.NewSymbol("list")) -if v264.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v264))) -} -v265 := v264.Get() -v266 := lang.Apply(v265, []any{lang.NewSymbol("glojure.core/fn")}) -v267 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v268 := v267.FindInternedVar(lang.NewSymbol("list")) -if v268.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v268))) -} -v269 := v268.Get() -v270 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v271 := v270.FindInternedVar(lang.NewSymbol("apply")) -if v271.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v271))) -} -v272 := v271.Get() -v273 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v274 := v273.FindInternedVar(lang.NewSymbol("vector")) -if v274.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v274))) -} -v275 := v274.Get() -v276 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v277 := v276.FindInternedVar(lang.NewSymbol("seq")) -if v277.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v277))) -} -v278 := v277.Get() -v279 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v280 := v279.FindInternedVar(lang.NewSymbol("concat")) -if v280.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v280))) -} -v281 := v280.Get() -v282 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v283 := v282.FindInternedVar(lang.NewSymbol("list")) -if v283.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v283))) -} -v284 := v283.Get() -v285 := lang.Apply(v284, []any{lang.NewSymbol("this")}) -v286 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v287 := v286.FindInternedVar(lang.NewSymbol("list")) -if v287.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v287))) -} -v288 := v287.Get() -v289 := lang.Apply(v288, []any{lang.NewSymbol("&")}) -v290 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v291 := v290.FindInternedVar(lang.NewSymbol("list")) -if v291.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v291))) -} -v292 := v291.Get() -v293 := lang.Apply(v292, []any{lang.NewSymbol("args")}) -v294 := lang.Apply(v281, []any{v285, v289, v293}) -v295 := lang.Apply(v278, []any{v294}) -v296 := lang.Apply(v272, []any{v275, v295}) -v297 := lang.Apply(v269, []any{v296}) -v298 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v299 := v298.FindInternedVar(lang.NewSymbol("list")) -if v299.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v299))) -} -v300 := v299.Get() -v301 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v302 := v301.FindInternedVar(lang.NewSymbol("seq")) -if v302.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v302))) -} -v303 := v302.Get() -v304 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v305 := v304.FindInternedVar(lang.NewSymbol("concat")) -if v305.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v305))) -} -v306 := v305.Get() -v307 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v308 := v307.FindInternedVar(lang.NewSymbol("list")) -if v308.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v308))) -} -v309 := v308.Get() -v310 := lang.Apply(v309, []any{lang.NewSymbol("glojure.core/class")}) -v311 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v312 := v311.FindInternedVar(lang.NewSymbol("list")) -if v312.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v312))) -} -v313 := v312.Get() -v314 := lang.Apply(v313, []any{lang.NewSymbol("this")}) -v315 := lang.Apply(v306, []any{v310, v314}) -v316 := lang.Apply(v303, []any{v315}) -v317 := lang.Apply(v300, []any{v316}) -v318 := lang.Apply(v262, []any{v266, v297, v317}) -v319 := lang.Apply(v259, []any{v318}) -v320 := lang.Apply(v256, []any{v319}) -v321 := lang.Apply(v241, []any{v245, v253, v320}) -v322 := lang.Apply(v238, []any{v321}) -v323 := lang.Apply(v235, []any{v322}) -v324 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v325 := v324.FindInternedVar(lang.NewSymbol("list")) -if v325.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v325))) -} -v326 := v325.Get() -v327 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v328 := v327.FindInternedVar(lang.NewSymbol("seq")) -if v328.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v328))) -} -v329 := v328.Get() -v330 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v331 := v330.FindInternedVar(lang.NewSymbol("concat")) -if v331.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v331))) -} -v332 := v331.Get() -v333 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v334 := v333.FindInternedVar(lang.NewSymbol("list")) -if v334.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v334))) -} -v335 := v334.Get() -v336 := lang.Apply(v335, []any{lang.NewSymbol("glojure.core/swap!")}) -v337 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v338 := v337.FindInternedVar(lang.NewSymbol("list")) -if v338.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v338))) -} -v339 := v338.Get() -v340 := lang.Apply(v339, []any{v5}) -v341 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v342 := v341.FindInternedVar(lang.NewSymbol("list")) -if v342.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v342))) -} -v343 := v342.Get() -v344 := lang.Apply(v343, []any{lang.NewSymbol("glojure.core/assoc-in")}) -v345 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v346 := v345.FindInternedVar(lang.NewSymbol("list")) -if v346.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v346))) -} -v347 := v346.Get() -v348 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v349 := v348.FindInternedVar(lang.NewSymbol("apply")) -if v349.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v349))) -} -v350 := v349.Get() -v351 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v352 := v351.FindInternedVar(lang.NewSymbol("vector")) -if v352.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v352))) -} -v353 := v352.Get() -v354 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v355 := v354.FindInternedVar(lang.NewSymbol("seq")) -if v355.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v355))) -} -v356 := v355.Get() -v357 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v358 := v357.FindInternedVar(lang.NewSymbol("concat")) -if v358.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v358))) -} -v359 := v358.Get() -v360 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v361 := v360.FindInternedVar(lang.NewSymbol("list")) -if v361.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v361))) -} -v362 := v361.Get() -v363 := lang.Apply(v362, []any{lang.NewKeyword("multis")}) -v364 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v365 := v364.FindInternedVar(lang.NewSymbol("list")) -if v365.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v365))) -} -v366 := v365.Get() -v367 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v368 := v367.FindInternedVar(lang.NewSymbol("seq")) -if v368.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v368))) -} -v369 := v368.Get() -v370 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v371 := v370.FindInternedVar(lang.NewSymbol("concat")) -if v371.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v371))) -} -v372 := v371.Get() -v373 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v374 := v373.FindInternedVar(lang.NewSymbol("list")) -if v374.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v374))) -} -v375 := v374.Get() -v376 := lang.Apply(v375, []any{lang.NewSymbol("glojure.core/keyword")}) -v377 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v378 := v377.FindInternedVar(lang.NewSymbol("list")) -if v378.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v378))) -} -v379 := v378.Get() -v380 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v381 := v380.FindInternedVar(lang.NewSymbol("seq")) -if v381.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v381))) -} -v382 := v381.Get() -v383 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v384 := v383.FindInternedVar(lang.NewSymbol("concat")) -if v384.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v384))) -} -v385 := v384.Get() -v386 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v387 := v386.FindInternedVar(lang.NewSymbol("list")) -if v387.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v387))) -} -v388 := v387.Get() -v389 := lang.Apply(v388, []any{lang.NewSymbol("quote")}) -v390 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v391 := v390.FindInternedVar(lang.NewSymbol("list")) -if v391.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v391))) -} -v392 := v391.Get() -v393 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v394 := v393.FindInternedVar(lang.NewSymbol("first")) -if v394.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v394))) -} -v395 := v394.Get() -v396 := lang.Apply(v395, []any{v222}) -v397 := lang.Apply(v392, []any{v396}) -v398 := lang.Apply(v385, []any{v389, v397}) -v399 := lang.Apply(v382, []any{v398}) -v400 := lang.Apply(v379, []any{v399}) -v401 := lang.Apply(v372, []any{v376, v400}) -v402 := lang.Apply(v369, []any{v401}) -v403 := lang.Apply(v366, []any{v402}) -v404 := lang.Apply(v359, []any{v363, v403}) -v405 := lang.Apply(v356, []any{v404}) -v406 := lang.Apply(v350, []any{v353, v405}) -v407 := lang.Apply(v347, []any{v406}) -v408 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v409 := v408.FindInternedVar(lang.NewSymbol("list")) -if v409.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v409))) -} -v410 := v409.Get() -v411 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v412 := v411.FindInternedVar(lang.NewSymbol("first")) -if v412.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v412))) -} -v413 := v412.Get() -v414 := lang.Apply(v413, []any{v222}) -v415 := lang.Apply(v410, []any{v414}) -v416 := lang.Apply(v332, []any{v336, v340, v344, v407, v415}) -v417 := lang.Apply(v329, []any{v416}) -v418 := lang.Apply(v326, []any{v417}) -v419 := lang.Apply(v228, []any{v232, v323, v418}) -v420 := lang.Apply(v225, []any{v419}) -return v420 -}) -v222 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(102), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(104), lang.NewKeyword("end-column"), int(90)) -v223, err := lang.WithMeta(v221, v222.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v224 := lang.Apply(v220, []any{v223, v35}) -v225 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v226 := v225.FindInternedVar(lang.NewSymbol("list")) -if v226.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v226))) -} -v227 := v226.Get() -v228 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v229 := v228.FindInternedVar(lang.NewSymbol("seq")) -if v229.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v229))) -} -v230 := v229.Get() -v231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v232 := v231.FindInternedVar(lang.NewSymbol("concat")) -if v232.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v232))) -} -v233 := v232.Get() -v234 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v235 := v234.FindInternedVar(lang.NewSymbol("list")) -if v235.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v235))) -} -v236 := v235.Get() -v237 := lang.Apply(v236, []any{lang.NewSymbol("var")}) -v238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v239 := v238.FindInternedVar(lang.NewSymbol("list")) -if v239.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v239))) -} -v240 := v239.Get() -v241 := lang.Apply(v240, []any{v5}) -v242 := lang.Apply(v233, []any{v237, v241}) -v243 := lang.Apply(v230, []any{v242}) -v244 := lang.Apply(v227, []any{v243}) -v245 := lang.Apply(v55, []any{v59, v169, v217, v224, v244}) -v246 := lang.Apply(v52, []any{v245}) -return v246 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// defstruct -{ -v0 := lang.NewSymbol("defstruct").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("keys"))), lang.NewKeyword("doc"), "Same as (def name (create-struct keys...))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4044), lang.NewKeyword("end-line"), int(4044))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("seq")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("concat")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("list")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{lang.NewSymbol("def")}) -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("list")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v5}) -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("list")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("seq")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("concat")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("list")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.Apply(v32, []any{lang.NewSymbol("glojure.core/create-struct")}) -v34 := lang.Apply(v29, []any{v33, v6}) -v35 := lang.Apply(v26, []any{v34}) -v36 := lang.Apply(v23, []any{v35}) -v37 := lang.Apply(v12, []any{v16, v20, v36}) -v38 := lang.Apply(v9, []any{v37}) -return v38 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// delay -{ -v0 := lang.NewSymbol("delay").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Takes a body of expressions and yields a Delay object that will\n invoke the body only the first time it is forced (with force or deref/@), and\n will cache the result and return it on all subsequent force\n calls. See also - realized?", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(739), lang.NewKeyword("end-line"), int(739))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("list")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("list*")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.NewVector() -v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(746), lang.NewKeyword("column"), int(62), lang.NewKeyword("end-line"), int(746), lang.NewKeyword("end-column"), int(63)) -v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v15 := lang.Apply(v11, []any{lang.NewSymbol("fn*"), v14, v5}) -v16 := lang.Apply(v8, []any{lang.NewSymbol("new"), lang.NewSymbol("glojure.lang.Delay"), v15}) -return v16 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// delay? -{ -v0 := lang.NewSymbol("delay?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "returns true if x is a Delay created with delay", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(748), lang.NewKeyword("end-line"), int(748))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{glojure.lang4.Delay, v3}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// deliver -{ -v0 := lang.NewSymbol("deliver").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("promise"), lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Delivers the supplied value to the promise, releasing any pending\n derefs. A subsequent call to deliver on a promise will have no effect.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7109), lang.NewKeyword("end-line"), int(7109))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.Apply(v3, []any{v4}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// denominator -{ -v1 := reflect.TypeOf((*big8.Int)(nil)) -v0 := lang.NewSymbol("denominator").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("r"))), lang.NewKeyword("doc"), "Returns the denominator part of a Ratio.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3591), lang.NewKeyword("end-line"), int(3591))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5, ok := lang.FieldOrMethod(v4, "denominator") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "denominator"))) -} -var v6 any -switch reflect.TypeOf(v5).Kind() { -case reflect.Func: - v6 = lang.Apply(v5, nil) -default: - v6 = v5 -} -return v6 -}) -v4 := reflect.TypeOf((*big8.Int)(nil)) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// deref -{ -v0 := lang.NewSymbol("deref").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref")), lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("timeout-ms"), lang.NewSymbol("timeout-val"))), lang.NewKeyword("doc"), "Also reader macro: @ref/@agent/@var/@atom/@delay/@future/@promise. Within a transaction,\n returns the in-transaction-value of ref, else returns the\n most-recently-committed value of ref. When applied to a var, agent\n or atom, returns its current state. When applied to a delay, forces\n it if not already forced. When applied to a future, will block if\n computation not complete. When applied to a promise, will block\n until a value is delivered. The variant taking a timeout can be\n used for blocking references (futures and promises), and will return\n timeout-val if the timeout (in milliseconds) is reached before a\n value is available. See also - realized?.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2304), lang.NewKeyword("end-line"), int(2304))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{lang.IDeref, v3}) -if lang.IsTruthy(v8) { -v9, ok := lang.FieldOrMethod(v3, "Deref") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "Deref"))) -} -var v10 any -switch reflect.TypeOf(v9).Kind() { -case reflect.Func: - v10 = lang.Apply(v9, nil) -default: - v10 = v9 -} -v4 = v10 -} else { -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("deref-future")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v3}) -v4 = v14 -} -return v4 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -var v6 any -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("instance?")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{lang.IBlockingDeref, v3}) -if lang.IsTruthy(v10) { -v11, _ := lang.FieldOrMethod(v3, "DerefWithTimeout") -if reflect.TypeOf(v11).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("DerefWithTimeout is not a function"))) -} -v12 := lang.Apply(v11, []any{v4, v5}) -v6 = v12 -} else { -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("deref-future")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v3, v4, v5}) -v6 = v16 -} -return v6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// deref-as-map -{ -v0 := lang.NewSymbol("deref-as-map").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(408), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(408), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{lang.IPending, v3}) -var v5 any = v9 -_ = v5 -var v11 any -if lang.IsTruthy(v5) { -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("not")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15, ok := lang.FieldOrMethod(v3, "isRealized") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "isRealized"))) -} -var v16 any -switch reflect.TypeOf(v15).Kind() { -case reflect.Func: - v16 = lang.Apply(v15, nil) -default: - v16 = v15 -} -v17 := lang.Apply(v14, []any{v16}) -v11 = v17 -} else { -v11 = v5 -} -var v4 any = v11 -_ = v4 -var v6 any -if lang.IsTruthy(v4) { -v6 = nil -} else { -var v7 any -func() { -defer func() { -if r := recover(); r != nil { -if lang.CatchMatches(r, lang.Throwable) { -v8 := r -_ = v8 -v9 := lang.NewVector(true, v8) -v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(415), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(415), lang.NewKeyword("end-column"), int(25)) -v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v7 = v11 -} else { -panic(r) -} -} -}() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("deref")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v3}) -v12 := lang.NewVector(false, v11) -v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(413), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(413), lang.NewKeyword("end-column"), int(32)) -v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v7 = v14 -}() -v6 = v7 -} -var v5 any = v6 -_ = v5 -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("nth")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v5, int64(0), nil}) -var v15 any = v19 -_ = v15 -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("nth")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v5, int64(1), nil}) -var v20 any = v24 -_ = v20 -var v26 any -var v27 any = v15 -_ = v27 -var v29 any -if lang.IsTruthy(v27) { -v29 = v27 -} else { -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("instance?")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{lang.*Agent, v3}) -var v30 any = v34 -_ = v30 -var v36 any -if lang.IsTruthy(v30) { -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("agent-error")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v3}) -v36 = v40 -} else { -v36 = v30 -} -v29 = v36 -} -if lang.IsTruthy(v29) { -v26 = lang.NewKeyword("failed") -} else { -var v27 any -if lang.IsTruthy(v4) { -v27 = lang.NewKeyword("pending") -} else { -var v28 any -if lang.IsTruthy(lang.NewKeyword("else")) { -v28 = lang.NewKeyword("ready") -} else { -v28 = nil -} -v27 = v28 -} -v26 = v27 -} -v29 := lang.NewMap(lang.NewKeyword("status"), v26, lang.NewKeyword("val"), v20) -v30 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(416), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(429), lang.NewKeyword("end-column"), int(14)) -v31, err := lang.WithMeta(v29, v30.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v31 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// deref-future -{ -v0 := lang.NewSymbol("deref-future").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2296), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(2296), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fut")), lang.NewVector(lang.NewSymbol("fut"), lang.NewSymbol("timeout-ms"), lang.NewSymbol("timeout-val"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -v4, ok := lang.FieldOrMethod(v3, "Get") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "Get"))) -} -var v5 any -switch reflect.TypeOf(v4).Kind() { -case reflect.Func: - v5 = lang.Apply(v4, nil) -default: - v5 = v4 -} -return v5 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -var v6 any -func() { -defer func() { -if r := recover(); r != nil { -if lang.CatchMatches(r, lang.TimeoutError) { -v7 := r -_ = v7 -v6 = v5 -} else { -panic(r) -} -} -}() -v7, _ := lang.FieldOrMethod(v3, "Get") -if reflect.TypeOf(v7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Get is not a function"))) -} -v8 := lang.Apply(v7, []any{v4, time9.Millisecond}) -v6 = v8 -}() -return v6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// derive -{ -v0 := lang.NewSymbol("derive").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag"), lang.NewSymbol("parent")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"), lang.NewSymbol("parent"))), lang.NewKeyword("doc"), "Establishes a parent/child relationship between parent and\n tag. Parent must be a namespace-qualified symbol or keyword and\n child can be either a namespace-qualified symbol or keyword or a\n class. h must be a hierarchy obtained from make-hierarchy, if not\n supplied defaults to, and modifies, the global hierarchy.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5605), lang.NewKeyword("end-line"), int(5605))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v3 := args[0] -v4 := args[1] -_ = nil -_ = nil -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("alter-var-root")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("global-hierarchy")) -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("derive")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v7, []any{v8, v11, v3, v4}) -_ = v12 -return nil - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -_ = nil -_ = nil -_ = nil -v7 := lang.Apply(lang.NewKeyword("parents"), []any{v3}) -var v6 any = v7 -_ = v6 -v9 := lang.Apply(lang.NewKeyword("descendants"), []any{v3}) -var v8 any = v9 -_ = v8 -v11 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) -var v10 any = v11 -_ = v10 -var v13 lang.FnFunc -v13 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 5 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v14 := args[0] -v15 := args[1] -v16 := args[2] -v17 := args[3] -v18 := args[4] -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("reduce1")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -var v22 lang.FnFunc -v22 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v23 := args[0] -v24 := args[1] -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("assoc")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("reduce1")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("conj")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("get")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.CreatePersistentTreeSet() -v38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5628), lang.NewKeyword("column"), int(61), lang.NewKeyword("end-line"), int(5628), lang.NewKeyword("end-column"), int(63)) -v39, err := lang.WithMeta(v37, v38.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v40 := lang.Apply(v36, []any{v18, v24, v39}) -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("cons")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v18, []any{v17}) -v45 := lang.Apply(v43, []any{v17, v44}) -v46 := lang.Apply(v30, []any{v33, v40, v45}) -v47 := lang.Apply(v27, []any{v23, v24, v46}) -return v47 -}) -v23 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5626), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(5628), lang.NewKeyword("end-column"), int(98)) -v24, err := lang.WithMeta(v22, v23.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("cons")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.Apply(v16, []any{v15}) -v29 := lang.Apply(v27, []any{v15, v28}) -v30 := lang.Apply(v21, []any{v24, v14, v29}) -return v30 -}) -v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5625), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(5629), lang.NewKeyword("end-column"), int(56)) -v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v12 any = v15 -_ = v12 -var v18 any -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("contains?")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v6, []any{v4}) -v23 := lang.Apply(v21, []any{v22, v5}) -if lang.IsTruthy(v23) { -v18 = nil -} else { -var v24 any -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("contains?")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.Apply(v10, []any{v4}) -v29 := lang.Apply(v27, []any{v28, v5}) -if lang.IsTruthy(v29) { -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("print-str")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.Apply(v32, []any{v4, "already has", v5, "as ancestor"}) -v34 := lang.Apply(lang.NewError, []any{v33}) -panic(v34) -} else { -v24 = nil -} -_ = v24 -var v35 any -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("contains?")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v10, []any{v5}) -v40 := lang.Apply(v38, []any{v39, v4}) -if lang.IsTruthy(v40) { -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("print-str")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{"Cyclic derivation:", v5, "has", v4, "as ancestor"}) -v45 := lang.Apply(lang.NewError, []any{v44}) -panic(v45) -} else { -v35 = nil -} -_ = v35 -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("assoc")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) -} -v48 := v47.Get() -v49 := lang.Apply(lang.NewKeyword("parents"), []any{v3}) -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("conj")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("get")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) -} -v55 := v54.Get() -v56 := lang.CreatePersistentTreeSet() -v57 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5636), lang.NewKeyword("column"), int(61), lang.NewKeyword("end-line"), int(5636), lang.NewKeyword("end-column"), int(63)) -v58, err := lang.WithMeta(v56, v57.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v59 := lang.Apply(v55, []any{v6, v4, v58}) -v60 := lang.Apply(v52, []any{v59, v5}) -v61 := lang.Apply(v48, []any{v49, v4, v60}) -v62 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) -v63 := lang.Apply(v12, []any{v62, v4, v8, v5, v10}) -v64 := lang.Apply(lang.NewKeyword("descendants"), []any{v3}) -v65 := lang.Apply(v12, []any{v64, v5, v10, v4, v8}) -v66 := lang.NewMap(lang.NewKeyword("parents"), v61, lang.NewKeyword("ancestors"), v63, lang.NewKeyword("descendants"), v65) -v67 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5636), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(5638), lang.NewKeyword("end-column"), int(61)) -v68, err := lang.WithMeta(v66, v67.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v18 = v68 -} -var v17 any = v18 -_ = v17 -var v70 any -if lang.IsTruthy(v17) { -v70 = v17 -} else { -v70 = v3 -} -return v70 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// descendants -{ -v0 := lang.NewSymbol("descendants").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"))), lang.NewKeyword("doc"), "Returns the immediate and indirect children of tag, through a\n relationship established via derive. h must be a hierarchy obtained\n from make-hierarchy, if not supplied defaults to the global\n hierarchy. Note: does not work on Java type inheritance\n relationships.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5593), lang.NewKeyword("end-line"), int(5593))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("descendants")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("global-hierarchy")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v6, []any{v9, v3}) -return v10 - case 2: -v3 := args[0] -v4 := args[1] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("class?")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v4}) -if lang.IsTruthy(v9) { -v10 := lang.Apply(lang.NewUnsupportedOperationError, []any{"Can't get descendants of classes"}) -panic(v10) -} else { -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("not-empty")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("get")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(lang.NewKeyword("descendants"), []any{v3}) -v18 := lang.Apply(v16, []any{v17, v4}) -v19 := lang.Apply(v13, []any{v18}) -v5 = v19 -} -return v5 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// destructure -{ -v0 := lang.NewSymbol("destructure").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4400), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(4400), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("partition")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{int64(2), v3}) -var v4 any = v8 -_ = v4 -var v10 lang.FnFunc -{ // function pb -v10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v12 := args[0] -v13 := args[1] -v14 := args[2] -var v16 lang.FnFunc -v16 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v17 := args[0] -v18 := args[1] -v19 := args[2] -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("gensym")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v23, []any{"vec__"}) -var v20 any = v24 -_ = v20 -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("gensym")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.Apply(v28, []any{"seq__"}) -var v25 any = v29 -_ = v25 -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("gensym")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{"first__"}) -var v30 any = v34 -_ = v30 -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("some")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.CreatePersistentTreeSet(lang.NewSymbol("&")) -v40 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4408), lang.NewKeyword("column"), int(43), lang.NewKeyword("end-line"), int(4408), lang.NewKeyword("end-column"), int(47)) -v41, err := lang.WithMeta(v39, v40.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v42 := lang.Apply(v38, []any{v41, v18}) -var v35 any = v42 -_ = v35 -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("conj")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) -} -v48 := v47.Get() -v49 := lang.Apply(v48, []any{v17, v20, v19}) -var v45 any = v49 -_ = v45 -var v51 any -if lang.IsTruthy(v35) { -v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("conj")) -if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) -} -v54 := v53.Get() -v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v56 := v55.FindInternedVar(lang.NewSymbol("list")) -if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) -} -v57 := v56.Get() -v58 := lang.Apply(v57, []any{lang.NewSymbol("glojure.core/seq"), v20}) -v59 := lang.Apply(v54, []any{v45, v25, v58}) -v51 = v59 -} else { -v51 = v45 -} -var v44 any = v51 -_ = v44 -var v45 any = int64(0) -_ = v45 -var v46 any = v18 -_ = v46 -var v47 any = false -_ = v47 -var v48 any -for { -var v49 any -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("seq")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.Apply(v52, []any{v46}) -if lang.IsTruthy(v53) { -v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v56 := v55.FindInternedVar(lang.NewSymbol("first")) -if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) -} -v57 := v56.Get() -v58 := lang.Apply(v57, []any{v46}) -var v54 any = v58 -_ = v54 -var v60 any -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("=")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) -} -v63 := v62.Get() -v64 := lang.Apply(v63, []any{v54, lang.NewSymbol("&")}) -if lang.IsTruthy(v64) { -v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v67 := v66.FindInternedVar(lang.NewSymbol("second")) -if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) -} -v68 := v67.Get() -v69 := lang.Apply(v68, []any{v46}) -v70 := lang.Apply(v11, []any{v44, v69, v25}) -var v65 any = v70 -var v71 any = v45 -v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v74 := v73.FindInternedVar(lang.NewSymbol("nnext")) -if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) -} -v75 := v74.Get() -v76 := lang.Apply(v75, []any{v46}) -var v72 any = v76 -var v77 any = true -v44 = v65 -v45 = v71 -v46 = v72 -v47 = v77 -continue -} else { -var v78 any -v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v80 := v79.FindInternedVar(lang.NewSymbol("=")) -if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) -} -v81 := v80.Get() -v82 := lang.Apply(v81, []any{v54, lang.NewKeyword("as")}) -if lang.IsTruthy(v82) { -v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v84 := v83.FindInternedVar(lang.NewSymbol("second")) -if v84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) -} -v85 := v84.Get() -v86 := lang.Apply(v85, []any{v46}) -v87 := lang.Apply(v11, []any{v44, v86, v20}) -v78 = v87 -} else { -var v88 any -if lang.IsTruthy(lang.NewKeyword("else")) { -var v89 any -if lang.IsTruthy(v47) { -v90 := lang.Apply(errors6.New, []any{"Unsupported binding form, only :as can follow & parameter"}) -panic(v90) -} else { -var v92 any -if lang.IsTruthy(v35) { -v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v94 := v93.FindInternedVar(lang.NewSymbol("conj")) -if v94.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) -} -v95 := v94.Get() -v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v97 := v96.FindInternedVar(lang.NewSymbol("seq")) -if v97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) -} -v98 := v97.Get() -v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v100 := v99.FindInternedVar(lang.NewSymbol("concat")) -if v100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) -} -v101 := v100.Get() -v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v103 := v102.FindInternedVar(lang.NewSymbol("list")) -if v103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) -} -v104 := v103.Get() -v105 := lang.Apply(v104, []any{lang.NewSymbol("glojure.core/first")}) -v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v107 := v106.FindInternedVar(lang.NewSymbol("list")) -if v107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) -} -v108 := v107.Get() -v109 := lang.Apply(v108, []any{v25}) -v110 := lang.Apply(v101, []any{v105, v109}) -v111 := lang.Apply(v98, []any{v110}) -v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v113 := v112.FindInternedVar(lang.NewSymbol("seq")) -if v113.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) -} -v114 := v113.Get() -v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v116 := v115.FindInternedVar(lang.NewSymbol("concat")) -if v116.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) -} -v117 := v116.Get() -v118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v119 := v118.FindInternedVar(lang.NewSymbol("list")) -if v119.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v119))) -} -v120 := v119.Get() -v121 := lang.Apply(v120, []any{lang.NewSymbol("glojure.core/next")}) -v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v123 := v122.FindInternedVar(lang.NewSymbol("list")) -if v123.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) -} -v124 := v123.Get() -v125 := lang.Apply(v124, []any{v25}) -v126 := lang.Apply(v117, []any{v121, v125}) -v127 := lang.Apply(v114, []any{v126}) -v128 := lang.Apply(v95, []any{v44, v30, v111, v25, v127}) -v92 = v128 -} else { -v92 = v44 -} -var v129 any -if lang.IsTruthy(v35) { -v129 = v30 -} else { -v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v131 := v130.FindInternedVar(lang.NewSymbol("list")) -if v131.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) -} -v132 := v131.Get() -v133 := lang.Apply(v132, []any{lang.NewSymbol("glojure.core/nth"), v20, v45, nil}) -v129 = v133 -} -v134 := lang.Apply(v11, []any{v92, v54, v129}) -var v91 any = v134 -v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v137 := v136.FindInternedVar(lang.NewSymbol("inc")) -if v137.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) -} -v138 := v137.Get() -v139 := lang.Apply(v138, []any{v45}) -var v135 any = v139 -v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v142 := v141.FindInternedVar(lang.NewSymbol("next")) -if v142.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) -} -v143 := v142.Get() -v144 := lang.Apply(v143, []any{v46}) -var v140 any = v144 -var v145 any = v47 -v44 = v91 -v45 = v135 -v46 = v140 -v47 = v145 -continue -} -v88 = v89 -} else { -v88 = nil -} -v78 = v88 -} -v60 = v78 -} -v49 = v60 -} else { -v49 = v44 -} -v48 = v49 - break -} -return v48 -}) -v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4404), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(4438), lang.NewKeyword("end-column"), int(34)) -v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v15 any = v18 -_ = v15 -var v20 lang.FnFunc -v20 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v21 := args[0] -v22 := args[1] -v23 := args[2] -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("gensym")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.Apply(v27, []any{"map__"}) -var v24 any = v28 -_ = v24 -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("with-meta")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.NewMap(lang.NewKeyword("tag"), lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.ISeq")) -v34 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4442), lang.NewKeyword("column"), int(52), lang.NewKeyword("end-line"), int(4442), lang.NewKeyword("end-column"), int(103)) -v35, err := lang.WithMeta(v33, v34.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v36 := lang.Apply(v32, []any{v24, v35}) -var v29 any = v36 -_ = v29 -v38 := lang.Apply(lang.NewKeyword("or"), []any{v22}) -var v37 any = v38 -_ = v37 -var v41 lang.FnFunc -v41 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v42 := args[0] -var v43 any -v44 := lang.Apply(lang.NewKeyword("as"), []any{v22}) -if lang.IsTruthy(v44) { -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("conj")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.Apply(lang.NewKeyword("as"), []any{v22}) -v49 := lang.Apply(v47, []any{v42, v48, v24}) -v43 = v49 -} else { -v43 = v42 -} -return v43 -}) -v42 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4450), lang.NewKeyword("column"), int(40), lang.NewKeyword("end-line"), int(4453), lang.NewKeyword("end-column"), int(48)) -v43, err := lang.WithMeta(v41, v42.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("conj")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("conj")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) -} -v49 := v48.Get() -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("conj")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("conj")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) -} -v55 := v54.Get() -v56 := lang.Apply(v55, []any{v21, v24}) -v57 := lang.Apply(v52, []any{v56, v23}) -v58 := lang.Apply(v49, []any{v57, v24}) -v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v60 := v59.FindInternedVar(lang.NewSymbol("seq")) -if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) -} -v61 := v60.Get() -v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v63 := v62.FindInternedVar(lang.NewSymbol("concat")) -if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) -} -v64 := v63.Get() -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("list")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) -} -v67 := v66.Get() -v68 := lang.Apply(v67, []any{lang.NewSymbol("if")}) -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("list")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) -} -v71 := v70.Get() -v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v73 := v72.FindInternedVar(lang.NewSymbol("seq")) -if v73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) -} -v74 := v73.Get() -v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v76 := v75.FindInternedVar(lang.NewSymbol("concat")) -if v76.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) -} -v77 := v76.Get() -v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v79 := v78.FindInternedVar(lang.NewSymbol("list")) -if v79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) -} -v80 := v79.Get() -v81 := lang.Apply(v80, []any{lang.NewSymbol("glojure.core/seq?")}) -v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v83 := v82.FindInternedVar(lang.NewSymbol("list")) -if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) -} -v84 := v83.Get() -v85 := lang.Apply(v84, []any{v24}) -v86 := lang.Apply(v77, []any{v81, v85}) -v87 := lang.Apply(v74, []any{v86}) -v88 := lang.Apply(v71, []any{v87}) -v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v90 := v89.FindInternedVar(lang.NewSymbol("list")) -if v90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) -} -v91 := v90.Get() -v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v93 := v92.FindInternedVar(lang.NewSymbol("seq")) -if v93.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) -} -v94 := v93.Get() -v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v96 := v95.FindInternedVar(lang.NewSymbol("concat")) -if v96.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) -} -v97 := v96.Get() -v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v99 := v98.FindInternedVar(lang.NewSymbol("list")) -if v99.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) -} -v100 := v99.Get() -v101 := lang.Apply(v100, []any{lang.NewSymbol("if")}) -v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v103 := v102.FindInternedVar(lang.NewSymbol("list")) -if v103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) -} -v104 := v103.Get() -v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v106 := v105.FindInternedVar(lang.NewSymbol("seq")) -if v106.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) -} -v107 := v106.Get() -v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v109 := v108.FindInternedVar(lang.NewSymbol("concat")) -if v109.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) -} -v110 := v109.Get() -v111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v112 := v111.FindInternedVar(lang.NewSymbol("list")) -if v112.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v112))) -} -v113 := v112.Get() -v114 := lang.Apply(v113, []any{lang.NewSymbol("glojure.core/next")}) -v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v116 := v115.FindInternedVar(lang.NewSymbol("list")) -if v116.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) -} -v117 := v116.Get() -v118 := lang.Apply(v117, []any{v29}) -v119 := lang.Apply(v110, []any{v114, v118}) -v120 := lang.Apply(v107, []any{v119}) -v121 := lang.Apply(v104, []any{v120}) -v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v123 := v122.FindInternedVar(lang.NewSymbol("list")) -if v123.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) -} -v124 := v123.Get() -v125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v126 := v125.FindInternedVar(lang.NewSymbol("seq")) -if v126.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v126))) -} -v127 := v126.Get() -v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v129 := v128.FindInternedVar(lang.NewSymbol("concat")) -if v129.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v129))) -} -v130 := v129.Get() -v131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v132 := v131.FindInternedVar(lang.NewSymbol("list")) -if v132.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v132))) -} -v133 := v132.Get() -v134 := lang.Apply(v133, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewPersistentArrayMapAsIfByAssoc")}) -v135 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v136 := v135.FindInternedVar(lang.NewSymbol("list")) -if v136.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v136))) -} -v137 := v136.Get() -v138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v139 := v138.FindInternedVar(lang.NewSymbol("seq")) -if v139.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v139))) -} -v140 := v139.Get() -v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v142 := v141.FindInternedVar(lang.NewSymbol("concat")) -if v142.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) -} -v143 := v142.Get() -v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v145 := v144.FindInternedVar(lang.NewSymbol("list")) -if v145.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) -} -v146 := v145.Get() -v147 := lang.Apply(v146, []any{lang.NewSymbol("glojure.core/to-array")}) -v148 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v149 := v148.FindInternedVar(lang.NewSymbol("list")) -if v149.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v149))) -} -v150 := v149.Get() -v151 := lang.Apply(v150, []any{v29}) -v152 := lang.Apply(v143, []any{v147, v151}) -v153 := lang.Apply(v140, []any{v152}) -v154 := lang.Apply(v137, []any{v153}) -v155 := lang.Apply(v130, []any{v134, v154}) -v156 := lang.Apply(v127, []any{v155}) -v157 := lang.Apply(v124, []any{v156}) -v158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v159 := v158.FindInternedVar(lang.NewSymbol("list")) -if v159.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v159))) -} -v160 := v159.Get() -v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v162 := v161.FindInternedVar(lang.NewSymbol("seq")) -if v162.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) -} -v163 := v162.Get() -v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v165 := v164.FindInternedVar(lang.NewSymbol("concat")) -if v165.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) -} -v166 := v165.Get() -v167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v168 := v167.FindInternedVar(lang.NewSymbol("list")) -if v168.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v168))) -} -v169 := v168.Get() -v170 := lang.Apply(v169, []any{lang.NewSymbol("if")}) -v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v172 := v171.FindInternedVar(lang.NewSymbol("list")) -if v172.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) -} -v173 := v172.Get() -v174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v175 := v174.FindInternedVar(lang.NewSymbol("seq")) -if v175.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v175))) -} -v176 := v175.Get() -v177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v178 := v177.FindInternedVar(lang.NewSymbol("concat")) -if v178.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v178))) -} -v179 := v178.Get() -v180 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v181 := v180.FindInternedVar(lang.NewSymbol("list")) -if v181.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v181))) -} -v182 := v181.Get() -v183 := lang.Apply(v182, []any{lang.NewSymbol("glojure.core/seq")}) -v184 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v185 := v184.FindInternedVar(lang.NewSymbol("list")) -if v185.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v185))) -} -v186 := v185.Get() -v187 := lang.Apply(v186, []any{v29}) -v188 := lang.Apply(v179, []any{v183, v187}) -v189 := lang.Apply(v176, []any{v188}) -v190 := lang.Apply(v173, []any{v189}) -v191 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v192 := v191.FindInternedVar(lang.NewSymbol("list")) -if v192.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v192))) -} -v193 := v192.Get() -v194 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v195 := v194.FindInternedVar(lang.NewSymbol("seq")) -if v195.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v195))) -} -v196 := v195.Get() -v197 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v198 := v197.FindInternedVar(lang.NewSymbol("concat")) -if v198.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v198))) -} -v199 := v198.Get() -v200 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v201 := v200.FindInternedVar(lang.NewSymbol("list")) -if v201.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v201))) -} -v202 := v201.Get() -v203 := lang.Apply(v202, []any{lang.NewSymbol("glojure.core/first")}) -v204 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v205 := v204.FindInternedVar(lang.NewSymbol("list")) -if v205.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v205))) -} -v206 := v205.Get() -v207 := lang.Apply(v206, []any{v29}) -v208 := lang.Apply(v199, []any{v203, v207}) -v209 := lang.Apply(v196, []any{v208}) -v210 := lang.Apply(v193, []any{v209}) -v211 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v212 := v211.FindInternedVar(lang.NewSymbol("list")) -if v212.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v212))) -} -v213 := v212.Get() -v214 := lang.Apply(v213, []any{lang.NewSymbol("glojure.lang.PersistentArrayMap/EMPTY")}) -v215 := lang.Apply(v166, []any{v170, v190, v210, v214}) -v216 := lang.Apply(v163, []any{v215}) -v217 := lang.Apply(v160, []any{v216}) -v218 := lang.Apply(v97, []any{v101, v121, v157, v217}) -v219 := lang.Apply(v94, []any{v218}) -v220 := lang.Apply(v91, []any{v219}) -v221 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v222 := v221.FindInternedVar(lang.NewSymbol("list")) -if v222.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v222))) -} -v223 := v222.Get() -v224 := lang.Apply(v223, []any{v24}) -v225 := lang.Apply(v64, []any{v68, v88, v220, v224}) -v226 := lang.Apply(v61, []any{v225}) -v227 := lang.Apply(v46, []any{v58, v226}) -v228 := lang.Apply(v43, []any{v227}) -var v40 any = v228 -_ = v40 -v231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v232 := v231.FindInternedVar(lang.NewSymbol("reduce1")) -if v232.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v232))) -} -v233 := v232.Get() -var v234 lang.FnFunc -v234 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v235 := args[0] -v236 := args[1] -var v237 any -v238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v239 := v238.FindInternedVar(lang.NewSymbol("keyword?")) -if v239.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v239))) -} -v240 := v239.Get() -v241 := lang.Apply(v240, []any{v236}) -if lang.IsTruthy(v241) { -v243 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v244 := v243.FindInternedVar(lang.NewSymbol("namespace")) -if v244.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v244))) -} -v245 := v244.Get() -v246 := lang.Apply(v245, []any{v236}) -var v242 any = v246 -_ = v242 -v248 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v249 := v248.FindInternedVar(lang.NewSymbol("name")) -if v249.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v249))) -} -v250 := v249.Get() -v251 := lang.Apply(v250, []any{v236}) -var v247 any = v251 -_ = v247 -var v253 any -v254 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v255 := v254.FindInternedVar(lang.NewSymbol("=")) -if v255.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v255))) -} -v256 := v255.Get() -v257 := lang.Apply(v256, []any{v247, "keys"}) -if lang.IsTruthy(v257) { -v258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v259 := v258.FindInternedVar(lang.NewSymbol("assoc")) -if v259.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v259))) -} -v260 := v259.Get() -var v261 lang.FnFunc -v261 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v262 := args[0] -v263 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v264 := v263.FindInternedVar(lang.NewSymbol("keyword")) -if v264.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v264))) -} -v265 := v264.Get() -var v266 any = v242 -_ = v266 -var v268 any -if lang.IsTruthy(v266) { -v268 = v266 -} else { -v269 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v270 := v269.FindInternedVar(lang.NewSymbol("namespace")) -if v270.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v270))) -} -v271 := v270.Get() -v272 := lang.Apply(v271, []any{v262}) -v268 = v272 -} -v266 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v267 := v266.FindInternedVar(lang.NewSymbol("name")) -if v267.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v267))) -} -v268 := v267.Get() -v269 := lang.Apply(v268, []any{v262}) -v270 := lang.Apply(v265, []any{v268, v269}) -return v270 -}) -v262 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4460), lang.NewKeyword("column"), int(93), lang.NewKeyword("end-line"), int(4460), lang.NewKeyword("end-column"), int(135)) -v263, err := lang.WithMeta(v261, v262.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v264 := lang.Apply(v260, []any{v235, v236, v263}) -v253 = v264 -} else { -var v265 any -v266 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v267 := v266.FindInternedVar(lang.NewSymbol("=")) -if v267.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v267))) -} -v268 := v267.Get() -v269 := lang.Apply(v268, []any{v247, "syms"}) -if lang.IsTruthy(v269) { -v270 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v271 := v270.FindInternedVar(lang.NewSymbol("assoc")) -if v271.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v271))) -} -v272 := v271.Get() -var v273 lang.FnFunc -v273 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v274 := args[0] -v275 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v276 := v275.FindInternedVar(lang.NewSymbol("list")) -if v276.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v276))) -} -v277 := v276.Get() -v278 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v279 := v278.FindInternedVar(lang.NewSymbol("symbol")) -if v279.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v279))) -} -v280 := v279.Get() -var v281 any = v242 -_ = v281 -var v283 any -if lang.IsTruthy(v281) { -v283 = v281 -} else { -v284 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v285 := v284.FindInternedVar(lang.NewSymbol("namespace")) -if v285.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v285))) -} -v286 := v285.Get() -v287 := lang.Apply(v286, []any{v274}) -v283 = v287 -} -v281 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v282 := v281.FindInternedVar(lang.NewSymbol("name")) -if v282.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v282))) -} -v283 := v282.Get() -v284 := lang.Apply(v283, []any{v274}) -v285 := lang.Apply(v280, []any{v283, v284}) -v286 := lang.Apply(v277, []any{lang.NewSymbol("quote"), v285}) -return v286 -}) -v274 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4461), lang.NewKeyword("column"), int(93), lang.NewKeyword("end-line"), int(4461), lang.NewKeyword("end-column"), int(148)) -v275, err := lang.WithMeta(v273, v274.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v276 := lang.Apply(v272, []any{v235, v236, v275}) -v265 = v276 -} else { -var v277 any -v278 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v279 := v278.FindInternedVar(lang.NewSymbol("=")) -if v279.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v279))) -} -v280 := v279.Get() -v281 := lang.Apply(v280, []any{v247, "strs"}) -if lang.IsTruthy(v281) { -v282 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v283 := v282.FindInternedVar(lang.NewSymbol("assoc")) -if v283.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v283))) -} -v284 := v283.Get() -v285 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v286 := v285.FindInternedVar(lang.NewSymbol("str")) -if v286.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v286))) -} -v287 := v286.Get() -v288 := lang.Apply(v284, []any{v235, v236, v287}) -v277 = v288 -} else { -var v289 any -if lang.IsTruthy(lang.NewKeyword("else")) { -v289 = v235 -} else { -v289 = nil -} -v277 = v289 -} -v265 = v277 -} -v253 = v265 -} -v237 = v253 -} else { -v237 = v235 -} -return v237 -}) -v235 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4456), lang.NewKeyword("column"), int(45), lang.NewKeyword("end-line"), int(4464), lang.NewKeyword("end-column"), int(60)) -v236, err := lang.WithMeta(v234, v235.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v237 := lang.NewMap() -v238 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4465), lang.NewKeyword("column"), int(45), lang.NewKeyword("end-line"), int(4465), lang.NewKeyword("end-column"), int(46)) -v239, err := lang.WithMeta(v237, v238.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v240 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v241 := v240.FindInternedVar(lang.NewSymbol("keys")) -if v241.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v241))) -} -v242 := v241.Get() -v243 := lang.Apply(v242, []any{v22}) -v244 := lang.Apply(v233, []any{v236, v239, v243}) -var v230 any = v244 -_ = v230 -v246 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v247 := v246.FindInternedVar(lang.NewSymbol("reduce1")) -if v247.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v247))) -} -v248 := v247.Get() -var v249 lang.FnFunc -v249 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v250 := args[0] -v251 := args[1] -v252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v253 := v252.FindInternedVar(lang.NewSymbol("reduce1")) -if v253.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v253))) -} -v254 := v253.Get() -var v255 lang.FnFunc -v255 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v256 := args[0] -v257 := args[1] -v258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v259 := v258.FindInternedVar(lang.NewSymbol("assoc")) -if v259.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v259))) -} -v260 := v259.Get() -v261 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v262 := v261.FindInternedVar(lang.NewSymbol("val")) -if v262.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v262))) -} -v263 := v262.Get() -v264 := lang.Apply(v263, []any{v251}) -v265 := lang.Apply(v264, []any{v257}) -v266 := lang.Apply(v260, []any{v256, v257, v265}) -return v266 -}) -v256 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4469), lang.NewKeyword("column"), int(52), lang.NewKeyword("end-line"), int(4469), lang.NewKeyword("end-column"), int(82)) -v257, err := lang.WithMeta(v255, v256.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v259 := v258.FindInternedVar(lang.NewSymbol("dissoc")) -if v259.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v259))) -} -v260 := v259.Get() -v261 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v262 := v261.FindInternedVar(lang.NewSymbol("key")) -if v262.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v262))) -} -v263 := v262.Get() -v264 := lang.Apply(v263, []any{v251}) -v265 := lang.Apply(v260, []any{v250, v264}) -v266 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v267 := v266.FindInternedVar(lang.NewSymbol("key")) -if v267.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v267))) -} -v268 := v267.Get() -v269 := lang.Apply(v268, []any{v251}) -v270 := lang.Apply(v269, []any{v250}) -v271 := lang.Apply(v254, []any{v257, v265, v270}) -return v271 -}) -v250 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4468), lang.NewKeyword("column"), int(41), lang.NewKeyword("end-line"), int(4471), lang.NewKeyword("end-column"), int(70)) -v251, err := lang.WithMeta(v249, v250.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v253 := v252.FindInternedVar(lang.NewSymbol("dissoc")) -if v253.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v253))) -} -v254 := v253.Get() -v255 := lang.Apply(v254, []any{v22, lang.NewKeyword("as"), lang.NewKeyword("or")}) -v256 := lang.Apply(v248, []any{v251, v255, v230}) -var v229 any = v256 -_ = v229 -var v230 any -for { -var v231 any -v232 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v233 := v232.FindInternedVar(lang.NewSymbol("seq")) -if v233.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v233))) -} -v234 := v233.Get() -v235 := lang.Apply(v234, []any{v229}) -if lang.IsTruthy(v235) { -v237 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v238 := v237.FindInternedVar(lang.NewSymbol("key")) -if v238.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v238))) -} -v239 := v238.Get() -v240 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v241 := v240.FindInternedVar(lang.NewSymbol("first")) -if v241.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v241))) -} -v242 := v241.Get() -v243 := lang.Apply(v242, []any{v229}) -v244 := lang.Apply(v239, []any{v243}) -var v236 any = v244 -_ = v236 -v246 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v247 := v246.FindInternedVar(lang.NewSymbol("val")) -if v247.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v247))) -} -v248 := v247.Get() -v249 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v250 := v249.FindInternedVar(lang.NewSymbol("first")) -if v250.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v250))) -} -v251 := v250.Get() -v252 := lang.Apply(v251, []any{v229}) -v253 := lang.Apply(v248, []any{v252}) -var v245 any = v253 -_ = v245 -var v255 any -v256 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v257 := v256.FindInternedVar(lang.NewSymbol("instance?")) -if v257.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v257))) -} -v258 := v257.Get() -v259 := lang.Apply(v258, []any{lang.Named, v236}) -if lang.IsTruthy(v259) { -v260 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v261 := v260.FindInternedVar(lang.NewSymbol("with-meta")) -if v261.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v261))) -} -v262 := v261.Get() -v263 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v264 := v263.FindInternedVar(lang.NewSymbol("symbol")) -if v264.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v264))) -} -v265 := v264.Get() -v266 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v267 := v266.FindInternedVar(lang.NewSymbol("name")) -if v267.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v267))) -} -v268 := v267.Get() -v269 := lang.Apply(v268, []any{v236}) -v270 := lang.Apply(v265, []any{nil, v269}) -v271 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v272 := v271.FindInternedVar(lang.NewSymbol("meta")) -if v272.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v272))) -} -v273 := v272.Get() -v274 := lang.Apply(v273, []any{v236}) -v275 := lang.Apply(v262, []any{v270, v274}) -v255 = v275 -} else { -v255 = v236 -} -var v254 any = v255 -_ = v254 -var v277 any -v278 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v279 := v278.FindInternedVar(lang.NewSymbol("contains?")) -if v279.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v279))) -} -v280 := v279.Get() -v281 := lang.Apply(v280, []any{v37, v254}) -if lang.IsTruthy(v281) { -v282 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v283 := v282.FindInternedVar(lang.NewSymbol("list")) -if v283.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v283))) -} -v284 := v283.Get() -v285 := lang.Apply(v37, []any{v254}) -v286 := lang.Apply(v284, []any{lang.NewSymbol("glojure.core/get"), v24, v245, v285}) -v277 = v286 -} else { -v287 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v288 := v287.FindInternedVar(lang.NewSymbol("list")) -if v288.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v288))) -} -v289 := v288.Get() -v290 := lang.Apply(v289, []any{lang.NewSymbol("glojure.core/get"), v24, v245}) -v277 = v290 -} -var v276 any = v277 -_ = v276 -var v293 any -v294 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v295 := v294.FindInternedVar(lang.NewSymbol("ident?")) -if v295.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v295))) -} -v296 := v295.Get() -v297 := lang.Apply(v296, []any{v236}) -if lang.IsTruthy(v297) { -v298 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v299 := v298.FindInternedVar(lang.NewSymbol("conj")) -if v299.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v299))) -} -v300 := v299.Get() -v301 := lang.Apply(v300, []any{v40, v254, v276}) -v293 = v301 -} else { -v302 := lang.Apply(v11, []any{v40, v236, v276}) -v293 = v302 -} -var v292 any = v293 -v304 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v305 := v304.FindInternedVar(lang.NewSymbol("next")) -if v305.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v305))) -} -v306 := v305.Get() -v307 := lang.Apply(v306, []any{v229}) -var v303 any = v307 -v40 = v292 -v229 = v303 -continue -} else { -v231 = v40 -} -v230 = v231 - break -} -return v230 -}) -v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4440), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(4485), lang.NewKeyword("end-column"), int(34)) -v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v19 any = v22 -_ = v19 -var v24 any -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("symbol?")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.Apply(v27, []any{v13}) -if lang.IsTruthy(v28) { -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("conj")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("conj")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v12, v13}) -v36 := lang.Apply(v31, []any{v35, v14}) -v24 = v36 -} else { -var v37 any -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("vector?")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.Apply(v40, []any{v13}) -if lang.IsTruthy(v41) { -v42 := lang.Apply(v15, []any{v12, v13, v14}) -v37 = v42 -} else { -var v43 any -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("map?")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v13}) -if lang.IsTruthy(v47) { -v48 := lang.Apply(v19, []any{v12, v13, v14}) -v43 = v48 -} else { -var v49 any -if lang.IsTruthy(lang.NewKeyword("else")) { -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("str")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.Apply(v52, []any{"Unsupported binding form: ", v13}) -v54 := lang.Apply(errors6.New, []any{v53}) -panic(v54) -} else { -v49 = nil -} -v43 = v49 -} -v37 = v43 -} -v24 = v37 -} -return v24 -}) -v11 := v10 -_ = v11 -} -v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4402), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(4490), lang.NewKeyword("end-column"), int(82)) -v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v9 any = v12 -_ = v9 -var v14 lang.FnFunc -v14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v15 := args[0] -v16 := args[1] -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("first")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v16}) -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("second")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v16}) -v25 := lang.Apply(v9, []any{v15, v20, v24}) -return v25 -}) -v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4491), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(4491), lang.NewKeyword("end-column"), int(66)) -v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v13 any = v16 -_ = v13 -var v18 any -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("every?")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("symbol?")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("map")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("first")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v27, []any{v30, v4}) -v32 := lang.Apply(v21, []any{v24, v31}) -if lang.IsTruthy(v32) { -v18 = v3 -} else { -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("reduce1")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.NewVector() -v37 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4494), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(4494), lang.NewKeyword("end-column"), int(31)) -v38, err := lang.WithMeta(v36, v37.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v39 := lang.Apply(v35, []any{v13, v38, v4}) -v18 = v39 -} -return v18 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// disj -{ -v0 := lang.NewSymbol("disj").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("set")), lang.NewVector(lang.NewSymbol("set"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("set"), lang.NewSymbol("key"), lang.NewSymbol("&"), lang.NewSymbol("ks"))), lang.NewKeyword("doc"), "disj[oin]. Returns a new set of the same (hashed/sorted) type, that\n does not contain key(s).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1514), lang.NewKeyword("end-line"), int(1514))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -return v3 - case 2: -v3 := args[0] -v4 := args[1] -var v5 any -if lang.IsTruthy(v3) { -v6, _ := lang.FieldOrMethod(v3, "Disjoin") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Disjoin is not a function"))) -} -v7 := lang.Apply(v6, []any{v4}) -v5 = v7 -} else { -v5 = nil -} -return v5 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -recur_loop_304: -var v6 any -if lang.IsTruthy(v3) { -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("disj")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v3, v4}) -var v7 any = v11 -_ = v7 -var v13 any -if lang.IsTruthy(v5) { -var v14 any = v7 -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("first")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v5}) -var v15 any = v19 -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("next")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v5}) -var v20 any = v24 -v3 = v14 -v4 = v15 -v5 = v20 -goto recur_loop_304 -} else { -v13 = v7 -} -v6 = v13 -} else { -v6 = nil -} -return v6 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// disj! -{ -v0 := lang.NewSymbol("disj!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("set")), lang.NewVector(lang.NewSymbol("set"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("set"), lang.NewSymbol("key"), lang.NewSymbol("&"), lang.NewSymbol("ks"))), lang.NewKeyword("doc"), "disj[oin]. Returns a transient set of the same (hashed/sorted) type, that\n does not contain key(s).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3401), lang.NewKeyword("end-line"), int(3401))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -return v3 - case 2: -v3 := args[0] -v4 := args[1] -v5, _ := lang.FieldOrMethod(v3, "Disjoin") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Disjoin is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -recur_loop_615: -v7, _ := lang.FieldOrMethod(v3, "Disjoin") -if reflect.TypeOf(v7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Disjoin is not a function"))) -} -v8 := lang.Apply(v7, []any{v4}) -var v6 any = v8 -_ = v6 -var v10 any -if lang.IsTruthy(v5) { -var v11 any = v6 -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("first")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v5}) -var v12 any = v16 -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("next")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v20, []any{v5}) -var v17 any = v21 -v3 = v11 -v4 = v12 -v5 = v17 -goto recur_loop_615 -} else { -v10 = v6 -} -return v10 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// dissoc -{ -v0 := lang.NewSymbol("dissoc").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map")), lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"), lang.NewSymbol("&"), lang.NewSymbol("ks"))), lang.NewKeyword("doc"), "dissoc[iate]. Returns a new map of the same (hashed/sorted) type,\n that does not contain a mapping for key(s).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1500), lang.NewKeyword("end-line"), int(1500))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -return v3 - case 2: -v3 := args[0] -v4 := args[1] -v5, _ := lang.FieldOrMethod(runtime5.RT, "Dissoc") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Dissoc is not a function"))) -} -v6 := lang.Apply(v5, []any{v3, v4}) -return v6 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -recur_loop_301: -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("dissoc")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v3, v4}) -var v6 any = v10 -_ = v6 -var v12 any -if lang.IsTruthy(v5) { -var v13 any = v6 -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("first")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v5}) -var v14 any = v18 -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("next")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.Apply(v22, []any{v5}) -var v19 any = v23 -v3 = v13 -v4 = v14 -v5 = v19 -goto recur_loop_301 -} else { -v12 = v6 -} -return v12 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// dissoc! -{ -v0 := lang.NewSymbol("dissoc!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"), lang.NewSymbol("&"), lang.NewSymbol("ks"))), lang.NewKeyword("doc"), "Returns a transient map that doesn't contain a mapping for key(s).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3382), lang.NewKeyword("end-line"), int(3382))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v3 := args[0] -v4 := args[1] -v5, _ := lang.FieldOrMethod(v3, "without") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("without is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -recur_loop_611: -v7, _ := lang.FieldOrMethod(v3, "without") -if reflect.TypeOf(v7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("without is not a function"))) -} -v8 := lang.Apply(v7, []any{v4}) -var v6 any = v8 -_ = v6 -var v10 any -if lang.IsTruthy(v5) { -var v11 any = v6 -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("first")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v5}) -var v12 any = v16 -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("next")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v20, []any{v5}) -var v17 any = v21 -v3 = v11 -v4 = v12 -v5 = v17 -goto recur_loop_611 -} else { -v10 = v6 -} -return v10 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// distinct -{ -v0 := lang.NewSymbol("distinct").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the elements of coll with duplicates removed.\n Returns a stateful transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5053), lang.NewKeyword("end-line"), int(5053))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("volatile!")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.CreatePersistentTreeSet() -v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5060), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(5060), lang.NewKeyword("end-column"), int(30)) -v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v12 := lang.Apply(v8, []any{v11}) -var v5 any = v12 -_ = v5 -var v14 lang.FnFunc -v14 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v15 := lang.Apply(v4, nil) -return v15 - case 1: -v15 := args[0] -v16 := lang.Apply(v4, []any{v15}) -return v16 - case 2: -v15 := args[0] -v16 := args[1] -var v17 any -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("contains?")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("deref")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v5}) -v25 := lang.Apply(v20, []any{v24, v16}) -if lang.IsTruthy(v25) { -v17 = v15 -} else { -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("conj")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29, ok := lang.FieldOrMethod(v5, "Deref") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "Deref"))) -} -var v30 any -switch reflect.TypeOf(v29).Kind() { -case reflect.Func: - v30 = lang.Apply(v29, nil) -default: - v30 = v29 -} -v31 := lang.Apply(v28, []any{v30, v16}) -v32, _ := lang.FieldOrMethod(v5, "reset") -if reflect.TypeOf(v32).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) -} -v33 := lang.Apply(v32, []any{v31}) -_ = v33 -v34 := lang.Apply(v4, []any{v15, v16}) -v17 = v34 -} -return v17 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5061), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(5068), lang.NewKeyword("end-column"), int(37)) -v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v16 -}) -v4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5059), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(5068), lang.NewKeyword("end-column"), int(39)) -v5, err := lang.WithMeta(v3, v4.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v5 - case 1: -v3 := args[0] -var v5 lang.FnFunc -{ // function step -v5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v7 := args[0] -v8 := args[1] -var v9 lang.FnFunc -v9 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -var v10 lang.FnFunc -v10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v11 := args[0] -v12 := args[1] -recur_loop_877: -var v13 any = v11 -_ = v13 -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("nth")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v13, int64(0), nil}) -var v14 any = v18 -_ = v14 -var v19 any = v13 -_ = v19 -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("seq")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v19}) -var v21 any = v25 -_ = v21 -var v27 any -if lang.IsTruthy(v21) { -var v28 any = v21 -_ = v28 -var v30 any -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("contains?")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v12, v14}) -if lang.IsTruthy(v34) { -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("rest")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v28}) -var v35 any = v39 -var v40 any = v12 -v11 = v35 -v12 = v40 -goto recur_loop_877 -} else { -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("cons")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("rest")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v28}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("conj")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v12, v14}) -v52 := lang.Apply(v6, []any{v47, v51}) -v53 := lang.Apply(v43, []any{v14, v52}) -v30 = v53 -} -v27 = v30 -} else { -v27 = nil -} -return v27 -}) -v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5072), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(5076), lang.NewKeyword("end-column"), int(66)) -v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v13 := lang.Apply(v12, []any{v7, v8}) -return v13 -}) -v10 := lang.Apply(lang.NewLazySeq, []any{v9}) -return v10 -}) -v6 := v5 -_ = v6 -} -v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5070), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(5077), lang.NewKeyword("end-column"), int(29)) -v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v4 any = v7 -_ = v4 -v9 := lang.CreatePersistentTreeSet() -v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5078), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(5078), lang.NewKeyword("end-column"), int(19)) -v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v12 := lang.Apply(v4, []any{v3, v11}) -return v12 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// distinct? -{ -v1 := reflect.TypeOf(false) -v0 := lang.NewSymbol("distinct?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Returns true if no two of the arguments are =", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5664), lang.NewKeyword("end-line"), int(5664))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v4 := args[0] -return true - case 2: -v4 := args[0] -v5 := args[1] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("not")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("=")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v4, v5}) -v13 := lang.Apply(v8, []any{v12}) -return v13 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6 := lang.NewList(args[2:]...) -var v7 any -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("not=")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v4, v5}) -if lang.IsTruthy(v11) { -v13 := lang.CreatePersistentTreeSet(v4, v5) -v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5673), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(5673), lang.NewKeyword("end-column"), int(20)) -v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v12 any = v15 -_ = v12 -var v16 any = v6 -_ = v16 -var v17 any = v16 -_ = v17 -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("seq")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v17}) -var v18 any = v22 -_ = v18 -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("first")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v18}) -var v23 any = v27 -_ = v23 -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("next")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.Apply(v31, []any{v28}) -var v28 any = v32 -_ = v28 -var v33 any = v23 -_ = v33 -var v34 any = v28 -_ = v34 -var v35 any = v17 -_ = v35 -var v37 any = v37 -_ = v37 -var v38 any = v38 -_ = v38 -var v39 any -for { -var v40 any = v40 -_ = v40 -var v41 any = v38 -_ = v41 -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("seq")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.Apply(v45, []any{v41}) -var v42 any = v46 -_ = v42 -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("first")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v42}) -var v47 any = v51 -_ = v47 -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("next")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) -} -v55 := v54.Get() -v56 := lang.Apply(v55, []any{v52}) -var v52 any = v56 -_ = v52 -var v57 any = v47 -_ = v57 -var v58 any = v52 -_ = v58 -var v59 any = v41 -_ = v59 -var v61 any -if lang.IsTruthy(v59) { -var v62 any -v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v64 := v63.FindInternedVar(lang.NewSymbol("contains?")) -if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) -} -v65 := v64.Get() -v66 := lang.Apply(v65, []any{v40, v57}) -if lang.IsTruthy(v66) { -v62 = false -} else { -v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v69 := v68.FindInternedVar(lang.NewSymbol("conj")) -if v69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) -} -v70 := v69.Get() -v71 := lang.Apply(v70, []any{v40, v57}) -var v67 any = v71 -var v72 any = v58 -v37 = v67 -v38 = v72 -continue -} -v61 = v62 -} else { -v61 = true -} -v39 = v61 - break -} -v7 = v39 -} else { -v7 = false -} -return v7 - } -}) -v4 := reflect.TypeOf(false) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// doall -{ -v0 := lang.NewSymbol("doall").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "When lazy sequences are produced via functions that have side\n effects, any effects other than those needed to produce the first\n element in the seq do not occur until the seq is consumed. doall can\n be used to force any effects. Walks through the successive nexts of\n the seq, retains the head and returns it, thus causing the entire\n seq to reside in memory at one time.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3131), lang.NewKeyword("end-line"), int(3131))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("dorun")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{v3}) -_ = v7 -return v3 - case 2: -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("dorun")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3, v4}) -_ = v8 -return v4 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// dorun -{ -v0 := lang.NewSymbol("dorun").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "When lazy sequences are produced via functions that have side\n effects, any effects other than those needed to produce the first\n element in the seq do not occur until the seq is consumed. dorun can\n be used to force any effects. Walks through the successive nexts of\n the seq, does not retain the head and returns nil.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3116), lang.NewKeyword("end-line"), int(3116))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -recur_loop_579: -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -var v4 any = v8 -_ = v4 -var v10 any -if lang.IsTruthy(v4) { -var v11 any = v4 -_ = v11 -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("next")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v11}) -var v13 any = v17 -v3 = v13 -goto recur_loop_579 -} else { -v10 = nil -} -return v10 - case 2: -v3 := args[0] -v4 := args[1] -recur_loop_580: -var v5 any -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("seq")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v4}) -var v6 any = v10 -_ = v6 -var v12 any -if lang.IsTruthy(v6) { -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("pos?")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v3}) -v12 = v16 -} else { -v12 = v6 -} -if lang.IsTruthy(v12) { -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("dec")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v3}) -var v6 any = v10 -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("next")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v4}) -var v11 any = v15 -v3 = v6 -v4 = v11 -goto recur_loop_580 -} else { -v5 = nil -} -return v5 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// doseq -{ -v0 := lang.NewSymbol("doseq").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("seq-exprs"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Repeatedly executes body (presumably for side-effects) with\n bindings and filtering as provided by \"for\". Does not retain\n the head of the sequence. Returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3209), lang.NewKeyword("end-line"), int(3209))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -var v7 any -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v5}) -if lang.IsTruthy(v11) { -v7 = nil -} else { -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("str")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("first")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v3}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("meta")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) -v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) -v28 := lang.Apply(lang.NewIllegalArgumentError, []any{v27}) -panic(v28) -} -_ = v7 -var v29 any -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("even?")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("count")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v5}) -v37 := lang.Apply(v32, []any{v36}) -if lang.IsTruthy(v37) { -v29 = nil -} else { -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("str")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("first")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v3}) -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("meta")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v3}) -v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) -v53 := lang.Apply(v40, []any{v44, " requires ", "an even number of forms in binding vector", " in ", v47, ":", v52}) -v54 := lang.Apply(lang.NewIllegalArgumentError, []any{v53}) -panic(v54) -} -_ = v29 -_ = nil -var v56 lang.FnFunc -{ // function step -v56 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v58 := args[0] -v59 := args[1] -var v60 any -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("not")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) -} -v63 := v62.Get() -v64 := lang.Apply(v63, []any{v59}) -if lang.IsTruthy(v64) { -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("seq")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) -} -v67 := v66.Get() -v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v69 := v68.FindInternedVar(lang.NewSymbol("concat")) -if v69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) -} -v70 := v69.Get() -v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v72 := v71.FindInternedVar(lang.NewSymbol("list")) -if v72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) -} -v73 := v72.Get() -v74 := lang.Apply(v73, []any{lang.NewSymbol("do")}) -v75 := lang.Apply(v70, []any{v74, v6}) -v76 := lang.Apply(v67, []any{v75}) -v77 := lang.NewVector(true, v76) -v78 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3220), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(3220), lang.NewKeyword("end-column"), int(36)) -v79, err := lang.WithMeta(v77, v78.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v60 = v79 -} else { -v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v82 := v81.FindInternedVar(lang.NewSymbol("first")) -if v82.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) -} -v83 := v82.Get() -v84 := lang.Apply(v83, []any{v59}) -var v80 any = v84 -_ = v80 -v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v87 := v86.FindInternedVar(lang.NewSymbol("second")) -if v87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) -} -v88 := v87.Get() -v89 := lang.Apply(v88, []any{v59}) -var v85 any = v89 -_ = v85 -var v91 any -v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v93 := v92.FindInternedVar(lang.NewSymbol("keyword?")) -if v93.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) -} -v94 := v93.Get() -v95 := lang.Apply(v94, []any{v80}) -if lang.IsTruthy(v95) { -v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v98 := v97.FindInternedVar(lang.NewSymbol("nnext")) -if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) -} -v99 := v98.Get() -v100 := lang.Apply(v99, []any{v59}) -v101 := lang.Apply(v57, []any{v58, v100}) -var v96 any = v101 -_ = v96 -v103 := lang.Apply(v96, []any{int64(0)}) -var v102 any = v103 -_ = v102 -v105 := lang.Apply(v96, []any{int64(1)}) -var v104 any = v105 -_ = v104 -var v107 any -v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v109 := v108.FindInternedVar(lang.NewSymbol("=")) -if v109.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) -} -v110 := v109.Get() -v111 := lang.Apply(v110, []any{v80, lang.NewKeyword("let")}) -if lang.IsTruthy(v111) { -v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v113 := v112.FindInternedVar(lang.NewSymbol("seq")) -if v113.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) -} -v114 := v113.Get() -v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v116 := v115.FindInternedVar(lang.NewSymbol("concat")) -if v116.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) -} -v117 := v116.Get() -v118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v119 := v118.FindInternedVar(lang.NewSymbol("list")) -if v119.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v119))) -} -v120 := v119.Get() -v121 := lang.Apply(v120, []any{lang.NewSymbol("glojure.core/let")}) -v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v123 := v122.FindInternedVar(lang.NewSymbol("list")) -if v123.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) -} -v124 := v123.Get() -v125 := lang.Apply(v124, []any{v85}) -v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v127 := v126.FindInternedVar(lang.NewSymbol("list")) -if v127.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) -} -v128 := v127.Get() -v129 := lang.Apply(v128, []any{v104}) -v130 := lang.Apply(v117, []any{v121, v125, v129}) -v131 := lang.Apply(v114, []any{v130}) -v132 := lang.NewVector(v102, v131) -v133 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3228), lang.NewKeyword("column"), int(37), lang.NewKeyword("end-line"), int(3228), lang.NewKeyword("end-column"), int(64)) -v134, err := lang.WithMeta(v132, v133.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v107 = v134 -} else { -var v135 any -v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v137 := v136.FindInternedVar(lang.NewSymbol("=")) -if v137.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) -} -v138 := v137.Get() -v139 := lang.Apply(v138, []any{v80, lang.NewKeyword("while")}) -if lang.IsTruthy(v139) { -v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v141 := v140.FindInternedVar(lang.NewSymbol("seq")) -if v141.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) -} -v142 := v141.Get() -v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v144 := v143.FindInternedVar(lang.NewSymbol("concat")) -if v144.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) -} -v145 := v144.Get() -v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v147 := v146.FindInternedVar(lang.NewSymbol("list")) -if v147.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) -} -v148 := v147.Get() -v149 := lang.Apply(v148, []any{lang.NewSymbol("glojure.core/when")}) -v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v151 := v150.FindInternedVar(lang.NewSymbol("list")) -if v151.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) -} -v152 := v151.Get() -v153 := lang.Apply(v152, []any{v85}) -v154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v155 := v154.FindInternedVar(lang.NewSymbol("list")) -if v155.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v155))) -} -v156 := v155.Get() -v157 := lang.Apply(v156, []any{v104}) -var v158 any -if lang.IsTruthy(v102) { -v159 := lang.NewVector(v58) -v160 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3231), lang.NewKeyword("column"), int(65), lang.NewKeyword("end-line"), int(3231), lang.NewKeyword("end-column"), int(73)) -v161, err := lang.WithMeta(v159, v160.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v158 = v161 -} else { -v158 = nil -} -v162 := lang.Apply(v145, []any{v149, v153, v157, v158}) -v163 := lang.Apply(v142, []any{v162}) -v164 := lang.NewVector(false, v163) -v165 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3229), lang.NewKeyword("column"), int(39), lang.NewKeyword("end-line"), int(3231), lang.NewKeyword("end-column"), int(76)) -v166, err := lang.WithMeta(v164, v165.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v135 = v166 -} else { -var v167 any -v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v169 := v168.FindInternedVar(lang.NewSymbol("=")) -if v169.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) -} -v170 := v169.Get() -v171 := lang.Apply(v170, []any{v80, lang.NewKeyword("when")}) -if lang.IsTruthy(v171) { -v172 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v173 := v172.FindInternedVar(lang.NewSymbol("seq")) -if v173.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v173))) -} -v174 := v173.Get() -v175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v176 := v175.FindInternedVar(lang.NewSymbol("concat")) -if v176.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v176))) -} -v177 := v176.Get() -v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v179 := v178.FindInternedVar(lang.NewSymbol("list")) -if v179.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) -} -v180 := v179.Get() -v181 := lang.Apply(v180, []any{lang.NewSymbol("if")}) -v182 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v183 := v182.FindInternedVar(lang.NewSymbol("list")) -if v183.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v183))) -} -v184 := v183.Get() -v185 := lang.Apply(v184, []any{v85}) -v186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v187 := v186.FindInternedVar(lang.NewSymbol("list")) -if v187.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v187))) -} -v188 := v187.Get() -v189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v190 := v189.FindInternedVar(lang.NewSymbol("seq")) -if v190.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v190))) -} -v191 := v190.Get() -v192 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v193 := v192.FindInternedVar(lang.NewSymbol("concat")) -if v193.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v193))) -} -v194 := v193.Get() -v195 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v196 := v195.FindInternedVar(lang.NewSymbol("list")) -if v196.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v196))) -} -v197 := v196.Get() -v198 := lang.Apply(v197, []any{lang.NewSymbol("do")}) -v199 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v200 := v199.FindInternedVar(lang.NewSymbol("list")) -if v200.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v200))) -} -v201 := v200.Get() -v202 := lang.Apply(v201, []any{v104}) -var v203 any -if lang.IsTruthy(v102) { -v204 := lang.NewVector(v58) -v205 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3235), lang.NewKeyword("column"), int(66), lang.NewKeyword("end-line"), int(3235), lang.NewKeyword("end-column"), int(74)) -v206, err := lang.WithMeta(v204, v205.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v203 = v206 -} else { -v203 = nil -} -v207 := lang.Apply(v194, []any{v198, v202, v203}) -v208 := lang.Apply(v191, []any{v207}) -v209 := lang.Apply(v188, []any{v208}) -v210 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v211 := v210.FindInternedVar(lang.NewSymbol("list")) -if v211.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v211))) -} -v212 := v211.Get() -v213 := lang.Apply(v212, []any{v58}) -v214 := lang.Apply(v177, []any{v181, v185, v209, v213}) -v215 := lang.Apply(v174, []any{v214}) -v216 := lang.NewVector(false, v215) -v217 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3232), lang.NewKeyword("column"), int(38), lang.NewKeyword("end-line"), int(3236), lang.NewKeyword("end-column"), int(57)) -v218, err := lang.WithMeta(v216, v217.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v167 = v218 -} else { -v167 = nil -} -v135 = v167 -} -v107 = v135 -} -v91 = v107 -} else { -v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v98 := v97.FindInternedVar(lang.NewSymbol("gensym")) -if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) -} -v99 := v98.Get() -v100 := lang.Apply(v99, []any{"seq_"}) -var v96 any = v100 -_ = v96 -v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v103 := v102.FindInternedVar(lang.NewSymbol("with-meta")) -if v103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) -} -v104 := v103.Get() -v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v106 := v105.FindInternedVar(lang.NewSymbol("gensym")) -if v106.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) -} -v107 := v106.Get() -v108 := lang.Apply(v107, []any{"chunk_"}) -v109 := lang.NewMap(lang.NewKeyword("tag"), lang.NewSymbol("glojure.lang.IChunk")) -v110 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3239), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(3239), lang.NewKeyword("end-column"), int(72)) -v111, err := lang.WithMeta(v109, v110.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v112 := lang.Apply(v104, []any{v108, v111}) -var v101 any = v112 -_ = v101 -v114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v115 := v114.FindInternedVar(lang.NewSymbol("gensym")) -if v115.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v115))) -} -v116 := v115.Get() -v117 := lang.Apply(v116, []any{"count_"}) -var v113 any = v117 -_ = v113 -v119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v120 := v119.FindInternedVar(lang.NewSymbol("gensym")) -if v120.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v120))) -} -v121 := v120.Get() -v122 := lang.Apply(v121, []any{"i_"}) -var v118 any = v122 -_ = v118 -v124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v125 := v124.FindInternedVar(lang.NewSymbol("seq")) -if v125.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v125))) -} -v126 := v125.Get() -v127 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v128 := v127.FindInternedVar(lang.NewSymbol("concat")) -if v128.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v128))) -} -v129 := v128.Get() -v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v131 := v130.FindInternedVar(lang.NewSymbol("list")) -if v131.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) -} -v132 := v131.Get() -v133 := lang.Apply(v132, []any{lang.NewSymbol("recur")}) -v134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v135 := v134.FindInternedVar(lang.NewSymbol("list")) -if v135.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v135))) -} -v136 := v135.Get() -v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v138 := v137.FindInternedVar(lang.NewSymbol("seq")) -if v138.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) -} -v139 := v138.Get() -v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v141 := v140.FindInternedVar(lang.NewSymbol("concat")) -if v141.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) -} -v142 := v141.Get() -v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v144 := v143.FindInternedVar(lang.NewSymbol("list")) -if v144.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) -} -v145 := v144.Get() -v146 := lang.Apply(v145, []any{lang.NewSymbol("glojure.core/next")}) -v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v148 := v147.FindInternedVar(lang.NewSymbol("list")) -if v148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) -} -v149 := v148.Get() -v150 := lang.Apply(v149, []any{v96}) -v151 := lang.Apply(v142, []any{v146, v150}) -v152 := lang.Apply(v139, []any{v151}) -v153 := lang.Apply(v136, []any{v152}) -v154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v155 := v154.FindInternedVar(lang.NewSymbol("list")) -if v155.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v155))) -} -v156 := v155.Get() -v157 := lang.Apply(v156, []any{nil}) -v158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v159 := v158.FindInternedVar(lang.NewSymbol("list")) -if v159.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v159))) -} -v160 := v159.Get() -v161 := lang.Apply(v160, []any{int64(0)}) -v162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v163 := v162.FindInternedVar(lang.NewSymbol("list")) -if v163.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v163))) -} -v164 := v163.Get() -v165 := lang.Apply(v164, []any{int64(0)}) -v166 := lang.Apply(v129, []any{v133, v153, v157, v161, v165}) -v167 := lang.Apply(v126, []any{v166}) -var v123 any = v167 -_ = v123 -v169 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v170 := v169.FindInternedVar(lang.NewSymbol("nnext")) -if v170.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v170))) -} -v171 := v170.Get() -v172 := lang.Apply(v171, []any{v59}) -v173 := lang.Apply(v57, []any{v123, v172}) -var v168 any = v173 -_ = v168 -v175 := lang.Apply(v168, []any{int64(0)}) -var v174 any = v175 -_ = v174 -v177 := lang.Apply(v168, []any{int64(1)}) -var v176 any = v177 -_ = v176 -v179 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v180 := v179.FindInternedVar(lang.NewSymbol("seq")) -if v180.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v180))) -} -v181 := v180.Get() -v182 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v183 := v182.FindInternedVar(lang.NewSymbol("concat")) -if v183.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v183))) -} -v184 := v183.Get() -v185 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v186 := v185.FindInternedVar(lang.NewSymbol("list")) -if v186.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v186))) -} -v187 := v186.Get() -v188 := lang.Apply(v187, []any{lang.NewSymbol("recur")}) -v189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v190 := v189.FindInternedVar(lang.NewSymbol("list")) -if v190.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v190))) -} -v191 := v190.Get() -v192 := lang.Apply(v191, []any{v96}) -v193 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v194 := v193.FindInternedVar(lang.NewSymbol("list")) -if v194.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v194))) -} -v195 := v194.Get() -v196 := lang.Apply(v195, []any{v101}) -v197 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v198 := v197.FindInternedVar(lang.NewSymbol("list")) -if v198.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v198))) -} -v199 := v198.Get() -v200 := lang.Apply(v199, []any{v113}) -v201 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v202 := v201.FindInternedVar(lang.NewSymbol("list")) -if v202.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v202))) -} -v203 := v202.Get() -v204 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v205 := v204.FindInternedVar(lang.NewSymbol("seq")) -if v205.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v205))) -} -v206 := v205.Get() -v207 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v208 := v207.FindInternedVar(lang.NewSymbol("concat")) -if v208.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v208))) -} -v209 := v208.Get() -v210 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v211 := v210.FindInternedVar(lang.NewSymbol("list")) -if v211.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v211))) -} -v212 := v211.Get() -v213 := lang.Apply(v212, []any{lang.NewSymbol("glojure.core/unchecked-inc")}) -v214 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v215 := v214.FindInternedVar(lang.NewSymbol("list")) -if v215.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v215))) -} -v216 := v215.Get() -v217 := lang.Apply(v216, []any{v118}) -v218 := lang.Apply(v209, []any{v213, v217}) -v219 := lang.Apply(v206, []any{v218}) -v220 := lang.Apply(v203, []any{v219}) -v221 := lang.Apply(v184, []any{v188, v192, v196, v200, v220}) -v222 := lang.Apply(v181, []any{v221}) -var v178 any = v222 -_ = v178 -v224 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v225 := v224.FindInternedVar(lang.NewSymbol("nnext")) -if v225.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v225))) -} -v226 := v225.Get() -v227 := lang.Apply(v226, []any{v59}) -v228 := lang.Apply(v57, []any{v178, v227}) -var v223 any = v228 -_ = v223 -v230 := lang.Apply(v223, []any{int64(1)}) -var v229 any = v230 -_ = v229 -v232 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v233 := v232.FindInternedVar(lang.NewSymbol("seq")) -if v233.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v233))) -} -v234 := v233.Get() -v235 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v236 := v235.FindInternedVar(lang.NewSymbol("concat")) -if v236.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v236))) -} -v237 := v236.Get() -v238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v239 := v238.FindInternedVar(lang.NewSymbol("list")) -if v239.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v239))) -} -v240 := v239.Get() -v241 := lang.Apply(v240, []any{lang.NewSymbol("glojure.core/loop")}) -v242 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v243 := v242.FindInternedVar(lang.NewSymbol("list")) -if v243.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v243))) -} -v244 := v243.Get() -v245 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v246 := v245.FindInternedVar(lang.NewSymbol("apply")) -if v246.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v246))) -} -v247 := v246.Get() -v248 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v249 := v248.FindInternedVar(lang.NewSymbol("vector")) -if v249.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v249))) -} -v250 := v249.Get() -v251 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v252 := v251.FindInternedVar(lang.NewSymbol("seq")) -if v252.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v252))) -} -v253 := v252.Get() -v254 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v255 := v254.FindInternedVar(lang.NewSymbol("concat")) -if v255.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v255))) -} -v256 := v255.Get() -v257 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v258 := v257.FindInternedVar(lang.NewSymbol("list")) -if v258.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v258))) -} -v259 := v258.Get() -v260 := lang.Apply(v259, []any{v96}) -v261 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v262 := v261.FindInternedVar(lang.NewSymbol("list")) -if v262.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v262))) -} -v263 := v262.Get() -v264 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v265 := v264.FindInternedVar(lang.NewSymbol("seq")) -if v265.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v265))) -} -v266 := v265.Get() -v267 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v268 := v267.FindInternedVar(lang.NewSymbol("concat")) -if v268.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v268))) -} -v269 := v268.Get() -v270 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v271 := v270.FindInternedVar(lang.NewSymbol("list")) -if v271.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v271))) -} -v272 := v271.Get() -v273 := lang.Apply(v272, []any{lang.NewSymbol("glojure.core/seq")}) -v274 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v275 := v274.FindInternedVar(lang.NewSymbol("list")) -if v275.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v275))) -} -v276 := v275.Get() -v277 := lang.Apply(v276, []any{v85}) -v278 := lang.Apply(v269, []any{v273, v277}) -v279 := lang.Apply(v266, []any{v278}) -v280 := lang.Apply(v263, []any{v279}) -v281 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v282 := v281.FindInternedVar(lang.NewSymbol("list")) -if v282.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v282))) -} -v283 := v282.Get() -v284 := lang.Apply(v283, []any{v101}) -v285 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v286 := v285.FindInternedVar(lang.NewSymbol("list")) -if v286.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v286))) -} -v287 := v286.Get() -v288 := lang.Apply(v287, []any{nil}) -v289 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v290 := v289.FindInternedVar(lang.NewSymbol("list")) -if v290.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v290))) -} -v291 := v290.Get() -v292 := lang.Apply(v291, []any{v113}) -v293 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v294 := v293.FindInternedVar(lang.NewSymbol("list")) -if v294.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v294))) -} -v295 := v294.Get() -v296 := lang.Apply(v295, []any{int64(0)}) -v297 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v298 := v297.FindInternedVar(lang.NewSymbol("list")) -if v298.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v298))) -} -v299 := v298.Get() -v300 := lang.Apply(v299, []any{v118}) -v301 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v302 := v301.FindInternedVar(lang.NewSymbol("list")) -if v302.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v302))) -} -v303 := v302.Get() -v304 := lang.Apply(v303, []any{int64(0)}) -v305 := lang.Apply(v256, []any{v260, v280, v284, v288, v292, v296, v300, v304}) -v306 := lang.Apply(v253, []any{v305}) -v307 := lang.Apply(v247, []any{v250, v306}) -v308 := lang.Apply(v244, []any{v307}) -v309 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v310 := v309.FindInternedVar(lang.NewSymbol("list")) -if v310.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v310))) -} -v311 := v310.Get() -v312 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v313 := v312.FindInternedVar(lang.NewSymbol("seq")) -if v313.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v313))) -} -v314 := v313.Get() -v315 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v316 := v315.FindInternedVar(lang.NewSymbol("concat")) -if v316.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v316))) -} -v317 := v316.Get() -v318 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v319 := v318.FindInternedVar(lang.NewSymbol("list")) -if v319.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v319))) -} -v320 := v319.Get() -v321 := lang.Apply(v320, []any{lang.NewSymbol("if")}) -v322 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v323 := v322.FindInternedVar(lang.NewSymbol("list")) -if v323.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v323))) -} -v324 := v323.Get() -v325 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v326 := v325.FindInternedVar(lang.NewSymbol("seq")) -if v326.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v326))) -} -v327 := v326.Get() -v328 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v329 := v328.FindInternedVar(lang.NewSymbol("concat")) -if v329.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v329))) -} -v330 := v329.Get() -v331 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v332 := v331.FindInternedVar(lang.NewSymbol("list")) -if v332.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v332))) -} -v333 := v332.Get() -v334 := lang.Apply(v333, []any{lang.NewSymbol("glojure.core/<")}) -v335 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v336 := v335.FindInternedVar(lang.NewSymbol("list")) -if v336.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v336))) -} -v337 := v336.Get() -v338 := lang.Apply(v337, []any{v118}) -v339 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v340 := v339.FindInternedVar(lang.NewSymbol("list")) -if v340.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v340))) -} -v341 := v340.Get() -v342 := lang.Apply(v341, []any{v113}) -v343 := lang.Apply(v330, []any{v334, v338, v342}) -v344 := lang.Apply(v327, []any{v343}) -v345 := lang.Apply(v324, []any{v344}) -v346 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v347 := v346.FindInternedVar(lang.NewSymbol("list")) -if v347.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v347))) -} -v348 := v347.Get() -v349 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v350 := v349.FindInternedVar(lang.NewSymbol("seq")) -if v350.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v350))) -} -v351 := v350.Get() -v352 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v353 := v352.FindInternedVar(lang.NewSymbol("concat")) -if v353.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v353))) -} -v354 := v353.Get() -v355 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v356 := v355.FindInternedVar(lang.NewSymbol("list")) -if v356.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v356))) -} -v357 := v356.Get() -v358 := lang.Apply(v357, []any{lang.NewSymbol("glojure.core/let")}) -v359 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v360 := v359.FindInternedVar(lang.NewSymbol("list")) -if v360.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v360))) -} -v361 := v360.Get() -v362 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v363 := v362.FindInternedVar(lang.NewSymbol("apply")) -if v363.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v363))) -} -v364 := v363.Get() -v365 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v366 := v365.FindInternedVar(lang.NewSymbol("vector")) -if v366.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v366))) -} -v367 := v366.Get() -v368 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v369 := v368.FindInternedVar(lang.NewSymbol("seq")) -if v369.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v369))) -} -v370 := v369.Get() -v371 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v372 := v371.FindInternedVar(lang.NewSymbol("concat")) -if v372.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v372))) -} -v373 := v372.Get() -v374 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v375 := v374.FindInternedVar(lang.NewSymbol("list")) -if v375.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v375))) -} -v376 := v375.Get() -v377 := lang.Apply(v376, []any{v80}) -v378 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v379 := v378.FindInternedVar(lang.NewSymbol("list")) -if v379.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v379))) -} -v380 := v379.Get() -v381 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v382 := v381.FindInternedVar(lang.NewSymbol("seq")) -if v382.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v382))) -} -v383 := v382.Get() -v384 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v385 := v384.FindInternedVar(lang.NewSymbol("concat")) -if v385.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v385))) -} -v386 := v385.Get() -v387 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v388 := v387.FindInternedVar(lang.NewSymbol("list")) -if v388.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v388))) -} -v389 := v388.Get() -v390 := lang.Apply(v389, []any{lang.NewSymbol(".nth")}) -v391 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v392 := v391.FindInternedVar(lang.NewSymbol("list")) -if v392.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v392))) -} -v393 := v392.Get() -v394 := lang.Apply(v393, []any{v101}) -v395 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v396 := v395.FindInternedVar(lang.NewSymbol("list")) -if v396.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v396))) -} -v397 := v396.Get() -v398 := lang.Apply(v397, []any{v118}) -v399 := lang.Apply(v386, []any{v390, v394, v398}) -v400 := lang.Apply(v383, []any{v399}) -v401 := lang.Apply(v380, []any{v400}) -v402 := lang.Apply(v373, []any{v377, v401}) -v403 := lang.Apply(v370, []any{v402}) -v404 := lang.Apply(v364, []any{v367, v403}) -v405 := lang.Apply(v361, []any{v404}) -v406 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v407 := v406.FindInternedVar(lang.NewSymbol("list")) -if v407.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v407))) -} -v408 := v407.Get() -v409 := lang.Apply(v408, []any{v229}) -var v410 any -if lang.IsTruthy(v174) { -v411 := lang.NewVector(v178) -v412 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3256), lang.NewKeyword("column"), int(48), lang.NewKeyword("end-line"), int(3256), lang.NewKeyword("end-column"), int(62)) -v413, err := lang.WithMeta(v411, v412.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v410 = v413 -} else { -v410 = nil -} -v414 := lang.Apply(v354, []any{v358, v405, v409, v410}) -v415 := lang.Apply(v351, []any{v414}) -v416 := lang.Apply(v348, []any{v415}) -v417 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v418 := v417.FindInternedVar(lang.NewSymbol("list")) -if v418.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v418))) -} -v419 := v418.Get() -v420 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v421 := v420.FindInternedVar(lang.NewSymbol("seq")) -if v421.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v421))) -} -v422 := v421.Get() -v423 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v424 := v423.FindInternedVar(lang.NewSymbol("concat")) -if v424.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v424))) -} -v425 := v424.Get() -v426 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v427 := v426.FindInternedVar(lang.NewSymbol("list")) -if v427.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v427))) -} -v428 := v427.Get() -v429 := lang.Apply(v428, []any{lang.NewSymbol("glojure.core/when-let")}) -v430 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v431 := v430.FindInternedVar(lang.NewSymbol("list")) -if v431.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v431))) -} -v432 := v431.Get() -v433 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v434 := v433.FindInternedVar(lang.NewSymbol("apply")) -if v434.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v434))) -} -v435 := v434.Get() -v436 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v437 := v436.FindInternedVar(lang.NewSymbol("vector")) -if v437.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v437))) -} -v438 := v437.Get() -v439 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v440 := v439.FindInternedVar(lang.NewSymbol("seq")) -if v440.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v440))) -} -v441 := v440.Get() -v442 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v443 := v442.FindInternedVar(lang.NewSymbol("concat")) -if v443.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v443))) -} -v444 := v443.Get() -v445 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v446 := v445.FindInternedVar(lang.NewSymbol("list")) -if v446.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v446))) -} -v447 := v446.Get() -v448 := lang.Apply(v447, []any{v96}) -v449 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v450 := v449.FindInternedVar(lang.NewSymbol("list")) -if v450.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v450))) -} -v451 := v450.Get() -v452 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v453 := v452.FindInternedVar(lang.NewSymbol("seq")) -if v453.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v453))) -} -v454 := v453.Get() -v455 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v456 := v455.FindInternedVar(lang.NewSymbol("concat")) -if v456.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v456))) -} -v457 := v456.Get() -v458 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v459 := v458.FindInternedVar(lang.NewSymbol("list")) -if v459.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v459))) -} -v460 := v459.Get() -v461 := lang.Apply(v460, []any{lang.NewSymbol("glojure.core/seq")}) -v462 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v463 := v462.FindInternedVar(lang.NewSymbol("list")) -if v463.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v463))) -} -v464 := v463.Get() -v465 := lang.Apply(v464, []any{v96}) -v466 := lang.Apply(v457, []any{v461, v465}) -v467 := lang.Apply(v454, []any{v466}) -v468 := lang.Apply(v451, []any{v467}) -v469 := lang.Apply(v444, []any{v448, v468}) -v470 := lang.Apply(v441, []any{v469}) -v471 := lang.Apply(v435, []any{v438, v470}) -v472 := lang.Apply(v432, []any{v471}) -v473 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v474 := v473.FindInternedVar(lang.NewSymbol("list")) -if v474.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v474))) -} -v475 := v474.Get() -v476 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v477 := v476.FindInternedVar(lang.NewSymbol("seq")) -if v477.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v477))) -} -v478 := v477.Get() -v479 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v480 := v479.FindInternedVar(lang.NewSymbol("concat")) -if v480.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v480))) -} -v481 := v480.Get() -v482 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v483 := v482.FindInternedVar(lang.NewSymbol("list")) -if v483.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v483))) -} -v484 := v483.Get() -v485 := lang.Apply(v484, []any{lang.NewSymbol("if")}) -v486 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v487 := v486.FindInternedVar(lang.NewSymbol("list")) -if v487.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v487))) -} -v488 := v487.Get() -v489 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v490 := v489.FindInternedVar(lang.NewSymbol("seq")) -if v490.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v490))) -} -v491 := v490.Get() -v492 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v493 := v492.FindInternedVar(lang.NewSymbol("concat")) -if v493.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v493))) -} -v494 := v493.Get() -v495 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v496 := v495.FindInternedVar(lang.NewSymbol("list")) -if v496.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v496))) -} -v497 := v496.Get() -v498 := lang.Apply(v497, []any{lang.NewSymbol("glojure.core/chunked-seq?")}) -v499 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v500 := v499.FindInternedVar(lang.NewSymbol("list")) -if v500.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v500))) -} -v501 := v500.Get() -v502 := lang.Apply(v501, []any{v96}) -v503 := lang.Apply(v494, []any{v498, v502}) -v504 := lang.Apply(v491, []any{v503}) -v505 := lang.Apply(v488, []any{v504}) -v506 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v507 := v506.FindInternedVar(lang.NewSymbol("list")) -if v507.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v507))) -} -v508 := v507.Get() -v509 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v510 := v509.FindInternedVar(lang.NewSymbol("seq")) -if v510.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v510))) -} -v511 := v510.Get() -v512 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v513 := v512.FindInternedVar(lang.NewSymbol("concat")) -if v513.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v513))) -} -v514 := v513.Get() -v515 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v516 := v515.FindInternedVar(lang.NewSymbol("list")) -if v516.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v516))) -} -v517 := v516.Get() -v518 := lang.Apply(v517, []any{lang.NewSymbol("glojure.core/let")}) -v519 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v520 := v519.FindInternedVar(lang.NewSymbol("list")) -if v520.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v520))) -} -v521 := v520.Get() -v522 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v523 := v522.FindInternedVar(lang.NewSymbol("apply")) -if v523.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v523))) -} -v524 := v523.Get() -v525 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v526 := v525.FindInternedVar(lang.NewSymbol("vector")) -if v526.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v526))) -} -v527 := v526.Get() -v528 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v529 := v528.FindInternedVar(lang.NewSymbol("seq")) -if v529.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v529))) -} -v530 := v529.Get() -v531 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v532 := v531.FindInternedVar(lang.NewSymbol("concat")) -if v532.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v532))) -} -v533 := v532.Get() -v534 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v535 := v534.FindInternedVar(lang.NewSymbol("list")) -if v535.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v535))) -} -v536 := v535.Get() -v537 := lang.Apply(v536, []any{lang.NewSymbol("c__0__auto__")}) -v538 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v539 := v538.FindInternedVar(lang.NewSymbol("list")) -if v539.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v539))) -} -v540 := v539.Get() -v541 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v542 := v541.FindInternedVar(lang.NewSymbol("seq")) -if v542.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v542))) -} -v543 := v542.Get() -v544 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v545 := v544.FindInternedVar(lang.NewSymbol("concat")) -if v545.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v545))) -} -v546 := v545.Get() -v547 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v548 := v547.FindInternedVar(lang.NewSymbol("list")) -if v548.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v548))) -} -v549 := v548.Get() -v550 := lang.Apply(v549, []any{lang.NewSymbol("glojure.core/chunk-first")}) -v551 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v552 := v551.FindInternedVar(lang.NewSymbol("list")) -if v552.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v552))) -} -v553 := v552.Get() -v554 := lang.Apply(v553, []any{v96}) -v555 := lang.Apply(v546, []any{v550, v554}) -v556 := lang.Apply(v543, []any{v555}) -v557 := lang.Apply(v540, []any{v556}) -v558 := lang.Apply(v533, []any{v537, v557}) -v559 := lang.Apply(v530, []any{v558}) -v560 := lang.Apply(v524, []any{v527, v559}) -v561 := lang.Apply(v521, []any{v560}) -v562 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v563 := v562.FindInternedVar(lang.NewSymbol("list")) -if v563.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v563))) -} -v564 := v563.Get() -v565 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v566 := v565.FindInternedVar(lang.NewSymbol("seq")) -if v566.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v566))) -} -v567 := v566.Get() -v568 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v569 := v568.FindInternedVar(lang.NewSymbol("concat")) -if v569.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v569))) -} -v570 := v569.Get() -v571 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v572 := v571.FindInternedVar(lang.NewSymbol("list")) -if v572.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v572))) -} -v573 := v572.Get() -v574 := lang.Apply(v573, []any{lang.NewSymbol("recur")}) -v575 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v576 := v575.FindInternedVar(lang.NewSymbol("list")) -if v576.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v576))) -} -v577 := v576.Get() -v578 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v579 := v578.FindInternedVar(lang.NewSymbol("seq")) -if v579.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v579))) -} -v580 := v579.Get() -v581 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v582 := v581.FindInternedVar(lang.NewSymbol("concat")) -if v582.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v582))) -} -v583 := v582.Get() -v584 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v585 := v584.FindInternedVar(lang.NewSymbol("list")) -if v585.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v585))) -} -v586 := v585.Get() -v587 := lang.Apply(v586, []any{lang.NewSymbol("glojure.core/chunk-rest")}) -v588 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v589 := v588.FindInternedVar(lang.NewSymbol("list")) -if v589.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v589))) -} -v590 := v589.Get() -v591 := lang.Apply(v590, []any{v96}) -v592 := lang.Apply(v583, []any{v587, v591}) -v593 := lang.Apply(v580, []any{v592}) -v594 := lang.Apply(v577, []any{v593}) -v595 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v596 := v595.FindInternedVar(lang.NewSymbol("list")) -if v596.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v596))) -} -v597 := v596.Get() -v598 := lang.Apply(v597, []any{lang.NewSymbol("c__0__auto__")}) -v599 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v600 := v599.FindInternedVar(lang.NewSymbol("list")) -if v600.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v600))) -} -v601 := v600.Get() -v602 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v603 := v602.FindInternedVar(lang.NewSymbol("seq")) -if v603.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v603))) -} -v604 := v603.Get() -v605 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v606 := v605.FindInternedVar(lang.NewSymbol("concat")) -if v606.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v606))) -} -v607 := v606.Get() -v608 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v609 := v608.FindInternedVar(lang.NewSymbol("list")) -if v609.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v609))) -} -v610 := v609.Get() -v611 := lang.Apply(v610, []any{lang.NewSymbol("glojure.core/int")}) -v612 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v613 := v612.FindInternedVar(lang.NewSymbol("list")) -if v613.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v613))) -} -v614 := v613.Get() -v615 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v616 := v615.FindInternedVar(lang.NewSymbol("seq")) -if v616.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v616))) -} -v617 := v616.Get() -v618 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v619 := v618.FindInternedVar(lang.NewSymbol("concat")) -if v619.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v619))) -} -v620 := v619.Get() -v621 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v622 := v621.FindInternedVar(lang.NewSymbol("list")) -if v622.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v622))) -} -v623 := v622.Get() -v624 := lang.Apply(v623, []any{lang.NewSymbol("glojure.core/count")}) -v625 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v626 := v625.FindInternedVar(lang.NewSymbol("list")) -if v626.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v626))) -} -v627 := v626.Get() -v628 := lang.Apply(v627, []any{lang.NewSymbol("c__0__auto__")}) -v629 := lang.Apply(v620, []any{v624, v628}) -v630 := lang.Apply(v617, []any{v629}) -v631 := lang.Apply(v614, []any{v630}) -v632 := lang.Apply(v607, []any{v611, v631}) -v633 := lang.Apply(v604, []any{v632}) -v634 := lang.Apply(v601, []any{v633}) -v635 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v636 := v635.FindInternedVar(lang.NewSymbol("list")) -if v636.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v636))) -} -v637 := v636.Get() -v638 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v639 := v638.FindInternedVar(lang.NewSymbol("seq")) -if v639.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v639))) -} -v640 := v639.Get() -v641 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v642 := v641.FindInternedVar(lang.NewSymbol("concat")) -if v642.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v642))) -} -v643 := v642.Get() -v644 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v645 := v644.FindInternedVar(lang.NewSymbol("list")) -if v645.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v645))) -} -v646 := v645.Get() -v647 := lang.Apply(v646, []any{lang.NewSymbol("glojure.core/int")}) -v648 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v649 := v648.FindInternedVar(lang.NewSymbol("list")) -if v649.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v649))) -} -v650 := v649.Get() -v651 := lang.Apply(v650, []any{int64(0)}) -v652 := lang.Apply(v643, []any{v647, v651}) -v653 := lang.Apply(v640, []any{v652}) -v654 := lang.Apply(v637, []any{v653}) -v655 := lang.Apply(v570, []any{v574, v594, v598, v634, v654}) -v656 := lang.Apply(v567, []any{v655}) -v657 := lang.Apply(v564, []any{v656}) -v658 := lang.Apply(v514, []any{v518, v561, v657}) -v659 := lang.Apply(v511, []any{v658}) -v660 := lang.Apply(v508, []any{v659}) -v661 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v662 := v661.FindInternedVar(lang.NewSymbol("list")) -if v662.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v662))) -} -v663 := v662.Get() -v664 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v665 := v664.FindInternedVar(lang.NewSymbol("seq")) -if v665.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v665))) -} -v666 := v665.Get() -v667 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v668 := v667.FindInternedVar(lang.NewSymbol("concat")) -if v668.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v668))) -} -v669 := v668.Get() -v670 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v671 := v670.FindInternedVar(lang.NewSymbol("list")) -if v671.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v671))) -} -v672 := v671.Get() -v673 := lang.Apply(v672, []any{lang.NewSymbol("glojure.core/let")}) -v674 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v675 := v674.FindInternedVar(lang.NewSymbol("list")) -if v675.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v675))) -} -v676 := v675.Get() -v677 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v678 := v677.FindInternedVar(lang.NewSymbol("apply")) -if v678.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v678))) -} -v679 := v678.Get() -v680 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v681 := v680.FindInternedVar(lang.NewSymbol("vector")) -if v681.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v681))) -} -v682 := v681.Get() -v683 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v684 := v683.FindInternedVar(lang.NewSymbol("seq")) -if v684.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v684))) -} -v685 := v684.Get() -v686 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v687 := v686.FindInternedVar(lang.NewSymbol("concat")) -if v687.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v687))) -} -v688 := v687.Get() -v689 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v690 := v689.FindInternedVar(lang.NewSymbol("list")) -if v690.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v690))) -} -v691 := v690.Get() -v692 := lang.Apply(v691, []any{v80}) -v693 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v694 := v693.FindInternedVar(lang.NewSymbol("list")) -if v694.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v694))) -} -v695 := v694.Get() -v696 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v697 := v696.FindInternedVar(lang.NewSymbol("seq")) -if v697.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v697))) -} -v698 := v697.Get() -v699 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v700 := v699.FindInternedVar(lang.NewSymbol("concat")) -if v700.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v700))) -} -v701 := v700.Get() -v702 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v703 := v702.FindInternedVar(lang.NewSymbol("list")) -if v703.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v703))) -} -v704 := v703.Get() -v705 := lang.Apply(v704, []any{lang.NewSymbol("glojure.core/first")}) -v706 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v707 := v706.FindInternedVar(lang.NewSymbol("list")) -if v707.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v707))) -} -v708 := v707.Get() -v709 := lang.Apply(v708, []any{v96}) -v710 := lang.Apply(v701, []any{v705, v709}) -v711 := lang.Apply(v698, []any{v710}) -v712 := lang.Apply(v695, []any{v711}) -v713 := lang.Apply(v688, []any{v692, v712}) -v714 := lang.Apply(v685, []any{v713}) -v715 := lang.Apply(v679, []any{v682, v714}) -v716 := lang.Apply(v676, []any{v715}) -v717 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v718 := v717.FindInternedVar(lang.NewSymbol("list")) -if v718.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v718))) -} -v719 := v718.Get() -v720 := lang.Apply(v719, []any{v176}) -var v721 any -if lang.IsTruthy(v174) { -v722 := lang.NewVector(v123) -v723 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3264), lang.NewKeyword("column"), int(52), lang.NewKeyword("end-line"), int(3264), lang.NewKeyword("end-column"), int(60)) -v724, err := lang.WithMeta(v722, v723.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v721 = v724 -} else { -v721 = nil -} -v725 := lang.Apply(v669, []any{v673, v716, v720, v721}) -v726 := lang.Apply(v666, []any{v725}) -v727 := lang.Apply(v663, []any{v726}) -v728 := lang.Apply(v481, []any{v485, v505, v660, v727}) -v729 := lang.Apply(v478, []any{v728}) -v730 := lang.Apply(v475, []any{v729}) -v731 := lang.Apply(v425, []any{v429, v472, v730}) -v732 := lang.Apply(v422, []any{v731}) -v733 := lang.Apply(v419, []any{v732}) -v734 := lang.Apply(v317, []any{v321, v345, v416, v733}) -v735 := lang.Apply(v314, []any{v734}) -v736 := lang.Apply(v311, []any{v735}) -v737 := lang.Apply(v237, []any{v241, v308, v736}) -v738 := lang.Apply(v234, []any{v737}) -v739 := lang.NewVector(true, v738) -v740 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3250), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(3264), lang.NewKeyword("end-column"), int(67)) -v741, err := lang.WithMeta(v739, v740.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v91 = v741 -} -v60 = v91 -} -return v60 -}) -v57 := v56 -_ = v57 -} -v57 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3218), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(3264), lang.NewKeyword("end-column"), int(72)) -v58, err := lang.WithMeta(v56, v57.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v55 any = v58 -_ = v55 -v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v61 := v60.FindInternedVar(lang.NewSymbol("nth")) -if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) -} -v62 := v61.Get() -v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v64 := v63.FindInternedVar(lang.NewSymbol("seq")) -if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) -} -v65 := v64.Get() -v66 := lang.Apply(v65, []any{v5}) -v67 := lang.Apply(v55, []any{nil, v66}) -v68 := lang.Apply(v62, []any{v67, int64(1)}) -return v68 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// dosync -{ -v0 := lang.NewSymbol("dosync").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("exprs"))), lang.NewKeyword("doc"), "Runs the exprs (in an implicit do) in a transaction that encompasses\n exprs and any nested calls. Starts a transaction if none is already\n running on this thread. Any uncaught exception will abort the\n transaction and flow out of dosync. The exprs may be run more than\n once, but any effects on Refs will be atomic.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5100), lang.NewKeyword("end-line"), int(5100))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("seq")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("concat")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("list")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{lang.NewSymbol("glojure.core/sync")}) -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("list")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{nil}) -v20 := lang.Apply(v11, []any{v15, v19, v5}) -v21 := lang.Apply(v8, []any{v20}) -return v21 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// dotimes -{ -v0 := lang.NewSymbol("dotimes").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "bindings => name n\n\n Repeatedly executes body (presumably for side-effects) with name\n bound to integers from 0 through n-1.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3306), lang.NewKeyword("end-line"), int(3306))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -var v7 any -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v5}) -if lang.IsTruthy(v11) { -v7 = nil -} else { -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("str")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("first")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v3}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("meta")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) -v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) -v28 := lang.Apply(lang.NewIllegalArgumentError, []any{v27}) -panic(v28) -} -_ = v7 -var v29 any -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("=")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("count")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v5}) -v37 := lang.Apply(v32, []any{int64(2), v36}) -if lang.IsTruthy(v37) { -v29 = nil -} else { -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("str")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("first")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v3}) -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("meta")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v3}) -v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) -v53 := lang.Apply(v40, []any{v44, " requires ", "exactly 2 forms in binding vector", " in ", v47, ":", v52}) -v54 := lang.Apply(lang.NewIllegalArgumentError, []any{v53}) -panic(v54) -} -_ = v29 -_ = nil -v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v57 := v56.FindInternedVar(lang.NewSymbol("first")) -if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) -} -v58 := v57.Get() -v59 := lang.Apply(v58, []any{v5}) -var v55 any = v59 -_ = v55 -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("second")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) -} -v63 := v62.Get() -v64 := lang.Apply(v63, []any{v5}) -var v60 any = v64 -_ = v60 -v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v67 := v66.FindInternedVar(lang.NewSymbol("seq")) -if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) -} -v68 := v67.Get() -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("concat")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) -} -v71 := v70.Get() -v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v73 := v72.FindInternedVar(lang.NewSymbol("list")) -if v73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) -} -v74 := v73.Get() -v75 := lang.Apply(v74, []any{lang.NewSymbol("glojure.core/let")}) -v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v77 := v76.FindInternedVar(lang.NewSymbol("list")) -if v77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) -} -v78 := v77.Get() -v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v80 := v79.FindInternedVar(lang.NewSymbol("apply")) -if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) -} -v81 := v80.Get() -v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v83 := v82.FindInternedVar(lang.NewSymbol("vector")) -if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) -} -v84 := v83.Get() -v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v86 := v85.FindInternedVar(lang.NewSymbol("seq")) -if v86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) -} -v87 := v86.Get() -v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v89 := v88.FindInternedVar(lang.NewSymbol("concat")) -if v89.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) -} -v90 := v89.Get() -v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v92 := v91.FindInternedVar(lang.NewSymbol("list")) -if v92.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) -} -v93 := v92.Get() -v94 := lang.Apply(v93, []any{lang.NewSymbol("n__0__auto__")}) -v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v96 := v95.FindInternedVar(lang.NewSymbol("list")) -if v96.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) -} -v97 := v96.Get() -v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v99 := v98.FindInternedVar(lang.NewSymbol("seq")) -if v99.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) -} -v100 := v99.Get() -v101 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v102 := v101.FindInternedVar(lang.NewSymbol("concat")) -if v102.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v102))) -} -v103 := v102.Get() -v104 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v105 := v104.FindInternedVar(lang.NewSymbol("list")) -if v105.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v105))) -} -v106 := v105.Get() -v107 := lang.Apply(v106, []any{lang.NewSymbol("glojure.core/long")}) -v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v109 := v108.FindInternedVar(lang.NewSymbol("list")) -if v109.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) -} -v110 := v109.Get() -v111 := lang.Apply(v110, []any{v60}) -v112 := lang.Apply(v103, []any{v107, v111}) -v113 := lang.Apply(v100, []any{v112}) -v114 := lang.Apply(v97, []any{v113}) -v115 := lang.Apply(v90, []any{v94, v114}) -v116 := lang.Apply(v87, []any{v115}) -v117 := lang.Apply(v81, []any{v84, v116}) -v118 := lang.Apply(v78, []any{v117}) -v119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v120 := v119.FindInternedVar(lang.NewSymbol("list")) -if v120.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v120))) -} -v121 := v120.Get() -v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v123 := v122.FindInternedVar(lang.NewSymbol("seq")) -if v123.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) -} -v124 := v123.Get() -v125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v126 := v125.FindInternedVar(lang.NewSymbol("concat")) -if v126.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v126))) -} -v127 := v126.Get() -v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v129 := v128.FindInternedVar(lang.NewSymbol("list")) -if v129.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v129))) -} -v130 := v129.Get() -v131 := lang.Apply(v130, []any{lang.NewSymbol("glojure.core/loop")}) -v132 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v133 := v132.FindInternedVar(lang.NewSymbol("list")) -if v133.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v133))) -} -v134 := v133.Get() -v135 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v136 := v135.FindInternedVar(lang.NewSymbol("apply")) -if v136.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v136))) -} -v137 := v136.Get() -v138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v139 := v138.FindInternedVar(lang.NewSymbol("vector")) -if v139.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v139))) -} -v140 := v139.Get() -v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v142 := v141.FindInternedVar(lang.NewSymbol("seq")) -if v142.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) -} -v143 := v142.Get() -v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v145 := v144.FindInternedVar(lang.NewSymbol("concat")) -if v145.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) -} -v146 := v145.Get() -v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v148 := v147.FindInternedVar(lang.NewSymbol("list")) -if v148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) -} -v149 := v148.Get() -v150 := lang.Apply(v149, []any{v55}) -v151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v152 := v151.FindInternedVar(lang.NewSymbol("list")) -if v152.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v152))) -} -v153 := v152.Get() -v154 := lang.Apply(v153, []any{int64(0)}) -v155 := lang.Apply(v146, []any{v150, v154}) -v156 := lang.Apply(v143, []any{v155}) -v157 := lang.Apply(v137, []any{v140, v156}) -v158 := lang.Apply(v134, []any{v157}) -v159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v160 := v159.FindInternedVar(lang.NewSymbol("list")) -if v160.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v160))) -} -v161 := v160.Get() -v162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v163 := v162.FindInternedVar(lang.NewSymbol("seq")) -if v163.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v163))) -} -v164 := v163.Get() -v165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v166 := v165.FindInternedVar(lang.NewSymbol("concat")) -if v166.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v166))) -} -v167 := v166.Get() -v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v169 := v168.FindInternedVar(lang.NewSymbol("list")) -if v169.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) -} -v170 := v169.Get() -v171 := lang.Apply(v170, []any{lang.NewSymbol("glojure.core/when")}) -v172 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v173 := v172.FindInternedVar(lang.NewSymbol("list")) -if v173.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v173))) -} -v174 := v173.Get() -v175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v176 := v175.FindInternedVar(lang.NewSymbol("seq")) -if v176.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v176))) -} -v177 := v176.Get() -v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v179 := v178.FindInternedVar(lang.NewSymbol("concat")) -if v179.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) -} -v180 := v179.Get() -v181 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v182 := v181.FindInternedVar(lang.NewSymbol("list")) -if v182.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v182))) -} -v183 := v182.Get() -v184 := lang.Apply(v183, []any{lang.NewSymbol("glojure.core/<")}) -v185 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v186 := v185.FindInternedVar(lang.NewSymbol("list")) -if v186.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v186))) -} -v187 := v186.Get() -v188 := lang.Apply(v187, []any{v55}) -v189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v190 := v189.FindInternedVar(lang.NewSymbol("list")) -if v190.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v190))) -} -v191 := v190.Get() -v192 := lang.Apply(v191, []any{lang.NewSymbol("n__0__auto__")}) -v193 := lang.Apply(v180, []any{v184, v188, v192}) -v194 := lang.Apply(v177, []any{v193}) -v195 := lang.Apply(v174, []any{v194}) -v196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v197 := v196.FindInternedVar(lang.NewSymbol("list")) -if v197.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v197))) -} -v198 := v197.Get() -v199 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v200 := v199.FindInternedVar(lang.NewSymbol("seq")) -if v200.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v200))) -} -v201 := v200.Get() -v202 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v203 := v202.FindInternedVar(lang.NewSymbol("concat")) -if v203.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v203))) -} -v204 := v203.Get() -v205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v206 := v205.FindInternedVar(lang.NewSymbol("list")) -if v206.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v206))) -} -v207 := v206.Get() -v208 := lang.Apply(v207, []any{lang.NewSymbol("recur")}) -v209 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v210 := v209.FindInternedVar(lang.NewSymbol("list")) -if v210.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v210))) -} -v211 := v210.Get() -v212 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v213 := v212.FindInternedVar(lang.NewSymbol("seq")) -if v213.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v213))) -} -v214 := v213.Get() -v215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v216 := v215.FindInternedVar(lang.NewSymbol("concat")) -if v216.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v216))) -} -v217 := v216.Get() -v218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v219 := v218.FindInternedVar(lang.NewSymbol("list")) -if v219.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v219))) -} -v220 := v219.Get() -v221 := lang.Apply(v220, []any{lang.NewSymbol("glojure.core/unchecked-inc")}) -v222 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v223 := v222.FindInternedVar(lang.NewSymbol("list")) -if v223.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v223))) -} -v224 := v223.Get() -v225 := lang.Apply(v224, []any{v55}) -v226 := lang.Apply(v217, []any{v221, v225}) -v227 := lang.Apply(v214, []any{v226}) -v228 := lang.Apply(v211, []any{v227}) -v229 := lang.Apply(v204, []any{v208, v228}) -v230 := lang.Apply(v201, []any{v229}) -v231 := lang.Apply(v198, []any{v230}) -v232 := lang.Apply(v167, []any{v171, v195, v6, v231}) -v233 := lang.Apply(v164, []any{v232}) -v234 := lang.Apply(v161, []any{v233}) -v235 := lang.Apply(v127, []any{v131, v158, v234}) -v236 := lang.Apply(v124, []any{v235}) -v237 := lang.Apply(v121, []any{v236}) -v238 := lang.Apply(v71, []any{v75, v118, v237}) -v239 := lang.Apply(v68, []any{v238}) -return v239 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// doto -{ -v0 := lang.NewSymbol("doto").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "Evaluates x then calls all of the methods and functions with the\n value of x supplied at the front of the given arguments. The forms\n are evaluated in order. Returns x.\n\n (doto (new java.util.HashMap) (.put \"a\" 1) (.put \"b\" 2))", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3853), lang.NewKeyword("end-line"), int(3853))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("gensym")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, nil) -var v7 any = v11 -_ = v7 -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("seq")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("concat")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{lang.NewSymbol("glojure.core/let")}) -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("apply")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("vector")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("seq")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("concat")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("list")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.Apply(v40, []any{v7}) -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("list")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) -} -v44 := v43.Get() -v45 := lang.Apply(v44, []any{v5}) -v46 := lang.Apply(v37, []any{v41, v45}) -v47 := lang.Apply(v34, []any{v46}) -v48 := lang.Apply(v28, []any{v31, v47}) -v49 := lang.Apply(v25, []any{v48}) -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("map")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -var v53 lang.FnFunc -v53 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v54 := args[0] -v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v56 := v55.FindInternedVar(lang.NewSymbol("with-meta")) -if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) -} -v57 := v56.Get() -var v58 any -v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v60 := v59.FindInternedVar(lang.NewSymbol("seq?")) -if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) -} -v61 := v60.Get() -v62 := lang.Apply(v61, []any{v54}) -if lang.IsTruthy(v62) { -v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v64 := v63.FindInternedVar(lang.NewSymbol("seq")) -if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) -} -v65 := v64.Get() -v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v67 := v66.FindInternedVar(lang.NewSymbol("concat")) -if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) -} -v68 := v67.Get() -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("list")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) -} -v71 := v70.Get() -v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v73 := v72.FindInternedVar(lang.NewSymbol("first")) -if v73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) -} -v74 := v73.Get() -v75 := lang.Apply(v74, []any{v54}) -v76 := lang.Apply(v71, []any{v75}) -v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v78 := v77.FindInternedVar(lang.NewSymbol("list")) -if v78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) -} -v79 := v78.Get() -v80 := lang.Apply(v79, []any{v7}) -v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v82 := v81.FindInternedVar(lang.NewSymbol("next")) -if v82.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) -} -v83 := v82.Get() -v84 := lang.Apply(v83, []any{v54}) -v85 := lang.Apply(v68, []any{v76, v80, v84}) -v86 := lang.Apply(v65, []any{v85}) -v58 = v86 -} else { -v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v88 := v87.FindInternedVar(lang.NewSymbol("seq")) -if v88.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) -} -v89 := v88.Get() -v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v91 := v90.FindInternedVar(lang.NewSymbol("concat")) -if v91.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) -} -v92 := v91.Get() -v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v94 := v93.FindInternedVar(lang.NewSymbol("list")) -if v94.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) -} -v95 := v94.Get() -v96 := lang.Apply(v95, []any{v54}) -v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v98 := v97.FindInternedVar(lang.NewSymbol("list")) -if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) -} -v99 := v98.Get() -v100 := lang.Apply(v99, []any{v7}) -v101 := lang.Apply(v92, []any{v96, v100}) -v102 := lang.Apply(v89, []any{v101}) -v58 = v102 -} -v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v104 := v103.FindInternedVar(lang.NewSymbol("meta")) -if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) -} -v105 := v104.Get() -v106 := lang.Apply(v105, []any{v54}) -v107 := lang.Apply(v57, []any{v58, v106}) -return v107 -}) -v54 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3863), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(3868), lang.NewKeyword("end-column"), int(30)) -v55, err := lang.WithMeta(v53, v54.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v56 := lang.Apply(v52, []any{v55, v6}) -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("list")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) -} -v59 := v58.Get() -v60 := lang.Apply(v59, []any{v7}) -v61 := lang.Apply(v18, []any{v22, v49, v56, v60}) -v62 := lang.Apply(v15, []any{v61}) -return v62 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// double -{ -var v1 lang.FnFunc -{ // function double__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/DoubleCast")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v3}) -v35 := lang.Apply(v26, []any{v30, v34}) -v36 := lang.Apply(v23, []any{v35}) -v37 := lang.Apply(v20, []any{v36}) -v38 := lang.Apply(v9, []any{v13, v17, v37}) -v39 := lang.Apply(v6, []any{v38}) -return v39 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("double").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to double", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3493), lang.NewKeyword("end-line"), int(3493))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := lang.Apply(lang.AsFloat64, []any{v4}) -return v5 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// double-array -{ -var v1 lang.FnFunc -{ // function double-array__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewList(args[0:]...) -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/doubleArray")}) -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("list")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("seq")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("concat")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("list")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.Apply(v37, []any{lang.NewSymbol("glojure.core/args")}) -v39 := lang.Apply(v30, []any{v34, v38}) -v40 := lang.Apply(v27, []any{v39}) -v41 := lang.Apply(v24, []any{v40}) -v42 := lang.Apply(v9, []any{v13, v17, v21, v41}) -v43 := lang.Apply(v6, []any{v42}) -return v43 - } -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("double-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Creates an array of doubles", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5341), lang.NewKeyword("end-line"), int(5341))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v4 := args[0] -v5, _ := lang.FieldOrMethod(lang.Numbers, "doubleArray") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("doubleArray is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 - case 2: -v4 := args[0] -v5 := args[1] -v6, _ := lang.FieldOrMethod(lang.Numbers, "doubleArrayInit") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("doubleArrayInit is not a function"))) -} -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// double? -{ -v0 := lang.NewSymbol("double?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a Double", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1421), lang.NewKeyword("end-line"), int(1421))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{lang.Builtins["float64"], v3}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// doubles -{ -var v1 lang.FnFunc -{ // function doubles -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/doubles")}) -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("list")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v26 := lang.Apply(v9, []any{v13, v17, v21, v25}) -v27 := lang.Apply(v6, []any{v26}) -return v27 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("doubles").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Casts to double[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5402), lang.NewKeyword("end-line"), int(5402))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5, _ := lang.FieldOrMethod(lang.Numbers, "doubles") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("doubles is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// drop -{ -v0 := lang.NewSymbol("drop").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a laziness-preserving sequence of all but the first n items in coll.\n Returns a stateful transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2901), lang.NewKeyword("end-line"), int(2901))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := args[0] -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("volatile!")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v3}) -var v6 any = v10 -_ = v6 -var v12 lang.FnFunc -v12 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v13 := lang.Apply(v5, nil) -return v13 - case 1: -v13 := args[0] -v14 := lang.Apply(v5, []any{v13}) -return v14 - case 2: -v13 := args[0] -v14 := args[1] -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("deref")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v6}) -var v15 any = v19 -_ = v15 -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("dec")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24, ok := lang.FieldOrMethod(v6, "Deref") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "Deref"))) -} -var v25 any -switch reflect.TypeOf(v24).Kind() { -case reflect.Func: - v25 = lang.Apply(v24, nil) -default: - v25 = v24 -} -v26 := lang.Apply(v23, []any{v25}) -v27, _ := lang.FieldOrMethod(v6, "reset") -if reflect.TypeOf(v27).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) -} -v28 := lang.Apply(v27, []any{v26}) -_ = v28 -var v29 any -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("pos?")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.Apply(v32, []any{v15}) -if lang.IsTruthy(v33) { -v29 = v13 -} else { -v34 := lang.Apply(v5, []any{v13, v14}) -v29 = v34 -} -return v29 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2909), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(2917), lang.NewKeyword("end-column"), int(39)) -v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v14 -}) -v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2907), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2917), lang.NewKeyword("end-column"), int(41)) -v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v6 - case 2: -v3 := args[0] -v4 := args[1] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{lang.IDrop, v4}) -if lang.IsTruthy(v9) { -var v11 any -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("pos?")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v3}) -if lang.IsTruthy(v15) { -var v16 any -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("int?")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v3}) -if lang.IsTruthy(v20) { -v16 = v3 -} else { -v21 := lang.Apply(nil, []any{v3}) -v16 = v21 -} -v22, _ := lang.FieldOrMethod(v4, "drop") -if reflect.TypeOf(v22).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("drop is not a function"))) -} -v23 := lang.Apply(v22, []any{v16}) -v11 = v23 -} else { -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("seq")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v4}) -v11 = v27 -} -var v10 any = v11 -_ = v10 -var v29 any -if lang.IsTruthy(v10) { -v29 = v10 -} else { -v29 = lang.NewList() -} -v5 = v29 -} else { -var v11 lang.FnFunc -v11 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v12 := args[0] -v13 := args[1] -recur_loop_539: -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("seq")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v13}) -var v14 any = v18 -_ = v14 -var v20 any -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("pos?")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v12}) -var v21 any = v25 -_ = v21 -var v27 any -if lang.IsTruthy(v21) { -v27 = v14 -} else { -v27 = v21 -} -if lang.IsTruthy(v27) { -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("dec")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v12}) -var v21 any = v25 -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("rest")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{v14}) -var v26 any = v30 -v12 = v21 -v13 = v26 -goto recur_loop_539 -} else { -v20 = v14 -} -return v20 -}) -v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2925), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(2929), lang.NewKeyword("end-column"), int(28)) -v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v10 any = v13 -_ = v10 -var v15 lang.FnFunc -v15 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v16 := lang.Apply(v10, []any{v3, v4}) -return v16 -}) -v16 := lang.Apply(lang.NewLazySeq, []any{v15}) -v5 = v16 -} -return v5 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// drop-last -{ -v0 := lang.NewSymbol("drop-last").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return a lazy sequence of all but the last n (default 1) items in coll", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2932), lang.NewKeyword("end-line"), int(2932))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("drop-last")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{int64(1), v3}) -return v7 - case 2: -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("map")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -var v8 lang.FnFunc -v8 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v9 := args[0] -v10 := args[1] -return v9 -}) -v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2937), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(2937), lang.NewKeyword("end-column"), int(29)) -v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("drop")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v3, v4}) -v15 := lang.Apply(v7, []any{v10, v4, v14}) -return v15 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// drop-while -{ -v0 := lang.NewSymbol("drop-while").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred")), lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the items in coll starting from the\n first item for which (pred item) returns logical false. Returns a\n stateful transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2950), lang.NewKeyword("end-line"), int(2950))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := args[0] -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("volatile!")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{true}) -var v6 any = v10 -_ = v6 -var v12 lang.FnFunc -v12 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v13 := lang.Apply(v5, nil) -return v13 - case 1: -v13 := args[0] -v14 := lang.Apply(v5, []any{v13}) -return v14 - case 2: -v13 := args[0] -v14 := args[1] -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("deref")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v6}) -var v15 any = v19 -_ = v15 -var v21 any -var v22 any = v15 -_ = v22 -var v24 any -if lang.IsTruthy(v22) { -v25 := lang.Apply(v3, []any{v14}) -v24 = v25 -} else { -v24 = v22 -} -if lang.IsTruthy(v24) { -v21 = v13 -} else { -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("vreset!")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v6, nil}) -_ = v25 -v26 := lang.Apply(v5, []any{v13, v14}) -v21 = v26 -} -return v21 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2959), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(2968), lang.NewKeyword("end-column"), int(42)) -v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v14 -}) -v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2957), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2968), lang.NewKeyword("end-column"), int(44)) -v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v6 - case 2: -v3 := args[0] -v4 := args[1] -var v6 lang.FnFunc -v6 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v7 := args[0] -v8 := args[1] -recur_loop_552: -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("seq")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{v8}) -var v9 any = v13 -_ = v9 -var v15 any -var v16 any = v9 -_ = v16 -var v18 any -if lang.IsTruthy(v16) { -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("first")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v9}) -v23 := lang.Apply(v7, []any{v22}) -v18 = v23 -} else { -v18 = v16 -} -if lang.IsTruthy(v18) { -var v16 any = v7 -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("rest")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v20, []any{v9}) -var v17 any = v21 -v7 = v16 -v8 = v17 -goto recur_loop_552 -} else { -v15 = v9 -} -return v15 -}) -v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2970), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(2974), lang.NewKeyword("end-column"), int(26)) -v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v5 any = v8 -_ = v5 -var v10 lang.FnFunc -v10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v11 := lang.Apply(v5, []any{v3, v4}) -return v11 -}) -v11 := lang.Apply(lang.NewLazySeq, []any{v10}) -return v11 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// elide-top-frames -{ -v0 := lang.NewSymbol("elide-top-frames").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4794), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(4794), lang.NewKeyword("end-column"), int(32), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ex"), lang.NewSymbol("class-name"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v6, ok := lang.FieldOrMethod(v3, "getStackTrace") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getStackTrace"))) -} -var v7 any -switch reflect.TypeOf(v6).Kind() { -case reflect.Func: - v7 = lang.Apply(v6, nil) -default: - v7 = v6 -} -var v5 any = v7 -_ = v5 -var v9 any = v3 -_ = v9 -var v11 any -if lang.IsTruthy(v5) { -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("into-array")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("drop-while")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -var v18 lang.FnFunc -v18 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v19 := args[0] -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("=")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23, ok := lang.FieldOrMethod(v19, "getClassName") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v19, "getClassName"))) -} -var v24 any -switch reflect.TypeOf(v23).Kind() { -case reflect.Func: - v24 = lang.Apply(v23, nil) -default: - v24 = v23 -} -v25 := lang.Apply(v22, []any{v4, v24}) -return v25 -}) -v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4801), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(4801), lang.NewKeyword("end-column"), int(77)) -v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v21 := lang.Apply(v17, []any{v20, v5}) -v22 := lang.Apply(v14, []any{nil, v21}) -v11 = v22 -} else { -v11 = nil -} -v23, _ := lang.FieldOrMethod(v9, "setStackTrace") -if reflect.TypeOf(v23).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setStackTrace is not a function"))) -} -v24 := lang.Apply(v23, []any{v11}) -_ = v24 -return v9 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// emit-extend-protocol -{ -v0 := lang.NewSymbol("emit-extend-protocol").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(205), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(205), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("p"), lang.NewSymbol("specs"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("parse-impls")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v4}) -var v5 any = v9 -_ = v5 -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("seq")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("concat")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("list")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{lang.NewSymbol("do")}) -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("map")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -var v24 lang.FnFunc -v24 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v25 := args[0] -var v26 any = v25 -_ = v26 -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("nth")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{v26, int64(0), nil}) -var v27 any = v31 -_ = v27 -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("nth")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v26, int64(1), nil}) -var v32 any = v36 -_ = v32 -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("seq")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("concat")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{lang.NewSymbol("glojure.core/extend-type")}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v27}) -v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("list")) -if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) -} -v54 := v53.Get() -v55 := lang.Apply(v54, []any{v3}) -v56 := lang.Apply(v43, []any{v47, v51, v55, v32}) -v57 := lang.Apply(v40, []any{v56}) -return v57 -}) -v25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(208), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(209), lang.NewKeyword("end-column"), int(42)) -v26, err := lang.WithMeta(v24, v25.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v27 := lang.Apply(v23, []any{v26, v5}) -v28 := lang.Apply(v16, []any{v20, v27}) -v29 := lang.Apply(v13, []any{v28}) -return v29 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// emit-extend-type -{ -v0 := lang.NewSymbol("emit-extend-type").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(175), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(175), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"), lang.NewSymbol("specs"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("parse-impls")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v4}) -var v5 any = v9 -_ = v5 -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("seq")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("concat")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("list")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{lang.NewSymbol("glojure.core/extend")}) -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("list")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v3}) -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("mapcat")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("partial")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("emit-hinted-impl")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v30, []any{v33, v3}) -v35 := lang.Apply(v27, []any{v34, v5}) -v36 := lang.Apply(v16, []any{v20, v24, v35}) -v37 := lang.Apply(v13, []any{v36}) -return v37 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// emit-hinted-impl -{ -v0 := lang.NewSymbol("emit-hinted-impl").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(163), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(163), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"), lang.NewVector(lang.NewSymbol("p"), lang.NewSymbol("fs")))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -var v5 any = v4 -_ = v5 -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("nth")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v5, int64(0), nil}) -var v6 any = v10 -_ = v6 -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("nth")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v5, int64(1), nil}) -var v11 any = v15 -_ = v11 -var v18 lang.FnFunc -v18 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v19 := args[0] -var v21 any -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("vector?")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("first")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.Apply(v27, []any{v20}) -v29 := lang.Apply(v24, []any{v28}) -if lang.IsTruthy(v29) { -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("list")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.Apply(v32, []any{v20}) -v21 = v33 -} else { -v21 = v20 -} -var v20 any = v21 -_ = v20 -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("map")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -var v38 lang.FnFunc -v38 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v39 := args[0] -var v40 any = v39 -_ = v40 -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("seq")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) -} -v44 := v43.Get() -v45 := lang.Apply(v44, []any{v40}) -var v41 any = v45 -_ = v41 -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("first")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) -} -v49 := v48.Get() -v50 := lang.Apply(v49, []any{v41}) -var v46 any = v50 -_ = v46 -v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("next")) -if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) -} -v54 := v53.Get() -v55 := lang.Apply(v54, []any{v51}) -var v51 any = v55 -_ = v51 -var v56 any = v46 -_ = v56 -v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v59 := v58.FindInternedVar(lang.NewSymbol("seq")) -if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) -} -v60 := v59.Get() -v61 := lang.Apply(v60, []any{v56}) -var v57 any = v61 -_ = v57 -v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v64 := v63.FindInternedVar(lang.NewSymbol("first")) -if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) -} -v65 := v64.Get() -v66 := lang.Apply(v65, []any{v57}) -var v62 any = v66 -_ = v62 -v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v69 := v68.FindInternedVar(lang.NewSymbol("next")) -if v69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) -} -v70 := v69.Get() -v71 := lang.Apply(v70, []any{v67}) -var v67 any = v71 -_ = v67 -var v72 any = v62 -_ = v72 -var v73 any = v67 -_ = v73 -var v74 any = v51 -_ = v74 -v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v77 := v76.FindInternedVar(lang.NewSymbol("cons")) -if v77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) -} -v78 := v77.Get() -v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v80 := v79.FindInternedVar(lang.NewSymbol("apply")) -if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) -} -v81 := v80.Get() -v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v83 := v82.FindInternedVar(lang.NewSymbol("vector")) -if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) -} -v84 := v83.Get() -v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v86 := v85.FindInternedVar(lang.NewSymbol("vary-meta")) -if v86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) -} -v87 := v86.Get() -v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v89 := v88.FindInternedVar(lang.NewSymbol("assoc")) -if v89.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) -} -v90 := v89.Get() -v91 := lang.Apply(v87, []any{v72, v90, lang.NewKeyword("tag"), v3}) -v92 := lang.Apply(v81, []any{v84, v91, v73}) -v93 := lang.Apply(v78, []any{v92, v74}) -return v93 -}) -v39 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(168), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(170), lang.NewKeyword("end-column"), int(36)) -v40, err := lang.WithMeta(v38, v39.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v41 := lang.Apply(v37, []any{v40, v20}) -return v41 -}) -v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(164), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(171), lang.NewKeyword("end-column"), int(30)) -v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v17 any = v20 -_ = v17 -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("zipmap")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("map")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -var v28 lang.FnFunc -v28 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v29 := args[0] -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("keyword")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("name")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("first")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v29}) -v40 := lang.Apply(v35, []any{v39}) -v41 := lang.Apply(v32, []any{v40}) -return v41 -}) -v29 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(172), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(172), lang.NewKeyword("end-column"), int(46)) -v30, err := lang.WithMeta(v28, v29.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v31 := lang.Apply(v27, []any{v30, v11}) -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("map")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -var v35 lang.FnFunc -v35 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v36 := args[0] -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("cons")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("drop")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{int64(1), v36}) -v44 := lang.Apply(v17, []any{v43}) -v45 := lang.Apply(v39, []any{lang.NewSymbol("glojure.core/fn"), v44}) -return v45 -}) -v36 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(173), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(173), lang.NewKeyword("end-column"), int(49)) -v37, err := lang.WithMeta(v35, v36.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v38 := lang.Apply(v34, []any{v37, v11}) -v39 := lang.Apply(v24, []any{v31, v38}) -v40 := lang.NewVector(v6, v39) -v41 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(172), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(173), lang.NewKeyword("end-column"), int(55)) -v42, err := lang.WithMeta(v40, v41.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v42 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// empty -{ -v0 := lang.NewSymbol("empty").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns an empty collection of the same category as coll, or nil", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5265), lang.NewKeyword("end-line"), int(5265))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{lang.IPersistentCollection, v3}) -if lang.IsTruthy(v8) { -v9, ok := lang.FieldOrMethod(v3, "empty") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "empty"))) -} -var v10 any -switch reflect.TypeOf(v9).Kind() { -case reflect.Func: - v10 = lang.Apply(v9, nil) -default: - v10 = v9 -} -v4 = v10 -} else { -v4 = nil -} -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// empty? -{ -v0 := lang.NewSymbol("empty?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll has no items. To check the emptiness of a seq,\n please use the idiom (seq x) rather than (not (empty? x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6247), lang.NewKeyword("end-line"), int(6247))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("counted?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -if lang.IsTruthy(v8) { -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("zero?")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("count")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v3}) -v16 := lang.Apply(v11, []any{v15}) -v4 = v16 -} else { -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("not")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("seq")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.Apply(v22, []any{v3}) -v24 := lang.Apply(v19, []any{v23}) -v4 = v24 -} -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// ensure -{ -v0 := lang.NewSymbol("ensure").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref"))), lang.NewKeyword("doc"), "Must be called in a transaction. Protects the ref from modification\n by other transactions. Returns the in-transaction-value of\n ref. Allows for more concurrency than (ref-set ref @ref)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2480), lang.NewKeyword("end-line"), int(2480))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, _ := lang.FieldOrMethod(v3, "touch") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("touch is not a function"))) -} -v5 := lang.Apply(v4, []any{}) -_ = v5 -v6, _ := lang.FieldOrMethod(v3, "deref") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("deref is not a function"))) -} -v7 := lang.Apply(v6, []any{}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// ensure-reduced -{ -v0 := lang.NewSymbol("ensure-reduced").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "If x is already reduced?, returns it, else returns (reduced x)", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2841), lang.NewKeyword("end-line"), int(2841))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("reduced?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -if lang.IsTruthy(v8) { -v4 = v3 -} else { -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("reduced")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v3}) -v4 = v12 -} -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// enumeration-seq -{ -v0 := lang.NewSymbol("enumeration-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("e"))), lang.NewKeyword("doc"), "Returns a seq on a java.util.Enumeration", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5710), lang.NewKeyword("end-line"), int(5710))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.Apply(nil, []any{v3}) -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// error-handler -{ -v0 := lang.NewSymbol("error-handler").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("doc"), "Returns the error-handler of agent a, or nil if there is none.\n See set-error-handler!", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2202), lang.NewKeyword("end-line"), int(2202))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, ok := lang.FieldOrMethod(v3, "getErrorHandler") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getErrorHandler"))) -} -var v5 any -switch reflect.TypeOf(v4).Kind() { -case reflect.Func: - v5 = lang.Apply(v4, nil) -default: - v5 = v4 -} -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// error-mode -{ -v0 := lang.NewSymbol("error-mode").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("doc"), "Returns the error-mode of agent a. See set-error-mode!", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2227), lang.NewKeyword("end-line"), int(2227))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, ok := lang.FieldOrMethod(v3, "getErrorMode") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getErrorMode"))) -} -var v5 any -switch reflect.TypeOf(v4).Kind() { -case reflect.Func: - v5 = lang.Apply(v4, nil) -default: - v5 = v4 -} -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// eval -{ -v0 := lang.NewSymbol("eval").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("form"))), lang.NewKeyword("doc"), "Evaluates the form data structure (not text!) and returns the result.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3203), lang.NewKeyword("end-line"), int(3203))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, _ := lang.FieldOrMethod(runtime5.Compiler, "Eval") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Eval is not a function"))) -} -v5 := lang.Apply(v4, []any{v3}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// even? -{ -v0 := lang.NewSymbol("even?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is even, throws an exception if n is not an integer", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1381), lang.NewKeyword("end-line"), int(1381))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("integer?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -if lang.IsTruthy(v8) { -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("zero?")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("bit-and")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(lang.UncheckedLongCast, []any{v3}) -v16 := lang.Apply(v14, []any{v15, int64(1)}) -v17 := lang.Apply(v11, []any{v16}) -v4 = v17 -} else { -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("str")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v20, []any{"Argument must be an integer: ", v3}) -v22 := lang.Apply(lang.NewIllegalArgumentError, []any{v21}) -panic(v22) -} -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// every-pred -{ -v0 := lang.NewSymbol("every-pred").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("p")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2"), lang.NewSymbol("p3")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2"), lang.NewSymbol("p3"), lang.NewSymbol("&"), lang.NewSymbol("ps"))), lang.NewKeyword("doc"), "Takes a set of predicates and returns a function f that returns true if all of its\n composing predicates return a logical true value against all of its arguments, else it returns\n false. Note that f is short-circuiting in that it will stop execution on the first\n argument that triggers a logical false result against the original predicates.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7422), lang.NewKeyword("end-line"), int(7422))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -var v4 lang.FnFunc -{ // function ep1 -v4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -return true - case 1: -v6 := args[0] -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("boolean")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v3, []any{v6}) -v11 := lang.Apply(v9, []any{v10}) -return v11 - case 2: -v6 := args[0] -v7 := args[1] -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("boolean")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v12 := lang.Apply(v3, []any{v6}) -var v11 any = v12 -_ = v11 -var v14 any -if lang.IsTruthy(v11) { -v15 := lang.Apply(v3, []any{v7}) -v14 = v15 -} else { -v14 = v11 -} -v11 := lang.Apply(v10, []any{v14}) -return v11 - case 3: -v6 := args[0] -v7 := args[1] -v8 := args[2] -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("boolean")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v13 := lang.Apply(v3, []any{v6}) -var v12 any = v13 -_ = v12 -var v15 any -if lang.IsTruthy(v12) { -v17 := lang.Apply(v3, []any{v7}) -var v16 any = v17 -_ = v16 -var v19 any -if lang.IsTruthy(v16) { -v20 := lang.Apply(v3, []any{v8}) -v19 = v20 -} else { -v19 = v16 -} -v15 = v19 -} else { -v15 = v12 -} -v12 := lang.Apply(v11, []any{v15}) -return v12 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v6 := args[0] -v7 := args[1] -v8 := args[2] -v9 := lang.NewList(args[3:]...) -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("boolean")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v14 := lang.Apply(v5, []any{v6, v7, v8}) -var v13 any = v14 -_ = v13 -var v16 any -if lang.IsTruthy(v13) { -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("every?")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v3, v9}) -v16 = v20 -} else { -v16 = v13 -} -v13 := lang.Apply(v12, []any{v16}) -return v13 - } -}) -v5 := v4 -_ = v5 -} -v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7429), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7435), lang.NewKeyword("end-column"), int(56)) -v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v6 - case 2: -v3 := args[0] -v4 := args[1] -var v5 lang.FnFunc -{ // function ep2 -v5 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -return true - case 1: -v7 := args[0] -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("boolean")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v12 := lang.Apply(v3, []any{v7}) -var v11 any = v12 -_ = v11 -var v14 any -if lang.IsTruthy(v11) { -v15 := lang.Apply(v4, []any{v7}) -v14 = v15 -} else { -v14 = v11 -} -v11 := lang.Apply(v10, []any{v14}) -return v11 - case 2: -v7 := args[0] -v8 := args[1] -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("boolean")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v13 := lang.Apply(v3, []any{v7}) -var v12 any = v13 -_ = v12 -var v15 any -if lang.IsTruthy(v12) { -v17 := lang.Apply(v3, []any{v8}) -var v16 any = v17 -_ = v16 -var v19 any -if lang.IsTruthy(v16) { -v21 := lang.Apply(v4, []any{v7}) -var v20 any = v21 -_ = v20 -var v23 any -if lang.IsTruthy(v20) { -v24 := lang.Apply(v4, []any{v8}) -v23 = v24 -} else { -v23 = v20 -} -v19 = v23 -} else { -v19 = v16 -} -v15 = v19 -} else { -v15 = v12 -} -v12 := lang.Apply(v11, []any{v15}) -return v12 - case 3: -v7 := args[0] -v8 := args[1] -v9 := args[2] -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("boolean")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v14 := lang.Apply(v3, []any{v7}) -var v13 any = v14 -_ = v13 -var v16 any -if lang.IsTruthy(v13) { -v18 := lang.Apply(v3, []any{v8}) -var v17 any = v18 -_ = v17 -var v20 any -if lang.IsTruthy(v17) { -v22 := lang.Apply(v3, []any{v9}) -var v21 any = v22 -_ = v21 -var v24 any -if lang.IsTruthy(v21) { -v26 := lang.Apply(v4, []any{v7}) -var v25 any = v26 -_ = v25 -var v28 any -if lang.IsTruthy(v25) { -v30 := lang.Apply(v4, []any{v8}) -var v29 any = v30 -_ = v29 -var v32 any -if lang.IsTruthy(v29) { -v33 := lang.Apply(v4, []any{v9}) -v32 = v33 -} else { -v32 = v29 -} -v28 = v32 -} else { -v28 = v25 -} -v24 = v28 -} else { -v24 = v21 -} -v20 = v24 -} else { -v20 = v17 -} -v16 = v20 -} else { -v16 = v13 -} -v13 := lang.Apply(v12, []any{v16}) -return v13 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v7 := args[0] -v8 := args[1] -v9 := args[2] -v10 := lang.NewList(args[3:]...) -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("boolean")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v15 := lang.Apply(v6, []any{v7, v8, v9}) -var v14 any = v15 -_ = v14 -var v17 any -if lang.IsTruthy(v14) { -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("every?")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -var v21 lang.FnFunc -v21 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v22 := args[0] -v24 := lang.Apply(v3, []any{v22}) -var v23 any = v24 -_ = v23 -var v26 any -if lang.IsTruthy(v23) { -v27 := lang.Apply(v4, []any{v22}) -v26 = v27 -} else { -v26 = v23 -} -return v26 -}) -v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7443), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(7443), lang.NewKeyword("end-column"), int(65)) -v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v24 := lang.Apply(v20, []any{v23, v10}) -v17 = v24 -} else { -v17 = v14 -} -v14 := lang.Apply(v13, []any{v17}) -return v14 - } -}) -v6 := v5 -_ = v6 -} -v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7437), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7443), lang.NewKeyword("end-column"), int(75)) -v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v7 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -var v6 lang.FnFunc -{ // function ep3 -v6 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -return true - case 1: -v8 := args[0] -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("boolean")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v13 := lang.Apply(v3, []any{v8}) -var v12 any = v13 -_ = v12 -var v15 any -if lang.IsTruthy(v12) { -v17 := lang.Apply(v4, []any{v8}) -var v16 any = v17 -_ = v16 -var v19 any -if lang.IsTruthy(v16) { -v20 := lang.Apply(v5, []any{v8}) -v19 = v20 -} else { -v19 = v16 -} -v15 = v19 -} else { -v15 = v12 -} -v12 := lang.Apply(v11, []any{v15}) -return v12 - case 2: -v8 := args[0] -v9 := args[1] -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("boolean")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v14 := lang.Apply(v3, []any{v8}) -var v13 any = v14 -_ = v13 -var v16 any -if lang.IsTruthy(v13) { -v18 := lang.Apply(v3, []any{v9}) -var v17 any = v18 -_ = v17 -var v20 any -if lang.IsTruthy(v17) { -v22 := lang.Apply(v4, []any{v8}) -var v21 any = v22 -_ = v21 -var v24 any -if lang.IsTruthy(v21) { -v26 := lang.Apply(v4, []any{v9}) -var v25 any = v26 -_ = v25 -var v28 any -if lang.IsTruthy(v25) { -v30 := lang.Apply(v5, []any{v8}) -var v29 any = v30 -_ = v29 -var v32 any -if lang.IsTruthy(v29) { -v33 := lang.Apply(v5, []any{v9}) -v32 = v33 -} else { -v32 = v29 -} -v28 = v32 -} else { -v28 = v25 -} -v24 = v28 -} else { -v24 = v21 -} -v20 = v24 -} else { -v20 = v17 -} -v16 = v20 -} else { -v16 = v13 -} -v13 := lang.Apply(v12, []any{v16}) -return v13 - case 3: -v8 := args[0] -v9 := args[1] -v10 := args[2] -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("boolean")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v15 := lang.Apply(v3, []any{v8}) -var v14 any = v15 -_ = v14 -var v17 any -if lang.IsTruthy(v14) { -v19 := lang.Apply(v3, []any{v9}) -var v18 any = v19 -_ = v18 -var v21 any -if lang.IsTruthy(v18) { -v23 := lang.Apply(v3, []any{v10}) -var v22 any = v23 -_ = v22 -var v25 any -if lang.IsTruthy(v22) { -v27 := lang.Apply(v4, []any{v8}) -var v26 any = v27 -_ = v26 -var v29 any -if lang.IsTruthy(v26) { -v31 := lang.Apply(v4, []any{v9}) -var v30 any = v31 -_ = v30 -var v33 any -if lang.IsTruthy(v30) { -v35 := lang.Apply(v4, []any{v10}) -var v34 any = v35 -_ = v34 -var v37 any -if lang.IsTruthy(v34) { -v39 := lang.Apply(v5, []any{v8}) -var v38 any = v39 -_ = v38 -var v41 any -if lang.IsTruthy(v38) { -v43 := lang.Apply(v5, []any{v9}) -var v42 any = v43 -_ = v42 -var v45 any -if lang.IsTruthy(v42) { -v46 := lang.Apply(v5, []any{v10}) -v45 = v46 -} else { -v45 = v42 -} -v41 = v45 -} else { -v41 = v38 -} -v37 = v41 -} else { -v37 = v34 -} -v33 = v37 -} else { -v33 = v30 -} -v29 = v33 -} else { -v29 = v26 -} -v25 = v29 -} else { -v25 = v22 -} -v21 = v25 -} else { -v21 = v18 -} -v17 = v21 -} else { -v17 = v14 -} -v14 := lang.Apply(v13, []any{v17}) -return v14 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v8 := args[0] -v9 := args[1] -v10 := args[2] -v11 := lang.NewList(args[3:]...) -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("boolean")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v16 := lang.Apply(v7, []any{v8, v9, v10}) -var v15 any = v16 -_ = v15 -var v18 any -if lang.IsTruthy(v15) { -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("every?")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -var v22 lang.FnFunc -v22 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v23 := args[0] -v25 := lang.Apply(v3, []any{v23}) -var v24 any = v25 -_ = v24 -var v27 any -if lang.IsTruthy(v24) { -v29 := lang.Apply(v4, []any{v23}) -var v28 any = v29 -_ = v28 -var v31 any -if lang.IsTruthy(v28) { -v32 := lang.Apply(v5, []any{v23}) -v31 = v32 -} else { -v31 = v28 -} -v27 = v31 -} else { -v27 = v24 -} -return v27 -}) -v23 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7451), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(7451), lang.NewKeyword("end-column"), int(72)) -v24, err := lang.WithMeta(v22, v23.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v25 := lang.Apply(v21, []any{v24, v11}) -v18 = v25 -} else { -v18 = v15 -} -v15 := lang.Apply(v14, []any{v18}) -return v15 - } -}) -v7 := v6 -_ = v7 -} -v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7445), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7451), lang.NewKeyword("end-column"), int(82)) -v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v8 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("list*")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v3, v4, v5, v7}) -var v7 any = v11 -_ = v7 -var v13 lang.FnFunc -{ // function epn -v13 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -return true - case 1: -v15 := args[0] -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("every?")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -var v19 lang.FnFunc -v19 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v20 := args[0] -v21 := lang.Apply(v20, []any{v15}) -return v21 -}) -v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7456), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(7456), lang.NewKeyword("end-column"), int(28)) -v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v22 := lang.Apply(v18, []any{v21, v7}) -return v22 - case 2: -v15 := args[0] -v16 := args[1] -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("every?")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -var v20 lang.FnFunc -v20 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v21 := args[0] -v23 := lang.Apply(v21, []any{v15}) -var v22 any = v23 -_ = v22 -var v25 any -if lang.IsTruthy(v22) { -v26 := lang.Apply(v21, []any{v16}) -v25 = v26 -} else { -v25 = v22 -} -return v25 -}) -v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7457), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7457), lang.NewKeyword("end-column"), int(42)) -v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v23 := lang.Apply(v19, []any{v22, v7}) -return v23 - case 3: -v15 := args[0] -v16 := args[1] -v17 := args[2] -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("every?")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -var v21 lang.FnFunc -v21 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v22 := args[0] -v24 := lang.Apply(v22, []any{v15}) -var v23 any = v24 -_ = v23 -var v26 any -if lang.IsTruthy(v23) { -v28 := lang.Apply(v22, []any{v16}) -var v27 any = v28 -_ = v27 -var v30 any -if lang.IsTruthy(v27) { -v31 := lang.Apply(v22, []any{v17}) -v30 = v31 -} else { -v30 = v27 -} -v26 = v30 -} else { -v26 = v23 -} -return v26 -}) -v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7458), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(7458), lang.NewKeyword("end-column"), int(50)) -v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v24 := lang.Apply(v20, []any{v23, v7}) -return v24 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v15 := args[0] -v16 := args[1] -v17 := args[2] -v18 := lang.NewList(args[3:]...) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("boolean")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v23 := lang.Apply(v14, []any{v15, v16, v17}) -var v22 any = v23 -_ = v22 -var v25 any -if lang.IsTruthy(v22) { -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("every?")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -var v29 lang.FnFunc -v29 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v30 := args[0] -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("every?")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v30, v18}) -return v34 -}) -v30 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7460), lang.NewKeyword("column"), int(48), lang.NewKeyword("end-line"), int(7460), lang.NewKeyword("end-column"), int(63)) -v31, err := lang.WithMeta(v29, v30.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v32 := lang.Apply(v28, []any{v31, v7}) -v25 = v32 -} else { -v25 = v22 -} -v22 := lang.Apply(v21, []any{v25}) -return v22 - } -}) -v14 := v13 -_ = v14 -} -v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7454), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7460), lang.NewKeyword("end-column"), int(71)) -v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v15 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// every? -{ -v1 := reflect.TypeOf(false) -v0 := lang.NewSymbol("every?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if (pred x) is logical true for every x in coll, else\n false.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2664), lang.NewKeyword("end-line"), int(2664))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -recur_loop_480: -var v6 any -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("nil?")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("seq")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{v5}) -v14 := lang.Apply(v9, []any{v13}) -if lang.IsTruthy(v14) { -v6 = true -} else { -var v15 any -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("first")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v5}) -v20 := lang.Apply(v4, []any{v19}) -if lang.IsTruthy(v20) { -var v21 any = v4 -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("next")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{v5}) -var v22 any = v26 -v4 = v21 -v5 = v22 -goto recur_loop_480 -} else { -var v27 any -if lang.IsTruthy(lang.NewKeyword("else")) { -v27 = false -} else { -v27 = nil -} -v15 = v27 -} -v6 = v15 -} -return v6 -}) -v4 := reflect.TypeOf(false) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// ex-cause -{ -v0 := lang.NewSymbol("ex-cause").WithMeta(lang.NewMap(lang.NewKeyword("tag"), nil, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ex"))), lang.NewKeyword("doc"), "Returns the cause of ex if ex is a Throwable.\n Otherwise returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4828), lang.NewKeyword("end-line"), int(4828))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{lang.Throwable, v3}) -if lang.IsTruthy(v8) { -v9, ok := lang.FieldOrMethod(v3, "getCause") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getCause"))) -} -var v10 any -switch reflect.TypeOf(v9).Kind() { -case reflect.Func: - v10 = lang.Apply(v9, nil) -default: - v10 = v9 -} -v4 = v10 -} else { -v4 = nil -} -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// ex-data -{ -v0 := lang.NewSymbol("ex-data").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ex"))), lang.NewKeyword("doc"), "Returns exception data (a map) if ex is an IExceptionInfo.\n Otherwise returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4812), lang.NewKeyword("end-line"), int(4812))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{nil, v3}) -if lang.IsTruthy(v8) { -v9, ok := lang.FieldOrMethod(v3, "getData") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getData"))) -} -var v10 any -switch reflect.TypeOf(v9).Kind() { -case reflect.Func: - v10 = lang.Apply(v9, nil) -default: - v10 = v9 -} -v4 = v10 -} else { -v4 = nil -} -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// ex-info -{ -v0 := lang.NewSymbol("ex-info").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("msg"), lang.NewSymbol("map")), lang.NewVector(lang.NewSymbol("msg"), lang.NewSymbol("map"), lang.NewSymbol("cause"))), lang.NewKeyword("doc"), "Create an instance of ExceptionInfo, a RuntimeException subclass\n that carries a map of additional data.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4803), lang.NewKeyword("end-line"), int(4803))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("elide-top-frames")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(ExceptionInfo10., []any{v3, v4}) -v9 := lang.Apply(v7, []any{v8, "glojure.core$ex_info"}) -return v9 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("elide-top-frames")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(ExceptionInfo10., []any{v3, v4, v5}) -v10 := lang.Apply(v8, []any{v9, "glojure.core$ex_info"}) -return v10 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// ex-message -{ -v0 := lang.NewSymbol("ex-message").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ex"))), lang.NewKeyword("doc"), "Returns the message attached to ex if ex is a Throwable.\n Otherwise returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4820), lang.NewKeyword("end-line"), int(4820))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{lang.Throwable, v3}) -if lang.IsTruthy(v8) { -v9, ok := lang.FieldOrMethod(v3, "getMessage") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getMessage"))) -} -var v10 any -switch reflect.TypeOf(v9).Kind() { -case reflect.Func: - v10 = lang.Apply(v9, nil) -default: - v10 = v9 -} -v4 = v10 -} else { -v4 = nil -} -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// extend -{ -v0 := lang.NewSymbol("extend").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atype"), lang.NewSymbol("&"), lang.NewSymbol("proto+mmaps"))), lang.NewKeyword("doc"), "Implementations of protocol methods can be provided using the extend construct:\n\n (extend AType\n AProtocol\n {:foo an-existing-fn\n :bar (fn [a b] ...)\n :baz (fn ([a]...) ([a b] ...)...)}\n BProtocol \n {...} \n ...)\n \n extend takes a type/class (or interface, see below), and one or more\n protocol + method map pairs. It will extend the polymorphism of the\n protocol's methods to call the supplied methods when an AType is\n provided as the first argument. \n\n Method maps are maps of the keyword-ized method names to ordinary\n fns. This facilitates easy reuse of existing fns and fn maps, for\n code reuse/mixins without derivation or composition. You can extend\n an interface to a protocol. This is primarily to facilitate interop\n with the host (e.g. Java) but opens the door to incidental multiple\n inheritance of implementation since a class can inherit from more\n than one interface, both of which extend the protocol. It is TBD how\n to specify which impl to use. You can extend a protocol on nil.\n\n If you are supplying the definitions explicitly (i.e. not reusing\n exsting functions or mixin maps), you may find it more convenient to\n use the extend-type or extend-protocol macros.\n\n Note that multiple independent extend clauses can exist for the same\n type, not all protocols need be defined in a single extend call.\n\n See also:\n extends?, satisfies?, extenders", lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(116), lang.NewKeyword("end-line"), int(116))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.NewList(args[1:]...) -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("seq")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("partition")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v11, []any{int64(2), v4}) -v13 := lang.Apply(v8, []any{v12}) -var v5 any = v13 -_ = v5 -var v14 any = nil -_ = v14 -var v15 any = int64(0) -_ = v15 -var v16 any = int64(0) -_ = v16 -var v17 any -for { -var v18 any -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("<")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v16, v15}) -if lang.IsTruthy(v22) { -v24, _ := lang.FieldOrMethod(v14, "nth") -if reflect.TypeOf(v24).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) -} -v25 := lang.Apply(v24, []any{v16}) -var v23 any = v25 -_ = v23 -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("nth")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{v23, int64(0), nil}) -var v26 any = v30 -_ = v26 -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("nth")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v23, int64(1), nil}) -var v31 any = v35 -_ = v31 -var v37 any -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("protocol?")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.Apply(v40, []any{v26}) -if lang.IsTruthy(v41) { -v37 = nil -} else { -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("str")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) -} -v44 := v43.Get() -v45 := lang.Apply(v44, []any{v26, " is not a protocol"}) -v46 := lang.Apply(errors6.New, []any{v45}) -panic(v46) -} -_ = v37 -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("reduce1")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) -} -v49 := v48.Get() -var v50 lang.FnFunc -v50 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v51 := args[0] -v52 := args[1] -var v53 any = v52 -_ = v53 -v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v56 := v55.FindInternedVar(lang.NewSymbol("nth")) -if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) -} -v57 := v56.Get() -v58 := lang.Apply(v57, []any{v53, int64(0), nil}) -var v54 any = v58 -_ = v54 -v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v61 := v60.FindInternedVar(lang.NewSymbol("nth")) -if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) -} -v62 := v61.Get() -v63 := lang.Apply(v62, []any{v53, int64(1), nil}) -var v59 any = v63 -_ = v59 -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("get-in")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) -} -v67 := v66.Get() -v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v69 := v68.FindInternedVar(lang.NewSymbol("deref")) -if v69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) -} -v70 := v69.Get() -v71 := lang.Apply(v70, []any{v26}) -v72 := lang.NewVector(lang.NewKeyword("multis"), v54) -v73 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(158), lang.NewKeyword("column"), int(33), lang.NewKeyword("end-line"), int(158), lang.NewKeyword("end-column"), int(43)) -v74, err := lang.WithMeta(v72, v73.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v75 := lang.Apply(v67, []any{v71, v74}) -var v76 lang.FnFunc -v76 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v77 := args[0] -v78 := lang.NewList(args[1:]...) -v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v80 := v79.FindInternedVar(lang.NewSymbol("apply")) -if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) -} -v81 := v80.Get() -v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v83 := v82.FindInternedVar(lang.NewSymbol("cons")) -if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) -} -v84 := v83.Get() -v85 := lang.Apply(v84, []any{v77, v78}) -v86 := lang.Apply(v81, []any{v59, v85}) -return v86 - } -}) -v77, _ := lang.FieldOrMethod(v75, "AddMethod") -if reflect.TypeOf(v77).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("AddMethod is not a function"))) -} -v78 := lang.Apply(v77, []any{v3, v76}) -return v78 -}) -v51 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(156), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(160), lang.NewKeyword("end-column"), int(45)) -v52, err := lang.WithMeta(v50, v51.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v53 := lang.Apply(v49, []any{v52, nil, v31}) -_ = v53 -var v54 any = v5 -var v55 any = v14 -var v56 any = v15 -v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v59 := v58.FindInternedVar(lang.NewSymbol("unchecked-inc")) -if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) -} -v60 := v59.Get() -v61 := lang.Apply(v60, []any{v16}) -var v57 any = v61 -v5 = v54 -v14 = v55 -v15 = v56 -v16 = v57 -continue -} else { -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("seq")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v5}) -var v23 any = v27 -_ = v23 -var v29 any -if lang.IsTruthy(v23) { -var v30 any = v23 -_ = v30 -var v32 any -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("chunked-seq?")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v30}) -if lang.IsTruthy(v36) { -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("chunk-first")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.Apply(v40, []any{v30}) -var v37 any = v41 -_ = v37 -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("chunk-rest")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v30}) -var v43 any = v47 -var v48 any = v37 -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("int")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("count")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) -} -v55 := v54.Get() -v56 := lang.Apply(v55, []any{v37}) -v57 := lang.Apply(v52, []any{v56}) -var v49 any = v57 -v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v60 := v59.FindInternedVar(lang.NewSymbol("int")) -if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) -} -v61 := v60.Get() -v62 := lang.Apply(v61, []any{int64(0)}) -var v58 any = v62 -v5 = v43 -v14 = v48 -v15 = v49 -v16 = v58 -continue -} else { -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("first")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.Apply(v40, []any{v30}) -var v37 any = v41 -_ = v37 -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("nth")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.Apply(v45, []any{v37, int64(0), nil}) -var v42 any = v46 -_ = v42 -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("nth")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v37, int64(1), nil}) -var v47 any = v51 -_ = v47 -var v53 any -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("protocol?")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) -} -v56 := v55.Get() -v57 := lang.Apply(v56, []any{v42}) -if lang.IsTruthy(v57) { -v53 = nil -} else { -v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v59 := v58.FindInternedVar(lang.NewSymbol("str")) -if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) -} -v60 := v59.Get() -v61 := lang.Apply(v60, []any{v42, " is not a protocol"}) -v62 := lang.Apply(errors6.New, []any{v61}) -panic(v62) -} -_ = v53 -v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v64 := v63.FindInternedVar(lang.NewSymbol("reduce1")) -if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) -} -v65 := v64.Get() -var v66 lang.FnFunc -v66 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v67 := args[0] -v68 := args[1] -var v69 any = v68 -_ = v69 -v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v72 := v71.FindInternedVar(lang.NewSymbol("nth")) -if v72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) -} -v73 := v72.Get() -v74 := lang.Apply(v73, []any{v69, int64(0), nil}) -var v70 any = v74 -_ = v70 -v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v77 := v76.FindInternedVar(lang.NewSymbol("nth")) -if v77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) -} -v78 := v77.Get() -v79 := lang.Apply(v78, []any{v69, int64(1), nil}) -var v75 any = v79 -_ = v75 -v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v82 := v81.FindInternedVar(lang.NewSymbol("get-in")) -if v82.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) -} -v83 := v82.Get() -v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v85 := v84.FindInternedVar(lang.NewSymbol("deref")) -if v85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) -} -v86 := v85.Get() -v87 := lang.Apply(v86, []any{v42}) -v88 := lang.NewVector(lang.NewKeyword("multis"), v70) -v89 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(158), lang.NewKeyword("column"), int(33), lang.NewKeyword("end-line"), int(158), lang.NewKeyword("end-column"), int(43)) -v90, err := lang.WithMeta(v88, v89.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v91 := lang.Apply(v83, []any{v87, v90}) -var v92 lang.FnFunc -v92 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v93 := args[0] -v94 := lang.NewList(args[1:]...) -v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v96 := v95.FindInternedVar(lang.NewSymbol("apply")) -if v96.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) -} -v97 := v96.Get() -v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v99 := v98.FindInternedVar(lang.NewSymbol("cons")) -if v99.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) -} -v100 := v99.Get() -v101 := lang.Apply(v100, []any{v93, v94}) -v102 := lang.Apply(v97, []any{v75, v101}) -return v102 - } -}) -v93, _ := lang.FieldOrMethod(v91, "AddMethod") -if reflect.TypeOf(v93).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("AddMethod is not a function"))) -} -v94 := lang.Apply(v93, []any{v3, v92}) -return v94 -}) -v67 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(156), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(160), lang.NewKeyword("end-column"), int(45)) -v68, err := lang.WithMeta(v66, v67.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v69 := lang.Apply(v65, []any{v68, nil, v47}) -_ = v69 -v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v72 := v71.FindInternedVar(lang.NewSymbol("next")) -if v72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) -} -v73 := v72.Get() -v74 := lang.Apply(v73, []any{v30}) -var v70 any = v74 -var v75 any = nil -var v76 any = int64(0) -var v77 any = int64(0) -v5 = v70 -v14 = v75 -v15 = v76 -v16 = v77 -continue -} -v29 = v32 -} else { -v29 = nil -} -v18 = v29 -} -v17 = v18 - break -} -return v17 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// extend-protocol -{ -v0 := lang.NewSymbol("extend-protocol").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("p"), lang.NewSymbol("&"), lang.NewSymbol("specs"))), lang.NewKeyword("doc"), "Useful when you want to provide several implementations of the same\n protocol all at once. Takes a single protocol and the implementation\n of that protocol for one or more types.\n\n (extend-protocol Protocol\n AType\n (foo [x] ...)\n (bar [x y] ...)\n BType\n (foo [x] ...)\n (bar [x y] ...)\n AClass\n (foo [x] ...)\n (bar [x y] ...)\n nil\n (foo [x] ...)\n (bar [x y] ...))\n\n expands into:\n\n (do\n (clojure.core/extend-type AType Protocol \n (foo [x] ...) \n (bar [x y] ...))\n (clojure.core/extend-type BType Protocol \n (foo [x] ...) \n (bar [x y] ...))\n (clojure.core/extend-type AClass Protocol \n (foo [x] ...) \n (bar [x y] ...))\n (clojure.core/extend-type nil Protocol \n (foo [x] ...) \n (bar [x y] ...)))", lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(212), lang.NewKeyword("end-line"), int(212))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("emit-extend-protocol")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v5, v6}) -return v10 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// extend-type -{ -v0 := lang.NewSymbol("extend-type").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("t"), lang.NewSymbol("&"), lang.NewSymbol("specs"))), lang.NewKeyword("doc"), "A macro that expands into an extend call. Useful when you are\n supplying the definitions explicitly inline, extend-type\n automatically creates the maps required by extend. Propagates the\n class as a type hint on the first argument of all fns.\n\n (extend-type MyType \n Countable\n (cnt [c] ...)\n Foo\n (bar [x y] ...)\n (baz ([x] ...) ([x y & zs] ...)))\n\n expands into:\n\n (extend MyType\n Countable\n {:cnt (fn [c] ...)}\n Foo\n {:baz (fn ([x] ...) ([x y & zs] ...))\n :bar (fn [x y] ...)})", lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(180), lang.NewKeyword("end-line"), int(180))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("emit-extend-type")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v5, v6}) -return v10 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// false? -{ -v1 := reflect.TypeOf(false) -v0 := lang.NewSymbol("false?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is the value false, false otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(504), lang.NewKeyword("end-line"), int(504))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := lang.Apply(lang.Identical, []any{v4, false}) -return v5 -}) -v4 := reflect.TypeOf(false) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// ffirst -{ -v0 := lang.NewSymbol("ffirst").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Same as (first (first x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(98), lang.NewKeyword("end-line"), int(102))).(*lang.Symbol) -var v2 lang.FnFunc -{ // function ffirst -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("first")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("first")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v4}) -v12 := lang.Apply(v7, []any{v11}) -return v12 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(102), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(102), lang.NewKeyword("end-column"), int(50))).(lang.FnFunc) -v3 := v2 -_ = v3 -} -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// file-seq -{ -v0 := lang.NewSymbol("file-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("dir"))), lang.NewKeyword("doc"), "A tree seq on java.io.Files", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4972), lang.NewKeyword("end-line"), int(4972))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("tree-seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -var v7 lang.FnFunc -v7 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v8 := args[0] -v9, _ := lang.FieldOrMethod(v8, "isDirectory") -if reflect.TypeOf(v9).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("isDirectory is not a function"))) -} -v10 := lang.Apply(v9, []any{}) -return v10 -}) -v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4978), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(4978), lang.NewKeyword("end-column"), int(47)) -v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v10 lang.FnFunc -v10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v11 := args[0] -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("seq")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15, _ := lang.FieldOrMethod(v11, "listFiles") -if reflect.TypeOf(v15).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("listFiles is not a function"))) -} -v16 := lang.Apply(v15, []any{}) -v17 := lang.Apply(v14, []any{v16}) -return v17 -}) -v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4979), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(4979), lang.NewKeyword("end-column"), int(51)) -v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v13 := lang.Apply(v6, []any{v9, v12, v3}) -return v13 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// filter -{ -v0 := lang.NewSymbol("filter").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred")), lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the items in coll for which\n (pred item) returns logical true. pred must be free of side-effects.\n Returns a transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2785), lang.NewKeyword("end-line"), int(2785))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := args[0] -var v6 lang.FnFunc -v6 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v7 := lang.Apply(v5, nil) -return v7 - case 1: -v7 := args[0] -v8 := lang.Apply(v5, []any{v7}) -return v8 - case 2: -v7 := args[0] -v8 := args[1] -var v9 any -v10 := lang.Apply(v3, []any{v8}) -if lang.IsTruthy(v10) { -v11 := lang.Apply(v5, []any{v7, v8}) -v9 = v11 -} else { -v9 = v7 -} -return v9 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2793), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(2799), lang.NewKeyword("end-column"), int(22)) -v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v8 -}) -v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2792), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2799), lang.NewKeyword("end-column"), int(23)) -v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v6 - case 2: -v3 := args[0] -v4 := args[1] -var v5 lang.FnFunc -v5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("seq")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v4}) -var v6 any = v10 -_ = v6 -var v12 any -if lang.IsTruthy(v6) { -var v13 any = v6 -_ = v13 -var v15 any -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("chunked-seq?")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v13}) -if lang.IsTruthy(v19) { -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("chunk-first")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v13}) -var v20 any = v24 -_ = v20 -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("count")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.Apply(v28, []any{v20}) -var v25 any = v29 -_ = v25 -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("chunk-buffer")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v25}) -var v30 any = v34 -_ = v30 -v37 := lang.Apply(lang.LongCast, []any{v25}) -var v36 any = v37 -_ = v36 -var v39 any = int64(0) -_ = v39 -var v40 any -for { -var v41 any -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("<")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) -} -v44 := v43.Get() -v45 := lang.Apply(v44, []any{v39, v36}) -if lang.IsTruthy(v45) { -v47, _ := lang.FieldOrMethod(v20, "nth") -if reflect.TypeOf(v47).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) -} -v48 := lang.Apply(v47, []any{v39}) -var v46 any = v48 -_ = v46 -var v50 any -v51 := lang.Apply(v3, []any{v46}) -if lang.IsTruthy(v51) { -v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("chunk-append")) -if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) -} -v54 := v53.Get() -v55 := lang.Apply(v54, []any{v30, v46}) -v50 = v55 -} else { -v50 = nil -} -_ = v50 -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("unchecked-inc")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) -} -v49 := v48.Get() -v50 := lang.Apply(v49, []any{v39}) -var v46 any = v50 -v39 = v46 -continue -} else { -v41 = nil -} -v40 = v41 - break -} -_ = v40 -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("chunk-cons")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("chunk")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) -} -v41 := v40.Get() -v42 := lang.Apply(v41, []any{v30}) -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("filter")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("chunk-rest")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) -} -v48 := v47.Get() -v49 := lang.Apply(v48, []any{v13}) -v50 := lang.Apply(v45, []any{v3, v49}) -v51 := lang.Apply(v38, []any{v42, v50}) -v15 = v51 -} else { -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("first")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v13}) -var v20 any = v24 -_ = v20 -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("rest")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.Apply(v28, []any{v13}) -var v25 any = v29 -_ = v25 -var v31 any -v32 := lang.Apply(v3, []any{v20}) -if lang.IsTruthy(v32) { -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("cons")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("filter")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v3, v25}) -v40 := lang.Apply(v35, []any{v20, v39}) -v31 = v40 -} else { -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("filter")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v3, v25}) -v31 = v44 -} -v15 = v31 -} -v12 = v15 -} else { -v12 = nil -} -return v12 -}) -v6 := lang.Apply(lang.NewLazySeq, []any{v5}) -return v6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// filter-key -{ -v0 := lang.NewSymbol("filter-key").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("keyfn"), lang.NewSymbol("pred"), lang.NewSymbol("amap"))), lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4115), lang.NewKeyword("end-line"), int(4117), lang.NewKeyword("private"), true)).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v7 := lang.NewMap() -v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4118), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(4118), lang.NewKeyword("end-column"), int(17)) -v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v6 any = v9 -_ = v6 -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("seq")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v5}) -var v10 any = v14 -_ = v10 -var v15 any -for { -var v16 any -if lang.IsTruthy(v10) { -var v17 any -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("first")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v20, []any{v10}) -v22 := lang.Apply(v3, []any{v21}) -v23 := lang.Apply(v4, []any{v22}) -if lang.IsTruthy(v23) { -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("assoc")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("key")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("first")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v10}) -v35 := lang.Apply(v30, []any{v34}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("val")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("first")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) -} -v41 := v40.Get() -v42 := lang.Apply(v41, []any{v10}) -v43 := lang.Apply(v38, []any{v42}) -v44 := lang.Apply(v27, []any{v6, v35, v43}) -var v24 any = v44 -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("next")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) -} -v48 := v47.Get() -v49 := lang.Apply(v48, []any{v10}) -var v45 any = v49 -v6 = v24 -v10 = v45 -continue -} else { -var v50 any = v6 -v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("next")) -if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) -} -v54 := v53.Get() -v55 := lang.Apply(v54, []any{v10}) -var v51 any = v55 -v6 = v50 -v10 = v51 -continue -} -v16 = v17 -} else { -v16 = v6 -} -v15 = v16 - break -} -return v15 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// filterv -{ -v0 := lang.NewSymbol("filterv").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a vector of the items in coll for which\n (pred item) returns logical true. pred must be free of side-effects.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6961), lang.NewKeyword("end-line"), int(6961))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("persistent!")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("reduce")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -var v11 lang.FnFunc -v11 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v12 := args[0] -v13 := args[1] -var v14 any -v15 := lang.Apply(v3, []any{v13}) -if lang.IsTruthy(v15) { -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("conj!")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v12, v13}) -v14 = v19 -} else { -v14 = v12 -} -return v14 -}) -v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6967), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(6967), lang.NewKeyword("end-column"), int(52)) -v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("transient")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.NewVector() -v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6968), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(6968), lang.NewKeyword("end-column"), int(27)) -v19, err := lang.WithMeta(v17, v18.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v20 := lang.Apply(v16, []any{v19}) -v21 := lang.Apply(v10, []any{v13, v20, v4}) -v22 := lang.Apply(v7, []any{v21}) -return v22 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// find -{ -v0 := lang.NewSymbol("find").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"))), lang.NewKeyword("doc"), "Returns the map entry for key, or nil if key not present.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1530), lang.NewKeyword("end-line"), int(1530))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5, _ := lang.FieldOrMethod(runtime5.RT, "Find") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Find is not a function"))) -} -v6 := lang.Apply(v5, []any{v3, v4}) -return v6 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// find-keyword -{ -v1 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() -v0 := lang.NewSymbol("find-keyword").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name"))), lang.NewKeyword("doc"), "Returns a Keyword with the given namespace and name if one already\n exists. This function will not intern a new keyword. If the keyword\n has not already been interned, it will return nil. Do not use :\n in the keyword strings, it will be added automatically.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(618), lang.NewKeyword("end-line"), int(618))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v4 := args[0] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("keyword?")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v4}) -if lang.IsTruthy(v9) { -v5 = v4 -} else { -var v10 any -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("symbol?")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v4}) -if lang.IsTruthy(v14) { -v15 := lang.Apply(nil, []any{v4}) -v10 = v15 -} else { -var v16 any -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("string?")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v4}) -if lang.IsTruthy(v20) { -v21 := lang.Apply(nil, []any{v4}) -v16 = v21 -} else { -v16 = nil -} -v10 = v16 -} -v5 = v10 -} -return v5 - case 2: -v4 := args[0] -v5 := args[1] -v6 := lang.Apply(nil, []any{v4, v5}) -return v6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v4 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// find-ns -{ -v0 := lang.NewSymbol("find-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Returns the namespace named by the symbol or nil if it doesn't exist.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4125), lang.NewKeyword("end-line"), int(4125))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.Apply(lang.FindNamespace, []any{v3}) -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// find-var -{ -v0 := lang.NewSymbol("find-var").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Returns the global var named by the namespace-qualified symbol, or\n nil if no var with that name.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2013), lang.NewKeyword("end-line"), int(2013))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, _ := lang.FieldOrMethod(runtime5.RT, "FindVar") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("FindVar is not a function"))) -} -v5 := lang.Apply(v4, []any{v3}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// first -{ -v0 := lang.NewSymbol("first").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns the first item in the collection. Calls seq on its\n argument. If coll is nil, returns nil.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(47), lang.NewKeyword("end-line"), int(52))).(*lang.Symbol) -var v2 lang.FnFunc -{ // function first -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := lang.Apply(lang.First, []any{v4}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(52), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(52), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) -v3 := v2 -_ = v3 -} -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// fits-table? -{ -v0 := lang.NewSymbol("fits-table?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ints"))), lang.NewKeyword("doc"), "Returns true if the collection of ints can fit within the\n max-table-switch-size, false otherwise.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6625), lang.NewKeyword("end-line"), int(6625), lang.NewKeyword("private"), true)).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("<")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("-")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("apply")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("max")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("seq")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v3}) -v20 := lang.Apply(v12, []any{v15, v19}) -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("apply")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("min")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("seq")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{v3}) -v31 := lang.Apply(v23, []any{v26, v30}) -v32 := lang.Apply(v9, []any{v20, v31}) -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("max-switch-table-size")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v6, []any{v32, v35}) -return v36 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// flatten -{ -v0 := lang.NewSymbol("flatten").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Takes any nested combination of sequential things (lists, vectors,\n etc.) and returns their contents as a single, flat lazy sequence.\n (flatten nil) returns an empty sequence.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7118), lang.NewKeyword("end-line"), int(7118))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("filter")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("complement")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("sequential?")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v9, []any{v12}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("rest")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("tree-seq")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("sequential?")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("seq")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v19, []any{v22, v25, v3}) -v27 := lang.Apply(v16, []any{v26}) -v28 := lang.Apply(v6, []any{v13, v27}) -return v28 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// float -{ -var v1 lang.FnFunc -{ // function float__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -var v30 any -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -if lang.IsTruthy(v33) { -v30 = lang.NewSymbol("uncheckedFloatCast") -} else { -v30 = lang.NewSymbol("floatCast") -} -v34 := lang.Apply(v29, []any{v30}) -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("list")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v3}) -v39 := lang.Apply(v26, []any{v34, v38}) -v40 := lang.Apply(v23, []any{v39}) -v41 := lang.Apply(v20, []any{v40}) -v42 := lang.Apply(v9, []any{v13, v17, v41}) -v43 := lang.Apply(v6, []any{v42}) -return v43 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("float").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to float", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3487), lang.NewKeyword("end-line"), int(3487))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := lang.Apply(lang.FloatCast, []any{v4}) -return v5 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// float-array -{ -var v1 lang.FnFunc -{ // function float-array__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewList(args[0:]...) -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/floatArray")}) -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("list")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("seq")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("concat")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("list")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.Apply(v37, []any{lang.NewSymbol("glojure.core/args")}) -v39 := lang.Apply(v30, []any{v34, v38}) -v40 := lang.Apply(v27, []any{v39}) -v41 := lang.Apply(v24, []any{v40}) -v42 := lang.Apply(v9, []any{v13, v17, v21, v41}) -v43 := lang.Apply(v6, []any{v42}) -return v43 - } -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("float-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Creates an array of floats", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5301), lang.NewKeyword("end-line"), int(5301))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v4 := args[0] -v5, _ := lang.FieldOrMethod(lang.Numbers, "floatArray") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("floatArray is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 - case 2: -v4 := args[0] -v5 := args[1] -v6, _ := lang.FieldOrMethod(lang.Numbers, "floatArrayInit") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("floatArrayInit is not a function"))) -} -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// float? -{ -v0 := lang.NewSymbol("float?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is a floating point number", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3605), lang.NewKeyword("end-line"), int(3605))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{lang.Builtins["float64"], v3}) -var v4 any = v8 -_ = v4 -var v10 any -if lang.IsTruthy(v4) { -v10 = v4 -} else { -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("instance?")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{lang.Builtins["float32"], v3}) -v10 = v14 -} -return v10 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// floats -{ -var v1 lang.FnFunc -{ // function floats -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/floats")}) -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("list")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v26 := lang.Apply(v9, []any{v13, v17, v21, v25}) -v27 := lang.Apply(v6, []any{v26}) -return v27 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("floats").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Casts to float[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5392), lang.NewKeyword("end-line"), int(5392))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5, _ := lang.FieldOrMethod(lang.Numbers, "floats") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("floats is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// flush -{ -v0 := lang.NewSymbol("flush").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Flushes the output stream that is the current value of\n *out*", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3706), lang.NewKeyword("end-line"), int(3706))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v4 := v3.FindInternedVar(lang.NewSymbol("*out*")) -if v4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) -} -v5 := v4.Get() -v6, _ := lang.FieldOrMethod(v5, "Sync") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Sync is not a function"))) -} -v7 := lang.Apply(v6, []any{}) -_ = v7 -return nil -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// fn -{ -v0 := lang.NewSymbol("fn").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("sigs"))), lang.NewKeyword("doc"), "params => positional-params*, or positional-params* & rest-param\n positional-param => binding-form\n rest-param => binding-form\n binding-form => name, or destructuring-form\n\n Defines a function.\n\n See https://glojure.org/reference/special_forms#fn for more information", lang.NewKeyword("forms"), lang.NewVector(lang.NewList(lang.NewSymbol("fn"), lang.NewSymbol("name?"), lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("exprs*")), lang.NewList(lang.NewSymbol("fn"), lang.NewSymbol("name?"), lang.NewList(lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("exprs*")), lang.NewSymbol("+"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4533), lang.NewKeyword("end-line"), int(4533), lang.NewKeyword("special-form"), true)).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -var v7 any -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("symbol?")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("first")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v5}) -v15 := lang.Apply(v10, []any{v14}) -if lang.IsTruthy(v15) { -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("first")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v5}) -v7 = v19 -} else { -v7 = nil -} -var v6 any = v7 -_ = v6 -var v21 any -if lang.IsTruthy(v6) { -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("next")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v20}) -v21 = v25 -} else { -v21 = v20 -} -var v20 any = v21 -_ = v20 -var v27 any -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("vector?")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("first")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v26}) -v35 := lang.Apply(v30, []any{v34}) -if lang.IsTruthy(v35) { -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v26}) -v27 = v39 -} else { -var v40 any -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("seq?")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("first")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v26}) -v48 := lang.Apply(v43, []any{v47}) -if lang.IsTruthy(v48) { -v40 = v26 -} else { -var v49 any -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("seq")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.Apply(v52, []any{v26}) -if lang.IsTruthy(v53) { -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("str")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) -} -v56 := v55.Get() -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("first")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) -} -v59 := v58.Get() -v60 := lang.Apply(v59, []any{v26}) -v61 := lang.Apply(v56, []any{"Parameter declaration ", v60, " should be a vector"}) -v49 = v61 -} else { -v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v63 := v62.FindInternedVar(lang.NewSymbol("str")) -if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) -} -v64 := v63.Get() -v65 := lang.Apply(v64, []any{"Parameter declaration missing"}) -v49 = v65 -} -v66 := lang.Apply(lang.NewIllegalArgumentError, []any{v49}) -panic(v66) -} -v27 = v40 -} -var v26 any = v27 -_ = v26 -var v68 lang.FnFunc -v68 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v69 := args[0] -var v70 any -v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v72 := v71.FindInternedVar(lang.NewSymbol("not")) -if v72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) -} -v73 := v72.Get() -v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v75 := v74.FindInternedVar(lang.NewSymbol("seq?")) -if v75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) -} -v76 := v75.Get() -v77 := lang.Apply(v76, []any{v69}) -v78 := lang.Apply(v73, []any{v77}) -if lang.IsTruthy(v78) { -v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v80 := v79.FindInternedVar(lang.NewSymbol("str")) -if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) -} -v81 := v80.Get() -v82 := lang.Apply(v81, []any{"Invalid signature ", v69, " should be a list"}) -v83 := lang.Apply(lang.NewIllegalArgumentError, []any{v82}) -panic(v83) -} else { -v70 = nil -} -_ = v70 -var v84 any = v69 -_ = v84 -v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v87 := v86.FindInternedVar(lang.NewSymbol("seq")) -if v87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) -} -v88 := v87.Get() -v89 := lang.Apply(v88, []any{v84}) -var v85 any = v89 -_ = v85 -v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v92 := v91.FindInternedVar(lang.NewSymbol("first")) -if v92.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) -} -v93 := v92.Get() -v94 := lang.Apply(v93, []any{v85}) -var v90 any = v94 -_ = v90 -v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v97 := v96.FindInternedVar(lang.NewSymbol("next")) -if v97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) -} -v98 := v97.Get() -v99 := lang.Apply(v98, []any{v95}) -var v95 any = v99 -_ = v95 -var v100 any = v90 -_ = v100 -var v101 any = v95 -_ = v101 -var v103 any -v104 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v105 := v104.FindInternedVar(lang.NewSymbol("not")) -if v105.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v105))) -} -v106 := v105.Get() -v107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v108 := v107.FindInternedVar(lang.NewSymbol("vector?")) -if v108.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v108))) -} -v109 := v108.Get() -v110 := lang.Apply(v109, []any{v100}) -v111 := lang.Apply(v106, []any{v110}) -if lang.IsTruthy(v111) { -var v112 any -v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v114 := v113.FindInternedVar(lang.NewSymbol("seq?")) -if v114.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) -} -v115 := v114.Get() -v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v117 := v116.FindInternedVar(lang.NewSymbol("first")) -if v117.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) -} -v118 := v117.Get() -v119 := lang.Apply(v118, []any{v26}) -v120 := lang.Apply(v115, []any{v119}) -if lang.IsTruthy(v120) { -v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v122 := v121.FindInternedVar(lang.NewSymbol("str")) -if v122.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) -} -v123 := v122.Get() -v124 := lang.Apply(v123, []any{"Parameter declaration ", v100, " should be a vector"}) -v112 = v124 -} else { -v125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v126 := v125.FindInternedVar(lang.NewSymbol("str")) -if v126.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v126))) -} -v127 := v126.Get() -v128 := lang.Apply(v127, []any{"Invalid signature ", v69, " should be a list"}) -v112 = v128 -} -v129 := lang.Apply(lang.NewIllegalArgumentError, []any{v112}) -panic(v129) -} else { -v103 = nil -} -var v102 any = v103 -_ = v102 -var v131 any -v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v134 := v133.FindInternedVar(lang.NewSymbol("next")) -if v134.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) -} -v135 := v134.Get() -v136 := lang.Apply(v135, []any{v101}) -var v132 any = v136 -_ = v132 -var v138 any -if lang.IsTruthy(v132) { -v139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v140 := v139.FindInternedVar(lang.NewSymbol("map?")) -if v140.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v140))) -} -v141 := v140.Get() -v142 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v143 := v142.FindInternedVar(lang.NewSymbol("first")) -if v143.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v143))) -} -v144 := v143.Get() -v145 := lang.Apply(v144, []any{v101}) -v146 := lang.Apply(v141, []any{v145}) -v138 = v146 -} else { -v138 = v132 -} -if lang.IsTruthy(v138) { -v132 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v133 := v132.FindInternedVar(lang.NewSymbol("first")) -if v133.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v133))) -} -v134 := v133.Get() -v135 := lang.Apply(v134, []any{v101}) -v131 = v135 -} else { -v131 = nil -} -var v130 any = v131 -_ = v130 -var v137 any -if lang.IsTruthy(v130) { -v138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v139 := v138.FindInternedVar(lang.NewSymbol("next")) -if v139.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v139))) -} -v140 := v139.Get() -v141 := lang.Apply(v140, []any{v136}) -v137 = v141 -} else { -v137 = v136 -} -var v136 any = v137 -_ = v136 -var v143 any = v142 -_ = v143 -var v145 any -if lang.IsTruthy(v143) { -v145 = v143 -} else { -v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v147 := v146.FindInternedVar(lang.NewSymbol("meta")) -if v147.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) -} -v148 := v147.Get() -v149 := lang.Apply(v148, []any{v100}) -v145 = v149 -} -var v142 any = v145 -_ = v142 -v144 := lang.Apply(lang.NewKeyword("pre"), []any{v142}) -var v143 any = v144 -_ = v143 -v146 := lang.Apply(lang.NewKeyword("post"), []any{v142}) -var v145 any = v146 -_ = v145 -var v148 any -if lang.IsTruthy(v145) { -v149 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v150 := v149.FindInternedVar(lang.NewSymbol("seq")) -if v150.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v150))) -} -v151 := v150.Get() -v152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v153 := v152.FindInternedVar(lang.NewSymbol("concat")) -if v153.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v153))) -} -v154 := v153.Get() -v155 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v156 := v155.FindInternedVar(lang.NewSymbol("list")) -if v156.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v156))) -} -v157 := v156.Get() -v158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v159 := v158.FindInternedVar(lang.NewSymbol("seq")) -if v159.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v159))) -} -v160 := v159.Get() -v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v162 := v161.FindInternedVar(lang.NewSymbol("concat")) -if v162.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) -} -v163 := v162.Get() -v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v165 := v164.FindInternedVar(lang.NewSymbol("list")) -if v165.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) -} -v166 := v165.Get() -v167 := lang.Apply(v166, []any{lang.NewSymbol("glojure.core/let")}) -v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v169 := v168.FindInternedVar(lang.NewSymbol("list")) -if v169.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) -} -v170 := v169.Get() -v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v172 := v171.FindInternedVar(lang.NewSymbol("apply")) -if v172.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) -} -v173 := v172.Get() -v174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v175 := v174.FindInternedVar(lang.NewSymbol("vector")) -if v175.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v175))) -} -v176 := v175.Get() -v177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v178 := v177.FindInternedVar(lang.NewSymbol("seq")) -if v178.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v178))) -} -v179 := v178.Get() -v180 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v181 := v180.FindInternedVar(lang.NewSymbol("concat")) -if v181.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v181))) -} -v182 := v181.Get() -v183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v184 := v183.FindInternedVar(lang.NewSymbol("list")) -if v184.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v184))) -} -v185 := v184.Get() -v186 := lang.Apply(v185, []any{lang.NewSymbol("%")}) -v187 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v188 := v187.FindInternedVar(lang.NewSymbol("list")) -if v188.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v188))) -} -v189 := v188.Get() -var v190 any -v191 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v192 := v191.FindInternedVar(lang.NewSymbol("<")) -if v192.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v192))) -} -v193 := v192.Get() -v194 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v195 := v194.FindInternedVar(lang.NewSymbol("count")) -if v195.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v195))) -} -v196 := v195.Get() -v197 := lang.Apply(v196, []any{v147}) -v198 := lang.Apply(v193, []any{int64(1), v197}) -if lang.IsTruthy(v198) { -v199 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v200 := v199.FindInternedVar(lang.NewSymbol("seq")) -if v200.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v200))) -} -v201 := v200.Get() -v202 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v203 := v202.FindInternedVar(lang.NewSymbol("concat")) -if v203.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v203))) -} -v204 := v203.Get() -v205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v206 := v205.FindInternedVar(lang.NewSymbol("list")) -if v206.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v206))) -} -v207 := v206.Get() -v208 := lang.Apply(v207, []any{lang.NewSymbol("do")}) -v209 := lang.Apply(v204, []any{v208, v147}) -v210 := lang.Apply(v201, []any{v209}) -v190 = v210 -} else { -v211 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v212 := v211.FindInternedVar(lang.NewSymbol("first")) -if v212.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v212))) -} -v213 := v212.Get() -v214 := lang.Apply(v213, []any{v147}) -v190 = v214 -} -v215 := lang.Apply(v189, []any{v190}) -v216 := lang.Apply(v182, []any{v186, v215}) -v217 := lang.Apply(v179, []any{v216}) -v218 := lang.Apply(v173, []any{v176, v217}) -v219 := lang.Apply(v170, []any{v218}) -v220 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v221 := v220.FindInternedVar(lang.NewSymbol("map")) -if v221.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v221))) -} -v222 := v221.Get() -var v223 lang.FnFunc -v223 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v224 := args[0] -v225 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v226 := v225.FindInternedVar(lang.NewSymbol("seq")) -if v226.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v226))) -} -v227 := v226.Get() -v228 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v229 := v228.FindInternedVar(lang.NewSymbol("concat")) -if v229.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v229))) -} -v230 := v229.Get() -v231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v232 := v231.FindInternedVar(lang.NewSymbol("list")) -if v232.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v232))) -} -v233 := v232.Get() -v234 := lang.Apply(v233, []any{lang.NewSymbol("glojure.core/assert")}) -v235 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v236 := v235.FindInternedVar(lang.NewSymbol("list")) -if v236.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v236))) -} -v237 := v236.Get() -v238 := lang.Apply(v237, []any{v224}) -v239 := lang.Apply(v230, []any{v234, v238}) -v240 := lang.Apply(v227, []any{v239}) -return v240 -}) -v224 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4582), lang.NewKeyword("column"), int(41), lang.NewKeyword("end-line"), int(4582), lang.NewKeyword("end-column"), int(62)) -v225, err := lang.WithMeta(v223, v224.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v226 := lang.Apply(v222, []any{v225, v145}) -v227 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v228 := v227.FindInternedVar(lang.NewSymbol("list")) -if v228.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v228))) -} -v229 := v228.Get() -v230 := lang.Apply(v229, []any{lang.NewSymbol("%")}) -v231 := lang.Apply(v163, []any{v167, v219, v226, v230}) -v232 := lang.Apply(v160, []any{v231}) -v233 := lang.Apply(v157, []any{v232}) -v234 := lang.Apply(v154, []any{v233}) -v235 := lang.Apply(v151, []any{v234}) -v148 = v235 -} else { -v148 = v147 -} -var v147 any = v148 -_ = v147 -var v237 any -if lang.IsTruthy(v143) { -v238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v239 := v238.FindInternedVar(lang.NewSymbol("concat")) -if v239.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v239))) -} -v240 := v239.Get() -v241 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v242 := v241.FindInternedVar(lang.NewSymbol("map")) -if v242.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v242))) -} -v243 := v242.Get() -var v244 lang.FnFunc -v244 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v245 := args[0] -v246 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v247 := v246.FindInternedVar(lang.NewSymbol("seq")) -if v247.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v247))) -} -v248 := v247.Get() -v249 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v250 := v249.FindInternedVar(lang.NewSymbol("concat")) -if v250.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v250))) -} -v251 := v250.Get() -v252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v253 := v252.FindInternedVar(lang.NewSymbol("list")) -if v253.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v253))) -} -v254 := v253.Get() -v255 := lang.Apply(v254, []any{lang.NewSymbol("glojure.core/assert")}) -v256 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v257 := v256.FindInternedVar(lang.NewSymbol("list")) -if v257.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v257))) -} -v258 := v257.Get() -v259 := lang.Apply(v258, []any{v245}) -v260 := lang.Apply(v251, []any{v255, v259}) -v261 := lang.Apply(v248, []any{v260}) -return v261 -}) -v245 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4586), lang.NewKeyword("column"), int(44), lang.NewKeyword("end-line"), int(4586), lang.NewKeyword("end-column"), int(65)) -v246, err := lang.WithMeta(v244, v245.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v247 := lang.Apply(v243, []any{v246, v143}) -v248 := lang.Apply(v240, []any{v247, v236}) -v237 = v248 -} else { -v237 = v236 -} -var v236 any = v237 -_ = v236 -v250 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v251 := v250.FindInternedVar(lang.NewSymbol("maybe-destructured")) -if v251.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v251))) -} -v252 := v251.Get() -v253 := lang.Apply(v252, []any{v100, v236}) -return v253 -}) -v69 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4558), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(4589), lang.NewKeyword("end-column"), int(53)) -v70, err := lang.WithMeta(v68, v69.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v67 any = v70 -_ = v67 -v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v73 := v72.FindInternedVar(lang.NewSymbol("map")) -if v73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) -} -v74 := v73.Get() -v75 := lang.Apply(v74, []any{v67, v26}) -var v71 any = v75 -_ = v71 -v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v78 := v77.FindInternedVar(lang.NewSymbol("with-meta")) -if v78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) -} -v79 := v78.Get() -var v80 any -if lang.IsTruthy(v6) { -v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v82 := v81.FindInternedVar(lang.NewSymbol("list*")) -if v82.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) -} -v83 := v82.Get() -v84 := lang.Apply(v83, []any{lang.NewSymbol("fn*"), v6, v71}) -v80 = v84 -} else { -v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v86 := v85.FindInternedVar(lang.NewSymbol("cons")) -if v86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) -} -v87 := v86.Get() -v88 := lang.Apply(v87, []any{lang.NewSymbol("fn*"), v71}) -v80 = v88 -} -v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v90 := v89.FindInternedVar(lang.NewSymbol("meta")) -if v90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) -} -v91 := v90.Get() -v92 := lang.Apply(v91, []any{v3}) -v93 := lang.Apply(v79, []any{v80, v92}) -return v93 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// fn? -{ -v0 := lang.NewSymbol("fn?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements Fn, i.e. is an object created via fn.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6216), lang.NewKeyword("end-line"), int(6216))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{runtime5.*Fn, v3}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// fnext -{ -v0 := lang.NewSymbol("fnext").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Same as (first (next x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(112), lang.NewKeyword("end-line"), int(116))).(*lang.Symbol) -var v2 lang.FnFunc -{ // function fnext -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("first")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("next")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v4}) -v12 := lang.Apply(v7, []any{v11}) -return v12 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(116), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(116), lang.NewKeyword("end-column"), int(47))).(lang.FnFunc) -v3 := v2 -_ = v3 -} -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// fnil -{ -v0 := lang.NewSymbol("fnil").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("z"))), lang.NewKeyword("doc"), "Takes a function f, and returns a function that calls f, replacing\n a nil first argument to f with the supplied value x. Higher arity\n versions can replace arguments in the second and third\n positions (y, z). Note that the function f can take any number of\n arguments, not just the one(s) being nil-patched.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6558), lang.NewKeyword("end-line"), int(6558))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v3 := args[0] -v4 := args[1] -var v5 lang.FnFunc -v5 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v6 := args[0] -var v7 any -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("nil?")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v6}) -if lang.IsTruthy(v11) { -v7 = v4 -} else { -v7 = v6 -} -v12 := lang.Apply(v3, []any{v7}) -return v12 - case 2: -v6 := args[0] -v7 := args[1] -var v8 any -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("nil?")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v6}) -if lang.IsTruthy(v12) { -v8 = v4 -} else { -v8 = v6 -} -v13 := lang.Apply(v3, []any{v8, v7}) -return v13 - case 3: -v6 := args[0] -v7 := args[1] -v8 := args[2] -var v9 any -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("nil?")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{v6}) -if lang.IsTruthy(v13) { -v9 = v4 -} else { -v9 = v6 -} -v14 := lang.Apply(v3, []any{v9, v7, v8}) -return v14 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v6 := args[0] -v7 := args[1] -v8 := args[2] -v9 := lang.NewList(args[3:]...) -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("apply")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -var v13 any -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("nil?")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v6}) -if lang.IsTruthy(v17) { -v13 = v4 -} else { -v13 = v6 -} -v18 := lang.Apply(v12, []any{v3, v13, v7, v8, v9}) -return v18 - } -}) -v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6567), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(6571), lang.NewKeyword("end-column"), int(55)) -v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v7 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -var v6 lang.FnFunc -v6 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v7 := args[0] -v8 := args[1] -var v9 any -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("nil?")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{v7}) -if lang.IsTruthy(v13) { -v9 = v4 -} else { -v9 = v7 -} -var v14 any -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("nil?")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v8}) -if lang.IsTruthy(v18) { -v14 = v5 -} else { -v14 = v8 -} -v19 := lang.Apply(v3, []any{v9, v14}) -return v19 - case 3: -v7 := args[0] -v8 := args[1] -v9 := args[2] -var v10 any -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("nil?")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v7}) -if lang.IsTruthy(v14) { -v10 = v4 -} else { -v10 = v7 -} -var v15 any -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("nil?")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v8}) -if lang.IsTruthy(v19) { -v15 = v5 -} else { -v15 = v8 -} -v20 := lang.Apply(v3, []any{v10, v15, v9}) -return v20 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v7 := args[0] -v8 := args[1] -v9 := args[2] -v10 := lang.NewList(args[3:]...) -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("apply")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -var v14 any -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("nil?")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v7}) -if lang.IsTruthy(v18) { -v14 = v4 -} else { -v14 = v7 -} -var v19 any -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("nil?")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.Apply(v22, []any{v8}) -if lang.IsTruthy(v23) { -v19 = v5 -} else { -v19 = v8 -} -v24 := lang.Apply(v13, []any{v3, v14, v19, v9, v10}) -return v24 - } -}) -v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6573), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(6576), lang.NewKeyword("end-column"), int(71)) -v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v8 - case 4: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -var v7 lang.FnFunc -v7 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v8 := args[0] -v9 := args[1] -var v10 any -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("nil?")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v8}) -if lang.IsTruthy(v14) { -v10 = v4 -} else { -v10 = v8 -} -var v15 any -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("nil?")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v9}) -if lang.IsTruthy(v19) { -v15 = v5 -} else { -v15 = v9 -} -v20 := lang.Apply(v3, []any{v10, v15}) -return v20 - case 3: -v8 := args[0] -v9 := args[1] -v10 := args[2] -var v11 any -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("nil?")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v8}) -if lang.IsTruthy(v15) { -v11 = v4 -} else { -v11 = v8 -} -var v16 any -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("nil?")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v9}) -if lang.IsTruthy(v20) { -v16 = v5 -} else { -v16 = v9 -} -var v21 any -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("nil?")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v10}) -if lang.IsTruthy(v25) { -v21 = v6 -} else { -v21 = v10 -} -v26 := lang.Apply(v3, []any{v11, v16, v21}) -return v26 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v8 := args[0] -v9 := args[1] -v10 := args[2] -v11 := lang.NewList(args[3:]...) -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("apply")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -var v15 any -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("nil?")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v8}) -if lang.IsTruthy(v19) { -v15 = v4 -} else { -v15 = v8 -} -var v20 any -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("nil?")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v9}) -if lang.IsTruthy(v24) { -v20 = v5 -} else { -v20 = v9 -} -var v25 any -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("nil?")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.Apply(v28, []any{v10}) -if lang.IsTruthy(v29) { -v25 = v6 -} else { -v25 = v10 -} -v30 := lang.Apply(v14, []any{v3, v15, v20, v25, v11}) -return v30 - } -}) -v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6578), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(6581), lang.NewKeyword("end-column"), int(87)) -v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v9 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// for -{ -v0 := lang.NewSymbol("for").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("seq-exprs"), lang.NewSymbol("body-expr"))), lang.NewKeyword("doc"), "List comprehension. Takes a vector of one or more\n binding-form/collection-expr pairs, each followed by zero or more\n modifiers, and yields a lazy sequence of evaluations of expr.\n Collections are iterated in a nested fashion, rightmost fastest,\n and nested coll-exprs can refer to bindings created in prior\n binding-forms. Supported modifiers are: :let [binding-form expr ...],\n :while test, :when test.\n\n (take 100 (for [x (range 100000000) y (range 1000000) :while (< y x)] [x y]))", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4646), lang.NewKeyword("end-line"), int(4646))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -var v7 any -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v5}) -if lang.IsTruthy(v11) { -v7 = nil -} else { -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("str")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("first")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v3}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("meta")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) -v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) -v28 := lang.Apply(lang.NewIllegalArgumentError, []any{v27}) -panic(v28) -} -_ = v7 -var v29 any -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("even?")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("count")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v5}) -v37 := lang.Apply(v32, []any{v36}) -if lang.IsTruthy(v37) { -v29 = nil -} else { -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("str")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("first")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v3}) -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("meta")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v3}) -v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) -v53 := lang.Apply(v40, []any{v44, " requires ", "an even number of forms in binding vector", " in ", v47, ":", v52}) -v54 := lang.Apply(lang.NewIllegalArgumentError, []any{v53}) -panic(v54) -} -_ = v29 -_ = nil -var v56 lang.FnFunc -v56 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v57 := args[0] -v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v59 := v58.FindInternedVar(lang.NewSymbol("reduce1")) -if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) -} -v60 := v59.Get() -var v61 lang.FnFunc -v61 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v62 := args[0] -v63 := args[1] -var v64 any = v63 -_ = v64 -v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v67 := v66.FindInternedVar(lang.NewSymbol("nth")) -if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) -} -v68 := v67.Get() -v69 := lang.Apply(v68, []any{v64, int64(0), nil}) -var v65 any = v69 -_ = v65 -v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v72 := v71.FindInternedVar(lang.NewSymbol("nth")) -if v72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) -} -v73 := v72.Get() -v74 := lang.Apply(v73, []any{v64, int64(1), nil}) -var v70 any = v74 -_ = v70 -var v76 any -v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v78 := v77.FindInternedVar(lang.NewSymbol("keyword?")) -if v78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) -} -v79 := v78.Get() -v80 := lang.Apply(v79, []any{v65}) -if lang.IsTruthy(v80) { -v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v82 := v81.FindInternedVar(lang.NewSymbol("conj")) -if v82.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) -} -v83 := v82.Get() -v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v85 := v84.FindInternedVar(lang.NewSymbol("pop")) -if v85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) -} -v86 := v85.Get() -v87 := lang.Apply(v86, []any{v62}) -v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v89 := v88.FindInternedVar(lang.NewSymbol("conj")) -if v89.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) -} -v90 := v89.Get() -v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v92 := v91.FindInternedVar(lang.NewSymbol("peek")) -if v92.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) -} -v93 := v92.Get() -v94 := lang.Apply(v93, []any{v62}) -v95 := lang.NewVector(v65, v70) -v96 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4664), lang.NewKeyword("column"), int(72), lang.NewKeyword("end-line"), int(4664), lang.NewKeyword("end-column"), int(76)) -v97, err := lang.WithMeta(v95, v96.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v98 := lang.Apply(v90, []any{v94, v97}) -v99 := lang.Apply(v83, []any{v87, v98}) -v76 = v99 -} else { -v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v101 := v100.FindInternedVar(lang.NewSymbol("conj")) -if v101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) -} -v102 := v101.Get() -v103 := lang.NewVector(v65, v70) -v104 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4665), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(4665), lang.NewKeyword("end-column"), int(50)) -v105, err := lang.WithMeta(v103, v104.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v106 := lang.Apply(v102, []any{v62, v105}) -v76 = v106 -} -return v76 -}) -v62 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4662), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(4665), lang.NewKeyword("end-column"), int(53)) -v63, err := lang.WithMeta(v61, v62.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v64 := lang.NewVector() -v65 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4666), lang.NewKeyword("column"), int(29), lang.NewKeyword("end-line"), int(4666), lang.NewKeyword("end-column"), int(30)) -v66, err := lang.WithMeta(v64, v65.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v68 := v67.FindInternedVar(lang.NewSymbol("partition")) -if v68.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) -} -v69 := v68.Get() -v70 := lang.Apply(v69, []any{int64(2), v57}) -v71 := lang.Apply(v60, []any{v63, v66, v70}) -return v71 -}) -v57 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4661), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(4666), lang.NewKeyword("end-column"), int(56)) -v58, err := lang.WithMeta(v56, v57.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v55 any = v58 -_ = v55 -var v60 lang.FnFunc -v60 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v61 := lang.NewList(args[0:]...) -v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v63 := v62.FindInternedVar(lang.NewSymbol("apply")) -if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) -} -v64 := v63.Get() -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("str")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) -} -v67 := v66.Get() -v68 := lang.Apply(v64, []any{v67, v61}) -v69 := lang.Apply(lang.NewIllegalArgumentError, []any{v68}) -panic(v69) - } -}) -v61 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4667), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(4667), lang.NewKeyword("end-column"), int(125)) -v62, err := lang.WithMeta(v60, v61.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v59 any = v62 -_ = v59 -var v64 lang.FnFunc -{ // function emit-bind -v64 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v66 := args[0] -var v67 any = v66 -_ = v67 -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("seq")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) -} -v71 := v70.Get() -v72 := lang.Apply(v71, []any{v67}) -var v68 any = v72 -_ = v68 -v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v75 := v74.FindInternedVar(lang.NewSymbol("first")) -if v75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) -} -v76 := v75.Get() -v77 := lang.Apply(v76, []any{v68}) -var v73 any = v77 -_ = v73 -v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v80 := v79.FindInternedVar(lang.NewSymbol("next")) -if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) -} -v81 := v80.Get() -v82 := lang.Apply(v81, []any{v78}) -var v78 any = v82 -_ = v78 -var v83 any = v73 -_ = v83 -v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v86 := v85.FindInternedVar(lang.NewSymbol("seq")) -if v86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) -} -v87 := v86.Get() -v88 := lang.Apply(v87, []any{v83}) -var v84 any = v88 -_ = v84 -v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v91 := v90.FindInternedVar(lang.NewSymbol("first")) -if v91.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) -} -v92 := v91.Get() -v93 := lang.Apply(v92, []any{v84}) -var v89 any = v93 -_ = v89 -v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v96 := v95.FindInternedVar(lang.NewSymbol("next")) -if v96.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) -} -v97 := v96.Get() -v98 := lang.Apply(v97, []any{v94}) -var v94 any = v98 -_ = v94 -var v99 any = v89 -_ = v99 -v101 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v102 := v101.FindInternedVar(lang.NewSymbol("first")) -if v102.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v102))) -} -v103 := v102.Get() -v104 := lang.Apply(v103, []any{v94}) -var v100 any = v104 -_ = v100 -v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v107 := v106.FindInternedVar(lang.NewSymbol("next")) -if v107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) -} -v108 := v107.Get() -v109 := lang.Apply(v108, []any{v105}) -var v105 any = v109 -_ = v105 -var v110 any = v100 -_ = v110 -var v111 any = v105 -_ = v111 -var v112 any = v78 -_ = v112 -v114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v115 := v114.FindInternedVar(lang.NewSymbol("nth")) -if v115.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v115))) -} -v116 := v115.Get() -v117 := lang.Apply(v116, []any{v112, int64(0), nil}) -var v113 any = v117 -_ = v113 -v119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v120 := v119.FindInternedVar(lang.NewSymbol("nth")) -if v120.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v120))) -} -v121 := v120.Get() -v122 := lang.Apply(v121, []any{v113, int64(0), nil}) -var v118 any = v122 -_ = v118 -v124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v125 := v124.FindInternedVar(lang.NewSymbol("nth")) -if v125.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v125))) -} -v126 := v125.Get() -v127 := lang.Apply(v126, []any{v113, int64(1), nil}) -var v123 any = v127 -_ = v123 -var v128 any = v112 -_ = v128 -v131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v132 := v131.FindInternedVar(lang.NewSymbol("gensym")) -if v132.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v132))) -} -v133 := v132.Get() -v134 := lang.Apply(v133, []any{"iter__"}) -var v130 any = v134 -_ = v130 -v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v137 := v136.FindInternedVar(lang.NewSymbol("gensym")) -if v137.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) -} -v138 := v137.Get() -v139 := lang.Apply(v138, []any{"s__"}) -var v135 any = v139 -_ = v135 -var v141 lang.FnFunc -{ // function do-mod -v141 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v143 := args[0] -var v144 any = v143 -_ = v144 -v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v147 := v146.FindInternedVar(lang.NewSymbol("seq")) -if v147.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) -} -v148 := v147.Get() -v149 := lang.Apply(v148, []any{v144}) -var v145 any = v149 -_ = v145 -v151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v152 := v151.FindInternedVar(lang.NewSymbol("first")) -if v152.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v152))) -} -v153 := v152.Get() -v154 := lang.Apply(v153, []any{v145}) -var v150 any = v154 -_ = v150 -v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v157 := v156.FindInternedVar(lang.NewSymbol("next")) -if v157.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) -} -v158 := v157.Get() -v159 := lang.Apply(v158, []any{v155}) -var v155 any = v159 -_ = v155 -var v160 any = v150 -_ = v160 -v162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v163 := v162.FindInternedVar(lang.NewSymbol("nth")) -if v163.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v163))) -} -v164 := v163.Get() -v165 := lang.Apply(v164, []any{v160, int64(0), nil}) -var v161 any = v165 -_ = v161 -v167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v168 := v167.FindInternedVar(lang.NewSymbol("nth")) -if v168.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v168))) -} -v169 := v168.Get() -v170 := lang.Apply(v169, []any{v160, int64(1), nil}) -var v166 any = v170 -_ = v166 -var v171 any = v160 -_ = v171 -var v172 any = v155 -_ = v172 -var v174 any -v175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v176 := v175.FindInternedVar(lang.NewSymbol("=")) -if v176.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v176))) -} -v177 := v176.Get() -v178 := lang.Apply(v177, []any{v161, lang.NewKeyword("let")}) -if lang.IsTruthy(v178) { -v179 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v180 := v179.FindInternedVar(lang.NewSymbol("seq")) -if v180.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v180))) -} -v181 := v180.Get() -v182 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v183 := v182.FindInternedVar(lang.NewSymbol("concat")) -if v183.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v183))) -} -v184 := v183.Get() -v185 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v186 := v185.FindInternedVar(lang.NewSymbol("list")) -if v186.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v186))) -} -v187 := v186.Get() -v188 := lang.Apply(v187, []any{lang.NewSymbol("glojure.core/let")}) -v189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v190 := v189.FindInternedVar(lang.NewSymbol("list")) -if v190.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v190))) -} -v191 := v190.Get() -v192 := lang.Apply(v191, []any{v166}) -v193 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v194 := v193.FindInternedVar(lang.NewSymbol("list")) -if v194.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v194))) -} -v195 := v194.Get() -v196 := lang.Apply(v142, []any{v172}) -v197 := lang.Apply(v195, []any{v196}) -v198 := lang.Apply(v184, []any{v188, v192, v197}) -v199 := lang.Apply(v181, []any{v198}) -v174 = v199 -} else { -var v200 any -v201 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v202 := v201.FindInternedVar(lang.NewSymbol("=")) -if v202.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v202))) -} -v203 := v202.Get() -v204 := lang.Apply(v203, []any{v161, lang.NewKeyword("while")}) -if lang.IsTruthy(v204) { -v205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v206 := v205.FindInternedVar(lang.NewSymbol("seq")) -if v206.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v206))) -} -v207 := v206.Get() -v208 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v209 := v208.FindInternedVar(lang.NewSymbol("concat")) -if v209.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v209))) -} -v210 := v209.Get() -v211 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v212 := v211.FindInternedVar(lang.NewSymbol("list")) -if v212.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v212))) -} -v213 := v212.Get() -v214 := lang.Apply(v213, []any{lang.NewSymbol("glojure.core/when")}) -v215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v216 := v215.FindInternedVar(lang.NewSymbol("list")) -if v216.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v216))) -} -v217 := v216.Get() -v218 := lang.Apply(v217, []any{v166}) -v219 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v220 := v219.FindInternedVar(lang.NewSymbol("list")) -if v220.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v220))) -} -v221 := v220.Get() -v222 := lang.Apply(v142, []any{v172}) -v223 := lang.Apply(v221, []any{v222}) -v224 := lang.Apply(v210, []any{v214, v218, v223}) -v225 := lang.Apply(v207, []any{v224}) -v200 = v225 -} else { -var v226 any -v227 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v228 := v227.FindInternedVar(lang.NewSymbol("=")) -if v228.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v228))) -} -v229 := v228.Get() -v230 := lang.Apply(v229, []any{v161, lang.NewKeyword("when")}) -if lang.IsTruthy(v230) { -v231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v232 := v231.FindInternedVar(lang.NewSymbol("seq")) -if v232.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v232))) -} -v233 := v232.Get() -v234 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v235 := v234.FindInternedVar(lang.NewSymbol("concat")) -if v235.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v235))) -} -v236 := v235.Get() -v237 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v238 := v237.FindInternedVar(lang.NewSymbol("list")) -if v238.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v238))) -} -v239 := v238.Get() -v240 := lang.Apply(v239, []any{lang.NewSymbol("if")}) -v241 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v242 := v241.FindInternedVar(lang.NewSymbol("list")) -if v242.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v242))) -} -v243 := v242.Get() -v244 := lang.Apply(v243, []any{v166}) -v245 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v246 := v245.FindInternedVar(lang.NewSymbol("list")) -if v246.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v246))) -} -v247 := v246.Get() -v248 := lang.Apply(v142, []any{v172}) -v249 := lang.Apply(v247, []any{v248}) -v250 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v251 := v250.FindInternedVar(lang.NewSymbol("list")) -if v251.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v251))) -} -v252 := v251.Get() -v253 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v254 := v253.FindInternedVar(lang.NewSymbol("seq")) -if v254.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v254))) -} -v255 := v254.Get() -v256 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v257 := v256.FindInternedVar(lang.NewSymbol("concat")) -if v257.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v257))) -} -v258 := v257.Get() -v259 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v260 := v259.FindInternedVar(lang.NewSymbol("list")) -if v260.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v260))) -} -v261 := v260.Get() -v262 := lang.Apply(v261, []any{lang.NewSymbol("recur")}) -v263 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v264 := v263.FindInternedVar(lang.NewSymbol("list")) -if v264.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v264))) -} -v265 := v264.Get() -v266 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v267 := v266.FindInternedVar(lang.NewSymbol("seq")) -if v267.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v267))) -} -v268 := v267.Get() -v269 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v270 := v269.FindInternedVar(lang.NewSymbol("concat")) -if v270.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v270))) -} -v271 := v270.Get() -v272 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v273 := v272.FindInternedVar(lang.NewSymbol("list")) -if v273.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v273))) -} -v274 := v273.Get() -v275 := lang.Apply(v274, []any{lang.NewSymbol("glojure.core/rest")}) -v276 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v277 := v276.FindInternedVar(lang.NewSymbol("list")) -if v277.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v277))) -} -v278 := v277.Get() -v279 := lang.Apply(v278, []any{v135}) -v280 := lang.Apply(v271, []any{v275, v279}) -v281 := lang.Apply(v268, []any{v280}) -v282 := lang.Apply(v265, []any{v281}) -v283 := lang.Apply(v258, []any{v262, v282}) -v284 := lang.Apply(v255, []any{v283}) -v285 := lang.Apply(v252, []any{v284}) -v286 := lang.Apply(v236, []any{v240, v244, v249, v285}) -v287 := lang.Apply(v233, []any{v286}) -v226 = v287 -} else { -var v288 any -v289 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v290 := v289.FindInternedVar(lang.NewSymbol("keyword?")) -if v290.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v290))) -} -v291 := v290.Get() -v292 := lang.Apply(v291, []any{v161}) -if lang.IsTruthy(v292) { -v293 := lang.Apply(v59, []any{"Invalid 'for' keyword ", v161}) -v288 = v293 -} else { -var v294 any -if lang.IsTruthy(v128) { -v295 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v296 := v295.FindInternedVar(lang.NewSymbol("seq")) -if v296.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v296))) -} -v297 := v296.Get() -v298 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v299 := v298.FindInternedVar(lang.NewSymbol("concat")) -if v299.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v299))) -} -v300 := v299.Get() -v301 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v302 := v301.FindInternedVar(lang.NewSymbol("list")) -if v302.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v302))) -} -v303 := v302.Get() -v304 := lang.Apply(v303, []any{lang.NewSymbol("glojure.core/let")}) -v305 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v306 := v305.FindInternedVar(lang.NewSymbol("list")) -if v306.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v306))) -} -v307 := v306.Get() -v308 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v309 := v308.FindInternedVar(lang.NewSymbol("apply")) -if v309.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v309))) -} -v310 := v309.Get() -v311 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v312 := v311.FindInternedVar(lang.NewSymbol("vector")) -if v312.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v312))) -} -v313 := v312.Get() -v314 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v315 := v314.FindInternedVar(lang.NewSymbol("seq")) -if v315.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v315))) -} -v316 := v315.Get() -v317 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v318 := v317.FindInternedVar(lang.NewSymbol("concat")) -if v318.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v318))) -} -v319 := v318.Get() -v320 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v321 := v320.FindInternedVar(lang.NewSymbol("list")) -if v321.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v321))) -} -v322 := v321.Get() -v323 := lang.Apply(v322, []any{lang.NewSymbol("iterys__0__auto__")}) -v324 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v325 := v324.FindInternedVar(lang.NewSymbol("list")) -if v325.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v325))) -} -v326 := v325.Get() -v327 := lang.Apply(v65, []any{v128}) -v328 := lang.Apply(v326, []any{v327}) -v329 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v330 := v329.FindInternedVar(lang.NewSymbol("list")) -if v330.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v330))) -} -v331 := v330.Get() -v332 := lang.Apply(v331, []any{lang.NewSymbol("fs__1__auto__")}) -v333 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v334 := v333.FindInternedVar(lang.NewSymbol("list")) -if v334.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v334))) -} -v335 := v334.Get() -v336 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v337 := v336.FindInternedVar(lang.NewSymbol("seq")) -if v337.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v337))) -} -v338 := v337.Get() -v339 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v340 := v339.FindInternedVar(lang.NewSymbol("concat")) -if v340.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v340))) -} -v341 := v340.Get() -v342 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v343 := v342.FindInternedVar(lang.NewSymbol("list")) -if v343.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v343))) -} -v344 := v343.Get() -v345 := lang.Apply(v344, []any{lang.NewSymbol("glojure.core/seq")}) -v346 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v347 := v346.FindInternedVar(lang.NewSymbol("list")) -if v347.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v347))) -} -v348 := v347.Get() -v349 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v350 := v349.FindInternedVar(lang.NewSymbol("seq")) -if v350.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v350))) -} -v351 := v350.Get() -v352 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v353 := v352.FindInternedVar(lang.NewSymbol("concat")) -if v353.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v353))) -} -v354 := v353.Get() -v355 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v356 := v355.FindInternedVar(lang.NewSymbol("list")) -if v356.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v356))) -} -v357 := v356.Get() -v358 := lang.Apply(v357, []any{lang.NewSymbol("iterys__0__auto__")}) -v359 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v360 := v359.FindInternedVar(lang.NewSymbol("list")) -if v360.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v360))) -} -v361 := v360.Get() -v362 := lang.Apply(v361, []any{v123}) -v363 := lang.Apply(v354, []any{v358, v362}) -v364 := lang.Apply(v351, []any{v363}) -v365 := lang.Apply(v348, []any{v364}) -v366 := lang.Apply(v341, []any{v345, v365}) -v367 := lang.Apply(v338, []any{v366}) -v368 := lang.Apply(v335, []any{v367}) -v369 := lang.Apply(v319, []any{v323, v328, v332, v368}) -v370 := lang.Apply(v316, []any{v369}) -v371 := lang.Apply(v310, []any{v313, v370}) -v372 := lang.Apply(v307, []any{v371}) -v373 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v374 := v373.FindInternedVar(lang.NewSymbol("list")) -if v374.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v374))) -} -v375 := v374.Get() -v376 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v377 := v376.FindInternedVar(lang.NewSymbol("seq")) -if v377.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v377))) -} -v378 := v377.Get() -v379 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v380 := v379.FindInternedVar(lang.NewSymbol("concat")) -if v380.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v380))) -} -v381 := v380.Get() -v382 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v383 := v382.FindInternedVar(lang.NewSymbol("list")) -if v383.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v383))) -} -v384 := v383.Get() -v385 := lang.Apply(v384, []any{lang.NewSymbol("if")}) -v386 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v387 := v386.FindInternedVar(lang.NewSymbol("list")) -if v387.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v387))) -} -v388 := v387.Get() -v389 := lang.Apply(v388, []any{lang.NewSymbol("fs__1__auto__")}) -v390 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v391 := v390.FindInternedVar(lang.NewSymbol("list")) -if v391.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v391))) -} -v392 := v391.Get() -v393 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v394 := v393.FindInternedVar(lang.NewSymbol("seq")) -if v394.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v394))) -} -v395 := v394.Get() -v396 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v397 := v396.FindInternedVar(lang.NewSymbol("concat")) -if v397.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v397))) -} -v398 := v397.Get() -v399 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v400 := v399.FindInternedVar(lang.NewSymbol("list")) -if v400.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v400))) -} -v401 := v400.Get() -v402 := lang.Apply(v401, []any{lang.NewSymbol("glojure.core/concat")}) -v403 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v404 := v403.FindInternedVar(lang.NewSymbol("list")) -if v404.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v404))) -} -v405 := v404.Get() -v406 := lang.Apply(v405, []any{lang.NewSymbol("fs__1__auto__")}) -v407 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v408 := v407.FindInternedVar(lang.NewSymbol("list")) -if v408.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v408))) -} -v409 := v408.Get() -v410 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v411 := v410.FindInternedVar(lang.NewSymbol("seq")) -if v411.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v411))) -} -v412 := v411.Get() -v413 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v414 := v413.FindInternedVar(lang.NewSymbol("concat")) -if v414.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v414))) -} -v415 := v414.Get() -v416 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v417 := v416.FindInternedVar(lang.NewSymbol("list")) -if v417.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v417))) -} -v418 := v417.Get() -v419 := lang.Apply(v418, []any{v130}) -v420 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v421 := v420.FindInternedVar(lang.NewSymbol("list")) -if v421.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v421))) -} -v422 := v421.Get() -v423 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v424 := v423.FindInternedVar(lang.NewSymbol("seq")) -if v424.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v424))) -} -v425 := v424.Get() -v426 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v427 := v426.FindInternedVar(lang.NewSymbol("concat")) -if v427.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v427))) -} -v428 := v427.Get() -v429 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v430 := v429.FindInternedVar(lang.NewSymbol("list")) -if v430.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v430))) -} -v431 := v430.Get() -v432 := lang.Apply(v431, []any{lang.NewSymbol("glojure.core/rest")}) -v433 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v434 := v433.FindInternedVar(lang.NewSymbol("list")) -if v434.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v434))) -} -v435 := v434.Get() -v436 := lang.Apply(v435, []any{v135}) -v437 := lang.Apply(v428, []any{v432, v436}) -v438 := lang.Apply(v425, []any{v437}) -v439 := lang.Apply(v422, []any{v438}) -v440 := lang.Apply(v415, []any{v419, v439}) -v441 := lang.Apply(v412, []any{v440}) -v442 := lang.Apply(v409, []any{v441}) -v443 := lang.Apply(v398, []any{v402, v406, v442}) -v444 := lang.Apply(v395, []any{v443}) -v445 := lang.Apply(v392, []any{v444}) -v446 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v447 := v446.FindInternedVar(lang.NewSymbol("list")) -if v447.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v447))) -} -v448 := v447.Get() -v449 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v450 := v449.FindInternedVar(lang.NewSymbol("seq")) -if v450.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v450))) -} -v451 := v450.Get() -v452 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v453 := v452.FindInternedVar(lang.NewSymbol("concat")) -if v453.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v453))) -} -v454 := v453.Get() -v455 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v456 := v455.FindInternedVar(lang.NewSymbol("list")) -if v456.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v456))) -} -v457 := v456.Get() -v458 := lang.Apply(v457, []any{lang.NewSymbol("recur")}) -v459 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v460 := v459.FindInternedVar(lang.NewSymbol("list")) -if v460.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v460))) -} -v461 := v460.Get() -v462 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v463 := v462.FindInternedVar(lang.NewSymbol("seq")) -if v463.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v463))) -} -v464 := v463.Get() -v465 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v466 := v465.FindInternedVar(lang.NewSymbol("concat")) -if v466.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v466))) -} -v467 := v466.Get() -v468 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v469 := v468.FindInternedVar(lang.NewSymbol("list")) -if v469.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v469))) -} -v470 := v469.Get() -v471 := lang.Apply(v470, []any{lang.NewSymbol("glojure.core/rest")}) -v472 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v473 := v472.FindInternedVar(lang.NewSymbol("list")) -if v473.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v473))) -} -v474 := v473.Get() -v475 := lang.Apply(v474, []any{v135}) -v476 := lang.Apply(v467, []any{v471, v475}) -v477 := lang.Apply(v464, []any{v476}) -v478 := lang.Apply(v461, []any{v477}) -v479 := lang.Apply(v454, []any{v458, v478}) -v480 := lang.Apply(v451, []any{v479}) -v481 := lang.Apply(v448, []any{v480}) -v482 := lang.Apply(v381, []any{v385, v389, v445, v481}) -v483 := lang.Apply(v378, []any{v482}) -v484 := lang.Apply(v375, []any{v483}) -v485 := lang.Apply(v300, []any{v304, v372, v484}) -v486 := lang.Apply(v297, []any{v485}) -v294 = v486 -} else { -var v487 any -if lang.IsTruthy(lang.NewKeyword("else")) { -v488 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v489 := v488.FindInternedVar(lang.NewSymbol("seq")) -if v489.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v489))) -} -v490 := v489.Get() -v491 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v492 := v491.FindInternedVar(lang.NewSymbol("concat")) -if v492.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v492))) -} -v493 := v492.Get() -v494 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v495 := v494.FindInternedVar(lang.NewSymbol("list")) -if v495.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v495))) -} -v496 := v495.Get() -v497 := lang.Apply(v496, []any{lang.NewSymbol("glojure.core/cons")}) -v498 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v499 := v498.FindInternedVar(lang.NewSymbol("list")) -if v499.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v499))) -} -v500 := v499.Get() -v501 := lang.Apply(v500, []any{v6}) -v502 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v503 := v502.FindInternedVar(lang.NewSymbol("list")) -if v503.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v503))) -} -v504 := v503.Get() -v505 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v506 := v505.FindInternedVar(lang.NewSymbol("seq")) -if v506.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v506))) -} -v507 := v506.Get() -v508 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v509 := v508.FindInternedVar(lang.NewSymbol("concat")) -if v509.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v509))) -} -v510 := v509.Get() -v511 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v512 := v511.FindInternedVar(lang.NewSymbol("list")) -if v512.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v512))) -} -v513 := v512.Get() -v514 := lang.Apply(v513, []any{v130}) -v515 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v516 := v515.FindInternedVar(lang.NewSymbol("list")) -if v516.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v516))) -} -v517 := v516.Get() -v518 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v519 := v518.FindInternedVar(lang.NewSymbol("seq")) -if v519.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v519))) -} -v520 := v519.Get() -v521 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v522 := v521.FindInternedVar(lang.NewSymbol("concat")) -if v522.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v522))) -} -v523 := v522.Get() -v524 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v525 := v524.FindInternedVar(lang.NewSymbol("list")) -if v525.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v525))) -} -v526 := v525.Get() -v527 := lang.Apply(v526, []any{lang.NewSymbol("glojure.core/rest")}) -v528 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v529 := v528.FindInternedVar(lang.NewSymbol("list")) -if v529.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v529))) -} -v530 := v529.Get() -v531 := lang.Apply(v530, []any{v135}) -v532 := lang.Apply(v523, []any{v527, v531}) -v533 := lang.Apply(v520, []any{v532}) -v534 := lang.Apply(v517, []any{v533}) -v535 := lang.Apply(v510, []any{v514, v534}) -v536 := lang.Apply(v507, []any{v535}) -v537 := lang.Apply(v504, []any{v536}) -v538 := lang.Apply(v493, []any{v497, v501, v537}) -v539 := lang.Apply(v490, []any{v538}) -v487 = v539 -} else { -v487 = nil -} -v294 = v487 -} -v288 = v294 -} -v226 = v288 -} -v200 = v226 -} -v174 = v200 -} -return v174 -}) -v142 := v141 -_ = v142 -} -v142 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4672), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(4687), lang.NewKeyword("end-column"), int(73)) -v143, err := lang.WithMeta(v141, v142.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v140 any = v143 -_ = v140 -var v145 any -if lang.IsTruthy(v128) { -v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v147 := v146.FindInternedVar(lang.NewSymbol("seq")) -if v147.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) -} -v148 := v147.Get() -v149 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v150 := v149.FindInternedVar(lang.NewSymbol("concat")) -if v150.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v150))) -} -v151 := v150.Get() -v152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v153 := v152.FindInternedVar(lang.NewSymbol("list")) -if v153.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v153))) -} -v154 := v153.Get() -v155 := lang.Apply(v154, []any{lang.NewSymbol("glojure.core/fn")}) -v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v157 := v156.FindInternedVar(lang.NewSymbol("list")) -if v157.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) -} -v158 := v157.Get() -v159 := lang.Apply(v158, []any{v130}) -v160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v161 := v160.FindInternedVar(lang.NewSymbol("list")) -if v161.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v161))) -} -v162 := v161.Get() -v163 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v164 := v163.FindInternedVar(lang.NewSymbol("apply")) -if v164.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v164))) -} -v165 := v164.Get() -v166 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v167 := v166.FindInternedVar(lang.NewSymbol("vector")) -if v167.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v167))) -} -v168 := v167.Get() -v169 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v170 := v169.FindInternedVar(lang.NewSymbol("seq")) -if v170.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v170))) -} -v171 := v170.Get() -v172 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v173 := v172.FindInternedVar(lang.NewSymbol("concat")) -if v173.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v173))) -} -v174 := v173.Get() -v175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v176 := v175.FindInternedVar(lang.NewSymbol("list")) -if v176.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v176))) -} -v177 := v176.Get() -v178 := lang.Apply(v177, []any{v135}) -v179 := lang.Apply(v174, []any{v178}) -v180 := lang.Apply(v171, []any{v179}) -v181 := lang.Apply(v165, []any{v168, v180}) -v182 := lang.Apply(v162, []any{v181}) -v183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v184 := v183.FindInternedVar(lang.NewSymbol("list")) -if v184.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v184))) -} -v185 := v184.Get() -v186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v187 := v186.FindInternedVar(lang.NewSymbol("seq")) -if v187.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v187))) -} -v188 := v187.Get() -v189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v190 := v189.FindInternedVar(lang.NewSymbol("concat")) -if v190.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v190))) -} -v191 := v190.Get() -v192 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v193 := v192.FindInternedVar(lang.NewSymbol("list")) -if v193.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v193))) -} -v194 := v193.Get() -v195 := lang.Apply(v194, []any{lang.NewSymbol("glojure.core/lazy-seq")}) -v196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v197 := v196.FindInternedVar(lang.NewSymbol("list")) -if v197.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v197))) -} -v198 := v197.Get() -v199 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v200 := v199.FindInternedVar(lang.NewSymbol("seq")) -if v200.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v200))) -} -v201 := v200.Get() -v202 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v203 := v202.FindInternedVar(lang.NewSymbol("concat")) -if v203.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v203))) -} -v204 := v203.Get() -v205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v206 := v205.FindInternedVar(lang.NewSymbol("list")) -if v206.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v206))) -} -v207 := v206.Get() -v208 := lang.Apply(v207, []any{lang.NewSymbol("glojure.core/loop")}) -v209 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v210 := v209.FindInternedVar(lang.NewSymbol("list")) -if v210.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v210))) -} -v211 := v210.Get() -v212 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v213 := v212.FindInternedVar(lang.NewSymbol("apply")) -if v213.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v213))) -} -v214 := v213.Get() -v215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v216 := v215.FindInternedVar(lang.NewSymbol("vector")) -if v216.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v216))) -} -v217 := v216.Get() -v218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v219 := v218.FindInternedVar(lang.NewSymbol("seq")) -if v219.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v219))) -} -v220 := v219.Get() -v221 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v222 := v221.FindInternedVar(lang.NewSymbol("concat")) -if v222.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v222))) -} -v223 := v222.Get() -v224 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v225 := v224.FindInternedVar(lang.NewSymbol("list")) -if v225.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v225))) -} -v226 := v225.Get() -v227 := lang.Apply(v226, []any{v135}) -v228 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v229 := v228.FindInternedVar(lang.NewSymbol("list")) -if v229.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v229))) -} -v230 := v229.Get() -v231 := lang.Apply(v230, []any{v135}) -v232 := lang.Apply(v223, []any{v227, v231}) -v233 := lang.Apply(v220, []any{v232}) -v234 := lang.Apply(v214, []any{v217, v233}) -v235 := lang.Apply(v211, []any{v234}) -v236 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v237 := v236.FindInternedVar(lang.NewSymbol("list")) -if v237.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v237))) -} -v238 := v237.Get() -v239 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v240 := v239.FindInternedVar(lang.NewSymbol("seq")) -if v240.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v240))) -} -v241 := v240.Get() -v242 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v243 := v242.FindInternedVar(lang.NewSymbol("concat")) -if v243.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v243))) -} -v244 := v243.Get() -v245 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v246 := v245.FindInternedVar(lang.NewSymbol("list")) -if v246.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v246))) -} -v247 := v246.Get() -v248 := lang.Apply(v247, []any{lang.NewSymbol("glojure.core/when-first")}) -v249 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v250 := v249.FindInternedVar(lang.NewSymbol("list")) -if v250.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v250))) -} -v251 := v250.Get() -v252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v253 := v252.FindInternedVar(lang.NewSymbol("apply")) -if v253.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v253))) -} -v254 := v253.Get() -v255 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v256 := v255.FindInternedVar(lang.NewSymbol("vector")) -if v256.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v256))) -} -v257 := v256.Get() -v258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v259 := v258.FindInternedVar(lang.NewSymbol("seq")) -if v259.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v259))) -} -v260 := v259.Get() -v261 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v262 := v261.FindInternedVar(lang.NewSymbol("concat")) -if v262.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v262))) -} -v263 := v262.Get() -v264 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v265 := v264.FindInternedVar(lang.NewSymbol("list")) -if v265.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v265))) -} -v266 := v265.Get() -v267 := lang.Apply(v266, []any{v99}) -v268 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v269 := v268.FindInternedVar(lang.NewSymbol("list")) -if v269.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v269))) -} -v270 := v269.Get() -v271 := lang.Apply(v270, []any{v135}) -v272 := lang.Apply(v263, []any{v267, v271}) -v273 := lang.Apply(v260, []any{v272}) -v274 := lang.Apply(v254, []any{v257, v273}) -v275 := lang.Apply(v251, []any{v274}) -v276 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v277 := v276.FindInternedVar(lang.NewSymbol("list")) -if v277.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v277))) -} -v278 := v277.Get() -v279 := lang.Apply(v140, []any{v111}) -v280 := lang.Apply(v278, []any{v279}) -v281 := lang.Apply(v244, []any{v248, v275, v280}) -v282 := lang.Apply(v241, []any{v281}) -v283 := lang.Apply(v238, []any{v282}) -v284 := lang.Apply(v204, []any{v208, v235, v283}) -v285 := lang.Apply(v201, []any{v284}) -v286 := lang.Apply(v198, []any{v285}) -v287 := lang.Apply(v191, []any{v195, v286}) -v288 := lang.Apply(v188, []any{v287}) -v289 := lang.Apply(v185, []any{v288}) -v290 := lang.Apply(v151, []any{v155, v159, v182, v289}) -v291 := lang.Apply(v148, []any{v290}) -v145 = v291 -} else { -v293 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v294 := v293.FindInternedVar(lang.NewSymbol("gensym")) -if v294.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v294))) -} -v295 := v294.Get() -v296 := lang.Apply(v295, []any{"i__"}) -var v292 any = v296 -_ = v292 -v298 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v299 := v298.FindInternedVar(lang.NewSymbol("gensym")) -if v299.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v299))) -} -v300 := v299.Get() -v301 := lang.Apply(v300, []any{"b__"}) -var v297 any = v301 -_ = v297 -var v303 lang.FnFunc -{ // function do-cmod -v303 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v305 := args[0] -var v306 any = v305 -_ = v306 -v308 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v309 := v308.FindInternedVar(lang.NewSymbol("seq")) -if v309.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v309))) -} -v310 := v309.Get() -v311 := lang.Apply(v310, []any{v306}) -var v307 any = v311 -_ = v307 -v313 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v314 := v313.FindInternedVar(lang.NewSymbol("first")) -if v314.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v314))) -} -v315 := v314.Get() -v316 := lang.Apply(v315, []any{v307}) -var v312 any = v316 -_ = v312 -v318 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v319 := v318.FindInternedVar(lang.NewSymbol("next")) -if v319.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v319))) -} -v320 := v319.Get() -v321 := lang.Apply(v320, []any{v317}) -var v317 any = v321 -_ = v317 -var v322 any = v312 -_ = v322 -v324 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v325 := v324.FindInternedVar(lang.NewSymbol("nth")) -if v325.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v325))) -} -v326 := v325.Get() -v327 := lang.Apply(v326, []any{v322, int64(0), nil}) -var v323 any = v327 -_ = v323 -v329 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v330 := v329.FindInternedVar(lang.NewSymbol("nth")) -if v330.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v330))) -} -v331 := v330.Get() -v332 := lang.Apply(v331, []any{v322, int64(1), nil}) -var v328 any = v332 -_ = v328 -var v333 any = v322 -_ = v333 -var v334 any = v317 -_ = v334 -var v336 any -v337 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v338 := v337.FindInternedVar(lang.NewSymbol("=")) -if v338.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v338))) -} -v339 := v338.Get() -v340 := lang.Apply(v339, []any{v323, lang.NewKeyword("let")}) -if lang.IsTruthy(v340) { -v341 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v342 := v341.FindInternedVar(lang.NewSymbol("seq")) -if v342.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v342))) -} -v343 := v342.Get() -v344 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v345 := v344.FindInternedVar(lang.NewSymbol("concat")) -if v345.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v345))) -} -v346 := v345.Get() -v347 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v348 := v347.FindInternedVar(lang.NewSymbol("list")) -if v348.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v348))) -} -v349 := v348.Get() -v350 := lang.Apply(v349, []any{lang.NewSymbol("glojure.core/let")}) -v351 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v352 := v351.FindInternedVar(lang.NewSymbol("list")) -if v352.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v352))) -} -v353 := v352.Get() -v354 := lang.Apply(v353, []any{v328}) -v355 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v356 := v355.FindInternedVar(lang.NewSymbol("list")) -if v356.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v356))) -} -v357 := v356.Get() -v358 := lang.Apply(v304, []any{v334}) -v359 := lang.Apply(v357, []any{v358}) -v360 := lang.Apply(v346, []any{v350, v354, v359}) -v361 := lang.Apply(v343, []any{v360}) -v336 = v361 -} else { -var v362 any -v363 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v364 := v363.FindInternedVar(lang.NewSymbol("=")) -if v364.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v364))) -} -v365 := v364.Get() -v366 := lang.Apply(v365, []any{v323, lang.NewKeyword("while")}) -if lang.IsTruthy(v366) { -v367 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v368 := v367.FindInternedVar(lang.NewSymbol("seq")) -if v368.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v368))) -} -v369 := v368.Get() -v370 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v371 := v370.FindInternedVar(lang.NewSymbol("concat")) -if v371.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v371))) -} -v372 := v371.Get() -v373 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v374 := v373.FindInternedVar(lang.NewSymbol("list")) -if v374.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v374))) -} -v375 := v374.Get() -v376 := lang.Apply(v375, []any{lang.NewSymbol("glojure.core/when")}) -v377 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v378 := v377.FindInternedVar(lang.NewSymbol("list")) -if v378.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v378))) -} -v379 := v378.Get() -v380 := lang.Apply(v379, []any{v328}) -v381 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v382 := v381.FindInternedVar(lang.NewSymbol("list")) -if v382.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v382))) -} -v383 := v382.Get() -v384 := lang.Apply(v304, []any{v334}) -v385 := lang.Apply(v383, []any{v384}) -v386 := lang.Apply(v372, []any{v376, v380, v385}) -v387 := lang.Apply(v369, []any{v386}) -v362 = v387 -} else { -var v388 any -v389 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v390 := v389.FindInternedVar(lang.NewSymbol("=")) -if v390.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v390))) -} -v391 := v390.Get() -v392 := lang.Apply(v391, []any{v323, lang.NewKeyword("when")}) -if lang.IsTruthy(v392) { -v393 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v394 := v393.FindInternedVar(lang.NewSymbol("seq")) -if v394.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v394))) -} -v395 := v394.Get() -v396 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v397 := v396.FindInternedVar(lang.NewSymbol("concat")) -if v397.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v397))) -} -v398 := v397.Get() -v399 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v400 := v399.FindInternedVar(lang.NewSymbol("list")) -if v400.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v400))) -} -v401 := v400.Get() -v402 := lang.Apply(v401, []any{lang.NewSymbol("if")}) -v403 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v404 := v403.FindInternedVar(lang.NewSymbol("list")) -if v404.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v404))) -} -v405 := v404.Get() -v406 := lang.Apply(v405, []any{v328}) -v407 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v408 := v407.FindInternedVar(lang.NewSymbol("list")) -if v408.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v408))) -} -v409 := v408.Get() -v410 := lang.Apply(v304, []any{v334}) -v411 := lang.Apply(v409, []any{v410}) -v412 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v413 := v412.FindInternedVar(lang.NewSymbol("list")) -if v413.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v413))) -} -v414 := v413.Get() -v415 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v416 := v415.FindInternedVar(lang.NewSymbol("seq")) -if v416.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v416))) -} -v417 := v416.Get() -v418 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v419 := v418.FindInternedVar(lang.NewSymbol("concat")) -if v419.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v419))) -} -v420 := v419.Get() -v421 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v422 := v421.FindInternedVar(lang.NewSymbol("list")) -if v422.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v422))) -} -v423 := v422.Get() -v424 := lang.Apply(v423, []any{lang.NewSymbol("recur")}) -v425 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v426 := v425.FindInternedVar(lang.NewSymbol("list")) -if v426.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v426))) -} -v427 := v426.Get() -v428 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v429 := v428.FindInternedVar(lang.NewSymbol("seq")) -if v429.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v429))) -} -v430 := v429.Get() -v431 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v432 := v431.FindInternedVar(lang.NewSymbol("concat")) -if v432.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v432))) -} -v433 := v432.Get() -v434 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v435 := v434.FindInternedVar(lang.NewSymbol("list")) -if v435.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v435))) -} -v436 := v435.Get() -v437 := lang.Apply(v436, []any{lang.NewSymbol("glojure.core/unchecked-inc")}) -v438 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v439 := v438.FindInternedVar(lang.NewSymbol("list")) -if v439.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v439))) -} -v440 := v439.Get() -v441 := lang.Apply(v440, []any{v292}) -v442 := lang.Apply(v433, []any{v437, v441}) -v443 := lang.Apply(v430, []any{v442}) -v444 := lang.Apply(v427, []any{v443}) -v445 := lang.Apply(v420, []any{v424, v444}) -v446 := lang.Apply(v417, []any{v445}) -v447 := lang.Apply(v414, []any{v446}) -v448 := lang.Apply(v398, []any{v402, v406, v411, v447}) -v449 := lang.Apply(v395, []any{v448}) -v388 = v449 -} else { -var v450 any -v451 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v452 := v451.FindInternedVar(lang.NewSymbol("keyword?")) -if v452.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v452))) -} -v453 := v452.Get() -v454 := lang.Apply(v453, []any{v323}) -if lang.IsTruthy(v454) { -v455 := lang.Apply(v59, []any{"Invalid 'for' keyword ", v323}) -v450 = v455 -} else { -var v456 any -if lang.IsTruthy(lang.NewKeyword("else")) { -v457 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v458 := v457.FindInternedVar(lang.NewSymbol("seq")) -if v458.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v458))) -} -v459 := v458.Get() -v460 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v461 := v460.FindInternedVar(lang.NewSymbol("concat")) -if v461.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v461))) -} -v462 := v461.Get() -v463 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v464 := v463.FindInternedVar(lang.NewSymbol("list")) -if v464.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v464))) -} -v465 := v464.Get() -v466 := lang.Apply(v465, []any{lang.NewSymbol("do")}) -v467 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v468 := v467.FindInternedVar(lang.NewSymbol("list")) -if v468.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v468))) -} -v469 := v468.Get() -v470 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v471 := v470.FindInternedVar(lang.NewSymbol("seq")) -if v471.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v471))) -} -v472 := v471.Get() -v473 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v474 := v473.FindInternedVar(lang.NewSymbol("concat")) -if v474.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v474))) -} -v475 := v474.Get() -v476 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v477 := v476.FindInternedVar(lang.NewSymbol("list")) -if v477.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v477))) -} -v478 := v477.Get() -v479 := lang.Apply(v478, []any{lang.NewSymbol("glojure.core/chunk-append")}) -v480 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v481 := v480.FindInternedVar(lang.NewSymbol("list")) -if v481.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v481))) -} -v482 := v481.Get() -v483 := lang.Apply(v482, []any{v297}) -v484 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v485 := v484.FindInternedVar(lang.NewSymbol("list")) -if v485.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v485))) -} -v486 := v485.Get() -v487 := lang.Apply(v486, []any{v6}) -v488 := lang.Apply(v475, []any{v479, v483, v487}) -v489 := lang.Apply(v472, []any{v488}) -v490 := lang.Apply(v469, []any{v489}) -v491 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v492 := v491.FindInternedVar(lang.NewSymbol("list")) -if v492.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v492))) -} -v493 := v492.Get() -v494 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v495 := v494.FindInternedVar(lang.NewSymbol("seq")) -if v495.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v495))) -} -v496 := v495.Get() -v497 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v498 := v497.FindInternedVar(lang.NewSymbol("concat")) -if v498.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v498))) -} -v499 := v498.Get() -v500 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v501 := v500.FindInternedVar(lang.NewSymbol("list")) -if v501.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v501))) -} -v502 := v501.Get() -v503 := lang.Apply(v502, []any{lang.NewSymbol("recur")}) -v504 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v505 := v504.FindInternedVar(lang.NewSymbol("list")) -if v505.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v505))) -} -v506 := v505.Get() -v507 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v508 := v507.FindInternedVar(lang.NewSymbol("seq")) -if v508.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v508))) -} -v509 := v508.Get() -v510 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v511 := v510.FindInternedVar(lang.NewSymbol("concat")) -if v511.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v511))) -} -v512 := v511.Get() -v513 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v514 := v513.FindInternedVar(lang.NewSymbol("list")) -if v514.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v514))) -} -v515 := v514.Get() -v516 := lang.Apply(v515, []any{lang.NewSymbol("glojure.core/unchecked-inc")}) -v517 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v518 := v517.FindInternedVar(lang.NewSymbol("list")) -if v518.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v518))) -} -v519 := v518.Get() -v520 := lang.Apply(v519, []any{v292}) -v521 := lang.Apply(v512, []any{v516, v520}) -v522 := lang.Apply(v509, []any{v521}) -v523 := lang.Apply(v506, []any{v522}) -v524 := lang.Apply(v499, []any{v503, v523}) -v525 := lang.Apply(v496, []any{v524}) -v526 := lang.Apply(v493, []any{v525}) -v527 := lang.Apply(v462, []any{v466, v490, v526}) -v528 := lang.Apply(v459, []any{v527}) -v456 = v528 -} else { -v456 = nil -} -v450 = v456 -} -v388 = v450 -} -v362 = v388 -} -v336 = v362 -} -return v336 -}) -v304 := v303 -_ = v304 -} -v304 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4698), lang.NewKeyword("column"), int(39), lang.NewKeyword("end-line"), int(4710), lang.NewKeyword("end-column"), int(79)) -v305, err := lang.WithMeta(v303, v304.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v302 any = v305 -_ = v302 -v307 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v308 := v307.FindInternedVar(lang.NewSymbol("seq")) -if v308.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v308))) -} -v309 := v308.Get() -v310 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v311 := v310.FindInternedVar(lang.NewSymbol("concat")) -if v311.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v311))) -} -v312 := v311.Get() -v313 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v314 := v313.FindInternedVar(lang.NewSymbol("list")) -if v314.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v314))) -} -v315 := v314.Get() -v316 := lang.Apply(v315, []any{lang.NewSymbol("glojure.core/fn")}) -v317 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v318 := v317.FindInternedVar(lang.NewSymbol("list")) -if v318.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v318))) -} -v319 := v318.Get() -v320 := lang.Apply(v319, []any{v130}) -v321 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v322 := v321.FindInternedVar(lang.NewSymbol("list")) -if v322.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v322))) -} -v323 := v322.Get() -v324 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v325 := v324.FindInternedVar(lang.NewSymbol("apply")) -if v325.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v325))) -} -v326 := v325.Get() -v327 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v328 := v327.FindInternedVar(lang.NewSymbol("vector")) -if v328.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v328))) -} -v329 := v328.Get() -v330 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v331 := v330.FindInternedVar(lang.NewSymbol("seq")) -if v331.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v331))) -} -v332 := v331.Get() -v333 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v334 := v333.FindInternedVar(lang.NewSymbol("concat")) -if v334.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v334))) -} -v335 := v334.Get() -v336 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v337 := v336.FindInternedVar(lang.NewSymbol("list")) -if v337.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v337))) -} -v338 := v337.Get() -v339 := lang.Apply(v338, []any{v135}) -v340 := lang.Apply(v335, []any{v339}) -v341 := lang.Apply(v332, []any{v340}) -v342 := lang.Apply(v326, []any{v329, v341}) -v343 := lang.Apply(v323, []any{v342}) -v344 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v345 := v344.FindInternedVar(lang.NewSymbol("list")) -if v345.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v345))) -} -v346 := v345.Get() -v347 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v348 := v347.FindInternedVar(lang.NewSymbol("seq")) -if v348.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v348))) -} -v349 := v348.Get() -v350 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v351 := v350.FindInternedVar(lang.NewSymbol("concat")) -if v351.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v351))) -} -v352 := v351.Get() -v353 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v354 := v353.FindInternedVar(lang.NewSymbol("list")) -if v354.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v354))) -} -v355 := v354.Get() -v356 := lang.Apply(v355, []any{lang.NewSymbol("glojure.core/lazy-seq")}) -v357 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v358 := v357.FindInternedVar(lang.NewSymbol("list")) -if v358.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v358))) -} -v359 := v358.Get() -v360 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v361 := v360.FindInternedVar(lang.NewSymbol("seq")) -if v361.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v361))) -} -v362 := v361.Get() -v363 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v364 := v363.FindInternedVar(lang.NewSymbol("concat")) -if v364.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v364))) -} -v365 := v364.Get() -v366 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v367 := v366.FindInternedVar(lang.NewSymbol("list")) -if v367.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v367))) -} -v368 := v367.Get() -v369 := lang.Apply(v368, []any{lang.NewSymbol("glojure.core/loop")}) -v370 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v371 := v370.FindInternedVar(lang.NewSymbol("list")) -if v371.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v371))) -} -v372 := v371.Get() -v373 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v374 := v373.FindInternedVar(lang.NewSymbol("apply")) -if v374.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v374))) -} -v375 := v374.Get() -v376 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v377 := v376.FindInternedVar(lang.NewSymbol("vector")) -if v377.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v377))) -} -v378 := v377.Get() -v379 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v380 := v379.FindInternedVar(lang.NewSymbol("seq")) -if v380.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v380))) -} -v381 := v380.Get() -v382 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v383 := v382.FindInternedVar(lang.NewSymbol("concat")) -if v383.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v383))) -} -v384 := v383.Get() -v385 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v386 := v385.FindInternedVar(lang.NewSymbol("list")) -if v386.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v386))) -} -v387 := v386.Get() -v388 := lang.Apply(v387, []any{v135}) -v389 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v390 := v389.FindInternedVar(lang.NewSymbol("list")) -if v390.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v390))) -} -v391 := v390.Get() -v392 := lang.Apply(v391, []any{v135}) -v393 := lang.Apply(v384, []any{v388, v392}) -v394 := lang.Apply(v381, []any{v393}) -v395 := lang.Apply(v375, []any{v378, v394}) -v396 := lang.Apply(v372, []any{v395}) -v397 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v398 := v397.FindInternedVar(lang.NewSymbol("list")) -if v398.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v398))) -} -v399 := v398.Get() -v400 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v401 := v400.FindInternedVar(lang.NewSymbol("seq")) -if v401.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v401))) -} -v402 := v401.Get() -v403 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v404 := v403.FindInternedVar(lang.NewSymbol("concat")) -if v404.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v404))) -} -v405 := v404.Get() -v406 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v407 := v406.FindInternedVar(lang.NewSymbol("list")) -if v407.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v407))) -} -v408 := v407.Get() -v409 := lang.Apply(v408, []any{lang.NewSymbol("glojure.core/when-let")}) -v410 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v411 := v410.FindInternedVar(lang.NewSymbol("list")) -if v411.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v411))) -} -v412 := v411.Get() -v413 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v414 := v413.FindInternedVar(lang.NewSymbol("apply")) -if v414.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v414))) -} -v415 := v414.Get() -v416 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v417 := v416.FindInternedVar(lang.NewSymbol("vector")) -if v417.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v417))) -} -v418 := v417.Get() -v419 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v420 := v419.FindInternedVar(lang.NewSymbol("seq")) -if v420.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v420))) -} -v421 := v420.Get() -v422 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v423 := v422.FindInternedVar(lang.NewSymbol("concat")) -if v423.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v423))) -} -v424 := v423.Get() -v425 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v426 := v425.FindInternedVar(lang.NewSymbol("list")) -if v426.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v426))) -} -v427 := v426.Get() -v428 := lang.Apply(v427, []any{v135}) -v429 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v430 := v429.FindInternedVar(lang.NewSymbol("list")) -if v430.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v430))) -} -v431 := v430.Get() -v432 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v433 := v432.FindInternedVar(lang.NewSymbol("seq")) -if v433.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v433))) -} -v434 := v433.Get() -v435 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v436 := v435.FindInternedVar(lang.NewSymbol("concat")) -if v436.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v436))) -} -v437 := v436.Get() -v438 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v439 := v438.FindInternedVar(lang.NewSymbol("list")) -if v439.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v439))) -} -v440 := v439.Get() -v441 := lang.Apply(v440, []any{lang.NewSymbol("glojure.core/seq")}) -v442 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v443 := v442.FindInternedVar(lang.NewSymbol("list")) -if v443.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v443))) -} -v444 := v443.Get() -v445 := lang.Apply(v444, []any{v135}) -v446 := lang.Apply(v437, []any{v441, v445}) -v447 := lang.Apply(v434, []any{v446}) -v448 := lang.Apply(v431, []any{v447}) -v449 := lang.Apply(v424, []any{v428, v448}) -v450 := lang.Apply(v421, []any{v449}) -v451 := lang.Apply(v415, []any{v418, v450}) -v452 := lang.Apply(v412, []any{v451}) -v453 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v454 := v453.FindInternedVar(lang.NewSymbol("list")) -if v454.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v454))) -} -v455 := v454.Get() -v456 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v457 := v456.FindInternedVar(lang.NewSymbol("seq")) -if v457.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v457))) -} -v458 := v457.Get() -v459 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v460 := v459.FindInternedVar(lang.NewSymbol("concat")) -if v460.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v460))) -} -v461 := v460.Get() -v462 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v463 := v462.FindInternedVar(lang.NewSymbol("list")) -if v463.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v463))) -} -v464 := v463.Get() -v465 := lang.Apply(v464, []any{lang.NewSymbol("if")}) -v466 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v467 := v466.FindInternedVar(lang.NewSymbol("list")) -if v467.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v467))) -} -v468 := v467.Get() -v469 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v470 := v469.FindInternedVar(lang.NewSymbol("seq")) -if v470.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v470))) -} -v471 := v470.Get() -v472 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v473 := v472.FindInternedVar(lang.NewSymbol("concat")) -if v473.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v473))) -} -v474 := v473.Get() -v475 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v476 := v475.FindInternedVar(lang.NewSymbol("list")) -if v476.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v476))) -} -v477 := v476.Get() -v478 := lang.Apply(v477, []any{lang.NewSymbol("glojure.core/chunked-seq?")}) -v479 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v480 := v479.FindInternedVar(lang.NewSymbol("list")) -if v480.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v480))) -} -v481 := v480.Get() -v482 := lang.Apply(v481, []any{v135}) -v483 := lang.Apply(v474, []any{v478, v482}) -v484 := lang.Apply(v471, []any{v483}) -v485 := lang.Apply(v468, []any{v484}) -v486 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v487 := v486.FindInternedVar(lang.NewSymbol("list")) -if v487.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v487))) -} -v488 := v487.Get() -v489 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v490 := v489.FindInternedVar(lang.NewSymbol("seq")) -if v490.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v490))) -} -v491 := v490.Get() -v492 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v493 := v492.FindInternedVar(lang.NewSymbol("concat")) -if v493.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v493))) -} -v494 := v493.Get() -v495 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v496 := v495.FindInternedVar(lang.NewSymbol("list")) -if v496.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v496))) -} -v497 := v496.Get() -v498 := lang.Apply(v497, []any{lang.NewSymbol("glojure.core/let")}) -v499 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v500 := v499.FindInternedVar(lang.NewSymbol("list")) -if v500.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v500))) -} -v501 := v500.Get() -v502 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v503 := v502.FindInternedVar(lang.NewSymbol("apply")) -if v503.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v503))) -} -v504 := v503.Get() -v505 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v506 := v505.FindInternedVar(lang.NewSymbol("vector")) -if v506.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v506))) -} -v507 := v506.Get() -v508 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v509 := v508.FindInternedVar(lang.NewSymbol("seq")) -if v509.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v509))) -} -v510 := v509.Get() -v511 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v512 := v511.FindInternedVar(lang.NewSymbol("concat")) -if v512.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v512))) -} -v513 := v512.Get() -v514 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v515 := v514.FindInternedVar(lang.NewSymbol("list")) -if v515.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v515))) -} -v516 := v515.Get() -v517 := lang.Apply(v516, []any{lang.NewSymbol("c__0__auto__")}) -v518 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v519 := v518.FindInternedVar(lang.NewSymbol("list")) -if v519.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v519))) -} -v520 := v519.Get() -v521 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v522 := v521.FindInternedVar(lang.NewSymbol("seq")) -if v522.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v522))) -} -v523 := v522.Get() -v524 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v525 := v524.FindInternedVar(lang.NewSymbol("concat")) -if v525.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v525))) -} -v526 := v525.Get() -v527 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v528 := v527.FindInternedVar(lang.NewSymbol("list")) -if v528.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v528))) -} -v529 := v528.Get() -v530 := lang.Apply(v529, []any{lang.NewSymbol("glojure.core/chunk-first")}) -v531 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v532 := v531.FindInternedVar(lang.NewSymbol("list")) -if v532.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v532))) -} -v533 := v532.Get() -v534 := lang.Apply(v533, []any{v135}) -v535 := lang.Apply(v526, []any{v530, v534}) -v536 := lang.Apply(v523, []any{v535}) -v537 := lang.Apply(v520, []any{v536}) -v538 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v539 := v538.FindInternedVar(lang.NewSymbol("list")) -if v539.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v539))) -} -v540 := v539.Get() -v541 := lang.Apply(v540, []any{lang.NewSymbol("size__1__auto__")}) -v542 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v543 := v542.FindInternedVar(lang.NewSymbol("list")) -if v543.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v543))) -} -v544 := v543.Get() -v545 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v546 := v545.FindInternedVar(lang.NewSymbol("seq")) -if v546.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v546))) -} -v547 := v546.Get() -v548 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v549 := v548.FindInternedVar(lang.NewSymbol("concat")) -if v549.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v549))) -} -v550 := v549.Get() -v551 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v552 := v551.FindInternedVar(lang.NewSymbol("list")) -if v552.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v552))) -} -v553 := v552.Get() -v554 := lang.Apply(v553, []any{lang.NewSymbol("glojure.core/int")}) -v555 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v556 := v555.FindInternedVar(lang.NewSymbol("list")) -if v556.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v556))) -} -v557 := v556.Get() -v558 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v559 := v558.FindInternedVar(lang.NewSymbol("seq")) -if v559.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v559))) -} -v560 := v559.Get() -v561 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v562 := v561.FindInternedVar(lang.NewSymbol("concat")) -if v562.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v562))) -} -v563 := v562.Get() -v564 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v565 := v564.FindInternedVar(lang.NewSymbol("list")) -if v565.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v565))) -} -v566 := v565.Get() -v567 := lang.Apply(v566, []any{lang.NewSymbol("glojure.core/count")}) -v568 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v569 := v568.FindInternedVar(lang.NewSymbol("list")) -if v569.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v569))) -} -v570 := v569.Get() -v571 := lang.Apply(v570, []any{lang.NewSymbol("c__0__auto__")}) -v572 := lang.Apply(v563, []any{v567, v571}) -v573 := lang.Apply(v560, []any{v572}) -v574 := lang.Apply(v557, []any{v573}) -v575 := lang.Apply(v550, []any{v554, v574}) -v576 := lang.Apply(v547, []any{v575}) -v577 := lang.Apply(v544, []any{v576}) -v578 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v579 := v578.FindInternedVar(lang.NewSymbol("list")) -if v579.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v579))) -} -v580 := v579.Get() -v581 := lang.Apply(v580, []any{v297}) -v582 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v583 := v582.FindInternedVar(lang.NewSymbol("list")) -if v583.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v583))) -} -v584 := v583.Get() -v585 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v586 := v585.FindInternedVar(lang.NewSymbol("seq")) -if v586.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v586))) -} -v587 := v586.Get() -v588 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v589 := v588.FindInternedVar(lang.NewSymbol("concat")) -if v589.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v589))) -} -v590 := v589.Get() -v591 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v592 := v591.FindInternedVar(lang.NewSymbol("list")) -if v592.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v592))) -} -v593 := v592.Get() -v594 := lang.Apply(v593, []any{lang.NewSymbol("glojure.core/chunk-buffer")}) -v595 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v596 := v595.FindInternedVar(lang.NewSymbol("list")) -if v596.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v596))) -} -v597 := v596.Get() -v598 := lang.Apply(v597, []any{lang.NewSymbol("size__1__auto__")}) -v599 := lang.Apply(v590, []any{v594, v598}) -v600 := lang.Apply(v587, []any{v599}) -v601 := lang.Apply(v584, []any{v600}) -v602 := lang.Apply(v513, []any{v517, v537, v541, v577, v581, v601}) -v603 := lang.Apply(v510, []any{v602}) -v604 := lang.Apply(v504, []any{v507, v603}) -v605 := lang.Apply(v501, []any{v604}) -v606 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v607 := v606.FindInternedVar(lang.NewSymbol("list")) -if v607.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v607))) -} -v608 := v607.Get() -v609 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v610 := v609.FindInternedVar(lang.NewSymbol("seq")) -if v610.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v610))) -} -v611 := v610.Get() -v612 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v613 := v612.FindInternedVar(lang.NewSymbol("concat")) -if v613.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v613))) -} -v614 := v613.Get() -v615 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v616 := v615.FindInternedVar(lang.NewSymbol("list")) -if v616.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v616))) -} -v617 := v616.Get() -v618 := lang.Apply(v617, []any{lang.NewSymbol("if")}) -v619 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v620 := v619.FindInternedVar(lang.NewSymbol("list")) -if v620.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v620))) -} -v621 := v620.Get() -v622 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v623 := v622.FindInternedVar(lang.NewSymbol("seq")) -if v623.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v623))) -} -v624 := v623.Get() -v625 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v626 := v625.FindInternedVar(lang.NewSymbol("concat")) -if v626.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v626))) -} -v627 := v626.Get() -v628 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v629 := v628.FindInternedVar(lang.NewSymbol("list")) -if v629.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v629))) -} -v630 := v629.Get() -v631 := lang.Apply(v630, []any{lang.NewSymbol("glojure.core/loop")}) -v632 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v633 := v632.FindInternedVar(lang.NewSymbol("list")) -if v633.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v633))) -} -v634 := v633.Get() -v635 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v636 := v635.FindInternedVar(lang.NewSymbol("apply")) -if v636.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v636))) -} -v637 := v636.Get() -v638 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v639 := v638.FindInternedVar(lang.NewSymbol("vector")) -if v639.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v639))) -} -v640 := v639.Get() -v641 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v642 := v641.FindInternedVar(lang.NewSymbol("seq")) -if v642.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v642))) -} -v643 := v642.Get() -v644 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v645 := v644.FindInternedVar(lang.NewSymbol("concat")) -if v645.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v645))) -} -v646 := v645.Get() -v647 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v648 := v647.FindInternedVar(lang.NewSymbol("list")) -if v648.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v648))) -} -v649 := v648.Get() -v650 := lang.Apply(v649, []any{v292}) -v651 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v652 := v651.FindInternedVar(lang.NewSymbol("list")) -if v652.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v652))) -} -v653 := v652.Get() -v654 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v655 := v654.FindInternedVar(lang.NewSymbol("seq")) -if v655.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v655))) -} -v656 := v655.Get() -v657 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v658 := v657.FindInternedVar(lang.NewSymbol("concat")) -if v658.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v658))) -} -v659 := v658.Get() -v660 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v661 := v660.FindInternedVar(lang.NewSymbol("list")) -if v661.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v661))) -} -v662 := v661.Get() -v663 := lang.Apply(v662, []any{lang.NewSymbol("glojure.core/int")}) -v664 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v665 := v664.FindInternedVar(lang.NewSymbol("list")) -if v665.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v665))) -} -v666 := v665.Get() -v667 := lang.Apply(v666, []any{int64(0)}) -v668 := lang.Apply(v659, []any{v663, v667}) -v669 := lang.Apply(v656, []any{v668}) -v670 := lang.Apply(v653, []any{v669}) -v671 := lang.Apply(v646, []any{v650, v670}) -v672 := lang.Apply(v643, []any{v671}) -v673 := lang.Apply(v637, []any{v640, v672}) -v674 := lang.Apply(v634, []any{v673}) -v675 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v676 := v675.FindInternedVar(lang.NewSymbol("list")) -if v676.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v676))) -} -v677 := v676.Get() -v678 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v679 := v678.FindInternedVar(lang.NewSymbol("seq")) -if v679.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v679))) -} -v680 := v679.Get() -v681 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v682 := v681.FindInternedVar(lang.NewSymbol("concat")) -if v682.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v682))) -} -v683 := v682.Get() -v684 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v685 := v684.FindInternedVar(lang.NewSymbol("list")) -if v685.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v685))) -} -v686 := v685.Get() -v687 := lang.Apply(v686, []any{lang.NewSymbol("if")}) -v688 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v689 := v688.FindInternedVar(lang.NewSymbol("list")) -if v689.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v689))) -} -v690 := v689.Get() -v691 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v692 := v691.FindInternedVar(lang.NewSymbol("seq")) -if v692.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v692))) -} -v693 := v692.Get() -v694 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v695 := v694.FindInternedVar(lang.NewSymbol("concat")) -if v695.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v695))) -} -v696 := v695.Get() -v697 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v698 := v697.FindInternedVar(lang.NewSymbol("list")) -if v698.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v698))) -} -v699 := v698.Get() -v700 := lang.Apply(v699, []any{lang.NewSymbol("glojure.core/<")}) -v701 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v702 := v701.FindInternedVar(lang.NewSymbol("list")) -if v702.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v702))) -} -v703 := v702.Get() -v704 := lang.Apply(v703, []any{v292}) -v705 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v706 := v705.FindInternedVar(lang.NewSymbol("list")) -if v706.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v706))) -} -v707 := v706.Get() -v708 := lang.Apply(v707, []any{lang.NewSymbol("size__1__auto__")}) -v709 := lang.Apply(v696, []any{v700, v704, v708}) -v710 := lang.Apply(v693, []any{v709}) -v711 := lang.Apply(v690, []any{v710}) -v712 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v713 := v712.FindInternedVar(lang.NewSymbol("list")) -if v713.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v713))) -} -v714 := v713.Get() -v715 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v716 := v715.FindInternedVar(lang.NewSymbol("seq")) -if v716.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v716))) -} -v717 := v716.Get() -v718 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v719 := v718.FindInternedVar(lang.NewSymbol("concat")) -if v719.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v719))) -} -v720 := v719.Get() -v721 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v722 := v721.FindInternedVar(lang.NewSymbol("list")) -if v722.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v722))) -} -v723 := v722.Get() -v724 := lang.Apply(v723, []any{lang.NewSymbol("glojure.core/let")}) -v725 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v726 := v725.FindInternedVar(lang.NewSymbol("list")) -if v726.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v726))) -} -v727 := v726.Get() -v728 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v729 := v728.FindInternedVar(lang.NewSymbol("apply")) -if v729.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v729))) -} -v730 := v729.Get() -v731 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v732 := v731.FindInternedVar(lang.NewSymbol("vector")) -if v732.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v732))) -} -v733 := v732.Get() -v734 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v735 := v734.FindInternedVar(lang.NewSymbol("seq")) -if v735.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v735))) -} -v736 := v735.Get() -v737 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v738 := v737.FindInternedVar(lang.NewSymbol("concat")) -if v738.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v738))) -} -v739 := v738.Get() -v740 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v741 := v740.FindInternedVar(lang.NewSymbol("list")) -if v741.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v741))) -} -v742 := v741.Get() -v743 := lang.Apply(v742, []any{v99}) -v744 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v745 := v744.FindInternedVar(lang.NewSymbol("list")) -if v745.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v745))) -} -v746 := v745.Get() -v747 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v748 := v747.FindInternedVar(lang.NewSymbol("seq")) -if v748.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v748))) -} -v749 := v748.Get() -v750 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v751 := v750.FindInternedVar(lang.NewSymbol("concat")) -if v751.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v751))) -} -v752 := v751.Get() -v753 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v754 := v753.FindInternedVar(lang.NewSymbol("list")) -if v754.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v754))) -} -v755 := v754.Get() -v756 := lang.Apply(v755, []any{lang.NewSymbol(".nth")}) -v757 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v758 := v757.FindInternedVar(lang.NewSymbol("list")) -if v758.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v758))) -} -v759 := v758.Get() -v760 := lang.Apply(v759, []any{lang.NewSymbol("c__0__auto__")}) -v761 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v762 := v761.FindInternedVar(lang.NewSymbol("list")) -if v762.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v762))) -} -v763 := v762.Get() -v764 := lang.Apply(v763, []any{v292}) -v765 := lang.Apply(v752, []any{v756, v760, v764}) -v766 := lang.Apply(v749, []any{v765}) -v767 := lang.Apply(v746, []any{v766}) -v768 := lang.Apply(v739, []any{v743, v767}) -v769 := lang.Apply(v736, []any{v768}) -v770 := lang.Apply(v730, []any{v733, v769}) -v771 := lang.Apply(v727, []any{v770}) -v772 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v773 := v772.FindInternedVar(lang.NewSymbol("list")) -if v773.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v773))) -} -v774 := v773.Get() -v775 := lang.Apply(v302, []any{v111}) -v776 := lang.Apply(v774, []any{v775}) -v777 := lang.Apply(v720, []any{v724, v771, v776}) -v778 := lang.Apply(v717, []any{v777}) -v779 := lang.Apply(v714, []any{v778}) -v780 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v781 := v780.FindInternedVar(lang.NewSymbol("list")) -if v781.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v781))) -} -v782 := v781.Get() -v783 := lang.Apply(v782, []any{true}) -v784 := lang.Apply(v683, []any{v687, v711, v779, v783}) -v785 := lang.Apply(v680, []any{v784}) -v786 := lang.Apply(v677, []any{v785}) -v787 := lang.Apply(v627, []any{v631, v674, v786}) -v788 := lang.Apply(v624, []any{v787}) -v789 := lang.Apply(v621, []any{v788}) -v790 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v791 := v790.FindInternedVar(lang.NewSymbol("list")) -if v791.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v791))) -} -v792 := v791.Get() -v793 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v794 := v793.FindInternedVar(lang.NewSymbol("seq")) -if v794.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v794))) -} -v795 := v794.Get() -v796 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v797 := v796.FindInternedVar(lang.NewSymbol("concat")) -if v797.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v797))) -} -v798 := v797.Get() -v799 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v800 := v799.FindInternedVar(lang.NewSymbol("list")) -if v800.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v800))) -} -v801 := v800.Get() -v802 := lang.Apply(v801, []any{lang.NewSymbol("glojure.core/chunk-cons")}) -v803 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v804 := v803.FindInternedVar(lang.NewSymbol("list")) -if v804.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v804))) -} -v805 := v804.Get() -v806 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v807 := v806.FindInternedVar(lang.NewSymbol("seq")) -if v807.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v807))) -} -v808 := v807.Get() -v809 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v810 := v809.FindInternedVar(lang.NewSymbol("concat")) -if v810.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v810))) -} -v811 := v810.Get() -v812 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v813 := v812.FindInternedVar(lang.NewSymbol("list")) -if v813.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v813))) -} -v814 := v813.Get() -v815 := lang.Apply(v814, []any{lang.NewSymbol("glojure.core/chunk")}) -v816 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v817 := v816.FindInternedVar(lang.NewSymbol("list")) -if v817.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v817))) -} -v818 := v817.Get() -v819 := lang.Apply(v818, []any{v297}) -v820 := lang.Apply(v811, []any{v815, v819}) -v821 := lang.Apply(v808, []any{v820}) -v822 := lang.Apply(v805, []any{v821}) -v823 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v824 := v823.FindInternedVar(lang.NewSymbol("list")) -if v824.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v824))) -} -v825 := v824.Get() -v826 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v827 := v826.FindInternedVar(lang.NewSymbol("seq")) -if v827.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v827))) -} -v828 := v827.Get() -v829 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v830 := v829.FindInternedVar(lang.NewSymbol("concat")) -if v830.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v830))) -} -v831 := v830.Get() -v832 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v833 := v832.FindInternedVar(lang.NewSymbol("list")) -if v833.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v833))) -} -v834 := v833.Get() -v835 := lang.Apply(v834, []any{v130}) -v836 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v837 := v836.FindInternedVar(lang.NewSymbol("list")) -if v837.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v837))) -} -v838 := v837.Get() -v839 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v840 := v839.FindInternedVar(lang.NewSymbol("seq")) -if v840.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v840))) -} -v841 := v840.Get() -v842 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v843 := v842.FindInternedVar(lang.NewSymbol("concat")) -if v843.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v843))) -} -v844 := v843.Get() -v845 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v846 := v845.FindInternedVar(lang.NewSymbol("list")) -if v846.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v846))) -} -v847 := v846.Get() -v848 := lang.Apply(v847, []any{lang.NewSymbol("glojure.core/chunk-rest")}) -v849 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v850 := v849.FindInternedVar(lang.NewSymbol("list")) -if v850.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v850))) -} -v851 := v850.Get() -v852 := lang.Apply(v851, []any{v135}) -v853 := lang.Apply(v844, []any{v848, v852}) -v854 := lang.Apply(v841, []any{v853}) -v855 := lang.Apply(v838, []any{v854}) -v856 := lang.Apply(v831, []any{v835, v855}) -v857 := lang.Apply(v828, []any{v856}) -v858 := lang.Apply(v825, []any{v857}) -v859 := lang.Apply(v798, []any{v802, v822, v858}) -v860 := lang.Apply(v795, []any{v859}) -v861 := lang.Apply(v792, []any{v860}) -v862 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v863 := v862.FindInternedVar(lang.NewSymbol("list")) -if v863.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v863))) -} -v864 := v863.Get() -v865 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v866 := v865.FindInternedVar(lang.NewSymbol("seq")) -if v866.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v866))) -} -v867 := v866.Get() -v868 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v869 := v868.FindInternedVar(lang.NewSymbol("concat")) -if v869.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v869))) -} -v870 := v869.Get() -v871 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v872 := v871.FindInternedVar(lang.NewSymbol("list")) -if v872.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v872))) -} -v873 := v872.Get() -v874 := lang.Apply(v873, []any{lang.NewSymbol("glojure.core/chunk-cons")}) -v875 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v876 := v875.FindInternedVar(lang.NewSymbol("list")) -if v876.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v876))) -} -v877 := v876.Get() -v878 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v879 := v878.FindInternedVar(lang.NewSymbol("seq")) -if v879.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v879))) -} -v880 := v879.Get() -v881 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v882 := v881.FindInternedVar(lang.NewSymbol("concat")) -if v882.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v882))) -} -v883 := v882.Get() -v884 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v885 := v884.FindInternedVar(lang.NewSymbol("list")) -if v885.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v885))) -} -v886 := v885.Get() -v887 := lang.Apply(v886, []any{lang.NewSymbol("glojure.core/chunk")}) -v888 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v889 := v888.FindInternedVar(lang.NewSymbol("list")) -if v889.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v889))) -} -v890 := v889.Get() -v891 := lang.Apply(v890, []any{v297}) -v892 := lang.Apply(v883, []any{v887, v891}) -v893 := lang.Apply(v880, []any{v892}) -v894 := lang.Apply(v877, []any{v893}) -v895 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v896 := v895.FindInternedVar(lang.NewSymbol("list")) -if v896.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v896))) -} -v897 := v896.Get() -v898 := lang.Apply(v897, []any{nil}) -v899 := lang.Apply(v870, []any{v874, v894, v898}) -v900 := lang.Apply(v867, []any{v899}) -v901 := lang.Apply(v864, []any{v900}) -v902 := lang.Apply(v614, []any{v618, v789, v861, v901}) -v903 := lang.Apply(v611, []any{v902}) -v904 := lang.Apply(v608, []any{v903}) -v905 := lang.Apply(v494, []any{v498, v605, v904}) -v906 := lang.Apply(v491, []any{v905}) -v907 := lang.Apply(v488, []any{v906}) -v908 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v909 := v908.FindInternedVar(lang.NewSymbol("list")) -if v909.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v909))) -} -v910 := v909.Get() -v911 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v912 := v911.FindInternedVar(lang.NewSymbol("seq")) -if v912.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v912))) -} -v913 := v912.Get() -v914 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v915 := v914.FindInternedVar(lang.NewSymbol("concat")) -if v915.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v915))) -} -v916 := v915.Get() -v917 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v918 := v917.FindInternedVar(lang.NewSymbol("list")) -if v918.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v918))) -} -v919 := v918.Get() -v920 := lang.Apply(v919, []any{lang.NewSymbol("glojure.core/let")}) -v921 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v922 := v921.FindInternedVar(lang.NewSymbol("list")) -if v922.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v922))) -} -v923 := v922.Get() -v924 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v925 := v924.FindInternedVar(lang.NewSymbol("apply")) -if v925.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v925))) -} -v926 := v925.Get() -v927 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v928 := v927.FindInternedVar(lang.NewSymbol("vector")) -if v928.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v928))) -} -v929 := v928.Get() -v930 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v931 := v930.FindInternedVar(lang.NewSymbol("seq")) -if v931.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v931))) -} -v932 := v931.Get() -v933 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v934 := v933.FindInternedVar(lang.NewSymbol("concat")) -if v934.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v934))) -} -v935 := v934.Get() -v936 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v937 := v936.FindInternedVar(lang.NewSymbol("list")) -if v937.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v937))) -} -v938 := v937.Get() -v939 := lang.Apply(v938, []any{v99}) -v940 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v941 := v940.FindInternedVar(lang.NewSymbol("list")) -if v941.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v941))) -} -v942 := v941.Get() -v943 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v944 := v943.FindInternedVar(lang.NewSymbol("seq")) -if v944.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v944))) -} -v945 := v944.Get() -v946 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v947 := v946.FindInternedVar(lang.NewSymbol("concat")) -if v947.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v947))) -} -v948 := v947.Get() -v949 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v950 := v949.FindInternedVar(lang.NewSymbol("list")) -if v950.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v950))) -} -v951 := v950.Get() -v952 := lang.Apply(v951, []any{lang.NewSymbol("glojure.core/first")}) -v953 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v954 := v953.FindInternedVar(lang.NewSymbol("list")) -if v954.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v954))) -} -v955 := v954.Get() -v956 := lang.Apply(v955, []any{v135}) -v957 := lang.Apply(v948, []any{v952, v956}) -v958 := lang.Apply(v945, []any{v957}) -v959 := lang.Apply(v942, []any{v958}) -v960 := lang.Apply(v935, []any{v939, v959}) -v961 := lang.Apply(v932, []any{v960}) -v962 := lang.Apply(v926, []any{v929, v961}) -v963 := lang.Apply(v923, []any{v962}) -v964 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v965 := v964.FindInternedVar(lang.NewSymbol("list")) -if v965.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v965))) -} -v966 := v965.Get() -v967 := lang.Apply(v140, []any{v111}) -v968 := lang.Apply(v966, []any{v967}) -v969 := lang.Apply(v916, []any{v920, v963, v968}) -v970 := lang.Apply(v913, []any{v969}) -v971 := lang.Apply(v910, []any{v970}) -v972 := lang.Apply(v461, []any{v465, v485, v907, v971}) -v973 := lang.Apply(v458, []any{v972}) -v974 := lang.Apply(v455, []any{v973}) -v975 := lang.Apply(v405, []any{v409, v452, v974}) -v976 := lang.Apply(v402, []any{v975}) -v977 := lang.Apply(v399, []any{v976}) -v978 := lang.Apply(v365, []any{v369, v396, v977}) -v979 := lang.Apply(v362, []any{v978}) -v980 := lang.Apply(v359, []any{v979}) -v981 := lang.Apply(v352, []any{v356, v980}) -v982 := lang.Apply(v349, []any{v981}) -v983 := lang.Apply(v346, []any{v982}) -v984 := lang.Apply(v312, []any{v316, v320, v343, v983}) -v985 := lang.Apply(v309, []any{v984}) -v145 = v985 -} -return v145 -}) -v65 := v64 -_ = v65 -} -v65 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4668), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(4729), lang.NewKeyword("end-column"), int(68)) -v66, err := lang.WithMeta(v64, v65.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v63 any = v66 -_ = v63 -v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v69 := v68.FindInternedVar(lang.NewSymbol("seq")) -if v69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) -} -v70 := v69.Get() -v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v72 := v71.FindInternedVar(lang.NewSymbol("concat")) -if v72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) -} -v73 := v72.Get() -v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v75 := v74.FindInternedVar(lang.NewSymbol("list")) -if v75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) -} -v76 := v75.Get() -v77 := lang.Apply(v76, []any{lang.NewSymbol("glojure.core/let")}) -v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v79 := v78.FindInternedVar(lang.NewSymbol("list")) -if v79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) -} -v80 := v79.Get() -v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v82 := v81.FindInternedVar(lang.NewSymbol("apply")) -if v82.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) -} -v83 := v82.Get() -v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v85 := v84.FindInternedVar(lang.NewSymbol("vector")) -if v85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) -} -v86 := v85.Get() -v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v88 := v87.FindInternedVar(lang.NewSymbol("seq")) -if v88.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) -} -v89 := v88.Get() -v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v91 := v90.FindInternedVar(lang.NewSymbol("concat")) -if v91.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) -} -v92 := v91.Get() -v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v94 := v93.FindInternedVar(lang.NewSymbol("list")) -if v94.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) -} -v95 := v94.Get() -v96 := lang.Apply(v95, []any{lang.NewSymbol("iter__0__auto__")}) -v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v98 := v97.FindInternedVar(lang.NewSymbol("list")) -if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) -} -v99 := v98.Get() -v100 := lang.Apply(v55, []any{v5}) -v101 := lang.Apply(v63, []any{v100}) -v102 := lang.Apply(v99, []any{v101}) -v103 := lang.Apply(v92, []any{v96, v102}) -v104 := lang.Apply(v89, []any{v103}) -v105 := lang.Apply(v83, []any{v86, v104}) -v106 := lang.Apply(v80, []any{v105}) -v107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v108 := v107.FindInternedVar(lang.NewSymbol("list")) -if v108.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v108))) -} -v109 := v108.Get() -v110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v111 := v110.FindInternedVar(lang.NewSymbol("seq")) -if v111.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v111))) -} -v112 := v111.Get() -v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v114 := v113.FindInternedVar(lang.NewSymbol("concat")) -if v114.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) -} -v115 := v114.Get() -v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v117 := v116.FindInternedVar(lang.NewSymbol("list")) -if v117.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) -} -v118 := v117.Get() -v119 := lang.Apply(v118, []any{lang.NewSymbol("iter__0__auto__")}) -v120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v121 := v120.FindInternedVar(lang.NewSymbol("list")) -if v121.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v121))) -} -v122 := v121.Get() -v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v124 := v123.FindInternedVar(lang.NewSymbol("second")) -if v124.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) -} -v125 := v124.Get() -v126 := lang.Apply(v125, []any{v5}) -v127 := lang.Apply(v122, []any{v126}) -v128 := lang.Apply(v115, []any{v119, v127}) -v129 := lang.Apply(v112, []any{v128}) -v130 := lang.Apply(v109, []any{v129}) -v131 := lang.Apply(v73, []any{v77, v106, v130}) -v132 := lang.Apply(v70, []any{v131}) -return v132 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// force -{ -v0 := lang.NewSymbol("force").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "If x is a Delay, returns the (possibly cached) value of its expression, else returns x", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(754), lang.NewKeyword("end-line"), int(754))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, _ := lang.FieldOrMethod(glojure.lang4.Delay, "force") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("force is not a function"))) -} -v5 := lang.Apply(v4, []any{v3}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// format -{ -v0 := lang.NewSymbol("format").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fmt"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Formats a string using java.lang.String.format, see java.util.Formatter for format\n string syntax", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5717), lang.NewKeyword("end-line"), int(5717))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.NewList(args[1:]...) -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("apply")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{fmt.Sprintf, v3, v4}) -return v8 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// frequencies -{ -v0 := lang.NewSymbol("frequencies").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a map from distinct items in coll to the number of times\n they appear.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7185), lang.NewKeyword("end-line"), int(7185))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("persistent!")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("reduce")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -var v10 lang.FnFunc -v10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v11 := args[0] -v12 := args[1] -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("assoc!")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("inc")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("get")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v11, v12, int64(0)}) -v23 := lang.Apply(v18, []any{v22}) -v24 := lang.Apply(v15, []any{v11, v12, v23}) -return v24 -}) -v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7192), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(7193), lang.NewKeyword("end-column"), int(54)) -v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("transient")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.NewMap() -v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7194), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(7194), lang.NewKeyword("end-column"), int(24)) -v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v19 := lang.Apply(v15, []any{v18}) -v20 := lang.Apply(v9, []any{v12, v19, v3}) -v21 := lang.Apply(v6, []any{v20}) -return v21 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// future -{ -v0 := lang.NewSymbol("future").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Takes a body of expressions and yields a future object that will\n invoke the body in another thread, and will cache the result and\n return it on all subsequent calls to deref/@. If the computation has\n not yet finished, calls to deref/@ will block, unless the variant of\n deref with timeout is used. See also - realized?.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7009), lang.NewKeyword("end-line"), int(7009))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("seq")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("concat")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("list")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{lang.NewSymbol("glojure.core/future-call")}) -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("list")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("seq")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("concat")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("list")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.Apply(v27, []any{lang.NewSymbol("fn*")}) -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("list")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("apply")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("vector")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("seq")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("concat")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, nil) -v45 := lang.Apply(v40, []any{v44}) -v46 := lang.Apply(v34, []any{v37, v45}) -v47 := lang.Apply(v31, []any{v46}) -v48 := lang.Apply(v24, []any{v28, v47, v5}) -v49 := lang.Apply(v21, []any{v48}) -v50 := lang.Apply(v18, []any{v49}) -v51 := lang.Apply(v11, []any{v15, v50}) -v52 := lang.Apply(v8, []any{v51}) -return v52 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// future-call -{ -v0 := lang.NewSymbol("future-call").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Takes a function of no args and yields a future object that will\n invoke the function in another thread, and will cache the result and\n return it on all subsequent calls to deref/@. If the computation has\n not yet finished, calls to deref/@ will block, unless the variant\n of deref with timeout is used. See also - realized?.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7003), lang.NewKeyword("end-line"), int(7003))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("binding-conveyor-fn")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v4}) -var v4 any = v8 -_ = v4 -v10 := lang.Apply(lang.AgentSubmit, []any{v4}) -var v9 any = v10 -_ = v9 -return v9 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// future-cancel -{ -v0 := lang.NewSymbol("future-cancel").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Cancels the future, if possible.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7019), lang.NewKeyword("end-line"), int(7019))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, _ := lang.FieldOrMethod(v3, "cancel") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("cancel is not a function"))) -} -v5 := lang.Apply(v4, []any{true}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// future-cancelled? -{ -v0 := lang.NewSymbol("future-cancelled?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Returns true if future f is cancelled", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7025), lang.NewKeyword("end-line"), int(7025))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, ok := lang.FieldOrMethod(v3, "isCancelled") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "isCancelled"))) -} -var v5 any -switch reflect.TypeOf(v4).Kind() { -case reflect.Func: - v5 = lang.Apply(v4, nil) -default: - v5 = v4 -} -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// future-done? -{ -v0 := lang.NewSymbol("future-done?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Returns true if future f is done", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6538), lang.NewKeyword("end-line"), int(6538))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, ok := lang.FieldOrMethod(v3, "isDone") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "isDone"))) -} -var v5 any -switch reflect.TypeOf(v4).Kind() { -case reflect.Func: - v5 = lang.Apply(v4, nil) -default: - v5 = v4 -} -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// future? -{ -v0 := lang.NewSymbol("future?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is a future", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6532), lang.NewKeyword("end-line"), int(6532))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{java.util.concurrent7.Future, v3}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// gen-class -{ -v0 := lang.NewSymbol("gen-class").WithMeta(lang.NewMap()).(*lang.Symbol) -v1 := ns.Intern(v0) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// gensym -{ -v0 := lang.NewSymbol("gensym").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("prefix-string"))), lang.NewKeyword("doc"), "Returns a new symbol with a unique name. If a prefix string is\n supplied, the name is prefix# where # is some unique number. If\n prefix is not supplied, the prefix is 'G__'.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(599), lang.NewKeyword("end-line"), int(599))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v4 := v3.FindInternedVar(lang.NewSymbol("gensym")) -if v4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) -} -v5 := v4.Get() -v6 := lang.Apply(v5, []any{"G__"}) -return v6 - case 1: -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("str")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("str")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10, _ := lang.FieldOrMethod(runtime5.RT, "NextID") -if reflect.TypeOf(v10).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("NextID is not a function"))) -} -v11 := lang.Apply(v10, []any{}) -v12 := lang.Apply(v9, []any{v11}) -v13 := lang.Apply(v6, []any{v3, v12}) -v14 := lang.Apply(lang.NewSymbol, []any{v13}) -return v14 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// get -{ -var v1 lang.FnFunc -{ // function get__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("seq")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("concat")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("list")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{lang.NewSymbol(".")}) -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("list")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("list")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("seq")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("concat")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("list")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.Apply(v31, []any{lang.NewSymbol("glojure.core/Get")}) -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("list")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v3}) -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("list")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v4}) -v41 := lang.Apply(v28, []any{v32, v36, v40, v5}) -v42 := lang.Apply(v25, []any{v41}) -v43 := lang.Apply(v22, []any{v42}) -v44 := lang.Apply(v11, []any{v15, v19, v43}) -v45 := lang.Apply(v8, []any{v44}) -return v45 - } -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("get").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"), lang.NewSymbol("not-found"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the value mapped to key, not-found or nil if key not present\n in associative collection, set, string, array, or ILookup instance.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)int64(3)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1489), lang.NewKeyword("end-line"), int(1489))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v4 := args[0] -v5 := args[1] -v6 := lang.Apply(lang.Get, []any{v4, v5}) -return v6 - case 3: -v4 := args[0] -v5 := args[1] -v6 := args[2] -v7 := lang.Apply(lang.GetDefault, []any{v4, v5, v6}) -return v7 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// get-in -{ -v0 := lang.NewSymbol("get-in").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("ks")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("ks"), lang.NewSymbol("not-found"))), lang.NewKeyword("doc"), "Returns the value in a nested associative structure,\n where ks is a sequence of keys. Returns nil if the key\n is not present, or the not-found value if supplied.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6128), lang.NewKeyword("end-line"), int(6128))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("reduce1")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("get")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v7, []any{v10, v3, v4}) -return v11 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v7 := lang.Apply(reflect.StructOf, []any{nil}) -v8 := lang.Apply(reflect.New, []any{v7}) -v9, ok := lang.FieldOrMethod(v8, "Interface") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "Interface"))) -} -var v10 any -switch reflect.TypeOf(v9).Kind() { -case reflect.Func: - v10 = lang.Apply(v9, nil) -default: - v10 = v9 -} -var v6 any = v10 -_ = v6 -var v11 any = v11 -_ = v11 -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("seq")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v12}) -var v12 any = v16 -_ = v12 -var v17 any -for { -var v18 any -if lang.IsTruthy(v12) { -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("get")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("first")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{v12}) -v27 := lang.Apply(v22, []any{v19, v26, v6}) -var v19 any = v27 -_ = v19 -var v29 any -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("identical?")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.Apply(v32, []any{v6, v19}) -if lang.IsTruthy(v33) { -v29 = v5 -} else { -var v34 any = v6 -var v35 any = v19 -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("next")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v12}) -var v36 any = v40 -v6 = v34 -v11 = v35 -v12 = v36 -continue -} -v18 = v29 -} else { -v18 = v11 -} -v17 = v18 - break -} -return v17 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// get-method -{ -v0 := lang.NewSymbol("get-method").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"), lang.NewSymbol("dispatch-val"))), lang.NewKeyword("doc"), "Given a multimethod and a dispatch value, returns the dispatch fn\n that would apply to that value, or nil if none apply and no default", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1815), lang.NewKeyword("end-line"), int(1815))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5, _ := lang.FieldOrMethod(v3, "getMethod") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("getMethod is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// get-thread-bindings -{ -v0 := lang.NewSymbol("get-thread-bindings").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Get a map with the Var/value pairs which is currently in effect for the\n current thread.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1937), lang.NewKeyword("end-line"), int(1937))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.Apply(nil, nil) -return v3 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// get-validator -{ -v0 := lang.NewSymbol("get-validator").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("iref"))), lang.NewKeyword("doc"), "Gets the validator-fn for a var/ref/agent/atom.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2392), lang.NewKeyword("end-line"), int(2392))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, _ := lang.FieldOrMethod(v3, "getValidator") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("getValidator is not a function"))) -} -v5 := lang.Apply(v4, []any{}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// global-hierarchy -{ -v0 := lang.NewSymbol("global-hierarchy").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5513), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(5514), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, lang.NewMap(lang.NewKeyword("parents"), lang.NewMap(), lang.NewKeyword("descendants"), lang.NewMap(), lang.NewKeyword("ancestors"), lang.NewMap()), true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// group-by -{ -v0 := lang.NewSymbol("group-by").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a map of the elements of coll keyed by the result of\n f on each element. The value at each key will be a vector of the\n corresponding elements, in the order they appeared in coll.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7128), lang.NewKeyword("end-line"), int(7128))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("persistent!")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("reduce")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -var v11 lang.FnFunc -v11 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v12 := args[0] -v13 := args[1] -v15 := lang.Apply(v3, []any{v13}) -var v14 any = v15 -_ = v14 -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("assoc!")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("conj")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("get")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.NewVector() -v27 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7139), lang.NewKeyword("column"), int(40), lang.NewKeyword("end-line"), int(7139), lang.NewKeyword("end-column"), int(41)) -v28, err := lang.WithMeta(v26, v27.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v29 := lang.Apply(v25, []any{v12, v14, v28}) -v30 := lang.Apply(v22, []any{v29, v13}) -v31 := lang.Apply(v19, []any{v12, v14, v30}) -return v31 -}) -v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7137), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(7139), lang.NewKeyword("end-column"), int(48)) -v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("transient")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.NewMap() -v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7140), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(7140), lang.NewKeyword("end-column"), int(17)) -v19, err := lang.WithMeta(v17, v18.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v20 := lang.Apply(v16, []any{v19}) -v21 := lang.Apply(v10, []any{v13, v20, v4}) -v22 := lang.Apply(v7, []any{v21}) -return v22 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// halt-when -{ -v0 := lang.NewSymbol("halt-when").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred")), lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("retf"))), lang.NewKeyword("doc"), "Returns a transducer that ends transduction when pred returns true\n for an input. When retf is supplied it must be a fn of 2 arguments -\n it will be passed the (completed) result so far and the input that\n triggered the predicate, and its return value (if it does not throw\n an exception) will be the return value of the transducer. If retf\n is not supplied, the input that triggered the predicate will be\n returned. If the predicate never returns true the transduction is\n unaffected.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7657), lang.NewKeyword("end-line"), int(7657))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("halt-when")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{v3, nil}) -return v7 - case 2: -v3 := args[0] -v4 := args[1] -var v5 lang.FnFunc -v5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v6 := args[0] -var v7 lang.FnFunc -v7 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v8 := lang.Apply(v6, nil) -return v8 - case 1: -v8 := args[0] -var v9 any -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("map?")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v8}) -var v10 any = v14 -_ = v10 -var v16 any -if lang.IsTruthy(v10) { -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("contains?")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v8, lang.NewKeyword("glojure.core/halt")}) -v16 = v20 -} else { -v16 = v10 -} -if lang.IsTruthy(v16) { -v10 := lang.Apply(lang.NewKeyword("glojure.core/halt"), []any{v8}) -v9 = v10 -} else { -v11 := lang.Apply(v6, []any{v8}) -v9 = v11 -} -return v9 - case 2: -v8 := args[0] -v9 := args[1] -var v10 any -v11 := lang.Apply(v3, []any{v9}) -if lang.IsTruthy(v11) { -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("reduced")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -var v15 any -if lang.IsTruthy(v4) { -v16 := lang.Apply(v6, []any{v8}) -v17 := lang.Apply(v4, []any{v16, v9}) -v15 = v17 -} else { -v15 = v9 -} -v18 := lang.NewMap(lang.NewKeyword("glojure.core/halt"), v15) -v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7678), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(7678), lang.NewKeyword("end-column"), int(72)) -v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v21 := lang.Apply(v14, []any{v20}) -v10 = v21 -} else { -v22 := lang.Apply(v6, []any{v8, v9}) -v10 = v22 -} -return v10 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7670), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7679), lang.NewKeyword("end-column"), int(34)) -v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v9 -}) -v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7669), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7679), lang.NewKeyword("end-column"), int(35)) -v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v7 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// hash -{ -v0 := lang.NewSymbol("hash").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns the hash code of its argument. Note this is the hash code\n consistent with =, and thus is different than .hashCode for Integer,\n Short, Byte and Clojure collections.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5189), lang.NewKeyword("end-line"), int(5189))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.Apply(lang.HashEq, []any{v3}) -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// hash-map -{ -v0 := lang.NewSymbol("hash-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keyvals"))), lang.NewKeyword("doc"), "keyval => key val\n Returns a new hash map with supplied mappings. If any keys are\n equal, they are handled as if by repeated uses of assoc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(378), lang.NewKeyword("end-line"), int(378))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v3 := lang.NewMap() -v4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(384), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(384), lang.NewKeyword("end-column"), int(8)) -v5, err := lang.WithMeta(v3, v4.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v5 - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewList(args[0:]...) -v4 := lang.Apply(lang.CreatePersistentHashMap, []any{v3}) -return v4 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// hash-ordered-coll -{ -v0 := lang.NewSymbol("hash-ordered-coll").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns the hash code, consistent with =, for an external ordered\n collection implementing Iterable.\n See http://glojure.org/data_structures#hash for full algorithms.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5210), lang.NewKeyword("end-line"), int(5210))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.Apply(nil, []any{v3}) -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// hash-set -{ -v0 := lang.NewSymbol("hash-set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keys"))), lang.NewKeyword("doc"), "Returns a new hash set with supplied keys. Any equal keys are\n handled as if by repeated uses of conj.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(388), lang.NewKeyword("end-line"), int(388))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v3 := lang.CreatePersistentTreeSet() -v4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(393), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(393), lang.NewKeyword("end-column"), int(9)) -v5, err := lang.WithMeta(v3, v4.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v5 - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewList(args[0:]...) -v4 := lang.Apply(nil, []any{v3}) -return v4 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// hash-unordered-coll -{ -v0 := lang.NewSymbol("hash-unordered-coll").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns the hash code, consistent with =, for an external unordered\n collection implementing Iterable. For maps, the iterator should\n return map entries whose hash is computed as\n (hash-ordered-coll [k v]).\n See http://glojure.org/data_structures#hash for full algorithms.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5219), lang.NewKeyword("end-line"), int(5219))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.Apply(nil, []any{v3}) -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// ident? -{ -v0 := lang.NewSymbol("ident?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a symbol or keyword", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1608), lang.NewKeyword("end-line"), int(1608))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("keyword?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -var v4 any = v8 -_ = v4 -var v10 any -if lang.IsTruthy(v4) { -v10 = v4 -} else { -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("symbol?")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v3}) -v10 = v14 -} -return v10 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// identical? -{ -var v1 lang.FnFunc -{ // function identical?__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("concat")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("list")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol("glojure.lang.Util")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{lang.NewSymbol("glojure.core/identical")}) -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{v3}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{v4}) -v31 := lang.Apply(v10, []any{v14, v18, v22, v26, v30}) -v32 := lang.Apply(v7, []any{v31}) -return v32 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("identical?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Tests if 2 arguments are the same object", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(768), lang.NewKeyword("end-line"), int(768))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6 := lang.Apply(lang.Identical, []any{v4, v5}) -return v6 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// identity -{ -v0 := lang.NewSymbol("identity").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns its argument.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1446), lang.NewKeyword("end-line"), int(1446))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -return v3 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// if-let -{ -v0 := lang.NewSymbol("if-let").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("then")), lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("then"), lang.NewSymbol("else"), lang.NewSymbol("&"), lang.NewSymbol("oldform"))), lang.NewKeyword("doc"), "bindings => binding-form test\n\n If test is true, evaluates then with binding-form bound to the value of \n test, if not, yields else", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1839), lang.NewKeyword("end-line"), int(1839))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 4: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("seq")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("concat")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("list")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/if-let")}) -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("list")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v5}) -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("list")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v6}) -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("list")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.Apply(v27, []any{nil}) -v29 := lang.Apply(v12, []any{v16, v20, v24, v28}) -v30 := lang.Apply(v9, []any{v29}) -return v30 - default: - if len(args) < 5 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := args[4] -v8 := lang.NewList(args[5:]...) -var v9 any -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("vector?")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{v5}) -if lang.IsTruthy(v13) { -v9 = nil -} else { -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("str")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("first")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v3}) -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("*ns*")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("meta")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v3}) -v28 := lang.Apply(lang.NewKeyword("line"), []any{v27}) -v29 := lang.Apply(v16, []any{v20, " requires ", "a vector for its binding", " in ", v23, ":", v28}) -v30 := lang.Apply(lang.NewIllegalArgumentError, []any{v29}) -panic(v30) -} -_ = v9 -var v31 any -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("nil?")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v8}) -if lang.IsTruthy(v35) { -v31 = nil -} else { -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("str")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("first")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) -} -v41 := v40.Get() -v42 := lang.Apply(v41, []any{v3}) -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("*ns*")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("meta")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) -} -v48 := v47.Get() -v49 := lang.Apply(v48, []any{v3}) -v50 := lang.Apply(lang.NewKeyword("line"), []any{v49}) -v51 := lang.Apply(v38, []any{v42, " requires ", "1 or 2 forms after binding vector", " in ", v45, ":", v50}) -v52 := lang.Apply(lang.NewIllegalArgumentError, []any{v51}) -panic(v52) -} -_ = v31 -var v53 any -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("=")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) -} -v56 := v55.Get() -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("count")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) -} -v59 := v58.Get() -v60 := lang.Apply(v59, []any{v5}) -v61 := lang.Apply(v56, []any{int64(2), v60}) -if lang.IsTruthy(v61) { -v53 = nil -} else { -v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v63 := v62.FindInternedVar(lang.NewSymbol("str")) -if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) -} -v64 := v63.Get() -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("first")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) -} -v67 := v66.Get() -v68 := lang.Apply(v67, []any{v3}) -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("*ns*")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) -} -v71 := v70.Get() -v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v73 := v72.FindInternedVar(lang.NewSymbol("meta")) -if v73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) -} -v74 := v73.Get() -v75 := lang.Apply(v74, []any{v3}) -v76 := lang.Apply(lang.NewKeyword("line"), []any{v75}) -v77 := lang.Apply(v64, []any{v68, " requires ", "exactly 2 forms in binding vector", " in ", v71, ":", v76}) -v78 := lang.Apply(lang.NewIllegalArgumentError, []any{v77}) -panic(v78) -} -_ = v53 -_ = nil -v80 := lang.Apply(v5, []any{int64(0)}) -var v79 any = v80 -_ = v79 -v82 := lang.Apply(v5, []any{int64(1)}) -var v81 any = v82 -_ = v81 -v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v85 := v84.FindInternedVar(lang.NewSymbol("seq")) -if v85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) -} -v86 := v85.Get() -v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v88 := v87.FindInternedVar(lang.NewSymbol("concat")) -if v88.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) -} -v89 := v88.Get() -v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v91 := v90.FindInternedVar(lang.NewSymbol("list")) -if v91.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) -} -v92 := v91.Get() -v93 := lang.Apply(v92, []any{lang.NewSymbol("glojure.core/let")}) -v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v95 := v94.FindInternedVar(lang.NewSymbol("list")) -if v95.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) -} -v96 := v95.Get() -v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v98 := v97.FindInternedVar(lang.NewSymbol("apply")) -if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) -} -v99 := v98.Get() -v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v101 := v100.FindInternedVar(lang.NewSymbol("vector")) -if v101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) -} -v102 := v101.Get() -v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v104 := v103.FindInternedVar(lang.NewSymbol("seq")) -if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) -} -v105 := v104.Get() -v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v107 := v106.FindInternedVar(lang.NewSymbol("concat")) -if v107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) -} -v108 := v107.Get() -v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v110 := v109.FindInternedVar(lang.NewSymbol("list")) -if v110.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) -} -v111 := v110.Get() -v112 := lang.Apply(v111, []any{lang.NewSymbol("temp__0__auto__")}) -v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v114 := v113.FindInternedVar(lang.NewSymbol("list")) -if v114.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) -} -v115 := v114.Get() -v116 := lang.Apply(v115, []any{v81}) -v117 := lang.Apply(v108, []any{v112, v116}) -v118 := lang.Apply(v105, []any{v117}) -v119 := lang.Apply(v99, []any{v102, v118}) -v120 := lang.Apply(v96, []any{v119}) -v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v122 := v121.FindInternedVar(lang.NewSymbol("list")) -if v122.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) -} -v123 := v122.Get() -v124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v125 := v124.FindInternedVar(lang.NewSymbol("seq")) -if v125.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v125))) -} -v126 := v125.Get() -v127 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v128 := v127.FindInternedVar(lang.NewSymbol("concat")) -if v128.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v128))) -} -v129 := v128.Get() -v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v131 := v130.FindInternedVar(lang.NewSymbol("list")) -if v131.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) -} -v132 := v131.Get() -v133 := lang.Apply(v132, []any{lang.NewSymbol("if")}) -v134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v135 := v134.FindInternedVar(lang.NewSymbol("list")) -if v135.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v135))) -} -v136 := v135.Get() -v137 := lang.Apply(v136, []any{lang.NewSymbol("temp__0__auto__")}) -v138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v139 := v138.FindInternedVar(lang.NewSymbol("list")) -if v139.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v139))) -} -v140 := v139.Get() -v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v142 := v141.FindInternedVar(lang.NewSymbol("seq")) -if v142.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) -} -v143 := v142.Get() -v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v145 := v144.FindInternedVar(lang.NewSymbol("concat")) -if v145.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) -} -v146 := v145.Get() -v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v148 := v147.FindInternedVar(lang.NewSymbol("list")) -if v148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) -} -v149 := v148.Get() -v150 := lang.Apply(v149, []any{lang.NewSymbol("glojure.core/let")}) -v151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v152 := v151.FindInternedVar(lang.NewSymbol("list")) -if v152.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v152))) -} -v153 := v152.Get() -v154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v155 := v154.FindInternedVar(lang.NewSymbol("apply")) -if v155.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v155))) -} -v156 := v155.Get() -v157 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v158 := v157.FindInternedVar(lang.NewSymbol("vector")) -if v158.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v158))) -} -v159 := v158.Get() -v160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v161 := v160.FindInternedVar(lang.NewSymbol("seq")) -if v161.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v161))) -} -v162 := v161.Get() -v163 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v164 := v163.FindInternedVar(lang.NewSymbol("concat")) -if v164.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v164))) -} -v165 := v164.Get() -v166 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v167 := v166.FindInternedVar(lang.NewSymbol("list")) -if v167.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v167))) -} -v168 := v167.Get() -v169 := lang.Apply(v168, []any{v79}) -v170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v171 := v170.FindInternedVar(lang.NewSymbol("list")) -if v171.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v171))) -} -v172 := v171.Get() -v173 := lang.Apply(v172, []any{lang.NewSymbol("temp__0__auto__")}) -v174 := lang.Apply(v165, []any{v169, v173}) -v175 := lang.Apply(v162, []any{v174}) -v176 := lang.Apply(v156, []any{v159, v175}) -v177 := lang.Apply(v153, []any{v176}) -v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v179 := v178.FindInternedVar(lang.NewSymbol("list")) -if v179.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) -} -v180 := v179.Get() -v181 := lang.Apply(v180, []any{v6}) -v182 := lang.Apply(v146, []any{v150, v177, v181}) -v183 := lang.Apply(v143, []any{v182}) -v184 := lang.Apply(v140, []any{v183}) -v185 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v186 := v185.FindInternedVar(lang.NewSymbol("list")) -if v186.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v186))) -} -v187 := v186.Get() -v188 := lang.Apply(v187, []any{v7}) -v189 := lang.Apply(v129, []any{v133, v137, v184, v188}) -v190 := lang.Apply(v126, []any{v189}) -v191 := lang.Apply(v123, []any{v190}) -v192 := lang.Apply(v89, []any{v93, v120, v191}) -v193 := lang.Apply(v86, []any{v192}) -return v193 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// if-not -{ -v0 := lang.NewSymbol("if-not").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("test"), lang.NewSymbol("then")), lang.NewVector(lang.NewSymbol("test"), lang.NewSymbol("then"), lang.NewSymbol("else"))), lang.NewKeyword("doc"), "Evaluates test. If logical false, evaluates and returns then expr, \n otherwise else expr, if supplied, else nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(760), lang.NewKeyword("end-line"), int(760))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 4: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("seq")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("concat")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("list")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/if-not")}) -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("list")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v5}) -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("list")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v6}) -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("list")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.Apply(v27, []any{nil}) -v29 := lang.Apply(v12, []any{v16, v20, v24, v28}) -v30 := lang.Apply(v9, []any{v29}) -return v30 - case 5: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := args[4] -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("seq")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("concat")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("if")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/not")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v5}) -v35 := lang.Apply(v26, []any{v30, v34}) -v36 := lang.Apply(v23, []any{v35}) -v37 := lang.Apply(v20, []any{v36}) -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("list")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.Apply(v40, []any{v6}) -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("list")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) -} -v44 := v43.Get() -v45 := lang.Apply(v44, []any{v7}) -v46 := lang.Apply(v13, []any{v17, v37, v41, v45}) -v47 := lang.Apply(v10, []any{v46}) -return v47 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// if-some -{ -v0 := lang.NewSymbol("if-some").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("then")), lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("then"), lang.NewSymbol("else"), lang.NewSymbol("&"), lang.NewSymbol("oldform"))), lang.NewKeyword("doc"), "bindings => binding-form test\n\n If test is not nil, evaluates then with binding-form bound to the\n value of test, if not, yields else", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1874), lang.NewKeyword("end-line"), int(1874))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 4: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("seq")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("concat")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("list")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/if-some")}) -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("list")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v5}) -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("list")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v6}) -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("list")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.Apply(v27, []any{nil}) -v29 := lang.Apply(v12, []any{v16, v20, v24, v28}) -v30 := lang.Apply(v9, []any{v29}) -return v30 - default: - if len(args) < 5 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := args[4] -v8 := lang.NewList(args[5:]...) -var v9 any -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("vector?")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{v5}) -if lang.IsTruthy(v13) { -v9 = nil -} else { -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("str")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("first")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v3}) -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("*ns*")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("meta")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v3}) -v28 := lang.Apply(lang.NewKeyword("line"), []any{v27}) -v29 := lang.Apply(v16, []any{v20, " requires ", "a vector for its binding", " in ", v23, ":", v28}) -v30 := lang.Apply(lang.NewIllegalArgumentError, []any{v29}) -panic(v30) -} -_ = v9 -var v31 any -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("nil?")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v8}) -if lang.IsTruthy(v35) { -v31 = nil -} else { -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("str")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("first")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) -} -v41 := v40.Get() -v42 := lang.Apply(v41, []any{v3}) -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("*ns*")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("meta")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) -} -v48 := v47.Get() -v49 := lang.Apply(v48, []any{v3}) -v50 := lang.Apply(lang.NewKeyword("line"), []any{v49}) -v51 := lang.Apply(v38, []any{v42, " requires ", "1 or 2 forms after binding vector", " in ", v45, ":", v50}) -v52 := lang.Apply(lang.NewIllegalArgumentError, []any{v51}) -panic(v52) -} -_ = v31 -var v53 any -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("=")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) -} -v56 := v55.Get() -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("count")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) -} -v59 := v58.Get() -v60 := lang.Apply(v59, []any{v5}) -v61 := lang.Apply(v56, []any{int64(2), v60}) -if lang.IsTruthy(v61) { -v53 = nil -} else { -v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v63 := v62.FindInternedVar(lang.NewSymbol("str")) -if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) -} -v64 := v63.Get() -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("first")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) -} -v67 := v66.Get() -v68 := lang.Apply(v67, []any{v3}) -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("*ns*")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) -} -v71 := v70.Get() -v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v73 := v72.FindInternedVar(lang.NewSymbol("meta")) -if v73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) -} -v74 := v73.Get() -v75 := lang.Apply(v74, []any{v3}) -v76 := lang.Apply(lang.NewKeyword("line"), []any{v75}) -v77 := lang.Apply(v64, []any{v68, " requires ", "exactly 2 forms in binding vector", " in ", v71, ":", v76}) -v78 := lang.Apply(lang.NewIllegalArgumentError, []any{v77}) -panic(v78) -} -_ = v53 -_ = nil -v80 := lang.Apply(v5, []any{int64(0)}) -var v79 any = v80 -_ = v79 -v82 := lang.Apply(v5, []any{int64(1)}) -var v81 any = v82 -_ = v81 -v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v85 := v84.FindInternedVar(lang.NewSymbol("seq")) -if v85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) -} -v86 := v85.Get() -v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v88 := v87.FindInternedVar(lang.NewSymbol("concat")) -if v88.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) -} -v89 := v88.Get() -v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v91 := v90.FindInternedVar(lang.NewSymbol("list")) -if v91.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) -} -v92 := v91.Get() -v93 := lang.Apply(v92, []any{lang.NewSymbol("glojure.core/let")}) -v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v95 := v94.FindInternedVar(lang.NewSymbol("list")) -if v95.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) -} -v96 := v95.Get() -v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v98 := v97.FindInternedVar(lang.NewSymbol("apply")) -if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) -} -v99 := v98.Get() -v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v101 := v100.FindInternedVar(lang.NewSymbol("vector")) -if v101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) -} -v102 := v101.Get() -v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v104 := v103.FindInternedVar(lang.NewSymbol("seq")) -if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) -} -v105 := v104.Get() -v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v107 := v106.FindInternedVar(lang.NewSymbol("concat")) -if v107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) -} -v108 := v107.Get() -v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v110 := v109.FindInternedVar(lang.NewSymbol("list")) -if v110.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) -} -v111 := v110.Get() -v112 := lang.Apply(v111, []any{lang.NewSymbol("temp__0__auto__")}) -v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v114 := v113.FindInternedVar(lang.NewSymbol("list")) -if v114.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) -} -v115 := v114.Get() -v116 := lang.Apply(v115, []any{v81}) -v117 := lang.Apply(v108, []any{v112, v116}) -v118 := lang.Apply(v105, []any{v117}) -v119 := lang.Apply(v99, []any{v102, v118}) -v120 := lang.Apply(v96, []any{v119}) -v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v122 := v121.FindInternedVar(lang.NewSymbol("list")) -if v122.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) -} -v123 := v122.Get() -v124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v125 := v124.FindInternedVar(lang.NewSymbol("seq")) -if v125.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v125))) -} -v126 := v125.Get() -v127 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v128 := v127.FindInternedVar(lang.NewSymbol("concat")) -if v128.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v128))) -} -v129 := v128.Get() -v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v131 := v130.FindInternedVar(lang.NewSymbol("list")) -if v131.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) -} -v132 := v131.Get() -v133 := lang.Apply(v132, []any{lang.NewSymbol("if")}) -v134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v135 := v134.FindInternedVar(lang.NewSymbol("list")) -if v135.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v135))) -} -v136 := v135.Get() -v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v138 := v137.FindInternedVar(lang.NewSymbol("seq")) -if v138.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) -} -v139 := v138.Get() -v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v141 := v140.FindInternedVar(lang.NewSymbol("concat")) -if v141.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) -} -v142 := v141.Get() -v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v144 := v143.FindInternedVar(lang.NewSymbol("list")) -if v144.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) -} -v145 := v144.Get() -v146 := lang.Apply(v145, []any{lang.NewSymbol("glojure.core/nil?")}) -v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v148 := v147.FindInternedVar(lang.NewSymbol("list")) -if v148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) -} -v149 := v148.Get() -v150 := lang.Apply(v149, []any{lang.NewSymbol("temp__0__auto__")}) -v151 := lang.Apply(v142, []any{v146, v150}) -v152 := lang.Apply(v139, []any{v151}) -v153 := lang.Apply(v136, []any{v152}) -v154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v155 := v154.FindInternedVar(lang.NewSymbol("list")) -if v155.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v155))) -} -v156 := v155.Get() -v157 := lang.Apply(v156, []any{v7}) -v158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v159 := v158.FindInternedVar(lang.NewSymbol("list")) -if v159.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v159))) -} -v160 := v159.Get() -v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v162 := v161.FindInternedVar(lang.NewSymbol("seq")) -if v162.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) -} -v163 := v162.Get() -v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v165 := v164.FindInternedVar(lang.NewSymbol("concat")) -if v165.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) -} -v166 := v165.Get() -v167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v168 := v167.FindInternedVar(lang.NewSymbol("list")) -if v168.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v168))) -} -v169 := v168.Get() -v170 := lang.Apply(v169, []any{lang.NewSymbol("glojure.core/let")}) -v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v172 := v171.FindInternedVar(lang.NewSymbol("list")) -if v172.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) -} -v173 := v172.Get() -v174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v175 := v174.FindInternedVar(lang.NewSymbol("apply")) -if v175.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v175))) -} -v176 := v175.Get() -v177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v178 := v177.FindInternedVar(lang.NewSymbol("vector")) -if v178.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v178))) -} -v179 := v178.Get() -v180 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v181 := v180.FindInternedVar(lang.NewSymbol("seq")) -if v181.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v181))) -} -v182 := v181.Get() -v183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v184 := v183.FindInternedVar(lang.NewSymbol("concat")) -if v184.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v184))) -} -v185 := v184.Get() -v186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v187 := v186.FindInternedVar(lang.NewSymbol("list")) -if v187.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v187))) -} -v188 := v187.Get() -v189 := lang.Apply(v188, []any{v79}) -v190 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v191 := v190.FindInternedVar(lang.NewSymbol("list")) -if v191.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v191))) -} -v192 := v191.Get() -v193 := lang.Apply(v192, []any{lang.NewSymbol("temp__0__auto__")}) -v194 := lang.Apply(v185, []any{v189, v193}) -v195 := lang.Apply(v182, []any{v194}) -v196 := lang.Apply(v176, []any{v179, v195}) -v197 := lang.Apply(v173, []any{v196}) -v198 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v199 := v198.FindInternedVar(lang.NewSymbol("list")) -if v199.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v199))) -} -v200 := v199.Get() -v201 := lang.Apply(v200, []any{v6}) -v202 := lang.Apply(v166, []any{v170, v197, v201}) -v203 := lang.Apply(v163, []any{v202}) -v204 := lang.Apply(v160, []any{v203}) -v205 := lang.Apply(v129, []any{v133, v153, v157, v204}) -v206 := lang.Apply(v126, []any{v205}) -v207 := lang.Apply(v123, []any{v206}) -v208 := lang.Apply(v89, []any{v93, v120, v207}) -v209 := lang.Apply(v86, []any{v208}) -return v209 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// ifn? -{ -v0 := lang.NewSymbol("ifn?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements IFn. Note that many data structures\n (e.g. sets and maps) implement IFn", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6209), lang.NewKeyword("end-line"), int(6209))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{glojure.lang4.IFn, v3}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// import -{ -v0 := lang.NewSymbol("import").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("import-symbols-or-lists"))), lang.NewKeyword("doc"), "import-list => (package-symbol class-name-symbols*)\n\n For each name in class-name-symbols, adds a mapping from name to the\n class named by package.name to the current namespace. Use :import in the ns\n macro in preference to calling this directly.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3426), lang.NewKeyword("end-line"), int(3426))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("map")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -var v10 lang.FnFunc -v10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v11 := args[0] -var v12 any -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("seq?")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v11}) -var v13 any = v17 -_ = v13 -var v19 any -if lang.IsTruthy(v13) { -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("=")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("first")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{v11}) -v27 := lang.Apply(v22, []any{lang.NewSymbol("quote"), v26}) -v19 = v27 -} else { -v19 = v13 -} -if lang.IsTruthy(v19) { -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("second")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v11}) -v12 = v16 -} else { -v12 = v11 -} -return v12 -}) -v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3434), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(3434), lang.NewKeyword("end-column"), int(73)) -v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v13 := lang.Apply(v9, []any{v12, v5}) -var v6 any = v13 -_ = v6 -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("seq")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("concat")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("list")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v23, []any{lang.NewSymbol("do")}) -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("map")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -var v28 lang.FnFunc -v28 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v29 := args[0] -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("list")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.Apply(v32, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Import"), v29}) -return v33 -}) -v29 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3436), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(3436), lang.NewKeyword("end-column"), int(73)) -v30, err := lang.WithMeta(v28, v29.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("reduce1")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -var v34 lang.FnFunc -v34 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v35 := args[0] -v36 := args[1] -var v37 any -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("symbol?")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.Apply(v40, []any{v36}) -if lang.IsTruthy(v41) { -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("conj")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) -} -v44 := v43.Get() -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("name")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.Apply(v47, []any{v36}) -v49 := lang.Apply(v44, []any{v35, v48}) -v37 = v49 -} else { -v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v52 := v51.FindInternedVar(lang.NewSymbol("first")) -if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) -} -v53 := v52.Get() -v54 := lang.Apply(v53, []any{v36}) -var v50 any = v54 -_ = v50 -v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v57 := v56.FindInternedVar(lang.NewSymbol("rest")) -if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) -} -v58 := v57.Get() -v59 := lang.Apply(v58, []any{v36}) -var v55 any = v59 -_ = v55 -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("into1")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) -} -v63 := v62.Get() -v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v65 := v64.FindInternedVar(lang.NewSymbol("map")) -if v65.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) -} -v66 := v65.Get() -var v67 lang.FnFunc -v67 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v68 := args[0] -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("str")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) -} -v71 := v70.Get() -v72 := lang.Apply(v71, []any{v50, ".", v68}) -return v72 -}) -v68 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3441), lang.NewKeyword("column"), int(45), lang.NewKeyword("end-line"), int(3441), lang.NewKeyword("end-column"), int(58)) -v69, err := lang.WithMeta(v67, v68.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v70 := lang.Apply(v66, []any{v69, v55}) -v71 := lang.Apply(v63, []any{v35, v70}) -v37 = v71 -} -return v37 -}) -v35 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3437), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(3441), lang.NewKeyword("end-column"), int(66)) -v36, err := lang.WithMeta(v34, v35.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v37 := lang.NewVector() -v38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3442), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(3442), lang.NewKeyword("end-column"), int(26)) -v39, err := lang.WithMeta(v37, v38.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v40 := lang.Apply(v33, []any{v36, v39, v6}) -v41 := lang.Apply(v27, []any{v30, v40}) -v42 := lang.Apply(v20, []any{v24, v41}) -v43 := lang.Apply(v17, []any{v42}) -return v43 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// in-ns -{ -v0 := lang.NewSymbol("in-ns").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, nil, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// inc -{ -var v1 lang.FnFunc -{ // function inc__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -var v30 any -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -if lang.IsTruthy(v33) { -v30 = lang.NewSymbol("unchecked_inc") -} else { -v30 = lang.NewSymbol("inc") -} -v34 := lang.Apply(v29, []any{v30}) -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("list")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v3}) -v39 := lang.Apply(v26, []any{v34, v38}) -v40 := lang.Apply(v23, []any{v39}) -v41 := lang.Apply(v20, []any{v40}) -v42 := lang.Apply(v9, []any{v13, v17, v41}) -v43 := lang.Apply(v6, []any{v42}) -return v43 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("inc").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns a number one greater than num. Does not auto-promote\n longs, will throw on overflow. See also: inc'", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(915), lang.NewKeyword("end-line"), int(915))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5, _ := lang.FieldOrMethod(lang.Numbers, "inc") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("inc is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// inc' -{ -var v1 lang.FnFunc -{ // function inc'__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/incP")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v3}) -v35 := lang.Apply(v26, []any{v30, v34}) -v36 := lang.Apply(v23, []any{v35}) -v37 := lang.Apply(v20, []any{v36}) -v38 := lang.Apply(v9, []any{v13, v17, v37}) -v39 := lang.Apply(v6, []any{v38}) -return v39 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("inc'").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns a number one greater than num. Supports arbitrary precision.\n See also: inc", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(908), lang.NewKeyword("end-line"), int(908))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5, _ := lang.FieldOrMethod(lang.Numbers, "incP") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("incP is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// indexed? -{ -v0 := lang.NewSymbol("indexed?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return true if coll implements Indexed, indicating efficient lookup by index", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6263), lang.NewKeyword("end-line"), int(6263))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{glojure.lang4.Indexed, v3}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// infinite? -{ -var v1 lang.FnFunc -{ // function infinite?__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol("Double/isInfinite")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v3}) -v18 := lang.Apply(v9, []any{v13, v17}) -v19 := lang.Apply(v6, []any{v18}) -return v19 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("infinite?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns true if num is negative or positive infinity, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)), lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7977), lang.NewKeyword("end-line"), int(7977))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := lang.Apply(nil, []any{v4}) -return v5 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// inst-ms -{ -v0 := lang.NewSymbol("inst-ms").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("inst"))), lang.NewKeyword("doc"), "Return the number of milliseconds since January 1, 1970, 00:00:00 GMT", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6831), lang.NewKeyword("end-line"), int(6831))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.Apply(nil, []any{v3}) -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// inst? -{ -v0 := lang.NewSymbol("inst?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x satisfies Inst", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6837), lang.NewKeyword("end-line"), int(6837))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -return nil -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// instance? -{ -v0 := lang.NewSymbol("instance?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Evaluates x and tests if it is an instance of the type\n t. Returns true or false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(139), lang.NewKeyword("end-line"), int(143))).(*lang.Symbol) -var v2 lang.FnFunc -{ // function instance? -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6 := lang.Apply(lang.HasType, []any{v4, v5}) -return v6 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(143), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(143), lang.NewKeyword("end-column"), int(85))).(lang.FnFunc) -v3 := v2 -_ = v3 -} -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// int -{ -var v1 lang.FnFunc -{ // function int__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -var v30 any -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -if lang.IsTruthy(v33) { -v30 = lang.NewSymbol("uncheckedIntCast") -} else { -v30 = lang.NewSymbol("intCast") -} -v34 := lang.Apply(v29, []any{v30}) -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("list")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v3}) -v39 := lang.Apply(v26, []any{v34, v38}) -v40 := lang.Apply(v23, []any{v39}) -v41 := lang.Apply(v20, []any{v40}) -v42 := lang.Apply(v9, []any{v13, v17, v41}) -v43 := lang.Apply(v6, []any{v42}) -return v43 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to int", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(875), lang.NewKeyword("end-line"), int(875))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5, _ := lang.FieldOrMethod(runtime5.RT, "IntCast") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("IntCast is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// int-array -{ -var v1 lang.FnFunc -{ // function int-array__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewList(args[0:]...) -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/intArray")}) -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("list")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("seq")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("concat")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("list")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.Apply(v37, []any{lang.NewSymbol("glojure.core/args")}) -v39 := lang.Apply(v30, []any{v34, v38}) -v40 := lang.Apply(v27, []any{v39}) -v41 := lang.Apply(v24, []any{v40}) -v42 := lang.Apply(v9, []any{v13, v17, v21, v41}) -v43 := lang.Apply(v6, []any{v42}) -return v43 - } -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("int-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Creates an array of ints", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5356), lang.NewKeyword("end-line"), int(5356))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v4 := args[0] -v5, _ := lang.FieldOrMethod(lang.Numbers, "intArray") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("intArray is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 - case 2: -v4 := args[0] -v5 := args[1] -v6, _ := lang.FieldOrMethod(lang.Numbers, "intArrayInit") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("intArrayInit is not a function"))) -} -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// int? -{ -v0 := lang.NewSymbol("int?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a fixed precision integer", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1395), lang.NewKeyword("end-line"), int(1395))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{lang.Builtins["int64"], v3}) -var v4 any = v8 -_ = v4 -var v10 any -if lang.IsTruthy(v4) { -v10 = v4 -} else { -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("instance?")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{nil, v3}) -var v11 any = v15 -_ = v11 -var v17 any -if lang.IsTruthy(v11) { -v17 = v11 -} else { -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("instance?")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{nil, v3}) -var v18 any = v22 -_ = v18 -var v24 any -if lang.IsTruthy(v18) { -v24 = v18 -} else { -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("instance?")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.Apply(v27, []any{nil, v3}) -v24 = v28 -} -v17 = v24 -} -v10 = v17 -} -return v10 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// integer? -{ -v0 := lang.NewSymbol("integer?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is an integer", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1379), lang.NewKeyword("end-line"), int(1379))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.Apply(lang.IsInteger, []any{v3}) -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// interleave -{ -v0 := lang.NewSymbol("interleave").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("c1")), lang.NewVector(lang.NewSymbol("c1"), lang.NewSymbol("c2")), lang.NewVector(lang.NewSymbol("c1"), lang.NewSymbol("c2"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Returns a lazy seq of the first item in each coll, then the second etc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4308), lang.NewKeyword("end-line"), int(4308))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -return lang.NewList() - case 1: -v3 := args[0] -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -return v3 -}) -v5 := lang.Apply(lang.NewLazySeq, []any{v4}) -return v5 - case 2: -v3 := args[0] -v4 := args[1] -var v5 lang.FnFunc -v5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("seq")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v3}) -var v6 any = v10 -_ = v6 -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("seq")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v4}) -var v11 any = v15 -_ = v11 -var v17 any -var v18 any = v6 -_ = v18 -var v20 any -if lang.IsTruthy(v18) { -v20 = v11 -} else { -v20 = v18 -} -if lang.IsTruthy(v20) { -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("cons")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("first")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v6}) -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("cons")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("first")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{v11}) -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("interleave")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("rest")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v6}) -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("rest")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) -} -v41 := v40.Get() -v42 := lang.Apply(v41, []any{v11}) -v43 := lang.Apply(v34, []any{v38, v42}) -v44 := lang.Apply(v27, []any{v31, v43}) -v45 := lang.Apply(v20, []any{v24, v44}) -v17 = v45 -} else { -v17 = nil -} -return v17 -}) -v6 := lang.Apply(lang.NewLazySeq, []any{v5}) -return v6 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -var v6 lang.FnFunc -v6 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("map")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("seq")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("conj")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v5, v4, v3}) -v18 := lang.Apply(v10, []any{v13, v17}) -var v7 any = v18 -_ = v7 -var v20 any -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("every?")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("identity")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v23, []any{v26, v7}) -if lang.IsTruthy(v27) { -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("concat")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("map")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("first")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.Apply(v33, []any{v36, v7}) -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("apply")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("interleave")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("map")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("rest")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) -} -v49 := v48.Get() -v50 := lang.Apply(v46, []any{v49, v7}) -v51 := lang.Apply(v40, []any{v43, v50}) -v52 := lang.Apply(v30, []any{v37, v51}) -v20 = v52 -} else { -v20 = nil -} -return v20 -}) -v7 := lang.Apply(lang.NewLazySeq, []any{v6}) -return v7 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// intern -{ -v0 := lang.NewSymbol("intern").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name"), lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Finds or creates a var named by the symbol name in the namespace\n ns (which can be a symbol or a namespace), setting its root binding\n to val if supplied. The namespace must exist. The var will adopt any\n metadata from the name symbol. Returns the var.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6311), lang.NewKeyword("end-line"), int(6311))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v3 := args[0] -v4 := args[1] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("the-ns")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v3}) -v10 := lang.Apply(nil, []any{v9, v4}) -var v5 any = v10 -_ = v5 -var v12 any -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("meta")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v4}) -if lang.IsTruthy(v16) { -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("meta")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v4}) -v21, _ := lang.FieldOrMethod(v5, "setMeta") -if reflect.TypeOf(v21).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMeta is not a function"))) -} -v22 := lang.Apply(v21, []any{v20}) -v12 = v22 -} else { -v12 = nil -} -_ = v12 -return v5 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("the-ns")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v3}) -v11 := lang.Apply(nil, []any{v10, v4, v5}) -var v6 any = v11 -_ = v6 -var v13 any -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("meta")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v4}) -if lang.IsTruthy(v17) { -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("meta")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v20, []any{v4}) -v22, _ := lang.FieldOrMethod(v6, "setMeta") -if reflect.TypeOf(v22).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMeta is not a function"))) -} -v23 := lang.Apply(v22, []any{v21}) -v13 = v23 -} else { -v13 = nil -} -_ = v13 -return v6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// interpose -{ -v0 := lang.NewSymbol("interpose").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sep")), lang.NewVector(lang.NewSymbol("sep"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy seq of the elements of coll separated by sep.\n Returns a stateful transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5230), lang.NewKeyword("end-line"), int(5230))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := args[0] -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("volatile!")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{false}) -var v6 any = v10 -_ = v6 -var v12 lang.FnFunc -v12 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v13 := lang.Apply(v5, nil) -return v13 - case 1: -v13 := args[0] -v14 := lang.Apply(v5, []any{v13}) -return v14 - case 2: -v13 := args[0] -v14 := args[1] -var v15 any -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("deref")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v6}) -if lang.IsTruthy(v19) { -v21 := lang.Apply(v5, []any{v13, v3}) -var v20 any = v21 -_ = v20 -var v23 any -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("reduced?")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v20}) -if lang.IsTruthy(v27) { -v23 = v20 -} else { -v28 := lang.Apply(v5, []any{v20, v14}) -v23 = v28 -} -v15 = v23 -} else { -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("vreset!")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.Apply(v22, []any{v6, true}) -_ = v23 -v24 := lang.Apply(v5, []any{v13, v14}) -v15 = v24 -} -return v15 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5238), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(5249), lang.NewKeyword("end-column"), int(35)) -v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v14 -}) -v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5236), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(5249), lang.NewKeyword("end-column"), int(37)) -v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v6 - case 2: -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("drop")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("interleave")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("repeat")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v3}) -v15 := lang.Apply(v10, []any{v14, v4}) -v16 := lang.Apply(v7, []any{int64(1), v15}) -return v16 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// into -{ -v0 := lang.NewSymbol("into").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("to")), lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("from")), lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("xform"), lang.NewSymbol("from"))), lang.NewKeyword("doc"), "Returns a new coll consisting of to with all of the items of\n from conjoined. A transducer may be supplied.\n (into x) returns x. (into) returns [].", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6922), lang.NewKeyword("end-line"), int(6922))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v3 := lang.NewVector() -v4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6928), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(6928), lang.NewKeyword("end-column"), int(8)) -v5, err := lang.WithMeta(v3, v4.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v5 - case 1: -v3 := args[0] -return v3 - case 2: -v3 := args[0] -v4 := args[1] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{lang.IEditableCollection, v3}) -if lang.IsTruthy(v9) { -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("with-meta")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("persistent!")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("reduce")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("conj!")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("transient")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v26 := lang.Apply(v18, []any{v21, v25, v4}) -v27 := lang.Apply(v15, []any{v26}) -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("meta")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{v3}) -v32 := lang.Apply(v12, []any{v27, v31}) -v5 = v32 -} else { -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("reduce")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("conj")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v35, []any{v38, v3, v4}) -v5 = v39 -} -return v5 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -var v6 any -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("instance?")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{lang.IEditableCollection, v3}) -if lang.IsTruthy(v10) { -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("meta")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v3}) -var v11 any = v15 -_ = v11 -var v17 lang.FnFunc -v17 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v18 := args[0] -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("with-meta")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("persistent!")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v18}) -v26 := lang.Apply(v21, []any{v25, v11}) -return v26 - case 2: -v18 := args[0] -v19 := args[1] -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("conj!")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.Apply(v22, []any{v18, v19}) -return v23 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6937), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(6939), lang.NewKeyword("end-column"), int(44)) -v19, err := lang.WithMeta(v17, v18.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v16 any = v19 -_ = v16 -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("transduce")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("transient")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v3}) -v28 := lang.Apply(v23, []any{v4, v16, v27, v5}) -v6 = v28 -} else { -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("transduce")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("conj")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v13, []any{v4, v16, v3, v5}) -v6 = v17 -} -return v6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// into-array -{ -v0 := lang.NewSymbol("into-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("aseq")), lang.NewVector(lang.NewSymbol("type"), lang.NewSymbol("aseq"))), lang.NewKeyword("doc"), "Returns an array with components set to the values in aseq. The array's\n component type is type if provided, or the type of the first value in\n aseq if present, or Object. All values in aseq must be compatible with\n the component type. Class objects for the primitive types can be obtained\n using, e.g., Integer/TYPE.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3444), lang.NewKeyword("end-line"), int(3444))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{v3}) -v8 := lang.Apply(nil, []any{v7}) -return v8 - case 2: -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v4}) -v9 := lang.Apply(nil, []any{v3, v8}) -return v9 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// into1 -{ -v0 := lang.NewSymbol("into1").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("from"))), lang.NewKeyword("doc"), "Returns a new coll consisting of to-coll with all of the items of\n from-coll conjoined.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3416), lang.NewKeyword("end-line"), int(3416), lang.NewKeyword("private"), true)).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{lang.IEditableCollection, v3}) -if lang.IsTruthy(v9) { -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("persistent!")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("reduce1")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("conj!")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("transient")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v3}) -v23 := lang.Apply(v15, []any{v18, v22, v4}) -v24 := lang.Apply(v12, []any{v23}) -v5 = v24 -} else { -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("reduce1")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("conj")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v27, []any{v30, v3, v4}) -v5 = v31 -} -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// ints -{ -var v1 lang.FnFunc -{ // function ints -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/ints")}) -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("list")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v26 := lang.Apply(v9, []any{v13, v17, v21, v25}) -v27 := lang.Apply(v6, []any{v26}) -return v27 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("ints").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Casts to int[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5397), lang.NewKeyword("end-line"), int(5397))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5, _ := lang.FieldOrMethod(lang.Numbers, "ints") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ints is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// io! -{ -v0 := lang.NewSymbol("io!").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "If an io! block occurs in a transaction, throws an\n IllegalStateException, else runs body in an implicit do. If the\n first expression in body is a literal string, will use that as the\n exception message.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(2504), lang.NewKeyword("end-line"), int(2504))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -var v7 any -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("string?")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("first")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v5}) -v15 := lang.Apply(v10, []any{v14}) -if lang.IsTruthy(v15) { -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("first")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v5}) -v7 = v19 -} else { -v7 = nil -} -var v6 any = v7 -_ = v6 -var v21 any -if lang.IsTruthy(v6) { -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("next")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v20}) -v21 = v25 -} else { -v21 = v20 -} -var v20 any = v21 -_ = v20 -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("seq")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("concat")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("list")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{lang.NewSymbol("if")}) -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("list")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("seq")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("concat")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("list")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) -} -v48 := v47.Get() -v49 := lang.Apply(v48, []any{lang.NewSymbol("glojure.lang.LockingTransaction/isRunning")}) -v50 := lang.Apply(v45, []any{v49}) -v51 := lang.Apply(v42, []any{v50}) -v52 := lang.Apply(v39, []any{v51}) -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("list")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) -} -v55 := v54.Get() -v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v57 := v56.FindInternedVar(lang.NewSymbol("seq")) -if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) -} -v58 := v57.Get() -v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v60 := v59.FindInternedVar(lang.NewSymbol("concat")) -if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) -} -v61 := v60.Get() -v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v63 := v62.FindInternedVar(lang.NewSymbol("list")) -if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) -} -v64 := v63.Get() -v65 := lang.Apply(v64, []any{lang.NewSymbol("throw")}) -v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v67 := v66.FindInternedVar(lang.NewSymbol("list")) -if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) -} -v68 := v67.Get() -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("seq")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) -} -v71 := v70.Get() -v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v73 := v72.FindInternedVar(lang.NewSymbol("concat")) -if v73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) -} -v74 := v73.Get() -v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v76 := v75.FindInternedVar(lang.NewSymbol("list")) -if v76.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) -} -v77 := v76.Get() -v78 := lang.Apply(v77, []any{lang.NewSymbol("new")}) -v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v80 := v79.FindInternedVar(lang.NewSymbol("list")) -if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) -} -v81 := v80.Get() -v82 := lang.Apply(v81, []any{lang.NewSymbol("glojure.core/IllegalStateException")}) -v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v84 := v83.FindInternedVar(lang.NewSymbol("list")) -if v84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) -} -v85 := v84.Get() -var v86 any = v6 -_ = v86 -var v88 any -if lang.IsTruthy(v86) { -v88 = v86 -} else { -v88 = "I/O in transaction" -} -v86 := lang.Apply(v85, []any{v88}) -v87 := lang.Apply(v74, []any{v78, v82, v86}) -v88 := lang.Apply(v71, []any{v87}) -v89 := lang.Apply(v68, []any{v88}) -v90 := lang.Apply(v61, []any{v65, v89}) -v91 := lang.Apply(v58, []any{v90}) -v92 := lang.Apply(v55, []any{v91}) -v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v94 := v93.FindInternedVar(lang.NewSymbol("list")) -if v94.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) -} -v95 := v94.Get() -v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v97 := v96.FindInternedVar(lang.NewSymbol("seq")) -if v97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) -} -v98 := v97.Get() -v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v100 := v99.FindInternedVar(lang.NewSymbol("concat")) -if v100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) -} -v101 := v100.Get() -v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v103 := v102.FindInternedVar(lang.NewSymbol("list")) -if v103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) -} -v104 := v103.Get() -v105 := lang.Apply(v104, []any{lang.NewSymbol("do")}) -v106 := lang.Apply(v101, []any{v105, v20}) -v107 := lang.Apply(v98, []any{v106}) -v108 := lang.Apply(v95, []any{v107}) -v109 := lang.Apply(v32, []any{v36, v52, v92, v108}) -v110 := lang.Apply(v29, []any{v109}) -return v110 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// isa? -{ -v0 := lang.NewSymbol("isa?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("child"), lang.NewSymbol("parent")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("child"), lang.NewSymbol("parent"))), lang.NewKeyword("doc"), "Returns true if (= child parent), or child is directly or indirectly derived from\n parent, either via a Java type inheritance relationship or a\n relationship established via derive. h must be a hierarchy obtained\n from make-hierarchy, if not supplied defaults to the global\n hierarchy", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5543), lang.NewKeyword("end-line"), int(5543))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("isa?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("global-hierarchy")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v7, []any{v10, v3, v4}) -return v11 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("=")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v4, v5}) -var v6 any = v10 -_ = v6 -var v12 any -if lang.IsTruthy(v6) { -v12 = v6 -} else { -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("class?")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v5}) -var v14 any = v18 -_ = v14 -var v20 any -if lang.IsTruthy(v14) { -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("class?")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v4}) -var v21 any = v25 -_ = v21 -var v27 any -if lang.IsTruthy(v21) { -v28, _ := lang.FieldOrMethod(v4, "AssignableTo") -if reflect.TypeOf(v28).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("AssignableTo is not a function"))) -} -v29 := lang.Apply(v28, []any{v5}) -v27 = v29 -} else { -v27 = v21 -} -v20 = v27 -} else { -v20 = v14 -} -var v13 any = v20 -_ = v13 -var v15 any -if lang.IsTruthy(v13) { -v15 = v13 -} else { -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("contains?")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) -v21 := lang.Apply(v20, []any{v4}) -v22 := lang.Apply(v19, []any{v21, v5}) -var v16 any = v22 -_ = v16 -var v24 any -if lang.IsTruthy(v16) { -v24 = v16 -} else { -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("class?")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{v4}) -var v26 any = v30 -_ = v26 -var v32 any -if lang.IsTruthy(v26) { -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("some")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -var v36 lang.FnFunc -v36 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v37 := args[0] -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("contains?")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) -v42 := lang.Apply(v41, []any{v37}) -v43 := lang.Apply(v40, []any{v42, v5}) -return v43 -}) -v37 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5556), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(5556), lang.NewKeyword("end-column"), int(71)) -v38, err := lang.WithMeta(v36, v37.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("supers")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) -} -v41 := v40.Get() -v42 := lang.Apply(v41, []any{v4}) -v43 := lang.Apply(v35, []any{v38, v42}) -v32 = v43 -} else { -v32 = v26 -} -var v25 any = v32 -_ = v25 -var v27 any -if lang.IsTruthy(v25) { -v27 = v25 -} else { -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("vector?")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.Apply(v31, []any{v5}) -var v28 any = v32 -_ = v28 -var v34 any -if lang.IsTruthy(v28) { -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("vector?")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v4}) -var v35 any = v39 -_ = v35 -var v41 any -if lang.IsTruthy(v35) { -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("=")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("count")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) -} -v48 := v47.Get() -v49 := lang.Apply(v48, []any{v5}) -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("count")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.Apply(v52, []any{v4}) -v54 := lang.Apply(v45, []any{v49, v53}) -var v42 any = v54 -_ = v42 -var v56 any -if lang.IsTruthy(v42) { -var v57 any = true -_ = v57 -var v58 any = int64(0) -_ = v58 -var v59 any -for { -var v60 any -v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v63 := v62.FindInternedVar(lang.NewSymbol("not")) -if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) -} -v64 := v63.Get() -v65 := lang.Apply(v64, []any{v57}) -var v61 any = v65 -_ = v61 -var v67 any -if lang.IsTruthy(v61) { -v67 = v61 -} else { -v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v69 := v68.FindInternedVar(lang.NewSymbol("=")) -if v69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) -} -v70 := v69.Get() -v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v72 := v71.FindInternedVar(lang.NewSymbol("count")) -if v72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) -} -v73 := v72.Get() -v74 := lang.Apply(v73, []any{v5}) -v75 := lang.Apply(v70, []any{v58, v74}) -v67 = v75 -} -if lang.IsTruthy(v67) { -v60 = v57 -} else { -v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v63 := v62.FindInternedVar(lang.NewSymbol("isa?")) -if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) -} -v64 := v63.Get() -v65 := lang.Apply(v4, []any{v58}) -v66 := lang.Apply(v5, []any{v58}) -v67 := lang.Apply(v64, []any{v3, v65, v66}) -var v61 any = v67 -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("inc")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) -} -v71 := v70.Get() -v72 := lang.Apply(v71, []any{v58}) -var v68 any = v72 -v57 = v61 -v58 = v68 -continue -} -v59 = v60 - break -} -v56 = v59 -} else { -v56 = v42 -} -v41 = v56 -} else { -v41 = v35 -} -v34 = v41 -} else { -v34 = v28 -} -v27 = v34 -} -v24 = v27 -} -v15 = v24 -} -v12 = v15 -} -return v12 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// iterate -{ -v0 := lang.NewSymbol("iterate").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns a lazy (infinite!) sequence of x, (f x), (f (f x)) etc.\n f must be free of side-effects", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3011), lang.NewKeyword("end-line"), int(3011))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.Apply(nil, []any{v3, v4}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// iteration -{ -v0 := lang.NewSymbol("iteration").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("step"), lang.NewSymbol("&"), lang.NewMap(lang.NewKeyword("keys"), lang.NewVector(lang.NewSymbol("somef"), lang.NewSymbol("vf"), lang.NewSymbol("kf"), lang.NewSymbol("initk")), lang.NewKeyword("or"), lang.NewMap(lang.NewSymbol("vf"), lang.NewSymbol("identity"), lang.NewSymbol("kf"), lang.NewSymbol("identity"), lang.NewSymbol("somef"), lang.NewSymbol("some?"), lang.NewSymbol("initk"), nil)))), lang.NewKeyword("doc"), "Creates a seqable/reducible via repeated calls to step,\n a function of some (continuation token) 'k'. The first call to step\n will be passed initk, returning 'ret'. Iff (somef ret) is true,\n (vf ret) will be included in the iteration, else iteration will\n terminate and vf/kf will not be called. If (kf ret) is non-nil it\n will be passed to the next step call, else iteration will terminate.\n\n This can be used e.g. to consume APIs that return paginated or batched data.\n\n step - (possibly impure) fn of 'k' -> 'ret'\n\n :somef - fn of 'ret' -> logical true/false, default 'some?'\n :vf - fn of 'ret' -> 'v', a value produced by the iteration, default 'identity'\n :kf - fn of 'ret' -> 'next-k' or nil (signaling 'do not continue'), default 'identity'\n :initk - the first value passed to step, default 'nil'\n\n It is presumed that step with non-initk is unreproducible/non-idempotent.\n If step with initk is unreproducible it is on the consumer to not consume twice.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7716), lang.NewKeyword("end-line"), int(7716))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.NewList(args[1:]...) -var v5 any = v4 -_ = v5 -var v7 any -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("seq?")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v6}) -if lang.IsTruthy(v11) { -var v12 any -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("next")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v6}) -if lang.IsTruthy(v16) { -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("to-array")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v6}) -v21 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{v20}) -v12 = v21 -} else { -var v22 any -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("seq")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{v6}) -if lang.IsTruthy(v26) { -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("first")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{v6}) -v22 = v30 -} else { -v22 = nil -} -v12 = v22 -} -v7 = v12 -} else { -v7 = v6 -} -var v6 any = v7 -_ = v6 -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("get")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("some?")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.Apply(v34, []any{v6, lang.NewKeyword("somef"), v37}) -var v31 any = v38 -_ = v31 -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("get")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("identity")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.Apply(v42, []any{v6, lang.NewKeyword("vf"), v45}) -var v39 any = v46 -_ = v39 -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("get")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v52 := v51.FindInternedVar(lang.NewSymbol("identity")) -if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) -} -v53 := v52.Get() -v54 := lang.Apply(v50, []any{v6, lang.NewKeyword("kf"), v53}) -var v47 any = v54 -_ = v47 -v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v57 := v56.FindInternedVar(lang.NewSymbol("get")) -if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) -} -v58 := v57.Get() -v59 := lang.Apply(v58, []any{v6, lang.NewKeyword("initk"), nil}) -var v55 any = v59 -_ = v55 -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("seq")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) -} -v63 := v62.Get() -v64 := lang.NewVector(nil) -v65 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7743), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(7743), lang.NewKeyword("end-column"), int(11)) -v66, err := lang.WithMeta(v64, v65.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v67 lang.FnFunc -{ // function next -v67 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v69 := args[0] -var v70 any -v71 := lang.Apply(v31, []any{v69}) -if lang.IsTruthy(v71) { -v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v73 := v72.FindInternedVar(lang.NewSymbol("cons")) -if v73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) -} -v74 := v73.Get() -v75 := lang.Apply(v39, []any{v69}) -v77 := lang.Apply(v47, []any{v69}) -var v76 any = v77 -_ = v76 -var v79 any -v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v81 := v80.FindInternedVar(lang.NewSymbol("nil?")) -if v81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) -} -v82 := v81.Get() -v83 := lang.Apply(v82, []any{v76}) -if lang.IsTruthy(v83) { -v79 = nil -} else { -var v84 any = v76 -_ = v84 -var v86 lang.FnFunc -v86 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v87 := lang.Apply(v3, []any{v84}) -v88 := lang.Apply(v68, []any{v87}) -return v88 -}) -v87 := lang.Apply(lang.NewLazySeq, []any{v86}) -v79 = v87 -} -v76 := lang.Apply(v74, []any{v75, v79}) -v70 = v76 -} else { -v70 = nil -} -return v70 -}) -v68 := v67 -_ = v68 -} -v68 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7744), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(7748), lang.NewKeyword("end-column"), int(51)) -v69, err := lang.WithMeta(v67, v68.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v70 := lang.Apply(v3, []any{v55}) -v71 := lang.Apply(v69, []any{v70}) -v72 := lang.Apply(v63, []any{v66, v71}) -v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v74 := v73.FindInternedVar(lang.NewSymbol("reduce")) -if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) -} -v75 := v74.Get() -v76 := lang.NewVector(nil, nil, nil) -v77 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7751), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(7751), lang.NewKeyword("end-column"), int(22)) -v78, err := lang.WithMeta(v76, v77.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v79 any = nil -_ = v79 -v81 := lang.Apply(v3, []any{v55}) -var v80 any = v81 -_ = v80 -var v82 any -for { -var v83 any -v84 := lang.Apply(v31, []any{v80}) -if lang.IsTruthy(v84) { -v86 := lang.Apply(v39, []any{v80}) -v87 := lang.Apply(nil, []any{v85, v86}) -var v85 any = v87 -_ = v85 -var v89 any -v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v91 := v90.FindInternedVar(lang.NewSymbol("reduced?")) -if v91.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) -} -v92 := v91.Get() -v93 := lang.Apply(v92, []any{v85}) -if lang.IsTruthy(v93) { -v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v95 := v94.FindInternedVar(lang.NewSymbol("deref")) -if v95.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) -} -v96 := v95.Get() -v97 := lang.Apply(v96, []any{v85}) -v89 = v97 -} else { -v99 := lang.Apply(v47, []any{v80}) -var v98 any = v99 -_ = v98 -var v101 any -v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v103 := v102.FindInternedVar(lang.NewSymbol("nil?")) -if v103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) -} -v104 := v103.Get() -v105 := lang.Apply(v104, []any{v98}) -if lang.IsTruthy(v105) { -v101 = v85 -} else { -var v106 any = v98 -_ = v106 -var v108 any = v85 -v110 := lang.Apply(v3, []any{v106}) -var v109 any = v110 -v79 = v108 -v80 = v109 -continue -} -v89 = v101 -} -v83 = v89 -} else { -v83 = v79 -} -v82 = v83 - break -} -v79 := lang.Apply(v75, []any{v78, v82}) -v80 := lang.Apply(nil, []any{glojure.lang4.Seqable, v72, lang.IReduceInit, v79}) -return v80 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// iterator-seq -{ -v0 := lang.NewSymbol("iterator-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("iter"))), lang.NewKeyword("doc"), "Returns a seq on a java.util.Iterator. Note that most collections\n providing iterators implement Iterable and thus support seq directly.\n Seqs cache values, thus iterator-seq should not be used on any\n iterator that repeatedly returns the same mutable object.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5700), lang.NewKeyword("end-line"), int(5700))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.Apply(nil, []any{v3}) -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// juxt -{ -v0 := lang.NewSymbol("juxt").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("g")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("g"), lang.NewSymbol("h")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("g"), lang.NewSymbol("h"), lang.NewSymbol("&"), lang.NewSymbol("fs"))), lang.NewKeyword("doc"), "Takes a set of functions and returns a fn that is the juxtaposition\n of those fns. The returned fn takes a variable number of args, and\n returns a vector containing the result of applying each fn to the\n args (left-to-right).\n ((juxt a b c) x) => [(a x) (b x) (c x)]", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2568), lang.NewKeyword("end-line"), int(2568))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v5 := lang.Apply(v3, nil) -v6 := lang.NewVector(v5) -v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2578), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(2578), lang.NewKeyword("end-column"), int(16)) -v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v8 - case 1: -v5 := args[0] -v6 := lang.Apply(v3, []any{v5}) -v7 := lang.NewVector(v6) -v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2579), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(2579), lang.NewKeyword("end-column"), int(19)) -v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v9 - case 2: -v5 := args[0] -v6 := args[1] -v7 := lang.Apply(v3, []any{v5, v6}) -v8 := lang.NewVector(v7) -v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2580), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(2580), lang.NewKeyword("end-column"), int(23)) -v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v10 - case 3: -v5 := args[0] -v6 := args[1] -v7 := args[2] -v8 := lang.Apply(v3, []any{v5, v6, v7}) -v9 := lang.NewVector(v8) -v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2581), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(2581), lang.NewKeyword("end-column"), int(27)) -v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v11 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := args[0] -v6 := args[1] -v7 := args[2] -v8 := lang.NewList(args[3:]...) -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("apply")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v3, v5, v6, v7, v8}) -v13 := lang.NewVector(v12) -v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2582), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(2582), lang.NewKeyword("end-column"), int(45)) -v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v15 - } -}) -v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2577), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2582), lang.NewKeyword("end-column"), int(47)) -v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v6 - case 2: -v3 := args[0] -v4 := args[1] -var v5 lang.FnFunc -v5 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v6 := lang.Apply(v3, nil) -v7 := lang.Apply(v4, nil) -v8 := lang.NewVector(v6, v7) -v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2585), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(2585), lang.NewKeyword("end-column"), int(20)) -v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v10 - case 1: -v6 := args[0] -v7 := lang.Apply(v3, []any{v6}) -v8 := lang.Apply(v4, []any{v6}) -v9 := lang.NewVector(v7, v8) -v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2586), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(2586), lang.NewKeyword("end-column"), int(25)) -v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v11 - case 2: -v6 := args[0] -v7 := args[1] -v8 := lang.Apply(v3, []any{v6, v7}) -v9 := lang.Apply(v4, []any{v6, v7}) -v10 := lang.NewVector(v8, v9) -v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2587), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(2587), lang.NewKeyword("end-column"), int(31)) -v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v12 - case 3: -v6 := args[0] -v7 := args[1] -v8 := args[2] -v9 := lang.Apply(v3, []any{v6, v7, v8}) -v10 := lang.Apply(v4, []any{v6, v7, v8}) -v11 := lang.NewVector(v9, v10) -v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2588), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(2588), lang.NewKeyword("end-column"), int(37)) -v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v13 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v6 := args[0] -v7 := args[1] -v8 := args[2] -v9 := lang.NewList(args[3:]...) -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("apply")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{v3, v6, v7, v8, v9}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("apply")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v4, v6, v7, v8, v9}) -v18 := lang.NewVector(v13, v17) -v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2589), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(2589), lang.NewKeyword("end-column"), int(66)) -v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v20 - } -}) -v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2584), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2589), lang.NewKeyword("end-column"), int(68)) -v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v7 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -var v6 lang.FnFunc -v6 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v7 := lang.Apply(v3, nil) -v8 := lang.Apply(v4, nil) -v9 := lang.Apply(v5, nil) -v10 := lang.NewVector(v7, v8, v9) -v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2592), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(2592), lang.NewKeyword("end-column"), int(24)) -v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v12 - case 1: -v7 := args[0] -v8 := lang.Apply(v3, []any{v7}) -v9 := lang.Apply(v4, []any{v7}) -v10 := lang.Apply(v5, []any{v7}) -v11 := lang.NewVector(v8, v9, v10) -v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2593), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(2593), lang.NewKeyword("end-column"), int(31)) -v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v13 - case 2: -v7 := args[0] -v8 := args[1] -v9 := lang.Apply(v3, []any{v7, v8}) -v10 := lang.Apply(v4, []any{v7, v8}) -v11 := lang.Apply(v5, []any{v7, v8}) -v12 := lang.NewVector(v9, v10, v11) -v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2594), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(2594), lang.NewKeyword("end-column"), int(39)) -v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v14 - case 3: -v7 := args[0] -v8 := args[1] -v9 := args[2] -v10 := lang.Apply(v3, []any{v7, v8, v9}) -v11 := lang.Apply(v4, []any{v7, v8, v9}) -v12 := lang.Apply(v5, []any{v7, v8, v9}) -v13 := lang.NewVector(v10, v11, v12) -v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2595), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(2595), lang.NewKeyword("end-column"), int(47)) -v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v15 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v7 := args[0] -v8 := args[1] -v9 := args[2] -v10 := lang.NewList(args[3:]...) -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("apply")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v3, v7, v8, v9, v10}) -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("apply")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v4, v7, v8, v9, v10}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("apply")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v5, v7, v8, v9, v10}) -v23 := lang.NewVector(v14, v18, v22) -v24 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2596), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(2596), lang.NewKeyword("end-column"), int(87)) -v25, err := lang.WithMeta(v23, v24.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v25 - } -}) -v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2591), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2596), lang.NewKeyword("end-column"), int(89)) -v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v8 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("list*")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v3, v4, v5, v7}) -var v7 any = v11 -_ = v7 -var v13 lang.FnFunc -v13 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("reduce1")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -var v17 lang.FnFunc -v17 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v18 := args[0] -v19 := args[1] -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("conj")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.Apply(v19, nil) -v24 := lang.Apply(v22, []any{v18, v23}) -return v24 -}) -v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2600), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(2600), lang.NewKeyword("end-column"), int(37)) -v19, err := lang.WithMeta(v17, v18.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v20 := lang.NewVector() -v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2600), lang.NewKeyword("column"), int(39), lang.NewKeyword("end-line"), int(2600), lang.NewKeyword("end-column"), int(40)) -v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v23 := lang.Apply(v16, []any{v19, v22, v7}) -return v23 - case 1: -v14 := args[0] -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("reduce1")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -var v18 lang.FnFunc -v18 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v19 := args[0] -v20 := args[1] -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("conj")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v20, []any{v14}) -v25 := lang.Apply(v23, []any{v19, v24}) -return v25 -}) -v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2601), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(2601), lang.NewKeyword("end-column"), int(40)) -v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v21 := lang.NewVector() -v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2601), lang.NewKeyword("column"), int(42), lang.NewKeyword("end-line"), int(2601), lang.NewKeyword("end-column"), int(43)) -v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v24 := lang.Apply(v17, []any{v20, v23, v7}) -return v24 - case 2: -v14 := args[0] -v15 := args[1] -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("reduce1")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -var v19 lang.FnFunc -v19 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v20 := args[0] -v21 := args[1] -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("conj")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v21, []any{v14, v15}) -v26 := lang.Apply(v24, []any{v20, v25}) -return v26 -}) -v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2602), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(2602), lang.NewKeyword("end-column"), int(44)) -v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v22 := lang.NewVector() -v23 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2602), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(2602), lang.NewKeyword("end-column"), int(47)) -v24, err := lang.WithMeta(v22, v23.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v25 := lang.Apply(v18, []any{v21, v24, v7}) -return v25 - case 3: -v14 := args[0] -v15 := args[1] -v16 := args[2] -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("reduce1")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -var v20 lang.FnFunc -v20 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v21 := args[0] -v22 := args[1] -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("conj")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v22, []any{v14, v15, v16}) -v27 := lang.Apply(v25, []any{v21, v26}) -return v27 -}) -v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2603), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(2603), lang.NewKeyword("end-column"), int(48)) -v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v23 := lang.NewVector() -v24 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2603), lang.NewKeyword("column"), int(50), lang.NewKeyword("end-line"), int(2603), lang.NewKeyword("end-column"), int(51)) -v25, err := lang.WithMeta(v23, v24.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v26 := lang.Apply(v19, []any{v22, v25, v7}) -return v26 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v14 := args[0] -v15 := args[1] -v16 := args[2] -v17 := lang.NewList(args[3:]...) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("reduce1")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -var v21 lang.FnFunc -v21 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v22 := args[0] -v23 := args[1] -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("conj")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("apply")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{v23, v14, v15, v16, v17}) -v31 := lang.Apply(v26, []any{v22, v30}) -return v31 -}) -v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2604), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(2604), lang.NewKeyword("end-column"), int(66)) -v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v24 := lang.NewVector() -v25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2604), lang.NewKeyword("column"), int(68), lang.NewKeyword("end-line"), int(2604), lang.NewKeyword("end-column"), int(69)) -v26, err := lang.WithMeta(v24, v25.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v27 := lang.Apply(v20, []any{v23, v26, v7}) -return v27 - } -}) -v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2599), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(2604), lang.NewKeyword("end-column"), int(75)) -v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v15 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// keep -{ -v0 := lang.NewSymbol("keep").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the non-nil results of (f item). Note,\n this means false return values will be included. f must be free of\n side-effects. Returns a transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7339), lang.NewKeyword("end-line"), int(7339))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := args[0] -var v6 lang.FnFunc -v6 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v7 := lang.Apply(v5, nil) -return v7 - case 1: -v7 := args[0] -v8 := lang.Apply(v5, []any{v7}) -return v8 - case 2: -v7 := args[0] -v8 := args[1] -v10 := lang.Apply(v3, []any{v8}) -var v9 any = v10 -_ = v9 -var v12 any -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("nil?")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v9}) -if lang.IsTruthy(v16) { -v12 = v7 -} else { -v17 := lang.Apply(v5, []any{v7, v9}) -v12 = v17 -} -return v12 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7347), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7354), lang.NewKeyword("end-column"), int(31)) -v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v8 -}) -v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7346), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7354), lang.NewKeyword("end-column"), int(32)) -v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v6 - case 2: -v3 := args[0] -v4 := args[1] -var v5 lang.FnFunc -v5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("seq")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v4}) -var v6 any = v10 -_ = v6 -var v12 any -if lang.IsTruthy(v6) { -var v13 any = v6 -_ = v13 -var v15 any -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("chunked-seq?")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v13}) -if lang.IsTruthy(v19) { -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("chunk-first")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v13}) -var v20 any = v24 -_ = v20 -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("count")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.Apply(v28, []any{v20}) -var v25 any = v29 -_ = v25 -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("chunk-buffer")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v25}) -var v30 any = v34 -_ = v30 -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("long")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v25}) -var v36 any = v40 -_ = v36 -var v42 any = int64(0) -_ = v42 -var v43 any -for { -var v44 any -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("<")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.Apply(v47, []any{v42, v36}) -if lang.IsTruthy(v48) { -v50, _ := lang.FieldOrMethod(v20, "nth") -if reflect.TypeOf(v50).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) -} -v51 := lang.Apply(v50, []any{v42}) -v52 := lang.Apply(v3, []any{v51}) -var v49 any = v52 -_ = v49 -var v54 any -v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v56 := v55.FindInternedVar(lang.NewSymbol("nil?")) -if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) -} -v57 := v56.Get() -v58 := lang.Apply(v57, []any{v49}) -if lang.IsTruthy(v58) { -v54 = nil -} else { -v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v60 := v59.FindInternedVar(lang.NewSymbol("chunk-append")) -if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) -} -v61 := v60.Get() -v62 := lang.Apply(v61, []any{v30, v49}) -v54 = v62 -} -_ = v54 -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("unchecked-inc")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.Apply(v52, []any{v42}) -var v49 any = v53 -v42 = v49 -continue -} else { -v44 = nil -} -v43 = v44 - break -} -_ = v43 -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("chunk-cons")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("chunk")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) -} -v41 := v40.Get() -v42 := lang.Apply(v41, []any{v30}) -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("keep")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("chunk-rest")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) -} -v48 := v47.Get() -v49 := lang.Apply(v48, []any{v13}) -v50 := lang.Apply(v45, []any{v3, v49}) -v51 := lang.Apply(v38, []any{v42, v50}) -v15 = v51 -} else { -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("first")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v13}) -v25 := lang.Apply(v3, []any{v24}) -var v20 any = v25 -_ = v20 -var v27 any -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("nil?")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{v20}) -if lang.IsTruthy(v31) { -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("keep")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("rest")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v13}) -v39 := lang.Apply(v34, []any{v3, v38}) -v27 = v39 -} else { -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("cons")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("keep")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("rest")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) -} -v48 := v47.Get() -v49 := lang.Apply(v48, []any{v13}) -v50 := lang.Apply(v45, []any{v3, v49}) -v51 := lang.Apply(v42, []any{v20, v50}) -v27 = v51 -} -v15 = v27 -} -v12 = v15 -} else { -v12 = nil -} -return v12 -}) -v6 := lang.Apply(lang.NewLazySeq, []any{v5}) -return v6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// keep-indexed -{ -v0 := lang.NewSymbol("keep-indexed").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the non-nil results of (f index item). Note,\n this means false return values will be included. f must be free of\n side-effects. Returns a stateful transducer when no collection is\n provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7372), lang.NewKeyword("end-line"), int(7372))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := args[0] -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("volatile!")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{int64(-1)}) -var v6 any = v10 -_ = v6 -var v12 lang.FnFunc -v12 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v13 := lang.Apply(v5, nil) -return v13 - case 1: -v13 := args[0] -v14 := lang.Apply(v5, []any{v13}) -return v14 - case 2: -v13 := args[0] -v14 := args[1] -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("inc")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19, ok := lang.FieldOrMethod(v6, "Deref") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "Deref"))) -} -var v20 any -switch reflect.TypeOf(v19).Kind() { -case reflect.Func: - v20 = lang.Apply(v19, nil) -default: - v20 = v19 -} -v21 := lang.Apply(v18, []any{v20}) -v22, _ := lang.FieldOrMethod(v6, "reset") -if reflect.TypeOf(v22).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) -} -v23 := lang.Apply(v22, []any{v21}) -var v15 any = v23 -_ = v15 -v25 := lang.Apply(v3, []any{v15, v14}) -var v24 any = v25 -_ = v24 -var v27 any -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("nil?")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{v24}) -if lang.IsTruthy(v31) { -v27 = v13 -} else { -v32 := lang.Apply(v5, []any{v13, v24}) -v27 = v32 -} -return v27 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7382), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7390), lang.NewKeyword("end-column"), int(33)) -v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v14 -}) -v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7380), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7390), lang.NewKeyword("end-column"), int(35)) -v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v6 - case 2: -v3 := args[0] -v4 := args[1] -return nil - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// key -{ -v0 := lang.NewSymbol("key").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("e"))), lang.NewKeyword("doc"), "Returns the key of the map entry.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1563), lang.NewKeyword("end-line"), int(1563))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, _ := lang.FieldOrMethod(v3, "GetKey") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("GetKey is not a function"))) -} -v5 := lang.Apply(v4, []any{}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// keys -{ -v0 := lang.NewSymbol("keys").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"))), lang.NewKeyword("doc"), "Returns a sequence of the map's keys, in the same order as (seq map).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1551), lang.NewKeyword("end-line"), int(1551))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.Apply(lang.Keys, []any{v3}) -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// keyword -{ -v1 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() -v0 := lang.NewSymbol("keyword").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name"))), lang.NewKeyword("doc"), "Returns a Keyword with the given namespace and name. Do not use :\n in the keyword strings, it will be added automatically.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(609), lang.NewKeyword("end-line"), int(609))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v4 := args[0] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("keyword?")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v4}) -if lang.IsTruthy(v9) { -v5 = v4 -} else { -var v10 any -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("symbol?")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v4}) -if lang.IsTruthy(v14) { -v15 := lang.Apply(lang.InternKeywordSymbol, []any{v4}) -v10 = v15 -} else { -var v16 any -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("string?")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v4}) -if lang.IsTruthy(v20) { -v21 := lang.Apply(lang.InternKeywordString, []any{v4}) -v16 = v21 -} else { -v16 = nil -} -v10 = v16 -} -v5 = v10 -} -return v5 - case 2: -v4 := args[0] -v5 := args[1] -v6 := lang.Apply(lang.InternKeyword, []any{v4, v5}) -return v6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v4 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// keyword? -{ -v0 := lang.NewSymbol("keyword?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a Keyword", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(563), lang.NewKeyword("end-line"), int(563))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{lang.Keyword, v3}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// last -{ -v0 := lang.NewSymbol("last").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return the last item in coll, in linear time", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(262), lang.NewKeyword("end-line"), int(266))).(*lang.Symbol) -var v2 lang.FnFunc -{ // function last -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -recur_loop_32: -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("next")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v4}) -if lang.IsTruthy(v9) { -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("next")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v4}) -var v10 any = v14 -v4 = v10 -goto recur_loop_32 -} else { -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("first")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v4}) -v5 = v18 -} -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(266), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(269), lang.NewKeyword("end-column"), int(21))).(lang.FnFunc) -v3 := v2 -_ = v3 -} -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// lazy-cat -{ -v0 := lang.NewSymbol("lazy-cat").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Expands to code which yields a lazy sequence of the concatenation\n of the supplied colls. Each coll expr is not evaluated until it is\n needed. \n\n (lazy-cat xs ys zs) === (concat (lazy-seq xs) (lazy-seq ys) (lazy-seq zs))", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4636), lang.NewKeyword("end-line"), int(4636))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("seq")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("concat")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("list")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{lang.NewSymbol("glojure.core/concat")}) -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("map")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -var v19 lang.FnFunc -v19 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v20 := args[0] -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("list")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v23, []any{lang.NewSymbol("glojure.core/lazy-seq"), v20}) -return v24 -}) -v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4644), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(4644), lang.NewKeyword("end-column"), int(37)) -v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v22 := lang.Apply(v18, []any{v21, v5}) -v23 := lang.Apply(v11, []any{v15, v22}) -v24 := lang.Apply(v8, []any{v23}) -return v24 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// lazy-seq -{ -v0 := lang.NewSymbol("lazy-seq").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Takes a body of expressions that returns an ISeq or nil, and yields\n a Seqable object that will invoke the body only the first time seq\n is called, and will cache the result and return it on all subsequent\n seq calls. See also - realized?", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(676), lang.NewKeyword("end-line"), int(676))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("list")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("list*")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.NewVector() -v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(683), lang.NewKeyword("column"), int(101), lang.NewKeyword("end-line"), int(683), lang.NewKeyword("end-column"), int(102)) -v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v15 := lang.Apply(v11, []any{lang.NewSymbol("fn*"), v14, v5}) -v16 := lang.Apply(v8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewLazySeq"), v15}) -return v16 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// let -{ -v0 := lang.NewSymbol("let").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "binding => binding-form init-expr\n binding-form => name, or destructuring-form\n destructuring-form => map-destructure-form, or seq-destructure-form\n\n Evaluates the exprs in a lexical context in which the symbols in\n the binding-forms are bound to their respective init-exprs or parts\n therein.\n\n See https://glojure.org/reference/special_forms#binding-forms for\n more information about destructuring.", lang.NewKeyword("forms"), lang.NewVector(lang.NewList(lang.NewSymbol("let"), lang.NewVector(lang.NewSymbol("bindings*")), lang.NewSymbol("exprs*"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4496), lang.NewKeyword("end-line"), int(4496), lang.NewKeyword("special-form"), true)).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -var v7 any -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v5}) -if lang.IsTruthy(v11) { -v7 = nil -} else { -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("str")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("first")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v3}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("meta")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) -v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) -v28 := lang.Apply(lang.NewIllegalArgumentError, []any{v27}) -panic(v28) -} -_ = v7 -var v29 any -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("even?")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("count")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v5}) -v37 := lang.Apply(v32, []any{v36}) -if lang.IsTruthy(v37) { -v29 = nil -} else { -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("str")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("first")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v3}) -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("meta")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v3}) -v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) -v53 := lang.Apply(v40, []any{v44, " requires ", "an even number of forms in binding vector", " in ", v47, ":", v52}) -v54 := lang.Apply(lang.NewIllegalArgumentError, []any{v53}) -panic(v54) -} -_ = v29 -_ = nil -v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v56 := v55.FindInternedVar(lang.NewSymbol("seq")) -if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) -} -v57 := v56.Get() -v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v59 := v58.FindInternedVar(lang.NewSymbol("concat")) -if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) -} -v60 := v59.Get() -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("list")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) -} -v63 := v62.Get() -v64 := lang.Apply(v63, []any{lang.NewSymbol("let*")}) -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("list")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) -} -v67 := v66.Get() -v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v69 := v68.FindInternedVar(lang.NewSymbol("destructure")) -if v69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) -} -v70 := v69.Get() -v71 := lang.Apply(v70, []any{v5}) -v72 := lang.Apply(v67, []any{v71}) -v73 := lang.Apply(v60, []any{v64, v72, v6}) -v74 := lang.Apply(v57, []any{v73}) -return v74 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// letfn -{ -v0 := lang.NewSymbol("letfn").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fnspecs"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "fnspec ==> (fname [params*] exprs) or (fname ([params*] exprs)+)\n\n Takes a vector of function specs and a body, and generates a set of\n bindings of functions to their names. All of the names are available\n in all of the definitions of the functions, as well as the body.", lang.NewKeyword("forms"), lang.NewVector(lang.NewList(lang.NewSymbol("letfn"), lang.NewVector(lang.NewSymbol("fnspecs*")), lang.NewSymbol("exprs*"))), lang.NewKeyword("url"), nil, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6545), lang.NewKeyword("end-line"), int(6545), lang.NewKeyword("special-form"), true)).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("seq")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("concat")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("list")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{lang.NewSymbol("letfn*")}) -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("list")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("vec")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("interleave")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("map")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("first")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.Apply(v28, []any{v31, v5}) -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("map")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -var v36 lang.FnFunc -v36 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v37 := args[0] -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("cons")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.Apply(v40, []any{lang.NewSymbol("glojure.core/fn"), v37}) -return v41 -}) -v37 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6555), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(6555), lang.NewKeyword("end-column"), int(47)) -v38, err := lang.WithMeta(v36, v37.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v39 := lang.Apply(v35, []any{v38, v5}) -v40 := lang.Apply(v25, []any{v32, v39}) -v41 := lang.Apply(v22, []any{v40}) -v42 := lang.Apply(v19, []any{v41}) -v43 := lang.Apply(v12, []any{v16, v42, v6}) -v44 := lang.Apply(v9, []any{v43}) -return v44 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// libspec? -{ -v0 := lang.NewSymbol("libspec?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is a libspec", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5848), lang.NewKeyword("end-line"), int(5848), lang.NewKeyword("private"), true)).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("symbol?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -var v4 any = v8 -_ = v4 -var v10 any -if lang.IsTruthy(v4) { -v10 = v4 -} else { -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("vector?")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v3}) -var v11 any = v15 -_ = v11 -var v17 any -if lang.IsTruthy(v11) { -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("nil?")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("second")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v26 := lang.Apply(v21, []any{v25}) -var v18 any = v26 -_ = v18 -var v28 any -if lang.IsTruthy(v18) { -v28 = v18 -} else { -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("keyword?")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("second")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.Apply(v31, []any{v35}) -v28 = v36 -} -v17 = v28 -} else { -v17 = v11 -} -v10 = v17 -} -return v10 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// lift-ns -{ -v0 := lang.NewSymbol("lift-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"))), lang.NewKeyword("doc"), "Returns [lifted-ns lifted-kvs] or nil if m can't be lifted.", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(261), lang.NewKeyword("end-line"), int(261), lang.NewKeyword("private"), true)).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("*print-namespace-maps*")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -if lang.IsTruthy(v7) { -var v8 any = nil -_ = v8 -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("seq")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{v3}) -var v9 any = v13 -_ = v9 -var v14 any = v9 -_ = v14 -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("seq")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v14}) -var v15 any = v19 -_ = v15 -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("first")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v15}) -var v20 any = v24 -_ = v20 -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("next")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.Apply(v28, []any{v25}) -var v25 any = v29 -_ = v25 -var v30 any = v20 -_ = v30 -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("nth")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v30, int64(0), nil}) -var v31 any = v35 -_ = v31 -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("nth")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v30, int64(1), nil}) -var v36 any = v40 -_ = v36 -var v41 any = v30 -_ = v41 -var v42 any = v25 -_ = v42 -v44 := lang.NewVector() -v45 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(267), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(267), lang.NewKeyword("end-column"), int(17)) -v46, err := lang.WithMeta(v44, v45.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v43 any = v46 -_ = v43 -var v48 any = v48 -_ = v48 -var v49 any = v49 -_ = v49 -var v50 any = v50 -_ = v50 -var v51 any -for { -var v52 any = v52 -_ = v52 -var v53 any = v49 -_ = v53 -v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v56 := v55.FindInternedVar(lang.NewSymbol("seq")) -if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) -} -v57 := v56.Get() -v58 := lang.Apply(v57, []any{v53}) -var v54 any = v58 -_ = v54 -v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v61 := v60.FindInternedVar(lang.NewSymbol("first")) -if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) -} -v62 := v61.Get() -v63 := lang.Apply(v62, []any{v54}) -var v59 any = v63 -_ = v59 -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("next")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) -} -v67 := v66.Get() -v68 := lang.Apply(v67, []any{v64}) -var v64 any = v68 -_ = v64 -var v69 any = v59 -_ = v69 -v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v72 := v71.FindInternedVar(lang.NewSymbol("nth")) -if v72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) -} -v73 := v72.Get() -v74 := lang.Apply(v73, []any{v69, int64(0), nil}) -var v70 any = v74 -_ = v70 -v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v77 := v76.FindInternedVar(lang.NewSymbol("nth")) -if v77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) -} -v78 := v77.Get() -v79 := lang.Apply(v78, []any{v69, int64(1), nil}) -var v75 any = v79 -_ = v75 -var v80 any = v69 -_ = v80 -var v81 any = v64 -_ = v81 -var v82 any = v82 -_ = v82 -var v84 any -if lang.IsTruthy(v80) { -var v85 any -v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v87 := v86.FindInternedVar(lang.NewSymbol("qualified-ident?")) -if v87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) -} -v88 := v87.Get() -v89 := lang.Apply(v88, []any{v70}) -if lang.IsTruthy(v89) { -var v90 any -if lang.IsTruthy(v52) { -var v91 any -v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v93 := v92.FindInternedVar(lang.NewSymbol("=")) -if v93.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) -} -v94 := v93.Get() -v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v96 := v95.FindInternedVar(lang.NewSymbol("namespace")) -if v96.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) -} -v97 := v96.Get() -v98 := lang.Apply(v97, []any{v70}) -v99 := lang.Apply(v94, []any{v52, v98}) -if lang.IsTruthy(v99) { -var v100 any = v52 -var v101 any = v81 -v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v104 := v103.FindInternedVar(lang.NewSymbol("conj")) -if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) -} -v105 := v104.Get() -v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v107 := v106.FindInternedVar(lang.NewSymbol("strip-ns")) -if v107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) -} -v108 := v107.Get() -v109 := lang.Apply(v108, []any{v70}) -v110 := lang.NewVector(v109, v75) -v111 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(272), lang.NewKeyword("column"), int(43), lang.NewKeyword("end-line"), int(272), lang.NewKeyword("end-column"), int(58)) -v112, err := lang.WithMeta(v110, v111.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v113 := lang.Apply(v105, []any{v82, v112}) -var v102 any = v113 -v48 = v100 -v49 = v101 -v50 = v102 -continue -} else { -v91 = nil -} -v90 = v91 -} else { -v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v116 := v115.FindInternedVar(lang.NewSymbol("namespace")) -if v116.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) -} -v117 := v116.Get() -v118 := lang.Apply(v117, []any{v70}) -var v114 any = v118 -_ = v114 -var v120 any -if lang.IsTruthy(v114) { -var v121 any = v114 -_ = v121 -var v123 any = v121 -var v124 any = v81 -v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v127 := v126.FindInternedVar(lang.NewSymbol("conj")) -if v127.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) -} -v128 := v127.Get() -v129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v130 := v129.FindInternedVar(lang.NewSymbol("strip-ns")) -if v130.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v130))) -} -v131 := v130.Get() -v132 := lang.Apply(v131, []any{v70}) -v133 := lang.NewVector(v132, v75) -v134 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(274), lang.NewKeyword("column"), int(47), lang.NewKeyword("end-line"), int(274), lang.NewKeyword("end-column"), int(62)) -v135, err := lang.WithMeta(v133, v134.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v136 := lang.Apply(v128, []any{v82, v135}) -var v125 any = v136 -v48 = v123 -v49 = v124 -v50 = v125 -continue -} else { -v120 = nil -} -v90 = v120 -} -v85 = v90 -} else { -v85 = nil -} -v84 = v85 -} else { -v114 := lang.NewVector(v52, v82) -v115 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(275), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(275), lang.NewKeyword("end-column"), int(16)) -v116, err := lang.WithMeta(v114, v115.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v84 = v116 -} -v51 = v84 - break -} -v4 = v51 -} else { -v4 = nil -} -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// line-seq -{ -v0 := lang.NewSymbol("line-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rdr"))), lang.NewKeyword("doc"), "Returns the lines of text from rdr as a lazy sequence of strings.\n rdr must implement java.io.BufferedReader.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3068), lang.NewKeyword("end-line"), int(3068))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v5, ok := lang.FieldOrMethod(v3, "readLine") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "readLine"))) -} -var v6 any -switch reflect.TypeOf(v5).Kind() { -case reflect.Func: - v6 = lang.Apply(v5, nil) -default: - v6 = v5 -} -var v4 any = v6 -_ = v4 -var v8 any -if lang.IsTruthy(v4) { -var v9 any = v4 -_ = v9 -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("cons")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -var v14 lang.FnFunc -v14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("line-seq")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v3}) -return v18 -}) -v15 := lang.Apply(lang.NewLazySeq, []any{v14}) -v16 := lang.Apply(v13, []any{v9, v15}) -v8 = v16 -} else { -v8 = nil -} -return v8 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// list -{ -v0 := lang.NewSymbol("list").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("items"))), lang.NewKeyword("doc"), "Creates a new list containing the items.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(15), lang.NewKeyword("end-line"), int(18))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, nil, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// list* -{ -v0 := lang.NewSymbol("list*").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Creates a new seq containing the items prepended to the rest, the\n last of which will be treated as a sequence.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(641), lang.NewKeyword("end-line"), int(641))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{v3}) -return v7 - case 2: -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("cons")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3, v4}) -return v8 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("cons")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("cons")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v4, v5}) -v13 := lang.Apply(v8, []any{v3, v12}) -return v13 - case 4: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("cons")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("cons")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("cons")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v5, v6}) -v17 := lang.Apply(v12, []any{v4, v16}) -v18 := lang.Apply(v9, []any{v3, v17}) -return v18 - default: - if len(args) < 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := lang.NewList(args[4:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("cons")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("cons")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("cons")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("cons")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("spread")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.Apply(v22, []any{v7}) -v24 := lang.Apply(v19, []any{v6, v23}) -v25 := lang.Apply(v16, []any{v5, v24}) -v26 := lang.Apply(v13, []any{v4, v25}) -v27 := lang.Apply(v10, []any{v3, v26}) -return v27 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// list? -{ -v0 := lang.NewSymbol("list?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements IPersistentList", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6198), lang.NewKeyword("end-line"), int(6198))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{lang.IPersistentList, v3}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// load -{ -v0 := lang.NewSymbol("load").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("paths"))), lang.NewKeyword("doc"), "Loads Clojure code from resources in classpath. A path is interpreted as\n classpath-relative if it begins with a slash or relative to the root\n directory for the current namespace otherwise.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("redef"), true, lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6095), lang.NewKeyword("end-line"), int(6095))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewList(args[0:]...) -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -var v4 any = v8 -_ = v4 -var v9 any = nil -_ = v9 -var v10 any = int64(0) -_ = v10 -var v11 any = int64(0) -_ = v11 -var v12 any -for { -var v13 any -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("<")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v11, v10}) -if lang.IsTruthy(v17) { -v19, _ := lang.FieldOrMethod(v9, "nth") -if reflect.TypeOf(v19).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) -} -v20 := lang.Apply(v19, []any{v11}) -var v18 any = v20 -_ = v18 -var v23 any -v24 := lang.Apply(strings11.HasPrefix, []any{v22, "/"}) -if lang.IsTruthy(v24) { -v23 = v22 -} else { -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("str")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("root-directory")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("ns-name")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("*ns*")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.Apply(v33, []any{v36}) -v38 := lang.Apply(v30, []any{v37}) -v39 := lang.Apply(v27, []any{v38, lang.NewChar(47), v22}) -v23 = v39 -} -var v22 any = v23 -_ = v22 -var v41 any -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) -} -v44 := v43.Get() -if lang.IsTruthy(v44) { -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("printf")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.Apply(v47, []any{"(glojure.core/load \"%s\")\n", v22}) -_ = v48 -v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v50 := v49.FindInternedVar(lang.NewSymbol("flush")) -if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) -} -v51 := v50.Get() -v52 := lang.Apply(v51, nil) -v41 = v52 -} else { -v41 = nil -} -_ = v41 -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("check-cyclic-dependency")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) -} -v55 := v54.Get() -v56 := lang.Apply(v55, []any{v22}) -_ = v56 -var v57 any -v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v59 := v58.FindInternedVar(lang.NewSymbol("=")) -if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) -} -v60 := v59.Get() -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("first")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) -} -v63 := v62.Get() -v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v65 := v64.FindInternedVar(lang.NewSymbol("*pending-paths*")) -if v65.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) -} -v66 := v65.Get() -v67 := lang.Apply(v63, []any{v66}) -v68 := lang.Apply(v60, []any{v22, v67}) -if lang.IsTruthy(v68) { -v57 = nil -} else { -v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v71 := v70.FindInternedVar(lang.NewSymbol("push-thread-bindings")) -if v71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) -} -v72 := v71.Get() -v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v74 := v73.FindInternedVar(lang.NewSymbol("hash-map")) -if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) -} -v75 := v74.Get() -v76 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*pending-paths*")) -v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v78 := v77.FindInternedVar(lang.NewSymbol("conj")) -if v78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) -} -v79 := v78.Get() -v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v81 := v80.FindInternedVar(lang.NewSymbol("*pending-paths*")) -if v81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) -} -v82 := v81.Get() -v83 := lang.Apply(v79, []any{v82, v22}) -v84 := lang.Apply(v75, []any{v76, v83}) -v85 := lang.Apply(v72, []any{v84}) -_ = v85 -var v86 any -func() { -defer func() { -v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v88 := v87.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) -if v88.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) -} -v89 := v88.Get() -v90 := lang.Apply(v89, nil) -}() -v91 := lang.Apply(strings11.TrimPrefix, []any{v22, "/"}) -v92, _ := lang.FieldOrMethod(runtime5.RT, "Load") -if reflect.TypeOf(v92).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Load is not a function"))) -} -v93 := lang.Apply(v92, []any{v91}) -v86 = v93 -}() -v57 = v86 -} -_ = v57 -var v22 any = v4 -var v23 any = v9 -var v24 any = v10 -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("unchecked-inc")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.Apply(v28, []any{v11}) -var v25 any = v29 -v4 = v22 -v9 = v23 -v10 = v24 -v11 = v25 -continue -} else { -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("seq")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v4}) -var v18 any = v22 -_ = v18 -var v24 any -if lang.IsTruthy(v18) { -var v25 any = v18 -_ = v25 -var v27 any -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("chunked-seq?")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{v25}) -if lang.IsTruthy(v31) { -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("chunk-first")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v25}) -var v32 any = v36 -_ = v32 -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("chunk-rest")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) -} -v41 := v40.Get() -v42 := lang.Apply(v41, []any{v25}) -var v38 any = v42 -var v43 any = v32 -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("int")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("count")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v32}) -v52 := lang.Apply(v47, []any{v51}) -var v44 any = v52 -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("int")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) -} -v56 := v55.Get() -v57 := lang.Apply(v56, []any{int64(0)}) -var v53 any = v57 -v4 = v38 -v9 = v43 -v10 = v44 -v11 = v53 -continue -} else { -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("first")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v25}) -var v32 any = v36 -_ = v32 -var v39 any -v40 := lang.Apply(strings11.HasPrefix, []any{v38, "/"}) -if lang.IsTruthy(v40) { -v39 = v38 -} else { -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("str")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("root-directory")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("ns-name")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) -} -v49 := v48.Get() -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("*ns*")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.Apply(v49, []any{v52}) -v54 := lang.Apply(v46, []any{v53}) -v55 := lang.Apply(v43, []any{v54, lang.NewChar(47), v38}) -v39 = v55 -} -var v38 any = v39 -_ = v38 -var v57 any -v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v59 := v58.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) -if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) -} -v60 := v59.Get() -if lang.IsTruthy(v60) { -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("printf")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) -} -v63 := v62.Get() -v64 := lang.Apply(v63, []any{"(glojure.core/load \"%s\")\n", v38}) -_ = v64 -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("flush")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) -} -v67 := v66.Get() -v68 := lang.Apply(v67, nil) -v57 = v68 -} else { -v57 = nil -} -_ = v57 -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("check-cyclic-dependency")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) -} -v71 := v70.Get() -v72 := lang.Apply(v71, []any{v38}) -_ = v72 -var v73 any -v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v75 := v74.FindInternedVar(lang.NewSymbol("=")) -if v75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) -} -v76 := v75.Get() -v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v78 := v77.FindInternedVar(lang.NewSymbol("first")) -if v78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) -} -v79 := v78.Get() -v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v81 := v80.FindInternedVar(lang.NewSymbol("*pending-paths*")) -if v81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) -} -v82 := v81.Get() -v83 := lang.Apply(v79, []any{v82}) -v84 := lang.Apply(v76, []any{v38, v83}) -if lang.IsTruthy(v84) { -v73 = nil -} else { -v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v87 := v86.FindInternedVar(lang.NewSymbol("push-thread-bindings")) -if v87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) -} -v88 := v87.Get() -v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v90 := v89.FindInternedVar(lang.NewSymbol("hash-map")) -if v90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) -} -v91 := v90.Get() -v92 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*pending-paths*")) -v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v94 := v93.FindInternedVar(lang.NewSymbol("conj")) -if v94.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) -} -v95 := v94.Get() -v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v97 := v96.FindInternedVar(lang.NewSymbol("*pending-paths*")) -if v97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) -} -v98 := v97.Get() -v99 := lang.Apply(v95, []any{v98, v38}) -v100 := lang.Apply(v91, []any{v92, v99}) -v101 := lang.Apply(v88, []any{v100}) -_ = v101 -var v102 any -func() { -defer func() { -v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v104 := v103.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) -if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) -} -v105 := v104.Get() -v106 := lang.Apply(v105, nil) -}() -v107 := lang.Apply(strings11.TrimPrefix, []any{v38, "/"}) -v108, _ := lang.FieldOrMethod(runtime5.RT, "Load") -if reflect.TypeOf(v108).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Load is not a function"))) -} -v109 := lang.Apply(v108, []any{v107}) -v102 = v109 -}() -v73 = v102 -} -_ = v73 -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("next")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) -} -v41 := v40.Get() -v42 := lang.Apply(v41, []any{v25}) -var v38 any = v42 -var v43 any = nil -var v44 any = int64(0) -var v45 any = int64(0) -v4 = v38 -v9 = v43 -v10 = v44 -v11 = v45 -continue -} -v24 = v27 -} else { -v24 = nil -} -v13 = v24 -} -v12 = v13 - break -} -return v12 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// load-all -{ -v0 := lang.NewSymbol("load-all").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"), lang.NewSymbol("need-ns"), lang.NewSymbol("require"))), lang.NewKeyword("doc"), "Loads a lib given its name and forces a load of any libs it directly or\n indirectly loads. If need-ns, ensures that the associated namespace\n exists after loading. If require, records the load so any duplicate loads\n can be skipped.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5892), lang.NewKeyword("end-line"), int(5892), lang.NewKeyword("private"), true)).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -var v6 lang.FnFunc -v6 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("commute")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("*loaded-libs*")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -var v13 lang.FnFunc -v13 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v14 := args[0] -v15 := args[1] -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("reduce1")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("conj")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v18, []any{v21, v14, v15}) -return v22 -}) -v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5899), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(5899), lang.NewKeyword("end-column"), int(47)) -v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("push-thread-bindings")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("hash-map")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*loaded-libs*")) -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("ref")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("sorted-set")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, nil) -v31 := lang.Apply(v26, []any{v30}) -v32 := lang.Apply(v22, []any{v23, v31}) -v33 := lang.Apply(v19, []any{v32}) -_ = v33 -var v34 any -func() { -defer func() { -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.Apply(v37, nil) -}() -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("load-one")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) -} -v41 := v40.Get() -v42 := lang.Apply(v41, []any{v3, v4, v5}) -_ = v42 -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("deref")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("*loaded-libs*")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) -} -v48 := v47.Get() -v49 := lang.Apply(v45, []any{v48}) -v34 = v49 -}() -v16 := lang.Apply(v9, []any{v12, v15, v34}) -return v16 -}) -v7, _ := lang.FieldOrMethod(lang.LockingTransaction, "RunInTransaction") -if reflect.TypeOf(v7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("RunInTransaction is not a function"))) -} -v8 := lang.Apply(v7, []any{v6}) -return v8 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// load-data-reader-file -{ -v0 := lang.NewSymbol("load-data-reader-file").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7836), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7836), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("mappings"), lang.NewSymbol("url"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v6, ok := lang.FieldOrMethod(v4, "openStream") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "openStream"))) -} -var v7 any -switch reflect.TypeOf(v6).Kind() { -case reflect.Func: - v7 = lang.Apply(v6, nil) -default: - v7 = v6 -} -v8 := lang.Apply(java.io.InputStreamReader13., []any{v7, "UTF-8"}) -v9 := lang.Apply(glojure.lang.LineNumberingPushbackReader12., []any{v8}) -var v5 any = v9 -_ = v5 -var v11 any -func() { -defer func() { -v12, ok := lang.FieldOrMethod(v5, "close") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "close"))) -} -var v13 any -switch reflect.TypeOf(v12).Kind() { -case reflect.Func: - v13 = lang.Apply(v12, nil) -default: - v13 = v12 -} -}() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("push-thread-bindings")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("hash-map")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*file*")) -v22, ok := lang.FieldOrMethod(v4, "getFile") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "getFile"))) -} -var v23 any -switch reflect.TypeOf(v22).Kind() { -case reflect.Func: - v23 = lang.Apply(v22, nil) -default: - v23 = v22 -} -v24 := lang.Apply(v20, []any{v21, v23}) -v25 := lang.Apply(v17, []any{v24}) -_ = v25 -var v26 any -func() { -defer func() { -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, nil) -}() -var v32 any -v33, ok := lang.FieldOrMethod(v4, "getPath") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "getPath"))) -} -var v34 any -switch reflect.TypeOf(v33).Kind() { -case reflect.Func: - v34 = lang.Apply(v33, nil) -default: - v34 = v33 -} -v35, _ := lang.FieldOrMethod(v34, "endsWith") -if reflect.TypeOf(v35).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("endsWith is not a function"))) -} -v36 := lang.Apply(v35, []any{"cljc"}) -if lang.IsTruthy(v36) { -v37 := lang.NewMap(lang.NewKeyword("eof"), nil, lang.NewKeyword("read-cond"), lang.NewKeyword("allow")) -v38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7842), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7842), lang.NewKeyword("end-column"), int(52)) -v39, err := lang.WithMeta(v37, v38.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v32 = v39 -} else { -v40 := lang.NewMap(lang.NewKeyword("eof"), nil) -v41 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7843), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7843), lang.NewKeyword("end-column"), int(34)) -v42, err := lang.WithMeta(v40, v41.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v32 = v42 -} -var v31 any = v32 -_ = v31 -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("read")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v31, v5}) -var v43 any = v47 -_ = v43 -var v49 any -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("not")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("map?")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) -} -v55 := v54.Get() -v56 := lang.Apply(v55, []any{v43}) -v57 := lang.Apply(v52, []any{v56}) -if lang.IsTruthy(v57) { -v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v59 := v58.FindInternedVar(lang.NewSymbol("ex-info")) -if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) -} -v60 := v59.Get() -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("str")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) -} -v63 := v62.Get() -v64 := lang.Apply(v63, []any{"Not a valid data-reader map"}) -v65 := lang.NewMap(lang.NewKeyword("url"), v4) -v66 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7847), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(7847), lang.NewKeyword("end-column"), int(36)) -v67, err := lang.WithMeta(v65, v66.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v68 := lang.Apply(v60, []any{v64, v67}) -panic(v68) -} else { -v49 = nil -} -_ = v49 -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("reduce")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) -} -v71 := v70.Get() -var v72 lang.FnFunc -v72 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v73 := args[0] -v74 := args[1] -var v75 any = v74 -_ = v75 -v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v78 := v77.FindInternedVar(lang.NewSymbol("nth")) -if v78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) -} -v79 := v78.Get() -v80 := lang.Apply(v79, []any{v75, int64(0), nil}) -var v76 any = v80 -_ = v76 -v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v83 := v82.FindInternedVar(lang.NewSymbol("nth")) -if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) -} -v84 := v83.Get() -v85 := lang.Apply(v84, []any{v75, int64(1), nil}) -var v81 any = v85 -_ = v81 -var v87 any -v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v89 := v88.FindInternedVar(lang.NewSymbol("not")) -if v89.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) -} -v90 := v89.Get() -v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v92 := v91.FindInternedVar(lang.NewSymbol("symbol?")) -if v92.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) -} -v93 := v92.Get() -v94 := lang.Apply(v93, []any{v76}) -v95 := lang.Apply(v90, []any{v94}) -if lang.IsTruthy(v95) { -v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v97 := v96.FindInternedVar(lang.NewSymbol("ex-info")) -if v97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) -} -v98 := v97.Get() -v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v100 := v99.FindInternedVar(lang.NewSymbol("str")) -if v100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) -} -v101 := v100.Get() -v102 := lang.Apply(v101, []any{"Invalid form in data-reader file"}) -v103 := lang.NewMap(lang.NewKeyword("url"), v4, lang.NewKeyword("form"), v76) -v104 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7852), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(7853), lang.NewKeyword("end-column"), int(38)) -v105, err := lang.WithMeta(v103, v104.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v106 := lang.Apply(v98, []any{v102, v105}) -panic(v106) -} else { -v87 = nil -} -_ = v87 -v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v109 := v108.FindInternedVar(lang.NewSymbol("data-reader-var")) -if v109.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) -} -v110 := v109.Get() -v111 := lang.Apply(v110, []any{v81}) -var v107 any = v111 -_ = v107 -var v113 any -v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v116 := v115.FindInternedVar(lang.NewSymbol("contains?")) -if v116.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) -} -v117 := v116.Get() -v118 := lang.Apply(v117, []any{v3, v76}) -var v114 any = v118 -_ = v114 -var v120 any -if lang.IsTruthy(v114) { -v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v122 := v121.FindInternedVar(lang.NewSymbol("not=")) -if v122.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) -} -v123 := v122.Get() -v124 := lang.Apply(v3, []any{v76}) -v125 := lang.Apply(v123, []any{v124, v107}) -v120 = v125 -} else { -v120 = v114 -} -if lang.IsTruthy(v120) { -v114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v115 := v114.FindInternedVar(lang.NewSymbol("ex-info")) -if v115.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v115))) -} -v116 := v115.Get() -v117 := lang.NewMap(lang.NewKeyword("url"), v4, lang.NewKeyword("conflict"), v76, lang.NewKeyword("mappings"), v73) -v118 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7858), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(7860), lang.NewKeyword("end-column"), int(44)) -v119, err := lang.WithMeta(v117, v118.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v120 := lang.Apply(v116, []any{"Conflicting data-reader mapping", v119}) -panic(v120) -} else { -v113 = nil -} -_ = v113 -v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v122 := v121.FindInternedVar(lang.NewSymbol("assoc")) -if v122.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) -} -v123 := v122.Get() -v124 := lang.Apply(v123, []any{v73, v76, v107}) -return v124 -}) -v73 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7849), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(7861), lang.NewKeyword("end-column"), int(32)) -v74, err := lang.WithMeta(v72, v73.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v75 := lang.Apply(v71, []any{v74, v3, v43}) -v26 = v75 -}() -v11 = v26 -}() -return v11 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// load-data-readers -{ -v0 := lang.NewSymbol("load-data-readers").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7865), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7865), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v4 := v3.FindInternedVar(lang.NewSymbol("alter-var-root")) -if v4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) -} -v5 := v4.Get() -v6 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*data-readers*")) -var v7 lang.FnFunc -v7 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v8 := args[0] -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("reduce")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("load-data-reader-file")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("data-reader-urls")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, nil) -v19 := lang.Apply(v11, []any{v14, v8, v18}) -return v19 -}) -v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7867), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(7869), lang.NewKeyword("end-column"), int(57)) -v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v10 := lang.Apply(v5, []any{v6, v9}) -return v10 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// load-file -{ -v0 := lang.NewSymbol("load-file").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, nil, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// load-lib -{ -v0 := lang.NewSymbol("load-lib").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("prefix"), lang.NewSymbol("lib"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Loads a lib with options", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5904), lang.NewKeyword("end-line"), int(5904), lang.NewKeyword("private"), true)).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("throw-if")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -var v9 any = v3 -_ = v9 -var v11 any -if lang.IsTruthy(v9) { -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("pos?")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("name")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v4}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("int")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{lang.NewChar(46)}) -v23 := lang.Apply(strings11.Index, []any{v18, v22}) -v24 := lang.Apply(v14, []any{v23}) -v11 = v24 -} else { -v11 = v9 -} -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("name")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v4}) -v13 := lang.Apply(v8, []any{v11, "Found lib name '%s' containing period with prefix '%s'. lib names inside prefix lists must not contain periods", v12, v3}) -_ = v13 -var v15 any -if lang.IsTruthy(v3) { -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("symbol")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("str")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v3, lang.NewChar(46), v14}) -v23 := lang.Apply(v18, []any{v22}) -v15 = v23 -} else { -v15 = v14 -} -var v14 any = v15 -_ = v14 -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("apply")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("hash-map")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v27, []any{v30, v5}) -var v24 any = v31 -_ = v24 -var v32 any = v24 -_ = v32 -var v34 any -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("seq?")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v33}) -if lang.IsTruthy(v38) { -var v39 any -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("next")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v33}) -if lang.IsTruthy(v43) { -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("to-array")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v33}) -v48 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{v47}) -v39 = v48 -} else { -var v49 any -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("seq")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.Apply(v52, []any{v33}) -if lang.IsTruthy(v53) { -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("first")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) -} -v56 := v55.Get() -v57 := lang.Apply(v56, []any{v33}) -v49 = v57 -} else { -v49 = nil -} -v39 = v49 -} -v34 = v39 -} else { -v34 = v33 -} -var v33 any = v34 -_ = v33 -v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v60 := v59.FindInternedVar(lang.NewSymbol("get")) -if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) -} -v61 := v60.Get() -v62 := lang.Apply(v61, []any{v33, lang.NewKeyword("as")}) -var v58 any = v62 -_ = v58 -v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v65 := v64.FindInternedVar(lang.NewSymbol("get")) -if v65.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) -} -v66 := v65.Get() -v67 := lang.Apply(v66, []any{v33, lang.NewKeyword("reload")}) -var v63 any = v67 -_ = v63 -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("get")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) -} -v71 := v70.Get() -v72 := lang.Apply(v71, []any{v33, lang.NewKeyword("reload-all")}) -var v68 any = v72 -_ = v68 -v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v75 := v74.FindInternedVar(lang.NewSymbol("get")) -if v75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) -} -v76 := v75.Get() -v77 := lang.Apply(v76, []any{v33, lang.NewKeyword("require")}) -var v73 any = v77 -_ = v73 -v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v80 := v79.FindInternedVar(lang.NewSymbol("get")) -if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) -} -v81 := v80.Get() -v82 := lang.Apply(v81, []any{v33, lang.NewKeyword("use")}) -var v78 any = v82 -_ = v78 -v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v85 := v84.FindInternedVar(lang.NewSymbol("get")) -if v85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) -} -v86 := v85.Get() -v87 := lang.Apply(v86, []any{v33, lang.NewKeyword("verbose")}) -var v83 any = v87 -_ = v83 -v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v90 := v89.FindInternedVar(lang.NewSymbol("get")) -if v90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) -} -v91 := v90.Get() -v92 := lang.Apply(v91, []any{v33, lang.NewKeyword("as-alias")}) -var v88 any = v92 -_ = v88 -v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v95 := v94.FindInternedVar(lang.NewSymbol("contains?")) -if v95.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) -} -v96 := v95.Get() -v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v98 := v97.FindInternedVar(lang.NewSymbol("deref")) -if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) -} -v99 := v98.Get() -v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v101 := v100.FindInternedVar(lang.NewSymbol("*loaded-libs*")) -if v101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) -} -v102 := v101.Get() -v103 := lang.Apply(v99, []any{v102}) -v104 := lang.Apply(v96, []any{v103, v14}) -var v93 any = v104 -_ = v93 -var v106 any = v58 -_ = v106 -var v108 any -if lang.IsTruthy(v106) { -v108 = v106 -} else { -v108 = v78 -} -var v105 any = v108 -_ = v105 -var v107 any -if lang.IsTruthy(v68) { -v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v109 := v108.FindInternedVar(lang.NewSymbol("load-all")) -if v109.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) -} -v110 := v109.Get() -v107 = v110 -} else { -var v111 any -if lang.IsTruthy(v63) { -v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v113 := v112.FindInternedVar(lang.NewSymbol("load-one")) -if v113.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) -} -v114 := v113.Get() -v111 = v114 -} else { -var v115 any -v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v117 := v116.FindInternedVar(lang.NewSymbol("not")) -if v117.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) -} -v118 := v117.Get() -v119 := lang.Apply(v118, []any{v93}) -if lang.IsTruthy(v119) { -var v120 any -if lang.IsTruthy(v105) { -v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v122 := v121.FindInternedVar(lang.NewSymbol("load-one")) -if v122.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) -} -v123 := v122.Get() -v120 = v123 -} else { -var v124 any -if lang.IsTruthy(v88) { -var v125 lang.FnFunc -v125 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v126 := args[0] -v127 := args[1] -v128 := args[2] -v129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v130 := v129.FindInternedVar(lang.NewSymbol("create-ns")) -if v130.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v130))) -} -v131 := v130.Get() -v132 := lang.Apply(v131, []any{v126}) -return v132 -}) -v126 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5918), lang.NewKeyword("column"), int(48), lang.NewKeyword("end-line"), int(5918), lang.NewKeyword("end-column"), int(88)) -v127, err := lang.WithMeta(v125, v126.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v124 = v127 -} else { -var v128 any -if lang.IsTruthy(lang.NewKeyword("else")) { -v129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v130 := v129.FindInternedVar(lang.NewSymbol("load-one")) -if v130.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v130))) -} -v131 := v130.Get() -v128 = v131 -} else { -v128 = nil -} -v124 = v128 -} -v120 = v124 -} -v115 = v120 -} else { -v115 = nil -} -v111 = v115 -} -v107 = v111 -} -var v106 any = v107 -_ = v106 -v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v134 := v133.FindInternedVar(lang.NewSymbol("select-keys")) -if v134.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) -} -v135 := v134.Get() -v136 := lang.Apply(v135, []any{v24, lang.NewList(lang.NewKeyword("exclude"), lang.NewKeyword("only"), lang.NewKeyword("rename"), lang.NewKeyword("refer"))}) -var v132 any = v136 -_ = v132 -v138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v139 := v138.FindInternedVar(lang.NewSymbol("not")) -if v139.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v139))) -} -v140 := v139.Get() -v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v142 := v141.FindInternedVar(lang.NewSymbol("find-ns")) -if v142.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) -} -v143 := v142.Get() -v144 := lang.Apply(v143, []any{v14}) -v145 := lang.Apply(v140, []any{v144}) -var v137 any = v145 -_ = v137 -v148 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v149 := v148.FindInternedVar(lang.NewSymbol("push-thread-bindings")) -if v149.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v149))) -} -v150 := v149.Get() -v151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v152 := v151.FindInternedVar(lang.NewSymbol("hash-map")) -if v152.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v152))) -} -v153 := v152.Get() -v154 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*loading-verbosely*")) -v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v157 := v156.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) -if v157.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) -} -v158 := v157.Get() -var v155 any = v158 -_ = v155 -var v160 any -if lang.IsTruthy(v155) { -v160 = v155 -} else { -v160 = v83 -} -v155 := lang.Apply(v153, []any{v154, v160}) -v156 := lang.Apply(v150, []any{v155}) -_ = v156 -var v157 any -func() { -defer func() { -v158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v159 := v158.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) -if v159.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v159))) -} -v160 := v159.Get() -v161 := lang.Apply(v160, nil) -}() -var v162 any -if lang.IsTruthy(v106) { -var v163 any -func() { -defer func() { -if r := recover(); r != nil { -if lang.CatchMatches(r, lang.Builtins["any"]) { -v164 := r -_ = v164 -var v165 any -if lang.IsTruthy(v137) { -v166 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v167 := v166.FindInternedVar(lang.NewSymbol("remove-ns")) -if v167.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v167))) -} -v168 := v167.Get() -v169 := lang.Apply(v168, []any{v14}) -v165 = v169 -} else { -v165 = nil -} -_ = v165 -panic(v164) -} else { -panic(r) -} -} -}() -v164 := lang.Apply(v106, []any{v14, v105, v73}) -v163 = v164 -}() -v162 = v163 -} else { -v165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v166 := v165.FindInternedVar(lang.NewSymbol("throw-if")) -if v166.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v166))) -} -v167 := v166.Get() -var v168 any = v105 -_ = v168 -var v170 any -if lang.IsTruthy(v168) { -v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v172 := v171.FindInternedVar(lang.NewSymbol("not")) -if v172.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) -} -v173 := v172.Get() -v174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v175 := v174.FindInternedVar(lang.NewSymbol("find-ns")) -if v175.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v175))) -} -v176 := v175.Get() -v177 := lang.Apply(v176, []any{v14}) -v178 := lang.Apply(v173, []any{v177}) -v170 = v178 -} else { -v170 = v168 -} -v168 := lang.Apply(v167, []any{v170, "namespace '%s' not found", v14}) -v162 = v168 -} -_ = v162 -var v169 any -var v170 any = v105 -_ = v170 -var v172 any -if lang.IsTruthy(v170) { -v173 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v174 := v173.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) -if v174.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v174))) -} -v175 := v174.Get() -v172 = v175 -} else { -v172 = v170 -} -if lang.IsTruthy(v172) { -v170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v171 := v170.FindInternedVar(lang.NewSymbol("printf")) -if v171.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v171))) -} -v172 := v171.Get() -v173 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v174 := v173.FindInternedVar(lang.NewSymbol("ns-name")) -if v174.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v174))) -} -v175 := v174.Get() -v176 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v177 := v176.FindInternedVar(lang.NewSymbol("*ns*")) -if v177.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v177))) -} -v178 := v177.Get() -v179 := lang.Apply(v175, []any{v178}) -v180 := lang.Apply(v172, []any{"(glojure.core/in-ns '%s)\n", v179}) -v169 = v180 -} else { -v169 = nil -} -_ = v169 -var v181 any -if lang.IsTruthy(v58) { -var v182 any -v183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v184 := v183.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) -if v184.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v184))) -} -v185 := v184.Get() -if lang.IsTruthy(v185) { -v186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v187 := v186.FindInternedVar(lang.NewSymbol("printf")) -if v187.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v187))) -} -v188 := v187.Get() -v189 := lang.Apply(v188, []any{"(glojure.core/alias '%s '%s)\n", v58, v14}) -v182 = v189 -} else { -v182 = nil -} -_ = v182 -v190 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v191 := v190.FindInternedVar(lang.NewSymbol("alias")) -if v191.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v191))) -} -v192 := v191.Get() -v193 := lang.Apply(v192, []any{v58, v14}) -v181 = v193 -} else { -v181 = nil -} -_ = v181 -var v194 any -if lang.IsTruthy(v88) { -var v195 any -v196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v197 := v196.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) -if v197.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v197))) -} -v198 := v197.Get() -if lang.IsTruthy(v198) { -v199 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v200 := v199.FindInternedVar(lang.NewSymbol("printf")) -if v200.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v200))) -} -v201 := v200.Get() -v202 := lang.Apply(v201, []any{"(glojure.core/alias '%s '%s)\n", v88, v14}) -v195 = v202 -} else { -v195 = nil -} -_ = v195 -v203 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v204 := v203.FindInternedVar(lang.NewSymbol("alias")) -if v204.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v204))) -} -v205 := v204.Get() -v206 := lang.Apply(v205, []any{v88, v14}) -v194 = v206 -} else { -v194 = nil -} -_ = v194 -var v207 any -var v208 any = v78 -_ = v208 -var v210 any -if lang.IsTruthy(v208) { -v210 = v208 -} else { -v211 := lang.Apply(lang.NewKeyword("refer"), []any{v132}) -v210 = v211 -} -if lang.IsTruthy(v210) { -var v208 any -v209 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v210 := v209.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) -if v210.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v210))) -} -v211 := v210.Get() -if lang.IsTruthy(v211) { -v212 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v213 := v212.FindInternedVar(lang.NewSymbol("printf")) -if v213.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v213))) -} -v214 := v213.Get() -v215 := lang.Apply(v214, []any{"(glojure.core/refer '%s", v14}) -_ = v215 -v217 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v218 := v217.FindInternedVar(lang.NewSymbol("seq")) -if v218.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v218))) -} -v219 := v218.Get() -v220 := lang.Apply(v219, []any{v132}) -var v216 any = v220 -_ = v216 -var v221 any = nil -_ = v221 -var v222 any = int64(0) -_ = v222 -var v223 any = int64(0) -_ = v223 -var v224 any -for { -var v225 any -v226 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v227 := v226.FindInternedVar(lang.NewSymbol("<")) -if v227.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v227))) -} -v228 := v227.Get() -v229 := lang.Apply(v228, []any{v223, v222}) -if lang.IsTruthy(v229) { -v231, _ := lang.FieldOrMethod(v221, "nth") -if reflect.TypeOf(v231).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) -} -v232 := lang.Apply(v231, []any{v223}) -var v230 any = v232 -_ = v230 -v234 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v235 := v234.FindInternedVar(lang.NewSymbol("printf")) -if v235.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v235))) -} -v236 := v235.Get() -v237 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v238 := v237.FindInternedVar(lang.NewSymbol("key")) -if v238.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v238))) -} -v239 := v238.Get() -v240 := lang.Apply(v239, []any{v230}) -v241 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v242 := v241.FindInternedVar(lang.NewSymbol("print-str")) -if v242.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v242))) -} -v243 := v242.Get() -v244 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v245 := v244.FindInternedVar(lang.NewSymbol("val")) -if v245.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v245))) -} -v246 := v245.Get() -v247 := lang.Apply(v246, []any{v230}) -v248 := lang.Apply(v243, []any{v247}) -v249 := lang.Apply(v236, []any{" %s '%s", v240, v248}) -_ = v249 -var v250 any = v216 -var v251 any = v221 -var v252 any = v222 -v254 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v255 := v254.FindInternedVar(lang.NewSymbol("unchecked-inc")) -if v255.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v255))) -} -v256 := v255.Get() -v257 := lang.Apply(v256, []any{v223}) -var v253 any = v257 -v216 = v250 -v221 = v251 -v222 = v252 -v223 = v253 -continue -} else { -v231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v232 := v231.FindInternedVar(lang.NewSymbol("seq")) -if v232.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v232))) -} -v233 := v232.Get() -v234 := lang.Apply(v233, []any{v216}) -var v230 any = v234 -_ = v230 -var v236 any -if lang.IsTruthy(v230) { -var v237 any = v230 -_ = v237 -var v239 any -v240 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v241 := v240.FindInternedVar(lang.NewSymbol("chunked-seq?")) -if v241.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v241))) -} -v242 := v241.Get() -v243 := lang.Apply(v242, []any{v237}) -if lang.IsTruthy(v243) { -v245 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v246 := v245.FindInternedVar(lang.NewSymbol("chunk-first")) -if v246.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v246))) -} -v247 := v246.Get() -v248 := lang.Apply(v247, []any{v237}) -var v244 any = v248 -_ = v244 -v251 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v252 := v251.FindInternedVar(lang.NewSymbol("chunk-rest")) -if v252.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v252))) -} -v253 := v252.Get() -v254 := lang.Apply(v253, []any{v237}) -var v250 any = v254 -var v255 any = v244 -v257 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v258 := v257.FindInternedVar(lang.NewSymbol("int")) -if v258.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v258))) -} -v259 := v258.Get() -v260 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v261 := v260.FindInternedVar(lang.NewSymbol("count")) -if v261.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v261))) -} -v262 := v261.Get() -v263 := lang.Apply(v262, []any{v244}) -v264 := lang.Apply(v259, []any{v263}) -var v256 any = v264 -v266 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v267 := v266.FindInternedVar(lang.NewSymbol("int")) -if v267.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v267))) -} -v268 := v267.Get() -v269 := lang.Apply(v268, []any{int64(0)}) -var v265 any = v269 -v216 = v250 -v221 = v255 -v222 = v256 -v223 = v265 -continue -} else { -v245 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v246 := v245.FindInternedVar(lang.NewSymbol("first")) -if v246.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v246))) -} -v247 := v246.Get() -v248 := lang.Apply(v247, []any{v237}) -var v244 any = v248 -_ = v244 -v250 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v251 := v250.FindInternedVar(lang.NewSymbol("printf")) -if v251.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v251))) -} -v252 := v251.Get() -v253 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v254 := v253.FindInternedVar(lang.NewSymbol("key")) -if v254.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v254))) -} -v255 := v254.Get() -v256 := lang.Apply(v255, []any{v244}) -v257 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v258 := v257.FindInternedVar(lang.NewSymbol("print-str")) -if v258.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v258))) -} -v259 := v258.Get() -v260 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v261 := v260.FindInternedVar(lang.NewSymbol("val")) -if v261.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v261))) -} -v262 := v261.Get() -v263 := lang.Apply(v262, []any{v244}) -v264 := lang.Apply(v259, []any{v263}) -v265 := lang.Apply(v252, []any{" %s '%s", v256, v264}) -_ = v265 -v267 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v268 := v267.FindInternedVar(lang.NewSymbol("next")) -if v268.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v268))) -} -v269 := v268.Get() -v270 := lang.Apply(v269, []any{v237}) -var v266 any = v270 -var v271 any = nil -var v272 any = int64(0) -var v273 any = int64(0) -v216 = v266 -v221 = v271 -v222 = v272 -v223 = v273 -continue -} -v236 = v239 -} else { -v236 = nil -} -v225 = v236 -} -v224 = v225 - break -} -_ = v224 -v216 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v217 := v216.FindInternedVar(lang.NewSymbol("printf")) -if v217.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v217))) -} -v218 := v217.Get() -v219 := lang.Apply(v218, []any{")\n"}) -v208 = v219 -} else { -v208 = nil -} -_ = v208 -v220 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v221 := v220.FindInternedVar(lang.NewSymbol("apply")) -if v221.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v221))) -} -v222 := v221.Get() -v223 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v224 := v223.FindInternedVar(lang.NewSymbol("refer")) -if v224.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v224))) -} -v225 := v224.Get() -v226 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v227 := v226.FindInternedVar(lang.NewSymbol("mapcat")) -if v227.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v227))) -} -v228 := v227.Get() -v229 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v230 := v229.FindInternedVar(lang.NewSymbol("seq")) -if v230.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v230))) -} -v231 := v230.Get() -v232 := lang.Apply(v228, []any{v231, v132}) -v233 := lang.Apply(v222, []any{v225, v14, v232}) -v207 = v233 -} else { -v207 = nil -} -v157 = v207 -}() -return v157 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// load-libs -{ -v0 := lang.NewSymbol("load-libs").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Loads libs, interpreting libspecs, prefix lists, and flags for\n forwarding to load-lib", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5951), lang.NewKeyword("end-line"), int(5951), lang.NewKeyword("private"), true)).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewList(args[0:]...) -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("filter")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("keyword?")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v7, []any{v10, v3}) -var v4 any = v11 -_ = v4 -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("interleave")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("repeat")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{true}) -v20 := lang.Apply(v15, []any{v4, v19}) -var v12 any = v20 -_ = v12 -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("filter")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("complement")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("keyword?")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v27, []any{v30}) -v32 := lang.Apply(v24, []any{v31, v21}) -var v21 any = v32 -_ = v21 -v35 := lang.CreatePersistentTreeSet(lang.NewKeyword("as"), lang.NewKeyword("reload"), lang.NewKeyword("reload-all"), lang.NewKeyword("require"), lang.NewKeyword("use"), lang.NewKeyword("verbose"), lang.NewKeyword("refer"), lang.NewKeyword("as-alias")) -v36 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5959), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(5959), lang.NewKeyword("end-column"), int(86)) -v37, err := lang.WithMeta(v35, v36.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v34 any = v37 -_ = v34 -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("seq")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) -} -v41 := v40.Get() -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("remove")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) -} -v44 := v43.Get() -v45 := lang.Apply(v44, []any{v34, v4}) -v46 := lang.Apply(v41, []any{v45}) -var v38 any = v46 -_ = v38 -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("throw-if")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v52 := v51.FindInternedVar(lang.NewSymbol("apply")) -if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) -} -v53 := v52.Get() -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("str")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) -} -v56 := v55.Get() -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("interpose")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) -} -v59 := v58.Get() -v60 := lang.Apply(v59, []any{lang.NewChar(44), v38}) -v61 := lang.Apply(v53, []any{v56, "Unsupported option(s) supplied: ", v60}) -v62 := lang.Apply(v50, []any{v38, v61}) -_ = v62 -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("throw-if")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("not")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("seq")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v21}) -v44 := lang.Apply(v39, []any{v43}) -v45 := lang.Apply(v36, []any{v44, "Nothing specified to load"}) -_ = v45 -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("seq")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) -} -v49 := v48.Get() -v50 := lang.Apply(v49, []any{v21}) -var v46 any = v50 -_ = v46 -var v51 any = nil -_ = v51 -var v52 any = int64(0) -_ = v52 -var v53 any = int64(0) -_ = v53 -var v54 any -for { -var v55 any -v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v57 := v56.FindInternedVar(lang.NewSymbol("<")) -if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) -} -v58 := v57.Get() -v59 := lang.Apply(v58, []any{v53, v52}) -if lang.IsTruthy(v59) { -v61, _ := lang.FieldOrMethod(v51, "nth") -if reflect.TypeOf(v61).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) -} -v62 := lang.Apply(v61, []any{v53}) -var v60 any = v62 -_ = v60 -var v64 any -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("libspec?")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) -} -v67 := v66.Get() -v68 := lang.Apply(v67, []any{v60}) -if lang.IsTruthy(v68) { -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("apply")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) -} -v71 := v70.Get() -v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v73 := v72.FindInternedVar(lang.NewSymbol("load-lib")) -if v73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) -} -v74 := v73.Get() -v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v76 := v75.FindInternedVar(lang.NewSymbol("prependss")) -if v76.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) -} -v77 := v76.Get() -v78 := lang.Apply(v77, []any{v60, v12}) -v79 := lang.Apply(v71, []any{v74, nil, v78}) -v64 = v79 -} else { -var v80 any = v60 -_ = v80 -v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v83 := v82.FindInternedVar(lang.NewSymbol("seq")) -if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) -} -v84 := v83.Get() -v85 := lang.Apply(v84, []any{v80}) -var v81 any = v85 -_ = v81 -v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v88 := v87.FindInternedVar(lang.NewSymbol("first")) -if v88.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) -} -v89 := v88.Get() -v90 := lang.Apply(v89, []any{v81}) -var v86 any = v90 -_ = v86 -v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v93 := v92.FindInternedVar(lang.NewSymbol("next")) -if v93.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) -} -v94 := v93.Get() -v95 := lang.Apply(v94, []any{v91}) -var v91 any = v95 -_ = v91 -var v96 any = v86 -_ = v96 -var v97 any = v91 -_ = v97 -v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v100 := v99.FindInternedVar(lang.NewSymbol("throw-if")) -if v100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) -} -v101 := v100.Get() -v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v103 := v102.FindInternedVar(lang.NewSymbol("nil?")) -if v103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) -} -v104 := v103.Get() -v105 := lang.Apply(v104, []any{v96}) -v106 := lang.Apply(v101, []any{v105, "prefix cannot be nil"}) -_ = v106 -v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v109 := v108.FindInternedVar(lang.NewSymbol("seq")) -if v109.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) -} -v110 := v109.Get() -v111 := lang.Apply(v110, []any{v97}) -var v107 any = v111 -_ = v107 -var v112 any = nil -_ = v112 -var v113 any = int64(0) -_ = v113 -var v114 any = int64(0) -_ = v114 -var v115 any -for { -var v116 any -v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v118 := v117.FindInternedVar(lang.NewSymbol("<")) -if v118.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) -} -v119 := v118.Get() -v120 := lang.Apply(v119, []any{v114, v113}) -if lang.IsTruthy(v120) { -v122, _ := lang.FieldOrMethod(v112, "nth") -if reflect.TypeOf(v122).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) -} -v123 := lang.Apply(v122, []any{v114}) -var v121 any = v123 -_ = v121 -v125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v126 := v125.FindInternedVar(lang.NewSymbol("apply")) -if v126.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v126))) -} -v127 := v126.Get() -v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v129 := v128.FindInternedVar(lang.NewSymbol("load-lib")) -if v129.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v129))) -} -v130 := v129.Get() -v131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v132 := v131.FindInternedVar(lang.NewSymbol("prependss")) -if v132.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v132))) -} -v133 := v132.Get() -v134 := lang.Apply(v133, []any{v121, v12}) -v135 := lang.Apply(v127, []any{v130, v96, v134}) -_ = v135 -var v136 any = v107 -var v137 any = v112 -var v138 any = v113 -v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v141 := v140.FindInternedVar(lang.NewSymbol("unchecked-inc")) -if v141.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) -} -v142 := v141.Get() -v143 := lang.Apply(v142, []any{v114}) -var v139 any = v143 -v107 = v136 -v112 = v137 -v113 = v138 -v114 = v139 -continue -} else { -v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v123 := v122.FindInternedVar(lang.NewSymbol("seq")) -if v123.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) -} -v124 := v123.Get() -v125 := lang.Apply(v124, []any{v107}) -var v121 any = v125 -_ = v121 -var v127 any -if lang.IsTruthy(v121) { -var v128 any = v121 -_ = v128 -var v130 any -v131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v132 := v131.FindInternedVar(lang.NewSymbol("chunked-seq?")) -if v132.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v132))) -} -v133 := v132.Get() -v134 := lang.Apply(v133, []any{v128}) -if lang.IsTruthy(v134) { -v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v137 := v136.FindInternedVar(lang.NewSymbol("chunk-first")) -if v137.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) -} -v138 := v137.Get() -v139 := lang.Apply(v138, []any{v128}) -var v135 any = v139 -_ = v135 -v142 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v143 := v142.FindInternedVar(lang.NewSymbol("chunk-rest")) -if v143.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v143))) -} -v144 := v143.Get() -v145 := lang.Apply(v144, []any{v128}) -var v141 any = v145 -var v146 any = v135 -v148 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v149 := v148.FindInternedVar(lang.NewSymbol("int")) -if v149.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v149))) -} -v150 := v149.Get() -v151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v152 := v151.FindInternedVar(lang.NewSymbol("count")) -if v152.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v152))) -} -v153 := v152.Get() -v154 := lang.Apply(v153, []any{v135}) -v155 := lang.Apply(v150, []any{v154}) -var v147 any = v155 -v157 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v158 := v157.FindInternedVar(lang.NewSymbol("int")) -if v158.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v158))) -} -v159 := v158.Get() -v160 := lang.Apply(v159, []any{int64(0)}) -var v156 any = v160 -v107 = v141 -v112 = v146 -v113 = v147 -v114 = v156 -continue -} else { -v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v137 := v136.FindInternedVar(lang.NewSymbol("first")) -if v137.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) -} -v138 := v137.Get() -v139 := lang.Apply(v138, []any{v128}) -var v135 any = v139 -_ = v135 -v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v142 := v141.FindInternedVar(lang.NewSymbol("apply")) -if v142.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) -} -v143 := v142.Get() -v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v145 := v144.FindInternedVar(lang.NewSymbol("load-lib")) -if v145.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) -} -v146 := v145.Get() -v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v148 := v147.FindInternedVar(lang.NewSymbol("prependss")) -if v148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) -} -v149 := v148.Get() -v150 := lang.Apply(v149, []any{v135, v12}) -v151 := lang.Apply(v143, []any{v146, v96, v150}) -_ = v151 -v153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v154 := v153.FindInternedVar(lang.NewSymbol("next")) -if v154.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v154))) -} -v155 := v154.Get() -v156 := lang.Apply(v155, []any{v128}) -var v152 any = v156 -var v157 any = nil -var v158 any = int64(0) -var v159 any = int64(0) -v107 = v152 -v112 = v157 -v113 = v158 -v114 = v159 -continue -} -v127 = v130 -} else { -v127 = nil -} -v116 = v127 -} -v115 = v116 - break -} -v64 = v115 -} -_ = v64 -var v80 any = v46 -var v81 any = v51 -var v82 any = v52 -v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v85 := v84.FindInternedVar(lang.NewSymbol("unchecked-inc")) -if v85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) -} -v86 := v85.Get() -v87 := lang.Apply(v86, []any{v53}) -var v83 any = v87 -v46 = v80 -v51 = v81 -v52 = v82 -v53 = v83 -continue -} else { -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("seq")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) -} -v63 := v62.Get() -v64 := lang.Apply(v63, []any{v46}) -var v60 any = v64 -_ = v60 -var v66 any -if lang.IsTruthy(v60) { -var v67 any = v60 -_ = v67 -var v69 any -v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v71 := v70.FindInternedVar(lang.NewSymbol("chunked-seq?")) -if v71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) -} -v72 := v71.Get() -v73 := lang.Apply(v72, []any{v67}) -if lang.IsTruthy(v73) { -v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v76 := v75.FindInternedVar(lang.NewSymbol("chunk-first")) -if v76.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) -} -v77 := v76.Get() -v78 := lang.Apply(v77, []any{v67}) -var v74 any = v78 -_ = v74 -v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v82 := v81.FindInternedVar(lang.NewSymbol("chunk-rest")) -if v82.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) -} -v83 := v82.Get() -v84 := lang.Apply(v83, []any{v67}) -var v80 any = v84 -var v85 any = v74 -v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v88 := v87.FindInternedVar(lang.NewSymbol("int")) -if v88.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) -} -v89 := v88.Get() -v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v91 := v90.FindInternedVar(lang.NewSymbol("count")) -if v91.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) -} -v92 := v91.Get() -v93 := lang.Apply(v92, []any{v74}) -v94 := lang.Apply(v89, []any{v93}) -var v86 any = v94 -v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v97 := v96.FindInternedVar(lang.NewSymbol("int")) -if v97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) -} -v98 := v97.Get() -v99 := lang.Apply(v98, []any{int64(0)}) -var v95 any = v99 -v46 = v80 -v51 = v85 -v52 = v86 -v53 = v95 -continue -} else { -v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v76 := v75.FindInternedVar(lang.NewSymbol("first")) -if v76.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) -} -v77 := v76.Get() -v78 := lang.Apply(v77, []any{v67}) -var v74 any = v78 -_ = v74 -var v80 any -v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v82 := v81.FindInternedVar(lang.NewSymbol("libspec?")) -if v82.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) -} -v83 := v82.Get() -v84 := lang.Apply(v83, []any{v74}) -if lang.IsTruthy(v84) { -v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v86 := v85.FindInternedVar(lang.NewSymbol("apply")) -if v86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) -} -v87 := v86.Get() -v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v89 := v88.FindInternedVar(lang.NewSymbol("load-lib")) -if v89.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) -} -v90 := v89.Get() -v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v92 := v91.FindInternedVar(lang.NewSymbol("prependss")) -if v92.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) -} -v93 := v92.Get() -v94 := lang.Apply(v93, []any{v74, v12}) -v95 := lang.Apply(v87, []any{v90, nil, v94}) -v80 = v95 -} else { -var v96 any = v74 -_ = v96 -v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v99 := v98.FindInternedVar(lang.NewSymbol("seq")) -if v99.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) -} -v100 := v99.Get() -v101 := lang.Apply(v100, []any{v96}) -var v97 any = v101 -_ = v97 -v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v104 := v103.FindInternedVar(lang.NewSymbol("first")) -if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) -} -v105 := v104.Get() -v106 := lang.Apply(v105, []any{v97}) -var v102 any = v106 -_ = v102 -v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v109 := v108.FindInternedVar(lang.NewSymbol("next")) -if v109.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) -} -v110 := v109.Get() -v111 := lang.Apply(v110, []any{v107}) -var v107 any = v111 -_ = v107 -var v112 any = v102 -_ = v112 -var v113 any = v107 -_ = v113 -v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v116 := v115.FindInternedVar(lang.NewSymbol("throw-if")) -if v116.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) -} -v117 := v116.Get() -v118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v119 := v118.FindInternedVar(lang.NewSymbol("nil?")) -if v119.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v119))) -} -v120 := v119.Get() -v121 := lang.Apply(v120, []any{v112}) -v122 := lang.Apply(v117, []any{v121, "prefix cannot be nil"}) -_ = v122 -v124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v125 := v124.FindInternedVar(lang.NewSymbol("seq")) -if v125.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v125))) -} -v126 := v125.Get() -v127 := lang.Apply(v126, []any{v113}) -var v123 any = v127 -_ = v123 -var v128 any = nil -_ = v128 -var v129 any = int64(0) -_ = v129 -var v130 any = int64(0) -_ = v130 -var v131 any -for { -var v132 any -v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v134 := v133.FindInternedVar(lang.NewSymbol("<")) -if v134.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) -} -v135 := v134.Get() -v136 := lang.Apply(v135, []any{v130, v129}) -if lang.IsTruthy(v136) { -v138, _ := lang.FieldOrMethod(v128, "nth") -if reflect.TypeOf(v138).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) -} -v139 := lang.Apply(v138, []any{v130}) -var v137 any = v139 -_ = v137 -v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v142 := v141.FindInternedVar(lang.NewSymbol("apply")) -if v142.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) -} -v143 := v142.Get() -v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v145 := v144.FindInternedVar(lang.NewSymbol("load-lib")) -if v145.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) -} -v146 := v145.Get() -v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v148 := v147.FindInternedVar(lang.NewSymbol("prependss")) -if v148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) -} -v149 := v148.Get() -v150 := lang.Apply(v149, []any{v137, v12}) -v151 := lang.Apply(v143, []any{v146, v112, v150}) -_ = v151 -var v152 any = v123 -var v153 any = v128 -var v154 any = v129 -v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v157 := v156.FindInternedVar(lang.NewSymbol("unchecked-inc")) -if v157.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) -} -v158 := v157.Get() -v159 := lang.Apply(v158, []any{v130}) -var v155 any = v159 -v123 = v152 -v128 = v153 -v129 = v154 -v130 = v155 -continue -} else { -v138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v139 := v138.FindInternedVar(lang.NewSymbol("seq")) -if v139.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v139))) -} -v140 := v139.Get() -v141 := lang.Apply(v140, []any{v123}) -var v137 any = v141 -_ = v137 -var v143 any -if lang.IsTruthy(v137) { -var v144 any = v137 -_ = v144 -var v146 any -v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v148 := v147.FindInternedVar(lang.NewSymbol("chunked-seq?")) -if v148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) -} -v149 := v148.Get() -v150 := lang.Apply(v149, []any{v144}) -if lang.IsTruthy(v150) { -v152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v153 := v152.FindInternedVar(lang.NewSymbol("chunk-first")) -if v153.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v153))) -} -v154 := v153.Get() -v155 := lang.Apply(v154, []any{v144}) -var v151 any = v155 -_ = v151 -v158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v159 := v158.FindInternedVar(lang.NewSymbol("chunk-rest")) -if v159.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v159))) -} -v160 := v159.Get() -v161 := lang.Apply(v160, []any{v144}) -var v157 any = v161 -var v162 any = v151 -v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v165 := v164.FindInternedVar(lang.NewSymbol("int")) -if v165.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) -} -v166 := v165.Get() -v167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v168 := v167.FindInternedVar(lang.NewSymbol("count")) -if v168.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v168))) -} -v169 := v168.Get() -v170 := lang.Apply(v169, []any{v151}) -v171 := lang.Apply(v166, []any{v170}) -var v163 any = v171 -v173 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v174 := v173.FindInternedVar(lang.NewSymbol("int")) -if v174.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v174))) -} -v175 := v174.Get() -v176 := lang.Apply(v175, []any{int64(0)}) -var v172 any = v176 -v123 = v157 -v128 = v162 -v129 = v163 -v130 = v172 -continue -} else { -v152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v153 := v152.FindInternedVar(lang.NewSymbol("first")) -if v153.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v153))) -} -v154 := v153.Get() -v155 := lang.Apply(v154, []any{v144}) -var v151 any = v155 -_ = v151 -v157 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v158 := v157.FindInternedVar(lang.NewSymbol("apply")) -if v158.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v158))) -} -v159 := v158.Get() -v160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v161 := v160.FindInternedVar(lang.NewSymbol("load-lib")) -if v161.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v161))) -} -v162 := v161.Get() -v163 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v164 := v163.FindInternedVar(lang.NewSymbol("prependss")) -if v164.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v164))) -} -v165 := v164.Get() -v166 := lang.Apply(v165, []any{v151, v12}) -v167 := lang.Apply(v159, []any{v162, v112, v166}) -_ = v167 -v169 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v170 := v169.FindInternedVar(lang.NewSymbol("next")) -if v170.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v170))) -} -v171 := v170.Get() -v172 := lang.Apply(v171, []any{v144}) -var v168 any = v172 -var v173 any = nil -var v174 any = int64(0) -var v175 any = int64(0) -v123 = v168 -v128 = v173 -v129 = v174 -v130 = v175 -continue -} -v143 = v146 -} else { -v143 = nil -} -v132 = v143 -} -v131 = v132 - break -} -v80 = v131 -} -_ = v80 -v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v98 := v97.FindInternedVar(lang.NewSymbol("next")) -if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) -} -v99 := v98.Get() -v100 := lang.Apply(v99, []any{v67}) -var v96 any = v100 -var v101 any = nil -var v102 any = int64(0) -var v103 any = int64(0) -v46 = v96 -v51 = v101 -v52 = v102 -v53 = v103 -continue -} -v66 = v69 -} else { -v66 = nil -} -v55 = v66 -} -v54 = v55 - break -} -return v54 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// load-one -{ -v0 := lang.NewSymbol("load-one").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"), lang.NewSymbol("need-ns"), lang.NewSymbol("require"))), lang.NewKeyword("doc"), "Loads a lib given its name. If need-ns, ensures that the associated\n namespace exists after loading. If require, records the load so any\n duplicate loads can be skipped.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5879), lang.NewKeyword("end-line"), int(5879), lang.NewKeyword("private"), true)).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("load")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("root-resource")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v3}) -v13 := lang.Apply(v8, []any{v12}) -_ = v13 -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("throw-if")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -var v17 any = v4 -_ = v17 -var v19 any -if lang.IsTruthy(v17) { -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("not")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("find-ns")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{v3}) -v27 := lang.Apply(v22, []any{v26}) -v19 = v27 -} else { -v19 = v17 -} -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("root-resource")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v3}) -v21 := lang.Apply(v16, []any{v19, "namespace '%s' not found after loading '%s'", v3, v20}) -_ = v21 -var v22 any -if lang.IsTruthy(v5) { -var v23 lang.FnFunc -v23 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("commute")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("*loaded-libs*")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("conj")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.Apply(v26, []any{v29, v32, v3}) -return v33 -}) -v24, _ := lang.FieldOrMethod(lang.LockingTransaction, "RunInTransaction") -if reflect.TypeOf(v24).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("RunInTransaction is not a function"))) -} -v25 := lang.Apply(v24, []any{v23}) -v22 = v25 -} else { -v22 = nil -} -return v22 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// load-reader -{ -v0 := lang.NewSymbol("load-reader").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rdr"))), lang.NewKeyword("doc"), "Sequentially read and evaluate the set of forms contained in the\n stream/file", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4081), lang.NewKeyword("end-line"), int(4081))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, _ := lang.FieldOrMethod(runtime5.Compiler, "load") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("load is not a function"))) -} -v5 := lang.Apply(v4, []any{v3}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// load-string -{ -v0 := lang.NewSymbol("load-string").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Sequentially read and evaluate the set of forms contained in the\n string", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4088), lang.NewKeyword("end-line"), int(4088))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v5 := lang.Apply(java.io.StringReader14., []any{v3}) -v6 := lang.Apply(glojure.lang.LineNumberingPushbackReader12., []any{v5}) -var v4 any = v6 -_ = v4 -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("load-reader")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v4}) -return v11 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// loaded-libs -{ -v0 := lang.NewSymbol("loaded-libs").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Returns a sorted set of symbols naming the currently loaded libs", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6090), lang.NewKeyword("end-line"), int(6090))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v4 := v3.FindInternedVar(lang.NewSymbol("deref")) -if v4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) -} -v5 := v4.Get() -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("*loaded-libs*")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v5, []any{v8}) -return v9 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// locking -{ -v0 := lang.NewSymbol("locking").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Executes exprs in an implicit do, while holding the monitor of x.\n Will release the monitor of x in all circumstances.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1643), lang.NewKeyword("end-line"), int(1643))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("seq")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("concat")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("list")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/let")}) -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("list")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("apply")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("vector")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("seq")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("concat")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{lang.NewSymbol("lockee__0__auto__")}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v5}) -v40 := lang.Apply(v31, []any{v35, v39}) -v41 := lang.Apply(v28, []any{v40}) -v42 := lang.Apply(v22, []any{v25, v41}) -v43 := lang.Apply(v19, []any{v42}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("seq")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) -} -v49 := v48.Get() -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("concat")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("list")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) -} -v55 := v54.Get() -v56 := lang.Apply(v55, []any{lang.NewSymbol("try")}) -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("list")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) -} -v59 := v58.Get() -v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v61 := v60.FindInternedVar(lang.NewSymbol("seq")) -if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) -} -v62 := v61.Get() -v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v64 := v63.FindInternedVar(lang.NewSymbol("concat")) -if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) -} -v65 := v64.Get() -v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v67 := v66.FindInternedVar(lang.NewSymbol("list")) -if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) -} -v68 := v67.Get() -v69 := lang.Apply(v68, []any{lang.NewSymbol("glojure.core/let")}) -v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v71 := v70.FindInternedVar(lang.NewSymbol("list")) -if v71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) -} -v72 := v71.Get() -v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v74 := v73.FindInternedVar(lang.NewSymbol("apply")) -if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) -} -v75 := v74.Get() -v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v77 := v76.FindInternedVar(lang.NewSymbol("vector")) -if v77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) -} -v78 := v77.Get() -v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v80 := v79.FindInternedVar(lang.NewSymbol("seq")) -if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) -} -v81 := v80.Get() -v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v83 := v82.FindInternedVar(lang.NewSymbol("concat")) -if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) -} -v84 := v83.Get() -v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v86 := v85.FindInternedVar(lang.NewSymbol("list")) -if v86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) -} -v87 := v86.Get() -v88 := lang.Apply(v87, []any{lang.NewSymbol("locklocal__1__auto__")}) -v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v90 := v89.FindInternedVar(lang.NewSymbol("list")) -if v90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) -} -v91 := v90.Get() -v92 := lang.Apply(v91, []any{lang.NewSymbol("lockee__0__auto__")}) -v93 := lang.Apply(v84, []any{v88, v92}) -v94 := lang.Apply(v81, []any{v93}) -v95 := lang.Apply(v75, []any{v78, v94}) -v96 := lang.Apply(v72, []any{v95}) -v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v98 := v97.FindInternedVar(lang.NewSymbol("list")) -if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) -} -v99 := v98.Get() -v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v101 := v100.FindInternedVar(lang.NewSymbol("seq")) -if v101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) -} -v102 := v101.Get() -v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v104 := v103.FindInternedVar(lang.NewSymbol("concat")) -if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) -} -v105 := v104.Get() -v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v107 := v106.FindInternedVar(lang.NewSymbol("list")) -if v107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) -} -v108 := v107.Get() -v109 := lang.Apply(v108, []any{lang.NewSymbol("monitor-enter")}) -v110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v111 := v110.FindInternedVar(lang.NewSymbol("list")) -if v111.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v111))) -} -v112 := v111.Get() -v113 := lang.Apply(v112, []any{lang.NewSymbol("locklocal__1__auto__")}) -v114 := lang.Apply(v105, []any{v109, v113}) -v115 := lang.Apply(v102, []any{v114}) -v116 := lang.Apply(v99, []any{v115}) -v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v118 := v117.FindInternedVar(lang.NewSymbol("list")) -if v118.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) -} -v119 := v118.Get() -v120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v121 := v120.FindInternedVar(lang.NewSymbol("seq")) -if v121.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v121))) -} -v122 := v121.Get() -v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v124 := v123.FindInternedVar(lang.NewSymbol("concat")) -if v124.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) -} -v125 := v124.Get() -v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v127 := v126.FindInternedVar(lang.NewSymbol("list")) -if v127.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) -} -v128 := v127.Get() -v129 := lang.Apply(v128, []any{lang.NewSymbol("try")}) -v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v131 := v130.FindInternedVar(lang.NewSymbol("list")) -if v131.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) -} -v132 := v131.Get() -v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v134 := v133.FindInternedVar(lang.NewSymbol("seq")) -if v134.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) -} -v135 := v134.Get() -v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v137 := v136.FindInternedVar(lang.NewSymbol("concat")) -if v137.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) -} -v138 := v137.Get() -v139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v140 := v139.FindInternedVar(lang.NewSymbol("list")) -if v140.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v140))) -} -v141 := v140.Get() -v142 := lang.Apply(v141, []any{lang.NewSymbol("finally")}) -v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v144 := v143.FindInternedVar(lang.NewSymbol("list")) -if v144.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) -} -v145 := v144.Get() -v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v147 := v146.FindInternedVar(lang.NewSymbol("seq")) -if v147.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) -} -v148 := v147.Get() -v149 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v150 := v149.FindInternedVar(lang.NewSymbol("concat")) -if v150.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v150))) -} -v151 := v150.Get() -v152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v153 := v152.FindInternedVar(lang.NewSymbol("list")) -if v153.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v153))) -} -v154 := v153.Get() -v155 := lang.Apply(v154, []any{lang.NewSymbol("monitor-exit")}) -v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v157 := v156.FindInternedVar(lang.NewSymbol("list")) -if v157.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) -} -v158 := v157.Get() -v159 := lang.Apply(v158, []any{lang.NewSymbol("locklocal__1__auto__")}) -v160 := lang.Apply(v151, []any{v155, v159}) -v161 := lang.Apply(v148, []any{v160}) -v162 := lang.Apply(v145, []any{v161}) -v163 := lang.Apply(v138, []any{v142, v162}) -v164 := lang.Apply(v135, []any{v163}) -v165 := lang.Apply(v132, []any{v164}) -v166 := lang.Apply(v125, []any{v129, v6, v165}) -v167 := lang.Apply(v122, []any{v166}) -v168 := lang.Apply(v119, []any{v167}) -v169 := lang.Apply(v65, []any{v69, v96, v116, v168}) -v170 := lang.Apply(v62, []any{v169}) -v171 := lang.Apply(v59, []any{v170}) -v172 := lang.Apply(v52, []any{v56, v171}) -v173 := lang.Apply(v49, []any{v172}) -v174 := lang.Apply(v46, []any{v173}) -v175 := lang.Apply(v12, []any{v16, v43, v174}) -v176 := lang.Apply(v9, []any{v175}) -return v176 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// long -{ -var v1 lang.FnFunc -{ // function long__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/LongCast")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v3}) -v35 := lang.Apply(v26, []any{v30, v34}) -v36 := lang.Apply(v23, []any{v35}) -v37 := lang.Apply(v20, []any{v36}) -v38 := lang.Apply(v9, []any{v13, v17, v37}) -v39 := lang.Apply(v6, []any{v38}) -return v39 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("long").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to long", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3481), lang.NewKeyword("end-line"), int(3481))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := lang.Apply(lang.LongCast, []any{v4}) -return v5 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// long-array -{ -var v1 lang.FnFunc -{ // function long-array__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewList(args[0:]...) -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/longArray")}) -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("list")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("seq")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("concat")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("list")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.Apply(v37, []any{lang.NewSymbol("glojure.core/args")}) -v39 := lang.Apply(v30, []any{v34, v38}) -v40 := lang.Apply(v27, []any{v39}) -v41 := lang.Apply(v24, []any{v40}) -v42 := lang.Apply(v9, []any{v13, v17, v21, v41}) -v43 := lang.Apply(v6, []any{v42}) -return v43 - } -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("long-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Creates an array of longs", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5364), lang.NewKeyword("end-line"), int(5364))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v4 := args[0] -v5, _ := lang.FieldOrMethod(lang.Numbers, "longArray") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("longArray is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 - case 2: -v4 := args[0] -v5 := args[1] -v6, _ := lang.FieldOrMethod(lang.Numbers, "longArrayInit") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("longArrayInit is not a function"))) -} -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// longs -{ -var v1 lang.FnFunc -{ // function longs -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/longs")}) -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("list")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v26 := lang.Apply(v9, []any{v13, v17, v21, v25}) -v27 := lang.Apply(v6, []any{v26}) -return v27 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("longs").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Casts to long[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5407), lang.NewKeyword("end-line"), int(5407))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5, _ := lang.FieldOrMethod(lang.Numbers, "longs") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("longs is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// loop -{ -v0 := lang.NewSymbol("loop").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Evaluates the exprs in a lexical context in which the symbols in\n the binding-forms are bound to their respective init-exprs or parts\n therein. Acts as a recur target.", lang.NewKeyword("forms"), lang.NewVector(lang.NewList(lang.NewSymbol("loop"), lang.NewVector(lang.NewSymbol("bindings*")), lang.NewSymbol("exprs*"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4597), lang.NewKeyword("end-line"), int(4597), lang.NewKeyword("special-form"), true)).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -var v7 any -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v5}) -if lang.IsTruthy(v11) { -v7 = nil -} else { -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("str")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("first")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v3}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("meta")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) -v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) -v28 := lang.Apply(lang.NewIllegalArgumentError, []any{v27}) -panic(v28) -} -_ = v7 -var v29 any -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("even?")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("count")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v5}) -v37 := lang.Apply(v32, []any{v36}) -if lang.IsTruthy(v37) { -v29 = nil -} else { -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("str")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("first")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v3}) -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("meta")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v3}) -v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) -v53 := lang.Apply(v40, []any{v44, " requires ", "an even number of forms in binding vector", " in ", v47, ":", v52}) -v54 := lang.Apply(lang.NewIllegalArgumentError, []any{v53}) -panic(v54) -} -_ = v29 -_ = nil -v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v57 := v56.FindInternedVar(lang.NewSymbol("destructure")) -if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) -} -v58 := v57.Get() -v59 := lang.Apply(v58, []any{v5}) -var v55 any = v59 -_ = v55 -var v61 any -v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v63 := v62.FindInternedVar(lang.NewSymbol("=")) -if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) -} -v64 := v63.Get() -v65 := lang.Apply(v64, []any{v55, v5}) -if lang.IsTruthy(v65) { -v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v67 := v66.FindInternedVar(lang.NewSymbol("seq")) -if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) -} -v68 := v67.Get() -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("concat")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) -} -v71 := v70.Get() -v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v73 := v72.FindInternedVar(lang.NewSymbol("list")) -if v73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) -} -v74 := v73.Get() -v75 := lang.Apply(v74, []any{lang.NewSymbol("loop*")}) -v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v77 := v76.FindInternedVar(lang.NewSymbol("list")) -if v77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) -} -v78 := v77.Get() -v79 := lang.Apply(v78, []any{v5}) -v80 := lang.Apply(v71, []any{v75, v79, v6}) -v81 := lang.Apply(v68, []any{v80}) -v61 = v81 -} else { -v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v84 := v83.FindInternedVar(lang.NewSymbol("take-nth")) -if v84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) -} -v85 := v84.Get() -v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v87 := v86.FindInternedVar(lang.NewSymbol("drop")) -if v87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) -} -v88 := v87.Get() -v89 := lang.Apply(v88, []any{int64(1), v5}) -v90 := lang.Apply(v85, []any{int64(2), v89}) -var v82 any = v90 -_ = v82 -v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v93 := v92.FindInternedVar(lang.NewSymbol("take-nth")) -if v93.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) -} -v94 := v93.Get() -v95 := lang.Apply(v94, []any{int64(2), v5}) -var v91 any = v95 -_ = v91 -v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v98 := v97.FindInternedVar(lang.NewSymbol("map")) -if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) -} -v99 := v98.Get() -var v100 lang.FnFunc -v100 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v101 := args[0] -var v102 any -v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v104 := v103.FindInternedVar(lang.NewSymbol("symbol?")) -if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) -} -v105 := v104.Get() -v106 := lang.Apply(v105, []any{v101}) -if lang.IsTruthy(v106) { -v102 = v101 -} else { -v107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v108 := v107.FindInternedVar(lang.NewSymbol("gensym")) -if v108.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v108))) -} -v109 := v108.Get() -v110 := lang.Apply(v109, nil) -v102 = v110 -} -return v102 -}) -v101 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4611), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(4611), lang.NewKeyword("end-column"), int(58)) -v102, err := lang.WithMeta(v100, v101.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v103 := lang.Apply(v99, []any{v102, v91}) -var v96 any = v103 -_ = v96 -v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v106 := v105.FindInternedVar(lang.NewSymbol("reduce1")) -if v106.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) -} -v107 := v106.Get() -var v108 lang.FnFunc -v108 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v109 := args[0] -v110 := args[1] -var v111 any = v110 -_ = v111 -v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v114 := v113.FindInternedVar(lang.NewSymbol("nth")) -if v114.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) -} -v115 := v114.Get() -v116 := lang.Apply(v115, []any{v111, int64(0), nil}) -var v112 any = v116 -_ = v112 -v118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v119 := v118.FindInternedVar(lang.NewSymbol("nth")) -if v119.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v119))) -} -v120 := v119.Get() -v121 := lang.Apply(v120, []any{v111, int64(1), nil}) -var v117 any = v121 -_ = v117 -v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v124 := v123.FindInternedVar(lang.NewSymbol("nth")) -if v124.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) -} -v125 := v124.Get() -v126 := lang.Apply(v125, []any{v111, int64(2), nil}) -var v122 any = v126 -_ = v122 -var v128 any -v129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v130 := v129.FindInternedVar(lang.NewSymbol("symbol?")) -if v130.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v130))) -} -v131 := v130.Get() -v132 := lang.Apply(v131, []any{v112}) -if lang.IsTruthy(v132) { -v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v134 := v133.FindInternedVar(lang.NewSymbol("conj")) -if v134.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) -} -v135 := v134.Get() -v136 := lang.Apply(v135, []any{v109, v122, v117}) -v128 = v136 -} else { -v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v138 := v137.FindInternedVar(lang.NewSymbol("conj")) -if v138.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) -} -v139 := v138.Get() -v140 := lang.Apply(v139, []any{v109, v122, v117, v112, v122}) -v128 = v140 -} -return v128 -}) -v109 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4612), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(4615), lang.NewKeyword("end-column"), int(50)) -v110, err := lang.WithMeta(v108, v109.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v111 := lang.NewVector() -v112 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4616), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(4616), lang.NewKeyword("end-column"), int(28)) -v113, err := lang.WithMeta(v111, v112.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v115 := v114.FindInternedVar(lang.NewSymbol("map")) -if v115.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v115))) -} -v116 := v115.Get() -v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v118 := v117.FindInternedVar(lang.NewSymbol("vector")) -if v118.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) -} -v119 := v118.Get() -v120 := lang.Apply(v116, []any{v119, v91, v82, v96}) -v121 := lang.Apply(v107, []any{v110, v113, v120}) -var v104 any = v121 -_ = v104 -v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v124 := v123.FindInternedVar(lang.NewSymbol("seq")) -if v124.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) -} -v125 := v124.Get() -v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v127 := v126.FindInternedVar(lang.NewSymbol("concat")) -if v127.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) -} -v128 := v127.Get() -v129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v130 := v129.FindInternedVar(lang.NewSymbol("list")) -if v130.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v130))) -} -v131 := v130.Get() -v132 := lang.Apply(v131, []any{lang.NewSymbol("glojure.core/let")}) -v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v134 := v133.FindInternedVar(lang.NewSymbol("list")) -if v134.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) -} -v135 := v134.Get() -v136 := lang.Apply(v135, []any{v104}) -v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v138 := v137.FindInternedVar(lang.NewSymbol("list")) -if v138.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) -} -v139 := v138.Get() -v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v141 := v140.FindInternedVar(lang.NewSymbol("seq")) -if v141.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) -} -v142 := v141.Get() -v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v144 := v143.FindInternedVar(lang.NewSymbol("concat")) -if v144.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) -} -v145 := v144.Get() -v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v147 := v146.FindInternedVar(lang.NewSymbol("list")) -if v147.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) -} -v148 := v147.Get() -v149 := lang.Apply(v148, []any{lang.NewSymbol("loop*")}) -v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v151 := v150.FindInternedVar(lang.NewSymbol("list")) -if v151.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) -} -v152 := v151.Get() -v153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v154 := v153.FindInternedVar(lang.NewSymbol("vec")) -if v154.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v154))) -} -v155 := v154.Get() -v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v157 := v156.FindInternedVar(lang.NewSymbol("interleave")) -if v157.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) -} -v158 := v157.Get() -v159 := lang.Apply(v158, []any{v96, v96}) -v160 := lang.Apply(v155, []any{v159}) -v161 := lang.Apply(v152, []any{v160}) -v162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v163 := v162.FindInternedVar(lang.NewSymbol("list")) -if v163.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v163))) -} -v164 := v163.Get() -v165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v166 := v165.FindInternedVar(lang.NewSymbol("seq")) -if v166.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v166))) -} -v167 := v166.Get() -v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v169 := v168.FindInternedVar(lang.NewSymbol("concat")) -if v169.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) -} -v170 := v169.Get() -v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v172 := v171.FindInternedVar(lang.NewSymbol("list")) -if v172.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) -} -v173 := v172.Get() -v174 := lang.Apply(v173, []any{lang.NewSymbol("glojure.core/let")}) -v175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v176 := v175.FindInternedVar(lang.NewSymbol("list")) -if v176.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v176))) -} -v177 := v176.Get() -v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v179 := v178.FindInternedVar(lang.NewSymbol("vec")) -if v179.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) -} -v180 := v179.Get() -v181 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v182 := v181.FindInternedVar(lang.NewSymbol("interleave")) -if v182.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v182))) -} -v183 := v182.Get() -v184 := lang.Apply(v183, []any{v91, v96}) -v185 := lang.Apply(v180, []any{v184}) -v186 := lang.Apply(v177, []any{v185}) -v187 := lang.Apply(v170, []any{v174, v186, v6}) -v188 := lang.Apply(v167, []any{v187}) -v189 := lang.Apply(v164, []any{v188}) -v190 := lang.Apply(v145, []any{v149, v161, v189}) -v191 := lang.Apply(v142, []any{v190}) -v192 := lang.Apply(v139, []any{v191}) -v193 := lang.Apply(v128, []any{v132, v136, v192}) -v194 := lang.Apply(v125, []any{v193}) -v61 = v194 -} -return v61 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// macroexpand -{ -v0 := lang.NewSymbol("macroexpand").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("form"))), lang.NewKeyword("doc"), "Repeatedly calls macroexpand-1 on form until it no longer\n represents a macro form, then returns it. Note neither\n macroexpand-1 nor macroexpand expand macros in subforms.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4025), lang.NewKeyword("end-line"), int(4025))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("macroexpand-1")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -var v4 any = v8 -_ = v4 -var v10 any -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("identical?")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v4, v3}) -if lang.IsTruthy(v14) { -v10 = v3 -} else { -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("macroexpand")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v4}) -v10 = v18 -} -return v10 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// macroexpand-1 -{ -v0 := lang.NewSymbol("macroexpand-1").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("form"))), lang.NewKeyword("doc"), "If form represents a macro form, returns its expansion,\n else returns form.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4017), lang.NewKeyword("end-line"), int(4017))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, _ := lang.FieldOrMethod(runtime5.Compiler, "macroexpand1") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("macroexpand1 is not a function"))) -} -v5 := lang.Apply(v4, []any{v3}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// make-array -{ -v0 := lang.NewSymbol("make-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("type"), lang.NewSymbol("len")), lang.NewVector(lang.NewSymbol("type"), lang.NewSymbol("dim"), lang.NewSymbol("&"), lang.NewSymbol("more-dims"))), lang.NewKeyword("doc"), "Creates and returns an array of instances of the specified class of\n the specified dimension(s). Note that a class object is required.\n Class objects can be obtained by using their imported or\n fully-qualified name. Class objects for the primitive types can be\n obtained using, e.g., Integer/TYPE.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3985), lang.NewKeyword("end-line"), int(3985))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("int")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v4}) -v9, _ := lang.FieldOrMethod(nil, "newInstance") -if reflect.TypeOf(v9).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("newInstance is not a function"))) -} -v10 := lang.Apply(v9, []any{v3, v8}) -return v10 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("cons")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v4, v5}) -var v6 any = v10 -_ = v6 -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("make-array")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15, ok := lang.FieldOrMethod(nil, "TYPE") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "TYPE"))) -} -var v16 any -switch reflect.TypeOf(v15).Kind() { -case reflect.Func: - v16 = lang.Apply(v15, nil) -default: - v16 = v15 -} -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("count")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v6}) -v21 := lang.Apply(v14, []any{v16, v20}) -var v11 any = v21 -_ = v11 -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("long")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("alength")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{v11}) -v31 := lang.Apply(v26, []any{v30}) -var v23 any = v31 -_ = v23 -var v33 any = int64(0) -_ = v33 -var v34 any -for { -var v35 any -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("<")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v33, v23}) -if lang.IsTruthy(v39) { -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("aset-int")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("nth")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.Apply(v45, []any{v6, v33}) -v47 := lang.Apply(v42, []any{v11, v33, v46}) -_ = v47 -v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v50 := v49.FindInternedVar(lang.NewSymbol("unchecked-inc")) -if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) -} -v51 := v50.Get() -v52 := lang.Apply(v51, []any{v33}) -var v48 any = v52 -v33 = v48 -continue -} else { -v35 = nil -} -v34 = v35 - break -} -_ = v34 -v23, _ := lang.FieldOrMethod(nil, "newInstance") -if reflect.TypeOf(v23).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("newInstance is not a function"))) -} -v24 := lang.Apply(v23, []any{v3, v11}) -return v24 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// make-hierarchy -{ -v0 := lang.NewSymbol("make-hierarchy").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Creates a hierarchy object for use with derive, isa? etc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5507), lang.NewKeyword("end-line"), int(5507))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewMap() -v4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5511), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(5511), lang.NewKeyword("end-column"), int(17)) -v5, err := lang.WithMeta(v3, v4.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v6 := lang.NewMap() -v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5511), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(5511), lang.NewKeyword("end-column"), int(33)) -v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v9 := lang.NewMap() -v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5511), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(5511), lang.NewKeyword("end-column"), int(47)) -v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v12 := lang.NewMap(lang.NewKeyword("parents"), v5, lang.NewKeyword("descendants"), v8, lang.NewKeyword("ancestors"), v11) -v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5511), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(5511), lang.NewKeyword("end-column"), int(48)) -v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v14 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// map -{ -v0 := lang.NewSymbol("map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2"), lang.NewSymbol("c3")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2"), lang.NewSymbol("c3"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Returns a lazy sequence consisting of the result of applying f to\n the set of first items of each coll, followed by applying f to the\n set of second items in each coll, until any one of the colls is\n exhausted. Any remaining items in other colls are ignored. Function\n f should accept number-of-colls arguments. Returns a transducer when\n no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2719), lang.NewKeyword("end-line"), int(2719))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := args[0] -var v6 lang.FnFunc -v6 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v7 := lang.Apply(v5, nil) -return v7 - case 1: -v7 := args[0] -v8 := lang.Apply(v5, []any{v7}) -return v8 - case 2: -v7 := args[0] -v8 := args[1] -v9 := lang.Apply(v3, []any{v8}) -v10 := lang.Apply(v5, []any{v7, v9}) -return v10 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v7 := args[0] -v8 := args[1] -v9 := lang.NewList(args[2:]...) -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("apply")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{v3, v8, v9}) -v14 := lang.Apply(v5, []any{v7, v13}) -return v14 - } -}) -v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2730), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(2736), lang.NewKeyword("end-column"), int(47)) -v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v8 -}) -v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2729), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2736), lang.NewKeyword("end-column"), int(48)) -v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v6 - case 2: -v3 := args[0] -v4 := args[1] -var v5 lang.FnFunc -v5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("seq")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v4}) -var v6 any = v10 -_ = v6 -var v12 any -if lang.IsTruthy(v6) { -var v13 any = v6 -_ = v13 -var v15 any -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("chunked-seq?")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v13}) -if lang.IsTruthy(v19) { -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("chunk-first")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v13}) -var v20 any = v24 -_ = v20 -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("int")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("count")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.Apply(v31, []any{v20}) -v33 := lang.Apply(v28, []any{v32}) -var v25 any = v33 -_ = v25 -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("chunk-buffer")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v25}) -var v34 any = v38 -_ = v34 -v41 := lang.Apply(lang.LongCast, []any{v25}) -var v40 any = v41 -_ = v40 -var v43 any = int64(0) -_ = v43 -var v44 any -for { -var v45 any -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("<")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) -} -v48 := v47.Get() -v49 := lang.Apply(v48, []any{v43, v40}) -if lang.IsTruthy(v49) { -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("chunk-append")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53, _ := lang.FieldOrMethod(v20, "nth") -if reflect.TypeOf(v53).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) -} -v54 := lang.Apply(v53, []any{v43}) -v55 := lang.Apply(v3, []any{v54}) -v56 := lang.Apply(v52, []any{v34, v55}) -_ = v56 -v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v59 := v58.FindInternedVar(lang.NewSymbol("unchecked-inc")) -if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) -} -v60 := v59.Get() -v61 := lang.Apply(v60, []any{v43}) -var v57 any = v61 -v43 = v57 -continue -} else { -v45 = nil -} -v44 = v45 - break -} -_ = v44 -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("chunk-cons")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("chunk")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.Apply(v45, []any{v34}) -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("map")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) -} -v49 := v48.Get() -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("chunk-rest")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.Apply(v52, []any{v13}) -v54 := lang.Apply(v49, []any{v3, v53}) -v55 := lang.Apply(v42, []any{v46, v54}) -v15 = v55 -} else { -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("cons")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("first")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{v13}) -v27 := lang.Apply(v3, []any{v26}) -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("map")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("rest")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v13}) -v35 := lang.Apply(v30, []any{v3, v34}) -v36 := lang.Apply(v22, []any{v27, v35}) -v15 = v36 -} -v12 = v15 -} else { -v12 = nil -} -return v12 -}) -v6 := lang.Apply(lang.NewLazySeq, []any{v5}) -return v6 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -var v6 lang.FnFunc -v6 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("seq")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v4}) -var v7 any = v11 -_ = v7 -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("seq")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v5}) -var v12 any = v16 -_ = v12 -var v18 any -var v19 any = v7 -_ = v19 -var v21 any -if lang.IsTruthy(v19) { -v21 = v12 -} else { -v21 = v19 -} -if lang.IsTruthy(v21) { -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("cons")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("first")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v7}) -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("first")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.Apply(v28, []any{v12}) -v30 := lang.Apply(v3, []any{v25, v29}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("map")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("rest")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.Apply(v36, []any{v7}) -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("rest")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.Apply(v40, []any{v12}) -v42 := lang.Apply(v33, []any{v3, v37, v41}) -v43 := lang.Apply(v21, []any{v30, v42}) -v18 = v43 -} else { -v18 = nil -} -return v18 -}) -v7 := lang.Apply(lang.NewLazySeq, []any{v6}) -return v7 - case 4: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -var v7 lang.FnFunc -v7 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("seq")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v4}) -var v8 any = v12 -_ = v8 -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("seq")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v5}) -var v13 any = v17 -_ = v13 -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("seq")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v6}) -var v18 any = v22 -_ = v18 -var v24 any -var v25 any = v8 -_ = v25 -var v27 any -if lang.IsTruthy(v25) { -var v28 any = v13 -_ = v28 -var v30 any -if lang.IsTruthy(v28) { -v30 = v18 -} else { -v30 = v28 -} -v27 = v30 -} else { -v27 = v25 -} -if lang.IsTruthy(v27) { -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("cons")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("first")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{v8}) -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("first")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v13}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("first")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v18}) -v40 := lang.Apply(v3, []any{v31, v35, v39}) -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("map")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("rest")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v8}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("rest")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v13}) -v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("rest")) -if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) -} -v54 := v53.Get() -v55 := lang.Apply(v54, []any{v18}) -v56 := lang.Apply(v43, []any{v3, v47, v51, v55}) -v57 := lang.Apply(v27, []any{v40, v56}) -v24 = v57 -} else { -v24 = nil -} -return v24 -}) -v8 := lang.Apply(lang.NewLazySeq, []any{v7}) -return v8 - default: - if len(args) < 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := lang.NewList(args[4:]...) -var v9 lang.FnFunc -{ // function step -v9 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v11 := args[0] -var v12 lang.FnFunc -v12 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("map")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v16, []any{v19, v11}) -var v13 any = v20 -_ = v13 -var v22 any -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("every?")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("identity")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.Apply(v25, []any{v28, v13}) -if lang.IsTruthy(v29) { -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("cons")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("map")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("first")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v35, []any{v38, v13}) -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("map")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("rest")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.Apply(v42, []any{v45, v13}) -v47 := lang.Apply(v10, []any{v46}) -v48 := lang.Apply(v32, []any{v39, v47}) -v22 = v48 -} else { -v22 = nil -} -return v22 -}) -v13 := lang.Apply(lang.NewLazySeq, []any{v12}) -return v13 -}) -v10 := v9 -_ = v10 -} -v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2761), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(2765), lang.NewKeyword("end-column"), int(68)) -v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v8 any = v11 -_ = v8 -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("map")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -var v16 lang.FnFunc -v16 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v17 := args[0] -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("apply")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v20, []any{v3, v17}) -return v21 -}) -v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2766), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(2766), lang.NewKeyword("end-column"), int(22)) -v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("conj")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v7, v6, v5, v4}) -v23 := lang.Apply(v8, []any{v22}) -v24 := lang.Apply(v15, []any{v18, v23}) -return v24 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// map-entry? -{ -v0 := lang.NewSymbol("map-entry?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a map entry", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.8", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1473), lang.NewKeyword("end-line"), int(1473))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{lang.MapEntry, v3}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// map-indexed -{ -v0 := lang.NewSymbol("map-indexed").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence consisting of the result of applying f to 0\n and the first item of coll, followed by applying f to 1 and the second\n item in coll, etc, until coll is exhausted. Thus function f should\n accept 2 arguments, index and item. Returns a stateful transducer when\n no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7309), lang.NewKeyword("end-line"), int(7309))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := args[0] -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("volatile!")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{int64(-1)}) -var v6 any = v10 -_ = v6 -var v12 lang.FnFunc -v12 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v13 := lang.Apply(v5, nil) -return v13 - case 1: -v13 := args[0] -v14 := lang.Apply(v5, []any{v13}) -return v14 - case 2: -v13 := args[0] -v14 := args[1] -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("inc")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18, ok := lang.FieldOrMethod(v6, "Deref") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "Deref"))) -} -var v19 any -switch reflect.TypeOf(v18).Kind() { -case reflect.Func: - v19 = lang.Apply(v18, nil) -default: - v19 = v18 -} -v20 := lang.Apply(v17, []any{v19}) -v21, _ := lang.FieldOrMethod(v6, "reset") -if reflect.TypeOf(v21).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) -} -v22 := lang.Apply(v21, []any{v20}) -v23 := lang.Apply(v3, []any{v22, v14}) -v24 := lang.Apply(v5, []any{v13, v23}) -return v24 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7320), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7324), lang.NewKeyword("end-column"), int(48)) -v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v14 -}) -v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7318), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7324), lang.NewKeyword("end-column"), int(50)) -v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v6 - case 2: -v3 := args[0] -v4 := args[1] -return nil - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// map? -{ -v0 := lang.NewSymbol("map?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x implements IPersistentMap", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(167), lang.NewKeyword("end-line"), int(171))).(*lang.Symbol) -var v2 lang.FnFunc -{ // function map? -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{lang.IPersistentMap, v4}) -return v8 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(171), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(171), lang.NewKeyword("end-column"), int(97))).(lang.FnFunc) -v3 := v2 -_ = v3 -} -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// mapcat -{ -v0 := lang.NewSymbol("mapcat").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Returns the result of applying concat to the result of applying map\n to f and colls. Thus function f should return a collection. Returns\n a transducer when no collections are provided", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2775), lang.NewKeyword("end-line"), int(2775))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("comp")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("map")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v3}) -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("cat")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v6, []any{v10, v13}) -return v14 - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.NewList(args[1:]...) -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("apply")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("concat")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("apply")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("map")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v13, []any{v16, v3, v4}) -v18 := lang.Apply(v7, []any{v10, v17}) -return v18 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// mapv -{ -v0 := lang.NewSymbol("mapv").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2"), lang.NewSymbol("c3")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2"), lang.NewSymbol("c3"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Returns a vector consisting of the result of applying f to the\n set of first items of each coll, followed by applying f to the set\n of second items in each coll, until any one of the colls is\n exhausted. Any remaining items in other colls are ignored. Function\n f should accept number-of-colls arguments.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6943), lang.NewKeyword("end-line"), int(6943))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("persistent!")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("reduce")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -var v11 lang.FnFunc -v11 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v12 := args[0] -v13 := args[1] -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("conj!")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v3, []any{v13}) -v18 := lang.Apply(v16, []any{v12, v17}) -return v18 -}) -v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6952), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(6952), lang.NewKeyword("end-column"), int(43)) -v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("transient")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.NewVector() -v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6952), lang.NewKeyword("column"), int(56), lang.NewKeyword("end-line"), int(6952), lang.NewKeyword("end-column"), int(57)) -v19, err := lang.WithMeta(v17, v18.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v20 := lang.Apply(v16, []any{v19}) -v21 := lang.Apply(v10, []any{v13, v20, v4}) -v22 := lang.Apply(v7, []any{v21}) -return v22 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("into")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.NewVector() -v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6955), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(6955), lang.NewKeyword("end-column"), int(13)) -v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("map")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v3, v4, v5}) -v16 := lang.Apply(v8, []any{v11, v15}) -return v16 - case 4: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("into")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.NewVector() -v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6957), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(6957), lang.NewKeyword("end-column"), int(13)) -v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("map")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v3, v4, v5, v6}) -v17 := lang.Apply(v9, []any{v12, v16}) -return v17 - default: - if len(args) < 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := lang.NewList(args[4:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("into")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.NewVector() -v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6959), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(6959), lang.NewKeyword("end-column"), int(13)) -v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("apply")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("map")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v16, []any{v19, v3, v4, v5, v6, v7}) -v21 := lang.Apply(v10, []any{v13, v20}) -return v21 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// max -{ -var v1 lang.FnFunc -v1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v2 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -if lang.IsTruthy(v7) { -v4 = closed11 -} else { -v4 = v3 -} -var v3 any = v4 -_ = v3 -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("seq")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("concat")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("seq")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("concat")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v2}) -v40 := lang.Apply(v31, []any{v35, v39}) -v41 := lang.Apply(v28, []any{v40}) -v42 := lang.Apply(v25, []any{v41}) -v43 := lang.Apply(v14, []any{v18, v22, v42}) -v44 := lang.Apply(v11, []any{v43}) -return v44 - case 2: -v2 := args[0] -v3 := args[1] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -if lang.IsTruthy(v8) { -v5 = closed11 -} else { -v5 = v4 -} -var v4 any = v5 -_ = v4 -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("seq")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("concat")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("list")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("list")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("list")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("seq")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("concat")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("list")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v4}) -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("list")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v2}) -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("list")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v3}) -v45 := lang.Apply(v32, []any{v36, v40, v44}) -v46 := lang.Apply(v29, []any{v45}) -v47 := lang.Apply(v26, []any{v46}) -v48 := lang.Apply(v15, []any{v19, v23, v47}) -v49 := lang.Apply(v12, []any{v48}) -return v49 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v2 := args[0] -v3 := args[1] -v4 := lang.NewList(args[2:]...) -var v6 any -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -if lang.IsTruthy(v9) { -v6 = closed11 -} else { -v6 = v5 -} -var v5 any = v6 -_ = v5 -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -var v14 lang.FnFunc -v14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v15 := args[0] -v16 := args[1] -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("concat")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v5}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v15}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v16}) -v52 := lang.Apply(v39, []any{v43, v47, v51}) -v53 := lang.Apply(v36, []any{v52}) -v54 := lang.Apply(v33, []any{v53}) -v55 := lang.Apply(v22, []any{v26, v30, v54}) -v56 := lang.Apply(v19, []any{v55}) -return v56 -}) -v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) -v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("concat")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v5}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v2}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v3}) -v52 := lang.Apply(v39, []any{v43, v47, v51}) -v53 := lang.Apply(v36, []any{v52}) -v54 := lang.Apply(v33, []any{v53}) -v55 := lang.Apply(v22, []any{v26, v30, v54}) -v56 := lang.Apply(v19, []any{v55}) -v57 := lang.Apply(v13, []any{v16, v56, v4}) -return v57 - } -}) -v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) -} -v5 := lang.Apply(v4, []any{v3, int64(1)}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v0 := lang.NewSymbol("max").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the greatest of the nums.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1108), lang.NewKeyword("end-line"), int(1108))).(*lang.Symbol) -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v5 := args[0] -return v5 - case 2: -v5 := args[0] -v6 := args[1] -v7, _ := lang.FieldOrMethod(lang.Numbers, "max") -if reflect.TypeOf(v7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("max is not a function"))) -} -v8 := lang.Apply(v7, []any{v5, v6}) -return v8 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := args[0] -v6 := args[1] -v7 := lang.NewList(args[2:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("max")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("max")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v5, v6}) -v18 := lang.Apply(v10, []any{v13, v17, v7}) -return v18 - } -}) -v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v3 := ns.InternWithValue(v0, v4, true) -if v0.Meta() != nil { - v3.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// max-key -{ -v0 := lang.NewSymbol("max-key").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Returns the x for which (k x), a number, is greatest.\n\n If there are multiple such xs, the last one is returned.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5013), lang.NewKeyword("end-line"), int(5013))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v3 := args[0] -v4 := args[1] -return v4 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -var v6 any -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol(">")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v3, []any{v4}) -v11 := lang.Apply(v3, []any{v5}) -v12 := lang.Apply(v9, []any{v10, v11}) -if lang.IsTruthy(v12) { -v6 = v4 -} else { -v6 = v5 -} -return v6 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v8 := lang.Apply(v3, []any{v4}) -var v7 any = v8 -_ = v7 -v10 := lang.Apply(v3, []any{v5}) -var v9 any = v10 -_ = v9 -var v12 any -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol(">")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v7, v9}) -if lang.IsTruthy(v16) { -v17 := lang.NewVector(v4, v7) -v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5023), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(5023), lang.NewKeyword("end-column"), int(36)) -v19, err := lang.WithMeta(v17, v18.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v12 = v19 -} else { -v20 := lang.NewVector(v5, v9) -v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5023), lang.NewKeyword("column"), int(38), lang.NewKeyword("end-line"), int(5023), lang.NewKeyword("end-column"), int(43)) -v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v12 = v22 -} -var v11 any = v12 -_ = v11 -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("nth")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v11, int64(0), nil}) -var v23 any = v27 -_ = v23 -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("nth")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.Apply(v31, []any{v11, int64(1), nil}) -var v28 any = v32 -_ = v28 -var v34 any = v34 -_ = v34 -var v35 any = v35 -_ = v35 -var v36 any = v36 -_ = v36 -var v37 any -for { -var v38 any -if lang.IsTruthy(v36) { -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("first")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v36}) -var v39 any = v43 -_ = v39 -v45 := lang.Apply(v3, []any{v39}) -var v44 any = v45 -_ = v44 -var v47 any -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol(">=")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v44, v35}) -if lang.IsTruthy(v51) { -var v52 any = v39 -var v53 any = v44 -v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v56 := v55.FindInternedVar(lang.NewSymbol("next")) -if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) -} -v57 := v56.Get() -v58 := lang.Apply(v57, []any{v36}) -var v54 any = v58 -v34 = v52 -v35 = v53 -v36 = v54 -continue -} else { -var v59 any = v34 -var v60 any = v35 -v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v63 := v62.FindInternedVar(lang.NewSymbol("next")) -if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) -} -v64 := v63.Get() -v65 := lang.Apply(v64, []any{v36}) -var v61 any = v65 -v34 = v59 -v35 = v60 -v36 = v61 -continue -} -v38 = v47 -} else { -v38 = v34 -} -v37 = v38 - break -} -return v37 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// max-mask-bits -{ -v0 := lang.NewSymbol("max-mask-bits").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6601), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(6601), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, int64(13), true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// max-switch-table-size -{ -v0 := lang.NewSymbol("max-switch-table-size").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6602), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(6602), lang.NewKeyword("end-column"), int(36), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, int64(8192), true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// maybe-destructured -{ -v0 := lang.NewSymbol("maybe-destructured").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4514), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(4515), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("params"), lang.NewSymbol("body"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("every?")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("symbol?")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v8, []any{v11, v3}) -if lang.IsTruthy(v12) { -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("cons")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v3, v4}) -v5 = v16 -} else { -var v17 any = v17 -_ = v17 -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("with-meta")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.NewVector() -v23 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4520), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(4520), lang.NewKeyword("end-column"), int(35)) -v24, err := lang.WithMeta(v22, v23.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("meta")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.Apply(v27, []any{v17}) -v29 := lang.Apply(v21, []any{v24, v28}) -var v18 any = v29 -_ = v18 -v31 := lang.NewVector() -v32 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4521), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(4521), lang.NewKeyword("end-column"), int(18)) -v33, err := lang.WithMeta(v31, v32.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v30 any = v33 -_ = v30 -var v34 any -for { -var v35 any -if lang.IsTruthy(v17) { -var v36 any -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("symbol?")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("first")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v17}) -v44 := lang.Apply(v39, []any{v43}) -if lang.IsTruthy(v44) { -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("next")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) -} -v48 := v47.Get() -v49 := lang.Apply(v48, []any{v17}) -var v45 any = v49 -v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v52 := v51.FindInternedVar(lang.NewSymbol("conj")) -if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) -} -v53 := v52.Get() -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("first")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) -} -v56 := v55.Get() -v57 := lang.Apply(v56, []any{v17}) -v58 := lang.Apply(v53, []any{v18, v57}) -var v50 any = v58 -var v59 any = v30 -v17 = v45 -v18 = v50 -v30 = v59 -continue -} else { -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("gensym")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) -} -v63 := v62.Get() -v64 := lang.Apply(v63, []any{"p__"}) -var v60 any = v64 -_ = v60 -v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v68 := v67.FindInternedVar(lang.NewSymbol("next")) -if v68.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) -} -v69 := v68.Get() -v70 := lang.Apply(v69, []any{v17}) -var v66 any = v70 -v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v73 := v72.FindInternedVar(lang.NewSymbol("conj")) -if v73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) -} -v74 := v73.Get() -v75 := lang.Apply(v74, []any{v18, v60}) -var v71 any = v75 -v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v78 := v77.FindInternedVar(lang.NewSymbol("conj")) -if v78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) -} -v79 := v78.Get() -v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v81 := v80.FindInternedVar(lang.NewSymbol("conj")) -if v81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) -} -v82 := v81.Get() -v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v84 := v83.FindInternedVar(lang.NewSymbol("first")) -if v84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) -} -v85 := v84.Get() -v86 := lang.Apply(v85, []any{v17}) -v87 := lang.Apply(v82, []any{v30, v86}) -v88 := lang.Apply(v79, []any{v87, v60}) -var v76 any = v88 -v17 = v66 -v18 = v71 -v30 = v76 -continue -} -v35 = v36 -} else { -v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v61 := v60.FindInternedVar(lang.NewSymbol("seq")) -if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) -} -v62 := v61.Get() -v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v64 := v63.FindInternedVar(lang.NewSymbol("concat")) -if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) -} -v65 := v64.Get() -v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v67 := v66.FindInternedVar(lang.NewSymbol("list")) -if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) -} -v68 := v67.Get() -v69 := lang.Apply(v68, []any{v18}) -v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v71 := v70.FindInternedVar(lang.NewSymbol("list")) -if v71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) -} -v72 := v71.Get() -v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v74 := v73.FindInternedVar(lang.NewSymbol("seq")) -if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) -} -v75 := v74.Get() -v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v77 := v76.FindInternedVar(lang.NewSymbol("concat")) -if v77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) -} -v78 := v77.Get() -v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v80 := v79.FindInternedVar(lang.NewSymbol("list")) -if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) -} -v81 := v80.Get() -v82 := lang.Apply(v81, []any{lang.NewSymbol("glojure.core/let")}) -v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v84 := v83.FindInternedVar(lang.NewSymbol("list")) -if v84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) -} -v85 := v84.Get() -v86 := lang.Apply(v85, []any{v30}) -v87 := lang.Apply(v78, []any{v82, v86, v4}) -v88 := lang.Apply(v75, []any{v87}) -v89 := lang.Apply(v72, []any{v88}) -v90 := lang.Apply(v65, []any{v69, v89}) -v91 := lang.Apply(v62, []any{v90}) -v35 = v91 -} -v34 = v35 - break -} -v5 = v34 -} -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// maybe-min-hash -{ -v0 := lang.NewSymbol("maybe-min-hash").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("hashes"))), lang.NewKeyword("doc"), "takes a collection of hashes and returns [shift mask] or nil if none found", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6604), lang.NewKeyword("end-line"), int(6604), lang.NewKeyword("private"), true)).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("first")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("filter")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -var v10 lang.FnFunc -v10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v11 := args[0] -var v12 any = v11 -_ = v12 -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("nth")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v12, int64(0), nil}) -var v13 any = v17 -_ = v13 -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("nth")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v12, int64(1), nil}) -var v18 any = v22 -_ = v18 -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("apply")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("distinct?")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("map")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -var v33 lang.FnFunc -v33 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v34 := args[0] -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("shift-mask")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v13, v18, v34}) -return v38 -}) -v34 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6609), lang.NewKeyword("column"), int(37), lang.NewKeyword("end-line"), int(6609), lang.NewKeyword("end-column"), int(55)) -v35, err := lang.WithMeta(v33, v34.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v36 := lang.Apply(v32, []any{v35, v3}) -v37 := lang.Apply(v26, []any{v29, v36}) -return v37 -}) -v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6608), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(6609), lang.NewKeyword("end-column"), int(65)) -v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v14 lang.FnFunc -{ // function iter__154 -v14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v16 := args[0] -var v17 lang.FnFunc -v17 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -var v18 any = v18 -_ = v18 -var v19 any -for { -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v18}) -var v20 any = v24 -_ = v20 -var v26 any -if lang.IsTruthy(v20) { -var v27 any = v20 -_ = v27 -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("first")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.Apply(v32, []any{v27}) -var v29 any = v33 -_ = v29 -var v36 lang.FnFunc -{ // function iter__156 -v36 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v38 := args[0] -var v39 lang.FnFunc -v39 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -var v40 any = v40 -_ = v40 -var v41 any -for { -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("seq")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.Apply(v45, []any{v40}) -var v42 any = v46 -_ = v42 -var v48 any -if lang.IsTruthy(v42) { -var v49 any = v42 -_ = v49 -var v51 any -v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("chunked-seq?")) -if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) -} -v54 := v53.Get() -v55 := lang.Apply(v54, []any{v49}) -if lang.IsTruthy(v55) { -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("chunk-first")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) -} -v59 := v58.Get() -v60 := lang.Apply(v59, []any{v49}) -var v56 any = v60 -_ = v56 -v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v63 := v62.FindInternedVar(lang.NewSymbol("int")) -if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) -} -v64 := v63.Get() -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("count")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) -} -v67 := v66.Get() -v68 := lang.Apply(v67, []any{v56}) -v69 := lang.Apply(v64, []any{v68}) -var v61 any = v69 -_ = v61 -v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v72 := v71.FindInternedVar(lang.NewSymbol("chunk-buffer")) -if v72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) -} -v73 := v72.Get() -v74 := lang.Apply(v73, []any{v61}) -var v70 any = v74 -_ = v70 -var v76 any -v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v79 := v78.FindInternedVar(lang.NewSymbol("int")) -if v79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) -} -v80 := v79.Get() -v81 := lang.Apply(v80, []any{int64(0)}) -var v77 any = v81 -_ = v77 -var v82 any -for { -var v83 any -v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v85 := v84.FindInternedVar(lang.NewSymbol("<")) -if v85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) -} -v86 := v85.Get() -v87 := lang.Apply(v86, []any{v77, v61}) -if lang.IsTruthy(v87) { -v89, _ := lang.FieldOrMethod(v56, "nth") -if reflect.TypeOf(v89).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) -} -v90 := lang.Apply(v89, []any{v77}) -var v88 any = v90 -_ = v88 -v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v93 := v92.FindInternedVar(lang.NewSymbol("chunk-append")) -if v93.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) -} -v94 := v93.Get() -v95 := lang.NewVector(v88, v29) -v96 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6612), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(6612), lang.NewKeyword("end-column"), int(26)) -v97, err := lang.WithMeta(v95, v96.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v98 := lang.Apply(v94, []any{v70, v97}) -_ = v98 -v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v101 := v100.FindInternedVar(lang.NewSymbol("unchecked-inc")) -if v101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) -} -v102 := v101.Get() -v103 := lang.Apply(v102, []any{v77}) -var v99 any = v103 -v77 = v99 -continue -} else { -v83 = true -} -v82 = v83 - break -} -if lang.IsTruthy(v82) { -v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v78 := v77.FindInternedVar(lang.NewSymbol("chunk-cons")) -if v78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) -} -v79 := v78.Get() -v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v81 := v80.FindInternedVar(lang.NewSymbol("chunk")) -if v81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) -} -v82 := v81.Get() -v83 := lang.Apply(v82, []any{v70}) -v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v85 := v84.FindInternedVar(lang.NewSymbol("chunk-rest")) -if v85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) -} -v86 := v85.Get() -v87 := lang.Apply(v86, []any{v49}) -v88 := lang.Apply(v37, []any{v87}) -v89 := lang.Apply(v79, []any{v83, v88}) -v76 = v89 -} else { -v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v91 := v90.FindInternedVar(lang.NewSymbol("chunk-cons")) -if v91.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) -} -v92 := v91.Get() -v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v94 := v93.FindInternedVar(lang.NewSymbol("chunk")) -if v94.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) -} -v95 := v94.Get() -v96 := lang.Apply(v95, []any{v70}) -v97 := lang.Apply(v92, []any{v96, nil}) -v76 = v97 -} -v51 = v76 -} else { -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("first")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) -} -v59 := v58.Get() -v60 := lang.Apply(v59, []any{v49}) -var v56 any = v60 -_ = v56 -v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v63 := v62.FindInternedVar(lang.NewSymbol("cons")) -if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) -} -v64 := v63.Get() -v65 := lang.NewVector(v56, v29) -v66 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6612), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(6612), lang.NewKeyword("end-column"), int(26)) -v67, err := lang.WithMeta(v65, v66.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v69 := v68.FindInternedVar(lang.NewSymbol("rest")) -if v69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) -} -v70 := v69.Get() -v71 := lang.Apply(v70, []any{v49}) -v72 := lang.Apply(v37, []any{v71}) -v73 := lang.Apply(v64, []any{v67, v72}) -v51 = v73 -} -v48 = v51 -} else { -v48 = nil -} -v41 = v48 - break -} -return v41 -}) -v40 := lang.Apply(lang.NewLazySeq, []any{v39}) -return v40 -}) -v37 := v36 -_ = v37 -} -var v35 any = v36 -_ = v35 -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("seq")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("range")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{int64(0), int64(31)}) -v45 := lang.Apply(v35, []any{v44}) -v46 := lang.Apply(v40, []any{v45}) -var v37 any = v46 -_ = v37 -var v48 any -if lang.IsTruthy(v37) { -v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v50 := v49.FindInternedVar(lang.NewSymbol("concat")) -if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) -} -v51 := v50.Get() -v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("rest")) -if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) -} -v54 := v53.Get() -v55 := lang.Apply(v54, []any{v18}) -v56 := lang.Apply(v15, []any{v55}) -v57 := lang.Apply(v51, []any{v37, v56}) -v48 = v57 -} else { -v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v60 := v59.FindInternedVar(lang.NewSymbol("rest")) -if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) -} -v61 := v60.Get() -v62 := lang.Apply(v61, []any{v18}) -var v58 any = v62 -v18 = v58 -continue -} -v26 = v48 -} else { -v26 = nil -} -v19 = v26 - break -} -return v19 -}) -v18 := lang.Apply(lang.NewLazySeq, []any{v17}) -return v18 -}) -v15 := v14 -_ = v15 -} -var v13 any = v14 -_ = v13 -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("map")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -var v19 lang.FnFunc -v19 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v20 := args[0] -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("dec")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("bit-shift-left")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v26, []any{int64(1), v20}) -v28 := lang.Apply(v23, []any{v27}) -return v28 -}) -v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6610), lang.NewKeyword("column"), int(29), lang.NewKeyword("end-line"), int(6610), lang.NewKeyword("end-column"), int(55)) -v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("range")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("inc")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("max-mask-bits")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v27, []any{v30}) -v32 := lang.Apply(v24, []any{int64(1), v31}) -v33 := lang.Apply(v18, []any{v21, v32}) -v34 := lang.Apply(v13, []any{v33}) -v13 := lang.Apply(v9, []any{v12, v34}) -v14 := lang.Apply(v6, []any{v13}) -return v14 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// memfn -{ -v0 := lang.NewSymbol("memfn").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Expands into code that creates a fn that expects to be passed an\n object and any args and calls the named instance method on the\n object passing the args. Use when you want to treat a Java method as\n a first-class fn. name may be type-hinted with the method receiver's\n type in order to avoid reflective calls.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3872), lang.NewKeyword("end-line"), int(3872))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("with-meta")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("gensym")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{"target"}) -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("meta")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v5}) -v19 := lang.Apply(v10, []any{v14, v18}) -var v7 any = v19 -_ = v7 -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/fn")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("apply")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("vector")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("seq")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("concat")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("list")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) -} -v48 := v47.Get() -v49 := lang.Apply(v48, []any{v7}) -v50 := lang.Apply(v45, []any{v49, v6}) -v51 := lang.Apply(v42, []any{v50}) -v52 := lang.Apply(v36, []any{v39, v51}) -v53 := lang.Apply(v33, []any{v52}) -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("list")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) -} -v56 := v55.Get() -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("seq")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) -} -v59 := v58.Get() -v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v61 := v60.FindInternedVar(lang.NewSymbol("concat")) -if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) -} -v62 := v61.Get() -v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v64 := v63.FindInternedVar(lang.NewSymbol("list")) -if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) -} -v65 := v64.Get() -v66 := lang.Apply(v65, []any{lang.NewSymbol(".")}) -v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v68 := v67.FindInternedVar(lang.NewSymbol("list")) -if v68.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) -} -v69 := v68.Get() -v70 := lang.Apply(v69, []any{v7}) -v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v72 := v71.FindInternedVar(lang.NewSymbol("list")) -if v72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) -} -v73 := v72.Get() -v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v75 := v74.FindInternedVar(lang.NewSymbol("seq")) -if v75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) -} -v76 := v75.Get() -v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v78 := v77.FindInternedVar(lang.NewSymbol("concat")) -if v78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) -} -v79 := v78.Get() -v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v81 := v80.FindInternedVar(lang.NewSymbol("list")) -if v81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) -} -v82 := v81.Get() -v83 := lang.Apply(v82, []any{v5}) -v84 := lang.Apply(v79, []any{v83, v6}) -v85 := lang.Apply(v76, []any{v84}) -v86 := lang.Apply(v73, []any{v85}) -v87 := lang.Apply(v62, []any{v66, v70, v86}) -v88 := lang.Apply(v59, []any{v87}) -v89 := lang.Apply(v56, []any{v88}) -v90 := lang.Apply(v26, []any{v30, v53, v89}) -v91 := lang.Apply(v23, []any{v90}) -return v91 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// memoize -{ -v0 := lang.NewSymbol("memoize").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Returns a memoized version of a referentially transparent function. The\n memoized version of the function keeps a cache of the mapping from arguments\n to results and, when calls with the same arguments are repeated often, has\n higher performance at the expense of higher memory use.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6337), lang.NewKeyword("end-line"), int(6337))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("atom")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.NewMap() -v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6345), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(6345), lang.NewKeyword("end-column"), int(20)) -v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v11 := lang.Apply(v7, []any{v10}) -var v4 any = v11 -_ = v4 -var v13 lang.FnFunc -v13 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v14 := lang.NewList(args[0:]...) -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("find")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("deref")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v4}) -v23 := lang.Apply(v18, []any{v22, v14}) -var v15 any = v23 -_ = v15 -var v25 any -if lang.IsTruthy(v15) { -var v26 any = v15 -_ = v26 -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("val")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{v26}) -v25 = v31 -} else { -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("apply")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{v3, v14}) -var v26 any = v30 -_ = v26 -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("swap!")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("assoc")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.Apply(v34, []any{v4, v37, v14, v26}) -_ = v38 -v25 = v26 -} -return v25 - } -}) -v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6346), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(6351), lang.NewKeyword("end-column"), int(16)) -v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v15 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// merge -{ -v0 := lang.NewSymbol("merge").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("maps"))), lang.NewKeyword("doc"), "Returns a map that consists of the rest of the maps conj-ed onto\n the first. If a key occurs in more than one map, the mapping from\n the latter (left-to-right) will be the mapping in the result.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3040), lang.NewKeyword("end-line"), int(3040))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewList(args[0:]...) -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("some")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("identity")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v7, []any{v10, v3}) -if lang.IsTruthy(v11) { -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("reduce1")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -var v15 lang.FnFunc -v15 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v16 := args[0] -v17 := args[1] -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("conj")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -var v21 any = v16 -_ = v21 -var v23 any -if lang.IsTruthy(v21) { -v23 = v21 -} else { -v24 := lang.NewMap() -v25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3048), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(3048), lang.NewKeyword("end-column"), int(29)) -v26, err := lang.WithMeta(v24, v25.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v23 = v26 -} -v21 := lang.Apply(v20, []any{v23, v17}) -return v21 -}) -v16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3048), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(3048), lang.NewKeyword("end-column"), int(34)) -v17, err := lang.WithMeta(v15, v16.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v18 := lang.Apply(v14, []any{v17, v3}) -v4 = v18 -} else { -v4 = nil -} -return v4 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// merge-hash-collisions -{ -v0 := lang.NewSymbol("merge-hash-collisions").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr-sym"), lang.NewSymbol("default"), lang.NewSymbol("tests"), lang.NewSymbol("thens"))), lang.NewKeyword("doc"), "Takes a case expression, default expression, and a sequence of test constants\n and a corresponding sequence of then expressions. Returns a tuple of\n [tests thens skip-check-set] where no tests have the same hash. Each set of\n input test constants with the same hash is replaced with a single test\n constant (the case int), and their respective thens are combined into:\n (condp = expr\n test-1 then-1\n ...\n test-n then-n\n default).\n The skip-check is a set of case ints for which post-switch equivalence\n checking must not be done (the cases holding the above condp thens).", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6647), lang.NewKeyword("end-line"), int(6647), lang.NewKeyword("private"), true)).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v9 := lang.NewMap() -v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6661), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(6661), lang.NewKeyword("end-column"), int(27)) -v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v8 any = v11 -_ = v8 -var v12 any = v5 -_ = v12 -var v13 any = v6 -_ = v13 -var v14 any -for { -var v15 any -var v16 any = v12 -_ = v16 -var v18 any -if lang.IsTruthy(v16) { -v18 = v13 -} else { -v18 = v16 -} -if lang.IsTruthy(v18) { -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("update")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("first")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.Apply(v22, []any{v12}) -v24 := lang.Apply(lang.Hash, []any{v23}) -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("fnil")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("conj")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.NewVector() -v32 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6664), lang.NewKeyword("column"), int(102), lang.NewKeyword("end-line"), int(6664), lang.NewKeyword("end-column"), int(103)) -v33, err := lang.WithMeta(v31, v32.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v34 := lang.Apply(v27, []any{v30, v33}) -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("first")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v12}) -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("first")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) -} -v41 := v40.Get() -v42 := lang.Apply(v41, []any{v13}) -v43 := lang.NewVector(v38, v42) -v44 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6664), lang.NewKeyword("column"), int(106), lang.NewKeyword("end-line"), int(6664), lang.NewKeyword("end-column"), int(128)) -v45, err := lang.WithMeta(v43, v44.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v46 := lang.Apply(v19, []any{v8, v24, v34, v45}) -var v16 any = v46 -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("next")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v12}) -var v47 any = v51 -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("next")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) -} -v55 := v54.Get() -v56 := lang.Apply(v55, []any{v13}) -var v52 any = v56 -v8 = v16 -v12 = v47 -v13 = v52 -continue -} else { -v15 = v8 -} -v14 = v15 - break -} -var v7 any = v14 -_ = v7 -var v9 lang.FnFunc -v9 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v10 := args[0] -v11 := args[1] -v12 := args[2] -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("mapcat")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -var v17 lang.FnFunc -v17 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v18 := args[0] -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("first")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v18}) -v26 := lang.Apply(v21, []any{lang.NewSymbol("quote"), v25}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("second")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{v18}) -v31 := lang.NewVector(v26, v30) -v32 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6668), lang.NewKeyword("column"), int(56), lang.NewKeyword("end-line"), int(6668), lang.NewKeyword("end-column"), int(93)) -v33, err := lang.WithMeta(v31, v32.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v33 -}) -v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6668), lang.NewKeyword("column"), int(47), lang.NewKeyword("end-line"), int(6668), lang.NewKeyword("end-column"), int(94)) -v19, err := lang.WithMeta(v17, v18.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v20 := lang.Apply(v16, []any{v19, v12}) -var v13 any = v20 -_ = v13 -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("seq")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("concat")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("list")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/condp")}) -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{lang.NewSymbol("glojure.core/=")}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v3}) -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v4}) -v44 := lang.Apply(v27, []any{v31, v35, v39, v13, v43}) -v45 := lang.Apply(v24, []any{v44}) -var v21 any = v45 -_ = v21 -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("assoc")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) -} -v49 := v48.Get() -v50 := lang.Apply(v49, []any{v10, v11, v21}) -return v50 -}) -v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6667), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(6670), lang.NewKeyword("end-column"), int(42)) -v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v8 any = v11 -_ = v8 -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("reduce1")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -var v16 lang.FnFunc -v16 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v17 := args[0] -v18 := args[1] -var v19 any = v18 -_ = v19 -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("nth")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v19, int64(0), nil}) -var v20 any = v24 -_ = v20 -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("nth")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.Apply(v28, []any{v19, int64(1), nil}) -var v25 any = v29 -_ = v25 -var v31 any -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("==")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("count")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v25}) -v39 := lang.Apply(v34, []any{int64(1), v38}) -if lang.IsTruthy(v39) { -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("assoc")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("ffirst")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.Apply(v45, []any{v25}) -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("second")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) -} -v49 := v48.Get() -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("first")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.Apply(v52, []any{v25}) -v54 := lang.Apply(v49, []any{v53}) -v55 := lang.Apply(v42, []any{v17, v46, v54}) -v31 = v55 -} else { -v56 := lang.Apply(v8, []any{v17, v20, v25}) -v31 = v56 -} -return v31 -}) -v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6672), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(6675), lang.NewKeyword("end-column"), int(45)) -v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v19 := lang.NewMap() -v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6676), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(6676), lang.NewKeyword("end-column"), int(17)) -v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v22 := lang.Apply(v15, []any{v18, v21, v7}) -var v12 any = v22 -_ = v12 -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("into1")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.CreatePersistentTreeSet() -v28 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6680), lang.NewKeyword("column"), int(29), lang.NewKeyword("end-line"), int(6680), lang.NewKeyword("end-column"), int(31)) -v29, err := lang.WithMeta(v27, v28.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("map")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("first")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("filter")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -var v39 lang.FnFunc -v39 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v40 := args[0] -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("<")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("count")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("second")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) -} -v49 := v48.Get() -v50 := lang.Apply(v49, []any{v40}) -v51 := lang.Apply(v46, []any{v50}) -v52 := lang.Apply(v43, []any{int64(1), v51}) -return v52 -}) -v40 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6678), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(6678), lang.NewKeyword("end-column"), int(54)) -v41, err := lang.WithMeta(v39, v40.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v42 := lang.Apply(v38, []any{v41, v7}) -v43 := lang.Apply(v32, []any{v35, v42}) -v44 := lang.Apply(v26, []any{v29, v43}) -var v23 any = v44 -_ = v23 -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("keys")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) -} -v48 := v47.Get() -v49 := lang.Apply(v48, []any{v12}) -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("vals")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.Apply(v52, []any{v12}) -v54 := lang.NewVector(v49, v53, v23) -v55 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6681), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(6681), lang.NewKeyword("end-column"), int(40)) -v56, err := lang.WithMeta(v54, v55.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v56 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// merge-with -{ -v0 := lang.NewSymbol("merge-with").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("maps"))), lang.NewKeyword("doc"), "Returns a map that consists of the rest of the maps conj-ed onto\n the first. If a key occurs in more than one map, the mapping(s)\n from the latter (left-to-right) will be combined with the mapping in\n the result by calling (f val-in-result val-in-latter).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3050), lang.NewKeyword("end-line"), int(3050))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.NewList(args[1:]...) -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("some")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("identity")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v8, []any{v11, v4}) -if lang.IsTruthy(v12) { -var v14 lang.FnFunc -v14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v15 := args[0] -v16 := args[1] -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("key")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v20, []any{v16}) -var v17 any = v21 -_ = v17 -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("val")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{v16}) -var v22 any = v26 -_ = v22 -var v28 any -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("contains?")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.Apply(v31, []any{v15, v17}) -if lang.IsTruthy(v32) { -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("assoc")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("get")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v15, v17}) -v40 := lang.Apply(v3, []any{v39, v22}) -v41 := lang.Apply(v35, []any{v15, v17, v40}) -v28 = v41 -} else { -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("assoc")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) -} -v44 := v43.Get() -v45 := lang.Apply(v44, []any{v15, v17, v22}) -v28 = v45 -} -return v28 -}) -v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3059), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(3063), lang.NewKeyword("end-column"), int(23)) -v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v13 any = v16 -_ = v13 -var v18 lang.FnFunc -v18 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v19 := args[0] -v20 := args[1] -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("reduce1")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -var v24 any = v19 -_ = v24 -var v26 any -if lang.IsTruthy(v24) { -v26 = v24 -} else { -v27 := lang.NewMap() -v28 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3065), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(3065), lang.NewKeyword("end-column"), int(35)) -v29, err := lang.WithMeta(v27, v28.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v26 = v29 -} -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("seq")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v20}) -v28 := lang.Apply(v23, []any{v13, v26, v27}) -return v28 -}) -v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3064), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(3065), lang.NewKeyword("end-column"), int(47)) -v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v17 any = v20 -_ = v17 -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("reduce1")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v17, v4}) -v5 = v25 -} else { -v5 = nil -} -return v5 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// meta -{ -v0 := lang.NewSymbol("meta").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("obj"))), lang.NewKeyword("doc"), "Returns the metadata of obj, returns nil if there is no metadata.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(202), lang.NewKeyword("end-line"), int(206))).(*lang.Symbol) -var v2 lang.FnFunc -{ // function meta -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{lang.IMeta, v4}) -if lang.IsTruthy(v9) { -v10, ok := lang.FieldOrMethod(v4, "Meta") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "Meta"))) -} -var v11 any -switch reflect.TypeOf(v10).Kind() { -case reflect.Func: - v11 = lang.Apply(v10, nil) -default: - v11 = v10 -} -v5 = v11 -} else { -v5 = nil -} -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(206), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(208), lang.NewKeyword("end-column"), int(21))).(lang.FnFunc) -v3 := v2 -_ = v3 -} -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// methods -{ -v0 := lang.NewSymbol("methods").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"))), lang.NewKeyword("doc"), "Given a multimethod, returns a map of dispatch values -> dispatch fns", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1809), lang.NewKeyword("end-line"), int(1809))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, ok := lang.FieldOrMethod(v3, "getMethodTable") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getMethodTable"))) -} -var v5 any -switch reflect.TypeOf(v4).Kind() { -case reflect.Func: - v5 = lang.Apply(v4, nil) -default: - v5 = v4 -} -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// min -{ -var v1 lang.FnFunc -v1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v2 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -if lang.IsTruthy(v7) { -v4 = closed12 -} else { -v4 = v3 -} -var v3 any = v4 -_ = v3 -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("seq")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("concat")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("seq")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("concat")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v2}) -v40 := lang.Apply(v31, []any{v35, v39}) -v41 := lang.Apply(v28, []any{v40}) -v42 := lang.Apply(v25, []any{v41}) -v43 := lang.Apply(v14, []any{v18, v22, v42}) -v44 := lang.Apply(v11, []any{v43}) -return v44 - case 2: -v2 := args[0] -v3 := args[1] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -if lang.IsTruthy(v8) { -v5 = closed12 -} else { -v5 = v4 -} -var v4 any = v5 -_ = v4 -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("seq")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("concat")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("list")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("list")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("list")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("seq")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("concat")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("list")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v4}) -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("list")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v2}) -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("list")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v3}) -v45 := lang.Apply(v32, []any{v36, v40, v44}) -v46 := lang.Apply(v29, []any{v45}) -v47 := lang.Apply(v26, []any{v46}) -v48 := lang.Apply(v15, []any{v19, v23, v47}) -v49 := lang.Apply(v12, []any{v48}) -return v49 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v2 := args[0] -v3 := args[1] -v4 := lang.NewList(args[2:]...) -var v6 any -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -if lang.IsTruthy(v9) { -v6 = closed12 -} else { -v6 = v5 -} -var v5 any = v6 -_ = v5 -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -var v14 lang.FnFunc -v14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v15 := args[0] -v16 := args[1] -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("concat")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v5}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v15}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v16}) -v52 := lang.Apply(v39, []any{v43, v47, v51}) -v53 := lang.Apply(v36, []any{v52}) -v54 := lang.Apply(v33, []any{v53}) -v55 := lang.Apply(v22, []any{v26, v30, v54}) -v56 := lang.Apply(v19, []any{v55}) -return v56 -}) -v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) -v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("concat")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v5}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v2}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v3}) -v52 := lang.Apply(v39, []any{v43, v47, v51}) -v53 := lang.Apply(v36, []any{v52}) -v54 := lang.Apply(v33, []any{v53}) -v55 := lang.Apply(v22, []any{v26, v30, v54}) -v56 := lang.Apply(v19, []any{v55}) -v57 := lang.Apply(v13, []any{v16, v56, v4}) -return v57 - } -}) -v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) -} -v5 := lang.Apply(v4, []any{v3, int64(1)}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v0 := lang.NewSymbol("min").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the least of the nums.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1118), lang.NewKeyword("end-line"), int(1118))).(*lang.Symbol) -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v5 := args[0] -return v5 - case 2: -v5 := args[0] -v6 := args[1] -v7, _ := lang.FieldOrMethod(lang.Numbers, "min") -if reflect.TypeOf(v7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("min is not a function"))) -} -v8 := lang.Apply(v7, []any{v5, v6}) -return v8 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := args[0] -v6 := args[1] -v7 := lang.NewList(args[2:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("min")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("min")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v5, v6}) -v18 := lang.Apply(v10, []any{v13, v17, v7}) -return v18 - } -}) -v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v3 := ns.InternWithValue(v0, v4, true) -if v0.Meta() != nil { - v3.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// min-key -{ -v0 := lang.NewSymbol("min-key").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Returns the x for which (k x), a number, is least.\n\n If there are multiple such xs, the last one is returned.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5033), lang.NewKeyword("end-line"), int(5033))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v3 := args[0] -v4 := args[1] -return v4 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -var v6 any -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("<")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v3, []any{v4}) -v11 := lang.Apply(v3, []any{v5}) -v12 := lang.Apply(v9, []any{v10, v11}) -if lang.IsTruthy(v12) { -v6 = v4 -} else { -v6 = v5 -} -return v6 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v8 := lang.Apply(v3, []any{v4}) -var v7 any = v8 -_ = v7 -v10 := lang.Apply(v3, []any{v5}) -var v9 any = v10 -_ = v9 -var v12 any -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("<")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v7, v9}) -if lang.IsTruthy(v16) { -v17 := lang.NewVector(v4, v7) -v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5043), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(5043), lang.NewKeyword("end-column"), int(36)) -v19, err := lang.WithMeta(v17, v18.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v12 = v19 -} else { -v20 := lang.NewVector(v5, v9) -v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5043), lang.NewKeyword("column"), int(38), lang.NewKeyword("end-line"), int(5043), lang.NewKeyword("end-column"), int(43)) -v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v12 = v22 -} -var v11 any = v12 -_ = v11 -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("nth")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v11, int64(0), nil}) -var v23 any = v27 -_ = v23 -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("nth")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.Apply(v31, []any{v11, int64(1), nil}) -var v28 any = v32 -_ = v28 -var v34 any = v34 -_ = v34 -var v35 any = v35 -_ = v35 -var v36 any = v36 -_ = v36 -var v37 any -for { -var v38 any -if lang.IsTruthy(v36) { -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("first")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v36}) -var v39 any = v43 -_ = v39 -v45 := lang.Apply(v3, []any{v39}) -var v44 any = v45 -_ = v44 -var v47 any -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("<=")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v44, v35}) -if lang.IsTruthy(v51) { -var v52 any = v39 -var v53 any = v44 -v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v56 := v55.FindInternedVar(lang.NewSymbol("next")) -if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) -} -v57 := v56.Get() -v58 := lang.Apply(v57, []any{v36}) -var v54 any = v58 -v34 = v52 -v35 = v53 -v36 = v54 -continue -} else { -var v59 any = v34 -var v60 any = v35 -v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v63 := v62.FindInternedVar(lang.NewSymbol("next")) -if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) -} -v64 := v63.Get() -v65 := lang.Apply(v64, []any{v36}) -var v61 any = v65 -v34 = v59 -v35 = v60 -v36 = v61 -continue -} -v38 = v47 -} else { -v38 = v34 -} -v37 = v38 - break -} -return v37 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// mix-collection-hash -{ -v0 := lang.NewSymbol("mix-collection-hash").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("hash-basis"), lang.NewSymbol("count"))), lang.NewKeyword("doc"), "Mix final collection hash for ordered or unordered collections.\n hash-basis is the combined collection hash, count is the number\n of elements included in the basis. Note this is the hash code\n consistent with =, different from .hashCode.\n See http://glojure.org/data_structures#hash for full algorithms.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5199), lang.NewKeyword("end-line"), int(5199))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.Apply(nil, []any{v3, v4}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// mk-bound-fn -{ -v0 := lang.NewSymbol("mk-bound-fn").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5127), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(5127), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sc"), lang.NewSymbol("test"), lang.NewSymbol("key"))), lang.NewKeyword("private"), true, lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -var v6 lang.FnFunc -v6 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v7 := args[0] -v8, ok := lang.FieldOrMethod(v3, "comparator") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "comparator"))) -} -var v9 any -switch reflect.TypeOf(v8).Kind() { -case reflect.Func: - v9 = lang.Apply(v8, nil) -default: - v9 = v8 -} -v10, _ := lang.FieldOrMethod(v3, "entryKey") -if reflect.TypeOf(v10).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("entryKey is not a function"))) -} -v11 := lang.Apply(v10, []any{v7}) -v12, _ := lang.FieldOrMethod(v9, "compare") -if reflect.TypeOf(v12).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("compare is not a function"))) -} -v13 := lang.Apply(v12, []any{v11, v5}) -v14 := lang.Apply(v4, []any{v13, int64(0)}) -return v14 -}) -v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5130), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(5131), lang.NewKeyword("end-column"), int(64)) -v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v8 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// mod -{ -v0 := lang.NewSymbol("mod").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"), lang.NewSymbol("div"))), lang.NewKeyword("doc"), "Modulus of num and div. Truncates toward negative infinity.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3567), lang.NewKeyword("end-line"), int(3567))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("rem")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v3, v4}) -var v5 any = v9 -_ = v5 -var v11 any -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("zero?")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v5}) -var v12 any = v16 -_ = v12 -var v18 any -if lang.IsTruthy(v12) { -v18 = v12 -} else { -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("=")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("pos?")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("pos?")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.Apply(v28, []any{v4}) -v30 := lang.Apply(v21, []any{v25, v29}) -v18 = v30 -} -if lang.IsTruthy(v18) { -v11 = v5 -} else { -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("+")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v5, v4}) -v11 = v15 -} -return v11 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// name -{ -v1 := reflect.TypeOf("") -v0 := lang.NewSymbol("name").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns the name String of a string, symbol or keyword.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1585), lang.NewKeyword("end-line"), int(1585))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("string?")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v4}) -if lang.IsTruthy(v9) { -v5 = v4 -} else { -v10, _ := lang.FieldOrMethod(v4, "Name") -if reflect.TypeOf(v10).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Name is not a function"))) -} -v11 := lang.Apply(v10, []any{}) -v5 = v11 -} -return v5 -}) -v4 := reflect.TypeOf("") -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// namespace -{ -v1 := reflect.TypeOf("") -v0 := lang.NewSymbol("namespace").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns the namespace String of a symbol or keyword, or nil if not present.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1593), lang.NewKeyword("end-line"), int(1593))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5, _ := lang.FieldOrMethod(v4, "Namespace") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Namespace is not a function"))) -} -v6 := lang.Apply(v5, []any{}) -return v6 -}) -v4 := reflect.TypeOf("") -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// nary-inline -{ -v0 := lang.NewSymbol("nary-inline").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(948), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(948), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("op")), lang.NewVector(lang.NewSymbol("op"), lang.NewSymbol("unchecked-op"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("nary-inline")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{v3, v3}) -return v7 - case 2: -v3 := args[0] -v4 := args[1] -var v5 lang.FnFunc -v5 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v6 := args[0] -var v8 any -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -if lang.IsTruthy(v11) { -v8 = v4 -} else { -v8 = v7 -} -var v7 any = v8 -_ = v7 -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("seq")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("concat")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{lang.NewSymbol(".")}) -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("seq")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("concat")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v7}) -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v6}) -v44 := lang.Apply(v35, []any{v39, v43}) -v45 := lang.Apply(v32, []any{v44}) -v46 := lang.Apply(v29, []any{v45}) -v47 := lang.Apply(v18, []any{v22, v26, v46}) -v48 := lang.Apply(v15, []any{v47}) -return v48 - case 2: -v6 := args[0] -v7 := args[1] -var v9 any -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -if lang.IsTruthy(v12) { -v9 = v4 -} else { -v9 = v8 -} -var v8 any = v9 -_ = v8 -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("seq")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("concat")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("list")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.Apply(v22, []any{lang.NewSymbol(".")}) -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("list")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v26, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("list")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("seq")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("concat")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("list")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v8}) -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("list")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v6}) -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("list")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.Apply(v47, []any{v7}) -v49 := lang.Apply(v36, []any{v40, v44, v48}) -v50 := lang.Apply(v33, []any{v49}) -v51 := lang.Apply(v30, []any{v50}) -v52 := lang.Apply(v19, []any{v23, v27, v51}) -v53 := lang.Apply(v16, []any{v52}) -return v53 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v6 := args[0] -v7 := args[1] -v8 := lang.NewList(args[2:]...) -var v10 any -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -if lang.IsTruthy(v13) { -v10 = v4 -} else { -v10 = v9 -} -var v9 any = v10 -_ = v9 -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("reduce1")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -var v18 lang.FnFunc -v18 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v19 := args[0] -v20 := args[1] -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol(".")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("list")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("seq")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("concat")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v9}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v19}) -v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("list")) -if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) -} -v54 := v53.Get() -v55 := lang.Apply(v54, []any{v20}) -v56 := lang.Apply(v43, []any{v47, v51, v55}) -v57 := lang.Apply(v40, []any{v56}) -v58 := lang.Apply(v37, []any{v57}) -v59 := lang.Apply(v26, []any{v30, v34, v58}) -v60 := lang.Apply(v23, []any{v59}) -return v60 -}) -v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) -v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol(".")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("list")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("seq")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("concat")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v9}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v6}) -v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("list")) -if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) -} -v54 := v53.Get() -v55 := lang.Apply(v54, []any{v7}) -v56 := lang.Apply(v43, []any{v47, v51, v55}) -v57 := lang.Apply(v40, []any{v56}) -v58 := lang.Apply(v37, []any{v57}) -v59 := lang.Apply(v26, []any{v30, v34, v58}) -v60 := lang.Apply(v23, []any{v59}) -v61 := lang.Apply(v17, []any{v20, v60, v8}) -return v61 - } -}) -v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86)) -v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v7 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// nat-int? -{ -v0 := lang.NewSymbol("nat-int?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a non-negative fixed precision integer", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1415), lang.NewKeyword("end-line"), int(1415))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("int?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -var v4 any = v8 -_ = v4 -var v10 any -if lang.IsTruthy(v4) { -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("not")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("neg?")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v3}) -v18 := lang.Apply(v13, []any{v17}) -v10 = v18 -} else { -v10 = v4 -} -return v10 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// neg-int? -{ -v0 := lang.NewSymbol("neg-int?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a negative fixed precision integer", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1409), lang.NewKeyword("end-line"), int(1409))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("int?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -var v4 any = v8 -_ = v4 -var v10 any -if lang.IsTruthy(v4) { -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("neg?")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v3}) -v10 = v14 -} else { -v10 = v4 -} -return v10 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// neg? -{ -var v1 lang.FnFunc -{ // function neg?__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/isNeg")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v3}) -v35 := lang.Apply(v26, []any{v30, v34}) -v36 := lang.Apply(v23, []any{v35}) -v37 := lang.Apply(v20, []any{v36}) -v38 := lang.Apply(v9, []any{v13, v17, v37}) -v39 := lang.Apply(v6, []any{v38}) -return v39 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("neg?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns true if num is less than zero, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1259), lang.NewKeyword("end-line"), int(1259))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5, _ := lang.FieldOrMethod(lang.Numbers, "isNeg") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("isNeg is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// newline -{ -v0 := lang.NewSymbol("newline").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Writes a platform-specific newline to *out*", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3698), lang.NewKeyword("end-line"), int(3698))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v4 := v3.FindInternedVar(lang.NewSymbol("*out*")) -if v4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) -} -v5 := v4.Get() -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("system-newline")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(lang.AppendWriter, []any{v5, v8}) -_ = v9 -return nil -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// next -{ -v1 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() -v0 := lang.NewSymbol("next").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a seq of the items after the first. Calls seq on its\n argument. If there are no more items, returns nil.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(55), lang.NewKeyword("end-line"), int(61))).(*lang.Symbol) -var v3 lang.FnFunc -{ // function next -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := args[0] -v6 := lang.Apply(lang.Next, []any{v5}) -return v6 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(61), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(61), lang.NewKeyword("end-column"), int(77))).(lang.FnFunc) -v4 := v3 -_ = v4 -} -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// nfirst -{ -v0 := lang.NewSymbol("nfirst").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Same as (next (first x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(105), lang.NewKeyword("end-line"), int(109))).(*lang.Symbol) -var v2 lang.FnFunc -{ // function nfirst -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("next")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("first")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v4}) -v12 := lang.Apply(v7, []any{v11}) -return v12 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(109), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(109), lang.NewKeyword("end-column"), int(49))).(lang.FnFunc) -v3 := v2 -_ = v3 -} -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// nil? -{ -v1 := reflect.TypeOf(false) -var v2 lang.FnFunc -{ // function nil?__inliner -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("list")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Identical"), v4, nil}) -return v8 -}) -v3 := v2 -_ = v3 -} -v0 := lang.NewSymbol("nil?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v2, lang.NewKeyword("doc"), "Returns true if x is nil, false otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(435), lang.NewKeyword("end-line"), int(435))).(*lang.Symbol) -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := args[0] -v6 := lang.Apply(lang.IsNil, []any{v5}) -return v6 -}) -v5 := reflect.TypeOf(false) -v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v5)).(lang.FnFunc) -v3 := ns.InternWithValue(v0, v4, true) -if v0.Meta() != nil { - v3.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// nnext -{ -v0 := lang.NewSymbol("nnext").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Same as (next (next x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(119), lang.NewKeyword("end-line"), int(123))).(*lang.Symbol) -var v2 lang.FnFunc -{ // function nnext -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("next")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("next")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v4}) -v12 := lang.Apply(v7, []any{v11}) -return v12 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(123), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(123), lang.NewKeyword("end-column"), int(46))).(lang.FnFunc) -v3 := v2 -_ = v3 -} -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// normalize-slurp-opts -{ -v0 := lang.NewSymbol("normalize-slurp-opts").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6974), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(6974), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("opts"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("string?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("first")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v3}) -v12 := lang.Apply(v7, []any{v11}) -if lang.IsTruthy(v12) { -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("println")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{"WARNING: (slurp f enc) is deprecated, use (slurp f :encoding enc)."}) -_ = v16 -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("first")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v3}) -v21 := lang.NewVector(lang.NewKeyword("encoding"), v20) -v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6979), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(6979), lang.NewKeyword("end-column"), int(30)) -v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v4 = v23 -} else { -v4 = v3 -} -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// not -{ -v1 := reflect.TypeOf(false) -v0 := lang.NewSymbol("not").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is logical false, false otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(523), lang.NewKeyword("end-line"), int(523))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -var v5 any -if lang.IsTruthy(v4) { -v5 = false -} else { -v5 = true -} -return v5 -}) -v4 := reflect.TypeOf(false) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// not-any? -{ -v1 := reflect.TypeOf(false) -v0 := lang.NewSymbol("not-any?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns false if (pred x) is logical true for any x in coll,\n else true.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(2696), lang.NewKeyword("end-line"), int(2701))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v4 := lang.Apply(closed14, nil) -v5 := lang.Apply(closed13, []any{v4}) -return v5 - case 1: -v4 := args[0] -v5 := lang.Apply(closed14, []any{v4}) -v6 := lang.Apply(closed13, []any{v5}) -return v6 - case 2: -v4 := args[0] -v5 := args[1] -v6 := lang.Apply(closed14, []any{v4, v5}) -v7 := lang.Apply(closed13, []any{v6}) -return v7 - case 3: -v4 := args[0] -v5 := args[1] -v6 := args[2] -v7 := lang.Apply(closed14, []any{v4, v5, v6}) -v8 := lang.Apply(closed13, []any{v7}) -return v8 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6 := args[2] -v7 := lang.NewList(args[3:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("apply")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{closed14, v4, v5, v6, v7}) -v12 := lang.Apply(closed13, []any{v11}) -return v12 - } -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2559), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2564), lang.NewKeyword("end-column"), int(49))).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// not-empty -{ -v0 := lang.NewSymbol("not-empty").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "If coll is empty, returns nil, else coll", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5516), lang.NewKeyword("end-line"), int(5516))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -if lang.IsTruthy(v8) { -v4 = v3 -} else { -v4 = nil -} -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// not-every? -{ -v1 := reflect.TypeOf(false) -v0 := lang.NewSymbol("not-every?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns false if (pred x) is logical true for every x in\n coll, else true.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(2677), lang.NewKeyword("end-line"), int(2682))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v4 := lang.Apply(closed15, nil) -v5 := lang.Apply(closed13, []any{v4}) -return v5 - case 1: -v4 := args[0] -v5 := lang.Apply(closed15, []any{v4}) -v6 := lang.Apply(closed13, []any{v5}) -return v6 - case 2: -v4 := args[0] -v5 := args[1] -v6 := lang.Apply(closed15, []any{v4, v5}) -v7 := lang.Apply(closed13, []any{v6}) -return v7 - case 3: -v4 := args[0] -v5 := args[1] -v6 := args[2] -v7 := lang.Apply(closed15, []any{v4, v5, v6}) -v8 := lang.Apply(closed13, []any{v7}) -return v8 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6 := args[2] -v7 := lang.NewList(args[3:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("apply")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{closed15, v4, v5, v6, v7}) -v12 := lang.Apply(closed13, []any{v11}) -return v12 - } -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2559), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2564), lang.NewKeyword("end-column"), int(49))).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// not= -{ -v1 := reflect.TypeOf(false) -v0 := lang.NewSymbol("not=").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Same as (not (= obj1 obj2))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(812), lang.NewKeyword("end-line"), int(812))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v4 := args[0] -return false - case 2: -v4 := args[0] -v5 := args[1] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("not")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("=")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v4, v5}) -v13 := lang.Apply(v8, []any{v12}) -return v13 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6 := lang.NewList(args[2:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("not")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("apply")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("=")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v12, []any{v15, v4, v5, v6}) -v17 := lang.Apply(v9, []any{v16}) -return v17 - } -}) -v4 := reflect.TypeOf(false) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// ns -{ -v0 := lang.NewSymbol("ns").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("docstring?"), lang.NewSymbol("attr-map?"), lang.NewSymbol("references*"))), lang.NewKeyword("doc"), "Sets *ns* to the namespace named by name (unevaluated), creating it\n if needed. references can be zero or more of: (:refer-glojure ...)\n (:require ...) (:use ...) (:import ...) (:load ...) (:gen-class)\n with the syntax of refer-glojure/require/use/import/load/gen-class\n respectively, except the arguments are unevaluated and need not be\n quoted. (:gen-class ...), when supplied, defaults to :name\n corresponding to the ns name, :main true, :impl-ns same as ns, and\n :init-impl-ns true. All options of gen-class are\n supported. The :gen-class directive is ignored when not\n compiling. If :gen-class is not supplied, when compiled only an\n nsname__init.class will be generated. If :refer-glojure is not used, a\n default (refer 'glojure.core) is used. Use of ns is preferred to\n individual calls to in-ns/require/use/import:\n\n (ns foo.bar\n (:refer-glojure :exclude [ancestors printf])\n (:require (glojure.contrib sql combinatorics))\n (:use (my.lib this that))\n (:import (java.util Date Timer Random)\n (java.sql Connection Statement)))", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5742), lang.NewKeyword("end-line"), int(5742))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -var v8 lang.FnFunc -v8 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v9 := args[0] -var v10 any = v9 -_ = v10 -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("seq")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v10}) -var v11 any = v15 -_ = v11 -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("first")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v11}) -var v16 any = v20 -_ = v16 -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("next")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v21}) -var v21 any = v25 -_ = v21 -var v26 any = v16 -_ = v26 -var v27 any = v21 -_ = v27 -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("seq")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("concat")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("list")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("symbol")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("name")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v26}) -v45 := lang.Apply(v40, []any{"glojure.core", v44}) -v46 := lang.Apply(v37, []any{v45}) -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("map")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) -} -v49 := v48.Get() -var v50 lang.FnFunc -v50 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v51 := args[0] -v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("list")) -if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) -} -v54 := v53.Get() -v55 := lang.Apply(v54, []any{lang.NewSymbol("quote"), v51}) -return v55 -}) -v51 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5769), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(5769), lang.NewKeyword("end-column"), int(36)) -v52, err := lang.WithMeta(v50, v51.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v53 := lang.Apply(v49, []any{v52, v27}) -v54 := lang.Apply(v34, []any{v46, v53}) -v55 := lang.Apply(v31, []any{v54}) -return v55 -}) -v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5767), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(5769), lang.NewKeyword("end-column"), int(44)) -v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v7 any = v10 -_ = v7 -var v12 any -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("string?")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("first")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v6}) -v20 := lang.Apply(v15, []any{v19}) -if lang.IsTruthy(v20) { -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("first")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v6}) -v12 = v24 -} else { -v12 = nil -} -var v11 any = v12 -_ = v11 -var v26 any -if lang.IsTruthy(v11) { -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("next")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{v25}) -v26 = v30 -} else { -v26 = v25 -} -var v25 any = v26 -_ = v25 -var v32 any -if lang.IsTruthy(v11) { -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("vary-meta")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("assoc")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v35, []any{v31, v38, lang.NewKeyword("doc"), v11}) -v32 = v39 -} else { -v32 = v31 -} -var v31 any = v32 -_ = v31 -var v41 any -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("map?")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) -} -v44 := v43.Get() -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("first")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.Apply(v47, []any{v25}) -v49 := lang.Apply(v44, []any{v48}) -if lang.IsTruthy(v49) { -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("first")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.Apply(v52, []any{v25}) -v41 = v53 -} else { -v41 = nil -} -var v40 any = v41 -_ = v40 -var v55 any -if lang.IsTruthy(v40) { -v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v57 := v56.FindInternedVar(lang.NewSymbol("next")) -if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) -} -v58 := v57.Get() -v59 := lang.Apply(v58, []any{v54}) -v55 = v59 -} else { -v55 = v54 -} -var v54 any = v55 -_ = v54 -var v61 any -if lang.IsTruthy(v40) { -v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v63 := v62.FindInternedVar(lang.NewSymbol("vary-meta")) -if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) -} -v64 := v63.Get() -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("merge")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) -} -v67 := v66.Get() -v68 := lang.Apply(v64, []any{v60, v67, v40}) -v61 = v68 -} else { -v61 = v60 -} -var v60 any = v61 -_ = v60 -v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v71 := v70.FindInternedVar(lang.NewSymbol("first")) -if v71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) -} -v72 := v71.Get() -v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v74 := v73.FindInternedVar(lang.NewSymbol("filter")) -if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) -} -v75 := v74.Get() -var v76 lang.FnFunc -v76 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v77 := args[0] -v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v79 := v78.FindInternedVar(lang.NewSymbol("=")) -if v79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) -} -v80 := v79.Get() -v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v82 := v81.FindInternedVar(lang.NewSymbol("first")) -if v82.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) -} -v83 := v82.Get() -v84 := lang.Apply(v83, []any{v77}) -v85 := lang.Apply(v80, []any{lang.NewKeyword("gen-class"), v84}) -return v85 -}) -v77 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5780), lang.NewKeyword("column"), int(41), lang.NewKeyword("end-line"), int(5780), lang.NewKeyword("end-column"), int(65)) -v78, err := lang.WithMeta(v76, v77.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v79 := lang.Apply(v75, []any{v78, v54}) -v80 := lang.Apply(v72, []any{v79}) -var v69 any = v80 -_ = v69 -var v82 any -if lang.IsTruthy(v69) { -v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v84 := v83.FindInternedVar(lang.NewSymbol("list*")) -if v84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) -} -v85 := v84.Get() -v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v87 := v86.FindInternedVar(lang.NewSymbol("str")) -if v87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) -} -v88 := v87.Get() -v89 := lang.Apply(v88, []any{v60}) -v90, _ := lang.FieldOrMethod(v89, "replace") -if reflect.TypeOf(v90).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("replace is not a function"))) -} -v91 := lang.Apply(v90, []any{lang.NewChar(45), lang.NewChar(95)}) -v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v93 := v92.FindInternedVar(lang.NewSymbol("next")) -if v93.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) -} -v94 := v93.Get() -v95 := lang.Apply(v94, []any{v69}) -v96 := lang.Apply(v85, []any{lang.NewSymbol("glojure.core/gen-class"), lang.NewKeyword("name"), v91, lang.NewKeyword("impl-ns"), v60, lang.NewKeyword("main"), true, v95}) -v82 = v96 -} else { -v82 = nil -} -var v81 any = v82 -_ = v81 -v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v99 := v98.FindInternedVar(lang.NewSymbol("remove")) -if v99.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) -} -v100 := v99.Get() -var v101 lang.FnFunc -v101 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v102 := args[0] -v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v104 := v103.FindInternedVar(lang.NewSymbol("=")) -if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) -} -v105 := v104.Get() -v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v107 := v106.FindInternedVar(lang.NewSymbol("first")) -if v107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) -} -v108 := v107.Get() -v109 := lang.Apply(v108, []any{v102}) -v110 := lang.Apply(v105, []any{lang.NewKeyword("gen-class"), v109}) -return v110 -}) -v102 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5784), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(5784), lang.NewKeyword("end-column"), int(52)) -v103, err := lang.WithMeta(v101, v102.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v104 := lang.Apply(v100, []any{v103, v97}) -var v97 any = v104 -_ = v97 -v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v107 := v106.FindInternedVar(lang.NewSymbol("meta")) -if v107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) -} -v108 := v107.Get() -v109 := lang.Apply(v108, []any{v60}) -var v105 any = v109 -_ = v105 -v111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v112 := v111.FindInternedVar(lang.NewSymbol("seq")) -if v112.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v112))) -} -v113 := v112.Get() -v114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v115 := v114.FindInternedVar(lang.NewSymbol("concat")) -if v115.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v115))) -} -v116 := v115.Get() -v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v118 := v117.FindInternedVar(lang.NewSymbol("list")) -if v118.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) -} -v119 := v118.Get() -v120 := lang.Apply(v119, []any{lang.NewSymbol("do")}) -v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v122 := v121.FindInternedVar(lang.NewSymbol("list")) -if v122.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) -} -v123 := v122.Get() -v124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v125 := v124.FindInternedVar(lang.NewSymbol("seq")) -if v125.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v125))) -} -v126 := v125.Get() -v127 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v128 := v127.FindInternedVar(lang.NewSymbol("concat")) -if v128.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v128))) -} -v129 := v128.Get() -v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v131 := v130.FindInternedVar(lang.NewSymbol("list")) -if v131.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) -} -v132 := v131.Get() -v133 := lang.Apply(v132, []any{lang.NewSymbol("glojure.core/in-ns")}) -v134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v135 := v134.FindInternedVar(lang.NewSymbol("list")) -if v135.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v135))) -} -v136 := v135.Get() -v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v138 := v137.FindInternedVar(lang.NewSymbol("seq")) -if v138.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) -} -v139 := v138.Get() -v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v141 := v140.FindInternedVar(lang.NewSymbol("concat")) -if v141.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) -} -v142 := v141.Get() -v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v144 := v143.FindInternedVar(lang.NewSymbol("list")) -if v144.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) -} -v145 := v144.Get() -v146 := lang.Apply(v145, []any{lang.NewSymbol("quote")}) -v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v148 := v147.FindInternedVar(lang.NewSymbol("list")) -if v148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) -} -v149 := v148.Get() -v150 := lang.Apply(v149, []any{v60}) -v151 := lang.Apply(v142, []any{v146, v150}) -v152 := lang.Apply(v139, []any{v151}) -v153 := lang.Apply(v136, []any{v152}) -v154 := lang.Apply(v129, []any{v133, v153}) -v155 := lang.Apply(v126, []any{v154}) -v156 := lang.Apply(v123, []any{v155}) -var v157 any -if lang.IsTruthy(v105) { -v158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v159 := v158.FindInternedVar(lang.NewSymbol("seq")) -if v159.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v159))) -} -v160 := v159.Get() -v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v162 := v161.FindInternedVar(lang.NewSymbol("concat")) -if v162.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) -} -v163 := v162.Get() -v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v165 := v164.FindInternedVar(lang.NewSymbol("list")) -if v165.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) -} -v166 := v165.Get() -v167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v168 := v167.FindInternedVar(lang.NewSymbol("seq")) -if v168.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v168))) -} -v169 := v168.Get() -v170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v171 := v170.FindInternedVar(lang.NewSymbol("concat")) -if v171.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v171))) -} -v172 := v171.Get() -v173 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v174 := v173.FindInternedVar(lang.NewSymbol("list")) -if v174.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v174))) -} -v175 := v174.Get() -v176 := lang.Apply(v175, []any{lang.NewSymbol(".ResetMeta")}) -v177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v178 := v177.FindInternedVar(lang.NewSymbol("list")) -if v178.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v178))) -} -v179 := v178.Get() -v180 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v181 := v180.FindInternedVar(lang.NewSymbol("seq")) -if v181.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v181))) -} -v182 := v181.Get() -v183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v184 := v183.FindInternedVar(lang.NewSymbol("concat")) -if v184.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v184))) -} -v185 := v184.Get() -v186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v187 := v186.FindInternedVar(lang.NewSymbol("list")) -if v187.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v187))) -} -v188 := v187.Get() -v189 := lang.Apply(v188, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.FindNamespace")}) -v190 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v191 := v190.FindInternedVar(lang.NewSymbol("list")) -if v191.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v191))) -} -v192 := v191.Get() -v193 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v194 := v193.FindInternedVar(lang.NewSymbol("seq")) -if v194.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v194))) -} -v195 := v194.Get() -v196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v197 := v196.FindInternedVar(lang.NewSymbol("concat")) -if v197.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v197))) -} -v198 := v197.Get() -v199 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v200 := v199.FindInternedVar(lang.NewSymbol("list")) -if v200.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v200))) -} -v201 := v200.Get() -v202 := lang.Apply(v201, []any{lang.NewSymbol("quote")}) -v203 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v204 := v203.FindInternedVar(lang.NewSymbol("list")) -if v204.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v204))) -} -v205 := v204.Get() -v206 := lang.Apply(v205, []any{v60}) -v207 := lang.Apply(v198, []any{v202, v206}) -v208 := lang.Apply(v195, []any{v207}) -v209 := lang.Apply(v192, []any{v208}) -v210 := lang.Apply(v185, []any{v189, v209}) -v211 := lang.Apply(v182, []any{v210}) -v212 := lang.Apply(v179, []any{v211}) -v213 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v214 := v213.FindInternedVar(lang.NewSymbol("list")) -if v214.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v214))) -} -v215 := v214.Get() -v216 := lang.Apply(v215, []any{v105}) -v217 := lang.Apply(v172, []any{v176, v212, v216}) -v218 := lang.Apply(v169, []any{v217}) -v219 := lang.Apply(v166, []any{v218}) -v220 := lang.Apply(v163, []any{v219}) -v221 := lang.Apply(v160, []any{v220}) -v157 = v221 -} else { -v157 = nil -} -v222 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v223 := v222.FindInternedVar(lang.NewSymbol("list")) -if v223.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v223))) -} -v224 := v223.Get() -v225 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v226 := v225.FindInternedVar(lang.NewSymbol("seq")) -if v226.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v226))) -} -v227 := v226.Get() -v228 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v229 := v228.FindInternedVar(lang.NewSymbol("concat")) -if v229.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v229))) -} -v230 := v229.Get() -v231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v232 := v231.FindInternedVar(lang.NewSymbol("list")) -if v232.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v232))) -} -v233 := v232.Get() -v234 := lang.Apply(v233, []any{lang.NewSymbol("glojure.core/with-loading-context")}) -var v235 any -if lang.IsTruthy(v81) { -v236 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v237 := v236.FindInternedVar(lang.NewSymbol("list")) -if v237.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v237))) -} -v238 := v237.Get() -v239 := lang.Apply(v238, []any{v81}) -v235 = v239 -} else { -v235 = nil -} -var v240 any -v242 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v243 := v242.FindInternedVar(lang.NewSymbol("not=")) -if v243.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v243))) -} -v244 := v243.Get() -v245 := lang.Apply(v244, []any{v60, lang.NewSymbol("glojure.core")}) -var v241 any = v245 -_ = v241 -var v247 any -if lang.IsTruthy(v241) { -v248 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v249 := v248.FindInternedVar(lang.NewSymbol("not-any?")) -if v249.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v249))) -} -v250 := v249.Get() -var v251 lang.FnFunc -v251 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v252 := args[0] -v253 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v254 := v253.FindInternedVar(lang.NewSymbol("=")) -if v254.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v254))) -} -v255 := v254.Get() -v256 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v257 := v256.FindInternedVar(lang.NewSymbol("first")) -if v257.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v257))) -} -v258 := v257.Get() -v259 := lang.Apply(v258, []any{v252}) -v260 := lang.Apply(v255, []any{lang.NewKeyword("refer-glojure"), v259}) -return v260 -}) -v252 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5793), lang.NewKeyword("column"), int(58), lang.NewKeyword("end-line"), int(5793), lang.NewKeyword("end-column"), int(86)) -v253, err := lang.WithMeta(v251, v252.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v254 := lang.Apply(v250, []any{v253, v97}) -v247 = v254 -} else { -v247 = v241 -} -if lang.IsTruthy(v247) { -v241 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v242 := v241.FindInternedVar(lang.NewSymbol("seq")) -if v242.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v242))) -} -v243 := v242.Get() -v244 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v245 := v244.FindInternedVar(lang.NewSymbol("concat")) -if v245.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v245))) -} -v246 := v245.Get() -v247 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v248 := v247.FindInternedVar(lang.NewSymbol("list")) -if v248.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v248))) -} -v249 := v248.Get() -v250 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v251 := v250.FindInternedVar(lang.NewSymbol("seq")) -if v251.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v251))) -} -v252 := v251.Get() -v253 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v254 := v253.FindInternedVar(lang.NewSymbol("concat")) -if v254.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v254))) -} -v255 := v254.Get() -v256 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v257 := v256.FindInternedVar(lang.NewSymbol("list")) -if v257.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v257))) -} -v258 := v257.Get() -v259 := lang.Apply(v258, []any{lang.NewSymbol("glojure.core/refer")}) -v260 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v261 := v260.FindInternedVar(lang.NewSymbol("list")) -if v261.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v261))) -} -v262 := v261.Get() -v263 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v264 := v263.FindInternedVar(lang.NewSymbol("seq")) -if v264.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v264))) -} -v265 := v264.Get() -v266 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v267 := v266.FindInternedVar(lang.NewSymbol("concat")) -if v267.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v267))) -} -v268 := v267.Get() -v269 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v270 := v269.FindInternedVar(lang.NewSymbol("list")) -if v270.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v270))) -} -v271 := v270.Get() -v272 := lang.Apply(v271, []any{lang.NewSymbol("quote")}) -v273 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v274 := v273.FindInternedVar(lang.NewSymbol("list")) -if v274.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v274))) -} -v275 := v274.Get() -v276 := lang.Apply(v275, []any{lang.NewSymbol("glojure.core")}) -v277 := lang.Apply(v268, []any{v272, v276}) -v278 := lang.Apply(v265, []any{v277}) -v279 := lang.Apply(v262, []any{v278}) -v280 := lang.Apply(v255, []any{v259, v279}) -v281 := lang.Apply(v252, []any{v280}) -v282 := lang.Apply(v249, []any{v281}) -v283 := lang.Apply(v246, []any{v282}) -v284 := lang.Apply(v243, []any{v283}) -v240 = v284 -} else { -v240 = nil -} -v285 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v286 := v285.FindInternedVar(lang.NewSymbol("map")) -if v286.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v286))) -} -v287 := v286.Get() -v288 := lang.Apply(v287, []any{v7, v97}) -v289 := lang.Apply(v230, []any{v234, v235, v240, v288}) -v290 := lang.Apply(v227, []any{v289}) -v291 := lang.Apply(v224, []any{v290}) -v292 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v293 := v292.FindInternedVar(lang.NewSymbol("list")) -if v293.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v293))) -} -v294 := v293.Get() -v295 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v296 := v295.FindInternedVar(lang.NewSymbol("seq")) -if v296.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v296))) -} -v297 := v296.Get() -v298 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v299 := v298.FindInternedVar(lang.NewSymbol("concat")) -if v299.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v299))) -} -v300 := v299.Get() -v301 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v302 := v301.FindInternedVar(lang.NewSymbol("list")) -if v302.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v302))) -} -v303 := v302.Get() -v304 := lang.Apply(v303, []any{lang.NewSymbol("if")}) -v305 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v306 := v305.FindInternedVar(lang.NewSymbol("list")) -if v306.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v306))) -} -v307 := v306.Get() -v308 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v309 := v308.FindInternedVar(lang.NewSymbol("seq")) -if v309.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v309))) -} -v310 := v309.Get() -v311 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v312 := v311.FindInternedVar(lang.NewSymbol("concat")) -if v312.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v312))) -} -v313 := v312.Get() -v314 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v315 := v314.FindInternedVar(lang.NewSymbol("list")) -if v315.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v315))) -} -v316 := v315.Get() -v317 := lang.Apply(v316, []any{lang.NewSymbol(".Equals")}) -v318 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v319 := v318.FindInternedVar(lang.NewSymbol("list")) -if v319.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v319))) -} -v320 := v319.Get() -v321 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v322 := v321.FindInternedVar(lang.NewSymbol("seq")) -if v322.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v322))) -} -v323 := v322.Get() -v324 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v325 := v324.FindInternedVar(lang.NewSymbol("concat")) -if v325.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v325))) -} -v326 := v325.Get() -v327 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v328 := v327.FindInternedVar(lang.NewSymbol("list")) -if v328.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v328))) -} -v329 := v328.Get() -v330 := lang.Apply(v329, []any{lang.NewSymbol("quote")}) -v331 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v332 := v331.FindInternedVar(lang.NewSymbol("list")) -if v332.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v332))) -} -v333 := v332.Get() -v334 := lang.Apply(v333, []any{v60}) -v335 := lang.Apply(v326, []any{v330, v334}) -v336 := lang.Apply(v323, []any{v335}) -v337 := lang.Apply(v320, []any{v336}) -v338 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v339 := v338.FindInternedVar(lang.NewSymbol("list")) -if v339.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v339))) -} -v340 := v339.Get() -v341 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v342 := v341.FindInternedVar(lang.NewSymbol("seq")) -if v342.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v342))) -} -v343 := v342.Get() -v344 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v345 := v344.FindInternedVar(lang.NewSymbol("concat")) -if v345.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v345))) -} -v346 := v345.Get() -v347 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v348 := v347.FindInternedVar(lang.NewSymbol("list")) -if v348.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v348))) -} -v349 := v348.Get() -v350 := lang.Apply(v349, []any{lang.NewSymbol("quote")}) -v351 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v352 := v351.FindInternedVar(lang.NewSymbol("list")) -if v352.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v352))) -} -v353 := v352.Get() -v354 := lang.Apply(v353, []any{lang.NewSymbol("glojure.core")}) -v355 := lang.Apply(v346, []any{v350, v354}) -v356 := lang.Apply(v343, []any{v355}) -v357 := lang.Apply(v340, []any{v356}) -v358 := lang.Apply(v313, []any{v317, v337, v357}) -v359 := lang.Apply(v310, []any{v358}) -v360 := lang.Apply(v307, []any{v359}) -v361 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v362 := v361.FindInternedVar(lang.NewSymbol("list")) -if v362.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v362))) -} -v363 := v362.Get() -v364 := lang.Apply(v363, []any{nil}) -v365 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v366 := v365.FindInternedVar(lang.NewSymbol("list")) -if v366.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v366))) -} -v367 := v366.Get() -v368 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v369 := v368.FindInternedVar(lang.NewSymbol("seq")) -if v369.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v369))) -} -v370 := v369.Get() -v371 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v372 := v371.FindInternedVar(lang.NewSymbol("concat")) -if v372.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v372))) -} -v373 := v372.Get() -v374 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v375 := v374.FindInternedVar(lang.NewSymbol("list")) -if v375.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v375))) -} -v376 := v375.Get() -v377 := lang.Apply(v376, []any{lang.NewSymbol("do")}) -v378 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v379 := v378.FindInternedVar(lang.NewSymbol("list")) -if v379.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v379))) -} -v380 := v379.Get() -v381 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v382 := v381.FindInternedVar(lang.NewSymbol("seq")) -if v382.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v382))) -} -v383 := v382.Get() -v384 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v385 := v384.FindInternedVar(lang.NewSymbol("concat")) -if v385.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v385))) -} -v386 := v385.Get() -v387 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v388 := v387.FindInternedVar(lang.NewSymbol("list")) -if v388.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v388))) -} -v389 := v388.Get() -v390 := lang.Apply(v389, []any{lang.NewSymbol("glojure.core/dosync")}) -v391 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v392 := v391.FindInternedVar(lang.NewSymbol("list")) -if v392.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v392))) -} -v393 := v392.Get() -v394 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v395 := v394.FindInternedVar(lang.NewSymbol("seq")) -if v395.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v395))) -} -v396 := v395.Get() -v397 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v398 := v397.FindInternedVar(lang.NewSymbol("concat")) -if v398.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v398))) -} -v399 := v398.Get() -v400 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v401 := v400.FindInternedVar(lang.NewSymbol("list")) -if v401.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v401))) -} -v402 := v401.Get() -v403 := lang.Apply(v402, []any{lang.NewSymbol("glojure.core/commute")}) -v404 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v405 := v404.FindInternedVar(lang.NewSymbol("list")) -if v405.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v405))) -} -v406 := v405.Get() -v407 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v408 := v407.FindInternedVar(lang.NewSymbol("seq")) -if v408.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v408))) -} -v409 := v408.Get() -v410 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v411 := v410.FindInternedVar(lang.NewSymbol("concat")) -if v411.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v411))) -} -v412 := v411.Get() -v413 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v414 := v413.FindInternedVar(lang.NewSymbol("list")) -if v414.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v414))) -} -v415 := v414.Get() -v416 := lang.Apply(v415, []any{lang.NewSymbol("glojure.core/deref")}) -v417 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v418 := v417.FindInternedVar(lang.NewSymbol("list")) -if v418.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v418))) -} -v419 := v418.Get() -v420 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v421 := v420.FindInternedVar(lang.NewSymbol("seq")) -if v421.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v421))) -} -v422 := v421.Get() -v423 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v424 := v423.FindInternedVar(lang.NewSymbol("concat")) -if v424.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v424))) -} -v425 := v424.Get() -v426 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v427 := v426.FindInternedVar(lang.NewSymbol("list")) -if v427.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v427))) -} -v428 := v427.Get() -v429 := lang.Apply(v428, []any{lang.NewSymbol("var")}) -v430 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v431 := v430.FindInternedVar(lang.NewSymbol("list")) -if v431.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v431))) -} -v432 := v431.Get() -v433 := lang.Apply(v432, []any{lang.NewSymbol("glojure.core/*loaded-libs*")}) -v434 := lang.Apply(v425, []any{v429, v433}) -v435 := lang.Apply(v422, []any{v434}) -v436 := lang.Apply(v419, []any{v435}) -v437 := lang.Apply(v412, []any{v416, v436}) -v438 := lang.Apply(v409, []any{v437}) -v439 := lang.Apply(v406, []any{v438}) -v440 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v441 := v440.FindInternedVar(lang.NewSymbol("list")) -if v441.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v441))) -} -v442 := v441.Get() -v443 := lang.Apply(v442, []any{lang.NewSymbol("glojure.core/conj")}) -v444 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v445 := v444.FindInternedVar(lang.NewSymbol("list")) -if v445.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v445))) -} -v446 := v445.Get() -v447 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v448 := v447.FindInternedVar(lang.NewSymbol("seq")) -if v448.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v448))) -} -v449 := v448.Get() -v450 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v451 := v450.FindInternedVar(lang.NewSymbol("concat")) -if v451.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v451))) -} -v452 := v451.Get() -v453 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v454 := v453.FindInternedVar(lang.NewSymbol("list")) -if v454.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v454))) -} -v455 := v454.Get() -v456 := lang.Apply(v455, []any{lang.NewSymbol("quote")}) -v457 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v458 := v457.FindInternedVar(lang.NewSymbol("list")) -if v458.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v458))) -} -v459 := v458.Get() -v460 := lang.Apply(v459, []any{v60}) -v461 := lang.Apply(v452, []any{v456, v460}) -v462 := lang.Apply(v449, []any{v461}) -v463 := lang.Apply(v446, []any{v462}) -v464 := lang.Apply(v399, []any{v403, v439, v443, v463}) -v465 := lang.Apply(v396, []any{v464}) -v466 := lang.Apply(v393, []any{v465}) -v467 := lang.Apply(v386, []any{v390, v466}) -v468 := lang.Apply(v383, []any{v467}) -v469 := lang.Apply(v380, []any{v468}) -v470 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v471 := v470.FindInternedVar(lang.NewSymbol("list")) -if v471.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v471))) -} -v472 := v471.Get() -v473 := lang.Apply(v472, []any{nil}) -v474 := lang.Apply(v373, []any{v377, v469, v473}) -v475 := lang.Apply(v370, []any{v474}) -v476 := lang.Apply(v367, []any{v475}) -v477 := lang.Apply(v300, []any{v304, v360, v364, v476}) -v478 := lang.Apply(v297, []any{v477}) -v479 := lang.Apply(v294, []any{v478}) -v480 := lang.Apply(v116, []any{v120, v156, v157, v291, v479}) -v481 := lang.Apply(v113, []any{v480}) -return v481 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// ns-aliases -{ -v0 := lang.NewSymbol("ns-aliases").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of the aliases for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4273), lang.NewKeyword("end-line"), int(4273))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("the-ns")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{v3}) -v8, ok := lang.FieldOrMethod(v7, "getAliases") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "getAliases"))) -} -var v9 any -switch reflect.TypeOf(v8).Kind() { -case reflect.Func: - v9 = lang.Apply(v8, nil) -default: - v9 = v8 -} -return v9 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// ns-imports -{ -v0 := lang.NewSymbol("ns-imports").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of the import mappings for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4199), lang.NewKeyword("end-line"), int(4199))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("filter-key")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("val")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("partial")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("instance?")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v12, []any{v15, reflect.Type}) -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("ns-map")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v3}) -v21 := lang.Apply(v6, []any{v9, v16, v20}) -return v21 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// ns-interns -{ -v0 := lang.NewSymbol("ns-interns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of the intern mappings for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4206), lang.NewKeyword("end-line"), int(4206))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("the-ns")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v4}) -var v4 any = v8 -_ = v4 -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("filter-key")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("val")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -var v16 lang.FnFunc -v16 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v17 := args[0] -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("instance?")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{lang.*Var, v17}) -var v18 any = v22 -_ = v18 -var v24 any -if lang.IsTruthy(v18) { -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("=")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28, ok := lang.FieldOrMethod(v17, "Namespace") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v17, "Namespace"))) -} -var v29 any -switch reflect.TypeOf(v28).Kind() { -case reflect.Func: - v29 = lang.Apply(v28, nil) -default: - v29 = v28 -} -v30 := lang.Apply(v27, []any{v4, v29}) -v24 = v30 -} else { -v24 = v18 -} -return v24 -}) -v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4212), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(4213), lang.NewKeyword("end-column"), int(56)) -v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("ns-map")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v4}) -v23 := lang.Apply(v12, []any{v15, v18, v22}) -return v23 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// ns-map -{ -v0 := lang.NewSymbol("ns-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of all the mappings for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4170), lang.NewKeyword("end-line"), int(4170))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("the-ns")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{v3}) -v8, ok := lang.FieldOrMethod(v7, "Mappings") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "Mappings"))) -} -var v9 any -switch reflect.TypeOf(v8).Kind() { -case reflect.Func: - v9 = lang.Apply(v8, nil) -default: - v9 = v8 -} -return v9 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// ns-name -{ -v0 := lang.NewSymbol("ns-name").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns the name of the namespace, a symbol.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4163), lang.NewKeyword("end-line"), int(4163))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("the-ns")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{v3}) -v8, ok := lang.FieldOrMethod(v7, "Name") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "Name"))) -} -var v9 any -switch reflect.TypeOf(v8).Kind() { -case reflect.Func: - v9 = lang.Apply(v8, nil) -default: - v9 = v8 -} -return v9 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// ns-publics -{ -v0 := lang.NewSymbol("ns-publics").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of the public intern mappings for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4188), lang.NewKeyword("end-line"), int(4188))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("the-ns")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v4}) -var v4 any = v8 -_ = v4 -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("filter-key")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("val")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -var v16 lang.FnFunc -v16 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v17 := args[0] -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("instance?")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{lang.*Var, v17}) -var v18 any = v22 -_ = v18 -var v24 any -if lang.IsTruthy(v18) { -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("=")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29, ok := lang.FieldOrMethod(v17, "Namespace") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v17, "Namespace"))) -} -var v30 any -switch reflect.TypeOf(v29).Kind() { -case reflect.Func: - v30 = lang.Apply(v29, nil) -default: - v30 = v29 -} -v31 := lang.Apply(v28, []any{v4, v30}) -var v25 any = v31 -_ = v25 -var v33 any -if lang.IsTruthy(v25) { -v34, ok := lang.FieldOrMethod(v17, "IsPublic") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v17, "IsPublic"))) -} -var v35 any -switch reflect.TypeOf(v34).Kind() { -case reflect.Func: - v35 = lang.Apply(v34, nil) -default: - v35 = v34 -} -v33 = v35 -} else { -v33 = v25 -} -v24 = v33 -} else { -v24 = v18 -} -return v24 -}) -v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4194), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(4196), lang.NewKeyword("end-column"), int(48)) -v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("ns-map")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v4}) -v23 := lang.Apply(v12, []any{v15, v18, v22}) -return v23 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// ns-refers -{ -v0 := lang.NewSymbol("ns-refers").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of the refer mappings for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4253), lang.NewKeyword("end-line"), int(4253))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("the-ns")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v4}) -var v4 any = v8 -_ = v4 -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("filter-key")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("val")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -var v16 lang.FnFunc -v16 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v17 := args[0] -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("instance?")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{lang.*Var, v17}) -var v18 any = v22 -_ = v18 -var v24 any -if lang.IsTruthy(v18) { -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("not=")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28, ok := lang.FieldOrMethod(v17, "Namespace") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v17, "Namespace"))) -} -var v29 any -switch reflect.TypeOf(v28).Kind() { -case reflect.Func: - v29 = lang.Apply(v28, nil) -default: - v29 = v28 -} -v30 := lang.Apply(v27, []any{v4, v29}) -v24 = v30 -} else { -v24 = v18 -} -return v24 -}) -v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4259), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(4260), lang.NewKeyword("end-column"), int(59)) -v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("ns-map")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v4}) -v23 := lang.Apply(v12, []any{v15, v18, v22}) -return v23 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// ns-resolve -{ -v0 := lang.NewSymbol("ns-resolve").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("sym")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("env"), lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Returns the var or Class to which a symbol will be resolved in the\n namespace (unless found in the environment), else nil. Note that\n if the symbol is fully qualified, the var/Class to which it resolves\n need not be present in the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4358), lang.NewKeyword("end-line"), int(4358))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("ns-resolve")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3, nil, v4}) -return v8 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -var v6 any -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("contains?")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v4, v5}) -if lang.IsTruthy(v10) { -v6 = nil -} else { -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("the-ns")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v3}) -v15, _ := lang.FieldOrMethod(runtime5.Compiler, "maybeResolveIn") -if reflect.TypeOf(v15).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("maybeResolveIn is not a function"))) -} -v16 := lang.Apply(v15, []any{v14, v5}) -v6 = v16 -} -return v6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// ns-unalias -{ -v0 := lang.NewSymbol("ns-unalias").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Removes the alias for the symbol from the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4280), lang.NewKeyword("end-line"), int(4280))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("the-ns")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -v9, _ := lang.FieldOrMethod(v8, "removeAlias") -if reflect.TypeOf(v9).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("removeAlias is not a function"))) -} -v10 := lang.Apply(v9, []any{v4}) -return v10 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// ns-unmap -{ -v0 := lang.NewSymbol("ns-unmap").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Removes the mappings for the symbol from the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4177), lang.NewKeyword("end-line"), int(4177))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("the-ns")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -v9, _ := lang.FieldOrMethod(v8, "unmap") -if reflect.TypeOf(v9).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("unmap is not a function"))) -} -v10 := lang.Apply(v9, []any{v4}) -return v10 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// nth -{ -var v1 lang.FnFunc -{ // function nth__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("seq")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("concat")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("list")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{lang.NewSymbol(".")}) -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("list")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("list")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("seq")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("concat")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("list")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.Apply(v31, []any{lang.NewSymbol("glojure.core/Nth")}) -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("list")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("seq")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("concat")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) -} -v41 := v40.Get() -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("list")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) -} -v44 := v43.Get() -v45 := lang.Apply(v44, []any{lang.NewSymbol("glojure.core/unquote")}) -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("list")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) -} -v48 := v47.Get() -v49 := lang.Apply(v48, []any{lang.NewSymbol("glojure.core/c")}) -v50 := lang.Apply(v41, []any{v45, v49}) -v51 := lang.Apply(v38, []any{v50}) -v52 := lang.Apply(v35, []any{v51}) -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("list")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) -} -v55 := v54.Get() -v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v57 := v56.FindInternedVar(lang.NewSymbol("seq")) -if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) -} -v58 := v57.Get() -v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v60 := v59.FindInternedVar(lang.NewSymbol("concat")) -if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) -} -v61 := v60.Get() -v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v63 := v62.FindInternedVar(lang.NewSymbol("list")) -if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) -} -v64 := v63.Get() -v65 := lang.Apply(v64, []any{lang.NewSymbol("glojure.core/unquote")}) -v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v67 := v66.FindInternedVar(lang.NewSymbol("list")) -if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) -} -v68 := v67.Get() -v69 := lang.Apply(v68, []any{lang.NewSymbol("glojure.core/i")}) -v70 := lang.Apply(v61, []any{v65, v69}) -v71 := lang.Apply(v58, []any{v70}) -v72 := lang.Apply(v55, []any{v71}) -v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v74 := v73.FindInternedVar(lang.NewSymbol("list")) -if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) -} -v75 := v74.Get() -v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v77 := v76.FindInternedVar(lang.NewSymbol("seq")) -if v77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) -} -v78 := v77.Get() -v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v80 := v79.FindInternedVar(lang.NewSymbol("concat")) -if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) -} -v81 := v80.Get() -v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v83 := v82.FindInternedVar(lang.NewSymbol("list")) -if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) -} -v84 := v83.Get() -v85 := lang.Apply(v84, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) -v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v87 := v86.FindInternedVar(lang.NewSymbol("list")) -if v87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) -} -v88 := v87.Get() -v89 := lang.Apply(v88, []any{lang.NewSymbol("glojure.core/nf")}) -v90 := lang.Apply(v81, []any{v85, v89}) -v91 := lang.Apply(v78, []any{v90}) -v92 := lang.Apply(v75, []any{v91}) -v93 := lang.Apply(v28, []any{v32, v52, v72, v92}) -v94 := lang.Apply(v25, []any{v93}) -v95 := lang.Apply(v22, []any{v94}) -v96 := lang.Apply(v11, []any{v15, v19, v95}) -v97 := lang.Apply(v8, []any{v96}) -return v97 - } -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("nth").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("index")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("index"), lang.NewSymbol("not-found"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the value at the index. get returns nil if index out of\n bounds, nth throws an exception unless not-found is supplied. nth\n also works for strings, Java arrays, regex Matchers and Lists, and,\n in O(n) time, for sequences.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)int64(3)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(882), lang.NewKeyword("end-line"), int(882))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v4 := args[0] -v5 := args[1] -v6, _ := lang.FieldOrMethod(runtime5.RT, "Nth") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Nth is not a function"))) -} -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 - case 3: -v4 := args[0] -v5 := args[1] -v6 := args[2] -v7, _ := lang.FieldOrMethod(runtime5.RT, "NthDefault") -if reflect.TypeOf(v7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("NthDefault is not a function"))) -} -v8 := lang.Apply(v7, []any{v4, v5, v6}) -return v8 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// nthnext -{ -v0 := lang.NewSymbol("nthnext").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns the nth next of coll, (seq coll) when n is 0.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3147), lang.NewKeyword("end-line"), int(3147))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{lang.IDrop, v3}) -if lang.IsTruthy(v9) { -var v10 any -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("pos?")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v4}) -if lang.IsTruthy(v14) { -var v15 any -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("int?")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v4}) -if lang.IsTruthy(v19) { -v15 = v4 -} else { -v20 := lang.Apply(nil, []any{v4}) -v15 = v20 -} -v21, _ := lang.FieldOrMethod(v3, "drop") -if reflect.TypeOf(v21).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("drop is not a function"))) -} -v22 := lang.Apply(v21, []any{v15}) -v10 = v22 -} else { -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("seq")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{v3}) -v10 = v26 -} -v5 = v10 -} else { -var v27 any = v27 -_ = v27 -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("seq")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.Apply(v31, []any{v3}) -var v28 any = v32 -_ = v28 -var v33 any -for { -var v34 any -var v35 any = v28 -_ = v35 -var v37 any -if lang.IsTruthy(v35) { -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("pos?")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.Apply(v40, []any{v27}) -v37 = v41 -} else { -v37 = v35 -} -if lang.IsTruthy(v37) { -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("dec")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v27}) -var v35 any = v39 -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("next")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v28}) -var v40 any = v44 -v27 = v35 -v28 = v40 -continue -} else { -v34 = v28 -} -v33 = v34 - break -} -v5 = v33 -} -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// nthrest -{ -v0 := lang.NewSymbol("nthrest").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns the nth rest of coll, coll when n is 0.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3161), lang.NewKeyword("end-line"), int(3161))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("pos?")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v4}) -if lang.IsTruthy(v9) { -var v11 any -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("instance?")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{lang.IDrop, v3}) -if lang.IsTruthy(v15) { -var v16 any -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("int?")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v4}) -if lang.IsTruthy(v20) { -v16 = v4 -} else { -v21 := lang.Apply(nil, []any{v4}) -v16 = v21 -} -v22, _ := lang.FieldOrMethod(v3, "drop") -if reflect.TypeOf(v22).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("drop is not a function"))) -} -v23 := lang.Apply(v22, []any{v16}) -v11 = v23 -} else { -var v24 any = v24 -_ = v24 -var v25 any = v3 -_ = v25 -var v26 any -for { -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("pos?")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.Apply(v31, []any{v24}) -var v28 any = v32 -_ = v28 -var v34 any -if lang.IsTruthy(v28) { -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("seq")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v25}) -v34 = v38 -} else { -v34 = v28 -} -var v27 any = v34 -_ = v27 -var v29 any -if lang.IsTruthy(v27) { -var v30 any = v27 -_ = v30 -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("dec")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v24}) -var v32 any = v36 -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("rest")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.Apply(v40, []any{v30}) -var v37 any = v41 -v24 = v32 -v25 = v37 -continue -} else { -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("seq")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.Apply(v32, []any{v25}) -v29 = v33 -} -v26 = v29 - break -} -v11 = v26 -} -var v10 any = v11 -_ = v10 -var v25 any -if lang.IsTruthy(v10) { -v25 = v10 -} else { -v25 = lang.NewList() -} -v5 = v25 -} else { -v5 = v3 -} -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// num -{ -var v1 lang.FnFunc -{ // function num__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/num")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v3}) -v35 := lang.Apply(v26, []any{v30, v34}) -v36 := lang.Apply(v23, []any{v35}) -v37 := lang.Apply(v20, []any{v36}) -v38 := lang.Apply(v9, []any{v13, v17, v37}) -v39 := lang.Apply(v6, []any{v38}) -return v39 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("num").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to Number", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3474), lang.NewKeyword("end-line"), int(3474))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5, _ := lang.FieldOrMethod(lang.Numbers, "num") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("num is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// number? -{ -v0 := lang.NewSymbol("number?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is a Number", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3560), lang.NewKeyword("end-line"), int(3560))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.Apply(lang.IsNumber, []any{v3}) -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// numerator -{ -v1 := reflect.TypeOf((*big8.Int)(nil)) -v0 := lang.NewSymbol("numerator").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("r"))), lang.NewKeyword("doc"), "Returns the numerator part of a Ratio.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3583), lang.NewKeyword("end-line"), int(3583))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5, ok := lang.FieldOrMethod(v4, "numerator") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "numerator"))) -} -var v6 any -switch reflect.TypeOf(v5).Kind() { -case reflect.Func: - v6 = lang.Apply(v5, nil) -default: - v6 = v5 -} -return v6 -}) -v4 := reflect.TypeOf((*big8.Int)(nil)) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// object-array -{ -var v1 lang.FnFunc -{ // function object-array__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/Object_array")}) -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("list")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v26 := lang.Apply(v9, []any{v13, v17, v21, v25}) -v27 := lang.Apply(v6, []any{v26}) -return v27 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("object-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Creates an array of objects", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)), lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5349), lang.NewKeyword("end-line"), int(5349))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5, _ := lang.FieldOrMethod(runtime5.RT, "Object_array") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Object_array is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// odd? -{ -v0 := lang.NewSymbol("odd?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is odd, throws an exception if n is not an integer", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1389), lang.NewKeyword("end-line"), int(1389))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("not")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("even?")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v3}) -v11 := lang.Apply(v6, []any{v10}) -return v11 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// or -{ -v0 := lang.NewSymbol("or").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("next"))), lang.NewKeyword("doc"), "Evaluates exprs one at a time, from left to right. If a form\n returns a logical true value, or returns that value and doesn't\n evaluate any of the other expressions, otherwise it returns the\n value of the last expression. (or) returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(847), lang.NewKeyword("end-line"), int(847))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v3 := args[0] -v4 := args[1] -return nil - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -return v5 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("seq")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("concat")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("list")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/let")}) -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("list")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("apply")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("vector")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("seq")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("concat")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{lang.NewSymbol("or__0__auto__")}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v5}) -v40 := lang.Apply(v31, []any{v35, v39}) -v41 := lang.Apply(v28, []any{v40}) -v42 := lang.Apply(v22, []any{v25, v41}) -v43 := lang.Apply(v19, []any{v42}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("seq")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) -} -v49 := v48.Get() -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("concat")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("list")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) -} -v55 := v54.Get() -v56 := lang.Apply(v55, []any{lang.NewSymbol("if")}) -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("list")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) -} -v59 := v58.Get() -v60 := lang.Apply(v59, []any{lang.NewSymbol("or__0__auto__")}) -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("list")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) -} -v63 := v62.Get() -v64 := lang.Apply(v63, []any{lang.NewSymbol("or__0__auto__")}) -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("list")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) -} -v67 := v66.Get() -v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v69 := v68.FindInternedVar(lang.NewSymbol("seq")) -if v69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) -} -v70 := v69.Get() -v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v72 := v71.FindInternedVar(lang.NewSymbol("concat")) -if v72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) -} -v73 := v72.Get() -v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v75 := v74.FindInternedVar(lang.NewSymbol("list")) -if v75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) -} -v76 := v75.Get() -v77 := lang.Apply(v76, []any{lang.NewSymbol("glojure.core/or")}) -v78 := lang.Apply(v73, []any{v77, v6}) -v79 := lang.Apply(v70, []any{v78}) -v80 := lang.Apply(v67, []any{v79}) -v81 := lang.Apply(v52, []any{v56, v60, v64, v80}) -v82 := lang.Apply(v49, []any{v81}) -v83 := lang.Apply(v46, []any{v82}) -v84 := lang.Apply(v12, []any{v16, v43, v83}) -v85 := lang.Apply(v9, []any{v84}) -return v85 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// parents -{ -v0 := lang.NewSymbol("parents").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"))), lang.NewKeyword("doc"), "Returns the immediate parents of tag, either via a Java type\n inheritance relationship or a relationship established via derive. h\n must be a hierarchy obtained from make-hierarchy, if not supplied\n defaults to the global hierarchy", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5564), lang.NewKeyword("end-line"), int(5564))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("parents")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("global-hierarchy")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v6, []any{v9, v3}) -return v10 - case 2: -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("not-empty")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("get")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(lang.NewKeyword("parents"), []any{v3}) -v13 := lang.Apply(v11, []any{v12, v4}) -var v8 any = v13 -_ = v8 -var v15 any -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("class?")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v4}) -if lang.IsTruthy(v19) { -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("into1")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("set")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("bases")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.Apply(v28, []any{v4}) -v30 := lang.Apply(v25, []any{v29}) -v31 := lang.Apply(v22, []any{v30, v8}) -v15 = v31 -} else { -v15 = v8 -} -v8 := lang.Apply(v7, []any{v15}) -return v8 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// parse-boolean -{ -v0 := lang.NewSymbol("parse-boolean").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse strings \"true\" or \"false\" and return a boolean, or nil if invalid", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7957), lang.NewKeyword("end-line"), int(7957))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("string?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -if lang.IsTruthy(v8) { -var v9 any = v3 -_ = v9 -v4 = nil -} else { -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("parsing-err")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v3}) -v13 := lang.Apply(lang.NewIllegalArgumentError, []any{v12}) -panic(v13) -} -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// parse-double -{ -v0 := lang.NewSymbol("parse-double").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse string with floating point components and return a Double value,\n or nil if parse fails.\n\n Grammar: https://docs.oracle.com/javase/8/docs/api/java/lang/Double.html#valueOf-java.lang.String-", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7935), lang.NewKeyword("end-line"), int(7935))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("string?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -if lang.IsTruthy(v8) { -v10 := lang.Apply(strconv15.ParseFloat, []any{v3, int64(64)}) -var v9 any = v10 -_ = v9 -var v12 any -v13 := lang.Apply(v9, []any{int64(1)}) -if lang.IsTruthy(v13) { -v12 = nil -} else { -v14 := lang.Apply(v9, []any{int64(0)}) -v12 = v14 -} -v4 = v12 -} else { -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("parsing-err")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v3}) -v13 := lang.Apply(lang.NewIllegalArgumentError, []any{v12}) -panic(v13) -} -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// parse-impls -{ -v0 := lang.NewSymbol("parse-impls").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(13), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(13), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("specs"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v5 := lang.NewMap() -v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(14), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(14), lang.NewKeyword("end-column"), int(15)) -v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v4 any = v7 -_ = v4 -var v8 any = v3 -_ = v8 -var v9 any -for { -var v10 any -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("seq")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v8}) -if lang.IsTruthy(v14) { -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("assoc")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("first")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v8}) -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("take-while")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("seq?")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("next")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.Apply(v31, []any{v8}) -v33 := lang.Apply(v25, []any{v28, v32}) -v34 := lang.Apply(v18, []any{v4, v22, v33}) -var v15 any = v34 -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("drop-while")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("seq?")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) -} -v41 := v40.Get() -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("next")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) -} -v44 := v43.Get() -v45 := lang.Apply(v44, []any{v8}) -v46 := lang.Apply(v38, []any{v41, v45}) -var v35 any = v46 -v4 = v15 -v8 = v35 -continue -} else { -v10 = v4 -} -v9 = v10 - break -} -return v9 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// parse-long -{ -v0 := lang.NewSymbol("parse-long").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse string of decimal digits with optional leading -/+ and return a\n Long value, or nil if parse fails", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7926), lang.NewKeyword("end-line"), int(7926))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("string?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -if lang.IsTruthy(v8) { -v10 := lang.Apply(strconv15.ParseInt, []any{v3, int64(10), int64(64)}) -var v9 any = v10 -_ = v9 -var v12 any -v13 := lang.Apply(v9, []any{int64(1)}) -if lang.IsTruthy(v13) { -v12 = nil -} else { -v14 := lang.Apply(v9, []any{int64(0)}) -v12 = v14 -} -v4 = v12 -} else { -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("parsing-err")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v3}) -v13 := lang.Apply(lang.NewIllegalArgumentError, []any{v12}) -panic(v13) -} -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// parse-uuid -{ -v0 := lang.NewSymbol("parse-uuid").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse a string representing a UUID and return a java.util.UUID instance,\n or nil if parse fails.\n\n Grammar: https://docs.oracle.com/javase/8/docs/api/java/util/UUID.html#toString--", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7946), lang.NewKeyword("end-line"), int(7946))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -var v4 any -func() { -defer func() { -if r := recover(); r != nil { -if lang.CatchMatches(r, lang.*IllegalArgumentError) { -v5 := r -_ = v5 -v4 = nil -} else { -panic(r) -} -} -}() -v6 := lang.Apply(uuid16.Parse, []any{v3}) -var v5 any = v6 -_ = v5 -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("nth")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v5, int64(0), nil}) -var v7 any = v11 -_ = v7 -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("nth")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v5, int64(1), nil}) -var v12 any = v16 -_ = v12 -var v18 any -if lang.IsTruthy(v12) { -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("str")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{"Error parsing UUID: ", v12}) -v23 := lang.Apply(lang.NewIllegalArgumentError, []any{v22}) -panic(v23) -} else { -v18 = v7 -} -v4 = v18 -}() -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// parsing-err -{ -v0 := lang.NewSymbol("parsing-err").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Construct message for parsing for non-string parsing error", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(7921), lang.NewKeyword("end-line"), int(7921), lang.NewKeyword("private"), true)).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("str")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -var v7 any -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("nil?")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v3}) -if lang.IsTruthy(v11) { -v7 = "nil" -} else { -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("class")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v3}) -v16, ok := lang.FieldOrMethod(v15, "Name") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v15, "Name"))) -} -var v17 any -switch reflect.TypeOf(v16).Kind() { -case reflect.Func: - v17 = lang.Apply(v16, nil) -default: - v17 = v16 -} -v7 = v17 -} -v18 := lang.Apply(v6, []any{"Expected string, got ", v7}) -return v18 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// partial -{ -v0 := lang.NewSymbol("partial").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("arg1")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("arg1"), lang.NewSymbol("arg2")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("arg1"), lang.NewSymbol("arg2"), lang.NewSymbol("arg3")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("arg1"), lang.NewSymbol("arg2"), lang.NewSymbol("arg3"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Takes a function f and fewer than the normal arguments to f, and\n returns a fn that takes a variable number of additional args. When\n called, the returned function calls f with args + additional args.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2606), lang.NewKeyword("end-line"), int(2606))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -return v3 - case 2: -v3 := args[0] -v4 := args[1] -var v5 lang.FnFunc -v5 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v6 := lang.Apply(v3, []any{v4}) -return v6 - case 1: -v6 := args[0] -v7 := lang.Apply(v3, []any{v4, v6}) -return v7 - case 2: -v6 := args[0] -v7 := args[1] -v8 := lang.Apply(v3, []any{v4, v6, v7}) -return v8 - case 3: -v6 := args[0] -v7 := args[1] -v8 := args[2] -v9 := lang.Apply(v3, []any{v4, v6, v7, v8}) -return v9 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v6 := args[0] -v7 := args[1] -v8 := args[2] -v9 := lang.NewList(args[3:]...) -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("apply")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{v3, v4, v6, v7, v8, v9}) -return v13 - } -}) -v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2614), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(2619), lang.NewKeyword("end-column"), int(48)) -v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v7 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -var v6 lang.FnFunc -v6 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v7 := lang.Apply(v3, []any{v4, v5}) -return v7 - case 1: -v7 := args[0] -v8 := lang.Apply(v3, []any{v4, v5, v7}) -return v8 - case 2: -v7 := args[0] -v8 := args[1] -v9 := lang.Apply(v3, []any{v4, v5, v7, v8}) -return v9 - case 3: -v7 := args[0] -v8 := args[1] -v9 := args[2] -v10 := lang.Apply(v3, []any{v4, v5, v7, v8, v9}) -return v10 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v7 := args[0] -v8 := args[1] -v9 := args[2] -v10 := lang.NewList(args[3:]...) -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("apply")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v3, v4, v5, v7, v8, v9, v10}) -return v14 - } -}) -v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2621), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(2626), lang.NewKeyword("end-column"), int(53)) -v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v8 - case 4: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -var v7 lang.FnFunc -v7 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v8 := lang.Apply(v3, []any{v4, v5, v6}) -return v8 - case 1: -v8 := args[0] -v9 := lang.Apply(v3, []any{v4, v5, v6, v8}) -return v9 - case 2: -v8 := args[0] -v9 := args[1] -v10 := lang.Apply(v3, []any{v4, v5, v6, v8, v9}) -return v10 - case 3: -v8 := args[0] -v9 := args[1] -v10 := args[2] -v11 := lang.Apply(v3, []any{v4, v5, v6, v8, v9, v10}) -return v11 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v8 := args[0] -v9 := args[1] -v10 := args[2] -v11 := lang.NewList(args[3:]...) -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("apply")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v3, v4, v5, v6, v8, v9, v10, v11}) -return v15 - } -}) -v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2628), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(2633), lang.NewKeyword("end-column"), int(58)) -v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v9 - default: - if len(args) < 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := lang.NewList(args[4:]...) -var v8 lang.FnFunc -v8 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v9 := lang.NewList(args[0:]...) -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("apply")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("concat")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v7, v9}) -v17 := lang.Apply(v12, []any{v3, v4, v5, v6, v16}) -return v17 - } -}) -v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2635), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(2635), lang.NewKeyword("end-column"), int(60)) -v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v10 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// partition -{ -v0 := lang.NewSymbol("partition").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("pad"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of lists of n items each, at offsets step\n apart. If step is not supplied, defaults to n, i.e. the partitions\n do not overlap. If a pad collection is supplied, use its elements as\n necessary to complete last partition upto n items. In case there are\n not enough padding elements, return a partition with less than n items.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3177), lang.NewKeyword("end-line"), int(3177))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("partition")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3, v3, v4}) -return v8 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -var v6 lang.FnFunc -v6 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("seq")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v5}) -var v7 any = v11 -_ = v7 -var v13 any -if lang.IsTruthy(v7) { -var v14 any = v7 -_ = v14 -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("doall")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("take")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.Apply(v22, []any{v3, v14}) -v24 := lang.Apply(v19, []any{v23}) -var v16 any = v24 -_ = v16 -var v26 any -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("=")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("count")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.Apply(v32, []any{v16}) -v34 := lang.Apply(v29, []any{v3, v33}) -if lang.IsTruthy(v34) { -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("cons")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("partition")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("nthrest")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v14, v4}) -v45 := lang.Apply(v40, []any{v3, v4, v44}) -v46 := lang.Apply(v37, []any{v16, v45}) -v26 = v46 -} else { -v26 = nil -} -v13 = v26 -} else { -v13 = nil -} -return v13 -}) -v7 := lang.Apply(lang.NewLazySeq, []any{v6}) -return v7 - case 4: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -var v7 lang.FnFunc -v7 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("seq")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v6}) -var v8 any = v12 -_ = v8 -var v14 any -if lang.IsTruthy(v8) { -var v15 any = v8 -_ = v15 -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("doall")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("take")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v3, v15}) -v25 := lang.Apply(v20, []any{v24}) -var v17 any = v25 -_ = v17 -var v27 any -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("=")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("count")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v17}) -v35 := lang.Apply(v30, []any{v3, v34}) -if lang.IsTruthy(v35) { -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("cons")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("partition")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) -} -v41 := v40.Get() -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("nthrest")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) -} -v44 := v43.Get() -v45 := lang.Apply(v44, []any{v15, v4}) -v46 := lang.Apply(v41, []any{v3, v4, v5, v45}) -v47 := lang.Apply(v38, []any{v17, v46}) -v27 = v47 -} else { -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v52 := v51.FindInternedVar(lang.NewSymbol("take")) -if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) -} -v53 := v52.Get() -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("concat")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) -} -v56 := v55.Get() -v57 := lang.Apply(v56, []any{v17, v5}) -v58 := lang.Apply(v53, []any{v3, v57}) -v59 := lang.Apply(v50, []any{v58}) -v27 = v59 -} -v14 = v27 -} else { -v14 = nil -} -return v14 -}) -v8 := lang.Apply(lang.NewLazySeq, []any{v7}) -return v8 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// partition-all -{ -v0 := lang.NewSymbol("partition-all").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of lists like partition, but may include\n partitions with fewer than n items at the end. Returns a stateful\n transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7222), lang.NewKeyword("end-line"), int(7222))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := args[0] -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("to-array")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v3}) -v11 := lang.Apply(lang.NewArrayList, []any{v10}) -var v6 any = v11 -_ = v6 -var v13 lang.FnFunc -v13 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v14 := lang.Apply(v5, nil) -return v14 - case 1: -v14 := args[0] -var v16 any -v17, ok := lang.FieldOrMethod(v6, "isEmpty") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "isEmpty"))) -} -var v18 any -switch reflect.TypeOf(v17).Kind() { -case reflect.Func: - v18 = lang.Apply(v17, nil) -default: - v18 = v17 -} -if lang.IsTruthy(v18) { -v16 = v15 -} else { -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("vec")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23, ok := lang.FieldOrMethod(v6, "toArray") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "toArray"))) -} -var v24 any -switch reflect.TypeOf(v23).Kind() { -case reflect.Func: - v24 = lang.Apply(v23, nil) -default: - v24 = v23 -} -v25 := lang.Apply(v22, []any{v24}) -var v19 any = v25 -_ = v19 -v27, ok := lang.FieldOrMethod(v6, "clear") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "clear"))) -} -var v28 any -switch reflect.TypeOf(v27).Kind() { -case reflect.Func: - v28 = lang.Apply(v27, nil) -default: - v28 = v27 -} -_ = v28 -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("unreduced")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.Apply(v5, []any{v15, v19}) -v33 := lang.Apply(v31, []any{v32}) -v16 = v33 -} -var v15 any = v16 -_ = v15 -v20 := lang.Apply(v5, []any{v15}) -return v20 - case 2: -v14 := args[0] -v15 := args[1] -v16, _ := lang.FieldOrMethod(v6, "add") -if reflect.TypeOf(v16).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) -} -v17 := lang.Apply(v16, []any{v15}) -_ = v17 -var v18 any -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("=")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22, ok := lang.FieldOrMethod(v6, "size") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "size"))) -} -var v23 any -switch reflect.TypeOf(v22).Kind() { -case reflect.Func: - v23 = lang.Apply(v22, nil) -default: - v23 = v22 -} -v24 := lang.Apply(v21, []any{v3, v23}) -if lang.IsTruthy(v24) { -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("vec")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29, ok := lang.FieldOrMethod(v6, "toArray") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "toArray"))) -} -var v30 any -switch reflect.TypeOf(v29).Kind() { -case reflect.Func: - v30 = lang.Apply(v29, nil) -default: - v30 = v29 -} -v31 := lang.Apply(v28, []any{v30}) -var v25 any = v31 -_ = v25 -v33, ok := lang.FieldOrMethod(v6, "clear") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "clear"))) -} -var v34 any -switch reflect.TypeOf(v33).Kind() { -case reflect.Func: - v34 = lang.Apply(v33, nil) -default: - v34 = v33 -} -_ = v34 -v35 := lang.Apply(v5, []any{v14, v25}) -v18 = v35 -} else { -v18 = v14 -} -return v18 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7231), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7247), lang.NewKeyword("end-column"), int(23)) -v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v15 -}) -v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7229), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7247), lang.NewKeyword("end-column"), int(25)) -v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v6 - case 2: -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("partition-all")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3, v3, v4}) -return v8 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -var v6 lang.FnFunc -v6 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("seq")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v5}) -var v7 any = v11 -_ = v7 -var v13 any -if lang.IsTruthy(v7) { -var v14 any = v7 -_ = v14 -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("doall")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("take")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.Apply(v22, []any{v3, v14}) -v24 := lang.Apply(v19, []any{v23}) -var v16 any = v24 -_ = v16 -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("cons")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("partition-all")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("nthrest")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v14, v4}) -v36 := lang.Apply(v31, []any{v3, v4, v35}) -v37 := lang.Apply(v28, []any{v16, v36}) -v13 = v37 -} else { -v13 = nil -} -return v13 -}) -v7 := lang.Apply(lang.NewLazySeq, []any{v6}) -return v7 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// partition-by -{ -v0 := lang.NewSymbol("partition-by").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Applies f to each value in coll, splitting it each time f returns a\n new value. Returns a lazy seq of partitions. Returns a stateful\n transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7142), lang.NewKeyword("end-line"), int(7142))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := args[0] -var v6 any = "unimplemented: new with non-constant class type" -_ = v6 -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("volatile!")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{lang.NewKeyword("glojure.core/none")}) -var v7 any = v11 -_ = v7 -var v13 lang.FnFunc -v13 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v14 := lang.Apply(v5, nil) -return v14 - case 1: -v14 := args[0] -var v16 any -v17, ok := lang.FieldOrMethod(v6, "isEmpty") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "isEmpty"))) -} -var v18 any -switch reflect.TypeOf(v17).Kind() { -case reflect.Func: - v18 = lang.Apply(v17, nil) -default: - v18 = v17 -} -if lang.IsTruthy(v18) { -v16 = v15 -} else { -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("vec")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23, ok := lang.FieldOrMethod(v6, "toArray") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "toArray"))) -} -var v24 any -switch reflect.TypeOf(v23).Kind() { -case reflect.Func: - v24 = lang.Apply(v23, nil) -default: - v24 = v23 -} -v25 := lang.Apply(v22, []any{v24}) -var v19 any = v25 -_ = v19 -v27, ok := lang.FieldOrMethod(v6, "clear") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "clear"))) -} -var v28 any -switch reflect.TypeOf(v27).Kind() { -case reflect.Func: - v28 = lang.Apply(v27, nil) -default: - v28 = v27 -} -_ = v28 -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("unreduced")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.Apply(v5, []any{v15, v19}) -v33 := lang.Apply(v31, []any{v32}) -v16 = v33 -} -var v15 any = v16 -_ = v15 -v20 := lang.Apply(v5, []any{v15}) -return v20 - case 2: -v14 := args[0] -v15 := args[1] -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("deref")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v7}) -var v16 any = v20 -_ = v16 -v22 := lang.Apply(v3, []any{v15}) -var v21 any = v22 -_ = v21 -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("vreset!")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v7, v21}) -_ = v27 -var v28 any -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("identical?")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.Apply(v32, []any{v16, lang.NewKeyword("glojure.core/none")}) -var v29 any = v33 -_ = v29 -var v35 any -if lang.IsTruthy(v29) { -v35 = v29 -} else { -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("=")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v21, v16}) -v35 = v39 -} -if lang.IsTruthy(v35) { -v29, _ := lang.FieldOrMethod(v6, "add") -if reflect.TypeOf(v29).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) -} -v30 := lang.Apply(v29, []any{v15}) -_ = v30 -v28 = v14 -} else { -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("vec")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35, ok := lang.FieldOrMethod(v6, "toArray") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "toArray"))) -} -var v36 any -switch reflect.TypeOf(v35).Kind() { -case reflect.Func: - v36 = lang.Apply(v35, nil) -default: - v36 = v35 -} -v37 := lang.Apply(v34, []any{v36}) -var v31 any = v37 -_ = v31 -v39, ok := lang.FieldOrMethod(v6, "clear") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "clear"))) -} -var v40 any -switch reflect.TypeOf(v39).Kind() { -case reflect.Func: - v40 = lang.Apply(v39, nil) -default: - v40 = v39 -} -_ = v40 -v42 := lang.Apply(v5, []any{v14, v31}) -var v41 any = v42 -_ = v41 -var v44 any -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("reduced?")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.Apply(v47, []any{v41}) -if lang.IsTruthy(v48) { -v44 = nil -} else { -v49, _ := lang.FieldOrMethod(v6, "add") -if reflect.TypeOf(v49).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) -} -v50 := lang.Apply(v49, []any{v15}) -v44 = v50 -} -_ = v44 -v28 = v41 -} -return v28 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7152), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(7176), lang.NewKeyword("end-column"), int(28)) -v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v15 -}) -v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7149), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(7176), lang.NewKeyword("end-column"), int(30)) -v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v6 - case 2: -v3 := args[0] -v4 := args[1] -var v5 lang.FnFunc -v5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("seq")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v4}) -var v6 any = v10 -_ = v6 -var v12 any -if lang.IsTruthy(v6) { -var v13 any = v6 -_ = v13 -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("first")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v13}) -var v15 any = v19 -_ = v15 -v21 := lang.Apply(v3, []any{v15}) -var v20 any = v21 -_ = v20 -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("cons")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("take-while")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -var v29 lang.FnFunc -v29 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v30 := args[0] -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("=")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v3, []any{v30}) -v35 := lang.Apply(v33, []any{v20, v34}) -return v35 -}) -v30 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7182), lang.NewKeyword("column"), int(41), lang.NewKeyword("end-line"), int(7182), lang.NewKeyword("end-column"), int(53)) -v31, err := lang.WithMeta(v29, v30.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("next")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v13}) -v36 := lang.Apply(v28, []any{v31, v35}) -v37 := lang.Apply(v25, []any{v15, v36}) -var v22 any = v37 -_ = v22 -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("cons")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) -} -v41 := v40.Get() -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("partition-by")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) -} -v44 := v43.Get() -var v45 lang.FnFunc -v45 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("drop")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) -} -v48 := v47.Get() -v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v50 := v49.FindInternedVar(lang.NewSymbol("count")) -if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) -} -v51 := v50.Get() -v52 := lang.Apply(v51, []any{v22}) -v53 := lang.Apply(v48, []any{v52, v13}) -return v53 -}) -v46 := lang.Apply(lang.NewLazySeq, []any{v45}) -v47 := lang.Apply(v44, []any{v3, v46}) -v48 := lang.Apply(v41, []any{v22, v47}) -v12 = v48 -} else { -v12 = nil -} -return v12 -}) -v6 := lang.Apply(lang.NewLazySeq, []any{v5}) -return v6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// partitionv -{ -v0 := lang.NewSymbol("partitionv").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("pad"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of vectors of n items each, at offsets step\n apart. If step is not supplied, defaults to n, i.e. the partitions\n do not overlap. If a pad collection is supplied, use its elements as\n necessary to complete last partition upto n items. In case there are\n not enough padding elements, return a partition with less than n items.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7262), lang.NewKeyword("end-line"), int(7262))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("partitionv")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3, v3, v4}) -return v8 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -var v6 lang.FnFunc -v6 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("seq")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v5}) -var v7 any = v11 -_ = v7 -var v13 any -if lang.IsTruthy(v7) { -var v14 any = v7 -_ = v14 -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("into")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.NewVector() -v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7274), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(7274), lang.NewKeyword("end-column"), int(23)) -v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("take")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{v3}) -v27 := lang.Apply(v19, []any{v22, v26, v14}) -var v16 any = v27 -_ = v16 -var v29 any -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("=")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("count")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v16}) -v37 := lang.Apply(v32, []any{v3, v36}) -if lang.IsTruthy(v37) { -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("cons")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("partitionv")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("nthrest")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v14, v4}) -v48 := lang.Apply(v43, []any{v3, v4, v47}) -v49 := lang.Apply(v40, []any{v16, v48}) -v29 = v49 -} else { -v29 = nil -} -v13 = v29 -} else { -v13 = nil -} -return v13 -}) -v7 := lang.Apply(lang.NewLazySeq, []any{v6}) -return v7 - case 4: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -var v7 lang.FnFunc -v7 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("seq")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v6}) -var v8 any = v12 -_ = v8 -var v14 any -if lang.IsTruthy(v8) { -var v15 any = v8 -_ = v15 -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("into")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.NewVector() -v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7280), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(7280), lang.NewKeyword("end-column"), int(23)) -v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("take")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v3}) -v28 := lang.Apply(v20, []any{v23, v27, v15}) -var v17 any = v28 -_ = v17 -var v30 any -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("=")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("count")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.Apply(v36, []any{v17}) -v38 := lang.Apply(v33, []any{v3, v37}) -if lang.IsTruthy(v38) { -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("cons")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) -} -v41 := v40.Get() -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("partitionv")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) -} -v44 := v43.Get() -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("nthrest")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.Apply(v47, []any{v15, v4}) -v49 := lang.Apply(v44, []any{v3, v4, v5, v48}) -v50 := lang.Apply(v41, []any{v17, v49}) -v30 = v50 -} else { -v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v52 := v51.FindInternedVar(lang.NewSymbol("list")) -if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) -} -v53 := v52.Get() -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("into")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) -} -v56 := v55.Get() -v57 := lang.NewVector() -v58 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7283), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(7283), lang.NewKeyword("end-column"), int(25)) -v59, err := lang.WithMeta(v57, v58.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v61 := v60.FindInternedVar(lang.NewSymbol("take")) -if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) -} -v62 := v61.Get() -v63 := lang.Apply(v62, []any{v3}) -v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v65 := v64.FindInternedVar(lang.NewSymbol("concat")) -if v65.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) -} -v66 := v65.Get() -v67 := lang.Apply(v66, []any{v17, v5}) -v68 := lang.Apply(v56, []any{v59, v63, v67}) -v69 := lang.Apply(v53, []any{v68}) -v30 = v69 -} -v14 = v30 -} else { -v14 = nil -} -return v14 -}) -v8 := lang.Apply(lang.NewLazySeq, []any{v7}) -return v8 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// partitionv-all -{ -v0 := lang.NewSymbol("partitionv-all").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of vector partitions, but may include\n partitions with fewer than n items at the end.\n Returns a stateful transducer when no collection is provided.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7285), lang.NewKeyword("end-line"), int(7285))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("partition-all")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{v3}) -return v7 - case 2: -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("partitionv-all")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3, v3, v4}) -return v8 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -var v6 lang.FnFunc -v6 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("seq")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v5}) -var v7 any = v11 -_ = v7 -var v13 any -if lang.IsTruthy(v7) { -var v14 any = v7 -_ = v14 -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("into")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.NewVector() -v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7297), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(7297), lang.NewKeyword("end-column"), int(25)) -v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("take")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{v3}) -v27 := lang.Apply(v19, []any{v22, v26, v5}) -var v16 any = v27 -_ = v16 -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("cons")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("partitionv-all")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("drop")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v4, v14}) -v39 := lang.Apply(v34, []any{v3, v4, v38}) -v40 := lang.Apply(v31, []any{v16, v39}) -v13 = v40 -} else { -v13 = nil -} -return v13 -}) -v7 := lang.Apply(lang.NewLazySeq, []any{v6}) -return v7 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// pcalls -{ -v0 := lang.NewSymbol("pcalls").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("fns"))), lang.NewKeyword("doc"), "Executes the no-arg fns in parallel, returning a lazy sequence of\n their values", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7056), lang.NewKeyword("end-line"), int(7056))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewList(args[0:]...) -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("pmap")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -var v7 lang.FnFunc -v7 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v8 := args[0] -v9 := lang.Apply(v8, nil) -return v9 -}) -v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7061), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(7061), lang.NewKeyword("end-column"), int(20)) -v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v10 := lang.Apply(v6, []any{v9, v3}) -return v10 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// peek -{ -v0 := lang.NewSymbol("peek").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "For a list or queue, same as first, for a vector, same as, but much\n more efficient than, last. If the collection is empty, returns nil.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1455), lang.NewKeyword("end-line"), int(1455))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, _ := lang.FieldOrMethod(runtime5.RT, "Peek") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Peek is not a function"))) -} -v5 := lang.Apply(v4, []any{v3}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// persistent! -{ -v0 := lang.NewSymbol("persistent!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a new, persistent version of the transient collection, in\n constant time. The transient collection cannot be used after this\n call, any such use will throw an exception.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3350), lang.NewKeyword("end-line"), int(3350))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, ok := lang.FieldOrMethod(v3, "Persistent") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "Persistent"))) -} -var v5 any -switch reflect.TypeOf(v4).Kind() { -case reflect.Func: - v5 = lang.Apply(v4, nil) -default: - v5 = v4 -} -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// pmap -{ -v0 := lang.NewSymbol("pmap").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Like map, except f is applied in parallel. Semi-lazy in that the\n parallel computation stays ahead of the consumption, but doesn't\n realize the entire result unless required. Only useful for\n computationally intensive functions where the time of f dominates\n the coordination overhead.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7031), lang.NewKeyword("end-line"), int(7031))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v3 := args[0] -v4 := args[1] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("+")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(runtime17.NumCPU, nil) -v10 := lang.Apply(v8, []any{int64(2), v9}) -var v5 any = v10 -_ = v5 -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("map")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -var v15 lang.FnFunc -v15 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v16 := args[0] -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("future-call")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -var v20 lang.FnFunc -v20 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v21 := lang.Apply(v3, []any{v16}) -return v21 -}) -v21 := lang.Apply(v19, []any{v20}) -return v21 -}) -v16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7041), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7041), lang.NewKeyword("end-column"), int(34)) -v17, err := lang.WithMeta(v15, v16.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v18 := lang.Apply(v14, []any{v17, v4}) -var v11 any = v18 -_ = v11 -var v20 lang.FnFunc -{ // function step -v20 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v22 := args[0] -v23 := args[1] -var v24 any = v22 -_ = v24 -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("seq")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.Apply(v28, []any{v24}) -var v25 any = v29 -_ = v25 -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("first")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v25}) -var v30 any = v34 -_ = v30 -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("next")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v35}) -var v35 any = v39 -_ = v35 -var v40 any = v30 -_ = v40 -var v41 any = v35 -_ = v41 -var v42 any = v24 -_ = v42 -var v44 lang.FnFunc -v44 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("seq")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) -} -v48 := v47.Get() -v49 := lang.Apply(v48, []any{v23}) -var v45 any = v49 -_ = v45 -var v51 any -if lang.IsTruthy(v45) { -var v52 any = v45 -_ = v52 -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("cons")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) -} -v56 := v55.Get() -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("deref")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) -} -v59 := v58.Get() -v60 := lang.Apply(v59, []any{v40}) -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("rest")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) -} -v63 := v62.Get() -v64 := lang.Apply(v63, []any{v52}) -v65 := lang.Apply(v21, []any{v41, v64}) -v66 := lang.Apply(v56, []any{v60, v65}) -v51 = v66 -} else { -v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("map")) -if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) -} -v54 := v53.Get() -v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v56 := v55.FindInternedVar(lang.NewSymbol("deref")) -if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) -} -v57 := v56.Get() -v58 := lang.Apply(v54, []any{v57, v42}) -v51 = v58 -} -return v51 -}) -v45 := lang.Apply(lang.NewLazySeq, []any{v44}) -return v45 -}) -v21 := v20 -_ = v21 -} -v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7042), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(7046), lang.NewKeyword("end-column"), int(36)) -v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v19 any = v22 -_ = v19 -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("drop")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v5, v11}) -v28 := lang.Apply(v19, []any{v11, v27}) -return v28 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -var v7 lang.FnFunc -{ // function step -v7 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v9 := args[0] -var v10 lang.FnFunc -v10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("map")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("seq")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v14, []any{v17, v9}) -var v11 any = v18 -_ = v11 -var v20 any -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("every?")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("identity")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v23, []any{v26, v11}) -if lang.IsTruthy(v27) { -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("cons")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("map")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("first")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.Apply(v33, []any{v36, v11}) -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("map")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("rest")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v40, []any{v43, v11}) -v45 := lang.Apply(v8, []any{v44}) -v46 := lang.Apply(v30, []any{v37, v45}) -v20 = v46 -} else { -v20 = nil -} -return v20 -}) -v11 := lang.Apply(lang.NewLazySeq, []any{v10}) -return v11 -}) -v8 := v7 -_ = v8 -} -v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7049), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(7053), lang.NewKeyword("end-column"), int(67)) -v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v6 any = v9 -_ = v6 -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("pmap")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -var v14 lang.FnFunc -v14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v15 := args[0] -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("apply")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v3, v15}) -return v19 -}) -v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7054), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(7054), lang.NewKeyword("end-column"), int(23)) -v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("cons")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v4, v5}) -v21 := lang.Apply(v6, []any{v20}) -v22 := lang.Apply(v13, []any{v16, v21}) -return v22 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// pop -{ -v0 := lang.NewSymbol("pop").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "For a list or queue, returns a new list/queue without the first\n item, for a vector, returns a new vector without the last item. If\n the collection is empty, throws an exception. Note - not the same\n as next/butlast.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1462), lang.NewKeyword("end-line"), int(1462))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, _ := lang.FieldOrMethod(runtime5.RT, "Pop") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Pop is not a function"))) -} -v5 := lang.Apply(v4, []any{v3}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// pop! -{ -v0 := lang.NewSymbol("pop!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Removes the last item from a transient vector. If\n the collection is empty, throws an exception. Returns coll", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3393), lang.NewKeyword("end-line"), int(3393))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, ok := lang.FieldOrMethod(v3, "pop") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "pop"))) -} -var v5 any -switch reflect.TypeOf(v4).Kind() { -case reflect.Func: - v5 = lang.Apply(v4, nil) -default: - v5 = v4 -} -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// pop-thread-bindings -{ -v0 := lang.NewSymbol("pop-thread-bindings").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Pop one set of bindings pushed with push-binding before. It is an error to\n pop bindings without pushing before.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1929), lang.NewKeyword("end-line"), int(1929))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.Apply(lang.PopThreadBindings, nil) -return v3 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// pos-int? -{ -v0 := lang.NewSymbol("pos-int?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a positive fixed precision integer", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1403), lang.NewKeyword("end-line"), int(1403))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("int?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -var v4 any = v8 -_ = v4 -var v10 any -if lang.IsTruthy(v4) { -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("pos?")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v3}) -v10 = v14 -} else { -v10 = v4 -} -return v10 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// pos? -{ -var v1 lang.FnFunc -{ // function pos?__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/isPos")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v3}) -v35 := lang.Apply(v26, []any{v30, v34}) -v36 := lang.Apply(v23, []any{v35}) -v37 := lang.Apply(v20, []any{v36}) -v38 := lang.Apply(v9, []any{v13, v17, v37}) -v39 := lang.Apply(v6, []any{v38}) -return v39 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("pos?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns true if num is greater than zero, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1252), lang.NewKeyword("end-line"), int(1252))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5, _ := lang.FieldOrMethod(lang.Numbers, "isPos") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("isPos is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// pr -{ -v0 := lang.NewSymbol("pr").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Prints the object(s) to the output stream that is the current value\n of *out*. Prints the object(s), separated by spaces if there is\n more than one. By default, pr and prn print in a way that objects\n can be read by the reader", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3678), lang.NewKeyword("end-line"), int(3678), lang.NewKeyword("dynamic"), true)).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -return nil - case 1: -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("pr-on")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("*out*")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v6, []any{v3, v9}) -return v10 - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.NewList(args[1:]...) -recur_loop_671: -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("pr")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -_ = v8 -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("*out*")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(lang.AppendWriter, []any{v11, lang.NewChar(32)}) -_ = v12 -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("next")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v4}) -var v13 any = v17 -_ = v13 -var v19 any -if lang.IsTruthy(v13) { -var v20 any = v13 -_ = v20 -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("first")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{v4}) -var v22 any = v26 -var v27 any = v20 -v3 = v22 -v4 = v27 -goto recur_loop_671 -} else { -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("apply")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("pr")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v22, []any{v25, v4}) -v19 = v26 -} -return v19 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// pr-on -{ -v0 := lang.NewSymbol("pr-on").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("w"))), lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3669), lang.NewKeyword("end-line"), int(3669), lang.NewKeyword("private"), true)).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("*print-dup*")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -if lang.IsTruthy(v8) { -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("print-dup")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v3, v4}) -v5 = v12 -} else { -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("print-method")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v3, v4}) -v5 = v16 -} -_ = v5 -return nil -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// pr-str -{ -v1 := reflect.TypeOf("") -v0 := lang.NewSymbol("pr-str").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("xs"))), lang.NewKeyword("doc"), "pr to a string, returning it", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4758), lang.NewKeyword("end-line"), int(4758))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := lang.NewList(args[0:]...) -var v5 any = "unimplemented: new with non-constant class type" -_ = v5 -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("push-thread-bindings")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("hash-map")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*out*")) -v15 := lang.Apply(v13, []any{v14, v5}) -v16 := lang.Apply(v10, []any{v15}) -_ = v16 -var v17 any -func() { -defer func() { -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v20, nil) -}() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("apply")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("pr")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.Apply(v24, []any{v27, v4}) -_ = v28 -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("str")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.Apply(v31, []any{v5}) -v17 = v32 -}() -return v17 - } -}) -v4 := reflect.TypeOf("") -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// prefer-method -{ -v0 := lang.NewSymbol("prefer-method").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"), lang.NewSymbol("dispatch-val-x"), lang.NewSymbol("dispatch-val-y"))), lang.NewKeyword("doc"), "Causes the multimethod to prefer matches of dispatch-val-x over dispatch-val-y \n when there is a conflict", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1801), lang.NewKeyword("end-line"), int(1801))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6, _ := lang.FieldOrMethod(v3, "PreferMethod") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("PreferMethod is not a function"))) -} -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// prefers -{ -v0 := lang.NewSymbol("prefers").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"))), lang.NewKeyword("doc"), "Given a multimethod, returns a map of preferred value -> set of other values", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1822), lang.NewKeyword("end-line"), int(1822))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, ok := lang.FieldOrMethod(v3, "getPreferTable") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getPreferTable"))) -} -var v5 any -switch reflect.TypeOf(v4).Kind() { -case reflect.Func: - v5 = lang.Apply(v4, nil) -default: - v5 = v4 -} -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// prep-hashes -{ -v0 := lang.NewSymbol("prep-hashes").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr-sym"), lang.NewSymbol("default"), lang.NewSymbol("tests"), lang.NewSymbol("thens"))), lang.NewKeyword("doc"), "Takes a sequence of test constants and a corresponding sequence of then\n expressions. Returns a tuple of [shift mask case-map switch-type skip-check]\n where case-map is a map of int case values to [test then] tuples, switch-type\n is either :sparse or :compact, and skip-check is a set of case ints for which\n post-switch equivalence checking must not be done (occurs with hash\n collisions).", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6683), lang.NewKeyword("end-line"), int(6683), lang.NewKeyword("private"), true)).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -var v8 lang.FnFunc -v8 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v9 := args[0] -v10 := lang.Apply(lang.Hash, []any{v9}) -return v10 -}) -v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6691), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(6691), lang.NewKeyword("end-column"), int(66)) -v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v7 any = v10 -_ = v7 -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("into1")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.CreatePersistentTreeSet() -v16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6692), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(6692), lang.NewKeyword("end-column"), int(25)) -v17, err := lang.WithMeta(v15, v16.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("map")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v20, []any{v7, v5}) -v22 := lang.Apply(v14, []any{v17, v21}) -var v11 any = v22 -_ = v11 -var v24 any -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("==")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("count")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{v5}) -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("count")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v11}) -v36 := lang.Apply(v27, []any{v31, v35}) -if lang.IsTruthy(v36) { -var v37 any -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("fits-table?")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.Apply(v40, []any{v11}) -if lang.IsTruthy(v41) { -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("case-map")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) -} -v44 := v43.Get() -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("identity")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.Apply(v44, []any{v7, v47, v5, v6}) -v49 := lang.NewVector(int64(0), int64(0), v48, lang.NewKeyword("compact")) -v50 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6696), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(6696), lang.NewKeyword("end-column"), int(63)) -v51, err := lang.WithMeta(v49, v50.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v37 = v51 -} else { -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("maybe-min-hash")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) -} -v56 := v55.Get() -v57 := lang.Apply(v56, []any{v11}) -var v53 any = v57 -_ = v53 -var v59 any -if lang.IsTruthy(v53) { -v59 = v53 -} else { -v60 := lang.NewVector(int64(0), int64(0)) -v61 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6697), lang.NewKeyword("column"), int(56), lang.NewKeyword("end-line"), int(6697), lang.NewKeyword("end-column"), int(60)) -v62, err := lang.WithMeta(v60, v61.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v59 = v62 -} -var v52 any = v59 -_ = v52 -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("nth")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) -} -v56 := v55.Get() -v57 := lang.Apply(v56, []any{v52, int64(0), nil}) -var v53 any = v57 -_ = v53 -v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v60 := v59.FindInternedVar(lang.NewSymbol("nth")) -if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) -} -v61 := v60.Get() -v62 := lang.Apply(v61, []any{v52, int64(1), nil}) -var v58 any = v62 -_ = v58 -var v64 any -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("zero?")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) -} -v67 := v66.Get() -v68 := lang.Apply(v67, []any{v58}) -if lang.IsTruthy(v68) { -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("case-map")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) -} -v71 := v70.Get() -v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v73 := v72.FindInternedVar(lang.NewSymbol("identity")) -if v73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) -} -v74 := v73.Get() -v75 := lang.Apply(v71, []any{v7, v74, v5, v6}) -v76 := lang.NewVector(int64(0), int64(0), v75, lang.NewKeyword("sparse")) -v77 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6700), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(6700), lang.NewKeyword("end-column"), int(66)) -v78, err := lang.WithMeta(v76, v77.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v64 = v78 -} else { -v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v80 := v79.FindInternedVar(lang.NewSymbol("case-map")) -if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) -} -v81 := v80.Get() -var v82 lang.FnFunc -v82 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v83 := args[0] -v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v85 := v84.FindInternedVar(lang.NewSymbol("shift-mask")) -if v85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) -} -v86 := v85.Get() -v87 := lang.Apply(v7, []any{v83}) -v88 := lang.Apply(v86, []any{v53, v58, v87}) -return v88 -}) -v83 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6702), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(6702), lang.NewKeyword("end-column"), int(71)) -v84, err := lang.WithMeta(v82, v83.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v86 := v85.FindInternedVar(lang.NewSymbol("identity")) -if v86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) -} -v87 := v86.Get() -v88 := lang.Apply(v81, []any{v84, v87, v5, v6}) -v89 := lang.NewVector(v53, v58, v88, lang.NewKeyword("compact")) -v90 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6702), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(6702), lang.NewKeyword("end-column"), int(103)) -v91, err := lang.WithMeta(v89, v90.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v64 = v91 -} -v37 = v64 -} -v24 = v37 -} else { -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("merge-hash-collisions")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) -} -v55 := v54.Get() -v56 := lang.Apply(v55, []any{v3, v4, v5, v6}) -var v52 any = v56 -_ = v52 -v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v59 := v58.FindInternedVar(lang.NewSymbol("nth")) -if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) -} -v60 := v59.Get() -v61 := lang.Apply(v60, []any{v52, int64(0), nil}) -var v57 any = v61 -_ = v57 -v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v64 := v63.FindInternedVar(lang.NewSymbol("nth")) -if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) -} -v65 := v64.Get() -v66 := lang.Apply(v65, []any{v52, int64(1), nil}) -var v62 any = v66 -_ = v62 -v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v69 := v68.FindInternedVar(lang.NewSymbol("nth")) -if v69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) -} -v70 := v69.Get() -v71 := lang.Apply(v70, []any{v52, int64(2), nil}) -var v67 any = v71 -_ = v67 -v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v74 := v73.FindInternedVar(lang.NewSymbol("prep-hashes")) -if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) -} -v75 := v74.Get() -v76 := lang.Apply(v75, []any{v3, v4, v57, v62}) -var v72 any = v76 -_ = v72 -v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v79 := v78.FindInternedVar(lang.NewSymbol("nth")) -if v79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) -} -v80 := v79.Get() -v81 := lang.Apply(v80, []any{v72, int64(0), nil}) -var v77 any = v81 -_ = v77 -v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v84 := v83.FindInternedVar(lang.NewSymbol("nth")) -if v84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) -} -v85 := v84.Get() -v86 := lang.Apply(v85, []any{v72, int64(1), nil}) -var v82 any = v86 -_ = v82 -v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v89 := v88.FindInternedVar(lang.NewSymbol("nth")) -if v89.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) -} -v90 := v89.Get() -v91 := lang.Apply(v90, []any{v72, int64(2), nil}) -var v87 any = v91 -_ = v87 -v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v94 := v93.FindInternedVar(lang.NewSymbol("nth")) -if v94.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) -} -v95 := v94.Get() -v96 := lang.Apply(v95, []any{v72, int64(3), nil}) -var v92 any = v96 -_ = v92 -var v98 any -v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v100 := v99.FindInternedVar(lang.NewSymbol("zero?")) -if v100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) -} -v101 := v100.Get() -v102 := lang.Apply(v101, []any{v82}) -if lang.IsTruthy(v102) { -v98 = v97 -} else { -v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v104 := v103.FindInternedVar(lang.NewSymbol("into1")) -if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) -} -v105 := v104.Get() -v106 := lang.CreatePersistentTreeSet() -v107 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6708), lang.NewKeyword("column"), int(33), lang.NewKeyword("end-line"), int(6708), lang.NewKeyword("end-column"), int(35)) -v108, err := lang.WithMeta(v106, v107.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v110 := v109.FindInternedVar(lang.NewSymbol("map")) -if v110.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) -} -v111 := v110.Get() -var v112 lang.FnFunc -v112 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v113 := args[0] -v114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v115 := v114.FindInternedVar(lang.NewSymbol("shift-mask")) -if v115.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v115))) -} -v116 := v115.Get() -v117 := lang.Apply(v116, []any{v77, v82, v113}) -return v117 -}) -v113 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6708), lang.NewKeyword("column"), int(42), lang.NewKeyword("end-line"), int(6708), lang.NewKeyword("end-column"), int(67)) -v114, err := lang.WithMeta(v112, v113.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v115 := lang.Apply(v111, []any{v114, v97}) -v116 := lang.Apply(v105, []any{v108, v115}) -v98 = v116 -} -var v97 any = v98 -_ = v97 -v118 := lang.NewVector(v77, v82, v87, v92, v97) -v119 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6709), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(6709), lang.NewKeyword("end-column"), int(52)) -v120, err := lang.WithMeta(v118, v119.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v24 = v120 -} -return v24 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// prep-ints -{ -v0 := lang.NewSymbol("prep-ints").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tests"), lang.NewSymbol("thens"))), lang.NewKeyword("doc"), "Takes a sequence of int-sized test constants and a corresponding sequence of\n then expressions. Returns a tuple of [shift mask case-map switch-type] where\n case-map is a map of int case values to [test then] tuples, and switch-type\n is either :sparse or :compact.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6631), lang.NewKeyword("end-line"), int(6631), lang.NewKeyword("private"), true)).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("fits-table?")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v3}) -if lang.IsTruthy(v9) { -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("case-map")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("int")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("int")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v12, []any{v15, v18, v3, v4}) -v20 := lang.NewVector(int64(0), int64(0), v19, lang.NewKeyword("compact")) -v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6639), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(6639), lang.NewKeyword("end-column"), int(49)) -v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v5 = v22 -} else { -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("maybe-min-hash")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("map")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("int")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v30, []any{v33, v3}) -v35 := lang.Apply(v27, []any{v34}) -var v24 any = v35 -_ = v24 -var v37 any -if lang.IsTruthy(v24) { -v37 = v24 -} else { -v38 := lang.NewVector(int64(0), int64(0)) -v39 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6640), lang.NewKeyword("column"), int(61), lang.NewKeyword("end-line"), int(6640), lang.NewKeyword("end-column"), int(65)) -v40, err := lang.WithMeta(v38, v39.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v37 = v40 -} -var v23 any = v37 -_ = v23 -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("nth")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.Apply(v27, []any{v23, int64(0), nil}) -var v24 any = v28 -_ = v24 -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("nth")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.Apply(v32, []any{v23, int64(1), nil}) -var v29 any = v33 -_ = v29 -var v35 any -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("zero?")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v29}) -if lang.IsTruthy(v39) { -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("case-map")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("int")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("int")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) -} -v48 := v47.Get() -v49 := lang.Apply(v42, []any{v45, v48, v3, v4}) -v50 := lang.NewVector(int64(0), int64(0), v49, lang.NewKeyword("sparse")) -v51 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6643), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(6643), lang.NewKeyword("end-column"), int(52)) -v52, err := lang.WithMeta(v50, v51.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v35 = v52 -} else { -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("case-map")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) -} -v55 := v54.Get() -var v56 lang.FnFunc -v56 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v57 := args[0] -v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v59 := v58.FindInternedVar(lang.NewSymbol("shift-mask")) -if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) -} -v60 := v59.Get() -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("int")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) -} -v63 := v62.Get() -v64 := lang.Apply(v63, []any{v57}) -v65 := lang.Apply(v60, []any{v24, v29, v64}) -return v65 -}) -v57 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6645), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(6645), lang.NewKeyword("end-column"), int(62)) -v58, err := lang.WithMeta(v56, v57.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v60 := v59.FindInternedVar(lang.NewSymbol("int")) -if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) -} -v61 := v60.Get() -v62 := lang.Apply(v55, []any{v58, v61, v3, v4}) -v63 := lang.NewVector(v24, v29, v62, lang.NewKeyword("compact")) -v64 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6645), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(6645), lang.NewKeyword("end-column"), int(89)) -v65, err := lang.WithMeta(v63, v64.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v35 = v65 -} -v5 = v35 -} -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// prependss -{ -v0 := lang.NewSymbol("prependss").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Prepends a symbol or a seq to coll", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5857), lang.NewKeyword("end-line"), int(5857), lang.NewKeyword("private"), true)).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("symbol?")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v3}) -if lang.IsTruthy(v9) { -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("cons")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{v3, v4}) -v5 = v13 -} else { -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("concat")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v3, v4}) -v5 = v17 -} -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// preserving-reduced -{ -v0 := lang.NewSymbol("preserving-reduced").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7638), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(7638), lang.NewKeyword("end-column"), int(34), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rf"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := args[0] -v6 := args[1] -v8 := lang.Apply(v3, []any{v5, v6}) -var v7 any = v8 -_ = v7 -var v10 any -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("reduced?")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v7}) -if lang.IsTruthy(v14) { -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("reduced")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v7}) -v10 = v18 -} else { -v10 = v7 -} -return v10 -}) -v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7640), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(7643), lang.NewKeyword("end-column"), int(12)) -v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v6 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// print -{ -v0 := lang.NewSymbol("print").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Prints the object(s) to the output stream that is the current value\n of *out*. print and println produce output for human consumption.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3725), lang.NewKeyword("end-line"), int(3725))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewList(args[0:]...) -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("push-thread-bindings")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("hash-map")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*print-readably*")) -v12 := lang.Apply(v10, []any{v11, nil}) -v13 := lang.Apply(v7, []any{v12}) -_ = v13 -var v14 any -func() { -defer func() { -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, nil) -}() -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("apply")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("pr")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v21, []any{v24, v3}) -v14 = v25 -}() -return v14 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// print-ctor -{ -v0 := lang.NewSymbol("print-ctor").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(95), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(95), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("print-args"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.Apply(lang.WriteWriter, []any{v5, "#=("}) -_ = v6 -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("class")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v3}) -v11, ok := lang.FieldOrMethod(v10, "Name") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v10, "Name"))) -} -var v12 any -switch reflect.TypeOf(v11).Kind() { -case reflect.Func: - v12 = lang.Apply(v11, nil) -default: - v12 = v11 -} -v13 := lang.Apply(lang.WriteWriter, []any{v5, v12}) -_ = v13 -v14 := lang.Apply(lang.WriteWriter, []any{v5, ". "}) -_ = v14 -v15 := lang.Apply(v4, []any{v3, v5}) -_ = v15 -v16 := lang.Apply(lang.WriteWriter, []any{v5, ")"}) -return v16 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// print-dup -{ -v0 := lang.NewSymbol("print-dup").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3667), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(3667), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, nil, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// print-initialized -{ -v0 := lang.NewSymbol("print-initialized").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(520), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(520), lang.NewKeyword("end-column"), int(39), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, true, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// print-map -{ -v0 := lang.NewSymbol("print-map").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(252), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(252), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("print-one"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("print-prefix-map")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{nil, v3, v4, v5}) -return v9 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// print-meta -{ -v0 := lang.NewSymbol("print-meta").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(70), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(70), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("meta")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v3}) -var v5 any = v9 -_ = v5 -var v11 any -if lang.IsTruthy(v5) { -var v12 any = v5 -_ = v12 -var v14 any -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("pos?")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("count")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v12}) -v23 := lang.Apply(v18, []any{v22}) -var v15 any = v23 -_ = v15 -var v25 any -if lang.IsTruthy(v15) { -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("*print-dup*")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -var v26 any = v29 -_ = v26 -var v31 any -if lang.IsTruthy(v26) { -v31 = v26 -} else { -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("*print-meta*")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -var v32 any = v35 -_ = v32 -var v37 any -if lang.IsTruthy(v32) { -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("*print-readably*")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v37 = v40 -} else { -v37 = v32 -} -v31 = v37 -} -v25 = v31 -} else { -v25 = v15 -} -if lang.IsTruthy(v25) { -v15 := lang.Apply(lang.WriteWriter, []any{v4, "^"}) -_ = v15 -var v16 any -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("=")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("count")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v12}) -v25 := lang.Apply(v20, []any{v24, int64(1)}) -var v17 any = v25 -_ = v17 -var v27 any -if lang.IsTruthy(v17) { -v28 := lang.Apply(lang.NewKeyword("tag"), []any{v12}) -v27 = v28 -} else { -v27 = v17 -} -if lang.IsTruthy(v27) { -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("pr-on")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(lang.NewKeyword("tag"), []any{v12}) -v21 := lang.Apply(v19, []any{v20, v4}) -v16 = v21 -} else { -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("pr-on")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v12, v4}) -v16 = v25 -} -_ = v16 -v26 := lang.Apply(lang.WriteWriter, []any{v4, " "}) -v14 = v26 -} else { -v14 = nil -} -v11 = v14 -} else { -v11 = nil -} -return v11 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// print-method -{ -v0 := lang.NewSymbol("print-method").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3664), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(3664), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, nil, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// print-object -{ -v0 := lang.NewSymbol("print-object").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(115), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(115), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("print-tagged-object")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("str")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v3}) -v12 := lang.Apply(v7, []any{v3, v11, v4}) -return v12 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// print-prefix-map -{ -v0 := lang.NewSymbol("print-prefix-map").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(243), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(243), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("prefix"), lang.NewSymbol("kvs"), lang.NewSymbol("print-one"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("print-sequential")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("str")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{v3, "{"}) -var v14 lang.FnFunc -v14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v15 := args[0] -v16 := args[1] -var v17 any = v15 -_ = v17 -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("nth")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v17, int64(0), nil}) -var v18 any = v22 -_ = v18 -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("nth")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v17, int64(1), nil}) -var v23 any = v27 -_ = v23 -v29 := lang.Apply(v5, []any{v18, v16}) -_ = v29 -v30 := lang.Apply(lang.AppendWriter, []any{v16, lang.NewChar(32)}) -_ = v30 -v31 := lang.Apply(v5, []any{v23, v16}) -return v31 -}) -v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(246), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(247), lang.NewKeyword("end-column"), int(107)) -v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v17 := lang.Apply(v9, []any{v13, v16, ", ", "}", v4, v6}) -return v17 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// print-sequential -{ -v0 := lang.NewSymbol("print-sequential").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(46), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(46), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("begin"), lang.NewSymbol("print-one"), lang.NewSymbol("sep"), lang.NewSymbol("end"), lang.NewSymbol("sequence"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 6 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := args[4] -v8 := args[5] -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("push-thread-bindings")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("hash-map")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*print-level*")) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("not")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("*print-dup*")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v20, []any{v23}) -var v17 any = v24 -_ = v17 -var v26 any -if lang.IsTruthy(v17) { -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("*print-level*")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -var v27 any = v30 -_ = v27 -var v32 any -if lang.IsTruthy(v27) { -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("dec")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("*print-level*")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v35, []any{v38}) -v32 = v39 -} else { -v32 = v27 -} -v26 = v32 -} else { -v26 = v17 -} -v17 := lang.Apply(v15, []any{v16, v26}) -v18 := lang.Apply(v12, []any{v17}) -_ = v18 -var v19 any -func() { -defer func() { -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.Apply(v22, nil) -}() -var v24 any -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("*print-level*")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -var v25 any = v28 -_ = v25 -var v30 any -if lang.IsTruthy(v25) { -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("neg?")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("*print-level*")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.Apply(v33, []any{v36}) -v30 = v37 -} else { -v30 = v25 -} -if lang.IsTruthy(v30) { -v25 := lang.Apply(lang.WriteWriter, []any{v8, "#"}) -v24 = v25 -} else { -v26 := lang.Apply(lang.WriteWriter, []any{v8, v3}) -_ = v26 -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("seq")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{v7}) -var v27 any = v31 -_ = v27 -var v33 any -if lang.IsTruthy(v27) { -var v34 any = v27 -_ = v34 -var v36 any -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("not")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("*print-dup*")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v40, []any{v43}) -var v37 any = v44 -_ = v37 -var v46 any -if lang.IsTruthy(v37) { -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("*print-length*")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) -} -v49 := v48.Get() -v46 = v49 -} else { -v46 = v37 -} -if lang.IsTruthy(v46) { -var v37 any = v34 -_ = v37 -var v38 any = v37 -_ = v38 -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("seq")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v38}) -var v39 any = v43 -_ = v39 -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("first")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.Apply(v47, []any{v39}) -var v44 any = v48 -_ = v44 -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("next")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.Apply(v52, []any{v49}) -var v49 any = v53 -_ = v49 -var v54 any = v44 -_ = v54 -var v55 any = v49 -_ = v55 -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("*print-length*")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) -} -v59 := v58.Get() -var v56 any = v59 -_ = v56 -var v61 any = v61 -_ = v61 -var v62 any = v62 -_ = v62 -var v63 any -for { -var v64 any = v61 -_ = v64 -v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v67 := v66.FindInternedVar(lang.NewSymbol("seq")) -if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) -} -v68 := v67.Get() -v69 := lang.Apply(v68, []any{v64}) -var v65 any = v69 -_ = v65 -v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v72 := v71.FindInternedVar(lang.NewSymbol("first")) -if v72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) -} -v73 := v72.Get() -v74 := lang.Apply(v73, []any{v65}) -var v70 any = v74 -_ = v70 -v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v77 := v76.FindInternedVar(lang.NewSymbol("next")) -if v77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) -} -v78 := v77.Get() -v79 := lang.Apply(v78, []any{v75}) -var v75 any = v79 -_ = v75 -var v80 any = v70 -_ = v80 -var v81 any = v75 -_ = v81 -var v82 any = v82 -_ = v82 -var v84 any -v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v86 := v85.FindInternedVar(lang.NewSymbol("zero?")) -if v86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) -} -v87 := v86.Get() -v88 := lang.Apply(v87, []any{v82}) -if lang.IsTruthy(v88) { -v89 := lang.Apply(lang.WriteWriter, []any{v8, "..."}) -v84 = v89 -} else { -v90 := lang.Apply(v4, []any{v80, v8}) -_ = v90 -var v91 any -if lang.IsTruthy(v81) { -v92 := lang.Apply(lang.WriteWriter, []any{v8, v5}) -_ = v92 -var v93 any = v81 -v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v96 := v95.FindInternedVar(lang.NewSymbol("dec")) -if v96.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) -} -v97 := v96.Get() -v98 := lang.Apply(v97, []any{v82}) -var v94 any = v98 -v61 = v93 -v62 = v94 -continue -} else { -v91 = nil -} -v84 = v91 -} -v63 = v84 - break -} -v36 = v63 -} else { -var v37 any = v34 -_ = v37 -var v38 any = v37 -_ = v38 -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("seq")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v38}) -var v39 any = v43 -_ = v39 -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("first")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.Apply(v47, []any{v39}) -var v44 any = v48 -_ = v44 -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("next")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.Apply(v52, []any{v49}) -var v49 any = v53 -_ = v49 -var v54 any = v44 -_ = v54 -var v55 any = v49 -_ = v55 -var v57 any = v57 -_ = v57 -var v58 any -for { -var v59 any = v57 -_ = v59 -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("seq")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) -} -v63 := v62.Get() -v64 := lang.Apply(v63, []any{v59}) -var v60 any = v64 -_ = v60 -v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v67 := v66.FindInternedVar(lang.NewSymbol("first")) -if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) -} -v68 := v67.Get() -v69 := lang.Apply(v68, []any{v60}) -var v65 any = v69 -_ = v65 -v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v72 := v71.FindInternedVar(lang.NewSymbol("next")) -if v72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) -} -v73 := v72.Get() -v74 := lang.Apply(v73, []any{v70}) -var v70 any = v74 -_ = v70 -var v75 any = v65 -_ = v75 -var v76 any = v70 -_ = v76 -v78 := lang.Apply(v4, []any{v75, v8}) -_ = v78 -var v79 any -if lang.IsTruthy(v76) { -v80 := lang.Apply(lang.WriteWriter, []any{v8, v5}) -_ = v80 -var v81 any = v76 -v57 = v81 -continue -} else { -v79 = nil -} -v58 = v79 - break -} -v36 = v58 -} -v33 = v36 -} else { -v33 = nil -} -_ = v33 -v27 := lang.Apply(lang.WriteWriter, []any{v8, v6}) -v24 = v27 -} -v19 = v24 -}() -return v19 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// print-simple -{ -v0 := lang.NewSymbol("print-simple").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(81), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(81), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("print-meta")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3, v4}) -_ = v8 -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("str")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v3}) -v13 := lang.Apply(lang.WriteWriter, []any{v4, v12}) -return v13 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// print-str -{ -v1 := reflect.TypeOf("") -v0 := lang.NewSymbol("print-str").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("xs"))), lang.NewKeyword("doc"), "print to a string, returning it", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4776), lang.NewKeyword("end-line"), int(4776))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := lang.NewList(args[0:]...) -var v5 any = "unimplemented: new with non-constant class type" -_ = v5 -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("push-thread-bindings")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("hash-map")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*out*")) -v15 := lang.Apply(v13, []any{v14, v5}) -v16 := lang.Apply(v10, []any{v15}) -_ = v16 -var v17 any -func() { -defer func() { -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v20, nil) -}() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("apply")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("print")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.Apply(v24, []any{v27, v4}) -_ = v28 -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("str")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.Apply(v31, []any{v5}) -v17 = v32 -}() -return v17 - } -}) -v4 := reflect.TypeOf("") -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// print-tagged-object -{ -v0 := lang.NewSymbol("print-tagged-object").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(102), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(102), lang.NewKeyword("end-column"), int(26), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("rep"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -var v6 any -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("instance?")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{lang.IMeta, v3}) -if lang.IsTruthy(v10) { -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("print-meta")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v3, v5}) -v6 = v14 -} else { -v6 = nil -} -_ = v6 -v15 := lang.Apply(lang.WriteWriter, []any{v5, "#object["}) -_ = v15 -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("class")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v3}) -var v16 any = v20 -_ = v16 -var v22 any -if lang.IsTruthy(false) { -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("print-method")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26, ok := lang.FieldOrMethod(v16, "Name") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v16, "Name"))) -} -var v27 any -switch reflect.TypeOf(v26).Kind() { -case reflect.Func: - v27 = lang.Apply(v26, nil) -default: - v27 = v26 -} -v28 := lang.Apply(v25, []any{v27, v5}) -v22 = v28 -} else { -v29, ok := lang.FieldOrMethod(v16, "Name") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v16, "Name"))) -} -var v30 any -switch reflect.TypeOf(v29).Kind() { -case reflect.Func: - v30 = lang.Apply(v29, nil) -default: - v30 = v29 -} -v31 := lang.Apply(lang.WriteWriter, []any{v5, v30}) -v22 = v31 -} -_ = v22 -v16 := lang.Apply(lang.WriteWriter, []any{v5, " "}) -_ = v16 -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("format")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(lang.IdentityHash, []any{v3}) -v21 := lang.Apply(v19, []any{"0x%x ", v20}) -v22 := lang.Apply(lang.WriteWriter, []any{v5, v21}) -_ = v22 -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("print-method")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{v4, v5}) -_ = v26 -v27 := lang.Apply(lang.WriteWriter, []any{v5, "]"}) -return v27 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// print-throwable -{ -v0 := lang.NewSymbol("print-throwable").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(478), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(478), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.Apply(lang.WriteWriter, []any{v4, "#error {\n :cause "}) -_ = v5 -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("Throwable->map")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v3}) -var v6 any = v10 -_ = v6 -var v12 any -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("seq?")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v11}) -if lang.IsTruthy(v16) { -var v17 any -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("next")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v20, []any{v11}) -if lang.IsTruthy(v21) { -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("to-array")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v11}) -v26 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{v25}) -v17 = v26 -} else { -var v27 any -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("seq")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{v11}) -if lang.IsTruthy(v31) { -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("first")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v11}) -v27 = v35 -} else { -v27 = nil -} -v17 = v27 -} -v12 = v17 -} else { -v12 = v11 -} -var v11 any = v12 -_ = v11 -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("get")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v11, lang.NewKeyword("cause")}) -var v36 any = v40 -_ = v36 -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("get")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) -} -v44 := v43.Get() -v45 := lang.Apply(v44, []any{v11, lang.NewKeyword("data")}) -var v41 any = v45 -_ = v41 -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("get")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) -} -v49 := v48.Get() -v50 := lang.Apply(v49, []any{v11, lang.NewKeyword("via")}) -var v46 any = v50 -_ = v46 -v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("get")) -if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) -} -v54 := v53.Get() -v55 := lang.Apply(v54, []any{v11, lang.NewKeyword("trace")}) -var v51 any = v55 -_ = v51 -var v57 lang.FnFunc -v57 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v58 := args[0] -v59 := lang.Apply(lang.WriteWriter, []any{v4, "{:type "}) -_ = v59 -v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v61 := v60.FindInternedVar(lang.NewSymbol("print-method")) -if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) -} -v62 := v61.Get() -v63 := lang.Apply(lang.NewKeyword("type"), []any{v58}) -v64 := lang.Apply(v62, []any{v63, v4}) -_ = v64 -v65 := lang.Apply(lang.WriteWriter, []any{v4, "\n :message "}) -_ = v65 -v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v67 := v66.FindInternedVar(lang.NewSymbol("print-method")) -if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) -} -v68 := v67.Get() -v69 := lang.Apply(lang.NewKeyword("message"), []any{v58}) -v70 := lang.Apply(v68, []any{v69, v4}) -_ = v70 -v72 := lang.Apply(lang.NewKeyword("data"), []any{v58}) -var v71 any = v72 -_ = v71 -var v74 any -if lang.IsTruthy(v71) { -var v75 any = v71 -_ = v75 -v77 := lang.Apply(lang.WriteWriter, []any{v4, "\n :data "}) -_ = v77 -v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v79 := v78.FindInternedVar(lang.NewSymbol("print-method")) -if v79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) -} -v80 := v79.Get() -v81 := lang.Apply(v80, []any{v75, v4}) -v74 = v81 -} else { -v74 = nil -} -_ = v74 -v72 := lang.Apply(lang.NewKeyword("at"), []any{v58}) -var v71 any = v72 -_ = v71 -var v74 any -if lang.IsTruthy(v71) { -var v75 any = v71 -_ = v75 -v77 := lang.Apply(lang.WriteWriter, []any{v4, "\n :at "}) -_ = v77 -v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v79 := v78.FindInternedVar(lang.NewSymbol("print-method")) -if v79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) -} -v80 := v79.Get() -v81 := lang.Apply(lang.NewKeyword("at"), []any{v58}) -v82 := lang.Apply(v80, []any{v81, v4}) -v74 = v82 -} else { -v74 = nil -} -_ = v74 -v71 := lang.Apply(lang.WriteWriter, []any{v4, "}"}) -return v71 -}) -v58 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(481), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(491), lang.NewKeyword("end-column"), int(73)) -v59, err := lang.WithMeta(v57, v58.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v56 any = v59 -_ = v56 -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("print-method")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) -} -v63 := v62.Get() -v64 := lang.Apply(v63, []any{v36, v4}) -_ = v64 -var v65 any -if lang.IsTruthy(v41) { -v66 := lang.Apply(lang.WriteWriter, []any{v4, "\n :data "}) -_ = v66 -v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v68 := v67.FindInternedVar(lang.NewSymbol("print-method")) -if v68.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) -} -v69 := v68.Get() -v70 := lang.Apply(v69, []any{v41, v4}) -v65 = v70 -} else { -v65 = nil -} -_ = v65 -var v71 any -if lang.IsTruthy(v46) { -v72 := lang.Apply(lang.WriteWriter, []any{v4, "\n :via\n ["}) -_ = v72 -v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v75 := v74.FindInternedVar(lang.NewSymbol("first")) -if v75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) -} -v76 := v75.Get() -v77 := lang.Apply(v76, []any{v46}) -var v73 any = v77 -_ = v73 -var v79 any -if lang.IsTruthy(v73) { -var v80 any = v73 -_ = v80 -v82 := lang.Apply(v56, []any{v80}) -_ = v82 -v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v85 := v84.FindInternedVar(lang.NewSymbol("seq")) -if v85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) -} -v86 := v85.Get() -v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v88 := v87.FindInternedVar(lang.NewSymbol("rest")) -if v88.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) -} -v89 := v88.Get() -v90 := lang.Apply(v89, []any{v46}) -v91 := lang.Apply(v86, []any{v90}) -var v83 any = v91 -_ = v83 -var v92 any = nil -_ = v92 -var v93 any = int64(0) -_ = v93 -var v94 any = int64(0) -_ = v94 -var v95 any -for { -var v96 any -v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v98 := v97.FindInternedVar(lang.NewSymbol("<")) -if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) -} -v99 := v98.Get() -v100 := lang.Apply(v99, []any{v94, v93}) -if lang.IsTruthy(v100) { -v102, _ := lang.FieldOrMethod(v92, "nth") -if reflect.TypeOf(v102).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) -} -v103 := lang.Apply(v102, []any{v94}) -var v101 any = v103 -_ = v101 -v105 := lang.Apply(lang.WriteWriter, []any{v4, "\n "}) -_ = v105 -v106 := lang.Apply(v56, []any{v101}) -_ = v106 -var v107 any = v83 -var v108 any = v92 -var v109 any = v93 -v111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v112 := v111.FindInternedVar(lang.NewSymbol("unchecked-inc")) -if v112.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v112))) -} -v113 := v112.Get() -v114 := lang.Apply(v113, []any{v94}) -var v110 any = v114 -v83 = v107 -v92 = v108 -v93 = v109 -v94 = v110 -continue -} else { -v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v103 := v102.FindInternedVar(lang.NewSymbol("seq")) -if v103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) -} -v104 := v103.Get() -v105 := lang.Apply(v104, []any{v83}) -var v101 any = v105 -_ = v101 -var v107 any -if lang.IsTruthy(v101) { -var v108 any = v101 -_ = v108 -var v110 any -v111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v112 := v111.FindInternedVar(lang.NewSymbol("chunked-seq?")) -if v112.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v112))) -} -v113 := v112.Get() -v114 := lang.Apply(v113, []any{v108}) -if lang.IsTruthy(v114) { -v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v117 := v116.FindInternedVar(lang.NewSymbol("chunk-first")) -if v117.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) -} -v118 := v117.Get() -v119 := lang.Apply(v118, []any{v108}) -var v115 any = v119 -_ = v115 -v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v123 := v122.FindInternedVar(lang.NewSymbol("chunk-rest")) -if v123.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) -} -v124 := v123.Get() -v125 := lang.Apply(v124, []any{v108}) -var v121 any = v125 -var v126 any = v115 -v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v129 := v128.FindInternedVar(lang.NewSymbol("int")) -if v129.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v129))) -} -v130 := v129.Get() -v131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v132 := v131.FindInternedVar(lang.NewSymbol("count")) -if v132.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v132))) -} -v133 := v132.Get() -v134 := lang.Apply(v133, []any{v115}) -v135 := lang.Apply(v130, []any{v134}) -var v127 any = v135 -v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v138 := v137.FindInternedVar(lang.NewSymbol("int")) -if v138.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) -} -v139 := v138.Get() -v140 := lang.Apply(v139, []any{int64(0)}) -var v136 any = v140 -v83 = v121 -v92 = v126 -v93 = v127 -v94 = v136 -continue -} else { -v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v117 := v116.FindInternedVar(lang.NewSymbol("first")) -if v117.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) -} -v118 := v117.Get() -v119 := lang.Apply(v118, []any{v108}) -var v115 any = v119 -_ = v115 -v121 := lang.Apply(lang.WriteWriter, []any{v4, "\n "}) -_ = v121 -v122 := lang.Apply(v56, []any{v115}) -_ = v122 -v124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v125 := v124.FindInternedVar(lang.NewSymbol("next")) -if v125.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v125))) -} -v126 := v125.Get() -v127 := lang.Apply(v126, []any{v108}) -var v123 any = v127 -var v128 any = nil -var v129 any = int64(0) -var v130 any = int64(0) -v83 = v123 -v92 = v128 -v93 = v129 -v94 = v130 -continue -} -v107 = v110 -} else { -v107 = nil -} -v96 = v107 -} -v95 = v96 - break -} -v79 = v95 -} else { -v79 = nil -} -_ = v79 -v73 := lang.Apply(lang.WriteWriter, []any{v4, "]"}) -v71 = v73 -} else { -v71 = nil -} -_ = v71 -var v74 any -if lang.IsTruthy(v51) { -v75 := lang.Apply(lang.WriteWriter, []any{v4, "\n :trace\n ["}) -_ = v75 -v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v78 := v77.FindInternedVar(lang.NewSymbol("first")) -if v78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) -} -v79 := v78.Get() -v80 := lang.Apply(v79, []any{v51}) -var v76 any = v80 -_ = v76 -var v82 any -if lang.IsTruthy(v76) { -var v83 any = v76 -_ = v83 -v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v86 := v85.FindInternedVar(lang.NewSymbol("print-method")) -if v86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) -} -v87 := v86.Get() -v88 := lang.Apply(v87, []any{v83, v4}) -_ = v88 -v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v91 := v90.FindInternedVar(lang.NewSymbol("seq")) -if v91.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) -} -v92 := v91.Get() -v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v94 := v93.FindInternedVar(lang.NewSymbol("rest")) -if v94.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) -} -v95 := v94.Get() -v96 := lang.Apply(v95, []any{v51}) -v97 := lang.Apply(v92, []any{v96}) -var v89 any = v97 -_ = v89 -var v98 any = nil -_ = v98 -var v99 any = int64(0) -_ = v99 -var v100 any = int64(0) -_ = v100 -var v101 any -for { -var v102 any -v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v104 := v103.FindInternedVar(lang.NewSymbol("<")) -if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) -} -v105 := v104.Get() -v106 := lang.Apply(v105, []any{v100, v99}) -if lang.IsTruthy(v106) { -v108, _ := lang.FieldOrMethod(v98, "nth") -if reflect.TypeOf(v108).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) -} -v109 := lang.Apply(v108, []any{v100}) -var v107 any = v109 -_ = v107 -v111 := lang.Apply(lang.WriteWriter, []any{v4, "\n "}) -_ = v111 -v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v113 := v112.FindInternedVar(lang.NewSymbol("print-method")) -if v113.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) -} -v114 := v113.Get() -v115 := lang.Apply(v114, []any{v107, v4}) -_ = v115 -var v116 any = v89 -var v117 any = v98 -var v118 any = v99 -v120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v121 := v120.FindInternedVar(lang.NewSymbol("unchecked-inc")) -if v121.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v121))) -} -v122 := v121.Get() -v123 := lang.Apply(v122, []any{v100}) -var v119 any = v123 -v89 = v116 -v98 = v117 -v99 = v118 -v100 = v119 -continue -} else { -v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v109 := v108.FindInternedVar(lang.NewSymbol("seq")) -if v109.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) -} -v110 := v109.Get() -v111 := lang.Apply(v110, []any{v89}) -var v107 any = v111 -_ = v107 -var v113 any -if lang.IsTruthy(v107) { -var v114 any = v107 -_ = v114 -var v116 any -v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v118 := v117.FindInternedVar(lang.NewSymbol("chunked-seq?")) -if v118.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) -} -v119 := v118.Get() -v120 := lang.Apply(v119, []any{v114}) -if lang.IsTruthy(v120) { -v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v123 := v122.FindInternedVar(lang.NewSymbol("chunk-first")) -if v123.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) -} -v124 := v123.Get() -v125 := lang.Apply(v124, []any{v114}) -var v121 any = v125 -_ = v121 -v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v129 := v128.FindInternedVar(lang.NewSymbol("chunk-rest")) -if v129.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v129))) -} -v130 := v129.Get() -v131 := lang.Apply(v130, []any{v114}) -var v127 any = v131 -var v132 any = v121 -v134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v135 := v134.FindInternedVar(lang.NewSymbol("int")) -if v135.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v135))) -} -v136 := v135.Get() -v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v138 := v137.FindInternedVar(lang.NewSymbol("count")) -if v138.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) -} -v139 := v138.Get() -v140 := lang.Apply(v139, []any{v121}) -v141 := lang.Apply(v136, []any{v140}) -var v133 any = v141 -v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v144 := v143.FindInternedVar(lang.NewSymbol("int")) -if v144.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) -} -v145 := v144.Get() -v146 := lang.Apply(v145, []any{int64(0)}) -var v142 any = v146 -v89 = v127 -v98 = v132 -v99 = v133 -v100 = v142 -continue -} else { -v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v123 := v122.FindInternedVar(lang.NewSymbol("first")) -if v123.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) -} -v124 := v123.Get() -v125 := lang.Apply(v124, []any{v114}) -var v121 any = v125 -_ = v121 -v127 := lang.Apply(lang.WriteWriter, []any{v4, "\n "}) -_ = v127 -v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v129 := v128.FindInternedVar(lang.NewSymbol("print-method")) -if v129.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v129))) -} -v130 := v129.Get() -v131 := lang.Apply(v130, []any{v121, v4}) -_ = v131 -v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v134 := v133.FindInternedVar(lang.NewSymbol("next")) -if v134.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) -} -v135 := v134.Get() -v136 := lang.Apply(v135, []any{v114}) -var v132 any = v136 -var v137 any = nil -var v138 any = int64(0) -var v139 any = int64(0) -v89 = v132 -v98 = v137 -v99 = v138 -v100 = v139 -continue -} -v113 = v116 -} else { -v113 = nil -} -v102 = v113 -} -v101 = v102 - break -} -v82 = v101 -} else { -v82 = nil -} -_ = v82 -v76 := lang.Apply(lang.WriteWriter, []any{v4, "]"}) -v74 = v76 -} else { -v74 = nil -} -_ = v74 -v6 := lang.Apply(lang.WriteWriter, []any{v4, "}"}) -return v6 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// printf -{ -v0 := lang.NewSymbol("printf").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fmt"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Prints formatted output, as per format", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5725), lang.NewKeyword("end-line"), int(5725))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.NewList(args[1:]...) -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("print")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("apply")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("format")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v10, []any{v13, v3, v4}) -v15 := lang.Apply(v7, []any{v14}) -return v15 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// println -{ -v0 := lang.NewSymbol("println").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Same as print followed by (newline)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3734), lang.NewKeyword("end-line"), int(3734))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewList(args[0:]...) -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("push-thread-bindings")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("hash-map")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*print-readably*")) -v12 := lang.Apply(v10, []any{v11, nil}) -v13 := lang.Apply(v7, []any{v12}) -_ = v13 -var v14 any -func() { -defer func() { -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, nil) -}() -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("apply")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("prn")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v21, []any{v24, v3}) -v14 = v25 -}() -return v14 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// println-str -{ -v1 := reflect.TypeOf("") -v0 := lang.NewSymbol("println-str").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("xs"))), lang.NewKeyword("doc"), "println to a string, returning it", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4785), lang.NewKeyword("end-line"), int(4785))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := lang.NewList(args[0:]...) -var v5 any = "unimplemented: new with non-constant class type" -_ = v5 -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("push-thread-bindings")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("hash-map")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*out*")) -v15 := lang.Apply(v13, []any{v14, v5}) -v16 := lang.Apply(v10, []any{v15}) -_ = v16 -var v17 any -func() { -defer func() { -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v20, nil) -}() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("apply")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("println")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.Apply(v24, []any{v27, v4}) -_ = v28 -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("str")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.Apply(v31, []any{v5}) -v17 = v32 -}() -return v17 - } -}) -v4 := reflect.TypeOf("") -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// prn -{ -v0 := lang.NewSymbol("prn").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Same as pr followed by (newline). Observes *flush-on-newline*", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3715), lang.NewKeyword("end-line"), int(3715))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewList(args[0:]...) -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("apply")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("pr")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v6, []any{v9, v3}) -_ = v10 -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("newline")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, nil) -_ = v14 -var v15 any -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("*flush-on-newline*")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -if lang.IsTruthy(v18) { -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("flush")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, nil) -v15 = v22 -} else { -v15 = nil -} -return v15 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// prn-str -{ -v1 := reflect.TypeOf("") -v0 := lang.NewSymbol("prn-str").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("xs"))), lang.NewKeyword("doc"), "prn to a string, returning it", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4767), lang.NewKeyword("end-line"), int(4767))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := lang.NewList(args[0:]...) -var v5 any = "unimplemented: new with non-constant class type" -_ = v5 -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("push-thread-bindings")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("hash-map")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*out*")) -v15 := lang.Apply(v13, []any{v14, v5}) -v16 := lang.Apply(v10, []any{v15}) -_ = v16 -var v17 any -func() { -defer func() { -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v20, nil) -}() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("apply")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("prn")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.Apply(v24, []any{v27, v4}) -_ = v28 -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("str")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.Apply(v31, []any{v5}) -v17 = v32 -}() -return v17 - } -}) -v4 := reflect.TypeOf("") -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// promise -{ -v0 := lang.NewSymbol("promise").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Returns a promise object that can be read with deref/@, and set,\n once only, with deliver. Calls to deref/@ prior to delivery will\n block, unless the variant of deref with timeout is used. All\n subsequent derefs will return the same delivered value without\n blocking. See also - realized?.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7078), lang.NewKeyword("end-line"), int(7078))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := lang.Apply(java.util.concurrent.CountDownLatch18., []any{int64(1)}) -var v3 any = v4 -_ = v3 -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("atom")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v3}) -var v5 any = v9 -_ = v5 -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("deref")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.NewVector(nil) -v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7091), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(7091), lang.NewKeyword("end-column"), int(17)) -v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v17, ok := lang.FieldOrMethod(v3, "await") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "await"))) -} -var v18 any -switch reflect.TypeOf(v17).Kind() { -case reflect.Func: - v18 = lang.Apply(v17, nil) -default: - v18 = v17 -} -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("deref")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v5}) -v23 := lang.Apply(v13, []any{v16, v18, v22}) -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("deref")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.NewVector(nil, nil, nil) -v28 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7094), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(7094), lang.NewKeyword("end-column"), int(34)) -v29, err := lang.WithMeta(v27, v28.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v30 any -v31, _ := lang.FieldOrMethod(v3, "await") -if reflect.TypeOf(v31).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) -} -v32 := lang.Apply(v31, []any{nil, time9.Millisecond}) -if lang.IsTruthy(v32) { -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("deref")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v5}) -v30 = v36 -} else { -v30 = nil -} -v37 := lang.Apply(v26, []any{v29, v30}) -v38 := lang.NewVector(nil) -v39 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7099), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(7099), lang.NewKeyword("end-column"), int(24)) -v40, err := lang.WithMeta(v38, v39.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("zero?")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44, ok := lang.FieldOrMethod(v3, "getCount") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getCount"))) -} -var v45 any -switch reflect.TypeOf(v44).Kind() { -case reflect.Func: - v45 = lang.Apply(v44, nil) -default: - v45 = v44 -} -v46 := lang.Apply(v43, []any{v45}) -v47 := lang.Apply(nil, []any{v40, v46}) -v48 := lang.NewVector(nil, nil) -v49 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7103), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(7103), lang.NewKeyword("end-column"), int(14)) -v50, err := lang.WithMeta(v48, v49.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v51 any -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("pos?")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) -} -v55 := v54.Get() -v56, ok := lang.FieldOrMethod(v3, "getCount") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getCount"))) -} -var v57 any -switch reflect.TypeOf(v56).Kind() { -case reflect.Func: - v57 = lang.Apply(v56, nil) -default: - v57 = v56 -} -v58 := lang.Apply(v55, []any{v57}) -var v52 any = v58 -_ = v52 -var v60 any -if lang.IsTruthy(v52) { -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("compare-and-set!")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) -} -v63 := v62.Get() -v64 := lang.Apply(v63, []any{v5, v3, nil}) -v60 = v64 -} else { -v60 = v52 -} -if lang.IsTruthy(v60) { -v52, ok := lang.FieldOrMethod(v3, "countDown") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "countDown"))) -} -var v53 any -switch reflect.TypeOf(v52).Kind() { -case reflect.Func: - v53 = lang.Apply(v52, nil) -default: - v53 = v52 -} -_ = v53 -v51 = nil -} else { -v51 = nil -} -v54 := lang.Apply(nil, []any{v50, v51}) -v55 := lang.Apply(nil, []any{lang.IDeref, v23, lang.IBlockingDeref, v37, lang.IPending, v47, glojure.lang4.IFn, v54}) -return v55 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// protocol? -{ -v0 := lang.NewSymbol("protocol?").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(110), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(110), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("maybe-p"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{lang.IAtom, v3}) -if lang.IsTruthy(v8) { -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("boolean")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("deref")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v3}) -v16 := lang.Apply(lang.NewKeyword("on-interface"), []any{v15}) -v17 := lang.Apply(v11, []any{v16}) -v4 = v17 -} else { -v4 = false -} -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// push-thread-bindings -{ -v0 := lang.NewSymbol("push-thread-bindings").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"))), lang.NewKeyword("doc"), "WARNING: This is a low-level function. Prefer high-level macros like\n binding where ever possible.\n\n Takes a map of Var/value pairs. Binds each Var to the associated value for\n the current thread. Each call *MUST* be accompanied by a matching call to\n pop-thread-bindings wrapped in a try-finally!\n \n (push-thread-bindings bindings)\n (try\n ...\n (finally\n (pop-thread-bindings)))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(26), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1911), lang.NewKeyword("end-line"), int(1911))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.Apply(lang.PushThreadBindings, []any{v3}) -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// pvalues -{ -v0 := lang.NewSymbol("pvalues").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("exprs"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the values of the exprs, which are\n evaluated in parallel", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7063), lang.NewKeyword("end-line"), int(7063))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("seq")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("concat")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("list")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{lang.NewSymbol("glojure.core/pcalls")}) -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("map")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -var v19 lang.FnFunc -v19 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v20 := args[0] -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("list")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.NewVector() -v25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7069), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(7069), lang.NewKeyword("end-column"), int(31)) -v26, err := lang.WithMeta(v24, v25.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v27 := lang.Apply(v23, []any{lang.NewSymbol("glojure.core/fn"), v26, v20}) -return v27 -}) -v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7069), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(7069), lang.NewKeyword("end-column"), int(34)) -v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v22 := lang.Apply(v18, []any{v21, v5}) -v23 := lang.Apply(v11, []any{v15, v22}) -v24 := lang.Apply(v8, []any{v23}) -return v24 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// qualified-ident? -{ -v0 := lang.NewSymbol("qualified-ident?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a symbol or keyword with a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1618), lang.NewKeyword("end-line"), int(1618))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("boolean")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("ident?")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v3}) -var v7 any = v11 -_ = v7 -var v13 any -if lang.IsTruthy(v7) { -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("namespace")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v3}) -var v14 any = v18 -_ = v14 -var v20 any -if lang.IsTruthy(v14) { -v20 = true -} else { -v20 = v14 -} -v13 = v20 -} else { -v13 = v7 -} -v7 := lang.Apply(v6, []any{v13}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// qualified-keyword? -{ -v0 := lang.NewSymbol("qualified-keyword?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a keyword with a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1638), lang.NewKeyword("end-line"), int(1638))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("boolean")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("keyword?")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v3}) -var v7 any = v11 -_ = v7 -var v13 any -if lang.IsTruthy(v7) { -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("namespace")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v3}) -var v14 any = v18 -_ = v14 -var v20 any -if lang.IsTruthy(v14) { -v20 = true -} else { -v20 = v14 -} -v13 = v20 -} else { -v13 = v7 -} -v7 := lang.Apply(v6, []any{v13}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// qualified-symbol? -{ -v0 := lang.NewSymbol("qualified-symbol?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a symbol with a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1628), lang.NewKeyword("end-line"), int(1628))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("boolean")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("symbol?")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v3}) -var v7 any = v11 -_ = v7 -var v13 any -if lang.IsTruthy(v7) { -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("namespace")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v3}) -var v14 any = v18 -_ = v14 -var v20 any -if lang.IsTruthy(v14) { -v20 = true -} else { -v20 = v14 -} -v13 = v20 -} else { -v13 = v7 -} -v7 := lang.Apply(v6, []any{v13}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// quot -{ -var v1 lang.FnFunc -{ // function quot__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("concat")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("list")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("seq")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("concat")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("list")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/quotient")}) -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v4}) -v40 := lang.Apply(v27, []any{v31, v35, v39}) -v41 := lang.Apply(v24, []any{v40}) -v42 := lang.Apply(v21, []any{v41}) -v43 := lang.Apply(v10, []any{v14, v18, v42}) -v44 := lang.Apply(v7, []any{v43}) -return v44 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("quot").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"), lang.NewSymbol("div"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "quot[ient] of dividing numerator by denominator.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1266), lang.NewKeyword("end-line"), int(1266))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6, _ := lang.FieldOrMethod(lang.Numbers, "quotient") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("quotient is not a function"))) -} -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// rand -{ -v0 := lang.NewSymbol("rand").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns a random floating point number between 0 (inclusive) and\n n (default 1) (exclusive).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4935), lang.NewKeyword("end-line"), int(4935))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v3 := lang.Apply(rand19.Float64, nil) -return v3 - case 1: -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("*")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("rand")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, nil) -v11 := lang.Apply(v6, []any{v3, v10}) -return v11 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// rand-int -{ -v0 := lang.NewSymbol("rand-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns a random integer between 0 (inclusive) and n (exclusive).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4943), lang.NewKeyword("end-line"), int(4943))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("int")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("rand")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v3}) -v11 := lang.Apply(v6, []any{v10}) -return v11 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// rand-nth -{ -v0 := lang.NewSymbol("rand-nth").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return a random element of the (sequential) collection. Will have\n the same performance characteristics as nth for the given\n collection.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7213), lang.NewKeyword("end-line"), int(7213))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("nth")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("rand-int")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("count")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{v3}) -v14 := lang.Apply(v9, []any{v13}) -v15 := lang.Apply(v6, []any{v3, v14}) -return v15 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// random-sample -{ -v0 := lang.NewSymbol("random-sample").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("prob")), lang.NewVector(lang.NewSymbol("prob"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns items from coll with random probability of prob (0.0 -\n 1.0). Returns a transducer when no collection is provided.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7699), lang.NewKeyword("end-line"), int(7699))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("filter")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -var v7 lang.FnFunc -v7 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v8 := args[0] -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("<")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("rand")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, nil) -v16 := lang.Apply(v11, []any{v15, v3}) -return v16 -}) -v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7704), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(7704), lang.NewKeyword("end-column"), int(37)) -v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v10 := lang.Apply(v6, []any{v9}) -return v10 - case 2: -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("filter")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -var v8 lang.FnFunc -v8 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v9 := args[0] -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("<")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("rand")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, nil) -v17 := lang.Apply(v12, []any{v16, v3}) -return v17 -}) -v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7706), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(7706), lang.NewKeyword("end-column"), int(37)) -v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v11 := lang.Apply(v7, []any{v10, v4}) -return v11 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// random-uuid -{ -v0 := lang.NewSymbol("random-uuid").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Returns a pseudo-randomly generated java.util.UUID instance (i.e. type 4).\n\n See: https://docs.oracle.com/javase/8/docs/api/java/util/UUID.html#randomUUID--", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6852), lang.NewKeyword("end-line"), int(6852))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.Apply(uuid20.NewV7, nil) -return v3 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// range -{ -v0 := lang.NewSymbol("range").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("end")), lang.NewVector(lang.NewSymbol("start"), lang.NewSymbol("end")), lang.NewVector(lang.NewSymbol("start"), lang.NewSymbol("end"), lang.NewSymbol("step"))), lang.NewKeyword("doc"), "Returns a lazy seq of nums from start (inclusive) to end\n (exclusive), by step, where start defaults to 0, step to 1, and end to\n infinity. When step is equal to 0, returns an infinite sequence of\n start. When start is equal to end, returns empty list.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3018), lang.NewKeyword("end-line"), int(3018))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v4 := v3.FindInternedVar(lang.NewSymbol("iterate")) -if v4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) -} -v5 := v4.Get() -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("inc'")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v5, []any{v8, int64(0)}) -return v9 - case 1: -v3 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("int?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -if lang.IsTruthy(v8) { -v9 := lang.Apply(lang.NewLongRange, []any{int64(0), v3, int64(1)}) -v4 = v9 -} else { -v10 := lang.Apply(lang.NewRange, []any{int64(0), v3, int64(1)}) -v4 = v10 -} -return v4 - case 2: -v3 := args[0] -v4 := args[1] -var v5 any -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("int?")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v3}) -var v6 any = v10 -_ = v6 -var v12 any -if lang.IsTruthy(v6) { -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("int?")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v4}) -v12 = v16 -} else { -v12 = v6 -} -if lang.IsTruthy(v12) { -v6 := lang.Apply(lang.NewLongRange, []any{v3, v4, int64(1)}) -v5 = v6 -} else { -v7 := lang.Apply(lang.NewRange, []any{v3, v4, int64(1)}) -v5 = v7 -} -return v5 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -var v6 any -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("int?")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v3}) -var v7 any = v11 -_ = v7 -var v13 any -if lang.IsTruthy(v7) { -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("int?")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v4}) -var v14 any = v18 -_ = v14 -var v20 any -if lang.IsTruthy(v14) { -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("int?")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v5}) -v20 = v24 -} else { -v20 = v14 -} -v13 = v20 -} else { -v13 = v7 -} -if lang.IsTruthy(v13) { -v7 := lang.Apply(lang.NewLongRange, []any{v3, v4, v5}) -v6 = v7 -} else { -v8 := lang.Apply(lang.NewRange, []any{v3, v4, v5}) -v6 = v8 -} -return v6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// ratio? -{ -v0 := lang.NewSymbol("ratio?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is a Ratio", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3577), lang.NewKeyword("end-line"), int(3577))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{lang.*Ratio, v3}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// rational? -{ -v0 := lang.NewSymbol("rational?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is a rational number", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3613), lang.NewKeyword("end-line"), int(3613))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("integer?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -var v4 any = v8 -_ = v4 -var v10 any -if lang.IsTruthy(v4) { -v10 = v4 -} else { -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("ratio?")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v3}) -var v11 any = v15 -_ = v11 -var v17 any -if lang.IsTruthy(v11) { -v17 = v11 -} else { -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("decimal?")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v20, []any{v3}) -v17 = v21 -} -v10 = v17 -} -return v10 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// rationalize -{ -v0 := lang.NewSymbol("rationalize").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("doc"), "returns the rational value of num", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1282), lang.NewKeyword("end-line"), int(1282))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, _ := lang.FieldOrMethod(lang.Numbers, "rationalize") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("rationalize is not a function"))) -} -v5 := lang.Apply(v4, []any{v3}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// re-find -{ -v0 := lang.NewSymbol("re-find").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m")), lang.NewVector(lang.NewSymbol("re"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns the next regex match, if any, of string to pattern, using\n java.util.regex.Matcher.find(). Uses re-groups to return the\n groups.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4922), lang.NewKeyword("end-line"), int(4922))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -var v4 any -v5, _ := lang.FieldOrMethod(v3, "find") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("find is not a function"))) -} -v6 := lang.Apply(v5, []any{}) -if lang.IsTruthy(v6) { -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("re-groups")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v3}) -v4 = v10 -} else { -v4 = nil -} -return v4 - case 2: -v3 := args[0] -v4 := args[1] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("re-matcher")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v3, v4}) -var v5 any = v9 -_ = v5 -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("re-find")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v5}) -return v14 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// re-groups -{ -v0 := lang.NewSymbol("re-groups").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"))), lang.NewKeyword("doc"), "Returns the groups from the most recent match/find. If there are no\n nested groups, returns a string of the entire match. If there are\n nested groups, returns a vector of the groups, the first element\n being the entire match.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4882), lang.NewKeyword("end-line"), int(4882))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v5, _ := lang.FieldOrMethod(v3, "groupCount") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("groupCount is not a function"))) -} -v6 := lang.Apply(v5, []any{}) -var v4 any = v6 -_ = v4 -var v8 any -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("zero?")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v4}) -if lang.IsTruthy(v12) { -v13, _ := lang.FieldOrMethod(v3, "group") -if reflect.TypeOf(v13).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("group is not a function"))) -} -v14 := lang.Apply(v13, []any{}) -v8 = v14 -} else { -v16 := lang.NewVector() -v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4893), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(4893), lang.NewKeyword("end-column"), int(21)) -v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v15 any = v18 -_ = v15 -var v19 any = int64(0) -_ = v19 -var v20 any -for { -var v21 any -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("<=")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v19, v4}) -if lang.IsTruthy(v25) { -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("conj")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30, _ := lang.FieldOrMethod(v3, "groupInt") -if reflect.TypeOf(v30).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("groupInt is not a function"))) -} -v31 := lang.Apply(v30, []any{v19}) -v32 := lang.Apply(v29, []any{v15, v31}) -var v26 any = v32 -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("inc")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.Apply(v36, []any{v19}) -var v33 any = v37 -v15 = v26 -v19 = v33 -continue -} else { -v21 = v15 -} -v20 = v21 - break -} -v8 = v20 -} -return v8 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// re-matcher -{ -v1 := reflect.TypeOf((*lang.RegexpMatcher)(nil)) -v0 := lang.NewSymbol("re-matcher").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("re"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns an instance of java.util.regex.Matcher, for use, e.g. in\n re-find.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4873), lang.NewKeyword("end-line"), int(4873))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6 := lang.Apply(lang.NewRegexpMatcher, []any{v4, v5}) -return v6 -}) -v4 := reflect.TypeOf((*lang.RegexpMatcher)(nil)) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// re-matches -{ -v0 := lang.NewSymbol("re-matches").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("re"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns the match, if any, of string to pattern, using\n java.util.regex.Matcher.matches(). Uses re-groups to return the\n groups.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4910), lang.NewKeyword("end-line"), int(4910))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("re-matcher")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v3, v4}) -var v5 any = v9 -_ = v5 -var v11 any -v12, _ := lang.FieldOrMethod(v5, "matches") -if reflect.TypeOf(v12).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("matches is not a function"))) -} -v13 := lang.Apply(v12, []any{}) -if lang.IsTruthy(v13) { -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("re-groups")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v5}) -v11 = v17 -} else { -v11 = nil -} -return v11 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// re-pattern -{ -v1 := reflect.TypeOf((*regexp21.Regexp)(nil)) -v0 := lang.NewSymbol("re-pattern").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns an instance of java.util.regex.Pattern, for use, e.g. in\n re-matcher.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4863), lang.NewKeyword("end-line"), int(4863))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{regexp21.*Regexp, v4}) -if lang.IsTruthy(v9) { -v5 = v4 -} else { -v10 := lang.Apply(regexp21.MustCompile, []any{v4}) -v5 = v10 -} -return v5 -}) -v4 := reflect.TypeOf((*regexp21.Regexp)(nil)) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// re-seq -{ -v0 := lang.NewSymbol("re-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("re"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns a lazy sequence of successive matches of pattern in string,\n using java.util.regex.Matcher.find(), each such match processed with\n re-groups.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4898), lang.NewKeyword("end-line"), int(4898))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("re-matcher")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v3, v4}) -var v5 any = v9 -_ = v5 -var v11 lang.FnFunc -{ // function step -v11 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -var v13 any -v14, _ := lang.FieldOrMethod(v5, "find") -if reflect.TypeOf(v14).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("find is not a function"))) -} -v15 := lang.Apply(v14, []any{}) -if lang.IsTruthy(v15) { -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("cons")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("re-groups")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v5}) -var v23 lang.FnFunc -v23 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v24 := lang.Apply(v12, nil) -return v24 -}) -v24 := lang.Apply(lang.NewLazySeq, []any{v23}) -v25 := lang.Apply(v18, []any{v22, v24}) -v13 = v25 -} else { -v13 = nil -} -return v13 -}) -v12 := v11 -_ = v12 -} -v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4906), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(4908), lang.NewKeyword("end-column"), int(49)) -v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v14 := lang.Apply(v13, nil) -return v14 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// read -{ -v0 := lang.NewSymbol("read").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("stream")), lang.NewVector(lang.NewSymbol("stream"), lang.NewSymbol("eof-error?"), lang.NewSymbol("eof-value")), lang.NewVector(lang.NewSymbol("stream"), lang.NewSymbol("eof-error?"), lang.NewSymbol("eof-value"), lang.NewSymbol("recursive?")), lang.NewVector(lang.NewSymbol("opts"), lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Reads the next object from stream, which must be an instance of\n java.io.PushbackReader or some derivee. stream defaults to the\n current value of *in*.\n\n Opts is a persistent map with valid keys:\n :read-cond - :allow to process reader conditionals, or\n :preserve to keep all branches\n :features - persistent set of feature keywords for reader conditionals\n :eof - on eof, return value unless :eofthrow, then throw.\n if not specified, will throw\n\n Note that read can execute code (controlled by *read-eval*),\n and as such should be used only with trusted sources.\n\n For data structure interop use glojure.edn/read", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3742), lang.NewKeyword("end-line"), int(3742))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v4 := v3.FindInternedVar(lang.NewSymbol("read")) -if v4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) -} -v5 := v4.Get() -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("*in*")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v5, []any{v8}) -return v9 - case 1: -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("read")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{v3, true, nil}) -return v7 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("read")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v3, v4, v5, false}) -return v9 - case 4: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("boolean")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v4}) -v11, _ := lang.FieldOrMethod(glojure.lang4.LispReader, "read") -if reflect.TypeOf(v11).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("read is not a function"))) -} -v12 := lang.Apply(v11, []any{v3, v10, v5, v6}) -return v12 - case 2: -v3 := args[0] -v4 := args[1] -v5, _ := lang.FieldOrMethod(glojure.lang4.LispReader, "read") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("read is not a function"))) -} -v6 := lang.Apply(v5, []any{v4, v3}) -return v6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// read+string -{ -v0 := lang.NewSymbol("read+string").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("stream")), lang.NewVector(lang.NewSymbol("stream"), lang.NewSymbol("eof-error?"), lang.NewSymbol("eof-value")), lang.NewVector(lang.NewSymbol("stream"), lang.NewSymbol("eof-error?"), lang.NewSymbol("eof-value"), lang.NewSymbol("recursive?")), lang.NewVector(lang.NewSymbol("opts"), lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Like read, and taking the same args. stream must be a LineNumberingPushbackReader.\n Returns a vector containing the object read and the (whitespace-trimmed) string read.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3771), lang.NewKeyword("end-line"), int(3771))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v4 := v3.FindInternedVar(lang.NewSymbol("read+string")) -if v4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) -} -v5 := v4.Get() -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("*in*")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v5, []any{v8}) -return v9 - case 1: -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("read+string")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{v3, true, nil}) -return v7 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("read+string")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v3, v4, v5, false}) -return v9 - case 4: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -var v7 any -func() { -defer func() { -if r := recover(); r != nil { -if lang.CatchMatches(r, lang.Throwable) { -v8 := r -_ = v8 -v9, ok := lang.FieldOrMethod(v3, "getString") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getString"))) -} -var v10 any -switch reflect.TypeOf(v9).Kind() { -case reflect.Func: - v10 = lang.Apply(v9, nil) -default: - v10 = v9 -} -_ = v10 -panic(v8) -} else { -panic(r) -} -} -}() -v8, ok := lang.FieldOrMethod(v3, "captureString") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "captureString"))) -} -var v9 any -switch reflect.TypeOf(v8).Kind() { -case reflect.Func: - v9 = lang.Apply(v8, nil) -default: - v9 = v8 -} -_ = v9 -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("read")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v3, v4, v5, v6}) -var v10 any = v14 -_ = v10 -v16, ok := lang.FieldOrMethod(v3, "getString") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getString"))) -} -var v17 any -switch reflect.TypeOf(v16).Kind() { -case reflect.Func: - v17 = lang.Apply(v16, nil) -default: - v17 = v16 -} -v18, ok := lang.FieldOrMethod(v17, "trim") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v17, "trim"))) -} -var v19 any -switch reflect.TypeOf(v18).Kind() { -case reflect.Func: - v19 = lang.Apply(v18, nil) -default: - v19 = v18 -} -var v15 any = v19 -_ = v15 -v21 := lang.NewVector(v10, v15) -v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3783), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(3783), lang.NewKeyword("end-column"), int(12)) -v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v7 = v23 -}() -return v7 - case 2: -v3 := args[0] -v4 := args[1] -var v5 any -func() { -defer func() { -if r := recover(); r != nil { -if lang.CatchMatches(r, lang.Throwable) { -v6 := r -_ = v6 -v7, ok := lang.FieldOrMethod(v4, "getString") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "getString"))) -} -var v8 any -switch reflect.TypeOf(v7).Kind() { -case reflect.Func: - v8 = lang.Apply(v7, nil) -default: - v8 = v7 -} -_ = v8 -panic(v6) -} else { -panic(r) -} -} -}() -v6, ok := lang.FieldOrMethod(v4, "captureString") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "captureString"))) -} -var v7 any -switch reflect.TypeOf(v6).Kind() { -case reflect.Func: - v7 = lang.Apply(v6, nil) -default: - v7 = v6 -} -_ = v7 -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("read")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v3, v4}) -var v8 any = v12 -_ = v8 -v14, ok := lang.FieldOrMethod(v4, "getString") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "getString"))) -} -var v15 any -switch reflect.TypeOf(v14).Kind() { -case reflect.Func: - v15 = lang.Apply(v14, nil) -default: - v15 = v14 -} -v16, ok := lang.FieldOrMethod(v15, "trim") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v15, "trim"))) -} -var v17 any -switch reflect.TypeOf(v16).Kind() { -case reflect.Func: - v17 = lang.Apply(v16, nil) -default: - v17 = v16 -} -var v13 any = v17 -_ = v13 -v19 := lang.NewVector(v8, v13) -v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3792), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(3792), lang.NewKeyword("end-column"), int(12)) -v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v5 = v21 -}() -return v5 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// read-line -{ -v0 := lang.NewSymbol("read-line").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Reads the next line from stream that is the current value of *in* .", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3797), lang.NewKeyword("end-line"), int(3797))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -var v3 any -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("*in*")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v6, []any{glojure.lang4.LineNumberingPushbackReader, v9}) -if lang.IsTruthy(v10) { -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("*in*")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14, ok := lang.FieldOrMethod(v13, "readLine") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v13, "readLine"))) -} -var v15 any -switch reflect.TypeOf(v14).Kind() { -case reflect.Func: - v15 = lang.Apply(v14, nil) -default: - v15 = v14 -} -v3 = v15 -} else { -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("*in*")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19, ok := lang.FieldOrMethod(v18, "readLine") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v18, "readLine"))) -} -var v20 any -switch reflect.TypeOf(v19).Kind() { -case reflect.Func: - v20 = lang.Apply(v19, nil) -default: - v20 = v19 -} -v3 = v20 -} -return v3 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// read-string -{ -v0 := lang.NewSymbol("read-string").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s")), lang.NewVector(lang.NewSymbol("opts"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Reads one object from the string s. Optionally include reader\n options, as specified in read.\n\n Note that read-string can execute code (controlled by *read-eval*),\n and as such should be used only with trusted sources.\n\n For data structure interop use glojure.edn/read-string", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3806), lang.NewKeyword("end-line"), int(3806))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -v4 := lang.Apply(runtime5.RTReadString, []any{v3}) -return v4 - case 2: -v3 := args[0] -v4 := args[1] -v5 := lang.Apply(runtime5.RTReadString, []any{v4, v3}) -return v5 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// reader-conditional -{ -v0 := lang.NewSymbol("reader-conditional").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("form"), lang.NewSymbol("splicing?"))), lang.NewKeyword("doc"), "Construct a data representation of a reader conditional.\n If true, splicing? indicates read-cond-splicing.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7782), lang.NewKeyword("end-line"), int(7782))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.Apply(nil, []any{v3, v4}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// reader-conditional? -{ -v0 := lang.NewSymbol("reader-conditional?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("value"))), lang.NewKeyword("doc"), "Return true if the value is the data representation of a reader conditional", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7776), lang.NewKeyword("end-line"), int(7776))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{glojure.lang4.ReaderConditional, v3}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// realized? -{ -v0 := lang.NewSymbol("realized?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if a value has been produced for a promise, delay, future or lazy sequence.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7559), lang.NewKeyword("end-line"), int(7559))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, ok := lang.FieldOrMethod(v3, "isRealized") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "isRealized"))) -} -var v5 any -switch reflect.TypeOf(v4).Kind() { -case reflect.Func: - v5 = lang.Apply(v4, nil) -default: - v5 = v4 -} -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// reduce -{ -v0 := lang.NewSymbol("reduce").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("val"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "f should be a function of 2 arguments. If val is not supplied,\n returns the result of applying f to the first 2 items in coll, then\n applying f to that result and the 3rd item, etc. If coll contains no\n items, f must accept no arguments as well, and reduce returns the\n result of calling f with no arguments. If coll has only 1 item, it\n is returned and f is not called. If val is supplied, returns the\n result of applying f to val and the first item in coll, then\n applying f to that result and the 2nd item, etc. If coll contains no\n items, returns val and f is not called.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6860), lang.NewKeyword("end-line"), int(6860))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v3 := args[0] -v4 := args[1] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{lang.IReduce, v4}) -if lang.IsTruthy(v9) { -v10, _ := lang.FieldOrMethod(v4, "Reduce") -if reflect.TypeOf(v10).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Reduce is not a function"))) -} -v11 := lang.Apply(v10, []any{v3}) -v5 = v11 -} else { -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core.protocols")) -v13 := v12.FindInternedVar(lang.NewSymbol("coll-reduce")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v4, v3}) -v5 = v15 -} -return v5 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -var v6 any -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("instance?")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{lang.IReduceInit, v5}) -if lang.IsTruthy(v10) { -v11, _ := lang.FieldOrMethod(v5, "ReduceInit") -if reflect.TypeOf(v11).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) -} -v12 := lang.Apply(v11, []any{v3, v4}) -v6 = v12 -} else { -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core.protocols")) -v14 := v13.FindInternedVar(lang.NewSymbol("coll-reduce")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v5, v3, v4}) -v6 = v16 -} -return v6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// reduce-kv -{ -v0 := lang.NewSymbol("reduce-kv").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Reduces an associative collection. f should be a function of 3\n arguments. Returns the result of applying f to init, the first key\n and the first value in coll, then applying f to that result and the\n 2nd key and value, etc. If coll contains no entries, returns init\n and f is not called. Note that reduce-kv is supported on vectors,\n where the keys will be the ordinals.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6882), lang.NewKeyword("end-line"), int(6882))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core.protocols")) -v7 := v6.FindInternedVar(lang.NewSymbol("kv-reduce")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v5, v3, v4}) -return v9 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// reduce1 -{ -v0 := lang.NewSymbol("reduce1").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(923), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(924), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("val"), lang.NewSymbol("coll"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v3 := args[0] -v4 := args[1] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("seq")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v4}) -var v5 any = v9 -_ = v5 -var v11 any -if lang.IsTruthy(v5) { -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("reduce1")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("first")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v5}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("next")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v5}) -v23 := lang.Apply(v14, []any{v3, v18, v22}) -v11 = v23 -} else { -v24 := lang.Apply(v3, nil) -v11 = v24 -} -return v11 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -recur_loop_156: -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("seq")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v5}) -var v6 any = v10 -_ = v6 -var v12 any -if lang.IsTruthy(v6) { -var v13 any -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("chunked-seq?")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v6}) -if lang.IsTruthy(v17) { -var v18 any = v3 -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("chunk-first")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.Apply(v22, []any{v6}) -v24, _ := lang.FieldOrMethod(v23, "ReduceInit") -if reflect.TypeOf(v24).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) -} -v25 := lang.Apply(v24, []any{v3, v4}) -var v19 any = v25 -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("chunk-next")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{v6}) -var v26 any = v30 -v3 = v18 -v4 = v19 -v5 = v26 -goto recur_loop_156 -} else { -var v31 any = v3 -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("first")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v6}) -v37 := lang.Apply(v3, []any{v4, v36}) -var v32 any = v37 -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("next")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) -} -v41 := v40.Get() -v42 := lang.Apply(v41, []any{v6}) -var v38 any = v42 -v3 = v31 -v4 = v32 -v5 = v38 -goto recur_loop_156 -} -v12 = v13 -} else { -v12 = v4 -} -return v12 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// reduced -{ -v0 := lang.NewSymbol("reduced").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Wraps x in a way such that a reduce will terminate with the value x", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2828), lang.NewKeyword("end-line"), int(2828))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.Apply(lang.NewReduced, []any{v3}) -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// reduced? -{ -var v1 lang.FnFunc -{ // function reduced?__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.IsReduced")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v3}) -v18 := lang.Apply(v9, []any{v13, v17}) -v19 := lang.Apply(v6, []any{v18}) -return v19 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("reduced?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns true if x is the result of a call to reduced", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)), lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2834), lang.NewKeyword("end-line"), int(2834))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := lang.Apply(lang.IsReduced, []any{v4}) -return v5 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// reductions -{ -v0 := lang.NewSymbol("reductions").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy seq of the intermediate values of the reduction (as\n per reduce) of coll by f, starting with init.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7196), lang.NewKeyword("end-line"), int(7196))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v3 := args[0] -v4 := args[1] -var v5 lang.FnFunc -v5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("seq")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v4}) -var v6 any = v10 -_ = v6 -var v12 any -if lang.IsTruthy(v6) { -var v13 any = v6 -_ = v13 -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("reductions")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("first")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v20, []any{v13}) -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("rest")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v13}) -v26 := lang.Apply(v17, []any{v3, v21, v25}) -v12 = v26 -} else { -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("list")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v3, nil) -v17 := lang.Apply(v15, []any{v16}) -v12 = v17 -} -return v12 -}) -v6 := lang.Apply(lang.NewLazySeq, []any{v5}) -return v6 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -var v6 any -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("reduced?")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v4}) -if lang.IsTruthy(v10) { -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("list")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("deref")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v4}) -v18 := lang.Apply(v13, []any{v17}) -v6 = v18 -} else { -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("cons")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -var v22 lang.FnFunc -v22 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("seq")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v5}) -var v23 any = v27 -_ = v23 -var v29 any -if lang.IsTruthy(v23) { -var v30 any = v23 -_ = v30 -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("reductions")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("first")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v30}) -v39 := lang.Apply(v3, []any{v4, v38}) -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("rest")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v30}) -v44 := lang.Apply(v34, []any{v3, v39, v43}) -v29 = v44 -} else { -v29 = nil -} -return v29 -}) -v23 := lang.Apply(lang.NewLazySeq, []any{v22}) -v24 := lang.Apply(v21, []any{v4, v23}) -v6 = v24 -} -return v6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// ref -{ -v0 := lang.NewSymbol("ref").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Creates and returns a Ref with an initial value of x and zero or\n more options (in any order):\n\n :meta metadata-map\n\n :validator validate-fn\n\n :min-history (default 0)\n :max-history (default 10)\n\n If metadata-map is supplied, it will become the metadata on the\n ref. validate-fn must be nil or a side-effect-free fn of one\n argument, which will be passed the intended new state on any state\n change. If the new state is unacceptable, the validate-fn should\n return false or throw an exception. validate-fn will be called on\n transaction commit, when all refs have their final values.\n\n Normally refs accumulate history dynamically as needed to deal with\n read demands. If you know in advance you will need history you can\n set :min-history to ensure it will be available when first needed (instead\n of after a read fault). History is limited, and the limit can be set\n with :max-history.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2260), lang.NewKeyword("end-line"), int(2260))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -v4 := lang.Apply(lang.NewRef, []any{v3}) -return v4 - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.NewList(args[1:]...) -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("setup-reference")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("ref")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v3}) -v13 := lang.Apply(v8, []any{v12, v4}) -var v5 any = v13 -_ = v5 -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("apply")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("hash-map")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v17, []any{v20, v4}) -var v14 any = v21 -_ = v14 -var v23 any -v24 := lang.Apply(lang.NewKeyword("max-history"), []any{v14}) -if lang.IsTruthy(v24) { -v25 := lang.Apply(lang.NewKeyword("max-history"), []any{v14}) -v26, _ := lang.FieldOrMethod(v5, "setMaxHistory") -if reflect.TypeOf(v26).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMaxHistory is not a function"))) -} -v27 := lang.Apply(v26, []any{v25}) -v23 = v27 -} else { -v23 = nil -} -_ = v23 -var v28 any -v29 := lang.Apply(lang.NewKeyword("min-history"), []any{v14}) -if lang.IsTruthy(v29) { -v30 := lang.Apply(lang.NewKeyword("min-history"), []any{v14}) -v31, _ := lang.FieldOrMethod(v5, "setMinHistory") -if reflect.TypeOf(v31).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMinHistory is not a function"))) -} -v32 := lang.Apply(v31, []any{v30}) -v28 = v32 -} else { -v28 = nil -} -_ = v28 -return v5 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// ref-history-count -{ -v0 := lang.NewSymbol("ref-history-count").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref"))), lang.NewKeyword("doc"), "Returns the history count of a ref", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2455), lang.NewKeyword("end-line"), int(2455))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, ok := lang.FieldOrMethod(v3, "getHistoryCount") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getHistoryCount"))) -} -var v5 any -switch reflect.TypeOf(v4).Kind() { -case reflect.Func: - v5 = lang.Apply(v4, nil) -default: - v5 = v4 -} -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// ref-max-history -{ -v0 := lang.NewSymbol("ref-max-history").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref")), lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Gets the max-history of a ref, or sets it and returns the ref", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2471), lang.NewKeyword("end-line"), int(2471))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -v4, ok := lang.FieldOrMethod(v3, "getMaxHistory") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getMaxHistory"))) -} -var v5 any -switch reflect.TypeOf(v4).Kind() { -case reflect.Func: - v5 = lang.Apply(v4, nil) -default: - v5 = v4 -} -return v5 - case 2: -v3 := args[0] -v4 := args[1] -v5, _ := lang.FieldOrMethod(v3, "setMaxHistory") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMaxHistory is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// ref-min-history -{ -v0 := lang.NewSymbol("ref-min-history").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref")), lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Gets the min-history of a ref, or sets it and returns the ref", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2462), lang.NewKeyword("end-line"), int(2462))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -v4, ok := lang.FieldOrMethod(v3, "getMinHistory") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getMinHistory"))) -} -var v5 any -switch reflect.TypeOf(v4).Kind() { -case reflect.Func: - v5 = lang.Apply(v4, nil) -default: - v5 = v4 -} -return v5 - case 2: -v3 := args[0] -v4 := args[1] -v5, _ := lang.FieldOrMethod(v3, "setMinHistory") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMinHistory is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// ref-set -{ -v0 := lang.NewSymbol("ref-set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Must be called in a transaction. Sets the value of ref.\n Returns val.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2447), lang.NewKeyword("end-line"), int(2447))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5, _ := lang.FieldOrMethod(v3, "set") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("set is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// refer -{ -v0 := lang.NewSymbol("refer").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns-sym"), lang.NewSymbol("&"), lang.NewSymbol("filters"))), lang.NewKeyword("doc"), "refers to all public vars of ns, subject to filters.\n filters can include at most one each of:\n\n :exclude list-of-symbols\n :only list-of-symbols\n :rename map-of-fromsymbol-tosymbol\n\n For each public interned var in the namespace named by the symbol,\n adds a mapping from the name of the var to the var to the current\n namespace. Throws an exception if name is already mapped to\n something else in the current namespace. Filters can be used to\n select a subset, via inclusion or exclusion, or to provide a mapping\n to a symbol different from the var's name, in order to prevent\n clashes. Use :use in the ns macro in preference to calling this directly.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4216), lang.NewKeyword("end-line"), int(4216))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.NewList(args[1:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("find-ns")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v3}) -var v6 any = v10 -_ = v6 -var v12 any -if lang.IsTruthy(v6) { -v12 = v6 -} else { -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("str")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{"No namespace: ", v3}) -v17 := lang.Apply(errors6.New, []any{v16}) -panic(v17) -} -var v5 any = v12 -_ = v5 -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("apply")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("hash-map")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v9, []any{v12, v4}) -var v6 any = v13 -_ = v6 -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("ns-publics")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v5}) -var v14 any = v18 -_ = v14 -v21 := lang.Apply(lang.NewKeyword("rename"), []any{v6}) -var v20 any = v21 -_ = v20 -var v23 any -if lang.IsTruthy(v20) { -v23 = v20 -} else { -v24 := lang.NewMap() -v25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4236), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(4236), lang.NewKeyword("end-column"), int(36)) -v26, err := lang.WithMeta(v24, v25.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v23 = v26 -} -var v19 any = v23 -_ = v19 -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("set")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(lang.NewKeyword("exclude"), []any{v6}) -v25 := lang.Apply(v23, []any{v24}) -var v20 any = v25 -_ = v20 -var v27 any -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("=")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(lang.NewKeyword("refer"), []any{v6}) -v32 := lang.Apply(v30, []any{lang.NewKeyword("all"), v31}) -if lang.IsTruthy(v32) { -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("keys")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v14}) -v27 = v36 -} else { -v38 := lang.Apply(lang.NewKeyword("refer"), []any{v6}) -var v37 any = v38 -_ = v37 -var v40 any -if lang.IsTruthy(v37) { -v40 = v37 -} else { -v42 := lang.Apply(lang.NewKeyword("only"), []any{v6}) -var v41 any = v42 -_ = v41 -var v44 any -if lang.IsTruthy(v41) { -v44 = v41 -} else { -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("keys")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.Apply(v47, []any{v14}) -v44 = v48 -} -v40 = v44 -} -v27 = v40 -} -var v26 any = v27 -_ = v26 -var v38 any -var v39 any = v26 -_ = v39 -var v41 any -if lang.IsTruthy(v39) { -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("not")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) -} -v44 := v43.Get() -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("instance?")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.Apply(v47, []any{lang.Sequential, v26}) -v49 := lang.Apply(v44, []any{v48}) -v41 = v49 -} else { -v41 = v39 -} -if lang.IsTruthy(v41) { -v39 := lang.Apply(errors6.New, []any{":only/:refer value must be a sequential collection of symbols"}) -panic(v39) -} else { -v38 = nil -} -_ = v38 -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("seq")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v26}) -var v40 any = v44 -_ = v40 -var v45 any = nil -_ = v45 -var v46 any = int64(0) -_ = v46 -var v47 any = int64(0) -_ = v47 -var v48 any -for { -var v49 any -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("<")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.Apply(v52, []any{v47, v46}) -if lang.IsTruthy(v53) { -v55, _ := lang.FieldOrMethod(v45, "nth") -if reflect.TypeOf(v55).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) -} -v56 := lang.Apply(v55, []any{v47}) -var v54 any = v56 -_ = v54 -var v58 any -v59 := lang.Apply(v20, []any{v54}) -if lang.IsTruthy(v59) { -v58 = nil -} else { -v61 := lang.Apply(v14, []any{v54}) -var v60 any = v61 -_ = v60 -var v63 any -if lang.IsTruthy(v60) { -v63 = nil -} else { -panic("unimplemented: new with non-constant class type") -} -_ = v63 -v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v65 := v64.FindInternedVar(lang.NewSymbol("*ns*")) -if v65.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) -} -v66 := v65.Get() -v68 := lang.Apply(v19, []any{v54}) -var v67 any = v68 -_ = v67 -var v70 any -if lang.IsTruthy(v67) { -v70 = v67 -} else { -v70 = v54 -} -v67, _ := lang.FieldOrMethod(v66, "Refer") -if reflect.TypeOf(v67).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Refer is not a function"))) -} -v68 := lang.Apply(v67, []any{v70, v60}) -v58 = v68 -} -_ = v58 -var v60 any = v40 -var v61 any = v45 -var v62 any = v46 -v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v65 := v64.FindInternedVar(lang.NewSymbol("unchecked-inc")) -if v65.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) -} -v66 := v65.Get() -v67 := lang.Apply(v66, []any{v47}) -var v63 any = v67 -v40 = v60 -v45 = v61 -v46 = v62 -v47 = v63 -continue -} else { -v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v56 := v55.FindInternedVar(lang.NewSymbol("seq")) -if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) -} -v57 := v56.Get() -v58 := lang.Apply(v57, []any{v40}) -var v54 any = v58 -_ = v54 -var v60 any -if lang.IsTruthy(v54) { -var v61 any = v54 -_ = v61 -var v63 any -v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v65 := v64.FindInternedVar(lang.NewSymbol("chunked-seq?")) -if v65.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) -} -v66 := v65.Get() -v67 := lang.Apply(v66, []any{v61}) -if lang.IsTruthy(v67) { -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("chunk-first")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) -} -v71 := v70.Get() -v72 := lang.Apply(v71, []any{v61}) -var v68 any = v72 -_ = v68 -v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v76 := v75.FindInternedVar(lang.NewSymbol("chunk-rest")) -if v76.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) -} -v77 := v76.Get() -v78 := lang.Apply(v77, []any{v61}) -var v74 any = v78 -var v79 any = v68 -v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v82 := v81.FindInternedVar(lang.NewSymbol("int")) -if v82.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) -} -v83 := v82.Get() -v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v85 := v84.FindInternedVar(lang.NewSymbol("count")) -if v85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) -} -v86 := v85.Get() -v87 := lang.Apply(v86, []any{v68}) -v88 := lang.Apply(v83, []any{v87}) -var v80 any = v88 -v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v91 := v90.FindInternedVar(lang.NewSymbol("int")) -if v91.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) -} -v92 := v91.Get() -v93 := lang.Apply(v92, []any{int64(0)}) -var v89 any = v93 -v40 = v74 -v45 = v79 -v46 = v80 -v47 = v89 -continue -} else { -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("first")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) -} -v71 := v70.Get() -v72 := lang.Apply(v71, []any{v61}) -var v68 any = v72 -_ = v68 -var v74 any -v75 := lang.Apply(v20, []any{v68}) -if lang.IsTruthy(v75) { -v74 = nil -} else { -v77 := lang.Apply(v14, []any{v68}) -var v76 any = v77 -_ = v76 -var v79 any -if lang.IsTruthy(v76) { -v79 = nil -} else { -panic("unimplemented: new with non-constant class type") -} -_ = v79 -v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v81 := v80.FindInternedVar(lang.NewSymbol("*ns*")) -if v81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) -} -v82 := v81.Get() -v84 := lang.Apply(v19, []any{v68}) -var v83 any = v84 -_ = v83 -var v86 any -if lang.IsTruthy(v83) { -v86 = v83 -} else { -v86 = v68 -} -v83, _ := lang.FieldOrMethod(v82, "Refer") -if reflect.TypeOf(v83).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Refer is not a function"))) -} -v84 := lang.Apply(v83, []any{v86, v76}) -v74 = v84 -} -_ = v74 -v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v78 := v77.FindInternedVar(lang.NewSymbol("next")) -if v78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) -} -v79 := v78.Get() -v80 := lang.Apply(v79, []any{v61}) -var v76 any = v80 -var v81 any = nil -var v82 any = int64(0) -var v83 any = int64(0) -v40 = v76 -v45 = v81 -v46 = v82 -v47 = v83 -continue -} -v60 = v63 -} else { -v60 = nil -} -v49 = v60 -} -v48 = v49 - break -} -return v48 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// refer-glojure -{ -v0 := lang.NewSymbol("refer-glojure").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("filters"))), lang.NewKeyword("doc"), "Same as (refer 'glojure.core )", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5800), lang.NewKeyword("end-line"), int(5800))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("seq")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("concat")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("list")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{lang.NewSymbol("glojure.core/refer")}) -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("list")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("seq")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("concat")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("list")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.Apply(v27, []any{lang.NewSymbol("quote")}) -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("list")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.Apply(v31, []any{lang.NewSymbol("glojure.core")}) -v33 := lang.Apply(v24, []any{v28, v32}) -v34 := lang.Apply(v21, []any{v33}) -v35 := lang.Apply(v18, []any{v34}) -v36 := lang.Apply(v11, []any{v15, v35, v5}) -v37 := lang.Apply(v8, []any{v36}) -return v37 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// release-pending-sends -{ -v0 := lang.NewSymbol("release-pending-sends").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Normally, actions sent directly or indirectly during another action\n are held until the action completes (changes the agent's\n state). This function can be used to dispatch any pending sent\n actions immediately. This has no impact on actions sent during a\n transaction, which are still held until commit. If no action is\n occurring, does nothing. Returns the number of actions dispatched.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2131), lang.NewKeyword("end-line"), int(2131))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.Apply(nil, nil) -return v3 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// rem -{ -var v1 lang.FnFunc -{ // function rem__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("concat")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("list")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("seq")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("concat")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("list")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/remainder")}) -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v4}) -v40 := lang.Apply(v27, []any{v31, v35, v39}) -v41 := lang.Apply(v24, []any{v40}) -v42 := lang.Apply(v21, []any{v41}) -v43 := lang.Apply(v10, []any{v14, v18, v42}) -v44 := lang.Apply(v7, []any{v43}) -return v44 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("rem").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"), lang.NewSymbol("div"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "remainder of dividing numerator by denominator.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1274), lang.NewKeyword("end-line"), int(1274))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6, _ := lang.FieldOrMethod(lang.Numbers, "remainder") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("remainder is not a function"))) -} -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// remove -{ -v0 := lang.NewSymbol("remove").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred")), lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the items in coll for which\n (pred item) returns logical false. pred must be free of side-effects.\n Returns a transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2818), lang.NewKeyword("end-line"), int(2818))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("filter")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("complement")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v3}) -v11 := lang.Apply(v6, []any{v10}) -return v11 - case 2: -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("filter")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("complement")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v3}) -v12 := lang.Apply(v7, []any{v11, v4}) -return v12 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// remove-all-methods -{ -v0 := lang.NewSymbol("remove-all-methods").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"))), lang.NewKeyword("doc"), "Removes all of the methods of multimethod.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1787), lang.NewKeyword("end-line"), int(1787))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, ok := lang.FieldOrMethod(v3, "reset") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "reset"))) -} -var v5 any -switch reflect.TypeOf(v4).Kind() { -case reflect.Func: - v5 = lang.Apply(v4, nil) -default: - v5 = v4 -} -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// remove-method -{ -v0 := lang.NewSymbol("remove-method").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"), lang.NewSymbol("dispatch-val"))), lang.NewKeyword("doc"), "Removes the method of multimethod associated with dispatch-value.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1794), lang.NewKeyword("end-line"), int(1794))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5, _ := lang.FieldOrMethod(v3, "removeMethod") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("removeMethod is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// remove-ns -{ -v0 := lang.NewSymbol("remove-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Removes the namespace named by the symbol. Use with caution.\n Cannot be used to remove the glojure namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4139), lang.NewKeyword("end-line"), int(4139))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.Apply(lang.RemoveNamespace, []any{v3}) -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// remove-tap -{ -v0 := lang.NewSymbol("remove-tap").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Remove f from the tap set.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7883), lang.NewKeyword("end-line"), int(7883))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("swap!")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("tapset")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("disj")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v6, []any{v9, v12, v3}) -_ = v13 -return nil -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// remove-watch -{ -v0 := lang.NewSymbol("remove-watch").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("reference"), lang.NewSymbol("key"))), lang.NewKeyword("doc"), "Removes a watch (set by add-watch) from a reference", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2160), lang.NewKeyword("end-line"), int(2160))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5, _ := lang.FieldOrMethod(v3, "removeWatch") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("removeWatch is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// repeat -{ -v0 := lang.NewSymbol("repeat").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns a lazy (infinite!, or length n if supplied) sequence of xs.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2997), lang.NewKeyword("end-line"), int(2997))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -v4 := lang.Apply(lang.NewRepeat, []any{v3}) -return v4 - case 2: -v3 := args[0] -v4 := args[1] -v5 := lang.Apply(lang.NewRepeatN, []any{v3, v4}) -return v5 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// repeatedly -{ -v0 := lang.NewSymbol("repeatedly").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Takes a function of no args, presumably with side effects, and\n returns an infinite (or length n if supplied) lazy sequence of calls\n to it", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5167), lang.NewKeyword("end-line"), int(5167))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("cons")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v3, nil) -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("repeatedly")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v3}) -v13 := lang.Apply(v7, []any{v8, v12}) -return v13 -}) -v5 := lang.Apply(lang.NewLazySeq, []any{v4}) -return v5 - case 2: -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("take")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("repeatedly")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v4}) -v12 := lang.Apply(v7, []any{v3, v11}) -return v12 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// replace -{ -v0 := lang.NewSymbol("replace").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("smap")), lang.NewVector(lang.NewSymbol("smap"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Given a map of replacement pairs and a vector/collection, returns a\n vector/seq with any elements = a key in smap replaced with the\n corresponding val in smap. Returns a transducer when no collection\n is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5082), lang.NewKeyword("end-line"), int(5082))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("map")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -var v7 lang.FnFunc -v7 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v8 := args[0] -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("find")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{v3, v8}) -var v9 any = v13 -_ = v9 -var v15 any -if lang.IsTruthy(v9) { -var v16 any = v9 -_ = v16 -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("val")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v20, []any{v16}) -v15 = v21 -} else { -v15 = v8 -} -return v15 -}) -v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5090), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5090), lang.NewKeyword("end-column"), int(47)) -v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v10 := lang.Apply(v6, []any{v9}) -return v10 - case 2: -v3 := args[0] -v4 := args[1] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("vector?")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v4}) -if lang.IsTruthy(v9) { -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("reduce1")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -var v13 lang.FnFunc -v13 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v14 := args[0] -v15 := args[1] -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("find")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("nth")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.Apply(v22, []any{v14, v15}) -v24 := lang.Apply(v19, []any{v3, v23}) -var v16 any = v24 -_ = v16 -var v26 any -if lang.IsTruthy(v16) { -var v27 any = v16 -_ = v27 -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("assoc")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("val")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v27}) -v36 := lang.Apply(v31, []any{v14, v15, v35}) -v26 = v36 -} else { -v26 = v14 -} -return v26 -}) -v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5093), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(5096), lang.NewKeyword("end-column"), int(23)) -v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("range")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("count")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v4}) -v23 := lang.Apply(v18, []any{v22}) -v24 := lang.Apply(v12, []any{v15, v4, v23}) -v5 = v24 -} else { -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("map")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -var v28 lang.FnFunc -v28 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v29 := args[0] -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("find")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v3, v29}) -var v30 any = v34 -_ = v30 -var v36 any -if lang.IsTruthy(v30) { -var v37 any = v30 -_ = v37 -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("val")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) -} -v41 := v40.Get() -v42 := lang.Apply(v41, []any{v37}) -v36 = v42 -} else { -v36 = v29 -} -return v36 -}) -v29 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5098), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(5098), lang.NewKeyword("end-column"), int(49)) -v30, err := lang.WithMeta(v28, v29.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v31 := lang.Apply(v27, []any{v30, v4}) -v5 = v31 -} -return v5 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// replicate -{ -v0 := lang.NewSymbol("replicate").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "DEPRECATED: Use 'repeat' instead.\n Returns a lazy seq of n xs.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("deprecated"), "1.3", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3004), lang.NewKeyword("end-line"), int(3004))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("take")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("repeat")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v4}) -v12 := lang.Apply(v7, []any{v3, v11}) -return v12 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// require -{ -v0 := lang.NewSymbol("require").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Loads libs, skipping any that are already loaded. Each argument is\n either a libspec that identifies a lib, a prefix list that identifies\n multiple libs whose names share a common prefix, or a flag that modifies\n how all the identified libs are loaded. Use :require in the ns macro\n in preference to calling this directly.\n\n Libs\n\n A 'lib' is a named set of resources in classpath whose contents define a\n library of Clojure code. Lib names are symbols and each lib is associated\n with a Clojure namespace and a Java package that share its name. A lib's\n name also locates its root directory within classpath using Java's\n package name to classpath-relative path mapping. All resources in a lib\n should be contained in the directory structure under its root directory.\n All definitions a lib makes should be in its associated namespace.\n\n 'require loads a lib by loading its root resource. The root resource path\n is derived from the lib name in the following manner:\n Consider a lib named by the symbol 'x.y.z; it has the root directory\n /x/y/, and its root resource is /x/y/z.clj, or\n /x/y/z.cljc if /x/y/z.clj does not exist. The\n root resource should contain code to create the lib's\n namespace (usually by using the ns macro) and load any additional\n lib resources.\n\n Libspecs\n\n A libspec is a lib name or a vector containing a lib name followed by\n options expressed as sequential keywords and arguments.\n\n Recognized options:\n :as takes a symbol as its argument and makes that symbol an alias to the\n lib's namespace in the current namespace.\n :as-alias takes a symbol as its argument and aliases like :as, however\n the lib will not be loaded. If the lib has not been loaded, a new\n empty namespace will be created (as with create-ns).\n :refer takes a list of symbols to refer from the namespace or the :all\n keyword to bring in all public vars.\n\n Prefix Lists\n\n It's common for Clojure code to depend on several libs whose names have\n the same prefix. When specifying libs, prefix lists can be used to reduce\n repetition. A prefix list contains the shared prefix followed by libspecs\n with the shared prefix removed from the lib names. After removing the\n prefix, the names that remain must not contain any periods.\n\n Flags\n\n A flag is a keyword.\n Recognized flags: :reload, :reload-all, :verbose\n :reload forces loading of all the identified libs even if they are\n already loaded (has no effect on libspecs using :as-alias)\n :reload-all implies :reload and also forces loading of all libs that the\n identified libs directly or indirectly load via require or use\n (has no effect on libspecs using :as-alias)\n :verbose triggers printing information about each load, alias, and refer\n\n Example:\n\n The following would load the libraries glojure.zip and glojure.set\n abbreviated as 's'.\n\n (require '(glojure zip [set :as s]))", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5989), lang.NewKeyword("end-line"), int(5989))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewList(args[0:]...) -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("apply")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("load-libs")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v6, []any{v9, lang.NewKeyword("require"), v3}) -return v10 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// requiring-resolve -{ -v0 := lang.NewSymbol("requiring-resolve").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Resolves namespace-qualified sym per 'resolve'. If initial resolve\nfails, attempts to require sym's namespace and retries.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6068), lang.NewKeyword("end-line"), int(6068))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("qualified-symbol?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -if lang.IsTruthy(v8) { -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("resolve")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{v3}) -var v9 any = v13 -_ = v9 -var v15 any -if lang.IsTruthy(v9) { -v15 = v9 -} else { -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("serialized-require")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("symbol")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("namespace")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v26 := lang.Apply(v21, []any{v25}) -v27 := lang.Apply(v18, []any{v26}) -_ = v27 -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("resolve")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{v3}) -v15 = v31 -} -v4 = v15 -} else { -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("str")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v11, []any{"Not a qualified symbol: ", v3}) -v13 := lang.Apply(lang.NewIllegalArgumentError, []any{v12}) -panic(v13) -} -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// reset! -{ -v0 := lang.NewSymbol("reset!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atom"), lang.NewSymbol("newval"))), lang.NewKeyword("doc"), "Sets the value of atom to newval without regard for the\n current value. Returns newval.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2368), lang.NewKeyword("end-line"), int(2368))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5, _ := lang.FieldOrMethod(v3, "reset") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// reset-meta! -{ -v0 := lang.NewSymbol("reset-meta!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("iref"), lang.NewSymbol("metadata-map"))), lang.NewKeyword("doc"), "Atomically resets the metadata for a namespace/var/ref/agent/atom", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2408), lang.NewKeyword("end-line"), int(2408))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5, _ := lang.FieldOrMethod(v3, "ResetMeta") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ResetMeta is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// reset-vals! -{ -v0 := lang.NewSymbol("reset-vals!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atom"), lang.NewSymbol("newval"))), lang.NewKeyword("doc"), "Sets the value of atom to newval. Returns [old new], the value of the\n atom before and after the reset.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2375), lang.NewKeyword("end-line"), int(2375))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5, _ := lang.FieldOrMethod(v3, "resetVals") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("resetVals is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// resolve -{ -v0 := lang.NewSymbol("resolve").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym")), lang.NewVector(lang.NewSymbol("env"), lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "same as (ns-resolve *ns* symbol) or (ns-resolve *ns* &env symbol)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4371), lang.NewKeyword("end-line"), int(4371))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("ns-resolve")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("*ns*")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v6, []any{v9, v3}) -return v10 - case 2: -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("ns-resolve")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("*ns*")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v7, []any{v10, v3, v4}) -return v11 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// rest -{ -v1 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() -v0 := lang.NewSymbol("rest").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a possibly empty seq of the items after the first. Calls seq on its\n argument.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(64), lang.NewKeyword("end-line"), int(70))).(*lang.Symbol) -var v3 lang.FnFunc -{ // function rest -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := args[0] -v6 := lang.Apply(lang.Rest, []any{v5}) -return v6 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(70), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(70), lang.NewKeyword("end-column"), int(77))).(lang.FnFunc) -v4 := v3 -_ = v4 -} -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// restart-agent -{ -v0 := lang.NewSymbol("restart-agent").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("new-state"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "When an agent is failed, changes the agent state to new-state and\n then un-fails the agent so that sends are allowed again. If\n a :clear-actions true option is given, any actions queued on the\n agent that were being held while it was failed will be discarded,\n otherwise those held actions will proceed. The new-state must pass\n the validator if any, or restart will throw an exception and the\n agent will remain failed with its old state and error. Watchers, if\n any, will NOT be notified of the new state. Throws an exception if\n the agent is not failed.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2175), lang.NewKeyword("end-line"), int(2175))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("apply")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("hash-map")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v9, []any{v12, v5}) -var v6 any = v13 -_ = v6 -var v15 any -v16 := lang.Apply(lang.NewKeyword("clear-actions"), []any{v6}) -if lang.IsTruthy(v16) { -v15 = true -} else { -v15 = false -} -v17, _ := lang.FieldOrMethod(v3, "restart") -if reflect.TypeOf(v17).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("restart is not a function"))) -} -v18 := lang.Apply(v17, []any{v4, v15}) -return v18 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// resultset-seq -{ -v0 := lang.NewSymbol("resultset-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rs"))), lang.NewKeyword("doc"), "Creates and returns a lazy sequence of structmaps corresponding to\n the rows in the java.sql.ResultSet rs", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5681), lang.NewKeyword("end-line"), int(5681))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v5, _ := lang.FieldOrMethod(v3, "getMetaData") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("getMetaData is not a function"))) -} -v6 := lang.Apply(v5, []any{}) -var v4 any = v6 -_ = v4 -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("range")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("inc")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14, _ := lang.FieldOrMethod(v4, "getColumnCount") -if reflect.TypeOf(v14).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("getColumnCount is not a function"))) -} -v15 := lang.Apply(v14, []any{}) -v16 := lang.Apply(v13, []any{v15}) -v17 := lang.Apply(v10, []any{int64(1), v16}) -var v7 any = v17 -_ = v7 -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("map")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("comp")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("keyword")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -var v28 lang.FnFunc -v28 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v29 := args[0] -v30, ok := lang.FieldOrMethod(v29, "toLowerCase") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v29, "toLowerCase"))) -} -var v31 any -switch reflect.TypeOf(v30).Kind() { -case reflect.Func: - v31 = lang.Apply(v30, nil) -default: - v31 = v30 -} -return v31 -}) -v29 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5688), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(5688), lang.NewKeyword("end-column"), int(62)) -v30, err := lang.WithMeta(v28, v29.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v31 := lang.Apply(v24, []any{v27, v30}) -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("map")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -var v35 lang.FnFunc -v35 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v36 := args[0] -v37, _ := lang.FieldOrMethod(v4, "getColumnLabel") -if reflect.TypeOf(v37).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("getColumnLabel is not a function"))) -} -v38 := lang.Apply(v37, []any{v36}) -return v38 -}) -v36 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5689), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(5689), lang.NewKeyword("end-column"), int(63)) -v37, err := lang.WithMeta(v35, v36.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v38 := lang.Apply(v34, []any{v37, v7}) -v39 := lang.Apply(v21, []any{v31, v38}) -var v18 any = v39 -_ = v18 -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("apply")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) -} -v44 := v43.Get() -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("distinct?")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.Apply(v44, []any{v47, v18}) -var v41 any = v48 -_ = v41 -var v50 any -if lang.IsTruthy(v41) { -v50 = v41 -} else { -v51 := lang.Apply(lang.NewError, []any{"ResultSet must have unique column labels"}) -panic(v51) -} -var v40 any = v50 -_ = v40 -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("apply")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) -} -v44 := v43.Get() -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("create-struct")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.Apply(v44, []any{v47, v18}) -var v41 any = v48 -_ = v41 -var v50 lang.FnFunc -v50 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v52 := v51.FindInternedVar(lang.NewSymbol("map")) -if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) -} -v53 := v52.Get() -var v54 lang.FnFunc -v54 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v55 := args[0] -v56, _ := lang.FieldOrMethod(v3, "getObject") -if reflect.TypeOf(v56).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("getObject is not a function"))) -} -v57 := lang.Apply(v56, []any{v55}) -return v57 -}) -v55 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5694), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(5694), lang.NewKeyword("end-column"), int(71)) -v56, err := lang.WithMeta(v54, v55.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v57 := lang.Apply(v53, []any{v56, v7}) -return v57 -}) -v51 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5694), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(5694), lang.NewKeyword("end-column"), int(78)) -v52, err := lang.WithMeta(v50, v51.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v49 any = v52 -_ = v49 -var v54 lang.FnFunc -{ // function thisfn -v54 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -var v56 any -v57, _ := lang.FieldOrMethod(v3, "next") -if reflect.TypeOf(v57).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("next is not a function"))) -} -v58 := lang.Apply(v57, []any{}) -if lang.IsTruthy(v58) { -v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v60 := v59.FindInternedVar(lang.NewSymbol("cons")) -if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) -} -v61 := v60.Get() -v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v63 := v62.FindInternedVar(lang.NewSymbol("apply")) -if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) -} -v64 := v63.Get() -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("struct")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) -} -v67 := v66.Get() -v68 := lang.Apply(v49, nil) -v69 := lang.Apply(v64, []any{v67, v41, v68}) -var v70 lang.FnFunc -v70 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v71 := lang.Apply(v55, nil) -return v71 -}) -v71 := lang.Apply(lang.NewLazySeq, []any{v70}) -v72 := lang.Apply(v61, []any{v69, v71}) -v56 = v72 -} else { -v56 = nil -} -return v56 -}) -v55 := v54 -_ = v55 -} -v55 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5695), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(5697), lang.NewKeyword("end-column"), int(86)) -v56, err := lang.WithMeta(v54, v55.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v53 any = v56 -_ = v53 -v58 := lang.Apply(v53, nil) -return v58 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// reverse -{ -v0 := lang.NewSymbol("reverse").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a seq of the items in coll in reverse order. Not lazy.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(940), lang.NewKeyword("end-line"), int(940))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("reduce1")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("conj")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v6, []any{v9, lang.NewList(), v3}) -return v10 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// reversible? -{ -v0 := lang.NewSymbol("reversible?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements Reversible", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6257), lang.NewKeyword("end-line"), int(6257))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{glojure.lang4.Reversible, v3}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// root-directory -{ -v0 := lang.NewSymbol("root-directory").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"))), lang.NewKeyword("doc"), "Returns the root resource path for a lib", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5871), lang.NewKeyword("end-line"), int(5871), lang.NewKeyword("private"), true)).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("root-resource")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -var v4 any = v8 -_ = v4 -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("subs")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(strings11.LastIndex, []any{v4, "/"}) -v14 := lang.Apply(v12, []any{v4, int64(0), v13}) -return v14 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// root-resource -{ -v1 := reflect.TypeOf("") -v0 := lang.NewSymbol("root-resource").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"))), lang.NewKeyword("doc"), "Returns the root directory path for a lib", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5864), lang.NewKeyword("end-line"), int(5864), lang.NewKeyword("private"), true)).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("str")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("name")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v4}) -v12 := lang.Apply(strings11.ReplaceAll, []any{v11, "-", "_"}) -v13 := lang.Apply(strings11.ReplaceAll, []any{v12, ".", "/"}) -v14 := lang.Apply(v7, []any{lang.NewChar(47), v13}) -return v14 -}) -v4 := reflect.TypeOf("") -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// rseq -{ -v0 := lang.NewSymbol("rseq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rev"))), lang.NewKeyword("doc"), "Returns, in constant time, a seq of the items in rev (which\n can be a vector or sorted-map), in reverse order. If rev is empty returns nil", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1577), lang.NewKeyword("end-line"), int(1577))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, _ := lang.FieldOrMethod(v3, "rseq") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("rseq is not a function"))) -} -v5 := lang.Apply(v4, []any{}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// rsubseq -{ -v0 := lang.NewSymbol("rsubseq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sc"), lang.NewSymbol("test"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("sc"), lang.NewSymbol("start-test"), lang.NewSymbol("start-key"), lang.NewSymbol("end-test"), lang.NewSymbol("end-key"))), lang.NewKeyword("doc"), "sc must be a sorted collection, test(s) one of <, <=, > or\n >=. Returns a reverse seq of those entries with keys ek for\n which (test (.. sc comparator (compare ek key)) 0) is true", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5150), lang.NewKeyword("end-line"), int(5150))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("mk-bound-fn")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v3, v4, v5}) -var v6 any = v10 -_ = v6 -var v12 any -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("<")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("<=")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.CreatePersistentTreeSet(v15, v18) -v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5158), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5158), lang.NewKeyword("end-column"), int(17)) -v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v22 := lang.Apply(v21, []any{v4}) -if lang.IsTruthy(v22) { -v24, _ := lang.FieldOrMethod(v3, "seqFrom") -if reflect.TypeOf(v24).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("seqFrom is not a function"))) -} -v25 := lang.Apply(v24, []any{v5, false}) -var v23 any = v25 -_ = v23 -var v27 any -if lang.IsTruthy(v23) { -var v28 any = v23 -_ = v28 -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("nth")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.Apply(v32, []any{v28, int64(0), nil}) -var v29 any = v33 -_ = v29 -var v34 any = v28 -_ = v34 -var v36 any -v37 := lang.Apply(v6, []any{v29}) -if lang.IsTruthy(v37) { -v36 = v34 -} else { -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("next")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.Apply(v40, []any{v34}) -v36 = v41 -} -v27 = v36 -} else { -v27 = nil -} -v12 = v27 -} else { -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("take-while")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26, _ := lang.FieldOrMethod(v3, "seq") -if reflect.TypeOf(v26).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("seq is not a function"))) -} -v27 := lang.Apply(v26, []any{false}) -v28 := lang.Apply(v25, []any{v6, v27}) -v12 = v28 -} -return v12 - case 5: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := args[4] -v9, _ := lang.FieldOrMethod(v3, "seqFrom") -if reflect.TypeOf(v9).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("seqFrom is not a function"))) -} -v10 := lang.Apply(v9, []any{v7, false}) -var v8 any = v10 -_ = v8 -var v12 any -if lang.IsTruthy(v8) { -var v13 any = v8 -_ = v13 -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("nth")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v13, int64(0), nil}) -var v14 any = v18 -_ = v14 -var v19 any = v13 -_ = v19 -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("take-while")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("mk-bound-fn")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v3, v4, v5}) -var v28 any -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("mk-bound-fn")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.Apply(v31, []any{v3, v6, v7}) -v33 := lang.Apply(v32, []any{v14}) -if lang.IsTruthy(v33) { -v28 = v19 -} else { -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("next")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.Apply(v36, []any{v19}) -v28 = v37 -} -v38 := lang.Apply(v23, []any{v27, v28}) -v12 = v38 -} else { -v12 = nil -} -return v12 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// run! -{ -v0 := lang.NewSymbol("run!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("proc"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Runs the supplied procedure (via reduce), for purposes of side\n effects, on successive items in the collection. Returns nil", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7708), lang.NewKeyword("end-line"), int(7708))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("reduce")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -var v8 lang.FnFunc -v8 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v9 := args[0] -v10 := args[1] -v11 := lang.Apply(v3, []any{v10}) -return v11 -}) -v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7713), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(7713), lang.NewKeyword("end-column"), int(20)) -v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v11 := lang.Apply(v7, []any{v10, nil, v4}) -_ = v11 -return nil -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// second -{ -v0 := lang.NewSymbol("second").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Same as (first (next x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(91), lang.NewKeyword("end-line"), int(95))).(*lang.Symbol) -var v2 lang.FnFunc -{ // function second -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("first")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("next")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v4}) -v12 := lang.Apply(v7, []any{v11}) -return v12 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(95), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(95), lang.NewKeyword("end-column"), int(49))).(lang.FnFunc) -v3 := v2 -_ = v3 -} -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// select-keys -{ -v0 := lang.NewSymbol("select-keys").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("keyseq"))), lang.NewKeyword("doc"), "Returns a map containing only those entries in map whose key is in keys", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1536), lang.NewKeyword("end-line"), int(1536))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v6 := lang.NewMap() -v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1541), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(1541), lang.NewKeyword("end-column"), int(17)) -v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v5 any = v8 -_ = v5 -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("seq")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{v4}) -var v9 any = v13 -_ = v9 -var v14 any -for { -var v15 any -if lang.IsTruthy(v9) { -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("first")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v9}) -v21, _ := lang.FieldOrMethod(runtime5.RT, "Find") -if reflect.TypeOf(v21).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Find is not a function"))) -} -v22 := lang.Apply(v21, []any{v3, v20}) -var v16 any = v22 -_ = v16 -var v25 any -if lang.IsTruthy(v16) { -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("conj")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.Apply(v28, []any{v5, v16}) -v25 = v29 -} else { -v25 = v5 -} -var v24 any = v25 -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("next")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v9}) -var v30 any = v34 -v5 = v24 -v9 = v30 -continue -} else { -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("with-meta")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("meta")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v3}) -v23 := lang.Apply(v18, []any{v5, v22}) -v15 = v23 -} -v14 = v15 - break -} -return v14 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// send -{ -v0 := lang.NewSymbol("send").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Dispatch an action to an agent. Returns the agent immediately.\n Subsequently, in a thread from a thread pool, the state of the agent\n will be set to the value of:\n\n (apply action-fn state-of-agent args)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2109), lang.NewKeyword("end-line"), int(2109))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("apply")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("send-via")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v8, []any{v11, nil, v3, v4, v5}) -return v12 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// send-off -{ -v0 := lang.NewSymbol("send-off").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Dispatch a potentially blocking action to an agent. Returns the\n agent immediately. Subsequently, in a separate thread, the state of\n the agent will be set to the value of:\n\n (apply action-fn state-of-agent args)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2120), lang.NewKeyword("end-line"), int(2120))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("apply")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("send-via")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v8, []any{v11, nil, v3, v4, v5}) -return v12 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// send-via -{ -v0 := lang.NewSymbol("send-via").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("executor"), lang.NewSymbol("a"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Dispatch an action to an agent. Returns the agent immediately.\n Subsequently, in a thread supplied by executor, the state of the agent\n will be set to the value of:\n\n (apply action-fn state-of-agent args)", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2099), lang.NewKeyword("end-line"), int(2099))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("push-thread-bindings")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("hash-map")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*agent*")) -v15 := lang.Apply(v13, []any{v14, v4}) -v16 := lang.Apply(v10, []any{v15}) -_ = v16 -var v17 any -func() { -defer func() { -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v20, nil) -}() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("binding-conveyor-fn")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v5}) -v17 = v25 -}() -v7, _ := lang.FieldOrMethod(v4, "dispatch") -if reflect.TypeOf(v7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("dispatch is not a function"))) -} -v8 := lang.Apply(v7, []any{v17, v6, v3}) -return v8 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// seq -{ -v1 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() -v0 := lang.NewSymbol("seq").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a seq on the collection. If the collection is\n empty, returns nil. (seq nil) returns nil. seq also works on\n Strings, native Java arrays (of reference types) and any objects\n that implement Iterable. Note that seqs cache values, thus seq\n should not be used on any Iterable whose iterator repeatedly\n returns the same mutable object.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(4), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(126), lang.NewKeyword("end-line"), int(136))).(*lang.Symbol) -var v3 lang.FnFunc -{ // function seq -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := args[0] -v6 := lang.Apply(lang.Seq, []any{v5}) -return v6 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(136), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(136), lang.NewKeyword("end-column"), int(126))).(lang.FnFunc) -v4 := v3 -_ = v4 -} -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// seq-to-map-for-destructuring -{ -v0 := lang.NewSymbol("seq-to-map-for-destructuring").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Builds a map from a seq as described in\n https://glojure.org/reference/special_forms#keyword-arguments", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(34), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4390), lang.NewKeyword("end-line"), int(4390))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("next")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -if lang.IsTruthy(v8) { -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("to-array")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v3}) -v13 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{v12}) -v4 = v13 -} else { -var v14 any -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("seq")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v3}) -if lang.IsTruthy(v18) { -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("first")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v3}) -v14 = v22 -} else { -v14 = nil -} -v4 = v14 -} -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// seq? -{ -v0 := lang.NewSymbol("seq?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x implements ISeq", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(146), lang.NewKeyword("end-line"), int(150))).(*lang.Symbol) -var v2 lang.FnFunc -{ // function seq? -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{lang.ISeq, v4}) -return v8 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(150), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(150), lang.NewKeyword("end-column"), int(87))).(lang.FnFunc) -v3 := v2 -_ = v3 -} -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// seqable? -{ -v0 := lang.NewSymbol("seqable?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if the seq function is supported for x", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6204), lang.NewKeyword("end-line"), int(6204))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.Apply(nil, []any{v3}) -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// seque -{ -v0 := lang.NewSymbol("seque").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s")), lang.NewVector(lang.NewSymbol("n-or-q"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Creates a queued seq on another (presumably lazy) seq s. The queued\n seq will produce a concrete seq in the background, and can get up to\n n items ahead of the consumer. n-or-q can be an integer n buffer\n size, or an instance of java.util.concurrent BlockingQueue. Note\n that reading from a seque can block if the reader gets ahead of the\n producer.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5419), lang.NewKeyword("end-line"), int(5419))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seque")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{int64(100), v3}) -return v7 - case 2: -v3 := args[0] -v4 := args[1] -var v6 any -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("instance?")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{nil, v3}) -if lang.IsTruthy(v10) { -v6 = v3 -} else { -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("int")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v3}) -v15 := lang.Apply(LinkedBlockingQueue22., []any{v14}) -v6 = v15 -} -var v5 any = v6 -_ = v5 -v17 := lang.Apply(reflect.StructOf, []any{nil}) -v18 := lang.Apply(reflect.New, []any{v17}) -v19, ok := lang.FieldOrMethod(v18, "Interface") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v18, "Interface"))) -} -var v20 any -switch reflect.TypeOf(v19).Kind() { -case reflect.Func: - v20 = lang.Apply(v19, nil) -default: - v20 = v19 -} -var v16 any = v20 -_ = v16 -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("agent")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -var v25 lang.FnFunc -v25 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -return v4 -}) -v26 := lang.Apply(lang.NewLazySeq, []any{v25}) -v27 := lang.Apply(v24, []any{v26}) -var v21 any = v27 -_ = v21 -var v29 lang.FnFunc -v29 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v30 := args[0] -v31 := args[1] -var v32 any -v33, _ := lang.FieldOrMethod(v30, "offer") -if reflect.TypeOf(v33).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("offer is not a function"))) -} -v34 := lang.Apply(v33, []any{v30}) -if lang.IsTruthy(v34) { -panic(v31) -} else { -v32 = v31 -} -return v32 -}) -v30 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5435), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(5438), lang.NewKeyword("end-column"), int(26)) -v31, err := lang.WithMeta(v29, v30.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v28 any = v31 -_ = v28 -var v33 lang.FnFunc -v33 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v34 := args[0] -var v35 any -if lang.IsTruthy(v34) { -var v36 any -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("instance?")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.Apply(v39, []any{nil, v34}) -if lang.IsTruthy(v40) { -v41 := lang.Apply(v28, []any{v5, v34}) -v36 = v41 -} else { -var v42 any -func() { -defer func() { -if r := recover(); r != nil { -if lang.CatchMatches(r, lang.Builtins["any"]) { -v43 := r -_ = v43 -v44 := lang.Apply(v28, []any{v5, v43}) -v42 = v44 -} else { -panic(r) -} -} -}() -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("seq")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v34}) -var v43 any = v47 -_ = v43 -var v48 any = v43 -_ = v48 -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("seq")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.Apply(v52, []any{v48}) -var v49 any = v53 -_ = v49 -v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v56 := v55.FindInternedVar(lang.NewSymbol("first")) -if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) -} -v57 := v56.Get() -v58 := lang.Apply(v57, []any{v49}) -var v54 any = v58 -_ = v54 -v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v61 := v60.FindInternedVar(lang.NewSymbol("next")) -if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) -} -v62 := v61.Get() -v63 := lang.Apply(v62, []any{v59}) -var v59 any = v63 -_ = v59 -var v64 any = v54 -_ = v64 -var v65 any = v59 -_ = v65 -var v66 any = v48 -_ = v66 -var v68 any = v68 -_ = v68 -var v69 any -for { -var v70 any = v68 -_ = v70 -v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v73 := v72.FindInternedVar(lang.NewSymbol("seq")) -if v73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) -} -v74 := v73.Get() -v75 := lang.Apply(v74, []any{v70}) -var v71 any = v75 -_ = v71 -v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v78 := v77.FindInternedVar(lang.NewSymbol("first")) -if v78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) -} -v79 := v78.Get() -v80 := lang.Apply(v79, []any{v71}) -var v76 any = v80 -_ = v76 -v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v83 := v82.FindInternedVar(lang.NewSymbol("next")) -if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) -} -v84 := v83.Get() -v85 := lang.Apply(v84, []any{v81}) -var v81 any = v85 -_ = v81 -var v86 any = v76 -_ = v86 -var v87 any = v81 -_ = v87 -var v88 any = v70 -_ = v88 -var v90 any -if lang.IsTruthy(v88) { -var v91 any -var v92 any -v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v94 := v93.FindInternedVar(lang.NewSymbol("nil?")) -if v94.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) -} -v95 := v94.Get() -v96 := lang.Apply(v95, []any{v86}) -if lang.IsTruthy(v96) { -v92 = v16 -} else { -v92 = v86 -} -v97, _ := lang.FieldOrMethod(v5, "offer") -if reflect.TypeOf(v97).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("offer is not a function"))) -} -v98 := lang.Apply(v97, []any{v92}) -if lang.IsTruthy(v98) { -var v99 any = v87 -v68 = v99 -continue -} else { -v91 = v88 -} -v90 = v91 -} else { -var v100 any -v101, _ := lang.FieldOrMethod(v5, "offer") -if reflect.TypeOf(v101).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("offer is not a function"))) -} -v102 := lang.Apply(v101, []any{v5}) -if lang.IsTruthy(v102) { -v100 = nil -} else { -v100 = lang.NewList() -} -v90 = v100 -} -v69 = v90 - break -} -v42 = v69 -}() -v36 = v42 -} -v35 = v36 -} else { -v35 = nil -} -return v35 -}) -v34 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5439), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(5452), lang.NewKeyword("end-column"), int(44)) -v35, err := lang.WithMeta(v33, v34.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v32 any = v35 -_ = v32 -var v37 lang.FnFunc -{ // function drain -v37 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -var v39 lang.FnFunc -v39 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v41, ok := lang.FieldOrMethod(v5, "take") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "take"))) -} -var v42 any -switch reflect.TypeOf(v41).Kind() { -case reflect.Func: - v42 = lang.Apply(v41, nil) -default: - v42 = v41 -} -var v40 any = v42 -_ = v40 -var v44 any -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("identical?")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.Apply(v47, []any{v40, v5}) -if lang.IsTruthy(v48) { -v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v50 := v49.FindInternedVar(lang.NewSymbol("deref")) -if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) -} -v51 := v50.Get() -v52 := lang.Apply(v51, []any{v21}) -_ = v52 -v44 = nil -} else { -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("send-off")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) -} -v55 := v54.Get() -v56 := lang.Apply(v55, []any{v21, v32}) -_ = v56 -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("release-pending-sends")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) -} -v59 := v58.Get() -v60 := lang.Apply(v59, nil) -_ = v60 -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("cons")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) -} -v63 := v62.Get() -var v64 any -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("identical?")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) -} -v67 := v66.Get() -v68 := lang.Apply(v67, []any{v40, v16}) -if lang.IsTruthy(v68) { -v64 = nil -} else { -v64 = v40 -} -v69 := lang.Apply(v38, nil) -v70 := lang.Apply(v63, []any{v64, v69}) -v44 = v70 -} -return v44 -}) -v40 := lang.Apply(lang.NewLazySeq, []any{v39}) -return v40 -}) -v38 := v37 -_ = v38 -} -v38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5453), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(5461), lang.NewKeyword("end-column"), int(73)) -v39, err := lang.WithMeta(v37, v38.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v36 any = v39 -_ = v36 -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("send-off")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v21, v32}) -_ = v44 -v45 := lang.Apply(v36, nil) -return v45 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// sequence -{ -v0 := lang.NewSymbol("sequence").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("coll"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Coerces coll to a (possibly empty) sequence, if it is not already\n one. Will not force a lazy seq. (sequence nil) yields (), When a\n transducer is supplied, returns a lazy sequence of applications of\n the transform to the items in coll(s), i.e. to the set of first\n items of each coll, followed by the set of second\n items in each coll, until any one of the colls is exhausted. Any\n remaining items in other colls are ignored. The transform should accept\n number-of-colls arguments", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2639), lang.NewKeyword("end-line"), int(2639))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -if lang.IsTruthy(v8) { -v4 = v3 -} else { -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("seq")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{v3}) -var v9 any = v13 -_ = v9 -var v15 any -if lang.IsTruthy(v9) { -v15 = v9 -} else { -v15 = lang.NewList() -} -v4 = v15 -} -return v4 - case 2: -v3 := args[0] -v4 := args[1] -v6 := lang.Apply(nil, []any{v4}) -v7 := lang.Apply(nil, []any{v3, v6}) -v8 := lang.Apply(nil, []any{v7}) -var v5 any = v8 -_ = v5 -var v10 any -if lang.IsTruthy(v5) { -v10 = v5 -} else { -v10 = lang.NewList() -} -return v10 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("map")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -var v10 lang.FnFunc -v10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v11 := args[0] -v12 := lang.Apply(nil, []any{v11}) -return v12 -}) -v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2661), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(2661), lang.NewKeyword("end-column"), int(41)) -v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("cons")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v4, v5}) -v17 := lang.Apply(v9, []any{v12, v16}) -v18 := lang.Apply(nil, []any{v3, v17}) -v19 := lang.Apply(nil, []any{v18}) -var v6 any = v19 -_ = v6 -var v21 any -if lang.IsTruthy(v6) { -v21 = v6 -} else { -v21 = lang.NewList() -} -return v21 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// sequential? -{ -v0 := lang.NewSymbol("sequential?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements Sequential", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6229), lang.NewKeyword("end-line"), int(6229))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{lang.Sequential, v3}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// serialized-require -{ -v0 := lang.NewSymbol("serialized-require").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Like 'require', but serializes loading.\n Interim function preferred over 'require' for known asynchronous loads.\n Future changes may make these equivalent.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6059), lang.NewKeyword("end-line"), int(6059), lang.NewKeyword("private"), true)).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewList(args[0:]...) -var v4 any = nil -_ = v4 -var v6 any -func() { -var v7 any = v4 -_ = v7 -v9 := lang.Apply(nil, []any{v7}) -_ = v9 -var v10 any -func() { -defer func() { -v11 := lang.Apply(nil, []any{v7}) -}() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("apply")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("require")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v14, []any{v17, v3}) -v10 = v18 -}() -v6 = v10 -}() -return v6 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// set -{ -v0 := lang.NewSymbol("set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a set of the distinct elements of coll.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4104), lang.NewKeyword("end-line"), int(4104))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("set?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -if lang.IsTruthy(v8) { -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("with-meta")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v3, nil}) -v4 = v12 -} else { -var v13 any -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("instance?")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.IReduceInit, v3}) -if lang.IsTruthy(v17) { -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("persistent!")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("conj!")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("transient")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.CreatePersistentTreeSet() -v28 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4112), lang.NewKeyword("column"), int(108), lang.NewKeyword("end-line"), int(4112), lang.NewKeyword("end-column"), int(110)) -v29, err := lang.WithMeta(v27, v28.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v30 := lang.Apply(v26, []any{v29}) -v31, _ := lang.FieldOrMethod(v3, "ReduceInit") -if reflect.TypeOf(v31).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) -} -v32 := lang.Apply(v31, []any{v23, v30}) -v33 := lang.Apply(v20, []any{v32}) -v13 = v33 -} else { -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("persistent!")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("reduce1")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("conj!")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("transient")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.CreatePersistentTreeSet() -v47 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4113), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(4113), lang.NewKeyword("end-column"), int(48)) -v48, err := lang.WithMeta(v46, v47.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v49 := lang.Apply(v45, []any{v48}) -v50 := lang.Apply(v39, []any{v42, v49, v3}) -v51 := lang.Apply(v36, []any{v50}) -v13 = v51 -} -v4 = v13 -} -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// set-agent-send-executor! -{ -v0 := lang.NewSymbol("set-agent-send-executor!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("executor"))), lang.NewKeyword("doc"), "Sets the ExecutorService to be used by send", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(30), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2087), lang.NewKeyword("end-line"), int(2087))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -return nil -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// set-agent-send-off-executor! -{ -v0 := lang.NewSymbol("set-agent-send-off-executor!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("executor"))), lang.NewKeyword("doc"), "Sets the ExecutorService to be used by send-off", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(34), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2093), lang.NewKeyword("end-line"), int(2093))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -return nil -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// set-error-handler! -{ -v0 := lang.NewSymbol("set-error-handler!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("handler-fn"))), lang.NewKeyword("doc"), "Sets the error-handler of agent a to handler-fn. If an action\n being run by the agent throws an exception or doesn't pass the\n validator fn, handler-fn will be called with two arguments: the\n agent and the exception.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2192), lang.NewKeyword("end-line"), int(2192))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5, _ := lang.FieldOrMethod(v3, "setErrorHandler") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorHandler is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// set-error-mode! -{ -v0 := lang.NewSymbol("set-error-mode!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("mode-keyword"))), lang.NewKeyword("doc"), "Sets the error-mode of agent a to mode-keyword, which must be\n either :fail or :continue. If an action being run by the agent\n throws an exception or doesn't pass the validator fn, an\n error-handler may be called (see set-error-handler!), after which,\n if the mode is :continue, the agent will continue as if neither the\n action that caused the error nor the error itself ever happened.\n \n If the mode is :fail, the agent will become failed and will stop\n accepting new 'send' and 'send-off' actions, and any previously\n queued actions will be held until a 'restart-agent'. Deref will\n still work, returning the state of the agent before the error.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2210), lang.NewKeyword("end-line"), int(2210))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5, _ := lang.FieldOrMethod(v3, "setErrorMode") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorMode is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// set-validator! -{ -v0 := lang.NewSymbol("set-validator!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("iref"), lang.NewSymbol("validator-fn"))), lang.NewKeyword("doc"), "Sets the validator-fn for a var/ref/agent/atom. validator-fn must be nil or a\n side-effect-free fn of one argument, which will be passed the intended\n new state on any state change. If the new state is unacceptable, the\n validator-fn should return false or throw an exception. If the current state (root\n value if var) is not acceptable to the new validator, an exception\n will be thrown and the validator will not be changed.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2381), lang.NewKeyword("end-line"), int(2381))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5, _ := lang.FieldOrMethod(v3, "setValidator") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setValidator is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// set? -{ -v0 := lang.NewSymbol("set?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements IPersistentSet", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4098), lang.NewKeyword("end-line"), int(4098))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{lang.IPersistentSet, v3}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// setup-reference -{ -v0 := lang.NewSymbol("setup-reference").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2043), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(2044), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("r"), lang.NewSymbol("options"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("apply")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("hash-map")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v8, []any{v11, v4}) -var v5 any = v12 -_ = v5 -var v14 any -v15 := lang.Apply(lang.NewKeyword("meta"), []any{v5}) -if lang.IsTruthy(v15) { -v16 := lang.Apply(lang.NewKeyword("meta"), []any{v5}) -v17, _ := lang.FieldOrMethod(v3, "ResetMeta") -if reflect.TypeOf(v17).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ResetMeta is not a function"))) -} -v18 := lang.Apply(v17, []any{v16}) -v14 = v18 -} else { -v14 = nil -} -_ = v14 -var v19 any -v20 := lang.Apply(lang.NewKeyword("validator"), []any{v5}) -if lang.IsTruthy(v20) { -v21 := lang.Apply(lang.NewKeyword("validator"), []any{v5}) -v22, _ := lang.FieldOrMethod(v3, "setValidator") -if reflect.TypeOf(v22).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setValidator is not a function"))) -} -v23 := lang.Apply(v22, []any{v21}) -v19 = v23 -} else { -v19 = nil -} -_ = v19 -return v3 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// shift-mask -{ -v0 := lang.NewSymbol("shift-mask").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6598), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(6598), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("shift"), lang.NewSymbol("mask"), lang.NewSymbol("x"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("bit-and")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("bit-shift-right")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v5, v3}) -v13 := lang.Apply(v8, []any{v12, v4}) -return v13 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// short -{ -var v1 lang.FnFunc -{ // function short__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -var v30 any -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -if lang.IsTruthy(v33) { -v30 = lang.NewSymbol("uncheckedShortCast") -} else { -v30 = lang.NewSymbol("shortCast") -} -v34 := lang.Apply(v29, []any{v30}) -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("list")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v3}) -v39 := lang.Apply(v26, []any{v34, v38}) -v40 := lang.Apply(v23, []any{v39}) -v41 := lang.Apply(v20, []any{v40}) -v42 := lang.Apply(v9, []any{v13, v17, v41}) -v43 := lang.Apply(v6, []any{v42}) -return v43 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("short").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to short", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3499), lang.NewKeyword("end-line"), int(3499))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := lang.Apply(lang.ShortCast, []any{v4}) -return v5 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// short-array -{ -var v1 lang.FnFunc -{ // function short-array__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewList(args[0:]...) -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/shortArray")}) -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("list")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("seq")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("concat")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("list")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.Apply(v37, []any{lang.NewSymbol("glojure.core/args")}) -v39 := lang.Apply(v30, []any{v34, v38}) -v40 := lang.Apply(v27, []any{v39}) -v41 := lang.Apply(v24, []any{v40}) -v42 := lang.Apply(v9, []any{v13, v17, v21, v41}) -v43 := lang.Apply(v6, []any{v42}) -return v43 - } -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("short-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Creates an array of shorts", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)int64(2)), lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5333), lang.NewKeyword("end-line"), int(5333))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v4 := args[0] -v5, _ := lang.FieldOrMethod(lang.Numbers, "shortArray") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("shortArray is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 - case 2: -v4 := args[0] -v5 := args[1] -v6, _ := lang.FieldOrMethod(lang.Numbers, "shortArrayInit") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("shortArrayInit is not a function"))) -} -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// shorts -{ -var v1 lang.FnFunc -{ // function shorts -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/shorts")}) -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("list")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v26 := lang.Apply(v9, []any{v13, v17, v21, v25}) -v27 := lang.Apply(v6, []any{v26}) -return v27 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("shorts").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Casts to shorts[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5387), lang.NewKeyword("end-line"), int(5387))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5, _ := lang.FieldOrMethod(lang.Numbers, "shorts") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("shorts is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// shuffle -{ -v0 := lang.NewSymbol("shuffle").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return a random permutation of coll", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7300), lang.NewKeyword("end-line"), int(7300))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("to-array")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -v9 := lang.Apply(lang.NewArrayList, []any{v8}) -var v4 any = v9 -_ = v4 -v11 := lang.Apply(nil, []any{v4}) -_ = v11 -v12, ok := lang.FieldOrMethod(v4, "toArray") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "toArray"))) -} -var v13 any -switch reflect.TypeOf(v12).Kind() { -case reflect.Func: - v13 = lang.Apply(v12, nil) -default: - v13 = v12 -} -v14 := lang.Apply(nil, []any{v13}) -return v14 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// shutdown-agents -{ -v0 := lang.NewSymbol("shutdown-agents").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Initiates a shutdown of the thread pools that back the agent\n system. Running actions will complete, but no new actions will be\n accepted", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2252), lang.NewKeyword("end-line"), int(2252))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.Apply(lang.ShutdownAgents, nil) -return v3 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// sigs -{ -v0 := lang.NewSymbol("sigs").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(223), lang.NewKeyword("column"), int(2), lang.NewKeyword("end-line"), int(224), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("assert-valid-fdecl")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{v3}) -_ = v7 -var v9 lang.FnFunc -v9 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v10 := args[0] -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("first")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v10}) -var v11 any = v15 -_ = v11 -var v17 any -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("first")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v20, []any{v16}) -v22 := lang.Apply(lang.Equals, []any{lang.NewSymbol("&form"), v21}) -if lang.IsTruthy(v22) { -v23 := lang.Apply(lang.Count, []any{v16}) -v24 := lang.Apply(lang.Subvec, []any{v16, int64(2), v23}) -v17 = v24 -} else { -v17 = v16 -} -var v16 any = v17 -_ = v16 -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("next")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.Apply(v28, []any{v10}) -var v25 any = v29 -_ = v25 -var v31 any -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("map?")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("first")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v25}) -v39 := lang.Apply(v34, []any{v38}) -if lang.IsTruthy(v39) { -var v40 any -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("next")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v25}) -if lang.IsTruthy(v44) { -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("with-meta")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("conj")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -var v51 any -v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("meta")) -if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) -} -v54 := v53.Get() -v55 := lang.Apply(v54, []any{v16}) -if lang.IsTruthy(v55) { -v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v57 := v56.FindInternedVar(lang.NewSymbol("meta")) -if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) -} -v58 := v57.Get() -v59 := lang.Apply(v58, []any{v16}) -v51 = v59 -} else { -v60 := lang.NewMap() -v61 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(237), lang.NewKeyword("column"), int(77), lang.NewKeyword("end-line"), int(237), lang.NewKeyword("end-column"), int(78)) -v62, err := lang.WithMeta(v60, v61.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v51 = v62 -} -v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v64 := v63.FindInternedVar(lang.NewSymbol("first")) -if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) -} -v65 := v64.Get() -v66 := lang.Apply(v65, []any{v25}) -v67 := lang.Apply(v50, []any{v51, v66}) -v68 := lang.Apply(v47, []any{v16, v67}) -v40 = v68 -} else { -v40 = v16 -} -v31 = v40 -} else { -v31 = v16 -} -return v31 -}) -v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(228), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(239), lang.NewKeyword("end-column"), int(25)) -v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v8 any = v11 -_ = v8 -var v13 lang.FnFunc -v13 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v14 := args[0] -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("meta")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v14}) -var v15 any = v19 -_ = v15 -v21 := lang.Apply(lang.NewKeyword("tag"), []any{v15}) -var v20 any = v21 -_ = v20 -var v23 any -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("instance?")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v26, []any{lang.*Symbol, v20}) -if lang.IsTruthy(v27) { -var v28 any -v29, ok := lang.FieldOrMethod(v20, "Name") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v20, "Name"))) -} -var v30 any -switch reflect.TypeOf(v29).Kind() { -case reflect.Func: - v30 = lang.Apply(v29, nil) -default: - v30 = v29 -} -v31 := lang.Apply(strings11.Index, []any{v30, "."}) -v32 := lang.Apply(lang.Equiv, []any{v31, int64(-1)}) -if lang.IsTruthy(v32) { -var v33 any -v34 := lang.Apply(lang.Equals, []any{nil, nil}) -if lang.IsTruthy(v34) { -var v35 any = nil -_ = v35 -var v37 any -if lang.IsTruthy(v35) { -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("with-meta")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("assoc")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44, ok := lang.FieldOrMethod(v35, "Name") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v35, "Name"))) -} -var v45 any -switch reflect.TypeOf(v44).Kind() { -case reflect.Func: - v45 = lang.Apply(v44, nil) -default: - v45 = v44 -} -v46 := lang.Apply(lang.NewSymbol, []any{v45}) -v47 := lang.Apply(v43, []any{v15, lang.NewKeyword("tag"), v46}) -v48 := lang.Apply(v40, []any{v14, v47}) -v37 = v48 -} else { -v37 = v14 -} -v33 = v37 -} else { -v33 = v14 -} -v28 = v33 -} else { -v28 = v14 -} -v23 = v28 -} else { -v23 = v14 -} -return v23 -}) -v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(240), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(252), lang.NewKeyword("end-column"), int(37)) -v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v12 any = v15 -_ = v12 -var v17 any -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("seq?")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("first")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v3}) -v25 := lang.Apply(v20, []any{v24}) -if lang.IsTruthy(v25) { -v27 := lang.NewVector() -v28 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(254), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(254), lang.NewKeyword("end-column"), int(20)) -v29, err := lang.WithMeta(v27, v28.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v26 any = v29 -_ = v26 -var v30 any = v3 -_ = v30 -var v31 any -for { -var v32 any -if lang.IsTruthy(v30) { -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("conj")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("first")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v30}) -v41 := lang.Apply(v8, []any{v40}) -v42 := lang.Apply(v12, []any{v41}) -v43 := lang.Apply(v36, []any{v26, v42}) -var v33 any = v43 -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("next")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.Apply(v47, []any{v30}) -var v44 any = v48 -v26 = v33 -v30 = v44 -continue -} else { -v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v50 := v49.FindInternedVar(lang.NewSymbol("seq")) -if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) -} -v51 := v50.Get() -v52 := lang.Apply(v51, []any{v26}) -v32 = v52 -} -v31 = v32 - break -} -v17 = v31 -} else { -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("list")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.Apply(v8, []any{v3}) -v30 := lang.Apply(v12, []any{v29}) -v31 := lang.Apply(v28, []any{v30}) -v17 = v31 -} -return v17 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(225), lang.NewKeyword("column"), int(2), lang.NewKeyword("end-line"), int(258), lang.NewKeyword("end-column"), int(43))).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// simple-ident? -{ -v0 := lang.NewSymbol("simple-ident?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a symbol or keyword without a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1613), lang.NewKeyword("end-line"), int(1613))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("ident?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -var v4 any = v8 -_ = v4 -var v10 any -if lang.IsTruthy(v4) { -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("nil?")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("namespace")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v3}) -v18 := lang.Apply(v13, []any{v17}) -v10 = v18 -} else { -v10 = v4 -} -return v10 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// simple-keyword? -{ -v0 := lang.NewSymbol("simple-keyword?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a keyword without a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1633), lang.NewKeyword("end-line"), int(1633))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("keyword?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -var v4 any = v8 -_ = v4 -var v10 any -if lang.IsTruthy(v4) { -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("nil?")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("namespace")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v3}) -v18 := lang.Apply(v13, []any{v17}) -v10 = v18 -} else { -v10 = v4 -} -return v10 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// simple-symbol? -{ -v0 := lang.NewSymbol("simple-symbol?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a symbol without a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1623), lang.NewKeyword("end-line"), int(1623))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("symbol?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -var v4 any = v8 -_ = v4 -var v10 any -if lang.IsTruthy(v4) { -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("nil?")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("namespace")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v3}) -v18 := lang.Apply(v13, []any{v17}) -v10 = v18 -} else { -v10 = v4 -} -return v10 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// slurp -{ -v1 := reflect.TypeOf("") -v0 := lang.NewSymbol("slurp").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("opts"))), lang.NewKeyword("doc"), "Opens a reader on f and reads all its contents, returning a string.\n See glojure.java.io/reader for a complete list of supported arguments.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6982), lang.NewKeyword("end-line"), int(6982))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := lang.NewList(args[1:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("normalize-slurp-opts")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v6}) -var v6 any = v10 -_ = v6 -var v11 any = "unimplemented: new with non-constant class type" -_ = v11 -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("apply")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.FindNamespace(lang.NewSymbol("glojure.go.io")) -v18 := v17.FindInternedVar(lang.NewSymbol("reader")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v16, []any{v19, v4, v6}) -var v13 any = v20 -_ = v13 -var v22 any -func() { -defer func() { -v23, ok := lang.FieldOrMethod(v13, "close") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v13, "close"))) -} -var v24 any -switch reflect.TypeOf(v23).Kind() { -case reflect.Func: - v24 = lang.Apply(v23, nil) -default: - v24 = v23 -} -}() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.go.io")) -v26 := v25.FindInternedVar(lang.NewSymbol("copy")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.Apply(v27, []any{v13, v11}) -_ = v28 -v29 := lang.Apply(lang.ToString, []any{v11}) -v22 = v29 -}() -return v22 - } -}) -v4 := reflect.TypeOf("") -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// some -{ -v0 := lang.NewSymbol("some").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns the first logical true value of (pred x) for any x in coll,\n else nil. One common idiom is to use a set as pred, for example\n this will return :fred if :fred is in the sequence, otherwise nil:\n (some #{:fred} coll)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2684), lang.NewKeyword("end-line"), int(2684))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -recur_loop_481: -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("seq")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v4}) -var v5 any = v9 -_ = v5 -var v11 any -if lang.IsTruthy(v5) { -var v12 any = v5 -_ = v12 -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("first")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v12}) -v19 := lang.Apply(v3, []any{v18}) -var v14 any = v19 -_ = v14 -var v21 any -if lang.IsTruthy(v14) { -v21 = v14 -} else { -var v22 any = v3 -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("next")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v12}) -var v23 any = v27 -v3 = v22 -v4 = v23 -goto recur_loop_481 -} -v11 = v21 -} else { -v11 = nil -} -return v11 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// some-> -{ -v0 := lang.NewSymbol("some->").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "When expr is not nil, threads it into the first form (via ->),\n and when that result is not nil, through the next etc", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7610), lang.NewKeyword("end-line"), int(7610))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("gensym")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, nil) -var v7 any = v11 -_ = v7 -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("map")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -var v16 lang.FnFunc -v16 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v17 := args[0] -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("seq")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("concat")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("list")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v26, []any{lang.NewSymbol("if")}) -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("list")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("seq")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("concat")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("list")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.Apply(v39, []any{lang.NewSymbol("glojure.core/nil?")}) -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("list")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v7}) -v45 := lang.Apply(v36, []any{v40, v44}) -v46 := lang.Apply(v33, []any{v45}) -v47 := lang.Apply(v30, []any{v46}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{nil}) -v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("list")) -if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) -} -v54 := v53.Get() -v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v56 := v55.FindInternedVar(lang.NewSymbol("seq")) -if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) -} -v57 := v56.Get() -v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v59 := v58.FindInternedVar(lang.NewSymbol("concat")) -if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) -} -v60 := v59.Get() -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("list")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) -} -v63 := v62.Get() -v64 := lang.Apply(v63, []any{lang.NewSymbol("glojure.core/->")}) -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("list")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) -} -v67 := v66.Get() -v68 := lang.Apply(v67, []any{v7}) -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("list")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) -} -v71 := v70.Get() -v72 := lang.Apply(v71, []any{v17}) -v73 := lang.Apply(v60, []any{v64, v68, v72}) -v74 := lang.Apply(v57, []any{v73}) -v75 := lang.Apply(v54, []any{v74}) -v76 := lang.Apply(v23, []any{v27, v47, v51, v75}) -v77 := lang.Apply(v20, []any{v76}) -return v77 -}) -v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7616), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7616), lang.NewKeyword("end-column"), int(64)) -v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v19 := lang.Apply(v15, []any{v18, v6}) -var v12 any = v19 -_ = v12 -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/let")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("apply")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("vector")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("seq")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("concat")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("list")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) -} -v48 := v47.Get() -v49 := lang.Apply(v48, []any{v7}) -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("list")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.Apply(v52, []any{v5}) -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("interleave")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) -} -v56 := v55.Get() -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("repeat")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) -} -v59 := v58.Get() -v60 := lang.Apply(v59, []any{v7}) -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("butlast")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) -} -v63 := v62.Get() -v64 := lang.Apply(v63, []any{v12}) -v65 := lang.Apply(v56, []any{v60, v64}) -v66 := lang.Apply(v45, []any{v49, v53, v65}) -v67 := lang.Apply(v42, []any{v66}) -v68 := lang.Apply(v36, []any{v39, v67}) -v69 := lang.Apply(v33, []any{v68}) -v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v71 := v70.FindInternedVar(lang.NewSymbol("list")) -if v71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) -} -v72 := v71.Get() -var v73 any -v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v75 := v74.FindInternedVar(lang.NewSymbol("empty?")) -if v75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) -} -v76 := v75.Get() -v77 := lang.Apply(v76, []any{v12}) -if lang.IsTruthy(v77) { -v73 = v7 -} else { -v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v79 := v78.FindInternedVar(lang.NewSymbol("last")) -if v79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) -} -v80 := v79.Get() -v81 := lang.Apply(v80, []any{v12}) -v73 = v81 -} -v82 := lang.Apply(v72, []any{v73}) -v83 := lang.Apply(v26, []any{v30, v69, v82}) -v84 := lang.Apply(v23, []any{v83}) -return v84 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// some->> -{ -v0 := lang.NewSymbol("some->>").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "When expr is not nil, threads it into the first form (via ->>),\n and when that result is not nil, through the next etc", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7624), lang.NewKeyword("end-line"), int(7624))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("gensym")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, nil) -var v7 any = v11 -_ = v7 -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("map")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -var v16 lang.FnFunc -v16 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v17 := args[0] -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("seq")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("concat")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("list")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v26, []any{lang.NewSymbol("if")}) -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("list")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("seq")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("concat")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("list")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.Apply(v39, []any{lang.NewSymbol("glojure.core/nil?")}) -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("list")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v7}) -v45 := lang.Apply(v36, []any{v40, v44}) -v46 := lang.Apply(v33, []any{v45}) -v47 := lang.Apply(v30, []any{v46}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{nil}) -v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("list")) -if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) -} -v54 := v53.Get() -v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v56 := v55.FindInternedVar(lang.NewSymbol("seq")) -if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) -} -v57 := v56.Get() -v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v59 := v58.FindInternedVar(lang.NewSymbol("concat")) -if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) -} -v60 := v59.Get() -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("list")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) -} -v63 := v62.Get() -v64 := lang.Apply(v63, []any{lang.NewSymbol("glojure.core/->>")}) -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("list")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) -} -v67 := v66.Get() -v68 := lang.Apply(v67, []any{v7}) -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("list")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) -} -v71 := v70.Get() -v72 := lang.Apply(v71, []any{v17}) -v73 := lang.Apply(v60, []any{v64, v68, v72}) -v74 := lang.Apply(v57, []any{v73}) -v75 := lang.Apply(v54, []any{v74}) -v76 := lang.Apply(v23, []any{v27, v47, v51, v75}) -v77 := lang.Apply(v20, []any{v76}) -return v77 -}) -v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7630), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7630), lang.NewKeyword("end-column"), int(65)) -v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v19 := lang.Apply(v15, []any{v18, v6}) -var v12 any = v19 -_ = v12 -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/let")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("apply")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("vector")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("seq")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("concat")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("list")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) -} -v48 := v47.Get() -v49 := lang.Apply(v48, []any{v7}) -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("list")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.Apply(v52, []any{v5}) -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("interleave")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) -} -v56 := v55.Get() -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("repeat")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) -} -v59 := v58.Get() -v60 := lang.Apply(v59, []any{v7}) -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("butlast")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) -} -v63 := v62.Get() -v64 := lang.Apply(v63, []any{v12}) -v65 := lang.Apply(v56, []any{v60, v64}) -v66 := lang.Apply(v45, []any{v49, v53, v65}) -v67 := lang.Apply(v42, []any{v66}) -v68 := lang.Apply(v36, []any{v39, v67}) -v69 := lang.Apply(v33, []any{v68}) -v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v71 := v70.FindInternedVar(lang.NewSymbol("list")) -if v71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) -} -v72 := v71.Get() -var v73 any -v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v75 := v74.FindInternedVar(lang.NewSymbol("empty?")) -if v75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) -} -v76 := v75.Get() -v77 := lang.Apply(v76, []any{v12}) -if lang.IsTruthy(v77) { -v73 = v7 -} else { -v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v79 := v78.FindInternedVar(lang.NewSymbol("last")) -if v79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) -} -v80 := v79.Get() -v81 := lang.Apply(v80, []any{v12}) -v73 = v81 -} -v82 := lang.Apply(v72, []any{v73}) -v83 := lang.Apply(v26, []any{v30, v69, v82}) -v84 := lang.Apply(v23, []any{v83}) -return v84 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// some-fn -{ -v0 := lang.NewSymbol("some-fn").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("p")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2"), lang.NewSymbol("p3")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2"), lang.NewSymbol("p3"), lang.NewSymbol("&"), lang.NewSymbol("ps"))), lang.NewKeyword("doc"), "Takes a set of predicates and returns a function f that returns the first logical true value\n returned by one of its composing predicates against any of its arguments, else it returns\n logical false. Note that f is short-circuiting in that it will stop execution on the first\n argument that triggers a logical true result against the original predicates.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7462), lang.NewKeyword("end-line"), int(7462))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -var v4 lang.FnFunc -{ // function sp1 -v4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -return nil - case 1: -v6 := args[0] -v7 := lang.Apply(v3, []any{v6}) -return v7 - case 2: -v6 := args[0] -v7 := args[1] -v9 := lang.Apply(v3, []any{v6}) -var v8 any = v9 -_ = v8 -var v11 any -if lang.IsTruthy(v8) { -v11 = v8 -} else { -v12 := lang.Apply(v3, []any{v7}) -v11 = v12 -} -return v11 - case 3: -v6 := args[0] -v7 := args[1] -v8 := args[2] -v10 := lang.Apply(v3, []any{v6}) -var v9 any = v10 -_ = v9 -var v12 any -if lang.IsTruthy(v9) { -v12 = v9 -} else { -v14 := lang.Apply(v3, []any{v7}) -var v13 any = v14 -_ = v13 -var v16 any -if lang.IsTruthy(v13) { -v16 = v13 -} else { -v17 := lang.Apply(v3, []any{v8}) -v16 = v17 -} -v12 = v16 -} -return v12 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v6 := args[0] -v7 := args[1] -v8 := args[2] -v9 := lang.NewList(args[3:]...) -v11 := lang.Apply(v5, []any{v6, v7, v8}) -var v10 any = v11 -_ = v10 -var v13 any -if lang.IsTruthy(v10) { -v13 = v10 -} else { -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("some")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v3, v9}) -v13 = v17 -} -return v13 - } -}) -v5 := v4 -_ = v5 -} -v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7469), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7475), lang.NewKeyword("end-column"), int(43)) -v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v6 - case 2: -v3 := args[0] -v4 := args[1] -var v5 lang.FnFunc -{ // function sp2 -v5 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -return nil - case 1: -v7 := args[0] -v9 := lang.Apply(v3, []any{v7}) -var v8 any = v9 -_ = v8 -var v11 any -if lang.IsTruthy(v8) { -v11 = v8 -} else { -v12 := lang.Apply(v4, []any{v7}) -v11 = v12 -} -return v11 - case 2: -v7 := args[0] -v8 := args[1] -v10 := lang.Apply(v3, []any{v7}) -var v9 any = v10 -_ = v9 -var v12 any -if lang.IsTruthy(v9) { -v12 = v9 -} else { -v14 := lang.Apply(v3, []any{v8}) -var v13 any = v14 -_ = v13 -var v16 any -if lang.IsTruthy(v13) { -v16 = v13 -} else { -v18 := lang.Apply(v4, []any{v7}) -var v17 any = v18 -_ = v17 -var v20 any -if lang.IsTruthy(v17) { -v20 = v17 -} else { -v21 := lang.Apply(v4, []any{v8}) -v20 = v21 -} -v16 = v20 -} -v12 = v16 -} -return v12 - case 3: -v7 := args[0] -v8 := args[1] -v9 := args[2] -v11 := lang.Apply(v3, []any{v7}) -var v10 any = v11 -_ = v10 -var v13 any -if lang.IsTruthy(v10) { -v13 = v10 -} else { -v15 := lang.Apply(v3, []any{v8}) -var v14 any = v15 -_ = v14 -var v17 any -if lang.IsTruthy(v14) { -v17 = v14 -} else { -v19 := lang.Apply(v3, []any{v9}) -var v18 any = v19 -_ = v18 -var v21 any -if lang.IsTruthy(v18) { -v21 = v18 -} else { -v23 := lang.Apply(v4, []any{v7}) -var v22 any = v23 -_ = v22 -var v25 any -if lang.IsTruthy(v22) { -v25 = v22 -} else { -v27 := lang.Apply(v4, []any{v8}) -var v26 any = v27 -_ = v26 -var v29 any -if lang.IsTruthy(v26) { -v29 = v26 -} else { -v30 := lang.Apply(v4, []any{v9}) -v29 = v30 -} -v25 = v29 -} -v21 = v25 -} -v17 = v21 -} -v13 = v17 -} -return v13 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v7 := args[0] -v8 := args[1] -v9 := args[2] -v10 := lang.NewList(args[3:]...) -v12 := lang.Apply(v6, []any{v7, v8, v9}) -var v11 any = v12 -_ = v11 -var v14 any -if lang.IsTruthy(v11) { -v14 = v11 -} else { -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("some")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -var v18 lang.FnFunc -v18 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v19 := args[0] -v21 := lang.Apply(v3, []any{v19}) -var v20 any = v21 -_ = v20 -var v23 any -if lang.IsTruthy(v20) { -v23 = v20 -} else { -v24 := lang.Apply(v4, []any{v19}) -v23 = v24 -} -return v23 -}) -v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7483), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(7483), lang.NewKeyword("end-column"), int(52)) -v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v21 := lang.Apply(v17, []any{v20, v10}) -v14 = v21 -} -return v14 - } -}) -v6 := v5 -_ = v6 -} -v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7477), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7483), lang.NewKeyword("end-column"), int(61)) -v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v7 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -var v6 lang.FnFunc -{ // function sp3 -v6 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -return nil - case 1: -v8 := args[0] -v10 := lang.Apply(v3, []any{v8}) -var v9 any = v10 -_ = v9 -var v12 any -if lang.IsTruthy(v9) { -v12 = v9 -} else { -v14 := lang.Apply(v4, []any{v8}) -var v13 any = v14 -_ = v13 -var v16 any -if lang.IsTruthy(v13) { -v16 = v13 -} else { -v17 := lang.Apply(v5, []any{v8}) -v16 = v17 -} -v12 = v16 -} -return v12 - case 2: -v8 := args[0] -v9 := args[1] -v11 := lang.Apply(v3, []any{v8}) -var v10 any = v11 -_ = v10 -var v13 any -if lang.IsTruthy(v10) { -v13 = v10 -} else { -v15 := lang.Apply(v3, []any{v9}) -var v14 any = v15 -_ = v14 -var v17 any -if lang.IsTruthy(v14) { -v17 = v14 -} else { -v19 := lang.Apply(v4, []any{v8}) -var v18 any = v19 -_ = v18 -var v21 any -if lang.IsTruthy(v18) { -v21 = v18 -} else { -v23 := lang.Apply(v4, []any{v9}) -var v22 any = v23 -_ = v22 -var v25 any -if lang.IsTruthy(v22) { -v25 = v22 -} else { -v27 := lang.Apply(v5, []any{v8}) -var v26 any = v27 -_ = v26 -var v29 any -if lang.IsTruthy(v26) { -v29 = v26 -} else { -v30 := lang.Apply(v5, []any{v9}) -v29 = v30 -} -v25 = v29 -} -v21 = v25 -} -v17 = v21 -} -v13 = v17 -} -return v13 - case 3: -v8 := args[0] -v9 := args[1] -v10 := args[2] -v12 := lang.Apply(v3, []any{v8}) -var v11 any = v12 -_ = v11 -var v14 any -if lang.IsTruthy(v11) { -v14 = v11 -} else { -v16 := lang.Apply(v3, []any{v9}) -var v15 any = v16 -_ = v15 -var v18 any -if lang.IsTruthy(v15) { -v18 = v15 -} else { -v20 := lang.Apply(v3, []any{v10}) -var v19 any = v20 -_ = v19 -var v22 any -if lang.IsTruthy(v19) { -v22 = v19 -} else { -v24 := lang.Apply(v4, []any{v8}) -var v23 any = v24 -_ = v23 -var v26 any -if lang.IsTruthy(v23) { -v26 = v23 -} else { -v28 := lang.Apply(v4, []any{v9}) -var v27 any = v28 -_ = v27 -var v30 any -if lang.IsTruthy(v27) { -v30 = v27 -} else { -v32 := lang.Apply(v4, []any{v10}) -var v31 any = v32 -_ = v31 -var v34 any -if lang.IsTruthy(v31) { -v34 = v31 -} else { -v36 := lang.Apply(v5, []any{v8}) -var v35 any = v36 -_ = v35 -var v38 any -if lang.IsTruthy(v35) { -v38 = v35 -} else { -v40 := lang.Apply(v5, []any{v9}) -var v39 any = v40 -_ = v39 -var v42 any -if lang.IsTruthy(v39) { -v42 = v39 -} else { -v43 := lang.Apply(v5, []any{v10}) -v42 = v43 -} -v38 = v42 -} -v34 = v38 -} -v30 = v34 -} -v26 = v30 -} -v22 = v26 -} -v18 = v22 -} -v14 = v18 -} -return v14 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v8 := args[0] -v9 := args[1] -v10 := args[2] -v11 := lang.NewList(args[3:]...) -v13 := lang.Apply(v7, []any{v8, v9, v10}) -var v12 any = v13 -_ = v12 -var v15 any -if lang.IsTruthy(v12) { -v15 = v12 -} else { -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("some")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -var v19 lang.FnFunc -v19 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v20 := args[0] -v22 := lang.Apply(v3, []any{v20}) -var v21 any = v22 -_ = v21 -var v24 any -if lang.IsTruthy(v21) { -v24 = v21 -} else { -v26 := lang.Apply(v4, []any{v20}) -var v25 any = v26 -_ = v25 -var v28 any -if lang.IsTruthy(v25) { -v28 = v25 -} else { -v29 := lang.Apply(v5, []any{v20}) -v28 = v29 -} -v24 = v28 -} -return v24 -}) -v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7491), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(7491), lang.NewKeyword("end-column"), int(59)) -v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v22 := lang.Apply(v18, []any{v21, v11}) -v15 = v22 -} -return v15 - } -}) -v7 := v6 -_ = v7 -} -v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7485), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7491), lang.NewKeyword("end-column"), int(68)) -v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v8 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("list*")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v3, v4, v5, v7}) -var v7 any = v11 -_ = v7 -var v13 lang.FnFunc -{ // function spn -v13 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -return nil - case 1: -v15 := args[0] -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("some")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -var v19 lang.FnFunc -v19 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v20 := args[0] -v21 := lang.Apply(v20, []any{v15}) -return v21 -}) -v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7496), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(7496), lang.NewKeyword("end-column"), int(26)) -v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v22 := lang.Apply(v18, []any{v21, v7}) -return v22 - case 2: -v15 := args[0] -v16 := args[1] -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("some")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -var v20 lang.FnFunc -v20 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v21 := args[0] -v23 := lang.Apply(v21, []any{v15}) -var v22 any = v23 -_ = v22 -var v25 any -if lang.IsTruthy(v22) { -v25 = v22 -} else { -v26 := lang.Apply(v21, []any{v16}) -v25 = v26 -} -return v25 -}) -v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7497), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(7497), lang.NewKeyword("end-column"), int(39)) -v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v23 := lang.Apply(v19, []any{v22, v7}) -return v23 - case 3: -v15 := args[0] -v16 := args[1] -v17 := args[2] -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("some")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -var v21 lang.FnFunc -v21 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v22 := args[0] -v24 := lang.Apply(v22, []any{v15}) -var v23 any = v24 -_ = v23 -var v26 any -if lang.IsTruthy(v23) { -v26 = v23 -} else { -v28 := lang.Apply(v22, []any{v16}) -var v27 any = v28 -_ = v27 -var v30 any -if lang.IsTruthy(v27) { -v30 = v27 -} else { -v31 := lang.Apply(v22, []any{v17}) -v30 = v31 -} -v26 = v30 -} -return v26 -}) -v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7498), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7498), lang.NewKeyword("end-column"), int(47)) -v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v24 := lang.Apply(v20, []any{v23, v7}) -return v24 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v15 := args[0] -v16 := args[1] -v17 := args[2] -v18 := lang.NewList(args[3:]...) -v20 := lang.Apply(v14, []any{v15, v16, v17}) -var v19 any = v20 -_ = v19 -var v22 any -if lang.IsTruthy(v19) { -v22 = v19 -} else { -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("some")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -var v26 lang.FnFunc -v26 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v27 := args[0] -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("some")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{v27, v18}) -return v31 -}) -v27 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7500), lang.NewKeyword("column"), int(36), lang.NewKeyword("end-line"), int(7500), lang.NewKeyword("end-column"), int(49)) -v28, err := lang.WithMeta(v26, v27.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v29 := lang.Apply(v25, []any{v28, v7}) -v22 = v29 -} -return v22 - } -}) -v14 := v13 -_ = v14 -} -v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7494), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7500), lang.NewKeyword("end-column"), int(56)) -v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v15 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// some? -{ -v1 := reflect.TypeOf(false) -v0 := lang.NewSymbol("some?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is not nil, false otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(530), lang.NewKeyword("end-line"), int(530))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("not")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("nil?")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v4}) -v12 := lang.Apply(v7, []any{v11}) -return v12 -}) -v4 := reflect.TypeOf(false) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// sort -{ -v0 := lang.NewSymbol("sort").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("comp"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a sorted sequence of the items in coll. If no comparator is\n supplied, uses compare. comparator must implement\n java.util.Comparator. Guaranteed to be stable: equal elements will\n not be reordered. If coll is a Java array, it will be modified. To\n avoid this, sort a copy of the array.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3085), lang.NewKeyword("end-line"), int(3085))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("sort")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("compare")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v6, []any{v9, v3}) -return v10 - case 2: -v3 := args[0] -v4 := args[1] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("seq")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v4}) -if lang.IsTruthy(v9) { -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("to-array")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v4}) -var v10 any = v14 -_ = v10 -v16 := lang.Apply(lang.SortSlice, []any{v10, v3}) -_ = v16 -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("with-meta")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("seq")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.Apply(v22, []any{v10}) -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("meta")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v4}) -v28 := lang.Apply(v19, []any{v23, v27}) -v5 = v28 -} else { -v5 = lang.NewList() -} -return v5 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// sort-by -{ -v0 := lang.NewSymbol("sort-by").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("keyfn"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("keyfn"), lang.NewSymbol("comp"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a sorted sequence of the items in coll, where the sort\n order is determined by comparing (keyfn item). If no comparator is\n supplied, uses compare. comparator must implement\n java.util.Comparator. Guaranteed to be stable: equal elements will\n not be reordered. If coll is a Java array, it will be modified. To\n avoid this, sort a copy of the array.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3102), lang.NewKeyword("end-line"), int(3102))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("sort-by")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("compare")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v7, []any{v3, v10, v4}) -return v11 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("sort")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -var v9 lang.FnFunc -v9 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v10 := args[0] -v11 := args[1] -v12 := lang.Apply(v3, []any{v10}) -v13 := lang.Apply(v3, []any{v11}) -v14 := lang.Apply(v4, []any{v12, v13}) -return v14 -}) -v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3114), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(3114), lang.NewKeyword("end-column"), int(46)) -v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v12 := lang.Apply(v8, []any{v11, v5}) -return v12 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// sorted-map -{ -v0 := lang.NewSymbol("sorted-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keyvals"))), lang.NewKeyword("doc"), "keyval => key val\n Returns a new sorted map with supplied mappings. If any keys are\n equal, they are handled as if by repeated uses of assoc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(397), lang.NewKeyword("end-line"), int(397))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewList(args[0:]...) -v4 := lang.Apply(lang.CreatePersistentTreeMap, []any{v3}) -return v4 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// sorted-map-by -{ -v0 := lang.NewSymbol("sorted-map-by").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("comparator"), lang.NewSymbol("&"), lang.NewSymbol("keyvals"))), lang.NewKeyword("doc"), "keyval => key val\n Returns a new sorted map with supplied mappings, using the supplied\n comparator. If any keys are equal, they are handled as if by\n repeated uses of assoc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(406), lang.NewKeyword("end-line"), int(406))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.NewList(args[1:]...) -v5 := lang.Apply(nil, []any{v3, v4}) -return v5 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// sorted-set -{ -v0 := lang.NewSymbol("sorted-set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keys"))), lang.NewKeyword("doc"), "Returns a new sorted set with supplied keys. Any equal keys are\n handled as if by repeated uses of conj.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(416), lang.NewKeyword("end-line"), int(416))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewList(args[0:]...) -v4 := lang.Apply(lang.CreatePersistentTreeSet, []any{v3}) -return v4 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// sorted-set-by -{ -v0 := lang.NewSymbol("sorted-set-by").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("comparator"), lang.NewSymbol("&"), lang.NewSymbol("keys"))), lang.NewKeyword("doc"), "Returns a new sorted set with supplied keys, using the supplied\n comparator. Any equal keys are handled as if by repeated uses of\n conj.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(424), lang.NewKeyword("end-line"), int(424))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.NewList(args[1:]...) -v5 := lang.Apply(lang.CreatePersistentTreeSetWithComparator, []any{v3, v4}) -return v5 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// sorted? -{ -v0 := lang.NewSymbol("sorted?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements Sorted", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6235), lang.NewKeyword("end-line"), int(6235))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{glojure.lang4.Sorted, v3}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// special-symbol? -{ -v0 := lang.NewSymbol("special-symbol?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns true if s names a special form", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4992), lang.NewKeyword("end-line"), int(4992))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("contains?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7, ok := lang.FieldOrMethod(runtime5.Compiler, "specials") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", runtime5.Compiler, "specials"))) -} -var v8 any -switch reflect.TypeOf(v7).Kind() { -case reflect.Func: - v8 = lang.Apply(v7, nil) -default: - v8 = v7 -} -v9 := lang.Apply(v6, []any{v8, v3}) -return v9 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// spit -{ -v0 := lang.NewSymbol("spit").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("content"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Opposite of slurp. Opens f with writer, writes content, then\n closes f. Options passed to glojure.java.io/writer.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6994), lang.NewKeyword("end-line"), int(6994))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("apply")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{nil, v3, v5}) -var v6 any = v10 -_ = v6 -var v12 any -func() { -defer func() { -v13, ok := lang.FieldOrMethod(v6, "close") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "close"))) -} -var v14 any -switch reflect.TypeOf(v13).Kind() { -case reflect.Func: - v14 = lang.Apply(v13, nil) -default: - v14 = v13 -} -}() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("str")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v4}) -v19 := lang.Apply(lang.WriteWriter, []any{v6, v18}) -v12 = v19 -}() -return v12 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// split-at -{ -v0 := lang.NewSymbol("split-at").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a vector of [(take n coll) (drop n coll)]", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2983), lang.NewKeyword("end-line"), int(2983))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("take")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3, v4}) -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("drop")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v3, v4}) -v13 := lang.NewVector(v8, v12) -v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2988), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2988), lang.NewKeyword("end-column"), int(33)) -v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v15 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// split-with -{ -v0 := lang.NewSymbol("split-with").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a vector of [(take-while pred coll) (drop-while pred coll)]", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2990), lang.NewKeyword("end-line"), int(2990))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("take-while")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3, v4}) -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("drop-while")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v3, v4}) -v13 := lang.NewVector(v8, v12) -v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2995), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2995), lang.NewKeyword("end-column"), int(51)) -v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v15 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// splitv-at -{ -v0 := lang.NewSymbol("splitv-at").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a vector of [(into [] (take n) coll) (drop n coll)]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7256), lang.NewKeyword("end-line"), int(7256))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("into")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.NewVector() -v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7260), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(7260), lang.NewKeyword("end-column"), int(11)) -v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("take")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v3}) -v15 := lang.Apply(v7, []any{v10, v14, v4}) -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("drop")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v3, v4}) -v20 := lang.NewVector(v15, v19) -v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7260), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(7260), lang.NewKeyword("end-column"), int(41)) -v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v22 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// spread -{ -v0 := lang.NewSymbol("spread").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("arglist"))), lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(632), lang.NewKeyword("end-line"), int(632), lang.NewKeyword("private"), true)).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("nil?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -if lang.IsTruthy(v8) { -v4 = nil -} else { -var v9 any -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("nil?")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("next")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v3}) -v17 := lang.Apply(v12, []any{v16}) -if lang.IsTruthy(v17) { -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("seq")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("first")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v3}) -v25 := lang.Apply(v20, []any{v24}) -v9 = v25 -} else { -var v26 any -if lang.IsTruthy(lang.NewKeyword("else")) { -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("cons")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("first")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.Apply(v32, []any{v3}) -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("spread")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("next")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v3}) -v41 := lang.Apply(v36, []any{v40}) -v42 := lang.Apply(v29, []any{v33, v41}) -v26 = v42 -} else { -v26 = nil -} -v9 = v26 -} -v4 = v9 -} -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// str -{ -v1 := reflect.TypeOf("") -v0 := lang.NewSymbol("str").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("ys"))), lang.NewKeyword("doc"), "With no args, returns the empty string. With one arg x, returns\n x.toString(). (str nil) returns the empty string. With more than\n one arg, returns the concatenation of the str values of the args.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(543), lang.NewKeyword("end-line"), int(543))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -return "" - case 1: -v4 := args[0] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("nil?")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v4}) -if lang.IsTruthy(v9) { -v5 = "" -} else { -v10 := lang.Apply(lang.ToString, []any{v4}) -v5 = v10 -} -return v5 - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := lang.NewList(args[1:]...) -var v6 lang.FnFunc -v6 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v7 := args[0] -v8 := args[1] -recur_loop_74: -var v9 any -if lang.IsTruthy(v8) { -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("str")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("first")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v8}) -v18 := lang.Apply(v13, []any{v17}) -v19, _ := lang.FieldOrMethod(v7, "WriteString") -if reflect.TypeOf(v19).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("WriteString is not a function"))) -} -v20 := lang.Apply(v19, []any{v18}) -_ = v20 -var v10 any = v7 -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("next")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v8}) -var v21 any = v25 -v7 = v10 -v8 = v21 -goto recur_loop_74 -} else { -v26, ok := lang.FieldOrMethod(v7, "String") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "String"))) -} -var v27 any -switch reflect.TypeOf(v26).Kind() { -case reflect.Func: - v27 = lang.Apply(v26, nil) -default: - v27 = v26 -} -v9 = v27 -} -return v9 -}) -v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(554), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(554), lang.NewKeyword("end-column"), int(127)) -v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("cons")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v4, v5}) -v13 := lang.Apply(v8, []any{"unimplemented: new with non-constant class type", v12}) -return v13 - } -}) -v4 := reflect.TypeOf("") -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// stream-into! -{ -v0 := lang.NewSymbol("stream-into!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("stream")), lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("xform"), lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Returns a new coll consisting of coll with all of the items of the\n stream conjoined. This is a terminal operation on the stream.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6810), lang.NewKeyword("end-line"), int(6810))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v3 := args[0] -v4 := args[1] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{lang.IEditableCollection, v3}) -if lang.IsTruthy(v9) { -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("with-meta")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("persistent!")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("stream-reduce!")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("conj!")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("transient")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v26 := lang.Apply(v18, []any{v21, v25, v4}) -v27 := lang.Apply(v15, []any{v26}) -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("meta")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{v3}) -v32 := lang.Apply(v12, []any{v27, v31}) -v5 = v32 -} else { -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("stream-reduce!")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("conj")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v35, []any{v38, v3, v4}) -v5 = v39 -} -return v5 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -var v6 any -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("instance?")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{lang.IEditableCollection, v3}) -if lang.IsTruthy(v10) { -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("with-meta")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("persistent!")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("stream-transduce!")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("conj!")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("transient")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{v3}) -v27 := lang.Apply(v19, []any{v4, v22, v26, v5}) -v28 := lang.Apply(v16, []any{v27}) -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("meta")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.Apply(v31, []any{v3}) -v33 := lang.Apply(v13, []any{v28, v32}) -v6 = v33 -} else { -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("stream-transduce!")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("conj")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.Apply(v36, []any{v4, v39, v3, v5}) -v6 = v40 -} -return v6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// stream-reduce! -{ -v0 := lang.NewSymbol("stream-reduce!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("s")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Works like reduce but takes a java.util.stream.BaseStream as its source.\n Honors 'reduced', is a terminal operation on the stream", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6784), lang.NewKeyword("end-line"), int(6784))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v3 := args[0] -v4 := args[1] -v5, ok := lang.FieldOrMethod(v4, "iterator") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "iterator"))) -} -var v6 any -switch reflect.TypeOf(v5).Kind() { -case reflect.Func: - v6 = lang.Apply(v5, nil) -default: - v6 = v5 -} -v7 := lang.Apply(nil, []any{v6, v3}) -return v7 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6, ok := lang.FieldOrMethod(v5, "iterator") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "iterator"))) -} -var v7 any -switch reflect.TypeOf(v6).Kind() { -case reflect.Func: - v7 = lang.Apply(v6, nil) -default: - v7 = v6 -} -v8 := lang.Apply(nil, []any{v7, v3, v4}) -return v8 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// stream-seq! -{ -v0 := lang.NewSymbol("stream-seq!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Takes a java.util.stream.BaseStream instance s and returns a seq of its\n contents. This is a terminal operation on the stream.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6793), lang.NewKeyword("end-line"), int(6793))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("iterator-seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7, ok := lang.FieldOrMethod(v3, "iterator") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "iterator"))) -} -var v8 any -switch reflect.TypeOf(v7).Kind() { -case reflect.Func: - v8 = lang.Apply(v7, nil) -default: - v8 = v7 -} -v9 := lang.Apply(v6, []any{v8}) -return v9 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// stream-transduce! -{ -v0 := lang.NewSymbol("stream-transduce!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("f"), lang.NewSymbol("stream")), lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Works like transduce but takes a java.util.stream.BaseStream as its source.\n This is a terminal operation on the stream.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6800), lang.NewKeyword("end-line"), int(6800))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("stream-transduce!")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v4, nil) -v10 := lang.Apply(v8, []any{v3, v4, v9, v5}) -return v10 - case 4: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v8 := lang.Apply(v3, []any{v7}) -var v7 any = v8 -_ = v7 -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("stream-reduce!")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{v7, v5, v6}) -var v9 any = v13 -_ = v9 -v15 := lang.Apply(v7, []any{v9}) -return v15 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// string? -{ -v0 := lang.NewSymbol("string?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a String", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(160), lang.NewKeyword("end-line"), int(164))).(*lang.Symbol) -var v2 lang.FnFunc -{ // function string? -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{lang.Builtins["string"], v4}) -return v8 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(164), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(164), lang.NewKeyword("end-column"), int(58))).(lang.FnFunc) -v3 := v2 -_ = v3 -} -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// strip-ns -{ -v0 := lang.NewSymbol("strip-ns").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(255), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(255), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("named"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("symbol?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -if lang.IsTruthy(v8) { -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("symbol")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("name")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v3}) -v16 := lang.Apply(v11, []any{nil, v15}) -v4 = v16 -} else { -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("keyword")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("name")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.Apply(v22, []any{v3}) -v24 := lang.Apply(v19, []any{nil, v23}) -v4 = v24 -} -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// struct -{ -v0 := lang.NewSymbol("struct").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("&"), lang.NewSymbol("vals"))), lang.NewKeyword("doc"), "Returns a new structmap instance with the keys of the\n structure-basis. vals must be supplied for basis keys in order -\n where values are not supplied they will default to nil.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4061), lang.NewKeyword("end-line"), int(4061))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.NewList(args[1:]...) -v5 := lang.Apply(lang.ConstructPersistentStructMap, []any{v3, v4}) -return v5 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// struct-map -{ -v0 := lang.NewSymbol("struct-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("&"), lang.NewSymbol("inits"))), lang.NewKeyword("doc"), "Returns a new structmap instance with the keys of the\n structure-basis. keyvals may contain all, some or none of the basis\n keys - where values are not supplied they will default to nil.\n keyvals can also contain keys not in the basis.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4051), lang.NewKeyword("end-line"), int(4051))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.NewList(args[1:]...) -v5 := lang.Apply(lang.CreatePersistentStructMap, []any{v3, v4}) -return v5 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// subs -{ -v0 := lang.NewSymbol("subs").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("start")), lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("start"), lang.NewSymbol("end"))), lang.NewKeyword("doc"), "Returns the substring of s beginning at start inclusive, and ending\n at end (defaults to length of string), exclusive.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5005), lang.NewKeyword("end-line"), int(5005))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v3 := args[0] -v4 := args[1] -v5 := lang.Apply(lang.Builtins["slice"], []any{v3, v4}) -return v5 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.Apply(lang.Builtins["slice"], []any{v3, v4, v5}) -return v6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// subseq -{ -v0 := lang.NewSymbol("subseq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sc"), lang.NewSymbol("test"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("sc"), lang.NewSymbol("start-test"), lang.NewSymbol("start-key"), lang.NewSymbol("end-test"), lang.NewSymbol("end-key"))), lang.NewKeyword("doc"), "sc must be a sorted collection, test(s) one of <, <=, > or\n >=. Returns a seq of those entries with keys ek for\n which (test (.. sc comparator (compare ek key)) 0) is true", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5133), lang.NewKeyword("end-line"), int(5133))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("mk-bound-fn")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v3, v4, v5}) -var v6 any = v10 -_ = v6 -var v12 any -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol(">")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol(">=")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.CreatePersistentTreeSet(v15, v18) -v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5141), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5141), lang.NewKeyword("end-column"), int(17)) -v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v22 := lang.Apply(v21, []any{v4}) -if lang.IsTruthy(v22) { -v24, _ := lang.FieldOrMethod(v3, "seqFrom") -if reflect.TypeOf(v24).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("seqFrom is not a function"))) -} -v25 := lang.Apply(v24, []any{v5, true}) -var v23 any = v25 -_ = v23 -var v27 any -if lang.IsTruthy(v23) { -var v28 any = v23 -_ = v28 -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("nth")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.Apply(v32, []any{v28, int64(0), nil}) -var v29 any = v33 -_ = v29 -var v34 any = v28 -_ = v34 -var v36 any -v37 := lang.Apply(v6, []any{v29}) -if lang.IsTruthy(v37) { -v36 = v34 -} else { -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("next")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.Apply(v40, []any{v34}) -v36 = v41 -} -v27 = v36 -} else { -v27 = nil -} -v12 = v27 -} else { -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("take-while")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26, _ := lang.FieldOrMethod(v3, "seq") -if reflect.TypeOf(v26).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("seq is not a function"))) -} -v27 := lang.Apply(v26, []any{true}) -v28 := lang.Apply(v25, []any{v6, v27}) -v12 = v28 -} -return v12 - case 5: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := args[4] -v9, _ := lang.FieldOrMethod(v3, "seqFrom") -if reflect.TypeOf(v9).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("seqFrom is not a function"))) -} -v10 := lang.Apply(v9, []any{v5, true}) -var v8 any = v10 -_ = v8 -var v12 any -if lang.IsTruthy(v8) { -var v13 any = v8 -_ = v13 -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("nth")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v13, int64(0), nil}) -var v14 any = v18 -_ = v14 -var v19 any = v13 -_ = v19 -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("take-while")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("mk-bound-fn")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v3, v6, v7}) -var v28 any -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("mk-bound-fn")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.Apply(v31, []any{v3, v4, v5}) -v33 := lang.Apply(v32, []any{v14}) -if lang.IsTruthy(v33) { -v28 = v19 -} else { -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("next")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.Apply(v36, []any{v19}) -v28 = v37 -} -v38 := lang.Apply(v23, []any{v27, v28}) -v12 = v38 -} else { -v12 = nil -} -return v12 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// subvec -{ -v0 := lang.NewSymbol("subvec").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("v"), lang.NewSymbol("start")), lang.NewVector(lang.NewSymbol("v"), lang.NewSymbol("start"), lang.NewSymbol("end"))), lang.NewKeyword("doc"), "Returns a persistent vector of the items in vector from\n start (inclusive) to end (exclusive). If end is not supplied,\n defaults to (count vector). This operation is O(1) and very fast, as\n the resulting vector shares structure with the original and no\n trimming is done.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3819), lang.NewKeyword("end-line"), int(3819))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("subvec")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("count")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v3}) -v12 := lang.Apply(v7, []any{v3, v4, v11}) -return v12 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6, _ := lang.FieldOrMethod(runtime5.RT, "Subvec") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Subvec is not a function"))) -} -v7 := lang.Apply(v6, []any{v3, v4, v5}) -return v7 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// supers -{ -v0 := lang.NewSymbol("supers").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("class"))), lang.NewKeyword("doc"), "Returns the immediate and indirect superclasses and interfaces of c, if any", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5532), lang.NewKeyword("end-line"), int(5532))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("set")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("bases")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v3}) -v12 := lang.Apply(v7, []any{v11}) -var v4 any = v12 -_ = v4 -var v13 any = v4 -_ = v13 -var v14 any -for { -var v15 any -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("seq")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v13}) -if lang.IsTruthy(v19) { -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("first")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v13}) -var v20 any = v24 -_ = v20 -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("bases")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.Apply(v28, []any{v20}) -var v25 any = v29 -_ = v25 -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("into1")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v4, v25}) -var v31 any = v35 -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("into1")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("disj")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v13, v20}) -v44 := lang.Apply(v39, []any{v43, v25}) -var v36 any = v44 -v4 = v31 -v13 = v36 -continue -} else { -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("not-empty")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.Apply(v22, []any{v4}) -v15 = v23 -} -v14 = v15 - break -} -return v14 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// swap! -{ -v0 := lang.NewSymbol("swap!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atom"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Atomically swaps the value of atom to be:\n (apply f current-value-of-atom args). Note that f may be called\n multiple times, and thus should be free of side effects. Returns\n the value that was swapped in.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2343), lang.NewKeyword("end-line"), int(2343))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -v6, _ := lang.FieldOrMethod(v3, "swap") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("swap is not a function"))) -} -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// swap-vals! -{ -v0 := lang.NewSymbol("swap-vals!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atom"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Atomically swaps the value of atom to be:\n (apply f current-value-of-atom args). Note that f may be called\n multiple times, and thus should be free of side effects.\n Returns [old new], the value of the atom before and after the swap.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2352), lang.NewKeyword("end-line"), int(2352))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -v6, _ := lang.FieldOrMethod(v3, "swapVals") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("swapVals is not a function"))) -} -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// symbol -{ -v1 := reflect.TypeOf((*lang.Symbol)(nil)) -v0 := lang.NewSymbol("symbol").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name"))), lang.NewKeyword("doc"), "Returns a Symbol with the given namespace and name. Arity-1 works\n on strings, keywords, and vars.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(584), lang.NewKeyword("end-line"), int(584))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v4 := args[0] -var v5 any -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("symbol?")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v4}) -if lang.IsTruthy(v9) { -v5 = v4 -} else { -var v10 any -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("instance?")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{lang.Builtins["string"], v4}) -if lang.IsTruthy(v14) { -v15 := lang.Apply(lang.NewSymbol, []any{v4}) -v10 = v15 -} else { -var v16 any -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("instance?")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{lang.*Var, v4}) -if lang.IsTruthy(v20) { -v21, ok := lang.FieldOrMethod(v4, "toSymbol") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "toSymbol"))) -} -var v22 any -switch reflect.TypeOf(v21).Kind() { -case reflect.Func: - v22 = lang.Apply(v21, nil) -default: - v22 = v21 -} -v16 = v22 -} else { -var v23 any -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("instance?")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v26, []any{lang.Keyword, v4}) -if lang.IsTruthy(v27) { -v28, ok := lang.FieldOrMethod(v4, "sym") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "sym"))) -} -var v29 any -switch reflect.TypeOf(v28).Kind() { -case reflect.Func: - v29 = lang.Apply(v28, nil) -default: - v29 = v28 -} -v23 = v29 -} else { -var v30 any -if lang.IsTruthy(lang.NewKeyword("else")) { -v31 := lang.Apply(lang.NewIllegalArgumentError, []any{"no conversion to symbol"}) -panic(v31) -} else { -v30 = nil -} -v23 = v30 -} -v16 = v23 -} -v10 = v16 -} -v5 = v10 -} -return v5 - case 2: -v4 := args[0] -v5 := args[1] -v6 := lang.Apply(lang.InternSymbol, []any{v4, v5}) -return v6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v4 := reflect.TypeOf((*lang.Symbol)(nil)) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// symbol? -{ -v0 := lang.NewSymbol("symbol?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a Symbol", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(557), lang.NewKeyword("end-line"), int(557))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{lang.*Symbol, v3}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// sync -{ -v0 := lang.NewSymbol("sync").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("flags-ignored-for-now"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "transaction-flags => TBD, pass nil for now\n\n Runs the exprs (in an implicit do) in a transaction that encompasses\n exprs and any nested calls. Starts a transaction if none is already\n running on this thread. Any uncaught exception will abort the\n transaction and flow out of sync. The exprs may be run more than\n once, but any effects on Refs will be atomic.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(2490), lang.NewKeyword("end-line"), int(2490))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("seq")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("concat")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("list")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{lang.NewSymbol(".")}) -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("list")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.LockingTransaction")}) -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("list")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("seq")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("concat")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("list")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.Apply(v32, []any{lang.NewSymbol("glojure.core/RunInTransaction")}) -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("list")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("seq")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("concat")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("list")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.Apply(v45, []any{lang.NewSymbol("glojure.core/fn")}) -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("list")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) -} -v49 := v48.Get() -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("apply")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("vector")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) -} -v55 := v54.Get() -v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v57 := v56.FindInternedVar(lang.NewSymbol("seq")) -if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) -} -v58 := v57.Get() -v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v60 := v59.FindInternedVar(lang.NewSymbol("concat")) -if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) -} -v61 := v60.Get() -v62 := lang.Apply(v61, nil) -v63 := lang.Apply(v58, []any{v62}) -v64 := lang.Apply(v52, []any{v55, v63}) -v65 := lang.Apply(v49, []any{v64}) -v66 := lang.Apply(v42, []any{v46, v65, v6}) -v67 := lang.Apply(v39, []any{v66}) -v68 := lang.Apply(v36, []any{v67}) -v69 := lang.Apply(v29, []any{v33, v68}) -v70 := lang.Apply(v26, []any{v69}) -v71 := lang.Apply(v23, []any{v70}) -v72 := lang.Apply(v12, []any{v16, v20, v71}) -v73 := lang.Apply(v9, []any{v72}) -return v73 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// system-newline -{ -v0 := lang.NewSymbol("system-newline").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3695), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(3695), lang.NewKeyword("end-column"), int(40), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v1 := ns.InternWithValue(v0, "\n", true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// tagged-literal -{ -v0 := lang.NewSymbol("tagged-literal").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag"), lang.NewSymbol("form"))), lang.NewKeyword("doc"), "Construct a data representation of a tagged literal from a\n tag symbol and a form.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7769), lang.NewKeyword("end-line"), int(7769))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.Apply(nil, []any{v3, v4}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// tagged-literal? -{ -v0 := lang.NewSymbol("tagged-literal?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("value"))), lang.NewKeyword("doc"), "Return true if the value is the data representation of a tagged literal", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7763), lang.NewKeyword("end-line"), int(7763))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{glojure.lang4.TaggedLiteral, v3}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// take -{ -v0 := lang.NewSymbol("take").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the first n items in coll, or all items if\n there are fewer than n. Returns a stateful transducer when\n no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2853), lang.NewKeyword("end-line"), int(2853))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := args[0] -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("volatile!")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v3}) -var v6 any = v10 -_ = v6 -var v12 lang.FnFunc -v12 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v13 := lang.Apply(v5, nil) -return v13 - case 1: -v13 := args[0] -v14 := lang.Apply(v5, []any{v13}) -return v14 - case 2: -v13 := args[0] -v14 := args[1] -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("deref")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v6}) -var v15 any = v19 -_ = v15 -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("dec")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24, ok := lang.FieldOrMethod(v6, "Deref") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "Deref"))) -} -var v25 any -switch reflect.TypeOf(v24).Kind() { -case reflect.Func: - v25 = lang.Apply(v24, nil) -default: - v25 = v24 -} -v26 := lang.Apply(v23, []any{v25}) -v27, _ := lang.FieldOrMethod(v6, "reset") -if reflect.TypeOf(v27).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) -} -v28 := lang.Apply(v27, []any{v26}) -var v20 any = v28 -_ = v20 -var v30 any -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("pos?")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v15}) -if lang.IsTruthy(v34) { -v35 := lang.Apply(v5, []any{v29, v14}) -v30 = v35 -} else { -v30 = v29 -} -var v29 any = v30 -_ = v29 -var v37 any -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("not")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("pos?")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v20}) -v45 := lang.Apply(v40, []any{v44}) -if lang.IsTruthy(v45) { -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("ensure-reduced")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) -} -v48 := v47.Get() -v49 := lang.Apply(v48, []any{v29}) -v37 = v49 -} else { -v37 = v29 -} -return v37 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2862), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(2873), lang.NewKeyword("end-column"), int(28)) -v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v14 -}) -v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2860), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2873), lang.NewKeyword("end-column"), int(30)) -v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v6 - case 2: -v3 := args[0] -v4 := args[1] -var v5 lang.FnFunc -v5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -var v6 any -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("pos?")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v3}) -if lang.IsTruthy(v10) { -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("seq")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v4}) -var v11 any = v15 -_ = v11 -var v17 any -if lang.IsTruthy(v11) { -var v18 any = v11 -_ = v18 -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("cons")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("first")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{v18}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("take")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("dec")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.Apply(v32, []any{v3}) -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("rest")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.Apply(v36, []any{v18}) -v38 := lang.Apply(v29, []any{v33, v37}) -v39 := lang.Apply(v22, []any{v26, v38}) -v17 = v39 -} else { -v17 = nil -} -v6 = v17 -} else { -v6 = nil -} -return v6 -}) -v6 := lang.Apply(lang.NewLazySeq, []any{v5}) -return v6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// take-last -{ -v0 := lang.NewSymbol("take-last").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a seq of the last n items in coll. Depending on the type\n of coll may be no better than linear time. For vectors, see also subvec.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2939), lang.NewKeyword("end-line"), int(2939))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("seq")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v4}) -var v5 any = v9 -_ = v5 -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("seq")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("drop")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v3, v4}) -v18 := lang.Apply(v13, []any{v17}) -var v10 any = v18 -_ = v10 -var v19 any -for { -var v20 any -if lang.IsTruthy(v10) { -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("next")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v5}) -var v21 any = v25 -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("next")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{v10}) -var v26 any = v30 -v5 = v21 -v10 = v26 -continue -} else { -v20 = v5 -} -v19 = v20 - break -} -return v19 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// take-nth -{ -v0 := lang.NewSymbol("take-nth").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy seq of every nth item in coll. Returns a stateful\n transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4287), lang.NewKeyword("end-line"), int(4287))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := args[0] -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("volatile!")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{int64(-1)}) -var v6 any = v10 -_ = v6 -var v12 lang.FnFunc -v12 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v13 := lang.Apply(v5, nil) -return v13 - case 1: -v13 := args[0] -v14 := lang.Apply(v5, []any{v13}) -return v14 - case 2: -v13 := args[0] -v14 := args[1] -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("inc")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19, ok := lang.FieldOrMethod(v6, "Deref") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "Deref"))) -} -var v20 any -switch reflect.TypeOf(v19).Kind() { -case reflect.Func: - v20 = lang.Apply(v19, nil) -default: - v20 = v19 -} -v21 := lang.Apply(v18, []any{v20}) -v22, _ := lang.FieldOrMethod(v6, "reset") -if reflect.TypeOf(v22).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) -} -v23 := lang.Apply(v22, []any{v21}) -var v15 any = v23 -_ = v15 -var v25 any -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("zero?")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("rem")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.Apply(v31, []any{v15, v3}) -v33 := lang.Apply(v28, []any{v32}) -if lang.IsTruthy(v33) { -v34 := lang.Apply(v5, []any{v13, v14}) -v25 = v34 -} else { -v25 = v13 -} -return v25 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4295), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(4302), lang.NewKeyword("end-column"), int(28)) -v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v14 -}) -v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4293), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(4302), lang.NewKeyword("end-column"), int(30)) -v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v6 - case 2: -v3 := args[0] -v4 := args[1] -var v5 lang.FnFunc -v5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("seq")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v4}) -var v6 any = v10 -_ = v6 -var v12 any -if lang.IsTruthy(v6) { -var v13 any = v6 -_ = v13 -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("cons")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("first")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v20, []any{v13}) -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("take-nth")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("drop")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.Apply(v27, []any{v3, v13}) -v29 := lang.Apply(v24, []any{v3, v28}) -v30 := lang.Apply(v17, []any{v21, v29}) -v12 = v30 -} else { -v12 = nil -} -return v12 -}) -v6 := lang.Apply(lang.NewLazySeq, []any{v5}) -return v6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// take-while -{ -v0 := lang.NewSymbol("take-while").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred")), lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of successive items from coll while\n (pred item) returns logical true. pred must be free of side-effects.\n Returns a transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2880), lang.NewKeyword("end-line"), int(2880))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -var v4 lang.FnFunc -v4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v5 := args[0] -var v6 lang.FnFunc -v6 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v7 := lang.Apply(v5, nil) -return v7 - case 1: -v7 := args[0] -v8 := lang.Apply(v5, []any{v7}) -return v8 - case 2: -v7 := args[0] -v8 := args[1] -var v9 any -v10 := lang.Apply(v3, []any{v8}) -if lang.IsTruthy(v10) { -v11 := lang.Apply(v5, []any{v7, v8}) -v9 = v11 -} else { -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("reduced")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v7}) -v9 = v15 -} -return v9 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2888), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(2894), lang.NewKeyword("end-column"), int(33)) -v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v8 -}) -v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2887), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2894), lang.NewKeyword("end-column"), int(34)) -v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v6 - case 2: -v3 := args[0] -v4 := args[1] -var v5 lang.FnFunc -v5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("seq")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v9, []any{v4}) -var v6 any = v10 -_ = v6 -var v12 any -if lang.IsTruthy(v6) { -var v13 any = v6 -_ = v13 -var v15 any -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("first")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v13}) -v20 := lang.Apply(v3, []any{v19}) -if lang.IsTruthy(v20) { -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("cons")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("first")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.Apply(v26, []any{v13}) -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("take-while")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("rest")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v13}) -v35 := lang.Apply(v30, []any{v3, v34}) -v36 := lang.Apply(v23, []any{v27, v35}) -v15 = v36 -} else { -v15 = nil -} -v12 = v15 -} else { -v12 = nil -} -return v12 -}) -v6 := lang.Apply(lang.NewLazySeq, []any{v5}) -return v6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// tapset -{ -v0 := lang.NewSymbol("tapset").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7882), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(7882), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) -v2 := lang.NewAtom(lang.CreatePersistentTreeSet()) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// test -{ -v0 := lang.NewSymbol("test").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("v"))), lang.NewKeyword("doc"), "test [v] finds fn at key :test in var metadata and calls it,\n presuming failure will throw exception", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4853), lang.NewKeyword("end-line"), int(4853))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("meta")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -v9 := lang.Apply(lang.NewKeyword("test"), []any{v8}) -var v4 any = v9 -_ = v4 -var v11 any -if lang.IsTruthy(v4) { -v12 := lang.Apply(v4, nil) -_ = v12 -v11 = lang.NewKeyword("ok") -} else { -v11 = lang.NewKeyword("no-test") -} -return v11 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// the-ns -{ -v0 := lang.NewSymbol("the-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "If passed a namespace, returns it. Else, when passed a symbol,\n returns the namespace named by it, throwing an exception if not\n found.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4152), lang.NewKeyword("end-line"), int(4152))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{lang.*Namespace, v3}) -if lang.IsTruthy(v8) { -v4 = v3 -} else { -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("find-ns")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{v3}) -var v9 any = v13 -_ = v9 -var v15 any -if lang.IsTruthy(v9) { -v15 = v9 -} else { -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("str")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{"No namespace: ", v3, " found"}) -v20 := lang.Apply(lang.NewError, []any{v19}) -panic(v20) -} -v4 = v15 -} -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// thread-bound? -{ -v0 := lang.NewSymbol("thread-bound?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("vars"))), lang.NewKeyword("doc"), "Returns true if all of the vars provided as arguments have thread-local bindings.\n Implies that set!'ing the provided vars will succeed. Returns true if no vars are provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5499), lang.NewKeyword("end-line"), int(5499))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewList(args[0:]...) -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("every?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -var v7 lang.FnFunc -v7 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v8 := args[0] -v9, ok := lang.FieldOrMethod(v8, "getThreadBinding") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "getThreadBinding"))) -} -var v10 any -switch reflect.TypeOf(v9).Kind() { -case reflect.Func: - v10 = lang.Apply(v9, nil) -default: - v10 = v9 -} -return v10 -}) -v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5505), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5505), lang.NewKeyword("end-column"), int(78)) -v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v10 := lang.Apply(v6, []any{v9, v3}) -return v10 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// throw-if -{ -v0 := lang.NewSymbol("throw-if").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("fmt"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Throws a CompilerException with a message if pred is true", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5832), lang.NewKeyword("end-line"), int(5832), lang.NewKeyword("private"), true)).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -var v6 any -if lang.IsTruthy(v3) { -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("apply")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("format")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v10, []any{v13, v4, v5}) -var v7 any = v14 -_ = v7 -v16 := lang.Apply(lang.NewError, []any{v7}) -var v15 any = v16 -_ = v15 -v18, ok := lang.FieldOrMethod(v15, "getStackTrace") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v15, "getStackTrace"))) -} -var v19 any -switch reflect.TypeOf(v18).Kind() { -case reflect.Func: - v19 = lang.Apply(v18, nil) -default: - v19 = v18 -} -var v17 any = v19 -_ = v17 -var v21 lang.FnFunc -v21 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v22 := args[0] -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("not=")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26, ok := lang.FieldOrMethod(v22, "getMethodName") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v22, "getMethodName"))) -} -var v27 any -switch reflect.TypeOf(v26).Kind() { -case reflect.Func: - v27 = lang.Apply(v26, nil) -default: - v27 = v26 -} -v28 := lang.Apply(v25, []any{v27, "doInvoke"}) -return v28 -}) -v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5839), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(5839), lang.NewKeyword("end-column"), int(74)) -v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v20 any = v23 -_ = v20 -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("into-array")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("drop")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("drop-while")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v20, v17}) -v35 := lang.Apply(v30, []any{int64(2), v34}) -v36 := lang.Apply(v27, []any{nil, v35}) -var v24 any = v36 -_ = v24 -v38, _ := lang.FieldOrMethod(v15, "setStackTrace") -if reflect.TypeOf(v38).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setStackTrace is not a function"))) -} -v39 := lang.Apply(v38, []any{v24}) -_ = v39 -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("*file*")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43, ok := lang.FieldOrMethod(nil, "Deref") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "Deref"))) -} -var v44 any -switch reflect.TypeOf(v43).Kind() { -case reflect.Func: - v44 = lang.Apply(v43, nil) -default: - v44 = v43 -} -v45, ok := lang.FieldOrMethod(nil, "Deref") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "Deref"))) -} -var v46 any -switch reflect.TypeOf(v45).Kind() { -case reflect.Func: - v46 = lang.Apply(v45, nil) -default: - v46 = v45 -} -v47 := lang.Apply(lang.NewCompilerError, []any{v42, v44, v46, v15}) -panic(v47) -} else { -v6 = nil -} -return v6 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// time -{ -v0 := lang.NewSymbol("time").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"))), lang.NewKeyword("doc"), "Evaluates expr and prints the time it took. Returns the value of\n expr.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3885), lang.NewKeyword("end-line"), int(3885))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("seq")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("concat")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("list")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{lang.NewSymbol("glojure.core/let")}) -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("list")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("apply")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("vector")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("seq")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("concat")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{lang.NewSymbol("start__0__auto__")}) -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("list")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("seq")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("concat")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{lang.NewSymbol(".UnixNano")}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v52 := v51.FindInternedVar(lang.NewSymbol("seq")) -if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) -} -v53 := v52.Get() -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("concat")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) -} -v56 := v55.Get() -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("list")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) -} -v59 := v58.Get() -v60 := lang.Apply(v59, []any{lang.NewSymbol("time.Now")}) -v61 := lang.Apply(v56, []any{v60}) -v62 := lang.Apply(v53, []any{v61}) -v63 := lang.Apply(v50, []any{v62}) -v64 := lang.Apply(v43, []any{v47, v63}) -v65 := lang.Apply(v40, []any{v64}) -v66 := lang.Apply(v37, []any{v65}) -v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v68 := v67.FindInternedVar(lang.NewSymbol("list")) -if v68.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) -} -v69 := v68.Get() -v70 := lang.Apply(v69, []any{lang.NewSymbol("ret__1__auto__")}) -v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v72 := v71.FindInternedVar(lang.NewSymbol("list")) -if v72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) -} -v73 := v72.Get() -v74 := lang.Apply(v73, []any{v5}) -v75 := lang.Apply(v30, []any{v34, v66, v70, v74}) -v76 := lang.Apply(v27, []any{v75}) -v77 := lang.Apply(v21, []any{v24, v76}) -v78 := lang.Apply(v18, []any{v77}) -v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v80 := v79.FindInternedVar(lang.NewSymbol("list")) -if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) -} -v81 := v80.Get() -v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v83 := v82.FindInternedVar(lang.NewSymbol("seq")) -if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) -} -v84 := v83.Get() -v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v86 := v85.FindInternedVar(lang.NewSymbol("concat")) -if v86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) -} -v87 := v86.Get() -v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v89 := v88.FindInternedVar(lang.NewSymbol("list")) -if v89.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) -} -v90 := v89.Get() -v91 := lang.Apply(v90, []any{lang.NewSymbol("glojure.core/prn")}) -v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v93 := v92.FindInternedVar(lang.NewSymbol("list")) -if v93.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) -} -v94 := v93.Get() -v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v96 := v95.FindInternedVar(lang.NewSymbol("seq")) -if v96.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) -} -v97 := v96.Get() -v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v99 := v98.FindInternedVar(lang.NewSymbol("concat")) -if v99.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) -} -v100 := v99.Get() -v101 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v102 := v101.FindInternedVar(lang.NewSymbol("list")) -if v102.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v102))) -} -v103 := v102.Get() -v104 := lang.Apply(v103, []any{lang.NewSymbol("glojure.core/str")}) -v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v106 := v105.FindInternedVar(lang.NewSymbol("list")) -if v106.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) -} -v107 := v106.Get() -v108 := lang.Apply(v107, []any{"Elapsed time: "}) -v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v110 := v109.FindInternedVar(lang.NewSymbol("list")) -if v110.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) -} -v111 := v110.Get() -v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v113 := v112.FindInternedVar(lang.NewSymbol("seq")) -if v113.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) -} -v114 := v113.Get() -v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v116 := v115.FindInternedVar(lang.NewSymbol("concat")) -if v116.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) -} -v117 := v116.Get() -v118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v119 := v118.FindInternedVar(lang.NewSymbol("list")) -if v119.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v119))) -} -v120 := v119.Get() -v121 := lang.Apply(v120, []any{lang.NewSymbol("glojure.core//")}) -v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v123 := v122.FindInternedVar(lang.NewSymbol("list")) -if v123.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) -} -v124 := v123.Get() -v125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v126 := v125.FindInternedVar(lang.NewSymbol("seq")) -if v126.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v126))) -} -v127 := v126.Get() -v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v129 := v128.FindInternedVar(lang.NewSymbol("concat")) -if v129.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v129))) -} -v130 := v129.Get() -v131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v132 := v131.FindInternedVar(lang.NewSymbol("list")) -if v132.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v132))) -} -v133 := v132.Get() -v134 := lang.Apply(v133, []any{lang.NewSymbol("glojure.core/double")}) -v135 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v136 := v135.FindInternedVar(lang.NewSymbol("list")) -if v136.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v136))) -} -v137 := v136.Get() -v138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v139 := v138.FindInternedVar(lang.NewSymbol("seq")) -if v139.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v139))) -} -v140 := v139.Get() -v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v142 := v141.FindInternedVar(lang.NewSymbol("concat")) -if v142.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) -} -v143 := v142.Get() -v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v145 := v144.FindInternedVar(lang.NewSymbol("list")) -if v145.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) -} -v146 := v145.Get() -v147 := lang.Apply(v146, []any{lang.NewSymbol("glojure.core/-")}) -v148 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v149 := v148.FindInternedVar(lang.NewSymbol("list")) -if v149.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v149))) -} -v150 := v149.Get() -v151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v152 := v151.FindInternedVar(lang.NewSymbol("seq")) -if v152.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v152))) -} -v153 := v152.Get() -v154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v155 := v154.FindInternedVar(lang.NewSymbol("concat")) -if v155.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v155))) -} -v156 := v155.Get() -v157 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v158 := v157.FindInternedVar(lang.NewSymbol("list")) -if v158.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v158))) -} -v159 := v158.Get() -v160 := lang.Apply(v159, []any{lang.NewSymbol(".UnixNano")}) -v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v162 := v161.FindInternedVar(lang.NewSymbol("list")) -if v162.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) -} -v163 := v162.Get() -v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v165 := v164.FindInternedVar(lang.NewSymbol("seq")) -if v165.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) -} -v166 := v165.Get() -v167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v168 := v167.FindInternedVar(lang.NewSymbol("concat")) -if v168.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v168))) -} -v169 := v168.Get() -v170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v171 := v170.FindInternedVar(lang.NewSymbol("list")) -if v171.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v171))) -} -v172 := v171.Get() -v173 := lang.Apply(v172, []any{lang.NewSymbol("time.Now")}) -v174 := lang.Apply(v169, []any{v173}) -v175 := lang.Apply(v166, []any{v174}) -v176 := lang.Apply(v163, []any{v175}) -v177 := lang.Apply(v156, []any{v160, v176}) -v178 := lang.Apply(v153, []any{v177}) -v179 := lang.Apply(v150, []any{v178}) -v180 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v181 := v180.FindInternedVar(lang.NewSymbol("list")) -if v181.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v181))) -} -v182 := v181.Get() -v183 := lang.Apply(v182, []any{lang.NewSymbol("start__0__auto__")}) -v184 := lang.Apply(v143, []any{v147, v179, v183}) -v185 := lang.Apply(v140, []any{v184}) -v186 := lang.Apply(v137, []any{v185}) -v187 := lang.Apply(v130, []any{v134, v186}) -v188 := lang.Apply(v127, []any{v187}) -v189 := lang.Apply(v124, []any{v188}) -v190 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v191 := v190.FindInternedVar(lang.NewSymbol("list")) -if v191.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v191))) -} -v192 := v191.Get() -v193 := lang.Apply(v192, []any{nil}) -v194 := lang.Apply(v117, []any{v121, v189, v193}) -v195 := lang.Apply(v114, []any{v194}) -v196 := lang.Apply(v111, []any{v195}) -v197 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v198 := v197.FindInternedVar(lang.NewSymbol("list")) -if v198.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v198))) -} -v199 := v198.Get() -v200 := lang.Apply(v199, []any{" msecs"}) -v201 := lang.Apply(v100, []any{v104, v108, v196, v200}) -v202 := lang.Apply(v97, []any{v201}) -v203 := lang.Apply(v94, []any{v202}) -v204 := lang.Apply(v87, []any{v91, v203}) -v205 := lang.Apply(v84, []any{v204}) -v206 := lang.Apply(v81, []any{v205}) -v207 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v208 := v207.FindInternedVar(lang.NewSymbol("list")) -if v208.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v208))) -} -v209 := v208.Get() -v210 := lang.Apply(v209, []any{lang.NewSymbol("ret__1__auto__")}) -v211 := lang.Apply(v11, []any{v15, v78, v206, v210}) -v212 := lang.Apply(v8, []any{v211}) -return v212 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// to-array -{ -v0 := lang.NewSymbol("to-array").WithMeta(lang.NewMap(lang.NewKeyword("tag"), "[Ljava.lang.Object;", lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns an array of Objects containing the contents of coll, which\n can be any Collection. Maps to java.util.Collection.toArray().", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(337), lang.NewKeyword("end-line"), int(337))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, _ := lang.FieldOrMethod(runtime5.RT, "ToArray") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ToArray is not a function"))) -} -v5 := lang.Apply(v4, []any{v3}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), "[Ljava.lang.Object;")).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// to-array-2d -{ -v0 := lang.NewSymbol("to-array-2d").WithMeta(lang.NewMap(lang.NewKeyword("tag"), "[[Ljava.lang.Object;", lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a (potentially-ragged) 2-dimensional array of Objects\n containing the contents of coll, which can be any Collection of any\n Collection.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4002), lang.NewKeyword("end-line"), int(4002))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("make-array")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8, _ := lang.FieldOrMethod(reflect.Type, "forName") -if reflect.TypeOf(v8).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("forName is not a function"))) -} -v9 := lang.Apply(v8, []any{"[Ljava.lang.Object;"}) -v10, _ := lang.FieldOrMethod(v3, "size") -if reflect.TypeOf(v10).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("size is not a function"))) -} -v11 := lang.Apply(v10, []any{}) -v12 := lang.Apply(v7, []any{v9, v11}) -var v4 any = v12 -_ = v4 -var v14 any = int64(0) -_ = v14 -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("seq")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v3}) -var v15 any = v19 -_ = v15 -var v20 any -for { -var v21 any -if lang.IsTruthy(v15) { -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("aset")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("to-array")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("first")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{v15}) -v32 := lang.Apply(v27, []any{v31}) -v33 := lang.Apply(v24, []any{v4, v14, v32}) -_ = v33 -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("inc")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v14}) -var v34 any = v38 -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("next")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v15}) -var v39 any = v43 -v14 = v34 -v15 = v39 -continue -} else { -v21 = nil -} -v20 = v21 - break -} -_ = v20 -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), "[[Ljava.lang.Object;")).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// trampoline -{ -v0 := lang.NewSymbol("trampoline").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "trampoline can be used to convert algorithms requiring mutual\n recursion without stack consumption. Calls f with supplied args, if\n any. If f returns a fn, calls that fn with no arguments, and\n continues to repeat, until the return value is not a fn, then\n returns that non-fn value. Note that if you want to return a fn as a\n final value, you must wrap it in some data structure and unpack it\n after trampoline returns.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6293), lang.NewKeyword("end-line"), int(6293))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: -v3 := args[0] -recur_loop_1073: -v5 := lang.Apply(v3, nil) -var v4 any = v5 -_ = v4 -var v7 any -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("fn?")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v4}) -if lang.IsTruthy(v11) { -var v12 any = v4 -v3 = v12 -goto recur_loop_1073 -} else { -v7 = v4 -} -return v7 - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.NewList(args[1:]...) -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("trampoline")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -var v8 lang.FnFunc -v8 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("apply")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v3, v4}) -return v12 -}) -v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6309), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(6309), lang.NewKeyword("end-column"), int(32)) -v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v11 := lang.Apply(v7, []any{v10}) -return v11 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// transduce -{ -v0 := lang.NewSymbol("transduce").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "reduce with a transformation of f (xf). If init is not\n supplied, (f) will be called to produce it. f should be a reducing\n step function that accepts both 1 and 2 arguments, if it accepts\n only 2 you can add the arity-1 with 'completing'. Returns the result\n of applying (the transformed) xf to init and the first item in coll,\n then applying xf to that result and the 2nd item, etc. If coll\n contains no items, returns init and f is not called. Note that\n certain transforms may inject or skip items.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6905), lang.NewKeyword("end-line"), int(6905))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("transduce")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v4, nil) -v10 := lang.Apply(v8, []any{v3, v4, v9, v5}) -return v10 - case 4: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v8 := lang.Apply(v3, []any{v7}) -var v7 any = v8 -_ = v7 -var v10 any -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("instance?")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{lang.IReduceInit, v6}) -if lang.IsTruthy(v14) { -v15, _ := lang.FieldOrMethod(v6, "ReduceInit") -if reflect.TypeOf(v15).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) -} -v16 := lang.Apply(v15, []any{v7, v5}) -v10 = v16 -} else { -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core.protocols")) -v18 := v17.FindInternedVar(lang.NewSymbol("coll-reduce")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v6, v7, v5}) -v10 = v20 -} -var v9 any = v10 -_ = v9 -v22 := lang.Apply(v7, []any{v9}) -return v22 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// transient -{ -v0 := lang.NewSymbol("transient").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a new, transient version of the collection, in constant time.\n\n Transients support a parallel set of 'changing' operations, with similar names\n followed by ! - assoc!, conj! etc. These do the same things as their persistent\n counterparts except the return values are themselves transient.\n\n Note in particular that transients are not designed to be bashed in-place. You\n must capture and use the return value in the next call. In this way, they support\n the same code structure as the functional persistent code they replace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3335), lang.NewKeyword("end-line"), int(3335))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, ok := lang.FieldOrMethod(v3, "AsTransient") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "AsTransient"))) -} -var v5 any -switch reflect.TypeOf(v4).Kind() { -case reflect.Func: - v5 = lang.Apply(v4, nil) -default: - v5 = v4 -} -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// tree-seq -{ -v0 := lang.NewSymbol("tree-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("branch?"), lang.NewSymbol("children"), lang.NewSymbol("root"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the nodes in a tree, via a depth-first walk.\n branch? must be a fn of one arg that returns true if passed a node\n that can have children (but may not). children must be a fn of one\n arg that returns a sequence of the children. Will only be called on\n nodes for which branch? returns true. Root is the root node of the\n tree.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4955), lang.NewKeyword("end-line"), int(4955))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -var v7 lang.FnFunc -{ // function walk -v7 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v9 := args[0] -var v10 lang.FnFunc -v10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("cons")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -var v14 any -v15 := lang.Apply(v3, []any{v9}) -if lang.IsTruthy(v15) { -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("mapcat")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v4, []any{v9}) -v20 := lang.Apply(v18, []any{v8, v19}) -v14 = v20 -} else { -v14 = nil -} -v21 := lang.Apply(v13, []any{v9, v14}) -return v21 -}) -v11 := lang.Apply(lang.NewLazySeq, []any{v10}) -return v11 -}) -v8 := v7 -_ = v8 -} -v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4965), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(4969), lang.NewKeyword("end-column"), int(53)) -v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v6 any = v9 -_ = v6 -v11 := lang.Apply(v6, []any{v5}) -return v11 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// true? -{ -v1 := reflect.TypeOf(false) -v0 := lang.NewSymbol("true?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is the value true, false otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(511), lang.NewKeyword("end-line"), int(511))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := lang.Apply(lang.Identical, []any{v4, true}) -return v5 -}) -v4 := reflect.TypeOf(false) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// type -{ -v0 := lang.NewSymbol("type").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns the :type metadata of x, or its Class if none", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3467), lang.NewKeyword("end-line"), int(3467))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("get")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("meta")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v3}) -v12 := lang.Apply(v7, []any{v11, lang.NewKeyword("type")}) -var v4 any = v12 -_ = v4 -var v14 any -if lang.IsTruthy(v4) { -v14 = v4 -} else { -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("class")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v3}) -v14 = v18 -} -return v14 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// unchecked-add -{ -var v1 lang.FnFunc -{ // function unchecked-add__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("concat")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("list")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("seq")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("concat")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("list")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/unchecked_add")}) -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v4}) -v40 := lang.Apply(v27, []any{v31, v35, v39}) -v41 := lang.Apply(v24, []any{v40}) -v42 := lang.Apply(v21, []any{v41}) -v43 := lang.Apply(v10, []any{v14, v18, v42}) -v44 := lang.Apply(v7, []any{v43}) -return v44 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("unchecked-add").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the sum of x and y, both long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1203), lang.NewKeyword("end-line"), int(1203))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_add") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_add is not a function"))) -} -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// unchecked-add-int -{ -var v1 lang.FnFunc -{ // function unchecked-add-int__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("concat")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("list")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("seq")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("concat")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("list")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/unchecked_int_add")}) -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v4}) -v40 := lang.Apply(v27, []any{v31, v35, v39}) -v41 := lang.Apply(v24, []any{v40}) -v42 := lang.Apply(v21, []any{v41}) -v43 := lang.Apply(v10, []any{v14, v18, v42}) -v44 := lang.Apply(v7, []any{v43}) -return v44 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("unchecked-add-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the sum of x and y, both int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1196), lang.NewKeyword("end-line"), int(1196))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_int_add") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_add is not a function"))) -} -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// unchecked-byte -{ -var v1 lang.FnFunc -{ // function unchecked-byte__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/UncheckedByteCast")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v3}) -v35 := lang.Apply(v26, []any{v30, v34}) -v36 := lang.Apply(v23, []any{v35}) -v37 := lang.Apply(v20, []any{v36}) -v38 := lang.Apply(v9, []any{v13, v17, v37}) -v39 := lang.Apply(v6, []any{v38}) -return v39 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("unchecked-byte").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to byte. Subject to rounding or truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3517), lang.NewKeyword("end-line"), int(3517))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := lang.Apply(lang.UncheckedByteCast, []any{v4}) -return v5 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// unchecked-char -{ -var v1 lang.FnFunc -{ // function unchecked-char__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/UncheckedCharCast")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v3}) -v35 := lang.Apply(v26, []any{v30, v34}) -v36 := lang.Apply(v23, []any{v35}) -v37 := lang.Apply(v20, []any{v36}) -v38 := lang.Apply(v9, []any{v13, v17, v37}) -v39 := lang.Apply(v6, []any{v38}) -return v39 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("unchecked-char").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to char. Subject to rounding or truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3529), lang.NewKeyword("end-line"), int(3529))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5, _ := lang.FieldOrMethod(runtime5.RT, "UncheckedCharCast") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedCharCast is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// unchecked-dec -{ -var v1 lang.FnFunc -{ // function unchecked-dec__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/unchecked_dec")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v3}) -v35 := lang.Apply(v26, []any{v30, v34}) -v36 := lang.Apply(v23, []any{v35}) -v37 := lang.Apply(v20, []any{v36}) -v38 := lang.Apply(v9, []any{v13, v17, v37}) -v39 := lang.Apply(v6, []any{v38}) -return v39 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("unchecked-dec").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns a number one less than x, a long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1175), lang.NewKeyword("end-line"), int(1175))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_dec") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_dec is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// unchecked-dec-int -{ -var v1 lang.FnFunc -{ // function unchecked-dec-int__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/unchecked_int_dec")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v3}) -v35 := lang.Apply(v26, []any{v30, v34}) -v36 := lang.Apply(v23, []any{v35}) -v37 := lang.Apply(v20, []any{v36}) -v38 := lang.Apply(v9, []any{v13, v17, v37}) -v39 := lang.Apply(v6, []any{v38}) -return v39 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("unchecked-dec-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns a number one less than x, an int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1168), lang.NewKeyword("end-line"), int(1168))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_int_dec") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_dec is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// unchecked-divide-int -{ -var v1 lang.FnFunc -{ // function unchecked-divide-int__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("concat")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("list")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("seq")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("concat")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("list")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/unchecked_int_divide")}) -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v4}) -v40 := lang.Apply(v27, []any{v31, v35, v39}) -v41 := lang.Apply(v24, []any{v40}) -v42 := lang.Apply(v21, []any{v41}) -v43 := lang.Apply(v10, []any{v14, v18, v42}) -v44 := lang.Apply(v7, []any{v43}) -return v44 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("unchecked-divide-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the division of x by y, both int.\n Note - uses a primitive operator subject to truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(26), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1238), lang.NewKeyword("end-line"), int(1238))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_int_divide") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_divide is not a function"))) -} -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// unchecked-double -{ -var v1 lang.FnFunc -{ // function unchecked-double__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/UncheckedDoubleCast")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v3}) -v35 := lang.Apply(v26, []any{v30, v34}) -v36 := lang.Apply(v23, []any{v35}) -v37 := lang.Apply(v20, []any{v36}) -v38 := lang.Apply(v9, []any{v13, v17, v37}) -v39 := lang.Apply(v6, []any{v38}) -return v39 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("unchecked-double").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to double. Subject to rounding.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3553), lang.NewKeyword("end-line"), int(3553))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := lang.Apply(lang.AsFloat64, []any{v4}) -return v5 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// unchecked-float -{ -var v1 lang.FnFunc -{ // function unchecked-float__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/UncheckedFloatCast")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v3}) -v35 := lang.Apply(v26, []any{v30, v34}) -v36 := lang.Apply(v23, []any{v35}) -v37 := lang.Apply(v20, []any{v36}) -v38 := lang.Apply(v9, []any{v13, v17, v37}) -v39 := lang.Apply(v6, []any{v38}) -return v39 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("unchecked-float").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to float. Subject to rounding.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3547), lang.NewKeyword("end-line"), int(3547))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := lang.Apply(lang.UncheckedFloatCast, []any{v4}) -return v5 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// unchecked-inc -{ -var v1 lang.FnFunc -{ // function unchecked-inc__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/unchecked_inc")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v3}) -v35 := lang.Apply(v26, []any{v30, v34}) -v36 := lang.Apply(v23, []any{v35}) -v37 := lang.Apply(v20, []any{v36}) -v38 := lang.Apply(v9, []any{v13, v17, v37}) -v39 := lang.Apply(v6, []any{v38}) -return v39 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("unchecked-inc").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns a number one greater than x, a long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1161), lang.NewKeyword("end-line"), int(1161))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_inc") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_inc is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// unchecked-inc-int -{ -var v1 lang.FnFunc -{ // function unchecked-inc-int__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/unchecked_int_inc")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v3}) -v35 := lang.Apply(v26, []any{v30, v34}) -v36 := lang.Apply(v23, []any{v35}) -v37 := lang.Apply(v20, []any{v36}) -v38 := lang.Apply(v9, []any{v13, v17, v37}) -v39 := lang.Apply(v6, []any{v38}) -return v39 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("unchecked-inc-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns a number one greater than x, an int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1154), lang.NewKeyword("end-line"), int(1154))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_int_inc") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_inc is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// unchecked-int -{ -var v1 lang.FnFunc -{ // function unchecked-int__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/UncheckedIntCast")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v3}) -v35 := lang.Apply(v26, []any{v30, v34}) -v36 := lang.Apply(v23, []any{v35}) -v37 := lang.Apply(v20, []any{v36}) -v38 := lang.Apply(v9, []any{v13, v17, v37}) -v39 := lang.Apply(v6, []any{v38}) -return v39 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("unchecked-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to int. Subject to rounding or truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3535), lang.NewKeyword("end-line"), int(3535))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := lang.Apply(lang.UncheckedIntCast, []any{v4}) -return v5 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// unchecked-long -{ -var v1 lang.FnFunc -{ // function unchecked-long__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/UncheckedLongCast")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v3}) -v35 := lang.Apply(v26, []any{v30, v34}) -v36 := lang.Apply(v23, []any{v35}) -v37 := lang.Apply(v20, []any{v36}) -v38 := lang.Apply(v9, []any{v13, v17, v37}) -v39 := lang.Apply(v6, []any{v38}) -return v39 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("unchecked-long").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to long. Subject to rounding or truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3541), lang.NewKeyword("end-line"), int(3541))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := lang.Apply(lang.UncheckedLongCast, []any{v4}) -return v5 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// unchecked-multiply -{ -var v1 lang.FnFunc -{ // function unchecked-multiply__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("concat")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("list")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("seq")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("concat")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("list")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/unchecked_multiply")}) -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v4}) -v40 := lang.Apply(v27, []any{v31, v35, v39}) -v41 := lang.Apply(v24, []any{v40}) -v42 := lang.Apply(v21, []any{v41}) -v43 := lang.Apply(v10, []any{v14, v18, v42}) -v44 := lang.Apply(v7, []any{v43}) -return v44 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("unchecked-multiply").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the product of x and y, both long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1231), lang.NewKeyword("end-line"), int(1231))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_multiply") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_multiply is not a function"))) -} -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// unchecked-multiply-int -{ -var v1 lang.FnFunc -{ // function unchecked-multiply-int__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("concat")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("list")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("seq")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("concat")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("list")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/unchecked_int_multiply")}) -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v4}) -v40 := lang.Apply(v27, []any{v31, v35, v39}) -v41 := lang.Apply(v24, []any{v40}) -v42 := lang.Apply(v21, []any{v41}) -v43 := lang.Apply(v10, []any{v14, v18, v42}) -v44 := lang.Apply(v7, []any{v43}) -return v44 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("unchecked-multiply-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the product of x and y, both int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1224), lang.NewKeyword("end-line"), int(1224))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_int_multiply") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_multiply is not a function"))) -} -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// unchecked-negate -{ -var v1 lang.FnFunc -{ // function unchecked-negate__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/unchecked_minus")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v3}) -v35 := lang.Apply(v26, []any{v30, v34}) -v36 := lang.Apply(v23, []any{v35}) -v37 := lang.Apply(v20, []any{v36}) -v38 := lang.Apply(v9, []any{v13, v17, v37}) -v39 := lang.Apply(v6, []any{v38}) -return v39 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("unchecked-negate").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the negation of x, a long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1189), lang.NewKeyword("end-line"), int(1189))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_negate") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_negate is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// unchecked-negate-int -{ -var v1 lang.FnFunc -{ // function unchecked-negate-int__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/unchecked_int_negate")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v3}) -v35 := lang.Apply(v26, []any{v30, v34}) -v36 := lang.Apply(v23, []any{v35}) -v37 := lang.Apply(v20, []any{v36}) -v38 := lang.Apply(v9, []any{v13, v17, v37}) -v39 := lang.Apply(v6, []any{v38}) -return v39 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("unchecked-negate-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the negation of x, an int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(26), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1182), lang.NewKeyword("end-line"), int(1182))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_int_negate") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_negate is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// unchecked-remainder-int -{ -var v1 lang.FnFunc -{ // function unchecked-remainder-int__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("concat")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("list")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("seq")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("concat")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("list")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/unchecked_int_remainder")}) -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v4}) -v40 := lang.Apply(v27, []any{v31, v35, v39}) -v41 := lang.Apply(v24, []any{v40}) -v42 := lang.Apply(v21, []any{v41}) -v43 := lang.Apply(v10, []any{v14, v18, v42}) -v44 := lang.Apply(v7, []any{v43}) -return v44 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("unchecked-remainder-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the remainder of division of x by y, both int.\n Note - uses a primitive operator subject to truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(29), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1245), lang.NewKeyword("end-line"), int(1245))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_int_remainder") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_remainder is not a function"))) -} -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// unchecked-short -{ -var v1 lang.FnFunc -{ // function unchecked-short__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/UncheckedShortCast")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v3}) -v35 := lang.Apply(v26, []any{v30, v34}) -v36 := lang.Apply(v23, []any{v35}) -v37 := lang.Apply(v20, []any{v36}) -v38 := lang.Apply(v9, []any{v13, v17, v37}) -v39 := lang.Apply(v6, []any{v38}) -return v39 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("unchecked-short").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to short. Subject to rounding or truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3523), lang.NewKeyword("end-line"), int(3523))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := lang.Apply(lang.UncheckedShortCast, []any{v4}) -return v5 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// unchecked-subtract -{ -var v1 lang.FnFunc -{ // function unchecked-subtract__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("concat")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("list")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("seq")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("concat")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("list")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/unchecked_minus")}) -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v4}) -v40 := lang.Apply(v27, []any{v31, v35, v39}) -v41 := lang.Apply(v24, []any{v40}) -v42 := lang.Apply(v21, []any{v41}) -v43 := lang.Apply(v10, []any{v14, v18, v42}) -v44 := lang.Apply(v7, []any{v43}) -return v44 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("unchecked-subtract").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the difference of x and y, both long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1217), lang.NewKeyword("end-line"), int(1217))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_minus") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_minus is not a function"))) -} -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// unchecked-subtract-int -{ -var v1 lang.FnFunc -{ // function unchecked-subtract-int__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("concat")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("list")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("seq")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("concat")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("list")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/unchecked_int_subtract")}) -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v4}) -v40 := lang.Apply(v27, []any{v31, v35, v39}) -v41 := lang.Apply(v24, []any{v40}) -v42 := lang.Apply(v21, []any{v41}) -v43 := lang.Apply(v10, []any{v14, v18, v42}) -v44 := lang.Apply(v7, []any{v43}) -return v44 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("unchecked-subtract-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the difference of x and y, both int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1210), lang.NewKeyword("end-line"), int(1210))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_int_subtract") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_subtract is not a function"))) -} -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// underive -{ -v0 := lang.NewSymbol("underive").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag"), lang.NewSymbol("parent")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"), lang.NewSymbol("parent"))), lang.NewKeyword("doc"), "Removes a parent/child relationship between parent and\n tag. h must be a hierarchy obtained from make-hierarchy, if not\n supplied defaults to, and modifies, the global hierarchy.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5643), lang.NewKeyword("end-line"), int(5643))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("alter-var-root")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("global-hierarchy")) -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("underive")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v7, []any{v8, v11, v3, v4}) -_ = v12 -return nil - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v7 := lang.Apply(lang.NewKeyword("parents"), []any{v3}) -var v6 any = v7 -_ = v6 -var v9 any -v10 := lang.Apply(v6, []any{v4}) -if lang.IsTruthy(v10) { -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("disj")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v6, []any{v4}) -v15 := lang.Apply(v13, []any{v14, v5}) -v9 = v15 -} else { -v16 := lang.CreatePersistentTreeSet() -v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5652), lang.NewKeyword("column"), int(36), lang.NewKeyword("end-line"), int(5652), lang.NewKeyword("end-column"), int(38)) -v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v9 = v18 -} -var v8 any = v9 -_ = v8 -var v20 any -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("not-empty")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v8}) -if lang.IsTruthy(v24) { -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("assoc")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.Apply(v27, []any{v6, v4, v8}) -v20 = v28 -} else { -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("dissoc")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.Apply(v31, []any{v6, v4}) -v20 = v32 -} -var v19 any = v20 -_ = v19 -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("flatten")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("map")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -var v40 lang.FnFunc -v40 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v41 := args[0] -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("cons")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) -} -v44 := v43.Get() -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("key")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.Apply(v47, []any{v41}) -v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v50 := v49.FindInternedVar(lang.NewSymbol("interpose")) -if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) -} -v51 := v50.Get() -v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("key")) -if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) -} -v54 := v53.Get() -v55 := lang.Apply(v54, []any{v41}) -v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v57 := v56.FindInternedVar(lang.NewSymbol("val")) -if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) -} -v58 := v57.Get() -v59 := lang.Apply(v58, []any{v41}) -v60 := lang.Apply(v51, []any{v55, v59}) -v61 := lang.Apply(v44, []any{v48, v60}) -return v61 -}) -v41 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5656), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(5656), lang.NewKeyword("end-column"), int(70)) -v42, err := lang.WithMeta(v40, v41.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("seq")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.Apply(v45, []any{v19}) -v47 := lang.Apply(v39, []any{v42, v46}) -v48 := lang.Apply(v36, []any{v47}) -var v33 any = v48 -_ = v33 -var v50 any -v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v52 := v51.FindInternedVar(lang.NewSymbol("contains?")) -if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) -} -v53 := v52.Get() -v54 := lang.Apply(v6, []any{v4}) -v55 := lang.Apply(v53, []any{v54, v5}) -if lang.IsTruthy(v55) { -v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v57 := v56.FindInternedVar(lang.NewSymbol("reduce1")) -if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) -} -v58 := v57.Get() -var v59 lang.FnFunc -v59 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v60 := args[0] -v61 := args[1] -v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v63 := v62.FindInternedVar(lang.NewSymbol("apply")) -if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) -} -v64 := v63.Get() -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("derive")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) -} -v67 := v66.Get() -v68 := lang.Apply(v64, []any{v67, v60, v61}) -return v68 -}) -v60 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5659), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5659), lang.NewKeyword("end-column"), int(31)) -v61, err := lang.WithMeta(v59, v60.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v63 := v62.FindInternedVar(lang.NewSymbol("make-hierarchy")) -if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) -} -v64 := v63.Get() -v65 := lang.Apply(v64, nil) -v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v67 := v66.FindInternedVar(lang.NewSymbol("partition")) -if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) -} -v68 := v67.Get() -v69 := lang.Apply(v68, []any{int64(2), v33}) -v70 := lang.Apply(v58, []any{v61, v65, v69}) -v50 = v70 -} else { -v50 = v3 -} -return v50 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// unquote -{ -v0 := lang.NewSymbol("unquote").WithMeta(lang.NewMap()).(*lang.Symbol) -v1 := ns.Intern(v0) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// unquote-splicing -{ -v0 := lang.NewSymbol("unquote-splicing").WithMeta(lang.NewMap()).(*lang.Symbol) -v1 := ns.Intern(v0) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// unreduced -{ -v0 := lang.NewSymbol("unreduced").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "If x is reduced?, returns (deref x), else returns x", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2847), lang.NewKeyword("end-line"), int(2847))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("reduced?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -if lang.IsTruthy(v8) { -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("deref")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v3}) -v4 = v12 -} else { -v4 = v3 -} -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// unsigned-bit-shift-right -{ -var v1 lang.FnFunc -{ // function unsigned-bit-shift-right__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("seq")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("concat")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("list")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("list")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("list")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("seq")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("concat")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("list")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/unsignedShiftRight")}) -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v3}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.Apply(v38, []any{v4}) -v40 := lang.Apply(v27, []any{v31, v35, v39}) -v41 := lang.Apply(v24, []any{v40}) -v42 := lang.Apply(v21, []any{v41}) -v43 := lang.Apply(v10, []any{v14, v18, v42}) -v44 := lang.Apply(v7, []any{v43}) -return v44 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("unsigned-bit-shift-right").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Bitwise shift right, without sign-extension.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(30), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1373), lang.NewKeyword("end-line"), int(1373))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6, _ := lang.FieldOrMethod(lang.Numbers, "unsignedShiftRight") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("unsignedShiftRight is not a function"))) -} -v7 := lang.Apply(v6, []any{v4, v5}) -return v7 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// update -{ -v0 := lang.NewSymbol("update").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f"), lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("z")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("z"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "'Updates' a value in an associative structure, where k is a\n key and f is a function that will take the old value\n and any supplied args and return the new value, and returns a new\n structure. If the key does not exist, nil is passed as the old value.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6174), lang.NewKeyword("end-line"), int(6174))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("assoc")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("get")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v3, v4}) -v13 := lang.Apply(v5, []any{v12}) -v14 := lang.Apply(v8, []any{v3, v4, v13}) -return v14 - case 4: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("assoc")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("get")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{v3, v4}) -v14 := lang.Apply(v5, []any{v13, v6}) -v15 := lang.Apply(v9, []any{v3, v4, v14}) -return v15 - case 5: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := args[4] -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("assoc")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("get")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, []any{v3, v4}) -v15 := lang.Apply(v5, []any{v14, v6, v7}) -v16 := lang.Apply(v10, []any{v3, v4, v15}) -return v16 - case 6: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := args[4] -v8 := args[5] -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("assoc")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("get")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v3, v4}) -v16 := lang.Apply(v5, []any{v15, v6, v7, v8}) -v17 := lang.Apply(v11, []any{v3, v4, v16}) -return v17 - default: - if len(args) < 6 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := args[4] -v8 := args[5] -v9 := lang.NewList(args[6:]...) -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("assoc")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("apply")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("get")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v3, v4}) -v20 := lang.Apply(v15, []any{v5, v19, v6, v7, v8, v9}) -v21 := lang.Apply(v12, []any{v3, v4, v20}) -return v21 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// update-in -{ -v0 := lang.NewSymbol("update-in").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("ks"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "'Updates' a value in a nested associative structure, where ks is a\n sequence of keys and f is a function that will take the old value\n and any supplied args and return the new value, and returns a new\n nested structure. If any levels do not exist, hash-maps will be\n created.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6158), lang.NewKeyword("end-line"), int(6158))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -var v8 lang.FnFunc -{ // function up -v8 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v10 := args[0] -v11 := args[1] -v12 := args[2] -v13 := args[3] -var v14 any = v11 -_ = v14 -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("seq")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v18, []any{v14}) -var v15 any = v19 -_ = v15 -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("first")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v23, []any{v15}) -var v20 any = v24 -_ = v20 -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("next")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.Apply(v28, []any{v25}) -var v25 any = v29 -_ = v25 -var v30 any = v20 -_ = v30 -var v31 any = v25 -_ = v31 -var v33 any -if lang.IsTruthy(v31) { -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("assoc")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("get")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v10, v30}) -v41 := lang.Apply(v9, []any{v40, v31, v12, v13}) -v42 := lang.Apply(v36, []any{v10, v30, v41}) -v33 = v42 -} else { -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("assoc")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("apply")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) -} -v48 := v47.Get() -v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v50 := v49.FindInternedVar(lang.NewSymbol("get")) -if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) -} -v51 := v50.Get() -v52 := lang.Apply(v51, []any{v10, v30}) -v53 := lang.Apply(v48, []any{v12, v52, v13}) -v54 := lang.Apply(v45, []any{v10, v30, v53}) -v33 = v54 -} -return v33 -}) -v9 := v8 -_ = v9 -} -v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6167), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(6171), lang.NewKeyword("end-column"), int(59)) -v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v7 any = v10 -_ = v7 -v12 := lang.Apply(v7, []any{v3, v4, v5, v6}) -return v12 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// update-keys -{ -v0 := lang.NewSymbol("update-keys").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("f"))), lang.NewKeyword("doc"), "m f => {(f k) v ...}\n\n Given a map m and a function f of 1-argument, returns a new map whose\n keys are the result of applying f to the keys of m, mapped to the\n corresponding values of m.\n f must return a unique key for each key of m, else the behavior is undefined.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7906), lang.NewKeyword("end-line"), int(7906))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("persistent!")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("reduce-kv")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -var v12 lang.FnFunc -v12 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v13 := args[0] -v14 := args[1] -v15 := args[2] -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("assoc!")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.Apply(v4, []any{v14}) -v20 := lang.Apply(v18, []any{v13, v19, v15}) -return v20 -}) -v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7916), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7916), lang.NewKeyword("end-column"), int(59)) -v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("transient")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.NewMap() -v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7917), lang.NewKeyword("column"), int(36), lang.NewKeyword("end-line"), int(7917), lang.NewKeyword("end-column"), int(37)) -v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v21 := lang.Apply(v17, []any{v20}) -v22 := lang.Apply(v11, []any{v14, v21, v3}) -v23 := lang.Apply(v8, []any{v22}) -var v5 any = v23 -_ = v5 -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("with-meta")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("meta")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{v3}) -v32 := lang.Apply(v27, []any{v5, v31}) -return v32 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// update-vals -{ -v0 := lang.NewSymbol("update-vals").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("f"))), lang.NewKeyword("doc"), "m f => {k (f v) ...}\n\n Given a map m and a function f of 1-argument, returns a new map where the keys of m\n are mapped to result of applying f to the corresponding values of m.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7890), lang.NewKeyword("end-line"), int(7890))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("with-meta")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("persistent!")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("reduce-kv")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -var v14 lang.FnFunc -v14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v15 := args[0] -v16 := args[1] -v17 := args[2] -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("assoc!")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v4, []any{v17}) -v22 := lang.Apply(v20, []any{v15, v16, v21}) -return v22 -}) -v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7899), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(7899), lang.NewKeyword("end-column"), int(51)) -v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v17 any -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("instance?")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v20, []any{lang.IEditableCollection, v3}) -if lang.IsTruthy(v21) { -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("transient")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v17 = v25 -} else { -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("transient")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.NewMap() -v30 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7902), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(7902), lang.NewKeyword("end-column"), int(31)) -v31, err := lang.WithMeta(v29, v30.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v32 := lang.Apply(v28, []any{v31}) -v17 = v32 -} -v33 := lang.Apply(v13, []any{v16, v17, v3}) -v34 := lang.Apply(v10, []any{v33}) -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("meta")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.Apply(v37, []any{v3}) -v39 := lang.Apply(v7, []any{v34, v38}) -return v39 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// uri? -{ -v0 := lang.NewSymbol("uri?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a java.net.URI", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7877), lang.NewKeyword("end-line"), int(7877))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{url23.URL, v3}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// use -{ -v0 := lang.NewSymbol("use").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Like 'require, but also refers to each lib's namespace using\n glojure.core/refer. Use :use in the ns macro in preference to calling\n this directly.\n\n 'use accepts additional options in libspecs: :exclude, :only, :rename.\n The arguments and semantics for :exclude, :only, and :rename are the same\n as those documented for glojure.core/refer.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6079), lang.NewKeyword("end-line"), int(6079))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := lang.NewList(args[0:]...) -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("apply")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("load-libs")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.Apply(v6, []any{v9, lang.NewKeyword("require"), lang.NewKeyword("use"), v3}) -return v10 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// uuid? -{ -v0 := lang.NewSymbol("uuid?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a java.util.UUID", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6847), lang.NewKeyword("end-line"), int(6847))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{uuid20.UUID, v3}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// val -{ -v0 := lang.NewSymbol("val").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("e"))), lang.NewKeyword("doc"), "Returns the value in the map entry.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1570), lang.NewKeyword("end-line"), int(1570))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, _ := lang.FieldOrMethod(v3, "GetValue") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("GetValue is not a function"))) -} -v5 := lang.Apply(v4, []any{}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// vals -{ -v0 := lang.NewSymbol("vals").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"))), lang.NewKeyword("doc"), "Returns a sequence of the map's values, in the same order as (seq map).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1557), lang.NewKeyword("end-line"), int(1557))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.Apply(lang.Vals, []any{v3}) -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// var-get -{ -v0 := lang.NewSymbol("var-get").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Gets the value in the var object", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4326), lang.NewKeyword("end-line"), int(4326))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4, _ := lang.FieldOrMethod(v3, "Get") -if reflect.TypeOf(v4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Get is not a function"))) -} -v5 := lang.Apply(v4, []any{}) -return v5 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// var-set -{ -v0 := lang.NewSymbol("var-set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Sets the value in the var object to val. The var must be\n thread-locally bound.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4332), lang.NewKeyword("end-line"), int(4332))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5, _ := lang.FieldOrMethod(v3, "Set") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Set is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// var? -{ -v0 := lang.NewSymbol("var?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("v"))), lang.NewKeyword("doc"), "Returns true if v is of type glojure.lang.Var", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4999), lang.NewKeyword("end-line"), int(4999))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{lang.*Var, v3}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// vary-meta -{ -v0 := lang.NewSymbol("vary-meta").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("obj"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Returns an object of the same type and value as obj, with\n (apply f (meta obj) args) as its metadata.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(668), lang.NewKeyword("end-line"), int(668))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("with-meta")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("apply")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("meta")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v3}) -v16 := lang.Apply(v11, []any{v4, v15, v5}) -v17 := lang.Apply(v8, []any{v3, v16}) -return v17 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// vec -{ -v0 := lang.NewSymbol("vec").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Creates a new vector containing the contents of coll. Java arrays\n will be aliased and should not be modified.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(366), lang.NewKeyword("end-line"), int(366))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -var v4 any -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("vector?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{v3}) -if lang.IsTruthy(v8) { -var v9 any -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("instance?")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.IObj, v3}) -if lang.IsTruthy(v13) { -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("with-meta")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v3, nil}) -v9 = v17 -} else { -v18 := lang.Apply(lang.CreateLazilyPersistentVector, []any{v3}) -v9 = v18 -} -v4 = v9 -} else { -v19 := lang.Apply(lang.CreateLazilyPersistentVector, []any{v3}) -v4 = v19 -} -return v4 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// vector -{ -v0 := lang.NewSymbol("vector").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("a")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d"), lang.NewSymbol("e")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d"), lang.NewSymbol("e"), lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d"), lang.NewSymbol("e"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Creates a new vector containing the args.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(352), lang.NewKeyword("end-line"), int(352))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: -v3 := lang.NewVector() -v4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(356), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(356), lang.NewKeyword("end-column"), int(8)) -v5, err := lang.WithMeta(v3, v4.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v5 - case 1: -v3 := args[0] -v4 := lang.NewVector(v3) -v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(357), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(357), lang.NewKeyword("end-column"), int(10)) -v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v6 - case 2: -v3 := args[0] -v4 := args[1] -v5 := lang.NewVector(v3, v4) -v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(358), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(358), lang.NewKeyword("end-column"), int(14)) -v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v7 - case 3: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewVector(v3, v4, v5) -v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(359), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(359), lang.NewKeyword("end-column"), int(18)) -v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v8 - case 4: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := lang.NewVector(v3, v4, v5, v6) -v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(360), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(360), lang.NewKeyword("end-column"), int(22)) -v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v9 - case 5: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := args[4] -v8 := lang.NewVector(v3, v4, v5, v6, v7) -v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(361), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(361), lang.NewKeyword("end-column"), int(25)) -v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v10 - case 6: -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := args[4] -v8 := args[5] -v9 := lang.NewVector(v3, v4, v5, v6, v7, v8) -v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(362), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(362), lang.NewKeyword("end-column"), int(29)) -v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -return v11 - default: - if len(args) < 6 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := args[4] -v8 := args[5] -v9 := lang.NewList(args[6:]...) -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("cons")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("cons")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("cons")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("cons")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("cons")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("cons")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.Apply(v27, []any{v8, v9}) -v29 := lang.Apply(v24, []any{v7, v28}) -v30 := lang.Apply(v21, []any{v6, v29}) -v31 := lang.Apply(v18, []any{v5, v30}) -v32 := lang.Apply(v15, []any{v4, v31}) -v33 := lang.Apply(v12, []any{v3, v32}) -v34 := lang.Apply(lang.CreateLazilyPersistentVector, []any{v33}) -return v34 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// vector? -{ -v0 := lang.NewSymbol("vector?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x implements IPersistentVector", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(174), lang.NewKeyword("end-line"), int(178))).(*lang.Symbol) -var v2 lang.FnFunc -{ // function vector? -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) -if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) -} -v7 := v6.Get() -v8 := lang.Apply(v7, []any{lang.IPersistentVector, v4}) -return v8 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(178), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(178), lang.NewKeyword("end-column"), int(106))).(lang.FnFunc) -v3 := v2 -_ = v3 -} -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// volatile! -{ -v1 := reflect.TypeOf((*lang.Volatile)(nil)).Elem() -v0 := lang.NewSymbol("volatile!").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Creates and returns a Volatile with an initial value of val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2517), lang.NewKeyword("end-line"), int(2517))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := lang.Apply(lang.NewVolatile, []any{v4}) -return v5 -}) -v4 := reflect.TypeOf((*lang.Volatile)(nil)).Elem() -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// volatile? -{ -v0 := lang.NewSymbol("volatile?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is a volatile.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2540), lang.NewKeyword("end-line"), int(2540))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.Apply(v6, []any{lang.Volatile, v3}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// vreset! -{ -v0 := lang.NewSymbol("vreset!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("vol"), lang.NewSymbol("newval"))), lang.NewKeyword("doc"), "Sets the value of volatile to newval without regard for the\n current value. Returns newval.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2524), lang.NewKeyword("end-line"), int(2524))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5, _ := lang.FieldOrMethod(v3, "reset") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// vswap! -{ -v0 := lang.NewSymbol("vswap!").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("vol"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Non-atomically swaps the value of the volatile as if:\n (apply f current-value-of-vol args). Returns the value that\n was swapped in.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(2531), lang.NewKeyword("end-line"), int(2531))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := args[3] -v7 := lang.NewList(args[4:]...) -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("with-meta")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.NewMap(lang.NewKeyword("tag"), lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Volatile")) -v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2537), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(2537), lang.NewKeyword("end-column"), int(81)) -v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v15 := lang.Apply(v11, []any{v5, v14}) -var v8 any = v15 -_ = v8 -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("concat")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("list")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{lang.NewSymbol(".reset")}) -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{v8}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{v6}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("seq")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) -} -v49 := v48.Get() -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("concat")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("list")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) -} -v55 := v54.Get() -v56 := lang.Apply(v55, []any{lang.NewSymbol(".Deref")}) -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("list")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) -} -v59 := v58.Get() -v60 := lang.Apply(v59, []any{v8}) -v61 := lang.Apply(v52, []any{v56, v60}) -v62 := lang.Apply(v49, []any{v61}) -v63 := lang.Apply(v46, []any{v62}) -v64 := lang.Apply(v39, []any{v43, v63, v7}) -v65 := lang.Apply(v36, []any{v64}) -v66 := lang.Apply(v33, []any{v65}) -v67 := lang.Apply(v22, []any{v26, v30, v66}) -v68 := lang.Apply(v19, []any{v67}) -return v68 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// when -{ -v0 := lang.NewSymbol("when").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("test"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Evaluates test. If logical true, evaluates body in an implicit do.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(492), lang.NewKeyword("end-line"), int(492))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("list")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("cons")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol("do"), v6}) -v14 := lang.Apply(v9, []any{lang.NewSymbol("if"), v5, v13}) -return v14 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// when-first -{ -v0 := lang.NewSymbol("when-first").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "bindings => x xs\n\n Roughly the same as (when (seq xs) (let [x (first xs)] body)) but xs is evaluated only once", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4622), lang.NewKeyword("end-line"), int(4622))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -var v7 any -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v5}) -if lang.IsTruthy(v11) { -v7 = nil -} else { -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("str")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("first")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v3}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("meta")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) -v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) -v28 := lang.Apply(lang.NewIllegalArgumentError, []any{v27}) -panic(v28) -} -_ = v7 -var v29 any -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("=")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("count")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v5}) -v37 := lang.Apply(v32, []any{int64(2), v36}) -if lang.IsTruthy(v37) { -v29 = nil -} else { -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("str")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("first")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v3}) -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("meta")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v3}) -v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) -v53 := lang.Apply(v40, []any{v44, " requires ", "exactly 2 forms in binding vector", " in ", v47, ":", v52}) -v54 := lang.Apply(lang.NewIllegalArgumentError, []any{v53}) -panic(v54) -} -_ = v29 -_ = nil -var v55 any = v5 -_ = v55 -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("nth")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) -} -v59 := v58.Get() -v60 := lang.Apply(v59, []any{v55, int64(0), nil}) -var v56 any = v60 -_ = v56 -v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v63 := v62.FindInternedVar(lang.NewSymbol("nth")) -if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) -} -v64 := v63.Get() -v65 := lang.Apply(v64, []any{v55, int64(1), nil}) -var v61 any = v65 -_ = v61 -v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v68 := v67.FindInternedVar(lang.NewSymbol("seq")) -if v68.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) -} -v69 := v68.Get() -v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v71 := v70.FindInternedVar(lang.NewSymbol("concat")) -if v71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) -} -v72 := v71.Get() -v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v74 := v73.FindInternedVar(lang.NewSymbol("list")) -if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) -} -v75 := v74.Get() -v76 := lang.Apply(v75, []any{lang.NewSymbol("glojure.core/when-let")}) -v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v78 := v77.FindInternedVar(lang.NewSymbol("list")) -if v78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) -} -v79 := v78.Get() -v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v81 := v80.FindInternedVar(lang.NewSymbol("apply")) -if v81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) -} -v82 := v81.Get() -v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v84 := v83.FindInternedVar(lang.NewSymbol("vector")) -if v84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) -} -v85 := v84.Get() -v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v87 := v86.FindInternedVar(lang.NewSymbol("seq")) -if v87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) -} -v88 := v87.Get() -v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v90 := v89.FindInternedVar(lang.NewSymbol("concat")) -if v90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) -} -v91 := v90.Get() -v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v93 := v92.FindInternedVar(lang.NewSymbol("list")) -if v93.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) -} -v94 := v93.Get() -v95 := lang.Apply(v94, []any{lang.NewSymbol("xs__0__auto__")}) -v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v97 := v96.FindInternedVar(lang.NewSymbol("list")) -if v97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) -} -v98 := v97.Get() -v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v100 := v99.FindInternedVar(lang.NewSymbol("seq")) -if v100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) -} -v101 := v100.Get() -v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v103 := v102.FindInternedVar(lang.NewSymbol("concat")) -if v103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) -} -v104 := v103.Get() -v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v106 := v105.FindInternedVar(lang.NewSymbol("list")) -if v106.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) -} -v107 := v106.Get() -v108 := lang.Apply(v107, []any{lang.NewSymbol("glojure.core/seq")}) -v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v110 := v109.FindInternedVar(lang.NewSymbol("list")) -if v110.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) -} -v111 := v110.Get() -v112 := lang.Apply(v111, []any{v61}) -v113 := lang.Apply(v104, []any{v108, v112}) -v114 := lang.Apply(v101, []any{v113}) -v115 := lang.Apply(v98, []any{v114}) -v116 := lang.Apply(v91, []any{v95, v115}) -v117 := lang.Apply(v88, []any{v116}) -v118 := lang.Apply(v82, []any{v85, v117}) -v119 := lang.Apply(v79, []any{v118}) -v120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v121 := v120.FindInternedVar(lang.NewSymbol("list")) -if v121.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v121))) -} -v122 := v121.Get() -v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v124 := v123.FindInternedVar(lang.NewSymbol("seq")) -if v124.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) -} -v125 := v124.Get() -v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v127 := v126.FindInternedVar(lang.NewSymbol("concat")) -if v127.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) -} -v128 := v127.Get() -v129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v130 := v129.FindInternedVar(lang.NewSymbol("list")) -if v130.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v130))) -} -v131 := v130.Get() -v132 := lang.Apply(v131, []any{lang.NewSymbol("glojure.core/let")}) -v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v134 := v133.FindInternedVar(lang.NewSymbol("list")) -if v134.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) -} -v135 := v134.Get() -v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v137 := v136.FindInternedVar(lang.NewSymbol("apply")) -if v137.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) -} -v138 := v137.Get() -v139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v140 := v139.FindInternedVar(lang.NewSymbol("vector")) -if v140.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v140))) -} -v141 := v140.Get() -v142 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v143 := v142.FindInternedVar(lang.NewSymbol("seq")) -if v143.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v143))) -} -v144 := v143.Get() -v145 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v146 := v145.FindInternedVar(lang.NewSymbol("concat")) -if v146.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v146))) -} -v147 := v146.Get() -v148 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v149 := v148.FindInternedVar(lang.NewSymbol("list")) -if v149.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v149))) -} -v150 := v149.Get() -v151 := lang.Apply(v150, []any{v56}) -v152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v153 := v152.FindInternedVar(lang.NewSymbol("list")) -if v153.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v153))) -} -v154 := v153.Get() -v155 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v156 := v155.FindInternedVar(lang.NewSymbol("seq")) -if v156.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v156))) -} -v157 := v156.Get() -v158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v159 := v158.FindInternedVar(lang.NewSymbol("concat")) -if v159.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v159))) -} -v160 := v159.Get() -v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v162 := v161.FindInternedVar(lang.NewSymbol("list")) -if v162.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) -} -v163 := v162.Get() -v164 := lang.Apply(v163, []any{lang.NewSymbol("glojure.core/first")}) -v165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v166 := v165.FindInternedVar(lang.NewSymbol("list")) -if v166.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v166))) -} -v167 := v166.Get() -v168 := lang.Apply(v167, []any{lang.NewSymbol("xs__0__auto__")}) -v169 := lang.Apply(v160, []any{v164, v168}) -v170 := lang.Apply(v157, []any{v169}) -v171 := lang.Apply(v154, []any{v170}) -v172 := lang.Apply(v147, []any{v151, v171}) -v173 := lang.Apply(v144, []any{v172}) -v174 := lang.Apply(v138, []any{v141, v173}) -v175 := lang.Apply(v135, []any{v174}) -v176 := lang.Apply(v128, []any{v132, v175, v6}) -v177 := lang.Apply(v125, []any{v176}) -v178 := lang.Apply(v122, []any{v177}) -v179 := lang.Apply(v72, []any{v76, v119, v178}) -v180 := lang.Apply(v69, []any{v179}) -return v180 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// when-let -{ -v0 := lang.NewSymbol("when-let").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "bindings => binding-form test\n\n When test is true, evaluates body with binding-form bound to the value of test", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1859), lang.NewKeyword("end-line"), int(1859))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -var v7 any -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v5}) -if lang.IsTruthy(v11) { -v7 = nil -} else { -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("str")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("first")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v3}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("meta")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) -v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) -v28 := lang.Apply(lang.NewIllegalArgumentError, []any{v27}) -panic(v28) -} -_ = v7 -var v29 any -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("=")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("count")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v5}) -v37 := lang.Apply(v32, []any{int64(2), v36}) -if lang.IsTruthy(v37) { -v29 = nil -} else { -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("str")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("first")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v3}) -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("meta")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v3}) -v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) -v53 := lang.Apply(v40, []any{v44, " requires ", "exactly 2 forms in binding vector", " in ", v47, ":", v52}) -v54 := lang.Apply(lang.NewIllegalArgumentError, []any{v53}) -panic(v54) -} -_ = v29 -_ = nil -v56 := lang.Apply(v5, []any{int64(0)}) -var v55 any = v56 -_ = v55 -v58 := lang.Apply(v5, []any{int64(1)}) -var v57 any = v58 -_ = v57 -v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v61 := v60.FindInternedVar(lang.NewSymbol("seq")) -if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) -} -v62 := v61.Get() -v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v64 := v63.FindInternedVar(lang.NewSymbol("concat")) -if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) -} -v65 := v64.Get() -v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v67 := v66.FindInternedVar(lang.NewSymbol("list")) -if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) -} -v68 := v67.Get() -v69 := lang.Apply(v68, []any{lang.NewSymbol("glojure.core/let")}) -v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v71 := v70.FindInternedVar(lang.NewSymbol("list")) -if v71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) -} -v72 := v71.Get() -v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v74 := v73.FindInternedVar(lang.NewSymbol("apply")) -if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) -} -v75 := v74.Get() -v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v77 := v76.FindInternedVar(lang.NewSymbol("vector")) -if v77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) -} -v78 := v77.Get() -v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v80 := v79.FindInternedVar(lang.NewSymbol("seq")) -if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) -} -v81 := v80.Get() -v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v83 := v82.FindInternedVar(lang.NewSymbol("concat")) -if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) -} -v84 := v83.Get() -v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v86 := v85.FindInternedVar(lang.NewSymbol("list")) -if v86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) -} -v87 := v86.Get() -v88 := lang.Apply(v87, []any{lang.NewSymbol("temp__0__auto__")}) -v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v90 := v89.FindInternedVar(lang.NewSymbol("list")) -if v90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) -} -v91 := v90.Get() -v92 := lang.Apply(v91, []any{v57}) -v93 := lang.Apply(v84, []any{v88, v92}) -v94 := lang.Apply(v81, []any{v93}) -v95 := lang.Apply(v75, []any{v78, v94}) -v96 := lang.Apply(v72, []any{v95}) -v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v98 := v97.FindInternedVar(lang.NewSymbol("list")) -if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) -} -v99 := v98.Get() -v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v101 := v100.FindInternedVar(lang.NewSymbol("seq")) -if v101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) -} -v102 := v101.Get() -v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v104 := v103.FindInternedVar(lang.NewSymbol("concat")) -if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) -} -v105 := v104.Get() -v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v107 := v106.FindInternedVar(lang.NewSymbol("list")) -if v107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) -} -v108 := v107.Get() -v109 := lang.Apply(v108, []any{lang.NewSymbol("glojure.core/when")}) -v110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v111 := v110.FindInternedVar(lang.NewSymbol("list")) -if v111.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v111))) -} -v112 := v111.Get() -v113 := lang.Apply(v112, []any{lang.NewSymbol("temp__0__auto__")}) -v114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v115 := v114.FindInternedVar(lang.NewSymbol("list")) -if v115.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v115))) -} -v116 := v115.Get() -v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v118 := v117.FindInternedVar(lang.NewSymbol("seq")) -if v118.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) -} -v119 := v118.Get() -v120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v121 := v120.FindInternedVar(lang.NewSymbol("concat")) -if v121.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v121))) -} -v122 := v121.Get() -v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v124 := v123.FindInternedVar(lang.NewSymbol("list")) -if v124.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) -} -v125 := v124.Get() -v126 := lang.Apply(v125, []any{lang.NewSymbol("glojure.core/let")}) -v127 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v128 := v127.FindInternedVar(lang.NewSymbol("list")) -if v128.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v128))) -} -v129 := v128.Get() -v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v131 := v130.FindInternedVar(lang.NewSymbol("apply")) -if v131.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) -} -v132 := v131.Get() -v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v134 := v133.FindInternedVar(lang.NewSymbol("vector")) -if v134.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) -} -v135 := v134.Get() -v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v137 := v136.FindInternedVar(lang.NewSymbol("seq")) -if v137.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) -} -v138 := v137.Get() -v139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v140 := v139.FindInternedVar(lang.NewSymbol("concat")) -if v140.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v140))) -} -v141 := v140.Get() -v142 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v143 := v142.FindInternedVar(lang.NewSymbol("list")) -if v143.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v143))) -} -v144 := v143.Get() -v145 := lang.Apply(v144, []any{v55}) -v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v147 := v146.FindInternedVar(lang.NewSymbol("list")) -if v147.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) -} -v148 := v147.Get() -v149 := lang.Apply(v148, []any{lang.NewSymbol("temp__0__auto__")}) -v150 := lang.Apply(v141, []any{v145, v149}) -v151 := lang.Apply(v138, []any{v150}) -v152 := lang.Apply(v132, []any{v135, v151}) -v153 := lang.Apply(v129, []any{v152}) -v154 := lang.Apply(v122, []any{v126, v153, v6}) -v155 := lang.Apply(v119, []any{v154}) -v156 := lang.Apply(v116, []any{v155}) -v157 := lang.Apply(v105, []any{v109, v113, v156}) -v158 := lang.Apply(v102, []any{v157}) -v159 := lang.Apply(v99, []any{v158}) -v160 := lang.Apply(v65, []any{v69, v96, v159}) -v161 := lang.Apply(v62, []any{v160}) -return v161 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// when-not -{ -v0 := lang.NewSymbol("when-not").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("test"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Evaluates test. If logical false, evaluates body in an implicit do.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(498), lang.NewKeyword("end-line"), int(498))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("list")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("cons")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol("do"), v6}) -v14 := lang.Apply(v9, []any{lang.NewSymbol("if"), v5, nil, v13}) -return v14 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// when-some -{ -v0 := lang.NewSymbol("when-some").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "bindings => binding-form test\n\n When test is not nil, evaluates body with binding-form bound to the\n value of test", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1894), lang.NewKeyword("end-line"), int(1894))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -var v7 any -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v5}) -if lang.IsTruthy(v11) { -v7 = nil -} else { -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("str")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("first")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v3}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("meta")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) -v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) -v28 := lang.Apply(lang.NewIllegalArgumentError, []any{v27}) -panic(v28) -} -_ = v7 -var v29 any -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("=")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("count")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v5}) -v37 := lang.Apply(v32, []any{int64(2), v36}) -if lang.IsTruthy(v37) { -v29 = nil -} else { -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("str")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("first")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v3}) -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("meta")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v3}) -v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) -v53 := lang.Apply(v40, []any{v44, " requires ", "exactly 2 forms in binding vector", " in ", v47, ":", v52}) -v54 := lang.Apply(lang.NewIllegalArgumentError, []any{v53}) -panic(v54) -} -_ = v29 -_ = nil -v56 := lang.Apply(v5, []any{int64(0)}) -var v55 any = v56 -_ = v55 -v58 := lang.Apply(v5, []any{int64(1)}) -var v57 any = v58 -_ = v57 -v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v61 := v60.FindInternedVar(lang.NewSymbol("seq")) -if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) -} -v62 := v61.Get() -v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v64 := v63.FindInternedVar(lang.NewSymbol("concat")) -if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) -} -v65 := v64.Get() -v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v67 := v66.FindInternedVar(lang.NewSymbol("list")) -if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) -} -v68 := v67.Get() -v69 := lang.Apply(v68, []any{lang.NewSymbol("glojure.core/let")}) -v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v71 := v70.FindInternedVar(lang.NewSymbol("list")) -if v71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) -} -v72 := v71.Get() -v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v74 := v73.FindInternedVar(lang.NewSymbol("apply")) -if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) -} -v75 := v74.Get() -v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v77 := v76.FindInternedVar(lang.NewSymbol("vector")) -if v77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) -} -v78 := v77.Get() -v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v80 := v79.FindInternedVar(lang.NewSymbol("seq")) -if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) -} -v81 := v80.Get() -v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v83 := v82.FindInternedVar(lang.NewSymbol("concat")) -if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) -} -v84 := v83.Get() -v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v86 := v85.FindInternedVar(lang.NewSymbol("list")) -if v86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) -} -v87 := v86.Get() -v88 := lang.Apply(v87, []any{lang.NewSymbol("temp__0__auto__")}) -v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v90 := v89.FindInternedVar(lang.NewSymbol("list")) -if v90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) -} -v91 := v90.Get() -v92 := lang.Apply(v91, []any{v57}) -v93 := lang.Apply(v84, []any{v88, v92}) -v94 := lang.Apply(v81, []any{v93}) -v95 := lang.Apply(v75, []any{v78, v94}) -v96 := lang.Apply(v72, []any{v95}) -v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v98 := v97.FindInternedVar(lang.NewSymbol("list")) -if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) -} -v99 := v98.Get() -v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v101 := v100.FindInternedVar(lang.NewSymbol("seq")) -if v101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) -} -v102 := v101.Get() -v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v104 := v103.FindInternedVar(lang.NewSymbol("concat")) -if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) -} -v105 := v104.Get() -v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v107 := v106.FindInternedVar(lang.NewSymbol("list")) -if v107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) -} -v108 := v107.Get() -v109 := lang.Apply(v108, []any{lang.NewSymbol("if")}) -v110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v111 := v110.FindInternedVar(lang.NewSymbol("list")) -if v111.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v111))) -} -v112 := v111.Get() -v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v114 := v113.FindInternedVar(lang.NewSymbol("seq")) -if v114.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) -} -v115 := v114.Get() -v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v117 := v116.FindInternedVar(lang.NewSymbol("concat")) -if v117.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) -} -v118 := v117.Get() -v119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v120 := v119.FindInternedVar(lang.NewSymbol("list")) -if v120.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v120))) -} -v121 := v120.Get() -v122 := lang.Apply(v121, []any{lang.NewSymbol("glojure.core/nil?")}) -v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v124 := v123.FindInternedVar(lang.NewSymbol("list")) -if v124.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) -} -v125 := v124.Get() -v126 := lang.Apply(v125, []any{lang.NewSymbol("temp__0__auto__")}) -v127 := lang.Apply(v118, []any{v122, v126}) -v128 := lang.Apply(v115, []any{v127}) -v129 := lang.Apply(v112, []any{v128}) -v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v131 := v130.FindInternedVar(lang.NewSymbol("list")) -if v131.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) -} -v132 := v131.Get() -v133 := lang.Apply(v132, []any{nil}) -v134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v135 := v134.FindInternedVar(lang.NewSymbol("list")) -if v135.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v135))) -} -v136 := v135.Get() -v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v138 := v137.FindInternedVar(lang.NewSymbol("seq")) -if v138.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) -} -v139 := v138.Get() -v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v141 := v140.FindInternedVar(lang.NewSymbol("concat")) -if v141.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) -} -v142 := v141.Get() -v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v144 := v143.FindInternedVar(lang.NewSymbol("list")) -if v144.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) -} -v145 := v144.Get() -v146 := lang.Apply(v145, []any{lang.NewSymbol("glojure.core/let")}) -v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v148 := v147.FindInternedVar(lang.NewSymbol("list")) -if v148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) -} -v149 := v148.Get() -v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v151 := v150.FindInternedVar(lang.NewSymbol("apply")) -if v151.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) -} -v152 := v151.Get() -v153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v154 := v153.FindInternedVar(lang.NewSymbol("vector")) -if v154.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v154))) -} -v155 := v154.Get() -v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v157 := v156.FindInternedVar(lang.NewSymbol("seq")) -if v157.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) -} -v158 := v157.Get() -v159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v160 := v159.FindInternedVar(lang.NewSymbol("concat")) -if v160.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v160))) -} -v161 := v160.Get() -v162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v163 := v162.FindInternedVar(lang.NewSymbol("list")) -if v163.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v163))) -} -v164 := v163.Get() -v165 := lang.Apply(v164, []any{v55}) -v166 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v167 := v166.FindInternedVar(lang.NewSymbol("list")) -if v167.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v167))) -} -v168 := v167.Get() -v169 := lang.Apply(v168, []any{lang.NewSymbol("temp__0__auto__")}) -v170 := lang.Apply(v161, []any{v165, v169}) -v171 := lang.Apply(v158, []any{v170}) -v172 := lang.Apply(v152, []any{v155, v171}) -v173 := lang.Apply(v149, []any{v172}) -v174 := lang.Apply(v142, []any{v146, v173, v6}) -v175 := lang.Apply(v139, []any{v174}) -v176 := lang.Apply(v136, []any{v175}) -v177 := lang.Apply(v105, []any{v109, v129, v133, v176}) -v178 := lang.Apply(v102, []any{v177}) -v179 := lang.Apply(v99, []any{v178}) -v180 := lang.Apply(v65, []any{v69, v96, v179}) -v181 := lang.Apply(v62, []any{v180}) -return v181 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// while -{ -v0 := lang.NewSymbol("while").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("test"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Repeatedly executes body while test expression is true. Presumes\n some side-effect will cause test to become false/nil. Returns nil", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6327), lang.NewKeyword("end-line"), int(6327))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("seq")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("concat")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("list")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/loop")}) -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("list")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("apply")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("vector")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("seq")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("concat")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.Apply(v31, nil) -v33 := lang.Apply(v28, []any{v32}) -v34 := lang.Apply(v22, []any{v25, v33}) -v35 := lang.Apply(v19, []any{v34}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("seq")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) -} -v41 := v40.Get() -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("concat")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) -} -v44 := v43.Get() -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("list")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.Apply(v47, []any{lang.NewSymbol("glojure.core/when")}) -v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v50 := v49.FindInternedVar(lang.NewSymbol("list")) -if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) -} -v51 := v50.Get() -v52 := lang.Apply(v51, []any{v5}) -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("list")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) -} -v55 := v54.Get() -v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v57 := v56.FindInternedVar(lang.NewSymbol("seq")) -if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) -} -v58 := v57.Get() -v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v60 := v59.FindInternedVar(lang.NewSymbol("concat")) -if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) -} -v61 := v60.Get() -v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v63 := v62.FindInternedVar(lang.NewSymbol("list")) -if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) -} -v64 := v63.Get() -v65 := lang.Apply(v64, []any{lang.NewSymbol("recur")}) -v66 := lang.Apply(v61, []any{v65}) -v67 := lang.Apply(v58, []any{v66}) -v68 := lang.Apply(v55, []any{v67}) -v69 := lang.Apply(v44, []any{v48, v52, v6, v68}) -v70 := lang.Apply(v41, []any{v69}) -v71 := lang.Apply(v38, []any{v70}) -v72 := lang.Apply(v12, []any{v16, v35, v71}) -v73 := lang.Apply(v9, []any{v72}) -return v73 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// with-bindings -{ -v0 := lang.NewSymbol("with-bindings").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("binding-map"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Takes a map of Var/value pairs. Installs for the given Vars the associated\n values as thread-local bindings. Then executes body. Pops the installed\n bindings after body was evaluated. Returns the value of body.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1984), lang.NewKeyword("end-line"), int(1984))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("seq")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("concat")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("list")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/with-bindings*")}) -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("list")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v19, []any{v5}) -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("list")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("seq")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("concat")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("list")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.Apply(v32, []any{lang.NewSymbol("glojure.core/fn")}) -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("list")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("apply")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("vector")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("seq")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v47 := v46.FindInternedVar(lang.NewSymbol("concat")) -if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) -} -v48 := v47.Get() -v49 := lang.Apply(v48, nil) -v50 := lang.Apply(v45, []any{v49}) -v51 := lang.Apply(v39, []any{v42, v50}) -v52 := lang.Apply(v36, []any{v51}) -v53 := lang.Apply(v29, []any{v33, v52, v6}) -v54 := lang.Apply(v26, []any{v53}) -v55 := lang.Apply(v23, []any{v54}) -v56 := lang.Apply(v12, []any{v16, v20, v55}) -v57 := lang.Apply(v9, []any{v56}) -return v57 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// with-bindings* -{ -v0 := lang.NewSymbol("with-bindings*").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("binding-map"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Takes a map of Var/value pairs. Installs for the given Vars the associated\n values as thread-local bindings. Then calls f with the supplied arguments.\n Pops the installed bindings after f returned. Returns whatever f returns.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1971), lang.NewKeyword("end-line"), int(1971))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("push-thread-bindings")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.Apply(v8, []any{v3}) -_ = v9 -var v10 any -func() { -defer func() { -v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v12 := v11.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) -if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) -} -v13 := v12.Get() -v14 := lang.Apply(v13, nil) -}() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("apply")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v4, v5}) -v10 = v18 -}() -return v10 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// with-in-str -{ -v0 := lang.NewSymbol("with-in-str").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Evaluates body in a context in which *in* is bound to a fresh\n StringReader initialized with the string s.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4749), lang.NewKeyword("end-line"), int(4749))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("seq")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("concat")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("list")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/with-open")}) -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("list")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("apply")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("vector")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("seq")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("concat")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("list")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{lang.NewSymbol("s__0__auto__")}) -v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v37 := v36.FindInternedVar(lang.NewSymbol("list")) -if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) -} -v38 := v37.Get() -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("seq")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) -} -v41 := v40.Get() -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("concat")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) -} -v44 := v43.Get() -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("list")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.Apply(v47, []any{lang.NewSymbol("glojure.core/->")}) -v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v50 := v49.FindInternedVar(lang.NewSymbol("list")) -if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) -} -v51 := v50.Get() -v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("seq")) -if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) -} -v54 := v53.Get() -v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v56 := v55.FindInternedVar(lang.NewSymbol("concat")) -if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) -} -v57 := v56.Get() -v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v59 := v58.FindInternedVar(lang.NewSymbol("list")) -if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) -} -v60 := v59.Get() -v61 := lang.Apply(v60, []any{lang.NewSymbol("java.io.StringReader.")}) -v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v63 := v62.FindInternedVar(lang.NewSymbol("list")) -if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) -} -v64 := v63.Get() -v65 := lang.Apply(v64, []any{v5}) -v66 := lang.Apply(v57, []any{v61, v65}) -v67 := lang.Apply(v54, []any{v66}) -v68 := lang.Apply(v51, []any{v67}) -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("list")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) -} -v71 := v70.Get() -v72 := lang.Apply(v71, []any{lang.NewSymbol("glojure.lang.LineNumberingPushbackReader.")}) -v73 := lang.Apply(v44, []any{v48, v68, v72}) -v74 := lang.Apply(v41, []any{v73}) -v75 := lang.Apply(v38, []any{v74}) -v76 := lang.Apply(v31, []any{v35, v75}) -v77 := lang.Apply(v28, []any{v76}) -v78 := lang.Apply(v22, []any{v25, v77}) -v79 := lang.Apply(v19, []any{v78}) -v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v81 := v80.FindInternedVar(lang.NewSymbol("list")) -if v81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) -} -v82 := v81.Get() -v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v84 := v83.FindInternedVar(lang.NewSymbol("seq")) -if v84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) -} -v85 := v84.Get() -v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v87 := v86.FindInternedVar(lang.NewSymbol("concat")) -if v87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) -} -v88 := v87.Get() -v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v90 := v89.FindInternedVar(lang.NewSymbol("list")) -if v90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) -} -v91 := v90.Get() -v92 := lang.Apply(v91, []any{lang.NewSymbol("glojure.core/binding")}) -v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v94 := v93.FindInternedVar(lang.NewSymbol("list")) -if v94.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) -} -v95 := v94.Get() -v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v97 := v96.FindInternedVar(lang.NewSymbol("apply")) -if v97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) -} -v98 := v97.Get() -v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v100 := v99.FindInternedVar(lang.NewSymbol("vector")) -if v100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) -} -v101 := v100.Get() -v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v103 := v102.FindInternedVar(lang.NewSymbol("seq")) -if v103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) -} -v104 := v103.Get() -v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v106 := v105.FindInternedVar(lang.NewSymbol("concat")) -if v106.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) -} -v107 := v106.Get() -v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v109 := v108.FindInternedVar(lang.NewSymbol("list")) -if v109.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) -} -v110 := v109.Get() -v111 := lang.Apply(v110, []any{lang.NewSymbol("glojure.core/*in*")}) -v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v113 := v112.FindInternedVar(lang.NewSymbol("list")) -if v113.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) -} -v114 := v113.Get() -v115 := lang.Apply(v114, []any{lang.NewSymbol("s__0__auto__")}) -v116 := lang.Apply(v107, []any{v111, v115}) -v117 := lang.Apply(v104, []any{v116}) -v118 := lang.Apply(v98, []any{v101, v117}) -v119 := lang.Apply(v95, []any{v118}) -v120 := lang.Apply(v88, []any{v92, v119, v6}) -v121 := lang.Apply(v85, []any{v120}) -v122 := lang.Apply(v82, []any{v121}) -v123 := lang.Apply(v12, []any{v16, v79, v122}) -v124 := lang.Apply(v9, []any{v123}) -return v124 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// with-loading-context -{ -v0 := lang.NewSymbol("with-loading-context").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5734), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5734), lang.NewKeyword("end-column"), int(30), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("macro"), true)).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("seq")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("concat")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("list")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("seq")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("concat")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("list")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.Apply(v23, []any{lang.NewSymbol("glojure.core/fn")}) -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("list")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.Apply(v27, []any{lang.NewSymbol("loading__0__auto__")}) -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("list")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("apply")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("vector")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("seq")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("concat")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, nil) -v45 := lang.Apply(v40, []any{v44}) -v46 := lang.Apply(v34, []any{v37, v45}) -v47 := lang.Apply(v31, []any{v46}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v52 := v51.FindInternedVar(lang.NewSymbol("seq")) -if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) -} -v53 := v52.Get() -v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v55 := v54.FindInternedVar(lang.NewSymbol("concat")) -if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) -} -v56 := v55.Get() -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("list")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) -} -v59 := v58.Get() -v60 := lang.Apply(v59, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.PushThreadBindings")}) -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("list")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) -} -v63 := v62.Get() -v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v65 := v64.FindInternedVar(lang.NewSymbol("apply")) -if v65.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) -} -v66 := v65.Get() -v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v68 := v67.FindInternedVar(lang.NewSymbol("hash-map")) -if v68.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) -} -v69 := v68.Get() -v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v71 := v70.FindInternedVar(lang.NewSymbol("seq")) -if v71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) -} -v72 := v71.Get() -v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v74 := v73.FindInternedVar(lang.NewSymbol("concat")) -if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) -} -v75 := v74.Get() -v76 := lang.Apply(v75, nil) -v77 := lang.Apply(v72, []any{v76}) -v78 := lang.Apply(v66, []any{v69, v77}) -v79 := lang.Apply(v63, []any{v78}) -v80 := lang.Apply(v56, []any{v60, v79}) -v81 := lang.Apply(v53, []any{v80}) -v82 := lang.Apply(v50, []any{v81}) -v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v84 := v83.FindInternedVar(lang.NewSymbol("list")) -if v84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) -} -v85 := v84.Get() -v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v87 := v86.FindInternedVar(lang.NewSymbol("seq")) -if v87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) -} -v88 := v87.Get() -v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v90 := v89.FindInternedVar(lang.NewSymbol("concat")) -if v90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) -} -v91 := v90.Get() -v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v93 := v92.FindInternedVar(lang.NewSymbol("list")) -if v93.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) -} -v94 := v93.Get() -v95 := lang.Apply(v94, []any{lang.NewSymbol("try")}) -v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v97 := v96.FindInternedVar(lang.NewSymbol("list")) -if v97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) -} -v98 := v97.Get() -v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v100 := v99.FindInternedVar(lang.NewSymbol("seq")) -if v100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) -} -v101 := v100.Get() -v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v103 := v102.FindInternedVar(lang.NewSymbol("concat")) -if v103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) -} -v104 := v103.Get() -v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v106 := v105.FindInternedVar(lang.NewSymbol("list")) -if v106.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) -} -v107 := v106.Get() -v108 := lang.Apply(v107, []any{lang.NewSymbol("finally")}) -v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v110 := v109.FindInternedVar(lang.NewSymbol("list")) -if v110.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) -} -v111 := v110.Get() -v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v113 := v112.FindInternedVar(lang.NewSymbol("seq")) -if v113.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) -} -v114 := v113.Get() -v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v116 := v115.FindInternedVar(lang.NewSymbol("concat")) -if v116.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) -} -v117 := v116.Get() -v118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v119 := v118.FindInternedVar(lang.NewSymbol("list")) -if v119.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v119))) -} -v120 := v119.Get() -v121 := lang.Apply(v120, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.PopThreadBindings")}) -v122 := lang.Apply(v117, []any{v121}) -v123 := lang.Apply(v114, []any{v122}) -v124 := lang.Apply(v111, []any{v123}) -v125 := lang.Apply(v104, []any{v108, v124}) -v126 := lang.Apply(v101, []any{v125}) -v127 := lang.Apply(v98, []any{v126}) -v128 := lang.Apply(v91, []any{v95, v5, v127}) -v129 := lang.Apply(v88, []any{v128}) -v130 := lang.Apply(v85, []any{v129}) -v131 := lang.Apply(v20, []any{v24, v28, v47, v82, v130}) -v132 := lang.Apply(v17, []any{v131}) -v133 := lang.Apply(v14, []any{v132}) -v134 := lang.Apply(v11, []any{v133}) -v135 := lang.Apply(v8, []any{v134}) -return v135 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// with-local-vars -{ -v0 := lang.NewSymbol("with-local-vars").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name-vals-vec"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "varbinding=> symbol init-expr\n\n Executes the exprs in a context in which the symbols are bound to\n vars with per-thread bindings to the init-exprs. The symbols refer\n to the var objects themselves, and must be accessed with var-get and\n var-set", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4339), lang.NewKeyword("end-line"), int(4339))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -var v7 any -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v5}) -if lang.IsTruthy(v11) { -v7 = nil -} else { -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("str")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("first")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v3}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("meta")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) -v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) -v28 := lang.Apply(lang.NewIllegalArgumentError, []any{v27}) -panic(v28) -} -_ = v7 -var v29 any -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("even?")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("count")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v5}) -v37 := lang.Apply(v32, []any{v36}) -if lang.IsTruthy(v37) { -v29 = nil -} else { -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("str")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("first")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v3}) -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("meta")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v3}) -v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) -v53 := lang.Apply(v40, []any{v44, " requires ", "an even number of forms in binding vector", " in ", v47, ":", v52}) -v54 := lang.Apply(lang.NewIllegalArgumentError, []any{v53}) -panic(v54) -} -_ = v29 -_ = nil -v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v56 := v55.FindInternedVar(lang.NewSymbol("seq")) -if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) -} -v57 := v56.Get() -v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v59 := v58.FindInternedVar(lang.NewSymbol("concat")) -if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) -} -v60 := v59.Get() -v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v62 := v61.FindInternedVar(lang.NewSymbol("list")) -if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) -} -v63 := v62.Get() -v64 := lang.Apply(v63, []any{lang.NewSymbol("glojure.core/let")}) -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("list")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) -} -v67 := v66.Get() -v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v69 := v68.FindInternedVar(lang.NewSymbol("apply")) -if v69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) -} -v70 := v69.Get() -v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v72 := v71.FindInternedVar(lang.NewSymbol("vector")) -if v72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) -} -v73 := v72.Get() -v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v75 := v74.FindInternedVar(lang.NewSymbol("seq")) -if v75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) -} -v76 := v75.Get() -v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v78 := v77.FindInternedVar(lang.NewSymbol("concat")) -if v78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) -} -v79 := v78.Get() -v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v81 := v80.FindInternedVar(lang.NewSymbol("interleave")) -if v81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) -} -v82 := v81.Get() -v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v84 := v83.FindInternedVar(lang.NewSymbol("take-nth")) -if v84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) -} -v85 := v84.Get() -v86 := lang.Apply(v85, []any{int64(2), v5}) -v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v88 := v87.FindInternedVar(lang.NewSymbol("repeat")) -if v88.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) -} -v89 := v88.Get() -v90 := lang.Apply(v89, []any{lang.NewList(lang.NewSymbol(".."), lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.*Var"), lang.NewSymbol("create"), lang.NewSymbol("setDynamic"))}) -v91 := lang.Apply(v82, []any{v86, v90}) -v92 := lang.Apply(v79, []any{v91}) -v93 := lang.Apply(v76, []any{v92}) -v94 := lang.Apply(v70, []any{v73, v93}) -v95 := lang.Apply(v67, []any{v94}) -v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v97 := v96.FindInternedVar(lang.NewSymbol("list")) -if v97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) -} -v98 := v97.Get() -v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v100 := v99.FindInternedVar(lang.NewSymbol("seq")) -if v100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) -} -v101 := v100.Get() -v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v103 := v102.FindInternedVar(lang.NewSymbol("concat")) -if v103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) -} -v104 := v103.Get() -v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v106 := v105.FindInternedVar(lang.NewSymbol("list")) -if v106.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) -} -v107 := v106.Get() -v108 := lang.Apply(v107, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.PushThreadBindings")}) -v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v110 := v109.FindInternedVar(lang.NewSymbol("list")) -if v110.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) -} -v111 := v110.Get() -v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v113 := v112.FindInternedVar(lang.NewSymbol("apply")) -if v113.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) -} -v114 := v113.Get() -v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v116 := v115.FindInternedVar(lang.NewSymbol("hash-map")) -if v116.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) -} -v117 := v116.Get() -v118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v119 := v118.FindInternedVar(lang.NewSymbol("seq")) -if v119.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v119))) -} -v120 := v119.Get() -v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v122 := v121.FindInternedVar(lang.NewSymbol("concat")) -if v122.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) -} -v123 := v122.Get() -v124 := lang.Apply(v123, nil) -v125 := lang.Apply(v120, []any{v124}) -v126 := lang.Apply(v114, []any{v117, v125}) -v127 := lang.Apply(v111, []any{v126}) -v128 := lang.Apply(v104, []any{v108, v127}) -v129 := lang.Apply(v101, []any{v128}) -v130 := lang.Apply(v98, []any{v129}) -v131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v132 := v131.FindInternedVar(lang.NewSymbol("list")) -if v132.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v132))) -} -v133 := v132.Get() -v134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v135 := v134.FindInternedVar(lang.NewSymbol("seq")) -if v135.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v135))) -} -v136 := v135.Get() -v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v138 := v137.FindInternedVar(lang.NewSymbol("concat")) -if v138.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) -} -v139 := v138.Get() -v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v141 := v140.FindInternedVar(lang.NewSymbol("list")) -if v141.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) -} -v142 := v141.Get() -v143 := lang.Apply(v142, []any{lang.NewSymbol("try")}) -v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v145 := v144.FindInternedVar(lang.NewSymbol("list")) -if v145.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) -} -v146 := v145.Get() -v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v148 := v147.FindInternedVar(lang.NewSymbol("seq")) -if v148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) -} -v149 := v148.Get() -v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v151 := v150.FindInternedVar(lang.NewSymbol("concat")) -if v151.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) -} -v152 := v151.Get() -v153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v154 := v153.FindInternedVar(lang.NewSymbol("list")) -if v154.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v154))) -} -v155 := v154.Get() -v156 := lang.Apply(v155, []any{lang.NewSymbol("finally")}) -v157 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v158 := v157.FindInternedVar(lang.NewSymbol("list")) -if v158.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v158))) -} -v159 := v158.Get() -v160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v161 := v160.FindInternedVar(lang.NewSymbol("seq")) -if v161.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v161))) -} -v162 := v161.Get() -v163 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v164 := v163.FindInternedVar(lang.NewSymbol("concat")) -if v164.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v164))) -} -v165 := v164.Get() -v166 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v167 := v166.FindInternedVar(lang.NewSymbol("list")) -if v167.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v167))) -} -v168 := v167.Get() -v169 := lang.Apply(v168, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.PopThreadBindings")}) -v170 := lang.Apply(v165, []any{v169}) -v171 := lang.Apply(v162, []any{v170}) -v172 := lang.Apply(v159, []any{v171}) -v173 := lang.Apply(v152, []any{v156, v172}) -v174 := lang.Apply(v149, []any{v173}) -v175 := lang.Apply(v146, []any{v174}) -v176 := lang.Apply(v139, []any{v143, v6, v175}) -v177 := lang.Apply(v136, []any{v176}) -v178 := lang.Apply(v133, []any{v177}) -v179 := lang.Apply(v60, []any{v64, v95, v130, v178}) -v180 := lang.Apply(v57, []any{v179}) -return v180 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// with-meta -{ -v0 := lang.NewSymbol("with-meta").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("obj"), lang.NewSymbol("m"))), lang.NewKeyword("doc"), "Returns an object of the same type and value as obj, with\n map m as its metadata.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(211), lang.NewKeyword("end-line"), int(216))).(*lang.Symbol) -var v2 lang.FnFunc -{ // function with-meta -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5 := args[1] -v6, _ := lang.FieldOrMethod(v4, "WithMeta") -if reflect.TypeOf(v6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("WithMeta is not a function"))) -} -v7 := lang.Apply(v6, []any{v5}) -return v7 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(216), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(217), lang.NewKeyword("end-column"), int(32))).(lang.FnFunc) -v3 := v2 -_ = v3 -} -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// with-open -{ -v0 := lang.NewSymbol("with-open").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "bindings => [name init ...]\n\n Evaluates body in a try expression with names bound to the values\n of the inits, and a finally clause that calls (.close name) on each\n name in reverse order.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3832), lang.NewKeyword("end-line"), int(3832))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -var v7 any -v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) -if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) -} -v10 := v9.Get() -v11 := lang.Apply(v10, []any{v5}) -if lang.IsTruthy(v11) { -v7 = nil -} else { -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("str")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v16 := v15.FindInternedVar(lang.NewSymbol("first")) -if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) -} -v17 := v16.Get() -v18 := lang.Apply(v17, []any{v3}) -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("meta")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.Apply(v24, []any{v3}) -v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) -v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) -v28 := lang.Apply(lang.NewIllegalArgumentError, []any{v27}) -panic(v28) -} -_ = v7 -var v29 any -v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v31 := v30.FindInternedVar(lang.NewSymbol("even?")) -if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) -} -v32 := v31.Get() -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("count")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v5}) -v37 := lang.Apply(v32, []any{v36}) -if lang.IsTruthy(v37) { -v29 = nil -} else { -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("str")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("first")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.Apply(v43, []any{v3}) -v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) -if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) -} -v47 := v46.Get() -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("meta")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v3}) -v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) -v53 := lang.Apply(v40, []any{v44, " requires ", "an even number of forms in binding vector", " in ", v47, ":", v52}) -v54 := lang.Apply(lang.NewIllegalArgumentError, []any{v53}) -panic(v54) -} -_ = v29 -_ = nil -var v55 any -v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v57 := v56.FindInternedVar(lang.NewSymbol("=")) -if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) -} -v58 := v57.Get() -v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v60 := v59.FindInternedVar(lang.NewSymbol("count")) -if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) -} -v61 := v60.Get() -v62 := lang.Apply(v61, []any{v5}) -v63 := lang.Apply(v58, []any{v62, int64(0)}) -if lang.IsTruthy(v63) { -v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v65 := v64.FindInternedVar(lang.NewSymbol("seq")) -if v65.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) -} -v66 := v65.Get() -v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v68 := v67.FindInternedVar(lang.NewSymbol("concat")) -if v68.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) -} -v69 := v68.Get() -v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v71 := v70.FindInternedVar(lang.NewSymbol("list")) -if v71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) -} -v72 := v71.Get() -v73 := lang.Apply(v72, []any{lang.NewSymbol("do")}) -v74 := lang.Apply(v69, []any{v73, v6}) -v75 := lang.Apply(v66, []any{v74}) -v55 = v75 -} else { -var v76 any -v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v78 := v77.FindInternedVar(lang.NewSymbol("symbol?")) -if v78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) -} -v79 := v78.Get() -v80 := lang.Apply(v5, []any{int64(0)}) -v81 := lang.Apply(v79, []any{v80}) -if lang.IsTruthy(v81) { -v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v83 := v82.FindInternedVar(lang.NewSymbol("seq")) -if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) -} -v84 := v83.Get() -v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v86 := v85.FindInternedVar(lang.NewSymbol("concat")) -if v86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) -} -v87 := v86.Get() -v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v89 := v88.FindInternedVar(lang.NewSymbol("list")) -if v89.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) -} -v90 := v89.Get() -v91 := lang.Apply(v90, []any{lang.NewSymbol("glojure.core/let")}) -v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v93 := v92.FindInternedVar(lang.NewSymbol("list")) -if v93.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) -} -v94 := v93.Get() -v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v96 := v95.FindInternedVar(lang.NewSymbol("subvec")) -if v96.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) -} -v97 := v96.Get() -v98 := lang.Apply(v97, []any{v5, int64(0), int64(2)}) -v99 := lang.Apply(v94, []any{v98}) -v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v101 := v100.FindInternedVar(lang.NewSymbol("list")) -if v101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) -} -v102 := v101.Get() -v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v104 := v103.FindInternedVar(lang.NewSymbol("seq")) -if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) -} -v105 := v104.Get() -v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v107 := v106.FindInternedVar(lang.NewSymbol("concat")) -if v107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) -} -v108 := v107.Get() -v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v110 := v109.FindInternedVar(lang.NewSymbol("list")) -if v110.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) -} -v111 := v110.Get() -v112 := lang.Apply(v111, []any{lang.NewSymbol("try")}) -v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v114 := v113.FindInternedVar(lang.NewSymbol("list")) -if v114.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) -} -v115 := v114.Get() -v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v117 := v116.FindInternedVar(lang.NewSymbol("seq")) -if v117.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) -} -v118 := v117.Get() -v119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v120 := v119.FindInternedVar(lang.NewSymbol("concat")) -if v120.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v120))) -} -v121 := v120.Get() -v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v123 := v122.FindInternedVar(lang.NewSymbol("list")) -if v123.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) -} -v124 := v123.Get() -v125 := lang.Apply(v124, []any{lang.NewSymbol("glojure.core/with-open")}) -v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v127 := v126.FindInternedVar(lang.NewSymbol("list")) -if v127.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) -} -v128 := v127.Get() -v129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v130 := v129.FindInternedVar(lang.NewSymbol("subvec")) -if v130.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v130))) -} -v131 := v130.Get() -v132 := lang.Apply(v131, []any{v5, int64(2)}) -v133 := lang.Apply(v128, []any{v132}) -v134 := lang.Apply(v121, []any{v125, v133, v6}) -v135 := lang.Apply(v118, []any{v134}) -v136 := lang.Apply(v115, []any{v135}) -v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v138 := v137.FindInternedVar(lang.NewSymbol("list")) -if v138.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) -} -v139 := v138.Get() -v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v141 := v140.FindInternedVar(lang.NewSymbol("seq")) -if v141.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) -} -v142 := v141.Get() -v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v144 := v143.FindInternedVar(lang.NewSymbol("concat")) -if v144.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) -} -v145 := v144.Get() -v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v147 := v146.FindInternedVar(lang.NewSymbol("list")) -if v147.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) -} -v148 := v147.Get() -v149 := lang.Apply(v148, []any{lang.NewSymbol("finally")}) -v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v151 := v150.FindInternedVar(lang.NewSymbol("list")) -if v151.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) -} -v152 := v151.Get() -v153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v154 := v153.FindInternedVar(lang.NewSymbol("seq")) -if v154.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v154))) -} -v155 := v154.Get() -v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v157 := v156.FindInternedVar(lang.NewSymbol("concat")) -if v157.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) -} -v158 := v157.Get() -v159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v160 := v159.FindInternedVar(lang.NewSymbol("list")) -if v160.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v160))) -} -v161 := v160.Get() -v162 := lang.Apply(v161, []any{lang.NewSymbol(".")}) -v163 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v164 := v163.FindInternedVar(lang.NewSymbol("list")) -if v164.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v164))) -} -v165 := v164.Get() -v166 := lang.Apply(v5, []any{int64(0)}) -v167 := lang.Apply(v165, []any{v166}) -v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v169 := v168.FindInternedVar(lang.NewSymbol("list")) -if v169.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) -} -v170 := v169.Get() -v171 := lang.Apply(v170, []any{lang.NewSymbol("close")}) -v172 := lang.Apply(v158, []any{v162, v167, v171}) -v173 := lang.Apply(v155, []any{v172}) -v174 := lang.Apply(v152, []any{v173}) -v175 := lang.Apply(v145, []any{v149, v174}) -v176 := lang.Apply(v142, []any{v175}) -v177 := lang.Apply(v139, []any{v176}) -v178 := lang.Apply(v108, []any{v112, v136, v177}) -v179 := lang.Apply(v105, []any{v178}) -v180 := lang.Apply(v102, []any{v179}) -v181 := lang.Apply(v87, []any{v91, v99, v180}) -v182 := lang.Apply(v84, []any{v181}) -v76 = v182 -} else { -var v183 any -if lang.IsTruthy(lang.NewKeyword("else")) { -v184 := lang.Apply(lang.NewIllegalArgumentError, []any{"with-open only allows Symbols in bindings"}) -panic(v184) -} else { -v183 = nil -} -v76 = v183 -} -v55 = v76 -} -return v55 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// with-out-str -{ -v0 := lang.NewSymbol("with-out-str").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Evaluates exprs in a context in which *out* is bound to a fresh\n StringWriter. Returns the string created by any nested printing\n calls.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4738), lang.NewKeyword("end-line"), int(4738))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := lang.NewList(args[2:]...) -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("seq")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("concat")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("list")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{lang.NewSymbol("glojure.core/let")}) -v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v17 := v16.FindInternedVar(lang.NewSymbol("list")) -if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) -} -v18 := v17.Get() -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("apply")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v23 := v22.FindInternedVar(lang.NewSymbol("vector")) -if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) -} -v24 := v23.Get() -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("seq")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("concat")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{lang.NewSymbol("s__0__auto__")}) -v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v36 := v35.FindInternedVar(lang.NewSymbol("list")) -if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) -} -v37 := v36.Get() -v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v39 := v38.FindInternedVar(lang.NewSymbol("seq")) -if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) -} -v40 := v39.Get() -v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v42 := v41.FindInternedVar(lang.NewSymbol("concat")) -if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) -} -v43 := v42.Get() -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{lang.NewSymbol("new")}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{lang.NewSymbol("strings.Builder")}) -v52 := lang.Apply(v43, []any{v47, v51}) -v53 := lang.Apply(v40, []any{v52}) -v54 := lang.Apply(v37, []any{v53}) -v55 := lang.Apply(v30, []any{v34, v54}) -v56 := lang.Apply(v27, []any{v55}) -v57 := lang.Apply(v21, []any{v24, v56}) -v58 := lang.Apply(v18, []any{v57}) -v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v60 := v59.FindInternedVar(lang.NewSymbol("list")) -if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) -} -v61 := v60.Get() -v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v63 := v62.FindInternedVar(lang.NewSymbol("seq")) -if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) -} -v64 := v63.Get() -v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v66 := v65.FindInternedVar(lang.NewSymbol("concat")) -if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) -} -v67 := v66.Get() -v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v69 := v68.FindInternedVar(lang.NewSymbol("list")) -if v69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) -} -v70 := v69.Get() -v71 := lang.Apply(v70, []any{lang.NewSymbol("glojure.core/binding")}) -v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v73 := v72.FindInternedVar(lang.NewSymbol("list")) -if v73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) -} -v74 := v73.Get() -v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v76 := v75.FindInternedVar(lang.NewSymbol("apply")) -if v76.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) -} -v77 := v76.Get() -v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v79 := v78.FindInternedVar(lang.NewSymbol("vector")) -if v79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) -} -v80 := v79.Get() -v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v82 := v81.FindInternedVar(lang.NewSymbol("seq")) -if v82.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) -} -v83 := v82.Get() -v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v85 := v84.FindInternedVar(lang.NewSymbol("concat")) -if v85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) -} -v86 := v85.Get() -v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v88 := v87.FindInternedVar(lang.NewSymbol("list")) -if v88.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) -} -v89 := v88.Get() -v90 := lang.Apply(v89, []any{lang.NewSymbol("glojure.core/*out*")}) -v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v92 := v91.FindInternedVar(lang.NewSymbol("list")) -if v92.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) -} -v93 := v92.Get() -v94 := lang.Apply(v93, []any{lang.NewSymbol("s__0__auto__")}) -v95 := lang.Apply(v86, []any{v90, v94}) -v96 := lang.Apply(v83, []any{v95}) -v97 := lang.Apply(v77, []any{v80, v96}) -v98 := lang.Apply(v74, []any{v97}) -v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v100 := v99.FindInternedVar(lang.NewSymbol("list")) -if v100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) -} -v101 := v100.Get() -v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v103 := v102.FindInternedVar(lang.NewSymbol("seq")) -if v103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) -} -v104 := v103.Get() -v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v106 := v105.FindInternedVar(lang.NewSymbol("concat")) -if v106.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) -} -v107 := v106.Get() -v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v109 := v108.FindInternedVar(lang.NewSymbol("list")) -if v109.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) -} -v110 := v109.Get() -v111 := lang.Apply(v110, []any{lang.NewSymbol("glojure.core/str")}) -v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v113 := v112.FindInternedVar(lang.NewSymbol("list")) -if v113.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) -} -v114 := v113.Get() -v115 := lang.Apply(v114, []any{lang.NewSymbol("s__0__auto__")}) -v116 := lang.Apply(v107, []any{v111, v115}) -v117 := lang.Apply(v104, []any{v116}) -v118 := lang.Apply(v101, []any{v117}) -v119 := lang.Apply(v67, []any{v71, v98, v5, v118}) -v120 := lang.Apply(v64, []any{v119}) -v121 := lang.Apply(v61, []any{v120}) -v122 := lang.Apply(v11, []any{v15, v58, v121}) -v123 := lang.Apply(v8, []any{v122}) -return v123 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// with-precision -{ -v0 := lang.NewSymbol("with-precision").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("precision"), lang.NewSymbol("&"), lang.NewSymbol("exprs"))), lang.NewKeyword("doc"), "Sets the precision and rounding mode to be used for BigDecimal operations.\n\n Usage: (with-precision 10 (/ 1M 3))\n or: (with-precision 10 :rounding HALF_DOWN (/ 1M 3))\n\n The rounding mode is one of CEILING, FLOOR, HALF_UP, HALF_DOWN,\n HALF_EVEN, UP, DOWN and UNNECESSARY; it defaults to HALF_UP.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5110), lang.NewKeyword("end-line"), int(5110))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -var v8 any -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("=")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v13 := v12.FindInternedVar(lang.NewSymbol("first")) -if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) -} -v14 := v13.Get() -v15 := lang.Apply(v14, []any{v6}) -v16 := lang.Apply(v11, []any{v15, lang.NewKeyword("rounding")}) -if lang.IsTruthy(v16) { -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("next")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("next")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.Apply(v22, []any{v6}) -v24 := lang.Apply(v19, []any{v23}) -v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v26 := v25.FindInternedVar(lang.NewSymbol("seq")) -if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) -} -v27 := v26.Get() -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("concat")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("seq")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("concat")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v41 := v40.FindInternedVar(lang.NewSymbol("list")) -if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) -} -v42 := v41.Get() -v43 := lang.Apply(v42, []any{lang.NewSymbol(".")}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{lang.NewSymbol("java.math.RoundingMode")}) -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("list")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v52 := v51.FindInternedVar(lang.NewSymbol("second")) -if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) -} -v53 := v52.Get() -v54 := lang.Apply(v53, []any{v6}) -v55 := lang.Apply(v50, []any{v54}) -v56 := lang.Apply(v39, []any{v43, v47, v55}) -v57 := lang.Apply(v36, []any{v56}) -v58 := lang.Apply(v33, []any{v57}) -v59 := lang.Apply(v30, []any{v58}) -v60 := lang.Apply(v27, []any{v59}) -v61 := lang.NewVector(v24, v60) -v62 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5121), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(5122), lang.NewKeyword("end-column"), int(69)) -v63, err := lang.WithMeta(v61, v62.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v8 = v63 -} else { -v64 := lang.NewVector(v6, nil) -v65 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5123), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(5123), lang.NewKeyword("end-column"), int(33)) -v66, err := lang.WithMeta(v64, v65.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v8 = v66 -} -var v7 any = v8 -_ = v7 -v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v69 := v68.FindInternedVar(lang.NewSymbol("nth")) -if v69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) -} -v70 := v69.Get() -v71 := lang.Apply(v70, []any{v7, int64(0), nil}) -var v67 any = v71 -_ = v67 -v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v74 := v73.FindInternedVar(lang.NewSymbol("nth")) -if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) -} -v75 := v74.Get() -v76 := lang.Apply(v75, []any{v7, int64(1), nil}) -var v72 any = v76 -_ = v72 -v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v79 := v78.FindInternedVar(lang.NewSymbol("seq")) -if v79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) -} -v80 := v79.Get() -v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v82 := v81.FindInternedVar(lang.NewSymbol("concat")) -if v82.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) -} -v83 := v82.Get() -v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v85 := v84.FindInternedVar(lang.NewSymbol("list")) -if v85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) -} -v86 := v85.Get() -v87 := lang.Apply(v86, []any{lang.NewSymbol("glojure.core/binding")}) -v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v89 := v88.FindInternedVar(lang.NewSymbol("list")) -if v89.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) -} -v90 := v89.Get() -v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v92 := v91.FindInternedVar(lang.NewSymbol("apply")) -if v92.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) -} -v93 := v92.Get() -v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v95 := v94.FindInternedVar(lang.NewSymbol("vector")) -if v95.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) -} -v96 := v95.Get() -v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v98 := v97.FindInternedVar(lang.NewSymbol("seq")) -if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) -} -v99 := v98.Get() -v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v101 := v100.FindInternedVar(lang.NewSymbol("concat")) -if v101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) -} -v102 := v101.Get() -v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v104 := v103.FindInternedVar(lang.NewSymbol("list")) -if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) -} -v105 := v104.Get() -v106 := lang.Apply(v105, []any{lang.NewSymbol("glojure.core/*math-context*")}) -v107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v108 := v107.FindInternedVar(lang.NewSymbol("list")) -if v108.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v108))) -} -v109 := v108.Get() -v110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v111 := v110.FindInternedVar(lang.NewSymbol("seq")) -if v111.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v111))) -} -v112 := v111.Get() -v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v114 := v113.FindInternedVar(lang.NewSymbol("concat")) -if v114.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) -} -v115 := v114.Get() -v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v117 := v116.FindInternedVar(lang.NewSymbol("list")) -if v117.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) -} -v118 := v117.Get() -v119 := lang.Apply(v118, []any{lang.NewSymbol("java.math.MathContext.")}) -v120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v121 := v120.FindInternedVar(lang.NewSymbol("list")) -if v121.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v121))) -} -v122 := v121.Get() -v123 := lang.Apply(v122, []any{v5}) -v124 := lang.Apply(v115, []any{v119, v123, v72}) -v125 := lang.Apply(v112, []any{v124}) -v126 := lang.Apply(v109, []any{v125}) -v127 := lang.Apply(v102, []any{v106, v126}) -v128 := lang.Apply(v99, []any{v127}) -v129 := lang.Apply(v93, []any{v96, v128}) -v130 := lang.Apply(v90, []any{v129}) -v131 := lang.Apply(v83, []any{v87, v130, v67}) -v132 := lang.Apply(v80, []any{v131}) -return v132 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// with-redefs -{ -v0 := lang.NewSymbol("with-redefs").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "binding => var-symbol temp-value-expr\n\n Temporarily redefines Vars while executing the body. The\n temp-value-exprs will be evaluated and each resulting value will\n replace in parallel the root value of its Var. After the body is\n executed, the root values of all the Vars will be set back to their\n old values. These temporary changes will be visible in all threads.\n Useful for mocking out functions during testing.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7544), lang.NewKeyword("end-line"), int(7544))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v5 := args[2] -v6 := lang.NewList(args[3:]...) -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("seq")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("concat")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("list")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/with-redefs-fn")}) -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("list")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v21 := v20.FindInternedVar(lang.NewSymbol("zipmap")) -if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) -} -v22 := v21.Get() -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("map")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -var v26 lang.FnFunc -v26 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v27 := args[0] -v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v29 := v28.FindInternedVar(lang.NewSymbol("list")) -if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) -} -v30 := v29.Get() -v31 := lang.Apply(v30, []any{lang.NewSymbol("var"), v27}) -return v31 -}) -v27 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7555), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(7555), lang.NewKeyword("end-column"), int(47)) -v28, err := lang.WithMeta(v26, v27.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("take-nth")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.Apply(v31, []any{int64(2), v5}) -v33 := lang.Apply(v25, []any{v28, v32}) -v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v35 := v34.FindInternedVar(lang.NewSymbol("take-nth")) -if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) -} -v36 := v35.Get() -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("next")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v5}) -v41 := lang.Apply(v36, []any{int64(2), v40}) -v42 := lang.Apply(v22, []any{v33, v41}) -v43 := lang.Apply(v19, []any{v42}) -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("list")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("seq")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) -} -v49 := v48.Get() -v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v51 := v50.FindInternedVar(lang.NewSymbol("concat")) -if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) -} -v52 := v51.Get() -v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v54 := v53.FindInternedVar(lang.NewSymbol("list")) -if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) -} -v55 := v54.Get() -v56 := lang.Apply(v55, []any{lang.NewSymbol("glojure.core/fn")}) -v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v58 := v57.FindInternedVar(lang.NewSymbol("list")) -if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) -} -v59 := v58.Get() -v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v61 := v60.FindInternedVar(lang.NewSymbol("apply")) -if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) -} -v62 := v61.Get() -v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v64 := v63.FindInternedVar(lang.NewSymbol("vector")) -if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) -} -v65 := v64.Get() -v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v67 := v66.FindInternedVar(lang.NewSymbol("seq")) -if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) -} -v68 := v67.Get() -v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v70 := v69.FindInternedVar(lang.NewSymbol("concat")) -if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) -} -v71 := v70.Get() -v72 := lang.Apply(v71, nil) -v73 := lang.Apply(v68, []any{v72}) -v74 := lang.Apply(v62, []any{v65, v73}) -v75 := lang.Apply(v59, []any{v74}) -v76 := lang.Apply(v52, []any{v56, v75, v6}) -v77 := lang.Apply(v49, []any{v76}) -v78 := lang.Apply(v46, []any{v77}) -v79 := lang.Apply(v12, []any{v16, v43, v78}) -v80 := lang.Apply(v9, []any{v79}) -return v80 - } -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// with-redefs-fn -{ -v0 := lang.NewSymbol("with-redefs-fn").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("binding-map"), lang.NewSymbol("func"))), lang.NewKeyword("doc"), "Temporarily redefines Vars during a call to func. Each val of\n binding-map will replace the root value of its key which must be\n a Var. After func is called with no args, the root values of all\n the Vars will be set back to their old values. These temporary\n changes will be visible in all threads. Useful for mocking out\n functions during testing.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7524), lang.NewKeyword("end-line"), int(7524))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -var v6 lang.FnFunc -v6 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v7 := args[0] -v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v10 := v9.FindInternedVar(lang.NewSymbol("seq")) -if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) -} -v11 := v10.Get() -v12 := lang.Apply(v11, []any{v7}) -var v8 any = v12 -_ = v8 -var v13 any = nil -_ = v13 -var v14 any = int64(0) -_ = v14 -var v15 any = int64(0) -_ = v15 -var v16 any -for { -var v17 any -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("<")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.Apply(v20, []any{v15, v14}) -if lang.IsTruthy(v21) { -v23, _ := lang.FieldOrMethod(v13, "nth") -if reflect.TypeOf(v23).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) -} -v24 := lang.Apply(v23, []any{v15}) -var v22 any = v24 -_ = v22 -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("nth")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.Apply(v28, []any{v22, int64(0), nil}) -var v25 any = v29 -_ = v25 -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("nth")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v22, int64(1), nil}) -var v30 any = v34 -_ = v30 -v36, _ := lang.FieldOrMethod(v25, "bindRoot") -if reflect.TypeOf(v36).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("bindRoot is not a function"))) -} -v37 := lang.Apply(v36, []any{v30}) -_ = v37 -var v38 any = v8 -var v39 any = v13 -var v40 any = v14 -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("unchecked-inc")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) -} -v44 := v43.Get() -v45 := lang.Apply(v44, []any{v15}) -var v41 any = v45 -v8 = v38 -v13 = v39 -v14 = v40 -v15 = v41 -continue -} else { -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("seq")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{v8}) -var v22 any = v26 -_ = v22 -var v28 any -if lang.IsTruthy(v22) { -var v29 any = v22 -_ = v29 -var v31 any -v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v33 := v32.FindInternedVar(lang.NewSymbol("chunked-seq?")) -if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) -} -v34 := v33.Get() -v35 := lang.Apply(v34, []any{v29}) -if lang.IsTruthy(v35) { -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("chunk-first")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v29}) -var v36 any = v40 -_ = v36 -v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v44 := v43.FindInternedVar(lang.NewSymbol("chunk-rest")) -if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) -} -v45 := v44.Get() -v46 := lang.Apply(v45, []any{v29}) -var v42 any = v46 -var v47 any = v36 -v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v50 := v49.FindInternedVar(lang.NewSymbol("int")) -if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) -} -v51 := v50.Get() -v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v53 := v52.FindInternedVar(lang.NewSymbol("count")) -if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) -} -v54 := v53.Get() -v55 := lang.Apply(v54, []any{v36}) -v56 := lang.Apply(v51, []any{v55}) -var v48 any = v56 -v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v59 := v58.FindInternedVar(lang.NewSymbol("int")) -if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) -} -v60 := v59.Get() -v61 := lang.Apply(v60, []any{int64(0)}) -var v57 any = v61 -v8 = v42 -v13 = v47 -v14 = v48 -v15 = v57 -continue -} else { -v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v38 := v37.FindInternedVar(lang.NewSymbol("first")) -if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) -} -v39 := v38.Get() -v40 := lang.Apply(v39, []any{v29}) -var v36 any = v40 -_ = v36 -v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v43 := v42.FindInternedVar(lang.NewSymbol("nth")) -if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) -} -v44 := v43.Get() -v45 := lang.Apply(v44, []any{v36, int64(0), nil}) -var v41 any = v45 -_ = v41 -v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v48 := v47.FindInternedVar(lang.NewSymbol("nth")) -if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) -} -v49 := v48.Get() -v50 := lang.Apply(v49, []any{v36, int64(1), nil}) -var v46 any = v50 -_ = v46 -v52, _ := lang.FieldOrMethod(v41, "bindRoot") -if reflect.TypeOf(v52).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("bindRoot is not a function"))) -} -v53 := lang.Apply(v52, []any{v46}) -_ = v53 -v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v56 := v55.FindInternedVar(lang.NewSymbol("next")) -if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) -} -v57 := v56.Get() -v58 := lang.Apply(v57, []any{v29}) -var v54 any = v58 -var v59 any = nil -var v60 any = int64(0) -var v61 any = int64(0) -v8 = v54 -v13 = v59 -v14 = v60 -v15 = v61 -continue -} -v28 = v31 -} else { -v28 = nil -} -v17 = v28 -} -v16 = v17 - break -} -return v16 -}) -v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7533), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(7535), lang.NewKeyword("end-column"), int(93)) -v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -var v5 any = v8 -_ = v5 -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("zipmap")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v14 := v13.FindInternedVar(lang.NewSymbol("keys")) -if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) -} -v15 := v14.Get() -v16 := lang.Apply(v15, []any{v3}) -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("map")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -var v20 lang.FnFunc -v20 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v21 := args[0] -v22, ok := lang.FieldOrMethod(v21, "getRawRoot") -if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v21, "getRawRoot"))) -} -var v23 any -switch reflect.TypeOf(v22).Kind() { -case reflect.Func: - v23 = lang.Apply(v22, nil) -default: - v23 = v22 -} -return v23 -}) -v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7537), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(7537), lang.NewKeyword("end-column"), int(92)) -v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v24 := v23.FindInternedVar(lang.NewSymbol("keys")) -if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) -} -v25 := v24.Get() -v26 := lang.Apply(v25, []any{v3}) -v27 := lang.Apply(v19, []any{v22, v26}) -v28 := lang.Apply(v12, []any{v16, v27}) -var v9 any = v28 -_ = v9 -var v30 any -func() { -defer func() { -v31 := lang.Apply(v5, []any{v9}) -}() -v32 := lang.Apply(v5, []any{v3}) -_ = v32 -v33 := lang.Apply(v4, nil) -v30 = v33 -}() -return v30 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// xml-seq -{ -v0 := lang.NewSymbol("xml-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("root"))), lang.NewKeyword("doc"), "A tree seq on the xml elements as per xml/parse", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4982), lang.NewKeyword("end-line"), int(4982))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("tree-seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("complement")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("string?")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v9, []any{v12}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("comp")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v18 := v17.FindInternedVar(lang.NewSymbol("seq")) -if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) -} -v19 := v18.Get() -v20 := lang.Apply(v16, []any{v19, lang.NewKeyword("content")}) -v21 := lang.Apply(v6, []any{v13, v20, v3}) -return v21 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// zero? -{ -var v1 lang.FnFunc -{ // function zero?__inliner -v1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v5 := v4.FindInternedVar(lang.NewSymbol("seq")) -if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) -} -v6 := v5.Get() -v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v8 := v7.FindInternedVar(lang.NewSymbol("concat")) -if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) -} -v9 := v8.Get() -v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v11 := v10.FindInternedVar(lang.NewSymbol("list")) -if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) -} -v12 := v11.Get() -v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("list")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) -v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v19 := v18.FindInternedVar(lang.NewSymbol("list")) -if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) -} -v20 := v19.Get() -v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v22 := v21.FindInternedVar(lang.NewSymbol("seq")) -if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) -} -v23 := v22.Get() -v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v25 := v24.FindInternedVar(lang.NewSymbol("concat")) -if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) -} -v26 := v25.Get() -v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v28 := v27.FindInternedVar(lang.NewSymbol("list")) -if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) -} -v29 := v28.Get() -v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/isZero")}) -v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v32 := v31.FindInternedVar(lang.NewSymbol("list")) -if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) -} -v33 := v32.Get() -v34 := lang.Apply(v33, []any{v3}) -v35 := lang.Apply(v26, []any{v30, v34}) -v36 := lang.Apply(v23, []any{v35}) -v37 := lang.Apply(v20, []any{v36}) -v38 := lang.Apply(v9, []any{v13, v17, v37}) -v39 := lang.Apply(v6, []any{v38}) -return v39 -}) -v2 := v1 -_ = v2 -} -v0 := lang.NewSymbol("zero?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns true if num is zero, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(860), lang.NewKeyword("end-line"), int(860))).(*lang.Symbol) -var v3 lang.FnFunc -v3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v4 := args[0] -v5, _ := lang.FieldOrMethod(lang.Numbers, "isZero") -if reflect.TypeOf(v5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("isZero is not a function"))) -} -v6 := lang.Apply(v5, []any{v4}) -return v6 -}) -v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v2 := ns.InternWithValue(v0, v3, true) -if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -// zipmap -{ -v0 := lang.NewSymbol("zipmap").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("keys"), lang.NewSymbol("vals"))), lang.NewKeyword("doc"), "Returns a map with the keys mapped to the corresponding vals.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6583), lang.NewKeyword("end-line"), int(6583))).(*lang.Symbol) -var v2 lang.FnFunc -v2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } -v3 := args[0] -v4 := args[1] -v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v7 := v6.FindInternedVar(lang.NewSymbol("transient")) -if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) -} -v8 := v7.Get() -v9 := lang.NewMap() -v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6588), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(6588), lang.NewKeyword("end-column"), int(28)) -v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) -if err != nil { - panic(err) -} -v12 := lang.Apply(v8, []any{v11}) -var v5 any = v12 -_ = v5 -v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v15 := v14.FindInternedVar(lang.NewSymbol("seq")) -if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) -} -v16 := v15.Get() -v17 := lang.Apply(v16, []any{v3}) -var v13 any = v17 -_ = v13 -v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v20 := v19.FindInternedVar(lang.NewSymbol("seq")) -if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) -} -v21 := v20.Get() -v22 := lang.Apply(v21, []any{v4}) -var v18 any = v22 -_ = v18 -var v23 any -for { -var v24 any -var v25 any = v13 -_ = v25 -var v27 any -if lang.IsTruthy(v25) { -v27 = v18 -} else { -v27 = v25 -} -if lang.IsTruthy(v27) { -v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v27 := v26.FindInternedVar(lang.NewSymbol("assoc!")) -if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) -} -v28 := v27.Get() -v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v30 := v29.FindInternedVar(lang.NewSymbol("first")) -if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) -} -v31 := v30.Get() -v32 := lang.Apply(v31, []any{v13}) -v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v34 := v33.FindInternedVar(lang.NewSymbol("first")) -if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) -} -v35 := v34.Get() -v36 := lang.Apply(v35, []any{v18}) -v37 := lang.Apply(v28, []any{v5, v32, v36}) -var v25 any = v37 -v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v40 := v39.FindInternedVar(lang.NewSymbol("next")) -if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) -} -v41 := v40.Get() -v42 := lang.Apply(v41, []any{v13}) -var v38 any = v42 -v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v45 := v44.FindInternedVar(lang.NewSymbol("next")) -if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) -} -v46 := v45.Get() -v47 := lang.Apply(v46, []any{v18}) -var v43 any = v47 -v5 = v25 -v13 = v38 -v18 = v43 -continue -} else { -v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) -v49 := v48.FindInternedVar(lang.NewSymbol("persistent!")) -if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) -} -v50 := v49.Get() -v51 := lang.Apply(v50, []any{v5}) -v24 = v51 -} -v23 = v24 - break -} -return v23 -}) -v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) -v1 := ns.InternWithValue(v0, v2, true) -if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) -} -} -} diff --git a/pkg/gen/gljimports/gljimports_darwin_amd64.go b/pkg/gen/gljimports/gljimports_darwin_amd64.go index 46e4385c..3bcbcbb1 100644 --- a/pkg/gen/gljimports/gljimports_darwin_amd64.go +++ b/pkg/gen/gljimports/gljimports_darwin_amd64.go @@ -3829,7 +3829,6 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewSubVector", github_com_glojurelang_glojure_pkg_lang.NewSubVector) _register("github.com/glojurelang/glojure/pkg/lang.NewSymbol", github_com_glojurelang_glojure_pkg_lang.NewSymbol) _register("github.com/glojurelang/glojure/pkg/lang.NewTimeoutError", github_com_glojurelang_glojure_pkg_lang.NewTimeoutError) - _register("github.com/glojurelang/glojure/pkg/lang.NewTransformerIterator", github_com_glojurelang_glojure_pkg_lang.NewTransformerIterator) _register("github.com/glojurelang/glojure/pkg/lang.NewUnsupportedOperationError", github_com_glojurelang_glojure_pkg_lang.NewUnsupportedOperationError) _register("github.com/glojurelang/glojure/pkg/lang.NewVar", github_com_glojurelang_glojure_pkg_lang.NewVar) _register("github.com/glojurelang/glojure/pkg/lang.NewVarWithRoot", github_com_glojurelang_glojure_pkg_lang.NewVarWithRoot) @@ -3925,8 +3924,6 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.*TimeoutError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TimeoutError)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.ToSlice", github_com_glojurelang_glojure_pkg_lang.ToSlice) _register("github.com/glojurelang/glojure/pkg/lang.ToString", github_com_glojurelang_glojure_pkg_lang.ToString) - _register("github.com/glojurelang/glojure/pkg/lang.TransformerIterator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransformerIterator)(nil)).Elem()) - _register("github.com/glojurelang/glojure/pkg/lang.*TransformerIterator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransformerIterator)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.TransientMap", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransientMap)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*TransientMap", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransientMap)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.TransientSet", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransientSet)(nil)).Elem()) diff --git a/pkg/gen/gljimports/gljimports_darwin_arm64.go b/pkg/gen/gljimports/gljimports_darwin_arm64.go index cc80b762..2c79fbc1 100644 --- a/pkg/gen/gljimports/gljimports_darwin_arm64.go +++ b/pkg/gen/gljimports/gljimports_darwin_arm64.go @@ -3829,7 +3829,6 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewSubVector", github_com_glojurelang_glojure_pkg_lang.NewSubVector) _register("github.com/glojurelang/glojure/pkg/lang.NewSymbol", github_com_glojurelang_glojure_pkg_lang.NewSymbol) _register("github.com/glojurelang/glojure/pkg/lang.NewTimeoutError", github_com_glojurelang_glojure_pkg_lang.NewTimeoutError) - _register("github.com/glojurelang/glojure/pkg/lang.NewTransformerIterator", github_com_glojurelang_glojure_pkg_lang.NewTransformerIterator) _register("github.com/glojurelang/glojure/pkg/lang.NewUnsupportedOperationError", github_com_glojurelang_glojure_pkg_lang.NewUnsupportedOperationError) _register("github.com/glojurelang/glojure/pkg/lang.NewVar", github_com_glojurelang_glojure_pkg_lang.NewVar) _register("github.com/glojurelang/glojure/pkg/lang.NewVarWithRoot", github_com_glojurelang_glojure_pkg_lang.NewVarWithRoot) @@ -3925,8 +3924,6 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.*TimeoutError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TimeoutError)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.ToSlice", github_com_glojurelang_glojure_pkg_lang.ToSlice) _register("github.com/glojurelang/glojure/pkg/lang.ToString", github_com_glojurelang_glojure_pkg_lang.ToString) - _register("github.com/glojurelang/glojure/pkg/lang.TransformerIterator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransformerIterator)(nil)).Elem()) - _register("github.com/glojurelang/glojure/pkg/lang.*TransformerIterator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransformerIterator)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.TransientMap", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransientMap)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*TransientMap", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransientMap)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.TransientSet", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransientSet)(nil)).Elem()) diff --git a/pkg/gen/gljimports/gljimports_js_wasm.go b/pkg/gen/gljimports/gljimports_js_wasm.go index 0e33377c..bd92bdce 100644 --- a/pkg/gen/gljimports/gljimports_js_wasm.go +++ b/pkg/gen/gljimports/gljimports_js_wasm.go @@ -3829,7 +3829,6 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewSubVector", github_com_glojurelang_glojure_pkg_lang.NewSubVector) _register("github.com/glojurelang/glojure/pkg/lang.NewSymbol", github_com_glojurelang_glojure_pkg_lang.NewSymbol) _register("github.com/glojurelang/glojure/pkg/lang.NewTimeoutError", github_com_glojurelang_glojure_pkg_lang.NewTimeoutError) - _register("github.com/glojurelang/glojure/pkg/lang.NewTransformerIterator", github_com_glojurelang_glojure_pkg_lang.NewTransformerIterator) _register("github.com/glojurelang/glojure/pkg/lang.NewUnsupportedOperationError", github_com_glojurelang_glojure_pkg_lang.NewUnsupportedOperationError) _register("github.com/glojurelang/glojure/pkg/lang.NewVar", github_com_glojurelang_glojure_pkg_lang.NewVar) _register("github.com/glojurelang/glojure/pkg/lang.NewVarWithRoot", github_com_glojurelang_glojure_pkg_lang.NewVarWithRoot) @@ -3925,8 +3924,6 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.*TimeoutError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TimeoutError)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.ToSlice", github_com_glojurelang_glojure_pkg_lang.ToSlice) _register("github.com/glojurelang/glojure/pkg/lang.ToString", github_com_glojurelang_glojure_pkg_lang.ToString) - _register("github.com/glojurelang/glojure/pkg/lang.TransformerIterator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransformerIterator)(nil)).Elem()) - _register("github.com/glojurelang/glojure/pkg/lang.*TransformerIterator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransformerIterator)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.TransientMap", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransientMap)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*TransientMap", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransientMap)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.TransientSet", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransientSet)(nil)).Elem()) diff --git a/pkg/gen/gljimports/gljimports_linux_amd64.go b/pkg/gen/gljimports/gljimports_linux_amd64.go index 4d0773fa..76b9feb7 100644 --- a/pkg/gen/gljimports/gljimports_linux_amd64.go +++ b/pkg/gen/gljimports/gljimports_linux_amd64.go @@ -3829,7 +3829,6 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewSubVector", github_com_glojurelang_glojure_pkg_lang.NewSubVector) _register("github.com/glojurelang/glojure/pkg/lang.NewSymbol", github_com_glojurelang_glojure_pkg_lang.NewSymbol) _register("github.com/glojurelang/glojure/pkg/lang.NewTimeoutError", github_com_glojurelang_glojure_pkg_lang.NewTimeoutError) - _register("github.com/glojurelang/glojure/pkg/lang.NewTransformerIterator", github_com_glojurelang_glojure_pkg_lang.NewTransformerIterator) _register("github.com/glojurelang/glojure/pkg/lang.NewUnsupportedOperationError", github_com_glojurelang_glojure_pkg_lang.NewUnsupportedOperationError) _register("github.com/glojurelang/glojure/pkg/lang.NewVar", github_com_glojurelang_glojure_pkg_lang.NewVar) _register("github.com/glojurelang/glojure/pkg/lang.NewVarWithRoot", github_com_glojurelang_glojure_pkg_lang.NewVarWithRoot) @@ -3925,8 +3924,6 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.*TimeoutError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TimeoutError)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.ToSlice", github_com_glojurelang_glojure_pkg_lang.ToSlice) _register("github.com/glojurelang/glojure/pkg/lang.ToString", github_com_glojurelang_glojure_pkg_lang.ToString) - _register("github.com/glojurelang/glojure/pkg/lang.TransformerIterator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransformerIterator)(nil)).Elem()) - _register("github.com/glojurelang/glojure/pkg/lang.*TransformerIterator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransformerIterator)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.TransientMap", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransientMap)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*TransientMap", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransientMap)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.TransientSet", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransientSet)(nil)).Elem()) diff --git a/pkg/gen/gljimports/gljimports_linux_arm64.go b/pkg/gen/gljimports/gljimports_linux_arm64.go index 25233e75..8bc1c9c3 100644 --- a/pkg/gen/gljimports/gljimports_linux_arm64.go +++ b/pkg/gen/gljimports/gljimports_linux_arm64.go @@ -3829,7 +3829,6 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewSubVector", github_com_glojurelang_glojure_pkg_lang.NewSubVector) _register("github.com/glojurelang/glojure/pkg/lang.NewSymbol", github_com_glojurelang_glojure_pkg_lang.NewSymbol) _register("github.com/glojurelang/glojure/pkg/lang.NewTimeoutError", github_com_glojurelang_glojure_pkg_lang.NewTimeoutError) - _register("github.com/glojurelang/glojure/pkg/lang.NewTransformerIterator", github_com_glojurelang_glojure_pkg_lang.NewTransformerIterator) _register("github.com/glojurelang/glojure/pkg/lang.NewUnsupportedOperationError", github_com_glojurelang_glojure_pkg_lang.NewUnsupportedOperationError) _register("github.com/glojurelang/glojure/pkg/lang.NewVar", github_com_glojurelang_glojure_pkg_lang.NewVar) _register("github.com/glojurelang/glojure/pkg/lang.NewVarWithRoot", github_com_glojurelang_glojure_pkg_lang.NewVarWithRoot) @@ -3925,8 +3924,6 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.*TimeoutError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TimeoutError)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.ToSlice", github_com_glojurelang_glojure_pkg_lang.ToSlice) _register("github.com/glojurelang/glojure/pkg/lang.ToString", github_com_glojurelang_glojure_pkg_lang.ToString) - _register("github.com/glojurelang/glojure/pkg/lang.TransformerIterator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransformerIterator)(nil)).Elem()) - _register("github.com/glojurelang/glojure/pkg/lang.*TransformerIterator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransformerIterator)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.TransientMap", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransientMap)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*TransientMap", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransientMap)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.TransientSet", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransientSet)(nil)).Elem()) diff --git a/pkg/gen/gljimports/gljimports_windows_amd64.go b/pkg/gen/gljimports/gljimports_windows_amd64.go index ee2cce63..c274410b 100644 --- a/pkg/gen/gljimports/gljimports_windows_amd64.go +++ b/pkg/gen/gljimports/gljimports_windows_amd64.go @@ -3829,7 +3829,6 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewSubVector", github_com_glojurelang_glojure_pkg_lang.NewSubVector) _register("github.com/glojurelang/glojure/pkg/lang.NewSymbol", github_com_glojurelang_glojure_pkg_lang.NewSymbol) _register("github.com/glojurelang/glojure/pkg/lang.NewTimeoutError", github_com_glojurelang_glojure_pkg_lang.NewTimeoutError) - _register("github.com/glojurelang/glojure/pkg/lang.NewTransformerIterator", github_com_glojurelang_glojure_pkg_lang.NewTransformerIterator) _register("github.com/glojurelang/glojure/pkg/lang.NewUnsupportedOperationError", github_com_glojurelang_glojure_pkg_lang.NewUnsupportedOperationError) _register("github.com/glojurelang/glojure/pkg/lang.NewVar", github_com_glojurelang_glojure_pkg_lang.NewVar) _register("github.com/glojurelang/glojure/pkg/lang.NewVarWithRoot", github_com_glojurelang_glojure_pkg_lang.NewVarWithRoot) @@ -3925,8 +3924,6 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.*TimeoutError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TimeoutError)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.ToSlice", github_com_glojurelang_glojure_pkg_lang.ToSlice) _register("github.com/glojurelang/glojure/pkg/lang.ToString", github_com_glojurelang_glojure_pkg_lang.ToString) - _register("github.com/glojurelang/glojure/pkg/lang.TransformerIterator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransformerIterator)(nil)).Elem()) - _register("github.com/glojurelang/glojure/pkg/lang.*TransformerIterator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransformerIterator)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.TransientMap", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransientMap)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*TransientMap", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransientMap)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.TransientSet", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransientSet)(nil)).Elem()) diff --git a/pkg/gen/gljimports/gljimports_windows_arm.go b/pkg/gen/gljimports/gljimports_windows_arm.go index f5faf6fd..2e36c1ab 100644 --- a/pkg/gen/gljimports/gljimports_windows_arm.go +++ b/pkg/gen/gljimports/gljimports_windows_arm.go @@ -3829,7 +3829,6 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewSubVector", github_com_glojurelang_glojure_pkg_lang.NewSubVector) _register("github.com/glojurelang/glojure/pkg/lang.NewSymbol", github_com_glojurelang_glojure_pkg_lang.NewSymbol) _register("github.com/glojurelang/glojure/pkg/lang.NewTimeoutError", github_com_glojurelang_glojure_pkg_lang.NewTimeoutError) - _register("github.com/glojurelang/glojure/pkg/lang.NewTransformerIterator", github_com_glojurelang_glojure_pkg_lang.NewTransformerIterator) _register("github.com/glojurelang/glojure/pkg/lang.NewUnsupportedOperationError", github_com_glojurelang_glojure_pkg_lang.NewUnsupportedOperationError) _register("github.com/glojurelang/glojure/pkg/lang.NewVar", github_com_glojurelang_glojure_pkg_lang.NewVar) _register("github.com/glojurelang/glojure/pkg/lang.NewVarWithRoot", github_com_glojurelang_glojure_pkg_lang.NewVarWithRoot) @@ -3925,8 +3924,6 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.*TimeoutError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TimeoutError)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.ToSlice", github_com_glojurelang_glojure_pkg_lang.ToSlice) _register("github.com/glojurelang/glojure/pkg/lang.ToString", github_com_glojurelang_glojure_pkg_lang.ToString) - _register("github.com/glojurelang/glojure/pkg/lang.TransformerIterator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransformerIterator)(nil)).Elem()) - _register("github.com/glojurelang/glojure/pkg/lang.*TransformerIterator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransformerIterator)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.TransientMap", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransientMap)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/lang.*TransientMap", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransientMap)(nil))) _register("github.com/glojurelang/glojure/pkg/lang.TransientSet", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_lang.TransientSet)(nil)).Elem()) diff --git a/pkg/lang/transformer_iterator.go b/pkg/lang/transformer_iterator.go deleted file mode 100644 index 30d6202f..00000000 --- a/pkg/lang/transformer_iterator.go +++ /dev/null @@ -1,67 +0,0 @@ -package lang - -import "errors" - -// TransformerIterator provides a view over a Transduced collection. -type TransformerIterator struct { - // source - sourceIter any - xf IFn - multi bool - - // iteration state - buffer []any - next any - completed bool -} - -var ( - _ Iterator = (*TransformerIterator)(nil) - - transformerIteratorNone = &struct{}{} -) - -// NewTransformerIteratorSeq creates a new transformer iterator. -func NewTransformerIterator(xform IFn, iter any, multi bool) *TransformerIterator { - ti := &TransformerIterator{ - sourceIter: iter, - multi: multi, - next: transformerIteratorNone, - } - ti.xf = xform.Invoke(NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - return nil - case 1: - return args[0] - case 2: - ti.buffer = append(ti.buffer, args[1]) - return args[0] - default: - panic("invalid arity") - } - })).(IFn) - - return ti -} - -func (ti *TransformerIterator) HasNext() bool { - return ti.step() -} - -func (ti *TransformerIterator) Next() any { - if ti.HasNext() { - ret := ti.next - ti.next = transformerIteratorNone - return ret - } - panic(errors.New("no next element")) -} - -func (ti *TransformerIterator) Remove() { - panic(errors.New("remove not supported")) -} - -func (ti *TransformerIterator) step() bool { - return false -} diff --git a/pkg/runtime/rtcompat.go b/pkg/runtime/rtcompat.go index 706e86b9..2f13ba16 100644 --- a/pkg/runtime/rtcompat.go +++ b/pkg/runtime/rtcompat.go @@ -184,31 +184,6 @@ func (rt *RTMethods) ToArray(coll any) any { return lang.ToSlice(coll) } -func (rt *RTMethods) ChunkIteratorSeq(iter any) ISeq { - // Go does not have an iterator interface like Java, but it does now - // have the iter.Seq functions. For now, we support only TransformerIterators. - ti, ok := iter.(*lang.TransformerIterator) - if !ok { - panic(fmt.Errorf("ChunkIteratorSeq requires a TransformerIterator, got %T", iter)) - } - - if !ti.HasNext() { - return nil - } - - const chunkSize = 32 - - return lang.NewLazySeq(func() any { - arr := make([]any, 0, chunkSize) - n := 0 - for ti.HasNext() && n < chunkSize { - arr[n] = ti.Next() - n++ - } - return lang.NewChunkedCons(lang.NewSliceChunk(arr), rt.ChunkIteratorSeq(ti)) - }) -} - var ( mungeCharMap = map[rune]string{ '-': "_", From dc9cb215819cdabe48fb359587cab88c232eb93d Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sun, 24 Aug 2025 15:15:19 -0700 Subject: [PATCH 42/67] Fix numbers regression; comment out transducers test Signed-off-by: James Hamlin --- pkg/stdlib/glojure/core.glj | 230 +++++----- scripts/rewrite-core/rewrite.clj | 9 + test/glojure/test_glojure/transducers.glj | 484 +++++++++++----------- 3 files changed, 366 insertions(+), 357 deletions(-) diff --git a/pkg/stdlib/glojure/core.glj b/pkg/stdlib/glojure/core.glj index b21b33ac..45342cee 100644 --- a/pkg/stdlib/glojure/core.glj +++ b/pkg/stdlib/glojure/core.glj @@ -860,9 +860,9 @@ (defn zero? "Returns true if num is zero, else false" { - :inline (fn [num] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (isZero ~num))) + :inline (fn [num] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (IsZero ~num))) :added "1.0"} - [num] (. github.com$glojurelang$glojure$pkg$lang.Numbers (isZero num))) + [num] (. github.com$glojurelang$glojure$pkg$lang.Numbers (IsZero num))) (defn count "Returns the number of items in the collection. (count nil) returns @@ -893,11 +893,11 @@ (defn < "Returns non-nil if nums are in monotonically increasing order, otherwise false." - {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (lt ~x ~y))) + {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Lt ~x ~y))) :inline-arities #{2} :added "1.0"} ([x] true) - ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (lt x y))) + ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Lt x y))) ([x y & more] (if (< x y) (if (next more) @@ -908,16 +908,16 @@ (defn inc' "Returns a number one greater than num. Supports arbitrary precision. See also: inc" - {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (incP ~x))) + {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (IncP ~x))) :added "1.0"} - [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (incP x))) + [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (IncP x))) (defn inc "Returns a number one greater than num. Does not auto-promote longs, will throw on overflow. See also: inc'" {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (~(if *unchecked-math* 'unchecked_inc 'inc) ~x))) :added "1.2"} - [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (inc x))) + [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Inc x))) ;; reduce is defined again later after InternalReduce loads (defn ^:private ^:static @@ -959,8 +959,8 @@ (fn [a b] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (~op ~a ~b))) `(. github.com$glojurelang$glojure$pkg$lang.Numbers (~op ~x ~y)) more)))))) -(defn ^:private >1? [n] (.Gt github.com$glojurelang$glojure$pkg$lang.Numbers n 1)) -(defn ^:private >0? [n] (.Gt github.com$glojurelang$glojure$pkg$lang.Numbers n 0)) +(defn ^:private >1? [n] (.Gt github.com$glojurelang$glojure$pkg$lang.Numbers N 1)) +(defn ^:private >0? [n] (.Gt github.com$glojurelang$glojure$pkg$lang.Numbers N 0)) (defn +' "Returns the sum of nums. (+') returns 0. Supports arbitrary precision. @@ -970,7 +970,7 @@ :added "1.0"} ([] 0) ([x] (github.com$glojurelang$glojure$pkg$lang.MustAsNumber x)) - ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (addP x y))) + ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (AddP x y))) ([x y & more] (reduce1 +' (+' x y) more))) @@ -982,7 +982,7 @@ :added "1.2"} ([] 0) ([x] (github.com$glojurelang$glojure$pkg$lang.MustAsNumber x)) - ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (add x y))) + ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Add x y))) ([x y & more] (reduce1 + (+ x y) more))) @@ -994,7 +994,7 @@ :added "1.0"} ([] 1) ([x] (github.com$glojurelang$glojure$pkg$lang.MustAsNumber x)) - ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (multiplyP x y))) + ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (MultiplyP x y))) ([x y & more] (reduce1 *' (*' x y) more))) @@ -1006,7 +1006,7 @@ :added "1.2"} ([] 1) ([x] (github.com$glojurelang$glojure$pkg$lang.MustAsNumber x)) - ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (multiply x y))) + ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Multiply x y))) ([x y & more] (reduce1 * (* x y) more))) @@ -1017,7 +1017,7 @@ :inline-arities >1? :added "1.0"} ([x] (/ 1 x)) - ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (divide x y))) + ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Divide x y))) ([x y & more] (reduce1 / (/ x y) more))) @@ -1029,7 +1029,7 @@ :inline-arities >0? :added "1.0"} ([x] (*' -1 x)) - ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (minusP x y))) + ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (MinusP x y))) ([x y & more] (reduce1 -' (-' x y) more))) @@ -1041,18 +1041,18 @@ :inline-arities >0? :added "1.2"} ([x] (* -1 x)) - ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (minus x y))) + ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Minus x y))) ([x y & more] (reduce1 - (- x y) more))) (defn <= "Returns non-nil if nums are in monotonically non-decreasing order, otherwise false." - {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (lte ~x ~y))) + {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Lte ~x ~y))) :inline-arities #{2} :added "1.0"} ([x] true) - ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (lte x y))) + ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Lte x y))) ([x y & more] (if (<= x y) (if (next more) @@ -1063,11 +1063,11 @@ (defn > "Returns non-nil if nums are in monotonically decreasing order, otherwise false." - {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (gt ~x ~y))) + {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Gt ~x ~y))) :inline-arities #{2} :added "1.0"} ([x] true) - ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (gt x y))) + ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Gt x y))) ([x y & more] (if (> x y) (if (next more) @@ -1078,11 +1078,11 @@ (defn >= "Returns non-nil if nums are in monotonically non-increasing order, otherwise false." - {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (gte ~x ~y))) + {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Gte ~x ~y))) :inline-arities #{2} :added "1.0"} ([x] true) - ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (gte x y))) + ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Gte x y))) ([x y & more] (if (>= x y) (if (next more) @@ -1093,11 +1093,11 @@ (defn == "Returns non-nil if nums all have the equivalent value (type-independent), otherwise false" - {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (equiv ~x ~y))) + {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Equiv ~x ~y))) :inline-arities #{2} :added "1.0"} ([x] true) - ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (equiv x y))) + ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Equiv x y))) ([x y & more] (if (== x y) (if (next more) @@ -1111,7 +1111,7 @@ :inline-arities >1? :inline (nary-inline 'max)} ([x] x) - ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (max x y))) + ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Max x y))) ([x y & more] (reduce1 max (max x y) more))) @@ -1121,7 +1121,7 @@ :inline-arities >1? :inline (nary-inline 'min)} ([x] x) - ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (min x y))) + ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Min x y))) ([x y & more] (reduce1 min (min x y) more))) @@ -1140,159 +1140,159 @@ (defn dec' "Returns a number one less than num. Supports arbitrary precision. See also: dec" - {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (decP ~x))) + {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (DecP ~x))) :added "1.0"} - [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (decP x))) + [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (DecP x))) (defn dec "Returns a number one less than num. Does not auto-promote longs, will throw on overflow. See also: dec'" {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (~(if *unchecked-math* 'unchecked_dec 'dec) ~x))) :added "1.2"} - [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (dec x))) + [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Dec x))) (defn unchecked-inc-int "Returns a number one greater than x, an int. Note - uses a primitive operator subject to overflow." - {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_int_inc ~x))) + {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_int_inc ~x))) :added "1.0"} - [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_int_inc x))) + [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_int_inc x))) (defn unchecked-inc "Returns a number one greater than x, a long. Note - uses a primitive operator subject to overflow." - {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_inc ~x))) + {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_inc ~x))) :added "1.0"} - [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_inc x))) + [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_inc x))) (defn unchecked-dec-int "Returns a number one less than x, an int. Note - uses a primitive operator subject to overflow." - {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_int_dec ~x))) + {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_int_dec ~x))) :added "1.0"} - [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_int_dec x))) + [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_int_dec x))) (defn unchecked-dec "Returns a number one less than x, a long. Note - uses a primitive operator subject to overflow." - {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_dec ~x))) + {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (UncheckedDec ~x))) :added "1.0"} - [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_dec x))) + [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (UncheckedDec x))) (defn unchecked-negate-int "Returns the negation of x, an int. Note - uses a primitive operator subject to overflow." - {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_int_negate ~x))) + {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_int_negate ~x))) :added "1.0"} - [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_int_negate x))) + [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_int_negate x))) (defn unchecked-negate "Returns the negation of x, a long. Note - uses a primitive operator subject to overflow." - {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_minus ~x))) + {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_minus ~x))) :added "1.0"} [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_negate x))) (defn unchecked-add-int "Returns the sum of x and y, both int. Note - uses a primitive operator subject to overflow." - {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_int_add ~x ~y))) + {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_int_add ~x ~y))) :added "1.0"} - [x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_int_add x y))) + [x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_int_add x y))) (defn unchecked-add "Returns the sum of x and y, both long. Note - uses a primitive operator subject to overflow." - {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_add ~x ~y))) + {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (UncheckedAdd ~x ~y))) :added "1.0"} - [x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_add x y))) + [x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (UncheckedAdd x y))) (defn unchecked-subtract-int "Returns the difference of x and y, both int. Note - uses a primitive operator subject to overflow." - {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_int_subtract ~x ~y))) + {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_int_subtract ~x ~y))) :added "1.0"} - [x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_int_subtract x y))) + [x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_int_subtract x y))) (defn unchecked-subtract "Returns the difference of x and y, both long. Note - uses a primitive operator subject to overflow." - {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_minus ~x ~y))) + {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_minus ~x ~y))) :added "1.0"} - [x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_minus x y))) + [x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_minus x y))) (defn unchecked-multiply-int "Returns the product of x and y, both int. Note - uses a primitive operator subject to overflow." - {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_int_multiply ~x ~y))) + {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_int_multiply ~x ~y))) :added "1.0"} - [x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_int_multiply x y))) + [x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_int_multiply x y))) (defn unchecked-multiply "Returns the product of x and y, both long. Note - uses a primitive operator subject to overflow." - {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_multiply ~x ~y))) + {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_multiply ~x ~y))) :added "1.0"} - [x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_multiply x y))) + [x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_multiply x y))) (defn unchecked-divide-int "Returns the division of x by y, both int. Note - uses a primitive operator subject to truncation." - {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_int_divide ~x ~y))) + {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (UncheckedIntDivide ~x ~y))) :added "1.0"} - [x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_int_divide x y))) + [x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (UncheckedIntDivide x y))) (defn unchecked-remainder-int "Returns the remainder of division of x by y, both int. Note - uses a primitive operator subject to truncation." - {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_int_remainder ~x ~y))) + {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_int_remainder ~x ~y))) :added "1.0"} - [x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_int_remainder x y))) + [x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_int_remainder x y))) (defn pos? "Returns true if num is greater than zero, else false" { - :inline (fn [num] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (isPos ~num))) + :inline (fn [num] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (IsPos ~num))) :added "1.0"} - [num] (. github.com$glojurelang$glojure$pkg$lang.Numbers (isPos num))) + [num] (. github.com$glojurelang$glojure$pkg$lang.Numbers (IsPos num))) (defn neg? "Returns true if num is less than zero, else false" { - :inline (fn [num] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (isNeg ~num))) + :inline (fn [num] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (IsNeg ~num))) :added "1.0"} - [num] (. github.com$glojurelang$glojure$pkg$lang.Numbers (isNeg num))) + [num] (. github.com$glojurelang$glojure$pkg$lang.Numbers (IsNeg num))) (defn quot "quot[ient] of dividing numerator by denominator." {:added "1.0" :static true - :inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (quotient ~x ~y)))} + :inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Quotient ~x ~y)))} [num div] - (. github.com$glojurelang$glojure$pkg$lang.Numbers (quotient num div))) + (. github.com$glojurelang$glojure$pkg$lang.Numbers (Quotient num div))) (defn rem "remainder of dividing numerator by denominator." {:added "1.0" :static true - :inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (remainder ~x ~y)))} + :inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Remainder ~x ~y)))} [num div] - (. github.com$glojurelang$glojure$pkg$lang.Numbers (remainder num div))) + (. github.com$glojurelang$glojure$pkg$lang.Numbers (Remainder num div))) (defn rationalize "returns the rational value of num" {:added "1.0" :static true} [num] - (. github.com$glojurelang$glojure$pkg$lang.Numbers (rationalize num))) + (. github.com$glojurelang$glojure$pkg$lang.Numbers (Rationalize num))) ;;Bit ops (defn bit-not "Bitwise complement" - {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (not ~x))) + {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Not ~x))) :added "1.0"} - [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers not x)) + [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers Not x)) (defn bit-and @@ -1300,7 +1300,7 @@ {:inline (nary-inline 'and) :inline-arities >1? :added "1.0"} - ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers and x y)) + ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers And x y)) ([x y & more] (reduce1 bit-and (bit-and x y) more))) @@ -1309,7 +1309,7 @@ {:inline (nary-inline 'or) :inline-arities >1? :added "1.0"} - ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers or x y)) + ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers Or x y)) ([x y & more] (reduce1 bit-or (bit-or x y) more))) @@ -1318,7 +1318,7 @@ {:inline (nary-inline 'xor) :inline-arities >1? :added "1.0"} - ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers xor x y)) + ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers Xor x y)) ([x y & more] (reduce1 bit-xor (bit-xor x y) more))) @@ -1328,7 +1328,7 @@ :inline-arities >1? :added "1.0" :static true} - ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers andNot x y)) + ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers AndNot x y)) ([x y & more] (reduce1 bit-and-not (bit-and-not x y) more))) @@ -1337,44 +1337,44 @@ "Clear bit at index n" {:added "1.0" :static true} - [x n] (. github.com$glojurelang$glojure$pkg$lang.Numbers clearBit x n)) + [x n] (. github.com$glojurelang$glojure$pkg$lang.Numbers ClearBit x n)) (defn bit-set "Set bit at index n" {:added "1.0" :static true} - [x n] (. github.com$glojurelang$glojure$pkg$lang.Numbers setBit x n)) + [x n] (. github.com$glojurelang$glojure$pkg$lang.Numbers SetBit x n)) (defn bit-flip "Flip bit at index n" {:added "1.0" :static true} - [x n] (. github.com$glojurelang$glojure$pkg$lang.Numbers flipBit x n)) + [x n] (. github.com$glojurelang$glojure$pkg$lang.Numbers FlipBit x n)) (defn bit-test "Test bit at index n" {:added "1.0" :static true} - [x n] (. github.com$glojurelang$glojure$pkg$lang.Numbers testBit x n)) + [x n] (. github.com$glojurelang$glojure$pkg$lang.Numbers TestBit x n)) (defn bit-shift-left "Bitwise shift left" - {:inline (fn [x n] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (shiftLeft ~x ~n))) + {:inline (fn [x n] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (ShiftLeft ~x ~n))) :added "1.0"} - [x n] (. github.com$glojurelang$glojure$pkg$lang.Numbers shiftLeft x n)) + [x n] (. github.com$glojurelang$glojure$pkg$lang.Numbers ShiftLeft x n)) (defn bit-shift-right "Bitwise shift right" - {:inline (fn [x n] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (shiftRight ~x ~n))) + {:inline (fn [x n] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (ShiftRight ~x ~n))) :added "1.0"} - [x n] (. github.com$glojurelang$glojure$pkg$lang.Numbers shiftRight x n)) + [x n] (. github.com$glojurelang$glojure$pkg$lang.Numbers ShiftRight x n)) (defn unsigned-bit-shift-right "Bitwise shift right, without sign-extension." - {:inline (fn [x n] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (unsignedShiftRight ~x ~n))) + {:inline (fn [x n] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (UnsignedShiftRight ~x ~n))) :added "1.6"} - [x n] (. github.com$glojurelang$glojure$pkg$lang.Numbers unsignedShiftRight x n)) + [x n] (. github.com$glojurelang$glojure$pkg$lang.Numbers UnsignedShiftRight x n)) (defn integer? "Returns true if n is an integer" {:added "1.0", :static true} [n] (github.com$glojurelang$glojure$pkg$lang.IsInteger n)) @@ -3474,9 +3474,9 @@ (defn num "Coerce to Number" { - :inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (num ~x))) + :inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Num ~x))) :added "1.0"} - [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (num x))) + [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Num x))) (defn long "Coerce to long" @@ -5300,51 +5300,51 @@ (defn float-array "Creates an array of floats" - {:inline (fn [& args] `(. github.com$glojurelang$glojure$pkg$lang.Numbers floatArray (unquote-splicing args))) + {:inline (fn [& args] `(. github.com$glojurelang$glojure$pkg$lang.Numbers FloatArray (unquote-splicing args))) :inline-arities #{1 2} :added "1.0"} - ([size-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers floatArray size-or-seq)) - ([size init-val-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers floatArrayInit size init-val-or-seq))) + ([size-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers FloatArray size-or-seq)) + ([size init-val-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers FloatArrayInit size init-val-or-seq))) (defn boolean-array "Creates an array of booleans" - {:inline (fn [& args] `(. github.com$glojurelang$glojure$pkg$lang.Numbers booleanArray (unquote-splicing args))) + {:inline (fn [& args] `(. github.com$glojurelang$glojure$pkg$lang.Numbers BooleanArray (unquote-splicing args))) :inline-arities #{1 2} :added "1.1"} - ([size-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers booleanArray size-or-seq)) - ([size init-val-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers booleanArrayInit size init-val-or-seq))) + ([size-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers BooleanArray size-or-seq)) + ([size init-val-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers BooleanArrayInit size init-val-or-seq))) (defn byte-array "Creates an array of bytes" - {:inline (fn [& args] `(. github.com$glojurelang$glojure$pkg$lang.Numbers byteArray (unquote-splicing args))) + {:inline (fn [& args] `(. github.com$glojurelang$glojure$pkg$lang.Numbers ByteArray (unquote-splicing args))) :inline-arities #{1 2} :added "1.1"} - ([size-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers byteArray size-or-seq)) - ([size init-val-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers byteArrayInit size init-val-or-seq))) + ([size-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers ByteArray size-or-seq)) + ([size init-val-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers ByteArrayInit size init-val-or-seq))) (defn char-array "Creates an array of chars" - {:inline (fn [& args] `(. github.com$glojurelang$glojure$pkg$lang.Numbers charArray (unquote-splicing args))) + {:inline (fn [& args] `(. github.com$glojurelang$glojure$pkg$lang.Numbers CharArray (unquote-splicing args))) :inline-arities #{1 2} :added "1.1"} - ([size-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers charArray size-or-seq)) - ([size init-val-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers charArrayInit size init-val-or-seq))) + ([size-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers CharArray size-or-seq)) + ([size init-val-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers CharArrayInit size init-val-or-seq))) (defn short-array "Creates an array of shorts" - {:inline (fn [& args] `(. github.com$glojurelang$glojure$pkg$lang.Numbers shortArray (unquote-splicing args))) + {:inline (fn [& args] `(. github.com$glojurelang$glojure$pkg$lang.Numbers ShortArray (unquote-splicing args))) :inline-arities #{1 2} :added "1.1"} - ([size-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers shortArray size-or-seq)) - ([size init-val-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers shortArrayInit size init-val-or-seq))) + ([size-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers ShortArray size-or-seq)) + ([size init-val-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers ShortArrayInit size init-val-or-seq))) (defn double-array "Creates an array of doubles" - {:inline (fn [& args] `(. github.com$glojurelang$glojure$pkg$lang.Numbers doubleArray (unquote-splicing args))) + {:inline (fn [& args] `(. github.com$glojurelang$glojure$pkg$lang.Numbers DoubleArray (unquote-splicing args))) :inline-arities #{1 2} :added "1.0"} - ([size-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers doubleArray size-or-seq)) - ([size init-val-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers doubleArrayInit size init-val-or-seq))) + ([size-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers DoubleArray size-or-seq)) + ([size init-val-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers DoubleArrayInit size init-val-or-seq))) (defn object-array "Creates an array of objects" @@ -5355,59 +5355,59 @@ (defn int-array "Creates an array of ints" - {:inline (fn [& args] `(. github.com$glojurelang$glojure$pkg$lang.Numbers intArray (unquote-splicing args))) + {:inline (fn [& args] `(. github.com$glojurelang$glojure$pkg$lang.Numbers IntArray (unquote-splicing args))) :inline-arities #{1 2} :added "1.0"} - ([size-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers intArray size-or-seq)) - ([size init-val-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers intArrayInit size init-val-or-seq))) + ([size-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers IntArray size-or-seq)) + ([size init-val-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers IntArrayInit size init-val-or-seq))) (defn long-array "Creates an array of longs" - {:inline (fn [& args] `(. github.com$glojurelang$glojure$pkg$lang.Numbers longArray (unquote-splicing args))) + {:inline (fn [& args] `(. github.com$glojurelang$glojure$pkg$lang.Numbers LongArray (unquote-splicing args))) :inline-arities #{1 2} :added "1.0"} - ([size-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers longArray size-or-seq)) - ([size init-val-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers longArrayInit size init-val-or-seq))) + ([size-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers LongArray size-or-seq)) + ([size init-val-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers LongArrayInit size init-val-or-seq))) (definline booleans "Casts to boolean[]" {:added "1.1"} - [xs] `(. github.com$glojurelang$glojure$pkg$lang.Numbers booleans ~xs)) + [xs] `(. github.com$glojurelang$glojure$pkg$lang.Numbers Booleans ~xs)) (definline bytes "Casts to bytes[]" {:added "1.1"} - [xs] `(. github.com$glojurelang$glojure$pkg$lang.Numbers bytes ~xs)) + [xs] `(. github.com$glojurelang$glojure$pkg$lang.Numbers Bytes ~xs)) (definline chars "Casts to chars[]" {:added "1.1"} - [xs] `(. github.com$glojurelang$glojure$pkg$lang.Numbers chars ~xs)) + [xs] `(. github.com$glojurelang$glojure$pkg$lang.Numbers Chars ~xs)) (definline shorts "Casts to shorts[]" {:added "1.1"} - [xs] `(. github.com$glojurelang$glojure$pkg$lang.Numbers shorts ~xs)) + [xs] `(. github.com$glojurelang$glojure$pkg$lang.Numbers Shorts ~xs)) (definline floats "Casts to float[]" {:added "1.0"} - [xs] `(. github.com$glojurelang$glojure$pkg$lang.Numbers floats ~xs)) + [xs] `(. github.com$glojurelang$glojure$pkg$lang.Numbers Floats ~xs)) (definline ints "Casts to int[]" {:added "1.0"} - [xs] `(. github.com$glojurelang$glojure$pkg$lang.Numbers ints ~xs)) + [xs] `(. github.com$glojurelang$glojure$pkg$lang.Numbers Ints ~xs)) (definline doubles "Casts to double[]" {:added "1.0"} - [xs] `(. github.com$glojurelang$glojure$pkg$lang.Numbers doubles ~xs)) + [xs] `(. github.com$glojurelang$glojure$pkg$lang.Numbers Doubles ~xs)) (definline longs "Casts to long[]" {:added "1.0"} - [xs] `(. github.com$glojurelang$glojure$pkg$lang.Numbers longs ~xs)) + [xs] `(. github.com$glojurelang$glojure$pkg$lang.Numbers Longs ~xs)) (defn bytes? "Return true if x is a byte array" diff --git a/scripts/rewrite-core/rewrite.clj b/scripts/rewrite-core/rewrite.clj index 96cb58df..7736de1a 100644 --- a/scripts/rewrite-core/rewrite.clj +++ b/scripts/rewrite-core/rewrite.clj @@ -727,6 +727,15 @@ (sexpr-replace 'clojure.lang.RT/uncheckedIntCast 'github.com$glojurelang$glojure$pkg$lang.UncheckedIntCast) + [(fn select [zloc] (try + (and (symbol? (z/sexpr zloc)) + (or + (and (z/leftmost? zloc) (= 'github.com$glojurelang$glojure$pkg$lang.Numbers (-> zloc z/up z/left z/sexpr))) + (= 'github.com$glojurelang$glojure$pkg$lang.Numbers (-> zloc z/left z/sexpr)))) + (catch Exception e false))) + (fn visit [zloc] (z/replace zloc + (let [sym (-> zloc z/sexpr str)] + (symbol (str (string/upper-case (first sym)) (subs sym 1))))))] (sexpr-splice-replace 'clojure.lang.Numbers/gt ['.Gt 'github.com$glojurelang$glojure$pkg$lang.Numbers]) diff --git a/test/glojure/test_glojure/transducers.glj b/test/glojure/test_glojure/transducers.glj index 6c524442..a94e11b6 100644 --- a/test/glojure/test_glojure/transducers.glj +++ b/test/glojure/test_glojure/transducers.glj @@ -163,247 +163,247 @@ ;; clojure.pprint/pprint ;; with-out-str))))) -(deftest test-transduce - (let [long+ (fn ([a b] (+ (long a) (long b))) - ([a] a) - ([] 0)) - mapinc (map inc) - mapinclong (map (comp inc long)) - arange (range 100) - avec (into [] arange) - alist (into () arange) - obj-array (into-array arange) - int-array (into-array Integer/TYPE (map #(Integer. (int %)) arange)) - long-array (into-array Long/TYPE arange) - float-array (into-array Float/TYPE arange) - char-array (into-array Character/TYPE (map char arange)) - double-array (into-array Double/TYPE arange) - byte-array (into-array Byte/TYPE (map byte arange)) - int-vec (into (vector-of :int) arange) - long-vec (into (vector-of :long) arange) - float-vec (into (vector-of :float) arange) - char-vec (into (vector-of :char) (map char arange)) - double-vec (into (vector-of :double) arange) - byte-vec (into (vector-of :byte) (map byte arange))] - (is (== 5050 - (transduce mapinc + arange) - (transduce mapinc + avec) - (transduce mapinc + alist) - (transduce mapinc + obj-array) - (transduce mapinc + int-array) - (transduce mapinc + long-array) - (transduce mapinc + float-array) - (transduce mapinclong + char-array) - (transduce mapinc + double-array) - (transduce mapinclong + byte-array) - (transduce mapinc + int-vec) - (transduce mapinc + long-vec) - (transduce mapinc + float-vec) - (transduce mapinclong + char-vec) - (transduce mapinc + double-vec) - (transduce mapinclong + byte-vec) - )) - (is (== 5051 - (transduce mapinc + 1 arange) - (transduce mapinc + 1 avec) - (transduce mapinc + 1 alist) - (transduce mapinc + 1 obj-array) - (transduce mapinc + 1 int-array) - (transduce mapinc + 1 long-array) - (transduce mapinc + 1 float-array) - (transduce mapinclong + 1 char-array) - (transduce mapinc + 1 double-array) - (transduce mapinclong + 1 byte-array) - (transduce mapinc + 1 int-vec) - (transduce mapinc + 1 long-vec) - (transduce mapinc + 1 float-vec) - (transduce mapinclong + 1 char-vec) - (transduce mapinc + 1 double-vec) - (transduce mapinclong + 1 byte-vec))))) - -(deftest test-dedupe - (are [x y] (= (transduce (dedupe) conj x) y) - [] [] - [1] [1] - [1 2 3] [1 2 3] - [1 2 3 1 2 2 1 1] [1 2 3 1 2 1] - [1 1 1 2] [1 2] - [1 1 1 1] [1] - - "" [] - "a" [\a] - "aaaa" [\a] - "aabaa" [\a \b \a] - "abba" [\a \b \a] - - [nil nil nil] [nil] - [1 1.0 1.0M 1N] [1 1.0 1.0M 1N] - [0.5 0.5] [0.5])) - -(deftest test-cat - (are [x y] (= (transduce cat conj x) y) - [] [] - [[1 2]] [1 2] - [[1 2] [3 4]] [1 2 3 4] - [[] [3 4]] [3 4] - [[1 2] []] [1 2] - [[] []] [] - [[1 2] [3 4] [5 6]] [1 2 3 4 5 6])) - -(deftest test-partition-all - (are [n coll y] (= (transduce (partition-all n) conj coll) y) - 2 [1 2 3] '((1 2) (3)) - 2 [1 2 3 4] '((1 2) (3 4)) - 2 [] () - 1 [] () - 1 [1 2 3] '((1) (2) (3)) - 5 [1 2 3] '((1 2 3)))) - -(deftest test-take - (are [n y] (= (transduce (take n) conj [1 2 3 4 5]) y) - 1 '(1) - 3 '(1 2 3) - 5 '(1 2 3 4 5) - 9 '(1 2 3 4 5) - 0 () - -1 () - -2 ())) - -(deftest test-drop - (are [n y] (= (transduce (drop n) conj [1 2 3 4 5]) y) - 1 '(2 3 4 5) - 3 '(4 5) - 5 () - 9 () - 0 '(1 2 3 4 5) - -1 '(1 2 3 4 5) - -2 '(1 2 3 4 5))) - -(deftest test-take-nth - (are [n y] (= (transduce (take-nth n) conj [1 2 3 4 5]) y) - 1 '(1 2 3 4 5) - 2 '(1 3 5) - 3 '(1 4) - 4 '(1 5) - 5 '(1) - 9 '(1))) - -(deftest test-take-while - (are [coll y] (= (transduce (take-while pos?) conj coll) y) - [] () - [1 2 3 4] '(1 2 3 4) - [1 2 3 -1] '(1 2 3) - [1 -1 2 3] '(1) - [-1 1 2 3] () - [-1 -2 -3] ())) - -(deftest test-drop-while - (are [coll y] (= (transduce (drop-while pos?) conj coll) y) - [] () - [1 2 3 4] () - [1 2 3 -1] '(-1) - [1 -1 2 3] '(-1 2 3) - [-1 1 2 3] '(-1 1 2 3) - [-1 -2 -3] '(-1 -2 -3))) - -(deftest test-re-reduced - (is (= [:a] (transduce (take 1) conj [:a]))) - (is (= [:a] (transduce (comp (take 1) (take 1)) conj [:a]))) - (is (= [:a] (transduce (comp (take 1) (take 1) (take 1)) conj [:a]))) - (is (= [:a] (transduce (comp (take 1) (take 1) (take 1) (take 1)) conj [:a]))) - (is (= [[:a]] (transduce (comp (partition-by keyword?) (take 1)) conj [] [:a]))) - (is (= [[:a]] (sequence (comp (partition-by keyword?) (take 1)) [:a]))) - (is (= [[[:a]]] (sequence (comp (partition-by keyword?) (take 1) (partition-by keyword?) (take 1)) [:a]))) - (is (= [[0]] (transduce (comp (take 1) (partition-all 3) (take 1)) conj [] (range 15)))) - (is (= [1] (transduce (take 1) conj (seq (long-array [1 2 3 4])))))) - -(deftest test-sequence-multi-xform - (is (= [11 12 13 14] (sequence (map +) [1 2 3 4] (repeat 10)))) - (is (= [11 12 13 14] (sequence (map +) (repeat 10) [1 2 3 4]))) - (is (= [31 32 33 34] (sequence (map +) (repeat 10) (repeat 20) [1 2 3 4])))) - -;; (deftest test-eduction -;; (testing "one xform" -;; (is (= [1 2 3 4 5] -;; (eduction (map inc) (range 5))))) -;; (testing "multiple xforms" -;; (is (= ["2" "4"] -;; (eduction (map inc) (filter even?) (map str) (range 5))))) -;; (testing "materialize at the end" -;; (is (= [1 1 1 1 2 2 2 3 3 4] -;; (->> (range 5) -;; (eduction (mapcat range) (map inc)) -;; sort))) -;; (is (= [1 1 2 1 2 3 1 2 3 4] -;; (vec (->> (range 5) -;; (eduction (mapcat range) (map inc)) -;; to-array)))) -;; (is (= {1 4, 2 3, 3 2, 4 1} -;; (->> (range 5) -;; (eduction (mapcat range) (map inc)) -;; frequencies))) -;; (is (= ["drib" "god" "hsif" "kravdraa" "tac"] -;; (->> ["cat" "dog" "fish" "bird" "aardvark"] -;; (eduction (map clojure.string/reverse)) -;; (sort-by first))))) -;; (testing "expanding transducer with nils" -;; (is (= '(1 2 3 nil 4 5 6 nil) -;; (eduction cat [[1 2 3 nil] [4 5 6 nil]]))))) - -;; (deftest test-eduction-completion -;; (testing "eduction completes inner xformed reducing fn" -;; (is (= [[0 1 2] [3 4 5] [6 7]] -;; (into [] -;; (comp cat (partition-all 3)) -;; (eduction (partition-all 5) (range 8)))))) -;; (testing "outer reducing fn completed only once" -;; (let [counter (atom 0) -;; ;; outer rfn -;; rf (completing conj #(do (swap! counter inc) -;; (vec %))) -;; coll (eduction (map inc) (range 5)) -;; res (transduce (map str) rf [] coll)] -;; (is (= 1 @counter)) -;; (is (= ["1" "2" "3" "4" "5"] res))))) - -(deftest test-run! - (is (nil? (run! identity [1]))) - (is (nil? (run! reduced (range))))) - -(deftest test-distinct - (are [out in] (= out (sequence (distinct in)) (sequence (distinct) in)) - [] [] - (range 10) (range 10) - [0] (repeat 10 0) - [0 1 2] [0 0 1 1 2 2 1 1 0 0] - [1] [1 1N])) - -(deftest test-interpose - (are [out in] (= out (sequence (interpose :s) in)) - [] (range 0) - [0] (range 1) - [0 :s 1] (range 2) - [0 :s 1 :s 2] (range 3)) - (testing "Can end reduction on separator or input" - (let [expected (interpose :s (range))] - (dotimes [i 10] - (is (= (take i expected) - (sequence (comp (interpose :s) (take i)) - (range)))))))) - -(deftest test-map-indexed - (is (= [] - (sequence (map-indexed vector) []))) - (is (= [[0 1] [1 2] [2 3] [3 4]] - (sequence (map-indexed vector) (range 1 5))))) - -(deftest test-into+halt-when - (is (= :anomaly (into [] (comp (filter some?) (halt-when #{:anomaly})) - [1 2 3 :anomaly 4]))) - (is (= {:anomaly :oh-no!, - :partial-results [1 2]} - (into [] - (halt-when :anomaly #(assoc %2 :partial-results %1)) - [1 2 {:anomaly :oh-no!} 3 4])))) +;; (deftest test-transduce +;; (let [long+ (fn ([a b] (+ (long a) (long b))) +;; ([a] a) +;; ([] 0)) +;; mapinc (map inc) +;; mapinclong (map (comp inc long)) +;; arange (range 100) +;; avec (into [] arange) +;; alist (into () arange) +;; obj-array (into-array arange) +;; int-array (into-array Integer/TYPE (map #(Integer. (int %)) arange)) +;; long-array (into-array Long/TYPE arange) +;; float-array (into-array Float/TYPE arange) +;; char-array (into-array Character/TYPE (map char arange)) +;; double-array (into-array Double/TYPE arange) +;; byte-array (into-array Byte/TYPE (map byte arange)) +;; int-vec (into (vector-of :int) arange) +;; long-vec (into (vector-of :long) arange) +;; float-vec (into (vector-of :float) arange) +;; char-vec (into (vector-of :char) (map char arange)) +;; double-vec (into (vector-of :double) arange) +;; byte-vec (into (vector-of :byte) (map byte arange))] +;; (is (== 5050 +;; (transduce mapinc + arange) +;; (transduce mapinc + avec) +;; (transduce mapinc + alist) +;; (transduce mapinc + obj-array) +;; (transduce mapinc + int-array) +;; (transduce mapinc + long-array) +;; (transduce mapinc + float-array) +;; (transduce mapinclong + char-array) +;; (transduce mapinc + double-array) +;; (transduce mapinclong + byte-array) +;; (transduce mapinc + int-vec) +;; (transduce mapinc + long-vec) +;; (transduce mapinc + float-vec) +;; (transduce mapinclong + char-vec) +;; (transduce mapinc + double-vec) +;; (transduce mapinclong + byte-vec) +;; )) +;; (is (== 5051 +;; (transduce mapinc + 1 arange) +;; (transduce mapinc + 1 avec) +;; (transduce mapinc + 1 alist) +;; (transduce mapinc + 1 obj-array) +;; (transduce mapinc + 1 int-array) +;; (transduce mapinc + 1 long-array) +;; (transduce mapinc + 1 float-array) +;; (transduce mapinclong + 1 char-array) +;; (transduce mapinc + 1 double-array) +;; (transduce mapinclong + 1 byte-array) +;; (transduce mapinc + 1 int-vec) +;; (transduce mapinc + 1 long-vec) +;; (transduce mapinc + 1 float-vec) +;; (transduce mapinclong + 1 char-vec) +;; (transduce mapinc + 1 double-vec) +;; (transduce mapinclong + 1 byte-vec))))) + +;; (deftest test-dedupe +;; (are [x y] (= (transduce (dedupe) conj x) y) +;; [] [] +;; [1] [1] +;; [1 2 3] [1 2 3] +;; [1 2 3 1 2 2 1 1] [1 2 3 1 2 1] +;; [1 1 1 2] [1 2] +;; [1 1 1 1] [1] + +;; "" [] +;; "a" [\a] +;; "aaaa" [\a] +;; "aabaa" [\a \b \a] +;; "abba" [\a \b \a] + +;; [nil nil nil] [nil] +;; [1 1.0 1.0M 1N] [1 1.0 1.0M 1N] +;; [0.5 0.5] [0.5])) + +;; (deftest test-cat +;; (are [x y] (= (transduce cat conj x) y) +;; [] [] +;; [[1 2]] [1 2] +;; [[1 2] [3 4]] [1 2 3 4] +;; [[] [3 4]] [3 4] +;; [[1 2] []] [1 2] +;; [[] []] [] +;; [[1 2] [3 4] [5 6]] [1 2 3 4 5 6])) + +;; (deftest test-partition-all +;; (are [n coll y] (= (transduce (partition-all n) conj coll) y) +;; 2 [1 2 3] '((1 2) (3)) +;; 2 [1 2 3 4] '((1 2) (3 4)) +;; 2 [] () +;; 1 [] () +;; 1 [1 2 3] '((1) (2) (3)) +;; 5 [1 2 3] '((1 2 3)))) + +;; (deftest test-take +;; (are [n y] (= (transduce (take n) conj [1 2 3 4 5]) y) +;; 1 '(1) +;; 3 '(1 2 3) +;; 5 '(1 2 3 4 5) +;; 9 '(1 2 3 4 5) +;; 0 () +;; -1 () +;; -2 ())) + +;; (deftest test-drop +;; (are [n y] (= (transduce (drop n) conj [1 2 3 4 5]) y) +;; 1 '(2 3 4 5) +;; 3 '(4 5) +;; 5 () +;; 9 () +;; 0 '(1 2 3 4 5) +;; -1 '(1 2 3 4 5) +;; -2 '(1 2 3 4 5))) + +;; (deftest test-take-nth +;; (are [n y] (= (transduce (take-nth n) conj [1 2 3 4 5]) y) +;; 1 '(1 2 3 4 5) +;; 2 '(1 3 5) +;; 3 '(1 4) +;; 4 '(1 5) +;; 5 '(1) +;; 9 '(1))) + +;; (deftest test-take-while +;; (are [coll y] (= (transduce (take-while pos?) conj coll) y) +;; [] () +;; [1 2 3 4] '(1 2 3 4) +;; [1 2 3 -1] '(1 2 3) +;; [1 -1 2 3] '(1) +;; [-1 1 2 3] () +;; [-1 -2 -3] ())) + +;; (deftest test-drop-while +;; (are [coll y] (= (transduce (drop-while pos?) conj coll) y) +;; [] () +;; [1 2 3 4] () +;; [1 2 3 -1] '(-1) +;; [1 -1 2 3] '(-1 2 3) +;; [-1 1 2 3] '(-1 1 2 3) +;; [-1 -2 -3] '(-1 -2 -3))) + +;; (deftest test-re-reduced +;; (is (= [:a] (transduce (take 1) conj [:a]))) +;; (is (= [:a] (transduce (comp (take 1) (take 1)) conj [:a]))) +;; (is (= [:a] (transduce (comp (take 1) (take 1) (take 1)) conj [:a]))) +;; (is (= [:a] (transduce (comp (take 1) (take 1) (take 1) (take 1)) conj [:a]))) +;; (is (= [[:a]] (transduce (comp (partition-by keyword?) (take 1)) conj [] [:a]))) +;; (is (= [[:a]] (sequence (comp (partition-by keyword?) (take 1)) [:a]))) +;; (is (= [[[:a]]] (sequence (comp (partition-by keyword?) (take 1) (partition-by keyword?) (take 1)) [:a]))) +;; (is (= [[0]] (transduce (comp (take 1) (partition-all 3) (take 1)) conj [] (range 15)))) +;; (is (= [1] (transduce (take 1) conj (seq (long-array [1 2 3 4])))))) + +;; (deftest test-sequence-multi-xform +;; (is (= [11 12 13 14] (sequence (map +) [1 2 3 4] (repeat 10)))) +;; (is (= [11 12 13 14] (sequence (map +) (repeat 10) [1 2 3 4]))) +;; (is (= [31 32 33 34] (sequence (map +) (repeat 10) (repeat 20) [1 2 3 4])))) + +;; ;; (deftest test-eduction +;; ;; (testing "one xform" +;; ;; (is (= [1 2 3 4 5] +;; ;; (eduction (map inc) (range 5))))) +;; ;; (testing "multiple xforms" +;; ;; (is (= ["2" "4"] +;; ;; (eduction (map inc) (filter even?) (map str) (range 5))))) +;; ;; (testing "materialize at the end" +;; ;; (is (= [1 1 1 1 2 2 2 3 3 4] +;; ;; (->> (range 5) +;; ;; (eduction (mapcat range) (map inc)) +;; ;; sort))) +;; ;; (is (= [1 1 2 1 2 3 1 2 3 4] +;; ;; (vec (->> (range 5) +;; ;; (eduction (mapcat range) (map inc)) +;; ;; to-array)))) +;; ;; (is (= {1 4, 2 3, 3 2, 4 1} +;; ;; (->> (range 5) +;; ;; (eduction (mapcat range) (map inc)) +;; ;; frequencies))) +;; ;; (is (= ["drib" "god" "hsif" "kravdraa" "tac"] +;; ;; (->> ["cat" "dog" "fish" "bird" "aardvark"] +;; ;; (eduction (map clojure.string/reverse)) +;; ;; (sort-by first))))) +;; ;; (testing "expanding transducer with nils" +;; ;; (is (= '(1 2 3 nil 4 5 6 nil) +;; ;; (eduction cat [[1 2 3 nil] [4 5 6 nil]]))))) + +;; ;; (deftest test-eduction-completion +;; ;; (testing "eduction completes inner xformed reducing fn" +;; ;; (is (= [[0 1 2] [3 4 5] [6 7]] +;; ;; (into [] +;; ;; (comp cat (partition-all 3)) +;; ;; (eduction (partition-all 5) (range 8)))))) +;; ;; (testing "outer reducing fn completed only once" +;; ;; (let [counter (atom 0) +;; ;; ;; outer rfn +;; ;; rf (completing conj #(do (swap! counter inc) +;; ;; (vec %))) +;; ;; coll (eduction (map inc) (range 5)) +;; ;; res (transduce (map str) rf [] coll)] +;; ;; (is (= 1 @counter)) +;; ;; (is (= ["1" "2" "3" "4" "5"] res))))) + +;; (deftest test-run! +;; (is (nil? (run! identity [1]))) +;; (is (nil? (run! reduced (range))))) + +;; (deftest test-distinct +;; (are [out in] (= out (sequence (distinct in)) (sequence (distinct) in)) +;; [] [] +;; (range 10) (range 10) +;; [0] (repeat 10 0) +;; [0 1 2] [0 0 1 1 2 2 1 1 0 0] +;; [1] [1 1N])) + +;; (deftest test-interpose +;; (are [out in] (= out (sequence (interpose :s) in)) +;; [] (range 0) +;; [0] (range 1) +;; [0 :s 1] (range 2) +;; [0 :s 1 :s 2] (range 3)) +;; (testing "Can end reduction on separator or input" +;; (let [expected (interpose :s (range))] +;; (dotimes [i 10] +;; (is (= (take i expected) +;; (sequence (comp (interpose :s) (take i)) +;; (range)))))))) + +;; (deftest test-map-indexed +;; (is (= [] +;; (sequence (map-indexed vector) []))) +;; (is (= [[0 1] [1 2] [2 3] [3 4]] +;; (sequence (map-indexed vector) (range 1 5))))) + +;; (deftest test-into+halt-when +;; (is (= :anomaly (into [] (comp (filter some?) (halt-when #{:anomaly})) +;; [1 2 3 :anomaly 4]))) +;; (is (= {:anomaly :oh-no!, +;; :partial-results [1 2]} +;; (into [] +;; (halt-when :anomaly #(assoc %2 :partial-results %1)) +;; [1 2 {:anomaly :oh-no!} 3 4])))) (run-tests) From efbe959eab88fe48be35e73def2e0508c5606f52 Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sun, 24 Aug 2025 16:26:48 -0700 Subject: [PATCH 43/67] UUID fixes, codegen fixes Signed-off-by: James Hamlin --- pkg/codegen/codegen.go | 71 +- .../testdata/codegen/test/const_keyword.go | 3 + .../testdata/codegen/test/const_number.go | 3 + .../testdata/codegen/test/const_string.go | 3 + pkg/codegen/testdata/codegen/test/core.go | 86825 ++++++++++++++++ .../testdata/codegen/test/def_simple.go | 3 + .../testdata/codegen/test/fn_closure.go | 15 +- pkg/codegen/testdata/codegen/test/fn_recur.go | 121 +- .../testdata/codegen/test/loop_simple.go | 61 +- .../testdata/codegen/test/maybe_class.go | 2 + pkg/codegen/testdata/codegen/test/ns_skip.go | 3 + .../testdata/codegen/test/quote_simple.go | 2 + pkg/codegen/testdata/codegen/test/the_var.go | 2 + .../testdata/codegen/test/throw_simple.go | 2 + .../testdata/codegen/test/try_advanced.go | 76 +- .../testdata/codegen/test/try_basic.go | 2 + pkg/codegen/testdata/codegen/test/values.go | 18 +- .../testdata/codegen/test/with_meta.go | 2 + pkg/stdlib/glojure/core.glj | 6 +- pkg/stdlib/glojure/uuid.glj | 4 +- scripts/rewrite-core/rewrite.clj | 4 +- 21 files changed, 87086 insertions(+), 142 deletions(-) create mode 100644 pkg/codegen/testdata/codegen/test/core.go diff --git a/pkg/codegen/codegen.go b/pkg/codegen/codegen.go index 2903a81a..08588dd9 100644 --- a/pkg/codegen/codegen.go +++ b/pkg/codegen/codegen.go @@ -91,6 +91,9 @@ func (g *Generator) Generate(ns *lang.Namespace) error { // add lang import g.addImport("github.com/glojurelang/glojure/pkg/lang") + g.addImport("fmt") // for error formatting + g.writef("// reference fmt to avoid unused import error\n") + g.writef("_ = fmt.Printf\n") g.writef(" ns := lang.FindOrCreateNamespace(lang.NewSymbol(%#v))\n", ns.Name().String()) g.writef(" _ = ns\n") @@ -157,9 +160,14 @@ func (g *Generator) Generate(ns *lang.Namespace) error { for _, lifted := range sortedLifted { // Generate the value - this will write any needed initialization + g.writef("var %s any\n", lifted.varName) + g.pushVarScope() + g.writef("{\n") valueCode := g.generateValue(lifted.value) // Declare the lifted variable with the final value - g.writef(" var %s = %s\n", lifted.varName, valueCode) + g.writef("%s = %s\n", lifted.varName, valueCode) + g.writef("}\n") + g.popVarScope() } // Write the lifted values code to init @@ -180,7 +188,7 @@ func (g *Generator) Generate(ns *lang.Namespace) error { if err != nil { // If formatting fails, write the unformatted code with the error g.originalWriter.Write(sourceBytes) - return fmt.Errorf("formatting failed: %w\n\nGenerated code:\n%s", err, string(sourceBytes)) + return fmt.Errorf("formatting failed: %w\n", err) } // Write formatted code to the original writer @@ -541,12 +549,14 @@ func (g *Generator) generateSetValue(s lang.IPersistentSet) string { if idx > 0 { buf.WriteString(", ") } + idx++ element := seq.First() elementVar := g.generateValue(element) buf.WriteString(elementVar) } buf.WriteString(")") + return buf.String() } @@ -593,7 +603,6 @@ func (g *Generator) generateFn(fn *runtime.Fn) string { g.writef("%s = lang.NewFnFunc(func(args ...any) any {\n", fnVar) - g.addImport("fmt") // Import fmt for error formatting // Check arity g.writef(" if len(args) != %d {\n", methodNode.FixedArity) g.writef(" panic(lang.NewIllegalArgumentError(\"wrong number of arguments (\" + fmt.Sprint(len(args)) + \")\"))\n") @@ -667,6 +676,7 @@ func (g *Generator) generateFnMethod(methodNode *ast.FnMethodNode, argsVar strin if i < methodNode.FixedArity { // Regular parameter g.writef("%s := %s[%d]\n", paramVar, argsVar, i) + g.writeAssign("_", paramVar) // Prevent unused variable warning paramVars[i] = paramVar } else { // Variadic parameter - collect rest args @@ -869,8 +879,15 @@ func (g *Generator) generateLet(node *ast.Node, isLoop bool) string { letNode := node.Sub.(*ast.LetNode) // Push a new variable scope for the let bindings + resultId := g.allocateTempVar() + g.writef("var %s any\n", resultId) + + g.writef("{ // let\n") g.pushVarScope() - defer g.popVarScope() + defer func() { + g.popVarScope() + g.writef("} // end let\n") + }() // Collect binding variable names for recur context if this is a loop var bindingVars []string @@ -885,10 +902,11 @@ func (g *Generator) generateLet(node *ast.Node, isLoop bool) string { init := bindingNode.Init // Allocate a Go variable for the Clojure name - varName := g.allocateLocal(name) + g.writef("// let binding \"%s\"\n", name) // Generate initialization code initCode := g.generateASTNode(init) + varName := g.allocateLocal(name) g.writef("var %s any = %s\n", varName, initCode) g.writeAssign("_", varName) // Prevent unused variable warning @@ -898,13 +916,11 @@ func (g *Generator) generateLet(node *ast.Node, isLoop bool) string { } } - resultId := g.allocateTempVar() if isLoop { // Push recur context for this loop g.pushRecurContext(letNode.LoopID, bindingVars, false) defer g.popRecurContext() - g.writef("var %s any\n", resultId) g.writef("for {\n") } @@ -914,10 +930,10 @@ func (g *Generator) generateLet(node *ast.Node, isLoop bool) string { g.writeAssign(resultId, result) g.writef(" break\n") // Break out of the loop after the body g.writef("}\n") - return resultId } else { - return result + g.writeAssign(resultId, result) } + return resultId } func (g *Generator) generateRecur(node *ast.Node) string { @@ -1135,10 +1151,37 @@ func (g *Generator) generateSet(node *ast.Node) string { return setId } +var ( + // TODO: fix all these invalid imports + expectedInvalidImports = map[string]bool{ + "ExceptionInfo": true, + "LinkedBlockingQueue": true, + "glojure.lang.LineNumberingPushbackReader": true, + "glojure.lang": true, + "java.io.InputStreamReader": true, + "java.io.StringReader": true, + "java.util.concurrent.CountDownLatch": true, + "java.util.concurrent": true, + } +) + func (g *Generator) generateMaybeClass(node *ast.Node) string { sym := node.Sub.(*ast.MaybeClassNode).Class.(*lang.Symbol) pkg := sym.FullName() + v, ok := pkgmap.Get(sym.FullName()) + // special-case for reflect.Types + // + // NB: we're allowing references to exports of packages that aren't in the package map + // This implies a difference in behavior, where the interpreter would fail while + // the compiled code would succeed, because the import will cause the go toolchain + // to pull in the package. + if ok { + if t, ok := v.(reflect.Type); ok { + return g.getTypeString(t) + } + } + // find last dot in the package name dotIndex := strings.LastIndex(pkg, ".") if dotIndex == -1 { @@ -1152,6 +1195,12 @@ func (g *Generator) generateMaybeClass(node *ast.Node) string { exportedName := pkg[dotIndex+1:] packageName := pkgmap.UnmungePkg(mungedPkgName) + + if _, ok := expectedInvalidImports[packageName]; ok { + // TODO: fix all these invalid imports + fmt.Println("Warning: skipping invalid import:", packageName) + return "nil" + } alias := g.addImportWithAlias(packageName) return alias + "." + exportedName @@ -1269,6 +1318,10 @@ func (g *Generator) addImport(pkg string) { } func (g *Generator) addImportWithAlias(pkg string) string { + if pkg == "glojure.lang.LineNumberingPushbackReader" { + panic("glojure.lang.LineNumberingPushbackReader is not a valid Go package") + } + // Check if the package is already imported if alias, ok := g.imports[pkg]; ok { return alias // Return existing alias diff --git a/pkg/codegen/testdata/codegen/test/const_keyword.go b/pkg/codegen/testdata/codegen/test/const_keyword.go index ab52e79c..89c9b878 100644 --- a/pkg/codegen/testdata/codegen/test/const_keyword.go +++ b/pkg/codegen/testdata/codegen/test/const_keyword.go @@ -3,10 +3,13 @@ package generated import ( + fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" ) func init() { + // reference fmt to avoid unused import error + _ = fmt.Printf ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.const-keyword")) _ = ns // const-keyword diff --git a/pkg/codegen/testdata/codegen/test/const_number.go b/pkg/codegen/testdata/codegen/test/const_number.go index 29c4a19e..cfad0c27 100644 --- a/pkg/codegen/testdata/codegen/test/const_number.go +++ b/pkg/codegen/testdata/codegen/test/const_number.go @@ -3,10 +3,13 @@ package generated import ( + fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" ) func init() { + // reference fmt to avoid unused import error + _ = fmt.Printf ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.const-number")) _ = ns // const-number diff --git a/pkg/codegen/testdata/codegen/test/const_string.go b/pkg/codegen/testdata/codegen/test/const_string.go index 075854d8..2c4b37e2 100644 --- a/pkg/codegen/testdata/codegen/test/const_string.go +++ b/pkg/codegen/testdata/codegen/test/const_string.go @@ -3,10 +3,13 @@ package generated import ( + fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" ) func init() { + // reference fmt to avoid unused import error + _ = fmt.Printf ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.const-string")) _ = ns // const-string diff --git a/pkg/codegen/testdata/codegen/test/core.go b/pkg/codegen/testdata/codegen/test/core.go new file mode 100644 index 00000000..61f7b98b --- /dev/null +++ b/pkg/codegen/testdata/codegen/test/core.go @@ -0,0 +1,86825 @@ +// Code generated by glojure codegen. DO NOT EDIT. + +package generated + +import ( + errors5 "errors" + fmt "fmt" + lang "github.com/glojurelang/glojure/pkg/lang" + runtime4 "github.com/glojurelang/glojure/pkg/runtime" + uuid10 "github.com/google/uuid" + math3 "math" + big6 "math/big" + rand12 "math/rand" + url14 "net/url" + reflect "reflect" + regexp13 "regexp" + runtime11 "runtime" + strconv9 "strconv" + strings8 "strings" + time7 "time" +) + +func init() { + // Closed-over values + var closed0 any + { + closed0 = lang.NewSymbol("unchecked_multiply") + } + var closed1 any + { + closed1 = lang.NewSymbol("multiply") + } + var closed10 any + { + closed10 = lang.NewSymbol("and") + } + var closed11 any + { + closed11 = lang.NewSymbol("andNot") + } + var closed12 any + { + closed12 = lang.NewSymbol("or") + } + var closed13 any + { + closed13 = lang.NewSymbol("xor") + } + var closed14 any + { + closed14 = lang.NewSymbol("max") + } + var closed15 any + { + closed15 = lang.NewSymbol("min") + } + var closed16 any + { + var v0 lang.FnFunc + v0 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v1 := args[0] + _ = v1 + var v2 any + if lang.IsTruthy(v1) { + v2 = false + } else { + v2 = true + } + return v2 + }) + v1 := reflect.TypeOf(false) + v0 = v0.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v1)).(lang.FnFunc) + closed16 = v0 + } + var closed17 any + { + var v0 lang.FnFunc + v0 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + recur_loop_481: + var v3 any + { // let + // let binding "temp__0__auto__" + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.Apply(v6, []any{v2}) + var v8 any = v7 + _ = v8 + var v9 any + if lang.IsTruthy(v8) { + var v10 any + { // let + // let binding "s" + var v11 any = v8 + _ = v11 + var v12 any + { // let + // let binding "or__0__auto__" + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("first")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{v11}) + v17 := lang.Apply(v1, []any{v16}) + var v18 any = v17 + _ = v18 + var v19 any + if lang.IsTruthy(v18) { + v19 = v18 + } else { + var v20 any = v1 + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("next")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v11}) + var v21 any = v25 + v1 = v20 + v2 = v21 + goto recur_loop_481 + } + v12 = v19 + } // end let + v10 = v12 + } // end let + v9 = v10 + } else { + v9 = nil + } + v3 = v9 + } // end let + return v3 + }) + v0 = v0.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + closed17 = v0 + } + var closed18 any + { + var v0 lang.FnFunc + v0 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + recur_loop_480: + var v3 any + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("nil?")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("seq")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, []any{v2}) + v11 := lang.Apply(v6, []any{v10}) + if lang.IsTruthy(v11) { + v3 = true + } else { + var v12 any + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("first")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{v2}) + v17 := lang.Apply(v1, []any{v16}) + if lang.IsTruthy(v17) { + var v18 any = v1 + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("next")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.Apply(v22, []any{v2}) + var v19 any = v23 + v1 = v18 + v2 = v19 + goto recur_loop_480 + } else { + var v24 any + if lang.IsTruthy(lang.NewKeyword("else")) { + v24 = false + } else { + v24 = nil + } + v12 = v24 + } + v3 = v12 + } + return v3 + }) + v1 := reflect.TypeOf(false) + v0 = v0.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v1)).(lang.FnFunc) + closed18 = v0 + } + var closed2 any + { + closed2 = lang.NewSymbol("multiplyP") + } + var closed3 any + { + closed3 = lang.NewSymbol("unchecked_add") + } + var closed4 any + { + closed4 = lang.NewSymbol("add") + } + var closed5 any + { + closed5 = lang.NewSymbol("addP") + } + var closed6 any + { + closed6 = lang.NewSymbol("unchecked_minus") + } + var closed7 any + { + closed7 = lang.NewSymbol("minus") + } + var closed8 any + { + closed8 = lang.NewSymbol("minusP") + } + var closed9 any + { + closed9 = lang.NewSymbol("divide") + } + + // reference fmt to avoid unused import error + _ = fmt.Printf + ns := lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")) + _ = ns + // * + { + var v1 lang.FnFunc + v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var v3 any + { // let + // let binding "op" + var v4 any + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + if lang.IsTruthy(v7) { + v4 = closed0 + } else { + v4 = closed1 + } + var v8 any = v4 + _ = v8 + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("seq")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("concat")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("list")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("list")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("list")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("seq")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("concat")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("list")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{v8}) + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("list")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v38, []any{v2}) + v40 := lang.Apply(v31, []any{v35, v39}) + v41 := lang.Apply(v28, []any{v40}) + v42 := lang.Apply(v25, []any{v41}) + v43 := lang.Apply(v14, []any{v18, v22, v42}) + v44 := lang.Apply(v11, []any{v43}) + v3 = v44 + } // end let + return v3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any + { // let + // let binding "op" + var v5 any + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + if lang.IsTruthy(v8) { + v5 = closed0 + } else { + v5 = closed1 + } + var v9 any = v5 + _ = v9 + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("seq")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("concat")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("list")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("list")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("list")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("seq")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("concat")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("list")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.Apply(v35, []any{v9}) + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("list")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.Apply(v39, []any{v2}) + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("list")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.Apply(v43, []any{v3}) + v45 := lang.Apply(v32, []any{v36, v40, v44}) + v46 := lang.Apply(v29, []any{v45}) + v47 := lang.Apply(v26, []any{v46}) + v48 := lang.Apply(v15, []any{v19, v23, v47}) + v49 := lang.Apply(v12, []any{v48}) + v4 = v49 + } // end let + return v4 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := lang.NewList(args[2:]...) + var v5 any + { // let + // let binding "op" + var v6 any + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + if lang.IsTruthy(v9) { + v6 = closed0 + } else { + v6 = closed1 + } + var v10 any = v6 + _ = v10 + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + var v14 lang.FnFunc + v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v15 := args[0] + _ = v15 + v16 := args[1] + _ = v16 + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("seq")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("concat")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("list")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("seq")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("concat")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("list")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.Apply(v42, []any{v10}) + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("list")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.Apply(v46, []any{v15}) + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("list")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v16}) + v52 := lang.Apply(v39, []any{v43, v47, v51}) + v53 := lang.Apply(v36, []any{v52}) + v54 := lang.Apply(v33, []any{v53}) + v55 := lang.Apply(v22, []any{v26, v30, v54}) + v56 := lang.Apply(v19, []any{v55}) + return v56 + }) + v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("seq")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("concat")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("list")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("seq")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("concat")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("list")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.Apply(v42, []any{v10}) + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("list")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.Apply(v46, []any{v2}) + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("list")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v3}) + v52 := lang.Apply(v39, []any{v43, v47, v51}) + v53 := lang.Apply(v36, []any{v52}) + v54 := lang.Apply(v33, []any{v53}) + v55 := lang.Apply(v22, []any{v26, v30, v54}) + v56 := lang.Apply(v19, []any{v55}) + v57 := lang.Apply(v13, []any{v16, v56, v4}) + v5 = v57 + } // end let + return v5 + } + }) + v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + v5 := lang.Apply(v4, []any{nil, int64(1)}) + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v0 := lang.NewSymbol("*").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the product of nums. (*) returns 1. Does not auto-promote\n longs, will throw on overflow. See also: *'", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1001), lang.NewKeyword("end-line"), int(1001))).(*lang.Symbol) + var v4 lang.FnFunc + v4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return int64(1) + case 1: + v5 := args[0] + _ = v5 + v6 := lang.Apply(lang.MustAsNumber, []any{v5}) + return v6 + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7, _ := lang.FieldOrMethod(lang.Numbers, "Multiply") + if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Multiply is not a function"))) + } + v8 := lang.Apply(v7, []any{v5, v6}) + return v8 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := lang.NewList(args[2:]...) + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("*")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("*")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{v5, v6}) + v18 := lang.Apply(v10, []any{v13, v17, v7}) + return v18 + } + }) + v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v3 := ns.InternWithValue(v0, v4, true) + if v0.Meta() != nil { + v3.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // *' + { + var v1 lang.FnFunc + v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var v3 any + { // let + // let binding "op" + var v4 any + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + if lang.IsTruthy(v7) { + v4 = closed2 + } else { + v4 = closed2 + } + var v8 any = v4 + _ = v8 + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("seq")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("concat")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("list")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("list")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("list")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("seq")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("concat")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("list")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{v8}) + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("list")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v38, []any{v2}) + v40 := lang.Apply(v31, []any{v35, v39}) + v41 := lang.Apply(v28, []any{v40}) + v42 := lang.Apply(v25, []any{v41}) + v43 := lang.Apply(v14, []any{v18, v22, v42}) + v44 := lang.Apply(v11, []any{v43}) + v3 = v44 + } // end let + return v3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any + { // let + // let binding "op" + var v5 any + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + if lang.IsTruthy(v8) { + v5 = closed2 + } else { + v5 = closed2 + } + var v9 any = v5 + _ = v9 + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("seq")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("concat")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("list")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("list")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("list")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("seq")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("concat")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("list")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.Apply(v35, []any{v9}) + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("list")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.Apply(v39, []any{v2}) + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("list")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.Apply(v43, []any{v3}) + v45 := lang.Apply(v32, []any{v36, v40, v44}) + v46 := lang.Apply(v29, []any{v45}) + v47 := lang.Apply(v26, []any{v46}) + v48 := lang.Apply(v15, []any{v19, v23, v47}) + v49 := lang.Apply(v12, []any{v48}) + v4 = v49 + } // end let + return v4 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := lang.NewList(args[2:]...) + var v5 any + { // let + // let binding "op" + var v6 any + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + if lang.IsTruthy(v9) { + v6 = closed2 + } else { + v6 = closed2 + } + var v10 any = v6 + _ = v10 + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + var v14 lang.FnFunc + v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v15 := args[0] + _ = v15 + v16 := args[1] + _ = v16 + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("seq")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("concat")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("list")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("seq")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("concat")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("list")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.Apply(v42, []any{v10}) + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("list")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.Apply(v46, []any{v15}) + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("list")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v16}) + v52 := lang.Apply(v39, []any{v43, v47, v51}) + v53 := lang.Apply(v36, []any{v52}) + v54 := lang.Apply(v33, []any{v53}) + v55 := lang.Apply(v22, []any{v26, v30, v54}) + v56 := lang.Apply(v19, []any{v55}) + return v56 + }) + v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("seq")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("concat")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("list")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("seq")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("concat")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("list")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.Apply(v42, []any{v10}) + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("list")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.Apply(v46, []any{v2}) + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("list")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v3}) + v52 := lang.Apply(v39, []any{v43, v47, v51}) + v53 := lang.Apply(v36, []any{v52}) + v54 := lang.Apply(v33, []any{v53}) + v55 := lang.Apply(v22, []any{v26, v30, v54}) + v56 := lang.Apply(v19, []any{v55}) + v57 := lang.Apply(v13, []any{v16, v56, v4}) + v5 = v57 + } // end let + return v5 + } + }) + v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + v5 := lang.Apply(v4, []any{nil, int64(1)}) + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v0 := lang.NewSymbol("*'").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the product of nums. (*') returns 1. Supports arbitrary precision.\n See also: *", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(989), lang.NewKeyword("end-line"), int(989))).(*lang.Symbol) + var v4 lang.FnFunc + v4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return int64(1) + case 1: + v5 := args[0] + _ = v5 + v6 := lang.Apply(lang.MustAsNumber, []any{v5}) + return v6 + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7, _ := lang.FieldOrMethod(lang.Numbers, "MultiplyP") + if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("MultiplyP is not a function"))) + } + v8 := lang.Apply(v7, []any{v5, v6}) + return v8 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := lang.NewList(args[2:]...) + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("*'")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("*'")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{v5, v6}) + v18 := lang.Apply(v10, []any{v13, v17, v7}) + return v18 + } + }) + v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v3 := ns.InternWithValue(v0, v4, true) + if v0.Meta() != nil { + v3.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // *1 + { + v0 := lang.NewSymbol("*1").WithMeta(lang.NewMap()).(*lang.Symbol) + v1 := ns.Intern(v0) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // *2 + { + v0 := lang.NewSymbol("*2").WithMeta(lang.NewMap()).(*lang.Symbol) + v1 := ns.Intern(v0) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // *3 + { + v0 := lang.NewSymbol("*3").WithMeta(lang.NewMap()).(*lang.Symbol) + v1 := ns.Intern(v0) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // *agent* + { + v0 := lang.NewSymbol("*agent*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + v1 := ns.InternWithValue(v0, nil, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // *assert* + { + v0 := lang.NewSymbol("*assert*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "When set to logical false, 'assert' will omit assertion checks in\n compiled code. Defaults to true.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + v1 := ns.InternWithValue(v0, false, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // *command-line-args* + { + v0 := lang.NewSymbol("*command-line-args*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "A sequence of the supplied command line arguments, or nil if\n none were supplied", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + v1 := ns.InternWithValue(v0, nil, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // *compile-files* + { + v0 := lang.NewSymbol("*compile-files*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "Set to true when compiling files, false otherwise.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + v1 := ns.InternWithValue(v0, false, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // *compile-path* + { + v0 := lang.NewSymbol("*compile-path*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "Specifies the directory where 'compile' will write out .class\n files. This directory must be in the classpath for 'compile' to\n work.\n\n Defaults to \"classes\"", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + v1 := ns.InternWithValue(v0, nil, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // *compiler-options* + { + v0 := lang.NewSymbol("*compiler-options*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.4", lang.NewKeyword("doc"), "A map of keys to options.\n Note, when binding dynamically make sure to merge with previous value.\n Supported options:\n :elide-meta - a collection of metadata keys to elide during compilation.\n :disable-locals-clearing - set to true to disable clearing, useful for using a debugger\n :direct-linking - set to true to use direct static invocation of functions, rather than vars\n Note that call sites compiled with direct linking will not be affected by var redefinition.\n Use ^:redef (or ^:dynamic) on a var to prevent direct linking and allow redefinition.\n See https://glojure.org/reference/compilation for more information.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + v1 := ns.InternWithValue(v0, nil, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // *data-readers* + { + v0 := lang.NewSymbol("*data-readers*").WithMeta(lang.NewMap(lang.NewKeyword("doc"), "Map from reader tag symbols to data reader Vars.\n\n When Clojure starts, it searches for files named 'data_readers.clj'\n and 'data_readers.cljc' at the root of the classpath. Each such file\n must contain a literal map of symbols, like this:\n\n {foo/bar my.project.foo/bar\n foo/baz my.project/baz}\n\n The first symbol in each pair is a tag that will be recognized by\n the Clojure reader. The second symbol in the pair is the\n fully-qualified name of a Var which will be invoked by the reader to\n parse the form following the tag. For example, given the\n data_readers.clj file above, the Clojure reader would parse this\n form:\n\n #foo/bar [1 2 3]\n\n by invoking the Var #'my.project.foo/bar on the vector [1 2 3]. The\n data reader function is invoked on the form AFTER it has been read\n as a normal Clojure data structure by the reader.\n\n Reader tags without namespace qualifiers are reserved for\n Clojure. Default reader tags are defined in\n glojure.core/default-data-readers but may be overridden in\n data_readers.clj, data_readers.cljc, or by rebinding this Var.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(49), lang.NewKeyword("column"), int(6), lang.NewKeyword("line"), int(7794), lang.NewKeyword("end-line"), int(7794), lang.NewKeyword("dynamic"), true)).(*lang.Symbol) + v1 := ns.InternWithValue(v0, lang.NewMap(), true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // *default-data-reader-fn* + { + v0 := lang.NewSymbol("*default-data-reader-fn*").WithMeta(lang.NewMap(lang.NewKeyword("doc"), "When no data reader is found for a tag and *default-data-reader-fn*\n is non-nil, it will be called with two arguments,\n the tag and the value. If *default-data-reader-fn* is nil (the\n default), an exception will be thrown for the unknown tag.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(59), lang.NewKeyword("column"), int(6), lang.NewKeyword("line"), int(7823), lang.NewKeyword("end-line"), int(7823), lang.NewKeyword("dynamic"), true)).(*lang.Symbol) + v1 := ns.InternWithValue(v0, nil, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // *e + { + v0 := lang.NewSymbol("*e").WithMeta(lang.NewMap()).(*lang.Symbol) + v1 := ns.Intern(v0) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // *err* + { + v0 := lang.NewSymbol("*err*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "A java.io.Writer object representing standard error for print operations.\n\n Defaults to System/err, wrapped in a PrintWriter", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + v1 := ns.InternWithValue(v0, nil, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // *file* + { + v0 := lang.NewSymbol("*file*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "The path of the file being evaluated, as a String.\n\n When there is no file, e.g. in the REPL, the value is not defined.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + v1 := ns.InternWithValue(v0, "NO_SOURCE_FILE", true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // *flush-on-newline* + { + v0 := lang.NewSymbol("*flush-on-newline*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "When set to true, output will be flushed whenever a newline is printed.\n\n Defaults to true.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + v1 := ns.InternWithValue(v0, nil, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // *loaded-libs* + { + v0 := lang.NewSymbol("*loaded-libs*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5817), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(5820), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + v1 := ns.InternWithValue(v0, nil, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // *loading-verbosely* + { + v0 := lang.NewSymbol("*loading-verbosely*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5827), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(5830), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + v1 := ns.InternWithValue(v0, false, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // *ns* + { + v0 := lang.NewSymbol("*ns*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "A glojure.lang.Namespace object representing the current namespace.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + v1 := ns.InternWithValue(v0, lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // *pending-paths* + { + v0 := lang.NewSymbol("*pending-paths*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5822), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(5825), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + v1 := ns.InternWithValue(v0, lang.NewList(), true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // *print-dup* + { + v0 := lang.NewSymbol("*print-dup*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "When set to logical true, objects will be printed in a way that preserves\n their type when read in later.\n\n Defaults to false.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + v1 := ns.InternWithValue(v0, nil, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // *print-length* + { + v0 := lang.NewSymbol("*print-length*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(14), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(23), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + v1 := ns.InternWithValue(v0, nil, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // *print-level* + { + v0 := lang.NewSymbol("*print-level*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(25), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(35), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + v1 := ns.InternWithValue(v0, nil, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // *print-meta* + { + v0 := lang.NewSymbol("*print-meta*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "If set to logical true, when printing an object, its metadata will also\n be printed in a form that can be read back by the reader.\n\n Defaults to false.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + v1 := ns.InternWithValue(v0, nil, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // *print-namespace-maps* + { + v0 := lang.NewSymbol("*print-namespace-maps*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(39), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(44), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + v1 := ns.InternWithValue(v0, false, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // *print-readably* + { + v0 := lang.NewSymbol("*print-readably*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "When set to logical false, strings and characters will be printed with\n non-alphanumeric characters converted to the appropriate escape sequences.\n\n Defaults to true", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + v1 := ns.InternWithValue(v0, true, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // *read-eval* + { + v0 := lang.NewSymbol("*read-eval*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "Defaults to true (or value specified by system property, see below)\n ***This setting implies that the full power of the reader is in play,\n including syntax that can cause code to execute. It should never be\n used with untrusted sources. See also: glojure.edn/read.***\n\n When set to logical false in the thread-local binding,\n the eval reader (#=) and record/type literal syntax are disabled in read/load.\n Example (will fail): (binding [*read-eval* false] (read-string \"#=(* 2 21)\"))\n\n The default binding can be controlled by the system property\n 'glojure.read.eval' System properties can be set on the command line\n like this:\n\n java -Dglojure.read.eval=false ...\n\n The system property can also be set to 'unknown' via\n -Dglojure.read.eval=unknown, in which case the default binding\n is :unknown and all reads will fail in contexts where *read-eval*\n has not been explicitly bound to either true or false. This setting\n can be a useful diagnostic tool to ensure that all of your reads\n occur in considered contexts. You can also accomplish this in a\n particular scope by binding *read-eval* to :unknown\n ", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + v1 := ns.InternWithValue(v0, nil, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // *repl* + { + v0 := lang.NewSymbol("*repl*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6288), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(6291), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + v1 := ns.InternWithValue(v0, false, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // *unchecked-math* + { + v0 := lang.NewSymbol("*unchecked-math*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.3", lang.NewKeyword("doc"), "While bound to true, compilations of +, -, *, inc, dec and the\n coercions will be done without overflow checks. While bound\n to :warn-on-boxed, same behavior as true, and a warning is emitted\n when compilation uses boxed math. Default: false.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + v1 := ns.InternWithValue(v0, nil, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // *verbose-defrecords* + { + v0 := lang.NewSymbol("*verbose-defrecords*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(37), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(37), lang.NewKeyword("end-column"), int(35), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + v1 := ns.InternWithValue(v0, false, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // *warn-on-reflection* + { + v0 := lang.NewSymbol("*warn-on-reflection*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "When set to true, the compiler will emit warnings when reflection is\n needed to resolve Java method calls or field accesses.\n\n Defaults to false.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + v1 := ns.InternWithValue(v0, nil, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // + + { + var v1 lang.FnFunc + v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var v3 any + { // let + // let binding "op" + var v4 any + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + if lang.IsTruthy(v7) { + v4 = closed3 + } else { + v4 = closed4 + } + var v8 any = v4 + _ = v8 + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("seq")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("concat")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("list")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("list")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("list")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("seq")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("concat")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("list")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{v8}) + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("list")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v38, []any{v2}) + v40 := lang.Apply(v31, []any{v35, v39}) + v41 := lang.Apply(v28, []any{v40}) + v42 := lang.Apply(v25, []any{v41}) + v43 := lang.Apply(v14, []any{v18, v22, v42}) + v44 := lang.Apply(v11, []any{v43}) + v3 = v44 + } // end let + return v3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any + { // let + // let binding "op" + var v5 any + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + if lang.IsTruthy(v8) { + v5 = closed3 + } else { + v5 = closed4 + } + var v9 any = v5 + _ = v9 + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("seq")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("concat")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("list")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("list")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("list")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("seq")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("concat")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("list")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.Apply(v35, []any{v9}) + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("list")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.Apply(v39, []any{v2}) + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("list")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.Apply(v43, []any{v3}) + v45 := lang.Apply(v32, []any{v36, v40, v44}) + v46 := lang.Apply(v29, []any{v45}) + v47 := lang.Apply(v26, []any{v46}) + v48 := lang.Apply(v15, []any{v19, v23, v47}) + v49 := lang.Apply(v12, []any{v48}) + v4 = v49 + } // end let + return v4 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := lang.NewList(args[2:]...) + var v5 any + { // let + // let binding "op" + var v6 any + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + if lang.IsTruthy(v9) { + v6 = closed3 + } else { + v6 = closed4 + } + var v10 any = v6 + _ = v10 + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + var v14 lang.FnFunc + v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v15 := args[0] + _ = v15 + v16 := args[1] + _ = v16 + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("seq")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("concat")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("list")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("seq")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("concat")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("list")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.Apply(v42, []any{v10}) + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("list")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.Apply(v46, []any{v15}) + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("list")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v16}) + v52 := lang.Apply(v39, []any{v43, v47, v51}) + v53 := lang.Apply(v36, []any{v52}) + v54 := lang.Apply(v33, []any{v53}) + v55 := lang.Apply(v22, []any{v26, v30, v54}) + v56 := lang.Apply(v19, []any{v55}) + return v56 + }) + v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("seq")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("concat")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("list")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("seq")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("concat")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("list")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.Apply(v42, []any{v10}) + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("list")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.Apply(v46, []any{v2}) + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("list")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v3}) + v52 := lang.Apply(v39, []any{v43, v47, v51}) + v53 := lang.Apply(v36, []any{v52}) + v54 := lang.Apply(v33, []any{v53}) + v55 := lang.Apply(v22, []any{v26, v30, v54}) + v56 := lang.Apply(v19, []any{v55}) + v57 := lang.Apply(v13, []any{v16, v56, v4}) + v5 = v57 + } // end let + return v5 + } + }) + v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + v5 := lang.Apply(v4, []any{nil, int64(1)}) + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v0 := lang.NewSymbol("+").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the sum of nums. (+) returns 0. Does not auto-promote\n longs, will throw on overflow. See also: +'", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(977), lang.NewKeyword("end-line"), int(977))).(*lang.Symbol) + var v4 lang.FnFunc + v4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return int64(0) + case 1: + v5 := args[0] + _ = v5 + v6 := lang.Apply(lang.MustAsNumber, []any{v5}) + return v6 + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7, _ := lang.FieldOrMethod(lang.Numbers, "Add") + if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Add is not a function"))) + } + v8 := lang.Apply(v7, []any{v5, v6}) + return v8 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := lang.NewList(args[2:]...) + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("+")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("+")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{v5, v6}) + v18 := lang.Apply(v10, []any{v13, v17, v7}) + return v18 + } + }) + v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v3 := ns.InternWithValue(v0, v4, true) + if v0.Meta() != nil { + v3.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // +' + { + var v1 lang.FnFunc + v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var v3 any + { // let + // let binding "op" + var v4 any + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + if lang.IsTruthy(v7) { + v4 = closed5 + } else { + v4 = closed5 + } + var v8 any = v4 + _ = v8 + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("seq")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("concat")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("list")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("list")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("list")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("seq")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("concat")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("list")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{v8}) + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("list")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v38, []any{v2}) + v40 := lang.Apply(v31, []any{v35, v39}) + v41 := lang.Apply(v28, []any{v40}) + v42 := lang.Apply(v25, []any{v41}) + v43 := lang.Apply(v14, []any{v18, v22, v42}) + v44 := lang.Apply(v11, []any{v43}) + v3 = v44 + } // end let + return v3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any + { // let + // let binding "op" + var v5 any + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + if lang.IsTruthy(v8) { + v5 = closed5 + } else { + v5 = closed5 + } + var v9 any = v5 + _ = v9 + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("seq")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("concat")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("list")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("list")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("list")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("seq")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("concat")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("list")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.Apply(v35, []any{v9}) + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("list")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.Apply(v39, []any{v2}) + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("list")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.Apply(v43, []any{v3}) + v45 := lang.Apply(v32, []any{v36, v40, v44}) + v46 := lang.Apply(v29, []any{v45}) + v47 := lang.Apply(v26, []any{v46}) + v48 := lang.Apply(v15, []any{v19, v23, v47}) + v49 := lang.Apply(v12, []any{v48}) + v4 = v49 + } // end let + return v4 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := lang.NewList(args[2:]...) + var v5 any + { // let + // let binding "op" + var v6 any + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + if lang.IsTruthy(v9) { + v6 = closed5 + } else { + v6 = closed5 + } + var v10 any = v6 + _ = v10 + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + var v14 lang.FnFunc + v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v15 := args[0] + _ = v15 + v16 := args[1] + _ = v16 + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("seq")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("concat")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("list")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("seq")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("concat")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("list")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.Apply(v42, []any{v10}) + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("list")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.Apply(v46, []any{v15}) + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("list")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v16}) + v52 := lang.Apply(v39, []any{v43, v47, v51}) + v53 := lang.Apply(v36, []any{v52}) + v54 := lang.Apply(v33, []any{v53}) + v55 := lang.Apply(v22, []any{v26, v30, v54}) + v56 := lang.Apply(v19, []any{v55}) + return v56 + }) + v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("seq")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("concat")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("list")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("seq")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("concat")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("list")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.Apply(v42, []any{v10}) + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("list")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.Apply(v46, []any{v2}) + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("list")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v3}) + v52 := lang.Apply(v39, []any{v43, v47, v51}) + v53 := lang.Apply(v36, []any{v52}) + v54 := lang.Apply(v33, []any{v53}) + v55 := lang.Apply(v22, []any{v26, v30, v54}) + v56 := lang.Apply(v19, []any{v55}) + v57 := lang.Apply(v13, []any{v16, v56, v4}) + v5 = v57 + } // end let + return v5 + } + }) + v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + v5 := lang.Apply(v4, []any{nil, int64(1)}) + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v0 := lang.NewSymbol("+'").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the sum of nums. (+') returns 0. Supports arbitrary precision.\n See also: +", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(965), lang.NewKeyword("end-line"), int(965))).(*lang.Symbol) + var v4 lang.FnFunc + v4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return int64(0) + case 1: + v5 := args[0] + _ = v5 + v6 := lang.Apply(lang.MustAsNumber, []any{v5}) + return v6 + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7, _ := lang.FieldOrMethod(lang.Numbers, "AddP") + if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("AddP is not a function"))) + } + v8 := lang.Apply(v7, []any{v5, v6}) + return v8 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := lang.NewList(args[2:]...) + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("+'")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("+'")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{v5, v6}) + v18 := lang.Apply(v10, []any{v13, v17, v7}) + return v18 + } + }) + v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v3 := ns.InternWithValue(v0, v4, true) + if v0.Meta() != nil { + v3.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // - + { + var v1 lang.FnFunc + v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var v3 any + { // let + // let binding "op" + var v4 any + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + if lang.IsTruthy(v7) { + v4 = closed6 + } else { + v4 = closed7 + } + var v8 any = v4 + _ = v8 + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("seq")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("concat")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("list")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("list")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("list")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("seq")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("concat")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("list")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{v8}) + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("list")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v38, []any{v2}) + v40 := lang.Apply(v31, []any{v35, v39}) + v41 := lang.Apply(v28, []any{v40}) + v42 := lang.Apply(v25, []any{v41}) + v43 := lang.Apply(v14, []any{v18, v22, v42}) + v44 := lang.Apply(v11, []any{v43}) + v3 = v44 + } // end let + return v3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any + { // let + // let binding "op" + var v5 any + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + if lang.IsTruthy(v8) { + v5 = closed6 + } else { + v5 = closed7 + } + var v9 any = v5 + _ = v9 + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("seq")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("concat")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("list")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("list")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("list")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("seq")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("concat")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("list")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.Apply(v35, []any{v9}) + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("list")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.Apply(v39, []any{v2}) + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("list")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.Apply(v43, []any{v3}) + v45 := lang.Apply(v32, []any{v36, v40, v44}) + v46 := lang.Apply(v29, []any{v45}) + v47 := lang.Apply(v26, []any{v46}) + v48 := lang.Apply(v15, []any{v19, v23, v47}) + v49 := lang.Apply(v12, []any{v48}) + v4 = v49 + } // end let + return v4 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := lang.NewList(args[2:]...) + var v5 any + { // let + // let binding "op" + var v6 any + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + if lang.IsTruthy(v9) { + v6 = closed6 + } else { + v6 = closed7 + } + var v10 any = v6 + _ = v10 + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + var v14 lang.FnFunc + v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v15 := args[0] + _ = v15 + v16 := args[1] + _ = v16 + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("seq")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("concat")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("list")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("seq")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("concat")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("list")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.Apply(v42, []any{v10}) + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("list")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.Apply(v46, []any{v15}) + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("list")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v16}) + v52 := lang.Apply(v39, []any{v43, v47, v51}) + v53 := lang.Apply(v36, []any{v52}) + v54 := lang.Apply(v33, []any{v53}) + v55 := lang.Apply(v22, []any{v26, v30, v54}) + v56 := lang.Apply(v19, []any{v55}) + return v56 + }) + v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("seq")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("concat")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("list")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("seq")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("concat")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("list")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.Apply(v42, []any{v10}) + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("list")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.Apply(v46, []any{v2}) + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("list")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v3}) + v52 := lang.Apply(v39, []any{v43, v47, v51}) + v53 := lang.Apply(v36, []any{v52}) + v54 := lang.Apply(v33, []any{v53}) + v55 := lang.Apply(v22, []any{v26, v30, v54}) + v56 := lang.Apply(v19, []any{v55}) + v57 := lang.Apply(v13, []any{v16, v56, v4}) + v5 = v57 + } // end let + return v5 + } + }) + v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + v5 := lang.Apply(v4, []any{nil, int64(0)}) + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v0 := lang.NewSymbol("-").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "If no ys are supplied, returns the negation of x, else subtracts\n the ys from x and returns the result. Does not auto-promote\n longs, will throw on overflow. See also: -'", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1036), lang.NewKeyword("end-line"), int(1036))).(*lang.Symbol) + var v4 lang.FnFunc + v4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v5 := args[0] + _ = v5 + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("*")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{int64(-1), v5}) + return v9 + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7, _ := lang.FieldOrMethod(lang.Numbers, "Minus") + if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Minus is not a function"))) + } + v8 := lang.Apply(v7, []any{v5, v6}) + return v8 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := lang.NewList(args[2:]...) + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("-")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("-")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{v5, v6}) + v18 := lang.Apply(v10, []any{v13, v17, v7}) + return v18 + } + }) + v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v3 := ns.InternWithValue(v0, v4, true) + if v0.Meta() != nil { + v3.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // -' + { + var v1 lang.FnFunc + v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var v3 any + { // let + // let binding "op" + var v4 any + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + if lang.IsTruthy(v7) { + v4 = closed8 + } else { + v4 = closed8 + } + var v8 any = v4 + _ = v8 + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("seq")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("concat")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("list")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("list")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("list")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("seq")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("concat")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("list")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{v8}) + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("list")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v38, []any{v2}) + v40 := lang.Apply(v31, []any{v35, v39}) + v41 := lang.Apply(v28, []any{v40}) + v42 := lang.Apply(v25, []any{v41}) + v43 := lang.Apply(v14, []any{v18, v22, v42}) + v44 := lang.Apply(v11, []any{v43}) + v3 = v44 + } // end let + return v3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any + { // let + // let binding "op" + var v5 any + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + if lang.IsTruthy(v8) { + v5 = closed8 + } else { + v5 = closed8 + } + var v9 any = v5 + _ = v9 + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("seq")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("concat")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("list")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("list")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("list")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("seq")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("concat")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("list")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.Apply(v35, []any{v9}) + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("list")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.Apply(v39, []any{v2}) + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("list")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.Apply(v43, []any{v3}) + v45 := lang.Apply(v32, []any{v36, v40, v44}) + v46 := lang.Apply(v29, []any{v45}) + v47 := lang.Apply(v26, []any{v46}) + v48 := lang.Apply(v15, []any{v19, v23, v47}) + v49 := lang.Apply(v12, []any{v48}) + v4 = v49 + } // end let + return v4 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := lang.NewList(args[2:]...) + var v5 any + { // let + // let binding "op" + var v6 any + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + if lang.IsTruthy(v9) { + v6 = closed8 + } else { + v6 = closed8 + } + var v10 any = v6 + _ = v10 + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + var v14 lang.FnFunc + v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v15 := args[0] + _ = v15 + v16 := args[1] + _ = v16 + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("seq")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("concat")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("list")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("seq")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("concat")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("list")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.Apply(v42, []any{v10}) + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("list")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.Apply(v46, []any{v15}) + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("list")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v16}) + v52 := lang.Apply(v39, []any{v43, v47, v51}) + v53 := lang.Apply(v36, []any{v52}) + v54 := lang.Apply(v33, []any{v53}) + v55 := lang.Apply(v22, []any{v26, v30, v54}) + v56 := lang.Apply(v19, []any{v55}) + return v56 + }) + v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("seq")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("concat")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("list")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("seq")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("concat")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("list")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.Apply(v42, []any{v10}) + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("list")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.Apply(v46, []any{v2}) + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("list")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v3}) + v52 := lang.Apply(v39, []any{v43, v47, v51}) + v53 := lang.Apply(v36, []any{v52}) + v54 := lang.Apply(v33, []any{v53}) + v55 := lang.Apply(v22, []any{v26, v30, v54}) + v56 := lang.Apply(v19, []any{v55}) + v57 := lang.Apply(v13, []any{v16, v56, v4}) + v5 = v57 + } // end let + return v5 + } + }) + v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + v5 := lang.Apply(v4, []any{nil, int64(0)}) + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v0 := lang.NewSymbol("-'").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "If no ys are supplied, returns the negation of x, else subtracts\n the ys from x and returns the result. Supports arbitrary precision.\n See also: -", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1024), lang.NewKeyword("end-line"), int(1024))).(*lang.Symbol) + var v4 lang.FnFunc + v4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v5 := args[0] + _ = v5 + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("*'")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{int64(-1), v5}) + return v9 + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7, _ := lang.FieldOrMethod(lang.Numbers, "MinusP") + if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("MinusP is not a function"))) + } + v8 := lang.Apply(v7, []any{v5, v6}) + return v8 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := lang.NewList(args[2:]...) + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("-'")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("-'")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{v5, v6}) + v18 := lang.Apply(v10, []any{v13, v17, v7}) + return v18 + } + }) + v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v3 := ns.InternWithValue(v0, v4, true) + if v0.Meta() != nil { + v3.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // -> + { + v0 := lang.NewSymbol("->").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "Threads the expr through the forms. Inserts x as the\n second item in the first form, making a list of it if it is not a\n list already. If there are more forms, inserts the first form as the\n second item in second form, etc.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1675), lang.NewKeyword("end-line"), int(1675))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + var v7 any + { // let + // let binding "x" + var v8 any = v5 + _ = v8 + // let binding "forms" + var v9 any = v6 + _ = v9 + for { + var v10 any + if lang.IsTruthy(v9) { + var v11 any + { // let + // let binding "form" + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("first")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.Apply(v14, []any{v9}) + var v16 any = v15 + _ = v16 + // let binding "threaded" + var v17 any + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("seq?")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.Apply(v20, []any{v16}) + if lang.IsTruthy(v21) { + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("with-meta")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("seq")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("concat")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("first")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.Apply(v36, []any{v16}) + v38 := lang.Apply(v33, []any{v37}) + v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v40 := v39.FindInternedVar(lang.NewSymbol("list")) + if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) + } + v41 := v40.Get() + v42 := lang.Apply(v41, []any{v8}) + v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v44 := v43.FindInternedVar(lang.NewSymbol("next")) + if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) + } + v45 := v44.Get() + v46 := lang.Apply(v45, []any{v16}) + v47 := lang.Apply(v30, []any{v38, v42, v46}) + v48 := lang.Apply(v27, []any{v47}) + v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v50 := v49.FindInternedVar(lang.NewSymbol("meta")) + if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) + } + v51 := v50.Get() + v52 := lang.Apply(v51, []any{v16}) + v53 := lang.Apply(v24, []any{v48, v52}) + v17 = v53 + } else { + v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v55 := v54.FindInternedVar(lang.NewSymbol("list")) + if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) + } + v56 := v55.Get() + v57 := lang.Apply(v56, []any{v16, v8}) + v17 = v57 + } + var v58 any = v17 + _ = v58 + var v59 any = v58 + v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v62 := v61.FindInternedVar(lang.NewSymbol("next")) + if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) + } + v63 := v62.Get() + v64 := lang.Apply(v63, []any{v9}) + var v60 any = v64 + v8 = v59 + v9 = v60 + continue + } // end let + v10 = v11 + } else { + v10 = v8 + } + v7 = v10 + break + } + } // end let + return v7 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // ->> + { + v0 := lang.NewSymbol("->>").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "Threads the expr through the forms. Inserts x as the\n last item in the first form, making a list of it if it is not a\n list already. If there are more forms, inserts the first form as the\n last item in second form, etc.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1691), lang.NewKeyword("end-line"), int(1691))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + var v7 any + { // let + // let binding "x" + var v8 any = v5 + _ = v8 + // let binding "forms" + var v9 any = v6 + _ = v9 + for { + var v10 any + if lang.IsTruthy(v9) { + var v11 any + { // let + // let binding "form" + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("first")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.Apply(v14, []any{v9}) + var v16 any = v15 + _ = v16 + // let binding "threaded" + var v17 any + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("seq?")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.Apply(v20, []any{v16}) + if lang.IsTruthy(v21) { + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("with-meta")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("seq")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("concat")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("first")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.Apply(v36, []any{v16}) + v38 := lang.Apply(v33, []any{v37}) + v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v40 := v39.FindInternedVar(lang.NewSymbol("next")) + if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) + } + v41 := v40.Get() + v42 := lang.Apply(v41, []any{v16}) + v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v44 := v43.FindInternedVar(lang.NewSymbol("list")) + if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) + } + v45 := v44.Get() + v46 := lang.Apply(v45, []any{v8}) + v47 := lang.Apply(v30, []any{v38, v42, v46}) + v48 := lang.Apply(v27, []any{v47}) + v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v50 := v49.FindInternedVar(lang.NewSymbol("meta")) + if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) + } + v51 := v50.Get() + v52 := lang.Apply(v51, []any{v16}) + v53 := lang.Apply(v24, []any{v48, v52}) + v17 = v53 + } else { + v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v55 := v54.FindInternedVar(lang.NewSymbol("list")) + if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) + } + v56 := v55.Get() + v57 := lang.Apply(v56, []any{v16, v8}) + v17 = v57 + } + var v58 any = v17 + _ = v58 + var v59 any = v58 + v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v62 := v61.FindInternedVar(lang.NewSymbol("next")) + if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) + } + v63 := v62.Get() + v64 := lang.Apply(v63, []any{v9}) + var v60 any = v64 + v8 = v59 + v9 = v60 + continue + } // end let + v10 = v11 + } else { + v10 = v8 + } + v7 = v10 + break + } + } // end let + return v7 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // -protocols + { + v0 := lang.NewSymbol("-protocols").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("doc"), "Private store of protocols. Go's reflection capabilities\n don't yet support a native interface-based implementation, so\n protocols are implemented in Glojure as maps from type to protocol\n method implementations.", lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(21), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(26), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + v3 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("coll-reduce"), nil), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("coll-reduce"), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("f"), lang.NewSymbol("val")))))) + v4 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("internal-reduce"), nil), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("internal-reduce"), lang.NewVector(lang.NewSymbol("seq"), lang.NewSymbol("f"), lang.NewSymbol("start")))))) + v5 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("kv-reduce"), nil), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("kv-reduce"), lang.NewVector(lang.NewSymbol("amap"), lang.NewSymbol("f"), lang.NewSymbol("init")))))) + v6 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("datafy"), nil), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("datafy"), lang.NewVector(lang.NewSymbol("o")), "return a representation of o as data (default identity)")))) + v7 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("nav"), nil), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("nav"), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("k"), lang.NewSymbol("v")), "return (possibly transformed) v in the context of coll and k (a key/index or nil),\ndefaults to returning v.")))) + v8 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("make-reader"), nil, lang.NewKeyword("make-writer"), nil, lang.NewKeyword("make-input-stream"), nil, lang.NewKeyword("make-output-stream"), nil), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("make-reader"), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("opts")), "Creates an io.Reader. See also IOFactory docs."), lang.NewList(lang.NewSymbol("make-writer"), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("opts")), "Creates an io.Reader. See also IOFactory docs."), lang.NewList(lang.NewSymbol("make-input-stream"), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("opts")), "Creates a BufferedInputStream. See also IOFactory docs."), lang.NewList(lang.NewSymbol("make-output-stream"), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("opts")), "Creates a BufferedOutputStream. See also IOFactory docs.")))) + v2 := lang.NewAtom(lang.NewMap(lang.NewSymbol("CollReduce"), v3, lang.NewSymbol("InternalReduce"), v4, lang.NewSymbol("IKVReduce"), v5, lang.NewSymbol("Datafiable"), v6, lang.NewSymbol("Navigable"), v7, lang.NewSymbol("IOFactory"), v8)) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // .. + { + v0 := lang.NewSymbol("..").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("form")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("form"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "form => fieldName-symbol or (instanceMethodName-symbol args*)\n\n Expands into a member access (.) of the first member on the first\n argument, followed by the next member on the result, etc. For\n instance:\n\n (.. System (getProperties) (get \"os.name\"))\n\n expands to:\n\n (. (. System (getProperties)) (get \"os.name\"))\n\n but is easier to write, read, and understand.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1657), lang.NewKeyword("end-line"), int(1657))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 4: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("seq")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("concat")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("list")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{lang.NewSymbol(".")}) + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("list")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.Apply(v19, []any{v5}) + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("list")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.Apply(v23, []any{v6}) + v25 := lang.Apply(v12, []any{v16, v20, v24}) + v26 := lang.Apply(v9, []any{v25}) + return v26 + default: + if len(args) < 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := lang.NewList(args[4:]...) + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("seq")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("concat")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("..")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("seq")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("concat")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol(".")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{v5}) + v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v36 := v35.FindInternedVar(lang.NewSymbol("list")) + if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + } + v37 := v36.Get() + v38 := lang.Apply(v37, []any{v6}) + v39 := lang.Apply(v26, []any{v30, v34, v38}) + v40 := lang.Apply(v23, []any{v39}) + v41 := lang.Apply(v20, []any{v40}) + v42 := lang.Apply(v13, []any{v17, v41, v7}) + v43 := lang.Apply(v10, []any{v42}) + return v43 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // / + { + var v1 lang.FnFunc + v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var v3 any + { // let + // let binding "op" + var v4 any + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + if lang.IsTruthy(v7) { + v4 = closed9 + } else { + v4 = closed9 + } + var v8 any = v4 + _ = v8 + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("seq")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("concat")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("list")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("list")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("list")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("seq")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("concat")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("list")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{v8}) + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("list")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v38, []any{v2}) + v40 := lang.Apply(v31, []any{v35, v39}) + v41 := lang.Apply(v28, []any{v40}) + v42 := lang.Apply(v25, []any{v41}) + v43 := lang.Apply(v14, []any{v18, v22, v42}) + v44 := lang.Apply(v11, []any{v43}) + v3 = v44 + } // end let + return v3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any + { // let + // let binding "op" + var v5 any + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + if lang.IsTruthy(v8) { + v5 = closed9 + } else { + v5 = closed9 + } + var v9 any = v5 + _ = v9 + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("seq")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("concat")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("list")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("list")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("list")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("seq")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("concat")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("list")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.Apply(v35, []any{v9}) + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("list")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.Apply(v39, []any{v2}) + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("list")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.Apply(v43, []any{v3}) + v45 := lang.Apply(v32, []any{v36, v40, v44}) + v46 := lang.Apply(v29, []any{v45}) + v47 := lang.Apply(v26, []any{v46}) + v48 := lang.Apply(v15, []any{v19, v23, v47}) + v49 := lang.Apply(v12, []any{v48}) + v4 = v49 + } // end let + return v4 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := lang.NewList(args[2:]...) + var v5 any + { // let + // let binding "op" + var v6 any + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + if lang.IsTruthy(v9) { + v6 = closed9 + } else { + v6 = closed9 + } + var v10 any = v6 + _ = v10 + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + var v14 lang.FnFunc + v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v15 := args[0] + _ = v15 + v16 := args[1] + _ = v16 + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("seq")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("concat")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("list")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("seq")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("concat")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("list")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.Apply(v42, []any{v10}) + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("list")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.Apply(v46, []any{v15}) + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("list")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v16}) + v52 := lang.Apply(v39, []any{v43, v47, v51}) + v53 := lang.Apply(v36, []any{v52}) + v54 := lang.Apply(v33, []any{v53}) + v55 := lang.Apply(v22, []any{v26, v30, v54}) + v56 := lang.Apply(v19, []any{v55}) + return v56 + }) + v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("seq")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("concat")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("list")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("seq")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("concat")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("list")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.Apply(v42, []any{v10}) + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("list")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.Apply(v46, []any{v2}) + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("list")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v3}) + v52 := lang.Apply(v39, []any{v43, v47, v51}) + v53 := lang.Apply(v36, []any{v52}) + v54 := lang.Apply(v33, []any{v53}) + v55 := lang.Apply(v22, []any{v26, v30, v54}) + v56 := lang.Apply(v19, []any{v55}) + v57 := lang.Apply(v13, []any{v16, v56, v4}) + v5 = v57 + } // end let + return v5 + } + }) + v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + v5 := lang.Apply(v4, []any{nil, int64(1)}) + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v0 := lang.NewSymbol("/").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "If no denominators are supplied, returns 1/numerator,\n else returns numerator divided by all of the denominators.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1013), lang.NewKeyword("end-line"), int(1013))).(*lang.Symbol) + var v4 lang.FnFunc + v4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v5 := args[0] + _ = v5 + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("/")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{int64(1), v5}) + return v9 + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7, _ := lang.FieldOrMethod(lang.Numbers, "Divide") + if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Divide is not a function"))) + } + v8 := lang.Apply(v7, []any{v5, v6}) + return v8 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := lang.NewList(args[2:]...) + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("/")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("/")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{v5, v6}) + v18 := lang.Apply(v10, []any{v13, v17, v7}) + return v18 + } + }) + v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v3 := ns.InternWithValue(v0, v4, true) + if v0.Meta() != nil { + v3.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // < + { + var v1 lang.FnFunc + { // function <__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("seq")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("concat")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("list")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("list")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("list")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("seq")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("concat")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("list")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/Lt")}) + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("list")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{v3}) + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("list")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v38, []any{v4}) + v40 := lang.Apply(v27, []any{v31, v35, v39}) + v41 := lang.Apply(v24, []any{v40}) + v42 := lang.Apply(v21, []any{v41}) + v43 := lang.Apply(v10, []any{v14, v18, v42}) + v44 := lang.Apply(v7, []any{v43}) + return v44 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("<").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns non-nil if nums are in monotonically increasing order,\n otherwise false.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(893), lang.NewKeyword("end-line"), int(893))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + return true + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6, _ := lang.FieldOrMethod(lang.Numbers, "Lt") + if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Lt is not a function"))) + } + v7 := lang.Apply(v6, []any{v4, v5}) + return v7 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := lang.NewList(args[2:]...) + recur_loop_150: + var v7 any + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("<")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v4, v5}) + if lang.IsTruthy(v11) { + var v12 any + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("next")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{v6}) + if lang.IsTruthy(v16) { + var v17 any = v5 + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("first")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{v6}) + var v18 any = v22 + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("next")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.Apply(v26, []any{v6}) + var v23 any = v27 + v4 = v17 + v5 = v18 + v6 = v23 + goto recur_loop_150 + } else { + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("<")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("first")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{v6}) + v35 := lang.Apply(v30, []any{v5, v34}) + v12 = v35 + } + v7 = v12 + } else { + v7 = false + } + return v7 + } + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // <= + { + var v1 lang.FnFunc + { // function <=__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("seq")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("concat")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("list")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("list")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("list")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("seq")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("concat")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("list")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/Lte")}) + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("list")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{v3}) + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("list")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v38, []any{v4}) + v40 := lang.Apply(v27, []any{v31, v35, v39}) + v41 := lang.Apply(v24, []any{v40}) + v42 := lang.Apply(v21, []any{v41}) + v43 := lang.Apply(v10, []any{v14, v18, v42}) + v44 := lang.Apply(v7, []any{v43}) + return v44 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("<=").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns non-nil if nums are in monotonically non-decreasing order,\n otherwise false.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1048), lang.NewKeyword("end-line"), int(1048))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + return true + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6, _ := lang.FieldOrMethod(lang.Numbers, "Lte") + if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Lte is not a function"))) + } + v7 := lang.Apply(v6, []any{v4, v5}) + return v7 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := lang.NewList(args[2:]...) + recur_loop_194: + var v7 any + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("<=")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v4, v5}) + if lang.IsTruthy(v11) { + var v12 any + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("next")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{v6}) + if lang.IsTruthy(v16) { + var v17 any = v5 + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("first")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{v6}) + var v18 any = v22 + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("next")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.Apply(v26, []any{v6}) + var v23 any = v27 + v4 = v17 + v5 = v18 + v6 = v23 + goto recur_loop_194 + } else { + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("<=")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("first")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{v6}) + v35 := lang.Apply(v30, []any{v5, v34}) + v12 = v35 + } + v7 = v12 + } else { + v7 = false + } + return v7 + } + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // = + { + var v1 lang.FnFunc + { // function =__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("seq")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("concat")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("list")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("list")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{lang.NewSymbol("glojure.lang.Util")}) + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("list")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{lang.NewSymbol("glojure.core/equiv")}) + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("list")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.Apply(v25, []any{v3}) + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{v4}) + v31 := lang.Apply(v10, []any{v14, v18, v22, v26, v30}) + v32 := lang.Apply(v7, []any{v31}) + return v32 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("=").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Equality. Returns true if x equals y, false if not. Same as\n Java x.equals(y) except it also works for nil, and compares\n numbers and collections in a type-independent manner. Clojure's immutable data\n structures define equals() (and thus =) as a value, not an identity,\n comparison.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(776), lang.NewKeyword("end-line"), int(776))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + return true + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := lang.Apply(lang.Equiv, []any{v4, v5}) + return v6 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := lang.NewList(args[2:]...) + recur_loop_126: + var v7 any + v8 := lang.Apply(lang.Equiv, []any{v4, v5}) + if lang.IsTruthy(v8) { + var v9 any + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("next")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{v6}) + if lang.IsTruthy(v13) { + var v14 any = v5 + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("first")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{v6}) + var v15 any = v19 + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("next")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.Apply(v23, []any{v6}) + var v20 any = v24 + v4 = v14 + v5 = v15 + v6 = v20 + goto recur_loop_126 + } else { + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("first")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.Apply(v27, []any{v6}) + v29 := lang.Apply(lang.Equiv, []any{v5, v28}) + v9 = v29 + } + v7 = v9 + } else { + v7 = false + } + return v7 + } + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // == + { + var v1 lang.FnFunc + { // function ==__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("seq")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("concat")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("list")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("list")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("list")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("seq")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("concat")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("list")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/Equiv")}) + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("list")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{v3}) + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("list")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v38, []any{v4}) + v40 := lang.Apply(v27, []any{v31, v35, v39}) + v41 := lang.Apply(v24, []any{v40}) + v42 := lang.Apply(v21, []any{v41}) + v43 := lang.Apply(v10, []any{v14, v18, v42}) + v44 := lang.Apply(v7, []any{v43}) + return v44 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("==").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns non-nil if nums all have the equivalent\n value (type-independent), otherwise false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1093), lang.NewKeyword("end-line"), int(1093))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + return true + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6, _ := lang.FieldOrMethod(lang.Numbers, "Equiv") + if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Equiv is not a function"))) + } + v7 := lang.Apply(v6, []any{v4, v5}) + return v7 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := lang.NewList(args[2:]...) + recur_loop_206: + var v7 any + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("==")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v4, v5}) + if lang.IsTruthy(v11) { + var v12 any + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("next")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{v6}) + if lang.IsTruthy(v16) { + var v17 any = v5 + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("first")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{v6}) + var v18 any = v22 + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("next")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.Apply(v26, []any{v6}) + var v23 any = v27 + v4 = v17 + v5 = v18 + v6 = v23 + goto recur_loop_206 + } else { + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("==")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("first")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{v6}) + v35 := lang.Apply(v30, []any{v5, v34}) + v12 = v35 + } + v7 = v12 + } else { + v7 = false + } + return v7 + } + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // > + { + var v1 lang.FnFunc + { // function >__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("seq")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("concat")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("list")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("list")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("list")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("seq")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("concat")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("list")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/Gt")}) + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("list")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{v3}) + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("list")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v38, []any{v4}) + v40 := lang.Apply(v27, []any{v31, v35, v39}) + v41 := lang.Apply(v24, []any{v40}) + v42 := lang.Apply(v21, []any{v41}) + v43 := lang.Apply(v10, []any{v14, v18, v42}) + v44 := lang.Apply(v7, []any{v43}) + return v44 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol(">").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns non-nil if nums are in monotonically decreasing order,\n otherwise false.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1063), lang.NewKeyword("end-line"), int(1063))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + return true + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + v7 := lang.Apply(v6, []any{v4, v5}) + return v7 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := lang.NewList(args[2:]...) + recur_loop_198: + var v7 any + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol(">")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v4, v5}) + if lang.IsTruthy(v11) { + var v12 any + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("next")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{v6}) + if lang.IsTruthy(v16) { + var v17 any = v5 + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("first")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{v6}) + var v18 any = v22 + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("next")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.Apply(v26, []any{v6}) + var v23 any = v27 + v4 = v17 + v5 = v18 + v6 = v23 + goto recur_loop_198 + } else { + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol(">")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("first")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{v6}) + v35 := lang.Apply(v30, []any{v5, v34}) + v12 = v35 + } + v7 = v12 + } else { + v7 = false + } + return v7 + } + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // >0? + { + v0 := lang.NewSymbol(">0?").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(963), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(963), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + v5 := lang.Apply(v4, []any{nil, int64(0)}) + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // >1? + { + v0 := lang.NewSymbol(">1?").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(962), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(962), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + v5 := lang.Apply(v4, []any{nil, int64(1)}) + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // >= + { + var v1 lang.FnFunc + { // function >=__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("seq")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("concat")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("list")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("list")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("list")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("seq")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("concat")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("list")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/Gte")}) + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("list")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{v3}) + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("list")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v38, []any{v4}) + v40 := lang.Apply(v27, []any{v31, v35, v39}) + v41 := lang.Apply(v24, []any{v40}) + v42 := lang.Apply(v21, []any{v41}) + v43 := lang.Apply(v10, []any{v14, v18, v42}) + v44 := lang.Apply(v7, []any{v43}) + return v44 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol(">=").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns non-nil if nums are in monotonically non-increasing order,\n otherwise false.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1078), lang.NewKeyword("end-line"), int(1078))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + return true + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6, _ := lang.FieldOrMethod(lang.Numbers, "Gte") + if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gte is not a function"))) + } + v7 := lang.Apply(v6, []any{v4, v5}) + return v7 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := lang.NewList(args[2:]...) + recur_loop_202: + var v7 any + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol(">=")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v4, v5}) + if lang.IsTruthy(v11) { + var v12 any + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("next")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{v6}) + if lang.IsTruthy(v16) { + var v17 any = v5 + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("first")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{v6}) + var v18 any = v22 + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("next")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.Apply(v26, []any{v6}) + var v23 any = v27 + v4 = v17 + v5 = v18 + v6 = v23 + goto recur_loop_202 + } else { + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol(">=")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("first")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{v6}) + v35 := lang.Apply(v30, []any{v5, v34}) + v12 = v35 + } + v7 = v12 + } else { + v7 = false + } + return v7 + } + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // NaN? + { + var v1 lang.FnFunc + { // function NaN?__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("concat")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("list")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol("math.IsNaN")}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{v3}) + v18 := lang.Apply(v9, []any{v13, v17}) + v19 := lang.Apply(v6, []any{v18}) + return v19 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("NaN?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns true if num is NaN, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)), lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7968), lang.NewKeyword("end-line"), int(7968))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := lang.Apply(math3.IsNaN, []any{v4}) + return v5 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // StackTraceElement->vec + { + v0 := lang.NewSymbol("StackTraceElement->vec").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"))), lang.NewKeyword("doc"), "Constructs a data representation for a StackTraceElement: [class method file line]", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(436), lang.NewKeyword("end-line"), int(436))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("symbol")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7, ok := lang.FieldOrMethod(v3, "getClassName") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getClassName"))) + } + var v8 any + switch reflect.TypeOf(v7).Kind() { + case reflect.Func: + v8 = lang.Apply(v7, nil) + default: + v8 = v7 + } + v9 := lang.Apply(v6, []any{v8}) + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("symbol")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13, ok := lang.FieldOrMethod(v3, "getMethodName") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getMethodName"))) + } + var v14 any + switch reflect.TypeOf(v13).Kind() { + case reflect.Func: + v14 = lang.Apply(v13, nil) + default: + v14 = v13 + } + v15 := lang.Apply(v12, []any{v14}) + v16, ok := lang.FieldOrMethod(v3, "getFileName") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getFileName"))) + } + var v17 any + switch reflect.TypeOf(v16).Kind() { + case reflect.Func: + v17 = lang.Apply(v16, nil) + default: + v17 = v16 + } + v18, ok := lang.FieldOrMethod(v3, "getLineNumber") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getLineNumber"))) + } + var v19 any + switch reflect.TypeOf(v18).Kind() { + case reflect.Func: + v19 = lang.Apply(v18, nil) + default: + v19 = v18 + } + v20 := lang.NewVector(v9, v15, v17, v19) + v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(440), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(440), lang.NewKeyword("end-column"), int(94)) + v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v22 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // Throwable->map + { + v0 := lang.NewSymbol("Throwable->map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"))), lang.NewKeyword("doc"), "Constructs a data representation for a Throwable with keys:\n :cause - root cause message\n :phase - error phase\n :via - cause chain, with cause keys:\n :type - exception class symbol\n :message - exception message\n :data - ex-data\n :at - top stack element\n :trace - root cause stack elements", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(442), lang.NewKeyword("end-line"), int(442))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + { // let + // let binding "base" + var v5 lang.FnFunc + v5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v6 := args[0] + _ = v6 + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("merge")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("symbol")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("class")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{v6}) + v17, ok := lang.FieldOrMethod(v16, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v16, "Name"))) + } + var v18 any + switch reflect.TypeOf(v17).Kind() { + case reflect.Func: + v18 = lang.Apply(v17, nil) + default: + v18 = v17 + } + v19 := lang.Apply(v12, []any{v18}) + v20 := lang.NewMap(lang.NewKeyword("type"), v19) + v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(455), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(455), lang.NewKeyword("end-column"), int(56)) + v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v23 any + { // let + // let binding "temp__0__auto__" + v24, ok := lang.FieldOrMethod(v6, "getLocalizedMessage") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "getLocalizedMessage"))) + } + var v25 any + switch reflect.TypeOf(v24).Kind() { + case reflect.Func: + v25 = lang.Apply(v24, nil) + default: + v25 = v24 + } + var v26 any = v25 + _ = v26 + var v27 any + if lang.IsTruthy(v26) { + var v28 any + { // let + // let binding "msg" + var v29 any = v26 + _ = v29 + v30 := lang.NewMap(lang.NewKeyword("message"), v29) + v31 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(457), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(457), lang.NewKeyword("end-column"), int(33)) + v32, err := lang.WithMeta(v30, v31.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v28 = v32 + } // end let + v27 = v28 + } else { + v27 = nil + } + v23 = v27 + } // end let + var v24 any + { // let + // let binding "temp__0__auto__" + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("ex-data")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.Apply(v27, []any{v6}) + var v29 any = v28 + _ = v29 + var v30 any + if lang.IsTruthy(v29) { + var v31 any + { // let + // let binding "ed" + var v32 any = v29 + _ = v32 + v33 := lang.NewMap(lang.NewKeyword("data"), v32) + v34 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(459), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(459), lang.NewKeyword("end-column"), int(29)) + v35, err := lang.WithMeta(v33, v34.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v31 = v35 + } // end let + v30 = v31 + } else { + v30 = nil + } + v24 = v30 + } // end let + var v25 any + { // let + // let binding "st" + v26, ok := lang.FieldOrMethod(v6, "getStackTrace") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "getStackTrace"))) + } + var v27 any + switch reflect.TypeOf(v26).Kind() { + case reflect.Func: + v27 = lang.Apply(v26, nil) + default: + v27 = v26 + } + var v28 any = v27 + _ = v28 + var v29 any + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("pos?")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("alength")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.Apply(v35, []any{v28}) + v37 := lang.Apply(v32, []any{v36}) + if lang.IsTruthy(v37) { + v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v39 := v38.FindInternedVar(lang.NewSymbol("StackTraceElement->vec")) + if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + } + v40 := v39.Get() + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("aget")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.Apply(v43, []any{v28, int64(0)}) + v45 := lang.Apply(v40, []any{v44}) + v46 := lang.NewMap(lang.NewKeyword("at"), v45) + v47 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(462), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(462), lang.NewKeyword("end-column"), int(63)) + v48, err := lang.WithMeta(v46, v47.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v29 = v48 + } else { + v29 = nil + } + v25 = v29 + } // end let + v26 := lang.Apply(v9, []any{v22, v23, v24, v25}) + return v26 + }) + v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(454), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(462), lang.NewKeyword("end-column"), int(67)) + v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v8 any = v7 + _ = v8 + // let binding "via" + var v9 any + { // let + // let binding "via" + v10 := lang.NewVector() + v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(463), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(463), lang.NewKeyword("end-column"), int(25)) + v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v13 any = v12 + _ = v13 + // let binding "t" + var v14 any = v3 + _ = v14 + for { + var v15 any + if lang.IsTruthy(v14) { + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("conj")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.Apply(v19, []any{v13, v14}) + var v16 any = v20 + v22, ok := lang.FieldOrMethod(v14, "getCause") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v14, "getCause"))) + } + var v23 any + switch reflect.TypeOf(v22).Kind() { + case reflect.Func: + v23 = lang.Apply(v22, nil) + default: + v23 = v22 + } + var v21 any = v23 + v13 = v16 + v14 = v21 + continue + } else { + v15 = v13 + } + v9 = v15 + break + } + } // end let + var v10 any = v9 + _ = v10 + // let binding "root" + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("peek")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{v10}) + var v15 any = v14 + _ = v15 + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("merge")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("vec")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("map")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v8, v10}) + v26 := lang.Apply(v21, []any{v25}) + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("vec")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("map")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("StackTraceElement->vec")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + var v36 any + { // let + // let binding "or__0__auto__" + var v37 any = v15 + _ = v37 + var v38 any + if lang.IsTruthy(v37) { + v38 = v37 + } else { + v38 = v3 + } + v36 = v38 + } // end let + v37, ok := lang.FieldOrMethod(v36, "getStackTrace") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v36, "getStackTrace"))) + } + var v38 any + switch reflect.TypeOf(v37).Kind() { + case reflect.Func: + v38 = lang.Apply(v37, nil) + default: + v38 = v37 + } + v39 := lang.Apply(v32, []any{v35, v38}) + v40 := lang.Apply(v29, []any{v39}) + v41 := lang.NewMap(lang.NewKeyword("via"), v26, lang.NewKeyword("trace"), v40) + v42 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(468), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(470), lang.NewKeyword("end-column"), int(111)) + v43, err := lang.WithMeta(v41, v42.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v44 any + { // let + // let binding "temp__0__auto__" + v45, ok := lang.FieldOrMethod(v15, "getLocalizedMessage") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v15, "getLocalizedMessage"))) + } + var v46 any + switch reflect.TypeOf(v45).Kind() { + case reflect.Func: + v46 = lang.Apply(v45, nil) + default: + v46 = v45 + } + var v47 any = v46 + _ = v47 + var v48 any + if lang.IsTruthy(v47) { + var v49 any + { // let + // let binding "root-msg" + var v50 any = v47 + _ = v50 + v51 := lang.NewMap(lang.NewKeyword("cause"), v50) + v52 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(472), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(472), lang.NewKeyword("end-column"), int(25)) + v53, err := lang.WithMeta(v51, v52.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v49 = v53 + } // end let + v48 = v49 + } else { + v48 = nil + } + v44 = v48 + } // end let + var v45 any + { // let + // let binding "temp__0__auto__" + v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v47 := v46.FindInternedVar(lang.NewSymbol("ex-data")) + if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) + } + v48 := v47.Get() + v49 := lang.Apply(v48, []any{v15}) + var v50 any = v49 + _ = v50 + var v51 any + if lang.IsTruthy(v50) { + var v52 any + { // let + // let binding "data" + var v53 any = v50 + _ = v53 + v54 := lang.NewMap(lang.NewKeyword("data"), v53) + v55 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(474), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(474), lang.NewKeyword("end-column"), int(20)) + v56, err := lang.WithMeta(v54, v55.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v52 = v56 + } // end let + v51 = v52 + } else { + v51 = nil + } + v45 = v51 + } // end let + var v46 any + { // let + // let binding "temp__0__auto__" + v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v48 := v47.FindInternedVar(lang.NewSymbol("ex-data")) + if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) + } + v49 := v48.Get() + v50 := lang.Apply(v49, []any{v3}) + v51 := lang.Apply(lang.NewKeyword("glojure.error/phase"), []any{v50}) + var v52 any = v51 + _ = v52 + var v53 any + if lang.IsTruthy(v52) { + var v54 any + { // let + // let binding "phase" + var v55 any = v52 + _ = v55 + v56 := lang.NewMap(lang.NewKeyword("phase"), v55) + v57 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(476), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(476), lang.NewKeyword("end-column"), int(22)) + v58, err := lang.WithMeta(v56, v57.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v54 = v58 + } // end let + v53 = v54 + } else { + v53 = nil + } + v46 = v53 + } // end let + v47 := lang.Apply(v18, []any{v43, v44, v45, v46}) + v4 = v47 + } // end let + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // abs + { + var v1 lang.FnFunc + { // function abs__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("concat")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("list")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Abs")}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{v3}) + v18 := lang.Apply(v9, []any{v13, v17}) + v19 := lang.Apply(v6, []any{v18}) + return v19 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("abs").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the absolute value of a.\n If a is Long/MIN_VALUE => Long/MIN_VALUE\n If a is a double and zero => +0.0\n If a is a double and ##Inf or ##-Inf => ##Inf\n If a is a double and ##NaN => ##NaN", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)), lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1128), lang.NewKeyword("end-line"), int(1128))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := lang.Apply(lang.Abs, []any{v4}) + return v5 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // accessor + { + v0 := lang.NewSymbol("accessor").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("key"))), lang.NewKeyword("doc"), "Returns a fn that, given an instance of a structmap with the basis,\n returns the value at the key. The key must be in the basis. The\n returned function should be (slightly) more efficient than using\n get, but such use of accessors should be limited to known\n performance-critical areas.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4070), lang.NewKeyword("end-line"), int(4070))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5, _ := lang.FieldOrMethod(nil, "getAccessor") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getAccessor is not a function"))) + } + v6 := lang.Apply(v5, []any{v3, v4}) + return v6 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // aclone + { + var v1 lang.FnFunc + { // function aclone__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("concat")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("list")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("seq")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("concat")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/Aclone")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{v3}) + v35 := lang.Apply(v26, []any{v30, v34}) + v36 := lang.Apply(v23, []any{v35}) + v37 := lang.Apply(v20, []any{v36}) + v38 := lang.Apply(v9, []any{v13, v17, v37}) + v39 := lang.Apply(v6, []any{v38}) + return v39 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("aclone").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns a clone of the Java array. Works on arrays of known\n types.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3904), lang.NewKeyword("end-line"), int(3904))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5, _ := lang.FieldOrMethod(runtime4.RT, "Aclone") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Aclone is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // add-classpath + { + v0 := lang.NewSymbol("add-classpath").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("url"))), lang.NewKeyword("doc"), "DEPRECATED \n\n Adds the url (String or URL object) to the classpath per\n URLClassLoader.addURL", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("deprecated"), "1.1", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5176), lang.NewKeyword("end-line"), int(5176))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("println")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.Apply(v6, []any{"WARNING: add-classpath is deprecated"}) + _ = v7 + v8 := lang.Apply(nil, []any{v3}) + return v8 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // add-doc-and-meta + { + v0 := lang.NewSymbol("add-doc-and-meta").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("docstring"), lang.NewSymbol("meta"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(26), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6400), lang.NewKeyword("end-line"), int(6400), lang.NewKeyword("private"), true)).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 5 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := args[4] + _ = v7 + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("seq")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("concat")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("glojure.core/alter-meta!")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("seq")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("concat")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("var")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{v5}) + v35 := lang.Apply(v26, []any{v30, v34}) + v36 := lang.Apply(v23, []any{v35}) + v37 := lang.Apply(v20, []any{v36}) + v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v39 := v38.FindInternedVar(lang.NewSymbol("list")) + if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + } + v40 := v39.Get() + v41 := lang.Apply(v40, []any{lang.NewSymbol("glojure.core/merge")}) + v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v43 := v42.FindInternedVar(lang.NewSymbol("list")) + if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) + } + v44 := v43.Get() + v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v46 := v45.FindInternedVar(lang.NewSymbol("seq")) + if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) + } + v47 := v46.Get() + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("concat")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v52 := v51.FindInternedVar(lang.NewSymbol("list")) + if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) + } + v53 := v52.Get() + v54 := lang.Apply(v53, []any{lang.NewSymbol("glojure.core/assoc")}) + v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v56 := v55.FindInternedVar(lang.NewSymbol("list")) + if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) + } + v57 := v56.Get() + v58 := lang.Apply(v57, []any{v7}) + v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v60 := v59.FindInternedVar(lang.NewSymbol("list")) + if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) + } + v61 := v60.Get() + v62 := lang.Apply(v61, []any{lang.NewKeyword("doc")}) + v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v64 := v63.FindInternedVar(lang.NewSymbol("list")) + if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) + } + v65 := v64.Get() + v66 := lang.Apply(v65, []any{v6}) + v67 := lang.Apply(v50, []any{v54, v58, v62, v66}) + v68 := lang.Apply(v47, []any{v67}) + v69 := lang.Apply(v44, []any{v68}) + v70 := lang.Apply(v13, []any{v17, v37, v41, v69}) + v71 := lang.Apply(v10, []any{v70}) + return v71 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // add-watch + { + v0 := lang.NewSymbol("add-watch").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("reference"), lang.NewSymbol("key"), lang.NewSymbol("fn"))), lang.NewKeyword("doc"), "Adds a watch function to an agent/atom/var/ref reference. The watch\n fn must be a fn of 4 args: a key, the reference, its old-state, its\n new-state. Whenever the reference's state might have been changed,\n any registered watches will have their functions called. The watch fn\n will be called synchronously, on the agent's thread if an agent,\n before any pending sends if agent or ref. Note that an atom's or\n ref's state may have changed again prior to the fn call, so use\n old/new-state rather than derefing the reference. Note also that watch\n fns may be called from multiple threads simultaneously. Var watchers\n are triggered only by root binding changes, not thread-local\n set!s. Keys must be unique per reference, and can be used to remove\n the watch with remove-watch, but are otherwise considered opaque by\n the watch mechanism.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2142), lang.NewKeyword("end-line"), int(2142))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6, _ := lang.FieldOrMethod(v3, "addWatch") + if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("addWatch is not a function"))) + } + v7 := lang.Apply(v6, []any{v4, v5}) + return v7 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // agent + { + v0 := lang.NewSymbol("agent").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("state"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Creates and returns an agent with an initial value of state and\n zero or more options (in any order):\n\n :meta metadata-map\n\n :validator validate-fn\n\n :error-handler handler-fn\n\n :error-mode mode-keyword\n\n If metadata-map is supplied, it will become the metadata on the\n agent. validate-fn must be nil or a side-effect-free fn of one\n argument, which will be passed the intended new state on any state\n change. If the new state is unacceptable, the validate-fn should\n return false or throw an exception. handler-fn is called if an\n action throws an exception or if validate-fn rejects a new state --\n see set-error-handler! for details. The mode-keyword may be either\n :continue (the default if an error-handler is given) or :fail (the\n default if no error-handler is given) -- see set-error-mode! for\n details.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2052), lang.NewKeyword("end-line"), int(2052))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.NewList(args[1:]...) + var v5 any + { // let + // let binding "a" + var v6 any = "unimplemented: new with non-constant class type" + _ = v6 + // let binding "opts" + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("apply")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("hash-map")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v9, []any{v12, v4}) + var v14 any = v13 + _ = v14 + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("setup-reference")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{v6, v4}) + _ = v18 + var v19 any + v20 := lang.Apply(lang.NewKeyword("error-handler"), []any{v14}) + if lang.IsTruthy(v20) { + v21 := lang.Apply(lang.NewKeyword("error-handler"), []any{v14}) + v22, _ := lang.FieldOrMethod(v6, "setErrorHandler") + if reflect.TypeOf(v22).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorHandler is not a function"))) + } + v23 := lang.Apply(v22, []any{v21}) + v19 = v23 + } else { + v19 = nil + } + _ = v19 + var v24 any + { // let + // let binding "or__0__auto__" + v25 := lang.Apply(lang.NewKeyword("error-mode"), []any{v14}) + var v26 any = v25 + _ = v26 + var v27 any + if lang.IsTruthy(v26) { + v27 = v26 + } else { + var v28 any + v29 := lang.Apply(lang.NewKeyword("error-handler"), []any{v14}) + if lang.IsTruthy(v29) { + v28 = lang.NewKeyword("continue") + } else { + v28 = lang.NewKeyword("fail") + } + v27 = v28 + } + v24 = v27 + } // end let + v25, _ := lang.FieldOrMethod(v6, "setErrorMode") + if reflect.TypeOf(v25).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorMode is not a function"))) + } + v26 := lang.Apply(v25, []any{v24}) + _ = v26 + v5 = v6 + } // end let + return v5 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // agent-error + { + v0 := lang.NewSymbol("agent-error").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("doc"), "Returns the exception thrown during an asynchronous action of the\n agent if the agent is failed. Returns nil if the agent is not\n failed.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2167), lang.NewKeyword("end-line"), int(2167))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4, ok := lang.FieldOrMethod(v3, "getError") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getError"))) + } + var v5 any + switch reflect.TypeOf(v4).Kind() { + case reflect.Func: + v5 = lang.Apply(v4, nil) + default: + v5 = v4 + } + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // agent-errors + { + v0 := lang.NewSymbol("agent-errors").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("doc"), "DEPRECATED: Use 'agent-error' instead.\n Returns a sequence of the exceptions thrown during asynchronous\n actions of the agent.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("deprecated"), "1.2", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2234), lang.NewKeyword("end-line"), int(2234))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + { // let + // let binding "temp__0__auto__" + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("agent-error")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v3}) + var v9 any = v8 + _ = v9 + var v10 any + if lang.IsTruthy(v9) { + var v11 any + { // let + // let binding "e" + var v12 any = v9 + _ = v12 + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("list")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{v12}) + v11 = v16 + } // end let + v10 = v11 + } else { + v10 = nil + } + v4 = v10 + } // end let + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // aget + { + var v1 lang.FnFunc + { // function aget__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("seq")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("concat")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("list")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("list")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("list")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("seq")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("concat")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("list")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/Aget")}) + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("list")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{v3}) + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("list")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v40 := v39.FindInternedVar(lang.NewSymbol("seq")) + if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) + } + v41 := v40.Get() + v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v43 := v42.FindInternedVar(lang.NewSymbol("concat")) + if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) + } + v44 := v43.Get() + v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v46 := v45.FindInternedVar(lang.NewSymbol("list")) + if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) + } + v47 := v46.Get() + v48 := lang.Apply(v47, []any{lang.NewSymbol("glojure.core/int")}) + v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v50 := v49.FindInternedVar(lang.NewSymbol("list")) + if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) + } + v51 := v50.Get() + v52 := lang.Apply(v51, []any{v4}) + v53 := lang.Apply(v44, []any{v48, v52}) + v54 := lang.Apply(v41, []any{v53}) + v55 := lang.Apply(v38, []any{v54}) + v56 := lang.Apply(v27, []any{v31, v35, v55}) + v57 := lang.Apply(v24, []any{v56}) + v58 := lang.Apply(v21, []any{v57}) + v59 := lang.Apply(v10, []any{v14, v18, v58}) + v60 := lang.Apply(v7, []any{v59}) + return v60 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("aget").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("&"), lang.NewSymbol("idxs"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the value at the index/indices. Works on Java arrays of all\n types.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3911), lang.NewKeyword("end-line"), int(3911))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := lang.Apply(lang.Get, []any{v4, v5}) + return v6 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := lang.NewList(args[2:]...) + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("apply")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("aget")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("aget")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{v4, v5}) + v17 := lang.Apply(v9, []any{v12, v16, v6}) + return v17 + } + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // alength + { + var v1 lang.FnFunc + { // function alength__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("concat")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("list")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("seq")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("concat")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/Alength")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{v3}) + v35 := lang.Apply(v26, []any{v30, v34}) + v36 := lang.Apply(v23, []any{v35}) + v37 := lang.Apply(v20, []any{v36}) + v38 := lang.Apply(v9, []any{v13, v17, v37}) + v39 := lang.Apply(v6, []any{v38}) + return v39 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("alength").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the length of the Java array. Works on arrays of all\n types.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3897), lang.NewKeyword("end-line"), int(3897))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5, _ := lang.FieldOrMethod(runtime4.RT, "Alength") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Alength is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // alias + { + v0 := lang.NewSymbol("alias").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("alias"), lang.NewSymbol("namespace-sym"))), lang.NewKeyword("doc"), "Add an alias in the current namespace to another\n namespace. Arguments are two symbols: the alias to be used, and\n the symbolic name of the target namespace. Use :as in the ns macro in preference\n to calling this directly.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4263), lang.NewKeyword("end-line"), int(4263))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("*ns*")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("the-ns")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v4}) + v12, _ := lang.FieldOrMethod(v7, "AddAlias") + if reflect.TypeOf(v12).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("AddAlias is not a function"))) + } + v13 := lang.Apply(v12, []any{v3, v11}) + return v13 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // all-ns + { + v0 := lang.NewSymbol("all-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Returns a sequence of all namespaces.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4146), lang.NewKeyword("end-line"), int(4146))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := lang.Apply(nil, nil) + return v3 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // alter + { + v0 := lang.NewSymbol("alter").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("fun"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Must be called in a transaction. Sets the in-transaction-value of\n ref to:\n\n (apply fun in-transaction-value-of-ref args)\n\n and returns the in-transaction-value of ref.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2435), lang.NewKeyword("end-line"), int(2435))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.NewList(args[2:]...) + v6, _ := lang.FieldOrMethod(v3, "alter") + if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("alter is not a function"))) + } + v7 := lang.Apply(v6, []any{v4, v5}) + return v7 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // alter-meta! + { + v0 := lang.NewSymbol("alter-meta!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("iref"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Atomically sets the metadata for a namespace/var/ref/agent/atom to be:\n\n (apply f its-current-meta args)\n\n f must be free of side-effects", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2398), lang.NewKeyword("end-line"), int(2398))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.NewList(args[2:]...) + v6, _ := lang.FieldOrMethod(v3, "AlterMeta") + if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("AlterMeta is not a function"))) + } + v7 := lang.Apply(v6, []any{v4, v5}) + return v7 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // alter-var-root + { + v0 := lang.NewSymbol("alter-var-root").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("v"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Atomically alters the root binding of var v by applying f to its\n current value plus any args", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5484), lang.NewKeyword("end-line"), int(5484))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.NewList(args[2:]...) + v6, _ := lang.FieldOrMethod(v3, "alterRoot") + if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("alterRoot is not a function"))) + } + v7 := lang.Apply(v6, []any{v4, v5}) + return v7 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // amap + { + v0 := lang.NewSymbol("amap").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("idx"), lang.NewSymbol("ret"), lang.NewSymbol("expr"))), lang.NewKeyword("doc"), "Maps an expression across an array a, using an index named idx, and\n return value named ret, initialized to a clone of a, then setting \n each element of ret to the evaluation of expr, returning the new \n array ret.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5273), lang.NewKeyword("end-line"), int(5273))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 6 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := args[4] + _ = v7 + v8 := args[5] + _ = v8 + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("seq")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("concat")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("list")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{lang.NewSymbol("glojure.core/let")}) + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("list")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("apply")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("vector")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("seq")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("concat")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("list")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.Apply(v36, []any{lang.NewSymbol("a__0__auto__")}) + v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v39 := v38.FindInternedVar(lang.NewSymbol("list")) + if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + } + v40 := v39.Get() + v41 := lang.Apply(v40, []any{v5}) + v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v43 := v42.FindInternedVar(lang.NewSymbol("list")) + if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) + } + v44 := v43.Get() + v45 := lang.Apply(v44, []any{lang.NewSymbol("l__1__auto__")}) + v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v47 := v46.FindInternedVar(lang.NewSymbol("list")) + if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) + } + v48 := v47.Get() + v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v50 := v49.FindInternedVar(lang.NewSymbol("seq")) + if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) + } + v51 := v50.Get() + v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v53 := v52.FindInternedVar(lang.NewSymbol("concat")) + if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) + } + v54 := v53.Get() + v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v56 := v55.FindInternedVar(lang.NewSymbol("list")) + if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) + } + v57 := v56.Get() + v58 := lang.Apply(v57, []any{lang.NewSymbol("glojure.core/alength")}) + v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v60 := v59.FindInternedVar(lang.NewSymbol("list")) + if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) + } + v61 := v60.Get() + v62 := lang.Apply(v61, []any{lang.NewSymbol("a__0__auto__")}) + v63 := lang.Apply(v54, []any{v58, v62}) + v64 := lang.Apply(v51, []any{v63}) + v65 := lang.Apply(v48, []any{v64}) + v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v67 := v66.FindInternedVar(lang.NewSymbol("list")) + if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) + } + v68 := v67.Get() + v69 := lang.Apply(v68, []any{v7}) + v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v71 := v70.FindInternedVar(lang.NewSymbol("list")) + if v71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) + } + v72 := v71.Get() + v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v74 := v73.FindInternedVar(lang.NewSymbol("seq")) + if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) + } + v75 := v74.Get() + v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v77 := v76.FindInternedVar(lang.NewSymbol("concat")) + if v77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) + } + v78 := v77.Get() + v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v80 := v79.FindInternedVar(lang.NewSymbol("list")) + if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) + } + v81 := v80.Get() + v82 := lang.Apply(v81, []any{lang.NewSymbol("glojure.core/aclone")}) + v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v84 := v83.FindInternedVar(lang.NewSymbol("list")) + if v84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) + } + v85 := v84.Get() + v86 := lang.Apply(v85, []any{lang.NewSymbol("a__0__auto__")}) + v87 := lang.Apply(v78, []any{v82, v86}) + v88 := lang.Apply(v75, []any{v87}) + v89 := lang.Apply(v72, []any{v88}) + v90 := lang.Apply(v33, []any{v37, v41, v45, v65, v69, v89}) + v91 := lang.Apply(v30, []any{v90}) + v92 := lang.Apply(v24, []any{v27, v91}) + v93 := lang.Apply(v21, []any{v92}) + v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v95 := v94.FindInternedVar(lang.NewSymbol("list")) + if v95.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) + } + v96 := v95.Get() + v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v98 := v97.FindInternedVar(lang.NewSymbol("seq")) + if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) + } + v99 := v98.Get() + v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v101 := v100.FindInternedVar(lang.NewSymbol("concat")) + if v101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) + } + v102 := v101.Get() + v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v104 := v103.FindInternedVar(lang.NewSymbol("list")) + if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) + } + v105 := v104.Get() + v106 := lang.Apply(v105, []any{lang.NewSymbol("glojure.core/loop")}) + v107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v108 := v107.FindInternedVar(lang.NewSymbol("list")) + if v108.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v108))) + } + v109 := v108.Get() + v110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v111 := v110.FindInternedVar(lang.NewSymbol("apply")) + if v111.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v111))) + } + v112 := v111.Get() + v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v114 := v113.FindInternedVar(lang.NewSymbol("vector")) + if v114.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) + } + v115 := v114.Get() + v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v117 := v116.FindInternedVar(lang.NewSymbol("seq")) + if v117.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) + } + v118 := v117.Get() + v119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v120 := v119.FindInternedVar(lang.NewSymbol("concat")) + if v120.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v120))) + } + v121 := v120.Get() + v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v123 := v122.FindInternedVar(lang.NewSymbol("list")) + if v123.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) + } + v124 := v123.Get() + v125 := lang.Apply(v124, []any{v6}) + v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v127 := v126.FindInternedVar(lang.NewSymbol("list")) + if v127.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) + } + v128 := v127.Get() + v129 := lang.Apply(v128, []any{int64(0)}) + v130 := lang.Apply(v121, []any{v125, v129}) + v131 := lang.Apply(v118, []any{v130}) + v132 := lang.Apply(v112, []any{v115, v131}) + v133 := lang.Apply(v109, []any{v132}) + v134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v135 := v134.FindInternedVar(lang.NewSymbol("list")) + if v135.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v135))) + } + v136 := v135.Get() + v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v138 := v137.FindInternedVar(lang.NewSymbol("seq")) + if v138.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) + } + v139 := v138.Get() + v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v141 := v140.FindInternedVar(lang.NewSymbol("concat")) + if v141.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) + } + v142 := v141.Get() + v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v144 := v143.FindInternedVar(lang.NewSymbol("list")) + if v144.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) + } + v145 := v144.Get() + v146 := lang.Apply(v145, []any{lang.NewSymbol("if")}) + v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v148 := v147.FindInternedVar(lang.NewSymbol("list")) + if v148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) + } + v149 := v148.Get() + v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v151 := v150.FindInternedVar(lang.NewSymbol("seq")) + if v151.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) + } + v152 := v151.Get() + v153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v154 := v153.FindInternedVar(lang.NewSymbol("concat")) + if v154.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v154))) + } + v155 := v154.Get() + v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v157 := v156.FindInternedVar(lang.NewSymbol("list")) + if v157.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) + } + v158 := v157.Get() + v159 := lang.Apply(v158, []any{lang.NewSymbol("glojure.core/<")}) + v160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v161 := v160.FindInternedVar(lang.NewSymbol("list")) + if v161.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v161))) + } + v162 := v161.Get() + v163 := lang.Apply(v162, []any{v6}) + v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v165 := v164.FindInternedVar(lang.NewSymbol("list")) + if v165.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) + } + v166 := v165.Get() + v167 := lang.Apply(v166, []any{lang.NewSymbol("l__1__auto__")}) + v168 := lang.Apply(v155, []any{v159, v163, v167}) + v169 := lang.Apply(v152, []any{v168}) + v170 := lang.Apply(v149, []any{v169}) + v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v172 := v171.FindInternedVar(lang.NewSymbol("list")) + if v172.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) + } + v173 := v172.Get() + v174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v175 := v174.FindInternedVar(lang.NewSymbol("seq")) + if v175.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v175))) + } + v176 := v175.Get() + v177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v178 := v177.FindInternedVar(lang.NewSymbol("concat")) + if v178.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v178))) + } + v179 := v178.Get() + v180 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v181 := v180.FindInternedVar(lang.NewSymbol("list")) + if v181.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v181))) + } + v182 := v181.Get() + v183 := lang.Apply(v182, []any{lang.NewSymbol("do")}) + v184 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v185 := v184.FindInternedVar(lang.NewSymbol("list")) + if v185.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v185))) + } + v186 := v185.Get() + v187 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v188 := v187.FindInternedVar(lang.NewSymbol("seq")) + if v188.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v188))) + } + v189 := v188.Get() + v190 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v191 := v190.FindInternedVar(lang.NewSymbol("concat")) + if v191.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v191))) + } + v192 := v191.Get() + v193 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v194 := v193.FindInternedVar(lang.NewSymbol("list")) + if v194.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v194))) + } + v195 := v194.Get() + v196 := lang.Apply(v195, []any{lang.NewSymbol("glojure.core/aset")}) + v197 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v198 := v197.FindInternedVar(lang.NewSymbol("list")) + if v198.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v198))) + } + v199 := v198.Get() + v200 := lang.Apply(v199, []any{v7}) + v201 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v202 := v201.FindInternedVar(lang.NewSymbol("list")) + if v202.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v202))) + } + v203 := v202.Get() + v204 := lang.Apply(v203, []any{v6}) + v205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v206 := v205.FindInternedVar(lang.NewSymbol("list")) + if v206.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v206))) + } + v207 := v206.Get() + v208 := lang.Apply(v207, []any{v8}) + v209 := lang.Apply(v192, []any{v196, v200, v204, v208}) + v210 := lang.Apply(v189, []any{v209}) + v211 := lang.Apply(v186, []any{v210}) + v212 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v213 := v212.FindInternedVar(lang.NewSymbol("list")) + if v213.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v213))) + } + v214 := v213.Get() + v215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v216 := v215.FindInternedVar(lang.NewSymbol("seq")) + if v216.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v216))) + } + v217 := v216.Get() + v218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v219 := v218.FindInternedVar(lang.NewSymbol("concat")) + if v219.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v219))) + } + v220 := v219.Get() + v221 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v222 := v221.FindInternedVar(lang.NewSymbol("list")) + if v222.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v222))) + } + v223 := v222.Get() + v224 := lang.Apply(v223, []any{lang.NewSymbol("recur")}) + v225 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v226 := v225.FindInternedVar(lang.NewSymbol("list")) + if v226.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v226))) + } + v227 := v226.Get() + v228 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v229 := v228.FindInternedVar(lang.NewSymbol("seq")) + if v229.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v229))) + } + v230 := v229.Get() + v231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v232 := v231.FindInternedVar(lang.NewSymbol("concat")) + if v232.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v232))) + } + v233 := v232.Get() + v234 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v235 := v234.FindInternedVar(lang.NewSymbol("list")) + if v235.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v235))) + } + v236 := v235.Get() + v237 := lang.Apply(v236, []any{lang.NewSymbol("glojure.core/unchecked-inc")}) + v238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v239 := v238.FindInternedVar(lang.NewSymbol("list")) + if v239.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v239))) + } + v240 := v239.Get() + v241 := lang.Apply(v240, []any{v6}) + v242 := lang.Apply(v233, []any{v237, v241}) + v243 := lang.Apply(v230, []any{v242}) + v244 := lang.Apply(v227, []any{v243}) + v245 := lang.Apply(v220, []any{v224, v244}) + v246 := lang.Apply(v217, []any{v245}) + v247 := lang.Apply(v214, []any{v246}) + v248 := lang.Apply(v179, []any{v183, v211, v247}) + v249 := lang.Apply(v176, []any{v248}) + v250 := lang.Apply(v173, []any{v249}) + v251 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v252 := v251.FindInternedVar(lang.NewSymbol("list")) + if v252.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v252))) + } + v253 := v252.Get() + v254 := lang.Apply(v253, []any{v7}) + v255 := lang.Apply(v142, []any{v146, v170, v250, v254}) + v256 := lang.Apply(v139, []any{v255}) + v257 := lang.Apply(v136, []any{v256}) + v258 := lang.Apply(v102, []any{v106, v133, v257}) + v259 := lang.Apply(v99, []any{v258}) + v260 := lang.Apply(v96, []any{v259}) + v261 := lang.Apply(v14, []any{v18, v93, v260}) + v262 := lang.Apply(v11, []any{v261}) + return v262 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // ancestors + { + v0 := lang.NewSymbol("ancestors").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"))), lang.NewKeyword("doc"), "Returns the immediate and indirect parents of tag, either via a Java type\n inheritance relationship or a relationship established via derive. h\n must be a hierarchy obtained from make-hierarchy, if not supplied\n defaults to the global hierarchy", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5577), lang.NewKeyword("end-line"), int(5577))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("ancestors")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("global-hierarchy")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v6, []any{v9, v3}) + return v10 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("not-empty")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + var v8 any + { // let + // let binding "ta" + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("get")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) + v13 := lang.Apply(v11, []any{v12, v4}) + var v14 any = v13 + _ = v14 + var v15 any + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("class?")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{v4}) + if lang.IsTruthy(v19) { + var v20 any + { // let + // let binding "superclasses" + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("set")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("supers")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.Apply(v26, []any{v4}) + v28 := lang.Apply(v23, []any{v27}) + var v29 any = v28 + _ = v29 + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("reduce1")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("into1")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("cons")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v40 := v39.FindInternedVar(lang.NewSymbol("map")) + if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) + } + v41 := v40.Get() + var v42 lang.FnFunc + v42 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v43 := args[0] + _ = v43 + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("get")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) + v48 := lang.Apply(v46, []any{v47, v43}) + return v48 + }) + v43 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5590), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(5590), lang.NewKeyword("end-column"), int(54)) + v44, err := lang.WithMeta(v42, v43.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v45 := lang.Apply(v41, []any{v44, v29}) + v46 := lang.Apply(v38, []any{v14, v45}) + v47 := lang.Apply(v32, []any{v35, v29, v46}) + v20 = v47 + } // end let + v15 = v20 + } else { + v15 = v14 + } + v8 = v15 + } // end let + v9 := lang.Apply(v7, []any{v8}) + return v9 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // and + { + v0 := lang.NewSymbol("and").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("next"))), lang.NewKeyword("doc"), "Evaluates exprs one at a time, from left to right. If a form\n returns logical false (nil or false), and returns that value and\n doesn't evaluate any of the other expressions, otherwise it returns\n the value of the last expr. (and) returns true.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(835), lang.NewKeyword("end-line"), int(835))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + return true + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + return v5 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("seq")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("concat")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("list")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/let")}) + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("list")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("apply")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("vector")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("seq")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("concat")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("list")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{lang.NewSymbol("and__0__auto__")}) + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("list")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v38, []any{v5}) + v40 := lang.Apply(v31, []any{v35, v39}) + v41 := lang.Apply(v28, []any{v40}) + v42 := lang.Apply(v22, []any{v25, v41}) + v43 := lang.Apply(v19, []any{v42}) + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("list")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v48 := v47.FindInternedVar(lang.NewSymbol("seq")) + if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) + } + v49 := v48.Get() + v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v51 := v50.FindInternedVar(lang.NewSymbol("concat")) + if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) + } + v52 := v51.Get() + v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v54 := v53.FindInternedVar(lang.NewSymbol("list")) + if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) + } + v55 := v54.Get() + v56 := lang.Apply(v55, []any{lang.NewSymbol("if")}) + v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v58 := v57.FindInternedVar(lang.NewSymbol("list")) + if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) + } + v59 := v58.Get() + v60 := lang.Apply(v59, []any{lang.NewSymbol("and__0__auto__")}) + v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v62 := v61.FindInternedVar(lang.NewSymbol("list")) + if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) + } + v63 := v62.Get() + v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v65 := v64.FindInternedVar(lang.NewSymbol("seq")) + if v65.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) + } + v66 := v65.Get() + v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v68 := v67.FindInternedVar(lang.NewSymbol("concat")) + if v68.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) + } + v69 := v68.Get() + v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v71 := v70.FindInternedVar(lang.NewSymbol("list")) + if v71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) + } + v72 := v71.Get() + v73 := lang.Apply(v72, []any{lang.NewSymbol("glojure.core/and")}) + v74 := lang.Apply(v69, []any{v73, v6}) + v75 := lang.Apply(v66, []any{v74}) + v76 := lang.Apply(v63, []any{v75}) + v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v78 := v77.FindInternedVar(lang.NewSymbol("list")) + if v78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) + } + v79 := v78.Get() + v80 := lang.Apply(v79, []any{lang.NewSymbol("and__0__auto__")}) + v81 := lang.Apply(v52, []any{v56, v60, v76, v80}) + v82 := lang.Apply(v49, []any{v81}) + v83 := lang.Apply(v46, []any{v82}) + v84 := lang.Apply(v12, []any{v16, v43, v83}) + v85 := lang.Apply(v9, []any{v84}) + return v85 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // any? + { + v1 := reflect.TypeOf(false) + v0 := lang.NewSymbol("any?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true given any argument.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(537), lang.NewKeyword("end-line"), int(537))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + return true + }) + v4 := reflect.TypeOf(false) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // apply + { + v0 := lang.NewSymbol("apply").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("z"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Applies fn f to the argument list formed by prepending intervening arguments to args.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(653), lang.NewKeyword("end-line"), int(653))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("seq")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v4}) + v9 := lang.Apply(lang.Apply, []any{v3, v8}) + return v9 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("list*")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{v4, v5}) + v10 := lang.Apply(lang.Apply, []any{v3, v9}) + return v10 + case 4: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("list*")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, []any{v4, v5, v6}) + v11 := lang.Apply(lang.Apply, []any{v3, v10}) + return v11 + case 5: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := args[4] + _ = v7 + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("list*")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v4, v5, v6, v7}) + v12 := lang.Apply(lang.Apply, []any{v3, v11}) + return v12 + default: + if len(args) < 5 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := args[4] + _ = v7 + v8 := lang.NewList(args[5:]...) + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("cons")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("cons")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("cons")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("cons")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("spread")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.Apply(v23, []any{v8}) + v25 := lang.Apply(v20, []any{v7, v24}) + v26 := lang.Apply(v17, []any{v6, v25}) + v27 := lang.Apply(v14, []any{v5, v26}) + v28 := lang.Apply(v11, []any{v4, v27}) + v29 := lang.Apply(lang.Apply, []any{v3, v28}) + return v29 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // areduce + { + v0 := lang.NewSymbol("areduce").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("idx"), lang.NewSymbol("ret"), lang.NewSymbol("init"), lang.NewSymbol("expr"))), lang.NewKeyword("doc"), "Reduces an expression across an array a, using an index named idx,\n and return value named ret, initialized to init, setting ret to the \n evaluation of expr at each step, returning ret.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5289), lang.NewKeyword("end-line"), int(5289))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 7 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := args[4] + _ = v7 + v8 := args[5] + _ = v8 + v9 := args[6] + _ = v9 + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("seq")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("concat")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("list")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{lang.NewSymbol("glojure.core/let")}) + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("list")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("apply")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("vector")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("seq")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("concat")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v36 := v35.FindInternedVar(lang.NewSymbol("list")) + if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + } + v37 := v36.Get() + v38 := lang.Apply(v37, []any{lang.NewSymbol("a__0__auto__")}) + v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v40 := v39.FindInternedVar(lang.NewSymbol("list")) + if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) + } + v41 := v40.Get() + v42 := lang.Apply(v41, []any{v5}) + v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v44 := v43.FindInternedVar(lang.NewSymbol("list")) + if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) + } + v45 := v44.Get() + v46 := lang.Apply(v45, []any{lang.NewSymbol("l__1__auto__")}) + v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v48 := v47.FindInternedVar(lang.NewSymbol("list")) + if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) + } + v49 := v48.Get() + v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v51 := v50.FindInternedVar(lang.NewSymbol("seq")) + if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) + } + v52 := v51.Get() + v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v54 := v53.FindInternedVar(lang.NewSymbol("concat")) + if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) + } + v55 := v54.Get() + v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v57 := v56.FindInternedVar(lang.NewSymbol("list")) + if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) + } + v58 := v57.Get() + v59 := lang.Apply(v58, []any{lang.NewSymbol("glojure.core/alength")}) + v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v61 := v60.FindInternedVar(lang.NewSymbol("list")) + if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) + } + v62 := v61.Get() + v63 := lang.Apply(v62, []any{lang.NewSymbol("a__0__auto__")}) + v64 := lang.Apply(v55, []any{v59, v63}) + v65 := lang.Apply(v52, []any{v64}) + v66 := lang.Apply(v49, []any{v65}) + v67 := lang.Apply(v34, []any{v38, v42, v46, v66}) + v68 := lang.Apply(v31, []any{v67}) + v69 := lang.Apply(v25, []any{v28, v68}) + v70 := lang.Apply(v22, []any{v69}) + v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v72 := v71.FindInternedVar(lang.NewSymbol("list")) + if v72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) + } + v73 := v72.Get() + v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v75 := v74.FindInternedVar(lang.NewSymbol("seq")) + if v75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) + } + v76 := v75.Get() + v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v78 := v77.FindInternedVar(lang.NewSymbol("concat")) + if v78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) + } + v79 := v78.Get() + v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v81 := v80.FindInternedVar(lang.NewSymbol("list")) + if v81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) + } + v82 := v81.Get() + v83 := lang.Apply(v82, []any{lang.NewSymbol("glojure.core/loop")}) + v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v85 := v84.FindInternedVar(lang.NewSymbol("list")) + if v85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) + } + v86 := v85.Get() + v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v88 := v87.FindInternedVar(lang.NewSymbol("apply")) + if v88.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) + } + v89 := v88.Get() + v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v91 := v90.FindInternedVar(lang.NewSymbol("vector")) + if v91.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) + } + v92 := v91.Get() + v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v94 := v93.FindInternedVar(lang.NewSymbol("seq")) + if v94.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) + } + v95 := v94.Get() + v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v97 := v96.FindInternedVar(lang.NewSymbol("concat")) + if v97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) + } + v98 := v97.Get() + v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v100 := v99.FindInternedVar(lang.NewSymbol("list")) + if v100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) + } + v101 := v100.Get() + v102 := lang.Apply(v101, []any{v6}) + v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v104 := v103.FindInternedVar(lang.NewSymbol("list")) + if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) + } + v105 := v104.Get() + v106 := lang.Apply(v105, []any{int64(0)}) + v107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v108 := v107.FindInternedVar(lang.NewSymbol("list")) + if v108.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v108))) + } + v109 := v108.Get() + v110 := lang.Apply(v109, []any{v7}) + v111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v112 := v111.FindInternedVar(lang.NewSymbol("list")) + if v112.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v112))) + } + v113 := v112.Get() + v114 := lang.Apply(v113, []any{v8}) + v115 := lang.Apply(v98, []any{v102, v106, v110, v114}) + v116 := lang.Apply(v95, []any{v115}) + v117 := lang.Apply(v89, []any{v92, v116}) + v118 := lang.Apply(v86, []any{v117}) + v119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v120 := v119.FindInternedVar(lang.NewSymbol("list")) + if v120.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v120))) + } + v121 := v120.Get() + v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v123 := v122.FindInternedVar(lang.NewSymbol("seq")) + if v123.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) + } + v124 := v123.Get() + v125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v126 := v125.FindInternedVar(lang.NewSymbol("concat")) + if v126.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v126))) + } + v127 := v126.Get() + v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v129 := v128.FindInternedVar(lang.NewSymbol("list")) + if v129.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v129))) + } + v130 := v129.Get() + v131 := lang.Apply(v130, []any{lang.NewSymbol("if")}) + v132 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v133 := v132.FindInternedVar(lang.NewSymbol("list")) + if v133.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v133))) + } + v134 := v133.Get() + v135 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v136 := v135.FindInternedVar(lang.NewSymbol("seq")) + if v136.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v136))) + } + v137 := v136.Get() + v138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v139 := v138.FindInternedVar(lang.NewSymbol("concat")) + if v139.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v139))) + } + v140 := v139.Get() + v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v142 := v141.FindInternedVar(lang.NewSymbol("list")) + if v142.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) + } + v143 := v142.Get() + v144 := lang.Apply(v143, []any{lang.NewSymbol("glojure.core/<")}) + v145 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v146 := v145.FindInternedVar(lang.NewSymbol("list")) + if v146.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v146))) + } + v147 := v146.Get() + v148 := lang.Apply(v147, []any{v6}) + v149 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v150 := v149.FindInternedVar(lang.NewSymbol("list")) + if v150.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v150))) + } + v151 := v150.Get() + v152 := lang.Apply(v151, []any{lang.NewSymbol("l__1__auto__")}) + v153 := lang.Apply(v140, []any{v144, v148, v152}) + v154 := lang.Apply(v137, []any{v153}) + v155 := lang.Apply(v134, []any{v154}) + v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v157 := v156.FindInternedVar(lang.NewSymbol("list")) + if v157.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) + } + v158 := v157.Get() + v159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v160 := v159.FindInternedVar(lang.NewSymbol("seq")) + if v160.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v160))) + } + v161 := v160.Get() + v162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v163 := v162.FindInternedVar(lang.NewSymbol("concat")) + if v163.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v163))) + } + v164 := v163.Get() + v165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v166 := v165.FindInternedVar(lang.NewSymbol("list")) + if v166.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v166))) + } + v167 := v166.Get() + v168 := lang.Apply(v167, []any{lang.NewSymbol("recur")}) + v169 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v170 := v169.FindInternedVar(lang.NewSymbol("list")) + if v170.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v170))) + } + v171 := v170.Get() + v172 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v173 := v172.FindInternedVar(lang.NewSymbol("seq")) + if v173.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v173))) + } + v174 := v173.Get() + v175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v176 := v175.FindInternedVar(lang.NewSymbol("concat")) + if v176.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v176))) + } + v177 := v176.Get() + v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v179 := v178.FindInternedVar(lang.NewSymbol("list")) + if v179.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) + } + v180 := v179.Get() + v181 := lang.Apply(v180, []any{lang.NewSymbol("glojure.core/unchecked-inc-int")}) + v182 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v183 := v182.FindInternedVar(lang.NewSymbol("list")) + if v183.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v183))) + } + v184 := v183.Get() + v185 := lang.Apply(v184, []any{v6}) + v186 := lang.Apply(v177, []any{v181, v185}) + v187 := lang.Apply(v174, []any{v186}) + v188 := lang.Apply(v171, []any{v187}) + v189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v190 := v189.FindInternedVar(lang.NewSymbol("list")) + if v190.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v190))) + } + v191 := v190.Get() + v192 := lang.Apply(v191, []any{v9}) + v193 := lang.Apply(v164, []any{v168, v188, v192}) + v194 := lang.Apply(v161, []any{v193}) + v195 := lang.Apply(v158, []any{v194}) + v196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v197 := v196.FindInternedVar(lang.NewSymbol("list")) + if v197.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v197))) + } + v198 := v197.Get() + v199 := lang.Apply(v198, []any{v7}) + v200 := lang.Apply(v127, []any{v131, v155, v195, v199}) + v201 := lang.Apply(v124, []any{v200}) + v202 := lang.Apply(v121, []any{v201}) + v203 := lang.Apply(v79, []any{v83, v118, v202}) + v204 := lang.Apply(v76, []any{v203}) + v205 := lang.Apply(v73, []any{v204}) + v206 := lang.Apply(v15, []any{v19, v70, v205}) + v207 := lang.Apply(v12, []any{v206}) + return v207 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // array + { + v0 := lang.NewSymbol("array").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3457), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3458), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("items"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := lang.NewList(args[0:]...) + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("into-array")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.Apply(v6, []any{v3}) + return v7 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // array-map + { + v0 := lang.NewSymbol("array-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keyvals"))), lang.NewKeyword("doc"), "Constructs an array-map. If any keys are equal, they are handled as\n if by repeated uses of assoc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4378), lang.NewKeyword("end-line"), int(4378))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + v3, ok := lang.FieldOrMethod(nil, "EMPTY") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "EMPTY"))) + } + var v4 any + switch reflect.TypeOf(v3).Kind() { + case reflect.Func: + v4 = lang.Apply(v3, nil) + default: + v4 = v3 + } + return v4 + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := lang.NewList(args[0:]...) + var v4 any + { // let + // let binding "ary" + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("to-array")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v3}) + var v9 any = v8 + _ = v9 + var v10 any + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("odd?")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("alength")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{v9}) + v18 := lang.Apply(v13, []any{v17}) + if lang.IsTruthy(v18) { + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("str")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("last")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v3}) + v26 := lang.Apply(v21, []any{"No value supplied for key: ", v25}) + v27 := lang.Apply(lang.NewIllegalArgumentError, []any{v26}) + panic(v27) + } else { + v28 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{v9}) + v10 = v28 + } + v4 = v10 + } // end let + return v4 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // as-> + { + v0 := lang.NewSymbol("as->").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "Binds name to expr, evaluates the first form in the lexical context\n of that binding, then binds name to that result, repeating for each\n successive form, returning the result of the last form.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7598), lang.NewKeyword("end-line"), int(7598))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := lang.NewList(args[4:]...) + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("seq")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("concat")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("glojure.core/let")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("apply")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("vector")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("seq")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("concat")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("list")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.Apply(v35, []any{v6}) + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("list")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.Apply(v39, []any{v5}) + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("interleave")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("repeat")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.Apply(v46, []any{v6}) + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("butlast")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v7}) + v52 := lang.Apply(v43, []any{v47, v51}) + v53 := lang.Apply(v32, []any{v36, v40, v52}) + v54 := lang.Apply(v29, []any{v53}) + v55 := lang.Apply(v23, []any{v26, v54}) + v56 := lang.Apply(v20, []any{v55}) + v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v58 := v57.FindInternedVar(lang.NewSymbol("list")) + if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) + } + v59 := v58.Get() + var v60 any + v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v62 := v61.FindInternedVar(lang.NewSymbol("empty?")) + if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) + } + v63 := v62.Get() + v64 := lang.Apply(v63, []any{v7}) + if lang.IsTruthy(v64) { + v60 = v6 + } else { + v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v66 := v65.FindInternedVar(lang.NewSymbol("last")) + if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) + } + v67 := v66.Get() + v68 := lang.Apply(v67, []any{v7}) + v60 = v68 + } + v69 := lang.Apply(v59, []any{v60}) + v70 := lang.Apply(v13, []any{v17, v56, v69}) + v71 := lang.Apply(v10, []any{v70}) + return v71 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // aset + { + var v1 lang.FnFunc + { // function aset__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("seq")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("concat")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("list")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.Apply(v14, []any{lang.NewSymbol(".")}) + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("list")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("list")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("seq")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("concat")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("list")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.Apply(v31, []any{lang.NewSymbol("glojure.core/Aset")}) + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("list")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.Apply(v35, []any{v3}) + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("list")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("seq")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v44 := v43.FindInternedVar(lang.NewSymbol("concat")) + if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) + } + v45 := v44.Get() + v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v47 := v46.FindInternedVar(lang.NewSymbol("list")) + if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) + } + v48 := v47.Get() + v49 := lang.Apply(v48, []any{lang.NewSymbol("glojure.core/int")}) + v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v51 := v50.FindInternedVar(lang.NewSymbol("list")) + if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) + } + v52 := v51.Get() + v53 := lang.Apply(v52, []any{v4}) + v54 := lang.Apply(v45, []any{v49, v53}) + v55 := lang.Apply(v42, []any{v54}) + v56 := lang.Apply(v39, []any{v55}) + v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v58 := v57.FindInternedVar(lang.NewSymbol("list")) + if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) + } + v59 := v58.Get() + v60 := lang.Apply(v59, []any{v5}) + v61 := lang.Apply(v28, []any{v32, v36, v56, v60}) + v62 := lang.Apply(v25, []any{v61}) + v63 := lang.Apply(v22, []any{v62}) + v64 := lang.Apply(v11, []any{v15, v19, v63}) + v65 := lang.Apply(v8, []any{v64}) + return v65 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("aset").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on Java arrays of\n reference types. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(3)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3922), lang.NewKeyword("end-line"), int(3922))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := args[2] + _ = v6 + v7 := lang.Apply(lang.SliceSet, []any{v4, v5, v6}) + _ = v7 + return v6 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := args[2] + _ = v6 + v7 := lang.NewList(args[3:]...) + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("apply")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("aset")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("aget")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{v4, v5}) + v18 := lang.Apply(v10, []any{v13, v17, v6, v7}) + return v18 + } + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // aset-boolean + { + v0 := lang.NewSymbol("aset-boolean").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of boolean. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3956), lang.NewKeyword("end-line"), int(3958))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("boolean")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{v5}) + v10, _ := lang.FieldOrMethod(nil, "setBoolean") + if reflect.TypeOf(v10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setBoolean is not a function"))) + } + v11 := lang.Apply(v10, []any{v3, v4, v9}) + _ = v11 + return v5 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("apply")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("aset-boolean")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("aget")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{v3, v4}) + v17 := lang.Apply(v9, []any{v12, v16, v5, v6}) + return v17 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // aset-byte + { + v0 := lang.NewSymbol("aset-byte").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of byte. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3976), lang.NewKeyword("end-line"), int(3978))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("byte")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{v5}) + v10, _ := lang.FieldOrMethod(nil, "setByte") + if reflect.TypeOf(v10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setByte is not a function"))) + } + v11 := lang.Apply(v10, []any{v3, v4, v9}) + _ = v11 + return v5 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("apply")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("aset-byte")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("aget")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{v3, v4}) + v17 := lang.Apply(v9, []any{v12, v16, v5, v6}) + return v17 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // aset-char + { + v0 := lang.NewSymbol("aset-char").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of char. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3981), lang.NewKeyword("end-line"), int(3983))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("char")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{v5}) + v10, _ := lang.FieldOrMethod(nil, "setChar") + if reflect.TypeOf(v10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setChar is not a function"))) + } + v11 := lang.Apply(v10, []any{v3, v4, v9}) + _ = v11 + return v5 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("apply")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("aset-char")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("aget")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{v3, v4}) + v17 := lang.Apply(v9, []any{v12, v16, v5, v6}) + return v17 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // aset-double + { + v0 := lang.NewSymbol("aset-double").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of double. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3966), lang.NewKeyword("end-line"), int(3968))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("double")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{v5}) + v10, _ := lang.FieldOrMethod(nil, "setDouble") + if reflect.TypeOf(v10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setDouble is not a function"))) + } + v11 := lang.Apply(v10, []any{v3, v4, v9}) + _ = v11 + return v5 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("apply")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("aset-double")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("aget")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{v3, v4}) + v17 := lang.Apply(v9, []any{v12, v16, v5, v6}) + return v17 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // aset-float + { + v0 := lang.NewSymbol("aset-float").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of float. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3961), lang.NewKeyword("end-line"), int(3963))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("float")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{v5}) + v10, _ := lang.FieldOrMethod(nil, "setFloat") + if reflect.TypeOf(v10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setFloat is not a function"))) + } + v11 := lang.Apply(v10, []any{v3, v4, v9}) + _ = v11 + return v5 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("apply")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("aset-float")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("aget")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{v3, v4}) + v17 := lang.Apply(v9, []any{v12, v16, v5, v6}) + return v17 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // aset-int + { + v0 := lang.NewSymbol("aset-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of int. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3946), lang.NewKeyword("end-line"), int(3948))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("int")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{v5}) + v10, _ := lang.FieldOrMethod(nil, "setInt") + if reflect.TypeOf(v10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setInt is not a function"))) + } + v11 := lang.Apply(v10, []any{v3, v4, v9}) + _ = v11 + return v5 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("apply")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("aset-int")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("aget")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{v3, v4}) + v17 := lang.Apply(v9, []any{v12, v16, v5, v6}) + return v17 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // aset-long + { + v0 := lang.NewSymbol("aset-long").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of long. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3951), lang.NewKeyword("end-line"), int(3953))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("long")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{v5}) + v10, _ := lang.FieldOrMethod(nil, "setLong") + if reflect.TypeOf(v10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setLong is not a function"))) + } + v11 := lang.Apply(v10, []any{v3, v4, v9}) + _ = v11 + return v5 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("apply")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("aset-long")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("aget")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{v3, v4}) + v17 := lang.Apply(v9, []any{v12, v16, v5, v6}) + return v17 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // aset-short + { + v0 := lang.NewSymbol("aset-short").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of short. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3971), lang.NewKeyword("end-line"), int(3973))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("short")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{v5}) + v10, _ := lang.FieldOrMethod(nil, "setShort") + if reflect.TypeOf(v10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setShort is not a function"))) + } + v11 := lang.Apply(v10, []any{v3, v4, v9}) + _ = v11 + return v5 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("apply")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("aset-short")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("aget")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{v3, v4}) + v17 := lang.Apply(v9, []any{v12, v16, v5, v6}) + return v17 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // assert + { + v0 := lang.NewSymbol("assert").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("message"))), lang.NewKeyword("doc"), "Evaluates expression x and throws an AssertionError with optional\n message if x does not evaluate to logical true.\n\n Assertion checks are omitted from compiled code if '*assert*' is\n false.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4837), lang.NewKeyword("end-line"), int(4837))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("*assert*")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + if lang.IsTruthy(v9) { + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("seq")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("concat")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("list")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{lang.NewSymbol("glojure.core/when-not")}) + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("list")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.Apply(v22, []any{v5}) + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("list")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("seq")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("concat")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("list")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.Apply(v35, []any{lang.NewSymbol("throw")}) + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("list")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("seq")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v44 := v43.FindInternedVar(lang.NewSymbol("concat")) + if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) + } + v45 := v44.Get() + v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v47 := v46.FindInternedVar(lang.NewSymbol("list")) + if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) + } + v48 := v47.Get() + v49 := lang.Apply(v48, []any{lang.NewSymbol("new")}) + v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v51 := v50.FindInternedVar(lang.NewSymbol("list")) + if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) + } + v52 := v51.Get() + v53 := lang.Apply(v52, []any{lang.NewSymbol("glojure.core/AssertionError")}) + v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v55 := v54.FindInternedVar(lang.NewSymbol("list")) + if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) + } + v56 := v55.Get() + v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v58 := v57.FindInternedVar(lang.NewSymbol("seq")) + if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) + } + v59 := v58.Get() + v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v61 := v60.FindInternedVar(lang.NewSymbol("concat")) + if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) + } + v62 := v61.Get() + v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v64 := v63.FindInternedVar(lang.NewSymbol("list")) + if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) + } + v65 := v64.Get() + v66 := lang.Apply(v65, []any{lang.NewSymbol("glojure.core/str")}) + v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v68 := v67.FindInternedVar(lang.NewSymbol("list")) + if v68.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) + } + v69 := v68.Get() + v70 := lang.Apply(v69, []any{"Assert failed: "}) + v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v72 := v71.FindInternedVar(lang.NewSymbol("list")) + if v72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) + } + v73 := v72.Get() + v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v75 := v74.FindInternedVar(lang.NewSymbol("seq")) + if v75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) + } + v76 := v75.Get() + v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v78 := v77.FindInternedVar(lang.NewSymbol("concat")) + if v78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) + } + v79 := v78.Get() + v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v81 := v80.FindInternedVar(lang.NewSymbol("list")) + if v81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) + } + v82 := v81.Get() + v83 := lang.Apply(v82, []any{lang.NewSymbol("glojure.core/pr-str")}) + v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v85 := v84.FindInternedVar(lang.NewSymbol("list")) + if v85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) + } + v86 := v85.Get() + v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v88 := v87.FindInternedVar(lang.NewSymbol("seq")) + if v88.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) + } + v89 := v88.Get() + v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v91 := v90.FindInternedVar(lang.NewSymbol("concat")) + if v91.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) + } + v92 := v91.Get() + v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v94 := v93.FindInternedVar(lang.NewSymbol("list")) + if v94.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) + } + v95 := v94.Get() + v96 := lang.Apply(v95, []any{lang.NewSymbol("quote")}) + v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v98 := v97.FindInternedVar(lang.NewSymbol("list")) + if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) + } + v99 := v98.Get() + v100 := lang.Apply(v99, []any{v5}) + v101 := lang.Apply(v92, []any{v96, v100}) + v102 := lang.Apply(v89, []any{v101}) + v103 := lang.Apply(v86, []any{v102}) + v104 := lang.Apply(v79, []any{v83, v103}) + v105 := lang.Apply(v76, []any{v104}) + v106 := lang.Apply(v73, []any{v105}) + v107 := lang.Apply(v62, []any{v66, v70, v106}) + v108 := lang.Apply(v59, []any{v107}) + v109 := lang.Apply(v56, []any{v108}) + v110 := lang.Apply(v45, []any{v49, v53, v109}) + v111 := lang.Apply(v42, []any{v110}) + v112 := lang.Apply(v39, []any{v111}) + v113 := lang.Apply(v32, []any{v36, v112}) + v114 := lang.Apply(v29, []any{v113}) + v115 := lang.Apply(v26, []any{v114}) + v116 := lang.Apply(v15, []any{v19, v23, v115}) + v117 := lang.Apply(v12, []any{v116}) + v6 = v117 + } else { + v6 = nil + } + return v6 + case 4: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + var v7 any + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("*assert*")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + if lang.IsTruthy(v10) { + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("seq")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("concat")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("list")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.Apply(v19, []any{lang.NewSymbol("glojure.core/when-not")}) + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("list")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.Apply(v23, []any{v5}) + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("list")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("seq")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("concat")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("list")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.Apply(v36, []any{lang.NewSymbol("throw")}) + v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v39 := v38.FindInternedVar(lang.NewSymbol("list")) + if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + } + v40 := v39.Get() + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("seq")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("concat")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v48 := v47.FindInternedVar(lang.NewSymbol("list")) + if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) + } + v49 := v48.Get() + v50 := lang.Apply(v49, []any{lang.NewSymbol("new")}) + v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v52 := v51.FindInternedVar(lang.NewSymbol("list")) + if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) + } + v53 := v52.Get() + v54 := lang.Apply(v53, []any{lang.NewSymbol("glojure.core/AssertionError")}) + v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v56 := v55.FindInternedVar(lang.NewSymbol("list")) + if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) + } + v57 := v56.Get() + v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v59 := v58.FindInternedVar(lang.NewSymbol("seq")) + if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) + } + v60 := v59.Get() + v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v62 := v61.FindInternedVar(lang.NewSymbol("concat")) + if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) + } + v63 := v62.Get() + v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v65 := v64.FindInternedVar(lang.NewSymbol("list")) + if v65.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) + } + v66 := v65.Get() + v67 := lang.Apply(v66, []any{lang.NewSymbol("glojure.core/str")}) + v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v69 := v68.FindInternedVar(lang.NewSymbol("list")) + if v69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) + } + v70 := v69.Get() + v71 := lang.Apply(v70, []any{"Assert failed: "}) + v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v73 := v72.FindInternedVar(lang.NewSymbol("list")) + if v73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) + } + v74 := v73.Get() + v75 := lang.Apply(v74, []any{v6}) + v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v77 := v76.FindInternedVar(lang.NewSymbol("list")) + if v77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) + } + v78 := v77.Get() + v79 := lang.Apply(v78, []any{"\n"}) + v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v81 := v80.FindInternedVar(lang.NewSymbol("list")) + if v81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) + } + v82 := v81.Get() + v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v84 := v83.FindInternedVar(lang.NewSymbol("seq")) + if v84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) + } + v85 := v84.Get() + v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v87 := v86.FindInternedVar(lang.NewSymbol("concat")) + if v87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) + } + v88 := v87.Get() + v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v90 := v89.FindInternedVar(lang.NewSymbol("list")) + if v90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) + } + v91 := v90.Get() + v92 := lang.Apply(v91, []any{lang.NewSymbol("glojure.core/pr-str")}) + v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v94 := v93.FindInternedVar(lang.NewSymbol("list")) + if v94.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) + } + v95 := v94.Get() + v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v97 := v96.FindInternedVar(lang.NewSymbol("seq")) + if v97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) + } + v98 := v97.Get() + v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v100 := v99.FindInternedVar(lang.NewSymbol("concat")) + if v100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) + } + v101 := v100.Get() + v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v103 := v102.FindInternedVar(lang.NewSymbol("list")) + if v103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) + } + v104 := v103.Get() + v105 := lang.Apply(v104, []any{lang.NewSymbol("quote")}) + v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v107 := v106.FindInternedVar(lang.NewSymbol("list")) + if v107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) + } + v108 := v107.Get() + v109 := lang.Apply(v108, []any{v5}) + v110 := lang.Apply(v101, []any{v105, v109}) + v111 := lang.Apply(v98, []any{v110}) + v112 := lang.Apply(v95, []any{v111}) + v113 := lang.Apply(v88, []any{v92, v112}) + v114 := lang.Apply(v85, []any{v113}) + v115 := lang.Apply(v82, []any{v114}) + v116 := lang.Apply(v63, []any{v67, v71, v75, v79, v115}) + v117 := lang.Apply(v60, []any{v116}) + v118 := lang.Apply(v57, []any{v117}) + v119 := lang.Apply(v46, []any{v50, v54, v118}) + v120 := lang.Apply(v43, []any{v119}) + v121 := lang.Apply(v40, []any{v120}) + v122 := lang.Apply(v33, []any{v37, v121}) + v123 := lang.Apply(v30, []any{v122}) + v124 := lang.Apply(v27, []any{v123}) + v125 := lang.Apply(v16, []any{v20, v24, v124}) + v126 := lang.Apply(v13, []any{v125}) + v7 = v126 + } else { + v7 = nil + } + return v7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // assert-args + { + v0 := lang.NewSymbol("assert-args").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("pairs"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(38), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1830), lang.NewKeyword("end-line"), int(1830), lang.NewKeyword("private"), true)).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.NewList(args[2:]...) + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("seq")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("concat")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("list")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.Apply(v14, []any{lang.NewSymbol("do")}) + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("list")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("seq")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("concat")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("list")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.Apply(v27, []any{lang.NewSymbol("glojure.core/when-not")}) + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("list")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("first")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{v5}) + v36 := lang.Apply(v31, []any{v35}) + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("list")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("seq")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v44 := v43.FindInternedVar(lang.NewSymbol("concat")) + if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) + } + v45 := v44.Get() + v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v47 := v46.FindInternedVar(lang.NewSymbol("list")) + if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) + } + v48 := v47.Get() + v49 := lang.Apply(v48, []any{lang.NewSymbol("throw")}) + v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v51 := v50.FindInternedVar(lang.NewSymbol("list")) + if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) + } + v52 := v51.Get() + v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v54 := v53.FindInternedVar(lang.NewSymbol("seq")) + if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) + } + v55 := v54.Get() + v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v57 := v56.FindInternedVar(lang.NewSymbol("concat")) + if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) + } + v58 := v57.Get() + v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v60 := v59.FindInternedVar(lang.NewSymbol("list")) + if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) + } + v61 := v60.Get() + v62 := lang.Apply(v61, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewIllegalArgumentError")}) + v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v64 := v63.FindInternedVar(lang.NewSymbol("list")) + if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) + } + v65 := v64.Get() + v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v67 := v66.FindInternedVar(lang.NewSymbol("seq")) + if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) + } + v68 := v67.Get() + v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v70 := v69.FindInternedVar(lang.NewSymbol("concat")) + if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) + } + v71 := v70.Get() + v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v73 := v72.FindInternedVar(lang.NewSymbol("list")) + if v73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) + } + v74 := v73.Get() + v75 := lang.Apply(v74, []any{lang.NewSymbol("glojure.core/str")}) + v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v77 := v76.FindInternedVar(lang.NewSymbol("list")) + if v77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) + } + v78 := v77.Get() + v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v80 := v79.FindInternedVar(lang.NewSymbol("seq")) + if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) + } + v81 := v80.Get() + v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v83 := v82.FindInternedVar(lang.NewSymbol("concat")) + if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) + } + v84 := v83.Get() + v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v86 := v85.FindInternedVar(lang.NewSymbol("list")) + if v86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) + } + v87 := v86.Get() + v88 := lang.Apply(v87, []any{lang.NewSymbol("glojure.core/first")}) + v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v90 := v89.FindInternedVar(lang.NewSymbol("list")) + if v90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) + } + v91 := v90.Get() + v92 := lang.Apply(v91, []any{lang.NewSymbol("&form")}) + v93 := lang.Apply(v84, []any{v88, v92}) + v94 := lang.Apply(v81, []any{v93}) + v95 := lang.Apply(v78, []any{v94}) + v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v97 := v96.FindInternedVar(lang.NewSymbol("list")) + if v97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) + } + v98 := v97.Get() + v99 := lang.Apply(v98, []any{" requires "}) + v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v101 := v100.FindInternedVar(lang.NewSymbol("list")) + if v101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) + } + v102 := v101.Get() + v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v104 := v103.FindInternedVar(lang.NewSymbol("second")) + if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) + } + v105 := v104.Get() + v106 := lang.Apply(v105, []any{v5}) + v107 := lang.Apply(v102, []any{v106}) + v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v109 := v108.FindInternedVar(lang.NewSymbol("list")) + if v109.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) + } + v110 := v109.Get() + v111 := lang.Apply(v110, []any{" in "}) + v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v113 := v112.FindInternedVar(lang.NewSymbol("list")) + if v113.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) + } + v114 := v113.Get() + v115 := lang.Apply(v114, []any{lang.NewSymbol("*ns*")}) + v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v117 := v116.FindInternedVar(lang.NewSymbol("list")) + if v117.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) + } + v118 := v117.Get() + v119 := lang.Apply(v118, []any{":"}) + v120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v121 := v120.FindInternedVar(lang.NewSymbol("list")) + if v121.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v121))) + } + v122 := v121.Get() + v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v124 := v123.FindInternedVar(lang.NewSymbol("seq")) + if v124.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) + } + v125 := v124.Get() + v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v127 := v126.FindInternedVar(lang.NewSymbol("concat")) + if v127.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) + } + v128 := v127.Get() + v129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v130 := v129.FindInternedVar(lang.NewSymbol("list")) + if v130.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v130))) + } + v131 := v130.Get() + v132 := lang.Apply(v131, []any{lang.NewKeyword("line")}) + v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v134 := v133.FindInternedVar(lang.NewSymbol("list")) + if v134.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) + } + v135 := v134.Get() + v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v137 := v136.FindInternedVar(lang.NewSymbol("seq")) + if v137.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) + } + v138 := v137.Get() + v139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v140 := v139.FindInternedVar(lang.NewSymbol("concat")) + if v140.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v140))) + } + v141 := v140.Get() + v142 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v143 := v142.FindInternedVar(lang.NewSymbol("list")) + if v143.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v143))) + } + v144 := v143.Get() + v145 := lang.Apply(v144, []any{lang.NewSymbol("glojure.core/meta")}) + v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v147 := v146.FindInternedVar(lang.NewSymbol("list")) + if v147.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) + } + v148 := v147.Get() + v149 := lang.Apply(v148, []any{lang.NewSymbol("&form")}) + v150 := lang.Apply(v141, []any{v145, v149}) + v151 := lang.Apply(v138, []any{v150}) + v152 := lang.Apply(v135, []any{v151}) + v153 := lang.Apply(v128, []any{v132, v152}) + v154 := lang.Apply(v125, []any{v153}) + v155 := lang.Apply(v122, []any{v154}) + v156 := lang.Apply(v71, []any{v75, v95, v99, v107, v111, v115, v119, v155}) + v157 := lang.Apply(v68, []any{v156}) + v158 := lang.Apply(v65, []any{v157}) + v159 := lang.Apply(v58, []any{v62, v158}) + v160 := lang.Apply(v55, []any{v159}) + v161 := lang.Apply(v52, []any{v160}) + v162 := lang.Apply(v45, []any{v49, v161}) + v163 := lang.Apply(v42, []any{v162}) + v164 := lang.Apply(v39, []any{v163}) + v165 := lang.Apply(v24, []any{v28, v36, v164}) + v166 := lang.Apply(v21, []any{v165}) + v167 := lang.Apply(v18, []any{v166}) + v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v169 := v168.FindInternedVar(lang.NewSymbol("list")) + if v169.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) + } + v170 := v169.Get() + var v171 any + { // let + // let binding "more" + v172 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v173 := v172.FindInternedVar(lang.NewSymbol("nnext")) + if v173.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v173))) + } + v174 := v173.Get() + v175 := lang.Apply(v174, []any{v5}) + var v176 any = v175 + _ = v176 + var v177 any + if lang.IsTruthy(v176) { + v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v179 := v178.FindInternedVar(lang.NewSymbol("list*")) + if v179.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) + } + v180 := v179.Get() + v181 := lang.Apply(v180, []any{lang.NewSymbol("glojure.core/assert-args"), v176}) + v177 = v181 + } else { + v177 = nil + } + v171 = v177 + } // end let + v172 := lang.Apply(v170, []any{v171}) + v173 := lang.Apply(v11, []any{v15, v167, v172}) + v174 := lang.Apply(v8, []any{v173}) + return v174 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // assert-valid-fdecl + { + v0 := lang.NewSymbol("assert-valid-fdecl").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fdecl"))), lang.NewKeyword("doc"), "A good fdecl looks like (([a] ...) ([a b] ...)) near the end of defn.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(42), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(7502), lang.NewKeyword("end-line"), int(7502), lang.NewKeyword("private"), true, lang.NewKeyword("dynamic"), true)).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("empty?")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v3}) + if lang.IsTruthy(v8) { + v9 := lang.Apply(lang.NewIllegalArgumentError, []any{"Parameter declaration missing"}) + panic(v9) + } else { + v4 = nil + } + _ = v4 + var v10 any + { // let + // let binding "argdecls" + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("map")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + var v14 lang.FnFunc + v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v15 := args[0] + _ = v15 + var v16 any + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("seq?")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.Apply(v19, []any{v15}) + if lang.IsTruthy(v20) { + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("first")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.Apply(v23, []any{v15}) + v16 = v24 + } else { + var v25 any + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("seq?")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("first")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.Apply(v31, []any{v3}) + v33 := lang.Apply(v28, []any{v32}) + if lang.IsTruthy(v33) { + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("str")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.Apply(v36, []any{"Invalid signature \"", v15, "\" should be a list"}) + v25 = v37 + } else { + v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v39 := v38.FindInternedVar(lang.NewSymbol("str")) + if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + } + v40 := v39.Get() + v41 := lang.Apply(v40, []any{"Parameter declaration \"", v15, "\" should be a vector"}) + v25 = v41 + } + v42 := lang.Apply(lang.NewIllegalArgumentError, []any{v25}) + panic(v42) + } + return v16 + }) + v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7508), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7517), lang.NewKeyword("end-column"), int(59)) + v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v17 := lang.Apply(v13, []any{v16, v3}) + var v18 any = v17 + _ = v18 + // let binding "bad-args" + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("seq")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("remove")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + var v25 lang.FnFunc + v25 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v26 := args[0] + _ = v26 + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("vector?")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{v26}) + return v30 + }) + v26 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7519), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(7519), lang.NewKeyword("end-column"), int(42)) + v27, err := lang.WithMeta(v25, v26.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v28 := lang.Apply(v24, []any{v27, v18}) + v29 := lang.Apply(v21, []any{v28}) + var v30 any = v29 + _ = v30 + var v31 any + if lang.IsTruthy(v30) { + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("str")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v36 := v35.FindInternedVar(lang.NewSymbol("first")) + if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + } + v37 := v36.Get() + v38 := lang.Apply(v37, []any{v30}) + v39 := lang.Apply(v34, []any{"Parameter declaration \"", v38, "\" should be a vector"}) + v40 := lang.Apply(lang.NewIllegalArgumentError, []any{v39}) + panic(v40) + } else { + v31 = nil + } + v10 = v31 + } // end let + return v10 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // assoc + { + v0 := lang.NewSymbol("assoc").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"), lang.NewSymbol("val"), lang.NewSymbol("&"), lang.NewSymbol("kvs"))), lang.NewKeyword("doc"), "assoc[iate]. When applied to a map, returns a new map of the\n same (hashed/sorted) type, that contains the mapping of key(s) to\n val(s). When applied to a vector, returns a new vector that\n contains val at index. Note - index must be <= (count vector).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(181), lang.NewKeyword("end-line"), int(188))).(*lang.Symbol) + var v2 lang.FnFunc + { // function assoc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := args[2] + _ = v6 + v7 := lang.Apply(lang.Assoc, []any{v4, v5, v6}) + return v7 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := args[2] + _ = v6 + v7 := lang.NewList(args[3:]...) + recur_loop_24: + var v8 any + { // let + // let binding "ret" + v9 := lang.Apply(lang.Assoc, []any{v4, v5, v6}) + var v10 any = v9 + _ = v10 + var v11 any + if lang.IsTruthy(v7) { + var v12 any + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("next")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{v7}) + if lang.IsTruthy(v16) { + var v17 any = v10 + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("first")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{v7}) + var v18 any = v22 + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("second")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.Apply(v26, []any{v7}) + var v23 any = v27 + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("nnext")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.Apply(v31, []any{v7}) + var v28 any = v32 + v4 = v17 + v5 = v18 + v6 = v23 + v7 = v28 + goto recur_loop_24 + } else { + v33 := lang.Apply(lang.NewIllegalArgumentError, []any{"assoc expects even number of arguments after map/vector, found odd number"}) + panic(v33) + } + v11 = v12 + } else { + v11 = v10 + } + v8 = v11 + } // end let + return v8 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(189), lang.NewKeyword("column"), int(2), lang.NewKeyword("end-line"), int(198), lang.NewKeyword("end-column"), int(15))).(lang.FnFunc) + v3 := v2 + _ = v3 + } + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // assoc! + { + v0 := lang.NewSymbol("assoc!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("key"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("key"), lang.NewSymbol("val"), lang.NewSymbol("&"), lang.NewSymbol("kvs"))), lang.NewKeyword("doc"), "When applied to a transient map, adds mapping of key(s) to\n val(s). When applied to a transient vector, sets the val at index.\n Note - index must be <= (count vector). Returns coll.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3369), lang.NewKeyword("end-line"), int(3369))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6, _ := lang.FieldOrMethod(v3, "Assoc") + if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Assoc is not a function"))) + } + v7 := lang.Apply(v6, []any{v4, v5}) + return v7 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + recur_loop_609: + var v7 any + { // let + // let binding "ret" + v8, _ := lang.FieldOrMethod(v3, "Assoc") + if reflect.TypeOf(v8).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Assoc is not a function"))) + } + v9 := lang.Apply(v8, []any{v4, v5}) + var v10 any = v9 + _ = v10 + var v11 any + if lang.IsTruthy(v6) { + var v12 any = v10 + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("first")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{v6}) + var v13 any = v17 + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("second")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{v6}) + var v18 any = v22 + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("nnext")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.Apply(v26, []any{v6}) + var v23 any = v27 + v3 = v12 + v4 = v13 + v5 = v18 + v6 = v23 + goto recur_loop_609 + } else { + v11 = v10 + } + v7 = v11 + } // end let + return v7 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // assoc-in + { + v0 := lang.NewSymbol("assoc-in").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("&"), lang.NewSymbol("ks")), lang.NewSymbol("v"))), lang.NewKeyword("doc"), "Associates a value in a nested associative structure, where ks is a\n sequence of keys and v is the new value and returns a new nested structure.\n If any levels do not exist, hash-maps will be created.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6147), lang.NewKeyword("end-line"), int(6147))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any + { // let + // let binding "vec__138" + var v7 any = v4 + _ = v7 + // let binding "seq__139" + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("seq")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v7}) + var v12 any = v11 + _ = v12 + // let binding "first__140" + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("first")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{v12}) + var v17 any = v16 + _ = v17 + // let binding "seq__139" + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("next")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.Apply(v20, []any{v12}) + var v22 any = v21 + _ = v22 + // let binding "k" + var v23 any = v17 + _ = v23 + // let binding "ks" + var v24 any = v22 + _ = v24 + var v25 any + if lang.IsTruthy(v24) { + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("assoc")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("assoc-in")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("get")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{v3, v23}) + v36 := lang.Apply(v31, []any{v35, v24, v5}) + v37 := lang.Apply(v28, []any{v3, v23, v36}) + v25 = v37 + } else { + v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v39 := v38.FindInternedVar(lang.NewSymbol("assoc")) + if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + } + v40 := v39.Get() + v41 := lang.Apply(v40, []any{v3, v23, v5}) + v25 = v41 + } + v6 = v25 + } // end let + return v6 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // associative? + { + v0 := lang.NewSymbol("associative?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements Associative", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6223), lang.NewKeyword("end-line"), int(6223))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.Apply(v6, []any{nil, v3}) + return v7 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // atom + { + v0 := lang.NewSymbol("atom").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Creates and returns an Atom with an initial value of x and zero or\n more options (in any order):\n\n :meta metadata-map\n\n :validator validate-fn\n\n If metadata-map is supplied, it will become the metadata on the\n atom. validate-fn must be nil or a side-effect-free fn of one\n argument, which will be passed the intended new state on any state\n change. If the new state is unacceptable, the validate-fn should\n return false or throw an exception.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2325), lang.NewKeyword("end-line"), int(2325))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + v4 := lang.Apply(lang.NewAtom, []any{v3}) + return v4 + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.NewList(args[1:]...) + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("setup-reference")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("atom")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v3}) + v12 := lang.Apply(v7, []any{v11, v4}) + return v12 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // await + { + v0 := lang.NewSymbol("await").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("agents"))), lang.NewKeyword("doc"), "Blocks the current thread (indefinitely!) until all actions\n dispatched thus far, from this thread or agent, to the agent(s) have\n occurred. Will block on failed agents. Will never return if\n a failed agent is restarted with :clear-actions true or shutdown-agents was called.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3267), lang.NewKeyword("end-line"), int(3267))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := lang.NewList(args[0:]...) + var v4 any + v5 := lang.Apply(nil, nil) + if lang.IsTruthy(v5) { + panic("unimplemented: new with non-constant class type") + } else { + var v6 any + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("*agent*")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + if lang.IsTruthy(v9) { + v10 := lang.Apply(errors5.New, []any{"Can't await in agent action"}) + panic(v10) + } else { + v6 = nil + } + _ = v6 + var v11 any + { // let + // let binding "latch" + var v12 any = "unimplemented: new with non-constant class type" + _ = v12 + // let binding "count-down" + var v13 lang.FnFunc + v13 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v14 := args[0] + _ = v14 + v15, _ := lang.FieldOrMethod(v12, "countDown") + if reflect.TypeOf(v15).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("countDown is not a function"))) + } + v16 := lang.Apply(v15, []any{}) + _ = v16 + return v14 + }) + v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3279), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(3279), lang.NewKeyword("end-column"), int(61)) + v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v16 any = v15 + _ = v16 + var v17 any + { // let + // let binding "seq_1" + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("seq")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.Apply(v20, []any{v3}) + var v22 any = v21 + _ = v22 + // let binding "chunk_2" + var v23 any = nil + _ = v23 + // let binding "count_3" + var v24 any = int64(0) + _ = v24 + // let binding "i_4" + var v25 any = int64(0) + _ = v25 + for { + var v26 any + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("<")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{v25, v24}) + if lang.IsTruthy(v30) { + var v31 any + { // let + // let binding "agent" + v32, _ := lang.FieldOrMethod(v23, "nth") + if reflect.TypeOf(v32).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + v33 := lang.Apply(v32, []any{v25}) + var v34 any = v33 + _ = v34 + v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v36 := v35.FindInternedVar(lang.NewSymbol("send")) + if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + } + v37 := v36.Get() + v38 := lang.Apply(v37, []any{v34, v16}) + _ = v38 + var v39 any = v22 + var v40 any = v23 + var v41 any = v24 + v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v44 := v43.FindInternedVar(lang.NewSymbol("unchecked-inc")) + if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) + } + v45 := v44.Get() + v46 := lang.Apply(v45, []any{v25}) + var v42 any = v46 + v22 = v39 + v23 = v40 + v24 = v41 + v25 = v42 + continue + } // end let + v26 = v31 + } else { + var v32 any + { // let + // let binding "temp__0__auto__" + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("seq")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.Apply(v35, []any{v22}) + var v37 any = v36 + _ = v37 + var v38 any + if lang.IsTruthy(v37) { + var v39 any + { // let + // let binding "seq_1" + var v40 any = v37 + _ = v40 + var v41 any + v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v43 := v42.FindInternedVar(lang.NewSymbol("chunked-seq?")) + if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) + } + v44 := v43.Get() + v45 := lang.Apply(v44, []any{v40}) + if lang.IsTruthy(v45) { + var v46 any + { // let + // let binding "c__0__auto__" + v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v48 := v47.FindInternedVar(lang.NewSymbol("chunk-first")) + if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) + } + v49 := v48.Get() + v50 := lang.Apply(v49, []any{v40}) + var v51 any = v50 + _ = v51 + v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v54 := v53.FindInternedVar(lang.NewSymbol("chunk-rest")) + if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) + } + v55 := v54.Get() + v56 := lang.Apply(v55, []any{v40}) + var v52 any = v56 + var v57 any = v51 + v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v60 := v59.FindInternedVar(lang.NewSymbol("int")) + if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) + } + v61 := v60.Get() + v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v63 := v62.FindInternedVar(lang.NewSymbol("count")) + if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) + } + v64 := v63.Get() + v65 := lang.Apply(v64, []any{v51}) + v66 := lang.Apply(v61, []any{v65}) + var v58 any = v66 + v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v69 := v68.FindInternedVar(lang.NewSymbol("int")) + if v69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) + } + v70 := v69.Get() + v71 := lang.Apply(v70, []any{int64(0)}) + var v67 any = v71 + v22 = v52 + v23 = v57 + v24 = v58 + v25 = v67 + continue + } // end let + v41 = v46 + } else { + var v47 any + { // let + // let binding "agent" + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("first")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v40}) + var v52 any = v51 + _ = v52 + v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v54 := v53.FindInternedVar(lang.NewSymbol("send")) + if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) + } + v55 := v54.Get() + v56 := lang.Apply(v55, []any{v52, v16}) + _ = v56 + v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v59 := v58.FindInternedVar(lang.NewSymbol("next")) + if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) + } + v60 := v59.Get() + v61 := lang.Apply(v60, []any{v40}) + var v57 any = v61 + var v62 any = nil + var v63 any = int64(0) + var v64 any = int64(0) + v22 = v57 + v23 = v62 + v24 = v63 + v25 = v64 + continue + } // end let + v41 = v47 + } + v39 = v41 + } // end let + v38 = v39 + } else { + v38 = nil + } + v32 = v38 + } // end let + v26 = v32 + } + v17 = v26 + break + } + } // end let + _ = v17 + v18, _ := lang.FieldOrMethod(v12, "await") + if reflect.TypeOf(v18).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) + } + v19 := lang.Apply(v18, []any{}) + v11 = v19 + } // end let + v4 = v11 + } + return v4 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // await-for + { + v0 := lang.NewSymbol("await-for").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("timeout-ms"), lang.NewSymbol("&"), lang.NewSymbol("agents"))), lang.NewKeyword("doc"), "Blocks the current thread until all actions dispatched thus\n far (from this thread or agent) to the agents have occurred, or the\n timeout (in milliseconds) has elapsed. Returns logical false if\n returning due to timeout, logical true otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3289), lang.NewKeyword("end-line"), int(3289))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.NewList(args[1:]...) + var v5 any + v6 := lang.Apply(nil, nil) + if lang.IsTruthy(v6) { + panic("unimplemented: new with non-constant class type") + } else { + var v7 any + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("*agent*")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + if lang.IsTruthy(v10) { + v11 := lang.Apply(errors5.New, []any{"Can't await in agent action"}) + panic(v11) + } else { + v7 = nil + } + _ = v7 + var v12 any + { // let + // let binding "latch" + var v13 any = "unimplemented: new with non-constant class type" + _ = v13 + // let binding "count-down" + var v14 lang.FnFunc + v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v15 := args[0] + _ = v15 + v16, _ := lang.FieldOrMethod(v13, "countDown") + if reflect.TypeOf(v16).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("countDown is not a function"))) + } + v17 := lang.Apply(v16, []any{}) + _ = v17 + return v15 + }) + v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3301), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(3301), lang.NewKeyword("end-column"), int(62)) + v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v17 any = v16 + _ = v17 + var v18 any + { // let + // let binding "seq_5" + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("seq")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{v4}) + var v23 any = v22 + _ = v23 + // let binding "chunk_6" + var v24 any = nil + _ = v24 + // let binding "count_7" + var v25 any = int64(0) + _ = v25 + // let binding "i_8" + var v26 any = int64(0) + _ = v26 + for { + var v27 any + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("<")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.Apply(v30, []any{v26, v25}) + if lang.IsTruthy(v31) { + var v32 any + { // let + // let binding "agent" + v33, _ := lang.FieldOrMethod(v24, "nth") + if reflect.TypeOf(v33).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + v34 := lang.Apply(v33, []any{v26}) + var v35 any = v34 + _ = v35 + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("send")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v38, []any{v35, v17}) + _ = v39 + var v40 any = v23 + var v41 any = v24 + var v42 any = v25 + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("unchecked-inc")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.Apply(v46, []any{v26}) + var v43 any = v47 + v23 = v40 + v24 = v41 + v25 = v42 + v26 = v43 + continue + } // end let + v27 = v32 + } else { + var v33 any + { // let + // let binding "temp__0__auto__" + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("seq")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.Apply(v36, []any{v23}) + var v38 any = v37 + _ = v38 + var v39 any + if lang.IsTruthy(v38) { + var v40 any + { // let + // let binding "seq_5" + var v41 any = v38 + _ = v41 + var v42 any + v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v44 := v43.FindInternedVar(lang.NewSymbol("chunked-seq?")) + if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) + } + v45 := v44.Get() + v46 := lang.Apply(v45, []any{v41}) + if lang.IsTruthy(v46) { + var v47 any + { // let + // let binding "c__0__auto__" + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("chunk-first")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v41}) + var v52 any = v51 + _ = v52 + v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v55 := v54.FindInternedVar(lang.NewSymbol("chunk-rest")) + if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) + } + v56 := v55.Get() + v57 := lang.Apply(v56, []any{v41}) + var v53 any = v57 + var v58 any = v52 + v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v61 := v60.FindInternedVar(lang.NewSymbol("int")) + if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) + } + v62 := v61.Get() + v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v64 := v63.FindInternedVar(lang.NewSymbol("count")) + if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) + } + v65 := v64.Get() + v66 := lang.Apply(v65, []any{v52}) + v67 := lang.Apply(v62, []any{v66}) + var v59 any = v67 + v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v70 := v69.FindInternedVar(lang.NewSymbol("int")) + if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) + } + v71 := v70.Get() + v72 := lang.Apply(v71, []any{int64(0)}) + var v68 any = v72 + v23 = v53 + v24 = v58 + v25 = v59 + v26 = v68 + continue + } // end let + v42 = v47 + } else { + var v48 any + { // let + // let binding "agent" + v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v50 := v49.FindInternedVar(lang.NewSymbol("first")) + if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) + } + v51 := v50.Get() + v52 := lang.Apply(v51, []any{v41}) + var v53 any = v52 + _ = v53 + v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v55 := v54.FindInternedVar(lang.NewSymbol("send")) + if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) + } + v56 := v55.Get() + v57 := lang.Apply(v56, []any{v53, v17}) + _ = v57 + v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v60 := v59.FindInternedVar(lang.NewSymbol("next")) + if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) + } + v61 := v60.Get() + v62 := lang.Apply(v61, []any{v41}) + var v58 any = v62 + var v63 any = nil + var v64 any = int64(0) + var v65 any = int64(0) + v23 = v58 + v24 = v63 + v25 = v64 + v26 = v65 + continue + } // end let + v42 = v48 + } + v40 = v42 + } // end let + v39 = v40 + } else { + v39 = nil + } + v33 = v39 + } // end let + v27 = v33 + } + v18 = v27 + break + } + } // end let + _ = v18 + v19, ok := lang.FieldOrMethod(nil, "MILLISECONDS") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "MILLISECONDS"))) + } + var v20 any + switch reflect.TypeOf(v19).Kind() { + case reflect.Func: + v20 = lang.Apply(v19, nil) + default: + v20 = v19 + } + v21, _ := lang.FieldOrMethod(v13, "await") + if reflect.TypeOf(v21).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) + } + v22 := lang.Apply(v21, []any{v3, v20}) + v12 = v22 + } // end let + v5 = v12 + } + return v5 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // await1 + { + v0 := lang.NewSymbol("await1").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3284), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3284), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("pos?")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8, ok := lang.FieldOrMethod(v3, "getQueueCount") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getQueueCount"))) + } + var v9 any + switch reflect.TypeOf(v8).Kind() { + case reflect.Func: + v9 = lang.Apply(v8, nil) + default: + v9 = v8 + } + v10 := lang.Apply(v7, []any{v9}) + if lang.IsTruthy(v10) { + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("await")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{v3}) + v4 = v14 + } else { + v4 = nil + } + _ = v4 + return v3 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // bases + { + v0 := lang.NewSymbol("bases").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"))), lang.NewKeyword("doc"), "Returns the immediate superclass and direct interfaces of c, if any", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5522), lang.NewKeyword("end-line"), int(5522))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + if lang.IsTruthy(v3) { + var v5 any + { // let + // let binding "i" + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("seq")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{nil}) + var v10 any = v9 + _ = v10 + // let binding "s" + var v11 any = nil + _ = v11 + var v12 any + if lang.IsTruthy(v11) { + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("cons")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{v11, v10}) + v12 = v16 + } else { + v12 = v10 + } + v5 = v12 + } // end let + v4 = v5 + } else { + v4 = nil + } + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // bigdec + { + v1 := reflect.TypeOf((*lang.BigDecimal)(nil)) + v0 := lang.NewSymbol("bigdec").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Coerce to BigDecimal", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3648), lang.NewKeyword("end-line"), int(3648))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + var v5 any + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("decimal?")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{v4}) + if lang.IsTruthy(v9) { + v5 = v4 + } else { + var v10 any + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("float?")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{v4}) + if lang.IsTruthy(v14) { + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("double")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{v4}) + v19 := lang.Apply(lang.NewBigDecimalFromFloat64, []any{v18}) + v10 = v19 + } else { + var v20 any + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("ratio?")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.Apply(v23, []any{v4}) + if lang.IsTruthy(v24) { + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("/")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.Apply(lang.NewBigDecimalFromRatio, []any{v4}) + v29, ok := lang.FieldOrMethod(v4, "denominator") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "denominator"))) + } + var v30 any + switch reflect.TypeOf(v29).Kind() { + case reflect.Func: + v30 = lang.Apply(v29, nil) + default: + v30 = v29 + } + v31 := lang.Apply(v27, []any{v28, v30}) + v20 = v31 + } else { + var v32 any + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("instance?")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.Apply(v35, []any{*lang.BigInt, v4}) + if lang.IsTruthy(v36) { + v37, ok := lang.FieldOrMethod(v4, "toBigDecimal") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "toBigDecimal"))) + } + var v38 any + switch reflect.TypeOf(v37).Kind() { + case reflect.Func: + v38 = lang.Apply(v37, nil) + default: + v38 = v37 + } + v32 = v38 + } else { + var v39 any + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("instance?")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.Apply(v42, []any{*big6.Int, v4}) + if lang.IsTruthy(v43) { + v44 := lang.Apply(lang.NewBigDecimal, []any{v4}) + v39 = v44 + } else { + var v45 any + v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v47 := v46.FindInternedVar(lang.NewSymbol("number?")) + if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) + } + v48 := v47.Get() + v49 := lang.Apply(v48, []any{v4}) + if lang.IsTruthy(v49) { + v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v51 := v50.FindInternedVar(lang.NewSymbol("long")) + if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) + } + v52 := v51.Get() + v53 := lang.Apply(v52, []any{v4}) + v54 := lang.Apply(lang.NewBigDecimalFromInt64, []any{v53}) + v45 = v54 + } else { + var v55 any + if lang.IsTruthy(lang.NewKeyword("else")) { + v56 := lang.Apply(lang.NewBigDecimal, []any{v4}) + v55 = v56 + } else { + v55 = nil + } + v45 = v55 + } + v39 = v45 + } + v32 = v39 + } + v20 = v32 + } + v10 = v20 + } + v5 = v10 + } + return v5 + }) + v4 := reflect.TypeOf((*lang.BigDecimal)(nil)) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // bigint + { + v1 := reflect.TypeOf((*lang.BigInt)(nil)) + v0 := lang.NewSymbol("bigint").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Coerce to BigInt", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3620), lang.NewKeyword("end-line"), int(3620))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + var v5 any + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{*lang.BigInt, v4}) + if lang.IsTruthy(v9) { + v5 = v4 + } else { + var v10 any + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("instance?")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{*big6.Int, v4}) + if lang.IsTruthy(v14) { + v15 := lang.Apply(lang.NewBigIntFromGoBigInt, []any{v4}) + v10 = v15 + } else { + var v16 any + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("decimal?")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.Apply(v19, []any{v4}) + if lang.IsTruthy(v20) { + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("bigint")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24, ok := lang.FieldOrMethod(v4, "toBigInteger") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "toBigInteger"))) + } + var v25 any + switch reflect.TypeOf(v24).Kind() { + case reflect.Func: + v25 = lang.Apply(v24, nil) + default: + v25 = v24 + } + v26 := lang.Apply(v23, []any{v25}) + v16 = v26 + } else { + var v27 any + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("float?")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.Apply(v30, []any{v4}) + if lang.IsTruthy(v31) { + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("bigint")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v36 := v35.FindInternedVar(lang.NewSymbol("double")) + if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + } + v37 := v36.Get() + v38 := lang.Apply(v37, []any{v4}) + v39 := lang.Apply(lang.NewBigDecimalFromFloat64, []any{v38}) + v40 := lang.Apply(v34, []any{v39}) + v27 = v40 + } else { + var v41 any + v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v43 := v42.FindInternedVar(lang.NewSymbol("ratio?")) + if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) + } + v44 := v43.Get() + v45 := lang.Apply(v44, []any{v4}) + if lang.IsTruthy(v45) { + v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v47 := v46.FindInternedVar(lang.NewSymbol("bigint")) + if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) + } + v48 := v47.Get() + v49, ok := lang.FieldOrMethod(v4, "bigIntegerValue") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "bigIntegerValue"))) + } + var v50 any + switch reflect.TypeOf(v49).Kind() { + case reflect.Func: + v50 = lang.Apply(v49, nil) + default: + v50 = v49 + } + v51 := lang.Apply(v48, []any{v50}) + v41 = v51 + } else { + var v52 any + v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v54 := v53.FindInternedVar(lang.NewSymbol("number?")) + if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) + } + v55 := v54.Get() + v56 := lang.Apply(v55, []any{v4}) + if lang.IsTruthy(v56) { + v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v58 := v57.FindInternedVar(lang.NewSymbol("long")) + if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) + } + v59 := v58.Get() + v60 := lang.Apply(v59, []any{v4}) + v61 := lang.Apply(lang.NewBigIntFromInt64, []any{v60}) + v52 = v61 + } else { + var v62 any + if lang.IsTruthy(lang.NewKeyword("else")) { + v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v64 := v63.FindInternedVar(lang.NewSymbol("bigint")) + if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) + } + v65 := v64.Get() + v66 := lang.Apply(lang.NewBigInt, []any{v4}) + v67 := lang.Apply(v65, []any{v66}) + v62 = v67 + } else { + v62 = nil + } + v52 = v62 + } + v41 = v52 + } + v27 = v41 + } + v16 = v27 + } + v10 = v16 + } + v5 = v10 + } + return v5 + }) + v4 := reflect.TypeOf((*lang.BigInt)(nil)) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // biginteger + { + v1 := reflect.TypeOf((*big6.Int)(nil)) + v0 := lang.NewSymbol("biginteger").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Coerce to BigInteger", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3634), lang.NewKeyword("end-line"), int(3634))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + var v5 any + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{*big6.Int, v4}) + if lang.IsTruthy(v9) { + v5 = v4 + } else { + var v10 any + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("instance?")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{*lang.BigInt, v4}) + if lang.IsTruthy(v14) { + v15, ok := lang.FieldOrMethod(v4, "toBigInteger") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "toBigInteger"))) + } + var v16 any + switch reflect.TypeOf(v15).Kind() { + case reflect.Func: + v16 = lang.Apply(v15, nil) + default: + v16 = v15 + } + v10 = v16 + } else { + var v17 any + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("decimal?")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.Apply(v20, []any{v4}) + if lang.IsTruthy(v21) { + v22, ok := lang.FieldOrMethod(v4, "toBigInteger") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "toBigInteger"))) + } + var v23 any + switch reflect.TypeOf(v22).Kind() { + case reflect.Func: + v23 = lang.Apply(v22, nil) + default: + v23 = v22 + } + v17 = v23 + } else { + var v24 any + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("float?")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.Apply(v27, []any{v4}) + if lang.IsTruthy(v28) { + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("double")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.Apply(v31, []any{v4}) + v33 := lang.Apply(lang.NewBigDecimalFromFloat64, []any{v32}) + v34, ok := lang.FieldOrMethod(v33, "toBigInteger") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v33, "toBigInteger"))) + } + var v35 any + switch reflect.TypeOf(v34).Kind() { + case reflect.Func: + v35 = lang.Apply(v34, nil) + default: + v35 = v34 + } + v24 = v35 + } else { + var v36 any + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("ratio?")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.Apply(v39, []any{v4}) + if lang.IsTruthy(v40) { + v41, ok := lang.FieldOrMethod(v4, "bigIntegerValue") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "bigIntegerValue"))) + } + var v42 any + switch reflect.TypeOf(v41).Kind() { + case reflect.Func: + v42 = lang.Apply(v41, nil) + default: + v42 = v41 + } + v36 = v42 + } else { + var v43 any + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("number?")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.Apply(v46, []any{v4}) + if lang.IsTruthy(v47) { + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("long")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v4}) + v52 := lang.Apply(big6.NewInt, []any{v51}) + v43 = v52 + } else { + var v53 any + if lang.IsTruthy(lang.NewKeyword("else")) { + v54 := lang.Apply(lang.NewBigInt, []any{v4}) + v53 = v54 + } else { + v53 = nil + } + v43 = v53 + } + v36 = v43 + } + v24 = v36 + } + v17 = v24 + } + v10 = v17 + } + v5 = v10 + } + return v5 + }) + v4 := reflect.TypeOf((*big6.Int)(nil)) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // binding + { + v0 := lang.NewSymbol("binding").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "binding => var-symbol init-expr\n\n Creates new bindings for the (already-existing) vars, with the\n supplied initial values, executes the exprs in an implicit do, then\n re-establishes the bindings that existed before. The new bindings\n are made in parallel (unlike let); all init-exprs are evaluated\n before the vars are bound to their new values.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1945), lang.NewKeyword("end-line"), int(1945))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + var v7 any + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v5}) + if lang.IsTruthy(v11) { + v7 = nil + } else { + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("str")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("first")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{v3}) + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("meta")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v3}) + v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) + v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) + v28 := lang.Apply(lang.NewIllegalArgumentError, []any{v27}) + panic(v28) + } + _ = v7 + var v29 any + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("even?")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("count")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.Apply(v35, []any{v5}) + v37 := lang.Apply(v32, []any{v36}) + if lang.IsTruthy(v37) { + v29 = nil + } else { + v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v39 := v38.FindInternedVar(lang.NewSymbol("str")) + if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + } + v40 := v39.Get() + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("first")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.Apply(v43, []any{v3}) + v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) + if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) + } + v47 := v46.Get() + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("meta")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v3}) + v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) + v53 := lang.Apply(v40, []any{v44, " requires ", "an even number of forms in binding vector", " in ", v47, ":", v52}) + v54 := lang.Apply(lang.NewIllegalArgumentError, []any{v53}) + panic(v54) + } + _ = v29 + _ = nil + var v55 any + { // let + // let binding "var-ize" + var v56 lang.FnFunc + v56 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v57 := args[0] + _ = v57 + var v58 any + { // let + // let binding "ret" + v59 := lang.NewVector() + v60 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1959), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(1959), lang.NewKeyword("end-column"), int(31)) + v61, err := lang.WithMeta(v59, v60.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v62 any = v61 + _ = v62 + // let binding "vvs" + v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v64 := v63.FindInternedVar(lang.NewSymbol("seq")) + if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) + } + v65 := v64.Get() + v66 := lang.Apply(v65, []any{v57}) + var v67 any = v66 + _ = v67 + for { + var v68 any + if lang.IsTruthy(v67) { + v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v71 := v70.FindInternedVar(lang.NewSymbol("conj")) + if v71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) + } + v72 := v71.Get() + v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v74 := v73.FindInternedVar(lang.NewSymbol("conj")) + if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) + } + v75 := v74.Get() + v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v77 := v76.FindInternedVar(lang.NewSymbol("seq")) + if v77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) + } + v78 := v77.Get() + v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v80 := v79.FindInternedVar(lang.NewSymbol("concat")) + if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) + } + v81 := v80.Get() + v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v83 := v82.FindInternedVar(lang.NewSymbol("list")) + if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) + } + v84 := v83.Get() + v85 := lang.Apply(v84, []any{lang.NewSymbol("var")}) + v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v87 := v86.FindInternedVar(lang.NewSymbol("list")) + if v87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) + } + v88 := v87.Get() + v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v90 := v89.FindInternedVar(lang.NewSymbol("first")) + if v90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) + } + v91 := v90.Get() + v92 := lang.Apply(v91, []any{v67}) + v93 := lang.Apply(v88, []any{v92}) + v94 := lang.Apply(v81, []any{v85, v93}) + v95 := lang.Apply(v78, []any{v94}) + v96 := lang.Apply(v75, []any{v62, v95}) + v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v98 := v97.FindInternedVar(lang.NewSymbol("second")) + if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) + } + v99 := v98.Get() + v100 := lang.Apply(v99, []any{v67}) + v101 := lang.Apply(v72, []any{v96, v100}) + var v69 any = v101 + v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v104 := v103.FindInternedVar(lang.NewSymbol("next")) + if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) + } + v105 := v104.Get() + v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v107 := v106.FindInternedVar(lang.NewSymbol("next")) + if v107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) + } + v108 := v107.Get() + v109 := lang.Apply(v108, []any{v67}) + v110 := lang.Apply(v105, []any{v109}) + var v102 any = v110 + v62 = v69 + v67 = v102 + continue + } else { + v111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v112 := v111.FindInternedVar(lang.NewSymbol("seq")) + if v112.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v112))) + } + v113 := v112.Get() + v114 := lang.Apply(v113, []any{v62}) + v68 = v114 + } + v58 = v68 + break + } + } // end let + return v58 + }) + v57 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1958), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(1963), lang.NewKeyword("end-column"), int(34)) + v58, err := lang.WithMeta(v56, v57.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v59 any = v58 + _ = v59 + v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v61 := v60.FindInternedVar(lang.NewSymbol("seq")) + if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) + } + v62 := v61.Get() + v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v64 := v63.FindInternedVar(lang.NewSymbol("concat")) + if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) + } + v65 := v64.Get() + v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v67 := v66.FindInternedVar(lang.NewSymbol("list")) + if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) + } + v68 := v67.Get() + v69 := lang.Apply(v68, []any{lang.NewSymbol("glojure.core/let")}) + v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v71 := v70.FindInternedVar(lang.NewSymbol("list")) + if v71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) + } + v72 := v71.Get() + v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v74 := v73.FindInternedVar(lang.NewSymbol("apply")) + if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) + } + v75 := v74.Get() + v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v77 := v76.FindInternedVar(lang.NewSymbol("vector")) + if v77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) + } + v78 := v77.Get() + v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v80 := v79.FindInternedVar(lang.NewSymbol("seq")) + if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) + } + v81 := v80.Get() + v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v83 := v82.FindInternedVar(lang.NewSymbol("concat")) + if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) + } + v84 := v83.Get() + v85 := lang.Apply(v84, nil) + v86 := lang.Apply(v81, []any{v85}) + v87 := lang.Apply(v75, []any{v78, v86}) + v88 := lang.Apply(v72, []any{v87}) + v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v90 := v89.FindInternedVar(lang.NewSymbol("list")) + if v90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) + } + v91 := v90.Get() + v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v93 := v92.FindInternedVar(lang.NewSymbol("seq")) + if v93.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) + } + v94 := v93.Get() + v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v96 := v95.FindInternedVar(lang.NewSymbol("concat")) + if v96.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) + } + v97 := v96.Get() + v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v99 := v98.FindInternedVar(lang.NewSymbol("list")) + if v99.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) + } + v100 := v99.Get() + v101 := lang.Apply(v100, []any{lang.NewSymbol("glojure.core/push-thread-bindings")}) + v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v103 := v102.FindInternedVar(lang.NewSymbol("list")) + if v103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) + } + v104 := v103.Get() + v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v106 := v105.FindInternedVar(lang.NewSymbol("seq")) + if v106.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) + } + v107 := v106.Get() + v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v109 := v108.FindInternedVar(lang.NewSymbol("concat")) + if v109.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) + } + v110 := v109.Get() + v111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v112 := v111.FindInternedVar(lang.NewSymbol("list")) + if v112.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v112))) + } + v113 := v112.Get() + v114 := lang.Apply(v113, []any{lang.NewSymbol("glojure.core/hash-map")}) + v115 := lang.Apply(v59, []any{v5}) + v116 := lang.Apply(v110, []any{v114, v115}) + v117 := lang.Apply(v107, []any{v116}) + v118 := lang.Apply(v104, []any{v117}) + v119 := lang.Apply(v97, []any{v101, v118}) + v120 := lang.Apply(v94, []any{v119}) + v121 := lang.Apply(v91, []any{v120}) + v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v123 := v122.FindInternedVar(lang.NewSymbol("list")) + if v123.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) + } + v124 := v123.Get() + v125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v126 := v125.FindInternedVar(lang.NewSymbol("seq")) + if v126.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v126))) + } + v127 := v126.Get() + v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v129 := v128.FindInternedVar(lang.NewSymbol("concat")) + if v129.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v129))) + } + v130 := v129.Get() + v131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v132 := v131.FindInternedVar(lang.NewSymbol("list")) + if v132.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v132))) + } + v133 := v132.Get() + v134 := lang.Apply(v133, []any{lang.NewSymbol("try")}) + v135 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v136 := v135.FindInternedVar(lang.NewSymbol("list")) + if v136.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v136))) + } + v137 := v136.Get() + v138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v139 := v138.FindInternedVar(lang.NewSymbol("seq")) + if v139.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v139))) + } + v140 := v139.Get() + v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v142 := v141.FindInternedVar(lang.NewSymbol("concat")) + if v142.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) + } + v143 := v142.Get() + v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v145 := v144.FindInternedVar(lang.NewSymbol("list")) + if v145.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) + } + v146 := v145.Get() + v147 := lang.Apply(v146, []any{lang.NewSymbol("finally")}) + v148 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v149 := v148.FindInternedVar(lang.NewSymbol("list")) + if v149.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v149))) + } + v150 := v149.Get() + v151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v152 := v151.FindInternedVar(lang.NewSymbol("seq")) + if v152.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v152))) + } + v153 := v152.Get() + v154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v155 := v154.FindInternedVar(lang.NewSymbol("concat")) + if v155.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v155))) + } + v156 := v155.Get() + v157 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v158 := v157.FindInternedVar(lang.NewSymbol("list")) + if v158.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v158))) + } + v159 := v158.Get() + v160 := lang.Apply(v159, []any{lang.NewSymbol("glojure.core/pop-thread-bindings")}) + v161 := lang.Apply(v156, []any{v160}) + v162 := lang.Apply(v153, []any{v161}) + v163 := lang.Apply(v150, []any{v162}) + v164 := lang.Apply(v143, []any{v147, v163}) + v165 := lang.Apply(v140, []any{v164}) + v166 := lang.Apply(v137, []any{v165}) + v167 := lang.Apply(v130, []any{v134, v6, v166}) + v168 := lang.Apply(v127, []any{v167}) + v169 := lang.Apply(v124, []any{v168}) + v170 := lang.Apply(v65, []any{v69, v88, v121, v169}) + v171 := lang.Apply(v62, []any{v170}) + v55 = v171 + } // end let + return v55 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // binding-conveyor-fn + { + v0 := lang.NewSymbol("binding-conveyor-fn").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2020), lang.NewKeyword("end-line"), int(2020), lang.NewKeyword("private"), true)).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + { // let + // let binding "frame" + v5 := lang.Apply(lang.CloneThreadBindingFrame, nil) + var v6 any = v5 + _ = v6 + var v7 lang.FnFunc + v7 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + v8 := lang.Apply(lang.ResetThreadBindingFrame, []any{v6}) + _ = v8 + v9 := lang.Apply(v3, nil) + return v9 + case 1: + v8 := args[0] + _ = v8 + v9 := lang.Apply(lang.ResetThreadBindingFrame, []any{v6}) + _ = v9 + v10 := lang.Apply(v3, []any{v8}) + return v10 + case 2: + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + v10 := lang.Apply(lang.ResetThreadBindingFrame, []any{v6}) + _ = v10 + v11 := lang.Apply(v3, []any{v8, v9}) + return v11 + case 3: + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + v10 := args[2] + _ = v10 + v11 := lang.Apply(lang.ResetThreadBindingFrame, []any{v6}) + _ = v11 + v12 := lang.Apply(v3, []any{v8, v9, v10}) + return v12 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + v10 := args[2] + _ = v10 + v11 := lang.NewList(args[3:]...) + v12 := lang.Apply(lang.ResetThreadBindingFrame, []any{v6}) + _ = v12 + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("apply")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{v3, v8, v9, v10, v11}) + return v16 + } + }) + v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2025), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2040), lang.NewKeyword("end-column"), int(31)) + v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v4 = v9 + } // end let + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // bit-and + { + var v1 lang.FnFunc + v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var v3 any + { // let + // let binding "op" + var v4 any + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + if lang.IsTruthy(v7) { + v4 = closed10 + } else { + v4 = closed10 + } + var v8 any = v4 + _ = v8 + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("seq")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("concat")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("list")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("list")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("list")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("seq")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("concat")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("list")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{v8}) + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("list")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v38, []any{v2}) + v40 := lang.Apply(v31, []any{v35, v39}) + v41 := lang.Apply(v28, []any{v40}) + v42 := lang.Apply(v25, []any{v41}) + v43 := lang.Apply(v14, []any{v18, v22, v42}) + v44 := lang.Apply(v11, []any{v43}) + v3 = v44 + } // end let + return v3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any + { // let + // let binding "op" + var v5 any + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + if lang.IsTruthy(v8) { + v5 = closed10 + } else { + v5 = closed10 + } + var v9 any = v5 + _ = v9 + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("seq")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("concat")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("list")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("list")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("list")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("seq")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("concat")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("list")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.Apply(v35, []any{v9}) + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("list")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.Apply(v39, []any{v2}) + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("list")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.Apply(v43, []any{v3}) + v45 := lang.Apply(v32, []any{v36, v40, v44}) + v46 := lang.Apply(v29, []any{v45}) + v47 := lang.Apply(v26, []any{v46}) + v48 := lang.Apply(v15, []any{v19, v23, v47}) + v49 := lang.Apply(v12, []any{v48}) + v4 = v49 + } // end let + return v4 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := lang.NewList(args[2:]...) + var v5 any + { // let + // let binding "op" + var v6 any + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + if lang.IsTruthy(v9) { + v6 = closed10 + } else { + v6 = closed10 + } + var v10 any = v6 + _ = v10 + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + var v14 lang.FnFunc + v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v15 := args[0] + _ = v15 + v16 := args[1] + _ = v16 + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("seq")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("concat")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("list")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("seq")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("concat")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("list")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.Apply(v42, []any{v10}) + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("list")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.Apply(v46, []any{v15}) + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("list")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v16}) + v52 := lang.Apply(v39, []any{v43, v47, v51}) + v53 := lang.Apply(v36, []any{v52}) + v54 := lang.Apply(v33, []any{v53}) + v55 := lang.Apply(v22, []any{v26, v30, v54}) + v56 := lang.Apply(v19, []any{v55}) + return v56 + }) + v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("seq")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("concat")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("list")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("seq")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("concat")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("list")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.Apply(v42, []any{v10}) + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("list")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.Apply(v46, []any{v2}) + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("list")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v3}) + v52 := lang.Apply(v39, []any{v43, v47, v51}) + v53 := lang.Apply(v36, []any{v52}) + v54 := lang.Apply(v33, []any{v53}) + v55 := lang.Apply(v22, []any{v26, v30, v54}) + v56 := lang.Apply(v19, []any{v55}) + v57 := lang.Apply(v13, []any{v16, v56, v4}) + v5 = v57 + } // end let + return v5 + } + }) + v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + v5 := lang.Apply(v4, []any{nil, int64(1)}) + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v0 := lang.NewSymbol("bit-and").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Bitwise and", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1298), lang.NewKeyword("end-line"), int(1298))).(*lang.Symbol) + var v4 lang.FnFunc + v4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7, _ := lang.FieldOrMethod(lang.Numbers, "And") + if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("And is not a function"))) + } + v8 := lang.Apply(v7, []any{v5, v6}) + return v8 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := lang.NewList(args[2:]...) + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("bit-and")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("bit-and")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{v5, v6}) + v18 := lang.Apply(v10, []any{v13, v17, v7}) + return v18 + } + }) + v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v3 := ns.InternWithValue(v0, v4, true) + if v0.Meta() != nil { + v3.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // bit-and-not + { + var v1 lang.FnFunc + v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var v3 any + { // let + // let binding "op" + var v4 any + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + if lang.IsTruthy(v7) { + v4 = closed11 + } else { + v4 = closed11 + } + var v8 any = v4 + _ = v8 + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("seq")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("concat")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("list")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("list")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("list")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("seq")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("concat")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("list")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{v8}) + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("list")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v38, []any{v2}) + v40 := lang.Apply(v31, []any{v35, v39}) + v41 := lang.Apply(v28, []any{v40}) + v42 := lang.Apply(v25, []any{v41}) + v43 := lang.Apply(v14, []any{v18, v22, v42}) + v44 := lang.Apply(v11, []any{v43}) + v3 = v44 + } // end let + return v3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any + { // let + // let binding "op" + var v5 any + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + if lang.IsTruthy(v8) { + v5 = closed11 + } else { + v5 = closed11 + } + var v9 any = v5 + _ = v9 + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("seq")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("concat")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("list")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("list")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("list")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("seq")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("concat")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("list")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.Apply(v35, []any{v9}) + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("list")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.Apply(v39, []any{v2}) + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("list")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.Apply(v43, []any{v3}) + v45 := lang.Apply(v32, []any{v36, v40, v44}) + v46 := lang.Apply(v29, []any{v45}) + v47 := lang.Apply(v26, []any{v46}) + v48 := lang.Apply(v15, []any{v19, v23, v47}) + v49 := lang.Apply(v12, []any{v48}) + v4 = v49 + } // end let + return v4 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := lang.NewList(args[2:]...) + var v5 any + { // let + // let binding "op" + var v6 any + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + if lang.IsTruthy(v9) { + v6 = closed11 + } else { + v6 = closed11 + } + var v10 any = v6 + _ = v10 + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + var v14 lang.FnFunc + v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v15 := args[0] + _ = v15 + v16 := args[1] + _ = v16 + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("seq")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("concat")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("list")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("seq")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("concat")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("list")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.Apply(v42, []any{v10}) + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("list")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.Apply(v46, []any{v15}) + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("list")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v16}) + v52 := lang.Apply(v39, []any{v43, v47, v51}) + v53 := lang.Apply(v36, []any{v52}) + v54 := lang.Apply(v33, []any{v53}) + v55 := lang.Apply(v22, []any{v26, v30, v54}) + v56 := lang.Apply(v19, []any{v55}) + return v56 + }) + v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("seq")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("concat")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("list")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("seq")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("concat")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("list")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.Apply(v42, []any{v10}) + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("list")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.Apply(v46, []any{v2}) + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("list")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v3}) + v52 := lang.Apply(v39, []any{v43, v47, v51}) + v53 := lang.Apply(v36, []any{v52}) + v54 := lang.Apply(v33, []any{v53}) + v55 := lang.Apply(v22, []any{v26, v30, v54}) + v56 := lang.Apply(v19, []any{v55}) + v57 := lang.Apply(v13, []any{v16, v56, v4}) + v5 = v57 + } // end let + return v5 + } + }) + v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + v5 := lang.Apply(v4, []any{nil, int64(1)}) + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v0 := lang.NewSymbol("bit-and-not").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Bitwise and with complement", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1325), lang.NewKeyword("end-line"), int(1325))).(*lang.Symbol) + var v4 lang.FnFunc + v4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7, _ := lang.FieldOrMethod(lang.Numbers, "AndNot") + if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("AndNot is not a function"))) + } + v8 := lang.Apply(v7, []any{v5, v6}) + return v8 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := lang.NewList(args[2:]...) + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("bit-and-not")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("bit-and-not")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{v5, v6}) + v18 := lang.Apply(v10, []any{v13, v17, v7}) + return v18 + } + }) + v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v3 := ns.InternWithValue(v0, v4, true) + if v0.Meta() != nil { + v3.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // bit-clear + { + v0 := lang.NewSymbol("bit-clear").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Clear bit at index n", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1336), lang.NewKeyword("end-line"), int(1336))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5, _ := lang.FieldOrMethod(lang.Numbers, "ClearBit") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ClearBit is not a function"))) + } + v6 := lang.Apply(v5, []any{v3, v4}) + return v6 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // bit-flip + { + v0 := lang.NewSymbol("bit-flip").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Flip bit at index n", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1348), lang.NewKeyword("end-line"), int(1348))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5, _ := lang.FieldOrMethod(lang.Numbers, "FlipBit") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("FlipBit is not a function"))) + } + v6 := lang.Apply(v5, []any{v3, v4}) + return v6 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // bit-not + { + var v1 lang.FnFunc + { // function bit-not__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("concat")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("list")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("seq")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("concat")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/Not")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{v3}) + v35 := lang.Apply(v26, []any{v30, v34}) + v36 := lang.Apply(v23, []any{v35}) + v37 := lang.Apply(v20, []any{v36}) + v38 := lang.Apply(v9, []any{v13, v17, v37}) + v39 := lang.Apply(v6, []any{v38}) + return v39 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("bit-not").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Bitwise complement", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1291), lang.NewKeyword("end-line"), int(1291))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5, _ := lang.FieldOrMethod(lang.Numbers, "Not") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Not is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // bit-or + { + var v1 lang.FnFunc + v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var v3 any + { // let + // let binding "op" + var v4 any + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + if lang.IsTruthy(v7) { + v4 = closed12 + } else { + v4 = closed12 + } + var v8 any = v4 + _ = v8 + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("seq")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("concat")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("list")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("list")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("list")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("seq")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("concat")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("list")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{v8}) + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("list")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v38, []any{v2}) + v40 := lang.Apply(v31, []any{v35, v39}) + v41 := lang.Apply(v28, []any{v40}) + v42 := lang.Apply(v25, []any{v41}) + v43 := lang.Apply(v14, []any{v18, v22, v42}) + v44 := lang.Apply(v11, []any{v43}) + v3 = v44 + } // end let + return v3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any + { // let + // let binding "op" + var v5 any + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + if lang.IsTruthy(v8) { + v5 = closed12 + } else { + v5 = closed12 + } + var v9 any = v5 + _ = v9 + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("seq")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("concat")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("list")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("list")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("list")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("seq")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("concat")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("list")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.Apply(v35, []any{v9}) + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("list")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.Apply(v39, []any{v2}) + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("list")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.Apply(v43, []any{v3}) + v45 := lang.Apply(v32, []any{v36, v40, v44}) + v46 := lang.Apply(v29, []any{v45}) + v47 := lang.Apply(v26, []any{v46}) + v48 := lang.Apply(v15, []any{v19, v23, v47}) + v49 := lang.Apply(v12, []any{v48}) + v4 = v49 + } // end let + return v4 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := lang.NewList(args[2:]...) + var v5 any + { // let + // let binding "op" + var v6 any + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + if lang.IsTruthy(v9) { + v6 = closed12 + } else { + v6 = closed12 + } + var v10 any = v6 + _ = v10 + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + var v14 lang.FnFunc + v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v15 := args[0] + _ = v15 + v16 := args[1] + _ = v16 + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("seq")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("concat")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("list")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("seq")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("concat")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("list")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.Apply(v42, []any{v10}) + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("list")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.Apply(v46, []any{v15}) + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("list")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v16}) + v52 := lang.Apply(v39, []any{v43, v47, v51}) + v53 := lang.Apply(v36, []any{v52}) + v54 := lang.Apply(v33, []any{v53}) + v55 := lang.Apply(v22, []any{v26, v30, v54}) + v56 := lang.Apply(v19, []any{v55}) + return v56 + }) + v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("seq")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("concat")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("list")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("seq")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("concat")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("list")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.Apply(v42, []any{v10}) + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("list")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.Apply(v46, []any{v2}) + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("list")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v3}) + v52 := lang.Apply(v39, []any{v43, v47, v51}) + v53 := lang.Apply(v36, []any{v52}) + v54 := lang.Apply(v33, []any{v53}) + v55 := lang.Apply(v22, []any{v26, v30, v54}) + v56 := lang.Apply(v19, []any{v55}) + v57 := lang.Apply(v13, []any{v16, v56, v4}) + v5 = v57 + } // end let + return v5 + } + }) + v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + v5 := lang.Apply(v4, []any{nil, int64(1)}) + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v0 := lang.NewSymbol("bit-or").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Bitwise or", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1307), lang.NewKeyword("end-line"), int(1307))).(*lang.Symbol) + var v4 lang.FnFunc + v4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7, _ := lang.FieldOrMethod(lang.Numbers, "Or") + if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Or is not a function"))) + } + v8 := lang.Apply(v7, []any{v5, v6}) + return v8 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := lang.NewList(args[2:]...) + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("bit-or")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("bit-or")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{v5, v6}) + v18 := lang.Apply(v10, []any{v13, v17, v7}) + return v18 + } + }) + v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v3 := ns.InternWithValue(v0, v4, true) + if v0.Meta() != nil { + v3.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // bit-set + { + v0 := lang.NewSymbol("bit-set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Set bit at index n", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1342), lang.NewKeyword("end-line"), int(1342))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5, _ := lang.FieldOrMethod(lang.Numbers, "SetBit") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("SetBit is not a function"))) + } + v6 := lang.Apply(v5, []any{v3, v4}) + return v6 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // bit-shift-left + { + var v1 lang.FnFunc + { // function bit-shift-left__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("seq")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("concat")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("list")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("list")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("list")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("seq")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("concat")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("list")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/ShiftLeft")}) + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("list")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{v3}) + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("list")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v38, []any{v4}) + v40 := lang.Apply(v27, []any{v31, v35, v39}) + v41 := lang.Apply(v24, []any{v40}) + v42 := lang.Apply(v21, []any{v41}) + v43 := lang.Apply(v10, []any{v14, v18, v42}) + v44 := lang.Apply(v7, []any{v43}) + return v44 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("bit-shift-left").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Bitwise shift left", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1361), lang.NewKeyword("end-line"), int(1361))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6, _ := lang.FieldOrMethod(lang.Numbers, "ShiftLeft") + if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ShiftLeft is not a function"))) + } + v7 := lang.Apply(v6, []any{v4, v5}) + return v7 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // bit-shift-right + { + var v1 lang.FnFunc + { // function bit-shift-right__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("seq")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("concat")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("list")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("list")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("list")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("seq")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("concat")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("list")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/ShiftRight")}) + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("list")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{v3}) + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("list")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v38, []any{v4}) + v40 := lang.Apply(v27, []any{v31, v35, v39}) + v41 := lang.Apply(v24, []any{v40}) + v42 := lang.Apply(v21, []any{v41}) + v43 := lang.Apply(v10, []any{v14, v18, v42}) + v44 := lang.Apply(v7, []any{v43}) + return v44 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("bit-shift-right").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Bitwise shift right", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1367), lang.NewKeyword("end-line"), int(1367))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6, _ := lang.FieldOrMethod(lang.Numbers, "ShiftRight") + if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ShiftRight is not a function"))) + } + v7 := lang.Apply(v6, []any{v4, v5}) + return v7 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // bit-test + { + v0 := lang.NewSymbol("bit-test").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Test bit at index n", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1354), lang.NewKeyword("end-line"), int(1354))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5, _ := lang.FieldOrMethod(lang.Numbers, "TestBit") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("TestBit is not a function"))) + } + v6 := lang.Apply(v5, []any{v3, v4}) + return v6 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // bit-xor + { + var v1 lang.FnFunc + v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var v3 any + { // let + // let binding "op" + var v4 any + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + if lang.IsTruthy(v7) { + v4 = closed13 + } else { + v4 = closed13 + } + var v8 any = v4 + _ = v8 + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("seq")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("concat")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("list")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("list")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("list")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("seq")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("concat")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("list")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{v8}) + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("list")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v38, []any{v2}) + v40 := lang.Apply(v31, []any{v35, v39}) + v41 := lang.Apply(v28, []any{v40}) + v42 := lang.Apply(v25, []any{v41}) + v43 := lang.Apply(v14, []any{v18, v22, v42}) + v44 := lang.Apply(v11, []any{v43}) + v3 = v44 + } // end let + return v3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any + { // let + // let binding "op" + var v5 any + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + if lang.IsTruthy(v8) { + v5 = closed13 + } else { + v5 = closed13 + } + var v9 any = v5 + _ = v9 + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("seq")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("concat")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("list")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("list")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("list")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("seq")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("concat")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("list")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.Apply(v35, []any{v9}) + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("list")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.Apply(v39, []any{v2}) + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("list")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.Apply(v43, []any{v3}) + v45 := lang.Apply(v32, []any{v36, v40, v44}) + v46 := lang.Apply(v29, []any{v45}) + v47 := lang.Apply(v26, []any{v46}) + v48 := lang.Apply(v15, []any{v19, v23, v47}) + v49 := lang.Apply(v12, []any{v48}) + v4 = v49 + } // end let + return v4 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := lang.NewList(args[2:]...) + var v5 any + { // let + // let binding "op" + var v6 any + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + if lang.IsTruthy(v9) { + v6 = closed13 + } else { + v6 = closed13 + } + var v10 any = v6 + _ = v10 + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + var v14 lang.FnFunc + v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v15 := args[0] + _ = v15 + v16 := args[1] + _ = v16 + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("seq")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("concat")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("list")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("seq")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("concat")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("list")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.Apply(v42, []any{v10}) + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("list")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.Apply(v46, []any{v15}) + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("list")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v16}) + v52 := lang.Apply(v39, []any{v43, v47, v51}) + v53 := lang.Apply(v36, []any{v52}) + v54 := lang.Apply(v33, []any{v53}) + v55 := lang.Apply(v22, []any{v26, v30, v54}) + v56 := lang.Apply(v19, []any{v55}) + return v56 + }) + v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("seq")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("concat")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("list")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("seq")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("concat")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("list")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.Apply(v42, []any{v10}) + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("list")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.Apply(v46, []any{v2}) + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("list")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v3}) + v52 := lang.Apply(v39, []any{v43, v47, v51}) + v53 := lang.Apply(v36, []any{v52}) + v54 := lang.Apply(v33, []any{v53}) + v55 := lang.Apply(v22, []any{v26, v30, v54}) + v56 := lang.Apply(v19, []any{v55}) + v57 := lang.Apply(v13, []any{v16, v56, v4}) + v5 = v57 + } // end let + return v5 + } + }) + v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + v5 := lang.Apply(v4, []any{nil, int64(1)}) + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v0 := lang.NewSymbol("bit-xor").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Bitwise exclusive or", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1316), lang.NewKeyword("end-line"), int(1316))).(*lang.Symbol) + var v4 lang.FnFunc + v4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7, _ := lang.FieldOrMethod(lang.Numbers, "Xor") + if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Xor is not a function"))) + } + v8 := lang.Apply(v7, []any{v5, v6}) + return v8 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := lang.NewList(args[2:]...) + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("bit-xor")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("bit-xor")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{v5, v6}) + v18 := lang.Apply(v10, []any{v13, v17, v7}) + return v18 + } + }) + v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v3 := ns.InternWithValue(v0, v4, true) + if v0.Meta() != nil { + v3.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // boolean + { + var v1 lang.FnFunc + { // function boolean__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("concat")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("list")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("seq")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("concat")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/BooleanCast")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{v3}) + v35 := lang.Apply(v26, []any{v30, v34}) + v36 := lang.Apply(v23, []any{v35}) + v37 := lang.Apply(v20, []any{v36}) + v38 := lang.Apply(v9, []any{v13, v17, v37}) + v39 := lang.Apply(v6, []any{v38}) + return v39 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("boolean").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to boolean", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1601), lang.NewKeyword("end-line"), int(1601))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5, _ := lang.FieldOrMethod(runtime4.RT, "BooleanCast") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("BooleanCast is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // boolean-array + { + var v1 lang.FnFunc + { // function boolean-array__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := lang.NewList(args[0:]...) + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("concat")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("list")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/BooleanArray")}) + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("list")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("seq")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("concat")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) + v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v36 := v35.FindInternedVar(lang.NewSymbol("list")) + if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + } + v37 := v36.Get() + v38 := lang.Apply(v37, []any{lang.NewSymbol("glojure.core/args")}) + v39 := lang.Apply(v30, []any{v34, v38}) + v40 := lang.Apply(v27, []any{v39}) + v41 := lang.Apply(v24, []any{v40}) + v42 := lang.Apply(v9, []any{v13, v17, v21, v41}) + v43 := lang.Apply(v6, []any{v42}) + return v43 + } + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("boolean-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Creates an array of booleans", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1), int64(2)), lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5309), lang.NewKeyword("end-line"), int(5309))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + v5, _ := lang.FieldOrMethod(lang.Numbers, "BooleanArray") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("BooleanArray is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6, _ := lang.FieldOrMethod(lang.Numbers, "BooleanArrayInit") + if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("BooleanArrayInit is not a function"))) + } + v7 := lang.Apply(v6, []any{v4, v5}) + return v7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // boolean? + { + v0 := lang.NewSymbol("boolean?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a Boolean", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(518), lang.NewKeyword("end-line"), int(518))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.Apply(v6, []any{lang.Builtins["bool"], v3}) + return v7 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // booleans + { + var v1 lang.FnFunc + { // function booleans + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("concat")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("list")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/Booleans")}) + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("list")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v3}) + v26 := lang.Apply(v9, []any{v13, v17, v21, v25}) + v27 := lang.Apply(v6, []any{v26}) + return v27 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("booleans").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Casts to boolean[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5372), lang.NewKeyword("end-line"), int(5372))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5, _ := lang.FieldOrMethod(lang.Numbers, "Booleans") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Booleans is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // bound-fn + { + v0 := lang.NewSymbol("bound-fn").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("fntail"))), lang.NewKeyword("doc"), "Returns a function defined by the given fntail, which will install the\n same bindings in effect as in the thread at the time bound-fn was called.\n This may be used to define a helper function which runs on a different\n thread, but needs the same bindings in place.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(2004), lang.NewKeyword("end-line"), int(2004))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.NewList(args[2:]...) + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("seq")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("concat")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("list")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.Apply(v14, []any{lang.NewSymbol("glojure.core/bound-fn*")}) + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("list")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("seq")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("concat")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("list")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.Apply(v27, []any{lang.NewSymbol("glojure.core/fn")}) + v29 := lang.Apply(v24, []any{v28, v5}) + v30 := lang.Apply(v21, []any{v29}) + v31 := lang.Apply(v18, []any{v30}) + v32 := lang.Apply(v11, []any{v15, v31}) + v33 := lang.Apply(v8, []any{v32}) + return v33 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // bound-fn* + { + v0 := lang.NewSymbol("bound-fn*").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Returns a function, which will install the same bindings in effect as in\n the thread at the time bound-fn* was called and then call f with any given\n arguments. This may be used to define a helper function which runs on a\n different thread, but needs the same bindings in place.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1992), lang.NewKeyword("end-line"), int(1992))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + { // let + // let binding "bindings" + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("get-thread-bindings")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, nil) + var v9 any = v8 + _ = v9 + var v10 lang.FnFunc + v10 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v11 := lang.NewList(args[0:]...) + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("apply")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("with-bindings*")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v14, []any{v17, v9, v3, v11}) + return v18 + } + }) + v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2001), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2002), lang.NewKeyword("end-column"), int(45)) + v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v4 = v12 + } // end let + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // bound? + { + v0 := lang.NewSymbol("bound?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("vars"))), lang.NewKeyword("doc"), "Returns true if all of the vars provided as arguments have any bound value, root or thread-local.\n Implies that deref'ing the provided vars will succeed. Returns true if no vars are provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5491), lang.NewKeyword("end-line"), int(5491))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := lang.NewList(args[0:]...) + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("every?")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + var v7 lang.FnFunc + v7 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v8 := args[0] + _ = v8 + v9, ok := lang.FieldOrMethod(v8, "isBound") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "isBound"))) + } + var v10 any + switch reflect.TypeOf(v9).Kind() { + case reflect.Func: + v10 = lang.Apply(v9, nil) + default: + v10 = v9 + } + return v10 + }) + v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5497), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5497), lang.NewKeyword("end-column"), int(69)) + v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v10 := lang.Apply(v6, []any{v9, v3}) + return v10 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // bounded-count + { + v0 := lang.NewSymbol("bounded-count").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "If coll is counted? returns its count, else will count at most the first n\n elements of coll using its seq", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7410), lang.NewKeyword("end-line"), int(7410))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("counted?")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{v4}) + if lang.IsTruthy(v9) { + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("count")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{v4}) + v5 = v13 + } else { + var v14 any + { // let + // let binding "i" + var v15 any = int64(0) + _ = v15 + // let binding "s" + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("seq")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{v4}) + var v20 any = v19 + _ = v20 + for { + var v21 any + var v22 any + { // let + // let binding "and__0__auto__" + var v23 any = v20 + _ = v23 + var v24 any + if lang.IsTruthy(v23) { + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("<")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.Apply(v27, []any{v15, v3}) + v24 = v28 + } else { + v24 = v23 + } + v22 = v24 + } // end let + if lang.IsTruthy(v22) { + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("inc")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.Apply(v26, []any{v15}) + var v23 any = v27 + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("next")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.Apply(v31, []any{v20}) + var v28 any = v32 + v15 = v23 + v20 = v28 + continue + } else { + v21 = v15 + } + v14 = v21 + break + } + } // end let + v5 = v14 + } + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // butlast + { + v0 := lang.NewSymbol("butlast").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return a seq of all but the last item in coll, in linear time", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(272), lang.NewKeyword("end-line"), int(276))).(*lang.Symbol) + var v2 lang.FnFunc + { // function butlast + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + var v5 any + { // let + // let binding "ret" + v6 := lang.NewVector() + v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(277), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(277), lang.NewKeyword("end-column"), int(24)) + v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v9 any = v8 + _ = v9 + // let binding "s" + var v10 any = v4 + _ = v10 + for { + var v11 any + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("next")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.Apply(v14, []any{v10}) + if lang.IsTruthy(v15) { + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("conj")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("first")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.Apply(v22, []any{v10}) + v24 := lang.Apply(v19, []any{v9, v23}) + var v16 any = v24 + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("next")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.Apply(v28, []any{v10}) + var v25 any = v29 + v9 = v16 + v10 = v25 + continue + } else { + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("seq")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.Apply(v32, []any{v9}) + v11 = v33 + } + v5 = v11 + break + } + } // end let + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(276), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(280), lang.NewKeyword("end-column"), int(27))).(lang.FnFunc) + v3 := v2 + _ = v3 + } + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // byte + { + var v1 lang.FnFunc + { // function byte__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("concat")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("list")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("seq")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("concat")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + var v30 any + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + if lang.IsTruthy(v33) { + v30 = lang.NewSymbol("uncheckedByteCast") + } else { + v30 = lang.NewSymbol("byteCast") + } + v34 := lang.Apply(v29, []any{v30}) + v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v36 := v35.FindInternedVar(lang.NewSymbol("list")) + if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + } + v37 := v36.Get() + v38 := lang.Apply(v37, []any{v3}) + v39 := lang.Apply(v26, []any{v34, v38}) + v40 := lang.Apply(v23, []any{v39}) + v41 := lang.Apply(v20, []any{v40}) + v42 := lang.Apply(v9, []any{v13, v17, v41}) + v43 := lang.Apply(v6, []any{v42}) + return v43 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("byte").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to byte", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3505), lang.NewKeyword("end-line"), int(3505))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := lang.Apply(lang.ByteCast, []any{v4}) + return v5 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // byte-array + { + var v1 lang.FnFunc + { // function byte-array__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := lang.NewList(args[0:]...) + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("concat")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("list")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/ByteArray")}) + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("list")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("seq")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("concat")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) + v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v36 := v35.FindInternedVar(lang.NewSymbol("list")) + if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + } + v37 := v36.Get() + v38 := lang.Apply(v37, []any{lang.NewSymbol("glojure.core/args")}) + v39 := lang.Apply(v30, []any{v34, v38}) + v40 := lang.Apply(v27, []any{v39}) + v41 := lang.Apply(v24, []any{v40}) + v42 := lang.Apply(v9, []any{v13, v17, v21, v41}) + v43 := lang.Apply(v6, []any{v42}) + return v43 + } + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("byte-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Creates an array of bytes", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1), int64(2)), lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5317), lang.NewKeyword("end-line"), int(5317))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + v5, _ := lang.FieldOrMethod(lang.Numbers, "ByteArray") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ByteArray is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6, _ := lang.FieldOrMethod(lang.Numbers, "ByteArrayInit") + if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ByteArrayInit is not a function"))) + } + v7 := lang.Apply(v6, []any{v4, v5}) + return v7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // bytes + { + var v1 lang.FnFunc + { // function bytes + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("concat")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("list")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/Bytes")}) + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("list")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v3}) + v26 := lang.Apply(v9, []any{v13, v17, v21, v25}) + v27 := lang.Apply(v6, []any{v26}) + return v27 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("bytes").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Casts to bytes[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5377), lang.NewKeyword("end-line"), int(5377))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5, _ := lang.FieldOrMethod(lang.Numbers, "Bytes") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Bytes is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // bytes? + { + v0 := lang.NewSymbol("bytes?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a byte array", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5412), lang.NewKeyword("end-line"), int(5412))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("nil?")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v3}) + if lang.IsTruthy(v8) { + v4 = false + } else { + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("=")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("class")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.Apply(v14, []any{v3}) + v16, ok := lang.FieldOrMethod(v15, "getComponentType") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v15, "getComponentType"))) + } + var v17 any + switch reflect.TypeOf(v16).Kind() { + case reflect.Func: + v17 = lang.Apply(v16, nil) + default: + v17 = v16 + } + v18 := lang.Apply(v11, []any{v17, nil}) + v4 = v18 + } + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // case + { + v0 := lang.NewSymbol("case").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("e"), lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes an expression, and a set of clauses.\n\n Each clause can take the form of either:\n\n test-constant result-expr\n\n (test-constant1 ... test-constantN) result-expr\n\n The test-constants are not evaluated. They must be compile-time\n literals, and need not be quoted. If the expression is equal to a\n test-constant, the corresponding result-expr is returned. A single\n default expression can follow the clauses, and its value will be\n returned if no clause matches. If no default expression is provided\n and no clause matches, an IllegalArgumentException is thrown.\n\n Unlike cond and condp, case does a constant-time dispatch, the\n clauses are not considered sequentially. All manner of constant\n expressions are acceptable in case, including numbers, strings,\n symbols, keywords, and (Clojure) composites thereof. Note that since\n lists are used to group multiple constants that map to the same\n expression, a vector can be used to match a list if needed. The\n test-constants need not be all of the same type.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6712), lang.NewKeyword("end-line"), int(6712))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + var v7 any + { // let + // let binding "ge" + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("with-meta")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("gensym")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, nil) + v15 := lang.NewMap(lang.NewKeyword("tag"), lang.Object) + v16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6738), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(6738), lang.NewKeyword("end-column"), int(84)) + v17, err := lang.WithMeta(v15, v16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v18 := lang.Apply(v10, []any{v14, v17}) + var v19 any = v18 + _ = v19 + // let binding "default" + var v20 any + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("odd?")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("count")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.Apply(v26, []any{v6}) + v28 := lang.Apply(v23, []any{v27}) + if lang.IsTruthy(v28) { + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("last")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.Apply(v31, []any{v6}) + v20 = v32 + } else { + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("seq")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("concat")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v40 := v39.FindInternedVar(lang.NewSymbol("list")) + if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) + } + v41 := v40.Get() + v42 := lang.Apply(v41, []any{lang.NewSymbol("throw")}) + v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v44 := v43.FindInternedVar(lang.NewSymbol("list")) + if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) + } + v45 := v44.Get() + v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v47 := v46.FindInternedVar(lang.NewSymbol("seq")) + if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) + } + v48 := v47.Get() + v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v50 := v49.FindInternedVar(lang.NewSymbol("concat")) + if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) + } + v51 := v50.Get() + v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v53 := v52.FindInternedVar(lang.NewSymbol("list")) + if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) + } + v54 := v53.Get() + v55 := lang.Apply(v54, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewIllegalArgumentError")}) + v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v57 := v56.FindInternedVar(lang.NewSymbol("list")) + if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) + } + v58 := v57.Get() + v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v60 := v59.FindInternedVar(lang.NewSymbol("seq")) + if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) + } + v61 := v60.Get() + v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v63 := v62.FindInternedVar(lang.NewSymbol("concat")) + if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) + } + v64 := v63.Get() + v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v66 := v65.FindInternedVar(lang.NewSymbol("list")) + if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) + } + v67 := v66.Get() + v68 := lang.Apply(v67, []any{lang.NewSymbol("glojure.core/str")}) + v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v70 := v69.FindInternedVar(lang.NewSymbol("list")) + if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) + } + v71 := v70.Get() + v72 := lang.Apply(v71, []any{"No matching clause: "}) + v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v74 := v73.FindInternedVar(lang.NewSymbol("list")) + if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) + } + v75 := v74.Get() + v76 := lang.Apply(v75, []any{v19}) + v77 := lang.Apply(v64, []any{v68, v72, v76}) + v78 := lang.Apply(v61, []any{v77}) + v79 := lang.Apply(v58, []any{v78}) + v80 := lang.Apply(v51, []any{v55, v79}) + v81 := lang.Apply(v48, []any{v80}) + v82 := lang.Apply(v45, []any{v81}) + v83 := lang.Apply(v38, []any{v42, v82}) + v84 := lang.Apply(v35, []any{v83}) + v20 = v84 + } + var v85 any = v20 + _ = v85 + var v86 any + v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v88 := v87.FindInternedVar(lang.NewSymbol(">")) + if v88.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) + } + v89 := v88.Get() + v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v91 := v90.FindInternedVar(lang.NewSymbol("count")) + if v91.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) + } + v92 := v91.Get() + v93 := lang.Apply(v92, []any{v6}) + v94 := lang.Apply(v89, []any{int64(2), v93}) + if lang.IsTruthy(v94) { + v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v96 := v95.FindInternedVar(lang.NewSymbol("seq")) + if v96.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) + } + v97 := v96.Get() + v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v99 := v98.FindInternedVar(lang.NewSymbol("concat")) + if v99.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) + } + v100 := v99.Get() + v101 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v102 := v101.FindInternedVar(lang.NewSymbol("list")) + if v102.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v102))) + } + v103 := v102.Get() + v104 := lang.Apply(v103, []any{lang.NewSymbol("glojure.core/let")}) + v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v106 := v105.FindInternedVar(lang.NewSymbol("list")) + if v106.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) + } + v107 := v106.Get() + v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v109 := v108.FindInternedVar(lang.NewSymbol("apply")) + if v109.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) + } + v110 := v109.Get() + v111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v112 := v111.FindInternedVar(lang.NewSymbol("vector")) + if v112.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v112))) + } + v113 := v112.Get() + v114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v115 := v114.FindInternedVar(lang.NewSymbol("seq")) + if v115.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v115))) + } + v116 := v115.Get() + v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v118 := v117.FindInternedVar(lang.NewSymbol("concat")) + if v118.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) + } + v119 := v118.Get() + v120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v121 := v120.FindInternedVar(lang.NewSymbol("list")) + if v121.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v121))) + } + v122 := v121.Get() + v123 := lang.Apply(v122, []any{v19}) + v124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v125 := v124.FindInternedVar(lang.NewSymbol("list")) + if v125.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v125))) + } + v126 := v125.Get() + v127 := lang.Apply(v126, []any{v5}) + v128 := lang.Apply(v119, []any{v123, v127}) + v129 := lang.Apply(v116, []any{v128}) + v130 := lang.Apply(v110, []any{v113, v129}) + v131 := lang.Apply(v107, []any{v130}) + v132 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v133 := v132.FindInternedVar(lang.NewSymbol("list")) + if v133.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v133))) + } + v134 := v133.Get() + v135 := lang.Apply(v134, []any{v85}) + v136 := lang.Apply(v100, []any{v104, v131, v135}) + v137 := lang.Apply(v97, []any{v136}) + v86 = v137 + } else { + var v138 any + { // let + // let binding "pairs" + v139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v140 := v139.FindInternedVar(lang.NewSymbol("partition")) + if v140.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v140))) + } + v141 := v140.Get() + v142 := lang.Apply(v141, []any{int64(2), v6}) + var v143 any = v142 + _ = v143 + // let binding "assoc-test" + var v144 lang.FnFunc + { // function assoc-test + v144 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v146 := args[0] + _ = v146 + v147 := args[1] + _ = v147 + v148 := args[2] + _ = v148 + var v149 any + v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v151 := v150.FindInternedVar(lang.NewSymbol("contains?")) + if v151.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) + } + v152 := v151.Get() + v153 := lang.Apply(v152, []any{v146, v147}) + if lang.IsTruthy(v153) { + v154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v155 := v154.FindInternedVar(lang.NewSymbol("str")) + if v155.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v155))) + } + v156 := v155.Get() + v157 := lang.Apply(v156, []any{"Duplicate case test constant: ", v147}) + v158 := lang.Apply(lang.NewIllegalArgumentError, []any{v157}) + panic(v158) + } else { + v159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v160 := v159.FindInternedVar(lang.NewSymbol("assoc")) + if v160.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v160))) + } + v161 := v160.Get() + v162 := lang.Apply(v161, []any{v146, v147, v148}) + v149 = v162 + } + return v149 + }) + v145 := v144 + _ = v145 + } + v145 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6745), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(6748), lang.NewKeyword("end-column"), int(48)) + v146, err := lang.WithMeta(v144, v145.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v147 any = v146 + _ = v147 + // let binding "pairs" + v148 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v149 := v148.FindInternedVar(lang.NewSymbol("reduce1")) + if v149.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v149))) + } + v150 := v149.Get() + var v151 lang.FnFunc + v151 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v152 := args[0] + _ = v152 + v153 := args[1] + _ = v153 + var v154 any + { // let + // let binding "vec__177" + var v155 any = v153 + _ = v155 + // let binding "test" + v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v157 := v156.FindInternedVar(lang.NewSymbol("nth")) + if v157.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) + } + v158 := v157.Get() + v159 := lang.Apply(v158, []any{v155, int64(0), nil}) + var v160 any = v159 + _ = v160 + // let binding "expr" + v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v162 := v161.FindInternedVar(lang.NewSymbol("nth")) + if v162.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) + } + v163 := v162.Get() + v164 := lang.Apply(v163, []any{v155, int64(1), nil}) + var v165 any = v164 + _ = v165 + var v166 any + v167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v168 := v167.FindInternedVar(lang.NewSymbol("seq?")) + if v168.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v168))) + } + v169 := v168.Get() + v170 := lang.Apply(v169, []any{v160}) + if lang.IsTruthy(v170) { + v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v172 := v171.FindInternedVar(lang.NewSymbol("reduce1")) + if v172.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) + } + v173 := v172.Get() + var v174 lang.FnFunc + v174 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v175 := args[0] + _ = v175 + v176 := args[1] + _ = v176 + v177 := lang.Apply(v147, []any{v175, v176, v165}) + return v177 + }) + v175 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6752), lang.NewKeyword("column"), int(37), lang.NewKeyword("end-line"), int(6752), lang.NewKeyword("end-column"), int(60)) + v176, err := lang.WithMeta(v174, v175.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v177 := lang.Apply(v173, []any{v176, v152, v160}) + v166 = v177 + } else { + v178 := lang.Apply(v147, []any{v152, v160, v165}) + v166 = v178 + } + v154 = v166 + } // end let + return v154 + }) + v152 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6750), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(6753), lang.NewKeyword("end-column"), int(53)) + v153, err := lang.WithMeta(v151, v152.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v154 := lang.NewMap() + v155 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6754), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(6754), lang.NewKeyword("end-column"), int(25)) + v156, err := lang.WithMeta(v154, v155.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v157 := lang.Apply(v150, []any{v153, v156, v143}) + var v158 any = v157 + _ = v158 + // let binding "tests" + v159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v160 := v159.FindInternedVar(lang.NewSymbol("keys")) + if v160.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v160))) + } + v161 := v160.Get() + v162 := lang.Apply(v161, []any{v158}) + var v163 any = v162 + _ = v163 + // let binding "thens" + v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v165 := v164.FindInternedVar(lang.NewSymbol("vals")) + if v165.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) + } + v166 := v165.Get() + v167 := lang.Apply(v166, []any{v158}) + var v168 any = v167 + _ = v168 + // let binding "mode" + var v169 any + v170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v171 := v170.FindInternedVar(lang.NewSymbol("every?")) + if v171.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v171))) + } + v172 := v171.Get() + var v173 lang.FnFunc + v173 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v174 := args[0] + _ = v174 + var v175 any + { // let + // let binding "and__0__auto__" + v176 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v177 := v176.FindInternedVar(lang.NewSymbol("integer?")) + if v177.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v177))) + } + v178 := v177.Get() + v179 := lang.Apply(v178, []any{v174}) + var v180 any = v179 + _ = v180 + var v181 any + if lang.IsTruthy(v180) { + v182 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v183 := v182.FindInternedVar(lang.NewSymbol("<=")) + if v183.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v183))) + } + v184 := v183.Get() + v185 := lang.Apply(v184, []any{math3.MinInt, v174, math3.MaxInt}) + v181 = v185 + } else { + v181 = v180 + } + v175 = v181 + } // end let + return v175 + }) + v174 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6758), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(6758), lang.NewKeyword("end-column"), int(77)) + v175, err := lang.WithMeta(v173, v174.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v176 := lang.Apply(v172, []any{v175, v163}) + if lang.IsTruthy(v176) { + v169 = lang.NewKeyword("ints") + } else { + var v177 any + v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v179 := v178.FindInternedVar(lang.NewSymbol("every?")) + if v179.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) + } + v180 := v179.Get() + v181 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v182 := v181.FindInternedVar(lang.NewSymbol("keyword?")) + if v182.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v182))) + } + v183 := v182.Get() + v184 := lang.Apply(v180, []any{v183, v163}) + if lang.IsTruthy(v184) { + v177 = lang.NewKeyword("identity") + } else { + var v185 any + if lang.IsTruthy(lang.NewKeyword("else")) { + v185 = lang.NewKeyword("hashes") + } else { + v185 = nil + } + v177 = v185 + } + v169 = v177 + } + var v186 any = v169 + _ = v186 + var v187 any + { // let + // let binding "pred__180" + v188 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v189 := v188.FindInternedVar(lang.NewSymbol("=")) + if v189.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v189))) + } + v190 := v189.Get() + var v191 any = v190 + _ = v191 + // let binding "expr__181" + var v192 any = v186 + _ = v192 + var v193 any + v194 := lang.Apply(v191, []any{lang.NewKeyword("ints"), v192}) + if lang.IsTruthy(v194) { + var v195 any + { // let + // let binding "vec__182" + v196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v197 := v196.FindInternedVar(lang.NewSymbol("prep-ints")) + if v197.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v197))) + } + v198 := v197.Get() + v199 := lang.Apply(v198, []any{v163, v168}) + var v200 any = v199 + _ = v200 + // let binding "shift" + v201 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v202 := v201.FindInternedVar(lang.NewSymbol("nth")) + if v202.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v202))) + } + v203 := v202.Get() + v204 := lang.Apply(v203, []any{v200, int64(0), nil}) + var v205 any = v204 + _ = v205 + // let binding "mask" + v206 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v207 := v206.FindInternedVar(lang.NewSymbol("nth")) + if v207.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v207))) + } + v208 := v207.Get() + v209 := lang.Apply(v208, []any{v200, int64(1), nil}) + var v210 any = v209 + _ = v210 + // let binding "imap" + v211 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v212 := v211.FindInternedVar(lang.NewSymbol("nth")) + if v212.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v212))) + } + v213 := v212.Get() + v214 := lang.Apply(v213, []any{v200, int64(2), nil}) + var v215 any = v214 + _ = v215 + // let binding "switch-type" + v216 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v217 := v216.FindInternedVar(lang.NewSymbol("nth")) + if v217.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v217))) + } + v218 := v217.Get() + v219 := lang.Apply(v218, []any{v200, int64(3), nil}) + var v220 any = v219 + _ = v220 + v221 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v222 := v221.FindInternedVar(lang.NewSymbol("seq")) + if v222.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v222))) + } + v223 := v222.Get() + v224 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v225 := v224.FindInternedVar(lang.NewSymbol("concat")) + if v225.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v225))) + } + v226 := v225.Get() + v227 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v228 := v227.FindInternedVar(lang.NewSymbol("list")) + if v228.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v228))) + } + v229 := v228.Get() + v230 := lang.Apply(v229, []any{lang.NewSymbol("glojure.core/let")}) + v231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v232 := v231.FindInternedVar(lang.NewSymbol("list")) + if v232.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v232))) + } + v233 := v232.Get() + v234 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v235 := v234.FindInternedVar(lang.NewSymbol("apply")) + if v235.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v235))) + } + v236 := v235.Get() + v237 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v238 := v237.FindInternedVar(lang.NewSymbol("vector")) + if v238.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v238))) + } + v239 := v238.Get() + v240 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v241 := v240.FindInternedVar(lang.NewSymbol("seq")) + if v241.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v241))) + } + v242 := v241.Get() + v243 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v244 := v243.FindInternedVar(lang.NewSymbol("concat")) + if v244.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v244))) + } + v245 := v244.Get() + v246 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v247 := v246.FindInternedVar(lang.NewSymbol("list")) + if v247.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v247))) + } + v248 := v247.Get() + v249 := lang.Apply(v248, []any{v19}) + v250 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v251 := v250.FindInternedVar(lang.NewSymbol("list")) + if v251.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v251))) + } + v252 := v251.Get() + v253 := lang.Apply(v252, []any{v5}) + v254 := lang.Apply(v245, []any{v249, v253}) + v255 := lang.Apply(v242, []any{v254}) + v256 := lang.Apply(v236, []any{v239, v255}) + v257 := lang.Apply(v233, []any{v256}) + v258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v259 := v258.FindInternedVar(lang.NewSymbol("list")) + if v259.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v259))) + } + v260 := v259.Get() + v261 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v262 := v261.FindInternedVar(lang.NewSymbol("seq")) + if v262.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v262))) + } + v263 := v262.Get() + v264 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v265 := v264.FindInternedVar(lang.NewSymbol("concat")) + if v265.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v265))) + } + v266 := v265.Get() + v267 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v268 := v267.FindInternedVar(lang.NewSymbol("list")) + if v268.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v268))) + } + v269 := v268.Get() + v270 := lang.Apply(v269, []any{lang.NewSymbol("case*")}) + v271 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v272 := v271.FindInternedVar(lang.NewSymbol("list")) + if v272.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v272))) + } + v273 := v272.Get() + v274 := lang.Apply(v273, []any{v19}) + v275 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v276 := v275.FindInternedVar(lang.NewSymbol("list")) + if v276.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v276))) + } + v277 := v276.Get() + v278 := lang.Apply(v277, []any{v205}) + v279 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v280 := v279.FindInternedVar(lang.NewSymbol("list")) + if v280.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v280))) + } + v281 := v280.Get() + v282 := lang.Apply(v281, []any{v210}) + v283 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v284 := v283.FindInternedVar(lang.NewSymbol("list")) + if v284.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v284))) + } + v285 := v284.Get() + v286 := lang.Apply(v285, []any{v85}) + v287 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v288 := v287.FindInternedVar(lang.NewSymbol("list")) + if v288.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v288))) + } + v289 := v288.Get() + v290 := lang.Apply(v289, []any{v215}) + v291 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v292 := v291.FindInternedVar(lang.NewSymbol("list")) + if v292.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v292))) + } + v293 := v292.Get() + v294 := lang.Apply(v293, []any{v220}) + v295 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v296 := v295.FindInternedVar(lang.NewSymbol("list")) + if v296.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v296))) + } + v297 := v296.Get() + v298 := lang.Apply(v297, []any{lang.NewKeyword("int")}) + v299 := lang.Apply(v266, []any{v270, v274, v278, v282, v286, v290, v294, v298}) + v300 := lang.Apply(v263, []any{v299}) + v301 := lang.Apply(v260, []any{v300}) + v302 := lang.Apply(v226, []any{v230, v257, v301}) + v303 := lang.Apply(v223, []any{v302}) + v195 = v303 + } // end let + v193 = v195 + } else { + var v196 any + v197 := lang.Apply(v191, []any{lang.NewKeyword("hashes"), v192}) + if lang.IsTruthy(v197) { + var v198 any + { // let + // let binding "vec__185" + v199 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v200 := v199.FindInternedVar(lang.NewSymbol("prep-hashes")) + if v200.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v200))) + } + v201 := v200.Get() + v202 := lang.Apply(v201, []any{v19, v85, v163, v168}) + var v203 any = v202 + _ = v203 + // let binding "shift" + v204 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v205 := v204.FindInternedVar(lang.NewSymbol("nth")) + if v205.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v205))) + } + v206 := v205.Get() + v207 := lang.Apply(v206, []any{v203, int64(0), nil}) + var v208 any = v207 + _ = v208 + // let binding "mask" + v209 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v210 := v209.FindInternedVar(lang.NewSymbol("nth")) + if v210.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v210))) + } + v211 := v210.Get() + v212 := lang.Apply(v211, []any{v203, int64(1), nil}) + var v213 any = v212 + _ = v213 + // let binding "imap" + v214 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v215 := v214.FindInternedVar(lang.NewSymbol("nth")) + if v215.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v215))) + } + v216 := v215.Get() + v217 := lang.Apply(v216, []any{v203, int64(2), nil}) + var v218 any = v217 + _ = v218 + // let binding "switch-type" + v219 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v220 := v219.FindInternedVar(lang.NewSymbol("nth")) + if v220.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v220))) + } + v221 := v220.Get() + v222 := lang.Apply(v221, []any{v203, int64(3), nil}) + var v223 any = v222 + _ = v223 + // let binding "skip-check" + v224 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v225 := v224.FindInternedVar(lang.NewSymbol("nth")) + if v225.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v225))) + } + v226 := v225.Get() + v227 := lang.Apply(v226, []any{v203, int64(4), nil}) + var v228 any = v227 + _ = v228 + v229 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v230 := v229.FindInternedVar(lang.NewSymbol("seq")) + if v230.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v230))) + } + v231 := v230.Get() + v232 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v233 := v232.FindInternedVar(lang.NewSymbol("concat")) + if v233.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v233))) + } + v234 := v233.Get() + v235 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v236 := v235.FindInternedVar(lang.NewSymbol("list")) + if v236.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v236))) + } + v237 := v236.Get() + v238 := lang.Apply(v237, []any{lang.NewSymbol("glojure.core/let")}) + v239 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v240 := v239.FindInternedVar(lang.NewSymbol("list")) + if v240.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v240))) + } + v241 := v240.Get() + v242 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v243 := v242.FindInternedVar(lang.NewSymbol("apply")) + if v243.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v243))) + } + v244 := v243.Get() + v245 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v246 := v245.FindInternedVar(lang.NewSymbol("vector")) + if v246.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v246))) + } + v247 := v246.Get() + v248 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v249 := v248.FindInternedVar(lang.NewSymbol("seq")) + if v249.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v249))) + } + v250 := v249.Get() + v251 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v252 := v251.FindInternedVar(lang.NewSymbol("concat")) + if v252.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v252))) + } + v253 := v252.Get() + v254 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v255 := v254.FindInternedVar(lang.NewSymbol("list")) + if v255.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v255))) + } + v256 := v255.Get() + v257 := lang.Apply(v256, []any{v19}) + v258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v259 := v258.FindInternedVar(lang.NewSymbol("list")) + if v259.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v259))) + } + v260 := v259.Get() + v261 := lang.Apply(v260, []any{v5}) + v262 := lang.Apply(v253, []any{v257, v261}) + v263 := lang.Apply(v250, []any{v262}) + v264 := lang.Apply(v244, []any{v247, v263}) + v265 := lang.Apply(v241, []any{v264}) + v266 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v267 := v266.FindInternedVar(lang.NewSymbol("list")) + if v267.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v267))) + } + v268 := v267.Get() + v269 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v270 := v269.FindInternedVar(lang.NewSymbol("seq")) + if v270.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v270))) + } + v271 := v270.Get() + v272 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v273 := v272.FindInternedVar(lang.NewSymbol("concat")) + if v273.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v273))) + } + v274 := v273.Get() + v275 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v276 := v275.FindInternedVar(lang.NewSymbol("list")) + if v276.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v276))) + } + v277 := v276.Get() + v278 := lang.Apply(v277, []any{lang.NewSymbol("case*")}) + v279 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v280 := v279.FindInternedVar(lang.NewSymbol("list")) + if v280.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v280))) + } + v281 := v280.Get() + v282 := lang.Apply(v281, []any{v19}) + v283 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v284 := v283.FindInternedVar(lang.NewSymbol("list")) + if v284.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v284))) + } + v285 := v284.Get() + v286 := lang.Apply(v285, []any{v208}) + v287 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v288 := v287.FindInternedVar(lang.NewSymbol("list")) + if v288.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v288))) + } + v289 := v288.Get() + v290 := lang.Apply(v289, []any{v213}) + v291 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v292 := v291.FindInternedVar(lang.NewSymbol("list")) + if v292.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v292))) + } + v293 := v292.Get() + v294 := lang.Apply(v293, []any{v85}) + v295 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v296 := v295.FindInternedVar(lang.NewSymbol("list")) + if v296.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v296))) + } + v297 := v296.Get() + v298 := lang.Apply(v297, []any{v218}) + v299 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v300 := v299.FindInternedVar(lang.NewSymbol("list")) + if v300.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v300))) + } + v301 := v300.Get() + v302 := lang.Apply(v301, []any{v223}) + v303 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v304 := v303.FindInternedVar(lang.NewSymbol("list")) + if v304.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v304))) + } + v305 := v304.Get() + v306 := lang.Apply(v305, []any{lang.NewKeyword("hash-equiv")}) + v307 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v308 := v307.FindInternedVar(lang.NewSymbol("list")) + if v308.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v308))) + } + v309 := v308.Get() + v310 := lang.Apply(v309, []any{v228}) + v311 := lang.Apply(v274, []any{v278, v282, v286, v290, v294, v298, v302, v306, v310}) + v312 := lang.Apply(v271, []any{v311}) + v313 := lang.Apply(v268, []any{v312}) + v314 := lang.Apply(v234, []any{v238, v265, v313}) + v315 := lang.Apply(v231, []any{v314}) + v198 = v315 + } // end let + v196 = v198 + } else { + var v199 any + v200 := lang.Apply(v191, []any{lang.NewKeyword("identity"), v192}) + if lang.IsTruthy(v200) { + var v201 any + { // let + // let binding "vec__188" + v202 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v203 := v202.FindInternedVar(lang.NewSymbol("prep-hashes")) + if v203.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v203))) + } + v204 := v203.Get() + v205 := lang.Apply(v204, []any{v19, v85, v163, v168}) + var v206 any = v205 + _ = v206 + // let binding "shift" + v207 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v208 := v207.FindInternedVar(lang.NewSymbol("nth")) + if v208.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v208))) + } + v209 := v208.Get() + v210 := lang.Apply(v209, []any{v206, int64(0), nil}) + var v211 any = v210 + _ = v211 + // let binding "mask" + v212 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v213 := v212.FindInternedVar(lang.NewSymbol("nth")) + if v213.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v213))) + } + v214 := v213.Get() + v215 := lang.Apply(v214, []any{v206, int64(1), nil}) + var v216 any = v215 + _ = v216 + // let binding "imap" + v217 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v218 := v217.FindInternedVar(lang.NewSymbol("nth")) + if v218.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v218))) + } + v219 := v218.Get() + v220 := lang.Apply(v219, []any{v206, int64(2), nil}) + var v221 any = v220 + _ = v221 + // let binding "switch-type" + v222 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v223 := v222.FindInternedVar(lang.NewSymbol("nth")) + if v223.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v223))) + } + v224 := v223.Get() + v225 := lang.Apply(v224, []any{v206, int64(3), nil}) + var v226 any = v225 + _ = v226 + // let binding "skip-check" + v227 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v228 := v227.FindInternedVar(lang.NewSymbol("nth")) + if v228.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v228))) + } + v229 := v228.Get() + v230 := lang.Apply(v229, []any{v206, int64(4), nil}) + var v231 any = v230 + _ = v231 + v232 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v233 := v232.FindInternedVar(lang.NewSymbol("seq")) + if v233.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v233))) + } + v234 := v233.Get() + v235 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v236 := v235.FindInternedVar(lang.NewSymbol("concat")) + if v236.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v236))) + } + v237 := v236.Get() + v238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v239 := v238.FindInternedVar(lang.NewSymbol("list")) + if v239.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v239))) + } + v240 := v239.Get() + v241 := lang.Apply(v240, []any{lang.NewSymbol("glojure.core/let")}) + v242 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v243 := v242.FindInternedVar(lang.NewSymbol("list")) + if v243.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v243))) + } + v244 := v243.Get() + v245 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v246 := v245.FindInternedVar(lang.NewSymbol("apply")) + if v246.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v246))) + } + v247 := v246.Get() + v248 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v249 := v248.FindInternedVar(lang.NewSymbol("vector")) + if v249.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v249))) + } + v250 := v249.Get() + v251 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v252 := v251.FindInternedVar(lang.NewSymbol("seq")) + if v252.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v252))) + } + v253 := v252.Get() + v254 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v255 := v254.FindInternedVar(lang.NewSymbol("concat")) + if v255.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v255))) + } + v256 := v255.Get() + v257 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v258 := v257.FindInternedVar(lang.NewSymbol("list")) + if v258.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v258))) + } + v259 := v258.Get() + v260 := lang.Apply(v259, []any{v19}) + v261 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v262 := v261.FindInternedVar(lang.NewSymbol("list")) + if v262.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v262))) + } + v263 := v262.Get() + v264 := lang.Apply(v263, []any{v5}) + v265 := lang.Apply(v256, []any{v260, v264}) + v266 := lang.Apply(v253, []any{v265}) + v267 := lang.Apply(v247, []any{v250, v266}) + v268 := lang.Apply(v244, []any{v267}) + v269 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v270 := v269.FindInternedVar(lang.NewSymbol("list")) + if v270.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v270))) + } + v271 := v270.Get() + v272 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v273 := v272.FindInternedVar(lang.NewSymbol("seq")) + if v273.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v273))) + } + v274 := v273.Get() + v275 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v276 := v275.FindInternedVar(lang.NewSymbol("concat")) + if v276.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v276))) + } + v277 := v276.Get() + v278 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v279 := v278.FindInternedVar(lang.NewSymbol("list")) + if v279.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v279))) + } + v280 := v279.Get() + v281 := lang.Apply(v280, []any{lang.NewSymbol("case*")}) + v282 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v283 := v282.FindInternedVar(lang.NewSymbol("list")) + if v283.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v283))) + } + v284 := v283.Get() + v285 := lang.Apply(v284, []any{v19}) + v286 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v287 := v286.FindInternedVar(lang.NewSymbol("list")) + if v287.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v287))) + } + v288 := v287.Get() + v289 := lang.Apply(v288, []any{v211}) + v290 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v291 := v290.FindInternedVar(lang.NewSymbol("list")) + if v291.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v291))) + } + v292 := v291.Get() + v293 := lang.Apply(v292, []any{v216}) + v294 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v295 := v294.FindInternedVar(lang.NewSymbol("list")) + if v295.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v295))) + } + v296 := v295.Get() + v297 := lang.Apply(v296, []any{v85}) + v298 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v299 := v298.FindInternedVar(lang.NewSymbol("list")) + if v299.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v299))) + } + v300 := v299.Get() + v301 := lang.Apply(v300, []any{v221}) + v302 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v303 := v302.FindInternedVar(lang.NewSymbol("list")) + if v303.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v303))) + } + v304 := v303.Get() + v305 := lang.Apply(v304, []any{v226}) + v306 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v307 := v306.FindInternedVar(lang.NewSymbol("list")) + if v307.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v307))) + } + v308 := v307.Get() + v309 := lang.Apply(v308, []any{lang.NewKeyword("hash-identity")}) + v310 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v311 := v310.FindInternedVar(lang.NewSymbol("list")) + if v311.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v311))) + } + v312 := v311.Get() + v313 := lang.Apply(v312, []any{v231}) + v314 := lang.Apply(v277, []any{v281, v285, v289, v293, v297, v301, v305, v309, v313}) + v315 := lang.Apply(v274, []any{v314}) + v316 := lang.Apply(v271, []any{v315}) + v317 := lang.Apply(v237, []any{v241, v268, v316}) + v318 := lang.Apply(v234, []any{v317}) + v201 = v318 + } // end let + v199 = v201 + } else { + v202 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v203 := v202.FindInternedVar(lang.NewSymbol("str")) + if v203.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v203))) + } + v204 := v203.Get() + v205 := lang.Apply(v204, []any{"No matching clause: ", v192}) + v206 := lang.Apply(lang.NewIllegalArgumentError, []any{v205}) + panic(v206) + } + v196 = v199 + } + v193 = v196 + } + v187 = v193 + } // end let + v138 = v187 + } // end let + v86 = v138 + } + v7 = v86 + } // end let + return v7 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // case-map + { + v0 := lang.NewSymbol("case-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("case-f"), lang.NewSymbol("test-f"), lang.NewSymbol("tests"), lang.NewSymbol("thens"))), lang.NewKeyword("doc"), "Transforms a sequence of test constants and a corresponding sequence of then\n expressions into a sorted map to be consumed by case*. The form of the map\n entries are {(case-f test) [(test-f test) then]}.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6614), lang.NewKeyword("end-line"), int(6614), lang.NewKeyword("private"), true)).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("into1")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("sorted-map")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, nil) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("zipmap")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("map")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.Apply(v19, []any{v3, v5}) + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("map")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("vector")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("map")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{v4, v5}) + v31 := lang.Apply(v23, []any{v26, v30, v6}) + v32 := lang.Apply(v16, []any{v20, v31}) + v33 := lang.Apply(v9, []any{v13, v32}) + return v33 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // cast + { + v0 := lang.NewSymbol("cast").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Throws a ClassCastException if x is not a c, else returns x.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(345), lang.NewKeyword("end-line"), int(345))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5, _ := lang.FieldOrMethod(v3, "cast") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("cast is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // cat + { + v0 := lang.NewSymbol("cat").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rf"))), lang.NewKeyword("doc"), "A transducer which concatenates the contents of each input, which must be a\n collection, into the reduction.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7645), lang.NewKeyword("end-line"), int(7645))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + { // let + // let binding "rrf" + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("preserving-reduced")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v3}) + var v9 any = v8 + _ = v9 + var v10 lang.FnFunc + v10 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + v11 := lang.Apply(v3, nil) + return v11 + case 1: + v11 := args[0] + _ = v11 + v12 := lang.Apply(v3, []any{v11}) + return v12 + case 2: + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("reduce")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{v9, v11, v12}) + return v16 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7651), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(7655), lang.NewKeyword("end-column"), int(36)) + v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v4 = v12 + } // end let + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // char + { + var v1 lang.FnFunc + { // function char__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("concat")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("list")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("seq")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("concat")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + var v30 any + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + if lang.IsTruthy(v33) { + v30 = lang.NewSymbol("uncheckedCharCast") + } else { + v30 = lang.NewSymbol("charCast") + } + v34 := lang.Apply(v29, []any{v30}) + v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v36 := v35.FindInternedVar(lang.NewSymbol("list")) + if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + } + v37 := v36.Get() + v38 := lang.Apply(v37, []any{v3}) + v39 := lang.Apply(v26, []any{v34, v38}) + v40 := lang.Apply(v23, []any{v39}) + v41 := lang.Apply(v20, []any{v40}) + v42 := lang.Apply(v9, []any{v13, v17, v41}) + v43 := lang.Apply(v6, []any{v42}) + return v43 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("char").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to char", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3511), lang.NewKeyword("end-line"), int(3511))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5, _ := lang.FieldOrMethod(runtime4.RT, "CharCast") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("CharCast is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // char-array + { + var v1 lang.FnFunc + { // function char-array__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := lang.NewList(args[0:]...) + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("concat")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("list")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/CharArray")}) + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("list")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("seq")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("concat")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) + v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v36 := v35.FindInternedVar(lang.NewSymbol("list")) + if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + } + v37 := v36.Get() + v38 := lang.Apply(v37, []any{lang.NewSymbol("glojure.core/args")}) + v39 := lang.Apply(v30, []any{v34, v38}) + v40 := lang.Apply(v27, []any{v39}) + v41 := lang.Apply(v24, []any{v40}) + v42 := lang.Apply(v9, []any{v13, v17, v21, v41}) + v43 := lang.Apply(v6, []any{v42}) + return v43 + } + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("char-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Creates an array of chars", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1), int64(2)), lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5325), lang.NewKeyword("end-line"), int(5325))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + v5, _ := lang.FieldOrMethod(lang.Numbers, "CharArray") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("CharArray is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6, _ := lang.FieldOrMethod(lang.Numbers, "CharArrayInit") + if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("CharArrayInit is not a function"))) + } + v7 := lang.Apply(v6, []any{v4, v5}) + return v7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // char-escape-string + { + v1 := reflect.TypeOf("") + v0 := lang.NewSymbol("char-escape-string").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("doc"), "Returns escape string for char or nil if none", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(6), lang.NewKeyword("line"), int(214), lang.NewKeyword("end-line"), int(217))).(*lang.Symbol) + v2 := ns.InternWithValue(v0, lang.NewMap(lang.NewChar(10), "\\n", lang.NewChar(9), "\\t", lang.NewChar(13), "\\r", lang.NewChar(34), "\\\"", lang.NewChar(92), "\\\\", lang.NewChar(12), "\\f", lang.NewChar(8), "\\b"), true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // char-name-string + { + v1 := reflect.TypeOf("") + v0 := lang.NewSymbol("char-name-string").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("doc"), "Returns name string for char or nil if none", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(6), lang.NewKeyword("line"), int(335), lang.NewKeyword("end-line"), int(338))).(*lang.Symbol) + v2 := ns.InternWithValue(v0, lang.NewMap(lang.NewChar(10), "newline", lang.NewChar(9), "tab", lang.NewChar(32), "space", lang.NewChar(8), "backspace", lang.NewChar(12), "formfeed", lang.NewChar(13), "return"), true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // char? + { + v0 := lang.NewSymbol("char?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a Character", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(153), lang.NewKeyword("end-line"), int(157))).(*lang.Symbol) + var v2 lang.FnFunc + { // function char? + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{lang.Char, v4}) + return v8 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(157), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(157), lang.NewKeyword("end-column"), int(89))).(lang.FnFunc) + v3 := v2 + _ = v3 + } + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // chars + { + var v1 lang.FnFunc + { // function chars + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("concat")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("list")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/Chars")}) + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("list")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v3}) + v26 := lang.Apply(v9, []any{v13, v17, v21, v25}) + v27 := lang.Apply(v6, []any{v26}) + return v27 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("chars").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Casts to chars[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5382), lang.NewKeyword("end-line"), int(5382))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5, _ := lang.FieldOrMethod(lang.Numbers, "Chars") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Chars is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // check-cyclic-dependency + { + v0 := lang.NewSymbol("check-cyclic-dependency").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("path"))), lang.NewKeyword("doc"), "Detects and rejects non-trivial cyclic load dependencies. The\n exception message shows the dependency chain with the cycle\n highlighted. Ignores the trivial case of a file attempting to load\n itself because that can occur when a gen-class'd class loads its\n implementation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(30), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5974), lang.NewKeyword("end-line"), int(5974), lang.NewKeyword("private"), true)).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("some")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.CreatePersistentTreeSet(v3) + v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5981), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(5981), lang.NewKeyword("end-column"), int(21)) + v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("rest")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("*pending-paths*")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v13, []any{v16}) + v18 := lang.Apply(v7, []any{v10, v17}) + if lang.IsTruthy(v18) { + var v19 any + { // let + // let binding "pending" + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("map")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + var v23 lang.FnFunc + v23 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v24 := args[0] + _ = v24 + var v25 any + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("=")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.Apply(v28, []any{v24, v3}) + if lang.IsTruthy(v29) { + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("str")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.Apply(v32, []any{"[ ", v24, " ]"}) + v25 = v33 + } else { + v25 = v24 + } + return v25 + }) + v24 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5982), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(5982), lang.NewKeyword("end-column"), int(59)) + v25, err := lang.WithMeta(v23, v24.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("cons")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("*pending-paths*")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.Apply(v28, []any{v3, v31}) + v33 := lang.Apply(v22, []any{v25, v32}) + var v34 any = v33 + _ = v34 + // let binding "chain" + v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v36 := v35.FindInternedVar(lang.NewSymbol("apply")) + if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + } + v37 := v36.Get() + v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v39 := v38.FindInternedVar(lang.NewSymbol("str")) + if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + } + v40 := v39.Get() + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("interpose")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.Apply(v43, []any{"->", v34}) + v45 := lang.Apply(v37, []any{v40, v44}) + var v46 any = v45 + _ = v46 + v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v48 := v47.FindInternedVar(lang.NewSymbol("throw-if")) + if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) + } + v49 := v48.Get() + v50 := lang.Apply(v49, []any{true, "Cyclic load dependency: %s", v46}) + v19 = v50 + } // end let + v4 = v19 + } else { + v4 = nil + } + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // check-valid-options + { + v0 := lang.NewSymbol("check-valid-options").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("options"), lang.NewSymbol("&"), lang.NewSymbol("valid-keys"))), lang.NewKeyword("doc"), "Throws an exception if the given option map contains keys not listed\n as valid, else returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(35), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1709), lang.NewKeyword("end-line"), int(1709), lang.NewKeyword("private"), true)).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.NewList(args[1:]...) + var v5 any + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("seq")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("apply")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("disj")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("apply")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("hash-set")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("keys")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.Apply(v23, []any{v3}) + v25 := lang.Apply(v17, []any{v20, v24}) + v26 := lang.Apply(v11, []any{v14, v25, v4}) + v27 := lang.Apply(v8, []any{v26}) + if lang.IsTruthy(v27) { + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("apply")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("str")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("first")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.Apply(v36, []any{v4}) + v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v39 := v38.FindInternedVar(lang.NewSymbol("map")) + if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + } + v40 := v39.Get() + var v41 lang.FnFunc + v41 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v42 := args[0] + _ = v42 + v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v44 := v43.FindInternedVar(lang.NewSymbol("str")) + if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) + } + v45 := v44.Get() + v46 := lang.Apply(v45, []any{", ", v42}) + return v46 + }) + v42 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1718), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(1718), lang.NewKeyword("end-column"), int(28)) + v43, err := lang.WithMeta(v41, v42.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("rest")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.Apply(v46, []any{v4}) + v48 := lang.Apply(v40, []any{v43, v47}) + v49 := lang.Apply(v30, []any{v33, "Only these options are valid: ", v37, v48}) + v50 := lang.Apply(lang.NewIllegalArgumentError, []any{v49}) + panic(v50) + } else { + v5 = nil + } + return v5 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // chunk + { + v0 := lang.NewSymbol("chunk").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(691), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(691), lang.NewKeyword("end-column"), int(41), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("b"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4, ok := lang.FieldOrMethod(v3, "chunk") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "chunk"))) + } + var v5 any + switch reflect.TypeOf(v4).Kind() { + case reflect.Func: + v5 = lang.Apply(v4, nil) + default: + v5 = v4 + } + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // chunk-append + { + v0 := lang.NewSymbol("chunk-append").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(688), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(688), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("b"), lang.NewSymbol("x"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5, _ := lang.FieldOrMethod(v3, "add") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // chunk-buffer + { + v0 := lang.NewSymbol("chunk-buffer").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(685), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(685), lang.NewKeyword("end-column"), int(53), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("capacity"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.Apply(lang.NewChunkBuffer, []any{v3}) + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // chunk-cons + { + v0 := lang.NewSymbol("chunk-cons").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(703), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(703), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("chunk"), lang.NewSymbol("rest"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any + v6 := lang.Apply(lang.Count, []any{v3}) + v7 := lang.Apply(lang.IsZero, []any{v6}) + if lang.IsTruthy(v7) { + v5 = v4 + } else { + v8 := lang.Apply(lang.NewChunkedCons, []any{v3, v4}) + v5 = v8 + } + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // chunk-first + { + v0 := lang.NewSymbol("chunk-first").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(694), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(694), lang.NewKeyword("end-column"), int(48), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4, ok := lang.FieldOrMethod(v3, "chunkedFirst") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "chunkedFirst"))) + } + var v5 any + switch reflect.TypeOf(v4).Kind() { + case reflect.Func: + v5 = lang.Apply(v4, nil) + default: + v5 = v4 + } + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // chunk-next + { + v0 := lang.NewSymbol("chunk-next").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(700), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(700), lang.NewKeyword("end-column"), int(71), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4, ok := lang.FieldOrMethod(v3, "chunkedNext") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "chunkedNext"))) + } + var v5 any + switch reflect.TypeOf(v4).Kind() { + case reflect.Func: + v5 = lang.Apply(v4, nil) + default: + v5 = v4 + } + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // chunk-rest + { + v0 := lang.NewSymbol("chunk-rest").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(697), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(697), lang.NewKeyword("end-column"), int(71), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4, ok := lang.FieldOrMethod(v3, "chunkedMore") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "chunkedMore"))) + } + var v5 any + switch reflect.TypeOf(v4).Kind() { + case reflect.Func: + v5 = lang.Apply(v4, nil) + default: + v5 = v4 + } + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // chunked-seq? + { + v0 := lang.NewSymbol("chunked-seq?").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(708), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(708), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.Apply(v6, []any{lang.IChunkedSeq, v3}) + return v7 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // class + { + v0 := lang.NewSymbol("class").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns the Class of x", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3461), lang.NewKeyword("end-line"), int(3461))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("nil?")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v3}) + if lang.IsTruthy(v8) { + v4 = v3 + } else { + v9 := lang.Apply(lang.TypeOf, []any{v3}) + v4 = v9 + } + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // class? + { + v0 := lang.NewSymbol("class?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is an instance of Class", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5465), lang.NewKeyword("end-line"), int(5465))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.Apply(v6, []any{reflect.Type, v3}) + return v7 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // clear-agent-errors + { + v0 := lang.NewSymbol("clear-agent-errors").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("doc"), "DEPRECATED: Use 'restart-agent' instead.\n Clears any exceptions thrown during asynchronous actions of the\n agent, allowing subsequent actions to occur.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("deprecated"), "1.2", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2244), lang.NewKeyword("end-line"), int(2244))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("restart-agent")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7, ok := lang.FieldOrMethod(v3, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "Deref"))) + } + var v8 any + switch reflect.TypeOf(v7).Kind() { + case reflect.Func: + v8 = lang.Apply(v7, nil) + default: + v8 = v7 + } + v9 := lang.Apply(v6, []any{v3, v8}) + return v9 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // coll? + { + v0 := lang.NewSymbol("coll?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements IPersistentCollection", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6192), lang.NewKeyword("end-line"), int(6192))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.Apply(v6, []any{lang.IPersistentCollection, v3}) + return v7 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // comment + { + v0 := lang.NewSymbol("comment").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Ignores body, yields nil", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4733), lang.NewKeyword("end-line"), int(4733))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.NewList(args[2:]...) + return nil + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // commute + { + v0 := lang.NewSymbol("commute").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("fun"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Must be called in a transaction. Sets the in-transaction-value of\n ref to:\n\n (apply fun in-transaction-value-of-ref args)\n\n and returns the in-transaction-value of ref.\n\n At the commit point of the transaction, sets the value of ref to be:\n\n (apply fun most-recently-committed-value-of-ref args)\n\n Thus fun should be commutative, or, failing that, you must accept\n last-one-in-wins behavior. commute allows for more concurrency than\n ref-set.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2414), lang.NewKeyword("end-line"), int(2414))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.NewList(args[2:]...) + v6, _ := lang.FieldOrMethod(v3, "Commute") + if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Commute is not a function"))) + } + v7 := lang.Apply(v6, []any{v4, v5}) + return v7 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // comp + { + v0 := lang.NewSymbol("comp").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("g")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("g"), lang.NewSymbol("&"), lang.NewSymbol("fs"))), lang.NewKeyword("doc"), "Takes a set of functions and returns a fn that is the composition\n of those fns. The returned fn takes a variable number of args,\n applies the rightmost of fns to the args, the next\n fn (right-to-left) to the result, etc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2549), lang.NewKeyword("end-line"), int(2549))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v4 := v3.FindInternedVar(lang.NewSymbol("identity")) + if v4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) + } + v5 := v4.Get() + return v5 + case 1: + v3 := args[0] + _ = v3 + return v3 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 lang.FnFunc + v5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + v6 := lang.Apply(v4, nil) + v7 := lang.Apply(v3, []any{v6}) + return v7 + case 1: + v6 := args[0] + _ = v6 + v7 := lang.Apply(v4, []any{v6}) + v8 := lang.Apply(v3, []any{v7}) + return v8 + case 2: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := lang.Apply(v4, []any{v6, v7}) + v9 := lang.Apply(v3, []any{v8}) + return v9 + case 3: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + v9 := lang.Apply(v4, []any{v6, v7, v8}) + v10 := lang.Apply(v3, []any{v9}) + return v10 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + v9 := lang.NewList(args[3:]...) + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("apply")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{v4, v6, v7, v8, v9}) + v14 := lang.Apply(v3, []any{v13}) + return v14 + } + }) + v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2559), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2564), lang.NewKeyword("end-column"), int(49)) + v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v7 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.NewList(args[2:]...) + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("reduce1")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("comp")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("list*")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.Apply(v14, []any{v3, v4, v5}) + v16 := lang.Apply(v8, []any{v11, v15}) + return v16 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // comparator + { + v0 := lang.NewSymbol("comparator").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"))), lang.NewKeyword("doc"), "Returns an implementation of java.util.Comparator based upon pred.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3077), lang.NewKeyword("end-line"), int(3077))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 lang.FnFunc + v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + var v7 any + v8 := lang.Apply(v3, []any{v5, v6}) + if lang.IsTruthy(v8) { + v7 = int64(-1) + } else { + var v9 any + v10 := lang.Apply(v3, []any{v6, v5}) + if lang.IsTruthy(v10) { + v9 = int64(1) + } else { + var v11 any + if lang.IsTruthy(lang.NewKeyword("else")) { + v11 = int64(0) + } else { + v11 = nil + } + v9 = v11 + } + v7 = v9 + } + return v7 + }) + v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3082), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(3083), lang.NewKeyword("end-column"), int(48)) + v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v6 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // compare + { + var v1 lang.FnFunc + { // function compare__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("seq")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("concat")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("list")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("list")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{lang.NewSymbol("glojure.lang.Util")}) + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("list")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{lang.NewSymbol("glojure.core/compare")}) + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("list")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.Apply(v25, []any{v3}) + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{v4}) + v31 := lang.Apply(v10, []any{v14, v18, v22, v26, v30}) + v32 := lang.Apply(v7, []any{v31}) + return v32 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("compare").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Comparator. Returns a negative number, zero, or a positive number\n when x is logically 'less than', 'equal to', or 'greater than'\n y. Same as Java x.compareTo(y) except it also works for nil, and\n compares numbers and collections in a type-independent manner. x\n must implement Comparable", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(824), lang.NewKeyword("end-line"), int(824))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := lang.Apply(lang.Compare, []any{v4, v5}) + return v6 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // compare-and-set! + { + v0 := lang.NewSymbol("compare-and-set!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atom"), lang.NewSymbol("oldval"), lang.NewSymbol("newval"))), lang.NewKeyword("doc"), "Atomically sets the value of atom to newval if and only if the\n current value of the atom is identical to oldval. Returns true if\n set happened, else false", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2360), lang.NewKeyword("end-line"), int(2360))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6, _ := lang.FieldOrMethod(v3, "compareAndSet") + if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("compareAndSet is not a function"))) + } + v7 := lang.Apply(v6, []any{v4, v5}) + return v7 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // compile + { + v0 := lang.NewSymbol("compile").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"))), lang.NewKeyword("doc"), "Compiles the namespace named by the symbol lib into a set of\n classfiles. The source for the lib must be in a proper\n classpath-relative directory. The output files will go into the\n directory specified by *compile-path*, and that directory too must\n be in the classpath.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6114), lang.NewKeyword("end-line"), int(6114))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + { // let + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("push-thread-bindings")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("hash-map")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*compile-files*")) + v12 := lang.Apply(v10, []any{v11, true}) + v13 := lang.Apply(v7, []any{v12}) + _ = v13 + var v14 any + func() { + defer func() { + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, nil) + }() + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("load-one")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{v3, true, true}) + v14 = v22 + }() + v4 = v14 + } // end let + _ = v4 + return v3 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // complement + { + v0 := lang.NewSymbol("complement").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Takes a fn f and returns a fn that takes the same arguments as f,\n has the same effects, if any, and returns the opposite truth value.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1428), lang.NewKeyword("end-line"), int(1428))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 lang.FnFunc + v4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("not")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v3, nil) + v9 := lang.Apply(v7, []any{v8}) + return v9 + case 1: + v5 := args[0] + _ = v5 + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("not")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v3, []any{v5}) + v10 := lang.Apply(v8, []any{v9}) + return v10 + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("not")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v3, []any{v5, v6}) + v11 := lang.Apply(v9, []any{v10}) + return v11 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := lang.NewList(args[2:]...) + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("not")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("apply")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{v3, v5, v6, v7}) + v15 := lang.Apply(v10, []any{v14}) + return v15 + } + }) + v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1434), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(1438), lang.NewKeyword("end-column"), int(40)) + v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v6 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // completing + { + v0 := lang.NewSymbol("completing").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("cf"))), lang.NewKeyword("doc"), "Takes a reducing function f of 2 args and returns a fn suitable for\n transduce by adding an arity-1 signature that calls cf (default -\n identity) on the result argument.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6893), lang.NewKeyword("end-line"), int(6893))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("completing")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("identity")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v6, []any{v3, v9}) + return v10 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 lang.FnFunc + v5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + v6 := lang.Apply(v3, nil) + return v6 + case 1: + v6 := args[0] + _ = v6 + v7 := lang.Apply(v4, []any{v6}) + return v7 + case 2: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := lang.Apply(v3, []any{v6, v7}) + return v8 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6900), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(6903), lang.NewKeyword("end-column"), int(23)) + v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // concat + { + v0 := lang.NewSymbol("concat").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("zs"))), lang.NewKeyword("doc"), "Returns a lazy seq representing the concatenation of the elements in the supplied colls.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(711), lang.NewKeyword("end-line"), int(711))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + return nil + }) + v4 := lang.Apply(lang.NewLazySeq, []any{v3}) + return v4 + case 1: + v3 := args[0] + _ = v3 + var v4 lang.FnFunc + v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + return v3 + }) + v5 := lang.Apply(lang.NewLazySeq, []any{v4}) + return v5 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 lang.FnFunc + v5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v6 any + { // let + // let binding "s" + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("seq")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, []any{v3}) + var v11 any = v10 + _ = v11 + var v12 any + if lang.IsTruthy(v11) { + var v13 any + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("chunked-seq?")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{v11}) + if lang.IsTruthy(v17) { + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("chunk-cons")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("chunk-first")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.Apply(v23, []any{v11}) + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("concat")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("chunk-rest")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.Apply(v30, []any{v11}) + v32 := lang.Apply(v27, []any{v31, v4}) + v33 := lang.Apply(v20, []any{v24, v32}) + v13 = v33 + } else { + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("cons")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("first")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.Apply(v39, []any{v11}) + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("concat")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("rest")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.Apply(v46, []any{v11}) + v48 := lang.Apply(v43, []any{v47, v4}) + v49 := lang.Apply(v36, []any{v40, v48}) + v13 = v49 + } + v12 = v13 + } else { + v12 = v4 + } + v6 = v12 + } // end let + return v6 + }) + v6 := lang.Apply(lang.NewLazySeq, []any{v5}) + return v6 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.NewList(args[2:]...) + var v6 any + { // let + // let binding "cat" + var v7 lang.FnFunc + { // function cat + v7 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v9 := args[0] + _ = v9 + v10 := args[1] + _ = v10 + var v11 lang.FnFunc + v11 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v12 any + { // let + // let binding "xys" + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("seq")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{v9}) + var v17 any = v16 + _ = v17 + var v18 any + if lang.IsTruthy(v17) { + var v19 any + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("chunked-seq?")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.Apply(v22, []any{v17}) + if lang.IsTruthy(v23) { + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("chunk-cons")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("chunk-first")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{v17}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("chunk-rest")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{v17}) + v35 := lang.Apply(v8, []any{v34, v10}) + v36 := lang.Apply(v26, []any{v30, v35}) + v19 = v36 + } else { + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("cons")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("first")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.Apply(v42, []any{v17}) + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("rest")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.Apply(v46, []any{v17}) + v48 := lang.Apply(v8, []any{v47, v10}) + v49 := lang.Apply(v39, []any{v43, v48}) + v19 = v49 + } + v18 = v19 + } else { + var v50 any + if lang.IsTruthy(v10) { + v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v52 := v51.FindInternedVar(lang.NewSymbol("first")) + if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) + } + v53 := v52.Get() + v54 := lang.Apply(v53, []any{v10}) + v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v56 := v55.FindInternedVar(lang.NewSymbol("next")) + if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) + } + v57 := v56.Get() + v58 := lang.Apply(v57, []any{v10}) + v59 := lang.Apply(v8, []any{v54, v58}) + v50 = v59 + } else { + v50 = nil + } + v18 = v50 + } + v12 = v18 + } // end let + return v12 + }) + v12 := lang.Apply(lang.NewLazySeq, []any{v11}) + return v12 + }) + v8 := v7 + _ = v8 + } + v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(726), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(735), lang.NewKeyword("end-column"), int(56)) + v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v10 any = v9 + _ = v10 + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("concat")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{v3, v4}) + v15 := lang.Apply(v10, []any{v14, v5}) + v6 = v15 + } // end let + return v6 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // cond + { + v0 := lang.NewSymbol("cond").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes a set of test/expr pairs. It evaluates each test one at a\n time. If a test returns logical true, cond evaluates and returns\n the value of the corresponding expr and doesn't evaluate any of the\n other tests or exprs. (cond) returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(569), lang.NewKeyword("end-line"), int(569))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.NewList(args[2:]...) + var v6 any + if lang.IsTruthy(v5) { + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("list")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("first")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{v5}) + var v14 any + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("next")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{v5}) + if lang.IsTruthy(v18) { + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("second")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{v5}) + v14 = v22 + } else { + v23 := lang.Apply(lang.NewIllegalArgumentError, []any{"cond requires an even number of forms"}) + panic(v23) + } + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("cons")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("next")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("next")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.Apply(v32, []any{v5}) + v34 := lang.Apply(v29, []any{v33}) + v35 := lang.Apply(v26, []any{lang.NewSymbol("glojure.core/cond"), v34}) + v36 := lang.Apply(v9, []any{lang.NewSymbol("if"), v13, v14, v35}) + v6 = v36 + } else { + v6 = nil + } + return v6 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // cond-> + { + v0 := lang.NewSymbol("cond->").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes an expression and a set of test/form pairs. Threads expr (via ->)\n through each form for which the corresponding test\n expression is true. Note that, unlike cond branching, cond-> threading does\n not short circuit after the first true test expression.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7564), lang.NewKeyword("end-line"), int(7564))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + _ = nil + var v7 any + { // let + // let binding "g" + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("gensym")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, nil) + var v12 any = v11 + _ = v12 + // let binding "steps" + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("map")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + var v16 lang.FnFunc + v16 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v17 := args[0] + _ = v17 + var v18 any + { // let + // let binding "vec__337" + var v19 any = v17 + _ = v19 + // let binding "test" + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("nth")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.Apply(v22, []any{v19, int64(0), nil}) + var v24 any = v23 + _ = v24 + // let binding "step" + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("nth")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.Apply(v27, []any{v19, int64(1), nil}) + var v29 any = v28 + _ = v29 + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("seq")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("concat")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("list")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v38, []any{lang.NewSymbol("if")}) + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("list")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.Apply(v42, []any{v24}) + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("list")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v48 := v47.FindInternedVar(lang.NewSymbol("seq")) + if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) + } + v49 := v48.Get() + v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v51 := v50.FindInternedVar(lang.NewSymbol("concat")) + if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) + } + v52 := v51.Get() + v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v54 := v53.FindInternedVar(lang.NewSymbol("list")) + if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) + } + v55 := v54.Get() + v56 := lang.Apply(v55, []any{lang.NewSymbol("glojure.core/->")}) + v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v58 := v57.FindInternedVar(lang.NewSymbol("list")) + if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) + } + v59 := v58.Get() + v60 := lang.Apply(v59, []any{v12}) + v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v62 := v61.FindInternedVar(lang.NewSymbol("list")) + if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) + } + v63 := v62.Get() + v64 := lang.Apply(v63, []any{v29}) + v65 := lang.Apply(v52, []any{v56, v60, v64}) + v66 := lang.Apply(v49, []any{v65}) + v67 := lang.Apply(v46, []any{v66}) + v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v69 := v68.FindInternedVar(lang.NewSymbol("list")) + if v69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) + } + v70 := v69.Get() + v71 := lang.Apply(v70, []any{v12}) + v72 := lang.Apply(v35, []any{v39, v43, v67, v71}) + v73 := lang.Apply(v32, []any{v72}) + v18 = v73 + } // end let + return v18 + }) + v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7573), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7573), lang.NewKeyword("end-column"), int(66)) + v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("partition")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{int64(2), v6}) + v23 := lang.Apply(v15, []any{v18, v22}) + var v24 any = v23 + _ = v24 + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("seq")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("concat")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/let")}) + v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v36 := v35.FindInternedVar(lang.NewSymbol("list")) + if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + } + v37 := v36.Get() + v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v39 := v38.FindInternedVar(lang.NewSymbol("apply")) + if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + } + v40 := v39.Get() + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("vector")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("seq")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v48 := v47.FindInternedVar(lang.NewSymbol("concat")) + if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) + } + v49 := v48.Get() + v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v51 := v50.FindInternedVar(lang.NewSymbol("list")) + if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) + } + v52 := v51.Get() + v53 := lang.Apply(v52, []any{v12}) + v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v55 := v54.FindInternedVar(lang.NewSymbol("list")) + if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) + } + v56 := v55.Get() + v57 := lang.Apply(v56, []any{v5}) + v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v59 := v58.FindInternedVar(lang.NewSymbol("interleave")) + if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) + } + v60 := v59.Get() + v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v62 := v61.FindInternedVar(lang.NewSymbol("repeat")) + if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) + } + v63 := v62.Get() + v64 := lang.Apply(v63, []any{v12}) + v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v66 := v65.FindInternedVar(lang.NewSymbol("butlast")) + if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) + } + v67 := v66.Get() + v68 := lang.Apply(v67, []any{v24}) + v69 := lang.Apply(v60, []any{v64, v68}) + v70 := lang.Apply(v49, []any{v53, v57, v69}) + v71 := lang.Apply(v46, []any{v70}) + v72 := lang.Apply(v40, []any{v43, v71}) + v73 := lang.Apply(v37, []any{v72}) + v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v75 := v74.FindInternedVar(lang.NewSymbol("list")) + if v75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) + } + v76 := v75.Get() + var v77 any + v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v79 := v78.FindInternedVar(lang.NewSymbol("empty?")) + if v79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) + } + v80 := v79.Get() + v81 := lang.Apply(v80, []any{v24}) + if lang.IsTruthy(v81) { + v77 = v12 + } else { + v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v83 := v82.FindInternedVar(lang.NewSymbol("last")) + if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) + } + v84 := v83.Get() + v85 := lang.Apply(v84, []any{v24}) + v77 = v85 + } + v86 := lang.Apply(v76, []any{v77}) + v87 := lang.Apply(v30, []any{v34, v73, v86}) + v88 := lang.Apply(v27, []any{v87}) + v7 = v88 + } // end let + return v7 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // cond->> + { + v0 := lang.NewSymbol("cond->>").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes an expression and a set of test/form pairs. Threads expr (via ->>)\n through each form for which the corresponding test expression\n is true. Note that, unlike cond branching, cond->> threading does not short circuit\n after the first true test expression.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7581), lang.NewKeyword("end-line"), int(7581))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + _ = nil + var v7 any + { // let + // let binding "g" + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("gensym")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, nil) + var v12 any = v11 + _ = v12 + // let binding "steps" + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("map")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + var v16 lang.FnFunc + v16 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v17 := args[0] + _ = v17 + var v18 any + { // let + // let binding "vec__341" + var v19 any = v17 + _ = v19 + // let binding "test" + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("nth")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.Apply(v22, []any{v19, int64(0), nil}) + var v24 any = v23 + _ = v24 + // let binding "step" + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("nth")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.Apply(v27, []any{v19, int64(1), nil}) + var v29 any = v28 + _ = v29 + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("seq")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("concat")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("list")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v38, []any{lang.NewSymbol("if")}) + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("list")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.Apply(v42, []any{v24}) + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("list")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v48 := v47.FindInternedVar(lang.NewSymbol("seq")) + if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) + } + v49 := v48.Get() + v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v51 := v50.FindInternedVar(lang.NewSymbol("concat")) + if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) + } + v52 := v51.Get() + v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v54 := v53.FindInternedVar(lang.NewSymbol("list")) + if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) + } + v55 := v54.Get() + v56 := lang.Apply(v55, []any{lang.NewSymbol("glojure.core/->>")}) + v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v58 := v57.FindInternedVar(lang.NewSymbol("list")) + if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) + } + v59 := v58.Get() + v60 := lang.Apply(v59, []any{v12}) + v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v62 := v61.FindInternedVar(lang.NewSymbol("list")) + if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) + } + v63 := v62.Get() + v64 := lang.Apply(v63, []any{v29}) + v65 := lang.Apply(v52, []any{v56, v60, v64}) + v66 := lang.Apply(v49, []any{v65}) + v67 := lang.Apply(v46, []any{v66}) + v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v69 := v68.FindInternedVar(lang.NewSymbol("list")) + if v69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) + } + v70 := v69.Get() + v71 := lang.Apply(v70, []any{v12}) + v72 := lang.Apply(v35, []any{v39, v43, v67, v71}) + v73 := lang.Apply(v32, []any{v72}) + v18 = v73 + } // end let + return v18 + }) + v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7590), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7590), lang.NewKeyword("end-column"), int(67)) + v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("partition")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{int64(2), v6}) + v23 := lang.Apply(v15, []any{v18, v22}) + var v24 any = v23 + _ = v24 + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("seq")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("concat")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/let")}) + v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v36 := v35.FindInternedVar(lang.NewSymbol("list")) + if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + } + v37 := v36.Get() + v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v39 := v38.FindInternedVar(lang.NewSymbol("apply")) + if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + } + v40 := v39.Get() + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("vector")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("seq")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v48 := v47.FindInternedVar(lang.NewSymbol("concat")) + if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) + } + v49 := v48.Get() + v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v51 := v50.FindInternedVar(lang.NewSymbol("list")) + if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) + } + v52 := v51.Get() + v53 := lang.Apply(v52, []any{v12}) + v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v55 := v54.FindInternedVar(lang.NewSymbol("list")) + if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) + } + v56 := v55.Get() + v57 := lang.Apply(v56, []any{v5}) + v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v59 := v58.FindInternedVar(lang.NewSymbol("interleave")) + if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) + } + v60 := v59.Get() + v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v62 := v61.FindInternedVar(lang.NewSymbol("repeat")) + if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) + } + v63 := v62.Get() + v64 := lang.Apply(v63, []any{v12}) + v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v66 := v65.FindInternedVar(lang.NewSymbol("butlast")) + if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) + } + v67 := v66.Get() + v68 := lang.Apply(v67, []any{v24}) + v69 := lang.Apply(v60, []any{v64, v68}) + v70 := lang.Apply(v49, []any{v53, v57, v69}) + v71 := lang.Apply(v46, []any{v70}) + v72 := lang.Apply(v40, []any{v43, v71}) + v73 := lang.Apply(v37, []any{v72}) + v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v75 := v74.FindInternedVar(lang.NewSymbol("list")) + if v75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) + } + v76 := v75.Get() + var v77 any + v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v79 := v78.FindInternedVar(lang.NewSymbol("empty?")) + if v79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) + } + v80 := v79.Get() + v81 := lang.Apply(v80, []any{v24}) + if lang.IsTruthy(v81) { + v77 = v12 + } else { + v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v83 := v82.FindInternedVar(lang.NewSymbol("last")) + if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) + } + v84 := v83.Get() + v85 := lang.Apply(v84, []any{v24}) + v77 = v85 + } + v86 := lang.Apply(v76, []any{v77}) + v87 := lang.Apply(v30, []any{v34, v73, v86}) + v88 := lang.Apply(v27, []any{v87}) + v7 = v88 + } // end let + return v7 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // condp + { + v0 := lang.NewSymbol("condp").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes a binary predicate, an expression, and a set of clauses.\n Each clause can take the form of either:\n\n test-expr result-expr\n\n test-expr :>> result-fn\n\n Note :>> is an ordinary keyword.\n\n For each clause, (pred test-expr expr) is evaluated. If it returns\n logical true, the clause is a match. If a binary clause matches, the\n result-expr is returned, if a ternary clause matches, its result-fn,\n which must be a unary function, is called with the result of the\n predicate as its argument, the result of that call being the return\n value of condp. A single default expression can follow the clauses,\n and its value will be returned if no clause matches. If no default\n expression is provided and no clause matches, an\n IllegalArgumentException is thrown.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6353), lang.NewKeyword("end-line"), int(6353))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := lang.NewList(args[4:]...) + var v8 any + { // let + // let binding "gpred" + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("gensym")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.Apply(v11, []any{"pred__"}) + var v13 any = v12 + _ = v13 + // let binding "gexpr" + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("gensym")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{"expr__"}) + var v18 any = v17 + _ = v18 + // let binding "emit" + var v19 lang.FnFunc + { // function emit + v19 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v21 := args[0] + _ = v21 + v22 := args[1] + _ = v22 + v23 := args[2] + _ = v23 + var v24 any + { // let + // let binding "vec__144" + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("split-at")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + var v28 any + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("=")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("second")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{v23}) + v36 := lang.Apply(v31, []any{lang.NewKeyword(">>"), v35}) + if lang.IsTruthy(v36) { + v28 = int64(3) + } else { + v28 = int64(2) + } + v37 := lang.Apply(v27, []any{v28, v23}) + var v38 any = v37 + _ = v38 + // let binding "vec__147" + v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v40 := v39.FindInternedVar(lang.NewSymbol("nth")) + if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) + } + v41 := v40.Get() + v42 := lang.Apply(v41, []any{v38, int64(0), nil}) + var v43 any = v42 + _ = v43 + // let binding "a" + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("nth")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.Apply(v46, []any{v43, int64(0), nil}) + var v48 any = v47 + _ = v48 + // let binding "b" + v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v50 := v49.FindInternedVar(lang.NewSymbol("nth")) + if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) + } + v51 := v50.Get() + v52 := lang.Apply(v51, []any{v43, int64(1), nil}) + var v53 any = v52 + _ = v53 + // let binding "c" + v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v55 := v54.FindInternedVar(lang.NewSymbol("nth")) + if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) + } + v56 := v55.Get() + v57 := lang.Apply(v56, []any{v43, int64(2), nil}) + var v58 any = v57 + _ = v58 + // let binding "clause" + var v59 any = v43 + _ = v59 + // let binding "more" + v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v61 := v60.FindInternedVar(lang.NewSymbol("nth")) + if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) + } + v62 := v61.Get() + v63 := lang.Apply(v62, []any{v38, int64(1), nil}) + var v64 any = v63 + _ = v64 + // let binding "n" + v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v66 := v65.FindInternedVar(lang.NewSymbol("count")) + if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) + } + v67 := v66.Get() + v68 := lang.Apply(v67, []any{v59}) + var v69 any = v68 + _ = v69 + var v70 any + v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v72 := v71.FindInternedVar(lang.NewSymbol("=")) + if v72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) + } + v73 := v72.Get() + v74 := lang.Apply(v73, []any{int64(0), v69}) + if lang.IsTruthy(v74) { + v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v76 := v75.FindInternedVar(lang.NewSymbol("seq")) + if v76.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) + } + v77 := v76.Get() + v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v79 := v78.FindInternedVar(lang.NewSymbol("concat")) + if v79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) + } + v80 := v79.Get() + v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v82 := v81.FindInternedVar(lang.NewSymbol("list")) + if v82.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) + } + v83 := v82.Get() + v84 := lang.Apply(v83, []any{lang.NewSymbol("throw")}) + v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v86 := v85.FindInternedVar(lang.NewSymbol("list")) + if v86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) + } + v87 := v86.Get() + v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v89 := v88.FindInternedVar(lang.NewSymbol("seq")) + if v89.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) + } + v90 := v89.Get() + v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v92 := v91.FindInternedVar(lang.NewSymbol("concat")) + if v92.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) + } + v93 := v92.Get() + v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v95 := v94.FindInternedVar(lang.NewSymbol("list")) + if v95.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) + } + v96 := v95.Get() + v97 := lang.Apply(v96, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewIllegalArgumentError")}) + v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v99 := v98.FindInternedVar(lang.NewSymbol("list")) + if v99.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) + } + v100 := v99.Get() + v101 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v102 := v101.FindInternedVar(lang.NewSymbol("seq")) + if v102.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v102))) + } + v103 := v102.Get() + v104 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v105 := v104.FindInternedVar(lang.NewSymbol("concat")) + if v105.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v105))) + } + v106 := v105.Get() + v107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v108 := v107.FindInternedVar(lang.NewSymbol("list")) + if v108.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v108))) + } + v109 := v108.Get() + v110 := lang.Apply(v109, []any{lang.NewSymbol("glojure.core/str")}) + v111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v112 := v111.FindInternedVar(lang.NewSymbol("list")) + if v112.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v112))) + } + v113 := v112.Get() + v114 := lang.Apply(v113, []any{"No matching clause: "}) + v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v116 := v115.FindInternedVar(lang.NewSymbol("list")) + if v116.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) + } + v117 := v116.Get() + v118 := lang.Apply(v117, []any{v22}) + v119 := lang.Apply(v106, []any{v110, v114, v118}) + v120 := lang.Apply(v103, []any{v119}) + v121 := lang.Apply(v100, []any{v120}) + v122 := lang.Apply(v93, []any{v97, v121}) + v123 := lang.Apply(v90, []any{v122}) + v124 := lang.Apply(v87, []any{v123}) + v125 := lang.Apply(v80, []any{v84, v124}) + v126 := lang.Apply(v77, []any{v125}) + v70 = v126 + } else { + var v127 any + v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v129 := v128.FindInternedVar(lang.NewSymbol("=")) + if v129.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v129))) + } + v130 := v129.Get() + v131 := lang.Apply(v130, []any{int64(1), v69}) + if lang.IsTruthy(v131) { + v127 = v48 + } else { + var v132 any + v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v134 := v133.FindInternedVar(lang.NewSymbol("=")) + if v134.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) + } + v135 := v134.Get() + v136 := lang.Apply(v135, []any{int64(2), v69}) + if lang.IsTruthy(v136) { + v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v138 := v137.FindInternedVar(lang.NewSymbol("seq")) + if v138.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) + } + v139 := v138.Get() + v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v141 := v140.FindInternedVar(lang.NewSymbol("concat")) + if v141.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) + } + v142 := v141.Get() + v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v144 := v143.FindInternedVar(lang.NewSymbol("list")) + if v144.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) + } + v145 := v144.Get() + v146 := lang.Apply(v145, []any{lang.NewSymbol("if")}) + v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v148 := v147.FindInternedVar(lang.NewSymbol("list")) + if v148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) + } + v149 := v148.Get() + v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v151 := v150.FindInternedVar(lang.NewSymbol("seq")) + if v151.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) + } + v152 := v151.Get() + v153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v154 := v153.FindInternedVar(lang.NewSymbol("concat")) + if v154.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v154))) + } + v155 := v154.Get() + v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v157 := v156.FindInternedVar(lang.NewSymbol("list")) + if v157.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) + } + v158 := v157.Get() + v159 := lang.Apply(v158, []any{v21}) + v160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v161 := v160.FindInternedVar(lang.NewSymbol("list")) + if v161.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v161))) + } + v162 := v161.Get() + v163 := lang.Apply(v162, []any{v48}) + v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v165 := v164.FindInternedVar(lang.NewSymbol("list")) + if v165.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) + } + v166 := v165.Get() + v167 := lang.Apply(v166, []any{v22}) + v168 := lang.Apply(v155, []any{v159, v163, v167}) + v169 := lang.Apply(v152, []any{v168}) + v170 := lang.Apply(v149, []any{v169}) + v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v172 := v171.FindInternedVar(lang.NewSymbol("list")) + if v172.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) + } + v173 := v172.Get() + v174 := lang.Apply(v173, []any{v53}) + v175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v176 := v175.FindInternedVar(lang.NewSymbol("list")) + if v176.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v176))) + } + v177 := v176.Get() + v178 := lang.Apply(v20, []any{v21, v22, v64}) + v179 := lang.Apply(v177, []any{v178}) + v180 := lang.Apply(v142, []any{v146, v170, v174, v179}) + v181 := lang.Apply(v139, []any{v180}) + v132 = v181 + } else { + var v182 any + if lang.IsTruthy(lang.NewKeyword("else")) { + v183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v184 := v183.FindInternedVar(lang.NewSymbol("seq")) + if v184.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v184))) + } + v185 := v184.Get() + v186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v187 := v186.FindInternedVar(lang.NewSymbol("concat")) + if v187.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v187))) + } + v188 := v187.Get() + v189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v190 := v189.FindInternedVar(lang.NewSymbol("list")) + if v190.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v190))) + } + v191 := v190.Get() + v192 := lang.Apply(v191, []any{lang.NewSymbol("glojure.core/if-let")}) + v193 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v194 := v193.FindInternedVar(lang.NewSymbol("list")) + if v194.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v194))) + } + v195 := v194.Get() + v196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v197 := v196.FindInternedVar(lang.NewSymbol("apply")) + if v197.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v197))) + } + v198 := v197.Get() + v199 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v200 := v199.FindInternedVar(lang.NewSymbol("vector")) + if v200.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v200))) + } + v201 := v200.Get() + v202 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v203 := v202.FindInternedVar(lang.NewSymbol("seq")) + if v203.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v203))) + } + v204 := v203.Get() + v205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v206 := v205.FindInternedVar(lang.NewSymbol("concat")) + if v206.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v206))) + } + v207 := v206.Get() + v208 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v209 := v208.FindInternedVar(lang.NewSymbol("list")) + if v209.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v209))) + } + v210 := v209.Get() + v211 := lang.Apply(v210, []any{lang.NewSymbol("p__0__auto__")}) + v212 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v213 := v212.FindInternedVar(lang.NewSymbol("list")) + if v213.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v213))) + } + v214 := v213.Get() + v215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v216 := v215.FindInternedVar(lang.NewSymbol("seq")) + if v216.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v216))) + } + v217 := v216.Get() + v218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v219 := v218.FindInternedVar(lang.NewSymbol("concat")) + if v219.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v219))) + } + v220 := v219.Get() + v221 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v222 := v221.FindInternedVar(lang.NewSymbol("list")) + if v222.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v222))) + } + v223 := v222.Get() + v224 := lang.Apply(v223, []any{v21}) + v225 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v226 := v225.FindInternedVar(lang.NewSymbol("list")) + if v226.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v226))) + } + v227 := v226.Get() + v228 := lang.Apply(v227, []any{v48}) + v229 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v230 := v229.FindInternedVar(lang.NewSymbol("list")) + if v230.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v230))) + } + v231 := v230.Get() + v232 := lang.Apply(v231, []any{v22}) + v233 := lang.Apply(v220, []any{v224, v228, v232}) + v234 := lang.Apply(v217, []any{v233}) + v235 := lang.Apply(v214, []any{v234}) + v236 := lang.Apply(v207, []any{v211, v235}) + v237 := lang.Apply(v204, []any{v236}) + v238 := lang.Apply(v198, []any{v201, v237}) + v239 := lang.Apply(v195, []any{v238}) + v240 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v241 := v240.FindInternedVar(lang.NewSymbol("list")) + if v241.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v241))) + } + v242 := v241.Get() + v243 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v244 := v243.FindInternedVar(lang.NewSymbol("seq")) + if v244.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v244))) + } + v245 := v244.Get() + v246 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v247 := v246.FindInternedVar(lang.NewSymbol("concat")) + if v247.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v247))) + } + v248 := v247.Get() + v249 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v250 := v249.FindInternedVar(lang.NewSymbol("list")) + if v250.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v250))) + } + v251 := v250.Get() + v252 := lang.Apply(v251, []any{v58}) + v253 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v254 := v253.FindInternedVar(lang.NewSymbol("list")) + if v254.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v254))) + } + v255 := v254.Get() + v256 := lang.Apply(v255, []any{lang.NewSymbol("p__0__auto__")}) + v257 := lang.Apply(v248, []any{v252, v256}) + v258 := lang.Apply(v245, []any{v257}) + v259 := lang.Apply(v242, []any{v258}) + v260 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v261 := v260.FindInternedVar(lang.NewSymbol("list")) + if v261.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v261))) + } + v262 := v261.Get() + v263 := lang.Apply(v20, []any{v21, v22, v64}) + v264 := lang.Apply(v262, []any{v263}) + v265 := lang.Apply(v188, []any{v192, v239, v259, v264}) + v266 := lang.Apply(v185, []any{v265}) + v182 = v266 + } else { + v182 = nil + } + v132 = v182 + } + v127 = v132 + } + v70 = v127 + } + v24 = v70 + } // end let + return v24 + }) + v20 := v19 + _ = v20 + } + v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6377), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(6389), lang.NewKeyword("end-column"), int(53)) + v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v22 any = v21 + _ = v22 + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("seq")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("concat")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("list")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.Apply(v31, []any{lang.NewSymbol("glojure.core/let")}) + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("list")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("apply")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v40 := v39.FindInternedVar(lang.NewSymbol("vector")) + if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) + } + v41 := v40.Get() + v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v43 := v42.FindInternedVar(lang.NewSymbol("seq")) + if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) + } + v44 := v43.Get() + v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v46 := v45.FindInternedVar(lang.NewSymbol("concat")) + if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) + } + v47 := v46.Get() + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("list")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v13}) + v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v53 := v52.FindInternedVar(lang.NewSymbol("list")) + if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) + } + v54 := v53.Get() + v55 := lang.Apply(v54, []any{v5}) + v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v57 := v56.FindInternedVar(lang.NewSymbol("list")) + if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) + } + v58 := v57.Get() + v59 := lang.Apply(v58, []any{v18}) + v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v61 := v60.FindInternedVar(lang.NewSymbol("list")) + if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) + } + v62 := v61.Get() + v63 := lang.Apply(v62, []any{v6}) + v64 := lang.Apply(v47, []any{v51, v55, v59, v63}) + v65 := lang.Apply(v44, []any{v64}) + v66 := lang.Apply(v38, []any{v41, v65}) + v67 := lang.Apply(v35, []any{v66}) + v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v69 := v68.FindInternedVar(lang.NewSymbol("list")) + if v69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) + } + v70 := v69.Get() + v71 := lang.Apply(v22, []any{v13, v18, v7}) + v72 := lang.Apply(v70, []any{v71}) + v73 := lang.Apply(v28, []any{v32, v67, v72}) + v74 := lang.Apply(v25, []any{v73}) + v8 = v74 + } // end let + return v8 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // conj + { + v0 := lang.NewSymbol("conj").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("xs"))), lang.NewKeyword("doc"), "conj[oin]. Returns a new collection with the xs\n 'added'. (conj nil item) returns (item).\n (conj coll) returns coll. (conj) returns [].\n The 'addition' may happen at different 'places' depending\n on the concrete type.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(73), lang.NewKeyword("end-line"), int(81))).(*lang.Symbol) + var v2 lang.FnFunc + { // function conj + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + v4 := lang.NewVector() + v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(82), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(82), lang.NewKeyword("end-column"), int(14)) + v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v6 + case 1: + v4 := args[0] + _ = v4 + return v4 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := lang.Apply(lang.Conj, []any{v4, v5}) + return v6 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := lang.NewList(args[2:]...) + recur_loop_10: + var v7 any + if lang.IsTruthy(v6) { + v9 := lang.Apply(lang.Conj, []any{v4, v5}) + var v8 any = v9 + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("first")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{v6}) + var v10 any = v14 + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("next")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{v6}) + var v15 any = v19 + v4 = v8 + v5 = v10 + v6 = v15 + goto recur_loop_10 + } else { + v20 := lang.Apply(lang.Conj, []any{v4, v5}) + v7 = v20 + } + return v7 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(81), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(88), lang.NewKeyword("end-column"), int(67))).(lang.FnFunc) + v3 := v2 + _ = v3 + } + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // conj! + { + v0 := lang.NewSymbol("conj!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Adds x to the transient collection, and return coll. The 'addition'\n may happen at different 'places' depending on the concrete type.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3359), lang.NewKeyword("end-line"), int(3359))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v4 := v3.FindInternedVar(lang.NewSymbol("transient")) + if v4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) + } + v5 := v4.Get() + v6 := lang.NewVector() + v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3364), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(3364), lang.NewKeyword("end-column"), int(19)) + v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v9 := lang.Apply(v5, []any{v8}) + return v9 + case 1: + v3 := args[0] + _ = v3 + return v3 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5, _ := lang.FieldOrMethod(v3, "Conj") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Conj is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // cons + { + v0 := lang.NewSymbol("cons").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("seq"))), lang.NewKeyword("doc"), "Returns a new seq where x is the first element and seq is\n the rest.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(21), lang.NewKeyword("end-line"), int(27))).(*lang.Symbol) + var v2 lang.FnFunc + { // function cons + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := lang.Apply(lang.NewCons, []any{v4, v5}) + return v6 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(27), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(27), lang.NewKeyword("end-column"), int(89))).(lang.FnFunc) + v3 := v2 + _ = v3 + } + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // constantly + { + v0 := lang.NewSymbol("constantly").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns a function that takes any number of arguments and returns x.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1440), lang.NewKeyword("end-line"), int(1440))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 lang.FnFunc + v4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := lang.NewList(args[0:]...) + return v3 + } + }) + v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1444), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(1444), lang.NewKeyword("end-column"), int(21)) + v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v6 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // contains? + { + v0 := lang.NewSymbol("contains?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("key"))), lang.NewKeyword("doc"), "Returns true if key is present in the given collection, otherwise\n returns false. Note that for numerically indexed collections like\n vectors and Java arrays, this tests if the numeric key is within the\n range of indexes. 'contains?' operates constant or logarithmic time;\n it will not perform a linear search for a value. See also 'some'.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1479), lang.NewKeyword("end-line"), int(1479))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5, _ := lang.FieldOrMethod(runtime4.RT, "Contains") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Contains is not a function"))) + } + v6 := lang.Apply(v5, []any{v3, v4}) + return v6 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // count + { + var v1 lang.FnFunc + { // function count__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("concat")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("list")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("seq")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("concat")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/Count")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{v3}) + v35 := lang.Apply(v26, []any{v30, v34}) + v36 := lang.Apply(v23, []any{v35}) + v37 := lang.Apply(v20, []any{v36}) + v38 := lang.Apply(v9, []any{v13, v17, v37}) + v39 := lang.Apply(v6, []any{v38}) + return v39 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("count").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the number of items in the collection. (count nil) returns\n 0. Also works on strings, arrays, and Java Collections and Maps", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(867), lang.NewKeyword("end-line"), int(867))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := lang.Apply(lang.Count, []any{v4}) + return v5 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // counted? + { + v0 := lang.NewSymbol("counted?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements count in constant time", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6241), lang.NewKeyword("end-line"), int(6241))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.Apply(v6, []any{lang.Counted, v3}) + return v7 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // create-ns + { + v0 := lang.NewSymbol("create-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Create a new namespace named by the symbol if one doesn't already\n exist, returns it or the already-existing namespace of the same\n name.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4131), lang.NewKeyword("end-line"), int(4131))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.Apply(nil, []any{v3}) + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // create-struct + { + v0 := lang.NewSymbol("create-struct").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keys"))), lang.NewKeyword("doc"), "Returns a structure basis object.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4037), lang.NewKeyword("end-line"), int(4037))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := lang.NewList(args[0:]...) + v4 := lang.Apply(lang.CreatePersistentStructMapSlotMap, []any{v3}) + return v4 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // cycle + { + v0 := lang.NewSymbol("cycle").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy (infinite!) sequence of repetitions of the items in coll.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2977), lang.NewKeyword("end-line"), int(2977))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.Apply(v6, []any{v3}) + v8 := lang.Apply(lang.NewCycle, []any{v7}) + return v8 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // data-reader-urls + { + v0 := lang.NewSymbol("data-reader-urls").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7830), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7830), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + return lang.NewList() + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // data-reader-var + { + v0 := lang.NewSymbol("data-reader-var").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7832), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7832), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("intern")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("create-ns")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("symbol")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("namespace")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{v3}) + v17 := lang.Apply(v12, []any{v16}) + v18 := lang.Apply(v9, []any{v17}) + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("symbol")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("name")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v3}) + v26 := lang.Apply(v21, []any{v25}) + v27 := lang.Apply(v6, []any{v18, v26}) + return v27 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // dec + { + var v1 lang.FnFunc + { // function dec__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("concat")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("list")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("seq")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("concat")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + var v30 any + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + if lang.IsTruthy(v33) { + v30 = lang.NewSymbol("unchecked_dec") + } else { + v30 = lang.NewSymbol("dec") + } + v34 := lang.Apply(v29, []any{v30}) + v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v36 := v35.FindInternedVar(lang.NewSymbol("list")) + if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + } + v37 := v36.Get() + v38 := lang.Apply(v37, []any{v3}) + v39 := lang.Apply(v26, []any{v34, v38}) + v40 := lang.Apply(v23, []any{v39}) + v41 := lang.Apply(v20, []any{v40}) + v42 := lang.Apply(v9, []any{v13, v17, v41}) + v43 := lang.Apply(v6, []any{v42}) + return v43 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("dec").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns a number one less than num. Does not auto-promote\n longs, will throw on overflow. See also: dec'", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1147), lang.NewKeyword("end-line"), int(1147))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5, _ := lang.FieldOrMethod(lang.Numbers, "Dec") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Dec is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // dec' + { + var v1 lang.FnFunc + { // function dec'__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("concat")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("list")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("seq")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("concat")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/DecP")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{v3}) + v35 := lang.Apply(v26, []any{v30, v34}) + v36 := lang.Apply(v23, []any{v35}) + v37 := lang.Apply(v20, []any{v36}) + v38 := lang.Apply(v9, []any{v13, v17, v37}) + v39 := lang.Apply(v6, []any{v38}) + return v39 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("dec'").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns a number one less than num. Supports arbitrary precision.\n See also: dec", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1140), lang.NewKeyword("end-line"), int(1140))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5, _ := lang.FieldOrMethod(lang.Numbers, "DecP") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("DecP is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // decimal? + { + v0 := lang.NewSymbol("decimal?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is a BigDecimal", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3599), lang.NewKeyword("end-line"), int(3599))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.Apply(v6, []any{*lang.BigDecimal, v3}) + return v7 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // declare + { + v0 := lang.NewSymbol("declare").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("names"))), lang.NewKeyword("doc"), "defs the supplied var names with no bindings, useful for making forward declarations.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(2768), lang.NewKeyword("end-line"), int(2768))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.NewList(args[2:]...) + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("seq")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("concat")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("list")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.Apply(v14, []any{lang.NewSymbol("do")}) + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("map")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + var v19 lang.FnFunc + v19 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v20 := args[0] + _ = v20 + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("list")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("vary-meta")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("assoc")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v26, []any{v20, v29, lang.NewKeyword("declared"), true}) + v31 := lang.Apply(v23, []any{lang.NewSymbol("def"), v30}) + return v31 + }) + v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2771), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(2771), lang.NewKeyword("end-column"), int(71)) + v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v22 := lang.Apply(v18, []any{v21, v5}) + v23 := lang.Apply(v11, []any{v15, v22}) + v24 := lang.Apply(v8, []any{v23}) + return v24 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // dedupe + { + v0 := lang.NewSymbol("dedupe").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence removing consecutive duplicates in coll.\n Returns a transducer when no collection is provided.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7681), lang.NewKeyword("end-line"), int(7681))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + var v5 any + { // let + // let binding "pv" + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("volatile!")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{lang.NewKeyword("glojure.core/none")}) + var v10 any = v9 + _ = v10 + var v11 lang.FnFunc + v11 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + v12 := lang.Apply(v4, nil) + return v12 + case 1: + v12 := args[0] + _ = v12 + v13 := lang.Apply(v4, []any{v12}) + return v13 + case 2: + v12 := args[0] + _ = v12 + v13 := args[1] + _ = v13 + var v14 any + { // let + // let binding "prior" + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("deref")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{v10}) + var v19 any = v18 + _ = v19 + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("vreset!")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.Apply(v22, []any{v10, v13}) + _ = v23 + var v24 any + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("=")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.Apply(v27, []any{v19, v13}) + if lang.IsTruthy(v28) { + v24 = v12 + } else { + v29 := lang.Apply(v4, []any{v12, v13}) + v24 = v29 + } + v14 = v24 + } // end let + return v14 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7688), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7696), lang.NewKeyword("end-column"), int(37)) + v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v5 = v13 + } // end let + return v5 + }) + v4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7686), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7696), lang.NewKeyword("end-column"), int(39)) + v5, err := lang.WithMeta(v3, v4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v5 + case 1: + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("sequence")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("dedupe")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, nil) + v11 := lang.Apply(v6, []any{v10, v3}) + return v11 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // def-aset + { + v0 := lang.NewSymbol("def-aset").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("method"), lang.NewSymbol("coerce"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3935), lang.NewKeyword("end-line"), int(3936), lang.NewKeyword("private"), true)).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 5 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := args[4] + _ = v7 + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("seq")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("concat")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("glojure.core/defn")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.Apply(v20, []any{v5}) + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("list")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("apply")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("hash-map")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("seq")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("concat")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("list")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.Apply(v39, []any{lang.NewKeyword("arglists")}) + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("list")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("seq")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v48 := v47.FindInternedVar(lang.NewSymbol("concat")) + if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) + } + v49 := v48.Get() + v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v51 := v50.FindInternedVar(lang.NewSymbol("list")) + if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) + } + v52 := v51.Get() + v53 := lang.Apply(v52, []any{lang.NewSymbol("quote")}) + v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v55 := v54.FindInternedVar(lang.NewSymbol("list")) + if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) + } + v56 := v55.Get() + v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v58 := v57.FindInternedVar(lang.NewSymbol("seq")) + if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) + } + v59 := v58.Get() + v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v61 := v60.FindInternedVar(lang.NewSymbol("concat")) + if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) + } + v62 := v61.Get() + v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v64 := v63.FindInternedVar(lang.NewSymbol("list")) + if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) + } + v65 := v64.Get() + v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v67 := v66.FindInternedVar(lang.NewSymbol("apply")) + if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) + } + v68 := v67.Get() + v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v70 := v69.FindInternedVar(lang.NewSymbol("vector")) + if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) + } + v71 := v70.Get() + v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v73 := v72.FindInternedVar(lang.NewSymbol("seq")) + if v73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) + } + v74 := v73.Get() + v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v76 := v75.FindInternedVar(lang.NewSymbol("concat")) + if v76.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) + } + v77 := v76.Get() + v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v79 := v78.FindInternedVar(lang.NewSymbol("list")) + if v79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) + } + v80 := v79.Get() + v81 := lang.Apply(v80, []any{lang.NewSymbol("array")}) + v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v83 := v82.FindInternedVar(lang.NewSymbol("list")) + if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) + } + v84 := v83.Get() + v85 := lang.Apply(v84, []any{lang.NewSymbol("idx")}) + v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v87 := v86.FindInternedVar(lang.NewSymbol("list")) + if v87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) + } + v88 := v87.Get() + v89 := lang.Apply(v88, []any{lang.NewSymbol("val")}) + v90 := lang.Apply(v77, []any{v81, v85, v89}) + v91 := lang.Apply(v74, []any{v90}) + v92 := lang.Apply(v68, []any{v71, v91}) + v93 := lang.Apply(v65, []any{v92}) + v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v95 := v94.FindInternedVar(lang.NewSymbol("list")) + if v95.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) + } + v96 := v95.Get() + v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v98 := v97.FindInternedVar(lang.NewSymbol("apply")) + if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) + } + v99 := v98.Get() + v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v101 := v100.FindInternedVar(lang.NewSymbol("vector")) + if v101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) + } + v102 := v101.Get() + v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v104 := v103.FindInternedVar(lang.NewSymbol("seq")) + if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) + } + v105 := v104.Get() + v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v107 := v106.FindInternedVar(lang.NewSymbol("concat")) + if v107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) + } + v108 := v107.Get() + v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v110 := v109.FindInternedVar(lang.NewSymbol("list")) + if v110.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) + } + v111 := v110.Get() + v112 := lang.Apply(v111, []any{lang.NewSymbol("array")}) + v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v114 := v113.FindInternedVar(lang.NewSymbol("list")) + if v114.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) + } + v115 := v114.Get() + v116 := lang.Apply(v115, []any{lang.NewSymbol("idx")}) + v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v118 := v117.FindInternedVar(lang.NewSymbol("list")) + if v118.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) + } + v119 := v118.Get() + v120 := lang.Apply(v119, []any{lang.NewSymbol("idx2")}) + v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v122 := v121.FindInternedVar(lang.NewSymbol("list")) + if v122.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) + } + v123 := v122.Get() + v124 := lang.Apply(v123, []any{lang.NewSymbol("&")}) + v125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v126 := v125.FindInternedVar(lang.NewSymbol("list")) + if v126.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v126))) + } + v127 := v126.Get() + v128 := lang.Apply(v127, []any{lang.NewSymbol("idxv")}) + v129 := lang.Apply(v108, []any{v112, v116, v120, v124, v128}) + v130 := lang.Apply(v105, []any{v129}) + v131 := lang.Apply(v99, []any{v102, v130}) + v132 := lang.Apply(v96, []any{v131}) + v133 := lang.Apply(v62, []any{v93, v132}) + v134 := lang.Apply(v59, []any{v133}) + v135 := lang.Apply(v56, []any{v134}) + v136 := lang.Apply(v49, []any{v53, v135}) + v137 := lang.Apply(v46, []any{v136}) + v138 := lang.Apply(v43, []any{v137}) + v139 := lang.Apply(v36, []any{v40, v138}) + v140 := lang.Apply(v33, []any{v139}) + v141 := lang.Apply(v27, []any{v30, v140}) + v142 := lang.Apply(v24, []any{v141}) + v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v144 := v143.FindInternedVar(lang.NewSymbol("list")) + if v144.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) + } + v145 := v144.Get() + v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v147 := v146.FindInternedVar(lang.NewSymbol("seq")) + if v147.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) + } + v148 := v147.Get() + v149 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v150 := v149.FindInternedVar(lang.NewSymbol("concat")) + if v150.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v150))) + } + v151 := v150.Get() + v152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v153 := v152.FindInternedVar(lang.NewSymbol("list")) + if v153.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v153))) + } + v154 := v153.Get() + v155 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v156 := v155.FindInternedVar(lang.NewSymbol("apply")) + if v156.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v156))) + } + v157 := v156.Get() + v158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v159 := v158.FindInternedVar(lang.NewSymbol("vector")) + if v159.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v159))) + } + v160 := v159.Get() + v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v162 := v161.FindInternedVar(lang.NewSymbol("seq")) + if v162.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) + } + v163 := v162.Get() + v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v165 := v164.FindInternedVar(lang.NewSymbol("concat")) + if v165.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) + } + v166 := v165.Get() + v167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v168 := v167.FindInternedVar(lang.NewSymbol("list")) + if v168.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v168))) + } + v169 := v168.Get() + v170 := lang.Apply(v169, []any{lang.NewSymbol("array__0__auto__")}) + v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v172 := v171.FindInternedVar(lang.NewSymbol("list")) + if v172.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) + } + v173 := v172.Get() + v174 := lang.Apply(v173, []any{lang.NewSymbol("idx__1__auto__")}) + v175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v176 := v175.FindInternedVar(lang.NewSymbol("list")) + if v176.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v176))) + } + v177 := v176.Get() + v178 := lang.Apply(v177, []any{lang.NewSymbol("val__2__auto__")}) + v179 := lang.Apply(v166, []any{v170, v174, v178}) + v180 := lang.Apply(v163, []any{v179}) + v181 := lang.Apply(v157, []any{v160, v180}) + v182 := lang.Apply(v154, []any{v181}) + v183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v184 := v183.FindInternedVar(lang.NewSymbol("list")) + if v184.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v184))) + } + v185 := v184.Get() + v186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v187 := v186.FindInternedVar(lang.NewSymbol("seq")) + if v187.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v187))) + } + v188 := v187.Get() + v189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v190 := v189.FindInternedVar(lang.NewSymbol("concat")) + if v190.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v190))) + } + v191 := v190.Get() + v192 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v193 := v192.FindInternedVar(lang.NewSymbol("list")) + if v193.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v193))) + } + v194 := v193.Get() + v195 := lang.Apply(v194, []any{lang.NewSymbol(".")}) + v196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v197 := v196.FindInternedVar(lang.NewSymbol("list")) + if v197.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v197))) + } + v198 := v197.Get() + v199 := lang.Apply(v198, []any{lang.NewSymbol("glojure.core/Array")}) + v200 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v201 := v200.FindInternedVar(lang.NewSymbol("list")) + if v201.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v201))) + } + v202 := v201.Get() + v203 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v204 := v203.FindInternedVar(lang.NewSymbol("seq")) + if v204.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v204))) + } + v205 := v204.Get() + v206 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v207 := v206.FindInternedVar(lang.NewSymbol("concat")) + if v207.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v207))) + } + v208 := v207.Get() + v209 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v210 := v209.FindInternedVar(lang.NewSymbol("list")) + if v210.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v210))) + } + v211 := v210.Get() + v212 := lang.Apply(v211, []any{v6}) + v213 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v214 := v213.FindInternedVar(lang.NewSymbol("list")) + if v214.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v214))) + } + v215 := v214.Get() + v216 := lang.Apply(v215, []any{lang.NewSymbol("array__0__auto__")}) + v217 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v218 := v217.FindInternedVar(lang.NewSymbol("list")) + if v218.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v218))) + } + v219 := v218.Get() + v220 := lang.Apply(v219, []any{lang.NewSymbol("idx__1__auto__")}) + v221 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v222 := v221.FindInternedVar(lang.NewSymbol("list")) + if v222.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v222))) + } + v223 := v222.Get() + v224 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v225 := v224.FindInternedVar(lang.NewSymbol("seq")) + if v225.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v225))) + } + v226 := v225.Get() + v227 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v228 := v227.FindInternedVar(lang.NewSymbol("concat")) + if v228.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v228))) + } + v229 := v228.Get() + v230 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v231 := v230.FindInternedVar(lang.NewSymbol("list")) + if v231.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v231))) + } + v232 := v231.Get() + v233 := lang.Apply(v232, []any{v7}) + v234 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v235 := v234.FindInternedVar(lang.NewSymbol("list")) + if v235.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v235))) + } + v236 := v235.Get() + v237 := lang.Apply(v236, []any{lang.NewSymbol("val__2__auto__")}) + v238 := lang.Apply(v229, []any{v233, v237}) + v239 := lang.Apply(v226, []any{v238}) + v240 := lang.Apply(v223, []any{v239}) + v241 := lang.Apply(v208, []any{v212, v216, v220, v240}) + v242 := lang.Apply(v205, []any{v241}) + v243 := lang.Apply(v202, []any{v242}) + v244 := lang.Apply(v191, []any{v195, v199, v243}) + v245 := lang.Apply(v188, []any{v244}) + v246 := lang.Apply(v185, []any{v245}) + v247 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v248 := v247.FindInternedVar(lang.NewSymbol("list")) + if v248.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v248))) + } + v249 := v248.Get() + v250 := lang.Apply(v249, []any{lang.NewSymbol("val__2__auto__")}) + v251 := lang.Apply(v151, []any{v182, v246, v250}) + v252 := lang.Apply(v148, []any{v251}) + v253 := lang.Apply(v145, []any{v252}) + v254 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v255 := v254.FindInternedVar(lang.NewSymbol("list")) + if v255.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v255))) + } + v256 := v255.Get() + v257 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v258 := v257.FindInternedVar(lang.NewSymbol("seq")) + if v258.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v258))) + } + v259 := v258.Get() + v260 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v261 := v260.FindInternedVar(lang.NewSymbol("concat")) + if v261.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v261))) + } + v262 := v261.Get() + v263 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v264 := v263.FindInternedVar(lang.NewSymbol("list")) + if v264.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v264))) + } + v265 := v264.Get() + v266 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v267 := v266.FindInternedVar(lang.NewSymbol("apply")) + if v267.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v267))) + } + v268 := v267.Get() + v269 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v270 := v269.FindInternedVar(lang.NewSymbol("vector")) + if v270.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v270))) + } + v271 := v270.Get() + v272 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v273 := v272.FindInternedVar(lang.NewSymbol("seq")) + if v273.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v273))) + } + v274 := v273.Get() + v275 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v276 := v275.FindInternedVar(lang.NewSymbol("concat")) + if v276.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v276))) + } + v277 := v276.Get() + v278 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v279 := v278.FindInternedVar(lang.NewSymbol("list")) + if v279.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v279))) + } + v280 := v279.Get() + v281 := lang.Apply(v280, []any{lang.NewSymbol("array__0__auto__")}) + v282 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v283 := v282.FindInternedVar(lang.NewSymbol("list")) + if v283.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v283))) + } + v284 := v283.Get() + v285 := lang.Apply(v284, []any{lang.NewSymbol("idx__1__auto__")}) + v286 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v287 := v286.FindInternedVar(lang.NewSymbol("list")) + if v287.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v287))) + } + v288 := v287.Get() + v289 := lang.Apply(v288, []any{lang.NewSymbol("idx2__3__auto__")}) + v290 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v291 := v290.FindInternedVar(lang.NewSymbol("list")) + if v291.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v291))) + } + v292 := v291.Get() + v293 := lang.Apply(v292, []any{lang.NewSymbol("&")}) + v294 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v295 := v294.FindInternedVar(lang.NewSymbol("list")) + if v295.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v295))) + } + v296 := v295.Get() + v297 := lang.Apply(v296, []any{lang.NewSymbol("idxv__4__auto__")}) + v298 := lang.Apply(v277, []any{v281, v285, v289, v293, v297}) + v299 := lang.Apply(v274, []any{v298}) + v300 := lang.Apply(v268, []any{v271, v299}) + v301 := lang.Apply(v265, []any{v300}) + v302 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v303 := v302.FindInternedVar(lang.NewSymbol("list")) + if v303.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v303))) + } + v304 := v303.Get() + v305 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v306 := v305.FindInternedVar(lang.NewSymbol("seq")) + if v306.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v306))) + } + v307 := v306.Get() + v308 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v309 := v308.FindInternedVar(lang.NewSymbol("concat")) + if v309.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v309))) + } + v310 := v309.Get() + v311 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v312 := v311.FindInternedVar(lang.NewSymbol("list")) + if v312.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v312))) + } + v313 := v312.Get() + v314 := lang.Apply(v313, []any{lang.NewSymbol("glojure.core/apply")}) + v315 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v316 := v315.FindInternedVar(lang.NewSymbol("list")) + if v316.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v316))) + } + v317 := v316.Get() + v318 := lang.Apply(v317, []any{v5}) + v319 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v320 := v319.FindInternedVar(lang.NewSymbol("list")) + if v320.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v320))) + } + v321 := v320.Get() + v322 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v323 := v322.FindInternedVar(lang.NewSymbol("seq")) + if v323.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v323))) + } + v324 := v323.Get() + v325 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v326 := v325.FindInternedVar(lang.NewSymbol("concat")) + if v326.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v326))) + } + v327 := v326.Get() + v328 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v329 := v328.FindInternedVar(lang.NewSymbol("list")) + if v329.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v329))) + } + v330 := v329.Get() + v331 := lang.Apply(v330, []any{lang.NewSymbol("glojure.core/aget")}) + v332 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v333 := v332.FindInternedVar(lang.NewSymbol("list")) + if v333.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v333))) + } + v334 := v333.Get() + v335 := lang.Apply(v334, []any{lang.NewSymbol("array__0__auto__")}) + v336 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v337 := v336.FindInternedVar(lang.NewSymbol("list")) + if v337.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v337))) + } + v338 := v337.Get() + v339 := lang.Apply(v338, []any{lang.NewSymbol("idx__1__auto__")}) + v340 := lang.Apply(v327, []any{v331, v335, v339}) + v341 := lang.Apply(v324, []any{v340}) + v342 := lang.Apply(v321, []any{v341}) + v343 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v344 := v343.FindInternedVar(lang.NewSymbol("list")) + if v344.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v344))) + } + v345 := v344.Get() + v346 := lang.Apply(v345, []any{lang.NewSymbol("idx2__3__auto__")}) + v347 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v348 := v347.FindInternedVar(lang.NewSymbol("list")) + if v348.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v348))) + } + v349 := v348.Get() + v350 := lang.Apply(v349, []any{lang.NewSymbol("idxv__4__auto__")}) + v351 := lang.Apply(v310, []any{v314, v318, v342, v346, v350}) + v352 := lang.Apply(v307, []any{v351}) + v353 := lang.Apply(v304, []any{v352}) + v354 := lang.Apply(v262, []any{v301, v353}) + v355 := lang.Apply(v259, []any{v354}) + v356 := lang.Apply(v256, []any{v355}) + v357 := lang.Apply(v13, []any{v17, v21, v142, v253, v356}) + v358 := lang.Apply(v10, []any{v357}) + return v358 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // definline + { + v0 := lang.NewSymbol("definline").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("decl"))), lang.NewKeyword("doc"), "Experimental - like defmacro, except defines a named function whose\n body is the expansion, calls to which may be expanded inline as if\n it were a macro. Cannot be used with variadic (&) args.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5253), lang.NewKeyword("end-line"), int(5253))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + var v7 any + { // let + // let binding "vec__80" + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("split-with")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("comp")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("not")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("vector?")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.Apply(v13, []any{v16, v19}) + v21 := lang.Apply(v10, []any{v20, v6}) + var v22 any = v21 + _ = v22 + // let binding "pre-args" + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("nth")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.Apply(v25, []any{v22, int64(0), nil}) + var v27 any = v26 + _ = v27 + // let binding "vec__83" + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("nth")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.Apply(v30, []any{v22, int64(1), nil}) + var v32 any = v31 + _ = v32 + // let binding "args" + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("nth")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.Apply(v35, []any{v32, int64(0), nil}) + var v37 any = v36 + _ = v37 + // let binding "expr" + v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v39 := v38.FindInternedVar(lang.NewSymbol("nth")) + if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + } + v40 := v39.Get() + v41 := lang.Apply(v40, []any{v32, int64(1), nil}) + var v42 any = v41 + _ = v42 + v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v44 := v43.FindInternedVar(lang.NewSymbol("seq")) + if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) + } + v45 := v44.Get() + v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v47 := v46.FindInternedVar(lang.NewSymbol("concat")) + if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) + } + v48 := v47.Get() + v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v50 := v49.FindInternedVar(lang.NewSymbol("list")) + if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) + } + v51 := v50.Get() + v52 := lang.Apply(v51, []any{lang.NewSymbol("do")}) + v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v54 := v53.FindInternedVar(lang.NewSymbol("list")) + if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) + } + v55 := v54.Get() + v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v57 := v56.FindInternedVar(lang.NewSymbol("seq")) + if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) + } + v58 := v57.Get() + v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v60 := v59.FindInternedVar(lang.NewSymbol("concat")) + if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) + } + v61 := v60.Get() + v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v63 := v62.FindInternedVar(lang.NewSymbol("list")) + if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) + } + v64 := v63.Get() + v65 := lang.Apply(v64, []any{lang.NewSymbol("glojure.core/defn")}) + v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v67 := v66.FindInternedVar(lang.NewSymbol("list")) + if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) + } + v68 := v67.Get() + v69 := lang.Apply(v68, []any{v5}) + v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v71 := v70.FindInternedVar(lang.NewSymbol("list")) + if v71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) + } + v72 := v71.Get() + v73 := lang.Apply(v72, []any{v37}) + v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v75 := v74.FindInternedVar(lang.NewSymbol("list")) + if v75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) + } + v76 := v75.Get() + v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v78 := v77.FindInternedVar(lang.NewSymbol("apply")) + if v78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) + } + v79 := v78.Get() + v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v81 := v80.FindInternedVar(lang.NewSymbol("eval")) + if v81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) + } + v82 := v81.Get() + v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v84 := v83.FindInternedVar(lang.NewSymbol("list")) + if v84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) + } + v85 := v84.Get() + v86 := lang.Apply(v85, []any{lang.NewSymbol("glojure.core/fn"), v37, v42}) + v87 := lang.Apply(v82, []any{v86}) + v88 := lang.Apply(v79, []any{v87, v37}) + v89 := lang.Apply(v76, []any{v88}) + v90 := lang.Apply(v61, []any{v65, v69, v27, v73, v89}) + v91 := lang.Apply(v58, []any{v90}) + v92 := lang.Apply(v55, []any{v91}) + v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v94 := v93.FindInternedVar(lang.NewSymbol("list")) + if v94.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) + } + v95 := v94.Get() + v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v97 := v96.FindInternedVar(lang.NewSymbol("seq")) + if v97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) + } + v98 := v97.Get() + v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v100 := v99.FindInternedVar(lang.NewSymbol("concat")) + if v100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) + } + v101 := v100.Get() + v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v103 := v102.FindInternedVar(lang.NewSymbol("list")) + if v103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) + } + v104 := v103.Get() + v105 := lang.Apply(v104, []any{lang.NewSymbol("glojure.core/alter-meta!")}) + v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v107 := v106.FindInternedVar(lang.NewSymbol("list")) + if v107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) + } + v108 := v107.Get() + v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v110 := v109.FindInternedVar(lang.NewSymbol("seq")) + if v110.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) + } + v111 := v110.Get() + v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v113 := v112.FindInternedVar(lang.NewSymbol("concat")) + if v113.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) + } + v114 := v113.Get() + v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v116 := v115.FindInternedVar(lang.NewSymbol("list")) + if v116.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) + } + v117 := v116.Get() + v118 := lang.Apply(v117, []any{lang.NewSymbol("var")}) + v119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v120 := v119.FindInternedVar(lang.NewSymbol("list")) + if v120.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v120))) + } + v121 := v120.Get() + v122 := lang.Apply(v121, []any{v5}) + v123 := lang.Apply(v114, []any{v118, v122}) + v124 := lang.Apply(v111, []any{v123}) + v125 := lang.Apply(v108, []any{v124}) + v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v127 := v126.FindInternedVar(lang.NewSymbol("list")) + if v127.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) + } + v128 := v127.Get() + v129 := lang.Apply(v128, []any{lang.NewSymbol("glojure.core/assoc")}) + v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v131 := v130.FindInternedVar(lang.NewSymbol("list")) + if v131.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) + } + v132 := v131.Get() + v133 := lang.Apply(v132, []any{lang.NewKeyword("inline")}) + v134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v135 := v134.FindInternedVar(lang.NewSymbol("list")) + if v135.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v135))) + } + v136 := v135.Get() + v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v138 := v137.FindInternedVar(lang.NewSymbol("seq")) + if v138.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) + } + v139 := v138.Get() + v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v141 := v140.FindInternedVar(lang.NewSymbol("concat")) + if v141.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) + } + v142 := v141.Get() + v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v144 := v143.FindInternedVar(lang.NewSymbol("list")) + if v144.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) + } + v145 := v144.Get() + v146 := lang.Apply(v145, []any{lang.NewSymbol("glojure.core/fn")}) + v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v148 := v147.FindInternedVar(lang.NewSymbol("list")) + if v148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) + } + v149 := v148.Get() + v150 := lang.Apply(v149, []any{v5}) + v151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v152 := v151.FindInternedVar(lang.NewSymbol("list")) + if v152.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v152))) + } + v153 := v152.Get() + v154 := lang.Apply(v153, []any{v37}) + v155 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v156 := v155.FindInternedVar(lang.NewSymbol("list")) + if v156.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v156))) + } + v157 := v156.Get() + v158 := lang.Apply(v157, []any{v42}) + v159 := lang.Apply(v142, []any{v146, v150, v154, v158}) + v160 := lang.Apply(v139, []any{v159}) + v161 := lang.Apply(v136, []any{v160}) + v162 := lang.Apply(v101, []any{v105, v125, v129, v133, v161}) + v163 := lang.Apply(v98, []any{v162}) + v164 := lang.Apply(v95, []any{v163}) + v165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v166 := v165.FindInternedVar(lang.NewSymbol("list")) + if v166.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v166))) + } + v167 := v166.Get() + v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v169 := v168.FindInternedVar(lang.NewSymbol("seq")) + if v169.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) + } + v170 := v169.Get() + v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v172 := v171.FindInternedVar(lang.NewSymbol("concat")) + if v172.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) + } + v173 := v172.Get() + v174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v175 := v174.FindInternedVar(lang.NewSymbol("list")) + if v175.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v175))) + } + v176 := v175.Get() + v177 := lang.Apply(v176, []any{lang.NewSymbol("var")}) + v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v179 := v178.FindInternedVar(lang.NewSymbol("list")) + if v179.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) + } + v180 := v179.Get() + v181 := lang.Apply(v180, []any{v5}) + v182 := lang.Apply(v173, []any{v177, v181}) + v183 := lang.Apply(v170, []any{v182}) + v184 := lang.Apply(v167, []any{v183}) + v185 := lang.Apply(v48, []any{v52, v92, v164, v184}) + v186 := lang.Apply(v45, []any{v185}) + v7 = v186 + } // end let + return v7 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // defmacro + { + v0 := lang.NewSymbol("defmacro").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("doc-string?"), lang.NewSymbol("attr-map?"), lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("body")), lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("doc-string?"), lang.NewSymbol("attr-map?"), lang.NewList(lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("body")), lang.NewSymbol("+"), lang.NewSymbol("attr-map?"))), lang.NewKeyword("doc"), "Like defn, but the resulting function name is declared as a\n macro and will be used as a macro by the compiler when it is\n called.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(445), lang.NewKeyword("end-line"), int(451))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + var v7 any + { // let + // let binding "prefix" + var v8 any + { // let + // let binding "p" + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("list")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.Apply(v11, []any{v5}) + var v13 any = v12 + _ = v13 + // let binding "args" + var v14 any = v6 + _ = v14 + for { + var v15 any + { // let + // let binding "f" + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("first")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{v14}) + var v20 any = v19 + _ = v20 + var v21 any + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("string?")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v20}) + if lang.IsTruthy(v25) { + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("cons")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{v20, v13}) + var v26 any = v30 + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("next")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{v14}) + var v31 any = v35 + v13 = v26 + v14 = v31 + continue + } else { + var v36 any + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("map?")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.Apply(v39, []any{v20}) + if lang.IsTruthy(v40) { + v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v43 := v42.FindInternedVar(lang.NewSymbol("cons")) + if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) + } + v44 := v43.Get() + v45 := lang.Apply(v44, []any{v20, v13}) + var v41 any = v45 + v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v48 := v47.FindInternedVar(lang.NewSymbol("next")) + if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) + } + v49 := v48.Get() + v50 := lang.Apply(v49, []any{v14}) + var v46 any = v50 + v13 = v41 + v14 = v46 + continue + } else { + v36 = v13 + } + v21 = v36 + } + v15 = v21 + } // end let + v8 = v15 + break + } + } // end let + var v9 any = v8 + _ = v9 + // let binding "fdecl" + var v10 any + { // let + // let binding "fd" + var v11 any = v6 + _ = v11 + for { + var v12 any + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("string?")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("first")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{v11}) + v20 := lang.Apply(v15, []any{v19}) + if lang.IsTruthy(v20) { + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("next")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v11}) + var v21 any = v25 + v11 = v21 + continue + } else { + var v26 any + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("map?")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("first")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.Apply(v32, []any{v11}) + v34 := lang.Apply(v29, []any{v33}) + if lang.IsTruthy(v34) { + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("next")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v38, []any{v11}) + var v35 any = v39 + v11 = v35 + continue + } else { + v26 = v11 + } + v12 = v26 + } + v10 = v12 + break + } + } // end let + var v11 any = v10 + _ = v11 + // let binding "fdecl" + var v12 any + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("vector?")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("first")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{v11}) + v20 := lang.Apply(v15, []any{v19}) + if lang.IsTruthy(v20) { + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("list")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.Apply(v23, []any{v11}) + v12 = v24 + } else { + v12 = v11 + } + var v25 any = v12 + _ = v25 + // let binding "add-implicit-args" + var v26 lang.FnFunc + v26 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v27 := args[0] + _ = v27 + var v28 any + { // let + // let binding "args" + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("first")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.Apply(v31, []any{v27}) + var v33 any = v32 + _ = v33 + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("cons")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("vec")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("cons")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v44 := v43.FindInternedVar(lang.NewSymbol("cons")) + if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) + } + v45 := v44.Get() + v46 := lang.Apply(v45, []any{lang.NewSymbol("&env"), v33}) + v47 := lang.Apply(v42, []any{lang.NewSymbol("&form"), v46}) + v48 := lang.Apply(v39, []any{v47}) + v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v50 := v49.FindInternedVar(lang.NewSymbol("next")) + if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) + } + v51 := v50.Get() + v52 := lang.Apply(v51, []any{v27}) + v53 := lang.Apply(v36, []any{v48, v52}) + v28 = v53 + } // end let + return v28 + }) + v27 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(469), lang.NewKeyword("column"), int(38), lang.NewKeyword("end-line"), int(471), lang.NewKeyword("end-column"), int(87)) + v28, err := lang.WithMeta(v26, v27.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v29 any = v28 + _ = v29 + // let binding "add-args" + var v30 lang.FnFunc + v30 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v31 := args[0] + _ = v31 + v32 := args[1] + _ = v32 + recur_loop_61: + var v33 any + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("nil?")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.Apply(v36, []any{v32}) + if lang.IsTruthy(v37) { + v33 = v31 + } else { + var v38 any + { // let + // let binding "d" + v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v40 := v39.FindInternedVar(lang.NewSymbol("first")) + if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) + } + v41 := v40.Get() + v42 := lang.Apply(v41, []any{v32}) + var v43 any = v42 + _ = v43 + var v44 any + v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v46 := v45.FindInternedVar(lang.NewSymbol("map?")) + if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) + } + v47 := v46.Get() + v48 := lang.Apply(v47, []any{v43}) + if lang.IsTruthy(v48) { + v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v50 := v49.FindInternedVar(lang.NewSymbol("conj")) + if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) + } + v51 := v50.Get() + v52 := lang.Apply(v51, []any{v31, v43}) + v44 = v52 + } else { + v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v55 := v54.FindInternedVar(lang.NewSymbol("conj")) + if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) + } + v56 := v55.Get() + v57 := lang.Apply(v29, []any{v43}) + v58 := lang.Apply(v56, []any{v31, v57}) + var v53 any = v58 + v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v61 := v60.FindInternedVar(lang.NewSymbol("next")) + if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) + } + v62 := v61.Get() + v63 := lang.Apply(v62, []any{v32}) + var v59 any = v63 + v31 = v53 + v32 = v59 + goto recur_loop_61 + } + v38 = v44 + } // end let + v33 = v38 + } + return v33 + }) + v31 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(472), lang.NewKeyword("column"), int(29), lang.NewKeyword("end-line"), int(478), lang.NewKeyword("end-column"), int(90)) + v32, err := lang.WithMeta(v30, v31.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v33 any = v32 + _ = v33 + // let binding "fdecl" + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("seq")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.NewVector() + v38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(479), lang.NewKeyword("column"), int(41), lang.NewKeyword("end-line"), int(479), lang.NewKeyword("end-column"), int(42)) + v39, err := lang.WithMeta(v37, v38.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v40 := lang.Apply(v33, []any{v39, v25}) + v41 := lang.Apply(v36, []any{v40}) + var v42 any = v41 + _ = v42 + // let binding "decl" + var v43 any + { // let + // let binding "p" + var v44 any = v9 + _ = v44 + // let binding "d" + var v45 any = v42 + _ = v45 + for { + var v46 any + if lang.IsTruthy(v44) { + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("next")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v44}) + var v47 any = v51 + v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v54 := v53.FindInternedVar(lang.NewSymbol("cons")) + if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) + } + v55 := v54.Get() + v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v57 := v56.FindInternedVar(lang.NewSymbol("first")) + if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) + } + v58 := v57.Get() + v59 := lang.Apply(v58, []any{v44}) + v60 := lang.Apply(v55, []any{v59, v45}) + var v52 any = v60 + v44 = v47 + v45 = v52 + continue + } else { + v46 = v45 + } + v43 = v46 + break + } + } // end let + var v44 any = v43 + _ = v44 + v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v46 := v45.FindInternedVar(lang.NewSymbol("list")) + if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) + } + v47 := v46.Get() + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("cons")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{lang.NewSymbol("glojure.core/defn"), v44}) + v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v53 := v52.FindInternedVar(lang.NewSymbol("list")) + if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) + } + v54 := v53.Get() + v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v56 := v55.FindInternedVar(lang.NewSymbol("list")) + if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) + } + v57 := v56.Get() + v58 := lang.Apply(v57, []any{lang.NewSymbol("var"), v5}) + v59 := lang.Apply(v54, []any{lang.NewSymbol("."), v58, lang.NewList(lang.NewSymbol("SetMacro"))}) + v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v61 := v60.FindInternedVar(lang.NewSymbol("list")) + if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) + } + v62 := v61.Get() + v63 := lang.Apply(v62, []any{lang.NewSymbol("var"), v5}) + v64 := lang.Apply(v47, []any{lang.NewSymbol("do"), v51, v59, v63}) + v7 = v64 + } // end let + return v7 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(451), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(487), lang.NewKeyword("end-column"), int(40))).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // defmethod + { + v0 := lang.NewSymbol("defmethod").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"), lang.NewSymbol("dispatch-val"), lang.NewSymbol("&"), lang.NewSymbol("fn-tail"))), lang.NewKeyword("doc"), "Creates and installs a new method of multimethod associated with dispatch-value. ", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1781), lang.NewKeyword("end-line"), int(1781))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := lang.NewList(args[4:]...) + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("seq")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("concat")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol(".")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("with-meta")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.NewMap(lang.NewKeyword("tag"), lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.*MultiFn")) + v25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1785), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(1785), lang.NewKeyword("end-column"), int(82)) + v26, err := lang.WithMeta(v24, v25.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v27 := lang.Apply(v23, []any{v5, v26}) + v28 := lang.Apply(v20, []any{v27}) + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("list")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.Apply(v31, []any{lang.NewSymbol("glojure.core/AddMethod")}) + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("list")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.Apply(v35, []any{v6}) + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("list")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("seq")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v44 := v43.FindInternedVar(lang.NewSymbol("concat")) + if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) + } + v45 := v44.Get() + v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v47 := v46.FindInternedVar(lang.NewSymbol("list")) + if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) + } + v48 := v47.Get() + v49 := lang.Apply(v48, []any{lang.NewSymbol("glojure.core/fn")}) + v50 := lang.Apply(v45, []any{v49, v7}) + v51 := lang.Apply(v42, []any{v50}) + v52 := lang.Apply(v39, []any{v51}) + v53 := lang.Apply(v13, []any{v17, v28, v32, v36, v52}) + v54 := lang.Apply(v10, []any{v53}) + return v54 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // defmulti + { + v0 := lang.NewSymbol("defmulti").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("docstring?"), lang.NewSymbol("attr-map?"), lang.NewSymbol("dispatch-fn"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Creates a new multimethod with the associated dispatch function.\n The docstring and attr-map are optional.\n\n Options are key-value pairs and may be one of:\n\n :default\n\n The default dispatch value, defaults to :default\n\n :hierarchy\n\n The value used for hierarchical dispatch (e.g. ::square is-a ::shape)\n\n Hierarchies are type-like relationships that do not depend upon type\n inheritance. By default Clojure's multimethods dispatch off of a\n global hierarchy map. However, a hierarchy relationship can be\n created with the derive function used to augment the root ancestor\n created with make-hierarchy.\n\n Multimethods expect the value of the hierarchy option to be supplied as\n a reference type e.g. a var (i.e. via the Var-quote dispatch macro #'\n or the var special form).", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1723), lang.NewKeyword("end-line"), int(1723))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + var v7 any + { // let + // let binding "docstring" + var v8 any + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("string?")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("first")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.Apply(v14, []any{v6}) + v16 := lang.Apply(v11, []any{v15}) + if lang.IsTruthy(v16) { + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("first")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.Apply(v19, []any{v6}) + v8 = v20 + } else { + v8 = nil + } + var v21 any = v8 + _ = v21 + // let binding "options" + var v22 any + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("string?")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("first")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.Apply(v28, []any{v6}) + v30 := lang.Apply(v25, []any{v29}) + if lang.IsTruthy(v30) { + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("next")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{v6}) + v22 = v34 + } else { + v22 = v6 + } + var v35 any = v22 + _ = v35 + // let binding "m" + var v36 any + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("map?")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("first")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.Apply(v42, []any{v35}) + v44 := lang.Apply(v39, []any{v43}) + if lang.IsTruthy(v44) { + v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v46 := v45.FindInternedVar(lang.NewSymbol("first")) + if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) + } + v47 := v46.Get() + v48 := lang.Apply(v47, []any{v35}) + v36 = v48 + } else { + v49 := lang.NewMap() + v50 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1757), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(1757), lang.NewKeyword("end-column"), int(24)) + v51, err := lang.WithMeta(v49, v50.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v36 = v51 + } + var v52 any = v36 + _ = v52 + // let binding "options" + var v53 any + v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v55 := v54.FindInternedVar(lang.NewSymbol("map?")) + if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) + } + v56 := v55.Get() + v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v58 := v57.FindInternedVar(lang.NewSymbol("first")) + if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) + } + v59 := v58.Get() + v60 := lang.Apply(v59, []any{v35}) + v61 := lang.Apply(v56, []any{v60}) + if lang.IsTruthy(v61) { + v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v63 := v62.FindInternedVar(lang.NewSymbol("next")) + if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) + } + v64 := v63.Get() + v65 := lang.Apply(v64, []any{v35}) + v53 = v65 + } else { + v53 = v35 + } + var v66 any = v53 + _ = v66 + // let binding "dispatch-fn" + v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v68 := v67.FindInternedVar(lang.NewSymbol("first")) + if v68.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) + } + v69 := v68.Get() + v70 := lang.Apply(v69, []any{v66}) + var v71 any = v70 + _ = v71 + // let binding "options" + v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v73 := v72.FindInternedVar(lang.NewSymbol("next")) + if v73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) + } + v74 := v73.Get() + v75 := lang.Apply(v74, []any{v66}) + var v76 any = v75 + _ = v76 + // let binding "m" + var v77 any + if lang.IsTruthy(v21) { + v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v79 := v78.FindInternedVar(lang.NewSymbol("assoc")) + if v79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) + } + v80 := v79.Get() + v81 := lang.Apply(v80, []any{v52, lang.NewKeyword("doc"), v21}) + v77 = v81 + } else { + v77 = v52 + } + var v82 any = v77 + _ = v82 + // let binding "m" + var v83 any + v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v85 := v84.FindInternedVar(lang.NewSymbol("meta")) + if v85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) + } + v86 := v85.Get() + v87 := lang.Apply(v86, []any{v5}) + if lang.IsTruthy(v87) { + v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v89 := v88.FindInternedVar(lang.NewSymbol("conj")) + if v89.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) + } + v90 := v89.Get() + v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v92 := v91.FindInternedVar(lang.NewSymbol("meta")) + if v92.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) + } + v93 := v92.Get() + v94 := lang.Apply(v93, []any{v5}) + v95 := lang.Apply(v90, []any{v94, v82}) + v83 = v95 + } else { + v83 = v82 + } + var v96 any = v83 + _ = v96 + // let binding "mm-name" + v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v98 := v97.FindInternedVar(lang.NewSymbol("with-meta")) + if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) + } + v99 := v98.Get() + v100 := lang.Apply(v99, []any{v5, v96}) + var v101 any = v100 + _ = v101 + var v102 any + v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v104 := v103.FindInternedVar(lang.NewSymbol("=")) + if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) + } + v105 := v104.Get() + v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v107 := v106.FindInternedVar(lang.NewSymbol("count")) + if v107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) + } + v108 := v107.Get() + v109 := lang.Apply(v108, []any{v76}) + v110 := lang.Apply(v105, []any{v109, int64(1)}) + if lang.IsTruthy(v110) { + v111 := lang.Apply(lang.NewError, []any{"The syntax for defmulti has changed. Example: (defmulti name dispatch-fn :default dispatch-value)"}) + panic(v111) + } else { + v102 = nil + } + _ = v102 + var v112 any + { // let + // let binding "options" + v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v114 := v113.FindInternedVar(lang.NewSymbol("apply")) + if v114.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) + } + v115 := v114.Get() + v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v117 := v116.FindInternedVar(lang.NewSymbol("hash-map")) + if v117.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) + } + v118 := v117.Get() + v119 := lang.Apply(v115, []any{v118, v76}) + var v120 any = v119 + _ = v120 + // let binding "default" + v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v122 := v121.FindInternedVar(lang.NewSymbol("get")) + if v122.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) + } + v123 := v122.Get() + v124 := lang.Apply(v123, []any{v120, lang.NewKeyword("default"), lang.NewKeyword("default")}) + var v125 any = v124 + _ = v125 + // let binding "hierarchy" + v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v127 := v126.FindInternedVar(lang.NewSymbol("get")) + if v127.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) + } + v128 := v127.Get() + v129 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("global-hierarchy")) + v130 := lang.Apply(v128, []any{v120, lang.NewKeyword("hierarchy"), v129}) + var v131 any = v130 + _ = v131 + v132 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v133 := v132.FindInternedVar(lang.NewSymbol("check-valid-options")) + if v133.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v133))) + } + v134 := v133.Get() + v135 := lang.Apply(v134, []any{v120, lang.NewKeyword("default"), lang.NewKeyword("hierarchy")}) + _ = v135 + v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v137 := v136.FindInternedVar(lang.NewSymbol("seq")) + if v137.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) + } + v138 := v137.Get() + v139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v140 := v139.FindInternedVar(lang.NewSymbol("concat")) + if v140.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v140))) + } + v141 := v140.Get() + v142 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v143 := v142.FindInternedVar(lang.NewSymbol("list")) + if v143.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v143))) + } + v144 := v143.Get() + v145 := lang.Apply(v144, []any{lang.NewSymbol("glojure.core/let")}) + v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v147 := v146.FindInternedVar(lang.NewSymbol("list")) + if v147.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) + } + v148 := v147.Get() + v149 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v150 := v149.FindInternedVar(lang.NewSymbol("apply")) + if v150.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v150))) + } + v151 := v150.Get() + v152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v153 := v152.FindInternedVar(lang.NewSymbol("vector")) + if v153.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v153))) + } + v154 := v153.Get() + v155 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v156 := v155.FindInternedVar(lang.NewSymbol("seq")) + if v156.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v156))) + } + v157 := v156.Get() + v158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v159 := v158.FindInternedVar(lang.NewSymbol("concat")) + if v159.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v159))) + } + v160 := v159.Get() + v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v162 := v161.FindInternedVar(lang.NewSymbol("list")) + if v162.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) + } + v163 := v162.Get() + v164 := lang.Apply(v163, []any{lang.NewSymbol("v__0__auto__")}) + v165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v166 := v165.FindInternedVar(lang.NewSymbol("list")) + if v166.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v166))) + } + v167 := v166.Get() + v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v169 := v168.FindInternedVar(lang.NewSymbol("seq")) + if v169.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) + } + v170 := v169.Get() + v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v172 := v171.FindInternedVar(lang.NewSymbol("concat")) + if v172.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) + } + v173 := v172.Get() + v174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v175 := v174.FindInternedVar(lang.NewSymbol("list")) + if v175.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v175))) + } + v176 := v175.Get() + v177 := lang.Apply(v176, []any{lang.NewSymbol("def")}) + v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v179 := v178.FindInternedVar(lang.NewSymbol("list")) + if v179.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) + } + v180 := v179.Get() + v181 := lang.Apply(v180, []any{v101}) + v182 := lang.Apply(v173, []any{v177, v181}) + v183 := lang.Apply(v170, []any{v182}) + v184 := lang.Apply(v167, []any{v183}) + v185 := lang.Apply(v160, []any{v164, v184}) + v186 := lang.Apply(v157, []any{v185}) + v187 := lang.Apply(v151, []any{v154, v186}) + v188 := lang.Apply(v148, []any{v187}) + v189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v190 := v189.FindInternedVar(lang.NewSymbol("list")) + if v190.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v190))) + } + v191 := v190.Get() + v192 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v193 := v192.FindInternedVar(lang.NewSymbol("seq")) + if v193.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v193))) + } + v194 := v193.Get() + v195 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v196 := v195.FindInternedVar(lang.NewSymbol("concat")) + if v196.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v196))) + } + v197 := v196.Get() + v198 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v199 := v198.FindInternedVar(lang.NewSymbol("list")) + if v199.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v199))) + } + v200 := v199.Get() + v201 := lang.Apply(v200, []any{lang.NewSymbol("glojure.core/when-not")}) + v202 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v203 := v202.FindInternedVar(lang.NewSymbol("list")) + if v203.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v203))) + } + v204 := v203.Get() + v205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v206 := v205.FindInternedVar(lang.NewSymbol("seq")) + if v206.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v206))) + } + v207 := v206.Get() + v208 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v209 := v208.FindInternedVar(lang.NewSymbol("concat")) + if v209.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v209))) + } + v210 := v209.Get() + v211 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v212 := v211.FindInternedVar(lang.NewSymbol("list")) + if v212.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v212))) + } + v213 := v212.Get() + v214 := lang.Apply(v213, []any{lang.NewSymbol("glojure.core/and")}) + v215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v216 := v215.FindInternedVar(lang.NewSymbol("list")) + if v216.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v216))) + } + v217 := v216.Get() + v218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v219 := v218.FindInternedVar(lang.NewSymbol("seq")) + if v219.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v219))) + } + v220 := v219.Get() + v221 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v222 := v221.FindInternedVar(lang.NewSymbol("concat")) + if v222.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v222))) + } + v223 := v222.Get() + v224 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v225 := v224.FindInternedVar(lang.NewSymbol("list")) + if v225.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v225))) + } + v226 := v225.Get() + v227 := lang.Apply(v226, []any{lang.NewSymbol(".HasRoot")}) + v228 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v229 := v228.FindInternedVar(lang.NewSymbol("list")) + if v229.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v229))) + } + v230 := v229.Get() + v231 := lang.Apply(v230, []any{lang.NewSymbol("v__0__auto__")}) + v232 := lang.Apply(v223, []any{v227, v231}) + v233 := lang.Apply(v220, []any{v232}) + v234 := lang.Apply(v217, []any{v233}) + v235 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v236 := v235.FindInternedVar(lang.NewSymbol("list")) + if v236.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v236))) + } + v237 := v236.Get() + v238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v239 := v238.FindInternedVar(lang.NewSymbol("seq")) + if v239.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v239))) + } + v240 := v239.Get() + v241 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v242 := v241.FindInternedVar(lang.NewSymbol("concat")) + if v242.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v242))) + } + v243 := v242.Get() + v244 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v245 := v244.FindInternedVar(lang.NewSymbol("list")) + if v245.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v245))) + } + v246 := v245.Get() + v247 := lang.Apply(v246, []any{lang.NewSymbol("glojure.core/instance?")}) + v248 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v249 := v248.FindInternedVar(lang.NewSymbol("list")) + if v249.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v249))) + } + v250 := v249.Get() + v251 := lang.Apply(v250, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.*MultiFn")}) + v252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v253 := v252.FindInternedVar(lang.NewSymbol("list")) + if v253.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v253))) + } + v254 := v253.Get() + v255 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v256 := v255.FindInternedVar(lang.NewSymbol("seq")) + if v256.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v256))) + } + v257 := v256.Get() + v258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v259 := v258.FindInternedVar(lang.NewSymbol("concat")) + if v259.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v259))) + } + v260 := v259.Get() + v261 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v262 := v261.FindInternedVar(lang.NewSymbol("list")) + if v262.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v262))) + } + v263 := v262.Get() + v264 := lang.Apply(v263, []any{lang.NewSymbol("glojure.core/deref")}) + v265 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v266 := v265.FindInternedVar(lang.NewSymbol("list")) + if v266.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v266))) + } + v267 := v266.Get() + v268 := lang.Apply(v267, []any{lang.NewSymbol("v__0__auto__")}) + v269 := lang.Apply(v260, []any{v264, v268}) + v270 := lang.Apply(v257, []any{v269}) + v271 := lang.Apply(v254, []any{v270}) + v272 := lang.Apply(v243, []any{v247, v251, v271}) + v273 := lang.Apply(v240, []any{v272}) + v274 := lang.Apply(v237, []any{v273}) + v275 := lang.Apply(v210, []any{v214, v234, v274}) + v276 := lang.Apply(v207, []any{v275}) + v277 := lang.Apply(v204, []any{v276}) + v278 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v279 := v278.FindInternedVar(lang.NewSymbol("list")) + if v279.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v279))) + } + v280 := v279.Get() + v281 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v282 := v281.FindInternedVar(lang.NewSymbol("seq")) + if v282.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v282))) + } + v283 := v282.Get() + v284 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v285 := v284.FindInternedVar(lang.NewSymbol("concat")) + if v285.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v285))) + } + v286 := v285.Get() + v287 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v288 := v287.FindInternedVar(lang.NewSymbol("list")) + if v288.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v288))) + } + v289 := v288.Get() + v290 := lang.Apply(v289, []any{lang.NewSymbol("def")}) + v291 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v292 := v291.FindInternedVar(lang.NewSymbol("list")) + if v292.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v292))) + } + v293 := v292.Get() + v294 := lang.Apply(v293, []any{v101}) + v295 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v296 := v295.FindInternedVar(lang.NewSymbol("list")) + if v296.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v296))) + } + v297 := v296.Get() + v298 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v299 := v298.FindInternedVar(lang.NewSymbol("seq")) + if v299.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v299))) + } + v300 := v299.Get() + v301 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v302 := v301.FindInternedVar(lang.NewSymbol("concat")) + if v302.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v302))) + } + v303 := v302.Get() + v304 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v305 := v304.FindInternedVar(lang.NewSymbol("list")) + if v305.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v305))) + } + v306 := v305.Get() + v307 := lang.Apply(v306, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewMultiFn")}) + v308 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v309 := v308.FindInternedVar(lang.NewSymbol("list")) + if v309.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v309))) + } + v310 := v309.Get() + v311 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v312 := v311.FindInternedVar(lang.NewSymbol("name")) + if v312.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v312))) + } + v313 := v312.Get() + v314 := lang.Apply(v313, []any{v101}) + v315 := lang.Apply(v310, []any{v314}) + v316 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v317 := v316.FindInternedVar(lang.NewSymbol("list")) + if v317.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v317))) + } + v318 := v317.Get() + v319 := lang.Apply(v318, []any{v71}) + v320 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v321 := v320.FindInternedVar(lang.NewSymbol("list")) + if v321.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v321))) + } + v322 := v321.Get() + v323 := lang.Apply(v322, []any{v125}) + v324 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v325 := v324.FindInternedVar(lang.NewSymbol("list")) + if v325.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v325))) + } + v326 := v325.Get() + v327 := lang.Apply(v326, []any{v131}) + v328 := lang.Apply(v303, []any{v307, v315, v319, v323, v327}) + v329 := lang.Apply(v300, []any{v328}) + v330 := lang.Apply(v297, []any{v329}) + v331 := lang.Apply(v286, []any{v290, v294, v330}) + v332 := lang.Apply(v283, []any{v331}) + v333 := lang.Apply(v280, []any{v332}) + v334 := lang.Apply(v197, []any{v201, v277, v333}) + v335 := lang.Apply(v194, []any{v334}) + v336 := lang.Apply(v191, []any{v335}) + v337 := lang.Apply(v141, []any{v145, v188, v336}) + v338 := lang.Apply(v138, []any{v337}) + v112 = v338 + } // end let + v7 = v112 + } // end let + return v7 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // defn + { + v0 := lang.NewSymbol("defn").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("doc-string?"), lang.NewSymbol("attr-map?"), lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("prepost-map?"), lang.NewSymbol("body")), lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("doc-string?"), lang.NewSymbol("attr-map?"), lang.NewList(lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("prepost-map?"), lang.NewSymbol("body")), lang.NewSymbol("+"), lang.NewSymbol("attr-map?"))), lang.NewKeyword("doc"), "Same as (def name (fn [params* ] exprs*)) or (def\n name (fn ([params* ] exprs*)+)) with any doc-string or attrs added\n to the var metadata. prepost-map defines a map with optional keys\n :pre and :post that contain collections of pre or post conditions.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(284), lang.NewKeyword("end-line"), int(291))).(*lang.Symbol) + var v2 lang.FnFunc + { // function defn + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := args[2] + _ = v6 + v7 := lang.NewList(args[3:]...) + var v8 any + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("instance?")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.Apply(v11, []any{*lang.Symbol, v6}) + if lang.IsTruthy(v12) { + v8 = nil + } else { + v13 := lang.Apply(lang.NewIllegalArgumentError, []any{"First argument to defn must be a symbol"}) + panic(v13) + } + _ = v8 + var v14 any + { // let + // let binding "m" + var v15 any + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("string?")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("first")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{v7}) + v23 := lang.Apply(v18, []any{v22}) + if lang.IsTruthy(v23) { + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("first")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.Apply(v26, []any{v7}) + v28 := lang.NewMap(lang.NewKeyword("doc"), v27) + v29 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(297), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(297), lang.NewKeyword("end-column"), int(38)) + v30, err := lang.WithMeta(v28, v29.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v15 = v30 + } else { + v31 := lang.NewMap() + v32 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(298), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(298), lang.NewKeyword("end-column"), int(20)) + v33, err := lang.WithMeta(v31, v32.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v15 = v33 + } + var v34 any = v15 + _ = v34 + // let binding "fdecl" + var v35 any + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("string?")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v40 := v39.FindInternedVar(lang.NewSymbol("first")) + if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) + } + v41 := v40.Get() + v42 := lang.Apply(v41, []any{v7}) + v43 := lang.Apply(v38, []any{v42}) + if lang.IsTruthy(v43) { + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("next")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.Apply(v46, []any{v7}) + v35 = v47 + } else { + v35 = v7 + } + var v48 any = v35 + _ = v48 + // let binding "m" + var v49 any + v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v51 := v50.FindInternedVar(lang.NewSymbol("map?")) + if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) + } + v52 := v51.Get() + v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v54 := v53.FindInternedVar(lang.NewSymbol("first")) + if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) + } + v55 := v54.Get() + v56 := lang.Apply(v55, []any{v48}) + v57 := lang.Apply(v52, []any{v56}) + if lang.IsTruthy(v57) { + v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v59 := v58.FindInternedVar(lang.NewSymbol("conj")) + if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) + } + v60 := v59.Get() + v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v62 := v61.FindInternedVar(lang.NewSymbol("first")) + if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) + } + v63 := v62.Get() + v64 := lang.Apply(v63, []any{v48}) + v65 := lang.Apply(v60, []any{v34, v64}) + v49 = v65 + } else { + v49 = v34 + } + var v66 any = v49 + _ = v66 + // let binding "fdecl" + var v67 any + v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v69 := v68.FindInternedVar(lang.NewSymbol("map?")) + if v69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) + } + v70 := v69.Get() + v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v72 := v71.FindInternedVar(lang.NewSymbol("first")) + if v72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) + } + v73 := v72.Get() + v74 := lang.Apply(v73, []any{v48}) + v75 := lang.Apply(v70, []any{v74}) + if lang.IsTruthy(v75) { + v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v77 := v76.FindInternedVar(lang.NewSymbol("next")) + if v77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) + } + v78 := v77.Get() + v79 := lang.Apply(v78, []any{v48}) + v67 = v79 + } else { + v67 = v48 + } + var v80 any = v67 + _ = v80 + // let binding "fdecl" + var v81 any + v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v83 := v82.FindInternedVar(lang.NewSymbol("vector?")) + if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) + } + v84 := v83.Get() + v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v86 := v85.FindInternedVar(lang.NewSymbol("first")) + if v86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) + } + v87 := v86.Get() + v88 := lang.Apply(v87, []any{v80}) + v89 := lang.Apply(v84, []any{v88}) + if lang.IsTruthy(v89) { + v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v91 := v90.FindInternedVar(lang.NewSymbol("list")) + if v91.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) + } + v92 := v91.Get() + v93 := lang.Apply(v92, []any{v80}) + v81 = v93 + } else { + v81 = v80 + } + var v94 any = v81 + _ = v94 + // let binding "m" + var v95 any + v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v97 := v96.FindInternedVar(lang.NewSymbol("map?")) + if v97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) + } + v98 := v97.Get() + v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v100 := v99.FindInternedVar(lang.NewSymbol("last")) + if v100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) + } + v101 := v100.Get() + v102 := lang.Apply(v101, []any{v94}) + v103 := lang.Apply(v98, []any{v102}) + if lang.IsTruthy(v103) { + v104 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v105 := v104.FindInternedVar(lang.NewSymbol("conj")) + if v105.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v105))) + } + v106 := v105.Get() + v107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v108 := v107.FindInternedVar(lang.NewSymbol("last")) + if v108.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v108))) + } + v109 := v108.Get() + v110 := lang.Apply(v109, []any{v94}) + v111 := lang.Apply(v106, []any{v66, v110}) + v95 = v111 + } else { + v95 = v66 + } + var v112 any = v95 + _ = v112 + // let binding "fdecl" + var v113 any + v114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v115 := v114.FindInternedVar(lang.NewSymbol("map?")) + if v115.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v115))) + } + v116 := v115.Get() + v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v118 := v117.FindInternedVar(lang.NewSymbol("last")) + if v118.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) + } + v119 := v118.Get() + v120 := lang.Apply(v119, []any{v94}) + v121 := lang.Apply(v116, []any{v120}) + if lang.IsTruthy(v121) { + v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v123 := v122.FindInternedVar(lang.NewSymbol("butlast")) + if v123.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) + } + v124 := v123.Get() + v125 := lang.Apply(v124, []any{v94}) + v113 = v125 + } else { + v113 = v94 + } + var v126 any = v113 + _ = v126 + // let binding "m" + v127 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v128 := v127.FindInternedVar(lang.NewSymbol("conj")) + if v128.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v128))) + } + v129 := v128.Get() + v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v131 := v130.FindInternedVar(lang.NewSymbol("list")) + if v131.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) + } + v132 := v131.Get() + v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v134 := v133.FindInternedVar(lang.NewSymbol("sigs")) + if v134.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) + } + v135 := v134.Get() + v136 := lang.Apply(v135, []any{v126}) + v137 := lang.Apply(v132, []any{lang.NewSymbol("quote"), v136}) + v138 := lang.NewMap(lang.NewKeyword("arglists"), v137) + v139 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(317), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(317), lang.NewKeyword("end-column"), int(60)) + v140, err := lang.WithMeta(v138, v139.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v141 := lang.Apply(v129, []any{v140, v112}) + var v142 any = v141 + _ = v142 + // let binding "m" + var v143 any + { // let + // let binding "inline" + v144 := lang.Apply(lang.NewKeyword("inline"), []any{v142}) + var v145 any = v144 + _ = v145 + // let binding "ifn" + v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v147 := v146.FindInternedVar(lang.NewSymbol("first")) + if v147.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) + } + v148 := v147.Get() + v149 := lang.Apply(v148, []any{v145}) + var v150 any = v149 + _ = v150 + // let binding "iname" + v151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v152 := v151.FindInternedVar(lang.NewSymbol("second")) + if v152.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v152))) + } + v153 := v152.Get() + v154 := lang.Apply(v153, []any{v145}) + var v155 any = v154 + _ = v155 + var v156 any + var v157 any + v158 := lang.Apply(lang.Equiv, []any{lang.NewSymbol("fn"), v150}) + if lang.IsTruthy(v158) { + var v159 any + v160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v161 := v160.FindInternedVar(lang.NewSymbol("instance?")) + if v161.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v161))) + } + v162 := v161.Get() + v163 := lang.Apply(v162, []any{*lang.Symbol, v155}) + if lang.IsTruthy(v163) { + v159 = false + } else { + v159 = true + } + v157 = v159 + } else { + v157 = nil + } + if lang.IsTruthy(v157) { + v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v165 := v164.FindInternedVar(lang.NewSymbol("assoc")) + if v165.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) + } + v166 := v165.Get() + v167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v168 := v167.FindInternedVar(lang.NewSymbol("cons")) + if v168.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v168))) + } + v169 := v168.Get() + v170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v171 := v170.FindInternedVar(lang.NewSymbol("cons")) + if v171.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v171))) + } + v172 := v171.Get() + v173, ok := lang.FieldOrMethod(v6, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "Name"))) + } + var v174 any + switch reflect.TypeOf(v173).Kind() { + case reflect.Func: + v174 = lang.Apply(v173, nil) + default: + v174 = v173 + } + v175 := lang.Apply(lang.ConcatStrings, []any{v174, "__inliner"}) + v176 := lang.Apply(lang.NewSymbol, []any{v175}) + v177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v178 := v177.FindInternedVar(lang.NewSymbol("next")) + if v178.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v178))) + } + v179 := v178.Get() + v180 := lang.Apply(v179, []any{v145}) + v181 := lang.Apply(v172, []any{v176, v180}) + v182 := lang.Apply(v169, []any{v150, v181}) + v183 := lang.Apply(v166, []any{v142, lang.NewKeyword("inline"), v182}) + v156 = v183 + } else { + v156 = v142 + } + v143 = v156 + } // end let + var v144 any = v143 + _ = v144 + // let binding "m" + v145 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v146 := v145.FindInternedVar(lang.NewSymbol("conj")) + if v146.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v146))) + } + v147 := v146.Get() + var v148 any + v149 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v150 := v149.FindInternedVar(lang.NewSymbol("meta")) + if v150.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v150))) + } + v151 := v150.Get() + v152 := lang.Apply(v151, []any{v6}) + if lang.IsTruthy(v152) { + v153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v154 := v153.FindInternedVar(lang.NewSymbol("meta")) + if v154.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v154))) + } + v155 := v154.Get() + v156 := lang.Apply(v155, []any{v6}) + v148 = v156 + } else { + v157 := lang.NewMap() + v158 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(328), lang.NewKeyword("column"), int(51), lang.NewKeyword("end-line"), int(328), lang.NewKeyword("end-column"), int(52)) + v159, err := lang.WithMeta(v157, v158.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v148 = v159 + } + v160 := lang.Apply(v147, []any{v148, v144}) + var v161 any = v160 + _ = v161 + v162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v163 := v162.FindInternedVar(lang.NewSymbol("list")) + if v163.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v163))) + } + v164 := v163.Get() + v165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v166 := v165.FindInternedVar(lang.NewSymbol("with-meta")) + if v166.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v166))) + } + v167 := v166.Get() + v168 := lang.Apply(v167, []any{v6, v161}) + v169 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v170 := v169.FindInternedVar(lang.NewSymbol("with-meta")) + if v170.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v170))) + } + v171 := v170.Get() + v172 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v173 := v172.FindInternedVar(lang.NewSymbol("cons")) + if v173.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v173))) + } + v174 := v173.Get() + v175 := lang.Apply(v174, []any{lang.NewSymbol("glojure.core/fn"), v126}) + v176 := lang.Apply(lang.NewKeyword("tag"), []any{v161}) + v177 := lang.NewMap(lang.NewKeyword("rettag"), v176) + v178 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(333), lang.NewKeyword("column"), int(37), lang.NewKeyword("end-line"), int(333), lang.NewKeyword("end-column"), int(54)) + v179, err := lang.WithMeta(v177, v178.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v180 := lang.Apply(v171, []any{v175, v179}) + v181 := lang.Apply(v164, []any{lang.NewSymbol("def"), v168, v180}) + v14 = v181 + } // end let + return v14 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(291), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(333), lang.NewKeyword("end-column"), int(58))).(lang.FnFunc) + v3 := v2 + _ = v3 + } + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // defn- + { + v0 := lang.NewSymbol("defn-").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("decls"))), lang.NewKeyword("doc"), "same as defn, yielding non-public def", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4949), lang.NewKeyword("end-line"), int(4949))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("list*")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("with-meta")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("assoc")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("meta")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{v5}) + v20 := lang.Apply(v15, []any{v19, lang.NewKeyword("private"), true}) + v21 := lang.Apply(v12, []any{v5, v20}) + v22 := lang.Apply(v9, []any{lang.NewSymbol("glojure.core/defn"), v21, v6}) + return v22 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // defonce + { + v0 := lang.NewSymbol("defonce").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("expr"))), lang.NewKeyword("doc"), "defs name to have the root value of the expr iff the named var has no root value,\n else expr is unevaluated", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5806), lang.NewKeyword("end-line"), int(5806))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("seq")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("concat")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("list")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/let")}) + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("list")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("apply")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("vector")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("seq")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("concat")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("list")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{lang.NewSymbol("v__0__auto__")}) + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("list")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v40 := v39.FindInternedVar(lang.NewSymbol("seq")) + if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) + } + v41 := v40.Get() + v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v43 := v42.FindInternedVar(lang.NewSymbol("concat")) + if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) + } + v44 := v43.Get() + v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v46 := v45.FindInternedVar(lang.NewSymbol("list")) + if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) + } + v47 := v46.Get() + v48 := lang.Apply(v47, []any{lang.NewSymbol("def")}) + v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v50 := v49.FindInternedVar(lang.NewSymbol("list")) + if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) + } + v51 := v50.Get() + v52 := lang.Apply(v51, []any{v5}) + v53 := lang.Apply(v44, []any{v48, v52}) + v54 := lang.Apply(v41, []any{v53}) + v55 := lang.Apply(v38, []any{v54}) + v56 := lang.Apply(v31, []any{v35, v55}) + v57 := lang.Apply(v28, []any{v56}) + v58 := lang.Apply(v22, []any{v25, v57}) + v59 := lang.Apply(v19, []any{v58}) + v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v61 := v60.FindInternedVar(lang.NewSymbol("list")) + if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) + } + v62 := v61.Get() + v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v64 := v63.FindInternedVar(lang.NewSymbol("seq")) + if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) + } + v65 := v64.Get() + v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v67 := v66.FindInternedVar(lang.NewSymbol("concat")) + if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) + } + v68 := v67.Get() + v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v70 := v69.FindInternedVar(lang.NewSymbol("list")) + if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) + } + v71 := v70.Get() + v72 := lang.Apply(v71, []any{lang.NewSymbol("glojure.core/when-not")}) + v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v74 := v73.FindInternedVar(lang.NewSymbol("list")) + if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) + } + v75 := v74.Get() + v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v77 := v76.FindInternedVar(lang.NewSymbol("seq")) + if v77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) + } + v78 := v77.Get() + v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v80 := v79.FindInternedVar(lang.NewSymbol("concat")) + if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) + } + v81 := v80.Get() + v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v83 := v82.FindInternedVar(lang.NewSymbol("list")) + if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) + } + v84 := v83.Get() + v85 := lang.Apply(v84, []any{lang.NewSymbol(".HasRoot")}) + v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v87 := v86.FindInternedVar(lang.NewSymbol("list")) + if v87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) + } + v88 := v87.Get() + v89 := lang.Apply(v88, []any{lang.NewSymbol("v__0__auto__")}) + v90 := lang.Apply(v81, []any{v85, v89}) + v91 := lang.Apply(v78, []any{v90}) + v92 := lang.Apply(v75, []any{v91}) + v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v94 := v93.FindInternedVar(lang.NewSymbol("list")) + if v94.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) + } + v95 := v94.Get() + v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v97 := v96.FindInternedVar(lang.NewSymbol("seq")) + if v97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) + } + v98 := v97.Get() + v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v100 := v99.FindInternedVar(lang.NewSymbol("concat")) + if v100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) + } + v101 := v100.Get() + v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v103 := v102.FindInternedVar(lang.NewSymbol("list")) + if v103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) + } + v104 := v103.Get() + v105 := lang.Apply(v104, []any{lang.NewSymbol("def")}) + v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v107 := v106.FindInternedVar(lang.NewSymbol("list")) + if v107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) + } + v108 := v107.Get() + v109 := lang.Apply(v108, []any{v5}) + v110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v111 := v110.FindInternedVar(lang.NewSymbol("list")) + if v111.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v111))) + } + v112 := v111.Get() + v113 := lang.Apply(v112, []any{v6}) + v114 := lang.Apply(v101, []any{v105, v109, v113}) + v115 := lang.Apply(v98, []any{v114}) + v116 := lang.Apply(v95, []any{v115}) + v117 := lang.Apply(v68, []any{v72, v92, v116}) + v118 := lang.Apply(v65, []any{v117}) + v119 := lang.Apply(v62, []any{v118}) + v120 := lang.Apply(v12, []any{v16, v59, v119}) + v121 := lang.Apply(v9, []any{v120}) + return v121 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // defprotocol + { + v0 := lang.NewSymbol("defprotocol").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("opts+sigs"))), lang.NewKeyword("doc"), "A protocol is a named set of named methods and their signatures:\n (defprotocol AProtocolName\n\n ;optional doc string\n \"A doc string for AProtocol abstraction\"\n\n ;options\n :extend-via-metadata true\n\n ;method signatures\n (bar [this a b] \"bar docs\")\n (baz [this a] [this a b] [this a b c] \"baz docs\"))\n\n No implementations are provided. Docs can be specified for the\n protocol overall and for each method. The above yields a set of\n polymorphic functions and a protocol object. All are\n namespace-qualified by the ns enclosing the definition The resulting\n functions dispatch on the type of their first argument, which is\n required and corresponds to the implicit target object ('this' in \n Java parlance). defprotocol is dynamic, has no special compile-time \n effect, and defines no new types or classes. Implementations of \n the protocol methods can be provided using extend.\n\n When :extend-via-metadata is true, values can extend protocols by\n adding metadata where keys are fully-qualified protocol function\n symbols and values are function implementations. Protocol\n implementations are checked first for direct definitions (defrecord,\n deftype, reify), then metadata definitions, then external\n extensions (extend, extend-type, extend-protocol)\n\n defprotocol will automatically generate a corresponding interface,\n with the same name as the protocol, i.e. given a protocol:\n my.ns/Protocol, an interface: my.ns.Protocol. The interface will\n have methods corresponding to the protocol functions, and the\n protocol will automatically work with instances of the interface.\n\n Note that you should not use this interface with deftype or\n reify, as they support the protocol directly:\n\n (defprotocol P \n (foo [this]) \n (bar-me [this] [this y]))\n\n (deftype Foo [a b c] \n P\n (foo [this] a)\n (bar-me [this] b)\n (bar-me [this y] (+ c y)))\n \n (bar-me (Foo. 1 2 3) 42)\n => 45\n\n (foo \n (let [x 42]\n (reify P \n (foo [this] 17)\n (bar-me [this] x)\n (bar-me [this y] x))))\n => 17", lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(28), lang.NewKeyword("end-line"), int(28))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + var v7 any + { // let + // let binding "doc" + var v8 any + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("string?")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("first")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.Apply(v14, []any{v6}) + v16 := lang.Apply(v11, []any{v15}) + if lang.IsTruthy(v16) { + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("first")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.Apply(v19, []any{v6}) + v8 = v20 + } else { + v8 = nil + } + var v21 any = v8 + _ = v21 + // let binding "opts+sigs" + var v22 any + if lang.IsTruthy(v21) { + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("rest")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.Apply(v25, []any{v6}) + v22 = v26 + } else { + v22 = v6 + } + var v27 any = v22 + _ = v27 + // let binding "opts" + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("take-while")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + var v31 lang.FnFunc + v31 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v32 := args[0] + _ = v32 + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("not")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("seq?")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v38, []any{v32}) + v40 := lang.Apply(v35, []any{v39}) + return v40 + }) + v32 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(92), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(92), lang.NewKeyword("end-column"), int(40)) + v33, err := lang.WithMeta(v31, v32.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v34 := lang.Apply(v30, []any{v33, v27}) + var v35 any = v34 + _ = v35 + // let binding "sigs" + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("drop-while")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + var v39 lang.FnFunc + v39 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v40 := args[0] + _ = v40 + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("not")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("seq?")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.Apply(v46, []any{v40}) + v48 := lang.Apply(v43, []any{v47}) + return v48 + }) + v40 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(93), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(93), lang.NewKeyword("end-column"), int(40)) + v41, err := lang.WithMeta(v39, v40.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v42 := lang.Apply(v38, []any{v41, v27}) + var v43 any = v42 + _ = v43 + // let binding "opts" + var v44 any + v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v46 := v45.FindInternedVar(lang.NewSymbol("=")) + if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) + } + v47 := v46.Get() + v48 := lang.Apply(v47, []any{v43, v35}) + if lang.IsTruthy(v48) { + v44 = nil + } else { + v44 = v35 + } + var v49 any = v44 + _ = v49 + v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v51 := v50.FindInternedVar(lang.NewSymbol("seq")) + if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) + } + v52 := v51.Get() + v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v54 := v53.FindInternedVar(lang.NewSymbol("concat")) + if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) + } + v55 := v54.Get() + v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v57 := v56.FindInternedVar(lang.NewSymbol("list")) + if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) + } + v58 := v57.Get() + v59 := lang.Apply(v58, []any{lang.NewSymbol("do")}) + v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v61 := v60.FindInternedVar(lang.NewSymbol("list")) + if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) + } + v62 := v61.Get() + v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v64 := v63.FindInternedVar(lang.NewSymbol("seq")) + if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) + } + v65 := v64.Get() + v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v67 := v66.FindInternedVar(lang.NewSymbol("concat")) + if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) + } + v68 := v67.Get() + v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v70 := v69.FindInternedVar(lang.NewSymbol("list")) + if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) + } + v71 := v70.Get() + v72 := lang.Apply(v71, []any{lang.NewSymbol("def")}) + v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v74 := v73.FindInternedVar(lang.NewSymbol("list")) + if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) + } + v75 := v74.Get() + v76 := lang.Apply(v75, []any{v5}) + v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v78 := v77.FindInternedVar(lang.NewSymbol("list")) + if v78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) + } + v79 := v78.Get() + v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v81 := v80.FindInternedVar(lang.NewSymbol("seq")) + if v81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) + } + v82 := v81.Get() + v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v84 := v83.FindInternedVar(lang.NewSymbol("concat")) + if v84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) + } + v85 := v84.Get() + v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v87 := v86.FindInternedVar(lang.NewSymbol("list")) + if v87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) + } + v88 := v87.Get() + v89 := lang.Apply(v88, []any{lang.NewSymbol("glojure.core/atom")}) + v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v91 := v90.FindInternedVar(lang.NewSymbol("list")) + if v91.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) + } + v92 := v91.Get() + v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v94 := v93.FindInternedVar(lang.NewSymbol("apply")) + if v94.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) + } + v95 := v94.Get() + v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v97 := v96.FindInternedVar(lang.NewSymbol("hash-map")) + if v97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) + } + v98 := v97.Get() + v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v100 := v99.FindInternedVar(lang.NewSymbol("seq")) + if v100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) + } + v101 := v100.Get() + v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v103 := v102.FindInternedVar(lang.NewSymbol("concat")) + if v103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) + } + v104 := v103.Get() + v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v106 := v105.FindInternedVar(lang.NewSymbol("list")) + if v106.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) + } + v107 := v106.Get() + v108 := lang.Apply(v107, []any{lang.NewKeyword("on-interface")}) + v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v110 := v109.FindInternedVar(lang.NewSymbol("list")) + if v110.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) + } + v111 := v110.Get() + v112 := lang.Apply(v111, []any{true}) + v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v114 := v113.FindInternedVar(lang.NewSymbol("list")) + if v114.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) + } + v115 := v114.Get() + v116 := lang.Apply(v115, []any{lang.NewKeyword("sigs")}) + v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v118 := v117.FindInternedVar(lang.NewSymbol("list")) + if v118.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) + } + v119 := v118.Get() + v120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v121 := v120.FindInternedVar(lang.NewSymbol("seq")) + if v121.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v121))) + } + v122 := v121.Get() + v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v124 := v123.FindInternedVar(lang.NewSymbol("concat")) + if v124.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) + } + v125 := v124.Get() + v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v127 := v126.FindInternedVar(lang.NewSymbol("list")) + if v127.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) + } + v128 := v127.Get() + v129 := lang.Apply(v128, []any{lang.NewSymbol("quote")}) + v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v131 := v130.FindInternedVar(lang.NewSymbol("list")) + if v131.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) + } + v132 := v131.Get() + v133 := lang.Apply(v132, []any{v43}) + v134 := lang.Apply(v125, []any{v129, v133}) + v135 := lang.Apply(v122, []any{v134}) + v136 := lang.Apply(v119, []any{v135}) + v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v138 := v137.FindInternedVar(lang.NewSymbol("list")) + if v138.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) + } + v139 := v138.Get() + v140 := lang.Apply(v139, []any{lang.NewKeyword("multis")}) + v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v142 := v141.FindInternedVar(lang.NewSymbol("list")) + if v142.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) + } + v143 := v142.Get() + v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v145 := v144.FindInternedVar(lang.NewSymbol("apply")) + if v145.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) + } + v146 := v145.Get() + v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v148 := v147.FindInternedVar(lang.NewSymbol("hash-map")) + if v148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) + } + v149 := v148.Get() + v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v151 := v150.FindInternedVar(lang.NewSymbol("seq")) + if v151.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) + } + v152 := v151.Get() + v153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v154 := v153.FindInternedVar(lang.NewSymbol("concat")) + if v154.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v154))) + } + v155 := v154.Get() + v156 := lang.Apply(v155, nil) + v157 := lang.Apply(v152, []any{v156}) + v158 := lang.Apply(v146, []any{v149, v157}) + v159 := lang.Apply(v143, []any{v158}) + v160 := lang.Apply(v104, []any{v108, v112, v116, v136, v140, v159}) + v161 := lang.Apply(v101, []any{v160}) + v162 := lang.Apply(v95, []any{v98, v161}) + v163 := lang.Apply(v92, []any{v162}) + v164 := lang.Apply(v85, []any{v89, v163}) + v165 := lang.Apply(v82, []any{v164}) + v166 := lang.Apply(v79, []any{v165}) + v167 := lang.Apply(v68, []any{v72, v76, v166}) + v168 := lang.Apply(v65, []any{v167}) + v169 := lang.Apply(v62, []any{v168}) + v170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v171 := v170.FindInternedVar(lang.NewSymbol("list")) + if v171.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v171))) + } + v172 := v171.Get() + v173 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v174 := v173.FindInternedVar(lang.NewSymbol("seq")) + if v174.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v174))) + } + v175 := v174.Get() + v176 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v177 := v176.FindInternedVar(lang.NewSymbol("concat")) + if v177.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v177))) + } + v178 := v177.Get() + v179 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v180 := v179.FindInternedVar(lang.NewSymbol("list")) + if v180.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v180))) + } + v181 := v180.Get() + v182 := lang.Apply(v181, []any{lang.NewSymbol("glojure.core/swap!")}) + v183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v184 := v183.FindInternedVar(lang.NewSymbol("list")) + if v184.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v184))) + } + v185 := v184.Get() + v186 := lang.Apply(v185, []any{lang.NewSymbol("glojure.core/-protocols")}) + v187 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v188 := v187.FindInternedVar(lang.NewSymbol("list")) + if v188.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v188))) + } + v189 := v188.Get() + v190 := lang.Apply(v189, []any{lang.NewSymbol("glojure.core/assoc")}) + v191 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v192 := v191.FindInternedVar(lang.NewSymbol("list")) + if v192.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v192))) + } + v193 := v192.Get() + v194 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v195 := v194.FindInternedVar(lang.NewSymbol("seq")) + if v195.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v195))) + } + v196 := v195.Get() + v197 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v198 := v197.FindInternedVar(lang.NewSymbol("concat")) + if v198.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v198))) + } + v199 := v198.Get() + v200 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v201 := v200.FindInternedVar(lang.NewSymbol("list")) + if v201.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v201))) + } + v202 := v201.Get() + v203 := lang.Apply(v202, []any{lang.NewSymbol("quote")}) + v204 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v205 := v204.FindInternedVar(lang.NewSymbol("list")) + if v205.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v205))) + } + v206 := v205.Get() + v207 := lang.Apply(v206, []any{v5}) + v208 := lang.Apply(v199, []any{v203, v207}) + v209 := lang.Apply(v196, []any{v208}) + v210 := lang.Apply(v193, []any{v209}) + v211 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v212 := v211.FindInternedVar(lang.NewSymbol("list")) + if v212.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v212))) + } + v213 := v212.Get() + v214 := lang.Apply(v213, []any{v5}) + v215 := lang.Apply(v178, []any{v182, v186, v190, v210, v214}) + v216 := lang.Apply(v175, []any{v215}) + v217 := lang.Apply(v172, []any{v216}) + v218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v219 := v218.FindInternedVar(lang.NewSymbol("map")) + if v219.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v219))) + } + v220 := v219.Get() + var v221 lang.FnFunc + v221 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v222 := args[0] + _ = v222 + v223 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v224 := v223.FindInternedVar(lang.NewSymbol("seq")) + if v224.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v224))) + } + v225 := v224.Get() + v226 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v227 := v226.FindInternedVar(lang.NewSymbol("concat")) + if v227.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v227))) + } + v228 := v227.Get() + v229 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v230 := v229.FindInternedVar(lang.NewSymbol("list")) + if v230.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v230))) + } + v231 := v230.Get() + v232 := lang.Apply(v231, []any{lang.NewSymbol("do")}) + v233 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v234 := v233.FindInternedVar(lang.NewSymbol("list")) + if v234.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v234))) + } + v235 := v234.Get() + v236 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v237 := v236.FindInternedVar(lang.NewSymbol("seq")) + if v237.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v237))) + } + v238 := v237.Get() + v239 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v240 := v239.FindInternedVar(lang.NewSymbol("concat")) + if v240.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v240))) + } + v241 := v240.Get() + v242 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v243 := v242.FindInternedVar(lang.NewSymbol("list")) + if v243.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v243))) + } + v244 := v243.Get() + v245 := lang.Apply(v244, []any{lang.NewSymbol("glojure.core/defmulti")}) + v246 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v247 := v246.FindInternedVar(lang.NewSymbol("list")) + if v247.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v247))) + } + v248 := v247.Get() + v249 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v250 := v249.FindInternedVar(lang.NewSymbol("first")) + if v250.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v250))) + } + v251 := v250.Get() + v252 := lang.Apply(v251, []any{v222}) + v253 := lang.Apply(v248, []any{v252}) + v254 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v255 := v254.FindInternedVar(lang.NewSymbol("list")) + if v255.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v255))) + } + v256 := v255.Get() + v257 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v258 := v257.FindInternedVar(lang.NewSymbol("seq")) + if v258.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v258))) + } + v259 := v258.Get() + v260 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v261 := v260.FindInternedVar(lang.NewSymbol("concat")) + if v261.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v261))) + } + v262 := v261.Get() + v263 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v264 := v263.FindInternedVar(lang.NewSymbol("list")) + if v264.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v264))) + } + v265 := v264.Get() + v266 := lang.Apply(v265, []any{lang.NewSymbol("glojure.core/fn")}) + v267 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v268 := v267.FindInternedVar(lang.NewSymbol("list")) + if v268.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v268))) + } + v269 := v268.Get() + v270 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v271 := v270.FindInternedVar(lang.NewSymbol("apply")) + if v271.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v271))) + } + v272 := v271.Get() + v273 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v274 := v273.FindInternedVar(lang.NewSymbol("vector")) + if v274.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v274))) + } + v275 := v274.Get() + v276 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v277 := v276.FindInternedVar(lang.NewSymbol("seq")) + if v277.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v277))) + } + v278 := v277.Get() + v279 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v280 := v279.FindInternedVar(lang.NewSymbol("concat")) + if v280.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v280))) + } + v281 := v280.Get() + v282 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v283 := v282.FindInternedVar(lang.NewSymbol("list")) + if v283.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v283))) + } + v284 := v283.Get() + v285 := lang.Apply(v284, []any{lang.NewSymbol("this")}) + v286 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v287 := v286.FindInternedVar(lang.NewSymbol("list")) + if v287.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v287))) + } + v288 := v287.Get() + v289 := lang.Apply(v288, []any{lang.NewSymbol("&")}) + v290 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v291 := v290.FindInternedVar(lang.NewSymbol("list")) + if v291.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v291))) + } + v292 := v291.Get() + v293 := lang.Apply(v292, []any{lang.NewSymbol("args")}) + v294 := lang.Apply(v281, []any{v285, v289, v293}) + v295 := lang.Apply(v278, []any{v294}) + v296 := lang.Apply(v272, []any{v275, v295}) + v297 := lang.Apply(v269, []any{v296}) + v298 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v299 := v298.FindInternedVar(lang.NewSymbol("list")) + if v299.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v299))) + } + v300 := v299.Get() + v301 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v302 := v301.FindInternedVar(lang.NewSymbol("seq")) + if v302.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v302))) + } + v303 := v302.Get() + v304 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v305 := v304.FindInternedVar(lang.NewSymbol("concat")) + if v305.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v305))) + } + v306 := v305.Get() + v307 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v308 := v307.FindInternedVar(lang.NewSymbol("list")) + if v308.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v308))) + } + v309 := v308.Get() + v310 := lang.Apply(v309, []any{lang.NewSymbol("glojure.core/class")}) + v311 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v312 := v311.FindInternedVar(lang.NewSymbol("list")) + if v312.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v312))) + } + v313 := v312.Get() + v314 := lang.Apply(v313, []any{lang.NewSymbol("this")}) + v315 := lang.Apply(v306, []any{v310, v314}) + v316 := lang.Apply(v303, []any{v315}) + v317 := lang.Apply(v300, []any{v316}) + v318 := lang.Apply(v262, []any{v266, v297, v317}) + v319 := lang.Apply(v259, []any{v318}) + v320 := lang.Apply(v256, []any{v319}) + v321 := lang.Apply(v241, []any{v245, v253, v320}) + v322 := lang.Apply(v238, []any{v321}) + v323 := lang.Apply(v235, []any{v322}) + v324 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v325 := v324.FindInternedVar(lang.NewSymbol("list")) + if v325.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v325))) + } + v326 := v325.Get() + v327 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v328 := v327.FindInternedVar(lang.NewSymbol("seq")) + if v328.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v328))) + } + v329 := v328.Get() + v330 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v331 := v330.FindInternedVar(lang.NewSymbol("concat")) + if v331.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v331))) + } + v332 := v331.Get() + v333 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v334 := v333.FindInternedVar(lang.NewSymbol("list")) + if v334.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v334))) + } + v335 := v334.Get() + v336 := lang.Apply(v335, []any{lang.NewSymbol("glojure.core/swap!")}) + v337 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v338 := v337.FindInternedVar(lang.NewSymbol("list")) + if v338.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v338))) + } + v339 := v338.Get() + v340 := lang.Apply(v339, []any{v5}) + v341 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v342 := v341.FindInternedVar(lang.NewSymbol("list")) + if v342.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v342))) + } + v343 := v342.Get() + v344 := lang.Apply(v343, []any{lang.NewSymbol("glojure.core/assoc-in")}) + v345 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v346 := v345.FindInternedVar(lang.NewSymbol("list")) + if v346.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v346))) + } + v347 := v346.Get() + v348 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v349 := v348.FindInternedVar(lang.NewSymbol("apply")) + if v349.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v349))) + } + v350 := v349.Get() + v351 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v352 := v351.FindInternedVar(lang.NewSymbol("vector")) + if v352.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v352))) + } + v353 := v352.Get() + v354 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v355 := v354.FindInternedVar(lang.NewSymbol("seq")) + if v355.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v355))) + } + v356 := v355.Get() + v357 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v358 := v357.FindInternedVar(lang.NewSymbol("concat")) + if v358.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v358))) + } + v359 := v358.Get() + v360 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v361 := v360.FindInternedVar(lang.NewSymbol("list")) + if v361.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v361))) + } + v362 := v361.Get() + v363 := lang.Apply(v362, []any{lang.NewKeyword("multis")}) + v364 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v365 := v364.FindInternedVar(lang.NewSymbol("list")) + if v365.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v365))) + } + v366 := v365.Get() + v367 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v368 := v367.FindInternedVar(lang.NewSymbol("seq")) + if v368.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v368))) + } + v369 := v368.Get() + v370 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v371 := v370.FindInternedVar(lang.NewSymbol("concat")) + if v371.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v371))) + } + v372 := v371.Get() + v373 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v374 := v373.FindInternedVar(lang.NewSymbol("list")) + if v374.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v374))) + } + v375 := v374.Get() + v376 := lang.Apply(v375, []any{lang.NewSymbol("glojure.core/keyword")}) + v377 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v378 := v377.FindInternedVar(lang.NewSymbol("list")) + if v378.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v378))) + } + v379 := v378.Get() + v380 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v381 := v380.FindInternedVar(lang.NewSymbol("seq")) + if v381.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v381))) + } + v382 := v381.Get() + v383 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v384 := v383.FindInternedVar(lang.NewSymbol("concat")) + if v384.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v384))) + } + v385 := v384.Get() + v386 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v387 := v386.FindInternedVar(lang.NewSymbol("list")) + if v387.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v387))) + } + v388 := v387.Get() + v389 := lang.Apply(v388, []any{lang.NewSymbol("quote")}) + v390 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v391 := v390.FindInternedVar(lang.NewSymbol("list")) + if v391.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v391))) + } + v392 := v391.Get() + v393 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v394 := v393.FindInternedVar(lang.NewSymbol("first")) + if v394.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v394))) + } + v395 := v394.Get() + v396 := lang.Apply(v395, []any{v222}) + v397 := lang.Apply(v392, []any{v396}) + v398 := lang.Apply(v385, []any{v389, v397}) + v399 := lang.Apply(v382, []any{v398}) + v400 := lang.Apply(v379, []any{v399}) + v401 := lang.Apply(v372, []any{v376, v400}) + v402 := lang.Apply(v369, []any{v401}) + v403 := lang.Apply(v366, []any{v402}) + v404 := lang.Apply(v359, []any{v363, v403}) + v405 := lang.Apply(v356, []any{v404}) + v406 := lang.Apply(v350, []any{v353, v405}) + v407 := lang.Apply(v347, []any{v406}) + v408 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v409 := v408.FindInternedVar(lang.NewSymbol("list")) + if v409.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v409))) + } + v410 := v409.Get() + v411 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v412 := v411.FindInternedVar(lang.NewSymbol("first")) + if v412.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v412))) + } + v413 := v412.Get() + v414 := lang.Apply(v413, []any{v222}) + v415 := lang.Apply(v410, []any{v414}) + v416 := lang.Apply(v332, []any{v336, v340, v344, v407, v415}) + v417 := lang.Apply(v329, []any{v416}) + v418 := lang.Apply(v326, []any{v417}) + v419 := lang.Apply(v228, []any{v232, v323, v418}) + v420 := lang.Apply(v225, []any{v419}) + return v420 + }) + v222 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(102), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(104), lang.NewKeyword("end-column"), int(90)) + v223, err := lang.WithMeta(v221, v222.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v224 := lang.Apply(v220, []any{v223, v43}) + v225 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v226 := v225.FindInternedVar(lang.NewSymbol("list")) + if v226.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v226))) + } + v227 := v226.Get() + v228 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v229 := v228.FindInternedVar(lang.NewSymbol("seq")) + if v229.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v229))) + } + v230 := v229.Get() + v231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v232 := v231.FindInternedVar(lang.NewSymbol("concat")) + if v232.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v232))) + } + v233 := v232.Get() + v234 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v235 := v234.FindInternedVar(lang.NewSymbol("list")) + if v235.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v235))) + } + v236 := v235.Get() + v237 := lang.Apply(v236, []any{lang.NewSymbol("var")}) + v238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v239 := v238.FindInternedVar(lang.NewSymbol("list")) + if v239.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v239))) + } + v240 := v239.Get() + v241 := lang.Apply(v240, []any{v5}) + v242 := lang.Apply(v233, []any{v237, v241}) + v243 := lang.Apply(v230, []any{v242}) + v244 := lang.Apply(v227, []any{v243}) + v245 := lang.Apply(v55, []any{v59, v169, v217, v224, v244}) + v246 := lang.Apply(v52, []any{v245}) + v7 = v246 + } // end let + return v7 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // defstruct + { + v0 := lang.NewSymbol("defstruct").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("keys"))), lang.NewKeyword("doc"), "Same as (def name (create-struct keys...))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4044), lang.NewKeyword("end-line"), int(4044))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("seq")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("concat")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("list")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{lang.NewSymbol("def")}) + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("list")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.Apply(v19, []any{v5}) + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("list")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("seq")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("concat")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("list")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.Apply(v32, []any{lang.NewSymbol("glojure.core/create-struct")}) + v34 := lang.Apply(v29, []any{v33, v6}) + v35 := lang.Apply(v26, []any{v34}) + v36 := lang.Apply(v23, []any{v35}) + v37 := lang.Apply(v12, []any{v16, v20, v36}) + v38 := lang.Apply(v9, []any{v37}) + return v38 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // delay + { + v0 := lang.NewSymbol("delay").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Takes a body of expressions and yields a Delay object that will\n invoke the body only the first time it is forced (with force or deref/@), and\n will cache the result and return it on all subsequent force\n calls. See also - realized?", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(739), lang.NewKeyword("end-line"), int(739))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.NewList(args[2:]...) + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("list")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("list*")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.NewVector() + v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(746), lang.NewKeyword("column"), int(62), lang.NewKeyword("end-line"), int(746), lang.NewKeyword("end-column"), int(63)) + v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v15 := lang.Apply(v11, []any{lang.NewSymbol("fn*"), v14, v5}) + v16 := lang.Apply(v8, []any{lang.NewSymbol("new"), lang.NewSymbol("glojure.lang.Delay"), v15}) + return v16 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // delay? + { + v0 := lang.NewSymbol("delay?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "returns true if x is a Delay created with delay", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(748), lang.NewKeyword("end-line"), int(748))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.Apply(v6, []any{nil, v3}) + return v7 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // deliver + { + v0 := lang.NewSymbol("deliver").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("promise"), lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Delivers the supplied value to the promise, releasing any pending\n derefs. A subsequent call to deliver on a promise will have no effect.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7109), lang.NewKeyword("end-line"), int(7109))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.Apply(v3, []any{v4}) + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // denominator + { + v1 := reflect.TypeOf((*big6.Int)(nil)) + v0 := lang.NewSymbol("denominator").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("r"))), lang.NewKeyword("doc"), "Returns the denominator part of a Ratio.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3591), lang.NewKeyword("end-line"), int(3591))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5, ok := lang.FieldOrMethod(v4, "denominator") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "denominator"))) + } + var v6 any + switch reflect.TypeOf(v5).Kind() { + case reflect.Func: + v6 = lang.Apply(v5, nil) + default: + v6 = v5 + } + return v6 + }) + v4 := reflect.TypeOf((*big6.Int)(nil)) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // deref + { + v0 := lang.NewSymbol("deref").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref")), lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("timeout-ms"), lang.NewSymbol("timeout-val"))), lang.NewKeyword("doc"), "Also reader macro: @ref/@agent/@var/@atom/@delay/@future/@promise. Within a transaction,\n returns the in-transaction-value of ref, else returns the\n most-recently-committed value of ref. When applied to a var, agent\n or atom, returns its current state. When applied to a delay, forces\n it if not already forced. When applied to a future, will block if\n computation not complete. When applied to a promise, will block\n until a value is delivered. The variant taking a timeout can be\n used for blocking references (futures and promises), and will return\n timeout-val if the timeout (in milliseconds) is reached before a\n value is available. See also - realized?.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2304), lang.NewKeyword("end-line"), int(2304))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + var v4 any + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{lang.IDeref, v3}) + if lang.IsTruthy(v8) { + v9, ok := lang.FieldOrMethod(v3, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "Deref"))) + } + var v10 any + switch reflect.TypeOf(v9).Kind() { + case reflect.Func: + v10 = lang.Apply(v9, nil) + default: + v10 = v9 + } + v4 = v10 + } else { + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("deref-future")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{v3}) + v4 = v14 + } + return v4 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("instance?")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, []any{lang.IBlockingDeref, v3}) + if lang.IsTruthy(v10) { + v11, _ := lang.FieldOrMethod(v3, "DerefWithTimeout") + if reflect.TypeOf(v11).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("DerefWithTimeout is not a function"))) + } + v12 := lang.Apply(v11, []any{v4, v5}) + v6 = v12 + } else { + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("deref-future")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{v3, v4, v5}) + v6 = v16 + } + return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // deref-as-map + { + v0 := lang.NewSymbol("deref-as-map").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(408), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(408), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + { // let + // let binding "pending" + var v5 any + { // let + // let binding "and__0__auto__" + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{lang.IPending, v3}) + var v10 any = v9 + _ = v10 + var v11 any + if lang.IsTruthy(v10) { + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("not")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15, ok := lang.FieldOrMethod(v3, "isRealized") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "isRealized"))) + } + var v16 any + switch reflect.TypeOf(v15).Kind() { + case reflect.Func: + v16 = lang.Apply(v15, nil) + default: + v16 = v15 + } + v17 := lang.Apply(v14, []any{v16}) + v11 = v17 + } else { + v11 = v10 + } + v5 = v11 + } // end let + var v6 any = v5 + _ = v6 + // let binding "vec__250" + var v7 any + if lang.IsTruthy(v6) { + v7 = nil + } else { + var v8 any + func() { + defer func() { + if r := recover(); r != nil { + if lang.CatchMatches(r, lang.Throwable) { + v9 := r + _ = v9 + v10 := lang.NewVector(true, v9) + v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(415), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(415), lang.NewKeyword("end-column"), int(25)) + v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v8 = v12 + } else { + panic(r) + } + } + }() + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("deref")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.Apply(v11, []any{v3}) + v13 := lang.NewVector(false, v12) + v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(413), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(413), lang.NewKeyword("end-column"), int(32)) + v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v8 = v15 + }() + v7 = v8 + } + var v16 any = v7 + _ = v16 + // let binding "ex" + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("nth")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.Apply(v19, []any{v16, int64(0), nil}) + var v21 any = v20 + _ = v21 + // let binding "val" + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("nth")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v16, int64(1), nil}) + var v26 any = v25 + _ = v26 + var v27 any + var v28 any + { // let + // let binding "or__0__auto__" + var v29 any = v21 + _ = v29 + var v30 any + if lang.IsTruthy(v29) { + v30 = v29 + } else { + var v31 any + { // let + // let binding "and__0__auto__" + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("instance?")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{*lang.Agent, v3}) + var v36 any = v35 + _ = v36 + var v37 any + if lang.IsTruthy(v36) { + v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v39 := v38.FindInternedVar(lang.NewSymbol("agent-error")) + if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + } + v40 := v39.Get() + v41 := lang.Apply(v40, []any{v3}) + v37 = v41 + } else { + v37 = v36 + } + v31 = v37 + } // end let + v30 = v31 + } + v28 = v30 + } // end let + if lang.IsTruthy(v28) { + v27 = lang.NewKeyword("failed") + } else { + var v29 any + if lang.IsTruthy(v6) { + v29 = lang.NewKeyword("pending") + } else { + var v30 any + if lang.IsTruthy(lang.NewKeyword("else")) { + v30 = lang.NewKeyword("ready") + } else { + v30 = nil + } + v29 = v30 + } + v27 = v29 + } + v31 := lang.NewMap(lang.NewKeyword("status"), v27, lang.NewKeyword("val"), v26) + v32 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(416), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(429), lang.NewKeyword("end-column"), int(14)) + v33, err := lang.WithMeta(v31, v32.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v4 = v33 + } // end let + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // deref-future + { + v0 := lang.NewSymbol("deref-future").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2296), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(2296), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fut")), lang.NewVector(lang.NewSymbol("fut"), lang.NewSymbol("timeout-ms"), lang.NewSymbol("timeout-val"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + v4, ok := lang.FieldOrMethod(v3, "Get") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "Get"))) + } + var v5 any + switch reflect.TypeOf(v4).Kind() { + case reflect.Func: + v5 = lang.Apply(v4, nil) + default: + v5 = v4 + } + return v5 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any + func() { + defer func() { + if r := recover(); r != nil { + if lang.CatchMatches(r, lang.TimeoutError) { + v7 := r + _ = v7 + v6 = v5 + } else { + panic(r) + } + } + }() + v7, _ := lang.FieldOrMethod(v3, "Get") + if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Get is not a function"))) + } + v8 := lang.Apply(v7, []any{v4, time7.Millisecond}) + v6 = v8 + }() + return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // derive + { + v0 := lang.NewSymbol("derive").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag"), lang.NewSymbol("parent")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"), lang.NewSymbol("parent"))), lang.NewKeyword("doc"), "Establishes a parent/child relationship between parent and\n tag. Parent must be a namespace-qualified symbol or keyword and\n child can be either a namespace-qualified symbol or keyword or a\n class. h must be a hierarchy obtained from make-hierarchy, if not\n supplied defaults to, and modifies, the global hierarchy.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5605), lang.NewKeyword("end-line"), int(5605))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + _ = nil + _ = nil + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("alter-var-root")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("global-hierarchy")) + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("derive")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.Apply(v7, []any{v8, v11, v3, v4}) + _ = v12 + return nil + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + _ = nil + _ = nil + _ = nil + var v6 any + { // let + // let binding "tp" + v7 := lang.Apply(lang.NewKeyword("parents"), []any{v3}) + var v8 any = v7 + _ = v8 + // let binding "td" + v9 := lang.Apply(lang.NewKeyword("descendants"), []any{v3}) + var v10 any = v9 + _ = v10 + // let binding "ta" + v11 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) + var v12 any = v11 + _ = v12 + // let binding "tf" + var v13 lang.FnFunc + v13 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 5 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v14 := args[0] + _ = v14 + v15 := args[1] + _ = v15 + v16 := args[2] + _ = v16 + v17 := args[3] + _ = v17 + v18 := args[4] + _ = v18 + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("reduce1")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + var v22 lang.FnFunc + v22 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v23 := args[0] + _ = v23 + v24 := args[1] + _ = v24 + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("assoc")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("reduce1")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("conj")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("get")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.CreatePersistentTreeSet() + v38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5628), lang.NewKeyword("column"), int(61), lang.NewKeyword("end-line"), int(5628), lang.NewKeyword("end-column"), int(63)) + v39, err := lang.WithMeta(v37, v38.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v40 := lang.Apply(v36, []any{v18, v24, v39}) + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("cons")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.Apply(v18, []any{v17}) + v45 := lang.Apply(v43, []any{v17, v44}) + v46 := lang.Apply(v30, []any{v33, v40, v45}) + v47 := lang.Apply(v27, []any{v23, v24, v46}) + return v47 + }) + v23 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5626), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(5628), lang.NewKeyword("end-column"), int(98)) + v24, err := lang.WithMeta(v22, v23.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("cons")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.Apply(v16, []any{v15}) + v29 := lang.Apply(v27, []any{v15, v28}) + v30 := lang.Apply(v21, []any{v24, v14, v29}) + return v30 + }) + v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5625), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(5629), lang.NewKeyword("end-column"), int(56)) + v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v16 any = v15 + _ = v16 + var v17 any + { // let + // let binding "or__0__auto__" + var v18 any + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("contains?")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v8, []any{v4}) + v23 := lang.Apply(v21, []any{v22, v5}) + if lang.IsTruthy(v23) { + v18 = nil + } else { + var v24 any + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("contains?")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.Apply(v12, []any{v4}) + v29 := lang.Apply(v27, []any{v28, v5}) + if lang.IsTruthy(v29) { + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("print-str")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.Apply(v32, []any{v4, "already has", v5, "as ancestor"}) + v34 := lang.Apply(lang.NewError, []any{v33}) + panic(v34) + } else { + v24 = nil + } + _ = v24 + var v35 any + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("contains?")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v12, []any{v5}) + v40 := lang.Apply(v38, []any{v39, v4}) + if lang.IsTruthy(v40) { + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("print-str")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.Apply(v43, []any{"Cyclic derivation:", v5, "has", v4, "as ancestor"}) + v45 := lang.Apply(lang.NewError, []any{v44}) + panic(v45) + } else { + v35 = nil + } + _ = v35 + v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v47 := v46.FindInternedVar(lang.NewSymbol("assoc")) + if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) + } + v48 := v47.Get() + v49 := lang.Apply(lang.NewKeyword("parents"), []any{v3}) + v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v51 := v50.FindInternedVar(lang.NewSymbol("conj")) + if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) + } + v52 := v51.Get() + v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v54 := v53.FindInternedVar(lang.NewSymbol("get")) + if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) + } + v55 := v54.Get() + v56 := lang.CreatePersistentTreeSet() + v57 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5636), lang.NewKeyword("column"), int(61), lang.NewKeyword("end-line"), int(5636), lang.NewKeyword("end-column"), int(63)) + v58, err := lang.WithMeta(v56, v57.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v59 := lang.Apply(v55, []any{v8, v4, v58}) + v60 := lang.Apply(v52, []any{v59, v5}) + v61 := lang.Apply(v48, []any{v49, v4, v60}) + v62 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) + v63 := lang.Apply(v16, []any{v62, v4, v10, v5, v12}) + v64 := lang.Apply(lang.NewKeyword("descendants"), []any{v3}) + v65 := lang.Apply(v16, []any{v64, v5, v12, v4, v10}) + v66 := lang.NewMap(lang.NewKeyword("parents"), v61, lang.NewKeyword("ancestors"), v63, lang.NewKeyword("descendants"), v65) + v67 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5636), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(5638), lang.NewKeyword("end-column"), int(61)) + v68, err := lang.WithMeta(v66, v67.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v18 = v68 + } + var v69 any = v18 + _ = v69 + var v70 any + if lang.IsTruthy(v69) { + v70 = v69 + } else { + v70 = v3 + } + v17 = v70 + } // end let + v6 = v17 + } // end let + return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // descendants + { + v0 := lang.NewSymbol("descendants").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"))), lang.NewKeyword("doc"), "Returns the immediate and indirect children of tag, through a\n relationship established via derive. h must be a hierarchy obtained\n from make-hierarchy, if not supplied defaults to the global\n hierarchy. Note: does not work on Java type inheritance\n relationships.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5593), lang.NewKeyword("end-line"), int(5593))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("descendants")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("global-hierarchy")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v6, []any{v9, v3}) + return v10 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("class?")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{v4}) + if lang.IsTruthy(v9) { + v10 := lang.Apply(lang.NewUnsupportedOperationError, []any{"Can't get descendants of classes"}) + panic(v10) + } else { + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("not-empty")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("get")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(lang.NewKeyword("descendants"), []any{v3}) + v18 := lang.Apply(v16, []any{v17, v4}) + v19 := lang.Apply(v13, []any{v18}) + v5 = v19 + } + return v5 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // destructure + { + v0 := lang.NewSymbol("destructure").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4400), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(4400), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + { // let + // let binding "bents" + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("partition")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{int64(2), v3}) + var v9 any = v8 + _ = v9 + // let binding "pb" + var v10 lang.FnFunc + { // function pb + v10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v12 := args[0] + _ = v12 + v13 := args[1] + _ = v13 + v14 := args[2] + _ = v14 + var v15 any + { // let + // let binding "pvec" + var v16 lang.FnFunc + v16 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v17 := args[0] + _ = v17 + v18 := args[1] + _ = v18 + v19 := args[2] + _ = v19 + var v20 any + { // let + // let binding "gvec" + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("gensym")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.Apply(v23, []any{"vec__"}) + var v25 any = v24 + _ = v25 + // let binding "gseq" + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("gensym")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.Apply(v28, []any{"seq__"}) + var v30 any = v29 + _ = v30 + // let binding "gfirst" + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("gensym")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{"first__"}) + var v35 any = v34 + _ = v35 + // let binding "has-rest" + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("some")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.CreatePersistentTreeSet(lang.NewSymbol("&")) + v40 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4408), lang.NewKeyword("column"), int(43), lang.NewKeyword("end-line"), int(4408), lang.NewKeyword("end-column"), int(47)) + v41, err := lang.WithMeta(v39, v40.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v42 := lang.Apply(v38, []any{v41, v18}) + var v43 any = v42 + _ = v43 + var v44 any + { // let + // let binding "ret" + var v45 any + { // let + // let binding "ret" + v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v47 := v46.FindInternedVar(lang.NewSymbol("conj")) + if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) + } + v48 := v47.Get() + v49 := lang.Apply(v48, []any{v17, v25, v19}) + var v50 any = v49 + _ = v50 + var v51 any + if lang.IsTruthy(v43) { + v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v53 := v52.FindInternedVar(lang.NewSymbol("conj")) + if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) + } + v54 := v53.Get() + v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v56 := v55.FindInternedVar(lang.NewSymbol("list")) + if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) + } + v57 := v56.Get() + v58 := lang.Apply(v57, []any{lang.NewSymbol("glojure.core/seq"), v25}) + v59 := lang.Apply(v54, []any{v50, v30, v58}) + v51 = v59 + } else { + v51 = v50 + } + v45 = v51 + } // end let + var v46 any = v45 + _ = v46 + // let binding "n" + var v47 any = int64(0) + _ = v47 + // let binding "bs" + var v48 any = v18 + _ = v48 + // let binding "seen-rest?" + var v49 any = false + _ = v49 + for { + var v50 any + v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v52 := v51.FindInternedVar(lang.NewSymbol("seq")) + if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) + } + v53 := v52.Get() + v54 := lang.Apply(v53, []any{v48}) + if lang.IsTruthy(v54) { + var v55 any + { // let + // let binding "firstb" + v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v57 := v56.FindInternedVar(lang.NewSymbol("first")) + if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) + } + v58 := v57.Get() + v59 := lang.Apply(v58, []any{v48}) + var v60 any = v59 + _ = v60 + var v61 any + v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v63 := v62.FindInternedVar(lang.NewSymbol("=")) + if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) + } + v64 := v63.Get() + v65 := lang.Apply(v64, []any{v60, lang.NewSymbol("&")}) + if lang.IsTruthy(v65) { + v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v68 := v67.FindInternedVar(lang.NewSymbol("second")) + if v68.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) + } + v69 := v68.Get() + v70 := lang.Apply(v69, []any{v48}) + v71 := lang.Apply(v11, []any{v46, v70, v30}) + var v66 any = v71 + var v72 any = v47 + v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v75 := v74.FindInternedVar(lang.NewSymbol("nnext")) + if v75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) + } + v76 := v75.Get() + v77 := lang.Apply(v76, []any{v48}) + var v73 any = v77 + var v78 any = true + v46 = v66 + v47 = v72 + v48 = v73 + v49 = v78 + continue + } else { + var v79 any + v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v81 := v80.FindInternedVar(lang.NewSymbol("=")) + if v81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) + } + v82 := v81.Get() + v83 := lang.Apply(v82, []any{v60, lang.NewKeyword("as")}) + if lang.IsTruthy(v83) { + v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v85 := v84.FindInternedVar(lang.NewSymbol("second")) + if v85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) + } + v86 := v85.Get() + v87 := lang.Apply(v86, []any{v48}) + v88 := lang.Apply(v11, []any{v46, v87, v25}) + v79 = v88 + } else { + var v89 any + if lang.IsTruthy(lang.NewKeyword("else")) { + var v90 any + if lang.IsTruthy(v49) { + v91 := lang.Apply(errors5.New, []any{"Unsupported binding form, only :as can follow & parameter"}) + panic(v91) + } else { + var v93 any + if lang.IsTruthy(v43) { + v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v95 := v94.FindInternedVar(lang.NewSymbol("conj")) + if v95.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) + } + v96 := v95.Get() + v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v98 := v97.FindInternedVar(lang.NewSymbol("seq")) + if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) + } + v99 := v98.Get() + v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v101 := v100.FindInternedVar(lang.NewSymbol("concat")) + if v101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) + } + v102 := v101.Get() + v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v104 := v103.FindInternedVar(lang.NewSymbol("list")) + if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) + } + v105 := v104.Get() + v106 := lang.Apply(v105, []any{lang.NewSymbol("glojure.core/first")}) + v107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v108 := v107.FindInternedVar(lang.NewSymbol("list")) + if v108.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v108))) + } + v109 := v108.Get() + v110 := lang.Apply(v109, []any{v30}) + v111 := lang.Apply(v102, []any{v106, v110}) + v112 := lang.Apply(v99, []any{v111}) + v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v114 := v113.FindInternedVar(lang.NewSymbol("seq")) + if v114.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) + } + v115 := v114.Get() + v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v117 := v116.FindInternedVar(lang.NewSymbol("concat")) + if v117.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) + } + v118 := v117.Get() + v119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v120 := v119.FindInternedVar(lang.NewSymbol("list")) + if v120.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v120))) + } + v121 := v120.Get() + v122 := lang.Apply(v121, []any{lang.NewSymbol("glojure.core/next")}) + v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v124 := v123.FindInternedVar(lang.NewSymbol("list")) + if v124.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) + } + v125 := v124.Get() + v126 := lang.Apply(v125, []any{v30}) + v127 := lang.Apply(v118, []any{v122, v126}) + v128 := lang.Apply(v115, []any{v127}) + v129 := lang.Apply(v96, []any{v46, v35, v112, v30, v128}) + v93 = v129 + } else { + v93 = v46 + } + var v130 any + if lang.IsTruthy(v43) { + v130 = v35 + } else { + v131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v132 := v131.FindInternedVar(lang.NewSymbol("list")) + if v132.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v132))) + } + v133 := v132.Get() + v134 := lang.Apply(v133, []any{lang.NewSymbol("glojure.core/nth"), v25, v47, nil}) + v130 = v134 + } + v135 := lang.Apply(v11, []any{v93, v60, v130}) + var v92 any = v135 + v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v138 := v137.FindInternedVar(lang.NewSymbol("inc")) + if v138.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) + } + v139 := v138.Get() + v140 := lang.Apply(v139, []any{v47}) + var v136 any = v140 + v142 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v143 := v142.FindInternedVar(lang.NewSymbol("next")) + if v143.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v143))) + } + v144 := v143.Get() + v145 := lang.Apply(v144, []any{v48}) + var v141 any = v145 + var v146 any = v49 + v46 = v92 + v47 = v136 + v48 = v141 + v49 = v146 + continue + } + v89 = v90 + } else { + v89 = nil + } + v79 = v89 + } + v61 = v79 + } + v55 = v61 + } // end let + v50 = v55 + } else { + v50 = v46 + } + v44 = v50 + break + } + } // end let + v20 = v44 + } // end let + return v20 + }) + v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4404), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(4438), lang.NewKeyword("end-column"), int(34)) + v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v19 any = v18 + _ = v19 + // let binding "pmap" + var v20 lang.FnFunc + v20 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v21 := args[0] + _ = v21 + v22 := args[1] + _ = v22 + v23 := args[2] + _ = v23 + var v24 any + { // let + // let binding "gmap" + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("gensym")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.Apply(v27, []any{"map__"}) + var v29 any = v28 + _ = v29 + // let binding "gmapseq" + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("with-meta")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.NewMap(lang.NewKeyword("tag"), lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.ISeq")) + v34 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4442), lang.NewKeyword("column"), int(52), lang.NewKeyword("end-line"), int(4442), lang.NewKeyword("end-column"), int(103)) + v35, err := lang.WithMeta(v33, v34.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v36 := lang.Apply(v32, []any{v29, v35}) + var v37 any = v36 + _ = v37 + // let binding "defaults" + v38 := lang.Apply(lang.NewKeyword("or"), []any{v22}) + var v39 any = v38 + _ = v39 + var v40 any + { // let + // let binding "ret" + var v41 lang.FnFunc + v41 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v42 := args[0] + _ = v42 + var v43 any + v44 := lang.Apply(lang.NewKeyword("as"), []any{v22}) + if lang.IsTruthy(v44) { + v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v46 := v45.FindInternedVar(lang.NewSymbol("conj")) + if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) + } + v47 := v46.Get() + v48 := lang.Apply(lang.NewKeyword("as"), []any{v22}) + v49 := lang.Apply(v47, []any{v42, v48, v29}) + v43 = v49 + } else { + v43 = v42 + } + return v43 + }) + v42 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4450), lang.NewKeyword("column"), int(40), lang.NewKeyword("end-line"), int(4453), lang.NewKeyword("end-column"), int(48)) + v43, err := lang.WithMeta(v41, v42.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("conj")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v48 := v47.FindInternedVar(lang.NewSymbol("conj")) + if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) + } + v49 := v48.Get() + v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v51 := v50.FindInternedVar(lang.NewSymbol("conj")) + if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) + } + v52 := v51.Get() + v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v54 := v53.FindInternedVar(lang.NewSymbol("conj")) + if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) + } + v55 := v54.Get() + v56 := lang.Apply(v55, []any{v21, v29}) + v57 := lang.Apply(v52, []any{v56, v23}) + v58 := lang.Apply(v49, []any{v57, v29}) + v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v60 := v59.FindInternedVar(lang.NewSymbol("seq")) + if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) + } + v61 := v60.Get() + v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v63 := v62.FindInternedVar(lang.NewSymbol("concat")) + if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) + } + v64 := v63.Get() + v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v66 := v65.FindInternedVar(lang.NewSymbol("list")) + if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) + } + v67 := v66.Get() + v68 := lang.Apply(v67, []any{lang.NewSymbol("if")}) + v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v70 := v69.FindInternedVar(lang.NewSymbol("list")) + if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) + } + v71 := v70.Get() + v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v73 := v72.FindInternedVar(lang.NewSymbol("seq")) + if v73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) + } + v74 := v73.Get() + v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v76 := v75.FindInternedVar(lang.NewSymbol("concat")) + if v76.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) + } + v77 := v76.Get() + v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v79 := v78.FindInternedVar(lang.NewSymbol("list")) + if v79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) + } + v80 := v79.Get() + v81 := lang.Apply(v80, []any{lang.NewSymbol("glojure.core/seq?")}) + v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v83 := v82.FindInternedVar(lang.NewSymbol("list")) + if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) + } + v84 := v83.Get() + v85 := lang.Apply(v84, []any{v29}) + v86 := lang.Apply(v77, []any{v81, v85}) + v87 := lang.Apply(v74, []any{v86}) + v88 := lang.Apply(v71, []any{v87}) + v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v90 := v89.FindInternedVar(lang.NewSymbol("list")) + if v90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) + } + v91 := v90.Get() + v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v93 := v92.FindInternedVar(lang.NewSymbol("seq")) + if v93.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) + } + v94 := v93.Get() + v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v96 := v95.FindInternedVar(lang.NewSymbol("concat")) + if v96.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) + } + v97 := v96.Get() + v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v99 := v98.FindInternedVar(lang.NewSymbol("list")) + if v99.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) + } + v100 := v99.Get() + v101 := lang.Apply(v100, []any{lang.NewSymbol("if")}) + v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v103 := v102.FindInternedVar(lang.NewSymbol("list")) + if v103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) + } + v104 := v103.Get() + v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v106 := v105.FindInternedVar(lang.NewSymbol("seq")) + if v106.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) + } + v107 := v106.Get() + v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v109 := v108.FindInternedVar(lang.NewSymbol("concat")) + if v109.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) + } + v110 := v109.Get() + v111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v112 := v111.FindInternedVar(lang.NewSymbol("list")) + if v112.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v112))) + } + v113 := v112.Get() + v114 := lang.Apply(v113, []any{lang.NewSymbol("glojure.core/next")}) + v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v116 := v115.FindInternedVar(lang.NewSymbol("list")) + if v116.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) + } + v117 := v116.Get() + v118 := lang.Apply(v117, []any{v37}) + v119 := lang.Apply(v110, []any{v114, v118}) + v120 := lang.Apply(v107, []any{v119}) + v121 := lang.Apply(v104, []any{v120}) + v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v123 := v122.FindInternedVar(lang.NewSymbol("list")) + if v123.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) + } + v124 := v123.Get() + v125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v126 := v125.FindInternedVar(lang.NewSymbol("seq")) + if v126.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v126))) + } + v127 := v126.Get() + v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v129 := v128.FindInternedVar(lang.NewSymbol("concat")) + if v129.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v129))) + } + v130 := v129.Get() + v131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v132 := v131.FindInternedVar(lang.NewSymbol("list")) + if v132.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v132))) + } + v133 := v132.Get() + v134 := lang.Apply(v133, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewPersistentArrayMapAsIfByAssoc")}) + v135 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v136 := v135.FindInternedVar(lang.NewSymbol("list")) + if v136.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v136))) + } + v137 := v136.Get() + v138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v139 := v138.FindInternedVar(lang.NewSymbol("seq")) + if v139.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v139))) + } + v140 := v139.Get() + v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v142 := v141.FindInternedVar(lang.NewSymbol("concat")) + if v142.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) + } + v143 := v142.Get() + v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v145 := v144.FindInternedVar(lang.NewSymbol("list")) + if v145.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) + } + v146 := v145.Get() + v147 := lang.Apply(v146, []any{lang.NewSymbol("glojure.core/to-array")}) + v148 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v149 := v148.FindInternedVar(lang.NewSymbol("list")) + if v149.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v149))) + } + v150 := v149.Get() + v151 := lang.Apply(v150, []any{v37}) + v152 := lang.Apply(v143, []any{v147, v151}) + v153 := lang.Apply(v140, []any{v152}) + v154 := lang.Apply(v137, []any{v153}) + v155 := lang.Apply(v130, []any{v134, v154}) + v156 := lang.Apply(v127, []any{v155}) + v157 := lang.Apply(v124, []any{v156}) + v158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v159 := v158.FindInternedVar(lang.NewSymbol("list")) + if v159.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v159))) + } + v160 := v159.Get() + v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v162 := v161.FindInternedVar(lang.NewSymbol("seq")) + if v162.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) + } + v163 := v162.Get() + v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v165 := v164.FindInternedVar(lang.NewSymbol("concat")) + if v165.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) + } + v166 := v165.Get() + v167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v168 := v167.FindInternedVar(lang.NewSymbol("list")) + if v168.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v168))) + } + v169 := v168.Get() + v170 := lang.Apply(v169, []any{lang.NewSymbol("if")}) + v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v172 := v171.FindInternedVar(lang.NewSymbol("list")) + if v172.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) + } + v173 := v172.Get() + v174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v175 := v174.FindInternedVar(lang.NewSymbol("seq")) + if v175.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v175))) + } + v176 := v175.Get() + v177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v178 := v177.FindInternedVar(lang.NewSymbol("concat")) + if v178.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v178))) + } + v179 := v178.Get() + v180 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v181 := v180.FindInternedVar(lang.NewSymbol("list")) + if v181.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v181))) + } + v182 := v181.Get() + v183 := lang.Apply(v182, []any{lang.NewSymbol("glojure.core/seq")}) + v184 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v185 := v184.FindInternedVar(lang.NewSymbol("list")) + if v185.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v185))) + } + v186 := v185.Get() + v187 := lang.Apply(v186, []any{v37}) + v188 := lang.Apply(v179, []any{v183, v187}) + v189 := lang.Apply(v176, []any{v188}) + v190 := lang.Apply(v173, []any{v189}) + v191 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v192 := v191.FindInternedVar(lang.NewSymbol("list")) + if v192.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v192))) + } + v193 := v192.Get() + v194 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v195 := v194.FindInternedVar(lang.NewSymbol("seq")) + if v195.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v195))) + } + v196 := v195.Get() + v197 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v198 := v197.FindInternedVar(lang.NewSymbol("concat")) + if v198.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v198))) + } + v199 := v198.Get() + v200 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v201 := v200.FindInternedVar(lang.NewSymbol("list")) + if v201.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v201))) + } + v202 := v201.Get() + v203 := lang.Apply(v202, []any{lang.NewSymbol("glojure.core/first")}) + v204 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v205 := v204.FindInternedVar(lang.NewSymbol("list")) + if v205.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v205))) + } + v206 := v205.Get() + v207 := lang.Apply(v206, []any{v37}) + v208 := lang.Apply(v199, []any{v203, v207}) + v209 := lang.Apply(v196, []any{v208}) + v210 := lang.Apply(v193, []any{v209}) + v211 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v212 := v211.FindInternedVar(lang.NewSymbol("list")) + if v212.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v212))) + } + v213 := v212.Get() + v214 := lang.Apply(v213, []any{lang.NewSymbol("glojure.lang.PersistentArrayMap/EMPTY")}) + v215 := lang.Apply(v166, []any{v170, v190, v210, v214}) + v216 := lang.Apply(v163, []any{v215}) + v217 := lang.Apply(v160, []any{v216}) + v218 := lang.Apply(v97, []any{v101, v121, v157, v217}) + v219 := lang.Apply(v94, []any{v218}) + v220 := lang.Apply(v91, []any{v219}) + v221 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v222 := v221.FindInternedVar(lang.NewSymbol("list")) + if v222.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v222))) + } + v223 := v222.Get() + v224 := lang.Apply(v223, []any{v29}) + v225 := lang.Apply(v64, []any{v68, v88, v220, v224}) + v226 := lang.Apply(v61, []any{v225}) + v227 := lang.Apply(v46, []any{v58, v226}) + v228 := lang.Apply(v43, []any{v227}) + var v229 any = v228 + _ = v229 + // let binding "bes" + var v230 any + { // let + // let binding "transforms" + v231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v232 := v231.FindInternedVar(lang.NewSymbol("reduce1")) + if v232.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v232))) + } + v233 := v232.Get() + var v234 lang.FnFunc + v234 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v235 := args[0] + _ = v235 + v236 := args[1] + _ = v236 + var v237 any + v238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v239 := v238.FindInternedVar(lang.NewSymbol("keyword?")) + if v239.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v239))) + } + v240 := v239.Get() + v241 := lang.Apply(v240, []any{v236}) + if lang.IsTruthy(v241) { + var v242 any + { // let + // let binding "mkns" + v243 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v244 := v243.FindInternedVar(lang.NewSymbol("namespace")) + if v244.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v244))) + } + v245 := v244.Get() + v246 := lang.Apply(v245, []any{v236}) + var v247 any = v246 + _ = v247 + // let binding "mkn" + v248 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v249 := v248.FindInternedVar(lang.NewSymbol("name")) + if v249.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v249))) + } + v250 := v249.Get() + v251 := lang.Apply(v250, []any{v236}) + var v252 any = v251 + _ = v252 + var v253 any + v254 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v255 := v254.FindInternedVar(lang.NewSymbol("=")) + if v255.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v255))) + } + v256 := v255.Get() + v257 := lang.Apply(v256, []any{v252, "keys"}) + if lang.IsTruthy(v257) { + v258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v259 := v258.FindInternedVar(lang.NewSymbol("assoc")) + if v259.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v259))) + } + v260 := v259.Get() + var v261 lang.FnFunc + v261 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v262 := args[0] + _ = v262 + v263 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v264 := v263.FindInternedVar(lang.NewSymbol("keyword")) + if v264.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v264))) + } + v265 := v264.Get() + var v266 any + { // let + // let binding "or__0__auto__" + var v267 any = v247 + _ = v267 + var v268 any + if lang.IsTruthy(v267) { + v268 = v267 + } else { + v269 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v270 := v269.FindInternedVar(lang.NewSymbol("namespace")) + if v270.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v270))) + } + v271 := v270.Get() + v272 := lang.Apply(v271, []any{v262}) + v268 = v272 + } + v266 = v268 + } // end let + v267 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v268 := v267.FindInternedVar(lang.NewSymbol("name")) + if v268.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v268))) + } + v269 := v268.Get() + v270 := lang.Apply(v269, []any{v262}) + v271 := lang.Apply(v265, []any{v266, v270}) + return v271 + }) + v262 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4460), lang.NewKeyword("column"), int(93), lang.NewKeyword("end-line"), int(4460), lang.NewKeyword("end-column"), int(135)) + v263, err := lang.WithMeta(v261, v262.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v264 := lang.Apply(v260, []any{v235, v236, v263}) + v253 = v264 + } else { + var v265 any + v266 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v267 := v266.FindInternedVar(lang.NewSymbol("=")) + if v267.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v267))) + } + v268 := v267.Get() + v269 := lang.Apply(v268, []any{v252, "syms"}) + if lang.IsTruthy(v269) { + v270 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v271 := v270.FindInternedVar(lang.NewSymbol("assoc")) + if v271.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v271))) + } + v272 := v271.Get() + var v273 lang.FnFunc + v273 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v274 := args[0] + _ = v274 + v275 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v276 := v275.FindInternedVar(lang.NewSymbol("list")) + if v276.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v276))) + } + v277 := v276.Get() + v278 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v279 := v278.FindInternedVar(lang.NewSymbol("symbol")) + if v279.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v279))) + } + v280 := v279.Get() + var v281 any + { // let + // let binding "or__0__auto__" + var v282 any = v247 + _ = v282 + var v283 any + if lang.IsTruthy(v282) { + v283 = v282 + } else { + v284 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v285 := v284.FindInternedVar(lang.NewSymbol("namespace")) + if v285.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v285))) + } + v286 := v285.Get() + v287 := lang.Apply(v286, []any{v274}) + v283 = v287 + } + v281 = v283 + } // end let + v282 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v283 := v282.FindInternedVar(lang.NewSymbol("name")) + if v283.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v283))) + } + v284 := v283.Get() + v285 := lang.Apply(v284, []any{v274}) + v286 := lang.Apply(v280, []any{v281, v285}) + v287 := lang.Apply(v277, []any{lang.NewSymbol("quote"), v286}) + return v287 + }) + v274 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4461), lang.NewKeyword("column"), int(93), lang.NewKeyword("end-line"), int(4461), lang.NewKeyword("end-column"), int(148)) + v275, err := lang.WithMeta(v273, v274.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v276 := lang.Apply(v272, []any{v235, v236, v275}) + v265 = v276 + } else { + var v277 any + v278 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v279 := v278.FindInternedVar(lang.NewSymbol("=")) + if v279.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v279))) + } + v280 := v279.Get() + v281 := lang.Apply(v280, []any{v252, "strs"}) + if lang.IsTruthy(v281) { + v282 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v283 := v282.FindInternedVar(lang.NewSymbol("assoc")) + if v283.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v283))) + } + v284 := v283.Get() + v285 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v286 := v285.FindInternedVar(lang.NewSymbol("str")) + if v286.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v286))) + } + v287 := v286.Get() + v288 := lang.Apply(v284, []any{v235, v236, v287}) + v277 = v288 + } else { + var v289 any + if lang.IsTruthy(lang.NewKeyword("else")) { + v289 = v235 + } else { + v289 = nil + } + v277 = v289 + } + v265 = v277 + } + v253 = v265 + } + v242 = v253 + } // end let + v237 = v242 + } else { + v237 = v235 + } + return v237 + }) + v235 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4456), lang.NewKeyword("column"), int(45), lang.NewKeyword("end-line"), int(4464), lang.NewKeyword("end-column"), int(60)) + v236, err := lang.WithMeta(v234, v235.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v237 := lang.NewMap() + v238 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4465), lang.NewKeyword("column"), int(45), lang.NewKeyword("end-line"), int(4465), lang.NewKeyword("end-column"), int(46)) + v239, err := lang.WithMeta(v237, v238.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v240 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v241 := v240.FindInternedVar(lang.NewSymbol("keys")) + if v241.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v241))) + } + v242 := v241.Get() + v243 := lang.Apply(v242, []any{v22}) + v244 := lang.Apply(v233, []any{v236, v239, v243}) + var v245 any = v244 + _ = v245 + v246 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v247 := v246.FindInternedVar(lang.NewSymbol("reduce1")) + if v247.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v247))) + } + v248 := v247.Get() + var v249 lang.FnFunc + v249 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v250 := args[0] + _ = v250 + v251 := args[1] + _ = v251 + v252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v253 := v252.FindInternedVar(lang.NewSymbol("reduce1")) + if v253.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v253))) + } + v254 := v253.Get() + var v255 lang.FnFunc + v255 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v256 := args[0] + _ = v256 + v257 := args[1] + _ = v257 + v258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v259 := v258.FindInternedVar(lang.NewSymbol("assoc")) + if v259.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v259))) + } + v260 := v259.Get() + v261 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v262 := v261.FindInternedVar(lang.NewSymbol("val")) + if v262.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v262))) + } + v263 := v262.Get() + v264 := lang.Apply(v263, []any{v251}) + v265 := lang.Apply(v264, []any{v257}) + v266 := lang.Apply(v260, []any{v256, v257, v265}) + return v266 + }) + v256 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4469), lang.NewKeyword("column"), int(52), lang.NewKeyword("end-line"), int(4469), lang.NewKeyword("end-column"), int(82)) + v257, err := lang.WithMeta(v255, v256.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v259 := v258.FindInternedVar(lang.NewSymbol("dissoc")) + if v259.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v259))) + } + v260 := v259.Get() + v261 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v262 := v261.FindInternedVar(lang.NewSymbol("key")) + if v262.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v262))) + } + v263 := v262.Get() + v264 := lang.Apply(v263, []any{v251}) + v265 := lang.Apply(v260, []any{v250, v264}) + v266 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v267 := v266.FindInternedVar(lang.NewSymbol("key")) + if v267.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v267))) + } + v268 := v267.Get() + v269 := lang.Apply(v268, []any{v251}) + v270 := lang.Apply(v269, []any{v250}) + v271 := lang.Apply(v254, []any{v257, v265, v270}) + return v271 + }) + v250 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4468), lang.NewKeyword("column"), int(41), lang.NewKeyword("end-line"), int(4471), lang.NewKeyword("end-column"), int(70)) + v251, err := lang.WithMeta(v249, v250.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v253 := v252.FindInternedVar(lang.NewSymbol("dissoc")) + if v253.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v253))) + } + v254 := v253.Get() + v255 := lang.Apply(v254, []any{v22, lang.NewKeyword("as"), lang.NewKeyword("or")}) + v256 := lang.Apply(v248, []any{v251, v255, v245}) + v230 = v256 + } // end let + var v231 any = v230 + _ = v231 + for { + var v232 any + v233 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v234 := v233.FindInternedVar(lang.NewSymbol("seq")) + if v234.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v234))) + } + v235 := v234.Get() + v236 := lang.Apply(v235, []any{v231}) + if lang.IsTruthy(v236) { + var v237 any + { // let + // let binding "bb" + v238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v239 := v238.FindInternedVar(lang.NewSymbol("key")) + if v239.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v239))) + } + v240 := v239.Get() + v241 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v242 := v241.FindInternedVar(lang.NewSymbol("first")) + if v242.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v242))) + } + v243 := v242.Get() + v244 := lang.Apply(v243, []any{v231}) + v245 := lang.Apply(v240, []any{v244}) + var v246 any = v245 + _ = v246 + // let binding "bk" + v247 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v248 := v247.FindInternedVar(lang.NewSymbol("val")) + if v248.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v248))) + } + v249 := v248.Get() + v250 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v251 := v250.FindInternedVar(lang.NewSymbol("first")) + if v251.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v251))) + } + v252 := v251.Get() + v253 := lang.Apply(v252, []any{v231}) + v254 := lang.Apply(v249, []any{v253}) + var v255 any = v254 + _ = v255 + // let binding "local" + var v256 any + v257 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v258 := v257.FindInternedVar(lang.NewSymbol("instance?")) + if v258.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v258))) + } + v259 := v258.Get() + v260 := lang.Apply(v259, []any{lang.Named, v246}) + if lang.IsTruthy(v260) { + v261 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v262 := v261.FindInternedVar(lang.NewSymbol("with-meta")) + if v262.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v262))) + } + v263 := v262.Get() + v264 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v265 := v264.FindInternedVar(lang.NewSymbol("symbol")) + if v265.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v265))) + } + v266 := v265.Get() + v267 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v268 := v267.FindInternedVar(lang.NewSymbol("name")) + if v268.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v268))) + } + v269 := v268.Get() + v270 := lang.Apply(v269, []any{v246}) + v271 := lang.Apply(v266, []any{nil, v270}) + v272 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v273 := v272.FindInternedVar(lang.NewSymbol("meta")) + if v273.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v273))) + } + v274 := v273.Get() + v275 := lang.Apply(v274, []any{v246}) + v276 := lang.Apply(v263, []any{v271, v275}) + v256 = v276 + } else { + v256 = v246 + } + var v277 any = v256 + _ = v277 + // let binding "bv" + var v278 any + v279 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v280 := v279.FindInternedVar(lang.NewSymbol("contains?")) + if v280.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v280))) + } + v281 := v280.Get() + v282 := lang.Apply(v281, []any{v39, v277}) + if lang.IsTruthy(v282) { + v283 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v284 := v283.FindInternedVar(lang.NewSymbol("list")) + if v284.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v284))) + } + v285 := v284.Get() + v286 := lang.Apply(v39, []any{v277}) + v287 := lang.Apply(v285, []any{lang.NewSymbol("glojure.core/get"), v29, v255, v286}) + v278 = v287 + } else { + v288 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v289 := v288.FindInternedVar(lang.NewSymbol("list")) + if v289.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v289))) + } + v290 := v289.Get() + v291 := lang.Apply(v290, []any{lang.NewSymbol("glojure.core/get"), v29, v255}) + v278 = v291 + } + var v292 any = v278 + _ = v292 + var v294 any + v295 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v296 := v295.FindInternedVar(lang.NewSymbol("ident?")) + if v296.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v296))) + } + v297 := v296.Get() + v298 := lang.Apply(v297, []any{v246}) + if lang.IsTruthy(v298) { + v299 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v300 := v299.FindInternedVar(lang.NewSymbol("conj")) + if v300.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v300))) + } + v301 := v300.Get() + v302 := lang.Apply(v301, []any{v229, v277, v292}) + v294 = v302 + } else { + v303 := lang.Apply(v11, []any{v229, v246, v292}) + v294 = v303 + } + var v293 any = v294 + v305 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v306 := v305.FindInternedVar(lang.NewSymbol("next")) + if v306.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v306))) + } + v307 := v306.Get() + v308 := lang.Apply(v307, []any{v231}) + var v304 any = v308 + v229 = v293 + v231 = v304 + continue + } // end let + v232 = v237 + } else { + v232 = v229 + } + v40 = v232 + break + } + } // end let + v24 = v40 + } // end let + return v24 + }) + v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4440), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(4485), lang.NewKeyword("end-column"), int(34)) + v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v23 any = v22 + _ = v23 + var v24 any + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("symbol?")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.Apply(v27, []any{v13}) + if lang.IsTruthy(v28) { + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("conj")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("conj")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{v12, v13}) + v36 := lang.Apply(v31, []any{v35, v14}) + v24 = v36 + } else { + var v37 any + v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v39 := v38.FindInternedVar(lang.NewSymbol("vector?")) + if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + } + v40 := v39.Get() + v41 := lang.Apply(v40, []any{v13}) + if lang.IsTruthy(v41) { + v42 := lang.Apply(v19, []any{v12, v13, v14}) + v37 = v42 + } else { + var v43 any + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("map?")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.Apply(v46, []any{v13}) + if lang.IsTruthy(v47) { + v48 := lang.Apply(v23, []any{v12, v13, v14}) + v43 = v48 + } else { + var v49 any + if lang.IsTruthy(lang.NewKeyword("else")) { + v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v51 := v50.FindInternedVar(lang.NewSymbol("str")) + if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) + } + v52 := v51.Get() + v53 := lang.Apply(v52, []any{"Unsupported binding form: ", v13}) + v54 := lang.Apply(errors5.New, []any{v53}) + panic(v54) + } else { + v49 = nil + } + v43 = v49 + } + v37 = v43 + } + v24 = v37 + } + v15 = v24 + } // end let + return v15 + }) + v11 := v10 + _ = v11 + } + v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4402), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(4490), lang.NewKeyword("end-column"), int(82)) + v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v13 any = v12 + _ = v13 + // let binding "process-entry" + var v14 lang.FnFunc + v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v15 := args[0] + _ = v15 + v16 := args[1] + _ = v16 + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("first")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.Apply(v19, []any{v16}) + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("second")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.Apply(v23, []any{v16}) + v25 := lang.Apply(v13, []any{v15, v20, v24}) + return v25 + }) + v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4491), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(4491), lang.NewKeyword("end-column"), int(66)) + v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v17 any = v16 + _ = v17 + var v18 any + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("every?")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("symbol?")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("map")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("first")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.Apply(v27, []any{v30, v9}) + v32 := lang.Apply(v21, []any{v24, v31}) + if lang.IsTruthy(v32) { + v18 = v3 + } else { + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("reduce1")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.NewVector() + v37 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4494), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(4494), lang.NewKeyword("end-column"), int(31)) + v38, err := lang.WithMeta(v36, v37.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v39 := lang.Apply(v35, []any{v17, v38, v9}) + v18 = v39 + } + v4 = v18 + } // end let + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // disj + { + v0 := lang.NewSymbol("disj").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("set")), lang.NewVector(lang.NewSymbol("set"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("set"), lang.NewSymbol("key"), lang.NewSymbol("&"), lang.NewSymbol("ks"))), lang.NewKeyword("doc"), "disj[oin]. Returns a new set of the same (hashed/sorted) type, that\n does not contain key(s).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1514), lang.NewKeyword("end-line"), int(1514))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + return v3 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any + if lang.IsTruthy(v3) { + v6, _ := lang.FieldOrMethod(v3, "Disjoin") + if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Disjoin is not a function"))) + } + v7 := lang.Apply(v6, []any{v4}) + v5 = v7 + } else { + v5 = nil + } + return v5 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.NewList(args[2:]...) + recur_loop_304: + var v6 any + if lang.IsTruthy(v3) { + var v7 any + { // let + // let binding "ret" + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("disj")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v3, v4}) + var v12 any = v11 + _ = v12 + var v13 any + if lang.IsTruthy(v5) { + var v14 any = v12 + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("first")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{v5}) + var v15 any = v19 + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("next")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.Apply(v23, []any{v5}) + var v20 any = v24 + v3 = v14 + v4 = v15 + v5 = v20 + goto recur_loop_304 + } else { + v13 = v12 + } + v7 = v13 + } // end let + v6 = v7 + } else { + v6 = nil + } + return v6 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // disj! + { + v0 := lang.NewSymbol("disj!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("set")), lang.NewVector(lang.NewSymbol("set"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("set"), lang.NewSymbol("key"), lang.NewSymbol("&"), lang.NewSymbol("ks"))), lang.NewKeyword("doc"), "disj[oin]. Returns a transient set of the same (hashed/sorted) type, that\n does not contain key(s).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3401), lang.NewKeyword("end-line"), int(3401))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + return v3 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5, _ := lang.FieldOrMethod(v3, "Disjoin") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Disjoin is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.NewList(args[2:]...) + recur_loop_615: + var v6 any + { // let + // let binding "ret" + v7, _ := lang.FieldOrMethod(v3, "Disjoin") + if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Disjoin is not a function"))) + } + v8 := lang.Apply(v7, []any{v4}) + var v9 any = v8 + _ = v9 + var v10 any + if lang.IsTruthy(v5) { + var v11 any = v9 + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("first")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{v5}) + var v12 any = v16 + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("next")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.Apply(v20, []any{v5}) + var v17 any = v21 + v3 = v11 + v4 = v12 + v5 = v17 + goto recur_loop_615 + } else { + v10 = v9 + } + v6 = v10 + } // end let + return v6 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // dissoc + { + v0 := lang.NewSymbol("dissoc").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map")), lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"), lang.NewSymbol("&"), lang.NewSymbol("ks"))), lang.NewKeyword("doc"), "dissoc[iate]. Returns a new map of the same (hashed/sorted) type,\n that does not contain a mapping for key(s).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1500), lang.NewKeyword("end-line"), int(1500))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + return v3 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5, _ := lang.FieldOrMethod(runtime4.RT, "Dissoc") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Dissoc is not a function"))) + } + v6 := lang.Apply(v5, []any{v3, v4}) + return v6 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.NewList(args[2:]...) + recur_loop_301: + var v6 any + { // let + // let binding "ret" + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("dissoc")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, []any{v3, v4}) + var v11 any = v10 + _ = v11 + var v12 any + if lang.IsTruthy(v5) { + var v13 any = v11 + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("first")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{v5}) + var v14 any = v18 + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("next")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.Apply(v22, []any{v5}) + var v19 any = v23 + v3 = v13 + v4 = v14 + v5 = v19 + goto recur_loop_301 + } else { + v12 = v11 + } + v6 = v12 + } // end let + return v6 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // dissoc! + { + v0 := lang.NewSymbol("dissoc!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"), lang.NewSymbol("&"), lang.NewSymbol("ks"))), lang.NewKeyword("doc"), "Returns a transient map that doesn't contain a mapping for key(s).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3382), lang.NewKeyword("end-line"), int(3382))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5, _ := lang.FieldOrMethod(v3, "without") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("without is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.NewList(args[2:]...) + recur_loop_611: + var v6 any + { // let + // let binding "ret" + v7, _ := lang.FieldOrMethod(v3, "without") + if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("without is not a function"))) + } + v8 := lang.Apply(v7, []any{v4}) + var v9 any = v8 + _ = v9 + var v10 any + if lang.IsTruthy(v5) { + var v11 any = v9 + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("first")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{v5}) + var v12 any = v16 + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("next")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.Apply(v20, []any{v5}) + var v17 any = v21 + v3 = v11 + v4 = v12 + v5 = v17 + goto recur_loop_611 + } else { + v10 = v9 + } + v6 = v10 + } // end let + return v6 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // distinct + { + v0 := lang.NewSymbol("distinct").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the elements of coll with duplicates removed.\n Returns a stateful transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5053), lang.NewKeyword("end-line"), int(5053))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + var v5 any + { // let + // let binding "seen" + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("volatile!")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.CreatePersistentTreeSet() + v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5060), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(5060), lang.NewKeyword("end-column"), int(30)) + v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v12 := lang.Apply(v8, []any{v11}) + var v13 any = v12 + _ = v13 + var v14 lang.FnFunc + v14 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + v15 := lang.Apply(v4, nil) + return v15 + case 1: + v15 := args[0] + _ = v15 + v16 := lang.Apply(v4, []any{v15}) + return v16 + case 2: + v15 := args[0] + _ = v15 + v16 := args[1] + _ = v16 + var v17 any + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("contains?")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("deref")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.Apply(v23, []any{v13}) + v25 := lang.Apply(v20, []any{v24, v16}) + if lang.IsTruthy(v25) { + v17 = v15 + } else { + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("conj")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29, ok := lang.FieldOrMethod(v13, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v13, "Deref"))) + } + var v30 any + switch reflect.TypeOf(v29).Kind() { + case reflect.Func: + v30 = lang.Apply(v29, nil) + default: + v30 = v29 + } + v31 := lang.Apply(v28, []any{v30, v16}) + v32, _ := lang.FieldOrMethod(v13, "reset") + if reflect.TypeOf(v32).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) + } + v33 := lang.Apply(v32, []any{v31}) + _ = v33 + v34 := lang.Apply(v4, []any{v15, v16}) + v17 = v34 + } + return v17 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5061), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(5068), lang.NewKeyword("end-column"), int(37)) + v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v5 = v16 + } // end let + return v5 + }) + v4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5059), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(5068), lang.NewKeyword("end-column"), int(39)) + v5, err := lang.WithMeta(v3, v4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v5 + case 1: + v3 := args[0] + _ = v3 + var v4 any + { // let + // let binding "step" + var v5 lang.FnFunc + { // function step + v5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + var v9 lang.FnFunc + v9 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v10 lang.FnFunc + v10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + recur_loop_877: + var v13 any + { // let + // let binding "vec__62" + var v14 any = v11 + _ = v14 + // let binding "f" + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("nth")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{v14, int64(0), nil}) + var v19 any = v18 + _ = v19 + // let binding "xs" + var v20 any = v14 + _ = v20 + var v21 any + { // let + // let binding "temp__0__auto__" + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("seq")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v20}) + var v26 any = v25 + _ = v26 + var v27 any + if lang.IsTruthy(v26) { + var v28 any + { // let + // let binding "s" + var v29 any = v26 + _ = v29 + var v30 any + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("contains?")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{v12, v19}) + if lang.IsTruthy(v34) { + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("rest")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v38, []any{v29}) + var v35 any = v39 + var v40 any = v12 + v11 = v35 + v12 = v40 + goto recur_loop_877 + } else { + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("cons")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("rest")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.Apply(v46, []any{v29}) + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("conj")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v12, v19}) + v52 := lang.Apply(v6, []any{v47, v51}) + v53 := lang.Apply(v43, []any{v19, v52}) + v30 = v53 + } + v28 = v30 + } // end let + v27 = v28 + } else { + v27 = nil + } + v21 = v27 + } // end let + v13 = v21 + } // end let + return v13 + }) + v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5072), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(5076), lang.NewKeyword("end-column"), int(66)) + v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v13 := lang.Apply(v12, []any{v7, v8}) + return v13 + }) + v10 := lang.Apply(lang.NewLazySeq, []any{v9}) + return v10 + }) + v6 := v5 + _ = v6 + } + v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5070), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(5077), lang.NewKeyword("end-column"), int(29)) + v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v8 any = v7 + _ = v8 + v9 := lang.CreatePersistentTreeSet() + v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5078), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(5078), lang.NewKeyword("end-column"), int(19)) + v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v12 := lang.Apply(v8, []any{v3, v11}) + v4 = v12 + } // end let + return v4 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // distinct? + { + v1 := reflect.TypeOf(false) + v0 := lang.NewSymbol("distinct?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Returns true if no two of the arguments are =", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5664), lang.NewKeyword("end-line"), int(5664))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + return true + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("not")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("=")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.Apply(v11, []any{v4, v5}) + v13 := lang.Apply(v8, []any{v12}) + return v13 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := lang.NewList(args[2:]...) + var v7 any + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("not=")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v4, v5}) + if lang.IsTruthy(v11) { + var v12 any + { // let + // let binding "s" + v13 := lang.CreatePersistentTreeSet(v4, v5) + v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5673), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(5673), lang.NewKeyword("end-column"), int(20)) + v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v16 any = v15 + _ = v16 + // let binding "G__99" + var v17 any = v6 + _ = v17 + // let binding "vec__100" + var v18 any = v17 + _ = v18 + // let binding "seq__101" + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("seq")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{v18}) + var v23 any = v22 + _ = v23 + // let binding "first__102" + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("first")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.Apply(v26, []any{v23}) + var v28 any = v27 + _ = v28 + // let binding "seq__101" + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("next")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.Apply(v31, []any{v23}) + var v33 any = v32 + _ = v33 + // let binding "x" + var v34 any = v28 + _ = v34 + // let binding "etc" + var v35 any = v33 + _ = v35 + // let binding "xs" + var v36 any = v18 + _ = v36 + var v37 any + { // let + // let binding "s" + var v38 any = v16 + _ = v38 + // let binding "G__99" + var v39 any = v17 + _ = v39 + for { + var v40 any + { // let + // let binding "s" + var v41 any = v38 + _ = v41 + // let binding "vec__103" + var v42 any = v39 + _ = v42 + // let binding "seq__104" + v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v44 := v43.FindInternedVar(lang.NewSymbol("seq")) + if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) + } + v45 := v44.Get() + v46 := lang.Apply(v45, []any{v42}) + var v47 any = v46 + _ = v47 + // let binding "first__105" + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("first")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v47}) + var v52 any = v51 + _ = v52 + // let binding "seq__104" + v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v54 := v53.FindInternedVar(lang.NewSymbol("next")) + if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) + } + v55 := v54.Get() + v56 := lang.Apply(v55, []any{v47}) + var v57 any = v56 + _ = v57 + // let binding "x" + var v58 any = v52 + _ = v58 + // let binding "etc" + var v59 any = v57 + _ = v59 + // let binding "xs" + var v60 any = v42 + _ = v60 + var v61 any + if lang.IsTruthy(v60) { + var v62 any + v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v64 := v63.FindInternedVar(lang.NewSymbol("contains?")) + if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) + } + v65 := v64.Get() + v66 := lang.Apply(v65, []any{v41, v58}) + if lang.IsTruthy(v66) { + v62 = false + } else { + v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v69 := v68.FindInternedVar(lang.NewSymbol("conj")) + if v69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) + } + v70 := v69.Get() + v71 := lang.Apply(v70, []any{v41, v58}) + var v67 any = v71 + var v72 any = v59 + v38 = v67 + v39 = v72 + continue + } + v61 = v62 + } else { + v61 = true + } + v40 = v61 + } // end let + v37 = v40 + break + } + } // end let + v12 = v37 + } // end let + v7 = v12 + } else { + v7 = false + } + return v7 + } + }) + v4 := reflect.TypeOf(false) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // doall + { + v0 := lang.NewSymbol("doall").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "When lazy sequences are produced via functions that have side\n effects, any effects other than those needed to produce the first\n element in the seq do not occur until the seq is consumed. doall can\n be used to force any effects. Walks through the successive nexts of\n the seq, retains the head and returns it, thus causing the entire\n seq to reside in memory at one time.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3131), lang.NewKeyword("end-line"), int(3131))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("dorun")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.Apply(v6, []any{v3}) + _ = v7 + return v3 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("dorun")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v3, v4}) + _ = v8 + return v4 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // dorun + { + v0 := lang.NewSymbol("dorun").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "When lazy sequences are produced via functions that have side\n effects, any effects other than those needed to produce the first\n element in the seq do not occur until the seq is consumed. dorun can\n be used to force any effects. Walks through the successive nexts of\n the seq, does not retain the head and returns nil.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3116), lang.NewKeyword("end-line"), int(3116))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + recur_loop_579: + var v4 any + { // let + // let binding "temp__0__auto__" + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("seq")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v3}) + var v9 any = v8 + _ = v9 + var v10 any + if lang.IsTruthy(v9) { + var v11 any + { // let + // let binding "s" + var v12 any = v9 + _ = v12 + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("next")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{v12}) + var v13 any = v17 + v3 = v13 + goto recur_loop_579 + } // end let + v10 = v11 + } else { + v10 = nil + } + v4 = v10 + } // end let + return v4 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + recur_loop_580: + var v5 any + var v6 any + { // let + // let binding "and__0__auto__" + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("seq")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, []any{v4}) + var v11 any = v10 + _ = v11 + var v12 any + if lang.IsTruthy(v11) { + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("pos?")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{v3}) + v12 = v16 + } else { + v12 = v11 + } + v6 = v12 + } // end let + if lang.IsTruthy(v6) { + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("dec")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v3}) + var v7 any = v11 + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("next")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{v4}) + var v12 any = v16 + v3 = v7 + v4 = v12 + goto recur_loop_580 + } else { + v5 = nil + } + return v5 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // doseq + { + v0 := lang.NewSymbol("doseq").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("seq-exprs"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Repeatedly executes body (presumably for side-effects) with\n bindings and filtering as provided by \"for\". Does not retain\n the head of the sequence. Returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3209), lang.NewKeyword("end-line"), int(3209))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + var v7 any + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v5}) + if lang.IsTruthy(v11) { + v7 = nil + } else { + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("str")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("first")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{v3}) + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("meta")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v3}) + v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) + v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) + v28 := lang.Apply(lang.NewIllegalArgumentError, []any{v27}) + panic(v28) + } + _ = v7 + var v29 any + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("even?")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("count")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.Apply(v35, []any{v5}) + v37 := lang.Apply(v32, []any{v36}) + if lang.IsTruthy(v37) { + v29 = nil + } else { + v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v39 := v38.FindInternedVar(lang.NewSymbol("str")) + if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + } + v40 := v39.Get() + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("first")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.Apply(v43, []any{v3}) + v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) + if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) + } + v47 := v46.Get() + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("meta")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v3}) + v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) + v53 := lang.Apply(v40, []any{v44, " requires ", "an even number of forms in binding vector", " in ", v47, ":", v52}) + v54 := lang.Apply(lang.NewIllegalArgumentError, []any{v53}) + panic(v54) + } + _ = v29 + _ = nil + var v55 any + { // let + // let binding "step" + var v56 lang.FnFunc + { // function step + v56 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v58 := args[0] + _ = v58 + v59 := args[1] + _ = v59 + var v60 any + v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v62 := v61.FindInternedVar(lang.NewSymbol("not")) + if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) + } + v63 := v62.Get() + v64 := lang.Apply(v63, []any{v59}) + if lang.IsTruthy(v64) { + v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v66 := v65.FindInternedVar(lang.NewSymbol("seq")) + if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) + } + v67 := v66.Get() + v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v69 := v68.FindInternedVar(lang.NewSymbol("concat")) + if v69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) + } + v70 := v69.Get() + v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v72 := v71.FindInternedVar(lang.NewSymbol("list")) + if v72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) + } + v73 := v72.Get() + v74 := lang.Apply(v73, []any{lang.NewSymbol("do")}) + v75 := lang.Apply(v70, []any{v74, v6}) + v76 := lang.Apply(v67, []any{v75}) + v77 := lang.NewVector(true, v76) + v78 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3220), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(3220), lang.NewKeyword("end-column"), int(36)) + v79, err := lang.WithMeta(v77, v78.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v60 = v79 + } else { + var v80 any + { // let + // let binding "k" + v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v82 := v81.FindInternedVar(lang.NewSymbol("first")) + if v82.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) + } + v83 := v82.Get() + v84 := lang.Apply(v83, []any{v59}) + var v85 any = v84 + _ = v85 + // let binding "v" + v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v87 := v86.FindInternedVar(lang.NewSymbol("second")) + if v87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) + } + v88 := v87.Get() + v89 := lang.Apply(v88, []any{v59}) + var v90 any = v89 + _ = v90 + var v91 any + v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v93 := v92.FindInternedVar(lang.NewSymbol("keyword?")) + if v93.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) + } + v94 := v93.Get() + v95 := lang.Apply(v94, []any{v85}) + if lang.IsTruthy(v95) { + var v96 any + { // let + // let binding "steppair" + v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v98 := v97.FindInternedVar(lang.NewSymbol("nnext")) + if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) + } + v99 := v98.Get() + v100 := lang.Apply(v99, []any{v59}) + v101 := lang.Apply(v57, []any{v58, v100}) + var v102 any = v101 + _ = v102 + // let binding "needrec" + v103 := lang.Apply(v102, []any{int64(0)}) + var v104 any = v103 + _ = v104 + // let binding "subform" + v105 := lang.Apply(v102, []any{int64(1)}) + var v106 any = v105 + _ = v106 + var v107 any + v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v109 := v108.FindInternedVar(lang.NewSymbol("=")) + if v109.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) + } + v110 := v109.Get() + v111 := lang.Apply(v110, []any{v85, lang.NewKeyword("let")}) + if lang.IsTruthy(v111) { + v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v113 := v112.FindInternedVar(lang.NewSymbol("seq")) + if v113.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) + } + v114 := v113.Get() + v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v116 := v115.FindInternedVar(lang.NewSymbol("concat")) + if v116.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) + } + v117 := v116.Get() + v118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v119 := v118.FindInternedVar(lang.NewSymbol("list")) + if v119.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v119))) + } + v120 := v119.Get() + v121 := lang.Apply(v120, []any{lang.NewSymbol("glojure.core/let")}) + v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v123 := v122.FindInternedVar(lang.NewSymbol("list")) + if v123.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) + } + v124 := v123.Get() + v125 := lang.Apply(v124, []any{v90}) + v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v127 := v126.FindInternedVar(lang.NewSymbol("list")) + if v127.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) + } + v128 := v127.Get() + v129 := lang.Apply(v128, []any{v106}) + v130 := lang.Apply(v117, []any{v121, v125, v129}) + v131 := lang.Apply(v114, []any{v130}) + v132 := lang.NewVector(v104, v131) + v133 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3228), lang.NewKeyword("column"), int(37), lang.NewKeyword("end-line"), int(3228), lang.NewKeyword("end-column"), int(64)) + v134, err := lang.WithMeta(v132, v133.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v107 = v134 + } else { + var v135 any + v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v137 := v136.FindInternedVar(lang.NewSymbol("=")) + if v137.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) + } + v138 := v137.Get() + v139 := lang.Apply(v138, []any{v85, lang.NewKeyword("while")}) + if lang.IsTruthy(v139) { + v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v141 := v140.FindInternedVar(lang.NewSymbol("seq")) + if v141.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) + } + v142 := v141.Get() + v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v144 := v143.FindInternedVar(lang.NewSymbol("concat")) + if v144.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) + } + v145 := v144.Get() + v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v147 := v146.FindInternedVar(lang.NewSymbol("list")) + if v147.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) + } + v148 := v147.Get() + v149 := lang.Apply(v148, []any{lang.NewSymbol("glojure.core/when")}) + v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v151 := v150.FindInternedVar(lang.NewSymbol("list")) + if v151.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) + } + v152 := v151.Get() + v153 := lang.Apply(v152, []any{v90}) + v154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v155 := v154.FindInternedVar(lang.NewSymbol("list")) + if v155.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v155))) + } + v156 := v155.Get() + v157 := lang.Apply(v156, []any{v106}) + var v158 any + if lang.IsTruthy(v104) { + v159 := lang.NewVector(v58) + v160 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3231), lang.NewKeyword("column"), int(65), lang.NewKeyword("end-line"), int(3231), lang.NewKeyword("end-column"), int(73)) + v161, err := lang.WithMeta(v159, v160.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v158 = v161 + } else { + v158 = nil + } + v162 := lang.Apply(v145, []any{v149, v153, v157, v158}) + v163 := lang.Apply(v142, []any{v162}) + v164 := lang.NewVector(false, v163) + v165 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3229), lang.NewKeyword("column"), int(39), lang.NewKeyword("end-line"), int(3231), lang.NewKeyword("end-column"), int(76)) + v166, err := lang.WithMeta(v164, v165.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v135 = v166 + } else { + var v167 any + v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v169 := v168.FindInternedVar(lang.NewSymbol("=")) + if v169.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) + } + v170 := v169.Get() + v171 := lang.Apply(v170, []any{v85, lang.NewKeyword("when")}) + if lang.IsTruthy(v171) { + v172 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v173 := v172.FindInternedVar(lang.NewSymbol("seq")) + if v173.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v173))) + } + v174 := v173.Get() + v175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v176 := v175.FindInternedVar(lang.NewSymbol("concat")) + if v176.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v176))) + } + v177 := v176.Get() + v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v179 := v178.FindInternedVar(lang.NewSymbol("list")) + if v179.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) + } + v180 := v179.Get() + v181 := lang.Apply(v180, []any{lang.NewSymbol("if")}) + v182 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v183 := v182.FindInternedVar(lang.NewSymbol("list")) + if v183.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v183))) + } + v184 := v183.Get() + v185 := lang.Apply(v184, []any{v90}) + v186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v187 := v186.FindInternedVar(lang.NewSymbol("list")) + if v187.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v187))) + } + v188 := v187.Get() + v189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v190 := v189.FindInternedVar(lang.NewSymbol("seq")) + if v190.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v190))) + } + v191 := v190.Get() + v192 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v193 := v192.FindInternedVar(lang.NewSymbol("concat")) + if v193.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v193))) + } + v194 := v193.Get() + v195 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v196 := v195.FindInternedVar(lang.NewSymbol("list")) + if v196.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v196))) + } + v197 := v196.Get() + v198 := lang.Apply(v197, []any{lang.NewSymbol("do")}) + v199 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v200 := v199.FindInternedVar(lang.NewSymbol("list")) + if v200.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v200))) + } + v201 := v200.Get() + v202 := lang.Apply(v201, []any{v106}) + var v203 any + if lang.IsTruthy(v104) { + v204 := lang.NewVector(v58) + v205 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3235), lang.NewKeyword("column"), int(66), lang.NewKeyword("end-line"), int(3235), lang.NewKeyword("end-column"), int(74)) + v206, err := lang.WithMeta(v204, v205.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v203 = v206 + } else { + v203 = nil + } + v207 := lang.Apply(v194, []any{v198, v202, v203}) + v208 := lang.Apply(v191, []any{v207}) + v209 := lang.Apply(v188, []any{v208}) + v210 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v211 := v210.FindInternedVar(lang.NewSymbol("list")) + if v211.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v211))) + } + v212 := v211.Get() + v213 := lang.Apply(v212, []any{v58}) + v214 := lang.Apply(v177, []any{v181, v185, v209, v213}) + v215 := lang.Apply(v174, []any{v214}) + v216 := lang.NewVector(false, v215) + v217 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3232), lang.NewKeyword("column"), int(38), lang.NewKeyword("end-line"), int(3236), lang.NewKeyword("end-column"), int(57)) + v218, err := lang.WithMeta(v216, v217.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v167 = v218 + } else { + v167 = nil + } + v135 = v167 + } + v107 = v135 + } + v96 = v107 + } // end let + v91 = v96 + } else { + var v97 any + { // let + // let binding "seq-" + v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v99 := v98.FindInternedVar(lang.NewSymbol("gensym")) + if v99.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) + } + v100 := v99.Get() + v101 := lang.Apply(v100, []any{"seq_"}) + var v102 any = v101 + _ = v102 + // let binding "chunk-" + v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v104 := v103.FindInternedVar(lang.NewSymbol("with-meta")) + if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) + } + v105 := v104.Get() + v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v107 := v106.FindInternedVar(lang.NewSymbol("gensym")) + if v107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) + } + v108 := v107.Get() + v109 := lang.Apply(v108, []any{"chunk_"}) + v110 := lang.NewMap(lang.NewKeyword("tag"), lang.NewSymbol("glojure.lang.IChunk")) + v111 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3239), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(3239), lang.NewKeyword("end-column"), int(72)) + v112, err := lang.WithMeta(v110, v111.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v113 := lang.Apply(v105, []any{v109, v112}) + var v114 any = v113 + _ = v114 + // let binding "count-" + v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v116 := v115.FindInternedVar(lang.NewSymbol("gensym")) + if v116.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) + } + v117 := v116.Get() + v118 := lang.Apply(v117, []any{"count_"}) + var v119 any = v118 + _ = v119 + // let binding "i-" + v120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v121 := v120.FindInternedVar(lang.NewSymbol("gensym")) + if v121.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v121))) + } + v122 := v121.Get() + v123 := lang.Apply(v122, []any{"i_"}) + var v124 any = v123 + _ = v124 + // let binding "recform" + v125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v126 := v125.FindInternedVar(lang.NewSymbol("seq")) + if v126.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v126))) + } + v127 := v126.Get() + v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v129 := v128.FindInternedVar(lang.NewSymbol("concat")) + if v129.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v129))) + } + v130 := v129.Get() + v131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v132 := v131.FindInternedVar(lang.NewSymbol("list")) + if v132.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v132))) + } + v133 := v132.Get() + v134 := lang.Apply(v133, []any{lang.NewSymbol("recur")}) + v135 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v136 := v135.FindInternedVar(lang.NewSymbol("list")) + if v136.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v136))) + } + v137 := v136.Get() + v138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v139 := v138.FindInternedVar(lang.NewSymbol("seq")) + if v139.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v139))) + } + v140 := v139.Get() + v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v142 := v141.FindInternedVar(lang.NewSymbol("concat")) + if v142.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) + } + v143 := v142.Get() + v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v145 := v144.FindInternedVar(lang.NewSymbol("list")) + if v145.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) + } + v146 := v145.Get() + v147 := lang.Apply(v146, []any{lang.NewSymbol("glojure.core/next")}) + v148 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v149 := v148.FindInternedVar(lang.NewSymbol("list")) + if v149.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v149))) + } + v150 := v149.Get() + v151 := lang.Apply(v150, []any{v102}) + v152 := lang.Apply(v143, []any{v147, v151}) + v153 := lang.Apply(v140, []any{v152}) + v154 := lang.Apply(v137, []any{v153}) + v155 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v156 := v155.FindInternedVar(lang.NewSymbol("list")) + if v156.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v156))) + } + v157 := v156.Get() + v158 := lang.Apply(v157, []any{nil}) + v159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v160 := v159.FindInternedVar(lang.NewSymbol("list")) + if v160.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v160))) + } + v161 := v160.Get() + v162 := lang.Apply(v161, []any{int64(0)}) + v163 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v164 := v163.FindInternedVar(lang.NewSymbol("list")) + if v164.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v164))) + } + v165 := v164.Get() + v166 := lang.Apply(v165, []any{int64(0)}) + v167 := lang.Apply(v130, []any{v134, v154, v158, v162, v166}) + v168 := lang.Apply(v127, []any{v167}) + var v169 any = v168 + _ = v169 + // let binding "steppair" + v170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v171 := v170.FindInternedVar(lang.NewSymbol("nnext")) + if v171.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v171))) + } + v172 := v171.Get() + v173 := lang.Apply(v172, []any{v59}) + v174 := lang.Apply(v57, []any{v169, v173}) + var v175 any = v174 + _ = v175 + // let binding "needrec" + v176 := lang.Apply(v175, []any{int64(0)}) + var v177 any = v176 + _ = v177 + // let binding "subform" + v178 := lang.Apply(v175, []any{int64(1)}) + var v179 any = v178 + _ = v179 + // let binding "recform-chunk" + v180 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v181 := v180.FindInternedVar(lang.NewSymbol("seq")) + if v181.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v181))) + } + v182 := v181.Get() + v183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v184 := v183.FindInternedVar(lang.NewSymbol("concat")) + if v184.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v184))) + } + v185 := v184.Get() + v186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v187 := v186.FindInternedVar(lang.NewSymbol("list")) + if v187.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v187))) + } + v188 := v187.Get() + v189 := lang.Apply(v188, []any{lang.NewSymbol("recur")}) + v190 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v191 := v190.FindInternedVar(lang.NewSymbol("list")) + if v191.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v191))) + } + v192 := v191.Get() + v193 := lang.Apply(v192, []any{v102}) + v194 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v195 := v194.FindInternedVar(lang.NewSymbol("list")) + if v195.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v195))) + } + v196 := v195.Get() + v197 := lang.Apply(v196, []any{v114}) + v198 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v199 := v198.FindInternedVar(lang.NewSymbol("list")) + if v199.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v199))) + } + v200 := v199.Get() + v201 := lang.Apply(v200, []any{v119}) + v202 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v203 := v202.FindInternedVar(lang.NewSymbol("list")) + if v203.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v203))) + } + v204 := v203.Get() + v205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v206 := v205.FindInternedVar(lang.NewSymbol("seq")) + if v206.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v206))) + } + v207 := v206.Get() + v208 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v209 := v208.FindInternedVar(lang.NewSymbol("concat")) + if v209.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v209))) + } + v210 := v209.Get() + v211 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v212 := v211.FindInternedVar(lang.NewSymbol("list")) + if v212.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v212))) + } + v213 := v212.Get() + v214 := lang.Apply(v213, []any{lang.NewSymbol("glojure.core/unchecked-inc")}) + v215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v216 := v215.FindInternedVar(lang.NewSymbol("list")) + if v216.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v216))) + } + v217 := v216.Get() + v218 := lang.Apply(v217, []any{v124}) + v219 := lang.Apply(v210, []any{v214, v218}) + v220 := lang.Apply(v207, []any{v219}) + v221 := lang.Apply(v204, []any{v220}) + v222 := lang.Apply(v185, []any{v189, v193, v197, v201, v221}) + v223 := lang.Apply(v182, []any{v222}) + var v224 any = v223 + _ = v224 + // let binding "steppair-chunk" + v225 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v226 := v225.FindInternedVar(lang.NewSymbol("nnext")) + if v226.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v226))) + } + v227 := v226.Get() + v228 := lang.Apply(v227, []any{v59}) + v229 := lang.Apply(v57, []any{v224, v228}) + var v230 any = v229 + _ = v230 + // let binding "subform-chunk" + v231 := lang.Apply(v230, []any{int64(1)}) + var v232 any = v231 + _ = v232 + v233 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v234 := v233.FindInternedVar(lang.NewSymbol("seq")) + if v234.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v234))) + } + v235 := v234.Get() + v236 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v237 := v236.FindInternedVar(lang.NewSymbol("concat")) + if v237.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v237))) + } + v238 := v237.Get() + v239 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v240 := v239.FindInternedVar(lang.NewSymbol("list")) + if v240.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v240))) + } + v241 := v240.Get() + v242 := lang.Apply(v241, []any{lang.NewSymbol("glojure.core/loop")}) + v243 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v244 := v243.FindInternedVar(lang.NewSymbol("list")) + if v244.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v244))) + } + v245 := v244.Get() + v246 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v247 := v246.FindInternedVar(lang.NewSymbol("apply")) + if v247.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v247))) + } + v248 := v247.Get() + v249 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v250 := v249.FindInternedVar(lang.NewSymbol("vector")) + if v250.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v250))) + } + v251 := v250.Get() + v252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v253 := v252.FindInternedVar(lang.NewSymbol("seq")) + if v253.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v253))) + } + v254 := v253.Get() + v255 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v256 := v255.FindInternedVar(lang.NewSymbol("concat")) + if v256.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v256))) + } + v257 := v256.Get() + v258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v259 := v258.FindInternedVar(lang.NewSymbol("list")) + if v259.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v259))) + } + v260 := v259.Get() + v261 := lang.Apply(v260, []any{v102}) + v262 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v263 := v262.FindInternedVar(lang.NewSymbol("list")) + if v263.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v263))) + } + v264 := v263.Get() + v265 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v266 := v265.FindInternedVar(lang.NewSymbol("seq")) + if v266.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v266))) + } + v267 := v266.Get() + v268 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v269 := v268.FindInternedVar(lang.NewSymbol("concat")) + if v269.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v269))) + } + v270 := v269.Get() + v271 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v272 := v271.FindInternedVar(lang.NewSymbol("list")) + if v272.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v272))) + } + v273 := v272.Get() + v274 := lang.Apply(v273, []any{lang.NewSymbol("glojure.core/seq")}) + v275 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v276 := v275.FindInternedVar(lang.NewSymbol("list")) + if v276.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v276))) + } + v277 := v276.Get() + v278 := lang.Apply(v277, []any{v90}) + v279 := lang.Apply(v270, []any{v274, v278}) + v280 := lang.Apply(v267, []any{v279}) + v281 := lang.Apply(v264, []any{v280}) + v282 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v283 := v282.FindInternedVar(lang.NewSymbol("list")) + if v283.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v283))) + } + v284 := v283.Get() + v285 := lang.Apply(v284, []any{v114}) + v286 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v287 := v286.FindInternedVar(lang.NewSymbol("list")) + if v287.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v287))) + } + v288 := v287.Get() + v289 := lang.Apply(v288, []any{nil}) + v290 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v291 := v290.FindInternedVar(lang.NewSymbol("list")) + if v291.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v291))) + } + v292 := v291.Get() + v293 := lang.Apply(v292, []any{v119}) + v294 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v295 := v294.FindInternedVar(lang.NewSymbol("list")) + if v295.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v295))) + } + v296 := v295.Get() + v297 := lang.Apply(v296, []any{int64(0)}) + v298 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v299 := v298.FindInternedVar(lang.NewSymbol("list")) + if v299.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v299))) + } + v300 := v299.Get() + v301 := lang.Apply(v300, []any{v124}) + v302 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v303 := v302.FindInternedVar(lang.NewSymbol("list")) + if v303.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v303))) + } + v304 := v303.Get() + v305 := lang.Apply(v304, []any{int64(0)}) + v306 := lang.Apply(v257, []any{v261, v281, v285, v289, v293, v297, v301, v305}) + v307 := lang.Apply(v254, []any{v306}) + v308 := lang.Apply(v248, []any{v251, v307}) + v309 := lang.Apply(v245, []any{v308}) + v310 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v311 := v310.FindInternedVar(lang.NewSymbol("list")) + if v311.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v311))) + } + v312 := v311.Get() + v313 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v314 := v313.FindInternedVar(lang.NewSymbol("seq")) + if v314.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v314))) + } + v315 := v314.Get() + v316 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v317 := v316.FindInternedVar(lang.NewSymbol("concat")) + if v317.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v317))) + } + v318 := v317.Get() + v319 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v320 := v319.FindInternedVar(lang.NewSymbol("list")) + if v320.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v320))) + } + v321 := v320.Get() + v322 := lang.Apply(v321, []any{lang.NewSymbol("if")}) + v323 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v324 := v323.FindInternedVar(lang.NewSymbol("list")) + if v324.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v324))) + } + v325 := v324.Get() + v326 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v327 := v326.FindInternedVar(lang.NewSymbol("seq")) + if v327.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v327))) + } + v328 := v327.Get() + v329 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v330 := v329.FindInternedVar(lang.NewSymbol("concat")) + if v330.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v330))) + } + v331 := v330.Get() + v332 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v333 := v332.FindInternedVar(lang.NewSymbol("list")) + if v333.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v333))) + } + v334 := v333.Get() + v335 := lang.Apply(v334, []any{lang.NewSymbol("glojure.core/<")}) + v336 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v337 := v336.FindInternedVar(lang.NewSymbol("list")) + if v337.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v337))) + } + v338 := v337.Get() + v339 := lang.Apply(v338, []any{v124}) + v340 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v341 := v340.FindInternedVar(lang.NewSymbol("list")) + if v341.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v341))) + } + v342 := v341.Get() + v343 := lang.Apply(v342, []any{v119}) + v344 := lang.Apply(v331, []any{v335, v339, v343}) + v345 := lang.Apply(v328, []any{v344}) + v346 := lang.Apply(v325, []any{v345}) + v347 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v348 := v347.FindInternedVar(lang.NewSymbol("list")) + if v348.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v348))) + } + v349 := v348.Get() + v350 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v351 := v350.FindInternedVar(lang.NewSymbol("seq")) + if v351.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v351))) + } + v352 := v351.Get() + v353 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v354 := v353.FindInternedVar(lang.NewSymbol("concat")) + if v354.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v354))) + } + v355 := v354.Get() + v356 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v357 := v356.FindInternedVar(lang.NewSymbol("list")) + if v357.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v357))) + } + v358 := v357.Get() + v359 := lang.Apply(v358, []any{lang.NewSymbol("glojure.core/let")}) + v360 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v361 := v360.FindInternedVar(lang.NewSymbol("list")) + if v361.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v361))) + } + v362 := v361.Get() + v363 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v364 := v363.FindInternedVar(lang.NewSymbol("apply")) + if v364.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v364))) + } + v365 := v364.Get() + v366 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v367 := v366.FindInternedVar(lang.NewSymbol("vector")) + if v367.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v367))) + } + v368 := v367.Get() + v369 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v370 := v369.FindInternedVar(lang.NewSymbol("seq")) + if v370.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v370))) + } + v371 := v370.Get() + v372 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v373 := v372.FindInternedVar(lang.NewSymbol("concat")) + if v373.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v373))) + } + v374 := v373.Get() + v375 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v376 := v375.FindInternedVar(lang.NewSymbol("list")) + if v376.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v376))) + } + v377 := v376.Get() + v378 := lang.Apply(v377, []any{v85}) + v379 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v380 := v379.FindInternedVar(lang.NewSymbol("list")) + if v380.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v380))) + } + v381 := v380.Get() + v382 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v383 := v382.FindInternedVar(lang.NewSymbol("seq")) + if v383.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v383))) + } + v384 := v383.Get() + v385 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v386 := v385.FindInternedVar(lang.NewSymbol("concat")) + if v386.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v386))) + } + v387 := v386.Get() + v388 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v389 := v388.FindInternedVar(lang.NewSymbol("list")) + if v389.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v389))) + } + v390 := v389.Get() + v391 := lang.Apply(v390, []any{lang.NewSymbol(".nth")}) + v392 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v393 := v392.FindInternedVar(lang.NewSymbol("list")) + if v393.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v393))) + } + v394 := v393.Get() + v395 := lang.Apply(v394, []any{v114}) + v396 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v397 := v396.FindInternedVar(lang.NewSymbol("list")) + if v397.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v397))) + } + v398 := v397.Get() + v399 := lang.Apply(v398, []any{v124}) + v400 := lang.Apply(v387, []any{v391, v395, v399}) + v401 := lang.Apply(v384, []any{v400}) + v402 := lang.Apply(v381, []any{v401}) + v403 := lang.Apply(v374, []any{v378, v402}) + v404 := lang.Apply(v371, []any{v403}) + v405 := lang.Apply(v365, []any{v368, v404}) + v406 := lang.Apply(v362, []any{v405}) + v407 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v408 := v407.FindInternedVar(lang.NewSymbol("list")) + if v408.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v408))) + } + v409 := v408.Get() + v410 := lang.Apply(v409, []any{v232}) + var v411 any + if lang.IsTruthy(v177) { + v412 := lang.NewVector(v224) + v413 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3256), lang.NewKeyword("column"), int(48), lang.NewKeyword("end-line"), int(3256), lang.NewKeyword("end-column"), int(62)) + v414, err := lang.WithMeta(v412, v413.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v411 = v414 + } else { + v411 = nil + } + v415 := lang.Apply(v355, []any{v359, v406, v410, v411}) + v416 := lang.Apply(v352, []any{v415}) + v417 := lang.Apply(v349, []any{v416}) + v418 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v419 := v418.FindInternedVar(lang.NewSymbol("list")) + if v419.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v419))) + } + v420 := v419.Get() + v421 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v422 := v421.FindInternedVar(lang.NewSymbol("seq")) + if v422.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v422))) + } + v423 := v422.Get() + v424 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v425 := v424.FindInternedVar(lang.NewSymbol("concat")) + if v425.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v425))) + } + v426 := v425.Get() + v427 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v428 := v427.FindInternedVar(lang.NewSymbol("list")) + if v428.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v428))) + } + v429 := v428.Get() + v430 := lang.Apply(v429, []any{lang.NewSymbol("glojure.core/when-let")}) + v431 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v432 := v431.FindInternedVar(lang.NewSymbol("list")) + if v432.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v432))) + } + v433 := v432.Get() + v434 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v435 := v434.FindInternedVar(lang.NewSymbol("apply")) + if v435.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v435))) + } + v436 := v435.Get() + v437 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v438 := v437.FindInternedVar(lang.NewSymbol("vector")) + if v438.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v438))) + } + v439 := v438.Get() + v440 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v441 := v440.FindInternedVar(lang.NewSymbol("seq")) + if v441.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v441))) + } + v442 := v441.Get() + v443 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v444 := v443.FindInternedVar(lang.NewSymbol("concat")) + if v444.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v444))) + } + v445 := v444.Get() + v446 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v447 := v446.FindInternedVar(lang.NewSymbol("list")) + if v447.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v447))) + } + v448 := v447.Get() + v449 := lang.Apply(v448, []any{v102}) + v450 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v451 := v450.FindInternedVar(lang.NewSymbol("list")) + if v451.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v451))) + } + v452 := v451.Get() + v453 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v454 := v453.FindInternedVar(lang.NewSymbol("seq")) + if v454.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v454))) + } + v455 := v454.Get() + v456 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v457 := v456.FindInternedVar(lang.NewSymbol("concat")) + if v457.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v457))) + } + v458 := v457.Get() + v459 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v460 := v459.FindInternedVar(lang.NewSymbol("list")) + if v460.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v460))) + } + v461 := v460.Get() + v462 := lang.Apply(v461, []any{lang.NewSymbol("glojure.core/seq")}) + v463 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v464 := v463.FindInternedVar(lang.NewSymbol("list")) + if v464.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v464))) + } + v465 := v464.Get() + v466 := lang.Apply(v465, []any{v102}) + v467 := lang.Apply(v458, []any{v462, v466}) + v468 := lang.Apply(v455, []any{v467}) + v469 := lang.Apply(v452, []any{v468}) + v470 := lang.Apply(v445, []any{v449, v469}) + v471 := lang.Apply(v442, []any{v470}) + v472 := lang.Apply(v436, []any{v439, v471}) + v473 := lang.Apply(v433, []any{v472}) + v474 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v475 := v474.FindInternedVar(lang.NewSymbol("list")) + if v475.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v475))) + } + v476 := v475.Get() + v477 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v478 := v477.FindInternedVar(lang.NewSymbol("seq")) + if v478.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v478))) + } + v479 := v478.Get() + v480 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v481 := v480.FindInternedVar(lang.NewSymbol("concat")) + if v481.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v481))) + } + v482 := v481.Get() + v483 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v484 := v483.FindInternedVar(lang.NewSymbol("list")) + if v484.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v484))) + } + v485 := v484.Get() + v486 := lang.Apply(v485, []any{lang.NewSymbol("if")}) + v487 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v488 := v487.FindInternedVar(lang.NewSymbol("list")) + if v488.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v488))) + } + v489 := v488.Get() + v490 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v491 := v490.FindInternedVar(lang.NewSymbol("seq")) + if v491.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v491))) + } + v492 := v491.Get() + v493 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v494 := v493.FindInternedVar(lang.NewSymbol("concat")) + if v494.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v494))) + } + v495 := v494.Get() + v496 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v497 := v496.FindInternedVar(lang.NewSymbol("list")) + if v497.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v497))) + } + v498 := v497.Get() + v499 := lang.Apply(v498, []any{lang.NewSymbol("glojure.core/chunked-seq?")}) + v500 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v501 := v500.FindInternedVar(lang.NewSymbol("list")) + if v501.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v501))) + } + v502 := v501.Get() + v503 := lang.Apply(v502, []any{v102}) + v504 := lang.Apply(v495, []any{v499, v503}) + v505 := lang.Apply(v492, []any{v504}) + v506 := lang.Apply(v489, []any{v505}) + v507 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v508 := v507.FindInternedVar(lang.NewSymbol("list")) + if v508.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v508))) + } + v509 := v508.Get() + v510 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v511 := v510.FindInternedVar(lang.NewSymbol("seq")) + if v511.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v511))) + } + v512 := v511.Get() + v513 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v514 := v513.FindInternedVar(lang.NewSymbol("concat")) + if v514.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v514))) + } + v515 := v514.Get() + v516 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v517 := v516.FindInternedVar(lang.NewSymbol("list")) + if v517.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v517))) + } + v518 := v517.Get() + v519 := lang.Apply(v518, []any{lang.NewSymbol("glojure.core/let")}) + v520 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v521 := v520.FindInternedVar(lang.NewSymbol("list")) + if v521.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v521))) + } + v522 := v521.Get() + v523 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v524 := v523.FindInternedVar(lang.NewSymbol("apply")) + if v524.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v524))) + } + v525 := v524.Get() + v526 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v527 := v526.FindInternedVar(lang.NewSymbol("vector")) + if v527.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v527))) + } + v528 := v527.Get() + v529 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v530 := v529.FindInternedVar(lang.NewSymbol("seq")) + if v530.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v530))) + } + v531 := v530.Get() + v532 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v533 := v532.FindInternedVar(lang.NewSymbol("concat")) + if v533.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v533))) + } + v534 := v533.Get() + v535 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v536 := v535.FindInternedVar(lang.NewSymbol("list")) + if v536.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v536))) + } + v537 := v536.Get() + v538 := lang.Apply(v537, []any{lang.NewSymbol("c__0__auto__")}) + v539 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v540 := v539.FindInternedVar(lang.NewSymbol("list")) + if v540.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v540))) + } + v541 := v540.Get() + v542 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v543 := v542.FindInternedVar(lang.NewSymbol("seq")) + if v543.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v543))) + } + v544 := v543.Get() + v545 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v546 := v545.FindInternedVar(lang.NewSymbol("concat")) + if v546.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v546))) + } + v547 := v546.Get() + v548 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v549 := v548.FindInternedVar(lang.NewSymbol("list")) + if v549.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v549))) + } + v550 := v549.Get() + v551 := lang.Apply(v550, []any{lang.NewSymbol("glojure.core/chunk-first")}) + v552 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v553 := v552.FindInternedVar(lang.NewSymbol("list")) + if v553.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v553))) + } + v554 := v553.Get() + v555 := lang.Apply(v554, []any{v102}) + v556 := lang.Apply(v547, []any{v551, v555}) + v557 := lang.Apply(v544, []any{v556}) + v558 := lang.Apply(v541, []any{v557}) + v559 := lang.Apply(v534, []any{v538, v558}) + v560 := lang.Apply(v531, []any{v559}) + v561 := lang.Apply(v525, []any{v528, v560}) + v562 := lang.Apply(v522, []any{v561}) + v563 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v564 := v563.FindInternedVar(lang.NewSymbol("list")) + if v564.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v564))) + } + v565 := v564.Get() + v566 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v567 := v566.FindInternedVar(lang.NewSymbol("seq")) + if v567.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v567))) + } + v568 := v567.Get() + v569 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v570 := v569.FindInternedVar(lang.NewSymbol("concat")) + if v570.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v570))) + } + v571 := v570.Get() + v572 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v573 := v572.FindInternedVar(lang.NewSymbol("list")) + if v573.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v573))) + } + v574 := v573.Get() + v575 := lang.Apply(v574, []any{lang.NewSymbol("recur")}) + v576 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v577 := v576.FindInternedVar(lang.NewSymbol("list")) + if v577.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v577))) + } + v578 := v577.Get() + v579 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v580 := v579.FindInternedVar(lang.NewSymbol("seq")) + if v580.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v580))) + } + v581 := v580.Get() + v582 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v583 := v582.FindInternedVar(lang.NewSymbol("concat")) + if v583.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v583))) + } + v584 := v583.Get() + v585 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v586 := v585.FindInternedVar(lang.NewSymbol("list")) + if v586.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v586))) + } + v587 := v586.Get() + v588 := lang.Apply(v587, []any{lang.NewSymbol("glojure.core/chunk-rest")}) + v589 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v590 := v589.FindInternedVar(lang.NewSymbol("list")) + if v590.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v590))) + } + v591 := v590.Get() + v592 := lang.Apply(v591, []any{v102}) + v593 := lang.Apply(v584, []any{v588, v592}) + v594 := lang.Apply(v581, []any{v593}) + v595 := lang.Apply(v578, []any{v594}) + v596 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v597 := v596.FindInternedVar(lang.NewSymbol("list")) + if v597.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v597))) + } + v598 := v597.Get() + v599 := lang.Apply(v598, []any{lang.NewSymbol("c__0__auto__")}) + v600 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v601 := v600.FindInternedVar(lang.NewSymbol("list")) + if v601.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v601))) + } + v602 := v601.Get() + v603 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v604 := v603.FindInternedVar(lang.NewSymbol("seq")) + if v604.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v604))) + } + v605 := v604.Get() + v606 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v607 := v606.FindInternedVar(lang.NewSymbol("concat")) + if v607.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v607))) + } + v608 := v607.Get() + v609 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v610 := v609.FindInternedVar(lang.NewSymbol("list")) + if v610.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v610))) + } + v611 := v610.Get() + v612 := lang.Apply(v611, []any{lang.NewSymbol("glojure.core/int")}) + v613 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v614 := v613.FindInternedVar(lang.NewSymbol("list")) + if v614.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v614))) + } + v615 := v614.Get() + v616 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v617 := v616.FindInternedVar(lang.NewSymbol("seq")) + if v617.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v617))) + } + v618 := v617.Get() + v619 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v620 := v619.FindInternedVar(lang.NewSymbol("concat")) + if v620.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v620))) + } + v621 := v620.Get() + v622 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v623 := v622.FindInternedVar(lang.NewSymbol("list")) + if v623.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v623))) + } + v624 := v623.Get() + v625 := lang.Apply(v624, []any{lang.NewSymbol("glojure.core/count")}) + v626 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v627 := v626.FindInternedVar(lang.NewSymbol("list")) + if v627.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v627))) + } + v628 := v627.Get() + v629 := lang.Apply(v628, []any{lang.NewSymbol("c__0__auto__")}) + v630 := lang.Apply(v621, []any{v625, v629}) + v631 := lang.Apply(v618, []any{v630}) + v632 := lang.Apply(v615, []any{v631}) + v633 := lang.Apply(v608, []any{v612, v632}) + v634 := lang.Apply(v605, []any{v633}) + v635 := lang.Apply(v602, []any{v634}) + v636 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v637 := v636.FindInternedVar(lang.NewSymbol("list")) + if v637.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v637))) + } + v638 := v637.Get() + v639 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v640 := v639.FindInternedVar(lang.NewSymbol("seq")) + if v640.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v640))) + } + v641 := v640.Get() + v642 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v643 := v642.FindInternedVar(lang.NewSymbol("concat")) + if v643.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v643))) + } + v644 := v643.Get() + v645 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v646 := v645.FindInternedVar(lang.NewSymbol("list")) + if v646.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v646))) + } + v647 := v646.Get() + v648 := lang.Apply(v647, []any{lang.NewSymbol("glojure.core/int")}) + v649 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v650 := v649.FindInternedVar(lang.NewSymbol("list")) + if v650.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v650))) + } + v651 := v650.Get() + v652 := lang.Apply(v651, []any{int64(0)}) + v653 := lang.Apply(v644, []any{v648, v652}) + v654 := lang.Apply(v641, []any{v653}) + v655 := lang.Apply(v638, []any{v654}) + v656 := lang.Apply(v571, []any{v575, v595, v599, v635, v655}) + v657 := lang.Apply(v568, []any{v656}) + v658 := lang.Apply(v565, []any{v657}) + v659 := lang.Apply(v515, []any{v519, v562, v658}) + v660 := lang.Apply(v512, []any{v659}) + v661 := lang.Apply(v509, []any{v660}) + v662 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v663 := v662.FindInternedVar(lang.NewSymbol("list")) + if v663.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v663))) + } + v664 := v663.Get() + v665 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v666 := v665.FindInternedVar(lang.NewSymbol("seq")) + if v666.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v666))) + } + v667 := v666.Get() + v668 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v669 := v668.FindInternedVar(lang.NewSymbol("concat")) + if v669.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v669))) + } + v670 := v669.Get() + v671 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v672 := v671.FindInternedVar(lang.NewSymbol("list")) + if v672.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v672))) + } + v673 := v672.Get() + v674 := lang.Apply(v673, []any{lang.NewSymbol("glojure.core/let")}) + v675 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v676 := v675.FindInternedVar(lang.NewSymbol("list")) + if v676.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v676))) + } + v677 := v676.Get() + v678 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v679 := v678.FindInternedVar(lang.NewSymbol("apply")) + if v679.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v679))) + } + v680 := v679.Get() + v681 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v682 := v681.FindInternedVar(lang.NewSymbol("vector")) + if v682.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v682))) + } + v683 := v682.Get() + v684 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v685 := v684.FindInternedVar(lang.NewSymbol("seq")) + if v685.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v685))) + } + v686 := v685.Get() + v687 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v688 := v687.FindInternedVar(lang.NewSymbol("concat")) + if v688.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v688))) + } + v689 := v688.Get() + v690 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v691 := v690.FindInternedVar(lang.NewSymbol("list")) + if v691.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v691))) + } + v692 := v691.Get() + v693 := lang.Apply(v692, []any{v85}) + v694 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v695 := v694.FindInternedVar(lang.NewSymbol("list")) + if v695.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v695))) + } + v696 := v695.Get() + v697 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v698 := v697.FindInternedVar(lang.NewSymbol("seq")) + if v698.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v698))) + } + v699 := v698.Get() + v700 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v701 := v700.FindInternedVar(lang.NewSymbol("concat")) + if v701.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v701))) + } + v702 := v701.Get() + v703 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v704 := v703.FindInternedVar(lang.NewSymbol("list")) + if v704.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v704))) + } + v705 := v704.Get() + v706 := lang.Apply(v705, []any{lang.NewSymbol("glojure.core/first")}) + v707 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v708 := v707.FindInternedVar(lang.NewSymbol("list")) + if v708.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v708))) + } + v709 := v708.Get() + v710 := lang.Apply(v709, []any{v102}) + v711 := lang.Apply(v702, []any{v706, v710}) + v712 := lang.Apply(v699, []any{v711}) + v713 := lang.Apply(v696, []any{v712}) + v714 := lang.Apply(v689, []any{v693, v713}) + v715 := lang.Apply(v686, []any{v714}) + v716 := lang.Apply(v680, []any{v683, v715}) + v717 := lang.Apply(v677, []any{v716}) + v718 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v719 := v718.FindInternedVar(lang.NewSymbol("list")) + if v719.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v719))) + } + v720 := v719.Get() + v721 := lang.Apply(v720, []any{v179}) + var v722 any + if lang.IsTruthy(v177) { + v723 := lang.NewVector(v169) + v724 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3264), lang.NewKeyword("column"), int(52), lang.NewKeyword("end-line"), int(3264), lang.NewKeyword("end-column"), int(60)) + v725, err := lang.WithMeta(v723, v724.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v722 = v725 + } else { + v722 = nil + } + v726 := lang.Apply(v670, []any{v674, v717, v721, v722}) + v727 := lang.Apply(v667, []any{v726}) + v728 := lang.Apply(v664, []any{v727}) + v729 := lang.Apply(v482, []any{v486, v506, v661, v728}) + v730 := lang.Apply(v479, []any{v729}) + v731 := lang.Apply(v476, []any{v730}) + v732 := lang.Apply(v426, []any{v430, v473, v731}) + v733 := lang.Apply(v423, []any{v732}) + v734 := lang.Apply(v420, []any{v733}) + v735 := lang.Apply(v318, []any{v322, v346, v417, v734}) + v736 := lang.Apply(v315, []any{v735}) + v737 := lang.Apply(v312, []any{v736}) + v738 := lang.Apply(v238, []any{v242, v309, v737}) + v739 := lang.Apply(v235, []any{v738}) + v740 := lang.NewVector(true, v739) + v741 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3250), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(3264), lang.NewKeyword("end-column"), int(67)) + v742, err := lang.WithMeta(v740, v741.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v97 = v742 + } // end let + v91 = v97 + } + v80 = v91 + } // end let + v60 = v80 + } + return v60 + }) + v57 := v56 + _ = v57 + } + v57 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3218), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(3264), lang.NewKeyword("end-column"), int(72)) + v58, err := lang.WithMeta(v56, v57.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v59 any = v58 + _ = v59 + v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v61 := v60.FindInternedVar(lang.NewSymbol("nth")) + if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) + } + v62 := v61.Get() + v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v64 := v63.FindInternedVar(lang.NewSymbol("seq")) + if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) + } + v65 := v64.Get() + v66 := lang.Apply(v65, []any{v5}) + v67 := lang.Apply(v59, []any{nil, v66}) + v68 := lang.Apply(v62, []any{v67, int64(1)}) + v55 = v68 + } // end let + return v55 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // dosync + { + v0 := lang.NewSymbol("dosync").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("exprs"))), lang.NewKeyword("doc"), "Runs the exprs (in an implicit do) in a transaction that encompasses\n exprs and any nested calls. Starts a transaction if none is already\n running on this thread. Any uncaught exception will abort the\n transaction and flow out of dosync. The exprs may be run more than\n once, but any effects on Refs will be atomic.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5100), lang.NewKeyword("end-line"), int(5100))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.NewList(args[2:]...) + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("seq")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("concat")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("list")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.Apply(v14, []any{lang.NewSymbol("glojure.core/sync")}) + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("list")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{nil}) + v20 := lang.Apply(v11, []any{v15, v19, v5}) + v21 := lang.Apply(v8, []any{v20}) + return v21 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // dotimes + { + v0 := lang.NewSymbol("dotimes").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "bindings => name n\n\n Repeatedly executes body (presumably for side-effects) with name\n bound to integers from 0 through n-1.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3306), lang.NewKeyword("end-line"), int(3306))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + var v7 any + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v5}) + if lang.IsTruthy(v11) { + v7 = nil + } else { + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("str")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("first")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{v3}) + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("meta")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v3}) + v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) + v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) + v28 := lang.Apply(lang.NewIllegalArgumentError, []any{v27}) + panic(v28) + } + _ = v7 + var v29 any + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("=")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("count")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.Apply(v35, []any{v5}) + v37 := lang.Apply(v32, []any{int64(2), v36}) + if lang.IsTruthy(v37) { + v29 = nil + } else { + v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v39 := v38.FindInternedVar(lang.NewSymbol("str")) + if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + } + v40 := v39.Get() + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("first")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.Apply(v43, []any{v3}) + v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) + if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) + } + v47 := v46.Get() + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("meta")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v3}) + v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) + v53 := lang.Apply(v40, []any{v44, " requires ", "exactly 2 forms in binding vector", " in ", v47, ":", v52}) + v54 := lang.Apply(lang.NewIllegalArgumentError, []any{v53}) + panic(v54) + } + _ = v29 + _ = nil + var v55 any + { // let + // let binding "i" + v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v57 := v56.FindInternedVar(lang.NewSymbol("first")) + if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) + } + v58 := v57.Get() + v59 := lang.Apply(v58, []any{v5}) + var v60 any = v59 + _ = v60 + // let binding "n" + v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v62 := v61.FindInternedVar(lang.NewSymbol("second")) + if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) + } + v63 := v62.Get() + v64 := lang.Apply(v63, []any{v5}) + var v65 any = v64 + _ = v65 + v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v67 := v66.FindInternedVar(lang.NewSymbol("seq")) + if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) + } + v68 := v67.Get() + v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v70 := v69.FindInternedVar(lang.NewSymbol("concat")) + if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) + } + v71 := v70.Get() + v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v73 := v72.FindInternedVar(lang.NewSymbol("list")) + if v73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) + } + v74 := v73.Get() + v75 := lang.Apply(v74, []any{lang.NewSymbol("glojure.core/let")}) + v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v77 := v76.FindInternedVar(lang.NewSymbol("list")) + if v77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) + } + v78 := v77.Get() + v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v80 := v79.FindInternedVar(lang.NewSymbol("apply")) + if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) + } + v81 := v80.Get() + v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v83 := v82.FindInternedVar(lang.NewSymbol("vector")) + if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) + } + v84 := v83.Get() + v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v86 := v85.FindInternedVar(lang.NewSymbol("seq")) + if v86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) + } + v87 := v86.Get() + v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v89 := v88.FindInternedVar(lang.NewSymbol("concat")) + if v89.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) + } + v90 := v89.Get() + v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v92 := v91.FindInternedVar(lang.NewSymbol("list")) + if v92.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) + } + v93 := v92.Get() + v94 := lang.Apply(v93, []any{lang.NewSymbol("n__0__auto__")}) + v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v96 := v95.FindInternedVar(lang.NewSymbol("list")) + if v96.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) + } + v97 := v96.Get() + v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v99 := v98.FindInternedVar(lang.NewSymbol("seq")) + if v99.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) + } + v100 := v99.Get() + v101 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v102 := v101.FindInternedVar(lang.NewSymbol("concat")) + if v102.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v102))) + } + v103 := v102.Get() + v104 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v105 := v104.FindInternedVar(lang.NewSymbol("list")) + if v105.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v105))) + } + v106 := v105.Get() + v107 := lang.Apply(v106, []any{lang.NewSymbol("glojure.core/long")}) + v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v109 := v108.FindInternedVar(lang.NewSymbol("list")) + if v109.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) + } + v110 := v109.Get() + v111 := lang.Apply(v110, []any{v65}) + v112 := lang.Apply(v103, []any{v107, v111}) + v113 := lang.Apply(v100, []any{v112}) + v114 := lang.Apply(v97, []any{v113}) + v115 := lang.Apply(v90, []any{v94, v114}) + v116 := lang.Apply(v87, []any{v115}) + v117 := lang.Apply(v81, []any{v84, v116}) + v118 := lang.Apply(v78, []any{v117}) + v119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v120 := v119.FindInternedVar(lang.NewSymbol("list")) + if v120.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v120))) + } + v121 := v120.Get() + v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v123 := v122.FindInternedVar(lang.NewSymbol("seq")) + if v123.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) + } + v124 := v123.Get() + v125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v126 := v125.FindInternedVar(lang.NewSymbol("concat")) + if v126.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v126))) + } + v127 := v126.Get() + v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v129 := v128.FindInternedVar(lang.NewSymbol("list")) + if v129.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v129))) + } + v130 := v129.Get() + v131 := lang.Apply(v130, []any{lang.NewSymbol("glojure.core/loop")}) + v132 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v133 := v132.FindInternedVar(lang.NewSymbol("list")) + if v133.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v133))) + } + v134 := v133.Get() + v135 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v136 := v135.FindInternedVar(lang.NewSymbol("apply")) + if v136.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v136))) + } + v137 := v136.Get() + v138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v139 := v138.FindInternedVar(lang.NewSymbol("vector")) + if v139.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v139))) + } + v140 := v139.Get() + v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v142 := v141.FindInternedVar(lang.NewSymbol("seq")) + if v142.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) + } + v143 := v142.Get() + v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v145 := v144.FindInternedVar(lang.NewSymbol("concat")) + if v145.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) + } + v146 := v145.Get() + v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v148 := v147.FindInternedVar(lang.NewSymbol("list")) + if v148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) + } + v149 := v148.Get() + v150 := lang.Apply(v149, []any{v60}) + v151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v152 := v151.FindInternedVar(lang.NewSymbol("list")) + if v152.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v152))) + } + v153 := v152.Get() + v154 := lang.Apply(v153, []any{int64(0)}) + v155 := lang.Apply(v146, []any{v150, v154}) + v156 := lang.Apply(v143, []any{v155}) + v157 := lang.Apply(v137, []any{v140, v156}) + v158 := lang.Apply(v134, []any{v157}) + v159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v160 := v159.FindInternedVar(lang.NewSymbol("list")) + if v160.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v160))) + } + v161 := v160.Get() + v162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v163 := v162.FindInternedVar(lang.NewSymbol("seq")) + if v163.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v163))) + } + v164 := v163.Get() + v165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v166 := v165.FindInternedVar(lang.NewSymbol("concat")) + if v166.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v166))) + } + v167 := v166.Get() + v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v169 := v168.FindInternedVar(lang.NewSymbol("list")) + if v169.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) + } + v170 := v169.Get() + v171 := lang.Apply(v170, []any{lang.NewSymbol("glojure.core/when")}) + v172 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v173 := v172.FindInternedVar(lang.NewSymbol("list")) + if v173.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v173))) + } + v174 := v173.Get() + v175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v176 := v175.FindInternedVar(lang.NewSymbol("seq")) + if v176.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v176))) + } + v177 := v176.Get() + v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v179 := v178.FindInternedVar(lang.NewSymbol("concat")) + if v179.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) + } + v180 := v179.Get() + v181 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v182 := v181.FindInternedVar(lang.NewSymbol("list")) + if v182.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v182))) + } + v183 := v182.Get() + v184 := lang.Apply(v183, []any{lang.NewSymbol("glojure.core/<")}) + v185 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v186 := v185.FindInternedVar(lang.NewSymbol("list")) + if v186.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v186))) + } + v187 := v186.Get() + v188 := lang.Apply(v187, []any{v60}) + v189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v190 := v189.FindInternedVar(lang.NewSymbol("list")) + if v190.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v190))) + } + v191 := v190.Get() + v192 := lang.Apply(v191, []any{lang.NewSymbol("n__0__auto__")}) + v193 := lang.Apply(v180, []any{v184, v188, v192}) + v194 := lang.Apply(v177, []any{v193}) + v195 := lang.Apply(v174, []any{v194}) + v196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v197 := v196.FindInternedVar(lang.NewSymbol("list")) + if v197.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v197))) + } + v198 := v197.Get() + v199 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v200 := v199.FindInternedVar(lang.NewSymbol("seq")) + if v200.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v200))) + } + v201 := v200.Get() + v202 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v203 := v202.FindInternedVar(lang.NewSymbol("concat")) + if v203.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v203))) + } + v204 := v203.Get() + v205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v206 := v205.FindInternedVar(lang.NewSymbol("list")) + if v206.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v206))) + } + v207 := v206.Get() + v208 := lang.Apply(v207, []any{lang.NewSymbol("recur")}) + v209 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v210 := v209.FindInternedVar(lang.NewSymbol("list")) + if v210.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v210))) + } + v211 := v210.Get() + v212 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v213 := v212.FindInternedVar(lang.NewSymbol("seq")) + if v213.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v213))) + } + v214 := v213.Get() + v215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v216 := v215.FindInternedVar(lang.NewSymbol("concat")) + if v216.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v216))) + } + v217 := v216.Get() + v218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v219 := v218.FindInternedVar(lang.NewSymbol("list")) + if v219.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v219))) + } + v220 := v219.Get() + v221 := lang.Apply(v220, []any{lang.NewSymbol("glojure.core/unchecked-inc")}) + v222 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v223 := v222.FindInternedVar(lang.NewSymbol("list")) + if v223.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v223))) + } + v224 := v223.Get() + v225 := lang.Apply(v224, []any{v60}) + v226 := lang.Apply(v217, []any{v221, v225}) + v227 := lang.Apply(v214, []any{v226}) + v228 := lang.Apply(v211, []any{v227}) + v229 := lang.Apply(v204, []any{v208, v228}) + v230 := lang.Apply(v201, []any{v229}) + v231 := lang.Apply(v198, []any{v230}) + v232 := lang.Apply(v167, []any{v171, v195, v6, v231}) + v233 := lang.Apply(v164, []any{v232}) + v234 := lang.Apply(v161, []any{v233}) + v235 := lang.Apply(v127, []any{v131, v158, v234}) + v236 := lang.Apply(v124, []any{v235}) + v237 := lang.Apply(v121, []any{v236}) + v238 := lang.Apply(v71, []any{v75, v118, v237}) + v239 := lang.Apply(v68, []any{v238}) + v55 = v239 + } // end let + return v55 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // doto + { + v0 := lang.NewSymbol("doto").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "Evaluates x then calls all of the methods and functions with the\n value of x supplied at the front of the given arguments. The forms\n are evaluated in order. Returns x.\n\n (doto (new java.util.HashMap) (.put \"a\" 1) (.put \"b\" 2))", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3853), lang.NewKeyword("end-line"), int(3853))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + var v7 any + { // let + // let binding "gx" + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("gensym")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, nil) + var v12 any = v11 + _ = v12 + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("seq")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("concat")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("list")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{lang.NewSymbol("glojure.core/let")}) + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("list")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("apply")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("vector")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("seq")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v36 := v35.FindInternedVar(lang.NewSymbol("concat")) + if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + } + v37 := v36.Get() + v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v39 := v38.FindInternedVar(lang.NewSymbol("list")) + if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + } + v40 := v39.Get() + v41 := lang.Apply(v40, []any{v12}) + v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v43 := v42.FindInternedVar(lang.NewSymbol("list")) + if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) + } + v44 := v43.Get() + v45 := lang.Apply(v44, []any{v5}) + v46 := lang.Apply(v37, []any{v41, v45}) + v47 := lang.Apply(v34, []any{v46}) + v48 := lang.Apply(v28, []any{v31, v47}) + v49 := lang.Apply(v25, []any{v48}) + v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v51 := v50.FindInternedVar(lang.NewSymbol("map")) + if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) + } + v52 := v51.Get() + var v53 lang.FnFunc + v53 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v54 := args[0] + _ = v54 + v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v56 := v55.FindInternedVar(lang.NewSymbol("with-meta")) + if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) + } + v57 := v56.Get() + var v58 any + v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v60 := v59.FindInternedVar(lang.NewSymbol("seq?")) + if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) + } + v61 := v60.Get() + v62 := lang.Apply(v61, []any{v54}) + if lang.IsTruthy(v62) { + v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v64 := v63.FindInternedVar(lang.NewSymbol("seq")) + if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) + } + v65 := v64.Get() + v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v67 := v66.FindInternedVar(lang.NewSymbol("concat")) + if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) + } + v68 := v67.Get() + v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v70 := v69.FindInternedVar(lang.NewSymbol("list")) + if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) + } + v71 := v70.Get() + v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v73 := v72.FindInternedVar(lang.NewSymbol("first")) + if v73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) + } + v74 := v73.Get() + v75 := lang.Apply(v74, []any{v54}) + v76 := lang.Apply(v71, []any{v75}) + v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v78 := v77.FindInternedVar(lang.NewSymbol("list")) + if v78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) + } + v79 := v78.Get() + v80 := lang.Apply(v79, []any{v12}) + v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v82 := v81.FindInternedVar(lang.NewSymbol("next")) + if v82.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) + } + v83 := v82.Get() + v84 := lang.Apply(v83, []any{v54}) + v85 := lang.Apply(v68, []any{v76, v80, v84}) + v86 := lang.Apply(v65, []any{v85}) + v58 = v86 + } else { + v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v88 := v87.FindInternedVar(lang.NewSymbol("seq")) + if v88.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) + } + v89 := v88.Get() + v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v91 := v90.FindInternedVar(lang.NewSymbol("concat")) + if v91.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) + } + v92 := v91.Get() + v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v94 := v93.FindInternedVar(lang.NewSymbol("list")) + if v94.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) + } + v95 := v94.Get() + v96 := lang.Apply(v95, []any{v54}) + v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v98 := v97.FindInternedVar(lang.NewSymbol("list")) + if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) + } + v99 := v98.Get() + v100 := lang.Apply(v99, []any{v12}) + v101 := lang.Apply(v92, []any{v96, v100}) + v102 := lang.Apply(v89, []any{v101}) + v58 = v102 + } + v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v104 := v103.FindInternedVar(lang.NewSymbol("meta")) + if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) + } + v105 := v104.Get() + v106 := lang.Apply(v105, []any{v54}) + v107 := lang.Apply(v57, []any{v58, v106}) + return v107 + }) + v54 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3863), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(3868), lang.NewKeyword("end-column"), int(30)) + v55, err := lang.WithMeta(v53, v54.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v56 := lang.Apply(v52, []any{v55, v6}) + v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v58 := v57.FindInternedVar(lang.NewSymbol("list")) + if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) + } + v59 := v58.Get() + v60 := lang.Apply(v59, []any{v12}) + v61 := lang.Apply(v18, []any{v22, v49, v56, v60}) + v62 := lang.Apply(v15, []any{v61}) + v7 = v62 + } // end let + return v7 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // double + { + var v1 lang.FnFunc + { // function double__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("concat")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("list")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("seq")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("concat")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/DoubleCast")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{v3}) + v35 := lang.Apply(v26, []any{v30, v34}) + v36 := lang.Apply(v23, []any{v35}) + v37 := lang.Apply(v20, []any{v36}) + v38 := lang.Apply(v9, []any{v13, v17, v37}) + v39 := lang.Apply(v6, []any{v38}) + return v39 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("double").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to double", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3493), lang.NewKeyword("end-line"), int(3493))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := lang.Apply(lang.AsFloat64, []any{v4}) + return v5 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // double-array + { + var v1 lang.FnFunc + { // function double-array__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := lang.NewList(args[0:]...) + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("concat")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("list")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/DoubleArray")}) + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("list")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("seq")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("concat")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) + v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v36 := v35.FindInternedVar(lang.NewSymbol("list")) + if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + } + v37 := v36.Get() + v38 := lang.Apply(v37, []any{lang.NewSymbol("glojure.core/args")}) + v39 := lang.Apply(v30, []any{v34, v38}) + v40 := lang.Apply(v27, []any{v39}) + v41 := lang.Apply(v24, []any{v40}) + v42 := lang.Apply(v9, []any{v13, v17, v21, v41}) + v43 := lang.Apply(v6, []any{v42}) + return v43 + } + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("double-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Creates an array of doubles", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1), int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5341), lang.NewKeyword("end-line"), int(5341))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + v5, _ := lang.FieldOrMethod(lang.Numbers, "DoubleArray") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("DoubleArray is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6, _ := lang.FieldOrMethod(lang.Numbers, "DoubleArrayInit") + if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("DoubleArrayInit is not a function"))) + } + v7 := lang.Apply(v6, []any{v4, v5}) + return v7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // double? + { + v0 := lang.NewSymbol("double?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a Double", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1421), lang.NewKeyword("end-line"), int(1421))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.Apply(v6, []any{lang.Builtins["float64"], v3}) + return v7 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // doubles + { + var v1 lang.FnFunc + { // function doubles + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("concat")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("list")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/Doubles")}) + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("list")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v3}) + v26 := lang.Apply(v9, []any{v13, v17, v21, v25}) + v27 := lang.Apply(v6, []any{v26}) + return v27 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("doubles").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Casts to double[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5402), lang.NewKeyword("end-line"), int(5402))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5, _ := lang.FieldOrMethod(lang.Numbers, "Doubles") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Doubles is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // drop + { + v0 := lang.NewSymbol("drop").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a laziness-preserving sequence of all but the first n items in coll.\n Returns a stateful transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2901), lang.NewKeyword("end-line"), int(2901))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + var v4 lang.FnFunc + v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + var v6 any + { // let + // let binding "nv" + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("volatile!")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, []any{v3}) + var v11 any = v10 + _ = v11 + var v12 lang.FnFunc + v12 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + v13 := lang.Apply(v5, nil) + return v13 + case 1: + v13 := args[0] + _ = v13 + v14 := lang.Apply(v5, []any{v13}) + return v14 + case 2: + v13 := args[0] + _ = v13 + v14 := args[1] + _ = v14 + var v15 any + { // let + // let binding "n" + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("deref")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{v11}) + var v20 any = v19 + _ = v20 + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("dec")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24, ok := lang.FieldOrMethod(v11, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v11, "Deref"))) + } + var v25 any + switch reflect.TypeOf(v24).Kind() { + case reflect.Func: + v25 = lang.Apply(v24, nil) + default: + v25 = v24 + } + v26 := lang.Apply(v23, []any{v25}) + v27, _ := lang.FieldOrMethod(v11, "reset") + if reflect.TypeOf(v27).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) + } + v28 := lang.Apply(v27, []any{v26}) + _ = v28 + var v29 any + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("pos?")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.Apply(v32, []any{v20}) + if lang.IsTruthy(v33) { + v29 = v13 + } else { + v34 := lang.Apply(v5, []any{v13, v14}) + v29 = v34 + } + v15 = v29 + } // end let + return v15 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2909), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(2917), lang.NewKeyword("end-column"), int(39)) + v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v6 = v14 + } // end let + return v6 + }) + v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2907), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2917), lang.NewKeyword("end-column"), int(41)) + v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v6 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{lang.IDrop, v4}) + if lang.IsTruthy(v9) { + var v10 any + { // let + // let binding "or__0__auto__" + var v11 any + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("pos?")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.Apply(v14, []any{v3}) + if lang.IsTruthy(v15) { + var v16 any + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("int?")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.Apply(v19, []any{v3}) + if lang.IsTruthy(v20) { + v16 = v3 + } else { + v21 := lang.Apply(nil, []any{v3}) + v16 = v21 + } + v22, _ := lang.FieldOrMethod(v4, "drop") + if reflect.TypeOf(v22).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("drop is not a function"))) + } + v23 := lang.Apply(v22, []any{v16}) + v11 = v23 + } else { + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("seq")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.Apply(v26, []any{v4}) + v11 = v27 + } + var v28 any = v11 + _ = v28 + var v29 any + if lang.IsTruthy(v28) { + v29 = v28 + } else { + v29 = lang.NewList() + } + v10 = v29 + } // end let + v5 = v10 + } else { + var v11 any + { // let + // let binding "step" + var v12 lang.FnFunc + v12 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v13 := args[0] + _ = v13 + v14 := args[1] + _ = v14 + recur_loop_539: + var v15 any + { // let + // let binding "s" + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("seq")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{v14}) + var v20 any = v19 + _ = v20 + var v21 any + var v22 any + { // let + // let binding "and__0__auto__" + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("pos?")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.Apply(v25, []any{v13}) + var v27 any = v26 + _ = v27 + var v28 any + if lang.IsTruthy(v27) { + v28 = v20 + } else { + v28 = v27 + } + v22 = v28 + } // end let + if lang.IsTruthy(v22) { + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("dec")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.Apply(v26, []any{v13}) + var v23 any = v27 + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("rest")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.Apply(v31, []any{v20}) + var v28 any = v32 + v13 = v23 + v14 = v28 + goto recur_loop_539 + } else { + v21 = v20 + } + v15 = v21 + } // end let + return v15 + }) + v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2925), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(2929), lang.NewKeyword("end-column"), int(28)) + v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v15 any = v14 + _ = v15 + var v16 lang.FnFunc + v16 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v17 := lang.Apply(v15, []any{v3, v4}) + return v17 + }) + v17 := lang.Apply(lang.NewLazySeq, []any{v16}) + v11 = v17 + } // end let + v5 = v11 + } + return v5 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // drop-last + { + v0 := lang.NewSymbol("drop-last").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return a lazy sequence of all but the last n (default 1) items in coll", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2932), lang.NewKeyword("end-line"), int(2932))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("drop-last")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.Apply(v6, []any{int64(1), v3}) + return v7 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("map")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + var v8 lang.FnFunc + v8 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v9 := args[0] + _ = v9 + v10 := args[1] + _ = v10 + return v9 + }) + v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2937), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(2937), lang.NewKeyword("end-column"), int(29)) + v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("drop")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{v3, v4}) + v15 := lang.Apply(v7, []any{v10, v4, v14}) + return v15 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // drop-while + { + v0 := lang.NewSymbol("drop-while").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred")), lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the items in coll starting from the\n first item for which (pred item) returns logical false. Returns a\n stateful transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2950), lang.NewKeyword("end-line"), int(2950))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + var v4 lang.FnFunc + v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + var v6 any + { // let + // let binding "dv" + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("volatile!")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, []any{true}) + var v11 any = v10 + _ = v11 + var v12 lang.FnFunc + v12 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + v13 := lang.Apply(v5, nil) + return v13 + case 1: + v13 := args[0] + _ = v13 + v14 := lang.Apply(v5, []any{v13}) + return v14 + case 2: + v13 := args[0] + _ = v13 + v14 := args[1] + _ = v14 + var v15 any + { // let + // let binding "drop?" + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("deref")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{v11}) + var v20 any = v19 + _ = v20 + var v21 any + var v22 any + { // let + // let binding "and__0__auto__" + var v23 any = v20 + _ = v23 + var v24 any + if lang.IsTruthy(v23) { + v25 := lang.Apply(v3, []any{v14}) + v24 = v25 + } else { + v24 = v23 + } + v22 = v24 + } // end let + if lang.IsTruthy(v22) { + v21 = v13 + } else { + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("vreset!")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.Apply(v25, []any{v11, nil}) + _ = v26 + v27 := lang.Apply(v5, []any{v13, v14}) + v21 = v27 + } + v15 = v21 + } // end let + return v15 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2959), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(2968), lang.NewKeyword("end-column"), int(42)) + v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v6 = v14 + } // end let + return v6 + }) + v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2957), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2968), lang.NewKeyword("end-column"), int(44)) + v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v6 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any + { // let + // let binding "step" + var v6 lang.FnFunc + v6 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + recur_loop_552: + var v9 any + { // let + // let binding "s" + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("seq")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{v8}) + var v14 any = v13 + _ = v14 + var v15 any + var v16 any + { // let + // let binding "and__0__auto__" + var v17 any = v14 + _ = v17 + var v18 any + if lang.IsTruthy(v17) { + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("first")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{v14}) + v23 := lang.Apply(v7, []any{v22}) + v18 = v23 + } else { + v18 = v17 + } + v16 = v18 + } // end let + if lang.IsTruthy(v16) { + var v17 any = v7 + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("rest")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{v14}) + var v18 any = v22 + v7 = v17 + v8 = v18 + goto recur_loop_552 + } else { + v15 = v14 + } + v9 = v15 + } // end let + return v9 + }) + v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2970), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(2974), lang.NewKeyword("end-column"), int(26)) + v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v9 any = v8 + _ = v9 + var v10 lang.FnFunc + v10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v11 := lang.Apply(v9, []any{v3, v4}) + return v11 + }) + v11 := lang.Apply(lang.NewLazySeq, []any{v10}) + v5 = v11 + } // end let + return v5 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // elide-top-frames + { + v0 := lang.NewSymbol("elide-top-frames").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4794), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(4794), lang.NewKeyword("end-column"), int(32), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ex"), lang.NewSymbol("class-name"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any + { // let + // let binding "tr" + v6, ok := lang.FieldOrMethod(v3, "getStackTrace") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getStackTrace"))) + } + var v7 any + switch reflect.TypeOf(v6).Kind() { + case reflect.Func: + v7 = lang.Apply(v6, nil) + default: + v7 = v6 + } + var v8 any = v7 + _ = v8 + var v9 any + { // let + // let binding "G__54" + var v10 any = v3 + _ = v10 + var v11 any + if lang.IsTruthy(v8) { + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("into-array")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("drop-while")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + var v18 lang.FnFunc + v18 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v19 := args[0] + _ = v19 + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("=")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23, ok := lang.FieldOrMethod(v19, "getClassName") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v19, "getClassName"))) + } + var v24 any + switch reflect.TypeOf(v23).Kind() { + case reflect.Func: + v24 = lang.Apply(v23, nil) + default: + v24 = v23 + } + v25 := lang.Apply(v22, []any{v4, v24}) + return v25 + }) + v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4801), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(4801), lang.NewKeyword("end-column"), int(77)) + v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v21 := lang.Apply(v17, []any{v20, v8}) + v22 := lang.Apply(v14, []any{nil, v21}) + v11 = v22 + } else { + v11 = nil + } + v23, _ := lang.FieldOrMethod(v10, "setStackTrace") + if reflect.TypeOf(v23).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setStackTrace is not a function"))) + } + v24 := lang.Apply(v23, []any{v11}) + _ = v24 + v9 = v10 + } // end let + v5 = v9 + } // end let + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // emit-extend-protocol + { + v0 := lang.NewSymbol("emit-extend-protocol").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(205), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(205), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("p"), lang.NewSymbol("specs"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any + { // let + // let binding "impls" + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("parse-impls")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{v4}) + var v10 any = v9 + _ = v10 + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("seq")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("concat")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("list")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.Apply(v19, []any{lang.NewSymbol("do")}) + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("map")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + var v24 lang.FnFunc + v24 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v25 := args[0] + _ = v25 + var v26 any + { // let + // let binding "vec__292" + var v27 any = v25 + _ = v27 + // let binding "t" + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("nth")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.Apply(v30, []any{v27, int64(0), nil}) + var v32 any = v31 + _ = v32 + // let binding "fs" + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("nth")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.Apply(v35, []any{v27, int64(1), nil}) + var v37 any = v36 + _ = v37 + v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v39 := v38.FindInternedVar(lang.NewSymbol("seq")) + if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + } + v40 := v39.Get() + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("concat")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("list")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.Apply(v46, []any{lang.NewSymbol("glojure.core/extend-type")}) + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("list")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v32}) + v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v53 := v52.FindInternedVar(lang.NewSymbol("list")) + if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) + } + v54 := v53.Get() + v55 := lang.Apply(v54, []any{v3}) + v56 := lang.Apply(v43, []any{v47, v51, v55, v37}) + v57 := lang.Apply(v40, []any{v56}) + v26 = v57 + } // end let + return v26 + }) + v25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(208), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(209), lang.NewKeyword("end-column"), int(42)) + v26, err := lang.WithMeta(v24, v25.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v27 := lang.Apply(v23, []any{v26, v10}) + v28 := lang.Apply(v16, []any{v20, v27}) + v29 := lang.Apply(v13, []any{v28}) + v5 = v29 + } // end let + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // emit-extend-type + { + v0 := lang.NewSymbol("emit-extend-type").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(175), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(175), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"), lang.NewSymbol("specs"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any + { // let + // let binding "impls" + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("parse-impls")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{v4}) + var v10 any = v9 + _ = v10 + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("seq")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("concat")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("list")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.Apply(v19, []any{lang.NewSymbol("glojure.core/extend")}) + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("list")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.Apply(v23, []any{v3}) + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("mapcat")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("partial")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("emit-hinted-impl")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v30, []any{v33, v3}) + v35 := lang.Apply(v27, []any{v34, v10}) + v36 := lang.Apply(v16, []any{v20, v24, v35}) + v37 := lang.Apply(v13, []any{v36}) + v5 = v37 + } // end let + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // emit-hinted-impl + { + v0 := lang.NewSymbol("emit-hinted-impl").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(163), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(163), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"), lang.NewVector(lang.NewSymbol("p"), lang.NewSymbol("fs")))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any + { // let + // let binding "vec__281" + var v6 any = v4 + _ = v6 + // let binding "p" + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("nth")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, []any{v6, int64(0), nil}) + var v11 any = v10 + _ = v11 + // let binding "fs" + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("nth")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.Apply(v14, []any{v6, int64(1), nil}) + var v16 any = v15 + _ = v16 + var v17 any + { // let + // let binding "hint" + var v18 lang.FnFunc + v18 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v19 := args[0] + _ = v19 + var v20 any + { // let + // let binding "specs" + var v21 any + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("vector?")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("first")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.Apply(v27, []any{v19}) + v29 := lang.Apply(v24, []any{v28}) + if lang.IsTruthy(v29) { + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("list")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.Apply(v32, []any{v19}) + v21 = v33 + } else { + v21 = v19 + } + var v34 any = v21 + _ = v34 + v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v36 := v35.FindInternedVar(lang.NewSymbol("map")) + if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + } + v37 := v36.Get() + var v38 lang.FnFunc + v38 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v39 := args[0] + _ = v39 + var v40 any + { // let + // let binding "vec__285" + var v41 any = v39 + _ = v41 + // let binding "seq__286" + v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v43 := v42.FindInternedVar(lang.NewSymbol("seq")) + if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) + } + v44 := v43.Get() + v45 := lang.Apply(v44, []any{v41}) + var v46 any = v45 + _ = v46 + // let binding "first__287" + v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v48 := v47.FindInternedVar(lang.NewSymbol("first")) + if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) + } + v49 := v48.Get() + v50 := lang.Apply(v49, []any{v46}) + var v51 any = v50 + _ = v51 + // let binding "seq__286" + v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v53 := v52.FindInternedVar(lang.NewSymbol("next")) + if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) + } + v54 := v53.Get() + v55 := lang.Apply(v54, []any{v46}) + var v56 any = v55 + _ = v56 + // let binding "vec__288" + var v57 any = v51 + _ = v57 + // let binding "seq__289" + v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v59 := v58.FindInternedVar(lang.NewSymbol("seq")) + if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) + } + v60 := v59.Get() + v61 := lang.Apply(v60, []any{v57}) + var v62 any = v61 + _ = v62 + // let binding "first__290" + v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v64 := v63.FindInternedVar(lang.NewSymbol("first")) + if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) + } + v65 := v64.Get() + v66 := lang.Apply(v65, []any{v62}) + var v67 any = v66 + _ = v67 + // let binding "seq__289" + v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v69 := v68.FindInternedVar(lang.NewSymbol("next")) + if v69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) + } + v70 := v69.Get() + v71 := lang.Apply(v70, []any{v62}) + var v72 any = v71 + _ = v72 + // let binding "target" + var v73 any = v67 + _ = v73 + // let binding "args" + var v74 any = v72 + _ = v74 + // let binding "body" + var v75 any = v56 + _ = v75 + v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v77 := v76.FindInternedVar(lang.NewSymbol("cons")) + if v77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) + } + v78 := v77.Get() + v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v80 := v79.FindInternedVar(lang.NewSymbol("apply")) + if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) + } + v81 := v80.Get() + v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v83 := v82.FindInternedVar(lang.NewSymbol("vector")) + if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) + } + v84 := v83.Get() + v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v86 := v85.FindInternedVar(lang.NewSymbol("vary-meta")) + if v86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) + } + v87 := v86.Get() + v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v89 := v88.FindInternedVar(lang.NewSymbol("assoc")) + if v89.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) + } + v90 := v89.Get() + v91 := lang.Apply(v87, []any{v73, v90, lang.NewKeyword("tag"), v3}) + v92 := lang.Apply(v81, []any{v84, v91, v74}) + v93 := lang.Apply(v78, []any{v92, v75}) + v40 = v93 + } // end let + return v40 + }) + v39 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(168), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(170), lang.NewKeyword("end-column"), int(36)) + v40, err := lang.WithMeta(v38, v39.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v41 := lang.Apply(v37, []any{v40, v34}) + v20 = v41 + } // end let + return v20 + }) + v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(164), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(171), lang.NewKeyword("end-column"), int(30)) + v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v21 any = v20 + _ = v21 + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("zipmap")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("map")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + var v28 lang.FnFunc + v28 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v29 := args[0] + _ = v29 + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("keyword")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("name")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("first")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v38, []any{v29}) + v40 := lang.Apply(v35, []any{v39}) + v41 := lang.Apply(v32, []any{v40}) + return v41 + }) + v29 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(172), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(172), lang.NewKeyword("end-column"), int(46)) + v30, err := lang.WithMeta(v28, v29.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v31 := lang.Apply(v27, []any{v30, v16}) + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("map")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + var v35 lang.FnFunc + v35 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v36 := args[0] + _ = v36 + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("cons")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("drop")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.Apply(v42, []any{int64(1), v36}) + v44 := lang.Apply(v21, []any{v43}) + v45 := lang.Apply(v39, []any{lang.NewSymbol("glojure.core/fn"), v44}) + return v45 + }) + v36 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(173), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(173), lang.NewKeyword("end-column"), int(49)) + v37, err := lang.WithMeta(v35, v36.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v38 := lang.Apply(v34, []any{v37, v16}) + v39 := lang.Apply(v24, []any{v31, v38}) + v40 := lang.NewVector(v11, v39) + v41 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(172), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(173), lang.NewKeyword("end-column"), int(55)) + v42, err := lang.WithMeta(v40, v41.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v17 = v42 + } // end let + v5 = v17 + } // end let + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // empty + { + v0 := lang.NewSymbol("empty").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns an empty collection of the same category as coll, or nil", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5265), lang.NewKeyword("end-line"), int(5265))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{lang.IPersistentCollection, v3}) + if lang.IsTruthy(v8) { + v9, ok := lang.FieldOrMethod(v3, "empty") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "empty"))) + } + var v10 any + switch reflect.TypeOf(v9).Kind() { + case reflect.Func: + v10 = lang.Apply(v9, nil) + default: + v10 = v9 + } + v4 = v10 + } else { + v4 = nil + } + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // empty? + { + v0 := lang.NewSymbol("empty?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll has no items. To check the emptiness of a seq,\n please use the idiom (seq x) rather than (not (empty? x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6247), lang.NewKeyword("end-line"), int(6247))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("counted?")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v3}) + if lang.IsTruthy(v8) { + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("zero?")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("count")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.Apply(v14, []any{v3}) + v16 := lang.Apply(v11, []any{v15}) + v4 = v16 + } else { + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("not")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("seq")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.Apply(v22, []any{v3}) + v24 := lang.Apply(v19, []any{v23}) + v4 = v24 + } + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // ensure + { + v0 := lang.NewSymbol("ensure").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref"))), lang.NewKeyword("doc"), "Must be called in a transaction. Protects the ref from modification\n by other transactions. Returns the in-transaction-value of\n ref. Allows for more concurrency than (ref-set ref @ref)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2480), lang.NewKeyword("end-line"), int(2480))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4, _ := lang.FieldOrMethod(v3, "touch") + if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("touch is not a function"))) + } + v5 := lang.Apply(v4, []any{}) + _ = v5 + v6, _ := lang.FieldOrMethod(v3, "deref") + if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("deref is not a function"))) + } + v7 := lang.Apply(v6, []any{}) + return v7 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // ensure-reduced + { + v0 := lang.NewSymbol("ensure-reduced").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "If x is already reduced?, returns it, else returns (reduced x)", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2841), lang.NewKeyword("end-line"), int(2841))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("reduced?")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v3}) + if lang.IsTruthy(v8) { + v4 = v3 + } else { + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("reduced")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.Apply(v11, []any{v3}) + v4 = v12 + } + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // enumeration-seq + { + v0 := lang.NewSymbol("enumeration-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("e"))), lang.NewKeyword("doc"), "Returns a seq on a java.util.Enumeration", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5710), lang.NewKeyword("end-line"), int(5710))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.Apply(nil, []any{v3}) + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // error-handler + { + v0 := lang.NewSymbol("error-handler").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("doc"), "Returns the error-handler of agent a, or nil if there is none.\n See set-error-handler!", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2202), lang.NewKeyword("end-line"), int(2202))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4, ok := lang.FieldOrMethod(v3, "getErrorHandler") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getErrorHandler"))) + } + var v5 any + switch reflect.TypeOf(v4).Kind() { + case reflect.Func: + v5 = lang.Apply(v4, nil) + default: + v5 = v4 + } + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // error-mode + { + v0 := lang.NewSymbol("error-mode").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("doc"), "Returns the error-mode of agent a. See set-error-mode!", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2227), lang.NewKeyword("end-line"), int(2227))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4, ok := lang.FieldOrMethod(v3, "getErrorMode") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getErrorMode"))) + } + var v5 any + switch reflect.TypeOf(v4).Kind() { + case reflect.Func: + v5 = lang.Apply(v4, nil) + default: + v5 = v4 + } + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // eval + { + v0 := lang.NewSymbol("eval").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("form"))), lang.NewKeyword("doc"), "Evaluates the form data structure (not text!) and returns the result.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3203), lang.NewKeyword("end-line"), int(3203))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4, _ := lang.FieldOrMethod(runtime4.Compiler, "Eval") + if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Eval is not a function"))) + } + v5 := lang.Apply(v4, []any{v3}) + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // even? + { + v0 := lang.NewSymbol("even?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is even, throws an exception if n is not an integer", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1381), lang.NewKeyword("end-line"), int(1381))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("integer?")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v3}) + if lang.IsTruthy(v8) { + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("zero?")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("bit-and")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.Apply(lang.UncheckedLongCast, []any{v3}) + v16 := lang.Apply(v14, []any{v15, int64(1)}) + v17 := lang.Apply(v11, []any{v16}) + v4 = v17 + } else { + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("str")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.Apply(v20, []any{"Argument must be an integer: ", v3}) + v22 := lang.Apply(lang.NewIllegalArgumentError, []any{v21}) + panic(v22) + } + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // every-pred + { + v0 := lang.NewSymbol("every-pred").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("p")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2"), lang.NewSymbol("p3")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2"), lang.NewSymbol("p3"), lang.NewSymbol("&"), lang.NewSymbol("ps"))), lang.NewKeyword("doc"), "Takes a set of predicates and returns a function f that returns true if all of its\n composing predicates return a logical true value against all of its arguments, else it returns\n false. Note that f is short-circuiting in that it will stop execution on the first\n argument that triggers a logical false result against the original predicates.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7422), lang.NewKeyword("end-line"), int(7422))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + var v4 lang.FnFunc + { // function ep1 + v4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return true + case 1: + v6 := args[0] + _ = v6 + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("boolean")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v3, []any{v6}) + v11 := lang.Apply(v9, []any{v10}) + return v11 + case 2: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("boolean")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + var v11 any + { // let + // let binding "and__0__auto__" + v12 := lang.Apply(v3, []any{v6}) + var v13 any = v12 + _ = v13 + var v14 any + if lang.IsTruthy(v13) { + v15 := lang.Apply(v3, []any{v7}) + v14 = v15 + } else { + v14 = v13 + } + v11 = v14 + } // end let + v12 := lang.Apply(v10, []any{v11}) + return v12 + case 3: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("boolean")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + var v12 any + { // let + // let binding "and__0__auto__" + v13 := lang.Apply(v3, []any{v6}) + var v14 any = v13 + _ = v14 + var v15 any + if lang.IsTruthy(v14) { + var v16 any + { // let + // let binding "and__0__auto__" + v17 := lang.Apply(v3, []any{v7}) + var v18 any = v17 + _ = v18 + var v19 any + if lang.IsTruthy(v18) { + v20 := lang.Apply(v3, []any{v8}) + v19 = v20 + } else { + v19 = v18 + } + v16 = v19 + } // end let + v15 = v16 + } else { + v15 = v14 + } + v12 = v15 + } // end let + v13 := lang.Apply(v11, []any{v12}) + return v13 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + v9 := lang.NewList(args[3:]...) + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("boolean")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + var v13 any + { // let + // let binding "and__0__auto__" + v14 := lang.Apply(v5, []any{v6, v7, v8}) + var v15 any = v14 + _ = v15 + var v16 any + if lang.IsTruthy(v15) { + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("every?")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.Apply(v19, []any{v3, v9}) + v16 = v20 + } else { + v16 = v15 + } + v13 = v16 + } // end let + v14 := lang.Apply(v12, []any{v13}) + return v14 + } + }) + v5 := v4 + _ = v5 + } + v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7429), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7435), lang.NewKeyword("end-column"), int(56)) + v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v6 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 lang.FnFunc + { // function ep2 + v5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return true + case 1: + v7 := args[0] + _ = v7 + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("boolean")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + var v11 any + { // let + // let binding "and__0__auto__" + v12 := lang.Apply(v3, []any{v7}) + var v13 any = v12 + _ = v13 + var v14 any + if lang.IsTruthy(v13) { + v15 := lang.Apply(v4, []any{v7}) + v14 = v15 + } else { + v14 = v13 + } + v11 = v14 + } // end let + v12 := lang.Apply(v10, []any{v11}) + return v12 + case 2: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("boolean")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + var v12 any + { // let + // let binding "and__0__auto__" + v13 := lang.Apply(v3, []any{v7}) + var v14 any = v13 + _ = v14 + var v15 any + if lang.IsTruthy(v14) { + var v16 any + { // let + // let binding "and__0__auto__" + v17 := lang.Apply(v3, []any{v8}) + var v18 any = v17 + _ = v18 + var v19 any + if lang.IsTruthy(v18) { + var v20 any + { // let + // let binding "and__0__auto__" + v21 := lang.Apply(v4, []any{v7}) + var v22 any = v21 + _ = v22 + var v23 any + if lang.IsTruthy(v22) { + v24 := lang.Apply(v4, []any{v8}) + v23 = v24 + } else { + v23 = v22 + } + v20 = v23 + } // end let + v19 = v20 + } else { + v19 = v18 + } + v16 = v19 + } // end let + v15 = v16 + } else { + v15 = v14 + } + v12 = v15 + } // end let + v13 := lang.Apply(v11, []any{v12}) + return v13 + case 3: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("boolean")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + var v13 any + { // let + // let binding "and__0__auto__" + v14 := lang.Apply(v3, []any{v7}) + var v15 any = v14 + _ = v15 + var v16 any + if lang.IsTruthy(v15) { + var v17 any + { // let + // let binding "and__0__auto__" + v18 := lang.Apply(v3, []any{v8}) + var v19 any = v18 + _ = v19 + var v20 any + if lang.IsTruthy(v19) { + var v21 any + { // let + // let binding "and__0__auto__" + v22 := lang.Apply(v3, []any{v9}) + var v23 any = v22 + _ = v23 + var v24 any + if lang.IsTruthy(v23) { + var v25 any + { // let + // let binding "and__0__auto__" + v26 := lang.Apply(v4, []any{v7}) + var v27 any = v26 + _ = v27 + var v28 any + if lang.IsTruthy(v27) { + var v29 any + { // let + // let binding "and__0__auto__" + v30 := lang.Apply(v4, []any{v8}) + var v31 any = v30 + _ = v31 + var v32 any + if lang.IsTruthy(v31) { + v33 := lang.Apply(v4, []any{v9}) + v32 = v33 + } else { + v32 = v31 + } + v29 = v32 + } // end let + v28 = v29 + } else { + v28 = v27 + } + v25 = v28 + } // end let + v24 = v25 + } else { + v24 = v23 + } + v21 = v24 + } // end let + v20 = v21 + } else { + v20 = v19 + } + v17 = v20 + } // end let + v16 = v17 + } else { + v16 = v15 + } + v13 = v16 + } // end let + v14 := lang.Apply(v12, []any{v13}) + return v14 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + v10 := lang.NewList(args[3:]...) + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("boolean")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + var v14 any + { // let + // let binding "and__0__auto__" + v15 := lang.Apply(v6, []any{v7, v8, v9}) + var v16 any = v15 + _ = v16 + var v17 any + if lang.IsTruthy(v16) { + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("every?")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + var v21 lang.FnFunc + v21 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v22 := args[0] + _ = v22 + var v23 any + { // let + // let binding "and__0__auto__" + v24 := lang.Apply(v3, []any{v22}) + var v25 any = v24 + _ = v25 + var v26 any + if lang.IsTruthy(v25) { + v27 := lang.Apply(v4, []any{v22}) + v26 = v27 + } else { + v26 = v25 + } + v23 = v26 + } // end let + return v23 + }) + v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7443), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(7443), lang.NewKeyword("end-column"), int(65)) + v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v24 := lang.Apply(v20, []any{v23, v10}) + v17 = v24 + } else { + v17 = v16 + } + v14 = v17 + } // end let + v15 := lang.Apply(v13, []any{v14}) + return v15 + } + }) + v6 := v5 + _ = v6 + } + v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7437), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7443), lang.NewKeyword("end-column"), int(75)) + v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v7 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 lang.FnFunc + { // function ep3 + v6 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return true + case 1: + v8 := args[0] + _ = v8 + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("boolean")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + var v12 any + { // let + // let binding "and__0__auto__" + v13 := lang.Apply(v3, []any{v8}) + var v14 any = v13 + _ = v14 + var v15 any + if lang.IsTruthy(v14) { + var v16 any + { // let + // let binding "and__0__auto__" + v17 := lang.Apply(v4, []any{v8}) + var v18 any = v17 + _ = v18 + var v19 any + if lang.IsTruthy(v18) { + v20 := lang.Apply(v5, []any{v8}) + v19 = v20 + } else { + v19 = v18 + } + v16 = v19 + } // end let + v15 = v16 + } else { + v15 = v14 + } + v12 = v15 + } // end let + v13 := lang.Apply(v11, []any{v12}) + return v13 + case 2: + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("boolean")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + var v13 any + { // let + // let binding "and__0__auto__" + v14 := lang.Apply(v3, []any{v8}) + var v15 any = v14 + _ = v15 + var v16 any + if lang.IsTruthy(v15) { + var v17 any + { // let + // let binding "and__0__auto__" + v18 := lang.Apply(v3, []any{v9}) + var v19 any = v18 + _ = v19 + var v20 any + if lang.IsTruthy(v19) { + var v21 any + { // let + // let binding "and__0__auto__" + v22 := lang.Apply(v4, []any{v8}) + var v23 any = v22 + _ = v23 + var v24 any + if lang.IsTruthy(v23) { + var v25 any + { // let + // let binding "and__0__auto__" + v26 := lang.Apply(v4, []any{v9}) + var v27 any = v26 + _ = v27 + var v28 any + if lang.IsTruthy(v27) { + var v29 any + { // let + // let binding "and__0__auto__" + v30 := lang.Apply(v5, []any{v8}) + var v31 any = v30 + _ = v31 + var v32 any + if lang.IsTruthy(v31) { + v33 := lang.Apply(v5, []any{v9}) + v32 = v33 + } else { + v32 = v31 + } + v29 = v32 + } // end let + v28 = v29 + } else { + v28 = v27 + } + v25 = v28 + } // end let + v24 = v25 + } else { + v24 = v23 + } + v21 = v24 + } // end let + v20 = v21 + } else { + v20 = v19 + } + v17 = v20 + } // end let + v16 = v17 + } else { + v16 = v15 + } + v13 = v16 + } // end let + v14 := lang.Apply(v12, []any{v13}) + return v14 + case 3: + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + v10 := args[2] + _ = v10 + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("boolean")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + var v14 any + { // let + // let binding "and__0__auto__" + v15 := lang.Apply(v3, []any{v8}) + var v16 any = v15 + _ = v16 + var v17 any + if lang.IsTruthy(v16) { + var v18 any + { // let + // let binding "and__0__auto__" + v19 := lang.Apply(v3, []any{v9}) + var v20 any = v19 + _ = v20 + var v21 any + if lang.IsTruthy(v20) { + var v22 any + { // let + // let binding "and__0__auto__" + v23 := lang.Apply(v3, []any{v10}) + var v24 any = v23 + _ = v24 + var v25 any + if lang.IsTruthy(v24) { + var v26 any + { // let + // let binding "and__0__auto__" + v27 := lang.Apply(v4, []any{v8}) + var v28 any = v27 + _ = v28 + var v29 any + if lang.IsTruthy(v28) { + var v30 any + { // let + // let binding "and__0__auto__" + v31 := lang.Apply(v4, []any{v9}) + var v32 any = v31 + _ = v32 + var v33 any + if lang.IsTruthy(v32) { + var v34 any + { // let + // let binding "and__0__auto__" + v35 := lang.Apply(v4, []any{v10}) + var v36 any = v35 + _ = v36 + var v37 any + if lang.IsTruthy(v36) { + var v38 any + { // let + // let binding "and__0__auto__" + v39 := lang.Apply(v5, []any{v8}) + var v40 any = v39 + _ = v40 + var v41 any + if lang.IsTruthy(v40) { + var v42 any + { // let + // let binding "and__0__auto__" + v43 := lang.Apply(v5, []any{v9}) + var v44 any = v43 + _ = v44 + var v45 any + if lang.IsTruthy(v44) { + v46 := lang.Apply(v5, []any{v10}) + v45 = v46 + } else { + v45 = v44 + } + v42 = v45 + } // end let + v41 = v42 + } else { + v41 = v40 + } + v38 = v41 + } // end let + v37 = v38 + } else { + v37 = v36 + } + v34 = v37 + } // end let + v33 = v34 + } else { + v33 = v32 + } + v30 = v33 + } // end let + v29 = v30 + } else { + v29 = v28 + } + v26 = v29 + } // end let + v25 = v26 + } else { + v25 = v24 + } + v22 = v25 + } // end let + v21 = v22 + } else { + v21 = v20 + } + v18 = v21 + } // end let + v17 = v18 + } else { + v17 = v16 + } + v14 = v17 + } // end let + v15 := lang.Apply(v13, []any{v14}) + return v15 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + v10 := args[2] + _ = v10 + v11 := lang.NewList(args[3:]...) + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("boolean")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + var v15 any + { // let + // let binding "and__0__auto__" + v16 := lang.Apply(v7, []any{v8, v9, v10}) + var v17 any = v16 + _ = v17 + var v18 any + if lang.IsTruthy(v17) { + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("every?")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + var v22 lang.FnFunc + v22 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v23 := args[0] + _ = v23 + var v24 any + { // let + // let binding "and__0__auto__" + v25 := lang.Apply(v3, []any{v23}) + var v26 any = v25 + _ = v26 + var v27 any + if lang.IsTruthy(v26) { + var v28 any + { // let + // let binding "and__0__auto__" + v29 := lang.Apply(v4, []any{v23}) + var v30 any = v29 + _ = v30 + var v31 any + if lang.IsTruthy(v30) { + v32 := lang.Apply(v5, []any{v23}) + v31 = v32 + } else { + v31 = v30 + } + v28 = v31 + } // end let + v27 = v28 + } else { + v27 = v26 + } + v24 = v27 + } // end let + return v24 + }) + v23 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7451), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(7451), lang.NewKeyword("end-column"), int(72)) + v24, err := lang.WithMeta(v22, v23.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v25 := lang.Apply(v21, []any{v24, v11}) + v18 = v25 + } else { + v18 = v17 + } + v15 = v18 + } // end let + v16 := lang.Apply(v14, []any{v15}) + return v16 + } + }) + v7 := v6 + _ = v7 + } + v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7445), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7451), lang.NewKeyword("end-column"), int(82)) + v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v8 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + var v7 any + { // let + // let binding "ps" + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("list*")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v3, v4, v5, v6}) + var v12 any = v11 + _ = v12 + var v13 lang.FnFunc + { // function epn + v13 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return true + case 1: + v15 := args[0] + _ = v15 + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("every?")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + var v19 lang.FnFunc + v19 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v20 := args[0] + _ = v20 + v21 := lang.Apply(v20, []any{v15}) + return v21 + }) + v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7456), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(7456), lang.NewKeyword("end-column"), int(28)) + v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v22 := lang.Apply(v18, []any{v21, v12}) + return v22 + case 2: + v15 := args[0] + _ = v15 + v16 := args[1] + _ = v16 + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("every?")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + var v20 lang.FnFunc + v20 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v21 := args[0] + _ = v21 + var v22 any + { // let + // let binding "and__0__auto__" + v23 := lang.Apply(v21, []any{v15}) + var v24 any = v23 + _ = v24 + var v25 any + if lang.IsTruthy(v24) { + v26 := lang.Apply(v21, []any{v16}) + v25 = v26 + } else { + v25 = v24 + } + v22 = v25 + } // end let + return v22 + }) + v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7457), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7457), lang.NewKeyword("end-column"), int(42)) + v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v23 := lang.Apply(v19, []any{v22, v12}) + return v23 + case 3: + v15 := args[0] + _ = v15 + v16 := args[1] + _ = v16 + v17 := args[2] + _ = v17 + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("every?")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + var v21 lang.FnFunc + v21 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v22 := args[0] + _ = v22 + var v23 any + { // let + // let binding "and__0__auto__" + v24 := lang.Apply(v22, []any{v15}) + var v25 any = v24 + _ = v25 + var v26 any + if lang.IsTruthy(v25) { + var v27 any + { // let + // let binding "and__0__auto__" + v28 := lang.Apply(v22, []any{v16}) + var v29 any = v28 + _ = v29 + var v30 any + if lang.IsTruthy(v29) { + v31 := lang.Apply(v22, []any{v17}) + v30 = v31 + } else { + v30 = v29 + } + v27 = v30 + } // end let + v26 = v27 + } else { + v26 = v25 + } + v23 = v26 + } // end let + return v23 + }) + v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7458), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(7458), lang.NewKeyword("end-column"), int(50)) + v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v24 := lang.Apply(v20, []any{v23, v12}) + return v24 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v15 := args[0] + _ = v15 + v16 := args[1] + _ = v16 + v17 := args[2] + _ = v17 + v18 := lang.NewList(args[3:]...) + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("boolean")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + var v22 any + { // let + // let binding "and__0__auto__" + v23 := lang.Apply(v14, []any{v15, v16, v17}) + var v24 any = v23 + _ = v24 + var v25 any + if lang.IsTruthy(v24) { + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("every?")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + var v29 lang.FnFunc + v29 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v30 := args[0] + _ = v30 + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("every?")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{v30, v18}) + return v34 + }) + v30 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7460), lang.NewKeyword("column"), int(48), lang.NewKeyword("end-line"), int(7460), lang.NewKeyword("end-column"), int(63)) + v31, err := lang.WithMeta(v29, v30.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v32 := lang.Apply(v28, []any{v31, v12}) + v25 = v32 + } else { + v25 = v24 + } + v22 = v25 + } // end let + v23 := lang.Apply(v21, []any{v22}) + return v23 + } + }) + v14 := v13 + _ = v14 + } + v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7454), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7460), lang.NewKeyword("end-column"), int(71)) + v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v7 = v15 + } // end let + return v7 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // every? + { + v1 := reflect.TypeOf(false) + v0 := lang.NewSymbol("every?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if (pred x) is logical true for every x in coll, else\n false.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2664), lang.NewKeyword("end-line"), int(2664))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + recur_loop_480: + var v6 any + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("nil?")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("seq")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{v5}) + v14 := lang.Apply(v9, []any{v13}) + if lang.IsTruthy(v14) { + v6 = true + } else { + var v15 any + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("first")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{v5}) + v20 := lang.Apply(v4, []any{v19}) + if lang.IsTruthy(v20) { + var v21 any = v4 + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("next")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.Apply(v25, []any{v5}) + var v22 any = v26 + v4 = v21 + v5 = v22 + goto recur_loop_480 + } else { + var v27 any + if lang.IsTruthy(lang.NewKeyword("else")) { + v27 = false + } else { + v27 = nil + } + v15 = v27 + } + v6 = v15 + } + return v6 + }) + v4 := reflect.TypeOf(false) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // ex-cause + { + v0 := lang.NewSymbol("ex-cause").WithMeta(lang.NewMap(lang.NewKeyword("tag"), nil, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ex"))), lang.NewKeyword("doc"), "Returns the cause of ex if ex is a Throwable.\n Otherwise returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4828), lang.NewKeyword("end-line"), int(4828))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{lang.Throwable, v3}) + if lang.IsTruthy(v8) { + v9, ok := lang.FieldOrMethod(v3, "getCause") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getCause"))) + } + var v10 any + switch reflect.TypeOf(v9).Kind() { + case reflect.Func: + v10 = lang.Apply(v9, nil) + default: + v10 = v9 + } + v4 = v10 + } else { + v4 = nil + } + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // ex-data + { + v0 := lang.NewSymbol("ex-data").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ex"))), lang.NewKeyword("doc"), "Returns exception data (a map) if ex is an IExceptionInfo.\n Otherwise returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4812), lang.NewKeyword("end-line"), int(4812))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{nil, v3}) + if lang.IsTruthy(v8) { + v9, ok := lang.FieldOrMethod(v3, "getData") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getData"))) + } + var v10 any + switch reflect.TypeOf(v9).Kind() { + case reflect.Func: + v10 = lang.Apply(v9, nil) + default: + v10 = v9 + } + v4 = v10 + } else { + v4 = nil + } + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // ex-info + { + v0 := lang.NewSymbol("ex-info").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("msg"), lang.NewSymbol("map")), lang.NewVector(lang.NewSymbol("msg"), lang.NewSymbol("map"), lang.NewSymbol("cause"))), lang.NewKeyword("doc"), "Create an instance of ExceptionInfo, a RuntimeException subclass\n that carries a map of additional data.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4803), lang.NewKeyword("end-line"), int(4803))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("elide-top-frames")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(nil, []any{v3, v4}) + v9 := lang.Apply(v7, []any{v8, "glojure.core$ex_info"}) + return v9 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("elide-top-frames")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(nil, []any{v3, v4, v5}) + v10 := lang.Apply(v8, []any{v9, "glojure.core$ex_info"}) + return v10 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // ex-message + { + v0 := lang.NewSymbol("ex-message").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ex"))), lang.NewKeyword("doc"), "Returns the message attached to ex if ex is a Throwable.\n Otherwise returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4820), lang.NewKeyword("end-line"), int(4820))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{lang.Throwable, v3}) + if lang.IsTruthy(v8) { + v9, ok := lang.FieldOrMethod(v3, "getMessage") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getMessage"))) + } + var v10 any + switch reflect.TypeOf(v9).Kind() { + case reflect.Func: + v10 = lang.Apply(v9, nil) + default: + v10 = v9 + } + v4 = v10 + } else { + v4 = nil + } + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // extend + { + v0 := lang.NewSymbol("extend").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atype"), lang.NewSymbol("&"), lang.NewSymbol("proto+mmaps"))), lang.NewKeyword("doc"), "Implementations of protocol methods can be provided using the extend construct:\n\n (extend AType\n AProtocol\n {:foo an-existing-fn\n :bar (fn [a b] ...)\n :baz (fn ([a]...) ([a b] ...)...)}\n BProtocol \n {...} \n ...)\n \n extend takes a type/class (or interface, see below), and one or more\n protocol + method map pairs. It will extend the polymorphism of the\n protocol's methods to call the supplied methods when an AType is\n provided as the first argument. \n\n Method maps are maps of the keyword-ized method names to ordinary\n fns. This facilitates easy reuse of existing fns and fn maps, for\n code reuse/mixins without derivation or composition. You can extend\n an interface to a protocol. This is primarily to facilitate interop\n with the host (e.g. Java) but opens the door to incidental multiple\n inheritance of implementation since a class can inherit from more\n than one interface, both of which extend the protocol. It is TBD how\n to specify which impl to use. You can extend a protocol on nil.\n\n If you are supplying the definitions explicitly (i.e. not reusing\n exsting functions or mixin maps), you may find it more convenient to\n use the extend-type or extend-protocol macros.\n\n Note that multiple independent extend clauses can exist for the same\n type, not all protocols need be defined in a single extend call.\n\n See also:\n extends?, satisfies?, extenders", lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(116), lang.NewKeyword("end-line"), int(116))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.NewList(args[1:]...) + var v5 any + { // let + // let binding "seq_262" + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("seq")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("partition")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.Apply(v11, []any{int64(2), v4}) + v13 := lang.Apply(v8, []any{v12}) + var v14 any = v13 + _ = v14 + // let binding "chunk_263" + var v15 any = nil + _ = v15 + // let binding "count_264" + var v16 any = int64(0) + _ = v16 + // let binding "i_265" + var v17 any = int64(0) + _ = v17 + for { + var v18 any + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("<")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{v17, v16}) + if lang.IsTruthy(v22) { + var v23 any + { // let + // let binding "vec__266" + v24, _ := lang.FieldOrMethod(v15, "nth") + if reflect.TypeOf(v24).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + v25 := lang.Apply(v24, []any{v17}) + var v26 any = v25 + _ = v26 + // let binding "proto" + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("nth")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{v26, int64(0), nil}) + var v31 any = v30 + _ = v31 + // let binding "mmap" + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("nth")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{v26, int64(1), nil}) + var v36 any = v35 + _ = v36 + var v37 any + v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v39 := v38.FindInternedVar(lang.NewSymbol("protocol?")) + if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + } + v40 := v39.Get() + v41 := lang.Apply(v40, []any{v31}) + if lang.IsTruthy(v41) { + v37 = nil + } else { + v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v43 := v42.FindInternedVar(lang.NewSymbol("str")) + if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) + } + v44 := v43.Get() + v45 := lang.Apply(v44, []any{v31, " is not a protocol"}) + v46 := lang.Apply(errors5.New, []any{v45}) + panic(v46) + } + _ = v37 + v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v48 := v47.FindInternedVar(lang.NewSymbol("reduce1")) + if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) + } + v49 := v48.Get() + var v50 lang.FnFunc + v50 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v51 := args[0] + _ = v51 + v52 := args[1] + _ = v52 + var v53 any + { // let + // let binding "vec__270" + var v54 any = v52 + _ = v54 + // let binding "k" + v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v56 := v55.FindInternedVar(lang.NewSymbol("nth")) + if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) + } + v57 := v56.Get() + v58 := lang.Apply(v57, []any{v54, int64(0), nil}) + var v59 any = v58 + _ = v59 + // let binding "v" + v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v61 := v60.FindInternedVar(lang.NewSymbol("nth")) + if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) + } + v62 := v61.Get() + v63 := lang.Apply(v62, []any{v54, int64(1), nil}) + var v64 any = v63 + _ = v64 + v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v66 := v65.FindInternedVar(lang.NewSymbol("get-in")) + if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) + } + v67 := v66.Get() + v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v69 := v68.FindInternedVar(lang.NewSymbol("deref")) + if v69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) + } + v70 := v69.Get() + v71 := lang.Apply(v70, []any{v31}) + v72 := lang.NewVector(lang.NewKeyword("multis"), v59) + v73 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(158), lang.NewKeyword("column"), int(33), lang.NewKeyword("end-line"), int(158), lang.NewKeyword("end-column"), int(43)) + v74, err := lang.WithMeta(v72, v73.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v75 := lang.Apply(v67, []any{v71, v74}) + var v76 lang.FnFunc + v76 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v77 := args[0] + _ = v77 + v78 := lang.NewList(args[1:]...) + v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v80 := v79.FindInternedVar(lang.NewSymbol("apply")) + if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) + } + v81 := v80.Get() + v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v83 := v82.FindInternedVar(lang.NewSymbol("cons")) + if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) + } + v84 := v83.Get() + v85 := lang.Apply(v84, []any{v77, v78}) + v86 := lang.Apply(v81, []any{v64, v85}) + return v86 + } + }) + v77, _ := lang.FieldOrMethod(v75, "AddMethod") + if reflect.TypeOf(v77).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("AddMethod is not a function"))) + } + v78 := lang.Apply(v77, []any{v3, v76}) + v53 = v78 + } // end let + return v53 + }) + v51 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(156), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(160), lang.NewKeyword("end-column"), int(45)) + v52, err := lang.WithMeta(v50, v51.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v53 := lang.Apply(v49, []any{v52, nil, v36}) + _ = v53 + var v54 any = v14 + var v55 any = v15 + var v56 any = v16 + v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v59 := v58.FindInternedVar(lang.NewSymbol("unchecked-inc")) + if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) + } + v60 := v59.Get() + v61 := lang.Apply(v60, []any{v17}) + var v57 any = v61 + v14 = v54 + v15 = v55 + v16 = v56 + v17 = v57 + continue + } // end let + v18 = v23 + } else { + var v24 any + { // let + // let binding "temp__0__auto__" + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("seq")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.Apply(v27, []any{v14}) + var v29 any = v28 + _ = v29 + var v30 any + if lang.IsTruthy(v29) { + var v31 any + { // let + // let binding "seq_262" + var v32 any = v29 + _ = v32 + var v33 any + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("chunked-seq?")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.Apply(v36, []any{v32}) + if lang.IsTruthy(v37) { + var v38 any + { // let + // let binding "c__0__auto__" + v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v40 := v39.FindInternedVar(lang.NewSymbol("chunk-first")) + if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) + } + v41 := v40.Get() + v42 := lang.Apply(v41, []any{v32}) + var v43 any = v42 + _ = v43 + v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v46 := v45.FindInternedVar(lang.NewSymbol("chunk-rest")) + if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) + } + v47 := v46.Get() + v48 := lang.Apply(v47, []any{v32}) + var v44 any = v48 + var v49 any = v43 + v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v52 := v51.FindInternedVar(lang.NewSymbol("int")) + if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) + } + v53 := v52.Get() + v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v55 := v54.FindInternedVar(lang.NewSymbol("count")) + if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) + } + v56 := v55.Get() + v57 := lang.Apply(v56, []any{v43}) + v58 := lang.Apply(v53, []any{v57}) + var v50 any = v58 + v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v61 := v60.FindInternedVar(lang.NewSymbol("int")) + if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) + } + v62 := v61.Get() + v63 := lang.Apply(v62, []any{int64(0)}) + var v59 any = v63 + v14 = v44 + v15 = v49 + v16 = v50 + v17 = v59 + continue + } // end let + v33 = v38 + } else { + var v39 any + { // let + // let binding "vec__273" + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("first")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.Apply(v42, []any{v32}) + var v44 any = v43 + _ = v44 + // let binding "proto" + v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v46 := v45.FindInternedVar(lang.NewSymbol("nth")) + if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) + } + v47 := v46.Get() + v48 := lang.Apply(v47, []any{v44, int64(0), nil}) + var v49 any = v48 + _ = v49 + // let binding "mmap" + v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v51 := v50.FindInternedVar(lang.NewSymbol("nth")) + if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) + } + v52 := v51.Get() + v53 := lang.Apply(v52, []any{v44, int64(1), nil}) + var v54 any = v53 + _ = v54 + var v55 any + v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v57 := v56.FindInternedVar(lang.NewSymbol("protocol?")) + if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) + } + v58 := v57.Get() + v59 := lang.Apply(v58, []any{v49}) + if lang.IsTruthy(v59) { + v55 = nil + } else { + v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v61 := v60.FindInternedVar(lang.NewSymbol("str")) + if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) + } + v62 := v61.Get() + v63 := lang.Apply(v62, []any{v49, " is not a protocol"}) + v64 := lang.Apply(errors5.New, []any{v63}) + panic(v64) + } + _ = v55 + v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v66 := v65.FindInternedVar(lang.NewSymbol("reduce1")) + if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) + } + v67 := v66.Get() + var v68 lang.FnFunc + v68 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v69 := args[0] + _ = v69 + v70 := args[1] + _ = v70 + var v71 any + { // let + // let binding "vec__277" + var v72 any = v70 + _ = v72 + // let binding "k" + v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v74 := v73.FindInternedVar(lang.NewSymbol("nth")) + if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) + } + v75 := v74.Get() + v76 := lang.Apply(v75, []any{v72, int64(0), nil}) + var v77 any = v76 + _ = v77 + // let binding "v" + v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v79 := v78.FindInternedVar(lang.NewSymbol("nth")) + if v79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) + } + v80 := v79.Get() + v81 := lang.Apply(v80, []any{v72, int64(1), nil}) + var v82 any = v81 + _ = v82 + v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v84 := v83.FindInternedVar(lang.NewSymbol("get-in")) + if v84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) + } + v85 := v84.Get() + v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v87 := v86.FindInternedVar(lang.NewSymbol("deref")) + if v87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) + } + v88 := v87.Get() + v89 := lang.Apply(v88, []any{v49}) + v90 := lang.NewVector(lang.NewKeyword("multis"), v77) + v91 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(158), lang.NewKeyword("column"), int(33), lang.NewKeyword("end-line"), int(158), lang.NewKeyword("end-column"), int(43)) + v92, err := lang.WithMeta(v90, v91.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v93 := lang.Apply(v85, []any{v89, v92}) + var v94 lang.FnFunc + v94 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v95 := args[0] + _ = v95 + v96 := lang.NewList(args[1:]...) + v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v98 := v97.FindInternedVar(lang.NewSymbol("apply")) + if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) + } + v99 := v98.Get() + v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v101 := v100.FindInternedVar(lang.NewSymbol("cons")) + if v101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) + } + v102 := v101.Get() + v103 := lang.Apply(v102, []any{v95, v96}) + v104 := lang.Apply(v99, []any{v82, v103}) + return v104 + } + }) + v95, _ := lang.FieldOrMethod(v93, "AddMethod") + if reflect.TypeOf(v95).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("AddMethod is not a function"))) + } + v96 := lang.Apply(v95, []any{v3, v94}) + v71 = v96 + } // end let + return v71 + }) + v69 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(156), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(160), lang.NewKeyword("end-column"), int(45)) + v70, err := lang.WithMeta(v68, v69.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v71 := lang.Apply(v67, []any{v70, nil, v54}) + _ = v71 + v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v74 := v73.FindInternedVar(lang.NewSymbol("next")) + if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) + } + v75 := v74.Get() + v76 := lang.Apply(v75, []any{v32}) + var v72 any = v76 + var v77 any = nil + var v78 any = int64(0) + var v79 any = int64(0) + v14 = v72 + v15 = v77 + v16 = v78 + v17 = v79 + continue + } // end let + v33 = v39 + } + v31 = v33 + } // end let + v30 = v31 + } else { + v30 = nil + } + v24 = v30 + } // end let + v18 = v24 + } + v5 = v18 + break + } + } // end let + return v5 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // extend-protocol + { + v0 := lang.NewSymbol("extend-protocol").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("p"), lang.NewSymbol("&"), lang.NewSymbol("specs"))), lang.NewKeyword("doc"), "Useful when you want to provide several implementations of the same\n protocol all at once. Takes a single protocol and the implementation\n of that protocol for one or more types.\n\n (extend-protocol Protocol\n AType\n (foo [x] ...)\n (bar [x y] ...)\n BType\n (foo [x] ...)\n (bar [x y] ...)\n AClass\n (foo [x] ...)\n (bar [x y] ...)\n nil\n (foo [x] ...)\n (bar [x y] ...))\n\n expands into:\n\n (do\n (clojure.core/extend-type AType Protocol \n (foo [x] ...) \n (bar [x y] ...))\n (clojure.core/extend-type BType Protocol \n (foo [x] ...) \n (bar [x y] ...))\n (clojure.core/extend-type AClass Protocol \n (foo [x] ...) \n (bar [x y] ...))\n (clojure.core/extend-type nil Protocol \n (foo [x] ...) \n (bar [x y] ...)))", lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(212), lang.NewKeyword("end-line"), int(212))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("emit-extend-protocol")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, []any{v5, v6}) + return v10 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // extend-type + { + v0 := lang.NewSymbol("extend-type").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("t"), lang.NewSymbol("&"), lang.NewSymbol("specs"))), lang.NewKeyword("doc"), "A macro that expands into an extend call. Useful when you are\n supplying the definitions explicitly inline, extend-type\n automatically creates the maps required by extend. Propagates the\n class as a type hint on the first argument of all fns.\n\n (extend-type MyType \n Countable\n (cnt [c] ...)\n Foo\n (bar [x y] ...)\n (baz ([x] ...) ([x y & zs] ...)))\n\n expands into:\n\n (extend MyType\n Countable\n {:cnt (fn [c] ...)}\n Foo\n {:baz (fn ([x] ...) ([x y & zs] ...))\n :bar (fn [x y] ...)})", lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(180), lang.NewKeyword("end-line"), int(180))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("emit-extend-type")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, []any{v5, v6}) + return v10 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // false? + { + v1 := reflect.TypeOf(false) + v0 := lang.NewSymbol("false?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is the value false, false otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(504), lang.NewKeyword("end-line"), int(504))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := lang.Apply(lang.Identical, []any{v4, false}) + return v5 + }) + v4 := reflect.TypeOf(false) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // ffirst + { + v0 := lang.NewSymbol("ffirst").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Same as (first (first x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(98), lang.NewKeyword("end-line"), int(102))).(*lang.Symbol) + var v2 lang.FnFunc + { // function ffirst + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("first")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("first")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v4}) + v12 := lang.Apply(v7, []any{v11}) + return v12 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(102), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(102), lang.NewKeyword("end-column"), int(50))).(lang.FnFunc) + v3 := v2 + _ = v3 + } + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // file-seq + { + v0 := lang.NewSymbol("file-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("dir"))), lang.NewKeyword("doc"), "A tree seq on java.io.Files", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4972), lang.NewKeyword("end-line"), int(4972))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("tree-seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + var v7 lang.FnFunc + v7 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v8 := args[0] + _ = v8 + v9, _ := lang.FieldOrMethod(v8, "isDirectory") + if reflect.TypeOf(v9).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("isDirectory is not a function"))) + } + v10 := lang.Apply(v9, []any{}) + return v10 + }) + v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4978), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(4978), lang.NewKeyword("end-column"), int(47)) + v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v10 lang.FnFunc + v10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v11 := args[0] + _ = v11 + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("seq")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15, _ := lang.FieldOrMethod(v11, "listFiles") + if reflect.TypeOf(v15).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("listFiles is not a function"))) + } + v16 := lang.Apply(v15, []any{}) + v17 := lang.Apply(v14, []any{v16}) + return v17 + }) + v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4979), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(4979), lang.NewKeyword("end-column"), int(51)) + v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v13 := lang.Apply(v6, []any{v9, v12, v3}) + return v13 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // filter + { + v0 := lang.NewSymbol("filter").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred")), lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the items in coll for which\n (pred item) returns logical true. pred must be free of side-effects.\n Returns a transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2785), lang.NewKeyword("end-line"), int(2785))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + var v4 lang.FnFunc + v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + var v6 lang.FnFunc + v6 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + v7 := lang.Apply(v5, nil) + return v7 + case 1: + v7 := args[0] + _ = v7 + v8 := lang.Apply(v5, []any{v7}) + return v8 + case 2: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + var v9 any + v10 := lang.Apply(v3, []any{v8}) + if lang.IsTruthy(v10) { + v11 := lang.Apply(v5, []any{v7, v8}) + v9 = v11 + } else { + v9 = v7 + } + return v9 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2793), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(2799), lang.NewKeyword("end-column"), int(22)) + v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v8 + }) + v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2792), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2799), lang.NewKeyword("end-column"), int(23)) + v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v6 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 lang.FnFunc + v5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v6 any + { // let + // let binding "temp__0__auto__" + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("seq")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, []any{v4}) + var v11 any = v10 + _ = v11 + var v12 any + if lang.IsTruthy(v11) { + var v13 any + { // let + // let binding "s" + var v14 any = v11 + _ = v14 + var v15 any + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("chunked-seq?")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{v14}) + if lang.IsTruthy(v19) { + var v20 any + { // let + // let binding "c" + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("chunk-first")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.Apply(v23, []any{v14}) + var v25 any = v24 + _ = v25 + // let binding "size" + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("count")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.Apply(v28, []any{v25}) + var v30 any = v29 + _ = v30 + // let binding "b" + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("chunk-buffer")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{v30}) + var v35 any = v34 + _ = v35 + var v36 any + { // let + // let binding "n__0__auto__" + v37 := lang.Apply(lang.LongCast, []any{v30}) + var v38 any = v37 + _ = v38 + var v39 any + { // let + // let binding "i" + var v40 any = int64(0) + _ = v40 + for { + var v41 any + v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v43 := v42.FindInternedVar(lang.NewSymbol("<")) + if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) + } + v44 := v43.Get() + v45 := lang.Apply(v44, []any{v40, v38}) + if lang.IsTruthy(v45) { + var v46 any + { // let + // let binding "v" + v47, _ := lang.FieldOrMethod(v25, "nth") + if reflect.TypeOf(v47).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + v48 := lang.Apply(v47, []any{v40}) + var v49 any = v48 + _ = v49 + var v50 any + v51 := lang.Apply(v3, []any{v49}) + if lang.IsTruthy(v51) { + v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v53 := v52.FindInternedVar(lang.NewSymbol("chunk-append")) + if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) + } + v54 := v53.Get() + v55 := lang.Apply(v54, []any{v35, v49}) + v50 = v55 + } else { + v50 = nil + } + v46 = v50 + } // end let + _ = v46 + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("unchecked-inc")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v40}) + var v47 any = v51 + v40 = v47 + continue + } else { + v41 = nil + } + v39 = v41 + break + } + } // end let + v36 = v39 + } // end let + _ = v36 + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("chunk-cons")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("chunk")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.Apply(v42, []any{v35}) + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("filter")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v48 := v47.FindInternedVar(lang.NewSymbol("chunk-rest")) + if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) + } + v49 := v48.Get() + v50 := lang.Apply(v49, []any{v14}) + v51 := lang.Apply(v46, []any{v3, v50}) + v52 := lang.Apply(v39, []any{v43, v51}) + v20 = v52 + } // end let + v15 = v20 + } else { + var v21 any + { // let + // let binding "f" + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("first")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v14}) + var v26 any = v25 + _ = v26 + // let binding "r" + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("rest")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{v14}) + var v31 any = v30 + _ = v31 + var v32 any + v33 := lang.Apply(v3, []any{v26}) + if lang.IsTruthy(v33) { + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("cons")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("filter")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.Apply(v39, []any{v3, v31}) + v41 := lang.Apply(v36, []any{v26, v40}) + v32 = v41 + } else { + v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v43 := v42.FindInternedVar(lang.NewSymbol("filter")) + if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) + } + v44 := v43.Get() + v45 := lang.Apply(v44, []any{v3, v31}) + v32 = v45 + } + v21 = v32 + } // end let + v15 = v21 + } + v13 = v15 + } // end let + v12 = v13 + } else { + v12 = nil + } + v6 = v12 + } // end let + return v6 + }) + v6 := lang.Apply(lang.NewLazySeq, []any{v5}) + return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // filter-key + { + v0 := lang.NewSymbol("filter-key").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("keyfn"), lang.NewSymbol("pred"), lang.NewSymbol("amap"))), lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4115), lang.NewKeyword("end-line"), int(4117), lang.NewKeyword("private"), true)).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any + { // let + // let binding "ret" + v7 := lang.NewMap() + v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4118), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(4118), lang.NewKeyword("end-column"), int(17)) + v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v10 any = v9 + _ = v10 + // let binding "es" + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("seq")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{v5}) + var v15 any = v14 + _ = v15 + for { + var v16 any + if lang.IsTruthy(v15) { + var v17 any + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("first")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.Apply(v20, []any{v15}) + v22 := lang.Apply(v3, []any{v21}) + v23 := lang.Apply(v4, []any{v22}) + if lang.IsTruthy(v23) { + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("assoc")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("key")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("first")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{v15}) + v35 := lang.Apply(v30, []any{v34}) + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("val")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v40 := v39.FindInternedVar(lang.NewSymbol("first")) + if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) + } + v41 := v40.Get() + v42 := lang.Apply(v41, []any{v15}) + v43 := lang.Apply(v38, []any{v42}) + v44 := lang.Apply(v27, []any{v10, v35, v43}) + var v24 any = v44 + v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v47 := v46.FindInternedVar(lang.NewSymbol("next")) + if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) + } + v48 := v47.Get() + v49 := lang.Apply(v48, []any{v15}) + var v45 any = v49 + v10 = v24 + v15 = v45 + continue + } else { + var v50 any = v10 + v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v53 := v52.FindInternedVar(lang.NewSymbol("next")) + if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) + } + v54 := v53.Get() + v55 := lang.Apply(v54, []any{v15}) + var v51 any = v55 + v10 = v50 + v15 = v51 + continue + } + v16 = v17 + } else { + v16 = v10 + } + v6 = v16 + break + } + } // end let + return v6 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // filterv + { + v0 := lang.NewSymbol("filterv").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a vector of the items in coll for which\n (pred item) returns logical true. pred must be free of side-effects.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6961), lang.NewKeyword("end-line"), int(6961))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("persistent!")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("reduce")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + var v11 lang.FnFunc + v11 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v12 := args[0] + _ = v12 + v13 := args[1] + _ = v13 + var v14 any + v15 := lang.Apply(v3, []any{v13}) + if lang.IsTruthy(v15) { + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("conj!")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{v12, v13}) + v14 = v19 + } else { + v14 = v12 + } + return v14 + }) + v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6967), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(6967), lang.NewKeyword("end-column"), int(52)) + v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("transient")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.NewVector() + v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6968), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(6968), lang.NewKeyword("end-column"), int(27)) + v19, err := lang.WithMeta(v17, v18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v20 := lang.Apply(v16, []any{v19}) + v21 := lang.Apply(v10, []any{v13, v20, v4}) + v22 := lang.Apply(v7, []any{v21}) + return v22 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // find + { + v0 := lang.NewSymbol("find").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"))), lang.NewKeyword("doc"), "Returns the map entry for key, or nil if key not present.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1530), lang.NewKeyword("end-line"), int(1530))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5, _ := lang.FieldOrMethod(runtime4.RT, "Find") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Find is not a function"))) + } + v6 := lang.Apply(v5, []any{v3, v4}) + return v6 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // find-keyword + { + v1 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() + v0 := lang.NewSymbol("find-keyword").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name"))), lang.NewKeyword("doc"), "Returns a Keyword with the given namespace and name if one already\n exists. This function will not intern a new keyword. If the keyword\n has not already been interned, it will return nil. Do not use :\n in the keyword strings, it will be added automatically.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(618), lang.NewKeyword("end-line"), int(618))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + var v5 any + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("keyword?")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{v4}) + if lang.IsTruthy(v9) { + v5 = v4 + } else { + var v10 any + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("symbol?")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{v4}) + if lang.IsTruthy(v14) { + v15 := lang.Apply(nil, []any{v4}) + v10 = v15 + } else { + var v16 any + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("string?")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.Apply(v19, []any{v4}) + if lang.IsTruthy(v20) { + v21 := lang.Apply(nil, []any{v4}) + v16 = v21 + } else { + v16 = nil + } + v10 = v16 + } + v5 = v10 + } + return v5 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := lang.Apply(nil, []any{v4, v5}) + return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v4 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // find-ns + { + v0 := lang.NewSymbol("find-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Returns the namespace named by the symbol or nil if it doesn't exist.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4125), lang.NewKeyword("end-line"), int(4125))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.Apply(lang.FindNamespace, []any{v3}) + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // find-var + { + v0 := lang.NewSymbol("find-var").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Returns the global var named by the namespace-qualified symbol, or\n nil if no var with that name.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2013), lang.NewKeyword("end-line"), int(2013))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4, _ := lang.FieldOrMethod(runtime4.RT, "FindVar") + if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("FindVar is not a function"))) + } + v5 := lang.Apply(v4, []any{v3}) + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // first + { + v0 := lang.NewSymbol("first").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns the first item in the collection. Calls seq on its\n argument. If coll is nil, returns nil.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(47), lang.NewKeyword("end-line"), int(52))).(*lang.Symbol) + var v2 lang.FnFunc + { // function first + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := lang.Apply(lang.First, []any{v4}) + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(52), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(52), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + v3 := v2 + _ = v3 + } + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // fits-table? + { + v0 := lang.NewSymbol("fits-table?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ints"))), lang.NewKeyword("doc"), "Returns true if the collection of ints can fit within the\n max-table-switch-size, false otherwise.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6625), lang.NewKeyword("end-line"), int(6625), lang.NewKeyword("private"), true)).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("<")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("-")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("apply")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("max")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("seq")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{v3}) + v20 := lang.Apply(v12, []any{v15, v19}) + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("apply")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("min")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("seq")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{v3}) + v31 := lang.Apply(v23, []any{v26, v30}) + v32 := lang.Apply(v9, []any{v20, v31}) + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("max-switch-table-size")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.Apply(v6, []any{v32, v35}) + return v36 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // flatten + { + v0 := lang.NewSymbol("flatten").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Takes any nested combination of sequential things (lists, vectors,\n etc.) and returns their contents as a single, flat lazy sequence.\n (flatten nil) returns an empty sequence.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7118), lang.NewKeyword("end-line"), int(7118))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("filter")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("complement")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("sequential?")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v9, []any{v12}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("rest")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("tree-seq")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("sequential?")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("seq")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.Apply(v19, []any{v22, v25, v3}) + v27 := lang.Apply(v16, []any{v26}) + v28 := lang.Apply(v6, []any{v13, v27}) + return v28 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // float + { + var v1 lang.FnFunc + { // function float__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("concat")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("list")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("seq")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("concat")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + var v30 any + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + if lang.IsTruthy(v33) { + v30 = lang.NewSymbol("uncheckedFloatCast") + } else { + v30 = lang.NewSymbol("floatCast") + } + v34 := lang.Apply(v29, []any{v30}) + v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v36 := v35.FindInternedVar(lang.NewSymbol("list")) + if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + } + v37 := v36.Get() + v38 := lang.Apply(v37, []any{v3}) + v39 := lang.Apply(v26, []any{v34, v38}) + v40 := lang.Apply(v23, []any{v39}) + v41 := lang.Apply(v20, []any{v40}) + v42 := lang.Apply(v9, []any{v13, v17, v41}) + v43 := lang.Apply(v6, []any{v42}) + return v43 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("float").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to float", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3487), lang.NewKeyword("end-line"), int(3487))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := lang.Apply(lang.FloatCast, []any{v4}) + return v5 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // float-array + { + var v1 lang.FnFunc + { // function float-array__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := lang.NewList(args[0:]...) + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("concat")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("list")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/FloatArray")}) + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("list")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("seq")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("concat")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) + v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v36 := v35.FindInternedVar(lang.NewSymbol("list")) + if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + } + v37 := v36.Get() + v38 := lang.Apply(v37, []any{lang.NewSymbol("glojure.core/args")}) + v39 := lang.Apply(v30, []any{v34, v38}) + v40 := lang.Apply(v27, []any{v39}) + v41 := lang.Apply(v24, []any{v40}) + v42 := lang.Apply(v9, []any{v13, v17, v21, v41}) + v43 := lang.Apply(v6, []any{v42}) + return v43 + } + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("float-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Creates an array of floats", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1), int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5301), lang.NewKeyword("end-line"), int(5301))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + v5, _ := lang.FieldOrMethod(lang.Numbers, "FloatArray") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("FloatArray is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6, _ := lang.FieldOrMethod(lang.Numbers, "FloatArrayInit") + if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("FloatArrayInit is not a function"))) + } + v7 := lang.Apply(v6, []any{v4, v5}) + return v7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // float? + { + v0 := lang.NewSymbol("float?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is a floating point number", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3605), lang.NewKeyword("end-line"), int(3605))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + { // let + // let binding "or__0__auto__" + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{lang.Builtins["float64"], v3}) + var v9 any = v8 + _ = v9 + var v10 any + if lang.IsTruthy(v9) { + v10 = v9 + } else { + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("instance?")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{lang.Builtins["float32"], v3}) + v10 = v14 + } + v4 = v10 + } // end let + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // floats + { + var v1 lang.FnFunc + { // function floats + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("concat")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("list")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/Floats")}) + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("list")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v3}) + v26 := lang.Apply(v9, []any{v13, v17, v21, v25}) + v27 := lang.Apply(v6, []any{v26}) + return v27 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("floats").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Casts to float[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5392), lang.NewKeyword("end-line"), int(5392))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5, _ := lang.FieldOrMethod(lang.Numbers, "Floats") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Floats is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // flush + { + v0 := lang.NewSymbol("flush").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Flushes the output stream that is the current value of\n *out*", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3706), lang.NewKeyword("end-line"), int(3706))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v4 := v3.FindInternedVar(lang.NewSymbol("*out*")) + if v4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) + } + v5 := v4.Get() + v6, _ := lang.FieldOrMethod(v5, "Sync") + if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Sync is not a function"))) + } + v7 := lang.Apply(v6, []any{}) + _ = v7 + return nil + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // fn + { + v0 := lang.NewSymbol("fn").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("sigs"))), lang.NewKeyword("doc"), "params => positional-params*, or positional-params* & rest-param\n positional-param => binding-form\n rest-param => binding-form\n binding-form => name, or destructuring-form\n\n Defines a function.\n\n See https://glojure.org/reference/special_forms#fn for more information", lang.NewKeyword("forms"), lang.NewVector(lang.NewList(lang.NewSymbol("fn"), lang.NewSymbol("name?"), lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("exprs*")), lang.NewList(lang.NewSymbol("fn"), lang.NewSymbol("name?"), lang.NewList(lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("exprs*")), lang.NewSymbol("+"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4533), lang.NewKeyword("end-line"), int(4533), lang.NewKeyword("special-form"), true)).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.NewList(args[2:]...) + var v6 any + { // let + // let binding "name" + var v7 any + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("symbol?")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("first")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{v5}) + v15 := lang.Apply(v10, []any{v14}) + if lang.IsTruthy(v15) { + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("first")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{v5}) + v7 = v19 + } else { + v7 = nil + } + var v20 any = v7 + _ = v20 + // let binding "sigs" + var v21 any + if lang.IsTruthy(v20) { + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("next")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v5}) + v21 = v25 + } else { + v21 = v5 + } + var v26 any = v21 + _ = v26 + // let binding "sigs" + var v27 any + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("vector?")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("first")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{v26}) + v35 := lang.Apply(v30, []any{v34}) + if lang.IsTruthy(v35) { + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("list")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v38, []any{v26}) + v27 = v39 + } else { + var v40 any + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("seq?")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("first")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.Apply(v46, []any{v26}) + v48 := lang.Apply(v43, []any{v47}) + if lang.IsTruthy(v48) { + v40 = v26 + } else { + var v49 any + v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v51 := v50.FindInternedVar(lang.NewSymbol("seq")) + if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) + } + v52 := v51.Get() + v53 := lang.Apply(v52, []any{v26}) + if lang.IsTruthy(v53) { + v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v55 := v54.FindInternedVar(lang.NewSymbol("str")) + if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) + } + v56 := v55.Get() + v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v58 := v57.FindInternedVar(lang.NewSymbol("first")) + if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) + } + v59 := v58.Get() + v60 := lang.Apply(v59, []any{v26}) + v61 := lang.Apply(v56, []any{"Parameter declaration ", v60, " should be a vector"}) + v49 = v61 + } else { + v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v63 := v62.FindInternedVar(lang.NewSymbol("str")) + if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) + } + v64 := v63.Get() + v65 := lang.Apply(v64, []any{"Parameter declaration missing"}) + v49 = v65 + } + v66 := lang.Apply(lang.NewIllegalArgumentError, []any{v49}) + panic(v66) + } + v27 = v40 + } + var v67 any = v27 + _ = v67 + // let binding "psig" + var v68 lang.FnFunc + v68 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v69 := args[0] + _ = v69 + var v70 any + v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v72 := v71.FindInternedVar(lang.NewSymbol("not")) + if v72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) + } + v73 := v72.Get() + v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v75 := v74.FindInternedVar(lang.NewSymbol("seq?")) + if v75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) + } + v76 := v75.Get() + v77 := lang.Apply(v76, []any{v69}) + v78 := lang.Apply(v73, []any{v77}) + if lang.IsTruthy(v78) { + v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v80 := v79.FindInternedVar(lang.NewSymbol("str")) + if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) + } + v81 := v80.Get() + v82 := lang.Apply(v81, []any{"Invalid signature ", v69, " should be a list"}) + v83 := lang.Apply(lang.NewIllegalArgumentError, []any{v82}) + panic(v83) + } else { + v70 = nil + } + _ = v70 + var v84 any + { // let + // let binding "vec__13" + var v85 any = v69 + _ = v85 + // let binding "seq__14" + v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v87 := v86.FindInternedVar(lang.NewSymbol("seq")) + if v87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) + } + v88 := v87.Get() + v89 := lang.Apply(v88, []any{v85}) + var v90 any = v89 + _ = v90 + // let binding "first__15" + v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v92 := v91.FindInternedVar(lang.NewSymbol("first")) + if v92.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) + } + v93 := v92.Get() + v94 := lang.Apply(v93, []any{v90}) + var v95 any = v94 + _ = v95 + // let binding "seq__14" + v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v97 := v96.FindInternedVar(lang.NewSymbol("next")) + if v97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) + } + v98 := v97.Get() + v99 := lang.Apply(v98, []any{v90}) + var v100 any = v99 + _ = v100 + // let binding "params" + var v101 any = v95 + _ = v101 + // let binding "body" + var v102 any = v100 + _ = v102 + // let binding "_" + var v103 any + v104 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v105 := v104.FindInternedVar(lang.NewSymbol("not")) + if v105.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v105))) + } + v106 := v105.Get() + v107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v108 := v107.FindInternedVar(lang.NewSymbol("vector?")) + if v108.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v108))) + } + v109 := v108.Get() + v110 := lang.Apply(v109, []any{v101}) + v111 := lang.Apply(v106, []any{v110}) + if lang.IsTruthy(v111) { + var v112 any + v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v114 := v113.FindInternedVar(lang.NewSymbol("seq?")) + if v114.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) + } + v115 := v114.Get() + v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v117 := v116.FindInternedVar(lang.NewSymbol("first")) + if v117.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) + } + v118 := v117.Get() + v119 := lang.Apply(v118, []any{v67}) + v120 := lang.Apply(v115, []any{v119}) + if lang.IsTruthy(v120) { + v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v122 := v121.FindInternedVar(lang.NewSymbol("str")) + if v122.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) + } + v123 := v122.Get() + v124 := lang.Apply(v123, []any{"Parameter declaration ", v101, " should be a vector"}) + v112 = v124 + } else { + v125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v126 := v125.FindInternedVar(lang.NewSymbol("str")) + if v126.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v126))) + } + v127 := v126.Get() + v128 := lang.Apply(v127, []any{"Invalid signature ", v69, " should be a list"}) + v112 = v128 + } + v129 := lang.Apply(lang.NewIllegalArgumentError, []any{v112}) + panic(v129) + } else { + v103 = nil + } + var v130 any = v103 + _ = v130 + // let binding "conds" + var v131 any + var v132 any + { // let + // let binding "and__0__auto__" + v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v134 := v133.FindInternedVar(lang.NewSymbol("next")) + if v134.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) + } + v135 := v134.Get() + v136 := lang.Apply(v135, []any{v102}) + var v137 any = v136 + _ = v137 + var v138 any + if lang.IsTruthy(v137) { + v139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v140 := v139.FindInternedVar(lang.NewSymbol("map?")) + if v140.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v140))) + } + v141 := v140.Get() + v142 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v143 := v142.FindInternedVar(lang.NewSymbol("first")) + if v143.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v143))) + } + v144 := v143.Get() + v145 := lang.Apply(v144, []any{v102}) + v146 := lang.Apply(v141, []any{v145}) + v138 = v146 + } else { + v138 = v137 + } + v132 = v138 + } // end let + if lang.IsTruthy(v132) { + v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v134 := v133.FindInternedVar(lang.NewSymbol("first")) + if v134.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) + } + v135 := v134.Get() + v136 := lang.Apply(v135, []any{v102}) + v131 = v136 + } else { + v131 = nil + } + var v137 any = v131 + _ = v137 + // let binding "body" + var v138 any + if lang.IsTruthy(v137) { + v139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v140 := v139.FindInternedVar(lang.NewSymbol("next")) + if v140.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v140))) + } + v141 := v140.Get() + v142 := lang.Apply(v141, []any{v102}) + v138 = v142 + } else { + v138 = v102 + } + var v143 any = v138 + _ = v143 + // let binding "conds" + var v144 any + { // let + // let binding "or__0__auto__" + var v145 any = v137 + _ = v145 + var v146 any + if lang.IsTruthy(v145) { + v146 = v145 + } else { + v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v148 := v147.FindInternedVar(lang.NewSymbol("meta")) + if v148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) + } + v149 := v148.Get() + v150 := lang.Apply(v149, []any{v101}) + v146 = v150 + } + v144 = v146 + } // end let + var v145 any = v144 + _ = v145 + // let binding "pre" + v146 := lang.Apply(lang.NewKeyword("pre"), []any{v145}) + var v147 any = v146 + _ = v147 + // let binding "post" + v148 := lang.Apply(lang.NewKeyword("post"), []any{v145}) + var v149 any = v148 + _ = v149 + // let binding "body" + var v150 any + if lang.IsTruthy(v149) { + v151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v152 := v151.FindInternedVar(lang.NewSymbol("seq")) + if v152.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v152))) + } + v153 := v152.Get() + v154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v155 := v154.FindInternedVar(lang.NewSymbol("concat")) + if v155.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v155))) + } + v156 := v155.Get() + v157 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v158 := v157.FindInternedVar(lang.NewSymbol("list")) + if v158.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v158))) + } + v159 := v158.Get() + v160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v161 := v160.FindInternedVar(lang.NewSymbol("seq")) + if v161.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v161))) + } + v162 := v161.Get() + v163 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v164 := v163.FindInternedVar(lang.NewSymbol("concat")) + if v164.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v164))) + } + v165 := v164.Get() + v166 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v167 := v166.FindInternedVar(lang.NewSymbol("list")) + if v167.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v167))) + } + v168 := v167.Get() + v169 := lang.Apply(v168, []any{lang.NewSymbol("glojure.core/let")}) + v170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v171 := v170.FindInternedVar(lang.NewSymbol("list")) + if v171.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v171))) + } + v172 := v171.Get() + v173 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v174 := v173.FindInternedVar(lang.NewSymbol("apply")) + if v174.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v174))) + } + v175 := v174.Get() + v176 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v177 := v176.FindInternedVar(lang.NewSymbol("vector")) + if v177.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v177))) + } + v178 := v177.Get() + v179 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v180 := v179.FindInternedVar(lang.NewSymbol("seq")) + if v180.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v180))) + } + v181 := v180.Get() + v182 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v183 := v182.FindInternedVar(lang.NewSymbol("concat")) + if v183.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v183))) + } + v184 := v183.Get() + v185 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v186 := v185.FindInternedVar(lang.NewSymbol("list")) + if v186.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v186))) + } + v187 := v186.Get() + v188 := lang.Apply(v187, []any{lang.NewSymbol("%")}) + v189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v190 := v189.FindInternedVar(lang.NewSymbol("list")) + if v190.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v190))) + } + v191 := v190.Get() + var v192 any + v193 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v194 := v193.FindInternedVar(lang.NewSymbol("<")) + if v194.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v194))) + } + v195 := v194.Get() + v196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v197 := v196.FindInternedVar(lang.NewSymbol("count")) + if v197.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v197))) + } + v198 := v197.Get() + v199 := lang.Apply(v198, []any{v143}) + v200 := lang.Apply(v195, []any{int64(1), v199}) + if lang.IsTruthy(v200) { + v201 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v202 := v201.FindInternedVar(lang.NewSymbol("seq")) + if v202.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v202))) + } + v203 := v202.Get() + v204 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v205 := v204.FindInternedVar(lang.NewSymbol("concat")) + if v205.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v205))) + } + v206 := v205.Get() + v207 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v208 := v207.FindInternedVar(lang.NewSymbol("list")) + if v208.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v208))) + } + v209 := v208.Get() + v210 := lang.Apply(v209, []any{lang.NewSymbol("do")}) + v211 := lang.Apply(v206, []any{v210, v143}) + v212 := lang.Apply(v203, []any{v211}) + v192 = v212 + } else { + v213 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v214 := v213.FindInternedVar(lang.NewSymbol("first")) + if v214.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v214))) + } + v215 := v214.Get() + v216 := lang.Apply(v215, []any{v143}) + v192 = v216 + } + v217 := lang.Apply(v191, []any{v192}) + v218 := lang.Apply(v184, []any{v188, v217}) + v219 := lang.Apply(v181, []any{v218}) + v220 := lang.Apply(v175, []any{v178, v219}) + v221 := lang.Apply(v172, []any{v220}) + v222 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v223 := v222.FindInternedVar(lang.NewSymbol("map")) + if v223.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v223))) + } + v224 := v223.Get() + var v225 lang.FnFunc + v225 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v226 := args[0] + _ = v226 + v227 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v228 := v227.FindInternedVar(lang.NewSymbol("seq")) + if v228.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v228))) + } + v229 := v228.Get() + v230 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v231 := v230.FindInternedVar(lang.NewSymbol("concat")) + if v231.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v231))) + } + v232 := v231.Get() + v233 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v234 := v233.FindInternedVar(lang.NewSymbol("list")) + if v234.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v234))) + } + v235 := v234.Get() + v236 := lang.Apply(v235, []any{lang.NewSymbol("glojure.core/assert")}) + v237 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v238 := v237.FindInternedVar(lang.NewSymbol("list")) + if v238.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v238))) + } + v239 := v238.Get() + v240 := lang.Apply(v239, []any{v226}) + v241 := lang.Apply(v232, []any{v236, v240}) + v242 := lang.Apply(v229, []any{v241}) + return v242 + }) + v226 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4582), lang.NewKeyword("column"), int(41), lang.NewKeyword("end-line"), int(4582), lang.NewKeyword("end-column"), int(62)) + v227, err := lang.WithMeta(v225, v226.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v228 := lang.Apply(v224, []any{v227, v149}) + v229 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v230 := v229.FindInternedVar(lang.NewSymbol("list")) + if v230.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v230))) + } + v231 := v230.Get() + v232 := lang.Apply(v231, []any{lang.NewSymbol("%")}) + v233 := lang.Apply(v165, []any{v169, v221, v228, v232}) + v234 := lang.Apply(v162, []any{v233}) + v235 := lang.Apply(v159, []any{v234}) + v236 := lang.Apply(v156, []any{v235}) + v237 := lang.Apply(v153, []any{v236}) + v150 = v237 + } else { + v150 = v143 + } + var v238 any = v150 + _ = v238 + // let binding "body" + var v239 any + if lang.IsTruthy(v147) { + v240 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v241 := v240.FindInternedVar(lang.NewSymbol("concat")) + if v241.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v241))) + } + v242 := v241.Get() + v243 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v244 := v243.FindInternedVar(lang.NewSymbol("map")) + if v244.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v244))) + } + v245 := v244.Get() + var v246 lang.FnFunc + v246 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v247 := args[0] + _ = v247 + v248 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v249 := v248.FindInternedVar(lang.NewSymbol("seq")) + if v249.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v249))) + } + v250 := v249.Get() + v251 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v252 := v251.FindInternedVar(lang.NewSymbol("concat")) + if v252.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v252))) + } + v253 := v252.Get() + v254 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v255 := v254.FindInternedVar(lang.NewSymbol("list")) + if v255.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v255))) + } + v256 := v255.Get() + v257 := lang.Apply(v256, []any{lang.NewSymbol("glojure.core/assert")}) + v258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v259 := v258.FindInternedVar(lang.NewSymbol("list")) + if v259.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v259))) + } + v260 := v259.Get() + v261 := lang.Apply(v260, []any{v247}) + v262 := lang.Apply(v253, []any{v257, v261}) + v263 := lang.Apply(v250, []any{v262}) + return v263 + }) + v247 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4586), lang.NewKeyword("column"), int(44), lang.NewKeyword("end-line"), int(4586), lang.NewKeyword("end-column"), int(65)) + v248, err := lang.WithMeta(v246, v247.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v249 := lang.Apply(v245, []any{v248, v147}) + v250 := lang.Apply(v242, []any{v249, v238}) + v239 = v250 + } else { + v239 = v238 + } + var v251 any = v239 + _ = v251 + v252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v253 := v252.FindInternedVar(lang.NewSymbol("maybe-destructured")) + if v253.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v253))) + } + v254 := v253.Get() + v255 := lang.Apply(v254, []any{v101, v251}) + v84 = v255 + } // end let + return v84 + }) + v69 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4558), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(4589), lang.NewKeyword("end-column"), int(53)) + v70, err := lang.WithMeta(v68, v69.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v71 any = v70 + _ = v71 + // let binding "new-sigs" + v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v73 := v72.FindInternedVar(lang.NewSymbol("map")) + if v73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) + } + v74 := v73.Get() + v75 := lang.Apply(v74, []any{v71, v67}) + var v76 any = v75 + _ = v76 + v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v78 := v77.FindInternedVar(lang.NewSymbol("with-meta")) + if v78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) + } + v79 := v78.Get() + var v80 any + if lang.IsTruthy(v20) { + v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v82 := v81.FindInternedVar(lang.NewSymbol("list*")) + if v82.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) + } + v83 := v82.Get() + v84 := lang.Apply(v83, []any{lang.NewSymbol("fn*"), v20, v76}) + v80 = v84 + } else { + v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v86 := v85.FindInternedVar(lang.NewSymbol("cons")) + if v86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) + } + v87 := v86.Get() + v88 := lang.Apply(v87, []any{lang.NewSymbol("fn*"), v76}) + v80 = v88 + } + v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v90 := v89.FindInternedVar(lang.NewSymbol("meta")) + if v90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) + } + v91 := v90.Get() + v92 := lang.Apply(v91, []any{v3}) + v93 := lang.Apply(v79, []any{v80, v92}) + v6 = v93 + } // end let + return v6 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // fn? + { + v0 := lang.NewSymbol("fn?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements Fn, i.e. is an object created via fn.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6216), lang.NewKeyword("end-line"), int(6216))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.Apply(v6, []any{*runtime4.Fn, v3}) + return v7 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // fnext + { + v0 := lang.NewSymbol("fnext").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Same as (first (next x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(112), lang.NewKeyword("end-line"), int(116))).(*lang.Symbol) + var v2 lang.FnFunc + { // function fnext + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("first")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("next")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v4}) + v12 := lang.Apply(v7, []any{v11}) + return v12 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(116), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(116), lang.NewKeyword("end-column"), int(47))).(lang.FnFunc) + v3 := v2 + _ = v3 + } + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // fnil + { + v0 := lang.NewSymbol("fnil").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("z"))), lang.NewKeyword("doc"), "Takes a function f, and returns a function that calls f, replacing\n a nil first argument to f with the supplied value x. Higher arity\n versions can replace arguments in the second and third\n positions (y, z). Note that the function f can take any number of\n arguments, not just the one(s) being nil-patched.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6558), lang.NewKeyword("end-line"), int(6558))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 lang.FnFunc + v5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v6 := args[0] + _ = v6 + var v7 any + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("nil?")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v6}) + if lang.IsTruthy(v11) { + v7 = v4 + } else { + v7 = v6 + } + v12 := lang.Apply(v3, []any{v7}) + return v12 + case 2: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + var v8 any + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("nil?")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.Apply(v11, []any{v6}) + if lang.IsTruthy(v12) { + v8 = v4 + } else { + v8 = v6 + } + v13 := lang.Apply(v3, []any{v8, v7}) + return v13 + case 3: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + var v9 any + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("nil?")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{v6}) + if lang.IsTruthy(v13) { + v9 = v4 + } else { + v9 = v6 + } + v14 := lang.Apply(v3, []any{v9, v7, v8}) + return v14 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + v9 := lang.NewList(args[3:]...) + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("apply")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + var v13 any + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("nil?")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{v6}) + if lang.IsTruthy(v17) { + v13 = v4 + } else { + v13 = v6 + } + v18 := lang.Apply(v12, []any{v3, v13, v7, v8, v9}) + return v18 + } + }) + v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6567), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(6571), lang.NewKeyword("end-column"), int(55)) + v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v7 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 lang.FnFunc + v6 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + var v9 any + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("nil?")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{v7}) + if lang.IsTruthy(v13) { + v9 = v4 + } else { + v9 = v7 + } + var v14 any + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("nil?")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{v8}) + if lang.IsTruthy(v18) { + v14 = v5 + } else { + v14 = v8 + } + v19 := lang.Apply(v3, []any{v9, v14}) + return v19 + case 3: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + var v10 any + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("nil?")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{v7}) + if lang.IsTruthy(v14) { + v10 = v4 + } else { + v10 = v7 + } + var v15 any + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("nil?")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{v8}) + if lang.IsTruthy(v19) { + v15 = v5 + } else { + v15 = v8 + } + v20 := lang.Apply(v3, []any{v10, v15, v9}) + return v20 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + v10 := lang.NewList(args[3:]...) + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("apply")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + var v14 any + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("nil?")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{v7}) + if lang.IsTruthy(v18) { + v14 = v4 + } else { + v14 = v7 + } + var v19 any + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("nil?")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.Apply(v22, []any{v8}) + if lang.IsTruthy(v23) { + v19 = v5 + } else { + v19 = v8 + } + v24 := lang.Apply(v13, []any{v3, v14, v19, v9, v10}) + return v24 + } + }) + v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6573), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(6576), lang.NewKeyword("end-column"), int(71)) + v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v8 + case 4: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + var v7 lang.FnFunc + v7 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + var v10 any + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("nil?")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{v8}) + if lang.IsTruthy(v14) { + v10 = v4 + } else { + v10 = v8 + } + var v15 any + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("nil?")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{v9}) + if lang.IsTruthy(v19) { + v15 = v5 + } else { + v15 = v9 + } + v20 := lang.Apply(v3, []any{v10, v15}) + return v20 + case 3: + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + v10 := args[2] + _ = v10 + var v11 any + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("nil?")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.Apply(v14, []any{v8}) + if lang.IsTruthy(v15) { + v11 = v4 + } else { + v11 = v8 + } + var v16 any + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("nil?")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.Apply(v19, []any{v9}) + if lang.IsTruthy(v20) { + v16 = v5 + } else { + v16 = v9 + } + var v21 any + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("nil?")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v10}) + if lang.IsTruthy(v25) { + v21 = v6 + } else { + v21 = v10 + } + v26 := lang.Apply(v3, []any{v11, v16, v21}) + return v26 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + v10 := args[2] + _ = v10 + v11 := lang.NewList(args[3:]...) + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("apply")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + var v15 any + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("nil?")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{v8}) + if lang.IsTruthy(v19) { + v15 = v4 + } else { + v15 = v8 + } + var v20 any + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("nil?")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.Apply(v23, []any{v9}) + if lang.IsTruthy(v24) { + v20 = v5 + } else { + v20 = v9 + } + var v25 any + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("nil?")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.Apply(v28, []any{v10}) + if lang.IsTruthy(v29) { + v25 = v6 + } else { + v25 = v10 + } + v30 := lang.Apply(v14, []any{v3, v15, v20, v25, v11}) + return v30 + } + }) + v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6578), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(6581), lang.NewKeyword("end-column"), int(87)) + v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v9 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // for + { + v0 := lang.NewSymbol("for").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("seq-exprs"), lang.NewSymbol("body-expr"))), lang.NewKeyword("doc"), "List comprehension. Takes a vector of one or more\n binding-form/collection-expr pairs, each followed by zero or more\n modifiers, and yields a lazy sequence of evaluations of expr.\n Collections are iterated in a nested fashion, rightmost fastest,\n and nested coll-exprs can refer to bindings created in prior\n binding-forms. Supported modifiers are: :let [binding-form expr ...],\n :while test, :when test.\n\n (take 100 (for [x (range 100000000) y (range 1000000) :while (< y x)] [x y]))", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4646), lang.NewKeyword("end-line"), int(4646))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + var v7 any + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v5}) + if lang.IsTruthy(v11) { + v7 = nil + } else { + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("str")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("first")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{v3}) + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("meta")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v3}) + v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) + v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) + v28 := lang.Apply(lang.NewIllegalArgumentError, []any{v27}) + panic(v28) + } + _ = v7 + var v29 any + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("even?")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("count")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.Apply(v35, []any{v5}) + v37 := lang.Apply(v32, []any{v36}) + if lang.IsTruthy(v37) { + v29 = nil + } else { + v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v39 := v38.FindInternedVar(lang.NewSymbol("str")) + if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + } + v40 := v39.Get() + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("first")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.Apply(v43, []any{v3}) + v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) + if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) + } + v47 := v46.Get() + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("meta")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v3}) + v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) + v53 := lang.Apply(v40, []any{v44, " requires ", "an even number of forms in binding vector", " in ", v47, ":", v52}) + v54 := lang.Apply(lang.NewIllegalArgumentError, []any{v53}) + panic(v54) + } + _ = v29 + _ = nil + var v55 any + { // let + // let binding "to-groups" + var v56 lang.FnFunc + v56 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v57 := args[0] + _ = v57 + v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v59 := v58.FindInternedVar(lang.NewSymbol("reduce1")) + if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) + } + v60 := v59.Get() + var v61 lang.FnFunc + v61 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v62 := args[0] + _ = v62 + v63 := args[1] + _ = v63 + var v64 any + { // let + // let binding "vec__24" + var v65 any = v63 + _ = v65 + // let binding "k" + v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v67 := v66.FindInternedVar(lang.NewSymbol("nth")) + if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) + } + v68 := v67.Get() + v69 := lang.Apply(v68, []any{v65, int64(0), nil}) + var v70 any = v69 + _ = v70 + // let binding "v" + v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v72 := v71.FindInternedVar(lang.NewSymbol("nth")) + if v72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) + } + v73 := v72.Get() + v74 := lang.Apply(v73, []any{v65, int64(1), nil}) + var v75 any = v74 + _ = v75 + var v76 any + v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v78 := v77.FindInternedVar(lang.NewSymbol("keyword?")) + if v78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) + } + v79 := v78.Get() + v80 := lang.Apply(v79, []any{v70}) + if lang.IsTruthy(v80) { + v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v82 := v81.FindInternedVar(lang.NewSymbol("conj")) + if v82.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) + } + v83 := v82.Get() + v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v85 := v84.FindInternedVar(lang.NewSymbol("pop")) + if v85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) + } + v86 := v85.Get() + v87 := lang.Apply(v86, []any{v62}) + v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v89 := v88.FindInternedVar(lang.NewSymbol("conj")) + if v89.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) + } + v90 := v89.Get() + v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v92 := v91.FindInternedVar(lang.NewSymbol("peek")) + if v92.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) + } + v93 := v92.Get() + v94 := lang.Apply(v93, []any{v62}) + v95 := lang.NewVector(v70, v75) + v96 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4664), lang.NewKeyword("column"), int(72), lang.NewKeyword("end-line"), int(4664), lang.NewKeyword("end-column"), int(76)) + v97, err := lang.WithMeta(v95, v96.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v98 := lang.Apply(v90, []any{v94, v97}) + v99 := lang.Apply(v83, []any{v87, v98}) + v76 = v99 + } else { + v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v101 := v100.FindInternedVar(lang.NewSymbol("conj")) + if v101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) + } + v102 := v101.Get() + v103 := lang.NewVector(v70, v75) + v104 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4665), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(4665), lang.NewKeyword("end-column"), int(50)) + v105, err := lang.WithMeta(v103, v104.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v106 := lang.Apply(v102, []any{v62, v105}) + v76 = v106 + } + v64 = v76 + } // end let + return v64 + }) + v62 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4662), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(4665), lang.NewKeyword("end-column"), int(53)) + v63, err := lang.WithMeta(v61, v62.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v64 := lang.NewVector() + v65 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4666), lang.NewKeyword("column"), int(29), lang.NewKeyword("end-line"), int(4666), lang.NewKeyword("end-column"), int(30)) + v66, err := lang.WithMeta(v64, v65.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v68 := v67.FindInternedVar(lang.NewSymbol("partition")) + if v68.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) + } + v69 := v68.Get() + v70 := lang.Apply(v69, []any{int64(2), v57}) + v71 := lang.Apply(v60, []any{v63, v66, v70}) + return v71 + }) + v57 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4661), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(4666), lang.NewKeyword("end-column"), int(56)) + v58, err := lang.WithMeta(v56, v57.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v59 any = v58 + _ = v59 + // let binding "err" + var v60 lang.FnFunc + v60 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v61 := lang.NewList(args[0:]...) + v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v63 := v62.FindInternedVar(lang.NewSymbol("apply")) + if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) + } + v64 := v63.Get() + v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v66 := v65.FindInternedVar(lang.NewSymbol("str")) + if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) + } + v67 := v66.Get() + v68 := lang.Apply(v64, []any{v67, v61}) + v69 := lang.Apply(lang.NewIllegalArgumentError, []any{v68}) + panic(v69) + } + }) + v61 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4667), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(4667), lang.NewKeyword("end-column"), int(125)) + v62, err := lang.WithMeta(v60, v61.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v63 any = v62 + _ = v63 + // let binding "emit-bind" + var v64 lang.FnFunc + { // function emit-bind + v64 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v66 := args[0] + _ = v66 + var v67 any + { // let + // let binding "vec__28" + var v68 any = v66 + _ = v68 + // let binding "seq__29" + v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v70 := v69.FindInternedVar(lang.NewSymbol("seq")) + if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) + } + v71 := v70.Get() + v72 := lang.Apply(v71, []any{v68}) + var v73 any = v72 + _ = v73 + // let binding "first__30" + v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v75 := v74.FindInternedVar(lang.NewSymbol("first")) + if v75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) + } + v76 := v75.Get() + v77 := lang.Apply(v76, []any{v73}) + var v78 any = v77 + _ = v78 + // let binding "seq__29" + v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v80 := v79.FindInternedVar(lang.NewSymbol("next")) + if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) + } + v81 := v80.Get() + v82 := lang.Apply(v81, []any{v73}) + var v83 any = v82 + _ = v83 + // let binding "vec__31" + var v84 any = v78 + _ = v84 + // let binding "seq__32" + v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v86 := v85.FindInternedVar(lang.NewSymbol("seq")) + if v86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) + } + v87 := v86.Get() + v88 := lang.Apply(v87, []any{v84}) + var v89 any = v88 + _ = v89 + // let binding "first__33" + v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v91 := v90.FindInternedVar(lang.NewSymbol("first")) + if v91.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) + } + v92 := v91.Get() + v93 := lang.Apply(v92, []any{v89}) + var v94 any = v93 + _ = v94 + // let binding "seq__32" + v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v96 := v95.FindInternedVar(lang.NewSymbol("next")) + if v96.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) + } + v97 := v96.Get() + v98 := lang.Apply(v97, []any{v89}) + var v99 any = v98 + _ = v99 + // let binding "bind" + var v100 any = v94 + _ = v100 + // let binding "first__33" + v101 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v102 := v101.FindInternedVar(lang.NewSymbol("first")) + if v102.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v102))) + } + v103 := v102.Get() + v104 := lang.Apply(v103, []any{v99}) + var v105 any = v104 + _ = v105 + // let binding "seq__32" + v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v107 := v106.FindInternedVar(lang.NewSymbol("next")) + if v107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) + } + v108 := v107.Get() + v109 := lang.Apply(v108, []any{v99}) + var v110 any = v109 + _ = v110 + // let binding "expr" + var v111 any = v105 + _ = v111 + // let binding "mod-pairs" + var v112 any = v110 + _ = v112 + // let binding "vec__34" + var v113 any = v83 + _ = v113 + // let binding "vec__37" + v114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v115 := v114.FindInternedVar(lang.NewSymbol("nth")) + if v115.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v115))) + } + v116 := v115.Get() + v117 := lang.Apply(v116, []any{v113, int64(0), nil}) + var v118 any = v117 + _ = v118 + // let binding "_" + v119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v120 := v119.FindInternedVar(lang.NewSymbol("nth")) + if v120.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v120))) + } + v121 := v120.Get() + v122 := lang.Apply(v121, []any{v118, int64(0), nil}) + var v123 any = v122 + _ = v123 + // let binding "next-expr" + v124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v125 := v124.FindInternedVar(lang.NewSymbol("nth")) + if v125.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v125))) + } + v126 := v125.Get() + v127 := lang.Apply(v126, []any{v118, int64(1), nil}) + var v128 any = v127 + _ = v128 + // let binding "next-groups" + var v129 any = v113 + _ = v129 + var v130 any + { // let + // let binding "giter" + v131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v132 := v131.FindInternedVar(lang.NewSymbol("gensym")) + if v132.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v132))) + } + v133 := v132.Get() + v134 := lang.Apply(v133, []any{"iter__"}) + var v135 any = v134 + _ = v135 + // let binding "gxs" + v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v137 := v136.FindInternedVar(lang.NewSymbol("gensym")) + if v137.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) + } + v138 := v137.Get() + v139 := lang.Apply(v138, []any{"s__"}) + var v140 any = v139 + _ = v140 + // let binding "do-mod" + var v141 lang.FnFunc + { // function do-mod + v141 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v143 := args[0] + _ = v143 + var v144 any + { // let + // let binding "vec__41" + var v145 any = v143 + _ = v145 + // let binding "seq__42" + v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v147 := v146.FindInternedVar(lang.NewSymbol("seq")) + if v147.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) + } + v148 := v147.Get() + v149 := lang.Apply(v148, []any{v145}) + var v150 any = v149 + _ = v150 + // let binding "first__43" + v151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v152 := v151.FindInternedVar(lang.NewSymbol("first")) + if v152.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v152))) + } + v153 := v152.Get() + v154 := lang.Apply(v153, []any{v150}) + var v155 any = v154 + _ = v155 + // let binding "seq__42" + v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v157 := v156.FindInternedVar(lang.NewSymbol("next")) + if v157.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) + } + v158 := v157.Get() + v159 := lang.Apply(v158, []any{v150}) + var v160 any = v159 + _ = v160 + // let binding "vec__44" + var v161 any = v155 + _ = v161 + // let binding "k" + v162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v163 := v162.FindInternedVar(lang.NewSymbol("nth")) + if v163.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v163))) + } + v164 := v163.Get() + v165 := lang.Apply(v164, []any{v161, int64(0), nil}) + var v166 any = v165 + _ = v166 + // let binding "v" + v167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v168 := v167.FindInternedVar(lang.NewSymbol("nth")) + if v168.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v168))) + } + v169 := v168.Get() + v170 := lang.Apply(v169, []any{v161, int64(1), nil}) + var v171 any = v170 + _ = v171 + // let binding "pair" + var v172 any = v161 + _ = v172 + // let binding "etc" + var v173 any = v160 + _ = v173 + var v174 any + v175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v176 := v175.FindInternedVar(lang.NewSymbol("=")) + if v176.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v176))) + } + v177 := v176.Get() + v178 := lang.Apply(v177, []any{v166, lang.NewKeyword("let")}) + if lang.IsTruthy(v178) { + v179 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v180 := v179.FindInternedVar(lang.NewSymbol("seq")) + if v180.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v180))) + } + v181 := v180.Get() + v182 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v183 := v182.FindInternedVar(lang.NewSymbol("concat")) + if v183.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v183))) + } + v184 := v183.Get() + v185 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v186 := v185.FindInternedVar(lang.NewSymbol("list")) + if v186.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v186))) + } + v187 := v186.Get() + v188 := lang.Apply(v187, []any{lang.NewSymbol("glojure.core/let")}) + v189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v190 := v189.FindInternedVar(lang.NewSymbol("list")) + if v190.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v190))) + } + v191 := v190.Get() + v192 := lang.Apply(v191, []any{v171}) + v193 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v194 := v193.FindInternedVar(lang.NewSymbol("list")) + if v194.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v194))) + } + v195 := v194.Get() + v196 := lang.Apply(v142, []any{v173}) + v197 := lang.Apply(v195, []any{v196}) + v198 := lang.Apply(v184, []any{v188, v192, v197}) + v199 := lang.Apply(v181, []any{v198}) + v174 = v199 + } else { + var v200 any + v201 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v202 := v201.FindInternedVar(lang.NewSymbol("=")) + if v202.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v202))) + } + v203 := v202.Get() + v204 := lang.Apply(v203, []any{v166, lang.NewKeyword("while")}) + if lang.IsTruthy(v204) { + v205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v206 := v205.FindInternedVar(lang.NewSymbol("seq")) + if v206.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v206))) + } + v207 := v206.Get() + v208 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v209 := v208.FindInternedVar(lang.NewSymbol("concat")) + if v209.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v209))) + } + v210 := v209.Get() + v211 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v212 := v211.FindInternedVar(lang.NewSymbol("list")) + if v212.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v212))) + } + v213 := v212.Get() + v214 := lang.Apply(v213, []any{lang.NewSymbol("glojure.core/when")}) + v215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v216 := v215.FindInternedVar(lang.NewSymbol("list")) + if v216.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v216))) + } + v217 := v216.Get() + v218 := lang.Apply(v217, []any{v171}) + v219 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v220 := v219.FindInternedVar(lang.NewSymbol("list")) + if v220.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v220))) + } + v221 := v220.Get() + v222 := lang.Apply(v142, []any{v173}) + v223 := lang.Apply(v221, []any{v222}) + v224 := lang.Apply(v210, []any{v214, v218, v223}) + v225 := lang.Apply(v207, []any{v224}) + v200 = v225 + } else { + var v226 any + v227 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v228 := v227.FindInternedVar(lang.NewSymbol("=")) + if v228.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v228))) + } + v229 := v228.Get() + v230 := lang.Apply(v229, []any{v166, lang.NewKeyword("when")}) + if lang.IsTruthy(v230) { + v231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v232 := v231.FindInternedVar(lang.NewSymbol("seq")) + if v232.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v232))) + } + v233 := v232.Get() + v234 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v235 := v234.FindInternedVar(lang.NewSymbol("concat")) + if v235.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v235))) + } + v236 := v235.Get() + v237 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v238 := v237.FindInternedVar(lang.NewSymbol("list")) + if v238.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v238))) + } + v239 := v238.Get() + v240 := lang.Apply(v239, []any{lang.NewSymbol("if")}) + v241 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v242 := v241.FindInternedVar(lang.NewSymbol("list")) + if v242.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v242))) + } + v243 := v242.Get() + v244 := lang.Apply(v243, []any{v171}) + v245 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v246 := v245.FindInternedVar(lang.NewSymbol("list")) + if v246.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v246))) + } + v247 := v246.Get() + v248 := lang.Apply(v142, []any{v173}) + v249 := lang.Apply(v247, []any{v248}) + v250 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v251 := v250.FindInternedVar(lang.NewSymbol("list")) + if v251.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v251))) + } + v252 := v251.Get() + v253 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v254 := v253.FindInternedVar(lang.NewSymbol("seq")) + if v254.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v254))) + } + v255 := v254.Get() + v256 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v257 := v256.FindInternedVar(lang.NewSymbol("concat")) + if v257.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v257))) + } + v258 := v257.Get() + v259 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v260 := v259.FindInternedVar(lang.NewSymbol("list")) + if v260.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v260))) + } + v261 := v260.Get() + v262 := lang.Apply(v261, []any{lang.NewSymbol("recur")}) + v263 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v264 := v263.FindInternedVar(lang.NewSymbol("list")) + if v264.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v264))) + } + v265 := v264.Get() + v266 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v267 := v266.FindInternedVar(lang.NewSymbol("seq")) + if v267.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v267))) + } + v268 := v267.Get() + v269 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v270 := v269.FindInternedVar(lang.NewSymbol("concat")) + if v270.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v270))) + } + v271 := v270.Get() + v272 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v273 := v272.FindInternedVar(lang.NewSymbol("list")) + if v273.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v273))) + } + v274 := v273.Get() + v275 := lang.Apply(v274, []any{lang.NewSymbol("glojure.core/rest")}) + v276 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v277 := v276.FindInternedVar(lang.NewSymbol("list")) + if v277.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v277))) + } + v278 := v277.Get() + v279 := lang.Apply(v278, []any{v140}) + v280 := lang.Apply(v271, []any{v275, v279}) + v281 := lang.Apply(v268, []any{v280}) + v282 := lang.Apply(v265, []any{v281}) + v283 := lang.Apply(v258, []any{v262, v282}) + v284 := lang.Apply(v255, []any{v283}) + v285 := lang.Apply(v252, []any{v284}) + v286 := lang.Apply(v236, []any{v240, v244, v249, v285}) + v287 := lang.Apply(v233, []any{v286}) + v226 = v287 + } else { + var v288 any + v289 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v290 := v289.FindInternedVar(lang.NewSymbol("keyword?")) + if v290.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v290))) + } + v291 := v290.Get() + v292 := lang.Apply(v291, []any{v166}) + if lang.IsTruthy(v292) { + v293 := lang.Apply(v63, []any{"Invalid 'for' keyword ", v166}) + v288 = v293 + } else { + var v294 any + if lang.IsTruthy(v129) { + v295 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v296 := v295.FindInternedVar(lang.NewSymbol("seq")) + if v296.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v296))) + } + v297 := v296.Get() + v298 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v299 := v298.FindInternedVar(lang.NewSymbol("concat")) + if v299.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v299))) + } + v300 := v299.Get() + v301 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v302 := v301.FindInternedVar(lang.NewSymbol("list")) + if v302.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v302))) + } + v303 := v302.Get() + v304 := lang.Apply(v303, []any{lang.NewSymbol("glojure.core/let")}) + v305 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v306 := v305.FindInternedVar(lang.NewSymbol("list")) + if v306.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v306))) + } + v307 := v306.Get() + v308 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v309 := v308.FindInternedVar(lang.NewSymbol("apply")) + if v309.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v309))) + } + v310 := v309.Get() + v311 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v312 := v311.FindInternedVar(lang.NewSymbol("vector")) + if v312.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v312))) + } + v313 := v312.Get() + v314 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v315 := v314.FindInternedVar(lang.NewSymbol("seq")) + if v315.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v315))) + } + v316 := v315.Get() + v317 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v318 := v317.FindInternedVar(lang.NewSymbol("concat")) + if v318.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v318))) + } + v319 := v318.Get() + v320 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v321 := v320.FindInternedVar(lang.NewSymbol("list")) + if v321.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v321))) + } + v322 := v321.Get() + v323 := lang.Apply(v322, []any{lang.NewSymbol("iterys__0__auto__")}) + v324 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v325 := v324.FindInternedVar(lang.NewSymbol("list")) + if v325.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v325))) + } + v326 := v325.Get() + v327 := lang.Apply(v65, []any{v129}) + v328 := lang.Apply(v326, []any{v327}) + v329 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v330 := v329.FindInternedVar(lang.NewSymbol("list")) + if v330.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v330))) + } + v331 := v330.Get() + v332 := lang.Apply(v331, []any{lang.NewSymbol("fs__1__auto__")}) + v333 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v334 := v333.FindInternedVar(lang.NewSymbol("list")) + if v334.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v334))) + } + v335 := v334.Get() + v336 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v337 := v336.FindInternedVar(lang.NewSymbol("seq")) + if v337.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v337))) + } + v338 := v337.Get() + v339 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v340 := v339.FindInternedVar(lang.NewSymbol("concat")) + if v340.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v340))) + } + v341 := v340.Get() + v342 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v343 := v342.FindInternedVar(lang.NewSymbol("list")) + if v343.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v343))) + } + v344 := v343.Get() + v345 := lang.Apply(v344, []any{lang.NewSymbol("glojure.core/seq")}) + v346 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v347 := v346.FindInternedVar(lang.NewSymbol("list")) + if v347.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v347))) + } + v348 := v347.Get() + v349 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v350 := v349.FindInternedVar(lang.NewSymbol("seq")) + if v350.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v350))) + } + v351 := v350.Get() + v352 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v353 := v352.FindInternedVar(lang.NewSymbol("concat")) + if v353.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v353))) + } + v354 := v353.Get() + v355 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v356 := v355.FindInternedVar(lang.NewSymbol("list")) + if v356.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v356))) + } + v357 := v356.Get() + v358 := lang.Apply(v357, []any{lang.NewSymbol("iterys__0__auto__")}) + v359 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v360 := v359.FindInternedVar(lang.NewSymbol("list")) + if v360.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v360))) + } + v361 := v360.Get() + v362 := lang.Apply(v361, []any{v128}) + v363 := lang.Apply(v354, []any{v358, v362}) + v364 := lang.Apply(v351, []any{v363}) + v365 := lang.Apply(v348, []any{v364}) + v366 := lang.Apply(v341, []any{v345, v365}) + v367 := lang.Apply(v338, []any{v366}) + v368 := lang.Apply(v335, []any{v367}) + v369 := lang.Apply(v319, []any{v323, v328, v332, v368}) + v370 := lang.Apply(v316, []any{v369}) + v371 := lang.Apply(v310, []any{v313, v370}) + v372 := lang.Apply(v307, []any{v371}) + v373 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v374 := v373.FindInternedVar(lang.NewSymbol("list")) + if v374.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v374))) + } + v375 := v374.Get() + v376 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v377 := v376.FindInternedVar(lang.NewSymbol("seq")) + if v377.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v377))) + } + v378 := v377.Get() + v379 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v380 := v379.FindInternedVar(lang.NewSymbol("concat")) + if v380.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v380))) + } + v381 := v380.Get() + v382 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v383 := v382.FindInternedVar(lang.NewSymbol("list")) + if v383.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v383))) + } + v384 := v383.Get() + v385 := lang.Apply(v384, []any{lang.NewSymbol("if")}) + v386 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v387 := v386.FindInternedVar(lang.NewSymbol("list")) + if v387.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v387))) + } + v388 := v387.Get() + v389 := lang.Apply(v388, []any{lang.NewSymbol("fs__1__auto__")}) + v390 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v391 := v390.FindInternedVar(lang.NewSymbol("list")) + if v391.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v391))) + } + v392 := v391.Get() + v393 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v394 := v393.FindInternedVar(lang.NewSymbol("seq")) + if v394.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v394))) + } + v395 := v394.Get() + v396 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v397 := v396.FindInternedVar(lang.NewSymbol("concat")) + if v397.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v397))) + } + v398 := v397.Get() + v399 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v400 := v399.FindInternedVar(lang.NewSymbol("list")) + if v400.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v400))) + } + v401 := v400.Get() + v402 := lang.Apply(v401, []any{lang.NewSymbol("glojure.core/concat")}) + v403 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v404 := v403.FindInternedVar(lang.NewSymbol("list")) + if v404.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v404))) + } + v405 := v404.Get() + v406 := lang.Apply(v405, []any{lang.NewSymbol("fs__1__auto__")}) + v407 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v408 := v407.FindInternedVar(lang.NewSymbol("list")) + if v408.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v408))) + } + v409 := v408.Get() + v410 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v411 := v410.FindInternedVar(lang.NewSymbol("seq")) + if v411.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v411))) + } + v412 := v411.Get() + v413 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v414 := v413.FindInternedVar(lang.NewSymbol("concat")) + if v414.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v414))) + } + v415 := v414.Get() + v416 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v417 := v416.FindInternedVar(lang.NewSymbol("list")) + if v417.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v417))) + } + v418 := v417.Get() + v419 := lang.Apply(v418, []any{v135}) + v420 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v421 := v420.FindInternedVar(lang.NewSymbol("list")) + if v421.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v421))) + } + v422 := v421.Get() + v423 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v424 := v423.FindInternedVar(lang.NewSymbol("seq")) + if v424.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v424))) + } + v425 := v424.Get() + v426 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v427 := v426.FindInternedVar(lang.NewSymbol("concat")) + if v427.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v427))) + } + v428 := v427.Get() + v429 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v430 := v429.FindInternedVar(lang.NewSymbol("list")) + if v430.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v430))) + } + v431 := v430.Get() + v432 := lang.Apply(v431, []any{lang.NewSymbol("glojure.core/rest")}) + v433 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v434 := v433.FindInternedVar(lang.NewSymbol("list")) + if v434.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v434))) + } + v435 := v434.Get() + v436 := lang.Apply(v435, []any{v140}) + v437 := lang.Apply(v428, []any{v432, v436}) + v438 := lang.Apply(v425, []any{v437}) + v439 := lang.Apply(v422, []any{v438}) + v440 := lang.Apply(v415, []any{v419, v439}) + v441 := lang.Apply(v412, []any{v440}) + v442 := lang.Apply(v409, []any{v441}) + v443 := lang.Apply(v398, []any{v402, v406, v442}) + v444 := lang.Apply(v395, []any{v443}) + v445 := lang.Apply(v392, []any{v444}) + v446 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v447 := v446.FindInternedVar(lang.NewSymbol("list")) + if v447.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v447))) + } + v448 := v447.Get() + v449 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v450 := v449.FindInternedVar(lang.NewSymbol("seq")) + if v450.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v450))) + } + v451 := v450.Get() + v452 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v453 := v452.FindInternedVar(lang.NewSymbol("concat")) + if v453.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v453))) + } + v454 := v453.Get() + v455 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v456 := v455.FindInternedVar(lang.NewSymbol("list")) + if v456.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v456))) + } + v457 := v456.Get() + v458 := lang.Apply(v457, []any{lang.NewSymbol("recur")}) + v459 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v460 := v459.FindInternedVar(lang.NewSymbol("list")) + if v460.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v460))) + } + v461 := v460.Get() + v462 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v463 := v462.FindInternedVar(lang.NewSymbol("seq")) + if v463.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v463))) + } + v464 := v463.Get() + v465 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v466 := v465.FindInternedVar(lang.NewSymbol("concat")) + if v466.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v466))) + } + v467 := v466.Get() + v468 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v469 := v468.FindInternedVar(lang.NewSymbol("list")) + if v469.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v469))) + } + v470 := v469.Get() + v471 := lang.Apply(v470, []any{lang.NewSymbol("glojure.core/rest")}) + v472 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v473 := v472.FindInternedVar(lang.NewSymbol("list")) + if v473.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v473))) + } + v474 := v473.Get() + v475 := lang.Apply(v474, []any{v140}) + v476 := lang.Apply(v467, []any{v471, v475}) + v477 := lang.Apply(v464, []any{v476}) + v478 := lang.Apply(v461, []any{v477}) + v479 := lang.Apply(v454, []any{v458, v478}) + v480 := lang.Apply(v451, []any{v479}) + v481 := lang.Apply(v448, []any{v480}) + v482 := lang.Apply(v381, []any{v385, v389, v445, v481}) + v483 := lang.Apply(v378, []any{v482}) + v484 := lang.Apply(v375, []any{v483}) + v485 := lang.Apply(v300, []any{v304, v372, v484}) + v486 := lang.Apply(v297, []any{v485}) + v294 = v486 + } else { + var v487 any + if lang.IsTruthy(lang.NewKeyword("else")) { + v488 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v489 := v488.FindInternedVar(lang.NewSymbol("seq")) + if v489.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v489))) + } + v490 := v489.Get() + v491 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v492 := v491.FindInternedVar(lang.NewSymbol("concat")) + if v492.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v492))) + } + v493 := v492.Get() + v494 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v495 := v494.FindInternedVar(lang.NewSymbol("list")) + if v495.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v495))) + } + v496 := v495.Get() + v497 := lang.Apply(v496, []any{lang.NewSymbol("glojure.core/cons")}) + v498 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v499 := v498.FindInternedVar(lang.NewSymbol("list")) + if v499.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v499))) + } + v500 := v499.Get() + v501 := lang.Apply(v500, []any{v6}) + v502 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v503 := v502.FindInternedVar(lang.NewSymbol("list")) + if v503.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v503))) + } + v504 := v503.Get() + v505 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v506 := v505.FindInternedVar(lang.NewSymbol("seq")) + if v506.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v506))) + } + v507 := v506.Get() + v508 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v509 := v508.FindInternedVar(lang.NewSymbol("concat")) + if v509.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v509))) + } + v510 := v509.Get() + v511 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v512 := v511.FindInternedVar(lang.NewSymbol("list")) + if v512.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v512))) + } + v513 := v512.Get() + v514 := lang.Apply(v513, []any{v135}) + v515 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v516 := v515.FindInternedVar(lang.NewSymbol("list")) + if v516.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v516))) + } + v517 := v516.Get() + v518 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v519 := v518.FindInternedVar(lang.NewSymbol("seq")) + if v519.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v519))) + } + v520 := v519.Get() + v521 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v522 := v521.FindInternedVar(lang.NewSymbol("concat")) + if v522.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v522))) + } + v523 := v522.Get() + v524 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v525 := v524.FindInternedVar(lang.NewSymbol("list")) + if v525.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v525))) + } + v526 := v525.Get() + v527 := lang.Apply(v526, []any{lang.NewSymbol("glojure.core/rest")}) + v528 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v529 := v528.FindInternedVar(lang.NewSymbol("list")) + if v529.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v529))) + } + v530 := v529.Get() + v531 := lang.Apply(v530, []any{v140}) + v532 := lang.Apply(v523, []any{v527, v531}) + v533 := lang.Apply(v520, []any{v532}) + v534 := lang.Apply(v517, []any{v533}) + v535 := lang.Apply(v510, []any{v514, v534}) + v536 := lang.Apply(v507, []any{v535}) + v537 := lang.Apply(v504, []any{v536}) + v538 := lang.Apply(v493, []any{v497, v501, v537}) + v539 := lang.Apply(v490, []any{v538}) + v487 = v539 + } else { + v487 = nil + } + v294 = v487 + } + v288 = v294 + } + v226 = v288 + } + v200 = v226 + } + v174 = v200 + } + v144 = v174 + } // end let + return v144 + }) + v142 := v141 + _ = v142 + } + v142 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4672), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(4687), lang.NewKeyword("end-column"), int(73)) + v143, err := lang.WithMeta(v141, v142.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v144 any = v143 + _ = v144 + var v145 any + if lang.IsTruthy(v129) { + v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v147 := v146.FindInternedVar(lang.NewSymbol("seq")) + if v147.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) + } + v148 := v147.Get() + v149 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v150 := v149.FindInternedVar(lang.NewSymbol("concat")) + if v150.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v150))) + } + v151 := v150.Get() + v152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v153 := v152.FindInternedVar(lang.NewSymbol("list")) + if v153.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v153))) + } + v154 := v153.Get() + v155 := lang.Apply(v154, []any{lang.NewSymbol("glojure.core/fn")}) + v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v157 := v156.FindInternedVar(lang.NewSymbol("list")) + if v157.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) + } + v158 := v157.Get() + v159 := lang.Apply(v158, []any{v135}) + v160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v161 := v160.FindInternedVar(lang.NewSymbol("list")) + if v161.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v161))) + } + v162 := v161.Get() + v163 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v164 := v163.FindInternedVar(lang.NewSymbol("apply")) + if v164.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v164))) + } + v165 := v164.Get() + v166 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v167 := v166.FindInternedVar(lang.NewSymbol("vector")) + if v167.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v167))) + } + v168 := v167.Get() + v169 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v170 := v169.FindInternedVar(lang.NewSymbol("seq")) + if v170.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v170))) + } + v171 := v170.Get() + v172 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v173 := v172.FindInternedVar(lang.NewSymbol("concat")) + if v173.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v173))) + } + v174 := v173.Get() + v175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v176 := v175.FindInternedVar(lang.NewSymbol("list")) + if v176.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v176))) + } + v177 := v176.Get() + v178 := lang.Apply(v177, []any{v140}) + v179 := lang.Apply(v174, []any{v178}) + v180 := lang.Apply(v171, []any{v179}) + v181 := lang.Apply(v165, []any{v168, v180}) + v182 := lang.Apply(v162, []any{v181}) + v183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v184 := v183.FindInternedVar(lang.NewSymbol("list")) + if v184.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v184))) + } + v185 := v184.Get() + v186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v187 := v186.FindInternedVar(lang.NewSymbol("seq")) + if v187.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v187))) + } + v188 := v187.Get() + v189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v190 := v189.FindInternedVar(lang.NewSymbol("concat")) + if v190.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v190))) + } + v191 := v190.Get() + v192 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v193 := v192.FindInternedVar(lang.NewSymbol("list")) + if v193.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v193))) + } + v194 := v193.Get() + v195 := lang.Apply(v194, []any{lang.NewSymbol("glojure.core/lazy-seq")}) + v196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v197 := v196.FindInternedVar(lang.NewSymbol("list")) + if v197.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v197))) + } + v198 := v197.Get() + v199 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v200 := v199.FindInternedVar(lang.NewSymbol("seq")) + if v200.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v200))) + } + v201 := v200.Get() + v202 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v203 := v202.FindInternedVar(lang.NewSymbol("concat")) + if v203.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v203))) + } + v204 := v203.Get() + v205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v206 := v205.FindInternedVar(lang.NewSymbol("list")) + if v206.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v206))) + } + v207 := v206.Get() + v208 := lang.Apply(v207, []any{lang.NewSymbol("glojure.core/loop")}) + v209 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v210 := v209.FindInternedVar(lang.NewSymbol("list")) + if v210.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v210))) + } + v211 := v210.Get() + v212 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v213 := v212.FindInternedVar(lang.NewSymbol("apply")) + if v213.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v213))) + } + v214 := v213.Get() + v215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v216 := v215.FindInternedVar(lang.NewSymbol("vector")) + if v216.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v216))) + } + v217 := v216.Get() + v218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v219 := v218.FindInternedVar(lang.NewSymbol("seq")) + if v219.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v219))) + } + v220 := v219.Get() + v221 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v222 := v221.FindInternedVar(lang.NewSymbol("concat")) + if v222.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v222))) + } + v223 := v222.Get() + v224 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v225 := v224.FindInternedVar(lang.NewSymbol("list")) + if v225.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v225))) + } + v226 := v225.Get() + v227 := lang.Apply(v226, []any{v140}) + v228 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v229 := v228.FindInternedVar(lang.NewSymbol("list")) + if v229.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v229))) + } + v230 := v229.Get() + v231 := lang.Apply(v230, []any{v140}) + v232 := lang.Apply(v223, []any{v227, v231}) + v233 := lang.Apply(v220, []any{v232}) + v234 := lang.Apply(v214, []any{v217, v233}) + v235 := lang.Apply(v211, []any{v234}) + v236 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v237 := v236.FindInternedVar(lang.NewSymbol("list")) + if v237.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v237))) + } + v238 := v237.Get() + v239 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v240 := v239.FindInternedVar(lang.NewSymbol("seq")) + if v240.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v240))) + } + v241 := v240.Get() + v242 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v243 := v242.FindInternedVar(lang.NewSymbol("concat")) + if v243.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v243))) + } + v244 := v243.Get() + v245 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v246 := v245.FindInternedVar(lang.NewSymbol("list")) + if v246.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v246))) + } + v247 := v246.Get() + v248 := lang.Apply(v247, []any{lang.NewSymbol("glojure.core/when-first")}) + v249 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v250 := v249.FindInternedVar(lang.NewSymbol("list")) + if v250.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v250))) + } + v251 := v250.Get() + v252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v253 := v252.FindInternedVar(lang.NewSymbol("apply")) + if v253.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v253))) + } + v254 := v253.Get() + v255 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v256 := v255.FindInternedVar(lang.NewSymbol("vector")) + if v256.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v256))) + } + v257 := v256.Get() + v258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v259 := v258.FindInternedVar(lang.NewSymbol("seq")) + if v259.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v259))) + } + v260 := v259.Get() + v261 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v262 := v261.FindInternedVar(lang.NewSymbol("concat")) + if v262.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v262))) + } + v263 := v262.Get() + v264 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v265 := v264.FindInternedVar(lang.NewSymbol("list")) + if v265.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v265))) + } + v266 := v265.Get() + v267 := lang.Apply(v266, []any{v100}) + v268 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v269 := v268.FindInternedVar(lang.NewSymbol("list")) + if v269.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v269))) + } + v270 := v269.Get() + v271 := lang.Apply(v270, []any{v140}) + v272 := lang.Apply(v263, []any{v267, v271}) + v273 := lang.Apply(v260, []any{v272}) + v274 := lang.Apply(v254, []any{v257, v273}) + v275 := lang.Apply(v251, []any{v274}) + v276 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v277 := v276.FindInternedVar(lang.NewSymbol("list")) + if v277.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v277))) + } + v278 := v277.Get() + v279 := lang.Apply(v144, []any{v112}) + v280 := lang.Apply(v278, []any{v279}) + v281 := lang.Apply(v244, []any{v248, v275, v280}) + v282 := lang.Apply(v241, []any{v281}) + v283 := lang.Apply(v238, []any{v282}) + v284 := lang.Apply(v204, []any{v208, v235, v283}) + v285 := lang.Apply(v201, []any{v284}) + v286 := lang.Apply(v198, []any{v285}) + v287 := lang.Apply(v191, []any{v195, v286}) + v288 := lang.Apply(v188, []any{v287}) + v289 := lang.Apply(v185, []any{v288}) + v290 := lang.Apply(v151, []any{v155, v159, v182, v289}) + v291 := lang.Apply(v148, []any{v290}) + v145 = v291 + } else { + var v292 any + { // let + // let binding "gi" + v293 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v294 := v293.FindInternedVar(lang.NewSymbol("gensym")) + if v294.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v294))) + } + v295 := v294.Get() + v296 := lang.Apply(v295, []any{"i__"}) + var v297 any = v296 + _ = v297 + // let binding "gb" + v298 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v299 := v298.FindInternedVar(lang.NewSymbol("gensym")) + if v299.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v299))) + } + v300 := v299.Get() + v301 := lang.Apply(v300, []any{"b__"}) + var v302 any = v301 + _ = v302 + // let binding "do-cmod" + var v303 lang.FnFunc + { // function do-cmod + v303 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v305 := args[0] + _ = v305 + var v306 any + { // let + // let binding "vec__48" + var v307 any = v305 + _ = v307 + // let binding "seq__49" + v308 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v309 := v308.FindInternedVar(lang.NewSymbol("seq")) + if v309.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v309))) + } + v310 := v309.Get() + v311 := lang.Apply(v310, []any{v307}) + var v312 any = v311 + _ = v312 + // let binding "first__50" + v313 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v314 := v313.FindInternedVar(lang.NewSymbol("first")) + if v314.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v314))) + } + v315 := v314.Get() + v316 := lang.Apply(v315, []any{v312}) + var v317 any = v316 + _ = v317 + // let binding "seq__49" + v318 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v319 := v318.FindInternedVar(lang.NewSymbol("next")) + if v319.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v319))) + } + v320 := v319.Get() + v321 := lang.Apply(v320, []any{v312}) + var v322 any = v321 + _ = v322 + // let binding "vec__51" + var v323 any = v317 + _ = v323 + // let binding "k" + v324 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v325 := v324.FindInternedVar(lang.NewSymbol("nth")) + if v325.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v325))) + } + v326 := v325.Get() + v327 := lang.Apply(v326, []any{v323, int64(0), nil}) + var v328 any = v327 + _ = v328 + // let binding "v" + v329 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v330 := v329.FindInternedVar(lang.NewSymbol("nth")) + if v330.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v330))) + } + v331 := v330.Get() + v332 := lang.Apply(v331, []any{v323, int64(1), nil}) + var v333 any = v332 + _ = v333 + // let binding "pair" + var v334 any = v323 + _ = v334 + // let binding "etc" + var v335 any = v322 + _ = v335 + var v336 any + v337 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v338 := v337.FindInternedVar(lang.NewSymbol("=")) + if v338.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v338))) + } + v339 := v338.Get() + v340 := lang.Apply(v339, []any{v328, lang.NewKeyword("let")}) + if lang.IsTruthy(v340) { + v341 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v342 := v341.FindInternedVar(lang.NewSymbol("seq")) + if v342.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v342))) + } + v343 := v342.Get() + v344 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v345 := v344.FindInternedVar(lang.NewSymbol("concat")) + if v345.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v345))) + } + v346 := v345.Get() + v347 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v348 := v347.FindInternedVar(lang.NewSymbol("list")) + if v348.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v348))) + } + v349 := v348.Get() + v350 := lang.Apply(v349, []any{lang.NewSymbol("glojure.core/let")}) + v351 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v352 := v351.FindInternedVar(lang.NewSymbol("list")) + if v352.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v352))) + } + v353 := v352.Get() + v354 := lang.Apply(v353, []any{v333}) + v355 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v356 := v355.FindInternedVar(lang.NewSymbol("list")) + if v356.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v356))) + } + v357 := v356.Get() + v358 := lang.Apply(v304, []any{v335}) + v359 := lang.Apply(v357, []any{v358}) + v360 := lang.Apply(v346, []any{v350, v354, v359}) + v361 := lang.Apply(v343, []any{v360}) + v336 = v361 + } else { + var v362 any + v363 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v364 := v363.FindInternedVar(lang.NewSymbol("=")) + if v364.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v364))) + } + v365 := v364.Get() + v366 := lang.Apply(v365, []any{v328, lang.NewKeyword("while")}) + if lang.IsTruthy(v366) { + v367 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v368 := v367.FindInternedVar(lang.NewSymbol("seq")) + if v368.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v368))) + } + v369 := v368.Get() + v370 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v371 := v370.FindInternedVar(lang.NewSymbol("concat")) + if v371.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v371))) + } + v372 := v371.Get() + v373 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v374 := v373.FindInternedVar(lang.NewSymbol("list")) + if v374.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v374))) + } + v375 := v374.Get() + v376 := lang.Apply(v375, []any{lang.NewSymbol("glojure.core/when")}) + v377 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v378 := v377.FindInternedVar(lang.NewSymbol("list")) + if v378.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v378))) + } + v379 := v378.Get() + v380 := lang.Apply(v379, []any{v333}) + v381 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v382 := v381.FindInternedVar(lang.NewSymbol("list")) + if v382.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v382))) + } + v383 := v382.Get() + v384 := lang.Apply(v304, []any{v335}) + v385 := lang.Apply(v383, []any{v384}) + v386 := lang.Apply(v372, []any{v376, v380, v385}) + v387 := lang.Apply(v369, []any{v386}) + v362 = v387 + } else { + var v388 any + v389 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v390 := v389.FindInternedVar(lang.NewSymbol("=")) + if v390.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v390))) + } + v391 := v390.Get() + v392 := lang.Apply(v391, []any{v328, lang.NewKeyword("when")}) + if lang.IsTruthy(v392) { + v393 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v394 := v393.FindInternedVar(lang.NewSymbol("seq")) + if v394.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v394))) + } + v395 := v394.Get() + v396 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v397 := v396.FindInternedVar(lang.NewSymbol("concat")) + if v397.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v397))) + } + v398 := v397.Get() + v399 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v400 := v399.FindInternedVar(lang.NewSymbol("list")) + if v400.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v400))) + } + v401 := v400.Get() + v402 := lang.Apply(v401, []any{lang.NewSymbol("if")}) + v403 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v404 := v403.FindInternedVar(lang.NewSymbol("list")) + if v404.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v404))) + } + v405 := v404.Get() + v406 := lang.Apply(v405, []any{v333}) + v407 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v408 := v407.FindInternedVar(lang.NewSymbol("list")) + if v408.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v408))) + } + v409 := v408.Get() + v410 := lang.Apply(v304, []any{v335}) + v411 := lang.Apply(v409, []any{v410}) + v412 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v413 := v412.FindInternedVar(lang.NewSymbol("list")) + if v413.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v413))) + } + v414 := v413.Get() + v415 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v416 := v415.FindInternedVar(lang.NewSymbol("seq")) + if v416.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v416))) + } + v417 := v416.Get() + v418 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v419 := v418.FindInternedVar(lang.NewSymbol("concat")) + if v419.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v419))) + } + v420 := v419.Get() + v421 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v422 := v421.FindInternedVar(lang.NewSymbol("list")) + if v422.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v422))) + } + v423 := v422.Get() + v424 := lang.Apply(v423, []any{lang.NewSymbol("recur")}) + v425 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v426 := v425.FindInternedVar(lang.NewSymbol("list")) + if v426.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v426))) + } + v427 := v426.Get() + v428 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v429 := v428.FindInternedVar(lang.NewSymbol("seq")) + if v429.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v429))) + } + v430 := v429.Get() + v431 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v432 := v431.FindInternedVar(lang.NewSymbol("concat")) + if v432.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v432))) + } + v433 := v432.Get() + v434 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v435 := v434.FindInternedVar(lang.NewSymbol("list")) + if v435.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v435))) + } + v436 := v435.Get() + v437 := lang.Apply(v436, []any{lang.NewSymbol("glojure.core/unchecked-inc")}) + v438 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v439 := v438.FindInternedVar(lang.NewSymbol("list")) + if v439.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v439))) + } + v440 := v439.Get() + v441 := lang.Apply(v440, []any{v297}) + v442 := lang.Apply(v433, []any{v437, v441}) + v443 := lang.Apply(v430, []any{v442}) + v444 := lang.Apply(v427, []any{v443}) + v445 := lang.Apply(v420, []any{v424, v444}) + v446 := lang.Apply(v417, []any{v445}) + v447 := lang.Apply(v414, []any{v446}) + v448 := lang.Apply(v398, []any{v402, v406, v411, v447}) + v449 := lang.Apply(v395, []any{v448}) + v388 = v449 + } else { + var v450 any + v451 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v452 := v451.FindInternedVar(lang.NewSymbol("keyword?")) + if v452.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v452))) + } + v453 := v452.Get() + v454 := lang.Apply(v453, []any{v328}) + if lang.IsTruthy(v454) { + v455 := lang.Apply(v63, []any{"Invalid 'for' keyword ", v328}) + v450 = v455 + } else { + var v456 any + if lang.IsTruthy(lang.NewKeyword("else")) { + v457 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v458 := v457.FindInternedVar(lang.NewSymbol("seq")) + if v458.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v458))) + } + v459 := v458.Get() + v460 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v461 := v460.FindInternedVar(lang.NewSymbol("concat")) + if v461.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v461))) + } + v462 := v461.Get() + v463 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v464 := v463.FindInternedVar(lang.NewSymbol("list")) + if v464.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v464))) + } + v465 := v464.Get() + v466 := lang.Apply(v465, []any{lang.NewSymbol("do")}) + v467 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v468 := v467.FindInternedVar(lang.NewSymbol("list")) + if v468.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v468))) + } + v469 := v468.Get() + v470 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v471 := v470.FindInternedVar(lang.NewSymbol("seq")) + if v471.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v471))) + } + v472 := v471.Get() + v473 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v474 := v473.FindInternedVar(lang.NewSymbol("concat")) + if v474.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v474))) + } + v475 := v474.Get() + v476 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v477 := v476.FindInternedVar(lang.NewSymbol("list")) + if v477.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v477))) + } + v478 := v477.Get() + v479 := lang.Apply(v478, []any{lang.NewSymbol("glojure.core/chunk-append")}) + v480 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v481 := v480.FindInternedVar(lang.NewSymbol("list")) + if v481.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v481))) + } + v482 := v481.Get() + v483 := lang.Apply(v482, []any{v302}) + v484 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v485 := v484.FindInternedVar(lang.NewSymbol("list")) + if v485.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v485))) + } + v486 := v485.Get() + v487 := lang.Apply(v486, []any{v6}) + v488 := lang.Apply(v475, []any{v479, v483, v487}) + v489 := lang.Apply(v472, []any{v488}) + v490 := lang.Apply(v469, []any{v489}) + v491 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v492 := v491.FindInternedVar(lang.NewSymbol("list")) + if v492.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v492))) + } + v493 := v492.Get() + v494 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v495 := v494.FindInternedVar(lang.NewSymbol("seq")) + if v495.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v495))) + } + v496 := v495.Get() + v497 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v498 := v497.FindInternedVar(lang.NewSymbol("concat")) + if v498.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v498))) + } + v499 := v498.Get() + v500 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v501 := v500.FindInternedVar(lang.NewSymbol("list")) + if v501.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v501))) + } + v502 := v501.Get() + v503 := lang.Apply(v502, []any{lang.NewSymbol("recur")}) + v504 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v505 := v504.FindInternedVar(lang.NewSymbol("list")) + if v505.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v505))) + } + v506 := v505.Get() + v507 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v508 := v507.FindInternedVar(lang.NewSymbol("seq")) + if v508.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v508))) + } + v509 := v508.Get() + v510 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v511 := v510.FindInternedVar(lang.NewSymbol("concat")) + if v511.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v511))) + } + v512 := v511.Get() + v513 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v514 := v513.FindInternedVar(lang.NewSymbol("list")) + if v514.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v514))) + } + v515 := v514.Get() + v516 := lang.Apply(v515, []any{lang.NewSymbol("glojure.core/unchecked-inc")}) + v517 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v518 := v517.FindInternedVar(lang.NewSymbol("list")) + if v518.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v518))) + } + v519 := v518.Get() + v520 := lang.Apply(v519, []any{v297}) + v521 := lang.Apply(v512, []any{v516, v520}) + v522 := lang.Apply(v509, []any{v521}) + v523 := lang.Apply(v506, []any{v522}) + v524 := lang.Apply(v499, []any{v503, v523}) + v525 := lang.Apply(v496, []any{v524}) + v526 := lang.Apply(v493, []any{v525}) + v527 := lang.Apply(v462, []any{v466, v490, v526}) + v528 := lang.Apply(v459, []any{v527}) + v456 = v528 + } else { + v456 = nil + } + v450 = v456 + } + v388 = v450 + } + v362 = v388 + } + v336 = v362 + } + v306 = v336 + } // end let + return v306 + }) + v304 := v303 + _ = v304 + } + v304 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4698), lang.NewKeyword("column"), int(39), lang.NewKeyword("end-line"), int(4710), lang.NewKeyword("end-column"), int(79)) + v305, err := lang.WithMeta(v303, v304.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v306 any = v305 + _ = v306 + v307 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v308 := v307.FindInternedVar(lang.NewSymbol("seq")) + if v308.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v308))) + } + v309 := v308.Get() + v310 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v311 := v310.FindInternedVar(lang.NewSymbol("concat")) + if v311.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v311))) + } + v312 := v311.Get() + v313 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v314 := v313.FindInternedVar(lang.NewSymbol("list")) + if v314.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v314))) + } + v315 := v314.Get() + v316 := lang.Apply(v315, []any{lang.NewSymbol("glojure.core/fn")}) + v317 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v318 := v317.FindInternedVar(lang.NewSymbol("list")) + if v318.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v318))) + } + v319 := v318.Get() + v320 := lang.Apply(v319, []any{v135}) + v321 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v322 := v321.FindInternedVar(lang.NewSymbol("list")) + if v322.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v322))) + } + v323 := v322.Get() + v324 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v325 := v324.FindInternedVar(lang.NewSymbol("apply")) + if v325.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v325))) + } + v326 := v325.Get() + v327 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v328 := v327.FindInternedVar(lang.NewSymbol("vector")) + if v328.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v328))) + } + v329 := v328.Get() + v330 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v331 := v330.FindInternedVar(lang.NewSymbol("seq")) + if v331.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v331))) + } + v332 := v331.Get() + v333 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v334 := v333.FindInternedVar(lang.NewSymbol("concat")) + if v334.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v334))) + } + v335 := v334.Get() + v336 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v337 := v336.FindInternedVar(lang.NewSymbol("list")) + if v337.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v337))) + } + v338 := v337.Get() + v339 := lang.Apply(v338, []any{v140}) + v340 := lang.Apply(v335, []any{v339}) + v341 := lang.Apply(v332, []any{v340}) + v342 := lang.Apply(v326, []any{v329, v341}) + v343 := lang.Apply(v323, []any{v342}) + v344 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v345 := v344.FindInternedVar(lang.NewSymbol("list")) + if v345.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v345))) + } + v346 := v345.Get() + v347 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v348 := v347.FindInternedVar(lang.NewSymbol("seq")) + if v348.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v348))) + } + v349 := v348.Get() + v350 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v351 := v350.FindInternedVar(lang.NewSymbol("concat")) + if v351.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v351))) + } + v352 := v351.Get() + v353 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v354 := v353.FindInternedVar(lang.NewSymbol("list")) + if v354.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v354))) + } + v355 := v354.Get() + v356 := lang.Apply(v355, []any{lang.NewSymbol("glojure.core/lazy-seq")}) + v357 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v358 := v357.FindInternedVar(lang.NewSymbol("list")) + if v358.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v358))) + } + v359 := v358.Get() + v360 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v361 := v360.FindInternedVar(lang.NewSymbol("seq")) + if v361.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v361))) + } + v362 := v361.Get() + v363 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v364 := v363.FindInternedVar(lang.NewSymbol("concat")) + if v364.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v364))) + } + v365 := v364.Get() + v366 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v367 := v366.FindInternedVar(lang.NewSymbol("list")) + if v367.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v367))) + } + v368 := v367.Get() + v369 := lang.Apply(v368, []any{lang.NewSymbol("glojure.core/loop")}) + v370 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v371 := v370.FindInternedVar(lang.NewSymbol("list")) + if v371.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v371))) + } + v372 := v371.Get() + v373 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v374 := v373.FindInternedVar(lang.NewSymbol("apply")) + if v374.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v374))) + } + v375 := v374.Get() + v376 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v377 := v376.FindInternedVar(lang.NewSymbol("vector")) + if v377.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v377))) + } + v378 := v377.Get() + v379 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v380 := v379.FindInternedVar(lang.NewSymbol("seq")) + if v380.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v380))) + } + v381 := v380.Get() + v382 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v383 := v382.FindInternedVar(lang.NewSymbol("concat")) + if v383.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v383))) + } + v384 := v383.Get() + v385 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v386 := v385.FindInternedVar(lang.NewSymbol("list")) + if v386.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v386))) + } + v387 := v386.Get() + v388 := lang.Apply(v387, []any{v140}) + v389 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v390 := v389.FindInternedVar(lang.NewSymbol("list")) + if v390.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v390))) + } + v391 := v390.Get() + v392 := lang.Apply(v391, []any{v140}) + v393 := lang.Apply(v384, []any{v388, v392}) + v394 := lang.Apply(v381, []any{v393}) + v395 := lang.Apply(v375, []any{v378, v394}) + v396 := lang.Apply(v372, []any{v395}) + v397 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v398 := v397.FindInternedVar(lang.NewSymbol("list")) + if v398.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v398))) + } + v399 := v398.Get() + v400 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v401 := v400.FindInternedVar(lang.NewSymbol("seq")) + if v401.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v401))) + } + v402 := v401.Get() + v403 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v404 := v403.FindInternedVar(lang.NewSymbol("concat")) + if v404.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v404))) + } + v405 := v404.Get() + v406 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v407 := v406.FindInternedVar(lang.NewSymbol("list")) + if v407.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v407))) + } + v408 := v407.Get() + v409 := lang.Apply(v408, []any{lang.NewSymbol("glojure.core/when-let")}) + v410 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v411 := v410.FindInternedVar(lang.NewSymbol("list")) + if v411.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v411))) + } + v412 := v411.Get() + v413 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v414 := v413.FindInternedVar(lang.NewSymbol("apply")) + if v414.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v414))) + } + v415 := v414.Get() + v416 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v417 := v416.FindInternedVar(lang.NewSymbol("vector")) + if v417.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v417))) + } + v418 := v417.Get() + v419 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v420 := v419.FindInternedVar(lang.NewSymbol("seq")) + if v420.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v420))) + } + v421 := v420.Get() + v422 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v423 := v422.FindInternedVar(lang.NewSymbol("concat")) + if v423.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v423))) + } + v424 := v423.Get() + v425 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v426 := v425.FindInternedVar(lang.NewSymbol("list")) + if v426.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v426))) + } + v427 := v426.Get() + v428 := lang.Apply(v427, []any{v140}) + v429 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v430 := v429.FindInternedVar(lang.NewSymbol("list")) + if v430.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v430))) + } + v431 := v430.Get() + v432 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v433 := v432.FindInternedVar(lang.NewSymbol("seq")) + if v433.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v433))) + } + v434 := v433.Get() + v435 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v436 := v435.FindInternedVar(lang.NewSymbol("concat")) + if v436.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v436))) + } + v437 := v436.Get() + v438 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v439 := v438.FindInternedVar(lang.NewSymbol("list")) + if v439.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v439))) + } + v440 := v439.Get() + v441 := lang.Apply(v440, []any{lang.NewSymbol("glojure.core/seq")}) + v442 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v443 := v442.FindInternedVar(lang.NewSymbol("list")) + if v443.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v443))) + } + v444 := v443.Get() + v445 := lang.Apply(v444, []any{v140}) + v446 := lang.Apply(v437, []any{v441, v445}) + v447 := lang.Apply(v434, []any{v446}) + v448 := lang.Apply(v431, []any{v447}) + v449 := lang.Apply(v424, []any{v428, v448}) + v450 := lang.Apply(v421, []any{v449}) + v451 := lang.Apply(v415, []any{v418, v450}) + v452 := lang.Apply(v412, []any{v451}) + v453 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v454 := v453.FindInternedVar(lang.NewSymbol("list")) + if v454.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v454))) + } + v455 := v454.Get() + v456 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v457 := v456.FindInternedVar(lang.NewSymbol("seq")) + if v457.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v457))) + } + v458 := v457.Get() + v459 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v460 := v459.FindInternedVar(lang.NewSymbol("concat")) + if v460.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v460))) + } + v461 := v460.Get() + v462 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v463 := v462.FindInternedVar(lang.NewSymbol("list")) + if v463.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v463))) + } + v464 := v463.Get() + v465 := lang.Apply(v464, []any{lang.NewSymbol("if")}) + v466 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v467 := v466.FindInternedVar(lang.NewSymbol("list")) + if v467.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v467))) + } + v468 := v467.Get() + v469 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v470 := v469.FindInternedVar(lang.NewSymbol("seq")) + if v470.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v470))) + } + v471 := v470.Get() + v472 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v473 := v472.FindInternedVar(lang.NewSymbol("concat")) + if v473.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v473))) + } + v474 := v473.Get() + v475 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v476 := v475.FindInternedVar(lang.NewSymbol("list")) + if v476.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v476))) + } + v477 := v476.Get() + v478 := lang.Apply(v477, []any{lang.NewSymbol("glojure.core/chunked-seq?")}) + v479 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v480 := v479.FindInternedVar(lang.NewSymbol("list")) + if v480.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v480))) + } + v481 := v480.Get() + v482 := lang.Apply(v481, []any{v140}) + v483 := lang.Apply(v474, []any{v478, v482}) + v484 := lang.Apply(v471, []any{v483}) + v485 := lang.Apply(v468, []any{v484}) + v486 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v487 := v486.FindInternedVar(lang.NewSymbol("list")) + if v487.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v487))) + } + v488 := v487.Get() + v489 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v490 := v489.FindInternedVar(lang.NewSymbol("seq")) + if v490.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v490))) + } + v491 := v490.Get() + v492 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v493 := v492.FindInternedVar(lang.NewSymbol("concat")) + if v493.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v493))) + } + v494 := v493.Get() + v495 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v496 := v495.FindInternedVar(lang.NewSymbol("list")) + if v496.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v496))) + } + v497 := v496.Get() + v498 := lang.Apply(v497, []any{lang.NewSymbol("glojure.core/let")}) + v499 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v500 := v499.FindInternedVar(lang.NewSymbol("list")) + if v500.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v500))) + } + v501 := v500.Get() + v502 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v503 := v502.FindInternedVar(lang.NewSymbol("apply")) + if v503.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v503))) + } + v504 := v503.Get() + v505 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v506 := v505.FindInternedVar(lang.NewSymbol("vector")) + if v506.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v506))) + } + v507 := v506.Get() + v508 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v509 := v508.FindInternedVar(lang.NewSymbol("seq")) + if v509.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v509))) + } + v510 := v509.Get() + v511 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v512 := v511.FindInternedVar(lang.NewSymbol("concat")) + if v512.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v512))) + } + v513 := v512.Get() + v514 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v515 := v514.FindInternedVar(lang.NewSymbol("list")) + if v515.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v515))) + } + v516 := v515.Get() + v517 := lang.Apply(v516, []any{lang.NewSymbol("c__0__auto__")}) + v518 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v519 := v518.FindInternedVar(lang.NewSymbol("list")) + if v519.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v519))) + } + v520 := v519.Get() + v521 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v522 := v521.FindInternedVar(lang.NewSymbol("seq")) + if v522.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v522))) + } + v523 := v522.Get() + v524 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v525 := v524.FindInternedVar(lang.NewSymbol("concat")) + if v525.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v525))) + } + v526 := v525.Get() + v527 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v528 := v527.FindInternedVar(lang.NewSymbol("list")) + if v528.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v528))) + } + v529 := v528.Get() + v530 := lang.Apply(v529, []any{lang.NewSymbol("glojure.core/chunk-first")}) + v531 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v532 := v531.FindInternedVar(lang.NewSymbol("list")) + if v532.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v532))) + } + v533 := v532.Get() + v534 := lang.Apply(v533, []any{v140}) + v535 := lang.Apply(v526, []any{v530, v534}) + v536 := lang.Apply(v523, []any{v535}) + v537 := lang.Apply(v520, []any{v536}) + v538 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v539 := v538.FindInternedVar(lang.NewSymbol("list")) + if v539.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v539))) + } + v540 := v539.Get() + v541 := lang.Apply(v540, []any{lang.NewSymbol("size__1__auto__")}) + v542 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v543 := v542.FindInternedVar(lang.NewSymbol("list")) + if v543.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v543))) + } + v544 := v543.Get() + v545 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v546 := v545.FindInternedVar(lang.NewSymbol("seq")) + if v546.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v546))) + } + v547 := v546.Get() + v548 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v549 := v548.FindInternedVar(lang.NewSymbol("concat")) + if v549.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v549))) + } + v550 := v549.Get() + v551 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v552 := v551.FindInternedVar(lang.NewSymbol("list")) + if v552.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v552))) + } + v553 := v552.Get() + v554 := lang.Apply(v553, []any{lang.NewSymbol("glojure.core/int")}) + v555 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v556 := v555.FindInternedVar(lang.NewSymbol("list")) + if v556.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v556))) + } + v557 := v556.Get() + v558 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v559 := v558.FindInternedVar(lang.NewSymbol("seq")) + if v559.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v559))) + } + v560 := v559.Get() + v561 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v562 := v561.FindInternedVar(lang.NewSymbol("concat")) + if v562.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v562))) + } + v563 := v562.Get() + v564 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v565 := v564.FindInternedVar(lang.NewSymbol("list")) + if v565.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v565))) + } + v566 := v565.Get() + v567 := lang.Apply(v566, []any{lang.NewSymbol("glojure.core/count")}) + v568 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v569 := v568.FindInternedVar(lang.NewSymbol("list")) + if v569.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v569))) + } + v570 := v569.Get() + v571 := lang.Apply(v570, []any{lang.NewSymbol("c__0__auto__")}) + v572 := lang.Apply(v563, []any{v567, v571}) + v573 := lang.Apply(v560, []any{v572}) + v574 := lang.Apply(v557, []any{v573}) + v575 := lang.Apply(v550, []any{v554, v574}) + v576 := lang.Apply(v547, []any{v575}) + v577 := lang.Apply(v544, []any{v576}) + v578 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v579 := v578.FindInternedVar(lang.NewSymbol("list")) + if v579.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v579))) + } + v580 := v579.Get() + v581 := lang.Apply(v580, []any{v302}) + v582 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v583 := v582.FindInternedVar(lang.NewSymbol("list")) + if v583.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v583))) + } + v584 := v583.Get() + v585 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v586 := v585.FindInternedVar(lang.NewSymbol("seq")) + if v586.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v586))) + } + v587 := v586.Get() + v588 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v589 := v588.FindInternedVar(lang.NewSymbol("concat")) + if v589.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v589))) + } + v590 := v589.Get() + v591 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v592 := v591.FindInternedVar(lang.NewSymbol("list")) + if v592.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v592))) + } + v593 := v592.Get() + v594 := lang.Apply(v593, []any{lang.NewSymbol("glojure.core/chunk-buffer")}) + v595 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v596 := v595.FindInternedVar(lang.NewSymbol("list")) + if v596.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v596))) + } + v597 := v596.Get() + v598 := lang.Apply(v597, []any{lang.NewSymbol("size__1__auto__")}) + v599 := lang.Apply(v590, []any{v594, v598}) + v600 := lang.Apply(v587, []any{v599}) + v601 := lang.Apply(v584, []any{v600}) + v602 := lang.Apply(v513, []any{v517, v537, v541, v577, v581, v601}) + v603 := lang.Apply(v510, []any{v602}) + v604 := lang.Apply(v504, []any{v507, v603}) + v605 := lang.Apply(v501, []any{v604}) + v606 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v607 := v606.FindInternedVar(lang.NewSymbol("list")) + if v607.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v607))) + } + v608 := v607.Get() + v609 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v610 := v609.FindInternedVar(lang.NewSymbol("seq")) + if v610.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v610))) + } + v611 := v610.Get() + v612 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v613 := v612.FindInternedVar(lang.NewSymbol("concat")) + if v613.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v613))) + } + v614 := v613.Get() + v615 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v616 := v615.FindInternedVar(lang.NewSymbol("list")) + if v616.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v616))) + } + v617 := v616.Get() + v618 := lang.Apply(v617, []any{lang.NewSymbol("if")}) + v619 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v620 := v619.FindInternedVar(lang.NewSymbol("list")) + if v620.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v620))) + } + v621 := v620.Get() + v622 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v623 := v622.FindInternedVar(lang.NewSymbol("seq")) + if v623.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v623))) + } + v624 := v623.Get() + v625 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v626 := v625.FindInternedVar(lang.NewSymbol("concat")) + if v626.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v626))) + } + v627 := v626.Get() + v628 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v629 := v628.FindInternedVar(lang.NewSymbol("list")) + if v629.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v629))) + } + v630 := v629.Get() + v631 := lang.Apply(v630, []any{lang.NewSymbol("glojure.core/loop")}) + v632 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v633 := v632.FindInternedVar(lang.NewSymbol("list")) + if v633.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v633))) + } + v634 := v633.Get() + v635 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v636 := v635.FindInternedVar(lang.NewSymbol("apply")) + if v636.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v636))) + } + v637 := v636.Get() + v638 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v639 := v638.FindInternedVar(lang.NewSymbol("vector")) + if v639.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v639))) + } + v640 := v639.Get() + v641 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v642 := v641.FindInternedVar(lang.NewSymbol("seq")) + if v642.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v642))) + } + v643 := v642.Get() + v644 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v645 := v644.FindInternedVar(lang.NewSymbol("concat")) + if v645.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v645))) + } + v646 := v645.Get() + v647 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v648 := v647.FindInternedVar(lang.NewSymbol("list")) + if v648.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v648))) + } + v649 := v648.Get() + v650 := lang.Apply(v649, []any{v297}) + v651 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v652 := v651.FindInternedVar(lang.NewSymbol("list")) + if v652.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v652))) + } + v653 := v652.Get() + v654 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v655 := v654.FindInternedVar(lang.NewSymbol("seq")) + if v655.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v655))) + } + v656 := v655.Get() + v657 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v658 := v657.FindInternedVar(lang.NewSymbol("concat")) + if v658.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v658))) + } + v659 := v658.Get() + v660 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v661 := v660.FindInternedVar(lang.NewSymbol("list")) + if v661.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v661))) + } + v662 := v661.Get() + v663 := lang.Apply(v662, []any{lang.NewSymbol("glojure.core/int")}) + v664 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v665 := v664.FindInternedVar(lang.NewSymbol("list")) + if v665.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v665))) + } + v666 := v665.Get() + v667 := lang.Apply(v666, []any{int64(0)}) + v668 := lang.Apply(v659, []any{v663, v667}) + v669 := lang.Apply(v656, []any{v668}) + v670 := lang.Apply(v653, []any{v669}) + v671 := lang.Apply(v646, []any{v650, v670}) + v672 := lang.Apply(v643, []any{v671}) + v673 := lang.Apply(v637, []any{v640, v672}) + v674 := lang.Apply(v634, []any{v673}) + v675 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v676 := v675.FindInternedVar(lang.NewSymbol("list")) + if v676.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v676))) + } + v677 := v676.Get() + v678 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v679 := v678.FindInternedVar(lang.NewSymbol("seq")) + if v679.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v679))) + } + v680 := v679.Get() + v681 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v682 := v681.FindInternedVar(lang.NewSymbol("concat")) + if v682.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v682))) + } + v683 := v682.Get() + v684 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v685 := v684.FindInternedVar(lang.NewSymbol("list")) + if v685.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v685))) + } + v686 := v685.Get() + v687 := lang.Apply(v686, []any{lang.NewSymbol("if")}) + v688 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v689 := v688.FindInternedVar(lang.NewSymbol("list")) + if v689.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v689))) + } + v690 := v689.Get() + v691 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v692 := v691.FindInternedVar(lang.NewSymbol("seq")) + if v692.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v692))) + } + v693 := v692.Get() + v694 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v695 := v694.FindInternedVar(lang.NewSymbol("concat")) + if v695.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v695))) + } + v696 := v695.Get() + v697 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v698 := v697.FindInternedVar(lang.NewSymbol("list")) + if v698.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v698))) + } + v699 := v698.Get() + v700 := lang.Apply(v699, []any{lang.NewSymbol("glojure.core/<")}) + v701 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v702 := v701.FindInternedVar(lang.NewSymbol("list")) + if v702.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v702))) + } + v703 := v702.Get() + v704 := lang.Apply(v703, []any{v297}) + v705 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v706 := v705.FindInternedVar(lang.NewSymbol("list")) + if v706.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v706))) + } + v707 := v706.Get() + v708 := lang.Apply(v707, []any{lang.NewSymbol("size__1__auto__")}) + v709 := lang.Apply(v696, []any{v700, v704, v708}) + v710 := lang.Apply(v693, []any{v709}) + v711 := lang.Apply(v690, []any{v710}) + v712 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v713 := v712.FindInternedVar(lang.NewSymbol("list")) + if v713.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v713))) + } + v714 := v713.Get() + v715 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v716 := v715.FindInternedVar(lang.NewSymbol("seq")) + if v716.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v716))) + } + v717 := v716.Get() + v718 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v719 := v718.FindInternedVar(lang.NewSymbol("concat")) + if v719.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v719))) + } + v720 := v719.Get() + v721 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v722 := v721.FindInternedVar(lang.NewSymbol("list")) + if v722.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v722))) + } + v723 := v722.Get() + v724 := lang.Apply(v723, []any{lang.NewSymbol("glojure.core/let")}) + v725 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v726 := v725.FindInternedVar(lang.NewSymbol("list")) + if v726.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v726))) + } + v727 := v726.Get() + v728 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v729 := v728.FindInternedVar(lang.NewSymbol("apply")) + if v729.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v729))) + } + v730 := v729.Get() + v731 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v732 := v731.FindInternedVar(lang.NewSymbol("vector")) + if v732.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v732))) + } + v733 := v732.Get() + v734 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v735 := v734.FindInternedVar(lang.NewSymbol("seq")) + if v735.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v735))) + } + v736 := v735.Get() + v737 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v738 := v737.FindInternedVar(lang.NewSymbol("concat")) + if v738.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v738))) + } + v739 := v738.Get() + v740 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v741 := v740.FindInternedVar(lang.NewSymbol("list")) + if v741.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v741))) + } + v742 := v741.Get() + v743 := lang.Apply(v742, []any{v100}) + v744 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v745 := v744.FindInternedVar(lang.NewSymbol("list")) + if v745.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v745))) + } + v746 := v745.Get() + v747 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v748 := v747.FindInternedVar(lang.NewSymbol("seq")) + if v748.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v748))) + } + v749 := v748.Get() + v750 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v751 := v750.FindInternedVar(lang.NewSymbol("concat")) + if v751.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v751))) + } + v752 := v751.Get() + v753 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v754 := v753.FindInternedVar(lang.NewSymbol("list")) + if v754.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v754))) + } + v755 := v754.Get() + v756 := lang.Apply(v755, []any{lang.NewSymbol(".nth")}) + v757 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v758 := v757.FindInternedVar(lang.NewSymbol("list")) + if v758.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v758))) + } + v759 := v758.Get() + v760 := lang.Apply(v759, []any{lang.NewSymbol("c__0__auto__")}) + v761 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v762 := v761.FindInternedVar(lang.NewSymbol("list")) + if v762.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v762))) + } + v763 := v762.Get() + v764 := lang.Apply(v763, []any{v297}) + v765 := lang.Apply(v752, []any{v756, v760, v764}) + v766 := lang.Apply(v749, []any{v765}) + v767 := lang.Apply(v746, []any{v766}) + v768 := lang.Apply(v739, []any{v743, v767}) + v769 := lang.Apply(v736, []any{v768}) + v770 := lang.Apply(v730, []any{v733, v769}) + v771 := lang.Apply(v727, []any{v770}) + v772 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v773 := v772.FindInternedVar(lang.NewSymbol("list")) + if v773.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v773))) + } + v774 := v773.Get() + v775 := lang.Apply(v306, []any{v112}) + v776 := lang.Apply(v774, []any{v775}) + v777 := lang.Apply(v720, []any{v724, v771, v776}) + v778 := lang.Apply(v717, []any{v777}) + v779 := lang.Apply(v714, []any{v778}) + v780 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v781 := v780.FindInternedVar(lang.NewSymbol("list")) + if v781.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v781))) + } + v782 := v781.Get() + v783 := lang.Apply(v782, []any{true}) + v784 := lang.Apply(v683, []any{v687, v711, v779, v783}) + v785 := lang.Apply(v680, []any{v784}) + v786 := lang.Apply(v677, []any{v785}) + v787 := lang.Apply(v627, []any{v631, v674, v786}) + v788 := lang.Apply(v624, []any{v787}) + v789 := lang.Apply(v621, []any{v788}) + v790 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v791 := v790.FindInternedVar(lang.NewSymbol("list")) + if v791.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v791))) + } + v792 := v791.Get() + v793 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v794 := v793.FindInternedVar(lang.NewSymbol("seq")) + if v794.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v794))) + } + v795 := v794.Get() + v796 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v797 := v796.FindInternedVar(lang.NewSymbol("concat")) + if v797.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v797))) + } + v798 := v797.Get() + v799 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v800 := v799.FindInternedVar(lang.NewSymbol("list")) + if v800.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v800))) + } + v801 := v800.Get() + v802 := lang.Apply(v801, []any{lang.NewSymbol("glojure.core/chunk-cons")}) + v803 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v804 := v803.FindInternedVar(lang.NewSymbol("list")) + if v804.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v804))) + } + v805 := v804.Get() + v806 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v807 := v806.FindInternedVar(lang.NewSymbol("seq")) + if v807.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v807))) + } + v808 := v807.Get() + v809 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v810 := v809.FindInternedVar(lang.NewSymbol("concat")) + if v810.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v810))) + } + v811 := v810.Get() + v812 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v813 := v812.FindInternedVar(lang.NewSymbol("list")) + if v813.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v813))) + } + v814 := v813.Get() + v815 := lang.Apply(v814, []any{lang.NewSymbol("glojure.core/chunk")}) + v816 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v817 := v816.FindInternedVar(lang.NewSymbol("list")) + if v817.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v817))) + } + v818 := v817.Get() + v819 := lang.Apply(v818, []any{v302}) + v820 := lang.Apply(v811, []any{v815, v819}) + v821 := lang.Apply(v808, []any{v820}) + v822 := lang.Apply(v805, []any{v821}) + v823 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v824 := v823.FindInternedVar(lang.NewSymbol("list")) + if v824.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v824))) + } + v825 := v824.Get() + v826 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v827 := v826.FindInternedVar(lang.NewSymbol("seq")) + if v827.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v827))) + } + v828 := v827.Get() + v829 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v830 := v829.FindInternedVar(lang.NewSymbol("concat")) + if v830.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v830))) + } + v831 := v830.Get() + v832 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v833 := v832.FindInternedVar(lang.NewSymbol("list")) + if v833.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v833))) + } + v834 := v833.Get() + v835 := lang.Apply(v834, []any{v135}) + v836 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v837 := v836.FindInternedVar(lang.NewSymbol("list")) + if v837.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v837))) + } + v838 := v837.Get() + v839 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v840 := v839.FindInternedVar(lang.NewSymbol("seq")) + if v840.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v840))) + } + v841 := v840.Get() + v842 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v843 := v842.FindInternedVar(lang.NewSymbol("concat")) + if v843.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v843))) + } + v844 := v843.Get() + v845 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v846 := v845.FindInternedVar(lang.NewSymbol("list")) + if v846.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v846))) + } + v847 := v846.Get() + v848 := lang.Apply(v847, []any{lang.NewSymbol("glojure.core/chunk-rest")}) + v849 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v850 := v849.FindInternedVar(lang.NewSymbol("list")) + if v850.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v850))) + } + v851 := v850.Get() + v852 := lang.Apply(v851, []any{v140}) + v853 := lang.Apply(v844, []any{v848, v852}) + v854 := lang.Apply(v841, []any{v853}) + v855 := lang.Apply(v838, []any{v854}) + v856 := lang.Apply(v831, []any{v835, v855}) + v857 := lang.Apply(v828, []any{v856}) + v858 := lang.Apply(v825, []any{v857}) + v859 := lang.Apply(v798, []any{v802, v822, v858}) + v860 := lang.Apply(v795, []any{v859}) + v861 := lang.Apply(v792, []any{v860}) + v862 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v863 := v862.FindInternedVar(lang.NewSymbol("list")) + if v863.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v863))) + } + v864 := v863.Get() + v865 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v866 := v865.FindInternedVar(lang.NewSymbol("seq")) + if v866.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v866))) + } + v867 := v866.Get() + v868 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v869 := v868.FindInternedVar(lang.NewSymbol("concat")) + if v869.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v869))) + } + v870 := v869.Get() + v871 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v872 := v871.FindInternedVar(lang.NewSymbol("list")) + if v872.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v872))) + } + v873 := v872.Get() + v874 := lang.Apply(v873, []any{lang.NewSymbol("glojure.core/chunk-cons")}) + v875 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v876 := v875.FindInternedVar(lang.NewSymbol("list")) + if v876.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v876))) + } + v877 := v876.Get() + v878 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v879 := v878.FindInternedVar(lang.NewSymbol("seq")) + if v879.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v879))) + } + v880 := v879.Get() + v881 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v882 := v881.FindInternedVar(lang.NewSymbol("concat")) + if v882.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v882))) + } + v883 := v882.Get() + v884 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v885 := v884.FindInternedVar(lang.NewSymbol("list")) + if v885.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v885))) + } + v886 := v885.Get() + v887 := lang.Apply(v886, []any{lang.NewSymbol("glojure.core/chunk")}) + v888 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v889 := v888.FindInternedVar(lang.NewSymbol("list")) + if v889.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v889))) + } + v890 := v889.Get() + v891 := lang.Apply(v890, []any{v302}) + v892 := lang.Apply(v883, []any{v887, v891}) + v893 := lang.Apply(v880, []any{v892}) + v894 := lang.Apply(v877, []any{v893}) + v895 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v896 := v895.FindInternedVar(lang.NewSymbol("list")) + if v896.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v896))) + } + v897 := v896.Get() + v898 := lang.Apply(v897, []any{nil}) + v899 := lang.Apply(v870, []any{v874, v894, v898}) + v900 := lang.Apply(v867, []any{v899}) + v901 := lang.Apply(v864, []any{v900}) + v902 := lang.Apply(v614, []any{v618, v789, v861, v901}) + v903 := lang.Apply(v611, []any{v902}) + v904 := lang.Apply(v608, []any{v903}) + v905 := lang.Apply(v494, []any{v498, v605, v904}) + v906 := lang.Apply(v491, []any{v905}) + v907 := lang.Apply(v488, []any{v906}) + v908 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v909 := v908.FindInternedVar(lang.NewSymbol("list")) + if v909.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v909))) + } + v910 := v909.Get() + v911 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v912 := v911.FindInternedVar(lang.NewSymbol("seq")) + if v912.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v912))) + } + v913 := v912.Get() + v914 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v915 := v914.FindInternedVar(lang.NewSymbol("concat")) + if v915.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v915))) + } + v916 := v915.Get() + v917 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v918 := v917.FindInternedVar(lang.NewSymbol("list")) + if v918.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v918))) + } + v919 := v918.Get() + v920 := lang.Apply(v919, []any{lang.NewSymbol("glojure.core/let")}) + v921 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v922 := v921.FindInternedVar(lang.NewSymbol("list")) + if v922.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v922))) + } + v923 := v922.Get() + v924 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v925 := v924.FindInternedVar(lang.NewSymbol("apply")) + if v925.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v925))) + } + v926 := v925.Get() + v927 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v928 := v927.FindInternedVar(lang.NewSymbol("vector")) + if v928.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v928))) + } + v929 := v928.Get() + v930 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v931 := v930.FindInternedVar(lang.NewSymbol("seq")) + if v931.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v931))) + } + v932 := v931.Get() + v933 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v934 := v933.FindInternedVar(lang.NewSymbol("concat")) + if v934.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v934))) + } + v935 := v934.Get() + v936 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v937 := v936.FindInternedVar(lang.NewSymbol("list")) + if v937.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v937))) + } + v938 := v937.Get() + v939 := lang.Apply(v938, []any{v100}) + v940 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v941 := v940.FindInternedVar(lang.NewSymbol("list")) + if v941.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v941))) + } + v942 := v941.Get() + v943 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v944 := v943.FindInternedVar(lang.NewSymbol("seq")) + if v944.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v944))) + } + v945 := v944.Get() + v946 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v947 := v946.FindInternedVar(lang.NewSymbol("concat")) + if v947.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v947))) + } + v948 := v947.Get() + v949 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v950 := v949.FindInternedVar(lang.NewSymbol("list")) + if v950.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v950))) + } + v951 := v950.Get() + v952 := lang.Apply(v951, []any{lang.NewSymbol("glojure.core/first")}) + v953 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v954 := v953.FindInternedVar(lang.NewSymbol("list")) + if v954.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v954))) + } + v955 := v954.Get() + v956 := lang.Apply(v955, []any{v140}) + v957 := lang.Apply(v948, []any{v952, v956}) + v958 := lang.Apply(v945, []any{v957}) + v959 := lang.Apply(v942, []any{v958}) + v960 := lang.Apply(v935, []any{v939, v959}) + v961 := lang.Apply(v932, []any{v960}) + v962 := lang.Apply(v926, []any{v929, v961}) + v963 := lang.Apply(v923, []any{v962}) + v964 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v965 := v964.FindInternedVar(lang.NewSymbol("list")) + if v965.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v965))) + } + v966 := v965.Get() + v967 := lang.Apply(v144, []any{v112}) + v968 := lang.Apply(v966, []any{v967}) + v969 := lang.Apply(v916, []any{v920, v963, v968}) + v970 := lang.Apply(v913, []any{v969}) + v971 := lang.Apply(v910, []any{v970}) + v972 := lang.Apply(v461, []any{v465, v485, v907, v971}) + v973 := lang.Apply(v458, []any{v972}) + v974 := lang.Apply(v455, []any{v973}) + v975 := lang.Apply(v405, []any{v409, v452, v974}) + v976 := lang.Apply(v402, []any{v975}) + v977 := lang.Apply(v399, []any{v976}) + v978 := lang.Apply(v365, []any{v369, v396, v977}) + v979 := lang.Apply(v362, []any{v978}) + v980 := lang.Apply(v359, []any{v979}) + v981 := lang.Apply(v352, []any{v356, v980}) + v982 := lang.Apply(v349, []any{v981}) + v983 := lang.Apply(v346, []any{v982}) + v984 := lang.Apply(v312, []any{v316, v320, v343, v983}) + v985 := lang.Apply(v309, []any{v984}) + v292 = v985 + } // end let + v145 = v292 + } + v130 = v145 + } // end let + v67 = v130 + } // end let + return v67 + }) + v65 := v64 + _ = v65 + } + v65 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4668), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(4729), lang.NewKeyword("end-column"), int(68)) + v66, err := lang.WithMeta(v64, v65.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v67 any = v66 + _ = v67 + v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v69 := v68.FindInternedVar(lang.NewSymbol("seq")) + if v69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) + } + v70 := v69.Get() + v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v72 := v71.FindInternedVar(lang.NewSymbol("concat")) + if v72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) + } + v73 := v72.Get() + v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v75 := v74.FindInternedVar(lang.NewSymbol("list")) + if v75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) + } + v76 := v75.Get() + v77 := lang.Apply(v76, []any{lang.NewSymbol("glojure.core/let")}) + v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v79 := v78.FindInternedVar(lang.NewSymbol("list")) + if v79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) + } + v80 := v79.Get() + v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v82 := v81.FindInternedVar(lang.NewSymbol("apply")) + if v82.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) + } + v83 := v82.Get() + v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v85 := v84.FindInternedVar(lang.NewSymbol("vector")) + if v85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) + } + v86 := v85.Get() + v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v88 := v87.FindInternedVar(lang.NewSymbol("seq")) + if v88.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) + } + v89 := v88.Get() + v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v91 := v90.FindInternedVar(lang.NewSymbol("concat")) + if v91.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) + } + v92 := v91.Get() + v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v94 := v93.FindInternedVar(lang.NewSymbol("list")) + if v94.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) + } + v95 := v94.Get() + v96 := lang.Apply(v95, []any{lang.NewSymbol("iter__0__auto__")}) + v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v98 := v97.FindInternedVar(lang.NewSymbol("list")) + if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) + } + v99 := v98.Get() + v100 := lang.Apply(v59, []any{v5}) + v101 := lang.Apply(v67, []any{v100}) + v102 := lang.Apply(v99, []any{v101}) + v103 := lang.Apply(v92, []any{v96, v102}) + v104 := lang.Apply(v89, []any{v103}) + v105 := lang.Apply(v83, []any{v86, v104}) + v106 := lang.Apply(v80, []any{v105}) + v107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v108 := v107.FindInternedVar(lang.NewSymbol("list")) + if v108.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v108))) + } + v109 := v108.Get() + v110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v111 := v110.FindInternedVar(lang.NewSymbol("seq")) + if v111.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v111))) + } + v112 := v111.Get() + v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v114 := v113.FindInternedVar(lang.NewSymbol("concat")) + if v114.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) + } + v115 := v114.Get() + v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v117 := v116.FindInternedVar(lang.NewSymbol("list")) + if v117.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) + } + v118 := v117.Get() + v119 := lang.Apply(v118, []any{lang.NewSymbol("iter__0__auto__")}) + v120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v121 := v120.FindInternedVar(lang.NewSymbol("list")) + if v121.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v121))) + } + v122 := v121.Get() + v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v124 := v123.FindInternedVar(lang.NewSymbol("second")) + if v124.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) + } + v125 := v124.Get() + v126 := lang.Apply(v125, []any{v5}) + v127 := lang.Apply(v122, []any{v126}) + v128 := lang.Apply(v115, []any{v119, v127}) + v129 := lang.Apply(v112, []any{v128}) + v130 := lang.Apply(v109, []any{v129}) + v131 := lang.Apply(v73, []any{v77, v106, v130}) + v132 := lang.Apply(v70, []any{v131}) + v55 = v132 + } // end let + return v55 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // force + { + v0 := lang.NewSymbol("force").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "If x is a Delay, returns the (possibly cached) value of its expression, else returns x", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(754), lang.NewKeyword("end-line"), int(754))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4, _ := lang.FieldOrMethod(nil, "force") + if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("force is not a function"))) + } + v5 := lang.Apply(v4, []any{v3}) + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // format + { + v0 := lang.NewSymbol("format").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fmt"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Formats a string using java.lang.String.format, see java.util.Formatter for format\n string syntax", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5717), lang.NewKeyword("end-line"), int(5717))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.NewList(args[1:]...) + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("apply")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{fmt.Sprintf, v3, v4}) + return v8 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // frequencies + { + v0 := lang.NewSymbol("frequencies").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a map from distinct items in coll to the number of times\n they appear.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7185), lang.NewKeyword("end-line"), int(7185))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("persistent!")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("reduce")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + var v10 lang.FnFunc + v10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("assoc!")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("inc")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("get")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{v11, v12, int64(0)}) + v23 := lang.Apply(v18, []any{v22}) + v24 := lang.Apply(v15, []any{v11, v12, v23}) + return v24 + }) + v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7192), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(7193), lang.NewKeyword("end-column"), int(54)) + v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("transient")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.NewMap() + v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7194), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(7194), lang.NewKeyword("end-column"), int(24)) + v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v19 := lang.Apply(v15, []any{v18}) + v20 := lang.Apply(v9, []any{v12, v19, v3}) + v21 := lang.Apply(v6, []any{v20}) + return v21 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // future + { + v0 := lang.NewSymbol("future").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Takes a body of expressions and yields a future object that will\n invoke the body in another thread, and will cache the result and\n return it on all subsequent calls to deref/@. If the computation has\n not yet finished, calls to deref/@ will block, unless the variant of\n deref with timeout is used. See also - realized?.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7009), lang.NewKeyword("end-line"), int(7009))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.NewList(args[2:]...) + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("seq")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("concat")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("list")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.Apply(v14, []any{lang.NewSymbol("glojure.core/future-call")}) + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("list")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("seq")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("concat")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("list")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.Apply(v27, []any{lang.NewSymbol("fn*")}) + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("list")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("apply")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v36 := v35.FindInternedVar(lang.NewSymbol("vector")) + if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + } + v37 := v36.Get() + v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v39 := v38.FindInternedVar(lang.NewSymbol("seq")) + if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + } + v40 := v39.Get() + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("concat")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.Apply(v43, nil) + v45 := lang.Apply(v40, []any{v44}) + v46 := lang.Apply(v34, []any{v37, v45}) + v47 := lang.Apply(v31, []any{v46}) + v48 := lang.Apply(v24, []any{v28, v47, v5}) + v49 := lang.Apply(v21, []any{v48}) + v50 := lang.Apply(v18, []any{v49}) + v51 := lang.Apply(v11, []any{v15, v50}) + v52 := lang.Apply(v8, []any{v51}) + return v52 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // future-call + { + v0 := lang.NewSymbol("future-call").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Takes a function of no args and yields a future object that will\n invoke the function in another thread, and will cache the result and\n return it on all subsequent calls to deref/@. If the computation has\n not yet finished, calls to deref/@ will block, unless the variant\n of deref with timeout is used. See also - realized?.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7003), lang.NewKeyword("end-line"), int(7003))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + { // let + // let binding "f" + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("binding-conveyor-fn")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v3}) + var v9 any = v8 + _ = v9 + // let binding "fut" + v10 := lang.Apply(lang.AgentSubmit, []any{v9}) + var v11 any = v10 + _ = v11 + v4 = v11 + } // end let + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // future-cancel + { + v0 := lang.NewSymbol("future-cancel").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Cancels the future, if possible.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7019), lang.NewKeyword("end-line"), int(7019))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4, _ := lang.FieldOrMethod(v3, "cancel") + if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("cancel is not a function"))) + } + v5 := lang.Apply(v4, []any{true}) + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // future-cancelled? + { + v0 := lang.NewSymbol("future-cancelled?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Returns true if future f is cancelled", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7025), lang.NewKeyword("end-line"), int(7025))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4, ok := lang.FieldOrMethod(v3, "isCancelled") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "isCancelled"))) + } + var v5 any + switch reflect.TypeOf(v4).Kind() { + case reflect.Func: + v5 = lang.Apply(v4, nil) + default: + v5 = v4 + } + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // future-done? + { + v0 := lang.NewSymbol("future-done?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Returns true if future f is done", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6538), lang.NewKeyword("end-line"), int(6538))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4, ok := lang.FieldOrMethod(v3, "isDone") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "isDone"))) + } + var v5 any + switch reflect.TypeOf(v4).Kind() { + case reflect.Func: + v5 = lang.Apply(v4, nil) + default: + v5 = v4 + } + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // future? + { + v0 := lang.NewSymbol("future?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is a future", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6532), lang.NewKeyword("end-line"), int(6532))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.Apply(v6, []any{nil, v3}) + return v7 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // gen-class + { + v0 := lang.NewSymbol("gen-class").WithMeta(lang.NewMap()).(*lang.Symbol) + v1 := ns.Intern(v0) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // gensym + { + v0 := lang.NewSymbol("gensym").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("prefix-string"))), lang.NewKeyword("doc"), "Returns a new symbol with a unique name. If a prefix string is\n supplied, the name is prefix# where # is some unique number. If\n prefix is not supplied, the prefix is 'G__'.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(599), lang.NewKeyword("end-line"), int(599))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v4 := v3.FindInternedVar(lang.NewSymbol("gensym")) + if v4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) + } + v5 := v4.Get() + v6 := lang.Apply(v5, []any{"G__"}) + return v6 + case 1: + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("str")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("str")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10, _ := lang.FieldOrMethod(runtime4.RT, "NextID") + if reflect.TypeOf(v10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("NextID is not a function"))) + } + v11 := lang.Apply(v10, []any{}) + v12 := lang.Apply(v9, []any{v11}) + v13 := lang.Apply(v6, []any{v3, v12}) + v14 := lang.Apply(lang.NewSymbol, []any{v13}) + return v14 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // get + { + var v1 lang.FnFunc + { // function get__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.NewList(args[2:]...) + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("seq")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("concat")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("list")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.Apply(v14, []any{lang.NewSymbol(".")}) + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("list")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("list")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("seq")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("concat")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("list")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.Apply(v31, []any{lang.NewSymbol("glojure.core/Get")}) + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("list")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.Apply(v35, []any{v3}) + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("list")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.Apply(v39, []any{v4}) + v41 := lang.Apply(v28, []any{v32, v36, v40, v5}) + v42 := lang.Apply(v25, []any{v41}) + v43 := lang.Apply(v22, []any{v42}) + v44 := lang.Apply(v11, []any{v15, v19, v43}) + v45 := lang.Apply(v8, []any{v44}) + return v45 + } + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("get").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"), lang.NewSymbol("not-found"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the value mapped to key, not-found or nil if key not present\n in associative collection, set, string, array, or ILookup instance.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2), int64(3)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1489), lang.NewKeyword("end-line"), int(1489))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := lang.Apply(lang.Get, []any{v4, v5}) + return v6 + case 3: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := args[2] + _ = v6 + v7 := lang.Apply(lang.GetDefault, []any{v4, v5, v6}) + return v7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // get-in + { + v0 := lang.NewSymbol("get-in").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("ks")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("ks"), lang.NewSymbol("not-found"))), lang.NewKeyword("doc"), "Returns the value in a nested associative structure,\n where ks is a sequence of keys. Returns nil if the key\n is not present, or the not-found value if supplied.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6128), lang.NewKeyword("end-line"), int(6128))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("reduce1")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("get")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v7, []any{v10, v3, v4}) + return v11 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any + { // let + // let binding "sentinel" + v7 := lang.Apply(reflect.StructOf, []any{nil}) + v8 := lang.Apply(reflect.New, []any{v7}) + v9, ok := lang.FieldOrMethod(v8, "Interface") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "Interface"))) + } + var v10 any + switch reflect.TypeOf(v9).Kind() { + case reflect.Func: + v10 = lang.Apply(v9, nil) + default: + v10 = v9 + } + var v11 any = v10 + _ = v11 + // let binding "m" + var v12 any = v3 + _ = v12 + // let binding "ks" + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("seq")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{v4}) + var v17 any = v16 + _ = v17 + for { + var v18 any + if lang.IsTruthy(v17) { + var v19 any + { // let + // let binding "m" + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("get")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("first")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.Apply(v25, []any{v17}) + v27 := lang.Apply(v22, []any{v12, v26, v11}) + var v28 any = v27 + _ = v28 + var v29 any + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("identical?")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.Apply(v32, []any{v11, v28}) + if lang.IsTruthy(v33) { + v29 = v5 + } else { + var v34 any = v11 + var v35 any = v28 + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("next")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.Apply(v39, []any{v17}) + var v36 any = v40 + v11 = v34 + v12 = v35 + v17 = v36 + continue + } + v19 = v29 + } // end let + v18 = v19 + } else { + v18 = v12 + } + v6 = v18 + break + } + } // end let + return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // get-method + { + v0 := lang.NewSymbol("get-method").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"), lang.NewSymbol("dispatch-val"))), lang.NewKeyword("doc"), "Given a multimethod and a dispatch value, returns the dispatch fn\n that would apply to that value, or nil if none apply and no default", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1815), lang.NewKeyword("end-line"), int(1815))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5, _ := lang.FieldOrMethod(v3, "getMethod") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getMethod is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // get-thread-bindings + { + v0 := lang.NewSymbol("get-thread-bindings").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Get a map with the Var/value pairs which is currently in effect for the\n current thread.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1937), lang.NewKeyword("end-line"), int(1937))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := lang.Apply(nil, nil) + return v3 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // get-validator + { + v0 := lang.NewSymbol("get-validator").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("iref"))), lang.NewKeyword("doc"), "Gets the validator-fn for a var/ref/agent/atom.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2392), lang.NewKeyword("end-line"), int(2392))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4, _ := lang.FieldOrMethod(v3, "getValidator") + if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getValidator is not a function"))) + } + v5 := lang.Apply(v4, []any{}) + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // global-hierarchy + { + v0 := lang.NewSymbol("global-hierarchy").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5513), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(5514), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + v1 := ns.InternWithValue(v0, lang.NewMap(lang.NewKeyword("parents"), lang.NewMap(), lang.NewKeyword("descendants"), lang.NewMap(), lang.NewKeyword("ancestors"), lang.NewMap()), true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // group-by + { + v0 := lang.NewSymbol("group-by").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a map of the elements of coll keyed by the result of\n f on each element. The value at each key will be a vector of the\n corresponding elements, in the order they appeared in coll.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7128), lang.NewKeyword("end-line"), int(7128))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("persistent!")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("reduce")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + var v11 lang.FnFunc + v11 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v12 := args[0] + _ = v12 + v13 := args[1] + _ = v13 + var v14 any + { // let + // let binding "k" + v15 := lang.Apply(v3, []any{v13}) + var v16 any = v15 + _ = v16 + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("assoc!")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("conj")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("get")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.NewVector() + v27 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7139), lang.NewKeyword("column"), int(40), lang.NewKeyword("end-line"), int(7139), lang.NewKeyword("end-column"), int(41)) + v28, err := lang.WithMeta(v26, v27.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v29 := lang.Apply(v25, []any{v12, v16, v28}) + v30 := lang.Apply(v22, []any{v29, v13}) + v31 := lang.Apply(v19, []any{v12, v16, v30}) + v14 = v31 + } // end let + return v14 + }) + v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7137), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(7139), lang.NewKeyword("end-column"), int(48)) + v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("transient")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.NewMap() + v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7140), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(7140), lang.NewKeyword("end-column"), int(17)) + v19, err := lang.WithMeta(v17, v18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v20 := lang.Apply(v16, []any{v19}) + v21 := lang.Apply(v10, []any{v13, v20, v4}) + v22 := lang.Apply(v7, []any{v21}) + return v22 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // halt-when + { + v0 := lang.NewSymbol("halt-when").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred")), lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("retf"))), lang.NewKeyword("doc"), "Returns a transducer that ends transduction when pred returns true\n for an input. When retf is supplied it must be a fn of 2 arguments -\n it will be passed the (completed) result so far and the input that\n triggered the predicate, and its return value (if it does not throw\n an exception) will be the return value of the transducer. If retf\n is not supplied, the input that triggered the predicate will be\n returned. If the predicate never returns true the transduction is\n unaffected.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7657), lang.NewKeyword("end-line"), int(7657))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("halt-when")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.Apply(v6, []any{v3, nil}) + return v7 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 lang.FnFunc + v5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v6 := args[0] + _ = v6 + var v7 lang.FnFunc + v7 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + v8 := lang.Apply(v6, nil) + return v8 + case 1: + v8 := args[0] + _ = v8 + var v9 any + var v10 any + { // let + // let binding "and__0__auto__" + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("map?")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{v8}) + var v15 any = v14 + _ = v15 + var v16 any + if lang.IsTruthy(v15) { + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("contains?")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.Apply(v19, []any{v8, lang.NewKeyword("glojure.core/halt")}) + v16 = v20 + } else { + v16 = v15 + } + v10 = v16 + } // end let + if lang.IsTruthy(v10) { + v11 := lang.Apply(lang.NewKeyword("glojure.core/halt"), []any{v8}) + v9 = v11 + } else { + v12 := lang.Apply(v6, []any{v8}) + v9 = v12 + } + return v9 + case 2: + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + var v10 any + v11 := lang.Apply(v3, []any{v9}) + if lang.IsTruthy(v11) { + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("reduced")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + var v15 any + if lang.IsTruthy(v4) { + v16 := lang.Apply(v6, []any{v8}) + v17 := lang.Apply(v4, []any{v16, v9}) + v15 = v17 + } else { + v15 = v9 + } + v18 := lang.NewMap(lang.NewKeyword("glojure.core/halt"), v15) + v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7678), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(7678), lang.NewKeyword("end-column"), int(72)) + v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v21 := lang.Apply(v14, []any{v20}) + v10 = v21 + } else { + v22 := lang.Apply(v6, []any{v8, v9}) + v10 = v22 + } + return v10 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7670), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7679), lang.NewKeyword("end-column"), int(34)) + v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v9 + }) + v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7669), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7679), lang.NewKeyword("end-column"), int(35)) + v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // hash + { + v0 := lang.NewSymbol("hash").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns the hash code of its argument. Note this is the hash code\n consistent with =, and thus is different than .hashCode for Integer,\n Short, Byte and Clojure collections.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5189), lang.NewKeyword("end-line"), int(5189))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.Apply(lang.HashEq, []any{v3}) + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // hash-map + { + v0 := lang.NewSymbol("hash-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keyvals"))), lang.NewKeyword("doc"), "keyval => key val\n Returns a new hash map with supplied mappings. If any keys are\n equal, they are handled as if by repeated uses of assoc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(378), lang.NewKeyword("end-line"), int(378))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + v3 := lang.NewMap() + v4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(384), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(384), lang.NewKeyword("end-column"), int(8)) + v5, err := lang.WithMeta(v3, v4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v5 + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := lang.NewList(args[0:]...) + v4 := lang.Apply(lang.CreatePersistentHashMap, []any{v3}) + return v4 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // hash-ordered-coll + { + v0 := lang.NewSymbol("hash-ordered-coll").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns the hash code, consistent with =, for an external ordered\n collection implementing Iterable.\n See http://glojure.org/data_structures#hash for full algorithms.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5210), lang.NewKeyword("end-line"), int(5210))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.Apply(nil, []any{v3}) + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // hash-set + { + v0 := lang.NewSymbol("hash-set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keys"))), lang.NewKeyword("doc"), "Returns a new hash set with supplied keys. Any equal keys are\n handled as if by repeated uses of conj.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(388), lang.NewKeyword("end-line"), int(388))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + v3 := lang.CreatePersistentTreeSet() + v4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(393), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(393), lang.NewKeyword("end-column"), int(9)) + v5, err := lang.WithMeta(v3, v4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v5 + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := lang.NewList(args[0:]...) + v4 := lang.Apply(nil, []any{v3}) + return v4 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // hash-unordered-coll + { + v0 := lang.NewSymbol("hash-unordered-coll").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns the hash code, consistent with =, for an external unordered\n collection implementing Iterable. For maps, the iterator should\n return map entries whose hash is computed as\n (hash-ordered-coll [k v]).\n See http://glojure.org/data_structures#hash for full algorithms.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5219), lang.NewKeyword("end-line"), int(5219))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.Apply(nil, []any{v3}) + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // ident? + { + v0 := lang.NewSymbol("ident?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a symbol or keyword", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1608), lang.NewKeyword("end-line"), int(1608))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + { // let + // let binding "or__0__auto__" + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("keyword?")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v3}) + var v9 any = v8 + _ = v9 + var v10 any + if lang.IsTruthy(v9) { + v10 = v9 + } else { + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("symbol?")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{v3}) + v10 = v14 + } + v4 = v10 + } // end let + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // identical? + { + var v1 lang.FnFunc + { // function identical?__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("seq")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("concat")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("list")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("list")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{lang.NewSymbol("glojure.lang.Util")}) + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("list")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{lang.NewSymbol("glojure.core/identical")}) + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("list")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.Apply(v25, []any{v3}) + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{v4}) + v31 := lang.Apply(v10, []any{v14, v18, v22, v26, v30}) + v32 := lang.Apply(v7, []any{v31}) + return v32 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("identical?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Tests if 2 arguments are the same object", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(768), lang.NewKeyword("end-line"), int(768))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := lang.Apply(lang.Identical, []any{v4, v5}) + return v6 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // identity + { + v0 := lang.NewSymbol("identity").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns its argument.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1446), lang.NewKeyword("end-line"), int(1446))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + return v3 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // if-let + { + v0 := lang.NewSymbol("if-let").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("then")), lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("then"), lang.NewSymbol("else"), lang.NewSymbol("&"), lang.NewSymbol("oldform"))), lang.NewKeyword("doc"), "bindings => binding-form test\n\n If test is true, evaluates then with binding-form bound to the value of \n test, if not, yields else", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1839), lang.NewKeyword("end-line"), int(1839))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 4: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("seq")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("concat")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("list")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/if-let")}) + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("list")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.Apply(v19, []any{v5}) + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("list")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.Apply(v23, []any{v6}) + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("list")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.Apply(v27, []any{nil}) + v29 := lang.Apply(v12, []any{v16, v20, v24, v28}) + v30 := lang.Apply(v9, []any{v29}) + return v30 + default: + if len(args) < 5 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := args[4] + _ = v7 + v8 := lang.NewList(args[5:]...) + var v9 any + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("vector?")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{v5}) + if lang.IsTruthy(v13) { + v9 = nil + } else { + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("str")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("first")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.Apply(v19, []any{v3}) + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("*ns*")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("meta")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.Apply(v26, []any{v3}) + v28 := lang.Apply(lang.NewKeyword("line"), []any{v27}) + v29 := lang.Apply(v16, []any{v20, " requires ", "a vector for its binding", " in ", v23, ":", v28}) + v30 := lang.Apply(lang.NewIllegalArgumentError, []any{v29}) + panic(v30) + } + _ = v9 + var v31 any + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("nil?")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{v8}) + if lang.IsTruthy(v35) { + v31 = nil + } else { + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("str")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v40 := v39.FindInternedVar(lang.NewSymbol("first")) + if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) + } + v41 := v40.Get() + v42 := lang.Apply(v41, []any{v3}) + v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v44 := v43.FindInternedVar(lang.NewSymbol("*ns*")) + if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) + } + v45 := v44.Get() + v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v47 := v46.FindInternedVar(lang.NewSymbol("meta")) + if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) + } + v48 := v47.Get() + v49 := lang.Apply(v48, []any{v3}) + v50 := lang.Apply(lang.NewKeyword("line"), []any{v49}) + v51 := lang.Apply(v38, []any{v42, " requires ", "1 or 2 forms after binding vector", " in ", v45, ":", v50}) + v52 := lang.Apply(lang.NewIllegalArgumentError, []any{v51}) + panic(v52) + } + _ = v31 + var v53 any + v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v55 := v54.FindInternedVar(lang.NewSymbol("=")) + if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) + } + v56 := v55.Get() + v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v58 := v57.FindInternedVar(lang.NewSymbol("count")) + if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) + } + v59 := v58.Get() + v60 := lang.Apply(v59, []any{v5}) + v61 := lang.Apply(v56, []any{int64(2), v60}) + if lang.IsTruthy(v61) { + v53 = nil + } else { + v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v63 := v62.FindInternedVar(lang.NewSymbol("str")) + if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) + } + v64 := v63.Get() + v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v66 := v65.FindInternedVar(lang.NewSymbol("first")) + if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) + } + v67 := v66.Get() + v68 := lang.Apply(v67, []any{v3}) + v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v70 := v69.FindInternedVar(lang.NewSymbol("*ns*")) + if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) + } + v71 := v70.Get() + v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v73 := v72.FindInternedVar(lang.NewSymbol("meta")) + if v73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) + } + v74 := v73.Get() + v75 := lang.Apply(v74, []any{v3}) + v76 := lang.Apply(lang.NewKeyword("line"), []any{v75}) + v77 := lang.Apply(v64, []any{v68, " requires ", "exactly 2 forms in binding vector", " in ", v71, ":", v76}) + v78 := lang.Apply(lang.NewIllegalArgumentError, []any{v77}) + panic(v78) + } + _ = v53 + _ = nil + var v79 any + { // let + // let binding "form" + v80 := lang.Apply(v5, []any{int64(0)}) + var v81 any = v80 + _ = v81 + // let binding "tst" + v82 := lang.Apply(v5, []any{int64(1)}) + var v83 any = v82 + _ = v83 + v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v85 := v84.FindInternedVar(lang.NewSymbol("seq")) + if v85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) + } + v86 := v85.Get() + v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v88 := v87.FindInternedVar(lang.NewSymbol("concat")) + if v88.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) + } + v89 := v88.Get() + v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v91 := v90.FindInternedVar(lang.NewSymbol("list")) + if v91.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) + } + v92 := v91.Get() + v93 := lang.Apply(v92, []any{lang.NewSymbol("glojure.core/let")}) + v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v95 := v94.FindInternedVar(lang.NewSymbol("list")) + if v95.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) + } + v96 := v95.Get() + v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v98 := v97.FindInternedVar(lang.NewSymbol("apply")) + if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) + } + v99 := v98.Get() + v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v101 := v100.FindInternedVar(lang.NewSymbol("vector")) + if v101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) + } + v102 := v101.Get() + v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v104 := v103.FindInternedVar(lang.NewSymbol("seq")) + if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) + } + v105 := v104.Get() + v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v107 := v106.FindInternedVar(lang.NewSymbol("concat")) + if v107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) + } + v108 := v107.Get() + v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v110 := v109.FindInternedVar(lang.NewSymbol("list")) + if v110.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) + } + v111 := v110.Get() + v112 := lang.Apply(v111, []any{lang.NewSymbol("temp__0__auto__")}) + v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v114 := v113.FindInternedVar(lang.NewSymbol("list")) + if v114.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) + } + v115 := v114.Get() + v116 := lang.Apply(v115, []any{v83}) + v117 := lang.Apply(v108, []any{v112, v116}) + v118 := lang.Apply(v105, []any{v117}) + v119 := lang.Apply(v99, []any{v102, v118}) + v120 := lang.Apply(v96, []any{v119}) + v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v122 := v121.FindInternedVar(lang.NewSymbol("list")) + if v122.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) + } + v123 := v122.Get() + v124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v125 := v124.FindInternedVar(lang.NewSymbol("seq")) + if v125.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v125))) + } + v126 := v125.Get() + v127 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v128 := v127.FindInternedVar(lang.NewSymbol("concat")) + if v128.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v128))) + } + v129 := v128.Get() + v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v131 := v130.FindInternedVar(lang.NewSymbol("list")) + if v131.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) + } + v132 := v131.Get() + v133 := lang.Apply(v132, []any{lang.NewSymbol("if")}) + v134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v135 := v134.FindInternedVar(lang.NewSymbol("list")) + if v135.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v135))) + } + v136 := v135.Get() + v137 := lang.Apply(v136, []any{lang.NewSymbol("temp__0__auto__")}) + v138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v139 := v138.FindInternedVar(lang.NewSymbol("list")) + if v139.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v139))) + } + v140 := v139.Get() + v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v142 := v141.FindInternedVar(lang.NewSymbol("seq")) + if v142.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) + } + v143 := v142.Get() + v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v145 := v144.FindInternedVar(lang.NewSymbol("concat")) + if v145.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) + } + v146 := v145.Get() + v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v148 := v147.FindInternedVar(lang.NewSymbol("list")) + if v148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) + } + v149 := v148.Get() + v150 := lang.Apply(v149, []any{lang.NewSymbol("glojure.core/let")}) + v151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v152 := v151.FindInternedVar(lang.NewSymbol("list")) + if v152.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v152))) + } + v153 := v152.Get() + v154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v155 := v154.FindInternedVar(lang.NewSymbol("apply")) + if v155.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v155))) + } + v156 := v155.Get() + v157 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v158 := v157.FindInternedVar(lang.NewSymbol("vector")) + if v158.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v158))) + } + v159 := v158.Get() + v160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v161 := v160.FindInternedVar(lang.NewSymbol("seq")) + if v161.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v161))) + } + v162 := v161.Get() + v163 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v164 := v163.FindInternedVar(lang.NewSymbol("concat")) + if v164.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v164))) + } + v165 := v164.Get() + v166 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v167 := v166.FindInternedVar(lang.NewSymbol("list")) + if v167.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v167))) + } + v168 := v167.Get() + v169 := lang.Apply(v168, []any{v81}) + v170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v171 := v170.FindInternedVar(lang.NewSymbol("list")) + if v171.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v171))) + } + v172 := v171.Get() + v173 := lang.Apply(v172, []any{lang.NewSymbol("temp__0__auto__")}) + v174 := lang.Apply(v165, []any{v169, v173}) + v175 := lang.Apply(v162, []any{v174}) + v176 := lang.Apply(v156, []any{v159, v175}) + v177 := lang.Apply(v153, []any{v176}) + v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v179 := v178.FindInternedVar(lang.NewSymbol("list")) + if v179.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) + } + v180 := v179.Get() + v181 := lang.Apply(v180, []any{v6}) + v182 := lang.Apply(v146, []any{v150, v177, v181}) + v183 := lang.Apply(v143, []any{v182}) + v184 := lang.Apply(v140, []any{v183}) + v185 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v186 := v185.FindInternedVar(lang.NewSymbol("list")) + if v186.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v186))) + } + v187 := v186.Get() + v188 := lang.Apply(v187, []any{v7}) + v189 := lang.Apply(v129, []any{v133, v137, v184, v188}) + v190 := lang.Apply(v126, []any{v189}) + v191 := lang.Apply(v123, []any{v190}) + v192 := lang.Apply(v89, []any{v93, v120, v191}) + v193 := lang.Apply(v86, []any{v192}) + v79 = v193 + } // end let + return v79 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // if-not + { + v0 := lang.NewSymbol("if-not").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("test"), lang.NewSymbol("then")), lang.NewVector(lang.NewSymbol("test"), lang.NewSymbol("then"), lang.NewSymbol("else"))), lang.NewKeyword("doc"), "Evaluates test. If logical false, evaluates and returns then expr, \n otherwise else expr, if supplied, else nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(760), lang.NewKeyword("end-line"), int(760))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 4: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("seq")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("concat")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("list")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/if-not")}) + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("list")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.Apply(v19, []any{v5}) + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("list")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.Apply(v23, []any{v6}) + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("list")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.Apply(v27, []any{nil}) + v29 := lang.Apply(v12, []any{v16, v20, v24, v28}) + v30 := lang.Apply(v9, []any{v29}) + return v30 + case 5: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := args[4] + _ = v7 + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("seq")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("concat")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("if")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("seq")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("concat")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/not")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{v5}) + v35 := lang.Apply(v26, []any{v30, v34}) + v36 := lang.Apply(v23, []any{v35}) + v37 := lang.Apply(v20, []any{v36}) + v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v39 := v38.FindInternedVar(lang.NewSymbol("list")) + if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + } + v40 := v39.Get() + v41 := lang.Apply(v40, []any{v6}) + v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v43 := v42.FindInternedVar(lang.NewSymbol("list")) + if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) + } + v44 := v43.Get() + v45 := lang.Apply(v44, []any{v7}) + v46 := lang.Apply(v13, []any{v17, v37, v41, v45}) + v47 := lang.Apply(v10, []any{v46}) + return v47 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // if-some + { + v0 := lang.NewSymbol("if-some").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("then")), lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("then"), lang.NewSymbol("else"), lang.NewSymbol("&"), lang.NewSymbol("oldform"))), lang.NewKeyword("doc"), "bindings => binding-form test\n\n If test is not nil, evaluates then with binding-form bound to the\n value of test, if not, yields else", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1874), lang.NewKeyword("end-line"), int(1874))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 4: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("seq")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("concat")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("list")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/if-some")}) + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("list")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.Apply(v19, []any{v5}) + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("list")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.Apply(v23, []any{v6}) + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("list")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.Apply(v27, []any{nil}) + v29 := lang.Apply(v12, []any{v16, v20, v24, v28}) + v30 := lang.Apply(v9, []any{v29}) + return v30 + default: + if len(args) < 5 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := args[4] + _ = v7 + v8 := lang.NewList(args[5:]...) + var v9 any + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("vector?")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{v5}) + if lang.IsTruthy(v13) { + v9 = nil + } else { + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("str")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("first")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.Apply(v19, []any{v3}) + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("*ns*")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("meta")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.Apply(v26, []any{v3}) + v28 := lang.Apply(lang.NewKeyword("line"), []any{v27}) + v29 := lang.Apply(v16, []any{v20, " requires ", "a vector for its binding", " in ", v23, ":", v28}) + v30 := lang.Apply(lang.NewIllegalArgumentError, []any{v29}) + panic(v30) + } + _ = v9 + var v31 any + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("nil?")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{v8}) + if lang.IsTruthy(v35) { + v31 = nil + } else { + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("str")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v40 := v39.FindInternedVar(lang.NewSymbol("first")) + if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) + } + v41 := v40.Get() + v42 := lang.Apply(v41, []any{v3}) + v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v44 := v43.FindInternedVar(lang.NewSymbol("*ns*")) + if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) + } + v45 := v44.Get() + v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v47 := v46.FindInternedVar(lang.NewSymbol("meta")) + if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) + } + v48 := v47.Get() + v49 := lang.Apply(v48, []any{v3}) + v50 := lang.Apply(lang.NewKeyword("line"), []any{v49}) + v51 := lang.Apply(v38, []any{v42, " requires ", "1 or 2 forms after binding vector", " in ", v45, ":", v50}) + v52 := lang.Apply(lang.NewIllegalArgumentError, []any{v51}) + panic(v52) + } + _ = v31 + var v53 any + v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v55 := v54.FindInternedVar(lang.NewSymbol("=")) + if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) + } + v56 := v55.Get() + v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v58 := v57.FindInternedVar(lang.NewSymbol("count")) + if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) + } + v59 := v58.Get() + v60 := lang.Apply(v59, []any{v5}) + v61 := lang.Apply(v56, []any{int64(2), v60}) + if lang.IsTruthy(v61) { + v53 = nil + } else { + v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v63 := v62.FindInternedVar(lang.NewSymbol("str")) + if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) + } + v64 := v63.Get() + v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v66 := v65.FindInternedVar(lang.NewSymbol("first")) + if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) + } + v67 := v66.Get() + v68 := lang.Apply(v67, []any{v3}) + v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v70 := v69.FindInternedVar(lang.NewSymbol("*ns*")) + if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) + } + v71 := v70.Get() + v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v73 := v72.FindInternedVar(lang.NewSymbol("meta")) + if v73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) + } + v74 := v73.Get() + v75 := lang.Apply(v74, []any{v3}) + v76 := lang.Apply(lang.NewKeyword("line"), []any{v75}) + v77 := lang.Apply(v64, []any{v68, " requires ", "exactly 2 forms in binding vector", " in ", v71, ":", v76}) + v78 := lang.Apply(lang.NewIllegalArgumentError, []any{v77}) + panic(v78) + } + _ = v53 + _ = nil + var v79 any + { // let + // let binding "form" + v80 := lang.Apply(v5, []any{int64(0)}) + var v81 any = v80 + _ = v81 + // let binding "tst" + v82 := lang.Apply(v5, []any{int64(1)}) + var v83 any = v82 + _ = v83 + v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v85 := v84.FindInternedVar(lang.NewSymbol("seq")) + if v85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) + } + v86 := v85.Get() + v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v88 := v87.FindInternedVar(lang.NewSymbol("concat")) + if v88.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) + } + v89 := v88.Get() + v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v91 := v90.FindInternedVar(lang.NewSymbol("list")) + if v91.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) + } + v92 := v91.Get() + v93 := lang.Apply(v92, []any{lang.NewSymbol("glojure.core/let")}) + v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v95 := v94.FindInternedVar(lang.NewSymbol("list")) + if v95.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) + } + v96 := v95.Get() + v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v98 := v97.FindInternedVar(lang.NewSymbol("apply")) + if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) + } + v99 := v98.Get() + v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v101 := v100.FindInternedVar(lang.NewSymbol("vector")) + if v101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) + } + v102 := v101.Get() + v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v104 := v103.FindInternedVar(lang.NewSymbol("seq")) + if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) + } + v105 := v104.Get() + v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v107 := v106.FindInternedVar(lang.NewSymbol("concat")) + if v107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) + } + v108 := v107.Get() + v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v110 := v109.FindInternedVar(lang.NewSymbol("list")) + if v110.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) + } + v111 := v110.Get() + v112 := lang.Apply(v111, []any{lang.NewSymbol("temp__0__auto__")}) + v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v114 := v113.FindInternedVar(lang.NewSymbol("list")) + if v114.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) + } + v115 := v114.Get() + v116 := lang.Apply(v115, []any{v83}) + v117 := lang.Apply(v108, []any{v112, v116}) + v118 := lang.Apply(v105, []any{v117}) + v119 := lang.Apply(v99, []any{v102, v118}) + v120 := lang.Apply(v96, []any{v119}) + v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v122 := v121.FindInternedVar(lang.NewSymbol("list")) + if v122.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) + } + v123 := v122.Get() + v124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v125 := v124.FindInternedVar(lang.NewSymbol("seq")) + if v125.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v125))) + } + v126 := v125.Get() + v127 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v128 := v127.FindInternedVar(lang.NewSymbol("concat")) + if v128.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v128))) + } + v129 := v128.Get() + v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v131 := v130.FindInternedVar(lang.NewSymbol("list")) + if v131.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) + } + v132 := v131.Get() + v133 := lang.Apply(v132, []any{lang.NewSymbol("if")}) + v134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v135 := v134.FindInternedVar(lang.NewSymbol("list")) + if v135.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v135))) + } + v136 := v135.Get() + v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v138 := v137.FindInternedVar(lang.NewSymbol("seq")) + if v138.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) + } + v139 := v138.Get() + v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v141 := v140.FindInternedVar(lang.NewSymbol("concat")) + if v141.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) + } + v142 := v141.Get() + v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v144 := v143.FindInternedVar(lang.NewSymbol("list")) + if v144.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) + } + v145 := v144.Get() + v146 := lang.Apply(v145, []any{lang.NewSymbol("glojure.core/nil?")}) + v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v148 := v147.FindInternedVar(lang.NewSymbol("list")) + if v148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) + } + v149 := v148.Get() + v150 := lang.Apply(v149, []any{lang.NewSymbol("temp__0__auto__")}) + v151 := lang.Apply(v142, []any{v146, v150}) + v152 := lang.Apply(v139, []any{v151}) + v153 := lang.Apply(v136, []any{v152}) + v154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v155 := v154.FindInternedVar(lang.NewSymbol("list")) + if v155.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v155))) + } + v156 := v155.Get() + v157 := lang.Apply(v156, []any{v7}) + v158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v159 := v158.FindInternedVar(lang.NewSymbol("list")) + if v159.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v159))) + } + v160 := v159.Get() + v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v162 := v161.FindInternedVar(lang.NewSymbol("seq")) + if v162.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) + } + v163 := v162.Get() + v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v165 := v164.FindInternedVar(lang.NewSymbol("concat")) + if v165.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) + } + v166 := v165.Get() + v167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v168 := v167.FindInternedVar(lang.NewSymbol("list")) + if v168.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v168))) + } + v169 := v168.Get() + v170 := lang.Apply(v169, []any{lang.NewSymbol("glojure.core/let")}) + v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v172 := v171.FindInternedVar(lang.NewSymbol("list")) + if v172.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) + } + v173 := v172.Get() + v174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v175 := v174.FindInternedVar(lang.NewSymbol("apply")) + if v175.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v175))) + } + v176 := v175.Get() + v177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v178 := v177.FindInternedVar(lang.NewSymbol("vector")) + if v178.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v178))) + } + v179 := v178.Get() + v180 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v181 := v180.FindInternedVar(lang.NewSymbol("seq")) + if v181.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v181))) + } + v182 := v181.Get() + v183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v184 := v183.FindInternedVar(lang.NewSymbol("concat")) + if v184.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v184))) + } + v185 := v184.Get() + v186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v187 := v186.FindInternedVar(lang.NewSymbol("list")) + if v187.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v187))) + } + v188 := v187.Get() + v189 := lang.Apply(v188, []any{v81}) + v190 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v191 := v190.FindInternedVar(lang.NewSymbol("list")) + if v191.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v191))) + } + v192 := v191.Get() + v193 := lang.Apply(v192, []any{lang.NewSymbol("temp__0__auto__")}) + v194 := lang.Apply(v185, []any{v189, v193}) + v195 := lang.Apply(v182, []any{v194}) + v196 := lang.Apply(v176, []any{v179, v195}) + v197 := lang.Apply(v173, []any{v196}) + v198 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v199 := v198.FindInternedVar(lang.NewSymbol("list")) + if v199.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v199))) + } + v200 := v199.Get() + v201 := lang.Apply(v200, []any{v6}) + v202 := lang.Apply(v166, []any{v170, v197, v201}) + v203 := lang.Apply(v163, []any{v202}) + v204 := lang.Apply(v160, []any{v203}) + v205 := lang.Apply(v129, []any{v133, v153, v157, v204}) + v206 := lang.Apply(v126, []any{v205}) + v207 := lang.Apply(v123, []any{v206}) + v208 := lang.Apply(v89, []any{v93, v120, v207}) + v209 := lang.Apply(v86, []any{v208}) + v79 = v209 + } // end let + return v79 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // ifn? + { + v0 := lang.NewSymbol("ifn?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements IFn. Note that many data structures\n (e.g. sets and maps) implement IFn", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6209), lang.NewKeyword("end-line"), int(6209))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.Apply(v6, []any{nil, v3}) + return v7 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // import + { + v0 := lang.NewSymbol("import").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("import-symbols-or-lists"))), lang.NewKeyword("doc"), "import-list => (package-symbol class-name-symbols*)\n\n For each name in class-name-symbols, adds a mapping from name to the\n class named by package.name to the current namespace. Use :import in the ns\n macro in preference to calling this directly.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3426), lang.NewKeyword("end-line"), int(3426))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.NewList(args[2:]...) + var v6 any + { // let + // let binding "specs" + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("map")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + var v10 lang.FnFunc + v10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v11 := args[0] + _ = v11 + var v12 any + var v13 any + { // let + // let binding "and__0__auto__" + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("seq?")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{v11}) + var v18 any = v17 + _ = v18 + var v19 any + if lang.IsTruthy(v18) { + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("=")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("first")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.Apply(v25, []any{v11}) + v27 := lang.Apply(v22, []any{lang.NewSymbol("quote"), v26}) + v19 = v27 + } else { + v19 = v18 + } + v13 = v19 + } // end let + if lang.IsTruthy(v13) { + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("second")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{v11}) + v12 = v17 + } else { + v12 = v11 + } + return v12 + }) + v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3434), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(3434), lang.NewKeyword("end-column"), int(73)) + v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v13 := lang.Apply(v9, []any{v12, v5}) + var v14 any = v13 + _ = v14 + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("seq")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("concat")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("list")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.Apply(v23, []any{lang.NewSymbol("do")}) + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("map")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + var v28 lang.FnFunc + v28 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v29 := args[0] + _ = v29 + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("list")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.Apply(v32, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Import"), v29}) + return v33 + }) + v29 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3436), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(3436), lang.NewKeyword("end-column"), int(73)) + v30, err := lang.WithMeta(v28, v29.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("reduce1")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + var v34 lang.FnFunc + v34 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v35 := args[0] + _ = v35 + v36 := args[1] + _ = v36 + var v37 any + v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v39 := v38.FindInternedVar(lang.NewSymbol("symbol?")) + if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + } + v40 := v39.Get() + v41 := lang.Apply(v40, []any{v36}) + if lang.IsTruthy(v41) { + v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v43 := v42.FindInternedVar(lang.NewSymbol("conj")) + if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) + } + v44 := v43.Get() + v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v46 := v45.FindInternedVar(lang.NewSymbol("name")) + if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) + } + v47 := v46.Get() + v48 := lang.Apply(v47, []any{v36}) + v49 := lang.Apply(v44, []any{v35, v48}) + v37 = v49 + } else { + var v50 any + { // let + // let binding "p" + v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v52 := v51.FindInternedVar(lang.NewSymbol("first")) + if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) + } + v53 := v52.Get() + v54 := lang.Apply(v53, []any{v36}) + var v55 any = v54 + _ = v55 + // let binding "cs" + v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v57 := v56.FindInternedVar(lang.NewSymbol("rest")) + if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) + } + v58 := v57.Get() + v59 := lang.Apply(v58, []any{v36}) + var v60 any = v59 + _ = v60 + v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v62 := v61.FindInternedVar(lang.NewSymbol("into1")) + if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) + } + v63 := v62.Get() + v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v65 := v64.FindInternedVar(lang.NewSymbol("map")) + if v65.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) + } + v66 := v65.Get() + var v67 lang.FnFunc + v67 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v68 := args[0] + _ = v68 + v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v70 := v69.FindInternedVar(lang.NewSymbol("str")) + if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) + } + v71 := v70.Get() + v72 := lang.Apply(v71, []any{v55, ".", v68}) + return v72 + }) + v68 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3441), lang.NewKeyword("column"), int(45), lang.NewKeyword("end-line"), int(3441), lang.NewKeyword("end-column"), int(58)) + v69, err := lang.WithMeta(v67, v68.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v70 := lang.Apply(v66, []any{v69, v60}) + v71 := lang.Apply(v63, []any{v35, v70}) + v50 = v71 + } // end let + v37 = v50 + } + return v37 + }) + v35 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3437), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(3441), lang.NewKeyword("end-column"), int(66)) + v36, err := lang.WithMeta(v34, v35.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v37 := lang.NewVector() + v38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3442), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(3442), lang.NewKeyword("end-column"), int(26)) + v39, err := lang.WithMeta(v37, v38.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v40 := lang.Apply(v33, []any{v36, v39, v14}) + v41 := lang.Apply(v27, []any{v30, v40}) + v42 := lang.Apply(v20, []any{v24, v41}) + v43 := lang.Apply(v17, []any{v42}) + v6 = v43 + } // end let + return v6 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // in-ns + { + v0 := lang.NewSymbol("in-ns").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + v1 := ns.InternWithValue(v0, nil, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // inc + { + var v1 lang.FnFunc + { // function inc__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("concat")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("list")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("seq")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("concat")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + var v30 any + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + if lang.IsTruthy(v33) { + v30 = lang.NewSymbol("unchecked_inc") + } else { + v30 = lang.NewSymbol("inc") + } + v34 := lang.Apply(v29, []any{v30}) + v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v36 := v35.FindInternedVar(lang.NewSymbol("list")) + if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + } + v37 := v36.Get() + v38 := lang.Apply(v37, []any{v3}) + v39 := lang.Apply(v26, []any{v34, v38}) + v40 := lang.Apply(v23, []any{v39}) + v41 := lang.Apply(v20, []any{v40}) + v42 := lang.Apply(v9, []any{v13, v17, v41}) + v43 := lang.Apply(v6, []any{v42}) + return v43 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("inc").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns a number one greater than num. Does not auto-promote\n longs, will throw on overflow. See also: inc'", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(915), lang.NewKeyword("end-line"), int(915))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5, _ := lang.FieldOrMethod(lang.Numbers, "Inc") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Inc is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // inc' + { + var v1 lang.FnFunc + { // function inc'__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("concat")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("list")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("seq")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("concat")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/IncP")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{v3}) + v35 := lang.Apply(v26, []any{v30, v34}) + v36 := lang.Apply(v23, []any{v35}) + v37 := lang.Apply(v20, []any{v36}) + v38 := lang.Apply(v9, []any{v13, v17, v37}) + v39 := lang.Apply(v6, []any{v38}) + return v39 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("inc'").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns a number one greater than num. Supports arbitrary precision.\n See also: inc", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(908), lang.NewKeyword("end-line"), int(908))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5, _ := lang.FieldOrMethod(lang.Numbers, "IncP") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("IncP is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // indexed? + { + v0 := lang.NewSymbol("indexed?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return true if coll implements Indexed, indicating efficient lookup by index", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6263), lang.NewKeyword("end-line"), int(6263))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.Apply(v6, []any{nil, v3}) + return v7 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // infinite? + { + var v1 lang.FnFunc + { // function infinite?__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("concat")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("list")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol("Double/isInfinite")}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{v3}) + v18 := lang.Apply(v9, []any{v13, v17}) + v19 := lang.Apply(v6, []any{v18}) + return v19 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("infinite?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns true if num is negative or positive infinity, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)), lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7977), lang.NewKeyword("end-line"), int(7977))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := lang.Apply(nil, []any{v4}) + return v5 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // inst-ms + { + v0 := lang.NewSymbol("inst-ms").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("inst"))), lang.NewKeyword("doc"), "Return the number of milliseconds since January 1, 1970, 00:00:00 GMT", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6831), lang.NewKeyword("end-line"), int(6831))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.Apply(nil, []any{v3}) + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // inst? + { + v0 := lang.NewSymbol("inst?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x satisfies Inst", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6837), lang.NewKeyword("end-line"), int(6837))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + return nil + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // instance? + { + v0 := lang.NewSymbol("instance?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Evaluates x and tests if it is an instance of the type\n t. Returns true or false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(139), lang.NewKeyword("end-line"), int(143))).(*lang.Symbol) + var v2 lang.FnFunc + { // function instance? + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := lang.Apply(lang.HasType, []any{v4, v5}) + return v6 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(143), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(143), lang.NewKeyword("end-column"), int(85))).(lang.FnFunc) + v3 := v2 + _ = v3 + } + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // int + { + var v1 lang.FnFunc + { // function int__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("concat")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("list")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("seq")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("concat")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + var v30 any + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + if lang.IsTruthy(v33) { + v30 = lang.NewSymbol("uncheckedIntCast") + } else { + v30 = lang.NewSymbol("intCast") + } + v34 := lang.Apply(v29, []any{v30}) + v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v36 := v35.FindInternedVar(lang.NewSymbol("list")) + if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + } + v37 := v36.Get() + v38 := lang.Apply(v37, []any{v3}) + v39 := lang.Apply(v26, []any{v34, v38}) + v40 := lang.Apply(v23, []any{v39}) + v41 := lang.Apply(v20, []any{v40}) + v42 := lang.Apply(v9, []any{v13, v17, v41}) + v43 := lang.Apply(v6, []any{v42}) + return v43 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to int", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(875), lang.NewKeyword("end-line"), int(875))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5, _ := lang.FieldOrMethod(runtime4.RT, "IntCast") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("IntCast is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // int-array + { + var v1 lang.FnFunc + { // function int-array__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := lang.NewList(args[0:]...) + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("concat")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("list")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/IntArray")}) + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("list")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("seq")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("concat")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) + v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v36 := v35.FindInternedVar(lang.NewSymbol("list")) + if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + } + v37 := v36.Get() + v38 := lang.Apply(v37, []any{lang.NewSymbol("glojure.core/args")}) + v39 := lang.Apply(v30, []any{v34, v38}) + v40 := lang.Apply(v27, []any{v39}) + v41 := lang.Apply(v24, []any{v40}) + v42 := lang.Apply(v9, []any{v13, v17, v21, v41}) + v43 := lang.Apply(v6, []any{v42}) + return v43 + } + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("int-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Creates an array of ints", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1), int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5356), lang.NewKeyword("end-line"), int(5356))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + v5, _ := lang.FieldOrMethod(lang.Numbers, "IntArray") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("IntArray is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6, _ := lang.FieldOrMethod(lang.Numbers, "IntArrayInit") + if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("IntArrayInit is not a function"))) + } + v7 := lang.Apply(v6, []any{v4, v5}) + return v7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // int? + { + v0 := lang.NewSymbol("int?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a fixed precision integer", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1395), lang.NewKeyword("end-line"), int(1395))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + { // let + // let binding "or__0__auto__" + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{lang.Builtins["int64"], v3}) + var v9 any = v8 + _ = v9 + var v10 any + if lang.IsTruthy(v9) { + v10 = v9 + } else { + var v11 any + { // let + // let binding "or__0__auto__" + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("instance?")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.Apply(v14, []any{nil, v3}) + var v16 any = v15 + _ = v16 + var v17 any + if lang.IsTruthy(v16) { + v17 = v16 + } else { + var v18 any + { // let + // let binding "or__0__auto__" + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("instance?")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{nil, v3}) + var v23 any = v22 + _ = v23 + var v24 any + if lang.IsTruthy(v23) { + v24 = v23 + } else { + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("instance?")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.Apply(v27, []any{nil, v3}) + v24 = v28 + } + v18 = v24 + } // end let + v17 = v18 + } + v11 = v17 + } // end let + v10 = v11 + } + v4 = v10 + } // end let + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // integer? + { + v0 := lang.NewSymbol("integer?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is an integer", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1379), lang.NewKeyword("end-line"), int(1379))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.Apply(lang.IsInteger, []any{v3}) + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // interleave + { + v0 := lang.NewSymbol("interleave").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("c1")), lang.NewVector(lang.NewSymbol("c1"), lang.NewSymbol("c2")), lang.NewVector(lang.NewSymbol("c1"), lang.NewSymbol("c2"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Returns a lazy seq of the first item in each coll, then the second etc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4308), lang.NewKeyword("end-line"), int(4308))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return lang.NewList() + case 1: + v3 := args[0] + _ = v3 + var v4 lang.FnFunc + v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + return v3 + }) + v5 := lang.Apply(lang.NewLazySeq, []any{v4}) + return v5 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 lang.FnFunc + v5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v6 any + { // let + // let binding "s1" + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("seq")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, []any{v3}) + var v11 any = v10 + _ = v11 + // let binding "s2" + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("seq")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.Apply(v14, []any{v4}) + var v16 any = v15 + _ = v16 + var v17 any + var v18 any + { // let + // let binding "and__0__auto__" + var v19 any = v11 + _ = v19 + var v20 any + if lang.IsTruthy(v19) { + v20 = v16 + } else { + v20 = v19 + } + v18 = v20 + } // end let + if lang.IsTruthy(v18) { + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("cons")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("first")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v11}) + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("cons")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("first")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.Apply(v31, []any{v16}) + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("interleave")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("rest")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v38, []any{v11}) + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("rest")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.Apply(v42, []any{v16}) + v44 := lang.Apply(v35, []any{v39, v43}) + v45 := lang.Apply(v28, []any{v32, v44}) + v46 := lang.Apply(v21, []any{v25, v45}) + v17 = v46 + } else { + v17 = nil + } + v6 = v17 + } // end let + return v6 + }) + v6 := lang.Apply(lang.NewLazySeq, []any{v5}) + return v6 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.NewList(args[2:]...) + var v6 lang.FnFunc + v6 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v7 any + { // let + // let binding "ss" + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("map")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("seq")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("conj")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{v5, v4, v3}) + v18 := lang.Apply(v10, []any{v13, v17}) + var v19 any = v18 + _ = v19 + var v20 any + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("every?")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("identity")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.Apply(v23, []any{v26, v19}) + if lang.IsTruthy(v27) { + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("concat")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("map")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("first")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.Apply(v33, []any{v36, v19}) + v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v39 := v38.FindInternedVar(lang.NewSymbol("apply")) + if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + } + v40 := v39.Get() + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("interleave")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("map")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v48 := v47.FindInternedVar(lang.NewSymbol("rest")) + if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) + } + v49 := v48.Get() + v50 := lang.Apply(v46, []any{v49, v19}) + v51 := lang.Apply(v40, []any{v43, v50}) + v52 := lang.Apply(v30, []any{v37, v51}) + v20 = v52 + } else { + v20 = nil + } + v7 = v20 + } // end let + return v7 + }) + v7 := lang.Apply(lang.NewLazySeq, []any{v6}) + return v7 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // intern + { + v0 := lang.NewSymbol("intern").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name"), lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Finds or creates a var named by the symbol name in the namespace\n ns (which can be a symbol or a namespace), setting its root binding\n to val if supplied. The namespace must exist. The var will adopt any\n metadata from the name symbol. Returns the var.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6311), lang.NewKeyword("end-line"), int(6311))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any + { // let + // let binding "v" + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("the-ns")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{v3}) + v10 := lang.Apply(nil, []any{v9, v4}) + var v11 any = v10 + _ = v11 + var v12 any + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("meta")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{v4}) + if lang.IsTruthy(v16) { + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("meta")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.Apply(v19, []any{v4}) + v21, _ := lang.FieldOrMethod(v11, "setMeta") + if reflect.TypeOf(v21).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMeta is not a function"))) + } + v22 := lang.Apply(v21, []any{v20}) + v12 = v22 + } else { + v12 = nil + } + _ = v12 + v5 = v11 + } // end let + return v5 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any + { // let + // let binding "v" + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("the-ns")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, []any{v3}) + v11 := lang.Apply(nil, []any{v10, v4, v5}) + var v12 any = v11 + _ = v12 + var v13 any + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("meta")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{v4}) + if lang.IsTruthy(v17) { + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("meta")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.Apply(v20, []any{v4}) + v22, _ := lang.FieldOrMethod(v12, "setMeta") + if reflect.TypeOf(v22).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMeta is not a function"))) + } + v23 := lang.Apply(v22, []any{v21}) + v13 = v23 + } else { + v13 = nil + } + _ = v13 + v6 = v12 + } // end let + return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // interpose + { + v0 := lang.NewSymbol("interpose").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sep")), lang.NewVector(lang.NewSymbol("sep"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy seq of the elements of coll separated by sep.\n Returns a stateful transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5230), lang.NewKeyword("end-line"), int(5230))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + var v4 lang.FnFunc + v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + var v6 any + { // let + // let binding "started" + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("volatile!")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, []any{false}) + var v11 any = v10 + _ = v11 + var v12 lang.FnFunc + v12 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + v13 := lang.Apply(v5, nil) + return v13 + case 1: + v13 := args[0] + _ = v13 + v14 := lang.Apply(v5, []any{v13}) + return v14 + case 2: + v13 := args[0] + _ = v13 + v14 := args[1] + _ = v14 + var v15 any + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("deref")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{v11}) + if lang.IsTruthy(v19) { + var v20 any + { // let + // let binding "sepr" + v21 := lang.Apply(v5, []any{v13, v3}) + var v22 any = v21 + _ = v22 + var v23 any + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("reduced?")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.Apply(v26, []any{v22}) + if lang.IsTruthy(v27) { + v23 = v22 + } else { + v28 := lang.Apply(v5, []any{v22, v14}) + v23 = v28 + } + v20 = v23 + } // end let + v15 = v20 + } else { + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("vreset!")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.Apply(v23, []any{v11, true}) + _ = v24 + v25 := lang.Apply(v5, []any{v13, v14}) + v15 = v25 + } + return v15 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5238), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(5249), lang.NewKeyword("end-column"), int(35)) + v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v6 = v14 + } // end let + return v6 + }) + v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5236), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(5249), lang.NewKeyword("end-column"), int(37)) + v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v6 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("drop")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("interleave")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("repeat")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{v3}) + v15 := lang.Apply(v10, []any{v14, v4}) + v16 := lang.Apply(v7, []any{int64(1), v15}) + return v16 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // into + { + v0 := lang.NewSymbol("into").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("to")), lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("from")), lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("xform"), lang.NewSymbol("from"))), lang.NewKeyword("doc"), "Returns a new coll consisting of to with all of the items of\n from conjoined. A transducer may be supplied.\n (into x) returns x. (into) returns [].", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6922), lang.NewKeyword("end-line"), int(6922))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + v3 := lang.NewVector() + v4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6928), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(6928), lang.NewKeyword("end-column"), int(8)) + v5, err := lang.WithMeta(v3, v4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v5 + case 1: + v3 := args[0] + _ = v3 + return v3 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{lang.IEditableCollection, v3}) + if lang.IsTruthy(v9) { + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("with-meta")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("persistent!")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("reduce")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("conj!")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("transient")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v3}) + v26 := lang.Apply(v18, []any{v21, v25, v4}) + v27 := lang.Apply(v15, []any{v26}) + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("meta")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.Apply(v30, []any{v3}) + v32 := lang.Apply(v12, []any{v27, v31}) + v5 = v32 + } else { + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("reduce")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("conj")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v35, []any{v38, v3, v4}) + v5 = v39 + } + return v5 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("instance?")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, []any{lang.IEditableCollection, v3}) + if lang.IsTruthy(v10) { + var v11 any + { // let + // let binding "tm" + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("meta")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.Apply(v14, []any{v3}) + var v16 any = v15 + _ = v16 + // let binding "rf" + var v17 lang.FnFunc + v17 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v18 := args[0] + _ = v18 + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("with-meta")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("persistent!")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v18}) + v26 := lang.Apply(v21, []any{v25, v16}) + return v26 + case 2: + v18 := args[0] + _ = v18 + v19 := args[1] + _ = v19 + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("conj!")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.Apply(v22, []any{v18, v19}) + return v23 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6937), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(6939), lang.NewKeyword("end-column"), int(44)) + v19, err := lang.WithMeta(v17, v18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v20 any = v19 + _ = v20 + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("transduce")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("transient")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.Apply(v26, []any{v3}) + v28 := lang.Apply(v23, []any{v4, v20, v27, v5}) + v11 = v28 + } // end let + v6 = v11 + } else { + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("transduce")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("conj")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v14, []any{v4, v17, v3, v5}) + v6 = v18 + } + return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // into-array + { + v0 := lang.NewSymbol("into-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("aseq")), lang.NewVector(lang.NewSymbol("type"), lang.NewSymbol("aseq"))), lang.NewKeyword("doc"), "Returns an array with components set to the values in aseq. The array's\n component type is type if provided, or the type of the first value in\n aseq if present, or Object. All values in aseq must be compatible with\n the component type. Class objects for the primitive types can be obtained\n using, e.g., Integer/TYPE.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3444), lang.NewKeyword("end-line"), int(3444))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.Apply(v6, []any{v3}) + v8 := lang.Apply(nil, []any{v7}) + return v8 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("seq")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v4}) + v9 := lang.Apply(nil, []any{v3, v8}) + return v9 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // into1 + { + v0 := lang.NewSymbol("into1").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("from"))), lang.NewKeyword("doc"), "Returns a new coll consisting of to-coll with all of the items of\n from-coll conjoined.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3416), lang.NewKeyword("end-line"), int(3416), lang.NewKeyword("private"), true)).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{lang.IEditableCollection, v3}) + if lang.IsTruthy(v9) { + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("persistent!")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("reduce1")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("conj!")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("transient")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{v3}) + v23 := lang.Apply(v15, []any{v18, v22, v4}) + v24 := lang.Apply(v12, []any{v23}) + v5 = v24 + } else { + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("reduce1")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("conj")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.Apply(v27, []any{v30, v3, v4}) + v5 = v31 + } + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // ints + { + var v1 lang.FnFunc + { // function ints + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("concat")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("list")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/Ints")}) + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("list")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v3}) + v26 := lang.Apply(v9, []any{v13, v17, v21, v25}) + v27 := lang.Apply(v6, []any{v26}) + return v27 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("ints").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Casts to int[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5397), lang.NewKeyword("end-line"), int(5397))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5, _ := lang.FieldOrMethod(lang.Numbers, "Ints") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Ints is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // io! + { + v0 := lang.NewSymbol("io!").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "If an io! block occurs in a transaction, throws an\n IllegalStateException, else runs body in an implicit do. If the\n first expression in body is a literal string, will use that as the\n exception message.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(2504), lang.NewKeyword("end-line"), int(2504))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.NewList(args[2:]...) + var v6 any + { // let + // let binding "message" + var v7 any + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("string?")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("first")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{v5}) + v15 := lang.Apply(v10, []any{v14}) + if lang.IsTruthy(v15) { + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("first")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{v5}) + v7 = v19 + } else { + v7 = nil + } + var v20 any = v7 + _ = v20 + // let binding "body" + var v21 any + if lang.IsTruthy(v20) { + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("next")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v5}) + v21 = v25 + } else { + v21 = v5 + } + var v26 any = v21 + _ = v26 + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("seq")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("concat")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("list")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.Apply(v35, []any{lang.NewSymbol("if")}) + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("list")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("seq")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v44 := v43.FindInternedVar(lang.NewSymbol("concat")) + if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) + } + v45 := v44.Get() + v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v47 := v46.FindInternedVar(lang.NewSymbol("list")) + if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) + } + v48 := v47.Get() + v49 := lang.Apply(v48, []any{lang.NewSymbol("glojure.lang.LockingTransaction/isRunning")}) + v50 := lang.Apply(v45, []any{v49}) + v51 := lang.Apply(v42, []any{v50}) + v52 := lang.Apply(v39, []any{v51}) + v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v54 := v53.FindInternedVar(lang.NewSymbol("list")) + if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) + } + v55 := v54.Get() + v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v57 := v56.FindInternedVar(lang.NewSymbol("seq")) + if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) + } + v58 := v57.Get() + v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v60 := v59.FindInternedVar(lang.NewSymbol("concat")) + if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) + } + v61 := v60.Get() + v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v63 := v62.FindInternedVar(lang.NewSymbol("list")) + if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) + } + v64 := v63.Get() + v65 := lang.Apply(v64, []any{lang.NewSymbol("throw")}) + v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v67 := v66.FindInternedVar(lang.NewSymbol("list")) + if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) + } + v68 := v67.Get() + v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v70 := v69.FindInternedVar(lang.NewSymbol("seq")) + if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) + } + v71 := v70.Get() + v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v73 := v72.FindInternedVar(lang.NewSymbol("concat")) + if v73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) + } + v74 := v73.Get() + v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v76 := v75.FindInternedVar(lang.NewSymbol("list")) + if v76.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) + } + v77 := v76.Get() + v78 := lang.Apply(v77, []any{lang.NewSymbol("new")}) + v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v80 := v79.FindInternedVar(lang.NewSymbol("list")) + if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) + } + v81 := v80.Get() + v82 := lang.Apply(v81, []any{lang.NewSymbol("glojure.core/IllegalStateException")}) + v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v84 := v83.FindInternedVar(lang.NewSymbol("list")) + if v84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) + } + v85 := v84.Get() + var v86 any + { // let + // let binding "or__0__auto__" + var v87 any = v20 + _ = v87 + var v88 any + if lang.IsTruthy(v87) { + v88 = v87 + } else { + v88 = "I/O in transaction" + } + v86 = v88 + } // end let + v87 := lang.Apply(v85, []any{v86}) + v88 := lang.Apply(v74, []any{v78, v82, v87}) + v89 := lang.Apply(v71, []any{v88}) + v90 := lang.Apply(v68, []any{v89}) + v91 := lang.Apply(v61, []any{v65, v90}) + v92 := lang.Apply(v58, []any{v91}) + v93 := lang.Apply(v55, []any{v92}) + v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v95 := v94.FindInternedVar(lang.NewSymbol("list")) + if v95.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) + } + v96 := v95.Get() + v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v98 := v97.FindInternedVar(lang.NewSymbol("seq")) + if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) + } + v99 := v98.Get() + v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v101 := v100.FindInternedVar(lang.NewSymbol("concat")) + if v101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) + } + v102 := v101.Get() + v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v104 := v103.FindInternedVar(lang.NewSymbol("list")) + if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) + } + v105 := v104.Get() + v106 := lang.Apply(v105, []any{lang.NewSymbol("do")}) + v107 := lang.Apply(v102, []any{v106, v26}) + v108 := lang.Apply(v99, []any{v107}) + v109 := lang.Apply(v96, []any{v108}) + v110 := lang.Apply(v32, []any{v36, v52, v93, v109}) + v111 := lang.Apply(v29, []any{v110}) + v6 = v111 + } // end let + return v6 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // isa? + { + v0 := lang.NewSymbol("isa?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("child"), lang.NewSymbol("parent")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("child"), lang.NewSymbol("parent"))), lang.NewKeyword("doc"), "Returns true if (= child parent), or child is directly or indirectly derived from\n parent, either via a Java type inheritance relationship or a\n relationship established via derive. h must be a hierarchy obtained\n from make-hierarchy, if not supplied defaults to the global\n hierarchy", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5543), lang.NewKeyword("end-line"), int(5543))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("isa?")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("global-hierarchy")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v7, []any{v10, v3, v4}) + return v11 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any + { // let + // let binding "or__0__auto__" + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("=")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, []any{v4, v5}) + var v11 any = v10 + _ = v11 + var v12 any + if lang.IsTruthy(v11) { + v12 = v11 + } else { + var v13 any + { // let + // let binding "or__0__auto__" + var v14 any + { // let + // let binding "and__0__auto__" + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("class?")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{v5}) + var v19 any = v18 + _ = v19 + var v20 any + if lang.IsTruthy(v19) { + var v21 any + { // let + // let binding "and__0__auto__" + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("class?")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v4}) + var v26 any = v25 + _ = v26 + var v27 any + if lang.IsTruthy(v26) { + v28, _ := lang.FieldOrMethod(v4, "AssignableTo") + if reflect.TypeOf(v28).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("AssignableTo is not a function"))) + } + v29 := lang.Apply(v28, []any{v5}) + v27 = v29 + } else { + v27 = v26 + } + v21 = v27 + } // end let + v20 = v21 + } else { + v20 = v19 + } + v14 = v20 + } // end let + var v15 any = v14 + _ = v15 + var v16 any + if lang.IsTruthy(v15) { + v16 = v15 + } else { + var v17 any + { // let + // let binding "or__0__auto__" + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("contains?")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) + v22 := lang.Apply(v21, []any{v4}) + v23 := lang.Apply(v20, []any{v22, v5}) + var v24 any = v23 + _ = v24 + var v25 any + if lang.IsTruthy(v24) { + v25 = v24 + } else { + var v26 any + { // let + // let binding "or__0__auto__" + var v27 any + { // let + // let binding "and__0__auto__" + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("class?")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.Apply(v30, []any{v4}) + var v32 any = v31 + _ = v32 + var v33 any + if lang.IsTruthy(v32) { + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("some")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + var v37 lang.FnFunc + v37 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v38 := args[0] + _ = v38 + v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v40 := v39.FindInternedVar(lang.NewSymbol("contains?")) + if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) + } + v41 := v40.Get() + v42 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) + v43 := lang.Apply(v42, []any{v38}) + v44 := lang.Apply(v41, []any{v43, v5}) + return v44 + }) + v38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5556), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(5556), lang.NewKeyword("end-column"), int(71)) + v39, err := lang.WithMeta(v37, v38.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("supers")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.Apply(v42, []any{v4}) + v44 := lang.Apply(v36, []any{v39, v43}) + v33 = v44 + } else { + v33 = v32 + } + v27 = v33 + } // end let + var v28 any = v27 + _ = v28 + var v29 any + if lang.IsTruthy(v28) { + v29 = v28 + } else { + var v30 any + { // let + // let binding "and__0__auto__" + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("vector?")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{v5}) + var v35 any = v34 + _ = v35 + var v36 any + if lang.IsTruthy(v35) { + var v37 any + { // let + // let binding "and__0__auto__" + v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v39 := v38.FindInternedVar(lang.NewSymbol("vector?")) + if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + } + v40 := v39.Get() + v41 := lang.Apply(v40, []any{v4}) + var v42 any = v41 + _ = v42 + var v43 any + if lang.IsTruthy(v42) { + var v44 any + { // let + // let binding "and__0__auto__" + v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v46 := v45.FindInternedVar(lang.NewSymbol("=")) + if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) + } + v47 := v46.Get() + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("count")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v5}) + v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v53 := v52.FindInternedVar(lang.NewSymbol("count")) + if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) + } + v54 := v53.Get() + v55 := lang.Apply(v54, []any{v4}) + v56 := lang.Apply(v47, []any{v51, v55}) + var v57 any = v56 + _ = v57 + var v58 any + if lang.IsTruthy(v57) { + var v59 any + { // let + // let binding "ret" + var v60 any = true + _ = v60 + // let binding "i" + var v61 any = int64(0) + _ = v61 + for { + var v62 any + var v63 any + { // let + // let binding "or__0__auto__" + v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v65 := v64.FindInternedVar(lang.NewSymbol("not")) + if v65.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) + } + v66 := v65.Get() + v67 := lang.Apply(v66, []any{v60}) + var v68 any = v67 + _ = v68 + var v69 any + if lang.IsTruthy(v68) { + v69 = v68 + } else { + v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v71 := v70.FindInternedVar(lang.NewSymbol("=")) + if v71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) + } + v72 := v71.Get() + v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v74 := v73.FindInternedVar(lang.NewSymbol("count")) + if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) + } + v75 := v74.Get() + v76 := lang.Apply(v75, []any{v5}) + v77 := lang.Apply(v72, []any{v61, v76}) + v69 = v77 + } + v63 = v69 + } // end let + if lang.IsTruthy(v63) { + v62 = v60 + } else { + v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v66 := v65.FindInternedVar(lang.NewSymbol("isa?")) + if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) + } + v67 := v66.Get() + v68 := lang.Apply(v4, []any{v61}) + v69 := lang.Apply(v5, []any{v61}) + v70 := lang.Apply(v67, []any{v3, v68, v69}) + var v64 any = v70 + v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v73 := v72.FindInternedVar(lang.NewSymbol("inc")) + if v73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) + } + v74 := v73.Get() + v75 := lang.Apply(v74, []any{v61}) + var v71 any = v75 + v60 = v64 + v61 = v71 + continue + } + v59 = v62 + break + } + } // end let + v58 = v59 + } else { + v58 = v57 + } + v44 = v58 + } // end let + v43 = v44 + } else { + v43 = v42 + } + v37 = v43 + } // end let + v36 = v37 + } else { + v36 = v35 + } + v30 = v36 + } // end let + v29 = v30 + } + v26 = v29 + } // end let + v25 = v26 + } + v17 = v25 + } // end let + v16 = v17 + } + v13 = v16 + } // end let + v12 = v13 + } + v6 = v12 + } // end let + return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // iterate + { + v0 := lang.NewSymbol("iterate").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns a lazy (infinite!) sequence of x, (f x), (f (f x)) etc.\n f must be free of side-effects", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3011), lang.NewKeyword("end-line"), int(3011))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.Apply(nil, []any{v3, v4}) + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // iteration + { + v0 := lang.NewSymbol("iteration").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("step"), lang.NewSymbol("&"), lang.NewMap(lang.NewKeyword("keys"), lang.NewVector(lang.NewSymbol("somef"), lang.NewSymbol("vf"), lang.NewSymbol("kf"), lang.NewSymbol("initk")), lang.NewKeyword("or"), lang.NewMap(lang.NewSymbol("vf"), lang.NewSymbol("identity"), lang.NewSymbol("kf"), lang.NewSymbol("identity"), lang.NewSymbol("somef"), lang.NewSymbol("some?"), lang.NewSymbol("initk"), nil)))), lang.NewKeyword("doc"), "Creates a seqable/reducible via repeated calls to step,\n a function of some (continuation token) 'k'. The first call to step\n will be passed initk, returning 'ret'. Iff (somef ret) is true,\n (vf ret) will be included in the iteration, else iteration will\n terminate and vf/kf will not be called. If (kf ret) is non-nil it\n will be passed to the next step call, else iteration will terminate.\n\n This can be used e.g. to consume APIs that return paginated or batched data.\n\n step - (possibly impure) fn of 'k' -> 'ret'\n\n :somef - fn of 'ret' -> logical true/false, default 'some?'\n :vf - fn of 'ret' -> 'v', a value produced by the iteration, default 'identity'\n :kf - fn of 'ret' -> 'next-k' or nil (signaling 'do not continue'), default 'identity'\n :initk - the first value passed to step, default 'nil'\n\n It is presumed that step with non-initk is unreproducible/non-idempotent.\n If step with initk is unreproducible it is on the consumer to not consume twice.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7716), lang.NewKeyword("end-line"), int(7716))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.NewList(args[1:]...) + var v5 any + { // let + // let binding "map__345" + var v6 any = v4 + _ = v6 + // let binding "map__345" + var v7 any + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("seq?")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v6}) + if lang.IsTruthy(v11) { + var v12 any + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("next")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{v6}) + if lang.IsTruthy(v16) { + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("to-array")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.Apply(v19, []any{v6}) + v21 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{v20}) + v12 = v21 + } else { + var v22 any + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("seq")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.Apply(v25, []any{v6}) + if lang.IsTruthy(v26) { + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("first")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{v6}) + v22 = v30 + } else { + v22 = nil + } + v12 = v22 + } + v7 = v12 + } else { + v7 = v6 + } + var v31 any = v7 + _ = v31 + // let binding "somef" + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("get")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v36 := v35.FindInternedVar(lang.NewSymbol("some?")) + if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + } + v37 := v36.Get() + v38 := lang.Apply(v34, []any{v31, lang.NewKeyword("somef"), v37}) + var v39 any = v38 + _ = v39 + // let binding "vf" + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("get")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v44 := v43.FindInternedVar(lang.NewSymbol("identity")) + if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) + } + v45 := v44.Get() + v46 := lang.Apply(v42, []any{v31, lang.NewKeyword("vf"), v45}) + var v47 any = v46 + _ = v47 + // let binding "kf" + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("get")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v52 := v51.FindInternedVar(lang.NewSymbol("identity")) + if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) + } + v53 := v52.Get() + v54 := lang.Apply(v50, []any{v31, lang.NewKeyword("kf"), v53}) + var v55 any = v54 + _ = v55 + // let binding "initk" + v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v57 := v56.FindInternedVar(lang.NewSymbol("get")) + if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) + } + v58 := v57.Get() + v59 := lang.Apply(v58, []any{v31, lang.NewKeyword("initk"), nil}) + var v60 any = v59 + _ = v60 + v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v62 := v61.FindInternedVar(lang.NewSymbol("seq")) + if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) + } + v63 := v62.Get() + v64 := lang.NewVector(nil) + v65 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7743), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(7743), lang.NewKeyword("end-column"), int(11)) + v66, err := lang.WithMeta(v64, v65.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v67 lang.FnFunc + { // function next + v67 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v69 := args[0] + _ = v69 + var v70 any + v71 := lang.Apply(v39, []any{v69}) + if lang.IsTruthy(v71) { + v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v73 := v72.FindInternedVar(lang.NewSymbol("cons")) + if v73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) + } + v74 := v73.Get() + v75 := lang.Apply(v47, []any{v69}) + var v76 any + { // let + // let binding "temp__0__auto__" + v77 := lang.Apply(v55, []any{v69}) + var v78 any = v77 + _ = v78 + var v79 any + v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v81 := v80.FindInternedVar(lang.NewSymbol("nil?")) + if v81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) + } + v82 := v81.Get() + v83 := lang.Apply(v82, []any{v78}) + if lang.IsTruthy(v83) { + v79 = nil + } else { + var v84 any + { // let + // let binding "k" + var v85 any = v78 + _ = v85 + var v86 lang.FnFunc + v86 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v87 := lang.Apply(v3, []any{v85}) + v88 := lang.Apply(v68, []any{v87}) + return v88 + }) + v87 := lang.Apply(lang.NewLazySeq, []any{v86}) + v84 = v87 + } // end let + v79 = v84 + } + v76 = v79 + } // end let + v77 := lang.Apply(v74, []any{v75, v76}) + v70 = v77 + } else { + v70 = nil + } + return v70 + }) + v68 := v67 + _ = v68 + } + v68 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7744), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(7748), lang.NewKeyword("end-column"), int(51)) + v69, err := lang.WithMeta(v67, v68.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v70 := lang.Apply(v3, []any{v60}) + v71 := lang.Apply(v69, []any{v70}) + v72 := lang.Apply(v63, []any{v66, v71}) + v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v74 := v73.FindInternedVar(lang.NewSymbol("reduce")) + if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) + } + v75 := v74.Get() + v76 := lang.NewVector(nil, nil, nil) + v77 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7751), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(7751), lang.NewKeyword("end-column"), int(22)) + v78, err := lang.WithMeta(v76, v77.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v79 any + { // let + // let binding "acc" + var v80 any = nil + _ = v80 + // let binding "ret" + v81 := lang.Apply(v3, []any{v60}) + var v82 any = v81 + _ = v82 + for { + var v83 any + v84 := lang.Apply(v39, []any{v82}) + if lang.IsTruthy(v84) { + var v85 any + { // let + // let binding "acc" + v86 := lang.Apply(v47, []any{v82}) + v87 := lang.Apply(nil, []any{v80, v86}) + var v88 any = v87 + _ = v88 + var v89 any + v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v91 := v90.FindInternedVar(lang.NewSymbol("reduced?")) + if v91.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) + } + v92 := v91.Get() + v93 := lang.Apply(v92, []any{v88}) + if lang.IsTruthy(v93) { + v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v95 := v94.FindInternedVar(lang.NewSymbol("deref")) + if v95.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) + } + v96 := v95.Get() + v97 := lang.Apply(v96, []any{v88}) + v89 = v97 + } else { + var v98 any + { // let + // let binding "temp__0__auto__" + v99 := lang.Apply(v55, []any{v82}) + var v100 any = v99 + _ = v100 + var v101 any + v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v103 := v102.FindInternedVar(lang.NewSymbol("nil?")) + if v103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) + } + v104 := v103.Get() + v105 := lang.Apply(v104, []any{v100}) + if lang.IsTruthy(v105) { + v101 = v88 + } else { + var v106 any + { // let + // let binding "k" + var v107 any = v100 + _ = v107 + var v108 any = v88 + v110 := lang.Apply(v3, []any{v107}) + var v109 any = v110 + v80 = v108 + v82 = v109 + continue + } // end let + v101 = v106 + } + v98 = v101 + } // end let + v89 = v98 + } + v85 = v89 + } // end let + v83 = v85 + } else { + v83 = v80 + } + v79 = v83 + break + } + } // end let + v80 := lang.Apply(v75, []any{v78, v79}) + v81 := lang.Apply(nil, []any{nil, v72, lang.IReduceInit, v80}) + v5 = v81 + } // end let + return v5 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // iterator-seq + { + v0 := lang.NewSymbol("iterator-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("iter"))), lang.NewKeyword("doc"), "Returns a seq on a java.util.Iterator. Note that most collections\n providing iterators implement Iterable and thus support seq directly.\n Seqs cache values, thus iterator-seq should not be used on any\n iterator that repeatedly returns the same mutable object.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5700), lang.NewKeyword("end-line"), int(5700))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.Apply(nil, []any{v3}) + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // juxt + { + v0 := lang.NewSymbol("juxt").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("g")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("g"), lang.NewSymbol("h")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("g"), lang.NewSymbol("h"), lang.NewSymbol("&"), lang.NewSymbol("fs"))), lang.NewKeyword("doc"), "Takes a set of functions and returns a fn that is the juxtaposition\n of those fns. The returned fn takes a variable number of args, and\n returns a vector containing the result of applying each fn to the\n args (left-to-right).\n ((juxt a b c) x) => [(a x) (b x) (c x)]", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2568), lang.NewKeyword("end-line"), int(2568))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + var v4 lang.FnFunc + v4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + v5 := lang.Apply(v3, nil) + v6 := lang.NewVector(v5) + v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2578), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(2578), lang.NewKeyword("end-column"), int(16)) + v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v8 + case 1: + v5 := args[0] + _ = v5 + v6 := lang.Apply(v3, []any{v5}) + v7 := lang.NewVector(v6) + v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2579), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(2579), lang.NewKeyword("end-column"), int(19)) + v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v9 + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := lang.Apply(v3, []any{v5, v6}) + v8 := lang.NewVector(v7) + v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2580), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(2580), lang.NewKeyword("end-column"), int(23)) + v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v10 + case 3: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := args[2] + _ = v7 + v8 := lang.Apply(v3, []any{v5, v6, v7}) + v9 := lang.NewVector(v8) + v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2581), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(2581), lang.NewKeyword("end-column"), int(27)) + v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v11 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := args[2] + _ = v7 + v8 := lang.NewList(args[3:]...) + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("apply")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.Apply(v11, []any{v3, v5, v6, v7, v8}) + v13 := lang.NewVector(v12) + v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2582), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(2582), lang.NewKeyword("end-column"), int(45)) + v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v15 + } + }) + v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2577), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2582), lang.NewKeyword("end-column"), int(47)) + v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v6 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 lang.FnFunc + v5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + v6 := lang.Apply(v3, nil) + v7 := lang.Apply(v4, nil) + v8 := lang.NewVector(v6, v7) + v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2585), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(2585), lang.NewKeyword("end-column"), int(20)) + v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v10 + case 1: + v6 := args[0] + _ = v6 + v7 := lang.Apply(v3, []any{v6}) + v8 := lang.Apply(v4, []any{v6}) + v9 := lang.NewVector(v7, v8) + v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2586), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(2586), lang.NewKeyword("end-column"), int(25)) + v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v11 + case 2: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := lang.Apply(v3, []any{v6, v7}) + v9 := lang.Apply(v4, []any{v6, v7}) + v10 := lang.NewVector(v8, v9) + v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2587), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(2587), lang.NewKeyword("end-column"), int(31)) + v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v12 + case 3: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + v9 := lang.Apply(v3, []any{v6, v7, v8}) + v10 := lang.Apply(v4, []any{v6, v7, v8}) + v11 := lang.NewVector(v9, v10) + v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2588), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(2588), lang.NewKeyword("end-column"), int(37)) + v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v13 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + v9 := lang.NewList(args[3:]...) + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("apply")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{v3, v6, v7, v8, v9}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("apply")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{v4, v6, v7, v8, v9}) + v18 := lang.NewVector(v13, v17) + v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2589), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(2589), lang.NewKeyword("end-column"), int(66)) + v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v20 + } + }) + v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2584), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2589), lang.NewKeyword("end-column"), int(68)) + v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v7 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 lang.FnFunc + v6 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + v7 := lang.Apply(v3, nil) + v8 := lang.Apply(v4, nil) + v9 := lang.Apply(v5, nil) + v10 := lang.NewVector(v7, v8, v9) + v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2592), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(2592), lang.NewKeyword("end-column"), int(24)) + v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v12 + case 1: + v7 := args[0] + _ = v7 + v8 := lang.Apply(v3, []any{v7}) + v9 := lang.Apply(v4, []any{v7}) + v10 := lang.Apply(v5, []any{v7}) + v11 := lang.NewVector(v8, v9, v10) + v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2593), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(2593), lang.NewKeyword("end-column"), int(31)) + v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v13 + case 2: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := lang.Apply(v3, []any{v7, v8}) + v10 := lang.Apply(v4, []any{v7, v8}) + v11 := lang.Apply(v5, []any{v7, v8}) + v12 := lang.NewVector(v9, v10, v11) + v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2594), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(2594), lang.NewKeyword("end-column"), int(39)) + v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v14 + case 3: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + v10 := lang.Apply(v3, []any{v7, v8, v9}) + v11 := lang.Apply(v4, []any{v7, v8, v9}) + v12 := lang.Apply(v5, []any{v7, v8, v9}) + v13 := lang.NewVector(v10, v11, v12) + v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2595), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(2595), lang.NewKeyword("end-column"), int(47)) + v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v15 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + v10 := lang.NewList(args[3:]...) + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("apply")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{v3, v7, v8, v9, v10}) + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("apply")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{v4, v7, v8, v9, v10}) + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("apply")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{v5, v7, v8, v9, v10}) + v23 := lang.NewVector(v14, v18, v22) + v24 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2596), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(2596), lang.NewKeyword("end-column"), int(87)) + v25, err := lang.WithMeta(v23, v24.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v25 + } + }) + v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2591), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2596), lang.NewKeyword("end-column"), int(89)) + v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v8 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + var v7 any + { // let + // let binding "fs" + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("list*")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v3, v4, v5, v6}) + var v12 any = v11 + _ = v12 + var v13 lang.FnFunc + v13 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("reduce1")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + var v17 lang.FnFunc + v17 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v18 := args[0] + _ = v18 + v19 := args[1] + _ = v19 + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("conj")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.Apply(v19, nil) + v24 := lang.Apply(v22, []any{v18, v23}) + return v24 + }) + v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2600), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(2600), lang.NewKeyword("end-column"), int(37)) + v19, err := lang.WithMeta(v17, v18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v20 := lang.NewVector() + v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2600), lang.NewKeyword("column"), int(39), lang.NewKeyword("end-line"), int(2600), lang.NewKeyword("end-column"), int(40)) + v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v23 := lang.Apply(v16, []any{v19, v22, v12}) + return v23 + case 1: + v14 := args[0] + _ = v14 + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("reduce1")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + var v18 lang.FnFunc + v18 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v19 := args[0] + _ = v19 + v20 := args[1] + _ = v20 + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("conj")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.Apply(v20, []any{v14}) + v25 := lang.Apply(v23, []any{v19, v24}) + return v25 + }) + v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2601), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(2601), lang.NewKeyword("end-column"), int(40)) + v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v21 := lang.NewVector() + v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2601), lang.NewKeyword("column"), int(42), lang.NewKeyword("end-line"), int(2601), lang.NewKeyword("end-column"), int(43)) + v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v24 := lang.Apply(v17, []any{v20, v23, v12}) + return v24 + case 2: + v14 := args[0] + _ = v14 + v15 := args[1] + _ = v15 + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("reduce1")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + var v19 lang.FnFunc + v19 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v20 := args[0] + _ = v20 + v21 := args[1] + _ = v21 + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("conj")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v21, []any{v14, v15}) + v26 := lang.Apply(v24, []any{v20, v25}) + return v26 + }) + v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2602), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(2602), lang.NewKeyword("end-column"), int(44)) + v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v22 := lang.NewVector() + v23 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2602), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(2602), lang.NewKeyword("end-column"), int(47)) + v24, err := lang.WithMeta(v22, v23.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v25 := lang.Apply(v18, []any{v21, v24, v12}) + return v25 + case 3: + v14 := args[0] + _ = v14 + v15 := args[1] + _ = v15 + v16 := args[2] + _ = v16 + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("reduce1")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + var v20 lang.FnFunc + v20 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v21 := args[0] + _ = v21 + v22 := args[1] + _ = v22 + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("conj")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.Apply(v22, []any{v14, v15, v16}) + v27 := lang.Apply(v25, []any{v21, v26}) + return v27 + }) + v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2603), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(2603), lang.NewKeyword("end-column"), int(48)) + v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v23 := lang.NewVector() + v24 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2603), lang.NewKeyword("column"), int(50), lang.NewKeyword("end-line"), int(2603), lang.NewKeyword("end-column"), int(51)) + v25, err := lang.WithMeta(v23, v24.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v26 := lang.Apply(v19, []any{v22, v25, v12}) + return v26 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v14 := args[0] + _ = v14 + v15 := args[1] + _ = v15 + v16 := args[2] + _ = v16 + v17 := lang.NewList(args[3:]...) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("reduce1")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + var v21 lang.FnFunc + v21 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v22 := args[0] + _ = v22 + v23 := args[1] + _ = v23 + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("conj")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("apply")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{v23, v14, v15, v16, v17}) + v31 := lang.Apply(v26, []any{v22, v30}) + return v31 + }) + v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2604), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(2604), lang.NewKeyword("end-column"), int(66)) + v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v24 := lang.NewVector() + v25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2604), lang.NewKeyword("column"), int(68), lang.NewKeyword("end-line"), int(2604), lang.NewKeyword("end-column"), int(69)) + v26, err := lang.WithMeta(v24, v25.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v27 := lang.Apply(v20, []any{v23, v26, v12}) + return v27 + } + }) + v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2599), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(2604), lang.NewKeyword("end-column"), int(75)) + v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v7 = v15 + } // end let + return v7 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // keep + { + v0 := lang.NewSymbol("keep").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the non-nil results of (f item). Note,\n this means false return values will be included. f must be free of\n side-effects. Returns a transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7339), lang.NewKeyword("end-line"), int(7339))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + var v4 lang.FnFunc + v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + var v6 lang.FnFunc + v6 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + v7 := lang.Apply(v5, nil) + return v7 + case 1: + v7 := args[0] + _ = v7 + v8 := lang.Apply(v5, []any{v7}) + return v8 + case 2: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + var v9 any + { // let + // let binding "v" + v10 := lang.Apply(v3, []any{v8}) + var v11 any = v10 + _ = v11 + var v12 any + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("nil?")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{v11}) + if lang.IsTruthy(v16) { + v12 = v7 + } else { + v17 := lang.Apply(v5, []any{v7, v11}) + v12 = v17 + } + v9 = v12 + } // end let + return v9 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7347), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7354), lang.NewKeyword("end-column"), int(31)) + v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v8 + }) + v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7346), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7354), lang.NewKeyword("end-column"), int(32)) + v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v6 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 lang.FnFunc + v5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v6 any + { // let + // let binding "temp__0__auto__" + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("seq")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, []any{v4}) + var v11 any = v10 + _ = v11 + var v12 any + if lang.IsTruthy(v11) { + var v13 any + { // let + // let binding "s" + var v14 any = v11 + _ = v14 + var v15 any + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("chunked-seq?")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{v14}) + if lang.IsTruthy(v19) { + var v20 any + { // let + // let binding "c" + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("chunk-first")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.Apply(v23, []any{v14}) + var v25 any = v24 + _ = v25 + // let binding "size" + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("count")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.Apply(v28, []any{v25}) + var v30 any = v29 + _ = v30 + // let binding "b" + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("chunk-buffer")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{v30}) + var v35 any = v34 + _ = v35 + var v36 any + { // let + // let binding "n__0__auto__" + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("long")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.Apply(v39, []any{v30}) + var v41 any = v40 + _ = v41 + var v42 any + { // let + // let binding "i" + var v43 any = int64(0) + _ = v43 + for { + var v44 any + v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v46 := v45.FindInternedVar(lang.NewSymbol("<")) + if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) + } + v47 := v46.Get() + v48 := lang.Apply(v47, []any{v43, v41}) + if lang.IsTruthy(v48) { + var v49 any + { // let + // let binding "x" + v50, _ := lang.FieldOrMethod(v25, "nth") + if reflect.TypeOf(v50).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + v51 := lang.Apply(v50, []any{v43}) + v52 := lang.Apply(v3, []any{v51}) + var v53 any = v52 + _ = v53 + var v54 any + v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v56 := v55.FindInternedVar(lang.NewSymbol("nil?")) + if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) + } + v57 := v56.Get() + v58 := lang.Apply(v57, []any{v53}) + if lang.IsTruthy(v58) { + v54 = nil + } else { + v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v60 := v59.FindInternedVar(lang.NewSymbol("chunk-append")) + if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) + } + v61 := v60.Get() + v62 := lang.Apply(v61, []any{v35, v53}) + v54 = v62 + } + v49 = v54 + } // end let + _ = v49 + v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v52 := v51.FindInternedVar(lang.NewSymbol("unchecked-inc")) + if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) + } + v53 := v52.Get() + v54 := lang.Apply(v53, []any{v43}) + var v50 any = v54 + v43 = v50 + continue + } else { + v44 = nil + } + v42 = v44 + break + } + } // end let + v36 = v42 + } // end let + _ = v36 + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("chunk-cons")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("chunk")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.Apply(v42, []any{v35}) + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("keep")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v48 := v47.FindInternedVar(lang.NewSymbol("chunk-rest")) + if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) + } + v49 := v48.Get() + v50 := lang.Apply(v49, []any{v14}) + v51 := lang.Apply(v46, []any{v3, v50}) + v52 := lang.Apply(v39, []any{v43, v51}) + v20 = v52 + } // end let + v15 = v20 + } else { + var v21 any + { // let + // let binding "x" + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("first")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v14}) + v26 := lang.Apply(v3, []any{v25}) + var v27 any = v26 + _ = v27 + var v28 any + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("nil?")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.Apply(v31, []any{v27}) + if lang.IsTruthy(v32) { + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("keep")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("rest")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v38, []any{v14}) + v40 := lang.Apply(v35, []any{v3, v39}) + v28 = v40 + } else { + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("cons")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("keep")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v48 := v47.FindInternedVar(lang.NewSymbol("rest")) + if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) + } + v49 := v48.Get() + v50 := lang.Apply(v49, []any{v14}) + v51 := lang.Apply(v46, []any{v3, v50}) + v52 := lang.Apply(v43, []any{v27, v51}) + v28 = v52 + } + v21 = v28 + } // end let + v15 = v21 + } + v13 = v15 + } // end let + v12 = v13 + } else { + v12 = nil + } + v6 = v12 + } // end let + return v6 + }) + v6 := lang.Apply(lang.NewLazySeq, []any{v5}) + return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // keep-indexed + { + v0 := lang.NewSymbol("keep-indexed").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the non-nil results of (f index item). Note,\n this means false return values will be included. f must be free of\n side-effects. Returns a stateful transducer when no collection is\n provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7372), lang.NewKeyword("end-line"), int(7372))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + var v4 lang.FnFunc + v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + var v6 any + { // let + // let binding "iv" + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("volatile!")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, []any{int64(-1)}) + var v11 any = v10 + _ = v11 + var v12 lang.FnFunc + v12 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + v13 := lang.Apply(v5, nil) + return v13 + case 1: + v13 := args[0] + _ = v13 + v14 := lang.Apply(v5, []any{v13}) + return v14 + case 2: + v13 := args[0] + _ = v13 + v14 := args[1] + _ = v14 + var v15 any + { // let + // let binding "i" + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("inc")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19, ok := lang.FieldOrMethod(v11, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v11, "Deref"))) + } + var v20 any + switch reflect.TypeOf(v19).Kind() { + case reflect.Func: + v20 = lang.Apply(v19, nil) + default: + v20 = v19 + } + v21 := lang.Apply(v18, []any{v20}) + v22, _ := lang.FieldOrMethod(v11, "reset") + if reflect.TypeOf(v22).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) + } + v23 := lang.Apply(v22, []any{v21}) + var v24 any = v23 + _ = v24 + // let binding "v" + v25 := lang.Apply(v3, []any{v24, v14}) + var v26 any = v25 + _ = v26 + var v27 any + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("nil?")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.Apply(v30, []any{v26}) + if lang.IsTruthy(v31) { + v27 = v13 + } else { + v32 := lang.Apply(v5, []any{v13, v26}) + v27 = v32 + } + v15 = v27 + } // end let + return v15 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7382), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7390), lang.NewKeyword("end-column"), int(33)) + v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v6 = v14 + } // end let + return v6 + }) + v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7380), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7390), lang.NewKeyword("end-column"), int(35)) + v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v6 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + return nil + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // key + { + v0 := lang.NewSymbol("key").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("e"))), lang.NewKeyword("doc"), "Returns the key of the map entry.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1563), lang.NewKeyword("end-line"), int(1563))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4, _ := lang.FieldOrMethod(v3, "GetKey") + if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("GetKey is not a function"))) + } + v5 := lang.Apply(v4, []any{}) + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // keys + { + v0 := lang.NewSymbol("keys").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"))), lang.NewKeyword("doc"), "Returns a sequence of the map's keys, in the same order as (seq map).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1551), lang.NewKeyword("end-line"), int(1551))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.Apply(lang.Keys, []any{v3}) + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // keyword + { + v1 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() + v0 := lang.NewSymbol("keyword").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name"))), lang.NewKeyword("doc"), "Returns a Keyword with the given namespace and name. Do not use :\n in the keyword strings, it will be added automatically.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(609), lang.NewKeyword("end-line"), int(609))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + var v5 any + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("keyword?")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{v4}) + if lang.IsTruthy(v9) { + v5 = v4 + } else { + var v10 any + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("symbol?")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{v4}) + if lang.IsTruthy(v14) { + v15 := lang.Apply(lang.InternKeywordSymbol, []any{v4}) + v10 = v15 + } else { + var v16 any + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("string?")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.Apply(v19, []any{v4}) + if lang.IsTruthy(v20) { + v21 := lang.Apply(lang.InternKeywordString, []any{v4}) + v16 = v21 + } else { + v16 = nil + } + v10 = v16 + } + v5 = v10 + } + return v5 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := lang.Apply(lang.InternKeyword, []any{v4, v5}) + return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v4 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // keyword? + { + v0 := lang.NewSymbol("keyword?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a Keyword", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(563), lang.NewKeyword("end-line"), int(563))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.Apply(v6, []any{lang.Keyword, v3}) + return v7 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // last + { + v0 := lang.NewSymbol("last").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return the last item in coll, in linear time", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(262), lang.NewKeyword("end-line"), int(266))).(*lang.Symbol) + var v2 lang.FnFunc + { // function last + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + recur_loop_32: + var v5 any + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("next")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{v4}) + if lang.IsTruthy(v9) { + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("next")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{v4}) + var v10 any = v14 + v4 = v10 + goto recur_loop_32 + } else { + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("first")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{v4}) + v5 = v18 + } + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(266), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(269), lang.NewKeyword("end-column"), int(21))).(lang.FnFunc) + v3 := v2 + _ = v3 + } + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // lazy-cat + { + v0 := lang.NewSymbol("lazy-cat").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Expands to code which yields a lazy sequence of the concatenation\n of the supplied colls. Each coll expr is not evaluated until it is\n needed. \n\n (lazy-cat xs ys zs) === (concat (lazy-seq xs) (lazy-seq ys) (lazy-seq zs))", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4636), lang.NewKeyword("end-line"), int(4636))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.NewList(args[2:]...) + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("seq")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("concat")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("list")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.Apply(v14, []any{lang.NewSymbol("glojure.core/concat")}) + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("map")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + var v19 lang.FnFunc + v19 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v20 := args[0] + _ = v20 + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("list")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.Apply(v23, []any{lang.NewSymbol("glojure.core/lazy-seq"), v20}) + return v24 + }) + v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4644), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(4644), lang.NewKeyword("end-column"), int(37)) + v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v22 := lang.Apply(v18, []any{v21, v5}) + v23 := lang.Apply(v11, []any{v15, v22}) + v24 := lang.Apply(v8, []any{v23}) + return v24 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // lazy-seq + { + v0 := lang.NewSymbol("lazy-seq").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Takes a body of expressions that returns an ISeq or nil, and yields\n a Seqable object that will invoke the body only the first time seq\n is called, and will cache the result and return it on all subsequent\n seq calls. See also - realized?", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(676), lang.NewKeyword("end-line"), int(676))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.NewList(args[2:]...) + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("list")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("list*")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.NewVector() + v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(683), lang.NewKeyword("column"), int(101), lang.NewKeyword("end-line"), int(683), lang.NewKeyword("end-column"), int(102)) + v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v15 := lang.Apply(v11, []any{lang.NewSymbol("fn*"), v14, v5}) + v16 := lang.Apply(v8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewLazySeq"), v15}) + return v16 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // let + { + v0 := lang.NewSymbol("let").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "binding => binding-form init-expr\n binding-form => name, or destructuring-form\n destructuring-form => map-destructure-form, or seq-destructure-form\n\n Evaluates the exprs in a lexical context in which the symbols in\n the binding-forms are bound to their respective init-exprs or parts\n therein.\n\n See https://glojure.org/reference/special_forms#binding-forms for\n more information about destructuring.", lang.NewKeyword("forms"), lang.NewVector(lang.NewList(lang.NewSymbol("let"), lang.NewVector(lang.NewSymbol("bindings*")), lang.NewSymbol("exprs*"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4496), lang.NewKeyword("end-line"), int(4496), lang.NewKeyword("special-form"), true)).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + var v7 any + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v5}) + if lang.IsTruthy(v11) { + v7 = nil + } else { + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("str")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("first")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{v3}) + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("meta")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v3}) + v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) + v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) + v28 := lang.Apply(lang.NewIllegalArgumentError, []any{v27}) + panic(v28) + } + _ = v7 + var v29 any + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("even?")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("count")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.Apply(v35, []any{v5}) + v37 := lang.Apply(v32, []any{v36}) + if lang.IsTruthy(v37) { + v29 = nil + } else { + v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v39 := v38.FindInternedVar(lang.NewSymbol("str")) + if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + } + v40 := v39.Get() + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("first")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.Apply(v43, []any{v3}) + v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) + if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) + } + v47 := v46.Get() + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("meta")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v3}) + v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) + v53 := lang.Apply(v40, []any{v44, " requires ", "an even number of forms in binding vector", " in ", v47, ":", v52}) + v54 := lang.Apply(lang.NewIllegalArgumentError, []any{v53}) + panic(v54) + } + _ = v29 + _ = nil + v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v56 := v55.FindInternedVar(lang.NewSymbol("seq")) + if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) + } + v57 := v56.Get() + v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v59 := v58.FindInternedVar(lang.NewSymbol("concat")) + if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) + } + v60 := v59.Get() + v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v62 := v61.FindInternedVar(lang.NewSymbol("list")) + if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) + } + v63 := v62.Get() + v64 := lang.Apply(v63, []any{lang.NewSymbol("let*")}) + v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v66 := v65.FindInternedVar(lang.NewSymbol("list")) + if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) + } + v67 := v66.Get() + v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v69 := v68.FindInternedVar(lang.NewSymbol("destructure")) + if v69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) + } + v70 := v69.Get() + v71 := lang.Apply(v70, []any{v5}) + v72 := lang.Apply(v67, []any{v71}) + v73 := lang.Apply(v60, []any{v64, v72, v6}) + v74 := lang.Apply(v57, []any{v73}) + return v74 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // letfn + { + v0 := lang.NewSymbol("letfn").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fnspecs"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "fnspec ==> (fname [params*] exprs) or (fname ([params*] exprs)+)\n\n Takes a vector of function specs and a body, and generates a set of\n bindings of functions to their names. All of the names are available\n in all of the definitions of the functions, as well as the body.", lang.NewKeyword("forms"), lang.NewVector(lang.NewList(lang.NewSymbol("letfn"), lang.NewVector(lang.NewSymbol("fnspecs*")), lang.NewSymbol("exprs*"))), lang.NewKeyword("url"), nil, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6545), lang.NewKeyword("end-line"), int(6545), lang.NewKeyword("special-form"), true)).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("seq")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("concat")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("list")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{lang.NewSymbol("letfn*")}) + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("list")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("vec")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("interleave")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("map")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("first")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.Apply(v28, []any{v31, v5}) + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("map")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + var v36 lang.FnFunc + v36 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v37 := args[0] + _ = v37 + v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v39 := v38.FindInternedVar(lang.NewSymbol("cons")) + if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + } + v40 := v39.Get() + v41 := lang.Apply(v40, []any{lang.NewSymbol("glojure.core/fn"), v37}) + return v41 + }) + v37 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6555), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(6555), lang.NewKeyword("end-column"), int(47)) + v38, err := lang.WithMeta(v36, v37.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v39 := lang.Apply(v35, []any{v38, v5}) + v40 := lang.Apply(v25, []any{v32, v39}) + v41 := lang.Apply(v22, []any{v40}) + v42 := lang.Apply(v19, []any{v41}) + v43 := lang.Apply(v12, []any{v16, v42, v6}) + v44 := lang.Apply(v9, []any{v43}) + return v44 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // libspec? + { + v0 := lang.NewSymbol("libspec?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is a libspec", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5848), lang.NewKeyword("end-line"), int(5848), lang.NewKeyword("private"), true)).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + { // let + // let binding "or__0__auto__" + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("symbol?")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v3}) + var v9 any = v8 + _ = v9 + var v10 any + if lang.IsTruthy(v9) { + v10 = v9 + } else { + var v11 any + { // let + // let binding "and__0__auto__" + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("vector?")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.Apply(v14, []any{v3}) + var v16 any = v15 + _ = v16 + var v17 any + if lang.IsTruthy(v16) { + var v18 any + { // let + // let binding "or__0__auto__" + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("nil?")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("second")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v3}) + v26 := lang.Apply(v21, []any{v25}) + var v27 any = v26 + _ = v27 + var v28 any + if lang.IsTruthy(v27) { + v28 = v27 + } else { + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("keyword?")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("second")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{v3}) + v36 := lang.Apply(v31, []any{v35}) + v28 = v36 + } + v18 = v28 + } // end let + v17 = v18 + } else { + v17 = v16 + } + v11 = v17 + } // end let + v10 = v11 + } + v4 = v10 + } // end let + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // lift-ns + { + v0 := lang.NewSymbol("lift-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"))), lang.NewKeyword("doc"), "Returns [lifted-ns lifted-kvs] or nil if m can't be lifted.", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(261), lang.NewKeyword("end-line"), int(261), lang.NewKeyword("private"), true)).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("*print-namespace-maps*")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + if lang.IsTruthy(v7) { + var v8 any + { // let + // let binding "ns" + var v9 any = nil + _ = v9 + // let binding "G__221" + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("seq")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{v3}) + var v14 any = v13 + _ = v14 + // let binding "vec__222" + var v15 any = v14 + _ = v15 + // let binding "seq__223" + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("seq")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{v15}) + var v20 any = v19 + _ = v20 + // let binding "first__224" + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("first")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.Apply(v23, []any{v20}) + var v25 any = v24 + _ = v25 + // let binding "seq__223" + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("next")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.Apply(v28, []any{v20}) + var v30 any = v29 + _ = v30 + // let binding "vec__225" + var v31 any = v25 + _ = v31 + // let binding "k" + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("nth")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{v31, int64(0), nil}) + var v36 any = v35 + _ = v36 + // let binding "v" + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("nth")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.Apply(v39, []any{v31, int64(1), nil}) + var v41 any = v40 + _ = v41 + // let binding "entry" + var v42 any = v31 + _ = v42 + // let binding "entries" + var v43 any = v30 + _ = v43 + // let binding "kvs" + v44 := lang.NewVector() + v45 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(267), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(267), lang.NewKeyword("end-column"), int(17)) + v46, err := lang.WithMeta(v44, v45.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v47 any = v46 + _ = v47 + var v48 any + { // let + // let binding "ns" + var v49 any = v9 + _ = v49 + // let binding "G__221" + var v50 any = v14 + _ = v50 + // let binding "kvs" + var v51 any = v47 + _ = v51 + for { + var v52 any + { // let + // let binding "ns" + var v53 any = v49 + _ = v53 + // let binding "vec__228" + var v54 any = v50 + _ = v54 + // let binding "seq__229" + v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v56 := v55.FindInternedVar(lang.NewSymbol("seq")) + if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) + } + v57 := v56.Get() + v58 := lang.Apply(v57, []any{v54}) + var v59 any = v58 + _ = v59 + // let binding "first__230" + v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v61 := v60.FindInternedVar(lang.NewSymbol("first")) + if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) + } + v62 := v61.Get() + v63 := lang.Apply(v62, []any{v59}) + var v64 any = v63 + _ = v64 + // let binding "seq__229" + v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v66 := v65.FindInternedVar(lang.NewSymbol("next")) + if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) + } + v67 := v66.Get() + v68 := lang.Apply(v67, []any{v59}) + var v69 any = v68 + _ = v69 + // let binding "vec__231" + var v70 any = v64 + _ = v70 + // let binding "k" + v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v72 := v71.FindInternedVar(lang.NewSymbol("nth")) + if v72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) + } + v73 := v72.Get() + v74 := lang.Apply(v73, []any{v70, int64(0), nil}) + var v75 any = v74 + _ = v75 + // let binding "v" + v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v77 := v76.FindInternedVar(lang.NewSymbol("nth")) + if v77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) + } + v78 := v77.Get() + v79 := lang.Apply(v78, []any{v70, int64(1), nil}) + var v80 any = v79 + _ = v80 + // let binding "entry" + var v81 any = v70 + _ = v81 + // let binding "entries" + var v82 any = v69 + _ = v82 + // let binding "kvs" + var v83 any = v51 + _ = v83 + var v84 any + if lang.IsTruthy(v81) { + var v85 any + v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v87 := v86.FindInternedVar(lang.NewSymbol("qualified-ident?")) + if v87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) + } + v88 := v87.Get() + v89 := lang.Apply(v88, []any{v75}) + if lang.IsTruthy(v89) { + var v90 any + if lang.IsTruthy(v53) { + var v91 any + v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v93 := v92.FindInternedVar(lang.NewSymbol("=")) + if v93.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) + } + v94 := v93.Get() + v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v96 := v95.FindInternedVar(lang.NewSymbol("namespace")) + if v96.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) + } + v97 := v96.Get() + v98 := lang.Apply(v97, []any{v75}) + v99 := lang.Apply(v94, []any{v53, v98}) + if lang.IsTruthy(v99) { + var v100 any = v53 + var v101 any = v82 + v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v104 := v103.FindInternedVar(lang.NewSymbol("conj")) + if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) + } + v105 := v104.Get() + v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v107 := v106.FindInternedVar(lang.NewSymbol("strip-ns")) + if v107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) + } + v108 := v107.Get() + v109 := lang.Apply(v108, []any{v75}) + v110 := lang.NewVector(v109, v80) + v111 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(272), lang.NewKeyword("column"), int(43), lang.NewKeyword("end-line"), int(272), lang.NewKeyword("end-column"), int(58)) + v112, err := lang.WithMeta(v110, v111.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v113 := lang.Apply(v105, []any{v83, v112}) + var v102 any = v113 + v49 = v100 + v50 = v101 + v51 = v102 + continue + } else { + v91 = nil + } + v90 = v91 + } else { + var v114 any + { // let + // let binding "temp__0__auto__" + v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v116 := v115.FindInternedVar(lang.NewSymbol("namespace")) + if v116.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) + } + v117 := v116.Get() + v118 := lang.Apply(v117, []any{v75}) + var v119 any = v118 + _ = v119 + var v120 any + if lang.IsTruthy(v119) { + var v121 any + { // let + // let binding "new-ns" + var v122 any = v119 + _ = v122 + var v123 any = v122 + var v124 any = v82 + v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v127 := v126.FindInternedVar(lang.NewSymbol("conj")) + if v127.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) + } + v128 := v127.Get() + v129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v130 := v129.FindInternedVar(lang.NewSymbol("strip-ns")) + if v130.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v130))) + } + v131 := v130.Get() + v132 := lang.Apply(v131, []any{v75}) + v133 := lang.NewVector(v132, v80) + v134 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(274), lang.NewKeyword("column"), int(47), lang.NewKeyword("end-line"), int(274), lang.NewKeyword("end-column"), int(62)) + v135, err := lang.WithMeta(v133, v134.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v136 := lang.Apply(v128, []any{v83, v135}) + var v125 any = v136 + v49 = v123 + v50 = v124 + v51 = v125 + continue + } // end let + v120 = v121 + } else { + v120 = nil + } + v114 = v120 + } // end let + v90 = v114 + } + v85 = v90 + } else { + v85 = nil + } + v84 = v85 + } else { + v115 := lang.NewVector(v53, v83) + v116 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(275), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(275), lang.NewKeyword("end-column"), int(16)) + v117, err := lang.WithMeta(v115, v116.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v84 = v117 + } + v52 = v84 + } // end let + v48 = v52 + break + } + } // end let + v8 = v48 + } // end let + v4 = v8 + } else { + v4 = nil + } + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // line-seq + { + v0 := lang.NewSymbol("line-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rdr"))), lang.NewKeyword("doc"), "Returns the lines of text from rdr as a lazy sequence of strings.\n rdr must implement java.io.BufferedReader.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3068), lang.NewKeyword("end-line"), int(3068))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + { // let + // let binding "temp__0__auto__" + v5, ok := lang.FieldOrMethod(v3, "readLine") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "readLine"))) + } + var v6 any + switch reflect.TypeOf(v5).Kind() { + case reflect.Func: + v6 = lang.Apply(v5, nil) + default: + v6 = v5 + } + var v7 any = v6 + _ = v7 + var v8 any + if lang.IsTruthy(v7) { + var v9 any + { // let + // let binding "line" + var v10 any = v7 + _ = v10 + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("cons")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + var v14 lang.FnFunc + v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("line-seq")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{v3}) + return v18 + }) + v15 := lang.Apply(lang.NewLazySeq, []any{v14}) + v16 := lang.Apply(v13, []any{v10, v15}) + v9 = v16 + } // end let + v8 = v9 + } else { + v8 = nil + } + v4 = v8 + } // end let + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // list + { + v0 := lang.NewSymbol("list").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("items"))), lang.NewKeyword("doc"), "Creates a new list containing the items.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(15), lang.NewKeyword("end-line"), int(18))).(*lang.Symbol) + v1 := ns.InternWithValue(v0, nil, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // list* + { + v0 := lang.NewSymbol("list*").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Creates a new seq containing the items prepended to the rest, the\n last of which will be treated as a sequence.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(641), lang.NewKeyword("end-line"), int(641))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.Apply(v6, []any{v3}) + return v7 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("cons")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v3, v4}) + return v8 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("cons")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("cons")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.Apply(v11, []any{v4, v5}) + v13 := lang.Apply(v8, []any{v3, v12}) + return v13 + case 4: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("cons")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("cons")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("cons")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{v5, v6}) + v17 := lang.Apply(v12, []any{v4, v16}) + v18 := lang.Apply(v9, []any{v3, v17}) + return v18 + default: + if len(args) < 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := lang.NewList(args[4:]...) + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("cons")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("cons")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("cons")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("cons")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("spread")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.Apply(v22, []any{v7}) + v24 := lang.Apply(v19, []any{v6, v23}) + v25 := lang.Apply(v16, []any{v5, v24}) + v26 := lang.Apply(v13, []any{v4, v25}) + v27 := lang.Apply(v10, []any{v3, v26}) + return v27 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // list? + { + v0 := lang.NewSymbol("list?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements IPersistentList", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6198), lang.NewKeyword("end-line"), int(6198))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.Apply(v6, []any{lang.IPersistentList, v3}) + return v7 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // load + { + v0 := lang.NewSymbol("load").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("paths"))), lang.NewKeyword("doc"), "Loads Clojure code from resources in classpath. A path is interpreted as\n classpath-relative if it begins with a slash or relative to the root\n directory for the current namespace otherwise.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("redef"), true, lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6095), lang.NewKeyword("end-line"), int(6095))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := lang.NewList(args[0:]...) + var v4 any + { // let + // let binding "seq_133" + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("seq")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v3}) + var v9 any = v8 + _ = v9 + // let binding "chunk_134" + var v10 any = nil + _ = v10 + // let binding "count_135" + var v11 any = int64(0) + _ = v11 + // let binding "i_136" + var v12 any = int64(0) + _ = v12 + for { + var v13 any + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("<")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{v12, v11}) + if lang.IsTruthy(v17) { + var v18 any + { // let + // let binding "path" + v19, _ := lang.FieldOrMethod(v10, "nth") + if reflect.TypeOf(v19).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + v20 := lang.Apply(v19, []any{v12}) + var v21 any = v20 + _ = v21 + var v22 any + { // let + // let binding "path" + var v23 any + v24 := lang.Apply(strings8.HasPrefix, []any{v21, "/"}) + if lang.IsTruthy(v24) { + v23 = v21 + } else { + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("str")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("root-directory")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("ns-name")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("*ns*")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.Apply(v33, []any{v36}) + v38 := lang.Apply(v30, []any{v37}) + v39 := lang.Apply(v27, []any{v38, lang.NewChar(47), v21}) + v23 = v39 + } + var v40 any = v23 + _ = v40 + var v41 any + v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v43 := v42.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) + if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) + } + v44 := v43.Get() + if lang.IsTruthy(v44) { + v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v46 := v45.FindInternedVar(lang.NewSymbol("printf")) + if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) + } + v47 := v46.Get() + v48 := lang.Apply(v47, []any{"(glojure.core/load \"%s\")\n", v40}) + _ = v48 + v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v50 := v49.FindInternedVar(lang.NewSymbol("flush")) + if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) + } + v51 := v50.Get() + v52 := lang.Apply(v51, nil) + v41 = v52 + } else { + v41 = nil + } + _ = v41 + v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v54 := v53.FindInternedVar(lang.NewSymbol("check-cyclic-dependency")) + if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) + } + v55 := v54.Get() + v56 := lang.Apply(v55, []any{v40}) + _ = v56 + var v57 any + v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v59 := v58.FindInternedVar(lang.NewSymbol("=")) + if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) + } + v60 := v59.Get() + v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v62 := v61.FindInternedVar(lang.NewSymbol("first")) + if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) + } + v63 := v62.Get() + v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v65 := v64.FindInternedVar(lang.NewSymbol("*pending-paths*")) + if v65.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) + } + v66 := v65.Get() + v67 := lang.Apply(v63, []any{v66}) + v68 := lang.Apply(v60, []any{v40, v67}) + if lang.IsTruthy(v68) { + v57 = nil + } else { + var v69 any + { // let + v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v71 := v70.FindInternedVar(lang.NewSymbol("push-thread-bindings")) + if v71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) + } + v72 := v71.Get() + v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v74 := v73.FindInternedVar(lang.NewSymbol("hash-map")) + if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) + } + v75 := v74.Get() + v76 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*pending-paths*")) + v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v78 := v77.FindInternedVar(lang.NewSymbol("conj")) + if v78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) + } + v79 := v78.Get() + v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v81 := v80.FindInternedVar(lang.NewSymbol("*pending-paths*")) + if v81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) + } + v82 := v81.Get() + v83 := lang.Apply(v79, []any{v82, v40}) + v84 := lang.Apply(v75, []any{v76, v83}) + v85 := lang.Apply(v72, []any{v84}) + _ = v85 + var v86 any + func() { + defer func() { + v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v88 := v87.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) + if v88.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) + } + v89 := v88.Get() + v90 := lang.Apply(v89, nil) + }() + v91 := lang.Apply(strings8.TrimPrefix, []any{v40, "/"}) + v92, _ := lang.FieldOrMethod(runtime4.RT, "Load") + if reflect.TypeOf(v92).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Load is not a function"))) + } + v93 := lang.Apply(v92, []any{v91}) + v86 = v93 + }() + v69 = v86 + } // end let + v57 = v69 + } + v22 = v57 + } // end let + _ = v22 + var v23 any = v9 + var v24 any = v10 + var v25 any = v11 + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("unchecked-inc")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{v12}) + var v26 any = v30 + v9 = v23 + v10 = v24 + v11 = v25 + v12 = v26 + continue + } // end let + v13 = v18 + } else { + var v19 any + { // let + // let binding "temp__0__auto__" + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("seq")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.Apply(v22, []any{v9}) + var v24 any = v23 + _ = v24 + var v25 any + if lang.IsTruthy(v24) { + var v26 any + { // let + // let binding "seq_133" + var v27 any = v24 + _ = v27 + var v28 any + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("chunked-seq?")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.Apply(v31, []any{v27}) + if lang.IsTruthy(v32) { + var v33 any + { // let + // let binding "c__0__auto__" + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("chunk-first")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.Apply(v36, []any{v27}) + var v38 any = v37 + _ = v38 + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("chunk-rest")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.Apply(v42, []any{v27}) + var v39 any = v43 + var v44 any = v38 + v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v47 := v46.FindInternedVar(lang.NewSymbol("int")) + if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) + } + v48 := v47.Get() + v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v50 := v49.FindInternedVar(lang.NewSymbol("count")) + if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) + } + v51 := v50.Get() + v52 := lang.Apply(v51, []any{v38}) + v53 := lang.Apply(v48, []any{v52}) + var v45 any = v53 + v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v56 := v55.FindInternedVar(lang.NewSymbol("int")) + if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) + } + v57 := v56.Get() + v58 := lang.Apply(v57, []any{int64(0)}) + var v54 any = v58 + v9 = v39 + v10 = v44 + v11 = v45 + v12 = v54 + continue + } // end let + v28 = v33 + } else { + var v34 any + { // let + // let binding "path" + v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v36 := v35.FindInternedVar(lang.NewSymbol("first")) + if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + } + v37 := v36.Get() + v38 := lang.Apply(v37, []any{v27}) + var v39 any = v38 + _ = v39 + var v40 any + { // let + // let binding "path" + var v41 any + v42 := lang.Apply(strings8.HasPrefix, []any{v39, "/"}) + if lang.IsTruthy(v42) { + v41 = v39 + } else { + v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v44 := v43.FindInternedVar(lang.NewSymbol("str")) + if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) + } + v45 := v44.Get() + v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v47 := v46.FindInternedVar(lang.NewSymbol("root-directory")) + if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) + } + v48 := v47.Get() + v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v50 := v49.FindInternedVar(lang.NewSymbol("ns-name")) + if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) + } + v51 := v50.Get() + v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v53 := v52.FindInternedVar(lang.NewSymbol("*ns*")) + if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) + } + v54 := v53.Get() + v55 := lang.Apply(v51, []any{v54}) + v56 := lang.Apply(v48, []any{v55}) + v57 := lang.Apply(v45, []any{v56, lang.NewChar(47), v39}) + v41 = v57 + } + var v58 any = v41 + _ = v58 + var v59 any + v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v61 := v60.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) + if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) + } + v62 := v61.Get() + if lang.IsTruthy(v62) { + v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v64 := v63.FindInternedVar(lang.NewSymbol("printf")) + if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) + } + v65 := v64.Get() + v66 := lang.Apply(v65, []any{"(glojure.core/load \"%s\")\n", v58}) + _ = v66 + v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v68 := v67.FindInternedVar(lang.NewSymbol("flush")) + if v68.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) + } + v69 := v68.Get() + v70 := lang.Apply(v69, nil) + v59 = v70 + } else { + v59 = nil + } + _ = v59 + v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v72 := v71.FindInternedVar(lang.NewSymbol("check-cyclic-dependency")) + if v72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) + } + v73 := v72.Get() + v74 := lang.Apply(v73, []any{v58}) + _ = v74 + var v75 any + v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v77 := v76.FindInternedVar(lang.NewSymbol("=")) + if v77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) + } + v78 := v77.Get() + v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v80 := v79.FindInternedVar(lang.NewSymbol("first")) + if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) + } + v81 := v80.Get() + v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v83 := v82.FindInternedVar(lang.NewSymbol("*pending-paths*")) + if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) + } + v84 := v83.Get() + v85 := lang.Apply(v81, []any{v84}) + v86 := lang.Apply(v78, []any{v58, v85}) + if lang.IsTruthy(v86) { + v75 = nil + } else { + var v87 any + { // let + v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v89 := v88.FindInternedVar(lang.NewSymbol("push-thread-bindings")) + if v89.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) + } + v90 := v89.Get() + v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v92 := v91.FindInternedVar(lang.NewSymbol("hash-map")) + if v92.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) + } + v93 := v92.Get() + v94 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*pending-paths*")) + v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v96 := v95.FindInternedVar(lang.NewSymbol("conj")) + if v96.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) + } + v97 := v96.Get() + v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v99 := v98.FindInternedVar(lang.NewSymbol("*pending-paths*")) + if v99.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) + } + v100 := v99.Get() + v101 := lang.Apply(v97, []any{v100, v58}) + v102 := lang.Apply(v93, []any{v94, v101}) + v103 := lang.Apply(v90, []any{v102}) + _ = v103 + var v104 any + func() { + defer func() { + v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v106 := v105.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) + if v106.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) + } + v107 := v106.Get() + v108 := lang.Apply(v107, nil) + }() + v109 := lang.Apply(strings8.TrimPrefix, []any{v58, "/"}) + v110, _ := lang.FieldOrMethod(runtime4.RT, "Load") + if reflect.TypeOf(v110).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Load is not a function"))) + } + v111 := lang.Apply(v110, []any{v109}) + v104 = v111 + }() + v87 = v104 + } // end let + v75 = v87 + } + v40 = v75 + } // end let + _ = v40 + v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v43 := v42.FindInternedVar(lang.NewSymbol("next")) + if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) + } + v44 := v43.Get() + v45 := lang.Apply(v44, []any{v27}) + var v41 any = v45 + var v46 any = nil + var v47 any = int64(0) + var v48 any = int64(0) + v9 = v41 + v10 = v46 + v11 = v47 + v12 = v48 + continue + } // end let + v28 = v34 + } + v26 = v28 + } // end let + v25 = v26 + } else { + v25 = nil + } + v19 = v25 + } // end let + v13 = v19 + } + v4 = v13 + break + } + } // end let + return v4 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // load-all + { + v0 := lang.NewSymbol("load-all").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"), lang.NewSymbol("need-ns"), lang.NewSymbol("require"))), lang.NewKeyword("doc"), "Loads a lib given its name and forces a load of any libs it directly or\n indirectly loads. If need-ns, ensures that the associated namespace\n exists after loading. If require, records the load so any duplicate loads\n can be skipped.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5892), lang.NewKeyword("end-line"), int(5892), lang.NewKeyword("private"), true)).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 lang.FnFunc + v6 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("commute")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("*loaded-libs*")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + var v13 lang.FnFunc + v13 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v14 := args[0] + _ = v14 + v15 := args[1] + _ = v15 + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("reduce1")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("conj")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v18, []any{v21, v14, v15}) + return v22 + }) + v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5899), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(5899), lang.NewKeyword("end-column"), int(47)) + v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v16 any + { // let + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("push-thread-bindings")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("hash-map")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*loaded-libs*")) + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("ref")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("sorted-set")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, nil) + v31 := lang.Apply(v26, []any{v30}) + v32 := lang.Apply(v22, []any{v23, v31}) + v33 := lang.Apply(v19, []any{v32}) + _ = v33 + var v34 any + func() { + defer func() { + v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v36 := v35.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) + if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + } + v37 := v36.Get() + v38 := lang.Apply(v37, nil) + }() + v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v40 := v39.FindInternedVar(lang.NewSymbol("load-one")) + if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) + } + v41 := v40.Get() + v42 := lang.Apply(v41, []any{v3, v4, v5}) + _ = v42 + v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v44 := v43.FindInternedVar(lang.NewSymbol("deref")) + if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) + } + v45 := v44.Get() + v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v47 := v46.FindInternedVar(lang.NewSymbol("*loaded-libs*")) + if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) + } + v48 := v47.Get() + v49 := lang.Apply(v45, []any{v48}) + v34 = v49 + }() + v16 = v34 + } // end let + v17 := lang.Apply(v9, []any{v12, v15, v16}) + return v17 + }) + v7, _ := lang.FieldOrMethod(lang.LockingTransaction, "RunInTransaction") + if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("RunInTransaction is not a function"))) + } + v8 := lang.Apply(v7, []any{v6}) + return v8 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // load-data-reader-file + { + v0 := lang.NewSymbol("load-data-reader-file").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7836), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7836), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("mappings"), lang.NewSymbol("url"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any + { // let + // let binding "rdr" + v6, ok := lang.FieldOrMethod(v4, "openStream") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "openStream"))) + } + var v7 any + switch reflect.TypeOf(v6).Kind() { + case reflect.Func: + v7 = lang.Apply(v6, nil) + default: + v7 = v6 + } + v8 := lang.Apply(nil, []any{v7, "UTF-8"}) + v9 := lang.Apply(nil, []any{v8}) + var v10 any = v9 + _ = v10 + var v11 any + func() { + defer func() { + v12, ok := lang.FieldOrMethod(v10, "close") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v10, "close"))) + } + var v13 any + switch reflect.TypeOf(v12).Kind() { + case reflect.Func: + v13 = lang.Apply(v12, nil) + default: + v13 = v12 + } + }() + var v14 any + { // let + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("push-thread-bindings")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("hash-map")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*file*")) + v22, ok := lang.FieldOrMethod(v4, "getFile") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "getFile"))) + } + var v23 any + switch reflect.TypeOf(v22).Kind() { + case reflect.Func: + v23 = lang.Apply(v22, nil) + default: + v23 = v22 + } + v24 := lang.Apply(v20, []any{v21, v23}) + v25 := lang.Apply(v17, []any{v24}) + _ = v25 + var v26 any + func() { + defer func() { + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, nil) + }() + var v31 any + { // let + // let binding "read-opts" + var v32 any + v33, ok := lang.FieldOrMethod(v4, "getPath") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "getPath"))) + } + var v34 any + switch reflect.TypeOf(v33).Kind() { + case reflect.Func: + v34 = lang.Apply(v33, nil) + default: + v34 = v33 + } + v35, _ := lang.FieldOrMethod(v34, "endsWith") + if reflect.TypeOf(v35).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("endsWith is not a function"))) + } + v36 := lang.Apply(v35, []any{"cljc"}) + if lang.IsTruthy(v36) { + v37 := lang.NewMap(lang.NewKeyword("eof"), nil, lang.NewKeyword("read-cond"), lang.NewKeyword("allow")) + v38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7842), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7842), lang.NewKeyword("end-column"), int(52)) + v39, err := lang.WithMeta(v37, v38.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v32 = v39 + } else { + v40 := lang.NewMap(lang.NewKeyword("eof"), nil) + v41 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7843), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7843), lang.NewKeyword("end-column"), int(34)) + v42, err := lang.WithMeta(v40, v41.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v32 = v42 + } + var v43 any = v32 + _ = v43 + // let binding "new-mappings" + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("read")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.Apply(v46, []any{v43, v10}) + var v48 any = v47 + _ = v48 + var v49 any + v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v51 := v50.FindInternedVar(lang.NewSymbol("not")) + if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) + } + v52 := v51.Get() + v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v54 := v53.FindInternedVar(lang.NewSymbol("map?")) + if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) + } + v55 := v54.Get() + v56 := lang.Apply(v55, []any{v48}) + v57 := lang.Apply(v52, []any{v56}) + if lang.IsTruthy(v57) { + v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v59 := v58.FindInternedVar(lang.NewSymbol("ex-info")) + if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) + } + v60 := v59.Get() + v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v62 := v61.FindInternedVar(lang.NewSymbol("str")) + if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) + } + v63 := v62.Get() + v64 := lang.Apply(v63, []any{"Not a valid data-reader map"}) + v65 := lang.NewMap(lang.NewKeyword("url"), v4) + v66 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7847), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(7847), lang.NewKeyword("end-column"), int(36)) + v67, err := lang.WithMeta(v65, v66.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v68 := lang.Apply(v60, []any{v64, v67}) + panic(v68) + } else { + v49 = nil + } + _ = v49 + v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v70 := v69.FindInternedVar(lang.NewSymbol("reduce")) + if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) + } + v71 := v70.Get() + var v72 lang.FnFunc + v72 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v73 := args[0] + _ = v73 + v74 := args[1] + _ = v74 + var v75 any + { // let + // let binding "vec__347" + var v76 any = v74 + _ = v76 + // let binding "k" + v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v78 := v77.FindInternedVar(lang.NewSymbol("nth")) + if v78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) + } + v79 := v78.Get() + v80 := lang.Apply(v79, []any{v76, int64(0), nil}) + var v81 any = v80 + _ = v81 + // let binding "v" + v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v83 := v82.FindInternedVar(lang.NewSymbol("nth")) + if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) + } + v84 := v83.Get() + v85 := lang.Apply(v84, []any{v76, int64(1), nil}) + var v86 any = v85 + _ = v86 + var v87 any + v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v89 := v88.FindInternedVar(lang.NewSymbol("not")) + if v89.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) + } + v90 := v89.Get() + v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v92 := v91.FindInternedVar(lang.NewSymbol("symbol?")) + if v92.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) + } + v93 := v92.Get() + v94 := lang.Apply(v93, []any{v81}) + v95 := lang.Apply(v90, []any{v94}) + if lang.IsTruthy(v95) { + v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v97 := v96.FindInternedVar(lang.NewSymbol("ex-info")) + if v97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) + } + v98 := v97.Get() + v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v100 := v99.FindInternedVar(lang.NewSymbol("str")) + if v100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) + } + v101 := v100.Get() + v102 := lang.Apply(v101, []any{"Invalid form in data-reader file"}) + v103 := lang.NewMap(lang.NewKeyword("url"), v4, lang.NewKeyword("form"), v81) + v104 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7852), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(7853), lang.NewKeyword("end-column"), int(38)) + v105, err := lang.WithMeta(v103, v104.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v106 := lang.Apply(v98, []any{v102, v105}) + panic(v106) + } else { + v87 = nil + } + _ = v87 + var v107 any + { // let + // let binding "v-var" + v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v109 := v108.FindInternedVar(lang.NewSymbol("data-reader-var")) + if v109.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) + } + v110 := v109.Get() + v111 := lang.Apply(v110, []any{v86}) + var v112 any = v111 + _ = v112 + var v113 any + var v114 any + { // let + // let binding "and__0__auto__" + v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v116 := v115.FindInternedVar(lang.NewSymbol("contains?")) + if v116.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) + } + v117 := v116.Get() + v118 := lang.Apply(v117, []any{v3, v81}) + var v119 any = v118 + _ = v119 + var v120 any + if lang.IsTruthy(v119) { + v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v122 := v121.FindInternedVar(lang.NewSymbol("not=")) + if v122.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) + } + v123 := v122.Get() + v124 := lang.Apply(v3, []any{v81}) + v125 := lang.Apply(v123, []any{v124, v112}) + v120 = v125 + } else { + v120 = v119 + } + v114 = v120 + } // end let + if lang.IsTruthy(v114) { + v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v116 := v115.FindInternedVar(lang.NewSymbol("ex-info")) + if v116.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) + } + v117 := v116.Get() + v118 := lang.NewMap(lang.NewKeyword("url"), v4, lang.NewKeyword("conflict"), v81, lang.NewKeyword("mappings"), v73) + v119 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7858), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(7860), lang.NewKeyword("end-column"), int(44)) + v120, err := lang.WithMeta(v118, v119.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v121 := lang.Apply(v117, []any{"Conflicting data-reader mapping", v120}) + panic(v121) + } else { + v113 = nil + } + _ = v113 + v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v123 := v122.FindInternedVar(lang.NewSymbol("assoc")) + if v123.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) + } + v124 := v123.Get() + v125 := lang.Apply(v124, []any{v73, v81, v112}) + v107 = v125 + } // end let + v75 = v107 + } // end let + return v75 + }) + v73 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7849), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(7861), lang.NewKeyword("end-column"), int(32)) + v74, err := lang.WithMeta(v72, v73.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v75 := lang.Apply(v71, []any{v74, v3, v48}) + v31 = v75 + } // end let + v26 = v31 + }() + v14 = v26 + } // end let + v11 = v14 + }() + v5 = v11 + } // end let + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // load-data-readers + { + v0 := lang.NewSymbol("load-data-readers").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7865), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7865), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v4 := v3.FindInternedVar(lang.NewSymbol("alter-var-root")) + if v4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) + } + v5 := v4.Get() + v6 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*data-readers*")) + var v7 lang.FnFunc + v7 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v8 := args[0] + _ = v8 + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("reduce")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("load-data-reader-file")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("data-reader-urls")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, nil) + v19 := lang.Apply(v11, []any{v14, v8, v18}) + return v19 + }) + v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7867), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(7869), lang.NewKeyword("end-column"), int(57)) + v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v10 := lang.Apply(v5, []any{v6, v9}) + return v10 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // load-file + { + v0 := lang.NewSymbol("load-file").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + v1 := ns.InternWithValue(v0, nil, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // load-lib + { + v0 := lang.NewSymbol("load-lib").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("prefix"), lang.NewSymbol("lib"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Loads a lib with options", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5904), lang.NewKeyword("end-line"), int(5904), lang.NewKeyword("private"), true)).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.NewList(args[2:]...) + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("throw-if")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + var v9 any + { // let + // let binding "and__0__auto__" + var v10 any = v3 + _ = v10 + var v11 any + if lang.IsTruthy(v10) { + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("pos?")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("name")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{v4}) + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("int")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{lang.NewChar(46)}) + v23 := lang.Apply(strings8.Index, []any{v18, v22}) + v24 := lang.Apply(v14, []any{v23}) + v11 = v24 + } else { + v11 = v10 + } + v9 = v11 + } // end let + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("name")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{v4}) + v14 := lang.Apply(v8, []any{v9, "Found lib name '%s' containing period with prefix '%s'. lib names inside prefix lists must not contain periods", v13, v3}) + _ = v14 + var v15 any + { // let + // let binding "lib" + var v16 any + if lang.IsTruthy(v3) { + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("symbol")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("str")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.Apply(v22, []any{v3, lang.NewChar(46), v4}) + v24 := lang.Apply(v19, []any{v23}) + v16 = v24 + } else { + v16 = v4 + } + var v25 any = v16 + _ = v25 + // let binding "opts" + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("apply")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("hash-map")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.Apply(v28, []any{v31, v5}) + var v33 any = v32 + _ = v33 + // let binding "map__110" + var v34 any = v33 + _ = v34 + // let binding "map__110" + var v35 any + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("seq?")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v38, []any{v34}) + if lang.IsTruthy(v39) { + var v40 any + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("next")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.Apply(v43, []any{v34}) + if lang.IsTruthy(v44) { + v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v46 := v45.FindInternedVar(lang.NewSymbol("to-array")) + if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) + } + v47 := v46.Get() + v48 := lang.Apply(v47, []any{v34}) + v49 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{v48}) + v40 = v49 + } else { + var v50 any + v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v52 := v51.FindInternedVar(lang.NewSymbol("seq")) + if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) + } + v53 := v52.Get() + v54 := lang.Apply(v53, []any{v34}) + if lang.IsTruthy(v54) { + v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v56 := v55.FindInternedVar(lang.NewSymbol("first")) + if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) + } + v57 := v56.Get() + v58 := lang.Apply(v57, []any{v34}) + v50 = v58 + } else { + v50 = nil + } + v40 = v50 + } + v35 = v40 + } else { + v35 = v34 + } + var v59 any = v35 + _ = v59 + // let binding "as" + v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v61 := v60.FindInternedVar(lang.NewSymbol("get")) + if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) + } + v62 := v61.Get() + v63 := lang.Apply(v62, []any{v59, lang.NewKeyword("as")}) + var v64 any = v63 + _ = v64 + // let binding "reload" + v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v66 := v65.FindInternedVar(lang.NewSymbol("get")) + if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) + } + v67 := v66.Get() + v68 := lang.Apply(v67, []any{v59, lang.NewKeyword("reload")}) + var v69 any = v68 + _ = v69 + // let binding "reload-all" + v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v71 := v70.FindInternedVar(lang.NewSymbol("get")) + if v71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) + } + v72 := v71.Get() + v73 := lang.Apply(v72, []any{v59, lang.NewKeyword("reload-all")}) + var v74 any = v73 + _ = v74 + // let binding "require" + v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v76 := v75.FindInternedVar(lang.NewSymbol("get")) + if v76.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) + } + v77 := v76.Get() + v78 := lang.Apply(v77, []any{v59, lang.NewKeyword("require")}) + var v79 any = v78 + _ = v79 + // let binding "use" + v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v81 := v80.FindInternedVar(lang.NewSymbol("get")) + if v81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) + } + v82 := v81.Get() + v83 := lang.Apply(v82, []any{v59, lang.NewKeyword("use")}) + var v84 any = v83 + _ = v84 + // let binding "verbose" + v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v86 := v85.FindInternedVar(lang.NewSymbol("get")) + if v86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) + } + v87 := v86.Get() + v88 := lang.Apply(v87, []any{v59, lang.NewKeyword("verbose")}) + var v89 any = v88 + _ = v89 + // let binding "as-alias" + v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v91 := v90.FindInternedVar(lang.NewSymbol("get")) + if v91.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) + } + v92 := v91.Get() + v93 := lang.Apply(v92, []any{v59, lang.NewKeyword("as-alias")}) + var v94 any = v93 + _ = v94 + // let binding "loaded" + v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v96 := v95.FindInternedVar(lang.NewSymbol("contains?")) + if v96.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) + } + v97 := v96.Get() + v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v99 := v98.FindInternedVar(lang.NewSymbol("deref")) + if v99.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) + } + v100 := v99.Get() + v101 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v102 := v101.FindInternedVar(lang.NewSymbol("*loaded-libs*")) + if v102.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v102))) + } + v103 := v102.Get() + v104 := lang.Apply(v100, []any{v103}) + v105 := lang.Apply(v97, []any{v104, v25}) + var v106 any = v105 + _ = v106 + // let binding "need-ns" + var v107 any + { // let + // let binding "or__0__auto__" + var v108 any = v64 + _ = v108 + var v109 any + if lang.IsTruthy(v108) { + v109 = v108 + } else { + v109 = v84 + } + v107 = v109 + } // end let + var v108 any = v107 + _ = v108 + // let binding "load" + var v109 any + if lang.IsTruthy(v74) { + v110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v111 := v110.FindInternedVar(lang.NewSymbol("load-all")) + if v111.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v111))) + } + v112 := v111.Get() + v109 = v112 + } else { + var v113 any + if lang.IsTruthy(v69) { + v114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v115 := v114.FindInternedVar(lang.NewSymbol("load-one")) + if v115.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v115))) + } + v116 := v115.Get() + v113 = v116 + } else { + var v117 any + v118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v119 := v118.FindInternedVar(lang.NewSymbol("not")) + if v119.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v119))) + } + v120 := v119.Get() + v121 := lang.Apply(v120, []any{v106}) + if lang.IsTruthy(v121) { + var v122 any + if lang.IsTruthy(v108) { + v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v124 := v123.FindInternedVar(lang.NewSymbol("load-one")) + if v124.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) + } + v125 := v124.Get() + v122 = v125 + } else { + var v126 any + if lang.IsTruthy(v94) { + var v127 lang.FnFunc + v127 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v128 := args[0] + _ = v128 + v129 := args[1] + _ = v129 + v130 := args[2] + _ = v130 + v131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v132 := v131.FindInternedVar(lang.NewSymbol("create-ns")) + if v132.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v132))) + } + v133 := v132.Get() + v134 := lang.Apply(v133, []any{v128}) + return v134 + }) + v128 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5918), lang.NewKeyword("column"), int(48), lang.NewKeyword("end-line"), int(5918), lang.NewKeyword("end-column"), int(88)) + v129, err := lang.WithMeta(v127, v128.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v126 = v129 + } else { + var v130 any + if lang.IsTruthy(lang.NewKeyword("else")) { + v131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v132 := v131.FindInternedVar(lang.NewSymbol("load-one")) + if v132.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v132))) + } + v133 := v132.Get() + v130 = v133 + } else { + v130 = nil + } + v126 = v130 + } + v122 = v126 + } + v117 = v122 + } else { + v117 = nil + } + v113 = v117 + } + v109 = v113 + } + var v134 any = v109 + _ = v134 + // let binding "filter-opts" + v135 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v136 := v135.FindInternedVar(lang.NewSymbol("select-keys")) + if v136.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v136))) + } + v137 := v136.Get() + v138 := lang.Apply(v137, []any{v33, lang.NewList(lang.NewKeyword("exclude"), lang.NewKeyword("only"), lang.NewKeyword("rename"), lang.NewKeyword("refer"))}) + var v139 any = v138 + _ = v139 + // let binding "undefined-on-entry" + v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v141 := v140.FindInternedVar(lang.NewSymbol("not")) + if v141.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) + } + v142 := v141.Get() + v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v144 := v143.FindInternedVar(lang.NewSymbol("find-ns")) + if v144.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) + } + v145 := v144.Get() + v146 := lang.Apply(v145, []any{v25}) + v147 := lang.Apply(v142, []any{v146}) + var v148 any = v147 + _ = v148 + var v149 any + { // let + v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v151 := v150.FindInternedVar(lang.NewSymbol("push-thread-bindings")) + if v151.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) + } + v152 := v151.Get() + v153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v154 := v153.FindInternedVar(lang.NewSymbol("hash-map")) + if v154.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v154))) + } + v155 := v154.Get() + v156 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*loading-verbosely*")) + var v157 any + { // let + // let binding "or__0__auto__" + v158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v159 := v158.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) + if v159.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v159))) + } + v160 := v159.Get() + var v161 any = v160 + _ = v161 + var v162 any + if lang.IsTruthy(v161) { + v162 = v161 + } else { + v162 = v89 + } + v157 = v162 + } // end let + v158 := lang.Apply(v155, []any{v156, v157}) + v159 := lang.Apply(v152, []any{v158}) + _ = v159 + var v160 any + func() { + defer func() { + v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v162 := v161.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) + if v162.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) + } + v163 := v162.Get() + v164 := lang.Apply(v163, nil) + }() + var v165 any + if lang.IsTruthy(v134) { + var v166 any + func() { + defer func() { + if r := recover(); r != nil { + if lang.CatchMatches(r, lang.Builtins["any"]) { + v167 := r + _ = v167 + var v168 any + if lang.IsTruthy(v148) { + v169 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v170 := v169.FindInternedVar(lang.NewSymbol("remove-ns")) + if v170.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v170))) + } + v171 := v170.Get() + v172 := lang.Apply(v171, []any{v25}) + v168 = v172 + } else { + v168 = nil + } + _ = v168 + panic(v167) + } else { + panic(r) + } + } + }() + v167 := lang.Apply(v134, []any{v25, v108, v79}) + v166 = v167 + }() + v165 = v166 + } else { + v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v169 := v168.FindInternedVar(lang.NewSymbol("throw-if")) + if v169.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) + } + v170 := v169.Get() + var v171 any + { // let + // let binding "and__0__auto__" + var v172 any = v108 + _ = v172 + var v173 any + if lang.IsTruthy(v172) { + v174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v175 := v174.FindInternedVar(lang.NewSymbol("not")) + if v175.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v175))) + } + v176 := v175.Get() + v177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v178 := v177.FindInternedVar(lang.NewSymbol("find-ns")) + if v178.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v178))) + } + v179 := v178.Get() + v180 := lang.Apply(v179, []any{v25}) + v181 := lang.Apply(v176, []any{v180}) + v173 = v181 + } else { + v173 = v172 + } + v171 = v173 + } // end let + v172 := lang.Apply(v170, []any{v171, "namespace '%s' not found", v25}) + v165 = v172 + } + _ = v165 + var v173 any + var v174 any + { // let + // let binding "and__0__auto__" + var v175 any = v108 + _ = v175 + var v176 any + if lang.IsTruthy(v175) { + v177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v178 := v177.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) + if v178.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v178))) + } + v179 := v178.Get() + v176 = v179 + } else { + v176 = v175 + } + v174 = v176 + } // end let + if lang.IsTruthy(v174) { + v175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v176 := v175.FindInternedVar(lang.NewSymbol("printf")) + if v176.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v176))) + } + v177 := v176.Get() + v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v179 := v178.FindInternedVar(lang.NewSymbol("ns-name")) + if v179.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) + } + v180 := v179.Get() + v181 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v182 := v181.FindInternedVar(lang.NewSymbol("*ns*")) + if v182.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v182))) + } + v183 := v182.Get() + v184 := lang.Apply(v180, []any{v183}) + v185 := lang.Apply(v177, []any{"(glojure.core/in-ns '%s)\n", v184}) + v173 = v185 + } else { + v173 = nil + } + _ = v173 + var v186 any + if lang.IsTruthy(v64) { + var v187 any + v188 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v189 := v188.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) + if v189.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v189))) + } + v190 := v189.Get() + if lang.IsTruthy(v190) { + v191 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v192 := v191.FindInternedVar(lang.NewSymbol("printf")) + if v192.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v192))) + } + v193 := v192.Get() + v194 := lang.Apply(v193, []any{"(glojure.core/alias '%s '%s)\n", v64, v25}) + v187 = v194 + } else { + v187 = nil + } + _ = v187 + v195 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v196 := v195.FindInternedVar(lang.NewSymbol("alias")) + if v196.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v196))) + } + v197 := v196.Get() + v198 := lang.Apply(v197, []any{v64, v25}) + v186 = v198 + } else { + v186 = nil + } + _ = v186 + var v199 any + if lang.IsTruthy(v94) { + var v200 any + v201 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v202 := v201.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) + if v202.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v202))) + } + v203 := v202.Get() + if lang.IsTruthy(v203) { + v204 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v205 := v204.FindInternedVar(lang.NewSymbol("printf")) + if v205.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v205))) + } + v206 := v205.Get() + v207 := lang.Apply(v206, []any{"(glojure.core/alias '%s '%s)\n", v94, v25}) + v200 = v207 + } else { + v200 = nil + } + _ = v200 + v208 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v209 := v208.FindInternedVar(lang.NewSymbol("alias")) + if v209.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v209))) + } + v210 := v209.Get() + v211 := lang.Apply(v210, []any{v94, v25}) + v199 = v211 + } else { + v199 = nil + } + _ = v199 + var v212 any + var v213 any + { // let + // let binding "or__0__auto__" + var v214 any = v84 + _ = v214 + var v215 any + if lang.IsTruthy(v214) { + v215 = v214 + } else { + v216 := lang.Apply(lang.NewKeyword("refer"), []any{v139}) + v215 = v216 + } + v213 = v215 + } // end let + if lang.IsTruthy(v213) { + var v214 any + v215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v216 := v215.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) + if v216.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v216))) + } + v217 := v216.Get() + if lang.IsTruthy(v217) { + v218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v219 := v218.FindInternedVar(lang.NewSymbol("printf")) + if v219.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v219))) + } + v220 := v219.Get() + v221 := lang.Apply(v220, []any{"(glojure.core/refer '%s", v25}) + _ = v221 + var v222 any + { // let + // let binding "seq_111" + v223 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v224 := v223.FindInternedVar(lang.NewSymbol("seq")) + if v224.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v224))) + } + v225 := v224.Get() + v226 := lang.Apply(v225, []any{v139}) + var v227 any = v226 + _ = v227 + // let binding "chunk_112" + var v228 any = nil + _ = v228 + // let binding "count_113" + var v229 any = int64(0) + _ = v229 + // let binding "i_114" + var v230 any = int64(0) + _ = v230 + for { + var v231 any + v232 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v233 := v232.FindInternedVar(lang.NewSymbol("<")) + if v233.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v233))) + } + v234 := v233.Get() + v235 := lang.Apply(v234, []any{v230, v229}) + if lang.IsTruthy(v235) { + var v236 any + { // let + // let binding "opt" + v237, _ := lang.FieldOrMethod(v228, "nth") + if reflect.TypeOf(v237).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + v238 := lang.Apply(v237, []any{v230}) + var v239 any = v238 + _ = v239 + v240 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v241 := v240.FindInternedVar(lang.NewSymbol("printf")) + if v241.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v241))) + } + v242 := v241.Get() + v243 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v244 := v243.FindInternedVar(lang.NewSymbol("key")) + if v244.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v244))) + } + v245 := v244.Get() + v246 := lang.Apply(v245, []any{v239}) + v247 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v248 := v247.FindInternedVar(lang.NewSymbol("print-str")) + if v248.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v248))) + } + v249 := v248.Get() + v250 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v251 := v250.FindInternedVar(lang.NewSymbol("val")) + if v251.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v251))) + } + v252 := v251.Get() + v253 := lang.Apply(v252, []any{v239}) + v254 := lang.Apply(v249, []any{v253}) + v255 := lang.Apply(v242, []any{" %s '%s", v246, v254}) + _ = v255 + var v256 any = v227 + var v257 any = v228 + var v258 any = v229 + v260 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v261 := v260.FindInternedVar(lang.NewSymbol("unchecked-inc")) + if v261.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v261))) + } + v262 := v261.Get() + v263 := lang.Apply(v262, []any{v230}) + var v259 any = v263 + v227 = v256 + v228 = v257 + v229 = v258 + v230 = v259 + continue + } // end let + v231 = v236 + } else { + var v237 any + { // let + // let binding "temp__0__auto__" + v238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v239 := v238.FindInternedVar(lang.NewSymbol("seq")) + if v239.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v239))) + } + v240 := v239.Get() + v241 := lang.Apply(v240, []any{v227}) + var v242 any = v241 + _ = v242 + var v243 any + if lang.IsTruthy(v242) { + var v244 any + { // let + // let binding "seq_111" + var v245 any = v242 + _ = v245 + var v246 any + v247 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v248 := v247.FindInternedVar(lang.NewSymbol("chunked-seq?")) + if v248.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v248))) + } + v249 := v248.Get() + v250 := lang.Apply(v249, []any{v245}) + if lang.IsTruthy(v250) { + var v251 any + { // let + // let binding "c__0__auto__" + v252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v253 := v252.FindInternedVar(lang.NewSymbol("chunk-first")) + if v253.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v253))) + } + v254 := v253.Get() + v255 := lang.Apply(v254, []any{v245}) + var v256 any = v255 + _ = v256 + v258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v259 := v258.FindInternedVar(lang.NewSymbol("chunk-rest")) + if v259.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v259))) + } + v260 := v259.Get() + v261 := lang.Apply(v260, []any{v245}) + var v257 any = v261 + var v262 any = v256 + v264 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v265 := v264.FindInternedVar(lang.NewSymbol("int")) + if v265.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v265))) + } + v266 := v265.Get() + v267 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v268 := v267.FindInternedVar(lang.NewSymbol("count")) + if v268.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v268))) + } + v269 := v268.Get() + v270 := lang.Apply(v269, []any{v256}) + v271 := lang.Apply(v266, []any{v270}) + var v263 any = v271 + v273 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v274 := v273.FindInternedVar(lang.NewSymbol("int")) + if v274.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v274))) + } + v275 := v274.Get() + v276 := lang.Apply(v275, []any{int64(0)}) + var v272 any = v276 + v227 = v257 + v228 = v262 + v229 = v263 + v230 = v272 + continue + } // end let + v246 = v251 + } else { + var v252 any + { // let + // let binding "opt" + v253 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v254 := v253.FindInternedVar(lang.NewSymbol("first")) + if v254.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v254))) + } + v255 := v254.Get() + v256 := lang.Apply(v255, []any{v245}) + var v257 any = v256 + _ = v257 + v258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v259 := v258.FindInternedVar(lang.NewSymbol("printf")) + if v259.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v259))) + } + v260 := v259.Get() + v261 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v262 := v261.FindInternedVar(lang.NewSymbol("key")) + if v262.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v262))) + } + v263 := v262.Get() + v264 := lang.Apply(v263, []any{v257}) + v265 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v266 := v265.FindInternedVar(lang.NewSymbol("print-str")) + if v266.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v266))) + } + v267 := v266.Get() + v268 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v269 := v268.FindInternedVar(lang.NewSymbol("val")) + if v269.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v269))) + } + v270 := v269.Get() + v271 := lang.Apply(v270, []any{v257}) + v272 := lang.Apply(v267, []any{v271}) + v273 := lang.Apply(v260, []any{" %s '%s", v264, v272}) + _ = v273 + v275 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v276 := v275.FindInternedVar(lang.NewSymbol("next")) + if v276.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v276))) + } + v277 := v276.Get() + v278 := lang.Apply(v277, []any{v245}) + var v274 any = v278 + var v279 any = nil + var v280 any = int64(0) + var v281 any = int64(0) + v227 = v274 + v228 = v279 + v229 = v280 + v230 = v281 + continue + } // end let + v246 = v252 + } + v244 = v246 + } // end let + v243 = v244 + } else { + v243 = nil + } + v237 = v243 + } // end let + v231 = v237 + } + v222 = v231 + break + } + } // end let + _ = v222 + v223 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v224 := v223.FindInternedVar(lang.NewSymbol("printf")) + if v224.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v224))) + } + v225 := v224.Get() + v226 := lang.Apply(v225, []any{")\n"}) + v214 = v226 + } else { + v214 = nil + } + _ = v214 + v227 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v228 := v227.FindInternedVar(lang.NewSymbol("apply")) + if v228.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v228))) + } + v229 := v228.Get() + v230 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v231 := v230.FindInternedVar(lang.NewSymbol("refer")) + if v231.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v231))) + } + v232 := v231.Get() + v233 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v234 := v233.FindInternedVar(lang.NewSymbol("mapcat")) + if v234.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v234))) + } + v235 := v234.Get() + v236 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v237 := v236.FindInternedVar(lang.NewSymbol("seq")) + if v237.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v237))) + } + v238 := v237.Get() + v239 := lang.Apply(v235, []any{v238, v139}) + v240 := lang.Apply(v229, []any{v232, v25, v239}) + v212 = v240 + } else { + v212 = nil + } + v160 = v212 + }() + v149 = v160 + } // end let + v15 = v149 + } // end let + return v15 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // load-libs + { + v0 := lang.NewSymbol("load-libs").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Loads libs, interpreting libspecs, prefix lists, and flags for\n forwarding to load-lib", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5951), lang.NewKeyword("end-line"), int(5951), lang.NewKeyword("private"), true)).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := lang.NewList(args[0:]...) + var v4 any + { // let + // let binding "flags" + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("filter")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("keyword?")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v7, []any{v10, v3}) + var v12 any = v11 + _ = v12 + // let binding "opts" + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("interleave")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("repeat")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{true}) + v20 := lang.Apply(v15, []any{v12, v19}) + var v21 any = v20 + _ = v21 + // let binding "args" + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("filter")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("complement")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("keyword?")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.Apply(v27, []any{v30}) + v32 := lang.Apply(v24, []any{v31, v3}) + var v33 any = v32 + _ = v33 + var v34 any + { // let + // let binding "supported" + v35 := lang.CreatePersistentTreeSet(lang.NewKeyword("as"), lang.NewKeyword("reload"), lang.NewKeyword("reload-all"), lang.NewKeyword("require"), lang.NewKeyword("use"), lang.NewKeyword("verbose"), lang.NewKeyword("refer"), lang.NewKeyword("as-alias")) + v36 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5959), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(5959), lang.NewKeyword("end-column"), int(86)) + v37, err := lang.WithMeta(v35, v36.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v38 any = v37 + _ = v38 + // let binding "unsupported" + v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v40 := v39.FindInternedVar(lang.NewSymbol("seq")) + if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) + } + v41 := v40.Get() + v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v43 := v42.FindInternedVar(lang.NewSymbol("remove")) + if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) + } + v44 := v43.Get() + v45 := lang.Apply(v44, []any{v38, v12}) + v46 := lang.Apply(v41, []any{v45}) + var v47 any = v46 + _ = v47 + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("throw-if")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v52 := v51.FindInternedVar(lang.NewSymbol("apply")) + if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) + } + v53 := v52.Get() + v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v55 := v54.FindInternedVar(lang.NewSymbol("str")) + if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) + } + v56 := v55.Get() + v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v58 := v57.FindInternedVar(lang.NewSymbol("interpose")) + if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) + } + v59 := v58.Get() + v60 := lang.Apply(v59, []any{lang.NewChar(44), v47}) + v61 := lang.Apply(v53, []any{v56, "Unsupported option(s) supplied: ", v60}) + v62 := lang.Apply(v50, []any{v47, v61}) + v34 = v62 + } // end let + _ = v34 + v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v36 := v35.FindInternedVar(lang.NewSymbol("throw-if")) + if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + } + v37 := v36.Get() + v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v39 := v38.FindInternedVar(lang.NewSymbol("not")) + if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + } + v40 := v39.Get() + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("seq")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.Apply(v43, []any{v33}) + v45 := lang.Apply(v40, []any{v44}) + v46 := lang.Apply(v37, []any{v45, "Nothing specified to load"}) + _ = v46 + var v47 any + { // let + // let binding "seq_115" + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("seq")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v33}) + var v52 any = v51 + _ = v52 + // let binding "chunk_116" + var v53 any = nil + _ = v53 + // let binding "count_117" + var v54 any = int64(0) + _ = v54 + // let binding "i_118" + var v55 any = int64(0) + _ = v55 + for { + var v56 any + v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v58 := v57.FindInternedVar(lang.NewSymbol("<")) + if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) + } + v59 := v58.Get() + v60 := lang.Apply(v59, []any{v55, v54}) + if lang.IsTruthy(v60) { + var v61 any + { // let + // let binding "arg" + v62, _ := lang.FieldOrMethod(v53, "nth") + if reflect.TypeOf(v62).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + v63 := lang.Apply(v62, []any{v55}) + var v64 any = v63 + _ = v64 + var v65 any + v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v67 := v66.FindInternedVar(lang.NewSymbol("libspec?")) + if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) + } + v68 := v67.Get() + v69 := lang.Apply(v68, []any{v64}) + if lang.IsTruthy(v69) { + v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v71 := v70.FindInternedVar(lang.NewSymbol("apply")) + if v71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) + } + v72 := v71.Get() + v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v74 := v73.FindInternedVar(lang.NewSymbol("load-lib")) + if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) + } + v75 := v74.Get() + v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v77 := v76.FindInternedVar(lang.NewSymbol("prependss")) + if v77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) + } + v78 := v77.Get() + v79 := lang.Apply(v78, []any{v64, v21}) + v80 := lang.Apply(v72, []any{v75, nil, v79}) + v65 = v80 + } else { + var v81 any + { // let + // let binding "vec__119" + var v82 any = v64 + _ = v82 + // let binding "seq__120" + v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v84 := v83.FindInternedVar(lang.NewSymbol("seq")) + if v84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) + } + v85 := v84.Get() + v86 := lang.Apply(v85, []any{v82}) + var v87 any = v86 + _ = v87 + // let binding "first__121" + v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v89 := v88.FindInternedVar(lang.NewSymbol("first")) + if v89.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) + } + v90 := v89.Get() + v91 := lang.Apply(v90, []any{v87}) + var v92 any = v91 + _ = v92 + // let binding "seq__120" + v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v94 := v93.FindInternedVar(lang.NewSymbol("next")) + if v94.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) + } + v95 := v94.Get() + v96 := lang.Apply(v95, []any{v87}) + var v97 any = v96 + _ = v97 + // let binding "prefix" + var v98 any = v92 + _ = v98 + // let binding "args" + var v99 any = v97 + _ = v99 + v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v101 := v100.FindInternedVar(lang.NewSymbol("throw-if")) + if v101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) + } + v102 := v101.Get() + v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v104 := v103.FindInternedVar(lang.NewSymbol("nil?")) + if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) + } + v105 := v104.Get() + v106 := lang.Apply(v105, []any{v98}) + v107 := lang.Apply(v102, []any{v106, "prefix cannot be nil"}) + _ = v107 + var v108 any + { // let + // let binding "seq_122" + v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v110 := v109.FindInternedVar(lang.NewSymbol("seq")) + if v110.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) + } + v111 := v110.Get() + v112 := lang.Apply(v111, []any{v99}) + var v113 any = v112 + _ = v113 + // let binding "chunk_123" + var v114 any = nil + _ = v114 + // let binding "count_124" + var v115 any = int64(0) + _ = v115 + // let binding "i_125" + var v116 any = int64(0) + _ = v116 + for { + var v117 any + v118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v119 := v118.FindInternedVar(lang.NewSymbol("<")) + if v119.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v119))) + } + v120 := v119.Get() + v121 := lang.Apply(v120, []any{v116, v115}) + if lang.IsTruthy(v121) { + var v122 any + { // let + // let binding "arg" + v123, _ := lang.FieldOrMethod(v114, "nth") + if reflect.TypeOf(v123).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + v124 := lang.Apply(v123, []any{v116}) + var v125 any = v124 + _ = v125 + v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v127 := v126.FindInternedVar(lang.NewSymbol("apply")) + if v127.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) + } + v128 := v127.Get() + v129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v130 := v129.FindInternedVar(lang.NewSymbol("load-lib")) + if v130.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v130))) + } + v131 := v130.Get() + v132 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v133 := v132.FindInternedVar(lang.NewSymbol("prependss")) + if v133.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v133))) + } + v134 := v133.Get() + v135 := lang.Apply(v134, []any{v125, v21}) + v136 := lang.Apply(v128, []any{v131, v98, v135}) + _ = v136 + var v137 any = v113 + var v138 any = v114 + var v139 any = v115 + v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v142 := v141.FindInternedVar(lang.NewSymbol("unchecked-inc")) + if v142.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) + } + v143 := v142.Get() + v144 := lang.Apply(v143, []any{v116}) + var v140 any = v144 + v113 = v137 + v114 = v138 + v115 = v139 + v116 = v140 + continue + } // end let + v117 = v122 + } else { + var v123 any + { // let + // let binding "temp__0__auto__" + v124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v125 := v124.FindInternedVar(lang.NewSymbol("seq")) + if v125.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v125))) + } + v126 := v125.Get() + v127 := lang.Apply(v126, []any{v113}) + var v128 any = v127 + _ = v128 + var v129 any + if lang.IsTruthy(v128) { + var v130 any + { // let + // let binding "seq_122" + var v131 any = v128 + _ = v131 + var v132 any + v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v134 := v133.FindInternedVar(lang.NewSymbol("chunked-seq?")) + if v134.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) + } + v135 := v134.Get() + v136 := lang.Apply(v135, []any{v131}) + if lang.IsTruthy(v136) { + var v137 any + { // let + // let binding "c__0__auto__" + v138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v139 := v138.FindInternedVar(lang.NewSymbol("chunk-first")) + if v139.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v139))) + } + v140 := v139.Get() + v141 := lang.Apply(v140, []any{v131}) + var v142 any = v141 + _ = v142 + v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v145 := v144.FindInternedVar(lang.NewSymbol("chunk-rest")) + if v145.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) + } + v146 := v145.Get() + v147 := lang.Apply(v146, []any{v131}) + var v143 any = v147 + var v148 any = v142 + v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v151 := v150.FindInternedVar(lang.NewSymbol("int")) + if v151.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) + } + v152 := v151.Get() + v153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v154 := v153.FindInternedVar(lang.NewSymbol("count")) + if v154.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v154))) + } + v155 := v154.Get() + v156 := lang.Apply(v155, []any{v142}) + v157 := lang.Apply(v152, []any{v156}) + var v149 any = v157 + v159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v160 := v159.FindInternedVar(lang.NewSymbol("int")) + if v160.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v160))) + } + v161 := v160.Get() + v162 := lang.Apply(v161, []any{int64(0)}) + var v158 any = v162 + v113 = v143 + v114 = v148 + v115 = v149 + v116 = v158 + continue + } // end let + v132 = v137 + } else { + var v138 any + { // let + // let binding "arg" + v139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v140 := v139.FindInternedVar(lang.NewSymbol("first")) + if v140.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v140))) + } + v141 := v140.Get() + v142 := lang.Apply(v141, []any{v131}) + var v143 any = v142 + _ = v143 + v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v145 := v144.FindInternedVar(lang.NewSymbol("apply")) + if v145.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) + } + v146 := v145.Get() + v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v148 := v147.FindInternedVar(lang.NewSymbol("load-lib")) + if v148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) + } + v149 := v148.Get() + v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v151 := v150.FindInternedVar(lang.NewSymbol("prependss")) + if v151.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) + } + v152 := v151.Get() + v153 := lang.Apply(v152, []any{v143, v21}) + v154 := lang.Apply(v146, []any{v149, v98, v153}) + _ = v154 + v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v157 := v156.FindInternedVar(lang.NewSymbol("next")) + if v157.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) + } + v158 := v157.Get() + v159 := lang.Apply(v158, []any{v131}) + var v155 any = v159 + var v160 any = nil + var v161 any = int64(0) + var v162 any = int64(0) + v113 = v155 + v114 = v160 + v115 = v161 + v116 = v162 + continue + } // end let + v132 = v138 + } + v130 = v132 + } // end let + v129 = v130 + } else { + v129 = nil + } + v123 = v129 + } // end let + v117 = v123 + } + v108 = v117 + break + } + } // end let + v81 = v108 + } // end let + v65 = v81 + } + _ = v65 + var v82 any = v52 + var v83 any = v53 + var v84 any = v54 + v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v87 := v86.FindInternedVar(lang.NewSymbol("unchecked-inc")) + if v87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) + } + v88 := v87.Get() + v89 := lang.Apply(v88, []any{v55}) + var v85 any = v89 + v52 = v82 + v53 = v83 + v54 = v84 + v55 = v85 + continue + } // end let + v56 = v61 + } else { + var v62 any + { // let + // let binding "temp__0__auto__" + v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v64 := v63.FindInternedVar(lang.NewSymbol("seq")) + if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) + } + v65 := v64.Get() + v66 := lang.Apply(v65, []any{v52}) + var v67 any = v66 + _ = v67 + var v68 any + if lang.IsTruthy(v67) { + var v69 any + { // let + // let binding "seq_115" + var v70 any = v67 + _ = v70 + var v71 any + v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v73 := v72.FindInternedVar(lang.NewSymbol("chunked-seq?")) + if v73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) + } + v74 := v73.Get() + v75 := lang.Apply(v74, []any{v70}) + if lang.IsTruthy(v75) { + var v76 any + { // let + // let binding "c__0__auto__" + v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v78 := v77.FindInternedVar(lang.NewSymbol("chunk-first")) + if v78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) + } + v79 := v78.Get() + v80 := lang.Apply(v79, []any{v70}) + var v81 any = v80 + _ = v81 + v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v84 := v83.FindInternedVar(lang.NewSymbol("chunk-rest")) + if v84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) + } + v85 := v84.Get() + v86 := lang.Apply(v85, []any{v70}) + var v82 any = v86 + var v87 any = v81 + v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v90 := v89.FindInternedVar(lang.NewSymbol("int")) + if v90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) + } + v91 := v90.Get() + v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v93 := v92.FindInternedVar(lang.NewSymbol("count")) + if v93.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) + } + v94 := v93.Get() + v95 := lang.Apply(v94, []any{v81}) + v96 := lang.Apply(v91, []any{v95}) + var v88 any = v96 + v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v99 := v98.FindInternedVar(lang.NewSymbol("int")) + if v99.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) + } + v100 := v99.Get() + v101 := lang.Apply(v100, []any{int64(0)}) + var v97 any = v101 + v52 = v82 + v53 = v87 + v54 = v88 + v55 = v97 + continue + } // end let + v71 = v76 + } else { + var v77 any + { // let + // let binding "arg" + v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v79 := v78.FindInternedVar(lang.NewSymbol("first")) + if v79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) + } + v80 := v79.Get() + v81 := lang.Apply(v80, []any{v70}) + var v82 any = v81 + _ = v82 + var v83 any + v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v85 := v84.FindInternedVar(lang.NewSymbol("libspec?")) + if v85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) + } + v86 := v85.Get() + v87 := lang.Apply(v86, []any{v82}) + if lang.IsTruthy(v87) { + v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v89 := v88.FindInternedVar(lang.NewSymbol("apply")) + if v89.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) + } + v90 := v89.Get() + v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v92 := v91.FindInternedVar(lang.NewSymbol("load-lib")) + if v92.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) + } + v93 := v92.Get() + v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v95 := v94.FindInternedVar(lang.NewSymbol("prependss")) + if v95.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) + } + v96 := v95.Get() + v97 := lang.Apply(v96, []any{v82, v21}) + v98 := lang.Apply(v90, []any{v93, nil, v97}) + v83 = v98 + } else { + var v99 any + { // let + // let binding "vec__126" + var v100 any = v82 + _ = v100 + // let binding "seq__127" + v101 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v102 := v101.FindInternedVar(lang.NewSymbol("seq")) + if v102.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v102))) + } + v103 := v102.Get() + v104 := lang.Apply(v103, []any{v100}) + var v105 any = v104 + _ = v105 + // let binding "first__128" + v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v107 := v106.FindInternedVar(lang.NewSymbol("first")) + if v107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) + } + v108 := v107.Get() + v109 := lang.Apply(v108, []any{v105}) + var v110 any = v109 + _ = v110 + // let binding "seq__127" + v111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v112 := v111.FindInternedVar(lang.NewSymbol("next")) + if v112.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v112))) + } + v113 := v112.Get() + v114 := lang.Apply(v113, []any{v105}) + var v115 any = v114 + _ = v115 + // let binding "prefix" + var v116 any = v110 + _ = v116 + // let binding "args" + var v117 any = v115 + _ = v117 + v118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v119 := v118.FindInternedVar(lang.NewSymbol("throw-if")) + if v119.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v119))) + } + v120 := v119.Get() + v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v122 := v121.FindInternedVar(lang.NewSymbol("nil?")) + if v122.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) + } + v123 := v122.Get() + v124 := lang.Apply(v123, []any{v116}) + v125 := lang.Apply(v120, []any{v124, "prefix cannot be nil"}) + _ = v125 + var v126 any + { // let + // let binding "seq_129" + v127 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v128 := v127.FindInternedVar(lang.NewSymbol("seq")) + if v128.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v128))) + } + v129 := v128.Get() + v130 := lang.Apply(v129, []any{v117}) + var v131 any = v130 + _ = v131 + // let binding "chunk_130" + var v132 any = nil + _ = v132 + // let binding "count_131" + var v133 any = int64(0) + _ = v133 + // let binding "i_132" + var v134 any = int64(0) + _ = v134 + for { + var v135 any + v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v137 := v136.FindInternedVar(lang.NewSymbol("<")) + if v137.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) + } + v138 := v137.Get() + v139 := lang.Apply(v138, []any{v134, v133}) + if lang.IsTruthy(v139) { + var v140 any + { // let + // let binding "arg" + v141, _ := lang.FieldOrMethod(v132, "nth") + if reflect.TypeOf(v141).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + v142 := lang.Apply(v141, []any{v134}) + var v143 any = v142 + _ = v143 + v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v145 := v144.FindInternedVar(lang.NewSymbol("apply")) + if v145.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) + } + v146 := v145.Get() + v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v148 := v147.FindInternedVar(lang.NewSymbol("load-lib")) + if v148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) + } + v149 := v148.Get() + v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v151 := v150.FindInternedVar(lang.NewSymbol("prependss")) + if v151.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) + } + v152 := v151.Get() + v153 := lang.Apply(v152, []any{v143, v21}) + v154 := lang.Apply(v146, []any{v149, v116, v153}) + _ = v154 + var v155 any = v131 + var v156 any = v132 + var v157 any = v133 + v159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v160 := v159.FindInternedVar(lang.NewSymbol("unchecked-inc")) + if v160.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v160))) + } + v161 := v160.Get() + v162 := lang.Apply(v161, []any{v134}) + var v158 any = v162 + v131 = v155 + v132 = v156 + v133 = v157 + v134 = v158 + continue + } // end let + v135 = v140 + } else { + var v141 any + { // let + // let binding "temp__0__auto__" + v142 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v143 := v142.FindInternedVar(lang.NewSymbol("seq")) + if v143.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v143))) + } + v144 := v143.Get() + v145 := lang.Apply(v144, []any{v131}) + var v146 any = v145 + _ = v146 + var v147 any + if lang.IsTruthy(v146) { + var v148 any + { // let + // let binding "seq_129" + var v149 any = v146 + _ = v149 + var v150 any + v151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v152 := v151.FindInternedVar(lang.NewSymbol("chunked-seq?")) + if v152.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v152))) + } + v153 := v152.Get() + v154 := lang.Apply(v153, []any{v149}) + if lang.IsTruthy(v154) { + var v155 any + { // let + // let binding "c__0__auto__" + v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v157 := v156.FindInternedVar(lang.NewSymbol("chunk-first")) + if v157.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) + } + v158 := v157.Get() + v159 := lang.Apply(v158, []any{v149}) + var v160 any = v159 + _ = v160 + v162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v163 := v162.FindInternedVar(lang.NewSymbol("chunk-rest")) + if v163.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v163))) + } + v164 := v163.Get() + v165 := lang.Apply(v164, []any{v149}) + var v161 any = v165 + var v166 any = v160 + v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v169 := v168.FindInternedVar(lang.NewSymbol("int")) + if v169.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) + } + v170 := v169.Get() + v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v172 := v171.FindInternedVar(lang.NewSymbol("count")) + if v172.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) + } + v173 := v172.Get() + v174 := lang.Apply(v173, []any{v160}) + v175 := lang.Apply(v170, []any{v174}) + var v167 any = v175 + v177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v178 := v177.FindInternedVar(lang.NewSymbol("int")) + if v178.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v178))) + } + v179 := v178.Get() + v180 := lang.Apply(v179, []any{int64(0)}) + var v176 any = v180 + v131 = v161 + v132 = v166 + v133 = v167 + v134 = v176 + continue + } // end let + v150 = v155 + } else { + var v156 any + { // let + // let binding "arg" + v157 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v158 := v157.FindInternedVar(lang.NewSymbol("first")) + if v158.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v158))) + } + v159 := v158.Get() + v160 := lang.Apply(v159, []any{v149}) + var v161 any = v160 + _ = v161 + v162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v163 := v162.FindInternedVar(lang.NewSymbol("apply")) + if v163.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v163))) + } + v164 := v163.Get() + v165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v166 := v165.FindInternedVar(lang.NewSymbol("load-lib")) + if v166.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v166))) + } + v167 := v166.Get() + v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v169 := v168.FindInternedVar(lang.NewSymbol("prependss")) + if v169.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) + } + v170 := v169.Get() + v171 := lang.Apply(v170, []any{v161, v21}) + v172 := lang.Apply(v164, []any{v167, v116, v171}) + _ = v172 + v174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v175 := v174.FindInternedVar(lang.NewSymbol("next")) + if v175.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v175))) + } + v176 := v175.Get() + v177 := lang.Apply(v176, []any{v149}) + var v173 any = v177 + var v178 any = nil + var v179 any = int64(0) + var v180 any = int64(0) + v131 = v173 + v132 = v178 + v133 = v179 + v134 = v180 + continue + } // end let + v150 = v156 + } + v148 = v150 + } // end let + v147 = v148 + } else { + v147 = nil + } + v141 = v147 + } // end let + v135 = v141 + } + v126 = v135 + break + } + } // end let + v99 = v126 + } // end let + v83 = v99 + } + _ = v83 + v101 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v102 := v101.FindInternedVar(lang.NewSymbol("next")) + if v102.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v102))) + } + v103 := v102.Get() + v104 := lang.Apply(v103, []any{v70}) + var v100 any = v104 + var v105 any = nil + var v106 any = int64(0) + var v107 any = int64(0) + v52 = v100 + v53 = v105 + v54 = v106 + v55 = v107 + continue + } // end let + v71 = v77 + } + v69 = v71 + } // end let + v68 = v69 + } else { + v68 = nil + } + v62 = v68 + } // end let + v56 = v62 + } + v47 = v56 + break + } + } // end let + v4 = v47 + } // end let + return v4 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // load-one + { + v0 := lang.NewSymbol("load-one").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"), lang.NewSymbol("need-ns"), lang.NewSymbol("require"))), lang.NewKeyword("doc"), "Loads a lib given its name. If need-ns, ensures that the associated\n namespace exists after loading. If require, records the load so any\n duplicate loads can be skipped.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5879), lang.NewKeyword("end-line"), int(5879), lang.NewKeyword("private"), true)).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("load")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("root-resource")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.Apply(v11, []any{v3}) + v13 := lang.Apply(v8, []any{v12}) + _ = v13 + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("throw-if")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + var v17 any + { // let + // let binding "and__0__auto__" + var v18 any = v4 + _ = v18 + var v19 any + if lang.IsTruthy(v18) { + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("not")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("find-ns")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.Apply(v25, []any{v3}) + v27 := lang.Apply(v22, []any{v26}) + v19 = v27 + } else { + v19 = v18 + } + v17 = v19 + } // end let + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("root-resource")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.Apply(v20, []any{v3}) + v22 := lang.Apply(v16, []any{v17, "namespace '%s' not found after loading '%s'", v3, v21}) + _ = v22 + var v23 any + if lang.IsTruthy(v5) { + var v24 lang.FnFunc + v24 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("commute")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("*loaded-libs*")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("conj")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v27, []any{v30, v33, v3}) + return v34 + }) + v25, _ := lang.FieldOrMethod(lang.LockingTransaction, "RunInTransaction") + if reflect.TypeOf(v25).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("RunInTransaction is not a function"))) + } + v26 := lang.Apply(v25, []any{v24}) + v23 = v26 + } else { + v23 = nil + } + return v23 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // load-reader + { + v0 := lang.NewSymbol("load-reader").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rdr"))), lang.NewKeyword("doc"), "Sequentially read and evaluate the set of forms contained in the\n stream/file", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4081), lang.NewKeyword("end-line"), int(4081))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4, _ := lang.FieldOrMethod(runtime4.Compiler, "load") + if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("load is not a function"))) + } + v5 := lang.Apply(v4, []any{v3}) + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // load-string + { + v0 := lang.NewSymbol("load-string").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Sequentially read and evaluate the set of forms contained in the\n string", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4088), lang.NewKeyword("end-line"), int(4088))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + { // let + // let binding "rdr" + v5 := lang.Apply(nil, []any{v3}) + v6 := lang.Apply(nil, []any{v5}) + var v7 any = v6 + _ = v7 + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("load-reader")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v7}) + v4 = v11 + } // end let + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // loaded-libs + { + v0 := lang.NewSymbol("loaded-libs").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Returns a sorted set of symbols naming the currently loaded libs", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6090), lang.NewKeyword("end-line"), int(6090))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v4 := v3.FindInternedVar(lang.NewSymbol("deref")) + if v4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) + } + v5 := v4.Get() + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("*loaded-libs*")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v5, []any{v8}) + return v9 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // locking + { + v0 := lang.NewSymbol("locking").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Executes exprs in an implicit do, while holding the monitor of x.\n Will release the monitor of x in all circumstances.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1643), lang.NewKeyword("end-line"), int(1643))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("seq")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("concat")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("list")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/let")}) + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("list")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("apply")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("vector")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("seq")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("concat")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("list")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{lang.NewSymbol("lockee__0__auto__")}) + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("list")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v38, []any{v5}) + v40 := lang.Apply(v31, []any{v35, v39}) + v41 := lang.Apply(v28, []any{v40}) + v42 := lang.Apply(v22, []any{v25, v41}) + v43 := lang.Apply(v19, []any{v42}) + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("list")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v48 := v47.FindInternedVar(lang.NewSymbol("seq")) + if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) + } + v49 := v48.Get() + v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v51 := v50.FindInternedVar(lang.NewSymbol("concat")) + if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) + } + v52 := v51.Get() + v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v54 := v53.FindInternedVar(lang.NewSymbol("list")) + if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) + } + v55 := v54.Get() + v56 := lang.Apply(v55, []any{lang.NewSymbol("try")}) + v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v58 := v57.FindInternedVar(lang.NewSymbol("list")) + if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) + } + v59 := v58.Get() + v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v61 := v60.FindInternedVar(lang.NewSymbol("seq")) + if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) + } + v62 := v61.Get() + v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v64 := v63.FindInternedVar(lang.NewSymbol("concat")) + if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) + } + v65 := v64.Get() + v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v67 := v66.FindInternedVar(lang.NewSymbol("list")) + if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) + } + v68 := v67.Get() + v69 := lang.Apply(v68, []any{lang.NewSymbol("glojure.core/let")}) + v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v71 := v70.FindInternedVar(lang.NewSymbol("list")) + if v71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) + } + v72 := v71.Get() + v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v74 := v73.FindInternedVar(lang.NewSymbol("apply")) + if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) + } + v75 := v74.Get() + v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v77 := v76.FindInternedVar(lang.NewSymbol("vector")) + if v77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) + } + v78 := v77.Get() + v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v80 := v79.FindInternedVar(lang.NewSymbol("seq")) + if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) + } + v81 := v80.Get() + v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v83 := v82.FindInternedVar(lang.NewSymbol("concat")) + if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) + } + v84 := v83.Get() + v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v86 := v85.FindInternedVar(lang.NewSymbol("list")) + if v86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) + } + v87 := v86.Get() + v88 := lang.Apply(v87, []any{lang.NewSymbol("locklocal__1__auto__")}) + v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v90 := v89.FindInternedVar(lang.NewSymbol("list")) + if v90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) + } + v91 := v90.Get() + v92 := lang.Apply(v91, []any{lang.NewSymbol("lockee__0__auto__")}) + v93 := lang.Apply(v84, []any{v88, v92}) + v94 := lang.Apply(v81, []any{v93}) + v95 := lang.Apply(v75, []any{v78, v94}) + v96 := lang.Apply(v72, []any{v95}) + v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v98 := v97.FindInternedVar(lang.NewSymbol("list")) + if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) + } + v99 := v98.Get() + v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v101 := v100.FindInternedVar(lang.NewSymbol("seq")) + if v101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) + } + v102 := v101.Get() + v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v104 := v103.FindInternedVar(lang.NewSymbol("concat")) + if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) + } + v105 := v104.Get() + v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v107 := v106.FindInternedVar(lang.NewSymbol("list")) + if v107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) + } + v108 := v107.Get() + v109 := lang.Apply(v108, []any{lang.NewSymbol("monitor-enter")}) + v110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v111 := v110.FindInternedVar(lang.NewSymbol("list")) + if v111.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v111))) + } + v112 := v111.Get() + v113 := lang.Apply(v112, []any{lang.NewSymbol("locklocal__1__auto__")}) + v114 := lang.Apply(v105, []any{v109, v113}) + v115 := lang.Apply(v102, []any{v114}) + v116 := lang.Apply(v99, []any{v115}) + v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v118 := v117.FindInternedVar(lang.NewSymbol("list")) + if v118.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) + } + v119 := v118.Get() + v120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v121 := v120.FindInternedVar(lang.NewSymbol("seq")) + if v121.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v121))) + } + v122 := v121.Get() + v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v124 := v123.FindInternedVar(lang.NewSymbol("concat")) + if v124.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) + } + v125 := v124.Get() + v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v127 := v126.FindInternedVar(lang.NewSymbol("list")) + if v127.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) + } + v128 := v127.Get() + v129 := lang.Apply(v128, []any{lang.NewSymbol("try")}) + v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v131 := v130.FindInternedVar(lang.NewSymbol("list")) + if v131.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) + } + v132 := v131.Get() + v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v134 := v133.FindInternedVar(lang.NewSymbol("seq")) + if v134.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) + } + v135 := v134.Get() + v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v137 := v136.FindInternedVar(lang.NewSymbol("concat")) + if v137.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) + } + v138 := v137.Get() + v139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v140 := v139.FindInternedVar(lang.NewSymbol("list")) + if v140.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v140))) + } + v141 := v140.Get() + v142 := lang.Apply(v141, []any{lang.NewSymbol("finally")}) + v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v144 := v143.FindInternedVar(lang.NewSymbol("list")) + if v144.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) + } + v145 := v144.Get() + v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v147 := v146.FindInternedVar(lang.NewSymbol("seq")) + if v147.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) + } + v148 := v147.Get() + v149 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v150 := v149.FindInternedVar(lang.NewSymbol("concat")) + if v150.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v150))) + } + v151 := v150.Get() + v152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v153 := v152.FindInternedVar(lang.NewSymbol("list")) + if v153.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v153))) + } + v154 := v153.Get() + v155 := lang.Apply(v154, []any{lang.NewSymbol("monitor-exit")}) + v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v157 := v156.FindInternedVar(lang.NewSymbol("list")) + if v157.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) + } + v158 := v157.Get() + v159 := lang.Apply(v158, []any{lang.NewSymbol("locklocal__1__auto__")}) + v160 := lang.Apply(v151, []any{v155, v159}) + v161 := lang.Apply(v148, []any{v160}) + v162 := lang.Apply(v145, []any{v161}) + v163 := lang.Apply(v138, []any{v142, v162}) + v164 := lang.Apply(v135, []any{v163}) + v165 := lang.Apply(v132, []any{v164}) + v166 := lang.Apply(v125, []any{v129, v6, v165}) + v167 := lang.Apply(v122, []any{v166}) + v168 := lang.Apply(v119, []any{v167}) + v169 := lang.Apply(v65, []any{v69, v96, v116, v168}) + v170 := lang.Apply(v62, []any{v169}) + v171 := lang.Apply(v59, []any{v170}) + v172 := lang.Apply(v52, []any{v56, v171}) + v173 := lang.Apply(v49, []any{v172}) + v174 := lang.Apply(v46, []any{v173}) + v175 := lang.Apply(v12, []any{v16, v43, v174}) + v176 := lang.Apply(v9, []any{v175}) + return v176 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // long + { + var v1 lang.FnFunc + { // function long__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("concat")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("list")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("seq")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("concat")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/LongCast")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{v3}) + v35 := lang.Apply(v26, []any{v30, v34}) + v36 := lang.Apply(v23, []any{v35}) + v37 := lang.Apply(v20, []any{v36}) + v38 := lang.Apply(v9, []any{v13, v17, v37}) + v39 := lang.Apply(v6, []any{v38}) + return v39 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("long").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to long", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3481), lang.NewKeyword("end-line"), int(3481))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := lang.Apply(lang.LongCast, []any{v4}) + return v5 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // long-array + { + var v1 lang.FnFunc + { // function long-array__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := lang.NewList(args[0:]...) + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("concat")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("list")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/LongArray")}) + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("list")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("seq")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("concat")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) + v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v36 := v35.FindInternedVar(lang.NewSymbol("list")) + if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + } + v37 := v36.Get() + v38 := lang.Apply(v37, []any{lang.NewSymbol("glojure.core/args")}) + v39 := lang.Apply(v30, []any{v34, v38}) + v40 := lang.Apply(v27, []any{v39}) + v41 := lang.Apply(v24, []any{v40}) + v42 := lang.Apply(v9, []any{v13, v17, v21, v41}) + v43 := lang.Apply(v6, []any{v42}) + return v43 + } + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("long-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Creates an array of longs", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1), int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5364), lang.NewKeyword("end-line"), int(5364))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + v5, _ := lang.FieldOrMethod(lang.Numbers, "LongArray") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("LongArray is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6, _ := lang.FieldOrMethod(lang.Numbers, "LongArrayInit") + if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("LongArrayInit is not a function"))) + } + v7 := lang.Apply(v6, []any{v4, v5}) + return v7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // longs + { + var v1 lang.FnFunc + { // function longs + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("concat")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("list")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/Longs")}) + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("list")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v3}) + v26 := lang.Apply(v9, []any{v13, v17, v21, v25}) + v27 := lang.Apply(v6, []any{v26}) + return v27 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("longs").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Casts to long[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5407), lang.NewKeyword("end-line"), int(5407))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5, _ := lang.FieldOrMethod(lang.Numbers, "Longs") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Longs is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // loop + { + v0 := lang.NewSymbol("loop").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Evaluates the exprs in a lexical context in which the symbols in\n the binding-forms are bound to their respective init-exprs or parts\n therein. Acts as a recur target.", lang.NewKeyword("forms"), lang.NewVector(lang.NewList(lang.NewSymbol("loop"), lang.NewVector(lang.NewSymbol("bindings*")), lang.NewSymbol("exprs*"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4597), lang.NewKeyword("end-line"), int(4597), lang.NewKeyword("special-form"), true)).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + var v7 any + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v5}) + if lang.IsTruthy(v11) { + v7 = nil + } else { + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("str")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("first")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{v3}) + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("meta")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v3}) + v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) + v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) + v28 := lang.Apply(lang.NewIllegalArgumentError, []any{v27}) + panic(v28) + } + _ = v7 + var v29 any + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("even?")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("count")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.Apply(v35, []any{v5}) + v37 := lang.Apply(v32, []any{v36}) + if lang.IsTruthy(v37) { + v29 = nil + } else { + v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v39 := v38.FindInternedVar(lang.NewSymbol("str")) + if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + } + v40 := v39.Get() + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("first")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.Apply(v43, []any{v3}) + v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) + if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) + } + v47 := v46.Get() + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("meta")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v3}) + v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) + v53 := lang.Apply(v40, []any{v44, " requires ", "an even number of forms in binding vector", " in ", v47, ":", v52}) + v54 := lang.Apply(lang.NewIllegalArgumentError, []any{v53}) + panic(v54) + } + _ = v29 + _ = nil + var v55 any + { // let + // let binding "db" + v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v57 := v56.FindInternedVar(lang.NewSymbol("destructure")) + if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) + } + v58 := v57.Get() + v59 := lang.Apply(v58, []any{v5}) + var v60 any = v59 + _ = v60 + var v61 any + v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v63 := v62.FindInternedVar(lang.NewSymbol("=")) + if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) + } + v64 := v63.Get() + v65 := lang.Apply(v64, []any{v60, v5}) + if lang.IsTruthy(v65) { + v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v67 := v66.FindInternedVar(lang.NewSymbol("seq")) + if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) + } + v68 := v67.Get() + v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v70 := v69.FindInternedVar(lang.NewSymbol("concat")) + if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) + } + v71 := v70.Get() + v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v73 := v72.FindInternedVar(lang.NewSymbol("list")) + if v73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) + } + v74 := v73.Get() + v75 := lang.Apply(v74, []any{lang.NewSymbol("loop*")}) + v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v77 := v76.FindInternedVar(lang.NewSymbol("list")) + if v77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) + } + v78 := v77.Get() + v79 := lang.Apply(v78, []any{v5}) + v80 := lang.Apply(v71, []any{v75, v79, v6}) + v81 := lang.Apply(v68, []any{v80}) + v61 = v81 + } else { + var v82 any + { // let + // let binding "vs" + v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v84 := v83.FindInternedVar(lang.NewSymbol("take-nth")) + if v84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) + } + v85 := v84.Get() + v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v87 := v86.FindInternedVar(lang.NewSymbol("drop")) + if v87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) + } + v88 := v87.Get() + v89 := lang.Apply(v88, []any{int64(1), v5}) + v90 := lang.Apply(v85, []any{int64(2), v89}) + var v91 any = v90 + _ = v91 + // let binding "bs" + v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v93 := v92.FindInternedVar(lang.NewSymbol("take-nth")) + if v93.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) + } + v94 := v93.Get() + v95 := lang.Apply(v94, []any{int64(2), v5}) + var v96 any = v95 + _ = v96 + // let binding "gs" + v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v98 := v97.FindInternedVar(lang.NewSymbol("map")) + if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) + } + v99 := v98.Get() + var v100 lang.FnFunc + v100 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v101 := args[0] + _ = v101 + var v102 any + v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v104 := v103.FindInternedVar(lang.NewSymbol("symbol?")) + if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) + } + v105 := v104.Get() + v106 := lang.Apply(v105, []any{v101}) + if lang.IsTruthy(v106) { + v102 = v101 + } else { + v107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v108 := v107.FindInternedVar(lang.NewSymbol("gensym")) + if v108.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v108))) + } + v109 := v108.Get() + v110 := lang.Apply(v109, nil) + v102 = v110 + } + return v102 + }) + v101 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4611), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(4611), lang.NewKeyword("end-column"), int(58)) + v102, err := lang.WithMeta(v100, v101.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v103 := lang.Apply(v99, []any{v102, v96}) + var v104 any = v103 + _ = v104 + // let binding "bfs" + v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v106 := v105.FindInternedVar(lang.NewSymbol("reduce1")) + if v106.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) + } + v107 := v106.Get() + var v108 lang.FnFunc + v108 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v109 := args[0] + _ = v109 + v110 := args[1] + _ = v110 + var v111 any + { // let + // let binding "vec__17" + var v112 any = v110 + _ = v112 + // let binding "b" + v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v114 := v113.FindInternedVar(lang.NewSymbol("nth")) + if v114.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) + } + v115 := v114.Get() + v116 := lang.Apply(v115, []any{v112, int64(0), nil}) + var v117 any = v116 + _ = v117 + // let binding "v" + v118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v119 := v118.FindInternedVar(lang.NewSymbol("nth")) + if v119.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v119))) + } + v120 := v119.Get() + v121 := lang.Apply(v120, []any{v112, int64(1), nil}) + var v122 any = v121 + _ = v122 + // let binding "g" + v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v124 := v123.FindInternedVar(lang.NewSymbol("nth")) + if v124.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) + } + v125 := v124.Get() + v126 := lang.Apply(v125, []any{v112, int64(2), nil}) + var v127 any = v126 + _ = v127 + var v128 any + v129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v130 := v129.FindInternedVar(lang.NewSymbol("symbol?")) + if v130.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v130))) + } + v131 := v130.Get() + v132 := lang.Apply(v131, []any{v117}) + if lang.IsTruthy(v132) { + v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v134 := v133.FindInternedVar(lang.NewSymbol("conj")) + if v134.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) + } + v135 := v134.Get() + v136 := lang.Apply(v135, []any{v109, v127, v122}) + v128 = v136 + } else { + v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v138 := v137.FindInternedVar(lang.NewSymbol("conj")) + if v138.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) + } + v139 := v138.Get() + v140 := lang.Apply(v139, []any{v109, v127, v122, v117, v127}) + v128 = v140 + } + v111 = v128 + } // end let + return v111 + }) + v109 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4612), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(4615), lang.NewKeyword("end-column"), int(50)) + v110, err := lang.WithMeta(v108, v109.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v111 := lang.NewVector() + v112 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4616), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(4616), lang.NewKeyword("end-column"), int(28)) + v113, err := lang.WithMeta(v111, v112.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v115 := v114.FindInternedVar(lang.NewSymbol("map")) + if v115.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v115))) + } + v116 := v115.Get() + v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v118 := v117.FindInternedVar(lang.NewSymbol("vector")) + if v118.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) + } + v119 := v118.Get() + v120 := lang.Apply(v116, []any{v119, v96, v91, v104}) + v121 := lang.Apply(v107, []any{v110, v113, v120}) + var v122 any = v121 + _ = v122 + v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v124 := v123.FindInternedVar(lang.NewSymbol("seq")) + if v124.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) + } + v125 := v124.Get() + v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v127 := v126.FindInternedVar(lang.NewSymbol("concat")) + if v127.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) + } + v128 := v127.Get() + v129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v130 := v129.FindInternedVar(lang.NewSymbol("list")) + if v130.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v130))) + } + v131 := v130.Get() + v132 := lang.Apply(v131, []any{lang.NewSymbol("glojure.core/let")}) + v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v134 := v133.FindInternedVar(lang.NewSymbol("list")) + if v134.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) + } + v135 := v134.Get() + v136 := lang.Apply(v135, []any{v122}) + v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v138 := v137.FindInternedVar(lang.NewSymbol("list")) + if v138.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) + } + v139 := v138.Get() + v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v141 := v140.FindInternedVar(lang.NewSymbol("seq")) + if v141.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) + } + v142 := v141.Get() + v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v144 := v143.FindInternedVar(lang.NewSymbol("concat")) + if v144.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) + } + v145 := v144.Get() + v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v147 := v146.FindInternedVar(lang.NewSymbol("list")) + if v147.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) + } + v148 := v147.Get() + v149 := lang.Apply(v148, []any{lang.NewSymbol("loop*")}) + v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v151 := v150.FindInternedVar(lang.NewSymbol("list")) + if v151.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) + } + v152 := v151.Get() + v153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v154 := v153.FindInternedVar(lang.NewSymbol("vec")) + if v154.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v154))) + } + v155 := v154.Get() + v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v157 := v156.FindInternedVar(lang.NewSymbol("interleave")) + if v157.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) + } + v158 := v157.Get() + v159 := lang.Apply(v158, []any{v104, v104}) + v160 := lang.Apply(v155, []any{v159}) + v161 := lang.Apply(v152, []any{v160}) + v162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v163 := v162.FindInternedVar(lang.NewSymbol("list")) + if v163.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v163))) + } + v164 := v163.Get() + v165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v166 := v165.FindInternedVar(lang.NewSymbol("seq")) + if v166.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v166))) + } + v167 := v166.Get() + v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v169 := v168.FindInternedVar(lang.NewSymbol("concat")) + if v169.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) + } + v170 := v169.Get() + v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v172 := v171.FindInternedVar(lang.NewSymbol("list")) + if v172.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) + } + v173 := v172.Get() + v174 := lang.Apply(v173, []any{lang.NewSymbol("glojure.core/let")}) + v175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v176 := v175.FindInternedVar(lang.NewSymbol("list")) + if v176.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v176))) + } + v177 := v176.Get() + v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v179 := v178.FindInternedVar(lang.NewSymbol("vec")) + if v179.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) + } + v180 := v179.Get() + v181 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v182 := v181.FindInternedVar(lang.NewSymbol("interleave")) + if v182.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v182))) + } + v183 := v182.Get() + v184 := lang.Apply(v183, []any{v96, v104}) + v185 := lang.Apply(v180, []any{v184}) + v186 := lang.Apply(v177, []any{v185}) + v187 := lang.Apply(v170, []any{v174, v186, v6}) + v188 := lang.Apply(v167, []any{v187}) + v189 := lang.Apply(v164, []any{v188}) + v190 := lang.Apply(v145, []any{v149, v161, v189}) + v191 := lang.Apply(v142, []any{v190}) + v192 := lang.Apply(v139, []any{v191}) + v193 := lang.Apply(v128, []any{v132, v136, v192}) + v194 := lang.Apply(v125, []any{v193}) + v82 = v194 + } // end let + v61 = v82 + } + v55 = v61 + } // end let + return v55 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // macroexpand + { + v0 := lang.NewSymbol("macroexpand").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("form"))), lang.NewKeyword("doc"), "Repeatedly calls macroexpand-1 on form until it no longer\n represents a macro form, then returns it. Note neither\n macroexpand-1 nor macroexpand expand macros in subforms.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4025), lang.NewKeyword("end-line"), int(4025))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + { // let + // let binding "ex" + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("macroexpand-1")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v3}) + var v9 any = v8 + _ = v9 + var v10 any + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("identical?")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{v9, v3}) + if lang.IsTruthy(v14) { + v10 = v3 + } else { + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("macroexpand")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{v9}) + v10 = v18 + } + v4 = v10 + } // end let + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // macroexpand-1 + { + v0 := lang.NewSymbol("macroexpand-1").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("form"))), lang.NewKeyword("doc"), "If form represents a macro form, returns its expansion,\n else returns form.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4017), lang.NewKeyword("end-line"), int(4017))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4, _ := lang.FieldOrMethod(runtime4.Compiler, "macroexpand1") + if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("macroexpand1 is not a function"))) + } + v5 := lang.Apply(v4, []any{v3}) + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // make-array + { + v0 := lang.NewSymbol("make-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("type"), lang.NewSymbol("len")), lang.NewVector(lang.NewSymbol("type"), lang.NewSymbol("dim"), lang.NewSymbol("&"), lang.NewSymbol("more-dims"))), lang.NewKeyword("doc"), "Creates and returns an array of instances of the specified class of\n the specified dimension(s). Note that a class object is required.\n Class objects can be obtained by using their imported or\n fully-qualified name. Class objects for the primitive types can be\n obtained using, e.g., Integer/TYPE.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3985), lang.NewKeyword("end-line"), int(3985))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("int")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v4}) + v9, _ := lang.FieldOrMethod(nil, "newInstance") + if reflect.TypeOf(v9).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("newInstance is not a function"))) + } + v10 := lang.Apply(v9, []any{v3, v8}) + return v10 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.NewList(args[2:]...) + var v6 any + { // let + // let binding "dims" + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("cons")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, []any{v4, v5}) + var v11 any = v10 + _ = v11 + // let binding "dimarray" + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("make-array")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15, ok := lang.FieldOrMethod(nil, "TYPE") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "TYPE"))) + } + var v16 any + switch reflect.TypeOf(v15).Kind() { + case reflect.Func: + v16 = lang.Apply(v15, nil) + default: + v16 = v15 + } + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("count")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.Apply(v19, []any{v11}) + v21 := lang.Apply(v14, []any{v16, v20}) + var v22 any = v21 + _ = v22 + var v23 any + { // let + // let binding "n__0__auto__" + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("long")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("alength")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{v22}) + v31 := lang.Apply(v26, []any{v30}) + var v32 any = v31 + _ = v32 + var v33 any + { // let + // let binding "i" + var v34 any = int64(0) + _ = v34 + for { + var v35 any + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("<")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v38, []any{v34, v32}) + if lang.IsTruthy(v39) { + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("aset-int")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v44 := v43.FindInternedVar(lang.NewSymbol("nth")) + if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) + } + v45 := v44.Get() + v46 := lang.Apply(v45, []any{v11, v34}) + v47 := lang.Apply(v42, []any{v22, v34, v46}) + _ = v47 + v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v50 := v49.FindInternedVar(lang.NewSymbol("unchecked-inc")) + if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) + } + v51 := v50.Get() + v52 := lang.Apply(v51, []any{v34}) + var v48 any = v52 + v34 = v48 + continue + } else { + v35 = nil + } + v33 = v35 + break + } + } // end let + v23 = v33 + } // end let + _ = v23 + v24, _ := lang.FieldOrMethod(nil, "newInstance") + if reflect.TypeOf(v24).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("newInstance is not a function"))) + } + v25 := lang.Apply(v24, []any{v3, v22}) + v6 = v25 + } // end let + return v6 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // make-hierarchy + { + v0 := lang.NewSymbol("make-hierarchy").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Creates a hierarchy object for use with derive, isa? etc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5507), lang.NewKeyword("end-line"), int(5507))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := lang.NewMap() + v4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5511), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(5511), lang.NewKeyword("end-column"), int(17)) + v5, err := lang.WithMeta(v3, v4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v6 := lang.NewMap() + v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5511), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(5511), lang.NewKeyword("end-column"), int(33)) + v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v9 := lang.NewMap() + v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5511), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(5511), lang.NewKeyword("end-column"), int(47)) + v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v12 := lang.NewMap(lang.NewKeyword("parents"), v5, lang.NewKeyword("descendants"), v8, lang.NewKeyword("ancestors"), v11) + v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5511), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(5511), lang.NewKeyword("end-column"), int(48)) + v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v14 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // map + { + v0 := lang.NewSymbol("map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2"), lang.NewSymbol("c3")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2"), lang.NewSymbol("c3"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Returns a lazy sequence consisting of the result of applying f to\n the set of first items of each coll, followed by applying f to the\n set of second items in each coll, until any one of the colls is\n exhausted. Any remaining items in other colls are ignored. Function\n f should accept number-of-colls arguments. Returns a transducer when\n no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2719), lang.NewKeyword("end-line"), int(2719))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + var v4 lang.FnFunc + v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + var v6 lang.FnFunc + v6 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + v7 := lang.Apply(v5, nil) + return v7 + case 1: + v7 := args[0] + _ = v7 + v8 := lang.Apply(v5, []any{v7}) + return v8 + case 2: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := lang.Apply(v3, []any{v8}) + v10 := lang.Apply(v5, []any{v7, v9}) + return v10 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := lang.NewList(args[2:]...) + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("apply")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{v3, v8, v9}) + v14 := lang.Apply(v5, []any{v7, v13}) + return v14 + } + }) + v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2730), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(2736), lang.NewKeyword("end-column"), int(47)) + v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v8 + }) + v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2729), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2736), lang.NewKeyword("end-column"), int(48)) + v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v6 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 lang.FnFunc + v5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v6 any + { // let + // let binding "temp__0__auto__" + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("seq")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, []any{v4}) + var v11 any = v10 + _ = v11 + var v12 any + if lang.IsTruthy(v11) { + var v13 any + { // let + // let binding "s" + var v14 any = v11 + _ = v14 + var v15 any + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("chunked-seq?")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{v14}) + if lang.IsTruthy(v19) { + var v20 any + { // let + // let binding "c" + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("chunk-first")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.Apply(v23, []any{v14}) + var v25 any = v24 + _ = v25 + // let binding "size" + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("int")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("count")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.Apply(v31, []any{v25}) + v33 := lang.Apply(v28, []any{v32}) + var v34 any = v33 + _ = v34 + // let binding "b" + v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v36 := v35.FindInternedVar(lang.NewSymbol("chunk-buffer")) + if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + } + v37 := v36.Get() + v38 := lang.Apply(v37, []any{v34}) + var v39 any = v38 + _ = v39 + var v40 any + { // let + // let binding "n__0__auto__" + v41 := lang.Apply(lang.LongCast, []any{v34}) + var v42 any = v41 + _ = v42 + var v43 any + { // let + // let binding "i" + var v44 any = int64(0) + _ = v44 + for { + var v45 any + v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v47 := v46.FindInternedVar(lang.NewSymbol("<")) + if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) + } + v48 := v47.Get() + v49 := lang.Apply(v48, []any{v44, v42}) + if lang.IsTruthy(v49) { + v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v51 := v50.FindInternedVar(lang.NewSymbol("chunk-append")) + if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) + } + v52 := v51.Get() + v53, _ := lang.FieldOrMethod(v25, "nth") + if reflect.TypeOf(v53).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + v54 := lang.Apply(v53, []any{v44}) + v55 := lang.Apply(v3, []any{v54}) + v56 := lang.Apply(v52, []any{v39, v55}) + _ = v56 + v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v59 := v58.FindInternedVar(lang.NewSymbol("unchecked-inc")) + if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) + } + v60 := v59.Get() + v61 := lang.Apply(v60, []any{v44}) + var v57 any = v61 + v44 = v57 + continue + } else { + v45 = nil + } + v43 = v45 + break + } + } // end let + v40 = v43 + } // end let + _ = v40 + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("chunk-cons")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("chunk")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.Apply(v46, []any{v39}) + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("map")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v52 := v51.FindInternedVar(lang.NewSymbol("chunk-rest")) + if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) + } + v53 := v52.Get() + v54 := lang.Apply(v53, []any{v14}) + v55 := lang.Apply(v50, []any{v3, v54}) + v56 := lang.Apply(v43, []any{v47, v55}) + v20 = v56 + } // end let + v15 = v20 + } else { + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("cons")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("first")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.Apply(v26, []any{v14}) + v28 := lang.Apply(v3, []any{v27}) + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("map")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("rest")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{v14}) + v36 := lang.Apply(v31, []any{v3, v35}) + v37 := lang.Apply(v23, []any{v28, v36}) + v15 = v37 + } + v13 = v15 + } // end let + v12 = v13 + } else { + v12 = nil + } + v6 = v12 + } // end let + return v6 + }) + v6 := lang.Apply(lang.NewLazySeq, []any{v5}) + return v6 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 lang.FnFunc + v6 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v7 any + { // let + // let binding "s1" + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("seq")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v4}) + var v12 any = v11 + _ = v12 + // let binding "s2" + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("seq")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{v5}) + var v17 any = v16 + _ = v17 + var v18 any + var v19 any + { // let + // let binding "and__0__auto__" + var v20 any = v12 + _ = v20 + var v21 any + if lang.IsTruthy(v20) { + v21 = v17 + } else { + v21 = v20 + } + v19 = v21 + } // end let + if lang.IsTruthy(v19) { + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("cons")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("first")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.Apply(v25, []any{v12}) + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("first")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{v17}) + v31 := lang.Apply(v3, []any{v26, v30}) + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("map")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v36 := v35.FindInternedVar(lang.NewSymbol("rest")) + if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + } + v37 := v36.Get() + v38 := lang.Apply(v37, []any{v12}) + v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v40 := v39.FindInternedVar(lang.NewSymbol("rest")) + if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) + } + v41 := v40.Get() + v42 := lang.Apply(v41, []any{v17}) + v43 := lang.Apply(v34, []any{v3, v38, v42}) + v44 := lang.Apply(v22, []any{v31, v43}) + v18 = v44 + } else { + v18 = nil + } + v7 = v18 + } // end let + return v7 + }) + v7 := lang.Apply(lang.NewLazySeq, []any{v6}) + return v7 + case 4: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + var v7 lang.FnFunc + v7 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v8 any + { // let + // let binding "s1" + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("seq")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.Apply(v11, []any{v4}) + var v13 any = v12 + _ = v13 + // let binding "s2" + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("seq")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{v5}) + var v18 any = v17 + _ = v18 + // let binding "s3" + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("seq")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{v6}) + var v23 any = v22 + _ = v23 + var v24 any + var v25 any + { // let + // let binding "and__0__auto__" + var v26 any = v13 + _ = v26 + var v27 any + if lang.IsTruthy(v26) { + var v28 any + { // let + // let binding "and__0__auto__" + var v29 any = v18 + _ = v29 + var v30 any + if lang.IsTruthy(v29) { + v30 = v23 + } else { + v30 = v29 + } + v28 = v30 + } // end let + v27 = v28 + } else { + v27 = v26 + } + v25 = v27 + } // end let + if lang.IsTruthy(v25) { + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("cons")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("first")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.Apply(v31, []any{v13}) + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("first")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.Apply(v35, []any{v18}) + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("first")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.Apply(v39, []any{v23}) + v41 := lang.Apply(v3, []any{v32, v36, v40}) + v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v43 := v42.FindInternedVar(lang.NewSymbol("map")) + if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) + } + v44 := v43.Get() + v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v46 := v45.FindInternedVar(lang.NewSymbol("rest")) + if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) + } + v47 := v46.Get() + v48 := lang.Apply(v47, []any{v13}) + v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v50 := v49.FindInternedVar(lang.NewSymbol("rest")) + if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) + } + v51 := v50.Get() + v52 := lang.Apply(v51, []any{v18}) + v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v54 := v53.FindInternedVar(lang.NewSymbol("rest")) + if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) + } + v55 := v54.Get() + v56 := lang.Apply(v55, []any{v23}) + v57 := lang.Apply(v44, []any{v3, v48, v52, v56}) + v58 := lang.Apply(v28, []any{v41, v57}) + v24 = v58 + } else { + v24 = nil + } + v8 = v24 + } // end let + return v8 + }) + v8 := lang.Apply(lang.NewLazySeq, []any{v7}) + return v8 + default: + if len(args) < 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := lang.NewList(args[4:]...) + var v8 any + { // let + // let binding "step" + var v9 lang.FnFunc + { // function step + v9 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v11 := args[0] + _ = v11 + var v12 lang.FnFunc + v12 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v13 any + { // let + // let binding "ss" + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("map")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("seq")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.Apply(v16, []any{v19, v11}) + var v21 any = v20 + _ = v21 + var v22 any + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("every?")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("identity")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.Apply(v25, []any{v28, v21}) + if lang.IsTruthy(v29) { + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("cons")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("map")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("first")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v35, []any{v38, v21}) + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("map")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v44 := v43.FindInternedVar(lang.NewSymbol("rest")) + if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) + } + v45 := v44.Get() + v46 := lang.Apply(v42, []any{v45, v21}) + v47 := lang.Apply(v10, []any{v46}) + v48 := lang.Apply(v32, []any{v39, v47}) + v22 = v48 + } else { + v22 = nil + } + v13 = v22 + } // end let + return v13 + }) + v13 := lang.Apply(lang.NewLazySeq, []any{v12}) + return v13 + }) + v10 := v9 + _ = v10 + } + v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2761), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(2765), lang.NewKeyword("end-column"), int(68)) + v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v12 any = v11 + _ = v12 + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("map")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + var v16 lang.FnFunc + v16 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v17 := args[0] + _ = v17 + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("apply")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.Apply(v20, []any{v3, v17}) + return v21 + }) + v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2766), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(2766), lang.NewKeyword("end-column"), int(22)) + v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("conj")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{v7, v6, v5, v4}) + v23 := lang.Apply(v12, []any{v22}) + v24 := lang.Apply(v15, []any{v18, v23}) + v8 = v24 + } // end let + return v8 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // map-entry? + { + v0 := lang.NewSymbol("map-entry?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a map entry", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.8", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1473), lang.NewKeyword("end-line"), int(1473))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.Apply(v6, []any{lang.MapEntry, v3}) + return v7 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // map-indexed + { + v0 := lang.NewSymbol("map-indexed").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence consisting of the result of applying f to 0\n and the first item of coll, followed by applying f to 1 and the second\n item in coll, etc, until coll is exhausted. Thus function f should\n accept 2 arguments, index and item. Returns a stateful transducer when\n no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7309), lang.NewKeyword("end-line"), int(7309))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + var v4 lang.FnFunc + v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + var v6 any + { // let + // let binding "i" + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("volatile!")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, []any{int64(-1)}) + var v11 any = v10 + _ = v11 + var v12 lang.FnFunc + v12 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + v13 := lang.Apply(v5, nil) + return v13 + case 1: + v13 := args[0] + _ = v13 + v14 := lang.Apply(v5, []any{v13}) + return v14 + case 2: + v13 := args[0] + _ = v13 + v14 := args[1] + _ = v14 + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("inc")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18, ok := lang.FieldOrMethod(v11, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v11, "Deref"))) + } + var v19 any + switch reflect.TypeOf(v18).Kind() { + case reflect.Func: + v19 = lang.Apply(v18, nil) + default: + v19 = v18 + } + v20 := lang.Apply(v17, []any{v19}) + v21, _ := lang.FieldOrMethod(v11, "reset") + if reflect.TypeOf(v21).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) + } + v22 := lang.Apply(v21, []any{v20}) + v23 := lang.Apply(v3, []any{v22, v14}) + v24 := lang.Apply(v5, []any{v13, v23}) + return v24 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7320), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7324), lang.NewKeyword("end-column"), int(48)) + v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v6 = v14 + } // end let + return v6 + }) + v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7318), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7324), lang.NewKeyword("end-column"), int(50)) + v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v6 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + return nil + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // map? + { + v0 := lang.NewSymbol("map?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x implements IPersistentMap", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(167), lang.NewKeyword("end-line"), int(171))).(*lang.Symbol) + var v2 lang.FnFunc + { // function map? + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{lang.IPersistentMap, v4}) + return v8 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(171), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(171), lang.NewKeyword("end-column"), int(97))).(lang.FnFunc) + v3 := v2 + _ = v3 + } + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // mapcat + { + v0 := lang.NewSymbol("mapcat").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Returns the result of applying concat to the result of applying map\n to f and colls. Thus function f should return a collection. Returns\n a transducer when no collections are provided", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2775), lang.NewKeyword("end-line"), int(2775))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("comp")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("map")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, []any{v3}) + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("cat")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v6, []any{v10, v13}) + return v14 + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.NewList(args[1:]...) + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("apply")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("concat")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("apply")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("map")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v13, []any{v16, v3, v4}) + v18 := lang.Apply(v7, []any{v10, v17}) + return v18 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // mapv + { + v0 := lang.NewSymbol("mapv").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2"), lang.NewSymbol("c3")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2"), lang.NewSymbol("c3"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Returns a vector consisting of the result of applying f to the\n set of first items of each coll, followed by applying f to the set\n of second items in each coll, until any one of the colls is\n exhausted. Any remaining items in other colls are ignored. Function\n f should accept number-of-colls arguments.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6943), lang.NewKeyword("end-line"), int(6943))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("persistent!")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("reduce")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + var v11 lang.FnFunc + v11 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v12 := args[0] + _ = v12 + v13 := args[1] + _ = v13 + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("conj!")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v3, []any{v13}) + v18 := lang.Apply(v16, []any{v12, v17}) + return v18 + }) + v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6952), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(6952), lang.NewKeyword("end-column"), int(43)) + v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("transient")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.NewVector() + v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6952), lang.NewKeyword("column"), int(56), lang.NewKeyword("end-line"), int(6952), lang.NewKeyword("end-column"), int(57)) + v19, err := lang.WithMeta(v17, v18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v20 := lang.Apply(v16, []any{v19}) + v21 := lang.Apply(v10, []any{v13, v20, v4}) + v22 := lang.Apply(v7, []any{v21}) + return v22 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("into")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.NewVector() + v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6955), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(6955), lang.NewKeyword("end-column"), int(13)) + v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("map")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.Apply(v14, []any{v3, v4, v5}) + v16 := lang.Apply(v8, []any{v11, v15}) + return v16 + case 4: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("into")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.NewVector() + v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6957), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(6957), lang.NewKeyword("end-column"), int(13)) + v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("map")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{v3, v4, v5, v6}) + v17 := lang.Apply(v9, []any{v12, v16}) + return v17 + default: + if len(args) < 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := lang.NewList(args[4:]...) + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("into")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.NewVector() + v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6959), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(6959), lang.NewKeyword("end-column"), int(13)) + v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("apply")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("map")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.Apply(v16, []any{v19, v3, v4, v5, v6, v7}) + v21 := lang.Apply(v10, []any{v13, v20}) + return v21 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // max + { + var v1 lang.FnFunc + v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var v3 any + { // let + // let binding "op" + var v4 any + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + if lang.IsTruthy(v7) { + v4 = closed14 + } else { + v4 = closed14 + } + var v8 any = v4 + _ = v8 + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("seq")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("concat")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("list")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("list")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("list")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("seq")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("concat")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("list")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{v8}) + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("list")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v38, []any{v2}) + v40 := lang.Apply(v31, []any{v35, v39}) + v41 := lang.Apply(v28, []any{v40}) + v42 := lang.Apply(v25, []any{v41}) + v43 := lang.Apply(v14, []any{v18, v22, v42}) + v44 := lang.Apply(v11, []any{v43}) + v3 = v44 + } // end let + return v3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any + { // let + // let binding "op" + var v5 any + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + if lang.IsTruthy(v8) { + v5 = closed14 + } else { + v5 = closed14 + } + var v9 any = v5 + _ = v9 + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("seq")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("concat")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("list")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("list")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("list")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("seq")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("concat")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("list")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.Apply(v35, []any{v9}) + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("list")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.Apply(v39, []any{v2}) + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("list")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.Apply(v43, []any{v3}) + v45 := lang.Apply(v32, []any{v36, v40, v44}) + v46 := lang.Apply(v29, []any{v45}) + v47 := lang.Apply(v26, []any{v46}) + v48 := lang.Apply(v15, []any{v19, v23, v47}) + v49 := lang.Apply(v12, []any{v48}) + v4 = v49 + } // end let + return v4 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := lang.NewList(args[2:]...) + var v5 any + { // let + // let binding "op" + var v6 any + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + if lang.IsTruthy(v9) { + v6 = closed14 + } else { + v6 = closed14 + } + var v10 any = v6 + _ = v10 + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + var v14 lang.FnFunc + v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v15 := args[0] + _ = v15 + v16 := args[1] + _ = v16 + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("seq")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("concat")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("list")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("seq")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("concat")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("list")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.Apply(v42, []any{v10}) + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("list")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.Apply(v46, []any{v15}) + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("list")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v16}) + v52 := lang.Apply(v39, []any{v43, v47, v51}) + v53 := lang.Apply(v36, []any{v52}) + v54 := lang.Apply(v33, []any{v53}) + v55 := lang.Apply(v22, []any{v26, v30, v54}) + v56 := lang.Apply(v19, []any{v55}) + return v56 + }) + v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("seq")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("concat")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("list")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("seq")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("concat")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("list")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.Apply(v42, []any{v10}) + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("list")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.Apply(v46, []any{v2}) + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("list")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v3}) + v52 := lang.Apply(v39, []any{v43, v47, v51}) + v53 := lang.Apply(v36, []any{v52}) + v54 := lang.Apply(v33, []any{v53}) + v55 := lang.Apply(v22, []any{v26, v30, v54}) + v56 := lang.Apply(v19, []any{v55}) + v57 := lang.Apply(v13, []any{v16, v56, v4}) + v5 = v57 + } // end let + return v5 + } + }) + v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + v5 := lang.Apply(v4, []any{nil, int64(1)}) + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v0 := lang.NewSymbol("max").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the greatest of the nums.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1108), lang.NewKeyword("end-line"), int(1108))).(*lang.Symbol) + var v4 lang.FnFunc + v4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v5 := args[0] + _ = v5 + return v5 + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7, _ := lang.FieldOrMethod(lang.Numbers, "Max") + if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Max is not a function"))) + } + v8 := lang.Apply(v7, []any{v5, v6}) + return v8 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := lang.NewList(args[2:]...) + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("max")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("max")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{v5, v6}) + v18 := lang.Apply(v10, []any{v13, v17, v7}) + return v18 + } + }) + v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v3 := ns.InternWithValue(v0, v4, true) + if v0.Meta() != nil { + v3.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // max-key + { + v0 := lang.NewSymbol("max-key").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Returns the x for which (k x), a number, is greatest.\n\n If there are multiple such xs, the last one is returned.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5013), lang.NewKeyword("end-line"), int(5013))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + return v4 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol(">")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v3, []any{v4}) + v11 := lang.Apply(v3, []any{v5}) + v12 := lang.Apply(v9, []any{v10, v11}) + if lang.IsTruthy(v12) { + v6 = v4 + } else { + v6 = v5 + } + return v6 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + var v7 any + { // let + // let binding "kx" + v8 := lang.Apply(v3, []any{v4}) + var v9 any = v8 + _ = v9 + // let binding "ky" + v10 := lang.Apply(v3, []any{v5}) + var v11 any = v10 + _ = v11 + // let binding "vec__55" + var v12 any + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol(">")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{v9, v11}) + if lang.IsTruthy(v16) { + v17 := lang.NewVector(v4, v9) + v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5023), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(5023), lang.NewKeyword("end-column"), int(36)) + v19, err := lang.WithMeta(v17, v18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v12 = v19 + } else { + v20 := lang.NewVector(v5, v11) + v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5023), lang.NewKeyword("column"), int(38), lang.NewKeyword("end-line"), int(5023), lang.NewKeyword("end-column"), int(43)) + v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v12 = v22 + } + var v23 any = v12 + _ = v23 + // let binding "v" + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("nth")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.Apply(v26, []any{v23, int64(0), nil}) + var v28 any = v27 + _ = v28 + // let binding "kv" + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("nth")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.Apply(v31, []any{v23, int64(1), nil}) + var v33 any = v32 + _ = v33 + var v34 any + { // let + // let binding "v" + var v35 any = v28 + _ = v35 + // let binding "kv" + var v36 any = v33 + _ = v36 + // let binding "more" + var v37 any = v6 + _ = v37 + for { + var v38 any + if lang.IsTruthy(v37) { + var v39 any + { // let + // let binding "w" + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("first")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.Apply(v42, []any{v37}) + var v44 any = v43 + _ = v44 + // let binding "kw" + v45 := lang.Apply(v3, []any{v44}) + var v46 any = v45 + _ = v46 + var v47 any + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol(">=")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v46, v36}) + if lang.IsTruthy(v51) { + var v52 any = v44 + var v53 any = v46 + v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v56 := v55.FindInternedVar(lang.NewSymbol("next")) + if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) + } + v57 := v56.Get() + v58 := lang.Apply(v57, []any{v37}) + var v54 any = v58 + v35 = v52 + v36 = v53 + v37 = v54 + continue + } else { + var v59 any = v35 + var v60 any = v36 + v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v63 := v62.FindInternedVar(lang.NewSymbol("next")) + if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) + } + v64 := v63.Get() + v65 := lang.Apply(v64, []any{v37}) + var v61 any = v65 + v35 = v59 + v36 = v60 + v37 = v61 + continue + } + v39 = v47 + } // end let + v38 = v39 + } else { + v38 = v35 + } + v34 = v38 + break + } + } // end let + v7 = v34 + } // end let + return v7 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // max-mask-bits + { + v0 := lang.NewSymbol("max-mask-bits").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6601), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(6601), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + v1 := ns.InternWithValue(v0, int64(13), true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // max-switch-table-size + { + v0 := lang.NewSymbol("max-switch-table-size").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6602), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(6602), lang.NewKeyword("end-column"), int(36), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + v1 := ns.InternWithValue(v0, int64(8192), true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // maybe-destructured + { + v0 := lang.NewSymbol("maybe-destructured").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4514), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(4515), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("params"), lang.NewSymbol("body"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("every?")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("symbol?")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.Apply(v8, []any{v11, v3}) + if lang.IsTruthy(v12) { + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("cons")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{v3, v4}) + v5 = v16 + } else { + var v17 any + { // let + // let binding "params" + var v18 any = v3 + _ = v18 + // let binding "new-params" + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("with-meta")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.NewVector() + v23 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4520), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(4520), lang.NewKeyword("end-column"), int(35)) + v24, err := lang.WithMeta(v22, v23.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("meta")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.Apply(v27, []any{v18}) + v29 := lang.Apply(v21, []any{v24, v28}) + var v30 any = v29 + _ = v30 + // let binding "lets" + v31 := lang.NewVector() + v32 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4521), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(4521), lang.NewKeyword("end-column"), int(18)) + v33, err := lang.WithMeta(v31, v32.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v34 any = v33 + _ = v34 + for { + var v35 any + if lang.IsTruthy(v18) { + var v36 any + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("symbol?")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("first")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.Apply(v42, []any{v18}) + v44 := lang.Apply(v39, []any{v43}) + if lang.IsTruthy(v44) { + v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v47 := v46.FindInternedVar(lang.NewSymbol("next")) + if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) + } + v48 := v47.Get() + v49 := lang.Apply(v48, []any{v18}) + var v45 any = v49 + v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v52 := v51.FindInternedVar(lang.NewSymbol("conj")) + if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) + } + v53 := v52.Get() + v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v55 := v54.FindInternedVar(lang.NewSymbol("first")) + if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) + } + v56 := v55.Get() + v57 := lang.Apply(v56, []any{v18}) + v58 := lang.Apply(v53, []any{v30, v57}) + var v50 any = v58 + var v59 any = v34 + v18 = v45 + v30 = v50 + v34 = v59 + continue + } else { + var v60 any + { // let + // let binding "gparam" + v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v62 := v61.FindInternedVar(lang.NewSymbol("gensym")) + if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) + } + v63 := v62.Get() + v64 := lang.Apply(v63, []any{"p__"}) + var v65 any = v64 + _ = v65 + v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v68 := v67.FindInternedVar(lang.NewSymbol("next")) + if v68.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) + } + v69 := v68.Get() + v70 := lang.Apply(v69, []any{v18}) + var v66 any = v70 + v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v73 := v72.FindInternedVar(lang.NewSymbol("conj")) + if v73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) + } + v74 := v73.Get() + v75 := lang.Apply(v74, []any{v30, v65}) + var v71 any = v75 + v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v78 := v77.FindInternedVar(lang.NewSymbol("conj")) + if v78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) + } + v79 := v78.Get() + v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v81 := v80.FindInternedVar(lang.NewSymbol("conj")) + if v81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) + } + v82 := v81.Get() + v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v84 := v83.FindInternedVar(lang.NewSymbol("first")) + if v84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) + } + v85 := v84.Get() + v86 := lang.Apply(v85, []any{v18}) + v87 := lang.Apply(v82, []any{v34, v86}) + v88 := lang.Apply(v79, []any{v87, v65}) + var v76 any = v88 + v18 = v66 + v30 = v71 + v34 = v76 + continue + } // end let + v36 = v60 + } + v35 = v36 + } else { + v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v62 := v61.FindInternedVar(lang.NewSymbol("seq")) + if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) + } + v63 := v62.Get() + v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v65 := v64.FindInternedVar(lang.NewSymbol("concat")) + if v65.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) + } + v66 := v65.Get() + v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v68 := v67.FindInternedVar(lang.NewSymbol("list")) + if v68.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) + } + v69 := v68.Get() + v70 := lang.Apply(v69, []any{v30}) + v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v72 := v71.FindInternedVar(lang.NewSymbol("list")) + if v72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) + } + v73 := v72.Get() + v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v75 := v74.FindInternedVar(lang.NewSymbol("seq")) + if v75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) + } + v76 := v75.Get() + v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v78 := v77.FindInternedVar(lang.NewSymbol("concat")) + if v78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) + } + v79 := v78.Get() + v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v81 := v80.FindInternedVar(lang.NewSymbol("list")) + if v81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) + } + v82 := v81.Get() + v83 := lang.Apply(v82, []any{lang.NewSymbol("glojure.core/let")}) + v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v85 := v84.FindInternedVar(lang.NewSymbol("list")) + if v85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) + } + v86 := v85.Get() + v87 := lang.Apply(v86, []any{v34}) + v88 := lang.Apply(v79, []any{v83, v87, v4}) + v89 := lang.Apply(v76, []any{v88}) + v90 := lang.Apply(v73, []any{v89}) + v91 := lang.Apply(v66, []any{v70, v90}) + v92 := lang.Apply(v63, []any{v91}) + v35 = v92 + } + v17 = v35 + break + } + } // end let + v5 = v17 + } + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // maybe-min-hash + { + v0 := lang.NewSymbol("maybe-min-hash").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("hashes"))), lang.NewKeyword("doc"), "takes a collection of hashes and returns [shift mask] or nil if none found", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6604), lang.NewKeyword("end-line"), int(6604), lang.NewKeyword("private"), true)).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("first")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("filter")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + var v10 lang.FnFunc + v10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v11 := args[0] + _ = v11 + var v12 any + { // let + // let binding "vec__151" + var v13 any = v11 + _ = v13 + // let binding "s" + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("nth")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{v13, int64(0), nil}) + var v18 any = v17 + _ = v18 + // let binding "m" + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("nth")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{v13, int64(1), nil}) + var v23 any = v22 + _ = v23 + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("apply")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("distinct?")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("map")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + var v33 lang.FnFunc + v33 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v34 := args[0] + _ = v34 + v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v36 := v35.FindInternedVar(lang.NewSymbol("shift-mask")) + if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + } + v37 := v36.Get() + v38 := lang.Apply(v37, []any{v18, v23, v34}) + return v38 + }) + v34 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6609), lang.NewKeyword("column"), int(37), lang.NewKeyword("end-line"), int(6609), lang.NewKeyword("end-column"), int(55)) + v35, err := lang.WithMeta(v33, v34.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v36 := lang.Apply(v32, []any{v35, v3}) + v37 := lang.Apply(v26, []any{v29, v36}) + v12 = v37 + } // end let + return v12 + }) + v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6608), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(6609), lang.NewKeyword("end-column"), int(65)) + v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v13 any + { // let + // let binding "iter__0__auto__" + var v14 lang.FnFunc + { // function iter__154 + v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v16 := args[0] + _ = v16 + var v17 lang.FnFunc + v17 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v18 any + { // let + // let binding "s__155" + var v19 any = v16 + _ = v19 + for { + var v20 any + { // let + // let binding "temp__0__auto__" + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("seq")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.Apply(v23, []any{v19}) + var v25 any = v24 + _ = v25 + var v26 any + if lang.IsTruthy(v25) { + var v27 any + { // let + // let binding "xs__0__auto__" + var v28 any = v25 + _ = v28 + var v29 any + { // let + // let binding "mask" + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("first")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.Apply(v32, []any{v28}) + var v34 any = v33 + _ = v34 + var v35 any + { // let + // let binding "iterys__0__auto__" + var v36 lang.FnFunc + { // function iter__156 + v36 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v38 := args[0] + _ = v38 + var v39 lang.FnFunc + v39 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v40 any + { // let + // let binding "s__157" + var v41 any = v38 + _ = v41 + for { + var v42 any + { // let + // let binding "temp__0__auto__" + v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v44 := v43.FindInternedVar(lang.NewSymbol("seq")) + if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) + } + v45 := v44.Get() + v46 := lang.Apply(v45, []any{v41}) + var v47 any = v46 + _ = v47 + var v48 any + if lang.IsTruthy(v47) { + var v49 any + { // let + // let binding "s__157" + var v50 any = v47 + _ = v50 + var v51 any + v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v53 := v52.FindInternedVar(lang.NewSymbol("chunked-seq?")) + if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) + } + v54 := v53.Get() + v55 := lang.Apply(v54, []any{v50}) + if lang.IsTruthy(v55) { + var v56 any + { // let + // let binding "c__0__auto__" + v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v58 := v57.FindInternedVar(lang.NewSymbol("chunk-first")) + if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) + } + v59 := v58.Get() + v60 := lang.Apply(v59, []any{v50}) + var v61 any = v60 + _ = v61 + // let binding "size__1__auto__" + v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v63 := v62.FindInternedVar(lang.NewSymbol("int")) + if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) + } + v64 := v63.Get() + v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v66 := v65.FindInternedVar(lang.NewSymbol("count")) + if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) + } + v67 := v66.Get() + v68 := lang.Apply(v67, []any{v61}) + v69 := lang.Apply(v64, []any{v68}) + var v70 any = v69 + _ = v70 + // let binding "b__159" + v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v72 := v71.FindInternedVar(lang.NewSymbol("chunk-buffer")) + if v72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) + } + v73 := v72.Get() + v74 := lang.Apply(v73, []any{v70}) + var v75 any = v74 + _ = v75 + var v76 any + var v77 any + { // let + // let binding "i__158" + v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v79 := v78.FindInternedVar(lang.NewSymbol("int")) + if v79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) + } + v80 := v79.Get() + v81 := lang.Apply(v80, []any{int64(0)}) + var v82 any = v81 + _ = v82 + for { + var v83 any + v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v85 := v84.FindInternedVar(lang.NewSymbol("<")) + if v85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) + } + v86 := v85.Get() + v87 := lang.Apply(v86, []any{v82, v70}) + if lang.IsTruthy(v87) { + var v88 any + { // let + // let binding "shift" + v89, _ := lang.FieldOrMethod(v61, "nth") + if reflect.TypeOf(v89).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + v90 := lang.Apply(v89, []any{v82}) + var v91 any = v90 + _ = v91 + v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v93 := v92.FindInternedVar(lang.NewSymbol("chunk-append")) + if v93.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) + } + v94 := v93.Get() + v95 := lang.NewVector(v91, v34) + v96 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6612), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(6612), lang.NewKeyword("end-column"), int(26)) + v97, err := lang.WithMeta(v95, v96.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v98 := lang.Apply(v94, []any{v75, v97}) + _ = v98 + v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v101 := v100.FindInternedVar(lang.NewSymbol("unchecked-inc")) + if v101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) + } + v102 := v101.Get() + v103 := lang.Apply(v102, []any{v82}) + var v99 any = v103 + v82 = v99 + continue + } // end let + v83 = v88 + } else { + v83 = true + } + v77 = v83 + break + } + } // end let + if lang.IsTruthy(v77) { + v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v79 := v78.FindInternedVar(lang.NewSymbol("chunk-cons")) + if v79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) + } + v80 := v79.Get() + v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v82 := v81.FindInternedVar(lang.NewSymbol("chunk")) + if v82.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) + } + v83 := v82.Get() + v84 := lang.Apply(v83, []any{v75}) + v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v86 := v85.FindInternedVar(lang.NewSymbol("chunk-rest")) + if v86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) + } + v87 := v86.Get() + v88 := lang.Apply(v87, []any{v50}) + v89 := lang.Apply(v37, []any{v88}) + v90 := lang.Apply(v80, []any{v84, v89}) + v76 = v90 + } else { + v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v92 := v91.FindInternedVar(lang.NewSymbol("chunk-cons")) + if v92.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) + } + v93 := v92.Get() + v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v95 := v94.FindInternedVar(lang.NewSymbol("chunk")) + if v95.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) + } + v96 := v95.Get() + v97 := lang.Apply(v96, []any{v75}) + v98 := lang.Apply(v93, []any{v97, nil}) + v76 = v98 + } + v56 = v76 + } // end let + v51 = v56 + } else { + var v57 any + { // let + // let binding "shift" + v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v59 := v58.FindInternedVar(lang.NewSymbol("first")) + if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) + } + v60 := v59.Get() + v61 := lang.Apply(v60, []any{v50}) + var v62 any = v61 + _ = v62 + v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v64 := v63.FindInternedVar(lang.NewSymbol("cons")) + if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) + } + v65 := v64.Get() + v66 := lang.NewVector(v62, v34) + v67 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6612), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(6612), lang.NewKeyword("end-column"), int(26)) + v68, err := lang.WithMeta(v66, v67.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v70 := v69.FindInternedVar(lang.NewSymbol("rest")) + if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) + } + v71 := v70.Get() + v72 := lang.Apply(v71, []any{v50}) + v73 := lang.Apply(v37, []any{v72}) + v74 := lang.Apply(v65, []any{v68, v73}) + v57 = v74 + } // end let + v51 = v57 + } + v49 = v51 + } // end let + v48 = v49 + } else { + v48 = nil + } + v42 = v48 + } // end let + v40 = v42 + break + } + } // end let + return v40 + }) + v40 := lang.Apply(lang.NewLazySeq, []any{v39}) + return v40 + }) + v37 := v36 + _ = v37 + } + var v37 any = v36 + _ = v37 + // let binding "fs__1__auto__" + v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v39 := v38.FindInternedVar(lang.NewSymbol("seq")) + if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + } + v40 := v39.Get() + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("range")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.Apply(v43, []any{int64(0), int64(31)}) + v45 := lang.Apply(v37, []any{v44}) + v46 := lang.Apply(v40, []any{v45}) + var v47 any = v46 + _ = v47 + var v48 any + if lang.IsTruthy(v47) { + v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v50 := v49.FindInternedVar(lang.NewSymbol("concat")) + if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) + } + v51 := v50.Get() + v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v53 := v52.FindInternedVar(lang.NewSymbol("rest")) + if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) + } + v54 := v53.Get() + v55 := lang.Apply(v54, []any{v19}) + v56 := lang.Apply(v15, []any{v55}) + v57 := lang.Apply(v51, []any{v47, v56}) + v48 = v57 + } else { + v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v60 := v59.FindInternedVar(lang.NewSymbol("rest")) + if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) + } + v61 := v60.Get() + v62 := lang.Apply(v61, []any{v19}) + var v58 any = v62 + v19 = v58 + continue + } + v35 = v48 + } // end let + v29 = v35 + } // end let + v27 = v29 + } // end let + v26 = v27 + } else { + v26 = nil + } + v20 = v26 + } // end let + v18 = v20 + break + } + } // end let + return v18 + }) + v18 := lang.Apply(lang.NewLazySeq, []any{v17}) + return v18 + }) + v15 := v14 + _ = v15 + } + var v15 any = v14 + _ = v15 + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("map")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + var v19 lang.FnFunc + v19 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v20 := args[0] + _ = v20 + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("dec")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("bit-shift-left")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.Apply(v26, []any{int64(1), v20}) + v28 := lang.Apply(v23, []any{v27}) + return v28 + }) + v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6610), lang.NewKeyword("column"), int(29), lang.NewKeyword("end-line"), int(6610), lang.NewKeyword("end-column"), int(55)) + v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("range")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("inc")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("max-mask-bits")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.Apply(v27, []any{v30}) + v32 := lang.Apply(v24, []any{int64(1), v31}) + v33 := lang.Apply(v18, []any{v21, v32}) + v34 := lang.Apply(v15, []any{v33}) + v13 = v34 + } // end let + v14 := lang.Apply(v9, []any{v12, v13}) + v15 := lang.Apply(v6, []any{v14}) + return v15 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // memfn + { + v0 := lang.NewSymbol("memfn").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Expands into code that creates a fn that expects to be passed an\n object and any args and calls the named instance method on the\n object passing the args. Use when you want to treat a Java method as\n a first-class fn. name may be type-hinted with the method receiver's\n type in order to avoid reflective calls.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3872), lang.NewKeyword("end-line"), int(3872))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + var v7 any + { // let + // let binding "t" + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("with-meta")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("gensym")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{"target"}) + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("meta")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{v5}) + v19 := lang.Apply(v10, []any{v14, v18}) + var v20 any = v19 + _ = v20 + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("seq")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("concat")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/fn")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("apply")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("vector")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("seq")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v44 := v43.FindInternedVar(lang.NewSymbol("concat")) + if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) + } + v45 := v44.Get() + v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v47 := v46.FindInternedVar(lang.NewSymbol("list")) + if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) + } + v48 := v47.Get() + v49 := lang.Apply(v48, []any{v20}) + v50 := lang.Apply(v45, []any{v49, v6}) + v51 := lang.Apply(v42, []any{v50}) + v52 := lang.Apply(v36, []any{v39, v51}) + v53 := lang.Apply(v33, []any{v52}) + v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v55 := v54.FindInternedVar(lang.NewSymbol("list")) + if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) + } + v56 := v55.Get() + v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v58 := v57.FindInternedVar(lang.NewSymbol("seq")) + if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) + } + v59 := v58.Get() + v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v61 := v60.FindInternedVar(lang.NewSymbol("concat")) + if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) + } + v62 := v61.Get() + v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v64 := v63.FindInternedVar(lang.NewSymbol("list")) + if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) + } + v65 := v64.Get() + v66 := lang.Apply(v65, []any{lang.NewSymbol(".")}) + v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v68 := v67.FindInternedVar(lang.NewSymbol("list")) + if v68.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) + } + v69 := v68.Get() + v70 := lang.Apply(v69, []any{v20}) + v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v72 := v71.FindInternedVar(lang.NewSymbol("list")) + if v72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) + } + v73 := v72.Get() + v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v75 := v74.FindInternedVar(lang.NewSymbol("seq")) + if v75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) + } + v76 := v75.Get() + v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v78 := v77.FindInternedVar(lang.NewSymbol("concat")) + if v78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) + } + v79 := v78.Get() + v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v81 := v80.FindInternedVar(lang.NewSymbol("list")) + if v81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) + } + v82 := v81.Get() + v83 := lang.Apply(v82, []any{v5}) + v84 := lang.Apply(v79, []any{v83, v6}) + v85 := lang.Apply(v76, []any{v84}) + v86 := lang.Apply(v73, []any{v85}) + v87 := lang.Apply(v62, []any{v66, v70, v86}) + v88 := lang.Apply(v59, []any{v87}) + v89 := lang.Apply(v56, []any{v88}) + v90 := lang.Apply(v26, []any{v30, v53, v89}) + v91 := lang.Apply(v23, []any{v90}) + v7 = v91 + } // end let + return v7 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // memoize + { + v0 := lang.NewSymbol("memoize").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Returns a memoized version of a referentially transparent function. The\n memoized version of the function keeps a cache of the mapping from arguments\n to results and, when calls with the same arguments are repeated often, has\n higher performance at the expense of higher memory use.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6337), lang.NewKeyword("end-line"), int(6337))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + { // let + // let binding "mem" + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("atom")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.NewMap() + v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6345), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(6345), lang.NewKeyword("end-column"), int(20)) + v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v11 := lang.Apply(v7, []any{v10}) + var v12 any = v11 + _ = v12 + var v13 lang.FnFunc + v13 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v14 := lang.NewList(args[0:]...) + var v15 any + { // let + // let binding "temp__0__auto__" + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("find")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("deref")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{v12}) + v23 := lang.Apply(v18, []any{v22, v14}) + var v24 any = v23 + _ = v24 + var v25 any + if lang.IsTruthy(v24) { + var v26 any + { // let + // let binding "e" + var v27 any = v24 + _ = v27 + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("val")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.Apply(v30, []any{v27}) + v26 = v31 + } // end let + v25 = v26 + } else { + var v27 any + { // let + // let binding "ret" + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("apply")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.Apply(v30, []any{v3, v14}) + var v32 any = v31 + _ = v32 + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("swap!")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("assoc")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v35, []any{v12, v38, v14, v32}) + _ = v39 + v27 = v32 + } // end let + v25 = v27 + } + v15 = v25 + } // end let + return v15 + } + }) + v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6346), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(6351), lang.NewKeyword("end-column"), int(16)) + v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v4 = v15 + } // end let + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // merge + { + v0 := lang.NewSymbol("merge").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("maps"))), lang.NewKeyword("doc"), "Returns a map that consists of the rest of the maps conj-ed onto\n the first. If a key occurs in more than one map, the mapping from\n the latter (left-to-right) will be the mapping in the result.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3040), lang.NewKeyword("end-line"), int(3040))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := lang.NewList(args[0:]...) + var v4 any + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("some")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("identity")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v7, []any{v10, v3}) + if lang.IsTruthy(v11) { + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("reduce1")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + var v15 lang.FnFunc + v15 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v16 := args[0] + _ = v16 + v17 := args[1] + _ = v17 + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("conj")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + var v21 any + { // let + // let binding "or__0__auto__" + var v22 any = v16 + _ = v22 + var v23 any + if lang.IsTruthy(v22) { + v23 = v22 + } else { + v24 := lang.NewMap() + v25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3048), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(3048), lang.NewKeyword("end-column"), int(29)) + v26, err := lang.WithMeta(v24, v25.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v23 = v26 + } + v21 = v23 + } // end let + v22 := lang.Apply(v20, []any{v21, v17}) + return v22 + }) + v16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3048), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(3048), lang.NewKeyword("end-column"), int(34)) + v17, err := lang.WithMeta(v15, v16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v18 := lang.Apply(v14, []any{v17, v3}) + v4 = v18 + } else { + v4 = nil + } + return v4 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // merge-hash-collisions + { + v0 := lang.NewSymbol("merge-hash-collisions").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr-sym"), lang.NewSymbol("default"), lang.NewSymbol("tests"), lang.NewSymbol("thens"))), lang.NewKeyword("doc"), "Takes a case expression, default expression, and a sequence of test constants\n and a corresponding sequence of then expressions. Returns a tuple of\n [tests thens skip-check-set] where no tests have the same hash. Each set of\n input test constants with the same hash is replaced with a single test\n constant (the case int), and their respective thens are combined into:\n (condp = expr\n test-1 then-1\n ...\n test-n then-n\n default).\n The skip-check is a set of case ints for which post-switch equivalence\n checking must not be done (the cases holding the above condp thens).", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6647), lang.NewKeyword("end-line"), int(6647), lang.NewKeyword("private"), true)).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + var v7 any + { // let + // let binding "buckets" + var v8 any + { // let + // let binding "m" + v9 := lang.NewMap() + v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6661), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(6661), lang.NewKeyword("end-column"), int(27)) + v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v12 any = v11 + _ = v12 + // let binding "ks" + var v13 any = v5 + _ = v13 + // let binding "vs" + var v14 any = v6 + _ = v14 + for { + var v15 any + var v16 any + { // let + // let binding "and__0__auto__" + var v17 any = v13 + _ = v17 + var v18 any + if lang.IsTruthy(v17) { + v18 = v14 + } else { + v18 = v17 + } + v16 = v18 + } // end let + if lang.IsTruthy(v16) { + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("update")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("first")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.Apply(v23, []any{v13}) + v25 := lang.Apply(lang.Hash, []any{v24}) + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("fnil")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("conj")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.NewVector() + v33 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6664), lang.NewKeyword("column"), int(102), lang.NewKeyword("end-line"), int(6664), lang.NewKeyword("end-column"), int(103)) + v34, err := lang.WithMeta(v32, v33.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v35 := lang.Apply(v28, []any{v31, v34}) + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("first")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v38, []any{v13}) + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("first")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.Apply(v42, []any{v14}) + v44 := lang.NewVector(v39, v43) + v45 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6664), lang.NewKeyword("column"), int(106), lang.NewKeyword("end-line"), int(6664), lang.NewKeyword("end-column"), int(128)) + v46, err := lang.WithMeta(v44, v45.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v47 := lang.Apply(v20, []any{v12, v25, v35, v46}) + var v17 any = v47 + v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v50 := v49.FindInternedVar(lang.NewSymbol("next")) + if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) + } + v51 := v50.Get() + v52 := lang.Apply(v51, []any{v13}) + var v48 any = v52 + v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v55 := v54.FindInternedVar(lang.NewSymbol("next")) + if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) + } + v56 := v55.Get() + v57 := lang.Apply(v56, []any{v14}) + var v53 any = v57 + v12 = v17 + v13 = v48 + v14 = v53 + continue + } else { + v15 = v12 + } + v8 = v15 + break + } + } // end let + var v9 any = v8 + _ = v9 + // let binding "assoc-multi" + var v10 lang.FnFunc + v10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + v13 := args[2] + _ = v13 + var v14 any + { // let + // let binding "testexprs" + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("mapcat")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + var v18 lang.FnFunc + v18 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v19 := args[0] + _ = v19 + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("list")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("first")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.Apply(v25, []any{v19}) + v27 := lang.Apply(v22, []any{lang.NewSymbol("quote"), v26}) + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("second")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.Apply(v30, []any{v19}) + v32 := lang.NewVector(v27, v31) + v33 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6668), lang.NewKeyword("column"), int(56), lang.NewKeyword("end-line"), int(6668), lang.NewKeyword("end-column"), int(93)) + v34, err := lang.WithMeta(v32, v33.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v34 + }) + v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6668), lang.NewKeyword("column"), int(47), lang.NewKeyword("end-line"), int(6668), lang.NewKeyword("end-column"), int(94)) + v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v21 := lang.Apply(v17, []any{v20, v13}) + var v22 any = v21 + _ = v22 + // let binding "expr" + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("seq")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("concat")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("list")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.Apply(v31, []any{lang.NewSymbol("glojure.core/condp")}) + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("list")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.Apply(v35, []any{lang.NewSymbol("glojure.core/=")}) + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("list")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.Apply(v39, []any{v3}) + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("list")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.Apply(v43, []any{v4}) + v45 := lang.Apply(v28, []any{v32, v36, v40, v22, v44}) + v46 := lang.Apply(v25, []any{v45}) + var v47 any = v46 + _ = v47 + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("assoc")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v11, v12, v47}) + v14 = v51 + } // end let + return v14 + }) + v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6667), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(6670), lang.NewKeyword("end-column"), int(42)) + v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v13 any = v12 + _ = v13 + // let binding "hmap" + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("reduce1")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + var v17 lang.FnFunc + v17 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v18 := args[0] + _ = v18 + v19 := args[1] + _ = v19 + var v20 any + { // let + // let binding "vec__164" + var v21 any = v19 + _ = v21 + // let binding "h" + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("nth")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v21, int64(0), nil}) + var v26 any = v25 + _ = v26 + // let binding "bucket" + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("nth")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{v21, int64(1), nil}) + var v31 any = v30 + _ = v31 + var v32 any + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("==")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("count")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v38, []any{v31}) + v40 := lang.Apply(v35, []any{int64(1), v39}) + if lang.IsTruthy(v40) { + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("assoc")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("ffirst")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.Apply(v46, []any{v31}) + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("second")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v52 := v51.FindInternedVar(lang.NewSymbol("first")) + if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) + } + v53 := v52.Get() + v54 := lang.Apply(v53, []any{v31}) + v55 := lang.Apply(v50, []any{v54}) + v56 := lang.Apply(v43, []any{v18, v47, v55}) + v32 = v56 + } else { + v57 := lang.Apply(v13, []any{v18, v26, v31}) + v32 = v57 + } + v20 = v32 + } // end let + return v20 + }) + v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6672), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(6675), lang.NewKeyword("end-column"), int(45)) + v19, err := lang.WithMeta(v17, v18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v20 := lang.NewMap() + v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6676), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(6676), lang.NewKeyword("end-column"), int(17)) + v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v23 := lang.Apply(v16, []any{v19, v22, v9}) + var v24 any = v23 + _ = v24 + // let binding "skip-check" + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("into1")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.CreatePersistentTreeSet() + v29 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6680), lang.NewKeyword("column"), int(29), lang.NewKeyword("end-line"), int(6680), lang.NewKeyword("end-column"), int(31)) + v30, err := lang.WithMeta(v28, v29.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("map")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("first")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("filter")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + var v40 lang.FnFunc + v40 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v41 := args[0] + _ = v41 + v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v43 := v42.FindInternedVar(lang.NewSymbol("<")) + if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) + } + v44 := v43.Get() + v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v46 := v45.FindInternedVar(lang.NewSymbol("count")) + if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) + } + v47 := v46.Get() + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("second")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v41}) + v52 := lang.Apply(v47, []any{v51}) + v53 := lang.Apply(v44, []any{int64(1), v52}) + return v53 + }) + v41 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6678), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(6678), lang.NewKeyword("end-column"), int(54)) + v42, err := lang.WithMeta(v40, v41.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v43 := lang.Apply(v39, []any{v42, v9}) + v44 := lang.Apply(v33, []any{v36, v43}) + v45 := lang.Apply(v27, []any{v30, v44}) + var v46 any = v45 + _ = v46 + v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v48 := v47.FindInternedVar(lang.NewSymbol("keys")) + if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) + } + v49 := v48.Get() + v50 := lang.Apply(v49, []any{v24}) + v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v52 := v51.FindInternedVar(lang.NewSymbol("vals")) + if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) + } + v53 := v52.Get() + v54 := lang.Apply(v53, []any{v24}) + v55 := lang.NewVector(v50, v54, v46) + v56 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6681), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(6681), lang.NewKeyword("end-column"), int(40)) + v57, err := lang.WithMeta(v55, v56.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v7 = v57 + } // end let + return v7 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // merge-with + { + v0 := lang.NewSymbol("merge-with").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("maps"))), lang.NewKeyword("doc"), "Returns a map that consists of the rest of the maps conj-ed onto\n the first. If a key occurs in more than one map, the mapping(s)\n from the latter (left-to-right) will be combined with the mapping in\n the result by calling (f val-in-result val-in-latter).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3050), lang.NewKeyword("end-line"), int(3050))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.NewList(args[1:]...) + var v5 any + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("some")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("identity")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.Apply(v8, []any{v11, v4}) + if lang.IsTruthy(v12) { + var v13 any + { // let + // let binding "merge-entry" + var v14 lang.FnFunc + v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v15 := args[0] + _ = v15 + v16 := args[1] + _ = v16 + var v17 any + { // let + // let binding "k" + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("key")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.Apply(v20, []any{v16}) + var v22 any = v21 + _ = v22 + // let binding "v" + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("val")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.Apply(v25, []any{v16}) + var v27 any = v26 + _ = v27 + var v28 any + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("contains?")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.Apply(v31, []any{v15, v22}) + if lang.IsTruthy(v32) { + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("assoc")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("get")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v38, []any{v15, v22}) + v40 := lang.Apply(v3, []any{v39, v27}) + v41 := lang.Apply(v35, []any{v15, v22, v40}) + v28 = v41 + } else { + v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v43 := v42.FindInternedVar(lang.NewSymbol("assoc")) + if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) + } + v44 := v43.Get() + v45 := lang.Apply(v44, []any{v15, v22, v27}) + v28 = v45 + } + v17 = v28 + } // end let + return v17 + }) + v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3059), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(3063), lang.NewKeyword("end-column"), int(23)) + v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v17 any = v16 + _ = v17 + // let binding "merge2" + var v18 lang.FnFunc + v18 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v19 := args[0] + _ = v19 + v20 := args[1] + _ = v20 + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("reduce1")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + var v24 any + { // let + // let binding "or__0__auto__" + var v25 any = v19 + _ = v25 + var v26 any + if lang.IsTruthy(v25) { + v26 = v25 + } else { + v27 := lang.NewMap() + v28 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3065), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(3065), lang.NewKeyword("end-column"), int(35)) + v29, err := lang.WithMeta(v27, v28.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v26 = v29 + } + v24 = v26 + } // end let + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("seq")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.Apply(v27, []any{v20}) + v29 := lang.Apply(v23, []any{v17, v24, v28}) + return v29 + }) + v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3064), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(3065), lang.NewKeyword("end-column"), int(47)) + v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v21 any = v20 + _ = v21 + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("reduce1")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v21, v4}) + v13 = v25 + } // end let + v5 = v13 + } else { + v5 = nil + } + return v5 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // meta + { + v0 := lang.NewSymbol("meta").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("obj"))), lang.NewKeyword("doc"), "Returns the metadata of obj, returns nil if there is no metadata.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(202), lang.NewKeyword("end-line"), int(206))).(*lang.Symbol) + var v2 lang.FnFunc + { // function meta + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + var v5 any + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{lang.IMeta, v4}) + if lang.IsTruthy(v9) { + v10, ok := lang.FieldOrMethod(v4, "Meta") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "Meta"))) + } + var v11 any + switch reflect.TypeOf(v10).Kind() { + case reflect.Func: + v11 = lang.Apply(v10, nil) + default: + v11 = v10 + } + v5 = v11 + } else { + v5 = nil + } + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(206), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(208), lang.NewKeyword("end-column"), int(21))).(lang.FnFunc) + v3 := v2 + _ = v3 + } + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // methods + { + v0 := lang.NewSymbol("methods").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"))), lang.NewKeyword("doc"), "Given a multimethod, returns a map of dispatch values -> dispatch fns", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1809), lang.NewKeyword("end-line"), int(1809))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4, ok := lang.FieldOrMethod(v3, "getMethodTable") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getMethodTable"))) + } + var v5 any + switch reflect.TypeOf(v4).Kind() { + case reflect.Func: + v5 = lang.Apply(v4, nil) + default: + v5 = v4 + } + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // min + { + var v1 lang.FnFunc + v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var v3 any + { // let + // let binding "op" + var v4 any + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + if lang.IsTruthy(v7) { + v4 = closed15 + } else { + v4 = closed15 + } + var v8 any = v4 + _ = v8 + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("seq")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("concat")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("list")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("list")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("list")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("seq")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("concat")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("list")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{v8}) + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("list")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v38, []any{v2}) + v40 := lang.Apply(v31, []any{v35, v39}) + v41 := lang.Apply(v28, []any{v40}) + v42 := lang.Apply(v25, []any{v41}) + v43 := lang.Apply(v14, []any{v18, v22, v42}) + v44 := lang.Apply(v11, []any{v43}) + v3 = v44 + } // end let + return v3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any + { // let + // let binding "op" + var v5 any + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + if lang.IsTruthy(v8) { + v5 = closed15 + } else { + v5 = closed15 + } + var v9 any = v5 + _ = v9 + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("seq")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("concat")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("list")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("list")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("list")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("seq")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("concat")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("list")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.Apply(v35, []any{v9}) + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("list")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.Apply(v39, []any{v2}) + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("list")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.Apply(v43, []any{v3}) + v45 := lang.Apply(v32, []any{v36, v40, v44}) + v46 := lang.Apply(v29, []any{v45}) + v47 := lang.Apply(v26, []any{v46}) + v48 := lang.Apply(v15, []any{v19, v23, v47}) + v49 := lang.Apply(v12, []any{v48}) + v4 = v49 + } // end let + return v4 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := lang.NewList(args[2:]...) + var v5 any + { // let + // let binding "op" + var v6 any + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + if lang.IsTruthy(v9) { + v6 = closed15 + } else { + v6 = closed15 + } + var v10 any = v6 + _ = v10 + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + var v14 lang.FnFunc + v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v15 := args[0] + _ = v15 + v16 := args[1] + _ = v16 + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("seq")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("concat")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("list")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("seq")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("concat")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("list")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.Apply(v42, []any{v10}) + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("list")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.Apply(v46, []any{v15}) + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("list")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v16}) + v52 := lang.Apply(v39, []any{v43, v47, v51}) + v53 := lang.Apply(v36, []any{v52}) + v54 := lang.Apply(v33, []any{v53}) + v55 := lang.Apply(v22, []any{v26, v30, v54}) + v56 := lang.Apply(v19, []any{v55}) + return v56 + }) + v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("seq")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("concat")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("list")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("seq")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("concat")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("list")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.Apply(v42, []any{v10}) + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("list")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.Apply(v46, []any{v2}) + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("list")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v3}) + v52 := lang.Apply(v39, []any{v43, v47, v51}) + v53 := lang.Apply(v36, []any{v52}) + v54 := lang.Apply(v33, []any{v53}) + v55 := lang.Apply(v22, []any{v26, v30, v54}) + v56 := lang.Apply(v19, []any{v55}) + v57 := lang.Apply(v13, []any{v16, v56, v4}) + v5 = v57 + } // end let + return v5 + } + }) + v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + v5 := lang.Apply(v4, []any{nil, int64(1)}) + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v0 := lang.NewSymbol("min").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the least of the nums.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1118), lang.NewKeyword("end-line"), int(1118))).(*lang.Symbol) + var v4 lang.FnFunc + v4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v5 := args[0] + _ = v5 + return v5 + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7, _ := lang.FieldOrMethod(lang.Numbers, "Min") + if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Min is not a function"))) + } + v8 := lang.Apply(v7, []any{v5, v6}) + return v8 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := lang.NewList(args[2:]...) + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("min")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("min")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{v5, v6}) + v18 := lang.Apply(v10, []any{v13, v17, v7}) + return v18 + } + }) + v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v3 := ns.InternWithValue(v0, v4, true) + if v0.Meta() != nil { + v3.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // min-key + { + v0 := lang.NewSymbol("min-key").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Returns the x for which (k x), a number, is least.\n\n If there are multiple such xs, the last one is returned.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5033), lang.NewKeyword("end-line"), int(5033))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + return v4 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("<")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v3, []any{v4}) + v11 := lang.Apply(v3, []any{v5}) + v12 := lang.Apply(v9, []any{v10, v11}) + if lang.IsTruthy(v12) { + v6 = v4 + } else { + v6 = v5 + } + return v6 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + var v7 any + { // let + // let binding "kx" + v8 := lang.Apply(v3, []any{v4}) + var v9 any = v8 + _ = v9 + // let binding "ky" + v10 := lang.Apply(v3, []any{v5}) + var v11 any = v10 + _ = v11 + // let binding "vec__58" + var v12 any + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("<")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{v9, v11}) + if lang.IsTruthy(v16) { + v17 := lang.NewVector(v4, v9) + v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5043), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(5043), lang.NewKeyword("end-column"), int(36)) + v19, err := lang.WithMeta(v17, v18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v12 = v19 + } else { + v20 := lang.NewVector(v5, v11) + v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5043), lang.NewKeyword("column"), int(38), lang.NewKeyword("end-line"), int(5043), lang.NewKeyword("end-column"), int(43)) + v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v12 = v22 + } + var v23 any = v12 + _ = v23 + // let binding "v" + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("nth")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.Apply(v26, []any{v23, int64(0), nil}) + var v28 any = v27 + _ = v28 + // let binding "kv" + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("nth")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.Apply(v31, []any{v23, int64(1), nil}) + var v33 any = v32 + _ = v33 + var v34 any + { // let + // let binding "v" + var v35 any = v28 + _ = v35 + // let binding "kv" + var v36 any = v33 + _ = v36 + // let binding "more" + var v37 any = v6 + _ = v37 + for { + var v38 any + if lang.IsTruthy(v37) { + var v39 any + { // let + // let binding "w" + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("first")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.Apply(v42, []any{v37}) + var v44 any = v43 + _ = v44 + // let binding "kw" + v45 := lang.Apply(v3, []any{v44}) + var v46 any = v45 + _ = v46 + var v47 any + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("<=")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v46, v36}) + if lang.IsTruthy(v51) { + var v52 any = v44 + var v53 any = v46 + v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v56 := v55.FindInternedVar(lang.NewSymbol("next")) + if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) + } + v57 := v56.Get() + v58 := lang.Apply(v57, []any{v37}) + var v54 any = v58 + v35 = v52 + v36 = v53 + v37 = v54 + continue + } else { + var v59 any = v35 + var v60 any = v36 + v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v63 := v62.FindInternedVar(lang.NewSymbol("next")) + if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) + } + v64 := v63.Get() + v65 := lang.Apply(v64, []any{v37}) + var v61 any = v65 + v35 = v59 + v36 = v60 + v37 = v61 + continue + } + v39 = v47 + } // end let + v38 = v39 + } else { + v38 = v35 + } + v34 = v38 + break + } + } // end let + v7 = v34 + } // end let + return v7 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // mix-collection-hash + { + v0 := lang.NewSymbol("mix-collection-hash").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("hash-basis"), lang.NewSymbol("count"))), lang.NewKeyword("doc"), "Mix final collection hash for ordered or unordered collections.\n hash-basis is the combined collection hash, count is the number\n of elements included in the basis. Note this is the hash code\n consistent with =, different from .hashCode.\n See http://glojure.org/data_structures#hash for full algorithms.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5199), lang.NewKeyword("end-line"), int(5199))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.Apply(nil, []any{v3, v4}) + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // mk-bound-fn + { + v0 := lang.NewSymbol("mk-bound-fn").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5127), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(5127), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sc"), lang.NewSymbol("test"), lang.NewSymbol("key"))), lang.NewKeyword("private"), true, lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 lang.FnFunc + v6 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v7 := args[0] + _ = v7 + v8, ok := lang.FieldOrMethod(v3, "comparator") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "comparator"))) + } + var v9 any + switch reflect.TypeOf(v8).Kind() { + case reflect.Func: + v9 = lang.Apply(v8, nil) + default: + v9 = v8 + } + v10, _ := lang.FieldOrMethod(v3, "entryKey") + if reflect.TypeOf(v10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("entryKey is not a function"))) + } + v11 := lang.Apply(v10, []any{v7}) + v12, _ := lang.FieldOrMethod(v9, "compare") + if reflect.TypeOf(v12).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("compare is not a function"))) + } + v13 := lang.Apply(v12, []any{v11, v5}) + v14 := lang.Apply(v4, []any{v13, int64(0)}) + return v14 + }) + v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5130), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(5131), lang.NewKeyword("end-column"), int(64)) + v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v8 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // mod + { + v0 := lang.NewSymbol("mod").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"), lang.NewSymbol("div"))), lang.NewKeyword("doc"), "Modulus of num and div. Truncates toward negative infinity.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3567), lang.NewKeyword("end-line"), int(3567))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any + { // let + // let binding "m" + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("rem")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{v3, v4}) + var v10 any = v9 + _ = v10 + var v11 any + var v12 any + { // let + // let binding "or__0__auto__" + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("zero?")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{v10}) + var v17 any = v16 + _ = v17 + var v18 any + if lang.IsTruthy(v17) { + v18 = v17 + } else { + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("=")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("pos?")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v3}) + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("pos?")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.Apply(v28, []any{v4}) + v30 := lang.Apply(v21, []any{v25, v29}) + v18 = v30 + } + v12 = v18 + } // end let + if lang.IsTruthy(v12) { + v11 = v10 + } else { + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("+")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{v10, v4}) + v11 = v16 + } + v5 = v11 + } // end let + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // name + { + v1 := reflect.TypeOf("") + v0 := lang.NewSymbol("name").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns the name String of a string, symbol or keyword.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1585), lang.NewKeyword("end-line"), int(1585))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + var v5 any + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("string?")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{v4}) + if lang.IsTruthy(v9) { + v5 = v4 + } else { + v10, _ := lang.FieldOrMethod(v4, "Name") + if reflect.TypeOf(v10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Name is not a function"))) + } + v11 := lang.Apply(v10, []any{}) + v5 = v11 + } + return v5 + }) + v4 := reflect.TypeOf("") + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // namespace + { + v1 := reflect.TypeOf("") + v0 := lang.NewSymbol("namespace").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns the namespace String of a symbol or keyword, or nil if not present.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1593), lang.NewKeyword("end-line"), int(1593))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5, _ := lang.FieldOrMethod(v4, "Namespace") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Namespace is not a function"))) + } + v6 := lang.Apply(v5, []any{}) + return v6 + }) + v4 := reflect.TypeOf("") + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // nary-inline + { + v0 := lang.NewSymbol("nary-inline").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(948), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(948), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("op")), lang.NewVector(lang.NewSymbol("op"), lang.NewSymbol("unchecked-op"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("nary-inline")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.Apply(v6, []any{v3, v3}) + return v7 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 lang.FnFunc + v5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v6 := args[0] + _ = v6 + var v7 any + { // let + // let binding "op" + var v8 any + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + if lang.IsTruthy(v11) { + v8 = v4 + } else { + v8 = v3 + } + var v12 any = v8 + _ = v12 + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("seq")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("concat")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("list")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{lang.NewSymbol(".")}) + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("list")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.Apply(v25, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("seq")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("concat")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("list")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v38, []any{v12}) + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("list")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.Apply(v42, []any{v6}) + v44 := lang.Apply(v35, []any{v39, v43}) + v45 := lang.Apply(v32, []any{v44}) + v46 := lang.Apply(v29, []any{v45}) + v47 := lang.Apply(v18, []any{v22, v26, v46}) + v48 := lang.Apply(v15, []any{v47}) + v7 = v48 + } // end let + return v7 + case 2: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + var v8 any + { // let + // let binding "op" + var v9 any + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + if lang.IsTruthy(v12) { + v9 = v4 + } else { + v9 = v3 + } + var v13 any = v9 + _ = v13 + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("seq")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("concat")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("list")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.Apply(v22, []any{lang.NewSymbol(".")}) + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("list")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.Apply(v26, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("list")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("seq")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("concat")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("list")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.Apply(v39, []any{v13}) + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("list")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.Apply(v43, []any{v6}) + v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v46 := v45.FindInternedVar(lang.NewSymbol("list")) + if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) + } + v47 := v46.Get() + v48 := lang.Apply(v47, []any{v7}) + v49 := lang.Apply(v36, []any{v40, v44, v48}) + v50 := lang.Apply(v33, []any{v49}) + v51 := lang.Apply(v30, []any{v50}) + v52 := lang.Apply(v19, []any{v23, v27, v51}) + v53 := lang.Apply(v16, []any{v52}) + v8 = v53 + } // end let + return v8 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := lang.NewList(args[2:]...) + var v9 any + { // let + // let binding "op" + var v10 any + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + if lang.IsTruthy(v13) { + v10 = v4 + } else { + v10 = v3 + } + var v14 any = v10 + _ = v14 + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("reduce1")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + var v18 lang.FnFunc + v18 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v19 := args[0] + _ = v19 + v20 := args[1] + _ = v20 + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("seq")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("concat")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol(".")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v36 := v35.FindInternedVar(lang.NewSymbol("list")) + if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + } + v37 := v36.Get() + v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v39 := v38.FindInternedVar(lang.NewSymbol("seq")) + if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + } + v40 := v39.Get() + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("concat")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("list")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.Apply(v46, []any{v14}) + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("list")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v19}) + v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v53 := v52.FindInternedVar(lang.NewSymbol("list")) + if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) + } + v54 := v53.Get() + v55 := lang.Apply(v54, []any{v20}) + v56 := lang.Apply(v43, []any{v47, v51, v55}) + v57 := lang.Apply(v40, []any{v56}) + v58 := lang.Apply(v37, []any{v57}) + v59 := lang.Apply(v26, []any{v30, v34, v58}) + v60 := lang.Apply(v23, []any{v59}) + return v60 + }) + v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("seq")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("concat")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol(".")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v36 := v35.FindInternedVar(lang.NewSymbol("list")) + if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + } + v37 := v36.Get() + v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v39 := v38.FindInternedVar(lang.NewSymbol("seq")) + if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + } + v40 := v39.Get() + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("concat")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("list")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.Apply(v46, []any{v14}) + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("list")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v6}) + v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v53 := v52.FindInternedVar(lang.NewSymbol("list")) + if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) + } + v54 := v53.Get() + v55 := lang.Apply(v54, []any{v7}) + v56 := lang.Apply(v43, []any{v47, v51, v55}) + v57 := lang.Apply(v40, []any{v56}) + v58 := lang.Apply(v37, []any{v57}) + v59 := lang.Apply(v26, []any{v30, v34, v58}) + v60 := lang.Apply(v23, []any{v59}) + v61 := lang.Apply(v17, []any{v20, v60, v8}) + v9 = v61 + } // end let + return v9 + } + }) + v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86)) + v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // nat-int? + { + v0 := lang.NewSymbol("nat-int?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a non-negative fixed precision integer", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1415), lang.NewKeyword("end-line"), int(1415))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + { // let + // let binding "and__0__auto__" + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("int?")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v3}) + var v9 any = v8 + _ = v9 + var v10 any + if lang.IsTruthy(v9) { + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("not")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("neg?")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{v3}) + v18 := lang.Apply(v13, []any{v17}) + v10 = v18 + } else { + v10 = v9 + } + v4 = v10 + } // end let + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // neg-int? + { + v0 := lang.NewSymbol("neg-int?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a negative fixed precision integer", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1409), lang.NewKeyword("end-line"), int(1409))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + { // let + // let binding "and__0__auto__" + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("int?")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v3}) + var v9 any = v8 + _ = v9 + var v10 any + if lang.IsTruthy(v9) { + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("neg?")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{v3}) + v10 = v14 + } else { + v10 = v9 + } + v4 = v10 + } // end let + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // neg? + { + var v1 lang.FnFunc + { // function neg?__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("concat")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("list")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("seq")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("concat")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/IsNeg")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{v3}) + v35 := lang.Apply(v26, []any{v30, v34}) + v36 := lang.Apply(v23, []any{v35}) + v37 := lang.Apply(v20, []any{v36}) + v38 := lang.Apply(v9, []any{v13, v17, v37}) + v39 := lang.Apply(v6, []any{v38}) + return v39 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("neg?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns true if num is less than zero, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1259), lang.NewKeyword("end-line"), int(1259))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5, _ := lang.FieldOrMethod(lang.Numbers, "IsNeg") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("IsNeg is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // newline + { + v0 := lang.NewSymbol("newline").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Writes a platform-specific newline to *out*", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3698), lang.NewKeyword("end-line"), int(3698))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v4 := v3.FindInternedVar(lang.NewSymbol("*out*")) + if v4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) + } + v5 := v4.Get() + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("system-newline")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(lang.AppendWriter, []any{v5, v8}) + _ = v9 + return nil + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // next + { + v1 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() + v0 := lang.NewSymbol("next").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a seq of the items after the first. Calls seq on its\n argument. If there are no more items, returns nil.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(55), lang.NewKeyword("end-line"), int(61))).(*lang.Symbol) + var v3 lang.FnFunc + { // function next + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + v6 := lang.Apply(lang.Next, []any{v5}) + return v6 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(61), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(61), lang.NewKeyword("end-column"), int(77))).(lang.FnFunc) + v4 := v3 + _ = v4 + } + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // nfirst + { + v0 := lang.NewSymbol("nfirst").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Same as (next (first x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(105), lang.NewKeyword("end-line"), int(109))).(*lang.Symbol) + var v2 lang.FnFunc + { // function nfirst + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("next")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("first")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v4}) + v12 := lang.Apply(v7, []any{v11}) + return v12 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(109), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(109), lang.NewKeyword("end-column"), int(49))).(lang.FnFunc) + v3 := v2 + _ = v3 + } + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // nil? + { + v1 := reflect.TypeOf(false) + var v2 lang.FnFunc + { // function nil?__inliner + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("list")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Identical"), v4, nil}) + return v8 + }) + v3 := v2 + _ = v3 + } + v0 := lang.NewSymbol("nil?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v2, lang.NewKeyword("doc"), "Returns true if x is nil, false otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(435), lang.NewKeyword("end-line"), int(435))).(*lang.Symbol) + var v4 lang.FnFunc + v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + v6 := lang.Apply(lang.IsNil, []any{v5}) + return v6 + }) + v5 := reflect.TypeOf(false) + v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v5)).(lang.FnFunc) + v3 := ns.InternWithValue(v0, v4, true) + if v0.Meta() != nil { + v3.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // nnext + { + v0 := lang.NewSymbol("nnext").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Same as (next (next x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(119), lang.NewKeyword("end-line"), int(123))).(*lang.Symbol) + var v2 lang.FnFunc + { // function nnext + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("next")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("next")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v4}) + v12 := lang.Apply(v7, []any{v11}) + return v12 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(123), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(123), lang.NewKeyword("end-column"), int(46))).(lang.FnFunc) + v3 := v2 + _ = v3 + } + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // normalize-slurp-opts + { + v0 := lang.NewSymbol("normalize-slurp-opts").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6974), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(6974), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("opts"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("string?")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("first")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v3}) + v12 := lang.Apply(v7, []any{v11}) + if lang.IsTruthy(v12) { + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("println")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{"WARNING: (slurp f enc) is deprecated, use (slurp f :encoding enc)."}) + _ = v16 + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("first")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.Apply(v19, []any{v3}) + v21 := lang.NewVector(lang.NewKeyword("encoding"), v20) + v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6979), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(6979), lang.NewKeyword("end-column"), int(30)) + v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v4 = v23 + } else { + v4 = v3 + } + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // not + { + v1 := reflect.TypeOf(false) + v0 := lang.NewSymbol("not").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is logical false, false otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(523), lang.NewKeyword("end-line"), int(523))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + var v5 any + if lang.IsTruthy(v4) { + v5 = false + } else { + v5 = true + } + return v5 + }) + v4 := reflect.TypeOf(false) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // not-any? + { + v1 := reflect.TypeOf(false) + v0 := lang.NewSymbol("not-any?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns false if (pred x) is logical true for any x in coll,\n else true.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(2696), lang.NewKeyword("end-line"), int(2701))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + v4 := lang.Apply(closed17, nil) + v5 := lang.Apply(closed16, []any{v4}) + return v5 + case 1: + v4 := args[0] + _ = v4 + v5 := lang.Apply(closed17, []any{v4}) + v6 := lang.Apply(closed16, []any{v5}) + return v6 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := lang.Apply(closed17, []any{v4, v5}) + v7 := lang.Apply(closed16, []any{v6}) + return v7 + case 3: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := args[2] + _ = v6 + v7 := lang.Apply(closed17, []any{v4, v5, v6}) + v8 := lang.Apply(closed16, []any{v7}) + return v8 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := args[2] + _ = v6 + v7 := lang.NewList(args[3:]...) + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("apply")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{closed17, v4, v5, v6, v7}) + v12 := lang.Apply(closed16, []any{v11}) + return v12 + } + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2559), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2564), lang.NewKeyword("end-column"), int(49))).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // not-empty + { + v0 := lang.NewSymbol("not-empty").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "If coll is empty, returns nil, else coll", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5516), lang.NewKeyword("end-line"), int(5516))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("seq")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v3}) + if lang.IsTruthy(v8) { + v4 = v3 + } else { + v4 = nil + } + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // not-every? + { + v1 := reflect.TypeOf(false) + v0 := lang.NewSymbol("not-every?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns false if (pred x) is logical true for every x in\n coll, else true.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(2677), lang.NewKeyword("end-line"), int(2682))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + v4 := lang.Apply(closed18, nil) + v5 := lang.Apply(closed16, []any{v4}) + return v5 + case 1: + v4 := args[0] + _ = v4 + v5 := lang.Apply(closed18, []any{v4}) + v6 := lang.Apply(closed16, []any{v5}) + return v6 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := lang.Apply(closed18, []any{v4, v5}) + v7 := lang.Apply(closed16, []any{v6}) + return v7 + case 3: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := args[2] + _ = v6 + v7 := lang.Apply(closed18, []any{v4, v5, v6}) + v8 := lang.Apply(closed16, []any{v7}) + return v8 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := args[2] + _ = v6 + v7 := lang.NewList(args[3:]...) + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("apply")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{closed18, v4, v5, v6, v7}) + v12 := lang.Apply(closed16, []any{v11}) + return v12 + } + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2559), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2564), lang.NewKeyword("end-column"), int(49))).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // not= + { + v1 := reflect.TypeOf(false) + v0 := lang.NewSymbol("not=").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Same as (not (= obj1 obj2))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(812), lang.NewKeyword("end-line"), int(812))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + return false + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("not")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("=")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.Apply(v11, []any{v4, v5}) + v13 := lang.Apply(v8, []any{v12}) + return v13 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := lang.NewList(args[2:]...) + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("not")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("apply")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("=")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v12, []any{v15, v4, v5, v6}) + v17 := lang.Apply(v9, []any{v16}) + return v17 + } + }) + v4 := reflect.TypeOf(false) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // ns + { + v0 := lang.NewSymbol("ns").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("docstring?"), lang.NewSymbol("attr-map?"), lang.NewSymbol("references*"))), lang.NewKeyword("doc"), "Sets *ns* to the namespace named by name (unevaluated), creating it\n if needed. references can be zero or more of: (:refer-glojure ...)\n (:require ...) (:use ...) (:import ...) (:load ...) (:gen-class)\n with the syntax of refer-glojure/require/use/import/load/gen-class\n respectively, except the arguments are unevaluated and need not be\n quoted. (:gen-class ...), when supplied, defaults to :name\n corresponding to the ns name, :main true, :impl-ns same as ns, and\n :init-impl-ns true. All options of gen-class are\n supported. The :gen-class directive is ignored when not\n compiling. If :gen-class is not supplied, when compiled only an\n nsname__init.class will be generated. If :refer-glojure is not used, a\n default (refer 'glojure.core) is used. Use of ns is preferred to\n individual calls to in-ns/require/use/import:\n\n (ns foo.bar\n (:refer-glojure :exclude [ancestors printf])\n (:require (glojure.contrib sql combinatorics))\n (:use (my.lib this that))\n (:import (java.util Date Timer Random)\n (java.sql Connection Statement)))", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5742), lang.NewKeyword("end-line"), int(5742))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + var v7 any + { // let + // let binding "process-reference" + var v8 lang.FnFunc + v8 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v9 := args[0] + _ = v9 + var v10 any + { // let + // let binding "vec__107" + var v11 any = v9 + _ = v11 + // let binding "seq__108" + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("seq")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.Apply(v14, []any{v11}) + var v16 any = v15 + _ = v16 + // let binding "first__109" + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("first")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.Apply(v19, []any{v16}) + var v21 any = v20 + _ = v21 + // let binding "seq__108" + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("next")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v16}) + var v26 any = v25 + _ = v26 + // let binding "kname" + var v27 any = v21 + _ = v27 + // let binding "args" + var v28 any = v26 + _ = v28 + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("seq")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("concat")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v36 := v35.FindInternedVar(lang.NewSymbol("list")) + if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + } + v37 := v36.Get() + v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v39 := v38.FindInternedVar(lang.NewSymbol("symbol")) + if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + } + v40 := v39.Get() + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("name")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.Apply(v43, []any{v27}) + v45 := lang.Apply(v40, []any{"glojure.core", v44}) + v46 := lang.Apply(v37, []any{v45}) + v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v48 := v47.FindInternedVar(lang.NewSymbol("map")) + if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) + } + v49 := v48.Get() + var v50 lang.FnFunc + v50 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v51 := args[0] + _ = v51 + v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v53 := v52.FindInternedVar(lang.NewSymbol("list")) + if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) + } + v54 := v53.Get() + v55 := lang.Apply(v54, []any{lang.NewSymbol("quote"), v51}) + return v55 + }) + v51 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5769), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(5769), lang.NewKeyword("end-column"), int(36)) + v52, err := lang.WithMeta(v50, v51.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v53 := lang.Apply(v49, []any{v52, v28}) + v54 := lang.Apply(v34, []any{v46, v53}) + v55 := lang.Apply(v31, []any{v54}) + v10 = v55 + } // end let + return v10 + }) + v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5767), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(5769), lang.NewKeyword("end-column"), int(44)) + v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v11 any = v10 + _ = v11 + // let binding "docstring" + var v12 any + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("string?")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("first")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{v6}) + v20 := lang.Apply(v15, []any{v19}) + if lang.IsTruthy(v20) { + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("first")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.Apply(v23, []any{v6}) + v12 = v24 + } else { + v12 = nil + } + var v25 any = v12 + _ = v25 + // let binding "references" + var v26 any + if lang.IsTruthy(v25) { + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("next")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{v6}) + v26 = v30 + } else { + v26 = v6 + } + var v31 any = v26 + _ = v31 + // let binding "name" + var v32 any + if lang.IsTruthy(v25) { + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("vary-meta")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("assoc")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v35, []any{v5, v38, lang.NewKeyword("doc"), v25}) + v32 = v39 + } else { + v32 = v5 + } + var v40 any = v32 + _ = v40 + // let binding "metadata" + var v41 any + v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v43 := v42.FindInternedVar(lang.NewSymbol("map?")) + if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) + } + v44 := v43.Get() + v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v46 := v45.FindInternedVar(lang.NewSymbol("first")) + if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) + } + v47 := v46.Get() + v48 := lang.Apply(v47, []any{v31}) + v49 := lang.Apply(v44, []any{v48}) + if lang.IsTruthy(v49) { + v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v51 := v50.FindInternedVar(lang.NewSymbol("first")) + if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) + } + v52 := v51.Get() + v53 := lang.Apply(v52, []any{v31}) + v41 = v53 + } else { + v41 = nil + } + var v54 any = v41 + _ = v54 + // let binding "references" + var v55 any + if lang.IsTruthy(v54) { + v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v57 := v56.FindInternedVar(lang.NewSymbol("next")) + if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) + } + v58 := v57.Get() + v59 := lang.Apply(v58, []any{v31}) + v55 = v59 + } else { + v55 = v31 + } + var v60 any = v55 + _ = v60 + // let binding "name" + var v61 any + if lang.IsTruthy(v54) { + v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v63 := v62.FindInternedVar(lang.NewSymbol("vary-meta")) + if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) + } + v64 := v63.Get() + v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v66 := v65.FindInternedVar(lang.NewSymbol("merge")) + if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) + } + v67 := v66.Get() + v68 := lang.Apply(v64, []any{v40, v67, v54}) + v61 = v68 + } else { + v61 = v40 + } + var v69 any = v61 + _ = v69 + // let binding "gen-class-clause" + v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v71 := v70.FindInternedVar(lang.NewSymbol("first")) + if v71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) + } + v72 := v71.Get() + v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v74 := v73.FindInternedVar(lang.NewSymbol("filter")) + if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) + } + v75 := v74.Get() + var v76 lang.FnFunc + v76 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v77 := args[0] + _ = v77 + v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v79 := v78.FindInternedVar(lang.NewSymbol("=")) + if v79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) + } + v80 := v79.Get() + v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v82 := v81.FindInternedVar(lang.NewSymbol("first")) + if v82.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) + } + v83 := v82.Get() + v84 := lang.Apply(v83, []any{v77}) + v85 := lang.Apply(v80, []any{lang.NewKeyword("gen-class"), v84}) + return v85 + }) + v77 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5780), lang.NewKeyword("column"), int(41), lang.NewKeyword("end-line"), int(5780), lang.NewKeyword("end-column"), int(65)) + v78, err := lang.WithMeta(v76, v77.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v79 := lang.Apply(v75, []any{v78, v60}) + v80 := lang.Apply(v72, []any{v79}) + var v81 any = v80 + _ = v81 + // let binding "gen-class-call" + var v82 any + if lang.IsTruthy(v81) { + v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v84 := v83.FindInternedVar(lang.NewSymbol("list*")) + if v84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) + } + v85 := v84.Get() + v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v87 := v86.FindInternedVar(lang.NewSymbol("str")) + if v87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) + } + v88 := v87.Get() + v89 := lang.Apply(v88, []any{v69}) + v90, _ := lang.FieldOrMethod(v89, "replace") + if reflect.TypeOf(v90).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("replace is not a function"))) + } + v91 := lang.Apply(v90, []any{lang.NewChar(45), lang.NewChar(95)}) + v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v93 := v92.FindInternedVar(lang.NewSymbol("next")) + if v93.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) + } + v94 := v93.Get() + v95 := lang.Apply(v94, []any{v81}) + v96 := lang.Apply(v85, []any{lang.NewSymbol("glojure.core/gen-class"), lang.NewKeyword("name"), v91, lang.NewKeyword("impl-ns"), v69, lang.NewKeyword("main"), true, v95}) + v82 = v96 + } else { + v82 = nil + } + var v97 any = v82 + _ = v97 + // let binding "references" + v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v99 := v98.FindInternedVar(lang.NewSymbol("remove")) + if v99.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) + } + v100 := v99.Get() + var v101 lang.FnFunc + v101 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v102 := args[0] + _ = v102 + v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v104 := v103.FindInternedVar(lang.NewSymbol("=")) + if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) + } + v105 := v104.Get() + v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v107 := v106.FindInternedVar(lang.NewSymbol("first")) + if v107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) + } + v108 := v107.Get() + v109 := lang.Apply(v108, []any{v102}) + v110 := lang.Apply(v105, []any{lang.NewKeyword("gen-class"), v109}) + return v110 + }) + v102 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5784), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(5784), lang.NewKeyword("end-column"), int(52)) + v103, err := lang.WithMeta(v101, v102.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v104 := lang.Apply(v100, []any{v103, v60}) + var v105 any = v104 + _ = v105 + // let binding "name-metadata" + v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v107 := v106.FindInternedVar(lang.NewSymbol("meta")) + if v107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) + } + v108 := v107.Get() + v109 := lang.Apply(v108, []any{v69}) + var v110 any = v109 + _ = v110 + v111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v112 := v111.FindInternedVar(lang.NewSymbol("seq")) + if v112.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v112))) + } + v113 := v112.Get() + v114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v115 := v114.FindInternedVar(lang.NewSymbol("concat")) + if v115.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v115))) + } + v116 := v115.Get() + v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v118 := v117.FindInternedVar(lang.NewSymbol("list")) + if v118.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) + } + v119 := v118.Get() + v120 := lang.Apply(v119, []any{lang.NewSymbol("do")}) + v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v122 := v121.FindInternedVar(lang.NewSymbol("list")) + if v122.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) + } + v123 := v122.Get() + v124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v125 := v124.FindInternedVar(lang.NewSymbol("seq")) + if v125.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v125))) + } + v126 := v125.Get() + v127 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v128 := v127.FindInternedVar(lang.NewSymbol("concat")) + if v128.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v128))) + } + v129 := v128.Get() + v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v131 := v130.FindInternedVar(lang.NewSymbol("list")) + if v131.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) + } + v132 := v131.Get() + v133 := lang.Apply(v132, []any{lang.NewSymbol("glojure.core/in-ns")}) + v134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v135 := v134.FindInternedVar(lang.NewSymbol("list")) + if v135.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v135))) + } + v136 := v135.Get() + v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v138 := v137.FindInternedVar(lang.NewSymbol("seq")) + if v138.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) + } + v139 := v138.Get() + v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v141 := v140.FindInternedVar(lang.NewSymbol("concat")) + if v141.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) + } + v142 := v141.Get() + v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v144 := v143.FindInternedVar(lang.NewSymbol("list")) + if v144.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) + } + v145 := v144.Get() + v146 := lang.Apply(v145, []any{lang.NewSymbol("quote")}) + v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v148 := v147.FindInternedVar(lang.NewSymbol("list")) + if v148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) + } + v149 := v148.Get() + v150 := lang.Apply(v149, []any{v69}) + v151 := lang.Apply(v142, []any{v146, v150}) + v152 := lang.Apply(v139, []any{v151}) + v153 := lang.Apply(v136, []any{v152}) + v154 := lang.Apply(v129, []any{v133, v153}) + v155 := lang.Apply(v126, []any{v154}) + v156 := lang.Apply(v123, []any{v155}) + var v157 any + if lang.IsTruthy(v110) { + v158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v159 := v158.FindInternedVar(lang.NewSymbol("seq")) + if v159.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v159))) + } + v160 := v159.Get() + v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v162 := v161.FindInternedVar(lang.NewSymbol("concat")) + if v162.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) + } + v163 := v162.Get() + v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v165 := v164.FindInternedVar(lang.NewSymbol("list")) + if v165.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) + } + v166 := v165.Get() + v167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v168 := v167.FindInternedVar(lang.NewSymbol("seq")) + if v168.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v168))) + } + v169 := v168.Get() + v170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v171 := v170.FindInternedVar(lang.NewSymbol("concat")) + if v171.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v171))) + } + v172 := v171.Get() + v173 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v174 := v173.FindInternedVar(lang.NewSymbol("list")) + if v174.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v174))) + } + v175 := v174.Get() + v176 := lang.Apply(v175, []any{lang.NewSymbol(".ResetMeta")}) + v177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v178 := v177.FindInternedVar(lang.NewSymbol("list")) + if v178.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v178))) + } + v179 := v178.Get() + v180 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v181 := v180.FindInternedVar(lang.NewSymbol("seq")) + if v181.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v181))) + } + v182 := v181.Get() + v183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v184 := v183.FindInternedVar(lang.NewSymbol("concat")) + if v184.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v184))) + } + v185 := v184.Get() + v186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v187 := v186.FindInternedVar(lang.NewSymbol("list")) + if v187.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v187))) + } + v188 := v187.Get() + v189 := lang.Apply(v188, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.FindNamespace")}) + v190 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v191 := v190.FindInternedVar(lang.NewSymbol("list")) + if v191.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v191))) + } + v192 := v191.Get() + v193 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v194 := v193.FindInternedVar(lang.NewSymbol("seq")) + if v194.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v194))) + } + v195 := v194.Get() + v196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v197 := v196.FindInternedVar(lang.NewSymbol("concat")) + if v197.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v197))) + } + v198 := v197.Get() + v199 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v200 := v199.FindInternedVar(lang.NewSymbol("list")) + if v200.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v200))) + } + v201 := v200.Get() + v202 := lang.Apply(v201, []any{lang.NewSymbol("quote")}) + v203 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v204 := v203.FindInternedVar(lang.NewSymbol("list")) + if v204.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v204))) + } + v205 := v204.Get() + v206 := lang.Apply(v205, []any{v69}) + v207 := lang.Apply(v198, []any{v202, v206}) + v208 := lang.Apply(v195, []any{v207}) + v209 := lang.Apply(v192, []any{v208}) + v210 := lang.Apply(v185, []any{v189, v209}) + v211 := lang.Apply(v182, []any{v210}) + v212 := lang.Apply(v179, []any{v211}) + v213 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v214 := v213.FindInternedVar(lang.NewSymbol("list")) + if v214.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v214))) + } + v215 := v214.Get() + v216 := lang.Apply(v215, []any{v110}) + v217 := lang.Apply(v172, []any{v176, v212, v216}) + v218 := lang.Apply(v169, []any{v217}) + v219 := lang.Apply(v166, []any{v218}) + v220 := lang.Apply(v163, []any{v219}) + v221 := lang.Apply(v160, []any{v220}) + v157 = v221 + } else { + v157 = nil + } + v222 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v223 := v222.FindInternedVar(lang.NewSymbol("list")) + if v223.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v223))) + } + v224 := v223.Get() + v225 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v226 := v225.FindInternedVar(lang.NewSymbol("seq")) + if v226.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v226))) + } + v227 := v226.Get() + v228 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v229 := v228.FindInternedVar(lang.NewSymbol("concat")) + if v229.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v229))) + } + v230 := v229.Get() + v231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v232 := v231.FindInternedVar(lang.NewSymbol("list")) + if v232.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v232))) + } + v233 := v232.Get() + v234 := lang.Apply(v233, []any{lang.NewSymbol("glojure.core/with-loading-context")}) + var v235 any + if lang.IsTruthy(v97) { + v236 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v237 := v236.FindInternedVar(lang.NewSymbol("list")) + if v237.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v237))) + } + v238 := v237.Get() + v239 := lang.Apply(v238, []any{v97}) + v235 = v239 + } else { + v235 = nil + } + var v240 any + var v241 any + { // let + // let binding "and__0__auto__" + v242 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v243 := v242.FindInternedVar(lang.NewSymbol("not=")) + if v243.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v243))) + } + v244 := v243.Get() + v245 := lang.Apply(v244, []any{v69, lang.NewSymbol("glojure.core")}) + var v246 any = v245 + _ = v246 + var v247 any + if lang.IsTruthy(v246) { + v248 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v249 := v248.FindInternedVar(lang.NewSymbol("not-any?")) + if v249.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v249))) + } + v250 := v249.Get() + var v251 lang.FnFunc + v251 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v252 := args[0] + _ = v252 + v253 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v254 := v253.FindInternedVar(lang.NewSymbol("=")) + if v254.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v254))) + } + v255 := v254.Get() + v256 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v257 := v256.FindInternedVar(lang.NewSymbol("first")) + if v257.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v257))) + } + v258 := v257.Get() + v259 := lang.Apply(v258, []any{v252}) + v260 := lang.Apply(v255, []any{lang.NewKeyword("refer-glojure"), v259}) + return v260 + }) + v252 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5793), lang.NewKeyword("column"), int(58), lang.NewKeyword("end-line"), int(5793), lang.NewKeyword("end-column"), int(86)) + v253, err := lang.WithMeta(v251, v252.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v254 := lang.Apply(v250, []any{v253, v105}) + v247 = v254 + } else { + v247 = v246 + } + v241 = v247 + } // end let + if lang.IsTruthy(v241) { + v242 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v243 := v242.FindInternedVar(lang.NewSymbol("seq")) + if v243.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v243))) + } + v244 := v243.Get() + v245 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v246 := v245.FindInternedVar(lang.NewSymbol("concat")) + if v246.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v246))) + } + v247 := v246.Get() + v248 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v249 := v248.FindInternedVar(lang.NewSymbol("list")) + if v249.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v249))) + } + v250 := v249.Get() + v251 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v252 := v251.FindInternedVar(lang.NewSymbol("seq")) + if v252.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v252))) + } + v253 := v252.Get() + v254 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v255 := v254.FindInternedVar(lang.NewSymbol("concat")) + if v255.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v255))) + } + v256 := v255.Get() + v257 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v258 := v257.FindInternedVar(lang.NewSymbol("list")) + if v258.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v258))) + } + v259 := v258.Get() + v260 := lang.Apply(v259, []any{lang.NewSymbol("glojure.core/refer")}) + v261 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v262 := v261.FindInternedVar(lang.NewSymbol("list")) + if v262.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v262))) + } + v263 := v262.Get() + v264 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v265 := v264.FindInternedVar(lang.NewSymbol("seq")) + if v265.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v265))) + } + v266 := v265.Get() + v267 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v268 := v267.FindInternedVar(lang.NewSymbol("concat")) + if v268.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v268))) + } + v269 := v268.Get() + v270 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v271 := v270.FindInternedVar(lang.NewSymbol("list")) + if v271.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v271))) + } + v272 := v271.Get() + v273 := lang.Apply(v272, []any{lang.NewSymbol("quote")}) + v274 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v275 := v274.FindInternedVar(lang.NewSymbol("list")) + if v275.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v275))) + } + v276 := v275.Get() + v277 := lang.Apply(v276, []any{lang.NewSymbol("glojure.core")}) + v278 := lang.Apply(v269, []any{v273, v277}) + v279 := lang.Apply(v266, []any{v278}) + v280 := lang.Apply(v263, []any{v279}) + v281 := lang.Apply(v256, []any{v260, v280}) + v282 := lang.Apply(v253, []any{v281}) + v283 := lang.Apply(v250, []any{v282}) + v284 := lang.Apply(v247, []any{v283}) + v285 := lang.Apply(v244, []any{v284}) + v240 = v285 + } else { + v240 = nil + } + v286 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v287 := v286.FindInternedVar(lang.NewSymbol("map")) + if v287.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v287))) + } + v288 := v287.Get() + v289 := lang.Apply(v288, []any{v11, v105}) + v290 := lang.Apply(v230, []any{v234, v235, v240, v289}) + v291 := lang.Apply(v227, []any{v290}) + v292 := lang.Apply(v224, []any{v291}) + v293 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v294 := v293.FindInternedVar(lang.NewSymbol("list")) + if v294.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v294))) + } + v295 := v294.Get() + v296 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v297 := v296.FindInternedVar(lang.NewSymbol("seq")) + if v297.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v297))) + } + v298 := v297.Get() + v299 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v300 := v299.FindInternedVar(lang.NewSymbol("concat")) + if v300.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v300))) + } + v301 := v300.Get() + v302 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v303 := v302.FindInternedVar(lang.NewSymbol("list")) + if v303.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v303))) + } + v304 := v303.Get() + v305 := lang.Apply(v304, []any{lang.NewSymbol("if")}) + v306 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v307 := v306.FindInternedVar(lang.NewSymbol("list")) + if v307.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v307))) + } + v308 := v307.Get() + v309 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v310 := v309.FindInternedVar(lang.NewSymbol("seq")) + if v310.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v310))) + } + v311 := v310.Get() + v312 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v313 := v312.FindInternedVar(lang.NewSymbol("concat")) + if v313.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v313))) + } + v314 := v313.Get() + v315 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v316 := v315.FindInternedVar(lang.NewSymbol("list")) + if v316.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v316))) + } + v317 := v316.Get() + v318 := lang.Apply(v317, []any{lang.NewSymbol(".Equals")}) + v319 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v320 := v319.FindInternedVar(lang.NewSymbol("list")) + if v320.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v320))) + } + v321 := v320.Get() + v322 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v323 := v322.FindInternedVar(lang.NewSymbol("seq")) + if v323.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v323))) + } + v324 := v323.Get() + v325 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v326 := v325.FindInternedVar(lang.NewSymbol("concat")) + if v326.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v326))) + } + v327 := v326.Get() + v328 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v329 := v328.FindInternedVar(lang.NewSymbol("list")) + if v329.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v329))) + } + v330 := v329.Get() + v331 := lang.Apply(v330, []any{lang.NewSymbol("quote")}) + v332 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v333 := v332.FindInternedVar(lang.NewSymbol("list")) + if v333.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v333))) + } + v334 := v333.Get() + v335 := lang.Apply(v334, []any{v69}) + v336 := lang.Apply(v327, []any{v331, v335}) + v337 := lang.Apply(v324, []any{v336}) + v338 := lang.Apply(v321, []any{v337}) + v339 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v340 := v339.FindInternedVar(lang.NewSymbol("list")) + if v340.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v340))) + } + v341 := v340.Get() + v342 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v343 := v342.FindInternedVar(lang.NewSymbol("seq")) + if v343.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v343))) + } + v344 := v343.Get() + v345 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v346 := v345.FindInternedVar(lang.NewSymbol("concat")) + if v346.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v346))) + } + v347 := v346.Get() + v348 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v349 := v348.FindInternedVar(lang.NewSymbol("list")) + if v349.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v349))) + } + v350 := v349.Get() + v351 := lang.Apply(v350, []any{lang.NewSymbol("quote")}) + v352 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v353 := v352.FindInternedVar(lang.NewSymbol("list")) + if v353.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v353))) + } + v354 := v353.Get() + v355 := lang.Apply(v354, []any{lang.NewSymbol("glojure.core")}) + v356 := lang.Apply(v347, []any{v351, v355}) + v357 := lang.Apply(v344, []any{v356}) + v358 := lang.Apply(v341, []any{v357}) + v359 := lang.Apply(v314, []any{v318, v338, v358}) + v360 := lang.Apply(v311, []any{v359}) + v361 := lang.Apply(v308, []any{v360}) + v362 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v363 := v362.FindInternedVar(lang.NewSymbol("list")) + if v363.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v363))) + } + v364 := v363.Get() + v365 := lang.Apply(v364, []any{nil}) + v366 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v367 := v366.FindInternedVar(lang.NewSymbol("list")) + if v367.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v367))) + } + v368 := v367.Get() + v369 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v370 := v369.FindInternedVar(lang.NewSymbol("seq")) + if v370.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v370))) + } + v371 := v370.Get() + v372 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v373 := v372.FindInternedVar(lang.NewSymbol("concat")) + if v373.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v373))) + } + v374 := v373.Get() + v375 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v376 := v375.FindInternedVar(lang.NewSymbol("list")) + if v376.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v376))) + } + v377 := v376.Get() + v378 := lang.Apply(v377, []any{lang.NewSymbol("do")}) + v379 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v380 := v379.FindInternedVar(lang.NewSymbol("list")) + if v380.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v380))) + } + v381 := v380.Get() + v382 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v383 := v382.FindInternedVar(lang.NewSymbol("seq")) + if v383.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v383))) + } + v384 := v383.Get() + v385 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v386 := v385.FindInternedVar(lang.NewSymbol("concat")) + if v386.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v386))) + } + v387 := v386.Get() + v388 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v389 := v388.FindInternedVar(lang.NewSymbol("list")) + if v389.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v389))) + } + v390 := v389.Get() + v391 := lang.Apply(v390, []any{lang.NewSymbol("glojure.core/dosync")}) + v392 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v393 := v392.FindInternedVar(lang.NewSymbol("list")) + if v393.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v393))) + } + v394 := v393.Get() + v395 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v396 := v395.FindInternedVar(lang.NewSymbol("seq")) + if v396.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v396))) + } + v397 := v396.Get() + v398 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v399 := v398.FindInternedVar(lang.NewSymbol("concat")) + if v399.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v399))) + } + v400 := v399.Get() + v401 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v402 := v401.FindInternedVar(lang.NewSymbol("list")) + if v402.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v402))) + } + v403 := v402.Get() + v404 := lang.Apply(v403, []any{lang.NewSymbol("glojure.core/commute")}) + v405 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v406 := v405.FindInternedVar(lang.NewSymbol("list")) + if v406.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v406))) + } + v407 := v406.Get() + v408 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v409 := v408.FindInternedVar(lang.NewSymbol("seq")) + if v409.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v409))) + } + v410 := v409.Get() + v411 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v412 := v411.FindInternedVar(lang.NewSymbol("concat")) + if v412.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v412))) + } + v413 := v412.Get() + v414 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v415 := v414.FindInternedVar(lang.NewSymbol("list")) + if v415.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v415))) + } + v416 := v415.Get() + v417 := lang.Apply(v416, []any{lang.NewSymbol("glojure.core/deref")}) + v418 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v419 := v418.FindInternedVar(lang.NewSymbol("list")) + if v419.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v419))) + } + v420 := v419.Get() + v421 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v422 := v421.FindInternedVar(lang.NewSymbol("seq")) + if v422.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v422))) + } + v423 := v422.Get() + v424 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v425 := v424.FindInternedVar(lang.NewSymbol("concat")) + if v425.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v425))) + } + v426 := v425.Get() + v427 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v428 := v427.FindInternedVar(lang.NewSymbol("list")) + if v428.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v428))) + } + v429 := v428.Get() + v430 := lang.Apply(v429, []any{lang.NewSymbol("var")}) + v431 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v432 := v431.FindInternedVar(lang.NewSymbol("list")) + if v432.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v432))) + } + v433 := v432.Get() + v434 := lang.Apply(v433, []any{lang.NewSymbol("glojure.core/*loaded-libs*")}) + v435 := lang.Apply(v426, []any{v430, v434}) + v436 := lang.Apply(v423, []any{v435}) + v437 := lang.Apply(v420, []any{v436}) + v438 := lang.Apply(v413, []any{v417, v437}) + v439 := lang.Apply(v410, []any{v438}) + v440 := lang.Apply(v407, []any{v439}) + v441 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v442 := v441.FindInternedVar(lang.NewSymbol("list")) + if v442.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v442))) + } + v443 := v442.Get() + v444 := lang.Apply(v443, []any{lang.NewSymbol("glojure.core/conj")}) + v445 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v446 := v445.FindInternedVar(lang.NewSymbol("list")) + if v446.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v446))) + } + v447 := v446.Get() + v448 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v449 := v448.FindInternedVar(lang.NewSymbol("seq")) + if v449.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v449))) + } + v450 := v449.Get() + v451 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v452 := v451.FindInternedVar(lang.NewSymbol("concat")) + if v452.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v452))) + } + v453 := v452.Get() + v454 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v455 := v454.FindInternedVar(lang.NewSymbol("list")) + if v455.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v455))) + } + v456 := v455.Get() + v457 := lang.Apply(v456, []any{lang.NewSymbol("quote")}) + v458 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v459 := v458.FindInternedVar(lang.NewSymbol("list")) + if v459.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v459))) + } + v460 := v459.Get() + v461 := lang.Apply(v460, []any{v69}) + v462 := lang.Apply(v453, []any{v457, v461}) + v463 := lang.Apply(v450, []any{v462}) + v464 := lang.Apply(v447, []any{v463}) + v465 := lang.Apply(v400, []any{v404, v440, v444, v464}) + v466 := lang.Apply(v397, []any{v465}) + v467 := lang.Apply(v394, []any{v466}) + v468 := lang.Apply(v387, []any{v391, v467}) + v469 := lang.Apply(v384, []any{v468}) + v470 := lang.Apply(v381, []any{v469}) + v471 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v472 := v471.FindInternedVar(lang.NewSymbol("list")) + if v472.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v472))) + } + v473 := v472.Get() + v474 := lang.Apply(v473, []any{nil}) + v475 := lang.Apply(v374, []any{v378, v470, v474}) + v476 := lang.Apply(v371, []any{v475}) + v477 := lang.Apply(v368, []any{v476}) + v478 := lang.Apply(v301, []any{v305, v361, v365, v477}) + v479 := lang.Apply(v298, []any{v478}) + v480 := lang.Apply(v295, []any{v479}) + v481 := lang.Apply(v116, []any{v120, v156, v157, v292, v480}) + v482 := lang.Apply(v113, []any{v481}) + v7 = v482 + } // end let + return v7 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // ns-aliases + { + v0 := lang.NewSymbol("ns-aliases").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of the aliases for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4273), lang.NewKeyword("end-line"), int(4273))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("the-ns")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.Apply(v6, []any{v3}) + v8, ok := lang.FieldOrMethod(v7, "getAliases") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "getAliases"))) + } + var v9 any + switch reflect.TypeOf(v8).Kind() { + case reflect.Func: + v9 = lang.Apply(v8, nil) + default: + v9 = v8 + } + return v9 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // ns-imports + { + v0 := lang.NewSymbol("ns-imports").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of the import mappings for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4199), lang.NewKeyword("end-line"), int(4199))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("filter-key")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("val")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("partial")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("instance?")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v12, []any{v15, reflect.Type}) + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("ns-map")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.Apply(v19, []any{v3}) + v21 := lang.Apply(v6, []any{v9, v16, v20}) + return v21 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // ns-interns + { + v0 := lang.NewSymbol("ns-interns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of the intern mappings for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4206), lang.NewKeyword("end-line"), int(4206))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + { // let + // let binding "ns" + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("the-ns")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v3}) + var v9 any = v8 + _ = v9 + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("filter-key")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("val")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + var v16 lang.FnFunc + v16 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v17 := args[0] + _ = v17 + var v18 any + { // let + // let binding "and__0__auto__" + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("instance?")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{*lang.Var, v17}) + var v23 any = v22 + _ = v23 + var v24 any + if lang.IsTruthy(v23) { + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("=")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28, ok := lang.FieldOrMethod(v17, "Namespace") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v17, "Namespace"))) + } + var v29 any + switch reflect.TypeOf(v28).Kind() { + case reflect.Func: + v29 = lang.Apply(v28, nil) + default: + v29 = v28 + } + v30 := lang.Apply(v27, []any{v9, v29}) + v24 = v30 + } else { + v24 = v23 + } + v18 = v24 + } // end let + return v18 + }) + v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4212), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(4213), lang.NewKeyword("end-column"), int(56)) + v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("ns-map")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{v9}) + v23 := lang.Apply(v12, []any{v15, v18, v22}) + v4 = v23 + } // end let + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // ns-map + { + v0 := lang.NewSymbol("ns-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of all the mappings for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4170), lang.NewKeyword("end-line"), int(4170))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("the-ns")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.Apply(v6, []any{v3}) + v8, ok := lang.FieldOrMethod(v7, "Mappings") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "Mappings"))) + } + var v9 any + switch reflect.TypeOf(v8).Kind() { + case reflect.Func: + v9 = lang.Apply(v8, nil) + default: + v9 = v8 + } + return v9 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // ns-name + { + v0 := lang.NewSymbol("ns-name").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns the name of the namespace, a symbol.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4163), lang.NewKeyword("end-line"), int(4163))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("the-ns")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.Apply(v6, []any{v3}) + v8, ok := lang.FieldOrMethod(v7, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "Name"))) + } + var v9 any + switch reflect.TypeOf(v8).Kind() { + case reflect.Func: + v9 = lang.Apply(v8, nil) + default: + v9 = v8 + } + return v9 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // ns-publics + { + v0 := lang.NewSymbol("ns-publics").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of the public intern mappings for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4188), lang.NewKeyword("end-line"), int(4188))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + { // let + // let binding "ns" + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("the-ns")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v3}) + var v9 any = v8 + _ = v9 + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("filter-key")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("val")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + var v16 lang.FnFunc + v16 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v17 := args[0] + _ = v17 + var v18 any + { // let + // let binding "and__0__auto__" + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("instance?")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{*lang.Var, v17}) + var v23 any = v22 + _ = v23 + var v24 any + if lang.IsTruthy(v23) { + var v25 any + { // let + // let binding "and__0__auto__" + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("=")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29, ok := lang.FieldOrMethod(v17, "Namespace") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v17, "Namespace"))) + } + var v30 any + switch reflect.TypeOf(v29).Kind() { + case reflect.Func: + v30 = lang.Apply(v29, nil) + default: + v30 = v29 + } + v31 := lang.Apply(v28, []any{v9, v30}) + var v32 any = v31 + _ = v32 + var v33 any + if lang.IsTruthy(v32) { + v34, ok := lang.FieldOrMethod(v17, "IsPublic") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v17, "IsPublic"))) + } + var v35 any + switch reflect.TypeOf(v34).Kind() { + case reflect.Func: + v35 = lang.Apply(v34, nil) + default: + v35 = v34 + } + v33 = v35 + } else { + v33 = v32 + } + v25 = v33 + } // end let + v24 = v25 + } else { + v24 = v23 + } + v18 = v24 + } // end let + return v18 + }) + v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4194), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(4196), lang.NewKeyword("end-column"), int(48)) + v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("ns-map")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{v9}) + v23 := lang.Apply(v12, []any{v15, v18, v22}) + v4 = v23 + } // end let + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // ns-refers + { + v0 := lang.NewSymbol("ns-refers").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of the refer mappings for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4253), lang.NewKeyword("end-line"), int(4253))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + { // let + // let binding "ns" + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("the-ns")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v3}) + var v9 any = v8 + _ = v9 + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("filter-key")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("val")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + var v16 lang.FnFunc + v16 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v17 := args[0] + _ = v17 + var v18 any + { // let + // let binding "and__0__auto__" + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("instance?")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{*lang.Var, v17}) + var v23 any = v22 + _ = v23 + var v24 any + if lang.IsTruthy(v23) { + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("not=")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28, ok := lang.FieldOrMethod(v17, "Namespace") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v17, "Namespace"))) + } + var v29 any + switch reflect.TypeOf(v28).Kind() { + case reflect.Func: + v29 = lang.Apply(v28, nil) + default: + v29 = v28 + } + v30 := lang.Apply(v27, []any{v9, v29}) + v24 = v30 + } else { + v24 = v23 + } + v18 = v24 + } // end let + return v18 + }) + v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4259), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(4260), lang.NewKeyword("end-column"), int(59)) + v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("ns-map")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{v9}) + v23 := lang.Apply(v12, []any{v15, v18, v22}) + v4 = v23 + } // end let + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // ns-resolve + { + v0 := lang.NewSymbol("ns-resolve").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("sym")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("env"), lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Returns the var or Class to which a symbol will be resolved in the\n namespace (unless found in the environment), else nil. Note that\n if the symbol is fully qualified, the var/Class to which it resolves\n need not be present in the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4358), lang.NewKeyword("end-line"), int(4358))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("ns-resolve")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v3, nil, v4}) + return v8 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("contains?")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, []any{v4, v5}) + if lang.IsTruthy(v10) { + v6 = nil + } else { + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("the-ns")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{v3}) + v15, _ := lang.FieldOrMethod(runtime4.Compiler, "maybeResolveIn") + if reflect.TypeOf(v15).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("maybeResolveIn is not a function"))) + } + v16 := lang.Apply(v15, []any{v14, v5}) + v6 = v16 + } + return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // ns-unalias + { + v0 := lang.NewSymbol("ns-unalias").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Removes the alias for the symbol from the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4280), lang.NewKeyword("end-line"), int(4280))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("the-ns")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v3}) + v9, _ := lang.FieldOrMethod(v8, "removeAlias") + if reflect.TypeOf(v9).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("removeAlias is not a function"))) + } + v10 := lang.Apply(v9, []any{v4}) + return v10 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // ns-unmap + { + v0 := lang.NewSymbol("ns-unmap").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Removes the mappings for the symbol from the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4177), lang.NewKeyword("end-line"), int(4177))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("the-ns")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v3}) + v9, _ := lang.FieldOrMethod(v8, "unmap") + if reflect.TypeOf(v9).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unmap is not a function"))) + } + v10 := lang.Apply(v9, []any{v4}) + return v10 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // nth + { + var v1 lang.FnFunc + { // function nth__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.NewList(args[2:]...) + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("seq")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("concat")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("list")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.Apply(v14, []any{lang.NewSymbol(".")}) + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("list")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("list")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("seq")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("concat")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("list")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.Apply(v31, []any{lang.NewSymbol("glojure.core/Nth")}) + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("list")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("seq")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v40 := v39.FindInternedVar(lang.NewSymbol("concat")) + if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) + } + v41 := v40.Get() + v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v43 := v42.FindInternedVar(lang.NewSymbol("list")) + if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) + } + v44 := v43.Get() + v45 := lang.Apply(v44, []any{lang.NewSymbol("glojure.core/unquote")}) + v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v47 := v46.FindInternedVar(lang.NewSymbol("list")) + if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) + } + v48 := v47.Get() + v49 := lang.Apply(v48, []any{lang.NewSymbol("glojure.core/c")}) + v50 := lang.Apply(v41, []any{v45, v49}) + v51 := lang.Apply(v38, []any{v50}) + v52 := lang.Apply(v35, []any{v51}) + v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v54 := v53.FindInternedVar(lang.NewSymbol("list")) + if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) + } + v55 := v54.Get() + v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v57 := v56.FindInternedVar(lang.NewSymbol("seq")) + if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) + } + v58 := v57.Get() + v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v60 := v59.FindInternedVar(lang.NewSymbol("concat")) + if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) + } + v61 := v60.Get() + v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v63 := v62.FindInternedVar(lang.NewSymbol("list")) + if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) + } + v64 := v63.Get() + v65 := lang.Apply(v64, []any{lang.NewSymbol("glojure.core/unquote")}) + v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v67 := v66.FindInternedVar(lang.NewSymbol("list")) + if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) + } + v68 := v67.Get() + v69 := lang.Apply(v68, []any{lang.NewSymbol("glojure.core/i")}) + v70 := lang.Apply(v61, []any{v65, v69}) + v71 := lang.Apply(v58, []any{v70}) + v72 := lang.Apply(v55, []any{v71}) + v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v74 := v73.FindInternedVar(lang.NewSymbol("list")) + if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) + } + v75 := v74.Get() + v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v77 := v76.FindInternedVar(lang.NewSymbol("seq")) + if v77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) + } + v78 := v77.Get() + v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v80 := v79.FindInternedVar(lang.NewSymbol("concat")) + if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) + } + v81 := v80.Get() + v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v83 := v82.FindInternedVar(lang.NewSymbol("list")) + if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) + } + v84 := v83.Get() + v85 := lang.Apply(v84, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) + v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v87 := v86.FindInternedVar(lang.NewSymbol("list")) + if v87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) + } + v88 := v87.Get() + v89 := lang.Apply(v88, []any{lang.NewSymbol("glojure.core/nf")}) + v90 := lang.Apply(v81, []any{v85, v89}) + v91 := lang.Apply(v78, []any{v90}) + v92 := lang.Apply(v75, []any{v91}) + v93 := lang.Apply(v28, []any{v32, v52, v72, v92}) + v94 := lang.Apply(v25, []any{v93}) + v95 := lang.Apply(v22, []any{v94}) + v96 := lang.Apply(v11, []any{v15, v19, v95}) + v97 := lang.Apply(v8, []any{v96}) + return v97 + } + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("nth").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("index")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("index"), lang.NewSymbol("not-found"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the value at the index. get returns nil if index out of\n bounds, nth throws an exception unless not-found is supplied. nth\n also works for strings, Java arrays, regex Matchers and Lists, and,\n in O(n) time, for sequences.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2), int64(3)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(882), lang.NewKeyword("end-line"), int(882))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6, _ := lang.FieldOrMethod(runtime4.RT, "Nth") + if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Nth is not a function"))) + } + v7 := lang.Apply(v6, []any{v4, v5}) + return v7 + case 3: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := args[2] + _ = v6 + v7, _ := lang.FieldOrMethod(runtime4.RT, "NthDefault") + if reflect.TypeOf(v7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("NthDefault is not a function"))) + } + v8 := lang.Apply(v7, []any{v4, v5, v6}) + return v8 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // nthnext + { + v0 := lang.NewSymbol("nthnext").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns the nth next of coll, (seq coll) when n is 0.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3147), lang.NewKeyword("end-line"), int(3147))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{lang.IDrop, v3}) + if lang.IsTruthy(v9) { + var v10 any + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("pos?")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{v4}) + if lang.IsTruthy(v14) { + var v15 any + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("int?")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{v4}) + if lang.IsTruthy(v19) { + v15 = v4 + } else { + v20 := lang.Apply(nil, []any{v4}) + v15 = v20 + } + v21, _ := lang.FieldOrMethod(v3, "drop") + if reflect.TypeOf(v21).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("drop is not a function"))) + } + v22 := lang.Apply(v21, []any{v15}) + v10 = v22 + } else { + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("seq")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.Apply(v25, []any{v3}) + v10 = v26 + } + v5 = v10 + } else { + var v27 any + { // let + // let binding "n" + var v28 any = v4 + _ = v28 + // let binding "xs" + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("seq")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.Apply(v31, []any{v3}) + var v33 any = v32 + _ = v33 + for { + var v34 any + var v35 any + { // let + // let binding "and__0__auto__" + var v36 any = v33 + _ = v36 + var v37 any + if lang.IsTruthy(v36) { + v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v39 := v38.FindInternedVar(lang.NewSymbol("pos?")) + if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + } + v40 := v39.Get() + v41 := lang.Apply(v40, []any{v28}) + v37 = v41 + } else { + v37 = v36 + } + v35 = v37 + } // end let + if lang.IsTruthy(v35) { + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("dec")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.Apply(v39, []any{v28}) + var v36 any = v40 + v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v43 := v42.FindInternedVar(lang.NewSymbol("next")) + if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) + } + v44 := v43.Get() + v45 := lang.Apply(v44, []any{v33}) + var v41 any = v45 + v28 = v36 + v33 = v41 + continue + } else { + v34 = v33 + } + v27 = v34 + break + } + } // end let + v5 = v27 + } + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // nthrest + { + v0 := lang.NewSymbol("nthrest").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns the nth rest of coll, coll when n is 0.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3161), lang.NewKeyword("end-line"), int(3161))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("pos?")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{v4}) + if lang.IsTruthy(v9) { + var v10 any + { // let + // let binding "or__0__auto__" + var v11 any + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("instance?")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.Apply(v14, []any{lang.IDrop, v3}) + if lang.IsTruthy(v15) { + var v16 any + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("int?")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.Apply(v19, []any{v4}) + if lang.IsTruthy(v20) { + v16 = v4 + } else { + v21 := lang.Apply(nil, []any{v4}) + v16 = v21 + } + v22, _ := lang.FieldOrMethod(v3, "drop") + if reflect.TypeOf(v22).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("drop is not a function"))) + } + v23 := lang.Apply(v22, []any{v16}) + v11 = v23 + } else { + var v24 any + { // let + // let binding "n" + var v25 any = v4 + _ = v25 + // let binding "xs" + var v26 any = v3 + _ = v26 + for { + var v27 any + { // let + // let binding "temp__0__auto__" + var v28 any + { // let + // let binding "and__0__auto__" + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("pos?")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.Apply(v31, []any{v25}) + var v33 any = v32 + _ = v33 + var v34 any + if lang.IsTruthy(v33) { + v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v36 := v35.FindInternedVar(lang.NewSymbol("seq")) + if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + } + v37 := v36.Get() + v38 := lang.Apply(v37, []any{v26}) + v34 = v38 + } else { + v34 = v33 + } + v28 = v34 + } // end let + var v29 any = v28 + _ = v29 + var v30 any + if lang.IsTruthy(v29) { + var v31 any + { // let + // let binding "xs" + var v32 any = v29 + _ = v32 + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("dec")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.Apply(v36, []any{v25}) + var v33 any = v37 + v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v40 := v39.FindInternedVar(lang.NewSymbol("rest")) + if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) + } + v41 := v40.Get() + v42 := lang.Apply(v41, []any{v32}) + var v38 any = v42 + v25 = v33 + v26 = v38 + continue + } // end let + v30 = v31 + } else { + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("seq")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{v26}) + v30 = v35 + } + v27 = v30 + } // end let + v24 = v27 + break + } + } // end let + v11 = v24 + } + var v25 any = v11 + _ = v25 + var v26 any + if lang.IsTruthy(v25) { + v26 = v25 + } else { + v26 = lang.NewList() + } + v10 = v26 + } // end let + v5 = v10 + } else { + v5 = v3 + } + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // num + { + var v1 lang.FnFunc + { // function num__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("concat")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("list")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("seq")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("concat")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/Num")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{v3}) + v35 := lang.Apply(v26, []any{v30, v34}) + v36 := lang.Apply(v23, []any{v35}) + v37 := lang.Apply(v20, []any{v36}) + v38 := lang.Apply(v9, []any{v13, v17, v37}) + v39 := lang.Apply(v6, []any{v38}) + return v39 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("num").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to Number", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3474), lang.NewKeyword("end-line"), int(3474))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5, _ := lang.FieldOrMethod(lang.Numbers, "Num") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Num is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // number? + { + v0 := lang.NewSymbol("number?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is a Number", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3560), lang.NewKeyword("end-line"), int(3560))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.Apply(lang.IsNumber, []any{v3}) + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // numerator + { + v1 := reflect.TypeOf((*big6.Int)(nil)) + v0 := lang.NewSymbol("numerator").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("r"))), lang.NewKeyword("doc"), "Returns the numerator part of a Ratio.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3583), lang.NewKeyword("end-line"), int(3583))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5, ok := lang.FieldOrMethod(v4, "numerator") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "numerator"))) + } + var v6 any + switch reflect.TypeOf(v5).Kind() { + case reflect.Func: + v6 = lang.Apply(v5, nil) + default: + v6 = v5 + } + return v6 + }) + v4 := reflect.TypeOf((*big6.Int)(nil)) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // object-array + { + var v1 lang.FnFunc + { // function object-array__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("concat")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("list")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/Object_array")}) + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("list")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v3}) + v26 := lang.Apply(v9, []any{v13, v17, v21, v25}) + v27 := lang.Apply(v6, []any{v26}) + return v27 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("object-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Creates an array of objects", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)), lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5349), lang.NewKeyword("end-line"), int(5349))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5, _ := lang.FieldOrMethod(runtime4.RT, "Object_array") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Object_array is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // odd? + { + v0 := lang.NewSymbol("odd?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is odd, throws an exception if n is not an integer", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1389), lang.NewKeyword("end-line"), int(1389))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("not")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("even?")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, []any{v3}) + v11 := lang.Apply(v6, []any{v10}) + return v11 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // or + { + v0 := lang.NewSymbol("or").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("next"))), lang.NewKeyword("doc"), "Evaluates exprs one at a time, from left to right. If a form\n returns a logical true value, or returns that value and doesn't\n evaluate any of the other expressions, otherwise it returns the\n value of the last expression. (or) returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(847), lang.NewKeyword("end-line"), int(847))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + return nil + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + return v5 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("seq")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("concat")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("list")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/let")}) + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("list")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("apply")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("vector")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("seq")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("concat")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("list")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{lang.NewSymbol("or__0__auto__")}) + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("list")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v38, []any{v5}) + v40 := lang.Apply(v31, []any{v35, v39}) + v41 := lang.Apply(v28, []any{v40}) + v42 := lang.Apply(v22, []any{v25, v41}) + v43 := lang.Apply(v19, []any{v42}) + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("list")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v48 := v47.FindInternedVar(lang.NewSymbol("seq")) + if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) + } + v49 := v48.Get() + v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v51 := v50.FindInternedVar(lang.NewSymbol("concat")) + if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) + } + v52 := v51.Get() + v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v54 := v53.FindInternedVar(lang.NewSymbol("list")) + if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) + } + v55 := v54.Get() + v56 := lang.Apply(v55, []any{lang.NewSymbol("if")}) + v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v58 := v57.FindInternedVar(lang.NewSymbol("list")) + if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) + } + v59 := v58.Get() + v60 := lang.Apply(v59, []any{lang.NewSymbol("or__0__auto__")}) + v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v62 := v61.FindInternedVar(lang.NewSymbol("list")) + if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) + } + v63 := v62.Get() + v64 := lang.Apply(v63, []any{lang.NewSymbol("or__0__auto__")}) + v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v66 := v65.FindInternedVar(lang.NewSymbol("list")) + if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) + } + v67 := v66.Get() + v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v69 := v68.FindInternedVar(lang.NewSymbol("seq")) + if v69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) + } + v70 := v69.Get() + v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v72 := v71.FindInternedVar(lang.NewSymbol("concat")) + if v72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) + } + v73 := v72.Get() + v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v75 := v74.FindInternedVar(lang.NewSymbol("list")) + if v75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) + } + v76 := v75.Get() + v77 := lang.Apply(v76, []any{lang.NewSymbol("glojure.core/or")}) + v78 := lang.Apply(v73, []any{v77, v6}) + v79 := lang.Apply(v70, []any{v78}) + v80 := lang.Apply(v67, []any{v79}) + v81 := lang.Apply(v52, []any{v56, v60, v64, v80}) + v82 := lang.Apply(v49, []any{v81}) + v83 := lang.Apply(v46, []any{v82}) + v84 := lang.Apply(v12, []any{v16, v43, v83}) + v85 := lang.Apply(v9, []any{v84}) + return v85 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // parents + { + v0 := lang.NewSymbol("parents").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"))), lang.NewKeyword("doc"), "Returns the immediate parents of tag, either via a Java type\n inheritance relationship or a relationship established via derive. h\n must be a hierarchy obtained from make-hierarchy, if not supplied\n defaults to the global hierarchy", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5564), lang.NewKeyword("end-line"), int(5564))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("parents")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("global-hierarchy")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v6, []any{v9, v3}) + return v10 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("not-empty")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + var v8 any + { // let + // let binding "tp" + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("get")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.Apply(lang.NewKeyword("parents"), []any{v3}) + v13 := lang.Apply(v11, []any{v12, v4}) + var v14 any = v13 + _ = v14 + var v15 any + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("class?")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{v4}) + if lang.IsTruthy(v19) { + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("into1")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("set")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("bases")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.Apply(v28, []any{v4}) + v30 := lang.Apply(v25, []any{v29}) + v31 := lang.Apply(v22, []any{v30, v14}) + v15 = v31 + } else { + v15 = v14 + } + v8 = v15 + } // end let + v9 := lang.Apply(v7, []any{v8}) + return v9 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // parse-boolean + { + v0 := lang.NewSymbol("parse-boolean").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse strings \"true\" or \"false\" and return a boolean, or nil if invalid", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7957), lang.NewKeyword("end-line"), int(7957))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("string?")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v3}) + if lang.IsTruthy(v8) { + var v9 any + { // let + // let binding "G__353" + var v10 any = v3 + _ = v10 + v9 = nil + } // end let + v4 = v9 + } else { + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("parsing-err")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{v3}) + v14 := lang.Apply(lang.NewIllegalArgumentError, []any{v13}) + panic(v14) + } + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // parse-double + { + v0 := lang.NewSymbol("parse-double").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse string with floating point components and return a Double value,\n or nil if parse fails.\n\n Grammar: https://docs.oracle.com/javase/8/docs/api/java/lang/Double.html#valueOf-java.lang.String-", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7935), lang.NewKeyword("end-line"), int(7935))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("string?")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v3}) + if lang.IsTruthy(v8) { + var v9 any + { // let + // let binding "result__3649__auto__" + v10 := lang.Apply(strconv9.ParseFloat, []any{v3, int64(64)}) + var v11 any = v10 + _ = v11 + var v12 any + v13 := lang.Apply(v11, []any{int64(1)}) + if lang.IsTruthy(v13) { + v12 = nil + } else { + v14 := lang.Apply(v11, []any{int64(0)}) + v12 = v14 + } + v9 = v12 + } // end let + v4 = v9 + } else { + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("parsing-err")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{v3}) + v14 := lang.Apply(lang.NewIllegalArgumentError, []any{v13}) + panic(v14) + } + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // parse-impls + { + v0 := lang.NewSymbol("parse-impls").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(13), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(13), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("specs"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + { // let + // let binding "ret" + v5 := lang.NewMap() + v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(14), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(14), lang.NewKeyword("end-column"), int(15)) + v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v8 any = v7 + _ = v8 + // let binding "s" + var v9 any = v3 + _ = v9 + for { + var v10 any + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("seq")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{v9}) + if lang.IsTruthy(v14) { + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("assoc")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("first")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{v9}) + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("take-while")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("seq?")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("next")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.Apply(v31, []any{v9}) + v33 := lang.Apply(v25, []any{v28, v32}) + v34 := lang.Apply(v18, []any{v8, v22, v33}) + var v15 any = v34 + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("drop-while")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v40 := v39.FindInternedVar(lang.NewSymbol("seq?")) + if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) + } + v41 := v40.Get() + v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v43 := v42.FindInternedVar(lang.NewSymbol("next")) + if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) + } + v44 := v43.Get() + v45 := lang.Apply(v44, []any{v9}) + v46 := lang.Apply(v38, []any{v41, v45}) + var v35 any = v46 + v8 = v15 + v9 = v35 + continue + } else { + v10 = v8 + } + v4 = v10 + break + } + } // end let + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // parse-long + { + v0 := lang.NewSymbol("parse-long").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse string of decimal digits with optional leading -/+ and return a\n Long value, or nil if parse fails", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7926), lang.NewKeyword("end-line"), int(7926))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("string?")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v3}) + if lang.IsTruthy(v8) { + var v9 any + { // let + // let binding "result__3648__auto__" + v10 := lang.Apply(strconv9.ParseInt, []any{v3, int64(10), int64(64)}) + var v11 any = v10 + _ = v11 + var v12 any + v13 := lang.Apply(v11, []any{int64(1)}) + if lang.IsTruthy(v13) { + v12 = nil + } else { + v14 := lang.Apply(v11, []any{int64(0)}) + v12 = v14 + } + v9 = v12 + } // end let + v4 = v9 + } else { + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("parsing-err")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{v3}) + v14 := lang.Apply(lang.NewIllegalArgumentError, []any{v13}) + panic(v14) + } + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // parse-uuid + { + v0 := lang.NewSymbol("parse-uuid").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse a string representing a UUID and return a java.util.UUID instance,\n or nil if parse fails.\n\n Grammar: https://docs.oracle.com/javase/8/docs/api/java/util/UUID.html#toString--", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7946), lang.NewKeyword("end-line"), int(7946))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + func() { + defer func() { + if r := recover(); r != nil { + if lang.CatchMatches(r, *lang.IllegalArgumentError) { + v5 := r + _ = v5 + v4 = nil + } else { + panic(r) + } + } + }() + var v5 any + { // let + // let binding "vec__350" + v6 := lang.Apply(uuid10.Parse, []any{v3}) + var v7 any = v6 + _ = v7 + // let binding "uuid" + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("nth")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v7, int64(0), nil}) + var v12 any = v11 + _ = v12 + // let binding "err" + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("nth")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{v7, int64(1), nil}) + var v17 any = v16 + _ = v17 + var v18 any + if lang.IsTruthy(v17) { + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("str")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{"Error parsing UUID: ", v17}) + v23 := lang.Apply(lang.NewIllegalArgumentError, []any{v22}) + panic(v23) + } else { + v18 = v12 + } + v5 = v18 + } // end let + v4 = v5 + }() + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // parsing-err + { + v0 := lang.NewSymbol("parsing-err").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Construct message for parsing for non-string parsing error", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(7921), lang.NewKeyword("end-line"), int(7921), lang.NewKeyword("private"), true)).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("str")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + var v7 any + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("nil?")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v3}) + if lang.IsTruthy(v11) { + v7 = "nil" + } else { + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("class")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.Apply(v14, []any{v3}) + v16, ok := lang.FieldOrMethod(v15, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v15, "Name"))) + } + var v17 any + switch reflect.TypeOf(v16).Kind() { + case reflect.Func: + v17 = lang.Apply(v16, nil) + default: + v17 = v16 + } + v7 = v17 + } + v18 := lang.Apply(v6, []any{"Expected string, got ", v7}) + return v18 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // partial + { + v0 := lang.NewSymbol("partial").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("arg1")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("arg1"), lang.NewSymbol("arg2")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("arg1"), lang.NewSymbol("arg2"), lang.NewSymbol("arg3")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("arg1"), lang.NewSymbol("arg2"), lang.NewSymbol("arg3"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Takes a function f and fewer than the normal arguments to f, and\n returns a fn that takes a variable number of additional args. When\n called, the returned function calls f with args + additional args.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2606), lang.NewKeyword("end-line"), int(2606))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + return v3 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 lang.FnFunc + v5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + v6 := lang.Apply(v3, []any{v4}) + return v6 + case 1: + v6 := args[0] + _ = v6 + v7 := lang.Apply(v3, []any{v4, v6}) + return v7 + case 2: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := lang.Apply(v3, []any{v4, v6, v7}) + return v8 + case 3: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + v9 := lang.Apply(v3, []any{v4, v6, v7, v8}) + return v9 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + v9 := lang.NewList(args[3:]...) + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("apply")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{v3, v4, v6, v7, v8, v9}) + return v13 + } + }) + v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2614), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(2619), lang.NewKeyword("end-column"), int(48)) + v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v7 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 lang.FnFunc + v6 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + v7 := lang.Apply(v3, []any{v4, v5}) + return v7 + case 1: + v7 := args[0] + _ = v7 + v8 := lang.Apply(v3, []any{v4, v5, v7}) + return v8 + case 2: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := lang.Apply(v3, []any{v4, v5, v7, v8}) + return v9 + case 3: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + v10 := lang.Apply(v3, []any{v4, v5, v7, v8, v9}) + return v10 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + v10 := lang.NewList(args[3:]...) + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("apply")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{v3, v4, v5, v7, v8, v9, v10}) + return v14 + } + }) + v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2621), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(2626), lang.NewKeyword("end-column"), int(53)) + v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v8 + case 4: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + var v7 lang.FnFunc + v7 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + v8 := lang.Apply(v3, []any{v4, v5, v6}) + return v8 + case 1: + v8 := args[0] + _ = v8 + v9 := lang.Apply(v3, []any{v4, v5, v6, v8}) + return v9 + case 2: + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + v10 := lang.Apply(v3, []any{v4, v5, v6, v8, v9}) + return v10 + case 3: + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + v10 := args[2] + _ = v10 + v11 := lang.Apply(v3, []any{v4, v5, v6, v8, v9, v10}) + return v11 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + v10 := args[2] + _ = v10 + v11 := lang.NewList(args[3:]...) + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("apply")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.Apply(v14, []any{v3, v4, v5, v6, v8, v9, v10, v11}) + return v15 + } + }) + v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2628), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(2633), lang.NewKeyword("end-column"), int(58)) + v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v9 + default: + if len(args) < 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := lang.NewList(args[4:]...) + var v8 lang.FnFunc + v8 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v9 := lang.NewList(args[0:]...) + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("apply")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("concat")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{v7, v9}) + v17 := lang.Apply(v12, []any{v3, v4, v5, v6, v16}) + return v17 + } + }) + v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2635), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(2635), lang.NewKeyword("end-column"), int(60)) + v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v10 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // partition + { + v0 := lang.NewSymbol("partition").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("pad"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of lists of n items each, at offsets step\n apart. If step is not supplied, defaults to n, i.e. the partitions\n do not overlap. If a pad collection is supplied, use its elements as\n necessary to complete last partition upto n items. In case there are\n not enough padding elements, return a partition with less than n items.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3177), lang.NewKeyword("end-line"), int(3177))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("partition")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v3, v3, v4}) + return v8 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 lang.FnFunc + v6 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v7 any + { // let + // let binding "temp__0__auto__" + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("seq")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v5}) + var v12 any = v11 + _ = v12 + var v13 any + if lang.IsTruthy(v12) { + var v14 any + { // let + // let binding "s" + var v15 any = v12 + _ = v15 + var v16 any + { // let + // let binding "p" + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("doall")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("take")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.Apply(v22, []any{v3, v15}) + v24 := lang.Apply(v19, []any{v23}) + var v25 any = v24 + _ = v25 + var v26 any + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("=")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("count")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.Apply(v32, []any{v25}) + v34 := lang.Apply(v29, []any{v3, v33}) + if lang.IsTruthy(v34) { + v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v36 := v35.FindInternedVar(lang.NewSymbol("cons")) + if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + } + v37 := v36.Get() + v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v39 := v38.FindInternedVar(lang.NewSymbol("partition")) + if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + } + v40 := v39.Get() + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("nthrest")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.Apply(v43, []any{v15, v4}) + v45 := lang.Apply(v40, []any{v3, v4, v44}) + v46 := lang.Apply(v37, []any{v25, v45}) + v26 = v46 + } else { + v26 = nil + } + v16 = v26 + } // end let + v14 = v16 + } // end let + v13 = v14 + } else { + v13 = nil + } + v7 = v13 + } // end let + return v7 + }) + v7 := lang.Apply(lang.NewLazySeq, []any{v6}) + return v7 + case 4: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + var v7 lang.FnFunc + v7 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v8 any + { // let + // let binding "temp__0__auto__" + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("seq")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.Apply(v11, []any{v6}) + var v13 any = v12 + _ = v13 + var v14 any + if lang.IsTruthy(v13) { + var v15 any + { // let + // let binding "s" + var v16 any = v13 + _ = v16 + var v17 any + { // let + // let binding "p" + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("doall")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("take")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.Apply(v23, []any{v3, v16}) + v25 := lang.Apply(v20, []any{v24}) + var v26 any = v25 + _ = v26 + var v27 any + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("=")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("count")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{v26}) + v35 := lang.Apply(v30, []any{v3, v34}) + if lang.IsTruthy(v35) { + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("cons")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v40 := v39.FindInternedVar(lang.NewSymbol("partition")) + if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) + } + v41 := v40.Get() + v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v43 := v42.FindInternedVar(lang.NewSymbol("nthrest")) + if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) + } + v44 := v43.Get() + v45 := lang.Apply(v44, []any{v16, v4}) + v46 := lang.Apply(v41, []any{v3, v4, v5, v45}) + v47 := lang.Apply(v38, []any{v26, v46}) + v27 = v47 + } else { + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("list")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v52 := v51.FindInternedVar(lang.NewSymbol("take")) + if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) + } + v53 := v52.Get() + v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v55 := v54.FindInternedVar(lang.NewSymbol("concat")) + if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) + } + v56 := v55.Get() + v57 := lang.Apply(v56, []any{v26, v5}) + v58 := lang.Apply(v53, []any{v3, v57}) + v59 := lang.Apply(v50, []any{v58}) + v27 = v59 + } + v17 = v27 + } // end let + v15 = v17 + } // end let + v14 = v15 + } else { + v14 = nil + } + v8 = v14 + } // end let + return v8 + }) + v8 := lang.Apply(lang.NewLazySeq, []any{v7}) + return v8 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // partition-all + { + v0 := lang.NewSymbol("partition-all").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of lists like partition, but may include\n partitions with fewer than n items at the end. Returns a stateful\n transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7222), lang.NewKeyword("end-line"), int(7222))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + var v4 lang.FnFunc + v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + var v6 any + { // let + // let binding "a" + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("to-array")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, []any{v3}) + v11 := lang.Apply(lang.NewArrayList, []any{v10}) + var v12 any = v11 + _ = v12 + var v13 lang.FnFunc + v13 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + v14 := lang.Apply(v5, nil) + return v14 + case 1: + v14 := args[0] + _ = v14 + var v15 any + { // let + // let binding "result" + var v16 any + v17, ok := lang.FieldOrMethod(v12, "isEmpty") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v12, "isEmpty"))) + } + var v18 any + switch reflect.TypeOf(v17).Kind() { + case reflect.Func: + v18 = lang.Apply(v17, nil) + default: + v18 = v17 + } + if lang.IsTruthy(v18) { + v16 = v14 + } else { + var v19 any + { // let + // let binding "v" + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("vec")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23, ok := lang.FieldOrMethod(v12, "toArray") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v12, "toArray"))) + } + var v24 any + switch reflect.TypeOf(v23).Kind() { + case reflect.Func: + v24 = lang.Apply(v23, nil) + default: + v24 = v23 + } + v25 := lang.Apply(v22, []any{v24}) + var v26 any = v25 + _ = v26 + v27, ok := lang.FieldOrMethod(v12, "clear") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v12, "clear"))) + } + var v28 any + switch reflect.TypeOf(v27).Kind() { + case reflect.Func: + v28 = lang.Apply(v27, nil) + default: + v28 = v27 + } + _ = v28 + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("unreduced")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.Apply(v5, []any{v14, v26}) + v33 := lang.Apply(v31, []any{v32}) + v19 = v33 + } // end let + v16 = v19 + } + var v20 any = v16 + _ = v20 + v21 := lang.Apply(v5, []any{v20}) + v15 = v21 + } // end let + return v15 + case 2: + v14 := args[0] + _ = v14 + v15 := args[1] + _ = v15 + v16, _ := lang.FieldOrMethod(v12, "add") + if reflect.TypeOf(v16).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) + } + v17 := lang.Apply(v16, []any{v15}) + _ = v17 + var v18 any + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("=")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22, ok := lang.FieldOrMethod(v12, "size") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v12, "size"))) + } + var v23 any + switch reflect.TypeOf(v22).Kind() { + case reflect.Func: + v23 = lang.Apply(v22, nil) + default: + v23 = v22 + } + v24 := lang.Apply(v21, []any{v3, v23}) + if lang.IsTruthy(v24) { + var v25 any + { // let + // let binding "v" + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("vec")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29, ok := lang.FieldOrMethod(v12, "toArray") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v12, "toArray"))) + } + var v30 any + switch reflect.TypeOf(v29).Kind() { + case reflect.Func: + v30 = lang.Apply(v29, nil) + default: + v30 = v29 + } + v31 := lang.Apply(v28, []any{v30}) + var v32 any = v31 + _ = v32 + v33, ok := lang.FieldOrMethod(v12, "clear") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v12, "clear"))) + } + var v34 any + switch reflect.TypeOf(v33).Kind() { + case reflect.Func: + v34 = lang.Apply(v33, nil) + default: + v34 = v33 + } + _ = v34 + v35 := lang.Apply(v5, []any{v14, v32}) + v25 = v35 + } // end let + v18 = v25 + } else { + v18 = v14 + } + return v18 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7231), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7247), lang.NewKeyword("end-column"), int(23)) + v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v6 = v15 + } // end let + return v6 + }) + v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7229), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7247), lang.NewKeyword("end-column"), int(25)) + v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v6 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("partition-all")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v3, v3, v4}) + return v8 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 lang.FnFunc + v6 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v7 any + { // let + // let binding "temp__0__auto__" + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("seq")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v5}) + var v12 any = v11 + _ = v12 + var v13 any + if lang.IsTruthy(v12) { + var v14 any + { // let + // let binding "s" + var v15 any = v12 + _ = v15 + var v16 any + { // let + // let binding "seg" + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("doall")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("take")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.Apply(v22, []any{v3, v15}) + v24 := lang.Apply(v19, []any{v23}) + var v25 any = v24 + _ = v25 + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("cons")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("partition-all")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("nthrest")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{v15, v4}) + v36 := lang.Apply(v31, []any{v3, v4, v35}) + v37 := lang.Apply(v28, []any{v25, v36}) + v16 = v37 + } // end let + v14 = v16 + } // end let + v13 = v14 + } else { + v13 = nil + } + v7 = v13 + } // end let + return v7 + }) + v7 := lang.Apply(lang.NewLazySeq, []any{v6}) + return v7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // partition-by + { + v0 := lang.NewSymbol("partition-by").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Applies f to each value in coll, splitting it each time f returns a\n new value. Returns a lazy seq of partitions. Returns a stateful\n transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7142), lang.NewKeyword("end-line"), int(7142))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + var v4 lang.FnFunc + v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + var v6 any + { // let + // let binding "a" + var v7 any = "unimplemented: new with non-constant class type" + _ = v7 + // let binding "pv" + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("volatile!")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{lang.NewKeyword("glojure.core/none")}) + var v12 any = v11 + _ = v12 + var v13 lang.FnFunc + v13 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + v14 := lang.Apply(v5, nil) + return v14 + case 1: + v14 := args[0] + _ = v14 + var v15 any + { // let + // let binding "result" + var v16 any + v17, ok := lang.FieldOrMethod(v7, "isEmpty") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "isEmpty"))) + } + var v18 any + switch reflect.TypeOf(v17).Kind() { + case reflect.Func: + v18 = lang.Apply(v17, nil) + default: + v18 = v17 + } + if lang.IsTruthy(v18) { + v16 = v14 + } else { + var v19 any + { // let + // let binding "v" + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("vec")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23, ok := lang.FieldOrMethod(v7, "toArray") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "toArray"))) + } + var v24 any + switch reflect.TypeOf(v23).Kind() { + case reflect.Func: + v24 = lang.Apply(v23, nil) + default: + v24 = v23 + } + v25 := lang.Apply(v22, []any{v24}) + var v26 any = v25 + _ = v26 + v27, ok := lang.FieldOrMethod(v7, "clear") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "clear"))) + } + var v28 any + switch reflect.TypeOf(v27).Kind() { + case reflect.Func: + v28 = lang.Apply(v27, nil) + default: + v28 = v27 + } + _ = v28 + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("unreduced")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.Apply(v5, []any{v14, v26}) + v33 := lang.Apply(v31, []any{v32}) + v19 = v33 + } // end let + v16 = v19 + } + var v20 any = v16 + _ = v20 + v21 := lang.Apply(v5, []any{v20}) + v15 = v21 + } // end let + return v15 + case 2: + v14 := args[0] + _ = v14 + v15 := args[1] + _ = v15 + var v16 any + { // let + // let binding "pval" + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("deref")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.Apply(v19, []any{v12}) + var v21 any = v20 + _ = v21 + // let binding "val" + v22 := lang.Apply(v3, []any{v15}) + var v23 any = v22 + _ = v23 + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("vreset!")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.Apply(v26, []any{v12, v23}) + _ = v27 + var v28 any + var v29 any + { // let + // let binding "or__0__auto__" + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("identical?")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.Apply(v32, []any{v21, lang.NewKeyword("glojure.core/none")}) + var v34 any = v33 + _ = v34 + var v35 any + if lang.IsTruthy(v34) { + v35 = v34 + } else { + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("=")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v38, []any{v23, v21}) + v35 = v39 + } + v29 = v35 + } // end let + if lang.IsTruthy(v29) { + v30, _ := lang.FieldOrMethod(v7, "add") + if reflect.TypeOf(v30).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) + } + v31 := lang.Apply(v30, []any{v15}) + _ = v31 + v28 = v14 + } else { + var v32 any + { // let + // let binding "v" + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("vec")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36, ok := lang.FieldOrMethod(v7, "toArray") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "toArray"))) + } + var v37 any + switch reflect.TypeOf(v36).Kind() { + case reflect.Func: + v37 = lang.Apply(v36, nil) + default: + v37 = v36 + } + v38 := lang.Apply(v35, []any{v37}) + var v39 any = v38 + _ = v39 + v40, ok := lang.FieldOrMethod(v7, "clear") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "clear"))) + } + var v41 any + switch reflect.TypeOf(v40).Kind() { + case reflect.Func: + v41 = lang.Apply(v40, nil) + default: + v41 = v40 + } + _ = v41 + var v42 any + { // let + // let binding "ret" + v43 := lang.Apply(v5, []any{v14, v39}) + var v44 any = v43 + _ = v44 + var v45 any + v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v47 := v46.FindInternedVar(lang.NewSymbol("reduced?")) + if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) + } + v48 := v47.Get() + v49 := lang.Apply(v48, []any{v44}) + if lang.IsTruthy(v49) { + v45 = nil + } else { + v50, _ := lang.FieldOrMethod(v7, "add") + if reflect.TypeOf(v50).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) + } + v51 := lang.Apply(v50, []any{v15}) + v45 = v51 + } + _ = v45 + v42 = v44 + } // end let + v32 = v42 + } // end let + v28 = v32 + } + v16 = v28 + } // end let + return v16 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7152), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(7176), lang.NewKeyword("end-column"), int(28)) + v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v6 = v15 + } // end let + return v6 + }) + v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7149), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(7176), lang.NewKeyword("end-column"), int(30)) + v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v6 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 lang.FnFunc + v5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v6 any + { // let + // let binding "temp__0__auto__" + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("seq")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, []any{v4}) + var v11 any = v10 + _ = v11 + var v12 any + if lang.IsTruthy(v11) { + var v13 any + { // let + // let binding "s" + var v14 any = v11 + _ = v14 + var v15 any + { // let + // let binding "fst" + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("first")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{v14}) + var v20 any = v19 + _ = v20 + // let binding "fv" + v21 := lang.Apply(v3, []any{v20}) + var v22 any = v21 + _ = v22 + // let binding "run" + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("cons")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("take-while")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + var v29 lang.FnFunc + v29 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v30 := args[0] + _ = v30 + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("=")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v3, []any{v30}) + v35 := lang.Apply(v33, []any{v22, v34}) + return v35 + }) + v30 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7182), lang.NewKeyword("column"), int(41), lang.NewKeyword("end-line"), int(7182), lang.NewKeyword("end-column"), int(53)) + v31, err := lang.WithMeta(v29, v30.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("next")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{v14}) + v36 := lang.Apply(v28, []any{v31, v35}) + v37 := lang.Apply(v25, []any{v20, v36}) + var v38 any = v37 + _ = v38 + v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v40 := v39.FindInternedVar(lang.NewSymbol("cons")) + if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) + } + v41 := v40.Get() + v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v43 := v42.FindInternedVar(lang.NewSymbol("partition-by")) + if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) + } + v44 := v43.Get() + var v45 lang.FnFunc + v45 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v47 := v46.FindInternedVar(lang.NewSymbol("drop")) + if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) + } + v48 := v47.Get() + v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v50 := v49.FindInternedVar(lang.NewSymbol("count")) + if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) + } + v51 := v50.Get() + v52 := lang.Apply(v51, []any{v38}) + v53 := lang.Apply(v48, []any{v52, v14}) + return v53 + }) + v46 := lang.Apply(lang.NewLazySeq, []any{v45}) + v47 := lang.Apply(v44, []any{v3, v46}) + v48 := lang.Apply(v41, []any{v38, v47}) + v15 = v48 + } // end let + v13 = v15 + } // end let + v12 = v13 + } else { + v12 = nil + } + v6 = v12 + } // end let + return v6 + }) + v6 := lang.Apply(lang.NewLazySeq, []any{v5}) + return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // partitionv + { + v0 := lang.NewSymbol("partitionv").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("pad"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of vectors of n items each, at offsets step\n apart. If step is not supplied, defaults to n, i.e. the partitions\n do not overlap. If a pad collection is supplied, use its elements as\n necessary to complete last partition upto n items. In case there are\n not enough padding elements, return a partition with less than n items.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7262), lang.NewKeyword("end-line"), int(7262))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("partitionv")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v3, v3, v4}) + return v8 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 lang.FnFunc + v6 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v7 any + { // let + // let binding "temp__0__auto__" + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("seq")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v5}) + var v12 any = v11 + _ = v12 + var v13 any + if lang.IsTruthy(v12) { + var v14 any + { // let + // let binding "s" + var v15 any = v12 + _ = v15 + var v16 any + { // let + // let binding "p" + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("into")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.NewVector() + v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7274), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(7274), lang.NewKeyword("end-column"), int(23)) + v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("take")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.Apply(v25, []any{v3}) + v27 := lang.Apply(v19, []any{v22, v26, v15}) + var v28 any = v27 + _ = v28 + var v29 any + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("=")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("count")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.Apply(v35, []any{v28}) + v37 := lang.Apply(v32, []any{v3, v36}) + if lang.IsTruthy(v37) { + v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v39 := v38.FindInternedVar(lang.NewSymbol("cons")) + if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + } + v40 := v39.Get() + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("partitionv")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("nthrest")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.Apply(v46, []any{v15, v4}) + v48 := lang.Apply(v43, []any{v3, v4, v47}) + v49 := lang.Apply(v40, []any{v28, v48}) + v29 = v49 + } else { + v29 = nil + } + v16 = v29 + } // end let + v14 = v16 + } // end let + v13 = v14 + } else { + v13 = nil + } + v7 = v13 + } // end let + return v7 + }) + v7 := lang.Apply(lang.NewLazySeq, []any{v6}) + return v7 + case 4: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + var v7 lang.FnFunc + v7 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v8 any + { // let + // let binding "temp__0__auto__" + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("seq")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.Apply(v11, []any{v6}) + var v13 any = v12 + _ = v13 + var v14 any + if lang.IsTruthy(v13) { + var v15 any + { // let + // let binding "s" + var v16 any = v13 + _ = v16 + var v17 any + { // let + // let binding "p" + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("into")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.NewVector() + v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7280), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(7280), lang.NewKeyword("end-column"), int(23)) + v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("take")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.Apply(v26, []any{v3}) + v28 := lang.Apply(v20, []any{v23, v27, v16}) + var v29 any = v28 + _ = v29 + var v30 any + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("=")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("count")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.Apply(v36, []any{v29}) + v38 := lang.Apply(v33, []any{v3, v37}) + if lang.IsTruthy(v38) { + v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v40 := v39.FindInternedVar(lang.NewSymbol("cons")) + if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) + } + v41 := v40.Get() + v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v43 := v42.FindInternedVar(lang.NewSymbol("partitionv")) + if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) + } + v44 := v43.Get() + v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v46 := v45.FindInternedVar(lang.NewSymbol("nthrest")) + if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) + } + v47 := v46.Get() + v48 := lang.Apply(v47, []any{v16, v4}) + v49 := lang.Apply(v44, []any{v3, v4, v5, v48}) + v50 := lang.Apply(v41, []any{v29, v49}) + v30 = v50 + } else { + v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v52 := v51.FindInternedVar(lang.NewSymbol("list")) + if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) + } + v53 := v52.Get() + v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v55 := v54.FindInternedVar(lang.NewSymbol("into")) + if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) + } + v56 := v55.Get() + v57 := lang.NewVector() + v58 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7283), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(7283), lang.NewKeyword("end-column"), int(25)) + v59, err := lang.WithMeta(v57, v58.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v61 := v60.FindInternedVar(lang.NewSymbol("take")) + if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) + } + v62 := v61.Get() + v63 := lang.Apply(v62, []any{v3}) + v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v65 := v64.FindInternedVar(lang.NewSymbol("concat")) + if v65.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) + } + v66 := v65.Get() + v67 := lang.Apply(v66, []any{v29, v5}) + v68 := lang.Apply(v56, []any{v59, v63, v67}) + v69 := lang.Apply(v53, []any{v68}) + v30 = v69 + } + v17 = v30 + } // end let + v15 = v17 + } // end let + v14 = v15 + } else { + v14 = nil + } + v8 = v14 + } // end let + return v8 + }) + v8 := lang.Apply(lang.NewLazySeq, []any{v7}) + return v8 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // partitionv-all + { + v0 := lang.NewSymbol("partitionv-all").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of vector partitions, but may include\n partitions with fewer than n items at the end.\n Returns a stateful transducer when no collection is provided.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7285), lang.NewKeyword("end-line"), int(7285))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("partition-all")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.Apply(v6, []any{v3}) + return v7 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("partitionv-all")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v3, v3, v4}) + return v8 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 lang.FnFunc + v6 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v7 any + { // let + // let binding "temp__0__auto__" + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("seq")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v5}) + var v12 any = v11 + _ = v12 + var v13 any + if lang.IsTruthy(v12) { + var v14 any + { // let + // let binding "s" + var v15 any = v12 + _ = v15 + var v16 any + { // let + // let binding "seg" + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("into")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.NewVector() + v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7297), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(7297), lang.NewKeyword("end-column"), int(25)) + v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("take")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.Apply(v25, []any{v3}) + v27 := lang.Apply(v19, []any{v22, v26, v5}) + var v28 any = v27 + _ = v28 + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("cons")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("partitionv-all")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v36 := v35.FindInternedVar(lang.NewSymbol("drop")) + if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + } + v37 := v36.Get() + v38 := lang.Apply(v37, []any{v4, v15}) + v39 := lang.Apply(v34, []any{v3, v4, v38}) + v40 := lang.Apply(v31, []any{v28, v39}) + v16 = v40 + } // end let + v14 = v16 + } // end let + v13 = v14 + } else { + v13 = nil + } + v7 = v13 + } // end let + return v7 + }) + v7 := lang.Apply(lang.NewLazySeq, []any{v6}) + return v7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // pcalls + { + v0 := lang.NewSymbol("pcalls").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("fns"))), lang.NewKeyword("doc"), "Executes the no-arg fns in parallel, returning a lazy sequence of\n their values", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7056), lang.NewKeyword("end-line"), int(7056))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := lang.NewList(args[0:]...) + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("pmap")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + var v7 lang.FnFunc + v7 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v8 := args[0] + _ = v8 + v9 := lang.Apply(v8, nil) + return v9 + }) + v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7061), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(7061), lang.NewKeyword("end-column"), int(20)) + v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v10 := lang.Apply(v6, []any{v9, v3}) + return v10 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // peek + { + v0 := lang.NewSymbol("peek").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "For a list or queue, same as first, for a vector, same as, but much\n more efficient than, last. If the collection is empty, returns nil.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1455), lang.NewKeyword("end-line"), int(1455))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4, _ := lang.FieldOrMethod(runtime4.RT, "Peek") + if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Peek is not a function"))) + } + v5 := lang.Apply(v4, []any{v3}) + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // persistent! + { + v0 := lang.NewSymbol("persistent!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a new, persistent version of the transient collection, in\n constant time. The transient collection cannot be used after this\n call, any such use will throw an exception.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3350), lang.NewKeyword("end-line"), int(3350))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4, ok := lang.FieldOrMethod(v3, "Persistent") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "Persistent"))) + } + var v5 any + switch reflect.TypeOf(v4).Kind() { + case reflect.Func: + v5 = lang.Apply(v4, nil) + default: + v5 = v4 + } + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // pmap + { + v0 := lang.NewSymbol("pmap").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Like map, except f is applied in parallel. Semi-lazy in that the\n parallel computation stays ahead of the consumption, but doesn't\n realize the entire result unless required. Only useful for\n computationally intensive functions where the time of f dominates\n the coordination overhead.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7031), lang.NewKeyword("end-line"), int(7031))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any + { // let + // let binding "n" + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("+")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(runtime11.NumCPU, nil) + v10 := lang.Apply(v8, []any{int64(2), v9}) + var v11 any = v10 + _ = v11 + // let binding "rets" + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("map")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + var v15 lang.FnFunc + v15 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v16 := args[0] + _ = v16 + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("future-call")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + var v20 lang.FnFunc + v20 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v21 := lang.Apply(v3, []any{v16}) + return v21 + }) + v21 := lang.Apply(v19, []any{v20}) + return v21 + }) + v16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7041), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7041), lang.NewKeyword("end-column"), int(34)) + v17, err := lang.WithMeta(v15, v16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v18 := lang.Apply(v14, []any{v17, v4}) + var v19 any = v18 + _ = v19 + // let binding "step" + var v20 lang.FnFunc + { // function step + v20 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v22 := args[0] + _ = v22 + v23 := args[1] + _ = v23 + var v24 any + { // let + // let binding "vec__323" + var v25 any = v22 + _ = v25 + // let binding "seq__324" + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("seq")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.Apply(v28, []any{v25}) + var v30 any = v29 + _ = v30 + // let binding "first__325" + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("first")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{v30}) + var v35 any = v34 + _ = v35 + // let binding "seq__324" + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("next")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v38, []any{v30}) + var v40 any = v39 + _ = v40 + // let binding "x" + var v41 any = v35 + _ = v41 + // let binding "xs" + var v42 any = v40 + _ = v42 + // let binding "vs" + var v43 any = v25 + _ = v43 + var v44 lang.FnFunc + v44 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v45 any + { // let + // let binding "temp__0__auto__" + v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v47 := v46.FindInternedVar(lang.NewSymbol("seq")) + if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) + } + v48 := v47.Get() + v49 := lang.Apply(v48, []any{v23}) + var v50 any = v49 + _ = v50 + var v51 any + if lang.IsTruthy(v50) { + var v52 any + { // let + // let binding "s" + var v53 any = v50 + _ = v53 + v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v55 := v54.FindInternedVar(lang.NewSymbol("cons")) + if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) + } + v56 := v55.Get() + v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v58 := v57.FindInternedVar(lang.NewSymbol("deref")) + if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) + } + v59 := v58.Get() + v60 := lang.Apply(v59, []any{v41}) + v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v62 := v61.FindInternedVar(lang.NewSymbol("rest")) + if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) + } + v63 := v62.Get() + v64 := lang.Apply(v63, []any{v53}) + v65 := lang.Apply(v21, []any{v42, v64}) + v66 := lang.Apply(v56, []any{v60, v65}) + v52 = v66 + } // end let + v51 = v52 + } else { + v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v54 := v53.FindInternedVar(lang.NewSymbol("map")) + if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) + } + v55 := v54.Get() + v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v57 := v56.FindInternedVar(lang.NewSymbol("deref")) + if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) + } + v58 := v57.Get() + v59 := lang.Apply(v55, []any{v58, v43}) + v51 = v59 + } + v45 = v51 + } // end let + return v45 + }) + v45 := lang.Apply(lang.NewLazySeq, []any{v44}) + v24 = v45 + } // end let + return v24 + }) + v21 := v20 + _ = v21 + } + v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7042), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(7046), lang.NewKeyword("end-column"), int(36)) + v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v23 any = v22 + _ = v23 + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("drop")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.Apply(v26, []any{v11, v19}) + v28 := lang.Apply(v23, []any{v19, v27}) + v5 = v28 + } // end let + return v5 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.NewList(args[2:]...) + var v6 any + { // let + // let binding "step" + var v7 lang.FnFunc + { // function step + v7 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v9 := args[0] + _ = v9 + var v10 lang.FnFunc + v10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v11 any + { // let + // let binding "ss" + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("map")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("seq")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v14, []any{v17, v9}) + var v19 any = v18 + _ = v19 + var v20 any + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("every?")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("identity")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.Apply(v23, []any{v26, v19}) + if lang.IsTruthy(v27) { + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("cons")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("map")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("first")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.Apply(v33, []any{v36, v19}) + v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v39 := v38.FindInternedVar(lang.NewSymbol("map")) + if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + } + v40 := v39.Get() + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("rest")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.Apply(v40, []any{v43, v19}) + v45 := lang.Apply(v8, []any{v44}) + v46 := lang.Apply(v30, []any{v37, v45}) + v20 = v46 + } else { + v20 = nil + } + v11 = v20 + } // end let + return v11 + }) + v11 := lang.Apply(lang.NewLazySeq, []any{v10}) + return v11 + }) + v8 := v7 + _ = v8 + } + v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7049), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(7053), lang.NewKeyword("end-column"), int(67)) + v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v10 any = v9 + _ = v10 + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("pmap")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + var v14 lang.FnFunc + v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v15 := args[0] + _ = v15 + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("apply")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{v3, v15}) + return v19 + }) + v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7054), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(7054), lang.NewKeyword("end-column"), int(23)) + v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("cons")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.Apply(v19, []any{v4, v5}) + v21 := lang.Apply(v10, []any{v20}) + v22 := lang.Apply(v13, []any{v16, v21}) + v6 = v22 + } // end let + return v6 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // pop + { + v0 := lang.NewSymbol("pop").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "For a list or queue, returns a new list/queue without the first\n item, for a vector, returns a new vector without the last item. If\n the collection is empty, throws an exception. Note - not the same\n as next/butlast.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1462), lang.NewKeyword("end-line"), int(1462))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4, _ := lang.FieldOrMethod(runtime4.RT, "Pop") + if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Pop is not a function"))) + } + v5 := lang.Apply(v4, []any{v3}) + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // pop! + { + v0 := lang.NewSymbol("pop!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Removes the last item from a transient vector. If\n the collection is empty, throws an exception. Returns coll", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3393), lang.NewKeyword("end-line"), int(3393))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4, ok := lang.FieldOrMethod(v3, "pop") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "pop"))) + } + var v5 any + switch reflect.TypeOf(v4).Kind() { + case reflect.Func: + v5 = lang.Apply(v4, nil) + default: + v5 = v4 + } + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // pop-thread-bindings + { + v0 := lang.NewSymbol("pop-thread-bindings").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Pop one set of bindings pushed with push-binding before. It is an error to\n pop bindings without pushing before.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1929), lang.NewKeyword("end-line"), int(1929))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := lang.Apply(lang.PopThreadBindings, nil) + return v3 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // pos-int? + { + v0 := lang.NewSymbol("pos-int?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a positive fixed precision integer", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1403), lang.NewKeyword("end-line"), int(1403))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + { // let + // let binding "and__0__auto__" + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("int?")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v3}) + var v9 any = v8 + _ = v9 + var v10 any + if lang.IsTruthy(v9) { + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("pos?")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{v3}) + v10 = v14 + } else { + v10 = v9 + } + v4 = v10 + } // end let + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // pos? + { + var v1 lang.FnFunc + { // function pos?__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("concat")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("list")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("seq")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("concat")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/IsPos")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{v3}) + v35 := lang.Apply(v26, []any{v30, v34}) + v36 := lang.Apply(v23, []any{v35}) + v37 := lang.Apply(v20, []any{v36}) + v38 := lang.Apply(v9, []any{v13, v17, v37}) + v39 := lang.Apply(v6, []any{v38}) + return v39 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("pos?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns true if num is greater than zero, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1252), lang.NewKeyword("end-line"), int(1252))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5, _ := lang.FieldOrMethod(lang.Numbers, "IsPos") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("IsPos is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // pr + { + v0 := lang.NewSymbol("pr").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Prints the object(s) to the output stream that is the current value\n of *out*. Prints the object(s), separated by spaces if there is\n more than one. By default, pr and prn print in a way that objects\n can be read by the reader", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3678), lang.NewKeyword("end-line"), int(3678), lang.NewKeyword("dynamic"), true)).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return nil + case 1: + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("pr-on")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("*out*")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v6, []any{v3, v9}) + return v10 + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.NewList(args[1:]...) + recur_loop_671: + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("pr")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v3}) + _ = v8 + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("*out*")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.Apply(lang.AppendWriter, []any{v11, lang.NewChar(32)}) + _ = v12 + var v13 any + { // let + // let binding "temp__0__auto__" + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("next")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{v4}) + var v18 any = v17 + _ = v18 + var v19 any + if lang.IsTruthy(v18) { + var v20 any + { // let + // let binding "nmore" + var v21 any = v18 + _ = v21 + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("first")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.Apply(v25, []any{v4}) + var v22 any = v26 + var v27 any = v21 + v3 = v22 + v4 = v27 + goto recur_loop_671 + } // end let + v19 = v20 + } else { + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("apply")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("pr")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.Apply(v23, []any{v26, v4}) + v19 = v27 + } + v13 = v19 + } // end let + return v13 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // pr-on + { + v0 := lang.NewSymbol("pr-on").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("w"))), lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3669), lang.NewKeyword("end-line"), int(3669), lang.NewKeyword("private"), true)).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("*print-dup*")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + if lang.IsTruthy(v8) { + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("print-dup")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.Apply(v11, []any{v3, v4}) + v5 = v12 + } else { + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("print-method")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{v3, v4}) + v5 = v16 + } + _ = v5 + return nil + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // pr-str + { + v1 := reflect.TypeOf("") + v0 := lang.NewSymbol("pr-str").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("xs"))), lang.NewKeyword("doc"), "pr to a string, returning it", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4758), lang.NewKeyword("end-line"), int(4758))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := lang.NewList(args[0:]...) + var v5 any + { // let + // let binding "s__0__auto__" + var v6 any = "unimplemented: new with non-constant class type" + _ = v6 + var v7 any + { // let + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("push-thread-bindings")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("hash-map")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*out*")) + v15 := lang.Apply(v13, []any{v14, v6}) + v16 := lang.Apply(v10, []any{v15}) + _ = v16 + var v17 any + func() { + defer func() { + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.Apply(v20, nil) + }() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("apply")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("pr")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.Apply(v24, []any{v27, v4}) + _ = v28 + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("str")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.Apply(v31, []any{v6}) + v17 = v32 + }() + v7 = v17 + } // end let + v5 = v7 + } // end let + return v5 + } + }) + v4 := reflect.TypeOf("") + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // prefer-method + { + v0 := lang.NewSymbol("prefer-method").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"), lang.NewSymbol("dispatch-val-x"), lang.NewSymbol("dispatch-val-y"))), lang.NewKeyword("doc"), "Causes the multimethod to prefer matches of dispatch-val-x over dispatch-val-y \n when there is a conflict", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1801), lang.NewKeyword("end-line"), int(1801))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6, _ := lang.FieldOrMethod(v3, "PreferMethod") + if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("PreferMethod is not a function"))) + } + v7 := lang.Apply(v6, []any{v4, v5}) + return v7 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // prefers + { + v0 := lang.NewSymbol("prefers").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"))), lang.NewKeyword("doc"), "Given a multimethod, returns a map of preferred value -> set of other values", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1822), lang.NewKeyword("end-line"), int(1822))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4, ok := lang.FieldOrMethod(v3, "getPreferTable") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getPreferTable"))) + } + var v5 any + switch reflect.TypeOf(v4).Kind() { + case reflect.Func: + v5 = lang.Apply(v4, nil) + default: + v5 = v4 + } + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // prep-hashes + { + v0 := lang.NewSymbol("prep-hashes").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr-sym"), lang.NewSymbol("default"), lang.NewSymbol("tests"), lang.NewSymbol("thens"))), lang.NewKeyword("doc"), "Takes a sequence of test constants and a corresponding sequence of then\n expressions. Returns a tuple of [shift mask case-map switch-type skip-check]\n where case-map is a map of int case values to [test then] tuples, switch-type\n is either :sparse or :compact, and skip-check is a set of case ints for which\n post-switch equivalence checking must not be done (occurs with hash\n collisions).", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6683), lang.NewKeyword("end-line"), int(6683), lang.NewKeyword("private"), true)).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + var v7 any + { // let + // let binding "hashcode" + var v8 lang.FnFunc + v8 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v9 := args[0] + _ = v9 + v10 := lang.Apply(lang.Hash, []any{v9}) + return v10 + }) + v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6691), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(6691), lang.NewKeyword("end-column"), int(66)) + v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v11 any = v10 + _ = v11 + // let binding "hashes" + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("into1")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.CreatePersistentTreeSet() + v16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6692), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(6692), lang.NewKeyword("end-column"), int(25)) + v17, err := lang.WithMeta(v15, v16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("map")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.Apply(v20, []any{v11, v5}) + v22 := lang.Apply(v14, []any{v17, v21}) + var v23 any = v22 + _ = v23 + var v24 any + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("==")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("count")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.Apply(v30, []any{v5}) + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("count")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{v23}) + v36 := lang.Apply(v27, []any{v31, v35}) + if lang.IsTruthy(v36) { + var v37 any + v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v39 := v38.FindInternedVar(lang.NewSymbol("fits-table?")) + if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + } + v40 := v39.Get() + v41 := lang.Apply(v40, []any{v23}) + if lang.IsTruthy(v41) { + v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v43 := v42.FindInternedVar(lang.NewSymbol("case-map")) + if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) + } + v44 := v43.Get() + v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v46 := v45.FindInternedVar(lang.NewSymbol("identity")) + if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) + } + v47 := v46.Get() + v48 := lang.Apply(v44, []any{v11, v47, v5, v6}) + v49 := lang.NewVector(int64(0), int64(0), v48, lang.NewKeyword("compact")) + v50 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6696), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(6696), lang.NewKeyword("end-column"), int(63)) + v51, err := lang.WithMeta(v49, v50.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v37 = v51 + } else { + var v52 any + { // let + // let binding "vec__167" + var v53 any + { // let + // let binding "or__0__auto__" + v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v55 := v54.FindInternedVar(lang.NewSymbol("maybe-min-hash")) + if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) + } + v56 := v55.Get() + v57 := lang.Apply(v56, []any{v23}) + var v58 any = v57 + _ = v58 + var v59 any + if lang.IsTruthy(v58) { + v59 = v58 + } else { + v60 := lang.NewVector(int64(0), int64(0)) + v61 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6697), lang.NewKeyword("column"), int(56), lang.NewKeyword("end-line"), int(6697), lang.NewKeyword("end-column"), int(60)) + v62, err := lang.WithMeta(v60, v61.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v59 = v62 + } + v53 = v59 + } // end let + var v54 any = v53 + _ = v54 + // let binding "shift" + v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v56 := v55.FindInternedVar(lang.NewSymbol("nth")) + if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) + } + v57 := v56.Get() + v58 := lang.Apply(v57, []any{v54, int64(0), nil}) + var v59 any = v58 + _ = v59 + // let binding "mask" + v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v61 := v60.FindInternedVar(lang.NewSymbol("nth")) + if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) + } + v62 := v61.Get() + v63 := lang.Apply(v62, []any{v54, int64(1), nil}) + var v64 any = v63 + _ = v64 + var v65 any + v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v67 := v66.FindInternedVar(lang.NewSymbol("zero?")) + if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) + } + v68 := v67.Get() + v69 := lang.Apply(v68, []any{v64}) + if lang.IsTruthy(v69) { + v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v71 := v70.FindInternedVar(lang.NewSymbol("case-map")) + if v71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) + } + v72 := v71.Get() + v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v74 := v73.FindInternedVar(lang.NewSymbol("identity")) + if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) + } + v75 := v74.Get() + v76 := lang.Apply(v72, []any{v11, v75, v5, v6}) + v77 := lang.NewVector(int64(0), int64(0), v76, lang.NewKeyword("sparse")) + v78 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6700), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(6700), lang.NewKeyword("end-column"), int(66)) + v79, err := lang.WithMeta(v77, v78.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v65 = v79 + } else { + v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v81 := v80.FindInternedVar(lang.NewSymbol("case-map")) + if v81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) + } + v82 := v81.Get() + var v83 lang.FnFunc + v83 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v84 := args[0] + _ = v84 + v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v86 := v85.FindInternedVar(lang.NewSymbol("shift-mask")) + if v86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) + } + v87 := v86.Get() + v88 := lang.Apply(v11, []any{v84}) + v89 := lang.Apply(v87, []any{v59, v64, v88}) + return v89 + }) + v84 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6702), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(6702), lang.NewKeyword("end-column"), int(71)) + v85, err := lang.WithMeta(v83, v84.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v87 := v86.FindInternedVar(lang.NewSymbol("identity")) + if v87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) + } + v88 := v87.Get() + v89 := lang.Apply(v82, []any{v85, v88, v5, v6}) + v90 := lang.NewVector(v59, v64, v89, lang.NewKeyword("compact")) + v91 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6702), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(6702), lang.NewKeyword("end-column"), int(103)) + v92, err := lang.WithMeta(v90, v91.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v65 = v92 + } + v52 = v65 + } // end let + v37 = v52 + } + v24 = v37 + } else { + var v53 any + { // let + // let binding "vec__170" + v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v55 := v54.FindInternedVar(lang.NewSymbol("merge-hash-collisions")) + if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) + } + v56 := v55.Get() + v57 := lang.Apply(v56, []any{v3, v4, v5, v6}) + var v58 any = v57 + _ = v58 + // let binding "tests" + v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v60 := v59.FindInternedVar(lang.NewSymbol("nth")) + if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) + } + v61 := v60.Get() + v62 := lang.Apply(v61, []any{v58, int64(0), nil}) + var v63 any = v62 + _ = v63 + // let binding "thens" + v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v65 := v64.FindInternedVar(lang.NewSymbol("nth")) + if v65.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) + } + v66 := v65.Get() + v67 := lang.Apply(v66, []any{v58, int64(1), nil}) + var v68 any = v67 + _ = v68 + // let binding "skip-check" + v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v70 := v69.FindInternedVar(lang.NewSymbol("nth")) + if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) + } + v71 := v70.Get() + v72 := lang.Apply(v71, []any{v58, int64(2), nil}) + var v73 any = v72 + _ = v73 + // let binding "vec__173" + v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v75 := v74.FindInternedVar(lang.NewSymbol("prep-hashes")) + if v75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) + } + v76 := v75.Get() + v77 := lang.Apply(v76, []any{v3, v4, v63, v68}) + var v78 any = v77 + _ = v78 + // let binding "shift" + v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v80 := v79.FindInternedVar(lang.NewSymbol("nth")) + if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) + } + v81 := v80.Get() + v82 := lang.Apply(v81, []any{v78, int64(0), nil}) + var v83 any = v82 + _ = v83 + // let binding "mask" + v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v85 := v84.FindInternedVar(lang.NewSymbol("nth")) + if v85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) + } + v86 := v85.Get() + v87 := lang.Apply(v86, []any{v78, int64(1), nil}) + var v88 any = v87 + _ = v88 + // let binding "case-map" + v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v90 := v89.FindInternedVar(lang.NewSymbol("nth")) + if v90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) + } + v91 := v90.Get() + v92 := lang.Apply(v91, []any{v78, int64(2), nil}) + var v93 any = v92 + _ = v93 + // let binding "switch-type" + v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v95 := v94.FindInternedVar(lang.NewSymbol("nth")) + if v95.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) + } + v96 := v95.Get() + v97 := lang.Apply(v96, []any{v78, int64(3), nil}) + var v98 any = v97 + _ = v98 + // let binding "skip-check" + var v99 any + v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v101 := v100.FindInternedVar(lang.NewSymbol("zero?")) + if v101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) + } + v102 := v101.Get() + v103 := lang.Apply(v102, []any{v88}) + if lang.IsTruthy(v103) { + v99 = v73 + } else { + v104 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v105 := v104.FindInternedVar(lang.NewSymbol("into1")) + if v105.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v105))) + } + v106 := v105.Get() + v107 := lang.CreatePersistentTreeSet() + v108 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6708), lang.NewKeyword("column"), int(33), lang.NewKeyword("end-line"), int(6708), lang.NewKeyword("end-column"), int(35)) + v109, err := lang.WithMeta(v107, v108.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v111 := v110.FindInternedVar(lang.NewSymbol("map")) + if v111.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v111))) + } + v112 := v111.Get() + var v113 lang.FnFunc + v113 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v114 := args[0] + _ = v114 + v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v116 := v115.FindInternedVar(lang.NewSymbol("shift-mask")) + if v116.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) + } + v117 := v116.Get() + v118 := lang.Apply(v117, []any{v83, v88, v114}) + return v118 + }) + v114 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6708), lang.NewKeyword("column"), int(42), lang.NewKeyword("end-line"), int(6708), lang.NewKeyword("end-column"), int(67)) + v115, err := lang.WithMeta(v113, v114.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v116 := lang.Apply(v112, []any{v115, v73}) + v117 := lang.Apply(v106, []any{v109, v116}) + v99 = v117 + } + var v118 any = v99 + _ = v118 + v119 := lang.NewVector(v83, v88, v93, v98, v118) + v120 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6709), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(6709), lang.NewKeyword("end-column"), int(52)) + v121, err := lang.WithMeta(v119, v120.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v53 = v121 + } // end let + v24 = v53 + } + v7 = v24 + } // end let + return v7 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // prep-ints + { + v0 := lang.NewSymbol("prep-ints").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tests"), lang.NewSymbol("thens"))), lang.NewKeyword("doc"), "Takes a sequence of int-sized test constants and a corresponding sequence of\n then expressions. Returns a tuple of [shift mask case-map switch-type] where\n case-map is a map of int case values to [test then] tuples, and switch-type\n is either :sparse or :compact.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6631), lang.NewKeyword("end-line"), int(6631), lang.NewKeyword("private"), true)).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("fits-table?")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{v3}) + if lang.IsTruthy(v9) { + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("case-map")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("int")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("int")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v12, []any{v15, v18, v3, v4}) + v20 := lang.NewVector(int64(0), int64(0), v19, lang.NewKeyword("compact")) + v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6639), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(6639), lang.NewKeyword("end-column"), int(49)) + v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v5 = v22 + } else { + var v23 any + { // let + // let binding "vec__160" + var v24 any + { // let + // let binding "or__0__auto__" + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("maybe-min-hash")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("map")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("int")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v30, []any{v33, v3}) + v35 := lang.Apply(v27, []any{v34}) + var v36 any = v35 + _ = v36 + var v37 any + if lang.IsTruthy(v36) { + v37 = v36 + } else { + v38 := lang.NewVector(int64(0), int64(0)) + v39 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6640), lang.NewKeyword("column"), int(61), lang.NewKeyword("end-line"), int(6640), lang.NewKeyword("end-column"), int(65)) + v40, err := lang.WithMeta(v38, v39.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v37 = v40 + } + v24 = v37 + } // end let + var v25 any = v24 + _ = v25 + // let binding "shift" + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("nth")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.Apply(v28, []any{v25, int64(0), nil}) + var v30 any = v29 + _ = v30 + // let binding "mask" + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("nth")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{v25, int64(1), nil}) + var v35 any = v34 + _ = v35 + var v36 any + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("zero?")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.Apply(v39, []any{v35}) + if lang.IsTruthy(v40) { + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("case-map")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("int")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v48 := v47.FindInternedVar(lang.NewSymbol("int")) + if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) + } + v49 := v48.Get() + v50 := lang.Apply(v43, []any{v46, v49, v3, v4}) + v51 := lang.NewVector(int64(0), int64(0), v50, lang.NewKeyword("sparse")) + v52 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6643), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(6643), lang.NewKeyword("end-column"), int(52)) + v53, err := lang.WithMeta(v51, v52.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v36 = v53 + } else { + v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v55 := v54.FindInternedVar(lang.NewSymbol("case-map")) + if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) + } + v56 := v55.Get() + var v57 lang.FnFunc + v57 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v58 := args[0] + _ = v58 + v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v60 := v59.FindInternedVar(lang.NewSymbol("shift-mask")) + if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) + } + v61 := v60.Get() + v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v63 := v62.FindInternedVar(lang.NewSymbol("int")) + if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) + } + v64 := v63.Get() + v65 := lang.Apply(v64, []any{v58}) + v66 := lang.Apply(v61, []any{v30, v35, v65}) + return v66 + }) + v58 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6645), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(6645), lang.NewKeyword("end-column"), int(62)) + v59, err := lang.WithMeta(v57, v58.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v61 := v60.FindInternedVar(lang.NewSymbol("int")) + if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) + } + v62 := v61.Get() + v63 := lang.Apply(v56, []any{v59, v62, v3, v4}) + v64 := lang.NewVector(v30, v35, v63, lang.NewKeyword("compact")) + v65 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6645), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(6645), lang.NewKeyword("end-column"), int(89)) + v66, err := lang.WithMeta(v64, v65.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v36 = v66 + } + v23 = v36 + } // end let + v5 = v23 + } + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // prependss + { + v0 := lang.NewSymbol("prependss").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Prepends a symbol or a seq to coll", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5857), lang.NewKeyword("end-line"), int(5857), lang.NewKeyword("private"), true)).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("symbol?")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{v3}) + if lang.IsTruthy(v9) { + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("cons")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{v3, v4}) + v5 = v13 + } else { + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("concat")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{v3, v4}) + v5 = v17 + } + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // preserving-reduced + { + v0 := lang.NewSymbol("preserving-reduced").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7638), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(7638), lang.NewKeyword("end-column"), int(34), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rf"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 lang.FnFunc + v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + var v7 any + { // let + // let binding "ret" + v8 := lang.Apply(v3, []any{v5, v6}) + var v9 any = v8 + _ = v9 + var v10 any + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("reduced?")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{v9}) + if lang.IsTruthy(v14) { + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("reduced")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{v9}) + v10 = v18 + } else { + v10 = v9 + } + v7 = v10 + } // end let + return v7 + }) + v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7640), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(7643), lang.NewKeyword("end-column"), int(12)) + v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v6 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // print + { + v0 := lang.NewSymbol("print").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Prints the object(s) to the output stream that is the current value\n of *out*. print and println produce output for human consumption.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3725), lang.NewKeyword("end-line"), int(3725))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := lang.NewList(args[0:]...) + var v4 any + { // let + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("push-thread-bindings")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("hash-map")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*print-readably*")) + v12 := lang.Apply(v10, []any{v11, nil}) + v13 := lang.Apply(v7, []any{v12}) + _ = v13 + var v14 any + func() { + defer func() { + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, nil) + }() + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("apply")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("pr")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v21, []any{v24, v3}) + v14 = v25 + }() + v4 = v14 + } // end let + return v4 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // print-ctor + { + v0 := lang.NewSymbol("print-ctor").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(95), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(95), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("print-args"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.Apply(lang.WriteWriter, []any{v5, "#=("}) + _ = v6 + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("class")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, []any{v3}) + v11, ok := lang.FieldOrMethod(v10, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v10, "Name"))) + } + var v12 any + switch reflect.TypeOf(v11).Kind() { + case reflect.Func: + v12 = lang.Apply(v11, nil) + default: + v12 = v11 + } + v13 := lang.Apply(lang.WriteWriter, []any{v5, v12}) + _ = v13 + v14 := lang.Apply(lang.WriteWriter, []any{v5, ". "}) + _ = v14 + v15 := lang.Apply(v4, []any{v3, v5}) + _ = v15 + v16 := lang.Apply(lang.WriteWriter, []any{v5, ")"}) + return v16 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // print-dup + { + v0 := lang.NewSymbol("print-dup").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3667), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(3667), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + v1 := ns.InternWithValue(v0, nil, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // print-initialized + { + v0 := lang.NewSymbol("print-initialized").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(520), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(520), lang.NewKeyword("end-column"), int(39), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + v1 := ns.InternWithValue(v0, true, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // print-map + { + v0 := lang.NewSymbol("print-map").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(252), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(252), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("print-one"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("print-prefix-map")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{nil, v3, v4, v5}) + return v9 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // print-meta + { + v0 := lang.NewSymbol("print-meta").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(70), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(70), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any + { // let + // let binding "temp__0__auto__" + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("meta")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{v3}) + var v10 any = v9 + _ = v10 + var v11 any + if lang.IsTruthy(v10) { + var v12 any + { // let + // let binding "m" + var v13 any = v10 + _ = v13 + var v14 any + var v15 any + { // let + // let binding "and__0__auto__" + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("pos?")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("count")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{v13}) + v23 := lang.Apply(v18, []any{v22}) + var v24 any = v23 + _ = v24 + var v25 any + if lang.IsTruthy(v24) { + var v26 any + { // let + // let binding "or__0__auto__" + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("*print-dup*")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + var v30 any = v29 + _ = v30 + var v31 any + if lang.IsTruthy(v30) { + v31 = v30 + } else { + var v32 any + { // let + // let binding "and__0__auto__" + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("*print-meta*")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + var v36 any = v35 + _ = v36 + var v37 any + if lang.IsTruthy(v36) { + v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v39 := v38.FindInternedVar(lang.NewSymbol("*print-readably*")) + if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + } + v40 := v39.Get() + v37 = v40 + } else { + v37 = v36 + } + v32 = v37 + } // end let + v31 = v32 + } + v26 = v31 + } // end let + v25 = v26 + } else { + v25 = v24 + } + v15 = v25 + } // end let + if lang.IsTruthy(v15) { + v16 := lang.Apply(lang.WriteWriter, []any{v4, "^"}) + _ = v16 + var v17 any + var v18 any + { // let + // let binding "and__0__auto__" + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("=")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("count")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v13}) + v26 := lang.Apply(v21, []any{v25, int64(1)}) + var v27 any = v26 + _ = v27 + var v28 any + if lang.IsTruthy(v27) { + v29 := lang.Apply(lang.NewKeyword("tag"), []any{v13}) + v28 = v29 + } else { + v28 = v27 + } + v18 = v28 + } // end let + if lang.IsTruthy(v18) { + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("pr-on")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(lang.NewKeyword("tag"), []any{v13}) + v23 := lang.Apply(v21, []any{v22, v4}) + v17 = v23 + } else { + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("pr-on")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.Apply(v26, []any{v13, v4}) + v17 = v27 + } + _ = v17 + v28 := lang.Apply(lang.WriteWriter, []any{v4, " "}) + v14 = v28 + } else { + v14 = nil + } + v12 = v14 + } // end let + v11 = v12 + } else { + v11 = nil + } + v5 = v11 + } // end let + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // print-method + { + v0 := lang.NewSymbol("print-method").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3664), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(3664), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + v1 := ns.InternWithValue(v0, nil, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // print-object + { + v0 := lang.NewSymbol("print-object").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(115), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(115), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("print-tagged-object")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("str")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v3}) + v12 := lang.Apply(v7, []any{v3, v11, v4}) + return v12 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // print-prefix-map + { + v0 := lang.NewSymbol("print-prefix-map").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(243), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(243), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("prefix"), lang.NewSymbol("kvs"), lang.NewSymbol("print-one"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("print-sequential")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("str")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{v3, "{"}) + var v14 lang.FnFunc + v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v15 := args[0] + _ = v15 + v16 := args[1] + _ = v16 + var v17 any + { // let + // let binding "vec__212" + var v18 any = v15 + _ = v18 + // let binding "k" + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("nth")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{v18, int64(0), nil}) + var v23 any = v22 + _ = v23 + // let binding "v" + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("nth")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.Apply(v26, []any{v18, int64(1), nil}) + var v28 any = v27 + _ = v28 + v29 := lang.Apply(v5, []any{v23, v16}) + _ = v29 + v30 := lang.Apply(lang.AppendWriter, []any{v16, lang.NewChar(32)}) + _ = v30 + v31 := lang.Apply(v5, []any{v28, v16}) + v17 = v31 + } // end let + return v17 + }) + v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(246), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(247), lang.NewKeyword("end-column"), int(107)) + v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v17 := lang.Apply(v9, []any{v13, v16, ", ", "}", v4, v6}) + return v17 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // print-sequential + { + v0 := lang.NewSymbol("print-sequential").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(46), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(46), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("begin"), lang.NewSymbol("print-one"), lang.NewSymbol("sep"), lang.NewSymbol("end"), lang.NewSymbol("sequence"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 6 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := args[4] + _ = v7 + v8 := args[5] + _ = v8 + var v9 any + { // let + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("push-thread-bindings")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("hash-map")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*print-level*")) + var v17 any + { // let + // let binding "and__0__auto__" + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("not")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("*print-dup*")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.Apply(v20, []any{v23}) + var v25 any = v24 + _ = v25 + var v26 any + if lang.IsTruthy(v25) { + var v27 any + { // let + // let binding "and__0__auto__" + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("*print-level*")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + var v31 any = v30 + _ = v31 + var v32 any + if lang.IsTruthy(v31) { + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("dec")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("*print-level*")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v35, []any{v38}) + v32 = v39 + } else { + v32 = v31 + } + v27 = v32 + } // end let + v26 = v27 + } else { + v26 = v25 + } + v17 = v26 + } // end let + v18 := lang.Apply(v15, []any{v16, v17}) + v19 := lang.Apply(v12, []any{v18}) + _ = v19 + var v20 any + func() { + defer func() { + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.Apply(v23, nil) + }() + var v25 any + var v26 any + { // let + // let binding "and__0__auto__" + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("*print-level*")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + var v30 any = v29 + _ = v30 + var v31 any + if lang.IsTruthy(v30) { + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("neg?")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v36 := v35.FindInternedVar(lang.NewSymbol("*print-level*")) + if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + } + v37 := v36.Get() + v38 := lang.Apply(v34, []any{v37}) + v31 = v38 + } else { + v31 = v30 + } + v26 = v31 + } // end let + if lang.IsTruthy(v26) { + v27 := lang.Apply(lang.WriteWriter, []any{v8, "#"}) + v25 = v27 + } else { + v28 := lang.Apply(lang.WriteWriter, []any{v8, v3}) + _ = v28 + var v29 any + { // let + // let binding "temp__0__auto__" + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("seq")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.Apply(v32, []any{v7}) + var v34 any = v33 + _ = v34 + var v35 any + if lang.IsTruthy(v34) { + var v36 any + { // let + // let binding "xs" + var v37 any = v34 + _ = v37 + var v38 any + var v39 any + { // let + // let binding "and__0__auto__" + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("not")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v44 := v43.FindInternedVar(lang.NewSymbol("*print-dup*")) + if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) + } + v45 := v44.Get() + v46 := lang.Apply(v42, []any{v45}) + var v47 any = v46 + _ = v47 + var v48 any + if lang.IsTruthy(v47) { + v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v50 := v49.FindInternedVar(lang.NewSymbol("*print-length*")) + if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) + } + v51 := v50.Get() + v48 = v51 + } else { + v48 = v47 + } + v39 = v48 + } // end let + if lang.IsTruthy(v39) { + var v40 any + { // let + // let binding "G__194" + var v41 any = v37 + _ = v41 + // let binding "vec__195" + var v42 any = v41 + _ = v42 + // let binding "seq__196" + v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v44 := v43.FindInternedVar(lang.NewSymbol("seq")) + if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) + } + v45 := v44.Get() + v46 := lang.Apply(v45, []any{v42}) + var v47 any = v46 + _ = v47 + // let binding "first__197" + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("first")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v47}) + var v52 any = v51 + _ = v52 + // let binding "seq__196" + v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v54 := v53.FindInternedVar(lang.NewSymbol("next")) + if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) + } + v55 := v54.Get() + v56 := lang.Apply(v55, []any{v47}) + var v57 any = v56 + _ = v57 + // let binding "x" + var v58 any = v52 + _ = v58 + // let binding "xs" + var v59 any = v57 + _ = v59 + // let binding "print-length" + v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v61 := v60.FindInternedVar(lang.NewSymbol("*print-length*")) + if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) + } + v62 := v61.Get() + var v63 any = v62 + _ = v63 + var v64 any + { // let + // let binding "G__194" + var v65 any = v41 + _ = v65 + // let binding "print-length" + var v66 any = v63 + _ = v66 + for { + var v67 any + { // let + // let binding "vec__198" + var v68 any = v65 + _ = v68 + // let binding "seq__199" + v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v70 := v69.FindInternedVar(lang.NewSymbol("seq")) + if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) + } + v71 := v70.Get() + v72 := lang.Apply(v71, []any{v68}) + var v73 any = v72 + _ = v73 + // let binding "first__200" + v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v75 := v74.FindInternedVar(lang.NewSymbol("first")) + if v75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) + } + v76 := v75.Get() + v77 := lang.Apply(v76, []any{v73}) + var v78 any = v77 + _ = v78 + // let binding "seq__199" + v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v80 := v79.FindInternedVar(lang.NewSymbol("next")) + if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) + } + v81 := v80.Get() + v82 := lang.Apply(v81, []any{v73}) + var v83 any = v82 + _ = v83 + // let binding "x" + var v84 any = v78 + _ = v84 + // let binding "xs" + var v85 any = v83 + _ = v85 + // let binding "print-length" + var v86 any = v66 + _ = v86 + var v87 any + v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v89 := v88.FindInternedVar(lang.NewSymbol("zero?")) + if v89.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) + } + v90 := v89.Get() + v91 := lang.Apply(v90, []any{v86}) + if lang.IsTruthy(v91) { + v92 := lang.Apply(lang.WriteWriter, []any{v8, "..."}) + v87 = v92 + } else { + v93 := lang.Apply(v4, []any{v84, v8}) + _ = v93 + var v94 any + if lang.IsTruthy(v85) { + v95 := lang.Apply(lang.WriteWriter, []any{v8, v5}) + _ = v95 + var v96 any = v85 + v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v99 := v98.FindInternedVar(lang.NewSymbol("dec")) + if v99.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) + } + v100 := v99.Get() + v101 := lang.Apply(v100, []any{v86}) + var v97 any = v101 + v65 = v96 + v66 = v97 + continue + } else { + v94 = nil + } + v87 = v94 + } + v67 = v87 + } // end let + v64 = v67 + break + } + } // end let + v40 = v64 + } // end let + v38 = v40 + } else { + var v41 any + { // let + // let binding "G__204" + var v42 any = v37 + _ = v42 + // let binding "vec__205" + var v43 any = v42 + _ = v43 + // let binding "seq__206" + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("seq")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.Apply(v46, []any{v43}) + var v48 any = v47 + _ = v48 + // let binding "first__207" + v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v50 := v49.FindInternedVar(lang.NewSymbol("first")) + if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) + } + v51 := v50.Get() + v52 := lang.Apply(v51, []any{v48}) + var v53 any = v52 + _ = v53 + // let binding "seq__206" + v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v55 := v54.FindInternedVar(lang.NewSymbol("next")) + if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) + } + v56 := v55.Get() + v57 := lang.Apply(v56, []any{v48}) + var v58 any = v57 + _ = v58 + // let binding "x" + var v59 any = v53 + _ = v59 + // let binding "xs" + var v60 any = v58 + _ = v60 + var v61 any + { // let + // let binding "G__204" + var v62 any = v42 + _ = v62 + for { + var v63 any + { // let + // let binding "vec__208" + var v64 any = v62 + _ = v64 + // let binding "seq__209" + v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v66 := v65.FindInternedVar(lang.NewSymbol("seq")) + if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) + } + v67 := v66.Get() + v68 := lang.Apply(v67, []any{v64}) + var v69 any = v68 + _ = v69 + // let binding "first__210" + v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v71 := v70.FindInternedVar(lang.NewSymbol("first")) + if v71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) + } + v72 := v71.Get() + v73 := lang.Apply(v72, []any{v69}) + var v74 any = v73 + _ = v74 + // let binding "seq__209" + v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v76 := v75.FindInternedVar(lang.NewSymbol("next")) + if v76.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) + } + v77 := v76.Get() + v78 := lang.Apply(v77, []any{v69}) + var v79 any = v78 + _ = v79 + // let binding "x" + var v80 any = v74 + _ = v80 + // let binding "xs" + var v81 any = v79 + _ = v81 + v82 := lang.Apply(v4, []any{v80, v8}) + _ = v82 + var v83 any + if lang.IsTruthy(v81) { + v84 := lang.Apply(lang.WriteWriter, []any{v8, v5}) + _ = v84 + var v85 any = v81 + v62 = v85 + continue + } else { + v83 = nil + } + v63 = v83 + } // end let + v61 = v63 + break + } + } // end let + v41 = v61 + } // end let + v38 = v41 + } + v36 = v38 + } // end let + v35 = v36 + } else { + v35 = nil + } + v29 = v35 + } // end let + _ = v29 + v30 := lang.Apply(lang.WriteWriter, []any{v8, v6}) + v25 = v30 + } + v20 = v25 + }() + v9 = v20 + } // end let + return v9 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // print-simple + { + v0 := lang.NewSymbol("print-simple").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(81), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(81), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("print-meta")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v3, v4}) + _ = v8 + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("str")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.Apply(v11, []any{v3}) + v13 := lang.Apply(lang.WriteWriter, []any{v4, v12}) + return v13 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // print-str + { + v1 := reflect.TypeOf("") + v0 := lang.NewSymbol("print-str").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("xs"))), lang.NewKeyword("doc"), "print to a string, returning it", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4776), lang.NewKeyword("end-line"), int(4776))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := lang.NewList(args[0:]...) + var v5 any + { // let + // let binding "s__0__auto__" + var v6 any = "unimplemented: new with non-constant class type" + _ = v6 + var v7 any + { // let + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("push-thread-bindings")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("hash-map")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*out*")) + v15 := lang.Apply(v13, []any{v14, v6}) + v16 := lang.Apply(v10, []any{v15}) + _ = v16 + var v17 any + func() { + defer func() { + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.Apply(v20, nil) + }() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("apply")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("print")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.Apply(v24, []any{v27, v4}) + _ = v28 + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("str")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.Apply(v31, []any{v6}) + v17 = v32 + }() + v7 = v17 + } // end let + v5 = v7 + } // end let + return v5 + } + }) + v4 := reflect.TypeOf("") + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // print-tagged-object + { + v0 := lang.NewSymbol("print-tagged-object").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(102), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(102), lang.NewKeyword("end-column"), int(26), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("rep"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("instance?")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, []any{lang.IMeta, v3}) + if lang.IsTruthy(v10) { + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("print-meta")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{v3, v5}) + v6 = v14 + } else { + v6 = nil + } + _ = v6 + v15 := lang.Apply(lang.WriteWriter, []any{v5, "#object["}) + _ = v15 + var v16 any + { // let + // let binding "c" + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("class")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.Apply(v19, []any{v3}) + var v21 any = v20 + _ = v21 + var v22 any + if lang.IsTruthy(false) { + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("print-method")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26, ok := lang.FieldOrMethod(v21, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v21, "Name"))) + } + var v27 any + switch reflect.TypeOf(v26).Kind() { + case reflect.Func: + v27 = lang.Apply(v26, nil) + default: + v27 = v26 + } + v28 := lang.Apply(v25, []any{v27, v5}) + v22 = v28 + } else { + v29, ok := lang.FieldOrMethod(v21, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v21, "Name"))) + } + var v30 any + switch reflect.TypeOf(v29).Kind() { + case reflect.Func: + v30 = lang.Apply(v29, nil) + default: + v30 = v29 + } + v31 := lang.Apply(lang.WriteWriter, []any{v5, v30}) + v22 = v31 + } + v16 = v22 + } // end let + _ = v16 + v17 := lang.Apply(lang.WriteWriter, []any{v5, " "}) + _ = v17 + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("format")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.Apply(lang.IdentityHash, []any{v3}) + v22 := lang.Apply(v20, []any{"0x%x ", v21}) + v23 := lang.Apply(lang.WriteWriter, []any{v5, v22}) + _ = v23 + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("print-method")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.Apply(v26, []any{v4, v5}) + _ = v27 + v28 := lang.Apply(lang.WriteWriter, []any{v5, "]"}) + return v28 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // print-throwable + { + v0 := lang.NewSymbol("print-throwable").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(478), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(478), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.Apply(lang.WriteWriter, []any{v4, "#error {\n :cause "}) + _ = v5 + var v6 any + { // let + // let binding "map__253" + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("Throwable->map")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, []any{v3}) + var v11 any = v10 + _ = v11 + // let binding "map__253" + var v12 any + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("seq?")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{v11}) + if lang.IsTruthy(v16) { + var v17 any + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("next")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.Apply(v20, []any{v11}) + if lang.IsTruthy(v21) { + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("to-array")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v11}) + v26 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{v25}) + v17 = v26 + } else { + var v27 any + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("seq")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.Apply(v30, []any{v11}) + if lang.IsTruthy(v31) { + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("first")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{v11}) + v27 = v35 + } else { + v27 = nil + } + v17 = v27 + } + v12 = v17 + } else { + v12 = v11 + } + var v36 any = v12 + _ = v36 + // let binding "cause" + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("get")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.Apply(v39, []any{v36, lang.NewKeyword("cause")}) + var v41 any = v40 + _ = v41 + // let binding "data" + v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v43 := v42.FindInternedVar(lang.NewSymbol("get")) + if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) + } + v44 := v43.Get() + v45 := lang.Apply(v44, []any{v36, lang.NewKeyword("data")}) + var v46 any = v45 + _ = v46 + // let binding "via" + v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v48 := v47.FindInternedVar(lang.NewSymbol("get")) + if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) + } + v49 := v48.Get() + v50 := lang.Apply(v49, []any{v36, lang.NewKeyword("via")}) + var v51 any = v50 + _ = v51 + // let binding "trace" + v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v53 := v52.FindInternedVar(lang.NewSymbol("get")) + if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) + } + v54 := v53.Get() + v55 := lang.Apply(v54, []any{v36, lang.NewKeyword("trace")}) + var v56 any = v55 + _ = v56 + // let binding "print-via" + var v57 lang.FnFunc + v57 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v58 := args[0] + _ = v58 + v59 := lang.Apply(lang.WriteWriter, []any{v4, "{:type "}) + _ = v59 + v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v61 := v60.FindInternedVar(lang.NewSymbol("print-method")) + if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) + } + v62 := v61.Get() + v63 := lang.Apply(lang.NewKeyword("type"), []any{v58}) + v64 := lang.Apply(v62, []any{v63, v4}) + _ = v64 + v65 := lang.Apply(lang.WriteWriter, []any{v4, "\n :message "}) + _ = v65 + v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v67 := v66.FindInternedVar(lang.NewSymbol("print-method")) + if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) + } + v68 := v67.Get() + v69 := lang.Apply(lang.NewKeyword("message"), []any{v58}) + v70 := lang.Apply(v68, []any{v69, v4}) + _ = v70 + var v71 any + { // let + // let binding "temp__0__auto__" + v72 := lang.Apply(lang.NewKeyword("data"), []any{v58}) + var v73 any = v72 + _ = v73 + var v74 any + if lang.IsTruthy(v73) { + var v75 any + { // let + // let binding "data" + var v76 any = v73 + _ = v76 + v77 := lang.Apply(lang.WriteWriter, []any{v4, "\n :data "}) + _ = v77 + v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v79 := v78.FindInternedVar(lang.NewSymbol("print-method")) + if v79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) + } + v80 := v79.Get() + v81 := lang.Apply(v80, []any{v76, v4}) + v75 = v81 + } // end let + v74 = v75 + } else { + v74 = nil + } + v71 = v74 + } // end let + _ = v71 + var v72 any + { // let + // let binding "temp__0__auto__" + v73 := lang.Apply(lang.NewKeyword("at"), []any{v58}) + var v74 any = v73 + _ = v74 + var v75 any + if lang.IsTruthy(v74) { + var v76 any + { // let + // let binding "at" + var v77 any = v74 + _ = v77 + v78 := lang.Apply(lang.WriteWriter, []any{v4, "\n :at "}) + _ = v78 + v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v80 := v79.FindInternedVar(lang.NewSymbol("print-method")) + if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) + } + v81 := v80.Get() + v82 := lang.Apply(lang.NewKeyword("at"), []any{v58}) + v83 := lang.Apply(v81, []any{v82, v4}) + v76 = v83 + } // end let + v75 = v76 + } else { + v75 = nil + } + v72 = v75 + } // end let + _ = v72 + v73 := lang.Apply(lang.WriteWriter, []any{v4, "}"}) + return v73 + }) + v58 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(481), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(491), lang.NewKeyword("end-column"), int(73)) + v59, err := lang.WithMeta(v57, v58.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v60 any = v59 + _ = v60 + v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v62 := v61.FindInternedVar(lang.NewSymbol("print-method")) + if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) + } + v63 := v62.Get() + v64 := lang.Apply(v63, []any{v41, v4}) + _ = v64 + var v65 any + if lang.IsTruthy(v46) { + v66 := lang.Apply(lang.WriteWriter, []any{v4, "\n :data "}) + _ = v66 + v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v68 := v67.FindInternedVar(lang.NewSymbol("print-method")) + if v68.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) + } + v69 := v68.Get() + v70 := lang.Apply(v69, []any{v46, v4}) + v65 = v70 + } else { + v65 = nil + } + _ = v65 + var v71 any + if lang.IsTruthy(v51) { + v72 := lang.Apply(lang.WriteWriter, []any{v4, "\n :via\n ["}) + _ = v72 + var v73 any + { // let + // let binding "temp__0__auto__" + v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v75 := v74.FindInternedVar(lang.NewSymbol("first")) + if v75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) + } + v76 := v75.Get() + v77 := lang.Apply(v76, []any{v51}) + var v78 any = v77 + _ = v78 + var v79 any + if lang.IsTruthy(v78) { + var v80 any + { // let + // let binding "fv" + var v81 any = v78 + _ = v81 + v82 := lang.Apply(v60, []any{v81}) + _ = v82 + var v83 any + { // let + // let binding "seq_254" + v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v85 := v84.FindInternedVar(lang.NewSymbol("seq")) + if v85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) + } + v86 := v85.Get() + v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v88 := v87.FindInternedVar(lang.NewSymbol("rest")) + if v88.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) + } + v89 := v88.Get() + v90 := lang.Apply(v89, []any{v51}) + v91 := lang.Apply(v86, []any{v90}) + var v92 any = v91 + _ = v92 + // let binding "chunk_255" + var v93 any = nil + _ = v93 + // let binding "count_256" + var v94 any = int64(0) + _ = v94 + // let binding "i_257" + var v95 any = int64(0) + _ = v95 + for { + var v96 any + v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v98 := v97.FindInternedVar(lang.NewSymbol("<")) + if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) + } + v99 := v98.Get() + v100 := lang.Apply(v99, []any{v95, v94}) + if lang.IsTruthy(v100) { + var v101 any + { // let + // let binding "v" + v102, _ := lang.FieldOrMethod(v93, "nth") + if reflect.TypeOf(v102).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + v103 := lang.Apply(v102, []any{v95}) + var v104 any = v103 + _ = v104 + v105 := lang.Apply(lang.WriteWriter, []any{v4, "\n "}) + _ = v105 + v106 := lang.Apply(v60, []any{v104}) + _ = v106 + var v107 any = v92 + var v108 any = v93 + var v109 any = v94 + v111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v112 := v111.FindInternedVar(lang.NewSymbol("unchecked-inc")) + if v112.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v112))) + } + v113 := v112.Get() + v114 := lang.Apply(v113, []any{v95}) + var v110 any = v114 + v92 = v107 + v93 = v108 + v94 = v109 + v95 = v110 + continue + } // end let + v96 = v101 + } else { + var v102 any + { // let + // let binding "temp__0__auto__" + v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v104 := v103.FindInternedVar(lang.NewSymbol("seq")) + if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) + } + v105 := v104.Get() + v106 := lang.Apply(v105, []any{v92}) + var v107 any = v106 + _ = v107 + var v108 any + if lang.IsTruthy(v107) { + var v109 any + { // let + // let binding "seq_254" + var v110 any = v107 + _ = v110 + var v111 any + v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v113 := v112.FindInternedVar(lang.NewSymbol("chunked-seq?")) + if v113.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) + } + v114 := v113.Get() + v115 := lang.Apply(v114, []any{v110}) + if lang.IsTruthy(v115) { + var v116 any + { // let + // let binding "c__0__auto__" + v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v118 := v117.FindInternedVar(lang.NewSymbol("chunk-first")) + if v118.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) + } + v119 := v118.Get() + v120 := lang.Apply(v119, []any{v110}) + var v121 any = v120 + _ = v121 + v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v124 := v123.FindInternedVar(lang.NewSymbol("chunk-rest")) + if v124.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) + } + v125 := v124.Get() + v126 := lang.Apply(v125, []any{v110}) + var v122 any = v126 + var v127 any = v121 + v129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v130 := v129.FindInternedVar(lang.NewSymbol("int")) + if v130.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v130))) + } + v131 := v130.Get() + v132 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v133 := v132.FindInternedVar(lang.NewSymbol("count")) + if v133.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v133))) + } + v134 := v133.Get() + v135 := lang.Apply(v134, []any{v121}) + v136 := lang.Apply(v131, []any{v135}) + var v128 any = v136 + v138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v139 := v138.FindInternedVar(lang.NewSymbol("int")) + if v139.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v139))) + } + v140 := v139.Get() + v141 := lang.Apply(v140, []any{int64(0)}) + var v137 any = v141 + v92 = v122 + v93 = v127 + v94 = v128 + v95 = v137 + continue + } // end let + v111 = v116 + } else { + var v117 any + { // let + // let binding "v" + v118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v119 := v118.FindInternedVar(lang.NewSymbol("first")) + if v119.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v119))) + } + v120 := v119.Get() + v121 := lang.Apply(v120, []any{v110}) + var v122 any = v121 + _ = v122 + v123 := lang.Apply(lang.WriteWriter, []any{v4, "\n "}) + _ = v123 + v124 := lang.Apply(v60, []any{v122}) + _ = v124 + v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v127 := v126.FindInternedVar(lang.NewSymbol("next")) + if v127.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) + } + v128 := v127.Get() + v129 := lang.Apply(v128, []any{v110}) + var v125 any = v129 + var v130 any = nil + var v131 any = int64(0) + var v132 any = int64(0) + v92 = v125 + v93 = v130 + v94 = v131 + v95 = v132 + continue + } // end let + v111 = v117 + } + v109 = v111 + } // end let + v108 = v109 + } else { + v108 = nil + } + v102 = v108 + } // end let + v96 = v102 + } + v83 = v96 + break + } + } // end let + v80 = v83 + } // end let + v79 = v80 + } else { + v79 = nil + } + v73 = v79 + } // end let + _ = v73 + v74 := lang.Apply(lang.WriteWriter, []any{v4, "]"}) + v71 = v74 + } else { + v71 = nil + } + _ = v71 + var v75 any + if lang.IsTruthy(v56) { + v76 := lang.Apply(lang.WriteWriter, []any{v4, "\n :trace\n ["}) + _ = v76 + var v77 any + { // let + // let binding "temp__0__auto__" + v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v79 := v78.FindInternedVar(lang.NewSymbol("first")) + if v79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) + } + v80 := v79.Get() + v81 := lang.Apply(v80, []any{v56}) + var v82 any = v81 + _ = v82 + var v83 any + if lang.IsTruthy(v82) { + var v84 any + { // let + // let binding "ft" + var v85 any = v82 + _ = v85 + v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v87 := v86.FindInternedVar(lang.NewSymbol("print-method")) + if v87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) + } + v88 := v87.Get() + v89 := lang.Apply(v88, []any{v85, v4}) + _ = v89 + var v90 any + { // let + // let binding "seq_258" + v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v92 := v91.FindInternedVar(lang.NewSymbol("seq")) + if v92.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) + } + v93 := v92.Get() + v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v95 := v94.FindInternedVar(lang.NewSymbol("rest")) + if v95.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) + } + v96 := v95.Get() + v97 := lang.Apply(v96, []any{v56}) + v98 := lang.Apply(v93, []any{v97}) + var v99 any = v98 + _ = v99 + // let binding "chunk_259" + var v100 any = nil + _ = v100 + // let binding "count_260" + var v101 any = int64(0) + _ = v101 + // let binding "i_261" + var v102 any = int64(0) + _ = v102 + for { + var v103 any + v104 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v105 := v104.FindInternedVar(lang.NewSymbol("<")) + if v105.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v105))) + } + v106 := v105.Get() + v107 := lang.Apply(v106, []any{v102, v101}) + if lang.IsTruthy(v107) { + var v108 any + { // let + // let binding "t" + v109, _ := lang.FieldOrMethod(v100, "nth") + if reflect.TypeOf(v109).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + v110 := lang.Apply(v109, []any{v102}) + var v111 any = v110 + _ = v111 + v112 := lang.Apply(lang.WriteWriter, []any{v4, "\n "}) + _ = v112 + v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v114 := v113.FindInternedVar(lang.NewSymbol("print-method")) + if v114.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) + } + v115 := v114.Get() + v116 := lang.Apply(v115, []any{v111, v4}) + _ = v116 + var v117 any = v99 + var v118 any = v100 + var v119 any = v101 + v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v122 := v121.FindInternedVar(lang.NewSymbol("unchecked-inc")) + if v122.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) + } + v123 := v122.Get() + v124 := lang.Apply(v123, []any{v102}) + var v120 any = v124 + v99 = v117 + v100 = v118 + v101 = v119 + v102 = v120 + continue + } // end let + v103 = v108 + } else { + var v109 any + { // let + // let binding "temp__0__auto__" + v110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v111 := v110.FindInternedVar(lang.NewSymbol("seq")) + if v111.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v111))) + } + v112 := v111.Get() + v113 := lang.Apply(v112, []any{v99}) + var v114 any = v113 + _ = v114 + var v115 any + if lang.IsTruthy(v114) { + var v116 any + { // let + // let binding "seq_258" + var v117 any = v114 + _ = v117 + var v118 any + v119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v120 := v119.FindInternedVar(lang.NewSymbol("chunked-seq?")) + if v120.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v120))) + } + v121 := v120.Get() + v122 := lang.Apply(v121, []any{v117}) + if lang.IsTruthy(v122) { + var v123 any + { // let + // let binding "c__0__auto__" + v124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v125 := v124.FindInternedVar(lang.NewSymbol("chunk-first")) + if v125.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v125))) + } + v126 := v125.Get() + v127 := lang.Apply(v126, []any{v117}) + var v128 any = v127 + _ = v128 + v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v131 := v130.FindInternedVar(lang.NewSymbol("chunk-rest")) + if v131.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) + } + v132 := v131.Get() + v133 := lang.Apply(v132, []any{v117}) + var v129 any = v133 + var v134 any = v128 + v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v137 := v136.FindInternedVar(lang.NewSymbol("int")) + if v137.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) + } + v138 := v137.Get() + v139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v140 := v139.FindInternedVar(lang.NewSymbol("count")) + if v140.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v140))) + } + v141 := v140.Get() + v142 := lang.Apply(v141, []any{v128}) + v143 := lang.Apply(v138, []any{v142}) + var v135 any = v143 + v145 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v146 := v145.FindInternedVar(lang.NewSymbol("int")) + if v146.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v146))) + } + v147 := v146.Get() + v148 := lang.Apply(v147, []any{int64(0)}) + var v144 any = v148 + v99 = v129 + v100 = v134 + v101 = v135 + v102 = v144 + continue + } // end let + v118 = v123 + } else { + var v124 any + { // let + // let binding "t" + v125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v126 := v125.FindInternedVar(lang.NewSymbol("first")) + if v126.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v126))) + } + v127 := v126.Get() + v128 := lang.Apply(v127, []any{v117}) + var v129 any = v128 + _ = v129 + v130 := lang.Apply(lang.WriteWriter, []any{v4, "\n "}) + _ = v130 + v131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v132 := v131.FindInternedVar(lang.NewSymbol("print-method")) + if v132.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v132))) + } + v133 := v132.Get() + v134 := lang.Apply(v133, []any{v129, v4}) + _ = v134 + v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v137 := v136.FindInternedVar(lang.NewSymbol("next")) + if v137.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) + } + v138 := v137.Get() + v139 := lang.Apply(v138, []any{v117}) + var v135 any = v139 + var v140 any = nil + var v141 any = int64(0) + var v142 any = int64(0) + v99 = v135 + v100 = v140 + v101 = v141 + v102 = v142 + continue + } // end let + v118 = v124 + } + v116 = v118 + } // end let + v115 = v116 + } else { + v115 = nil + } + v109 = v115 + } // end let + v103 = v109 + } + v90 = v103 + break + } + } // end let + v84 = v90 + } // end let + v83 = v84 + } else { + v83 = nil + } + v77 = v83 + } // end let + _ = v77 + v78 := lang.Apply(lang.WriteWriter, []any{v4, "]"}) + v75 = v78 + } else { + v75 = nil + } + v6 = v75 + } // end let + _ = v6 + v7 := lang.Apply(lang.WriteWriter, []any{v4, "}"}) + return v7 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // printf + { + v0 := lang.NewSymbol("printf").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fmt"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Prints formatted output, as per format", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5725), lang.NewKeyword("end-line"), int(5725))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.NewList(args[1:]...) + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("print")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("apply")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("format")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v10, []any{v13, v3, v4}) + v15 := lang.Apply(v7, []any{v14}) + return v15 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // println + { + v0 := lang.NewSymbol("println").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Same as print followed by (newline)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3734), lang.NewKeyword("end-line"), int(3734))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := lang.NewList(args[0:]...) + var v4 any + { // let + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("push-thread-bindings")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("hash-map")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*print-readably*")) + v12 := lang.Apply(v10, []any{v11, nil}) + v13 := lang.Apply(v7, []any{v12}) + _ = v13 + var v14 any + func() { + defer func() { + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, nil) + }() + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("apply")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("prn")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v21, []any{v24, v3}) + v14 = v25 + }() + v4 = v14 + } // end let + return v4 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // println-str + { + v1 := reflect.TypeOf("") + v0 := lang.NewSymbol("println-str").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("xs"))), lang.NewKeyword("doc"), "println to a string, returning it", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4785), lang.NewKeyword("end-line"), int(4785))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := lang.NewList(args[0:]...) + var v5 any + { // let + // let binding "s__0__auto__" + var v6 any = "unimplemented: new with non-constant class type" + _ = v6 + var v7 any + { // let + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("push-thread-bindings")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("hash-map")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*out*")) + v15 := lang.Apply(v13, []any{v14, v6}) + v16 := lang.Apply(v10, []any{v15}) + _ = v16 + var v17 any + func() { + defer func() { + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.Apply(v20, nil) + }() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("apply")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("println")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.Apply(v24, []any{v27, v4}) + _ = v28 + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("str")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.Apply(v31, []any{v6}) + v17 = v32 + }() + v7 = v17 + } // end let + v5 = v7 + } // end let + return v5 + } + }) + v4 := reflect.TypeOf("") + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // prn + { + v0 := lang.NewSymbol("prn").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Same as pr followed by (newline). Observes *flush-on-newline*", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3715), lang.NewKeyword("end-line"), int(3715))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := lang.NewList(args[0:]...) + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("apply")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("pr")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v6, []any{v9, v3}) + _ = v10 + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("newline")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, nil) + _ = v14 + var v15 any + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("*flush-on-newline*")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + if lang.IsTruthy(v18) { + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("flush")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, nil) + v15 = v22 + } else { + v15 = nil + } + return v15 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // prn-str + { + v1 := reflect.TypeOf("") + v0 := lang.NewSymbol("prn-str").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("xs"))), lang.NewKeyword("doc"), "prn to a string, returning it", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4767), lang.NewKeyword("end-line"), int(4767))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := lang.NewList(args[0:]...) + var v5 any + { // let + // let binding "s__0__auto__" + var v6 any = "unimplemented: new with non-constant class type" + _ = v6 + var v7 any + { // let + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("push-thread-bindings")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("hash-map")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*out*")) + v15 := lang.Apply(v13, []any{v14, v6}) + v16 := lang.Apply(v10, []any{v15}) + _ = v16 + var v17 any + func() { + defer func() { + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.Apply(v20, nil) + }() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("apply")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("prn")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.Apply(v24, []any{v27, v4}) + _ = v28 + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("str")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.Apply(v31, []any{v6}) + v17 = v32 + }() + v7 = v17 + } // end let + v5 = v7 + } // end let + return v5 + } + }) + v4 := reflect.TypeOf("") + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // promise + { + v0 := lang.NewSymbol("promise").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Returns a promise object that can be read with deref/@, and set,\n once only, with deliver. Calls to deref/@ prior to delivery will\n block, unless the variant of deref with timeout is used. All\n subsequent derefs will return the same delivered value without\n blocking. See also - realized?.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7078), lang.NewKeyword("end-line"), int(7078))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v3 any + { // let + // let binding "d" + v4 := lang.Apply(nil, []any{int64(1)}) + var v5 any = v4 + _ = v5 + // let binding "v" + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("atom")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{v5}) + var v10 any = v9 + _ = v10 + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("deref")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.NewVector(nil) + v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7091), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(7091), lang.NewKeyword("end-column"), int(17)) + v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v17, ok := lang.FieldOrMethod(v5, "await") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "await"))) + } + var v18 any + switch reflect.TypeOf(v17).Kind() { + case reflect.Func: + v18 = lang.Apply(v17, nil) + default: + v18 = v17 + } + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("deref")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{v10}) + v23 := lang.Apply(v13, []any{v16, v18, v22}) + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("deref")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.NewVector(nil, nil, nil) + v28 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7094), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(7094), lang.NewKeyword("end-column"), int(34)) + v29, err := lang.WithMeta(v27, v28.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v30 any + v31, _ := lang.FieldOrMethod(v5, "await") + if reflect.TypeOf(v31).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) + } + v32 := lang.Apply(v31, []any{nil, time7.Millisecond}) + if lang.IsTruthy(v32) { + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("deref")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.Apply(v35, []any{v10}) + v30 = v36 + } else { + v30 = nil + } + v37 := lang.Apply(v26, []any{v29, v30}) + v38 := lang.NewVector(nil) + v39 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7099), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(7099), lang.NewKeyword("end-column"), int(24)) + v40, err := lang.WithMeta(v38, v39.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("zero?")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44, ok := lang.FieldOrMethod(v5, "getCount") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "getCount"))) + } + var v45 any + switch reflect.TypeOf(v44).Kind() { + case reflect.Func: + v45 = lang.Apply(v44, nil) + default: + v45 = v44 + } + v46 := lang.Apply(v43, []any{v45}) + v47 := lang.Apply(nil, []any{v40, v46}) + v48 := lang.NewVector(nil, nil) + v49 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7103), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(7103), lang.NewKeyword("end-column"), int(14)) + v50, err := lang.WithMeta(v48, v49.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v51 any + var v52 any + { // let + // let binding "and__0__auto__" + v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v54 := v53.FindInternedVar(lang.NewSymbol("pos?")) + if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) + } + v55 := v54.Get() + v56, ok := lang.FieldOrMethod(v5, "getCount") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "getCount"))) + } + var v57 any + switch reflect.TypeOf(v56).Kind() { + case reflect.Func: + v57 = lang.Apply(v56, nil) + default: + v57 = v56 + } + v58 := lang.Apply(v55, []any{v57}) + var v59 any = v58 + _ = v59 + var v60 any + if lang.IsTruthy(v59) { + v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v62 := v61.FindInternedVar(lang.NewSymbol("compare-and-set!")) + if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) + } + v63 := v62.Get() + v64 := lang.Apply(v63, []any{v10, v5, nil}) + v60 = v64 + } else { + v60 = v59 + } + v52 = v60 + } // end let + if lang.IsTruthy(v52) { + v53, ok := lang.FieldOrMethod(v5, "countDown") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "countDown"))) + } + var v54 any + switch reflect.TypeOf(v53).Kind() { + case reflect.Func: + v54 = lang.Apply(v53, nil) + default: + v54 = v53 + } + _ = v54 + v51 = nil + } else { + v51 = nil + } + v55 := lang.Apply(nil, []any{v50, v51}) + v56 := lang.Apply(nil, []any{lang.IDeref, v23, lang.IBlockingDeref, v37, lang.IPending, v47, nil, v55}) + v3 = v56 + } // end let + return v3 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // protocol? + { + v0 := lang.NewSymbol("protocol?").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(110), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(110), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("maybe-p"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{lang.IAtom, v3}) + if lang.IsTruthy(v8) { + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("boolean")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("deref")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.Apply(v14, []any{v3}) + v16 := lang.Apply(lang.NewKeyword("on-interface"), []any{v15}) + v17 := lang.Apply(v11, []any{v16}) + v4 = v17 + } else { + v4 = false + } + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // push-thread-bindings + { + v0 := lang.NewSymbol("push-thread-bindings").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"))), lang.NewKeyword("doc"), "WARNING: This is a low-level function. Prefer high-level macros like\n binding where ever possible.\n\n Takes a map of Var/value pairs. Binds each Var to the associated value for\n the current thread. Each call *MUST* be accompanied by a matching call to\n pop-thread-bindings wrapped in a try-finally!\n \n (push-thread-bindings bindings)\n (try\n ...\n (finally\n (pop-thread-bindings)))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(26), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1911), lang.NewKeyword("end-line"), int(1911))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.Apply(lang.PushThreadBindings, []any{v3}) + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // pvalues + { + v0 := lang.NewSymbol("pvalues").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("exprs"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the values of the exprs, which are\n evaluated in parallel", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7063), lang.NewKeyword("end-line"), int(7063))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.NewList(args[2:]...) + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("seq")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("concat")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("list")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.Apply(v14, []any{lang.NewSymbol("glojure.core/pcalls")}) + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("map")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + var v19 lang.FnFunc + v19 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v20 := args[0] + _ = v20 + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("list")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.NewVector() + v25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7069), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(7069), lang.NewKeyword("end-column"), int(31)) + v26, err := lang.WithMeta(v24, v25.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v27 := lang.Apply(v23, []any{lang.NewSymbol("glojure.core/fn"), v26, v20}) + return v27 + }) + v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7069), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(7069), lang.NewKeyword("end-column"), int(34)) + v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v22 := lang.Apply(v18, []any{v21, v5}) + v23 := lang.Apply(v11, []any{v15, v22}) + v24 := lang.Apply(v8, []any{v23}) + return v24 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // qualified-ident? + { + v0 := lang.NewSymbol("qualified-ident?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a symbol or keyword with a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1618), lang.NewKeyword("end-line"), int(1618))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("boolean")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + var v7 any + { // let + // let binding "and__0__auto__" + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("ident?")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v3}) + var v12 any = v11 + _ = v12 + var v13 any + if lang.IsTruthy(v12) { + var v14 any + { // let + // let binding "and__0__auto__" + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("namespace")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{v3}) + var v19 any = v18 + _ = v19 + var v20 any + if lang.IsTruthy(v19) { + v20 = true + } else { + v20 = v19 + } + v14 = v20 + } // end let + v13 = v14 + } else { + v13 = v12 + } + v7 = v13 + } // end let + v8 := lang.Apply(v6, []any{v7}) + return v8 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // qualified-keyword? + { + v0 := lang.NewSymbol("qualified-keyword?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a keyword with a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1638), lang.NewKeyword("end-line"), int(1638))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("boolean")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + var v7 any + { // let + // let binding "and__0__auto__" + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("keyword?")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v3}) + var v12 any = v11 + _ = v12 + var v13 any + if lang.IsTruthy(v12) { + var v14 any + { // let + // let binding "and__0__auto__" + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("namespace")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{v3}) + var v19 any = v18 + _ = v19 + var v20 any + if lang.IsTruthy(v19) { + v20 = true + } else { + v20 = v19 + } + v14 = v20 + } // end let + v13 = v14 + } else { + v13 = v12 + } + v7 = v13 + } // end let + v8 := lang.Apply(v6, []any{v7}) + return v8 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // qualified-symbol? + { + v0 := lang.NewSymbol("qualified-symbol?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a symbol with a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1628), lang.NewKeyword("end-line"), int(1628))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("boolean")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + var v7 any + { // let + // let binding "and__0__auto__" + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("symbol?")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v3}) + var v12 any = v11 + _ = v12 + var v13 any + if lang.IsTruthy(v12) { + var v14 any + { // let + // let binding "and__0__auto__" + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("namespace")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{v3}) + var v19 any = v18 + _ = v19 + var v20 any + if lang.IsTruthy(v19) { + v20 = true + } else { + v20 = v19 + } + v14 = v20 + } // end let + v13 = v14 + } else { + v13 = v12 + } + v7 = v13 + } // end let + v8 := lang.Apply(v6, []any{v7}) + return v8 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // quot + { + var v1 lang.FnFunc + { // function quot__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("seq")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("concat")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("list")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("list")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("list")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("seq")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("concat")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("list")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/Quotient")}) + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("list")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{v3}) + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("list")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v38, []any{v4}) + v40 := lang.Apply(v27, []any{v31, v35, v39}) + v41 := lang.Apply(v24, []any{v40}) + v42 := lang.Apply(v21, []any{v41}) + v43 := lang.Apply(v10, []any{v14, v18, v42}) + v44 := lang.Apply(v7, []any{v43}) + return v44 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("quot").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"), lang.NewSymbol("div"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "quot[ient] of dividing numerator by denominator.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1266), lang.NewKeyword("end-line"), int(1266))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6, _ := lang.FieldOrMethod(lang.Numbers, "Quotient") + if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Quotient is not a function"))) + } + v7 := lang.Apply(v6, []any{v4, v5}) + return v7 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // rand + { + v0 := lang.NewSymbol("rand").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns a random floating point number between 0 (inclusive) and\n n (default 1) (exclusive).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4935), lang.NewKeyword("end-line"), int(4935))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + v3 := lang.Apply(rand12.Float64, nil) + return v3 + case 1: + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("*")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("rand")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, nil) + v11 := lang.Apply(v6, []any{v3, v10}) + return v11 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // rand-int + { + v0 := lang.NewSymbol("rand-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns a random integer between 0 (inclusive) and n (exclusive).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4943), lang.NewKeyword("end-line"), int(4943))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("int")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("rand")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, []any{v3}) + v11 := lang.Apply(v6, []any{v10}) + return v11 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // rand-nth + { + v0 := lang.NewSymbol("rand-nth").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return a random element of the (sequential) collection. Will have\n the same performance characteristics as nth for the given\n collection.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7213), lang.NewKeyword("end-line"), int(7213))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("nth")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("rand-int")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("count")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{v3}) + v14 := lang.Apply(v9, []any{v13}) + v15 := lang.Apply(v6, []any{v3, v14}) + return v15 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // random-sample + { + v0 := lang.NewSymbol("random-sample").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("prob")), lang.NewVector(lang.NewSymbol("prob"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns items from coll with random probability of prob (0.0 -\n 1.0). Returns a transducer when no collection is provided.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7699), lang.NewKeyword("end-line"), int(7699))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("filter")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + var v7 lang.FnFunc + v7 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v8 := args[0] + _ = v8 + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("<")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("rand")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.Apply(v14, nil) + v16 := lang.Apply(v11, []any{v15, v3}) + return v16 + }) + v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7704), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(7704), lang.NewKeyword("end-column"), int(37)) + v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v10 := lang.Apply(v6, []any{v9}) + return v10 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("filter")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + var v8 lang.FnFunc + v8 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v9 := args[0] + _ = v9 + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("<")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("rand")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, nil) + v17 := lang.Apply(v12, []any{v16, v3}) + return v17 + }) + v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7706), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(7706), lang.NewKeyword("end-column"), int(37)) + v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v11 := lang.Apply(v7, []any{v10, v4}) + return v11 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // random-uuid + { + v0 := lang.NewSymbol("random-uuid").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Returns a pseudo-randomly generated java.util.UUID instance (i.e. type 4).\n\n See: https://docs.oracle.com/javase/8/docs/api/java/util/UUID.html#randomUUID--", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6852), lang.NewKeyword("end-line"), int(6852))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := lang.Apply(uuid10.NewV7, nil) + return v3 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // range + { + v0 := lang.NewSymbol("range").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("end")), lang.NewVector(lang.NewSymbol("start"), lang.NewSymbol("end")), lang.NewVector(lang.NewSymbol("start"), lang.NewSymbol("end"), lang.NewSymbol("step"))), lang.NewKeyword("doc"), "Returns a lazy seq of nums from start (inclusive) to end\n (exclusive), by step, where start defaults to 0, step to 1, and end to\n infinity. When step is equal to 0, returns an infinite sequence of\n start. When start is equal to end, returns empty list.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3018), lang.NewKeyword("end-line"), int(3018))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v4 := v3.FindInternedVar(lang.NewSymbol("iterate")) + if v4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) + } + v5 := v4.Get() + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("inc'")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v5, []any{v8, int64(0)}) + return v9 + case 1: + v3 := args[0] + _ = v3 + var v4 any + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("int?")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v3}) + if lang.IsTruthy(v8) { + v9 := lang.Apply(lang.NewLongRange, []any{int64(0), v3, int64(1)}) + v4 = v9 + } else { + v10 := lang.Apply(lang.NewRange, []any{int64(0), v3, int64(1)}) + v4 = v10 + } + return v4 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any + var v6 any + { // let + // let binding "and__0__auto__" + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("int?")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, []any{v3}) + var v11 any = v10 + _ = v11 + var v12 any + if lang.IsTruthy(v11) { + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("int?")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{v4}) + v12 = v16 + } else { + v12 = v11 + } + v6 = v12 + } // end let + if lang.IsTruthy(v6) { + v7 := lang.Apply(lang.NewLongRange, []any{v3, v4, int64(1)}) + v5 = v7 + } else { + v8 := lang.Apply(lang.NewRange, []any{v3, v4, int64(1)}) + v5 = v8 + } + return v5 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any + var v7 any + { // let + // let binding "and__0__auto__" + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("int?")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v3}) + var v12 any = v11 + _ = v12 + var v13 any + if lang.IsTruthy(v12) { + var v14 any + { // let + // let binding "and__0__auto__" + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("int?")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{v4}) + var v19 any = v18 + _ = v19 + var v20 any + if lang.IsTruthy(v19) { + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("int?")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.Apply(v23, []any{v5}) + v20 = v24 + } else { + v20 = v19 + } + v14 = v20 + } // end let + v13 = v14 + } else { + v13 = v12 + } + v7 = v13 + } // end let + if lang.IsTruthy(v7) { + v8 := lang.Apply(lang.NewLongRange, []any{v3, v4, v5}) + v6 = v8 + } else { + v9 := lang.Apply(lang.NewRange, []any{v3, v4, v5}) + v6 = v9 + } + return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // ratio? + { + v0 := lang.NewSymbol("ratio?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is a Ratio", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3577), lang.NewKeyword("end-line"), int(3577))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.Apply(v6, []any{*lang.Ratio, v3}) + return v7 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // rational? + { + v0 := lang.NewSymbol("rational?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is a rational number", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3613), lang.NewKeyword("end-line"), int(3613))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + { // let + // let binding "or__0__auto__" + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("integer?")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v3}) + var v9 any = v8 + _ = v9 + var v10 any + if lang.IsTruthy(v9) { + v10 = v9 + } else { + var v11 any + { // let + // let binding "or__0__auto__" + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("ratio?")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.Apply(v14, []any{v3}) + var v16 any = v15 + _ = v16 + var v17 any + if lang.IsTruthy(v16) { + v17 = v16 + } else { + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("decimal?")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.Apply(v20, []any{v3}) + v17 = v21 + } + v11 = v17 + } // end let + v10 = v11 + } + v4 = v10 + } // end let + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // rationalize + { + v0 := lang.NewSymbol("rationalize").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("doc"), "returns the rational value of num", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1282), lang.NewKeyword("end-line"), int(1282))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4, _ := lang.FieldOrMethod(lang.Numbers, "Rationalize") + if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Rationalize is not a function"))) + } + v5 := lang.Apply(v4, []any{v3}) + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // re-find + { + v0 := lang.NewSymbol("re-find").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m")), lang.NewVector(lang.NewSymbol("re"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns the next regex match, if any, of string to pattern, using\n java.util.regex.Matcher.find(). Uses re-groups to return the\n groups.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4922), lang.NewKeyword("end-line"), int(4922))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + var v4 any + v5, _ := lang.FieldOrMethod(v3, "find") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("find is not a function"))) + } + v6 := lang.Apply(v5, []any{}) + if lang.IsTruthy(v6) { + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("re-groups")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, []any{v3}) + v4 = v10 + } else { + v4 = nil + } + return v4 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any + { // let + // let binding "m" + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("re-matcher")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{v3, v4}) + var v10 any = v9 + _ = v10 + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("re-find")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{v10}) + v5 = v14 + } // end let + return v5 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // re-groups + { + v0 := lang.NewSymbol("re-groups").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"))), lang.NewKeyword("doc"), "Returns the groups from the most recent match/find. If there are no\n nested groups, returns a string of the entire match. If there are\n nested groups, returns a vector of the groups, the first element\n being the entire match.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4882), lang.NewKeyword("end-line"), int(4882))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + { // let + // let binding "gc" + v5, _ := lang.FieldOrMethod(v3, "groupCount") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("groupCount is not a function"))) + } + v6 := lang.Apply(v5, []any{}) + var v7 any = v6 + _ = v7 + var v8 any + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("zero?")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.Apply(v11, []any{v7}) + if lang.IsTruthy(v12) { + v13, _ := lang.FieldOrMethod(v3, "group") + if reflect.TypeOf(v13).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("group is not a function"))) + } + v14 := lang.Apply(v13, []any{}) + v8 = v14 + } else { + var v15 any + { // let + // let binding "ret" + v16 := lang.NewVector() + v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4893), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(4893), lang.NewKeyword("end-column"), int(21)) + v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v19 any = v18 + _ = v19 + // let binding "c" + var v20 any = int64(0) + _ = v20 + for { + var v21 any + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("<=")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v20, v7}) + if lang.IsTruthy(v25) { + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("conj")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30, _ := lang.FieldOrMethod(v3, "groupInt") + if reflect.TypeOf(v30).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("groupInt is not a function"))) + } + v31 := lang.Apply(v30, []any{v20}) + v32 := lang.Apply(v29, []any{v19, v31}) + var v26 any = v32 + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("inc")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.Apply(v36, []any{v20}) + var v33 any = v37 + v19 = v26 + v20 = v33 + continue + } else { + v21 = v19 + } + v15 = v21 + break + } + } // end let + v8 = v15 + } + v4 = v8 + } // end let + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // re-matcher + { + v1 := reflect.TypeOf((*lang.RegexpMatcher)(nil)) + v0 := lang.NewSymbol("re-matcher").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("re"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns an instance of java.util.regex.Matcher, for use, e.g. in\n re-find.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4873), lang.NewKeyword("end-line"), int(4873))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := lang.Apply(lang.NewRegexpMatcher, []any{v4, v5}) + return v6 + }) + v4 := reflect.TypeOf((*lang.RegexpMatcher)(nil)) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // re-matches + { + v0 := lang.NewSymbol("re-matches").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("re"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns the match, if any, of string to pattern, using\n java.util.regex.Matcher.matches(). Uses re-groups to return the\n groups.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4910), lang.NewKeyword("end-line"), int(4910))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any + { // let + // let binding "m" + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("re-matcher")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{v3, v4}) + var v10 any = v9 + _ = v10 + var v11 any + v12, _ := lang.FieldOrMethod(v10, "matches") + if reflect.TypeOf(v12).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("matches is not a function"))) + } + v13 := lang.Apply(v12, []any{}) + if lang.IsTruthy(v13) { + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("re-groups")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{v10}) + v11 = v17 + } else { + v11 = nil + } + v5 = v11 + } // end let + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // re-pattern + { + v1 := reflect.TypeOf((*regexp13.Regexp)(nil)) + v0 := lang.NewSymbol("re-pattern").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns an instance of java.util.regex.Pattern, for use, e.g. in\n re-matcher.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4863), lang.NewKeyword("end-line"), int(4863))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + var v5 any + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{*regexp13.Regexp, v4}) + if lang.IsTruthy(v9) { + v5 = v4 + } else { + v10 := lang.Apply(regexp13.MustCompile, []any{v4}) + v5 = v10 + } + return v5 + }) + v4 := reflect.TypeOf((*regexp13.Regexp)(nil)) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // re-seq + { + v0 := lang.NewSymbol("re-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("re"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns a lazy sequence of successive matches of pattern in string,\n using java.util.regex.Matcher.find(), each such match processed with\n re-groups.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4898), lang.NewKeyword("end-line"), int(4898))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any + { // let + // let binding "m" + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("re-matcher")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{v3, v4}) + var v10 any = v9 + _ = v10 + var v11 lang.FnFunc + { // function step + v11 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v13 any + v14, _ := lang.FieldOrMethod(v10, "find") + if reflect.TypeOf(v14).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("find is not a function"))) + } + v15 := lang.Apply(v14, []any{}) + if lang.IsTruthy(v15) { + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("cons")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("re-groups")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{v10}) + var v23 lang.FnFunc + v23 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v24 := lang.Apply(v12, nil) + return v24 + }) + v24 := lang.Apply(lang.NewLazySeq, []any{v23}) + v25 := lang.Apply(v18, []any{v22, v24}) + v13 = v25 + } else { + v13 = nil + } + return v13 + }) + v12 := v11 + _ = v12 + } + v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4906), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(4908), lang.NewKeyword("end-column"), int(49)) + v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v14 := lang.Apply(v13, nil) + v5 = v14 + } // end let + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // read + { + v0 := lang.NewSymbol("read").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("stream")), lang.NewVector(lang.NewSymbol("stream"), lang.NewSymbol("eof-error?"), lang.NewSymbol("eof-value")), lang.NewVector(lang.NewSymbol("stream"), lang.NewSymbol("eof-error?"), lang.NewSymbol("eof-value"), lang.NewSymbol("recursive?")), lang.NewVector(lang.NewSymbol("opts"), lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Reads the next object from stream, which must be an instance of\n java.io.PushbackReader or some derivee. stream defaults to the\n current value of *in*.\n\n Opts is a persistent map with valid keys:\n :read-cond - :allow to process reader conditionals, or\n :preserve to keep all branches\n :features - persistent set of feature keywords for reader conditionals\n :eof - on eof, return value unless :eofthrow, then throw.\n if not specified, will throw\n\n Note that read can execute code (controlled by *read-eval*),\n and as such should be used only with trusted sources.\n\n For data structure interop use glojure.edn/read", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3742), lang.NewKeyword("end-line"), int(3742))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v4 := v3.FindInternedVar(lang.NewSymbol("read")) + if v4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) + } + v5 := v4.Get() + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("*in*")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v5, []any{v8}) + return v9 + case 1: + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("read")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.Apply(v6, []any{v3, true, nil}) + return v7 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("read")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{v3, v4, v5, false}) + return v9 + case 4: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("boolean")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, []any{v4}) + v11, _ := lang.FieldOrMethod(nil, "read") + if reflect.TypeOf(v11).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("read is not a function"))) + } + v12 := lang.Apply(v11, []any{v3, v10, v5, v6}) + return v12 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5, _ := lang.FieldOrMethod(nil, "read") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("read is not a function"))) + } + v6 := lang.Apply(v5, []any{v4, v3}) + return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // read+string + { + v0 := lang.NewSymbol("read+string").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("stream")), lang.NewVector(lang.NewSymbol("stream"), lang.NewSymbol("eof-error?"), lang.NewSymbol("eof-value")), lang.NewVector(lang.NewSymbol("stream"), lang.NewSymbol("eof-error?"), lang.NewSymbol("eof-value"), lang.NewSymbol("recursive?")), lang.NewVector(lang.NewSymbol("opts"), lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Like read, and taking the same args. stream must be a LineNumberingPushbackReader.\n Returns a vector containing the object read and the (whitespace-trimmed) string read.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3771), lang.NewKeyword("end-line"), int(3771))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v4 := v3.FindInternedVar(lang.NewSymbol("read+string")) + if v4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) + } + v5 := v4.Get() + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("*in*")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v5, []any{v8}) + return v9 + case 1: + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("read+string")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.Apply(v6, []any{v3, true, nil}) + return v7 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("read+string")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{v3, v4, v5, false}) + return v9 + case 4: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + var v7 any + func() { + defer func() { + if r := recover(); r != nil { + if lang.CatchMatches(r, lang.Throwable) { + v8 := r + _ = v8 + v9, ok := lang.FieldOrMethod(v3, "getString") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getString"))) + } + var v10 any + switch reflect.TypeOf(v9).Kind() { + case reflect.Func: + v10 = lang.Apply(v9, nil) + default: + v10 = v9 + } + _ = v10 + panic(v8) + } else { + panic(r) + } + } + }() + v8, ok := lang.FieldOrMethod(v3, "captureString") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "captureString"))) + } + var v9 any + switch reflect.TypeOf(v8).Kind() { + case reflect.Func: + v9 = lang.Apply(v8, nil) + default: + v9 = v8 + } + _ = v9 + var v10 any + { // let + // let binding "o" + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("read")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{v3, v4, v5, v6}) + var v15 any = v14 + _ = v15 + // let binding "s" + v16, ok := lang.FieldOrMethod(v3, "getString") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getString"))) + } + var v17 any + switch reflect.TypeOf(v16).Kind() { + case reflect.Func: + v17 = lang.Apply(v16, nil) + default: + v17 = v16 + } + v18, ok := lang.FieldOrMethod(v17, "trim") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v17, "trim"))) + } + var v19 any + switch reflect.TypeOf(v18).Kind() { + case reflect.Func: + v19 = lang.Apply(v18, nil) + default: + v19 = v18 + } + var v20 any = v19 + _ = v20 + v21 := lang.NewVector(v15, v20) + v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3783), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(3783), lang.NewKeyword("end-column"), int(12)) + v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v10 = v23 + } // end let + v7 = v10 + }() + return v7 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any + func() { + defer func() { + if r := recover(); r != nil { + if lang.CatchMatches(r, lang.Throwable) { + v6 := r + _ = v6 + v7, ok := lang.FieldOrMethod(v4, "getString") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "getString"))) + } + var v8 any + switch reflect.TypeOf(v7).Kind() { + case reflect.Func: + v8 = lang.Apply(v7, nil) + default: + v8 = v7 + } + _ = v8 + panic(v6) + } else { + panic(r) + } + } + }() + v6, ok := lang.FieldOrMethod(v4, "captureString") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "captureString"))) + } + var v7 any + switch reflect.TypeOf(v6).Kind() { + case reflect.Func: + v7 = lang.Apply(v6, nil) + default: + v7 = v6 + } + _ = v7 + var v8 any + { // let + // let binding "o" + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("read")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.Apply(v11, []any{v3, v4}) + var v13 any = v12 + _ = v13 + // let binding "s" + v14, ok := lang.FieldOrMethod(v4, "getString") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "getString"))) + } + var v15 any + switch reflect.TypeOf(v14).Kind() { + case reflect.Func: + v15 = lang.Apply(v14, nil) + default: + v15 = v14 + } + v16, ok := lang.FieldOrMethod(v15, "trim") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v15, "trim"))) + } + var v17 any + switch reflect.TypeOf(v16).Kind() { + case reflect.Func: + v17 = lang.Apply(v16, nil) + default: + v17 = v16 + } + var v18 any = v17 + _ = v18 + v19 := lang.NewVector(v13, v18) + v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3792), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(3792), lang.NewKeyword("end-column"), int(12)) + v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v8 = v21 + } // end let + v5 = v8 + }() + return v5 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // read-line + { + v0 := lang.NewSymbol("read-line").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Reads the next line from stream that is the current value of *in* .", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3797), lang.NewKeyword("end-line"), int(3797))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v3 any + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("*in*")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v6, []any{nil, v9}) + if lang.IsTruthy(v10) { + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("*in*")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14, ok := lang.FieldOrMethod(v13, "readLine") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v13, "readLine"))) + } + var v15 any + switch reflect.TypeOf(v14).Kind() { + case reflect.Func: + v15 = lang.Apply(v14, nil) + default: + v15 = v14 + } + v3 = v15 + } else { + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("*in*")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19, ok := lang.FieldOrMethod(v18, "readLine") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v18, "readLine"))) + } + var v20 any + switch reflect.TypeOf(v19).Kind() { + case reflect.Func: + v20 = lang.Apply(v19, nil) + default: + v20 = v19 + } + v3 = v20 + } + return v3 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // read-string + { + v0 := lang.NewSymbol("read-string").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s")), lang.NewVector(lang.NewSymbol("opts"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Reads one object from the string s. Optionally include reader\n options, as specified in read.\n\n Note that read-string can execute code (controlled by *read-eval*),\n and as such should be used only with trusted sources.\n\n For data structure interop use glojure.edn/read-string", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3806), lang.NewKeyword("end-line"), int(3806))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + v4 := lang.Apply(runtime4.RTReadString, []any{v3}) + return v4 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.Apply(runtime4.RTReadString, []any{v4, v3}) + return v5 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // reader-conditional + { + v0 := lang.NewSymbol("reader-conditional").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("form"), lang.NewSymbol("splicing?"))), lang.NewKeyword("doc"), "Construct a data representation of a reader conditional.\n If true, splicing? indicates read-cond-splicing.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7782), lang.NewKeyword("end-line"), int(7782))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.Apply(nil, []any{v3, v4}) + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // reader-conditional? + { + v0 := lang.NewSymbol("reader-conditional?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("value"))), lang.NewKeyword("doc"), "Return true if the value is the data representation of a reader conditional", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7776), lang.NewKeyword("end-line"), int(7776))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.Apply(v6, []any{nil, v3}) + return v7 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // realized? + { + v0 := lang.NewSymbol("realized?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if a value has been produced for a promise, delay, future or lazy sequence.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7559), lang.NewKeyword("end-line"), int(7559))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4, ok := lang.FieldOrMethod(v3, "isRealized") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "isRealized"))) + } + var v5 any + switch reflect.TypeOf(v4).Kind() { + case reflect.Func: + v5 = lang.Apply(v4, nil) + default: + v5 = v4 + } + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // reduce + { + v0 := lang.NewSymbol("reduce").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("val"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "f should be a function of 2 arguments. If val is not supplied,\n returns the result of applying f to the first 2 items in coll, then\n applying f to that result and the 3rd item, etc. If coll contains no\n items, f must accept no arguments as well, and reduce returns the\n result of calling f with no arguments. If coll has only 1 item, it\n is returned and f is not called. If val is supplied, returns the\n result of applying f to val and the first item in coll, then\n applying f to that result and the 2nd item, etc. If coll contains no\n items, returns val and f is not called.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6860), lang.NewKeyword("end-line"), int(6860))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{lang.IReduce, v4}) + if lang.IsTruthy(v9) { + v10, _ := lang.FieldOrMethod(v4, "Reduce") + if reflect.TypeOf(v10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Reduce is not a function"))) + } + v11 := lang.Apply(v10, []any{v3}) + v5 = v11 + } else { + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core.protocols")) + v13 := v12.FindInternedVar(lang.NewSymbol("coll-reduce")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.Apply(v14, []any{v4, v3}) + v5 = v15 + } + return v5 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("instance?")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, []any{lang.IReduceInit, v5}) + if lang.IsTruthy(v10) { + v11, _ := lang.FieldOrMethod(v5, "ReduceInit") + if reflect.TypeOf(v11).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) + } + v12 := lang.Apply(v11, []any{v3, v4}) + v6 = v12 + } else { + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core.protocols")) + v14 := v13.FindInternedVar(lang.NewSymbol("coll-reduce")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{v5, v3, v4}) + v6 = v16 + } + return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // reduce-kv + { + v0 := lang.NewSymbol("reduce-kv").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Reduces an associative collection. f should be a function of 3\n arguments. Returns the result of applying f to init, the first key\n and the first value in coll, then applying f to that result and the\n 2nd key and value, etc. If coll contains no entries, returns init\n and f is not called. Note that reduce-kv is supported on vectors,\n where the keys will be the ordinals.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6882), lang.NewKeyword("end-line"), int(6882))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core.protocols")) + v7 := v6.FindInternedVar(lang.NewSymbol("kv-reduce")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{v5, v3, v4}) + return v9 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // reduce1 + { + v0 := lang.NewSymbol("reduce1").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(923), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(924), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("val"), lang.NewSymbol("coll"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any + { // let + // let binding "s" + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("seq")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{v4}) + var v10 any = v9 + _ = v10 + var v11 any + if lang.IsTruthy(v10) { + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("reduce1")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("first")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{v10}) + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("next")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{v10}) + v23 := lang.Apply(v14, []any{v3, v18, v22}) + v11 = v23 + } else { + v24 := lang.Apply(v3, nil) + v11 = v24 + } + v5 = v11 + } // end let + return v5 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + recur_loop_156: + var v6 any + { // let + // let binding "s" + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("seq")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, []any{v5}) + var v11 any = v10 + _ = v11 + var v12 any + if lang.IsTruthy(v11) { + var v13 any + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("chunked-seq?")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{v11}) + if lang.IsTruthy(v17) { + var v18 any = v3 + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("chunk-first")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.Apply(v22, []any{v11}) + v24, _ := lang.FieldOrMethod(v23, "ReduceInit") + if reflect.TypeOf(v24).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) + } + v25 := lang.Apply(v24, []any{v3, v4}) + var v19 any = v25 + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("chunk-next")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{v11}) + var v26 any = v30 + v3 = v18 + v4 = v19 + v5 = v26 + goto recur_loop_156 + } else { + var v31 any = v3 + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("first")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.Apply(v35, []any{v11}) + v37 := lang.Apply(v3, []any{v4, v36}) + var v32 any = v37 + v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v40 := v39.FindInternedVar(lang.NewSymbol("next")) + if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) + } + v41 := v40.Get() + v42 := lang.Apply(v41, []any{v11}) + var v38 any = v42 + v3 = v31 + v4 = v32 + v5 = v38 + goto recur_loop_156 + } + v12 = v13 + } else { + v12 = v4 + } + v6 = v12 + } // end let + return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // reduced + { + v0 := lang.NewSymbol("reduced").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Wraps x in a way such that a reduce will terminate with the value x", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2828), lang.NewKeyword("end-line"), int(2828))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.Apply(lang.NewReduced, []any{v3}) + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // reduced? + { + var v1 lang.FnFunc + { // function reduced?__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("concat")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("list")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.IsReduced")}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{v3}) + v18 := lang.Apply(v9, []any{v13, v17}) + v19 := lang.Apply(v6, []any{v18}) + return v19 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("reduced?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns true if x is the result of a call to reduced", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)), lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2834), lang.NewKeyword("end-line"), int(2834))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := lang.Apply(lang.IsReduced, []any{v4}) + return v5 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // reductions + { + v0 := lang.NewSymbol("reductions").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy seq of the intermediate values of the reduction (as\n per reduce) of coll by f, starting with init.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7196), lang.NewKeyword("end-line"), int(7196))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 lang.FnFunc + v5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v6 any + { // let + // let binding "temp__0__auto__" + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("seq")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, []any{v4}) + var v11 any = v10 + _ = v11 + var v12 any + if lang.IsTruthy(v11) { + var v13 any + { // let + // let binding "s" + var v14 any = v11 + _ = v14 + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("reductions")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("first")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.Apply(v20, []any{v14}) + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("rest")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v14}) + v26 := lang.Apply(v17, []any{v3, v21, v25}) + v13 = v26 + } // end let + v12 = v13 + } else { + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v3, nil) + v18 := lang.Apply(v16, []any{v17}) + v12 = v18 + } + v6 = v12 + } // end let + return v6 + }) + v6 := lang.Apply(lang.NewLazySeq, []any{v5}) + return v6 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("reduced?")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, []any{v4}) + if lang.IsTruthy(v10) { + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("list")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("deref")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{v4}) + v18 := lang.Apply(v13, []any{v17}) + v6 = v18 + } else { + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("cons")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + var v22 lang.FnFunc + v22 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v23 any + { // let + // let binding "temp__0__auto__" + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("seq")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.Apply(v26, []any{v5}) + var v28 any = v27 + _ = v28 + var v29 any + if lang.IsTruthy(v28) { + var v30 any + { // let + // let binding "s" + var v31 any = v28 + _ = v31 + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("reductions")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v36 := v35.FindInternedVar(lang.NewSymbol("first")) + if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + } + v37 := v36.Get() + v38 := lang.Apply(v37, []any{v31}) + v39 := lang.Apply(v3, []any{v4, v38}) + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("rest")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.Apply(v42, []any{v31}) + v44 := lang.Apply(v34, []any{v3, v39, v43}) + v30 = v44 + } // end let + v29 = v30 + } else { + v29 = nil + } + v23 = v29 + } // end let + return v23 + }) + v23 := lang.Apply(lang.NewLazySeq, []any{v22}) + v24 := lang.Apply(v21, []any{v4, v23}) + v6 = v24 + } + return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // ref + { + v0 := lang.NewSymbol("ref").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Creates and returns a Ref with an initial value of x and zero or\n more options (in any order):\n\n :meta metadata-map\n\n :validator validate-fn\n\n :min-history (default 0)\n :max-history (default 10)\n\n If metadata-map is supplied, it will become the metadata on the\n ref. validate-fn must be nil or a side-effect-free fn of one\n argument, which will be passed the intended new state on any state\n change. If the new state is unacceptable, the validate-fn should\n return false or throw an exception. validate-fn will be called on\n transaction commit, when all refs have their final values.\n\n Normally refs accumulate history dynamically as needed to deal with\n read demands. If you know in advance you will need history you can\n set :min-history to ensure it will be available when first needed (instead\n of after a read fault). History is limited, and the limit can be set\n with :max-history.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2260), lang.NewKeyword("end-line"), int(2260))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + v4 := lang.Apply(lang.NewRef, []any{v3}) + return v4 + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.NewList(args[1:]...) + var v5 any + { // let + // let binding "r" + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("setup-reference")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("ref")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.Apply(v11, []any{v3}) + v13 := lang.Apply(v8, []any{v12, v4}) + var v14 any = v13 + _ = v14 + // let binding "opts" + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("apply")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("hash-map")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.Apply(v17, []any{v20, v4}) + var v22 any = v21 + _ = v22 + var v23 any + v24 := lang.Apply(lang.NewKeyword("max-history"), []any{v22}) + if lang.IsTruthy(v24) { + v25 := lang.Apply(lang.NewKeyword("max-history"), []any{v22}) + v26, _ := lang.FieldOrMethod(v14, "setMaxHistory") + if reflect.TypeOf(v26).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMaxHistory is not a function"))) + } + v27 := lang.Apply(v26, []any{v25}) + v23 = v27 + } else { + v23 = nil + } + _ = v23 + var v28 any + v29 := lang.Apply(lang.NewKeyword("min-history"), []any{v22}) + if lang.IsTruthy(v29) { + v30 := lang.Apply(lang.NewKeyword("min-history"), []any{v22}) + v31, _ := lang.FieldOrMethod(v14, "setMinHistory") + if reflect.TypeOf(v31).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMinHistory is not a function"))) + } + v32 := lang.Apply(v31, []any{v30}) + v28 = v32 + } else { + v28 = nil + } + _ = v28 + v5 = v14 + } // end let + return v5 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // ref-history-count + { + v0 := lang.NewSymbol("ref-history-count").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref"))), lang.NewKeyword("doc"), "Returns the history count of a ref", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2455), lang.NewKeyword("end-line"), int(2455))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4, ok := lang.FieldOrMethod(v3, "getHistoryCount") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getHistoryCount"))) + } + var v5 any + switch reflect.TypeOf(v4).Kind() { + case reflect.Func: + v5 = lang.Apply(v4, nil) + default: + v5 = v4 + } + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // ref-max-history + { + v0 := lang.NewSymbol("ref-max-history").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref")), lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Gets the max-history of a ref, or sets it and returns the ref", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2471), lang.NewKeyword("end-line"), int(2471))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + v4, ok := lang.FieldOrMethod(v3, "getMaxHistory") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getMaxHistory"))) + } + var v5 any + switch reflect.TypeOf(v4).Kind() { + case reflect.Func: + v5 = lang.Apply(v4, nil) + default: + v5 = v4 + } + return v5 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5, _ := lang.FieldOrMethod(v3, "setMaxHistory") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMaxHistory is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // ref-min-history + { + v0 := lang.NewSymbol("ref-min-history").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref")), lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Gets the min-history of a ref, or sets it and returns the ref", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2462), lang.NewKeyword("end-line"), int(2462))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + v4, ok := lang.FieldOrMethod(v3, "getMinHistory") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getMinHistory"))) + } + var v5 any + switch reflect.TypeOf(v4).Kind() { + case reflect.Func: + v5 = lang.Apply(v4, nil) + default: + v5 = v4 + } + return v5 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5, _ := lang.FieldOrMethod(v3, "setMinHistory") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMinHistory is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // ref-set + { + v0 := lang.NewSymbol("ref-set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Must be called in a transaction. Sets the value of ref.\n Returns val.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2447), lang.NewKeyword("end-line"), int(2447))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5, _ := lang.FieldOrMethod(v3, "set") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("set is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // refer + { + v0 := lang.NewSymbol("refer").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns-sym"), lang.NewSymbol("&"), lang.NewSymbol("filters"))), lang.NewKeyword("doc"), "refers to all public vars of ns, subject to filters.\n filters can include at most one each of:\n\n :exclude list-of-symbols\n :only list-of-symbols\n :rename map-of-fromsymbol-tosymbol\n\n For each public interned var in the namespace named by the symbol,\n adds a mapping from the name of the var to the var to the current\n namespace. Throws an exception if name is already mapped to\n something else in the current namespace. Filters can be used to\n select a subset, via inclusion or exclusion, or to provide a mapping\n to a symbol different from the var's name, in order to prevent\n clashes. Use :use in the ns macro in preference to calling this directly.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4216), lang.NewKeyword("end-line"), int(4216))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.NewList(args[1:]...) + var v5 any + { // let + // let binding "ns" + var v6 any + { // let + // let binding "or__0__auto__" + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("find-ns")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, []any{v3}) + var v11 any = v10 + _ = v11 + var v12 any + if lang.IsTruthy(v11) { + v12 = v11 + } else { + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("str")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{"No namespace: ", v3}) + v17 := lang.Apply(errors5.New, []any{v16}) + panic(v17) + } + v6 = v12 + } // end let + var v7 any = v6 + _ = v7 + // let binding "fs" + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("apply")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("hash-map")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v10, []any{v13, v4}) + var v15 any = v14 + _ = v15 + // let binding "nspublics" + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("ns-publics")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{v7}) + var v20 any = v19 + _ = v20 + // let binding "rename" + var v21 any + { // let + // let binding "or__0__auto__" + v22 := lang.Apply(lang.NewKeyword("rename"), []any{v15}) + var v23 any = v22 + _ = v23 + var v24 any + if lang.IsTruthy(v23) { + v24 = v23 + } else { + v25 := lang.NewMap() + v26 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4236), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(4236), lang.NewKeyword("end-column"), int(36)) + v27, err := lang.WithMeta(v25, v26.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v24 = v27 + } + v21 = v24 + } // end let + var v22 any = v21 + _ = v22 + // let binding "exclude" + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("set")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.Apply(lang.NewKeyword("exclude"), []any{v15}) + v27 := lang.Apply(v25, []any{v26}) + var v28 any = v27 + _ = v28 + // let binding "to-do" + var v29 any + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("=")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.Apply(lang.NewKeyword("refer"), []any{v15}) + v34 := lang.Apply(v32, []any{lang.NewKeyword("all"), v33}) + if lang.IsTruthy(v34) { + v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v36 := v35.FindInternedVar(lang.NewSymbol("keys")) + if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + } + v37 := v36.Get() + v38 := lang.Apply(v37, []any{v20}) + v29 = v38 + } else { + var v39 any + { // let + // let binding "or__0__auto__" + v40 := lang.Apply(lang.NewKeyword("refer"), []any{v15}) + var v41 any = v40 + _ = v41 + var v42 any + if lang.IsTruthy(v41) { + v42 = v41 + } else { + var v43 any + { // let + // let binding "or__0__auto__" + v44 := lang.Apply(lang.NewKeyword("only"), []any{v15}) + var v45 any = v44 + _ = v45 + var v46 any + if lang.IsTruthy(v45) { + v46 = v45 + } else { + v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v48 := v47.FindInternedVar(lang.NewSymbol("keys")) + if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) + } + v49 := v48.Get() + v50 := lang.Apply(v49, []any{v20}) + v46 = v50 + } + v43 = v46 + } // end let + v42 = v43 + } + v39 = v42 + } // end let + v29 = v39 + } + var v40 any = v29 + _ = v40 + var v41 any + var v42 any + { // let + // let binding "and__0__auto__" + var v43 any = v40 + _ = v43 + var v44 any + if lang.IsTruthy(v43) { + v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v46 := v45.FindInternedVar(lang.NewSymbol("not")) + if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) + } + v47 := v46.Get() + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("instance?")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{lang.Sequential, v40}) + v52 := lang.Apply(v47, []any{v51}) + v44 = v52 + } else { + v44 = v43 + } + v42 = v44 + } // end let + if lang.IsTruthy(v42) { + v43 := lang.Apply(errors5.New, []any{":only/:refer value must be a sequential collection of symbols"}) + panic(v43) + } else { + v41 = nil + } + _ = v41 + var v44 any + { // let + // let binding "seq_9" + v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v46 := v45.FindInternedVar(lang.NewSymbol("seq")) + if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) + } + v47 := v46.Get() + v48 := lang.Apply(v47, []any{v40}) + var v49 any = v48 + _ = v49 + // let binding "chunk_10" + var v50 any = nil + _ = v50 + // let binding "count_11" + var v51 any = int64(0) + _ = v51 + // let binding "i_12" + var v52 any = int64(0) + _ = v52 + for { + var v53 any + v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v55 := v54.FindInternedVar(lang.NewSymbol("<")) + if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) + } + v56 := v55.Get() + v57 := lang.Apply(v56, []any{v52, v51}) + if lang.IsTruthy(v57) { + var v58 any + { // let + // let binding "sym" + v59, _ := lang.FieldOrMethod(v50, "nth") + if reflect.TypeOf(v59).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + v60 := lang.Apply(v59, []any{v52}) + var v61 any = v60 + _ = v61 + var v62 any + v63 := lang.Apply(v28, []any{v61}) + if lang.IsTruthy(v63) { + v62 = nil + } else { + var v64 any + { // let + // let binding "v" + v65 := lang.Apply(v20, []any{v61}) + var v66 any = v65 + _ = v66 + var v67 any + if lang.IsTruthy(v66) { + v67 = nil + } else { + panic("unimplemented: new with non-constant class type") + } + _ = v67 + v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v69 := v68.FindInternedVar(lang.NewSymbol("*ns*")) + if v69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) + } + v70 := v69.Get() + var v71 any + { // let + // let binding "or__0__auto__" + v72 := lang.Apply(v22, []any{v61}) + var v73 any = v72 + _ = v73 + var v74 any + if lang.IsTruthy(v73) { + v74 = v73 + } else { + v74 = v61 + } + v71 = v74 + } // end let + v72, _ := lang.FieldOrMethod(v70, "Refer") + if reflect.TypeOf(v72).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Refer is not a function"))) + } + v73 := lang.Apply(v72, []any{v71, v66}) + v64 = v73 + } // end let + v62 = v64 + } + _ = v62 + var v65 any = v49 + var v66 any = v50 + var v67 any = v51 + v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v70 := v69.FindInternedVar(lang.NewSymbol("unchecked-inc")) + if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) + } + v71 := v70.Get() + v72 := lang.Apply(v71, []any{v52}) + var v68 any = v72 + v49 = v65 + v50 = v66 + v51 = v67 + v52 = v68 + continue + } // end let + v53 = v58 + } else { + var v59 any + { // let + // let binding "temp__0__auto__" + v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v61 := v60.FindInternedVar(lang.NewSymbol("seq")) + if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) + } + v62 := v61.Get() + v63 := lang.Apply(v62, []any{v49}) + var v64 any = v63 + _ = v64 + var v65 any + if lang.IsTruthy(v64) { + var v66 any + { // let + // let binding "seq_9" + var v67 any = v64 + _ = v67 + var v68 any + v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v70 := v69.FindInternedVar(lang.NewSymbol("chunked-seq?")) + if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) + } + v71 := v70.Get() + v72 := lang.Apply(v71, []any{v67}) + if lang.IsTruthy(v72) { + var v73 any + { // let + // let binding "c__0__auto__" + v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v75 := v74.FindInternedVar(lang.NewSymbol("chunk-first")) + if v75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) + } + v76 := v75.Get() + v77 := lang.Apply(v76, []any{v67}) + var v78 any = v77 + _ = v78 + v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v81 := v80.FindInternedVar(lang.NewSymbol("chunk-rest")) + if v81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) + } + v82 := v81.Get() + v83 := lang.Apply(v82, []any{v67}) + var v79 any = v83 + var v84 any = v78 + v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v87 := v86.FindInternedVar(lang.NewSymbol("int")) + if v87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) + } + v88 := v87.Get() + v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v90 := v89.FindInternedVar(lang.NewSymbol("count")) + if v90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) + } + v91 := v90.Get() + v92 := lang.Apply(v91, []any{v78}) + v93 := lang.Apply(v88, []any{v92}) + var v85 any = v93 + v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v96 := v95.FindInternedVar(lang.NewSymbol("int")) + if v96.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) + } + v97 := v96.Get() + v98 := lang.Apply(v97, []any{int64(0)}) + var v94 any = v98 + v49 = v79 + v50 = v84 + v51 = v85 + v52 = v94 + continue + } // end let + v68 = v73 + } else { + var v74 any + { // let + // let binding "sym" + v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v76 := v75.FindInternedVar(lang.NewSymbol("first")) + if v76.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) + } + v77 := v76.Get() + v78 := lang.Apply(v77, []any{v67}) + var v79 any = v78 + _ = v79 + var v80 any + v81 := lang.Apply(v28, []any{v79}) + if lang.IsTruthy(v81) { + v80 = nil + } else { + var v82 any + { // let + // let binding "v" + v83 := lang.Apply(v20, []any{v79}) + var v84 any = v83 + _ = v84 + var v85 any + if lang.IsTruthy(v84) { + v85 = nil + } else { + panic("unimplemented: new with non-constant class type") + } + _ = v85 + v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v87 := v86.FindInternedVar(lang.NewSymbol("*ns*")) + if v87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) + } + v88 := v87.Get() + var v89 any + { // let + // let binding "or__0__auto__" + v90 := lang.Apply(v22, []any{v79}) + var v91 any = v90 + _ = v91 + var v92 any + if lang.IsTruthy(v91) { + v92 = v91 + } else { + v92 = v79 + } + v89 = v92 + } // end let + v90, _ := lang.FieldOrMethod(v88, "Refer") + if reflect.TypeOf(v90).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Refer is not a function"))) + } + v91 := lang.Apply(v90, []any{v89, v84}) + v82 = v91 + } // end let + v80 = v82 + } + _ = v80 + v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v85 := v84.FindInternedVar(lang.NewSymbol("next")) + if v85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) + } + v86 := v85.Get() + v87 := lang.Apply(v86, []any{v67}) + var v83 any = v87 + var v88 any = nil + var v89 any = int64(0) + var v90 any = int64(0) + v49 = v83 + v50 = v88 + v51 = v89 + v52 = v90 + continue + } // end let + v68 = v74 + } + v66 = v68 + } // end let + v65 = v66 + } else { + v65 = nil + } + v59 = v65 + } // end let + v53 = v59 + } + v44 = v53 + break + } + } // end let + v5 = v44 + } // end let + return v5 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // refer-glojure + { + v0 := lang.NewSymbol("refer-glojure").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("filters"))), lang.NewKeyword("doc"), "Same as (refer 'glojure.core )", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5800), lang.NewKeyword("end-line"), int(5800))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.NewList(args[2:]...) + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("seq")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("concat")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("list")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.Apply(v14, []any{lang.NewSymbol("glojure.core/refer")}) + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("list")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("seq")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("concat")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("list")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.Apply(v27, []any{lang.NewSymbol("quote")}) + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("list")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.Apply(v31, []any{lang.NewSymbol("glojure.core")}) + v33 := lang.Apply(v24, []any{v28, v32}) + v34 := lang.Apply(v21, []any{v33}) + v35 := lang.Apply(v18, []any{v34}) + v36 := lang.Apply(v11, []any{v15, v35, v5}) + v37 := lang.Apply(v8, []any{v36}) + return v37 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // release-pending-sends + { + v0 := lang.NewSymbol("release-pending-sends").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Normally, actions sent directly or indirectly during another action\n are held until the action completes (changes the agent's\n state). This function can be used to dispatch any pending sent\n actions immediately. This has no impact on actions sent during a\n transaction, which are still held until commit. If no action is\n occurring, does nothing. Returns the number of actions dispatched.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2131), lang.NewKeyword("end-line"), int(2131))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := lang.Apply(nil, nil) + return v3 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // rem + { + var v1 lang.FnFunc + { // function rem__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("seq")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("concat")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("list")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("list")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("list")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("seq")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("concat")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("list")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/Remainder")}) + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("list")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{v3}) + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("list")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v38, []any{v4}) + v40 := lang.Apply(v27, []any{v31, v35, v39}) + v41 := lang.Apply(v24, []any{v40}) + v42 := lang.Apply(v21, []any{v41}) + v43 := lang.Apply(v10, []any{v14, v18, v42}) + v44 := lang.Apply(v7, []any{v43}) + return v44 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("rem").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"), lang.NewSymbol("div"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "remainder of dividing numerator by denominator.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1274), lang.NewKeyword("end-line"), int(1274))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6, _ := lang.FieldOrMethod(lang.Numbers, "Remainder") + if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Remainder is not a function"))) + } + v7 := lang.Apply(v6, []any{v4, v5}) + return v7 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // remove + { + v0 := lang.NewSymbol("remove").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred")), lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the items in coll for which\n (pred item) returns logical false. pred must be free of side-effects.\n Returns a transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2818), lang.NewKeyword("end-line"), int(2818))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("filter")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("complement")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, []any{v3}) + v11 := lang.Apply(v6, []any{v10}) + return v11 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("filter")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("complement")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v3}) + v12 := lang.Apply(v7, []any{v11, v4}) + return v12 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // remove-all-methods + { + v0 := lang.NewSymbol("remove-all-methods").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"))), lang.NewKeyword("doc"), "Removes all of the methods of multimethod.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1787), lang.NewKeyword("end-line"), int(1787))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4, ok := lang.FieldOrMethod(v3, "reset") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "reset"))) + } + var v5 any + switch reflect.TypeOf(v4).Kind() { + case reflect.Func: + v5 = lang.Apply(v4, nil) + default: + v5 = v4 + } + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // remove-method + { + v0 := lang.NewSymbol("remove-method").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"), lang.NewSymbol("dispatch-val"))), lang.NewKeyword("doc"), "Removes the method of multimethod associated with dispatch-value.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1794), lang.NewKeyword("end-line"), int(1794))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5, _ := lang.FieldOrMethod(v3, "removeMethod") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("removeMethod is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // remove-ns + { + v0 := lang.NewSymbol("remove-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Removes the namespace named by the symbol. Use with caution.\n Cannot be used to remove the glojure namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4139), lang.NewKeyword("end-line"), int(4139))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.Apply(lang.RemoveNamespace, []any{v3}) + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // remove-tap + { + v0 := lang.NewSymbol("remove-tap").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Remove f from the tap set.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7883), lang.NewKeyword("end-line"), int(7883))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("swap!")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("tapset")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("disj")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v6, []any{v9, v12, v3}) + _ = v13 + return nil + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // remove-watch + { + v0 := lang.NewSymbol("remove-watch").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("reference"), lang.NewSymbol("key"))), lang.NewKeyword("doc"), "Removes a watch (set by add-watch) from a reference", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2160), lang.NewKeyword("end-line"), int(2160))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5, _ := lang.FieldOrMethod(v3, "removeWatch") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("removeWatch is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // repeat + { + v0 := lang.NewSymbol("repeat").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns a lazy (infinite!, or length n if supplied) sequence of xs.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2997), lang.NewKeyword("end-line"), int(2997))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + v4 := lang.Apply(lang.NewRepeat, []any{v3}) + return v4 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.Apply(lang.NewRepeatN, []any{v3, v4}) + return v5 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // repeatedly + { + v0 := lang.NewSymbol("repeatedly").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Takes a function of no args, presumably with side effects, and\n returns an infinite (or length n if supplied) lazy sequence of calls\n to it", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5167), lang.NewKeyword("end-line"), int(5167))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + var v4 lang.FnFunc + v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("cons")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v3, nil) + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("repeatedly")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.Apply(v11, []any{v3}) + v13 := lang.Apply(v7, []any{v8, v12}) + return v13 + }) + v5 := lang.Apply(lang.NewLazySeq, []any{v4}) + return v5 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("take")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("repeatedly")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v4}) + v12 := lang.Apply(v7, []any{v3, v11}) + return v12 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // replace + { + v0 := lang.NewSymbol("replace").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("smap")), lang.NewVector(lang.NewSymbol("smap"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Given a map of replacement pairs and a vector/collection, returns a\n vector/seq with any elements = a key in smap replaced with the\n corresponding val in smap. Returns a transducer when no collection\n is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5082), lang.NewKeyword("end-line"), int(5082))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("map")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + var v7 lang.FnFunc + v7 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v8 := args[0] + _ = v8 + var v9 any + { // let + // let binding "temp__0__auto__" + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("find")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{v3, v8}) + var v14 any = v13 + _ = v14 + var v15 any + if lang.IsTruthy(v14) { + var v16 any + { // let + // let binding "e" + var v17 any = v14 + _ = v17 + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("val")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.Apply(v20, []any{v17}) + v16 = v21 + } // end let + v15 = v16 + } else { + v15 = v8 + } + v9 = v15 + } // end let + return v9 + }) + v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5090), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5090), lang.NewKeyword("end-column"), int(47)) + v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v10 := lang.Apply(v6, []any{v9}) + return v10 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("vector?")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{v4}) + if lang.IsTruthy(v9) { + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("reduce1")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + var v13 lang.FnFunc + v13 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v14 := args[0] + _ = v14 + v15 := args[1] + _ = v15 + var v16 any + { // let + // let binding "temp__0__auto__" + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("find")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("nth")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.Apply(v22, []any{v14, v15}) + v24 := lang.Apply(v19, []any{v3, v23}) + var v25 any = v24 + _ = v25 + var v26 any + if lang.IsTruthy(v25) { + var v27 any + { // let + // let binding "e" + var v28 any = v25 + _ = v28 + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("assoc")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("val")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{v28}) + v36 := lang.Apply(v31, []any{v14, v15, v35}) + v27 = v36 + } // end let + v26 = v27 + } else { + v26 = v14 + } + v16 = v26 + } // end let + return v16 + }) + v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5093), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(5096), lang.NewKeyword("end-column"), int(23)) + v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("range")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("count")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{v4}) + v23 := lang.Apply(v18, []any{v22}) + v24 := lang.Apply(v12, []any{v15, v4, v23}) + v5 = v24 + } else { + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("map")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + var v28 lang.FnFunc + v28 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v29 := args[0] + _ = v29 + var v30 any + { // let + // let binding "temp__0__auto__" + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("find")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{v3, v29}) + var v35 any = v34 + _ = v35 + var v36 any + if lang.IsTruthy(v35) { + var v37 any + { // let + // let binding "e" + var v38 any = v35 + _ = v38 + v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v40 := v39.FindInternedVar(lang.NewSymbol("val")) + if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) + } + v41 := v40.Get() + v42 := lang.Apply(v41, []any{v38}) + v37 = v42 + } // end let + v36 = v37 + } else { + v36 = v29 + } + v30 = v36 + } // end let + return v30 + }) + v29 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5098), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(5098), lang.NewKeyword("end-column"), int(49)) + v30, err := lang.WithMeta(v28, v29.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v31 := lang.Apply(v27, []any{v30, v4}) + v5 = v31 + } + return v5 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // replicate + { + v0 := lang.NewSymbol("replicate").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "DEPRECATED: Use 'repeat' instead.\n Returns a lazy seq of n xs.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("deprecated"), "1.3", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3004), lang.NewKeyword("end-line"), int(3004))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("take")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("repeat")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v4}) + v12 := lang.Apply(v7, []any{v3, v11}) + return v12 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // require + { + v0 := lang.NewSymbol("require").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Loads libs, skipping any that are already loaded. Each argument is\n either a libspec that identifies a lib, a prefix list that identifies\n multiple libs whose names share a common prefix, or a flag that modifies\n how all the identified libs are loaded. Use :require in the ns macro\n in preference to calling this directly.\n\n Libs\n\n A 'lib' is a named set of resources in classpath whose contents define a\n library of Clojure code. Lib names are symbols and each lib is associated\n with a Clojure namespace and a Java package that share its name. A lib's\n name also locates its root directory within classpath using Java's\n package name to classpath-relative path mapping. All resources in a lib\n should be contained in the directory structure under its root directory.\n All definitions a lib makes should be in its associated namespace.\n\n 'require loads a lib by loading its root resource. The root resource path\n is derived from the lib name in the following manner:\n Consider a lib named by the symbol 'x.y.z; it has the root directory\n /x/y/, and its root resource is /x/y/z.clj, or\n /x/y/z.cljc if /x/y/z.clj does not exist. The\n root resource should contain code to create the lib's\n namespace (usually by using the ns macro) and load any additional\n lib resources.\n\n Libspecs\n\n A libspec is a lib name or a vector containing a lib name followed by\n options expressed as sequential keywords and arguments.\n\n Recognized options:\n :as takes a symbol as its argument and makes that symbol an alias to the\n lib's namespace in the current namespace.\n :as-alias takes a symbol as its argument and aliases like :as, however\n the lib will not be loaded. If the lib has not been loaded, a new\n empty namespace will be created (as with create-ns).\n :refer takes a list of symbols to refer from the namespace or the :all\n keyword to bring in all public vars.\n\n Prefix Lists\n\n It's common for Clojure code to depend on several libs whose names have\n the same prefix. When specifying libs, prefix lists can be used to reduce\n repetition. A prefix list contains the shared prefix followed by libspecs\n with the shared prefix removed from the lib names. After removing the\n prefix, the names that remain must not contain any periods.\n\n Flags\n\n A flag is a keyword.\n Recognized flags: :reload, :reload-all, :verbose\n :reload forces loading of all the identified libs even if they are\n already loaded (has no effect on libspecs using :as-alias)\n :reload-all implies :reload and also forces loading of all libs that the\n identified libs directly or indirectly load via require or use\n (has no effect on libspecs using :as-alias)\n :verbose triggers printing information about each load, alias, and refer\n\n Example:\n\n The following would load the libraries glojure.zip and glojure.set\n abbreviated as 's'.\n\n (require '(glojure zip [set :as s]))", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5989), lang.NewKeyword("end-line"), int(5989))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := lang.NewList(args[0:]...) + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("apply")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("load-libs")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v6, []any{v9, lang.NewKeyword("require"), v3}) + return v10 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // requiring-resolve + { + v0 := lang.NewSymbol("requiring-resolve").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Resolves namespace-qualified sym per 'resolve'. If initial resolve\nfails, attempts to require sym's namespace and retries.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6068), lang.NewKeyword("end-line"), int(6068))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("qualified-symbol?")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v3}) + if lang.IsTruthy(v8) { + var v9 any + { // let + // let binding "or__0__auto__" + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("resolve")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{v3}) + var v14 any = v13 + _ = v14 + var v15 any + if lang.IsTruthy(v14) { + v15 = v14 + } else { + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("serialized-require")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("symbol")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("namespace")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v3}) + v26 := lang.Apply(v21, []any{v25}) + v27 := lang.Apply(v18, []any{v26}) + _ = v27 + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("resolve")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.Apply(v30, []any{v3}) + v15 = v31 + } + v9 = v15 + } // end let + v4 = v9 + } else { + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("str")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{"Not a qualified symbol: ", v3}) + v14 := lang.Apply(lang.NewIllegalArgumentError, []any{v13}) + panic(v14) + } + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // reset! + { + v0 := lang.NewSymbol("reset!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atom"), lang.NewSymbol("newval"))), lang.NewKeyword("doc"), "Sets the value of atom to newval without regard for the\n current value. Returns newval.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2368), lang.NewKeyword("end-line"), int(2368))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5, _ := lang.FieldOrMethod(v3, "reset") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // reset-meta! + { + v0 := lang.NewSymbol("reset-meta!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("iref"), lang.NewSymbol("metadata-map"))), lang.NewKeyword("doc"), "Atomically resets the metadata for a namespace/var/ref/agent/atom", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2408), lang.NewKeyword("end-line"), int(2408))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5, _ := lang.FieldOrMethod(v3, "ResetMeta") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ResetMeta is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // reset-vals! + { + v0 := lang.NewSymbol("reset-vals!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atom"), lang.NewSymbol("newval"))), lang.NewKeyword("doc"), "Sets the value of atom to newval. Returns [old new], the value of the\n atom before and after the reset.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2375), lang.NewKeyword("end-line"), int(2375))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5, _ := lang.FieldOrMethod(v3, "resetVals") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("resetVals is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // resolve + { + v0 := lang.NewSymbol("resolve").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym")), lang.NewVector(lang.NewSymbol("env"), lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "same as (ns-resolve *ns* symbol) or (ns-resolve *ns* &env symbol)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4371), lang.NewKeyword("end-line"), int(4371))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("ns-resolve")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("*ns*")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v6, []any{v9, v3}) + return v10 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("ns-resolve")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("*ns*")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v7, []any{v10, v3, v4}) + return v11 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // rest + { + v1 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() + v0 := lang.NewSymbol("rest").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a possibly empty seq of the items after the first. Calls seq on its\n argument.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(64), lang.NewKeyword("end-line"), int(70))).(*lang.Symbol) + var v3 lang.FnFunc + { // function rest + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + v6 := lang.Apply(lang.Rest, []any{v5}) + return v6 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(70), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(70), lang.NewKeyword("end-column"), int(77))).(lang.FnFunc) + v4 := v3 + _ = v4 + } + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // restart-agent + { + v0 := lang.NewSymbol("restart-agent").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("new-state"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "When an agent is failed, changes the agent state to new-state and\n then un-fails the agent so that sends are allowed again. If\n a :clear-actions true option is given, any actions queued on the\n agent that were being held while it was failed will be discarded,\n otherwise those held actions will proceed. The new-state must pass\n the validator if any, or restart will throw an exception and the\n agent will remain failed with its old state and error. Watchers, if\n any, will NOT be notified of the new state. Throws an exception if\n the agent is not failed.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2175), lang.NewKeyword("end-line"), int(2175))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.NewList(args[2:]...) + var v6 any + { // let + // let binding "opts" + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("apply")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("hash-map")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v9, []any{v12, v5}) + var v14 any = v13 + _ = v14 + var v15 any + v16 := lang.Apply(lang.NewKeyword("clear-actions"), []any{v14}) + if lang.IsTruthy(v16) { + v15 = true + } else { + v15 = false + } + v17, _ := lang.FieldOrMethod(v3, "restart") + if reflect.TypeOf(v17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("restart is not a function"))) + } + v18 := lang.Apply(v17, []any{v4, v15}) + v6 = v18 + } // end let + return v6 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // resultset-seq + { + v0 := lang.NewSymbol("resultset-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rs"))), lang.NewKeyword("doc"), "Creates and returns a lazy sequence of structmaps corresponding to\n the rows in the java.sql.ResultSet rs", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5681), lang.NewKeyword("end-line"), int(5681))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + { // let + // let binding "rsmeta" + v5, _ := lang.FieldOrMethod(v3, "getMetaData") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getMetaData is not a function"))) + } + v6 := lang.Apply(v5, []any{}) + var v7 any = v6 + _ = v7 + // let binding "idxs" + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("range")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("inc")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14, _ := lang.FieldOrMethod(v7, "getColumnCount") + if reflect.TypeOf(v14).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getColumnCount is not a function"))) + } + v15 := lang.Apply(v14, []any{}) + v16 := lang.Apply(v13, []any{v15}) + v17 := lang.Apply(v10, []any{int64(1), v16}) + var v18 any = v17 + _ = v18 + // let binding "keys" + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("map")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("comp")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("keyword")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + var v28 lang.FnFunc + v28 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v29 := args[0] + _ = v29 + v30, ok := lang.FieldOrMethod(v29, "toLowerCase") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v29, "toLowerCase"))) + } + var v31 any + switch reflect.TypeOf(v30).Kind() { + case reflect.Func: + v31 = lang.Apply(v30, nil) + default: + v31 = v30 + } + return v31 + }) + v29 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5688), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(5688), lang.NewKeyword("end-column"), int(62)) + v30, err := lang.WithMeta(v28, v29.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v31 := lang.Apply(v24, []any{v27, v30}) + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("map")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + var v35 lang.FnFunc + v35 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v36 := args[0] + _ = v36 + v37, _ := lang.FieldOrMethod(v7, "getColumnLabel") + if reflect.TypeOf(v37).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getColumnLabel is not a function"))) + } + v38 := lang.Apply(v37, []any{v36}) + return v38 + }) + v36 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5689), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(5689), lang.NewKeyword("end-column"), int(63)) + v37, err := lang.WithMeta(v35, v36.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v38 := lang.Apply(v34, []any{v37, v18}) + v39 := lang.Apply(v21, []any{v31, v38}) + var v40 any = v39 + _ = v40 + // let binding "check-keys" + var v41 any + { // let + // let binding "or__0__auto__" + v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v43 := v42.FindInternedVar(lang.NewSymbol("apply")) + if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) + } + v44 := v43.Get() + v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v46 := v45.FindInternedVar(lang.NewSymbol("distinct?")) + if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) + } + v47 := v46.Get() + v48 := lang.Apply(v44, []any{v47, v40}) + var v49 any = v48 + _ = v49 + var v50 any + if lang.IsTruthy(v49) { + v50 = v49 + } else { + v51 := lang.Apply(lang.NewError, []any{"ResultSet must have unique column labels"}) + panic(v51) + } + v41 = v50 + } // end let + var v42 any = v41 + _ = v42 + // let binding "row-struct" + v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v44 := v43.FindInternedVar(lang.NewSymbol("apply")) + if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) + } + v45 := v44.Get() + v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v47 := v46.FindInternedVar(lang.NewSymbol("create-struct")) + if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) + } + v48 := v47.Get() + v49 := lang.Apply(v45, []any{v48, v40}) + var v50 any = v49 + _ = v50 + // let binding "row-values" + var v51 lang.FnFunc + v51 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v53 := v52.FindInternedVar(lang.NewSymbol("map")) + if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) + } + v54 := v53.Get() + var v55 lang.FnFunc + v55 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v56 := args[0] + _ = v56 + v57, _ := lang.FieldOrMethod(v3, "getObject") + if reflect.TypeOf(v57).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getObject is not a function"))) + } + v58 := lang.Apply(v57, []any{v56}) + return v58 + }) + v56 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5694), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(5694), lang.NewKeyword("end-column"), int(71)) + v57, err := lang.WithMeta(v55, v56.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v58 := lang.Apply(v54, []any{v57, v18}) + return v58 + }) + v52 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5694), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(5694), lang.NewKeyword("end-column"), int(78)) + v53, err := lang.WithMeta(v51, v52.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v54 any = v53 + _ = v54 + // let binding "rows" + var v55 lang.FnFunc + { // function thisfn + v55 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v57 any + v58, _ := lang.FieldOrMethod(v3, "next") + if reflect.TypeOf(v58).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("next is not a function"))) + } + v59 := lang.Apply(v58, []any{}) + if lang.IsTruthy(v59) { + v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v61 := v60.FindInternedVar(lang.NewSymbol("cons")) + if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) + } + v62 := v61.Get() + v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v64 := v63.FindInternedVar(lang.NewSymbol("apply")) + if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) + } + v65 := v64.Get() + v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v67 := v66.FindInternedVar(lang.NewSymbol("struct")) + if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) + } + v68 := v67.Get() + v69 := lang.Apply(v54, nil) + v70 := lang.Apply(v65, []any{v68, v50, v69}) + var v71 lang.FnFunc + v71 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v72 := lang.Apply(v56, nil) + return v72 + }) + v72 := lang.Apply(lang.NewLazySeq, []any{v71}) + v73 := lang.Apply(v62, []any{v70, v72}) + v57 = v73 + } else { + v57 = nil + } + return v57 + }) + v56 := v55 + _ = v56 + } + v56 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5695), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(5697), lang.NewKeyword("end-column"), int(86)) + v57, err := lang.WithMeta(v55, v56.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v58 any = v57 + _ = v58 + v59 := lang.Apply(v58, nil) + v4 = v59 + } // end let + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // reverse + { + v0 := lang.NewSymbol("reverse").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a seq of the items in coll in reverse order. Not lazy.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(940), lang.NewKeyword("end-line"), int(940))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("reduce1")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("conj")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v6, []any{v9, lang.NewList(), v3}) + return v10 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // reversible? + { + v0 := lang.NewSymbol("reversible?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements Reversible", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6257), lang.NewKeyword("end-line"), int(6257))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.Apply(v6, []any{nil, v3}) + return v7 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // root-directory + { + v0 := lang.NewSymbol("root-directory").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"))), lang.NewKeyword("doc"), "Returns the root resource path for a lib", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5871), lang.NewKeyword("end-line"), int(5871), lang.NewKeyword("private"), true)).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + { // let + // let binding "d" + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("root-resource")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v3}) + var v9 any = v8 + _ = v9 + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("subs")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(strings8.LastIndex, []any{v9, "/"}) + v14 := lang.Apply(v12, []any{v9, int64(0), v13}) + v4 = v14 + } // end let + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // root-resource + { + v1 := reflect.TypeOf("") + v0 := lang.NewSymbol("root-resource").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"))), lang.NewKeyword("doc"), "Returns the root directory path for a lib", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5864), lang.NewKeyword("end-line"), int(5864), lang.NewKeyword("private"), true)).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("str")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("name")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v4}) + v12 := lang.Apply(strings8.ReplaceAll, []any{v11, "-", "_"}) + v13 := lang.Apply(strings8.ReplaceAll, []any{v12, ".", "/"}) + v14 := lang.Apply(v7, []any{lang.NewChar(47), v13}) + return v14 + }) + v4 := reflect.TypeOf("") + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // rseq + { + v0 := lang.NewSymbol("rseq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rev"))), lang.NewKeyword("doc"), "Returns, in constant time, a seq of the items in rev (which\n can be a vector or sorted-map), in reverse order. If rev is empty returns nil", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1577), lang.NewKeyword("end-line"), int(1577))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4, _ := lang.FieldOrMethod(v3, "rseq") + if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("rseq is not a function"))) + } + v5 := lang.Apply(v4, []any{}) + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // rsubseq + { + v0 := lang.NewSymbol("rsubseq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sc"), lang.NewSymbol("test"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("sc"), lang.NewSymbol("start-test"), lang.NewSymbol("start-key"), lang.NewSymbol("end-test"), lang.NewSymbol("end-key"))), lang.NewKeyword("doc"), "sc must be a sorted collection, test(s) one of <, <=, > or\n >=. Returns a reverse seq of those entries with keys ek for\n which (test (.. sc comparator (compare ek key)) 0) is true", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5150), lang.NewKeyword("end-line"), int(5150))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any + { // let + // let binding "include" + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("mk-bound-fn")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, []any{v3, v4, v5}) + var v11 any = v10 + _ = v11 + var v12 any + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("<")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("<=")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.CreatePersistentTreeSet(v15, v18) + v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5158), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5158), lang.NewKeyword("end-column"), int(17)) + v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v22 := lang.Apply(v21, []any{v4}) + if lang.IsTruthy(v22) { + var v23 any + { // let + // let binding "temp__0__auto__" + v24, _ := lang.FieldOrMethod(v3, "seqFrom") + if reflect.TypeOf(v24).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("seqFrom is not a function"))) + } + v25 := lang.Apply(v24, []any{v5, false}) + var v26 any = v25 + _ = v26 + var v27 any + if lang.IsTruthy(v26) { + var v28 any + { // let + // let binding "vec__74" + var v29 any = v26 + _ = v29 + // let binding "e" + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("nth")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.Apply(v32, []any{v29, int64(0), nil}) + var v34 any = v33 + _ = v34 + // let binding "s" + var v35 any = v29 + _ = v35 + var v36 any + v37 := lang.Apply(v11, []any{v34}) + if lang.IsTruthy(v37) { + v36 = v35 + } else { + v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v39 := v38.FindInternedVar(lang.NewSymbol("next")) + if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + } + v40 := v39.Get() + v41 := lang.Apply(v40, []any{v35}) + v36 = v41 + } + v28 = v36 + } // end let + v27 = v28 + } else { + v27 = nil + } + v23 = v27 + } // end let + v12 = v23 + } else { + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("take-while")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27, _ := lang.FieldOrMethod(v3, "seq") + if reflect.TypeOf(v27).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("seq is not a function"))) + } + v28 := lang.Apply(v27, []any{false}) + v29 := lang.Apply(v26, []any{v11, v28}) + v12 = v29 + } + v6 = v12 + } // end let + return v6 + case 5: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := args[4] + _ = v7 + var v8 any + { // let + // let binding "temp__0__auto__" + v9, _ := lang.FieldOrMethod(v3, "seqFrom") + if reflect.TypeOf(v9).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("seqFrom is not a function"))) + } + v10 := lang.Apply(v9, []any{v7, false}) + var v11 any = v10 + _ = v11 + var v12 any + if lang.IsTruthy(v11) { + var v13 any + { // let + // let binding "vec__77" + var v14 any = v11 + _ = v14 + // let binding "e" + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("nth")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{v14, int64(0), nil}) + var v19 any = v18 + _ = v19 + // let binding "s" + var v20 any = v14 + _ = v20 + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("take-while")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("mk-bound-fn")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.Apply(v26, []any{v3, v4, v5}) + var v28 any + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("mk-bound-fn")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.Apply(v31, []any{v3, v6, v7}) + v33 := lang.Apply(v32, []any{v19}) + if lang.IsTruthy(v33) { + v28 = v20 + } else { + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("next")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.Apply(v36, []any{v20}) + v28 = v37 + } + v38 := lang.Apply(v23, []any{v27, v28}) + v13 = v38 + } // end let + v12 = v13 + } else { + v12 = nil + } + v8 = v12 + } // end let + return v8 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // run! + { + v0 := lang.NewSymbol("run!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("proc"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Runs the supplied procedure (via reduce), for purposes of side\n effects, on successive items in the collection. Returns nil", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7708), lang.NewKeyword("end-line"), int(7708))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("reduce")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + var v8 lang.FnFunc + v8 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v9 := args[0] + _ = v9 + v10 := args[1] + _ = v10 + v11 := lang.Apply(v3, []any{v10}) + return v11 + }) + v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7713), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(7713), lang.NewKeyword("end-column"), int(20)) + v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v11 := lang.Apply(v7, []any{v10, nil, v4}) + _ = v11 + return nil + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // second + { + v0 := lang.NewSymbol("second").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Same as (first (next x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(91), lang.NewKeyword("end-line"), int(95))).(*lang.Symbol) + var v2 lang.FnFunc + { // function second + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("first")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("next")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v4}) + v12 := lang.Apply(v7, []any{v11}) + return v12 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(95), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(95), lang.NewKeyword("end-column"), int(49))).(lang.FnFunc) + v3 := v2 + _ = v3 + } + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // select-keys + { + v0 := lang.NewSymbol("select-keys").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("keyseq"))), lang.NewKeyword("doc"), "Returns a map containing only those entries in map whose key is in keys", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1536), lang.NewKeyword("end-line"), int(1536))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any + { // let + // let binding "ret" + v6 := lang.NewMap() + v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1541), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(1541), lang.NewKeyword("end-column"), int(17)) + v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v9 any = v8 + _ = v9 + // let binding "keys" + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("seq")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{v4}) + var v14 any = v13 + _ = v14 + for { + var v15 any + if lang.IsTruthy(v14) { + var v16 any + { // let + // let binding "entry" + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("first")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.Apply(v19, []any{v14}) + v21, _ := lang.FieldOrMethod(runtime4.RT, "Find") + if reflect.TypeOf(v21).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Find is not a function"))) + } + v22 := lang.Apply(v21, []any{v3, v20}) + var v23 any = v22 + _ = v23 + var v25 any + if lang.IsTruthy(v23) { + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("conj")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.Apply(v28, []any{v9, v23}) + v25 = v29 + } else { + v25 = v9 + } + var v24 any = v25 + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("next")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{v14}) + var v30 any = v34 + v9 = v24 + v14 = v30 + continue + } // end let + v15 = v16 + } else { + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("with-meta")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("meta")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.Apply(v22, []any{v3}) + v24 := lang.Apply(v19, []any{v9, v23}) + v15 = v24 + } + v5 = v15 + break + } + } // end let + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // send + { + v0 := lang.NewSymbol("send").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Dispatch an action to an agent. Returns the agent immediately.\n Subsequently, in a thread from a thread pool, the state of the agent\n will be set to the value of:\n\n (apply action-fn state-of-agent args)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2109), lang.NewKeyword("end-line"), int(2109))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.NewList(args[2:]...) + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("apply")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("send-via")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.Apply(v8, []any{v11, nil, v3, v4, v5}) + return v12 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // send-off + { + v0 := lang.NewSymbol("send-off").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Dispatch a potentially blocking action to an agent. Returns the\n agent immediately. Subsequently, in a separate thread, the state of\n the agent will be set to the value of:\n\n (apply action-fn state-of-agent args)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2120), lang.NewKeyword("end-line"), int(2120))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.NewList(args[2:]...) + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("apply")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("send-via")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.Apply(v8, []any{v11, nil, v3, v4, v5}) + return v12 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // send-via + { + v0 := lang.NewSymbol("send-via").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("executor"), lang.NewSymbol("a"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Dispatch an action to an agent. Returns the agent immediately.\n Subsequently, in a thread supplied by executor, the state of the agent\n will be set to the value of:\n\n (apply action-fn state-of-agent args)", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2099), lang.NewKeyword("end-line"), int(2099))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + var v7 any + { // let + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("push-thread-bindings")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("hash-map")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*agent*")) + v15 := lang.Apply(v13, []any{v14, v4}) + v16 := lang.Apply(v10, []any{v15}) + _ = v16 + var v17 any + func() { + defer func() { + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.Apply(v20, nil) + }() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("binding-conveyor-fn")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v5}) + v17 = v25 + }() + v7 = v17 + } // end let + v8, _ := lang.FieldOrMethod(v4, "dispatch") + if reflect.TypeOf(v8).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("dispatch is not a function"))) + } + v9 := lang.Apply(v8, []any{v7, v6, v3}) + return v9 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // seq + { + v1 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() + v0 := lang.NewSymbol("seq").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a seq on the collection. If the collection is\n empty, returns nil. (seq nil) returns nil. seq also works on\n Strings, native Java arrays (of reference types) and any objects\n that implement Iterable. Note that seqs cache values, thus seq\n should not be used on any Iterable whose iterator repeatedly\n returns the same mutable object.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(4), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(126), lang.NewKeyword("end-line"), int(136))).(*lang.Symbol) + var v3 lang.FnFunc + { // function seq + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + v6 := lang.Apply(lang.Seq, []any{v5}) + return v6 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(136), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(136), lang.NewKeyword("end-column"), int(126))).(lang.FnFunc) + v4 := v3 + _ = v4 + } + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // seq-to-map-for-destructuring + { + v0 := lang.NewSymbol("seq-to-map-for-destructuring").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Builds a map from a seq as described in\n https://glojure.org/reference/special_forms#keyword-arguments", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(34), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4390), lang.NewKeyword("end-line"), int(4390))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("next")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v3}) + if lang.IsTruthy(v8) { + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("to-array")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.Apply(v11, []any{v3}) + v13 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{v12}) + v4 = v13 + } else { + var v14 any + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("seq")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{v3}) + if lang.IsTruthy(v18) { + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("first")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{v3}) + v14 = v22 + } else { + v14 = nil + } + v4 = v14 + } + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // seq? + { + v0 := lang.NewSymbol("seq?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x implements ISeq", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(146), lang.NewKeyword("end-line"), int(150))).(*lang.Symbol) + var v2 lang.FnFunc + { // function seq? + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{lang.ISeq, v4}) + return v8 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(150), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(150), lang.NewKeyword("end-column"), int(87))).(lang.FnFunc) + v3 := v2 + _ = v3 + } + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // seqable? + { + v0 := lang.NewSymbol("seqable?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if the seq function is supported for x", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6204), lang.NewKeyword("end-line"), int(6204))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.Apply(nil, []any{v3}) + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // seque + { + v0 := lang.NewSymbol("seque").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s")), lang.NewVector(lang.NewSymbol("n-or-q"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Creates a queued seq on another (presumably lazy) seq s. The queued\n seq will produce a concrete seq in the background, and can get up to\n n items ahead of the consumer. n-or-q can be an integer n buffer\n size, or an instance of java.util.concurrent BlockingQueue. Note\n that reading from a seque can block if the reader gets ahead of the\n producer.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5419), lang.NewKeyword("end-line"), int(5419))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seque")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.Apply(v6, []any{int64(100), v3}) + return v7 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any + { // let + // let binding "q" + var v6 any + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("instance?")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, []any{nil, v3}) + if lang.IsTruthy(v10) { + v6 = v3 + } else { + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("int")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{v3}) + v15 := lang.Apply(nil, []any{v14}) + v6 = v15 + } + var v16 any = v6 + _ = v16 + // let binding "NIL" + v17 := lang.Apply(reflect.StructOf, []any{nil}) + v18 := lang.Apply(reflect.New, []any{v17}) + v19, ok := lang.FieldOrMethod(v18, "Interface") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v18, "Interface"))) + } + var v20 any + switch reflect.TypeOf(v19).Kind() { + case reflect.Func: + v20 = lang.Apply(v19, nil) + default: + v20 = v19 + } + var v21 any = v20 + _ = v21 + // let binding "agt" + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("agent")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + var v25 lang.FnFunc + v25 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + return v4 + }) + v26 := lang.Apply(lang.NewLazySeq, []any{v25}) + v27 := lang.Apply(v24, []any{v26}) + var v28 any = v27 + _ = v28 + // let binding "log-error" + var v29 lang.FnFunc + v29 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v30 := args[0] + _ = v30 + v31 := args[1] + _ = v31 + var v32 any + v33, _ := lang.FieldOrMethod(v30, "offer") + if reflect.TypeOf(v33).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("offer is not a function"))) + } + v34 := lang.Apply(v33, []any{v30}) + if lang.IsTruthy(v34) { + panic(v31) + } else { + v32 = v31 + } + return v32 + }) + v30 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5435), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(5438), lang.NewKeyword("end-column"), int(26)) + v31, err := lang.WithMeta(v29, v30.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v32 any = v31 + _ = v32 + // let binding "fill" + var v33 lang.FnFunc + v33 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v34 := args[0] + _ = v34 + var v35 any + if lang.IsTruthy(v34) { + var v36 any + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("instance?")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.Apply(v39, []any{nil, v34}) + if lang.IsTruthy(v40) { + v41 := lang.Apply(v32, []any{v16, v34}) + v36 = v41 + } else { + var v42 any + func() { + defer func() { + if r := recover(); r != nil { + if lang.CatchMatches(r, lang.Builtins["any"]) { + v43 := r + _ = v43 + v44 := lang.Apply(v32, []any{v16, v43}) + v42 = v44 + } else { + panic(r) + } + } + }() + var v43 any + { // let + // let binding "G__89" + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("seq")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.Apply(v46, []any{v34}) + var v48 any = v47 + _ = v48 + // let binding "vec__90" + var v49 any = v48 + _ = v49 + // let binding "seq__91" + v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v51 := v50.FindInternedVar(lang.NewSymbol("seq")) + if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) + } + v52 := v51.Get() + v53 := lang.Apply(v52, []any{v49}) + var v54 any = v53 + _ = v54 + // let binding "first__92" + v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v56 := v55.FindInternedVar(lang.NewSymbol("first")) + if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) + } + v57 := v56.Get() + v58 := lang.Apply(v57, []any{v54}) + var v59 any = v58 + _ = v59 + // let binding "seq__91" + v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v61 := v60.FindInternedVar(lang.NewSymbol("next")) + if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) + } + v62 := v61.Get() + v63 := lang.Apply(v62, []any{v54}) + var v64 any = v63 + _ = v64 + // let binding "x" + var v65 any = v59 + _ = v65 + // let binding "xs" + var v66 any = v64 + _ = v66 + // let binding "s" + var v67 any = v49 + _ = v67 + var v68 any + { // let + // let binding "G__89" + var v69 any = v48 + _ = v69 + for { + var v70 any + { // let + // let binding "vec__93" + var v71 any = v69 + _ = v71 + // let binding "seq__94" + v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v73 := v72.FindInternedVar(lang.NewSymbol("seq")) + if v73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) + } + v74 := v73.Get() + v75 := lang.Apply(v74, []any{v71}) + var v76 any = v75 + _ = v76 + // let binding "first__95" + v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v78 := v77.FindInternedVar(lang.NewSymbol("first")) + if v78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) + } + v79 := v78.Get() + v80 := lang.Apply(v79, []any{v76}) + var v81 any = v80 + _ = v81 + // let binding "seq__94" + v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v83 := v82.FindInternedVar(lang.NewSymbol("next")) + if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) + } + v84 := v83.Get() + v85 := lang.Apply(v84, []any{v76}) + var v86 any = v85 + _ = v86 + // let binding "x" + var v87 any = v81 + _ = v87 + // let binding "xs" + var v88 any = v86 + _ = v88 + // let binding "s" + var v89 any = v71 + _ = v89 + var v90 any + if lang.IsTruthy(v89) { + var v91 any + var v92 any + v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v94 := v93.FindInternedVar(lang.NewSymbol("nil?")) + if v94.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) + } + v95 := v94.Get() + v96 := lang.Apply(v95, []any{v87}) + if lang.IsTruthy(v96) { + v92 = v21 + } else { + v92 = v87 + } + v97, _ := lang.FieldOrMethod(v16, "offer") + if reflect.TypeOf(v97).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("offer is not a function"))) + } + v98 := lang.Apply(v97, []any{v92}) + if lang.IsTruthy(v98) { + var v99 any = v88 + v69 = v99 + continue + } else { + v91 = v89 + } + v90 = v91 + } else { + var v100 any + v101, _ := lang.FieldOrMethod(v16, "offer") + if reflect.TypeOf(v101).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("offer is not a function"))) + } + v102 := lang.Apply(v101, []any{v16}) + if lang.IsTruthy(v102) { + v100 = nil + } else { + v100 = lang.NewList() + } + v90 = v100 + } + v70 = v90 + } // end let + v68 = v70 + break + } + } // end let + v43 = v68 + } // end let + v42 = v43 + }() + v36 = v42 + } + v35 = v36 + } else { + v35 = nil + } + return v35 + }) + v34 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5439), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(5452), lang.NewKeyword("end-column"), int(44)) + v35, err := lang.WithMeta(v33, v34.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v36 any = v35 + _ = v36 + // let binding "drain" + var v37 lang.FnFunc + { // function drain + v37 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v39 lang.FnFunc + v39 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v40 any + { // let + // let binding "x" + v41, ok := lang.FieldOrMethod(v16, "take") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v16, "take"))) + } + var v42 any + switch reflect.TypeOf(v41).Kind() { + case reflect.Func: + v42 = lang.Apply(v41, nil) + default: + v42 = v41 + } + var v43 any = v42 + _ = v43 + var v44 any + v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v46 := v45.FindInternedVar(lang.NewSymbol("identical?")) + if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) + } + v47 := v46.Get() + v48 := lang.Apply(v47, []any{v43, v16}) + if lang.IsTruthy(v48) { + v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v50 := v49.FindInternedVar(lang.NewSymbol("deref")) + if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) + } + v51 := v50.Get() + v52 := lang.Apply(v51, []any{v28}) + _ = v52 + v44 = nil + } else { + v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v54 := v53.FindInternedVar(lang.NewSymbol("send-off")) + if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) + } + v55 := v54.Get() + v56 := lang.Apply(v55, []any{v28, v36}) + _ = v56 + v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v58 := v57.FindInternedVar(lang.NewSymbol("release-pending-sends")) + if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) + } + v59 := v58.Get() + v60 := lang.Apply(v59, nil) + _ = v60 + v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v62 := v61.FindInternedVar(lang.NewSymbol("cons")) + if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) + } + v63 := v62.Get() + var v64 any + v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v66 := v65.FindInternedVar(lang.NewSymbol("identical?")) + if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) + } + v67 := v66.Get() + v68 := lang.Apply(v67, []any{v43, v21}) + if lang.IsTruthy(v68) { + v64 = nil + } else { + v64 = v43 + } + v69 := lang.Apply(v38, nil) + v70 := lang.Apply(v63, []any{v64, v69}) + v44 = v70 + } + v40 = v44 + } // end let + return v40 + }) + v40 := lang.Apply(lang.NewLazySeq, []any{v39}) + return v40 + }) + v38 := v37 + _ = v38 + } + v38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5453), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(5461), lang.NewKeyword("end-column"), int(73)) + v39, err := lang.WithMeta(v37, v38.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v40 any = v39 + _ = v40 + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("send-off")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.Apply(v43, []any{v28, v36}) + _ = v44 + v45 := lang.Apply(v40, nil) + v5 = v45 + } // end let + return v5 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // sequence + { + v0 := lang.NewSymbol("sequence").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("coll"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Coerces coll to a (possibly empty) sequence, if it is not already\n one. Will not force a lazy seq. (sequence nil) yields (), When a\n transducer is supplied, returns a lazy sequence of applications of\n the transform to the items in coll(s), i.e. to the set of first\n items of each coll, followed by the set of second\n items in each coll, until any one of the colls is exhausted. Any\n remaining items in other colls are ignored. The transform should accept\n number-of-colls arguments", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2639), lang.NewKeyword("end-line"), int(2639))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + var v4 any + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("seq?")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v3}) + if lang.IsTruthy(v8) { + v4 = v3 + } else { + var v9 any + { // let + // let binding "or__0__auto__" + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("seq")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{v3}) + var v14 any = v13 + _ = v14 + var v15 any + if lang.IsTruthy(v14) { + v15 = v14 + } else { + v15 = lang.NewList() + } + v9 = v15 + } // end let + v4 = v9 + } + return v4 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any + { // let + // let binding "or__0__auto__" + v6 := lang.Apply(nil, []any{v4}) + v7 := lang.Apply(nil, []any{v3, v6}) + v8 := lang.Apply(nil, []any{v7}) + var v9 any = v8 + _ = v9 + var v10 any + if lang.IsTruthy(v9) { + v10 = v9 + } else { + v10 = lang.NewList() + } + v5 = v10 + } // end let + return v5 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.NewList(args[2:]...) + var v6 any + { // let + // let binding "or__0__auto__" + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("map")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + var v10 lang.FnFunc + v10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v11 := args[0] + _ = v11 + v12 := lang.Apply(nil, []any{v11}) + return v12 + }) + v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2661), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(2661), lang.NewKeyword("end-column"), int(41)) + v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("cons")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{v4, v5}) + v17 := lang.Apply(v9, []any{v12, v16}) + v18 := lang.Apply(nil, []any{v3, v17}) + v19 := lang.Apply(nil, []any{v18}) + var v20 any = v19 + _ = v20 + var v21 any + if lang.IsTruthy(v20) { + v21 = v20 + } else { + v21 = lang.NewList() + } + v6 = v21 + } // end let + return v6 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // sequential? + { + v0 := lang.NewSymbol("sequential?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements Sequential", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6229), lang.NewKeyword("end-line"), int(6229))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.Apply(v6, []any{lang.Sequential, v3}) + return v7 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // serialized-require + { + v0 := lang.NewSymbol("serialized-require").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Like 'require', but serializes loading.\n Interim function preferred over 'require' for known asynchronous loads.\n Future changes may make these equivalent.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6059), lang.NewKeyword("end-line"), int(6059), lang.NewKeyword("private"), true)).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := lang.NewList(args[0:]...) + var v4 any + { // let + // let binding "lockee__0__auto__" + var v5 any = nil + _ = v5 + var v6 any + func() { + var v7 any + { // let + // let binding "locklocal__1__auto__" + var v8 any = v5 + _ = v8 + v9 := lang.Apply(nil, []any{v8}) + _ = v9 + var v10 any + func() { + defer func() { + v11 := lang.Apply(nil, []any{v8}) + }() + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("apply")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("require")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v14, []any{v17, v3}) + v10 = v18 + }() + v7 = v10 + } // end let + v6 = v7 + }() + v4 = v6 + } // end let + return v4 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // set + { + v0 := lang.NewSymbol("set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a set of the distinct elements of coll.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4104), lang.NewKeyword("end-line"), int(4104))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("set?")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v3}) + if lang.IsTruthy(v8) { + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("with-meta")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.Apply(v11, []any{v3, nil}) + v4 = v12 + } else { + var v13 any + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("instance?")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.IReduceInit, v3}) + if lang.IsTruthy(v17) { + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("persistent!")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("conj!")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("transient")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.CreatePersistentTreeSet() + v28 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4112), lang.NewKeyword("column"), int(108), lang.NewKeyword("end-line"), int(4112), lang.NewKeyword("end-column"), int(110)) + v29, err := lang.WithMeta(v27, v28.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v30 := lang.Apply(v26, []any{v29}) + v31, _ := lang.FieldOrMethod(v3, "ReduceInit") + if reflect.TypeOf(v31).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) + } + v32 := lang.Apply(v31, []any{v23, v30}) + v33 := lang.Apply(v20, []any{v32}) + v13 = v33 + } else { + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("persistent!")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("reduce1")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("conj!")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v44 := v43.FindInternedVar(lang.NewSymbol("transient")) + if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) + } + v45 := v44.Get() + v46 := lang.CreatePersistentTreeSet() + v47 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4113), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(4113), lang.NewKeyword("end-column"), int(48)) + v48, err := lang.WithMeta(v46, v47.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v49 := lang.Apply(v45, []any{v48}) + v50 := lang.Apply(v39, []any{v42, v49, v3}) + v51 := lang.Apply(v36, []any{v50}) + v13 = v51 + } + v4 = v13 + } + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // set-agent-send-executor! + { + v0 := lang.NewSymbol("set-agent-send-executor!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("executor"))), lang.NewKeyword("doc"), "Sets the ExecutorService to be used by send", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(30), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2087), lang.NewKeyword("end-line"), int(2087))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + return nil + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // set-agent-send-off-executor! + { + v0 := lang.NewSymbol("set-agent-send-off-executor!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("executor"))), lang.NewKeyword("doc"), "Sets the ExecutorService to be used by send-off", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(34), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2093), lang.NewKeyword("end-line"), int(2093))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + return nil + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // set-error-handler! + { + v0 := lang.NewSymbol("set-error-handler!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("handler-fn"))), lang.NewKeyword("doc"), "Sets the error-handler of agent a to handler-fn. If an action\n being run by the agent throws an exception or doesn't pass the\n validator fn, handler-fn will be called with two arguments: the\n agent and the exception.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2192), lang.NewKeyword("end-line"), int(2192))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5, _ := lang.FieldOrMethod(v3, "setErrorHandler") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorHandler is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // set-error-mode! + { + v0 := lang.NewSymbol("set-error-mode!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("mode-keyword"))), lang.NewKeyword("doc"), "Sets the error-mode of agent a to mode-keyword, which must be\n either :fail or :continue. If an action being run by the agent\n throws an exception or doesn't pass the validator fn, an\n error-handler may be called (see set-error-handler!), after which,\n if the mode is :continue, the agent will continue as if neither the\n action that caused the error nor the error itself ever happened.\n \n If the mode is :fail, the agent will become failed and will stop\n accepting new 'send' and 'send-off' actions, and any previously\n queued actions will be held until a 'restart-agent'. Deref will\n still work, returning the state of the agent before the error.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2210), lang.NewKeyword("end-line"), int(2210))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5, _ := lang.FieldOrMethod(v3, "setErrorMode") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorMode is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // set-validator! + { + v0 := lang.NewSymbol("set-validator!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("iref"), lang.NewSymbol("validator-fn"))), lang.NewKeyword("doc"), "Sets the validator-fn for a var/ref/agent/atom. validator-fn must be nil or a\n side-effect-free fn of one argument, which will be passed the intended\n new state on any state change. If the new state is unacceptable, the\n validator-fn should return false or throw an exception. If the current state (root\n value if var) is not acceptable to the new validator, an exception\n will be thrown and the validator will not be changed.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2381), lang.NewKeyword("end-line"), int(2381))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5, _ := lang.FieldOrMethod(v3, "setValidator") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setValidator is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // set? + { + v0 := lang.NewSymbol("set?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements IPersistentSet", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4098), lang.NewKeyword("end-line"), int(4098))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.Apply(v6, []any{lang.IPersistentSet, v3}) + return v7 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // setup-reference + { + v0 := lang.NewSymbol("setup-reference").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2043), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(2044), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("r"), lang.NewSymbol("options"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any + { // let + // let binding "opts" + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("apply")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("hash-map")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.Apply(v8, []any{v11, v4}) + var v13 any = v12 + _ = v13 + var v14 any + v15 := lang.Apply(lang.NewKeyword("meta"), []any{v13}) + if lang.IsTruthy(v15) { + v16 := lang.Apply(lang.NewKeyword("meta"), []any{v13}) + v17, _ := lang.FieldOrMethod(v3, "ResetMeta") + if reflect.TypeOf(v17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ResetMeta is not a function"))) + } + v18 := lang.Apply(v17, []any{v16}) + v14 = v18 + } else { + v14 = nil + } + _ = v14 + var v19 any + v20 := lang.Apply(lang.NewKeyword("validator"), []any{v13}) + if lang.IsTruthy(v20) { + v21 := lang.Apply(lang.NewKeyword("validator"), []any{v13}) + v22, _ := lang.FieldOrMethod(v3, "setValidator") + if reflect.TypeOf(v22).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setValidator is not a function"))) + } + v23 := lang.Apply(v22, []any{v21}) + v19 = v23 + } else { + v19 = nil + } + _ = v19 + v5 = v3 + } // end let + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // shift-mask + { + v0 := lang.NewSymbol("shift-mask").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6598), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(6598), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("shift"), lang.NewSymbol("mask"), lang.NewSymbol("x"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("bit-and")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("bit-shift-right")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.Apply(v11, []any{v5, v3}) + v13 := lang.Apply(v8, []any{v12, v4}) + return v13 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // short + { + var v1 lang.FnFunc + { // function short__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("concat")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("list")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("seq")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("concat")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + var v30 any + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + if lang.IsTruthy(v33) { + v30 = lang.NewSymbol("uncheckedShortCast") + } else { + v30 = lang.NewSymbol("shortCast") + } + v34 := lang.Apply(v29, []any{v30}) + v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v36 := v35.FindInternedVar(lang.NewSymbol("list")) + if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + } + v37 := v36.Get() + v38 := lang.Apply(v37, []any{v3}) + v39 := lang.Apply(v26, []any{v34, v38}) + v40 := lang.Apply(v23, []any{v39}) + v41 := lang.Apply(v20, []any{v40}) + v42 := lang.Apply(v9, []any{v13, v17, v41}) + v43 := lang.Apply(v6, []any{v42}) + return v43 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("short").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to short", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3499), lang.NewKeyword("end-line"), int(3499))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := lang.Apply(lang.ShortCast, []any{v4}) + return v5 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // short-array + { + var v1 lang.FnFunc + { // function short-array__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := lang.NewList(args[0:]...) + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("concat")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("list")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/ShortArray")}) + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("list")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("seq")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("concat")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) + v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v36 := v35.FindInternedVar(lang.NewSymbol("list")) + if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + } + v37 := v36.Get() + v38 := lang.Apply(v37, []any{lang.NewSymbol("glojure.core/args")}) + v39 := lang.Apply(v30, []any{v34, v38}) + v40 := lang.Apply(v27, []any{v39}) + v41 := lang.Apply(v24, []any{v40}) + v42 := lang.Apply(v9, []any{v13, v17, v21, v41}) + v43 := lang.Apply(v6, []any{v42}) + return v43 + } + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("short-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Creates an array of shorts", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1), int64(2)), lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5333), lang.NewKeyword("end-line"), int(5333))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + v5, _ := lang.FieldOrMethod(lang.Numbers, "ShortArray") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ShortArray is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6, _ := lang.FieldOrMethod(lang.Numbers, "ShortArrayInit") + if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ShortArrayInit is not a function"))) + } + v7 := lang.Apply(v6, []any{v4, v5}) + return v7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // shorts + { + var v1 lang.FnFunc + { // function shorts + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("concat")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("list")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/Shorts")}) + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("list")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v3}) + v26 := lang.Apply(v9, []any{v13, v17, v21, v25}) + v27 := lang.Apply(v6, []any{v26}) + return v27 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("shorts").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Casts to shorts[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5387), lang.NewKeyword("end-line"), int(5387))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5, _ := lang.FieldOrMethod(lang.Numbers, "Shorts") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Shorts is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // shuffle + { + v0 := lang.NewSymbol("shuffle").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return a random permutation of coll", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7300), lang.NewKeyword("end-line"), int(7300))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + { // let + // let binding "al" + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("to-array")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v3}) + v9 := lang.Apply(lang.NewArrayList, []any{v8}) + var v10 any = v9 + _ = v10 + v11 := lang.Apply(nil, []any{v10}) + _ = v11 + v12, ok := lang.FieldOrMethod(v10, "toArray") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v10, "toArray"))) + } + var v13 any + switch reflect.TypeOf(v12).Kind() { + case reflect.Func: + v13 = lang.Apply(v12, nil) + default: + v13 = v12 + } + v14 := lang.Apply(nil, []any{v13}) + v4 = v14 + } // end let + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // shutdown-agents + { + v0 := lang.NewSymbol("shutdown-agents").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Initiates a shutdown of the thread pools that back the agent\n system. Running actions will complete, but no new actions will be\n accepted", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2252), lang.NewKeyword("end-line"), int(2252))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := lang.Apply(lang.ShutdownAgents, nil) + return v3 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // sigs + { + v0 := lang.NewSymbol("sigs").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(223), lang.NewKeyword("column"), int(2), lang.NewKeyword("end-line"), int(224), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("assert-valid-fdecl")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.Apply(v6, []any{v3}) + _ = v7 + var v8 any + { // let + // let binding "asig" + var v9 lang.FnFunc + v9 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v10 := args[0] + _ = v10 + var v11 any + { // let + // let binding "arglist" + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("first")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.Apply(v14, []any{v10}) + var v16 any = v15 + _ = v16 + // let binding "arglist" + var v17 any + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("first")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.Apply(v20, []any{v16}) + v22 := lang.Apply(lang.Equals, []any{lang.NewSymbol("&form"), v21}) + if lang.IsTruthy(v22) { + v23 := lang.Apply(lang.Count, []any{v16}) + v24 := lang.Apply(lang.Subvec, []any{v16, int64(2), v23}) + v17 = v24 + } else { + v17 = v16 + } + var v25 any = v17 + _ = v25 + // let binding "body" + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("next")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.Apply(v28, []any{v10}) + var v30 any = v29 + _ = v30 + var v31 any + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("map?")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v36 := v35.FindInternedVar(lang.NewSymbol("first")) + if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + } + v37 := v36.Get() + v38 := lang.Apply(v37, []any{v30}) + v39 := lang.Apply(v34, []any{v38}) + if lang.IsTruthy(v39) { + var v40 any + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("next")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.Apply(v43, []any{v30}) + if lang.IsTruthy(v44) { + v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v46 := v45.FindInternedVar(lang.NewSymbol("with-meta")) + if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) + } + v47 := v46.Get() + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("conj")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + var v51 any + v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v53 := v52.FindInternedVar(lang.NewSymbol("meta")) + if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) + } + v54 := v53.Get() + v55 := lang.Apply(v54, []any{v25}) + if lang.IsTruthy(v55) { + v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v57 := v56.FindInternedVar(lang.NewSymbol("meta")) + if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) + } + v58 := v57.Get() + v59 := lang.Apply(v58, []any{v25}) + v51 = v59 + } else { + v60 := lang.NewMap() + v61 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(237), lang.NewKeyword("column"), int(77), lang.NewKeyword("end-line"), int(237), lang.NewKeyword("end-column"), int(78)) + v62, err := lang.WithMeta(v60, v61.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v51 = v62 + } + v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v64 := v63.FindInternedVar(lang.NewSymbol("first")) + if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) + } + v65 := v64.Get() + v66 := lang.Apply(v65, []any{v30}) + v67 := lang.Apply(v50, []any{v51, v66}) + v68 := lang.Apply(v47, []any{v25, v67}) + v40 = v68 + } else { + v40 = v25 + } + v31 = v40 + } else { + v31 = v25 + } + v11 = v31 + } // end let + return v11 + }) + v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(228), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(239), lang.NewKeyword("end-column"), int(25)) + v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v12 any = v11 + _ = v12 + // let binding "resolve-tag" + var v13 lang.FnFunc + v13 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v14 := args[0] + _ = v14 + var v15 any + { // let + // let binding "m" + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("meta")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{v14}) + var v20 any = v19 + _ = v20 + // let binding "tag" + v21 := lang.Apply(lang.NewKeyword("tag"), []any{v20}) + var v22 any = v21 + _ = v22 + var v23 any + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("instance?")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.Apply(v26, []any{*lang.Symbol, v22}) + if lang.IsTruthy(v27) { + var v28 any + v29, ok := lang.FieldOrMethod(v22, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v22, "Name"))) + } + var v30 any + switch reflect.TypeOf(v29).Kind() { + case reflect.Func: + v30 = lang.Apply(v29, nil) + default: + v30 = v29 + } + v31 := lang.Apply(strings8.Index, []any{v30, "."}) + v32 := lang.Apply(lang.Equiv, []any{v31, int64(-1)}) + if lang.IsTruthy(v32) { + var v33 any + v34 := lang.Apply(lang.Equals, []any{nil, nil}) + if lang.IsTruthy(v34) { + var v35 any + { // let + // let binding "c" + var v36 any = nil + _ = v36 + var v37 any + if lang.IsTruthy(v36) { + v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v39 := v38.FindInternedVar(lang.NewSymbol("with-meta")) + if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + } + v40 := v39.Get() + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("assoc")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44, ok := lang.FieldOrMethod(v36, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v36, "Name"))) + } + var v45 any + switch reflect.TypeOf(v44).Kind() { + case reflect.Func: + v45 = lang.Apply(v44, nil) + default: + v45 = v44 + } + v46 := lang.Apply(lang.NewSymbol, []any{v45}) + v47 := lang.Apply(v43, []any{v20, lang.NewKeyword("tag"), v46}) + v48 := lang.Apply(v40, []any{v14, v47}) + v37 = v48 + } else { + v37 = v14 + } + v35 = v37 + } // end let + v33 = v35 + } else { + v33 = v14 + } + v28 = v33 + } else { + v28 = v14 + } + v23 = v28 + } else { + v23 = v14 + } + v15 = v23 + } // end let + return v15 + }) + v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(240), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(252), lang.NewKeyword("end-column"), int(37)) + v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v16 any = v15 + _ = v16 + var v17 any + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("seq?")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("first")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.Apply(v23, []any{v3}) + v25 := lang.Apply(v20, []any{v24}) + if lang.IsTruthy(v25) { + var v26 any + { // let + // let binding "ret" + v27 := lang.NewVector() + v28 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(254), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(254), lang.NewKeyword("end-column"), int(20)) + v29, err := lang.WithMeta(v27, v28.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v30 any = v29 + _ = v30 + // let binding "fdecls" + var v31 any = v3 + _ = v31 + for { + var v32 any + if lang.IsTruthy(v31) { + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("conj")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("first")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.Apply(v39, []any{v31}) + v41 := lang.Apply(v12, []any{v40}) + v42 := lang.Apply(v16, []any{v41}) + v43 := lang.Apply(v36, []any{v30, v42}) + var v33 any = v43 + v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v46 := v45.FindInternedVar(lang.NewSymbol("next")) + if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) + } + v47 := v46.Get() + v48 := lang.Apply(v47, []any{v31}) + var v44 any = v48 + v30 = v33 + v31 = v44 + continue + } else { + v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v50 := v49.FindInternedVar(lang.NewSymbol("seq")) + if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) + } + v51 := v50.Get() + v52 := lang.Apply(v51, []any{v30}) + v32 = v52 + } + v26 = v32 + break + } + } // end let + v17 = v26 + } else { + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v12, []any{v3}) + v31 := lang.Apply(v16, []any{v30}) + v32 := lang.Apply(v29, []any{v31}) + v17 = v32 + } + v8 = v17 + } // end let + return v8 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(225), lang.NewKeyword("column"), int(2), lang.NewKeyword("end-line"), int(258), lang.NewKeyword("end-column"), int(43))).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // simple-ident? + { + v0 := lang.NewSymbol("simple-ident?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a symbol or keyword without a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1613), lang.NewKeyword("end-line"), int(1613))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + { // let + // let binding "and__0__auto__" + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("ident?")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v3}) + var v9 any = v8 + _ = v9 + var v10 any + if lang.IsTruthy(v9) { + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("nil?")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("namespace")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{v3}) + v18 := lang.Apply(v13, []any{v17}) + v10 = v18 + } else { + v10 = v9 + } + v4 = v10 + } // end let + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // simple-keyword? + { + v0 := lang.NewSymbol("simple-keyword?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a keyword without a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1633), lang.NewKeyword("end-line"), int(1633))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + { // let + // let binding "and__0__auto__" + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("keyword?")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v3}) + var v9 any = v8 + _ = v9 + var v10 any + if lang.IsTruthy(v9) { + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("nil?")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("namespace")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{v3}) + v18 := lang.Apply(v13, []any{v17}) + v10 = v18 + } else { + v10 = v9 + } + v4 = v10 + } // end let + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // simple-symbol? + { + v0 := lang.NewSymbol("simple-symbol?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a symbol without a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1623), lang.NewKeyword("end-line"), int(1623))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + { // let + // let binding "and__0__auto__" + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("symbol?")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v3}) + var v9 any = v8 + _ = v9 + var v10 any + if lang.IsTruthy(v9) { + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("nil?")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("namespace")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{v3}) + v18 := lang.Apply(v13, []any{v17}) + v10 = v18 + } else { + v10 = v9 + } + v4 = v10 + } // end let + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // slurp + { + v1 := reflect.TypeOf("") + v0 := lang.NewSymbol("slurp").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("opts"))), lang.NewKeyword("doc"), "Opens a reader on f and reads all its contents, returning a string.\n See glojure.java.io/reader for a complete list of supported arguments.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6982), lang.NewKeyword("end-line"), int(6982))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := lang.NewList(args[1:]...) + var v6 any + { // let + // let binding "opts" + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("normalize-slurp-opts")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, []any{v5}) + var v11 any = v10 + _ = v11 + // let binding "sw" + var v12 any = "unimplemented: new with non-constant class type" + _ = v12 + var v13 any + { // let + // let binding "r" + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("apply")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.FindNamespace(lang.NewSymbol("glojure.go.io")) + v18 := v17.FindInternedVar(lang.NewSymbol("reader")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.Apply(v16, []any{v19, v4, v11}) + var v21 any = v20 + _ = v21 + var v22 any + func() { + defer func() { + v23, ok := lang.FieldOrMethod(v21, "close") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v21, "close"))) + } + var v24 any + switch reflect.TypeOf(v23).Kind() { + case reflect.Func: + v24 = lang.Apply(v23, nil) + default: + v24 = v23 + } + }() + v25 := lang.FindNamespace(lang.NewSymbol("glojure.go.io")) + v26 := v25.FindInternedVar(lang.NewSymbol("copy")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.Apply(v27, []any{v21, v12}) + _ = v28 + v29 := lang.Apply(lang.ToString, []any{v12}) + v22 = v29 + }() + v13 = v22 + } // end let + v6 = v13 + } // end let + return v6 + } + }) + v4 := reflect.TypeOf("") + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // some + { + v0 := lang.NewSymbol("some").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns the first logical true value of (pred x) for any x in coll,\n else nil. One common idiom is to use a set as pred, for example\n this will return :fred if :fred is in the sequence, otherwise nil:\n (some #{:fred} coll)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2684), lang.NewKeyword("end-line"), int(2684))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + recur_loop_481: + var v5 any + { // let + // let binding "temp__0__auto__" + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("seq")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{v4}) + var v10 any = v9 + _ = v10 + var v11 any + if lang.IsTruthy(v10) { + var v12 any + { // let + // let binding "s" + var v13 any = v10 + _ = v13 + var v14 any + { // let + // let binding "or__0__auto__" + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("first")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{v13}) + v19 := lang.Apply(v3, []any{v18}) + var v20 any = v19 + _ = v20 + var v21 any + if lang.IsTruthy(v20) { + v21 = v20 + } else { + var v22 any = v3 + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("next")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.Apply(v26, []any{v13}) + var v23 any = v27 + v3 = v22 + v4 = v23 + goto recur_loop_481 + } + v14 = v21 + } // end let + v12 = v14 + } // end let + v11 = v12 + } else { + v11 = nil + } + v5 = v11 + } // end let + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // some-> + { + v0 := lang.NewSymbol("some->").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "When expr is not nil, threads it into the first form (via ->),\n and when that result is not nil, through the next etc", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7610), lang.NewKeyword("end-line"), int(7610))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + var v7 any + { // let + // let binding "g" + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("gensym")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, nil) + var v12 any = v11 + _ = v12 + // let binding "steps" + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("map")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + var v16 lang.FnFunc + v16 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v17 := args[0] + _ = v17 + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("seq")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("concat")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("list")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.Apply(v26, []any{lang.NewSymbol("if")}) + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("list")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("seq")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("concat")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("list")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.Apply(v39, []any{lang.NewSymbol("glojure.core/nil?")}) + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("list")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.Apply(v43, []any{v12}) + v45 := lang.Apply(v36, []any{v40, v44}) + v46 := lang.Apply(v33, []any{v45}) + v47 := lang.Apply(v30, []any{v46}) + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("list")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{nil}) + v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v53 := v52.FindInternedVar(lang.NewSymbol("list")) + if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) + } + v54 := v53.Get() + v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v56 := v55.FindInternedVar(lang.NewSymbol("seq")) + if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) + } + v57 := v56.Get() + v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v59 := v58.FindInternedVar(lang.NewSymbol("concat")) + if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) + } + v60 := v59.Get() + v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v62 := v61.FindInternedVar(lang.NewSymbol("list")) + if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) + } + v63 := v62.Get() + v64 := lang.Apply(v63, []any{lang.NewSymbol("glojure.core/->")}) + v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v66 := v65.FindInternedVar(lang.NewSymbol("list")) + if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) + } + v67 := v66.Get() + v68 := lang.Apply(v67, []any{v12}) + v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v70 := v69.FindInternedVar(lang.NewSymbol("list")) + if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) + } + v71 := v70.Get() + v72 := lang.Apply(v71, []any{v17}) + v73 := lang.Apply(v60, []any{v64, v68, v72}) + v74 := lang.Apply(v57, []any{v73}) + v75 := lang.Apply(v54, []any{v74}) + v76 := lang.Apply(v23, []any{v27, v47, v51, v75}) + v77 := lang.Apply(v20, []any{v76}) + return v77 + }) + v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7616), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7616), lang.NewKeyword("end-column"), int(64)) + v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v19 := lang.Apply(v15, []any{v18, v6}) + var v20 any = v19 + _ = v20 + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("seq")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("concat")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/let")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("apply")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("vector")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("seq")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v44 := v43.FindInternedVar(lang.NewSymbol("concat")) + if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) + } + v45 := v44.Get() + v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v47 := v46.FindInternedVar(lang.NewSymbol("list")) + if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) + } + v48 := v47.Get() + v49 := lang.Apply(v48, []any{v12}) + v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v51 := v50.FindInternedVar(lang.NewSymbol("list")) + if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) + } + v52 := v51.Get() + v53 := lang.Apply(v52, []any{v5}) + v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v55 := v54.FindInternedVar(lang.NewSymbol("interleave")) + if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) + } + v56 := v55.Get() + v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v58 := v57.FindInternedVar(lang.NewSymbol("repeat")) + if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) + } + v59 := v58.Get() + v60 := lang.Apply(v59, []any{v12}) + v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v62 := v61.FindInternedVar(lang.NewSymbol("butlast")) + if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) + } + v63 := v62.Get() + v64 := lang.Apply(v63, []any{v20}) + v65 := lang.Apply(v56, []any{v60, v64}) + v66 := lang.Apply(v45, []any{v49, v53, v65}) + v67 := lang.Apply(v42, []any{v66}) + v68 := lang.Apply(v36, []any{v39, v67}) + v69 := lang.Apply(v33, []any{v68}) + v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v71 := v70.FindInternedVar(lang.NewSymbol("list")) + if v71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) + } + v72 := v71.Get() + var v73 any + v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v75 := v74.FindInternedVar(lang.NewSymbol("empty?")) + if v75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) + } + v76 := v75.Get() + v77 := lang.Apply(v76, []any{v20}) + if lang.IsTruthy(v77) { + v73 = v12 + } else { + v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v79 := v78.FindInternedVar(lang.NewSymbol("last")) + if v79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) + } + v80 := v79.Get() + v81 := lang.Apply(v80, []any{v20}) + v73 = v81 + } + v82 := lang.Apply(v72, []any{v73}) + v83 := lang.Apply(v26, []any{v30, v69, v82}) + v84 := lang.Apply(v23, []any{v83}) + v7 = v84 + } // end let + return v7 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // some->> + { + v0 := lang.NewSymbol("some->>").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "When expr is not nil, threads it into the first form (via ->>),\n and when that result is not nil, through the next etc", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7624), lang.NewKeyword("end-line"), int(7624))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + var v7 any + { // let + // let binding "g" + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("gensym")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, nil) + var v12 any = v11 + _ = v12 + // let binding "steps" + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("map")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + var v16 lang.FnFunc + v16 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v17 := args[0] + _ = v17 + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("seq")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("concat")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("list")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.Apply(v26, []any{lang.NewSymbol("if")}) + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("list")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("seq")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("concat")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("list")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.Apply(v39, []any{lang.NewSymbol("glojure.core/nil?")}) + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("list")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.Apply(v43, []any{v12}) + v45 := lang.Apply(v36, []any{v40, v44}) + v46 := lang.Apply(v33, []any{v45}) + v47 := lang.Apply(v30, []any{v46}) + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("list")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{nil}) + v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v53 := v52.FindInternedVar(lang.NewSymbol("list")) + if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) + } + v54 := v53.Get() + v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v56 := v55.FindInternedVar(lang.NewSymbol("seq")) + if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) + } + v57 := v56.Get() + v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v59 := v58.FindInternedVar(lang.NewSymbol("concat")) + if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) + } + v60 := v59.Get() + v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v62 := v61.FindInternedVar(lang.NewSymbol("list")) + if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) + } + v63 := v62.Get() + v64 := lang.Apply(v63, []any{lang.NewSymbol("glojure.core/->>")}) + v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v66 := v65.FindInternedVar(lang.NewSymbol("list")) + if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) + } + v67 := v66.Get() + v68 := lang.Apply(v67, []any{v12}) + v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v70 := v69.FindInternedVar(lang.NewSymbol("list")) + if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) + } + v71 := v70.Get() + v72 := lang.Apply(v71, []any{v17}) + v73 := lang.Apply(v60, []any{v64, v68, v72}) + v74 := lang.Apply(v57, []any{v73}) + v75 := lang.Apply(v54, []any{v74}) + v76 := lang.Apply(v23, []any{v27, v47, v51, v75}) + v77 := lang.Apply(v20, []any{v76}) + return v77 + }) + v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7630), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7630), lang.NewKeyword("end-column"), int(65)) + v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v19 := lang.Apply(v15, []any{v18, v6}) + var v20 any = v19 + _ = v20 + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("seq")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("concat")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/let")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("apply")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("vector")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("seq")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v44 := v43.FindInternedVar(lang.NewSymbol("concat")) + if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) + } + v45 := v44.Get() + v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v47 := v46.FindInternedVar(lang.NewSymbol("list")) + if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) + } + v48 := v47.Get() + v49 := lang.Apply(v48, []any{v12}) + v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v51 := v50.FindInternedVar(lang.NewSymbol("list")) + if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) + } + v52 := v51.Get() + v53 := lang.Apply(v52, []any{v5}) + v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v55 := v54.FindInternedVar(lang.NewSymbol("interleave")) + if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) + } + v56 := v55.Get() + v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v58 := v57.FindInternedVar(lang.NewSymbol("repeat")) + if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) + } + v59 := v58.Get() + v60 := lang.Apply(v59, []any{v12}) + v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v62 := v61.FindInternedVar(lang.NewSymbol("butlast")) + if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) + } + v63 := v62.Get() + v64 := lang.Apply(v63, []any{v20}) + v65 := lang.Apply(v56, []any{v60, v64}) + v66 := lang.Apply(v45, []any{v49, v53, v65}) + v67 := lang.Apply(v42, []any{v66}) + v68 := lang.Apply(v36, []any{v39, v67}) + v69 := lang.Apply(v33, []any{v68}) + v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v71 := v70.FindInternedVar(lang.NewSymbol("list")) + if v71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) + } + v72 := v71.Get() + var v73 any + v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v75 := v74.FindInternedVar(lang.NewSymbol("empty?")) + if v75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) + } + v76 := v75.Get() + v77 := lang.Apply(v76, []any{v20}) + if lang.IsTruthy(v77) { + v73 = v12 + } else { + v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v79 := v78.FindInternedVar(lang.NewSymbol("last")) + if v79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) + } + v80 := v79.Get() + v81 := lang.Apply(v80, []any{v20}) + v73 = v81 + } + v82 := lang.Apply(v72, []any{v73}) + v83 := lang.Apply(v26, []any{v30, v69, v82}) + v84 := lang.Apply(v23, []any{v83}) + v7 = v84 + } // end let + return v7 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // some-fn + { + v0 := lang.NewSymbol("some-fn").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("p")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2"), lang.NewSymbol("p3")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2"), lang.NewSymbol("p3"), lang.NewSymbol("&"), lang.NewSymbol("ps"))), lang.NewKeyword("doc"), "Takes a set of predicates and returns a function f that returns the first logical true value\n returned by one of its composing predicates against any of its arguments, else it returns\n logical false. Note that f is short-circuiting in that it will stop execution on the first\n argument that triggers a logical true result against the original predicates.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7462), lang.NewKeyword("end-line"), int(7462))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + var v4 lang.FnFunc + { // function sp1 + v4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return nil + case 1: + v6 := args[0] + _ = v6 + v7 := lang.Apply(v3, []any{v6}) + return v7 + case 2: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + var v8 any + { // let + // let binding "or__0__auto__" + v9 := lang.Apply(v3, []any{v6}) + var v10 any = v9 + _ = v10 + var v11 any + if lang.IsTruthy(v10) { + v11 = v10 + } else { + v12 := lang.Apply(v3, []any{v7}) + v11 = v12 + } + v8 = v11 + } // end let + return v8 + case 3: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + var v9 any + { // let + // let binding "or__0__auto__" + v10 := lang.Apply(v3, []any{v6}) + var v11 any = v10 + _ = v11 + var v12 any + if lang.IsTruthy(v11) { + v12 = v11 + } else { + var v13 any + { // let + // let binding "or__0__auto__" + v14 := lang.Apply(v3, []any{v7}) + var v15 any = v14 + _ = v15 + var v16 any + if lang.IsTruthy(v15) { + v16 = v15 + } else { + v17 := lang.Apply(v3, []any{v8}) + v16 = v17 + } + v13 = v16 + } // end let + v12 = v13 + } + v9 = v12 + } // end let + return v9 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + v9 := lang.NewList(args[3:]...) + var v10 any + { // let + // let binding "or__0__auto__" + v11 := lang.Apply(v5, []any{v6, v7, v8}) + var v12 any = v11 + _ = v12 + var v13 any + if lang.IsTruthy(v12) { + v13 = v12 + } else { + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("some")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{v3, v9}) + v13 = v17 + } + v10 = v13 + } // end let + return v10 + } + }) + v5 := v4 + _ = v5 + } + v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7469), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7475), lang.NewKeyword("end-column"), int(43)) + v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v6 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 lang.FnFunc + { // function sp2 + v5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return nil + case 1: + v7 := args[0] + _ = v7 + var v8 any + { // let + // let binding "or__0__auto__" + v9 := lang.Apply(v3, []any{v7}) + var v10 any = v9 + _ = v10 + var v11 any + if lang.IsTruthy(v10) { + v11 = v10 + } else { + v12 := lang.Apply(v4, []any{v7}) + v11 = v12 + } + v8 = v11 + } // end let + return v8 + case 2: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + var v9 any + { // let + // let binding "or__0__auto__" + v10 := lang.Apply(v3, []any{v7}) + var v11 any = v10 + _ = v11 + var v12 any + if lang.IsTruthy(v11) { + v12 = v11 + } else { + var v13 any + { // let + // let binding "or__0__auto__" + v14 := lang.Apply(v3, []any{v8}) + var v15 any = v14 + _ = v15 + var v16 any + if lang.IsTruthy(v15) { + v16 = v15 + } else { + var v17 any + { // let + // let binding "or__0__auto__" + v18 := lang.Apply(v4, []any{v7}) + var v19 any = v18 + _ = v19 + var v20 any + if lang.IsTruthy(v19) { + v20 = v19 + } else { + v21 := lang.Apply(v4, []any{v8}) + v20 = v21 + } + v17 = v20 + } // end let + v16 = v17 + } + v13 = v16 + } // end let + v12 = v13 + } + v9 = v12 + } // end let + return v9 + case 3: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + var v10 any + { // let + // let binding "or__0__auto__" + v11 := lang.Apply(v3, []any{v7}) + var v12 any = v11 + _ = v12 + var v13 any + if lang.IsTruthy(v12) { + v13 = v12 + } else { + var v14 any + { // let + // let binding "or__0__auto__" + v15 := lang.Apply(v3, []any{v8}) + var v16 any = v15 + _ = v16 + var v17 any + if lang.IsTruthy(v16) { + v17 = v16 + } else { + var v18 any + { // let + // let binding "or__0__auto__" + v19 := lang.Apply(v3, []any{v9}) + var v20 any = v19 + _ = v20 + var v21 any + if lang.IsTruthy(v20) { + v21 = v20 + } else { + var v22 any + { // let + // let binding "or__0__auto__" + v23 := lang.Apply(v4, []any{v7}) + var v24 any = v23 + _ = v24 + var v25 any + if lang.IsTruthy(v24) { + v25 = v24 + } else { + var v26 any + { // let + // let binding "or__0__auto__" + v27 := lang.Apply(v4, []any{v8}) + var v28 any = v27 + _ = v28 + var v29 any + if lang.IsTruthy(v28) { + v29 = v28 + } else { + v30 := lang.Apply(v4, []any{v9}) + v29 = v30 + } + v26 = v29 + } // end let + v25 = v26 + } + v22 = v25 + } // end let + v21 = v22 + } + v18 = v21 + } // end let + v17 = v18 + } + v14 = v17 + } // end let + v13 = v14 + } + v10 = v13 + } // end let + return v10 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + v10 := lang.NewList(args[3:]...) + var v11 any + { // let + // let binding "or__0__auto__" + v12 := lang.Apply(v6, []any{v7, v8, v9}) + var v13 any = v12 + _ = v13 + var v14 any + if lang.IsTruthy(v13) { + v14 = v13 + } else { + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("some")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + var v18 lang.FnFunc + v18 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v19 := args[0] + _ = v19 + var v20 any + { // let + // let binding "or__0__auto__" + v21 := lang.Apply(v3, []any{v19}) + var v22 any = v21 + _ = v22 + var v23 any + if lang.IsTruthy(v22) { + v23 = v22 + } else { + v24 := lang.Apply(v4, []any{v19}) + v23 = v24 + } + v20 = v23 + } // end let + return v20 + }) + v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7483), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(7483), lang.NewKeyword("end-column"), int(52)) + v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v21 := lang.Apply(v17, []any{v20, v10}) + v14 = v21 + } + v11 = v14 + } // end let + return v11 + } + }) + v6 := v5 + _ = v6 + } + v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7477), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7483), lang.NewKeyword("end-column"), int(61)) + v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v7 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 lang.FnFunc + { // function sp3 + v6 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return nil + case 1: + v8 := args[0] + _ = v8 + var v9 any + { // let + // let binding "or__0__auto__" + v10 := lang.Apply(v3, []any{v8}) + var v11 any = v10 + _ = v11 + var v12 any + if lang.IsTruthy(v11) { + v12 = v11 + } else { + var v13 any + { // let + // let binding "or__0__auto__" + v14 := lang.Apply(v4, []any{v8}) + var v15 any = v14 + _ = v15 + var v16 any + if lang.IsTruthy(v15) { + v16 = v15 + } else { + v17 := lang.Apply(v5, []any{v8}) + v16 = v17 + } + v13 = v16 + } // end let + v12 = v13 + } + v9 = v12 + } // end let + return v9 + case 2: + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + var v10 any + { // let + // let binding "or__0__auto__" + v11 := lang.Apply(v3, []any{v8}) + var v12 any = v11 + _ = v12 + var v13 any + if lang.IsTruthy(v12) { + v13 = v12 + } else { + var v14 any + { // let + // let binding "or__0__auto__" + v15 := lang.Apply(v3, []any{v9}) + var v16 any = v15 + _ = v16 + var v17 any + if lang.IsTruthy(v16) { + v17 = v16 + } else { + var v18 any + { // let + // let binding "or__0__auto__" + v19 := lang.Apply(v4, []any{v8}) + var v20 any = v19 + _ = v20 + var v21 any + if lang.IsTruthy(v20) { + v21 = v20 + } else { + var v22 any + { // let + // let binding "or__0__auto__" + v23 := lang.Apply(v4, []any{v9}) + var v24 any = v23 + _ = v24 + var v25 any + if lang.IsTruthy(v24) { + v25 = v24 + } else { + var v26 any + { // let + // let binding "or__0__auto__" + v27 := lang.Apply(v5, []any{v8}) + var v28 any = v27 + _ = v28 + var v29 any + if lang.IsTruthy(v28) { + v29 = v28 + } else { + v30 := lang.Apply(v5, []any{v9}) + v29 = v30 + } + v26 = v29 + } // end let + v25 = v26 + } + v22 = v25 + } // end let + v21 = v22 + } + v18 = v21 + } // end let + v17 = v18 + } + v14 = v17 + } // end let + v13 = v14 + } + v10 = v13 + } // end let + return v10 + case 3: + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + v10 := args[2] + _ = v10 + var v11 any + { // let + // let binding "or__0__auto__" + v12 := lang.Apply(v3, []any{v8}) + var v13 any = v12 + _ = v13 + var v14 any + if lang.IsTruthy(v13) { + v14 = v13 + } else { + var v15 any + { // let + // let binding "or__0__auto__" + v16 := lang.Apply(v3, []any{v9}) + var v17 any = v16 + _ = v17 + var v18 any + if lang.IsTruthy(v17) { + v18 = v17 + } else { + var v19 any + { // let + // let binding "or__0__auto__" + v20 := lang.Apply(v3, []any{v10}) + var v21 any = v20 + _ = v21 + var v22 any + if lang.IsTruthy(v21) { + v22 = v21 + } else { + var v23 any + { // let + // let binding "or__0__auto__" + v24 := lang.Apply(v4, []any{v8}) + var v25 any = v24 + _ = v25 + var v26 any + if lang.IsTruthy(v25) { + v26 = v25 + } else { + var v27 any + { // let + // let binding "or__0__auto__" + v28 := lang.Apply(v4, []any{v9}) + var v29 any = v28 + _ = v29 + var v30 any + if lang.IsTruthy(v29) { + v30 = v29 + } else { + var v31 any + { // let + // let binding "or__0__auto__" + v32 := lang.Apply(v4, []any{v10}) + var v33 any = v32 + _ = v33 + var v34 any + if lang.IsTruthy(v33) { + v34 = v33 + } else { + var v35 any + { // let + // let binding "or__0__auto__" + v36 := lang.Apply(v5, []any{v8}) + var v37 any = v36 + _ = v37 + var v38 any + if lang.IsTruthy(v37) { + v38 = v37 + } else { + var v39 any + { // let + // let binding "or__0__auto__" + v40 := lang.Apply(v5, []any{v9}) + var v41 any = v40 + _ = v41 + var v42 any + if lang.IsTruthy(v41) { + v42 = v41 + } else { + v43 := lang.Apply(v5, []any{v10}) + v42 = v43 + } + v39 = v42 + } // end let + v38 = v39 + } + v35 = v38 + } // end let + v34 = v35 + } + v31 = v34 + } // end let + v30 = v31 + } + v27 = v30 + } // end let + v26 = v27 + } + v23 = v26 + } // end let + v22 = v23 + } + v19 = v22 + } // end let + v18 = v19 + } + v15 = v18 + } // end let + v14 = v15 + } + v11 = v14 + } // end let + return v11 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + v10 := args[2] + _ = v10 + v11 := lang.NewList(args[3:]...) + var v12 any + { // let + // let binding "or__0__auto__" + v13 := lang.Apply(v7, []any{v8, v9, v10}) + var v14 any = v13 + _ = v14 + var v15 any + if lang.IsTruthy(v14) { + v15 = v14 + } else { + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("some")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + var v19 lang.FnFunc + v19 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v20 := args[0] + _ = v20 + var v21 any + { // let + // let binding "or__0__auto__" + v22 := lang.Apply(v3, []any{v20}) + var v23 any = v22 + _ = v23 + var v24 any + if lang.IsTruthy(v23) { + v24 = v23 + } else { + var v25 any + { // let + // let binding "or__0__auto__" + v26 := lang.Apply(v4, []any{v20}) + var v27 any = v26 + _ = v27 + var v28 any + if lang.IsTruthy(v27) { + v28 = v27 + } else { + v29 := lang.Apply(v5, []any{v20}) + v28 = v29 + } + v25 = v28 + } // end let + v24 = v25 + } + v21 = v24 + } // end let + return v21 + }) + v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7491), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(7491), lang.NewKeyword("end-column"), int(59)) + v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v22 := lang.Apply(v18, []any{v21, v11}) + v15 = v22 + } + v12 = v15 + } // end let + return v12 + } + }) + v7 := v6 + _ = v7 + } + v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7485), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7491), lang.NewKeyword("end-column"), int(68)) + v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v8 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + var v7 any + { // let + // let binding "ps" + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("list*")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v3, v4, v5, v6}) + var v12 any = v11 + _ = v12 + var v13 lang.FnFunc + { // function spn + v13 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return nil + case 1: + v15 := args[0] + _ = v15 + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("some")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + var v19 lang.FnFunc + v19 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v20 := args[0] + _ = v20 + v21 := lang.Apply(v20, []any{v15}) + return v21 + }) + v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7496), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(7496), lang.NewKeyword("end-column"), int(26)) + v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v22 := lang.Apply(v18, []any{v21, v12}) + return v22 + case 2: + v15 := args[0] + _ = v15 + v16 := args[1] + _ = v16 + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("some")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + var v20 lang.FnFunc + v20 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v21 := args[0] + _ = v21 + var v22 any + { // let + // let binding "or__0__auto__" + v23 := lang.Apply(v21, []any{v15}) + var v24 any = v23 + _ = v24 + var v25 any + if lang.IsTruthy(v24) { + v25 = v24 + } else { + v26 := lang.Apply(v21, []any{v16}) + v25 = v26 + } + v22 = v25 + } // end let + return v22 + }) + v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7497), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(7497), lang.NewKeyword("end-column"), int(39)) + v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v23 := lang.Apply(v19, []any{v22, v12}) + return v23 + case 3: + v15 := args[0] + _ = v15 + v16 := args[1] + _ = v16 + v17 := args[2] + _ = v17 + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("some")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + var v21 lang.FnFunc + v21 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v22 := args[0] + _ = v22 + var v23 any + { // let + // let binding "or__0__auto__" + v24 := lang.Apply(v22, []any{v15}) + var v25 any = v24 + _ = v25 + var v26 any + if lang.IsTruthy(v25) { + v26 = v25 + } else { + var v27 any + { // let + // let binding "or__0__auto__" + v28 := lang.Apply(v22, []any{v16}) + var v29 any = v28 + _ = v29 + var v30 any + if lang.IsTruthy(v29) { + v30 = v29 + } else { + v31 := lang.Apply(v22, []any{v17}) + v30 = v31 + } + v27 = v30 + } // end let + v26 = v27 + } + v23 = v26 + } // end let + return v23 + }) + v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7498), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7498), lang.NewKeyword("end-column"), int(47)) + v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v24 := lang.Apply(v20, []any{v23, v12}) + return v24 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v15 := args[0] + _ = v15 + v16 := args[1] + _ = v16 + v17 := args[2] + _ = v17 + v18 := lang.NewList(args[3:]...) + var v19 any + { // let + // let binding "or__0__auto__" + v20 := lang.Apply(v14, []any{v15, v16, v17}) + var v21 any = v20 + _ = v21 + var v22 any + if lang.IsTruthy(v21) { + v22 = v21 + } else { + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("some")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + var v26 lang.FnFunc + v26 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v27 := args[0] + _ = v27 + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("some")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.Apply(v30, []any{v27, v18}) + return v31 + }) + v27 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7500), lang.NewKeyword("column"), int(36), lang.NewKeyword("end-line"), int(7500), lang.NewKeyword("end-column"), int(49)) + v28, err := lang.WithMeta(v26, v27.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v29 := lang.Apply(v25, []any{v28, v12}) + v22 = v29 + } + v19 = v22 + } // end let + return v19 + } + }) + v14 := v13 + _ = v14 + } + v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7494), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7500), lang.NewKeyword("end-column"), int(56)) + v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v7 = v15 + } // end let + return v7 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // some? + { + v1 := reflect.TypeOf(false) + v0 := lang.NewSymbol("some?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is not nil, false otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(530), lang.NewKeyword("end-line"), int(530))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("not")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("nil?")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v4}) + v12 := lang.Apply(v7, []any{v11}) + return v12 + }) + v4 := reflect.TypeOf(false) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // sort + { + v0 := lang.NewSymbol("sort").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("comp"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a sorted sequence of the items in coll. If no comparator is\n supplied, uses compare. comparator must implement\n java.util.Comparator. Guaranteed to be stable: equal elements will\n not be reordered. If coll is a Java array, it will be modified. To\n avoid this, sort a copy of the array.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3085), lang.NewKeyword("end-line"), int(3085))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("sort")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("compare")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v6, []any{v9, v3}) + return v10 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("seq")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{v4}) + if lang.IsTruthy(v9) { + var v10 any + { // let + // let binding "a" + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("to-array")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{v4}) + var v15 any = v14 + _ = v15 + v16 := lang.Apply(lang.SortSlice, []any{v15, v3}) + _ = v16 + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("with-meta")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("seq")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.Apply(v22, []any{v15}) + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("meta")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.Apply(v26, []any{v4}) + v28 := lang.Apply(v19, []any{v23, v27}) + v10 = v28 + } // end let + v5 = v10 + } else { + v5 = lang.NewList() + } + return v5 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // sort-by + { + v0 := lang.NewSymbol("sort-by").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("keyfn"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("keyfn"), lang.NewSymbol("comp"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a sorted sequence of the items in coll, where the sort\n order is determined by comparing (keyfn item). If no comparator is\n supplied, uses compare. comparator must implement\n java.util.Comparator. Guaranteed to be stable: equal elements will\n not be reordered. If coll is a Java array, it will be modified. To\n avoid this, sort a copy of the array.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3102), lang.NewKeyword("end-line"), int(3102))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("sort-by")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("compare")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v7, []any{v3, v10, v4}) + return v11 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("sort")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + var v9 lang.FnFunc + v9 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + v12 := lang.Apply(v3, []any{v10}) + v13 := lang.Apply(v3, []any{v11}) + v14 := lang.Apply(v4, []any{v12, v13}) + return v14 + }) + v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3114), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(3114), lang.NewKeyword("end-column"), int(46)) + v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v12 := lang.Apply(v8, []any{v11, v5}) + return v12 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // sorted-map + { + v0 := lang.NewSymbol("sorted-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keyvals"))), lang.NewKeyword("doc"), "keyval => key val\n Returns a new sorted map with supplied mappings. If any keys are\n equal, they are handled as if by repeated uses of assoc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(397), lang.NewKeyword("end-line"), int(397))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := lang.NewList(args[0:]...) + v4 := lang.Apply(lang.CreatePersistentTreeMap, []any{v3}) + return v4 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // sorted-map-by + { + v0 := lang.NewSymbol("sorted-map-by").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("comparator"), lang.NewSymbol("&"), lang.NewSymbol("keyvals"))), lang.NewKeyword("doc"), "keyval => key val\n Returns a new sorted map with supplied mappings, using the supplied\n comparator. If any keys are equal, they are handled as if by\n repeated uses of assoc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(406), lang.NewKeyword("end-line"), int(406))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.NewList(args[1:]...) + v5 := lang.Apply(nil, []any{v3, v4}) + return v5 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // sorted-set + { + v0 := lang.NewSymbol("sorted-set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keys"))), lang.NewKeyword("doc"), "Returns a new sorted set with supplied keys. Any equal keys are\n handled as if by repeated uses of conj.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(416), lang.NewKeyword("end-line"), int(416))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := lang.NewList(args[0:]...) + v4 := lang.Apply(lang.CreatePersistentTreeSet, []any{v3}) + return v4 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // sorted-set-by + { + v0 := lang.NewSymbol("sorted-set-by").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("comparator"), lang.NewSymbol("&"), lang.NewSymbol("keys"))), lang.NewKeyword("doc"), "Returns a new sorted set with supplied keys, using the supplied\n comparator. Any equal keys are handled as if by repeated uses of\n conj.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(424), lang.NewKeyword("end-line"), int(424))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.NewList(args[1:]...) + v5 := lang.Apply(lang.CreatePersistentTreeSetWithComparator, []any{v3, v4}) + return v5 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // sorted? + { + v0 := lang.NewSymbol("sorted?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements Sorted", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6235), lang.NewKeyword("end-line"), int(6235))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.Apply(v6, []any{nil, v3}) + return v7 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // special-symbol? + { + v0 := lang.NewSymbol("special-symbol?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns true if s names a special form", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4992), lang.NewKeyword("end-line"), int(4992))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("contains?")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7, ok := lang.FieldOrMethod(runtime4.Compiler, "specials") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", runtime4.Compiler, "specials"))) + } + var v8 any + switch reflect.TypeOf(v7).Kind() { + case reflect.Func: + v8 = lang.Apply(v7, nil) + default: + v8 = v7 + } + v9 := lang.Apply(v6, []any{v8, v3}) + return v9 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // spit + { + v0 := lang.NewSymbol("spit").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("content"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Opposite of slurp. Opens f with writer, writes content, then\n closes f. Options passed to glojure.java.io/writer.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6994), lang.NewKeyword("end-line"), int(6994))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.NewList(args[2:]...) + var v6 any + { // let + // let binding "w" + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("apply")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, []any{nil, v3, v5}) + var v11 any = v10 + _ = v11 + var v12 any + func() { + defer func() { + v13, ok := lang.FieldOrMethod(v11, "close") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v11, "close"))) + } + var v14 any + switch reflect.TypeOf(v13).Kind() { + case reflect.Func: + v14 = lang.Apply(v13, nil) + default: + v14 = v13 + } + }() + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("str")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{v4}) + v19 := lang.Apply(lang.WriteWriter, []any{v11, v18}) + v12 = v19 + }() + v6 = v12 + } // end let + return v6 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // split-at + { + v0 := lang.NewSymbol("split-at").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a vector of [(take n coll) (drop n coll)]", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2983), lang.NewKeyword("end-line"), int(2983))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("take")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v3, v4}) + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("drop")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.Apply(v11, []any{v3, v4}) + v13 := lang.NewVector(v8, v12) + v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2988), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2988), lang.NewKeyword("end-column"), int(33)) + v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v15 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // split-with + { + v0 := lang.NewSymbol("split-with").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a vector of [(take-while pred coll) (drop-while pred coll)]", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2990), lang.NewKeyword("end-line"), int(2990))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("take-while")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v3, v4}) + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("drop-while")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.Apply(v11, []any{v3, v4}) + v13 := lang.NewVector(v8, v12) + v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2995), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2995), lang.NewKeyword("end-column"), int(51)) + v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v15 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // splitv-at + { + v0 := lang.NewSymbol("splitv-at").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a vector of [(into [] (take n) coll) (drop n coll)]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7256), lang.NewKeyword("end-line"), int(7256))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("into")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.NewVector() + v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7260), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(7260), lang.NewKeyword("end-column"), int(11)) + v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("take")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{v3}) + v15 := lang.Apply(v7, []any{v10, v14, v4}) + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("drop")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{v3, v4}) + v20 := lang.NewVector(v15, v19) + v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7260), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(7260), lang.NewKeyword("end-column"), int(41)) + v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v22 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // spread + { + v0 := lang.NewSymbol("spread").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("arglist"))), lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(632), lang.NewKeyword("end-line"), int(632), lang.NewKeyword("private"), true)).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("nil?")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v3}) + if lang.IsTruthy(v8) { + v4 = nil + } else { + var v9 any + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("nil?")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("next")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{v3}) + v17 := lang.Apply(v12, []any{v16}) + if lang.IsTruthy(v17) { + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("seq")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("first")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.Apply(v23, []any{v3}) + v25 := lang.Apply(v20, []any{v24}) + v9 = v25 + } else { + var v26 any + if lang.IsTruthy(lang.NewKeyword("else")) { + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("cons")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("first")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.Apply(v32, []any{v3}) + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("spread")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("next")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.Apply(v39, []any{v3}) + v41 := lang.Apply(v36, []any{v40}) + v42 := lang.Apply(v29, []any{v33, v41}) + v26 = v42 + } else { + v26 = nil + } + v9 = v26 + } + v4 = v9 + } + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // str + { + v1 := reflect.TypeOf("") + v0 := lang.NewSymbol("str").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("ys"))), lang.NewKeyword("doc"), "With no args, returns the empty string. With one arg x, returns\n x.toString(). (str nil) returns the empty string. With more than\n one arg, returns the concatenation of the str values of the args.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(543), lang.NewKeyword("end-line"), int(543))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return "" + case 1: + v4 := args[0] + _ = v4 + var v5 any + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("nil?")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{v4}) + if lang.IsTruthy(v9) { + v5 = "" + } else { + v10 := lang.Apply(lang.ToString, []any{v4}) + v5 = v10 + } + return v5 + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := lang.NewList(args[1:]...) + var v6 lang.FnFunc + v6 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + recur_loop_74: + var v9 any + if lang.IsTruthy(v8) { + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("str")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("first")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{v8}) + v18 := lang.Apply(v13, []any{v17}) + v19, _ := lang.FieldOrMethod(v7, "WriteString") + if reflect.TypeOf(v19).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("WriteString is not a function"))) + } + v20 := lang.Apply(v19, []any{v18}) + _ = v20 + var v10 any = v7 + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("next")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v8}) + var v21 any = v25 + v7 = v10 + v8 = v21 + goto recur_loop_74 + } else { + v26, ok := lang.FieldOrMethod(v7, "String") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "String"))) + } + var v27 any + switch reflect.TypeOf(v26).Kind() { + case reflect.Func: + v27 = lang.Apply(v26, nil) + default: + v27 = v26 + } + v9 = v27 + } + return v9 + }) + v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(554), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(554), lang.NewKeyword("end-column"), int(127)) + v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("cons")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.Apply(v11, []any{v4, v5}) + v13 := lang.Apply(v8, []any{"unimplemented: new with non-constant class type", v12}) + return v13 + } + }) + v4 := reflect.TypeOf("") + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // stream-into! + { + v0 := lang.NewSymbol("stream-into!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("stream")), lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("xform"), lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Returns a new coll consisting of coll with all of the items of the\n stream conjoined. This is a terminal operation on the stream.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6810), lang.NewKeyword("end-line"), int(6810))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{lang.IEditableCollection, v3}) + if lang.IsTruthy(v9) { + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("with-meta")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("persistent!")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("stream-reduce!")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("conj!")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("transient")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v3}) + v26 := lang.Apply(v18, []any{v21, v25, v4}) + v27 := lang.Apply(v15, []any{v26}) + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("meta")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.Apply(v30, []any{v3}) + v32 := lang.Apply(v12, []any{v27, v31}) + v5 = v32 + } else { + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("stream-reduce!")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("conj")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v35, []any{v38, v3, v4}) + v5 = v39 + } + return v5 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("instance?")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, []any{lang.IEditableCollection, v3}) + if lang.IsTruthy(v10) { + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("with-meta")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("persistent!")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("stream-transduce!")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("conj!")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("transient")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.Apply(v25, []any{v3}) + v27 := lang.Apply(v19, []any{v4, v22, v26, v5}) + v28 := lang.Apply(v16, []any{v27}) + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("meta")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.Apply(v31, []any{v3}) + v33 := lang.Apply(v13, []any{v28, v32}) + v6 = v33 + } else { + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("stream-transduce!")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("conj")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.Apply(v36, []any{v4, v39, v3, v5}) + v6 = v40 + } + return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // stream-reduce! + { + v0 := lang.NewSymbol("stream-reduce!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("s")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Works like reduce but takes a java.util.stream.BaseStream as its source.\n Honors 'reduced', is a terminal operation on the stream", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6784), lang.NewKeyword("end-line"), int(6784))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5, ok := lang.FieldOrMethod(v4, "iterator") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "iterator"))) + } + var v6 any + switch reflect.TypeOf(v5).Kind() { + case reflect.Func: + v6 = lang.Apply(v5, nil) + default: + v6 = v5 + } + v7 := lang.Apply(nil, []any{v6, v3}) + return v7 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6, ok := lang.FieldOrMethod(v5, "iterator") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "iterator"))) + } + var v7 any + switch reflect.TypeOf(v6).Kind() { + case reflect.Func: + v7 = lang.Apply(v6, nil) + default: + v7 = v6 + } + v8 := lang.Apply(nil, []any{v7, v3, v4}) + return v8 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // stream-seq! + { + v0 := lang.NewSymbol("stream-seq!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Takes a java.util.stream.BaseStream instance s and returns a seq of its\n contents. This is a terminal operation on the stream.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6793), lang.NewKeyword("end-line"), int(6793))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("iterator-seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7, ok := lang.FieldOrMethod(v3, "iterator") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "iterator"))) + } + var v8 any + switch reflect.TypeOf(v7).Kind() { + case reflect.Func: + v8 = lang.Apply(v7, nil) + default: + v8 = v7 + } + v9 := lang.Apply(v6, []any{v8}) + return v9 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // stream-transduce! + { + v0 := lang.NewSymbol("stream-transduce!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("f"), lang.NewSymbol("stream")), lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Works like transduce but takes a java.util.stream.BaseStream as its source.\n This is a terminal operation on the stream.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6800), lang.NewKeyword("end-line"), int(6800))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("stream-transduce!")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v4, nil) + v10 := lang.Apply(v8, []any{v3, v4, v9, v5}) + return v10 + case 4: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + var v7 any + { // let + // let binding "f" + v8 := lang.Apply(v3, []any{v4}) + var v9 any = v8 + _ = v9 + // let binding "ret" + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("stream-reduce!")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{v9, v5, v6}) + var v14 any = v13 + _ = v14 + v15 := lang.Apply(v9, []any{v14}) + v7 = v15 + } // end let + return v7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // string? + { + v0 := lang.NewSymbol("string?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a String", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(160), lang.NewKeyword("end-line"), int(164))).(*lang.Symbol) + var v2 lang.FnFunc + { // function string? + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{lang.Builtins["string"], v4}) + return v8 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(164), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(164), lang.NewKeyword("end-column"), int(58))).(lang.FnFunc) + v3 := v2 + _ = v3 + } + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // strip-ns + { + v0 := lang.NewSymbol("strip-ns").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(255), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(255), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("named"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("symbol?")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v3}) + if lang.IsTruthy(v8) { + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("symbol")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("name")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.Apply(v14, []any{v3}) + v16 := lang.Apply(v11, []any{nil, v15}) + v4 = v16 + } else { + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("keyword")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("name")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.Apply(v22, []any{v3}) + v24 := lang.Apply(v19, []any{nil, v23}) + v4 = v24 + } + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // struct + { + v0 := lang.NewSymbol("struct").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("&"), lang.NewSymbol("vals"))), lang.NewKeyword("doc"), "Returns a new structmap instance with the keys of the\n structure-basis. vals must be supplied for basis keys in order -\n where values are not supplied they will default to nil.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4061), lang.NewKeyword("end-line"), int(4061))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.NewList(args[1:]...) + v5 := lang.Apply(lang.ConstructPersistentStructMap, []any{v3, v4}) + return v5 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // struct-map + { + v0 := lang.NewSymbol("struct-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("&"), lang.NewSymbol("inits"))), lang.NewKeyword("doc"), "Returns a new structmap instance with the keys of the\n structure-basis. keyvals may contain all, some or none of the basis\n keys - where values are not supplied they will default to nil.\n keyvals can also contain keys not in the basis.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4051), lang.NewKeyword("end-line"), int(4051))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.NewList(args[1:]...) + v5 := lang.Apply(lang.CreatePersistentStructMap, []any{v3, v4}) + return v5 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // subs + { + v0 := lang.NewSymbol("subs").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("start")), lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("start"), lang.NewSymbol("end"))), lang.NewKeyword("doc"), "Returns the substring of s beginning at start inclusive, and ending\n at end (defaults to length of string), exclusive.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5005), lang.NewKeyword("end-line"), int(5005))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.Apply(lang.Builtins["slice"], []any{v3, v4}) + return v5 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.Apply(lang.Builtins["slice"], []any{v3, v4, v5}) + return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // subseq + { + v0 := lang.NewSymbol("subseq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sc"), lang.NewSymbol("test"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("sc"), lang.NewSymbol("start-test"), lang.NewSymbol("start-key"), lang.NewSymbol("end-test"), lang.NewSymbol("end-key"))), lang.NewKeyword("doc"), "sc must be a sorted collection, test(s) one of <, <=, > or\n >=. Returns a seq of those entries with keys ek for\n which (test (.. sc comparator (compare ek key)) 0) is true", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5133), lang.NewKeyword("end-line"), int(5133))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any + { // let + // let binding "include" + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("mk-bound-fn")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, []any{v3, v4, v5}) + var v11 any = v10 + _ = v11 + var v12 any + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol(">")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol(">=")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.CreatePersistentTreeSet(v15, v18) + v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5141), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5141), lang.NewKeyword("end-column"), int(17)) + v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v22 := lang.Apply(v21, []any{v4}) + if lang.IsTruthy(v22) { + var v23 any + { // let + // let binding "temp__0__auto__" + v24, _ := lang.FieldOrMethod(v3, "seqFrom") + if reflect.TypeOf(v24).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("seqFrom is not a function"))) + } + v25 := lang.Apply(v24, []any{v5, true}) + var v26 any = v25 + _ = v26 + var v27 any + if lang.IsTruthy(v26) { + var v28 any + { // let + // let binding "vec__68" + var v29 any = v26 + _ = v29 + // let binding "e" + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("nth")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.Apply(v32, []any{v29, int64(0), nil}) + var v34 any = v33 + _ = v34 + // let binding "s" + var v35 any = v29 + _ = v35 + var v36 any + v37 := lang.Apply(v11, []any{v34}) + if lang.IsTruthy(v37) { + v36 = v35 + } else { + v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v39 := v38.FindInternedVar(lang.NewSymbol("next")) + if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + } + v40 := v39.Get() + v41 := lang.Apply(v40, []any{v35}) + v36 = v41 + } + v28 = v36 + } // end let + v27 = v28 + } else { + v27 = nil + } + v23 = v27 + } // end let + v12 = v23 + } else { + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("take-while")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27, _ := lang.FieldOrMethod(v3, "seq") + if reflect.TypeOf(v27).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("seq is not a function"))) + } + v28 := lang.Apply(v27, []any{true}) + v29 := lang.Apply(v26, []any{v11, v28}) + v12 = v29 + } + v6 = v12 + } // end let + return v6 + case 5: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := args[4] + _ = v7 + var v8 any + { // let + // let binding "temp__0__auto__" + v9, _ := lang.FieldOrMethod(v3, "seqFrom") + if reflect.TypeOf(v9).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("seqFrom is not a function"))) + } + v10 := lang.Apply(v9, []any{v5, true}) + var v11 any = v10 + _ = v11 + var v12 any + if lang.IsTruthy(v11) { + var v13 any + { // let + // let binding "vec__71" + var v14 any = v11 + _ = v14 + // let binding "e" + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("nth")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{v14, int64(0), nil}) + var v19 any = v18 + _ = v19 + // let binding "s" + var v20 any = v14 + _ = v20 + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("take-while")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("mk-bound-fn")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.Apply(v26, []any{v3, v6, v7}) + var v28 any + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("mk-bound-fn")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.Apply(v31, []any{v3, v4, v5}) + v33 := lang.Apply(v32, []any{v19}) + if lang.IsTruthy(v33) { + v28 = v20 + } else { + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("next")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.Apply(v36, []any{v20}) + v28 = v37 + } + v38 := lang.Apply(v23, []any{v27, v28}) + v13 = v38 + } // end let + v12 = v13 + } else { + v12 = nil + } + v8 = v12 + } // end let + return v8 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // subvec + { + v0 := lang.NewSymbol("subvec").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("v"), lang.NewSymbol("start")), lang.NewVector(lang.NewSymbol("v"), lang.NewSymbol("start"), lang.NewSymbol("end"))), lang.NewKeyword("doc"), "Returns a persistent vector of the items in vector from\n start (inclusive) to end (exclusive). If end is not supplied,\n defaults to (count vector). This operation is O(1) and very fast, as\n the resulting vector shares structure with the original and no\n trimming is done.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3819), lang.NewKeyword("end-line"), int(3819))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("subvec")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("count")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v3}) + v12 := lang.Apply(v7, []any{v3, v4, v11}) + return v12 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6, _ := lang.FieldOrMethod(runtime4.RT, "Subvec") + if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Subvec is not a function"))) + } + v7 := lang.Apply(v6, []any{v3, v4, v5}) + return v7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // supers + { + v0 := lang.NewSymbol("supers").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("class"))), lang.NewKeyword("doc"), "Returns the immediate and indirect superclasses and interfaces of c, if any", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5532), lang.NewKeyword("end-line"), int(5532))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + { // let + // let binding "ret" + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("set")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("bases")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v3}) + v12 := lang.Apply(v7, []any{v11}) + var v13 any = v12 + _ = v13 + // let binding "cs" + var v14 any = v13 + _ = v14 + for { + var v15 any + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("seq")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{v14}) + if lang.IsTruthy(v19) { + var v20 any + { // let + // let binding "c" + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("first")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.Apply(v23, []any{v14}) + var v25 any = v24 + _ = v25 + // let binding "bs" + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("bases")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.Apply(v28, []any{v25}) + var v30 any = v29 + _ = v30 + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("into1")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{v13, v30}) + var v31 any = v35 + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("into1")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("disj")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.Apply(v42, []any{v14, v25}) + v44 := lang.Apply(v39, []any{v43, v30}) + var v36 any = v44 + v13 = v31 + v14 = v36 + continue + } // end let + v15 = v20 + } else { + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("not-empty")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.Apply(v23, []any{v13}) + v15 = v24 + } + v4 = v15 + break + } + } // end let + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // swap! + { + v0 := lang.NewSymbol("swap!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atom"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Atomically swaps the value of atom to be:\n (apply f current-value-of-atom args). Note that f may be called\n multiple times, and thus should be free of side effects. Returns\n the value that was swapped in.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2343), lang.NewKeyword("end-line"), int(2343))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.NewList(args[2:]...) + v6, _ := lang.FieldOrMethod(v3, "swap") + if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("swap is not a function"))) + } + v7 := lang.Apply(v6, []any{v4, v5}) + return v7 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // swap-vals! + { + v0 := lang.NewSymbol("swap-vals!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atom"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Atomically swaps the value of atom to be:\n (apply f current-value-of-atom args). Note that f may be called\n multiple times, and thus should be free of side effects.\n Returns [old new], the value of the atom before and after the swap.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2352), lang.NewKeyword("end-line"), int(2352))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.NewList(args[2:]...) + v6, _ := lang.FieldOrMethod(v3, "swapVals") + if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("swapVals is not a function"))) + } + v7 := lang.Apply(v6, []any{v4, v5}) + return v7 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // symbol + { + v1 := reflect.TypeOf((*lang.Symbol)(nil)) + v0 := lang.NewSymbol("symbol").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name"))), lang.NewKeyword("doc"), "Returns a Symbol with the given namespace and name. Arity-1 works\n on strings, keywords, and vars.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(584), lang.NewKeyword("end-line"), int(584))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + var v5 any + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("symbol?")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{v4}) + if lang.IsTruthy(v9) { + v5 = v4 + } else { + var v10 any + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("instance?")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{lang.Builtins["string"], v4}) + if lang.IsTruthy(v14) { + v15 := lang.Apply(lang.NewSymbol, []any{v4}) + v10 = v15 + } else { + var v16 any + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("instance?")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.Apply(v19, []any{*lang.Var, v4}) + if lang.IsTruthy(v20) { + v21, ok := lang.FieldOrMethod(v4, "toSymbol") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "toSymbol"))) + } + var v22 any + switch reflect.TypeOf(v21).Kind() { + case reflect.Func: + v22 = lang.Apply(v21, nil) + default: + v22 = v21 + } + v16 = v22 + } else { + var v23 any + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("instance?")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.Apply(v26, []any{lang.Keyword, v4}) + if lang.IsTruthy(v27) { + v28, ok := lang.FieldOrMethod(v4, "sym") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "sym"))) + } + var v29 any + switch reflect.TypeOf(v28).Kind() { + case reflect.Func: + v29 = lang.Apply(v28, nil) + default: + v29 = v28 + } + v23 = v29 + } else { + var v30 any + if lang.IsTruthy(lang.NewKeyword("else")) { + v31 := lang.Apply(lang.NewIllegalArgumentError, []any{"no conversion to symbol"}) + panic(v31) + } else { + v30 = nil + } + v23 = v30 + } + v16 = v23 + } + v10 = v16 + } + v5 = v10 + } + return v5 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := lang.Apply(lang.InternSymbol, []any{v4, v5}) + return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v4 := reflect.TypeOf((*lang.Symbol)(nil)) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // symbol? + { + v0 := lang.NewSymbol("symbol?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a Symbol", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(557), lang.NewKeyword("end-line"), int(557))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.Apply(v6, []any{*lang.Symbol, v3}) + return v7 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // sync + { + v0 := lang.NewSymbol("sync").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("flags-ignored-for-now"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "transaction-flags => TBD, pass nil for now\n\n Runs the exprs (in an implicit do) in a transaction that encompasses\n exprs and any nested calls. Starts a transaction if none is already\n running on this thread. Any uncaught exception will abort the\n transaction and flow out of sync. The exprs may be run more than\n once, but any effects on Refs will be atomic.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(2490), lang.NewKeyword("end-line"), int(2490))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("seq")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("concat")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("list")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{lang.NewSymbol(".")}) + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("list")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.Apply(v19, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.LockingTransaction")}) + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("list")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("seq")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("concat")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("list")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.Apply(v32, []any{lang.NewSymbol("glojure.core/RunInTransaction")}) + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("list")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("seq")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("concat")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v44 := v43.FindInternedVar(lang.NewSymbol("list")) + if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) + } + v45 := v44.Get() + v46 := lang.Apply(v45, []any{lang.NewSymbol("glojure.core/fn")}) + v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v48 := v47.FindInternedVar(lang.NewSymbol("list")) + if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) + } + v49 := v48.Get() + v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v51 := v50.FindInternedVar(lang.NewSymbol("apply")) + if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) + } + v52 := v51.Get() + v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v54 := v53.FindInternedVar(lang.NewSymbol("vector")) + if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) + } + v55 := v54.Get() + v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v57 := v56.FindInternedVar(lang.NewSymbol("seq")) + if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) + } + v58 := v57.Get() + v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v60 := v59.FindInternedVar(lang.NewSymbol("concat")) + if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) + } + v61 := v60.Get() + v62 := lang.Apply(v61, nil) + v63 := lang.Apply(v58, []any{v62}) + v64 := lang.Apply(v52, []any{v55, v63}) + v65 := lang.Apply(v49, []any{v64}) + v66 := lang.Apply(v42, []any{v46, v65, v6}) + v67 := lang.Apply(v39, []any{v66}) + v68 := lang.Apply(v36, []any{v67}) + v69 := lang.Apply(v29, []any{v33, v68}) + v70 := lang.Apply(v26, []any{v69}) + v71 := lang.Apply(v23, []any{v70}) + v72 := lang.Apply(v12, []any{v16, v20, v71}) + v73 := lang.Apply(v9, []any{v72}) + return v73 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // system-newline + { + v0 := lang.NewSymbol("system-newline").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3695), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(3695), lang.NewKeyword("end-column"), int(40), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + v1 := ns.InternWithValue(v0, "\n", true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // tagged-literal + { + v0 := lang.NewSymbol("tagged-literal").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag"), lang.NewSymbol("form"))), lang.NewKeyword("doc"), "Construct a data representation of a tagged literal from a\n tag symbol and a form.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7769), lang.NewKeyword("end-line"), int(7769))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.Apply(nil, []any{v3, v4}) + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // tagged-literal? + { + v0 := lang.NewSymbol("tagged-literal?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("value"))), lang.NewKeyword("doc"), "Return true if the value is the data representation of a tagged literal", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7763), lang.NewKeyword("end-line"), int(7763))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.Apply(v6, []any{nil, v3}) + return v7 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // take + { + v0 := lang.NewSymbol("take").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the first n items in coll, or all items if\n there are fewer than n. Returns a stateful transducer when\n no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2853), lang.NewKeyword("end-line"), int(2853))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + var v4 lang.FnFunc + v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + var v6 any + { // let + // let binding "nv" + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("volatile!")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, []any{v3}) + var v11 any = v10 + _ = v11 + var v12 lang.FnFunc + v12 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + v13 := lang.Apply(v5, nil) + return v13 + case 1: + v13 := args[0] + _ = v13 + v14 := lang.Apply(v5, []any{v13}) + return v14 + case 2: + v13 := args[0] + _ = v13 + v14 := args[1] + _ = v14 + var v15 any + { // let + // let binding "n" + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("deref")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{v11}) + var v20 any = v19 + _ = v20 + // let binding "nn" + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("dec")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24, ok := lang.FieldOrMethod(v11, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v11, "Deref"))) + } + var v25 any + switch reflect.TypeOf(v24).Kind() { + case reflect.Func: + v25 = lang.Apply(v24, nil) + default: + v25 = v24 + } + v26 := lang.Apply(v23, []any{v25}) + v27, _ := lang.FieldOrMethod(v11, "reset") + if reflect.TypeOf(v27).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) + } + v28 := lang.Apply(v27, []any{v26}) + var v29 any = v28 + _ = v29 + // let binding "result" + var v30 any + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("pos?")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{v20}) + if lang.IsTruthy(v34) { + v35 := lang.Apply(v5, []any{v13, v14}) + v30 = v35 + } else { + v30 = v13 + } + var v36 any = v30 + _ = v36 + var v37 any + v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v39 := v38.FindInternedVar(lang.NewSymbol("not")) + if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + } + v40 := v39.Get() + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("pos?")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.Apply(v43, []any{v29}) + v45 := lang.Apply(v40, []any{v44}) + if lang.IsTruthy(v45) { + v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v47 := v46.FindInternedVar(lang.NewSymbol("ensure-reduced")) + if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) + } + v48 := v47.Get() + v49 := lang.Apply(v48, []any{v36}) + v37 = v49 + } else { + v37 = v36 + } + v15 = v37 + } // end let + return v15 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2862), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(2873), lang.NewKeyword("end-column"), int(28)) + v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v6 = v14 + } // end let + return v6 + }) + v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2860), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2873), lang.NewKeyword("end-column"), int(30)) + v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v6 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 lang.FnFunc + v5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v6 any + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("pos?")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, []any{v3}) + if lang.IsTruthy(v10) { + var v11 any + { // let + // let binding "temp__0__auto__" + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("seq")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.Apply(v14, []any{v4}) + var v16 any = v15 + _ = v16 + var v17 any + if lang.IsTruthy(v16) { + var v18 any + { // let + // let binding "s" + var v19 any = v16 + _ = v19 + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("cons")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("first")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.Apply(v25, []any{v19}) + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("take")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("dec")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.Apply(v32, []any{v3}) + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("rest")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.Apply(v36, []any{v19}) + v38 := lang.Apply(v29, []any{v33, v37}) + v39 := lang.Apply(v22, []any{v26, v38}) + v18 = v39 + } // end let + v17 = v18 + } else { + v17 = nil + } + v11 = v17 + } // end let + v6 = v11 + } else { + v6 = nil + } + return v6 + }) + v6 := lang.Apply(lang.NewLazySeq, []any{v5}) + return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // take-last + { + v0 := lang.NewSymbol("take-last").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a seq of the last n items in coll. Depending on the type\n of coll may be no better than linear time. For vectors, see also subvec.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2939), lang.NewKeyword("end-line"), int(2939))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any + { // let + // let binding "s" + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("seq")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{v4}) + var v10 any = v9 + _ = v10 + // let binding "lead" + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("seq")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("drop")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{v3, v4}) + v18 := lang.Apply(v13, []any{v17}) + var v19 any = v18 + _ = v19 + for { + var v20 any + if lang.IsTruthy(v19) { + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("next")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v10}) + var v21 any = v25 + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("next")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{v19}) + var v26 any = v30 + v10 = v21 + v19 = v26 + continue + } else { + v20 = v10 + } + v5 = v20 + break + } + } // end let + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // take-nth + { + v0 := lang.NewSymbol("take-nth").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy seq of every nth item in coll. Returns a stateful\n transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4287), lang.NewKeyword("end-line"), int(4287))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + var v4 lang.FnFunc + v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + var v6 any + { // let + // let binding "iv" + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("volatile!")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, []any{int64(-1)}) + var v11 any = v10 + _ = v11 + var v12 lang.FnFunc + v12 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + v13 := lang.Apply(v5, nil) + return v13 + case 1: + v13 := args[0] + _ = v13 + v14 := lang.Apply(v5, []any{v13}) + return v14 + case 2: + v13 := args[0] + _ = v13 + v14 := args[1] + _ = v14 + var v15 any + { // let + // let binding "i" + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("inc")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19, ok := lang.FieldOrMethod(v11, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v11, "Deref"))) + } + var v20 any + switch reflect.TypeOf(v19).Kind() { + case reflect.Func: + v20 = lang.Apply(v19, nil) + default: + v20 = v19 + } + v21 := lang.Apply(v18, []any{v20}) + v22, _ := lang.FieldOrMethod(v11, "reset") + if reflect.TypeOf(v22).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) + } + v23 := lang.Apply(v22, []any{v21}) + var v24 any = v23 + _ = v24 + var v25 any + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("zero?")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("rem")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.Apply(v31, []any{v24, v3}) + v33 := lang.Apply(v28, []any{v32}) + if lang.IsTruthy(v33) { + v34 := lang.Apply(v5, []any{v13, v14}) + v25 = v34 + } else { + v25 = v13 + } + v15 = v25 + } // end let + return v15 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4295), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(4302), lang.NewKeyword("end-column"), int(28)) + v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v6 = v14 + } // end let + return v6 + }) + v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4293), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(4302), lang.NewKeyword("end-column"), int(30)) + v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v6 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 lang.FnFunc + v5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v6 any + { // let + // let binding "temp__0__auto__" + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("seq")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, []any{v4}) + var v11 any = v10 + _ = v11 + var v12 any + if lang.IsTruthy(v11) { + var v13 any + { // let + // let binding "s" + var v14 any = v11 + _ = v14 + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("cons")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("first")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.Apply(v20, []any{v14}) + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("take-nth")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("drop")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.Apply(v27, []any{v3, v14}) + v29 := lang.Apply(v24, []any{v3, v28}) + v30 := lang.Apply(v17, []any{v21, v29}) + v13 = v30 + } // end let + v12 = v13 + } else { + v12 = nil + } + v6 = v12 + } // end let + return v6 + }) + v6 := lang.Apply(lang.NewLazySeq, []any{v5}) + return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // take-while + { + v0 := lang.NewSymbol("take-while").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred")), lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of successive items from coll while\n (pred item) returns logical true. pred must be free of side-effects.\n Returns a transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2880), lang.NewKeyword("end-line"), int(2880))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + var v4 lang.FnFunc + v4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + var v6 lang.FnFunc + v6 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + v7 := lang.Apply(v5, nil) + return v7 + case 1: + v7 := args[0] + _ = v7 + v8 := lang.Apply(v5, []any{v7}) + return v8 + case 2: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + var v9 any + v10 := lang.Apply(v3, []any{v8}) + if lang.IsTruthy(v10) { + v11 := lang.Apply(v5, []any{v7, v8}) + v9 = v11 + } else { + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("reduced")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.Apply(v14, []any{v7}) + v9 = v15 + } + return v9 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2888), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(2894), lang.NewKeyword("end-column"), int(33)) + v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v8 + }) + v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2887), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2894), lang.NewKeyword("end-column"), int(34)) + v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v6 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 lang.FnFunc + v5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v6 any + { // let + // let binding "temp__0__auto__" + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("seq")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v9, []any{v4}) + var v11 any = v10 + _ = v11 + var v12 any + if lang.IsTruthy(v11) { + var v13 any + { // let + // let binding "s" + var v14 any = v11 + _ = v14 + var v15 any + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("first")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{v14}) + v20 := lang.Apply(v3, []any{v19}) + if lang.IsTruthy(v20) { + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("cons")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("first")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.Apply(v26, []any{v14}) + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("take-while")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("rest")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{v14}) + v35 := lang.Apply(v30, []any{v3, v34}) + v36 := lang.Apply(v23, []any{v27, v35}) + v15 = v36 + } else { + v15 = nil + } + v13 = v15 + } // end let + v12 = v13 + } else { + v12 = nil + } + v6 = v12 + } // end let + return v6 + }) + v6 := lang.Apply(lang.NewLazySeq, []any{v5}) + return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // tapset + { + v0 := lang.NewSymbol("tapset").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7882), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(7882), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + v2 := lang.NewAtom(lang.CreatePersistentTreeSet()) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // test + { + v0 := lang.NewSymbol("test").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("v"))), lang.NewKeyword("doc"), "test [v] finds fn at key :test in var metadata and calls it,\n presuming failure will throw exception", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4853), lang.NewKeyword("end-line"), int(4853))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + { // let + // let binding "f" + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("meta")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v3}) + v9 := lang.Apply(lang.NewKeyword("test"), []any{v8}) + var v10 any = v9 + _ = v10 + var v11 any + if lang.IsTruthy(v10) { + v12 := lang.Apply(v10, nil) + _ = v12 + v11 = lang.NewKeyword("ok") + } else { + v11 = lang.NewKeyword("no-test") + } + v4 = v11 + } // end let + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // the-ns + { + v0 := lang.NewSymbol("the-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "If passed a namespace, returns it. Else, when passed a symbol,\n returns the namespace named by it, throwing an exception if not\n found.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4152), lang.NewKeyword("end-line"), int(4152))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{*lang.Namespace, v3}) + if lang.IsTruthy(v8) { + v4 = v3 + } else { + var v9 any + { // let + // let binding "or__0__auto__" + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("find-ns")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{v3}) + var v14 any = v13 + _ = v14 + var v15 any + if lang.IsTruthy(v14) { + v15 = v14 + } else { + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("str")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{"No namespace: ", v3, " found"}) + v20 := lang.Apply(lang.NewError, []any{v19}) + panic(v20) + } + v9 = v15 + } // end let + v4 = v9 + } + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // thread-bound? + { + v0 := lang.NewSymbol("thread-bound?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("vars"))), lang.NewKeyword("doc"), "Returns true if all of the vars provided as arguments have thread-local bindings.\n Implies that set!'ing the provided vars will succeed. Returns true if no vars are provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5499), lang.NewKeyword("end-line"), int(5499))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := lang.NewList(args[0:]...) + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("every?")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + var v7 lang.FnFunc + v7 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v8 := args[0] + _ = v8 + v9, ok := lang.FieldOrMethod(v8, "getThreadBinding") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "getThreadBinding"))) + } + var v10 any + switch reflect.TypeOf(v9).Kind() { + case reflect.Func: + v10 = lang.Apply(v9, nil) + default: + v10 = v9 + } + return v10 + }) + v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5505), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5505), lang.NewKeyword("end-column"), int(78)) + v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v10 := lang.Apply(v6, []any{v9, v3}) + return v10 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // throw-if + { + v0 := lang.NewSymbol("throw-if").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("fmt"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Throws a CompilerException with a message if pred is true", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5832), lang.NewKeyword("end-line"), int(5832), lang.NewKeyword("private"), true)).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.NewList(args[2:]...) + var v6 any + if lang.IsTruthy(v3) { + var v7 any + { // let + // let binding "message" + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("apply")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("format")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v10, []any{v13, v4, v5}) + var v15 any = v14 + _ = v15 + // let binding "exception" + v16 := lang.Apply(lang.NewError, []any{v15}) + var v17 any = v16 + _ = v17 + // let binding "raw-trace" + v18, ok := lang.FieldOrMethod(v17, "getStackTrace") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v17, "getStackTrace"))) + } + var v19 any + switch reflect.TypeOf(v18).Kind() { + case reflect.Func: + v19 = lang.Apply(v18, nil) + default: + v19 = v18 + } + var v20 any = v19 + _ = v20 + // let binding "boring?" + var v21 lang.FnFunc + v21 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v22 := args[0] + _ = v22 + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("not=")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26, ok := lang.FieldOrMethod(v22, "getMethodName") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v22, "getMethodName"))) + } + var v27 any + switch reflect.TypeOf(v26).Kind() { + case reflect.Func: + v27 = lang.Apply(v26, nil) + default: + v27 = v26 + } + v28 := lang.Apply(v25, []any{v27, "doInvoke"}) + return v28 + }) + v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5839), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(5839), lang.NewKeyword("end-column"), int(74)) + v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v24 any = v23 + _ = v24 + // let binding "trace" + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("into-array")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("drop")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("drop-while")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{v24, v20}) + v35 := lang.Apply(v30, []any{int64(2), v34}) + v36 := lang.Apply(v27, []any{nil, v35}) + var v37 any = v36 + _ = v37 + v38, _ := lang.FieldOrMethod(v17, "setStackTrace") + if reflect.TypeOf(v38).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setStackTrace is not a function"))) + } + v39 := lang.Apply(v38, []any{v37}) + _ = v39 + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("*file*")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43, ok := lang.FieldOrMethod(nil, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "Deref"))) + } + var v44 any + switch reflect.TypeOf(v43).Kind() { + case reflect.Func: + v44 = lang.Apply(v43, nil) + default: + v44 = v43 + } + v45, ok := lang.FieldOrMethod(nil, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "Deref"))) + } + var v46 any + switch reflect.TypeOf(v45).Kind() { + case reflect.Func: + v46 = lang.Apply(v45, nil) + default: + v46 = v45 + } + v47 := lang.Apply(lang.NewCompilerError, []any{v42, v44, v46, v17}) + panic(v47) + } // end let + v6 = v7 + } else { + v6 = nil + } + return v6 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // time + { + v0 := lang.NewSymbol("time").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"))), lang.NewKeyword("doc"), "Evaluates expr and prints the time it took. Returns the value of\n expr.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3885), lang.NewKeyword("end-line"), int(3885))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("seq")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("concat")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("list")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.Apply(v14, []any{lang.NewSymbol("glojure.core/let")}) + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("list")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("apply")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("vector")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("seq")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("concat")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{lang.NewSymbol("start__0__auto__")}) + v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v36 := v35.FindInternedVar(lang.NewSymbol("list")) + if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + } + v37 := v36.Get() + v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v39 := v38.FindInternedVar(lang.NewSymbol("seq")) + if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + } + v40 := v39.Get() + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("concat")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("list")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.Apply(v46, []any{lang.NewSymbol(".UnixNano")}) + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("list")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v52 := v51.FindInternedVar(lang.NewSymbol("seq")) + if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) + } + v53 := v52.Get() + v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v55 := v54.FindInternedVar(lang.NewSymbol("concat")) + if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) + } + v56 := v55.Get() + v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v58 := v57.FindInternedVar(lang.NewSymbol("list")) + if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) + } + v59 := v58.Get() + v60 := lang.Apply(v59, []any{lang.NewSymbol("time.Now")}) + v61 := lang.Apply(v56, []any{v60}) + v62 := lang.Apply(v53, []any{v61}) + v63 := lang.Apply(v50, []any{v62}) + v64 := lang.Apply(v43, []any{v47, v63}) + v65 := lang.Apply(v40, []any{v64}) + v66 := lang.Apply(v37, []any{v65}) + v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v68 := v67.FindInternedVar(lang.NewSymbol("list")) + if v68.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) + } + v69 := v68.Get() + v70 := lang.Apply(v69, []any{lang.NewSymbol("ret__1__auto__")}) + v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v72 := v71.FindInternedVar(lang.NewSymbol("list")) + if v72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) + } + v73 := v72.Get() + v74 := lang.Apply(v73, []any{v5}) + v75 := lang.Apply(v30, []any{v34, v66, v70, v74}) + v76 := lang.Apply(v27, []any{v75}) + v77 := lang.Apply(v21, []any{v24, v76}) + v78 := lang.Apply(v18, []any{v77}) + v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v80 := v79.FindInternedVar(lang.NewSymbol("list")) + if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) + } + v81 := v80.Get() + v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v83 := v82.FindInternedVar(lang.NewSymbol("seq")) + if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) + } + v84 := v83.Get() + v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v86 := v85.FindInternedVar(lang.NewSymbol("concat")) + if v86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) + } + v87 := v86.Get() + v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v89 := v88.FindInternedVar(lang.NewSymbol("list")) + if v89.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) + } + v90 := v89.Get() + v91 := lang.Apply(v90, []any{lang.NewSymbol("glojure.core/prn")}) + v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v93 := v92.FindInternedVar(lang.NewSymbol("list")) + if v93.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) + } + v94 := v93.Get() + v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v96 := v95.FindInternedVar(lang.NewSymbol("seq")) + if v96.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) + } + v97 := v96.Get() + v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v99 := v98.FindInternedVar(lang.NewSymbol("concat")) + if v99.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) + } + v100 := v99.Get() + v101 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v102 := v101.FindInternedVar(lang.NewSymbol("list")) + if v102.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v102))) + } + v103 := v102.Get() + v104 := lang.Apply(v103, []any{lang.NewSymbol("glojure.core/str")}) + v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v106 := v105.FindInternedVar(lang.NewSymbol("list")) + if v106.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) + } + v107 := v106.Get() + v108 := lang.Apply(v107, []any{"Elapsed time: "}) + v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v110 := v109.FindInternedVar(lang.NewSymbol("list")) + if v110.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) + } + v111 := v110.Get() + v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v113 := v112.FindInternedVar(lang.NewSymbol("seq")) + if v113.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) + } + v114 := v113.Get() + v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v116 := v115.FindInternedVar(lang.NewSymbol("concat")) + if v116.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) + } + v117 := v116.Get() + v118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v119 := v118.FindInternedVar(lang.NewSymbol("list")) + if v119.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v119))) + } + v120 := v119.Get() + v121 := lang.Apply(v120, []any{lang.NewSymbol("glojure.core//")}) + v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v123 := v122.FindInternedVar(lang.NewSymbol("list")) + if v123.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) + } + v124 := v123.Get() + v125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v126 := v125.FindInternedVar(lang.NewSymbol("seq")) + if v126.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v126))) + } + v127 := v126.Get() + v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v129 := v128.FindInternedVar(lang.NewSymbol("concat")) + if v129.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v129))) + } + v130 := v129.Get() + v131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v132 := v131.FindInternedVar(lang.NewSymbol("list")) + if v132.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v132))) + } + v133 := v132.Get() + v134 := lang.Apply(v133, []any{lang.NewSymbol("glojure.core/double")}) + v135 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v136 := v135.FindInternedVar(lang.NewSymbol("list")) + if v136.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v136))) + } + v137 := v136.Get() + v138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v139 := v138.FindInternedVar(lang.NewSymbol("seq")) + if v139.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v139))) + } + v140 := v139.Get() + v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v142 := v141.FindInternedVar(lang.NewSymbol("concat")) + if v142.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) + } + v143 := v142.Get() + v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v145 := v144.FindInternedVar(lang.NewSymbol("list")) + if v145.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) + } + v146 := v145.Get() + v147 := lang.Apply(v146, []any{lang.NewSymbol("glojure.core/-")}) + v148 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v149 := v148.FindInternedVar(lang.NewSymbol("list")) + if v149.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v149))) + } + v150 := v149.Get() + v151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v152 := v151.FindInternedVar(lang.NewSymbol("seq")) + if v152.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v152))) + } + v153 := v152.Get() + v154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v155 := v154.FindInternedVar(lang.NewSymbol("concat")) + if v155.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v155))) + } + v156 := v155.Get() + v157 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v158 := v157.FindInternedVar(lang.NewSymbol("list")) + if v158.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v158))) + } + v159 := v158.Get() + v160 := lang.Apply(v159, []any{lang.NewSymbol(".UnixNano")}) + v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v162 := v161.FindInternedVar(lang.NewSymbol("list")) + if v162.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) + } + v163 := v162.Get() + v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v165 := v164.FindInternedVar(lang.NewSymbol("seq")) + if v165.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) + } + v166 := v165.Get() + v167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v168 := v167.FindInternedVar(lang.NewSymbol("concat")) + if v168.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v168))) + } + v169 := v168.Get() + v170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v171 := v170.FindInternedVar(lang.NewSymbol("list")) + if v171.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v171))) + } + v172 := v171.Get() + v173 := lang.Apply(v172, []any{lang.NewSymbol("time.Now")}) + v174 := lang.Apply(v169, []any{v173}) + v175 := lang.Apply(v166, []any{v174}) + v176 := lang.Apply(v163, []any{v175}) + v177 := lang.Apply(v156, []any{v160, v176}) + v178 := lang.Apply(v153, []any{v177}) + v179 := lang.Apply(v150, []any{v178}) + v180 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v181 := v180.FindInternedVar(lang.NewSymbol("list")) + if v181.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v181))) + } + v182 := v181.Get() + v183 := lang.Apply(v182, []any{lang.NewSymbol("start__0__auto__")}) + v184 := lang.Apply(v143, []any{v147, v179, v183}) + v185 := lang.Apply(v140, []any{v184}) + v186 := lang.Apply(v137, []any{v185}) + v187 := lang.Apply(v130, []any{v134, v186}) + v188 := lang.Apply(v127, []any{v187}) + v189 := lang.Apply(v124, []any{v188}) + v190 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v191 := v190.FindInternedVar(lang.NewSymbol("list")) + if v191.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v191))) + } + v192 := v191.Get() + v193 := lang.Apply(v192, []any{nil}) + v194 := lang.Apply(v117, []any{v121, v189, v193}) + v195 := lang.Apply(v114, []any{v194}) + v196 := lang.Apply(v111, []any{v195}) + v197 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v198 := v197.FindInternedVar(lang.NewSymbol("list")) + if v198.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v198))) + } + v199 := v198.Get() + v200 := lang.Apply(v199, []any{" msecs"}) + v201 := lang.Apply(v100, []any{v104, v108, v196, v200}) + v202 := lang.Apply(v97, []any{v201}) + v203 := lang.Apply(v94, []any{v202}) + v204 := lang.Apply(v87, []any{v91, v203}) + v205 := lang.Apply(v84, []any{v204}) + v206 := lang.Apply(v81, []any{v205}) + v207 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v208 := v207.FindInternedVar(lang.NewSymbol("list")) + if v208.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v208))) + } + v209 := v208.Get() + v210 := lang.Apply(v209, []any{lang.NewSymbol("ret__1__auto__")}) + v211 := lang.Apply(v11, []any{v15, v78, v206, v210}) + v212 := lang.Apply(v8, []any{v211}) + return v212 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // to-array + { + v0 := lang.NewSymbol("to-array").WithMeta(lang.NewMap(lang.NewKeyword("tag"), "[Ljava.lang.Object;", lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns an array of Objects containing the contents of coll, which\n can be any Collection. Maps to java.util.Collection.toArray().", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(337), lang.NewKeyword("end-line"), int(337))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4, _ := lang.FieldOrMethod(runtime4.RT, "ToArray") + if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ToArray is not a function"))) + } + v5 := lang.Apply(v4, []any{v3}) + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), "[Ljava.lang.Object;")).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // to-array-2d + { + v0 := lang.NewSymbol("to-array-2d").WithMeta(lang.NewMap(lang.NewKeyword("tag"), "[[Ljava.lang.Object;", lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a (potentially-ragged) 2-dimensional array of Objects\n containing the contents of coll, which can be any Collection of any\n Collection.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4002), lang.NewKeyword("end-line"), int(4002))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + { // let + // let binding "ret" + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("make-array")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8, _ := lang.FieldOrMethod(reflect.Type, "forName") + if reflect.TypeOf(v8).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("forName is not a function"))) + } + v9 := lang.Apply(v8, []any{"[Ljava.lang.Object;"}) + v10, _ := lang.FieldOrMethod(v3, "size") + if reflect.TypeOf(v10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("size is not a function"))) + } + v11 := lang.Apply(v10, []any{}) + v12 := lang.Apply(v7, []any{v9, v11}) + var v13 any = v12 + _ = v13 + var v14 any + { // let + // let binding "i" + var v15 any = int64(0) + _ = v15 + // let binding "xs" + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("seq")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{v3}) + var v20 any = v19 + _ = v20 + for { + var v21 any + if lang.IsTruthy(v20) { + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("aset")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("to-array")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("first")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.Apply(v30, []any{v20}) + v32 := lang.Apply(v27, []any{v31}) + v33 := lang.Apply(v24, []any{v13, v15, v32}) + _ = v33 + v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v36 := v35.FindInternedVar(lang.NewSymbol("inc")) + if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + } + v37 := v36.Get() + v38 := lang.Apply(v37, []any{v15}) + var v34 any = v38 + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("next")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.Apply(v42, []any{v20}) + var v39 any = v43 + v15 = v34 + v20 = v39 + continue + } else { + v21 = nil + } + v14 = v21 + break + } + } // end let + _ = v14 + v4 = v13 + } // end let + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), "[[Ljava.lang.Object;")).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // trampoline + { + v0 := lang.NewSymbol("trampoline").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "trampoline can be used to convert algorithms requiring mutual\n recursion without stack consumption. Calls f with supplied args, if\n any. If f returns a fn, calls that fn with no arguments, and\n continues to repeat, until the return value is not a fn, then\n returns that non-fn value. Note that if you want to return a fn as a\n final value, you must wrap it in some data structure and unpack it\n after trampoline returns.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6293), lang.NewKeyword("end-line"), int(6293))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + recur_loop_1073: + var v4 any + { // let + // let binding "ret" + v5 := lang.Apply(v3, nil) + var v6 any = v5 + _ = v6 + var v7 any + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("fn?")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v6}) + if lang.IsTruthy(v11) { + var v12 any = v6 + v3 = v12 + goto recur_loop_1073 + } else { + v7 = v6 + } + v4 = v7 + } // end let + return v4 + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.NewList(args[1:]...) + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("trampoline")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + var v8 lang.FnFunc + v8 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("apply")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.Apply(v11, []any{v3, v4}) + return v12 + }) + v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6309), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(6309), lang.NewKeyword("end-column"), int(32)) + v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v11 := lang.Apply(v7, []any{v10}) + return v11 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // transduce + { + v0 := lang.NewSymbol("transduce").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "reduce with a transformation of f (xf). If init is not\n supplied, (f) will be called to produce it. f should be a reducing\n step function that accepts both 1 and 2 arguments, if it accepts\n only 2 you can add the arity-1 with 'completing'. Returns the result\n of applying (the transformed) xf to init and the first item in coll,\n then applying xf to that result and the 2nd item, etc. If coll\n contains no items, returns init and f is not called. Note that\n certain transforms may inject or skip items.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6905), lang.NewKeyword("end-line"), int(6905))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("transduce")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v4, nil) + v10 := lang.Apply(v8, []any{v3, v4, v9, v5}) + return v10 + case 4: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + var v7 any + { // let + // let binding "f" + v8 := lang.Apply(v3, []any{v4}) + var v9 any = v8 + _ = v9 + // let binding "ret" + var v10 any + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("instance?")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{lang.IReduceInit, v6}) + if lang.IsTruthy(v14) { + v15, _ := lang.FieldOrMethod(v6, "ReduceInit") + if reflect.TypeOf(v15).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) + } + v16 := lang.Apply(v15, []any{v9, v5}) + v10 = v16 + } else { + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core.protocols")) + v18 := v17.FindInternedVar(lang.NewSymbol("coll-reduce")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.Apply(v19, []any{v6, v9, v5}) + v10 = v20 + } + var v21 any = v10 + _ = v21 + v22 := lang.Apply(v9, []any{v21}) + v7 = v22 + } // end let + return v7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // transient + { + v0 := lang.NewSymbol("transient").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a new, transient version of the collection, in constant time.\n\n Transients support a parallel set of 'changing' operations, with similar names\n followed by ! - assoc!, conj! etc. These do the same things as their persistent\n counterparts except the return values are themselves transient.\n\n Note in particular that transients are not designed to be bashed in-place. You\n must capture and use the return value in the next call. In this way, they support\n the same code structure as the functional persistent code they replace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3335), lang.NewKeyword("end-line"), int(3335))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4, ok := lang.FieldOrMethod(v3, "AsTransient") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "AsTransient"))) + } + var v5 any + switch reflect.TypeOf(v4).Kind() { + case reflect.Func: + v5 = lang.Apply(v4, nil) + default: + v5 = v4 + } + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // tree-seq + { + v0 := lang.NewSymbol("tree-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("branch?"), lang.NewSymbol("children"), lang.NewSymbol("root"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the nodes in a tree, via a depth-first walk.\n branch? must be a fn of one arg that returns true if passed a node\n that can have children (but may not). children must be a fn of one\n arg that returns a sequence of the children. Will only be called on\n nodes for which branch? returns true. Root is the root node of the\n tree.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4955), lang.NewKeyword("end-line"), int(4955))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any + { // let + // let binding "walk" + var v7 lang.FnFunc + { // function walk + v7 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v9 := args[0] + _ = v9 + var v10 lang.FnFunc + v10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("cons")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + var v14 any + v15 := lang.Apply(v3, []any{v9}) + if lang.IsTruthy(v15) { + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("mapcat")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v4, []any{v9}) + v20 := lang.Apply(v18, []any{v8, v19}) + v14 = v20 + } else { + v14 = nil + } + v21 := lang.Apply(v13, []any{v9, v14}) + return v21 + }) + v11 := lang.Apply(lang.NewLazySeq, []any{v10}) + return v11 + }) + v8 := v7 + _ = v8 + } + v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4965), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(4969), lang.NewKeyword("end-column"), int(53)) + v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v10 any = v9 + _ = v10 + v11 := lang.Apply(v10, []any{v5}) + v6 = v11 + } // end let + return v6 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // true? + { + v1 := reflect.TypeOf(false) + v0 := lang.NewSymbol("true?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is the value true, false otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(511), lang.NewKeyword("end-line"), int(511))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := lang.Apply(lang.Identical, []any{v4, true}) + return v5 + }) + v4 := reflect.TypeOf(false) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // type + { + v0 := lang.NewSymbol("type").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns the :type metadata of x, or its Class if none", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3467), lang.NewKeyword("end-line"), int(3467))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + { // let + // let binding "or__0__auto__" + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("get")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("meta")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v3}) + v12 := lang.Apply(v7, []any{v11, lang.NewKeyword("type")}) + var v13 any = v12 + _ = v13 + var v14 any + if lang.IsTruthy(v13) { + v14 = v13 + } else { + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("class")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{v3}) + v14 = v18 + } + v4 = v14 + } // end let + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-add + { + var v1 lang.FnFunc + { // function unchecked-add__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("seq")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("concat")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("list")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("list")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("list")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("seq")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("concat")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("list")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/UncheckedAdd")}) + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("list")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{v3}) + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("list")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v38, []any{v4}) + v40 := lang.Apply(v27, []any{v31, v35, v39}) + v41 := lang.Apply(v24, []any{v40}) + v42 := lang.Apply(v21, []any{v41}) + v43 := lang.Apply(v10, []any{v14, v18, v42}) + v44 := lang.Apply(v7, []any{v43}) + return v44 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("unchecked-add").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the sum of x and y, both long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1203), lang.NewKeyword("end-line"), int(1203))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedAdd") + if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedAdd is not a function"))) + } + v7 := lang.Apply(v6, []any{v4, v5}) + return v7 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-add-int + { + var v1 lang.FnFunc + { // function unchecked-add-int__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("seq")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("concat")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("list")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("list")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("list")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("seq")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("concat")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("list")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/Unchecked_int_add")}) + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("list")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{v3}) + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("list")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v38, []any{v4}) + v40 := lang.Apply(v27, []any{v31, v35, v39}) + v41 := lang.Apply(v24, []any{v40}) + v42 := lang.Apply(v21, []any{v41}) + v43 := lang.Apply(v10, []any{v14, v18, v42}) + v44 := lang.Apply(v7, []any{v43}) + return v44 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("unchecked-add-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the sum of x and y, both int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1196), lang.NewKeyword("end-line"), int(1196))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_add") + if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_add is not a function"))) + } + v7 := lang.Apply(v6, []any{v4, v5}) + return v7 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-byte + { + var v1 lang.FnFunc + { // function unchecked-byte__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("concat")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("list")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("seq")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("concat")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/UncheckedByteCast")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{v3}) + v35 := lang.Apply(v26, []any{v30, v34}) + v36 := lang.Apply(v23, []any{v35}) + v37 := lang.Apply(v20, []any{v36}) + v38 := lang.Apply(v9, []any{v13, v17, v37}) + v39 := lang.Apply(v6, []any{v38}) + return v39 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("unchecked-byte").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to byte. Subject to rounding or truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3517), lang.NewKeyword("end-line"), int(3517))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := lang.Apply(lang.UncheckedByteCast, []any{v4}) + return v5 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-char + { + var v1 lang.FnFunc + { // function unchecked-char__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("concat")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("list")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("seq")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("concat")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/UncheckedCharCast")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{v3}) + v35 := lang.Apply(v26, []any{v30, v34}) + v36 := lang.Apply(v23, []any{v35}) + v37 := lang.Apply(v20, []any{v36}) + v38 := lang.Apply(v9, []any{v13, v17, v37}) + v39 := lang.Apply(v6, []any{v38}) + return v39 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("unchecked-char").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to char. Subject to rounding or truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3529), lang.NewKeyword("end-line"), int(3529))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5, _ := lang.FieldOrMethod(runtime4.RT, "UncheckedCharCast") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedCharCast is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-dec + { + var v1 lang.FnFunc + { // function unchecked-dec__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("concat")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("list")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("seq")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("concat")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/UncheckedDec")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{v3}) + v35 := lang.Apply(v26, []any{v30, v34}) + v36 := lang.Apply(v23, []any{v35}) + v37 := lang.Apply(v20, []any{v36}) + v38 := lang.Apply(v9, []any{v13, v17, v37}) + v39 := lang.Apply(v6, []any{v38}) + return v39 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("unchecked-dec").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns a number one less than x, a long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1175), lang.NewKeyword("end-line"), int(1175))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedDec") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedDec is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-dec-int + { + var v1 lang.FnFunc + { // function unchecked-dec-int__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("concat")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("list")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("seq")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("concat")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/Unchecked_int_dec")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{v3}) + v35 := lang.Apply(v26, []any{v30, v34}) + v36 := lang.Apply(v23, []any{v35}) + v37 := lang.Apply(v20, []any{v36}) + v38 := lang.Apply(v9, []any{v13, v17, v37}) + v39 := lang.Apply(v6, []any{v38}) + return v39 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("unchecked-dec-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns a number one less than x, an int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1168), lang.NewKeyword("end-line"), int(1168))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_dec") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_dec is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-divide-int + { + var v1 lang.FnFunc + { // function unchecked-divide-int__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("seq")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("concat")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("list")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("list")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("list")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("seq")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("concat")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("list")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/UncheckedIntDivide")}) + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("list")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{v3}) + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("list")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v38, []any{v4}) + v40 := lang.Apply(v27, []any{v31, v35, v39}) + v41 := lang.Apply(v24, []any{v40}) + v42 := lang.Apply(v21, []any{v41}) + v43 := lang.Apply(v10, []any{v14, v18, v42}) + v44 := lang.Apply(v7, []any{v43}) + return v44 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("unchecked-divide-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the division of x by y, both int.\n Note - uses a primitive operator subject to truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(26), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1238), lang.NewKeyword("end-line"), int(1238))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedIntDivide") + if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedIntDivide is not a function"))) + } + v7 := lang.Apply(v6, []any{v4, v5}) + return v7 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-double + { + var v1 lang.FnFunc + { // function unchecked-double__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("concat")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("list")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("seq")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("concat")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/UncheckedDoubleCast")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{v3}) + v35 := lang.Apply(v26, []any{v30, v34}) + v36 := lang.Apply(v23, []any{v35}) + v37 := lang.Apply(v20, []any{v36}) + v38 := lang.Apply(v9, []any{v13, v17, v37}) + v39 := lang.Apply(v6, []any{v38}) + return v39 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("unchecked-double").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to double. Subject to rounding.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3553), lang.NewKeyword("end-line"), int(3553))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := lang.Apply(lang.AsFloat64, []any{v4}) + return v5 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-float + { + var v1 lang.FnFunc + { // function unchecked-float__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("concat")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("list")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("seq")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("concat")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/UncheckedFloatCast")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{v3}) + v35 := lang.Apply(v26, []any{v30, v34}) + v36 := lang.Apply(v23, []any{v35}) + v37 := lang.Apply(v20, []any{v36}) + v38 := lang.Apply(v9, []any{v13, v17, v37}) + v39 := lang.Apply(v6, []any{v38}) + return v39 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("unchecked-float").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to float. Subject to rounding.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3547), lang.NewKeyword("end-line"), int(3547))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := lang.Apply(lang.UncheckedFloatCast, []any{v4}) + return v5 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-inc + { + var v1 lang.FnFunc + { // function unchecked-inc__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("concat")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("list")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("seq")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("concat")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/Unchecked_inc")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{v3}) + v35 := lang.Apply(v26, []any{v30, v34}) + v36 := lang.Apply(v23, []any{v35}) + v37 := lang.Apply(v20, []any{v36}) + v38 := lang.Apply(v9, []any{v13, v17, v37}) + v39 := lang.Apply(v6, []any{v38}) + return v39 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("unchecked-inc").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns a number one greater than x, a long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1161), lang.NewKeyword("end-line"), int(1161))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_inc") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_inc is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-inc-int + { + var v1 lang.FnFunc + { // function unchecked-inc-int__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("concat")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("list")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("seq")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("concat")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/Unchecked_int_inc")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{v3}) + v35 := lang.Apply(v26, []any{v30, v34}) + v36 := lang.Apply(v23, []any{v35}) + v37 := lang.Apply(v20, []any{v36}) + v38 := lang.Apply(v9, []any{v13, v17, v37}) + v39 := lang.Apply(v6, []any{v38}) + return v39 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("unchecked-inc-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns a number one greater than x, an int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1154), lang.NewKeyword("end-line"), int(1154))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_inc") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_inc is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-int + { + var v1 lang.FnFunc + { // function unchecked-int__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("concat")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("list")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("seq")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("concat")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/UncheckedIntCast")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{v3}) + v35 := lang.Apply(v26, []any{v30, v34}) + v36 := lang.Apply(v23, []any{v35}) + v37 := lang.Apply(v20, []any{v36}) + v38 := lang.Apply(v9, []any{v13, v17, v37}) + v39 := lang.Apply(v6, []any{v38}) + return v39 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("unchecked-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to int. Subject to rounding or truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3535), lang.NewKeyword("end-line"), int(3535))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := lang.Apply(lang.UncheckedIntCast, []any{v4}) + return v5 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-long + { + var v1 lang.FnFunc + { // function unchecked-long__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("concat")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("list")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("seq")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("concat")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/UncheckedLongCast")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{v3}) + v35 := lang.Apply(v26, []any{v30, v34}) + v36 := lang.Apply(v23, []any{v35}) + v37 := lang.Apply(v20, []any{v36}) + v38 := lang.Apply(v9, []any{v13, v17, v37}) + v39 := lang.Apply(v6, []any{v38}) + return v39 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("unchecked-long").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to long. Subject to rounding or truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3541), lang.NewKeyword("end-line"), int(3541))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := lang.Apply(lang.UncheckedLongCast, []any{v4}) + return v5 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-multiply + { + var v1 lang.FnFunc + { // function unchecked-multiply__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("seq")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("concat")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("list")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("list")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("list")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("seq")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("concat")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("list")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/Unchecked_multiply")}) + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("list")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{v3}) + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("list")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v38, []any{v4}) + v40 := lang.Apply(v27, []any{v31, v35, v39}) + v41 := lang.Apply(v24, []any{v40}) + v42 := lang.Apply(v21, []any{v41}) + v43 := lang.Apply(v10, []any{v14, v18, v42}) + v44 := lang.Apply(v7, []any{v43}) + return v44 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("unchecked-multiply").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the product of x and y, both long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1231), lang.NewKeyword("end-line"), int(1231))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_multiply") + if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_multiply is not a function"))) + } + v7 := lang.Apply(v6, []any{v4, v5}) + return v7 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-multiply-int + { + var v1 lang.FnFunc + { // function unchecked-multiply-int__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("seq")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("concat")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("list")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("list")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("list")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("seq")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("concat")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("list")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/Unchecked_int_multiply")}) + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("list")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{v3}) + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("list")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v38, []any{v4}) + v40 := lang.Apply(v27, []any{v31, v35, v39}) + v41 := lang.Apply(v24, []any{v40}) + v42 := lang.Apply(v21, []any{v41}) + v43 := lang.Apply(v10, []any{v14, v18, v42}) + v44 := lang.Apply(v7, []any{v43}) + return v44 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("unchecked-multiply-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the product of x and y, both int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1224), lang.NewKeyword("end-line"), int(1224))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_multiply") + if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_multiply is not a function"))) + } + v7 := lang.Apply(v6, []any{v4, v5}) + return v7 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-negate + { + var v1 lang.FnFunc + { // function unchecked-negate__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("concat")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("list")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("seq")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("concat")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/Unchecked_minus")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{v3}) + v35 := lang.Apply(v26, []any{v30, v34}) + v36 := lang.Apply(v23, []any{v35}) + v37 := lang.Apply(v20, []any{v36}) + v38 := lang.Apply(v9, []any{v13, v17, v37}) + v39 := lang.Apply(v6, []any{v38}) + return v39 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("unchecked-negate").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the negation of x, a long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1189), lang.NewKeyword("end-line"), int(1189))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_negate") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_negate is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-negate-int + { + var v1 lang.FnFunc + { // function unchecked-negate-int__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("concat")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("list")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("seq")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("concat")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/Unchecked_int_negate")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{v3}) + v35 := lang.Apply(v26, []any{v30, v34}) + v36 := lang.Apply(v23, []any{v35}) + v37 := lang.Apply(v20, []any{v36}) + v38 := lang.Apply(v9, []any{v13, v17, v37}) + v39 := lang.Apply(v6, []any{v38}) + return v39 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("unchecked-negate-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the negation of x, an int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(26), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1182), lang.NewKeyword("end-line"), int(1182))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_negate") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_negate is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-remainder-int + { + var v1 lang.FnFunc + { // function unchecked-remainder-int__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("seq")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("concat")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("list")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("list")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("list")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("seq")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("concat")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("list")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/Unchecked_int_remainder")}) + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("list")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{v3}) + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("list")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v38, []any{v4}) + v40 := lang.Apply(v27, []any{v31, v35, v39}) + v41 := lang.Apply(v24, []any{v40}) + v42 := lang.Apply(v21, []any{v41}) + v43 := lang.Apply(v10, []any{v14, v18, v42}) + v44 := lang.Apply(v7, []any{v43}) + return v44 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("unchecked-remainder-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the remainder of division of x by y, both int.\n Note - uses a primitive operator subject to truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(29), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1245), lang.NewKeyword("end-line"), int(1245))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_remainder") + if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_remainder is not a function"))) + } + v7 := lang.Apply(v6, []any{v4, v5}) + return v7 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-short + { + var v1 lang.FnFunc + { // function unchecked-short__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("concat")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("list")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("seq")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("concat")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/UncheckedShortCast")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{v3}) + v35 := lang.Apply(v26, []any{v30, v34}) + v36 := lang.Apply(v23, []any{v35}) + v37 := lang.Apply(v20, []any{v36}) + v38 := lang.Apply(v9, []any{v13, v17, v37}) + v39 := lang.Apply(v6, []any{v38}) + return v39 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("unchecked-short").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to short. Subject to rounding or truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3523), lang.NewKeyword("end-line"), int(3523))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := lang.Apply(lang.UncheckedShortCast, []any{v4}) + return v5 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-subtract + { + var v1 lang.FnFunc + { // function unchecked-subtract__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("seq")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("concat")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("list")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("list")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("list")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("seq")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("concat")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("list")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/Unchecked_minus")}) + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("list")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{v3}) + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("list")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v38, []any{v4}) + v40 := lang.Apply(v27, []any{v31, v35, v39}) + v41 := lang.Apply(v24, []any{v40}) + v42 := lang.Apply(v21, []any{v41}) + v43 := lang.Apply(v10, []any{v14, v18, v42}) + v44 := lang.Apply(v7, []any{v43}) + return v44 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("unchecked-subtract").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the difference of x and y, both long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1217), lang.NewKeyword("end-line"), int(1217))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_minus") + if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_minus is not a function"))) + } + v7 := lang.Apply(v6, []any{v4, v5}) + return v7 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-subtract-int + { + var v1 lang.FnFunc + { // function unchecked-subtract-int__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("seq")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("concat")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("list")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("list")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("list")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("seq")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("concat")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("list")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/Unchecked_int_subtract")}) + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("list")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{v3}) + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("list")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v38, []any{v4}) + v40 := lang.Apply(v27, []any{v31, v35, v39}) + v41 := lang.Apply(v24, []any{v40}) + v42 := lang.Apply(v21, []any{v41}) + v43 := lang.Apply(v10, []any{v14, v18, v42}) + v44 := lang.Apply(v7, []any{v43}) + return v44 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("unchecked-subtract-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the difference of x and y, both int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1210), lang.NewKeyword("end-line"), int(1210))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_subtract") + if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_subtract is not a function"))) + } + v7 := lang.Apply(v6, []any{v4, v5}) + return v7 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // underive + { + v0 := lang.NewSymbol("underive").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag"), lang.NewSymbol("parent")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"), lang.NewSymbol("parent"))), lang.NewKeyword("doc"), "Removes a parent/child relationship between parent and\n tag. h must be a hierarchy obtained from make-hierarchy, if not\n supplied defaults to, and modifies, the global hierarchy.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5643), lang.NewKeyword("end-line"), int(5643))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("alter-var-root")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("global-hierarchy")) + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("underive")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.Apply(v7, []any{v8, v11, v3, v4}) + _ = v12 + return nil + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any + { // let + // let binding "parentMap" + v7 := lang.Apply(lang.NewKeyword("parents"), []any{v3}) + var v8 any = v7 + _ = v8 + // let binding "childsParents" + var v9 any + v10 := lang.Apply(v8, []any{v4}) + if lang.IsTruthy(v10) { + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("disj")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v8, []any{v4}) + v15 := lang.Apply(v13, []any{v14, v5}) + v9 = v15 + } else { + v16 := lang.CreatePersistentTreeSet() + v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5652), lang.NewKeyword("column"), int(36), lang.NewKeyword("end-line"), int(5652), lang.NewKeyword("end-column"), int(38)) + v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v9 = v18 + } + var v19 any = v9 + _ = v19 + // let binding "newParents" + var v20 any + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("not-empty")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.Apply(v23, []any{v19}) + if lang.IsTruthy(v24) { + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("assoc")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.Apply(v27, []any{v8, v4, v19}) + v20 = v28 + } else { + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("dissoc")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.Apply(v31, []any{v8, v4}) + v20 = v32 + } + var v33 any = v20 + _ = v33 + // let binding "deriv-seq" + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("flatten")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("map")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + var v40 lang.FnFunc + v40 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v41 := args[0] + _ = v41 + v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v43 := v42.FindInternedVar(lang.NewSymbol("cons")) + if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) + } + v44 := v43.Get() + v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v46 := v45.FindInternedVar(lang.NewSymbol("key")) + if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) + } + v47 := v46.Get() + v48 := lang.Apply(v47, []any{v41}) + v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v50 := v49.FindInternedVar(lang.NewSymbol("interpose")) + if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) + } + v51 := v50.Get() + v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v53 := v52.FindInternedVar(lang.NewSymbol("key")) + if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) + } + v54 := v53.Get() + v55 := lang.Apply(v54, []any{v41}) + v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v57 := v56.FindInternedVar(lang.NewSymbol("val")) + if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) + } + v58 := v57.Get() + v59 := lang.Apply(v58, []any{v41}) + v60 := lang.Apply(v51, []any{v55, v59}) + v61 := lang.Apply(v44, []any{v48, v60}) + return v61 + }) + v41 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5656), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(5656), lang.NewKeyword("end-column"), int(70)) + v42, err := lang.WithMeta(v40, v41.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v44 := v43.FindInternedVar(lang.NewSymbol("seq")) + if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) + } + v45 := v44.Get() + v46 := lang.Apply(v45, []any{v33}) + v47 := lang.Apply(v39, []any{v42, v46}) + v48 := lang.Apply(v36, []any{v47}) + var v49 any = v48 + _ = v49 + var v50 any + v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v52 := v51.FindInternedVar(lang.NewSymbol("contains?")) + if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) + } + v53 := v52.Get() + v54 := lang.Apply(v8, []any{v4}) + v55 := lang.Apply(v53, []any{v54, v5}) + if lang.IsTruthy(v55) { + v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v57 := v56.FindInternedVar(lang.NewSymbol("reduce1")) + if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) + } + v58 := v57.Get() + var v59 lang.FnFunc + v59 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v60 := args[0] + _ = v60 + v61 := args[1] + _ = v61 + v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v63 := v62.FindInternedVar(lang.NewSymbol("apply")) + if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) + } + v64 := v63.Get() + v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v66 := v65.FindInternedVar(lang.NewSymbol("derive")) + if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) + } + v67 := v66.Get() + v68 := lang.Apply(v64, []any{v67, v60, v61}) + return v68 + }) + v60 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5659), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5659), lang.NewKeyword("end-column"), int(31)) + v61, err := lang.WithMeta(v59, v60.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v63 := v62.FindInternedVar(lang.NewSymbol("make-hierarchy")) + if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) + } + v64 := v63.Get() + v65 := lang.Apply(v64, nil) + v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v67 := v66.FindInternedVar(lang.NewSymbol("partition")) + if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) + } + v68 := v67.Get() + v69 := lang.Apply(v68, []any{int64(2), v49}) + v70 := lang.Apply(v58, []any{v61, v65, v69}) + v50 = v70 + } else { + v50 = v3 + } + v6 = v50 + } // end let + return v6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // unquote + { + v0 := lang.NewSymbol("unquote").WithMeta(lang.NewMap()).(*lang.Symbol) + v1 := ns.Intern(v0) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // unquote-splicing + { + v0 := lang.NewSymbol("unquote-splicing").WithMeta(lang.NewMap()).(*lang.Symbol) + v1 := ns.Intern(v0) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // unreduced + { + v0 := lang.NewSymbol("unreduced").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "If x is reduced?, returns (deref x), else returns x", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2847), lang.NewKeyword("end-line"), int(2847))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("reduced?")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v3}) + if lang.IsTruthy(v8) { + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("deref")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.Apply(v11, []any{v3}) + v4 = v12 + } else { + v4 = v3 + } + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // unsigned-bit-shift-right + { + var v1 lang.FnFunc + { // function unsigned-bit-shift-right__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("seq")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("concat")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("list")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("list")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("list")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("seq")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("concat")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("list")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/UnsignedShiftRight")}) + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("list")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{v3}) + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("list")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.Apply(v38, []any{v4}) + v40 := lang.Apply(v27, []any{v31, v35, v39}) + v41 := lang.Apply(v24, []any{v40}) + v42 := lang.Apply(v21, []any{v41}) + v43 := lang.Apply(v10, []any{v14, v18, v42}) + v44 := lang.Apply(v7, []any{v43}) + return v44 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("unsigned-bit-shift-right").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Bitwise shift right, without sign-extension.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(30), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1373), lang.NewKeyword("end-line"), int(1373))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6, _ := lang.FieldOrMethod(lang.Numbers, "UnsignedShiftRight") + if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("UnsignedShiftRight is not a function"))) + } + v7 := lang.Apply(v6, []any{v4, v5}) + return v7 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // update + { + v0 := lang.NewSymbol("update").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f"), lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("z")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("z"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "'Updates' a value in an associative structure, where k is a\n key and f is a function that will take the old value\n and any supplied args and return the new value, and returns a new\n structure. If the key does not exist, nil is passed as the old value.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6174), lang.NewKeyword("end-line"), int(6174))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("assoc")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("get")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.Apply(v11, []any{v3, v4}) + v13 := lang.Apply(v5, []any{v12}) + v14 := lang.Apply(v8, []any{v3, v4, v13}) + return v14 + case 4: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("assoc")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("get")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{v3, v4}) + v14 := lang.Apply(v5, []any{v13, v6}) + v15 := lang.Apply(v9, []any{v3, v4, v14}) + return v15 + case 5: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := args[4] + _ = v7 + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("assoc")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("get")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{v3, v4}) + v15 := lang.Apply(v5, []any{v14, v6, v7}) + v16 := lang.Apply(v10, []any{v3, v4, v15}) + return v16 + case 6: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := args[4] + _ = v7 + v8 := args[5] + _ = v8 + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("assoc")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("get")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.Apply(v14, []any{v3, v4}) + v16 := lang.Apply(v5, []any{v15, v6, v7, v8}) + v17 := lang.Apply(v11, []any{v3, v4, v16}) + return v17 + default: + if len(args) < 6 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := args[4] + _ = v7 + v8 := args[5] + _ = v8 + v9 := lang.NewList(args[6:]...) + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("assoc")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("apply")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("get")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{v3, v4}) + v20 := lang.Apply(v15, []any{v5, v19, v6, v7, v8, v9}) + v21 := lang.Apply(v12, []any{v3, v4, v20}) + return v21 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // update-in + { + v0 := lang.NewSymbol("update-in").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("ks"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "'Updates' a value in a nested associative structure, where ks is a\n sequence of keys and f is a function that will take the old value\n and any supplied args and return the new value, and returns a new\n nested structure. If any levels do not exist, hash-maps will be\n created.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6158), lang.NewKeyword("end-line"), int(6158))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + var v7 any + { // let + // let binding "up" + var v8 lang.FnFunc + { // function up + v8 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + v12 := args[2] + _ = v12 + v13 := args[3] + _ = v13 + var v14 any + { // let + // let binding "vec__141" + var v15 any = v11 + _ = v15 + // let binding "seq__142" + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("seq")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v18, []any{v15}) + var v20 any = v19 + _ = v20 + // let binding "first__143" + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("first")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.Apply(v23, []any{v20}) + var v25 any = v24 + _ = v25 + // let binding "seq__142" + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("next")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.Apply(v28, []any{v20}) + var v30 any = v29 + _ = v30 + // let binding "k" + var v31 any = v25 + _ = v31 + // let binding "ks" + var v32 any = v30 + _ = v32 + var v33 any + if lang.IsTruthy(v32) { + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("assoc")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("get")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.Apply(v39, []any{v10, v31}) + v41 := lang.Apply(v9, []any{v40, v32, v12, v13}) + v42 := lang.Apply(v36, []any{v10, v31, v41}) + v33 = v42 + } else { + v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v44 := v43.FindInternedVar(lang.NewSymbol("assoc")) + if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) + } + v45 := v44.Get() + v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v47 := v46.FindInternedVar(lang.NewSymbol("apply")) + if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) + } + v48 := v47.Get() + v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v50 := v49.FindInternedVar(lang.NewSymbol("get")) + if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) + } + v51 := v50.Get() + v52 := lang.Apply(v51, []any{v10, v31}) + v53 := lang.Apply(v48, []any{v12, v52, v13}) + v54 := lang.Apply(v45, []any{v10, v31, v53}) + v33 = v54 + } + v14 = v33 + } // end let + return v14 + }) + v9 := v8 + _ = v9 + } + v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6167), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(6171), lang.NewKeyword("end-column"), int(59)) + v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v11 any = v10 + _ = v11 + v12 := lang.Apply(v11, []any{v3, v4, v5, v6}) + v7 = v12 + } // end let + return v7 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // update-keys + { + v0 := lang.NewSymbol("update-keys").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("f"))), lang.NewKeyword("doc"), "m f => {(f k) v ...}\n\n Given a map m and a function f of 1-argument, returns a new map whose\n keys are the result of applying f to the keys of m, mapped to the\n corresponding values of m.\n f must return a unique key for each key of m, else the behavior is undefined.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7906), lang.NewKeyword("end-line"), int(7906))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any + { // let + // let binding "ret" + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("persistent!")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("reduce-kv")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + var v12 lang.FnFunc + v12 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v13 := args[0] + _ = v13 + v14 := args[1] + _ = v14 + v15 := args[2] + _ = v15 + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("assoc!")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.Apply(v4, []any{v14}) + v20 := lang.Apply(v18, []any{v13, v19, v15}) + return v20 + }) + v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7916), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7916), lang.NewKeyword("end-column"), int(59)) + v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("transient")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.NewMap() + v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7917), lang.NewKeyword("column"), int(36), lang.NewKeyword("end-line"), int(7917), lang.NewKeyword("end-column"), int(37)) + v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v21 := lang.Apply(v17, []any{v20}) + v22 := lang.Apply(v11, []any{v14, v21, v3}) + v23 := lang.Apply(v8, []any{v22}) + var v24 any = v23 + _ = v24 + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("with-meta")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("meta")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.Apply(v30, []any{v3}) + v32 := lang.Apply(v27, []any{v24, v31}) + v5 = v32 + } // end let + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // update-vals + { + v0 := lang.NewSymbol("update-vals").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("f"))), lang.NewKeyword("doc"), "m f => {k (f v) ...}\n\n Given a map m and a function f of 1-argument, returns a new map where the keys of m\n are mapped to result of applying f to the corresponding values of m.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7890), lang.NewKeyword("end-line"), int(7890))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("with-meta")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("persistent!")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("reduce-kv")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + var v14 lang.FnFunc + v14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v15 := args[0] + _ = v15 + v16 := args[1] + _ = v16 + v17 := args[2] + _ = v17 + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("assoc!")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.Apply(v4, []any{v17}) + v22 := lang.Apply(v20, []any{v15, v16, v21}) + return v22 + }) + v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7899), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(7899), lang.NewKeyword("end-column"), int(51)) + v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v17 any + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("instance?")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.Apply(v20, []any{lang.IEditableCollection, v3}) + if lang.IsTruthy(v21) { + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("transient")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v3}) + v17 = v25 + } else { + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("transient")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.NewMap() + v30 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7902), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(7902), lang.NewKeyword("end-column"), int(31)) + v31, err := lang.WithMeta(v29, v30.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v32 := lang.Apply(v28, []any{v31}) + v17 = v32 + } + v33 := lang.Apply(v13, []any{v16, v17, v3}) + v34 := lang.Apply(v10, []any{v33}) + v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v36 := v35.FindInternedVar(lang.NewSymbol("meta")) + if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + } + v37 := v36.Get() + v38 := lang.Apply(v37, []any{v3}) + v39 := lang.Apply(v7, []any{v34, v38}) + return v39 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // uri? + { + v0 := lang.NewSymbol("uri?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a java.net.URI", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7877), lang.NewKeyword("end-line"), int(7877))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.Apply(v6, []any{url14.URL, v3}) + return v7 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // use + { + v0 := lang.NewSymbol("use").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Like 'require, but also refers to each lib's namespace using\n glojure.core/refer. Use :use in the ns macro in preference to calling\n this directly.\n\n 'use accepts additional options in libspecs: :exclude, :only, :rename.\n The arguments and semantics for :exclude, :only, and :rename are the same\n as those documented for glojure.core/refer.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6079), lang.NewKeyword("end-line"), int(6079))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := lang.NewList(args[0:]...) + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("apply")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("load-libs")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.Apply(v6, []any{v9, lang.NewKeyword("require"), lang.NewKeyword("use"), v3}) + return v10 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // uuid? + { + v0 := lang.NewSymbol("uuid?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a java.util.UUID", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6847), lang.NewKeyword("end-line"), int(6847))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.Apply(v6, []any{uuid10.UUID, v3}) + return v7 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // val + { + v0 := lang.NewSymbol("val").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("e"))), lang.NewKeyword("doc"), "Returns the value in the map entry.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1570), lang.NewKeyword("end-line"), int(1570))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4, _ := lang.FieldOrMethod(v3, "GetValue") + if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("GetValue is not a function"))) + } + v5 := lang.Apply(v4, []any{}) + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // vals + { + v0 := lang.NewSymbol("vals").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"))), lang.NewKeyword("doc"), "Returns a sequence of the map's values, in the same order as (seq map).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1557), lang.NewKeyword("end-line"), int(1557))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.Apply(lang.Vals, []any{v3}) + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // var-get + { + v0 := lang.NewSymbol("var-get").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Gets the value in the var object", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4326), lang.NewKeyword("end-line"), int(4326))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4, _ := lang.FieldOrMethod(v3, "Get") + if reflect.TypeOf(v4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Get is not a function"))) + } + v5 := lang.Apply(v4, []any{}) + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // var-set + { + v0 := lang.NewSymbol("var-set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Sets the value in the var object to val. The var must be\n thread-locally bound.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4332), lang.NewKeyword("end-line"), int(4332))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5, _ := lang.FieldOrMethod(v3, "Set") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Set is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // var? + { + v0 := lang.NewSymbol("var?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("v"))), lang.NewKeyword("doc"), "Returns true if v is of type glojure.lang.Var", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4999), lang.NewKeyword("end-line"), int(4999))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.Apply(v6, []any{*lang.Var, v3}) + return v7 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // vary-meta + { + v0 := lang.NewSymbol("vary-meta").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("obj"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Returns an object of the same type and value as obj, with\n (apply f (meta obj) args) as its metadata.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(668), lang.NewKeyword("end-line"), int(668))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.NewList(args[2:]...) + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("with-meta")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("apply")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("meta")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.Apply(v14, []any{v3}) + v16 := lang.Apply(v11, []any{v4, v15, v5}) + v17 := lang.Apply(v8, []any{v3, v16}) + return v17 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // vec + { + v0 := lang.NewSymbol("vec").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Creates a new vector containing the contents of coll. Java arrays\n will be aliased and should not be modified.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(366), lang.NewKeyword("end-line"), int(366))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("vector?")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{v3}) + if lang.IsTruthy(v8) { + var v9 any + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("instance?")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.IObj, v3}) + if lang.IsTruthy(v13) { + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("with-meta")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{v3, nil}) + v9 = v17 + } else { + v18 := lang.Apply(lang.CreateLazilyPersistentVector, []any{v3}) + v9 = v18 + } + v4 = v9 + } else { + v19 := lang.Apply(lang.CreateLazilyPersistentVector, []any{v3}) + v4 = v19 + } + return v4 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // vector + { + v0 := lang.NewSymbol("vector").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("a")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d"), lang.NewSymbol("e")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d"), lang.NewSymbol("e"), lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d"), lang.NewSymbol("e"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Creates a new vector containing the args.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(352), lang.NewKeyword("end-line"), int(352))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + v3 := lang.NewVector() + v4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(356), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(356), lang.NewKeyword("end-column"), int(8)) + v5, err := lang.WithMeta(v3, v4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v5 + case 1: + v3 := args[0] + _ = v3 + v4 := lang.NewVector(v3) + v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(357), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(357), lang.NewKeyword("end-column"), int(10)) + v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v6 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.NewVector(v3, v4) + v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(358), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(358), lang.NewKeyword("end-column"), int(14)) + v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v7 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewVector(v3, v4, v5) + v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(359), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(359), lang.NewKeyword("end-column"), int(18)) + v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v8 + case 4: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := lang.NewVector(v3, v4, v5, v6) + v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(360), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(360), lang.NewKeyword("end-column"), int(22)) + v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v9 + case 5: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := args[4] + _ = v7 + v8 := lang.NewVector(v3, v4, v5, v6, v7) + v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(361), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(361), lang.NewKeyword("end-column"), int(25)) + v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v10 + case 6: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := args[4] + _ = v7 + v8 := args[5] + _ = v8 + v9 := lang.NewVector(v3, v4, v5, v6, v7, v8) + v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(362), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(362), lang.NewKeyword("end-column"), int(29)) + v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return v11 + default: + if len(args) < 6 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := args[4] + _ = v7 + v8 := args[5] + _ = v8 + v9 := lang.NewList(args[6:]...) + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("cons")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("cons")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("cons")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("cons")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("cons")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("cons")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.Apply(v27, []any{v8, v9}) + v29 := lang.Apply(v24, []any{v7, v28}) + v30 := lang.Apply(v21, []any{v6, v29}) + v31 := lang.Apply(v18, []any{v5, v30}) + v32 := lang.Apply(v15, []any{v4, v31}) + v33 := lang.Apply(v12, []any{v3, v32}) + v34 := lang.Apply(lang.CreateLazilyPersistentVector, []any{v33}) + return v34 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // vector? + { + v0 := lang.NewSymbol("vector?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x implements IPersistentVector", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(174), lang.NewKeyword("end-line"), int(178))).(*lang.Symbol) + var v2 lang.FnFunc + { // function vector? + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) + if v6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + } + v7 := v6.Get() + v8 := lang.Apply(v7, []any{lang.IPersistentVector, v4}) + return v8 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(178), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(178), lang.NewKeyword("end-column"), int(106))).(lang.FnFunc) + v3 := v2 + _ = v3 + } + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // volatile! + { + v1 := reflect.TypeOf((*lang.Volatile)(nil)).Elem() + v0 := lang.NewSymbol("volatile!").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Creates and returns a Volatile with an initial value of val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2517), lang.NewKeyword("end-line"), int(2517))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := lang.Apply(lang.NewVolatile, []any{v4}) + return v5 + }) + v4 := reflect.TypeOf((*lang.Volatile)(nil)).Elem() + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // volatile? + { + v0 := lang.NewSymbol("volatile?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is a volatile.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2540), lang.NewKeyword("end-line"), int(2540))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.Apply(v6, []any{lang.Volatile, v3}) + return v7 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // vreset! + { + v0 := lang.NewSymbol("vreset!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("vol"), lang.NewSymbol("newval"))), lang.NewKeyword("doc"), "Sets the value of volatile to newval without regard for the\n current value. Returns newval.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2524), lang.NewKeyword("end-line"), int(2524))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5, _ := lang.FieldOrMethod(v3, "reset") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // vswap! + { + v0 := lang.NewSymbol("vswap!").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("vol"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Non-atomically swaps the value of the volatile as if:\n (apply f current-value-of-vol args). Returns the value that\n was swapped in.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(2531), lang.NewKeyword("end-line"), int(2531))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := lang.NewList(args[4:]...) + var v8 any + { // let + // let binding "v" + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("with-meta")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.NewMap(lang.NewKeyword("tag"), lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Volatile")) + v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2537), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(2537), lang.NewKeyword("end-column"), int(81)) + v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v15 := lang.Apply(v11, []any{v5, v14}) + var v16 any = v15 + _ = v16 + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("seq")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("concat")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("list")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.Apply(v25, []any{lang.NewSymbol(".reset")}) + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{v16}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("seq")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("concat")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("list")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.Apply(v42, []any{v6}) + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("list")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v48 := v47.FindInternedVar(lang.NewSymbol("seq")) + if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) + } + v49 := v48.Get() + v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v51 := v50.FindInternedVar(lang.NewSymbol("concat")) + if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) + } + v52 := v51.Get() + v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v54 := v53.FindInternedVar(lang.NewSymbol("list")) + if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) + } + v55 := v54.Get() + v56 := lang.Apply(v55, []any{lang.NewSymbol(".Deref")}) + v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v58 := v57.FindInternedVar(lang.NewSymbol("list")) + if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) + } + v59 := v58.Get() + v60 := lang.Apply(v59, []any{v16}) + v61 := lang.Apply(v52, []any{v56, v60}) + v62 := lang.Apply(v49, []any{v61}) + v63 := lang.Apply(v46, []any{v62}) + v64 := lang.Apply(v39, []any{v43, v63, v7}) + v65 := lang.Apply(v36, []any{v64}) + v66 := lang.Apply(v33, []any{v65}) + v67 := lang.Apply(v22, []any{v26, v30, v66}) + v68 := lang.Apply(v19, []any{v67}) + v8 = v68 + } // end let + return v8 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // when + { + v0 := lang.NewSymbol("when").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("test"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Evaluates test. If logical true, evaluates body in an implicit do.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(492), lang.NewKeyword("end-line"), int(492))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("list")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("cons")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol("do"), v6}) + v14 := lang.Apply(v9, []any{lang.NewSymbol("if"), v5, v13}) + return v14 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // when-first + { + v0 := lang.NewSymbol("when-first").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "bindings => x xs\n\n Roughly the same as (when (seq xs) (let [x (first xs)] body)) but xs is evaluated only once", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4622), lang.NewKeyword("end-line"), int(4622))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + var v7 any + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v5}) + if lang.IsTruthy(v11) { + v7 = nil + } else { + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("str")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("first")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{v3}) + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("meta")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v3}) + v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) + v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) + v28 := lang.Apply(lang.NewIllegalArgumentError, []any{v27}) + panic(v28) + } + _ = v7 + var v29 any + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("=")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("count")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.Apply(v35, []any{v5}) + v37 := lang.Apply(v32, []any{int64(2), v36}) + if lang.IsTruthy(v37) { + v29 = nil + } else { + v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v39 := v38.FindInternedVar(lang.NewSymbol("str")) + if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + } + v40 := v39.Get() + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("first")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.Apply(v43, []any{v3}) + v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) + if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) + } + v47 := v46.Get() + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("meta")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v3}) + v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) + v53 := lang.Apply(v40, []any{v44, " requires ", "exactly 2 forms in binding vector", " in ", v47, ":", v52}) + v54 := lang.Apply(lang.NewIllegalArgumentError, []any{v53}) + panic(v54) + } + _ = v29 + _ = nil + var v55 any + { // let + // let binding "vec__20" + var v56 any = v5 + _ = v56 + // let binding "x" + v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v58 := v57.FindInternedVar(lang.NewSymbol("nth")) + if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) + } + v59 := v58.Get() + v60 := lang.Apply(v59, []any{v56, int64(0), nil}) + var v61 any = v60 + _ = v61 + // let binding "xs" + v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v63 := v62.FindInternedVar(lang.NewSymbol("nth")) + if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) + } + v64 := v63.Get() + v65 := lang.Apply(v64, []any{v56, int64(1), nil}) + var v66 any = v65 + _ = v66 + v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v68 := v67.FindInternedVar(lang.NewSymbol("seq")) + if v68.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) + } + v69 := v68.Get() + v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v71 := v70.FindInternedVar(lang.NewSymbol("concat")) + if v71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) + } + v72 := v71.Get() + v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v74 := v73.FindInternedVar(lang.NewSymbol("list")) + if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) + } + v75 := v74.Get() + v76 := lang.Apply(v75, []any{lang.NewSymbol("glojure.core/when-let")}) + v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v78 := v77.FindInternedVar(lang.NewSymbol("list")) + if v78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) + } + v79 := v78.Get() + v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v81 := v80.FindInternedVar(lang.NewSymbol("apply")) + if v81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) + } + v82 := v81.Get() + v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v84 := v83.FindInternedVar(lang.NewSymbol("vector")) + if v84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) + } + v85 := v84.Get() + v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v87 := v86.FindInternedVar(lang.NewSymbol("seq")) + if v87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) + } + v88 := v87.Get() + v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v90 := v89.FindInternedVar(lang.NewSymbol("concat")) + if v90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) + } + v91 := v90.Get() + v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v93 := v92.FindInternedVar(lang.NewSymbol("list")) + if v93.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) + } + v94 := v93.Get() + v95 := lang.Apply(v94, []any{lang.NewSymbol("xs__0__auto__")}) + v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v97 := v96.FindInternedVar(lang.NewSymbol("list")) + if v97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) + } + v98 := v97.Get() + v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v100 := v99.FindInternedVar(lang.NewSymbol("seq")) + if v100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) + } + v101 := v100.Get() + v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v103 := v102.FindInternedVar(lang.NewSymbol("concat")) + if v103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) + } + v104 := v103.Get() + v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v106 := v105.FindInternedVar(lang.NewSymbol("list")) + if v106.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) + } + v107 := v106.Get() + v108 := lang.Apply(v107, []any{lang.NewSymbol("glojure.core/seq")}) + v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v110 := v109.FindInternedVar(lang.NewSymbol("list")) + if v110.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) + } + v111 := v110.Get() + v112 := lang.Apply(v111, []any{v66}) + v113 := lang.Apply(v104, []any{v108, v112}) + v114 := lang.Apply(v101, []any{v113}) + v115 := lang.Apply(v98, []any{v114}) + v116 := lang.Apply(v91, []any{v95, v115}) + v117 := lang.Apply(v88, []any{v116}) + v118 := lang.Apply(v82, []any{v85, v117}) + v119 := lang.Apply(v79, []any{v118}) + v120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v121 := v120.FindInternedVar(lang.NewSymbol("list")) + if v121.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v121))) + } + v122 := v121.Get() + v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v124 := v123.FindInternedVar(lang.NewSymbol("seq")) + if v124.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) + } + v125 := v124.Get() + v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v127 := v126.FindInternedVar(lang.NewSymbol("concat")) + if v127.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) + } + v128 := v127.Get() + v129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v130 := v129.FindInternedVar(lang.NewSymbol("list")) + if v130.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v130))) + } + v131 := v130.Get() + v132 := lang.Apply(v131, []any{lang.NewSymbol("glojure.core/let")}) + v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v134 := v133.FindInternedVar(lang.NewSymbol("list")) + if v134.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) + } + v135 := v134.Get() + v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v137 := v136.FindInternedVar(lang.NewSymbol("apply")) + if v137.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) + } + v138 := v137.Get() + v139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v140 := v139.FindInternedVar(lang.NewSymbol("vector")) + if v140.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v140))) + } + v141 := v140.Get() + v142 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v143 := v142.FindInternedVar(lang.NewSymbol("seq")) + if v143.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v143))) + } + v144 := v143.Get() + v145 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v146 := v145.FindInternedVar(lang.NewSymbol("concat")) + if v146.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v146))) + } + v147 := v146.Get() + v148 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v149 := v148.FindInternedVar(lang.NewSymbol("list")) + if v149.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v149))) + } + v150 := v149.Get() + v151 := lang.Apply(v150, []any{v61}) + v152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v153 := v152.FindInternedVar(lang.NewSymbol("list")) + if v153.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v153))) + } + v154 := v153.Get() + v155 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v156 := v155.FindInternedVar(lang.NewSymbol("seq")) + if v156.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v156))) + } + v157 := v156.Get() + v158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v159 := v158.FindInternedVar(lang.NewSymbol("concat")) + if v159.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v159))) + } + v160 := v159.Get() + v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v162 := v161.FindInternedVar(lang.NewSymbol("list")) + if v162.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) + } + v163 := v162.Get() + v164 := lang.Apply(v163, []any{lang.NewSymbol("glojure.core/first")}) + v165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v166 := v165.FindInternedVar(lang.NewSymbol("list")) + if v166.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v166))) + } + v167 := v166.Get() + v168 := lang.Apply(v167, []any{lang.NewSymbol("xs__0__auto__")}) + v169 := lang.Apply(v160, []any{v164, v168}) + v170 := lang.Apply(v157, []any{v169}) + v171 := lang.Apply(v154, []any{v170}) + v172 := lang.Apply(v147, []any{v151, v171}) + v173 := lang.Apply(v144, []any{v172}) + v174 := lang.Apply(v138, []any{v141, v173}) + v175 := lang.Apply(v135, []any{v174}) + v176 := lang.Apply(v128, []any{v132, v175, v6}) + v177 := lang.Apply(v125, []any{v176}) + v178 := lang.Apply(v122, []any{v177}) + v179 := lang.Apply(v72, []any{v76, v119, v178}) + v180 := lang.Apply(v69, []any{v179}) + v55 = v180 + } // end let + return v55 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // when-let + { + v0 := lang.NewSymbol("when-let").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "bindings => binding-form test\n\n When test is true, evaluates body with binding-form bound to the value of test", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1859), lang.NewKeyword("end-line"), int(1859))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + var v7 any + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v5}) + if lang.IsTruthy(v11) { + v7 = nil + } else { + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("str")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("first")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{v3}) + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("meta")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v3}) + v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) + v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) + v28 := lang.Apply(lang.NewIllegalArgumentError, []any{v27}) + panic(v28) + } + _ = v7 + var v29 any + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("=")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("count")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.Apply(v35, []any{v5}) + v37 := lang.Apply(v32, []any{int64(2), v36}) + if lang.IsTruthy(v37) { + v29 = nil + } else { + v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v39 := v38.FindInternedVar(lang.NewSymbol("str")) + if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + } + v40 := v39.Get() + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("first")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.Apply(v43, []any{v3}) + v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) + if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) + } + v47 := v46.Get() + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("meta")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v3}) + v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) + v53 := lang.Apply(v40, []any{v44, " requires ", "exactly 2 forms in binding vector", " in ", v47, ":", v52}) + v54 := lang.Apply(lang.NewIllegalArgumentError, []any{v53}) + panic(v54) + } + _ = v29 + _ = nil + var v55 any + { // let + // let binding "form" + v56 := lang.Apply(v5, []any{int64(0)}) + var v57 any = v56 + _ = v57 + // let binding "tst" + v58 := lang.Apply(v5, []any{int64(1)}) + var v59 any = v58 + _ = v59 + v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v61 := v60.FindInternedVar(lang.NewSymbol("seq")) + if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) + } + v62 := v61.Get() + v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v64 := v63.FindInternedVar(lang.NewSymbol("concat")) + if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) + } + v65 := v64.Get() + v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v67 := v66.FindInternedVar(lang.NewSymbol("list")) + if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) + } + v68 := v67.Get() + v69 := lang.Apply(v68, []any{lang.NewSymbol("glojure.core/let")}) + v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v71 := v70.FindInternedVar(lang.NewSymbol("list")) + if v71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) + } + v72 := v71.Get() + v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v74 := v73.FindInternedVar(lang.NewSymbol("apply")) + if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) + } + v75 := v74.Get() + v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v77 := v76.FindInternedVar(lang.NewSymbol("vector")) + if v77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) + } + v78 := v77.Get() + v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v80 := v79.FindInternedVar(lang.NewSymbol("seq")) + if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) + } + v81 := v80.Get() + v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v83 := v82.FindInternedVar(lang.NewSymbol("concat")) + if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) + } + v84 := v83.Get() + v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v86 := v85.FindInternedVar(lang.NewSymbol("list")) + if v86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) + } + v87 := v86.Get() + v88 := lang.Apply(v87, []any{lang.NewSymbol("temp__0__auto__")}) + v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v90 := v89.FindInternedVar(lang.NewSymbol("list")) + if v90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) + } + v91 := v90.Get() + v92 := lang.Apply(v91, []any{v59}) + v93 := lang.Apply(v84, []any{v88, v92}) + v94 := lang.Apply(v81, []any{v93}) + v95 := lang.Apply(v75, []any{v78, v94}) + v96 := lang.Apply(v72, []any{v95}) + v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v98 := v97.FindInternedVar(lang.NewSymbol("list")) + if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) + } + v99 := v98.Get() + v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v101 := v100.FindInternedVar(lang.NewSymbol("seq")) + if v101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) + } + v102 := v101.Get() + v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v104 := v103.FindInternedVar(lang.NewSymbol("concat")) + if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) + } + v105 := v104.Get() + v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v107 := v106.FindInternedVar(lang.NewSymbol("list")) + if v107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) + } + v108 := v107.Get() + v109 := lang.Apply(v108, []any{lang.NewSymbol("glojure.core/when")}) + v110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v111 := v110.FindInternedVar(lang.NewSymbol("list")) + if v111.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v111))) + } + v112 := v111.Get() + v113 := lang.Apply(v112, []any{lang.NewSymbol("temp__0__auto__")}) + v114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v115 := v114.FindInternedVar(lang.NewSymbol("list")) + if v115.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v115))) + } + v116 := v115.Get() + v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v118 := v117.FindInternedVar(lang.NewSymbol("seq")) + if v118.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) + } + v119 := v118.Get() + v120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v121 := v120.FindInternedVar(lang.NewSymbol("concat")) + if v121.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v121))) + } + v122 := v121.Get() + v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v124 := v123.FindInternedVar(lang.NewSymbol("list")) + if v124.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) + } + v125 := v124.Get() + v126 := lang.Apply(v125, []any{lang.NewSymbol("glojure.core/let")}) + v127 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v128 := v127.FindInternedVar(lang.NewSymbol("list")) + if v128.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v128))) + } + v129 := v128.Get() + v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v131 := v130.FindInternedVar(lang.NewSymbol("apply")) + if v131.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) + } + v132 := v131.Get() + v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v134 := v133.FindInternedVar(lang.NewSymbol("vector")) + if v134.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) + } + v135 := v134.Get() + v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v137 := v136.FindInternedVar(lang.NewSymbol("seq")) + if v137.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) + } + v138 := v137.Get() + v139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v140 := v139.FindInternedVar(lang.NewSymbol("concat")) + if v140.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v140))) + } + v141 := v140.Get() + v142 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v143 := v142.FindInternedVar(lang.NewSymbol("list")) + if v143.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v143))) + } + v144 := v143.Get() + v145 := lang.Apply(v144, []any{v57}) + v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v147 := v146.FindInternedVar(lang.NewSymbol("list")) + if v147.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) + } + v148 := v147.Get() + v149 := lang.Apply(v148, []any{lang.NewSymbol("temp__0__auto__")}) + v150 := lang.Apply(v141, []any{v145, v149}) + v151 := lang.Apply(v138, []any{v150}) + v152 := lang.Apply(v132, []any{v135, v151}) + v153 := lang.Apply(v129, []any{v152}) + v154 := lang.Apply(v122, []any{v126, v153, v6}) + v155 := lang.Apply(v119, []any{v154}) + v156 := lang.Apply(v116, []any{v155}) + v157 := lang.Apply(v105, []any{v109, v113, v156}) + v158 := lang.Apply(v102, []any{v157}) + v159 := lang.Apply(v99, []any{v158}) + v160 := lang.Apply(v65, []any{v69, v96, v159}) + v161 := lang.Apply(v62, []any{v160}) + v55 = v161 + } // end let + return v55 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // when-not + { + v0 := lang.NewSymbol("when-not").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("test"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Evaluates test. If logical false, evaluates body in an implicit do.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(498), lang.NewKeyword("end-line"), int(498))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("list")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("cons")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol("do"), v6}) + v14 := lang.Apply(v9, []any{lang.NewSymbol("if"), v5, nil, v13}) + return v14 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // when-some + { + v0 := lang.NewSymbol("when-some").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "bindings => binding-form test\n\n When test is not nil, evaluates body with binding-form bound to the\n value of test", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1894), lang.NewKeyword("end-line"), int(1894))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + var v7 any + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v5}) + if lang.IsTruthy(v11) { + v7 = nil + } else { + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("str")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("first")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{v3}) + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("meta")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v3}) + v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) + v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) + v28 := lang.Apply(lang.NewIllegalArgumentError, []any{v27}) + panic(v28) + } + _ = v7 + var v29 any + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("=")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("count")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.Apply(v35, []any{v5}) + v37 := lang.Apply(v32, []any{int64(2), v36}) + if lang.IsTruthy(v37) { + v29 = nil + } else { + v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v39 := v38.FindInternedVar(lang.NewSymbol("str")) + if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + } + v40 := v39.Get() + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("first")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.Apply(v43, []any{v3}) + v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) + if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) + } + v47 := v46.Get() + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("meta")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v3}) + v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) + v53 := lang.Apply(v40, []any{v44, " requires ", "exactly 2 forms in binding vector", " in ", v47, ":", v52}) + v54 := lang.Apply(lang.NewIllegalArgumentError, []any{v53}) + panic(v54) + } + _ = v29 + _ = nil + var v55 any + { // let + // let binding "form" + v56 := lang.Apply(v5, []any{int64(0)}) + var v57 any = v56 + _ = v57 + // let binding "tst" + v58 := lang.Apply(v5, []any{int64(1)}) + var v59 any = v58 + _ = v59 + v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v61 := v60.FindInternedVar(lang.NewSymbol("seq")) + if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) + } + v62 := v61.Get() + v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v64 := v63.FindInternedVar(lang.NewSymbol("concat")) + if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) + } + v65 := v64.Get() + v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v67 := v66.FindInternedVar(lang.NewSymbol("list")) + if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) + } + v68 := v67.Get() + v69 := lang.Apply(v68, []any{lang.NewSymbol("glojure.core/let")}) + v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v71 := v70.FindInternedVar(lang.NewSymbol("list")) + if v71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) + } + v72 := v71.Get() + v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v74 := v73.FindInternedVar(lang.NewSymbol("apply")) + if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) + } + v75 := v74.Get() + v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v77 := v76.FindInternedVar(lang.NewSymbol("vector")) + if v77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) + } + v78 := v77.Get() + v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v80 := v79.FindInternedVar(lang.NewSymbol("seq")) + if v80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) + } + v81 := v80.Get() + v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v83 := v82.FindInternedVar(lang.NewSymbol("concat")) + if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) + } + v84 := v83.Get() + v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v86 := v85.FindInternedVar(lang.NewSymbol("list")) + if v86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) + } + v87 := v86.Get() + v88 := lang.Apply(v87, []any{lang.NewSymbol("temp__0__auto__")}) + v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v90 := v89.FindInternedVar(lang.NewSymbol("list")) + if v90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) + } + v91 := v90.Get() + v92 := lang.Apply(v91, []any{v59}) + v93 := lang.Apply(v84, []any{v88, v92}) + v94 := lang.Apply(v81, []any{v93}) + v95 := lang.Apply(v75, []any{v78, v94}) + v96 := lang.Apply(v72, []any{v95}) + v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v98 := v97.FindInternedVar(lang.NewSymbol("list")) + if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) + } + v99 := v98.Get() + v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v101 := v100.FindInternedVar(lang.NewSymbol("seq")) + if v101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) + } + v102 := v101.Get() + v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v104 := v103.FindInternedVar(lang.NewSymbol("concat")) + if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) + } + v105 := v104.Get() + v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v107 := v106.FindInternedVar(lang.NewSymbol("list")) + if v107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) + } + v108 := v107.Get() + v109 := lang.Apply(v108, []any{lang.NewSymbol("if")}) + v110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v111 := v110.FindInternedVar(lang.NewSymbol("list")) + if v111.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v111))) + } + v112 := v111.Get() + v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v114 := v113.FindInternedVar(lang.NewSymbol("seq")) + if v114.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) + } + v115 := v114.Get() + v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v117 := v116.FindInternedVar(lang.NewSymbol("concat")) + if v117.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) + } + v118 := v117.Get() + v119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v120 := v119.FindInternedVar(lang.NewSymbol("list")) + if v120.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v120))) + } + v121 := v120.Get() + v122 := lang.Apply(v121, []any{lang.NewSymbol("glojure.core/nil?")}) + v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v124 := v123.FindInternedVar(lang.NewSymbol("list")) + if v124.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) + } + v125 := v124.Get() + v126 := lang.Apply(v125, []any{lang.NewSymbol("temp__0__auto__")}) + v127 := lang.Apply(v118, []any{v122, v126}) + v128 := lang.Apply(v115, []any{v127}) + v129 := lang.Apply(v112, []any{v128}) + v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v131 := v130.FindInternedVar(lang.NewSymbol("list")) + if v131.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) + } + v132 := v131.Get() + v133 := lang.Apply(v132, []any{nil}) + v134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v135 := v134.FindInternedVar(lang.NewSymbol("list")) + if v135.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v135))) + } + v136 := v135.Get() + v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v138 := v137.FindInternedVar(lang.NewSymbol("seq")) + if v138.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) + } + v139 := v138.Get() + v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v141 := v140.FindInternedVar(lang.NewSymbol("concat")) + if v141.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) + } + v142 := v141.Get() + v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v144 := v143.FindInternedVar(lang.NewSymbol("list")) + if v144.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) + } + v145 := v144.Get() + v146 := lang.Apply(v145, []any{lang.NewSymbol("glojure.core/let")}) + v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v148 := v147.FindInternedVar(lang.NewSymbol("list")) + if v148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) + } + v149 := v148.Get() + v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v151 := v150.FindInternedVar(lang.NewSymbol("apply")) + if v151.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) + } + v152 := v151.Get() + v153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v154 := v153.FindInternedVar(lang.NewSymbol("vector")) + if v154.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v154))) + } + v155 := v154.Get() + v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v157 := v156.FindInternedVar(lang.NewSymbol("seq")) + if v157.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) + } + v158 := v157.Get() + v159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v160 := v159.FindInternedVar(lang.NewSymbol("concat")) + if v160.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v160))) + } + v161 := v160.Get() + v162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v163 := v162.FindInternedVar(lang.NewSymbol("list")) + if v163.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v163))) + } + v164 := v163.Get() + v165 := lang.Apply(v164, []any{v57}) + v166 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v167 := v166.FindInternedVar(lang.NewSymbol("list")) + if v167.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v167))) + } + v168 := v167.Get() + v169 := lang.Apply(v168, []any{lang.NewSymbol("temp__0__auto__")}) + v170 := lang.Apply(v161, []any{v165, v169}) + v171 := lang.Apply(v158, []any{v170}) + v172 := lang.Apply(v152, []any{v155, v171}) + v173 := lang.Apply(v149, []any{v172}) + v174 := lang.Apply(v142, []any{v146, v173, v6}) + v175 := lang.Apply(v139, []any{v174}) + v176 := lang.Apply(v136, []any{v175}) + v177 := lang.Apply(v105, []any{v109, v129, v133, v176}) + v178 := lang.Apply(v102, []any{v177}) + v179 := lang.Apply(v99, []any{v178}) + v180 := lang.Apply(v65, []any{v69, v96, v179}) + v181 := lang.Apply(v62, []any{v180}) + v55 = v181 + } // end let + return v55 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // while + { + v0 := lang.NewSymbol("while").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("test"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Repeatedly executes body while test expression is true. Presumes\n some side-effect will cause test to become false/nil. Returns nil", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6327), lang.NewKeyword("end-line"), int(6327))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("seq")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("concat")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("list")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/loop")}) + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("list")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("apply")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("vector")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("seq")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("concat")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.Apply(v31, nil) + v33 := lang.Apply(v28, []any{v32}) + v34 := lang.Apply(v22, []any{v25, v33}) + v35 := lang.Apply(v19, []any{v34}) + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("list")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v40 := v39.FindInternedVar(lang.NewSymbol("seq")) + if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) + } + v41 := v40.Get() + v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v43 := v42.FindInternedVar(lang.NewSymbol("concat")) + if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) + } + v44 := v43.Get() + v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v46 := v45.FindInternedVar(lang.NewSymbol("list")) + if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) + } + v47 := v46.Get() + v48 := lang.Apply(v47, []any{lang.NewSymbol("glojure.core/when")}) + v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v50 := v49.FindInternedVar(lang.NewSymbol("list")) + if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) + } + v51 := v50.Get() + v52 := lang.Apply(v51, []any{v5}) + v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v54 := v53.FindInternedVar(lang.NewSymbol("list")) + if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) + } + v55 := v54.Get() + v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v57 := v56.FindInternedVar(lang.NewSymbol("seq")) + if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) + } + v58 := v57.Get() + v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v60 := v59.FindInternedVar(lang.NewSymbol("concat")) + if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) + } + v61 := v60.Get() + v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v63 := v62.FindInternedVar(lang.NewSymbol("list")) + if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) + } + v64 := v63.Get() + v65 := lang.Apply(v64, []any{lang.NewSymbol("recur")}) + v66 := lang.Apply(v61, []any{v65}) + v67 := lang.Apply(v58, []any{v66}) + v68 := lang.Apply(v55, []any{v67}) + v69 := lang.Apply(v44, []any{v48, v52, v6, v68}) + v70 := lang.Apply(v41, []any{v69}) + v71 := lang.Apply(v38, []any{v70}) + v72 := lang.Apply(v12, []any{v16, v35, v71}) + v73 := lang.Apply(v9, []any{v72}) + return v73 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // with-bindings + { + v0 := lang.NewSymbol("with-bindings").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("binding-map"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Takes a map of Var/value pairs. Installs for the given Vars the associated\n values as thread-local bindings. Then executes body. Pops the installed\n bindings after body was evaluated. Returns the value of body.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1984), lang.NewKeyword("end-line"), int(1984))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("seq")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("concat")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("list")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/with-bindings*")}) + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("list")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.Apply(v19, []any{v5}) + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("list")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("seq")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("concat")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("list")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.Apply(v32, []any{lang.NewSymbol("glojure.core/fn")}) + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("list")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("apply")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("vector")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v44 := v43.FindInternedVar(lang.NewSymbol("seq")) + if v44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) + } + v45 := v44.Get() + v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v47 := v46.FindInternedVar(lang.NewSymbol("concat")) + if v47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) + } + v48 := v47.Get() + v49 := lang.Apply(v48, nil) + v50 := lang.Apply(v45, []any{v49}) + v51 := lang.Apply(v39, []any{v42, v50}) + v52 := lang.Apply(v36, []any{v51}) + v53 := lang.Apply(v29, []any{v33, v52, v6}) + v54 := lang.Apply(v26, []any{v53}) + v55 := lang.Apply(v23, []any{v54}) + v56 := lang.Apply(v12, []any{v16, v20, v55}) + v57 := lang.Apply(v9, []any{v56}) + return v57 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // with-bindings* + { + v0 := lang.NewSymbol("with-bindings*").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("binding-map"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Takes a map of Var/value pairs. Installs for the given Vars the associated\n values as thread-local bindings. Then calls f with the supplied arguments.\n Pops the installed bindings after f returned. Returns whatever f returns.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1971), lang.NewKeyword("end-line"), int(1971))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.NewList(args[2:]...) + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("push-thread-bindings")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{v3}) + _ = v9 + var v10 any + func() { + defer func() { + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, nil) + }() + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("apply")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{v4, v5}) + v10 = v18 + }() + return v10 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // with-in-str + { + v0 := lang.NewSymbol("with-in-str").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Evaluates body in a context in which *in* is bound to a fresh\n StringReader initialized with the string s.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4749), lang.NewKeyword("end-line"), int(4749))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("seq")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("concat")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("list")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/with-open")}) + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("list")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("apply")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("vector")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("seq")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("concat")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("list")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.Apply(v34, []any{lang.NewSymbol("s__0__auto__")}) + v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v37 := v36.FindInternedVar(lang.NewSymbol("list")) + if v37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + } + v38 := v37.Get() + v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v40 := v39.FindInternedVar(lang.NewSymbol("seq")) + if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) + } + v41 := v40.Get() + v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v43 := v42.FindInternedVar(lang.NewSymbol("concat")) + if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) + } + v44 := v43.Get() + v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v46 := v45.FindInternedVar(lang.NewSymbol("list")) + if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) + } + v47 := v46.Get() + v48 := lang.Apply(v47, []any{lang.NewSymbol("glojure.core/->")}) + v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v50 := v49.FindInternedVar(lang.NewSymbol("list")) + if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) + } + v51 := v50.Get() + v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v53 := v52.FindInternedVar(lang.NewSymbol("seq")) + if v53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) + } + v54 := v53.Get() + v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v56 := v55.FindInternedVar(lang.NewSymbol("concat")) + if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) + } + v57 := v56.Get() + v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v59 := v58.FindInternedVar(lang.NewSymbol("list")) + if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) + } + v60 := v59.Get() + v61 := lang.Apply(v60, []any{lang.NewSymbol("java.io.StringReader.")}) + v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v63 := v62.FindInternedVar(lang.NewSymbol("list")) + if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) + } + v64 := v63.Get() + v65 := lang.Apply(v64, []any{v5}) + v66 := lang.Apply(v57, []any{v61, v65}) + v67 := lang.Apply(v54, []any{v66}) + v68 := lang.Apply(v51, []any{v67}) + v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v70 := v69.FindInternedVar(lang.NewSymbol("list")) + if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) + } + v71 := v70.Get() + v72 := lang.Apply(v71, []any{lang.NewSymbol("glojure.lang.LineNumberingPushbackReader.")}) + v73 := lang.Apply(v44, []any{v48, v68, v72}) + v74 := lang.Apply(v41, []any{v73}) + v75 := lang.Apply(v38, []any{v74}) + v76 := lang.Apply(v31, []any{v35, v75}) + v77 := lang.Apply(v28, []any{v76}) + v78 := lang.Apply(v22, []any{v25, v77}) + v79 := lang.Apply(v19, []any{v78}) + v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v81 := v80.FindInternedVar(lang.NewSymbol("list")) + if v81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) + } + v82 := v81.Get() + v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v84 := v83.FindInternedVar(lang.NewSymbol("seq")) + if v84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) + } + v85 := v84.Get() + v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v87 := v86.FindInternedVar(lang.NewSymbol("concat")) + if v87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) + } + v88 := v87.Get() + v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v90 := v89.FindInternedVar(lang.NewSymbol("list")) + if v90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) + } + v91 := v90.Get() + v92 := lang.Apply(v91, []any{lang.NewSymbol("glojure.core/binding")}) + v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v94 := v93.FindInternedVar(lang.NewSymbol("list")) + if v94.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) + } + v95 := v94.Get() + v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v97 := v96.FindInternedVar(lang.NewSymbol("apply")) + if v97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) + } + v98 := v97.Get() + v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v100 := v99.FindInternedVar(lang.NewSymbol("vector")) + if v100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) + } + v101 := v100.Get() + v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v103 := v102.FindInternedVar(lang.NewSymbol("seq")) + if v103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) + } + v104 := v103.Get() + v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v106 := v105.FindInternedVar(lang.NewSymbol("concat")) + if v106.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) + } + v107 := v106.Get() + v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v109 := v108.FindInternedVar(lang.NewSymbol("list")) + if v109.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) + } + v110 := v109.Get() + v111 := lang.Apply(v110, []any{lang.NewSymbol("glojure.core/*in*")}) + v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v113 := v112.FindInternedVar(lang.NewSymbol("list")) + if v113.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) + } + v114 := v113.Get() + v115 := lang.Apply(v114, []any{lang.NewSymbol("s__0__auto__")}) + v116 := lang.Apply(v107, []any{v111, v115}) + v117 := lang.Apply(v104, []any{v116}) + v118 := lang.Apply(v98, []any{v101, v117}) + v119 := lang.Apply(v95, []any{v118}) + v120 := lang.Apply(v88, []any{v92, v119, v6}) + v121 := lang.Apply(v85, []any{v120}) + v122 := lang.Apply(v82, []any{v121}) + v123 := lang.Apply(v12, []any{v16, v79, v122}) + v124 := lang.Apply(v9, []any{v123}) + return v124 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // with-loading-context + { + v0 := lang.NewSymbol("with-loading-context").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5734), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5734), lang.NewKeyword("end-column"), int(30), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("macro"), true)).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.NewList(args[2:]...) + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("seq")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("concat")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("list")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("seq")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("concat")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("list")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.Apply(v23, []any{lang.NewSymbol("glojure.core/fn")}) + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("list")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.Apply(v27, []any{lang.NewSymbol("loading__0__auto__")}) + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("list")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v33 := v32.FindInternedVar(lang.NewSymbol("apply")) + if v33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + } + v34 := v33.Get() + v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v36 := v35.FindInternedVar(lang.NewSymbol("vector")) + if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + } + v37 := v36.Get() + v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v39 := v38.FindInternedVar(lang.NewSymbol("seq")) + if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + } + v40 := v39.Get() + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("concat")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.Apply(v43, nil) + v45 := lang.Apply(v40, []any{v44}) + v46 := lang.Apply(v34, []any{v37, v45}) + v47 := lang.Apply(v31, []any{v46}) + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("list")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v52 := v51.FindInternedVar(lang.NewSymbol("seq")) + if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) + } + v53 := v52.Get() + v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v55 := v54.FindInternedVar(lang.NewSymbol("concat")) + if v55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) + } + v56 := v55.Get() + v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v58 := v57.FindInternedVar(lang.NewSymbol("list")) + if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) + } + v59 := v58.Get() + v60 := lang.Apply(v59, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.PushThreadBindings")}) + v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v62 := v61.FindInternedVar(lang.NewSymbol("list")) + if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) + } + v63 := v62.Get() + v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v65 := v64.FindInternedVar(lang.NewSymbol("apply")) + if v65.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) + } + v66 := v65.Get() + v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v68 := v67.FindInternedVar(lang.NewSymbol("hash-map")) + if v68.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) + } + v69 := v68.Get() + v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v71 := v70.FindInternedVar(lang.NewSymbol("seq")) + if v71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) + } + v72 := v71.Get() + v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v74 := v73.FindInternedVar(lang.NewSymbol("concat")) + if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) + } + v75 := v74.Get() + v76 := lang.Apply(v75, nil) + v77 := lang.Apply(v72, []any{v76}) + v78 := lang.Apply(v66, []any{v69, v77}) + v79 := lang.Apply(v63, []any{v78}) + v80 := lang.Apply(v56, []any{v60, v79}) + v81 := lang.Apply(v53, []any{v80}) + v82 := lang.Apply(v50, []any{v81}) + v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v84 := v83.FindInternedVar(lang.NewSymbol("list")) + if v84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) + } + v85 := v84.Get() + v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v87 := v86.FindInternedVar(lang.NewSymbol("seq")) + if v87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) + } + v88 := v87.Get() + v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v90 := v89.FindInternedVar(lang.NewSymbol("concat")) + if v90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) + } + v91 := v90.Get() + v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v93 := v92.FindInternedVar(lang.NewSymbol("list")) + if v93.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) + } + v94 := v93.Get() + v95 := lang.Apply(v94, []any{lang.NewSymbol("try")}) + v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v97 := v96.FindInternedVar(lang.NewSymbol("list")) + if v97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) + } + v98 := v97.Get() + v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v100 := v99.FindInternedVar(lang.NewSymbol("seq")) + if v100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) + } + v101 := v100.Get() + v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v103 := v102.FindInternedVar(lang.NewSymbol("concat")) + if v103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) + } + v104 := v103.Get() + v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v106 := v105.FindInternedVar(lang.NewSymbol("list")) + if v106.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) + } + v107 := v106.Get() + v108 := lang.Apply(v107, []any{lang.NewSymbol("finally")}) + v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v110 := v109.FindInternedVar(lang.NewSymbol("list")) + if v110.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) + } + v111 := v110.Get() + v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v113 := v112.FindInternedVar(lang.NewSymbol("seq")) + if v113.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) + } + v114 := v113.Get() + v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v116 := v115.FindInternedVar(lang.NewSymbol("concat")) + if v116.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) + } + v117 := v116.Get() + v118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v119 := v118.FindInternedVar(lang.NewSymbol("list")) + if v119.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v119))) + } + v120 := v119.Get() + v121 := lang.Apply(v120, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.PopThreadBindings")}) + v122 := lang.Apply(v117, []any{v121}) + v123 := lang.Apply(v114, []any{v122}) + v124 := lang.Apply(v111, []any{v123}) + v125 := lang.Apply(v104, []any{v108, v124}) + v126 := lang.Apply(v101, []any{v125}) + v127 := lang.Apply(v98, []any{v126}) + v128 := lang.Apply(v91, []any{v95, v5, v127}) + v129 := lang.Apply(v88, []any{v128}) + v130 := lang.Apply(v85, []any{v129}) + v131 := lang.Apply(v20, []any{v24, v28, v47, v82, v130}) + v132 := lang.Apply(v17, []any{v131}) + v133 := lang.Apply(v14, []any{v132}) + v134 := lang.Apply(v11, []any{v133}) + v135 := lang.Apply(v8, []any{v134}) + return v135 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // with-local-vars + { + v0 := lang.NewSymbol("with-local-vars").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name-vals-vec"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "varbinding=> symbol init-expr\n\n Executes the exprs in a context in which the symbols are bound to\n vars with per-thread bindings to the init-exprs. The symbols refer\n to the var objects themselves, and must be accessed with var-get and\n var-set", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4339), lang.NewKeyword("end-line"), int(4339))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + var v7 any + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v5}) + if lang.IsTruthy(v11) { + v7 = nil + } else { + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("str")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("first")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{v3}) + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("meta")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v3}) + v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) + v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) + v28 := lang.Apply(lang.NewIllegalArgumentError, []any{v27}) + panic(v28) + } + _ = v7 + var v29 any + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("even?")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("count")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.Apply(v35, []any{v5}) + v37 := lang.Apply(v32, []any{v36}) + if lang.IsTruthy(v37) { + v29 = nil + } else { + v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v39 := v38.FindInternedVar(lang.NewSymbol("str")) + if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + } + v40 := v39.Get() + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("first")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.Apply(v43, []any{v3}) + v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) + if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) + } + v47 := v46.Get() + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("meta")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v3}) + v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) + v53 := lang.Apply(v40, []any{v44, " requires ", "an even number of forms in binding vector", " in ", v47, ":", v52}) + v54 := lang.Apply(lang.NewIllegalArgumentError, []any{v53}) + panic(v54) + } + _ = v29 + _ = nil + v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v56 := v55.FindInternedVar(lang.NewSymbol("seq")) + if v56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) + } + v57 := v56.Get() + v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v59 := v58.FindInternedVar(lang.NewSymbol("concat")) + if v59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) + } + v60 := v59.Get() + v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v62 := v61.FindInternedVar(lang.NewSymbol("list")) + if v62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) + } + v63 := v62.Get() + v64 := lang.Apply(v63, []any{lang.NewSymbol("glojure.core/let")}) + v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v66 := v65.FindInternedVar(lang.NewSymbol("list")) + if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) + } + v67 := v66.Get() + v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v69 := v68.FindInternedVar(lang.NewSymbol("apply")) + if v69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) + } + v70 := v69.Get() + v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v72 := v71.FindInternedVar(lang.NewSymbol("vector")) + if v72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) + } + v73 := v72.Get() + v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v75 := v74.FindInternedVar(lang.NewSymbol("seq")) + if v75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) + } + v76 := v75.Get() + v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v78 := v77.FindInternedVar(lang.NewSymbol("concat")) + if v78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) + } + v79 := v78.Get() + v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v81 := v80.FindInternedVar(lang.NewSymbol("interleave")) + if v81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) + } + v82 := v81.Get() + v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v84 := v83.FindInternedVar(lang.NewSymbol("take-nth")) + if v84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) + } + v85 := v84.Get() + v86 := lang.Apply(v85, []any{int64(2), v5}) + v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v88 := v87.FindInternedVar(lang.NewSymbol("repeat")) + if v88.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) + } + v89 := v88.Get() + v90 := lang.Apply(v89, []any{lang.NewList(lang.NewSymbol(".."), lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.*Var"), lang.NewSymbol("create"), lang.NewSymbol("setDynamic"))}) + v91 := lang.Apply(v82, []any{v86, v90}) + v92 := lang.Apply(v79, []any{v91}) + v93 := lang.Apply(v76, []any{v92}) + v94 := lang.Apply(v70, []any{v73, v93}) + v95 := lang.Apply(v67, []any{v94}) + v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v97 := v96.FindInternedVar(lang.NewSymbol("list")) + if v97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) + } + v98 := v97.Get() + v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v100 := v99.FindInternedVar(lang.NewSymbol("seq")) + if v100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) + } + v101 := v100.Get() + v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v103 := v102.FindInternedVar(lang.NewSymbol("concat")) + if v103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) + } + v104 := v103.Get() + v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v106 := v105.FindInternedVar(lang.NewSymbol("list")) + if v106.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) + } + v107 := v106.Get() + v108 := lang.Apply(v107, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.PushThreadBindings")}) + v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v110 := v109.FindInternedVar(lang.NewSymbol("list")) + if v110.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) + } + v111 := v110.Get() + v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v113 := v112.FindInternedVar(lang.NewSymbol("apply")) + if v113.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) + } + v114 := v113.Get() + v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v116 := v115.FindInternedVar(lang.NewSymbol("hash-map")) + if v116.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) + } + v117 := v116.Get() + v118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v119 := v118.FindInternedVar(lang.NewSymbol("seq")) + if v119.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v119))) + } + v120 := v119.Get() + v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v122 := v121.FindInternedVar(lang.NewSymbol("concat")) + if v122.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) + } + v123 := v122.Get() + v124 := lang.Apply(v123, nil) + v125 := lang.Apply(v120, []any{v124}) + v126 := lang.Apply(v114, []any{v117, v125}) + v127 := lang.Apply(v111, []any{v126}) + v128 := lang.Apply(v104, []any{v108, v127}) + v129 := lang.Apply(v101, []any{v128}) + v130 := lang.Apply(v98, []any{v129}) + v131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v132 := v131.FindInternedVar(lang.NewSymbol("list")) + if v132.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v132))) + } + v133 := v132.Get() + v134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v135 := v134.FindInternedVar(lang.NewSymbol("seq")) + if v135.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v135))) + } + v136 := v135.Get() + v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v138 := v137.FindInternedVar(lang.NewSymbol("concat")) + if v138.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) + } + v139 := v138.Get() + v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v141 := v140.FindInternedVar(lang.NewSymbol("list")) + if v141.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) + } + v142 := v141.Get() + v143 := lang.Apply(v142, []any{lang.NewSymbol("try")}) + v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v145 := v144.FindInternedVar(lang.NewSymbol("list")) + if v145.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) + } + v146 := v145.Get() + v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v148 := v147.FindInternedVar(lang.NewSymbol("seq")) + if v148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) + } + v149 := v148.Get() + v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v151 := v150.FindInternedVar(lang.NewSymbol("concat")) + if v151.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) + } + v152 := v151.Get() + v153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v154 := v153.FindInternedVar(lang.NewSymbol("list")) + if v154.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v154))) + } + v155 := v154.Get() + v156 := lang.Apply(v155, []any{lang.NewSymbol("finally")}) + v157 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v158 := v157.FindInternedVar(lang.NewSymbol("list")) + if v158.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v158))) + } + v159 := v158.Get() + v160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v161 := v160.FindInternedVar(lang.NewSymbol("seq")) + if v161.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v161))) + } + v162 := v161.Get() + v163 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v164 := v163.FindInternedVar(lang.NewSymbol("concat")) + if v164.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v164))) + } + v165 := v164.Get() + v166 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v167 := v166.FindInternedVar(lang.NewSymbol("list")) + if v167.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v167))) + } + v168 := v167.Get() + v169 := lang.Apply(v168, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.PopThreadBindings")}) + v170 := lang.Apply(v165, []any{v169}) + v171 := lang.Apply(v162, []any{v170}) + v172 := lang.Apply(v159, []any{v171}) + v173 := lang.Apply(v152, []any{v156, v172}) + v174 := lang.Apply(v149, []any{v173}) + v175 := lang.Apply(v146, []any{v174}) + v176 := lang.Apply(v139, []any{v143, v6, v175}) + v177 := lang.Apply(v136, []any{v176}) + v178 := lang.Apply(v133, []any{v177}) + v179 := lang.Apply(v60, []any{v64, v95, v130, v178}) + v180 := lang.Apply(v57, []any{v179}) + return v180 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // with-meta + { + v0 := lang.NewSymbol("with-meta").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("obj"), lang.NewSymbol("m"))), lang.NewKeyword("doc"), "Returns an object of the same type and value as obj, with\n map m as its metadata.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(211), lang.NewKeyword("end-line"), int(216))).(*lang.Symbol) + var v2 lang.FnFunc + { // function with-meta + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6, _ := lang.FieldOrMethod(v4, "WithMeta") + if reflect.TypeOf(v6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("WithMeta is not a function"))) + } + v7 := lang.Apply(v6, []any{v5}) + return v7 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(216), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(217), lang.NewKeyword("end-column"), int(32))).(lang.FnFunc) + v3 := v2 + _ = v3 + } + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // with-open + { + v0 := lang.NewSymbol("with-open").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "bindings => [name init ...]\n\n Evaluates body in a try expression with names bound to the values\n of the inits, and a finally clause that calls (.close name) on each\n name in reverse order.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3832), lang.NewKeyword("end-line"), int(3832))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + var v7 any + v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) + if v9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + } + v10 := v9.Get() + v11 := lang.Apply(v10, []any{v5}) + if lang.IsTruthy(v11) { + v7 = nil + } else { + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("str")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v16 := v15.FindInternedVar(lang.NewSymbol("first")) + if v16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + } + v17 := v16.Get() + v18 := lang.Apply(v17, []any{v3}) + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("meta")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v3}) + v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) + v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) + v28 := lang.Apply(lang.NewIllegalArgumentError, []any{v27}) + panic(v28) + } + _ = v7 + var v29 any + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("even?")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("count")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.Apply(v35, []any{v5}) + v37 := lang.Apply(v32, []any{v36}) + if lang.IsTruthy(v37) { + v29 = nil + } else { + v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v39 := v38.FindInternedVar(lang.NewSymbol("str")) + if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + } + v40 := v39.Get() + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("first")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.Apply(v43, []any{v3}) + v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) + if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) + } + v47 := v46.Get() + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("meta")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{v3}) + v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) + v53 := lang.Apply(v40, []any{v44, " requires ", "an even number of forms in binding vector", " in ", v47, ":", v52}) + v54 := lang.Apply(lang.NewIllegalArgumentError, []any{v53}) + panic(v54) + } + _ = v29 + _ = nil + var v55 any + v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v57 := v56.FindInternedVar(lang.NewSymbol("=")) + if v57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) + } + v58 := v57.Get() + v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v60 := v59.FindInternedVar(lang.NewSymbol("count")) + if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) + } + v61 := v60.Get() + v62 := lang.Apply(v61, []any{v5}) + v63 := lang.Apply(v58, []any{v62, int64(0)}) + if lang.IsTruthy(v63) { + v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v65 := v64.FindInternedVar(lang.NewSymbol("seq")) + if v65.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) + } + v66 := v65.Get() + v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v68 := v67.FindInternedVar(lang.NewSymbol("concat")) + if v68.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) + } + v69 := v68.Get() + v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v71 := v70.FindInternedVar(lang.NewSymbol("list")) + if v71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) + } + v72 := v71.Get() + v73 := lang.Apply(v72, []any{lang.NewSymbol("do")}) + v74 := lang.Apply(v69, []any{v73, v6}) + v75 := lang.Apply(v66, []any{v74}) + v55 = v75 + } else { + var v76 any + v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v78 := v77.FindInternedVar(lang.NewSymbol("symbol?")) + if v78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) + } + v79 := v78.Get() + v80 := lang.Apply(v5, []any{int64(0)}) + v81 := lang.Apply(v79, []any{v80}) + if lang.IsTruthy(v81) { + v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v83 := v82.FindInternedVar(lang.NewSymbol("seq")) + if v83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) + } + v84 := v83.Get() + v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v86 := v85.FindInternedVar(lang.NewSymbol("concat")) + if v86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) + } + v87 := v86.Get() + v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v89 := v88.FindInternedVar(lang.NewSymbol("list")) + if v89.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) + } + v90 := v89.Get() + v91 := lang.Apply(v90, []any{lang.NewSymbol("glojure.core/let")}) + v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v93 := v92.FindInternedVar(lang.NewSymbol("list")) + if v93.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) + } + v94 := v93.Get() + v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v96 := v95.FindInternedVar(lang.NewSymbol("subvec")) + if v96.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) + } + v97 := v96.Get() + v98 := lang.Apply(v97, []any{v5, int64(0), int64(2)}) + v99 := lang.Apply(v94, []any{v98}) + v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v101 := v100.FindInternedVar(lang.NewSymbol("list")) + if v101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) + } + v102 := v101.Get() + v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v104 := v103.FindInternedVar(lang.NewSymbol("seq")) + if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) + } + v105 := v104.Get() + v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v107 := v106.FindInternedVar(lang.NewSymbol("concat")) + if v107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) + } + v108 := v107.Get() + v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v110 := v109.FindInternedVar(lang.NewSymbol("list")) + if v110.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) + } + v111 := v110.Get() + v112 := lang.Apply(v111, []any{lang.NewSymbol("try")}) + v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v114 := v113.FindInternedVar(lang.NewSymbol("list")) + if v114.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) + } + v115 := v114.Get() + v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v117 := v116.FindInternedVar(lang.NewSymbol("seq")) + if v117.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) + } + v118 := v117.Get() + v119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v120 := v119.FindInternedVar(lang.NewSymbol("concat")) + if v120.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v120))) + } + v121 := v120.Get() + v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v123 := v122.FindInternedVar(lang.NewSymbol("list")) + if v123.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) + } + v124 := v123.Get() + v125 := lang.Apply(v124, []any{lang.NewSymbol("glojure.core/with-open")}) + v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v127 := v126.FindInternedVar(lang.NewSymbol("list")) + if v127.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) + } + v128 := v127.Get() + v129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v130 := v129.FindInternedVar(lang.NewSymbol("subvec")) + if v130.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v130))) + } + v131 := v130.Get() + v132 := lang.Apply(v131, []any{v5, int64(2)}) + v133 := lang.Apply(v128, []any{v132}) + v134 := lang.Apply(v121, []any{v125, v133, v6}) + v135 := lang.Apply(v118, []any{v134}) + v136 := lang.Apply(v115, []any{v135}) + v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v138 := v137.FindInternedVar(lang.NewSymbol("list")) + if v138.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) + } + v139 := v138.Get() + v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v141 := v140.FindInternedVar(lang.NewSymbol("seq")) + if v141.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) + } + v142 := v141.Get() + v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v144 := v143.FindInternedVar(lang.NewSymbol("concat")) + if v144.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) + } + v145 := v144.Get() + v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v147 := v146.FindInternedVar(lang.NewSymbol("list")) + if v147.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) + } + v148 := v147.Get() + v149 := lang.Apply(v148, []any{lang.NewSymbol("finally")}) + v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v151 := v150.FindInternedVar(lang.NewSymbol("list")) + if v151.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) + } + v152 := v151.Get() + v153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v154 := v153.FindInternedVar(lang.NewSymbol("seq")) + if v154.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v154))) + } + v155 := v154.Get() + v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v157 := v156.FindInternedVar(lang.NewSymbol("concat")) + if v157.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) + } + v158 := v157.Get() + v159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v160 := v159.FindInternedVar(lang.NewSymbol("list")) + if v160.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v160))) + } + v161 := v160.Get() + v162 := lang.Apply(v161, []any{lang.NewSymbol(".")}) + v163 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v164 := v163.FindInternedVar(lang.NewSymbol("list")) + if v164.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v164))) + } + v165 := v164.Get() + v166 := lang.Apply(v5, []any{int64(0)}) + v167 := lang.Apply(v165, []any{v166}) + v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v169 := v168.FindInternedVar(lang.NewSymbol("list")) + if v169.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) + } + v170 := v169.Get() + v171 := lang.Apply(v170, []any{lang.NewSymbol("close")}) + v172 := lang.Apply(v158, []any{v162, v167, v171}) + v173 := lang.Apply(v155, []any{v172}) + v174 := lang.Apply(v152, []any{v173}) + v175 := lang.Apply(v145, []any{v149, v174}) + v176 := lang.Apply(v142, []any{v175}) + v177 := lang.Apply(v139, []any{v176}) + v178 := lang.Apply(v108, []any{v112, v136, v177}) + v179 := lang.Apply(v105, []any{v178}) + v180 := lang.Apply(v102, []any{v179}) + v181 := lang.Apply(v87, []any{v91, v99, v180}) + v182 := lang.Apply(v84, []any{v181}) + v76 = v182 + } else { + var v183 any + if lang.IsTruthy(lang.NewKeyword("else")) { + v184 := lang.Apply(lang.NewIllegalArgumentError, []any{"with-open only allows Symbols in bindings"}) + panic(v184) + } else { + v183 = nil + } + v76 = v183 + } + v55 = v76 + } + return v55 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // with-out-str + { + v0 := lang.NewSymbol("with-out-str").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Evaluates exprs in a context in which *out* is bound to a fresh\n StringWriter. Returns the string created by any nested printing\n calls.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4738), lang.NewKeyword("end-line"), int(4738))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := lang.NewList(args[2:]...) + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("seq")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("concat")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("list")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.Apply(v14, []any{lang.NewSymbol("glojure.core/let")}) + v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v17 := v16.FindInternedVar(lang.NewSymbol("list")) + if v17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + } + v18 := v17.Get() + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("apply")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("vector")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("seq")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("concat")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{lang.NewSymbol("s__0__auto__")}) + v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v36 := v35.FindInternedVar(lang.NewSymbol("list")) + if v36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + } + v37 := v36.Get() + v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v39 := v38.FindInternedVar(lang.NewSymbol("seq")) + if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + } + v40 := v39.Get() + v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v42 := v41.FindInternedVar(lang.NewSymbol("concat")) + if v42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + } + v43 := v42.Get() + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("list")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.Apply(v46, []any{lang.NewSymbol("new")}) + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("list")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.Apply(v50, []any{lang.NewSymbol("strings.Builder")}) + v52 := lang.Apply(v43, []any{v47, v51}) + v53 := lang.Apply(v40, []any{v52}) + v54 := lang.Apply(v37, []any{v53}) + v55 := lang.Apply(v30, []any{v34, v54}) + v56 := lang.Apply(v27, []any{v55}) + v57 := lang.Apply(v21, []any{v24, v56}) + v58 := lang.Apply(v18, []any{v57}) + v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v60 := v59.FindInternedVar(lang.NewSymbol("list")) + if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) + } + v61 := v60.Get() + v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v63 := v62.FindInternedVar(lang.NewSymbol("seq")) + if v63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) + } + v64 := v63.Get() + v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v66 := v65.FindInternedVar(lang.NewSymbol("concat")) + if v66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) + } + v67 := v66.Get() + v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v69 := v68.FindInternedVar(lang.NewSymbol("list")) + if v69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) + } + v70 := v69.Get() + v71 := lang.Apply(v70, []any{lang.NewSymbol("glojure.core/binding")}) + v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v73 := v72.FindInternedVar(lang.NewSymbol("list")) + if v73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) + } + v74 := v73.Get() + v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v76 := v75.FindInternedVar(lang.NewSymbol("apply")) + if v76.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) + } + v77 := v76.Get() + v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v79 := v78.FindInternedVar(lang.NewSymbol("vector")) + if v79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) + } + v80 := v79.Get() + v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v82 := v81.FindInternedVar(lang.NewSymbol("seq")) + if v82.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) + } + v83 := v82.Get() + v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v85 := v84.FindInternedVar(lang.NewSymbol("concat")) + if v85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) + } + v86 := v85.Get() + v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v88 := v87.FindInternedVar(lang.NewSymbol("list")) + if v88.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) + } + v89 := v88.Get() + v90 := lang.Apply(v89, []any{lang.NewSymbol("glojure.core/*out*")}) + v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v92 := v91.FindInternedVar(lang.NewSymbol("list")) + if v92.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) + } + v93 := v92.Get() + v94 := lang.Apply(v93, []any{lang.NewSymbol("s__0__auto__")}) + v95 := lang.Apply(v86, []any{v90, v94}) + v96 := lang.Apply(v83, []any{v95}) + v97 := lang.Apply(v77, []any{v80, v96}) + v98 := lang.Apply(v74, []any{v97}) + v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v100 := v99.FindInternedVar(lang.NewSymbol("list")) + if v100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) + } + v101 := v100.Get() + v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v103 := v102.FindInternedVar(lang.NewSymbol("seq")) + if v103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) + } + v104 := v103.Get() + v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v106 := v105.FindInternedVar(lang.NewSymbol("concat")) + if v106.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) + } + v107 := v106.Get() + v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v109 := v108.FindInternedVar(lang.NewSymbol("list")) + if v109.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) + } + v110 := v109.Get() + v111 := lang.Apply(v110, []any{lang.NewSymbol("glojure.core/str")}) + v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v113 := v112.FindInternedVar(lang.NewSymbol("list")) + if v113.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) + } + v114 := v113.Get() + v115 := lang.Apply(v114, []any{lang.NewSymbol("s__0__auto__")}) + v116 := lang.Apply(v107, []any{v111, v115}) + v117 := lang.Apply(v104, []any{v116}) + v118 := lang.Apply(v101, []any{v117}) + v119 := lang.Apply(v67, []any{v71, v98, v5, v118}) + v120 := lang.Apply(v64, []any{v119}) + v121 := lang.Apply(v61, []any{v120}) + v122 := lang.Apply(v11, []any{v15, v58, v121}) + v123 := lang.Apply(v8, []any{v122}) + return v123 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // with-precision + { + v0 := lang.NewSymbol("with-precision").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("precision"), lang.NewSymbol("&"), lang.NewSymbol("exprs"))), lang.NewKeyword("doc"), "Sets the precision and rounding mode to be used for BigDecimal operations.\n\n Usage: (with-precision 10 (/ 1M 3))\n or: (with-precision 10 :rounding HALF_DOWN (/ 1M 3))\n\n The rounding mode is one of CEILING, FLOOR, HALF_UP, HALF_DOWN,\n HALF_EVEN, UP, DOWN and UNNECESSARY; it defaults to HALF_UP.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5110), lang.NewKeyword("end-line"), int(5110))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + var v7 any + { // let + // let binding "vec__65" + var v8 any + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("=")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v13 := v12.FindInternedVar(lang.NewSymbol("first")) + if v13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + } + v14 := v13.Get() + v15 := lang.Apply(v14, []any{v6}) + v16 := lang.Apply(v11, []any{v15, lang.NewKeyword("rounding")}) + if lang.IsTruthy(v16) { + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("next")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("next")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.Apply(v22, []any{v6}) + v24 := lang.Apply(v19, []any{v23}) + v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v26 := v25.FindInternedVar(lang.NewSymbol("seq")) + if v26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + } + v27 := v26.Get() + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("concat")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("seq")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("concat")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("list")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.Apply(v42, []any{lang.NewSymbol(".")}) + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("list")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.Apply(v46, []any{lang.NewSymbol("java.math.RoundingMode")}) + v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v49 := v48.FindInternedVar(lang.NewSymbol("list")) + if v49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + } + v50 := v49.Get() + v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v52 := v51.FindInternedVar(lang.NewSymbol("second")) + if v52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) + } + v53 := v52.Get() + v54 := lang.Apply(v53, []any{v6}) + v55 := lang.Apply(v50, []any{v54}) + v56 := lang.Apply(v39, []any{v43, v47, v55}) + v57 := lang.Apply(v36, []any{v56}) + v58 := lang.Apply(v33, []any{v57}) + v59 := lang.Apply(v30, []any{v58}) + v60 := lang.Apply(v27, []any{v59}) + v61 := lang.NewVector(v24, v60) + v62 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5121), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(5122), lang.NewKeyword("end-column"), int(69)) + v63, err := lang.WithMeta(v61, v62.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v8 = v63 + } else { + v64 := lang.NewVector(v6, nil) + v65 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5123), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(5123), lang.NewKeyword("end-column"), int(33)) + v66, err := lang.WithMeta(v64, v65.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v8 = v66 + } + var v67 any = v8 + _ = v67 + // let binding "body" + v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v69 := v68.FindInternedVar(lang.NewSymbol("nth")) + if v69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) + } + v70 := v69.Get() + v71 := lang.Apply(v70, []any{v67, int64(0), nil}) + var v72 any = v71 + _ = v72 + // let binding "rm" + v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v74 := v73.FindInternedVar(lang.NewSymbol("nth")) + if v74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) + } + v75 := v74.Get() + v76 := lang.Apply(v75, []any{v67, int64(1), nil}) + var v77 any = v76 + _ = v77 + v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v79 := v78.FindInternedVar(lang.NewSymbol("seq")) + if v79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) + } + v80 := v79.Get() + v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v82 := v81.FindInternedVar(lang.NewSymbol("concat")) + if v82.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) + } + v83 := v82.Get() + v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v85 := v84.FindInternedVar(lang.NewSymbol("list")) + if v85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) + } + v86 := v85.Get() + v87 := lang.Apply(v86, []any{lang.NewSymbol("glojure.core/binding")}) + v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v89 := v88.FindInternedVar(lang.NewSymbol("list")) + if v89.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) + } + v90 := v89.Get() + v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v92 := v91.FindInternedVar(lang.NewSymbol("apply")) + if v92.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) + } + v93 := v92.Get() + v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v95 := v94.FindInternedVar(lang.NewSymbol("vector")) + if v95.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) + } + v96 := v95.Get() + v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v98 := v97.FindInternedVar(lang.NewSymbol("seq")) + if v98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) + } + v99 := v98.Get() + v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v101 := v100.FindInternedVar(lang.NewSymbol("concat")) + if v101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) + } + v102 := v101.Get() + v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v104 := v103.FindInternedVar(lang.NewSymbol("list")) + if v104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) + } + v105 := v104.Get() + v106 := lang.Apply(v105, []any{lang.NewSymbol("glojure.core/*math-context*")}) + v107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v108 := v107.FindInternedVar(lang.NewSymbol("list")) + if v108.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v108))) + } + v109 := v108.Get() + v110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v111 := v110.FindInternedVar(lang.NewSymbol("seq")) + if v111.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v111))) + } + v112 := v111.Get() + v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v114 := v113.FindInternedVar(lang.NewSymbol("concat")) + if v114.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) + } + v115 := v114.Get() + v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v117 := v116.FindInternedVar(lang.NewSymbol("list")) + if v117.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) + } + v118 := v117.Get() + v119 := lang.Apply(v118, []any{lang.NewSymbol("java.math.MathContext.")}) + v120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v121 := v120.FindInternedVar(lang.NewSymbol("list")) + if v121.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v121))) + } + v122 := v121.Get() + v123 := lang.Apply(v122, []any{v5}) + v124 := lang.Apply(v115, []any{v119, v123, v77}) + v125 := lang.Apply(v112, []any{v124}) + v126 := lang.Apply(v109, []any{v125}) + v127 := lang.Apply(v102, []any{v106, v126}) + v128 := lang.Apply(v99, []any{v127}) + v129 := lang.Apply(v93, []any{v96, v128}) + v130 := lang.Apply(v90, []any{v129}) + v131 := lang.Apply(v83, []any{v87, v130, v72}) + v132 := lang.Apply(v80, []any{v131}) + v7 = v132 + } // end let + return v7 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // with-redefs + { + v0 := lang.NewSymbol("with-redefs").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "binding => var-symbol temp-value-expr\n\n Temporarily redefines Vars while executing the body. The\n temp-value-exprs will be evaluated and each resulting value will\n replace in parallel the root value of its Var. After the body is\n executed, the root values of all the Vars will be set back to their\n old values. These temporary changes will be visible in all threads.\n Useful for mocking out functions during testing.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7544), lang.NewKeyword("end-line"), int(7544))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := lang.NewList(args[3:]...) + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("seq")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("concat")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("list")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/with-redefs-fn")}) + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("list")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v21 := v20.FindInternedVar(lang.NewSymbol("zipmap")) + if v21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + } + v22 := v21.Get() + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("map")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + var v26 lang.FnFunc + v26 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v27 := args[0] + _ = v27 + v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v29 := v28.FindInternedVar(lang.NewSymbol("list")) + if v29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + } + v30 := v29.Get() + v31 := lang.Apply(v30, []any{lang.NewSymbol("var"), v27}) + return v31 + }) + v27 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7555), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(7555), lang.NewKeyword("end-column"), int(47)) + v28, err := lang.WithMeta(v26, v27.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v30 := v29.FindInternedVar(lang.NewSymbol("take-nth")) + if v30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + } + v31 := v30.Get() + v32 := lang.Apply(v31, []any{int64(2), v5}) + v33 := lang.Apply(v25, []any{v28, v32}) + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("take-nth")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v38 := v37.FindInternedVar(lang.NewSymbol("next")) + if v38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + } + v39 := v38.Get() + v40 := lang.Apply(v39, []any{v5}) + v41 := lang.Apply(v36, []any{int64(2), v40}) + v42 := lang.Apply(v22, []any{v33, v41}) + v43 := lang.Apply(v19, []any{v42}) + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("list")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v48 := v47.FindInternedVar(lang.NewSymbol("seq")) + if v48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) + } + v49 := v48.Get() + v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v51 := v50.FindInternedVar(lang.NewSymbol("concat")) + if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) + } + v52 := v51.Get() + v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v54 := v53.FindInternedVar(lang.NewSymbol("list")) + if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) + } + v55 := v54.Get() + v56 := lang.Apply(v55, []any{lang.NewSymbol("glojure.core/fn")}) + v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v58 := v57.FindInternedVar(lang.NewSymbol("list")) + if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) + } + v59 := v58.Get() + v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v61 := v60.FindInternedVar(lang.NewSymbol("apply")) + if v61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) + } + v62 := v61.Get() + v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v64 := v63.FindInternedVar(lang.NewSymbol("vector")) + if v64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) + } + v65 := v64.Get() + v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v67 := v66.FindInternedVar(lang.NewSymbol("seq")) + if v67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) + } + v68 := v67.Get() + v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v70 := v69.FindInternedVar(lang.NewSymbol("concat")) + if v70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) + } + v71 := v70.Get() + v72 := lang.Apply(v71, nil) + v73 := lang.Apply(v68, []any{v72}) + v74 := lang.Apply(v62, []any{v65, v73}) + v75 := lang.Apply(v59, []any{v74}) + v76 := lang.Apply(v52, []any{v56, v75, v6}) + v77 := lang.Apply(v49, []any{v76}) + v78 := lang.Apply(v46, []any{v77}) + v79 := lang.Apply(v12, []any{v16, v43, v78}) + v80 := lang.Apply(v9, []any{v79}) + return v80 + } + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // with-redefs-fn + { + v0 := lang.NewSymbol("with-redefs-fn").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("binding-map"), lang.NewSymbol("func"))), lang.NewKeyword("doc"), "Temporarily redefines Vars during a call to func. Each val of\n binding-map will replace the root value of its key which must be\n a Var. After func is called with no args, the root values of all\n the Vars will be set back to their old values. These temporary\n changes will be visible in all threads. Useful for mocking out\n functions during testing.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7524), lang.NewKeyword("end-line"), int(7524))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any + { // let + // let binding "root-bind" + var v6 lang.FnFunc + v6 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v7 := args[0] + _ = v7 + var v8 any + { // let + // let binding "seq_326" + v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v10 := v9.FindInternedVar(lang.NewSymbol("seq")) + if v10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + } + v11 := v10.Get() + v12 := lang.Apply(v11, []any{v7}) + var v13 any = v12 + _ = v13 + // let binding "chunk_327" + var v14 any = nil + _ = v14 + // let binding "count_328" + var v15 any = int64(0) + _ = v15 + // let binding "i_329" + var v16 any = int64(0) + _ = v16 + for { + var v17 any + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("<")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.Apply(v20, []any{v16, v15}) + if lang.IsTruthy(v21) { + var v22 any + { // let + // let binding "vec__330" + v23, _ := lang.FieldOrMethod(v14, "nth") + if reflect.TypeOf(v23).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + v24 := lang.Apply(v23, []any{v16}) + var v25 any = v24 + _ = v25 + // let binding "a-var" + v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v27 := v26.FindInternedVar(lang.NewSymbol("nth")) + if v27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + } + v28 := v27.Get() + v29 := lang.Apply(v28, []any{v25, int64(0), nil}) + var v30 any = v29 + _ = v30 + // let binding "a-val" + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("nth")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{v25, int64(1), nil}) + var v35 any = v34 + _ = v35 + v36, _ := lang.FieldOrMethod(v30, "bindRoot") + if reflect.TypeOf(v36).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("bindRoot is not a function"))) + } + v37 := lang.Apply(v36, []any{v35}) + _ = v37 + var v38 any = v13 + var v39 any = v14 + var v40 any = v15 + v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v43 := v42.FindInternedVar(lang.NewSymbol("unchecked-inc")) + if v43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) + } + v44 := v43.Get() + v45 := lang.Apply(v44, []any{v16}) + var v41 any = v45 + v13 = v38 + v14 = v39 + v15 = v40 + v16 = v41 + continue + } // end let + v17 = v22 + } else { + var v23 any + { // let + // let binding "temp__0__auto__" + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("seq")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.Apply(v26, []any{v13}) + var v28 any = v27 + _ = v28 + var v29 any + if lang.IsTruthy(v28) { + var v30 any + { // let + // let binding "seq_326" + var v31 any = v28 + _ = v31 + var v32 any + v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v34 := v33.FindInternedVar(lang.NewSymbol("chunked-seq?")) + if v34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + } + v35 := v34.Get() + v36 := lang.Apply(v35, []any{v31}) + if lang.IsTruthy(v36) { + var v37 any + { // let + // let binding "c__0__auto__" + v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v39 := v38.FindInternedVar(lang.NewSymbol("chunk-first")) + if v39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + } + v40 := v39.Get() + v41 := lang.Apply(v40, []any{v31}) + var v42 any = v41 + _ = v42 + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("chunk-rest")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.Apply(v46, []any{v31}) + var v43 any = v47 + var v48 any = v42 + v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v51 := v50.FindInternedVar(lang.NewSymbol("int")) + if v51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) + } + v52 := v51.Get() + v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v54 := v53.FindInternedVar(lang.NewSymbol("count")) + if v54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) + } + v55 := v54.Get() + v56 := lang.Apply(v55, []any{v42}) + v57 := lang.Apply(v52, []any{v56}) + var v49 any = v57 + v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v60 := v59.FindInternedVar(lang.NewSymbol("int")) + if v60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) + } + v61 := v60.Get() + v62 := lang.Apply(v61, []any{int64(0)}) + var v58 any = v62 + v13 = v43 + v14 = v48 + v15 = v49 + v16 = v58 + continue + } // end let + v32 = v37 + } else { + var v38 any + { // let + // let binding "vec__333" + v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v40 := v39.FindInternedVar(lang.NewSymbol("first")) + if v40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) + } + v41 := v40.Get() + v42 := lang.Apply(v41, []any{v31}) + var v43 any = v42 + _ = v43 + // let binding "a-var" + v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v45 := v44.FindInternedVar(lang.NewSymbol("nth")) + if v45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + } + v46 := v45.Get() + v47 := lang.Apply(v46, []any{v43, int64(0), nil}) + var v48 any = v47 + _ = v48 + // let binding "a-val" + v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v50 := v49.FindInternedVar(lang.NewSymbol("nth")) + if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) + } + v51 := v50.Get() + v52 := lang.Apply(v51, []any{v43, int64(1), nil}) + var v53 any = v52 + _ = v53 + v54, _ := lang.FieldOrMethod(v48, "bindRoot") + if reflect.TypeOf(v54).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("bindRoot is not a function"))) + } + v55 := lang.Apply(v54, []any{v53}) + _ = v55 + v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v58 := v57.FindInternedVar(lang.NewSymbol("next")) + if v58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) + } + v59 := v58.Get() + v60 := lang.Apply(v59, []any{v31}) + var v56 any = v60 + var v61 any = nil + var v62 any = int64(0) + var v63 any = int64(0) + v13 = v56 + v14 = v61 + v15 = v62 + v16 = v63 + continue + } // end let + v32 = v38 + } + v30 = v32 + } // end let + v29 = v30 + } else { + v29 = nil + } + v23 = v29 + } // end let + v17 = v23 + } + v8 = v17 + break + } + } // end let + return v8 + }) + v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7533), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(7535), lang.NewKeyword("end-column"), int(93)) + v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v9 any = v8 + _ = v9 + // let binding "old-vals" + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("zipmap")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v14 := v13.FindInternedVar(lang.NewSymbol("keys")) + if v14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + } + v15 := v14.Get() + v16 := lang.Apply(v15, []any{v3}) + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("map")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + var v20 lang.FnFunc + v20 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v21 := args[0] + _ = v21 + v22, ok := lang.FieldOrMethod(v21, "getRawRoot") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v21, "getRawRoot"))) + } + var v23 any + switch reflect.TypeOf(v22).Kind() { + case reflect.Func: + v23 = lang.Apply(v22, nil) + default: + v23 = v22 + } + return v23 + }) + v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7537), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(7537), lang.NewKeyword("end-column"), int(92)) + v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v24 := v23.FindInternedVar(lang.NewSymbol("keys")) + if v24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + } + v25 := v24.Get() + v26 := lang.Apply(v25, []any{v3}) + v27 := lang.Apply(v19, []any{v22, v26}) + v28 := lang.Apply(v12, []any{v16, v27}) + var v29 any = v28 + _ = v29 + var v30 any + func() { + defer func() { + v31 := lang.Apply(v9, []any{v29}) + }() + v32 := lang.Apply(v9, []any{v3}) + _ = v32 + v33 := lang.Apply(v4, nil) + v30 = v33 + }() + v5 = v30 + } // end let + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // xml-seq + { + v0 := lang.NewSymbol("xml-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("root"))), lang.NewKeyword("doc"), "A tree seq on the xml elements as per xml/parse", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4982), lang.NewKeyword("end-line"), int(4982))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("tree-seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("complement")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("string?")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v9, []any{v12}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("comp")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("seq")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.Apply(v16, []any{v19, lang.NewKeyword("content")}) + v21 := lang.Apply(v6, []any{v13, v20, v3}) + return v21 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // zero? + { + var v1 lang.FnFunc + { // function zero?__inliner + v1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v5 := v4.FindInternedVar(lang.NewSymbol("seq")) + if v5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + } + v6 := v5.Get() + v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v8 := v7.FindInternedVar(lang.NewSymbol("concat")) + if v8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + } + v9 := v8.Get() + v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v11 := v10.FindInternedVar(lang.NewSymbol("list")) + if v11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + } + v12 := v11.Get() + v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("list")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v19 := v18.FindInternedVar(lang.NewSymbol("list")) + if v19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + } + v20 := v19.Get() + v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v22 := v21.FindInternedVar(lang.NewSymbol("seq")) + if v22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + } + v23 := v22.Get() + v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v25 := v24.FindInternedVar(lang.NewSymbol("concat")) + if v25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + } + v26 := v25.Get() + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("list")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/IsZero")}) + v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v32 := v31.FindInternedVar(lang.NewSymbol("list")) + if v32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + } + v33 := v32.Get() + v34 := lang.Apply(v33, []any{v3}) + v35 := lang.Apply(v26, []any{v30, v34}) + v36 := lang.Apply(v23, []any{v35}) + v37 := lang.Apply(v20, []any{v36}) + v38 := lang.Apply(v9, []any{v13, v17, v37}) + v39 := lang.Apply(v6, []any{v38}) + return v39 + }) + v2 := v1 + _ = v2 + } + v0 := lang.NewSymbol("zero?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns true if num is zero, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(860), lang.NewKeyword("end-line"), int(860))).(*lang.Symbol) + var v3 lang.FnFunc + v3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5, _ := lang.FieldOrMethod(lang.Numbers, "IsZero") + if reflect.TypeOf(v5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("IsZero is not a function"))) + } + v6 := lang.Apply(v5, []any{v4}) + return v6 + }) + v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v2 := ns.InternWithValue(v0, v3, true) + if v0.Meta() != nil { + v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } + // zipmap + { + v0 := lang.NewSymbol("zipmap").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("keys"), lang.NewSymbol("vals"))), lang.NewKeyword("doc"), "Returns a map with the keys mapped to the corresponding vals.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6583), lang.NewKeyword("end-line"), int(6583))).(*lang.Symbol) + var v2 lang.FnFunc + v2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any + { // let + // let binding "map" + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("transient")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.NewMap() + v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6588), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(6588), lang.NewKeyword("end-column"), int(28)) + v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + v12 := lang.Apply(v8, []any{v11}) + var v13 any = v12 + _ = v13 + // let binding "ks" + v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v15 := v14.FindInternedVar(lang.NewSymbol("seq")) + if v15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + } + v16 := v15.Get() + v17 := lang.Apply(v16, []any{v3}) + var v18 any = v17 + _ = v18 + // let binding "vs" + v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v20 := v19.FindInternedVar(lang.NewSymbol("seq")) + if v20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + } + v21 := v20.Get() + v22 := lang.Apply(v21, []any{v4}) + var v23 any = v22 + _ = v23 + for { + var v24 any + var v25 any + { // let + // let binding "and__0__auto__" + var v26 any = v18 + _ = v26 + var v27 any + if lang.IsTruthy(v26) { + v27 = v23 + } else { + v27 = v26 + } + v25 = v27 + } // end let + if lang.IsTruthy(v25) { + v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v28 := v27.FindInternedVar(lang.NewSymbol("assoc!")) + if v28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + } + v29 := v28.Get() + v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v31 := v30.FindInternedVar(lang.NewSymbol("first")) + if v31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + } + v32 := v31.Get() + v33 := lang.Apply(v32, []any{v18}) + v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v35 := v34.FindInternedVar(lang.NewSymbol("first")) + if v35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + } + v36 := v35.Get() + v37 := lang.Apply(v36, []any{v23}) + v38 := lang.Apply(v29, []any{v13, v33, v37}) + var v26 any = v38 + v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v41 := v40.FindInternedVar(lang.NewSymbol("next")) + if v41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + } + v42 := v41.Get() + v43 := lang.Apply(v42, []any{v18}) + var v39 any = v43 + v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v46 := v45.FindInternedVar(lang.NewSymbol("next")) + if v46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) + } + v47 := v46.Get() + v48 := lang.Apply(v47, []any{v23}) + var v44 any = v48 + v13 = v26 + v18 = v39 + v23 = v44 + continue + } else { + v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v50 := v49.FindInternedVar(lang.NewSymbol("persistent!")) + if v50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) + } + v51 := v50.Get() + v52 := lang.Apply(v51, []any{v13}) + v24 = v52 + } + v5 = v24 + break + } + } // end let + return v5 + }) + v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + v1 := ns.InternWithValue(v0, v2, true) + if v0.Meta() != nil { + v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + } + } +} diff --git a/pkg/codegen/testdata/codegen/test/def_simple.go b/pkg/codegen/testdata/codegen/test/def_simple.go index dc09bc97..854fe012 100644 --- a/pkg/codegen/testdata/codegen/test/def_simple.go +++ b/pkg/codegen/testdata/codegen/test/def_simple.go @@ -3,10 +3,13 @@ package generated import ( + fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" ) func init() { + // reference fmt to avoid unused import error + _ = fmt.Printf ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.def-simple")) _ = ns // foo diff --git a/pkg/codegen/testdata/codegen/test/fn_closure.go b/pkg/codegen/testdata/codegen/test/fn_closure.go index 67daf554..6726df74 100644 --- a/pkg/codegen/testdata/codegen/test/fn_closure.go +++ b/pkg/codegen/testdata/codegen/test/fn_closure.go @@ -9,10 +9,18 @@ import ( func init() { // Closed-over values - var closed0 = int64(42) - v0 := lang.NewAtom(int64(0)) - var closed1 = v0 + var closed0 any + { + closed0 = int64(42) + } + var closed1 any + { + v0 := lang.NewAtom(int64(0)) + closed1 = v0 + } + // reference fmt to avoid unused import error + _ = fmt.Printf ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.fn-closure")) _ = ns // -main @@ -84,6 +92,7 @@ func init() { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] + _ = v3 var v4 lang.FnFunc v4 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { diff --git a/pkg/codegen/testdata/codegen/test/fn_recur.go b/pkg/codegen/testdata/codegen/test/fn_recur.go index dcc7ceef..bbfdff3c 100644 --- a/pkg/codegen/testdata/codegen/test/fn_recur.go +++ b/pkg/codegen/testdata/codegen/test/fn_recur.go @@ -8,6 +8,8 @@ import ( ) func init() { + // reference fmt to avoid unused import error + _ = fmt.Printf ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.fn-recur")) _ = ns // -main @@ -42,63 +44,72 @@ func init() { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] - var v5 lang.FnFunc - { // function fib-helper - v5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v7 := args[0] - v8 := args[1] - v9 := args[2] - recur_loop_1612: - var v10 any - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("=")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{v9, v3}) - if lang.IsTruthy(v14) { - v10 = v7 - } else { - var v15 any = v8 - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("+")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + _ = v3 + var v4 any + { // let + // let binding "fib-helper" + var v5 lang.FnFunc + { // function fib-helper + v5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v19 := v18.Get() - v20 := lang.Apply(v19, []any{v7, v8}) - var v16 any = v20 - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("inc")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + recur_loop_1612: + var v10 any + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("=")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v9}) - var v21 any = v25 - v7 = v15 - v8 = v16 - v9 = v21 - goto recur_loop_1612 - } - return v10 - }) - v6 := v5 - _ = v6 - } - v6 := lang.NewMap(lang.NewKeyword("file"), "codegen/test/fn_recur.glj", lang.NewKeyword("line"), int(6), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(9), lang.NewKeyword("end-column"), int(50)) - v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v4 any = v7 - _ = v4 - v9 := lang.Apply(v4, []any{int64(0), int64(1), int64(0)}) - return v9 + v13 := v12.Get() + v14 := lang.Apply(v13, []any{v9, v3}) + if lang.IsTruthy(v14) { + v10 = v7 + } else { + var v15 any = v8 + v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v18 := v17.FindInternedVar(lang.NewSymbol("+")) + if v18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + } + v19 := v18.Get() + v20 := lang.Apply(v19, []any{v7, v8}) + var v16 any = v20 + v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v23 := v22.FindInternedVar(lang.NewSymbol("inc")) + if v23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + } + v24 := v23.Get() + v25 := lang.Apply(v24, []any{v9}) + var v21 any = v25 + v7 = v15 + v8 = v16 + v9 = v21 + goto recur_loop_1612 + } + return v10 + }) + v6 := v5 + _ = v6 + } + v6 := lang.NewMap(lang.NewKeyword("file"), "codegen/test/fn_recur.glj", lang.NewKeyword("line"), int(6), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(9), lang.NewKeyword("end-column"), int(50)) + v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v8 any = v7 + _ = v8 + v9 := lang.Apply(v8, []any{int64(0), int64(1), int64(0)}) + v4 = v9 + } // end let + return v4 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) diff --git a/pkg/codegen/testdata/codegen/test/loop_simple.go b/pkg/codegen/testdata/codegen/test/loop_simple.go index 2645677d..14641a34 100644 --- a/pkg/codegen/testdata/codegen/test/loop_simple.go +++ b/pkg/codegen/testdata/codegen/test/loop_simple.go @@ -8,6 +8,8 @@ import ( ) func init() { + // reference fmt to avoid unused import error + _ = fmt.Printf ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.loop-simple")) _ = ns // -main @@ -41,36 +43,39 @@ func init() { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - var v3 any = int64(0) - _ = v3 - var v4 any - for { - var v5 any - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("<")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{v3, int64(10)}) - if lang.IsTruthy(v9) { - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("inc")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + var v3 any + { // let + // let binding "i" + var v4 any = int64(0) + _ = v4 + for { + var v5 any + v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v7 := v6.FindInternedVar(lang.NewSymbol("<")) + if v7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + } + v8 := v7.Get() + v9 := lang.Apply(v8, []any{v4, int64(10)}) + if lang.IsTruthy(v9) { + v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + v12 := v11.FindInternedVar(lang.NewSymbol("inc")) + if v12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + } + v13 := v12.Get() + v14 := lang.Apply(v13, []any{v4}) + var v10 any = v14 + v4 = v10 + continue + } else { + v5 = v4 } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{v3}) - var v10 any = v14 - v3 = v10 - continue - } else { - v5 = v3 + v3 = v5 + break } - v4 = v5 - break - } - return v4 + } // end let + return v3 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) diff --git a/pkg/codegen/testdata/codegen/test/maybe_class.go b/pkg/codegen/testdata/codegen/test/maybe_class.go index 45b02008..e66462e6 100644 --- a/pkg/codegen/testdata/codegen/test/maybe_class.go +++ b/pkg/codegen/testdata/codegen/test/maybe_class.go @@ -9,6 +9,8 @@ import ( ) func init() { + // reference fmt to avoid unused import error + _ = fmt.Printf ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.maybe-class")) _ = ns // -main diff --git a/pkg/codegen/testdata/codegen/test/ns_skip.go b/pkg/codegen/testdata/codegen/test/ns_skip.go index 08024417..64042a3f 100644 --- a/pkg/codegen/testdata/codegen/test/ns_skip.go +++ b/pkg/codegen/testdata/codegen/test/ns_skip.go @@ -3,10 +3,13 @@ package generated import ( + fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" ) func init() { + // reference fmt to avoid unused import error + _ = fmt.Printf ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.ns-skip")) _ = ns } diff --git a/pkg/codegen/testdata/codegen/test/quote_simple.go b/pkg/codegen/testdata/codegen/test/quote_simple.go index b8a62159..ad0d5a66 100644 --- a/pkg/codegen/testdata/codegen/test/quote_simple.go +++ b/pkg/codegen/testdata/codegen/test/quote_simple.go @@ -8,6 +8,8 @@ import ( ) func init() { + // reference fmt to avoid unused import error + _ = fmt.Printf ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.quote-simple")) _ = ns // -main diff --git a/pkg/codegen/testdata/codegen/test/the_var.go b/pkg/codegen/testdata/codegen/test/the_var.go index 36f0b19b..7657f608 100644 --- a/pkg/codegen/testdata/codegen/test/the_var.go +++ b/pkg/codegen/testdata/codegen/test/the_var.go @@ -9,6 +9,8 @@ import ( ) func init() { + // reference fmt to avoid unused import error + _ = fmt.Printf ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.the-var")) _ = ns // -main diff --git a/pkg/codegen/testdata/codegen/test/throw_simple.go b/pkg/codegen/testdata/codegen/test/throw_simple.go index 176740b9..b7d50246 100644 --- a/pkg/codegen/testdata/codegen/test/throw_simple.go +++ b/pkg/codegen/testdata/codegen/test/throw_simple.go @@ -8,6 +8,8 @@ import ( ) func init() { + // reference fmt to avoid unused import error + _ = fmt.Printf ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.throw-simple")) _ = ns // -main diff --git a/pkg/codegen/testdata/codegen/test/try_advanced.go b/pkg/codegen/testdata/codegen/test/try_advanced.go index 95874b81..a5de465c 100644 --- a/pkg/codegen/testdata/codegen/test/try_advanced.go +++ b/pkg/codegen/testdata/codegen/test/try_advanced.go @@ -8,6 +8,8 @@ import ( ) func init() { + // reference fmt to avoid unused import error + _ = fmt.Printf ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-advanced")) _ = ns // -main @@ -118,24 +120,29 @@ func init() { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - var v3 any = "outer" - _ = v3 - var v5 any - func() { - defer func() { - if r := recover(); r != nil { - if lang.CatchMatches(r, lang.Builtins["any"]) { - v6 := r - _ = v6 - v5 = v6 - } else { - panic(r) + var v3 any + { // let + // let binding "e" + var v4 any = "outer" + _ = v4 + var v5 any + func() { + defer func() { + if r := recover(); r != nil { + if lang.CatchMatches(r, lang.Builtins["any"]) { + v6 := r + _ = v6 + v5 = v6 + } else { + panic(r) + } } - } + }() + panic("test") }() - panic("test") - }() - return v5 + v3 = v5 + } // end let + return v3 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) v1 := ns.InternWithValue(v0, v2, true) @@ -151,24 +158,29 @@ func init() { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - var v3 any = "outer" - _ = v3 - var v5 any - func() { - defer func() { - if r := recover(); r != nil { - if lang.CatchMatches(r, lang.Builtins["any"]) { - v6 := r - _ = v6 - v5 = v6 - } else { - panic(r) + var v3 any + { // let + // let binding "e" + var v4 any = "outer" + _ = v4 + var v5 any + func() { + defer func() { + if r := recover(); r != nil { + if lang.CatchMatches(r, lang.Builtins["any"]) { + v6 := r + _ = v6 + v5 = v6 + } else { + panic(r) + } } - } + }() + panic("test") }() - panic("test") - }() - _ = v5 + _ = v5 + v3 = v4 + } // end let return v3 }) v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) diff --git a/pkg/codegen/testdata/codegen/test/try_basic.go b/pkg/codegen/testdata/codegen/test/try_basic.go index 8c22b674..81d9d9cf 100644 --- a/pkg/codegen/testdata/codegen/test/try_basic.go +++ b/pkg/codegen/testdata/codegen/test/try_basic.go @@ -8,6 +8,8 @@ import ( ) func init() { + // reference fmt to avoid unused import error + _ = fmt.Printf ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")) _ = ns // -main diff --git a/pkg/codegen/testdata/codegen/test/values.go b/pkg/codegen/testdata/codegen/test/values.go index 97bff87f..cbdadd38 100644 --- a/pkg/codegen/testdata/codegen/test/values.go +++ b/pkg/codegen/testdata/codegen/test/values.go @@ -3,21 +3,23 @@ package generated import ( - hex1 "encoding/hex" + hex2 "encoding/hex" fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" - big2 "math/big" + big3 "math/big" reflect "reflect" ) func init() { + // reference fmt to avoid unused import error + _ = fmt.Printf ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.values")) _ = ns // -main { - v1 := lang.NewBigDecimalFromBigFloat((func() *big2.Float { - var z big2.Float - b, _ := hex1.DecodeString("010a0000004000000004a000000000000000") + v1 := lang.NewBigDecimalFromBigFloat((func() *big3.Float { + var z big3.Float + b, _ := hex2.DecodeString("010a0000004000000004a000000000000000") if err := z.GobDecode(b); err != nil { panic(err) } @@ -59,9 +61,9 @@ func init() { // big-decimal { v0 := lang.NewSymbol("big-decimal").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/values.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.values")))).(*lang.Symbol) - v2 := lang.NewBigDecimalFromBigFloat((func() *big2.Float { - var z big2.Float - b, _ := hex1.DecodeString("010a0000004000000004a000000000000000") + v2 := lang.NewBigDecimalFromBigFloat((func() *big3.Float { + var z big3.Float + b, _ := hex2.DecodeString("010a0000004000000004a000000000000000") if err := z.GobDecode(b); err != nil { panic(err) } diff --git a/pkg/codegen/testdata/codegen/test/with_meta.go b/pkg/codegen/testdata/codegen/test/with_meta.go index 9b2c6d19..2d26aec0 100644 --- a/pkg/codegen/testdata/codegen/test/with_meta.go +++ b/pkg/codegen/testdata/codegen/test/with_meta.go @@ -8,6 +8,8 @@ import ( ) func init() { + // reference fmt to avoid unused import error + _ = fmt.Printf ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.with-meta")) _ = ns // -main diff --git a/pkg/stdlib/glojure/core.glj b/pkg/stdlib/glojure/core.glj index 45342cee..bba93707 100644 --- a/pkg/stdlib/glojure/core.glj +++ b/pkg/stdlib/glojure/core.glj @@ -6847,14 +6847,14 @@ fails, attempts to require sym's namespace and retries." (defn uuid? "Return true if x is a java.util.UUID" {:added "1.9"} - [x] (instance? github.com$google$uuid$uuid.UUID x)) + [x] (instance? github.com$google$uuid.UUID x)) (defn random-uuid {:doc "Returns a pseudo-randomly generated java.util.UUID instance (i.e. type 4). See: https://docs.oracle.com/javase/8/docs/api/java/util/UUID.html#randomUUID--" :added "1.11"} - ^github.com$google$uuid$uuid.UUID [] (github.com$google$uuid$uuid.NewV7)) + ^github.com$google$uuid.UUID [] (github.com$google$uuid.NewV7)) ;; redefine reduce with internal-reduce (defn reduce @@ -7949,7 +7949,7 @@ fails, attempts to require sym's namespace and retries." Grammar: https://docs.oracle.com/javase/8/docs/api/java/util/UUID.html#toString--" :added "1.11"} - ^github.com$google$uuid$uuid.UUID [^go/string s] + ^github.com$google$uuid.UUID [^go/string s] (try (let [[uuid err] (github.com$google$uuid.Parse s)] (if err (throw (github.com$glojurelang$glojure$pkg$lang.NewIllegalArgumentError (str "Error parsing UUID: " err))) uuid)) (catch github.com$glojurelang$glojure$pkg$lang.*IllegalArgumentError _ nil))) diff --git a/pkg/stdlib/glojure/uuid.glj b/pkg/stdlib/glojure/uuid.glj index 1adccc8f..39e22663 100644 --- a/pkg/stdlib/glojure/uuid.glj +++ b/pkg/stdlib/glojure/uuid.glj @@ -13,8 +13,8 @@ (java.util.UUID/fromString form) (throw (github.com$glojurelang$glojure$pkg$lang.NewIllegalArgumentError "#uuid data reader expected string")))) -(defmethod print-method github.com$google$uuid$uuid.UUID [uuid ^io.Writer w] +(defmethod print-method github.com$google$uuid.UUID [uuid ^io.Writer w] (github.com$glojurelang$glojure$pkg$lang.WriteWriter w (str "#uuid \"" (str uuid) "\""))) -(defmethod print-dup github.com$google$uuid$uuid.UUID [o w] +(defmethod print-dup github.com$google$uuid.UUID [o w] (print-method o w)) diff --git a/scripts/rewrite-core/rewrite.clj b/scripts/rewrite-core/rewrite.clj index 7736de1a..8417a5c3 100644 --- a/scripts/rewrite-core/rewrite.clj +++ b/scripts/rewrite-core/rewrite.clj @@ -279,7 +279,7 @@ (sexpr-replace 'java.net.URI 'net$url.URL) - (sexpr-replace 'java.util.UUID 'github.com$google$uuid$uuid.UUID) + (sexpr-replace 'java.util.UUID 'github.com$google$uuid.UUID) (sexpr-replace '(java.util.UUID/fromString s) '(let [[uuid err] (github.com$google$uuid.Parse s)] @@ -288,7 +288,7 @@ uuid))) (sexpr-replace '(java.util.UUID/randomUUID) - '(github.com$google$uuid$uuid.NewV7)) + '(github.com$google$uuid.NewV7)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; struct map From 0873d2d7639ce4031a8f541995eea3bf38c7f801 Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sat, 30 Aug 2025 17:30:11 -0700 Subject: [PATCH 44/67] ref, float64 Signed-off-by: James Hamlin --- pkg/codegen/codegen.go | 53 +- .../testdata/codegen/test/const_keyword.go | 8 +- .../testdata/codegen/test/const_number.go | 8 +- .../testdata/codegen/test/const_string.go | 8 +- pkg/codegen/testdata/codegen/test/core.go | 124736 ++++++++------- .../testdata/codegen/test/def_simple.go | 8 +- .../testdata/codegen/test/fn_closure.go | 168 +- pkg/codegen/testdata/codegen/test/fn_recur.go | 119 +- .../testdata/codegen/test/loop_simple.go | 82 +- .../testdata/codegen/test/maybe_class.go | 30 +- pkg/codegen/testdata/codegen/test/multifn.glj | 9 + .../testdata/codegen/test/quote_simple.go | 14 +- pkg/codegen/testdata/codegen/test/ref.glj | 10 + pkg/codegen/testdata/codegen/test/ref.go | 53 + pkg/codegen/testdata/codegen/test/the_var.go | 38 +- .../testdata/codegen/test/throw_simple.go | 14 +- .../testdata/codegen/test/try_advanced.go | 245 +- .../testdata/codegen/test/try_basic.go | 330 +- pkg/codegen/testdata/codegen/test/values.go | 66 +- .../testdata/codegen/test/with_meta.go | 40 +- pkg/gen/gljimports/gljimports_darwin_amd64.go | 1 + pkg/gen/gljimports/gljimports_darwin_arm64.go | 1 + pkg/gen/gljimports/gljimports_js_wasm.go | 1 + pkg/gen/gljimports/gljimports_linux_amd64.go | 1 + pkg/gen/gljimports/gljimports_linux_arm64.go | 1 + .../gljimports/gljimports_windows_amd64.go | 1 + pkg/gen/gljimports/gljimports_windows_arm.go | 1 + pkg/lang/bigdecimal.go | 4 + pkg/lang/persistentstructmap.go | 38 + 29 files changed, 63210 insertions(+), 62878 deletions(-) create mode 100644 pkg/codegen/testdata/codegen/test/multifn.glj create mode 100644 pkg/codegen/testdata/codegen/test/ref.glj create mode 100644 pkg/codegen/testdata/codegen/test/ref.go diff --git a/pkg/codegen/codegen.go b/pkg/codegen/codegen.go index 08588dd9..a79bb8c1 100644 --- a/pkg/codegen/codegen.go +++ b/pkg/codegen/codegen.go @@ -209,7 +209,6 @@ func (g *Generator) generateVar(nsVariableName string, name *lang.Symbol, vr *la g.pushVarScope() defer g.popVarScope() - fmt.Printf("Generating var: %s\n", name.String()) g.writef("// %s\n", name.String()) g.writef("{\n") defer g.writef("}\n") @@ -251,8 +250,9 @@ func (g *Generator) generateValue(value any) string { return g.generateTypeValue(v) case *lang.Atom: return g.generateAtomValue(v) + case *lang.Ref: + return g.generateRefValue(v) case *lang.Namespace: - // Generate code to find or create the namespace return fmt.Sprintf("lang.FindOrCreateNamespace(lang.NewSymbol(%#v))", v.Name().String()) case *runtime.Fn: return g.generateFn(v) @@ -262,6 +262,8 @@ func (g *Generator) generateValue(value any) string { return g.generateVectorValue(v) case lang.IPersistentSet: return g.generateSetValue(v) + case *lang.MultiFn: + return g.generateMultiFn(v) case lang.Keyword: if ns := v.Namespace(); ns != "" { return fmt.Sprintf("lang.NewKeyword(\"%s/%s\")", ns, v.Name()) @@ -279,6 +281,8 @@ func (g *Generator) generateValue(value any) string { return fmt.Sprintf("int(%d)", v) case int64: return fmt.Sprintf("int64(%d)", v) + case float64: + return fmt.Sprintf("float64(%g)", v) case *lang.BigDecimal: return g.generateBigDecimalValue(v) case bool: @@ -299,10 +303,7 @@ func (g *Generator) generateValue(value any) string { return fmt.Sprintf("lang.NewList(%s)", strings.Join(vals, ", ")) } - fmt.Println("Unsupported value type:", reflect.TypeOf(v), v) - return "nil" - // TODO: panic - //panic(fmt.Sprintf("unsupported value type %T: %s", v, v)) + panic(fmt.Sprintf("unsupported value type %T: %s", v, v)) } } @@ -365,7 +366,7 @@ func (g *Generator) generateZeroValueExpr(t reflect.Type) string { case reflect.String: return `""` case reflect.Array: - elemExpr := g.generateZeroValueExpr(t.Elem()) + elemExpr := g.getTypeString(t.Elem()) return fmt.Sprintf("[%d]%s{}", t.Len(), elemExpr) case reflect.Slice: elemType := g.getTypeString(t.Elem()) @@ -414,6 +415,8 @@ func (g *Generator) getTypeString(t reflect.Type) string { case reflect.Map: return fmt.Sprintf("map[%s]%s", g.getTypeString(t.Key()), g.getTypeString(t.Elem())) case reflect.Ptr: + fmt.Printf("Pointer to %s\n", t.Elem().String()) + fmt.Println("returning", "*"+g.getTypeString(t.Elem())) return "*" + g.getTypeString(t.Elem()) case reflect.Chan: switch t.ChanDir() { @@ -469,6 +472,13 @@ func (g *Generator) generateAtomValue(atom *lang.Atom) string { return atomVar } +func (g *Generator) generateRefValue(ref *lang.Ref) string { + refVar := g.allocateTempVar() + initialValue := g.generateValue(ref.Deref()) + g.writef("%s := lang.NewRef(%s)\n", refVar, initialValue) + return refVar +} + // generateMapValue generates Go code for a Clojure map func (g *Generator) generateMapValue(m lang.IPersistentMap) string { var buf bytes.Buffer @@ -540,7 +550,7 @@ func (g *Generator) generateBigDecimalValue(bd *lang.BigDecimal) string { // generateSetValue generates Go code for a Clojure set func (g *Generator) generateSetValue(s lang.IPersistentSet) string { var buf bytes.Buffer - buf.WriteString("lang.CreatePersistentTreeSet(") + buf.WriteString("lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{") idx := 0 @@ -555,11 +565,15 @@ func (g *Generator) generateSetValue(s lang.IPersistentSet) string { buf.WriteString(elementVar) } - buf.WriteString(")") + buf.WriteString("}))") return buf.String() } +func (g *Generator) generateMultiFn(mf *lang.MultiFn) string { + +} + func (g *Generator) generateFn(fn *runtime.Fn) string { // Save and restore current environment prevEnv := g.currentFnEnv @@ -589,8 +603,9 @@ func (g *Generator) generateFn(fn *runtime.Fn) string { defer g.writef("}\n") namedFnVar := g.allocateLocal(fnName) + g.writef("var %s lang.FnFunc\n", namedFnVar) defer func() { - g.writef("%s := %s\n", namedFnVar, fnVar) + g.writeAssign(namedFnVar, fnVar) g.writeAssign("_", namedFnVar) // Prevent unused variable warning }() } @@ -680,7 +695,8 @@ func (g *Generator) generateFnMethod(methodNode *ast.FnMethodNode, argsVar strin paramVars[i] = paramVar } else { // Variadic parameter - collect rest args - g.writef("%s := lang.NewList(%s[%d:]...)\n", paramVar, argsVar, methodNode.FixedArity) + g.writef("var %s any = lang.NewList(%s[%d:]...)\n", paramVar, argsVar, methodNode.FixedArity) + g.writeAssign("_", paramVar) // Prevent unused variable warning paramVars = append(paramVars, paramVar) } } @@ -705,7 +721,7 @@ func (g *Generator) generateFnMethod(methodNode *ast.FnMethodNode, argsVar strin // AST Node Generation // generateASTNode generates code for an AST node -func (g *Generator) generateASTNode(node *ast.Node) string { +func (g *Generator) generateASTNode(node *ast.Node) (res string) { switch node.Op { case ast.OpDef: fmt.Println("Def not yet implemented; returning nil") @@ -841,7 +857,7 @@ func (g *Generator) generateDo(node *ast.Node) string { continue } stmtResult := g.generateASTNode(stmt) - g.writeAssign("_", stmtResult) // Discard intermediate results + g.writeAssign("_", stmtResult) // Prevent unused variable warning } // Return the final expression @@ -1015,7 +1031,8 @@ func (g *Generator) generateTry(node *ast.Node) string { if tryNode.Finally != nil { g.writef("defer func() {\n") // Finally doesn't affect the return value - _ = g.generateASTNode(tryNode.Finally) + result := g.generateASTNode(tryNode.Finally) + g.writeAssign("_", result) // Prevent unused variable warning g.writef("}()\n") } @@ -1147,7 +1164,7 @@ func (g *Generator) generateSet(node *ast.Node) string { itemIds[i] = itemId } setId := g.allocateTempVar() - g.writef("%s := lang.CreatePersistentTreeSet(%s)\n", setId, strings.Join(itemIds, ", ")) + g.writef("%s := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{%s}))\n", setId, strings.Join(itemIds, ", ")) return setId } @@ -1178,7 +1195,7 @@ func (g *Generator) generateMaybeClass(node *ast.Node) string { // to pull in the package. if ok { if t, ok := v.(reflect.Type); ok { - return g.getTypeString(t) + return g.generateTypeValue(t) } } @@ -1368,7 +1385,7 @@ func (g *Generator) writef(format string, args ...any) error { // writeAssign writes an assignment iff the r-value string is non-empty func (g *Generator) writeAssign(varName, rValue string) { - if rValue == "" { + if rValue == "" || rValue == "nil" { return } g.writef("%s = %s\n", varName, rValue) @@ -1501,7 +1518,7 @@ func (g *Generator) allocateTempVar() string { } currentScope := &g.varScopes[len(g.varScopes)-1] - varName := fmt.Sprintf("v%d", currentScope.nextNum) + varName := fmt.Sprintf("tmp%d", currentScope.nextNum) currentScope.nextNum++ return varName } diff --git a/pkg/codegen/testdata/codegen/test/const_keyword.go b/pkg/codegen/testdata/codegen/test/const_keyword.go index 89c9b878..a98db605 100644 --- a/pkg/codegen/testdata/codegen/test/const_keyword.go +++ b/pkg/codegen/testdata/codegen/test/const_keyword.go @@ -14,10 +14,10 @@ func init() { _ = ns // const-keyword { - v0 := lang.NewSymbol("const-keyword").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/const_keyword.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.const-keyword")))).(*lang.Symbol) - v1 := ns.InternWithValue(v0, lang.NewKeyword("foo"), true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp0 := lang.NewSymbol("const-keyword").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/const_keyword.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.const-keyword")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, lang.NewKeyword("foo"), true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } } diff --git a/pkg/codegen/testdata/codegen/test/const_number.go b/pkg/codegen/testdata/codegen/test/const_number.go index cfad0c27..b2735819 100644 --- a/pkg/codegen/testdata/codegen/test/const_number.go +++ b/pkg/codegen/testdata/codegen/test/const_number.go @@ -14,10 +14,10 @@ func init() { _ = ns // const-number { - v0 := lang.NewSymbol("const-number").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/const_number.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("doc"), "A constant number.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.const-number")))).(*lang.Symbol) - v1 := ns.InternWithValue(v0, int64(42), true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp0 := lang.NewSymbol("const-number").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/const_number.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("doc"), "A constant number.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.const-number")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, int64(42), true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } } diff --git a/pkg/codegen/testdata/codegen/test/const_string.go b/pkg/codegen/testdata/codegen/test/const_string.go index 2c4b37e2..9afa194d 100644 --- a/pkg/codegen/testdata/codegen/test/const_string.go +++ b/pkg/codegen/testdata/codegen/test/const_string.go @@ -14,10 +14,10 @@ func init() { _ = ns // const-string { - v0 := lang.NewSymbol("const-string").WithMeta(lang.NewMap(lang.NewKeyword("hello"), true, lang.NewKeyword("file"), "codegen/test/const_string.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.const-string")))).(*lang.Symbol) - v1 := ns.InternWithValue(v0, "Hello, World!", true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp0 := lang.NewSymbol("const-string").WithMeta(lang.NewMap(lang.NewKeyword("hello"), true, lang.NewKeyword("file"), "codegen/test/const_string.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.const-string")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, "Hello, World!", true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } } diff --git a/pkg/codegen/testdata/codegen/test/core.go b/pkg/codegen/testdata/codegen/test/core.go index 61f7b98b..31c41726 100644 --- a/pkg/codegen/testdata/codegen/test/core.go +++ b/pkg/codegen/testdata/codegen/test/core.go @@ -56,29 +56,29 @@ func init() { } var closed16 any { - var v0 lang.FnFunc - v0 = lang.NewFnFunc(func(args ...any) any { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v1 := args[0] _ = v1 - var v2 any + var tmp2 any if lang.IsTruthy(v1) { - v2 = false + tmp2 = false } else { - v2 = true + tmp2 = true } - return v2 + return tmp2 }) - v1 := reflect.TypeOf(false) - v0 = v0.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v1)).(lang.FnFunc) - closed16 = v0 + tmp1 := reflect.TypeOf(false) + tmp0 = tmp0.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp1)).(lang.FnFunc) + closed16 = tmp0 } var closed17 any { - var v0 lang.FnFunc - v0 = lang.NewFnFunc(func(args ...any) any { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -87,74 +87,73 @@ func init() { v2 := args[1] _ = v2 recur_loop_481: - var v3 any + var tmp3 any { // let // let binding "temp__0__auto__" - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.Apply(v6, []any{v2}) - var v8 any = v7 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.Apply(tmp6, []any{v2}) + var v8 any = tmp7 _ = v8 - var v9 any + var tmp9 any if lang.IsTruthy(v8) { - var v10 any + var tmp10 any { // let // let binding "s" var v11 any = v8 _ = v11 - var v12 any + var tmp12 any { // let // let binding "or__0__auto__" - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("first")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{v11}) - v17 := lang.Apply(v1, []any{v16}) - var v18 any = v17 + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("first")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{v11}) + tmp17 := lang.Apply(v1, []any{tmp16}) + var v18 any = tmp17 _ = v18 - var v19 any + var tmp19 any if lang.IsTruthy(v18) { - v19 = v18 + tmp19 = v18 } else { - var v20 any = v1 - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("next")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + var tmp20 any = v1 + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("next")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v11}) - var v21 any = v25 - v1 = v20 - v2 = v21 + tmp24 := tmp23.Get() + tmp25 := lang.Apply(tmp24, []any{v11}) + var tmp21 any = tmp25 + v1 = tmp20 + v2 = tmp21 goto recur_loop_481 } - v12 = v19 + tmp12 = tmp19 } // end let - v10 = v12 + tmp10 = tmp12 } // end let - v9 = v10 + tmp9 = tmp10 } else { - v9 = nil } - v3 = v9 + tmp3 = tmp9 } // end let - return v3 + return tmp3 }) - v0 = v0.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - closed17 = v0 + tmp0 = tmp0.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + closed17 = tmp0 } var closed18 any { - var v0 lang.FnFunc - v0 = lang.NewFnFunc(func(args ...any) any { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -163,62 +162,61 @@ func init() { v2 := args[1] _ = v2 recur_loop_480: - var v3 any - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("nil?")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("seq")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v9, []any{v2}) - v11 := lang.Apply(v6, []any{v10}) - if lang.IsTruthy(v11) { - v3 = true + var tmp3 any + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("nil?")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("seq")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp9, []any{v2}) + tmp11 := lang.Apply(tmp6, []any{tmp10}) + if lang.IsTruthy(tmp11) { + tmp3 = true } else { - var v12 any - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("first")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{v2}) - v17 := lang.Apply(v1, []any{v16}) - if lang.IsTruthy(v17) { - var v18 any = v1 - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("next")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.Apply(v22, []any{v2}) - var v19 any = v23 - v1 = v18 - v2 = v19 + var tmp12 any + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("first")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{v2}) + tmp17 := lang.Apply(v1, []any{tmp16}) + if lang.IsTruthy(tmp17) { + var tmp18 any = v1 + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("next")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.Apply(tmp22, []any{v2}) + var tmp19 any = tmp23 + v1 = tmp18 + v2 = tmp19 goto recur_loop_480 } else { - var v24 any + var tmp24 any if lang.IsTruthy(lang.NewKeyword("else")) { - v24 = false + tmp24 = false } else { - v24 = nil } - v12 = v24 + tmp12 = tmp24 } - v3 = v12 + tmp3 = tmp12 } - return v3 + return tmp3 }) - v1 := reflect.TypeOf(false) - v0 = v0.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v1)).(lang.FnFunc) - closed18 = v0 + tmp1 := reflect.TypeOf(false) + tmp0 = tmp0.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp1)).(lang.FnFunc) + closed18 = tmp0 } var closed2 any { @@ -259,190 +257,190 @@ func init() { _ = ns // * { - var v1 lang.FnFunc - v1 = lang.NewFnFunc(func(args ...any) any { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v2 := args[0] _ = v2 - var v3 any + var tmp3 any { // let // let binding "op" - var v4 any - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - if lang.IsTruthy(v7) { - v4 = closed0 + var tmp4 any + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + if lang.IsTruthy(tmp7) { + tmp4 = closed0 } else { - v4 = closed1 + tmp4 = closed1 } - var v8 any = v4 + var v8 any = tmp4 _ = v8 - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("seq")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("concat")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("list")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("list")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("list")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("seq")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) - } - v28 := v27.Get() - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("concat")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("list")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{v8}) - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("list")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.Apply(v38, []any{v2}) - v40 := lang.Apply(v31, []any{v35, v39}) - v41 := lang.Apply(v28, []any{v40}) - v42 := lang.Apply(v25, []any{v41}) - v43 := lang.Apply(v14, []any{v18, v22, v42}) - v44 := lang.Apply(v11, []any{v43}) - v3 = v44 + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("seq")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("concat")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol(".")}) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("seq")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) + } + tmp28 := tmp27.Get() + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("concat")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.Apply(tmp34, []any{v8}) + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{v2}) + tmp40 := lang.Apply(tmp31, []any{tmp35, tmp39}) + tmp41 := lang.Apply(tmp28, []any{tmp40}) + tmp42 := lang.Apply(tmp25, []any{tmp41}) + tmp43 := lang.Apply(tmp14, []any{tmp18, tmp22, tmp42}) + tmp44 := lang.Apply(tmp11, []any{tmp43}) + tmp3 = tmp44 } // end let - return v3 + return tmp3 case 2: v2 := args[0] _ = v2 v3 := args[1] _ = v3 - var v4 any + var tmp4 any { // let // let binding "op" - var v5 any - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - if lang.IsTruthy(v8) { - v5 = closed0 + var tmp5 any + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + if lang.IsTruthy(tmp8) { + tmp5 = closed0 } else { - v5 = closed1 + tmp5 = closed1 } - var v9 any = v5 + var v9 any = tmp5 _ = v9 - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("seq")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("concat")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("list")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("list")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("list")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("seq")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("concat")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) - } - v32 := v31.Get() - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("list")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - v36 := lang.Apply(v35, []any{v9}) - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("list")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.Apply(v39, []any{v2}) - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("list")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) - } - v43 := v42.Get() - v44 := lang.Apply(v43, []any{v3}) - v45 := lang.Apply(v32, []any{v36, v40, v44}) - v46 := lang.Apply(v29, []any{v45}) - v47 := lang.Apply(v26, []any{v46}) - v48 := lang.Apply(v15, []any{v19, v23, v47}) - v49 := lang.Apply(v12, []any{v48}) - v4 = v49 + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("seq")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("concat")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("list")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{lang.NewSymbol(".")}) + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("list")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.Apply(tmp22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("list")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("seq")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("concat")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) + } + tmp32 := tmp31.Get() + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("list")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) + } + tmp35 := tmp34.Get() + tmp36 := lang.Apply(tmp35, []any{v9}) + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("list")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.Apply(tmp39, []any{v2}) + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("list")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := lang.Apply(tmp43, []any{v3}) + tmp45 := lang.Apply(tmp32, []any{tmp36, tmp40, tmp44}) + tmp46 := lang.Apply(tmp29, []any{tmp45}) + tmp47 := lang.Apply(tmp26, []any{tmp46}) + tmp48 := lang.Apply(tmp15, []any{tmp19, tmp23, tmp47}) + tmp49 := lang.Apply(tmp12, []any{tmp48}) + tmp4 = tmp49 } // end let - return v4 + return tmp4 default: if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -451,32 +449,33 @@ func init() { _ = v2 v3 := args[1] _ = v3 - v4 := lang.NewList(args[2:]...) - var v5 any + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any { // let // let binding "op" - var v6 any - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - if lang.IsTruthy(v9) { - v6 = closed0 + var tmp6 any + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + if lang.IsTruthy(tmp9) { + tmp6 = closed0 } else { - v6 = closed1 + tmp6 = closed1 } - var v10 any = v6 + var v10 any = tmp6 _ = v10 - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - var v14 lang.FnFunc - v14 = lang.NewFnFunc(func(args ...any) any { + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -484,197 +483,197 @@ func init() { _ = v15 v16 := args[1] _ = v16 - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("seq")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("concat")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("list")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("seq")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) - } - v36 := v35.Get() - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("concat")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("list")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) - } - v42 := v41.Get() - v43 := lang.Apply(v42, []any{v10}) - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("list")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) - } - v46 := v45.Get() - v47 := lang.Apply(v46, []any{v15}) - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("list")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v16}) - v52 := lang.Apply(v39, []any{v43, v47, v51}) - v53 := lang.Apply(v36, []any{v52}) - v54 := lang.Apply(v33, []any{v53}) - v55 := lang.Apply(v22, []any{v26, v30, v54}) - v56 := lang.Apply(v19, []any{v55}) - return v56 + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("concat")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol(".")}) + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) + } + tmp42 := tmp41.Get() + tmp43 := lang.Apply(tmp42, []any{v10}) + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) + } + tmp46 := tmp45.Get() + tmp47 := lang.Apply(tmp46, []any{v15}) + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v16}) + tmp52 := lang.Apply(tmp39, []any{tmp43, tmp47, tmp51}) + tmp53 := lang.Apply(tmp36, []any{tmp52}) + tmp54 := lang.Apply(tmp33, []any{tmp53}) + tmp55 := lang.Apply(tmp22, []any{tmp26, tmp30, tmp54}) + tmp56 := lang.Apply(tmp19, []any{tmp55}) + return tmp56 }) - v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) - v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) + tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) if err != nil { panic(err) } - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("seq")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("concat")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("list")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("seq")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) - } - v36 := v35.Get() - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("concat")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("list")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) - } - v42 := v41.Get() - v43 := lang.Apply(v42, []any{v10}) - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("list")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) - } - v46 := v45.Get() - v47 := lang.Apply(v46, []any{v2}) - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("list")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v3}) - v52 := lang.Apply(v39, []any{v43, v47, v51}) - v53 := lang.Apply(v36, []any{v52}) - v54 := lang.Apply(v33, []any{v53}) - v55 := lang.Apply(v22, []any{v26, v30, v54}) - v56 := lang.Apply(v19, []any{v55}) - v57 := lang.Apply(v13, []any{v16, v56, v4}) - v5 = v57 + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("concat")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol(".")}) + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) + } + tmp42 := tmp41.Get() + tmp43 := lang.Apply(tmp42, []any{v10}) + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) + } + tmp46 := tmp45.Get() + tmp47 := lang.Apply(tmp46, []any{v2}) + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v3}) + tmp52 := lang.Apply(tmp39, []any{tmp43, tmp47, tmp51}) + tmp53 := lang.Apply(tmp36, []any{tmp52}) + tmp54 := lang.Apply(tmp33, []any{tmp53}) + tmp55 := lang.Apply(tmp22, []any{tmp26, tmp30, tmp54}) + tmp56 := lang.Apply(tmp19, []any{tmp55}) + tmp57 := lang.Apply(tmp13, []any{tmp16, tmp56, v4}) + tmp5 = tmp57 } // end let - return v5 + return tmp5 } }) - v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp1 = tmp1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") - if reflect.TypeOf(v4).Kind() != reflect.Func { + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - v5 := lang.Apply(v4, []any{nil, int64(1)}) - return v5 + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v0 := lang.NewSymbol("*").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the product of nums. (*) returns 1. Does not auto-promote\n longs, will throw on overflow. See also: *'", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1001), lang.NewKeyword("end-line"), int(1001))).(*lang.Symbol) - var v4 lang.FnFunc - v4 = lang.NewFnFunc(func(args ...any) any { + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp0 := lang.NewSymbol("*").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the product of nums. (*) returns 1. Does not auto-promote\n longs, will throw on overflow. See also: *'", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), tmp2, lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1001), lang.NewKeyword("end-line"), int(1001))).(*lang.Symbol) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: return int64(1) case 1: v5 := args[0] _ = v5 - v6 := lang.Apply(lang.MustAsNumber, []any{v5}) - return v6 + tmp6 := lang.Apply(lang.MustAsNumber, []any{v5}) + return tmp6 case 2: v5 := args[0] _ = v5 v6 := args[1] _ = v6 - v7, _ := lang.FieldOrMethod(lang.Numbers, "Multiply") - if reflect.TypeOf(v7).Kind() != reflect.Func { + tmp7, _ := lang.FieldOrMethod(lang.Numbers, "Multiply") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Multiply is not a function"))) } - v8 := lang.Apply(v7, []any{v5, v6}) - return v8 + tmp8 := lang.Apply(tmp7, []any{v5, v6}) + return tmp8 default: if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -683,222 +682,223 @@ func init() { _ = v5 v6 := args[1] _ = v6 - v7 := lang.NewList(args[2:]...) - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + var v7 any = lang.NewList(args[2:]...) + _ = v7 + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("*")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("*")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) } - v13 := v12.Get() - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("*")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + tmp13 := tmp12.Get() + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("*")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{v5, v6}) - v18 := lang.Apply(v10, []any{v13, v17, v7}) - return v18 + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{v5, v6}) + tmp18 := lang.Apply(tmp10, []any{tmp13, tmp17, v7}) + return tmp18 } }) - v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v3 := ns.InternWithValue(v0, v4, true) - if v0.Meta() != nil { - v3.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 := ns.InternWithValue(tmp0, tmp4, true) + if tmp0.Meta() != nil { + tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // *' { - var v1 lang.FnFunc - v1 = lang.NewFnFunc(func(args ...any) any { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v2 := args[0] _ = v2 - var v3 any + var tmp3 any { // let // let binding "op" - var v4 any - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - if lang.IsTruthy(v7) { - v4 = closed2 + var tmp4 any + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + if lang.IsTruthy(tmp7) { + tmp4 = closed2 } else { - v4 = closed2 + tmp4 = closed2 } - var v8 any = v4 + var v8 any = tmp4 _ = v8 - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("seq")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("concat")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("list")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("list")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("list")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("seq")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) - } - v28 := v27.Get() - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("concat")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("list")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{v8}) - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("list")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.Apply(v38, []any{v2}) - v40 := lang.Apply(v31, []any{v35, v39}) - v41 := lang.Apply(v28, []any{v40}) - v42 := lang.Apply(v25, []any{v41}) - v43 := lang.Apply(v14, []any{v18, v22, v42}) - v44 := lang.Apply(v11, []any{v43}) - v3 = v44 + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("seq")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("concat")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol(".")}) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("seq")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) + } + tmp28 := tmp27.Get() + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("concat")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.Apply(tmp34, []any{v8}) + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{v2}) + tmp40 := lang.Apply(tmp31, []any{tmp35, tmp39}) + tmp41 := lang.Apply(tmp28, []any{tmp40}) + tmp42 := lang.Apply(tmp25, []any{tmp41}) + tmp43 := lang.Apply(tmp14, []any{tmp18, tmp22, tmp42}) + tmp44 := lang.Apply(tmp11, []any{tmp43}) + tmp3 = tmp44 } // end let - return v3 + return tmp3 case 2: v2 := args[0] _ = v2 v3 := args[1] _ = v3 - var v4 any + var tmp4 any { // let // let binding "op" - var v5 any - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - if lang.IsTruthy(v8) { - v5 = closed2 + var tmp5 any + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + if lang.IsTruthy(tmp8) { + tmp5 = closed2 } else { - v5 = closed2 + tmp5 = closed2 } - var v9 any = v5 + var v9 any = tmp5 _ = v9 - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("seq")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("concat")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("list")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("list")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("list")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("seq")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("concat")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) - } - v32 := v31.Get() - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("list")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - v36 := lang.Apply(v35, []any{v9}) - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("list")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.Apply(v39, []any{v2}) - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("list")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) - } - v43 := v42.Get() - v44 := lang.Apply(v43, []any{v3}) - v45 := lang.Apply(v32, []any{v36, v40, v44}) - v46 := lang.Apply(v29, []any{v45}) - v47 := lang.Apply(v26, []any{v46}) - v48 := lang.Apply(v15, []any{v19, v23, v47}) - v49 := lang.Apply(v12, []any{v48}) - v4 = v49 + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("seq")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("concat")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("list")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{lang.NewSymbol(".")}) + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("list")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.Apply(tmp22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("list")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("seq")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("concat")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) + } + tmp32 := tmp31.Get() + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("list")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) + } + tmp35 := tmp34.Get() + tmp36 := lang.Apply(tmp35, []any{v9}) + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("list")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.Apply(tmp39, []any{v2}) + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("list")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := lang.Apply(tmp43, []any{v3}) + tmp45 := lang.Apply(tmp32, []any{tmp36, tmp40, tmp44}) + tmp46 := lang.Apply(tmp29, []any{tmp45}) + tmp47 := lang.Apply(tmp26, []any{tmp46}) + tmp48 := lang.Apply(tmp15, []any{tmp19, tmp23, tmp47}) + tmp49 := lang.Apply(tmp12, []any{tmp48}) + tmp4 = tmp49 } // end let - return v4 + return tmp4 default: if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -907,32 +907,33 @@ func init() { _ = v2 v3 := args[1] _ = v3 - v4 := lang.NewList(args[2:]...) - var v5 any + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any { // let // let binding "op" - var v6 any - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - if lang.IsTruthy(v9) { - v6 = closed2 + var tmp6 any + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + if lang.IsTruthy(tmp9) { + tmp6 = closed2 } else { - v6 = closed2 + tmp6 = closed2 } - var v10 any = v6 + var v10 any = tmp6 _ = v10 - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - var v14 lang.FnFunc - v14 = lang.NewFnFunc(func(args ...any) any { + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -940,197 +941,197 @@ func init() { _ = v15 v16 := args[1] _ = v16 - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("seq")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("concat")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("list")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("seq")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) - } - v36 := v35.Get() - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("concat")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("list")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) - } - v42 := v41.Get() - v43 := lang.Apply(v42, []any{v10}) - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("list")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) - } - v46 := v45.Get() - v47 := lang.Apply(v46, []any{v15}) - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("list")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v16}) - v52 := lang.Apply(v39, []any{v43, v47, v51}) - v53 := lang.Apply(v36, []any{v52}) - v54 := lang.Apply(v33, []any{v53}) - v55 := lang.Apply(v22, []any{v26, v30, v54}) - v56 := lang.Apply(v19, []any{v55}) - return v56 + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("concat")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol(".")}) + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) + } + tmp42 := tmp41.Get() + tmp43 := lang.Apply(tmp42, []any{v10}) + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) + } + tmp46 := tmp45.Get() + tmp47 := lang.Apply(tmp46, []any{v15}) + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v16}) + tmp52 := lang.Apply(tmp39, []any{tmp43, tmp47, tmp51}) + tmp53 := lang.Apply(tmp36, []any{tmp52}) + tmp54 := lang.Apply(tmp33, []any{tmp53}) + tmp55 := lang.Apply(tmp22, []any{tmp26, tmp30, tmp54}) + tmp56 := lang.Apply(tmp19, []any{tmp55}) + return tmp56 }) - v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) - v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) + tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) if err != nil { panic(err) } - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("seq")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("concat")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("list")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("seq")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) - } - v36 := v35.Get() - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("concat")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("list")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) - } - v42 := v41.Get() - v43 := lang.Apply(v42, []any{v10}) - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("list")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) - } - v46 := v45.Get() - v47 := lang.Apply(v46, []any{v2}) - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("list")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v3}) - v52 := lang.Apply(v39, []any{v43, v47, v51}) - v53 := lang.Apply(v36, []any{v52}) - v54 := lang.Apply(v33, []any{v53}) - v55 := lang.Apply(v22, []any{v26, v30, v54}) - v56 := lang.Apply(v19, []any{v55}) - v57 := lang.Apply(v13, []any{v16, v56, v4}) - v5 = v57 + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("concat")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol(".")}) + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) + } + tmp42 := tmp41.Get() + tmp43 := lang.Apply(tmp42, []any{v10}) + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) + } + tmp46 := tmp45.Get() + tmp47 := lang.Apply(tmp46, []any{v2}) + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v3}) + tmp52 := lang.Apply(tmp39, []any{tmp43, tmp47, tmp51}) + tmp53 := lang.Apply(tmp36, []any{tmp52}) + tmp54 := lang.Apply(tmp33, []any{tmp53}) + tmp55 := lang.Apply(tmp22, []any{tmp26, tmp30, tmp54}) + tmp56 := lang.Apply(tmp19, []any{tmp55}) + tmp57 := lang.Apply(tmp13, []any{tmp16, tmp56, v4}) + tmp5 = tmp57 } // end let - return v5 + return tmp5 } }) - v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp1 = tmp1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") - if reflect.TypeOf(v4).Kind() != reflect.Func { + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - v5 := lang.Apply(v4, []any{nil, int64(1)}) - return v5 + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v0 := lang.NewSymbol("*'").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the product of nums. (*') returns 1. Supports arbitrary precision.\n See also: *", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(989), lang.NewKeyword("end-line"), int(989))).(*lang.Symbol) - var v4 lang.FnFunc - v4 = lang.NewFnFunc(func(args ...any) any { + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp0 := lang.NewSymbol("*'").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the product of nums. (*') returns 1. Supports arbitrary precision.\n See also: *", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), tmp2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(989), lang.NewKeyword("end-line"), int(989))).(*lang.Symbol) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: return int64(1) case 1: v5 := args[0] _ = v5 - v6 := lang.Apply(lang.MustAsNumber, []any{v5}) - return v6 + tmp6 := lang.Apply(lang.MustAsNumber, []any{v5}) + return tmp6 case 2: v5 := args[0] _ = v5 v6 := args[1] _ = v6 - v7, _ := lang.FieldOrMethod(lang.Numbers, "MultiplyP") - if reflect.TypeOf(v7).Kind() != reflect.Func { + tmp7, _ := lang.FieldOrMethod(lang.Numbers, "MultiplyP") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("MultiplyP is not a function"))) } - v8 := lang.Apply(v7, []any{v5, v6}) - return v8 + tmp8 := lang.Apply(tmp7, []any{v5, v6}) + return tmp8 default: if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -1139,462 +1140,463 @@ func init() { _ = v5 v6 := args[1] _ = v6 - v7 := lang.NewList(args[2:]...) - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + var v7 any = lang.NewList(args[2:]...) + _ = v7 + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("*'")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("*'")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) } - v13 := v12.Get() - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("*'")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + tmp13 := tmp12.Get() + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("*'")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{v5, v6}) - v18 := lang.Apply(v10, []any{v13, v17, v7}) - return v18 + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{v5, v6}) + tmp18 := lang.Apply(tmp10, []any{tmp13, tmp17, v7}) + return tmp18 } }) - v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v3 := ns.InternWithValue(v0, v4, true) - if v0.Meta() != nil { - v3.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 := ns.InternWithValue(tmp0, tmp4, true) + if tmp0.Meta() != nil { + tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // *1 { - v0 := lang.NewSymbol("*1").WithMeta(lang.NewMap()).(*lang.Symbol) - v1 := ns.Intern(v0) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp0 := lang.NewSymbol("*1").WithMeta(lang.NewMap()).(*lang.Symbol) + tmp1 := ns.Intern(tmp0) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // *2 { - v0 := lang.NewSymbol("*2").WithMeta(lang.NewMap()).(*lang.Symbol) - v1 := ns.Intern(v0) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp0 := lang.NewSymbol("*2").WithMeta(lang.NewMap()).(*lang.Symbol) + tmp1 := ns.Intern(tmp0) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // *3 { - v0 := lang.NewSymbol("*3").WithMeta(lang.NewMap()).(*lang.Symbol) - v1 := ns.Intern(v0) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp0 := lang.NewSymbol("*3").WithMeta(lang.NewMap()).(*lang.Symbol) + tmp1 := ns.Intern(tmp0) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // *agent* { - v0 := lang.NewSymbol("*agent*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - v1 := ns.InternWithValue(v0, nil, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp0 := lang.NewSymbol("*agent*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // *assert* { - v0 := lang.NewSymbol("*assert*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "When set to logical false, 'assert' will omit assertion checks in\n compiled code. Defaults to true.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - v1 := ns.InternWithValue(v0, false, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp0 := lang.NewSymbol("*assert*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "When set to logical false, 'assert' will omit assertion checks in\n compiled code. Defaults to true.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, false, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // *command-line-args* { - v0 := lang.NewSymbol("*command-line-args*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "A sequence of the supplied command line arguments, or nil if\n none were supplied", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - v1 := ns.InternWithValue(v0, nil, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp0 := lang.NewSymbol("*command-line-args*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "A sequence of the supplied command line arguments, or nil if\n none were supplied", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // *compile-files* { - v0 := lang.NewSymbol("*compile-files*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "Set to true when compiling files, false otherwise.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - v1 := ns.InternWithValue(v0, false, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp0 := lang.NewSymbol("*compile-files*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "Set to true when compiling files, false otherwise.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, false, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // *compile-path* { - v0 := lang.NewSymbol("*compile-path*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "Specifies the directory where 'compile' will write out .class\n files. This directory must be in the classpath for 'compile' to\n work.\n\n Defaults to \"classes\"", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - v1 := ns.InternWithValue(v0, nil, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp0 := lang.NewSymbol("*compile-path*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "Specifies the directory where 'compile' will write out .class\n files. This directory must be in the classpath for 'compile' to\n work.\n\n Defaults to \"classes\"", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // *compiler-options* { - v0 := lang.NewSymbol("*compiler-options*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.4", lang.NewKeyword("doc"), "A map of keys to options.\n Note, when binding dynamically make sure to merge with previous value.\n Supported options:\n :elide-meta - a collection of metadata keys to elide during compilation.\n :disable-locals-clearing - set to true to disable clearing, useful for using a debugger\n :direct-linking - set to true to use direct static invocation of functions, rather than vars\n Note that call sites compiled with direct linking will not be affected by var redefinition.\n Use ^:redef (or ^:dynamic) on a var to prevent direct linking and allow redefinition.\n See https://glojure.org/reference/compilation for more information.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - v1 := ns.InternWithValue(v0, nil, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp0 := lang.NewSymbol("*compiler-options*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.4", lang.NewKeyword("doc"), "A map of keys to options.\n Note, when binding dynamically make sure to merge with previous value.\n Supported options:\n :elide-meta - a collection of metadata keys to elide during compilation.\n :disable-locals-clearing - set to true to disable clearing, useful for using a debugger\n :direct-linking - set to true to use direct static invocation of functions, rather than vars\n Note that call sites compiled with direct linking will not be affected by var redefinition.\n Use ^:redef (or ^:dynamic) on a var to prevent direct linking and allow redefinition.\n See https://glojure.org/reference/compilation for more information.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // *data-readers* { - v0 := lang.NewSymbol("*data-readers*").WithMeta(lang.NewMap(lang.NewKeyword("doc"), "Map from reader tag symbols to data reader Vars.\n\n When Clojure starts, it searches for files named 'data_readers.clj'\n and 'data_readers.cljc' at the root of the classpath. Each such file\n must contain a literal map of symbols, like this:\n\n {foo/bar my.project.foo/bar\n foo/baz my.project/baz}\n\n The first symbol in each pair is a tag that will be recognized by\n the Clojure reader. The second symbol in the pair is the\n fully-qualified name of a Var which will be invoked by the reader to\n parse the form following the tag. For example, given the\n data_readers.clj file above, the Clojure reader would parse this\n form:\n\n #foo/bar [1 2 3]\n\n by invoking the Var #'my.project.foo/bar on the vector [1 2 3]. The\n data reader function is invoked on the form AFTER it has been read\n as a normal Clojure data structure by the reader.\n\n Reader tags without namespace qualifiers are reserved for\n Clojure. Default reader tags are defined in\n glojure.core/default-data-readers but may be overridden in\n data_readers.clj, data_readers.cljc, or by rebinding this Var.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(49), lang.NewKeyword("column"), int(6), lang.NewKeyword("line"), int(7794), lang.NewKeyword("end-line"), int(7794), lang.NewKeyword("dynamic"), true)).(*lang.Symbol) - v1 := ns.InternWithValue(v0, lang.NewMap(), true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp0 := lang.NewSymbol("*data-readers*").WithMeta(lang.NewMap(lang.NewKeyword("doc"), "Map from reader tag symbols to data reader Vars.\n\n When Clojure starts, it searches for files named 'data_readers.clj'\n and 'data_readers.cljc' at the root of the classpath. Each such file\n must contain a literal map of symbols, like this:\n\n {foo/bar my.project.foo/bar\n foo/baz my.project/baz}\n\n The first symbol in each pair is a tag that will be recognized by\n the Clojure reader. The second symbol in the pair is the\n fully-qualified name of a Var which will be invoked by the reader to\n parse the form following the tag. For example, given the\n data_readers.clj file above, the Clojure reader would parse this\n form:\n\n #foo/bar [1 2 3]\n\n by invoking the Var #'my.project.foo/bar on the vector [1 2 3]. The\n data reader function is invoked on the form AFTER it has been read\n as a normal Clojure data structure by the reader.\n\n Reader tags without namespace qualifiers are reserved for\n Clojure. Default reader tags are defined in\n glojure.core/default-data-readers but may be overridden in\n data_readers.clj, data_readers.cljc, or by rebinding this Var.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(49), lang.NewKeyword("column"), int(6), lang.NewKeyword("line"), int(7794), lang.NewKeyword("end-line"), int(7794), lang.NewKeyword("dynamic"), true)).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, lang.NewMap(), true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // *default-data-reader-fn* { - v0 := lang.NewSymbol("*default-data-reader-fn*").WithMeta(lang.NewMap(lang.NewKeyword("doc"), "When no data reader is found for a tag and *default-data-reader-fn*\n is non-nil, it will be called with two arguments,\n the tag and the value. If *default-data-reader-fn* is nil (the\n default), an exception will be thrown for the unknown tag.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(59), lang.NewKeyword("column"), int(6), lang.NewKeyword("line"), int(7823), lang.NewKeyword("end-line"), int(7823), lang.NewKeyword("dynamic"), true)).(*lang.Symbol) - v1 := ns.InternWithValue(v0, nil, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp0 := lang.NewSymbol("*default-data-reader-fn*").WithMeta(lang.NewMap(lang.NewKeyword("doc"), "When no data reader is found for a tag and *default-data-reader-fn*\n is non-nil, it will be called with two arguments,\n the tag and the value. If *default-data-reader-fn* is nil (the\n default), an exception will be thrown for the unknown tag.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(59), lang.NewKeyword("column"), int(6), lang.NewKeyword("line"), int(7823), lang.NewKeyword("end-line"), int(7823), lang.NewKeyword("dynamic"), true)).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // *e { - v0 := lang.NewSymbol("*e").WithMeta(lang.NewMap()).(*lang.Symbol) - v1 := ns.Intern(v0) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp0 := lang.NewSymbol("*e").WithMeta(lang.NewMap()).(*lang.Symbol) + tmp1 := ns.Intern(tmp0) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // *err* { - v0 := lang.NewSymbol("*err*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "A java.io.Writer object representing standard error for print operations.\n\n Defaults to System/err, wrapped in a PrintWriter", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - v1 := ns.InternWithValue(v0, nil, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp0 := lang.NewSymbol("*err*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "A java.io.Writer object representing standard error for print operations.\n\n Defaults to System/err, wrapped in a PrintWriter", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // *file* { - v0 := lang.NewSymbol("*file*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "The path of the file being evaluated, as a String.\n\n When there is no file, e.g. in the REPL, the value is not defined.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - v1 := ns.InternWithValue(v0, "NO_SOURCE_FILE", true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp0 := lang.NewSymbol("*file*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "The path of the file being evaluated, as a String.\n\n When there is no file, e.g. in the REPL, the value is not defined.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, "NO_SOURCE_FILE", true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // *flush-on-newline* { - v0 := lang.NewSymbol("*flush-on-newline*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "When set to true, output will be flushed whenever a newline is printed.\n\n Defaults to true.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - v1 := ns.InternWithValue(v0, nil, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp0 := lang.NewSymbol("*flush-on-newline*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "When set to true, output will be flushed whenever a newline is printed.\n\n Defaults to true.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // *loaded-libs* { - v0 := lang.NewSymbol("*loaded-libs*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5817), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(5820), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - v1 := ns.InternWithValue(v0, nil, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp0 := lang.NewSymbol("*loaded-libs*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5817), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(5820), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // *loading-verbosely* { - v0 := lang.NewSymbol("*loading-verbosely*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5827), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(5830), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - v1 := ns.InternWithValue(v0, false, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp0 := lang.NewSymbol("*loading-verbosely*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5827), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(5830), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, false, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // *ns* { - v0 := lang.NewSymbol("*ns*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "A glojure.lang.Namespace object representing the current namespace.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - v1 := ns.InternWithValue(v0, lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp0 := lang.NewSymbol("*ns*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "A glojure.lang.Namespace object representing the current namespace.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // *pending-paths* { - v0 := lang.NewSymbol("*pending-paths*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5822), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(5825), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - v1 := ns.InternWithValue(v0, lang.NewList(), true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp0 := lang.NewSymbol("*pending-paths*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5822), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(5825), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, lang.NewList(), true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // *print-dup* { - v0 := lang.NewSymbol("*print-dup*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "When set to logical true, objects will be printed in a way that preserves\n their type when read in later.\n\n Defaults to false.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - v1 := ns.InternWithValue(v0, nil, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp0 := lang.NewSymbol("*print-dup*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "When set to logical true, objects will be printed in a way that preserves\n their type when read in later.\n\n Defaults to false.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // *print-length* { - v0 := lang.NewSymbol("*print-length*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(14), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(23), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - v1 := ns.InternWithValue(v0, nil, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp0 := lang.NewSymbol("*print-length*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(14), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(23), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // *print-level* { - v0 := lang.NewSymbol("*print-level*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(25), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(35), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - v1 := ns.InternWithValue(v0, nil, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp0 := lang.NewSymbol("*print-level*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(25), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(35), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // *print-meta* { - v0 := lang.NewSymbol("*print-meta*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "If set to logical true, when printing an object, its metadata will also\n be printed in a form that can be read back by the reader.\n\n Defaults to false.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - v1 := ns.InternWithValue(v0, nil, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp0 := lang.NewSymbol("*print-meta*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "If set to logical true, when printing an object, its metadata will also\n be printed in a form that can be read back by the reader.\n\n Defaults to false.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // *print-namespace-maps* { - v0 := lang.NewSymbol("*print-namespace-maps*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(39), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(44), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - v1 := ns.InternWithValue(v0, false, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp0 := lang.NewSymbol("*print-namespace-maps*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(39), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(44), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, false, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // *print-readably* { - v0 := lang.NewSymbol("*print-readably*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "When set to logical false, strings and characters will be printed with\n non-alphanumeric characters converted to the appropriate escape sequences.\n\n Defaults to true", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - v1 := ns.InternWithValue(v0, true, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp0 := lang.NewSymbol("*print-readably*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "When set to logical false, strings and characters will be printed with\n non-alphanumeric characters converted to the appropriate escape sequences.\n\n Defaults to true", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, true, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // *read-eval* { - v0 := lang.NewSymbol("*read-eval*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "Defaults to true (or value specified by system property, see below)\n ***This setting implies that the full power of the reader is in play,\n including syntax that can cause code to execute. It should never be\n used with untrusted sources. See also: glojure.edn/read.***\n\n When set to logical false in the thread-local binding,\n the eval reader (#=) and record/type literal syntax are disabled in read/load.\n Example (will fail): (binding [*read-eval* false] (read-string \"#=(* 2 21)\"))\n\n The default binding can be controlled by the system property\n 'glojure.read.eval' System properties can be set on the command line\n like this:\n\n java -Dglojure.read.eval=false ...\n\n The system property can also be set to 'unknown' via\n -Dglojure.read.eval=unknown, in which case the default binding\n is :unknown and all reads will fail in contexts where *read-eval*\n has not been explicitly bound to either true or false. This setting\n can be a useful diagnostic tool to ensure that all of your reads\n occur in considered contexts. You can also accomplish this in a\n particular scope by binding *read-eval* to :unknown\n ", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - v1 := ns.InternWithValue(v0, nil, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp0 := lang.NewSymbol("*read-eval*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "Defaults to true (or value specified by system property, see below)\n ***This setting implies that the full power of the reader is in play,\n including syntax that can cause code to execute. It should never be\n used with untrusted sources. See also: glojure.edn/read.***\n\n When set to logical false in the thread-local binding,\n the eval reader (#=) and record/type literal syntax are disabled in read/load.\n Example (will fail): (binding [*read-eval* false] (read-string \"#=(* 2 21)\"))\n\n The default binding can be controlled by the system property\n 'glojure.read.eval' System properties can be set on the command line\n like this:\n\n java -Dglojure.read.eval=false ...\n\n The system property can also be set to 'unknown' via\n -Dglojure.read.eval=unknown, in which case the default binding\n is :unknown and all reads will fail in contexts where *read-eval*\n has not been explicitly bound to either true or false. This setting\n can be a useful diagnostic tool to ensure that all of your reads\n occur in considered contexts. You can also accomplish this in a\n particular scope by binding *read-eval* to :unknown\n ", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // *repl* { - v0 := lang.NewSymbol("*repl*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6288), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(6291), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - v1 := ns.InternWithValue(v0, false, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp0 := lang.NewSymbol("*repl*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6288), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(6291), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, false, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // *unchecked-math* { - v0 := lang.NewSymbol("*unchecked-math*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.3", lang.NewKeyword("doc"), "While bound to true, compilations of +, -, *, inc, dec and the\n coercions will be done without overflow checks. While bound\n to :warn-on-boxed, same behavior as true, and a warning is emitted\n when compilation uses boxed math. Default: false.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - v1 := ns.InternWithValue(v0, nil, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp0 := lang.NewSymbol("*unchecked-math*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.3", lang.NewKeyword("doc"), "While bound to true, compilations of +, -, *, inc, dec and the\n coercions will be done without overflow checks. While bound\n to :warn-on-boxed, same behavior as true, and a warning is emitted\n when compilation uses boxed math. Default: false.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // *verbose-defrecords* { - v0 := lang.NewSymbol("*verbose-defrecords*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(37), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(37), lang.NewKeyword("end-column"), int(35), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - v1 := ns.InternWithValue(v0, false, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp0 := lang.NewSymbol("*verbose-defrecords*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(37), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(37), lang.NewKeyword("end-column"), int(35), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, false, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // *warn-on-reflection* { - v0 := lang.NewSymbol("*warn-on-reflection*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "When set to true, the compiler will emit warnings when reflection is\n needed to resolve Java method calls or field accesses.\n\n Defaults to false.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - v1 := ns.InternWithValue(v0, nil, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp0 := lang.NewSymbol("*warn-on-reflection*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "When set to true, the compiler will emit warnings when reflection is\n needed to resolve Java method calls or field accesses.\n\n Defaults to false.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // + { - var v1 lang.FnFunc - v1 = lang.NewFnFunc(func(args ...any) any { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v2 := args[0] _ = v2 - var v3 any + var tmp3 any { // let // let binding "op" - var v4 any - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - if lang.IsTruthy(v7) { - v4 = closed3 + var tmp4 any + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + if lang.IsTruthy(tmp7) { + tmp4 = closed3 } else { - v4 = closed4 + tmp4 = closed4 } - var v8 any = v4 + var v8 any = tmp4 _ = v8 - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("seq")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("concat")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("list")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("list")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("list")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("seq")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) - } - v28 := v27.Get() - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("concat")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("list")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{v8}) - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("list")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.Apply(v38, []any{v2}) - v40 := lang.Apply(v31, []any{v35, v39}) - v41 := lang.Apply(v28, []any{v40}) - v42 := lang.Apply(v25, []any{v41}) - v43 := lang.Apply(v14, []any{v18, v22, v42}) - v44 := lang.Apply(v11, []any{v43}) - v3 = v44 + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("seq")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("concat")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol(".")}) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("seq")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) + } + tmp28 := tmp27.Get() + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("concat")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.Apply(tmp34, []any{v8}) + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{v2}) + tmp40 := lang.Apply(tmp31, []any{tmp35, tmp39}) + tmp41 := lang.Apply(tmp28, []any{tmp40}) + tmp42 := lang.Apply(tmp25, []any{tmp41}) + tmp43 := lang.Apply(tmp14, []any{tmp18, tmp22, tmp42}) + tmp44 := lang.Apply(tmp11, []any{tmp43}) + tmp3 = tmp44 } // end let - return v3 + return tmp3 case 2: v2 := args[0] _ = v2 v3 := args[1] _ = v3 - var v4 any + var tmp4 any { // let // let binding "op" - var v5 any - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - if lang.IsTruthy(v8) { - v5 = closed3 + var tmp5 any + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + if lang.IsTruthy(tmp8) { + tmp5 = closed3 } else { - v5 = closed4 + tmp5 = closed4 } - var v9 any = v5 + var v9 any = tmp5 _ = v9 - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("seq")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("concat")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("list")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("list")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("list")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("seq")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("concat")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) - } - v32 := v31.Get() - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("list")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - v36 := lang.Apply(v35, []any{v9}) - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("list")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.Apply(v39, []any{v2}) - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("list")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) - } - v43 := v42.Get() - v44 := lang.Apply(v43, []any{v3}) - v45 := lang.Apply(v32, []any{v36, v40, v44}) - v46 := lang.Apply(v29, []any{v45}) - v47 := lang.Apply(v26, []any{v46}) - v48 := lang.Apply(v15, []any{v19, v23, v47}) - v49 := lang.Apply(v12, []any{v48}) - v4 = v49 + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("seq")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("concat")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("list")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{lang.NewSymbol(".")}) + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("list")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.Apply(tmp22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("list")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("seq")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("concat")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) + } + tmp32 := tmp31.Get() + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("list")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) + } + tmp35 := tmp34.Get() + tmp36 := lang.Apply(tmp35, []any{v9}) + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("list")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.Apply(tmp39, []any{v2}) + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("list")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := lang.Apply(tmp43, []any{v3}) + tmp45 := lang.Apply(tmp32, []any{tmp36, tmp40, tmp44}) + tmp46 := lang.Apply(tmp29, []any{tmp45}) + tmp47 := lang.Apply(tmp26, []any{tmp46}) + tmp48 := lang.Apply(tmp15, []any{tmp19, tmp23, tmp47}) + tmp49 := lang.Apply(tmp12, []any{tmp48}) + tmp4 = tmp49 } // end let - return v4 + return tmp4 default: if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -1603,32 +1605,33 @@ func init() { _ = v2 v3 := args[1] _ = v3 - v4 := lang.NewList(args[2:]...) - var v5 any + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any { // let // let binding "op" - var v6 any - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - if lang.IsTruthy(v9) { - v6 = closed3 + var tmp6 any + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + if lang.IsTruthy(tmp9) { + tmp6 = closed3 } else { - v6 = closed4 + tmp6 = closed4 } - var v10 any = v6 + var v10 any = tmp6 _ = v10 - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - var v14 lang.FnFunc - v14 = lang.NewFnFunc(func(args ...any) any { + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -1636,197 +1639,197 @@ func init() { _ = v15 v16 := args[1] _ = v16 - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("seq")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("concat")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("list")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("seq")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) - } - v36 := v35.Get() - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("concat")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("list")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) - } - v42 := v41.Get() - v43 := lang.Apply(v42, []any{v10}) - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("list")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) - } - v46 := v45.Get() - v47 := lang.Apply(v46, []any{v15}) - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("list")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v16}) - v52 := lang.Apply(v39, []any{v43, v47, v51}) - v53 := lang.Apply(v36, []any{v52}) - v54 := lang.Apply(v33, []any{v53}) - v55 := lang.Apply(v22, []any{v26, v30, v54}) - v56 := lang.Apply(v19, []any{v55}) - return v56 + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("concat")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol(".")}) + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) + } + tmp42 := tmp41.Get() + tmp43 := lang.Apply(tmp42, []any{v10}) + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) + } + tmp46 := tmp45.Get() + tmp47 := lang.Apply(tmp46, []any{v15}) + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v16}) + tmp52 := lang.Apply(tmp39, []any{tmp43, tmp47, tmp51}) + tmp53 := lang.Apply(tmp36, []any{tmp52}) + tmp54 := lang.Apply(tmp33, []any{tmp53}) + tmp55 := lang.Apply(tmp22, []any{tmp26, tmp30, tmp54}) + tmp56 := lang.Apply(tmp19, []any{tmp55}) + return tmp56 }) - v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) - v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) + tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) if err != nil { panic(err) } - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("seq")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("concat")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("list")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("seq")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) - } - v36 := v35.Get() - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("concat")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("list")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) - } - v42 := v41.Get() - v43 := lang.Apply(v42, []any{v10}) - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("list")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) - } - v46 := v45.Get() - v47 := lang.Apply(v46, []any{v2}) - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("list")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v3}) - v52 := lang.Apply(v39, []any{v43, v47, v51}) - v53 := lang.Apply(v36, []any{v52}) - v54 := lang.Apply(v33, []any{v53}) - v55 := lang.Apply(v22, []any{v26, v30, v54}) - v56 := lang.Apply(v19, []any{v55}) - v57 := lang.Apply(v13, []any{v16, v56, v4}) - v5 = v57 + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("concat")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol(".")}) + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) + } + tmp42 := tmp41.Get() + tmp43 := lang.Apply(tmp42, []any{v10}) + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) + } + tmp46 := tmp45.Get() + tmp47 := lang.Apply(tmp46, []any{v2}) + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v3}) + tmp52 := lang.Apply(tmp39, []any{tmp43, tmp47, tmp51}) + tmp53 := lang.Apply(tmp36, []any{tmp52}) + tmp54 := lang.Apply(tmp33, []any{tmp53}) + tmp55 := lang.Apply(tmp22, []any{tmp26, tmp30, tmp54}) + tmp56 := lang.Apply(tmp19, []any{tmp55}) + tmp57 := lang.Apply(tmp13, []any{tmp16, tmp56, v4}) + tmp5 = tmp57 } // end let - return v5 + return tmp5 } }) - v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp1 = tmp1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") - if reflect.TypeOf(v4).Kind() != reflect.Func { + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - v5 := lang.Apply(v4, []any{nil, int64(1)}) - return v5 + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v0 := lang.NewSymbol("+").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the sum of nums. (+) returns 0. Does not auto-promote\n longs, will throw on overflow. See also: +'", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(977), lang.NewKeyword("end-line"), int(977))).(*lang.Symbol) - var v4 lang.FnFunc - v4 = lang.NewFnFunc(func(args ...any) any { + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp0 := lang.NewSymbol("+").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the sum of nums. (+) returns 0. Does not auto-promote\n longs, will throw on overflow. See also: +'", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), tmp2, lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(977), lang.NewKeyword("end-line"), int(977))).(*lang.Symbol) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: return int64(0) case 1: v5 := args[0] _ = v5 - v6 := lang.Apply(lang.MustAsNumber, []any{v5}) - return v6 + tmp6 := lang.Apply(lang.MustAsNumber, []any{v5}) + return tmp6 case 2: v5 := args[0] _ = v5 v6 := args[1] _ = v6 - v7, _ := lang.FieldOrMethod(lang.Numbers, "Add") - if reflect.TypeOf(v7).Kind() != reflect.Func { + tmp7, _ := lang.FieldOrMethod(lang.Numbers, "Add") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Add is not a function"))) } - v8 := lang.Apply(v7, []any{v5, v6}) - return v8 + tmp8 := lang.Apply(tmp7, []any{v5, v6}) + return tmp8 default: if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -1835,222 +1838,223 @@ func init() { _ = v5 v6 := args[1] _ = v6 - v7 := lang.NewList(args[2:]...) - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + var v7 any = lang.NewList(args[2:]...) + _ = v7 + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("+")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("+")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) } - v13 := v12.Get() - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("+")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + tmp13 := tmp12.Get() + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("+")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{v5, v6}) - v18 := lang.Apply(v10, []any{v13, v17, v7}) - return v18 + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{v5, v6}) + tmp18 := lang.Apply(tmp10, []any{tmp13, tmp17, v7}) + return tmp18 } }) - v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v3 := ns.InternWithValue(v0, v4, true) - if v0.Meta() != nil { - v3.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 := ns.InternWithValue(tmp0, tmp4, true) + if tmp0.Meta() != nil { + tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // +' { - var v1 lang.FnFunc - v1 = lang.NewFnFunc(func(args ...any) any { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v2 := args[0] _ = v2 - var v3 any + var tmp3 any { // let // let binding "op" - var v4 any - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - if lang.IsTruthy(v7) { - v4 = closed5 + var tmp4 any + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + if lang.IsTruthy(tmp7) { + tmp4 = closed5 } else { - v4 = closed5 + tmp4 = closed5 } - var v8 any = v4 + var v8 any = tmp4 _ = v8 - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("seq")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("concat")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("list")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("list")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("list")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("seq")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) - } - v28 := v27.Get() - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("concat")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("list")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{v8}) - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("list")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.Apply(v38, []any{v2}) - v40 := lang.Apply(v31, []any{v35, v39}) - v41 := lang.Apply(v28, []any{v40}) - v42 := lang.Apply(v25, []any{v41}) - v43 := lang.Apply(v14, []any{v18, v22, v42}) - v44 := lang.Apply(v11, []any{v43}) - v3 = v44 + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("seq")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("concat")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol(".")}) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("seq")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) + } + tmp28 := tmp27.Get() + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("concat")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.Apply(tmp34, []any{v8}) + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{v2}) + tmp40 := lang.Apply(tmp31, []any{tmp35, tmp39}) + tmp41 := lang.Apply(tmp28, []any{tmp40}) + tmp42 := lang.Apply(tmp25, []any{tmp41}) + tmp43 := lang.Apply(tmp14, []any{tmp18, tmp22, tmp42}) + tmp44 := lang.Apply(tmp11, []any{tmp43}) + tmp3 = tmp44 } // end let - return v3 + return tmp3 case 2: v2 := args[0] _ = v2 v3 := args[1] _ = v3 - var v4 any + var tmp4 any { // let // let binding "op" - var v5 any - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - if lang.IsTruthy(v8) { - v5 = closed5 + var tmp5 any + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + if lang.IsTruthy(tmp8) { + tmp5 = closed5 } else { - v5 = closed5 + tmp5 = closed5 } - var v9 any = v5 + var v9 any = tmp5 _ = v9 - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("seq")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("concat")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("list")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("list")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("list")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("seq")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("concat")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) - } - v32 := v31.Get() - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("list")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - v36 := lang.Apply(v35, []any{v9}) - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("list")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.Apply(v39, []any{v2}) - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("list")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) - } - v43 := v42.Get() - v44 := lang.Apply(v43, []any{v3}) - v45 := lang.Apply(v32, []any{v36, v40, v44}) - v46 := lang.Apply(v29, []any{v45}) - v47 := lang.Apply(v26, []any{v46}) - v48 := lang.Apply(v15, []any{v19, v23, v47}) - v49 := lang.Apply(v12, []any{v48}) - v4 = v49 + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("seq")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("concat")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("list")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{lang.NewSymbol(".")}) + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("list")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.Apply(tmp22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("list")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("seq")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("concat")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) + } + tmp32 := tmp31.Get() + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("list")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) + } + tmp35 := tmp34.Get() + tmp36 := lang.Apply(tmp35, []any{v9}) + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("list")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.Apply(tmp39, []any{v2}) + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("list")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := lang.Apply(tmp43, []any{v3}) + tmp45 := lang.Apply(tmp32, []any{tmp36, tmp40, tmp44}) + tmp46 := lang.Apply(tmp29, []any{tmp45}) + tmp47 := lang.Apply(tmp26, []any{tmp46}) + tmp48 := lang.Apply(tmp15, []any{tmp19, tmp23, tmp47}) + tmp49 := lang.Apply(tmp12, []any{tmp48}) + tmp4 = tmp49 } // end let - return v4 + return tmp4 default: if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -2059,32 +2063,33 @@ func init() { _ = v2 v3 := args[1] _ = v3 - v4 := lang.NewList(args[2:]...) - var v5 any + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any { // let // let binding "op" - var v6 any - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - if lang.IsTruthy(v9) { - v6 = closed5 + var tmp6 any + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + if lang.IsTruthy(tmp9) { + tmp6 = closed5 } else { - v6 = closed5 + tmp6 = closed5 } - var v10 any = v6 + var v10 any = tmp6 _ = v10 - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - var v14 lang.FnFunc - v14 = lang.NewFnFunc(func(args ...any) any { + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -2092,197 +2097,197 @@ func init() { _ = v15 v16 := args[1] _ = v16 - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("seq")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("concat")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("list")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("seq")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) - } - v36 := v35.Get() - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("concat")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("list")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) - } - v42 := v41.Get() - v43 := lang.Apply(v42, []any{v10}) - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("list")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) - } - v46 := v45.Get() - v47 := lang.Apply(v46, []any{v15}) - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("list")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v16}) - v52 := lang.Apply(v39, []any{v43, v47, v51}) - v53 := lang.Apply(v36, []any{v52}) - v54 := lang.Apply(v33, []any{v53}) - v55 := lang.Apply(v22, []any{v26, v30, v54}) - v56 := lang.Apply(v19, []any{v55}) - return v56 + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("concat")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol(".")}) + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) + } + tmp42 := tmp41.Get() + tmp43 := lang.Apply(tmp42, []any{v10}) + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) + } + tmp46 := tmp45.Get() + tmp47 := lang.Apply(tmp46, []any{v15}) + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v16}) + tmp52 := lang.Apply(tmp39, []any{tmp43, tmp47, tmp51}) + tmp53 := lang.Apply(tmp36, []any{tmp52}) + tmp54 := lang.Apply(tmp33, []any{tmp53}) + tmp55 := lang.Apply(tmp22, []any{tmp26, tmp30, tmp54}) + tmp56 := lang.Apply(tmp19, []any{tmp55}) + return tmp56 }) - v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) - v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) + tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) if err != nil { panic(err) } - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("seq")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("concat")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("list")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("seq")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) - } - v36 := v35.Get() - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("concat")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("list")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) - } - v42 := v41.Get() - v43 := lang.Apply(v42, []any{v10}) - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("list")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) - } - v46 := v45.Get() - v47 := lang.Apply(v46, []any{v2}) - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("list")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v3}) - v52 := lang.Apply(v39, []any{v43, v47, v51}) - v53 := lang.Apply(v36, []any{v52}) - v54 := lang.Apply(v33, []any{v53}) - v55 := lang.Apply(v22, []any{v26, v30, v54}) - v56 := lang.Apply(v19, []any{v55}) - v57 := lang.Apply(v13, []any{v16, v56, v4}) - v5 = v57 + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("concat")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol(".")}) + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) + } + tmp42 := tmp41.Get() + tmp43 := lang.Apply(tmp42, []any{v10}) + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) + } + tmp46 := tmp45.Get() + tmp47 := lang.Apply(tmp46, []any{v2}) + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v3}) + tmp52 := lang.Apply(tmp39, []any{tmp43, tmp47, tmp51}) + tmp53 := lang.Apply(tmp36, []any{tmp52}) + tmp54 := lang.Apply(tmp33, []any{tmp53}) + tmp55 := lang.Apply(tmp22, []any{tmp26, tmp30, tmp54}) + tmp56 := lang.Apply(tmp19, []any{tmp55}) + tmp57 := lang.Apply(tmp13, []any{tmp16, tmp56, v4}) + tmp5 = tmp57 } // end let - return v5 + return tmp5 } }) - v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp1 = tmp1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") - if reflect.TypeOf(v4).Kind() != reflect.Func { + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - v5 := lang.Apply(v4, []any{nil, int64(1)}) - return v5 + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v0 := lang.NewSymbol("+'").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the sum of nums. (+') returns 0. Supports arbitrary precision.\n See also: +", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(965), lang.NewKeyword("end-line"), int(965))).(*lang.Symbol) - var v4 lang.FnFunc - v4 = lang.NewFnFunc(func(args ...any) any { + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp0 := lang.NewSymbol("+'").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the sum of nums. (+') returns 0. Supports arbitrary precision.\n See also: +", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), tmp2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(965), lang.NewKeyword("end-line"), int(965))).(*lang.Symbol) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: return int64(0) case 1: v5 := args[0] _ = v5 - v6 := lang.Apply(lang.MustAsNumber, []any{v5}) - return v6 + tmp6 := lang.Apply(lang.MustAsNumber, []any{v5}) + return tmp6 case 2: v5 := args[0] _ = v5 v6 := args[1] _ = v6 - v7, _ := lang.FieldOrMethod(lang.Numbers, "AddP") - if reflect.TypeOf(v7).Kind() != reflect.Func { + tmp7, _ := lang.FieldOrMethod(lang.Numbers, "AddP") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("AddP is not a function"))) } - v8 := lang.Apply(v7, []any{v5, v6}) - return v8 + tmp8 := lang.Apply(tmp7, []any{v5, v6}) + return tmp8 default: if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -2291,222 +2296,223 @@ func init() { _ = v5 v6 := args[1] _ = v6 - v7 := lang.NewList(args[2:]...) - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + var v7 any = lang.NewList(args[2:]...) + _ = v7 + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("+'")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("+'")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) } - v13 := v12.Get() - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("+'")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + tmp13 := tmp12.Get() + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("+'")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{v5, v6}) - v18 := lang.Apply(v10, []any{v13, v17, v7}) - return v18 + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{v5, v6}) + tmp18 := lang.Apply(tmp10, []any{tmp13, tmp17, v7}) + return tmp18 } }) - v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v3 := ns.InternWithValue(v0, v4, true) - if v0.Meta() != nil { - v3.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 := ns.InternWithValue(tmp0, tmp4, true) + if tmp0.Meta() != nil { + tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // - { - var v1 lang.FnFunc - v1 = lang.NewFnFunc(func(args ...any) any { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v2 := args[0] _ = v2 - var v3 any + var tmp3 any { // let // let binding "op" - var v4 any - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - if lang.IsTruthy(v7) { - v4 = closed6 + var tmp4 any + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + if lang.IsTruthy(tmp7) { + tmp4 = closed6 } else { - v4 = closed7 + tmp4 = closed7 } - var v8 any = v4 + var v8 any = tmp4 _ = v8 - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("seq")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("concat")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("list")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("list")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("list")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("seq")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) - } - v28 := v27.Get() - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("concat")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("list")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{v8}) - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("list")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.Apply(v38, []any{v2}) - v40 := lang.Apply(v31, []any{v35, v39}) - v41 := lang.Apply(v28, []any{v40}) - v42 := lang.Apply(v25, []any{v41}) - v43 := lang.Apply(v14, []any{v18, v22, v42}) - v44 := lang.Apply(v11, []any{v43}) - v3 = v44 + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("seq")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("concat")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol(".")}) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("seq")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) + } + tmp28 := tmp27.Get() + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("concat")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.Apply(tmp34, []any{v8}) + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{v2}) + tmp40 := lang.Apply(tmp31, []any{tmp35, tmp39}) + tmp41 := lang.Apply(tmp28, []any{tmp40}) + tmp42 := lang.Apply(tmp25, []any{tmp41}) + tmp43 := lang.Apply(tmp14, []any{tmp18, tmp22, tmp42}) + tmp44 := lang.Apply(tmp11, []any{tmp43}) + tmp3 = tmp44 } // end let - return v3 + return tmp3 case 2: v2 := args[0] _ = v2 v3 := args[1] _ = v3 - var v4 any + var tmp4 any { // let // let binding "op" - var v5 any - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - if lang.IsTruthy(v8) { - v5 = closed6 + var tmp5 any + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + if lang.IsTruthy(tmp8) { + tmp5 = closed6 } else { - v5 = closed7 + tmp5 = closed7 } - var v9 any = v5 + var v9 any = tmp5 _ = v9 - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("seq")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("concat")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("list")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("list")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("list")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("seq")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("concat")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) - } - v32 := v31.Get() - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("list")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - v36 := lang.Apply(v35, []any{v9}) - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("list")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.Apply(v39, []any{v2}) - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("list")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) - } - v43 := v42.Get() - v44 := lang.Apply(v43, []any{v3}) - v45 := lang.Apply(v32, []any{v36, v40, v44}) - v46 := lang.Apply(v29, []any{v45}) - v47 := lang.Apply(v26, []any{v46}) - v48 := lang.Apply(v15, []any{v19, v23, v47}) - v49 := lang.Apply(v12, []any{v48}) - v4 = v49 + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("seq")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("concat")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("list")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{lang.NewSymbol(".")}) + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("list")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.Apply(tmp22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("list")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("seq")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("concat")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) + } + tmp32 := tmp31.Get() + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("list")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) + } + tmp35 := tmp34.Get() + tmp36 := lang.Apply(tmp35, []any{v9}) + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("list")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.Apply(tmp39, []any{v2}) + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("list")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := lang.Apply(tmp43, []any{v3}) + tmp45 := lang.Apply(tmp32, []any{tmp36, tmp40, tmp44}) + tmp46 := lang.Apply(tmp29, []any{tmp45}) + tmp47 := lang.Apply(tmp26, []any{tmp46}) + tmp48 := lang.Apply(tmp15, []any{tmp19, tmp23, tmp47}) + tmp49 := lang.Apply(tmp12, []any{tmp48}) + tmp4 = tmp49 } // end let - return v4 + return tmp4 default: if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -2515,32 +2521,33 @@ func init() { _ = v2 v3 := args[1] _ = v3 - v4 := lang.NewList(args[2:]...) - var v5 any + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any { // let // let binding "op" - var v6 any - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - if lang.IsTruthy(v9) { - v6 = closed6 + var tmp6 any + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + if lang.IsTruthy(tmp9) { + tmp6 = closed6 } else { - v6 = closed7 + tmp6 = closed7 } - var v10 any = v6 + var v10 any = tmp6 _ = v10 - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - var v14 lang.FnFunc - v14 = lang.NewFnFunc(func(args ...any) any { + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -2548,201 +2555,201 @@ func init() { _ = v15 v16 := args[1] _ = v16 - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("seq")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("concat")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("list")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("seq")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) - } - v36 := v35.Get() - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("concat")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("list")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) - } - v42 := v41.Get() - v43 := lang.Apply(v42, []any{v10}) - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("list")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) - } - v46 := v45.Get() - v47 := lang.Apply(v46, []any{v15}) - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("list")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v16}) - v52 := lang.Apply(v39, []any{v43, v47, v51}) - v53 := lang.Apply(v36, []any{v52}) - v54 := lang.Apply(v33, []any{v53}) - v55 := lang.Apply(v22, []any{v26, v30, v54}) - v56 := lang.Apply(v19, []any{v55}) - return v56 + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("concat")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol(".")}) + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) + } + tmp42 := tmp41.Get() + tmp43 := lang.Apply(tmp42, []any{v10}) + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) + } + tmp46 := tmp45.Get() + tmp47 := lang.Apply(tmp46, []any{v15}) + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v16}) + tmp52 := lang.Apply(tmp39, []any{tmp43, tmp47, tmp51}) + tmp53 := lang.Apply(tmp36, []any{tmp52}) + tmp54 := lang.Apply(tmp33, []any{tmp53}) + tmp55 := lang.Apply(tmp22, []any{tmp26, tmp30, tmp54}) + tmp56 := lang.Apply(tmp19, []any{tmp55}) + return tmp56 }) - v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) - v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) + tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) if err != nil { panic(err) } - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("seq")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("concat")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("list")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("seq")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) - } - v36 := v35.Get() - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("concat")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("list")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) - } - v42 := v41.Get() - v43 := lang.Apply(v42, []any{v10}) - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("list")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) - } - v46 := v45.Get() - v47 := lang.Apply(v46, []any{v2}) - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("list")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v3}) - v52 := lang.Apply(v39, []any{v43, v47, v51}) - v53 := lang.Apply(v36, []any{v52}) - v54 := lang.Apply(v33, []any{v53}) - v55 := lang.Apply(v22, []any{v26, v30, v54}) - v56 := lang.Apply(v19, []any{v55}) - v57 := lang.Apply(v13, []any{v16, v56, v4}) - v5 = v57 + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("concat")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol(".")}) + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) + } + tmp42 := tmp41.Get() + tmp43 := lang.Apply(tmp42, []any{v10}) + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) + } + tmp46 := tmp45.Get() + tmp47 := lang.Apply(tmp46, []any{v2}) + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v3}) + tmp52 := lang.Apply(tmp39, []any{tmp43, tmp47, tmp51}) + tmp53 := lang.Apply(tmp36, []any{tmp52}) + tmp54 := lang.Apply(tmp33, []any{tmp53}) + tmp55 := lang.Apply(tmp22, []any{tmp26, tmp30, tmp54}) + tmp56 := lang.Apply(tmp19, []any{tmp55}) + tmp57 := lang.Apply(tmp13, []any{tmp16, tmp56, v4}) + tmp5 = tmp57 } // end let - return v5 + return tmp5 } }) - v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp1 = tmp1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") - if reflect.TypeOf(v4).Kind() != reflect.Func { + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - v5 := lang.Apply(v4, []any{nil, int64(0)}) - return v5 + tmp5 := lang.Apply(tmp4, []any{nil, int64(0)}) + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v0 := lang.NewSymbol("-").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "If no ys are supplied, returns the negation of x, else subtracts\n the ys from x and returns the result. Does not auto-promote\n longs, will throw on overflow. See also: -'", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1036), lang.NewKeyword("end-line"), int(1036))).(*lang.Symbol) - var v4 lang.FnFunc - v4 = lang.NewFnFunc(func(args ...any) any { + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp0 := lang.NewSymbol("-").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "If no ys are supplied, returns the negation of x, else subtracts\n the ys from x and returns the result. Does not auto-promote\n longs, will throw on overflow. See also: -'", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), tmp2, lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1036), lang.NewKeyword("end-line"), int(1036))).(*lang.Symbol) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v5 := args[0] _ = v5 - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("*")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{int64(-1), v5}) - return v9 + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("*")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.Apply(tmp8, []any{int64(-1), v5}) + return tmp9 case 2: v5 := args[0] _ = v5 v6 := args[1] _ = v6 - v7, _ := lang.FieldOrMethod(lang.Numbers, "Minus") - if reflect.TypeOf(v7).Kind() != reflect.Func { + tmp7, _ := lang.FieldOrMethod(lang.Numbers, "Minus") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Minus is not a function"))) } - v8 := lang.Apply(v7, []any{v5, v6}) - return v8 + tmp8 := lang.Apply(tmp7, []any{v5, v6}) + return tmp8 default: if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -2751,222 +2758,223 @@ func init() { _ = v5 v6 := args[1] _ = v6 - v7 := lang.NewList(args[2:]...) - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + var v7 any = lang.NewList(args[2:]...) + _ = v7 + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("-")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("-")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) } - v13 := v12.Get() - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("-")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + tmp13 := tmp12.Get() + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("-")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{v5, v6}) - v18 := lang.Apply(v10, []any{v13, v17, v7}) - return v18 + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{v5, v6}) + tmp18 := lang.Apply(tmp10, []any{tmp13, tmp17, v7}) + return tmp18 } }) - v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v3 := ns.InternWithValue(v0, v4, true) - if v0.Meta() != nil { - v3.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 := ns.InternWithValue(tmp0, tmp4, true) + if tmp0.Meta() != nil { + tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // -' { - var v1 lang.FnFunc - v1 = lang.NewFnFunc(func(args ...any) any { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v2 := args[0] _ = v2 - var v3 any + var tmp3 any { // let // let binding "op" - var v4 any - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - if lang.IsTruthy(v7) { - v4 = closed8 + var tmp4 any + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + if lang.IsTruthy(tmp7) { + tmp4 = closed8 } else { - v4 = closed8 + tmp4 = closed8 } - var v8 any = v4 + var v8 any = tmp4 _ = v8 - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("seq")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("concat")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("list")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("list")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("list")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("seq")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) - } - v28 := v27.Get() - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("concat")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("list")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{v8}) - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("list")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.Apply(v38, []any{v2}) - v40 := lang.Apply(v31, []any{v35, v39}) - v41 := lang.Apply(v28, []any{v40}) - v42 := lang.Apply(v25, []any{v41}) - v43 := lang.Apply(v14, []any{v18, v22, v42}) - v44 := lang.Apply(v11, []any{v43}) - v3 = v44 + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("seq")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("concat")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol(".")}) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("seq")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) + } + tmp28 := tmp27.Get() + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("concat")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.Apply(tmp34, []any{v8}) + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{v2}) + tmp40 := lang.Apply(tmp31, []any{tmp35, tmp39}) + tmp41 := lang.Apply(tmp28, []any{tmp40}) + tmp42 := lang.Apply(tmp25, []any{tmp41}) + tmp43 := lang.Apply(tmp14, []any{tmp18, tmp22, tmp42}) + tmp44 := lang.Apply(tmp11, []any{tmp43}) + tmp3 = tmp44 } // end let - return v3 + return tmp3 case 2: v2 := args[0] _ = v2 v3 := args[1] _ = v3 - var v4 any + var tmp4 any { // let // let binding "op" - var v5 any - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - if lang.IsTruthy(v8) { - v5 = closed8 + var tmp5 any + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + if lang.IsTruthy(tmp8) { + tmp5 = closed8 } else { - v5 = closed8 + tmp5 = closed8 } - var v9 any = v5 + var v9 any = tmp5 _ = v9 - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("seq")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("concat")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("list")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("list")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("list")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("seq")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("concat")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) - } - v32 := v31.Get() - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("list")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - v36 := lang.Apply(v35, []any{v9}) - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("list")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.Apply(v39, []any{v2}) - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("list")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) - } - v43 := v42.Get() - v44 := lang.Apply(v43, []any{v3}) - v45 := lang.Apply(v32, []any{v36, v40, v44}) - v46 := lang.Apply(v29, []any{v45}) - v47 := lang.Apply(v26, []any{v46}) - v48 := lang.Apply(v15, []any{v19, v23, v47}) - v49 := lang.Apply(v12, []any{v48}) - v4 = v49 + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("seq")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("concat")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("list")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{lang.NewSymbol(".")}) + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("list")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.Apply(tmp22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("list")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("seq")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("concat")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) + } + tmp32 := tmp31.Get() + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("list")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) + } + tmp35 := tmp34.Get() + tmp36 := lang.Apply(tmp35, []any{v9}) + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("list")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.Apply(tmp39, []any{v2}) + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("list")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := lang.Apply(tmp43, []any{v3}) + tmp45 := lang.Apply(tmp32, []any{tmp36, tmp40, tmp44}) + tmp46 := lang.Apply(tmp29, []any{tmp45}) + tmp47 := lang.Apply(tmp26, []any{tmp46}) + tmp48 := lang.Apply(tmp15, []any{tmp19, tmp23, tmp47}) + tmp49 := lang.Apply(tmp12, []any{tmp48}) + tmp4 = tmp49 } // end let - return v4 + return tmp4 default: if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -2975,32 +2983,33 @@ func init() { _ = v2 v3 := args[1] _ = v3 - v4 := lang.NewList(args[2:]...) - var v5 any + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any { // let // let binding "op" - var v6 any - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - if lang.IsTruthy(v9) { - v6 = closed8 + var tmp6 any + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + if lang.IsTruthy(tmp9) { + tmp6 = closed8 } else { - v6 = closed8 + tmp6 = closed8 } - var v10 any = v6 + var v10 any = tmp6 _ = v10 - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - var v14 lang.FnFunc - v14 = lang.NewFnFunc(func(args ...any) any { + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -3008,201 +3017,201 @@ func init() { _ = v15 v16 := args[1] _ = v16 - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("seq")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("concat")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("list")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("seq")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) - } - v36 := v35.Get() - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("concat")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("list")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) - } - v42 := v41.Get() - v43 := lang.Apply(v42, []any{v10}) - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("list")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) - } - v46 := v45.Get() - v47 := lang.Apply(v46, []any{v15}) - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("list")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v16}) - v52 := lang.Apply(v39, []any{v43, v47, v51}) - v53 := lang.Apply(v36, []any{v52}) - v54 := lang.Apply(v33, []any{v53}) - v55 := lang.Apply(v22, []any{v26, v30, v54}) - v56 := lang.Apply(v19, []any{v55}) - return v56 + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("concat")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol(".")}) + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) + } + tmp42 := tmp41.Get() + tmp43 := lang.Apply(tmp42, []any{v10}) + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) + } + tmp46 := tmp45.Get() + tmp47 := lang.Apply(tmp46, []any{v15}) + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v16}) + tmp52 := lang.Apply(tmp39, []any{tmp43, tmp47, tmp51}) + tmp53 := lang.Apply(tmp36, []any{tmp52}) + tmp54 := lang.Apply(tmp33, []any{tmp53}) + tmp55 := lang.Apply(tmp22, []any{tmp26, tmp30, tmp54}) + tmp56 := lang.Apply(tmp19, []any{tmp55}) + return tmp56 }) - v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) - v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) + tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) if err != nil { panic(err) } - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("seq")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("concat")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("list")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("seq")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) - } - v36 := v35.Get() - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("concat")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("list")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) - } - v42 := v41.Get() - v43 := lang.Apply(v42, []any{v10}) - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("list")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) - } - v46 := v45.Get() - v47 := lang.Apply(v46, []any{v2}) - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("list")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v3}) - v52 := lang.Apply(v39, []any{v43, v47, v51}) - v53 := lang.Apply(v36, []any{v52}) - v54 := lang.Apply(v33, []any{v53}) - v55 := lang.Apply(v22, []any{v26, v30, v54}) - v56 := lang.Apply(v19, []any{v55}) - v57 := lang.Apply(v13, []any{v16, v56, v4}) - v5 = v57 + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("concat")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol(".")}) + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) + } + tmp42 := tmp41.Get() + tmp43 := lang.Apply(tmp42, []any{v10}) + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) + } + tmp46 := tmp45.Get() + tmp47 := lang.Apply(tmp46, []any{v2}) + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v3}) + tmp52 := lang.Apply(tmp39, []any{tmp43, tmp47, tmp51}) + tmp53 := lang.Apply(tmp36, []any{tmp52}) + tmp54 := lang.Apply(tmp33, []any{tmp53}) + tmp55 := lang.Apply(tmp22, []any{tmp26, tmp30, tmp54}) + tmp56 := lang.Apply(tmp19, []any{tmp55}) + tmp57 := lang.Apply(tmp13, []any{tmp16, tmp56, v4}) + tmp5 = tmp57 } // end let - return v5 + return tmp5 } }) - v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp1 = tmp1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") - if reflect.TypeOf(v4).Kind() != reflect.Func { + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - v5 := lang.Apply(v4, []any{nil, int64(0)}) - return v5 + tmp5 := lang.Apply(tmp4, []any{nil, int64(0)}) + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v0 := lang.NewSymbol("-'").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "If no ys are supplied, returns the negation of x, else subtracts\n the ys from x and returns the result. Supports arbitrary precision.\n See also: -", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1024), lang.NewKeyword("end-line"), int(1024))).(*lang.Symbol) - var v4 lang.FnFunc - v4 = lang.NewFnFunc(func(args ...any) any { + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp0 := lang.NewSymbol("-'").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "If no ys are supplied, returns the negation of x, else subtracts\n the ys from x and returns the result. Supports arbitrary precision.\n See also: -", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), tmp2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1024), lang.NewKeyword("end-line"), int(1024))).(*lang.Symbol) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v5 := args[0] _ = v5 - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("*'")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{int64(-1), v5}) - return v9 + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("*'")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.Apply(tmp8, []any{int64(-1), v5}) + return tmp9 case 2: v5 := args[0] _ = v5 v6 := args[1] _ = v6 - v7, _ := lang.FieldOrMethod(lang.Numbers, "MinusP") - if reflect.TypeOf(v7).Kind() != reflect.Func { + tmp7, _ := lang.FieldOrMethod(lang.Numbers, "MinusP") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("MinusP is not a function"))) } - v8 := lang.Apply(v7, []any{v5, v6}) - return v8 + tmp8 := lang.Apply(tmp7, []any{v5, v6}) + return tmp8 default: if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -3211,41 +3220,42 @@ func init() { _ = v5 v6 := args[1] _ = v6 - v7 := lang.NewList(args[2:]...) - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + var v7 any = lang.NewList(args[2:]...) + _ = v7 + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("-'")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("-'")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) } - v13 := v12.Get() - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("-'")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + tmp13 := tmp12.Get() + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("-'")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{v5, v6}) - v18 := lang.Apply(v10, []any{v13, v17, v7}) - return v18 + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{v5, v6}) + tmp18 := lang.Apply(tmp10, []any{tmp13, tmp17, v7}) + return tmp18 } }) - v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v3 := ns.InternWithValue(v0, v4, true) - if v0.Meta() != nil { - v3.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 := ns.InternWithValue(tmp0, tmp4, true) + if tmp0.Meta() != nil { + tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // -> { - v0 := lang.NewSymbol("->").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "Threads the expr through the forms. Inserts x as the\n second item in the first form, making a list of it if it is not a\n list already. If there are more forms, inserts the first form as the\n second item in second form, etc.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1675), lang.NewKeyword("end-line"), int(1675))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("->").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "Threads the expr through the forms. Inserts x as the\n second item in the first form, making a list of it if it is not a\n list already. If there are more forms, inserts the first form as the\n second item in second form, etc.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1675), lang.NewKeyword("end-line"), int(1675))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 3 { @@ -3257,8 +3267,9 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - var v7 any + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any { // let // let binding "x" var v8 any = v5 @@ -3267,134 +3278,134 @@ func init() { var v9 any = v6 _ = v9 for { - var v10 any + var tmp10 any if lang.IsTruthy(v9) { - var v11 any + var tmp11 any { // let // let binding "form" - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("first")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("first")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) } - v14 := v13.Get() - v15 := lang.Apply(v14, []any{v9}) - var v16 any = v15 + tmp14 := tmp13.Get() + tmp15 := lang.Apply(tmp14, []any{v9}) + var v16 any = tmp15 _ = v16 // let binding "threaded" - var v17 any - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("seq?")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + var tmp17 any + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("seq?")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) } - v20 := v19.Get() - v21 := lang.Apply(v20, []any{v16}) - if lang.IsTruthy(v21) { - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("with-meta")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + tmp20 := tmp19.Get() + tmp21 := lang.Apply(tmp20, []any{v16}) + if lang.IsTruthy(tmp21) { + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("with-meta")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) } - v24 := v23.Get() - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("seq")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + tmp24 := tmp23.Get() + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("seq")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) } - v27 := v26.Get() - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("concat")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + tmp27 := tmp26.Get() + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("concat")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) } - v30 := v29.Get() - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + tmp30 := tmp29.Get() + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) } - v33 := v32.Get() - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("first")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + tmp33 := tmp32.Get() + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("first")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) } - v36 := v35.Get() - v37 := lang.Apply(v36, []any{v16}) - v38 := lang.Apply(v33, []any{v37}) - v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v40 := v39.FindInternedVar(lang.NewSymbol("list")) - if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) + tmp36 := tmp35.Get() + tmp37 := lang.Apply(tmp36, []any{v16}) + tmp38 := lang.Apply(tmp33, []any{tmp37}) + tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp40 := tmp39.FindInternedVar(lang.NewSymbol("list")) + if tmp40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) } - v41 := v40.Get() - v42 := lang.Apply(v41, []any{v8}) - v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v44 := v43.FindInternedVar(lang.NewSymbol("next")) - if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) + tmp41 := tmp40.Get() + tmp42 := lang.Apply(tmp41, []any{v8}) + tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp44 := tmp43.FindInternedVar(lang.NewSymbol("next")) + if tmp44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) } - v45 := v44.Get() - v46 := lang.Apply(v45, []any{v16}) - v47 := lang.Apply(v30, []any{v38, v42, v46}) - v48 := lang.Apply(v27, []any{v47}) - v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v50 := v49.FindInternedVar(lang.NewSymbol("meta")) - if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) + tmp45 := tmp44.Get() + tmp46 := lang.Apply(tmp45, []any{v16}) + tmp47 := lang.Apply(tmp30, []any{tmp38, tmp42, tmp46}) + tmp48 := lang.Apply(tmp27, []any{tmp47}) + tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp50 := tmp49.FindInternedVar(lang.NewSymbol("meta")) + if tmp50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) } - v51 := v50.Get() - v52 := lang.Apply(v51, []any{v16}) - v53 := lang.Apply(v24, []any{v48, v52}) - v17 = v53 + tmp51 := tmp50.Get() + tmp52 := lang.Apply(tmp51, []any{v16}) + tmp53 := lang.Apply(tmp24, []any{tmp48, tmp52}) + tmp17 = tmp53 } else { - v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v55 := v54.FindInternedVar(lang.NewSymbol("list")) - if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) + tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp55 := tmp54.FindInternedVar(lang.NewSymbol("list")) + if tmp55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) } - v56 := v55.Get() - v57 := lang.Apply(v56, []any{v16, v8}) - v17 = v57 + tmp56 := tmp55.Get() + tmp57 := lang.Apply(tmp56, []any{v16, v8}) + tmp17 = tmp57 } - var v58 any = v17 + var v58 any = tmp17 _ = v58 - var v59 any = v58 - v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v62 := v61.FindInternedVar(lang.NewSymbol("next")) - if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) + var tmp59 any = v58 + tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp62 := tmp61.FindInternedVar(lang.NewSymbol("next")) + if tmp62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) } - v63 := v62.Get() - v64 := lang.Apply(v63, []any{v9}) - var v60 any = v64 - v8 = v59 - v9 = v60 + tmp63 := tmp62.Get() + tmp64 := lang.Apply(tmp63, []any{v9}) + var tmp60 any = tmp64 + v8 = tmp59 + v9 = tmp60 continue } // end let - v10 = v11 + tmp10 = tmp11 } else { - v10 = v8 + tmp10 = v8 } - v7 = v10 + tmp7 = tmp10 break } } // end let - return v7 + return tmp7 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // ->> { - v0 := lang.NewSymbol("->>").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "Threads the expr through the forms. Inserts x as the\n last item in the first form, making a list of it if it is not a\n list already. If there are more forms, inserts the first form as the\n last item in second form, etc.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1691), lang.NewKeyword("end-line"), int(1691))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("->>").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "Threads the expr through the forms. Inserts x as the\n last item in the first form, making a list of it if it is not a\n list already. If there are more forms, inserts the first form as the\n last item in second form, etc.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1691), lang.NewKeyword("end-line"), int(1691))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 3 { @@ -3406,8 +3417,9 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - var v7 any + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any { // let // let binding "x" var v8 any = v5 @@ -3416,149 +3428,149 @@ func init() { var v9 any = v6 _ = v9 for { - var v10 any + var tmp10 any if lang.IsTruthy(v9) { - var v11 any + var tmp11 any { // let // let binding "form" - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("first")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("first")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) } - v14 := v13.Get() - v15 := lang.Apply(v14, []any{v9}) - var v16 any = v15 + tmp14 := tmp13.Get() + tmp15 := lang.Apply(tmp14, []any{v9}) + var v16 any = tmp15 _ = v16 // let binding "threaded" - var v17 any - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("seq?")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + var tmp17 any + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("seq?")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) } - v20 := v19.Get() - v21 := lang.Apply(v20, []any{v16}) - if lang.IsTruthy(v21) { - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("with-meta")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + tmp20 := tmp19.Get() + tmp21 := lang.Apply(tmp20, []any{v16}) + if lang.IsTruthy(tmp21) { + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("with-meta")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) } - v24 := v23.Get() - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("seq")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + tmp24 := tmp23.Get() + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("seq")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) } - v27 := v26.Get() - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("concat")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + tmp27 := tmp26.Get() + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("concat")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) } - v30 := v29.Get() - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + tmp30 := tmp29.Get() + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) } - v33 := v32.Get() - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("first")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + tmp33 := tmp32.Get() + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("first")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) } - v36 := v35.Get() - v37 := lang.Apply(v36, []any{v16}) - v38 := lang.Apply(v33, []any{v37}) - v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v40 := v39.FindInternedVar(lang.NewSymbol("next")) - if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) + tmp36 := tmp35.Get() + tmp37 := lang.Apply(tmp36, []any{v16}) + tmp38 := lang.Apply(tmp33, []any{tmp37}) + tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp40 := tmp39.FindInternedVar(lang.NewSymbol("next")) + if tmp40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) } - v41 := v40.Get() - v42 := lang.Apply(v41, []any{v16}) - v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v44 := v43.FindInternedVar(lang.NewSymbol("list")) - if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) + tmp41 := tmp40.Get() + tmp42 := lang.Apply(tmp41, []any{v16}) + tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp44 := tmp43.FindInternedVar(lang.NewSymbol("list")) + if tmp44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) } - v45 := v44.Get() - v46 := lang.Apply(v45, []any{v8}) - v47 := lang.Apply(v30, []any{v38, v42, v46}) - v48 := lang.Apply(v27, []any{v47}) - v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v50 := v49.FindInternedVar(lang.NewSymbol("meta")) - if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) + tmp45 := tmp44.Get() + tmp46 := lang.Apply(tmp45, []any{v8}) + tmp47 := lang.Apply(tmp30, []any{tmp38, tmp42, tmp46}) + tmp48 := lang.Apply(tmp27, []any{tmp47}) + tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp50 := tmp49.FindInternedVar(lang.NewSymbol("meta")) + if tmp50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) } - v51 := v50.Get() - v52 := lang.Apply(v51, []any{v16}) - v53 := lang.Apply(v24, []any{v48, v52}) - v17 = v53 + tmp51 := tmp50.Get() + tmp52 := lang.Apply(tmp51, []any{v16}) + tmp53 := lang.Apply(tmp24, []any{tmp48, tmp52}) + tmp17 = tmp53 } else { - v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v55 := v54.FindInternedVar(lang.NewSymbol("list")) - if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) + tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp55 := tmp54.FindInternedVar(lang.NewSymbol("list")) + if tmp55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) } - v56 := v55.Get() - v57 := lang.Apply(v56, []any{v16, v8}) - v17 = v57 + tmp56 := tmp55.Get() + tmp57 := lang.Apply(tmp56, []any{v16, v8}) + tmp17 = tmp57 } - var v58 any = v17 + var v58 any = tmp17 _ = v58 - var v59 any = v58 - v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v62 := v61.FindInternedVar(lang.NewSymbol("next")) - if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) + var tmp59 any = v58 + tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp62 := tmp61.FindInternedVar(lang.NewSymbol("next")) + if tmp62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) } - v63 := v62.Get() - v64 := lang.Apply(v63, []any{v9}) - var v60 any = v64 - v8 = v59 - v9 = v60 + tmp63 := tmp62.Get() + tmp64 := lang.Apply(tmp63, []any{v9}) + var tmp60 any = tmp64 + v8 = tmp59 + v9 = tmp60 continue } // end let - v10 = v11 + tmp10 = tmp11 } else { - v10 = v8 + tmp10 = v8 } - v7 = v10 + tmp7 = tmp10 break } } // end let - return v7 + return tmp7 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // -protocols { - v0 := lang.NewSymbol("-protocols").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("doc"), "Private store of protocols. Go's reflection capabilities\n don't yet support a native interface-based implementation, so\n protocols are implemented in Glojure as maps from type to protocol\n method implementations.", lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(21), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(26), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - v3 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("coll-reduce"), nil), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("coll-reduce"), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("f"), lang.NewSymbol("val")))))) - v4 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("internal-reduce"), nil), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("internal-reduce"), lang.NewVector(lang.NewSymbol("seq"), lang.NewSymbol("f"), lang.NewSymbol("start")))))) - v5 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("kv-reduce"), nil), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("kv-reduce"), lang.NewVector(lang.NewSymbol("amap"), lang.NewSymbol("f"), lang.NewSymbol("init")))))) - v6 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("datafy"), nil), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("datafy"), lang.NewVector(lang.NewSymbol("o")), "return a representation of o as data (default identity)")))) - v7 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("nav"), nil), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("nav"), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("k"), lang.NewSymbol("v")), "return (possibly transformed) v in the context of coll and k (a key/index or nil),\ndefaults to returning v.")))) - v8 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("make-reader"), nil, lang.NewKeyword("make-writer"), nil, lang.NewKeyword("make-input-stream"), nil, lang.NewKeyword("make-output-stream"), nil), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("make-reader"), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("opts")), "Creates an io.Reader. See also IOFactory docs."), lang.NewList(lang.NewSymbol("make-writer"), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("opts")), "Creates an io.Reader. See also IOFactory docs."), lang.NewList(lang.NewSymbol("make-input-stream"), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("opts")), "Creates a BufferedInputStream. See also IOFactory docs."), lang.NewList(lang.NewSymbol("make-output-stream"), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("opts")), "Creates a BufferedOutputStream. See also IOFactory docs.")))) - v2 := lang.NewAtom(lang.NewMap(lang.NewSymbol("CollReduce"), v3, lang.NewSymbol("InternalReduce"), v4, lang.NewSymbol("IKVReduce"), v5, lang.NewSymbol("Datafiable"), v6, lang.NewSymbol("Navigable"), v7, lang.NewSymbol("IOFactory"), v8)) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp0 := lang.NewSymbol("-protocols").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("doc"), "Private store of protocols. Go's reflection capabilities\n don't yet support a native interface-based implementation, so\n protocols are implemented in Glojure as maps from type to protocol\n method implementations.", lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(21), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(26), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp3 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("coll-reduce"), nil), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("coll-reduce"), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("f"), lang.NewSymbol("val")))))) + tmp4 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("internal-reduce"), nil), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("internal-reduce"), lang.NewVector(lang.NewSymbol("seq"), lang.NewSymbol("f"), lang.NewSymbol("start")))))) + tmp5 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("kv-reduce"), nil), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("kv-reduce"), lang.NewVector(lang.NewSymbol("amap"), lang.NewSymbol("f"), lang.NewSymbol("init")))))) + tmp6 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("datafy"), nil), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("datafy"), lang.NewVector(lang.NewSymbol("o")), "return a representation of o as data (default identity)")))) + tmp7 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("nav"), nil), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("nav"), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("k"), lang.NewSymbol("v")), "return (possibly transformed) v in the context of coll and k (a key/index or nil),\ndefaults to returning v.")))) + tmp8 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("make-reader"), nil, lang.NewKeyword("make-writer"), nil, lang.NewKeyword("make-input-stream"), nil, lang.NewKeyword("make-output-stream"), nil), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("make-reader"), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("opts")), "Creates an io.Reader. See also IOFactory docs."), lang.NewList(lang.NewSymbol("make-writer"), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("opts")), "Creates an io.Reader. See also IOFactory docs."), lang.NewList(lang.NewSymbol("make-input-stream"), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("opts")), "Creates a BufferedInputStream. See also IOFactory docs."), lang.NewList(lang.NewSymbol("make-output-stream"), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("opts")), "Creates a BufferedOutputStream. See also IOFactory docs.")))) + tmp2 := lang.NewAtom(lang.NewMap(lang.NewSymbol("CollReduce"), tmp3, lang.NewSymbol("InternalReduce"), tmp4, lang.NewSymbol("IKVReduce"), tmp5, lang.NewSymbol("Datafiable"), tmp6, lang.NewSymbol("Navigable"), tmp7, lang.NewSymbol("IOFactory"), tmp8)) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // .. { - v0 := lang.NewSymbol("..").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("form")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("form"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "form => fieldName-symbol or (instanceMethodName-symbol args*)\n\n Expands into a member access (.) of the first member on the first\n argument, followed by the next member on the result, etc. For\n instance:\n\n (.. System (getProperties) (get \"os.name\"))\n\n expands to:\n\n (. (. System (getProperties)) (get \"os.name\"))\n\n but is easier to write, read, and understand.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1657), lang.NewKeyword("end-line"), int(1657))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("..").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("form")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("form"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "form => fieldName-symbol or (instanceMethodName-symbol args*)\n\n Expands into a member access (.) of the first member on the first\n argument, followed by the next member on the result, etc. For\n instance:\n\n (.. System (getProperties) (get \"os.name\"))\n\n expands to:\n\n (. (. System (getProperties)) (get \"os.name\"))\n\n but is easier to write, read, and understand.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1657), lang.NewKeyword("end-line"), int(1657))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 4: v3 := args[0] @@ -3569,42 +3581,42 @@ func init() { _ = v5 v6 := args[3] _ = v6 - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("seq")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("concat")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("list")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{lang.NewSymbol(".")}) - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("list")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.Apply(v19, []any{v5}) - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("list")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.Apply(v23, []any{v6}) - v25 := lang.Apply(v12, []any{v16, v20, v24}) - v26 := lang.Apply(v9, []any{v25}) - return v26 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("seq")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("concat")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("list")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("list")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.Apply(tmp19, []any{v5}) + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("list")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.Apply(tmp23, []any{v6}) + tmp25 := lang.Apply(tmp12, []any{tmp16, tmp20, tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp25}) + return tmp26 default: if len(args) < 4 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -3617,265 +3629,266 @@ func init() { _ = v5 v6 := args[3] _ = v6 - v7 := lang.NewList(args[4:]...) - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("seq")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("concat")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("..")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("seq")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("concat")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol(".")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{v5}) - v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v36 := v35.FindInternedVar(lang.NewSymbol("list")) - if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) - } - v37 := v36.Get() - v38 := lang.Apply(v37, []any{v6}) - v39 := lang.Apply(v26, []any{v30, v34, v38}) - v40 := lang.Apply(v23, []any{v39}) - v41 := lang.Apply(v20, []any{v40}) - v42 := lang.Apply(v13, []any{v17, v41, v7}) - v43 := lang.Apply(v10, []any{v42}) - return v43 - } - }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + var v7 any = lang.NewList(args[4:]...) + _ = v7 + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("seq")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("concat")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("..")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol(".")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{v5}) + tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp36 := tmp35.FindInternedVar(lang.NewSymbol("list")) + if tmp36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) + } + tmp37 := tmp36.Get() + tmp38 := lang.Apply(tmp37, []any{v6}) + tmp39 := lang.Apply(tmp26, []any{tmp30, tmp34, tmp38}) + tmp40 := lang.Apply(tmp23, []any{tmp39}) + tmp41 := lang.Apply(tmp20, []any{tmp40}) + tmp42 := lang.Apply(tmp13, []any{tmp17, tmp41, v7}) + tmp43 := lang.Apply(tmp10, []any{tmp42}) + return tmp43 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // / { - var v1 lang.FnFunc - v1 = lang.NewFnFunc(func(args ...any) any { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v2 := args[0] _ = v2 - var v3 any + var tmp3 any { // let // let binding "op" - var v4 any - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - if lang.IsTruthy(v7) { - v4 = closed9 + var tmp4 any + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + if lang.IsTruthy(tmp7) { + tmp4 = closed9 } else { - v4 = closed9 + tmp4 = closed9 } - var v8 any = v4 + var v8 any = tmp4 _ = v8 - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("seq")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("concat")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("list")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("list")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("list")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("seq")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) - } - v28 := v27.Get() - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("concat")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("list")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{v8}) - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("list")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.Apply(v38, []any{v2}) - v40 := lang.Apply(v31, []any{v35, v39}) - v41 := lang.Apply(v28, []any{v40}) - v42 := lang.Apply(v25, []any{v41}) - v43 := lang.Apply(v14, []any{v18, v22, v42}) - v44 := lang.Apply(v11, []any{v43}) - v3 = v44 + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("seq")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("concat")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol(".")}) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("seq")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) + } + tmp28 := tmp27.Get() + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("concat")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.Apply(tmp34, []any{v8}) + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{v2}) + tmp40 := lang.Apply(tmp31, []any{tmp35, tmp39}) + tmp41 := lang.Apply(tmp28, []any{tmp40}) + tmp42 := lang.Apply(tmp25, []any{tmp41}) + tmp43 := lang.Apply(tmp14, []any{tmp18, tmp22, tmp42}) + tmp44 := lang.Apply(tmp11, []any{tmp43}) + tmp3 = tmp44 } // end let - return v3 + return tmp3 case 2: v2 := args[0] _ = v2 v3 := args[1] _ = v3 - var v4 any + var tmp4 any { // let // let binding "op" - var v5 any - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - if lang.IsTruthy(v8) { - v5 = closed9 + var tmp5 any + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + if lang.IsTruthy(tmp8) { + tmp5 = closed9 } else { - v5 = closed9 + tmp5 = closed9 } - var v9 any = v5 + var v9 any = tmp5 _ = v9 - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("seq")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("concat")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("list")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("list")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("list")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("seq")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("concat")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) - } - v32 := v31.Get() - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("list")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - v36 := lang.Apply(v35, []any{v9}) - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("list")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.Apply(v39, []any{v2}) - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("list")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) - } - v43 := v42.Get() - v44 := lang.Apply(v43, []any{v3}) - v45 := lang.Apply(v32, []any{v36, v40, v44}) - v46 := lang.Apply(v29, []any{v45}) - v47 := lang.Apply(v26, []any{v46}) - v48 := lang.Apply(v15, []any{v19, v23, v47}) - v49 := lang.Apply(v12, []any{v48}) - v4 = v49 + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("seq")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("concat")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("list")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{lang.NewSymbol(".")}) + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("list")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.Apply(tmp22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("list")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("seq")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("concat")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) + } + tmp32 := tmp31.Get() + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("list")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) + } + tmp35 := tmp34.Get() + tmp36 := lang.Apply(tmp35, []any{v9}) + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("list")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.Apply(tmp39, []any{v2}) + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("list")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := lang.Apply(tmp43, []any{v3}) + tmp45 := lang.Apply(tmp32, []any{tmp36, tmp40, tmp44}) + tmp46 := lang.Apply(tmp29, []any{tmp45}) + tmp47 := lang.Apply(tmp26, []any{tmp46}) + tmp48 := lang.Apply(tmp15, []any{tmp19, tmp23, tmp47}) + tmp49 := lang.Apply(tmp12, []any{tmp48}) + tmp4 = tmp49 } // end let - return v4 + return tmp4 default: if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -3884,32 +3897,33 @@ func init() { _ = v2 v3 := args[1] _ = v3 - v4 := lang.NewList(args[2:]...) - var v5 any + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any { // let // let binding "op" - var v6 any - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - if lang.IsTruthy(v9) { - v6 = closed9 + var tmp6 any + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + if lang.IsTruthy(tmp9) { + tmp6 = closed9 } else { - v6 = closed9 + tmp6 = closed9 } - var v10 any = v6 + var v10 any = tmp6 _ = v10 - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - var v14 lang.FnFunc - v14 = lang.NewFnFunc(func(args ...any) any { + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -3917,201 +3931,201 @@ func init() { _ = v15 v16 := args[1] _ = v16 - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("seq")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("concat")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("list")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("seq")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) - } - v36 := v35.Get() - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("concat")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("list")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) - } - v42 := v41.Get() - v43 := lang.Apply(v42, []any{v10}) - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("list")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) - } - v46 := v45.Get() - v47 := lang.Apply(v46, []any{v15}) - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("list")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v16}) - v52 := lang.Apply(v39, []any{v43, v47, v51}) - v53 := lang.Apply(v36, []any{v52}) - v54 := lang.Apply(v33, []any{v53}) - v55 := lang.Apply(v22, []any{v26, v30, v54}) - v56 := lang.Apply(v19, []any{v55}) - return v56 + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("concat")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol(".")}) + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) + } + tmp42 := tmp41.Get() + tmp43 := lang.Apply(tmp42, []any{v10}) + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) + } + tmp46 := tmp45.Get() + tmp47 := lang.Apply(tmp46, []any{v15}) + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v16}) + tmp52 := lang.Apply(tmp39, []any{tmp43, tmp47, tmp51}) + tmp53 := lang.Apply(tmp36, []any{tmp52}) + tmp54 := lang.Apply(tmp33, []any{tmp53}) + tmp55 := lang.Apply(tmp22, []any{tmp26, tmp30, tmp54}) + tmp56 := lang.Apply(tmp19, []any{tmp55}) + return tmp56 }) - v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) - v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) + tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) if err != nil { panic(err) } - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("seq")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("concat")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("list")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("seq")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) - } - v36 := v35.Get() - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("concat")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("list")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) - } - v42 := v41.Get() - v43 := lang.Apply(v42, []any{v10}) - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("list")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) - } - v46 := v45.Get() - v47 := lang.Apply(v46, []any{v2}) - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("list")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v3}) - v52 := lang.Apply(v39, []any{v43, v47, v51}) - v53 := lang.Apply(v36, []any{v52}) - v54 := lang.Apply(v33, []any{v53}) - v55 := lang.Apply(v22, []any{v26, v30, v54}) - v56 := lang.Apply(v19, []any{v55}) - v57 := lang.Apply(v13, []any{v16, v56, v4}) - v5 = v57 + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("concat")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol(".")}) + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) + } + tmp42 := tmp41.Get() + tmp43 := lang.Apply(tmp42, []any{v10}) + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) + } + tmp46 := tmp45.Get() + tmp47 := lang.Apply(tmp46, []any{v2}) + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v3}) + tmp52 := lang.Apply(tmp39, []any{tmp43, tmp47, tmp51}) + tmp53 := lang.Apply(tmp36, []any{tmp52}) + tmp54 := lang.Apply(tmp33, []any{tmp53}) + tmp55 := lang.Apply(tmp22, []any{tmp26, tmp30, tmp54}) + tmp56 := lang.Apply(tmp19, []any{tmp55}) + tmp57 := lang.Apply(tmp13, []any{tmp16, tmp56, v4}) + tmp5 = tmp57 } // end let - return v5 + return tmp5 } }) - v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp1 = tmp1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") - if reflect.TypeOf(v4).Kind() != reflect.Func { + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - v5 := lang.Apply(v4, []any{nil, int64(1)}) - return v5 + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v0 := lang.NewSymbol("/").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "If no denominators are supplied, returns 1/numerator,\n else returns numerator divided by all of the denominators.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1013), lang.NewKeyword("end-line"), int(1013))).(*lang.Symbol) - var v4 lang.FnFunc - v4 = lang.NewFnFunc(func(args ...any) any { + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp0 := lang.NewSymbol("/").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "If no denominators are supplied, returns 1/numerator,\n else returns numerator divided by all of the denominators.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), tmp2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1013), lang.NewKeyword("end-line"), int(1013))).(*lang.Symbol) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v5 := args[0] _ = v5 - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("/")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{int64(1), v5}) - return v9 + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("/")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.Apply(tmp8, []any{int64(1), v5}) + return tmp9 case 2: v5 := args[0] _ = v5 v6 := args[1] _ = v6 - v7, _ := lang.FieldOrMethod(lang.Numbers, "Divide") - if reflect.TypeOf(v7).Kind() != reflect.Func { + tmp7, _ := lang.FieldOrMethod(lang.Numbers, "Divide") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Divide is not a function"))) } - v8 := lang.Apply(v7, []any{v5, v6}) - return v8 + tmp8 := lang.Apply(tmp7, []any{v5, v6}) + return tmp8 default: if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -4120,41 +4134,43 @@ func init() { _ = v5 v6 := args[1] _ = v6 - v7 := lang.NewList(args[2:]...) - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + var v7 any = lang.NewList(args[2:]...) + _ = v7 + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("/")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("/")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) } - v13 := v12.Get() - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("/")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + tmp13 := tmp12.Get() + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("/")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{v5, v6}) - v18 := lang.Apply(v10, []any{v13, v17, v7}) - return v18 + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{v5, v6}) + tmp18 := lang.Apply(tmp10, []any{tmp13, tmp17, v7}) + return tmp18 } }) - v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v3 := ns.InternWithValue(v0, v4, true) - if v0.Meta() != nil { - v3.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 := ns.InternWithValue(tmp0, tmp4, true) + if tmp0.Meta() != nil { + tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // < { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function <__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -4162,84 +4178,84 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("seq")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("concat")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("list")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("list")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("list")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("seq")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("concat")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("list")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/Lt")}) - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("list")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{v3}) - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("list")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.Apply(v38, []any{v4}) - v40 := lang.Apply(v27, []any{v31, v35, v39}) - v41 := lang.Apply(v24, []any{v40}) - v42 := lang.Apply(v21, []any{v41}) - v43 := lang.Apply(v10, []any{v14, v18, v42}) - v44 := lang.Apply(v7, []any{v43}) - return v44 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("concat")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("list")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol(".")}) + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("seq")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("concat")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("list")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.Apply(tmp30, []any{lang.NewSymbol("glojure.core/Lt")}) + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.Apply(tmp34, []any{v3}) + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{v4}) + tmp40 := lang.Apply(tmp27, []any{tmp31, tmp35, tmp39}) + tmp41 := lang.Apply(tmp24, []any{tmp40}) + tmp42 := lang.Apply(tmp21, []any{tmp41}) + tmp43 := lang.Apply(tmp10, []any{tmp14, tmp18, tmp42}) + tmp44 := lang.Apply(tmp7, []any{tmp43}) + return tmp44 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("<").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns non-nil if nums are in monotonically increasing order,\n otherwise false.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(893), lang.NewKeyword("end-line"), int(893))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("<").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns non-nil if nums are in monotonically increasing order,\n otherwise false.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(893), lang.NewKeyword("end-line"), int(893))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v4 := args[0] @@ -4250,12 +4266,12 @@ func init() { _ = v4 v5 := args[1] _ = v5 - v6, _ := lang.FieldOrMethod(lang.Numbers, "Lt") - if reflect.TypeOf(v6).Kind() != reflect.Func { + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Lt") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Lt is not a function"))) } - v7 := lang.Apply(v6, []any{v4, v5}) - return v7 + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 default: if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -4264,82 +4280,84 @@ func init() { _ = v4 v5 := args[1] _ = v5 - v6 := lang.NewList(args[2:]...) + var v6 any = lang.NewList(args[2:]...) + _ = v6 recur_loop_150: - var v7 any - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("<")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v4, v5}) - if lang.IsTruthy(v11) { - var v12 any - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("next")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{v6}) - if lang.IsTruthy(v16) { - var v17 any = v5 - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("first")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{v6}) - var v18 any = v22 - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("next")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.Apply(v26, []any{v6}) - var v23 any = v27 - v4 = v17 - v5 = v18 - v6 = v23 + var tmp7 any + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("<")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v4, v5}) + if lang.IsTruthy(tmp11) { + var tmp12 any + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("next")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{v6}) + if lang.IsTruthy(tmp16) { + var tmp17 any = v5 + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("first")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, []any{v6}) + var tmp18 any = tmp22 + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("next")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.Apply(tmp26, []any{v6}) + var tmp23 any = tmp27 + v4 = tmp17 + v5 = tmp18 + v6 = tmp23 goto recur_loop_150 } else { - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("<")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("first")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{v6}) - v35 := lang.Apply(v30, []any{v5, v34}) - v12 = v35 - } - v7 = v12 + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("<")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("first")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{v6}) + tmp35 := lang.Apply(tmp30, []any{v5, tmp34}) + tmp12 = tmp35 + } + tmp7 = tmp12 } else { - v7 = false + tmp7 = false } - return v7 + return tmp7 } }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // <= { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function <=__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -4347,84 +4365,84 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("seq")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("concat")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("list")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("list")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("list")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("seq")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("concat")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("list")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/Lte")}) - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("list")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{v3}) - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("list")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.Apply(v38, []any{v4}) - v40 := lang.Apply(v27, []any{v31, v35, v39}) - v41 := lang.Apply(v24, []any{v40}) - v42 := lang.Apply(v21, []any{v41}) - v43 := lang.Apply(v10, []any{v14, v18, v42}) - v44 := lang.Apply(v7, []any{v43}) - return v44 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("concat")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("list")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol(".")}) + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("seq")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("concat")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("list")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.Apply(tmp30, []any{lang.NewSymbol("glojure.core/Lte")}) + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.Apply(tmp34, []any{v3}) + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{v4}) + tmp40 := lang.Apply(tmp27, []any{tmp31, tmp35, tmp39}) + tmp41 := lang.Apply(tmp24, []any{tmp40}) + tmp42 := lang.Apply(tmp21, []any{tmp41}) + tmp43 := lang.Apply(tmp10, []any{tmp14, tmp18, tmp42}) + tmp44 := lang.Apply(tmp7, []any{tmp43}) + return tmp44 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("<=").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns non-nil if nums are in monotonically non-decreasing order,\n otherwise false.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1048), lang.NewKeyword("end-line"), int(1048))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("<=").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns non-nil if nums are in monotonically non-decreasing order,\n otherwise false.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1048), lang.NewKeyword("end-line"), int(1048))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v4 := args[0] @@ -4435,12 +4453,12 @@ func init() { _ = v4 v5 := args[1] _ = v5 - v6, _ := lang.FieldOrMethod(lang.Numbers, "Lte") - if reflect.TypeOf(v6).Kind() != reflect.Func { + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Lte") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Lte is not a function"))) } - v7 := lang.Apply(v6, []any{v4, v5}) - return v7 + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 default: if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -4449,82 +4467,84 @@ func init() { _ = v4 v5 := args[1] _ = v5 - v6 := lang.NewList(args[2:]...) + var v6 any = lang.NewList(args[2:]...) + _ = v6 recur_loop_194: - var v7 any - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("<=")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v4, v5}) - if lang.IsTruthy(v11) { - var v12 any - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("next")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{v6}) - if lang.IsTruthy(v16) { - var v17 any = v5 - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("first")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{v6}) - var v18 any = v22 - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("next")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.Apply(v26, []any{v6}) - var v23 any = v27 - v4 = v17 - v5 = v18 - v6 = v23 + var tmp7 any + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("<=")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v4, v5}) + if lang.IsTruthy(tmp11) { + var tmp12 any + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("next")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{v6}) + if lang.IsTruthy(tmp16) { + var tmp17 any = v5 + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("first")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, []any{v6}) + var tmp18 any = tmp22 + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("next")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.Apply(tmp26, []any{v6}) + var tmp23 any = tmp27 + v4 = tmp17 + v5 = tmp18 + v6 = tmp23 goto recur_loop_194 } else { - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("<=")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("first")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{v6}) - v35 := lang.Apply(v30, []any{v5, v34}) - v12 = v35 - } - v7 = v12 + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("<=")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("first")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{v6}) + tmp35 := lang.Apply(tmp30, []any{v5, tmp34}) + tmp12 = tmp35 + } + tmp7 = tmp12 } else { - v7 = false + tmp7 = false } - return v7 + return tmp7 } }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // = { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function =__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -4532,63 +4552,63 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("seq")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("concat")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("list")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("list")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{lang.NewSymbol("glojure.lang.Util")}) - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("list")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{lang.NewSymbol("glojure.core/equiv")}) - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("list")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.Apply(v25, []any{v3}) - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{v4}) - v31 := lang.Apply(v10, []any{v14, v18, v22, v26, v30}) - v32 := lang.Apply(v7, []any{v31}) - return v32 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("concat")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("list")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol(".")}) + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("glojure.lang.Util")}) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("glojure.core/equiv")}) + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.Apply(tmp25, []any{v3}) + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{v4}) + tmp31 := lang.Apply(tmp10, []any{tmp14, tmp18, tmp22, tmp26, tmp30}) + tmp32 := lang.Apply(tmp7, []any{tmp31}) + return tmp32 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("=").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Equality. Returns true if x equals y, false if not. Same as\n Java x.equals(y) except it also works for nil, and compares\n numbers and collections in a type-independent manner. Clojure's immutable data\n structures define equals() (and thus =) as a value, not an identity,\n comparison.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(776), lang.NewKeyword("end-line"), int(776))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("=").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Equality. Returns true if x equals y, false if not. Same as\n Java x.equals(y) except it also works for nil, and compares\n numbers and collections in a type-independent manner. Clojure's immutable data\n structures define equals() (and thus =) as a value, not an identity,\n comparison.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(776), lang.NewKeyword("end-line"), int(776))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v4 := args[0] @@ -4599,8 +4619,8 @@ func init() { _ = v4 v5 := args[1] _ = v5 - v6 := lang.Apply(lang.Equiv, []any{v4, v5}) - return v6 + tmp6 := lang.Apply(lang.Equiv, []any{v4, v5}) + return tmp6 default: if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -4609,70 +4629,72 @@ func init() { _ = v4 v5 := args[1] _ = v5 - v6 := lang.NewList(args[2:]...) + var v6 any = lang.NewList(args[2:]...) + _ = v6 recur_loop_126: - var v7 any - v8 := lang.Apply(lang.Equiv, []any{v4, v5}) - if lang.IsTruthy(v8) { - var v9 any - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("next")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{v6}) - if lang.IsTruthy(v13) { - var v14 any = v5 - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("first")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{v6}) - var v15 any = v19 - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("next")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.Apply(v23, []any{v6}) - var v20 any = v24 - v4 = v14 - v5 = v15 - v6 = v20 + var tmp7 any + tmp8 := lang.Apply(lang.Equiv, []any{v4, v5}) + if lang.IsTruthy(tmp8) { + var tmp9 any + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("next")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{v6}) + if lang.IsTruthy(tmp13) { + var tmp14 any = v5 + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("first")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{v6}) + var tmp15 any = tmp19 + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("next")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.Apply(tmp23, []any{v6}) + var tmp20 any = tmp24 + v4 = tmp14 + v5 = tmp15 + v6 = tmp20 goto recur_loop_126 } else { - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("first")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("first")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) } - v27 := v26.Get() - v28 := lang.Apply(v27, []any{v6}) - v29 := lang.Apply(lang.Equiv, []any{v5, v28}) - v9 = v29 + tmp27 := tmp26.Get() + tmp28 := lang.Apply(tmp27, []any{v6}) + tmp29 := lang.Apply(lang.Equiv, []any{v5, tmp28}) + tmp9 = tmp29 } - v7 = v9 + tmp7 = tmp9 } else { - v7 = false + tmp7 = false } - return v7 + return tmp7 } }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // == { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function ==__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -4680,84 +4702,84 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("seq")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("concat")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("list")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("list")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("list")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("seq")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("concat")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("list")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/Equiv")}) - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("list")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{v3}) - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("list")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.Apply(v38, []any{v4}) - v40 := lang.Apply(v27, []any{v31, v35, v39}) - v41 := lang.Apply(v24, []any{v40}) - v42 := lang.Apply(v21, []any{v41}) - v43 := lang.Apply(v10, []any{v14, v18, v42}) - v44 := lang.Apply(v7, []any{v43}) - return v44 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("concat")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("list")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol(".")}) + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("seq")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("concat")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("list")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.Apply(tmp30, []any{lang.NewSymbol("glojure.core/Equiv")}) + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.Apply(tmp34, []any{v3}) + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{v4}) + tmp40 := lang.Apply(tmp27, []any{tmp31, tmp35, tmp39}) + tmp41 := lang.Apply(tmp24, []any{tmp40}) + tmp42 := lang.Apply(tmp21, []any{tmp41}) + tmp43 := lang.Apply(tmp10, []any{tmp14, tmp18, tmp42}) + tmp44 := lang.Apply(tmp7, []any{tmp43}) + return tmp44 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("==").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns non-nil if nums all have the equivalent\n value (type-independent), otherwise false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1093), lang.NewKeyword("end-line"), int(1093))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("==").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns non-nil if nums all have the equivalent\n value (type-independent), otherwise false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1093), lang.NewKeyword("end-line"), int(1093))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v4 := args[0] @@ -4768,12 +4790,12 @@ func init() { _ = v4 v5 := args[1] _ = v5 - v6, _ := lang.FieldOrMethod(lang.Numbers, "Equiv") - if reflect.TypeOf(v6).Kind() != reflect.Func { + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Equiv") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Equiv is not a function"))) } - v7 := lang.Apply(v6, []any{v4, v5}) - return v7 + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 default: if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -4782,82 +4804,84 @@ func init() { _ = v4 v5 := args[1] _ = v5 - v6 := lang.NewList(args[2:]...) + var v6 any = lang.NewList(args[2:]...) + _ = v6 recur_loop_206: - var v7 any - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("==")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v4, v5}) - if lang.IsTruthy(v11) { - var v12 any - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("next")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{v6}) - if lang.IsTruthy(v16) { - var v17 any = v5 - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("first")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{v6}) - var v18 any = v22 - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("next")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.Apply(v26, []any{v6}) - var v23 any = v27 - v4 = v17 - v5 = v18 - v6 = v23 + var tmp7 any + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("==")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v4, v5}) + if lang.IsTruthy(tmp11) { + var tmp12 any + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("next")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{v6}) + if lang.IsTruthy(tmp16) { + var tmp17 any = v5 + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("first")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, []any{v6}) + var tmp18 any = tmp22 + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("next")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.Apply(tmp26, []any{v6}) + var tmp23 any = tmp27 + v4 = tmp17 + v5 = tmp18 + v6 = tmp23 goto recur_loop_206 } else { - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("==")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("first")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{v6}) - v35 := lang.Apply(v30, []any{v5, v34}) - v12 = v35 - } - v7 = v12 + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("==")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("first")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{v6}) + tmp35 := lang.Apply(tmp30, []any{v5, tmp34}) + tmp12 = tmp35 + } + tmp7 = tmp12 } else { - v7 = false + tmp7 = false } - return v7 + return tmp7 } }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // > { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function >__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -4865,84 +4889,84 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("seq")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("concat")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("list")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("list")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("list")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("seq")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("concat")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("list")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/Gt")}) - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("list")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{v3}) - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("list")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.Apply(v38, []any{v4}) - v40 := lang.Apply(v27, []any{v31, v35, v39}) - v41 := lang.Apply(v24, []any{v40}) - v42 := lang.Apply(v21, []any{v41}) - v43 := lang.Apply(v10, []any{v14, v18, v42}) - v44 := lang.Apply(v7, []any{v43}) - return v44 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("concat")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("list")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol(".")}) + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("seq")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("concat")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("list")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.Apply(tmp30, []any{lang.NewSymbol("glojure.core/Gt")}) + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.Apply(tmp34, []any{v3}) + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{v4}) + tmp40 := lang.Apply(tmp27, []any{tmp31, tmp35, tmp39}) + tmp41 := lang.Apply(tmp24, []any{tmp40}) + tmp42 := lang.Apply(tmp21, []any{tmp41}) + tmp43 := lang.Apply(tmp10, []any{tmp14, tmp18, tmp42}) + tmp44 := lang.Apply(tmp7, []any{tmp43}) + return tmp44 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol(">").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns non-nil if nums are in monotonically decreasing order,\n otherwise false.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1063), lang.NewKeyword("end-line"), int(1063))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol(">").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns non-nil if nums are in monotonically decreasing order,\n otherwise false.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1063), lang.NewKeyword("end-line"), int(1063))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v4 := args[0] @@ -4953,12 +4977,12 @@ func init() { _ = v4 v5 := args[1] _ = v5 - v6, _ := lang.FieldOrMethod(lang.Numbers, "Gt") - if reflect.TypeOf(v6).Kind() != reflect.Func { + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - v7 := lang.Apply(v6, []any{v4, v5}) - return v7 + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 default: if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -4967,128 +4991,130 @@ func init() { _ = v4 v5 := args[1] _ = v5 - v6 := lang.NewList(args[2:]...) + var v6 any = lang.NewList(args[2:]...) + _ = v6 recur_loop_198: - var v7 any - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol(">")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v4, v5}) - if lang.IsTruthy(v11) { - var v12 any - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("next")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{v6}) - if lang.IsTruthy(v16) { - var v17 any = v5 - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("first")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{v6}) - var v18 any = v22 - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("next")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.Apply(v26, []any{v6}) - var v23 any = v27 - v4 = v17 - v5 = v18 - v6 = v23 + var tmp7 any + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol(">")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v4, v5}) + if lang.IsTruthy(tmp11) { + var tmp12 any + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("next")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{v6}) + if lang.IsTruthy(tmp16) { + var tmp17 any = v5 + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("first")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, []any{v6}) + var tmp18 any = tmp22 + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("next")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.Apply(tmp26, []any{v6}) + var tmp23 any = tmp27 + v4 = tmp17 + v5 = tmp18 + v6 = tmp23 goto recur_loop_198 } else { - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol(">")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("first")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{v6}) - v35 := lang.Apply(v30, []any{v5, v34}) - v12 = v35 - } - v7 = v12 + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol(">")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("first")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{v6}) + tmp35 := lang.Apply(tmp30, []any{v5, tmp34}) + tmp12 = tmp35 + } + tmp7 = tmp12 } else { - v7 = false + tmp7 = false } - return v7 + return tmp7 } }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // >0? { - v0 := lang.NewSymbol(">0?").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(963), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(963), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol(">0?").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(963), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(963), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") - if reflect.TypeOf(v4).Kind() != reflect.Func { + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - v5 := lang.Apply(v4, []any{nil, int64(0)}) - return v5 + tmp5 := lang.Apply(tmp4, []any{nil, int64(0)}) + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // >1? { - v0 := lang.NewSymbol(">1?").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(962), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(962), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol(">1?").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(962), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(962), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") - if reflect.TypeOf(v4).Kind() != reflect.Func { + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - v5 := lang.Apply(v4, []any{nil, int64(1)}) - return v5 + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // >= { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function >=__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -5096,84 +5122,84 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("seq")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("concat")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("list")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("list")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("list")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("seq")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("concat")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("list")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/Gte")}) - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("list")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{v3}) - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("list")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.Apply(v38, []any{v4}) - v40 := lang.Apply(v27, []any{v31, v35, v39}) - v41 := lang.Apply(v24, []any{v40}) - v42 := lang.Apply(v21, []any{v41}) - v43 := lang.Apply(v10, []any{v14, v18, v42}) - v44 := lang.Apply(v7, []any{v43}) - return v44 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("concat")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("list")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol(".")}) + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("seq")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("concat")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("list")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.Apply(tmp30, []any{lang.NewSymbol("glojure.core/Gte")}) + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.Apply(tmp34, []any{v3}) + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{v4}) + tmp40 := lang.Apply(tmp27, []any{tmp31, tmp35, tmp39}) + tmp41 := lang.Apply(tmp24, []any{tmp40}) + tmp42 := lang.Apply(tmp21, []any{tmp41}) + tmp43 := lang.Apply(tmp10, []any{tmp14, tmp18, tmp42}) + tmp44 := lang.Apply(tmp7, []any{tmp43}) + return tmp44 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol(">=").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns non-nil if nums are in monotonically non-increasing order,\n otherwise false.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1078), lang.NewKeyword("end-line"), int(1078))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol(">=").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns non-nil if nums are in monotonically non-increasing order,\n otherwise false.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1078), lang.NewKeyword("end-line"), int(1078))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v4 := args[0] @@ -5184,12 +5210,12 @@ func init() { _ = v4 v5 := args[1] _ = v5 - v6, _ := lang.FieldOrMethod(lang.Numbers, "Gte") - if reflect.TypeOf(v6).Kind() != reflect.Func { + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Gte") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gte is not a function"))) } - v7 := lang.Apply(v6, []any{v4, v5}) - return v7 + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 default: if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -5198,724 +5224,721 @@ func init() { _ = v4 v5 := args[1] _ = v5 - v6 := lang.NewList(args[2:]...) + var v6 any = lang.NewList(args[2:]...) + _ = v6 recur_loop_202: - var v7 any - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol(">=")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v4, v5}) - if lang.IsTruthy(v11) { - var v12 any - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("next")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{v6}) - if lang.IsTruthy(v16) { - var v17 any = v5 - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("first")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{v6}) - var v18 any = v22 - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("next")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.Apply(v26, []any{v6}) - var v23 any = v27 - v4 = v17 - v5 = v18 - v6 = v23 + var tmp7 any + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol(">=")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v4, v5}) + if lang.IsTruthy(tmp11) { + var tmp12 any + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("next")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{v6}) + if lang.IsTruthy(tmp16) { + var tmp17 any = v5 + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("first")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, []any{v6}) + var tmp18 any = tmp22 + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("next")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.Apply(tmp26, []any{v6}) + var tmp23 any = tmp27 + v4 = tmp17 + v5 = tmp18 + v6 = tmp23 goto recur_loop_202 } else { - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol(">=")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("first")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{v6}) - v35 := lang.Apply(v30, []any{v5, v34}) - v12 = v35 - } - v7 = v12 + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol(">=")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("first")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{v6}) + tmp35 := lang.Apply(tmp30, []any{v5, tmp34}) + tmp12 = tmp35 + } + tmp7 = tmp12 } else { - v7 = false + tmp7 = false } - return v7 + return tmp7 } }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // NaN? { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function NaN?__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("concat")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("list")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol("math.IsNaN")}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{v3}) - v18 := lang.Apply(v9, []any{v13, v17}) - v19 := lang.Apply(v6, []any{v18}) - return v19 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol("math.IsNaN")}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := lang.Apply(tmp9, []any{tmp13, tmp17}) + tmp19 := lang.Apply(tmp6, []any{tmp18}) + return tmp19 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("NaN?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns true if num is NaN, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)), lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7968), lang.NewKeyword("end-line"), int(7968))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("NaN?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns true if num is NaN, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1)})), lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7968), lang.NewKeyword("end-line"), int(7968))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5 := lang.Apply(math3.IsNaN, []any{v4}) - return v5 + tmp5 := lang.Apply(math3.IsNaN, []any{v4}) + return tmp5 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // StackTraceElement->vec { - v0 := lang.NewSymbol("StackTraceElement->vec").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"))), lang.NewKeyword("doc"), "Constructs a data representation for a StackTraceElement: [class method file line]", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(436), lang.NewKeyword("end-line"), int(436))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("StackTraceElement->vec").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"))), lang.NewKeyword("doc"), "Constructs a data representation for a StackTraceElement: [class method file line]", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(436), lang.NewKeyword("end-line"), int(436))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("symbol")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("symbol")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) } - v6 := v5.Get() - v7, ok := lang.FieldOrMethod(v3, "getClassName") + tmp6 := tmp5.Get() + tmp7, ok := lang.FieldOrMethod(v3, "getClassName") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getClassName"))) } - var v8 any - switch reflect.TypeOf(v7).Kind() { + var tmp8 any + switch reflect.TypeOf(tmp7).Kind() { case reflect.Func: - v8 = lang.Apply(v7, nil) + tmp8 = lang.Apply(tmp7, nil) default: - v8 = v7 + tmp8 = tmp7 } - v9 := lang.Apply(v6, []any{v8}) - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("symbol")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + tmp9 := lang.Apply(tmp6, []any{tmp8}) + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("symbol")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) } - v12 := v11.Get() - v13, ok := lang.FieldOrMethod(v3, "getMethodName") + tmp12 := tmp11.Get() + tmp13, ok := lang.FieldOrMethod(v3, "getMethodName") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getMethodName"))) } - var v14 any - switch reflect.TypeOf(v13).Kind() { + var tmp14 any + switch reflect.TypeOf(tmp13).Kind() { case reflect.Func: - v14 = lang.Apply(v13, nil) + tmp14 = lang.Apply(tmp13, nil) default: - v14 = v13 + tmp14 = tmp13 } - v15 := lang.Apply(v12, []any{v14}) - v16, ok := lang.FieldOrMethod(v3, "getFileName") + tmp15 := lang.Apply(tmp12, []any{tmp14}) + tmp16, ok := lang.FieldOrMethod(v3, "getFileName") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getFileName"))) } - var v17 any - switch reflect.TypeOf(v16).Kind() { + var tmp17 any + switch reflect.TypeOf(tmp16).Kind() { case reflect.Func: - v17 = lang.Apply(v16, nil) + tmp17 = lang.Apply(tmp16, nil) default: - v17 = v16 + tmp17 = tmp16 } - v18, ok := lang.FieldOrMethod(v3, "getLineNumber") + tmp18, ok := lang.FieldOrMethod(v3, "getLineNumber") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getLineNumber"))) } - var v19 any - switch reflect.TypeOf(v18).Kind() { + var tmp19 any + switch reflect.TypeOf(tmp18).Kind() { case reflect.Func: - v19 = lang.Apply(v18, nil) + tmp19 = lang.Apply(tmp18, nil) default: - v19 = v18 + tmp19 = tmp18 } - v20 := lang.NewVector(v9, v15, v17, v19) - v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(440), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(440), lang.NewKeyword("end-column"), int(94)) - v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) + tmp20 := lang.NewVector(tmp9, tmp15, tmp17, tmp19) + tmp21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(440), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(440), lang.NewKeyword("end-column"), int(94)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) if err != nil { panic(err) } - return v22 + return tmp22 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // Throwable->map { - v0 := lang.NewSymbol("Throwable->map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"))), lang.NewKeyword("doc"), "Constructs a data representation for a Throwable with keys:\n :cause - root cause message\n :phase - error phase\n :via - cause chain, with cause keys:\n :type - exception class symbol\n :message - exception message\n :data - ex-data\n :at - top stack element\n :trace - root cause stack elements", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(442), lang.NewKeyword("end-line"), int(442))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("Throwable->map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"))), lang.NewKeyword("doc"), "Constructs a data representation for a Throwable with keys:\n :cause - root cause message\n :phase - error phase\n :via - cause chain, with cause keys:\n :type - exception class symbol\n :message - exception message\n :data - ex-data\n :at - top stack element\n :trace - root cause stack elements", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(442), lang.NewKeyword("end-line"), int(442))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any + var tmp4 any { // let // let binding "base" - var v5 lang.FnFunc - v5 = lang.NewFnFunc(func(args ...any) any { + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v6 := args[0] _ = v6 - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("merge")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("symbol")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("class")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{v6}) - v17, ok := lang.FieldOrMethod(v16, "Name") + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("merge")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("symbol")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("class")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{v6}) + tmp17, ok := lang.FieldOrMethod(tmp16, "Name") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v16, "Name"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp16, "Name"))) } - var v18 any - switch reflect.TypeOf(v17).Kind() { + var tmp18 any + switch reflect.TypeOf(tmp17).Kind() { case reflect.Func: - v18 = lang.Apply(v17, nil) + tmp18 = lang.Apply(tmp17, nil) default: - v18 = v17 + tmp18 = tmp17 } - v19 := lang.Apply(v12, []any{v18}) - v20 := lang.NewMap(lang.NewKeyword("type"), v19) - v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(455), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(455), lang.NewKeyword("end-column"), int(56)) - v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) + tmp19 := lang.Apply(tmp12, []any{tmp18}) + tmp20 := lang.NewMap(lang.NewKeyword("type"), tmp19) + tmp21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(455), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(455), lang.NewKeyword("end-column"), int(56)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) if err != nil { panic(err) } - var v23 any + var tmp23 any { // let // let binding "temp__0__auto__" - v24, ok := lang.FieldOrMethod(v6, "getLocalizedMessage") + tmp24, ok := lang.FieldOrMethod(v6, "getLocalizedMessage") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "getLocalizedMessage"))) } - var v25 any - switch reflect.TypeOf(v24).Kind() { + var tmp25 any + switch reflect.TypeOf(tmp24).Kind() { case reflect.Func: - v25 = lang.Apply(v24, nil) + tmp25 = lang.Apply(tmp24, nil) default: - v25 = v24 + tmp25 = tmp24 } - var v26 any = v25 + var v26 any = tmp25 _ = v26 - var v27 any + var tmp27 any if lang.IsTruthy(v26) { - var v28 any + var tmp28 any { // let // let binding "msg" var v29 any = v26 _ = v29 - v30 := lang.NewMap(lang.NewKeyword("message"), v29) - v31 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(457), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(457), lang.NewKeyword("end-column"), int(33)) - v32, err := lang.WithMeta(v30, v31.(lang.IPersistentMap)) + tmp30 := lang.NewMap(lang.NewKeyword("message"), v29) + tmp31 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(457), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(457), lang.NewKeyword("end-column"), int(33)) + tmp32, err := lang.WithMeta(tmp30, tmp31.(lang.IPersistentMap)) if err != nil { panic(err) } - v28 = v32 + tmp28 = tmp32 } // end let - v27 = v28 + tmp27 = tmp28 } else { - v27 = nil } - v23 = v27 + tmp23 = tmp27 } // end let - var v24 any + var tmp24 any { // let // let binding "temp__0__auto__" - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("ex-data")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.Apply(v27, []any{v6}) - var v29 any = v28 + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("ex-data")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.Apply(tmp27, []any{v6}) + var v29 any = tmp28 _ = v29 - var v30 any + var tmp30 any if lang.IsTruthy(v29) { - var v31 any + var tmp31 any { // let // let binding "ed" var v32 any = v29 _ = v32 - v33 := lang.NewMap(lang.NewKeyword("data"), v32) - v34 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(459), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(459), lang.NewKeyword("end-column"), int(29)) - v35, err := lang.WithMeta(v33, v34.(lang.IPersistentMap)) + tmp33 := lang.NewMap(lang.NewKeyword("data"), v32) + tmp34 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(459), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(459), lang.NewKeyword("end-column"), int(29)) + tmp35, err := lang.WithMeta(tmp33, tmp34.(lang.IPersistentMap)) if err != nil { panic(err) } - v31 = v35 + tmp31 = tmp35 } // end let - v30 = v31 + tmp30 = tmp31 } else { - v30 = nil } - v24 = v30 + tmp24 = tmp30 } // end let - var v25 any + var tmp25 any { // let // let binding "st" - v26, ok := lang.FieldOrMethod(v6, "getStackTrace") + tmp26, ok := lang.FieldOrMethod(v6, "getStackTrace") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "getStackTrace"))) } - var v27 any - switch reflect.TypeOf(v26).Kind() { + var tmp27 any + switch reflect.TypeOf(tmp26).Kind() { case reflect.Func: - v27 = lang.Apply(v26, nil) + tmp27 = lang.Apply(tmp26, nil) default: - v27 = v26 + tmp27 = tmp26 } - var v28 any = v27 + var v28 any = tmp27 _ = v28 - var v29 any - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("pos?")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) - } - v32 := v31.Get() - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("alength")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - v36 := lang.Apply(v35, []any{v28}) - v37 := lang.Apply(v32, []any{v36}) - if lang.IsTruthy(v37) { - v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v39 := v38.FindInternedVar(lang.NewSymbol("StackTraceElement->vec")) - if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) - } - v40 := v39.Get() - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("aget")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) - } - v43 := v42.Get() - v44 := lang.Apply(v43, []any{v28, int64(0)}) - v45 := lang.Apply(v40, []any{v44}) - v46 := lang.NewMap(lang.NewKeyword("at"), v45) - v47 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(462), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(462), lang.NewKeyword("end-column"), int(63)) - v48, err := lang.WithMeta(v46, v47.(lang.IPersistentMap)) + var tmp29 any + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("pos?")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) + } + tmp32 := tmp31.Get() + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("alength")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) + } + tmp35 := tmp34.Get() + tmp36 := lang.Apply(tmp35, []any{v28}) + tmp37 := lang.Apply(tmp32, []any{tmp36}) + if lang.IsTruthy(tmp37) { + tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp39 := tmp38.FindInternedVar(lang.NewSymbol("StackTraceElement->vec")) + if tmp39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) + } + tmp40 := tmp39.Get() + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("aget")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := lang.Apply(tmp43, []any{v28, int64(0)}) + tmp45 := lang.Apply(tmp40, []any{tmp44}) + tmp46 := lang.NewMap(lang.NewKeyword("at"), tmp45) + tmp47 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(462), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(462), lang.NewKeyword("end-column"), int(63)) + tmp48, err := lang.WithMeta(tmp46, tmp47.(lang.IPersistentMap)) if err != nil { panic(err) } - v29 = v48 + tmp29 = tmp48 } else { - v29 = nil } - v25 = v29 + tmp25 = tmp29 } // end let - v26 := lang.Apply(v9, []any{v22, v23, v24, v25}) - return v26 + tmp26 := lang.Apply(tmp9, []any{tmp22, tmp23, tmp24, tmp25}) + return tmp26 }) - v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(454), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(462), lang.NewKeyword("end-column"), int(67)) - v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) + tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(454), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(462), lang.NewKeyword("end-column"), int(67)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) if err != nil { panic(err) } - var v8 any = v7 + var v8 any = tmp7 _ = v8 // let binding "via" - var v9 any + var tmp9 any { // let // let binding "via" - v10 := lang.NewVector() - v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(463), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(463), lang.NewKeyword("end-column"), int(25)) - v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) + tmp10 := lang.NewVector() + tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(463), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(463), lang.NewKeyword("end-column"), int(25)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) if err != nil { panic(err) } - var v13 any = v12 + var v13 any = tmp12 _ = v13 // let binding "t" var v14 any = v3 _ = v14 for { - var v15 any + var tmp15 any if lang.IsTruthy(v14) { - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("conj")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.Apply(v19, []any{v13, v14}) - var v16 any = v20 - v22, ok := lang.FieldOrMethod(v14, "getCause") + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("conj")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.Apply(tmp19, []any{v13, v14}) + var tmp16 any = tmp20 + tmp22, ok := lang.FieldOrMethod(v14, "getCause") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v14, "getCause"))) } - var v23 any - switch reflect.TypeOf(v22).Kind() { + var tmp23 any + switch reflect.TypeOf(tmp22).Kind() { case reflect.Func: - v23 = lang.Apply(v22, nil) + tmp23 = lang.Apply(tmp22, nil) default: - v23 = v22 + tmp23 = tmp22 } - var v21 any = v23 - v13 = v16 - v14 = v21 + var tmp21 any = tmp23 + v13 = tmp16 + v14 = tmp21 continue } else { - v15 = v13 + tmp15 = v13 } - v9 = v15 + tmp9 = tmp15 break } } // end let - var v10 any = v9 + var v10 any = tmp9 _ = v10 // let binding "root" - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("peek")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{v10}) - var v15 any = v14 + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("peek")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{v10}) + var v15 any = tmp14 _ = v15 - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("merge")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("vec")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("map")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v8, v10}) - v26 := lang.Apply(v21, []any{v25}) - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("vec")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("map")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) - } - v32 := v31.Get() - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("StackTraceElement->vec")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - var v36 any + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("merge")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("vec")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("map")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.Apply(tmp24, []any{v8, v10}) + tmp26 := lang.Apply(tmp21, []any{tmp25}) + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("vec")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("map")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) + } + tmp32 := tmp31.Get() + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("StackTraceElement->vec")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) + } + tmp35 := tmp34.Get() + var tmp36 any { // let // let binding "or__0__auto__" var v37 any = v15 _ = v37 - var v38 any + var tmp38 any if lang.IsTruthy(v37) { - v38 = v37 + tmp38 = v37 } else { - v38 = v3 + tmp38 = v3 } - v36 = v38 + tmp36 = tmp38 } // end let - v37, ok := lang.FieldOrMethod(v36, "getStackTrace") + tmp37, ok := lang.FieldOrMethod(tmp36, "getStackTrace") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v36, "getStackTrace"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp36, "getStackTrace"))) } - var v38 any - switch reflect.TypeOf(v37).Kind() { + var tmp38 any + switch reflect.TypeOf(tmp37).Kind() { case reflect.Func: - v38 = lang.Apply(v37, nil) + tmp38 = lang.Apply(tmp37, nil) default: - v38 = v37 + tmp38 = tmp37 } - v39 := lang.Apply(v32, []any{v35, v38}) - v40 := lang.Apply(v29, []any{v39}) - v41 := lang.NewMap(lang.NewKeyword("via"), v26, lang.NewKeyword("trace"), v40) - v42 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(468), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(470), lang.NewKeyword("end-column"), int(111)) - v43, err := lang.WithMeta(v41, v42.(lang.IPersistentMap)) + tmp39 := lang.Apply(tmp32, []any{tmp35, tmp38}) + tmp40 := lang.Apply(tmp29, []any{tmp39}) + tmp41 := lang.NewMap(lang.NewKeyword("via"), tmp26, lang.NewKeyword("trace"), tmp40) + tmp42 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(468), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(470), lang.NewKeyword("end-column"), int(111)) + tmp43, err := lang.WithMeta(tmp41, tmp42.(lang.IPersistentMap)) if err != nil { panic(err) } - var v44 any + var tmp44 any { // let // let binding "temp__0__auto__" - v45, ok := lang.FieldOrMethod(v15, "getLocalizedMessage") + tmp45, ok := lang.FieldOrMethod(v15, "getLocalizedMessage") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v15, "getLocalizedMessage"))) } - var v46 any - switch reflect.TypeOf(v45).Kind() { + var tmp46 any + switch reflect.TypeOf(tmp45).Kind() { case reflect.Func: - v46 = lang.Apply(v45, nil) + tmp46 = lang.Apply(tmp45, nil) default: - v46 = v45 + tmp46 = tmp45 } - var v47 any = v46 + var v47 any = tmp46 _ = v47 - var v48 any + var tmp48 any if lang.IsTruthy(v47) { - var v49 any + var tmp49 any { // let // let binding "root-msg" var v50 any = v47 _ = v50 - v51 := lang.NewMap(lang.NewKeyword("cause"), v50) - v52 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(472), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(472), lang.NewKeyword("end-column"), int(25)) - v53, err := lang.WithMeta(v51, v52.(lang.IPersistentMap)) + tmp51 := lang.NewMap(lang.NewKeyword("cause"), v50) + tmp52 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(472), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(472), lang.NewKeyword("end-column"), int(25)) + tmp53, err := lang.WithMeta(tmp51, tmp52.(lang.IPersistentMap)) if err != nil { panic(err) } - v49 = v53 + tmp49 = tmp53 } // end let - v48 = v49 + tmp48 = tmp49 } else { - v48 = nil } - v44 = v48 + tmp44 = tmp48 } // end let - var v45 any + var tmp45 any { // let // let binding "temp__0__auto__" - v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v47 := v46.FindInternedVar(lang.NewSymbol("ex-data")) - if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) - } - v48 := v47.Get() - v49 := lang.Apply(v48, []any{v15}) - var v50 any = v49 + tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp47 := tmp46.FindInternedVar(lang.NewSymbol("ex-data")) + if tmp47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) + } + tmp48 := tmp47.Get() + tmp49 := lang.Apply(tmp48, []any{v15}) + var v50 any = tmp49 _ = v50 - var v51 any + var tmp51 any if lang.IsTruthy(v50) { - var v52 any + var tmp52 any { // let // let binding "data" var v53 any = v50 _ = v53 - v54 := lang.NewMap(lang.NewKeyword("data"), v53) - v55 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(474), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(474), lang.NewKeyword("end-column"), int(20)) - v56, err := lang.WithMeta(v54, v55.(lang.IPersistentMap)) + tmp54 := lang.NewMap(lang.NewKeyword("data"), v53) + tmp55 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(474), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(474), lang.NewKeyword("end-column"), int(20)) + tmp56, err := lang.WithMeta(tmp54, tmp55.(lang.IPersistentMap)) if err != nil { panic(err) } - v52 = v56 + tmp52 = tmp56 } // end let - v51 = v52 + tmp51 = tmp52 } else { - v51 = nil } - v45 = v51 + tmp45 = tmp51 } // end let - var v46 any + var tmp46 any { // let // let binding "temp__0__auto__" - v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v48 := v47.FindInternedVar(lang.NewSymbol("ex-data")) - if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) - } - v49 := v48.Get() - v50 := lang.Apply(v49, []any{v3}) - v51 := lang.Apply(lang.NewKeyword("glojure.error/phase"), []any{v50}) - var v52 any = v51 + tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp48 := tmp47.FindInternedVar(lang.NewSymbol("ex-data")) + if tmp48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) + } + tmp49 := tmp48.Get() + tmp50 := lang.Apply(tmp49, []any{v3}) + tmp51 := lang.Apply(lang.NewKeyword("glojure.error/phase"), []any{tmp50}) + var v52 any = tmp51 _ = v52 - var v53 any + var tmp53 any if lang.IsTruthy(v52) { - var v54 any + var tmp54 any { // let // let binding "phase" var v55 any = v52 _ = v55 - v56 := lang.NewMap(lang.NewKeyword("phase"), v55) - v57 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(476), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(476), lang.NewKeyword("end-column"), int(22)) - v58, err := lang.WithMeta(v56, v57.(lang.IPersistentMap)) + tmp56 := lang.NewMap(lang.NewKeyword("phase"), v55) + tmp57 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(476), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(476), lang.NewKeyword("end-column"), int(22)) + tmp58, err := lang.WithMeta(tmp56, tmp57.(lang.IPersistentMap)) if err != nil { panic(err) } - v54 = v58 + tmp54 = tmp58 } // end let - v53 = v54 + tmp53 = tmp54 } else { - v53 = nil } - v46 = v53 + tmp46 = tmp53 } // end let - v47 := lang.Apply(v18, []any{v43, v44, v45, v46}) - v4 = v47 + tmp47 := lang.Apply(tmp18, []any{tmp43, tmp44, tmp45, tmp46}) + tmp4 = tmp47 } // end let - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // abs { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function abs__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("concat")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("list")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Abs")}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{v3}) - v18 := lang.Apply(v9, []any{v13, v17}) - v19 := lang.Apply(v6, []any{v18}) - return v19 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Abs")}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := lang.Apply(tmp9, []any{tmp13, tmp17}) + tmp19 := lang.Apply(tmp6, []any{tmp18}) + return tmp19 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("abs").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the absolute value of a.\n If a is Long/MIN_VALUE => Long/MIN_VALUE\n If a is a double and zero => +0.0\n If a is a double and ##Inf or ##-Inf => ##Inf\n If a is a double and ##NaN => ##NaN", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)), lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1128), lang.NewKeyword("end-line"), int(1128))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("abs").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the absolute value of a.\n If a is Long/MIN_VALUE => Long/MIN_VALUE\n If a is a double and zero => +0.0\n If a is a double and ##Inf or ##-Inf => ##Inf\n If a is a double and ##NaN => ##NaN", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1)})), lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1128), lang.NewKeyword("end-line"), int(1128))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5 := lang.Apply(lang.Abs, []any{v4}) - return v5 + tmp5 := lang.Apply(lang.Abs, []any{v4}) + return tmp5 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // accessor { - v0 := lang.NewSymbol("accessor").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("key"))), lang.NewKeyword("doc"), "Returns a fn that, given an instance of a structmap with the basis,\n returns the value at the key. The key must be in the basis. The\n returned function should be (slightly) more efficient than using\n get, but such use of accessors should be limited to known\n performance-critical areas.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4070), lang.NewKeyword("end-line"), int(4070))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("accessor").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("key"))), lang.NewKeyword("doc"), "Returns a fn that, given an instance of a structmap with the basis,\n returns the value at the key. The key must be in the basis. The\n returned function should be (slightly) more efficient than using\n get, but such use of accessors should be limited to known\n performance-critical areas.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4070), lang.NewKeyword("end-line"), int(4070))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -5923,150 +5946,151 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5, _ := lang.FieldOrMethod(nil, "getAccessor") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(nil, "getAccessor") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("getAccessor is not a function"))) } - v6 := lang.Apply(v5, []any{v3, v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // aclone { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function aclone__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("concat")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("list")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("seq")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("concat")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/Aclone")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{v3}) - v35 := lang.Apply(v26, []any{v30, v34}) - v36 := lang.Apply(v23, []any{v35}) - v37 := lang.Apply(v20, []any{v36}) - v38 := lang.Apply(v9, []any{v13, v17, v37}) - v39 := lang.Apply(v6, []any{v38}) - return v39 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/Aclone")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{v3}) + tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) + tmp36 := lang.Apply(tmp23, []any{tmp35}) + tmp37 := lang.Apply(tmp20, []any{tmp36}) + tmp38 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp37}) + tmp39 := lang.Apply(tmp6, []any{tmp38}) + return tmp39 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("aclone").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns a clone of the Java array. Works on arrays of known\n types.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3904), lang.NewKeyword("end-line"), int(3904))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("aclone").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns a clone of the Java array. Works on arrays of known\n types.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3904), lang.NewKeyword("end-line"), int(3904))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5, _ := lang.FieldOrMethod(runtime4.RT, "Aclone") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(runtime4.RT, "Aclone") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Aclone is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // add-classpath { - v0 := lang.NewSymbol("add-classpath").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("url"))), lang.NewKeyword("doc"), "DEPRECATED \n\n Adds the url (String or URL object) to the classpath per\n URLClassLoader.addURL", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("deprecated"), "1.1", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5176), lang.NewKeyword("end-line"), int(5176))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("add-classpath").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("url"))), lang.NewKeyword("doc"), "DEPRECATED \n\n Adds the url (String or URL object) to the classpath per\n URLClassLoader.addURL", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("deprecated"), "1.1", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5176), lang.NewKeyword("end-line"), int(5176))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("println")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("println")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) } - v6 := v5.Get() - v7 := lang.Apply(v6, []any{"WARNING: add-classpath is deprecated"}) - _ = v7 - v8 := lang.Apply(nil, []any{v3}) - return v8 + tmp6 := tmp5.Get() + tmp7 := lang.Apply(tmp6, []any{"WARNING: add-classpath is deprecated"}) + _ = tmp7 + tmp8 := lang.Apply(nil, []any{v3}) + return tmp8 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // add-doc-and-meta { - v0 := lang.NewSymbol("add-doc-and-meta").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("docstring"), lang.NewSymbol("meta"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(26), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6400), lang.NewKeyword("end-line"), int(6400), lang.NewKeyword("private"), true)).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("add-doc-and-meta").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("docstring"), lang.NewSymbol("meta"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(26), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6400), lang.NewKeyword("end-line"), int(6400), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 5 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -6080,131 +6104,131 @@ func init() { _ = v6 v7 := args[4] _ = v7 - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("seq")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("concat")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("glojure.core/alter-meta!")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("seq")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("concat")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("var")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{v5}) - v35 := lang.Apply(v26, []any{v30, v34}) - v36 := lang.Apply(v23, []any{v35}) - v37 := lang.Apply(v20, []any{v36}) - v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v39 := v38.FindInternedVar(lang.NewSymbol("list")) - if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) - } - v40 := v39.Get() - v41 := lang.Apply(v40, []any{lang.NewSymbol("glojure.core/merge")}) - v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v43 := v42.FindInternedVar(lang.NewSymbol("list")) - if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) - } - v44 := v43.Get() - v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v46 := v45.FindInternedVar(lang.NewSymbol("seq")) - if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) - } - v47 := v46.Get() - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("concat")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v52 := v51.FindInternedVar(lang.NewSymbol("list")) - if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) - } - v53 := v52.Get() - v54 := lang.Apply(v53, []any{lang.NewSymbol("glojure.core/assoc")}) - v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v56 := v55.FindInternedVar(lang.NewSymbol("list")) - if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) - } - v57 := v56.Get() - v58 := lang.Apply(v57, []any{v7}) - v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v60 := v59.FindInternedVar(lang.NewSymbol("list")) - if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) - } - v61 := v60.Get() - v62 := lang.Apply(v61, []any{lang.NewKeyword("doc")}) - v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v64 := v63.FindInternedVar(lang.NewSymbol("list")) - if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) - } - v65 := v64.Get() - v66 := lang.Apply(v65, []any{v6}) - v67 := lang.Apply(v50, []any{v54, v58, v62, v66}) - v68 := lang.Apply(v47, []any{v67}) - v69 := lang.Apply(v44, []any{v68}) - v70 := lang.Apply(v13, []any{v17, v37, v41, v69}) - v71 := lang.Apply(v10, []any{v70}) - return v71 - }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("seq")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("concat")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("glojure.core/alter-meta!")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("var")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{v5}) + tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) + tmp36 := lang.Apply(tmp23, []any{tmp35}) + tmp37 := lang.Apply(tmp20, []any{tmp36}) + tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp39 := tmp38.FindInternedVar(lang.NewSymbol("list")) + if tmp39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) + } + tmp40 := tmp39.Get() + tmp41 := lang.Apply(tmp40, []any{lang.NewSymbol("glojure.core/merge")}) + tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp43 := tmp42.FindInternedVar(lang.NewSymbol("list")) + if tmp43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) + } + tmp44 := tmp43.Get() + tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp46 := tmp45.FindInternedVar(lang.NewSymbol("seq")) + if tmp46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) + } + tmp47 := tmp46.Get() + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("concat")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp52 := tmp51.FindInternedVar(lang.NewSymbol("list")) + if tmp52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp52))) + } + tmp53 := tmp52.Get() + tmp54 := lang.Apply(tmp53, []any{lang.NewSymbol("glojure.core/assoc")}) + tmp55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp56 := tmp55.FindInternedVar(lang.NewSymbol("list")) + if tmp56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp56))) + } + tmp57 := tmp56.Get() + tmp58 := lang.Apply(tmp57, []any{v7}) + tmp59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp60 := tmp59.FindInternedVar(lang.NewSymbol("list")) + if tmp60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp60))) + } + tmp61 := tmp60.Get() + tmp62 := lang.Apply(tmp61, []any{lang.NewKeyword("doc")}) + tmp63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp64 := tmp63.FindInternedVar(lang.NewSymbol("list")) + if tmp64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp64))) + } + tmp65 := tmp64.Get() + tmp66 := lang.Apply(tmp65, []any{v6}) + tmp67 := lang.Apply(tmp50, []any{tmp54, tmp58, tmp62, tmp66}) + tmp68 := lang.Apply(tmp47, []any{tmp67}) + tmp69 := lang.Apply(tmp44, []any{tmp68}) + tmp70 := lang.Apply(tmp13, []any{tmp17, tmp37, tmp41, tmp69}) + tmp71 := lang.Apply(tmp10, []any{tmp70}) + return tmp71 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // add-watch { - v0 := lang.NewSymbol("add-watch").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("reference"), lang.NewSymbol("key"), lang.NewSymbol("fn"))), lang.NewKeyword("doc"), "Adds a watch function to an agent/atom/var/ref reference. The watch\n fn must be a fn of 4 args: a key, the reference, its old-state, its\n new-state. Whenever the reference's state might have been changed,\n any registered watches will have their functions called. The watch fn\n will be called synchronously, on the agent's thread if an agent,\n before any pending sends if agent or ref. Note that an atom's or\n ref's state may have changed again prior to the fn call, so use\n old/new-state rather than derefing the reference. Note also that watch\n fns may be called from multiple threads simultaneously. Var watchers\n are triggered only by root binding changes, not thread-local\n set!s. Keys must be unique per reference, and can be used to remove\n the watch with remove-watch, but are otherwise considered opaque by\n the watch mechanism.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2142), lang.NewKeyword("end-line"), int(2142))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("add-watch").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("reference"), lang.NewSymbol("key"), lang.NewSymbol("fn"))), lang.NewKeyword("doc"), "Adds a watch function to an agent/atom/var/ref reference. The watch\n fn must be a fn of 4 args: a key, the reference, its old-state, its\n new-state. Whenever the reference's state might have been changed,\n any registered watches will have their functions called. The watch fn\n will be called synchronously, on the agent's thread if an agent,\n before any pending sends if agent or ref. Note that an atom's or\n ref's state may have changed again prior to the fn call, so use\n old/new-state rather than derefing the reference. Note also that watch\n fns may be called from multiple threads simultaneously. Var watchers\n are triggered only by root binding changes, not thread-local\n set!s. Keys must be unique per reference, and can be used to remove\n the watch with remove-watch, but are otherwise considered opaque by\n the watch mechanism.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2142), lang.NewKeyword("end-line"), int(2142))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -6214,24 +6238,24 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6, _ := lang.FieldOrMethod(v3, "addWatch") - if reflect.TypeOf(v6).Kind() != reflect.Func { + tmp6, _ := lang.FieldOrMethod(v3, "addWatch") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("addWatch is not a function"))) } - v7 := lang.Apply(v6, []any{v4, v5}) - return v7 + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // agent { - v0 := lang.NewSymbol("agent").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("state"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Creates and returns an agent with an initial value of state and\n zero or more options (in any order):\n\n :meta metadata-map\n\n :validator validate-fn\n\n :error-handler handler-fn\n\n :error-mode mode-keyword\n\n If metadata-map is supplied, it will become the metadata on the\n agent. validate-fn must be nil or a side-effect-free fn of one\n argument, which will be passed the intended new state on any state\n change. If the new state is unacceptable, the validate-fn should\n return false or throw an exception. handler-fn is called if an\n action throws an exception or if validate-fn rejects a new state --\n see set-error-handler! for details. The mode-keyword may be either\n :continue (the default if an error-handler is given) or :fail (the\n default if no error-handler is given) -- see set-error-mode! for\n details.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2052), lang.NewKeyword("end-line"), int(2052))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("agent").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("state"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Creates and returns an agent with an initial value of state and\n zero or more options (in any order):\n\n :meta metadata-map\n\n :validator validate-fn\n\n :error-handler handler-fn\n\n :error-mode mode-keyword\n\n If metadata-map is supplied, it will become the metadata on the\n agent. validate-fn must be nil or a side-effect-free fn of one\n argument, which will be passed the intended new state on any state\n change. If the new state is unacceptable, the validate-fn should\n return false or throw an exception. handler-fn is called if an\n action throws an exception or if validate-fn rejects a new state --\n see set-error-handler! for details. The mode-keyword may be either\n :continue (the default if an error-handler is given) or :fail (the\n default if no error-handler is given) -- see set-error-mode! for\n details.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2052), lang.NewKeyword("end-line"), int(2052))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 1 { @@ -6239,174 +6263,174 @@ func init() { } v3 := args[0] _ = v3 - v4 := lang.NewList(args[1:]...) - var v5 any + var v4 any = lang.NewList(args[1:]...) + _ = v4 + var tmp5 any { // let // let binding "a" var v6 any = "unimplemented: new with non-constant class type" _ = v6 // let binding "opts" - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("apply")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("hash-map")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v9, []any{v12, v4}) - var v14 any = v13 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("apply")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("hash-map")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp9, []any{tmp12, v4}) + var v14 any = tmp13 _ = v14 - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("setup-reference")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{v6, v4}) - _ = v18 - var v19 any - v20 := lang.Apply(lang.NewKeyword("error-handler"), []any{v14}) - if lang.IsTruthy(v20) { - v21 := lang.Apply(lang.NewKeyword("error-handler"), []any{v14}) - v22, _ := lang.FieldOrMethod(v6, "setErrorHandler") - if reflect.TypeOf(v22).Kind() != reflect.Func { + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("setup-reference")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{v6, v4}) + _ = tmp18 + var tmp19 any + tmp20 := lang.Apply(lang.NewKeyword("error-handler"), []any{v14}) + if lang.IsTruthy(tmp20) { + tmp21 := lang.Apply(lang.NewKeyword("error-handler"), []any{v14}) + tmp22, _ := lang.FieldOrMethod(v6, "setErrorHandler") + if reflect.TypeOf(tmp22).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorHandler is not a function"))) } - v23 := lang.Apply(v22, []any{v21}) - v19 = v23 + tmp23 := lang.Apply(tmp22, []any{tmp21}) + tmp19 = tmp23 } else { - v19 = nil } - _ = v19 - var v24 any + _ = tmp19 + var tmp24 any { // let // let binding "or__0__auto__" - v25 := lang.Apply(lang.NewKeyword("error-mode"), []any{v14}) - var v26 any = v25 + tmp25 := lang.Apply(lang.NewKeyword("error-mode"), []any{v14}) + var v26 any = tmp25 _ = v26 - var v27 any + var tmp27 any if lang.IsTruthy(v26) { - v27 = v26 + tmp27 = v26 } else { - var v28 any - v29 := lang.Apply(lang.NewKeyword("error-handler"), []any{v14}) - if lang.IsTruthy(v29) { - v28 = lang.NewKeyword("continue") + var tmp28 any + tmp29 := lang.Apply(lang.NewKeyword("error-handler"), []any{v14}) + if lang.IsTruthy(tmp29) { + tmp28 = lang.NewKeyword("continue") } else { - v28 = lang.NewKeyword("fail") + tmp28 = lang.NewKeyword("fail") } - v27 = v28 + tmp27 = tmp28 } - v24 = v27 + tmp24 = tmp27 } // end let - v25, _ := lang.FieldOrMethod(v6, "setErrorMode") - if reflect.TypeOf(v25).Kind() != reflect.Func { + tmp25, _ := lang.FieldOrMethod(v6, "setErrorMode") + if reflect.TypeOf(tmp25).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorMode is not a function"))) } - v26 := lang.Apply(v25, []any{v24}) - _ = v26 - v5 = v6 + tmp26 := lang.Apply(tmp25, []any{tmp24}) + _ = tmp26 + tmp5 = v6 } // end let - return v5 + return tmp5 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // agent-error { - v0 := lang.NewSymbol("agent-error").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("doc"), "Returns the exception thrown during an asynchronous action of the\n agent if the agent is failed. Returns nil if the agent is not\n failed.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2167), lang.NewKeyword("end-line"), int(2167))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("agent-error").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("doc"), "Returns the exception thrown during an asynchronous action of the\n agent if the agent is failed. Returns nil if the agent is not\n failed.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2167), lang.NewKeyword("end-line"), int(2167))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4, ok := lang.FieldOrMethod(v3, "getError") + tmp4, ok := lang.FieldOrMethod(v3, "getError") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getError"))) } - var v5 any - switch reflect.TypeOf(v4).Kind() { + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { case reflect.Func: - v5 = lang.Apply(v4, nil) + tmp5 = lang.Apply(tmp4, nil) default: - v5 = v4 + tmp5 = tmp4 } - return v5 + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // agent-errors { - v0 := lang.NewSymbol("agent-errors").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("doc"), "DEPRECATED: Use 'agent-error' instead.\n Returns a sequence of the exceptions thrown during asynchronous\n actions of the agent.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("deprecated"), "1.2", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2234), lang.NewKeyword("end-line"), int(2234))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("agent-errors").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("doc"), "DEPRECATED: Use 'agent-error' instead.\n Returns a sequence of the exceptions thrown during asynchronous\n actions of the agent.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("deprecated"), "1.2", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2234), lang.NewKeyword("end-line"), int(2234))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any + var tmp4 any { // let // let binding "temp__0__auto__" - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("agent-error")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v3}) - var v9 any = v8 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("agent-error")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v3}) + var v9 any = tmp8 _ = v9 - var v10 any + var tmp10 any if lang.IsTruthy(v9) { - var v11 any + var tmp11 any { // let // let binding "e" var v12 any = v9 _ = v12 - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("list")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{v12}) - v11 = v16 + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("list")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{v12}) + tmp11 = tmp16 } // end let - v10 = v11 + tmp10 = tmp11 } else { - v10 = nil } - v4 = v10 + tmp4 = tmp10 } // end let - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // aget { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function aget__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -6414,120 +6438,120 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("seq")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("concat")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("list")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("list")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("list")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("seq")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("concat")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("list")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/Aget")}) - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("list")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{v3}) - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("list")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v40 := v39.FindInternedVar(lang.NewSymbol("seq")) - if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) - } - v41 := v40.Get() - v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v43 := v42.FindInternedVar(lang.NewSymbol("concat")) - if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) - } - v44 := v43.Get() - v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v46 := v45.FindInternedVar(lang.NewSymbol("list")) - if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) - } - v47 := v46.Get() - v48 := lang.Apply(v47, []any{lang.NewSymbol("glojure.core/int")}) - v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v50 := v49.FindInternedVar(lang.NewSymbol("list")) - if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) - } - v51 := v50.Get() - v52 := lang.Apply(v51, []any{v4}) - v53 := lang.Apply(v44, []any{v48, v52}) - v54 := lang.Apply(v41, []any{v53}) - v55 := lang.Apply(v38, []any{v54}) - v56 := lang.Apply(v27, []any{v31, v35, v55}) - v57 := lang.Apply(v24, []any{v56}) - v58 := lang.Apply(v21, []any{v57}) - v59 := lang.Apply(v10, []any{v14, v18, v58}) - v60 := lang.Apply(v7, []any{v59}) - return v60 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("concat")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("list")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol(".")}) + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("seq")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("concat")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("list")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.Apply(tmp30, []any{lang.NewSymbol("glojure.core/Aget")}) + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.Apply(tmp34, []any{v3}) + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp40 := tmp39.FindInternedVar(lang.NewSymbol("seq")) + if tmp40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) + } + tmp41 := tmp40.Get() + tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp43 := tmp42.FindInternedVar(lang.NewSymbol("concat")) + if tmp43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) + } + tmp44 := tmp43.Get() + tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp46 := tmp45.FindInternedVar(lang.NewSymbol("list")) + if tmp46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) + } + tmp47 := tmp46.Get() + tmp48 := lang.Apply(tmp47, []any{lang.NewSymbol("glojure.core/int")}) + tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp50 := tmp49.FindInternedVar(lang.NewSymbol("list")) + if tmp50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) + } + tmp51 := tmp50.Get() + tmp52 := lang.Apply(tmp51, []any{v4}) + tmp53 := lang.Apply(tmp44, []any{tmp48, tmp52}) + tmp54 := lang.Apply(tmp41, []any{tmp53}) + tmp55 := lang.Apply(tmp38, []any{tmp54}) + tmp56 := lang.Apply(tmp27, []any{tmp31, tmp35, tmp55}) + tmp57 := lang.Apply(tmp24, []any{tmp56}) + tmp58 := lang.Apply(tmp21, []any{tmp57}) + tmp59 := lang.Apply(tmp10, []any{tmp14, tmp18, tmp58}) + tmp60 := lang.Apply(tmp7, []any{tmp59}) + return tmp60 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("aget").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("&"), lang.NewSymbol("idxs"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the value at the index/indices. Works on Java arrays of all\n types.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3911), lang.NewKeyword("end-line"), int(3911))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("aget").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("&"), lang.NewSymbol("idxs"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the value at the index/indices. Works on Java arrays of all\n types.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3911), lang.NewKeyword("end-line"), int(3911))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 2: v4 := args[0] _ = v4 v5 := args[1] _ = v5 - v6 := lang.Apply(lang.Get, []any{v4, v5}) - return v6 + tmp6 := lang.Apply(lang.Get, []any{v4, v5}) + return tmp6 default: if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -6536,140 +6560,142 @@ func init() { _ = v4 v5 := args[1] _ = v5 - v6 := lang.NewList(args[2:]...) - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("apply")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("apply")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("aget")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("aget")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("aget")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("aget")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{v4, v5}) - v17 := lang.Apply(v9, []any{v12, v16, v6}) - return v17 + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{v4, v5}) + tmp17 := lang.Apply(tmp9, []any{tmp12, tmp16, v6}) + return tmp17 } }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // alength { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function alength__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("concat")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("list")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("seq")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("concat")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/Alength")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{v3}) - v35 := lang.Apply(v26, []any{v30, v34}) - v36 := lang.Apply(v23, []any{v35}) - v37 := lang.Apply(v20, []any{v36}) - v38 := lang.Apply(v9, []any{v13, v17, v37}) - v39 := lang.Apply(v6, []any{v38}) - return v39 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/Alength")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{v3}) + tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) + tmp36 := lang.Apply(tmp23, []any{tmp35}) + tmp37 := lang.Apply(tmp20, []any{tmp36}) + tmp38 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp37}) + tmp39 := lang.Apply(tmp6, []any{tmp38}) + return tmp39 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("alength").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the length of the Java array. Works on arrays of all\n types.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3897), lang.NewKeyword("end-line"), int(3897))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("alength").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the length of the Java array. Works on arrays of all\n types.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3897), lang.NewKeyword("end-line"), int(3897))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5, _ := lang.FieldOrMethod(runtime4.RT, "Alength") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(runtime4.RT, "Alength") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Alength is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // alias { - v0 := lang.NewSymbol("alias").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("alias"), lang.NewSymbol("namespace-sym"))), lang.NewKeyword("doc"), "Add an alias in the current namespace to another\n namespace. Arguments are two symbols: the alias to be used, and\n the symbolic name of the target namespace. Use :as in the ns macro in preference\n to calling this directly.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4263), lang.NewKeyword("end-line"), int(4263))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("alias").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("alias"), lang.NewSymbol("namespace-sym"))), lang.NewKeyword("doc"), "Add an alias in the current namespace to another\n namespace. Arguments are two symbols: the alias to be used, and\n the symbolic name of the target namespace. Use :as in the ns macro in preference\n to calling this directly.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4263), lang.NewKeyword("end-line"), int(4263))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -6677,54 +6703,54 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("*ns*")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("the-ns")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v4}) - v12, _ := lang.FieldOrMethod(v7, "AddAlias") - if reflect.TypeOf(v12).Kind() != reflect.Func { + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("*ns*")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("the-ns")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v4}) + tmp12, _ := lang.FieldOrMethod(tmp7, "AddAlias") + if reflect.TypeOf(tmp12).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("AddAlias is not a function"))) } - v13 := lang.Apply(v12, []any{v3, v11}) - return v13 + tmp13 := lang.Apply(tmp12, []any{v3, tmp11}) + return tmp13 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // all-ns { - v0 := lang.NewSymbol("all-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Returns a sequence of all namespaces.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4146), lang.NewKeyword("end-line"), int(4146))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("all-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Returns a sequence of all namespaces.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4146), lang.NewKeyword("end-line"), int(4146))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v3 := lang.Apply(nil, nil) - return v3 + tmp3 := lang.Apply(nil, nil) + return tmp3 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // alter { - v0 := lang.NewSymbol("alter").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("fun"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Must be called in a transaction. Sets the in-transaction-value of\n ref to:\n\n (apply fun in-transaction-value-of-ref args)\n\n and returns the in-transaction-value of ref.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2435), lang.NewKeyword("end-line"), int(2435))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("alter").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("fun"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Must be called in a transaction. Sets the in-transaction-value of\n ref to:\n\n (apply fun in-transaction-value-of-ref args)\n\n and returns the in-transaction-value of ref.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2435), lang.NewKeyword("end-line"), int(2435))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 2 { @@ -6734,26 +6760,27 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.NewList(args[2:]...) - v6, _ := lang.FieldOrMethod(v3, "alter") - if reflect.TypeOf(v6).Kind() != reflect.Func { + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6, _ := lang.FieldOrMethod(v3, "alter") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("alter is not a function"))) } - v7 := lang.Apply(v6, []any{v4, v5}) - return v7 + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // alter-meta! { - v0 := lang.NewSymbol("alter-meta!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("iref"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Atomically sets the metadata for a namespace/var/ref/agent/atom to be:\n\n (apply f its-current-meta args)\n\n f must be free of side-effects", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2398), lang.NewKeyword("end-line"), int(2398))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("alter-meta!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("iref"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Atomically sets the metadata for a namespace/var/ref/agent/atom to be:\n\n (apply f its-current-meta args)\n\n f must be free of side-effects", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2398), lang.NewKeyword("end-line"), int(2398))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 2 { @@ -6763,26 +6790,27 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.NewList(args[2:]...) - v6, _ := lang.FieldOrMethod(v3, "AlterMeta") - if reflect.TypeOf(v6).Kind() != reflect.Func { + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6, _ := lang.FieldOrMethod(v3, "AlterMeta") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("AlterMeta is not a function"))) } - v7 := lang.Apply(v6, []any{v4, v5}) - return v7 + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // alter-var-root { - v0 := lang.NewSymbol("alter-var-root").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("v"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Atomically alters the root binding of var v by applying f to its\n current value plus any args", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5484), lang.NewKeyword("end-line"), int(5484))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("alter-var-root").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("v"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Atomically alters the root binding of var v by applying f to its\n current value plus any args", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5484), lang.NewKeyword("end-line"), int(5484))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 2 { @@ -6792,26 +6820,27 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.NewList(args[2:]...) - v6, _ := lang.FieldOrMethod(v3, "alterRoot") - if reflect.TypeOf(v6).Kind() != reflect.Func { + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6, _ := lang.FieldOrMethod(v3, "alterRoot") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("alterRoot is not a function"))) } - v7 := lang.Apply(v6, []any{v4, v5}) - return v7 + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // amap { - v0 := lang.NewSymbol("amap").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("idx"), lang.NewSymbol("ret"), lang.NewSymbol("expr"))), lang.NewKeyword("doc"), "Maps an expression across an array a, using an index named idx, and\n return value named ret, initialized to a clone of a, then setting \n each element of ret to the evaluation of expr, returning the new \n array ret.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5273), lang.NewKeyword("end-line"), int(5273))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("amap").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("idx"), lang.NewSymbol("ret"), lang.NewSymbol("expr"))), lang.NewKeyword("doc"), "Maps an expression across an array a, using an index named idx, and\n return value named ret, initialized to a clone of a, then setting \n each element of ret to the evaluation of expr, returning the new \n array ret.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5273), lang.NewKeyword("end-line"), int(5273))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 6 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -6827,609 +6856,609 @@ func init() { _ = v7 v8 := args[5] _ = v8 - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("seq")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("concat")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("list")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{lang.NewSymbol("glojure.core/let")}) - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("list")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("apply")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("vector")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("seq")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("concat")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("list")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) - } - v36 := v35.Get() - v37 := lang.Apply(v36, []any{lang.NewSymbol("a__0__auto__")}) - v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v39 := v38.FindInternedVar(lang.NewSymbol("list")) - if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) - } - v40 := v39.Get() - v41 := lang.Apply(v40, []any{v5}) - v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v43 := v42.FindInternedVar(lang.NewSymbol("list")) - if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) - } - v44 := v43.Get() - v45 := lang.Apply(v44, []any{lang.NewSymbol("l__1__auto__")}) - v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v47 := v46.FindInternedVar(lang.NewSymbol("list")) - if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) - } - v48 := v47.Get() - v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v50 := v49.FindInternedVar(lang.NewSymbol("seq")) - if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) - } - v51 := v50.Get() - v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v53 := v52.FindInternedVar(lang.NewSymbol("concat")) - if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) - } - v54 := v53.Get() - v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v56 := v55.FindInternedVar(lang.NewSymbol("list")) - if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) - } - v57 := v56.Get() - v58 := lang.Apply(v57, []any{lang.NewSymbol("glojure.core/alength")}) - v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v60 := v59.FindInternedVar(lang.NewSymbol("list")) - if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) - } - v61 := v60.Get() - v62 := lang.Apply(v61, []any{lang.NewSymbol("a__0__auto__")}) - v63 := lang.Apply(v54, []any{v58, v62}) - v64 := lang.Apply(v51, []any{v63}) - v65 := lang.Apply(v48, []any{v64}) - v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v67 := v66.FindInternedVar(lang.NewSymbol("list")) - if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) - } - v68 := v67.Get() - v69 := lang.Apply(v68, []any{v7}) - v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v71 := v70.FindInternedVar(lang.NewSymbol("list")) - if v71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) - } - v72 := v71.Get() - v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v74 := v73.FindInternedVar(lang.NewSymbol("seq")) - if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) - } - v75 := v74.Get() - v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v77 := v76.FindInternedVar(lang.NewSymbol("concat")) - if v77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) - } - v78 := v77.Get() - v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v80 := v79.FindInternedVar(lang.NewSymbol("list")) - if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) - } - v81 := v80.Get() - v82 := lang.Apply(v81, []any{lang.NewSymbol("glojure.core/aclone")}) - v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v84 := v83.FindInternedVar(lang.NewSymbol("list")) - if v84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) - } - v85 := v84.Get() - v86 := lang.Apply(v85, []any{lang.NewSymbol("a__0__auto__")}) - v87 := lang.Apply(v78, []any{v82, v86}) - v88 := lang.Apply(v75, []any{v87}) - v89 := lang.Apply(v72, []any{v88}) - v90 := lang.Apply(v33, []any{v37, v41, v45, v65, v69, v89}) - v91 := lang.Apply(v30, []any{v90}) - v92 := lang.Apply(v24, []any{v27, v91}) - v93 := lang.Apply(v21, []any{v92}) - v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v95 := v94.FindInternedVar(lang.NewSymbol("list")) - if v95.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) - } - v96 := v95.Get() - v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v98 := v97.FindInternedVar(lang.NewSymbol("seq")) - if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) - } - v99 := v98.Get() - v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v101 := v100.FindInternedVar(lang.NewSymbol("concat")) - if v101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) - } - v102 := v101.Get() - v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v104 := v103.FindInternedVar(lang.NewSymbol("list")) - if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) - } - v105 := v104.Get() - v106 := lang.Apply(v105, []any{lang.NewSymbol("glojure.core/loop")}) - v107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v108 := v107.FindInternedVar(lang.NewSymbol("list")) - if v108.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v108))) - } - v109 := v108.Get() - v110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v111 := v110.FindInternedVar(lang.NewSymbol("apply")) - if v111.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v111))) - } - v112 := v111.Get() - v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v114 := v113.FindInternedVar(lang.NewSymbol("vector")) - if v114.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) - } - v115 := v114.Get() - v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v117 := v116.FindInternedVar(lang.NewSymbol("seq")) - if v117.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) - } - v118 := v117.Get() - v119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v120 := v119.FindInternedVar(lang.NewSymbol("concat")) - if v120.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v120))) - } - v121 := v120.Get() - v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v123 := v122.FindInternedVar(lang.NewSymbol("list")) - if v123.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) - } - v124 := v123.Get() - v125 := lang.Apply(v124, []any{v6}) - v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v127 := v126.FindInternedVar(lang.NewSymbol("list")) - if v127.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) - } - v128 := v127.Get() - v129 := lang.Apply(v128, []any{int64(0)}) - v130 := lang.Apply(v121, []any{v125, v129}) - v131 := lang.Apply(v118, []any{v130}) - v132 := lang.Apply(v112, []any{v115, v131}) - v133 := lang.Apply(v109, []any{v132}) - v134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v135 := v134.FindInternedVar(lang.NewSymbol("list")) - if v135.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v135))) - } - v136 := v135.Get() - v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v138 := v137.FindInternedVar(lang.NewSymbol("seq")) - if v138.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) - } - v139 := v138.Get() - v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v141 := v140.FindInternedVar(lang.NewSymbol("concat")) - if v141.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) - } - v142 := v141.Get() - v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v144 := v143.FindInternedVar(lang.NewSymbol("list")) - if v144.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) - } - v145 := v144.Get() - v146 := lang.Apply(v145, []any{lang.NewSymbol("if")}) - v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v148 := v147.FindInternedVar(lang.NewSymbol("list")) - if v148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) - } - v149 := v148.Get() - v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v151 := v150.FindInternedVar(lang.NewSymbol("seq")) - if v151.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) - } - v152 := v151.Get() - v153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v154 := v153.FindInternedVar(lang.NewSymbol("concat")) - if v154.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v154))) - } - v155 := v154.Get() - v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v157 := v156.FindInternedVar(lang.NewSymbol("list")) - if v157.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) - } - v158 := v157.Get() - v159 := lang.Apply(v158, []any{lang.NewSymbol("glojure.core/<")}) - v160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v161 := v160.FindInternedVar(lang.NewSymbol("list")) - if v161.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v161))) - } - v162 := v161.Get() - v163 := lang.Apply(v162, []any{v6}) - v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v165 := v164.FindInternedVar(lang.NewSymbol("list")) - if v165.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) - } - v166 := v165.Get() - v167 := lang.Apply(v166, []any{lang.NewSymbol("l__1__auto__")}) - v168 := lang.Apply(v155, []any{v159, v163, v167}) - v169 := lang.Apply(v152, []any{v168}) - v170 := lang.Apply(v149, []any{v169}) - v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v172 := v171.FindInternedVar(lang.NewSymbol("list")) - if v172.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) - } - v173 := v172.Get() - v174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v175 := v174.FindInternedVar(lang.NewSymbol("seq")) - if v175.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v175))) - } - v176 := v175.Get() - v177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v178 := v177.FindInternedVar(lang.NewSymbol("concat")) - if v178.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v178))) - } - v179 := v178.Get() - v180 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v181 := v180.FindInternedVar(lang.NewSymbol("list")) - if v181.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v181))) - } - v182 := v181.Get() - v183 := lang.Apply(v182, []any{lang.NewSymbol("do")}) - v184 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v185 := v184.FindInternedVar(lang.NewSymbol("list")) - if v185.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v185))) - } - v186 := v185.Get() - v187 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v188 := v187.FindInternedVar(lang.NewSymbol("seq")) - if v188.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v188))) - } - v189 := v188.Get() - v190 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v191 := v190.FindInternedVar(lang.NewSymbol("concat")) - if v191.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v191))) - } - v192 := v191.Get() - v193 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v194 := v193.FindInternedVar(lang.NewSymbol("list")) - if v194.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v194))) - } - v195 := v194.Get() - v196 := lang.Apply(v195, []any{lang.NewSymbol("glojure.core/aset")}) - v197 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v198 := v197.FindInternedVar(lang.NewSymbol("list")) - if v198.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v198))) - } - v199 := v198.Get() - v200 := lang.Apply(v199, []any{v7}) - v201 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v202 := v201.FindInternedVar(lang.NewSymbol("list")) - if v202.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v202))) - } - v203 := v202.Get() - v204 := lang.Apply(v203, []any{v6}) - v205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v206 := v205.FindInternedVar(lang.NewSymbol("list")) - if v206.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v206))) - } - v207 := v206.Get() - v208 := lang.Apply(v207, []any{v8}) - v209 := lang.Apply(v192, []any{v196, v200, v204, v208}) - v210 := lang.Apply(v189, []any{v209}) - v211 := lang.Apply(v186, []any{v210}) - v212 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v213 := v212.FindInternedVar(lang.NewSymbol("list")) - if v213.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v213))) - } - v214 := v213.Get() - v215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v216 := v215.FindInternedVar(lang.NewSymbol("seq")) - if v216.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v216))) - } - v217 := v216.Get() - v218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v219 := v218.FindInternedVar(lang.NewSymbol("concat")) - if v219.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v219))) - } - v220 := v219.Get() - v221 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v222 := v221.FindInternedVar(lang.NewSymbol("list")) - if v222.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v222))) - } - v223 := v222.Get() - v224 := lang.Apply(v223, []any{lang.NewSymbol("recur")}) - v225 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v226 := v225.FindInternedVar(lang.NewSymbol("list")) - if v226.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v226))) - } - v227 := v226.Get() - v228 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v229 := v228.FindInternedVar(lang.NewSymbol("seq")) - if v229.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v229))) - } - v230 := v229.Get() - v231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v232 := v231.FindInternedVar(lang.NewSymbol("concat")) - if v232.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v232))) - } - v233 := v232.Get() - v234 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v235 := v234.FindInternedVar(lang.NewSymbol("list")) - if v235.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v235))) - } - v236 := v235.Get() - v237 := lang.Apply(v236, []any{lang.NewSymbol("glojure.core/unchecked-inc")}) - v238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v239 := v238.FindInternedVar(lang.NewSymbol("list")) - if v239.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v239))) - } - v240 := v239.Get() - v241 := lang.Apply(v240, []any{v6}) - v242 := lang.Apply(v233, []any{v237, v241}) - v243 := lang.Apply(v230, []any{v242}) - v244 := lang.Apply(v227, []any{v243}) - v245 := lang.Apply(v220, []any{v224, v244}) - v246 := lang.Apply(v217, []any{v245}) - v247 := lang.Apply(v214, []any{v246}) - v248 := lang.Apply(v179, []any{v183, v211, v247}) - v249 := lang.Apply(v176, []any{v248}) - v250 := lang.Apply(v173, []any{v249}) - v251 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v252 := v251.FindInternedVar(lang.NewSymbol("list")) - if v252.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v252))) - } - v253 := v252.Get() - v254 := lang.Apply(v253, []any{v7}) - v255 := lang.Apply(v142, []any{v146, v170, v250, v254}) - v256 := lang.Apply(v139, []any{v255}) - v257 := lang.Apply(v136, []any{v256}) - v258 := lang.Apply(v102, []any{v106, v133, v257}) - v259 := lang.Apply(v99, []any{v258}) - v260 := lang.Apply(v96, []any{v259}) - v261 := lang.Apply(v14, []any{v18, v93, v260}) - v262 := lang.Apply(v11, []any{v261}) - return v262 - }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("seq")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("concat")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("glojure.core/let")}) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("apply")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("vector")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("seq")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("concat")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("list")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.Apply(tmp36, []any{lang.NewSymbol("a__0__auto__")}) + tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp39 := tmp38.FindInternedVar(lang.NewSymbol("list")) + if tmp39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) + } + tmp40 := tmp39.Get() + tmp41 := lang.Apply(tmp40, []any{v5}) + tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp43 := tmp42.FindInternedVar(lang.NewSymbol("list")) + if tmp43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) + } + tmp44 := tmp43.Get() + tmp45 := lang.Apply(tmp44, []any{lang.NewSymbol("l__1__auto__")}) + tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp47 := tmp46.FindInternedVar(lang.NewSymbol("list")) + if tmp47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) + } + tmp48 := tmp47.Get() + tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp50 := tmp49.FindInternedVar(lang.NewSymbol("seq")) + if tmp50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) + } + tmp51 := tmp50.Get() + tmp52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp53 := tmp52.FindInternedVar(lang.NewSymbol("concat")) + if tmp53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp53))) + } + tmp54 := tmp53.Get() + tmp55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp56 := tmp55.FindInternedVar(lang.NewSymbol("list")) + if tmp56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp56))) + } + tmp57 := tmp56.Get() + tmp58 := lang.Apply(tmp57, []any{lang.NewSymbol("glojure.core/alength")}) + tmp59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp60 := tmp59.FindInternedVar(lang.NewSymbol("list")) + if tmp60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp60))) + } + tmp61 := tmp60.Get() + tmp62 := lang.Apply(tmp61, []any{lang.NewSymbol("a__0__auto__")}) + tmp63 := lang.Apply(tmp54, []any{tmp58, tmp62}) + tmp64 := lang.Apply(tmp51, []any{tmp63}) + tmp65 := lang.Apply(tmp48, []any{tmp64}) + tmp66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp67 := tmp66.FindInternedVar(lang.NewSymbol("list")) + if tmp67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp67))) + } + tmp68 := tmp67.Get() + tmp69 := lang.Apply(tmp68, []any{v7}) + tmp70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp71 := tmp70.FindInternedVar(lang.NewSymbol("list")) + if tmp71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp71))) + } + tmp72 := tmp71.Get() + tmp73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp74 := tmp73.FindInternedVar(lang.NewSymbol("seq")) + if tmp74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp74))) + } + tmp75 := tmp74.Get() + tmp76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp77 := tmp76.FindInternedVar(lang.NewSymbol("concat")) + if tmp77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp77))) + } + tmp78 := tmp77.Get() + tmp79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp80 := tmp79.FindInternedVar(lang.NewSymbol("list")) + if tmp80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp80))) + } + tmp81 := tmp80.Get() + tmp82 := lang.Apply(tmp81, []any{lang.NewSymbol("glojure.core/aclone")}) + tmp83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp84 := tmp83.FindInternedVar(lang.NewSymbol("list")) + if tmp84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp84))) + } + tmp85 := tmp84.Get() + tmp86 := lang.Apply(tmp85, []any{lang.NewSymbol("a__0__auto__")}) + tmp87 := lang.Apply(tmp78, []any{tmp82, tmp86}) + tmp88 := lang.Apply(tmp75, []any{tmp87}) + tmp89 := lang.Apply(tmp72, []any{tmp88}) + tmp90 := lang.Apply(tmp33, []any{tmp37, tmp41, tmp45, tmp65, tmp69, tmp89}) + tmp91 := lang.Apply(tmp30, []any{tmp90}) + tmp92 := lang.Apply(tmp24, []any{tmp27, tmp91}) + tmp93 := lang.Apply(tmp21, []any{tmp92}) + tmp94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp95 := tmp94.FindInternedVar(lang.NewSymbol("list")) + if tmp95.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp95))) + } + tmp96 := tmp95.Get() + tmp97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp98 := tmp97.FindInternedVar(lang.NewSymbol("seq")) + if tmp98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp98))) + } + tmp99 := tmp98.Get() + tmp100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp101 := tmp100.FindInternedVar(lang.NewSymbol("concat")) + if tmp101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp101))) + } + tmp102 := tmp101.Get() + tmp103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp104 := tmp103.FindInternedVar(lang.NewSymbol("list")) + if tmp104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp104))) + } + tmp105 := tmp104.Get() + tmp106 := lang.Apply(tmp105, []any{lang.NewSymbol("glojure.core/loop")}) + tmp107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp108 := tmp107.FindInternedVar(lang.NewSymbol("list")) + if tmp108.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp108))) + } + tmp109 := tmp108.Get() + tmp110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp111 := tmp110.FindInternedVar(lang.NewSymbol("apply")) + if tmp111.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp111))) + } + tmp112 := tmp111.Get() + tmp113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp114 := tmp113.FindInternedVar(lang.NewSymbol("vector")) + if tmp114.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp114))) + } + tmp115 := tmp114.Get() + tmp116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp117 := tmp116.FindInternedVar(lang.NewSymbol("seq")) + if tmp117.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp117))) + } + tmp118 := tmp117.Get() + tmp119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp120 := tmp119.FindInternedVar(lang.NewSymbol("concat")) + if tmp120.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp120))) + } + tmp121 := tmp120.Get() + tmp122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp123 := tmp122.FindInternedVar(lang.NewSymbol("list")) + if tmp123.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp123))) + } + tmp124 := tmp123.Get() + tmp125 := lang.Apply(tmp124, []any{v6}) + tmp126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp127 := tmp126.FindInternedVar(lang.NewSymbol("list")) + if tmp127.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp127))) + } + tmp128 := tmp127.Get() + tmp129 := lang.Apply(tmp128, []any{int64(0)}) + tmp130 := lang.Apply(tmp121, []any{tmp125, tmp129}) + tmp131 := lang.Apply(tmp118, []any{tmp130}) + tmp132 := lang.Apply(tmp112, []any{tmp115, tmp131}) + tmp133 := lang.Apply(tmp109, []any{tmp132}) + tmp134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp135 := tmp134.FindInternedVar(lang.NewSymbol("list")) + if tmp135.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp135))) + } + tmp136 := tmp135.Get() + tmp137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp138 := tmp137.FindInternedVar(lang.NewSymbol("seq")) + if tmp138.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp138))) + } + tmp139 := tmp138.Get() + tmp140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp141 := tmp140.FindInternedVar(lang.NewSymbol("concat")) + if tmp141.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp141))) + } + tmp142 := tmp141.Get() + tmp143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp144 := tmp143.FindInternedVar(lang.NewSymbol("list")) + if tmp144.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp144))) + } + tmp145 := tmp144.Get() + tmp146 := lang.Apply(tmp145, []any{lang.NewSymbol("if")}) + tmp147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp148 := tmp147.FindInternedVar(lang.NewSymbol("list")) + if tmp148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp148))) + } + tmp149 := tmp148.Get() + tmp150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp151 := tmp150.FindInternedVar(lang.NewSymbol("seq")) + if tmp151.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp151))) + } + tmp152 := tmp151.Get() + tmp153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp154 := tmp153.FindInternedVar(lang.NewSymbol("concat")) + if tmp154.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp154))) + } + tmp155 := tmp154.Get() + tmp156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp157 := tmp156.FindInternedVar(lang.NewSymbol("list")) + if tmp157.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp157))) + } + tmp158 := tmp157.Get() + tmp159 := lang.Apply(tmp158, []any{lang.NewSymbol("glojure.core/<")}) + tmp160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp161 := tmp160.FindInternedVar(lang.NewSymbol("list")) + if tmp161.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp161))) + } + tmp162 := tmp161.Get() + tmp163 := lang.Apply(tmp162, []any{v6}) + tmp164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp165 := tmp164.FindInternedVar(lang.NewSymbol("list")) + if tmp165.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp165))) + } + tmp166 := tmp165.Get() + tmp167 := lang.Apply(tmp166, []any{lang.NewSymbol("l__1__auto__")}) + tmp168 := lang.Apply(tmp155, []any{tmp159, tmp163, tmp167}) + tmp169 := lang.Apply(tmp152, []any{tmp168}) + tmp170 := lang.Apply(tmp149, []any{tmp169}) + tmp171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp172 := tmp171.FindInternedVar(lang.NewSymbol("list")) + if tmp172.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp172))) + } + tmp173 := tmp172.Get() + tmp174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp175 := tmp174.FindInternedVar(lang.NewSymbol("seq")) + if tmp175.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp175))) + } + tmp176 := tmp175.Get() + tmp177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp178 := tmp177.FindInternedVar(lang.NewSymbol("concat")) + if tmp178.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp178))) + } + tmp179 := tmp178.Get() + tmp180 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp181 := tmp180.FindInternedVar(lang.NewSymbol("list")) + if tmp181.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp181))) + } + tmp182 := tmp181.Get() + tmp183 := lang.Apply(tmp182, []any{lang.NewSymbol("do")}) + tmp184 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp185 := tmp184.FindInternedVar(lang.NewSymbol("list")) + if tmp185.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp185))) + } + tmp186 := tmp185.Get() + tmp187 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp188 := tmp187.FindInternedVar(lang.NewSymbol("seq")) + if tmp188.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp188))) + } + tmp189 := tmp188.Get() + tmp190 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp191 := tmp190.FindInternedVar(lang.NewSymbol("concat")) + if tmp191.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp191))) + } + tmp192 := tmp191.Get() + tmp193 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp194 := tmp193.FindInternedVar(lang.NewSymbol("list")) + if tmp194.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp194))) + } + tmp195 := tmp194.Get() + tmp196 := lang.Apply(tmp195, []any{lang.NewSymbol("glojure.core/aset")}) + tmp197 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp198 := tmp197.FindInternedVar(lang.NewSymbol("list")) + if tmp198.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp198))) + } + tmp199 := tmp198.Get() + tmp200 := lang.Apply(tmp199, []any{v7}) + tmp201 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp202 := tmp201.FindInternedVar(lang.NewSymbol("list")) + if tmp202.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp202))) + } + tmp203 := tmp202.Get() + tmp204 := lang.Apply(tmp203, []any{v6}) + tmp205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp206 := tmp205.FindInternedVar(lang.NewSymbol("list")) + if tmp206.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp206))) + } + tmp207 := tmp206.Get() + tmp208 := lang.Apply(tmp207, []any{v8}) + tmp209 := lang.Apply(tmp192, []any{tmp196, tmp200, tmp204, tmp208}) + tmp210 := lang.Apply(tmp189, []any{tmp209}) + tmp211 := lang.Apply(tmp186, []any{tmp210}) + tmp212 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp213 := tmp212.FindInternedVar(lang.NewSymbol("list")) + if tmp213.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp213))) + } + tmp214 := tmp213.Get() + tmp215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp216 := tmp215.FindInternedVar(lang.NewSymbol("seq")) + if tmp216.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp216))) + } + tmp217 := tmp216.Get() + tmp218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp219 := tmp218.FindInternedVar(lang.NewSymbol("concat")) + if tmp219.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp219))) + } + tmp220 := tmp219.Get() + tmp221 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp222 := tmp221.FindInternedVar(lang.NewSymbol("list")) + if tmp222.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp222))) + } + tmp223 := tmp222.Get() + tmp224 := lang.Apply(tmp223, []any{lang.NewSymbol("recur")}) + tmp225 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp226 := tmp225.FindInternedVar(lang.NewSymbol("list")) + if tmp226.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp226))) + } + tmp227 := tmp226.Get() + tmp228 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp229 := tmp228.FindInternedVar(lang.NewSymbol("seq")) + if tmp229.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp229))) + } + tmp230 := tmp229.Get() + tmp231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp232 := tmp231.FindInternedVar(lang.NewSymbol("concat")) + if tmp232.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp232))) + } + tmp233 := tmp232.Get() + tmp234 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp235 := tmp234.FindInternedVar(lang.NewSymbol("list")) + if tmp235.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp235))) + } + tmp236 := tmp235.Get() + tmp237 := lang.Apply(tmp236, []any{lang.NewSymbol("glojure.core/unchecked-inc")}) + tmp238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp239 := tmp238.FindInternedVar(lang.NewSymbol("list")) + if tmp239.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp239))) + } + tmp240 := tmp239.Get() + tmp241 := lang.Apply(tmp240, []any{v6}) + tmp242 := lang.Apply(tmp233, []any{tmp237, tmp241}) + tmp243 := lang.Apply(tmp230, []any{tmp242}) + tmp244 := lang.Apply(tmp227, []any{tmp243}) + tmp245 := lang.Apply(tmp220, []any{tmp224, tmp244}) + tmp246 := lang.Apply(tmp217, []any{tmp245}) + tmp247 := lang.Apply(tmp214, []any{tmp246}) + tmp248 := lang.Apply(tmp179, []any{tmp183, tmp211, tmp247}) + tmp249 := lang.Apply(tmp176, []any{tmp248}) + tmp250 := lang.Apply(tmp173, []any{tmp249}) + tmp251 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp252 := tmp251.FindInternedVar(lang.NewSymbol("list")) + if tmp252.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp252))) + } + tmp253 := tmp252.Get() + tmp254 := lang.Apply(tmp253, []any{v7}) + tmp255 := lang.Apply(tmp142, []any{tmp146, tmp170, tmp250, tmp254}) + tmp256 := lang.Apply(tmp139, []any{tmp255}) + tmp257 := lang.Apply(tmp136, []any{tmp256}) + tmp258 := lang.Apply(tmp102, []any{tmp106, tmp133, tmp257}) + tmp259 := lang.Apply(tmp99, []any{tmp258}) + tmp260 := lang.Apply(tmp96, []any{tmp259}) + tmp261 := lang.Apply(tmp14, []any{tmp18, tmp93, tmp260}) + tmp262 := lang.Apply(tmp11, []any{tmp261}) + return tmp262 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // ancestors { - v0 := lang.NewSymbol("ancestors").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"))), lang.NewKeyword("doc"), "Returns the immediate and indirect parents of tag, either via a Java type\n inheritance relationship or a relationship established via derive. h\n must be a hierarchy obtained from make-hierarchy, if not supplied\n defaults to the global hierarchy", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5577), lang.NewKeyword("end-line"), int(5577))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("ancestors").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"))), lang.NewKeyword("doc"), "Returns the immediate and indirect parents of tag, either via a Java type\n inheritance relationship or a relationship established via derive. h\n must be a hierarchy obtained from make-hierarchy, if not supplied\n defaults to the global hierarchy", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5577), lang.NewKeyword("end-line"), int(5577))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("ancestors")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("global-hierarchy")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v6, []any{v9, v3}) - return v10 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("ancestors")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("global-hierarchy")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp6, []any{tmp9, v3}) + return tmp10 case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("not-empty")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("not-empty")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) } - v7 := v6.Get() - var v8 any + tmp7 := tmp6.Get() + var tmp8 any { // let // let binding "ta" - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("get")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) - v13 := lang.Apply(v11, []any{v12, v4}) - var v14 any = v13 + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("get")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) + tmp13 := lang.Apply(tmp11, []any{tmp12, v4}) + var v14 any = tmp13 _ = v14 - var v15 any - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("class?")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{v4}) - if lang.IsTruthy(v19) { - var v20 any + var tmp15 any + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("class?")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{v4}) + if lang.IsTruthy(tmp19) { + var tmp20 any { // let // let binding "superclasses" - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("set")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("supers")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.Apply(v26, []any{v4}) - v28 := lang.Apply(v23, []any{v27}) - var v29 any = v28 + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("set")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("supers")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.Apply(tmp26, []any{v4}) + tmp28 := lang.Apply(tmp23, []any{tmp27}) + var v29 any = tmp28 _ = v29 - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("reduce1")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) - } - v32 := v31.Get() - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("into1")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("cons")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v40 := v39.FindInternedVar(lang.NewSymbol("map")) - if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) - } - v41 := v40.Get() - var v42 lang.FnFunc - v42 = lang.NewFnFunc(func(args ...any) any { + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) + } + tmp32 := tmp31.Get() + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("into1")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) + } + tmp35 := tmp34.Get() + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("cons")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp40 := tmp39.FindInternedVar(lang.NewSymbol("map")) + if tmp40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) + } + tmp41 := tmp40.Get() + var tmp42 lang.FnFunc + tmp42 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v43 := args[0] _ = v43 - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("get")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("get")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) } - v46 := v45.Get() - v47 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) - v48 := lang.Apply(v46, []any{v47, v43}) - return v48 + tmp46 := tmp45.Get() + tmp47 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) + tmp48 := lang.Apply(tmp46, []any{tmp47, v43}) + return tmp48 }) - v43 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5590), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(5590), lang.NewKeyword("end-column"), int(54)) - v44, err := lang.WithMeta(v42, v43.(lang.IPersistentMap)) + tmp43 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5590), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(5590), lang.NewKeyword("end-column"), int(54)) + tmp44, err := lang.WithMeta(tmp42, tmp43.(lang.IPersistentMap)) if err != nil { panic(err) } - v45 := lang.Apply(v41, []any{v44, v29}) - v46 := lang.Apply(v38, []any{v14, v45}) - v47 := lang.Apply(v32, []any{v35, v29, v46}) - v20 = v47 + tmp45 := lang.Apply(tmp41, []any{tmp44, v29}) + tmp46 := lang.Apply(tmp38, []any{v14, tmp45}) + tmp47 := lang.Apply(tmp32, []any{tmp35, v29, tmp46}) + tmp20 = tmp47 } // end let - v15 = v20 + tmp15 = tmp20 } else { - v15 = v14 + tmp15 = v14 } - v8 = v15 + tmp8 = tmp15 } // end let - v9 := lang.Apply(v7, []any{v8}) - return v9 + tmp9 := lang.Apply(tmp7, []any{tmp8}) + return tmp9 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // and { - v0 := lang.NewSymbol("and").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("next"))), lang.NewKeyword("doc"), "Evaluates exprs one at a time, from left to right. If a form\n returns logical false (nil or false), and returns that value and\n doesn't evaluate any of the other expressions, otherwise it returns\n the value of the last expr. (and) returns true.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(835), lang.NewKeyword("end-line"), int(835))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("and").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("next"))), lang.NewKeyword("doc"), "Evaluates exprs one at a time, from left to right. If a form\n returns logical false (nil or false), and returns that value and\n doesn't evaluate any of the other expressions, otherwise it returns\n the value of the last expr. (and) returns true.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(835), lang.NewKeyword("end-line"), int(835))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 2: v3 := args[0] @@ -7455,161 +7484,162 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("seq")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("concat")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("list")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/let")}) - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("list")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("apply")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("vector")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("seq")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) - } - v28 := v27.Get() - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("concat")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("list")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{lang.NewSymbol("and__0__auto__")}) - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("list")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.Apply(v38, []any{v5}) - v40 := lang.Apply(v31, []any{v35, v39}) - v41 := lang.Apply(v28, []any{v40}) - v42 := lang.Apply(v22, []any{v25, v41}) - v43 := lang.Apply(v19, []any{v42}) - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("list")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) - } - v46 := v45.Get() - v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v48 := v47.FindInternedVar(lang.NewSymbol("seq")) - if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) - } - v49 := v48.Get() - v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v51 := v50.FindInternedVar(lang.NewSymbol("concat")) - if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) - } - v52 := v51.Get() - v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v54 := v53.FindInternedVar(lang.NewSymbol("list")) - if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) - } - v55 := v54.Get() - v56 := lang.Apply(v55, []any{lang.NewSymbol("if")}) - v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v58 := v57.FindInternedVar(lang.NewSymbol("list")) - if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) - } - v59 := v58.Get() - v60 := lang.Apply(v59, []any{lang.NewSymbol("and__0__auto__")}) - v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v62 := v61.FindInternedVar(lang.NewSymbol("list")) - if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) - } - v63 := v62.Get() - v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v65 := v64.FindInternedVar(lang.NewSymbol("seq")) - if v65.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) - } - v66 := v65.Get() - v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v68 := v67.FindInternedVar(lang.NewSymbol("concat")) - if v68.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) - } - v69 := v68.Get() - v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v71 := v70.FindInternedVar(lang.NewSymbol("list")) - if v71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) - } - v72 := v71.Get() - v73 := lang.Apply(v72, []any{lang.NewSymbol("glojure.core/and")}) - v74 := lang.Apply(v69, []any{v73, v6}) - v75 := lang.Apply(v66, []any{v74}) - v76 := lang.Apply(v63, []any{v75}) - v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v78 := v77.FindInternedVar(lang.NewSymbol("list")) - if v78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) - } - v79 := v78.Get() - v80 := lang.Apply(v79, []any{lang.NewSymbol("and__0__auto__")}) - v81 := lang.Apply(v52, []any{v56, v60, v76, v80}) - v82 := lang.Apply(v49, []any{v81}) - v83 := lang.Apply(v46, []any{v82}) - v84 := lang.Apply(v12, []any{v16, v43, v83}) - v85 := lang.Apply(v9, []any{v84}) - return v85 - } - }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("seq")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("concat")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("list")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("glojure.core/let")}) + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("list")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("apply")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("vector")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("seq")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) + } + tmp28 := tmp27.Get() + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("concat")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.Apply(tmp34, []any{lang.NewSymbol("and__0__auto__")}) + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{v5}) + tmp40 := lang.Apply(tmp31, []any{tmp35, tmp39}) + tmp41 := lang.Apply(tmp28, []any{tmp40}) + tmp42 := lang.Apply(tmp22, []any{tmp25, tmp41}) + tmp43 := lang.Apply(tmp19, []any{tmp42}) + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) + } + tmp46 := tmp45.Get() + tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp48 := tmp47.FindInternedVar(lang.NewSymbol("seq")) + if tmp48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) + } + tmp49 := tmp48.Get() + tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp51 := tmp50.FindInternedVar(lang.NewSymbol("concat")) + if tmp51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) + } + tmp52 := tmp51.Get() + tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp54 := tmp53.FindInternedVar(lang.NewSymbol("list")) + if tmp54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) + } + tmp55 := tmp54.Get() + tmp56 := lang.Apply(tmp55, []any{lang.NewSymbol("if")}) + tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp58 := tmp57.FindInternedVar(lang.NewSymbol("list")) + if tmp58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) + } + tmp59 := tmp58.Get() + tmp60 := lang.Apply(tmp59, []any{lang.NewSymbol("and__0__auto__")}) + tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp62 := tmp61.FindInternedVar(lang.NewSymbol("list")) + if tmp62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) + } + tmp63 := tmp62.Get() + tmp64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp65 := tmp64.FindInternedVar(lang.NewSymbol("seq")) + if tmp65.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp65))) + } + tmp66 := tmp65.Get() + tmp67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp68 := tmp67.FindInternedVar(lang.NewSymbol("concat")) + if tmp68.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp68))) + } + tmp69 := tmp68.Get() + tmp70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp71 := tmp70.FindInternedVar(lang.NewSymbol("list")) + if tmp71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp71))) + } + tmp72 := tmp71.Get() + tmp73 := lang.Apply(tmp72, []any{lang.NewSymbol("glojure.core/and")}) + tmp74 := lang.Apply(tmp69, []any{tmp73, v6}) + tmp75 := lang.Apply(tmp66, []any{tmp74}) + tmp76 := lang.Apply(tmp63, []any{tmp75}) + tmp77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp78 := tmp77.FindInternedVar(lang.NewSymbol("list")) + if tmp78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp78))) + } + tmp79 := tmp78.Get() + tmp80 := lang.Apply(tmp79, []any{lang.NewSymbol("and__0__auto__")}) + tmp81 := lang.Apply(tmp52, []any{tmp56, tmp60, tmp76, tmp80}) + tmp82 := lang.Apply(tmp49, []any{tmp81}) + tmp83 := lang.Apply(tmp46, []any{tmp82}) + tmp84 := lang.Apply(tmp12, []any{tmp16, tmp43, tmp83}) + tmp85 := lang.Apply(tmp9, []any{tmp84}) + return tmp85 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // any? { - v1 := reflect.TypeOf(false) - v0 := lang.NewSymbol("any?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true given any argument.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(537), lang.NewKeyword("end-line"), int(537))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp1 := reflect.TypeOf(false) + tmp0 := lang.NewSymbol("any?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true given any argument.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(537), lang.NewKeyword("end-line"), int(537))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -7617,33 +7647,33 @@ func init() { _ = v4 return true }) - v4 := reflect.TypeOf(false) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp4 := reflect.TypeOf(false) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // apply { - v0 := lang.NewSymbol("apply").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("z"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Applies fn f to the argument list formed by prepending intervening arguments to args.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(653), lang.NewKeyword("end-line"), int(653))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("apply").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("z"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Applies fn f to the argument list formed by prepending intervening arguments to args.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(653), lang.NewKeyword("end-line"), int(653))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("seq")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v4}) - v9 := lang.Apply(lang.Apply, []any{v3, v8}) - return v9 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v4}) + tmp9 := lang.Apply(lang.Apply, []any{v3, tmp8}) + return tmp9 case 3: v3 := args[0] _ = v3 @@ -7651,15 +7681,15 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("list*")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{v4, v5}) - v10 := lang.Apply(lang.Apply, []any{v3, v9}) - return v10 + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("list*")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.Apply(tmp8, []any{v4, v5}) + tmp10 := lang.Apply(lang.Apply, []any{v3, tmp9}) + return tmp10 case 4: v3 := args[0] _ = v3 @@ -7669,15 +7699,15 @@ func init() { _ = v5 v6 := args[3] _ = v6 - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("list*")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v9, []any{v4, v5, v6}) - v11 := lang.Apply(lang.Apply, []any{v3, v10}) - return v11 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("list*")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp9, []any{v4, v5, v6}) + tmp11 := lang.Apply(lang.Apply, []any{v3, tmp10}) + return tmp11 case 5: v3 := args[0] _ = v3 @@ -7689,15 +7719,15 @@ func init() { _ = v6 v7 := args[4] _ = v7 - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("list*")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v4, v5, v6, v7}) - v12 := lang.Apply(lang.Apply, []any{v3, v11}) - return v12 + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("list*")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v4, v5, v6, v7}) + tmp12 := lang.Apply(lang.Apply, []any{v3, tmp11}) + return tmp12 default: if len(args) < 5 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -7712,57 +7742,58 @@ func init() { _ = v6 v7 := args[4] _ = v7 - v8 := lang.NewList(args[5:]...) - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("cons")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("cons")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("cons")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("cons")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("spread")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.Apply(v23, []any{v8}) - v25 := lang.Apply(v20, []any{v7, v24}) - v26 := lang.Apply(v17, []any{v6, v25}) - v27 := lang.Apply(v14, []any{v5, v26}) - v28 := lang.Apply(v11, []any{v4, v27}) - v29 := lang.Apply(lang.Apply, []any{v3, v28}) - return v29 - } - }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + var v8 any = lang.NewList(args[5:]...) + _ = v8 + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("cons")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("cons")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("cons")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("cons")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("spread")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.Apply(tmp23, []any{v8}) + tmp25 := lang.Apply(tmp20, []any{v7, tmp24}) + tmp26 := lang.Apply(tmp17, []any{v6, tmp25}) + tmp27 := lang.Apply(tmp14, []any{v5, tmp26}) + tmp28 := lang.Apply(tmp11, []any{v4, tmp27}) + tmp29 := lang.Apply(lang.Apply, []any{v3, tmp28}) + return tmp29 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // areduce { - v0 := lang.NewSymbol("areduce").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("idx"), lang.NewSymbol("ret"), lang.NewSymbol("init"), lang.NewSymbol("expr"))), lang.NewKeyword("doc"), "Reduces an expression across an array a, using an index named idx,\n and return value named ret, initialized to init, setting ret to the \n evaluation of expr at each step, returning ret.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5289), lang.NewKeyword("end-line"), int(5289))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("areduce").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("idx"), lang.NewSymbol("ret"), lang.NewSymbol("init"), lang.NewSymbol("expr"))), lang.NewKeyword("doc"), "Reduces an expression across an array a, using an index named idx,\n and return value named ret, initialized to init, setting ret to the \n evaluation of expr at each step, returning ret.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5289), lang.NewKeyword("end-line"), int(5289))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 7 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -7780,477 +7811,479 @@ func init() { _ = v8 v9 := args[6] _ = v9 - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("seq")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("concat")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("list")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{lang.NewSymbol("glojure.core/let")}) - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("list")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("apply")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("vector")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) - } - v28 := v27.Get() - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("seq")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("concat")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v36 := v35.FindInternedVar(lang.NewSymbol("list")) - if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) - } - v37 := v36.Get() - v38 := lang.Apply(v37, []any{lang.NewSymbol("a__0__auto__")}) - v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v40 := v39.FindInternedVar(lang.NewSymbol("list")) - if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) - } - v41 := v40.Get() - v42 := lang.Apply(v41, []any{v5}) - v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v44 := v43.FindInternedVar(lang.NewSymbol("list")) - if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) - } - v45 := v44.Get() - v46 := lang.Apply(v45, []any{lang.NewSymbol("l__1__auto__")}) - v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v48 := v47.FindInternedVar(lang.NewSymbol("list")) - if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) - } - v49 := v48.Get() - v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v51 := v50.FindInternedVar(lang.NewSymbol("seq")) - if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) - } - v52 := v51.Get() - v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v54 := v53.FindInternedVar(lang.NewSymbol("concat")) - if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) - } - v55 := v54.Get() - v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v57 := v56.FindInternedVar(lang.NewSymbol("list")) - if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) - } - v58 := v57.Get() - v59 := lang.Apply(v58, []any{lang.NewSymbol("glojure.core/alength")}) - v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v61 := v60.FindInternedVar(lang.NewSymbol("list")) - if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) - } - v62 := v61.Get() - v63 := lang.Apply(v62, []any{lang.NewSymbol("a__0__auto__")}) - v64 := lang.Apply(v55, []any{v59, v63}) - v65 := lang.Apply(v52, []any{v64}) - v66 := lang.Apply(v49, []any{v65}) - v67 := lang.Apply(v34, []any{v38, v42, v46, v66}) - v68 := lang.Apply(v31, []any{v67}) - v69 := lang.Apply(v25, []any{v28, v68}) - v70 := lang.Apply(v22, []any{v69}) - v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v72 := v71.FindInternedVar(lang.NewSymbol("list")) - if v72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) - } - v73 := v72.Get() - v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v75 := v74.FindInternedVar(lang.NewSymbol("seq")) - if v75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) - } - v76 := v75.Get() - v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v78 := v77.FindInternedVar(lang.NewSymbol("concat")) - if v78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) - } - v79 := v78.Get() - v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v81 := v80.FindInternedVar(lang.NewSymbol("list")) - if v81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) - } - v82 := v81.Get() - v83 := lang.Apply(v82, []any{lang.NewSymbol("glojure.core/loop")}) - v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v85 := v84.FindInternedVar(lang.NewSymbol("list")) - if v85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) - } - v86 := v85.Get() - v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v88 := v87.FindInternedVar(lang.NewSymbol("apply")) - if v88.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) - } - v89 := v88.Get() - v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v91 := v90.FindInternedVar(lang.NewSymbol("vector")) - if v91.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) - } - v92 := v91.Get() - v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v94 := v93.FindInternedVar(lang.NewSymbol("seq")) - if v94.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) - } - v95 := v94.Get() - v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v97 := v96.FindInternedVar(lang.NewSymbol("concat")) - if v97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) - } - v98 := v97.Get() - v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v100 := v99.FindInternedVar(lang.NewSymbol("list")) - if v100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) - } - v101 := v100.Get() - v102 := lang.Apply(v101, []any{v6}) - v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v104 := v103.FindInternedVar(lang.NewSymbol("list")) - if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) - } - v105 := v104.Get() - v106 := lang.Apply(v105, []any{int64(0)}) - v107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v108 := v107.FindInternedVar(lang.NewSymbol("list")) - if v108.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v108))) - } - v109 := v108.Get() - v110 := lang.Apply(v109, []any{v7}) - v111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v112 := v111.FindInternedVar(lang.NewSymbol("list")) - if v112.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v112))) - } - v113 := v112.Get() - v114 := lang.Apply(v113, []any{v8}) - v115 := lang.Apply(v98, []any{v102, v106, v110, v114}) - v116 := lang.Apply(v95, []any{v115}) - v117 := lang.Apply(v89, []any{v92, v116}) - v118 := lang.Apply(v86, []any{v117}) - v119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v120 := v119.FindInternedVar(lang.NewSymbol("list")) - if v120.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v120))) - } - v121 := v120.Get() - v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v123 := v122.FindInternedVar(lang.NewSymbol("seq")) - if v123.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) - } - v124 := v123.Get() - v125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v126 := v125.FindInternedVar(lang.NewSymbol("concat")) - if v126.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v126))) - } - v127 := v126.Get() - v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v129 := v128.FindInternedVar(lang.NewSymbol("list")) - if v129.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v129))) - } - v130 := v129.Get() - v131 := lang.Apply(v130, []any{lang.NewSymbol("if")}) - v132 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v133 := v132.FindInternedVar(lang.NewSymbol("list")) - if v133.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v133))) - } - v134 := v133.Get() - v135 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v136 := v135.FindInternedVar(lang.NewSymbol("seq")) - if v136.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v136))) - } - v137 := v136.Get() - v138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v139 := v138.FindInternedVar(lang.NewSymbol("concat")) - if v139.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v139))) - } - v140 := v139.Get() - v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v142 := v141.FindInternedVar(lang.NewSymbol("list")) - if v142.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) - } - v143 := v142.Get() - v144 := lang.Apply(v143, []any{lang.NewSymbol("glojure.core/<")}) - v145 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v146 := v145.FindInternedVar(lang.NewSymbol("list")) - if v146.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v146))) - } - v147 := v146.Get() - v148 := lang.Apply(v147, []any{v6}) - v149 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v150 := v149.FindInternedVar(lang.NewSymbol("list")) - if v150.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v150))) - } - v151 := v150.Get() - v152 := lang.Apply(v151, []any{lang.NewSymbol("l__1__auto__")}) - v153 := lang.Apply(v140, []any{v144, v148, v152}) - v154 := lang.Apply(v137, []any{v153}) - v155 := lang.Apply(v134, []any{v154}) - v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v157 := v156.FindInternedVar(lang.NewSymbol("list")) - if v157.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) - } - v158 := v157.Get() - v159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v160 := v159.FindInternedVar(lang.NewSymbol("seq")) - if v160.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v160))) - } - v161 := v160.Get() - v162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v163 := v162.FindInternedVar(lang.NewSymbol("concat")) - if v163.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v163))) - } - v164 := v163.Get() - v165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v166 := v165.FindInternedVar(lang.NewSymbol("list")) - if v166.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v166))) - } - v167 := v166.Get() - v168 := lang.Apply(v167, []any{lang.NewSymbol("recur")}) - v169 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v170 := v169.FindInternedVar(lang.NewSymbol("list")) - if v170.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v170))) - } - v171 := v170.Get() - v172 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v173 := v172.FindInternedVar(lang.NewSymbol("seq")) - if v173.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v173))) - } - v174 := v173.Get() - v175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v176 := v175.FindInternedVar(lang.NewSymbol("concat")) - if v176.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v176))) - } - v177 := v176.Get() - v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v179 := v178.FindInternedVar(lang.NewSymbol("list")) - if v179.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) - } - v180 := v179.Get() - v181 := lang.Apply(v180, []any{lang.NewSymbol("glojure.core/unchecked-inc-int")}) - v182 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v183 := v182.FindInternedVar(lang.NewSymbol("list")) - if v183.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v183))) - } - v184 := v183.Get() - v185 := lang.Apply(v184, []any{v6}) - v186 := lang.Apply(v177, []any{v181, v185}) - v187 := lang.Apply(v174, []any{v186}) - v188 := lang.Apply(v171, []any{v187}) - v189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v190 := v189.FindInternedVar(lang.NewSymbol("list")) - if v190.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v190))) - } - v191 := v190.Get() - v192 := lang.Apply(v191, []any{v9}) - v193 := lang.Apply(v164, []any{v168, v188, v192}) - v194 := lang.Apply(v161, []any{v193}) - v195 := lang.Apply(v158, []any{v194}) - v196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v197 := v196.FindInternedVar(lang.NewSymbol("list")) - if v197.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v197))) - } - v198 := v197.Get() - v199 := lang.Apply(v198, []any{v7}) - v200 := lang.Apply(v127, []any{v131, v155, v195, v199}) - v201 := lang.Apply(v124, []any{v200}) - v202 := lang.Apply(v121, []any{v201}) - v203 := lang.Apply(v79, []any{v83, v118, v202}) - v204 := lang.Apply(v76, []any{v203}) - v205 := lang.Apply(v73, []any{v204}) - v206 := lang.Apply(v15, []any{v19, v70, v205}) - v207 := lang.Apply(v12, []any{v206}) - return v207 - }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("seq")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("concat")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("list")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{lang.NewSymbol("glojure.core/let")}) + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("list")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("apply")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("vector")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) + } + tmp28 := tmp27.Get() + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("seq")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("concat")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp36 := tmp35.FindInternedVar(lang.NewSymbol("list")) + if tmp36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) + } + tmp37 := tmp36.Get() + tmp38 := lang.Apply(tmp37, []any{lang.NewSymbol("a__0__auto__")}) + tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp40 := tmp39.FindInternedVar(lang.NewSymbol("list")) + if tmp40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) + } + tmp41 := tmp40.Get() + tmp42 := lang.Apply(tmp41, []any{v5}) + tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp44 := tmp43.FindInternedVar(lang.NewSymbol("list")) + if tmp44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) + } + tmp45 := tmp44.Get() + tmp46 := lang.Apply(tmp45, []any{lang.NewSymbol("l__1__auto__")}) + tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp48 := tmp47.FindInternedVar(lang.NewSymbol("list")) + if tmp48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) + } + tmp49 := tmp48.Get() + tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp51 := tmp50.FindInternedVar(lang.NewSymbol("seq")) + if tmp51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) + } + tmp52 := tmp51.Get() + tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp54 := tmp53.FindInternedVar(lang.NewSymbol("concat")) + if tmp54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) + } + tmp55 := tmp54.Get() + tmp56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp57 := tmp56.FindInternedVar(lang.NewSymbol("list")) + if tmp57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp57))) + } + tmp58 := tmp57.Get() + tmp59 := lang.Apply(tmp58, []any{lang.NewSymbol("glojure.core/alength")}) + tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp61 := tmp60.FindInternedVar(lang.NewSymbol("list")) + if tmp61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) + } + tmp62 := tmp61.Get() + tmp63 := lang.Apply(tmp62, []any{lang.NewSymbol("a__0__auto__")}) + tmp64 := lang.Apply(tmp55, []any{tmp59, tmp63}) + tmp65 := lang.Apply(tmp52, []any{tmp64}) + tmp66 := lang.Apply(tmp49, []any{tmp65}) + tmp67 := lang.Apply(tmp34, []any{tmp38, tmp42, tmp46, tmp66}) + tmp68 := lang.Apply(tmp31, []any{tmp67}) + tmp69 := lang.Apply(tmp25, []any{tmp28, tmp68}) + tmp70 := lang.Apply(tmp22, []any{tmp69}) + tmp71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp72 := tmp71.FindInternedVar(lang.NewSymbol("list")) + if tmp72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp72))) + } + tmp73 := tmp72.Get() + tmp74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp75 := tmp74.FindInternedVar(lang.NewSymbol("seq")) + if tmp75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp75))) + } + tmp76 := tmp75.Get() + tmp77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp78 := tmp77.FindInternedVar(lang.NewSymbol("concat")) + if tmp78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp78))) + } + tmp79 := tmp78.Get() + tmp80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp81 := tmp80.FindInternedVar(lang.NewSymbol("list")) + if tmp81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp81))) + } + tmp82 := tmp81.Get() + tmp83 := lang.Apply(tmp82, []any{lang.NewSymbol("glojure.core/loop")}) + tmp84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp85 := tmp84.FindInternedVar(lang.NewSymbol("list")) + if tmp85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp85))) + } + tmp86 := tmp85.Get() + tmp87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp88 := tmp87.FindInternedVar(lang.NewSymbol("apply")) + if tmp88.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp88))) + } + tmp89 := tmp88.Get() + tmp90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp91 := tmp90.FindInternedVar(lang.NewSymbol("vector")) + if tmp91.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp91))) + } + tmp92 := tmp91.Get() + tmp93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp94 := tmp93.FindInternedVar(lang.NewSymbol("seq")) + if tmp94.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp94))) + } + tmp95 := tmp94.Get() + tmp96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp97 := tmp96.FindInternedVar(lang.NewSymbol("concat")) + if tmp97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp97))) + } + tmp98 := tmp97.Get() + tmp99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp100 := tmp99.FindInternedVar(lang.NewSymbol("list")) + if tmp100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp100))) + } + tmp101 := tmp100.Get() + tmp102 := lang.Apply(tmp101, []any{v6}) + tmp103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp104 := tmp103.FindInternedVar(lang.NewSymbol("list")) + if tmp104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp104))) + } + tmp105 := tmp104.Get() + tmp106 := lang.Apply(tmp105, []any{int64(0)}) + tmp107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp108 := tmp107.FindInternedVar(lang.NewSymbol("list")) + if tmp108.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp108))) + } + tmp109 := tmp108.Get() + tmp110 := lang.Apply(tmp109, []any{v7}) + tmp111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp112 := tmp111.FindInternedVar(lang.NewSymbol("list")) + if tmp112.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp112))) + } + tmp113 := tmp112.Get() + tmp114 := lang.Apply(tmp113, []any{v8}) + tmp115 := lang.Apply(tmp98, []any{tmp102, tmp106, tmp110, tmp114}) + tmp116 := lang.Apply(tmp95, []any{tmp115}) + tmp117 := lang.Apply(tmp89, []any{tmp92, tmp116}) + tmp118 := lang.Apply(tmp86, []any{tmp117}) + tmp119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp120 := tmp119.FindInternedVar(lang.NewSymbol("list")) + if tmp120.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp120))) + } + tmp121 := tmp120.Get() + tmp122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp123 := tmp122.FindInternedVar(lang.NewSymbol("seq")) + if tmp123.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp123))) + } + tmp124 := tmp123.Get() + tmp125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp126 := tmp125.FindInternedVar(lang.NewSymbol("concat")) + if tmp126.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp126))) + } + tmp127 := tmp126.Get() + tmp128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp129 := tmp128.FindInternedVar(lang.NewSymbol("list")) + if tmp129.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp129))) + } + tmp130 := tmp129.Get() + tmp131 := lang.Apply(tmp130, []any{lang.NewSymbol("if")}) + tmp132 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp133 := tmp132.FindInternedVar(lang.NewSymbol("list")) + if tmp133.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp133))) + } + tmp134 := tmp133.Get() + tmp135 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp136 := tmp135.FindInternedVar(lang.NewSymbol("seq")) + if tmp136.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp136))) + } + tmp137 := tmp136.Get() + tmp138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp139 := tmp138.FindInternedVar(lang.NewSymbol("concat")) + if tmp139.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp139))) + } + tmp140 := tmp139.Get() + tmp141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp142 := tmp141.FindInternedVar(lang.NewSymbol("list")) + if tmp142.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp142))) + } + tmp143 := tmp142.Get() + tmp144 := lang.Apply(tmp143, []any{lang.NewSymbol("glojure.core/<")}) + tmp145 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp146 := tmp145.FindInternedVar(lang.NewSymbol("list")) + if tmp146.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp146))) + } + tmp147 := tmp146.Get() + tmp148 := lang.Apply(tmp147, []any{v6}) + tmp149 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp150 := tmp149.FindInternedVar(lang.NewSymbol("list")) + if tmp150.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp150))) + } + tmp151 := tmp150.Get() + tmp152 := lang.Apply(tmp151, []any{lang.NewSymbol("l__1__auto__")}) + tmp153 := lang.Apply(tmp140, []any{tmp144, tmp148, tmp152}) + tmp154 := lang.Apply(tmp137, []any{tmp153}) + tmp155 := lang.Apply(tmp134, []any{tmp154}) + tmp156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp157 := tmp156.FindInternedVar(lang.NewSymbol("list")) + if tmp157.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp157))) + } + tmp158 := tmp157.Get() + tmp159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp160 := tmp159.FindInternedVar(lang.NewSymbol("seq")) + if tmp160.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp160))) + } + tmp161 := tmp160.Get() + tmp162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp163 := tmp162.FindInternedVar(lang.NewSymbol("concat")) + if tmp163.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp163))) + } + tmp164 := tmp163.Get() + tmp165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp166 := tmp165.FindInternedVar(lang.NewSymbol("list")) + if tmp166.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp166))) + } + tmp167 := tmp166.Get() + tmp168 := lang.Apply(tmp167, []any{lang.NewSymbol("recur")}) + tmp169 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp170 := tmp169.FindInternedVar(lang.NewSymbol("list")) + if tmp170.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp170))) + } + tmp171 := tmp170.Get() + tmp172 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp173 := tmp172.FindInternedVar(lang.NewSymbol("seq")) + if tmp173.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp173))) + } + tmp174 := tmp173.Get() + tmp175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp176 := tmp175.FindInternedVar(lang.NewSymbol("concat")) + if tmp176.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp176))) + } + tmp177 := tmp176.Get() + tmp178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp179 := tmp178.FindInternedVar(lang.NewSymbol("list")) + if tmp179.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp179))) + } + tmp180 := tmp179.Get() + tmp181 := lang.Apply(tmp180, []any{lang.NewSymbol("glojure.core/unchecked-inc-int")}) + tmp182 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp183 := tmp182.FindInternedVar(lang.NewSymbol("list")) + if tmp183.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp183))) + } + tmp184 := tmp183.Get() + tmp185 := lang.Apply(tmp184, []any{v6}) + tmp186 := lang.Apply(tmp177, []any{tmp181, tmp185}) + tmp187 := lang.Apply(tmp174, []any{tmp186}) + tmp188 := lang.Apply(tmp171, []any{tmp187}) + tmp189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp190 := tmp189.FindInternedVar(lang.NewSymbol("list")) + if tmp190.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp190))) + } + tmp191 := tmp190.Get() + tmp192 := lang.Apply(tmp191, []any{v9}) + tmp193 := lang.Apply(tmp164, []any{tmp168, tmp188, tmp192}) + tmp194 := lang.Apply(tmp161, []any{tmp193}) + tmp195 := lang.Apply(tmp158, []any{tmp194}) + tmp196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp197 := tmp196.FindInternedVar(lang.NewSymbol("list")) + if tmp197.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp197))) + } + tmp198 := tmp197.Get() + tmp199 := lang.Apply(tmp198, []any{v7}) + tmp200 := lang.Apply(tmp127, []any{tmp131, tmp155, tmp195, tmp199}) + tmp201 := lang.Apply(tmp124, []any{tmp200}) + tmp202 := lang.Apply(tmp121, []any{tmp201}) + tmp203 := lang.Apply(tmp79, []any{tmp83, tmp118, tmp202}) + tmp204 := lang.Apply(tmp76, []any{tmp203}) + tmp205 := lang.Apply(tmp73, []any{tmp204}) + tmp206 := lang.Apply(tmp15, []any{tmp19, tmp70, tmp205}) + tmp207 := lang.Apply(tmp12, []any{tmp206}) + return tmp207 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // array { - v0 := lang.NewSymbol("array").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3457), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3458), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("items"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("array").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3457), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3458), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("items"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v3 := lang.NewList(args[0:]...) - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("into-array")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("into-array")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) } - v6 := v5.Get() - v7 := lang.Apply(v6, []any{v3}) - return v7 + tmp6 := tmp5.Get() + tmp7 := lang.Apply(tmp6, []any{v3}) + return tmp7 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // array-map { - v0 := lang.NewSymbol("array-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keyvals"))), lang.NewKeyword("doc"), "Constructs an array-map. If any keys are equal, they are handled as\n if by repeated uses of assoc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4378), lang.NewKeyword("end-line"), int(4378))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("array-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keyvals"))), lang.NewKeyword("doc"), "Constructs an array-map. If any keys are equal, they are handled as\n if by repeated uses of assoc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4378), lang.NewKeyword("end-line"), int(4378))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - v3, ok := lang.FieldOrMethod(nil, "EMPTY") + tmp3, ok := lang.FieldOrMethod(nil, "EMPTY") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "EMPTY"))) } - var v4 any - switch reflect.TypeOf(v3).Kind() { + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { case reflect.Func: - v4 = lang.Apply(v3, nil) + tmp4 = lang.Apply(tmp3, nil) default: - v4 = v3 + tmp4 = tmp3 } - return v4 + return tmp4 default: if len(args) < 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v3 := lang.NewList(args[0:]...) - var v4 any + var v3 any = lang.NewList(args[0:]...) + _ = v3 + var tmp4 any { // let // let binding "ary" - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("to-array")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v3}) - var v9 any = v8 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("to-array")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v3}) + var v9 any = tmp8 _ = v9 - var v10 any - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("odd?")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("alength")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{v9}) - v18 := lang.Apply(v13, []any{v17}) - if lang.IsTruthy(v18) { - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("str")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("last")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v3}) - v26 := lang.Apply(v21, []any{"No value supplied for key: ", v25}) - v27 := lang.Apply(lang.NewIllegalArgumentError, []any{v26}) - panic(v27) + var tmp10 any + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("odd?")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("alength")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{v9}) + tmp18 := lang.Apply(tmp13, []any{tmp17}) + if lang.IsTruthy(tmp18) { + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("str")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("last")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.Apply(tmp24, []any{v3}) + tmp26 := lang.Apply(tmp21, []any{"No value supplied for key: ", tmp25}) + tmp27 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp26}) + panic(tmp27) } else { - v28 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{v9}) - v10 = v28 + tmp28 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{v9}) + tmp10 = tmp28 } - v4 = v10 + tmp4 = tmp10 } // end let - return v4 + return tmp4 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // as-> { - v0 := lang.NewSymbol("as->").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "Binds name to expr, evaluates the first form in the lexical context\n of that binding, then binds name to that result, repeating for each\n successive form, returning the result of the last form.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7598), lang.NewKeyword("end-line"), int(7598))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("as->").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "Binds name to expr, evaluates the first form in the lexical context\n of that binding, then binds name to that result, repeating for each\n successive form, returning the result of the last form.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7598), lang.NewKeyword("end-line"), int(7598))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 4 { @@ -8264,138 +8297,140 @@ func init() { _ = v5 v6 := args[3] _ = v6 - v7 := lang.NewList(args[4:]...) - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("seq")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("concat")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("glojure.core/let")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("apply")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("vector")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("seq")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("concat")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) - } - v32 := v31.Get() - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("list")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - v36 := lang.Apply(v35, []any{v6}) - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("list")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.Apply(v39, []any{v5}) - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("interleave")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) - } - v43 := v42.Get() - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("repeat")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) - } - v46 := v45.Get() - v47 := lang.Apply(v46, []any{v6}) - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("butlast")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v7}) - v52 := lang.Apply(v43, []any{v47, v51}) - v53 := lang.Apply(v32, []any{v36, v40, v52}) - v54 := lang.Apply(v29, []any{v53}) - v55 := lang.Apply(v23, []any{v26, v54}) - v56 := lang.Apply(v20, []any{v55}) - v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v58 := v57.FindInternedVar(lang.NewSymbol("list")) - if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) - } - v59 := v58.Get() - var v60 any - v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v62 := v61.FindInternedVar(lang.NewSymbol("empty?")) - if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) - } - v63 := v62.Get() - v64 := lang.Apply(v63, []any{v7}) - if lang.IsTruthy(v64) { - v60 = v6 + var v7 any = lang.NewList(args[4:]...) + _ = v7 + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("seq")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("concat")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("glojure.core/let")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("apply")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("vector")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("seq")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("concat")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) + } + tmp32 := tmp31.Get() + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("list")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) + } + tmp35 := tmp34.Get() + tmp36 := lang.Apply(tmp35, []any{v6}) + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("list")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.Apply(tmp39, []any{v5}) + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("interleave")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("repeat")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) + } + tmp46 := tmp45.Get() + tmp47 := lang.Apply(tmp46, []any{v6}) + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("butlast")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v7}) + tmp52 := lang.Apply(tmp43, []any{tmp47, tmp51}) + tmp53 := lang.Apply(tmp32, []any{tmp36, tmp40, tmp52}) + tmp54 := lang.Apply(tmp29, []any{tmp53}) + tmp55 := lang.Apply(tmp23, []any{tmp26, tmp54}) + tmp56 := lang.Apply(tmp20, []any{tmp55}) + tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp58 := tmp57.FindInternedVar(lang.NewSymbol("list")) + if tmp58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) + } + tmp59 := tmp58.Get() + var tmp60 any + tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp62 := tmp61.FindInternedVar(lang.NewSymbol("empty?")) + if tmp62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) + } + tmp63 := tmp62.Get() + tmp64 := lang.Apply(tmp63, []any{v7}) + if lang.IsTruthy(tmp64) { + tmp60 = v6 } else { - v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v66 := v65.FindInternedVar(lang.NewSymbol("last")) - if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) + tmp65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp66 := tmp65.FindInternedVar(lang.NewSymbol("last")) + if tmp66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp66))) } - v67 := v66.Get() - v68 := lang.Apply(v67, []any{v7}) - v60 = v68 + tmp67 := tmp66.Get() + tmp68 := lang.Apply(tmp67, []any{v7}) + tmp60 = tmp68 } - v69 := lang.Apply(v59, []any{v60}) - v70 := lang.Apply(v13, []any{v17, v56, v69}) - v71 := lang.Apply(v10, []any{v70}) - return v71 + tmp69 := lang.Apply(tmp59, []any{tmp60}) + tmp70 := lang.Apply(tmp13, []any{tmp17, tmp56, tmp69}) + tmp71 := lang.Apply(tmp10, []any{tmp70}) + return tmp71 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // aset { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function aset__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -8405,119 +8440,119 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("seq")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("concat")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("list")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.Apply(v14, []any{lang.NewSymbol(".")}) - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("list")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("list")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("seq")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("concat")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) - } - v28 := v27.Get() - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("list")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.Apply(v31, []any{lang.NewSymbol("glojure.core/Aset")}) - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("list")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - v36 := lang.Apply(v35, []any{v3}) - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("list")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("seq")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) - } - v42 := v41.Get() - v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v44 := v43.FindInternedVar(lang.NewSymbol("concat")) - if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) - } - v45 := v44.Get() - v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v47 := v46.FindInternedVar(lang.NewSymbol("list")) - if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) - } - v48 := v47.Get() - v49 := lang.Apply(v48, []any{lang.NewSymbol("glojure.core/int")}) - v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v51 := v50.FindInternedVar(lang.NewSymbol("list")) - if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) - } - v52 := v51.Get() - v53 := lang.Apply(v52, []any{v4}) - v54 := lang.Apply(v45, []any{v49, v53}) - v55 := lang.Apply(v42, []any{v54}) - v56 := lang.Apply(v39, []any{v55}) - v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v58 := v57.FindInternedVar(lang.NewSymbol("list")) - if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) - } - v59 := v58.Get() - v60 := lang.Apply(v59, []any{v5}) - v61 := lang.Apply(v28, []any{v32, v36, v56, v60}) - v62 := lang.Apply(v25, []any{v61}) - v63 := lang.Apply(v22, []any{v62}) - v64 := lang.Apply(v11, []any{v15, v19, v63}) - v65 := lang.Apply(v8, []any{v64}) - return v65 + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("seq")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("concat")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("list")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol(".")}) + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("list")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("list")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("seq")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("concat")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) + } + tmp28 := tmp27.Get() + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("list")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.Apply(tmp31, []any{lang.NewSymbol("glojure.core/Aset")}) + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("list")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) + } + tmp35 := tmp34.Get() + tmp36 := lang.Apply(tmp35, []any{v3}) + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("list")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("seq")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) + } + tmp42 := tmp41.Get() + tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp44 := tmp43.FindInternedVar(lang.NewSymbol("concat")) + if tmp44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) + } + tmp45 := tmp44.Get() + tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp47 := tmp46.FindInternedVar(lang.NewSymbol("list")) + if tmp47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) + } + tmp48 := tmp47.Get() + tmp49 := lang.Apply(tmp48, []any{lang.NewSymbol("glojure.core/int")}) + tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp51 := tmp50.FindInternedVar(lang.NewSymbol("list")) + if tmp51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) + } + tmp52 := tmp51.Get() + tmp53 := lang.Apply(tmp52, []any{v4}) + tmp54 := lang.Apply(tmp45, []any{tmp49, tmp53}) + tmp55 := lang.Apply(tmp42, []any{tmp54}) + tmp56 := lang.Apply(tmp39, []any{tmp55}) + tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp58 := tmp57.FindInternedVar(lang.NewSymbol("list")) + if tmp58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) + } + tmp59 := tmp58.Get() + tmp60 := lang.Apply(tmp59, []any{v5}) + tmp61 := lang.Apply(tmp28, []any{tmp32, tmp36, tmp56, tmp60}) + tmp62 := lang.Apply(tmp25, []any{tmp61}) + tmp63 := lang.Apply(tmp22, []any{tmp62}) + tmp64 := lang.Apply(tmp11, []any{tmp15, tmp19, tmp63}) + tmp65 := lang.Apply(tmp8, []any{tmp64}) + return tmp65 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("aset").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on Java arrays of\n reference types. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(3)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3922), lang.NewKeyword("end-line"), int(3922))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("aset").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on Java arrays of\n reference types. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(3)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3922), lang.NewKeyword("end-line"), int(3922))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 3: v4 := args[0] @@ -8526,8 +8561,8 @@ func init() { _ = v5 v6 := args[2] _ = v6 - v7 := lang.Apply(lang.SliceSet, []any{v4, v5, v6}) - _ = v7 + tmp7 := lang.Apply(lang.SliceSet, []any{v4, v5, v6}) + _ = tmp7 return v6 default: if len(args) < 3 { @@ -8539,41 +8574,42 @@ func init() { _ = v5 v6 := args[2] _ = v6 - v7 := lang.NewList(args[3:]...) - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("apply")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + var v7 any = lang.NewList(args[3:]...) + _ = v7 + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("apply")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("aset")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("aset")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) } - v13 := v12.Get() - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("aget")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + tmp13 := tmp12.Get() + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("aget")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{v4, v5}) - v18 := lang.Apply(v10, []any{v13, v17, v6, v7}) - return v18 + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{v4, v5}) + tmp18 := lang.Apply(tmp10, []any{tmp13, tmp17, v6, v7}) + return tmp18 } }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // aset-boolean { - v0 := lang.NewSymbol("aset-boolean").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of boolean. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3956), lang.NewKeyword("end-line"), int(3958))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("aset-boolean").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of boolean. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3956), lang.NewKeyword("end-line"), int(3958))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 3: v3 := args[0] @@ -8582,19 +8618,19 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("boolean")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{v5}) - v10, _ := lang.FieldOrMethod(nil, "setBoolean") - if reflect.TypeOf(v10).Kind() != reflect.Func { + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("boolean")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.Apply(tmp8, []any{v5}) + tmp10, _ := lang.FieldOrMethod(nil, "setBoolean") + if reflect.TypeOf(tmp10).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("setBoolean is not a function"))) } - v11 := lang.Apply(v10, []any{v3, v4, v9}) - _ = v11 + tmp11 := lang.Apply(tmp10, []any{v3, v4, tmp9}) + _ = tmp11 return v5 default: if len(args) < 3 { @@ -8606,41 +8642,42 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("apply")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("apply")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("aset-boolean")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("aset-boolean")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("aget")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("aget")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{v3, v4}) - v17 := lang.Apply(v9, []any{v12, v16, v5, v6}) - return v17 + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{v3, v4}) + tmp17 := lang.Apply(tmp9, []any{tmp12, tmp16, v5, v6}) + return tmp17 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // aset-byte { - v0 := lang.NewSymbol("aset-byte").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of byte. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3976), lang.NewKeyword("end-line"), int(3978))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("aset-byte").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of byte. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3976), lang.NewKeyword("end-line"), int(3978))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 3: v3 := args[0] @@ -8649,19 +8686,19 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("byte")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{v5}) - v10, _ := lang.FieldOrMethod(nil, "setByte") - if reflect.TypeOf(v10).Kind() != reflect.Func { + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("byte")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.Apply(tmp8, []any{v5}) + tmp10, _ := lang.FieldOrMethod(nil, "setByte") + if reflect.TypeOf(tmp10).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("setByte is not a function"))) } - v11 := lang.Apply(v10, []any{v3, v4, v9}) - _ = v11 + tmp11 := lang.Apply(tmp10, []any{v3, v4, tmp9}) + _ = tmp11 return v5 default: if len(args) < 3 { @@ -8673,41 +8710,42 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("apply")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("apply")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("aset-byte")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("aset-byte")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("aget")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("aget")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{v3, v4}) - v17 := lang.Apply(v9, []any{v12, v16, v5, v6}) - return v17 + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{v3, v4}) + tmp17 := lang.Apply(tmp9, []any{tmp12, tmp16, v5, v6}) + return tmp17 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // aset-char { - v0 := lang.NewSymbol("aset-char").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of char. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3981), lang.NewKeyword("end-line"), int(3983))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("aset-char").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of char. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3981), lang.NewKeyword("end-line"), int(3983))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 3: v3 := args[0] @@ -8716,19 +8754,19 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("char")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{v5}) - v10, _ := lang.FieldOrMethod(nil, "setChar") - if reflect.TypeOf(v10).Kind() != reflect.Func { + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("char")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.Apply(tmp8, []any{v5}) + tmp10, _ := lang.FieldOrMethod(nil, "setChar") + if reflect.TypeOf(tmp10).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("setChar is not a function"))) } - v11 := lang.Apply(v10, []any{v3, v4, v9}) - _ = v11 + tmp11 := lang.Apply(tmp10, []any{v3, v4, tmp9}) + _ = tmp11 return v5 default: if len(args) < 3 { @@ -8740,41 +8778,42 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("apply")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("apply")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("aset-char")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("aset-char")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("aget")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("aget")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{v3, v4}) - v17 := lang.Apply(v9, []any{v12, v16, v5, v6}) - return v17 + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{v3, v4}) + tmp17 := lang.Apply(tmp9, []any{tmp12, tmp16, v5, v6}) + return tmp17 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // aset-double { - v0 := lang.NewSymbol("aset-double").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of double. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3966), lang.NewKeyword("end-line"), int(3968))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("aset-double").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of double. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3966), lang.NewKeyword("end-line"), int(3968))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 3: v3 := args[0] @@ -8783,19 +8822,19 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("double")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{v5}) - v10, _ := lang.FieldOrMethod(nil, "setDouble") - if reflect.TypeOf(v10).Kind() != reflect.Func { + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("double")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.Apply(tmp8, []any{v5}) + tmp10, _ := lang.FieldOrMethod(nil, "setDouble") + if reflect.TypeOf(tmp10).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("setDouble is not a function"))) } - v11 := lang.Apply(v10, []any{v3, v4, v9}) - _ = v11 + tmp11 := lang.Apply(tmp10, []any{v3, v4, tmp9}) + _ = tmp11 return v5 default: if len(args) < 3 { @@ -8807,41 +8846,42 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("apply")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("apply")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("aset-double")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("aset-double")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("aget")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("aget")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{v3, v4}) - v17 := lang.Apply(v9, []any{v12, v16, v5, v6}) - return v17 + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{v3, v4}) + tmp17 := lang.Apply(tmp9, []any{tmp12, tmp16, v5, v6}) + return tmp17 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // aset-float { - v0 := lang.NewSymbol("aset-float").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of float. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3961), lang.NewKeyword("end-line"), int(3963))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("aset-float").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of float. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3961), lang.NewKeyword("end-line"), int(3963))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 3: v3 := args[0] @@ -8850,19 +8890,19 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("float")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{v5}) - v10, _ := lang.FieldOrMethod(nil, "setFloat") - if reflect.TypeOf(v10).Kind() != reflect.Func { + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("float")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.Apply(tmp8, []any{v5}) + tmp10, _ := lang.FieldOrMethod(nil, "setFloat") + if reflect.TypeOf(tmp10).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("setFloat is not a function"))) } - v11 := lang.Apply(v10, []any{v3, v4, v9}) - _ = v11 + tmp11 := lang.Apply(tmp10, []any{v3, v4, tmp9}) + _ = tmp11 return v5 default: if len(args) < 3 { @@ -8874,41 +8914,42 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("apply")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("apply")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("aset-float")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("aset-float")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("aget")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("aget")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{v3, v4}) - v17 := lang.Apply(v9, []any{v12, v16, v5, v6}) - return v17 + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{v3, v4}) + tmp17 := lang.Apply(tmp9, []any{tmp12, tmp16, v5, v6}) + return tmp17 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // aset-int { - v0 := lang.NewSymbol("aset-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of int. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3946), lang.NewKeyword("end-line"), int(3948))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("aset-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of int. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3946), lang.NewKeyword("end-line"), int(3948))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 3: v3 := args[0] @@ -8917,19 +8958,19 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("int")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{v5}) - v10, _ := lang.FieldOrMethod(nil, "setInt") - if reflect.TypeOf(v10).Kind() != reflect.Func { + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("int")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.Apply(tmp8, []any{v5}) + tmp10, _ := lang.FieldOrMethod(nil, "setInt") + if reflect.TypeOf(tmp10).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("setInt is not a function"))) } - v11 := lang.Apply(v10, []any{v3, v4, v9}) - _ = v11 + tmp11 := lang.Apply(tmp10, []any{v3, v4, tmp9}) + _ = tmp11 return v5 default: if len(args) < 3 { @@ -8941,41 +8982,42 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("apply")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("apply")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("aset-int")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("aset-int")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("aget")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("aget")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{v3, v4}) - v17 := lang.Apply(v9, []any{v12, v16, v5, v6}) - return v17 + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{v3, v4}) + tmp17 := lang.Apply(tmp9, []any{tmp12, tmp16, v5, v6}) + return tmp17 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // aset-long { - v0 := lang.NewSymbol("aset-long").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of long. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3951), lang.NewKeyword("end-line"), int(3953))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("aset-long").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of long. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3951), lang.NewKeyword("end-line"), int(3953))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 3: v3 := args[0] @@ -8984,19 +9026,19 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("long")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{v5}) - v10, _ := lang.FieldOrMethod(nil, "setLong") - if reflect.TypeOf(v10).Kind() != reflect.Func { + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("long")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.Apply(tmp8, []any{v5}) + tmp10, _ := lang.FieldOrMethod(nil, "setLong") + if reflect.TypeOf(tmp10).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("setLong is not a function"))) } - v11 := lang.Apply(v10, []any{v3, v4, v9}) - _ = v11 + tmp11 := lang.Apply(tmp10, []any{v3, v4, tmp9}) + _ = tmp11 return v5 default: if len(args) < 3 { @@ -9008,41 +9050,42 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("apply")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("apply")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("aset-long")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("aset-long")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("aget")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("aget")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{v3, v4}) - v17 := lang.Apply(v9, []any{v12, v16, v5, v6}) - return v17 + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{v3, v4}) + tmp17 := lang.Apply(tmp9, []any{tmp12, tmp16, v5, v6}) + return tmp17 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // aset-short { - v0 := lang.NewSymbol("aset-short").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of short. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3971), lang.NewKeyword("end-line"), int(3973))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("aset-short").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of short. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3971), lang.NewKeyword("end-line"), int(3973))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 3: v3 := args[0] @@ -9051,19 +9094,19 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("short")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{v5}) - v10, _ := lang.FieldOrMethod(nil, "setShort") - if reflect.TypeOf(v10).Kind() != reflect.Func { + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("short")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.Apply(tmp8, []any{v5}) + tmp10, _ := lang.FieldOrMethod(nil, "setShort") + if reflect.TypeOf(tmp10).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("setShort is not a function"))) } - v11 := lang.Apply(v10, []any{v3, v4, v9}) - _ = v11 + tmp11 := lang.Apply(tmp10, []any{v3, v4, tmp9}) + _ = tmp11 return v5 default: if len(args) < 3 { @@ -9075,41 +9118,42 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("apply")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("apply")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("aset-short")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("aset-short")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("aget")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("aget")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{v3, v4}) - v17 := lang.Apply(v9, []any{v12, v16, v5, v6}) - return v17 + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{v3, v4}) + tmp17 := lang.Apply(tmp9, []any{tmp12, tmp16, v5, v6}) + return tmp17 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // assert { - v0 := lang.NewSymbol("assert").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("message"))), lang.NewKeyword("doc"), "Evaluates expression x and throws an AssertionError with optional\n message if x does not evaluate to logical true.\n\n Assertion checks are omitted from compiled code if '*assert*' is\n false.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4837), lang.NewKeyword("end-line"), int(4837))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("assert").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("message"))), lang.NewKeyword("doc"), "Evaluates expression x and throws an AssertionError with optional\n message if x does not evaluate to logical true.\n\n Assertion checks are omitted from compiled code if '*assert*' is\n false.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4837), lang.NewKeyword("end-line"), int(4837))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 3: v3 := args[0] @@ -9118,208 +9162,207 @@ func init() { _ = v4 v5 := args[2] _ = v5 - var v6 any - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("*assert*")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - if lang.IsTruthy(v9) { - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("seq")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("concat")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("list")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{lang.NewSymbol("glojure.core/when-not")}) - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("list")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.Apply(v22, []any{v5}) - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("list")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("seq")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("concat")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) - } - v32 := v31.Get() - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("list")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - v36 := lang.Apply(v35, []any{lang.NewSymbol("throw")}) - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("list")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("seq")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) - } - v42 := v41.Get() - v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v44 := v43.FindInternedVar(lang.NewSymbol("concat")) - if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) - } - v45 := v44.Get() - v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v47 := v46.FindInternedVar(lang.NewSymbol("list")) - if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) - } - v48 := v47.Get() - v49 := lang.Apply(v48, []any{lang.NewSymbol("new")}) - v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v51 := v50.FindInternedVar(lang.NewSymbol("list")) - if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) - } - v52 := v51.Get() - v53 := lang.Apply(v52, []any{lang.NewSymbol("glojure.core/AssertionError")}) - v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v55 := v54.FindInternedVar(lang.NewSymbol("list")) - if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) - } - v56 := v55.Get() - v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v58 := v57.FindInternedVar(lang.NewSymbol("seq")) - if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) - } - v59 := v58.Get() - v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v61 := v60.FindInternedVar(lang.NewSymbol("concat")) - if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) - } - v62 := v61.Get() - v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v64 := v63.FindInternedVar(lang.NewSymbol("list")) - if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) - } - v65 := v64.Get() - v66 := lang.Apply(v65, []any{lang.NewSymbol("glojure.core/str")}) - v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v68 := v67.FindInternedVar(lang.NewSymbol("list")) - if v68.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) - } - v69 := v68.Get() - v70 := lang.Apply(v69, []any{"Assert failed: "}) - v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v72 := v71.FindInternedVar(lang.NewSymbol("list")) - if v72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) - } - v73 := v72.Get() - v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v75 := v74.FindInternedVar(lang.NewSymbol("seq")) - if v75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) - } - v76 := v75.Get() - v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v78 := v77.FindInternedVar(lang.NewSymbol("concat")) - if v78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) - } - v79 := v78.Get() - v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v81 := v80.FindInternedVar(lang.NewSymbol("list")) - if v81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) - } - v82 := v81.Get() - v83 := lang.Apply(v82, []any{lang.NewSymbol("glojure.core/pr-str")}) - v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v85 := v84.FindInternedVar(lang.NewSymbol("list")) - if v85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) - } - v86 := v85.Get() - v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v88 := v87.FindInternedVar(lang.NewSymbol("seq")) - if v88.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) - } - v89 := v88.Get() - v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v91 := v90.FindInternedVar(lang.NewSymbol("concat")) - if v91.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) - } - v92 := v91.Get() - v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v94 := v93.FindInternedVar(lang.NewSymbol("list")) - if v94.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) - } - v95 := v94.Get() - v96 := lang.Apply(v95, []any{lang.NewSymbol("quote")}) - v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v98 := v97.FindInternedVar(lang.NewSymbol("list")) - if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) - } - v99 := v98.Get() - v100 := lang.Apply(v99, []any{v5}) - v101 := lang.Apply(v92, []any{v96, v100}) - v102 := lang.Apply(v89, []any{v101}) - v103 := lang.Apply(v86, []any{v102}) - v104 := lang.Apply(v79, []any{v83, v103}) - v105 := lang.Apply(v76, []any{v104}) - v106 := lang.Apply(v73, []any{v105}) - v107 := lang.Apply(v62, []any{v66, v70, v106}) - v108 := lang.Apply(v59, []any{v107}) - v109 := lang.Apply(v56, []any{v108}) - v110 := lang.Apply(v45, []any{v49, v53, v109}) - v111 := lang.Apply(v42, []any{v110}) - v112 := lang.Apply(v39, []any{v111}) - v113 := lang.Apply(v32, []any{v36, v112}) - v114 := lang.Apply(v29, []any{v113}) - v115 := lang.Apply(v26, []any{v114}) - v116 := lang.Apply(v15, []any{v19, v23, v115}) - v117 := lang.Apply(v12, []any{v116}) - v6 = v117 + var tmp6 any + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("*assert*")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + if lang.IsTruthy(tmp9) { + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("seq")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("concat")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("list")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{lang.NewSymbol("glojure.core/when-not")}) + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("list")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.Apply(tmp22, []any{v5}) + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("list")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("seq")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("concat")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) + } + tmp32 := tmp31.Get() + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("list")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) + } + tmp35 := tmp34.Get() + tmp36 := lang.Apply(tmp35, []any{lang.NewSymbol("throw")}) + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("list")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("seq")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) + } + tmp42 := tmp41.Get() + tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp44 := tmp43.FindInternedVar(lang.NewSymbol("concat")) + if tmp44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) + } + tmp45 := tmp44.Get() + tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp47 := tmp46.FindInternedVar(lang.NewSymbol("list")) + if tmp47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) + } + tmp48 := tmp47.Get() + tmp49 := lang.Apply(tmp48, []any{lang.NewSymbol("new")}) + tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp51 := tmp50.FindInternedVar(lang.NewSymbol("list")) + if tmp51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) + } + tmp52 := tmp51.Get() + tmp53 := lang.Apply(tmp52, []any{lang.NewSymbol("glojure.core/AssertionError")}) + tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp55 := tmp54.FindInternedVar(lang.NewSymbol("list")) + if tmp55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) + } + tmp56 := tmp55.Get() + tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp58 := tmp57.FindInternedVar(lang.NewSymbol("seq")) + if tmp58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) + } + tmp59 := tmp58.Get() + tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp61 := tmp60.FindInternedVar(lang.NewSymbol("concat")) + if tmp61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) + } + tmp62 := tmp61.Get() + tmp63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp64 := tmp63.FindInternedVar(lang.NewSymbol("list")) + if tmp64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp64))) + } + tmp65 := tmp64.Get() + tmp66 := lang.Apply(tmp65, []any{lang.NewSymbol("glojure.core/str")}) + tmp67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp68 := tmp67.FindInternedVar(lang.NewSymbol("list")) + if tmp68.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp68))) + } + tmp69 := tmp68.Get() + tmp70 := lang.Apply(tmp69, []any{"Assert failed: "}) + tmp71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp72 := tmp71.FindInternedVar(lang.NewSymbol("list")) + if tmp72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp72))) + } + tmp73 := tmp72.Get() + tmp74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp75 := tmp74.FindInternedVar(lang.NewSymbol("seq")) + if tmp75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp75))) + } + tmp76 := tmp75.Get() + tmp77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp78 := tmp77.FindInternedVar(lang.NewSymbol("concat")) + if tmp78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp78))) + } + tmp79 := tmp78.Get() + tmp80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp81 := tmp80.FindInternedVar(lang.NewSymbol("list")) + if tmp81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp81))) + } + tmp82 := tmp81.Get() + tmp83 := lang.Apply(tmp82, []any{lang.NewSymbol("glojure.core/pr-str")}) + tmp84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp85 := tmp84.FindInternedVar(lang.NewSymbol("list")) + if tmp85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp85))) + } + tmp86 := tmp85.Get() + tmp87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp88 := tmp87.FindInternedVar(lang.NewSymbol("seq")) + if tmp88.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp88))) + } + tmp89 := tmp88.Get() + tmp90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp91 := tmp90.FindInternedVar(lang.NewSymbol("concat")) + if tmp91.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp91))) + } + tmp92 := tmp91.Get() + tmp93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp94 := tmp93.FindInternedVar(lang.NewSymbol("list")) + if tmp94.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp94))) + } + tmp95 := tmp94.Get() + tmp96 := lang.Apply(tmp95, []any{lang.NewSymbol("quote")}) + tmp97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp98 := tmp97.FindInternedVar(lang.NewSymbol("list")) + if tmp98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp98))) + } + tmp99 := tmp98.Get() + tmp100 := lang.Apply(tmp99, []any{v5}) + tmp101 := lang.Apply(tmp92, []any{tmp96, tmp100}) + tmp102 := lang.Apply(tmp89, []any{tmp101}) + tmp103 := lang.Apply(tmp86, []any{tmp102}) + tmp104 := lang.Apply(tmp79, []any{tmp83, tmp103}) + tmp105 := lang.Apply(tmp76, []any{tmp104}) + tmp106 := lang.Apply(tmp73, []any{tmp105}) + tmp107 := lang.Apply(tmp62, []any{tmp66, tmp70, tmp106}) + tmp108 := lang.Apply(tmp59, []any{tmp107}) + tmp109 := lang.Apply(tmp56, []any{tmp108}) + tmp110 := lang.Apply(tmp45, []any{tmp49, tmp53, tmp109}) + tmp111 := lang.Apply(tmp42, []any{tmp110}) + tmp112 := lang.Apply(tmp39, []any{tmp111}) + tmp113 := lang.Apply(tmp32, []any{tmp36, tmp112}) + tmp114 := lang.Apply(tmp29, []any{tmp113}) + tmp115 := lang.Apply(tmp26, []any{tmp114}) + tmp116 := lang.Apply(tmp15, []any{tmp19, tmp23, tmp115}) + tmp117 := lang.Apply(tmp12, []any{tmp116}) + tmp6 = tmp117 } else { - v6 = nil } - return v6 + return tmp6 case 4: v3 := args[0] _ = v3 @@ -9329,237 +9372,236 @@ func init() { _ = v5 v6 := args[3] _ = v6 - var v7 any - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("*assert*")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - if lang.IsTruthy(v10) { - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("seq")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("concat")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("list")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.Apply(v19, []any{lang.NewSymbol("glojure.core/when-not")}) - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("list")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.Apply(v23, []any{v5}) - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("list")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("seq")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("concat")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("list")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) - } - v36 := v35.Get() - v37 := lang.Apply(v36, []any{lang.NewSymbol("throw")}) - v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v39 := v38.FindInternedVar(lang.NewSymbol("list")) - if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) - } - v40 := v39.Get() - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("seq")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) - } - v43 := v42.Get() - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("concat")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) - } - v46 := v45.Get() - v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v48 := v47.FindInternedVar(lang.NewSymbol("list")) - if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) - } - v49 := v48.Get() - v50 := lang.Apply(v49, []any{lang.NewSymbol("new")}) - v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v52 := v51.FindInternedVar(lang.NewSymbol("list")) - if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) - } - v53 := v52.Get() - v54 := lang.Apply(v53, []any{lang.NewSymbol("glojure.core/AssertionError")}) - v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v56 := v55.FindInternedVar(lang.NewSymbol("list")) - if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) - } - v57 := v56.Get() - v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v59 := v58.FindInternedVar(lang.NewSymbol("seq")) - if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) - } - v60 := v59.Get() - v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v62 := v61.FindInternedVar(lang.NewSymbol("concat")) - if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) - } - v63 := v62.Get() - v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v65 := v64.FindInternedVar(lang.NewSymbol("list")) - if v65.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) - } - v66 := v65.Get() - v67 := lang.Apply(v66, []any{lang.NewSymbol("glojure.core/str")}) - v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v69 := v68.FindInternedVar(lang.NewSymbol("list")) - if v69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) - } - v70 := v69.Get() - v71 := lang.Apply(v70, []any{"Assert failed: "}) - v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v73 := v72.FindInternedVar(lang.NewSymbol("list")) - if v73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) - } - v74 := v73.Get() - v75 := lang.Apply(v74, []any{v6}) - v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v77 := v76.FindInternedVar(lang.NewSymbol("list")) - if v77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) - } - v78 := v77.Get() - v79 := lang.Apply(v78, []any{"\n"}) - v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v81 := v80.FindInternedVar(lang.NewSymbol("list")) - if v81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) - } - v82 := v81.Get() - v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v84 := v83.FindInternedVar(lang.NewSymbol("seq")) - if v84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) - } - v85 := v84.Get() - v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v87 := v86.FindInternedVar(lang.NewSymbol("concat")) - if v87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) - } - v88 := v87.Get() - v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v90 := v89.FindInternedVar(lang.NewSymbol("list")) - if v90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) - } - v91 := v90.Get() - v92 := lang.Apply(v91, []any{lang.NewSymbol("glojure.core/pr-str")}) - v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v94 := v93.FindInternedVar(lang.NewSymbol("list")) - if v94.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) - } - v95 := v94.Get() - v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v97 := v96.FindInternedVar(lang.NewSymbol("seq")) - if v97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) - } - v98 := v97.Get() - v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v100 := v99.FindInternedVar(lang.NewSymbol("concat")) - if v100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) - } - v101 := v100.Get() - v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v103 := v102.FindInternedVar(lang.NewSymbol("list")) - if v103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) - } - v104 := v103.Get() - v105 := lang.Apply(v104, []any{lang.NewSymbol("quote")}) - v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v107 := v106.FindInternedVar(lang.NewSymbol("list")) - if v107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) - } - v108 := v107.Get() - v109 := lang.Apply(v108, []any{v5}) - v110 := lang.Apply(v101, []any{v105, v109}) - v111 := lang.Apply(v98, []any{v110}) - v112 := lang.Apply(v95, []any{v111}) - v113 := lang.Apply(v88, []any{v92, v112}) - v114 := lang.Apply(v85, []any{v113}) - v115 := lang.Apply(v82, []any{v114}) - v116 := lang.Apply(v63, []any{v67, v71, v75, v79, v115}) - v117 := lang.Apply(v60, []any{v116}) - v118 := lang.Apply(v57, []any{v117}) - v119 := lang.Apply(v46, []any{v50, v54, v118}) - v120 := lang.Apply(v43, []any{v119}) - v121 := lang.Apply(v40, []any{v120}) - v122 := lang.Apply(v33, []any{v37, v121}) - v123 := lang.Apply(v30, []any{v122}) - v124 := lang.Apply(v27, []any{v123}) - v125 := lang.Apply(v16, []any{v20, v24, v124}) - v126 := lang.Apply(v13, []any{v125}) - v7 = v126 + var tmp7 any + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("*assert*")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + if lang.IsTruthy(tmp10) { + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("seq")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("concat")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("list")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.Apply(tmp19, []any{lang.NewSymbol("glojure.core/when-not")}) + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("list")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.Apply(tmp23, []any{v5}) + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("list")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("seq")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("concat")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("list")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.Apply(tmp36, []any{lang.NewSymbol("throw")}) + tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp39 := tmp38.FindInternedVar(lang.NewSymbol("list")) + if tmp39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) + } + tmp40 := tmp39.Get() + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("seq")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("concat")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) + } + tmp46 := tmp45.Get() + tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp48 := tmp47.FindInternedVar(lang.NewSymbol("list")) + if tmp48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) + } + tmp49 := tmp48.Get() + tmp50 := lang.Apply(tmp49, []any{lang.NewSymbol("new")}) + tmp51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp52 := tmp51.FindInternedVar(lang.NewSymbol("list")) + if tmp52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp52))) + } + tmp53 := tmp52.Get() + tmp54 := lang.Apply(tmp53, []any{lang.NewSymbol("glojure.core/AssertionError")}) + tmp55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp56 := tmp55.FindInternedVar(lang.NewSymbol("list")) + if tmp56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp56))) + } + tmp57 := tmp56.Get() + tmp58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp59 := tmp58.FindInternedVar(lang.NewSymbol("seq")) + if tmp59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp59))) + } + tmp60 := tmp59.Get() + tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp62 := tmp61.FindInternedVar(lang.NewSymbol("concat")) + if tmp62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) + } + tmp63 := tmp62.Get() + tmp64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp65 := tmp64.FindInternedVar(lang.NewSymbol("list")) + if tmp65.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp65))) + } + tmp66 := tmp65.Get() + tmp67 := lang.Apply(tmp66, []any{lang.NewSymbol("glojure.core/str")}) + tmp68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp69 := tmp68.FindInternedVar(lang.NewSymbol("list")) + if tmp69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp69))) + } + tmp70 := tmp69.Get() + tmp71 := lang.Apply(tmp70, []any{"Assert failed: "}) + tmp72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp73 := tmp72.FindInternedVar(lang.NewSymbol("list")) + if tmp73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp73))) + } + tmp74 := tmp73.Get() + tmp75 := lang.Apply(tmp74, []any{v6}) + tmp76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp77 := tmp76.FindInternedVar(lang.NewSymbol("list")) + if tmp77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp77))) + } + tmp78 := tmp77.Get() + tmp79 := lang.Apply(tmp78, []any{"\n"}) + tmp80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp81 := tmp80.FindInternedVar(lang.NewSymbol("list")) + if tmp81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp81))) + } + tmp82 := tmp81.Get() + tmp83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp84 := tmp83.FindInternedVar(lang.NewSymbol("seq")) + if tmp84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp84))) + } + tmp85 := tmp84.Get() + tmp86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp87 := tmp86.FindInternedVar(lang.NewSymbol("concat")) + if tmp87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp87))) + } + tmp88 := tmp87.Get() + tmp89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp90 := tmp89.FindInternedVar(lang.NewSymbol("list")) + if tmp90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp90))) + } + tmp91 := tmp90.Get() + tmp92 := lang.Apply(tmp91, []any{lang.NewSymbol("glojure.core/pr-str")}) + tmp93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp94 := tmp93.FindInternedVar(lang.NewSymbol("list")) + if tmp94.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp94))) + } + tmp95 := tmp94.Get() + tmp96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp97 := tmp96.FindInternedVar(lang.NewSymbol("seq")) + if tmp97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp97))) + } + tmp98 := tmp97.Get() + tmp99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp100 := tmp99.FindInternedVar(lang.NewSymbol("concat")) + if tmp100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp100))) + } + tmp101 := tmp100.Get() + tmp102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp103 := tmp102.FindInternedVar(lang.NewSymbol("list")) + if tmp103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp103))) + } + tmp104 := tmp103.Get() + tmp105 := lang.Apply(tmp104, []any{lang.NewSymbol("quote")}) + tmp106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp107 := tmp106.FindInternedVar(lang.NewSymbol("list")) + if tmp107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp107))) + } + tmp108 := tmp107.Get() + tmp109 := lang.Apply(tmp108, []any{v5}) + tmp110 := lang.Apply(tmp101, []any{tmp105, tmp109}) + tmp111 := lang.Apply(tmp98, []any{tmp110}) + tmp112 := lang.Apply(tmp95, []any{tmp111}) + tmp113 := lang.Apply(tmp88, []any{tmp92, tmp112}) + tmp114 := lang.Apply(tmp85, []any{tmp113}) + tmp115 := lang.Apply(tmp82, []any{tmp114}) + tmp116 := lang.Apply(tmp63, []any{tmp67, tmp71, tmp75, tmp79, tmp115}) + tmp117 := lang.Apply(tmp60, []any{tmp116}) + tmp118 := lang.Apply(tmp57, []any{tmp117}) + tmp119 := lang.Apply(tmp46, []any{tmp50, tmp54, tmp118}) + tmp120 := lang.Apply(tmp43, []any{tmp119}) + tmp121 := lang.Apply(tmp40, []any{tmp120}) + tmp122 := lang.Apply(tmp33, []any{tmp37, tmp121}) + tmp123 := lang.Apply(tmp30, []any{tmp122}) + tmp124 := lang.Apply(tmp27, []any{tmp123}) + tmp125 := lang.Apply(tmp16, []any{tmp20, tmp24, tmp124}) + tmp126 := lang.Apply(tmp13, []any{tmp125}) + tmp7 = tmp126 } else { - v7 = nil } - return v7 + return tmp7 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // assert-args { - v0 := lang.NewSymbol("assert-args").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("pairs"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(38), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1830), lang.NewKeyword("end-line"), int(1830), lang.NewKeyword("private"), true)).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("assert-args").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("pairs"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(38), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1830), lang.NewKeyword("end-line"), int(1830), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 2 { @@ -9569,518 +9611,517 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.NewList(args[2:]...) - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("seq")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("concat")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("list")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.Apply(v14, []any{lang.NewSymbol("do")}) - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("list")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("seq")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("concat")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("list")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.Apply(v27, []any{lang.NewSymbol("glojure.core/when-not")}) - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("list")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("first")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{v5}) - v36 := lang.Apply(v31, []any{v35}) - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("list")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("seq")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) - } - v42 := v41.Get() - v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v44 := v43.FindInternedVar(lang.NewSymbol("concat")) - if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) - } - v45 := v44.Get() - v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v47 := v46.FindInternedVar(lang.NewSymbol("list")) - if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) - } - v48 := v47.Get() - v49 := lang.Apply(v48, []any{lang.NewSymbol("throw")}) - v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v51 := v50.FindInternedVar(lang.NewSymbol("list")) - if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) - } - v52 := v51.Get() - v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v54 := v53.FindInternedVar(lang.NewSymbol("seq")) - if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) - } - v55 := v54.Get() - v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v57 := v56.FindInternedVar(lang.NewSymbol("concat")) - if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) - } - v58 := v57.Get() - v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v60 := v59.FindInternedVar(lang.NewSymbol("list")) - if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) - } - v61 := v60.Get() - v62 := lang.Apply(v61, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewIllegalArgumentError")}) - v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v64 := v63.FindInternedVar(lang.NewSymbol("list")) - if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) - } - v65 := v64.Get() - v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v67 := v66.FindInternedVar(lang.NewSymbol("seq")) - if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) - } - v68 := v67.Get() - v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v70 := v69.FindInternedVar(lang.NewSymbol("concat")) - if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) - } - v71 := v70.Get() - v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v73 := v72.FindInternedVar(lang.NewSymbol("list")) - if v73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) - } - v74 := v73.Get() - v75 := lang.Apply(v74, []any{lang.NewSymbol("glojure.core/str")}) - v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v77 := v76.FindInternedVar(lang.NewSymbol("list")) - if v77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) - } - v78 := v77.Get() - v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v80 := v79.FindInternedVar(lang.NewSymbol("seq")) - if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) - } - v81 := v80.Get() - v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v83 := v82.FindInternedVar(lang.NewSymbol("concat")) - if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) - } - v84 := v83.Get() - v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v86 := v85.FindInternedVar(lang.NewSymbol("list")) - if v86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) - } - v87 := v86.Get() - v88 := lang.Apply(v87, []any{lang.NewSymbol("glojure.core/first")}) - v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v90 := v89.FindInternedVar(lang.NewSymbol("list")) - if v90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) - } - v91 := v90.Get() - v92 := lang.Apply(v91, []any{lang.NewSymbol("&form")}) - v93 := lang.Apply(v84, []any{v88, v92}) - v94 := lang.Apply(v81, []any{v93}) - v95 := lang.Apply(v78, []any{v94}) - v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v97 := v96.FindInternedVar(lang.NewSymbol("list")) - if v97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) - } - v98 := v97.Get() - v99 := lang.Apply(v98, []any{" requires "}) - v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v101 := v100.FindInternedVar(lang.NewSymbol("list")) - if v101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) - } - v102 := v101.Get() - v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v104 := v103.FindInternedVar(lang.NewSymbol("second")) - if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) - } - v105 := v104.Get() - v106 := lang.Apply(v105, []any{v5}) - v107 := lang.Apply(v102, []any{v106}) - v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v109 := v108.FindInternedVar(lang.NewSymbol("list")) - if v109.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) - } - v110 := v109.Get() - v111 := lang.Apply(v110, []any{" in "}) - v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v113 := v112.FindInternedVar(lang.NewSymbol("list")) - if v113.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) - } - v114 := v113.Get() - v115 := lang.Apply(v114, []any{lang.NewSymbol("*ns*")}) - v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v117 := v116.FindInternedVar(lang.NewSymbol("list")) - if v117.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) - } - v118 := v117.Get() - v119 := lang.Apply(v118, []any{":"}) - v120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v121 := v120.FindInternedVar(lang.NewSymbol("list")) - if v121.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v121))) - } - v122 := v121.Get() - v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v124 := v123.FindInternedVar(lang.NewSymbol("seq")) - if v124.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) - } - v125 := v124.Get() - v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v127 := v126.FindInternedVar(lang.NewSymbol("concat")) - if v127.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) - } - v128 := v127.Get() - v129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v130 := v129.FindInternedVar(lang.NewSymbol("list")) - if v130.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v130))) - } - v131 := v130.Get() - v132 := lang.Apply(v131, []any{lang.NewKeyword("line")}) - v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v134 := v133.FindInternedVar(lang.NewSymbol("list")) - if v134.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) - } - v135 := v134.Get() - v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v137 := v136.FindInternedVar(lang.NewSymbol("seq")) - if v137.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) - } - v138 := v137.Get() - v139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v140 := v139.FindInternedVar(lang.NewSymbol("concat")) - if v140.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v140))) - } - v141 := v140.Get() - v142 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v143 := v142.FindInternedVar(lang.NewSymbol("list")) - if v143.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v143))) - } - v144 := v143.Get() - v145 := lang.Apply(v144, []any{lang.NewSymbol("glojure.core/meta")}) - v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v147 := v146.FindInternedVar(lang.NewSymbol("list")) - if v147.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) - } - v148 := v147.Get() - v149 := lang.Apply(v148, []any{lang.NewSymbol("&form")}) - v150 := lang.Apply(v141, []any{v145, v149}) - v151 := lang.Apply(v138, []any{v150}) - v152 := lang.Apply(v135, []any{v151}) - v153 := lang.Apply(v128, []any{v132, v152}) - v154 := lang.Apply(v125, []any{v153}) - v155 := lang.Apply(v122, []any{v154}) - v156 := lang.Apply(v71, []any{v75, v95, v99, v107, v111, v115, v119, v155}) - v157 := lang.Apply(v68, []any{v156}) - v158 := lang.Apply(v65, []any{v157}) - v159 := lang.Apply(v58, []any{v62, v158}) - v160 := lang.Apply(v55, []any{v159}) - v161 := lang.Apply(v52, []any{v160}) - v162 := lang.Apply(v45, []any{v49, v161}) - v163 := lang.Apply(v42, []any{v162}) - v164 := lang.Apply(v39, []any{v163}) - v165 := lang.Apply(v24, []any{v28, v36, v164}) - v166 := lang.Apply(v21, []any{v165}) - v167 := lang.Apply(v18, []any{v166}) - v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v169 := v168.FindInternedVar(lang.NewSymbol("list")) - if v169.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) - } - v170 := v169.Get() - var v171 any + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("seq")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("concat")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("list")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("do")}) + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("list")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("seq")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("concat")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("list")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.Apply(tmp27, []any{lang.NewSymbol("glojure.core/when-not")}) + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("list")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("first")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.Apply(tmp34, []any{v5}) + tmp36 := lang.Apply(tmp31, []any{tmp35}) + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("list")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("seq")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) + } + tmp42 := tmp41.Get() + tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp44 := tmp43.FindInternedVar(lang.NewSymbol("concat")) + if tmp44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) + } + tmp45 := tmp44.Get() + tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp47 := tmp46.FindInternedVar(lang.NewSymbol("list")) + if tmp47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) + } + tmp48 := tmp47.Get() + tmp49 := lang.Apply(tmp48, []any{lang.NewSymbol("throw")}) + tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp51 := tmp50.FindInternedVar(lang.NewSymbol("list")) + if tmp51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) + } + tmp52 := tmp51.Get() + tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp54 := tmp53.FindInternedVar(lang.NewSymbol("seq")) + if tmp54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) + } + tmp55 := tmp54.Get() + tmp56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp57 := tmp56.FindInternedVar(lang.NewSymbol("concat")) + if tmp57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp57))) + } + tmp58 := tmp57.Get() + tmp59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp60 := tmp59.FindInternedVar(lang.NewSymbol("list")) + if tmp60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp60))) + } + tmp61 := tmp60.Get() + tmp62 := lang.Apply(tmp61, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewIllegalArgumentError")}) + tmp63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp64 := tmp63.FindInternedVar(lang.NewSymbol("list")) + if tmp64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp64))) + } + tmp65 := tmp64.Get() + tmp66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp67 := tmp66.FindInternedVar(lang.NewSymbol("seq")) + if tmp67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp67))) + } + tmp68 := tmp67.Get() + tmp69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp70 := tmp69.FindInternedVar(lang.NewSymbol("concat")) + if tmp70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp70))) + } + tmp71 := tmp70.Get() + tmp72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp73 := tmp72.FindInternedVar(lang.NewSymbol("list")) + if tmp73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp73))) + } + tmp74 := tmp73.Get() + tmp75 := lang.Apply(tmp74, []any{lang.NewSymbol("glojure.core/str")}) + tmp76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp77 := tmp76.FindInternedVar(lang.NewSymbol("list")) + if tmp77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp77))) + } + tmp78 := tmp77.Get() + tmp79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp80 := tmp79.FindInternedVar(lang.NewSymbol("seq")) + if tmp80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp80))) + } + tmp81 := tmp80.Get() + tmp82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp83 := tmp82.FindInternedVar(lang.NewSymbol("concat")) + if tmp83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp83))) + } + tmp84 := tmp83.Get() + tmp85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp86 := tmp85.FindInternedVar(lang.NewSymbol("list")) + if tmp86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp86))) + } + tmp87 := tmp86.Get() + tmp88 := lang.Apply(tmp87, []any{lang.NewSymbol("glojure.core/first")}) + tmp89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp90 := tmp89.FindInternedVar(lang.NewSymbol("list")) + if tmp90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp90))) + } + tmp91 := tmp90.Get() + tmp92 := lang.Apply(tmp91, []any{lang.NewSymbol("&form")}) + tmp93 := lang.Apply(tmp84, []any{tmp88, tmp92}) + tmp94 := lang.Apply(tmp81, []any{tmp93}) + tmp95 := lang.Apply(tmp78, []any{tmp94}) + tmp96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp97 := tmp96.FindInternedVar(lang.NewSymbol("list")) + if tmp97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp97))) + } + tmp98 := tmp97.Get() + tmp99 := lang.Apply(tmp98, []any{" requires "}) + tmp100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp101 := tmp100.FindInternedVar(lang.NewSymbol("list")) + if tmp101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp101))) + } + tmp102 := tmp101.Get() + tmp103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp104 := tmp103.FindInternedVar(lang.NewSymbol("second")) + if tmp104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp104))) + } + tmp105 := tmp104.Get() + tmp106 := lang.Apply(tmp105, []any{v5}) + tmp107 := lang.Apply(tmp102, []any{tmp106}) + tmp108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp109 := tmp108.FindInternedVar(lang.NewSymbol("list")) + if tmp109.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp109))) + } + tmp110 := tmp109.Get() + tmp111 := lang.Apply(tmp110, []any{" in "}) + tmp112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp113 := tmp112.FindInternedVar(lang.NewSymbol("list")) + if tmp113.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp113))) + } + tmp114 := tmp113.Get() + tmp115 := lang.Apply(tmp114, []any{lang.NewSymbol("*ns*")}) + tmp116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp117 := tmp116.FindInternedVar(lang.NewSymbol("list")) + if tmp117.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp117))) + } + tmp118 := tmp117.Get() + tmp119 := lang.Apply(tmp118, []any{":"}) + tmp120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp121 := tmp120.FindInternedVar(lang.NewSymbol("list")) + if tmp121.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp121))) + } + tmp122 := tmp121.Get() + tmp123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp124 := tmp123.FindInternedVar(lang.NewSymbol("seq")) + if tmp124.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp124))) + } + tmp125 := tmp124.Get() + tmp126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp127 := tmp126.FindInternedVar(lang.NewSymbol("concat")) + if tmp127.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp127))) + } + tmp128 := tmp127.Get() + tmp129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp130 := tmp129.FindInternedVar(lang.NewSymbol("list")) + if tmp130.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp130))) + } + tmp131 := tmp130.Get() + tmp132 := lang.Apply(tmp131, []any{lang.NewKeyword("line")}) + tmp133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp134 := tmp133.FindInternedVar(lang.NewSymbol("list")) + if tmp134.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp134))) + } + tmp135 := tmp134.Get() + tmp136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp137 := tmp136.FindInternedVar(lang.NewSymbol("seq")) + if tmp137.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp137))) + } + tmp138 := tmp137.Get() + tmp139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp140 := tmp139.FindInternedVar(lang.NewSymbol("concat")) + if tmp140.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp140))) + } + tmp141 := tmp140.Get() + tmp142 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp143 := tmp142.FindInternedVar(lang.NewSymbol("list")) + if tmp143.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp143))) + } + tmp144 := tmp143.Get() + tmp145 := lang.Apply(tmp144, []any{lang.NewSymbol("glojure.core/meta")}) + tmp146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp147 := tmp146.FindInternedVar(lang.NewSymbol("list")) + if tmp147.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp147))) + } + tmp148 := tmp147.Get() + tmp149 := lang.Apply(tmp148, []any{lang.NewSymbol("&form")}) + tmp150 := lang.Apply(tmp141, []any{tmp145, tmp149}) + tmp151 := lang.Apply(tmp138, []any{tmp150}) + tmp152 := lang.Apply(tmp135, []any{tmp151}) + tmp153 := lang.Apply(tmp128, []any{tmp132, tmp152}) + tmp154 := lang.Apply(tmp125, []any{tmp153}) + tmp155 := lang.Apply(tmp122, []any{tmp154}) + tmp156 := lang.Apply(tmp71, []any{tmp75, tmp95, tmp99, tmp107, tmp111, tmp115, tmp119, tmp155}) + tmp157 := lang.Apply(tmp68, []any{tmp156}) + tmp158 := lang.Apply(tmp65, []any{tmp157}) + tmp159 := lang.Apply(tmp58, []any{tmp62, tmp158}) + tmp160 := lang.Apply(tmp55, []any{tmp159}) + tmp161 := lang.Apply(tmp52, []any{tmp160}) + tmp162 := lang.Apply(tmp45, []any{tmp49, tmp161}) + tmp163 := lang.Apply(tmp42, []any{tmp162}) + tmp164 := lang.Apply(tmp39, []any{tmp163}) + tmp165 := lang.Apply(tmp24, []any{tmp28, tmp36, tmp164}) + tmp166 := lang.Apply(tmp21, []any{tmp165}) + tmp167 := lang.Apply(tmp18, []any{tmp166}) + tmp168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp169 := tmp168.FindInternedVar(lang.NewSymbol("list")) + if tmp169.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp169))) + } + tmp170 := tmp169.Get() + var tmp171 any { // let // let binding "more" - v172 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v173 := v172.FindInternedVar(lang.NewSymbol("nnext")) - if v173.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v173))) - } - v174 := v173.Get() - v175 := lang.Apply(v174, []any{v5}) - var v176 any = v175 + tmp172 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp173 := tmp172.FindInternedVar(lang.NewSymbol("nnext")) + if tmp173.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp173))) + } + tmp174 := tmp173.Get() + tmp175 := lang.Apply(tmp174, []any{v5}) + var v176 any = tmp175 _ = v176 - var v177 any + var tmp177 any if lang.IsTruthy(v176) { - v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v179 := v178.FindInternedVar(lang.NewSymbol("list*")) - if v179.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) - } - v180 := v179.Get() - v181 := lang.Apply(v180, []any{lang.NewSymbol("glojure.core/assert-args"), v176}) - v177 = v181 + tmp178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp179 := tmp178.FindInternedVar(lang.NewSymbol("list*")) + if tmp179.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp179))) + } + tmp180 := tmp179.Get() + tmp181 := lang.Apply(tmp180, []any{lang.NewSymbol("glojure.core/assert-args"), v176}) + tmp177 = tmp181 } else { - v177 = nil } - v171 = v177 + tmp171 = tmp177 } // end let - v172 := lang.Apply(v170, []any{v171}) - v173 := lang.Apply(v11, []any{v15, v167, v172}) - v174 := lang.Apply(v8, []any{v173}) - return v174 + tmp172 := lang.Apply(tmp170, []any{tmp171}) + tmp173 := lang.Apply(tmp11, []any{tmp15, tmp167, tmp172}) + tmp174 := lang.Apply(tmp8, []any{tmp173}) + return tmp174 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // assert-valid-fdecl { - v0 := lang.NewSymbol("assert-valid-fdecl").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fdecl"))), lang.NewKeyword("doc"), "A good fdecl looks like (([a] ...) ([a b] ...)) near the end of defn.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(42), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(7502), lang.NewKeyword("end-line"), int(7502), lang.NewKeyword("private"), true, lang.NewKeyword("dynamic"), true)).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("assert-valid-fdecl").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fdecl"))), lang.NewKeyword("doc"), "A good fdecl looks like (([a] ...) ([a b] ...)) near the end of defn.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(42), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(7502), lang.NewKeyword("end-line"), int(7502), lang.NewKeyword("private"), true, lang.NewKeyword("dynamic"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("empty?")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v3}) - if lang.IsTruthy(v8) { - v9 := lang.Apply(lang.NewIllegalArgumentError, []any{"Parameter declaration missing"}) - panic(v9) + var tmp4 any + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("empty?")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v3}) + if lang.IsTruthy(tmp8) { + tmp9 := lang.Apply(lang.NewIllegalArgumentError, []any{"Parameter declaration missing"}) + panic(tmp9) } else { - v4 = nil } - _ = v4 - var v10 any + _ = tmp4 + var tmp10 any { // let // let binding "argdecls" - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("map")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - var v14 lang.FnFunc - v14 = lang.NewFnFunc(func(args ...any) any { + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("map")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v15 := args[0] _ = v15 - var v16 any - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("seq?")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.Apply(v19, []any{v15}) - if lang.IsTruthy(v20) { - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("first")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.Apply(v23, []any{v15}) - v16 = v24 + var tmp16 any + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq?")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.Apply(tmp19, []any{v15}) + if lang.IsTruthy(tmp20) { + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("first")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.Apply(tmp23, []any{v15}) + tmp16 = tmp24 } else { - var v25 any - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("seq?")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) - } - v28 := v27.Get() - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("first")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.Apply(v31, []any{v3}) - v33 := lang.Apply(v28, []any{v32}) - if lang.IsTruthy(v33) { - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("str")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) - } - v36 := v35.Get() - v37 := lang.Apply(v36, []any{"Invalid signature \"", v15, "\" should be a list"}) - v25 = v37 + var tmp25 any + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("seq?")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) + } + tmp28 := tmp27.Get() + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("first")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.Apply(tmp31, []any{v3}) + tmp33 := lang.Apply(tmp28, []any{tmp32}) + if lang.IsTruthy(tmp33) { + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("str")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.Apply(tmp36, []any{"Invalid signature \"", v15, "\" should be a list"}) + tmp25 = tmp37 } else { - v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v39 := v38.FindInternedVar(lang.NewSymbol("str")) - if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp39 := tmp38.FindInternedVar(lang.NewSymbol("str")) + if tmp39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) } - v40 := v39.Get() - v41 := lang.Apply(v40, []any{"Parameter declaration \"", v15, "\" should be a vector"}) - v25 = v41 + tmp40 := tmp39.Get() + tmp41 := lang.Apply(tmp40, []any{"Parameter declaration \"", v15, "\" should be a vector"}) + tmp25 = tmp41 } - v42 := lang.Apply(lang.NewIllegalArgumentError, []any{v25}) - panic(v42) + tmp42 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp25}) + panic(tmp42) } - return v16 + return tmp16 }) - v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7508), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7517), lang.NewKeyword("end-column"), int(59)) - v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) + tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7508), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7517), lang.NewKeyword("end-column"), int(59)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) if err != nil { panic(err) } - v17 := lang.Apply(v13, []any{v16, v3}) - var v18 any = v17 + tmp17 := lang.Apply(tmp13, []any{tmp16, v3}) + var v18 any = tmp17 _ = v18 // let binding "bad-args" - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("seq")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("remove")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - var v25 lang.FnFunc - v25 = lang.NewFnFunc(func(args ...any) any { + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("seq")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("remove")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + var tmp25 lang.FnFunc + tmp25 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v26 := args[0] _ = v26 - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("vector?")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{v26}) - return v30 + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("vector?")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{v26}) + return tmp30 }) - v26 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7519), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(7519), lang.NewKeyword("end-column"), int(42)) - v27, err := lang.WithMeta(v25, v26.(lang.IPersistentMap)) + tmp26 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7519), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(7519), lang.NewKeyword("end-column"), int(42)) + tmp27, err := lang.WithMeta(tmp25, tmp26.(lang.IPersistentMap)) if err != nil { panic(err) } - v28 := lang.Apply(v24, []any{v27, v18}) - v29 := lang.Apply(v21, []any{v28}) - var v30 any = v29 + tmp28 := lang.Apply(tmp24, []any{tmp27, v18}) + tmp29 := lang.Apply(tmp21, []any{tmp28}) + var v30 any = tmp29 _ = v30 - var v31 any + var tmp31 any if lang.IsTruthy(v30) { - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("str")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v36 := v35.FindInternedVar(lang.NewSymbol("first")) - if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) - } - v37 := v36.Get() - v38 := lang.Apply(v37, []any{v30}) - v39 := lang.Apply(v34, []any{"Parameter declaration \"", v38, "\" should be a vector"}) - v40 := lang.Apply(lang.NewIllegalArgumentError, []any{v39}) - panic(v40) + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("str")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp36 := tmp35.FindInternedVar(lang.NewSymbol("first")) + if tmp36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) + } + tmp37 := tmp36.Get() + tmp38 := lang.Apply(tmp37, []any{v30}) + tmp39 := lang.Apply(tmp34, []any{"Parameter declaration \"", tmp38, "\" should be a vector"}) + tmp40 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp39}) + panic(tmp40) } else { - v31 = nil } - v10 = v31 + tmp10 = tmp31 } // end let - return v10 + return tmp10 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // assoc { - v0 := lang.NewSymbol("assoc").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"), lang.NewSymbol("val"), lang.NewSymbol("&"), lang.NewSymbol("kvs"))), lang.NewKeyword("doc"), "assoc[iate]. When applied to a map, returns a new map of the\n same (hashed/sorted) type, that contains the mapping of key(s) to\n val(s). When applied to a vector, returns a new vector that\n contains val at index. Note - index must be <= (count vector).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(181), lang.NewKeyword("end-line"), int(188))).(*lang.Symbol) - var v2 lang.FnFunc + tmp0 := lang.NewSymbol("assoc").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"), lang.NewSymbol("val"), lang.NewSymbol("&"), lang.NewSymbol("kvs"))), lang.NewKeyword("doc"), "assoc[iate]. When applied to a map, returns a new map of the\n same (hashed/sorted) type, that contains the mapping of key(s) to\n val(s). When applied to a vector, returns a new vector that\n contains val at index. Note - index must be <= (count vector).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(181), lang.NewKeyword("end-line"), int(188))).(*lang.Symbol) + var tmp2 lang.FnFunc { // function assoc - v2 = lang.NewFnFunc(func(args ...any) any { + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 3: v4 := args[0] @@ -10089,8 +10130,8 @@ func init() { _ = v5 v6 := args[2] _ = v6 - v7 := lang.Apply(lang.Assoc, []any{v4, v5, v6}) - return v7 + tmp7 := lang.Apply(lang.Assoc, []any{v4, v5, v6}) + return tmp7 default: if len(args) < 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -10101,82 +10142,83 @@ func init() { _ = v5 v6 := args[2] _ = v6 - v7 := lang.NewList(args[3:]...) + var v7 any = lang.NewList(args[3:]...) + _ = v7 recur_loop_24: - var v8 any + var tmp8 any { // let // let binding "ret" - v9 := lang.Apply(lang.Assoc, []any{v4, v5, v6}) - var v10 any = v9 + tmp9 := lang.Apply(lang.Assoc, []any{v4, v5, v6}) + var v10 any = tmp9 _ = v10 - var v11 any + var tmp11 any if lang.IsTruthy(v7) { - var v12 any - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("next")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{v7}) - if lang.IsTruthy(v16) { - var v17 any = v10 - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("first")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + var tmp12 any + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("next")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{v7}) + if lang.IsTruthy(tmp16) { + var tmp17 any = v10 + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("first")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{v7}) - var v18 any = v22 - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("second")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, []any{v7}) + var tmp18 any = tmp22 + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("second")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) } - v26 := v25.Get() - v27 := lang.Apply(v26, []any{v7}) - var v23 any = v27 - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("nnext")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + tmp26 := tmp25.Get() + tmp27 := lang.Apply(tmp26, []any{v7}) + var tmp23 any = tmp27 + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("nnext")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) } - v31 := v30.Get() - v32 := lang.Apply(v31, []any{v7}) - var v28 any = v32 - v4 = v17 - v5 = v18 - v6 = v23 - v7 = v28 + tmp31 := tmp30.Get() + tmp32 := lang.Apply(tmp31, []any{v7}) + var tmp28 any = tmp32 + v4 = tmp17 + v5 = tmp18 + v6 = tmp23 + v7 = tmp28 goto recur_loop_24 } else { - v33 := lang.Apply(lang.NewIllegalArgumentError, []any{"assoc expects even number of arguments after map/vector, found odd number"}) - panic(v33) + tmp33 := lang.Apply(lang.NewIllegalArgumentError, []any{"assoc expects even number of arguments after map/vector, found odd number"}) + panic(tmp33) } - v11 = v12 + tmp11 = tmp12 } else { - v11 = v10 + tmp11 = v10 } - v8 = v11 + tmp8 = tmp11 } // end let - return v8 + return tmp8 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(189), lang.NewKeyword("column"), int(2), lang.NewKeyword("end-line"), int(198), lang.NewKeyword("end-column"), int(15))).(lang.FnFunc) - v3 := v2 + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(189), lang.NewKeyword("column"), int(2), lang.NewKeyword("end-line"), int(198), lang.NewKeyword("end-column"), int(15))).(lang.FnFunc) + v3 = tmp2 _ = v3 } - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // assoc! { - v0 := lang.NewSymbol("assoc!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("key"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("key"), lang.NewSymbol("val"), lang.NewSymbol("&"), lang.NewSymbol("kvs"))), lang.NewKeyword("doc"), "When applied to a transient map, adds mapping of key(s) to\n val(s). When applied to a transient vector, sets the val at index.\n Note - index must be <= (count vector). Returns coll.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3369), lang.NewKeyword("end-line"), int(3369))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("assoc!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("key"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("key"), lang.NewSymbol("val"), lang.NewSymbol("&"), lang.NewSymbol("kvs"))), lang.NewKeyword("doc"), "When applied to a transient map, adds mapping of key(s) to\n val(s). When applied to a transient vector, sets the val at index.\n Note - index must be <= (count vector). Returns coll.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3369), lang.NewKeyword("end-line"), int(3369))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 3: v3 := args[0] @@ -10185,12 +10227,12 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6, _ := lang.FieldOrMethod(v3, "Assoc") - if reflect.TypeOf(v6).Kind() != reflect.Func { + tmp6, _ := lang.FieldOrMethod(v3, "Assoc") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Assoc is not a function"))) } - v7 := lang.Apply(v6, []any{v4, v5}) - return v7 + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 default: if len(args) < 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -10201,69 +10243,70 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) + var v6 any = lang.NewList(args[3:]...) + _ = v6 recur_loop_609: - var v7 any + var tmp7 any { // let // let binding "ret" - v8, _ := lang.FieldOrMethod(v3, "Assoc") - if reflect.TypeOf(v8).Kind() != reflect.Func { + tmp8, _ := lang.FieldOrMethod(v3, "Assoc") + if reflect.TypeOf(tmp8).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Assoc is not a function"))) } - v9 := lang.Apply(v8, []any{v4, v5}) - var v10 any = v9 + tmp9 := lang.Apply(tmp8, []any{v4, v5}) + var v10 any = tmp9 _ = v10 - var v11 any + var tmp11 any if lang.IsTruthy(v6) { - var v12 any = v10 - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("first")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{v6}) - var v13 any = v17 - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("second")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{v6}) - var v18 any = v22 - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("nnext")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.Apply(v26, []any{v6}) - var v23 any = v27 - v3 = v12 - v4 = v13 - v5 = v18 - v6 = v23 + var tmp12 any = v10 + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("first")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{v6}) + var tmp13 any = tmp17 + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("second")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, []any{v6}) + var tmp18 any = tmp22 + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("nnext")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.Apply(tmp26, []any{v6}) + var tmp23 any = tmp27 + v3 = tmp12 + v4 = tmp13 + v5 = tmp18 + v6 = tmp23 goto recur_loop_609 } else { - v11 = v10 + tmp11 = v10 } - v7 = v11 + tmp7 = tmp11 } // end let - return v7 + return tmp7 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // assoc-in { - v0 := lang.NewSymbol("assoc-in").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("&"), lang.NewSymbol("ks")), lang.NewSymbol("v"))), lang.NewKeyword("doc"), "Associates a value in a nested associative structure, where ks is a\n sequence of keys and v is the new value and returns a new nested structure.\n If any levels do not exist, hash-maps will be created.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6147), lang.NewKeyword("end-line"), int(6147))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("assoc-in").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("&"), lang.NewSymbol("ks")), lang.NewSymbol("v"))), lang.NewKeyword("doc"), "Associates a value in a nested associative structure, where ks is a\n sequence of keys and v is the new value and returns a new nested structure.\n If any levels do not exist, hash-maps will be created.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6147), lang.NewKeyword("end-line"), int(6147))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -10273,40 +10316,40 @@ func init() { _ = v4 v5 := args[2] _ = v5 - var v6 any + var tmp6 any { // let // let binding "vec__138" var v7 any = v4 _ = v7 // let binding "seq__139" - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("seq")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v7}) - var v12 any = v11 + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("seq")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v7}) + var v12 any = tmp11 _ = v12 // let binding "first__140" - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("first")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{v12}) - var v17 any = v16 + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("first")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{v12}) + var v17 any = tmp16 _ = v17 // let binding "seq__139" - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("next")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.Apply(v20, []any{v12}) - var v22 any = v21 + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("next")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.Apply(tmp20, []any{v12}) + var v22 any = tmp21 _ = v22 // let binding "k" var v23 any = v17 @@ -10314,185 +10357,186 @@ func init() { // let binding "ks" var v24 any = v22 _ = v24 - var v25 any + var tmp25 any if lang.IsTruthy(v24) { - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("assoc")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) - } - v28 := v27.Get() - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("assoc-in")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("get")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{v3, v23}) - v36 := lang.Apply(v31, []any{v35, v24, v5}) - v37 := lang.Apply(v28, []any{v3, v23, v36}) - v25 = v37 + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("assoc")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) + } + tmp28 := tmp27.Get() + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("assoc-in")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("get")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.Apply(tmp34, []any{v3, v23}) + tmp36 := lang.Apply(tmp31, []any{tmp35, v24, v5}) + tmp37 := lang.Apply(tmp28, []any{v3, v23, tmp36}) + tmp25 = tmp37 } else { - v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v39 := v38.FindInternedVar(lang.NewSymbol("assoc")) - if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp39 := tmp38.FindInternedVar(lang.NewSymbol("assoc")) + if tmp39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) } - v40 := v39.Get() - v41 := lang.Apply(v40, []any{v3, v23, v5}) - v25 = v41 + tmp40 := tmp39.Get() + tmp41 := lang.Apply(tmp40, []any{v3, v23, v5}) + tmp25 = tmp41 } - v6 = v25 + tmp6 = tmp25 } // end let - return v6 + return tmp6 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // associative? { - v0 := lang.NewSymbol("associative?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements Associative", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6223), lang.NewKeyword("end-line"), int(6223))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("associative?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements Associative", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6223), lang.NewKeyword("end-line"), int(6223))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) } - v6 := v5.Get() - v7 := lang.Apply(v6, []any{nil, v3}) - return v7 + tmp6 := tmp5.Get() + tmp7 := lang.Apply(tmp6, []any{nil, v3}) + return tmp7 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // atom { - v0 := lang.NewSymbol("atom").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Creates and returns an Atom with an initial value of x and zero or\n more options (in any order):\n\n :meta metadata-map\n\n :validator validate-fn\n\n If metadata-map is supplied, it will become the metadata on the\n atom. validate-fn must be nil or a side-effect-free fn of one\n argument, which will be passed the intended new state on any state\n change. If the new state is unacceptable, the validate-fn should\n return false or throw an exception.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2325), lang.NewKeyword("end-line"), int(2325))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("atom").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Creates and returns an Atom with an initial value of x and zero or\n more options (in any order):\n\n :meta metadata-map\n\n :validator validate-fn\n\n If metadata-map is supplied, it will become the metadata on the\n atom. validate-fn must be nil or a side-effect-free fn of one\n argument, which will be passed the intended new state on any state\n change. If the new state is unacceptable, the validate-fn should\n return false or throw an exception.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2325), lang.NewKeyword("end-line"), int(2325))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - v4 := lang.Apply(lang.NewAtom, []any{v3}) - return v4 + tmp4 := lang.Apply(lang.NewAtom, []any{v3}) + return tmp4 default: if len(args) < 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.NewList(args[1:]...) - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("setup-reference")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + var v4 any = lang.NewList(args[1:]...) + _ = v4 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("setup-reference")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("atom")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("atom")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v3}) - v12 := lang.Apply(v7, []any{v11, v4}) - return v12 + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v3}) + tmp12 := lang.Apply(tmp7, []any{tmp11, v4}) + return tmp12 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // await { - v0 := lang.NewSymbol("await").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("agents"))), lang.NewKeyword("doc"), "Blocks the current thread (indefinitely!) until all actions\n dispatched thus far, from this thread or agent, to the agent(s) have\n occurred. Will block on failed agents. Will never return if\n a failed agent is restarted with :clear-actions true or shutdown-agents was called.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3267), lang.NewKeyword("end-line"), int(3267))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("await").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("agents"))), lang.NewKeyword("doc"), "Blocks the current thread (indefinitely!) until all actions\n dispatched thus far, from this thread or agent, to the agent(s) have\n occurred. Will block on failed agents. Will never return if\n a failed agent is restarted with :clear-actions true or shutdown-agents was called.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3267), lang.NewKeyword("end-line"), int(3267))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v3 := lang.NewList(args[0:]...) - var v4 any - v5 := lang.Apply(nil, nil) - if lang.IsTruthy(v5) { + var v3 any = lang.NewList(args[0:]...) + _ = v3 + var tmp4 any + tmp5 := lang.Apply(nil, nil) + if lang.IsTruthy(tmp5) { panic("unimplemented: new with non-constant class type") } else { - var v6 any - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("*agent*")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - if lang.IsTruthy(v9) { - v10 := lang.Apply(errors5.New, []any{"Can't await in agent action"}) - panic(v10) + var tmp6 any + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("*agent*")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + if lang.IsTruthy(tmp9) { + tmp10 := lang.Apply(errors5.New, []any{"Can't await in agent action"}) + panic(tmp10) } else { - v6 = nil } - _ = v6 - var v11 any + _ = tmp6 + var tmp11 any { // let // let binding "latch" var v12 any = "unimplemented: new with non-constant class type" _ = v12 // let binding "count-down" - var v13 lang.FnFunc - v13 = lang.NewFnFunc(func(args ...any) any { + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v14 := args[0] _ = v14 - v15, _ := lang.FieldOrMethod(v12, "countDown") - if reflect.TypeOf(v15).Kind() != reflect.Func { + tmp15, _ := lang.FieldOrMethod(v12, "countDown") + if reflect.TypeOf(tmp15).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("countDown is not a function"))) } - v16 := lang.Apply(v15, []any{}) - _ = v16 + tmp16 := lang.Apply(tmp15, []any{}) + _ = tmp16 return v14 }) - v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3279), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(3279), lang.NewKeyword("end-column"), int(61)) - v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) + tmp14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3279), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(3279), lang.NewKeyword("end-column"), int(61)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) if err != nil { panic(err) } - var v16 any = v15 + var v16 any = tmp15 _ = v16 - var v17 any + var tmp17 any { // let // let binding "seq_1" - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("seq")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.Apply(v20, []any{v3}) - var v22 any = v21 + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("seq")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.Apply(tmp20, []any{v3}) + var v22 any = tmp21 _ = v22 // let binding "chunk_2" var v23 any = nil @@ -10504,209 +10548,208 @@ func init() { var v25 any = int64(0) _ = v25 for { - var v26 any - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("<")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + var tmp26 any + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("<")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{v25, v24}) - if lang.IsTruthy(v30) { - var v31 any + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{v25, v24}) + if lang.IsTruthy(tmp30) { + var tmp31 any { // let // let binding "agent" - v32, _ := lang.FieldOrMethod(v23, "nth") - if reflect.TypeOf(v32).Kind() != reflect.Func { + tmp32, _ := lang.FieldOrMethod(v23, "nth") + if reflect.TypeOf(tmp32).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) } - v33 := lang.Apply(v32, []any{v25}) - var v34 any = v33 + tmp33 := lang.Apply(tmp32, []any{v25}) + var v34 any = tmp33 _ = v34 - v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v36 := v35.FindInternedVar(lang.NewSymbol("send")) - if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp36 := tmp35.FindInternedVar(lang.NewSymbol("send")) + if tmp36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) } - v37 := v36.Get() - v38 := lang.Apply(v37, []any{v34, v16}) - _ = v38 - var v39 any = v22 - var v40 any = v23 - var v41 any = v24 - v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v44 := v43.FindInternedVar(lang.NewSymbol("unchecked-inc")) - if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) + tmp37 := tmp36.Get() + tmp38 := lang.Apply(tmp37, []any{v34, v16}) + _ = tmp38 + var tmp39 any = v22 + var tmp40 any = v23 + var tmp41 any = v24 + tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp44 := tmp43.FindInternedVar(lang.NewSymbol("unchecked-inc")) + if tmp44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) } - v45 := v44.Get() - v46 := lang.Apply(v45, []any{v25}) - var v42 any = v46 - v22 = v39 - v23 = v40 - v24 = v41 - v25 = v42 + tmp45 := tmp44.Get() + tmp46 := lang.Apply(tmp45, []any{v25}) + var tmp42 any = tmp46 + v22 = tmp39 + v23 = tmp40 + v24 = tmp41 + v25 = tmp42 continue } // end let - v26 = v31 + tmp26 = tmp31 } else { - var v32 any + var tmp32 any { // let // let binding "temp__0__auto__" - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("seq")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("seq")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) } - v35 := v34.Get() - v36 := lang.Apply(v35, []any{v22}) - var v37 any = v36 + tmp35 := tmp34.Get() + tmp36 := lang.Apply(tmp35, []any{v22}) + var v37 any = tmp36 _ = v37 - var v38 any + var tmp38 any if lang.IsTruthy(v37) { - var v39 any + var tmp39 any { // let // let binding "seq_1" var v40 any = v37 _ = v40 - var v41 any - v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v43 := v42.FindInternedVar(lang.NewSymbol("chunked-seq?")) - if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) + var tmp41 any + tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp43 := tmp42.FindInternedVar(lang.NewSymbol("chunked-seq?")) + if tmp43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) } - v44 := v43.Get() - v45 := lang.Apply(v44, []any{v40}) - if lang.IsTruthy(v45) { - var v46 any + tmp44 := tmp43.Get() + tmp45 := lang.Apply(tmp44, []any{v40}) + if lang.IsTruthy(tmp45) { + var tmp46 any { // let // let binding "c__0__auto__" - v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v48 := v47.FindInternedVar(lang.NewSymbol("chunk-first")) - if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) + tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp48 := tmp47.FindInternedVar(lang.NewSymbol("chunk-first")) + if tmp48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) } - v49 := v48.Get() - v50 := lang.Apply(v49, []any{v40}) - var v51 any = v50 + tmp49 := tmp48.Get() + tmp50 := lang.Apply(tmp49, []any{v40}) + var v51 any = tmp50 _ = v51 - v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v54 := v53.FindInternedVar(lang.NewSymbol("chunk-rest")) - if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) + tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp54 := tmp53.FindInternedVar(lang.NewSymbol("chunk-rest")) + if tmp54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) } - v55 := v54.Get() - v56 := lang.Apply(v55, []any{v40}) - var v52 any = v56 - var v57 any = v51 - v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v60 := v59.FindInternedVar(lang.NewSymbol("int")) - if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) + tmp55 := tmp54.Get() + tmp56 := lang.Apply(tmp55, []any{v40}) + var tmp52 any = tmp56 + var tmp57 any = v51 + tmp59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp60 := tmp59.FindInternedVar(lang.NewSymbol("int")) + if tmp60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp60))) } - v61 := v60.Get() - v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v63 := v62.FindInternedVar(lang.NewSymbol("count")) - if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) + tmp61 := tmp60.Get() + tmp62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp63 := tmp62.FindInternedVar(lang.NewSymbol("count")) + if tmp63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp63))) } - v64 := v63.Get() - v65 := lang.Apply(v64, []any{v51}) - v66 := lang.Apply(v61, []any{v65}) - var v58 any = v66 - v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v69 := v68.FindInternedVar(lang.NewSymbol("int")) - if v69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) + tmp64 := tmp63.Get() + tmp65 := lang.Apply(tmp64, []any{v51}) + tmp66 := lang.Apply(tmp61, []any{tmp65}) + var tmp58 any = tmp66 + tmp68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp69 := tmp68.FindInternedVar(lang.NewSymbol("int")) + if tmp69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp69))) } - v70 := v69.Get() - v71 := lang.Apply(v70, []any{int64(0)}) - var v67 any = v71 - v22 = v52 - v23 = v57 - v24 = v58 - v25 = v67 + tmp70 := tmp69.Get() + tmp71 := lang.Apply(tmp70, []any{int64(0)}) + var tmp67 any = tmp71 + v22 = tmp52 + v23 = tmp57 + v24 = tmp58 + v25 = tmp67 continue } // end let - v41 = v46 + tmp41 = tmp46 } else { - var v47 any + var tmp47 any { // let // let binding "agent" - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("first")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("first")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v40}) - var v52 any = v51 + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v40}) + var v52 any = tmp51 _ = v52 - v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v54 := v53.FindInternedVar(lang.NewSymbol("send")) - if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) + tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp54 := tmp53.FindInternedVar(lang.NewSymbol("send")) + if tmp54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) } - v55 := v54.Get() - v56 := lang.Apply(v55, []any{v52, v16}) - _ = v56 - v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v59 := v58.FindInternedVar(lang.NewSymbol("next")) - if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) + tmp55 := tmp54.Get() + tmp56 := lang.Apply(tmp55, []any{v52, v16}) + _ = tmp56 + tmp58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp59 := tmp58.FindInternedVar(lang.NewSymbol("next")) + if tmp59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp59))) } - v60 := v59.Get() - v61 := lang.Apply(v60, []any{v40}) - var v57 any = v61 - var v62 any = nil - var v63 any = int64(0) - var v64 any = int64(0) - v22 = v57 - v23 = v62 - v24 = v63 - v25 = v64 + tmp60 := tmp59.Get() + tmp61 := lang.Apply(tmp60, []any{v40}) + var tmp57 any = tmp61 + var tmp62 any = nil + var tmp63 any = int64(0) + var tmp64 any = int64(0) + v22 = tmp57 + v23 = tmp62 + v24 = tmp63 + v25 = tmp64 continue } // end let - v41 = v47 + tmp41 = tmp47 } - v39 = v41 + tmp39 = tmp41 } // end let - v38 = v39 + tmp38 = tmp39 } else { - v38 = nil } - v32 = v38 + tmp32 = tmp38 } // end let - v26 = v32 + tmp26 = tmp32 } - v17 = v26 + tmp17 = tmp26 break } } // end let - _ = v17 - v18, _ := lang.FieldOrMethod(v12, "await") - if reflect.TypeOf(v18).Kind() != reflect.Func { + _ = tmp17 + tmp18, _ := lang.FieldOrMethod(v12, "await") + if reflect.TypeOf(tmp18).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) } - v19 := lang.Apply(v18, []any{}) - v11 = v19 + tmp19 := lang.Apply(tmp18, []any{}) + tmp11 = tmp19 } // end let - v4 = v11 + tmp4 = tmp11 } - return v4 + return tmp4 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // await-for { - v0 := lang.NewSymbol("await-for").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("timeout-ms"), lang.NewSymbol("&"), lang.NewSymbol("agents"))), lang.NewKeyword("doc"), "Blocks the current thread until all actions dispatched thus\n far (from this thread or agent) to the agents have occurred, or the\n timeout (in milliseconds) has elapsed. Returns logical false if\n returning due to timeout, logical true otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3289), lang.NewKeyword("end-line"), int(3289))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("await-for").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("timeout-ms"), lang.NewSymbol("&"), lang.NewSymbol("agents"))), lang.NewKeyword("doc"), "Blocks the current thread until all actions dispatched thus\n far (from this thread or agent) to the agents have occurred, or the\n timeout (in milliseconds) has elapsed. Returns logical false if\n returning due to timeout, logical true otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3289), lang.NewKeyword("end-line"), int(3289))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 1 { @@ -10714,65 +10757,65 @@ func init() { } v3 := args[0] _ = v3 - v4 := lang.NewList(args[1:]...) - var v5 any - v6 := lang.Apply(nil, nil) - if lang.IsTruthy(v6) { + var v4 any = lang.NewList(args[1:]...) + _ = v4 + var tmp5 any + tmp6 := lang.Apply(nil, nil) + if lang.IsTruthy(tmp6) { panic("unimplemented: new with non-constant class type") } else { - var v7 any - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("*agent*")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - if lang.IsTruthy(v10) { - v11 := lang.Apply(errors5.New, []any{"Can't await in agent action"}) - panic(v11) + var tmp7 any + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("*agent*")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + if lang.IsTruthy(tmp10) { + tmp11 := lang.Apply(errors5.New, []any{"Can't await in agent action"}) + panic(tmp11) } else { - v7 = nil } - _ = v7 - var v12 any + _ = tmp7 + var tmp12 any { // let // let binding "latch" var v13 any = "unimplemented: new with non-constant class type" _ = v13 // let binding "count-down" - var v14 lang.FnFunc - v14 = lang.NewFnFunc(func(args ...any) any { + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v15 := args[0] _ = v15 - v16, _ := lang.FieldOrMethod(v13, "countDown") - if reflect.TypeOf(v16).Kind() != reflect.Func { + tmp16, _ := lang.FieldOrMethod(v13, "countDown") + if reflect.TypeOf(tmp16).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("countDown is not a function"))) } - v17 := lang.Apply(v16, []any{}) - _ = v17 + tmp17 := lang.Apply(tmp16, []any{}) + _ = tmp17 return v15 }) - v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3301), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(3301), lang.NewKeyword("end-column"), int(62)) - v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) + tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3301), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(3301), lang.NewKeyword("end-column"), int(62)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) if err != nil { panic(err) } - var v17 any = v16 + var v17 any = tmp16 _ = v17 - var v18 any + var tmp18 any { // let // let binding "seq_5" - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("seq")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{v4}) - var v23 any = v22 + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("seq")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, []any{v4}) + var v23 any = tmp22 _ = v23 // let binding "chunk_6" var v24 any = nil @@ -10784,813 +10827,813 @@ func init() { var v26 any = int64(0) _ = v26 for { - var v27 any - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("<")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + var tmp27 any + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("<")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) } - v30 := v29.Get() - v31 := lang.Apply(v30, []any{v26, v25}) - if lang.IsTruthy(v31) { - var v32 any + tmp30 := tmp29.Get() + tmp31 := lang.Apply(tmp30, []any{v26, v25}) + if lang.IsTruthy(tmp31) { + var tmp32 any { // let // let binding "agent" - v33, _ := lang.FieldOrMethod(v24, "nth") - if reflect.TypeOf(v33).Kind() != reflect.Func { + tmp33, _ := lang.FieldOrMethod(v24, "nth") + if reflect.TypeOf(tmp33).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) } - v34 := lang.Apply(v33, []any{v26}) - var v35 any = v34 + tmp34 := lang.Apply(tmp33, []any{v26}) + var v35 any = tmp34 _ = v35 - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("send")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("send")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) } - v38 := v37.Get() - v39 := lang.Apply(v38, []any{v35, v17}) - _ = v39 - var v40 any = v23 - var v41 any = v24 - var v42 any = v25 - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("unchecked-inc")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{v35, v17}) + _ = tmp39 + var tmp40 any = v23 + var tmp41 any = v24 + var tmp42 any = v25 + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("unchecked-inc")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) } - v46 := v45.Get() - v47 := lang.Apply(v46, []any{v26}) - var v43 any = v47 - v23 = v40 - v24 = v41 - v25 = v42 - v26 = v43 + tmp46 := tmp45.Get() + tmp47 := lang.Apply(tmp46, []any{v26}) + var tmp43 any = tmp47 + v23 = tmp40 + v24 = tmp41 + v25 = tmp42 + v26 = tmp43 continue } // end let - v27 = v32 + tmp27 = tmp32 } else { - var v33 any + var tmp33 any { // let // let binding "temp__0__auto__" - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("seq")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) } - v36 := v35.Get() - v37 := lang.Apply(v36, []any{v23}) - var v38 any = v37 + tmp36 := tmp35.Get() + tmp37 := lang.Apply(tmp36, []any{v23}) + var v38 any = tmp37 _ = v38 - var v39 any + var tmp39 any if lang.IsTruthy(v38) { - var v40 any + var tmp40 any { // let // let binding "seq_5" var v41 any = v38 _ = v41 - var v42 any - v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v44 := v43.FindInternedVar(lang.NewSymbol("chunked-seq?")) - if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) + var tmp42 any + tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp44 := tmp43.FindInternedVar(lang.NewSymbol("chunked-seq?")) + if tmp44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) } - v45 := v44.Get() - v46 := lang.Apply(v45, []any{v41}) - if lang.IsTruthy(v46) { - var v47 any + tmp45 := tmp44.Get() + tmp46 := lang.Apply(tmp45, []any{v41}) + if lang.IsTruthy(tmp46) { + var tmp47 any { // let // let binding "c__0__auto__" - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("chunk-first")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("chunk-first")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v41}) - var v52 any = v51 + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v41}) + var v52 any = tmp51 _ = v52 - v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v55 := v54.FindInternedVar(lang.NewSymbol("chunk-rest")) - if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) + tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp55 := tmp54.FindInternedVar(lang.NewSymbol("chunk-rest")) + if tmp55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) } - v56 := v55.Get() - v57 := lang.Apply(v56, []any{v41}) - var v53 any = v57 - var v58 any = v52 - v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v61 := v60.FindInternedVar(lang.NewSymbol("int")) - if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) + tmp56 := tmp55.Get() + tmp57 := lang.Apply(tmp56, []any{v41}) + var tmp53 any = tmp57 + var tmp58 any = v52 + tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp61 := tmp60.FindInternedVar(lang.NewSymbol("int")) + if tmp61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) } - v62 := v61.Get() - v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v64 := v63.FindInternedVar(lang.NewSymbol("count")) - if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) + tmp62 := tmp61.Get() + tmp63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp64 := tmp63.FindInternedVar(lang.NewSymbol("count")) + if tmp64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp64))) } - v65 := v64.Get() - v66 := lang.Apply(v65, []any{v52}) - v67 := lang.Apply(v62, []any{v66}) - var v59 any = v67 - v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v70 := v69.FindInternedVar(lang.NewSymbol("int")) - if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) + tmp65 := tmp64.Get() + tmp66 := lang.Apply(tmp65, []any{v52}) + tmp67 := lang.Apply(tmp62, []any{tmp66}) + var tmp59 any = tmp67 + tmp69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp70 := tmp69.FindInternedVar(lang.NewSymbol("int")) + if tmp70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp70))) } - v71 := v70.Get() - v72 := lang.Apply(v71, []any{int64(0)}) - var v68 any = v72 - v23 = v53 - v24 = v58 - v25 = v59 - v26 = v68 + tmp71 := tmp70.Get() + tmp72 := lang.Apply(tmp71, []any{int64(0)}) + var tmp68 any = tmp72 + v23 = tmp53 + v24 = tmp58 + v25 = tmp59 + v26 = tmp68 continue } // end let - v42 = v47 + tmp42 = tmp47 } else { - var v48 any + var tmp48 any { // let // let binding "agent" - v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v50 := v49.FindInternedVar(lang.NewSymbol("first")) - if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) + tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp50 := tmp49.FindInternedVar(lang.NewSymbol("first")) + if tmp50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) } - v51 := v50.Get() - v52 := lang.Apply(v51, []any{v41}) - var v53 any = v52 + tmp51 := tmp50.Get() + tmp52 := lang.Apply(tmp51, []any{v41}) + var v53 any = tmp52 _ = v53 - v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v55 := v54.FindInternedVar(lang.NewSymbol("send")) - if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) + tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp55 := tmp54.FindInternedVar(lang.NewSymbol("send")) + if tmp55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) } - v56 := v55.Get() - v57 := lang.Apply(v56, []any{v53, v17}) - _ = v57 - v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v60 := v59.FindInternedVar(lang.NewSymbol("next")) - if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) + tmp56 := tmp55.Get() + tmp57 := lang.Apply(tmp56, []any{v53, v17}) + _ = tmp57 + tmp59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp60 := tmp59.FindInternedVar(lang.NewSymbol("next")) + if tmp60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp60))) } - v61 := v60.Get() - v62 := lang.Apply(v61, []any{v41}) - var v58 any = v62 - var v63 any = nil - var v64 any = int64(0) - var v65 any = int64(0) - v23 = v58 - v24 = v63 - v25 = v64 - v26 = v65 + tmp61 := tmp60.Get() + tmp62 := lang.Apply(tmp61, []any{v41}) + var tmp58 any = tmp62 + var tmp63 any = nil + var tmp64 any = int64(0) + var tmp65 any = int64(0) + v23 = tmp58 + v24 = tmp63 + v25 = tmp64 + v26 = tmp65 continue } // end let - v42 = v48 + tmp42 = tmp48 } - v40 = v42 + tmp40 = tmp42 } // end let - v39 = v40 + tmp39 = tmp40 } else { - v39 = nil } - v33 = v39 + tmp33 = tmp39 } // end let - v27 = v33 + tmp27 = tmp33 } - v18 = v27 + tmp18 = tmp27 break } } // end let - _ = v18 - v19, ok := lang.FieldOrMethod(nil, "MILLISECONDS") + _ = tmp18 + tmp19, ok := lang.FieldOrMethod(nil, "MILLISECONDS") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "MILLISECONDS"))) } - var v20 any - switch reflect.TypeOf(v19).Kind() { + var tmp20 any + switch reflect.TypeOf(tmp19).Kind() { case reflect.Func: - v20 = lang.Apply(v19, nil) + tmp20 = lang.Apply(tmp19, nil) default: - v20 = v19 + tmp20 = tmp19 } - v21, _ := lang.FieldOrMethod(v13, "await") - if reflect.TypeOf(v21).Kind() != reflect.Func { + tmp21, _ := lang.FieldOrMethod(v13, "await") + if reflect.TypeOf(tmp21).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) } - v22 := lang.Apply(v21, []any{v3, v20}) - v12 = v22 + tmp22 := lang.Apply(tmp21, []any{v3, tmp20}) + tmp12 = tmp22 } // end let - v5 = v12 + tmp5 = tmp12 } - return v5 + return tmp5 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // await1 { - v0 := lang.NewSymbol("await1").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3284), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3284), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("await1").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3284), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3284), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("pos?")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8, ok := lang.FieldOrMethod(v3, "getQueueCount") + var tmp4 any + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("pos?")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8, ok := lang.FieldOrMethod(v3, "getQueueCount") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getQueueCount"))) } - var v9 any - switch reflect.TypeOf(v8).Kind() { + var tmp9 any + switch reflect.TypeOf(tmp8).Kind() { case reflect.Func: - v9 = lang.Apply(v8, nil) + tmp9 = lang.Apply(tmp8, nil) default: - v9 = v8 - } - v10 := lang.Apply(v7, []any{v9}) - if lang.IsTruthy(v10) { - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("await")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{v3}) - v4 = v14 + tmp9 = tmp8 + } + tmp10 := lang.Apply(tmp7, []any{tmp9}) + if lang.IsTruthy(tmp10) { + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("await")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{v3}) + tmp4 = tmp14 } else { - v4 = nil } - _ = v4 + _ = tmp4 return v3 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // bases { - v0 := lang.NewSymbol("bases").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"))), lang.NewKeyword("doc"), "Returns the immediate superclass and direct interfaces of c, if any", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5522), lang.NewKeyword("end-line"), int(5522))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("bases").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"))), lang.NewKeyword("doc"), "Returns the immediate superclass and direct interfaces of c, if any", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5522), lang.NewKeyword("end-line"), int(5522))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any + var tmp4 any if lang.IsTruthy(v3) { - var v5 any + var tmp5 any { // let // let binding "i" - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("seq")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{nil}) - var v10 any = v9 + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("seq")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.Apply(tmp8, []any{nil}) + var v10 any = tmp9 _ = v10 // let binding "s" var v11 any = nil _ = v11 - var v12 any + var tmp12 any if lang.IsTruthy(v11) { - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("cons")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{v11, v10}) - v12 = v16 + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("cons")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{v11, v10}) + tmp12 = tmp16 } else { - v12 = v10 + tmp12 = v10 } - v5 = v12 + tmp5 = tmp12 } // end let - v4 = v5 + tmp4 = tmp5 } else { - v4 = nil } - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // bigdec { - v1 := reflect.TypeOf((*lang.BigDecimal)(nil)) - v0 := lang.NewSymbol("bigdec").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Coerce to BigDecimal", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3648), lang.NewKeyword("end-line"), int(3648))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp1 := reflect.TypeOf((*lang.BigDecimal)(nil)) + tmp0 := lang.NewSymbol("bigdec").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Coerce to BigDecimal", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3648), lang.NewKeyword("end-line"), int(3648))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - var v5 any - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("decimal?")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{v4}) - if lang.IsTruthy(v9) { - v5 = v4 + var tmp5 any + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("decimal?")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.Apply(tmp8, []any{v4}) + if lang.IsTruthy(tmp9) { + tmp5 = v4 } else { - var v10 any - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("float?")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{v4}) - if lang.IsTruthy(v14) { - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("double")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{v4}) - v19 := lang.Apply(lang.NewBigDecimalFromFloat64, []any{v18}) - v10 = v19 + var tmp10 any + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("float?")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{v4}) + if lang.IsTruthy(tmp14) { + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("double")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{v4}) + tmp19 := lang.Apply(lang.NewBigDecimalFromFloat64, []any{tmp18}) + tmp10 = tmp19 } else { - var v20 any - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("ratio?")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.Apply(v23, []any{v4}) - if lang.IsTruthy(v24) { - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("/")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.Apply(lang.NewBigDecimalFromRatio, []any{v4}) - v29, ok := lang.FieldOrMethod(v4, "denominator") + var tmp20 any + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("ratio?")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.Apply(tmp23, []any{v4}) + if lang.IsTruthy(tmp24) { + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("/")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.Apply(lang.NewBigDecimalFromRatio, []any{v4}) + tmp29, ok := lang.FieldOrMethod(v4, "denominator") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "denominator"))) } - var v30 any - switch reflect.TypeOf(v29).Kind() { + var tmp30 any + switch reflect.TypeOf(tmp29).Kind() { case reflect.Func: - v30 = lang.Apply(v29, nil) + tmp30 = lang.Apply(tmp29, nil) default: - v30 = v29 + tmp30 = tmp29 } - v31 := lang.Apply(v27, []any{v28, v30}) - v20 = v31 + tmp31 := lang.Apply(tmp27, []any{tmp28, tmp30}) + tmp20 = tmp31 } else { - var v32 any - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("instance?")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - v36 := lang.Apply(v35, []any{*lang.BigInt, v4}) - if lang.IsTruthy(v36) { - v37, ok := lang.FieldOrMethod(v4, "toBigDecimal") + var tmp32 any + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("instance?")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) + } + tmp35 := tmp34.Get() + tmp36 := reflect.TypeOf((*lang.BigInt)(nil)) + tmp37 := lang.Apply(tmp35, []any{tmp36, v4}) + if lang.IsTruthy(tmp37) { + tmp38, ok := lang.FieldOrMethod(v4, "toBigDecimal") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "toBigDecimal"))) } - var v38 any - switch reflect.TypeOf(v37).Kind() { + var tmp39 any + switch reflect.TypeOf(tmp38).Kind() { case reflect.Func: - v38 = lang.Apply(v37, nil) + tmp39 = lang.Apply(tmp38, nil) default: - v38 = v37 + tmp39 = tmp38 } - v32 = v38 + tmp32 = tmp39 } else { - var v39 any - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("instance?")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) - } - v42 := v41.Get() - v43 := lang.Apply(v42, []any{*big6.Int, v4}) - if lang.IsTruthy(v43) { - v44 := lang.Apply(lang.NewBigDecimal, []any{v4}) - v39 = v44 + var tmp40 any + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("instance?")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := reflect.TypeOf((*big6.Int)(nil)) + tmp45 := lang.Apply(tmp43, []any{tmp44, v4}) + if lang.IsTruthy(tmp45) { + tmp46 := lang.Apply(lang.NewBigDecimal, []any{v4}) + tmp40 = tmp46 } else { - var v45 any - v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v47 := v46.FindInternedVar(lang.NewSymbol("number?")) - if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) + var tmp47 any + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("number?")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) } - v48 := v47.Get() - v49 := lang.Apply(v48, []any{v4}) - if lang.IsTruthy(v49) { - v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v51 := v50.FindInternedVar(lang.NewSymbol("long")) - if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v4}) + if lang.IsTruthy(tmp51) { + tmp52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp53 := tmp52.FindInternedVar(lang.NewSymbol("long")) + if tmp53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp53))) } - v52 := v51.Get() - v53 := lang.Apply(v52, []any{v4}) - v54 := lang.Apply(lang.NewBigDecimalFromInt64, []any{v53}) - v45 = v54 + tmp54 := tmp53.Get() + tmp55 := lang.Apply(tmp54, []any{v4}) + tmp56 := lang.Apply(lang.NewBigDecimalFromInt64, []any{tmp55}) + tmp47 = tmp56 } else { - var v55 any + var tmp57 any if lang.IsTruthy(lang.NewKeyword("else")) { - v56 := lang.Apply(lang.NewBigDecimal, []any{v4}) - v55 = v56 + tmp58 := lang.Apply(lang.NewBigDecimal, []any{v4}) + tmp57 = tmp58 } else { - v55 = nil } - v45 = v55 + tmp47 = tmp57 } - v39 = v45 + tmp40 = tmp47 } - v32 = v39 + tmp32 = tmp40 } - v20 = v32 + tmp20 = tmp32 } - v10 = v20 + tmp10 = tmp20 } - v5 = v10 + tmp5 = tmp10 } - return v5 + return tmp5 }) - v4 := reflect.TypeOf((*lang.BigDecimal)(nil)) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp4 := reflect.TypeOf((*lang.BigDecimal)(nil)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // bigint { - v1 := reflect.TypeOf((*lang.BigInt)(nil)) - v0 := lang.NewSymbol("bigint").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Coerce to BigInt", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3620), lang.NewKeyword("end-line"), int(3620))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp1 := reflect.TypeOf((*lang.BigInt)(nil)) + tmp0 := lang.NewSymbol("bigint").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Coerce to BigInt", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3620), lang.NewKeyword("end-line"), int(3620))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - var v5 any - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{*lang.BigInt, v4}) - if lang.IsTruthy(v9) { - v5 = v4 + var tmp5 any + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("instance?")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := reflect.TypeOf((*lang.BigInt)(nil)) + tmp10 := lang.Apply(tmp8, []any{tmp9, v4}) + if lang.IsTruthy(tmp10) { + tmp5 = v4 } else { - var v10 any - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("instance?")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{*big6.Int, v4}) - if lang.IsTruthy(v14) { - v15 := lang.Apply(lang.NewBigIntFromGoBigInt, []any{v4}) - v10 = v15 + var tmp11 any + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("instance?")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := reflect.TypeOf((*big6.Int)(nil)) + tmp16 := lang.Apply(tmp14, []any{tmp15, v4}) + if lang.IsTruthy(tmp16) { + tmp17 := lang.Apply(lang.NewBigIntFromGoBigInt, []any{v4}) + tmp11 = tmp17 } else { - var v16 any - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("decimal?")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.Apply(v19, []any{v4}) - if lang.IsTruthy(v20) { - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("bigint")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24, ok := lang.FieldOrMethod(v4, "toBigInteger") + var tmp18 any + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("decimal?")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, []any{v4}) + if lang.IsTruthy(tmp22) { + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("bigint")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26, ok := lang.FieldOrMethod(v4, "toBigInteger") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "toBigInteger"))) } - var v25 any - switch reflect.TypeOf(v24).Kind() { + var tmp27 any + switch reflect.TypeOf(tmp26).Kind() { case reflect.Func: - v25 = lang.Apply(v24, nil) + tmp27 = lang.Apply(tmp26, nil) default: - v25 = v24 + tmp27 = tmp26 } - v26 := lang.Apply(v23, []any{v25}) - v16 = v26 + tmp28 := lang.Apply(tmp25, []any{tmp27}) + tmp18 = tmp28 } else { - var v27 any - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("float?")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.Apply(v30, []any{v4}) - if lang.IsTruthy(v31) { - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("bigint")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v36 := v35.FindInternedVar(lang.NewSymbol("double")) - if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) - } - v37 := v36.Get() - v38 := lang.Apply(v37, []any{v4}) - v39 := lang.Apply(lang.NewBigDecimalFromFloat64, []any{v38}) - v40 := lang.Apply(v34, []any{v39}) - v27 = v40 + var tmp29 any + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("float?")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) + } + tmp32 := tmp31.Get() + tmp33 := lang.Apply(tmp32, []any{v4}) + if lang.IsTruthy(tmp33) { + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("bigint")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("double")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.Apply(tmp39, []any{v4}) + tmp41 := lang.Apply(lang.NewBigDecimalFromFloat64, []any{tmp40}) + tmp42 := lang.Apply(tmp36, []any{tmp41}) + tmp29 = tmp42 } else { - var v41 any - v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v43 := v42.FindInternedVar(lang.NewSymbol("ratio?")) - if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) - } - v44 := v43.Get() - v45 := lang.Apply(v44, []any{v4}) - if lang.IsTruthy(v45) { - v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v47 := v46.FindInternedVar(lang.NewSymbol("bigint")) - if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) + var tmp43 any + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("ratio?")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) + } + tmp46 := tmp45.Get() + tmp47 := lang.Apply(tmp46, []any{v4}) + if lang.IsTruthy(tmp47) { + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("bigint")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) } - v48 := v47.Get() - v49, ok := lang.FieldOrMethod(v4, "bigIntegerValue") + tmp50 := tmp49.Get() + tmp51, ok := lang.FieldOrMethod(v4, "bigIntegerValue") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "bigIntegerValue"))) } - var v50 any - switch reflect.TypeOf(v49).Kind() { + var tmp52 any + switch reflect.TypeOf(tmp51).Kind() { case reflect.Func: - v50 = lang.Apply(v49, nil) + tmp52 = lang.Apply(tmp51, nil) default: - v50 = v49 + tmp52 = tmp51 } - v51 := lang.Apply(v48, []any{v50}) - v41 = v51 + tmp53 := lang.Apply(tmp50, []any{tmp52}) + tmp43 = tmp53 } else { - var v52 any - v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v54 := v53.FindInternedVar(lang.NewSymbol("number?")) - if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) + var tmp54 any + tmp55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp56 := tmp55.FindInternedVar(lang.NewSymbol("number?")) + if tmp56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp56))) } - v55 := v54.Get() - v56 := lang.Apply(v55, []any{v4}) - if lang.IsTruthy(v56) { - v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v58 := v57.FindInternedVar(lang.NewSymbol("long")) - if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) + tmp57 := tmp56.Get() + tmp58 := lang.Apply(tmp57, []any{v4}) + if lang.IsTruthy(tmp58) { + tmp59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp60 := tmp59.FindInternedVar(lang.NewSymbol("long")) + if tmp60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp60))) } - v59 := v58.Get() - v60 := lang.Apply(v59, []any{v4}) - v61 := lang.Apply(lang.NewBigIntFromInt64, []any{v60}) - v52 = v61 + tmp61 := tmp60.Get() + tmp62 := lang.Apply(tmp61, []any{v4}) + tmp63 := lang.Apply(lang.NewBigIntFromInt64, []any{tmp62}) + tmp54 = tmp63 } else { - var v62 any + var tmp64 any if lang.IsTruthy(lang.NewKeyword("else")) { - v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v64 := v63.FindInternedVar(lang.NewSymbol("bigint")) - if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) + tmp65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp66 := tmp65.FindInternedVar(lang.NewSymbol("bigint")) + if tmp66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp66))) } - v65 := v64.Get() - v66 := lang.Apply(lang.NewBigInt, []any{v4}) - v67 := lang.Apply(v65, []any{v66}) - v62 = v67 + tmp67 := tmp66.Get() + tmp68 := lang.Apply(lang.NewBigInt, []any{v4}) + tmp69 := lang.Apply(tmp67, []any{tmp68}) + tmp64 = tmp69 } else { - v62 = nil } - v52 = v62 + tmp54 = tmp64 } - v41 = v52 + tmp43 = tmp54 } - v27 = v41 + tmp29 = tmp43 } - v16 = v27 + tmp18 = tmp29 } - v10 = v16 + tmp11 = tmp18 } - v5 = v10 + tmp5 = tmp11 } - return v5 + return tmp5 }) - v4 := reflect.TypeOf((*lang.BigInt)(nil)) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp4 := reflect.TypeOf((*lang.BigInt)(nil)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // biginteger { - v1 := reflect.TypeOf((*big6.Int)(nil)) - v0 := lang.NewSymbol("biginteger").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Coerce to BigInteger", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3634), lang.NewKeyword("end-line"), int(3634))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp1 := reflect.TypeOf((*big6.Int)(nil)) + tmp0 := lang.NewSymbol("biginteger").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Coerce to BigInteger", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3634), lang.NewKeyword("end-line"), int(3634))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - var v5 any - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{*big6.Int, v4}) - if lang.IsTruthy(v9) { - v5 = v4 + var tmp5 any + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("instance?")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := reflect.TypeOf((*big6.Int)(nil)) + tmp10 := lang.Apply(tmp8, []any{tmp9, v4}) + if lang.IsTruthy(tmp10) { + tmp5 = v4 } else { - var v10 any - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("instance?")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{*lang.BigInt, v4}) - if lang.IsTruthy(v14) { - v15, ok := lang.FieldOrMethod(v4, "toBigInteger") + var tmp11 any + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("instance?")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := reflect.TypeOf((*lang.BigInt)(nil)) + tmp16 := lang.Apply(tmp14, []any{tmp15, v4}) + if lang.IsTruthy(tmp16) { + tmp17, ok := lang.FieldOrMethod(v4, "toBigInteger") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "toBigInteger"))) } - var v16 any - switch reflect.TypeOf(v15).Kind() { + var tmp18 any + switch reflect.TypeOf(tmp17).Kind() { case reflect.Func: - v16 = lang.Apply(v15, nil) + tmp18 = lang.Apply(tmp17, nil) default: - v16 = v15 + tmp18 = tmp17 } - v10 = v16 + tmp11 = tmp18 } else { - var v17 any - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("decimal?")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.Apply(v20, []any{v4}) - if lang.IsTruthy(v21) { - v22, ok := lang.FieldOrMethod(v4, "toBigInteger") + var tmp19 any + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("decimal?")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.Apply(tmp22, []any{v4}) + if lang.IsTruthy(tmp23) { + tmp24, ok := lang.FieldOrMethod(v4, "toBigInteger") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "toBigInteger"))) } - var v23 any - switch reflect.TypeOf(v22).Kind() { + var tmp25 any + switch reflect.TypeOf(tmp24).Kind() { case reflect.Func: - v23 = lang.Apply(v22, nil) + tmp25 = lang.Apply(tmp24, nil) default: - v23 = v22 + tmp25 = tmp24 } - v17 = v23 + tmp19 = tmp25 } else { - var v24 any - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("float?")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.Apply(v27, []any{v4}) - if lang.IsTruthy(v28) { - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("double")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.Apply(v31, []any{v4}) - v33 := lang.Apply(lang.NewBigDecimalFromFloat64, []any{v32}) - v34, ok := lang.FieldOrMethod(v33, "toBigInteger") + var tmp26 any + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("float?")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{v4}) + if lang.IsTruthy(tmp30) { + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("double")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{v4}) + tmp35 := lang.Apply(lang.NewBigDecimalFromFloat64, []any{tmp34}) + tmp36, ok := lang.FieldOrMethod(tmp35, "toBigInteger") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v33, "toBigInteger"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp35, "toBigInteger"))) } - var v35 any - switch reflect.TypeOf(v34).Kind() { + var tmp37 any + switch reflect.TypeOf(tmp36).Kind() { case reflect.Func: - v35 = lang.Apply(v34, nil) + tmp37 = lang.Apply(tmp36, nil) default: - v35 = v34 + tmp37 = tmp36 } - v24 = v35 + tmp26 = tmp37 } else { - var v36 any - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("ratio?")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.Apply(v39, []any{v4}) - if lang.IsTruthy(v40) { - v41, ok := lang.FieldOrMethod(v4, "bigIntegerValue") + var tmp38 any + tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp40 := tmp39.FindInternedVar(lang.NewSymbol("ratio?")) + if tmp40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) + } + tmp41 := tmp40.Get() + tmp42 := lang.Apply(tmp41, []any{v4}) + if lang.IsTruthy(tmp42) { + tmp43, ok := lang.FieldOrMethod(v4, "bigIntegerValue") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "bigIntegerValue"))) } - var v42 any - switch reflect.TypeOf(v41).Kind() { + var tmp44 any + switch reflect.TypeOf(tmp43).Kind() { case reflect.Func: - v42 = lang.Apply(v41, nil) + tmp44 = lang.Apply(tmp43, nil) default: - v42 = v41 + tmp44 = tmp43 } - v36 = v42 + tmp38 = tmp44 } else { - var v43 any - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("number?")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + var tmp45 any + tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp47 := tmp46.FindInternedVar(lang.NewSymbol("number?")) + if tmp47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) } - v46 := v45.Get() - v47 := lang.Apply(v46, []any{v4}) - if lang.IsTruthy(v47) { - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("long")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + tmp48 := tmp47.Get() + tmp49 := lang.Apply(tmp48, []any{v4}) + if lang.IsTruthy(tmp49) { + tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp51 := tmp50.FindInternedVar(lang.NewSymbol("long")) + if tmp51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v4}) - v52 := lang.Apply(big6.NewInt, []any{v51}) - v43 = v52 + tmp52 := tmp51.Get() + tmp53 := lang.Apply(tmp52, []any{v4}) + tmp54 := lang.Apply(big6.NewInt, []any{tmp53}) + tmp45 = tmp54 } else { - var v53 any + var tmp55 any if lang.IsTruthy(lang.NewKeyword("else")) { - v54 := lang.Apply(lang.NewBigInt, []any{v4}) - v53 = v54 + tmp56 := lang.Apply(lang.NewBigInt, []any{v4}) + tmp55 = tmp56 } else { - v53 = nil } - v43 = v53 + tmp45 = tmp55 } - v36 = v43 + tmp38 = tmp45 } - v24 = v36 + tmp26 = tmp38 } - v17 = v24 + tmp19 = tmp26 } - v10 = v17 + tmp11 = tmp19 } - v5 = v10 + tmp5 = tmp11 } - return v5 + return tmp5 }) - v4 := reflect.TypeOf((*big6.Int)(nil)) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp4 := reflect.TypeOf((*big6.Int)(nil)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // binding { - v0 := lang.NewSymbol("binding").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "binding => var-symbol init-expr\n\n Creates new bindings for the (already-existing) vars, with the\n supplied initial values, executes the exprs in an implicit do, then\n re-establishes the bindings that existed before. The new bindings\n are made in parallel (unlike let); all init-exprs are evaluated\n before the vars are bound to their new values.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1945), lang.NewKeyword("end-line"), int(1945))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("binding").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "binding => var-symbol init-expr\n\n Creates new bindings for the (already-existing) vars, with the\n supplied initial values, executes the exprs in an implicit do, then\n re-establishes the bindings that existed before. The new bindings\n are made in parallel (unlike let); all init-exprs are evaluated\n before the vars are bound to their new values.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1945), lang.NewKeyword("end-line"), int(1945))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 3 { @@ -11602,480 +11645,478 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - var v7 any - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v5}) - if lang.IsTruthy(v11) { - v7 = nil + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("vector?")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v5}) + if lang.IsTruthy(tmp11) { } else { - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("str")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("first")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{v3}) - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("meta")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v3}) - v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) - v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) - v28 := lang.Apply(lang.NewIllegalArgumentError, []any{v27}) - panic(v28) - } - _ = v7 - var v29 any - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("even?")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) - } - v32 := v31.Get() - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("count")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - v36 := lang.Apply(v35, []any{v5}) - v37 := lang.Apply(v32, []any{v36}) - if lang.IsTruthy(v37) { - v29 = nil + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("str")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("first")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("*ns*")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("meta")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.Apply(tmp24, []any{v3}) + tmp26 := lang.Apply(lang.NewKeyword("line"), []any{tmp25}) + tmp27 := lang.Apply(tmp14, []any{tmp18, " requires ", "a vector for its binding", " in ", tmp21, ":", tmp26}) + tmp28 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp27}) + panic(tmp28) + } + _ = tmp7 + var tmp29 any + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("even?")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) + } + tmp32 := tmp31.Get() + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("count")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) + } + tmp35 := tmp34.Get() + tmp36 := lang.Apply(tmp35, []any{v5}) + tmp37 := lang.Apply(tmp32, []any{tmp36}) + if lang.IsTruthy(tmp37) { } else { - v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v39 := v38.FindInternedVar(lang.NewSymbol("str")) - if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) - } - v40 := v39.Get() - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("first")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) - } - v43 := v42.Get() - v44 := lang.Apply(v43, []any{v3}) - v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) - if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) - } - v47 := v46.Get() - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("meta")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v3}) - v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) - v53 := lang.Apply(v40, []any{v44, " requires ", "an even number of forms in binding vector", " in ", v47, ":", v52}) - v54 := lang.Apply(lang.NewIllegalArgumentError, []any{v53}) - panic(v54) - } - _ = v29 - _ = nil - var v55 any + tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp39 := tmp38.FindInternedVar(lang.NewSymbol("str")) + if tmp39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) + } + tmp40 := tmp39.Get() + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("first")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := lang.Apply(tmp43, []any{v3}) + tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp46 := tmp45.FindInternedVar(lang.NewSymbol("*ns*")) + if tmp46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) + } + tmp47 := tmp46.Get() + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("meta")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v3}) + tmp52 := lang.Apply(lang.NewKeyword("line"), []any{tmp51}) + tmp53 := lang.Apply(tmp40, []any{tmp44, " requires ", "an even number of forms in binding vector", " in ", tmp47, ":", tmp52}) + tmp54 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp53}) + panic(tmp54) + } + _ = tmp29 + var tmp55 any { // let // let binding "var-ize" - var v56 lang.FnFunc - v56 = lang.NewFnFunc(func(args ...any) any { + var tmp56 lang.FnFunc + tmp56 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v57 := args[0] _ = v57 - var v58 any + var tmp58 any { // let // let binding "ret" - v59 := lang.NewVector() - v60 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1959), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(1959), lang.NewKeyword("end-column"), int(31)) - v61, err := lang.WithMeta(v59, v60.(lang.IPersistentMap)) + tmp59 := lang.NewVector() + tmp60 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1959), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(1959), lang.NewKeyword("end-column"), int(31)) + tmp61, err := lang.WithMeta(tmp59, tmp60.(lang.IPersistentMap)) if err != nil { panic(err) } - var v62 any = v61 + var v62 any = tmp61 _ = v62 // let binding "vvs" - v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v64 := v63.FindInternedVar(lang.NewSymbol("seq")) - if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) - } - v65 := v64.Get() - v66 := lang.Apply(v65, []any{v57}) - var v67 any = v66 + tmp63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp64 := tmp63.FindInternedVar(lang.NewSymbol("seq")) + if tmp64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp64))) + } + tmp65 := tmp64.Get() + tmp66 := lang.Apply(tmp65, []any{v57}) + var v67 any = tmp66 _ = v67 for { - var v68 any + var tmp68 any if lang.IsTruthy(v67) { - v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v71 := v70.FindInternedVar(lang.NewSymbol("conj")) - if v71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) + tmp70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp71 := tmp70.FindInternedVar(lang.NewSymbol("conj")) + if tmp71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp71))) } - v72 := v71.Get() - v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v74 := v73.FindInternedVar(lang.NewSymbol("conj")) - if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) + tmp72 := tmp71.Get() + tmp73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp74 := tmp73.FindInternedVar(lang.NewSymbol("conj")) + if tmp74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp74))) } - v75 := v74.Get() - v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v77 := v76.FindInternedVar(lang.NewSymbol("seq")) - if v77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) + tmp75 := tmp74.Get() + tmp76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp77 := tmp76.FindInternedVar(lang.NewSymbol("seq")) + if tmp77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp77))) } - v78 := v77.Get() - v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v80 := v79.FindInternedVar(lang.NewSymbol("concat")) - if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) + tmp78 := tmp77.Get() + tmp79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp80 := tmp79.FindInternedVar(lang.NewSymbol("concat")) + if tmp80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp80))) } - v81 := v80.Get() - v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v83 := v82.FindInternedVar(lang.NewSymbol("list")) - if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) + tmp81 := tmp80.Get() + tmp82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp83 := tmp82.FindInternedVar(lang.NewSymbol("list")) + if tmp83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp83))) } - v84 := v83.Get() - v85 := lang.Apply(v84, []any{lang.NewSymbol("var")}) - v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v87 := v86.FindInternedVar(lang.NewSymbol("list")) - if v87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) + tmp84 := tmp83.Get() + tmp85 := lang.Apply(tmp84, []any{lang.NewSymbol("var")}) + tmp86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp87 := tmp86.FindInternedVar(lang.NewSymbol("list")) + if tmp87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp87))) } - v88 := v87.Get() - v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v90 := v89.FindInternedVar(lang.NewSymbol("first")) - if v90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) + tmp88 := tmp87.Get() + tmp89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp90 := tmp89.FindInternedVar(lang.NewSymbol("first")) + if tmp90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp90))) } - v91 := v90.Get() - v92 := lang.Apply(v91, []any{v67}) - v93 := lang.Apply(v88, []any{v92}) - v94 := lang.Apply(v81, []any{v85, v93}) - v95 := lang.Apply(v78, []any{v94}) - v96 := lang.Apply(v75, []any{v62, v95}) - v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v98 := v97.FindInternedVar(lang.NewSymbol("second")) - if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) + tmp91 := tmp90.Get() + tmp92 := lang.Apply(tmp91, []any{v67}) + tmp93 := lang.Apply(tmp88, []any{tmp92}) + tmp94 := lang.Apply(tmp81, []any{tmp85, tmp93}) + tmp95 := lang.Apply(tmp78, []any{tmp94}) + tmp96 := lang.Apply(tmp75, []any{v62, tmp95}) + tmp97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp98 := tmp97.FindInternedVar(lang.NewSymbol("second")) + if tmp98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp98))) } - v99 := v98.Get() - v100 := lang.Apply(v99, []any{v67}) - v101 := lang.Apply(v72, []any{v96, v100}) - var v69 any = v101 - v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v104 := v103.FindInternedVar(lang.NewSymbol("next")) - if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) + tmp99 := tmp98.Get() + tmp100 := lang.Apply(tmp99, []any{v67}) + tmp101 := lang.Apply(tmp72, []any{tmp96, tmp100}) + var tmp69 any = tmp101 + tmp103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp104 := tmp103.FindInternedVar(lang.NewSymbol("next")) + if tmp104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp104))) } - v105 := v104.Get() - v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v107 := v106.FindInternedVar(lang.NewSymbol("next")) - if v107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) + tmp105 := tmp104.Get() + tmp106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp107 := tmp106.FindInternedVar(lang.NewSymbol("next")) + if tmp107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp107))) } - v108 := v107.Get() - v109 := lang.Apply(v108, []any{v67}) - v110 := lang.Apply(v105, []any{v109}) - var v102 any = v110 - v62 = v69 - v67 = v102 + tmp108 := tmp107.Get() + tmp109 := lang.Apply(tmp108, []any{v67}) + tmp110 := lang.Apply(tmp105, []any{tmp109}) + var tmp102 any = tmp110 + v62 = tmp69 + v67 = tmp102 continue } else { - v111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v112 := v111.FindInternedVar(lang.NewSymbol("seq")) - if v112.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v112))) + tmp111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp112 := tmp111.FindInternedVar(lang.NewSymbol("seq")) + if tmp112.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp112))) } - v113 := v112.Get() - v114 := lang.Apply(v113, []any{v62}) - v68 = v114 + tmp113 := tmp112.Get() + tmp114 := lang.Apply(tmp113, []any{v62}) + tmp68 = tmp114 } - v58 = v68 + tmp58 = tmp68 break } } // end let - return v58 + return tmp58 }) - v57 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1958), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(1963), lang.NewKeyword("end-column"), int(34)) - v58, err := lang.WithMeta(v56, v57.(lang.IPersistentMap)) + tmp57 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1958), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(1963), lang.NewKeyword("end-column"), int(34)) + tmp58, err := lang.WithMeta(tmp56, tmp57.(lang.IPersistentMap)) if err != nil { panic(err) } - var v59 any = v58 + var v59 any = tmp58 _ = v59 - v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v61 := v60.FindInternedVar(lang.NewSymbol("seq")) - if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) - } - v62 := v61.Get() - v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v64 := v63.FindInternedVar(lang.NewSymbol("concat")) - if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) - } - v65 := v64.Get() - v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v67 := v66.FindInternedVar(lang.NewSymbol("list")) - if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) - } - v68 := v67.Get() - v69 := lang.Apply(v68, []any{lang.NewSymbol("glojure.core/let")}) - v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v71 := v70.FindInternedVar(lang.NewSymbol("list")) - if v71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) - } - v72 := v71.Get() - v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v74 := v73.FindInternedVar(lang.NewSymbol("apply")) - if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) - } - v75 := v74.Get() - v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v77 := v76.FindInternedVar(lang.NewSymbol("vector")) - if v77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) - } - v78 := v77.Get() - v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v80 := v79.FindInternedVar(lang.NewSymbol("seq")) - if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) - } - v81 := v80.Get() - v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v83 := v82.FindInternedVar(lang.NewSymbol("concat")) - if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) - } - v84 := v83.Get() - v85 := lang.Apply(v84, nil) - v86 := lang.Apply(v81, []any{v85}) - v87 := lang.Apply(v75, []any{v78, v86}) - v88 := lang.Apply(v72, []any{v87}) - v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v90 := v89.FindInternedVar(lang.NewSymbol("list")) - if v90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) - } - v91 := v90.Get() - v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v93 := v92.FindInternedVar(lang.NewSymbol("seq")) - if v93.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) - } - v94 := v93.Get() - v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v96 := v95.FindInternedVar(lang.NewSymbol("concat")) - if v96.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) - } - v97 := v96.Get() - v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v99 := v98.FindInternedVar(lang.NewSymbol("list")) - if v99.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) - } - v100 := v99.Get() - v101 := lang.Apply(v100, []any{lang.NewSymbol("glojure.core/push-thread-bindings")}) - v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v103 := v102.FindInternedVar(lang.NewSymbol("list")) - if v103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) - } - v104 := v103.Get() - v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v106 := v105.FindInternedVar(lang.NewSymbol("seq")) - if v106.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) - } - v107 := v106.Get() - v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v109 := v108.FindInternedVar(lang.NewSymbol("concat")) - if v109.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) - } - v110 := v109.Get() - v111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v112 := v111.FindInternedVar(lang.NewSymbol("list")) - if v112.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v112))) - } - v113 := v112.Get() - v114 := lang.Apply(v113, []any{lang.NewSymbol("glojure.core/hash-map")}) - v115 := lang.Apply(v59, []any{v5}) - v116 := lang.Apply(v110, []any{v114, v115}) - v117 := lang.Apply(v107, []any{v116}) - v118 := lang.Apply(v104, []any{v117}) - v119 := lang.Apply(v97, []any{v101, v118}) - v120 := lang.Apply(v94, []any{v119}) - v121 := lang.Apply(v91, []any{v120}) - v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v123 := v122.FindInternedVar(lang.NewSymbol("list")) - if v123.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) - } - v124 := v123.Get() - v125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v126 := v125.FindInternedVar(lang.NewSymbol("seq")) - if v126.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v126))) - } - v127 := v126.Get() - v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v129 := v128.FindInternedVar(lang.NewSymbol("concat")) - if v129.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v129))) - } - v130 := v129.Get() - v131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v132 := v131.FindInternedVar(lang.NewSymbol("list")) - if v132.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v132))) - } - v133 := v132.Get() - v134 := lang.Apply(v133, []any{lang.NewSymbol("try")}) - v135 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v136 := v135.FindInternedVar(lang.NewSymbol("list")) - if v136.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v136))) - } - v137 := v136.Get() - v138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v139 := v138.FindInternedVar(lang.NewSymbol("seq")) - if v139.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v139))) - } - v140 := v139.Get() - v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v142 := v141.FindInternedVar(lang.NewSymbol("concat")) - if v142.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) - } - v143 := v142.Get() - v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v145 := v144.FindInternedVar(lang.NewSymbol("list")) - if v145.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) - } - v146 := v145.Get() - v147 := lang.Apply(v146, []any{lang.NewSymbol("finally")}) - v148 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v149 := v148.FindInternedVar(lang.NewSymbol("list")) - if v149.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v149))) - } - v150 := v149.Get() - v151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v152 := v151.FindInternedVar(lang.NewSymbol("seq")) - if v152.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v152))) - } - v153 := v152.Get() - v154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v155 := v154.FindInternedVar(lang.NewSymbol("concat")) - if v155.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v155))) - } - v156 := v155.Get() - v157 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v158 := v157.FindInternedVar(lang.NewSymbol("list")) - if v158.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v158))) - } - v159 := v158.Get() - v160 := lang.Apply(v159, []any{lang.NewSymbol("glojure.core/pop-thread-bindings")}) - v161 := lang.Apply(v156, []any{v160}) - v162 := lang.Apply(v153, []any{v161}) - v163 := lang.Apply(v150, []any{v162}) - v164 := lang.Apply(v143, []any{v147, v163}) - v165 := lang.Apply(v140, []any{v164}) - v166 := lang.Apply(v137, []any{v165}) - v167 := lang.Apply(v130, []any{v134, v6, v166}) - v168 := lang.Apply(v127, []any{v167}) - v169 := lang.Apply(v124, []any{v168}) - v170 := lang.Apply(v65, []any{v69, v88, v121, v169}) - v171 := lang.Apply(v62, []any{v170}) - v55 = v171 + tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp61 := tmp60.FindInternedVar(lang.NewSymbol("seq")) + if tmp61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) + } + tmp62 := tmp61.Get() + tmp63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp64 := tmp63.FindInternedVar(lang.NewSymbol("concat")) + if tmp64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp64))) + } + tmp65 := tmp64.Get() + tmp66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp67 := tmp66.FindInternedVar(lang.NewSymbol("list")) + if tmp67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp67))) + } + tmp68 := tmp67.Get() + tmp69 := lang.Apply(tmp68, []any{lang.NewSymbol("glojure.core/let")}) + tmp70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp71 := tmp70.FindInternedVar(lang.NewSymbol("list")) + if tmp71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp71))) + } + tmp72 := tmp71.Get() + tmp73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp74 := tmp73.FindInternedVar(lang.NewSymbol("apply")) + if tmp74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp74))) + } + tmp75 := tmp74.Get() + tmp76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp77 := tmp76.FindInternedVar(lang.NewSymbol("vector")) + if tmp77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp77))) + } + tmp78 := tmp77.Get() + tmp79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp80 := tmp79.FindInternedVar(lang.NewSymbol("seq")) + if tmp80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp80))) + } + tmp81 := tmp80.Get() + tmp82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp83 := tmp82.FindInternedVar(lang.NewSymbol("concat")) + if tmp83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp83))) + } + tmp84 := tmp83.Get() + tmp85 := lang.Apply(tmp84, nil) + tmp86 := lang.Apply(tmp81, []any{tmp85}) + tmp87 := lang.Apply(tmp75, []any{tmp78, tmp86}) + tmp88 := lang.Apply(tmp72, []any{tmp87}) + tmp89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp90 := tmp89.FindInternedVar(lang.NewSymbol("list")) + if tmp90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp90))) + } + tmp91 := tmp90.Get() + tmp92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp93 := tmp92.FindInternedVar(lang.NewSymbol("seq")) + if tmp93.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp93))) + } + tmp94 := tmp93.Get() + tmp95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp96 := tmp95.FindInternedVar(lang.NewSymbol("concat")) + if tmp96.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp96))) + } + tmp97 := tmp96.Get() + tmp98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp99 := tmp98.FindInternedVar(lang.NewSymbol("list")) + if tmp99.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp99))) + } + tmp100 := tmp99.Get() + tmp101 := lang.Apply(tmp100, []any{lang.NewSymbol("glojure.core/push-thread-bindings")}) + tmp102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp103 := tmp102.FindInternedVar(lang.NewSymbol("list")) + if tmp103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp103))) + } + tmp104 := tmp103.Get() + tmp105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp106 := tmp105.FindInternedVar(lang.NewSymbol("seq")) + if tmp106.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp106))) + } + tmp107 := tmp106.Get() + tmp108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp109 := tmp108.FindInternedVar(lang.NewSymbol("concat")) + if tmp109.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp109))) + } + tmp110 := tmp109.Get() + tmp111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp112 := tmp111.FindInternedVar(lang.NewSymbol("list")) + if tmp112.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp112))) + } + tmp113 := tmp112.Get() + tmp114 := lang.Apply(tmp113, []any{lang.NewSymbol("glojure.core/hash-map")}) + tmp115 := lang.Apply(v59, []any{v5}) + tmp116 := lang.Apply(tmp110, []any{tmp114, tmp115}) + tmp117 := lang.Apply(tmp107, []any{tmp116}) + tmp118 := lang.Apply(tmp104, []any{tmp117}) + tmp119 := lang.Apply(tmp97, []any{tmp101, tmp118}) + tmp120 := lang.Apply(tmp94, []any{tmp119}) + tmp121 := lang.Apply(tmp91, []any{tmp120}) + tmp122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp123 := tmp122.FindInternedVar(lang.NewSymbol("list")) + if tmp123.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp123))) + } + tmp124 := tmp123.Get() + tmp125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp126 := tmp125.FindInternedVar(lang.NewSymbol("seq")) + if tmp126.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp126))) + } + tmp127 := tmp126.Get() + tmp128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp129 := tmp128.FindInternedVar(lang.NewSymbol("concat")) + if tmp129.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp129))) + } + tmp130 := tmp129.Get() + tmp131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp132 := tmp131.FindInternedVar(lang.NewSymbol("list")) + if tmp132.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp132))) + } + tmp133 := tmp132.Get() + tmp134 := lang.Apply(tmp133, []any{lang.NewSymbol("try")}) + tmp135 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp136 := tmp135.FindInternedVar(lang.NewSymbol("list")) + if tmp136.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp136))) + } + tmp137 := tmp136.Get() + tmp138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp139 := tmp138.FindInternedVar(lang.NewSymbol("seq")) + if tmp139.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp139))) + } + tmp140 := tmp139.Get() + tmp141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp142 := tmp141.FindInternedVar(lang.NewSymbol("concat")) + if tmp142.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp142))) + } + tmp143 := tmp142.Get() + tmp144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp145 := tmp144.FindInternedVar(lang.NewSymbol("list")) + if tmp145.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp145))) + } + tmp146 := tmp145.Get() + tmp147 := lang.Apply(tmp146, []any{lang.NewSymbol("finally")}) + tmp148 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp149 := tmp148.FindInternedVar(lang.NewSymbol("list")) + if tmp149.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp149))) + } + tmp150 := tmp149.Get() + tmp151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp152 := tmp151.FindInternedVar(lang.NewSymbol("seq")) + if tmp152.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp152))) + } + tmp153 := tmp152.Get() + tmp154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp155 := tmp154.FindInternedVar(lang.NewSymbol("concat")) + if tmp155.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp155))) + } + tmp156 := tmp155.Get() + tmp157 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp158 := tmp157.FindInternedVar(lang.NewSymbol("list")) + if tmp158.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp158))) + } + tmp159 := tmp158.Get() + tmp160 := lang.Apply(tmp159, []any{lang.NewSymbol("glojure.core/pop-thread-bindings")}) + tmp161 := lang.Apply(tmp156, []any{tmp160}) + tmp162 := lang.Apply(tmp153, []any{tmp161}) + tmp163 := lang.Apply(tmp150, []any{tmp162}) + tmp164 := lang.Apply(tmp143, []any{tmp147, tmp163}) + tmp165 := lang.Apply(tmp140, []any{tmp164}) + tmp166 := lang.Apply(tmp137, []any{tmp165}) + tmp167 := lang.Apply(tmp130, []any{tmp134, v6, tmp166}) + tmp168 := lang.Apply(tmp127, []any{tmp167}) + tmp169 := lang.Apply(tmp124, []any{tmp168}) + tmp170 := lang.Apply(tmp65, []any{tmp69, tmp88, tmp121, tmp169}) + tmp171 := lang.Apply(tmp62, []any{tmp170}) + tmp55 = tmp171 } // end let - return v55 + return tmp55 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // binding-conveyor-fn { - v0 := lang.NewSymbol("binding-conveyor-fn").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2020), lang.NewKeyword("end-line"), int(2020), lang.NewKeyword("private"), true)).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("binding-conveyor-fn").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2020), lang.NewKeyword("end-line"), int(2020), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any + var tmp4 any { // let // let binding "frame" - v5 := lang.Apply(lang.CloneThreadBindingFrame, nil) - var v6 any = v5 + tmp5 := lang.Apply(lang.CloneThreadBindingFrame, nil) + var v6 any = tmp5 _ = v6 - var v7 lang.FnFunc - v7 = lang.NewFnFunc(func(args ...any) any { + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - v8 := lang.Apply(lang.ResetThreadBindingFrame, []any{v6}) - _ = v8 - v9 := lang.Apply(v3, nil) - return v9 + tmp8 := lang.Apply(lang.ResetThreadBindingFrame, []any{v6}) + _ = tmp8 + tmp9 := lang.Apply(v3, nil) + return tmp9 case 1: v8 := args[0] _ = v8 - v9 := lang.Apply(lang.ResetThreadBindingFrame, []any{v6}) - _ = v9 - v10 := lang.Apply(v3, []any{v8}) - return v10 + tmp9 := lang.Apply(lang.ResetThreadBindingFrame, []any{v6}) + _ = tmp9 + tmp10 := lang.Apply(v3, []any{v8}) + return tmp10 case 2: v8 := args[0] _ = v8 v9 := args[1] _ = v9 - v10 := lang.Apply(lang.ResetThreadBindingFrame, []any{v6}) - _ = v10 - v11 := lang.Apply(v3, []any{v8, v9}) - return v11 + tmp10 := lang.Apply(lang.ResetThreadBindingFrame, []any{v6}) + _ = tmp10 + tmp11 := lang.Apply(v3, []any{v8, v9}) + return tmp11 case 3: v8 := args[0] _ = v8 @@ -12083,10 +12124,10 @@ func init() { _ = v9 v10 := args[2] _ = v10 - v11 := lang.Apply(lang.ResetThreadBindingFrame, []any{v6}) - _ = v11 - v12 := lang.Apply(v3, []any{v8, v9, v10}) - return v12 + tmp11 := lang.Apply(lang.ResetThreadBindingFrame, []any{v6}) + _ = tmp11 + tmp12 := lang.Apply(v3, []any{v8, v9, v10}) + return tmp12 default: if len(args) < 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -12097,220 +12138,221 @@ func init() { _ = v9 v10 := args[2] _ = v10 - v11 := lang.NewList(args[3:]...) - v12 := lang.Apply(lang.ResetThreadBindingFrame, []any{v6}) - _ = v12 - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("apply")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + var v11 any = lang.NewList(args[3:]...) + _ = v11 + tmp12 := lang.Apply(lang.ResetThreadBindingFrame, []any{v6}) + _ = tmp12 + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("apply")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{v3, v8, v9, v10, v11}) - return v16 + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{v3, v8, v9, v10, v11}) + return tmp16 } }) - v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2025), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2040), lang.NewKeyword("end-column"), int(31)) - v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) + tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2025), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2040), lang.NewKeyword("end-column"), int(31)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) if err != nil { panic(err) } - v4 = v9 + tmp4 = tmp9 } // end let - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // bit-and { - var v1 lang.FnFunc - v1 = lang.NewFnFunc(func(args ...any) any { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v2 := args[0] _ = v2 - var v3 any + var tmp3 any { // let // let binding "op" - var v4 any - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - if lang.IsTruthy(v7) { - v4 = closed10 + var tmp4 any + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + if lang.IsTruthy(tmp7) { + tmp4 = closed10 } else { - v4 = closed10 + tmp4 = closed10 } - var v8 any = v4 + var v8 any = tmp4 _ = v8 - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("seq")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("concat")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("list")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("list")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("list")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("seq")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) - } - v28 := v27.Get() - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("concat")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("list")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{v8}) - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("list")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.Apply(v38, []any{v2}) - v40 := lang.Apply(v31, []any{v35, v39}) - v41 := lang.Apply(v28, []any{v40}) - v42 := lang.Apply(v25, []any{v41}) - v43 := lang.Apply(v14, []any{v18, v22, v42}) - v44 := lang.Apply(v11, []any{v43}) - v3 = v44 + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("seq")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("concat")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol(".")}) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("seq")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) + } + tmp28 := tmp27.Get() + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("concat")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.Apply(tmp34, []any{v8}) + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{v2}) + tmp40 := lang.Apply(tmp31, []any{tmp35, tmp39}) + tmp41 := lang.Apply(tmp28, []any{tmp40}) + tmp42 := lang.Apply(tmp25, []any{tmp41}) + tmp43 := lang.Apply(tmp14, []any{tmp18, tmp22, tmp42}) + tmp44 := lang.Apply(tmp11, []any{tmp43}) + tmp3 = tmp44 } // end let - return v3 + return tmp3 case 2: v2 := args[0] _ = v2 v3 := args[1] _ = v3 - var v4 any + var tmp4 any { // let // let binding "op" - var v5 any - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - if lang.IsTruthy(v8) { - v5 = closed10 + var tmp5 any + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + if lang.IsTruthy(tmp8) { + tmp5 = closed10 } else { - v5 = closed10 + tmp5 = closed10 } - var v9 any = v5 + var v9 any = tmp5 _ = v9 - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("seq")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("concat")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("list")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("list")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("list")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("seq")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("concat")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) - } - v32 := v31.Get() - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("list")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - v36 := lang.Apply(v35, []any{v9}) - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("list")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.Apply(v39, []any{v2}) - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("list")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) - } - v43 := v42.Get() - v44 := lang.Apply(v43, []any{v3}) - v45 := lang.Apply(v32, []any{v36, v40, v44}) - v46 := lang.Apply(v29, []any{v45}) - v47 := lang.Apply(v26, []any{v46}) - v48 := lang.Apply(v15, []any{v19, v23, v47}) - v49 := lang.Apply(v12, []any{v48}) - v4 = v49 + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("seq")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("concat")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("list")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{lang.NewSymbol(".")}) + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("list")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.Apply(tmp22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("list")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("seq")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("concat")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) + } + tmp32 := tmp31.Get() + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("list")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) + } + tmp35 := tmp34.Get() + tmp36 := lang.Apply(tmp35, []any{v9}) + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("list")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.Apply(tmp39, []any{v2}) + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("list")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := lang.Apply(tmp43, []any{v3}) + tmp45 := lang.Apply(tmp32, []any{tmp36, tmp40, tmp44}) + tmp46 := lang.Apply(tmp29, []any{tmp45}) + tmp47 := lang.Apply(tmp26, []any{tmp46}) + tmp48 := lang.Apply(tmp15, []any{tmp19, tmp23, tmp47}) + tmp49 := lang.Apply(tmp12, []any{tmp48}) + tmp4 = tmp49 } // end let - return v4 + return tmp4 default: if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -12319,32 +12361,33 @@ func init() { _ = v2 v3 := args[1] _ = v3 - v4 := lang.NewList(args[2:]...) - var v5 any + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any { // let // let binding "op" - var v6 any - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - if lang.IsTruthy(v9) { - v6 = closed10 + var tmp6 any + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + if lang.IsTruthy(tmp9) { + tmp6 = closed10 } else { - v6 = closed10 + tmp6 = closed10 } - var v10 any = v6 + var v10 any = tmp6 _ = v10 - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - var v14 lang.FnFunc - v14 = lang.NewFnFunc(func(args ...any) any { + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -12352,190 +12395,190 @@ func init() { _ = v15 v16 := args[1] _ = v16 - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("seq")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("concat")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("list")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("seq")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) - } - v36 := v35.Get() - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("concat")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("list")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) - } - v42 := v41.Get() - v43 := lang.Apply(v42, []any{v10}) - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("list")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) - } - v46 := v45.Get() - v47 := lang.Apply(v46, []any{v15}) - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("list")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v16}) - v52 := lang.Apply(v39, []any{v43, v47, v51}) - v53 := lang.Apply(v36, []any{v52}) - v54 := lang.Apply(v33, []any{v53}) - v55 := lang.Apply(v22, []any{v26, v30, v54}) - v56 := lang.Apply(v19, []any{v55}) - return v56 + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("concat")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol(".")}) + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) + } + tmp42 := tmp41.Get() + tmp43 := lang.Apply(tmp42, []any{v10}) + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) + } + tmp46 := tmp45.Get() + tmp47 := lang.Apply(tmp46, []any{v15}) + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v16}) + tmp52 := lang.Apply(tmp39, []any{tmp43, tmp47, tmp51}) + tmp53 := lang.Apply(tmp36, []any{tmp52}) + tmp54 := lang.Apply(tmp33, []any{tmp53}) + tmp55 := lang.Apply(tmp22, []any{tmp26, tmp30, tmp54}) + tmp56 := lang.Apply(tmp19, []any{tmp55}) + return tmp56 }) - v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) - v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) + tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) if err != nil { panic(err) } - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("seq")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("concat")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("list")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("seq")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) - } - v36 := v35.Get() - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("concat")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("list")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) - } - v42 := v41.Get() - v43 := lang.Apply(v42, []any{v10}) - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("list")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) - } - v46 := v45.Get() - v47 := lang.Apply(v46, []any{v2}) - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("list")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v3}) - v52 := lang.Apply(v39, []any{v43, v47, v51}) - v53 := lang.Apply(v36, []any{v52}) - v54 := lang.Apply(v33, []any{v53}) - v55 := lang.Apply(v22, []any{v26, v30, v54}) - v56 := lang.Apply(v19, []any{v55}) - v57 := lang.Apply(v13, []any{v16, v56, v4}) - v5 = v57 + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("concat")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol(".")}) + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) + } + tmp42 := tmp41.Get() + tmp43 := lang.Apply(tmp42, []any{v10}) + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) + } + tmp46 := tmp45.Get() + tmp47 := lang.Apply(tmp46, []any{v2}) + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v3}) + tmp52 := lang.Apply(tmp39, []any{tmp43, tmp47, tmp51}) + tmp53 := lang.Apply(tmp36, []any{tmp52}) + tmp54 := lang.Apply(tmp33, []any{tmp53}) + tmp55 := lang.Apply(tmp22, []any{tmp26, tmp30, tmp54}) + tmp56 := lang.Apply(tmp19, []any{tmp55}) + tmp57 := lang.Apply(tmp13, []any{tmp16, tmp56, v4}) + tmp5 = tmp57 } // end let - return v5 + return tmp5 } }) - v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp1 = tmp1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") - if reflect.TypeOf(v4).Kind() != reflect.Func { + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - v5 := lang.Apply(v4, []any{nil, int64(1)}) - return v5 + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v0 := lang.NewSymbol("bit-and").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Bitwise and", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1298), lang.NewKeyword("end-line"), int(1298))).(*lang.Symbol) - var v4 lang.FnFunc - v4 = lang.NewFnFunc(func(args ...any) any { + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp0 := lang.NewSymbol("bit-and").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Bitwise and", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), tmp2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1298), lang.NewKeyword("end-line"), int(1298))).(*lang.Symbol) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 2: v5 := args[0] _ = v5 v6 := args[1] _ = v6 - v7, _ := lang.FieldOrMethod(lang.Numbers, "And") - if reflect.TypeOf(v7).Kind() != reflect.Func { + tmp7, _ := lang.FieldOrMethod(lang.Numbers, "And") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("And is not a function"))) } - v8 := lang.Apply(v7, []any{v5, v6}) - return v8 + tmp8 := lang.Apply(tmp7, []any{v5, v6}) + return tmp8 default: if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -12544,222 +12587,223 @@ func init() { _ = v5 v6 := args[1] _ = v6 - v7 := lang.NewList(args[2:]...) - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + var v7 any = lang.NewList(args[2:]...) + _ = v7 + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("bit-and")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("bit-and")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) } - v13 := v12.Get() - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("bit-and")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + tmp13 := tmp12.Get() + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("bit-and")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{v5, v6}) - v18 := lang.Apply(v10, []any{v13, v17, v7}) - return v18 + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{v5, v6}) + tmp18 := lang.Apply(tmp10, []any{tmp13, tmp17, v7}) + return tmp18 } }) - v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v3 := ns.InternWithValue(v0, v4, true) - if v0.Meta() != nil { - v3.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 := ns.InternWithValue(tmp0, tmp4, true) + if tmp0.Meta() != nil { + tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // bit-and-not { - var v1 lang.FnFunc - v1 = lang.NewFnFunc(func(args ...any) any { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v2 := args[0] _ = v2 - var v3 any + var tmp3 any { // let // let binding "op" - var v4 any - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - if lang.IsTruthy(v7) { - v4 = closed11 + var tmp4 any + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + if lang.IsTruthy(tmp7) { + tmp4 = closed11 } else { - v4 = closed11 + tmp4 = closed11 } - var v8 any = v4 + var v8 any = tmp4 _ = v8 - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("seq")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("concat")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("list")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("list")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("list")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("seq")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) - } - v28 := v27.Get() - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("concat")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("list")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{v8}) - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("list")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.Apply(v38, []any{v2}) - v40 := lang.Apply(v31, []any{v35, v39}) - v41 := lang.Apply(v28, []any{v40}) - v42 := lang.Apply(v25, []any{v41}) - v43 := lang.Apply(v14, []any{v18, v22, v42}) - v44 := lang.Apply(v11, []any{v43}) - v3 = v44 + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("seq")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("concat")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol(".")}) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("seq")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) + } + tmp28 := tmp27.Get() + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("concat")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.Apply(tmp34, []any{v8}) + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{v2}) + tmp40 := lang.Apply(tmp31, []any{tmp35, tmp39}) + tmp41 := lang.Apply(tmp28, []any{tmp40}) + tmp42 := lang.Apply(tmp25, []any{tmp41}) + tmp43 := lang.Apply(tmp14, []any{tmp18, tmp22, tmp42}) + tmp44 := lang.Apply(tmp11, []any{tmp43}) + tmp3 = tmp44 } // end let - return v3 + return tmp3 case 2: v2 := args[0] _ = v2 v3 := args[1] _ = v3 - var v4 any + var tmp4 any { // let // let binding "op" - var v5 any - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - if lang.IsTruthy(v8) { - v5 = closed11 + var tmp5 any + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + if lang.IsTruthy(tmp8) { + tmp5 = closed11 } else { - v5 = closed11 + tmp5 = closed11 } - var v9 any = v5 + var v9 any = tmp5 _ = v9 - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("seq")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("concat")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("list")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("list")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("list")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("seq")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("concat")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) - } - v32 := v31.Get() - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("list")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - v36 := lang.Apply(v35, []any{v9}) - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("list")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.Apply(v39, []any{v2}) - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("list")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) - } - v43 := v42.Get() - v44 := lang.Apply(v43, []any{v3}) - v45 := lang.Apply(v32, []any{v36, v40, v44}) - v46 := lang.Apply(v29, []any{v45}) - v47 := lang.Apply(v26, []any{v46}) - v48 := lang.Apply(v15, []any{v19, v23, v47}) - v49 := lang.Apply(v12, []any{v48}) - v4 = v49 + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("seq")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("concat")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("list")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{lang.NewSymbol(".")}) + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("list")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.Apply(tmp22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("list")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("seq")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("concat")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) + } + tmp32 := tmp31.Get() + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("list")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) + } + tmp35 := tmp34.Get() + tmp36 := lang.Apply(tmp35, []any{v9}) + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("list")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.Apply(tmp39, []any{v2}) + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("list")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := lang.Apply(tmp43, []any{v3}) + tmp45 := lang.Apply(tmp32, []any{tmp36, tmp40, tmp44}) + tmp46 := lang.Apply(tmp29, []any{tmp45}) + tmp47 := lang.Apply(tmp26, []any{tmp46}) + tmp48 := lang.Apply(tmp15, []any{tmp19, tmp23, tmp47}) + tmp49 := lang.Apply(tmp12, []any{tmp48}) + tmp4 = tmp49 } // end let - return v4 + return tmp4 default: if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -12768,32 +12812,33 @@ func init() { _ = v2 v3 := args[1] _ = v3 - v4 := lang.NewList(args[2:]...) - var v5 any + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any { // let // let binding "op" - var v6 any - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - if lang.IsTruthy(v9) { - v6 = closed11 + var tmp6 any + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + if lang.IsTruthy(tmp9) { + tmp6 = closed11 } else { - v6 = closed11 + tmp6 = closed11 } - var v10 any = v6 + var v10 any = tmp6 _ = v10 - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - var v14 lang.FnFunc - v14 = lang.NewFnFunc(func(args ...any) any { + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -12801,190 +12846,190 @@ func init() { _ = v15 v16 := args[1] _ = v16 - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("seq")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("concat")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("list")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("seq")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) - } - v36 := v35.Get() - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("concat")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("list")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) - } - v42 := v41.Get() - v43 := lang.Apply(v42, []any{v10}) - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("list")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) - } - v46 := v45.Get() - v47 := lang.Apply(v46, []any{v15}) - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("list")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v16}) - v52 := lang.Apply(v39, []any{v43, v47, v51}) - v53 := lang.Apply(v36, []any{v52}) - v54 := lang.Apply(v33, []any{v53}) - v55 := lang.Apply(v22, []any{v26, v30, v54}) - v56 := lang.Apply(v19, []any{v55}) - return v56 + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("concat")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol(".")}) + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) + } + tmp42 := tmp41.Get() + tmp43 := lang.Apply(tmp42, []any{v10}) + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) + } + tmp46 := tmp45.Get() + tmp47 := lang.Apply(tmp46, []any{v15}) + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v16}) + tmp52 := lang.Apply(tmp39, []any{tmp43, tmp47, tmp51}) + tmp53 := lang.Apply(tmp36, []any{tmp52}) + tmp54 := lang.Apply(tmp33, []any{tmp53}) + tmp55 := lang.Apply(tmp22, []any{tmp26, tmp30, tmp54}) + tmp56 := lang.Apply(tmp19, []any{tmp55}) + return tmp56 }) - v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) - v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) + tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) if err != nil { panic(err) } - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("seq")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("concat")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("list")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("seq")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) - } - v36 := v35.Get() - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("concat")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("list")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) - } - v42 := v41.Get() - v43 := lang.Apply(v42, []any{v10}) - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("list")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) - } - v46 := v45.Get() - v47 := lang.Apply(v46, []any{v2}) - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("list")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v3}) - v52 := lang.Apply(v39, []any{v43, v47, v51}) - v53 := lang.Apply(v36, []any{v52}) - v54 := lang.Apply(v33, []any{v53}) - v55 := lang.Apply(v22, []any{v26, v30, v54}) - v56 := lang.Apply(v19, []any{v55}) - v57 := lang.Apply(v13, []any{v16, v56, v4}) - v5 = v57 + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("concat")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol(".")}) + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) + } + tmp42 := tmp41.Get() + tmp43 := lang.Apply(tmp42, []any{v10}) + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) + } + tmp46 := tmp45.Get() + tmp47 := lang.Apply(tmp46, []any{v2}) + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v3}) + tmp52 := lang.Apply(tmp39, []any{tmp43, tmp47, tmp51}) + tmp53 := lang.Apply(tmp36, []any{tmp52}) + tmp54 := lang.Apply(tmp33, []any{tmp53}) + tmp55 := lang.Apply(tmp22, []any{tmp26, tmp30, tmp54}) + tmp56 := lang.Apply(tmp19, []any{tmp55}) + tmp57 := lang.Apply(tmp13, []any{tmp16, tmp56, v4}) + tmp5 = tmp57 } // end let - return v5 + return tmp5 } }) - v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp1 = tmp1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") - if reflect.TypeOf(v4).Kind() != reflect.Func { + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - v5 := lang.Apply(v4, []any{nil, int64(1)}) - return v5 + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v0 := lang.NewSymbol("bit-and-not").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Bitwise and with complement", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1325), lang.NewKeyword("end-line"), int(1325))).(*lang.Symbol) - var v4 lang.FnFunc - v4 = lang.NewFnFunc(func(args ...any) any { + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp0 := lang.NewSymbol("bit-and-not").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Bitwise and with complement", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), tmp2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1325), lang.NewKeyword("end-line"), int(1325))).(*lang.Symbol) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 2: v5 := args[0] _ = v5 v6 := args[1] _ = v6 - v7, _ := lang.FieldOrMethod(lang.Numbers, "AndNot") - if reflect.TypeOf(v7).Kind() != reflect.Func { + tmp7, _ := lang.FieldOrMethod(lang.Numbers, "AndNot") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("AndNot is not a function"))) } - v8 := lang.Apply(v7, []any{v5, v6}) - return v8 + tmp8 := lang.Apply(tmp7, []any{v5, v6}) + return tmp8 default: if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -12993,41 +13038,42 @@ func init() { _ = v5 v6 := args[1] _ = v6 - v7 := lang.NewList(args[2:]...) - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + var v7 any = lang.NewList(args[2:]...) + _ = v7 + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("bit-and-not")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("bit-and-not")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) } - v13 := v12.Get() - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("bit-and-not")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + tmp13 := tmp12.Get() + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("bit-and-not")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{v5, v6}) - v18 := lang.Apply(v10, []any{v13, v17, v7}) - return v18 + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{v5, v6}) + tmp18 := lang.Apply(tmp10, []any{tmp13, tmp17, v7}) + return tmp18 } }) - v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v3 := ns.InternWithValue(v0, v4, true) - if v0.Meta() != nil { - v3.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 := ns.InternWithValue(tmp0, tmp4, true) + if tmp0.Meta() != nil { + tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // bit-clear { - v0 := lang.NewSymbol("bit-clear").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Clear bit at index n", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1336), lang.NewKeyword("end-line"), int(1336))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("bit-clear").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Clear bit at index n", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1336), lang.NewKeyword("end-line"), int(1336))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -13035,24 +13081,24 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5, _ := lang.FieldOrMethod(lang.Numbers, "ClearBit") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "ClearBit") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("ClearBit is not a function"))) } - v6 := lang.Apply(v5, []any{v3, v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // bit-flip { - v0 := lang.NewSymbol("bit-flip").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Flip bit at index n", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1348), lang.NewKeyword("end-line"), int(1348))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("bit-flip").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Flip bit at index n", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1348), lang.NewKeyword("end-line"), int(1348))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -13060,304 +13106,305 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5, _ := lang.FieldOrMethod(lang.Numbers, "FlipBit") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "FlipBit") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("FlipBit is not a function"))) } - v6 := lang.Apply(v5, []any{v3, v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // bit-not { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function bit-not__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("concat")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("list")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("seq")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("concat")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/Not")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{v3}) - v35 := lang.Apply(v26, []any{v30, v34}) - v36 := lang.Apply(v23, []any{v35}) - v37 := lang.Apply(v20, []any{v36}) - v38 := lang.Apply(v9, []any{v13, v17, v37}) - v39 := lang.Apply(v6, []any{v38}) - return v39 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/Not")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{v3}) + tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) + tmp36 := lang.Apply(tmp23, []any{tmp35}) + tmp37 := lang.Apply(tmp20, []any{tmp36}) + tmp38 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp37}) + tmp39 := lang.Apply(tmp6, []any{tmp38}) + return tmp39 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("bit-not").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Bitwise complement", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1291), lang.NewKeyword("end-line"), int(1291))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("bit-not").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Bitwise complement", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1291), lang.NewKeyword("end-line"), int(1291))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5, _ := lang.FieldOrMethod(lang.Numbers, "Not") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Not") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Not is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // bit-or { - var v1 lang.FnFunc - v1 = lang.NewFnFunc(func(args ...any) any { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v2 := args[0] _ = v2 - var v3 any + var tmp3 any { // let // let binding "op" - var v4 any - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - if lang.IsTruthy(v7) { - v4 = closed12 + var tmp4 any + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + if lang.IsTruthy(tmp7) { + tmp4 = closed12 } else { - v4 = closed12 + tmp4 = closed12 } - var v8 any = v4 + var v8 any = tmp4 _ = v8 - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("seq")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("concat")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("list")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("list")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("list")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("seq")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) - } - v28 := v27.Get() - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("concat")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("list")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{v8}) - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("list")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.Apply(v38, []any{v2}) - v40 := lang.Apply(v31, []any{v35, v39}) - v41 := lang.Apply(v28, []any{v40}) - v42 := lang.Apply(v25, []any{v41}) - v43 := lang.Apply(v14, []any{v18, v22, v42}) - v44 := lang.Apply(v11, []any{v43}) - v3 = v44 + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("seq")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("concat")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol(".")}) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("seq")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) + } + tmp28 := tmp27.Get() + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("concat")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.Apply(tmp34, []any{v8}) + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{v2}) + tmp40 := lang.Apply(tmp31, []any{tmp35, tmp39}) + tmp41 := lang.Apply(tmp28, []any{tmp40}) + tmp42 := lang.Apply(tmp25, []any{tmp41}) + tmp43 := lang.Apply(tmp14, []any{tmp18, tmp22, tmp42}) + tmp44 := lang.Apply(tmp11, []any{tmp43}) + tmp3 = tmp44 } // end let - return v3 + return tmp3 case 2: v2 := args[0] _ = v2 v3 := args[1] _ = v3 - var v4 any + var tmp4 any { // let // let binding "op" - var v5 any - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - if lang.IsTruthy(v8) { - v5 = closed12 + var tmp5 any + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + if lang.IsTruthy(tmp8) { + tmp5 = closed12 } else { - v5 = closed12 + tmp5 = closed12 } - var v9 any = v5 + var v9 any = tmp5 _ = v9 - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("seq")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("concat")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("list")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("list")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("list")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("seq")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("concat")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) - } - v32 := v31.Get() - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("list")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - v36 := lang.Apply(v35, []any{v9}) - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("list")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.Apply(v39, []any{v2}) - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("list")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) - } - v43 := v42.Get() - v44 := lang.Apply(v43, []any{v3}) - v45 := lang.Apply(v32, []any{v36, v40, v44}) - v46 := lang.Apply(v29, []any{v45}) - v47 := lang.Apply(v26, []any{v46}) - v48 := lang.Apply(v15, []any{v19, v23, v47}) - v49 := lang.Apply(v12, []any{v48}) - v4 = v49 + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("seq")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("concat")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("list")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{lang.NewSymbol(".")}) + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("list")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.Apply(tmp22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("list")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("seq")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("concat")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) + } + tmp32 := tmp31.Get() + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("list")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) + } + tmp35 := tmp34.Get() + tmp36 := lang.Apply(tmp35, []any{v9}) + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("list")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.Apply(tmp39, []any{v2}) + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("list")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := lang.Apply(tmp43, []any{v3}) + tmp45 := lang.Apply(tmp32, []any{tmp36, tmp40, tmp44}) + tmp46 := lang.Apply(tmp29, []any{tmp45}) + tmp47 := lang.Apply(tmp26, []any{tmp46}) + tmp48 := lang.Apply(tmp15, []any{tmp19, tmp23, tmp47}) + tmp49 := lang.Apply(tmp12, []any{tmp48}) + tmp4 = tmp49 } // end let - return v4 + return tmp4 default: if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -13366,32 +13413,33 @@ func init() { _ = v2 v3 := args[1] _ = v3 - v4 := lang.NewList(args[2:]...) - var v5 any + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any { // let // let binding "op" - var v6 any - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - if lang.IsTruthy(v9) { - v6 = closed12 + var tmp6 any + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + if lang.IsTruthy(tmp9) { + tmp6 = closed12 } else { - v6 = closed12 + tmp6 = closed12 } - var v10 any = v6 + var v10 any = tmp6 _ = v10 - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - var v14 lang.FnFunc - v14 = lang.NewFnFunc(func(args ...any) any { + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -13399,190 +13447,190 @@ func init() { _ = v15 v16 := args[1] _ = v16 - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("seq")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("concat")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("list")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("seq")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) - } - v36 := v35.Get() - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("concat")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("list")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) - } - v42 := v41.Get() - v43 := lang.Apply(v42, []any{v10}) - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("list")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) - } - v46 := v45.Get() - v47 := lang.Apply(v46, []any{v15}) - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("list")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v16}) - v52 := lang.Apply(v39, []any{v43, v47, v51}) - v53 := lang.Apply(v36, []any{v52}) - v54 := lang.Apply(v33, []any{v53}) - v55 := lang.Apply(v22, []any{v26, v30, v54}) - v56 := lang.Apply(v19, []any{v55}) - return v56 + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("concat")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol(".")}) + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) + } + tmp42 := tmp41.Get() + tmp43 := lang.Apply(tmp42, []any{v10}) + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) + } + tmp46 := tmp45.Get() + tmp47 := lang.Apply(tmp46, []any{v15}) + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v16}) + tmp52 := lang.Apply(tmp39, []any{tmp43, tmp47, tmp51}) + tmp53 := lang.Apply(tmp36, []any{tmp52}) + tmp54 := lang.Apply(tmp33, []any{tmp53}) + tmp55 := lang.Apply(tmp22, []any{tmp26, tmp30, tmp54}) + tmp56 := lang.Apply(tmp19, []any{tmp55}) + return tmp56 }) - v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) - v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) + tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) if err != nil { panic(err) } - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("seq")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("concat")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("list")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("seq")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) - } - v36 := v35.Get() - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("concat")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("list")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) - } - v42 := v41.Get() - v43 := lang.Apply(v42, []any{v10}) - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("list")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) - } - v46 := v45.Get() - v47 := lang.Apply(v46, []any{v2}) - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("list")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v3}) - v52 := lang.Apply(v39, []any{v43, v47, v51}) - v53 := lang.Apply(v36, []any{v52}) - v54 := lang.Apply(v33, []any{v53}) - v55 := lang.Apply(v22, []any{v26, v30, v54}) - v56 := lang.Apply(v19, []any{v55}) - v57 := lang.Apply(v13, []any{v16, v56, v4}) - v5 = v57 + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("concat")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol(".")}) + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) + } + tmp42 := tmp41.Get() + tmp43 := lang.Apply(tmp42, []any{v10}) + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) + } + tmp46 := tmp45.Get() + tmp47 := lang.Apply(tmp46, []any{v2}) + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v3}) + tmp52 := lang.Apply(tmp39, []any{tmp43, tmp47, tmp51}) + tmp53 := lang.Apply(tmp36, []any{tmp52}) + tmp54 := lang.Apply(tmp33, []any{tmp53}) + tmp55 := lang.Apply(tmp22, []any{tmp26, tmp30, tmp54}) + tmp56 := lang.Apply(tmp19, []any{tmp55}) + tmp57 := lang.Apply(tmp13, []any{tmp16, tmp56, v4}) + tmp5 = tmp57 } // end let - return v5 + return tmp5 } }) - v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp1 = tmp1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") - if reflect.TypeOf(v4).Kind() != reflect.Func { + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - v5 := lang.Apply(v4, []any{nil, int64(1)}) - return v5 + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v0 := lang.NewSymbol("bit-or").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Bitwise or", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1307), lang.NewKeyword("end-line"), int(1307))).(*lang.Symbol) - var v4 lang.FnFunc - v4 = lang.NewFnFunc(func(args ...any) any { + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp0 := lang.NewSymbol("bit-or").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Bitwise or", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), tmp2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1307), lang.NewKeyword("end-line"), int(1307))).(*lang.Symbol) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 2: v5 := args[0] _ = v5 v6 := args[1] _ = v6 - v7, _ := lang.FieldOrMethod(lang.Numbers, "Or") - if reflect.TypeOf(v7).Kind() != reflect.Func { + tmp7, _ := lang.FieldOrMethod(lang.Numbers, "Or") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Or is not a function"))) } - v8 := lang.Apply(v7, []any{v5, v6}) - return v8 + tmp8 := lang.Apply(tmp7, []any{v5, v6}) + return tmp8 default: if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -13591,41 +13639,42 @@ func init() { _ = v5 v6 := args[1] _ = v6 - v7 := lang.NewList(args[2:]...) - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + var v7 any = lang.NewList(args[2:]...) + _ = v7 + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("bit-or")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("bit-or")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) } - v13 := v12.Get() - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("bit-or")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + tmp13 := tmp12.Get() + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("bit-or")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{v5, v6}) - v18 := lang.Apply(v10, []any{v13, v17, v7}) - return v18 + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{v5, v6}) + tmp18 := lang.Apply(tmp10, []any{tmp13, tmp17, v7}) + return tmp18 } }) - v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v3 := ns.InternWithValue(v0, v4, true) - if v0.Meta() != nil { - v3.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 := ns.InternWithValue(tmp0, tmp4, true) + if tmp0.Meta() != nil { + tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // bit-set { - v0 := lang.NewSymbol("bit-set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Set bit at index n", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1342), lang.NewKeyword("end-line"), int(1342))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("bit-set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Set bit at index n", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1342), lang.NewKeyword("end-line"), int(1342))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -13633,24 +13682,25 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5, _ := lang.FieldOrMethod(lang.Numbers, "SetBit") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "SetBit") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("SetBit is not a function"))) } - v6 := lang.Apply(v5, []any{v3, v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // bit-shift-left { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function bit-shift-left__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -13658,84 +13708,84 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("seq")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("concat")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("list")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("list")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("list")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("seq")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("concat")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("list")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/ShiftLeft")}) - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("list")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{v3}) - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("list")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.Apply(v38, []any{v4}) - v40 := lang.Apply(v27, []any{v31, v35, v39}) - v41 := lang.Apply(v24, []any{v40}) - v42 := lang.Apply(v21, []any{v41}) - v43 := lang.Apply(v10, []any{v14, v18, v42}) - v44 := lang.Apply(v7, []any{v43}) - return v44 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("concat")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("list")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol(".")}) + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("seq")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("concat")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("list")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.Apply(tmp30, []any{lang.NewSymbol("glojure.core/ShiftLeft")}) + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.Apply(tmp34, []any{v3}) + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{v4}) + tmp40 := lang.Apply(tmp27, []any{tmp31, tmp35, tmp39}) + tmp41 := lang.Apply(tmp24, []any{tmp40}) + tmp42 := lang.Apply(tmp21, []any{tmp41}) + tmp43 := lang.Apply(tmp10, []any{tmp14, tmp18, tmp42}) + tmp44 := lang.Apply(tmp7, []any{tmp43}) + return tmp44 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("bit-shift-left").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Bitwise shift left", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1361), lang.NewKeyword("end-line"), int(1361))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("bit-shift-left").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Bitwise shift left", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1361), lang.NewKeyword("end-line"), int(1361))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -13743,24 +13793,25 @@ func init() { _ = v4 v5 := args[1] _ = v5 - v6, _ := lang.FieldOrMethod(lang.Numbers, "ShiftLeft") - if reflect.TypeOf(v6).Kind() != reflect.Func { + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "ShiftLeft") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("ShiftLeft is not a function"))) } - v7 := lang.Apply(v6, []any{v4, v5}) - return v7 + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // bit-shift-right { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function bit-shift-right__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -13768,84 +13819,84 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("seq")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("concat")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("list")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("list")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("list")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("seq")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("concat")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("list")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/ShiftRight")}) - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("list")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{v3}) - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("list")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.Apply(v38, []any{v4}) - v40 := lang.Apply(v27, []any{v31, v35, v39}) - v41 := lang.Apply(v24, []any{v40}) - v42 := lang.Apply(v21, []any{v41}) - v43 := lang.Apply(v10, []any{v14, v18, v42}) - v44 := lang.Apply(v7, []any{v43}) - return v44 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("concat")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("list")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol(".")}) + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("seq")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("concat")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("list")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.Apply(tmp30, []any{lang.NewSymbol("glojure.core/ShiftRight")}) + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.Apply(tmp34, []any{v3}) + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{v4}) + tmp40 := lang.Apply(tmp27, []any{tmp31, tmp35, tmp39}) + tmp41 := lang.Apply(tmp24, []any{tmp40}) + tmp42 := lang.Apply(tmp21, []any{tmp41}) + tmp43 := lang.Apply(tmp10, []any{tmp14, tmp18, tmp42}) + tmp44 := lang.Apply(tmp7, []any{tmp43}) + return tmp44 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("bit-shift-right").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Bitwise shift right", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1367), lang.NewKeyword("end-line"), int(1367))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("bit-shift-right").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Bitwise shift right", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1367), lang.NewKeyword("end-line"), int(1367))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -13853,24 +13904,24 @@ func init() { _ = v4 v5 := args[1] _ = v5 - v6, _ := lang.FieldOrMethod(lang.Numbers, "ShiftRight") - if reflect.TypeOf(v6).Kind() != reflect.Func { + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "ShiftRight") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("ShiftRight is not a function"))) } - v7 := lang.Apply(v6, []any{v4, v5}) - return v7 + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // bit-test { - v0 := lang.NewSymbol("bit-test").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Test bit at index n", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1354), lang.NewKeyword("end-line"), int(1354))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("bit-test").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Test bit at index n", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1354), lang.NewKeyword("end-line"), int(1354))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -13878,205 +13929,205 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5, _ := lang.FieldOrMethod(lang.Numbers, "TestBit") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "TestBit") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("TestBit is not a function"))) } - v6 := lang.Apply(v5, []any{v3, v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // bit-xor { - var v1 lang.FnFunc - v1 = lang.NewFnFunc(func(args ...any) any { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v2 := args[0] _ = v2 - var v3 any + var tmp3 any { // let // let binding "op" - var v4 any - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - if lang.IsTruthy(v7) { - v4 = closed13 + var tmp4 any + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + if lang.IsTruthy(tmp7) { + tmp4 = closed13 } else { - v4 = closed13 + tmp4 = closed13 } - var v8 any = v4 + var v8 any = tmp4 _ = v8 - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("seq")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("concat")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("list")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("list")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("list")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("seq")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) - } - v28 := v27.Get() - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("concat")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("list")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{v8}) - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("list")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.Apply(v38, []any{v2}) - v40 := lang.Apply(v31, []any{v35, v39}) - v41 := lang.Apply(v28, []any{v40}) - v42 := lang.Apply(v25, []any{v41}) - v43 := lang.Apply(v14, []any{v18, v22, v42}) - v44 := lang.Apply(v11, []any{v43}) - v3 = v44 + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("seq")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("concat")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol(".")}) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("seq")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) + } + tmp28 := tmp27.Get() + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("concat")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.Apply(tmp34, []any{v8}) + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{v2}) + tmp40 := lang.Apply(tmp31, []any{tmp35, tmp39}) + tmp41 := lang.Apply(tmp28, []any{tmp40}) + tmp42 := lang.Apply(tmp25, []any{tmp41}) + tmp43 := lang.Apply(tmp14, []any{tmp18, tmp22, tmp42}) + tmp44 := lang.Apply(tmp11, []any{tmp43}) + tmp3 = tmp44 } // end let - return v3 + return tmp3 case 2: v2 := args[0] _ = v2 v3 := args[1] _ = v3 - var v4 any + var tmp4 any { // let // let binding "op" - var v5 any - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - if lang.IsTruthy(v8) { - v5 = closed13 + var tmp5 any + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + if lang.IsTruthy(tmp8) { + tmp5 = closed13 } else { - v5 = closed13 + tmp5 = closed13 } - var v9 any = v5 + var v9 any = tmp5 _ = v9 - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("seq")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("concat")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("list")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("list")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("list")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("seq")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("concat")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) - } - v32 := v31.Get() - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("list")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - v36 := lang.Apply(v35, []any{v9}) - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("list")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.Apply(v39, []any{v2}) - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("list")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) - } - v43 := v42.Get() - v44 := lang.Apply(v43, []any{v3}) - v45 := lang.Apply(v32, []any{v36, v40, v44}) - v46 := lang.Apply(v29, []any{v45}) - v47 := lang.Apply(v26, []any{v46}) - v48 := lang.Apply(v15, []any{v19, v23, v47}) - v49 := lang.Apply(v12, []any{v48}) - v4 = v49 + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("seq")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("concat")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("list")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{lang.NewSymbol(".")}) + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("list")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.Apply(tmp22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("list")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("seq")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("concat")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) + } + tmp32 := tmp31.Get() + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("list")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) + } + tmp35 := tmp34.Get() + tmp36 := lang.Apply(tmp35, []any{v9}) + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("list")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.Apply(tmp39, []any{v2}) + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("list")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := lang.Apply(tmp43, []any{v3}) + tmp45 := lang.Apply(tmp32, []any{tmp36, tmp40, tmp44}) + tmp46 := lang.Apply(tmp29, []any{tmp45}) + tmp47 := lang.Apply(tmp26, []any{tmp46}) + tmp48 := lang.Apply(tmp15, []any{tmp19, tmp23, tmp47}) + tmp49 := lang.Apply(tmp12, []any{tmp48}) + tmp4 = tmp49 } // end let - return v4 + return tmp4 default: if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -14085,32 +14136,33 @@ func init() { _ = v2 v3 := args[1] _ = v3 - v4 := lang.NewList(args[2:]...) - var v5 any + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any { // let // let binding "op" - var v6 any - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - if lang.IsTruthy(v9) { - v6 = closed13 + var tmp6 any + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + if lang.IsTruthy(tmp9) { + tmp6 = closed13 } else { - v6 = closed13 + tmp6 = closed13 } - var v10 any = v6 + var v10 any = tmp6 _ = v10 - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - var v14 lang.FnFunc - v14 = lang.NewFnFunc(func(args ...any) any { + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -14118,190 +14170,190 @@ func init() { _ = v15 v16 := args[1] _ = v16 - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("seq")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("concat")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("list")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("seq")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) - } - v36 := v35.Get() - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("concat")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("list")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) - } - v42 := v41.Get() - v43 := lang.Apply(v42, []any{v10}) - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("list")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) - } - v46 := v45.Get() - v47 := lang.Apply(v46, []any{v15}) - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("list")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v16}) - v52 := lang.Apply(v39, []any{v43, v47, v51}) - v53 := lang.Apply(v36, []any{v52}) - v54 := lang.Apply(v33, []any{v53}) - v55 := lang.Apply(v22, []any{v26, v30, v54}) - v56 := lang.Apply(v19, []any{v55}) - return v56 + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("concat")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol(".")}) + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) + } + tmp42 := tmp41.Get() + tmp43 := lang.Apply(tmp42, []any{v10}) + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) + } + tmp46 := tmp45.Get() + tmp47 := lang.Apply(tmp46, []any{v15}) + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v16}) + tmp52 := lang.Apply(tmp39, []any{tmp43, tmp47, tmp51}) + tmp53 := lang.Apply(tmp36, []any{tmp52}) + tmp54 := lang.Apply(tmp33, []any{tmp53}) + tmp55 := lang.Apply(tmp22, []any{tmp26, tmp30, tmp54}) + tmp56 := lang.Apply(tmp19, []any{tmp55}) + return tmp56 }) - v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) - v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) + tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) if err != nil { panic(err) } - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("seq")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("concat")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("list")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("seq")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) - } - v36 := v35.Get() - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("concat")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("list")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) - } - v42 := v41.Get() - v43 := lang.Apply(v42, []any{v10}) - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("list")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) - } - v46 := v45.Get() - v47 := lang.Apply(v46, []any{v2}) - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("list")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v3}) - v52 := lang.Apply(v39, []any{v43, v47, v51}) - v53 := lang.Apply(v36, []any{v52}) - v54 := lang.Apply(v33, []any{v53}) - v55 := lang.Apply(v22, []any{v26, v30, v54}) - v56 := lang.Apply(v19, []any{v55}) - v57 := lang.Apply(v13, []any{v16, v56, v4}) - v5 = v57 + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("concat")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol(".")}) + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) + } + tmp42 := tmp41.Get() + tmp43 := lang.Apply(tmp42, []any{v10}) + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) + } + tmp46 := tmp45.Get() + tmp47 := lang.Apply(tmp46, []any{v2}) + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v3}) + tmp52 := lang.Apply(tmp39, []any{tmp43, tmp47, tmp51}) + tmp53 := lang.Apply(tmp36, []any{tmp52}) + tmp54 := lang.Apply(tmp33, []any{tmp53}) + tmp55 := lang.Apply(tmp22, []any{tmp26, tmp30, tmp54}) + tmp56 := lang.Apply(tmp19, []any{tmp55}) + tmp57 := lang.Apply(tmp13, []any{tmp16, tmp56, v4}) + tmp5 = tmp57 } // end let - return v5 + return tmp5 } }) - v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp1 = tmp1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") - if reflect.TypeOf(v4).Kind() != reflect.Func { + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - v5 := lang.Apply(v4, []any{nil, int64(1)}) - return v5 + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v0 := lang.NewSymbol("bit-xor").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Bitwise exclusive or", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1316), lang.NewKeyword("end-line"), int(1316))).(*lang.Symbol) - var v4 lang.FnFunc - v4 = lang.NewFnFunc(func(args ...any) any { + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp0 := lang.NewSymbol("bit-xor").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Bitwise exclusive or", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), tmp2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1316), lang.NewKeyword("end-line"), int(1316))).(*lang.Symbol) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 2: v5 := args[0] _ = v5 v6 := args[1] _ = v6 - v7, _ := lang.FieldOrMethod(lang.Numbers, "Xor") - if reflect.TypeOf(v7).Kind() != reflect.Func { + tmp7, _ := lang.FieldOrMethod(lang.Numbers, "Xor") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Xor is not a function"))) } - v8 := lang.Apply(v7, []any{v5, v6}) - return v8 + tmp8 := lang.Apply(tmp7, []any{v5, v6}) + return tmp8 default: if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -14310,364 +14362,369 @@ func init() { _ = v5 v6 := args[1] _ = v6 - v7 := lang.NewList(args[2:]...) - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + var v7 any = lang.NewList(args[2:]...) + _ = v7 + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("bit-xor")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("bit-xor")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) } - v13 := v12.Get() - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("bit-xor")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + tmp13 := tmp12.Get() + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("bit-xor")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{v5, v6}) - v18 := lang.Apply(v10, []any{v13, v17, v7}) - return v18 + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{v5, v6}) + tmp18 := lang.Apply(tmp10, []any{tmp13, tmp17, v7}) + return tmp18 } }) - v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v3 := ns.InternWithValue(v0, v4, true) - if v0.Meta() != nil { - v3.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 := ns.InternWithValue(tmp0, tmp4, true) + if tmp0.Meta() != nil { + tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // boolean { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function boolean__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("concat")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("list")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("seq")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("concat")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/BooleanCast")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{v3}) - v35 := lang.Apply(v26, []any{v30, v34}) - v36 := lang.Apply(v23, []any{v35}) - v37 := lang.Apply(v20, []any{v36}) - v38 := lang.Apply(v9, []any{v13, v17, v37}) - v39 := lang.Apply(v6, []any{v38}) - return v39 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/BooleanCast")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{v3}) + tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) + tmp36 := lang.Apply(tmp23, []any{tmp35}) + tmp37 := lang.Apply(tmp20, []any{tmp36}) + tmp38 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp37}) + tmp39 := lang.Apply(tmp6, []any{tmp38}) + return tmp39 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("boolean").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to boolean", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1601), lang.NewKeyword("end-line"), int(1601))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("boolean").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to boolean", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1601), lang.NewKeyword("end-line"), int(1601))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5, _ := lang.FieldOrMethod(runtime4.RT, "BooleanCast") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(runtime4.RT, "BooleanCast") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("BooleanCast is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // boolean-array { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function boolean-array__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v3 := lang.NewList(args[0:]...) - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("concat")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("list")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/BooleanArray")}) - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("list")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("seq")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("concat")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) - v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v36 := v35.FindInternedVar(lang.NewSymbol("list")) - if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) - } - v37 := v36.Get() - v38 := lang.Apply(v37, []any{lang.NewSymbol("glojure.core/args")}) - v39 := lang.Apply(v30, []any{v34, v38}) - v40 := lang.Apply(v27, []any{v39}) - v41 := lang.Apply(v24, []any{v40}) - v42 := lang.Apply(v9, []any{v13, v17, v21, v41}) - v43 := lang.Apply(v6, []any{v42}) - return v43 + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.Apply(tmp20, []any{lang.NewSymbol("glojure.core/BooleanArray")}) + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("list")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("seq")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("concat")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) + tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp36 := tmp35.FindInternedVar(lang.NewSymbol("list")) + if tmp36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) + } + tmp37 := tmp36.Get() + tmp38 := lang.Apply(tmp37, []any{lang.NewSymbol("glojure.core/args")}) + tmp39 := lang.Apply(tmp30, []any{tmp34, tmp38}) + tmp40 := lang.Apply(tmp27, []any{tmp39}) + tmp41 := lang.Apply(tmp24, []any{tmp40}) + tmp42 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp21, tmp41}) + tmp43 := lang.Apply(tmp6, []any{tmp42}) + return tmp43 } }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("boolean-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Creates an array of booleans", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1), int64(2)), lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5309), lang.NewKeyword("end-line"), int(5309))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("boolean-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Creates an array of booleans", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5309), lang.NewKeyword("end-line"), int(5309))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v4 := args[0] _ = v4 - v5, _ := lang.FieldOrMethod(lang.Numbers, "BooleanArray") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "BooleanArray") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("BooleanArray is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 case 2: v4 := args[0] _ = v4 v5 := args[1] _ = v5 - v6, _ := lang.FieldOrMethod(lang.Numbers, "BooleanArrayInit") - if reflect.TypeOf(v6).Kind() != reflect.Func { + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "BooleanArrayInit") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("BooleanArrayInit is not a function"))) } - v7 := lang.Apply(v6, []any{v4, v5}) - return v7 + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // boolean? { - v0 := lang.NewSymbol("boolean?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a Boolean", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(518), lang.NewKeyword("end-line"), int(518))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("boolean?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a Boolean", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(518), lang.NewKeyword("end-line"), int(518))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) } - v6 := v5.Get() - v7 := lang.Apply(v6, []any{lang.Builtins["bool"], v3}) - return v7 + tmp6 := tmp5.Get() + tmp7 := lang.Apply(tmp6, []any{lang.Builtins["bool"], v3}) + return tmp7 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // booleans { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function booleans - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("concat")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("list")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/Booleans")}) - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("list")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v3}) - v26 := lang.Apply(v9, []any{v13, v17, v21, v25}) - v27 := lang.Apply(v6, []any{v26}) - return v27 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.Apply(tmp20, []any{lang.NewSymbol("glojure.core/Booleans")}) + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("list")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.Apply(tmp24, []any{v3}) + tmp26 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp21, tmp25}) + tmp27 := lang.Apply(tmp6, []any{tmp26}) + return tmp27 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("booleans").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Casts to boolean[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5372), lang.NewKeyword("end-line"), int(5372))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("booleans").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Casts to boolean[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5372), lang.NewKeyword("end-line"), int(5372))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5, _ := lang.FieldOrMethod(lang.Numbers, "Booleans") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Booleans") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Booleans is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // bound-fn { - v0 := lang.NewSymbol("bound-fn").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("fntail"))), lang.NewKeyword("doc"), "Returns a function defined by the given fntail, which will install the\n same bindings in effect as in the thread at the time bound-fn was called.\n This may be used to define a helper function which runs on a different\n thread, but needs the same bindings in place.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(2004), lang.NewKeyword("end-line"), int(2004))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("bound-fn").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("fntail"))), lang.NewKeyword("doc"), "Returns a function defined by the given fntail, which will install the\n same bindings in effect as in the thread at the time bound-fn was called.\n This may be used to define a helper function which runs on a different\n thread, but needs the same bindings in place.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(2004), lang.NewKeyword("end-line"), int(2004))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 2 { @@ -14677,183 +14734,186 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.NewList(args[2:]...) - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("seq")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("concat")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("list")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.Apply(v14, []any{lang.NewSymbol("glojure.core/bound-fn*")}) - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("list")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("seq")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("concat")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("list")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.Apply(v27, []any{lang.NewSymbol("glojure.core/fn")}) - v29 := lang.Apply(v24, []any{v28, v5}) - v30 := lang.Apply(v21, []any{v29}) - v31 := lang.Apply(v18, []any{v30}) - v32 := lang.Apply(v11, []any{v15, v31}) - v33 := lang.Apply(v8, []any{v32}) - return v33 - } - }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("seq")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("concat")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("list")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("glojure.core/bound-fn*")}) + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("list")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("seq")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("concat")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("list")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.Apply(tmp27, []any{lang.NewSymbol("glojure.core/fn")}) + tmp29 := lang.Apply(tmp24, []any{tmp28, v5}) + tmp30 := lang.Apply(tmp21, []any{tmp29}) + tmp31 := lang.Apply(tmp18, []any{tmp30}) + tmp32 := lang.Apply(tmp11, []any{tmp15, tmp31}) + tmp33 := lang.Apply(tmp8, []any{tmp32}) + return tmp33 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // bound-fn* { - v0 := lang.NewSymbol("bound-fn*").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Returns a function, which will install the same bindings in effect as in\n the thread at the time bound-fn* was called and then call f with any given\n arguments. This may be used to define a helper function which runs on a\n different thread, but needs the same bindings in place.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1992), lang.NewKeyword("end-line"), int(1992))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("bound-fn*").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Returns a function, which will install the same bindings in effect as in\n the thread at the time bound-fn* was called and then call f with any given\n arguments. This may be used to define a helper function which runs on a\n different thread, but needs the same bindings in place.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1992), lang.NewKeyword("end-line"), int(1992))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any + var tmp4 any { // let // let binding "bindings" - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("get-thread-bindings")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, nil) - var v9 any = v8 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("get-thread-bindings")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, nil) + var v9 any = tmp8 _ = v9 - var v10 lang.FnFunc - v10 = lang.NewFnFunc(func(args ...any) any { + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v11 := lang.NewList(args[0:]...) - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("apply")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + var v11 any = lang.NewList(args[0:]...) + _ = v11 + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("apply")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) } - v14 := v13.Get() - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("with-bindings*")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + tmp14 := tmp13.Get() + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("with-bindings*")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) } - v17 := v16.Get() - v18 := lang.Apply(v14, []any{v17, v9, v3, v11}) - return v18 + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp14, []any{tmp17, v9, v3, v11}) + return tmp18 } }) - v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2001), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2002), lang.NewKeyword("end-column"), int(45)) - v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) + tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2001), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2002), lang.NewKeyword("end-column"), int(45)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) if err != nil { panic(err) } - v4 = v12 + tmp4 = tmp12 } // end let - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // bound? { - v0 := lang.NewSymbol("bound?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("vars"))), lang.NewKeyword("doc"), "Returns true if all of the vars provided as arguments have any bound value, root or thread-local.\n Implies that deref'ing the provided vars will succeed. Returns true if no vars are provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5491), lang.NewKeyword("end-line"), int(5491))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("bound?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("vars"))), lang.NewKeyword("doc"), "Returns true if all of the vars provided as arguments have any bound value, root or thread-local.\n Implies that deref'ing the provided vars will succeed. Returns true if no vars are provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5491), lang.NewKeyword("end-line"), int(5491))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v3 := lang.NewList(args[0:]...) - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("every?")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - var v7 lang.FnFunc - v7 = lang.NewFnFunc(func(args ...any) any { + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("every?")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v8 := args[0] _ = v8 - v9, ok := lang.FieldOrMethod(v8, "isBound") + tmp9, ok := lang.FieldOrMethod(v8, "isBound") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "isBound"))) } - var v10 any - switch reflect.TypeOf(v9).Kind() { + var tmp10 any + switch reflect.TypeOf(tmp9).Kind() { case reflect.Func: - v10 = lang.Apply(v9, nil) + tmp10 = lang.Apply(tmp9, nil) default: - v10 = v9 + tmp10 = tmp9 } - return v10 + return tmp10 }) - v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5497), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5497), lang.NewKeyword("end-column"), int(69)) - v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) + tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5497), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5497), lang.NewKeyword("end-column"), int(69)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) if err != nil { panic(err) } - v10 := lang.Apply(v6, []any{v9, v3}) - return v10 + tmp10 := lang.Apply(tmp6, []any{tmp9, v3}) + return tmp10 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // bounded-count { - v0 := lang.NewSymbol("bounded-count").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "If coll is counted? returns its count, else will count at most the first n\n elements of coll using its seq", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7410), lang.NewKeyword("end-line"), int(7410))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("bounded-count").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "If coll is counted? returns its count, else will count at most the first n\n elements of coll using its seq", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7410), lang.NewKeyword("end-line"), int(7410))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -14861,551 +14921,556 @@ func init() { _ = v3 v4 := args[1] _ = v4 - var v5 any - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("counted?")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{v4}) - if lang.IsTruthy(v9) { - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("count")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{v4}) - v5 = v13 + var tmp5 any + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("counted?")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.Apply(tmp8, []any{v4}) + if lang.IsTruthy(tmp9) { + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("count")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{v4}) + tmp5 = tmp13 } else { - var v14 any + var tmp14 any { // let // let binding "i" var v15 any = int64(0) _ = v15 // let binding "s" - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("seq")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{v4}) - var v20 any = v19 + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("seq")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{v4}) + var v20 any = tmp19 _ = v20 for { - var v21 any - var v22 any + var tmp21 any + var tmp22 any { // let // let binding "and__0__auto__" var v23 any = v20 _ = v23 - var v24 any + var tmp24 any if lang.IsTruthy(v23) { - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("<")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("<")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) } - v27 := v26.Get() - v28 := lang.Apply(v27, []any{v15, v3}) - v24 = v28 + tmp27 := tmp26.Get() + tmp28 := lang.Apply(tmp27, []any{v15, v3}) + tmp24 = tmp28 } else { - v24 = v23 + tmp24 = v23 } - v22 = v24 + tmp22 = tmp24 } // end let - if lang.IsTruthy(v22) { - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("inc")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.Apply(v26, []any{v15}) - var v23 any = v27 - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("next")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.Apply(v31, []any{v20}) - var v28 any = v32 - v15 = v23 - v20 = v28 + if lang.IsTruthy(tmp22) { + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("inc")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.Apply(tmp26, []any{v15}) + var tmp23 any = tmp27 + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("next")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.Apply(tmp31, []any{v20}) + var tmp28 any = tmp32 + v15 = tmp23 + v20 = tmp28 continue } else { - v21 = v15 + tmp21 = v15 } - v14 = v21 + tmp14 = tmp21 break } } // end let - v5 = v14 + tmp5 = tmp14 } - return v5 + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // butlast { - v0 := lang.NewSymbol("butlast").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return a seq of all but the last item in coll, in linear time", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(272), lang.NewKeyword("end-line"), int(276))).(*lang.Symbol) - var v2 lang.FnFunc + tmp0 := lang.NewSymbol("butlast").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return a seq of all but the last item in coll, in linear time", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(272), lang.NewKeyword("end-line"), int(276))).(*lang.Symbol) + var tmp2 lang.FnFunc { // function butlast - v2 = lang.NewFnFunc(func(args ...any) any { + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - var v5 any + var tmp5 any { // let // let binding "ret" - v6 := lang.NewVector() - v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(277), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(277), lang.NewKeyword("end-column"), int(24)) - v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) + tmp6 := lang.NewVector() + tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(277), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(277), lang.NewKeyword("end-column"), int(24)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) if err != nil { panic(err) } - var v9 any = v8 + var v9 any = tmp8 _ = v9 // let binding "s" var v10 any = v4 _ = v10 for { - var v11 any - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("next")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.Apply(v14, []any{v10}) - if lang.IsTruthy(v15) { - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("conj")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("first")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.Apply(v22, []any{v10}) - v24 := lang.Apply(v19, []any{v9, v23}) - var v16 any = v24 - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("next")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) - } - v28 := v27.Get() - v29 := lang.Apply(v28, []any{v10}) - var v25 any = v29 - v9 = v16 - v10 = v25 + var tmp11 any + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("next")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.Apply(tmp14, []any{v10}) + if lang.IsTruthy(tmp15) { + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("conj")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("first")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.Apply(tmp22, []any{v10}) + tmp24 := lang.Apply(tmp19, []any{v9, tmp23}) + var tmp16 any = tmp24 + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("next")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) + } + tmp28 := tmp27.Get() + tmp29 := lang.Apply(tmp28, []any{v10}) + var tmp25 any = tmp29 + v9 = tmp16 + v10 = tmp25 continue } else { - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("seq")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("seq")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) } - v32 := v31.Get() - v33 := lang.Apply(v32, []any{v9}) - v11 = v33 + tmp32 := tmp31.Get() + tmp33 := lang.Apply(tmp32, []any{v9}) + tmp11 = tmp33 } - v5 = v11 + tmp5 = tmp11 break } } // end let - return v5 + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(276), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(280), lang.NewKeyword("end-column"), int(27))).(lang.FnFunc) - v3 := v2 + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(276), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(280), lang.NewKeyword("end-column"), int(27))).(lang.FnFunc) + v3 = tmp2 _ = v3 } - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // byte { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function byte__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("concat")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("list")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("seq")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("concat")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - var v30 any - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - if lang.IsTruthy(v33) { - v30 = lang.NewSymbol("uncheckedByteCast") + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + var tmp30 any + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + if lang.IsTruthy(tmp33) { + tmp30 = lang.NewSymbol("uncheckedByteCast") } else { - v30 = lang.NewSymbol("byteCast") - } - v34 := lang.Apply(v29, []any{v30}) - v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v36 := v35.FindInternedVar(lang.NewSymbol("list")) - if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) - } - v37 := v36.Get() - v38 := lang.Apply(v37, []any{v3}) - v39 := lang.Apply(v26, []any{v34, v38}) - v40 := lang.Apply(v23, []any{v39}) - v41 := lang.Apply(v20, []any{v40}) - v42 := lang.Apply(v9, []any{v13, v17, v41}) - v43 := lang.Apply(v6, []any{v42}) - return v43 + tmp30 = lang.NewSymbol("byteCast") + } + tmp34 := lang.Apply(tmp29, []any{tmp30}) + tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp36 := tmp35.FindInternedVar(lang.NewSymbol("list")) + if tmp36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) + } + tmp37 := tmp36.Get() + tmp38 := lang.Apply(tmp37, []any{v3}) + tmp39 := lang.Apply(tmp26, []any{tmp34, tmp38}) + tmp40 := lang.Apply(tmp23, []any{tmp39}) + tmp41 := lang.Apply(tmp20, []any{tmp40}) + tmp42 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp41}) + tmp43 := lang.Apply(tmp6, []any{tmp42}) + return tmp43 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("byte").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to byte", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3505), lang.NewKeyword("end-line"), int(3505))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("byte").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to byte", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3505), lang.NewKeyword("end-line"), int(3505))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5 := lang.Apply(lang.ByteCast, []any{v4}) - return v5 + tmp5 := lang.Apply(lang.ByteCast, []any{v4}) + return tmp5 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // byte-array { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function byte-array__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v3 := lang.NewList(args[0:]...) - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("concat")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("list")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/ByteArray")}) - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("list")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("seq")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("concat")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) - v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v36 := v35.FindInternedVar(lang.NewSymbol("list")) - if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) - } - v37 := v36.Get() - v38 := lang.Apply(v37, []any{lang.NewSymbol("glojure.core/args")}) - v39 := lang.Apply(v30, []any{v34, v38}) - v40 := lang.Apply(v27, []any{v39}) - v41 := lang.Apply(v24, []any{v40}) - v42 := lang.Apply(v9, []any{v13, v17, v21, v41}) - v43 := lang.Apply(v6, []any{v42}) - return v43 + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.Apply(tmp20, []any{lang.NewSymbol("glojure.core/ByteArray")}) + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("list")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("seq")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("concat")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) + tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp36 := tmp35.FindInternedVar(lang.NewSymbol("list")) + if tmp36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) + } + tmp37 := tmp36.Get() + tmp38 := lang.Apply(tmp37, []any{lang.NewSymbol("glojure.core/args")}) + tmp39 := lang.Apply(tmp30, []any{tmp34, tmp38}) + tmp40 := lang.Apply(tmp27, []any{tmp39}) + tmp41 := lang.Apply(tmp24, []any{tmp40}) + tmp42 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp21, tmp41}) + tmp43 := lang.Apply(tmp6, []any{tmp42}) + return tmp43 } }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("byte-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Creates an array of bytes", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1), int64(2)), lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5317), lang.NewKeyword("end-line"), int(5317))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("byte-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Creates an array of bytes", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5317), lang.NewKeyword("end-line"), int(5317))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v4 := args[0] _ = v4 - v5, _ := lang.FieldOrMethod(lang.Numbers, "ByteArray") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "ByteArray") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("ByteArray is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 case 2: v4 := args[0] _ = v4 v5 := args[1] _ = v5 - v6, _ := lang.FieldOrMethod(lang.Numbers, "ByteArrayInit") - if reflect.TypeOf(v6).Kind() != reflect.Func { + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "ByteArrayInit") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("ByteArrayInit is not a function"))) } - v7 := lang.Apply(v6, []any{v4, v5}) - return v7 + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // bytes { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function bytes - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("concat")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("list")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/Bytes")}) - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("list")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v3}) - v26 := lang.Apply(v9, []any{v13, v17, v21, v25}) - v27 := lang.Apply(v6, []any{v26}) - return v27 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.Apply(tmp20, []any{lang.NewSymbol("glojure.core/Bytes")}) + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("list")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.Apply(tmp24, []any{v3}) + tmp26 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp21, tmp25}) + tmp27 := lang.Apply(tmp6, []any{tmp26}) + return tmp27 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("bytes").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Casts to bytes[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5377), lang.NewKeyword("end-line"), int(5377))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("bytes").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Casts to bytes[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5377), lang.NewKeyword("end-line"), int(5377))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5, _ := lang.FieldOrMethod(lang.Numbers, "Bytes") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Bytes") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Bytes is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // bytes? { - v0 := lang.NewSymbol("bytes?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a byte array", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5412), lang.NewKeyword("end-line"), int(5412))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("bytes?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a byte array", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5412), lang.NewKeyword("end-line"), int(5412))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("nil?")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v3}) - if lang.IsTruthy(v8) { - v4 = false + var tmp4 any + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("nil?")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v3}) + if lang.IsTruthy(tmp8) { + tmp4 = false } else { - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("=")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("class")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.Apply(v14, []any{v3}) - v16, ok := lang.FieldOrMethod(v15, "getComponentType") + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("=")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("class")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.Apply(tmp14, []any{v3}) + tmp16, ok := lang.FieldOrMethod(tmp15, "getComponentType") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v15, "getComponentType"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp15, "getComponentType"))) } - var v17 any - switch reflect.TypeOf(v16).Kind() { + var tmp17 any + switch reflect.TypeOf(tmp16).Kind() { case reflect.Func: - v17 = lang.Apply(v16, nil) + tmp17 = lang.Apply(tmp16, nil) default: - v17 = v16 + tmp17 = tmp16 } - v18 := lang.Apply(v11, []any{v17, nil}) - v4 = v18 + tmp18 := lang.Apply(tmp11, []any{tmp17, nil}) + tmp4 = tmp18 } - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // case { - v0 := lang.NewSymbol("case").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("e"), lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes an expression, and a set of clauses.\n\n Each clause can take the form of either:\n\n test-constant result-expr\n\n (test-constant1 ... test-constantN) result-expr\n\n The test-constants are not evaluated. They must be compile-time\n literals, and need not be quoted. If the expression is equal to a\n test-constant, the corresponding result-expr is returned. A single\n default expression can follow the clauses, and its value will be\n returned if no clause matches. If no default expression is provided\n and no clause matches, an IllegalArgumentException is thrown.\n\n Unlike cond and condp, case does a constant-time dispatch, the\n clauses are not considered sequentially. All manner of constant\n expressions are acceptable in case, including numbers, strings,\n symbols, keywords, and (Clojure) composites thereof. Note that since\n lists are used to group multiple constants that map to the same\n expression, a vector can be used to match a list if needed. The\n test-constants need not be all of the same type.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6712), lang.NewKeyword("end-line"), int(6712))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("case").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("e"), lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes an expression, and a set of clauses.\n\n Each clause can take the form of either:\n\n test-constant result-expr\n\n (test-constant1 ... test-constantN) result-expr\n\n The test-constants are not evaluated. They must be compile-time\n literals, and need not be quoted. If the expression is equal to a\n test-constant, the corresponding result-expr is returned. A single\n default expression can follow the clauses, and its value will be\n returned if no clause matches. If no default expression is provided\n and no clause matches, an IllegalArgumentException is thrown.\n\n Unlike cond and condp, case does a constant-time dispatch, the\n clauses are not considered sequentially. All manner of constant\n expressions are acceptable in case, including numbers, strings,\n symbols, keywords, and (Clojure) composites thereof. Note that since\n lists are used to group multiple constants that map to the same\n expression, a vector can be used to match a list if needed. The\n test-constants need not be all of the same type.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6712), lang.NewKeyword("end-line"), int(6712))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 3 { @@ -15417,1210 +15482,1212 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - var v7 any + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any { // let // let binding "ge" - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("with-meta")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("gensym")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, nil) - v15 := lang.NewMap(lang.NewKeyword("tag"), lang.Object) - v16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6738), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(6738), lang.NewKeyword("end-column"), int(84)) - v17, err := lang.WithMeta(v15, v16.(lang.IPersistentMap)) + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("with-meta")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("gensym")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, nil) + tmp15 := reflect.TypeOf((*lang.Object)(nil)).Elem() + tmp16 := lang.NewMap(lang.NewKeyword("tag"), tmp15) + tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6738), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(6738), lang.NewKeyword("end-column"), int(84)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) if err != nil { panic(err) } - v18 := lang.Apply(v10, []any{v14, v17}) - var v19 any = v18 - _ = v19 + tmp19 := lang.Apply(tmp10, []any{tmp14, tmp18}) + var v20 any = tmp19 + _ = v20 // let binding "default" - var v20 any - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("odd?")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("count")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.Apply(v26, []any{v6}) - v28 := lang.Apply(v23, []any{v27}) - if lang.IsTruthy(v28) { - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("last")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.Apply(v31, []any{v6}) - v20 = v32 + var tmp21 any + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("odd?")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("count")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.Apply(tmp27, []any{v6}) + tmp29 := lang.Apply(tmp24, []any{tmp28}) + if lang.IsTruthy(tmp29) { + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("last")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) + } + tmp32 := tmp31.Get() + tmp33 := lang.Apply(tmp32, []any{v6}) + tmp21 = tmp33 } else { - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("seq")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("concat")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v40 := v39.FindInternedVar(lang.NewSymbol("list")) - if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) - } - v41 := v40.Get() - v42 := lang.Apply(v41, []any{lang.NewSymbol("throw")}) - v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v44 := v43.FindInternedVar(lang.NewSymbol("list")) - if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) - } - v45 := v44.Get() - v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v47 := v46.FindInternedVar(lang.NewSymbol("seq")) - if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) - } - v48 := v47.Get() - v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v50 := v49.FindInternedVar(lang.NewSymbol("concat")) - if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) - } - v51 := v50.Get() - v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v53 := v52.FindInternedVar(lang.NewSymbol("list")) - if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) - } - v54 := v53.Get() - v55 := lang.Apply(v54, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewIllegalArgumentError")}) - v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v57 := v56.FindInternedVar(lang.NewSymbol("list")) - if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) - } - v58 := v57.Get() - v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v60 := v59.FindInternedVar(lang.NewSymbol("seq")) - if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) - } - v61 := v60.Get() - v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v63 := v62.FindInternedVar(lang.NewSymbol("concat")) - if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) - } - v64 := v63.Get() - v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v66 := v65.FindInternedVar(lang.NewSymbol("list")) - if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) - } - v67 := v66.Get() - v68 := lang.Apply(v67, []any{lang.NewSymbol("glojure.core/str")}) - v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v70 := v69.FindInternedVar(lang.NewSymbol("list")) - if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) - } - v71 := v70.Get() - v72 := lang.Apply(v71, []any{"No matching clause: "}) - v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v74 := v73.FindInternedVar(lang.NewSymbol("list")) - if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) - } - v75 := v74.Get() - v76 := lang.Apply(v75, []any{v19}) - v77 := lang.Apply(v64, []any{v68, v72, v76}) - v78 := lang.Apply(v61, []any{v77}) - v79 := lang.Apply(v58, []any{v78}) - v80 := lang.Apply(v51, []any{v55, v79}) - v81 := lang.Apply(v48, []any{v80}) - v82 := lang.Apply(v45, []any{v81}) - v83 := lang.Apply(v38, []any{v42, v82}) - v84 := lang.Apply(v35, []any{v83}) - v20 = v84 - } - var v85 any = v20 - _ = v85 - var v86 any - v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v88 := v87.FindInternedVar(lang.NewSymbol(">")) - if v88.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) - } - v89 := v88.Get() - v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v91 := v90.FindInternedVar(lang.NewSymbol("count")) - if v91.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) - } - v92 := v91.Get() - v93 := lang.Apply(v92, []any{v6}) - v94 := lang.Apply(v89, []any{int64(2), v93}) - if lang.IsTruthy(v94) { - v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v96 := v95.FindInternedVar(lang.NewSymbol("seq")) - if v96.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) - } - v97 := v96.Get() - v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v99 := v98.FindInternedVar(lang.NewSymbol("concat")) - if v99.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) - } - v100 := v99.Get() - v101 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v102 := v101.FindInternedVar(lang.NewSymbol("list")) - if v102.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v102))) - } - v103 := v102.Get() - v104 := lang.Apply(v103, []any{lang.NewSymbol("glojure.core/let")}) - v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v106 := v105.FindInternedVar(lang.NewSymbol("list")) - if v106.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) - } - v107 := v106.Get() - v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v109 := v108.FindInternedVar(lang.NewSymbol("apply")) - if v109.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) - } - v110 := v109.Get() - v111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v112 := v111.FindInternedVar(lang.NewSymbol("vector")) - if v112.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v112))) - } - v113 := v112.Get() - v114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v115 := v114.FindInternedVar(lang.NewSymbol("seq")) - if v115.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v115))) - } - v116 := v115.Get() - v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v118 := v117.FindInternedVar(lang.NewSymbol("concat")) - if v118.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) - } - v119 := v118.Get() - v120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v121 := v120.FindInternedVar(lang.NewSymbol("list")) - if v121.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v121))) - } - v122 := v121.Get() - v123 := lang.Apply(v122, []any{v19}) - v124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v125 := v124.FindInternedVar(lang.NewSymbol("list")) - if v125.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v125))) - } - v126 := v125.Get() - v127 := lang.Apply(v126, []any{v5}) - v128 := lang.Apply(v119, []any{v123, v127}) - v129 := lang.Apply(v116, []any{v128}) - v130 := lang.Apply(v110, []any{v113, v129}) - v131 := lang.Apply(v107, []any{v130}) - v132 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v133 := v132.FindInternedVar(lang.NewSymbol("list")) - if v133.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v133))) - } - v134 := v133.Get() - v135 := lang.Apply(v134, []any{v85}) - v136 := lang.Apply(v100, []any{v104, v131, v135}) - v137 := lang.Apply(v97, []any{v136}) - v86 = v137 + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) + } + tmp42 := tmp41.Get() + tmp43 := lang.Apply(tmp42, []any{lang.NewSymbol("throw")}) + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) + } + tmp46 := tmp45.Get() + tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp48 := tmp47.FindInternedVar(lang.NewSymbol("seq")) + if tmp48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) + } + tmp49 := tmp48.Get() + tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp51 := tmp50.FindInternedVar(lang.NewSymbol("concat")) + if tmp51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) + } + tmp52 := tmp51.Get() + tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp54 := tmp53.FindInternedVar(lang.NewSymbol("list")) + if tmp54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) + } + tmp55 := tmp54.Get() + tmp56 := lang.Apply(tmp55, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewIllegalArgumentError")}) + tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp58 := tmp57.FindInternedVar(lang.NewSymbol("list")) + if tmp58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) + } + tmp59 := tmp58.Get() + tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp61 := tmp60.FindInternedVar(lang.NewSymbol("seq")) + if tmp61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) + } + tmp62 := tmp61.Get() + tmp63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp64 := tmp63.FindInternedVar(lang.NewSymbol("concat")) + if tmp64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp64))) + } + tmp65 := tmp64.Get() + tmp66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp67 := tmp66.FindInternedVar(lang.NewSymbol("list")) + if tmp67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp67))) + } + tmp68 := tmp67.Get() + tmp69 := lang.Apply(tmp68, []any{lang.NewSymbol("glojure.core/str")}) + tmp70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp71 := tmp70.FindInternedVar(lang.NewSymbol("list")) + if tmp71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp71))) + } + tmp72 := tmp71.Get() + tmp73 := lang.Apply(tmp72, []any{"No matching clause: "}) + tmp74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp75 := tmp74.FindInternedVar(lang.NewSymbol("list")) + if tmp75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp75))) + } + tmp76 := tmp75.Get() + tmp77 := lang.Apply(tmp76, []any{v20}) + tmp78 := lang.Apply(tmp65, []any{tmp69, tmp73, tmp77}) + tmp79 := lang.Apply(tmp62, []any{tmp78}) + tmp80 := lang.Apply(tmp59, []any{tmp79}) + tmp81 := lang.Apply(tmp52, []any{tmp56, tmp80}) + tmp82 := lang.Apply(tmp49, []any{tmp81}) + tmp83 := lang.Apply(tmp46, []any{tmp82}) + tmp84 := lang.Apply(tmp39, []any{tmp43, tmp83}) + tmp85 := lang.Apply(tmp36, []any{tmp84}) + tmp21 = tmp85 + } + var v86 any = tmp21 + _ = v86 + var tmp87 any + tmp88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp89 := tmp88.FindInternedVar(lang.NewSymbol(">")) + if tmp89.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp89))) + } + tmp90 := tmp89.Get() + tmp91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp92 := tmp91.FindInternedVar(lang.NewSymbol("count")) + if tmp92.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp92))) + } + tmp93 := tmp92.Get() + tmp94 := lang.Apply(tmp93, []any{v6}) + tmp95 := lang.Apply(tmp90, []any{int64(2), tmp94}) + if lang.IsTruthy(tmp95) { + tmp96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp97 := tmp96.FindInternedVar(lang.NewSymbol("seq")) + if tmp97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp97))) + } + tmp98 := tmp97.Get() + tmp99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp100 := tmp99.FindInternedVar(lang.NewSymbol("concat")) + if tmp100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp100))) + } + tmp101 := tmp100.Get() + tmp102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp103 := tmp102.FindInternedVar(lang.NewSymbol("list")) + if tmp103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp103))) + } + tmp104 := tmp103.Get() + tmp105 := lang.Apply(tmp104, []any{lang.NewSymbol("glojure.core/let")}) + tmp106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp107 := tmp106.FindInternedVar(lang.NewSymbol("list")) + if tmp107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp107))) + } + tmp108 := tmp107.Get() + tmp109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp110 := tmp109.FindInternedVar(lang.NewSymbol("apply")) + if tmp110.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp110))) + } + tmp111 := tmp110.Get() + tmp112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp113 := tmp112.FindInternedVar(lang.NewSymbol("vector")) + if tmp113.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp113))) + } + tmp114 := tmp113.Get() + tmp115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp116 := tmp115.FindInternedVar(lang.NewSymbol("seq")) + if tmp116.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp116))) + } + tmp117 := tmp116.Get() + tmp118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp119 := tmp118.FindInternedVar(lang.NewSymbol("concat")) + if tmp119.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp119))) + } + tmp120 := tmp119.Get() + tmp121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp122 := tmp121.FindInternedVar(lang.NewSymbol("list")) + if tmp122.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp122))) + } + tmp123 := tmp122.Get() + tmp124 := lang.Apply(tmp123, []any{v20}) + tmp125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp126 := tmp125.FindInternedVar(lang.NewSymbol("list")) + if tmp126.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp126))) + } + tmp127 := tmp126.Get() + tmp128 := lang.Apply(tmp127, []any{v5}) + tmp129 := lang.Apply(tmp120, []any{tmp124, tmp128}) + tmp130 := lang.Apply(tmp117, []any{tmp129}) + tmp131 := lang.Apply(tmp111, []any{tmp114, tmp130}) + tmp132 := lang.Apply(tmp108, []any{tmp131}) + tmp133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp134 := tmp133.FindInternedVar(lang.NewSymbol("list")) + if tmp134.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp134))) + } + tmp135 := tmp134.Get() + tmp136 := lang.Apply(tmp135, []any{v86}) + tmp137 := lang.Apply(tmp101, []any{tmp105, tmp132, tmp136}) + tmp138 := lang.Apply(tmp98, []any{tmp137}) + tmp87 = tmp138 } else { - var v138 any + var tmp139 any { // let // let binding "pairs" - v139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v140 := v139.FindInternedVar(lang.NewSymbol("partition")) - if v140.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v140))) - } - v141 := v140.Get() - v142 := lang.Apply(v141, []any{int64(2), v6}) - var v143 any = v142 - _ = v143 + tmp140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp141 := tmp140.FindInternedVar(lang.NewSymbol("partition")) + if tmp141.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp141))) + } + tmp142 := tmp141.Get() + tmp143 := lang.Apply(tmp142, []any{int64(2), v6}) + var v144 any = tmp143 + _ = v144 // let binding "assoc-test" - var v144 lang.FnFunc + var tmp145 lang.FnFunc { // function assoc-test - v144 = lang.NewFnFunc(func(args ...any) any { + var v146 lang.FnFunc + tmp145 = lang.NewFnFunc(func(args ...any) any { if len(args) != 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v146 := args[0] - _ = v146 - v147 := args[1] + v147 := args[0] _ = v147 - v148 := args[2] + v148 := args[1] _ = v148 - var v149 any - v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v151 := v150.FindInternedVar(lang.NewSymbol("contains?")) - if v151.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) + v149 := args[2] + _ = v149 + var tmp150 any + tmp151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp152 := tmp151.FindInternedVar(lang.NewSymbol("contains?")) + if tmp152.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp152))) } - v152 := v151.Get() - v153 := lang.Apply(v152, []any{v146, v147}) - if lang.IsTruthy(v153) { - v154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v155 := v154.FindInternedVar(lang.NewSymbol("str")) - if v155.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v155))) + tmp153 := tmp152.Get() + tmp154 := lang.Apply(tmp153, []any{v147, v148}) + if lang.IsTruthy(tmp154) { + tmp155 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp156 := tmp155.FindInternedVar(lang.NewSymbol("str")) + if tmp156.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp156))) } - v156 := v155.Get() - v157 := lang.Apply(v156, []any{"Duplicate case test constant: ", v147}) - v158 := lang.Apply(lang.NewIllegalArgumentError, []any{v157}) - panic(v158) + tmp157 := tmp156.Get() + tmp158 := lang.Apply(tmp157, []any{"Duplicate case test constant: ", v148}) + tmp159 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp158}) + panic(tmp159) } else { - v159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v160 := v159.FindInternedVar(lang.NewSymbol("assoc")) - if v160.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v160))) + tmp160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp161 := tmp160.FindInternedVar(lang.NewSymbol("assoc")) + if tmp161.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp161))) } - v161 := v160.Get() - v162 := lang.Apply(v161, []any{v146, v147, v148}) - v149 = v162 + tmp162 := tmp161.Get() + tmp163 := lang.Apply(tmp162, []any{v147, v148, v149}) + tmp150 = tmp163 } - return v149 + return tmp150 }) - v145 := v144 - _ = v145 + v146 = tmp145 + _ = v146 } - v145 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6745), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(6748), lang.NewKeyword("end-column"), int(48)) - v146, err := lang.WithMeta(v144, v145.(lang.IPersistentMap)) + tmp146 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6745), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(6748), lang.NewKeyword("end-column"), int(48)) + tmp147, err := lang.WithMeta(tmp145, tmp146.(lang.IPersistentMap)) if err != nil { panic(err) } - var v147 any = v146 - _ = v147 + var v148 any = tmp147 + _ = v148 // let binding "pairs" - v148 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v149 := v148.FindInternedVar(lang.NewSymbol("reduce1")) - if v149.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v149))) - } - v150 := v149.Get() - var v151 lang.FnFunc - v151 = lang.NewFnFunc(func(args ...any) any { + tmp149 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp150 := tmp149.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp150.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp150))) + } + tmp151 := tmp150.Get() + var tmp152 lang.FnFunc + tmp152 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v152 := args[0] - _ = v152 - v153 := args[1] + v153 := args[0] _ = v153 - var v154 any + v154 := args[1] + _ = v154 + var tmp155 any { // let // let binding "vec__177" - var v155 any = v153 - _ = v155 + var v156 any = v154 + _ = v156 // let binding "test" - v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v157 := v156.FindInternedVar(lang.NewSymbol("nth")) - if v157.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) + tmp157 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp158 := tmp157.FindInternedVar(lang.NewSymbol("nth")) + if tmp158.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp158))) } - v158 := v157.Get() - v159 := lang.Apply(v158, []any{v155, int64(0), nil}) - var v160 any = v159 - _ = v160 + tmp159 := tmp158.Get() + tmp160 := lang.Apply(tmp159, []any{v156, int64(0), nil}) + var v161 any = tmp160 + _ = v161 // let binding "expr" - v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v162 := v161.FindInternedVar(lang.NewSymbol("nth")) - if v162.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) + tmp162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp163 := tmp162.FindInternedVar(lang.NewSymbol("nth")) + if tmp163.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp163))) } - v163 := v162.Get() - v164 := lang.Apply(v163, []any{v155, int64(1), nil}) - var v165 any = v164 - _ = v165 - var v166 any - v167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v168 := v167.FindInternedVar(lang.NewSymbol("seq?")) - if v168.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v168))) + tmp164 := tmp163.Get() + tmp165 := lang.Apply(tmp164, []any{v156, int64(1), nil}) + var v166 any = tmp165 + _ = v166 + var tmp167 any + tmp168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp169 := tmp168.FindInternedVar(lang.NewSymbol("seq?")) + if tmp169.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp169))) } - v169 := v168.Get() - v170 := lang.Apply(v169, []any{v160}) - if lang.IsTruthy(v170) { - v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v172 := v171.FindInternedVar(lang.NewSymbol("reduce1")) - if v172.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) + tmp170 := tmp169.Get() + tmp171 := lang.Apply(tmp170, []any{v161}) + if lang.IsTruthy(tmp171) { + tmp172 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp173 := tmp172.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp173.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp173))) } - v173 := v172.Get() - var v174 lang.FnFunc - v174 = lang.NewFnFunc(func(args ...any) any { + tmp174 := tmp173.Get() + var tmp175 lang.FnFunc + tmp175 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v175 := args[0] - _ = v175 - v176 := args[1] + v176 := args[0] _ = v176 - v177 := lang.Apply(v147, []any{v175, v176, v165}) - return v177 + v177 := args[1] + _ = v177 + tmp178 := lang.Apply(v148, []any{v176, v177, v166}) + return tmp178 }) - v175 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6752), lang.NewKeyword("column"), int(37), lang.NewKeyword("end-line"), int(6752), lang.NewKeyword("end-column"), int(60)) - v176, err := lang.WithMeta(v174, v175.(lang.IPersistentMap)) + tmp176 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6752), lang.NewKeyword("column"), int(37), lang.NewKeyword("end-line"), int(6752), lang.NewKeyword("end-column"), int(60)) + tmp177, err := lang.WithMeta(tmp175, tmp176.(lang.IPersistentMap)) if err != nil { panic(err) } - v177 := lang.Apply(v173, []any{v176, v152, v160}) - v166 = v177 + tmp178 := lang.Apply(tmp174, []any{tmp177, v153, v161}) + tmp167 = tmp178 } else { - v178 := lang.Apply(v147, []any{v152, v160, v165}) - v166 = v178 + tmp179 := lang.Apply(v148, []any{v153, v161, v166}) + tmp167 = tmp179 } - v154 = v166 + tmp155 = tmp167 } // end let - return v154 + return tmp155 }) - v152 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6750), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(6753), lang.NewKeyword("end-column"), int(53)) - v153, err := lang.WithMeta(v151, v152.(lang.IPersistentMap)) + tmp153 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6750), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(6753), lang.NewKeyword("end-column"), int(53)) + tmp154, err := lang.WithMeta(tmp152, tmp153.(lang.IPersistentMap)) if err != nil { panic(err) } - v154 := lang.NewMap() - v155 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6754), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(6754), lang.NewKeyword("end-column"), int(25)) - v156, err := lang.WithMeta(v154, v155.(lang.IPersistentMap)) + tmp155 := lang.NewMap() + tmp156 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6754), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(6754), lang.NewKeyword("end-column"), int(25)) + tmp157, err := lang.WithMeta(tmp155, tmp156.(lang.IPersistentMap)) if err != nil { panic(err) } - v157 := lang.Apply(v150, []any{v153, v156, v143}) - var v158 any = v157 - _ = v158 + tmp158 := lang.Apply(tmp151, []any{tmp154, tmp157, v144}) + var v159 any = tmp158 + _ = v159 // let binding "tests" - v159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v160 := v159.FindInternedVar(lang.NewSymbol("keys")) - if v160.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v160))) - } - v161 := v160.Get() - v162 := lang.Apply(v161, []any{v158}) - var v163 any = v162 - _ = v163 + tmp160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp161 := tmp160.FindInternedVar(lang.NewSymbol("keys")) + if tmp161.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp161))) + } + tmp162 := tmp161.Get() + tmp163 := lang.Apply(tmp162, []any{v159}) + var v164 any = tmp163 + _ = v164 // let binding "thens" - v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v165 := v164.FindInternedVar(lang.NewSymbol("vals")) - if v165.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) - } - v166 := v165.Get() - v167 := lang.Apply(v166, []any{v158}) - var v168 any = v167 - _ = v168 + tmp165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp166 := tmp165.FindInternedVar(lang.NewSymbol("vals")) + if tmp166.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp166))) + } + tmp167 := tmp166.Get() + tmp168 := lang.Apply(tmp167, []any{v159}) + var v169 any = tmp168 + _ = v169 // let binding "mode" - var v169 any - v170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v171 := v170.FindInternedVar(lang.NewSymbol("every?")) - if v171.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v171))) - } - v172 := v171.Get() - var v173 lang.FnFunc - v173 = lang.NewFnFunc(func(args ...any) any { + var tmp170 any + tmp171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp172 := tmp171.FindInternedVar(lang.NewSymbol("every?")) + if tmp172.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp172))) + } + tmp173 := tmp172.Get() + var tmp174 lang.FnFunc + tmp174 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v174 := args[0] - _ = v174 - var v175 any + v175 := args[0] + _ = v175 + var tmp176 any { // let // let binding "and__0__auto__" - v176 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v177 := v176.FindInternedVar(lang.NewSymbol("integer?")) - if v177.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v177))) + tmp177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp178 := tmp177.FindInternedVar(lang.NewSymbol("integer?")) + if tmp178.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp178))) } - v178 := v177.Get() - v179 := lang.Apply(v178, []any{v174}) - var v180 any = v179 - _ = v180 - var v181 any - if lang.IsTruthy(v180) { - v182 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v183 := v182.FindInternedVar(lang.NewSymbol("<=")) - if v183.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v183))) + tmp179 := tmp178.Get() + tmp180 := lang.Apply(tmp179, []any{v175}) + var v181 any = tmp180 + _ = v181 + var tmp182 any + if lang.IsTruthy(v181) { + tmp183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp184 := tmp183.FindInternedVar(lang.NewSymbol("<=")) + if tmp184.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp184))) } - v184 := v183.Get() - v185 := lang.Apply(v184, []any{math3.MinInt, v174, math3.MaxInt}) - v181 = v185 + tmp185 := tmp184.Get() + tmp186 := lang.Apply(tmp185, []any{math3.MinInt, v175, math3.MaxInt}) + tmp182 = tmp186 } else { - v181 = v180 + tmp182 = v181 } - v175 = v181 + tmp176 = tmp182 } // end let - return v175 + return tmp176 }) - v174 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6758), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(6758), lang.NewKeyword("end-column"), int(77)) - v175, err := lang.WithMeta(v173, v174.(lang.IPersistentMap)) + tmp175 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6758), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(6758), lang.NewKeyword("end-column"), int(77)) + tmp176, err := lang.WithMeta(tmp174, tmp175.(lang.IPersistentMap)) if err != nil { panic(err) } - v176 := lang.Apply(v172, []any{v175, v163}) - if lang.IsTruthy(v176) { - v169 = lang.NewKeyword("ints") + tmp177 := lang.Apply(tmp173, []any{tmp176, v164}) + if lang.IsTruthy(tmp177) { + tmp170 = lang.NewKeyword("ints") } else { - var v177 any - v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v179 := v178.FindInternedVar(lang.NewSymbol("every?")) - if v179.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) + var tmp178 any + tmp179 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp180 := tmp179.FindInternedVar(lang.NewSymbol("every?")) + if tmp180.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp180))) } - v180 := v179.Get() - v181 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v182 := v181.FindInternedVar(lang.NewSymbol("keyword?")) - if v182.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v182))) + tmp181 := tmp180.Get() + tmp182 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp183 := tmp182.FindInternedVar(lang.NewSymbol("keyword?")) + if tmp183.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp183))) } - v183 := v182.Get() - v184 := lang.Apply(v180, []any{v183, v163}) - if lang.IsTruthy(v184) { - v177 = lang.NewKeyword("identity") + tmp184 := tmp183.Get() + tmp185 := lang.Apply(tmp181, []any{tmp184, v164}) + if lang.IsTruthy(tmp185) { + tmp178 = lang.NewKeyword("identity") } else { - var v185 any + var tmp186 any if lang.IsTruthy(lang.NewKeyword("else")) { - v185 = lang.NewKeyword("hashes") + tmp186 = lang.NewKeyword("hashes") } else { - v185 = nil } - v177 = v185 + tmp178 = tmp186 } - v169 = v177 + tmp170 = tmp178 } - var v186 any = v169 - _ = v186 - var v187 any + var v187 any = tmp170 + _ = v187 + var tmp188 any { // let // let binding "pred__180" - v188 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v189 := v188.FindInternedVar(lang.NewSymbol("=")) - if v189.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v189))) + tmp189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp190 := tmp189.FindInternedVar(lang.NewSymbol("=")) + if tmp190.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp190))) } - v190 := v189.Get() - var v191 any = v190 - _ = v191 - // let binding "expr__181" - var v192 any = v186 + tmp191 := tmp190.Get() + var v192 any = tmp191 _ = v192 - var v193 any - v194 := lang.Apply(v191, []any{lang.NewKeyword("ints"), v192}) - if lang.IsTruthy(v194) { - var v195 any + // let binding "expr__181" + var v193 any = v187 + _ = v193 + var tmp194 any + tmp195 := lang.Apply(v192, []any{lang.NewKeyword("ints"), v193}) + if lang.IsTruthy(tmp195) { + var tmp196 any { // let // let binding "vec__182" - v196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v197 := v196.FindInternedVar(lang.NewSymbol("prep-ints")) - if v197.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v197))) + tmp197 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp198 := tmp197.FindInternedVar(lang.NewSymbol("prep-ints")) + if tmp198.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp198))) } - v198 := v197.Get() - v199 := lang.Apply(v198, []any{v163, v168}) - var v200 any = v199 - _ = v200 + tmp199 := tmp198.Get() + tmp200 := lang.Apply(tmp199, []any{v164, v169}) + var v201 any = tmp200 + _ = v201 // let binding "shift" - v201 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v202 := v201.FindInternedVar(lang.NewSymbol("nth")) - if v202.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v202))) + tmp202 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp203 := tmp202.FindInternedVar(lang.NewSymbol("nth")) + if tmp203.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp203))) } - v203 := v202.Get() - v204 := lang.Apply(v203, []any{v200, int64(0), nil}) - var v205 any = v204 - _ = v205 + tmp204 := tmp203.Get() + tmp205 := lang.Apply(tmp204, []any{v201, int64(0), nil}) + var v206 any = tmp205 + _ = v206 // let binding "mask" - v206 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v207 := v206.FindInternedVar(lang.NewSymbol("nth")) - if v207.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v207))) + tmp207 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp208 := tmp207.FindInternedVar(lang.NewSymbol("nth")) + if tmp208.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp208))) } - v208 := v207.Get() - v209 := lang.Apply(v208, []any{v200, int64(1), nil}) - var v210 any = v209 - _ = v210 + tmp209 := tmp208.Get() + tmp210 := lang.Apply(tmp209, []any{v201, int64(1), nil}) + var v211 any = tmp210 + _ = v211 // let binding "imap" - v211 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v212 := v211.FindInternedVar(lang.NewSymbol("nth")) - if v212.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v212))) + tmp212 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp213 := tmp212.FindInternedVar(lang.NewSymbol("nth")) + if tmp213.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp213))) } - v213 := v212.Get() - v214 := lang.Apply(v213, []any{v200, int64(2), nil}) - var v215 any = v214 - _ = v215 + tmp214 := tmp213.Get() + tmp215 := lang.Apply(tmp214, []any{v201, int64(2), nil}) + var v216 any = tmp215 + _ = v216 // let binding "switch-type" - v216 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v217 := v216.FindInternedVar(lang.NewSymbol("nth")) - if v217.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v217))) + tmp217 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp218 := tmp217.FindInternedVar(lang.NewSymbol("nth")) + if tmp218.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp218))) } - v218 := v217.Get() - v219 := lang.Apply(v218, []any{v200, int64(3), nil}) - var v220 any = v219 - _ = v220 - v221 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v222 := v221.FindInternedVar(lang.NewSymbol("seq")) - if v222.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v222))) + tmp219 := tmp218.Get() + tmp220 := lang.Apply(tmp219, []any{v201, int64(3), nil}) + var v221 any = tmp220 + _ = v221 + tmp222 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp223 := tmp222.FindInternedVar(lang.NewSymbol("seq")) + if tmp223.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp223))) } - v223 := v222.Get() - v224 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v225 := v224.FindInternedVar(lang.NewSymbol("concat")) - if v225.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v225))) + tmp224 := tmp223.Get() + tmp225 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp226 := tmp225.FindInternedVar(lang.NewSymbol("concat")) + if tmp226.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp226))) } - v226 := v225.Get() - v227 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v228 := v227.FindInternedVar(lang.NewSymbol("list")) - if v228.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v228))) + tmp227 := tmp226.Get() + tmp228 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp229 := tmp228.FindInternedVar(lang.NewSymbol("list")) + if tmp229.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp229))) } - v229 := v228.Get() - v230 := lang.Apply(v229, []any{lang.NewSymbol("glojure.core/let")}) - v231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v232 := v231.FindInternedVar(lang.NewSymbol("list")) - if v232.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v232))) + tmp230 := tmp229.Get() + tmp231 := lang.Apply(tmp230, []any{lang.NewSymbol("glojure.core/let")}) + tmp232 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp233 := tmp232.FindInternedVar(lang.NewSymbol("list")) + if tmp233.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp233))) } - v233 := v232.Get() - v234 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v235 := v234.FindInternedVar(lang.NewSymbol("apply")) - if v235.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v235))) + tmp234 := tmp233.Get() + tmp235 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp236 := tmp235.FindInternedVar(lang.NewSymbol("apply")) + if tmp236.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp236))) } - v236 := v235.Get() - v237 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v238 := v237.FindInternedVar(lang.NewSymbol("vector")) - if v238.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v238))) + tmp237 := tmp236.Get() + tmp238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp239 := tmp238.FindInternedVar(lang.NewSymbol("vector")) + if tmp239.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp239))) } - v239 := v238.Get() - v240 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v241 := v240.FindInternedVar(lang.NewSymbol("seq")) - if v241.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v241))) + tmp240 := tmp239.Get() + tmp241 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp242 := tmp241.FindInternedVar(lang.NewSymbol("seq")) + if tmp242.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp242))) } - v242 := v241.Get() - v243 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v244 := v243.FindInternedVar(lang.NewSymbol("concat")) - if v244.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v244))) + tmp243 := tmp242.Get() + tmp244 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp245 := tmp244.FindInternedVar(lang.NewSymbol("concat")) + if tmp245.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp245))) } - v245 := v244.Get() - v246 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v247 := v246.FindInternedVar(lang.NewSymbol("list")) - if v247.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v247))) + tmp246 := tmp245.Get() + tmp247 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp248 := tmp247.FindInternedVar(lang.NewSymbol("list")) + if tmp248.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp248))) } - v248 := v247.Get() - v249 := lang.Apply(v248, []any{v19}) - v250 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v251 := v250.FindInternedVar(lang.NewSymbol("list")) - if v251.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v251))) + tmp249 := tmp248.Get() + tmp250 := lang.Apply(tmp249, []any{v20}) + tmp251 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp252 := tmp251.FindInternedVar(lang.NewSymbol("list")) + if tmp252.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp252))) } - v252 := v251.Get() - v253 := lang.Apply(v252, []any{v5}) - v254 := lang.Apply(v245, []any{v249, v253}) - v255 := lang.Apply(v242, []any{v254}) - v256 := lang.Apply(v236, []any{v239, v255}) - v257 := lang.Apply(v233, []any{v256}) - v258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v259 := v258.FindInternedVar(lang.NewSymbol("list")) - if v259.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v259))) + tmp253 := tmp252.Get() + tmp254 := lang.Apply(tmp253, []any{v5}) + tmp255 := lang.Apply(tmp246, []any{tmp250, tmp254}) + tmp256 := lang.Apply(tmp243, []any{tmp255}) + tmp257 := lang.Apply(tmp237, []any{tmp240, tmp256}) + tmp258 := lang.Apply(tmp234, []any{tmp257}) + tmp259 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp260 := tmp259.FindInternedVar(lang.NewSymbol("list")) + if tmp260.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp260))) } - v260 := v259.Get() - v261 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v262 := v261.FindInternedVar(lang.NewSymbol("seq")) - if v262.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v262))) + tmp261 := tmp260.Get() + tmp262 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp263 := tmp262.FindInternedVar(lang.NewSymbol("seq")) + if tmp263.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp263))) } - v263 := v262.Get() - v264 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v265 := v264.FindInternedVar(lang.NewSymbol("concat")) - if v265.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v265))) + tmp264 := tmp263.Get() + tmp265 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp266 := tmp265.FindInternedVar(lang.NewSymbol("concat")) + if tmp266.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp266))) } - v266 := v265.Get() - v267 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v268 := v267.FindInternedVar(lang.NewSymbol("list")) - if v268.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v268))) + tmp267 := tmp266.Get() + tmp268 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp269 := tmp268.FindInternedVar(lang.NewSymbol("list")) + if tmp269.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp269))) } - v269 := v268.Get() - v270 := lang.Apply(v269, []any{lang.NewSymbol("case*")}) - v271 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v272 := v271.FindInternedVar(lang.NewSymbol("list")) - if v272.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v272))) + tmp270 := tmp269.Get() + tmp271 := lang.Apply(tmp270, []any{lang.NewSymbol("case*")}) + tmp272 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp273 := tmp272.FindInternedVar(lang.NewSymbol("list")) + if tmp273.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp273))) } - v273 := v272.Get() - v274 := lang.Apply(v273, []any{v19}) - v275 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v276 := v275.FindInternedVar(lang.NewSymbol("list")) - if v276.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v276))) + tmp274 := tmp273.Get() + tmp275 := lang.Apply(tmp274, []any{v20}) + tmp276 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp277 := tmp276.FindInternedVar(lang.NewSymbol("list")) + if tmp277.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp277))) } - v277 := v276.Get() - v278 := lang.Apply(v277, []any{v205}) - v279 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v280 := v279.FindInternedVar(lang.NewSymbol("list")) - if v280.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v280))) + tmp278 := tmp277.Get() + tmp279 := lang.Apply(tmp278, []any{v206}) + tmp280 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp281 := tmp280.FindInternedVar(lang.NewSymbol("list")) + if tmp281.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp281))) } - v281 := v280.Get() - v282 := lang.Apply(v281, []any{v210}) - v283 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v284 := v283.FindInternedVar(lang.NewSymbol("list")) - if v284.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v284))) + tmp282 := tmp281.Get() + tmp283 := lang.Apply(tmp282, []any{v211}) + tmp284 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp285 := tmp284.FindInternedVar(lang.NewSymbol("list")) + if tmp285.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp285))) } - v285 := v284.Get() - v286 := lang.Apply(v285, []any{v85}) - v287 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v288 := v287.FindInternedVar(lang.NewSymbol("list")) - if v288.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v288))) + tmp286 := tmp285.Get() + tmp287 := lang.Apply(tmp286, []any{v86}) + tmp288 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp289 := tmp288.FindInternedVar(lang.NewSymbol("list")) + if tmp289.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp289))) } - v289 := v288.Get() - v290 := lang.Apply(v289, []any{v215}) - v291 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v292 := v291.FindInternedVar(lang.NewSymbol("list")) - if v292.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v292))) + tmp290 := tmp289.Get() + tmp291 := lang.Apply(tmp290, []any{v216}) + tmp292 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp293 := tmp292.FindInternedVar(lang.NewSymbol("list")) + if tmp293.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp293))) } - v293 := v292.Get() - v294 := lang.Apply(v293, []any{v220}) - v295 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v296 := v295.FindInternedVar(lang.NewSymbol("list")) - if v296.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v296))) + tmp294 := tmp293.Get() + tmp295 := lang.Apply(tmp294, []any{v221}) + tmp296 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp297 := tmp296.FindInternedVar(lang.NewSymbol("list")) + if tmp297.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp297))) } - v297 := v296.Get() - v298 := lang.Apply(v297, []any{lang.NewKeyword("int")}) - v299 := lang.Apply(v266, []any{v270, v274, v278, v282, v286, v290, v294, v298}) - v300 := lang.Apply(v263, []any{v299}) - v301 := lang.Apply(v260, []any{v300}) - v302 := lang.Apply(v226, []any{v230, v257, v301}) - v303 := lang.Apply(v223, []any{v302}) - v195 = v303 + tmp298 := tmp297.Get() + tmp299 := lang.Apply(tmp298, []any{lang.NewKeyword("int")}) + tmp300 := lang.Apply(tmp267, []any{tmp271, tmp275, tmp279, tmp283, tmp287, tmp291, tmp295, tmp299}) + tmp301 := lang.Apply(tmp264, []any{tmp300}) + tmp302 := lang.Apply(tmp261, []any{tmp301}) + tmp303 := lang.Apply(tmp227, []any{tmp231, tmp258, tmp302}) + tmp304 := lang.Apply(tmp224, []any{tmp303}) + tmp196 = tmp304 } // end let - v193 = v195 + tmp194 = tmp196 } else { - var v196 any - v197 := lang.Apply(v191, []any{lang.NewKeyword("hashes"), v192}) - if lang.IsTruthy(v197) { - var v198 any + var tmp197 any + tmp198 := lang.Apply(v192, []any{lang.NewKeyword("hashes"), v193}) + if lang.IsTruthy(tmp198) { + var tmp199 any { // let // let binding "vec__185" - v199 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v200 := v199.FindInternedVar(lang.NewSymbol("prep-hashes")) - if v200.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v200))) + tmp200 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp201 := tmp200.FindInternedVar(lang.NewSymbol("prep-hashes")) + if tmp201.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp201))) } - v201 := v200.Get() - v202 := lang.Apply(v201, []any{v19, v85, v163, v168}) - var v203 any = v202 - _ = v203 + tmp202 := tmp201.Get() + tmp203 := lang.Apply(tmp202, []any{v20, v86, v164, v169}) + var v204 any = tmp203 + _ = v204 // let binding "shift" - v204 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v205 := v204.FindInternedVar(lang.NewSymbol("nth")) - if v205.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v205))) + tmp205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp206 := tmp205.FindInternedVar(lang.NewSymbol("nth")) + if tmp206.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp206))) } - v206 := v205.Get() - v207 := lang.Apply(v206, []any{v203, int64(0), nil}) - var v208 any = v207 - _ = v208 + tmp207 := tmp206.Get() + tmp208 := lang.Apply(tmp207, []any{v204, int64(0), nil}) + var v209 any = tmp208 + _ = v209 // let binding "mask" - v209 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v210 := v209.FindInternedVar(lang.NewSymbol("nth")) - if v210.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v210))) + tmp210 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp211 := tmp210.FindInternedVar(lang.NewSymbol("nth")) + if tmp211.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp211))) } - v211 := v210.Get() - v212 := lang.Apply(v211, []any{v203, int64(1), nil}) - var v213 any = v212 - _ = v213 + tmp212 := tmp211.Get() + tmp213 := lang.Apply(tmp212, []any{v204, int64(1), nil}) + var v214 any = tmp213 + _ = v214 // let binding "imap" - v214 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v215 := v214.FindInternedVar(lang.NewSymbol("nth")) - if v215.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v215))) + tmp215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp216 := tmp215.FindInternedVar(lang.NewSymbol("nth")) + if tmp216.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp216))) } - v216 := v215.Get() - v217 := lang.Apply(v216, []any{v203, int64(2), nil}) - var v218 any = v217 - _ = v218 + tmp217 := tmp216.Get() + tmp218 := lang.Apply(tmp217, []any{v204, int64(2), nil}) + var v219 any = tmp218 + _ = v219 // let binding "switch-type" - v219 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v220 := v219.FindInternedVar(lang.NewSymbol("nth")) - if v220.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v220))) + tmp220 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp221 := tmp220.FindInternedVar(lang.NewSymbol("nth")) + if tmp221.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp221))) } - v221 := v220.Get() - v222 := lang.Apply(v221, []any{v203, int64(3), nil}) - var v223 any = v222 - _ = v223 + tmp222 := tmp221.Get() + tmp223 := lang.Apply(tmp222, []any{v204, int64(3), nil}) + var v224 any = tmp223 + _ = v224 // let binding "skip-check" - v224 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v225 := v224.FindInternedVar(lang.NewSymbol("nth")) - if v225.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v225))) + tmp225 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp226 := tmp225.FindInternedVar(lang.NewSymbol("nth")) + if tmp226.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp226))) } - v226 := v225.Get() - v227 := lang.Apply(v226, []any{v203, int64(4), nil}) - var v228 any = v227 - _ = v228 - v229 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v230 := v229.FindInternedVar(lang.NewSymbol("seq")) - if v230.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v230))) + tmp227 := tmp226.Get() + tmp228 := lang.Apply(tmp227, []any{v204, int64(4), nil}) + var v229 any = tmp228 + _ = v229 + tmp230 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp231 := tmp230.FindInternedVar(lang.NewSymbol("seq")) + if tmp231.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp231))) } - v231 := v230.Get() - v232 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v233 := v232.FindInternedVar(lang.NewSymbol("concat")) - if v233.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v233))) + tmp232 := tmp231.Get() + tmp233 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp234 := tmp233.FindInternedVar(lang.NewSymbol("concat")) + if tmp234.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp234))) } - v234 := v233.Get() - v235 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v236 := v235.FindInternedVar(lang.NewSymbol("list")) - if v236.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v236))) + tmp235 := tmp234.Get() + tmp236 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp237 := tmp236.FindInternedVar(lang.NewSymbol("list")) + if tmp237.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp237))) } - v237 := v236.Get() - v238 := lang.Apply(v237, []any{lang.NewSymbol("glojure.core/let")}) - v239 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v240 := v239.FindInternedVar(lang.NewSymbol("list")) - if v240.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v240))) + tmp238 := tmp237.Get() + tmp239 := lang.Apply(tmp238, []any{lang.NewSymbol("glojure.core/let")}) + tmp240 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp241 := tmp240.FindInternedVar(lang.NewSymbol("list")) + if tmp241.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp241))) } - v241 := v240.Get() - v242 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v243 := v242.FindInternedVar(lang.NewSymbol("apply")) - if v243.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v243))) + tmp242 := tmp241.Get() + tmp243 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp244 := tmp243.FindInternedVar(lang.NewSymbol("apply")) + if tmp244.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp244))) } - v244 := v243.Get() - v245 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v246 := v245.FindInternedVar(lang.NewSymbol("vector")) - if v246.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v246))) + tmp245 := tmp244.Get() + tmp246 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp247 := tmp246.FindInternedVar(lang.NewSymbol("vector")) + if tmp247.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp247))) } - v247 := v246.Get() - v248 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v249 := v248.FindInternedVar(lang.NewSymbol("seq")) - if v249.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v249))) + tmp248 := tmp247.Get() + tmp249 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp250 := tmp249.FindInternedVar(lang.NewSymbol("seq")) + if tmp250.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp250))) } - v250 := v249.Get() - v251 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v252 := v251.FindInternedVar(lang.NewSymbol("concat")) - if v252.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v252))) + tmp251 := tmp250.Get() + tmp252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp253 := tmp252.FindInternedVar(lang.NewSymbol("concat")) + if tmp253.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp253))) } - v253 := v252.Get() - v254 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v255 := v254.FindInternedVar(lang.NewSymbol("list")) - if v255.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v255))) + tmp254 := tmp253.Get() + tmp255 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp256 := tmp255.FindInternedVar(lang.NewSymbol("list")) + if tmp256.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp256))) } - v256 := v255.Get() - v257 := lang.Apply(v256, []any{v19}) - v258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v259 := v258.FindInternedVar(lang.NewSymbol("list")) - if v259.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v259))) + tmp257 := tmp256.Get() + tmp258 := lang.Apply(tmp257, []any{v20}) + tmp259 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp260 := tmp259.FindInternedVar(lang.NewSymbol("list")) + if tmp260.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp260))) } - v260 := v259.Get() - v261 := lang.Apply(v260, []any{v5}) - v262 := lang.Apply(v253, []any{v257, v261}) - v263 := lang.Apply(v250, []any{v262}) - v264 := lang.Apply(v244, []any{v247, v263}) - v265 := lang.Apply(v241, []any{v264}) - v266 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v267 := v266.FindInternedVar(lang.NewSymbol("list")) - if v267.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v267))) + tmp261 := tmp260.Get() + tmp262 := lang.Apply(tmp261, []any{v5}) + tmp263 := lang.Apply(tmp254, []any{tmp258, tmp262}) + tmp264 := lang.Apply(tmp251, []any{tmp263}) + tmp265 := lang.Apply(tmp245, []any{tmp248, tmp264}) + tmp266 := lang.Apply(tmp242, []any{tmp265}) + tmp267 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp268 := tmp267.FindInternedVar(lang.NewSymbol("list")) + if tmp268.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp268))) } - v268 := v267.Get() - v269 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v270 := v269.FindInternedVar(lang.NewSymbol("seq")) - if v270.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v270))) + tmp269 := tmp268.Get() + tmp270 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp271 := tmp270.FindInternedVar(lang.NewSymbol("seq")) + if tmp271.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp271))) } - v271 := v270.Get() - v272 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v273 := v272.FindInternedVar(lang.NewSymbol("concat")) - if v273.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v273))) + tmp272 := tmp271.Get() + tmp273 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp274 := tmp273.FindInternedVar(lang.NewSymbol("concat")) + if tmp274.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp274))) } - v274 := v273.Get() - v275 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v276 := v275.FindInternedVar(lang.NewSymbol("list")) - if v276.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v276))) + tmp275 := tmp274.Get() + tmp276 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp277 := tmp276.FindInternedVar(lang.NewSymbol("list")) + if tmp277.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp277))) } - v277 := v276.Get() - v278 := lang.Apply(v277, []any{lang.NewSymbol("case*")}) - v279 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v280 := v279.FindInternedVar(lang.NewSymbol("list")) - if v280.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v280))) + tmp278 := tmp277.Get() + tmp279 := lang.Apply(tmp278, []any{lang.NewSymbol("case*")}) + tmp280 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp281 := tmp280.FindInternedVar(lang.NewSymbol("list")) + if tmp281.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp281))) } - v281 := v280.Get() - v282 := lang.Apply(v281, []any{v19}) - v283 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v284 := v283.FindInternedVar(lang.NewSymbol("list")) - if v284.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v284))) + tmp282 := tmp281.Get() + tmp283 := lang.Apply(tmp282, []any{v20}) + tmp284 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp285 := tmp284.FindInternedVar(lang.NewSymbol("list")) + if tmp285.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp285))) } - v285 := v284.Get() - v286 := lang.Apply(v285, []any{v208}) - v287 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v288 := v287.FindInternedVar(lang.NewSymbol("list")) - if v288.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v288))) + tmp286 := tmp285.Get() + tmp287 := lang.Apply(tmp286, []any{v209}) + tmp288 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp289 := tmp288.FindInternedVar(lang.NewSymbol("list")) + if tmp289.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp289))) } - v289 := v288.Get() - v290 := lang.Apply(v289, []any{v213}) - v291 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v292 := v291.FindInternedVar(lang.NewSymbol("list")) - if v292.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v292))) + tmp290 := tmp289.Get() + tmp291 := lang.Apply(tmp290, []any{v214}) + tmp292 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp293 := tmp292.FindInternedVar(lang.NewSymbol("list")) + if tmp293.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp293))) } - v293 := v292.Get() - v294 := lang.Apply(v293, []any{v85}) - v295 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v296 := v295.FindInternedVar(lang.NewSymbol("list")) - if v296.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v296))) + tmp294 := tmp293.Get() + tmp295 := lang.Apply(tmp294, []any{v86}) + tmp296 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp297 := tmp296.FindInternedVar(lang.NewSymbol("list")) + if tmp297.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp297))) } - v297 := v296.Get() - v298 := lang.Apply(v297, []any{v218}) - v299 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v300 := v299.FindInternedVar(lang.NewSymbol("list")) - if v300.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v300))) + tmp298 := tmp297.Get() + tmp299 := lang.Apply(tmp298, []any{v219}) + tmp300 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp301 := tmp300.FindInternedVar(lang.NewSymbol("list")) + if tmp301.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp301))) } - v301 := v300.Get() - v302 := lang.Apply(v301, []any{v223}) - v303 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v304 := v303.FindInternedVar(lang.NewSymbol("list")) - if v304.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v304))) + tmp302 := tmp301.Get() + tmp303 := lang.Apply(tmp302, []any{v224}) + tmp304 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp305 := tmp304.FindInternedVar(lang.NewSymbol("list")) + if tmp305.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp305))) } - v305 := v304.Get() - v306 := lang.Apply(v305, []any{lang.NewKeyword("hash-equiv")}) - v307 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v308 := v307.FindInternedVar(lang.NewSymbol("list")) - if v308.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v308))) + tmp306 := tmp305.Get() + tmp307 := lang.Apply(tmp306, []any{lang.NewKeyword("hash-equiv")}) + tmp308 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp309 := tmp308.FindInternedVar(lang.NewSymbol("list")) + if tmp309.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp309))) } - v309 := v308.Get() - v310 := lang.Apply(v309, []any{v228}) - v311 := lang.Apply(v274, []any{v278, v282, v286, v290, v294, v298, v302, v306, v310}) - v312 := lang.Apply(v271, []any{v311}) - v313 := lang.Apply(v268, []any{v312}) - v314 := lang.Apply(v234, []any{v238, v265, v313}) - v315 := lang.Apply(v231, []any{v314}) - v198 = v315 + tmp310 := tmp309.Get() + tmp311 := lang.Apply(tmp310, []any{v229}) + tmp312 := lang.Apply(tmp275, []any{tmp279, tmp283, tmp287, tmp291, tmp295, tmp299, tmp303, tmp307, tmp311}) + tmp313 := lang.Apply(tmp272, []any{tmp312}) + tmp314 := lang.Apply(tmp269, []any{tmp313}) + tmp315 := lang.Apply(tmp235, []any{tmp239, tmp266, tmp314}) + tmp316 := lang.Apply(tmp232, []any{tmp315}) + tmp199 = tmp316 } // end let - v196 = v198 + tmp197 = tmp199 } else { - var v199 any - v200 := lang.Apply(v191, []any{lang.NewKeyword("identity"), v192}) - if lang.IsTruthy(v200) { - var v201 any + var tmp200 any + tmp201 := lang.Apply(v192, []any{lang.NewKeyword("identity"), v193}) + if lang.IsTruthy(tmp201) { + var tmp202 any { // let // let binding "vec__188" - v202 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v203 := v202.FindInternedVar(lang.NewSymbol("prep-hashes")) - if v203.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v203))) + tmp203 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp204 := tmp203.FindInternedVar(lang.NewSymbol("prep-hashes")) + if tmp204.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp204))) } - v204 := v203.Get() - v205 := lang.Apply(v204, []any{v19, v85, v163, v168}) - var v206 any = v205 - _ = v206 + tmp205 := tmp204.Get() + tmp206 := lang.Apply(tmp205, []any{v20, v86, v164, v169}) + var v207 any = tmp206 + _ = v207 // let binding "shift" - v207 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v208 := v207.FindInternedVar(lang.NewSymbol("nth")) - if v208.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v208))) + tmp208 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp209 := tmp208.FindInternedVar(lang.NewSymbol("nth")) + if tmp209.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp209))) } - v209 := v208.Get() - v210 := lang.Apply(v209, []any{v206, int64(0), nil}) - var v211 any = v210 - _ = v211 + tmp210 := tmp209.Get() + tmp211 := lang.Apply(tmp210, []any{v207, int64(0), nil}) + var v212 any = tmp211 + _ = v212 // let binding "mask" - v212 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v213 := v212.FindInternedVar(lang.NewSymbol("nth")) - if v213.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v213))) + tmp213 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp214 := tmp213.FindInternedVar(lang.NewSymbol("nth")) + if tmp214.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp214))) } - v214 := v213.Get() - v215 := lang.Apply(v214, []any{v206, int64(1), nil}) - var v216 any = v215 - _ = v216 + tmp215 := tmp214.Get() + tmp216 := lang.Apply(tmp215, []any{v207, int64(1), nil}) + var v217 any = tmp216 + _ = v217 // let binding "imap" - v217 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v218 := v217.FindInternedVar(lang.NewSymbol("nth")) - if v218.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v218))) + tmp218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp219 := tmp218.FindInternedVar(lang.NewSymbol("nth")) + if tmp219.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp219))) } - v219 := v218.Get() - v220 := lang.Apply(v219, []any{v206, int64(2), nil}) - var v221 any = v220 - _ = v221 + tmp220 := tmp219.Get() + tmp221 := lang.Apply(tmp220, []any{v207, int64(2), nil}) + var v222 any = tmp221 + _ = v222 // let binding "switch-type" - v222 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v223 := v222.FindInternedVar(lang.NewSymbol("nth")) - if v223.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v223))) + tmp223 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp224 := tmp223.FindInternedVar(lang.NewSymbol("nth")) + if tmp224.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp224))) } - v224 := v223.Get() - v225 := lang.Apply(v224, []any{v206, int64(3), nil}) - var v226 any = v225 - _ = v226 + tmp225 := tmp224.Get() + tmp226 := lang.Apply(tmp225, []any{v207, int64(3), nil}) + var v227 any = tmp226 + _ = v227 // let binding "skip-check" - v227 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v228 := v227.FindInternedVar(lang.NewSymbol("nth")) - if v228.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v228))) + tmp228 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp229 := tmp228.FindInternedVar(lang.NewSymbol("nth")) + if tmp229.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp229))) } - v229 := v228.Get() - v230 := lang.Apply(v229, []any{v206, int64(4), nil}) - var v231 any = v230 - _ = v231 - v232 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v233 := v232.FindInternedVar(lang.NewSymbol("seq")) - if v233.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v233))) + tmp230 := tmp229.Get() + tmp231 := lang.Apply(tmp230, []any{v207, int64(4), nil}) + var v232 any = tmp231 + _ = v232 + tmp233 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp234 := tmp233.FindInternedVar(lang.NewSymbol("seq")) + if tmp234.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp234))) } - v234 := v233.Get() - v235 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v236 := v235.FindInternedVar(lang.NewSymbol("concat")) - if v236.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v236))) + tmp235 := tmp234.Get() + tmp236 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp237 := tmp236.FindInternedVar(lang.NewSymbol("concat")) + if tmp237.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp237))) } - v237 := v236.Get() - v238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v239 := v238.FindInternedVar(lang.NewSymbol("list")) - if v239.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v239))) + tmp238 := tmp237.Get() + tmp239 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp240 := tmp239.FindInternedVar(lang.NewSymbol("list")) + if tmp240.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp240))) } - v240 := v239.Get() - v241 := lang.Apply(v240, []any{lang.NewSymbol("glojure.core/let")}) - v242 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v243 := v242.FindInternedVar(lang.NewSymbol("list")) - if v243.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v243))) + tmp241 := tmp240.Get() + tmp242 := lang.Apply(tmp241, []any{lang.NewSymbol("glojure.core/let")}) + tmp243 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp244 := tmp243.FindInternedVar(lang.NewSymbol("list")) + if tmp244.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp244))) } - v244 := v243.Get() - v245 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v246 := v245.FindInternedVar(lang.NewSymbol("apply")) - if v246.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v246))) + tmp245 := tmp244.Get() + tmp246 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp247 := tmp246.FindInternedVar(lang.NewSymbol("apply")) + if tmp247.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp247))) } - v247 := v246.Get() - v248 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v249 := v248.FindInternedVar(lang.NewSymbol("vector")) - if v249.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v249))) + tmp248 := tmp247.Get() + tmp249 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp250 := tmp249.FindInternedVar(lang.NewSymbol("vector")) + if tmp250.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp250))) } - v250 := v249.Get() - v251 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v252 := v251.FindInternedVar(lang.NewSymbol("seq")) - if v252.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v252))) + tmp251 := tmp250.Get() + tmp252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp253 := tmp252.FindInternedVar(lang.NewSymbol("seq")) + if tmp253.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp253))) } - v253 := v252.Get() - v254 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v255 := v254.FindInternedVar(lang.NewSymbol("concat")) - if v255.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v255))) + tmp254 := tmp253.Get() + tmp255 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp256 := tmp255.FindInternedVar(lang.NewSymbol("concat")) + if tmp256.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp256))) } - v256 := v255.Get() - v257 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v258 := v257.FindInternedVar(lang.NewSymbol("list")) - if v258.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v258))) + tmp257 := tmp256.Get() + tmp258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp259 := tmp258.FindInternedVar(lang.NewSymbol("list")) + if tmp259.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp259))) } - v259 := v258.Get() - v260 := lang.Apply(v259, []any{v19}) - v261 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v262 := v261.FindInternedVar(lang.NewSymbol("list")) - if v262.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v262))) + tmp260 := tmp259.Get() + tmp261 := lang.Apply(tmp260, []any{v20}) + tmp262 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp263 := tmp262.FindInternedVar(lang.NewSymbol("list")) + if tmp263.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp263))) } - v263 := v262.Get() - v264 := lang.Apply(v263, []any{v5}) - v265 := lang.Apply(v256, []any{v260, v264}) - v266 := lang.Apply(v253, []any{v265}) - v267 := lang.Apply(v247, []any{v250, v266}) - v268 := lang.Apply(v244, []any{v267}) - v269 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v270 := v269.FindInternedVar(lang.NewSymbol("list")) - if v270.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v270))) + tmp264 := tmp263.Get() + tmp265 := lang.Apply(tmp264, []any{v5}) + tmp266 := lang.Apply(tmp257, []any{tmp261, tmp265}) + tmp267 := lang.Apply(tmp254, []any{tmp266}) + tmp268 := lang.Apply(tmp248, []any{tmp251, tmp267}) + tmp269 := lang.Apply(tmp245, []any{tmp268}) + tmp270 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp271 := tmp270.FindInternedVar(lang.NewSymbol("list")) + if tmp271.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp271))) } - v271 := v270.Get() - v272 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v273 := v272.FindInternedVar(lang.NewSymbol("seq")) - if v273.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v273))) + tmp272 := tmp271.Get() + tmp273 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp274 := tmp273.FindInternedVar(lang.NewSymbol("seq")) + if tmp274.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp274))) } - v274 := v273.Get() - v275 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v276 := v275.FindInternedVar(lang.NewSymbol("concat")) - if v276.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v276))) + tmp275 := tmp274.Get() + tmp276 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp277 := tmp276.FindInternedVar(lang.NewSymbol("concat")) + if tmp277.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp277))) } - v277 := v276.Get() - v278 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v279 := v278.FindInternedVar(lang.NewSymbol("list")) - if v279.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v279))) + tmp278 := tmp277.Get() + tmp279 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp280 := tmp279.FindInternedVar(lang.NewSymbol("list")) + if tmp280.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp280))) } - v280 := v279.Get() - v281 := lang.Apply(v280, []any{lang.NewSymbol("case*")}) - v282 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v283 := v282.FindInternedVar(lang.NewSymbol("list")) - if v283.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v283))) + tmp281 := tmp280.Get() + tmp282 := lang.Apply(tmp281, []any{lang.NewSymbol("case*")}) + tmp283 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp284 := tmp283.FindInternedVar(lang.NewSymbol("list")) + if tmp284.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp284))) } - v284 := v283.Get() - v285 := lang.Apply(v284, []any{v19}) - v286 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v287 := v286.FindInternedVar(lang.NewSymbol("list")) - if v287.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v287))) + tmp285 := tmp284.Get() + tmp286 := lang.Apply(tmp285, []any{v20}) + tmp287 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp288 := tmp287.FindInternedVar(lang.NewSymbol("list")) + if tmp288.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp288))) } - v288 := v287.Get() - v289 := lang.Apply(v288, []any{v211}) - v290 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v291 := v290.FindInternedVar(lang.NewSymbol("list")) - if v291.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v291))) + tmp289 := tmp288.Get() + tmp290 := lang.Apply(tmp289, []any{v212}) + tmp291 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp292 := tmp291.FindInternedVar(lang.NewSymbol("list")) + if tmp292.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp292))) } - v292 := v291.Get() - v293 := lang.Apply(v292, []any{v216}) - v294 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v295 := v294.FindInternedVar(lang.NewSymbol("list")) - if v295.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v295))) + tmp293 := tmp292.Get() + tmp294 := lang.Apply(tmp293, []any{v217}) + tmp295 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp296 := tmp295.FindInternedVar(lang.NewSymbol("list")) + if tmp296.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp296))) } - v296 := v295.Get() - v297 := lang.Apply(v296, []any{v85}) - v298 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v299 := v298.FindInternedVar(lang.NewSymbol("list")) - if v299.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v299))) + tmp297 := tmp296.Get() + tmp298 := lang.Apply(tmp297, []any{v86}) + tmp299 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp300 := tmp299.FindInternedVar(lang.NewSymbol("list")) + if tmp300.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp300))) } - v300 := v299.Get() - v301 := lang.Apply(v300, []any{v221}) - v302 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v303 := v302.FindInternedVar(lang.NewSymbol("list")) - if v303.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v303))) + tmp301 := tmp300.Get() + tmp302 := lang.Apply(tmp301, []any{v222}) + tmp303 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp304 := tmp303.FindInternedVar(lang.NewSymbol("list")) + if tmp304.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp304))) } - v304 := v303.Get() - v305 := lang.Apply(v304, []any{v226}) - v306 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v307 := v306.FindInternedVar(lang.NewSymbol("list")) - if v307.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v307))) + tmp305 := tmp304.Get() + tmp306 := lang.Apply(tmp305, []any{v227}) + tmp307 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp308 := tmp307.FindInternedVar(lang.NewSymbol("list")) + if tmp308.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp308))) } - v308 := v307.Get() - v309 := lang.Apply(v308, []any{lang.NewKeyword("hash-identity")}) - v310 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v311 := v310.FindInternedVar(lang.NewSymbol("list")) - if v311.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v311))) + tmp309 := tmp308.Get() + tmp310 := lang.Apply(tmp309, []any{lang.NewKeyword("hash-identity")}) + tmp311 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp312 := tmp311.FindInternedVar(lang.NewSymbol("list")) + if tmp312.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp312))) } - v312 := v311.Get() - v313 := lang.Apply(v312, []any{v231}) - v314 := lang.Apply(v277, []any{v281, v285, v289, v293, v297, v301, v305, v309, v313}) - v315 := lang.Apply(v274, []any{v314}) - v316 := lang.Apply(v271, []any{v315}) - v317 := lang.Apply(v237, []any{v241, v268, v316}) - v318 := lang.Apply(v234, []any{v317}) - v201 = v318 + tmp313 := tmp312.Get() + tmp314 := lang.Apply(tmp313, []any{v232}) + tmp315 := lang.Apply(tmp278, []any{tmp282, tmp286, tmp290, tmp294, tmp298, tmp302, tmp306, tmp310, tmp314}) + tmp316 := lang.Apply(tmp275, []any{tmp315}) + tmp317 := lang.Apply(tmp272, []any{tmp316}) + tmp318 := lang.Apply(tmp238, []any{tmp242, tmp269, tmp317}) + tmp319 := lang.Apply(tmp235, []any{tmp318}) + tmp202 = tmp319 } // end let - v199 = v201 + tmp200 = tmp202 } else { - v202 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v203 := v202.FindInternedVar(lang.NewSymbol("str")) - if v203.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v203))) + tmp203 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp204 := tmp203.FindInternedVar(lang.NewSymbol("str")) + if tmp204.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp204))) } - v204 := v203.Get() - v205 := lang.Apply(v204, []any{"No matching clause: ", v192}) - v206 := lang.Apply(lang.NewIllegalArgumentError, []any{v205}) - panic(v206) + tmp205 := tmp204.Get() + tmp206 := lang.Apply(tmp205, []any{"No matching clause: ", v193}) + tmp207 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp206}) + panic(tmp207) } - v196 = v199 + tmp197 = tmp200 } - v193 = v196 + tmp194 = tmp197 } - v187 = v193 + tmp188 = tmp194 } // end let - v138 = v187 + tmp139 = tmp188 } // end let - v86 = v138 + tmp87 = tmp139 } - v7 = v86 + tmp7 = tmp87 } // end let - return v7 + return tmp7 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // case-map { - v0 := lang.NewSymbol("case-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("case-f"), lang.NewSymbol("test-f"), lang.NewSymbol("tests"), lang.NewSymbol("thens"))), lang.NewKeyword("doc"), "Transforms a sequence of test constants and a corresponding sequence of then\n expressions into a sorted map to be consumed by case*. The form of the map\n entries are {(case-f test) [(test-f test) then]}.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6614), lang.NewKeyword("end-line"), int(6614), lang.NewKeyword("private"), true)).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("case-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("case-f"), lang.NewSymbol("test-f"), lang.NewSymbol("tests"), lang.NewSymbol("thens"))), lang.NewKeyword("doc"), "Transforms a sequence of test constants and a corresponding sequence of then\n expressions into a sorted map to be consumed by case*. The form of the map\n entries are {(case-f test) [(test-f test) then]}.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6614), lang.NewKeyword("end-line"), int(6614), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 4 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -16632,67 +16699,67 @@ func init() { _ = v5 v6 := args[3] _ = v6 - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("into1")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("sorted-map")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, nil) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("zipmap")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("map")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.Apply(v19, []any{v3, v5}) - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("map")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("vector")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("map")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{v4, v5}) - v31 := lang.Apply(v23, []any{v26, v30, v6}) - v32 := lang.Apply(v16, []any{v20, v31}) - v33 := lang.Apply(v9, []any{v13, v32}) - return v33 - }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("into1")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("sorted-map")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, nil) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("zipmap")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("map")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.Apply(tmp19, []any{v3, v5}) + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("map")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("vector")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("map")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{v4, v5}) + tmp31 := lang.Apply(tmp23, []any{tmp26, tmp30, v6}) + tmp32 := lang.Apply(tmp16, []any{tmp20, tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp13, tmp32}) + return tmp33 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // cast { - v0 := lang.NewSymbol("cast").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Throws a ClassCastException if x is not a c, else returns x.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(345), lang.NewKeyword("end-line"), int(345))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("cast").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Throws a ClassCastException if x is not a c, else returns x.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(345), lang.NewKeyword("end-line"), int(345))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -16700,587 +16767,592 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5, _ := lang.FieldOrMethod(v3, "cast") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(v3, "cast") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("cast is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // cat { - v0 := lang.NewSymbol("cat").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rf"))), lang.NewKeyword("doc"), "A transducer which concatenates the contents of each input, which must be a\n collection, into the reduction.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7645), lang.NewKeyword("end-line"), int(7645))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("cat").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rf"))), lang.NewKeyword("doc"), "A transducer which concatenates the contents of each input, which must be a\n collection, into the reduction.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7645), lang.NewKeyword("end-line"), int(7645))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any + var tmp4 any { // let // let binding "rrf" - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("preserving-reduced")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v3}) - var v9 any = v8 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("preserving-reduced")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v3}) + var v9 any = tmp8 _ = v9 - var v10 lang.FnFunc - v10 = lang.NewFnFunc(func(args ...any) any { + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - v11 := lang.Apply(v3, nil) - return v11 + tmp11 := lang.Apply(v3, nil) + return tmp11 case 1: v11 := args[0] _ = v11 - v12 := lang.Apply(v3, []any{v11}) - return v12 + tmp12 := lang.Apply(v3, []any{v11}) + return tmp12 case 2: v11 := args[0] _ = v11 v12 := args[1] _ = v12 - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("reduce")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{v9, v11, v12}) - return v16 + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("reduce")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{v9, v11, v12}) + return tmp16 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7651), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(7655), lang.NewKeyword("end-column"), int(36)) - v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) + tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7651), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(7655), lang.NewKeyword("end-column"), int(36)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) if err != nil { panic(err) } - v4 = v12 + tmp4 = tmp12 } // end let - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // char { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function char__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("concat")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("list")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("seq")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("concat")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - var v30 any - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - if lang.IsTruthy(v33) { - v30 = lang.NewSymbol("uncheckedCharCast") + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + var tmp30 any + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + if lang.IsTruthy(tmp33) { + tmp30 = lang.NewSymbol("uncheckedCharCast") } else { - v30 = lang.NewSymbol("charCast") - } - v34 := lang.Apply(v29, []any{v30}) - v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v36 := v35.FindInternedVar(lang.NewSymbol("list")) - if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) - } - v37 := v36.Get() - v38 := lang.Apply(v37, []any{v3}) - v39 := lang.Apply(v26, []any{v34, v38}) - v40 := lang.Apply(v23, []any{v39}) - v41 := lang.Apply(v20, []any{v40}) - v42 := lang.Apply(v9, []any{v13, v17, v41}) - v43 := lang.Apply(v6, []any{v42}) - return v43 + tmp30 = lang.NewSymbol("charCast") + } + tmp34 := lang.Apply(tmp29, []any{tmp30}) + tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp36 := tmp35.FindInternedVar(lang.NewSymbol("list")) + if tmp36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) + } + tmp37 := tmp36.Get() + tmp38 := lang.Apply(tmp37, []any{v3}) + tmp39 := lang.Apply(tmp26, []any{tmp34, tmp38}) + tmp40 := lang.Apply(tmp23, []any{tmp39}) + tmp41 := lang.Apply(tmp20, []any{tmp40}) + tmp42 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp41}) + tmp43 := lang.Apply(tmp6, []any{tmp42}) + return tmp43 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("char").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to char", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3511), lang.NewKeyword("end-line"), int(3511))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("char").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to char", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3511), lang.NewKeyword("end-line"), int(3511))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5, _ := lang.FieldOrMethod(runtime4.RT, "CharCast") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(runtime4.RT, "CharCast") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("CharCast is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // char-array { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function char-array__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v3 := lang.NewList(args[0:]...) - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("concat")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("list")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/CharArray")}) - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("list")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("seq")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("concat")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) - v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v36 := v35.FindInternedVar(lang.NewSymbol("list")) - if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) - } - v37 := v36.Get() - v38 := lang.Apply(v37, []any{lang.NewSymbol("glojure.core/args")}) - v39 := lang.Apply(v30, []any{v34, v38}) - v40 := lang.Apply(v27, []any{v39}) - v41 := lang.Apply(v24, []any{v40}) - v42 := lang.Apply(v9, []any{v13, v17, v21, v41}) - v43 := lang.Apply(v6, []any{v42}) - return v43 + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.Apply(tmp20, []any{lang.NewSymbol("glojure.core/CharArray")}) + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("list")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("seq")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("concat")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) + tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp36 := tmp35.FindInternedVar(lang.NewSymbol("list")) + if tmp36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) + } + tmp37 := tmp36.Get() + tmp38 := lang.Apply(tmp37, []any{lang.NewSymbol("glojure.core/args")}) + tmp39 := lang.Apply(tmp30, []any{tmp34, tmp38}) + tmp40 := lang.Apply(tmp27, []any{tmp39}) + tmp41 := lang.Apply(tmp24, []any{tmp40}) + tmp42 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp21, tmp41}) + tmp43 := lang.Apply(tmp6, []any{tmp42}) + return tmp43 } }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("char-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Creates an array of chars", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1), int64(2)), lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5325), lang.NewKeyword("end-line"), int(5325))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("char-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Creates an array of chars", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5325), lang.NewKeyword("end-line"), int(5325))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v4 := args[0] _ = v4 - v5, _ := lang.FieldOrMethod(lang.Numbers, "CharArray") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "CharArray") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("CharArray is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 case 2: v4 := args[0] _ = v4 v5 := args[1] _ = v5 - v6, _ := lang.FieldOrMethod(lang.Numbers, "CharArrayInit") - if reflect.TypeOf(v6).Kind() != reflect.Func { + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "CharArrayInit") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("CharArrayInit is not a function"))) } - v7 := lang.Apply(v6, []any{v4, v5}) - return v7 + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // char-escape-string { - v1 := reflect.TypeOf("") - v0 := lang.NewSymbol("char-escape-string").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("doc"), "Returns escape string for char or nil if none", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(6), lang.NewKeyword("line"), int(214), lang.NewKeyword("end-line"), int(217))).(*lang.Symbol) - v2 := ns.InternWithValue(v0, lang.NewMap(lang.NewChar(10), "\\n", lang.NewChar(9), "\\t", lang.NewChar(13), "\\r", lang.NewChar(34), "\\\"", lang.NewChar(92), "\\\\", lang.NewChar(12), "\\f", lang.NewChar(8), "\\b"), true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp1 := reflect.TypeOf("") + tmp0 := lang.NewSymbol("char-escape-string").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("doc"), "Returns escape string for char or nil if none", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(6), lang.NewKeyword("line"), int(214), lang.NewKeyword("end-line"), int(217))).(*lang.Symbol) + tmp2 := ns.InternWithValue(tmp0, lang.NewMap(lang.NewChar(10), "\\n", lang.NewChar(9), "\\t", lang.NewChar(13), "\\r", lang.NewChar(34), "\\\"", lang.NewChar(92), "\\\\", lang.NewChar(12), "\\f", lang.NewChar(8), "\\b"), true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // char-name-string { - v1 := reflect.TypeOf("") - v0 := lang.NewSymbol("char-name-string").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("doc"), "Returns name string for char or nil if none", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(6), lang.NewKeyword("line"), int(335), lang.NewKeyword("end-line"), int(338))).(*lang.Symbol) - v2 := ns.InternWithValue(v0, lang.NewMap(lang.NewChar(10), "newline", lang.NewChar(9), "tab", lang.NewChar(32), "space", lang.NewChar(8), "backspace", lang.NewChar(12), "formfeed", lang.NewChar(13), "return"), true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp1 := reflect.TypeOf("") + tmp0 := lang.NewSymbol("char-name-string").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("doc"), "Returns name string for char or nil if none", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(6), lang.NewKeyword("line"), int(335), lang.NewKeyword("end-line"), int(338))).(*lang.Symbol) + tmp2 := ns.InternWithValue(tmp0, lang.NewMap(lang.NewChar(10), "newline", lang.NewChar(9), "tab", lang.NewChar(32), "space", lang.NewChar(8), "backspace", lang.NewChar(12), "formfeed", lang.NewChar(13), "return"), true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // char? { - v0 := lang.NewSymbol("char?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a Character", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(153), lang.NewKeyword("end-line"), int(157))).(*lang.Symbol) - var v2 lang.FnFunc + tmp0 := lang.NewSymbol("char?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a Character", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(153), lang.NewKeyword("end-line"), int(157))).(*lang.Symbol) + var tmp2 lang.FnFunc { // function char? - v2 = lang.NewFnFunc(func(args ...any) any { + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{lang.Char, v4}) - return v8 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("instance?")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := reflect.TypeOf(int32(0)) + tmp9 := lang.Apply(tmp7, []any{tmp8, v4}) + return tmp9 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(157), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(157), lang.NewKeyword("end-column"), int(89))).(lang.FnFunc) - v3 := v2 + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(157), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(157), lang.NewKeyword("end-column"), int(89))).(lang.FnFunc) + v3 = tmp2 _ = v3 } - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // chars { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function chars - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("concat")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("list")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/Chars")}) - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("list")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v3}) - v26 := lang.Apply(v9, []any{v13, v17, v21, v25}) - v27 := lang.Apply(v6, []any{v26}) - return v27 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.Apply(tmp20, []any{lang.NewSymbol("glojure.core/Chars")}) + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("list")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.Apply(tmp24, []any{v3}) + tmp26 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp21, tmp25}) + tmp27 := lang.Apply(tmp6, []any{tmp26}) + return tmp27 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("chars").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Casts to chars[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5382), lang.NewKeyword("end-line"), int(5382))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("chars").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Casts to chars[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5382), lang.NewKeyword("end-line"), int(5382))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5, _ := lang.FieldOrMethod(lang.Numbers, "Chars") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Chars") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Chars is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // check-cyclic-dependency { - v0 := lang.NewSymbol("check-cyclic-dependency").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("path"))), lang.NewKeyword("doc"), "Detects and rejects non-trivial cyclic load dependencies. The\n exception message shows the dependency chain with the cycle\n highlighted. Ignores the trivial case of a file attempting to load\n itself because that can occur when a gen-class'd class loads its\n implementation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(30), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5974), lang.NewKeyword("end-line"), int(5974), lang.NewKeyword("private"), true)).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("check-cyclic-dependency").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("path"))), lang.NewKeyword("doc"), "Detects and rejects non-trivial cyclic load dependencies. The\n exception message shows the dependency chain with the cycle\n highlighted. Ignores the trivial case of a file attempting to load\n itself because that can occur when a gen-class'd class loads its\n implementation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(30), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5974), lang.NewKeyword("end-line"), int(5974), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("some")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.CreatePersistentTreeSet(v3) - v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5981), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(5981), lang.NewKeyword("end-column"), int(21)) - v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) + var tmp4 any + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("some")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{v3})) + tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5981), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(5981), lang.NewKeyword("end-column"), int(21)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) if err != nil { panic(err) } - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("rest")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("*pending-paths*")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v13, []any{v16}) - v18 := lang.Apply(v7, []any{v10, v17}) - if lang.IsTruthy(v18) { - var v19 any + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("rest")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("*pending-paths*")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp13, []any{tmp16}) + tmp18 := lang.Apply(tmp7, []any{tmp10, tmp17}) + if lang.IsTruthy(tmp18) { + var tmp19 any { // let // let binding "pending" - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("map")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - var v23 lang.FnFunc - v23 = lang.NewFnFunc(func(args ...any) any { + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("map")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + var tmp23 lang.FnFunc + tmp23 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v24 := args[0] _ = v24 - var v25 any - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("=")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) - } - v28 := v27.Get() - v29 := lang.Apply(v28, []any{v24, v3}) - if lang.IsTruthy(v29) { - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("str")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) - } - v32 := v31.Get() - v33 := lang.Apply(v32, []any{"[ ", v24, " ]"}) - v25 = v33 + var tmp25 any + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("=")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) + } + tmp28 := tmp27.Get() + tmp29 := lang.Apply(tmp28, []any{v24, v3}) + if lang.IsTruthy(tmp29) { + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("str")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) + } + tmp32 := tmp31.Get() + tmp33 := lang.Apply(tmp32, []any{"[ ", v24, " ]"}) + tmp25 = tmp33 } else { - v25 = v24 + tmp25 = v24 } - return v25 + return tmp25 }) - v24 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5982), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(5982), lang.NewKeyword("end-column"), int(59)) - v25, err := lang.WithMeta(v23, v24.(lang.IPersistentMap)) + tmp24 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5982), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(5982), lang.NewKeyword("end-column"), int(59)) + tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) if err != nil { panic(err) } - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("cons")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) - } - v28 := v27.Get() - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("*pending-paths*")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.Apply(v28, []any{v3, v31}) - v33 := lang.Apply(v22, []any{v25, v32}) - var v34 any = v33 + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("cons")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) + } + tmp28 := tmp27.Get() + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("*pending-paths*")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.Apply(tmp28, []any{v3, tmp31}) + tmp33 := lang.Apply(tmp22, []any{tmp25, tmp32}) + var v34 any = tmp33 _ = v34 // let binding "chain" - v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v36 := v35.FindInternedVar(lang.NewSymbol("apply")) - if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) - } - v37 := v36.Get() - v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v39 := v38.FindInternedVar(lang.NewSymbol("str")) - if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) - } - v40 := v39.Get() - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("interpose")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) - } - v43 := v42.Get() - v44 := lang.Apply(v43, []any{"->", v34}) - v45 := lang.Apply(v37, []any{v40, v44}) - var v46 any = v45 + tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp36 := tmp35.FindInternedVar(lang.NewSymbol("apply")) + if tmp36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) + } + tmp37 := tmp36.Get() + tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp39 := tmp38.FindInternedVar(lang.NewSymbol("str")) + if tmp39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) + } + tmp40 := tmp39.Get() + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("interpose")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := lang.Apply(tmp43, []any{"->", v34}) + tmp45 := lang.Apply(tmp37, []any{tmp40, tmp44}) + var v46 any = tmp45 _ = v46 - v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v48 := v47.FindInternedVar(lang.NewSymbol("throw-if")) - if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) - } - v49 := v48.Get() - v50 := lang.Apply(v49, []any{true, "Cyclic load dependency: %s", v46}) - v19 = v50 + tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp48 := tmp47.FindInternedVar(lang.NewSymbol("throw-if")) + if tmp48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) + } + tmp49 := tmp48.Get() + tmp50 := lang.Apply(tmp49, []any{true, "Cyclic load dependency: %s", v46}) + tmp19 = tmp50 } // end let - v4 = v19 + tmp4 = tmp19 } else { - v4 = nil } - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // check-valid-options { - v0 := lang.NewSymbol("check-valid-options").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("options"), lang.NewSymbol("&"), lang.NewSymbol("valid-keys"))), lang.NewKeyword("doc"), "Throws an exception if the given option map contains keys not listed\n as valid, else returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(35), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1709), lang.NewKeyword("end-line"), int(1709), lang.NewKeyword("private"), true)).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("check-valid-options").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("options"), lang.NewSymbol("&"), lang.NewSymbol("valid-keys"))), lang.NewKeyword("doc"), "Throws an exception if the given option map contains keys not listed\n as valid, else returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(35), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1709), lang.NewKeyword("end-line"), int(1709), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 1 { @@ -17288,152 +17360,152 @@ func init() { } v3 := args[0] _ = v3 - v4 := lang.NewList(args[1:]...) - var v5 any - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("seq")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("apply")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("disj")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("apply")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("hash-set")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("keys")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.Apply(v23, []any{v3}) - v25 := lang.Apply(v17, []any{v20, v24}) - v26 := lang.Apply(v11, []any{v14, v25, v4}) - v27 := lang.Apply(v8, []any{v26}) - if lang.IsTruthy(v27) { - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("apply")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("str")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("first")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) - } - v36 := v35.Get() - v37 := lang.Apply(v36, []any{v4}) - v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v39 := v38.FindInternedVar(lang.NewSymbol("map")) - if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) - } - v40 := v39.Get() - var v41 lang.FnFunc - v41 = lang.NewFnFunc(func(args ...any) any { + var v4 any = lang.NewList(args[1:]...) + _ = v4 + var tmp5 any + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("seq")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("apply")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("disj")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("apply")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("hash-set")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("keys")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.Apply(tmp23, []any{v3}) + tmp25 := lang.Apply(tmp17, []any{tmp20, tmp24}) + tmp26 := lang.Apply(tmp11, []any{tmp14, tmp25, v4}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + if lang.IsTruthy(tmp27) { + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("apply")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("str")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("first")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.Apply(tmp36, []any{v4}) + tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp39 := tmp38.FindInternedVar(lang.NewSymbol("map")) + if tmp39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) + } + tmp40 := tmp39.Get() + var tmp41 lang.FnFunc + tmp41 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v42 := args[0] _ = v42 - v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v44 := v43.FindInternedVar(lang.NewSymbol("str")) - if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) - } - v45 := v44.Get() - v46 := lang.Apply(v45, []any{", ", v42}) - return v46 + tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp44 := tmp43.FindInternedVar(lang.NewSymbol("str")) + if tmp44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) + } + tmp45 := tmp44.Get() + tmp46 := lang.Apply(tmp45, []any{", ", v42}) + return tmp46 }) - v42 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1718), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(1718), lang.NewKeyword("end-column"), int(28)) - v43, err := lang.WithMeta(v41, v42.(lang.IPersistentMap)) + tmp42 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1718), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(1718), lang.NewKeyword("end-column"), int(28)) + tmp43, err := lang.WithMeta(tmp41, tmp42.(lang.IPersistentMap)) if err != nil { panic(err) } - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("rest")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) - } - v46 := v45.Get() - v47 := lang.Apply(v46, []any{v4}) - v48 := lang.Apply(v40, []any{v43, v47}) - v49 := lang.Apply(v30, []any{v33, "Only these options are valid: ", v37, v48}) - v50 := lang.Apply(lang.NewIllegalArgumentError, []any{v49}) - panic(v50) + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("rest")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) + } + tmp46 := tmp45.Get() + tmp47 := lang.Apply(tmp46, []any{v4}) + tmp48 := lang.Apply(tmp40, []any{tmp43, tmp47}) + tmp49 := lang.Apply(tmp30, []any{tmp33, "Only these options are valid: ", tmp37, tmp48}) + tmp50 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp49}) + panic(tmp50) } else { - v5 = nil } - return v5 + return tmp5 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // chunk { - v0 := lang.NewSymbol("chunk").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(691), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(691), lang.NewKeyword("end-column"), int(41), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("b"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("chunk").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(691), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(691), lang.NewKeyword("end-column"), int(41), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("b"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4, ok := lang.FieldOrMethod(v3, "chunk") + tmp4, ok := lang.FieldOrMethod(v3, "chunk") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "chunk"))) } - var v5 any - switch reflect.TypeOf(v4).Kind() { + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { case reflect.Func: - v5 = lang.Apply(v4, nil) + tmp5 = lang.Apply(tmp4, nil) default: - v5 = v4 + tmp5 = tmp4 } - return v5 + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // chunk-append { - v0 := lang.NewSymbol("chunk-append").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(688), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(688), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("b"), lang.NewSymbol("x"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("chunk-append").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(688), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(688), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("b"), lang.NewSymbol("x"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -17441,43 +17513,43 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5, _ := lang.FieldOrMethod(v3, "add") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(v3, "add") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // chunk-buffer { - v0 := lang.NewSymbol("chunk-buffer").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(685), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(685), lang.NewKeyword("end-column"), int(53), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("capacity"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("chunk-buffer").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(685), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(685), lang.NewKeyword("end-column"), int(53), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("capacity"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.Apply(lang.NewChunkBuffer, []any{v3}) - return v4 + tmp4 := lang.Apply(lang.NewChunkBuffer, []any{v3}) + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // chunk-cons { - v0 := lang.NewSymbol("chunk-cons").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(703), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(703), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("chunk"), lang.NewSymbol("rest"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("chunk-cons").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(703), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(703), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("chunk"), lang.NewSymbol("rest"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -17485,258 +17557,261 @@ func init() { _ = v3 v4 := args[1] _ = v4 - var v5 any - v6 := lang.Apply(lang.Count, []any{v3}) - v7 := lang.Apply(lang.IsZero, []any{v6}) - if lang.IsTruthy(v7) { - v5 = v4 + var tmp5 any + tmp6 := lang.Apply(lang.Count, []any{v3}) + tmp7 := lang.Apply(lang.IsZero, []any{tmp6}) + if lang.IsTruthy(tmp7) { + tmp5 = v4 } else { - v8 := lang.Apply(lang.NewChunkedCons, []any{v3, v4}) - v5 = v8 + tmp8 := lang.Apply(lang.NewChunkedCons, []any{v3, v4}) + tmp5 = tmp8 } - return v5 + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // chunk-first { - v0 := lang.NewSymbol("chunk-first").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(694), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(694), lang.NewKeyword("end-column"), int(48), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("chunk-first").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(694), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(694), lang.NewKeyword("end-column"), int(48), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4, ok := lang.FieldOrMethod(v3, "chunkedFirst") + tmp4, ok := lang.FieldOrMethod(v3, "chunkedFirst") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "chunkedFirst"))) } - var v5 any - switch reflect.TypeOf(v4).Kind() { + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { case reflect.Func: - v5 = lang.Apply(v4, nil) + tmp5 = lang.Apply(tmp4, nil) default: - v5 = v4 + tmp5 = tmp4 } - return v5 + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // chunk-next { - v0 := lang.NewSymbol("chunk-next").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(700), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(700), lang.NewKeyword("end-column"), int(71), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("chunk-next").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(700), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(700), lang.NewKeyword("end-column"), int(71), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4, ok := lang.FieldOrMethod(v3, "chunkedNext") + tmp4, ok := lang.FieldOrMethod(v3, "chunkedNext") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "chunkedNext"))) } - var v5 any - switch reflect.TypeOf(v4).Kind() { + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { case reflect.Func: - v5 = lang.Apply(v4, nil) + tmp5 = lang.Apply(tmp4, nil) default: - v5 = v4 + tmp5 = tmp4 } - return v5 + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // chunk-rest { - v0 := lang.NewSymbol("chunk-rest").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(697), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(697), lang.NewKeyword("end-column"), int(71), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("chunk-rest").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(697), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(697), lang.NewKeyword("end-column"), int(71), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4, ok := lang.FieldOrMethod(v3, "chunkedMore") + tmp4, ok := lang.FieldOrMethod(v3, "chunkedMore") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "chunkedMore"))) } - var v5 any - switch reflect.TypeOf(v4).Kind() { + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { case reflect.Func: - v5 = lang.Apply(v4, nil) + tmp5 = lang.Apply(tmp4, nil) default: - v5 = v4 + tmp5 = tmp4 } - return v5 + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // chunked-seq? { - v0 := lang.NewSymbol("chunked-seq?").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(708), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(708), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("chunked-seq?").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(708), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(708), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) } - v6 := v5.Get() - v7 := lang.Apply(v6, []any{lang.IChunkedSeq, v3}) - return v7 + tmp6 := tmp5.Get() + tmp7 := reflect.TypeOf((*lang.IChunkedSeq)(nil)).Elem() + tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) + return tmp8 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // class { - v0 := lang.NewSymbol("class").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns the Class of x", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3461), lang.NewKeyword("end-line"), int(3461))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("class").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns the Class of x", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3461), lang.NewKeyword("end-line"), int(3461))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("nil?")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v3}) - if lang.IsTruthy(v8) { - v4 = v3 + var tmp4 any + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("nil?")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v3}) + if lang.IsTruthy(tmp8) { + tmp4 = v3 } else { - v9 := lang.Apply(lang.TypeOf, []any{v3}) - v4 = v9 + tmp9 := lang.Apply(lang.TypeOf, []any{v3}) + tmp4 = tmp9 } - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // class? { - v0 := lang.NewSymbol("class?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is an instance of Class", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5465), lang.NewKeyword("end-line"), int(5465))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("class?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is an instance of Class", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5465), lang.NewKeyword("end-line"), int(5465))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) } - v6 := v5.Get() - v7 := lang.Apply(v6, []any{reflect.Type, v3}) - return v7 + tmp6 := tmp5.Get() + tmp7 := reflect.TypeOf((*reflect.Type)(nil)).Elem() + tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) + return tmp8 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // clear-agent-errors { - v0 := lang.NewSymbol("clear-agent-errors").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("doc"), "DEPRECATED: Use 'restart-agent' instead.\n Clears any exceptions thrown during asynchronous actions of the\n agent, allowing subsequent actions to occur.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("deprecated"), "1.2", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2244), lang.NewKeyword("end-line"), int(2244))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("clear-agent-errors").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("doc"), "DEPRECATED: Use 'restart-agent' instead.\n Clears any exceptions thrown during asynchronous actions of the\n agent, allowing subsequent actions to occur.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("deprecated"), "1.2", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2244), lang.NewKeyword("end-line"), int(2244))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("restart-agent")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("restart-agent")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) } - v6 := v5.Get() - v7, ok := lang.FieldOrMethod(v3, "Deref") + tmp6 := tmp5.Get() + tmp7, ok := lang.FieldOrMethod(v3, "Deref") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "Deref"))) } - var v8 any - switch reflect.TypeOf(v7).Kind() { + var tmp8 any + switch reflect.TypeOf(tmp7).Kind() { case reflect.Func: - v8 = lang.Apply(v7, nil) + tmp8 = lang.Apply(tmp7, nil) default: - v8 = v7 + tmp8 = tmp7 } - v9 := lang.Apply(v6, []any{v3, v8}) - return v9 + tmp9 := lang.Apply(tmp6, []any{v3, tmp8}) + return tmp9 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // coll? { - v0 := lang.NewSymbol("coll?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements IPersistentCollection", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6192), lang.NewKeyword("end-line"), int(6192))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("coll?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements IPersistentCollection", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6192), lang.NewKeyword("end-line"), int(6192))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) } - v6 := v5.Get() - v7 := lang.Apply(v6, []any{lang.IPersistentCollection, v3}) - return v7 + tmp6 := tmp5.Get() + tmp7 := reflect.TypeOf((*lang.IPersistentCollection)(nil)).Elem() + tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) + return tmp8 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // comment { - v0 := lang.NewSymbol("comment").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Ignores body, yields nil", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4733), lang.NewKeyword("end-line"), int(4733))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("comment").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Ignores body, yields nil", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4733), lang.NewKeyword("end-line"), int(4733))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 2 { @@ -17746,21 +17821,22 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.NewList(args[2:]...) + var v5 any = lang.NewList(args[2:]...) + _ = v5 return nil } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // commute { - v0 := lang.NewSymbol("commute").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("fun"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Must be called in a transaction. Sets the in-transaction-value of\n ref to:\n\n (apply fun in-transaction-value-of-ref args)\n\n and returns the in-transaction-value of ref.\n\n At the commit point of the transaction, sets the value of ref to be:\n\n (apply fun most-recently-committed-value-of-ref args)\n\n Thus fun should be commutative, or, failing that, you must accept\n last-one-in-wins behavior. commute allows for more concurrency than\n ref-set.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2414), lang.NewKeyword("end-line"), int(2414))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("commute").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("fun"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Must be called in a transaction. Sets the in-transaction-value of\n ref to:\n\n (apply fun in-transaction-value-of-ref args)\n\n and returns the in-transaction-value of ref.\n\n At the commit point of the transaction, sets the value of ref to be:\n\n (apply fun most-recently-committed-value-of-ref args)\n\n Thus fun should be commutative, or, failing that, you must accept\n last-one-in-wins behavior. commute allows for more concurrency than\n ref-set.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2414), lang.NewKeyword("end-line"), int(2414))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 2 { @@ -17770,35 +17846,36 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.NewList(args[2:]...) - v6, _ := lang.FieldOrMethod(v3, "Commute") - if reflect.TypeOf(v6).Kind() != reflect.Func { + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6, _ := lang.FieldOrMethod(v3, "Commute") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Commute is not a function"))) } - v7 := lang.Apply(v6, []any{v4, v5}) - return v7 + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // comp { - v0 := lang.NewSymbol("comp").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("g")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("g"), lang.NewSymbol("&"), lang.NewSymbol("fs"))), lang.NewKeyword("doc"), "Takes a set of functions and returns a fn that is the composition\n of those fns. The returned fn takes a variable number of args,\n applies the rightmost of fns to the args, the next\n fn (right-to-left) to the result, etc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2549), lang.NewKeyword("end-line"), int(2549))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("comp").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("g")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("g"), lang.NewSymbol("&"), lang.NewSymbol("fs"))), lang.NewKeyword("doc"), "Takes a set of functions and returns a fn that is the composition\n of those fns. The returned fn takes a variable number of args,\n applies the rightmost of fns to the args, the next\n fn (right-to-left) to the result, etc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2549), lang.NewKeyword("end-line"), int(2549))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v4 := v3.FindInternedVar(lang.NewSymbol("identity")) - if v4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) + tmp3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp4 := tmp3.FindInternedVar(lang.NewSymbol("identity")) + if tmp4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp4))) } - v5 := v4.Get() - return v5 + tmp5 := tmp4.Get() + return tmp5 case 1: v3 := args[0] _ = v3 @@ -17808,27 +17885,27 @@ func init() { _ = v3 v4 := args[1] _ = v4 - var v5 lang.FnFunc - v5 = lang.NewFnFunc(func(args ...any) any { + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - v6 := lang.Apply(v4, nil) - v7 := lang.Apply(v3, []any{v6}) - return v7 + tmp6 := lang.Apply(v4, nil) + tmp7 := lang.Apply(v3, []any{tmp6}) + return tmp7 case 1: v6 := args[0] _ = v6 - v7 := lang.Apply(v4, []any{v6}) - v8 := lang.Apply(v3, []any{v7}) - return v8 + tmp7 := lang.Apply(v4, []any{v6}) + tmp8 := lang.Apply(v3, []any{tmp7}) + return tmp8 case 2: v6 := args[0] _ = v6 v7 := args[1] _ = v7 - v8 := lang.Apply(v4, []any{v6, v7}) - v9 := lang.Apply(v3, []any{v8}) - return v9 + tmp8 := lang.Apply(v4, []any{v6, v7}) + tmp9 := lang.Apply(v3, []any{tmp8}) + return tmp9 case 3: v6 := args[0] _ = v6 @@ -17836,9 +17913,9 @@ func init() { _ = v7 v8 := args[2] _ = v8 - v9 := lang.Apply(v4, []any{v6, v7, v8}) - v10 := lang.Apply(v3, []any{v9}) - return v10 + tmp9 := lang.Apply(v4, []any{v6, v7, v8}) + tmp10 := lang.Apply(v3, []any{tmp9}) + return tmp10 default: if len(args) < 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -17849,24 +17926,25 @@ func init() { _ = v7 v8 := args[2] _ = v8 - v9 := lang.NewList(args[3:]...) - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("apply")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + var v9 any = lang.NewList(args[3:]...) + _ = v9 + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("apply")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{v4, v6, v7, v8, v9}) - v14 := lang.Apply(v3, []any{v13}) - return v14 + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{v4, v6, v7, v8, v9}) + tmp14 := lang.Apply(v3, []any{tmp13}) + return tmp14 } }) - v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2559), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2564), lang.NewKeyword("end-column"), int(49)) - v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) + tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2559), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2564), lang.NewKeyword("end-column"), int(49)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) if err != nil { panic(err) } - return v7 + return tmp7 default: if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -17875,48 +17953,49 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.NewList(args[2:]...) - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("reduce1")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) } - v8 := v7.Get() - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("comp")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + tmp8 := tmp7.Get() + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("comp")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) } - v11 := v10.Get() - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("list*")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + tmp11 := tmp10.Get() + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("list*")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) } - v14 := v13.Get() - v15 := lang.Apply(v14, []any{v3, v4, v5}) - v16 := lang.Apply(v8, []any{v11, v15}) - return v16 + tmp14 := tmp13.Get() + tmp15 := lang.Apply(tmp14, []any{v3, v4, v5}) + tmp16 := lang.Apply(tmp8, []any{tmp11, tmp15}) + return tmp16 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // comparator { - v0 := lang.NewSymbol("comparator").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"))), lang.NewKeyword("doc"), "Returns an implementation of java.util.Comparator based upon pred.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3077), lang.NewKeyword("end-line"), int(3077))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("comparator").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"))), lang.NewKeyword("doc"), "Returns an implementation of java.util.Comparator based upon pred.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3077), lang.NewKeyword("end-line"), int(3077))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 lang.FnFunc - v4 = lang.NewFnFunc(func(args ...any) any { + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -17924,46 +18003,46 @@ func init() { _ = v5 v6 := args[1] _ = v6 - var v7 any - v8 := lang.Apply(v3, []any{v5, v6}) - if lang.IsTruthy(v8) { - v7 = int64(-1) + var tmp7 any + tmp8 := lang.Apply(v3, []any{v5, v6}) + if lang.IsTruthy(tmp8) { + tmp7 = int64(-1) } else { - var v9 any - v10 := lang.Apply(v3, []any{v6, v5}) - if lang.IsTruthy(v10) { - v9 = int64(1) + var tmp9 any + tmp10 := lang.Apply(v3, []any{v6, v5}) + if lang.IsTruthy(tmp10) { + tmp9 = int64(1) } else { - var v11 any + var tmp11 any if lang.IsTruthy(lang.NewKeyword("else")) { - v11 = int64(0) + tmp11 = int64(0) } else { - v11 = nil } - v9 = v11 + tmp9 = tmp11 } - v7 = v9 + tmp7 = tmp9 } - return v7 + return tmp7 }) - v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3082), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(3083), lang.NewKeyword("end-column"), int(48)) - v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) + tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3082), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(3083), lang.NewKeyword("end-column"), int(48)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) if err != nil { panic(err) } - return v6 + return tmp6 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // compare { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function compare__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -17971,63 +18050,63 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("seq")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("concat")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("list")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("list")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{lang.NewSymbol("glojure.lang.Util")}) - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("list")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{lang.NewSymbol("glojure.core/compare")}) - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("list")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.Apply(v25, []any{v3}) - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{v4}) - v31 := lang.Apply(v10, []any{v14, v18, v22, v26, v30}) - v32 := lang.Apply(v7, []any{v31}) - return v32 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("concat")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("list")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol(".")}) + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("glojure.lang.Util")}) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("glojure.core/compare")}) + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.Apply(tmp25, []any{v3}) + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{v4}) + tmp31 := lang.Apply(tmp10, []any{tmp14, tmp18, tmp22, tmp26, tmp30}) + tmp32 := lang.Apply(tmp7, []any{tmp31}) + return tmp32 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("compare").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Comparator. Returns a negative number, zero, or a positive number\n when x is logically 'less than', 'equal to', or 'greater than'\n y. Same as Java x.compareTo(y) except it also works for nil, and\n compares numbers and collections in a type-independent manner. x\n must implement Comparable", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(824), lang.NewKeyword("end-line"), int(824))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("compare").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Comparator. Returns a negative number, zero, or a positive number\n when x is logically 'less than', 'equal to', or 'greater than'\n y. Same as Java x.compareTo(y) except it also works for nil, and\n compares numbers and collections in a type-independent manner. x\n must implement Comparable", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(824), lang.NewKeyword("end-line"), int(824))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -18035,20 +18114,20 @@ func init() { _ = v4 v5 := args[1] _ = v5 - v6 := lang.Apply(lang.Compare, []any{v4, v5}) - return v6 + tmp6 := lang.Apply(lang.Compare, []any{v4, v5}) + return tmp6 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // compare-and-set! { - v0 := lang.NewSymbol("compare-and-set!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atom"), lang.NewSymbol("oldval"), lang.NewSymbol("newval"))), lang.NewKeyword("doc"), "Atomically sets the value of atom to newval if and only if the\n current value of the atom is identical to oldval. Returns true if\n set happened, else false", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2360), lang.NewKeyword("end-line"), int(2360))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("compare-and-set!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atom"), lang.NewSymbol("oldval"), lang.NewSymbol("newval"))), lang.NewKeyword("doc"), "Atomically sets the value of atom to newval if and only if the\n current value of the atom is identical to oldval. Returns true if\n set happened, else false", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2360), lang.NewKeyword("end-line"), int(2360))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -18058,127 +18137,128 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6, _ := lang.FieldOrMethod(v3, "compareAndSet") - if reflect.TypeOf(v6).Kind() != reflect.Func { + tmp6, _ := lang.FieldOrMethod(v3, "compareAndSet") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("compareAndSet is not a function"))) } - v7 := lang.Apply(v6, []any{v4, v5}) - return v7 + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // compile { - v0 := lang.NewSymbol("compile").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"))), lang.NewKeyword("doc"), "Compiles the namespace named by the symbol lib into a set of\n classfiles. The source for the lib must be in a proper\n classpath-relative directory. The output files will go into the\n directory specified by *compile-path*, and that directory too must\n be in the classpath.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6114), lang.NewKeyword("end-line"), int(6114))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("compile").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"))), lang.NewKeyword("doc"), "Compiles the namespace named by the symbol lib into a set of\n classfiles. The source for the lib must be in a proper\n classpath-relative directory. The output files will go into the\n directory specified by *compile-path*, and that directory too must\n be in the classpath.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6114), lang.NewKeyword("end-line"), int(6114))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any + var tmp4 any { // let - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("push-thread-bindings")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("hash-map")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*compile-files*")) - v12 := lang.Apply(v10, []any{v11, true}) - v13 := lang.Apply(v7, []any{v12}) - _ = v13 - var v14 any + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("push-thread-bindings")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("hash-map")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*compile-files*")) + tmp12 := lang.Apply(tmp10, []any{tmp11, true}) + tmp13 := lang.Apply(tmp7, []any{tmp12}) + _ = tmp13 + var tmp14 any func() { defer func() { - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, nil) + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, nil) + _ = tmp18 }() - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("load-one")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{v3, true, true}) - v14 = v22 + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("load-one")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, []any{v3, true, true}) + tmp14 = tmp22 }() - v4 = v14 + tmp4 = tmp14 } // end let - _ = v4 + _ = tmp4 return v3 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // complement { - v0 := lang.NewSymbol("complement").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Takes a fn f and returns a fn that takes the same arguments as f,\n has the same effects, if any, and returns the opposite truth value.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1428), lang.NewKeyword("end-line"), int(1428))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("complement").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Takes a fn f and returns a fn that takes the same arguments as f,\n has the same effects, if any, and returns the opposite truth value.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1428), lang.NewKeyword("end-line"), int(1428))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 lang.FnFunc - v4 = lang.NewFnFunc(func(args ...any) any { + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("not")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v3, nil) - v9 := lang.Apply(v7, []any{v8}) - return v9 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("not")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(v3, nil) + tmp9 := lang.Apply(tmp7, []any{tmp8}) + return tmp9 case 1: v5 := args[0] _ = v5 - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("not")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v3, []any{v5}) - v10 := lang.Apply(v8, []any{v9}) - return v10 + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("not")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.Apply(v3, []any{v5}) + tmp10 := lang.Apply(tmp8, []any{tmp9}) + return tmp10 case 2: v5 := args[0] _ = v5 v6 := args[1] _ = v6 - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("not")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v3, []any{v5, v6}) - v11 := lang.Apply(v9, []any{v10}) - return v11 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("not")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(v3, []any{v5, v6}) + tmp11 := lang.Apply(tmp9, []any{tmp10}) + return tmp11 default: if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -18187,234 +18267,235 @@ func init() { _ = v5 v6 := args[1] _ = v6 - v7 := lang.NewList(args[2:]...) - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("not")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("apply")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{v3, v5, v6, v7}) - v15 := lang.Apply(v10, []any{v14}) - return v15 + var v7 any = lang.NewList(args[2:]...) + _ = v7 + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("not")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("apply")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{v3, v5, v6, v7}) + tmp15 := lang.Apply(tmp10, []any{tmp14}) + return tmp15 } }) - v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1434), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(1438), lang.NewKeyword("end-column"), int(40)) - v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) + tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1434), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(1438), lang.NewKeyword("end-column"), int(40)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) if err != nil { panic(err) } - return v6 + return tmp6 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // completing { - v0 := lang.NewSymbol("completing").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("cf"))), lang.NewKeyword("doc"), "Takes a reducing function f of 2 args and returns a fn suitable for\n transduce by adding an arity-1 signature that calls cf (default -\n identity) on the result argument.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6893), lang.NewKeyword("end-line"), int(6893))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("completing").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("cf"))), lang.NewKeyword("doc"), "Takes a reducing function f of 2 args and returns a fn suitable for\n transduce by adding an arity-1 signature that calls cf (default -\n identity) on the result argument.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6893), lang.NewKeyword("end-line"), int(6893))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("completing")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("identity")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v6, []any{v3, v9}) - return v10 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("completing")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("identity")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp6, []any{v3, tmp9}) + return tmp10 case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - var v5 lang.FnFunc - v5 = lang.NewFnFunc(func(args ...any) any { + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - v6 := lang.Apply(v3, nil) - return v6 + tmp6 := lang.Apply(v3, nil) + return tmp6 case 1: v6 := args[0] _ = v6 - v7 := lang.Apply(v4, []any{v6}) - return v7 + tmp7 := lang.Apply(v4, []any{v6}) + return tmp7 case 2: v6 := args[0] _ = v6 v7 := args[1] _ = v7 - v8 := lang.Apply(v3, []any{v6, v7}) - return v8 + tmp8 := lang.Apply(v3, []any{v6, v7}) + return tmp8 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6900), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(6903), lang.NewKeyword("end-column"), int(23)) - v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) + tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6900), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(6903), lang.NewKeyword("end-column"), int(23)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) if err != nil { panic(err) } - return v7 + return tmp7 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // concat { - v0 := lang.NewSymbol("concat").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("zs"))), lang.NewKeyword("doc"), "Returns a lazy seq representing the concatenation of the elements in the supplied colls.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(711), lang.NewKeyword("end-line"), int(711))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("concat").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("zs"))), lang.NewKeyword("doc"), "Returns a lazy seq representing the concatenation of the elements in the supplied colls.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(711), lang.NewKeyword("end-line"), int(711))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } return nil }) - v4 := lang.Apply(lang.NewLazySeq, []any{v3}) - return v4 + tmp4 := lang.Apply(lang.NewLazySeq, []any{tmp3}) + return tmp4 case 1: v3 := args[0] _ = v3 - var v4 lang.FnFunc - v4 = lang.NewFnFunc(func(args ...any) any { + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } return v3 }) - v5 := lang.Apply(lang.NewLazySeq, []any{v4}) - return v5 + tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) + return tmp5 case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - var v5 lang.FnFunc - v5 = lang.NewFnFunc(func(args ...any) any { + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - var v6 any + var tmp6 any { // let // let binding "s" - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("seq")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v9, []any{v3}) - var v11 any = v10 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("seq")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp9, []any{v3}) + var v11 any = tmp10 _ = v11 - var v12 any + var tmp12 any if lang.IsTruthy(v11) { - var v13 any - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("chunked-seq?")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{v11}) - if lang.IsTruthy(v17) { - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("chunk-cons")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + var tmp13 any + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("chunked-seq?")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{v11}) + if lang.IsTruthy(tmp17) { + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("chunk-cons")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) } - v20 := v19.Get() - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("chunk-first")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + tmp20 := tmp19.Get() + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("chunk-first")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) } - v23 := v22.Get() - v24 := lang.Apply(v23, []any{v11}) - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("concat")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + tmp23 := tmp22.Get() + tmp24 := lang.Apply(tmp23, []any{v11}) + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("concat")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) } - v27 := v26.Get() - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("chunk-rest")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + tmp27 := tmp26.Get() + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("chunk-rest")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) } - v30 := v29.Get() - v31 := lang.Apply(v30, []any{v11}) - v32 := lang.Apply(v27, []any{v31, v4}) - v33 := lang.Apply(v20, []any{v24, v32}) - v13 = v33 + tmp30 := tmp29.Get() + tmp31 := lang.Apply(tmp30, []any{v11}) + tmp32 := lang.Apply(tmp27, []any{tmp31, v4}) + tmp33 := lang.Apply(tmp20, []any{tmp24, tmp32}) + tmp13 = tmp33 } else { - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("cons")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("cons")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) } - v36 := v35.Get() - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("first")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + tmp36 := tmp35.Get() + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("first")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) } - v39 := v38.Get() - v40 := lang.Apply(v39, []any{v11}) - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("concat")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + tmp39 := tmp38.Get() + tmp40 := lang.Apply(tmp39, []any{v11}) + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("concat")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) } - v43 := v42.Get() - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("rest")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + tmp43 := tmp42.Get() + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("rest")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) } - v46 := v45.Get() - v47 := lang.Apply(v46, []any{v11}) - v48 := lang.Apply(v43, []any{v47, v4}) - v49 := lang.Apply(v36, []any{v40, v48}) - v13 = v49 + tmp46 := tmp45.Get() + tmp47 := lang.Apply(tmp46, []any{v11}) + tmp48 := lang.Apply(tmp43, []any{tmp47, v4}) + tmp49 := lang.Apply(tmp36, []any{tmp40, tmp48}) + tmp13 = tmp49 } - v12 = v13 + tmp12 = tmp13 } else { - v12 = v4 + tmp12 = v4 } - v6 = v12 + tmp6 = tmp12 } // end let - return v6 + return tmp6 }) - v6 := lang.Apply(lang.NewLazySeq, []any{v5}) - return v6 + tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) + return tmp6 default: if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -18423,13 +18504,15 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.NewList(args[2:]...) - var v6 any + var v5 any = lang.NewList(args[2:]...) + _ = v5 + var tmp6 any { // let // let binding "cat" - var v7 lang.FnFunc + var tmp7 lang.FnFunc { // function cat - v7 = lang.NewFnFunc(func(args ...any) any { + var v8 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -18437,148 +18520,147 @@ func init() { _ = v9 v10 := args[1] _ = v10 - var v11 lang.FnFunc - v11 = lang.NewFnFunc(func(args ...any) any { + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - var v12 any + var tmp12 any { // let // let binding "xys" - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("seq")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("seq")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{v9}) - var v17 any = v16 + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{v9}) + var v17 any = tmp16 _ = v17 - var v18 any + var tmp18 any if lang.IsTruthy(v17) { - var v19 any - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("chunked-seq?")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + var tmp19 any + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("chunked-seq?")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) } - v22 := v21.Get() - v23 := lang.Apply(v22, []any{v17}) - if lang.IsTruthy(v23) { - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("chunk-cons")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + tmp22 := tmp21.Get() + tmp23 := lang.Apply(tmp22, []any{v17}) + if lang.IsTruthy(tmp23) { + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("chunk-cons")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("chunk-first")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("chunk-first")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{v17}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("chunk-rest")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{v17}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("chunk-rest")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{v17}) - v35 := lang.Apply(v8, []any{v34, v10}) - v36 := lang.Apply(v26, []any{v30, v35}) - v19 = v36 + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{v17}) + tmp35 := lang.Apply(v8, []any{tmp34, v10}) + tmp36 := lang.Apply(tmp26, []any{tmp30, tmp35}) + tmp19 = tmp36 } else { - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("cons")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("cons")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) } - v39 := v38.Get() - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("first")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + tmp39 := tmp38.Get() + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("first")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) } - v42 := v41.Get() - v43 := lang.Apply(v42, []any{v17}) - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("rest")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + tmp42 := tmp41.Get() + tmp43 := lang.Apply(tmp42, []any{v17}) + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("rest")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) } - v46 := v45.Get() - v47 := lang.Apply(v46, []any{v17}) - v48 := lang.Apply(v8, []any{v47, v10}) - v49 := lang.Apply(v39, []any{v43, v48}) - v19 = v49 + tmp46 := tmp45.Get() + tmp47 := lang.Apply(tmp46, []any{v17}) + tmp48 := lang.Apply(v8, []any{tmp47, v10}) + tmp49 := lang.Apply(tmp39, []any{tmp43, tmp48}) + tmp19 = tmp49 } - v18 = v19 + tmp18 = tmp19 } else { - var v50 any + var tmp50 any if lang.IsTruthy(v10) { - v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v52 := v51.FindInternedVar(lang.NewSymbol("first")) - if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) + tmp51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp52 := tmp51.FindInternedVar(lang.NewSymbol("first")) + if tmp52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp52))) } - v53 := v52.Get() - v54 := lang.Apply(v53, []any{v10}) - v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v56 := v55.FindInternedVar(lang.NewSymbol("next")) - if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) + tmp53 := tmp52.Get() + tmp54 := lang.Apply(tmp53, []any{v10}) + tmp55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp56 := tmp55.FindInternedVar(lang.NewSymbol("next")) + if tmp56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp56))) } - v57 := v56.Get() - v58 := lang.Apply(v57, []any{v10}) - v59 := lang.Apply(v8, []any{v54, v58}) - v50 = v59 + tmp57 := tmp56.Get() + tmp58 := lang.Apply(tmp57, []any{v10}) + tmp59 := lang.Apply(v8, []any{tmp54, tmp58}) + tmp50 = tmp59 } else { - v50 = nil } - v18 = v50 + tmp18 = tmp50 } - v12 = v18 + tmp12 = tmp18 } // end let - return v12 + return tmp12 }) - v12 := lang.Apply(lang.NewLazySeq, []any{v11}) - return v12 + tmp12 := lang.Apply(lang.NewLazySeq, []any{tmp11}) + return tmp12 }) - v8 := v7 + v8 = tmp7 _ = v8 } - v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(726), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(735), lang.NewKeyword("end-column"), int(56)) - v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) + tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(726), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(735), lang.NewKeyword("end-column"), int(56)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) if err != nil { panic(err) } - var v10 any = v9 + var v10 any = tmp9 _ = v10 - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("concat")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{v3, v4}) - v15 := lang.Apply(v10, []any{v14, v5}) - v6 = v15 + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("concat")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{v3, v4}) + tmp15 := lang.Apply(v10, []any{tmp14, v5}) + tmp6 = tmp15 } // end let - return v6 + return tmp6 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // cond { - v0 := lang.NewSymbol("cond").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes a set of test/expr pairs. It evaluates each test one at a\n time. If a test returns logical true, cond evaluates and returns\n the value of the corresponding expr and doesn't evaluate any of the\n other tests or exprs. (cond) returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(569), lang.NewKeyword("end-line"), int(569))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("cond").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes a set of test/expr pairs. It evaluates each test one at a\n time. If a test returns logical true, cond evaluates and returns\n the value of the corresponding expr and doesn't evaluate any of the\n other tests or exprs. (cond) returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(569), lang.NewKeyword("end-line"), int(569))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 2 { @@ -18588,83 +18670,83 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.NewList(args[2:]...) - var v6 any + var v5 any = lang.NewList(args[2:]...) + _ = v5 + var tmp6 any if lang.IsTruthy(v5) { - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("list")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("first")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{v5}) - var v14 any - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("next")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{v5}) - if lang.IsTruthy(v18) { - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("second")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{v5}) - v14 = v22 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("list")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("first")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{v5}) + var tmp14 any + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("next")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{v5}) + if lang.IsTruthy(tmp18) { + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("second")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, []any{v5}) + tmp14 = tmp22 } else { - v23 := lang.Apply(lang.NewIllegalArgumentError, []any{"cond requires an even number of forms"}) - panic(v23) - } - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("cons")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("next")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("next")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) - } - v32 := v31.Get() - v33 := lang.Apply(v32, []any{v5}) - v34 := lang.Apply(v29, []any{v33}) - v35 := lang.Apply(v26, []any{lang.NewSymbol("glojure.core/cond"), v34}) - v36 := lang.Apply(v9, []any{lang.NewSymbol("if"), v13, v14, v35}) - v6 = v36 + tmp23 := lang.Apply(lang.NewIllegalArgumentError, []any{"cond requires an even number of forms"}) + panic(tmp23) + } + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("cons")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("next")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("next")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) + } + tmp32 := tmp31.Get() + tmp33 := lang.Apply(tmp32, []any{v5}) + tmp34 := lang.Apply(tmp29, []any{tmp33}) + tmp35 := lang.Apply(tmp26, []any{lang.NewSymbol("glojure.core/cond"), tmp34}) + tmp36 := lang.Apply(tmp9, []any{lang.NewSymbol("if"), tmp13, tmp14, tmp35}) + tmp6 = tmp36 } else { - v6 = nil } - return v6 + return tmp6 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // cond-> { - v0 := lang.NewSymbol("cond->").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes an expression and a set of test/form pairs. Threads expr (via ->)\n through each form for which the corresponding test\n expression is true. Note that, unlike cond branching, cond-> threading does\n not short circuit after the first true test expression.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7564), lang.NewKeyword("end-line"), int(7564))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("cond->").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes an expression and a set of test/form pairs. Threads expr (via ->)\n through each form for which the corresponding test\n expression is true. Note that, unlike cond branching, cond-> threading does\n not short circuit after the first true test expression.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7564), lang.NewKeyword("end-line"), int(7564))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 3 { @@ -18676,288 +18758,288 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - _ = nil - var v7 any + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any { // let // let binding "g" - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("gensym")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, nil) - var v12 any = v11 + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("gensym")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, nil) + var v12 any = tmp11 _ = v12 // let binding "steps" - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("map")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - var v16 lang.FnFunc - v16 = lang.NewFnFunc(func(args ...any) any { + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("map")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + var tmp16 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v17 := args[0] _ = v17 - var v18 any + var tmp18 any { // let // let binding "vec__337" var v19 any = v17 _ = v19 // let binding "test" - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("nth")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.Apply(v22, []any{v19, int64(0), nil}) - var v24 any = v23 + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("nth")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.Apply(tmp22, []any{v19, int64(0), nil}) + var v24 any = tmp23 _ = v24 // let binding "step" - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("nth")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.Apply(v27, []any{v19, int64(1), nil}) - var v29 any = v28 + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("nth")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.Apply(tmp27, []any{v19, int64(1), nil}) + var v29 any = tmp28 _ = v29 - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("seq")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) - } - v32 := v31.Get() - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("concat")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("list")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.Apply(v38, []any{lang.NewSymbol("if")}) - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("list")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) - } - v42 := v41.Get() - v43 := lang.Apply(v42, []any{v24}) - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("list")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) - } - v46 := v45.Get() - v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v48 := v47.FindInternedVar(lang.NewSymbol("seq")) - if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) - } - v49 := v48.Get() - v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v51 := v50.FindInternedVar(lang.NewSymbol("concat")) - if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) - } - v52 := v51.Get() - v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v54 := v53.FindInternedVar(lang.NewSymbol("list")) - if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) - } - v55 := v54.Get() - v56 := lang.Apply(v55, []any{lang.NewSymbol("glojure.core/->")}) - v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v58 := v57.FindInternedVar(lang.NewSymbol("list")) - if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) - } - v59 := v58.Get() - v60 := lang.Apply(v59, []any{v12}) - v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v62 := v61.FindInternedVar(lang.NewSymbol("list")) - if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) - } - v63 := v62.Get() - v64 := lang.Apply(v63, []any{v29}) - v65 := lang.Apply(v52, []any{v56, v60, v64}) - v66 := lang.Apply(v49, []any{v65}) - v67 := lang.Apply(v46, []any{v66}) - v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v69 := v68.FindInternedVar(lang.NewSymbol("list")) - if v69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) - } - v70 := v69.Get() - v71 := lang.Apply(v70, []any{v12}) - v72 := lang.Apply(v35, []any{v39, v43, v67, v71}) - v73 := lang.Apply(v32, []any{v72}) - v18 = v73 + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("seq")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) + } + tmp32 := tmp31.Get() + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("concat")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) + } + tmp35 := tmp34.Get() + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{lang.NewSymbol("if")}) + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) + } + tmp42 := tmp41.Get() + tmp43 := lang.Apply(tmp42, []any{v24}) + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) + } + tmp46 := tmp45.Get() + tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp48 := tmp47.FindInternedVar(lang.NewSymbol("seq")) + if tmp48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) + } + tmp49 := tmp48.Get() + tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp51 := tmp50.FindInternedVar(lang.NewSymbol("concat")) + if tmp51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) + } + tmp52 := tmp51.Get() + tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp54 := tmp53.FindInternedVar(lang.NewSymbol("list")) + if tmp54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) + } + tmp55 := tmp54.Get() + tmp56 := lang.Apply(tmp55, []any{lang.NewSymbol("glojure.core/->")}) + tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp58 := tmp57.FindInternedVar(lang.NewSymbol("list")) + if tmp58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) + } + tmp59 := tmp58.Get() + tmp60 := lang.Apply(tmp59, []any{v12}) + tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp62 := tmp61.FindInternedVar(lang.NewSymbol("list")) + if tmp62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) + } + tmp63 := tmp62.Get() + tmp64 := lang.Apply(tmp63, []any{v29}) + tmp65 := lang.Apply(tmp52, []any{tmp56, tmp60, tmp64}) + tmp66 := lang.Apply(tmp49, []any{tmp65}) + tmp67 := lang.Apply(tmp46, []any{tmp66}) + tmp68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp69 := tmp68.FindInternedVar(lang.NewSymbol("list")) + if tmp69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp69))) + } + tmp70 := tmp69.Get() + tmp71 := lang.Apply(tmp70, []any{v12}) + tmp72 := lang.Apply(tmp35, []any{tmp39, tmp43, tmp67, tmp71}) + tmp73 := lang.Apply(tmp32, []any{tmp72}) + tmp18 = tmp73 } // end let - return v18 + return tmp18 }) - v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7573), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7573), lang.NewKeyword("end-column"), int(66)) - v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) + tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7573), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7573), lang.NewKeyword("end-column"), int(66)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) if err != nil { panic(err) } - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("partition")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("partition")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{int64(2), v6}) - v23 := lang.Apply(v15, []any{v18, v22}) - var v24 any = v23 + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, []any{int64(2), v6}) + tmp23 := lang.Apply(tmp15, []any{tmp18, tmp22}) + var v24 any = tmp23 _ = v24 - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("seq")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("concat")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/let")}) - v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v36 := v35.FindInternedVar(lang.NewSymbol("list")) - if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) - } - v37 := v36.Get() - v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v39 := v38.FindInternedVar(lang.NewSymbol("apply")) - if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) - } - v40 := v39.Get() - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("vector")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) - } - v43 := v42.Get() - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("seq")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) - } - v46 := v45.Get() - v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v48 := v47.FindInternedVar(lang.NewSymbol("concat")) - if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) - } - v49 := v48.Get() - v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v51 := v50.FindInternedVar(lang.NewSymbol("list")) - if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) - } - v52 := v51.Get() - v53 := lang.Apply(v52, []any{v12}) - v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v55 := v54.FindInternedVar(lang.NewSymbol("list")) - if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) - } - v56 := v55.Get() - v57 := lang.Apply(v56, []any{v5}) - v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v59 := v58.FindInternedVar(lang.NewSymbol("interleave")) - if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) - } - v60 := v59.Get() - v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v62 := v61.FindInternedVar(lang.NewSymbol("repeat")) - if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) - } - v63 := v62.Get() - v64 := lang.Apply(v63, []any{v12}) - v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v66 := v65.FindInternedVar(lang.NewSymbol("butlast")) - if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) - } - v67 := v66.Get() - v68 := lang.Apply(v67, []any{v24}) - v69 := lang.Apply(v60, []any{v64, v68}) - v70 := lang.Apply(v49, []any{v53, v57, v69}) - v71 := lang.Apply(v46, []any{v70}) - v72 := lang.Apply(v40, []any{v43, v71}) - v73 := lang.Apply(v37, []any{v72}) - v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v75 := v74.FindInternedVar(lang.NewSymbol("list")) - if v75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) - } - v76 := v75.Get() - var v77 any - v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v79 := v78.FindInternedVar(lang.NewSymbol("empty?")) - if v79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) - } - v80 := v79.Get() - v81 := lang.Apply(v80, []any{v24}) - if lang.IsTruthy(v81) { - v77 = v12 + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("seq")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("concat")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{lang.NewSymbol("glojure.core/let")}) + tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp36 := tmp35.FindInternedVar(lang.NewSymbol("list")) + if tmp36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) + } + tmp37 := tmp36.Get() + tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp39 := tmp38.FindInternedVar(lang.NewSymbol("apply")) + if tmp39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) + } + tmp40 := tmp39.Get() + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("vector")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("seq")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) + } + tmp46 := tmp45.Get() + tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp48 := tmp47.FindInternedVar(lang.NewSymbol("concat")) + if tmp48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) + } + tmp49 := tmp48.Get() + tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp51 := tmp50.FindInternedVar(lang.NewSymbol("list")) + if tmp51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) + } + tmp52 := tmp51.Get() + tmp53 := lang.Apply(tmp52, []any{v12}) + tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp55 := tmp54.FindInternedVar(lang.NewSymbol("list")) + if tmp55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) + } + tmp56 := tmp55.Get() + tmp57 := lang.Apply(tmp56, []any{v5}) + tmp58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp59 := tmp58.FindInternedVar(lang.NewSymbol("interleave")) + if tmp59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp59))) + } + tmp60 := tmp59.Get() + tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp62 := tmp61.FindInternedVar(lang.NewSymbol("repeat")) + if tmp62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) + } + tmp63 := tmp62.Get() + tmp64 := lang.Apply(tmp63, []any{v12}) + tmp65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp66 := tmp65.FindInternedVar(lang.NewSymbol("butlast")) + if tmp66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp66))) + } + tmp67 := tmp66.Get() + tmp68 := lang.Apply(tmp67, []any{v24}) + tmp69 := lang.Apply(tmp60, []any{tmp64, tmp68}) + tmp70 := lang.Apply(tmp49, []any{tmp53, tmp57, tmp69}) + tmp71 := lang.Apply(tmp46, []any{tmp70}) + tmp72 := lang.Apply(tmp40, []any{tmp43, tmp71}) + tmp73 := lang.Apply(tmp37, []any{tmp72}) + tmp74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp75 := tmp74.FindInternedVar(lang.NewSymbol("list")) + if tmp75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp75))) + } + tmp76 := tmp75.Get() + var tmp77 any + tmp78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp79 := tmp78.FindInternedVar(lang.NewSymbol("empty?")) + if tmp79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp79))) + } + tmp80 := tmp79.Get() + tmp81 := lang.Apply(tmp80, []any{v24}) + if lang.IsTruthy(tmp81) { + tmp77 = v12 } else { - v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v83 := v82.FindInternedVar(lang.NewSymbol("last")) - if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) - } - v84 := v83.Get() - v85 := lang.Apply(v84, []any{v24}) - v77 = v85 - } - v86 := lang.Apply(v76, []any{v77}) - v87 := lang.Apply(v30, []any{v34, v73, v86}) - v88 := lang.Apply(v27, []any{v87}) - v7 = v88 + tmp82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp83 := tmp82.FindInternedVar(lang.NewSymbol("last")) + if tmp83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp83))) + } + tmp84 := tmp83.Get() + tmp85 := lang.Apply(tmp84, []any{v24}) + tmp77 = tmp85 + } + tmp86 := lang.Apply(tmp76, []any{tmp77}) + tmp87 := lang.Apply(tmp30, []any{tmp34, tmp73, tmp86}) + tmp88 := lang.Apply(tmp27, []any{tmp87}) + tmp7 = tmp88 } // end let - return v7 + return tmp7 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // cond->> { - v0 := lang.NewSymbol("cond->>").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes an expression and a set of test/form pairs. Threads expr (via ->>)\n through each form for which the corresponding test expression\n is true. Note that, unlike cond branching, cond->> threading does not short circuit\n after the first true test expression.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7581), lang.NewKeyword("end-line"), int(7581))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("cond->>").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes an expression and a set of test/form pairs. Threads expr (via ->>)\n through each form for which the corresponding test expression\n is true. Note that, unlike cond branching, cond->> threading does not short circuit\n after the first true test expression.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7581), lang.NewKeyword("end-line"), int(7581))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 3 { @@ -18969,288 +19051,288 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - _ = nil - var v7 any + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any { // let // let binding "g" - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("gensym")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, nil) - var v12 any = v11 + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("gensym")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, nil) + var v12 any = tmp11 _ = v12 // let binding "steps" - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("map")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - var v16 lang.FnFunc - v16 = lang.NewFnFunc(func(args ...any) any { + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("map")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + var tmp16 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v17 := args[0] _ = v17 - var v18 any + var tmp18 any { // let // let binding "vec__341" var v19 any = v17 _ = v19 // let binding "test" - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("nth")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.Apply(v22, []any{v19, int64(0), nil}) - var v24 any = v23 + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("nth")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.Apply(tmp22, []any{v19, int64(0), nil}) + var v24 any = tmp23 _ = v24 // let binding "step" - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("nth")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.Apply(v27, []any{v19, int64(1), nil}) - var v29 any = v28 + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("nth")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.Apply(tmp27, []any{v19, int64(1), nil}) + var v29 any = tmp28 _ = v29 - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("seq")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) - } - v32 := v31.Get() - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("concat")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("list")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.Apply(v38, []any{lang.NewSymbol("if")}) - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("list")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) - } - v42 := v41.Get() - v43 := lang.Apply(v42, []any{v24}) - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("list")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) - } - v46 := v45.Get() - v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v48 := v47.FindInternedVar(lang.NewSymbol("seq")) - if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) - } - v49 := v48.Get() - v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v51 := v50.FindInternedVar(lang.NewSymbol("concat")) - if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) - } - v52 := v51.Get() - v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v54 := v53.FindInternedVar(lang.NewSymbol("list")) - if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) - } - v55 := v54.Get() - v56 := lang.Apply(v55, []any{lang.NewSymbol("glojure.core/->>")}) - v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v58 := v57.FindInternedVar(lang.NewSymbol("list")) - if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) - } - v59 := v58.Get() - v60 := lang.Apply(v59, []any{v12}) - v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v62 := v61.FindInternedVar(lang.NewSymbol("list")) - if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) - } - v63 := v62.Get() - v64 := lang.Apply(v63, []any{v29}) - v65 := lang.Apply(v52, []any{v56, v60, v64}) - v66 := lang.Apply(v49, []any{v65}) - v67 := lang.Apply(v46, []any{v66}) - v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v69 := v68.FindInternedVar(lang.NewSymbol("list")) - if v69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) - } - v70 := v69.Get() - v71 := lang.Apply(v70, []any{v12}) - v72 := lang.Apply(v35, []any{v39, v43, v67, v71}) - v73 := lang.Apply(v32, []any{v72}) - v18 = v73 + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("seq")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) + } + tmp32 := tmp31.Get() + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("concat")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) + } + tmp35 := tmp34.Get() + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{lang.NewSymbol("if")}) + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) + } + tmp42 := tmp41.Get() + tmp43 := lang.Apply(tmp42, []any{v24}) + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) + } + tmp46 := tmp45.Get() + tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp48 := tmp47.FindInternedVar(lang.NewSymbol("seq")) + if tmp48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) + } + tmp49 := tmp48.Get() + tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp51 := tmp50.FindInternedVar(lang.NewSymbol("concat")) + if tmp51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) + } + tmp52 := tmp51.Get() + tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp54 := tmp53.FindInternedVar(lang.NewSymbol("list")) + if tmp54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) + } + tmp55 := tmp54.Get() + tmp56 := lang.Apply(tmp55, []any{lang.NewSymbol("glojure.core/->>")}) + tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp58 := tmp57.FindInternedVar(lang.NewSymbol("list")) + if tmp58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) + } + tmp59 := tmp58.Get() + tmp60 := lang.Apply(tmp59, []any{v12}) + tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp62 := tmp61.FindInternedVar(lang.NewSymbol("list")) + if tmp62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) + } + tmp63 := tmp62.Get() + tmp64 := lang.Apply(tmp63, []any{v29}) + tmp65 := lang.Apply(tmp52, []any{tmp56, tmp60, tmp64}) + tmp66 := lang.Apply(tmp49, []any{tmp65}) + tmp67 := lang.Apply(tmp46, []any{tmp66}) + tmp68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp69 := tmp68.FindInternedVar(lang.NewSymbol("list")) + if tmp69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp69))) + } + tmp70 := tmp69.Get() + tmp71 := lang.Apply(tmp70, []any{v12}) + tmp72 := lang.Apply(tmp35, []any{tmp39, tmp43, tmp67, tmp71}) + tmp73 := lang.Apply(tmp32, []any{tmp72}) + tmp18 = tmp73 } // end let - return v18 + return tmp18 }) - v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7590), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7590), lang.NewKeyword("end-column"), int(67)) - v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) + tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7590), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7590), lang.NewKeyword("end-column"), int(67)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) if err != nil { panic(err) } - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("partition")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("partition")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{int64(2), v6}) - v23 := lang.Apply(v15, []any{v18, v22}) - var v24 any = v23 + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, []any{int64(2), v6}) + tmp23 := lang.Apply(tmp15, []any{tmp18, tmp22}) + var v24 any = tmp23 _ = v24 - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("seq")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("concat")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/let")}) - v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v36 := v35.FindInternedVar(lang.NewSymbol("list")) - if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) - } - v37 := v36.Get() - v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v39 := v38.FindInternedVar(lang.NewSymbol("apply")) - if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) - } - v40 := v39.Get() - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("vector")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) - } - v43 := v42.Get() - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("seq")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) - } - v46 := v45.Get() - v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v48 := v47.FindInternedVar(lang.NewSymbol("concat")) - if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) - } - v49 := v48.Get() - v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v51 := v50.FindInternedVar(lang.NewSymbol("list")) - if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) - } - v52 := v51.Get() - v53 := lang.Apply(v52, []any{v12}) - v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v55 := v54.FindInternedVar(lang.NewSymbol("list")) - if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) - } - v56 := v55.Get() - v57 := lang.Apply(v56, []any{v5}) - v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v59 := v58.FindInternedVar(lang.NewSymbol("interleave")) - if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) - } - v60 := v59.Get() - v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v62 := v61.FindInternedVar(lang.NewSymbol("repeat")) - if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) - } - v63 := v62.Get() - v64 := lang.Apply(v63, []any{v12}) - v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v66 := v65.FindInternedVar(lang.NewSymbol("butlast")) - if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) - } - v67 := v66.Get() - v68 := lang.Apply(v67, []any{v24}) - v69 := lang.Apply(v60, []any{v64, v68}) - v70 := lang.Apply(v49, []any{v53, v57, v69}) - v71 := lang.Apply(v46, []any{v70}) - v72 := lang.Apply(v40, []any{v43, v71}) - v73 := lang.Apply(v37, []any{v72}) - v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v75 := v74.FindInternedVar(lang.NewSymbol("list")) - if v75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) - } - v76 := v75.Get() - var v77 any - v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v79 := v78.FindInternedVar(lang.NewSymbol("empty?")) - if v79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) - } - v80 := v79.Get() - v81 := lang.Apply(v80, []any{v24}) - if lang.IsTruthy(v81) { - v77 = v12 + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("seq")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("concat")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{lang.NewSymbol("glojure.core/let")}) + tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp36 := tmp35.FindInternedVar(lang.NewSymbol("list")) + if tmp36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) + } + tmp37 := tmp36.Get() + tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp39 := tmp38.FindInternedVar(lang.NewSymbol("apply")) + if tmp39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) + } + tmp40 := tmp39.Get() + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("vector")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("seq")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) + } + tmp46 := tmp45.Get() + tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp48 := tmp47.FindInternedVar(lang.NewSymbol("concat")) + if tmp48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) + } + tmp49 := tmp48.Get() + tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp51 := tmp50.FindInternedVar(lang.NewSymbol("list")) + if tmp51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) + } + tmp52 := tmp51.Get() + tmp53 := lang.Apply(tmp52, []any{v12}) + tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp55 := tmp54.FindInternedVar(lang.NewSymbol("list")) + if tmp55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) + } + tmp56 := tmp55.Get() + tmp57 := lang.Apply(tmp56, []any{v5}) + tmp58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp59 := tmp58.FindInternedVar(lang.NewSymbol("interleave")) + if tmp59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp59))) + } + tmp60 := tmp59.Get() + tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp62 := tmp61.FindInternedVar(lang.NewSymbol("repeat")) + if tmp62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) + } + tmp63 := tmp62.Get() + tmp64 := lang.Apply(tmp63, []any{v12}) + tmp65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp66 := tmp65.FindInternedVar(lang.NewSymbol("butlast")) + if tmp66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp66))) + } + tmp67 := tmp66.Get() + tmp68 := lang.Apply(tmp67, []any{v24}) + tmp69 := lang.Apply(tmp60, []any{tmp64, tmp68}) + tmp70 := lang.Apply(tmp49, []any{tmp53, tmp57, tmp69}) + tmp71 := lang.Apply(tmp46, []any{tmp70}) + tmp72 := lang.Apply(tmp40, []any{tmp43, tmp71}) + tmp73 := lang.Apply(tmp37, []any{tmp72}) + tmp74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp75 := tmp74.FindInternedVar(lang.NewSymbol("list")) + if tmp75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp75))) + } + tmp76 := tmp75.Get() + var tmp77 any + tmp78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp79 := tmp78.FindInternedVar(lang.NewSymbol("empty?")) + if tmp79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp79))) + } + tmp80 := tmp79.Get() + tmp81 := lang.Apply(tmp80, []any{v24}) + if lang.IsTruthy(tmp81) { + tmp77 = v12 } else { - v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v83 := v82.FindInternedVar(lang.NewSymbol("last")) - if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) - } - v84 := v83.Get() - v85 := lang.Apply(v84, []any{v24}) - v77 = v85 - } - v86 := lang.Apply(v76, []any{v77}) - v87 := lang.Apply(v30, []any{v34, v73, v86}) - v88 := lang.Apply(v27, []any{v87}) - v7 = v88 + tmp82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp83 := tmp82.FindInternedVar(lang.NewSymbol("last")) + if tmp83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp83))) + } + tmp84 := tmp83.Get() + tmp85 := lang.Apply(tmp84, []any{v24}) + tmp77 = tmp85 + } + tmp86 := lang.Apply(tmp76, []any{tmp77}) + tmp87 := lang.Apply(tmp30, []any{tmp34, tmp73, tmp86}) + tmp88 := lang.Apply(tmp27, []any{tmp87}) + tmp7 = tmp88 } // end let - return v7 + return tmp7 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // condp { - v0 := lang.NewSymbol("condp").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes a binary predicate, an expression, and a set of clauses.\n Each clause can take the form of either:\n\n test-expr result-expr\n\n test-expr :>> result-fn\n\n Note :>> is an ordinary keyword.\n\n For each clause, (pred test-expr expr) is evaluated. If it returns\n logical true, the clause is a match. If a binary clause matches, the\n result-expr is returned, if a ternary clause matches, its result-fn,\n which must be a unary function, is called with the result of the\n predicate as its argument, the result of that call being the return\n value of condp. A single default expression can follow the clauses,\n and its value will be returned if no clause matches. If no default\n expression is provided and no clause matches, an\n IllegalArgumentException is thrown.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6353), lang.NewKeyword("end-line"), int(6353))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("condp").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes a binary predicate, an expression, and a set of clauses.\n Each clause can take the form of either:\n\n test-expr result-expr\n\n test-expr :>> result-fn\n\n Note :>> is an ordinary keyword.\n\n For each clause, (pred test-expr expr) is evaluated. If it returns\n logical true, the clause is a match. If a binary clause matches, the\n result-expr is returned, if a ternary clause matches, its result-fn,\n which must be a unary function, is called with the result of the\n predicate as its argument, the result of that call being the return\n value of condp. A single default expression can follow the clauses,\n and its value will be returned if no clause matches. If no default\n expression is provided and no clause matches, an\n IllegalArgumentException is thrown.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6353), lang.NewKeyword("end-line"), int(6353))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 4 { @@ -19264,33 +19346,35 @@ func init() { _ = v5 v6 := args[3] _ = v6 - v7 := lang.NewList(args[4:]...) - var v8 any + var v7 any = lang.NewList(args[4:]...) + _ = v7 + var tmp8 any { // let // let binding "gpred" - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("gensym")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.Apply(v11, []any{"pred__"}) - var v13 any = v12 + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("gensym")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.Apply(tmp11, []any{"pred__"}) + var v13 any = tmp12 _ = v13 // let binding "gexpr" - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("gensym")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{"expr__"}) - var v18 any = v17 + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("gensym")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{"expr__"}) + var v18 any = tmp17 _ = v18 // let binding "emit" - var v19 lang.FnFunc + var tmp19 lang.FnFunc { // function emit - v19 = lang.NewFnFunc(func(args ...any) any { + var v20 lang.FnFunc + tmp19 = lang.NewFnFunc(func(args ...any) any { if len(args) != 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -19300,593 +19384,593 @@ func init() { _ = v22 v23 := args[2] _ = v23 - var v24 any + var tmp24 any { // let // let binding "vec__144" - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("split-at")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("split-at")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) } - v27 := v26.Get() - var v28 any - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("=")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + tmp27 := tmp26.Get() + var tmp28 any + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("=")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) } - v31 := v30.Get() - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("second")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + tmp31 := tmp30.Get() + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("second")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{v23}) - v36 := lang.Apply(v31, []any{lang.NewKeyword(">>"), v35}) - if lang.IsTruthy(v36) { - v28 = int64(3) + tmp34 := tmp33.Get() + tmp35 := lang.Apply(tmp34, []any{v23}) + tmp36 := lang.Apply(tmp31, []any{lang.NewKeyword(">>"), tmp35}) + if lang.IsTruthy(tmp36) { + tmp28 = int64(3) } else { - v28 = int64(2) + tmp28 = int64(2) } - v37 := lang.Apply(v27, []any{v28, v23}) - var v38 any = v37 + tmp37 := lang.Apply(tmp27, []any{tmp28, v23}) + var v38 any = tmp37 _ = v38 // let binding "vec__147" - v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v40 := v39.FindInternedVar(lang.NewSymbol("nth")) - if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) + tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp40 := tmp39.FindInternedVar(lang.NewSymbol("nth")) + if tmp40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) } - v41 := v40.Get() - v42 := lang.Apply(v41, []any{v38, int64(0), nil}) - var v43 any = v42 + tmp41 := tmp40.Get() + tmp42 := lang.Apply(tmp41, []any{v38, int64(0), nil}) + var v43 any = tmp42 _ = v43 // let binding "a" - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("nth")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("nth")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) } - v46 := v45.Get() - v47 := lang.Apply(v46, []any{v43, int64(0), nil}) - var v48 any = v47 + tmp46 := tmp45.Get() + tmp47 := lang.Apply(tmp46, []any{v43, int64(0), nil}) + var v48 any = tmp47 _ = v48 // let binding "b" - v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v50 := v49.FindInternedVar(lang.NewSymbol("nth")) - if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) + tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp50 := tmp49.FindInternedVar(lang.NewSymbol("nth")) + if tmp50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) } - v51 := v50.Get() - v52 := lang.Apply(v51, []any{v43, int64(1), nil}) - var v53 any = v52 + tmp51 := tmp50.Get() + tmp52 := lang.Apply(tmp51, []any{v43, int64(1), nil}) + var v53 any = tmp52 _ = v53 // let binding "c" - v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v55 := v54.FindInternedVar(lang.NewSymbol("nth")) - if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) + tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp55 := tmp54.FindInternedVar(lang.NewSymbol("nth")) + if tmp55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) } - v56 := v55.Get() - v57 := lang.Apply(v56, []any{v43, int64(2), nil}) - var v58 any = v57 + tmp56 := tmp55.Get() + tmp57 := lang.Apply(tmp56, []any{v43, int64(2), nil}) + var v58 any = tmp57 _ = v58 // let binding "clause" var v59 any = v43 _ = v59 // let binding "more" - v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v61 := v60.FindInternedVar(lang.NewSymbol("nth")) - if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) + tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp61 := tmp60.FindInternedVar(lang.NewSymbol("nth")) + if tmp61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) } - v62 := v61.Get() - v63 := lang.Apply(v62, []any{v38, int64(1), nil}) - var v64 any = v63 + tmp62 := tmp61.Get() + tmp63 := lang.Apply(tmp62, []any{v38, int64(1), nil}) + var v64 any = tmp63 _ = v64 // let binding "n" - v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v66 := v65.FindInternedVar(lang.NewSymbol("count")) - if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) + tmp65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp66 := tmp65.FindInternedVar(lang.NewSymbol("count")) + if tmp66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp66))) } - v67 := v66.Get() - v68 := lang.Apply(v67, []any{v59}) - var v69 any = v68 + tmp67 := tmp66.Get() + tmp68 := lang.Apply(tmp67, []any{v59}) + var v69 any = tmp68 _ = v69 - var v70 any - v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v72 := v71.FindInternedVar(lang.NewSymbol("=")) - if v72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) + var tmp70 any + tmp71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp72 := tmp71.FindInternedVar(lang.NewSymbol("=")) + if tmp72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp72))) } - v73 := v72.Get() - v74 := lang.Apply(v73, []any{int64(0), v69}) - if lang.IsTruthy(v74) { - v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v76 := v75.FindInternedVar(lang.NewSymbol("seq")) - if v76.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) + tmp73 := tmp72.Get() + tmp74 := lang.Apply(tmp73, []any{int64(0), v69}) + if lang.IsTruthy(tmp74) { + tmp75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp76 := tmp75.FindInternedVar(lang.NewSymbol("seq")) + if tmp76.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp76))) } - v77 := v76.Get() - v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v79 := v78.FindInternedVar(lang.NewSymbol("concat")) - if v79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) + tmp77 := tmp76.Get() + tmp78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp79 := tmp78.FindInternedVar(lang.NewSymbol("concat")) + if tmp79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp79))) } - v80 := v79.Get() - v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v82 := v81.FindInternedVar(lang.NewSymbol("list")) - if v82.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) + tmp80 := tmp79.Get() + tmp81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp82 := tmp81.FindInternedVar(lang.NewSymbol("list")) + if tmp82.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp82))) } - v83 := v82.Get() - v84 := lang.Apply(v83, []any{lang.NewSymbol("throw")}) - v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v86 := v85.FindInternedVar(lang.NewSymbol("list")) - if v86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) + tmp83 := tmp82.Get() + tmp84 := lang.Apply(tmp83, []any{lang.NewSymbol("throw")}) + tmp85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp86 := tmp85.FindInternedVar(lang.NewSymbol("list")) + if tmp86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp86))) } - v87 := v86.Get() - v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v89 := v88.FindInternedVar(lang.NewSymbol("seq")) - if v89.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) + tmp87 := tmp86.Get() + tmp88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp89 := tmp88.FindInternedVar(lang.NewSymbol("seq")) + if tmp89.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp89))) } - v90 := v89.Get() - v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v92 := v91.FindInternedVar(lang.NewSymbol("concat")) - if v92.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) + tmp90 := tmp89.Get() + tmp91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp92 := tmp91.FindInternedVar(lang.NewSymbol("concat")) + if tmp92.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp92))) } - v93 := v92.Get() - v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v95 := v94.FindInternedVar(lang.NewSymbol("list")) - if v95.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) + tmp93 := tmp92.Get() + tmp94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp95 := tmp94.FindInternedVar(lang.NewSymbol("list")) + if tmp95.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp95))) } - v96 := v95.Get() - v97 := lang.Apply(v96, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewIllegalArgumentError")}) - v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v99 := v98.FindInternedVar(lang.NewSymbol("list")) - if v99.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) + tmp96 := tmp95.Get() + tmp97 := lang.Apply(tmp96, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewIllegalArgumentError")}) + tmp98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp99 := tmp98.FindInternedVar(lang.NewSymbol("list")) + if tmp99.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp99))) } - v100 := v99.Get() - v101 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v102 := v101.FindInternedVar(lang.NewSymbol("seq")) - if v102.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v102))) + tmp100 := tmp99.Get() + tmp101 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp102 := tmp101.FindInternedVar(lang.NewSymbol("seq")) + if tmp102.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp102))) } - v103 := v102.Get() - v104 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v105 := v104.FindInternedVar(lang.NewSymbol("concat")) - if v105.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v105))) + tmp103 := tmp102.Get() + tmp104 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp105 := tmp104.FindInternedVar(lang.NewSymbol("concat")) + if tmp105.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp105))) } - v106 := v105.Get() - v107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v108 := v107.FindInternedVar(lang.NewSymbol("list")) - if v108.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v108))) + tmp106 := tmp105.Get() + tmp107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp108 := tmp107.FindInternedVar(lang.NewSymbol("list")) + if tmp108.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp108))) } - v109 := v108.Get() - v110 := lang.Apply(v109, []any{lang.NewSymbol("glojure.core/str")}) - v111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v112 := v111.FindInternedVar(lang.NewSymbol("list")) - if v112.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v112))) + tmp109 := tmp108.Get() + tmp110 := lang.Apply(tmp109, []any{lang.NewSymbol("glojure.core/str")}) + tmp111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp112 := tmp111.FindInternedVar(lang.NewSymbol("list")) + if tmp112.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp112))) } - v113 := v112.Get() - v114 := lang.Apply(v113, []any{"No matching clause: "}) - v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v116 := v115.FindInternedVar(lang.NewSymbol("list")) - if v116.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) + tmp113 := tmp112.Get() + tmp114 := lang.Apply(tmp113, []any{"No matching clause: "}) + tmp115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp116 := tmp115.FindInternedVar(lang.NewSymbol("list")) + if tmp116.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp116))) } - v117 := v116.Get() - v118 := lang.Apply(v117, []any{v22}) - v119 := lang.Apply(v106, []any{v110, v114, v118}) - v120 := lang.Apply(v103, []any{v119}) - v121 := lang.Apply(v100, []any{v120}) - v122 := lang.Apply(v93, []any{v97, v121}) - v123 := lang.Apply(v90, []any{v122}) - v124 := lang.Apply(v87, []any{v123}) - v125 := lang.Apply(v80, []any{v84, v124}) - v126 := lang.Apply(v77, []any{v125}) - v70 = v126 + tmp117 := tmp116.Get() + tmp118 := lang.Apply(tmp117, []any{v22}) + tmp119 := lang.Apply(tmp106, []any{tmp110, tmp114, tmp118}) + tmp120 := lang.Apply(tmp103, []any{tmp119}) + tmp121 := lang.Apply(tmp100, []any{tmp120}) + tmp122 := lang.Apply(tmp93, []any{tmp97, tmp121}) + tmp123 := lang.Apply(tmp90, []any{tmp122}) + tmp124 := lang.Apply(tmp87, []any{tmp123}) + tmp125 := lang.Apply(tmp80, []any{tmp84, tmp124}) + tmp126 := lang.Apply(tmp77, []any{tmp125}) + tmp70 = tmp126 } else { - var v127 any - v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v129 := v128.FindInternedVar(lang.NewSymbol("=")) - if v129.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v129))) + var tmp127 any + tmp128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp129 := tmp128.FindInternedVar(lang.NewSymbol("=")) + if tmp129.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp129))) } - v130 := v129.Get() - v131 := lang.Apply(v130, []any{int64(1), v69}) - if lang.IsTruthy(v131) { - v127 = v48 + tmp130 := tmp129.Get() + tmp131 := lang.Apply(tmp130, []any{int64(1), v69}) + if lang.IsTruthy(tmp131) { + tmp127 = v48 } else { - var v132 any - v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v134 := v133.FindInternedVar(lang.NewSymbol("=")) - if v134.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) + var tmp132 any + tmp133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp134 := tmp133.FindInternedVar(lang.NewSymbol("=")) + if tmp134.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp134))) } - v135 := v134.Get() - v136 := lang.Apply(v135, []any{int64(2), v69}) - if lang.IsTruthy(v136) { - v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v138 := v137.FindInternedVar(lang.NewSymbol("seq")) - if v138.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) + tmp135 := tmp134.Get() + tmp136 := lang.Apply(tmp135, []any{int64(2), v69}) + if lang.IsTruthy(tmp136) { + tmp137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp138 := tmp137.FindInternedVar(lang.NewSymbol("seq")) + if tmp138.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp138))) } - v139 := v138.Get() - v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v141 := v140.FindInternedVar(lang.NewSymbol("concat")) - if v141.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) + tmp139 := tmp138.Get() + tmp140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp141 := tmp140.FindInternedVar(lang.NewSymbol("concat")) + if tmp141.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp141))) } - v142 := v141.Get() - v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v144 := v143.FindInternedVar(lang.NewSymbol("list")) - if v144.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) + tmp142 := tmp141.Get() + tmp143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp144 := tmp143.FindInternedVar(lang.NewSymbol("list")) + if tmp144.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp144))) } - v145 := v144.Get() - v146 := lang.Apply(v145, []any{lang.NewSymbol("if")}) - v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v148 := v147.FindInternedVar(lang.NewSymbol("list")) - if v148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) + tmp145 := tmp144.Get() + tmp146 := lang.Apply(tmp145, []any{lang.NewSymbol("if")}) + tmp147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp148 := tmp147.FindInternedVar(lang.NewSymbol("list")) + if tmp148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp148))) } - v149 := v148.Get() - v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v151 := v150.FindInternedVar(lang.NewSymbol("seq")) - if v151.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) + tmp149 := tmp148.Get() + tmp150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp151 := tmp150.FindInternedVar(lang.NewSymbol("seq")) + if tmp151.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp151))) } - v152 := v151.Get() - v153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v154 := v153.FindInternedVar(lang.NewSymbol("concat")) - if v154.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v154))) + tmp152 := tmp151.Get() + tmp153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp154 := tmp153.FindInternedVar(lang.NewSymbol("concat")) + if tmp154.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp154))) } - v155 := v154.Get() - v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v157 := v156.FindInternedVar(lang.NewSymbol("list")) - if v157.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) + tmp155 := tmp154.Get() + tmp156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp157 := tmp156.FindInternedVar(lang.NewSymbol("list")) + if tmp157.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp157))) } - v158 := v157.Get() - v159 := lang.Apply(v158, []any{v21}) - v160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v161 := v160.FindInternedVar(lang.NewSymbol("list")) - if v161.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v161))) + tmp158 := tmp157.Get() + tmp159 := lang.Apply(tmp158, []any{v21}) + tmp160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp161 := tmp160.FindInternedVar(lang.NewSymbol("list")) + if tmp161.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp161))) } - v162 := v161.Get() - v163 := lang.Apply(v162, []any{v48}) - v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v165 := v164.FindInternedVar(lang.NewSymbol("list")) - if v165.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) + tmp162 := tmp161.Get() + tmp163 := lang.Apply(tmp162, []any{v48}) + tmp164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp165 := tmp164.FindInternedVar(lang.NewSymbol("list")) + if tmp165.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp165))) } - v166 := v165.Get() - v167 := lang.Apply(v166, []any{v22}) - v168 := lang.Apply(v155, []any{v159, v163, v167}) - v169 := lang.Apply(v152, []any{v168}) - v170 := lang.Apply(v149, []any{v169}) - v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v172 := v171.FindInternedVar(lang.NewSymbol("list")) - if v172.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) + tmp166 := tmp165.Get() + tmp167 := lang.Apply(tmp166, []any{v22}) + tmp168 := lang.Apply(tmp155, []any{tmp159, tmp163, tmp167}) + tmp169 := lang.Apply(tmp152, []any{tmp168}) + tmp170 := lang.Apply(tmp149, []any{tmp169}) + tmp171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp172 := tmp171.FindInternedVar(lang.NewSymbol("list")) + if tmp172.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp172))) } - v173 := v172.Get() - v174 := lang.Apply(v173, []any{v53}) - v175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v176 := v175.FindInternedVar(lang.NewSymbol("list")) - if v176.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v176))) + tmp173 := tmp172.Get() + tmp174 := lang.Apply(tmp173, []any{v53}) + tmp175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp176 := tmp175.FindInternedVar(lang.NewSymbol("list")) + if tmp176.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp176))) } - v177 := v176.Get() - v178 := lang.Apply(v20, []any{v21, v22, v64}) - v179 := lang.Apply(v177, []any{v178}) - v180 := lang.Apply(v142, []any{v146, v170, v174, v179}) - v181 := lang.Apply(v139, []any{v180}) - v132 = v181 + tmp177 := tmp176.Get() + tmp178 := lang.Apply(v20, []any{v21, v22, v64}) + tmp179 := lang.Apply(tmp177, []any{tmp178}) + tmp180 := lang.Apply(tmp142, []any{tmp146, tmp170, tmp174, tmp179}) + tmp181 := lang.Apply(tmp139, []any{tmp180}) + tmp132 = tmp181 } else { - var v182 any + var tmp182 any if lang.IsTruthy(lang.NewKeyword("else")) { - v183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v184 := v183.FindInternedVar(lang.NewSymbol("seq")) - if v184.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v184))) + tmp183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp184 := tmp183.FindInternedVar(lang.NewSymbol("seq")) + if tmp184.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp184))) } - v185 := v184.Get() - v186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v187 := v186.FindInternedVar(lang.NewSymbol("concat")) - if v187.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v187))) + tmp185 := tmp184.Get() + tmp186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp187 := tmp186.FindInternedVar(lang.NewSymbol("concat")) + if tmp187.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp187))) } - v188 := v187.Get() - v189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v190 := v189.FindInternedVar(lang.NewSymbol("list")) - if v190.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v190))) + tmp188 := tmp187.Get() + tmp189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp190 := tmp189.FindInternedVar(lang.NewSymbol("list")) + if tmp190.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp190))) } - v191 := v190.Get() - v192 := lang.Apply(v191, []any{lang.NewSymbol("glojure.core/if-let")}) - v193 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v194 := v193.FindInternedVar(lang.NewSymbol("list")) - if v194.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v194))) + tmp191 := tmp190.Get() + tmp192 := lang.Apply(tmp191, []any{lang.NewSymbol("glojure.core/if-let")}) + tmp193 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp194 := tmp193.FindInternedVar(lang.NewSymbol("list")) + if tmp194.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp194))) } - v195 := v194.Get() - v196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v197 := v196.FindInternedVar(lang.NewSymbol("apply")) - if v197.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v197))) + tmp195 := tmp194.Get() + tmp196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp197 := tmp196.FindInternedVar(lang.NewSymbol("apply")) + if tmp197.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp197))) } - v198 := v197.Get() - v199 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v200 := v199.FindInternedVar(lang.NewSymbol("vector")) - if v200.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v200))) + tmp198 := tmp197.Get() + tmp199 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp200 := tmp199.FindInternedVar(lang.NewSymbol("vector")) + if tmp200.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp200))) } - v201 := v200.Get() - v202 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v203 := v202.FindInternedVar(lang.NewSymbol("seq")) - if v203.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v203))) + tmp201 := tmp200.Get() + tmp202 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp203 := tmp202.FindInternedVar(lang.NewSymbol("seq")) + if tmp203.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp203))) } - v204 := v203.Get() - v205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v206 := v205.FindInternedVar(lang.NewSymbol("concat")) - if v206.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v206))) + tmp204 := tmp203.Get() + tmp205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp206 := tmp205.FindInternedVar(lang.NewSymbol("concat")) + if tmp206.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp206))) } - v207 := v206.Get() - v208 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v209 := v208.FindInternedVar(lang.NewSymbol("list")) - if v209.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v209))) + tmp207 := tmp206.Get() + tmp208 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp209 := tmp208.FindInternedVar(lang.NewSymbol("list")) + if tmp209.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp209))) } - v210 := v209.Get() - v211 := lang.Apply(v210, []any{lang.NewSymbol("p__0__auto__")}) - v212 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v213 := v212.FindInternedVar(lang.NewSymbol("list")) - if v213.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v213))) + tmp210 := tmp209.Get() + tmp211 := lang.Apply(tmp210, []any{lang.NewSymbol("p__0__auto__")}) + tmp212 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp213 := tmp212.FindInternedVar(lang.NewSymbol("list")) + if tmp213.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp213))) } - v214 := v213.Get() - v215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v216 := v215.FindInternedVar(lang.NewSymbol("seq")) - if v216.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v216))) + tmp214 := tmp213.Get() + tmp215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp216 := tmp215.FindInternedVar(lang.NewSymbol("seq")) + if tmp216.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp216))) } - v217 := v216.Get() - v218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v219 := v218.FindInternedVar(lang.NewSymbol("concat")) - if v219.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v219))) + tmp217 := tmp216.Get() + tmp218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp219 := tmp218.FindInternedVar(lang.NewSymbol("concat")) + if tmp219.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp219))) } - v220 := v219.Get() - v221 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v222 := v221.FindInternedVar(lang.NewSymbol("list")) - if v222.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v222))) + tmp220 := tmp219.Get() + tmp221 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp222 := tmp221.FindInternedVar(lang.NewSymbol("list")) + if tmp222.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp222))) } - v223 := v222.Get() - v224 := lang.Apply(v223, []any{v21}) - v225 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v226 := v225.FindInternedVar(lang.NewSymbol("list")) - if v226.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v226))) + tmp223 := tmp222.Get() + tmp224 := lang.Apply(tmp223, []any{v21}) + tmp225 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp226 := tmp225.FindInternedVar(lang.NewSymbol("list")) + if tmp226.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp226))) } - v227 := v226.Get() - v228 := lang.Apply(v227, []any{v48}) - v229 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v230 := v229.FindInternedVar(lang.NewSymbol("list")) - if v230.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v230))) + tmp227 := tmp226.Get() + tmp228 := lang.Apply(tmp227, []any{v48}) + tmp229 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp230 := tmp229.FindInternedVar(lang.NewSymbol("list")) + if tmp230.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp230))) } - v231 := v230.Get() - v232 := lang.Apply(v231, []any{v22}) - v233 := lang.Apply(v220, []any{v224, v228, v232}) - v234 := lang.Apply(v217, []any{v233}) - v235 := lang.Apply(v214, []any{v234}) - v236 := lang.Apply(v207, []any{v211, v235}) - v237 := lang.Apply(v204, []any{v236}) - v238 := lang.Apply(v198, []any{v201, v237}) - v239 := lang.Apply(v195, []any{v238}) - v240 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v241 := v240.FindInternedVar(lang.NewSymbol("list")) - if v241.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v241))) + tmp231 := tmp230.Get() + tmp232 := lang.Apply(tmp231, []any{v22}) + tmp233 := lang.Apply(tmp220, []any{tmp224, tmp228, tmp232}) + tmp234 := lang.Apply(tmp217, []any{tmp233}) + tmp235 := lang.Apply(tmp214, []any{tmp234}) + tmp236 := lang.Apply(tmp207, []any{tmp211, tmp235}) + tmp237 := lang.Apply(tmp204, []any{tmp236}) + tmp238 := lang.Apply(tmp198, []any{tmp201, tmp237}) + tmp239 := lang.Apply(tmp195, []any{tmp238}) + tmp240 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp241 := tmp240.FindInternedVar(lang.NewSymbol("list")) + if tmp241.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp241))) } - v242 := v241.Get() - v243 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v244 := v243.FindInternedVar(lang.NewSymbol("seq")) - if v244.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v244))) + tmp242 := tmp241.Get() + tmp243 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp244 := tmp243.FindInternedVar(lang.NewSymbol("seq")) + if tmp244.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp244))) } - v245 := v244.Get() - v246 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v247 := v246.FindInternedVar(lang.NewSymbol("concat")) - if v247.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v247))) + tmp245 := tmp244.Get() + tmp246 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp247 := tmp246.FindInternedVar(lang.NewSymbol("concat")) + if tmp247.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp247))) } - v248 := v247.Get() - v249 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v250 := v249.FindInternedVar(lang.NewSymbol("list")) - if v250.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v250))) + tmp248 := tmp247.Get() + tmp249 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp250 := tmp249.FindInternedVar(lang.NewSymbol("list")) + if tmp250.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp250))) } - v251 := v250.Get() - v252 := lang.Apply(v251, []any{v58}) - v253 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v254 := v253.FindInternedVar(lang.NewSymbol("list")) - if v254.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v254))) + tmp251 := tmp250.Get() + tmp252 := lang.Apply(tmp251, []any{v58}) + tmp253 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp254 := tmp253.FindInternedVar(lang.NewSymbol("list")) + if tmp254.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp254))) } - v255 := v254.Get() - v256 := lang.Apply(v255, []any{lang.NewSymbol("p__0__auto__")}) - v257 := lang.Apply(v248, []any{v252, v256}) - v258 := lang.Apply(v245, []any{v257}) - v259 := lang.Apply(v242, []any{v258}) - v260 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v261 := v260.FindInternedVar(lang.NewSymbol("list")) - if v261.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v261))) + tmp255 := tmp254.Get() + tmp256 := lang.Apply(tmp255, []any{lang.NewSymbol("p__0__auto__")}) + tmp257 := lang.Apply(tmp248, []any{tmp252, tmp256}) + tmp258 := lang.Apply(tmp245, []any{tmp257}) + tmp259 := lang.Apply(tmp242, []any{tmp258}) + tmp260 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp261 := tmp260.FindInternedVar(lang.NewSymbol("list")) + if tmp261.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp261))) } - v262 := v261.Get() - v263 := lang.Apply(v20, []any{v21, v22, v64}) - v264 := lang.Apply(v262, []any{v263}) - v265 := lang.Apply(v188, []any{v192, v239, v259, v264}) - v266 := lang.Apply(v185, []any{v265}) - v182 = v266 + tmp262 := tmp261.Get() + tmp263 := lang.Apply(v20, []any{v21, v22, v64}) + tmp264 := lang.Apply(tmp262, []any{tmp263}) + tmp265 := lang.Apply(tmp188, []any{tmp192, tmp239, tmp259, tmp264}) + tmp266 := lang.Apply(tmp185, []any{tmp265}) + tmp182 = tmp266 } else { - v182 = nil } - v132 = v182 + tmp132 = tmp182 } - v127 = v132 + tmp127 = tmp132 } - v70 = v127 + tmp70 = tmp127 } - v24 = v70 + tmp24 = tmp70 } // end let - return v24 + return tmp24 }) - v20 := v19 + v20 = tmp19 _ = v20 } - v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6377), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(6389), lang.NewKeyword("end-column"), int(53)) - v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) + tmp20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6377), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(6389), lang.NewKeyword("end-column"), int(53)) + tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) if err != nil { panic(err) } - var v22 any = v21 + var v22 any = tmp21 _ = v22 - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("seq")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("concat")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) - } - v28 := v27.Get() - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("list")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.Apply(v31, []any{lang.NewSymbol("glojure.core/let")}) - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("list")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("apply")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v40 := v39.FindInternedVar(lang.NewSymbol("vector")) - if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) - } - v41 := v40.Get() - v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v43 := v42.FindInternedVar(lang.NewSymbol("seq")) - if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) - } - v44 := v43.Get() - v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v46 := v45.FindInternedVar(lang.NewSymbol("concat")) - if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) - } - v47 := v46.Get() - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("list")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v13}) - v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v53 := v52.FindInternedVar(lang.NewSymbol("list")) - if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) - } - v54 := v53.Get() - v55 := lang.Apply(v54, []any{v5}) - v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v57 := v56.FindInternedVar(lang.NewSymbol("list")) - if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) - } - v58 := v57.Get() - v59 := lang.Apply(v58, []any{v18}) - v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v61 := v60.FindInternedVar(lang.NewSymbol("list")) - if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) - } - v62 := v61.Get() - v63 := lang.Apply(v62, []any{v6}) - v64 := lang.Apply(v47, []any{v51, v55, v59, v63}) - v65 := lang.Apply(v44, []any{v64}) - v66 := lang.Apply(v38, []any{v41, v65}) - v67 := lang.Apply(v35, []any{v66}) - v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v69 := v68.FindInternedVar(lang.NewSymbol("list")) - if v69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) - } - v70 := v69.Get() - v71 := lang.Apply(v22, []any{v13, v18, v7}) - v72 := lang.Apply(v70, []any{v71}) - v73 := lang.Apply(v28, []any{v32, v67, v72}) - v74 := lang.Apply(v25, []any{v73}) - v8 = v74 + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("seq")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("concat")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) + } + tmp28 := tmp27.Get() + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("list")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.Apply(tmp31, []any{lang.NewSymbol("glojure.core/let")}) + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("list")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) + } + tmp35 := tmp34.Get() + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("apply")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp40 := tmp39.FindInternedVar(lang.NewSymbol("vector")) + if tmp40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) + } + tmp41 := tmp40.Get() + tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp43 := tmp42.FindInternedVar(lang.NewSymbol("seq")) + if tmp43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) + } + tmp44 := tmp43.Get() + tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp46 := tmp45.FindInternedVar(lang.NewSymbol("concat")) + if tmp46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) + } + tmp47 := tmp46.Get() + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v13}) + tmp52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp53 := tmp52.FindInternedVar(lang.NewSymbol("list")) + if tmp53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp53))) + } + tmp54 := tmp53.Get() + tmp55 := lang.Apply(tmp54, []any{v5}) + tmp56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp57 := tmp56.FindInternedVar(lang.NewSymbol("list")) + if tmp57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp57))) + } + tmp58 := tmp57.Get() + tmp59 := lang.Apply(tmp58, []any{v18}) + tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp61 := tmp60.FindInternedVar(lang.NewSymbol("list")) + if tmp61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) + } + tmp62 := tmp61.Get() + tmp63 := lang.Apply(tmp62, []any{v6}) + tmp64 := lang.Apply(tmp47, []any{tmp51, tmp55, tmp59, tmp63}) + tmp65 := lang.Apply(tmp44, []any{tmp64}) + tmp66 := lang.Apply(tmp38, []any{tmp41, tmp65}) + tmp67 := lang.Apply(tmp35, []any{tmp66}) + tmp68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp69 := tmp68.FindInternedVar(lang.NewSymbol("list")) + if tmp69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp69))) + } + tmp70 := tmp69.Get() + tmp71 := lang.Apply(v22, []any{v13, v18, v7}) + tmp72 := lang.Apply(tmp70, []any{tmp71}) + tmp73 := lang.Apply(tmp28, []any{tmp32, tmp67, tmp72}) + tmp74 := lang.Apply(tmp25, []any{tmp73}) + tmp8 = tmp74 } // end let - return v8 + return tmp8 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // conj { - v0 := lang.NewSymbol("conj").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("xs"))), lang.NewKeyword("doc"), "conj[oin]. Returns a new collection with the xs\n 'added'. (conj nil item) returns (item).\n (conj coll) returns coll. (conj) returns [].\n The 'addition' may happen at different 'places' depending\n on the concrete type.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(73), lang.NewKeyword("end-line"), int(81))).(*lang.Symbol) - var v2 lang.FnFunc + tmp0 := lang.NewSymbol("conj").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("xs"))), lang.NewKeyword("doc"), "conj[oin]. Returns a new collection with the xs\n 'added'. (conj nil item) returns (item).\n (conj coll) returns coll. (conj) returns [].\n The 'addition' may happen at different 'places' depending\n on the concrete type.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(73), lang.NewKeyword("end-line"), int(81))).(*lang.Symbol) + var tmp2 lang.FnFunc { // function conj - v2 = lang.NewFnFunc(func(args ...any) any { + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - v4 := lang.NewVector() - v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(82), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(82), lang.NewKeyword("end-column"), int(14)) - v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) + tmp4 := lang.NewVector() + tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(82), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(82), lang.NewKeyword("end-column"), int(14)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) if err != nil { panic(err) } - return v6 + return tmp6 case 1: v4 := args[0] _ = v4 @@ -19896,8 +19980,8 @@ func init() { _ = v4 v5 := args[1] _ = v5 - v6 := lang.Apply(lang.Conj, []any{v4, v5}) - return v6 + tmp6 := lang.Apply(lang.Conj, []any{v4, v5}) + return tmp6 default: if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -19906,69 +19990,70 @@ func init() { _ = v4 v5 := args[1] _ = v5 - v6 := lang.NewList(args[2:]...) + var v6 any = lang.NewList(args[2:]...) + _ = v6 recur_loop_10: - var v7 any + var tmp7 any if lang.IsTruthy(v6) { - v9 := lang.Apply(lang.Conj, []any{v4, v5}) - var v8 any = v9 - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("first")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{v6}) - var v10 any = v14 - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("next")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{v6}) - var v15 any = v19 - v4 = v8 - v5 = v10 - v6 = v15 + tmp9 := lang.Apply(lang.Conj, []any{v4, v5}) + var tmp8 any = tmp9 + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("first")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{v6}) + var tmp10 any = tmp14 + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("next")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{v6}) + var tmp15 any = tmp19 + v4 = tmp8 + v5 = tmp10 + v6 = tmp15 goto recur_loop_10 } else { - v20 := lang.Apply(lang.Conj, []any{v4, v5}) - v7 = v20 + tmp20 := lang.Apply(lang.Conj, []any{v4, v5}) + tmp7 = tmp20 } - return v7 + return tmp7 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(81), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(88), lang.NewKeyword("end-column"), int(67))).(lang.FnFunc) - v3 := v2 + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(81), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(88), lang.NewKeyword("end-column"), int(67))).(lang.FnFunc) + v3 = tmp2 _ = v3 } - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // conj! { - v0 := lang.NewSymbol("conj!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Adds x to the transient collection, and return coll. The 'addition'\n may happen at different 'places' depending on the concrete type.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3359), lang.NewKeyword("end-line"), int(3359))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("conj!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Adds x to the transient collection, and return coll. The 'addition'\n may happen at different 'places' depending on the concrete type.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3359), lang.NewKeyword("end-line"), int(3359))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v4 := v3.FindInternedVar(lang.NewSymbol("transient")) - if v4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) - } - v5 := v4.Get() - v6 := lang.NewVector() - v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3364), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(3364), lang.NewKeyword("end-column"), int(19)) - v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) + tmp3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp4 := tmp3.FindInternedVar(lang.NewSymbol("transient")) + if tmp4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp4))) + } + tmp5 := tmp4.Get() + tmp6 := lang.NewVector() + tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3364), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(3364), lang.NewKeyword("end-column"), int(19)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) if err != nil { panic(err) } - v9 := lang.Apply(v5, []any{v8}) - return v9 + tmp9 := lang.Apply(tmp5, []any{tmp8}) + return tmp9 case 1: v3 := args[0] _ = v3 @@ -19978,28 +20063,29 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5, _ := lang.FieldOrMethod(v3, "Conj") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(v3, "Conj") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Conj is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // cons { - v0 := lang.NewSymbol("cons").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("seq"))), lang.NewKeyword("doc"), "Returns a new seq where x is the first element and seq is\n the rest.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(21), lang.NewKeyword("end-line"), int(27))).(*lang.Symbol) - var v2 lang.FnFunc + tmp0 := lang.NewSymbol("cons").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("seq"))), lang.NewKeyword("doc"), "Returns a new seq where x is the first element and seq is\n the rest.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(21), lang.NewKeyword("end-line"), int(27))).(*lang.Symbol) + var tmp2 lang.FnFunc { // function cons - v2 = lang.NewFnFunc(func(args ...any) any { + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -20007,57 +20093,58 @@ func init() { _ = v4 v5 := args[1] _ = v5 - v6 := lang.Apply(lang.NewCons, []any{v4, v5}) - return v6 + tmp6 := lang.Apply(lang.NewCons, []any{v4, v5}) + return tmp6 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(27), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(27), lang.NewKeyword("end-column"), int(89))).(lang.FnFunc) - v3 := v2 + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(27), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(27), lang.NewKeyword("end-column"), int(89))).(lang.FnFunc) + v3 = tmp2 _ = v3 } - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // constantly { - v0 := lang.NewSymbol("constantly").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns a function that takes any number of arguments and returns x.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1440), lang.NewKeyword("end-line"), int(1440))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("constantly").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns a function that takes any number of arguments and returns x.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1440), lang.NewKeyword("end-line"), int(1440))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 lang.FnFunc - v4 = lang.NewFnFunc(func(args ...any) any { + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v5 := lang.NewList(args[0:]...) + var v5 any = lang.NewList(args[0:]...) + _ = v5 return v3 } }) - v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1444), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(1444), lang.NewKeyword("end-column"), int(21)) - v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) + tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1444), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(1444), lang.NewKeyword("end-column"), int(21)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) if err != nil { panic(err) } - return v6 + return tmp6 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // contains? { - v0 := lang.NewSymbol("contains?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("key"))), lang.NewKeyword("doc"), "Returns true if key is present in the given collection, otherwise\n returns false. Note that for numerically indexed collections like\n vectors and Java arrays, this tests if the numeric key is within the\n range of indexes. 'contains?' operates constant or logarithmic time;\n it will not perform a linear search for a value. See also 'some'.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1479), lang.NewKeyword("end-line"), int(1479))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("contains?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("key"))), lang.NewKeyword("doc"), "Returns true if key is present in the given collection, otherwise\n returns false. Note that for numerically indexed collections like\n vectors and Java arrays, this tests if the numeric key is within the\n range of indexes. 'contains?' operates constant or logarithmic time;\n it will not perform a linear search for a value. See also 'some'.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1479), lang.NewKeyword("end-line"), int(1479))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -20065,521 +20152,527 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5, _ := lang.FieldOrMethod(runtime4.RT, "Contains") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(runtime4.RT, "Contains") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Contains is not a function"))) } - v6 := lang.Apply(v5, []any{v3, v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // count { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function count__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("concat")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("list")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("seq")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("concat")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/Count")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{v3}) - v35 := lang.Apply(v26, []any{v30, v34}) - v36 := lang.Apply(v23, []any{v35}) - v37 := lang.Apply(v20, []any{v36}) - v38 := lang.Apply(v9, []any{v13, v17, v37}) - v39 := lang.Apply(v6, []any{v38}) - return v39 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/Count")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{v3}) + tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) + tmp36 := lang.Apply(tmp23, []any{tmp35}) + tmp37 := lang.Apply(tmp20, []any{tmp36}) + tmp38 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp37}) + tmp39 := lang.Apply(tmp6, []any{tmp38}) + return tmp39 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("count").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the number of items in the collection. (count nil) returns\n 0. Also works on strings, arrays, and Java Collections and Maps", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(867), lang.NewKeyword("end-line"), int(867))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("count").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the number of items in the collection. (count nil) returns\n 0. Also works on strings, arrays, and Java Collections and Maps", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(867), lang.NewKeyword("end-line"), int(867))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5 := lang.Apply(lang.Count, []any{v4}) - return v5 + tmp5 := lang.Apply(lang.Count, []any{v4}) + return tmp5 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // counted? { - v0 := lang.NewSymbol("counted?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements count in constant time", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6241), lang.NewKeyword("end-line"), int(6241))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("counted?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements count in constant time", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6241), lang.NewKeyword("end-line"), int(6241))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) } - v6 := v5.Get() - v7 := lang.Apply(v6, []any{lang.Counted, v3}) - return v7 + tmp6 := tmp5.Get() + tmp7 := reflect.TypeOf((*lang.Counted)(nil)).Elem() + tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) + return tmp8 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // create-ns { - v0 := lang.NewSymbol("create-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Create a new namespace named by the symbol if one doesn't already\n exist, returns it or the already-existing namespace of the same\n name.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4131), lang.NewKeyword("end-line"), int(4131))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("create-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Create a new namespace named by the symbol if one doesn't already\n exist, returns it or the already-existing namespace of the same\n name.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4131), lang.NewKeyword("end-line"), int(4131))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.Apply(nil, []any{v3}) - return v4 + tmp4 := lang.Apply(nil, []any{v3}) + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // create-struct { - v0 := lang.NewSymbol("create-struct").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keys"))), lang.NewKeyword("doc"), "Returns a structure basis object.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4037), lang.NewKeyword("end-line"), int(4037))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("create-struct").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keys"))), lang.NewKeyword("doc"), "Returns a structure basis object.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4037), lang.NewKeyword("end-line"), int(4037))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v3 := lang.NewList(args[0:]...) - v4 := lang.Apply(lang.CreatePersistentStructMapSlotMap, []any{v3}) - return v4 + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := lang.Apply(lang.CreatePersistentStructMapSlotMap, []any{v3}) + return tmp4 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // cycle { - v0 := lang.NewSymbol("cycle").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy (infinite!) sequence of repetitions of the items in coll.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2977), lang.NewKeyword("end-line"), int(2977))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("cycle").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy (infinite!) sequence of repetitions of the items in coll.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2977), lang.NewKeyword("end-line"), int(2977))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) } - v6 := v5.Get() - v7 := lang.Apply(v6, []any{v3}) - v8 := lang.Apply(lang.NewCycle, []any{v7}) - return v8 + tmp6 := tmp5.Get() + tmp7 := lang.Apply(tmp6, []any{v3}) + tmp8 := lang.Apply(lang.NewCycle, []any{tmp7}) + return tmp8 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // data-reader-urls { - v0 := lang.NewSymbol("data-reader-urls").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7830), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7830), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("data-reader-urls").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7830), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7830), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } return lang.NewList() }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // data-reader-var { - v0 := lang.NewSymbol("data-reader-var").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7832), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7832), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("data-reader-var").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7832), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7832), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("intern")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("create-ns")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("symbol")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("namespace")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{v3}) - v17 := lang.Apply(v12, []any{v16}) - v18 := lang.Apply(v9, []any{v17}) - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("symbol")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("name")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v3}) - v26 := lang.Apply(v21, []any{v25}) - v27 := lang.Apply(v6, []any{v18, v26}) - return v27 - }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("intern")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("create-ns")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("symbol")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("namespace")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp16}) + tmp18 := lang.Apply(tmp9, []any{tmp17}) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("symbol")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("name")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.Apply(tmp24, []any{v3}) + tmp26 := lang.Apply(tmp21, []any{tmp25}) + tmp27 := lang.Apply(tmp6, []any{tmp18, tmp26}) + return tmp27 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // dec { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function dec__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("concat")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("list")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("seq")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("concat")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - var v30 any - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - if lang.IsTruthy(v33) { - v30 = lang.NewSymbol("unchecked_dec") + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + var tmp30 any + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + if lang.IsTruthy(tmp33) { + tmp30 = lang.NewSymbol("unchecked_dec") } else { - v30 = lang.NewSymbol("dec") - } - v34 := lang.Apply(v29, []any{v30}) - v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v36 := v35.FindInternedVar(lang.NewSymbol("list")) - if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) - } - v37 := v36.Get() - v38 := lang.Apply(v37, []any{v3}) - v39 := lang.Apply(v26, []any{v34, v38}) - v40 := lang.Apply(v23, []any{v39}) - v41 := lang.Apply(v20, []any{v40}) - v42 := lang.Apply(v9, []any{v13, v17, v41}) - v43 := lang.Apply(v6, []any{v42}) - return v43 + tmp30 = lang.NewSymbol("dec") + } + tmp34 := lang.Apply(tmp29, []any{tmp30}) + tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp36 := tmp35.FindInternedVar(lang.NewSymbol("list")) + if tmp36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) + } + tmp37 := tmp36.Get() + tmp38 := lang.Apply(tmp37, []any{v3}) + tmp39 := lang.Apply(tmp26, []any{tmp34, tmp38}) + tmp40 := lang.Apply(tmp23, []any{tmp39}) + tmp41 := lang.Apply(tmp20, []any{tmp40}) + tmp42 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp41}) + tmp43 := lang.Apply(tmp6, []any{tmp42}) + return tmp43 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("dec").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns a number one less than num. Does not auto-promote\n longs, will throw on overflow. See also: dec'", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1147), lang.NewKeyword("end-line"), int(1147))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("dec").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns a number one less than num. Does not auto-promote\n longs, will throw on overflow. See also: dec'", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1147), lang.NewKeyword("end-line"), int(1147))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5, _ := lang.FieldOrMethod(lang.Numbers, "Dec") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Dec") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Dec is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // dec' { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function dec'__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("concat")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("list")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("seq")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("concat")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/DecP")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{v3}) - v35 := lang.Apply(v26, []any{v30, v34}) - v36 := lang.Apply(v23, []any{v35}) - v37 := lang.Apply(v20, []any{v36}) - v38 := lang.Apply(v9, []any{v13, v17, v37}) - v39 := lang.Apply(v6, []any{v38}) - return v39 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/DecP")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{v3}) + tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) + tmp36 := lang.Apply(tmp23, []any{tmp35}) + tmp37 := lang.Apply(tmp20, []any{tmp36}) + tmp38 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp37}) + tmp39 := lang.Apply(tmp6, []any{tmp38}) + return tmp39 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("dec'").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns a number one less than num. Supports arbitrary precision.\n See also: dec", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1140), lang.NewKeyword("end-line"), int(1140))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("dec'").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns a number one less than num. Supports arbitrary precision.\n See also: dec", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1140), lang.NewKeyword("end-line"), int(1140))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5, _ := lang.FieldOrMethod(lang.Numbers, "DecP") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "DecP") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("DecP is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // decimal? { - v0 := lang.NewSymbol("decimal?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is a BigDecimal", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3599), lang.NewKeyword("end-line"), int(3599))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("decimal?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is a BigDecimal", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3599), lang.NewKeyword("end-line"), int(3599))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) } - v6 := v5.Get() - v7 := lang.Apply(v6, []any{*lang.BigDecimal, v3}) - return v7 + tmp6 := tmp5.Get() + tmp7 := reflect.TypeOf((*lang.BigDecimal)(nil)) + tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) + return tmp8 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // declare { - v0 := lang.NewSymbol("declare").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("names"))), lang.NewKeyword("doc"), "defs the supplied var names with no bindings, useful for making forward declarations.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(2768), lang.NewKeyword("end-line"), int(2768))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("declare").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("names"))), lang.NewKeyword("doc"), "defs the supplied var names with no bindings, useful for making forward declarations.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(2768), lang.NewKeyword("end-line"), int(2768))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 2 { @@ -20589,209 +20682,210 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.NewList(args[2:]...) - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("seq")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("concat")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("list")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.Apply(v14, []any{lang.NewSymbol("do")}) - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("map")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - var v19 lang.FnFunc - v19 = lang.NewFnFunc(func(args ...any) any { + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("seq")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("concat")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("list")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("do")}) + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("map")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + var tmp19 lang.FnFunc + tmp19 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v20 := args[0] _ = v20 - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("list")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("vary-meta")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("assoc")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v26, []any{v20, v29, lang.NewKeyword("declared"), true}) - v31 := lang.Apply(v23, []any{lang.NewSymbol("def"), v30}) - return v31 + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("list")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("vary-meta")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("assoc")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp26, []any{v20, tmp29, lang.NewKeyword("declared"), true}) + tmp31 := lang.Apply(tmp23, []any{lang.NewSymbol("def"), tmp30}) + return tmp31 }) - v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2771), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(2771), lang.NewKeyword("end-column"), int(71)) - v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) + tmp20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2771), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(2771), lang.NewKeyword("end-column"), int(71)) + tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) if err != nil { panic(err) } - v22 := lang.Apply(v18, []any{v21, v5}) - v23 := lang.Apply(v11, []any{v15, v22}) - v24 := lang.Apply(v8, []any{v23}) - return v24 + tmp22 := lang.Apply(tmp18, []any{tmp21, v5}) + tmp23 := lang.Apply(tmp11, []any{tmp15, tmp22}) + tmp24 := lang.Apply(tmp8, []any{tmp23}) + return tmp24 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // dedupe { - v0 := lang.NewSymbol("dedupe").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence removing consecutive duplicates in coll.\n Returns a transducer when no collection is provided.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7681), lang.NewKeyword("end-line"), int(7681))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("dedupe").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence removing consecutive duplicates in coll.\n Returns a transducer when no collection is provided.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7681), lang.NewKeyword("end-line"), int(7681))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - var v5 any + var tmp5 any { // let // let binding "pv" - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("volatile!")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{lang.NewKeyword("glojure.core/none")}) - var v10 any = v9 + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("volatile!")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.Apply(tmp8, []any{lang.NewKeyword("glojure.core/none")}) + var v10 any = tmp9 _ = v10 - var v11 lang.FnFunc - v11 = lang.NewFnFunc(func(args ...any) any { + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - v12 := lang.Apply(v4, nil) - return v12 + tmp12 := lang.Apply(v4, nil) + return tmp12 case 1: v12 := args[0] _ = v12 - v13 := lang.Apply(v4, []any{v12}) - return v13 + tmp13 := lang.Apply(v4, []any{v12}) + return tmp13 case 2: v12 := args[0] _ = v12 v13 := args[1] _ = v13 - var v14 any + var tmp14 any { // let // let binding "prior" - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("deref")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("deref")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{v10}) - var v19 any = v18 + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{v10}) + var v19 any = tmp18 _ = v19 - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("vreset!")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("vreset!")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) } - v22 := v21.Get() - v23 := lang.Apply(v22, []any{v10, v13}) - _ = v23 - var v24 any - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("=")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + tmp22 := tmp21.Get() + tmp23 := lang.Apply(tmp22, []any{v10, v13}) + _ = tmp23 + var tmp24 any + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("=")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) } - v27 := v26.Get() - v28 := lang.Apply(v27, []any{v19, v13}) - if lang.IsTruthy(v28) { - v24 = v12 + tmp27 := tmp26.Get() + tmp28 := lang.Apply(tmp27, []any{v19, v13}) + if lang.IsTruthy(tmp28) { + tmp24 = v12 } else { - v29 := lang.Apply(v4, []any{v12, v13}) - v24 = v29 + tmp29 := lang.Apply(v4, []any{v12, v13}) + tmp24 = tmp29 } - v14 = v24 + tmp14 = tmp24 } // end let - return v14 + return tmp14 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7688), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7696), lang.NewKeyword("end-column"), int(37)) - v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) + tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7688), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7696), lang.NewKeyword("end-column"), int(37)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) if err != nil { panic(err) } - v5 = v13 + tmp5 = tmp13 } // end let - return v5 + return tmp5 }) - v4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7686), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7696), lang.NewKeyword("end-column"), int(39)) - v5, err := lang.WithMeta(v3, v4.(lang.IPersistentMap)) + tmp4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7686), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7696), lang.NewKeyword("end-column"), int(39)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) if err != nil { panic(err) } - return v5 + return tmp5 case 1: v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("sequence")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("dedupe")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v9, nil) - v11 := lang.Apply(v6, []any{v10, v3}) - return v11 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("sequence")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("dedupe")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp9, nil) + tmp11 := lang.Apply(tmp6, []any{tmp10, v3}) + return tmp11 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // def-aset { - v0 := lang.NewSymbol("def-aset").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("method"), lang.NewSymbol("coerce"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3935), lang.NewKeyword("end-line"), int(3936), lang.NewKeyword("private"), true)).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("def-aset").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("method"), lang.NewSymbol("coerce"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3935), lang.NewKeyword("end-line"), int(3936), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 5 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -20805,637 +20899,637 @@ func init() { _ = v6 v7 := args[4] _ = v7 - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("seq")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("concat")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("glojure.core/defn")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.Apply(v20, []any{v5}) - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("list")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("apply")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("hash-map")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("seq")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("concat")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) - } - v36 := v35.Get() - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("list")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.Apply(v39, []any{lang.NewKeyword("arglists")}) - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("list")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) - } - v43 := v42.Get() - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("seq")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) - } - v46 := v45.Get() - v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v48 := v47.FindInternedVar(lang.NewSymbol("concat")) - if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) - } - v49 := v48.Get() - v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v51 := v50.FindInternedVar(lang.NewSymbol("list")) - if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) - } - v52 := v51.Get() - v53 := lang.Apply(v52, []any{lang.NewSymbol("quote")}) - v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v55 := v54.FindInternedVar(lang.NewSymbol("list")) - if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) - } - v56 := v55.Get() - v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v58 := v57.FindInternedVar(lang.NewSymbol("seq")) - if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) - } - v59 := v58.Get() - v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v61 := v60.FindInternedVar(lang.NewSymbol("concat")) - if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) - } - v62 := v61.Get() - v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v64 := v63.FindInternedVar(lang.NewSymbol("list")) - if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) - } - v65 := v64.Get() - v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v67 := v66.FindInternedVar(lang.NewSymbol("apply")) - if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) - } - v68 := v67.Get() - v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v70 := v69.FindInternedVar(lang.NewSymbol("vector")) - if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) - } - v71 := v70.Get() - v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v73 := v72.FindInternedVar(lang.NewSymbol("seq")) - if v73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) - } - v74 := v73.Get() - v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v76 := v75.FindInternedVar(lang.NewSymbol("concat")) - if v76.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) - } - v77 := v76.Get() - v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v79 := v78.FindInternedVar(lang.NewSymbol("list")) - if v79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) - } - v80 := v79.Get() - v81 := lang.Apply(v80, []any{lang.NewSymbol("array")}) - v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v83 := v82.FindInternedVar(lang.NewSymbol("list")) - if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) - } - v84 := v83.Get() - v85 := lang.Apply(v84, []any{lang.NewSymbol("idx")}) - v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v87 := v86.FindInternedVar(lang.NewSymbol("list")) - if v87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) - } - v88 := v87.Get() - v89 := lang.Apply(v88, []any{lang.NewSymbol("val")}) - v90 := lang.Apply(v77, []any{v81, v85, v89}) - v91 := lang.Apply(v74, []any{v90}) - v92 := lang.Apply(v68, []any{v71, v91}) - v93 := lang.Apply(v65, []any{v92}) - v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v95 := v94.FindInternedVar(lang.NewSymbol("list")) - if v95.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) - } - v96 := v95.Get() - v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v98 := v97.FindInternedVar(lang.NewSymbol("apply")) - if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) - } - v99 := v98.Get() - v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v101 := v100.FindInternedVar(lang.NewSymbol("vector")) - if v101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) - } - v102 := v101.Get() - v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v104 := v103.FindInternedVar(lang.NewSymbol("seq")) - if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) - } - v105 := v104.Get() - v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v107 := v106.FindInternedVar(lang.NewSymbol("concat")) - if v107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) - } - v108 := v107.Get() - v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v110 := v109.FindInternedVar(lang.NewSymbol("list")) - if v110.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) - } - v111 := v110.Get() - v112 := lang.Apply(v111, []any{lang.NewSymbol("array")}) - v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v114 := v113.FindInternedVar(lang.NewSymbol("list")) - if v114.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) - } - v115 := v114.Get() - v116 := lang.Apply(v115, []any{lang.NewSymbol("idx")}) - v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v118 := v117.FindInternedVar(lang.NewSymbol("list")) - if v118.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) - } - v119 := v118.Get() - v120 := lang.Apply(v119, []any{lang.NewSymbol("idx2")}) - v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v122 := v121.FindInternedVar(lang.NewSymbol("list")) - if v122.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) - } - v123 := v122.Get() - v124 := lang.Apply(v123, []any{lang.NewSymbol("&")}) - v125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v126 := v125.FindInternedVar(lang.NewSymbol("list")) - if v126.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v126))) - } - v127 := v126.Get() - v128 := lang.Apply(v127, []any{lang.NewSymbol("idxv")}) - v129 := lang.Apply(v108, []any{v112, v116, v120, v124, v128}) - v130 := lang.Apply(v105, []any{v129}) - v131 := lang.Apply(v99, []any{v102, v130}) - v132 := lang.Apply(v96, []any{v131}) - v133 := lang.Apply(v62, []any{v93, v132}) - v134 := lang.Apply(v59, []any{v133}) - v135 := lang.Apply(v56, []any{v134}) - v136 := lang.Apply(v49, []any{v53, v135}) - v137 := lang.Apply(v46, []any{v136}) - v138 := lang.Apply(v43, []any{v137}) - v139 := lang.Apply(v36, []any{v40, v138}) - v140 := lang.Apply(v33, []any{v139}) - v141 := lang.Apply(v27, []any{v30, v140}) - v142 := lang.Apply(v24, []any{v141}) - v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v144 := v143.FindInternedVar(lang.NewSymbol("list")) - if v144.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) - } - v145 := v144.Get() - v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v147 := v146.FindInternedVar(lang.NewSymbol("seq")) - if v147.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) - } - v148 := v147.Get() - v149 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v150 := v149.FindInternedVar(lang.NewSymbol("concat")) - if v150.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v150))) - } - v151 := v150.Get() - v152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v153 := v152.FindInternedVar(lang.NewSymbol("list")) - if v153.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v153))) - } - v154 := v153.Get() - v155 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v156 := v155.FindInternedVar(lang.NewSymbol("apply")) - if v156.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v156))) - } - v157 := v156.Get() - v158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v159 := v158.FindInternedVar(lang.NewSymbol("vector")) - if v159.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v159))) - } - v160 := v159.Get() - v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v162 := v161.FindInternedVar(lang.NewSymbol("seq")) - if v162.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) - } - v163 := v162.Get() - v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v165 := v164.FindInternedVar(lang.NewSymbol("concat")) - if v165.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) - } - v166 := v165.Get() - v167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v168 := v167.FindInternedVar(lang.NewSymbol("list")) - if v168.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v168))) - } - v169 := v168.Get() - v170 := lang.Apply(v169, []any{lang.NewSymbol("array__0__auto__")}) - v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v172 := v171.FindInternedVar(lang.NewSymbol("list")) - if v172.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) - } - v173 := v172.Get() - v174 := lang.Apply(v173, []any{lang.NewSymbol("idx__1__auto__")}) - v175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v176 := v175.FindInternedVar(lang.NewSymbol("list")) - if v176.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v176))) - } - v177 := v176.Get() - v178 := lang.Apply(v177, []any{lang.NewSymbol("val__2__auto__")}) - v179 := lang.Apply(v166, []any{v170, v174, v178}) - v180 := lang.Apply(v163, []any{v179}) - v181 := lang.Apply(v157, []any{v160, v180}) - v182 := lang.Apply(v154, []any{v181}) - v183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v184 := v183.FindInternedVar(lang.NewSymbol("list")) - if v184.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v184))) - } - v185 := v184.Get() - v186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v187 := v186.FindInternedVar(lang.NewSymbol("seq")) - if v187.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v187))) - } - v188 := v187.Get() - v189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v190 := v189.FindInternedVar(lang.NewSymbol("concat")) - if v190.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v190))) - } - v191 := v190.Get() - v192 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v193 := v192.FindInternedVar(lang.NewSymbol("list")) - if v193.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v193))) - } - v194 := v193.Get() - v195 := lang.Apply(v194, []any{lang.NewSymbol(".")}) - v196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v197 := v196.FindInternedVar(lang.NewSymbol("list")) - if v197.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v197))) - } - v198 := v197.Get() - v199 := lang.Apply(v198, []any{lang.NewSymbol("glojure.core/Array")}) - v200 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v201 := v200.FindInternedVar(lang.NewSymbol("list")) - if v201.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v201))) - } - v202 := v201.Get() - v203 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v204 := v203.FindInternedVar(lang.NewSymbol("seq")) - if v204.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v204))) - } - v205 := v204.Get() - v206 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v207 := v206.FindInternedVar(lang.NewSymbol("concat")) - if v207.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v207))) - } - v208 := v207.Get() - v209 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v210 := v209.FindInternedVar(lang.NewSymbol("list")) - if v210.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v210))) - } - v211 := v210.Get() - v212 := lang.Apply(v211, []any{v6}) - v213 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v214 := v213.FindInternedVar(lang.NewSymbol("list")) - if v214.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v214))) - } - v215 := v214.Get() - v216 := lang.Apply(v215, []any{lang.NewSymbol("array__0__auto__")}) - v217 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v218 := v217.FindInternedVar(lang.NewSymbol("list")) - if v218.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v218))) - } - v219 := v218.Get() - v220 := lang.Apply(v219, []any{lang.NewSymbol("idx__1__auto__")}) - v221 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v222 := v221.FindInternedVar(lang.NewSymbol("list")) - if v222.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v222))) - } - v223 := v222.Get() - v224 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v225 := v224.FindInternedVar(lang.NewSymbol("seq")) - if v225.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v225))) - } - v226 := v225.Get() - v227 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v228 := v227.FindInternedVar(lang.NewSymbol("concat")) - if v228.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v228))) - } - v229 := v228.Get() - v230 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v231 := v230.FindInternedVar(lang.NewSymbol("list")) - if v231.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v231))) - } - v232 := v231.Get() - v233 := lang.Apply(v232, []any{v7}) - v234 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v235 := v234.FindInternedVar(lang.NewSymbol("list")) - if v235.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v235))) - } - v236 := v235.Get() - v237 := lang.Apply(v236, []any{lang.NewSymbol("val__2__auto__")}) - v238 := lang.Apply(v229, []any{v233, v237}) - v239 := lang.Apply(v226, []any{v238}) - v240 := lang.Apply(v223, []any{v239}) - v241 := lang.Apply(v208, []any{v212, v216, v220, v240}) - v242 := lang.Apply(v205, []any{v241}) - v243 := lang.Apply(v202, []any{v242}) - v244 := lang.Apply(v191, []any{v195, v199, v243}) - v245 := lang.Apply(v188, []any{v244}) - v246 := lang.Apply(v185, []any{v245}) - v247 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v248 := v247.FindInternedVar(lang.NewSymbol("list")) - if v248.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v248))) - } - v249 := v248.Get() - v250 := lang.Apply(v249, []any{lang.NewSymbol("val__2__auto__")}) - v251 := lang.Apply(v151, []any{v182, v246, v250}) - v252 := lang.Apply(v148, []any{v251}) - v253 := lang.Apply(v145, []any{v252}) - v254 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v255 := v254.FindInternedVar(lang.NewSymbol("list")) - if v255.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v255))) - } - v256 := v255.Get() - v257 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v258 := v257.FindInternedVar(lang.NewSymbol("seq")) - if v258.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v258))) - } - v259 := v258.Get() - v260 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v261 := v260.FindInternedVar(lang.NewSymbol("concat")) - if v261.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v261))) - } - v262 := v261.Get() - v263 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v264 := v263.FindInternedVar(lang.NewSymbol("list")) - if v264.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v264))) - } - v265 := v264.Get() - v266 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v267 := v266.FindInternedVar(lang.NewSymbol("apply")) - if v267.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v267))) - } - v268 := v267.Get() - v269 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v270 := v269.FindInternedVar(lang.NewSymbol("vector")) - if v270.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v270))) - } - v271 := v270.Get() - v272 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v273 := v272.FindInternedVar(lang.NewSymbol("seq")) - if v273.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v273))) - } - v274 := v273.Get() - v275 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v276 := v275.FindInternedVar(lang.NewSymbol("concat")) - if v276.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v276))) - } - v277 := v276.Get() - v278 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v279 := v278.FindInternedVar(lang.NewSymbol("list")) - if v279.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v279))) - } - v280 := v279.Get() - v281 := lang.Apply(v280, []any{lang.NewSymbol("array__0__auto__")}) - v282 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v283 := v282.FindInternedVar(lang.NewSymbol("list")) - if v283.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v283))) - } - v284 := v283.Get() - v285 := lang.Apply(v284, []any{lang.NewSymbol("idx__1__auto__")}) - v286 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v287 := v286.FindInternedVar(lang.NewSymbol("list")) - if v287.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v287))) - } - v288 := v287.Get() - v289 := lang.Apply(v288, []any{lang.NewSymbol("idx2__3__auto__")}) - v290 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v291 := v290.FindInternedVar(lang.NewSymbol("list")) - if v291.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v291))) - } - v292 := v291.Get() - v293 := lang.Apply(v292, []any{lang.NewSymbol("&")}) - v294 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v295 := v294.FindInternedVar(lang.NewSymbol("list")) - if v295.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v295))) - } - v296 := v295.Get() - v297 := lang.Apply(v296, []any{lang.NewSymbol("idxv__4__auto__")}) - v298 := lang.Apply(v277, []any{v281, v285, v289, v293, v297}) - v299 := lang.Apply(v274, []any{v298}) - v300 := lang.Apply(v268, []any{v271, v299}) - v301 := lang.Apply(v265, []any{v300}) - v302 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v303 := v302.FindInternedVar(lang.NewSymbol("list")) - if v303.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v303))) - } - v304 := v303.Get() - v305 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v306 := v305.FindInternedVar(lang.NewSymbol("seq")) - if v306.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v306))) - } - v307 := v306.Get() - v308 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v309 := v308.FindInternedVar(lang.NewSymbol("concat")) - if v309.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v309))) - } - v310 := v309.Get() - v311 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v312 := v311.FindInternedVar(lang.NewSymbol("list")) - if v312.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v312))) - } - v313 := v312.Get() - v314 := lang.Apply(v313, []any{lang.NewSymbol("glojure.core/apply")}) - v315 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v316 := v315.FindInternedVar(lang.NewSymbol("list")) - if v316.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v316))) - } - v317 := v316.Get() - v318 := lang.Apply(v317, []any{v5}) - v319 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v320 := v319.FindInternedVar(lang.NewSymbol("list")) - if v320.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v320))) - } - v321 := v320.Get() - v322 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v323 := v322.FindInternedVar(lang.NewSymbol("seq")) - if v323.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v323))) - } - v324 := v323.Get() - v325 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v326 := v325.FindInternedVar(lang.NewSymbol("concat")) - if v326.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v326))) - } - v327 := v326.Get() - v328 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v329 := v328.FindInternedVar(lang.NewSymbol("list")) - if v329.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v329))) - } - v330 := v329.Get() - v331 := lang.Apply(v330, []any{lang.NewSymbol("glojure.core/aget")}) - v332 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v333 := v332.FindInternedVar(lang.NewSymbol("list")) - if v333.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v333))) - } - v334 := v333.Get() - v335 := lang.Apply(v334, []any{lang.NewSymbol("array__0__auto__")}) - v336 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v337 := v336.FindInternedVar(lang.NewSymbol("list")) - if v337.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v337))) - } - v338 := v337.Get() - v339 := lang.Apply(v338, []any{lang.NewSymbol("idx__1__auto__")}) - v340 := lang.Apply(v327, []any{v331, v335, v339}) - v341 := lang.Apply(v324, []any{v340}) - v342 := lang.Apply(v321, []any{v341}) - v343 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v344 := v343.FindInternedVar(lang.NewSymbol("list")) - if v344.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v344))) - } - v345 := v344.Get() - v346 := lang.Apply(v345, []any{lang.NewSymbol("idx2__3__auto__")}) - v347 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v348 := v347.FindInternedVar(lang.NewSymbol("list")) - if v348.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v348))) - } - v349 := v348.Get() - v350 := lang.Apply(v349, []any{lang.NewSymbol("idxv__4__auto__")}) - v351 := lang.Apply(v310, []any{v314, v318, v342, v346, v350}) - v352 := lang.Apply(v307, []any{v351}) - v353 := lang.Apply(v304, []any{v352}) - v354 := lang.Apply(v262, []any{v301, v353}) - v355 := lang.Apply(v259, []any{v354}) - v356 := lang.Apply(v256, []any{v355}) - v357 := lang.Apply(v13, []any{v17, v21, v142, v253, v356}) - v358 := lang.Apply(v10, []any{v357}) - return v358 - }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("seq")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("concat")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("glojure.core/defn")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.Apply(tmp20, []any{v5}) + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("list")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("apply")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("hash-map")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("seq")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("concat")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("list")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.Apply(tmp39, []any{lang.NewKeyword("arglists")}) + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("list")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("seq")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) + } + tmp46 := tmp45.Get() + tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp48 := tmp47.FindInternedVar(lang.NewSymbol("concat")) + if tmp48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) + } + tmp49 := tmp48.Get() + tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp51 := tmp50.FindInternedVar(lang.NewSymbol("list")) + if tmp51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) + } + tmp52 := tmp51.Get() + tmp53 := lang.Apply(tmp52, []any{lang.NewSymbol("quote")}) + tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp55 := tmp54.FindInternedVar(lang.NewSymbol("list")) + if tmp55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) + } + tmp56 := tmp55.Get() + tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp58 := tmp57.FindInternedVar(lang.NewSymbol("seq")) + if tmp58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) + } + tmp59 := tmp58.Get() + tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp61 := tmp60.FindInternedVar(lang.NewSymbol("concat")) + if tmp61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) + } + tmp62 := tmp61.Get() + tmp63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp64 := tmp63.FindInternedVar(lang.NewSymbol("list")) + if tmp64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp64))) + } + tmp65 := tmp64.Get() + tmp66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp67 := tmp66.FindInternedVar(lang.NewSymbol("apply")) + if tmp67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp67))) + } + tmp68 := tmp67.Get() + tmp69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp70 := tmp69.FindInternedVar(lang.NewSymbol("vector")) + if tmp70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp70))) + } + tmp71 := tmp70.Get() + tmp72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp73 := tmp72.FindInternedVar(lang.NewSymbol("seq")) + if tmp73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp73))) + } + tmp74 := tmp73.Get() + tmp75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp76 := tmp75.FindInternedVar(lang.NewSymbol("concat")) + if tmp76.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp76))) + } + tmp77 := tmp76.Get() + tmp78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp79 := tmp78.FindInternedVar(lang.NewSymbol("list")) + if tmp79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp79))) + } + tmp80 := tmp79.Get() + tmp81 := lang.Apply(tmp80, []any{lang.NewSymbol("array")}) + tmp82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp83 := tmp82.FindInternedVar(lang.NewSymbol("list")) + if tmp83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp83))) + } + tmp84 := tmp83.Get() + tmp85 := lang.Apply(tmp84, []any{lang.NewSymbol("idx")}) + tmp86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp87 := tmp86.FindInternedVar(lang.NewSymbol("list")) + if tmp87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp87))) + } + tmp88 := tmp87.Get() + tmp89 := lang.Apply(tmp88, []any{lang.NewSymbol("val")}) + tmp90 := lang.Apply(tmp77, []any{tmp81, tmp85, tmp89}) + tmp91 := lang.Apply(tmp74, []any{tmp90}) + tmp92 := lang.Apply(tmp68, []any{tmp71, tmp91}) + tmp93 := lang.Apply(tmp65, []any{tmp92}) + tmp94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp95 := tmp94.FindInternedVar(lang.NewSymbol("list")) + if tmp95.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp95))) + } + tmp96 := tmp95.Get() + tmp97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp98 := tmp97.FindInternedVar(lang.NewSymbol("apply")) + if tmp98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp98))) + } + tmp99 := tmp98.Get() + tmp100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp101 := tmp100.FindInternedVar(lang.NewSymbol("vector")) + if tmp101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp101))) + } + tmp102 := tmp101.Get() + tmp103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp104 := tmp103.FindInternedVar(lang.NewSymbol("seq")) + if tmp104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp104))) + } + tmp105 := tmp104.Get() + tmp106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp107 := tmp106.FindInternedVar(lang.NewSymbol("concat")) + if tmp107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp107))) + } + tmp108 := tmp107.Get() + tmp109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp110 := tmp109.FindInternedVar(lang.NewSymbol("list")) + if tmp110.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp110))) + } + tmp111 := tmp110.Get() + tmp112 := lang.Apply(tmp111, []any{lang.NewSymbol("array")}) + tmp113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp114 := tmp113.FindInternedVar(lang.NewSymbol("list")) + if tmp114.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp114))) + } + tmp115 := tmp114.Get() + tmp116 := lang.Apply(tmp115, []any{lang.NewSymbol("idx")}) + tmp117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp118 := tmp117.FindInternedVar(lang.NewSymbol("list")) + if tmp118.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp118))) + } + tmp119 := tmp118.Get() + tmp120 := lang.Apply(tmp119, []any{lang.NewSymbol("idx2")}) + tmp121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp122 := tmp121.FindInternedVar(lang.NewSymbol("list")) + if tmp122.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp122))) + } + tmp123 := tmp122.Get() + tmp124 := lang.Apply(tmp123, []any{lang.NewSymbol("&")}) + tmp125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp126 := tmp125.FindInternedVar(lang.NewSymbol("list")) + if tmp126.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp126))) + } + tmp127 := tmp126.Get() + tmp128 := lang.Apply(tmp127, []any{lang.NewSymbol("idxv")}) + tmp129 := lang.Apply(tmp108, []any{tmp112, tmp116, tmp120, tmp124, tmp128}) + tmp130 := lang.Apply(tmp105, []any{tmp129}) + tmp131 := lang.Apply(tmp99, []any{tmp102, tmp130}) + tmp132 := lang.Apply(tmp96, []any{tmp131}) + tmp133 := lang.Apply(tmp62, []any{tmp93, tmp132}) + tmp134 := lang.Apply(tmp59, []any{tmp133}) + tmp135 := lang.Apply(tmp56, []any{tmp134}) + tmp136 := lang.Apply(tmp49, []any{tmp53, tmp135}) + tmp137 := lang.Apply(tmp46, []any{tmp136}) + tmp138 := lang.Apply(tmp43, []any{tmp137}) + tmp139 := lang.Apply(tmp36, []any{tmp40, tmp138}) + tmp140 := lang.Apply(tmp33, []any{tmp139}) + tmp141 := lang.Apply(tmp27, []any{tmp30, tmp140}) + tmp142 := lang.Apply(tmp24, []any{tmp141}) + tmp143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp144 := tmp143.FindInternedVar(lang.NewSymbol("list")) + if tmp144.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp144))) + } + tmp145 := tmp144.Get() + tmp146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp147 := tmp146.FindInternedVar(lang.NewSymbol("seq")) + if tmp147.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp147))) + } + tmp148 := tmp147.Get() + tmp149 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp150 := tmp149.FindInternedVar(lang.NewSymbol("concat")) + if tmp150.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp150))) + } + tmp151 := tmp150.Get() + tmp152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp153 := tmp152.FindInternedVar(lang.NewSymbol("list")) + if tmp153.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp153))) + } + tmp154 := tmp153.Get() + tmp155 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp156 := tmp155.FindInternedVar(lang.NewSymbol("apply")) + if tmp156.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp156))) + } + tmp157 := tmp156.Get() + tmp158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp159 := tmp158.FindInternedVar(lang.NewSymbol("vector")) + if tmp159.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp159))) + } + tmp160 := tmp159.Get() + tmp161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp162 := tmp161.FindInternedVar(lang.NewSymbol("seq")) + if tmp162.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp162))) + } + tmp163 := tmp162.Get() + tmp164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp165 := tmp164.FindInternedVar(lang.NewSymbol("concat")) + if tmp165.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp165))) + } + tmp166 := tmp165.Get() + tmp167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp168 := tmp167.FindInternedVar(lang.NewSymbol("list")) + if tmp168.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp168))) + } + tmp169 := tmp168.Get() + tmp170 := lang.Apply(tmp169, []any{lang.NewSymbol("array__0__auto__")}) + tmp171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp172 := tmp171.FindInternedVar(lang.NewSymbol("list")) + if tmp172.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp172))) + } + tmp173 := tmp172.Get() + tmp174 := lang.Apply(tmp173, []any{lang.NewSymbol("idx__1__auto__")}) + tmp175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp176 := tmp175.FindInternedVar(lang.NewSymbol("list")) + if tmp176.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp176))) + } + tmp177 := tmp176.Get() + tmp178 := lang.Apply(tmp177, []any{lang.NewSymbol("val__2__auto__")}) + tmp179 := lang.Apply(tmp166, []any{tmp170, tmp174, tmp178}) + tmp180 := lang.Apply(tmp163, []any{tmp179}) + tmp181 := lang.Apply(tmp157, []any{tmp160, tmp180}) + tmp182 := lang.Apply(tmp154, []any{tmp181}) + tmp183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp184 := tmp183.FindInternedVar(lang.NewSymbol("list")) + if tmp184.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp184))) + } + tmp185 := tmp184.Get() + tmp186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp187 := tmp186.FindInternedVar(lang.NewSymbol("seq")) + if tmp187.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp187))) + } + tmp188 := tmp187.Get() + tmp189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp190 := tmp189.FindInternedVar(lang.NewSymbol("concat")) + if tmp190.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp190))) + } + tmp191 := tmp190.Get() + tmp192 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp193 := tmp192.FindInternedVar(lang.NewSymbol("list")) + if tmp193.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp193))) + } + tmp194 := tmp193.Get() + tmp195 := lang.Apply(tmp194, []any{lang.NewSymbol(".")}) + tmp196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp197 := tmp196.FindInternedVar(lang.NewSymbol("list")) + if tmp197.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp197))) + } + tmp198 := tmp197.Get() + tmp199 := lang.Apply(tmp198, []any{lang.NewSymbol("glojure.core/Array")}) + tmp200 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp201 := tmp200.FindInternedVar(lang.NewSymbol("list")) + if tmp201.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp201))) + } + tmp202 := tmp201.Get() + tmp203 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp204 := tmp203.FindInternedVar(lang.NewSymbol("seq")) + if tmp204.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp204))) + } + tmp205 := tmp204.Get() + tmp206 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp207 := tmp206.FindInternedVar(lang.NewSymbol("concat")) + if tmp207.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp207))) + } + tmp208 := tmp207.Get() + tmp209 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp210 := tmp209.FindInternedVar(lang.NewSymbol("list")) + if tmp210.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp210))) + } + tmp211 := tmp210.Get() + tmp212 := lang.Apply(tmp211, []any{v6}) + tmp213 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp214 := tmp213.FindInternedVar(lang.NewSymbol("list")) + if tmp214.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp214))) + } + tmp215 := tmp214.Get() + tmp216 := lang.Apply(tmp215, []any{lang.NewSymbol("array__0__auto__")}) + tmp217 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp218 := tmp217.FindInternedVar(lang.NewSymbol("list")) + if tmp218.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp218))) + } + tmp219 := tmp218.Get() + tmp220 := lang.Apply(tmp219, []any{lang.NewSymbol("idx__1__auto__")}) + tmp221 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp222 := tmp221.FindInternedVar(lang.NewSymbol("list")) + if tmp222.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp222))) + } + tmp223 := tmp222.Get() + tmp224 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp225 := tmp224.FindInternedVar(lang.NewSymbol("seq")) + if tmp225.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp225))) + } + tmp226 := tmp225.Get() + tmp227 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp228 := tmp227.FindInternedVar(lang.NewSymbol("concat")) + if tmp228.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp228))) + } + tmp229 := tmp228.Get() + tmp230 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp231 := tmp230.FindInternedVar(lang.NewSymbol("list")) + if tmp231.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp231))) + } + tmp232 := tmp231.Get() + tmp233 := lang.Apply(tmp232, []any{v7}) + tmp234 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp235 := tmp234.FindInternedVar(lang.NewSymbol("list")) + if tmp235.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp235))) + } + tmp236 := tmp235.Get() + tmp237 := lang.Apply(tmp236, []any{lang.NewSymbol("val__2__auto__")}) + tmp238 := lang.Apply(tmp229, []any{tmp233, tmp237}) + tmp239 := lang.Apply(tmp226, []any{tmp238}) + tmp240 := lang.Apply(tmp223, []any{tmp239}) + tmp241 := lang.Apply(tmp208, []any{tmp212, tmp216, tmp220, tmp240}) + tmp242 := lang.Apply(tmp205, []any{tmp241}) + tmp243 := lang.Apply(tmp202, []any{tmp242}) + tmp244 := lang.Apply(tmp191, []any{tmp195, tmp199, tmp243}) + tmp245 := lang.Apply(tmp188, []any{tmp244}) + tmp246 := lang.Apply(tmp185, []any{tmp245}) + tmp247 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp248 := tmp247.FindInternedVar(lang.NewSymbol("list")) + if tmp248.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp248))) + } + tmp249 := tmp248.Get() + tmp250 := lang.Apply(tmp249, []any{lang.NewSymbol("val__2__auto__")}) + tmp251 := lang.Apply(tmp151, []any{tmp182, tmp246, tmp250}) + tmp252 := lang.Apply(tmp148, []any{tmp251}) + tmp253 := lang.Apply(tmp145, []any{tmp252}) + tmp254 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp255 := tmp254.FindInternedVar(lang.NewSymbol("list")) + if tmp255.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp255))) + } + tmp256 := tmp255.Get() + tmp257 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp258 := tmp257.FindInternedVar(lang.NewSymbol("seq")) + if tmp258.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp258))) + } + tmp259 := tmp258.Get() + tmp260 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp261 := tmp260.FindInternedVar(lang.NewSymbol("concat")) + if tmp261.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp261))) + } + tmp262 := tmp261.Get() + tmp263 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp264 := tmp263.FindInternedVar(lang.NewSymbol("list")) + if tmp264.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp264))) + } + tmp265 := tmp264.Get() + tmp266 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp267 := tmp266.FindInternedVar(lang.NewSymbol("apply")) + if tmp267.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp267))) + } + tmp268 := tmp267.Get() + tmp269 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp270 := tmp269.FindInternedVar(lang.NewSymbol("vector")) + if tmp270.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp270))) + } + tmp271 := tmp270.Get() + tmp272 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp273 := tmp272.FindInternedVar(lang.NewSymbol("seq")) + if tmp273.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp273))) + } + tmp274 := tmp273.Get() + tmp275 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp276 := tmp275.FindInternedVar(lang.NewSymbol("concat")) + if tmp276.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp276))) + } + tmp277 := tmp276.Get() + tmp278 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp279 := tmp278.FindInternedVar(lang.NewSymbol("list")) + if tmp279.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp279))) + } + tmp280 := tmp279.Get() + tmp281 := lang.Apply(tmp280, []any{lang.NewSymbol("array__0__auto__")}) + tmp282 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp283 := tmp282.FindInternedVar(lang.NewSymbol("list")) + if tmp283.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp283))) + } + tmp284 := tmp283.Get() + tmp285 := lang.Apply(tmp284, []any{lang.NewSymbol("idx__1__auto__")}) + tmp286 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp287 := tmp286.FindInternedVar(lang.NewSymbol("list")) + if tmp287.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp287))) + } + tmp288 := tmp287.Get() + tmp289 := lang.Apply(tmp288, []any{lang.NewSymbol("idx2__3__auto__")}) + tmp290 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp291 := tmp290.FindInternedVar(lang.NewSymbol("list")) + if tmp291.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp291))) + } + tmp292 := tmp291.Get() + tmp293 := lang.Apply(tmp292, []any{lang.NewSymbol("&")}) + tmp294 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp295 := tmp294.FindInternedVar(lang.NewSymbol("list")) + if tmp295.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp295))) + } + tmp296 := tmp295.Get() + tmp297 := lang.Apply(tmp296, []any{lang.NewSymbol("idxv__4__auto__")}) + tmp298 := lang.Apply(tmp277, []any{tmp281, tmp285, tmp289, tmp293, tmp297}) + tmp299 := lang.Apply(tmp274, []any{tmp298}) + tmp300 := lang.Apply(tmp268, []any{tmp271, tmp299}) + tmp301 := lang.Apply(tmp265, []any{tmp300}) + tmp302 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp303 := tmp302.FindInternedVar(lang.NewSymbol("list")) + if tmp303.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp303))) + } + tmp304 := tmp303.Get() + tmp305 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp306 := tmp305.FindInternedVar(lang.NewSymbol("seq")) + if tmp306.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp306))) + } + tmp307 := tmp306.Get() + tmp308 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp309 := tmp308.FindInternedVar(lang.NewSymbol("concat")) + if tmp309.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp309))) + } + tmp310 := tmp309.Get() + tmp311 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp312 := tmp311.FindInternedVar(lang.NewSymbol("list")) + if tmp312.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp312))) + } + tmp313 := tmp312.Get() + tmp314 := lang.Apply(tmp313, []any{lang.NewSymbol("glojure.core/apply")}) + tmp315 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp316 := tmp315.FindInternedVar(lang.NewSymbol("list")) + if tmp316.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp316))) + } + tmp317 := tmp316.Get() + tmp318 := lang.Apply(tmp317, []any{v5}) + tmp319 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp320 := tmp319.FindInternedVar(lang.NewSymbol("list")) + if tmp320.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp320))) + } + tmp321 := tmp320.Get() + tmp322 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp323 := tmp322.FindInternedVar(lang.NewSymbol("seq")) + if tmp323.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp323))) + } + tmp324 := tmp323.Get() + tmp325 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp326 := tmp325.FindInternedVar(lang.NewSymbol("concat")) + if tmp326.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp326))) + } + tmp327 := tmp326.Get() + tmp328 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp329 := tmp328.FindInternedVar(lang.NewSymbol("list")) + if tmp329.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp329))) + } + tmp330 := tmp329.Get() + tmp331 := lang.Apply(tmp330, []any{lang.NewSymbol("glojure.core/aget")}) + tmp332 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp333 := tmp332.FindInternedVar(lang.NewSymbol("list")) + if tmp333.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp333))) + } + tmp334 := tmp333.Get() + tmp335 := lang.Apply(tmp334, []any{lang.NewSymbol("array__0__auto__")}) + tmp336 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp337 := tmp336.FindInternedVar(lang.NewSymbol("list")) + if tmp337.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp337))) + } + tmp338 := tmp337.Get() + tmp339 := lang.Apply(tmp338, []any{lang.NewSymbol("idx__1__auto__")}) + tmp340 := lang.Apply(tmp327, []any{tmp331, tmp335, tmp339}) + tmp341 := lang.Apply(tmp324, []any{tmp340}) + tmp342 := lang.Apply(tmp321, []any{tmp341}) + tmp343 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp344 := tmp343.FindInternedVar(lang.NewSymbol("list")) + if tmp344.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp344))) + } + tmp345 := tmp344.Get() + tmp346 := lang.Apply(tmp345, []any{lang.NewSymbol("idx2__3__auto__")}) + tmp347 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp348 := tmp347.FindInternedVar(lang.NewSymbol("list")) + if tmp348.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp348))) + } + tmp349 := tmp348.Get() + tmp350 := lang.Apply(tmp349, []any{lang.NewSymbol("idxv__4__auto__")}) + tmp351 := lang.Apply(tmp310, []any{tmp314, tmp318, tmp342, tmp346, tmp350}) + tmp352 := lang.Apply(tmp307, []any{tmp351}) + tmp353 := lang.Apply(tmp304, []any{tmp352}) + tmp354 := lang.Apply(tmp262, []any{tmp301, tmp353}) + tmp355 := lang.Apply(tmp259, []any{tmp354}) + tmp356 := lang.Apply(tmp256, []any{tmp355}) + tmp357 := lang.Apply(tmp13, []any{tmp17, tmp21, tmp142, tmp253, tmp356}) + tmp358 := lang.Apply(tmp10, []any{tmp357}) + return tmp358 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // definline { - v0 := lang.NewSymbol("definline").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("decl"))), lang.NewKeyword("doc"), "Experimental - like defmacro, except defines a named function whose\n body is the expansion, calls to which may be expanded inline as if\n it were a macro. Cannot be used with variadic (&) args.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5253), lang.NewKeyword("end-line"), int(5253))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("definline").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("decl"))), lang.NewKeyword("doc"), "Experimental - like defmacro, except defines a named function whose\n body is the expansion, calls to which may be expanded inline as if\n it were a macro. Cannot be used with variadic (&) args.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5253), lang.NewKeyword("end-line"), int(5253))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 3 { @@ -21447,346 +21541,347 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - var v7 any + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any { // let // let binding "vec__80" - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("split-with")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("comp")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("not")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("vector?")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.Apply(v13, []any{v16, v19}) - v21 := lang.Apply(v10, []any{v20, v6}) - var v22 any = v21 + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("split-with")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("comp")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("not")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("vector?")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.Apply(tmp13, []any{tmp16, tmp19}) + tmp21 := lang.Apply(tmp10, []any{tmp20, v6}) + var v22 any = tmp21 _ = v22 // let binding "pre-args" - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("nth")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.Apply(v25, []any{v22, int64(0), nil}) - var v27 any = v26 + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("nth")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.Apply(tmp25, []any{v22, int64(0), nil}) + var v27 any = tmp26 _ = v27 // let binding "vec__83" - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("nth")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.Apply(v30, []any{v22, int64(1), nil}) - var v32 any = v31 + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("nth")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.Apply(tmp30, []any{v22, int64(1), nil}) + var v32 any = tmp31 _ = v32 // let binding "args" - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("nth")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - v36 := lang.Apply(v35, []any{v32, int64(0), nil}) - var v37 any = v36 + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("nth")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) + } + tmp35 := tmp34.Get() + tmp36 := lang.Apply(tmp35, []any{v32, int64(0), nil}) + var v37 any = tmp36 _ = v37 // let binding "expr" - v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v39 := v38.FindInternedVar(lang.NewSymbol("nth")) - if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) - } - v40 := v39.Get() - v41 := lang.Apply(v40, []any{v32, int64(1), nil}) - var v42 any = v41 + tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp39 := tmp38.FindInternedVar(lang.NewSymbol("nth")) + if tmp39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) + } + tmp40 := tmp39.Get() + tmp41 := lang.Apply(tmp40, []any{v32, int64(1), nil}) + var v42 any = tmp41 _ = v42 - v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v44 := v43.FindInternedVar(lang.NewSymbol("seq")) - if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) - } - v45 := v44.Get() - v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v47 := v46.FindInternedVar(lang.NewSymbol("concat")) - if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) - } - v48 := v47.Get() - v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v50 := v49.FindInternedVar(lang.NewSymbol("list")) - if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) - } - v51 := v50.Get() - v52 := lang.Apply(v51, []any{lang.NewSymbol("do")}) - v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v54 := v53.FindInternedVar(lang.NewSymbol("list")) - if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) - } - v55 := v54.Get() - v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v57 := v56.FindInternedVar(lang.NewSymbol("seq")) - if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) - } - v58 := v57.Get() - v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v60 := v59.FindInternedVar(lang.NewSymbol("concat")) - if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) - } - v61 := v60.Get() - v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v63 := v62.FindInternedVar(lang.NewSymbol("list")) - if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) - } - v64 := v63.Get() - v65 := lang.Apply(v64, []any{lang.NewSymbol("glojure.core/defn")}) - v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v67 := v66.FindInternedVar(lang.NewSymbol("list")) - if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) - } - v68 := v67.Get() - v69 := lang.Apply(v68, []any{v5}) - v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v71 := v70.FindInternedVar(lang.NewSymbol("list")) - if v71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) - } - v72 := v71.Get() - v73 := lang.Apply(v72, []any{v37}) - v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v75 := v74.FindInternedVar(lang.NewSymbol("list")) - if v75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) - } - v76 := v75.Get() - v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v78 := v77.FindInternedVar(lang.NewSymbol("apply")) - if v78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) - } - v79 := v78.Get() - v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v81 := v80.FindInternedVar(lang.NewSymbol("eval")) - if v81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) - } - v82 := v81.Get() - v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v84 := v83.FindInternedVar(lang.NewSymbol("list")) - if v84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) - } - v85 := v84.Get() - v86 := lang.Apply(v85, []any{lang.NewSymbol("glojure.core/fn"), v37, v42}) - v87 := lang.Apply(v82, []any{v86}) - v88 := lang.Apply(v79, []any{v87, v37}) - v89 := lang.Apply(v76, []any{v88}) - v90 := lang.Apply(v61, []any{v65, v69, v27, v73, v89}) - v91 := lang.Apply(v58, []any{v90}) - v92 := lang.Apply(v55, []any{v91}) - v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v94 := v93.FindInternedVar(lang.NewSymbol("list")) - if v94.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) - } - v95 := v94.Get() - v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v97 := v96.FindInternedVar(lang.NewSymbol("seq")) - if v97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) - } - v98 := v97.Get() - v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v100 := v99.FindInternedVar(lang.NewSymbol("concat")) - if v100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) - } - v101 := v100.Get() - v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v103 := v102.FindInternedVar(lang.NewSymbol("list")) - if v103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) - } - v104 := v103.Get() - v105 := lang.Apply(v104, []any{lang.NewSymbol("glojure.core/alter-meta!")}) - v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v107 := v106.FindInternedVar(lang.NewSymbol("list")) - if v107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) - } - v108 := v107.Get() - v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v110 := v109.FindInternedVar(lang.NewSymbol("seq")) - if v110.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) - } - v111 := v110.Get() - v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v113 := v112.FindInternedVar(lang.NewSymbol("concat")) - if v113.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) - } - v114 := v113.Get() - v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v116 := v115.FindInternedVar(lang.NewSymbol("list")) - if v116.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) - } - v117 := v116.Get() - v118 := lang.Apply(v117, []any{lang.NewSymbol("var")}) - v119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v120 := v119.FindInternedVar(lang.NewSymbol("list")) - if v120.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v120))) - } - v121 := v120.Get() - v122 := lang.Apply(v121, []any{v5}) - v123 := lang.Apply(v114, []any{v118, v122}) - v124 := lang.Apply(v111, []any{v123}) - v125 := lang.Apply(v108, []any{v124}) - v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v127 := v126.FindInternedVar(lang.NewSymbol("list")) - if v127.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) - } - v128 := v127.Get() - v129 := lang.Apply(v128, []any{lang.NewSymbol("glojure.core/assoc")}) - v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v131 := v130.FindInternedVar(lang.NewSymbol("list")) - if v131.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) - } - v132 := v131.Get() - v133 := lang.Apply(v132, []any{lang.NewKeyword("inline")}) - v134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v135 := v134.FindInternedVar(lang.NewSymbol("list")) - if v135.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v135))) - } - v136 := v135.Get() - v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v138 := v137.FindInternedVar(lang.NewSymbol("seq")) - if v138.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) - } - v139 := v138.Get() - v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v141 := v140.FindInternedVar(lang.NewSymbol("concat")) - if v141.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) - } - v142 := v141.Get() - v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v144 := v143.FindInternedVar(lang.NewSymbol("list")) - if v144.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) - } - v145 := v144.Get() - v146 := lang.Apply(v145, []any{lang.NewSymbol("glojure.core/fn")}) - v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v148 := v147.FindInternedVar(lang.NewSymbol("list")) - if v148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) - } - v149 := v148.Get() - v150 := lang.Apply(v149, []any{v5}) - v151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v152 := v151.FindInternedVar(lang.NewSymbol("list")) - if v152.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v152))) - } - v153 := v152.Get() - v154 := lang.Apply(v153, []any{v37}) - v155 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v156 := v155.FindInternedVar(lang.NewSymbol("list")) - if v156.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v156))) - } - v157 := v156.Get() - v158 := lang.Apply(v157, []any{v42}) - v159 := lang.Apply(v142, []any{v146, v150, v154, v158}) - v160 := lang.Apply(v139, []any{v159}) - v161 := lang.Apply(v136, []any{v160}) - v162 := lang.Apply(v101, []any{v105, v125, v129, v133, v161}) - v163 := lang.Apply(v98, []any{v162}) - v164 := lang.Apply(v95, []any{v163}) - v165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v166 := v165.FindInternedVar(lang.NewSymbol("list")) - if v166.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v166))) - } - v167 := v166.Get() - v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v169 := v168.FindInternedVar(lang.NewSymbol("seq")) - if v169.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) - } - v170 := v169.Get() - v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v172 := v171.FindInternedVar(lang.NewSymbol("concat")) - if v172.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) - } - v173 := v172.Get() - v174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v175 := v174.FindInternedVar(lang.NewSymbol("list")) - if v175.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v175))) - } - v176 := v175.Get() - v177 := lang.Apply(v176, []any{lang.NewSymbol("var")}) - v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v179 := v178.FindInternedVar(lang.NewSymbol("list")) - if v179.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) - } - v180 := v179.Get() - v181 := lang.Apply(v180, []any{v5}) - v182 := lang.Apply(v173, []any{v177, v181}) - v183 := lang.Apply(v170, []any{v182}) - v184 := lang.Apply(v167, []any{v183}) - v185 := lang.Apply(v48, []any{v52, v92, v164, v184}) - v186 := lang.Apply(v45, []any{v185}) - v7 = v186 + tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp44 := tmp43.FindInternedVar(lang.NewSymbol("seq")) + if tmp44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) + } + tmp45 := tmp44.Get() + tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp47 := tmp46.FindInternedVar(lang.NewSymbol("concat")) + if tmp47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) + } + tmp48 := tmp47.Get() + tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp50 := tmp49.FindInternedVar(lang.NewSymbol("list")) + if tmp50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) + } + tmp51 := tmp50.Get() + tmp52 := lang.Apply(tmp51, []any{lang.NewSymbol("do")}) + tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp54 := tmp53.FindInternedVar(lang.NewSymbol("list")) + if tmp54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) + } + tmp55 := tmp54.Get() + tmp56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp57 := tmp56.FindInternedVar(lang.NewSymbol("seq")) + if tmp57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp57))) + } + tmp58 := tmp57.Get() + tmp59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp60 := tmp59.FindInternedVar(lang.NewSymbol("concat")) + if tmp60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp60))) + } + tmp61 := tmp60.Get() + tmp62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp63 := tmp62.FindInternedVar(lang.NewSymbol("list")) + if tmp63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp63))) + } + tmp64 := tmp63.Get() + tmp65 := lang.Apply(tmp64, []any{lang.NewSymbol("glojure.core/defn")}) + tmp66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp67 := tmp66.FindInternedVar(lang.NewSymbol("list")) + if tmp67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp67))) + } + tmp68 := tmp67.Get() + tmp69 := lang.Apply(tmp68, []any{v5}) + tmp70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp71 := tmp70.FindInternedVar(lang.NewSymbol("list")) + if tmp71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp71))) + } + tmp72 := tmp71.Get() + tmp73 := lang.Apply(tmp72, []any{v37}) + tmp74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp75 := tmp74.FindInternedVar(lang.NewSymbol("list")) + if tmp75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp75))) + } + tmp76 := tmp75.Get() + tmp77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp78 := tmp77.FindInternedVar(lang.NewSymbol("apply")) + if tmp78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp78))) + } + tmp79 := tmp78.Get() + tmp80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp81 := tmp80.FindInternedVar(lang.NewSymbol("eval")) + if tmp81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp81))) + } + tmp82 := tmp81.Get() + tmp83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp84 := tmp83.FindInternedVar(lang.NewSymbol("list")) + if tmp84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp84))) + } + tmp85 := tmp84.Get() + tmp86 := lang.Apply(tmp85, []any{lang.NewSymbol("glojure.core/fn"), v37, v42}) + tmp87 := lang.Apply(tmp82, []any{tmp86}) + tmp88 := lang.Apply(tmp79, []any{tmp87, v37}) + tmp89 := lang.Apply(tmp76, []any{tmp88}) + tmp90 := lang.Apply(tmp61, []any{tmp65, tmp69, v27, tmp73, tmp89}) + tmp91 := lang.Apply(tmp58, []any{tmp90}) + tmp92 := lang.Apply(tmp55, []any{tmp91}) + tmp93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp94 := tmp93.FindInternedVar(lang.NewSymbol("list")) + if tmp94.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp94))) + } + tmp95 := tmp94.Get() + tmp96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp97 := tmp96.FindInternedVar(lang.NewSymbol("seq")) + if tmp97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp97))) + } + tmp98 := tmp97.Get() + tmp99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp100 := tmp99.FindInternedVar(lang.NewSymbol("concat")) + if tmp100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp100))) + } + tmp101 := tmp100.Get() + tmp102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp103 := tmp102.FindInternedVar(lang.NewSymbol("list")) + if tmp103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp103))) + } + tmp104 := tmp103.Get() + tmp105 := lang.Apply(tmp104, []any{lang.NewSymbol("glojure.core/alter-meta!")}) + tmp106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp107 := tmp106.FindInternedVar(lang.NewSymbol("list")) + if tmp107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp107))) + } + tmp108 := tmp107.Get() + tmp109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp110 := tmp109.FindInternedVar(lang.NewSymbol("seq")) + if tmp110.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp110))) + } + tmp111 := tmp110.Get() + tmp112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp113 := tmp112.FindInternedVar(lang.NewSymbol("concat")) + if tmp113.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp113))) + } + tmp114 := tmp113.Get() + tmp115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp116 := tmp115.FindInternedVar(lang.NewSymbol("list")) + if tmp116.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp116))) + } + tmp117 := tmp116.Get() + tmp118 := lang.Apply(tmp117, []any{lang.NewSymbol("var")}) + tmp119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp120 := tmp119.FindInternedVar(lang.NewSymbol("list")) + if tmp120.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp120))) + } + tmp121 := tmp120.Get() + tmp122 := lang.Apply(tmp121, []any{v5}) + tmp123 := lang.Apply(tmp114, []any{tmp118, tmp122}) + tmp124 := lang.Apply(tmp111, []any{tmp123}) + tmp125 := lang.Apply(tmp108, []any{tmp124}) + tmp126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp127 := tmp126.FindInternedVar(lang.NewSymbol("list")) + if tmp127.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp127))) + } + tmp128 := tmp127.Get() + tmp129 := lang.Apply(tmp128, []any{lang.NewSymbol("glojure.core/assoc")}) + tmp130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp131 := tmp130.FindInternedVar(lang.NewSymbol("list")) + if tmp131.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp131))) + } + tmp132 := tmp131.Get() + tmp133 := lang.Apply(tmp132, []any{lang.NewKeyword("inline")}) + tmp134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp135 := tmp134.FindInternedVar(lang.NewSymbol("list")) + if tmp135.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp135))) + } + tmp136 := tmp135.Get() + tmp137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp138 := tmp137.FindInternedVar(lang.NewSymbol("seq")) + if tmp138.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp138))) + } + tmp139 := tmp138.Get() + tmp140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp141 := tmp140.FindInternedVar(lang.NewSymbol("concat")) + if tmp141.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp141))) + } + tmp142 := tmp141.Get() + tmp143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp144 := tmp143.FindInternedVar(lang.NewSymbol("list")) + if tmp144.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp144))) + } + tmp145 := tmp144.Get() + tmp146 := lang.Apply(tmp145, []any{lang.NewSymbol("glojure.core/fn")}) + tmp147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp148 := tmp147.FindInternedVar(lang.NewSymbol("list")) + if tmp148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp148))) + } + tmp149 := tmp148.Get() + tmp150 := lang.Apply(tmp149, []any{v5}) + tmp151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp152 := tmp151.FindInternedVar(lang.NewSymbol("list")) + if tmp152.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp152))) + } + tmp153 := tmp152.Get() + tmp154 := lang.Apply(tmp153, []any{v37}) + tmp155 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp156 := tmp155.FindInternedVar(lang.NewSymbol("list")) + if tmp156.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp156))) + } + tmp157 := tmp156.Get() + tmp158 := lang.Apply(tmp157, []any{v42}) + tmp159 := lang.Apply(tmp142, []any{tmp146, tmp150, tmp154, tmp158}) + tmp160 := lang.Apply(tmp139, []any{tmp159}) + tmp161 := lang.Apply(tmp136, []any{tmp160}) + tmp162 := lang.Apply(tmp101, []any{tmp105, tmp125, tmp129, tmp133, tmp161}) + tmp163 := lang.Apply(tmp98, []any{tmp162}) + tmp164 := lang.Apply(tmp95, []any{tmp163}) + tmp165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp166 := tmp165.FindInternedVar(lang.NewSymbol("list")) + if tmp166.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp166))) + } + tmp167 := tmp166.Get() + tmp168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp169 := tmp168.FindInternedVar(lang.NewSymbol("seq")) + if tmp169.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp169))) + } + tmp170 := tmp169.Get() + tmp171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp172 := tmp171.FindInternedVar(lang.NewSymbol("concat")) + if tmp172.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp172))) + } + tmp173 := tmp172.Get() + tmp174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp175 := tmp174.FindInternedVar(lang.NewSymbol("list")) + if tmp175.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp175))) + } + tmp176 := tmp175.Get() + tmp177 := lang.Apply(tmp176, []any{lang.NewSymbol("var")}) + tmp178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp179 := tmp178.FindInternedVar(lang.NewSymbol("list")) + if tmp179.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp179))) + } + tmp180 := tmp179.Get() + tmp181 := lang.Apply(tmp180, []any{v5}) + tmp182 := lang.Apply(tmp173, []any{tmp177, tmp181}) + tmp183 := lang.Apply(tmp170, []any{tmp182}) + tmp184 := lang.Apply(tmp167, []any{tmp183}) + tmp185 := lang.Apply(tmp48, []any{tmp52, tmp92, tmp164, tmp184}) + tmp186 := lang.Apply(tmp45, []any{tmp185}) + tmp7 = tmp186 } // end let - return v7 + return tmp7 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // defmacro { - v0 := lang.NewSymbol("defmacro").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("doc-string?"), lang.NewSymbol("attr-map?"), lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("body")), lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("doc-string?"), lang.NewSymbol("attr-map?"), lang.NewList(lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("body")), lang.NewSymbol("+"), lang.NewSymbol("attr-map?"))), lang.NewKeyword("doc"), "Like defn, but the resulting function name is declared as a\n macro and will be used as a macro by the compiler when it is\n called.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(445), lang.NewKeyword("end-line"), int(451))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("defmacro").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("doc-string?"), lang.NewSymbol("attr-map?"), lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("body")), lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("doc-string?"), lang.NewSymbol("attr-map?"), lang.NewList(lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("body")), lang.NewSymbol("+"), lang.NewSymbol("attr-map?"))), lang.NewKeyword("doc"), "Like defn, but the resulting function name is declared as a\n macro and will be used as a macro by the compiler when it is\n called.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(445), lang.NewKeyword("end-line"), int(451))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 3 { @@ -21798,278 +21893,279 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - var v7 any + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any { // let // let binding "prefix" - var v8 any + var tmp8 any { // let // let binding "p" - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("list")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.Apply(v11, []any{v5}) - var v13 any = v12 + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("list")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.Apply(tmp11, []any{v5}) + var v13 any = tmp12 _ = v13 // let binding "args" var v14 any = v6 _ = v14 for { - var v15 any + var tmp15 any { // let // let binding "f" - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("first")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("first")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{v14}) - var v20 any = v19 + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{v14}) + var v20 any = tmp19 _ = v20 - var v21 any - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("string?")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + var tmp21 any + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("string?")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v20}) - if lang.IsTruthy(v25) { - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("cons")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + tmp24 := tmp23.Get() + tmp25 := lang.Apply(tmp24, []any{v20}) + if lang.IsTruthy(tmp25) { + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("cons")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{v20, v13}) - var v26 any = v30 - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("next")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{v20, v13}) + var tmp26 any = tmp30 + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("next")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{v14}) - var v31 any = v35 - v13 = v26 - v14 = v31 + tmp34 := tmp33.Get() + tmp35 := lang.Apply(tmp34, []any{v14}) + var tmp31 any = tmp35 + v13 = tmp26 + v14 = tmp31 continue } else { - var v36 any - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("map?")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + var tmp36 any + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("map?")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) } - v39 := v38.Get() - v40 := lang.Apply(v39, []any{v20}) - if lang.IsTruthy(v40) { - v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v43 := v42.FindInternedVar(lang.NewSymbol("cons")) - if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) + tmp39 := tmp38.Get() + tmp40 := lang.Apply(tmp39, []any{v20}) + if lang.IsTruthy(tmp40) { + tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp43 := tmp42.FindInternedVar(lang.NewSymbol("cons")) + if tmp43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) } - v44 := v43.Get() - v45 := lang.Apply(v44, []any{v20, v13}) - var v41 any = v45 - v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v48 := v47.FindInternedVar(lang.NewSymbol("next")) - if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) + tmp44 := tmp43.Get() + tmp45 := lang.Apply(tmp44, []any{v20, v13}) + var tmp41 any = tmp45 + tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp48 := tmp47.FindInternedVar(lang.NewSymbol("next")) + if tmp48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) } - v49 := v48.Get() - v50 := lang.Apply(v49, []any{v14}) - var v46 any = v50 - v13 = v41 - v14 = v46 + tmp49 := tmp48.Get() + tmp50 := lang.Apply(tmp49, []any{v14}) + var tmp46 any = tmp50 + v13 = tmp41 + v14 = tmp46 continue } else { - v36 = v13 + tmp36 = v13 } - v21 = v36 + tmp21 = tmp36 } - v15 = v21 + tmp15 = tmp21 } // end let - v8 = v15 + tmp8 = tmp15 break } } // end let - var v9 any = v8 + var v9 any = tmp8 _ = v9 // let binding "fdecl" - var v10 any + var tmp10 any { // let // let binding "fd" var v11 any = v6 _ = v11 for { - var v12 any - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("string?")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("first")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{v11}) - v20 := lang.Apply(v15, []any{v19}) - if lang.IsTruthy(v20) { - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("next")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + var tmp12 any + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("string?")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("first")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{v11}) + tmp20 := lang.Apply(tmp15, []any{tmp19}) + if lang.IsTruthy(tmp20) { + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("next")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v11}) - var v21 any = v25 - v11 = v21 + tmp24 := tmp23.Get() + tmp25 := lang.Apply(tmp24, []any{v11}) + var tmp21 any = tmp25 + v11 = tmp21 continue } else { - var v26 any - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("map?")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + var tmp26 any + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("map?")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) } - v29 := v28.Get() - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("first")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + tmp29 := tmp28.Get() + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("first")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) } - v32 := v31.Get() - v33 := lang.Apply(v32, []any{v11}) - v34 := lang.Apply(v29, []any{v33}) - if lang.IsTruthy(v34) { - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("next")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + tmp32 := tmp31.Get() + tmp33 := lang.Apply(tmp32, []any{v11}) + tmp34 := lang.Apply(tmp29, []any{tmp33}) + if lang.IsTruthy(tmp34) { + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("next")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) } - v38 := v37.Get() - v39 := lang.Apply(v38, []any{v11}) - var v35 any = v39 - v11 = v35 + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{v11}) + var tmp35 any = tmp39 + v11 = tmp35 continue } else { - v26 = v11 + tmp26 = v11 } - v12 = v26 + tmp12 = tmp26 } - v10 = v12 + tmp10 = tmp12 break } } // end let - var v11 any = v10 + var v11 any = tmp10 _ = v11 // let binding "fdecl" - var v12 any - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("vector?")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("first")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{v11}) - v20 := lang.Apply(v15, []any{v19}) - if lang.IsTruthy(v20) { - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("list")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.Apply(v23, []any{v11}) - v12 = v24 + var tmp12 any + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("vector?")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("first")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{v11}) + tmp20 := lang.Apply(tmp15, []any{tmp19}) + if lang.IsTruthy(tmp20) { + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("list")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.Apply(tmp23, []any{v11}) + tmp12 = tmp24 } else { - v12 = v11 + tmp12 = v11 } - var v25 any = v12 + var v25 any = tmp12 _ = v25 // let binding "add-implicit-args" - var v26 lang.FnFunc - v26 = lang.NewFnFunc(func(args ...any) any { + var tmp26 lang.FnFunc + tmp26 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v27 := args[0] _ = v27 - var v28 any + var tmp28 any { // let // let binding "args" - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("first")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.Apply(v31, []any{v27}) - var v33 any = v32 + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("first")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.Apply(tmp31, []any{v27}) + var v33 any = tmp32 _ = v33 - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("cons")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) - } - v36 := v35.Get() - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("vec")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("cons")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) - } - v42 := v41.Get() - v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v44 := v43.FindInternedVar(lang.NewSymbol("cons")) - if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) - } - v45 := v44.Get() - v46 := lang.Apply(v45, []any{lang.NewSymbol("&env"), v33}) - v47 := lang.Apply(v42, []any{lang.NewSymbol("&form"), v46}) - v48 := lang.Apply(v39, []any{v47}) - v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v50 := v49.FindInternedVar(lang.NewSymbol("next")) - if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) - } - v51 := v50.Get() - v52 := lang.Apply(v51, []any{v27}) - v53 := lang.Apply(v36, []any{v48, v52}) - v28 = v53 + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("cons")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("vec")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("cons")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) + } + tmp42 := tmp41.Get() + tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp44 := tmp43.FindInternedVar(lang.NewSymbol("cons")) + if tmp44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) + } + tmp45 := tmp44.Get() + tmp46 := lang.Apply(tmp45, []any{lang.NewSymbol("&env"), v33}) + tmp47 := lang.Apply(tmp42, []any{lang.NewSymbol("&form"), tmp46}) + tmp48 := lang.Apply(tmp39, []any{tmp47}) + tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp50 := tmp49.FindInternedVar(lang.NewSymbol("next")) + if tmp50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) + } + tmp51 := tmp50.Get() + tmp52 := lang.Apply(tmp51, []any{v27}) + tmp53 := lang.Apply(tmp36, []any{tmp48, tmp52}) + tmp28 = tmp53 } // end let - return v28 + return tmp28 }) - v27 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(469), lang.NewKeyword("column"), int(38), lang.NewKeyword("end-line"), int(471), lang.NewKeyword("end-column"), int(87)) - v28, err := lang.WithMeta(v26, v27.(lang.IPersistentMap)) + tmp27 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(469), lang.NewKeyword("column"), int(38), lang.NewKeyword("end-line"), int(471), lang.NewKeyword("end-column"), int(87)) + tmp28, err := lang.WithMeta(tmp26, tmp27.(lang.IPersistentMap)) if err != nil { panic(err) } - var v29 any = v28 + var v29 any = tmp28 _ = v29 // let binding "add-args" - var v30 lang.FnFunc - v30 = lang.NewFnFunc(func(args ...any) any { + var tmp30 lang.FnFunc + tmp30 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -22078,100 +22174,100 @@ func init() { v32 := args[1] _ = v32 recur_loop_61: - var v33 any - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("nil?")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) - } - v36 := v35.Get() - v37 := lang.Apply(v36, []any{v32}) - if lang.IsTruthy(v37) { - v33 = v31 + var tmp33 any + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("nil?")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.Apply(tmp36, []any{v32}) + if lang.IsTruthy(tmp37) { + tmp33 = v31 } else { - var v38 any + var tmp38 any { // let // let binding "d" - v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v40 := v39.FindInternedVar(lang.NewSymbol("first")) - if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) + tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp40 := tmp39.FindInternedVar(lang.NewSymbol("first")) + if tmp40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) } - v41 := v40.Get() - v42 := lang.Apply(v41, []any{v32}) - var v43 any = v42 + tmp41 := tmp40.Get() + tmp42 := lang.Apply(tmp41, []any{v32}) + var v43 any = tmp42 _ = v43 - var v44 any - v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v46 := v45.FindInternedVar(lang.NewSymbol("map?")) - if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) + var tmp44 any + tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp46 := tmp45.FindInternedVar(lang.NewSymbol("map?")) + if tmp46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) } - v47 := v46.Get() - v48 := lang.Apply(v47, []any{v43}) - if lang.IsTruthy(v48) { - v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v50 := v49.FindInternedVar(lang.NewSymbol("conj")) - if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) + tmp47 := tmp46.Get() + tmp48 := lang.Apply(tmp47, []any{v43}) + if lang.IsTruthy(tmp48) { + tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp50 := tmp49.FindInternedVar(lang.NewSymbol("conj")) + if tmp50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) } - v51 := v50.Get() - v52 := lang.Apply(v51, []any{v31, v43}) - v44 = v52 + tmp51 := tmp50.Get() + tmp52 := lang.Apply(tmp51, []any{v31, v43}) + tmp44 = tmp52 } else { - v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v55 := v54.FindInternedVar(lang.NewSymbol("conj")) - if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) + tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp55 := tmp54.FindInternedVar(lang.NewSymbol("conj")) + if tmp55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) } - v56 := v55.Get() - v57 := lang.Apply(v29, []any{v43}) - v58 := lang.Apply(v56, []any{v31, v57}) - var v53 any = v58 - v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v61 := v60.FindInternedVar(lang.NewSymbol("next")) - if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) + tmp56 := tmp55.Get() + tmp57 := lang.Apply(v29, []any{v43}) + tmp58 := lang.Apply(tmp56, []any{v31, tmp57}) + var tmp53 any = tmp58 + tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp61 := tmp60.FindInternedVar(lang.NewSymbol("next")) + if tmp61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) } - v62 := v61.Get() - v63 := lang.Apply(v62, []any{v32}) - var v59 any = v63 - v31 = v53 - v32 = v59 + tmp62 := tmp61.Get() + tmp63 := lang.Apply(tmp62, []any{v32}) + var tmp59 any = tmp63 + v31 = tmp53 + v32 = tmp59 goto recur_loop_61 } - v38 = v44 + tmp38 = tmp44 } // end let - v33 = v38 + tmp33 = tmp38 } - return v33 + return tmp33 }) - v31 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(472), lang.NewKeyword("column"), int(29), lang.NewKeyword("end-line"), int(478), lang.NewKeyword("end-column"), int(90)) - v32, err := lang.WithMeta(v30, v31.(lang.IPersistentMap)) + tmp31 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(472), lang.NewKeyword("column"), int(29), lang.NewKeyword("end-line"), int(478), lang.NewKeyword("end-column"), int(90)) + tmp32, err := lang.WithMeta(tmp30, tmp31.(lang.IPersistentMap)) if err != nil { panic(err) } - var v33 any = v32 + var v33 any = tmp32 _ = v33 // let binding "fdecl" - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("seq")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) - } - v36 := v35.Get() - v37 := lang.NewVector() - v38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(479), lang.NewKeyword("column"), int(41), lang.NewKeyword("end-line"), int(479), lang.NewKeyword("end-column"), int(42)) - v39, err := lang.WithMeta(v37, v38.(lang.IPersistentMap)) + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.NewVector() + tmp38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(479), lang.NewKeyword("column"), int(41), lang.NewKeyword("end-line"), int(479), lang.NewKeyword("end-column"), int(42)) + tmp39, err := lang.WithMeta(tmp37, tmp38.(lang.IPersistentMap)) if err != nil { panic(err) } - v40 := lang.Apply(v33, []any{v39, v25}) - v41 := lang.Apply(v36, []any{v40}) - var v42 any = v41 + tmp40 := lang.Apply(v33, []any{tmp39, v25}) + tmp41 := lang.Apply(tmp36, []any{tmp40}) + var v42 any = tmp41 _ = v42 // let binding "decl" - var v43 any + var tmp43 any { // let // let binding "p" var v44 any = v9 @@ -22180,94 +22276,94 @@ func init() { var v45 any = v42 _ = v45 for { - var v46 any + var tmp46 any if lang.IsTruthy(v44) { - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("next")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("next")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v44}) - var v47 any = v51 - v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v54 := v53.FindInternedVar(lang.NewSymbol("cons")) - if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v44}) + var tmp47 any = tmp51 + tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp54 := tmp53.FindInternedVar(lang.NewSymbol("cons")) + if tmp54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) } - v55 := v54.Get() - v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v57 := v56.FindInternedVar(lang.NewSymbol("first")) - if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) + tmp55 := tmp54.Get() + tmp56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp57 := tmp56.FindInternedVar(lang.NewSymbol("first")) + if tmp57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp57))) } - v58 := v57.Get() - v59 := lang.Apply(v58, []any{v44}) - v60 := lang.Apply(v55, []any{v59, v45}) - var v52 any = v60 - v44 = v47 - v45 = v52 + tmp58 := tmp57.Get() + tmp59 := lang.Apply(tmp58, []any{v44}) + tmp60 := lang.Apply(tmp55, []any{tmp59, v45}) + var tmp52 any = tmp60 + v44 = tmp47 + v45 = tmp52 continue } else { - v46 = v45 + tmp46 = v45 } - v43 = v46 + tmp43 = tmp46 break } } // end let - var v44 any = v43 + var v44 any = tmp43 _ = v44 - v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v46 := v45.FindInternedVar(lang.NewSymbol("list")) - if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) - } - v47 := v46.Get() - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("cons")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{lang.NewSymbol("glojure.core/defn"), v44}) - v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v53 := v52.FindInternedVar(lang.NewSymbol("list")) - if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) - } - v54 := v53.Get() - v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v56 := v55.FindInternedVar(lang.NewSymbol("list")) - if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) - } - v57 := v56.Get() - v58 := lang.Apply(v57, []any{lang.NewSymbol("var"), v5}) - v59 := lang.Apply(v54, []any{lang.NewSymbol("."), v58, lang.NewList(lang.NewSymbol("SetMacro"))}) - v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v61 := v60.FindInternedVar(lang.NewSymbol("list")) - if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) - } - v62 := v61.Get() - v63 := lang.Apply(v62, []any{lang.NewSymbol("var"), v5}) - v64 := lang.Apply(v47, []any{lang.NewSymbol("do"), v51, v59, v63}) - v7 = v64 + tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp46 := tmp45.FindInternedVar(lang.NewSymbol("list")) + if tmp46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) + } + tmp47 := tmp46.Get() + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("cons")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{lang.NewSymbol("glojure.core/defn"), v44}) + tmp52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp53 := tmp52.FindInternedVar(lang.NewSymbol("list")) + if tmp53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp53))) + } + tmp54 := tmp53.Get() + tmp55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp56 := tmp55.FindInternedVar(lang.NewSymbol("list")) + if tmp56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp56))) + } + tmp57 := tmp56.Get() + tmp58 := lang.Apply(tmp57, []any{lang.NewSymbol("var"), v5}) + tmp59 := lang.Apply(tmp54, []any{lang.NewSymbol("."), tmp58, lang.NewList(lang.NewSymbol("SetMacro"))}) + tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp61 := tmp60.FindInternedVar(lang.NewSymbol("list")) + if tmp61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) + } + tmp62 := tmp61.Get() + tmp63 := lang.Apply(tmp62, []any{lang.NewSymbol("var"), v5}) + tmp64 := lang.Apply(tmp47, []any{lang.NewSymbol("do"), tmp51, tmp59, tmp63}) + tmp7 = tmp64 } // end let - return v7 + return tmp7 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(451), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(487), lang.NewKeyword("end-column"), int(40))).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(451), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(487), lang.NewKeyword("end-column"), int(40))).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // defmethod { - v0 := lang.NewSymbol("defmethod").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"), lang.NewSymbol("dispatch-val"), lang.NewSymbol("&"), lang.NewSymbol("fn-tail"))), lang.NewKeyword("doc"), "Creates and installs a new method of multimethod associated with dispatch-value. ", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1781), lang.NewKeyword("end-line"), int(1781))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("defmethod").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"), lang.NewSymbol("dispatch-val"), lang.NewSymbol("&"), lang.NewSymbol("fn-tail"))), lang.NewKeyword("doc"), "Creates and installs a new method of multimethod associated with dispatch-value. ", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1781), lang.NewKeyword("end-line"), int(1781))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 4 { @@ -22281,104 +22377,105 @@ func init() { _ = v5 v6 := args[3] _ = v6 - v7 := lang.NewList(args[4:]...) - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("seq")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("concat")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol(".")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("with-meta")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.NewMap(lang.NewKeyword("tag"), lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.*MultiFn")) - v25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1785), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(1785), lang.NewKeyword("end-column"), int(82)) - v26, err := lang.WithMeta(v24, v25.(lang.IPersistentMap)) + var v7 any = lang.NewList(args[4:]...) + _ = v7 + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("seq")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("concat")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol(".")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("with-meta")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.NewMap(lang.NewKeyword("tag"), lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.*MultiFn")) + tmp25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1785), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(1785), lang.NewKeyword("end-column"), int(82)) + tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) if err != nil { panic(err) } - v27 := lang.Apply(v23, []any{v5, v26}) - v28 := lang.Apply(v20, []any{v27}) - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("list")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.Apply(v31, []any{lang.NewSymbol("glojure.core/AddMethod")}) - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("list")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - v36 := lang.Apply(v35, []any{v6}) - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("list")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("seq")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) - } - v42 := v41.Get() - v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v44 := v43.FindInternedVar(lang.NewSymbol("concat")) - if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) - } - v45 := v44.Get() - v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v47 := v46.FindInternedVar(lang.NewSymbol("list")) - if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) - } - v48 := v47.Get() - v49 := lang.Apply(v48, []any{lang.NewSymbol("glojure.core/fn")}) - v50 := lang.Apply(v45, []any{v49, v7}) - v51 := lang.Apply(v42, []any{v50}) - v52 := lang.Apply(v39, []any{v51}) - v53 := lang.Apply(v13, []any{v17, v28, v32, v36, v52}) - v54 := lang.Apply(v10, []any{v53}) - return v54 - } - }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp27 := lang.Apply(tmp23, []any{v5, tmp26}) + tmp28 := lang.Apply(tmp20, []any{tmp27}) + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("list")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.Apply(tmp31, []any{lang.NewSymbol("glojure.core/AddMethod")}) + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("list")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) + } + tmp35 := tmp34.Get() + tmp36 := lang.Apply(tmp35, []any{v6}) + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("list")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("seq")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) + } + tmp42 := tmp41.Get() + tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp44 := tmp43.FindInternedVar(lang.NewSymbol("concat")) + if tmp44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) + } + tmp45 := tmp44.Get() + tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp47 := tmp46.FindInternedVar(lang.NewSymbol("list")) + if tmp47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) + } + tmp48 := tmp47.Get() + tmp49 := lang.Apply(tmp48, []any{lang.NewSymbol("glojure.core/fn")}) + tmp50 := lang.Apply(tmp45, []any{tmp49, v7}) + tmp51 := lang.Apply(tmp42, []any{tmp50}) + tmp52 := lang.Apply(tmp39, []any{tmp51}) + tmp53 := lang.Apply(tmp13, []any{tmp17, tmp28, tmp32, tmp36, tmp52}) + tmp54 := lang.Apply(tmp10, []any{tmp53}) + return tmp54 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // defmulti { - v0 := lang.NewSymbol("defmulti").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("docstring?"), lang.NewSymbol("attr-map?"), lang.NewSymbol("dispatch-fn"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Creates a new multimethod with the associated dispatch function.\n The docstring and attr-map are optional.\n\n Options are key-value pairs and may be one of:\n\n :default\n\n The default dispatch value, defaults to :default\n\n :hierarchy\n\n The value used for hierarchical dispatch (e.g. ::square is-a ::shape)\n\n Hierarchies are type-like relationships that do not depend upon type\n inheritance. By default Clojure's multimethods dispatch off of a\n global hierarchy map. However, a hierarchy relationship can be\n created with the derive function used to augment the root ancestor\n created with make-hierarchy.\n\n Multimethods expect the value of the hierarchy option to be supplied as\n a reference type e.g. a var (i.e. via the Var-quote dispatch macro #'\n or the var special form).", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1723), lang.NewKeyword("end-line"), int(1723))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("defmulti").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("docstring?"), lang.NewSymbol("attr-map?"), lang.NewSymbol("dispatch-fn"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Creates a new multimethod with the associated dispatch function.\n The docstring and attr-map are optional.\n\n Options are key-value pairs and may be one of:\n\n :default\n\n The default dispatch value, defaults to :default\n\n :hierarchy\n\n The value used for hierarchical dispatch (e.g. ::square is-a ::shape)\n\n Hierarchies are type-like relationships that do not depend upon type\n inheritance. By default Clojure's multimethods dispatch off of a\n global hierarchy map. However, a hierarchy relationship can be\n created with the derive function used to augment the root ancestor\n created with make-hierarchy.\n\n Multimethods expect the value of the hierarchy option to be supplied as\n a reference type e.g. a var (i.e. via the Var-quote dispatch macro #'\n or the var special form).", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1723), lang.NewKeyword("end-line"), int(1723))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 3 { @@ -22390,655 +22487,655 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - var v7 any + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any { // let // let binding "docstring" - var v8 any - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("string?")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("first")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.Apply(v14, []any{v6}) - v16 := lang.Apply(v11, []any{v15}) - if lang.IsTruthy(v16) { - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("first")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.Apply(v19, []any{v6}) - v8 = v20 + var tmp8 any + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("string?")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("first")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.Apply(tmp14, []any{v6}) + tmp16 := lang.Apply(tmp11, []any{tmp15}) + if lang.IsTruthy(tmp16) { + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("first")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.Apply(tmp19, []any{v6}) + tmp8 = tmp20 } else { - v8 = nil } - var v21 any = v8 + var v21 any = tmp8 _ = v21 // let binding "options" - var v22 any - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("string?")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("first")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) - } - v28 := v27.Get() - v29 := lang.Apply(v28, []any{v6}) - v30 := lang.Apply(v25, []any{v29}) - if lang.IsTruthy(v30) { - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("next")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{v6}) - v22 = v34 + var tmp22 any + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("string?")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("first")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) + } + tmp28 := tmp27.Get() + tmp29 := lang.Apply(tmp28, []any{v6}) + tmp30 := lang.Apply(tmp25, []any{tmp29}) + if lang.IsTruthy(tmp30) { + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("next")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{v6}) + tmp22 = tmp34 } else { - v22 = v6 + tmp22 = v6 } - var v35 any = v22 + var v35 any = tmp22 _ = v35 // let binding "m" - var v36 any - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("map?")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("first")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) - } - v42 := v41.Get() - v43 := lang.Apply(v42, []any{v35}) - v44 := lang.Apply(v39, []any{v43}) - if lang.IsTruthy(v44) { - v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v46 := v45.FindInternedVar(lang.NewSymbol("first")) - if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) - } - v47 := v46.Get() - v48 := lang.Apply(v47, []any{v35}) - v36 = v48 + var tmp36 any + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("map?")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("first")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) + } + tmp42 := tmp41.Get() + tmp43 := lang.Apply(tmp42, []any{v35}) + tmp44 := lang.Apply(tmp39, []any{tmp43}) + if lang.IsTruthy(tmp44) { + tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp46 := tmp45.FindInternedVar(lang.NewSymbol("first")) + if tmp46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) + } + tmp47 := tmp46.Get() + tmp48 := lang.Apply(tmp47, []any{v35}) + tmp36 = tmp48 } else { - v49 := lang.NewMap() - v50 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1757), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(1757), lang.NewKeyword("end-column"), int(24)) - v51, err := lang.WithMeta(v49, v50.(lang.IPersistentMap)) + tmp49 := lang.NewMap() + tmp50 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1757), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(1757), lang.NewKeyword("end-column"), int(24)) + tmp51, err := lang.WithMeta(tmp49, tmp50.(lang.IPersistentMap)) if err != nil { panic(err) } - v36 = v51 + tmp36 = tmp51 } - var v52 any = v36 + var v52 any = tmp36 _ = v52 // let binding "options" - var v53 any - v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v55 := v54.FindInternedVar(lang.NewSymbol("map?")) - if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) - } - v56 := v55.Get() - v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v58 := v57.FindInternedVar(lang.NewSymbol("first")) - if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) - } - v59 := v58.Get() - v60 := lang.Apply(v59, []any{v35}) - v61 := lang.Apply(v56, []any{v60}) - if lang.IsTruthy(v61) { - v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v63 := v62.FindInternedVar(lang.NewSymbol("next")) - if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) - } - v64 := v63.Get() - v65 := lang.Apply(v64, []any{v35}) - v53 = v65 + var tmp53 any + tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp55 := tmp54.FindInternedVar(lang.NewSymbol("map?")) + if tmp55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) + } + tmp56 := tmp55.Get() + tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp58 := tmp57.FindInternedVar(lang.NewSymbol("first")) + if tmp58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) + } + tmp59 := tmp58.Get() + tmp60 := lang.Apply(tmp59, []any{v35}) + tmp61 := lang.Apply(tmp56, []any{tmp60}) + if lang.IsTruthy(tmp61) { + tmp62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp63 := tmp62.FindInternedVar(lang.NewSymbol("next")) + if tmp63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp63))) + } + tmp64 := tmp63.Get() + tmp65 := lang.Apply(tmp64, []any{v35}) + tmp53 = tmp65 } else { - v53 = v35 + tmp53 = v35 } - var v66 any = v53 + var v66 any = tmp53 _ = v66 // let binding "dispatch-fn" - v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v68 := v67.FindInternedVar(lang.NewSymbol("first")) - if v68.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) - } - v69 := v68.Get() - v70 := lang.Apply(v69, []any{v66}) - var v71 any = v70 + tmp67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp68 := tmp67.FindInternedVar(lang.NewSymbol("first")) + if tmp68.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp68))) + } + tmp69 := tmp68.Get() + tmp70 := lang.Apply(tmp69, []any{v66}) + var v71 any = tmp70 _ = v71 // let binding "options" - v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v73 := v72.FindInternedVar(lang.NewSymbol("next")) - if v73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) - } - v74 := v73.Get() - v75 := lang.Apply(v74, []any{v66}) - var v76 any = v75 + tmp72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp73 := tmp72.FindInternedVar(lang.NewSymbol("next")) + if tmp73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp73))) + } + tmp74 := tmp73.Get() + tmp75 := lang.Apply(tmp74, []any{v66}) + var v76 any = tmp75 _ = v76 // let binding "m" - var v77 any + var tmp77 any if lang.IsTruthy(v21) { - v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v79 := v78.FindInternedVar(lang.NewSymbol("assoc")) - if v79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) - } - v80 := v79.Get() - v81 := lang.Apply(v80, []any{v52, lang.NewKeyword("doc"), v21}) - v77 = v81 + tmp78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp79 := tmp78.FindInternedVar(lang.NewSymbol("assoc")) + if tmp79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp79))) + } + tmp80 := tmp79.Get() + tmp81 := lang.Apply(tmp80, []any{v52, lang.NewKeyword("doc"), v21}) + tmp77 = tmp81 } else { - v77 = v52 + tmp77 = v52 } - var v82 any = v77 + var v82 any = tmp77 _ = v82 // let binding "m" - var v83 any - v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v85 := v84.FindInternedVar(lang.NewSymbol("meta")) - if v85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) - } - v86 := v85.Get() - v87 := lang.Apply(v86, []any{v5}) - if lang.IsTruthy(v87) { - v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v89 := v88.FindInternedVar(lang.NewSymbol("conj")) - if v89.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) - } - v90 := v89.Get() - v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v92 := v91.FindInternedVar(lang.NewSymbol("meta")) - if v92.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) - } - v93 := v92.Get() - v94 := lang.Apply(v93, []any{v5}) - v95 := lang.Apply(v90, []any{v94, v82}) - v83 = v95 + var tmp83 any + tmp84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp85 := tmp84.FindInternedVar(lang.NewSymbol("meta")) + if tmp85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp85))) + } + tmp86 := tmp85.Get() + tmp87 := lang.Apply(tmp86, []any{v5}) + if lang.IsTruthy(tmp87) { + tmp88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp89 := tmp88.FindInternedVar(lang.NewSymbol("conj")) + if tmp89.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp89))) + } + tmp90 := tmp89.Get() + tmp91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp92 := tmp91.FindInternedVar(lang.NewSymbol("meta")) + if tmp92.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp92))) + } + tmp93 := tmp92.Get() + tmp94 := lang.Apply(tmp93, []any{v5}) + tmp95 := lang.Apply(tmp90, []any{tmp94, v82}) + tmp83 = tmp95 } else { - v83 = v82 + tmp83 = v82 } - var v96 any = v83 + var v96 any = tmp83 _ = v96 // let binding "mm-name" - v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v98 := v97.FindInternedVar(lang.NewSymbol("with-meta")) - if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) - } - v99 := v98.Get() - v100 := lang.Apply(v99, []any{v5, v96}) - var v101 any = v100 + tmp97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp98 := tmp97.FindInternedVar(lang.NewSymbol("with-meta")) + if tmp98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp98))) + } + tmp99 := tmp98.Get() + tmp100 := lang.Apply(tmp99, []any{v5, v96}) + var v101 any = tmp100 _ = v101 - var v102 any - v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v104 := v103.FindInternedVar(lang.NewSymbol("=")) - if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) - } - v105 := v104.Get() - v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v107 := v106.FindInternedVar(lang.NewSymbol("count")) - if v107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) - } - v108 := v107.Get() - v109 := lang.Apply(v108, []any{v76}) - v110 := lang.Apply(v105, []any{v109, int64(1)}) - if lang.IsTruthy(v110) { - v111 := lang.Apply(lang.NewError, []any{"The syntax for defmulti has changed. Example: (defmulti name dispatch-fn :default dispatch-value)"}) - panic(v111) + var tmp102 any + tmp103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp104 := tmp103.FindInternedVar(lang.NewSymbol("=")) + if tmp104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp104))) + } + tmp105 := tmp104.Get() + tmp106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp107 := tmp106.FindInternedVar(lang.NewSymbol("count")) + if tmp107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp107))) + } + tmp108 := tmp107.Get() + tmp109 := lang.Apply(tmp108, []any{v76}) + tmp110 := lang.Apply(tmp105, []any{tmp109, int64(1)}) + if lang.IsTruthy(tmp110) { + tmp111 := lang.Apply(lang.NewError, []any{"The syntax for defmulti has changed. Example: (defmulti name dispatch-fn :default dispatch-value)"}) + panic(tmp111) } else { - v102 = nil } - _ = v102 - var v112 any + _ = tmp102 + var tmp112 any { // let // let binding "options" - v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v114 := v113.FindInternedVar(lang.NewSymbol("apply")) - if v114.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) - } - v115 := v114.Get() - v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v117 := v116.FindInternedVar(lang.NewSymbol("hash-map")) - if v117.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) - } - v118 := v117.Get() - v119 := lang.Apply(v115, []any{v118, v76}) - var v120 any = v119 + tmp113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp114 := tmp113.FindInternedVar(lang.NewSymbol("apply")) + if tmp114.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp114))) + } + tmp115 := tmp114.Get() + tmp116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp117 := tmp116.FindInternedVar(lang.NewSymbol("hash-map")) + if tmp117.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp117))) + } + tmp118 := tmp117.Get() + tmp119 := lang.Apply(tmp115, []any{tmp118, v76}) + var v120 any = tmp119 _ = v120 // let binding "default" - v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v122 := v121.FindInternedVar(lang.NewSymbol("get")) - if v122.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) - } - v123 := v122.Get() - v124 := lang.Apply(v123, []any{v120, lang.NewKeyword("default"), lang.NewKeyword("default")}) - var v125 any = v124 + tmp121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp122 := tmp121.FindInternedVar(lang.NewSymbol("get")) + if tmp122.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp122))) + } + tmp123 := tmp122.Get() + tmp124 := lang.Apply(tmp123, []any{v120, lang.NewKeyword("default"), lang.NewKeyword("default")}) + var v125 any = tmp124 _ = v125 // let binding "hierarchy" - v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v127 := v126.FindInternedVar(lang.NewSymbol("get")) - if v127.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) - } - v128 := v127.Get() - v129 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("global-hierarchy")) - v130 := lang.Apply(v128, []any{v120, lang.NewKeyword("hierarchy"), v129}) - var v131 any = v130 + tmp126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp127 := tmp126.FindInternedVar(lang.NewSymbol("get")) + if tmp127.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp127))) + } + tmp128 := tmp127.Get() + tmp129 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("global-hierarchy")) + tmp130 := lang.Apply(tmp128, []any{v120, lang.NewKeyword("hierarchy"), tmp129}) + var v131 any = tmp130 _ = v131 - v132 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v133 := v132.FindInternedVar(lang.NewSymbol("check-valid-options")) - if v133.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v133))) - } - v134 := v133.Get() - v135 := lang.Apply(v134, []any{v120, lang.NewKeyword("default"), lang.NewKeyword("hierarchy")}) - _ = v135 - v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v137 := v136.FindInternedVar(lang.NewSymbol("seq")) - if v137.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) - } - v138 := v137.Get() - v139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v140 := v139.FindInternedVar(lang.NewSymbol("concat")) - if v140.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v140))) - } - v141 := v140.Get() - v142 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v143 := v142.FindInternedVar(lang.NewSymbol("list")) - if v143.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v143))) - } - v144 := v143.Get() - v145 := lang.Apply(v144, []any{lang.NewSymbol("glojure.core/let")}) - v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v147 := v146.FindInternedVar(lang.NewSymbol("list")) - if v147.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) - } - v148 := v147.Get() - v149 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v150 := v149.FindInternedVar(lang.NewSymbol("apply")) - if v150.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v150))) - } - v151 := v150.Get() - v152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v153 := v152.FindInternedVar(lang.NewSymbol("vector")) - if v153.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v153))) - } - v154 := v153.Get() - v155 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v156 := v155.FindInternedVar(lang.NewSymbol("seq")) - if v156.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v156))) - } - v157 := v156.Get() - v158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v159 := v158.FindInternedVar(lang.NewSymbol("concat")) - if v159.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v159))) - } - v160 := v159.Get() - v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v162 := v161.FindInternedVar(lang.NewSymbol("list")) - if v162.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) - } - v163 := v162.Get() - v164 := lang.Apply(v163, []any{lang.NewSymbol("v__0__auto__")}) - v165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v166 := v165.FindInternedVar(lang.NewSymbol("list")) - if v166.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v166))) - } - v167 := v166.Get() - v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v169 := v168.FindInternedVar(lang.NewSymbol("seq")) - if v169.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) - } - v170 := v169.Get() - v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v172 := v171.FindInternedVar(lang.NewSymbol("concat")) - if v172.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) - } - v173 := v172.Get() - v174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v175 := v174.FindInternedVar(lang.NewSymbol("list")) - if v175.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v175))) - } - v176 := v175.Get() - v177 := lang.Apply(v176, []any{lang.NewSymbol("def")}) - v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v179 := v178.FindInternedVar(lang.NewSymbol("list")) - if v179.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) - } - v180 := v179.Get() - v181 := lang.Apply(v180, []any{v101}) - v182 := lang.Apply(v173, []any{v177, v181}) - v183 := lang.Apply(v170, []any{v182}) - v184 := lang.Apply(v167, []any{v183}) - v185 := lang.Apply(v160, []any{v164, v184}) - v186 := lang.Apply(v157, []any{v185}) - v187 := lang.Apply(v151, []any{v154, v186}) - v188 := lang.Apply(v148, []any{v187}) - v189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v190 := v189.FindInternedVar(lang.NewSymbol("list")) - if v190.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v190))) - } - v191 := v190.Get() - v192 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v193 := v192.FindInternedVar(lang.NewSymbol("seq")) - if v193.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v193))) - } - v194 := v193.Get() - v195 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v196 := v195.FindInternedVar(lang.NewSymbol("concat")) - if v196.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v196))) - } - v197 := v196.Get() - v198 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v199 := v198.FindInternedVar(lang.NewSymbol("list")) - if v199.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v199))) - } - v200 := v199.Get() - v201 := lang.Apply(v200, []any{lang.NewSymbol("glojure.core/when-not")}) - v202 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v203 := v202.FindInternedVar(lang.NewSymbol("list")) - if v203.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v203))) - } - v204 := v203.Get() - v205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v206 := v205.FindInternedVar(lang.NewSymbol("seq")) - if v206.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v206))) - } - v207 := v206.Get() - v208 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v209 := v208.FindInternedVar(lang.NewSymbol("concat")) - if v209.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v209))) - } - v210 := v209.Get() - v211 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v212 := v211.FindInternedVar(lang.NewSymbol("list")) - if v212.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v212))) - } - v213 := v212.Get() - v214 := lang.Apply(v213, []any{lang.NewSymbol("glojure.core/and")}) - v215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v216 := v215.FindInternedVar(lang.NewSymbol("list")) - if v216.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v216))) - } - v217 := v216.Get() - v218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v219 := v218.FindInternedVar(lang.NewSymbol("seq")) - if v219.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v219))) - } - v220 := v219.Get() - v221 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v222 := v221.FindInternedVar(lang.NewSymbol("concat")) - if v222.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v222))) - } - v223 := v222.Get() - v224 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v225 := v224.FindInternedVar(lang.NewSymbol("list")) - if v225.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v225))) - } - v226 := v225.Get() - v227 := lang.Apply(v226, []any{lang.NewSymbol(".HasRoot")}) - v228 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v229 := v228.FindInternedVar(lang.NewSymbol("list")) - if v229.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v229))) - } - v230 := v229.Get() - v231 := lang.Apply(v230, []any{lang.NewSymbol("v__0__auto__")}) - v232 := lang.Apply(v223, []any{v227, v231}) - v233 := lang.Apply(v220, []any{v232}) - v234 := lang.Apply(v217, []any{v233}) - v235 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v236 := v235.FindInternedVar(lang.NewSymbol("list")) - if v236.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v236))) - } - v237 := v236.Get() - v238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v239 := v238.FindInternedVar(lang.NewSymbol("seq")) - if v239.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v239))) - } - v240 := v239.Get() - v241 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v242 := v241.FindInternedVar(lang.NewSymbol("concat")) - if v242.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v242))) - } - v243 := v242.Get() - v244 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v245 := v244.FindInternedVar(lang.NewSymbol("list")) - if v245.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v245))) - } - v246 := v245.Get() - v247 := lang.Apply(v246, []any{lang.NewSymbol("glojure.core/instance?")}) - v248 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v249 := v248.FindInternedVar(lang.NewSymbol("list")) - if v249.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v249))) - } - v250 := v249.Get() - v251 := lang.Apply(v250, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.*MultiFn")}) - v252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v253 := v252.FindInternedVar(lang.NewSymbol("list")) - if v253.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v253))) - } - v254 := v253.Get() - v255 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v256 := v255.FindInternedVar(lang.NewSymbol("seq")) - if v256.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v256))) - } - v257 := v256.Get() - v258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v259 := v258.FindInternedVar(lang.NewSymbol("concat")) - if v259.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v259))) - } - v260 := v259.Get() - v261 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v262 := v261.FindInternedVar(lang.NewSymbol("list")) - if v262.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v262))) - } - v263 := v262.Get() - v264 := lang.Apply(v263, []any{lang.NewSymbol("glojure.core/deref")}) - v265 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v266 := v265.FindInternedVar(lang.NewSymbol("list")) - if v266.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v266))) - } - v267 := v266.Get() - v268 := lang.Apply(v267, []any{lang.NewSymbol("v__0__auto__")}) - v269 := lang.Apply(v260, []any{v264, v268}) - v270 := lang.Apply(v257, []any{v269}) - v271 := lang.Apply(v254, []any{v270}) - v272 := lang.Apply(v243, []any{v247, v251, v271}) - v273 := lang.Apply(v240, []any{v272}) - v274 := lang.Apply(v237, []any{v273}) - v275 := lang.Apply(v210, []any{v214, v234, v274}) - v276 := lang.Apply(v207, []any{v275}) - v277 := lang.Apply(v204, []any{v276}) - v278 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v279 := v278.FindInternedVar(lang.NewSymbol("list")) - if v279.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v279))) - } - v280 := v279.Get() - v281 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v282 := v281.FindInternedVar(lang.NewSymbol("seq")) - if v282.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v282))) - } - v283 := v282.Get() - v284 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v285 := v284.FindInternedVar(lang.NewSymbol("concat")) - if v285.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v285))) - } - v286 := v285.Get() - v287 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v288 := v287.FindInternedVar(lang.NewSymbol("list")) - if v288.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v288))) - } - v289 := v288.Get() - v290 := lang.Apply(v289, []any{lang.NewSymbol("def")}) - v291 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v292 := v291.FindInternedVar(lang.NewSymbol("list")) - if v292.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v292))) - } - v293 := v292.Get() - v294 := lang.Apply(v293, []any{v101}) - v295 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v296 := v295.FindInternedVar(lang.NewSymbol("list")) - if v296.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v296))) - } - v297 := v296.Get() - v298 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v299 := v298.FindInternedVar(lang.NewSymbol("seq")) - if v299.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v299))) - } - v300 := v299.Get() - v301 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v302 := v301.FindInternedVar(lang.NewSymbol("concat")) - if v302.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v302))) - } - v303 := v302.Get() - v304 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v305 := v304.FindInternedVar(lang.NewSymbol("list")) - if v305.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v305))) - } - v306 := v305.Get() - v307 := lang.Apply(v306, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewMultiFn")}) - v308 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v309 := v308.FindInternedVar(lang.NewSymbol("list")) - if v309.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v309))) - } - v310 := v309.Get() - v311 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v312 := v311.FindInternedVar(lang.NewSymbol("name")) - if v312.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v312))) - } - v313 := v312.Get() - v314 := lang.Apply(v313, []any{v101}) - v315 := lang.Apply(v310, []any{v314}) - v316 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v317 := v316.FindInternedVar(lang.NewSymbol("list")) - if v317.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v317))) - } - v318 := v317.Get() - v319 := lang.Apply(v318, []any{v71}) - v320 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v321 := v320.FindInternedVar(lang.NewSymbol("list")) - if v321.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v321))) - } - v322 := v321.Get() - v323 := lang.Apply(v322, []any{v125}) - v324 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v325 := v324.FindInternedVar(lang.NewSymbol("list")) - if v325.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v325))) - } - v326 := v325.Get() - v327 := lang.Apply(v326, []any{v131}) - v328 := lang.Apply(v303, []any{v307, v315, v319, v323, v327}) - v329 := lang.Apply(v300, []any{v328}) - v330 := lang.Apply(v297, []any{v329}) - v331 := lang.Apply(v286, []any{v290, v294, v330}) - v332 := lang.Apply(v283, []any{v331}) - v333 := lang.Apply(v280, []any{v332}) - v334 := lang.Apply(v197, []any{v201, v277, v333}) - v335 := lang.Apply(v194, []any{v334}) - v336 := lang.Apply(v191, []any{v335}) - v337 := lang.Apply(v141, []any{v145, v188, v336}) - v338 := lang.Apply(v138, []any{v337}) - v112 = v338 + tmp132 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp133 := tmp132.FindInternedVar(lang.NewSymbol("check-valid-options")) + if tmp133.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp133))) + } + tmp134 := tmp133.Get() + tmp135 := lang.Apply(tmp134, []any{v120, lang.NewKeyword("default"), lang.NewKeyword("hierarchy")}) + _ = tmp135 + tmp136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp137 := tmp136.FindInternedVar(lang.NewSymbol("seq")) + if tmp137.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp137))) + } + tmp138 := tmp137.Get() + tmp139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp140 := tmp139.FindInternedVar(lang.NewSymbol("concat")) + if tmp140.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp140))) + } + tmp141 := tmp140.Get() + tmp142 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp143 := tmp142.FindInternedVar(lang.NewSymbol("list")) + if tmp143.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp143))) + } + tmp144 := tmp143.Get() + tmp145 := lang.Apply(tmp144, []any{lang.NewSymbol("glojure.core/let")}) + tmp146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp147 := tmp146.FindInternedVar(lang.NewSymbol("list")) + if tmp147.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp147))) + } + tmp148 := tmp147.Get() + tmp149 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp150 := tmp149.FindInternedVar(lang.NewSymbol("apply")) + if tmp150.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp150))) + } + tmp151 := tmp150.Get() + tmp152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp153 := tmp152.FindInternedVar(lang.NewSymbol("vector")) + if tmp153.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp153))) + } + tmp154 := tmp153.Get() + tmp155 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp156 := tmp155.FindInternedVar(lang.NewSymbol("seq")) + if tmp156.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp156))) + } + tmp157 := tmp156.Get() + tmp158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp159 := tmp158.FindInternedVar(lang.NewSymbol("concat")) + if tmp159.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp159))) + } + tmp160 := tmp159.Get() + tmp161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp162 := tmp161.FindInternedVar(lang.NewSymbol("list")) + if tmp162.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp162))) + } + tmp163 := tmp162.Get() + tmp164 := lang.Apply(tmp163, []any{lang.NewSymbol("v__0__auto__")}) + tmp165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp166 := tmp165.FindInternedVar(lang.NewSymbol("list")) + if tmp166.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp166))) + } + tmp167 := tmp166.Get() + tmp168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp169 := tmp168.FindInternedVar(lang.NewSymbol("seq")) + if tmp169.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp169))) + } + tmp170 := tmp169.Get() + tmp171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp172 := tmp171.FindInternedVar(lang.NewSymbol("concat")) + if tmp172.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp172))) + } + tmp173 := tmp172.Get() + tmp174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp175 := tmp174.FindInternedVar(lang.NewSymbol("list")) + if tmp175.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp175))) + } + tmp176 := tmp175.Get() + tmp177 := lang.Apply(tmp176, []any{lang.NewSymbol("def")}) + tmp178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp179 := tmp178.FindInternedVar(lang.NewSymbol("list")) + if tmp179.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp179))) + } + tmp180 := tmp179.Get() + tmp181 := lang.Apply(tmp180, []any{v101}) + tmp182 := lang.Apply(tmp173, []any{tmp177, tmp181}) + tmp183 := lang.Apply(tmp170, []any{tmp182}) + tmp184 := lang.Apply(tmp167, []any{tmp183}) + tmp185 := lang.Apply(tmp160, []any{tmp164, tmp184}) + tmp186 := lang.Apply(tmp157, []any{tmp185}) + tmp187 := lang.Apply(tmp151, []any{tmp154, tmp186}) + tmp188 := lang.Apply(tmp148, []any{tmp187}) + tmp189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp190 := tmp189.FindInternedVar(lang.NewSymbol("list")) + if tmp190.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp190))) + } + tmp191 := tmp190.Get() + tmp192 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp193 := tmp192.FindInternedVar(lang.NewSymbol("seq")) + if tmp193.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp193))) + } + tmp194 := tmp193.Get() + tmp195 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp196 := tmp195.FindInternedVar(lang.NewSymbol("concat")) + if tmp196.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp196))) + } + tmp197 := tmp196.Get() + tmp198 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp199 := tmp198.FindInternedVar(lang.NewSymbol("list")) + if tmp199.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp199))) + } + tmp200 := tmp199.Get() + tmp201 := lang.Apply(tmp200, []any{lang.NewSymbol("glojure.core/when-not")}) + tmp202 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp203 := tmp202.FindInternedVar(lang.NewSymbol("list")) + if tmp203.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp203))) + } + tmp204 := tmp203.Get() + tmp205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp206 := tmp205.FindInternedVar(lang.NewSymbol("seq")) + if tmp206.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp206))) + } + tmp207 := tmp206.Get() + tmp208 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp209 := tmp208.FindInternedVar(lang.NewSymbol("concat")) + if tmp209.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp209))) + } + tmp210 := tmp209.Get() + tmp211 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp212 := tmp211.FindInternedVar(lang.NewSymbol("list")) + if tmp212.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp212))) + } + tmp213 := tmp212.Get() + tmp214 := lang.Apply(tmp213, []any{lang.NewSymbol("glojure.core/and")}) + tmp215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp216 := tmp215.FindInternedVar(lang.NewSymbol("list")) + if tmp216.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp216))) + } + tmp217 := tmp216.Get() + tmp218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp219 := tmp218.FindInternedVar(lang.NewSymbol("seq")) + if tmp219.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp219))) + } + tmp220 := tmp219.Get() + tmp221 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp222 := tmp221.FindInternedVar(lang.NewSymbol("concat")) + if tmp222.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp222))) + } + tmp223 := tmp222.Get() + tmp224 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp225 := tmp224.FindInternedVar(lang.NewSymbol("list")) + if tmp225.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp225))) + } + tmp226 := tmp225.Get() + tmp227 := lang.Apply(tmp226, []any{lang.NewSymbol(".HasRoot")}) + tmp228 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp229 := tmp228.FindInternedVar(lang.NewSymbol("list")) + if tmp229.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp229))) + } + tmp230 := tmp229.Get() + tmp231 := lang.Apply(tmp230, []any{lang.NewSymbol("v__0__auto__")}) + tmp232 := lang.Apply(tmp223, []any{tmp227, tmp231}) + tmp233 := lang.Apply(tmp220, []any{tmp232}) + tmp234 := lang.Apply(tmp217, []any{tmp233}) + tmp235 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp236 := tmp235.FindInternedVar(lang.NewSymbol("list")) + if tmp236.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp236))) + } + tmp237 := tmp236.Get() + tmp238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp239 := tmp238.FindInternedVar(lang.NewSymbol("seq")) + if tmp239.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp239))) + } + tmp240 := tmp239.Get() + tmp241 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp242 := tmp241.FindInternedVar(lang.NewSymbol("concat")) + if tmp242.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp242))) + } + tmp243 := tmp242.Get() + tmp244 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp245 := tmp244.FindInternedVar(lang.NewSymbol("list")) + if tmp245.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp245))) + } + tmp246 := tmp245.Get() + tmp247 := lang.Apply(tmp246, []any{lang.NewSymbol("glojure.core/instance?")}) + tmp248 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp249 := tmp248.FindInternedVar(lang.NewSymbol("list")) + if tmp249.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp249))) + } + tmp250 := tmp249.Get() + tmp251 := lang.Apply(tmp250, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.*MultiFn")}) + tmp252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp253 := tmp252.FindInternedVar(lang.NewSymbol("list")) + if tmp253.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp253))) + } + tmp254 := tmp253.Get() + tmp255 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp256 := tmp255.FindInternedVar(lang.NewSymbol("seq")) + if tmp256.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp256))) + } + tmp257 := tmp256.Get() + tmp258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp259 := tmp258.FindInternedVar(lang.NewSymbol("concat")) + if tmp259.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp259))) + } + tmp260 := tmp259.Get() + tmp261 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp262 := tmp261.FindInternedVar(lang.NewSymbol("list")) + if tmp262.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp262))) + } + tmp263 := tmp262.Get() + tmp264 := lang.Apply(tmp263, []any{lang.NewSymbol("glojure.core/deref")}) + tmp265 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp266 := tmp265.FindInternedVar(lang.NewSymbol("list")) + if tmp266.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp266))) + } + tmp267 := tmp266.Get() + tmp268 := lang.Apply(tmp267, []any{lang.NewSymbol("v__0__auto__")}) + tmp269 := lang.Apply(tmp260, []any{tmp264, tmp268}) + tmp270 := lang.Apply(tmp257, []any{tmp269}) + tmp271 := lang.Apply(tmp254, []any{tmp270}) + tmp272 := lang.Apply(tmp243, []any{tmp247, tmp251, tmp271}) + tmp273 := lang.Apply(tmp240, []any{tmp272}) + tmp274 := lang.Apply(tmp237, []any{tmp273}) + tmp275 := lang.Apply(tmp210, []any{tmp214, tmp234, tmp274}) + tmp276 := lang.Apply(tmp207, []any{tmp275}) + tmp277 := lang.Apply(tmp204, []any{tmp276}) + tmp278 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp279 := tmp278.FindInternedVar(lang.NewSymbol("list")) + if tmp279.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp279))) + } + tmp280 := tmp279.Get() + tmp281 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp282 := tmp281.FindInternedVar(lang.NewSymbol("seq")) + if tmp282.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp282))) + } + tmp283 := tmp282.Get() + tmp284 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp285 := tmp284.FindInternedVar(lang.NewSymbol("concat")) + if tmp285.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp285))) + } + tmp286 := tmp285.Get() + tmp287 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp288 := tmp287.FindInternedVar(lang.NewSymbol("list")) + if tmp288.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp288))) + } + tmp289 := tmp288.Get() + tmp290 := lang.Apply(tmp289, []any{lang.NewSymbol("def")}) + tmp291 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp292 := tmp291.FindInternedVar(lang.NewSymbol("list")) + if tmp292.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp292))) + } + tmp293 := tmp292.Get() + tmp294 := lang.Apply(tmp293, []any{v101}) + tmp295 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp296 := tmp295.FindInternedVar(lang.NewSymbol("list")) + if tmp296.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp296))) + } + tmp297 := tmp296.Get() + tmp298 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp299 := tmp298.FindInternedVar(lang.NewSymbol("seq")) + if tmp299.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp299))) + } + tmp300 := tmp299.Get() + tmp301 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp302 := tmp301.FindInternedVar(lang.NewSymbol("concat")) + if tmp302.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp302))) + } + tmp303 := tmp302.Get() + tmp304 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp305 := tmp304.FindInternedVar(lang.NewSymbol("list")) + if tmp305.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp305))) + } + tmp306 := tmp305.Get() + tmp307 := lang.Apply(tmp306, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewMultiFn")}) + tmp308 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp309 := tmp308.FindInternedVar(lang.NewSymbol("list")) + if tmp309.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp309))) + } + tmp310 := tmp309.Get() + tmp311 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp312 := tmp311.FindInternedVar(lang.NewSymbol("name")) + if tmp312.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp312))) + } + tmp313 := tmp312.Get() + tmp314 := lang.Apply(tmp313, []any{v101}) + tmp315 := lang.Apply(tmp310, []any{tmp314}) + tmp316 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp317 := tmp316.FindInternedVar(lang.NewSymbol("list")) + if tmp317.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp317))) + } + tmp318 := tmp317.Get() + tmp319 := lang.Apply(tmp318, []any{v71}) + tmp320 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp321 := tmp320.FindInternedVar(lang.NewSymbol("list")) + if tmp321.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp321))) + } + tmp322 := tmp321.Get() + tmp323 := lang.Apply(tmp322, []any{v125}) + tmp324 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp325 := tmp324.FindInternedVar(lang.NewSymbol("list")) + if tmp325.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp325))) + } + tmp326 := tmp325.Get() + tmp327 := lang.Apply(tmp326, []any{v131}) + tmp328 := lang.Apply(tmp303, []any{tmp307, tmp315, tmp319, tmp323, tmp327}) + tmp329 := lang.Apply(tmp300, []any{tmp328}) + tmp330 := lang.Apply(tmp297, []any{tmp329}) + tmp331 := lang.Apply(tmp286, []any{tmp290, tmp294, tmp330}) + tmp332 := lang.Apply(tmp283, []any{tmp331}) + tmp333 := lang.Apply(tmp280, []any{tmp332}) + tmp334 := lang.Apply(tmp197, []any{tmp201, tmp277, tmp333}) + tmp335 := lang.Apply(tmp194, []any{tmp334}) + tmp336 := lang.Apply(tmp191, []any{tmp335}) + tmp337 := lang.Apply(tmp141, []any{tmp145, tmp188, tmp336}) + tmp338 := lang.Apply(tmp138, []any{tmp337}) + tmp112 = tmp338 } // end let - v7 = v112 + tmp7 = tmp112 } // end let - return v7 + return tmp7 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // defn { - v0 := lang.NewSymbol("defn").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("doc-string?"), lang.NewSymbol("attr-map?"), lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("prepost-map?"), lang.NewSymbol("body")), lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("doc-string?"), lang.NewSymbol("attr-map?"), lang.NewList(lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("prepost-map?"), lang.NewSymbol("body")), lang.NewSymbol("+"), lang.NewSymbol("attr-map?"))), lang.NewKeyword("doc"), "Same as (def name (fn [params* ] exprs*)) or (def\n name (fn ([params* ] exprs*)+)) with any doc-string or attrs added\n to the var metadata. prepost-map defines a map with optional keys\n :pre and :post that contain collections of pre or post conditions.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(284), lang.NewKeyword("end-line"), int(291))).(*lang.Symbol) - var v2 lang.FnFunc + tmp0 := lang.NewSymbol("defn").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("doc-string?"), lang.NewSymbol("attr-map?"), lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("prepost-map?"), lang.NewSymbol("body")), lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("doc-string?"), lang.NewSymbol("attr-map?"), lang.NewList(lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("prepost-map?"), lang.NewSymbol("body")), lang.NewSymbol("+"), lang.NewSymbol("attr-map?"))), lang.NewKeyword("doc"), "Same as (def name (fn [params* ] exprs*)) or (def\n name (fn ([params* ] exprs*)+)) with any doc-string or attrs added\n to the var metadata. prepost-map defines a map with optional keys\n :pre and :post that contain collections of pre or post conditions.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(284), lang.NewKeyword("end-line"), int(291))).(*lang.Symbol) + var tmp2 lang.FnFunc { // function defn - v2 = lang.NewFnFunc(func(args ...any) any { + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 3 { @@ -23050,478 +23147,479 @@ func init() { _ = v5 v6 := args[2] _ = v6 - v7 := lang.NewList(args[3:]...) - var v8 any - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("instance?")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.Apply(v11, []any{*lang.Symbol, v6}) - if lang.IsTruthy(v12) { - v8 = nil + var v7 any = lang.NewList(args[3:]...) + _ = v7 + var tmp8 any + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("instance?")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := reflect.TypeOf((*lang.Symbol)(nil)) + tmp13 := lang.Apply(tmp11, []any{tmp12, v6}) + if lang.IsTruthy(tmp13) { } else { - v13 := lang.Apply(lang.NewIllegalArgumentError, []any{"First argument to defn must be a symbol"}) - panic(v13) + tmp14 := lang.Apply(lang.NewIllegalArgumentError, []any{"First argument to defn must be a symbol"}) + panic(tmp14) } - _ = v8 - var v14 any + _ = tmp8 + var tmp15 any { // let // let binding "m" - var v15 any - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("string?")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("first")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{v7}) - v23 := lang.Apply(v18, []any{v22}) - if lang.IsTruthy(v23) { - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("first")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.Apply(v26, []any{v7}) - v28 := lang.NewMap(lang.NewKeyword("doc"), v27) - v29 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(297), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(297), lang.NewKeyword("end-column"), int(38)) - v30, err := lang.WithMeta(v28, v29.(lang.IPersistentMap)) + var tmp16 any + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("string?")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("first")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.Apply(tmp22, []any{v7}) + tmp24 := lang.Apply(tmp19, []any{tmp23}) + if lang.IsTruthy(tmp24) { + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("first")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.Apply(tmp27, []any{v7}) + tmp29 := lang.NewMap(lang.NewKeyword("doc"), tmp28) + tmp30 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(297), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(297), lang.NewKeyword("end-column"), int(38)) + tmp31, err := lang.WithMeta(tmp29, tmp30.(lang.IPersistentMap)) if err != nil { panic(err) } - v15 = v30 + tmp16 = tmp31 } else { - v31 := lang.NewMap() - v32 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(298), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(298), lang.NewKeyword("end-column"), int(20)) - v33, err := lang.WithMeta(v31, v32.(lang.IPersistentMap)) + tmp32 := lang.NewMap() + tmp33 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(298), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(298), lang.NewKeyword("end-column"), int(20)) + tmp34, err := lang.WithMeta(tmp32, tmp33.(lang.IPersistentMap)) if err != nil { panic(err) } - v15 = v33 + tmp16 = tmp34 } - var v34 any = v15 - _ = v34 + var v35 any = tmp16 + _ = v35 // let binding "fdecl" - var v35 any - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("string?")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v40 := v39.FindInternedVar(lang.NewSymbol("first")) - if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) - } - v41 := v40.Get() - v42 := lang.Apply(v41, []any{v7}) - v43 := lang.Apply(v38, []any{v42}) - if lang.IsTruthy(v43) { - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("next")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) - } - v46 := v45.Get() - v47 := lang.Apply(v46, []any{v7}) - v35 = v47 + var tmp36 any + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("string?")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("first")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) + } + tmp42 := tmp41.Get() + tmp43 := lang.Apply(tmp42, []any{v7}) + tmp44 := lang.Apply(tmp39, []any{tmp43}) + if lang.IsTruthy(tmp44) { + tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp46 := tmp45.FindInternedVar(lang.NewSymbol("next")) + if tmp46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) + } + tmp47 := tmp46.Get() + tmp48 := lang.Apply(tmp47, []any{v7}) + tmp36 = tmp48 } else { - v35 = v7 + tmp36 = v7 } - var v48 any = v35 - _ = v48 + var v49 any = tmp36 + _ = v49 // let binding "m" - var v49 any - v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v51 := v50.FindInternedVar(lang.NewSymbol("map?")) - if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) - } - v52 := v51.Get() - v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v54 := v53.FindInternedVar(lang.NewSymbol("first")) - if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) - } - v55 := v54.Get() - v56 := lang.Apply(v55, []any{v48}) - v57 := lang.Apply(v52, []any{v56}) - if lang.IsTruthy(v57) { - v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v59 := v58.FindInternedVar(lang.NewSymbol("conj")) - if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) - } - v60 := v59.Get() - v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v62 := v61.FindInternedVar(lang.NewSymbol("first")) - if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) - } - v63 := v62.Get() - v64 := lang.Apply(v63, []any{v48}) - v65 := lang.Apply(v60, []any{v34, v64}) - v49 = v65 + var tmp50 any + tmp51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp52 := tmp51.FindInternedVar(lang.NewSymbol("map?")) + if tmp52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp52))) + } + tmp53 := tmp52.Get() + tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp55 := tmp54.FindInternedVar(lang.NewSymbol("first")) + if tmp55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) + } + tmp56 := tmp55.Get() + tmp57 := lang.Apply(tmp56, []any{v49}) + tmp58 := lang.Apply(tmp53, []any{tmp57}) + if lang.IsTruthy(tmp58) { + tmp59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp60 := tmp59.FindInternedVar(lang.NewSymbol("conj")) + if tmp60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp60))) + } + tmp61 := tmp60.Get() + tmp62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp63 := tmp62.FindInternedVar(lang.NewSymbol("first")) + if tmp63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp63))) + } + tmp64 := tmp63.Get() + tmp65 := lang.Apply(tmp64, []any{v49}) + tmp66 := lang.Apply(tmp61, []any{v35, tmp65}) + tmp50 = tmp66 } else { - v49 = v34 + tmp50 = v35 } - var v66 any = v49 - _ = v66 + var v67 any = tmp50 + _ = v67 // let binding "fdecl" - var v67 any - v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v69 := v68.FindInternedVar(lang.NewSymbol("map?")) - if v69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) - } - v70 := v69.Get() - v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v72 := v71.FindInternedVar(lang.NewSymbol("first")) - if v72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) - } - v73 := v72.Get() - v74 := lang.Apply(v73, []any{v48}) - v75 := lang.Apply(v70, []any{v74}) - if lang.IsTruthy(v75) { - v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v77 := v76.FindInternedVar(lang.NewSymbol("next")) - if v77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) - } - v78 := v77.Get() - v79 := lang.Apply(v78, []any{v48}) - v67 = v79 + var tmp68 any + tmp69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp70 := tmp69.FindInternedVar(lang.NewSymbol("map?")) + if tmp70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp70))) + } + tmp71 := tmp70.Get() + tmp72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp73 := tmp72.FindInternedVar(lang.NewSymbol("first")) + if tmp73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp73))) + } + tmp74 := tmp73.Get() + tmp75 := lang.Apply(tmp74, []any{v49}) + tmp76 := lang.Apply(tmp71, []any{tmp75}) + if lang.IsTruthy(tmp76) { + tmp77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp78 := tmp77.FindInternedVar(lang.NewSymbol("next")) + if tmp78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp78))) + } + tmp79 := tmp78.Get() + tmp80 := lang.Apply(tmp79, []any{v49}) + tmp68 = tmp80 } else { - v67 = v48 + tmp68 = v49 } - var v80 any = v67 - _ = v80 + var v81 any = tmp68 + _ = v81 // let binding "fdecl" - var v81 any - v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v83 := v82.FindInternedVar(lang.NewSymbol("vector?")) - if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) - } - v84 := v83.Get() - v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v86 := v85.FindInternedVar(lang.NewSymbol("first")) - if v86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) - } - v87 := v86.Get() - v88 := lang.Apply(v87, []any{v80}) - v89 := lang.Apply(v84, []any{v88}) - if lang.IsTruthy(v89) { - v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v91 := v90.FindInternedVar(lang.NewSymbol("list")) - if v91.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) - } - v92 := v91.Get() - v93 := lang.Apply(v92, []any{v80}) - v81 = v93 + var tmp82 any + tmp83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp84 := tmp83.FindInternedVar(lang.NewSymbol("vector?")) + if tmp84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp84))) + } + tmp85 := tmp84.Get() + tmp86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp87 := tmp86.FindInternedVar(lang.NewSymbol("first")) + if tmp87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp87))) + } + tmp88 := tmp87.Get() + tmp89 := lang.Apply(tmp88, []any{v81}) + tmp90 := lang.Apply(tmp85, []any{tmp89}) + if lang.IsTruthy(tmp90) { + tmp91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp92 := tmp91.FindInternedVar(lang.NewSymbol("list")) + if tmp92.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp92))) + } + tmp93 := tmp92.Get() + tmp94 := lang.Apply(tmp93, []any{v81}) + tmp82 = tmp94 } else { - v81 = v80 + tmp82 = v81 } - var v94 any = v81 - _ = v94 + var v95 any = tmp82 + _ = v95 // let binding "m" - var v95 any - v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v97 := v96.FindInternedVar(lang.NewSymbol("map?")) - if v97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) - } - v98 := v97.Get() - v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v100 := v99.FindInternedVar(lang.NewSymbol("last")) - if v100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) - } - v101 := v100.Get() - v102 := lang.Apply(v101, []any{v94}) - v103 := lang.Apply(v98, []any{v102}) - if lang.IsTruthy(v103) { - v104 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v105 := v104.FindInternedVar(lang.NewSymbol("conj")) - if v105.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v105))) - } - v106 := v105.Get() - v107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v108 := v107.FindInternedVar(lang.NewSymbol("last")) - if v108.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v108))) - } - v109 := v108.Get() - v110 := lang.Apply(v109, []any{v94}) - v111 := lang.Apply(v106, []any{v66, v110}) - v95 = v111 + var tmp96 any + tmp97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp98 := tmp97.FindInternedVar(lang.NewSymbol("map?")) + if tmp98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp98))) + } + tmp99 := tmp98.Get() + tmp100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp101 := tmp100.FindInternedVar(lang.NewSymbol("last")) + if tmp101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp101))) + } + tmp102 := tmp101.Get() + tmp103 := lang.Apply(tmp102, []any{v95}) + tmp104 := lang.Apply(tmp99, []any{tmp103}) + if lang.IsTruthy(tmp104) { + tmp105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp106 := tmp105.FindInternedVar(lang.NewSymbol("conj")) + if tmp106.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp106))) + } + tmp107 := tmp106.Get() + tmp108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp109 := tmp108.FindInternedVar(lang.NewSymbol("last")) + if tmp109.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp109))) + } + tmp110 := tmp109.Get() + tmp111 := lang.Apply(tmp110, []any{v95}) + tmp112 := lang.Apply(tmp107, []any{v67, tmp111}) + tmp96 = tmp112 } else { - v95 = v66 + tmp96 = v67 } - var v112 any = v95 - _ = v112 + var v113 any = tmp96 + _ = v113 // let binding "fdecl" - var v113 any - v114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v115 := v114.FindInternedVar(lang.NewSymbol("map?")) - if v115.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v115))) - } - v116 := v115.Get() - v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v118 := v117.FindInternedVar(lang.NewSymbol("last")) - if v118.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) - } - v119 := v118.Get() - v120 := lang.Apply(v119, []any{v94}) - v121 := lang.Apply(v116, []any{v120}) - if lang.IsTruthy(v121) { - v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v123 := v122.FindInternedVar(lang.NewSymbol("butlast")) - if v123.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) - } - v124 := v123.Get() - v125 := lang.Apply(v124, []any{v94}) - v113 = v125 + var tmp114 any + tmp115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp116 := tmp115.FindInternedVar(lang.NewSymbol("map?")) + if tmp116.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp116))) + } + tmp117 := tmp116.Get() + tmp118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp119 := tmp118.FindInternedVar(lang.NewSymbol("last")) + if tmp119.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp119))) + } + tmp120 := tmp119.Get() + tmp121 := lang.Apply(tmp120, []any{v95}) + tmp122 := lang.Apply(tmp117, []any{tmp121}) + if lang.IsTruthy(tmp122) { + tmp123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp124 := tmp123.FindInternedVar(lang.NewSymbol("butlast")) + if tmp124.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp124))) + } + tmp125 := tmp124.Get() + tmp126 := lang.Apply(tmp125, []any{v95}) + tmp114 = tmp126 } else { - v113 = v94 + tmp114 = v95 } - var v126 any = v113 - _ = v126 + var v127 any = tmp114 + _ = v127 // let binding "m" - v127 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v128 := v127.FindInternedVar(lang.NewSymbol("conj")) - if v128.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v128))) - } - v129 := v128.Get() - v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v131 := v130.FindInternedVar(lang.NewSymbol("list")) - if v131.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) - } - v132 := v131.Get() - v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v134 := v133.FindInternedVar(lang.NewSymbol("sigs")) - if v134.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) - } - v135 := v134.Get() - v136 := lang.Apply(v135, []any{v126}) - v137 := lang.Apply(v132, []any{lang.NewSymbol("quote"), v136}) - v138 := lang.NewMap(lang.NewKeyword("arglists"), v137) - v139 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(317), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(317), lang.NewKeyword("end-column"), int(60)) - v140, err := lang.WithMeta(v138, v139.(lang.IPersistentMap)) + tmp128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp129 := tmp128.FindInternedVar(lang.NewSymbol("conj")) + if tmp129.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp129))) + } + tmp130 := tmp129.Get() + tmp131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp132 := tmp131.FindInternedVar(lang.NewSymbol("list")) + if tmp132.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp132))) + } + tmp133 := tmp132.Get() + tmp134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp135 := tmp134.FindInternedVar(lang.NewSymbol("sigs")) + if tmp135.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp135))) + } + tmp136 := tmp135.Get() + tmp137 := lang.Apply(tmp136, []any{v127}) + tmp138 := lang.Apply(tmp133, []any{lang.NewSymbol("quote"), tmp137}) + tmp139 := lang.NewMap(lang.NewKeyword("arglists"), tmp138) + tmp140 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(317), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(317), lang.NewKeyword("end-column"), int(60)) + tmp141, err := lang.WithMeta(tmp139, tmp140.(lang.IPersistentMap)) if err != nil { panic(err) } - v141 := lang.Apply(v129, []any{v140, v112}) - var v142 any = v141 - _ = v142 + tmp142 := lang.Apply(tmp130, []any{tmp141, v113}) + var v143 any = tmp142 + _ = v143 // let binding "m" - var v143 any + var tmp144 any { // let // let binding "inline" - v144 := lang.Apply(lang.NewKeyword("inline"), []any{v142}) - var v145 any = v144 - _ = v145 + tmp145 := lang.Apply(lang.NewKeyword("inline"), []any{v143}) + var v146 any = tmp145 + _ = v146 // let binding "ifn" - v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v147 := v146.FindInternedVar(lang.NewSymbol("first")) - if v147.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) - } - v148 := v147.Get() - v149 := lang.Apply(v148, []any{v145}) - var v150 any = v149 - _ = v150 + tmp147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp148 := tmp147.FindInternedVar(lang.NewSymbol("first")) + if tmp148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp148))) + } + tmp149 := tmp148.Get() + tmp150 := lang.Apply(tmp149, []any{v146}) + var v151 any = tmp150 + _ = v151 // let binding "iname" - v151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v152 := v151.FindInternedVar(lang.NewSymbol("second")) - if v152.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v152))) - } - v153 := v152.Get() - v154 := lang.Apply(v153, []any{v145}) - var v155 any = v154 - _ = v155 - var v156 any - var v157 any - v158 := lang.Apply(lang.Equiv, []any{lang.NewSymbol("fn"), v150}) - if lang.IsTruthy(v158) { - var v159 any - v160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v161 := v160.FindInternedVar(lang.NewSymbol("instance?")) - if v161.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v161))) + tmp152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp153 := tmp152.FindInternedVar(lang.NewSymbol("second")) + if tmp153.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp153))) + } + tmp154 := tmp153.Get() + tmp155 := lang.Apply(tmp154, []any{v146}) + var v156 any = tmp155 + _ = v156 + var tmp157 any + var tmp158 any + tmp159 := lang.Apply(lang.Equiv, []any{lang.NewSymbol("fn"), v151}) + if lang.IsTruthy(tmp159) { + var tmp160 any + tmp161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp162 := tmp161.FindInternedVar(lang.NewSymbol("instance?")) + if tmp162.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp162))) } - v162 := v161.Get() - v163 := lang.Apply(v162, []any{*lang.Symbol, v155}) - if lang.IsTruthy(v163) { - v159 = false + tmp163 := tmp162.Get() + tmp164 := reflect.TypeOf((*lang.Symbol)(nil)) + tmp165 := lang.Apply(tmp163, []any{tmp164, v156}) + if lang.IsTruthy(tmp165) { + tmp160 = false } else { - v159 = true + tmp160 = true } - v157 = v159 + tmp158 = tmp160 } else { - v157 = nil } - if lang.IsTruthy(v157) { - v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v165 := v164.FindInternedVar(lang.NewSymbol("assoc")) - if v165.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) + if lang.IsTruthy(tmp158) { + tmp166 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp167 := tmp166.FindInternedVar(lang.NewSymbol("assoc")) + if tmp167.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp167))) } - v166 := v165.Get() - v167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v168 := v167.FindInternedVar(lang.NewSymbol("cons")) - if v168.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v168))) + tmp168 := tmp167.Get() + tmp169 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp170 := tmp169.FindInternedVar(lang.NewSymbol("cons")) + if tmp170.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp170))) } - v169 := v168.Get() - v170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v171 := v170.FindInternedVar(lang.NewSymbol("cons")) - if v171.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v171))) + tmp171 := tmp170.Get() + tmp172 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp173 := tmp172.FindInternedVar(lang.NewSymbol("cons")) + if tmp173.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp173))) } - v172 := v171.Get() - v173, ok := lang.FieldOrMethod(v6, "Name") + tmp174 := tmp173.Get() + tmp175, ok := lang.FieldOrMethod(v6, "Name") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "Name"))) } - var v174 any - switch reflect.TypeOf(v173).Kind() { + var tmp176 any + switch reflect.TypeOf(tmp175).Kind() { case reflect.Func: - v174 = lang.Apply(v173, nil) + tmp176 = lang.Apply(tmp175, nil) default: - v174 = v173 + tmp176 = tmp175 } - v175 := lang.Apply(lang.ConcatStrings, []any{v174, "__inliner"}) - v176 := lang.Apply(lang.NewSymbol, []any{v175}) - v177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v178 := v177.FindInternedVar(lang.NewSymbol("next")) - if v178.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v178))) + tmp177 := lang.Apply(lang.ConcatStrings, []any{tmp176, "__inliner"}) + tmp178 := lang.Apply(lang.NewSymbol, []any{tmp177}) + tmp179 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp180 := tmp179.FindInternedVar(lang.NewSymbol("next")) + if tmp180.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp180))) } - v179 := v178.Get() - v180 := lang.Apply(v179, []any{v145}) - v181 := lang.Apply(v172, []any{v176, v180}) - v182 := lang.Apply(v169, []any{v150, v181}) - v183 := lang.Apply(v166, []any{v142, lang.NewKeyword("inline"), v182}) - v156 = v183 + tmp181 := tmp180.Get() + tmp182 := lang.Apply(tmp181, []any{v146}) + tmp183 := lang.Apply(tmp174, []any{tmp178, tmp182}) + tmp184 := lang.Apply(tmp171, []any{v151, tmp183}) + tmp185 := lang.Apply(tmp168, []any{v143, lang.NewKeyword("inline"), tmp184}) + tmp157 = tmp185 } else { - v156 = v142 + tmp157 = v143 } - v143 = v156 + tmp144 = tmp157 } // end let - var v144 any = v143 - _ = v144 + var v145 any = tmp144 + _ = v145 // let binding "m" - v145 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v146 := v145.FindInternedVar(lang.NewSymbol("conj")) - if v146.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v146))) - } - v147 := v146.Get() - var v148 any - v149 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v150 := v149.FindInternedVar(lang.NewSymbol("meta")) - if v150.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v150))) - } - v151 := v150.Get() - v152 := lang.Apply(v151, []any{v6}) - if lang.IsTruthy(v152) { - v153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v154 := v153.FindInternedVar(lang.NewSymbol("meta")) - if v154.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v154))) - } - v155 := v154.Get() - v156 := lang.Apply(v155, []any{v6}) - v148 = v156 + tmp146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp147 := tmp146.FindInternedVar(lang.NewSymbol("conj")) + if tmp147.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp147))) + } + tmp148 := tmp147.Get() + var tmp149 any + tmp150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp151 := tmp150.FindInternedVar(lang.NewSymbol("meta")) + if tmp151.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp151))) + } + tmp152 := tmp151.Get() + tmp153 := lang.Apply(tmp152, []any{v6}) + if lang.IsTruthy(tmp153) { + tmp154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp155 := tmp154.FindInternedVar(lang.NewSymbol("meta")) + if tmp155.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp155))) + } + tmp156 := tmp155.Get() + tmp157 := lang.Apply(tmp156, []any{v6}) + tmp149 = tmp157 } else { - v157 := lang.NewMap() - v158 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(328), lang.NewKeyword("column"), int(51), lang.NewKeyword("end-line"), int(328), lang.NewKeyword("end-column"), int(52)) - v159, err := lang.WithMeta(v157, v158.(lang.IPersistentMap)) + tmp158 := lang.NewMap() + tmp159 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(328), lang.NewKeyword("column"), int(51), lang.NewKeyword("end-line"), int(328), lang.NewKeyword("end-column"), int(52)) + tmp160, err := lang.WithMeta(tmp158, tmp159.(lang.IPersistentMap)) if err != nil { panic(err) } - v148 = v159 - } - v160 := lang.Apply(v147, []any{v148, v144}) - var v161 any = v160 - _ = v161 - v162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v163 := v162.FindInternedVar(lang.NewSymbol("list")) - if v163.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v163))) - } - v164 := v163.Get() - v165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v166 := v165.FindInternedVar(lang.NewSymbol("with-meta")) - if v166.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v166))) - } - v167 := v166.Get() - v168 := lang.Apply(v167, []any{v6, v161}) - v169 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v170 := v169.FindInternedVar(lang.NewSymbol("with-meta")) - if v170.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v170))) - } - v171 := v170.Get() - v172 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v173 := v172.FindInternedVar(lang.NewSymbol("cons")) - if v173.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v173))) - } - v174 := v173.Get() - v175 := lang.Apply(v174, []any{lang.NewSymbol("glojure.core/fn"), v126}) - v176 := lang.Apply(lang.NewKeyword("tag"), []any{v161}) - v177 := lang.NewMap(lang.NewKeyword("rettag"), v176) - v178 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(333), lang.NewKeyword("column"), int(37), lang.NewKeyword("end-line"), int(333), lang.NewKeyword("end-column"), int(54)) - v179, err := lang.WithMeta(v177, v178.(lang.IPersistentMap)) + tmp149 = tmp160 + } + tmp161 := lang.Apply(tmp148, []any{tmp149, v145}) + var v162 any = tmp161 + _ = v162 + tmp163 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp164 := tmp163.FindInternedVar(lang.NewSymbol("list")) + if tmp164.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp164))) + } + tmp165 := tmp164.Get() + tmp166 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp167 := tmp166.FindInternedVar(lang.NewSymbol("with-meta")) + if tmp167.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp167))) + } + tmp168 := tmp167.Get() + tmp169 := lang.Apply(tmp168, []any{v6, v162}) + tmp170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp171 := tmp170.FindInternedVar(lang.NewSymbol("with-meta")) + if tmp171.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp171))) + } + tmp172 := tmp171.Get() + tmp173 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp174 := tmp173.FindInternedVar(lang.NewSymbol("cons")) + if tmp174.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp174))) + } + tmp175 := tmp174.Get() + tmp176 := lang.Apply(tmp175, []any{lang.NewSymbol("glojure.core/fn"), v127}) + tmp177 := lang.Apply(lang.NewKeyword("tag"), []any{v162}) + tmp178 := lang.NewMap(lang.NewKeyword("rettag"), tmp177) + tmp179 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(333), lang.NewKeyword("column"), int(37), lang.NewKeyword("end-line"), int(333), lang.NewKeyword("end-column"), int(54)) + tmp180, err := lang.WithMeta(tmp178, tmp179.(lang.IPersistentMap)) if err != nil { panic(err) } - v180 := lang.Apply(v171, []any{v175, v179}) - v181 := lang.Apply(v164, []any{lang.NewSymbol("def"), v168, v180}) - v14 = v181 + tmp181 := lang.Apply(tmp172, []any{tmp176, tmp180}) + tmp182 := lang.Apply(tmp165, []any{lang.NewSymbol("def"), tmp169, tmp181}) + tmp15 = tmp182 } // end let - return v14 + return tmp15 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(291), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(333), lang.NewKeyword("end-column"), int(58))).(lang.FnFunc) - v3 := v2 + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(291), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(333), lang.NewKeyword("end-column"), int(58))).(lang.FnFunc) + v3 = tmp2 _ = v3 } - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // defn- { - v0 := lang.NewSymbol("defn-").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("decls"))), lang.NewKeyword("doc"), "same as defn, yielding non-public def", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4949), lang.NewKeyword("end-line"), int(4949))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("defn-").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("decls"))), lang.NewKeyword("doc"), "same as defn, yielding non-public def", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4949), lang.NewKeyword("end-line"), int(4949))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 3 { @@ -23533,49 +23631,50 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("list*")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("with-meta")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("assoc")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("meta")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{v5}) - v20 := lang.Apply(v15, []any{v19, lang.NewKeyword("private"), true}) - v21 := lang.Apply(v12, []any{v5, v20}) - v22 := lang.Apply(v9, []any{lang.NewSymbol("glojure.core/defn"), v21, v6}) - return v22 - } - }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("list*")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("with-meta")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("assoc")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("meta")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{v5}) + tmp20 := lang.Apply(tmp15, []any{tmp19, lang.NewKeyword("private"), true}) + tmp21 := lang.Apply(tmp12, []any{v5, tmp20}) + tmp22 := lang.Apply(tmp9, []any{lang.NewSymbol("glojure.core/defn"), tmp21, v6}) + return tmp22 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // defonce { - v0 := lang.NewSymbol("defonce").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("expr"))), lang.NewKeyword("doc"), "defs name to have the root value of the expr iff the named var has no root value,\n else expr is unevaluated", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5806), lang.NewKeyword("end-line"), int(5806))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("defonce").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("expr"))), lang.NewKeyword("doc"), "defs name to have the root value of the expr iff the named var has no root value,\n else expr is unevaluated", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5806), lang.NewKeyword("end-line"), int(5806))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 4 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -23587,221 +23686,221 @@ func init() { _ = v5 v6 := args[3] _ = v6 - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("seq")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("concat")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("list")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/let")}) - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("list")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("apply")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("vector")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("seq")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) - } - v28 := v27.Get() - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("concat")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("list")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{lang.NewSymbol("v__0__auto__")}) - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("list")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v40 := v39.FindInternedVar(lang.NewSymbol("seq")) - if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) - } - v41 := v40.Get() - v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v43 := v42.FindInternedVar(lang.NewSymbol("concat")) - if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) - } - v44 := v43.Get() - v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v46 := v45.FindInternedVar(lang.NewSymbol("list")) - if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) - } - v47 := v46.Get() - v48 := lang.Apply(v47, []any{lang.NewSymbol("def")}) - v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v50 := v49.FindInternedVar(lang.NewSymbol("list")) - if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) - } - v51 := v50.Get() - v52 := lang.Apply(v51, []any{v5}) - v53 := lang.Apply(v44, []any{v48, v52}) - v54 := lang.Apply(v41, []any{v53}) - v55 := lang.Apply(v38, []any{v54}) - v56 := lang.Apply(v31, []any{v35, v55}) - v57 := lang.Apply(v28, []any{v56}) - v58 := lang.Apply(v22, []any{v25, v57}) - v59 := lang.Apply(v19, []any{v58}) - v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v61 := v60.FindInternedVar(lang.NewSymbol("list")) - if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) - } - v62 := v61.Get() - v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v64 := v63.FindInternedVar(lang.NewSymbol("seq")) - if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) - } - v65 := v64.Get() - v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v67 := v66.FindInternedVar(lang.NewSymbol("concat")) - if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) - } - v68 := v67.Get() - v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v70 := v69.FindInternedVar(lang.NewSymbol("list")) - if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) - } - v71 := v70.Get() - v72 := lang.Apply(v71, []any{lang.NewSymbol("glojure.core/when-not")}) - v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v74 := v73.FindInternedVar(lang.NewSymbol("list")) - if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) - } - v75 := v74.Get() - v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v77 := v76.FindInternedVar(lang.NewSymbol("seq")) - if v77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) - } - v78 := v77.Get() - v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v80 := v79.FindInternedVar(lang.NewSymbol("concat")) - if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) - } - v81 := v80.Get() - v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v83 := v82.FindInternedVar(lang.NewSymbol("list")) - if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) - } - v84 := v83.Get() - v85 := lang.Apply(v84, []any{lang.NewSymbol(".HasRoot")}) - v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v87 := v86.FindInternedVar(lang.NewSymbol("list")) - if v87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) - } - v88 := v87.Get() - v89 := lang.Apply(v88, []any{lang.NewSymbol("v__0__auto__")}) - v90 := lang.Apply(v81, []any{v85, v89}) - v91 := lang.Apply(v78, []any{v90}) - v92 := lang.Apply(v75, []any{v91}) - v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v94 := v93.FindInternedVar(lang.NewSymbol("list")) - if v94.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) - } - v95 := v94.Get() - v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v97 := v96.FindInternedVar(lang.NewSymbol("seq")) - if v97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) - } - v98 := v97.Get() - v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v100 := v99.FindInternedVar(lang.NewSymbol("concat")) - if v100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) - } - v101 := v100.Get() - v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v103 := v102.FindInternedVar(lang.NewSymbol("list")) - if v103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) - } - v104 := v103.Get() - v105 := lang.Apply(v104, []any{lang.NewSymbol("def")}) - v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v107 := v106.FindInternedVar(lang.NewSymbol("list")) - if v107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) - } - v108 := v107.Get() - v109 := lang.Apply(v108, []any{v5}) - v110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v111 := v110.FindInternedVar(lang.NewSymbol("list")) - if v111.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v111))) - } - v112 := v111.Get() - v113 := lang.Apply(v112, []any{v6}) - v114 := lang.Apply(v101, []any{v105, v109, v113}) - v115 := lang.Apply(v98, []any{v114}) - v116 := lang.Apply(v95, []any{v115}) - v117 := lang.Apply(v68, []any{v72, v92, v116}) - v118 := lang.Apply(v65, []any{v117}) - v119 := lang.Apply(v62, []any{v118}) - v120 := lang.Apply(v12, []any{v16, v59, v119}) - v121 := lang.Apply(v9, []any{v120}) - return v121 - }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("seq")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("concat")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("list")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("glojure.core/let")}) + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("list")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("apply")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("vector")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("seq")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) + } + tmp28 := tmp27.Get() + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("concat")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.Apply(tmp34, []any{lang.NewSymbol("v__0__auto__")}) + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp40 := tmp39.FindInternedVar(lang.NewSymbol("seq")) + if tmp40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) + } + tmp41 := tmp40.Get() + tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp43 := tmp42.FindInternedVar(lang.NewSymbol("concat")) + if tmp43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) + } + tmp44 := tmp43.Get() + tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp46 := tmp45.FindInternedVar(lang.NewSymbol("list")) + if tmp46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) + } + tmp47 := tmp46.Get() + tmp48 := lang.Apply(tmp47, []any{lang.NewSymbol("def")}) + tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp50 := tmp49.FindInternedVar(lang.NewSymbol("list")) + if tmp50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) + } + tmp51 := tmp50.Get() + tmp52 := lang.Apply(tmp51, []any{v5}) + tmp53 := lang.Apply(tmp44, []any{tmp48, tmp52}) + tmp54 := lang.Apply(tmp41, []any{tmp53}) + tmp55 := lang.Apply(tmp38, []any{tmp54}) + tmp56 := lang.Apply(tmp31, []any{tmp35, tmp55}) + tmp57 := lang.Apply(tmp28, []any{tmp56}) + tmp58 := lang.Apply(tmp22, []any{tmp25, tmp57}) + tmp59 := lang.Apply(tmp19, []any{tmp58}) + tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp61 := tmp60.FindInternedVar(lang.NewSymbol("list")) + if tmp61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) + } + tmp62 := tmp61.Get() + tmp63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp64 := tmp63.FindInternedVar(lang.NewSymbol("seq")) + if tmp64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp64))) + } + tmp65 := tmp64.Get() + tmp66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp67 := tmp66.FindInternedVar(lang.NewSymbol("concat")) + if tmp67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp67))) + } + tmp68 := tmp67.Get() + tmp69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp70 := tmp69.FindInternedVar(lang.NewSymbol("list")) + if tmp70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp70))) + } + tmp71 := tmp70.Get() + tmp72 := lang.Apply(tmp71, []any{lang.NewSymbol("glojure.core/when-not")}) + tmp73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp74 := tmp73.FindInternedVar(lang.NewSymbol("list")) + if tmp74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp74))) + } + tmp75 := tmp74.Get() + tmp76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp77 := tmp76.FindInternedVar(lang.NewSymbol("seq")) + if tmp77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp77))) + } + tmp78 := tmp77.Get() + tmp79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp80 := tmp79.FindInternedVar(lang.NewSymbol("concat")) + if tmp80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp80))) + } + tmp81 := tmp80.Get() + tmp82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp83 := tmp82.FindInternedVar(lang.NewSymbol("list")) + if tmp83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp83))) + } + tmp84 := tmp83.Get() + tmp85 := lang.Apply(tmp84, []any{lang.NewSymbol(".HasRoot")}) + tmp86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp87 := tmp86.FindInternedVar(lang.NewSymbol("list")) + if tmp87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp87))) + } + tmp88 := tmp87.Get() + tmp89 := lang.Apply(tmp88, []any{lang.NewSymbol("v__0__auto__")}) + tmp90 := lang.Apply(tmp81, []any{tmp85, tmp89}) + tmp91 := lang.Apply(tmp78, []any{tmp90}) + tmp92 := lang.Apply(tmp75, []any{tmp91}) + tmp93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp94 := tmp93.FindInternedVar(lang.NewSymbol("list")) + if tmp94.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp94))) + } + tmp95 := tmp94.Get() + tmp96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp97 := tmp96.FindInternedVar(lang.NewSymbol("seq")) + if tmp97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp97))) + } + tmp98 := tmp97.Get() + tmp99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp100 := tmp99.FindInternedVar(lang.NewSymbol("concat")) + if tmp100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp100))) + } + tmp101 := tmp100.Get() + tmp102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp103 := tmp102.FindInternedVar(lang.NewSymbol("list")) + if tmp103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp103))) + } + tmp104 := tmp103.Get() + tmp105 := lang.Apply(tmp104, []any{lang.NewSymbol("def")}) + tmp106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp107 := tmp106.FindInternedVar(lang.NewSymbol("list")) + if tmp107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp107))) + } + tmp108 := tmp107.Get() + tmp109 := lang.Apply(tmp108, []any{v5}) + tmp110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp111 := tmp110.FindInternedVar(lang.NewSymbol("list")) + if tmp111.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp111))) + } + tmp112 := tmp111.Get() + tmp113 := lang.Apply(tmp112, []any{v6}) + tmp114 := lang.Apply(tmp101, []any{tmp105, tmp109, tmp113}) + tmp115 := lang.Apply(tmp98, []any{tmp114}) + tmp116 := lang.Apply(tmp95, []any{tmp115}) + tmp117 := lang.Apply(tmp68, []any{tmp72, tmp92, tmp116}) + tmp118 := lang.Apply(tmp65, []any{tmp117}) + tmp119 := lang.Apply(tmp62, []any{tmp118}) + tmp120 := lang.Apply(tmp12, []any{tmp16, tmp59, tmp119}) + tmp121 := lang.Apply(tmp9, []any{tmp120}) + return tmp121 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // defprotocol { - v0 := lang.NewSymbol("defprotocol").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("opts+sigs"))), lang.NewKeyword("doc"), "A protocol is a named set of named methods and their signatures:\n (defprotocol AProtocolName\n\n ;optional doc string\n \"A doc string for AProtocol abstraction\"\n\n ;options\n :extend-via-metadata true\n\n ;method signatures\n (bar [this a b] \"bar docs\")\n (baz [this a] [this a b] [this a b c] \"baz docs\"))\n\n No implementations are provided. Docs can be specified for the\n protocol overall and for each method. The above yields a set of\n polymorphic functions and a protocol object. All are\n namespace-qualified by the ns enclosing the definition The resulting\n functions dispatch on the type of their first argument, which is\n required and corresponds to the implicit target object ('this' in \n Java parlance). defprotocol is dynamic, has no special compile-time \n effect, and defines no new types or classes. Implementations of \n the protocol methods can be provided using extend.\n\n When :extend-via-metadata is true, values can extend protocols by\n adding metadata where keys are fully-qualified protocol function\n symbols and values are function implementations. Protocol\n implementations are checked first for direct definitions (defrecord,\n deftype, reify), then metadata definitions, then external\n extensions (extend, extend-type, extend-protocol)\n\n defprotocol will automatically generate a corresponding interface,\n with the same name as the protocol, i.e. given a protocol:\n my.ns/Protocol, an interface: my.ns.Protocol. The interface will\n have methods corresponding to the protocol functions, and the\n protocol will automatically work with instances of the interface.\n\n Note that you should not use this interface with deftype or\n reify, as they support the protocol directly:\n\n (defprotocol P \n (foo [this]) \n (bar-me [this] [this y]))\n\n (deftype Foo [a b c] \n P\n (foo [this] a)\n (bar-me [this] b)\n (bar-me [this y] (+ c y)))\n \n (bar-me (Foo. 1 2 3) 42)\n => 45\n\n (foo \n (let [x 42]\n (reify P \n (foo [this] 17)\n (bar-me [this] x)\n (bar-me [this y] x))))\n => 17", lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(28), lang.NewKeyword("end-line"), int(28))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("defprotocol").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("opts+sigs"))), lang.NewKeyword("doc"), "A protocol is a named set of named methods and their signatures:\n (defprotocol AProtocolName\n\n ;optional doc string\n \"A doc string for AProtocol abstraction\"\n\n ;options\n :extend-via-metadata true\n\n ;method signatures\n (bar [this a b] \"bar docs\")\n (baz [this a] [this a b] [this a b c] \"baz docs\"))\n\n No implementations are provided. Docs can be specified for the\n protocol overall and for each method. The above yields a set of\n polymorphic functions and a protocol object. All are\n namespace-qualified by the ns enclosing the definition The resulting\n functions dispatch on the type of their first argument, which is\n required and corresponds to the implicit target object ('this' in \n Java parlance). defprotocol is dynamic, has no special compile-time \n effect, and defines no new types or classes. Implementations of \n the protocol methods can be provided using extend.\n\n When :extend-via-metadata is true, values can extend protocols by\n adding metadata where keys are fully-qualified protocol function\n symbols and values are function implementations. Protocol\n implementations are checked first for direct definitions (defrecord,\n deftype, reify), then metadata definitions, then external\n extensions (extend, extend-type, extend-protocol)\n\n defprotocol will automatically generate a corresponding interface,\n with the same name as the protocol, i.e. given a protocol:\n my.ns/Protocol, an interface: my.ns.Protocol. The interface will\n have methods corresponding to the protocol functions, and the\n protocol will automatically work with instances of the interface.\n\n Note that you should not use this interface with deftype or\n reify, as they support the protocol directly:\n\n (defprotocol P \n (foo [this]) \n (bar-me [this] [this y]))\n\n (deftype Foo [a b c] \n P\n (foo [this] a)\n (bar-me [this] b)\n (bar-me [this y] (+ c y)))\n \n (bar-me (Foo. 1 2 3) 42)\n => 45\n\n (foo \n (let [x 42]\n (reify P \n (foo [this] 17)\n (bar-me [this] x)\n (bar-me [this y] x))))\n => 17", lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(28), lang.NewKeyword("end-line"), int(28))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 3 { @@ -23813,866 +23912,865 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - var v7 any + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any { // let // let binding "doc" - var v8 any - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("string?")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("first")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.Apply(v14, []any{v6}) - v16 := lang.Apply(v11, []any{v15}) - if lang.IsTruthy(v16) { - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("first")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.Apply(v19, []any{v6}) - v8 = v20 + var tmp8 any + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("string?")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("first")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.Apply(tmp14, []any{v6}) + tmp16 := lang.Apply(tmp11, []any{tmp15}) + if lang.IsTruthy(tmp16) { + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("first")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.Apply(tmp19, []any{v6}) + tmp8 = tmp20 } else { - v8 = nil } - var v21 any = v8 + var v21 any = tmp8 _ = v21 // let binding "opts+sigs" - var v22 any + var tmp22 any if lang.IsTruthy(v21) { - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("rest")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.Apply(v25, []any{v6}) - v22 = v26 + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("rest")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.Apply(tmp25, []any{v6}) + tmp22 = tmp26 } else { - v22 = v6 + tmp22 = v6 } - var v27 any = v22 + var v27 any = tmp22 _ = v27 // let binding "opts" - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("take-while")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - var v31 lang.FnFunc - v31 = lang.NewFnFunc(func(args ...any) any { + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("take-while")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + var tmp31 lang.FnFunc + tmp31 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v32 := args[0] _ = v32 - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("not")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("seq?")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.Apply(v38, []any{v32}) - v40 := lang.Apply(v35, []any{v39}) - return v40 + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("not")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) + } + tmp35 := tmp34.Get() + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("seq?")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{v32}) + tmp40 := lang.Apply(tmp35, []any{tmp39}) + return tmp40 }) - v32 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(92), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(92), lang.NewKeyword("end-column"), int(40)) - v33, err := lang.WithMeta(v31, v32.(lang.IPersistentMap)) + tmp32 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(92), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(92), lang.NewKeyword("end-column"), int(40)) + tmp33, err := lang.WithMeta(tmp31, tmp32.(lang.IPersistentMap)) if err != nil { panic(err) } - v34 := lang.Apply(v30, []any{v33, v27}) - var v35 any = v34 + tmp34 := lang.Apply(tmp30, []any{tmp33, v27}) + var v35 any = tmp34 _ = v35 // let binding "sigs" - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("drop-while")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - var v39 lang.FnFunc - v39 = lang.NewFnFunc(func(args ...any) any { + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("drop-while")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + var tmp39 lang.FnFunc + tmp39 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v40 := args[0] _ = v40 - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("not")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) - } - v43 := v42.Get() - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("seq?")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) - } - v46 := v45.Get() - v47 := lang.Apply(v46, []any{v40}) - v48 := lang.Apply(v43, []any{v47}) - return v48 + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("not")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("seq?")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) + } + tmp46 := tmp45.Get() + tmp47 := lang.Apply(tmp46, []any{v40}) + tmp48 := lang.Apply(tmp43, []any{tmp47}) + return tmp48 }) - v40 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(93), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(93), lang.NewKeyword("end-column"), int(40)) - v41, err := lang.WithMeta(v39, v40.(lang.IPersistentMap)) + tmp40 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(93), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(93), lang.NewKeyword("end-column"), int(40)) + tmp41, err := lang.WithMeta(tmp39, tmp40.(lang.IPersistentMap)) if err != nil { panic(err) } - v42 := lang.Apply(v38, []any{v41, v27}) - var v43 any = v42 + tmp42 := lang.Apply(tmp38, []any{tmp41, v27}) + var v43 any = tmp42 _ = v43 // let binding "opts" - var v44 any - v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v46 := v45.FindInternedVar(lang.NewSymbol("=")) - if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) - } - v47 := v46.Get() - v48 := lang.Apply(v47, []any{v43, v35}) - if lang.IsTruthy(v48) { - v44 = nil + var tmp44 any + tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp46 := tmp45.FindInternedVar(lang.NewSymbol("=")) + if tmp46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) + } + tmp47 := tmp46.Get() + tmp48 := lang.Apply(tmp47, []any{v43, v35}) + if lang.IsTruthy(tmp48) { } else { - v44 = v35 + tmp44 = v35 } - var v49 any = v44 + var v49 any = tmp44 _ = v49 - v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v51 := v50.FindInternedVar(lang.NewSymbol("seq")) - if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) - } - v52 := v51.Get() - v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v54 := v53.FindInternedVar(lang.NewSymbol("concat")) - if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) - } - v55 := v54.Get() - v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v57 := v56.FindInternedVar(lang.NewSymbol("list")) - if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) - } - v58 := v57.Get() - v59 := lang.Apply(v58, []any{lang.NewSymbol("do")}) - v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v61 := v60.FindInternedVar(lang.NewSymbol("list")) - if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) - } - v62 := v61.Get() - v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v64 := v63.FindInternedVar(lang.NewSymbol("seq")) - if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) - } - v65 := v64.Get() - v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v67 := v66.FindInternedVar(lang.NewSymbol("concat")) - if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) - } - v68 := v67.Get() - v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v70 := v69.FindInternedVar(lang.NewSymbol("list")) - if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) - } - v71 := v70.Get() - v72 := lang.Apply(v71, []any{lang.NewSymbol("def")}) - v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v74 := v73.FindInternedVar(lang.NewSymbol("list")) - if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) - } - v75 := v74.Get() - v76 := lang.Apply(v75, []any{v5}) - v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v78 := v77.FindInternedVar(lang.NewSymbol("list")) - if v78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) - } - v79 := v78.Get() - v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v81 := v80.FindInternedVar(lang.NewSymbol("seq")) - if v81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) - } - v82 := v81.Get() - v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v84 := v83.FindInternedVar(lang.NewSymbol("concat")) - if v84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) - } - v85 := v84.Get() - v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v87 := v86.FindInternedVar(lang.NewSymbol("list")) - if v87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) - } - v88 := v87.Get() - v89 := lang.Apply(v88, []any{lang.NewSymbol("glojure.core/atom")}) - v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v91 := v90.FindInternedVar(lang.NewSymbol("list")) - if v91.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) - } - v92 := v91.Get() - v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v94 := v93.FindInternedVar(lang.NewSymbol("apply")) - if v94.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) - } - v95 := v94.Get() - v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v97 := v96.FindInternedVar(lang.NewSymbol("hash-map")) - if v97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) - } - v98 := v97.Get() - v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v100 := v99.FindInternedVar(lang.NewSymbol("seq")) - if v100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) - } - v101 := v100.Get() - v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v103 := v102.FindInternedVar(lang.NewSymbol("concat")) - if v103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) - } - v104 := v103.Get() - v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v106 := v105.FindInternedVar(lang.NewSymbol("list")) - if v106.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) - } - v107 := v106.Get() - v108 := lang.Apply(v107, []any{lang.NewKeyword("on-interface")}) - v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v110 := v109.FindInternedVar(lang.NewSymbol("list")) - if v110.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) - } - v111 := v110.Get() - v112 := lang.Apply(v111, []any{true}) - v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v114 := v113.FindInternedVar(lang.NewSymbol("list")) - if v114.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) - } - v115 := v114.Get() - v116 := lang.Apply(v115, []any{lang.NewKeyword("sigs")}) - v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v118 := v117.FindInternedVar(lang.NewSymbol("list")) - if v118.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) - } - v119 := v118.Get() - v120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v121 := v120.FindInternedVar(lang.NewSymbol("seq")) - if v121.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v121))) - } - v122 := v121.Get() - v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v124 := v123.FindInternedVar(lang.NewSymbol("concat")) - if v124.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) - } - v125 := v124.Get() - v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v127 := v126.FindInternedVar(lang.NewSymbol("list")) - if v127.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) - } - v128 := v127.Get() - v129 := lang.Apply(v128, []any{lang.NewSymbol("quote")}) - v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v131 := v130.FindInternedVar(lang.NewSymbol("list")) - if v131.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) - } - v132 := v131.Get() - v133 := lang.Apply(v132, []any{v43}) - v134 := lang.Apply(v125, []any{v129, v133}) - v135 := lang.Apply(v122, []any{v134}) - v136 := lang.Apply(v119, []any{v135}) - v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v138 := v137.FindInternedVar(lang.NewSymbol("list")) - if v138.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) - } - v139 := v138.Get() - v140 := lang.Apply(v139, []any{lang.NewKeyword("multis")}) - v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v142 := v141.FindInternedVar(lang.NewSymbol("list")) - if v142.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) - } - v143 := v142.Get() - v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v145 := v144.FindInternedVar(lang.NewSymbol("apply")) - if v145.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) - } - v146 := v145.Get() - v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v148 := v147.FindInternedVar(lang.NewSymbol("hash-map")) - if v148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) - } - v149 := v148.Get() - v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v151 := v150.FindInternedVar(lang.NewSymbol("seq")) - if v151.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) - } - v152 := v151.Get() - v153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v154 := v153.FindInternedVar(lang.NewSymbol("concat")) - if v154.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v154))) - } - v155 := v154.Get() - v156 := lang.Apply(v155, nil) - v157 := lang.Apply(v152, []any{v156}) - v158 := lang.Apply(v146, []any{v149, v157}) - v159 := lang.Apply(v143, []any{v158}) - v160 := lang.Apply(v104, []any{v108, v112, v116, v136, v140, v159}) - v161 := lang.Apply(v101, []any{v160}) - v162 := lang.Apply(v95, []any{v98, v161}) - v163 := lang.Apply(v92, []any{v162}) - v164 := lang.Apply(v85, []any{v89, v163}) - v165 := lang.Apply(v82, []any{v164}) - v166 := lang.Apply(v79, []any{v165}) - v167 := lang.Apply(v68, []any{v72, v76, v166}) - v168 := lang.Apply(v65, []any{v167}) - v169 := lang.Apply(v62, []any{v168}) - v170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v171 := v170.FindInternedVar(lang.NewSymbol("list")) - if v171.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v171))) - } - v172 := v171.Get() - v173 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v174 := v173.FindInternedVar(lang.NewSymbol("seq")) - if v174.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v174))) - } - v175 := v174.Get() - v176 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v177 := v176.FindInternedVar(lang.NewSymbol("concat")) - if v177.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v177))) - } - v178 := v177.Get() - v179 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v180 := v179.FindInternedVar(lang.NewSymbol("list")) - if v180.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v180))) - } - v181 := v180.Get() - v182 := lang.Apply(v181, []any{lang.NewSymbol("glojure.core/swap!")}) - v183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v184 := v183.FindInternedVar(lang.NewSymbol("list")) - if v184.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v184))) - } - v185 := v184.Get() - v186 := lang.Apply(v185, []any{lang.NewSymbol("glojure.core/-protocols")}) - v187 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v188 := v187.FindInternedVar(lang.NewSymbol("list")) - if v188.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v188))) - } - v189 := v188.Get() - v190 := lang.Apply(v189, []any{lang.NewSymbol("glojure.core/assoc")}) - v191 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v192 := v191.FindInternedVar(lang.NewSymbol("list")) - if v192.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v192))) - } - v193 := v192.Get() - v194 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v195 := v194.FindInternedVar(lang.NewSymbol("seq")) - if v195.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v195))) - } - v196 := v195.Get() - v197 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v198 := v197.FindInternedVar(lang.NewSymbol("concat")) - if v198.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v198))) - } - v199 := v198.Get() - v200 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v201 := v200.FindInternedVar(lang.NewSymbol("list")) - if v201.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v201))) - } - v202 := v201.Get() - v203 := lang.Apply(v202, []any{lang.NewSymbol("quote")}) - v204 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v205 := v204.FindInternedVar(lang.NewSymbol("list")) - if v205.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v205))) - } - v206 := v205.Get() - v207 := lang.Apply(v206, []any{v5}) - v208 := lang.Apply(v199, []any{v203, v207}) - v209 := lang.Apply(v196, []any{v208}) - v210 := lang.Apply(v193, []any{v209}) - v211 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v212 := v211.FindInternedVar(lang.NewSymbol("list")) - if v212.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v212))) - } - v213 := v212.Get() - v214 := lang.Apply(v213, []any{v5}) - v215 := lang.Apply(v178, []any{v182, v186, v190, v210, v214}) - v216 := lang.Apply(v175, []any{v215}) - v217 := lang.Apply(v172, []any{v216}) - v218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v219 := v218.FindInternedVar(lang.NewSymbol("map")) - if v219.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v219))) - } - v220 := v219.Get() - var v221 lang.FnFunc - v221 = lang.NewFnFunc(func(args ...any) any { + tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp51 := tmp50.FindInternedVar(lang.NewSymbol("seq")) + if tmp51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) + } + tmp52 := tmp51.Get() + tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp54 := tmp53.FindInternedVar(lang.NewSymbol("concat")) + if tmp54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) + } + tmp55 := tmp54.Get() + tmp56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp57 := tmp56.FindInternedVar(lang.NewSymbol("list")) + if tmp57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp57))) + } + tmp58 := tmp57.Get() + tmp59 := lang.Apply(tmp58, []any{lang.NewSymbol("do")}) + tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp61 := tmp60.FindInternedVar(lang.NewSymbol("list")) + if tmp61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) + } + tmp62 := tmp61.Get() + tmp63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp64 := tmp63.FindInternedVar(lang.NewSymbol("seq")) + if tmp64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp64))) + } + tmp65 := tmp64.Get() + tmp66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp67 := tmp66.FindInternedVar(lang.NewSymbol("concat")) + if tmp67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp67))) + } + tmp68 := tmp67.Get() + tmp69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp70 := tmp69.FindInternedVar(lang.NewSymbol("list")) + if tmp70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp70))) + } + tmp71 := tmp70.Get() + tmp72 := lang.Apply(tmp71, []any{lang.NewSymbol("def")}) + tmp73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp74 := tmp73.FindInternedVar(lang.NewSymbol("list")) + if tmp74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp74))) + } + tmp75 := tmp74.Get() + tmp76 := lang.Apply(tmp75, []any{v5}) + tmp77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp78 := tmp77.FindInternedVar(lang.NewSymbol("list")) + if tmp78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp78))) + } + tmp79 := tmp78.Get() + tmp80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp81 := tmp80.FindInternedVar(lang.NewSymbol("seq")) + if tmp81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp81))) + } + tmp82 := tmp81.Get() + tmp83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp84 := tmp83.FindInternedVar(lang.NewSymbol("concat")) + if tmp84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp84))) + } + tmp85 := tmp84.Get() + tmp86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp87 := tmp86.FindInternedVar(lang.NewSymbol("list")) + if tmp87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp87))) + } + tmp88 := tmp87.Get() + tmp89 := lang.Apply(tmp88, []any{lang.NewSymbol("glojure.core/atom")}) + tmp90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp91 := tmp90.FindInternedVar(lang.NewSymbol("list")) + if tmp91.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp91))) + } + tmp92 := tmp91.Get() + tmp93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp94 := tmp93.FindInternedVar(lang.NewSymbol("apply")) + if tmp94.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp94))) + } + tmp95 := tmp94.Get() + tmp96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp97 := tmp96.FindInternedVar(lang.NewSymbol("hash-map")) + if tmp97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp97))) + } + tmp98 := tmp97.Get() + tmp99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp100 := tmp99.FindInternedVar(lang.NewSymbol("seq")) + if tmp100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp100))) + } + tmp101 := tmp100.Get() + tmp102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp103 := tmp102.FindInternedVar(lang.NewSymbol("concat")) + if tmp103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp103))) + } + tmp104 := tmp103.Get() + tmp105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp106 := tmp105.FindInternedVar(lang.NewSymbol("list")) + if tmp106.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp106))) + } + tmp107 := tmp106.Get() + tmp108 := lang.Apply(tmp107, []any{lang.NewKeyword("on-interface")}) + tmp109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp110 := tmp109.FindInternedVar(lang.NewSymbol("list")) + if tmp110.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp110))) + } + tmp111 := tmp110.Get() + tmp112 := lang.Apply(tmp111, []any{true}) + tmp113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp114 := tmp113.FindInternedVar(lang.NewSymbol("list")) + if tmp114.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp114))) + } + tmp115 := tmp114.Get() + tmp116 := lang.Apply(tmp115, []any{lang.NewKeyword("sigs")}) + tmp117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp118 := tmp117.FindInternedVar(lang.NewSymbol("list")) + if tmp118.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp118))) + } + tmp119 := tmp118.Get() + tmp120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp121 := tmp120.FindInternedVar(lang.NewSymbol("seq")) + if tmp121.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp121))) + } + tmp122 := tmp121.Get() + tmp123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp124 := tmp123.FindInternedVar(lang.NewSymbol("concat")) + if tmp124.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp124))) + } + tmp125 := tmp124.Get() + tmp126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp127 := tmp126.FindInternedVar(lang.NewSymbol("list")) + if tmp127.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp127))) + } + tmp128 := tmp127.Get() + tmp129 := lang.Apply(tmp128, []any{lang.NewSymbol("quote")}) + tmp130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp131 := tmp130.FindInternedVar(lang.NewSymbol("list")) + if tmp131.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp131))) + } + tmp132 := tmp131.Get() + tmp133 := lang.Apply(tmp132, []any{v43}) + tmp134 := lang.Apply(tmp125, []any{tmp129, tmp133}) + tmp135 := lang.Apply(tmp122, []any{tmp134}) + tmp136 := lang.Apply(tmp119, []any{tmp135}) + tmp137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp138 := tmp137.FindInternedVar(lang.NewSymbol("list")) + if tmp138.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp138))) + } + tmp139 := tmp138.Get() + tmp140 := lang.Apply(tmp139, []any{lang.NewKeyword("multis")}) + tmp141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp142 := tmp141.FindInternedVar(lang.NewSymbol("list")) + if tmp142.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp142))) + } + tmp143 := tmp142.Get() + tmp144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp145 := tmp144.FindInternedVar(lang.NewSymbol("apply")) + if tmp145.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp145))) + } + tmp146 := tmp145.Get() + tmp147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp148 := tmp147.FindInternedVar(lang.NewSymbol("hash-map")) + if tmp148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp148))) + } + tmp149 := tmp148.Get() + tmp150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp151 := tmp150.FindInternedVar(lang.NewSymbol("seq")) + if tmp151.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp151))) + } + tmp152 := tmp151.Get() + tmp153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp154 := tmp153.FindInternedVar(lang.NewSymbol("concat")) + if tmp154.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp154))) + } + tmp155 := tmp154.Get() + tmp156 := lang.Apply(tmp155, nil) + tmp157 := lang.Apply(tmp152, []any{tmp156}) + tmp158 := lang.Apply(tmp146, []any{tmp149, tmp157}) + tmp159 := lang.Apply(tmp143, []any{tmp158}) + tmp160 := lang.Apply(tmp104, []any{tmp108, tmp112, tmp116, tmp136, tmp140, tmp159}) + tmp161 := lang.Apply(tmp101, []any{tmp160}) + tmp162 := lang.Apply(tmp95, []any{tmp98, tmp161}) + tmp163 := lang.Apply(tmp92, []any{tmp162}) + tmp164 := lang.Apply(tmp85, []any{tmp89, tmp163}) + tmp165 := lang.Apply(tmp82, []any{tmp164}) + tmp166 := lang.Apply(tmp79, []any{tmp165}) + tmp167 := lang.Apply(tmp68, []any{tmp72, tmp76, tmp166}) + tmp168 := lang.Apply(tmp65, []any{tmp167}) + tmp169 := lang.Apply(tmp62, []any{tmp168}) + tmp170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp171 := tmp170.FindInternedVar(lang.NewSymbol("list")) + if tmp171.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp171))) + } + tmp172 := tmp171.Get() + tmp173 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp174 := tmp173.FindInternedVar(lang.NewSymbol("seq")) + if tmp174.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp174))) + } + tmp175 := tmp174.Get() + tmp176 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp177 := tmp176.FindInternedVar(lang.NewSymbol("concat")) + if tmp177.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp177))) + } + tmp178 := tmp177.Get() + tmp179 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp180 := tmp179.FindInternedVar(lang.NewSymbol("list")) + if tmp180.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp180))) + } + tmp181 := tmp180.Get() + tmp182 := lang.Apply(tmp181, []any{lang.NewSymbol("glojure.core/swap!")}) + tmp183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp184 := tmp183.FindInternedVar(lang.NewSymbol("list")) + if tmp184.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp184))) + } + tmp185 := tmp184.Get() + tmp186 := lang.Apply(tmp185, []any{lang.NewSymbol("glojure.core/-protocols")}) + tmp187 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp188 := tmp187.FindInternedVar(lang.NewSymbol("list")) + if tmp188.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp188))) + } + tmp189 := tmp188.Get() + tmp190 := lang.Apply(tmp189, []any{lang.NewSymbol("glojure.core/assoc")}) + tmp191 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp192 := tmp191.FindInternedVar(lang.NewSymbol("list")) + if tmp192.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp192))) + } + tmp193 := tmp192.Get() + tmp194 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp195 := tmp194.FindInternedVar(lang.NewSymbol("seq")) + if tmp195.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp195))) + } + tmp196 := tmp195.Get() + tmp197 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp198 := tmp197.FindInternedVar(lang.NewSymbol("concat")) + if tmp198.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp198))) + } + tmp199 := tmp198.Get() + tmp200 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp201 := tmp200.FindInternedVar(lang.NewSymbol("list")) + if tmp201.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp201))) + } + tmp202 := tmp201.Get() + tmp203 := lang.Apply(tmp202, []any{lang.NewSymbol("quote")}) + tmp204 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp205 := tmp204.FindInternedVar(lang.NewSymbol("list")) + if tmp205.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp205))) + } + tmp206 := tmp205.Get() + tmp207 := lang.Apply(tmp206, []any{v5}) + tmp208 := lang.Apply(tmp199, []any{tmp203, tmp207}) + tmp209 := lang.Apply(tmp196, []any{tmp208}) + tmp210 := lang.Apply(tmp193, []any{tmp209}) + tmp211 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp212 := tmp211.FindInternedVar(lang.NewSymbol("list")) + if tmp212.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp212))) + } + tmp213 := tmp212.Get() + tmp214 := lang.Apply(tmp213, []any{v5}) + tmp215 := lang.Apply(tmp178, []any{tmp182, tmp186, tmp190, tmp210, tmp214}) + tmp216 := lang.Apply(tmp175, []any{tmp215}) + tmp217 := lang.Apply(tmp172, []any{tmp216}) + tmp218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp219 := tmp218.FindInternedVar(lang.NewSymbol("map")) + if tmp219.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp219))) + } + tmp220 := tmp219.Get() + var tmp221 lang.FnFunc + tmp221 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v222 := args[0] _ = v222 - v223 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v224 := v223.FindInternedVar(lang.NewSymbol("seq")) - if v224.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v224))) - } - v225 := v224.Get() - v226 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v227 := v226.FindInternedVar(lang.NewSymbol("concat")) - if v227.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v227))) - } - v228 := v227.Get() - v229 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v230 := v229.FindInternedVar(lang.NewSymbol("list")) - if v230.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v230))) - } - v231 := v230.Get() - v232 := lang.Apply(v231, []any{lang.NewSymbol("do")}) - v233 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v234 := v233.FindInternedVar(lang.NewSymbol("list")) - if v234.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v234))) - } - v235 := v234.Get() - v236 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v237 := v236.FindInternedVar(lang.NewSymbol("seq")) - if v237.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v237))) - } - v238 := v237.Get() - v239 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v240 := v239.FindInternedVar(lang.NewSymbol("concat")) - if v240.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v240))) - } - v241 := v240.Get() - v242 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v243 := v242.FindInternedVar(lang.NewSymbol("list")) - if v243.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v243))) - } - v244 := v243.Get() - v245 := lang.Apply(v244, []any{lang.NewSymbol("glojure.core/defmulti")}) - v246 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v247 := v246.FindInternedVar(lang.NewSymbol("list")) - if v247.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v247))) - } - v248 := v247.Get() - v249 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v250 := v249.FindInternedVar(lang.NewSymbol("first")) - if v250.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v250))) - } - v251 := v250.Get() - v252 := lang.Apply(v251, []any{v222}) - v253 := lang.Apply(v248, []any{v252}) - v254 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v255 := v254.FindInternedVar(lang.NewSymbol("list")) - if v255.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v255))) - } - v256 := v255.Get() - v257 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v258 := v257.FindInternedVar(lang.NewSymbol("seq")) - if v258.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v258))) - } - v259 := v258.Get() - v260 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v261 := v260.FindInternedVar(lang.NewSymbol("concat")) - if v261.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v261))) - } - v262 := v261.Get() - v263 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v264 := v263.FindInternedVar(lang.NewSymbol("list")) - if v264.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v264))) - } - v265 := v264.Get() - v266 := lang.Apply(v265, []any{lang.NewSymbol("glojure.core/fn")}) - v267 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v268 := v267.FindInternedVar(lang.NewSymbol("list")) - if v268.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v268))) - } - v269 := v268.Get() - v270 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v271 := v270.FindInternedVar(lang.NewSymbol("apply")) - if v271.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v271))) - } - v272 := v271.Get() - v273 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v274 := v273.FindInternedVar(lang.NewSymbol("vector")) - if v274.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v274))) - } - v275 := v274.Get() - v276 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v277 := v276.FindInternedVar(lang.NewSymbol("seq")) - if v277.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v277))) - } - v278 := v277.Get() - v279 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v280 := v279.FindInternedVar(lang.NewSymbol("concat")) - if v280.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v280))) - } - v281 := v280.Get() - v282 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v283 := v282.FindInternedVar(lang.NewSymbol("list")) - if v283.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v283))) - } - v284 := v283.Get() - v285 := lang.Apply(v284, []any{lang.NewSymbol("this")}) - v286 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v287 := v286.FindInternedVar(lang.NewSymbol("list")) - if v287.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v287))) - } - v288 := v287.Get() - v289 := lang.Apply(v288, []any{lang.NewSymbol("&")}) - v290 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v291 := v290.FindInternedVar(lang.NewSymbol("list")) - if v291.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v291))) - } - v292 := v291.Get() - v293 := lang.Apply(v292, []any{lang.NewSymbol("args")}) - v294 := lang.Apply(v281, []any{v285, v289, v293}) - v295 := lang.Apply(v278, []any{v294}) - v296 := lang.Apply(v272, []any{v275, v295}) - v297 := lang.Apply(v269, []any{v296}) - v298 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v299 := v298.FindInternedVar(lang.NewSymbol("list")) - if v299.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v299))) - } - v300 := v299.Get() - v301 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v302 := v301.FindInternedVar(lang.NewSymbol("seq")) - if v302.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v302))) - } - v303 := v302.Get() - v304 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v305 := v304.FindInternedVar(lang.NewSymbol("concat")) - if v305.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v305))) - } - v306 := v305.Get() - v307 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v308 := v307.FindInternedVar(lang.NewSymbol("list")) - if v308.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v308))) - } - v309 := v308.Get() - v310 := lang.Apply(v309, []any{lang.NewSymbol("glojure.core/class")}) - v311 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v312 := v311.FindInternedVar(lang.NewSymbol("list")) - if v312.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v312))) - } - v313 := v312.Get() - v314 := lang.Apply(v313, []any{lang.NewSymbol("this")}) - v315 := lang.Apply(v306, []any{v310, v314}) - v316 := lang.Apply(v303, []any{v315}) - v317 := lang.Apply(v300, []any{v316}) - v318 := lang.Apply(v262, []any{v266, v297, v317}) - v319 := lang.Apply(v259, []any{v318}) - v320 := lang.Apply(v256, []any{v319}) - v321 := lang.Apply(v241, []any{v245, v253, v320}) - v322 := lang.Apply(v238, []any{v321}) - v323 := lang.Apply(v235, []any{v322}) - v324 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v325 := v324.FindInternedVar(lang.NewSymbol("list")) - if v325.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v325))) - } - v326 := v325.Get() - v327 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v328 := v327.FindInternedVar(lang.NewSymbol("seq")) - if v328.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v328))) - } - v329 := v328.Get() - v330 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v331 := v330.FindInternedVar(lang.NewSymbol("concat")) - if v331.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v331))) - } - v332 := v331.Get() - v333 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v334 := v333.FindInternedVar(lang.NewSymbol("list")) - if v334.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v334))) - } - v335 := v334.Get() - v336 := lang.Apply(v335, []any{lang.NewSymbol("glojure.core/swap!")}) - v337 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v338 := v337.FindInternedVar(lang.NewSymbol("list")) - if v338.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v338))) - } - v339 := v338.Get() - v340 := lang.Apply(v339, []any{v5}) - v341 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v342 := v341.FindInternedVar(lang.NewSymbol("list")) - if v342.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v342))) - } - v343 := v342.Get() - v344 := lang.Apply(v343, []any{lang.NewSymbol("glojure.core/assoc-in")}) - v345 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v346 := v345.FindInternedVar(lang.NewSymbol("list")) - if v346.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v346))) - } - v347 := v346.Get() - v348 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v349 := v348.FindInternedVar(lang.NewSymbol("apply")) - if v349.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v349))) - } - v350 := v349.Get() - v351 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v352 := v351.FindInternedVar(lang.NewSymbol("vector")) - if v352.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v352))) - } - v353 := v352.Get() - v354 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v355 := v354.FindInternedVar(lang.NewSymbol("seq")) - if v355.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v355))) - } - v356 := v355.Get() - v357 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v358 := v357.FindInternedVar(lang.NewSymbol("concat")) - if v358.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v358))) - } - v359 := v358.Get() - v360 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v361 := v360.FindInternedVar(lang.NewSymbol("list")) - if v361.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v361))) - } - v362 := v361.Get() - v363 := lang.Apply(v362, []any{lang.NewKeyword("multis")}) - v364 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v365 := v364.FindInternedVar(lang.NewSymbol("list")) - if v365.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v365))) - } - v366 := v365.Get() - v367 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v368 := v367.FindInternedVar(lang.NewSymbol("seq")) - if v368.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v368))) - } - v369 := v368.Get() - v370 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v371 := v370.FindInternedVar(lang.NewSymbol("concat")) - if v371.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v371))) - } - v372 := v371.Get() - v373 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v374 := v373.FindInternedVar(lang.NewSymbol("list")) - if v374.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v374))) - } - v375 := v374.Get() - v376 := lang.Apply(v375, []any{lang.NewSymbol("glojure.core/keyword")}) - v377 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v378 := v377.FindInternedVar(lang.NewSymbol("list")) - if v378.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v378))) - } - v379 := v378.Get() - v380 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v381 := v380.FindInternedVar(lang.NewSymbol("seq")) - if v381.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v381))) - } - v382 := v381.Get() - v383 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v384 := v383.FindInternedVar(lang.NewSymbol("concat")) - if v384.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v384))) - } - v385 := v384.Get() - v386 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v387 := v386.FindInternedVar(lang.NewSymbol("list")) - if v387.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v387))) - } - v388 := v387.Get() - v389 := lang.Apply(v388, []any{lang.NewSymbol("quote")}) - v390 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v391 := v390.FindInternedVar(lang.NewSymbol("list")) - if v391.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v391))) - } - v392 := v391.Get() - v393 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v394 := v393.FindInternedVar(lang.NewSymbol("first")) - if v394.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v394))) - } - v395 := v394.Get() - v396 := lang.Apply(v395, []any{v222}) - v397 := lang.Apply(v392, []any{v396}) - v398 := lang.Apply(v385, []any{v389, v397}) - v399 := lang.Apply(v382, []any{v398}) - v400 := lang.Apply(v379, []any{v399}) - v401 := lang.Apply(v372, []any{v376, v400}) - v402 := lang.Apply(v369, []any{v401}) - v403 := lang.Apply(v366, []any{v402}) - v404 := lang.Apply(v359, []any{v363, v403}) - v405 := lang.Apply(v356, []any{v404}) - v406 := lang.Apply(v350, []any{v353, v405}) - v407 := lang.Apply(v347, []any{v406}) - v408 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v409 := v408.FindInternedVar(lang.NewSymbol("list")) - if v409.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v409))) - } - v410 := v409.Get() - v411 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v412 := v411.FindInternedVar(lang.NewSymbol("first")) - if v412.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v412))) - } - v413 := v412.Get() - v414 := lang.Apply(v413, []any{v222}) - v415 := lang.Apply(v410, []any{v414}) - v416 := lang.Apply(v332, []any{v336, v340, v344, v407, v415}) - v417 := lang.Apply(v329, []any{v416}) - v418 := lang.Apply(v326, []any{v417}) - v419 := lang.Apply(v228, []any{v232, v323, v418}) - v420 := lang.Apply(v225, []any{v419}) - return v420 + tmp223 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp224 := tmp223.FindInternedVar(lang.NewSymbol("seq")) + if tmp224.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp224))) + } + tmp225 := tmp224.Get() + tmp226 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp227 := tmp226.FindInternedVar(lang.NewSymbol("concat")) + if tmp227.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp227))) + } + tmp228 := tmp227.Get() + tmp229 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp230 := tmp229.FindInternedVar(lang.NewSymbol("list")) + if tmp230.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp230))) + } + tmp231 := tmp230.Get() + tmp232 := lang.Apply(tmp231, []any{lang.NewSymbol("do")}) + tmp233 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp234 := tmp233.FindInternedVar(lang.NewSymbol("list")) + if tmp234.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp234))) + } + tmp235 := tmp234.Get() + tmp236 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp237 := tmp236.FindInternedVar(lang.NewSymbol("seq")) + if tmp237.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp237))) + } + tmp238 := tmp237.Get() + tmp239 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp240 := tmp239.FindInternedVar(lang.NewSymbol("concat")) + if tmp240.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp240))) + } + tmp241 := tmp240.Get() + tmp242 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp243 := tmp242.FindInternedVar(lang.NewSymbol("list")) + if tmp243.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp243))) + } + tmp244 := tmp243.Get() + tmp245 := lang.Apply(tmp244, []any{lang.NewSymbol("glojure.core/defmulti")}) + tmp246 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp247 := tmp246.FindInternedVar(lang.NewSymbol("list")) + if tmp247.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp247))) + } + tmp248 := tmp247.Get() + tmp249 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp250 := tmp249.FindInternedVar(lang.NewSymbol("first")) + if tmp250.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp250))) + } + tmp251 := tmp250.Get() + tmp252 := lang.Apply(tmp251, []any{v222}) + tmp253 := lang.Apply(tmp248, []any{tmp252}) + tmp254 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp255 := tmp254.FindInternedVar(lang.NewSymbol("list")) + if tmp255.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp255))) + } + tmp256 := tmp255.Get() + tmp257 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp258 := tmp257.FindInternedVar(lang.NewSymbol("seq")) + if tmp258.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp258))) + } + tmp259 := tmp258.Get() + tmp260 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp261 := tmp260.FindInternedVar(lang.NewSymbol("concat")) + if tmp261.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp261))) + } + tmp262 := tmp261.Get() + tmp263 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp264 := tmp263.FindInternedVar(lang.NewSymbol("list")) + if tmp264.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp264))) + } + tmp265 := tmp264.Get() + tmp266 := lang.Apply(tmp265, []any{lang.NewSymbol("glojure.core/fn")}) + tmp267 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp268 := tmp267.FindInternedVar(lang.NewSymbol("list")) + if tmp268.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp268))) + } + tmp269 := tmp268.Get() + tmp270 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp271 := tmp270.FindInternedVar(lang.NewSymbol("apply")) + if tmp271.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp271))) + } + tmp272 := tmp271.Get() + tmp273 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp274 := tmp273.FindInternedVar(lang.NewSymbol("vector")) + if tmp274.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp274))) + } + tmp275 := tmp274.Get() + tmp276 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp277 := tmp276.FindInternedVar(lang.NewSymbol("seq")) + if tmp277.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp277))) + } + tmp278 := tmp277.Get() + tmp279 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp280 := tmp279.FindInternedVar(lang.NewSymbol("concat")) + if tmp280.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp280))) + } + tmp281 := tmp280.Get() + tmp282 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp283 := tmp282.FindInternedVar(lang.NewSymbol("list")) + if tmp283.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp283))) + } + tmp284 := tmp283.Get() + tmp285 := lang.Apply(tmp284, []any{lang.NewSymbol("this")}) + tmp286 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp287 := tmp286.FindInternedVar(lang.NewSymbol("list")) + if tmp287.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp287))) + } + tmp288 := tmp287.Get() + tmp289 := lang.Apply(tmp288, []any{lang.NewSymbol("&")}) + tmp290 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp291 := tmp290.FindInternedVar(lang.NewSymbol("list")) + if tmp291.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp291))) + } + tmp292 := tmp291.Get() + tmp293 := lang.Apply(tmp292, []any{lang.NewSymbol("args")}) + tmp294 := lang.Apply(tmp281, []any{tmp285, tmp289, tmp293}) + tmp295 := lang.Apply(tmp278, []any{tmp294}) + tmp296 := lang.Apply(tmp272, []any{tmp275, tmp295}) + tmp297 := lang.Apply(tmp269, []any{tmp296}) + tmp298 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp299 := tmp298.FindInternedVar(lang.NewSymbol("list")) + if tmp299.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp299))) + } + tmp300 := tmp299.Get() + tmp301 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp302 := tmp301.FindInternedVar(lang.NewSymbol("seq")) + if tmp302.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp302))) + } + tmp303 := tmp302.Get() + tmp304 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp305 := tmp304.FindInternedVar(lang.NewSymbol("concat")) + if tmp305.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp305))) + } + tmp306 := tmp305.Get() + tmp307 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp308 := tmp307.FindInternedVar(lang.NewSymbol("list")) + if tmp308.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp308))) + } + tmp309 := tmp308.Get() + tmp310 := lang.Apply(tmp309, []any{lang.NewSymbol("glojure.core/class")}) + tmp311 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp312 := tmp311.FindInternedVar(lang.NewSymbol("list")) + if tmp312.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp312))) + } + tmp313 := tmp312.Get() + tmp314 := lang.Apply(tmp313, []any{lang.NewSymbol("this")}) + tmp315 := lang.Apply(tmp306, []any{tmp310, tmp314}) + tmp316 := lang.Apply(tmp303, []any{tmp315}) + tmp317 := lang.Apply(tmp300, []any{tmp316}) + tmp318 := lang.Apply(tmp262, []any{tmp266, tmp297, tmp317}) + tmp319 := lang.Apply(tmp259, []any{tmp318}) + tmp320 := lang.Apply(tmp256, []any{tmp319}) + tmp321 := lang.Apply(tmp241, []any{tmp245, tmp253, tmp320}) + tmp322 := lang.Apply(tmp238, []any{tmp321}) + tmp323 := lang.Apply(tmp235, []any{tmp322}) + tmp324 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp325 := tmp324.FindInternedVar(lang.NewSymbol("list")) + if tmp325.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp325))) + } + tmp326 := tmp325.Get() + tmp327 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp328 := tmp327.FindInternedVar(lang.NewSymbol("seq")) + if tmp328.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp328))) + } + tmp329 := tmp328.Get() + tmp330 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp331 := tmp330.FindInternedVar(lang.NewSymbol("concat")) + if tmp331.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp331))) + } + tmp332 := tmp331.Get() + tmp333 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp334 := tmp333.FindInternedVar(lang.NewSymbol("list")) + if tmp334.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp334))) + } + tmp335 := tmp334.Get() + tmp336 := lang.Apply(tmp335, []any{lang.NewSymbol("glojure.core/swap!")}) + tmp337 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp338 := tmp337.FindInternedVar(lang.NewSymbol("list")) + if tmp338.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp338))) + } + tmp339 := tmp338.Get() + tmp340 := lang.Apply(tmp339, []any{v5}) + tmp341 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp342 := tmp341.FindInternedVar(lang.NewSymbol("list")) + if tmp342.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp342))) + } + tmp343 := tmp342.Get() + tmp344 := lang.Apply(tmp343, []any{lang.NewSymbol("glojure.core/assoc-in")}) + tmp345 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp346 := tmp345.FindInternedVar(lang.NewSymbol("list")) + if tmp346.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp346))) + } + tmp347 := tmp346.Get() + tmp348 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp349 := tmp348.FindInternedVar(lang.NewSymbol("apply")) + if tmp349.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp349))) + } + tmp350 := tmp349.Get() + tmp351 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp352 := tmp351.FindInternedVar(lang.NewSymbol("vector")) + if tmp352.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp352))) + } + tmp353 := tmp352.Get() + tmp354 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp355 := tmp354.FindInternedVar(lang.NewSymbol("seq")) + if tmp355.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp355))) + } + tmp356 := tmp355.Get() + tmp357 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp358 := tmp357.FindInternedVar(lang.NewSymbol("concat")) + if tmp358.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp358))) + } + tmp359 := tmp358.Get() + tmp360 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp361 := tmp360.FindInternedVar(lang.NewSymbol("list")) + if tmp361.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp361))) + } + tmp362 := tmp361.Get() + tmp363 := lang.Apply(tmp362, []any{lang.NewKeyword("multis")}) + tmp364 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp365 := tmp364.FindInternedVar(lang.NewSymbol("list")) + if tmp365.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp365))) + } + tmp366 := tmp365.Get() + tmp367 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp368 := tmp367.FindInternedVar(lang.NewSymbol("seq")) + if tmp368.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp368))) + } + tmp369 := tmp368.Get() + tmp370 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp371 := tmp370.FindInternedVar(lang.NewSymbol("concat")) + if tmp371.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp371))) + } + tmp372 := tmp371.Get() + tmp373 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp374 := tmp373.FindInternedVar(lang.NewSymbol("list")) + if tmp374.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp374))) + } + tmp375 := tmp374.Get() + tmp376 := lang.Apply(tmp375, []any{lang.NewSymbol("glojure.core/keyword")}) + tmp377 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp378 := tmp377.FindInternedVar(lang.NewSymbol("list")) + if tmp378.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp378))) + } + tmp379 := tmp378.Get() + tmp380 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp381 := tmp380.FindInternedVar(lang.NewSymbol("seq")) + if tmp381.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp381))) + } + tmp382 := tmp381.Get() + tmp383 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp384 := tmp383.FindInternedVar(lang.NewSymbol("concat")) + if tmp384.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp384))) + } + tmp385 := tmp384.Get() + tmp386 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp387 := tmp386.FindInternedVar(lang.NewSymbol("list")) + if tmp387.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp387))) + } + tmp388 := tmp387.Get() + tmp389 := lang.Apply(tmp388, []any{lang.NewSymbol("quote")}) + tmp390 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp391 := tmp390.FindInternedVar(lang.NewSymbol("list")) + if tmp391.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp391))) + } + tmp392 := tmp391.Get() + tmp393 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp394 := tmp393.FindInternedVar(lang.NewSymbol("first")) + if tmp394.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp394))) + } + tmp395 := tmp394.Get() + tmp396 := lang.Apply(tmp395, []any{v222}) + tmp397 := lang.Apply(tmp392, []any{tmp396}) + tmp398 := lang.Apply(tmp385, []any{tmp389, tmp397}) + tmp399 := lang.Apply(tmp382, []any{tmp398}) + tmp400 := lang.Apply(tmp379, []any{tmp399}) + tmp401 := lang.Apply(tmp372, []any{tmp376, tmp400}) + tmp402 := lang.Apply(tmp369, []any{tmp401}) + tmp403 := lang.Apply(tmp366, []any{tmp402}) + tmp404 := lang.Apply(tmp359, []any{tmp363, tmp403}) + tmp405 := lang.Apply(tmp356, []any{tmp404}) + tmp406 := lang.Apply(tmp350, []any{tmp353, tmp405}) + tmp407 := lang.Apply(tmp347, []any{tmp406}) + tmp408 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp409 := tmp408.FindInternedVar(lang.NewSymbol("list")) + if tmp409.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp409))) + } + tmp410 := tmp409.Get() + tmp411 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp412 := tmp411.FindInternedVar(lang.NewSymbol("first")) + if tmp412.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp412))) + } + tmp413 := tmp412.Get() + tmp414 := lang.Apply(tmp413, []any{v222}) + tmp415 := lang.Apply(tmp410, []any{tmp414}) + tmp416 := lang.Apply(tmp332, []any{tmp336, tmp340, tmp344, tmp407, tmp415}) + tmp417 := lang.Apply(tmp329, []any{tmp416}) + tmp418 := lang.Apply(tmp326, []any{tmp417}) + tmp419 := lang.Apply(tmp228, []any{tmp232, tmp323, tmp418}) + tmp420 := lang.Apply(tmp225, []any{tmp419}) + return tmp420 }) - v222 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(102), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(104), lang.NewKeyword("end-column"), int(90)) - v223, err := lang.WithMeta(v221, v222.(lang.IPersistentMap)) + tmp222 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(102), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(104), lang.NewKeyword("end-column"), int(90)) + tmp223, err := lang.WithMeta(tmp221, tmp222.(lang.IPersistentMap)) if err != nil { panic(err) } - v224 := lang.Apply(v220, []any{v223, v43}) - v225 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v226 := v225.FindInternedVar(lang.NewSymbol("list")) - if v226.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v226))) - } - v227 := v226.Get() - v228 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v229 := v228.FindInternedVar(lang.NewSymbol("seq")) - if v229.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v229))) - } - v230 := v229.Get() - v231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v232 := v231.FindInternedVar(lang.NewSymbol("concat")) - if v232.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v232))) - } - v233 := v232.Get() - v234 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v235 := v234.FindInternedVar(lang.NewSymbol("list")) - if v235.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v235))) - } - v236 := v235.Get() - v237 := lang.Apply(v236, []any{lang.NewSymbol("var")}) - v238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v239 := v238.FindInternedVar(lang.NewSymbol("list")) - if v239.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v239))) - } - v240 := v239.Get() - v241 := lang.Apply(v240, []any{v5}) - v242 := lang.Apply(v233, []any{v237, v241}) - v243 := lang.Apply(v230, []any{v242}) - v244 := lang.Apply(v227, []any{v243}) - v245 := lang.Apply(v55, []any{v59, v169, v217, v224, v244}) - v246 := lang.Apply(v52, []any{v245}) - v7 = v246 + tmp224 := lang.Apply(tmp220, []any{tmp223, v43}) + tmp225 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp226 := tmp225.FindInternedVar(lang.NewSymbol("list")) + if tmp226.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp226))) + } + tmp227 := tmp226.Get() + tmp228 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp229 := tmp228.FindInternedVar(lang.NewSymbol("seq")) + if tmp229.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp229))) + } + tmp230 := tmp229.Get() + tmp231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp232 := tmp231.FindInternedVar(lang.NewSymbol("concat")) + if tmp232.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp232))) + } + tmp233 := tmp232.Get() + tmp234 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp235 := tmp234.FindInternedVar(lang.NewSymbol("list")) + if tmp235.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp235))) + } + tmp236 := tmp235.Get() + tmp237 := lang.Apply(tmp236, []any{lang.NewSymbol("var")}) + tmp238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp239 := tmp238.FindInternedVar(lang.NewSymbol("list")) + if tmp239.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp239))) + } + tmp240 := tmp239.Get() + tmp241 := lang.Apply(tmp240, []any{v5}) + tmp242 := lang.Apply(tmp233, []any{tmp237, tmp241}) + tmp243 := lang.Apply(tmp230, []any{tmp242}) + tmp244 := lang.Apply(tmp227, []any{tmp243}) + tmp245 := lang.Apply(tmp55, []any{tmp59, tmp169, tmp217, tmp224, tmp244}) + tmp246 := lang.Apply(tmp52, []any{tmp245}) + tmp7 = tmp246 } // end let - return v7 + return tmp7 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // defstruct { - v0 := lang.NewSymbol("defstruct").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("keys"))), lang.NewKeyword("doc"), "Same as (def name (create-struct keys...))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4044), lang.NewKeyword("end-line"), int(4044))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("defstruct").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("keys"))), lang.NewKeyword("doc"), "Same as (def name (create-struct keys...))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4044), lang.NewKeyword("end-line"), int(4044))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 3 { @@ -24684,77 +24782,78 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("seq")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("concat")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("list")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{lang.NewSymbol("def")}) - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("list")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.Apply(v19, []any{v5}) - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("list")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("seq")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("concat")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("list")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) - } - v32 := v31.Get() - v33 := lang.Apply(v32, []any{lang.NewSymbol("glojure.core/create-struct")}) - v34 := lang.Apply(v29, []any{v33, v6}) - v35 := lang.Apply(v26, []any{v34}) - v36 := lang.Apply(v23, []any{v35}) - v37 := lang.Apply(v12, []any{v16, v20, v36}) - v38 := lang.Apply(v9, []any{v37}) - return v38 - } - }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("seq")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("concat")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("list")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("def")}) + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("list")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.Apply(tmp19, []any{v5}) + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("list")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("seq")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("concat")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("list")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) + } + tmp32 := tmp31.Get() + tmp33 := lang.Apply(tmp32, []any{lang.NewSymbol("glojure.core/create-struct")}) + tmp34 := lang.Apply(tmp29, []any{tmp33, v6}) + tmp35 := lang.Apply(tmp26, []any{tmp34}) + tmp36 := lang.Apply(tmp23, []any{tmp35}) + tmp37 := lang.Apply(tmp12, []any{tmp16, tmp20, tmp36}) + tmp38 := lang.Apply(tmp9, []any{tmp37}) + return tmp38 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // delay { - v0 := lang.NewSymbol("delay").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Takes a body of expressions and yields a Delay object that will\n invoke the body only the first time it is forced (with force or deref/@), and\n will cache the result and return it on all subsequent force\n calls. See also - realized?", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(739), lang.NewKeyword("end-line"), int(739))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("delay").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Takes a body of expressions and yields a Delay object that will\n invoke the body only the first time it is forced (with force or deref/@), and\n will cache the result and return it on all subsequent force\n calls. See also - realized?", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(739), lang.NewKeyword("end-line"), int(739))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 2 { @@ -24764,66 +24863,67 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.NewList(args[2:]...) - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("list")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("list*")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.NewVector() - v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(746), lang.NewKeyword("column"), int(62), lang.NewKeyword("end-line"), int(746), lang.NewKeyword("end-column"), int(63)) - v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("list")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("list*")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.NewVector() + tmp13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(746), lang.NewKeyword("column"), int(62), lang.NewKeyword("end-line"), int(746), lang.NewKeyword("end-column"), int(63)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) if err != nil { panic(err) } - v15 := lang.Apply(v11, []any{lang.NewSymbol("fn*"), v14, v5}) - v16 := lang.Apply(v8, []any{lang.NewSymbol("new"), lang.NewSymbol("glojure.lang.Delay"), v15}) - return v16 + tmp15 := lang.Apply(tmp11, []any{lang.NewSymbol("fn*"), tmp14, v5}) + tmp16 := lang.Apply(tmp8, []any{lang.NewSymbol("new"), lang.NewSymbol("glojure.lang.Delay"), tmp15}) + return tmp16 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // delay? { - v0 := lang.NewSymbol("delay?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "returns true if x is a Delay created with delay", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(748), lang.NewKeyword("end-line"), int(748))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("delay?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "returns true if x is a Delay created with delay", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(748), lang.NewKeyword("end-line"), int(748))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) } - v6 := v5.Get() - v7 := lang.Apply(v6, []any{nil, v3}) - return v7 + tmp6 := tmp5.Get() + tmp7 := lang.Apply(tmp6, []any{nil, v3}) + return tmp7 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // deliver { - v0 := lang.NewSymbol("deliver").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("promise"), lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Delivers the supplied value to the promise, releasing any pending\n derefs. A subsequent call to deliver on a promise will have no effect.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7109), lang.NewKeyword("end-line"), int(7109))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("deliver").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("promise"), lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Delivers the supplied value to the promise, releasing any pending\n derefs. A subsequent call to deliver on a promise will have no effect.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7109), lang.NewKeyword("end-line"), int(7109))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -24831,87 +24931,88 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.Apply(v3, []any{v4}) - return v5 + tmp5 := lang.Apply(v3, []any{v4}) + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // denominator { - v1 := reflect.TypeOf((*big6.Int)(nil)) - v0 := lang.NewSymbol("denominator").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("r"))), lang.NewKeyword("doc"), "Returns the denominator part of a Ratio.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3591), lang.NewKeyword("end-line"), int(3591))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp1 := reflect.TypeOf((*big6.Int)(nil)) + tmp0 := lang.NewSymbol("denominator").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("r"))), lang.NewKeyword("doc"), "Returns the denominator part of a Ratio.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3591), lang.NewKeyword("end-line"), int(3591))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5, ok := lang.FieldOrMethod(v4, "denominator") + tmp5, ok := lang.FieldOrMethod(v4, "denominator") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "denominator"))) } - var v6 any - switch reflect.TypeOf(v5).Kind() { + var tmp6 any + switch reflect.TypeOf(tmp5).Kind() { case reflect.Func: - v6 = lang.Apply(v5, nil) + tmp6 = lang.Apply(tmp5, nil) default: - v6 = v5 + tmp6 = tmp5 } - return v6 + return tmp6 }) - v4 := reflect.TypeOf((*big6.Int)(nil)) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp4 := reflect.TypeOf((*big6.Int)(nil)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // deref { - v0 := lang.NewSymbol("deref").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref")), lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("timeout-ms"), lang.NewSymbol("timeout-val"))), lang.NewKeyword("doc"), "Also reader macro: @ref/@agent/@var/@atom/@delay/@future/@promise. Within a transaction,\n returns the in-transaction-value of ref, else returns the\n most-recently-committed value of ref. When applied to a var, agent\n or atom, returns its current state. When applied to a delay, forces\n it if not already forced. When applied to a future, will block if\n computation not complete. When applied to a promise, will block\n until a value is delivered. The variant taking a timeout can be\n used for blocking references (futures and promises), and will return\n timeout-val if the timeout (in milliseconds) is reached before a\n value is available. See also - realized?.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2304), lang.NewKeyword("end-line"), int(2304))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("deref").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref")), lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("timeout-ms"), lang.NewSymbol("timeout-val"))), lang.NewKeyword("doc"), "Also reader macro: @ref/@agent/@var/@atom/@delay/@future/@promise. Within a transaction,\n returns the in-transaction-value of ref, else returns the\n most-recently-committed value of ref. When applied to a var, agent\n or atom, returns its current state. When applied to a delay, forces\n it if not already forced. When applied to a future, will block if\n computation not complete. When applied to a promise, will block\n until a value is delivered. The variant taking a timeout can be\n used for blocking references (futures and promises), and will return\n timeout-val if the timeout (in milliseconds) is reached before a\n value is available. See also - realized?.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2304), lang.NewKeyword("end-line"), int(2304))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - var v4 any - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{lang.IDeref, v3}) - if lang.IsTruthy(v8) { - v9, ok := lang.FieldOrMethod(v3, "Deref") + var tmp4 any + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("instance?")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := reflect.TypeOf((*lang.IDeref)(nil)).Elem() + tmp9 := lang.Apply(tmp7, []any{tmp8, v3}) + if lang.IsTruthy(tmp9) { + tmp10, ok := lang.FieldOrMethod(v3, "Deref") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "Deref"))) } - var v10 any - switch reflect.TypeOf(v9).Kind() { + var tmp11 any + switch reflect.TypeOf(tmp10).Kind() { case reflect.Func: - v10 = lang.Apply(v9, nil) + tmp11 = lang.Apply(tmp10, nil) default: - v10 = v9 + tmp11 = tmp10 } - v4 = v10 + tmp4 = tmp11 } else { - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("deref-future")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("deref-future")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{v3}) - v4 = v14 + tmp14 := tmp13.Get() + tmp15 := lang.Apply(tmp14, []any{v3}) + tmp4 = tmp15 } - return v4 + return tmp4 case 3: v3 := args[0] _ = v3 @@ -24919,253 +25020,254 @@ func init() { _ = v4 v5 := args[2] _ = v5 - var v6 any - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("instance?")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v9, []any{lang.IBlockingDeref, v3}) - if lang.IsTruthy(v10) { - v11, _ := lang.FieldOrMethod(v3, "DerefWithTimeout") - if reflect.TypeOf(v11).Kind() != reflect.Func { + var tmp6 any + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("instance?")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := reflect.TypeOf((*lang.IBlockingDeref)(nil)).Elem() + tmp11 := lang.Apply(tmp9, []any{tmp10, v3}) + if lang.IsTruthy(tmp11) { + tmp12, _ := lang.FieldOrMethod(v3, "DerefWithTimeout") + if reflect.TypeOf(tmp12).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("DerefWithTimeout is not a function"))) } - v12 := lang.Apply(v11, []any{v4, v5}) - v6 = v12 + tmp13 := lang.Apply(tmp12, []any{v4, v5}) + tmp6 = tmp13 } else { - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("deref-future")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("deref-future")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{v3, v4, v5}) - v6 = v16 + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{v3, v4, v5}) + tmp6 = tmp17 } - return v6 + return tmp6 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // deref-as-map { - v0 := lang.NewSymbol("deref-as-map").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(408), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(408), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("deref-as-map").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(408), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(408), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any + var tmp4 any { // let // let binding "pending" - var v5 any + var tmp5 any { // let // let binding "and__0__auto__" - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{lang.IPending, v3}) - var v10 any = v9 - _ = v10 - var v11 any - if lang.IsTruthy(v10) { - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("not")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("instance?")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := reflect.TypeOf((*lang.IPending)(nil)).Elem() + tmp10 := lang.Apply(tmp8, []any{tmp9, v3}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("not")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) } - v14 := v13.Get() - v15, ok := lang.FieldOrMethod(v3, "isRealized") + tmp15 := tmp14.Get() + tmp16, ok := lang.FieldOrMethod(v3, "isRealized") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "isRealized"))) } - var v16 any - switch reflect.TypeOf(v15).Kind() { + var tmp17 any + switch reflect.TypeOf(tmp16).Kind() { case reflect.Func: - v16 = lang.Apply(v15, nil) + tmp17 = lang.Apply(tmp16, nil) default: - v16 = v15 + tmp17 = tmp16 } - v17 := lang.Apply(v14, []any{v16}) - v11 = v17 + tmp18 := lang.Apply(tmp15, []any{tmp17}) + tmp12 = tmp18 } else { - v11 = v10 + tmp12 = v11 } - v5 = v11 + tmp5 = tmp12 } // end let - var v6 any = v5 + var v6 any = tmp5 _ = v6 // let binding "vec__250" - var v7 any + var tmp7 any if lang.IsTruthy(v6) { - v7 = nil } else { - var v8 any + var tmp8 any func() { defer func() { if r := recover(); r != nil { if lang.CatchMatches(r, lang.Throwable) { v9 := r _ = v9 - v10 := lang.NewVector(true, v9) - v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(415), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(415), lang.NewKeyword("end-column"), int(25)) - v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) + tmp10 := lang.NewVector(true, v9) + tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(415), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(415), lang.NewKeyword("end-column"), int(25)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) if err != nil { panic(err) } - v8 = v12 + tmp8 = tmp12 } else { panic(r) } } }() - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("deref")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.Apply(v11, []any{v3}) - v13 := lang.NewVector(false, v12) - v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(413), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(413), lang.NewKeyword("end-column"), int(32)) - v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("deref")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.Apply(tmp11, []any{v3}) + tmp13 := lang.NewVector(false, tmp12) + tmp14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(413), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(413), lang.NewKeyword("end-column"), int(32)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) if err != nil { panic(err) } - v8 = v15 + tmp8 = tmp15 }() - v7 = v8 + tmp7 = tmp8 } - var v16 any = v7 + var v16 any = tmp7 _ = v16 // let binding "ex" - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("nth")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.Apply(v19, []any{v16, int64(0), nil}) - var v21 any = v20 + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("nth")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.Apply(tmp19, []any{v16, int64(0), nil}) + var v21 any = tmp20 _ = v21 // let binding "val" - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("nth")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v16, int64(1), nil}) - var v26 any = v25 + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("nth")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.Apply(tmp24, []any{v16, int64(1), nil}) + var v26 any = tmp25 _ = v26 - var v27 any - var v28 any + var tmp27 any + var tmp28 any { // let // let binding "or__0__auto__" var v29 any = v21 _ = v29 - var v30 any + var tmp30 any if lang.IsTruthy(v29) { - v30 = v29 + tmp30 = v29 } else { - var v31 any + var tmp31 any { // let // let binding "and__0__auto__" - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("instance?")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{*lang.Agent, v3}) - var v36 any = v35 - _ = v36 - var v37 any - if lang.IsTruthy(v36) { - v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v39 := v38.FindInternedVar(lang.NewSymbol("agent-error")) - if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("instance?")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := reflect.TypeOf((*lang.Agent)(nil)) + tmp36 := lang.Apply(tmp34, []any{tmp35, v3}) + var v37 any = tmp36 + _ = v37 + var tmp38 any + if lang.IsTruthy(v37) { + tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp40 := tmp39.FindInternedVar(lang.NewSymbol("agent-error")) + if tmp40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) } - v40 := v39.Get() - v41 := lang.Apply(v40, []any{v3}) - v37 = v41 + tmp41 := tmp40.Get() + tmp42 := lang.Apply(tmp41, []any{v3}) + tmp38 = tmp42 } else { - v37 = v36 + tmp38 = v37 } - v31 = v37 + tmp31 = tmp38 } // end let - v30 = v31 + tmp30 = tmp31 } - v28 = v30 + tmp28 = tmp30 } // end let - if lang.IsTruthy(v28) { - v27 = lang.NewKeyword("failed") + if lang.IsTruthy(tmp28) { + tmp27 = lang.NewKeyword("failed") } else { - var v29 any + var tmp29 any if lang.IsTruthy(v6) { - v29 = lang.NewKeyword("pending") + tmp29 = lang.NewKeyword("pending") } else { - var v30 any + var tmp30 any if lang.IsTruthy(lang.NewKeyword("else")) { - v30 = lang.NewKeyword("ready") + tmp30 = lang.NewKeyword("ready") } else { - v30 = nil } - v29 = v30 + tmp29 = tmp30 } - v27 = v29 + tmp27 = tmp29 } - v31 := lang.NewMap(lang.NewKeyword("status"), v27, lang.NewKeyword("val"), v26) - v32 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(416), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(429), lang.NewKeyword("end-column"), int(14)) - v33, err := lang.WithMeta(v31, v32.(lang.IPersistentMap)) + tmp31 := lang.NewMap(lang.NewKeyword("status"), tmp27, lang.NewKeyword("val"), v26) + tmp32 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(416), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(429), lang.NewKeyword("end-column"), int(14)) + tmp33, err := lang.WithMeta(tmp31, tmp32.(lang.IPersistentMap)) if err != nil { panic(err) } - v4 = v33 + tmp4 = tmp33 } // end let - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // deref-future { - v0 := lang.NewSymbol("deref-future").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2296), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(2296), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fut")), lang.NewVector(lang.NewSymbol("fut"), lang.NewSymbol("timeout-ms"), lang.NewSymbol("timeout-val"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("deref-future").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2296), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(2296), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fut")), lang.NewVector(lang.NewSymbol("fut"), lang.NewSymbol("timeout-ms"), lang.NewSymbol("timeout-val"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - v4, ok := lang.FieldOrMethod(v3, "Get") + tmp4, ok := lang.FieldOrMethod(v3, "Get") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "Get"))) } - var v5 any - switch reflect.TypeOf(v4).Kind() { + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { case reflect.Func: - v5 = lang.Apply(v4, nil) + tmp5 = lang.Apply(tmp4, nil) default: - v5 = v4 + tmp5 = tmp4 } - return v5 + return tmp5 case 3: v3 := args[0] _ = v3 @@ -25173,65 +25275,64 @@ func init() { _ = v4 v5 := args[2] _ = v5 - var v6 any + var tmp6 any func() { defer func() { if r := recover(); r != nil { - if lang.CatchMatches(r, lang.TimeoutError) { - v7 := r - _ = v7 - v6 = v5 + tmp7 := reflect.TypeOf((*lang.TimeoutError)(nil)).Elem() + if lang.CatchMatches(r, tmp7) { + v8 := r + _ = v8 + tmp6 = v5 } else { panic(r) } } }() - v7, _ := lang.FieldOrMethod(v3, "Get") - if reflect.TypeOf(v7).Kind() != reflect.Func { + tmp8, _ := lang.FieldOrMethod(v3, "Get") + if reflect.TypeOf(tmp8).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Get is not a function"))) } - v8 := lang.Apply(v7, []any{v4, time7.Millisecond}) - v6 = v8 + tmp9 := lang.Apply(tmp8, []any{v4, time7.Millisecond}) + tmp6 = tmp9 }() - return v6 + return tmp6 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // derive { - v0 := lang.NewSymbol("derive").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag"), lang.NewSymbol("parent")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"), lang.NewSymbol("parent"))), lang.NewKeyword("doc"), "Establishes a parent/child relationship between parent and\n tag. Parent must be a namespace-qualified symbol or keyword and\n child can be either a namespace-qualified symbol or keyword or a\n class. h must be a hierarchy obtained from make-hierarchy, if not\n supplied defaults to, and modifies, the global hierarchy.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5605), lang.NewKeyword("end-line"), int(5605))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("derive").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag"), lang.NewSymbol("parent")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"), lang.NewSymbol("parent"))), lang.NewKeyword("doc"), "Establishes a parent/child relationship between parent and\n tag. Parent must be a namespace-qualified symbol or keyword and\n child can be either a namespace-qualified symbol or keyword or a\n class. h must be a hierarchy obtained from make-hierarchy, if not\n supplied defaults to, and modifies, the global hierarchy.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5605), lang.NewKeyword("end-line"), int(5605))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - _ = nil - _ = nil - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("alter-var-root")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("global-hierarchy")) - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("derive")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.Apply(v7, []any{v8, v11, v3, v4}) - _ = v12 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("alter-var-root")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("global-hierarchy")) + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("derive")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.Apply(tmp7, []any{tmp8, tmp11, v3, v4}) + _ = tmp12 return nil case 3: v3 := args[0] @@ -25240,26 +25341,23 @@ func init() { _ = v4 v5 := args[2] _ = v5 - _ = nil - _ = nil - _ = nil - var v6 any + var tmp6 any { // let // let binding "tp" - v7 := lang.Apply(lang.NewKeyword("parents"), []any{v3}) - var v8 any = v7 + tmp7 := lang.Apply(lang.NewKeyword("parents"), []any{v3}) + var v8 any = tmp7 _ = v8 // let binding "td" - v9 := lang.Apply(lang.NewKeyword("descendants"), []any{v3}) - var v10 any = v9 + tmp9 := lang.Apply(lang.NewKeyword("descendants"), []any{v3}) + var v10 any = tmp9 _ = v10 // let binding "ta" - v11 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) - var v12 any = v11 + tmp11 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) + var v12 any = tmp11 _ = v12 // let binding "tf" - var v13 lang.FnFunc - v13 = lang.NewFnFunc(func(args ...any) any { + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { if len(args) != 5 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -25273,14 +25371,14 @@ func init() { _ = v17 v18 := args[4] _ = v18 - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("reduce1")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - var v22 lang.FnFunc - v22 = lang.NewFnFunc(func(args ...any) any { + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + var tmp22 lang.FnFunc + tmp22 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -25288,290 +25386,288 @@ func init() { _ = v23 v24 := args[1] _ = v24 - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("assoc")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("reduce1")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("conj")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("get")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) - } - v36 := v35.Get() - v37 := lang.CreatePersistentTreeSet() - v38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5628), lang.NewKeyword("column"), int(61), lang.NewKeyword("end-line"), int(5628), lang.NewKeyword("end-column"), int(63)) - v39, err := lang.WithMeta(v37, v38.(lang.IPersistentMap)) + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("assoc")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("conj")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("get")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5628), lang.NewKeyword("column"), int(61), lang.NewKeyword("end-line"), int(5628), lang.NewKeyword("end-column"), int(63)) + tmp39, err := lang.WithMeta(tmp37, tmp38.(lang.IPersistentMap)) if err != nil { panic(err) } - v40 := lang.Apply(v36, []any{v18, v24, v39}) - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("cons")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) - } - v43 := v42.Get() - v44 := lang.Apply(v18, []any{v17}) - v45 := lang.Apply(v43, []any{v17, v44}) - v46 := lang.Apply(v30, []any{v33, v40, v45}) - v47 := lang.Apply(v27, []any{v23, v24, v46}) - return v47 + tmp40 := lang.Apply(tmp36, []any{v18, v24, tmp39}) + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("cons")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := lang.Apply(v18, []any{v17}) + tmp45 := lang.Apply(tmp43, []any{v17, tmp44}) + tmp46 := lang.Apply(tmp30, []any{tmp33, tmp40, tmp45}) + tmp47 := lang.Apply(tmp27, []any{v23, v24, tmp46}) + return tmp47 }) - v23 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5626), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(5628), lang.NewKeyword("end-column"), int(98)) - v24, err := lang.WithMeta(v22, v23.(lang.IPersistentMap)) + tmp23 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5626), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(5628), lang.NewKeyword("end-column"), int(98)) + tmp24, err := lang.WithMeta(tmp22, tmp23.(lang.IPersistentMap)) if err != nil { panic(err) } - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("cons")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("cons")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) } - v27 := v26.Get() - v28 := lang.Apply(v16, []any{v15}) - v29 := lang.Apply(v27, []any{v15, v28}) - v30 := lang.Apply(v21, []any{v24, v14, v29}) - return v30 + tmp27 := tmp26.Get() + tmp28 := lang.Apply(v16, []any{v15}) + tmp29 := lang.Apply(tmp27, []any{v15, tmp28}) + tmp30 := lang.Apply(tmp21, []any{tmp24, v14, tmp29}) + return tmp30 }) - v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5625), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(5629), lang.NewKeyword("end-column"), int(56)) - v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) + tmp14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5625), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(5629), lang.NewKeyword("end-column"), int(56)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) if err != nil { panic(err) } - var v16 any = v15 + var v16 any = tmp15 _ = v16 - var v17 any + var tmp17 any { // let // let binding "or__0__auto__" - var v18 any - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("contains?")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.Apply(v8, []any{v4}) - v23 := lang.Apply(v21, []any{v22, v5}) - if lang.IsTruthy(v23) { - v18 = nil + var tmp18 any + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("contains?")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.Apply(v8, []any{v4}) + tmp23 := lang.Apply(tmp21, []any{tmp22, v5}) + if lang.IsTruthy(tmp23) { } else { - var v24 any - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("contains?")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.Apply(v12, []any{v4}) - v29 := lang.Apply(v27, []any{v28, v5}) - if lang.IsTruthy(v29) { - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("print-str")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + var tmp24 any + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("contains?")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.Apply(v12, []any{v4}) + tmp29 := lang.Apply(tmp27, []any{tmp28, v5}) + if lang.IsTruthy(tmp29) { + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("print-str")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) } - v32 := v31.Get() - v33 := lang.Apply(v32, []any{v4, "already has", v5, "as ancestor"}) - v34 := lang.Apply(lang.NewError, []any{v33}) - panic(v34) + tmp32 := tmp31.Get() + tmp33 := lang.Apply(tmp32, []any{v4, "already has", v5, "as ancestor"}) + tmp34 := lang.Apply(lang.NewError, []any{tmp33}) + panic(tmp34) } else { - v24 = nil } - _ = v24 - var v35 any - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("contains?")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.Apply(v12, []any{v5}) - v40 := lang.Apply(v38, []any{v39, v4}) - if lang.IsTruthy(v40) { - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("print-str")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + _ = tmp24 + var tmp35 any + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("contains?")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.Apply(v12, []any{v5}) + tmp40 := lang.Apply(tmp38, []any{tmp39, v4}) + if lang.IsTruthy(tmp40) { + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("print-str")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) } - v43 := v42.Get() - v44 := lang.Apply(v43, []any{"Cyclic derivation:", v5, "has", v4, "as ancestor"}) - v45 := lang.Apply(lang.NewError, []any{v44}) - panic(v45) + tmp43 := tmp42.Get() + tmp44 := lang.Apply(tmp43, []any{"Cyclic derivation:", v5, "has", v4, "as ancestor"}) + tmp45 := lang.Apply(lang.NewError, []any{tmp44}) + panic(tmp45) } else { - v35 = nil } - _ = v35 - v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v47 := v46.FindInternedVar(lang.NewSymbol("assoc")) - if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) - } - v48 := v47.Get() - v49 := lang.Apply(lang.NewKeyword("parents"), []any{v3}) - v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v51 := v50.FindInternedVar(lang.NewSymbol("conj")) - if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) - } - v52 := v51.Get() - v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v54 := v53.FindInternedVar(lang.NewSymbol("get")) - if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) - } - v55 := v54.Get() - v56 := lang.CreatePersistentTreeSet() - v57 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5636), lang.NewKeyword("column"), int(61), lang.NewKeyword("end-line"), int(5636), lang.NewKeyword("end-column"), int(63)) - v58, err := lang.WithMeta(v56, v57.(lang.IPersistentMap)) + _ = tmp35 + tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp47 := tmp46.FindInternedVar(lang.NewSymbol("assoc")) + if tmp47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) + } + tmp48 := tmp47.Get() + tmp49 := lang.Apply(lang.NewKeyword("parents"), []any{v3}) + tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp51 := tmp50.FindInternedVar(lang.NewSymbol("conj")) + if tmp51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) + } + tmp52 := tmp51.Get() + tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp54 := tmp53.FindInternedVar(lang.NewSymbol("get")) + if tmp54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) + } + tmp55 := tmp54.Get() + tmp56 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp57 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5636), lang.NewKeyword("column"), int(61), lang.NewKeyword("end-line"), int(5636), lang.NewKeyword("end-column"), int(63)) + tmp58, err := lang.WithMeta(tmp56, tmp57.(lang.IPersistentMap)) if err != nil { panic(err) } - v59 := lang.Apply(v55, []any{v8, v4, v58}) - v60 := lang.Apply(v52, []any{v59, v5}) - v61 := lang.Apply(v48, []any{v49, v4, v60}) - v62 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) - v63 := lang.Apply(v16, []any{v62, v4, v10, v5, v12}) - v64 := lang.Apply(lang.NewKeyword("descendants"), []any{v3}) - v65 := lang.Apply(v16, []any{v64, v5, v12, v4, v10}) - v66 := lang.NewMap(lang.NewKeyword("parents"), v61, lang.NewKeyword("ancestors"), v63, lang.NewKeyword("descendants"), v65) - v67 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5636), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(5638), lang.NewKeyword("end-column"), int(61)) - v68, err := lang.WithMeta(v66, v67.(lang.IPersistentMap)) + tmp59 := lang.Apply(tmp55, []any{v8, v4, tmp58}) + tmp60 := lang.Apply(tmp52, []any{tmp59, v5}) + tmp61 := lang.Apply(tmp48, []any{tmp49, v4, tmp60}) + tmp62 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) + tmp63 := lang.Apply(v16, []any{tmp62, v4, v10, v5, v12}) + tmp64 := lang.Apply(lang.NewKeyword("descendants"), []any{v3}) + tmp65 := lang.Apply(v16, []any{tmp64, v5, v12, v4, v10}) + tmp66 := lang.NewMap(lang.NewKeyword("parents"), tmp61, lang.NewKeyword("ancestors"), tmp63, lang.NewKeyword("descendants"), tmp65) + tmp67 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5636), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(5638), lang.NewKeyword("end-column"), int(61)) + tmp68, err := lang.WithMeta(tmp66, tmp67.(lang.IPersistentMap)) if err != nil { panic(err) } - v18 = v68 + tmp18 = tmp68 } - var v69 any = v18 + var v69 any = tmp18 _ = v69 - var v70 any + var tmp70 any if lang.IsTruthy(v69) { - v70 = v69 + tmp70 = v69 } else { - v70 = v3 + tmp70 = v3 } - v17 = v70 + tmp17 = tmp70 } // end let - v6 = v17 + tmp6 = tmp17 } // end let - return v6 + return tmp6 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // descendants { - v0 := lang.NewSymbol("descendants").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"))), lang.NewKeyword("doc"), "Returns the immediate and indirect children of tag, through a\n relationship established via derive. h must be a hierarchy obtained\n from make-hierarchy, if not supplied defaults to the global\n hierarchy. Note: does not work on Java type inheritance\n relationships.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5593), lang.NewKeyword("end-line"), int(5593))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("descendants").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"))), lang.NewKeyword("doc"), "Returns the immediate and indirect children of tag, through a\n relationship established via derive. h must be a hierarchy obtained\n from make-hierarchy, if not supplied defaults to the global\n hierarchy. Note: does not work on Java type inheritance\n relationships.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5593), lang.NewKeyword("end-line"), int(5593))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("descendants")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("global-hierarchy")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v6, []any{v9, v3}) - return v10 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("descendants")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("global-hierarchy")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp6, []any{tmp9, v3}) + return tmp10 case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - var v5 any - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("class?")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{v4}) - if lang.IsTruthy(v9) { - v10 := lang.Apply(lang.NewUnsupportedOperationError, []any{"Can't get descendants of classes"}) - panic(v10) + var tmp5 any + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("class?")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.Apply(tmp8, []any{v4}) + if lang.IsTruthy(tmp9) { + tmp10 := lang.Apply(lang.NewUnsupportedOperationError, []any{"Can't get descendants of classes"}) + panic(tmp10) } else { - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("not-empty")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("get")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(lang.NewKeyword("descendants"), []any{v3}) - v18 := lang.Apply(v16, []any{v17, v4}) - v19 := lang.Apply(v13, []any{v18}) - v5 = v19 - } - return v5 + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("not-empty")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("get")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(lang.NewKeyword("descendants"), []any{v3}) + tmp18 := lang.Apply(tmp16, []any{tmp17, v4}) + tmp19 := lang.Apply(tmp13, []any{tmp18}) + tmp5 = tmp19 + } + return tmp5 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // destructure { - v0 := lang.NewSymbol("destructure").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4400), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(4400), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("destructure").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4400), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(4400), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any + var tmp4 any { // let // let binding "bents" - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("partition")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{int64(2), v3}) - var v9 any = v8 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("partition")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{int64(2), v3}) + var v9 any = tmp8 _ = v9 // let binding "pb" - var v10 lang.FnFunc + var tmp10 lang.FnFunc { // function pb - v10 = lang.NewFnFunc(func(args ...any) any { + var v11 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { if len(args) != 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -25581,11 +25677,11 @@ func init() { _ = v13 v14 := args[2] _ = v14 - var v15 any + var tmp15 any { // let // let binding "pvec" - var v16 lang.FnFunc - v16 = lang.NewFnFunc(func(args ...any) any { + var tmp16 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { if len(args) != 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -25595,92 +25691,92 @@ func init() { _ = v18 v19 := args[2] _ = v19 - var v20 any + var tmp20 any { // let // let binding "gvec" - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("gensym")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("gensym")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) } - v23 := v22.Get() - v24 := lang.Apply(v23, []any{"vec__"}) - var v25 any = v24 + tmp23 := tmp22.Get() + tmp24 := lang.Apply(tmp23, []any{"vec__"}) + var v25 any = tmp24 _ = v25 // let binding "gseq" - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("gensym")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("gensym")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) } - v28 := v27.Get() - v29 := lang.Apply(v28, []any{"seq__"}) - var v30 any = v29 + tmp28 := tmp27.Get() + tmp29 := lang.Apply(tmp28, []any{"seq__"}) + var v30 any = tmp29 _ = v30 // let binding "gfirst" - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("gensym")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("gensym")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{"first__"}) - var v35 any = v34 + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{"first__"}) + var v35 any = tmp34 _ = v35 // let binding "has-rest" - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("some")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("some")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) } - v38 := v37.Get() - v39 := lang.CreatePersistentTreeSet(lang.NewSymbol("&")) - v40 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4408), lang.NewKeyword("column"), int(43), lang.NewKeyword("end-line"), int(4408), lang.NewKeyword("end-column"), int(47)) - v41, err := lang.WithMeta(v39, v40.(lang.IPersistentMap)) + tmp38 := tmp37.Get() + tmp39 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{lang.NewSymbol("&")})) + tmp40 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4408), lang.NewKeyword("column"), int(43), lang.NewKeyword("end-line"), int(4408), lang.NewKeyword("end-column"), int(47)) + tmp41, err := lang.WithMeta(tmp39, tmp40.(lang.IPersistentMap)) if err != nil { panic(err) } - v42 := lang.Apply(v38, []any{v41, v18}) - var v43 any = v42 + tmp42 := lang.Apply(tmp38, []any{tmp41, v18}) + var v43 any = tmp42 _ = v43 - var v44 any + var tmp44 any { // let // let binding "ret" - var v45 any + var tmp45 any { // let // let binding "ret" - v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v47 := v46.FindInternedVar(lang.NewSymbol("conj")) - if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) + tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp47 := tmp46.FindInternedVar(lang.NewSymbol("conj")) + if tmp47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) } - v48 := v47.Get() - v49 := lang.Apply(v48, []any{v17, v25, v19}) - var v50 any = v49 + tmp48 := tmp47.Get() + tmp49 := lang.Apply(tmp48, []any{v17, v25, v19}) + var v50 any = tmp49 _ = v50 - var v51 any + var tmp51 any if lang.IsTruthy(v43) { - v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v53 := v52.FindInternedVar(lang.NewSymbol("conj")) - if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) + tmp52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp53 := tmp52.FindInternedVar(lang.NewSymbol("conj")) + if tmp53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp53))) } - v54 := v53.Get() - v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v56 := v55.FindInternedVar(lang.NewSymbol("list")) - if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) + tmp54 := tmp53.Get() + tmp55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp56 := tmp55.FindInternedVar(lang.NewSymbol("list")) + if tmp56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp56))) } - v57 := v56.Get() - v58 := lang.Apply(v57, []any{lang.NewSymbol("glojure.core/seq"), v25}) - v59 := lang.Apply(v54, []any{v50, v30, v58}) - v51 = v59 + tmp57 := tmp56.Get() + tmp58 := lang.Apply(tmp57, []any{lang.NewSymbol("glojure.core/seq"), v25}) + tmp59 := lang.Apply(tmp54, []any{v50, v30, tmp58}) + tmp51 = tmp59 } else { - v51 = v50 + tmp51 = v50 } - v45 = v51 + tmp45 = tmp51 } // end let - var v46 any = v45 + var v46 any = tmp45 _ = v46 // let binding "n" var v47 any = int64(0) @@ -25692,226 +25788,225 @@ func init() { var v49 any = false _ = v49 for { - var v50 any - v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v52 := v51.FindInternedVar(lang.NewSymbol("seq")) - if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) + var tmp50 any + tmp51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp52 := tmp51.FindInternedVar(lang.NewSymbol("seq")) + if tmp52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp52))) } - v53 := v52.Get() - v54 := lang.Apply(v53, []any{v48}) - if lang.IsTruthy(v54) { - var v55 any + tmp53 := tmp52.Get() + tmp54 := lang.Apply(tmp53, []any{v48}) + if lang.IsTruthy(tmp54) { + var tmp55 any { // let // let binding "firstb" - v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v57 := v56.FindInternedVar(lang.NewSymbol("first")) - if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) + tmp56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp57 := tmp56.FindInternedVar(lang.NewSymbol("first")) + if tmp57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp57))) } - v58 := v57.Get() - v59 := lang.Apply(v58, []any{v48}) - var v60 any = v59 + tmp58 := tmp57.Get() + tmp59 := lang.Apply(tmp58, []any{v48}) + var v60 any = tmp59 _ = v60 - var v61 any - v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v63 := v62.FindInternedVar(lang.NewSymbol("=")) - if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) + var tmp61 any + tmp62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp63 := tmp62.FindInternedVar(lang.NewSymbol("=")) + if tmp63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp63))) } - v64 := v63.Get() - v65 := lang.Apply(v64, []any{v60, lang.NewSymbol("&")}) - if lang.IsTruthy(v65) { - v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v68 := v67.FindInternedVar(lang.NewSymbol("second")) - if v68.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) + tmp64 := tmp63.Get() + tmp65 := lang.Apply(tmp64, []any{v60, lang.NewSymbol("&")}) + if lang.IsTruthy(tmp65) { + tmp67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp68 := tmp67.FindInternedVar(lang.NewSymbol("second")) + if tmp68.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp68))) } - v69 := v68.Get() - v70 := lang.Apply(v69, []any{v48}) - v71 := lang.Apply(v11, []any{v46, v70, v30}) - var v66 any = v71 - var v72 any = v47 - v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v75 := v74.FindInternedVar(lang.NewSymbol("nnext")) - if v75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) + tmp69 := tmp68.Get() + tmp70 := lang.Apply(tmp69, []any{v48}) + tmp71 := lang.Apply(v11, []any{v46, tmp70, v30}) + var tmp66 any = tmp71 + var tmp72 any = v47 + tmp74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp75 := tmp74.FindInternedVar(lang.NewSymbol("nnext")) + if tmp75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp75))) } - v76 := v75.Get() - v77 := lang.Apply(v76, []any{v48}) - var v73 any = v77 - var v78 any = true - v46 = v66 - v47 = v72 - v48 = v73 - v49 = v78 + tmp76 := tmp75.Get() + tmp77 := lang.Apply(tmp76, []any{v48}) + var tmp73 any = tmp77 + var tmp78 any = true + v46 = tmp66 + v47 = tmp72 + v48 = tmp73 + v49 = tmp78 continue } else { - var v79 any - v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v81 := v80.FindInternedVar(lang.NewSymbol("=")) - if v81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) + var tmp79 any + tmp80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp81 := tmp80.FindInternedVar(lang.NewSymbol("=")) + if tmp81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp81))) } - v82 := v81.Get() - v83 := lang.Apply(v82, []any{v60, lang.NewKeyword("as")}) - if lang.IsTruthy(v83) { - v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v85 := v84.FindInternedVar(lang.NewSymbol("second")) - if v85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) + tmp82 := tmp81.Get() + tmp83 := lang.Apply(tmp82, []any{v60, lang.NewKeyword("as")}) + if lang.IsTruthy(tmp83) { + tmp84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp85 := tmp84.FindInternedVar(lang.NewSymbol("second")) + if tmp85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp85))) } - v86 := v85.Get() - v87 := lang.Apply(v86, []any{v48}) - v88 := lang.Apply(v11, []any{v46, v87, v25}) - v79 = v88 + tmp86 := tmp85.Get() + tmp87 := lang.Apply(tmp86, []any{v48}) + tmp88 := lang.Apply(v11, []any{v46, tmp87, v25}) + tmp79 = tmp88 } else { - var v89 any + var tmp89 any if lang.IsTruthy(lang.NewKeyword("else")) { - var v90 any + var tmp90 any if lang.IsTruthy(v49) { - v91 := lang.Apply(errors5.New, []any{"Unsupported binding form, only :as can follow & parameter"}) - panic(v91) + tmp91 := lang.Apply(errors5.New, []any{"Unsupported binding form, only :as can follow & parameter"}) + panic(tmp91) } else { - var v93 any + var tmp93 any if lang.IsTruthy(v43) { - v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v95 := v94.FindInternedVar(lang.NewSymbol("conj")) - if v95.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) + tmp94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp95 := tmp94.FindInternedVar(lang.NewSymbol("conj")) + if tmp95.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp95))) } - v96 := v95.Get() - v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v98 := v97.FindInternedVar(lang.NewSymbol("seq")) - if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) + tmp96 := tmp95.Get() + tmp97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp98 := tmp97.FindInternedVar(lang.NewSymbol("seq")) + if tmp98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp98))) } - v99 := v98.Get() - v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v101 := v100.FindInternedVar(lang.NewSymbol("concat")) - if v101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) + tmp99 := tmp98.Get() + tmp100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp101 := tmp100.FindInternedVar(lang.NewSymbol("concat")) + if tmp101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp101))) } - v102 := v101.Get() - v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v104 := v103.FindInternedVar(lang.NewSymbol("list")) - if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) + tmp102 := tmp101.Get() + tmp103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp104 := tmp103.FindInternedVar(lang.NewSymbol("list")) + if tmp104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp104))) } - v105 := v104.Get() - v106 := lang.Apply(v105, []any{lang.NewSymbol("glojure.core/first")}) - v107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v108 := v107.FindInternedVar(lang.NewSymbol("list")) - if v108.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v108))) + tmp105 := tmp104.Get() + tmp106 := lang.Apply(tmp105, []any{lang.NewSymbol("glojure.core/first")}) + tmp107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp108 := tmp107.FindInternedVar(lang.NewSymbol("list")) + if tmp108.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp108))) } - v109 := v108.Get() - v110 := lang.Apply(v109, []any{v30}) - v111 := lang.Apply(v102, []any{v106, v110}) - v112 := lang.Apply(v99, []any{v111}) - v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v114 := v113.FindInternedVar(lang.NewSymbol("seq")) - if v114.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) + tmp109 := tmp108.Get() + tmp110 := lang.Apply(tmp109, []any{v30}) + tmp111 := lang.Apply(tmp102, []any{tmp106, tmp110}) + tmp112 := lang.Apply(tmp99, []any{tmp111}) + tmp113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp114 := tmp113.FindInternedVar(lang.NewSymbol("seq")) + if tmp114.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp114))) } - v115 := v114.Get() - v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v117 := v116.FindInternedVar(lang.NewSymbol("concat")) - if v117.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) + tmp115 := tmp114.Get() + tmp116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp117 := tmp116.FindInternedVar(lang.NewSymbol("concat")) + if tmp117.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp117))) } - v118 := v117.Get() - v119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v120 := v119.FindInternedVar(lang.NewSymbol("list")) - if v120.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v120))) + tmp118 := tmp117.Get() + tmp119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp120 := tmp119.FindInternedVar(lang.NewSymbol("list")) + if tmp120.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp120))) } - v121 := v120.Get() - v122 := lang.Apply(v121, []any{lang.NewSymbol("glojure.core/next")}) - v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v124 := v123.FindInternedVar(lang.NewSymbol("list")) - if v124.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) + tmp121 := tmp120.Get() + tmp122 := lang.Apply(tmp121, []any{lang.NewSymbol("glojure.core/next")}) + tmp123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp124 := tmp123.FindInternedVar(lang.NewSymbol("list")) + if tmp124.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp124))) } - v125 := v124.Get() - v126 := lang.Apply(v125, []any{v30}) - v127 := lang.Apply(v118, []any{v122, v126}) - v128 := lang.Apply(v115, []any{v127}) - v129 := lang.Apply(v96, []any{v46, v35, v112, v30, v128}) - v93 = v129 + tmp125 := tmp124.Get() + tmp126 := lang.Apply(tmp125, []any{v30}) + tmp127 := lang.Apply(tmp118, []any{tmp122, tmp126}) + tmp128 := lang.Apply(tmp115, []any{tmp127}) + tmp129 := lang.Apply(tmp96, []any{v46, v35, tmp112, v30, tmp128}) + tmp93 = tmp129 } else { - v93 = v46 + tmp93 = v46 } - var v130 any + var tmp130 any if lang.IsTruthy(v43) { - v130 = v35 + tmp130 = v35 } else { - v131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v132 := v131.FindInternedVar(lang.NewSymbol("list")) - if v132.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v132))) + tmp131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp132 := tmp131.FindInternedVar(lang.NewSymbol("list")) + if tmp132.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp132))) } - v133 := v132.Get() - v134 := lang.Apply(v133, []any{lang.NewSymbol("glojure.core/nth"), v25, v47, nil}) - v130 = v134 + tmp133 := tmp132.Get() + tmp134 := lang.Apply(tmp133, []any{lang.NewSymbol("glojure.core/nth"), v25, v47, nil}) + tmp130 = tmp134 } - v135 := lang.Apply(v11, []any{v93, v60, v130}) - var v92 any = v135 - v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v138 := v137.FindInternedVar(lang.NewSymbol("inc")) - if v138.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) + tmp135 := lang.Apply(v11, []any{tmp93, v60, tmp130}) + var tmp92 any = tmp135 + tmp137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp138 := tmp137.FindInternedVar(lang.NewSymbol("inc")) + if tmp138.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp138))) } - v139 := v138.Get() - v140 := lang.Apply(v139, []any{v47}) - var v136 any = v140 - v142 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v143 := v142.FindInternedVar(lang.NewSymbol("next")) - if v143.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v143))) + tmp139 := tmp138.Get() + tmp140 := lang.Apply(tmp139, []any{v47}) + var tmp136 any = tmp140 + tmp142 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp143 := tmp142.FindInternedVar(lang.NewSymbol("next")) + if tmp143.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp143))) } - v144 := v143.Get() - v145 := lang.Apply(v144, []any{v48}) - var v141 any = v145 - var v146 any = v49 - v46 = v92 - v47 = v136 - v48 = v141 - v49 = v146 + tmp144 := tmp143.Get() + tmp145 := lang.Apply(tmp144, []any{v48}) + var tmp141 any = tmp145 + var tmp146 any = v49 + v46 = tmp92 + v47 = tmp136 + v48 = tmp141 + v49 = tmp146 continue } - v89 = v90 + tmp89 = tmp90 } else { - v89 = nil } - v79 = v89 + tmp79 = tmp89 } - v61 = v79 + tmp61 = tmp79 } - v55 = v61 + tmp55 = tmp61 } // end let - v50 = v55 + tmp50 = tmp55 } else { - v50 = v46 + tmp50 = v46 } - v44 = v50 + tmp44 = tmp50 break } } // end let - v20 = v44 + tmp20 = tmp44 } // end let - return v20 + return tmp20 }) - v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4404), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(4438), lang.NewKeyword("end-column"), int(34)) - v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) + tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4404), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(4438), lang.NewKeyword("end-column"), int(34)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) if err != nil { panic(err) } - var v19 any = v18 + var v19 any = tmp18 _ = v19 // let binding "pmap" - var v20 lang.FnFunc - v20 = lang.NewFnFunc(func(args ...any) any { + var tmp20 lang.FnFunc + tmp20 = lang.NewFnFunc(func(args ...any) any { if len(args) != 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -25921,407 +26016,407 @@ func init() { _ = v22 v23 := args[2] _ = v23 - var v24 any + var tmp24 any { // let // let binding "gmap" - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("gensym")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("gensym")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) } - v27 := v26.Get() - v28 := lang.Apply(v27, []any{"map__"}) - var v29 any = v28 + tmp27 := tmp26.Get() + tmp28 := lang.Apply(tmp27, []any{"map__"}) + var v29 any = tmp28 _ = v29 // let binding "gmapseq" - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("with-meta")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("with-meta")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) } - v32 := v31.Get() - v33 := lang.NewMap(lang.NewKeyword("tag"), lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.ISeq")) - v34 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4442), lang.NewKeyword("column"), int(52), lang.NewKeyword("end-line"), int(4442), lang.NewKeyword("end-column"), int(103)) - v35, err := lang.WithMeta(v33, v34.(lang.IPersistentMap)) + tmp32 := tmp31.Get() + tmp33 := lang.NewMap(lang.NewKeyword("tag"), lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.ISeq")) + tmp34 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4442), lang.NewKeyword("column"), int(52), lang.NewKeyword("end-line"), int(4442), lang.NewKeyword("end-column"), int(103)) + tmp35, err := lang.WithMeta(tmp33, tmp34.(lang.IPersistentMap)) if err != nil { panic(err) } - v36 := lang.Apply(v32, []any{v29, v35}) - var v37 any = v36 + tmp36 := lang.Apply(tmp32, []any{v29, tmp35}) + var v37 any = tmp36 _ = v37 // let binding "defaults" - v38 := lang.Apply(lang.NewKeyword("or"), []any{v22}) - var v39 any = v38 + tmp38 := lang.Apply(lang.NewKeyword("or"), []any{v22}) + var v39 any = tmp38 _ = v39 - var v40 any + var tmp40 any { // let // let binding "ret" - var v41 lang.FnFunc - v41 = lang.NewFnFunc(func(args ...any) any { + var tmp41 lang.FnFunc + tmp41 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v42 := args[0] _ = v42 - var v43 any - v44 := lang.Apply(lang.NewKeyword("as"), []any{v22}) - if lang.IsTruthy(v44) { - v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v46 := v45.FindInternedVar(lang.NewSymbol("conj")) - if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) + var tmp43 any + tmp44 := lang.Apply(lang.NewKeyword("as"), []any{v22}) + if lang.IsTruthy(tmp44) { + tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp46 := tmp45.FindInternedVar(lang.NewSymbol("conj")) + if tmp46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) } - v47 := v46.Get() - v48 := lang.Apply(lang.NewKeyword("as"), []any{v22}) - v49 := lang.Apply(v47, []any{v42, v48, v29}) - v43 = v49 + tmp47 := tmp46.Get() + tmp48 := lang.Apply(lang.NewKeyword("as"), []any{v22}) + tmp49 := lang.Apply(tmp47, []any{v42, tmp48, v29}) + tmp43 = tmp49 } else { - v43 = v42 + tmp43 = v42 } - return v43 + return tmp43 }) - v42 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4450), lang.NewKeyword("column"), int(40), lang.NewKeyword("end-line"), int(4453), lang.NewKeyword("end-column"), int(48)) - v43, err := lang.WithMeta(v41, v42.(lang.IPersistentMap)) + tmp42 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4450), lang.NewKeyword("column"), int(40), lang.NewKeyword("end-line"), int(4453), lang.NewKeyword("end-column"), int(48)) + tmp43, err := lang.WithMeta(tmp41, tmp42.(lang.IPersistentMap)) if err != nil { panic(err) } - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("conj")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("conj")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) } - v46 := v45.Get() - v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v48 := v47.FindInternedVar(lang.NewSymbol("conj")) - if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) + tmp46 := tmp45.Get() + tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp48 := tmp47.FindInternedVar(lang.NewSymbol("conj")) + if tmp48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) } - v49 := v48.Get() - v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v51 := v50.FindInternedVar(lang.NewSymbol("conj")) - if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) + tmp49 := tmp48.Get() + tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp51 := tmp50.FindInternedVar(lang.NewSymbol("conj")) + if tmp51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) } - v52 := v51.Get() - v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v54 := v53.FindInternedVar(lang.NewSymbol("conj")) - if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) + tmp52 := tmp51.Get() + tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp54 := tmp53.FindInternedVar(lang.NewSymbol("conj")) + if tmp54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) } - v55 := v54.Get() - v56 := lang.Apply(v55, []any{v21, v29}) - v57 := lang.Apply(v52, []any{v56, v23}) - v58 := lang.Apply(v49, []any{v57, v29}) - v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v60 := v59.FindInternedVar(lang.NewSymbol("seq")) - if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) + tmp55 := tmp54.Get() + tmp56 := lang.Apply(tmp55, []any{v21, v29}) + tmp57 := lang.Apply(tmp52, []any{tmp56, v23}) + tmp58 := lang.Apply(tmp49, []any{tmp57, v29}) + tmp59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp60 := tmp59.FindInternedVar(lang.NewSymbol("seq")) + if tmp60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp60))) } - v61 := v60.Get() - v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v63 := v62.FindInternedVar(lang.NewSymbol("concat")) - if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) + tmp61 := tmp60.Get() + tmp62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp63 := tmp62.FindInternedVar(lang.NewSymbol("concat")) + if tmp63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp63))) } - v64 := v63.Get() - v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v66 := v65.FindInternedVar(lang.NewSymbol("list")) - if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) + tmp64 := tmp63.Get() + tmp65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp66 := tmp65.FindInternedVar(lang.NewSymbol("list")) + if tmp66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp66))) } - v67 := v66.Get() - v68 := lang.Apply(v67, []any{lang.NewSymbol("if")}) - v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v70 := v69.FindInternedVar(lang.NewSymbol("list")) - if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) + tmp67 := tmp66.Get() + tmp68 := lang.Apply(tmp67, []any{lang.NewSymbol("if")}) + tmp69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp70 := tmp69.FindInternedVar(lang.NewSymbol("list")) + if tmp70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp70))) } - v71 := v70.Get() - v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v73 := v72.FindInternedVar(lang.NewSymbol("seq")) - if v73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) + tmp71 := tmp70.Get() + tmp72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp73 := tmp72.FindInternedVar(lang.NewSymbol("seq")) + if tmp73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp73))) } - v74 := v73.Get() - v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v76 := v75.FindInternedVar(lang.NewSymbol("concat")) - if v76.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) + tmp74 := tmp73.Get() + tmp75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp76 := tmp75.FindInternedVar(lang.NewSymbol("concat")) + if tmp76.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp76))) } - v77 := v76.Get() - v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v79 := v78.FindInternedVar(lang.NewSymbol("list")) - if v79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) + tmp77 := tmp76.Get() + tmp78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp79 := tmp78.FindInternedVar(lang.NewSymbol("list")) + if tmp79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp79))) } - v80 := v79.Get() - v81 := lang.Apply(v80, []any{lang.NewSymbol("glojure.core/seq?")}) - v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v83 := v82.FindInternedVar(lang.NewSymbol("list")) - if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) + tmp80 := tmp79.Get() + tmp81 := lang.Apply(tmp80, []any{lang.NewSymbol("glojure.core/seq?")}) + tmp82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp83 := tmp82.FindInternedVar(lang.NewSymbol("list")) + if tmp83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp83))) } - v84 := v83.Get() - v85 := lang.Apply(v84, []any{v29}) - v86 := lang.Apply(v77, []any{v81, v85}) - v87 := lang.Apply(v74, []any{v86}) - v88 := lang.Apply(v71, []any{v87}) - v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v90 := v89.FindInternedVar(lang.NewSymbol("list")) - if v90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) + tmp84 := tmp83.Get() + tmp85 := lang.Apply(tmp84, []any{v29}) + tmp86 := lang.Apply(tmp77, []any{tmp81, tmp85}) + tmp87 := lang.Apply(tmp74, []any{tmp86}) + tmp88 := lang.Apply(tmp71, []any{tmp87}) + tmp89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp90 := tmp89.FindInternedVar(lang.NewSymbol("list")) + if tmp90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp90))) } - v91 := v90.Get() - v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v93 := v92.FindInternedVar(lang.NewSymbol("seq")) - if v93.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) + tmp91 := tmp90.Get() + tmp92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp93 := tmp92.FindInternedVar(lang.NewSymbol("seq")) + if tmp93.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp93))) } - v94 := v93.Get() - v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v96 := v95.FindInternedVar(lang.NewSymbol("concat")) - if v96.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) + tmp94 := tmp93.Get() + tmp95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp96 := tmp95.FindInternedVar(lang.NewSymbol("concat")) + if tmp96.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp96))) } - v97 := v96.Get() - v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v99 := v98.FindInternedVar(lang.NewSymbol("list")) - if v99.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) + tmp97 := tmp96.Get() + tmp98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp99 := tmp98.FindInternedVar(lang.NewSymbol("list")) + if tmp99.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp99))) } - v100 := v99.Get() - v101 := lang.Apply(v100, []any{lang.NewSymbol("if")}) - v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v103 := v102.FindInternedVar(lang.NewSymbol("list")) - if v103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) + tmp100 := tmp99.Get() + tmp101 := lang.Apply(tmp100, []any{lang.NewSymbol("if")}) + tmp102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp103 := tmp102.FindInternedVar(lang.NewSymbol("list")) + if tmp103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp103))) } - v104 := v103.Get() - v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v106 := v105.FindInternedVar(lang.NewSymbol("seq")) - if v106.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) + tmp104 := tmp103.Get() + tmp105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp106 := tmp105.FindInternedVar(lang.NewSymbol("seq")) + if tmp106.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp106))) } - v107 := v106.Get() - v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v109 := v108.FindInternedVar(lang.NewSymbol("concat")) - if v109.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) + tmp107 := tmp106.Get() + tmp108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp109 := tmp108.FindInternedVar(lang.NewSymbol("concat")) + if tmp109.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp109))) } - v110 := v109.Get() - v111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v112 := v111.FindInternedVar(lang.NewSymbol("list")) - if v112.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v112))) + tmp110 := tmp109.Get() + tmp111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp112 := tmp111.FindInternedVar(lang.NewSymbol("list")) + if tmp112.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp112))) } - v113 := v112.Get() - v114 := lang.Apply(v113, []any{lang.NewSymbol("glojure.core/next")}) - v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v116 := v115.FindInternedVar(lang.NewSymbol("list")) - if v116.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) + tmp113 := tmp112.Get() + tmp114 := lang.Apply(tmp113, []any{lang.NewSymbol("glojure.core/next")}) + tmp115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp116 := tmp115.FindInternedVar(lang.NewSymbol("list")) + if tmp116.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp116))) } - v117 := v116.Get() - v118 := lang.Apply(v117, []any{v37}) - v119 := lang.Apply(v110, []any{v114, v118}) - v120 := lang.Apply(v107, []any{v119}) - v121 := lang.Apply(v104, []any{v120}) - v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v123 := v122.FindInternedVar(lang.NewSymbol("list")) - if v123.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) + tmp117 := tmp116.Get() + tmp118 := lang.Apply(tmp117, []any{v37}) + tmp119 := lang.Apply(tmp110, []any{tmp114, tmp118}) + tmp120 := lang.Apply(tmp107, []any{tmp119}) + tmp121 := lang.Apply(tmp104, []any{tmp120}) + tmp122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp123 := tmp122.FindInternedVar(lang.NewSymbol("list")) + if tmp123.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp123))) } - v124 := v123.Get() - v125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v126 := v125.FindInternedVar(lang.NewSymbol("seq")) - if v126.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v126))) + tmp124 := tmp123.Get() + tmp125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp126 := tmp125.FindInternedVar(lang.NewSymbol("seq")) + if tmp126.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp126))) } - v127 := v126.Get() - v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v129 := v128.FindInternedVar(lang.NewSymbol("concat")) - if v129.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v129))) + tmp127 := tmp126.Get() + tmp128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp129 := tmp128.FindInternedVar(lang.NewSymbol("concat")) + if tmp129.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp129))) } - v130 := v129.Get() - v131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v132 := v131.FindInternedVar(lang.NewSymbol("list")) - if v132.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v132))) + tmp130 := tmp129.Get() + tmp131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp132 := tmp131.FindInternedVar(lang.NewSymbol("list")) + if tmp132.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp132))) } - v133 := v132.Get() - v134 := lang.Apply(v133, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewPersistentArrayMapAsIfByAssoc")}) - v135 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v136 := v135.FindInternedVar(lang.NewSymbol("list")) - if v136.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v136))) + tmp133 := tmp132.Get() + tmp134 := lang.Apply(tmp133, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewPersistentArrayMapAsIfByAssoc")}) + tmp135 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp136 := tmp135.FindInternedVar(lang.NewSymbol("list")) + if tmp136.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp136))) } - v137 := v136.Get() - v138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v139 := v138.FindInternedVar(lang.NewSymbol("seq")) - if v139.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v139))) + tmp137 := tmp136.Get() + tmp138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp139 := tmp138.FindInternedVar(lang.NewSymbol("seq")) + if tmp139.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp139))) } - v140 := v139.Get() - v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v142 := v141.FindInternedVar(lang.NewSymbol("concat")) - if v142.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) + tmp140 := tmp139.Get() + tmp141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp142 := tmp141.FindInternedVar(lang.NewSymbol("concat")) + if tmp142.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp142))) } - v143 := v142.Get() - v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v145 := v144.FindInternedVar(lang.NewSymbol("list")) - if v145.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) + tmp143 := tmp142.Get() + tmp144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp145 := tmp144.FindInternedVar(lang.NewSymbol("list")) + if tmp145.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp145))) } - v146 := v145.Get() - v147 := lang.Apply(v146, []any{lang.NewSymbol("glojure.core/to-array")}) - v148 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v149 := v148.FindInternedVar(lang.NewSymbol("list")) - if v149.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v149))) + tmp146 := tmp145.Get() + tmp147 := lang.Apply(tmp146, []any{lang.NewSymbol("glojure.core/to-array")}) + tmp148 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp149 := tmp148.FindInternedVar(lang.NewSymbol("list")) + if tmp149.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp149))) } - v150 := v149.Get() - v151 := lang.Apply(v150, []any{v37}) - v152 := lang.Apply(v143, []any{v147, v151}) - v153 := lang.Apply(v140, []any{v152}) - v154 := lang.Apply(v137, []any{v153}) - v155 := lang.Apply(v130, []any{v134, v154}) - v156 := lang.Apply(v127, []any{v155}) - v157 := lang.Apply(v124, []any{v156}) - v158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v159 := v158.FindInternedVar(lang.NewSymbol("list")) - if v159.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v159))) + tmp150 := tmp149.Get() + tmp151 := lang.Apply(tmp150, []any{v37}) + tmp152 := lang.Apply(tmp143, []any{tmp147, tmp151}) + tmp153 := lang.Apply(tmp140, []any{tmp152}) + tmp154 := lang.Apply(tmp137, []any{tmp153}) + tmp155 := lang.Apply(tmp130, []any{tmp134, tmp154}) + tmp156 := lang.Apply(tmp127, []any{tmp155}) + tmp157 := lang.Apply(tmp124, []any{tmp156}) + tmp158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp159 := tmp158.FindInternedVar(lang.NewSymbol("list")) + if tmp159.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp159))) } - v160 := v159.Get() - v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v162 := v161.FindInternedVar(lang.NewSymbol("seq")) - if v162.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) + tmp160 := tmp159.Get() + tmp161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp162 := tmp161.FindInternedVar(lang.NewSymbol("seq")) + if tmp162.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp162))) } - v163 := v162.Get() - v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v165 := v164.FindInternedVar(lang.NewSymbol("concat")) - if v165.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) + tmp163 := tmp162.Get() + tmp164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp165 := tmp164.FindInternedVar(lang.NewSymbol("concat")) + if tmp165.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp165))) } - v166 := v165.Get() - v167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v168 := v167.FindInternedVar(lang.NewSymbol("list")) - if v168.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v168))) + tmp166 := tmp165.Get() + tmp167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp168 := tmp167.FindInternedVar(lang.NewSymbol("list")) + if tmp168.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp168))) } - v169 := v168.Get() - v170 := lang.Apply(v169, []any{lang.NewSymbol("if")}) - v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v172 := v171.FindInternedVar(lang.NewSymbol("list")) - if v172.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) + tmp169 := tmp168.Get() + tmp170 := lang.Apply(tmp169, []any{lang.NewSymbol("if")}) + tmp171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp172 := tmp171.FindInternedVar(lang.NewSymbol("list")) + if tmp172.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp172))) } - v173 := v172.Get() - v174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v175 := v174.FindInternedVar(lang.NewSymbol("seq")) - if v175.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v175))) + tmp173 := tmp172.Get() + tmp174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp175 := tmp174.FindInternedVar(lang.NewSymbol("seq")) + if tmp175.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp175))) } - v176 := v175.Get() - v177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v178 := v177.FindInternedVar(lang.NewSymbol("concat")) - if v178.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v178))) + tmp176 := tmp175.Get() + tmp177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp178 := tmp177.FindInternedVar(lang.NewSymbol("concat")) + if tmp178.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp178))) } - v179 := v178.Get() - v180 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v181 := v180.FindInternedVar(lang.NewSymbol("list")) - if v181.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v181))) + tmp179 := tmp178.Get() + tmp180 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp181 := tmp180.FindInternedVar(lang.NewSymbol("list")) + if tmp181.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp181))) } - v182 := v181.Get() - v183 := lang.Apply(v182, []any{lang.NewSymbol("glojure.core/seq")}) - v184 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v185 := v184.FindInternedVar(lang.NewSymbol("list")) - if v185.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v185))) + tmp182 := tmp181.Get() + tmp183 := lang.Apply(tmp182, []any{lang.NewSymbol("glojure.core/seq")}) + tmp184 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp185 := tmp184.FindInternedVar(lang.NewSymbol("list")) + if tmp185.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp185))) } - v186 := v185.Get() - v187 := lang.Apply(v186, []any{v37}) - v188 := lang.Apply(v179, []any{v183, v187}) - v189 := lang.Apply(v176, []any{v188}) - v190 := lang.Apply(v173, []any{v189}) - v191 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v192 := v191.FindInternedVar(lang.NewSymbol("list")) - if v192.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v192))) + tmp186 := tmp185.Get() + tmp187 := lang.Apply(tmp186, []any{v37}) + tmp188 := lang.Apply(tmp179, []any{tmp183, tmp187}) + tmp189 := lang.Apply(tmp176, []any{tmp188}) + tmp190 := lang.Apply(tmp173, []any{tmp189}) + tmp191 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp192 := tmp191.FindInternedVar(lang.NewSymbol("list")) + if tmp192.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp192))) } - v193 := v192.Get() - v194 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v195 := v194.FindInternedVar(lang.NewSymbol("seq")) - if v195.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v195))) + tmp193 := tmp192.Get() + tmp194 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp195 := tmp194.FindInternedVar(lang.NewSymbol("seq")) + if tmp195.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp195))) } - v196 := v195.Get() - v197 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v198 := v197.FindInternedVar(lang.NewSymbol("concat")) - if v198.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v198))) + tmp196 := tmp195.Get() + tmp197 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp198 := tmp197.FindInternedVar(lang.NewSymbol("concat")) + if tmp198.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp198))) } - v199 := v198.Get() - v200 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v201 := v200.FindInternedVar(lang.NewSymbol("list")) - if v201.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v201))) + tmp199 := tmp198.Get() + tmp200 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp201 := tmp200.FindInternedVar(lang.NewSymbol("list")) + if tmp201.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp201))) } - v202 := v201.Get() - v203 := lang.Apply(v202, []any{lang.NewSymbol("glojure.core/first")}) - v204 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v205 := v204.FindInternedVar(lang.NewSymbol("list")) - if v205.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v205))) + tmp202 := tmp201.Get() + tmp203 := lang.Apply(tmp202, []any{lang.NewSymbol("glojure.core/first")}) + tmp204 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp205 := tmp204.FindInternedVar(lang.NewSymbol("list")) + if tmp205.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp205))) } - v206 := v205.Get() - v207 := lang.Apply(v206, []any{v37}) - v208 := lang.Apply(v199, []any{v203, v207}) - v209 := lang.Apply(v196, []any{v208}) - v210 := lang.Apply(v193, []any{v209}) - v211 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v212 := v211.FindInternedVar(lang.NewSymbol("list")) - if v212.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v212))) + tmp206 := tmp205.Get() + tmp207 := lang.Apply(tmp206, []any{v37}) + tmp208 := lang.Apply(tmp199, []any{tmp203, tmp207}) + tmp209 := lang.Apply(tmp196, []any{tmp208}) + tmp210 := lang.Apply(tmp193, []any{tmp209}) + tmp211 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp212 := tmp211.FindInternedVar(lang.NewSymbol("list")) + if tmp212.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp212))) } - v213 := v212.Get() - v214 := lang.Apply(v213, []any{lang.NewSymbol("glojure.lang.PersistentArrayMap/EMPTY")}) - v215 := lang.Apply(v166, []any{v170, v190, v210, v214}) - v216 := lang.Apply(v163, []any{v215}) - v217 := lang.Apply(v160, []any{v216}) - v218 := lang.Apply(v97, []any{v101, v121, v157, v217}) - v219 := lang.Apply(v94, []any{v218}) - v220 := lang.Apply(v91, []any{v219}) - v221 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v222 := v221.FindInternedVar(lang.NewSymbol("list")) - if v222.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v222))) + tmp213 := tmp212.Get() + tmp214 := lang.Apply(tmp213, []any{lang.NewSymbol("glojure.lang.PersistentArrayMap/EMPTY")}) + tmp215 := lang.Apply(tmp166, []any{tmp170, tmp190, tmp210, tmp214}) + tmp216 := lang.Apply(tmp163, []any{tmp215}) + tmp217 := lang.Apply(tmp160, []any{tmp216}) + tmp218 := lang.Apply(tmp97, []any{tmp101, tmp121, tmp157, tmp217}) + tmp219 := lang.Apply(tmp94, []any{tmp218}) + tmp220 := lang.Apply(tmp91, []any{tmp219}) + tmp221 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp222 := tmp221.FindInternedVar(lang.NewSymbol("list")) + if tmp222.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp222))) } - v223 := v222.Get() - v224 := lang.Apply(v223, []any{v29}) - v225 := lang.Apply(v64, []any{v68, v88, v220, v224}) - v226 := lang.Apply(v61, []any{v225}) - v227 := lang.Apply(v46, []any{v58, v226}) - v228 := lang.Apply(v43, []any{v227}) - var v229 any = v228 + tmp223 := tmp222.Get() + tmp224 := lang.Apply(tmp223, []any{v29}) + tmp225 := lang.Apply(tmp64, []any{tmp68, tmp88, tmp220, tmp224}) + tmp226 := lang.Apply(tmp61, []any{tmp225}) + tmp227 := lang.Apply(tmp46, []any{tmp58, tmp226}) + tmp228 := lang.Apply(tmp43, []any{tmp227}) + var v229 any = tmp228 _ = v229 // let binding "bes" - var v230 any + var tmp230 any { // let // let binding "transforms" - v231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v232 := v231.FindInternedVar(lang.NewSymbol("reduce1")) - if v232.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v232))) + tmp231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp232 := tmp231.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp232.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp232))) } - v233 := v232.Get() - var v234 lang.FnFunc - v234 = lang.NewFnFunc(func(args ...any) any { + tmp233 := tmp232.Get() + var tmp234 lang.FnFunc + tmp234 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -26329,249 +26424,248 @@ func init() { _ = v235 v236 := args[1] _ = v236 - var v237 any - v238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v239 := v238.FindInternedVar(lang.NewSymbol("keyword?")) - if v239.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v239))) + var tmp237 any + tmp238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp239 := tmp238.FindInternedVar(lang.NewSymbol("keyword?")) + if tmp239.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp239))) } - v240 := v239.Get() - v241 := lang.Apply(v240, []any{v236}) - if lang.IsTruthy(v241) { - var v242 any + tmp240 := tmp239.Get() + tmp241 := lang.Apply(tmp240, []any{v236}) + if lang.IsTruthy(tmp241) { + var tmp242 any { // let // let binding "mkns" - v243 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v244 := v243.FindInternedVar(lang.NewSymbol("namespace")) - if v244.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v244))) + tmp243 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp244 := tmp243.FindInternedVar(lang.NewSymbol("namespace")) + if tmp244.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp244))) } - v245 := v244.Get() - v246 := lang.Apply(v245, []any{v236}) - var v247 any = v246 + tmp245 := tmp244.Get() + tmp246 := lang.Apply(tmp245, []any{v236}) + var v247 any = tmp246 _ = v247 // let binding "mkn" - v248 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v249 := v248.FindInternedVar(lang.NewSymbol("name")) - if v249.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v249))) + tmp248 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp249 := tmp248.FindInternedVar(lang.NewSymbol("name")) + if tmp249.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp249))) } - v250 := v249.Get() - v251 := lang.Apply(v250, []any{v236}) - var v252 any = v251 + tmp250 := tmp249.Get() + tmp251 := lang.Apply(tmp250, []any{v236}) + var v252 any = tmp251 _ = v252 - var v253 any - v254 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v255 := v254.FindInternedVar(lang.NewSymbol("=")) - if v255.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v255))) + var tmp253 any + tmp254 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp255 := tmp254.FindInternedVar(lang.NewSymbol("=")) + if tmp255.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp255))) } - v256 := v255.Get() - v257 := lang.Apply(v256, []any{v252, "keys"}) - if lang.IsTruthy(v257) { - v258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v259 := v258.FindInternedVar(lang.NewSymbol("assoc")) - if v259.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v259))) + tmp256 := tmp255.Get() + tmp257 := lang.Apply(tmp256, []any{v252, "keys"}) + if lang.IsTruthy(tmp257) { + tmp258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp259 := tmp258.FindInternedVar(lang.NewSymbol("assoc")) + if tmp259.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp259))) } - v260 := v259.Get() - var v261 lang.FnFunc - v261 = lang.NewFnFunc(func(args ...any) any { + tmp260 := tmp259.Get() + var tmp261 lang.FnFunc + tmp261 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v262 := args[0] _ = v262 - v263 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v264 := v263.FindInternedVar(lang.NewSymbol("keyword")) - if v264.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v264))) + tmp263 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp264 := tmp263.FindInternedVar(lang.NewSymbol("keyword")) + if tmp264.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp264))) } - v265 := v264.Get() - var v266 any + tmp265 := tmp264.Get() + var tmp266 any { // let // let binding "or__0__auto__" var v267 any = v247 _ = v267 - var v268 any + var tmp268 any if lang.IsTruthy(v267) { - v268 = v267 + tmp268 = v267 } else { - v269 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v270 := v269.FindInternedVar(lang.NewSymbol("namespace")) - if v270.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v270))) + tmp269 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp270 := tmp269.FindInternedVar(lang.NewSymbol("namespace")) + if tmp270.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp270))) } - v271 := v270.Get() - v272 := lang.Apply(v271, []any{v262}) - v268 = v272 + tmp271 := tmp270.Get() + tmp272 := lang.Apply(tmp271, []any{v262}) + tmp268 = tmp272 } - v266 = v268 + tmp266 = tmp268 } // end let - v267 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v268 := v267.FindInternedVar(lang.NewSymbol("name")) - if v268.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v268))) + tmp267 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp268 := tmp267.FindInternedVar(lang.NewSymbol("name")) + if tmp268.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp268))) } - v269 := v268.Get() - v270 := lang.Apply(v269, []any{v262}) - v271 := lang.Apply(v265, []any{v266, v270}) - return v271 + tmp269 := tmp268.Get() + tmp270 := lang.Apply(tmp269, []any{v262}) + tmp271 := lang.Apply(tmp265, []any{tmp266, tmp270}) + return tmp271 }) - v262 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4460), lang.NewKeyword("column"), int(93), lang.NewKeyword("end-line"), int(4460), lang.NewKeyword("end-column"), int(135)) - v263, err := lang.WithMeta(v261, v262.(lang.IPersistentMap)) + tmp262 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4460), lang.NewKeyword("column"), int(93), lang.NewKeyword("end-line"), int(4460), lang.NewKeyword("end-column"), int(135)) + tmp263, err := lang.WithMeta(tmp261, tmp262.(lang.IPersistentMap)) if err != nil { panic(err) } - v264 := lang.Apply(v260, []any{v235, v236, v263}) - v253 = v264 + tmp264 := lang.Apply(tmp260, []any{v235, v236, tmp263}) + tmp253 = tmp264 } else { - var v265 any - v266 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v267 := v266.FindInternedVar(lang.NewSymbol("=")) - if v267.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v267))) + var tmp265 any + tmp266 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp267 := tmp266.FindInternedVar(lang.NewSymbol("=")) + if tmp267.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp267))) } - v268 := v267.Get() - v269 := lang.Apply(v268, []any{v252, "syms"}) - if lang.IsTruthy(v269) { - v270 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v271 := v270.FindInternedVar(lang.NewSymbol("assoc")) - if v271.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v271))) + tmp268 := tmp267.Get() + tmp269 := lang.Apply(tmp268, []any{v252, "syms"}) + if lang.IsTruthy(tmp269) { + tmp270 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp271 := tmp270.FindInternedVar(lang.NewSymbol("assoc")) + if tmp271.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp271))) } - v272 := v271.Get() - var v273 lang.FnFunc - v273 = lang.NewFnFunc(func(args ...any) any { + tmp272 := tmp271.Get() + var tmp273 lang.FnFunc + tmp273 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v274 := args[0] _ = v274 - v275 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v276 := v275.FindInternedVar(lang.NewSymbol("list")) - if v276.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v276))) + tmp275 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp276 := tmp275.FindInternedVar(lang.NewSymbol("list")) + if tmp276.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp276))) } - v277 := v276.Get() - v278 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v279 := v278.FindInternedVar(lang.NewSymbol("symbol")) - if v279.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v279))) + tmp277 := tmp276.Get() + tmp278 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp279 := tmp278.FindInternedVar(lang.NewSymbol("symbol")) + if tmp279.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp279))) } - v280 := v279.Get() - var v281 any + tmp280 := tmp279.Get() + var tmp281 any { // let // let binding "or__0__auto__" var v282 any = v247 _ = v282 - var v283 any + var tmp283 any if lang.IsTruthy(v282) { - v283 = v282 + tmp283 = v282 } else { - v284 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v285 := v284.FindInternedVar(lang.NewSymbol("namespace")) - if v285.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v285))) + tmp284 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp285 := tmp284.FindInternedVar(lang.NewSymbol("namespace")) + if tmp285.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp285))) } - v286 := v285.Get() - v287 := lang.Apply(v286, []any{v274}) - v283 = v287 + tmp286 := tmp285.Get() + tmp287 := lang.Apply(tmp286, []any{v274}) + tmp283 = tmp287 } - v281 = v283 + tmp281 = tmp283 } // end let - v282 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v283 := v282.FindInternedVar(lang.NewSymbol("name")) - if v283.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v283))) + tmp282 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp283 := tmp282.FindInternedVar(lang.NewSymbol("name")) + if tmp283.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp283))) } - v284 := v283.Get() - v285 := lang.Apply(v284, []any{v274}) - v286 := lang.Apply(v280, []any{v281, v285}) - v287 := lang.Apply(v277, []any{lang.NewSymbol("quote"), v286}) - return v287 + tmp284 := tmp283.Get() + tmp285 := lang.Apply(tmp284, []any{v274}) + tmp286 := lang.Apply(tmp280, []any{tmp281, tmp285}) + tmp287 := lang.Apply(tmp277, []any{lang.NewSymbol("quote"), tmp286}) + return tmp287 }) - v274 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4461), lang.NewKeyword("column"), int(93), lang.NewKeyword("end-line"), int(4461), lang.NewKeyword("end-column"), int(148)) - v275, err := lang.WithMeta(v273, v274.(lang.IPersistentMap)) + tmp274 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4461), lang.NewKeyword("column"), int(93), lang.NewKeyword("end-line"), int(4461), lang.NewKeyword("end-column"), int(148)) + tmp275, err := lang.WithMeta(tmp273, tmp274.(lang.IPersistentMap)) if err != nil { panic(err) } - v276 := lang.Apply(v272, []any{v235, v236, v275}) - v265 = v276 + tmp276 := lang.Apply(tmp272, []any{v235, v236, tmp275}) + tmp265 = tmp276 } else { - var v277 any - v278 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v279 := v278.FindInternedVar(lang.NewSymbol("=")) - if v279.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v279))) + var tmp277 any + tmp278 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp279 := tmp278.FindInternedVar(lang.NewSymbol("=")) + if tmp279.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp279))) } - v280 := v279.Get() - v281 := lang.Apply(v280, []any{v252, "strs"}) - if lang.IsTruthy(v281) { - v282 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v283 := v282.FindInternedVar(lang.NewSymbol("assoc")) - if v283.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v283))) + tmp280 := tmp279.Get() + tmp281 := lang.Apply(tmp280, []any{v252, "strs"}) + if lang.IsTruthy(tmp281) { + tmp282 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp283 := tmp282.FindInternedVar(lang.NewSymbol("assoc")) + if tmp283.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp283))) } - v284 := v283.Get() - v285 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v286 := v285.FindInternedVar(lang.NewSymbol("str")) - if v286.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v286))) + tmp284 := tmp283.Get() + tmp285 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp286 := tmp285.FindInternedVar(lang.NewSymbol("str")) + if tmp286.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp286))) } - v287 := v286.Get() - v288 := lang.Apply(v284, []any{v235, v236, v287}) - v277 = v288 + tmp287 := tmp286.Get() + tmp288 := lang.Apply(tmp284, []any{v235, v236, tmp287}) + tmp277 = tmp288 } else { - var v289 any + var tmp289 any if lang.IsTruthy(lang.NewKeyword("else")) { - v289 = v235 + tmp289 = v235 } else { - v289 = nil } - v277 = v289 + tmp277 = tmp289 } - v265 = v277 + tmp265 = tmp277 } - v253 = v265 + tmp253 = tmp265 } - v242 = v253 + tmp242 = tmp253 } // end let - v237 = v242 + tmp237 = tmp242 } else { - v237 = v235 + tmp237 = v235 } - return v237 + return tmp237 }) - v235 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4456), lang.NewKeyword("column"), int(45), lang.NewKeyword("end-line"), int(4464), lang.NewKeyword("end-column"), int(60)) - v236, err := lang.WithMeta(v234, v235.(lang.IPersistentMap)) + tmp235 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4456), lang.NewKeyword("column"), int(45), lang.NewKeyword("end-line"), int(4464), lang.NewKeyword("end-column"), int(60)) + tmp236, err := lang.WithMeta(tmp234, tmp235.(lang.IPersistentMap)) if err != nil { panic(err) } - v237 := lang.NewMap() - v238 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4465), lang.NewKeyword("column"), int(45), lang.NewKeyword("end-line"), int(4465), lang.NewKeyword("end-column"), int(46)) - v239, err := lang.WithMeta(v237, v238.(lang.IPersistentMap)) + tmp237 := lang.NewMap() + tmp238 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4465), lang.NewKeyword("column"), int(45), lang.NewKeyword("end-line"), int(4465), lang.NewKeyword("end-column"), int(46)) + tmp239, err := lang.WithMeta(tmp237, tmp238.(lang.IPersistentMap)) if err != nil { panic(err) } - v240 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v241 := v240.FindInternedVar(lang.NewSymbol("keys")) - if v241.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v241))) + tmp240 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp241 := tmp240.FindInternedVar(lang.NewSymbol("keys")) + if tmp241.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp241))) } - v242 := v241.Get() - v243 := lang.Apply(v242, []any{v22}) - v244 := lang.Apply(v233, []any{v236, v239, v243}) - var v245 any = v244 + tmp242 := tmp241.Get() + tmp243 := lang.Apply(tmp242, []any{v22}) + tmp244 := lang.Apply(tmp233, []any{tmp236, tmp239, tmp243}) + var v245 any = tmp244 _ = v245 - v246 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v247 := v246.FindInternedVar(lang.NewSymbol("reduce1")) - if v247.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v247))) + tmp246 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp247 := tmp246.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp247.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp247))) } - v248 := v247.Get() - var v249 lang.FnFunc - v249 = lang.NewFnFunc(func(args ...any) any { + tmp248 := tmp247.Get() + var tmp249 lang.FnFunc + tmp249 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -26579,14 +26673,14 @@ func init() { _ = v250 v251 := args[1] _ = v251 - v252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v253 := v252.FindInternedVar(lang.NewSymbol("reduce1")) - if v253.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v253))) + tmp252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp253 := tmp252.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp253.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp253))) } - v254 := v253.Get() - var v255 lang.FnFunc - v255 = lang.NewFnFunc(func(args ...any) any { + tmp254 := tmp253.Get() + var tmp255 lang.FnFunc + tmp255 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -26594,330 +26688,330 @@ func init() { _ = v256 v257 := args[1] _ = v257 - v258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v259 := v258.FindInternedVar(lang.NewSymbol("assoc")) - if v259.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v259))) + tmp258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp259 := tmp258.FindInternedVar(lang.NewSymbol("assoc")) + if tmp259.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp259))) } - v260 := v259.Get() - v261 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v262 := v261.FindInternedVar(lang.NewSymbol("val")) - if v262.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v262))) + tmp260 := tmp259.Get() + tmp261 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp262 := tmp261.FindInternedVar(lang.NewSymbol("val")) + if tmp262.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp262))) } - v263 := v262.Get() - v264 := lang.Apply(v263, []any{v251}) - v265 := lang.Apply(v264, []any{v257}) - v266 := lang.Apply(v260, []any{v256, v257, v265}) - return v266 + tmp263 := tmp262.Get() + tmp264 := lang.Apply(tmp263, []any{v251}) + tmp265 := lang.Apply(tmp264, []any{v257}) + tmp266 := lang.Apply(tmp260, []any{v256, v257, tmp265}) + return tmp266 }) - v256 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4469), lang.NewKeyword("column"), int(52), lang.NewKeyword("end-line"), int(4469), lang.NewKeyword("end-column"), int(82)) - v257, err := lang.WithMeta(v255, v256.(lang.IPersistentMap)) + tmp256 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4469), lang.NewKeyword("column"), int(52), lang.NewKeyword("end-line"), int(4469), lang.NewKeyword("end-column"), int(82)) + tmp257, err := lang.WithMeta(tmp255, tmp256.(lang.IPersistentMap)) if err != nil { panic(err) } - v258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v259 := v258.FindInternedVar(lang.NewSymbol("dissoc")) - if v259.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v259))) + tmp258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp259 := tmp258.FindInternedVar(lang.NewSymbol("dissoc")) + if tmp259.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp259))) } - v260 := v259.Get() - v261 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v262 := v261.FindInternedVar(lang.NewSymbol("key")) - if v262.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v262))) + tmp260 := tmp259.Get() + tmp261 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp262 := tmp261.FindInternedVar(lang.NewSymbol("key")) + if tmp262.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp262))) } - v263 := v262.Get() - v264 := lang.Apply(v263, []any{v251}) - v265 := lang.Apply(v260, []any{v250, v264}) - v266 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v267 := v266.FindInternedVar(lang.NewSymbol("key")) - if v267.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v267))) + tmp263 := tmp262.Get() + tmp264 := lang.Apply(tmp263, []any{v251}) + tmp265 := lang.Apply(tmp260, []any{v250, tmp264}) + tmp266 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp267 := tmp266.FindInternedVar(lang.NewSymbol("key")) + if tmp267.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp267))) } - v268 := v267.Get() - v269 := lang.Apply(v268, []any{v251}) - v270 := lang.Apply(v269, []any{v250}) - v271 := lang.Apply(v254, []any{v257, v265, v270}) - return v271 + tmp268 := tmp267.Get() + tmp269 := lang.Apply(tmp268, []any{v251}) + tmp270 := lang.Apply(tmp269, []any{v250}) + tmp271 := lang.Apply(tmp254, []any{tmp257, tmp265, tmp270}) + return tmp271 }) - v250 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4468), lang.NewKeyword("column"), int(41), lang.NewKeyword("end-line"), int(4471), lang.NewKeyword("end-column"), int(70)) - v251, err := lang.WithMeta(v249, v250.(lang.IPersistentMap)) + tmp250 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4468), lang.NewKeyword("column"), int(41), lang.NewKeyword("end-line"), int(4471), lang.NewKeyword("end-column"), int(70)) + tmp251, err := lang.WithMeta(tmp249, tmp250.(lang.IPersistentMap)) if err != nil { panic(err) } - v252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v253 := v252.FindInternedVar(lang.NewSymbol("dissoc")) - if v253.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v253))) + tmp252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp253 := tmp252.FindInternedVar(lang.NewSymbol("dissoc")) + if tmp253.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp253))) } - v254 := v253.Get() - v255 := lang.Apply(v254, []any{v22, lang.NewKeyword("as"), lang.NewKeyword("or")}) - v256 := lang.Apply(v248, []any{v251, v255, v245}) - v230 = v256 + tmp254 := tmp253.Get() + tmp255 := lang.Apply(tmp254, []any{v22, lang.NewKeyword("as"), lang.NewKeyword("or")}) + tmp256 := lang.Apply(tmp248, []any{tmp251, tmp255, v245}) + tmp230 = tmp256 } // end let - var v231 any = v230 + var v231 any = tmp230 _ = v231 for { - var v232 any - v233 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v234 := v233.FindInternedVar(lang.NewSymbol("seq")) - if v234.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v234))) + var tmp232 any + tmp233 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp234 := tmp233.FindInternedVar(lang.NewSymbol("seq")) + if tmp234.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp234))) } - v235 := v234.Get() - v236 := lang.Apply(v235, []any{v231}) - if lang.IsTruthy(v236) { - var v237 any + tmp235 := tmp234.Get() + tmp236 := lang.Apply(tmp235, []any{v231}) + if lang.IsTruthy(tmp236) { + var tmp237 any { // let // let binding "bb" - v238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v239 := v238.FindInternedVar(lang.NewSymbol("key")) - if v239.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v239))) + tmp238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp239 := tmp238.FindInternedVar(lang.NewSymbol("key")) + if tmp239.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp239))) } - v240 := v239.Get() - v241 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v242 := v241.FindInternedVar(lang.NewSymbol("first")) - if v242.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v242))) + tmp240 := tmp239.Get() + tmp241 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp242 := tmp241.FindInternedVar(lang.NewSymbol("first")) + if tmp242.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp242))) } - v243 := v242.Get() - v244 := lang.Apply(v243, []any{v231}) - v245 := lang.Apply(v240, []any{v244}) - var v246 any = v245 + tmp243 := tmp242.Get() + tmp244 := lang.Apply(tmp243, []any{v231}) + tmp245 := lang.Apply(tmp240, []any{tmp244}) + var v246 any = tmp245 _ = v246 // let binding "bk" - v247 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v248 := v247.FindInternedVar(lang.NewSymbol("val")) - if v248.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v248))) + tmp247 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp248 := tmp247.FindInternedVar(lang.NewSymbol("val")) + if tmp248.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp248))) } - v249 := v248.Get() - v250 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v251 := v250.FindInternedVar(lang.NewSymbol("first")) - if v251.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v251))) + tmp249 := tmp248.Get() + tmp250 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp251 := tmp250.FindInternedVar(lang.NewSymbol("first")) + if tmp251.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp251))) } - v252 := v251.Get() - v253 := lang.Apply(v252, []any{v231}) - v254 := lang.Apply(v249, []any{v253}) - var v255 any = v254 + tmp252 := tmp251.Get() + tmp253 := lang.Apply(tmp252, []any{v231}) + tmp254 := lang.Apply(tmp249, []any{tmp253}) + var v255 any = tmp254 _ = v255 // let binding "local" - var v256 any - v257 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v258 := v257.FindInternedVar(lang.NewSymbol("instance?")) - if v258.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v258))) + var tmp256 any + tmp257 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp258 := tmp257.FindInternedVar(lang.NewSymbol("instance?")) + if tmp258.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp258))) } - v259 := v258.Get() - v260 := lang.Apply(v259, []any{lang.Named, v246}) - if lang.IsTruthy(v260) { - v261 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v262 := v261.FindInternedVar(lang.NewSymbol("with-meta")) - if v262.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v262))) + tmp259 := tmp258.Get() + tmp260 := reflect.TypeOf((*lang.Named)(nil)).Elem() + tmp261 := lang.Apply(tmp259, []any{tmp260, v246}) + if lang.IsTruthy(tmp261) { + tmp262 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp263 := tmp262.FindInternedVar(lang.NewSymbol("with-meta")) + if tmp263.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp263))) } - v263 := v262.Get() - v264 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v265 := v264.FindInternedVar(lang.NewSymbol("symbol")) - if v265.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v265))) + tmp264 := tmp263.Get() + tmp265 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp266 := tmp265.FindInternedVar(lang.NewSymbol("symbol")) + if tmp266.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp266))) } - v266 := v265.Get() - v267 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v268 := v267.FindInternedVar(lang.NewSymbol("name")) - if v268.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v268))) + tmp267 := tmp266.Get() + tmp268 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp269 := tmp268.FindInternedVar(lang.NewSymbol("name")) + if tmp269.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp269))) } - v269 := v268.Get() - v270 := lang.Apply(v269, []any{v246}) - v271 := lang.Apply(v266, []any{nil, v270}) - v272 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v273 := v272.FindInternedVar(lang.NewSymbol("meta")) - if v273.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v273))) + tmp270 := tmp269.Get() + tmp271 := lang.Apply(tmp270, []any{v246}) + tmp272 := lang.Apply(tmp267, []any{nil, tmp271}) + tmp273 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp274 := tmp273.FindInternedVar(lang.NewSymbol("meta")) + if tmp274.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp274))) } - v274 := v273.Get() - v275 := lang.Apply(v274, []any{v246}) - v276 := lang.Apply(v263, []any{v271, v275}) - v256 = v276 + tmp275 := tmp274.Get() + tmp276 := lang.Apply(tmp275, []any{v246}) + tmp277 := lang.Apply(tmp264, []any{tmp272, tmp276}) + tmp256 = tmp277 } else { - v256 = v246 + tmp256 = v246 } - var v277 any = v256 - _ = v277 + var v278 any = tmp256 + _ = v278 // let binding "bv" - var v278 any - v279 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v280 := v279.FindInternedVar(lang.NewSymbol("contains?")) - if v280.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v280))) + var tmp279 any + tmp280 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp281 := tmp280.FindInternedVar(lang.NewSymbol("contains?")) + if tmp281.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp281))) } - v281 := v280.Get() - v282 := lang.Apply(v281, []any{v39, v277}) - if lang.IsTruthy(v282) { - v283 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v284 := v283.FindInternedVar(lang.NewSymbol("list")) - if v284.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v284))) + tmp282 := tmp281.Get() + tmp283 := lang.Apply(tmp282, []any{v39, v278}) + if lang.IsTruthy(tmp283) { + tmp284 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp285 := tmp284.FindInternedVar(lang.NewSymbol("list")) + if tmp285.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp285))) } - v285 := v284.Get() - v286 := lang.Apply(v39, []any{v277}) - v287 := lang.Apply(v285, []any{lang.NewSymbol("glojure.core/get"), v29, v255, v286}) - v278 = v287 + tmp286 := tmp285.Get() + tmp287 := lang.Apply(v39, []any{v278}) + tmp288 := lang.Apply(tmp286, []any{lang.NewSymbol("glojure.core/get"), v29, v255, tmp287}) + tmp279 = tmp288 } else { - v288 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v289 := v288.FindInternedVar(lang.NewSymbol("list")) - if v289.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v289))) + tmp289 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp290 := tmp289.FindInternedVar(lang.NewSymbol("list")) + if tmp290.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp290))) } - v290 := v289.Get() - v291 := lang.Apply(v290, []any{lang.NewSymbol("glojure.core/get"), v29, v255}) - v278 = v291 + tmp291 := tmp290.Get() + tmp292 := lang.Apply(tmp291, []any{lang.NewSymbol("glojure.core/get"), v29, v255}) + tmp279 = tmp292 } - var v292 any = v278 - _ = v292 - var v294 any - v295 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v296 := v295.FindInternedVar(lang.NewSymbol("ident?")) - if v296.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v296))) + var v293 any = tmp279 + _ = v293 + var tmp295 any + tmp296 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp297 := tmp296.FindInternedVar(lang.NewSymbol("ident?")) + if tmp297.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp297))) } - v297 := v296.Get() - v298 := lang.Apply(v297, []any{v246}) - if lang.IsTruthy(v298) { - v299 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v300 := v299.FindInternedVar(lang.NewSymbol("conj")) - if v300.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v300))) + tmp298 := tmp297.Get() + tmp299 := lang.Apply(tmp298, []any{v246}) + if lang.IsTruthy(tmp299) { + tmp300 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp301 := tmp300.FindInternedVar(lang.NewSymbol("conj")) + if tmp301.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp301))) } - v301 := v300.Get() - v302 := lang.Apply(v301, []any{v229, v277, v292}) - v294 = v302 + tmp302 := tmp301.Get() + tmp303 := lang.Apply(tmp302, []any{v229, v278, v293}) + tmp295 = tmp303 } else { - v303 := lang.Apply(v11, []any{v229, v246, v292}) - v294 = v303 + tmp304 := lang.Apply(v11, []any{v229, v246, v293}) + tmp295 = tmp304 } - var v293 any = v294 - v305 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v306 := v305.FindInternedVar(lang.NewSymbol("next")) - if v306.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v306))) + var tmp294 any = tmp295 + tmp306 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp307 := tmp306.FindInternedVar(lang.NewSymbol("next")) + if tmp307.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp307))) } - v307 := v306.Get() - v308 := lang.Apply(v307, []any{v231}) - var v304 any = v308 - v229 = v293 - v231 = v304 + tmp308 := tmp307.Get() + tmp309 := lang.Apply(tmp308, []any{v231}) + var tmp305 any = tmp309 + v229 = tmp294 + v231 = tmp305 continue } // end let - v232 = v237 + tmp232 = tmp237 } else { - v232 = v229 + tmp232 = v229 } - v40 = v232 + tmp40 = tmp232 break } } // end let - v24 = v40 + tmp24 = tmp40 } // end let - return v24 + return tmp24 }) - v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4440), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(4485), lang.NewKeyword("end-column"), int(34)) - v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) + tmp21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4440), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(4485), lang.NewKeyword("end-column"), int(34)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) if err != nil { panic(err) } - var v23 any = v22 + var v23 any = tmp22 _ = v23 - var v24 any - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("symbol?")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.Apply(v27, []any{v13}) - if lang.IsTruthy(v28) { - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("conj")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + var tmp24 any + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("symbol?")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.Apply(tmp27, []any{v13}) + if lang.IsTruthy(tmp28) { + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("conj")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) } - v31 := v30.Get() - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("conj")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + tmp31 := tmp30.Get() + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("conj")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{v12, v13}) - v36 := lang.Apply(v31, []any{v35, v14}) - v24 = v36 + tmp34 := tmp33.Get() + tmp35 := lang.Apply(tmp34, []any{v12, v13}) + tmp36 := lang.Apply(tmp31, []any{tmp35, v14}) + tmp24 = tmp36 } else { - var v37 any - v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v39 := v38.FindInternedVar(lang.NewSymbol("vector?")) - if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + var tmp37 any + tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp39 := tmp38.FindInternedVar(lang.NewSymbol("vector?")) + if tmp39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) } - v40 := v39.Get() - v41 := lang.Apply(v40, []any{v13}) - if lang.IsTruthy(v41) { - v42 := lang.Apply(v19, []any{v12, v13, v14}) - v37 = v42 + tmp40 := tmp39.Get() + tmp41 := lang.Apply(tmp40, []any{v13}) + if lang.IsTruthy(tmp41) { + tmp42 := lang.Apply(v19, []any{v12, v13, v14}) + tmp37 = tmp42 } else { - var v43 any - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("map?")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + var tmp43 any + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("map?")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) } - v46 := v45.Get() - v47 := lang.Apply(v46, []any{v13}) - if lang.IsTruthy(v47) { - v48 := lang.Apply(v23, []any{v12, v13, v14}) - v43 = v48 + tmp46 := tmp45.Get() + tmp47 := lang.Apply(tmp46, []any{v13}) + if lang.IsTruthy(tmp47) { + tmp48 := lang.Apply(v23, []any{v12, v13, v14}) + tmp43 = tmp48 } else { - var v49 any + var tmp49 any if lang.IsTruthy(lang.NewKeyword("else")) { - v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v51 := v50.FindInternedVar(lang.NewSymbol("str")) - if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) + tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp51 := tmp50.FindInternedVar(lang.NewSymbol("str")) + if tmp51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) } - v52 := v51.Get() - v53 := lang.Apply(v52, []any{"Unsupported binding form: ", v13}) - v54 := lang.Apply(errors5.New, []any{v53}) - panic(v54) + tmp52 := tmp51.Get() + tmp53 := lang.Apply(tmp52, []any{"Unsupported binding form: ", v13}) + tmp54 := lang.Apply(errors5.New, []any{tmp53}) + panic(tmp54) } else { - v49 = nil } - v43 = v49 + tmp43 = tmp49 } - v37 = v43 + tmp37 = tmp43 } - v24 = v37 + tmp24 = tmp37 } - v15 = v24 + tmp15 = tmp24 } // end let - return v15 + return tmp15 }) - v11 := v10 + v11 = tmp10 _ = v11 } - v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4402), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(4490), lang.NewKeyword("end-column"), int(82)) - v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) + tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4402), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(4490), lang.NewKeyword("end-column"), int(82)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) if err != nil { panic(err) } - var v13 any = v12 + var v13 any = tmp12 _ = v13 // let binding "process-entry" - var v14 lang.FnFunc - v14 = lang.NewFnFunc(func(args ...any) any { + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -26925,90 +27019,90 @@ func init() { _ = v15 v16 := args[1] _ = v16 - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("first")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.Apply(v19, []any{v16}) - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("second")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.Apply(v23, []any{v16}) - v25 := lang.Apply(v13, []any{v15, v20, v24}) - return v25 + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("first")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.Apply(tmp19, []any{v16}) + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("second")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.Apply(tmp23, []any{v16}) + tmp25 := lang.Apply(v13, []any{v15, tmp20, tmp24}) + return tmp25 }) - v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4491), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(4491), lang.NewKeyword("end-column"), int(66)) - v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) + tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4491), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(4491), lang.NewKeyword("end-column"), int(66)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) if err != nil { panic(err) } - var v17 any = v16 + var v17 any = tmp16 _ = v17 - var v18 any - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("every?")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("symbol?")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("map")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("first")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.Apply(v27, []any{v30, v9}) - v32 := lang.Apply(v21, []any{v24, v31}) - if lang.IsTruthy(v32) { - v18 = v3 + var tmp18 any + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("every?")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("symbol?")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("map")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("first")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.Apply(tmp27, []any{tmp30, v9}) + tmp32 := lang.Apply(tmp21, []any{tmp24, tmp31}) + if lang.IsTruthy(tmp32) { + tmp18 = v3 } else { - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("reduce1")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - v36 := lang.NewVector() - v37 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4494), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(4494), lang.NewKeyword("end-column"), int(31)) - v38, err := lang.WithMeta(v36, v37.(lang.IPersistentMap)) + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) + } + tmp35 := tmp34.Get() + tmp36 := lang.NewVector() + tmp37 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4494), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(4494), lang.NewKeyword("end-column"), int(31)) + tmp38, err := lang.WithMeta(tmp36, tmp37.(lang.IPersistentMap)) if err != nil { panic(err) } - v39 := lang.Apply(v35, []any{v17, v38, v9}) - v18 = v39 + tmp39 := lang.Apply(tmp35, []any{v17, tmp38, v9}) + tmp18 = tmp39 } - v4 = v18 + tmp4 = tmp18 } // end let - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // disj { - v0 := lang.NewSymbol("disj").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("set")), lang.NewVector(lang.NewSymbol("set"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("set"), lang.NewSymbol("key"), lang.NewSymbol("&"), lang.NewSymbol("ks"))), lang.NewKeyword("doc"), "disj[oin]. Returns a new set of the same (hashed/sorted) type, that\n does not contain key(s).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1514), lang.NewKeyword("end-line"), int(1514))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("disj").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("set")), lang.NewVector(lang.NewSymbol("set"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("set"), lang.NewSymbol("key"), lang.NewSymbol("&"), lang.NewSymbol("ks"))), lang.NewKeyword("doc"), "disj[oin]. Returns a new set of the same (hashed/sorted) type, that\n does not contain key(s).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1514), lang.NewKeyword("end-line"), int(1514))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] @@ -27019,18 +27113,17 @@ func init() { _ = v3 v4 := args[1] _ = v4 - var v5 any + var tmp5 any if lang.IsTruthy(v3) { - v6, _ := lang.FieldOrMethod(v3, "Disjoin") - if reflect.TypeOf(v6).Kind() != reflect.Func { + tmp6, _ := lang.FieldOrMethod(v3, "Disjoin") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Disjoin is not a function"))) } - v7 := lang.Apply(v6, []any{v4}) - v5 = v7 + tmp7 := lang.Apply(tmp6, []any{v4}) + tmp5 = tmp7 } else { - v5 = nil } - return v5 + return tmp5 default: if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -27039,68 +27132,68 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.NewList(args[2:]...) + var v5 any = lang.NewList(args[2:]...) + _ = v5 recur_loop_304: - var v6 any + var tmp6 any if lang.IsTruthy(v3) { - var v7 any + var tmp7 any { // let // let binding "ret" - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("disj")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v3, v4}) - var v12 any = v11 + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("disj")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v3, v4}) + var v12 any = tmp11 _ = v12 - var v13 any + var tmp13 any if lang.IsTruthy(v5) { - var v14 any = v12 - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("first")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{v5}) - var v15 any = v19 - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("next")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.Apply(v23, []any{v5}) - var v20 any = v24 - v3 = v14 - v4 = v15 - v5 = v20 + var tmp14 any = v12 + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("first")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{v5}) + var tmp15 any = tmp19 + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("next")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.Apply(tmp23, []any{v5}) + var tmp20 any = tmp24 + v3 = tmp14 + v4 = tmp15 + v5 = tmp20 goto recur_loop_304 } else { - v13 = v12 + tmp13 = v12 } - v7 = v13 + tmp7 = tmp13 } // end let - v6 = v7 + tmp6 = tmp7 } else { - v6 = nil } - return v6 + return tmp6 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // disj! { - v0 := lang.NewSymbol("disj!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("set")), lang.NewVector(lang.NewSymbol("set"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("set"), lang.NewSymbol("key"), lang.NewSymbol("&"), lang.NewSymbol("ks"))), lang.NewKeyword("doc"), "disj[oin]. Returns a transient set of the same (hashed/sorted) type, that\n does not contain key(s).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3401), lang.NewKeyword("end-line"), int(3401))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("disj!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("set")), lang.NewVector(lang.NewSymbol("set"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("set"), lang.NewSymbol("key"), lang.NewSymbol("&"), lang.NewSymbol("ks"))), lang.NewKeyword("doc"), "disj[oin]. Returns a transient set of the same (hashed/sorted) type, that\n does not contain key(s).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3401), lang.NewKeyword("end-line"), int(3401))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] @@ -27111,12 +27204,12 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5, _ := lang.FieldOrMethod(v3, "Disjoin") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(v3, "Disjoin") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Disjoin is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 default: if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -27125,60 +27218,61 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.NewList(args[2:]...) + var v5 any = lang.NewList(args[2:]...) + _ = v5 recur_loop_615: - var v6 any + var tmp6 any { // let // let binding "ret" - v7, _ := lang.FieldOrMethod(v3, "Disjoin") - if reflect.TypeOf(v7).Kind() != reflect.Func { + tmp7, _ := lang.FieldOrMethod(v3, "Disjoin") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Disjoin is not a function"))) } - v8 := lang.Apply(v7, []any{v4}) - var v9 any = v8 + tmp8 := lang.Apply(tmp7, []any{v4}) + var v9 any = tmp8 _ = v9 - var v10 any + var tmp10 any if lang.IsTruthy(v5) { - var v11 any = v9 - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("first")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{v5}) - var v12 any = v16 - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("next")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.Apply(v20, []any{v5}) - var v17 any = v21 - v3 = v11 - v4 = v12 - v5 = v17 + var tmp11 any = v9 + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("first")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{v5}) + var tmp12 any = tmp16 + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("next")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.Apply(tmp20, []any{v5}) + var tmp17 any = tmp21 + v3 = tmp11 + v4 = tmp12 + v5 = tmp17 goto recur_loop_615 } else { - v10 = v9 + tmp10 = v9 } - v6 = v10 + tmp6 = tmp10 } // end let - return v6 + return tmp6 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // dissoc { - v0 := lang.NewSymbol("dissoc").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map")), lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"), lang.NewSymbol("&"), lang.NewSymbol("ks"))), lang.NewKeyword("doc"), "dissoc[iate]. Returns a new map of the same (hashed/sorted) type,\n that does not contain a mapping for key(s).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1500), lang.NewKeyword("end-line"), int(1500))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("dissoc").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map")), lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"), lang.NewSymbol("&"), lang.NewSymbol("ks"))), lang.NewKeyword("doc"), "dissoc[iate]. Returns a new map of the same (hashed/sorted) type,\n that does not contain a mapping for key(s).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1500), lang.NewKeyword("end-line"), int(1500))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] @@ -27189,12 +27283,12 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5, _ := lang.FieldOrMethod(runtime4.RT, "Dissoc") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(runtime4.RT, "Dissoc") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Dissoc is not a function"))) } - v6 := lang.Apply(v5, []any{v3, v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 default: if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -27203,74 +27297,75 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.NewList(args[2:]...) + var v5 any = lang.NewList(args[2:]...) + _ = v5 recur_loop_301: - var v6 any + var tmp6 any { // let // let binding "ret" - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("dissoc")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v9, []any{v3, v4}) - var v11 any = v10 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("dissoc")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp9, []any{v3, v4}) + var v11 any = tmp10 _ = v11 - var v12 any + var tmp12 any if lang.IsTruthy(v5) { - var v13 any = v11 - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("first")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{v5}) - var v14 any = v18 - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("next")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.Apply(v22, []any{v5}) - var v19 any = v23 - v3 = v13 - v4 = v14 - v5 = v19 + var tmp13 any = v11 + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("first")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{v5}) + var tmp14 any = tmp18 + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("next")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.Apply(tmp22, []any{v5}) + var tmp19 any = tmp23 + v3 = tmp13 + v4 = tmp14 + v5 = tmp19 goto recur_loop_301 } else { - v12 = v11 + tmp12 = v11 } - v6 = v12 + tmp6 = tmp12 } // end let - return v6 + return tmp6 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // dissoc! { - v0 := lang.NewSymbol("dissoc!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"), lang.NewSymbol("&"), lang.NewSymbol("ks"))), lang.NewKeyword("doc"), "Returns a transient map that doesn't contain a mapping for key(s).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3382), lang.NewKeyword("end-line"), int(3382))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("dissoc!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"), lang.NewSymbol("&"), lang.NewSymbol("ks"))), lang.NewKeyword("doc"), "Returns a transient map that doesn't contain a mapping for key(s).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3382), lang.NewKeyword("end-line"), int(3382))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - v5, _ := lang.FieldOrMethod(v3, "without") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(v3, "without") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("without is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 default: if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -27279,177 +27374,179 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.NewList(args[2:]...) + var v5 any = lang.NewList(args[2:]...) + _ = v5 recur_loop_611: - var v6 any + var tmp6 any { // let // let binding "ret" - v7, _ := lang.FieldOrMethod(v3, "without") - if reflect.TypeOf(v7).Kind() != reflect.Func { + tmp7, _ := lang.FieldOrMethod(v3, "without") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("without is not a function"))) } - v8 := lang.Apply(v7, []any{v4}) - var v9 any = v8 + tmp8 := lang.Apply(tmp7, []any{v4}) + var v9 any = tmp8 _ = v9 - var v10 any + var tmp10 any if lang.IsTruthy(v5) { - var v11 any = v9 - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("first")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{v5}) - var v12 any = v16 - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("next")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.Apply(v20, []any{v5}) - var v17 any = v21 - v3 = v11 - v4 = v12 - v5 = v17 + var tmp11 any = v9 + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("first")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{v5}) + var tmp12 any = tmp16 + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("next")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.Apply(tmp20, []any{v5}) + var tmp17 any = tmp21 + v3 = tmp11 + v4 = tmp12 + v5 = tmp17 goto recur_loop_611 } else { - v10 = v9 + tmp10 = v9 } - v6 = v10 + tmp6 = tmp10 } // end let - return v6 + return tmp6 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // distinct { - v0 := lang.NewSymbol("distinct").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the elements of coll with duplicates removed.\n Returns a stateful transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5053), lang.NewKeyword("end-line"), int(5053))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("distinct").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the elements of coll with duplicates removed.\n Returns a stateful transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5053), lang.NewKeyword("end-line"), int(5053))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - var v5 any + var tmp5 any { // let // let binding "seen" - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("volatile!")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.CreatePersistentTreeSet() - v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5060), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(5060), lang.NewKeyword("end-column"), int(30)) - v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("volatile!")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5060), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(5060), lang.NewKeyword("end-column"), int(30)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) if err != nil { panic(err) } - v12 := lang.Apply(v8, []any{v11}) - var v13 any = v12 + tmp12 := lang.Apply(tmp8, []any{tmp11}) + var v13 any = tmp12 _ = v13 - var v14 lang.FnFunc - v14 = lang.NewFnFunc(func(args ...any) any { + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - v15 := lang.Apply(v4, nil) - return v15 + tmp15 := lang.Apply(v4, nil) + return tmp15 case 1: v15 := args[0] _ = v15 - v16 := lang.Apply(v4, []any{v15}) - return v16 + tmp16 := lang.Apply(v4, []any{v15}) + return tmp16 case 2: v15 := args[0] _ = v15 v16 := args[1] _ = v16 - var v17 any - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("contains?")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + var tmp17 any + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("contains?")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) } - v20 := v19.Get() - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("deref")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + tmp20 := tmp19.Get() + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("deref")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) } - v23 := v22.Get() - v24 := lang.Apply(v23, []any{v13}) - v25 := lang.Apply(v20, []any{v24, v16}) - if lang.IsTruthy(v25) { - v17 = v15 + tmp23 := tmp22.Get() + tmp24 := lang.Apply(tmp23, []any{v13}) + tmp25 := lang.Apply(tmp20, []any{tmp24, v16}) + if lang.IsTruthy(tmp25) { + tmp17 = v15 } else { - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("conj")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("conj")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) } - v28 := v27.Get() - v29, ok := lang.FieldOrMethod(v13, "Deref") + tmp28 := tmp27.Get() + tmp29, ok := lang.FieldOrMethod(v13, "Deref") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v13, "Deref"))) } - var v30 any - switch reflect.TypeOf(v29).Kind() { + var tmp30 any + switch reflect.TypeOf(tmp29).Kind() { case reflect.Func: - v30 = lang.Apply(v29, nil) + tmp30 = lang.Apply(tmp29, nil) default: - v30 = v29 + tmp30 = tmp29 } - v31 := lang.Apply(v28, []any{v30, v16}) - v32, _ := lang.FieldOrMethod(v13, "reset") - if reflect.TypeOf(v32).Kind() != reflect.Func { + tmp31 := lang.Apply(tmp28, []any{tmp30, v16}) + tmp32, _ := lang.FieldOrMethod(v13, "reset") + if reflect.TypeOf(tmp32).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) } - v33 := lang.Apply(v32, []any{v31}) - _ = v33 - v34 := lang.Apply(v4, []any{v15, v16}) - v17 = v34 + tmp33 := lang.Apply(tmp32, []any{tmp31}) + _ = tmp33 + tmp34 := lang.Apply(v4, []any{v15, v16}) + tmp17 = tmp34 } - return v17 + return tmp17 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5061), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(5068), lang.NewKeyword("end-column"), int(37)) - v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) + tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5061), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(5068), lang.NewKeyword("end-column"), int(37)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) if err != nil { panic(err) } - v5 = v16 + tmp5 = tmp16 } // end let - return v5 + return tmp5 }) - v4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5059), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(5068), lang.NewKeyword("end-column"), int(39)) - v5, err := lang.WithMeta(v3, v4.(lang.IPersistentMap)) + tmp4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5059), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(5068), lang.NewKeyword("end-column"), int(39)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) if err != nil { panic(err) } - return v5 + return tmp5 case 1: v3 := args[0] _ = v3 - var v4 any + var tmp4 any { // let // let binding "step" - var v5 lang.FnFunc + var tmp5 lang.FnFunc { // function step - v5 = lang.NewFnFunc(func(args ...any) any { + var v6 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -27457,13 +27554,13 @@ func init() { _ = v7 v8 := args[1] _ = v8 - var v9 lang.FnFunc - v9 = lang.NewFnFunc(func(args ...any) any { + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - var v10 lang.FnFunc - v10 = lang.NewFnFunc(func(args ...any) any { + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -27472,148 +27569,147 @@ func init() { v12 := args[1] _ = v12 recur_loop_877: - var v13 any + var tmp13 any { // let // let binding "vec__62" var v14 any = v11 _ = v14 // let binding "f" - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("nth")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("nth")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{v14, int64(0), nil}) - var v19 any = v18 + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{v14, int64(0), nil}) + var v19 any = tmp18 _ = v19 // let binding "xs" var v20 any = v14 _ = v20 - var v21 any + var tmp21 any { // let // let binding "temp__0__auto__" - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("seq")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("seq")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v20}) - var v26 any = v25 + tmp24 := tmp23.Get() + tmp25 := lang.Apply(tmp24, []any{v20}) + var v26 any = tmp25 _ = v26 - var v27 any + var tmp27 any if lang.IsTruthy(v26) { - var v28 any + var tmp28 any { // let // let binding "s" var v29 any = v26 _ = v29 - var v30 any - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("contains?")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + var tmp30 any + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("contains?")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{v12, v19}) - if lang.IsTruthy(v34) { - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("rest")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{v12, v19}) + if lang.IsTruthy(tmp34) { + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("rest")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) } - v38 := v37.Get() - v39 := lang.Apply(v38, []any{v29}) - var v35 any = v39 - var v40 any = v12 - v11 = v35 - v12 = v40 + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{v29}) + var tmp35 any = tmp39 + var tmp40 any = v12 + v11 = tmp35 + v12 = tmp40 goto recur_loop_877 } else { - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("cons")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("cons")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) } - v43 := v42.Get() - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("rest")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + tmp43 := tmp42.Get() + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("rest")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) } - v46 := v45.Get() - v47 := lang.Apply(v46, []any{v29}) - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("conj")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + tmp46 := tmp45.Get() + tmp47 := lang.Apply(tmp46, []any{v29}) + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("conj")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v12, v19}) - v52 := lang.Apply(v6, []any{v47, v51}) - v53 := lang.Apply(v43, []any{v19, v52}) - v30 = v53 + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v12, v19}) + tmp52 := lang.Apply(v6, []any{tmp47, tmp51}) + tmp53 := lang.Apply(tmp43, []any{v19, tmp52}) + tmp30 = tmp53 } - v28 = v30 + tmp28 = tmp30 } // end let - v27 = v28 + tmp27 = tmp28 } else { - v27 = nil } - v21 = v27 + tmp21 = tmp27 } // end let - v13 = v21 + tmp13 = tmp21 } // end let - return v13 + return tmp13 }) - v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5072), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(5076), lang.NewKeyword("end-column"), int(66)) - v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) + tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5072), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(5076), lang.NewKeyword("end-column"), int(66)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) if err != nil { panic(err) } - v13 := lang.Apply(v12, []any{v7, v8}) - return v13 + tmp13 := lang.Apply(tmp12, []any{v7, v8}) + return tmp13 }) - v10 := lang.Apply(lang.NewLazySeq, []any{v9}) - return v10 + tmp10 := lang.Apply(lang.NewLazySeq, []any{tmp9}) + return tmp10 }) - v6 := v5 + v6 = tmp5 _ = v6 } - v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5070), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(5077), lang.NewKeyword("end-column"), int(29)) - v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) + tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5070), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(5077), lang.NewKeyword("end-column"), int(29)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) if err != nil { panic(err) } - var v8 any = v7 + var v8 any = tmp7 _ = v8 - v9 := lang.CreatePersistentTreeSet() - v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5078), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(5078), lang.NewKeyword("end-column"), int(19)) - v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) + tmp9 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5078), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(5078), lang.NewKeyword("end-column"), int(19)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) if err != nil { panic(err) } - v12 := lang.Apply(v8, []any{v3, v11}) - v4 = v12 + tmp12 := lang.Apply(v8, []any{v3, tmp11}) + tmp4 = tmp12 } // end let - return v4 + return tmp4 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // distinct? { - v1 := reflect.TypeOf(false) - v0 := lang.NewSymbol("distinct?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Returns true if no two of the arguments are =", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5664), lang.NewKeyword("end-line"), int(5664))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp1 := reflect.TypeOf(false) + tmp0 := lang.NewSymbol("distinct?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Returns true if no two of the arguments are =", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5664), lang.NewKeyword("end-line"), int(5664))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v4 := args[0] @@ -27624,21 +27720,21 @@ func init() { _ = v4 v5 := args[1] _ = v5 - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("not")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("=")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.Apply(v11, []any{v4, v5}) - v13 := lang.Apply(v8, []any{v12}) - return v13 + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("not")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("=")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.Apply(tmp11, []any{v4, v5}) + tmp13 := lang.Apply(tmp8, []any{tmp12}) + return tmp13 default: if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -27647,26 +27743,27 @@ func init() { _ = v4 v5 := args[1] _ = v5 - v6 := lang.NewList(args[2:]...) - var v7 any - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("not=")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v4, v5}) - if lang.IsTruthy(v11) { - var v12 any + var v6 any = lang.NewList(args[2:]...) + _ = v6 + var tmp7 any + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("not=")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v4, v5}) + if lang.IsTruthy(tmp11) { + var tmp12 any { // let // let binding "s" - v13 := lang.CreatePersistentTreeSet(v4, v5) - v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5673), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(5673), lang.NewKeyword("end-column"), int(20)) - v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) + tmp13 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{v4, v5})) + tmp14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5673), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(5673), lang.NewKeyword("end-column"), int(20)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) if err != nil { panic(err) } - var v16 any = v15 + var v16 any = tmp15 _ = v16 // let binding "G__99" var v17 any = v6 @@ -27675,34 +27772,34 @@ func init() { var v18 any = v17 _ = v18 // let binding "seq__101" - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("seq")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{v18}) - var v23 any = v22 + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("seq")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, []any{v18}) + var v23 any = tmp22 _ = v23 // let binding "first__102" - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("first")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.Apply(v26, []any{v23}) - var v28 any = v27 + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("first")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.Apply(tmp26, []any{v23}) + var v28 any = tmp27 _ = v28 // let binding "seq__101" - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("next")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.Apply(v31, []any{v23}) - var v33 any = v32 + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("next")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.Apply(tmp31, []any{v23}) + var v33 any = tmp32 _ = v33 // let binding "x" var v34 any = v28 @@ -27713,7 +27810,7 @@ func init() { // let binding "xs" var v36 any = v18 _ = v36 - var v37 any + var tmp37 any { // let // let binding "s" var v38 any = v16 @@ -27722,7 +27819,7 @@ func init() { var v39 any = v17 _ = v39 for { - var v40 any + var tmp40 any { // let // let binding "s" var v41 any = v38 @@ -27731,34 +27828,34 @@ func init() { var v42 any = v39 _ = v42 // let binding "seq__104" - v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v44 := v43.FindInternedVar(lang.NewSymbol("seq")) - if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) + tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp44 := tmp43.FindInternedVar(lang.NewSymbol("seq")) + if tmp44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) } - v45 := v44.Get() - v46 := lang.Apply(v45, []any{v42}) - var v47 any = v46 + tmp45 := tmp44.Get() + tmp46 := lang.Apply(tmp45, []any{v42}) + var v47 any = tmp46 _ = v47 // let binding "first__105" - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("first")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("first")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v47}) - var v52 any = v51 + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v47}) + var v52 any = tmp51 _ = v52 // let binding "seq__104" - v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v54 := v53.FindInternedVar(lang.NewSymbol("next")) - if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) + tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp54 := tmp53.FindInternedVar(lang.NewSymbol("next")) + if tmp54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) } - v55 := v54.Get() - v56 := lang.Apply(v55, []any{v47}) - var v57 any = v56 + tmp55 := tmp54.Get() + tmp56 := lang.Apply(tmp55, []any{v47}) + var v57 any = tmp56 _ = v57 // let binding "x" var v58 any = v52 @@ -27769,220 +27866,218 @@ func init() { // let binding "xs" var v60 any = v42 _ = v60 - var v61 any + var tmp61 any if lang.IsTruthy(v60) { - var v62 any - v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v64 := v63.FindInternedVar(lang.NewSymbol("contains?")) - if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) + var tmp62 any + tmp63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp64 := tmp63.FindInternedVar(lang.NewSymbol("contains?")) + if tmp64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp64))) } - v65 := v64.Get() - v66 := lang.Apply(v65, []any{v41, v58}) - if lang.IsTruthy(v66) { - v62 = false + tmp65 := tmp64.Get() + tmp66 := lang.Apply(tmp65, []any{v41, v58}) + if lang.IsTruthy(tmp66) { + tmp62 = false } else { - v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v69 := v68.FindInternedVar(lang.NewSymbol("conj")) - if v69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) + tmp68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp69 := tmp68.FindInternedVar(lang.NewSymbol("conj")) + if tmp69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp69))) } - v70 := v69.Get() - v71 := lang.Apply(v70, []any{v41, v58}) - var v67 any = v71 - var v72 any = v59 - v38 = v67 - v39 = v72 + tmp70 := tmp69.Get() + tmp71 := lang.Apply(tmp70, []any{v41, v58}) + var tmp67 any = tmp71 + var tmp72 any = v59 + v38 = tmp67 + v39 = tmp72 continue } - v61 = v62 + tmp61 = tmp62 } else { - v61 = true + tmp61 = true } - v40 = v61 + tmp40 = tmp61 } // end let - v37 = v40 + tmp37 = tmp40 break } } // end let - v12 = v37 + tmp12 = tmp37 } // end let - v7 = v12 + tmp7 = tmp12 } else { - v7 = false + tmp7 = false } - return v7 + return tmp7 } }) - v4 := reflect.TypeOf(false) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp4 := reflect.TypeOf(false) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // doall { - v0 := lang.NewSymbol("doall").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "When lazy sequences are produced via functions that have side\n effects, any effects other than those needed to produce the first\n element in the seq do not occur until the seq is consumed. doall can\n be used to force any effects. Walks through the successive nexts of\n the seq, retains the head and returns it, thus causing the entire\n seq to reside in memory at one time.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3131), lang.NewKeyword("end-line"), int(3131))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("doall").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "When lazy sequences are produced via functions that have side\n effects, any effects other than those needed to produce the first\n element in the seq do not occur until the seq is consumed. doall can\n be used to force any effects. Walks through the successive nexts of\n the seq, retains the head and returns it, thus causing the entire\n seq to reside in memory at one time.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3131), lang.NewKeyword("end-line"), int(3131))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("dorun")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.Apply(v6, []any{v3}) - _ = v7 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("dorun")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.Apply(tmp6, []any{v3}) + _ = tmp7 return v3 case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("dorun")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v3, v4}) - _ = v8 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("dorun")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v3, v4}) + _ = tmp8 return v4 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // dorun { - v0 := lang.NewSymbol("dorun").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "When lazy sequences are produced via functions that have side\n effects, any effects other than those needed to produce the first\n element in the seq do not occur until the seq is consumed. dorun can\n be used to force any effects. Walks through the successive nexts of\n the seq, does not retain the head and returns nil.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3116), lang.NewKeyword("end-line"), int(3116))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("dorun").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "When lazy sequences are produced via functions that have side\n effects, any effects other than those needed to produce the first\n element in the seq do not occur until the seq is consumed. dorun can\n be used to force any effects. Walks through the successive nexts of\n the seq, does not retain the head and returns nil.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3116), lang.NewKeyword("end-line"), int(3116))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 recur_loop_579: - var v4 any + var tmp4 any { // let // let binding "temp__0__auto__" - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("seq")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v3}) - var v9 any = v8 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v3}) + var v9 any = tmp8 _ = v9 - var v10 any + var tmp10 any if lang.IsTruthy(v9) { - var v11 any + var tmp11 any { // let // let binding "s" var v12 any = v9 _ = v12 - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("next")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{v12}) - var v13 any = v17 - v3 = v13 + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("next")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{v12}) + var tmp13 any = tmp17 + v3 = tmp13 goto recur_loop_579 } // end let - v10 = v11 + tmp10 = tmp11 } else { - v10 = nil } - v4 = v10 + tmp4 = tmp10 } // end let - return v4 + return tmp4 case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 recur_loop_580: - var v5 any - var v6 any + var tmp5 any + var tmp6 any { // let // let binding "and__0__auto__" - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("seq")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v9, []any{v4}) - var v11 any = v10 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("seq")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp9, []any{v4}) + var v11 any = tmp10 _ = v11 - var v12 any + var tmp12 any if lang.IsTruthy(v11) { - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("pos?")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{v3}) - v12 = v16 + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("pos?")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp12 = tmp16 } else { - v12 = v11 + tmp12 = v11 } - v6 = v12 + tmp6 = tmp12 } // end let - if lang.IsTruthy(v6) { - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("dec")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v3}) - var v7 any = v11 - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("next")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{v4}) - var v12 any = v16 - v3 = v7 - v4 = v12 + if lang.IsTruthy(tmp6) { + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("dec")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v3}) + var tmp7 any = tmp11 + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("next")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{v4}) + var tmp12 any = tmp16 + v3 = tmp7 + v4 = tmp12 goto recur_loop_580 } else { - v5 = nil } - return v5 + return tmp5 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // doseq { - v0 := lang.NewSymbol("doseq").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("seq-exprs"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Repeatedly executes body (presumably for side-effects) with\n bindings and filtering as provided by \"for\". Does not retain\n the head of the sequence. Returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3209), lang.NewKeyword("end-line"), int(3209))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("doseq").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("seq-exprs"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Repeatedly executes body (presumably for side-effects) with\n bindings and filtering as provided by \"for\". Does not retain\n the head of the sequence. Returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3209), lang.NewKeyword("end-line"), int(3209))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 3 { @@ -27994,107 +28089,106 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - var v7 any - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v5}) - if lang.IsTruthy(v11) { - v7 = nil + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("vector?")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v5}) + if lang.IsTruthy(tmp11) { } else { - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("str")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("first")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{v3}) - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("meta")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v3}) - v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) - v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) - v28 := lang.Apply(lang.NewIllegalArgumentError, []any{v27}) - panic(v28) - } - _ = v7 - var v29 any - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("even?")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) - } - v32 := v31.Get() - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("count")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - v36 := lang.Apply(v35, []any{v5}) - v37 := lang.Apply(v32, []any{v36}) - if lang.IsTruthy(v37) { - v29 = nil + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("str")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("first")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("*ns*")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("meta")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.Apply(tmp24, []any{v3}) + tmp26 := lang.Apply(lang.NewKeyword("line"), []any{tmp25}) + tmp27 := lang.Apply(tmp14, []any{tmp18, " requires ", "a vector for its binding", " in ", tmp21, ":", tmp26}) + tmp28 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp27}) + panic(tmp28) + } + _ = tmp7 + var tmp29 any + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("even?")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) + } + tmp32 := tmp31.Get() + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("count")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) + } + tmp35 := tmp34.Get() + tmp36 := lang.Apply(tmp35, []any{v5}) + tmp37 := lang.Apply(tmp32, []any{tmp36}) + if lang.IsTruthy(tmp37) { } else { - v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v39 := v38.FindInternedVar(lang.NewSymbol("str")) - if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) - } - v40 := v39.Get() - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("first")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) - } - v43 := v42.Get() - v44 := lang.Apply(v43, []any{v3}) - v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) - if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) - } - v47 := v46.Get() - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("meta")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v3}) - v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) - v53 := lang.Apply(v40, []any{v44, " requires ", "an even number of forms in binding vector", " in ", v47, ":", v52}) - v54 := lang.Apply(lang.NewIllegalArgumentError, []any{v53}) - panic(v54) - } - _ = v29 - _ = nil - var v55 any + tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp39 := tmp38.FindInternedVar(lang.NewSymbol("str")) + if tmp39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) + } + tmp40 := tmp39.Get() + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("first")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := lang.Apply(tmp43, []any{v3}) + tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp46 := tmp45.FindInternedVar(lang.NewSymbol("*ns*")) + if tmp46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) + } + tmp47 := tmp46.Get() + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("meta")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v3}) + tmp52 := lang.Apply(lang.NewKeyword("line"), []any{tmp51}) + tmp53 := lang.Apply(tmp40, []any{tmp44, " requires ", "an even number of forms in binding vector", " in ", tmp47, ":", tmp52}) + tmp54 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp53}) + panic(tmp54) + } + _ = tmp29 + var tmp55 any { // let // let binding "step" - var v56 lang.FnFunc + var tmp56 lang.FnFunc { // function step - v56 = lang.NewFnFunc(func(args ...any) any { + var v57 lang.FnFunc + tmp56 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -28102,1528 +28196,1523 @@ func init() { _ = v58 v59 := args[1] _ = v59 - var v60 any - v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v62 := v61.FindInternedVar(lang.NewSymbol("not")) - if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) - } - v63 := v62.Get() - v64 := lang.Apply(v63, []any{v59}) - if lang.IsTruthy(v64) { - v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v66 := v65.FindInternedVar(lang.NewSymbol("seq")) - if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) + var tmp60 any + tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp62 := tmp61.FindInternedVar(lang.NewSymbol("not")) + if tmp62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) + } + tmp63 := tmp62.Get() + tmp64 := lang.Apply(tmp63, []any{v59}) + if lang.IsTruthy(tmp64) { + tmp65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp66 := tmp65.FindInternedVar(lang.NewSymbol("seq")) + if tmp66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp66))) } - v67 := v66.Get() - v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v69 := v68.FindInternedVar(lang.NewSymbol("concat")) - if v69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) + tmp67 := tmp66.Get() + tmp68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp69 := tmp68.FindInternedVar(lang.NewSymbol("concat")) + if tmp69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp69))) } - v70 := v69.Get() - v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v72 := v71.FindInternedVar(lang.NewSymbol("list")) - if v72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) + tmp70 := tmp69.Get() + tmp71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp72 := tmp71.FindInternedVar(lang.NewSymbol("list")) + if tmp72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp72))) } - v73 := v72.Get() - v74 := lang.Apply(v73, []any{lang.NewSymbol("do")}) - v75 := lang.Apply(v70, []any{v74, v6}) - v76 := lang.Apply(v67, []any{v75}) - v77 := lang.NewVector(true, v76) - v78 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3220), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(3220), lang.NewKeyword("end-column"), int(36)) - v79, err := lang.WithMeta(v77, v78.(lang.IPersistentMap)) + tmp73 := tmp72.Get() + tmp74 := lang.Apply(tmp73, []any{lang.NewSymbol("do")}) + tmp75 := lang.Apply(tmp70, []any{tmp74, v6}) + tmp76 := lang.Apply(tmp67, []any{tmp75}) + tmp77 := lang.NewVector(true, tmp76) + tmp78 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3220), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(3220), lang.NewKeyword("end-column"), int(36)) + tmp79, err := lang.WithMeta(tmp77, tmp78.(lang.IPersistentMap)) if err != nil { panic(err) } - v60 = v79 + tmp60 = tmp79 } else { - var v80 any + var tmp80 any { // let // let binding "k" - v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v82 := v81.FindInternedVar(lang.NewSymbol("first")) - if v82.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) + tmp81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp82 := tmp81.FindInternedVar(lang.NewSymbol("first")) + if tmp82.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp82))) } - v83 := v82.Get() - v84 := lang.Apply(v83, []any{v59}) - var v85 any = v84 + tmp83 := tmp82.Get() + tmp84 := lang.Apply(tmp83, []any{v59}) + var v85 any = tmp84 _ = v85 // let binding "v" - v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v87 := v86.FindInternedVar(lang.NewSymbol("second")) - if v87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) + tmp86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp87 := tmp86.FindInternedVar(lang.NewSymbol("second")) + if tmp87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp87))) } - v88 := v87.Get() - v89 := lang.Apply(v88, []any{v59}) - var v90 any = v89 + tmp88 := tmp87.Get() + tmp89 := lang.Apply(tmp88, []any{v59}) + var v90 any = tmp89 _ = v90 - var v91 any - v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v93 := v92.FindInternedVar(lang.NewSymbol("keyword?")) - if v93.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) + var tmp91 any + tmp92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp93 := tmp92.FindInternedVar(lang.NewSymbol("keyword?")) + if tmp93.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp93))) } - v94 := v93.Get() - v95 := lang.Apply(v94, []any{v85}) - if lang.IsTruthy(v95) { - var v96 any + tmp94 := tmp93.Get() + tmp95 := lang.Apply(tmp94, []any{v85}) + if lang.IsTruthy(tmp95) { + var tmp96 any { // let // let binding "steppair" - v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v98 := v97.FindInternedVar(lang.NewSymbol("nnext")) - if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) + tmp97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp98 := tmp97.FindInternedVar(lang.NewSymbol("nnext")) + if tmp98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp98))) } - v99 := v98.Get() - v100 := lang.Apply(v99, []any{v59}) - v101 := lang.Apply(v57, []any{v58, v100}) - var v102 any = v101 + tmp99 := tmp98.Get() + tmp100 := lang.Apply(tmp99, []any{v59}) + tmp101 := lang.Apply(v57, []any{v58, tmp100}) + var v102 any = tmp101 _ = v102 // let binding "needrec" - v103 := lang.Apply(v102, []any{int64(0)}) - var v104 any = v103 + tmp103 := lang.Apply(v102, []any{int64(0)}) + var v104 any = tmp103 _ = v104 // let binding "subform" - v105 := lang.Apply(v102, []any{int64(1)}) - var v106 any = v105 + tmp105 := lang.Apply(v102, []any{int64(1)}) + var v106 any = tmp105 _ = v106 - var v107 any - v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v109 := v108.FindInternedVar(lang.NewSymbol("=")) - if v109.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) + var tmp107 any + tmp108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp109 := tmp108.FindInternedVar(lang.NewSymbol("=")) + if tmp109.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp109))) } - v110 := v109.Get() - v111 := lang.Apply(v110, []any{v85, lang.NewKeyword("let")}) - if lang.IsTruthy(v111) { - v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v113 := v112.FindInternedVar(lang.NewSymbol("seq")) - if v113.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) + tmp110 := tmp109.Get() + tmp111 := lang.Apply(tmp110, []any{v85, lang.NewKeyword("let")}) + if lang.IsTruthy(tmp111) { + tmp112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp113 := tmp112.FindInternedVar(lang.NewSymbol("seq")) + if tmp113.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp113))) } - v114 := v113.Get() - v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v116 := v115.FindInternedVar(lang.NewSymbol("concat")) - if v116.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) + tmp114 := tmp113.Get() + tmp115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp116 := tmp115.FindInternedVar(lang.NewSymbol("concat")) + if tmp116.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp116))) } - v117 := v116.Get() - v118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v119 := v118.FindInternedVar(lang.NewSymbol("list")) - if v119.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v119))) + tmp117 := tmp116.Get() + tmp118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp119 := tmp118.FindInternedVar(lang.NewSymbol("list")) + if tmp119.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp119))) } - v120 := v119.Get() - v121 := lang.Apply(v120, []any{lang.NewSymbol("glojure.core/let")}) - v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v123 := v122.FindInternedVar(lang.NewSymbol("list")) - if v123.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) + tmp120 := tmp119.Get() + tmp121 := lang.Apply(tmp120, []any{lang.NewSymbol("glojure.core/let")}) + tmp122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp123 := tmp122.FindInternedVar(lang.NewSymbol("list")) + if tmp123.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp123))) } - v124 := v123.Get() - v125 := lang.Apply(v124, []any{v90}) - v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v127 := v126.FindInternedVar(lang.NewSymbol("list")) - if v127.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) + tmp124 := tmp123.Get() + tmp125 := lang.Apply(tmp124, []any{v90}) + tmp126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp127 := tmp126.FindInternedVar(lang.NewSymbol("list")) + if tmp127.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp127))) } - v128 := v127.Get() - v129 := lang.Apply(v128, []any{v106}) - v130 := lang.Apply(v117, []any{v121, v125, v129}) - v131 := lang.Apply(v114, []any{v130}) - v132 := lang.NewVector(v104, v131) - v133 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3228), lang.NewKeyword("column"), int(37), lang.NewKeyword("end-line"), int(3228), lang.NewKeyword("end-column"), int(64)) - v134, err := lang.WithMeta(v132, v133.(lang.IPersistentMap)) + tmp128 := tmp127.Get() + tmp129 := lang.Apply(tmp128, []any{v106}) + tmp130 := lang.Apply(tmp117, []any{tmp121, tmp125, tmp129}) + tmp131 := lang.Apply(tmp114, []any{tmp130}) + tmp132 := lang.NewVector(v104, tmp131) + tmp133 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3228), lang.NewKeyword("column"), int(37), lang.NewKeyword("end-line"), int(3228), lang.NewKeyword("end-column"), int(64)) + tmp134, err := lang.WithMeta(tmp132, tmp133.(lang.IPersistentMap)) if err != nil { panic(err) } - v107 = v134 + tmp107 = tmp134 } else { - var v135 any - v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v137 := v136.FindInternedVar(lang.NewSymbol("=")) - if v137.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) + var tmp135 any + tmp136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp137 := tmp136.FindInternedVar(lang.NewSymbol("=")) + if tmp137.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp137))) } - v138 := v137.Get() - v139 := lang.Apply(v138, []any{v85, lang.NewKeyword("while")}) - if lang.IsTruthy(v139) { - v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v141 := v140.FindInternedVar(lang.NewSymbol("seq")) - if v141.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) + tmp138 := tmp137.Get() + tmp139 := lang.Apply(tmp138, []any{v85, lang.NewKeyword("while")}) + if lang.IsTruthy(tmp139) { + tmp140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp141 := tmp140.FindInternedVar(lang.NewSymbol("seq")) + if tmp141.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp141))) } - v142 := v141.Get() - v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v144 := v143.FindInternedVar(lang.NewSymbol("concat")) - if v144.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) + tmp142 := tmp141.Get() + tmp143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp144 := tmp143.FindInternedVar(lang.NewSymbol("concat")) + if tmp144.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp144))) } - v145 := v144.Get() - v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v147 := v146.FindInternedVar(lang.NewSymbol("list")) - if v147.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) + tmp145 := tmp144.Get() + tmp146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp147 := tmp146.FindInternedVar(lang.NewSymbol("list")) + if tmp147.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp147))) } - v148 := v147.Get() - v149 := lang.Apply(v148, []any{lang.NewSymbol("glojure.core/when")}) - v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v151 := v150.FindInternedVar(lang.NewSymbol("list")) - if v151.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) + tmp148 := tmp147.Get() + tmp149 := lang.Apply(tmp148, []any{lang.NewSymbol("glojure.core/when")}) + tmp150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp151 := tmp150.FindInternedVar(lang.NewSymbol("list")) + if tmp151.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp151))) } - v152 := v151.Get() - v153 := lang.Apply(v152, []any{v90}) - v154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v155 := v154.FindInternedVar(lang.NewSymbol("list")) - if v155.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v155))) + tmp152 := tmp151.Get() + tmp153 := lang.Apply(tmp152, []any{v90}) + tmp154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp155 := tmp154.FindInternedVar(lang.NewSymbol("list")) + if tmp155.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp155))) } - v156 := v155.Get() - v157 := lang.Apply(v156, []any{v106}) - var v158 any + tmp156 := tmp155.Get() + tmp157 := lang.Apply(tmp156, []any{v106}) + var tmp158 any if lang.IsTruthy(v104) { - v159 := lang.NewVector(v58) - v160 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3231), lang.NewKeyword("column"), int(65), lang.NewKeyword("end-line"), int(3231), lang.NewKeyword("end-column"), int(73)) - v161, err := lang.WithMeta(v159, v160.(lang.IPersistentMap)) + tmp159 := lang.NewVector(v58) + tmp160 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3231), lang.NewKeyword("column"), int(65), lang.NewKeyword("end-line"), int(3231), lang.NewKeyword("end-column"), int(73)) + tmp161, err := lang.WithMeta(tmp159, tmp160.(lang.IPersistentMap)) if err != nil { panic(err) } - v158 = v161 + tmp158 = tmp161 } else { - v158 = nil } - v162 := lang.Apply(v145, []any{v149, v153, v157, v158}) - v163 := lang.Apply(v142, []any{v162}) - v164 := lang.NewVector(false, v163) - v165 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3229), lang.NewKeyword("column"), int(39), lang.NewKeyword("end-line"), int(3231), lang.NewKeyword("end-column"), int(76)) - v166, err := lang.WithMeta(v164, v165.(lang.IPersistentMap)) + tmp162 := lang.Apply(tmp145, []any{tmp149, tmp153, tmp157, tmp158}) + tmp163 := lang.Apply(tmp142, []any{tmp162}) + tmp164 := lang.NewVector(false, tmp163) + tmp165 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3229), lang.NewKeyword("column"), int(39), lang.NewKeyword("end-line"), int(3231), lang.NewKeyword("end-column"), int(76)) + tmp166, err := lang.WithMeta(tmp164, tmp165.(lang.IPersistentMap)) if err != nil { panic(err) } - v135 = v166 + tmp135 = tmp166 } else { - var v167 any - v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v169 := v168.FindInternedVar(lang.NewSymbol("=")) - if v169.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) + var tmp167 any + tmp168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp169 := tmp168.FindInternedVar(lang.NewSymbol("=")) + if tmp169.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp169))) } - v170 := v169.Get() - v171 := lang.Apply(v170, []any{v85, lang.NewKeyword("when")}) - if lang.IsTruthy(v171) { - v172 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v173 := v172.FindInternedVar(lang.NewSymbol("seq")) - if v173.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v173))) + tmp170 := tmp169.Get() + tmp171 := lang.Apply(tmp170, []any{v85, lang.NewKeyword("when")}) + if lang.IsTruthy(tmp171) { + tmp172 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp173 := tmp172.FindInternedVar(lang.NewSymbol("seq")) + if tmp173.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp173))) } - v174 := v173.Get() - v175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v176 := v175.FindInternedVar(lang.NewSymbol("concat")) - if v176.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v176))) + tmp174 := tmp173.Get() + tmp175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp176 := tmp175.FindInternedVar(lang.NewSymbol("concat")) + if tmp176.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp176))) } - v177 := v176.Get() - v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v179 := v178.FindInternedVar(lang.NewSymbol("list")) - if v179.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) + tmp177 := tmp176.Get() + tmp178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp179 := tmp178.FindInternedVar(lang.NewSymbol("list")) + if tmp179.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp179))) } - v180 := v179.Get() - v181 := lang.Apply(v180, []any{lang.NewSymbol("if")}) - v182 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v183 := v182.FindInternedVar(lang.NewSymbol("list")) - if v183.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v183))) + tmp180 := tmp179.Get() + tmp181 := lang.Apply(tmp180, []any{lang.NewSymbol("if")}) + tmp182 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp183 := tmp182.FindInternedVar(lang.NewSymbol("list")) + if tmp183.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp183))) } - v184 := v183.Get() - v185 := lang.Apply(v184, []any{v90}) - v186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v187 := v186.FindInternedVar(lang.NewSymbol("list")) - if v187.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v187))) + tmp184 := tmp183.Get() + tmp185 := lang.Apply(tmp184, []any{v90}) + tmp186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp187 := tmp186.FindInternedVar(lang.NewSymbol("list")) + if tmp187.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp187))) } - v188 := v187.Get() - v189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v190 := v189.FindInternedVar(lang.NewSymbol("seq")) - if v190.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v190))) + tmp188 := tmp187.Get() + tmp189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp190 := tmp189.FindInternedVar(lang.NewSymbol("seq")) + if tmp190.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp190))) } - v191 := v190.Get() - v192 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v193 := v192.FindInternedVar(lang.NewSymbol("concat")) - if v193.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v193))) + tmp191 := tmp190.Get() + tmp192 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp193 := tmp192.FindInternedVar(lang.NewSymbol("concat")) + if tmp193.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp193))) } - v194 := v193.Get() - v195 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v196 := v195.FindInternedVar(lang.NewSymbol("list")) - if v196.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v196))) + tmp194 := tmp193.Get() + tmp195 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp196 := tmp195.FindInternedVar(lang.NewSymbol("list")) + if tmp196.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp196))) } - v197 := v196.Get() - v198 := lang.Apply(v197, []any{lang.NewSymbol("do")}) - v199 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v200 := v199.FindInternedVar(lang.NewSymbol("list")) - if v200.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v200))) + tmp197 := tmp196.Get() + tmp198 := lang.Apply(tmp197, []any{lang.NewSymbol("do")}) + tmp199 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp200 := tmp199.FindInternedVar(lang.NewSymbol("list")) + if tmp200.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp200))) } - v201 := v200.Get() - v202 := lang.Apply(v201, []any{v106}) - var v203 any + tmp201 := tmp200.Get() + tmp202 := lang.Apply(tmp201, []any{v106}) + var tmp203 any if lang.IsTruthy(v104) { - v204 := lang.NewVector(v58) - v205 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3235), lang.NewKeyword("column"), int(66), lang.NewKeyword("end-line"), int(3235), lang.NewKeyword("end-column"), int(74)) - v206, err := lang.WithMeta(v204, v205.(lang.IPersistentMap)) + tmp204 := lang.NewVector(v58) + tmp205 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3235), lang.NewKeyword("column"), int(66), lang.NewKeyword("end-line"), int(3235), lang.NewKeyword("end-column"), int(74)) + tmp206, err := lang.WithMeta(tmp204, tmp205.(lang.IPersistentMap)) if err != nil { panic(err) } - v203 = v206 + tmp203 = tmp206 } else { - v203 = nil } - v207 := lang.Apply(v194, []any{v198, v202, v203}) - v208 := lang.Apply(v191, []any{v207}) - v209 := lang.Apply(v188, []any{v208}) - v210 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v211 := v210.FindInternedVar(lang.NewSymbol("list")) - if v211.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v211))) + tmp207 := lang.Apply(tmp194, []any{tmp198, tmp202, tmp203}) + tmp208 := lang.Apply(tmp191, []any{tmp207}) + tmp209 := lang.Apply(tmp188, []any{tmp208}) + tmp210 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp211 := tmp210.FindInternedVar(lang.NewSymbol("list")) + if tmp211.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp211))) } - v212 := v211.Get() - v213 := lang.Apply(v212, []any{v58}) - v214 := lang.Apply(v177, []any{v181, v185, v209, v213}) - v215 := lang.Apply(v174, []any{v214}) - v216 := lang.NewVector(false, v215) - v217 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3232), lang.NewKeyword("column"), int(38), lang.NewKeyword("end-line"), int(3236), lang.NewKeyword("end-column"), int(57)) - v218, err := lang.WithMeta(v216, v217.(lang.IPersistentMap)) + tmp212 := tmp211.Get() + tmp213 := lang.Apply(tmp212, []any{v58}) + tmp214 := lang.Apply(tmp177, []any{tmp181, tmp185, tmp209, tmp213}) + tmp215 := lang.Apply(tmp174, []any{tmp214}) + tmp216 := lang.NewVector(false, tmp215) + tmp217 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3232), lang.NewKeyword("column"), int(38), lang.NewKeyword("end-line"), int(3236), lang.NewKeyword("end-column"), int(57)) + tmp218, err := lang.WithMeta(tmp216, tmp217.(lang.IPersistentMap)) if err != nil { panic(err) } - v167 = v218 + tmp167 = tmp218 } else { - v167 = nil } - v135 = v167 + tmp135 = tmp167 } - v107 = v135 + tmp107 = tmp135 } - v96 = v107 + tmp96 = tmp107 } // end let - v91 = v96 + tmp91 = tmp96 } else { - var v97 any + var tmp97 any { // let // let binding "seq-" - v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v99 := v98.FindInternedVar(lang.NewSymbol("gensym")) - if v99.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) + tmp98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp99 := tmp98.FindInternedVar(lang.NewSymbol("gensym")) + if tmp99.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp99))) } - v100 := v99.Get() - v101 := lang.Apply(v100, []any{"seq_"}) - var v102 any = v101 + tmp100 := tmp99.Get() + tmp101 := lang.Apply(tmp100, []any{"seq_"}) + var v102 any = tmp101 _ = v102 // let binding "chunk-" - v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v104 := v103.FindInternedVar(lang.NewSymbol("with-meta")) - if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) + tmp103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp104 := tmp103.FindInternedVar(lang.NewSymbol("with-meta")) + if tmp104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp104))) } - v105 := v104.Get() - v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v107 := v106.FindInternedVar(lang.NewSymbol("gensym")) - if v107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) + tmp105 := tmp104.Get() + tmp106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp107 := tmp106.FindInternedVar(lang.NewSymbol("gensym")) + if tmp107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp107))) } - v108 := v107.Get() - v109 := lang.Apply(v108, []any{"chunk_"}) - v110 := lang.NewMap(lang.NewKeyword("tag"), lang.NewSymbol("glojure.lang.IChunk")) - v111 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3239), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(3239), lang.NewKeyword("end-column"), int(72)) - v112, err := lang.WithMeta(v110, v111.(lang.IPersistentMap)) + tmp108 := tmp107.Get() + tmp109 := lang.Apply(tmp108, []any{"chunk_"}) + tmp110 := lang.NewMap(lang.NewKeyword("tag"), lang.NewSymbol("glojure.lang.IChunk")) + tmp111 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3239), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(3239), lang.NewKeyword("end-column"), int(72)) + tmp112, err := lang.WithMeta(tmp110, tmp111.(lang.IPersistentMap)) if err != nil { panic(err) } - v113 := lang.Apply(v105, []any{v109, v112}) - var v114 any = v113 + tmp113 := lang.Apply(tmp105, []any{tmp109, tmp112}) + var v114 any = tmp113 _ = v114 // let binding "count-" - v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v116 := v115.FindInternedVar(lang.NewSymbol("gensym")) - if v116.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) + tmp115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp116 := tmp115.FindInternedVar(lang.NewSymbol("gensym")) + if tmp116.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp116))) } - v117 := v116.Get() - v118 := lang.Apply(v117, []any{"count_"}) - var v119 any = v118 + tmp117 := tmp116.Get() + tmp118 := lang.Apply(tmp117, []any{"count_"}) + var v119 any = tmp118 _ = v119 // let binding "i-" - v120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v121 := v120.FindInternedVar(lang.NewSymbol("gensym")) - if v121.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v121))) + tmp120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp121 := tmp120.FindInternedVar(lang.NewSymbol("gensym")) + if tmp121.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp121))) } - v122 := v121.Get() - v123 := lang.Apply(v122, []any{"i_"}) - var v124 any = v123 + tmp122 := tmp121.Get() + tmp123 := lang.Apply(tmp122, []any{"i_"}) + var v124 any = tmp123 _ = v124 // let binding "recform" - v125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v126 := v125.FindInternedVar(lang.NewSymbol("seq")) - if v126.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v126))) + tmp125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp126 := tmp125.FindInternedVar(lang.NewSymbol("seq")) + if tmp126.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp126))) } - v127 := v126.Get() - v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v129 := v128.FindInternedVar(lang.NewSymbol("concat")) - if v129.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v129))) + tmp127 := tmp126.Get() + tmp128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp129 := tmp128.FindInternedVar(lang.NewSymbol("concat")) + if tmp129.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp129))) } - v130 := v129.Get() - v131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v132 := v131.FindInternedVar(lang.NewSymbol("list")) - if v132.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v132))) + tmp130 := tmp129.Get() + tmp131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp132 := tmp131.FindInternedVar(lang.NewSymbol("list")) + if tmp132.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp132))) } - v133 := v132.Get() - v134 := lang.Apply(v133, []any{lang.NewSymbol("recur")}) - v135 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v136 := v135.FindInternedVar(lang.NewSymbol("list")) - if v136.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v136))) + tmp133 := tmp132.Get() + tmp134 := lang.Apply(tmp133, []any{lang.NewSymbol("recur")}) + tmp135 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp136 := tmp135.FindInternedVar(lang.NewSymbol("list")) + if tmp136.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp136))) } - v137 := v136.Get() - v138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v139 := v138.FindInternedVar(lang.NewSymbol("seq")) - if v139.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v139))) + tmp137 := tmp136.Get() + tmp138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp139 := tmp138.FindInternedVar(lang.NewSymbol("seq")) + if tmp139.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp139))) } - v140 := v139.Get() - v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v142 := v141.FindInternedVar(lang.NewSymbol("concat")) - if v142.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) + tmp140 := tmp139.Get() + tmp141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp142 := tmp141.FindInternedVar(lang.NewSymbol("concat")) + if tmp142.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp142))) } - v143 := v142.Get() - v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v145 := v144.FindInternedVar(lang.NewSymbol("list")) - if v145.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) + tmp143 := tmp142.Get() + tmp144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp145 := tmp144.FindInternedVar(lang.NewSymbol("list")) + if tmp145.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp145))) } - v146 := v145.Get() - v147 := lang.Apply(v146, []any{lang.NewSymbol("glojure.core/next")}) - v148 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v149 := v148.FindInternedVar(lang.NewSymbol("list")) - if v149.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v149))) + tmp146 := tmp145.Get() + tmp147 := lang.Apply(tmp146, []any{lang.NewSymbol("glojure.core/next")}) + tmp148 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp149 := tmp148.FindInternedVar(lang.NewSymbol("list")) + if tmp149.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp149))) } - v150 := v149.Get() - v151 := lang.Apply(v150, []any{v102}) - v152 := lang.Apply(v143, []any{v147, v151}) - v153 := lang.Apply(v140, []any{v152}) - v154 := lang.Apply(v137, []any{v153}) - v155 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v156 := v155.FindInternedVar(lang.NewSymbol("list")) - if v156.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v156))) + tmp150 := tmp149.Get() + tmp151 := lang.Apply(tmp150, []any{v102}) + tmp152 := lang.Apply(tmp143, []any{tmp147, tmp151}) + tmp153 := lang.Apply(tmp140, []any{tmp152}) + tmp154 := lang.Apply(tmp137, []any{tmp153}) + tmp155 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp156 := tmp155.FindInternedVar(lang.NewSymbol("list")) + if tmp156.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp156))) } - v157 := v156.Get() - v158 := lang.Apply(v157, []any{nil}) - v159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v160 := v159.FindInternedVar(lang.NewSymbol("list")) - if v160.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v160))) + tmp157 := tmp156.Get() + tmp158 := lang.Apply(tmp157, []any{nil}) + tmp159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp160 := tmp159.FindInternedVar(lang.NewSymbol("list")) + if tmp160.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp160))) } - v161 := v160.Get() - v162 := lang.Apply(v161, []any{int64(0)}) - v163 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v164 := v163.FindInternedVar(lang.NewSymbol("list")) - if v164.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v164))) + tmp161 := tmp160.Get() + tmp162 := lang.Apply(tmp161, []any{int64(0)}) + tmp163 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp164 := tmp163.FindInternedVar(lang.NewSymbol("list")) + if tmp164.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp164))) } - v165 := v164.Get() - v166 := lang.Apply(v165, []any{int64(0)}) - v167 := lang.Apply(v130, []any{v134, v154, v158, v162, v166}) - v168 := lang.Apply(v127, []any{v167}) - var v169 any = v168 + tmp165 := tmp164.Get() + tmp166 := lang.Apply(tmp165, []any{int64(0)}) + tmp167 := lang.Apply(tmp130, []any{tmp134, tmp154, tmp158, tmp162, tmp166}) + tmp168 := lang.Apply(tmp127, []any{tmp167}) + var v169 any = tmp168 _ = v169 // let binding "steppair" - v170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v171 := v170.FindInternedVar(lang.NewSymbol("nnext")) - if v171.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v171))) + tmp170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp171 := tmp170.FindInternedVar(lang.NewSymbol("nnext")) + if tmp171.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp171))) } - v172 := v171.Get() - v173 := lang.Apply(v172, []any{v59}) - v174 := lang.Apply(v57, []any{v169, v173}) - var v175 any = v174 + tmp172 := tmp171.Get() + tmp173 := lang.Apply(tmp172, []any{v59}) + tmp174 := lang.Apply(v57, []any{v169, tmp173}) + var v175 any = tmp174 _ = v175 // let binding "needrec" - v176 := lang.Apply(v175, []any{int64(0)}) - var v177 any = v176 + tmp176 := lang.Apply(v175, []any{int64(0)}) + var v177 any = tmp176 _ = v177 // let binding "subform" - v178 := lang.Apply(v175, []any{int64(1)}) - var v179 any = v178 + tmp178 := lang.Apply(v175, []any{int64(1)}) + var v179 any = tmp178 _ = v179 // let binding "recform-chunk" - v180 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v181 := v180.FindInternedVar(lang.NewSymbol("seq")) - if v181.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v181))) + tmp180 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp181 := tmp180.FindInternedVar(lang.NewSymbol("seq")) + if tmp181.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp181))) } - v182 := v181.Get() - v183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v184 := v183.FindInternedVar(lang.NewSymbol("concat")) - if v184.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v184))) + tmp182 := tmp181.Get() + tmp183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp184 := tmp183.FindInternedVar(lang.NewSymbol("concat")) + if tmp184.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp184))) } - v185 := v184.Get() - v186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v187 := v186.FindInternedVar(lang.NewSymbol("list")) - if v187.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v187))) + tmp185 := tmp184.Get() + tmp186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp187 := tmp186.FindInternedVar(lang.NewSymbol("list")) + if tmp187.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp187))) } - v188 := v187.Get() - v189 := lang.Apply(v188, []any{lang.NewSymbol("recur")}) - v190 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v191 := v190.FindInternedVar(lang.NewSymbol("list")) - if v191.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v191))) + tmp188 := tmp187.Get() + tmp189 := lang.Apply(tmp188, []any{lang.NewSymbol("recur")}) + tmp190 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp191 := tmp190.FindInternedVar(lang.NewSymbol("list")) + if tmp191.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp191))) } - v192 := v191.Get() - v193 := lang.Apply(v192, []any{v102}) - v194 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v195 := v194.FindInternedVar(lang.NewSymbol("list")) - if v195.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v195))) + tmp192 := tmp191.Get() + tmp193 := lang.Apply(tmp192, []any{v102}) + tmp194 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp195 := tmp194.FindInternedVar(lang.NewSymbol("list")) + if tmp195.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp195))) } - v196 := v195.Get() - v197 := lang.Apply(v196, []any{v114}) - v198 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v199 := v198.FindInternedVar(lang.NewSymbol("list")) - if v199.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v199))) + tmp196 := tmp195.Get() + tmp197 := lang.Apply(tmp196, []any{v114}) + tmp198 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp199 := tmp198.FindInternedVar(lang.NewSymbol("list")) + if tmp199.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp199))) } - v200 := v199.Get() - v201 := lang.Apply(v200, []any{v119}) - v202 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v203 := v202.FindInternedVar(lang.NewSymbol("list")) - if v203.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v203))) + tmp200 := tmp199.Get() + tmp201 := lang.Apply(tmp200, []any{v119}) + tmp202 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp203 := tmp202.FindInternedVar(lang.NewSymbol("list")) + if tmp203.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp203))) } - v204 := v203.Get() - v205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v206 := v205.FindInternedVar(lang.NewSymbol("seq")) - if v206.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v206))) + tmp204 := tmp203.Get() + tmp205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp206 := tmp205.FindInternedVar(lang.NewSymbol("seq")) + if tmp206.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp206))) } - v207 := v206.Get() - v208 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v209 := v208.FindInternedVar(lang.NewSymbol("concat")) - if v209.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v209))) + tmp207 := tmp206.Get() + tmp208 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp209 := tmp208.FindInternedVar(lang.NewSymbol("concat")) + if tmp209.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp209))) } - v210 := v209.Get() - v211 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v212 := v211.FindInternedVar(lang.NewSymbol("list")) - if v212.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v212))) + tmp210 := tmp209.Get() + tmp211 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp212 := tmp211.FindInternedVar(lang.NewSymbol("list")) + if tmp212.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp212))) } - v213 := v212.Get() - v214 := lang.Apply(v213, []any{lang.NewSymbol("glojure.core/unchecked-inc")}) - v215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v216 := v215.FindInternedVar(lang.NewSymbol("list")) - if v216.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v216))) + tmp213 := tmp212.Get() + tmp214 := lang.Apply(tmp213, []any{lang.NewSymbol("glojure.core/unchecked-inc")}) + tmp215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp216 := tmp215.FindInternedVar(lang.NewSymbol("list")) + if tmp216.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp216))) } - v217 := v216.Get() - v218 := lang.Apply(v217, []any{v124}) - v219 := lang.Apply(v210, []any{v214, v218}) - v220 := lang.Apply(v207, []any{v219}) - v221 := lang.Apply(v204, []any{v220}) - v222 := lang.Apply(v185, []any{v189, v193, v197, v201, v221}) - v223 := lang.Apply(v182, []any{v222}) - var v224 any = v223 + tmp217 := tmp216.Get() + tmp218 := lang.Apply(tmp217, []any{v124}) + tmp219 := lang.Apply(tmp210, []any{tmp214, tmp218}) + tmp220 := lang.Apply(tmp207, []any{tmp219}) + tmp221 := lang.Apply(tmp204, []any{tmp220}) + tmp222 := lang.Apply(tmp185, []any{tmp189, tmp193, tmp197, tmp201, tmp221}) + tmp223 := lang.Apply(tmp182, []any{tmp222}) + var v224 any = tmp223 _ = v224 // let binding "steppair-chunk" - v225 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v226 := v225.FindInternedVar(lang.NewSymbol("nnext")) - if v226.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v226))) + tmp225 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp226 := tmp225.FindInternedVar(lang.NewSymbol("nnext")) + if tmp226.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp226))) } - v227 := v226.Get() - v228 := lang.Apply(v227, []any{v59}) - v229 := lang.Apply(v57, []any{v224, v228}) - var v230 any = v229 + tmp227 := tmp226.Get() + tmp228 := lang.Apply(tmp227, []any{v59}) + tmp229 := lang.Apply(v57, []any{v224, tmp228}) + var v230 any = tmp229 _ = v230 // let binding "subform-chunk" - v231 := lang.Apply(v230, []any{int64(1)}) - var v232 any = v231 + tmp231 := lang.Apply(v230, []any{int64(1)}) + var v232 any = tmp231 _ = v232 - v233 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v234 := v233.FindInternedVar(lang.NewSymbol("seq")) - if v234.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v234))) + tmp233 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp234 := tmp233.FindInternedVar(lang.NewSymbol("seq")) + if tmp234.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp234))) } - v235 := v234.Get() - v236 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v237 := v236.FindInternedVar(lang.NewSymbol("concat")) - if v237.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v237))) + tmp235 := tmp234.Get() + tmp236 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp237 := tmp236.FindInternedVar(lang.NewSymbol("concat")) + if tmp237.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp237))) } - v238 := v237.Get() - v239 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v240 := v239.FindInternedVar(lang.NewSymbol("list")) - if v240.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v240))) + tmp238 := tmp237.Get() + tmp239 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp240 := tmp239.FindInternedVar(lang.NewSymbol("list")) + if tmp240.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp240))) } - v241 := v240.Get() - v242 := lang.Apply(v241, []any{lang.NewSymbol("glojure.core/loop")}) - v243 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v244 := v243.FindInternedVar(lang.NewSymbol("list")) - if v244.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v244))) + tmp241 := tmp240.Get() + tmp242 := lang.Apply(tmp241, []any{lang.NewSymbol("glojure.core/loop")}) + tmp243 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp244 := tmp243.FindInternedVar(lang.NewSymbol("list")) + if tmp244.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp244))) } - v245 := v244.Get() - v246 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v247 := v246.FindInternedVar(lang.NewSymbol("apply")) - if v247.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v247))) + tmp245 := tmp244.Get() + tmp246 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp247 := tmp246.FindInternedVar(lang.NewSymbol("apply")) + if tmp247.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp247))) } - v248 := v247.Get() - v249 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v250 := v249.FindInternedVar(lang.NewSymbol("vector")) - if v250.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v250))) + tmp248 := tmp247.Get() + tmp249 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp250 := tmp249.FindInternedVar(lang.NewSymbol("vector")) + if tmp250.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp250))) } - v251 := v250.Get() - v252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v253 := v252.FindInternedVar(lang.NewSymbol("seq")) - if v253.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v253))) + tmp251 := tmp250.Get() + tmp252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp253 := tmp252.FindInternedVar(lang.NewSymbol("seq")) + if tmp253.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp253))) } - v254 := v253.Get() - v255 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v256 := v255.FindInternedVar(lang.NewSymbol("concat")) - if v256.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v256))) + tmp254 := tmp253.Get() + tmp255 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp256 := tmp255.FindInternedVar(lang.NewSymbol("concat")) + if tmp256.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp256))) } - v257 := v256.Get() - v258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v259 := v258.FindInternedVar(lang.NewSymbol("list")) - if v259.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v259))) + tmp257 := tmp256.Get() + tmp258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp259 := tmp258.FindInternedVar(lang.NewSymbol("list")) + if tmp259.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp259))) } - v260 := v259.Get() - v261 := lang.Apply(v260, []any{v102}) - v262 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v263 := v262.FindInternedVar(lang.NewSymbol("list")) - if v263.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v263))) + tmp260 := tmp259.Get() + tmp261 := lang.Apply(tmp260, []any{v102}) + tmp262 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp263 := tmp262.FindInternedVar(lang.NewSymbol("list")) + if tmp263.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp263))) } - v264 := v263.Get() - v265 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v266 := v265.FindInternedVar(lang.NewSymbol("seq")) - if v266.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v266))) + tmp264 := tmp263.Get() + tmp265 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp266 := tmp265.FindInternedVar(lang.NewSymbol("seq")) + if tmp266.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp266))) } - v267 := v266.Get() - v268 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v269 := v268.FindInternedVar(lang.NewSymbol("concat")) - if v269.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v269))) + tmp267 := tmp266.Get() + tmp268 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp269 := tmp268.FindInternedVar(lang.NewSymbol("concat")) + if tmp269.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp269))) } - v270 := v269.Get() - v271 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v272 := v271.FindInternedVar(lang.NewSymbol("list")) - if v272.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v272))) + tmp270 := tmp269.Get() + tmp271 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp272 := tmp271.FindInternedVar(lang.NewSymbol("list")) + if tmp272.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp272))) } - v273 := v272.Get() - v274 := lang.Apply(v273, []any{lang.NewSymbol("glojure.core/seq")}) - v275 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v276 := v275.FindInternedVar(lang.NewSymbol("list")) - if v276.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v276))) + tmp273 := tmp272.Get() + tmp274 := lang.Apply(tmp273, []any{lang.NewSymbol("glojure.core/seq")}) + tmp275 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp276 := tmp275.FindInternedVar(lang.NewSymbol("list")) + if tmp276.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp276))) } - v277 := v276.Get() - v278 := lang.Apply(v277, []any{v90}) - v279 := lang.Apply(v270, []any{v274, v278}) - v280 := lang.Apply(v267, []any{v279}) - v281 := lang.Apply(v264, []any{v280}) - v282 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v283 := v282.FindInternedVar(lang.NewSymbol("list")) - if v283.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v283))) + tmp277 := tmp276.Get() + tmp278 := lang.Apply(tmp277, []any{v90}) + tmp279 := lang.Apply(tmp270, []any{tmp274, tmp278}) + tmp280 := lang.Apply(tmp267, []any{tmp279}) + tmp281 := lang.Apply(tmp264, []any{tmp280}) + tmp282 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp283 := tmp282.FindInternedVar(lang.NewSymbol("list")) + if tmp283.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp283))) } - v284 := v283.Get() - v285 := lang.Apply(v284, []any{v114}) - v286 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v287 := v286.FindInternedVar(lang.NewSymbol("list")) - if v287.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v287))) + tmp284 := tmp283.Get() + tmp285 := lang.Apply(tmp284, []any{v114}) + tmp286 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp287 := tmp286.FindInternedVar(lang.NewSymbol("list")) + if tmp287.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp287))) } - v288 := v287.Get() - v289 := lang.Apply(v288, []any{nil}) - v290 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v291 := v290.FindInternedVar(lang.NewSymbol("list")) - if v291.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v291))) + tmp288 := tmp287.Get() + tmp289 := lang.Apply(tmp288, []any{nil}) + tmp290 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp291 := tmp290.FindInternedVar(lang.NewSymbol("list")) + if tmp291.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp291))) } - v292 := v291.Get() - v293 := lang.Apply(v292, []any{v119}) - v294 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v295 := v294.FindInternedVar(lang.NewSymbol("list")) - if v295.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v295))) + tmp292 := tmp291.Get() + tmp293 := lang.Apply(tmp292, []any{v119}) + tmp294 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp295 := tmp294.FindInternedVar(lang.NewSymbol("list")) + if tmp295.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp295))) } - v296 := v295.Get() - v297 := lang.Apply(v296, []any{int64(0)}) - v298 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v299 := v298.FindInternedVar(lang.NewSymbol("list")) - if v299.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v299))) + tmp296 := tmp295.Get() + tmp297 := lang.Apply(tmp296, []any{int64(0)}) + tmp298 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp299 := tmp298.FindInternedVar(lang.NewSymbol("list")) + if tmp299.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp299))) } - v300 := v299.Get() - v301 := lang.Apply(v300, []any{v124}) - v302 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v303 := v302.FindInternedVar(lang.NewSymbol("list")) - if v303.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v303))) + tmp300 := tmp299.Get() + tmp301 := lang.Apply(tmp300, []any{v124}) + tmp302 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp303 := tmp302.FindInternedVar(lang.NewSymbol("list")) + if tmp303.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp303))) } - v304 := v303.Get() - v305 := lang.Apply(v304, []any{int64(0)}) - v306 := lang.Apply(v257, []any{v261, v281, v285, v289, v293, v297, v301, v305}) - v307 := lang.Apply(v254, []any{v306}) - v308 := lang.Apply(v248, []any{v251, v307}) - v309 := lang.Apply(v245, []any{v308}) - v310 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v311 := v310.FindInternedVar(lang.NewSymbol("list")) - if v311.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v311))) + tmp304 := tmp303.Get() + tmp305 := lang.Apply(tmp304, []any{int64(0)}) + tmp306 := lang.Apply(tmp257, []any{tmp261, tmp281, tmp285, tmp289, tmp293, tmp297, tmp301, tmp305}) + tmp307 := lang.Apply(tmp254, []any{tmp306}) + tmp308 := lang.Apply(tmp248, []any{tmp251, tmp307}) + tmp309 := lang.Apply(tmp245, []any{tmp308}) + tmp310 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp311 := tmp310.FindInternedVar(lang.NewSymbol("list")) + if tmp311.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp311))) } - v312 := v311.Get() - v313 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v314 := v313.FindInternedVar(lang.NewSymbol("seq")) - if v314.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v314))) + tmp312 := tmp311.Get() + tmp313 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp314 := tmp313.FindInternedVar(lang.NewSymbol("seq")) + if tmp314.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp314))) } - v315 := v314.Get() - v316 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v317 := v316.FindInternedVar(lang.NewSymbol("concat")) - if v317.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v317))) + tmp315 := tmp314.Get() + tmp316 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp317 := tmp316.FindInternedVar(lang.NewSymbol("concat")) + if tmp317.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp317))) } - v318 := v317.Get() - v319 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v320 := v319.FindInternedVar(lang.NewSymbol("list")) - if v320.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v320))) + tmp318 := tmp317.Get() + tmp319 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp320 := tmp319.FindInternedVar(lang.NewSymbol("list")) + if tmp320.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp320))) } - v321 := v320.Get() - v322 := lang.Apply(v321, []any{lang.NewSymbol("if")}) - v323 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v324 := v323.FindInternedVar(lang.NewSymbol("list")) - if v324.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v324))) + tmp321 := tmp320.Get() + tmp322 := lang.Apply(tmp321, []any{lang.NewSymbol("if")}) + tmp323 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp324 := tmp323.FindInternedVar(lang.NewSymbol("list")) + if tmp324.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp324))) } - v325 := v324.Get() - v326 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v327 := v326.FindInternedVar(lang.NewSymbol("seq")) - if v327.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v327))) + tmp325 := tmp324.Get() + tmp326 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp327 := tmp326.FindInternedVar(lang.NewSymbol("seq")) + if tmp327.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp327))) } - v328 := v327.Get() - v329 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v330 := v329.FindInternedVar(lang.NewSymbol("concat")) - if v330.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v330))) + tmp328 := tmp327.Get() + tmp329 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp330 := tmp329.FindInternedVar(lang.NewSymbol("concat")) + if tmp330.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp330))) } - v331 := v330.Get() - v332 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v333 := v332.FindInternedVar(lang.NewSymbol("list")) - if v333.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v333))) + tmp331 := tmp330.Get() + tmp332 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp333 := tmp332.FindInternedVar(lang.NewSymbol("list")) + if tmp333.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp333))) } - v334 := v333.Get() - v335 := lang.Apply(v334, []any{lang.NewSymbol("glojure.core/<")}) - v336 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v337 := v336.FindInternedVar(lang.NewSymbol("list")) - if v337.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v337))) + tmp334 := tmp333.Get() + tmp335 := lang.Apply(tmp334, []any{lang.NewSymbol("glojure.core/<")}) + tmp336 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp337 := tmp336.FindInternedVar(lang.NewSymbol("list")) + if tmp337.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp337))) } - v338 := v337.Get() - v339 := lang.Apply(v338, []any{v124}) - v340 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v341 := v340.FindInternedVar(lang.NewSymbol("list")) - if v341.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v341))) + tmp338 := tmp337.Get() + tmp339 := lang.Apply(tmp338, []any{v124}) + tmp340 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp341 := tmp340.FindInternedVar(lang.NewSymbol("list")) + if tmp341.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp341))) } - v342 := v341.Get() - v343 := lang.Apply(v342, []any{v119}) - v344 := lang.Apply(v331, []any{v335, v339, v343}) - v345 := lang.Apply(v328, []any{v344}) - v346 := lang.Apply(v325, []any{v345}) - v347 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v348 := v347.FindInternedVar(lang.NewSymbol("list")) - if v348.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v348))) + tmp342 := tmp341.Get() + tmp343 := lang.Apply(tmp342, []any{v119}) + tmp344 := lang.Apply(tmp331, []any{tmp335, tmp339, tmp343}) + tmp345 := lang.Apply(tmp328, []any{tmp344}) + tmp346 := lang.Apply(tmp325, []any{tmp345}) + tmp347 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp348 := tmp347.FindInternedVar(lang.NewSymbol("list")) + if tmp348.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp348))) } - v349 := v348.Get() - v350 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v351 := v350.FindInternedVar(lang.NewSymbol("seq")) - if v351.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v351))) + tmp349 := tmp348.Get() + tmp350 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp351 := tmp350.FindInternedVar(lang.NewSymbol("seq")) + if tmp351.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp351))) } - v352 := v351.Get() - v353 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v354 := v353.FindInternedVar(lang.NewSymbol("concat")) - if v354.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v354))) + tmp352 := tmp351.Get() + tmp353 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp354 := tmp353.FindInternedVar(lang.NewSymbol("concat")) + if tmp354.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp354))) } - v355 := v354.Get() - v356 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v357 := v356.FindInternedVar(lang.NewSymbol("list")) - if v357.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v357))) + tmp355 := tmp354.Get() + tmp356 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp357 := tmp356.FindInternedVar(lang.NewSymbol("list")) + if tmp357.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp357))) } - v358 := v357.Get() - v359 := lang.Apply(v358, []any{lang.NewSymbol("glojure.core/let")}) - v360 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v361 := v360.FindInternedVar(lang.NewSymbol("list")) - if v361.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v361))) + tmp358 := tmp357.Get() + tmp359 := lang.Apply(tmp358, []any{lang.NewSymbol("glojure.core/let")}) + tmp360 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp361 := tmp360.FindInternedVar(lang.NewSymbol("list")) + if tmp361.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp361))) } - v362 := v361.Get() - v363 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v364 := v363.FindInternedVar(lang.NewSymbol("apply")) - if v364.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v364))) + tmp362 := tmp361.Get() + tmp363 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp364 := tmp363.FindInternedVar(lang.NewSymbol("apply")) + if tmp364.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp364))) } - v365 := v364.Get() - v366 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v367 := v366.FindInternedVar(lang.NewSymbol("vector")) - if v367.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v367))) + tmp365 := tmp364.Get() + tmp366 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp367 := tmp366.FindInternedVar(lang.NewSymbol("vector")) + if tmp367.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp367))) } - v368 := v367.Get() - v369 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v370 := v369.FindInternedVar(lang.NewSymbol("seq")) - if v370.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v370))) + tmp368 := tmp367.Get() + tmp369 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp370 := tmp369.FindInternedVar(lang.NewSymbol("seq")) + if tmp370.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp370))) } - v371 := v370.Get() - v372 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v373 := v372.FindInternedVar(lang.NewSymbol("concat")) - if v373.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v373))) + tmp371 := tmp370.Get() + tmp372 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp373 := tmp372.FindInternedVar(lang.NewSymbol("concat")) + if tmp373.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp373))) } - v374 := v373.Get() - v375 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v376 := v375.FindInternedVar(lang.NewSymbol("list")) - if v376.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v376))) + tmp374 := tmp373.Get() + tmp375 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp376 := tmp375.FindInternedVar(lang.NewSymbol("list")) + if tmp376.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp376))) } - v377 := v376.Get() - v378 := lang.Apply(v377, []any{v85}) - v379 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v380 := v379.FindInternedVar(lang.NewSymbol("list")) - if v380.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v380))) + tmp377 := tmp376.Get() + tmp378 := lang.Apply(tmp377, []any{v85}) + tmp379 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp380 := tmp379.FindInternedVar(lang.NewSymbol("list")) + if tmp380.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp380))) } - v381 := v380.Get() - v382 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v383 := v382.FindInternedVar(lang.NewSymbol("seq")) - if v383.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v383))) + tmp381 := tmp380.Get() + tmp382 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp383 := tmp382.FindInternedVar(lang.NewSymbol("seq")) + if tmp383.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp383))) } - v384 := v383.Get() - v385 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v386 := v385.FindInternedVar(lang.NewSymbol("concat")) - if v386.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v386))) + tmp384 := tmp383.Get() + tmp385 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp386 := tmp385.FindInternedVar(lang.NewSymbol("concat")) + if tmp386.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp386))) } - v387 := v386.Get() - v388 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v389 := v388.FindInternedVar(lang.NewSymbol("list")) - if v389.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v389))) + tmp387 := tmp386.Get() + tmp388 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp389 := tmp388.FindInternedVar(lang.NewSymbol("list")) + if tmp389.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp389))) } - v390 := v389.Get() - v391 := lang.Apply(v390, []any{lang.NewSymbol(".nth")}) - v392 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v393 := v392.FindInternedVar(lang.NewSymbol("list")) - if v393.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v393))) + tmp390 := tmp389.Get() + tmp391 := lang.Apply(tmp390, []any{lang.NewSymbol(".nth")}) + tmp392 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp393 := tmp392.FindInternedVar(lang.NewSymbol("list")) + if tmp393.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp393))) } - v394 := v393.Get() - v395 := lang.Apply(v394, []any{v114}) - v396 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v397 := v396.FindInternedVar(lang.NewSymbol("list")) - if v397.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v397))) + tmp394 := tmp393.Get() + tmp395 := lang.Apply(tmp394, []any{v114}) + tmp396 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp397 := tmp396.FindInternedVar(lang.NewSymbol("list")) + if tmp397.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp397))) } - v398 := v397.Get() - v399 := lang.Apply(v398, []any{v124}) - v400 := lang.Apply(v387, []any{v391, v395, v399}) - v401 := lang.Apply(v384, []any{v400}) - v402 := lang.Apply(v381, []any{v401}) - v403 := lang.Apply(v374, []any{v378, v402}) - v404 := lang.Apply(v371, []any{v403}) - v405 := lang.Apply(v365, []any{v368, v404}) - v406 := lang.Apply(v362, []any{v405}) - v407 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v408 := v407.FindInternedVar(lang.NewSymbol("list")) - if v408.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v408))) + tmp398 := tmp397.Get() + tmp399 := lang.Apply(tmp398, []any{v124}) + tmp400 := lang.Apply(tmp387, []any{tmp391, tmp395, tmp399}) + tmp401 := lang.Apply(tmp384, []any{tmp400}) + tmp402 := lang.Apply(tmp381, []any{tmp401}) + tmp403 := lang.Apply(tmp374, []any{tmp378, tmp402}) + tmp404 := lang.Apply(tmp371, []any{tmp403}) + tmp405 := lang.Apply(tmp365, []any{tmp368, tmp404}) + tmp406 := lang.Apply(tmp362, []any{tmp405}) + tmp407 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp408 := tmp407.FindInternedVar(lang.NewSymbol("list")) + if tmp408.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp408))) } - v409 := v408.Get() - v410 := lang.Apply(v409, []any{v232}) - var v411 any + tmp409 := tmp408.Get() + tmp410 := lang.Apply(tmp409, []any{v232}) + var tmp411 any if lang.IsTruthy(v177) { - v412 := lang.NewVector(v224) - v413 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3256), lang.NewKeyword("column"), int(48), lang.NewKeyword("end-line"), int(3256), lang.NewKeyword("end-column"), int(62)) - v414, err := lang.WithMeta(v412, v413.(lang.IPersistentMap)) + tmp412 := lang.NewVector(v224) + tmp413 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3256), lang.NewKeyword("column"), int(48), lang.NewKeyword("end-line"), int(3256), lang.NewKeyword("end-column"), int(62)) + tmp414, err := lang.WithMeta(tmp412, tmp413.(lang.IPersistentMap)) if err != nil { panic(err) } - v411 = v414 + tmp411 = tmp414 } else { - v411 = nil } - v415 := lang.Apply(v355, []any{v359, v406, v410, v411}) - v416 := lang.Apply(v352, []any{v415}) - v417 := lang.Apply(v349, []any{v416}) - v418 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v419 := v418.FindInternedVar(lang.NewSymbol("list")) - if v419.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v419))) + tmp415 := lang.Apply(tmp355, []any{tmp359, tmp406, tmp410, tmp411}) + tmp416 := lang.Apply(tmp352, []any{tmp415}) + tmp417 := lang.Apply(tmp349, []any{tmp416}) + tmp418 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp419 := tmp418.FindInternedVar(lang.NewSymbol("list")) + if tmp419.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp419))) } - v420 := v419.Get() - v421 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v422 := v421.FindInternedVar(lang.NewSymbol("seq")) - if v422.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v422))) + tmp420 := tmp419.Get() + tmp421 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp422 := tmp421.FindInternedVar(lang.NewSymbol("seq")) + if tmp422.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp422))) } - v423 := v422.Get() - v424 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v425 := v424.FindInternedVar(lang.NewSymbol("concat")) - if v425.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v425))) + tmp423 := tmp422.Get() + tmp424 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp425 := tmp424.FindInternedVar(lang.NewSymbol("concat")) + if tmp425.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp425))) } - v426 := v425.Get() - v427 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v428 := v427.FindInternedVar(lang.NewSymbol("list")) - if v428.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v428))) + tmp426 := tmp425.Get() + tmp427 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp428 := tmp427.FindInternedVar(lang.NewSymbol("list")) + if tmp428.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp428))) } - v429 := v428.Get() - v430 := lang.Apply(v429, []any{lang.NewSymbol("glojure.core/when-let")}) - v431 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v432 := v431.FindInternedVar(lang.NewSymbol("list")) - if v432.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v432))) + tmp429 := tmp428.Get() + tmp430 := lang.Apply(tmp429, []any{lang.NewSymbol("glojure.core/when-let")}) + tmp431 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp432 := tmp431.FindInternedVar(lang.NewSymbol("list")) + if tmp432.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp432))) } - v433 := v432.Get() - v434 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v435 := v434.FindInternedVar(lang.NewSymbol("apply")) - if v435.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v435))) + tmp433 := tmp432.Get() + tmp434 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp435 := tmp434.FindInternedVar(lang.NewSymbol("apply")) + if tmp435.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp435))) } - v436 := v435.Get() - v437 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v438 := v437.FindInternedVar(lang.NewSymbol("vector")) - if v438.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v438))) + tmp436 := tmp435.Get() + tmp437 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp438 := tmp437.FindInternedVar(lang.NewSymbol("vector")) + if tmp438.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp438))) } - v439 := v438.Get() - v440 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v441 := v440.FindInternedVar(lang.NewSymbol("seq")) - if v441.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v441))) + tmp439 := tmp438.Get() + tmp440 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp441 := tmp440.FindInternedVar(lang.NewSymbol("seq")) + if tmp441.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp441))) } - v442 := v441.Get() - v443 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v444 := v443.FindInternedVar(lang.NewSymbol("concat")) - if v444.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v444))) + tmp442 := tmp441.Get() + tmp443 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp444 := tmp443.FindInternedVar(lang.NewSymbol("concat")) + if tmp444.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp444))) } - v445 := v444.Get() - v446 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v447 := v446.FindInternedVar(lang.NewSymbol("list")) - if v447.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v447))) + tmp445 := tmp444.Get() + tmp446 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp447 := tmp446.FindInternedVar(lang.NewSymbol("list")) + if tmp447.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp447))) } - v448 := v447.Get() - v449 := lang.Apply(v448, []any{v102}) - v450 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v451 := v450.FindInternedVar(lang.NewSymbol("list")) - if v451.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v451))) + tmp448 := tmp447.Get() + tmp449 := lang.Apply(tmp448, []any{v102}) + tmp450 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp451 := tmp450.FindInternedVar(lang.NewSymbol("list")) + if tmp451.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp451))) } - v452 := v451.Get() - v453 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v454 := v453.FindInternedVar(lang.NewSymbol("seq")) - if v454.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v454))) + tmp452 := tmp451.Get() + tmp453 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp454 := tmp453.FindInternedVar(lang.NewSymbol("seq")) + if tmp454.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp454))) } - v455 := v454.Get() - v456 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v457 := v456.FindInternedVar(lang.NewSymbol("concat")) - if v457.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v457))) + tmp455 := tmp454.Get() + tmp456 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp457 := tmp456.FindInternedVar(lang.NewSymbol("concat")) + if tmp457.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp457))) } - v458 := v457.Get() - v459 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v460 := v459.FindInternedVar(lang.NewSymbol("list")) - if v460.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v460))) + tmp458 := tmp457.Get() + tmp459 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp460 := tmp459.FindInternedVar(lang.NewSymbol("list")) + if tmp460.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp460))) } - v461 := v460.Get() - v462 := lang.Apply(v461, []any{lang.NewSymbol("glojure.core/seq")}) - v463 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v464 := v463.FindInternedVar(lang.NewSymbol("list")) - if v464.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v464))) + tmp461 := tmp460.Get() + tmp462 := lang.Apply(tmp461, []any{lang.NewSymbol("glojure.core/seq")}) + tmp463 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp464 := tmp463.FindInternedVar(lang.NewSymbol("list")) + if tmp464.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp464))) } - v465 := v464.Get() - v466 := lang.Apply(v465, []any{v102}) - v467 := lang.Apply(v458, []any{v462, v466}) - v468 := lang.Apply(v455, []any{v467}) - v469 := lang.Apply(v452, []any{v468}) - v470 := lang.Apply(v445, []any{v449, v469}) - v471 := lang.Apply(v442, []any{v470}) - v472 := lang.Apply(v436, []any{v439, v471}) - v473 := lang.Apply(v433, []any{v472}) - v474 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v475 := v474.FindInternedVar(lang.NewSymbol("list")) - if v475.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v475))) + tmp465 := tmp464.Get() + tmp466 := lang.Apply(tmp465, []any{v102}) + tmp467 := lang.Apply(tmp458, []any{tmp462, tmp466}) + tmp468 := lang.Apply(tmp455, []any{tmp467}) + tmp469 := lang.Apply(tmp452, []any{tmp468}) + tmp470 := lang.Apply(tmp445, []any{tmp449, tmp469}) + tmp471 := lang.Apply(tmp442, []any{tmp470}) + tmp472 := lang.Apply(tmp436, []any{tmp439, tmp471}) + tmp473 := lang.Apply(tmp433, []any{tmp472}) + tmp474 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp475 := tmp474.FindInternedVar(lang.NewSymbol("list")) + if tmp475.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp475))) } - v476 := v475.Get() - v477 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v478 := v477.FindInternedVar(lang.NewSymbol("seq")) - if v478.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v478))) + tmp476 := tmp475.Get() + tmp477 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp478 := tmp477.FindInternedVar(lang.NewSymbol("seq")) + if tmp478.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp478))) } - v479 := v478.Get() - v480 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v481 := v480.FindInternedVar(lang.NewSymbol("concat")) - if v481.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v481))) + tmp479 := tmp478.Get() + tmp480 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp481 := tmp480.FindInternedVar(lang.NewSymbol("concat")) + if tmp481.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp481))) } - v482 := v481.Get() - v483 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v484 := v483.FindInternedVar(lang.NewSymbol("list")) - if v484.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v484))) + tmp482 := tmp481.Get() + tmp483 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp484 := tmp483.FindInternedVar(lang.NewSymbol("list")) + if tmp484.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp484))) } - v485 := v484.Get() - v486 := lang.Apply(v485, []any{lang.NewSymbol("if")}) - v487 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v488 := v487.FindInternedVar(lang.NewSymbol("list")) - if v488.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v488))) + tmp485 := tmp484.Get() + tmp486 := lang.Apply(tmp485, []any{lang.NewSymbol("if")}) + tmp487 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp488 := tmp487.FindInternedVar(lang.NewSymbol("list")) + if tmp488.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp488))) } - v489 := v488.Get() - v490 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v491 := v490.FindInternedVar(lang.NewSymbol("seq")) - if v491.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v491))) + tmp489 := tmp488.Get() + tmp490 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp491 := tmp490.FindInternedVar(lang.NewSymbol("seq")) + if tmp491.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp491))) } - v492 := v491.Get() - v493 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v494 := v493.FindInternedVar(lang.NewSymbol("concat")) - if v494.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v494))) + tmp492 := tmp491.Get() + tmp493 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp494 := tmp493.FindInternedVar(lang.NewSymbol("concat")) + if tmp494.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp494))) } - v495 := v494.Get() - v496 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v497 := v496.FindInternedVar(lang.NewSymbol("list")) - if v497.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v497))) + tmp495 := tmp494.Get() + tmp496 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp497 := tmp496.FindInternedVar(lang.NewSymbol("list")) + if tmp497.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp497))) } - v498 := v497.Get() - v499 := lang.Apply(v498, []any{lang.NewSymbol("glojure.core/chunked-seq?")}) - v500 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v501 := v500.FindInternedVar(lang.NewSymbol("list")) - if v501.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v501))) + tmp498 := tmp497.Get() + tmp499 := lang.Apply(tmp498, []any{lang.NewSymbol("glojure.core/chunked-seq?")}) + tmp500 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp501 := tmp500.FindInternedVar(lang.NewSymbol("list")) + if tmp501.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp501))) } - v502 := v501.Get() - v503 := lang.Apply(v502, []any{v102}) - v504 := lang.Apply(v495, []any{v499, v503}) - v505 := lang.Apply(v492, []any{v504}) - v506 := lang.Apply(v489, []any{v505}) - v507 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v508 := v507.FindInternedVar(lang.NewSymbol("list")) - if v508.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v508))) + tmp502 := tmp501.Get() + tmp503 := lang.Apply(tmp502, []any{v102}) + tmp504 := lang.Apply(tmp495, []any{tmp499, tmp503}) + tmp505 := lang.Apply(tmp492, []any{tmp504}) + tmp506 := lang.Apply(tmp489, []any{tmp505}) + tmp507 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp508 := tmp507.FindInternedVar(lang.NewSymbol("list")) + if tmp508.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp508))) } - v509 := v508.Get() - v510 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v511 := v510.FindInternedVar(lang.NewSymbol("seq")) - if v511.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v511))) + tmp509 := tmp508.Get() + tmp510 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp511 := tmp510.FindInternedVar(lang.NewSymbol("seq")) + if tmp511.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp511))) } - v512 := v511.Get() - v513 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v514 := v513.FindInternedVar(lang.NewSymbol("concat")) - if v514.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v514))) + tmp512 := tmp511.Get() + tmp513 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp514 := tmp513.FindInternedVar(lang.NewSymbol("concat")) + if tmp514.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp514))) } - v515 := v514.Get() - v516 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v517 := v516.FindInternedVar(lang.NewSymbol("list")) - if v517.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v517))) + tmp515 := tmp514.Get() + tmp516 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp517 := tmp516.FindInternedVar(lang.NewSymbol("list")) + if tmp517.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp517))) } - v518 := v517.Get() - v519 := lang.Apply(v518, []any{lang.NewSymbol("glojure.core/let")}) - v520 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v521 := v520.FindInternedVar(lang.NewSymbol("list")) - if v521.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v521))) + tmp518 := tmp517.Get() + tmp519 := lang.Apply(tmp518, []any{lang.NewSymbol("glojure.core/let")}) + tmp520 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp521 := tmp520.FindInternedVar(lang.NewSymbol("list")) + if tmp521.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp521))) } - v522 := v521.Get() - v523 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v524 := v523.FindInternedVar(lang.NewSymbol("apply")) - if v524.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v524))) + tmp522 := tmp521.Get() + tmp523 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp524 := tmp523.FindInternedVar(lang.NewSymbol("apply")) + if tmp524.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp524))) } - v525 := v524.Get() - v526 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v527 := v526.FindInternedVar(lang.NewSymbol("vector")) - if v527.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v527))) + tmp525 := tmp524.Get() + tmp526 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp527 := tmp526.FindInternedVar(lang.NewSymbol("vector")) + if tmp527.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp527))) } - v528 := v527.Get() - v529 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v530 := v529.FindInternedVar(lang.NewSymbol("seq")) - if v530.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v530))) + tmp528 := tmp527.Get() + tmp529 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp530 := tmp529.FindInternedVar(lang.NewSymbol("seq")) + if tmp530.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp530))) } - v531 := v530.Get() - v532 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v533 := v532.FindInternedVar(lang.NewSymbol("concat")) - if v533.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v533))) + tmp531 := tmp530.Get() + tmp532 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp533 := tmp532.FindInternedVar(lang.NewSymbol("concat")) + if tmp533.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp533))) } - v534 := v533.Get() - v535 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v536 := v535.FindInternedVar(lang.NewSymbol("list")) - if v536.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v536))) + tmp534 := tmp533.Get() + tmp535 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp536 := tmp535.FindInternedVar(lang.NewSymbol("list")) + if tmp536.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp536))) } - v537 := v536.Get() - v538 := lang.Apply(v537, []any{lang.NewSymbol("c__0__auto__")}) - v539 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v540 := v539.FindInternedVar(lang.NewSymbol("list")) - if v540.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v540))) + tmp537 := tmp536.Get() + tmp538 := lang.Apply(tmp537, []any{lang.NewSymbol("c__0__auto__")}) + tmp539 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp540 := tmp539.FindInternedVar(lang.NewSymbol("list")) + if tmp540.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp540))) } - v541 := v540.Get() - v542 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v543 := v542.FindInternedVar(lang.NewSymbol("seq")) - if v543.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v543))) + tmp541 := tmp540.Get() + tmp542 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp543 := tmp542.FindInternedVar(lang.NewSymbol("seq")) + if tmp543.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp543))) } - v544 := v543.Get() - v545 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v546 := v545.FindInternedVar(lang.NewSymbol("concat")) - if v546.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v546))) + tmp544 := tmp543.Get() + tmp545 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp546 := tmp545.FindInternedVar(lang.NewSymbol("concat")) + if tmp546.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp546))) } - v547 := v546.Get() - v548 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v549 := v548.FindInternedVar(lang.NewSymbol("list")) - if v549.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v549))) + tmp547 := tmp546.Get() + tmp548 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp549 := tmp548.FindInternedVar(lang.NewSymbol("list")) + if tmp549.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp549))) } - v550 := v549.Get() - v551 := lang.Apply(v550, []any{lang.NewSymbol("glojure.core/chunk-first")}) - v552 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v553 := v552.FindInternedVar(lang.NewSymbol("list")) - if v553.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v553))) + tmp550 := tmp549.Get() + tmp551 := lang.Apply(tmp550, []any{lang.NewSymbol("glojure.core/chunk-first")}) + tmp552 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp553 := tmp552.FindInternedVar(lang.NewSymbol("list")) + if tmp553.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp553))) } - v554 := v553.Get() - v555 := lang.Apply(v554, []any{v102}) - v556 := lang.Apply(v547, []any{v551, v555}) - v557 := lang.Apply(v544, []any{v556}) - v558 := lang.Apply(v541, []any{v557}) - v559 := lang.Apply(v534, []any{v538, v558}) - v560 := lang.Apply(v531, []any{v559}) - v561 := lang.Apply(v525, []any{v528, v560}) - v562 := lang.Apply(v522, []any{v561}) - v563 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v564 := v563.FindInternedVar(lang.NewSymbol("list")) - if v564.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v564))) + tmp554 := tmp553.Get() + tmp555 := lang.Apply(tmp554, []any{v102}) + tmp556 := lang.Apply(tmp547, []any{tmp551, tmp555}) + tmp557 := lang.Apply(tmp544, []any{tmp556}) + tmp558 := lang.Apply(tmp541, []any{tmp557}) + tmp559 := lang.Apply(tmp534, []any{tmp538, tmp558}) + tmp560 := lang.Apply(tmp531, []any{tmp559}) + tmp561 := lang.Apply(tmp525, []any{tmp528, tmp560}) + tmp562 := lang.Apply(tmp522, []any{tmp561}) + tmp563 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp564 := tmp563.FindInternedVar(lang.NewSymbol("list")) + if tmp564.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp564))) } - v565 := v564.Get() - v566 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v567 := v566.FindInternedVar(lang.NewSymbol("seq")) - if v567.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v567))) + tmp565 := tmp564.Get() + tmp566 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp567 := tmp566.FindInternedVar(lang.NewSymbol("seq")) + if tmp567.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp567))) } - v568 := v567.Get() - v569 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v570 := v569.FindInternedVar(lang.NewSymbol("concat")) - if v570.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v570))) + tmp568 := tmp567.Get() + tmp569 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp570 := tmp569.FindInternedVar(lang.NewSymbol("concat")) + if tmp570.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp570))) } - v571 := v570.Get() - v572 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v573 := v572.FindInternedVar(lang.NewSymbol("list")) - if v573.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v573))) + tmp571 := tmp570.Get() + tmp572 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp573 := tmp572.FindInternedVar(lang.NewSymbol("list")) + if tmp573.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp573))) } - v574 := v573.Get() - v575 := lang.Apply(v574, []any{lang.NewSymbol("recur")}) - v576 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v577 := v576.FindInternedVar(lang.NewSymbol("list")) - if v577.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v577))) + tmp574 := tmp573.Get() + tmp575 := lang.Apply(tmp574, []any{lang.NewSymbol("recur")}) + tmp576 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp577 := tmp576.FindInternedVar(lang.NewSymbol("list")) + if tmp577.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp577))) } - v578 := v577.Get() - v579 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v580 := v579.FindInternedVar(lang.NewSymbol("seq")) - if v580.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v580))) + tmp578 := tmp577.Get() + tmp579 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp580 := tmp579.FindInternedVar(lang.NewSymbol("seq")) + if tmp580.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp580))) } - v581 := v580.Get() - v582 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v583 := v582.FindInternedVar(lang.NewSymbol("concat")) - if v583.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v583))) + tmp581 := tmp580.Get() + tmp582 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp583 := tmp582.FindInternedVar(lang.NewSymbol("concat")) + if tmp583.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp583))) } - v584 := v583.Get() - v585 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v586 := v585.FindInternedVar(lang.NewSymbol("list")) - if v586.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v586))) + tmp584 := tmp583.Get() + tmp585 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp586 := tmp585.FindInternedVar(lang.NewSymbol("list")) + if tmp586.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp586))) } - v587 := v586.Get() - v588 := lang.Apply(v587, []any{lang.NewSymbol("glojure.core/chunk-rest")}) - v589 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v590 := v589.FindInternedVar(lang.NewSymbol("list")) - if v590.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v590))) + tmp587 := tmp586.Get() + tmp588 := lang.Apply(tmp587, []any{lang.NewSymbol("glojure.core/chunk-rest")}) + tmp589 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp590 := tmp589.FindInternedVar(lang.NewSymbol("list")) + if tmp590.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp590))) } - v591 := v590.Get() - v592 := lang.Apply(v591, []any{v102}) - v593 := lang.Apply(v584, []any{v588, v592}) - v594 := lang.Apply(v581, []any{v593}) - v595 := lang.Apply(v578, []any{v594}) - v596 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v597 := v596.FindInternedVar(lang.NewSymbol("list")) - if v597.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v597))) + tmp591 := tmp590.Get() + tmp592 := lang.Apply(tmp591, []any{v102}) + tmp593 := lang.Apply(tmp584, []any{tmp588, tmp592}) + tmp594 := lang.Apply(tmp581, []any{tmp593}) + tmp595 := lang.Apply(tmp578, []any{tmp594}) + tmp596 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp597 := tmp596.FindInternedVar(lang.NewSymbol("list")) + if tmp597.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp597))) } - v598 := v597.Get() - v599 := lang.Apply(v598, []any{lang.NewSymbol("c__0__auto__")}) - v600 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v601 := v600.FindInternedVar(lang.NewSymbol("list")) - if v601.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v601))) + tmp598 := tmp597.Get() + tmp599 := lang.Apply(tmp598, []any{lang.NewSymbol("c__0__auto__")}) + tmp600 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp601 := tmp600.FindInternedVar(lang.NewSymbol("list")) + if tmp601.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp601))) } - v602 := v601.Get() - v603 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v604 := v603.FindInternedVar(lang.NewSymbol("seq")) - if v604.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v604))) + tmp602 := tmp601.Get() + tmp603 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp604 := tmp603.FindInternedVar(lang.NewSymbol("seq")) + if tmp604.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp604))) } - v605 := v604.Get() - v606 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v607 := v606.FindInternedVar(lang.NewSymbol("concat")) - if v607.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v607))) + tmp605 := tmp604.Get() + tmp606 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp607 := tmp606.FindInternedVar(lang.NewSymbol("concat")) + if tmp607.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp607))) } - v608 := v607.Get() - v609 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v610 := v609.FindInternedVar(lang.NewSymbol("list")) - if v610.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v610))) + tmp608 := tmp607.Get() + tmp609 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp610 := tmp609.FindInternedVar(lang.NewSymbol("list")) + if tmp610.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp610))) } - v611 := v610.Get() - v612 := lang.Apply(v611, []any{lang.NewSymbol("glojure.core/int")}) - v613 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v614 := v613.FindInternedVar(lang.NewSymbol("list")) - if v614.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v614))) + tmp611 := tmp610.Get() + tmp612 := lang.Apply(tmp611, []any{lang.NewSymbol("glojure.core/int")}) + tmp613 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp614 := tmp613.FindInternedVar(lang.NewSymbol("list")) + if tmp614.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp614))) } - v615 := v614.Get() - v616 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v617 := v616.FindInternedVar(lang.NewSymbol("seq")) - if v617.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v617))) + tmp615 := tmp614.Get() + tmp616 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp617 := tmp616.FindInternedVar(lang.NewSymbol("seq")) + if tmp617.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp617))) } - v618 := v617.Get() - v619 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v620 := v619.FindInternedVar(lang.NewSymbol("concat")) - if v620.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v620))) + tmp618 := tmp617.Get() + tmp619 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp620 := tmp619.FindInternedVar(lang.NewSymbol("concat")) + if tmp620.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp620))) } - v621 := v620.Get() - v622 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v623 := v622.FindInternedVar(lang.NewSymbol("list")) - if v623.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v623))) + tmp621 := tmp620.Get() + tmp622 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp623 := tmp622.FindInternedVar(lang.NewSymbol("list")) + if tmp623.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp623))) } - v624 := v623.Get() - v625 := lang.Apply(v624, []any{lang.NewSymbol("glojure.core/count")}) - v626 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v627 := v626.FindInternedVar(lang.NewSymbol("list")) - if v627.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v627))) + tmp624 := tmp623.Get() + tmp625 := lang.Apply(tmp624, []any{lang.NewSymbol("glojure.core/count")}) + tmp626 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp627 := tmp626.FindInternedVar(lang.NewSymbol("list")) + if tmp627.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp627))) } - v628 := v627.Get() - v629 := lang.Apply(v628, []any{lang.NewSymbol("c__0__auto__")}) - v630 := lang.Apply(v621, []any{v625, v629}) - v631 := lang.Apply(v618, []any{v630}) - v632 := lang.Apply(v615, []any{v631}) - v633 := lang.Apply(v608, []any{v612, v632}) - v634 := lang.Apply(v605, []any{v633}) - v635 := lang.Apply(v602, []any{v634}) - v636 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v637 := v636.FindInternedVar(lang.NewSymbol("list")) - if v637.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v637))) + tmp628 := tmp627.Get() + tmp629 := lang.Apply(tmp628, []any{lang.NewSymbol("c__0__auto__")}) + tmp630 := lang.Apply(tmp621, []any{tmp625, tmp629}) + tmp631 := lang.Apply(tmp618, []any{tmp630}) + tmp632 := lang.Apply(tmp615, []any{tmp631}) + tmp633 := lang.Apply(tmp608, []any{tmp612, tmp632}) + tmp634 := lang.Apply(tmp605, []any{tmp633}) + tmp635 := lang.Apply(tmp602, []any{tmp634}) + tmp636 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp637 := tmp636.FindInternedVar(lang.NewSymbol("list")) + if tmp637.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp637))) } - v638 := v637.Get() - v639 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v640 := v639.FindInternedVar(lang.NewSymbol("seq")) - if v640.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v640))) + tmp638 := tmp637.Get() + tmp639 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp640 := tmp639.FindInternedVar(lang.NewSymbol("seq")) + if tmp640.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp640))) } - v641 := v640.Get() - v642 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v643 := v642.FindInternedVar(lang.NewSymbol("concat")) - if v643.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v643))) + tmp641 := tmp640.Get() + tmp642 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp643 := tmp642.FindInternedVar(lang.NewSymbol("concat")) + if tmp643.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp643))) } - v644 := v643.Get() - v645 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v646 := v645.FindInternedVar(lang.NewSymbol("list")) - if v646.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v646))) + tmp644 := tmp643.Get() + tmp645 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp646 := tmp645.FindInternedVar(lang.NewSymbol("list")) + if tmp646.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp646))) } - v647 := v646.Get() - v648 := lang.Apply(v647, []any{lang.NewSymbol("glojure.core/int")}) - v649 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v650 := v649.FindInternedVar(lang.NewSymbol("list")) - if v650.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v650))) + tmp647 := tmp646.Get() + tmp648 := lang.Apply(tmp647, []any{lang.NewSymbol("glojure.core/int")}) + tmp649 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp650 := tmp649.FindInternedVar(lang.NewSymbol("list")) + if tmp650.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp650))) } - v651 := v650.Get() - v652 := lang.Apply(v651, []any{int64(0)}) - v653 := lang.Apply(v644, []any{v648, v652}) - v654 := lang.Apply(v641, []any{v653}) - v655 := lang.Apply(v638, []any{v654}) - v656 := lang.Apply(v571, []any{v575, v595, v599, v635, v655}) - v657 := lang.Apply(v568, []any{v656}) - v658 := lang.Apply(v565, []any{v657}) - v659 := lang.Apply(v515, []any{v519, v562, v658}) - v660 := lang.Apply(v512, []any{v659}) - v661 := lang.Apply(v509, []any{v660}) - v662 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v663 := v662.FindInternedVar(lang.NewSymbol("list")) - if v663.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v663))) + tmp651 := tmp650.Get() + tmp652 := lang.Apply(tmp651, []any{int64(0)}) + tmp653 := lang.Apply(tmp644, []any{tmp648, tmp652}) + tmp654 := lang.Apply(tmp641, []any{tmp653}) + tmp655 := lang.Apply(tmp638, []any{tmp654}) + tmp656 := lang.Apply(tmp571, []any{tmp575, tmp595, tmp599, tmp635, tmp655}) + tmp657 := lang.Apply(tmp568, []any{tmp656}) + tmp658 := lang.Apply(tmp565, []any{tmp657}) + tmp659 := lang.Apply(tmp515, []any{tmp519, tmp562, tmp658}) + tmp660 := lang.Apply(tmp512, []any{tmp659}) + tmp661 := lang.Apply(tmp509, []any{tmp660}) + tmp662 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp663 := tmp662.FindInternedVar(lang.NewSymbol("list")) + if tmp663.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp663))) } - v664 := v663.Get() - v665 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v666 := v665.FindInternedVar(lang.NewSymbol("seq")) - if v666.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v666))) + tmp664 := tmp663.Get() + tmp665 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp666 := tmp665.FindInternedVar(lang.NewSymbol("seq")) + if tmp666.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp666))) } - v667 := v666.Get() - v668 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v669 := v668.FindInternedVar(lang.NewSymbol("concat")) - if v669.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v669))) + tmp667 := tmp666.Get() + tmp668 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp669 := tmp668.FindInternedVar(lang.NewSymbol("concat")) + if tmp669.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp669))) } - v670 := v669.Get() - v671 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v672 := v671.FindInternedVar(lang.NewSymbol("list")) - if v672.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v672))) + tmp670 := tmp669.Get() + tmp671 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp672 := tmp671.FindInternedVar(lang.NewSymbol("list")) + if tmp672.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp672))) } - v673 := v672.Get() - v674 := lang.Apply(v673, []any{lang.NewSymbol("glojure.core/let")}) - v675 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v676 := v675.FindInternedVar(lang.NewSymbol("list")) - if v676.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v676))) + tmp673 := tmp672.Get() + tmp674 := lang.Apply(tmp673, []any{lang.NewSymbol("glojure.core/let")}) + tmp675 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp676 := tmp675.FindInternedVar(lang.NewSymbol("list")) + if tmp676.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp676))) } - v677 := v676.Get() - v678 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v679 := v678.FindInternedVar(lang.NewSymbol("apply")) - if v679.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v679))) + tmp677 := tmp676.Get() + tmp678 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp679 := tmp678.FindInternedVar(lang.NewSymbol("apply")) + if tmp679.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp679))) } - v680 := v679.Get() - v681 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v682 := v681.FindInternedVar(lang.NewSymbol("vector")) - if v682.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v682))) + tmp680 := tmp679.Get() + tmp681 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp682 := tmp681.FindInternedVar(lang.NewSymbol("vector")) + if tmp682.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp682))) } - v683 := v682.Get() - v684 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v685 := v684.FindInternedVar(lang.NewSymbol("seq")) - if v685.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v685))) + tmp683 := tmp682.Get() + tmp684 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp685 := tmp684.FindInternedVar(lang.NewSymbol("seq")) + if tmp685.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp685))) } - v686 := v685.Get() - v687 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v688 := v687.FindInternedVar(lang.NewSymbol("concat")) - if v688.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v688))) + tmp686 := tmp685.Get() + tmp687 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp688 := tmp687.FindInternedVar(lang.NewSymbol("concat")) + if tmp688.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp688))) } - v689 := v688.Get() - v690 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v691 := v690.FindInternedVar(lang.NewSymbol("list")) - if v691.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v691))) + tmp689 := tmp688.Get() + tmp690 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp691 := tmp690.FindInternedVar(lang.NewSymbol("list")) + if tmp691.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp691))) } - v692 := v691.Get() - v693 := lang.Apply(v692, []any{v85}) - v694 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v695 := v694.FindInternedVar(lang.NewSymbol("list")) - if v695.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v695))) + tmp692 := tmp691.Get() + tmp693 := lang.Apply(tmp692, []any{v85}) + tmp694 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp695 := tmp694.FindInternedVar(lang.NewSymbol("list")) + if tmp695.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp695))) } - v696 := v695.Get() - v697 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v698 := v697.FindInternedVar(lang.NewSymbol("seq")) - if v698.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v698))) + tmp696 := tmp695.Get() + tmp697 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp698 := tmp697.FindInternedVar(lang.NewSymbol("seq")) + if tmp698.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp698))) } - v699 := v698.Get() - v700 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v701 := v700.FindInternedVar(lang.NewSymbol("concat")) - if v701.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v701))) + tmp699 := tmp698.Get() + tmp700 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp701 := tmp700.FindInternedVar(lang.NewSymbol("concat")) + if tmp701.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp701))) } - v702 := v701.Get() - v703 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v704 := v703.FindInternedVar(lang.NewSymbol("list")) - if v704.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v704))) + tmp702 := tmp701.Get() + tmp703 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp704 := tmp703.FindInternedVar(lang.NewSymbol("list")) + if tmp704.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp704))) } - v705 := v704.Get() - v706 := lang.Apply(v705, []any{lang.NewSymbol("glojure.core/first")}) - v707 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v708 := v707.FindInternedVar(lang.NewSymbol("list")) - if v708.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v708))) + tmp705 := tmp704.Get() + tmp706 := lang.Apply(tmp705, []any{lang.NewSymbol("glojure.core/first")}) + tmp707 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp708 := tmp707.FindInternedVar(lang.NewSymbol("list")) + if tmp708.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp708))) } - v709 := v708.Get() - v710 := lang.Apply(v709, []any{v102}) - v711 := lang.Apply(v702, []any{v706, v710}) - v712 := lang.Apply(v699, []any{v711}) - v713 := lang.Apply(v696, []any{v712}) - v714 := lang.Apply(v689, []any{v693, v713}) - v715 := lang.Apply(v686, []any{v714}) - v716 := lang.Apply(v680, []any{v683, v715}) - v717 := lang.Apply(v677, []any{v716}) - v718 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v719 := v718.FindInternedVar(lang.NewSymbol("list")) - if v719.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v719))) + tmp709 := tmp708.Get() + tmp710 := lang.Apply(tmp709, []any{v102}) + tmp711 := lang.Apply(tmp702, []any{tmp706, tmp710}) + tmp712 := lang.Apply(tmp699, []any{tmp711}) + tmp713 := lang.Apply(tmp696, []any{tmp712}) + tmp714 := lang.Apply(tmp689, []any{tmp693, tmp713}) + tmp715 := lang.Apply(tmp686, []any{tmp714}) + tmp716 := lang.Apply(tmp680, []any{tmp683, tmp715}) + tmp717 := lang.Apply(tmp677, []any{tmp716}) + tmp718 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp719 := tmp718.FindInternedVar(lang.NewSymbol("list")) + if tmp719.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp719))) } - v720 := v719.Get() - v721 := lang.Apply(v720, []any{v179}) - var v722 any + tmp720 := tmp719.Get() + tmp721 := lang.Apply(tmp720, []any{v179}) + var tmp722 any if lang.IsTruthy(v177) { - v723 := lang.NewVector(v169) - v724 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3264), lang.NewKeyword("column"), int(52), lang.NewKeyword("end-line"), int(3264), lang.NewKeyword("end-column"), int(60)) - v725, err := lang.WithMeta(v723, v724.(lang.IPersistentMap)) + tmp723 := lang.NewVector(v169) + tmp724 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3264), lang.NewKeyword("column"), int(52), lang.NewKeyword("end-line"), int(3264), lang.NewKeyword("end-column"), int(60)) + tmp725, err := lang.WithMeta(tmp723, tmp724.(lang.IPersistentMap)) if err != nil { panic(err) } - v722 = v725 + tmp722 = tmp725 } else { - v722 = nil } - v726 := lang.Apply(v670, []any{v674, v717, v721, v722}) - v727 := lang.Apply(v667, []any{v726}) - v728 := lang.Apply(v664, []any{v727}) - v729 := lang.Apply(v482, []any{v486, v506, v661, v728}) - v730 := lang.Apply(v479, []any{v729}) - v731 := lang.Apply(v476, []any{v730}) - v732 := lang.Apply(v426, []any{v430, v473, v731}) - v733 := lang.Apply(v423, []any{v732}) - v734 := lang.Apply(v420, []any{v733}) - v735 := lang.Apply(v318, []any{v322, v346, v417, v734}) - v736 := lang.Apply(v315, []any{v735}) - v737 := lang.Apply(v312, []any{v736}) - v738 := lang.Apply(v238, []any{v242, v309, v737}) - v739 := lang.Apply(v235, []any{v738}) - v740 := lang.NewVector(true, v739) - v741 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3250), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(3264), lang.NewKeyword("end-column"), int(67)) - v742, err := lang.WithMeta(v740, v741.(lang.IPersistentMap)) + tmp726 := lang.Apply(tmp670, []any{tmp674, tmp717, tmp721, tmp722}) + tmp727 := lang.Apply(tmp667, []any{tmp726}) + tmp728 := lang.Apply(tmp664, []any{tmp727}) + tmp729 := lang.Apply(tmp482, []any{tmp486, tmp506, tmp661, tmp728}) + tmp730 := lang.Apply(tmp479, []any{tmp729}) + tmp731 := lang.Apply(tmp476, []any{tmp730}) + tmp732 := lang.Apply(tmp426, []any{tmp430, tmp473, tmp731}) + tmp733 := lang.Apply(tmp423, []any{tmp732}) + tmp734 := lang.Apply(tmp420, []any{tmp733}) + tmp735 := lang.Apply(tmp318, []any{tmp322, tmp346, tmp417, tmp734}) + tmp736 := lang.Apply(tmp315, []any{tmp735}) + tmp737 := lang.Apply(tmp312, []any{tmp736}) + tmp738 := lang.Apply(tmp238, []any{tmp242, tmp309, tmp737}) + tmp739 := lang.Apply(tmp235, []any{tmp738}) + tmp740 := lang.NewVector(true, tmp739) + tmp741 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3250), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(3264), lang.NewKeyword("end-column"), int(67)) + tmp742, err := lang.WithMeta(tmp740, tmp741.(lang.IPersistentMap)) if err != nil { panic(err) } - v97 = v742 + tmp97 = tmp742 } // end let - v91 = v97 + tmp91 = tmp97 } - v80 = v91 + tmp80 = tmp91 } // end let - v60 = v80 + tmp60 = tmp80 } - return v60 + return tmp60 }) - v57 := v56 + v57 = tmp56 _ = v57 } - v57 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3218), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(3264), lang.NewKeyword("end-column"), int(72)) - v58, err := lang.WithMeta(v56, v57.(lang.IPersistentMap)) + tmp57 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3218), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(3264), lang.NewKeyword("end-column"), int(72)) + tmp58, err := lang.WithMeta(tmp56, tmp57.(lang.IPersistentMap)) if err != nil { panic(err) } - var v59 any = v58 + var v59 any = tmp58 _ = v59 - v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v61 := v60.FindInternedVar(lang.NewSymbol("nth")) - if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) - } - v62 := v61.Get() - v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v64 := v63.FindInternedVar(lang.NewSymbol("seq")) - if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) - } - v65 := v64.Get() - v66 := lang.Apply(v65, []any{v5}) - v67 := lang.Apply(v59, []any{nil, v66}) - v68 := lang.Apply(v62, []any{v67, int64(1)}) - v55 = v68 + tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp61 := tmp60.FindInternedVar(lang.NewSymbol("nth")) + if tmp61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) + } + tmp62 := tmp61.Get() + tmp63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp64 := tmp63.FindInternedVar(lang.NewSymbol("seq")) + if tmp64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp64))) + } + tmp65 := tmp64.Get() + tmp66 := lang.Apply(tmp65, []any{v5}) + tmp67 := lang.Apply(v59, []any{nil, tmp66}) + tmp68 := lang.Apply(tmp62, []any{tmp67, int64(1)}) + tmp55 = tmp68 } // end let - return v55 + return tmp55 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // dosync { - v0 := lang.NewSymbol("dosync").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("exprs"))), lang.NewKeyword("doc"), "Runs the exprs (in an implicit do) in a transaction that encompasses\n exprs and any nested calls. Starts a transaction if none is already\n running on this thread. Any uncaught exception will abort the\n transaction and flow out of dosync. The exprs may be run more than\n once, but any effects on Refs will be atomic.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5100), lang.NewKeyword("end-line"), int(5100))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("dosync").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("exprs"))), lang.NewKeyword("doc"), "Runs the exprs (in an implicit do) in a transaction that encompasses\n exprs and any nested calls. Starts a transaction if none is already\n running on this thread. Any uncaught exception will abort the\n transaction and flow out of dosync. The exprs may be run more than\n once, but any effects on Refs will be atomic.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5100), lang.NewKeyword("end-line"), int(5100))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 2 { @@ -29633,49 +29722,50 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.NewList(args[2:]...) - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("seq")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("concat")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("list")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.Apply(v14, []any{lang.NewSymbol("glojure.core/sync")}) - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("list")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{nil}) - v20 := lang.Apply(v11, []any{v15, v19, v5}) - v21 := lang.Apply(v8, []any{v20}) - return v21 - } - }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("seq")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("concat")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("list")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("glojure.core/sync")}) + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("list")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{nil}) + tmp20 := lang.Apply(tmp11, []any{tmp15, tmp19, v5}) + tmp21 := lang.Apply(tmp8, []any{tmp20}) + return tmp21 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // dotimes { - v0 := lang.NewSymbol("dotimes").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "bindings => name n\n\n Repeatedly executes body (presumably for side-effects) with name\n bound to integers from 0 through n-1.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3306), lang.NewKeyword("end-line"), int(3306))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("dotimes").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "bindings => name n\n\n Repeatedly executes body (presumably for side-effects) with name\n bound to integers from 0 through n-1.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3306), lang.NewKeyword("end-line"), int(3306))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 3 { @@ -29687,445 +29777,443 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - var v7 any - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v5}) - if lang.IsTruthy(v11) { - v7 = nil + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("vector?")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v5}) + if lang.IsTruthy(tmp11) { } else { - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("str")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("first")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{v3}) - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("meta")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v3}) - v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) - v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) - v28 := lang.Apply(lang.NewIllegalArgumentError, []any{v27}) - panic(v28) - } - _ = v7 - var v29 any - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("=")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) - } - v32 := v31.Get() - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("count")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - v36 := lang.Apply(v35, []any{v5}) - v37 := lang.Apply(v32, []any{int64(2), v36}) - if lang.IsTruthy(v37) { - v29 = nil + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("str")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("first")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("*ns*")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("meta")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.Apply(tmp24, []any{v3}) + tmp26 := lang.Apply(lang.NewKeyword("line"), []any{tmp25}) + tmp27 := lang.Apply(tmp14, []any{tmp18, " requires ", "a vector for its binding", " in ", tmp21, ":", tmp26}) + tmp28 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp27}) + panic(tmp28) + } + _ = tmp7 + var tmp29 any + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("=")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) + } + tmp32 := tmp31.Get() + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("count")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) + } + tmp35 := tmp34.Get() + tmp36 := lang.Apply(tmp35, []any{v5}) + tmp37 := lang.Apply(tmp32, []any{int64(2), tmp36}) + if lang.IsTruthy(tmp37) { } else { - v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v39 := v38.FindInternedVar(lang.NewSymbol("str")) - if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) - } - v40 := v39.Get() - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("first")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) - } - v43 := v42.Get() - v44 := lang.Apply(v43, []any{v3}) - v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) - if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) - } - v47 := v46.Get() - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("meta")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v3}) - v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) - v53 := lang.Apply(v40, []any{v44, " requires ", "exactly 2 forms in binding vector", " in ", v47, ":", v52}) - v54 := lang.Apply(lang.NewIllegalArgumentError, []any{v53}) - panic(v54) - } - _ = v29 - _ = nil - var v55 any + tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp39 := tmp38.FindInternedVar(lang.NewSymbol("str")) + if tmp39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) + } + tmp40 := tmp39.Get() + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("first")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := lang.Apply(tmp43, []any{v3}) + tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp46 := tmp45.FindInternedVar(lang.NewSymbol("*ns*")) + if tmp46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) + } + tmp47 := tmp46.Get() + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("meta")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v3}) + tmp52 := lang.Apply(lang.NewKeyword("line"), []any{tmp51}) + tmp53 := lang.Apply(tmp40, []any{tmp44, " requires ", "exactly 2 forms in binding vector", " in ", tmp47, ":", tmp52}) + tmp54 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp53}) + panic(tmp54) + } + _ = tmp29 + var tmp55 any { // let // let binding "i" - v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v57 := v56.FindInternedVar(lang.NewSymbol("first")) - if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) - } - v58 := v57.Get() - v59 := lang.Apply(v58, []any{v5}) - var v60 any = v59 + tmp56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp57 := tmp56.FindInternedVar(lang.NewSymbol("first")) + if tmp57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp57))) + } + tmp58 := tmp57.Get() + tmp59 := lang.Apply(tmp58, []any{v5}) + var v60 any = tmp59 _ = v60 // let binding "n" - v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v62 := v61.FindInternedVar(lang.NewSymbol("second")) - if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) - } - v63 := v62.Get() - v64 := lang.Apply(v63, []any{v5}) - var v65 any = v64 + tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp62 := tmp61.FindInternedVar(lang.NewSymbol("second")) + if tmp62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) + } + tmp63 := tmp62.Get() + tmp64 := lang.Apply(tmp63, []any{v5}) + var v65 any = tmp64 _ = v65 - v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v67 := v66.FindInternedVar(lang.NewSymbol("seq")) - if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) - } - v68 := v67.Get() - v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v70 := v69.FindInternedVar(lang.NewSymbol("concat")) - if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) - } - v71 := v70.Get() - v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v73 := v72.FindInternedVar(lang.NewSymbol("list")) - if v73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) - } - v74 := v73.Get() - v75 := lang.Apply(v74, []any{lang.NewSymbol("glojure.core/let")}) - v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v77 := v76.FindInternedVar(lang.NewSymbol("list")) - if v77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) - } - v78 := v77.Get() - v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v80 := v79.FindInternedVar(lang.NewSymbol("apply")) - if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) - } - v81 := v80.Get() - v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v83 := v82.FindInternedVar(lang.NewSymbol("vector")) - if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) - } - v84 := v83.Get() - v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v86 := v85.FindInternedVar(lang.NewSymbol("seq")) - if v86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) - } - v87 := v86.Get() - v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v89 := v88.FindInternedVar(lang.NewSymbol("concat")) - if v89.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) - } - v90 := v89.Get() - v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v92 := v91.FindInternedVar(lang.NewSymbol("list")) - if v92.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) - } - v93 := v92.Get() - v94 := lang.Apply(v93, []any{lang.NewSymbol("n__0__auto__")}) - v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v96 := v95.FindInternedVar(lang.NewSymbol("list")) - if v96.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) - } - v97 := v96.Get() - v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v99 := v98.FindInternedVar(lang.NewSymbol("seq")) - if v99.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) - } - v100 := v99.Get() - v101 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v102 := v101.FindInternedVar(lang.NewSymbol("concat")) - if v102.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v102))) - } - v103 := v102.Get() - v104 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v105 := v104.FindInternedVar(lang.NewSymbol("list")) - if v105.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v105))) - } - v106 := v105.Get() - v107 := lang.Apply(v106, []any{lang.NewSymbol("glojure.core/long")}) - v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v109 := v108.FindInternedVar(lang.NewSymbol("list")) - if v109.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) - } - v110 := v109.Get() - v111 := lang.Apply(v110, []any{v65}) - v112 := lang.Apply(v103, []any{v107, v111}) - v113 := lang.Apply(v100, []any{v112}) - v114 := lang.Apply(v97, []any{v113}) - v115 := lang.Apply(v90, []any{v94, v114}) - v116 := lang.Apply(v87, []any{v115}) - v117 := lang.Apply(v81, []any{v84, v116}) - v118 := lang.Apply(v78, []any{v117}) - v119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v120 := v119.FindInternedVar(lang.NewSymbol("list")) - if v120.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v120))) - } - v121 := v120.Get() - v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v123 := v122.FindInternedVar(lang.NewSymbol("seq")) - if v123.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) - } - v124 := v123.Get() - v125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v126 := v125.FindInternedVar(lang.NewSymbol("concat")) - if v126.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v126))) - } - v127 := v126.Get() - v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v129 := v128.FindInternedVar(lang.NewSymbol("list")) - if v129.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v129))) - } - v130 := v129.Get() - v131 := lang.Apply(v130, []any{lang.NewSymbol("glojure.core/loop")}) - v132 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v133 := v132.FindInternedVar(lang.NewSymbol("list")) - if v133.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v133))) - } - v134 := v133.Get() - v135 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v136 := v135.FindInternedVar(lang.NewSymbol("apply")) - if v136.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v136))) - } - v137 := v136.Get() - v138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v139 := v138.FindInternedVar(lang.NewSymbol("vector")) - if v139.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v139))) - } - v140 := v139.Get() - v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v142 := v141.FindInternedVar(lang.NewSymbol("seq")) - if v142.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) - } - v143 := v142.Get() - v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v145 := v144.FindInternedVar(lang.NewSymbol("concat")) - if v145.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) - } - v146 := v145.Get() - v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v148 := v147.FindInternedVar(lang.NewSymbol("list")) - if v148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) - } - v149 := v148.Get() - v150 := lang.Apply(v149, []any{v60}) - v151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v152 := v151.FindInternedVar(lang.NewSymbol("list")) - if v152.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v152))) - } - v153 := v152.Get() - v154 := lang.Apply(v153, []any{int64(0)}) - v155 := lang.Apply(v146, []any{v150, v154}) - v156 := lang.Apply(v143, []any{v155}) - v157 := lang.Apply(v137, []any{v140, v156}) - v158 := lang.Apply(v134, []any{v157}) - v159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v160 := v159.FindInternedVar(lang.NewSymbol("list")) - if v160.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v160))) - } - v161 := v160.Get() - v162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v163 := v162.FindInternedVar(lang.NewSymbol("seq")) - if v163.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v163))) - } - v164 := v163.Get() - v165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v166 := v165.FindInternedVar(lang.NewSymbol("concat")) - if v166.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v166))) - } - v167 := v166.Get() - v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v169 := v168.FindInternedVar(lang.NewSymbol("list")) - if v169.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) - } - v170 := v169.Get() - v171 := lang.Apply(v170, []any{lang.NewSymbol("glojure.core/when")}) - v172 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v173 := v172.FindInternedVar(lang.NewSymbol("list")) - if v173.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v173))) - } - v174 := v173.Get() - v175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v176 := v175.FindInternedVar(lang.NewSymbol("seq")) - if v176.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v176))) - } - v177 := v176.Get() - v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v179 := v178.FindInternedVar(lang.NewSymbol("concat")) - if v179.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) - } - v180 := v179.Get() - v181 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v182 := v181.FindInternedVar(lang.NewSymbol("list")) - if v182.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v182))) - } - v183 := v182.Get() - v184 := lang.Apply(v183, []any{lang.NewSymbol("glojure.core/<")}) - v185 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v186 := v185.FindInternedVar(lang.NewSymbol("list")) - if v186.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v186))) - } - v187 := v186.Get() - v188 := lang.Apply(v187, []any{v60}) - v189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v190 := v189.FindInternedVar(lang.NewSymbol("list")) - if v190.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v190))) - } - v191 := v190.Get() - v192 := lang.Apply(v191, []any{lang.NewSymbol("n__0__auto__")}) - v193 := lang.Apply(v180, []any{v184, v188, v192}) - v194 := lang.Apply(v177, []any{v193}) - v195 := lang.Apply(v174, []any{v194}) - v196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v197 := v196.FindInternedVar(lang.NewSymbol("list")) - if v197.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v197))) - } - v198 := v197.Get() - v199 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v200 := v199.FindInternedVar(lang.NewSymbol("seq")) - if v200.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v200))) - } - v201 := v200.Get() - v202 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v203 := v202.FindInternedVar(lang.NewSymbol("concat")) - if v203.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v203))) - } - v204 := v203.Get() - v205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v206 := v205.FindInternedVar(lang.NewSymbol("list")) - if v206.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v206))) - } - v207 := v206.Get() - v208 := lang.Apply(v207, []any{lang.NewSymbol("recur")}) - v209 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v210 := v209.FindInternedVar(lang.NewSymbol("list")) - if v210.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v210))) - } - v211 := v210.Get() - v212 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v213 := v212.FindInternedVar(lang.NewSymbol("seq")) - if v213.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v213))) - } - v214 := v213.Get() - v215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v216 := v215.FindInternedVar(lang.NewSymbol("concat")) - if v216.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v216))) - } - v217 := v216.Get() - v218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v219 := v218.FindInternedVar(lang.NewSymbol("list")) - if v219.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v219))) - } - v220 := v219.Get() - v221 := lang.Apply(v220, []any{lang.NewSymbol("glojure.core/unchecked-inc")}) - v222 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v223 := v222.FindInternedVar(lang.NewSymbol("list")) - if v223.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v223))) - } - v224 := v223.Get() - v225 := lang.Apply(v224, []any{v60}) - v226 := lang.Apply(v217, []any{v221, v225}) - v227 := lang.Apply(v214, []any{v226}) - v228 := lang.Apply(v211, []any{v227}) - v229 := lang.Apply(v204, []any{v208, v228}) - v230 := lang.Apply(v201, []any{v229}) - v231 := lang.Apply(v198, []any{v230}) - v232 := lang.Apply(v167, []any{v171, v195, v6, v231}) - v233 := lang.Apply(v164, []any{v232}) - v234 := lang.Apply(v161, []any{v233}) - v235 := lang.Apply(v127, []any{v131, v158, v234}) - v236 := lang.Apply(v124, []any{v235}) - v237 := lang.Apply(v121, []any{v236}) - v238 := lang.Apply(v71, []any{v75, v118, v237}) - v239 := lang.Apply(v68, []any{v238}) - v55 = v239 + tmp66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp67 := tmp66.FindInternedVar(lang.NewSymbol("seq")) + if tmp67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp67))) + } + tmp68 := tmp67.Get() + tmp69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp70 := tmp69.FindInternedVar(lang.NewSymbol("concat")) + if tmp70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp70))) + } + tmp71 := tmp70.Get() + tmp72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp73 := tmp72.FindInternedVar(lang.NewSymbol("list")) + if tmp73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp73))) + } + tmp74 := tmp73.Get() + tmp75 := lang.Apply(tmp74, []any{lang.NewSymbol("glojure.core/let")}) + tmp76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp77 := tmp76.FindInternedVar(lang.NewSymbol("list")) + if tmp77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp77))) + } + tmp78 := tmp77.Get() + tmp79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp80 := tmp79.FindInternedVar(lang.NewSymbol("apply")) + if tmp80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp80))) + } + tmp81 := tmp80.Get() + tmp82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp83 := tmp82.FindInternedVar(lang.NewSymbol("vector")) + if tmp83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp83))) + } + tmp84 := tmp83.Get() + tmp85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp86 := tmp85.FindInternedVar(lang.NewSymbol("seq")) + if tmp86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp86))) + } + tmp87 := tmp86.Get() + tmp88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp89 := tmp88.FindInternedVar(lang.NewSymbol("concat")) + if tmp89.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp89))) + } + tmp90 := tmp89.Get() + tmp91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp92 := tmp91.FindInternedVar(lang.NewSymbol("list")) + if tmp92.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp92))) + } + tmp93 := tmp92.Get() + tmp94 := lang.Apply(tmp93, []any{lang.NewSymbol("n__0__auto__")}) + tmp95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp96 := tmp95.FindInternedVar(lang.NewSymbol("list")) + if tmp96.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp96))) + } + tmp97 := tmp96.Get() + tmp98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp99 := tmp98.FindInternedVar(lang.NewSymbol("seq")) + if tmp99.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp99))) + } + tmp100 := tmp99.Get() + tmp101 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp102 := tmp101.FindInternedVar(lang.NewSymbol("concat")) + if tmp102.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp102))) + } + tmp103 := tmp102.Get() + tmp104 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp105 := tmp104.FindInternedVar(lang.NewSymbol("list")) + if tmp105.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp105))) + } + tmp106 := tmp105.Get() + tmp107 := lang.Apply(tmp106, []any{lang.NewSymbol("glojure.core/long")}) + tmp108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp109 := tmp108.FindInternedVar(lang.NewSymbol("list")) + if tmp109.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp109))) + } + tmp110 := tmp109.Get() + tmp111 := lang.Apply(tmp110, []any{v65}) + tmp112 := lang.Apply(tmp103, []any{tmp107, tmp111}) + tmp113 := lang.Apply(tmp100, []any{tmp112}) + tmp114 := lang.Apply(tmp97, []any{tmp113}) + tmp115 := lang.Apply(tmp90, []any{tmp94, tmp114}) + tmp116 := lang.Apply(tmp87, []any{tmp115}) + tmp117 := lang.Apply(tmp81, []any{tmp84, tmp116}) + tmp118 := lang.Apply(tmp78, []any{tmp117}) + tmp119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp120 := tmp119.FindInternedVar(lang.NewSymbol("list")) + if tmp120.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp120))) + } + tmp121 := tmp120.Get() + tmp122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp123 := tmp122.FindInternedVar(lang.NewSymbol("seq")) + if tmp123.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp123))) + } + tmp124 := tmp123.Get() + tmp125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp126 := tmp125.FindInternedVar(lang.NewSymbol("concat")) + if tmp126.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp126))) + } + tmp127 := tmp126.Get() + tmp128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp129 := tmp128.FindInternedVar(lang.NewSymbol("list")) + if tmp129.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp129))) + } + tmp130 := tmp129.Get() + tmp131 := lang.Apply(tmp130, []any{lang.NewSymbol("glojure.core/loop")}) + tmp132 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp133 := tmp132.FindInternedVar(lang.NewSymbol("list")) + if tmp133.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp133))) + } + tmp134 := tmp133.Get() + tmp135 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp136 := tmp135.FindInternedVar(lang.NewSymbol("apply")) + if tmp136.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp136))) + } + tmp137 := tmp136.Get() + tmp138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp139 := tmp138.FindInternedVar(lang.NewSymbol("vector")) + if tmp139.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp139))) + } + tmp140 := tmp139.Get() + tmp141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp142 := tmp141.FindInternedVar(lang.NewSymbol("seq")) + if tmp142.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp142))) + } + tmp143 := tmp142.Get() + tmp144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp145 := tmp144.FindInternedVar(lang.NewSymbol("concat")) + if tmp145.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp145))) + } + tmp146 := tmp145.Get() + tmp147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp148 := tmp147.FindInternedVar(lang.NewSymbol("list")) + if tmp148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp148))) + } + tmp149 := tmp148.Get() + tmp150 := lang.Apply(tmp149, []any{v60}) + tmp151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp152 := tmp151.FindInternedVar(lang.NewSymbol("list")) + if tmp152.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp152))) + } + tmp153 := tmp152.Get() + tmp154 := lang.Apply(tmp153, []any{int64(0)}) + tmp155 := lang.Apply(tmp146, []any{tmp150, tmp154}) + tmp156 := lang.Apply(tmp143, []any{tmp155}) + tmp157 := lang.Apply(tmp137, []any{tmp140, tmp156}) + tmp158 := lang.Apply(tmp134, []any{tmp157}) + tmp159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp160 := tmp159.FindInternedVar(lang.NewSymbol("list")) + if tmp160.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp160))) + } + tmp161 := tmp160.Get() + tmp162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp163 := tmp162.FindInternedVar(lang.NewSymbol("seq")) + if tmp163.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp163))) + } + tmp164 := tmp163.Get() + tmp165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp166 := tmp165.FindInternedVar(lang.NewSymbol("concat")) + if tmp166.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp166))) + } + tmp167 := tmp166.Get() + tmp168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp169 := tmp168.FindInternedVar(lang.NewSymbol("list")) + if tmp169.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp169))) + } + tmp170 := tmp169.Get() + tmp171 := lang.Apply(tmp170, []any{lang.NewSymbol("glojure.core/when")}) + tmp172 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp173 := tmp172.FindInternedVar(lang.NewSymbol("list")) + if tmp173.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp173))) + } + tmp174 := tmp173.Get() + tmp175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp176 := tmp175.FindInternedVar(lang.NewSymbol("seq")) + if tmp176.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp176))) + } + tmp177 := tmp176.Get() + tmp178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp179 := tmp178.FindInternedVar(lang.NewSymbol("concat")) + if tmp179.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp179))) + } + tmp180 := tmp179.Get() + tmp181 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp182 := tmp181.FindInternedVar(lang.NewSymbol("list")) + if tmp182.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp182))) + } + tmp183 := tmp182.Get() + tmp184 := lang.Apply(tmp183, []any{lang.NewSymbol("glojure.core/<")}) + tmp185 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp186 := tmp185.FindInternedVar(lang.NewSymbol("list")) + if tmp186.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp186))) + } + tmp187 := tmp186.Get() + tmp188 := lang.Apply(tmp187, []any{v60}) + tmp189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp190 := tmp189.FindInternedVar(lang.NewSymbol("list")) + if tmp190.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp190))) + } + tmp191 := tmp190.Get() + tmp192 := lang.Apply(tmp191, []any{lang.NewSymbol("n__0__auto__")}) + tmp193 := lang.Apply(tmp180, []any{tmp184, tmp188, tmp192}) + tmp194 := lang.Apply(tmp177, []any{tmp193}) + tmp195 := lang.Apply(tmp174, []any{tmp194}) + tmp196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp197 := tmp196.FindInternedVar(lang.NewSymbol("list")) + if tmp197.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp197))) + } + tmp198 := tmp197.Get() + tmp199 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp200 := tmp199.FindInternedVar(lang.NewSymbol("seq")) + if tmp200.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp200))) + } + tmp201 := tmp200.Get() + tmp202 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp203 := tmp202.FindInternedVar(lang.NewSymbol("concat")) + if tmp203.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp203))) + } + tmp204 := tmp203.Get() + tmp205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp206 := tmp205.FindInternedVar(lang.NewSymbol("list")) + if tmp206.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp206))) + } + tmp207 := tmp206.Get() + tmp208 := lang.Apply(tmp207, []any{lang.NewSymbol("recur")}) + tmp209 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp210 := tmp209.FindInternedVar(lang.NewSymbol("list")) + if tmp210.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp210))) + } + tmp211 := tmp210.Get() + tmp212 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp213 := tmp212.FindInternedVar(lang.NewSymbol("seq")) + if tmp213.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp213))) + } + tmp214 := tmp213.Get() + tmp215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp216 := tmp215.FindInternedVar(lang.NewSymbol("concat")) + if tmp216.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp216))) + } + tmp217 := tmp216.Get() + tmp218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp219 := tmp218.FindInternedVar(lang.NewSymbol("list")) + if tmp219.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp219))) + } + tmp220 := tmp219.Get() + tmp221 := lang.Apply(tmp220, []any{lang.NewSymbol("glojure.core/unchecked-inc")}) + tmp222 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp223 := tmp222.FindInternedVar(lang.NewSymbol("list")) + if tmp223.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp223))) + } + tmp224 := tmp223.Get() + tmp225 := lang.Apply(tmp224, []any{v60}) + tmp226 := lang.Apply(tmp217, []any{tmp221, tmp225}) + tmp227 := lang.Apply(tmp214, []any{tmp226}) + tmp228 := lang.Apply(tmp211, []any{tmp227}) + tmp229 := lang.Apply(tmp204, []any{tmp208, tmp228}) + tmp230 := lang.Apply(tmp201, []any{tmp229}) + tmp231 := lang.Apply(tmp198, []any{tmp230}) + tmp232 := lang.Apply(tmp167, []any{tmp171, tmp195, v6, tmp231}) + tmp233 := lang.Apply(tmp164, []any{tmp232}) + tmp234 := lang.Apply(tmp161, []any{tmp233}) + tmp235 := lang.Apply(tmp127, []any{tmp131, tmp158, tmp234}) + tmp236 := lang.Apply(tmp124, []any{tmp235}) + tmp237 := lang.Apply(tmp121, []any{tmp236}) + tmp238 := lang.Apply(tmp71, []any{tmp75, tmp118, tmp237}) + tmp239 := lang.Apply(tmp68, []any{tmp238}) + tmp55 = tmp239 } // end let - return v55 + return tmp55 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // doto { - v0 := lang.NewSymbol("doto").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "Evaluates x then calls all of the methods and functions with the\n value of x supplied at the front of the given arguments. The forms\n are evaluated in order. Returns x.\n\n (doto (new java.util.HashMap) (.put \"a\" 1) (.put \"b\" 2))", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3853), lang.NewKeyword("end-line"), int(3853))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("doto").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "Evaluates x then calls all of the methods and functions with the\n value of x supplied at the front of the given arguments. The forms\n are evaluated in order. Returns x.\n\n (doto (new java.util.HashMap) (.put \"a\" 1) (.put \"b\" 2))", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3853), lang.NewKeyword("end-line"), int(3853))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 3 { @@ -30137,861 +30225,867 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - var v7 any + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any { // let // let binding "gx" - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("gensym")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, nil) - var v12 any = v11 + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("gensym")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, nil) + var v12 any = tmp11 _ = v12 - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("seq")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("concat")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("list")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{lang.NewSymbol("glojure.core/let")}) - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("list")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("apply")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) - } - v28 := v27.Get() - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("vector")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("seq")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v36 := v35.FindInternedVar(lang.NewSymbol("concat")) - if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) - } - v37 := v36.Get() - v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v39 := v38.FindInternedVar(lang.NewSymbol("list")) - if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) - } - v40 := v39.Get() - v41 := lang.Apply(v40, []any{v12}) - v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v43 := v42.FindInternedVar(lang.NewSymbol("list")) - if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) - } - v44 := v43.Get() - v45 := lang.Apply(v44, []any{v5}) - v46 := lang.Apply(v37, []any{v41, v45}) - v47 := lang.Apply(v34, []any{v46}) - v48 := lang.Apply(v28, []any{v31, v47}) - v49 := lang.Apply(v25, []any{v48}) - v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v51 := v50.FindInternedVar(lang.NewSymbol("map")) - if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) - } - v52 := v51.Get() - var v53 lang.FnFunc - v53 = lang.NewFnFunc(func(args ...any) any { + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("seq")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("concat")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("glojure.core/let")}) + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("apply")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) + } + tmp28 := tmp27.Get() + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("vector")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("seq")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp36 := tmp35.FindInternedVar(lang.NewSymbol("concat")) + if tmp36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) + } + tmp37 := tmp36.Get() + tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp39 := tmp38.FindInternedVar(lang.NewSymbol("list")) + if tmp39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) + } + tmp40 := tmp39.Get() + tmp41 := lang.Apply(tmp40, []any{v12}) + tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp43 := tmp42.FindInternedVar(lang.NewSymbol("list")) + if tmp43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) + } + tmp44 := tmp43.Get() + tmp45 := lang.Apply(tmp44, []any{v5}) + tmp46 := lang.Apply(tmp37, []any{tmp41, tmp45}) + tmp47 := lang.Apply(tmp34, []any{tmp46}) + tmp48 := lang.Apply(tmp28, []any{tmp31, tmp47}) + tmp49 := lang.Apply(tmp25, []any{tmp48}) + tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp51 := tmp50.FindInternedVar(lang.NewSymbol("map")) + if tmp51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) + } + tmp52 := tmp51.Get() + var tmp53 lang.FnFunc + tmp53 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v54 := args[0] _ = v54 - v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v56 := v55.FindInternedVar(lang.NewSymbol("with-meta")) - if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) - } - v57 := v56.Get() - var v58 any - v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v60 := v59.FindInternedVar(lang.NewSymbol("seq?")) - if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) - } - v61 := v60.Get() - v62 := lang.Apply(v61, []any{v54}) - if lang.IsTruthy(v62) { - v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v64 := v63.FindInternedVar(lang.NewSymbol("seq")) - if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) - } - v65 := v64.Get() - v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v67 := v66.FindInternedVar(lang.NewSymbol("concat")) - if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) - } - v68 := v67.Get() - v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v70 := v69.FindInternedVar(lang.NewSymbol("list")) - if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) - } - v71 := v70.Get() - v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v73 := v72.FindInternedVar(lang.NewSymbol("first")) - if v73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) - } - v74 := v73.Get() - v75 := lang.Apply(v74, []any{v54}) - v76 := lang.Apply(v71, []any{v75}) - v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v78 := v77.FindInternedVar(lang.NewSymbol("list")) - if v78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) - } - v79 := v78.Get() - v80 := lang.Apply(v79, []any{v12}) - v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v82 := v81.FindInternedVar(lang.NewSymbol("next")) - if v82.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) - } - v83 := v82.Get() - v84 := lang.Apply(v83, []any{v54}) - v85 := lang.Apply(v68, []any{v76, v80, v84}) - v86 := lang.Apply(v65, []any{v85}) - v58 = v86 + tmp55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp56 := tmp55.FindInternedVar(lang.NewSymbol("with-meta")) + if tmp56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp56))) + } + tmp57 := tmp56.Get() + var tmp58 any + tmp59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp60 := tmp59.FindInternedVar(lang.NewSymbol("seq?")) + if tmp60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp60))) + } + tmp61 := tmp60.Get() + tmp62 := lang.Apply(tmp61, []any{v54}) + if lang.IsTruthy(tmp62) { + tmp63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp64 := tmp63.FindInternedVar(lang.NewSymbol("seq")) + if tmp64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp64))) + } + tmp65 := tmp64.Get() + tmp66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp67 := tmp66.FindInternedVar(lang.NewSymbol("concat")) + if tmp67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp67))) + } + tmp68 := tmp67.Get() + tmp69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp70 := tmp69.FindInternedVar(lang.NewSymbol("list")) + if tmp70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp70))) + } + tmp71 := tmp70.Get() + tmp72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp73 := tmp72.FindInternedVar(lang.NewSymbol("first")) + if tmp73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp73))) + } + tmp74 := tmp73.Get() + tmp75 := lang.Apply(tmp74, []any{v54}) + tmp76 := lang.Apply(tmp71, []any{tmp75}) + tmp77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp78 := tmp77.FindInternedVar(lang.NewSymbol("list")) + if tmp78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp78))) + } + tmp79 := tmp78.Get() + tmp80 := lang.Apply(tmp79, []any{v12}) + tmp81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp82 := tmp81.FindInternedVar(lang.NewSymbol("next")) + if tmp82.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp82))) + } + tmp83 := tmp82.Get() + tmp84 := lang.Apply(tmp83, []any{v54}) + tmp85 := lang.Apply(tmp68, []any{tmp76, tmp80, tmp84}) + tmp86 := lang.Apply(tmp65, []any{tmp85}) + tmp58 = tmp86 } else { - v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v88 := v87.FindInternedVar(lang.NewSymbol("seq")) - if v88.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) - } - v89 := v88.Get() - v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v91 := v90.FindInternedVar(lang.NewSymbol("concat")) - if v91.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) - } - v92 := v91.Get() - v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v94 := v93.FindInternedVar(lang.NewSymbol("list")) - if v94.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) - } - v95 := v94.Get() - v96 := lang.Apply(v95, []any{v54}) - v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v98 := v97.FindInternedVar(lang.NewSymbol("list")) - if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) - } - v99 := v98.Get() - v100 := lang.Apply(v99, []any{v12}) - v101 := lang.Apply(v92, []any{v96, v100}) - v102 := lang.Apply(v89, []any{v101}) - v58 = v102 - } - v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v104 := v103.FindInternedVar(lang.NewSymbol("meta")) - if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) - } - v105 := v104.Get() - v106 := lang.Apply(v105, []any{v54}) - v107 := lang.Apply(v57, []any{v58, v106}) - return v107 + tmp87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp88 := tmp87.FindInternedVar(lang.NewSymbol("seq")) + if tmp88.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp88))) + } + tmp89 := tmp88.Get() + tmp90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp91 := tmp90.FindInternedVar(lang.NewSymbol("concat")) + if tmp91.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp91))) + } + tmp92 := tmp91.Get() + tmp93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp94 := tmp93.FindInternedVar(lang.NewSymbol("list")) + if tmp94.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp94))) + } + tmp95 := tmp94.Get() + tmp96 := lang.Apply(tmp95, []any{v54}) + tmp97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp98 := tmp97.FindInternedVar(lang.NewSymbol("list")) + if tmp98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp98))) + } + tmp99 := tmp98.Get() + tmp100 := lang.Apply(tmp99, []any{v12}) + tmp101 := lang.Apply(tmp92, []any{tmp96, tmp100}) + tmp102 := lang.Apply(tmp89, []any{tmp101}) + tmp58 = tmp102 + } + tmp103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp104 := tmp103.FindInternedVar(lang.NewSymbol("meta")) + if tmp104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp104))) + } + tmp105 := tmp104.Get() + tmp106 := lang.Apply(tmp105, []any{v54}) + tmp107 := lang.Apply(tmp57, []any{tmp58, tmp106}) + return tmp107 }) - v54 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3863), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(3868), lang.NewKeyword("end-column"), int(30)) - v55, err := lang.WithMeta(v53, v54.(lang.IPersistentMap)) + tmp54 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3863), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(3868), lang.NewKeyword("end-column"), int(30)) + tmp55, err := lang.WithMeta(tmp53, tmp54.(lang.IPersistentMap)) if err != nil { panic(err) } - v56 := lang.Apply(v52, []any{v55, v6}) - v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v58 := v57.FindInternedVar(lang.NewSymbol("list")) - if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) - } - v59 := v58.Get() - v60 := lang.Apply(v59, []any{v12}) - v61 := lang.Apply(v18, []any{v22, v49, v56, v60}) - v62 := lang.Apply(v15, []any{v61}) - v7 = v62 + tmp56 := lang.Apply(tmp52, []any{tmp55, v6}) + tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp58 := tmp57.FindInternedVar(lang.NewSymbol("list")) + if tmp58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) + } + tmp59 := tmp58.Get() + tmp60 := lang.Apply(tmp59, []any{v12}) + tmp61 := lang.Apply(tmp18, []any{tmp22, tmp49, tmp56, tmp60}) + tmp62 := lang.Apply(tmp15, []any{tmp61}) + tmp7 = tmp62 } // end let - return v7 + return tmp7 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // double { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function double__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("concat")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("list")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("seq")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("concat")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/DoubleCast")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{v3}) - v35 := lang.Apply(v26, []any{v30, v34}) - v36 := lang.Apply(v23, []any{v35}) - v37 := lang.Apply(v20, []any{v36}) - v38 := lang.Apply(v9, []any{v13, v17, v37}) - v39 := lang.Apply(v6, []any{v38}) - return v39 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/DoubleCast")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{v3}) + tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) + tmp36 := lang.Apply(tmp23, []any{tmp35}) + tmp37 := lang.Apply(tmp20, []any{tmp36}) + tmp38 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp37}) + tmp39 := lang.Apply(tmp6, []any{tmp38}) + return tmp39 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("double").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to double", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3493), lang.NewKeyword("end-line"), int(3493))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("double").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to double", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3493), lang.NewKeyword("end-line"), int(3493))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5 := lang.Apply(lang.AsFloat64, []any{v4}) - return v5 + tmp5 := lang.Apply(lang.AsFloat64, []any{v4}) + return tmp5 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // double-array { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function double-array__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v3 := lang.NewList(args[0:]...) - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("concat")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("list")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/DoubleArray")}) - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("list")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("seq")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("concat")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) - v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v36 := v35.FindInternedVar(lang.NewSymbol("list")) - if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) - } - v37 := v36.Get() - v38 := lang.Apply(v37, []any{lang.NewSymbol("glojure.core/args")}) - v39 := lang.Apply(v30, []any{v34, v38}) - v40 := lang.Apply(v27, []any{v39}) - v41 := lang.Apply(v24, []any{v40}) - v42 := lang.Apply(v9, []any{v13, v17, v21, v41}) - v43 := lang.Apply(v6, []any{v42}) - return v43 + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.Apply(tmp20, []any{lang.NewSymbol("glojure.core/DoubleArray")}) + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("list")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("seq")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("concat")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) + tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp36 := tmp35.FindInternedVar(lang.NewSymbol("list")) + if tmp36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) + } + tmp37 := tmp36.Get() + tmp38 := lang.Apply(tmp37, []any{lang.NewSymbol("glojure.core/args")}) + tmp39 := lang.Apply(tmp30, []any{tmp34, tmp38}) + tmp40 := lang.Apply(tmp27, []any{tmp39}) + tmp41 := lang.Apply(tmp24, []any{tmp40}) + tmp42 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp21, tmp41}) + tmp43 := lang.Apply(tmp6, []any{tmp42}) + return tmp43 } }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("double-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Creates an array of doubles", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1), int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5341), lang.NewKeyword("end-line"), int(5341))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("double-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Creates an array of doubles", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5341), lang.NewKeyword("end-line"), int(5341))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v4 := args[0] _ = v4 - v5, _ := lang.FieldOrMethod(lang.Numbers, "DoubleArray") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "DoubleArray") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("DoubleArray is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 case 2: v4 := args[0] _ = v4 v5 := args[1] _ = v5 - v6, _ := lang.FieldOrMethod(lang.Numbers, "DoubleArrayInit") - if reflect.TypeOf(v6).Kind() != reflect.Func { + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "DoubleArrayInit") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("DoubleArrayInit is not a function"))) } - v7 := lang.Apply(v6, []any{v4, v5}) - return v7 + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // double? { - v0 := lang.NewSymbol("double?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a Double", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1421), lang.NewKeyword("end-line"), int(1421))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("double?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a Double", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1421), lang.NewKeyword("end-line"), int(1421))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) } - v6 := v5.Get() - v7 := lang.Apply(v6, []any{lang.Builtins["float64"], v3}) - return v7 + tmp6 := tmp5.Get() + tmp7 := lang.Apply(tmp6, []any{lang.Builtins["float64"], v3}) + return tmp7 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // doubles { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function doubles - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("concat")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("list")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/Doubles")}) - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("list")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v3}) - v26 := lang.Apply(v9, []any{v13, v17, v21, v25}) - v27 := lang.Apply(v6, []any{v26}) - return v27 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.Apply(tmp20, []any{lang.NewSymbol("glojure.core/Doubles")}) + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("list")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.Apply(tmp24, []any{v3}) + tmp26 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp21, tmp25}) + tmp27 := lang.Apply(tmp6, []any{tmp26}) + return tmp27 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("doubles").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Casts to double[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5402), lang.NewKeyword("end-line"), int(5402))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("doubles").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Casts to double[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5402), lang.NewKeyword("end-line"), int(5402))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5, _ := lang.FieldOrMethod(lang.Numbers, "Doubles") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Doubles") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Doubles is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // drop { - v0 := lang.NewSymbol("drop").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a laziness-preserving sequence of all but the first n items in coll.\n Returns a stateful transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2901), lang.NewKeyword("end-line"), int(2901))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("drop").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a laziness-preserving sequence of all but the first n items in coll.\n Returns a stateful transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2901), lang.NewKeyword("end-line"), int(2901))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - var v4 lang.FnFunc - v4 = lang.NewFnFunc(func(args ...any) any { + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v5 := args[0] _ = v5 - var v6 any + var tmp6 any { // let // let binding "nv" - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("volatile!")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v9, []any{v3}) - var v11 any = v10 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("volatile!")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp9, []any{v3}) + var v11 any = tmp10 _ = v11 - var v12 lang.FnFunc - v12 = lang.NewFnFunc(func(args ...any) any { + var tmp12 lang.FnFunc + tmp12 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - v13 := lang.Apply(v5, nil) - return v13 + tmp13 := lang.Apply(v5, nil) + return tmp13 case 1: v13 := args[0] _ = v13 - v14 := lang.Apply(v5, []any{v13}) - return v14 + tmp14 := lang.Apply(v5, []any{v13}) + return tmp14 case 2: v13 := args[0] _ = v13 v14 := args[1] _ = v14 - var v15 any + var tmp15 any { // let // let binding "n" - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("deref")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("deref")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{v11}) - var v20 any = v19 + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{v11}) + var v20 any = tmp19 _ = v20 - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("dec")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("dec")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) } - v23 := v22.Get() - v24, ok := lang.FieldOrMethod(v11, "Deref") + tmp23 := tmp22.Get() + tmp24, ok := lang.FieldOrMethod(v11, "Deref") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v11, "Deref"))) } - var v25 any - switch reflect.TypeOf(v24).Kind() { + var tmp25 any + switch reflect.TypeOf(tmp24).Kind() { case reflect.Func: - v25 = lang.Apply(v24, nil) + tmp25 = lang.Apply(tmp24, nil) default: - v25 = v24 + tmp25 = tmp24 } - v26 := lang.Apply(v23, []any{v25}) - v27, _ := lang.FieldOrMethod(v11, "reset") - if reflect.TypeOf(v27).Kind() != reflect.Func { + tmp26 := lang.Apply(tmp23, []any{tmp25}) + tmp27, _ := lang.FieldOrMethod(v11, "reset") + if reflect.TypeOf(tmp27).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) } - v28 := lang.Apply(v27, []any{v26}) - _ = v28 - var v29 any - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("pos?")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + tmp28 := lang.Apply(tmp27, []any{tmp26}) + _ = tmp28 + var tmp29 any + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("pos?")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) } - v32 := v31.Get() - v33 := lang.Apply(v32, []any{v20}) - if lang.IsTruthy(v33) { - v29 = v13 + tmp32 := tmp31.Get() + tmp33 := lang.Apply(tmp32, []any{v20}) + if lang.IsTruthy(tmp33) { + tmp29 = v13 } else { - v34 := lang.Apply(v5, []any{v13, v14}) - v29 = v34 + tmp34 := lang.Apply(v5, []any{v13, v14}) + tmp29 = tmp34 } - v15 = v29 + tmp15 = tmp29 } // end let - return v15 + return tmp15 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2909), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(2917), lang.NewKeyword("end-column"), int(39)) - v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) + tmp13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2909), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(2917), lang.NewKeyword("end-column"), int(39)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) if err != nil { panic(err) } - v6 = v14 + tmp6 = tmp14 } // end let - return v6 + return tmp6 }) - v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2907), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2917), lang.NewKeyword("end-column"), int(41)) - v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) + tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2907), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2917), lang.NewKeyword("end-column"), int(41)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) if err != nil { panic(err) } - return v6 + return tmp6 case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - var v5 any - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{lang.IDrop, v4}) - if lang.IsTruthy(v9) { - var v10 any + var tmp5 any + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("instance?")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := reflect.TypeOf((*lang.IDrop)(nil)).Elem() + tmp10 := lang.Apply(tmp8, []any{tmp9, v4}) + if lang.IsTruthy(tmp10) { + var tmp11 any { // let // let binding "or__0__auto__" - var v11 any - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("pos?")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.Apply(v14, []any{v3}) - if lang.IsTruthy(v15) { - var v16 any - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("int?")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.Apply(v19, []any{v3}) - if lang.IsTruthy(v20) { - v16 = v3 + var tmp12 any + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("pos?")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{v3}) + if lang.IsTruthy(tmp16) { + var tmp17 any + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("int?")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.Apply(tmp20, []any{v3}) + if lang.IsTruthy(tmp21) { + tmp17 = v3 } else { - v21 := lang.Apply(nil, []any{v3}) - v16 = v21 + tmp22 := lang.Apply(nil, []any{v3}) + tmp17 = tmp22 } - v22, _ := lang.FieldOrMethod(v4, "drop") - if reflect.TypeOf(v22).Kind() != reflect.Func { + tmp23, _ := lang.FieldOrMethod(v4, "drop") + if reflect.TypeOf(tmp23).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("drop is not a function"))) } - v23 := lang.Apply(v22, []any{v16}) - v11 = v23 + tmp24 := lang.Apply(tmp23, []any{tmp17}) + tmp12 = tmp24 } else { - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("seq")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("seq")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) } - v26 := v25.Get() - v27 := lang.Apply(v26, []any{v4}) - v11 = v27 + tmp27 := tmp26.Get() + tmp28 := lang.Apply(tmp27, []any{v4}) + tmp12 = tmp28 } - var v28 any = v11 - _ = v28 - var v29 any - if lang.IsTruthy(v28) { - v29 = v28 + var v29 any = tmp12 + _ = v29 + var tmp30 any + if lang.IsTruthy(v29) { + tmp30 = v29 } else { - v29 = lang.NewList() + tmp30 = lang.NewList() } - v10 = v29 + tmp11 = tmp30 } // end let - v5 = v10 + tmp5 = tmp11 } else { - var v11 any + var tmp12 any { // let // let binding "step" - var v12 lang.FnFunc - v12 = lang.NewFnFunc(func(args ...any) any { + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v13 := args[0] - _ = v13 - v14 := args[1] + v14 := args[0] _ = v14 + v15 := args[1] + _ = v15 recur_loop_539: - var v15 any + var tmp16 any { // let // let binding "s" - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("seq")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{v14}) - var v20 any = v19 - _ = v20 - var v21 any - var v22 any + tmp19 := tmp18.Get() + tmp20 := lang.Apply(tmp19, []any{v15}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + var tmp23 any { // let // let binding "and__0__auto__" - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("pos?")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("pos?")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) } - v25 := v24.Get() - v26 := lang.Apply(v25, []any{v13}) - var v27 any = v26 - _ = v27 - var v28 any - if lang.IsTruthy(v27) { - v28 = v20 + tmp26 := tmp25.Get() + tmp27 := lang.Apply(tmp26, []any{v14}) + var v28 any = tmp27 + _ = v28 + var tmp29 any + if lang.IsTruthy(v28) { + tmp29 = v21 } else { - v28 = v27 + tmp29 = v28 } - v22 = v28 + tmp23 = tmp29 } // end let - if lang.IsTruthy(v22) { - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("dec")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + if lang.IsTruthy(tmp23) { + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("dec")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) } - v26 := v25.Get() - v27 := lang.Apply(v26, []any{v13}) - var v23 any = v27 - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("rest")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + tmp27 := tmp26.Get() + tmp28 := lang.Apply(tmp27, []any{v14}) + var tmp24 any = tmp28 + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("rest")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) } - v31 := v30.Get() - v32 := lang.Apply(v31, []any{v20}) - var v28 any = v32 - v13 = v23 - v14 = v28 + tmp32 := tmp31.Get() + tmp33 := lang.Apply(tmp32, []any{v21}) + var tmp29 any = tmp33 + v14 = tmp24 + v15 = tmp29 goto recur_loop_539 } else { - v21 = v20 + tmp22 = v21 } - v15 = v21 + tmp16 = tmp22 } // end let - return v15 + return tmp16 }) - v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2925), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(2929), lang.NewKeyword("end-column"), int(28)) - v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) + tmp14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2925), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(2929), lang.NewKeyword("end-column"), int(28)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) if err != nil { panic(err) } - var v15 any = v14 - _ = v15 - var v16 lang.FnFunc - v16 = lang.NewFnFunc(func(args ...any) any { + var v16 any = tmp15 + _ = v16 + var tmp17 lang.FnFunc + tmp17 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v17 := lang.Apply(v15, []any{v3, v4}) - return v17 + tmp18 := lang.Apply(v16, []any{v3, v4}) + return tmp18 }) - v17 := lang.Apply(lang.NewLazySeq, []any{v16}) - v11 = v17 + tmp18 := lang.Apply(lang.NewLazySeq, []any{tmp17}) + tmp12 = tmp18 } // end let - v5 = v11 + tmp5 = tmp12 } - return v5 + return tmp5 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // drop-last { - v0 := lang.NewSymbol("drop-last").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return a lazy sequence of all but the last n (default 1) items in coll", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2932), lang.NewKeyword("end-line"), int(2932))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("drop-last").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return a lazy sequence of all but the last n (default 1) items in coll", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2932), lang.NewKeyword("end-line"), int(2932))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("drop-last")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.Apply(v6, []any{int64(1), v3}) - return v7 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("drop-last")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.Apply(tmp6, []any{int64(1), v3}) + return tmp7 case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("map")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - var v8 lang.FnFunc - v8 = lang.NewFnFunc(func(args ...any) any { + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("map")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + var tmp8 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -31001,147 +31095,147 @@ func init() { _ = v10 return v9 }) - v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2937), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(2937), lang.NewKeyword("end-column"), int(29)) - v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) + tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2937), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(2937), lang.NewKeyword("end-column"), int(29)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) if err != nil { panic(err) } - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("drop")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("drop")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{v3, v4}) - v15 := lang.Apply(v7, []any{v10, v4, v14}) - return v15 + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{v3, v4}) + tmp15 := lang.Apply(tmp7, []any{tmp10, v4, tmp14}) + return tmp15 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // drop-while { - v0 := lang.NewSymbol("drop-while").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred")), lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the items in coll starting from the\n first item for which (pred item) returns logical false. Returns a\n stateful transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2950), lang.NewKeyword("end-line"), int(2950))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("drop-while").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred")), lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the items in coll starting from the\n first item for which (pred item) returns logical false. Returns a\n stateful transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2950), lang.NewKeyword("end-line"), int(2950))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - var v4 lang.FnFunc - v4 = lang.NewFnFunc(func(args ...any) any { + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v5 := args[0] _ = v5 - var v6 any + var tmp6 any { // let // let binding "dv" - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("volatile!")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v9, []any{true}) - var v11 any = v10 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("volatile!")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp9, []any{true}) + var v11 any = tmp10 _ = v11 - var v12 lang.FnFunc - v12 = lang.NewFnFunc(func(args ...any) any { + var tmp12 lang.FnFunc + tmp12 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - v13 := lang.Apply(v5, nil) - return v13 + tmp13 := lang.Apply(v5, nil) + return tmp13 case 1: v13 := args[0] _ = v13 - v14 := lang.Apply(v5, []any{v13}) - return v14 + tmp14 := lang.Apply(v5, []any{v13}) + return tmp14 case 2: v13 := args[0] _ = v13 v14 := args[1] _ = v14 - var v15 any + var tmp15 any { // let // let binding "drop?" - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("deref")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("deref")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{v11}) - var v20 any = v19 + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{v11}) + var v20 any = tmp19 _ = v20 - var v21 any - var v22 any + var tmp21 any + var tmp22 any { // let // let binding "and__0__auto__" var v23 any = v20 _ = v23 - var v24 any + var tmp24 any if lang.IsTruthy(v23) { - v25 := lang.Apply(v3, []any{v14}) - v24 = v25 + tmp25 := lang.Apply(v3, []any{v14}) + tmp24 = tmp25 } else { - v24 = v23 + tmp24 = v23 } - v22 = v24 + tmp22 = tmp24 } // end let - if lang.IsTruthy(v22) { - v21 = v13 + if lang.IsTruthy(tmp22) { + tmp21 = v13 } else { - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("vreset!")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("vreset!")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) } - v25 := v24.Get() - v26 := lang.Apply(v25, []any{v11, nil}) - _ = v26 - v27 := lang.Apply(v5, []any{v13, v14}) - v21 = v27 + tmp25 := tmp24.Get() + tmp26 := lang.Apply(tmp25, []any{v11, nil}) + _ = tmp26 + tmp27 := lang.Apply(v5, []any{v13, v14}) + tmp21 = tmp27 } - v15 = v21 + tmp15 = tmp21 } // end let - return v15 + return tmp15 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2959), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(2968), lang.NewKeyword("end-column"), int(42)) - v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) + tmp13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2959), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(2968), lang.NewKeyword("end-column"), int(42)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) if err != nil { panic(err) } - v6 = v14 + tmp6 = tmp14 } // end let - return v6 + return tmp6 }) - v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2957), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2968), lang.NewKeyword("end-column"), int(44)) - v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) + tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2957), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2968), lang.NewKeyword("end-column"), int(44)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) if err != nil { panic(err) } - return v6 + return tmp6 case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - var v5 any + var tmp5 any { // let // let binding "step" - var v6 lang.FnFunc - v6 = lang.NewFnFunc(func(args ...any) any { + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -31150,94 +31244,94 @@ func init() { v8 := args[1] _ = v8 recur_loop_552: - var v9 any + var tmp9 any { // let // let binding "s" - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("seq")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{v8}) - var v14 any = v13 + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("seq")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{v8}) + var v14 any = tmp13 _ = v14 - var v15 any - var v16 any + var tmp15 any + var tmp16 any { // let // let binding "and__0__auto__" var v17 any = v14 _ = v17 - var v18 any + var tmp18 any if lang.IsTruthy(v17) { - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("first")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("first")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{v14}) - v23 := lang.Apply(v7, []any{v22}) - v18 = v23 + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, []any{v14}) + tmp23 := lang.Apply(v7, []any{tmp22}) + tmp18 = tmp23 } else { - v18 = v17 + tmp18 = v17 } - v16 = v18 + tmp16 = tmp18 } // end let - if lang.IsTruthy(v16) { - var v17 any = v7 - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("rest")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + if lang.IsTruthy(tmp16) { + var tmp17 any = v7 + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("rest")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{v14}) - var v18 any = v22 - v7 = v17 - v8 = v18 + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, []any{v14}) + var tmp18 any = tmp22 + v7 = tmp17 + v8 = tmp18 goto recur_loop_552 } else { - v15 = v14 + tmp15 = v14 } - v9 = v15 + tmp9 = tmp15 } // end let - return v9 + return tmp9 }) - v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2970), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(2974), lang.NewKeyword("end-column"), int(26)) - v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) + tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2970), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(2974), lang.NewKeyword("end-column"), int(26)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) if err != nil { panic(err) } - var v9 any = v8 + var v9 any = tmp8 _ = v9 - var v10 lang.FnFunc - v10 = lang.NewFnFunc(func(args ...any) any { + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v11 := lang.Apply(v9, []any{v3, v4}) - return v11 + tmp11 := lang.Apply(v9, []any{v3, v4}) + return tmp11 }) - v11 := lang.Apply(lang.NewLazySeq, []any{v10}) - v5 = v11 + tmp11 := lang.Apply(lang.NewLazySeq, []any{tmp10}) + tmp5 = tmp11 } // end let - return v5 + return tmp5 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // elide-top-frames { - v0 := lang.NewSymbol("elide-top-frames").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4794), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(4794), lang.NewKeyword("end-column"), int(32), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ex"), lang.NewSymbol("class-name"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("elide-top-frames").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4794), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(4794), lang.NewKeyword("end-column"), int(32), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ex"), lang.NewSymbol("class-name"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -31245,102 +31339,101 @@ func init() { _ = v3 v4 := args[1] _ = v4 - var v5 any + var tmp5 any { // let // let binding "tr" - v6, ok := lang.FieldOrMethod(v3, "getStackTrace") + tmp6, ok := lang.FieldOrMethod(v3, "getStackTrace") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getStackTrace"))) } - var v7 any - switch reflect.TypeOf(v6).Kind() { + var tmp7 any + switch reflect.TypeOf(tmp6).Kind() { case reflect.Func: - v7 = lang.Apply(v6, nil) + tmp7 = lang.Apply(tmp6, nil) default: - v7 = v6 + tmp7 = tmp6 } - var v8 any = v7 + var v8 any = tmp7 _ = v8 - var v9 any + var tmp9 any { // let // let binding "G__54" var v10 any = v3 _ = v10 - var v11 any + var tmp11 any if lang.IsTruthy(v8) { - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("into-array")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("drop-while")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - var v18 lang.FnFunc - v18 = lang.NewFnFunc(func(args ...any) any { + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("into-array")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("drop-while")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + var tmp18 lang.FnFunc + tmp18 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v19 := args[0] _ = v19 - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("=")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("=")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) } - v22 := v21.Get() - v23, ok := lang.FieldOrMethod(v19, "getClassName") + tmp22 := tmp21.Get() + tmp23, ok := lang.FieldOrMethod(v19, "getClassName") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v19, "getClassName"))) } - var v24 any - switch reflect.TypeOf(v23).Kind() { + var tmp24 any + switch reflect.TypeOf(tmp23).Kind() { case reflect.Func: - v24 = lang.Apply(v23, nil) + tmp24 = lang.Apply(tmp23, nil) default: - v24 = v23 + tmp24 = tmp23 } - v25 := lang.Apply(v22, []any{v4, v24}) - return v25 + tmp25 := lang.Apply(tmp22, []any{v4, tmp24}) + return tmp25 }) - v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4801), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(4801), lang.NewKeyword("end-column"), int(77)) - v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) + tmp19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4801), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(4801), lang.NewKeyword("end-column"), int(77)) + tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) if err != nil { panic(err) } - v21 := lang.Apply(v17, []any{v20, v8}) - v22 := lang.Apply(v14, []any{nil, v21}) - v11 = v22 + tmp21 := lang.Apply(tmp17, []any{tmp20, v8}) + tmp22 := lang.Apply(tmp14, []any{nil, tmp21}) + tmp11 = tmp22 } else { - v11 = nil } - v23, _ := lang.FieldOrMethod(v10, "setStackTrace") - if reflect.TypeOf(v23).Kind() != reflect.Func { + tmp23, _ := lang.FieldOrMethod(v10, "setStackTrace") + if reflect.TypeOf(tmp23).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("setStackTrace is not a function"))) } - v24 := lang.Apply(v23, []any{v11}) - _ = v24 - v9 = v10 + tmp24 := lang.Apply(tmp23, []any{tmp11}) + _ = tmp24 + tmp9 = v10 } // end let - v5 = v9 + tmp5 = tmp9 } // end let - return v5 + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // emit-extend-protocol { - v0 := lang.NewSymbol("emit-extend-protocol").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(205), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(205), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("p"), lang.NewSymbol("specs"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("emit-extend-protocol").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(205), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(205), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("p"), lang.NewSymbol("specs"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -31348,137 +31441,137 @@ func init() { _ = v3 v4 := args[1] _ = v4 - var v5 any + var tmp5 any { // let // let binding "impls" - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("parse-impls")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{v4}) - var v10 any = v9 + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("parse-impls")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.Apply(tmp8, []any{v4}) + var v10 any = tmp9 _ = v10 - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("seq")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("concat")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("list")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.Apply(v19, []any{lang.NewSymbol("do")}) - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("map")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - var v24 lang.FnFunc - v24 = lang.NewFnFunc(func(args ...any) any { + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("seq")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("concat")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("list")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.Apply(tmp19, []any{lang.NewSymbol("do")}) + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("map")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + var tmp24 lang.FnFunc + tmp24 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v25 := args[0] _ = v25 - var v26 any + var tmp26 any { // let // let binding "vec__292" var v27 any = v25 _ = v27 // let binding "t" - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("nth")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.Apply(v30, []any{v27, int64(0), nil}) - var v32 any = v31 + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("nth")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.Apply(tmp30, []any{v27, int64(0), nil}) + var v32 any = tmp31 _ = v32 // let binding "fs" - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("nth")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - v36 := lang.Apply(v35, []any{v27, int64(1), nil}) - var v37 any = v36 + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("nth")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) + } + tmp35 := tmp34.Get() + tmp36 := lang.Apply(tmp35, []any{v27, int64(1), nil}) + var v37 any = tmp36 _ = v37 - v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v39 := v38.FindInternedVar(lang.NewSymbol("seq")) - if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) - } - v40 := v39.Get() - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("concat")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) - } - v43 := v42.Get() - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("list")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) - } - v46 := v45.Get() - v47 := lang.Apply(v46, []any{lang.NewSymbol("glojure.core/extend-type")}) - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("list")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v32}) - v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v53 := v52.FindInternedVar(lang.NewSymbol("list")) - if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) - } - v54 := v53.Get() - v55 := lang.Apply(v54, []any{v3}) - v56 := lang.Apply(v43, []any{v47, v51, v55, v37}) - v57 := lang.Apply(v40, []any{v56}) - v26 = v57 + tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp39 := tmp38.FindInternedVar(lang.NewSymbol("seq")) + if tmp39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) + } + tmp40 := tmp39.Get() + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("concat")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) + } + tmp46 := tmp45.Get() + tmp47 := lang.Apply(tmp46, []any{lang.NewSymbol("glojure.core/extend-type")}) + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v32}) + tmp52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp53 := tmp52.FindInternedVar(lang.NewSymbol("list")) + if tmp53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp53))) + } + tmp54 := tmp53.Get() + tmp55 := lang.Apply(tmp54, []any{v3}) + tmp56 := lang.Apply(tmp43, []any{tmp47, tmp51, tmp55, v37}) + tmp57 := lang.Apply(tmp40, []any{tmp56}) + tmp26 = tmp57 } // end let - return v26 + return tmp26 }) - v25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(208), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(209), lang.NewKeyword("end-column"), int(42)) - v26, err := lang.WithMeta(v24, v25.(lang.IPersistentMap)) + tmp25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(208), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(209), lang.NewKeyword("end-column"), int(42)) + tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) if err != nil { panic(err) } - v27 := lang.Apply(v23, []any{v26, v10}) - v28 := lang.Apply(v16, []any{v20, v27}) - v29 := lang.Apply(v13, []any{v28}) - v5 = v29 + tmp27 := lang.Apply(tmp23, []any{tmp26, v10}) + tmp28 := lang.Apply(tmp16, []any{tmp20, tmp27}) + tmp29 := lang.Apply(tmp13, []any{tmp28}) + tmp5 = tmp29 } // end let - return v5 + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // emit-extend-type { - v0 := lang.NewSymbol("emit-extend-type").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(175), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(175), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"), lang.NewSymbol("specs"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("emit-extend-type").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(175), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(175), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"), lang.NewSymbol("specs"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -31486,81 +31579,81 @@ func init() { _ = v3 v4 := args[1] _ = v4 - var v5 any + var tmp5 any { // let // let binding "impls" - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("parse-impls")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{v4}) - var v10 any = v9 + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("parse-impls")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.Apply(tmp8, []any{v4}) + var v10 any = tmp9 _ = v10 - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("seq")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("concat")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("list")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.Apply(v19, []any{lang.NewSymbol("glojure.core/extend")}) - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("list")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.Apply(v23, []any{v3}) - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("mapcat")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("partial")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("emit-hinted-impl")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v30, []any{v33, v3}) - v35 := lang.Apply(v27, []any{v34, v10}) - v36 := lang.Apply(v16, []any{v20, v24, v35}) - v37 := lang.Apply(v13, []any{v36}) - v5 = v37 + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("seq")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("concat")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("list")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.Apply(tmp19, []any{lang.NewSymbol("glojure.core/extend")}) + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("list")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.Apply(tmp23, []any{v3}) + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("mapcat")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("partial")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("emit-hinted-impl")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp30, []any{tmp33, v3}) + tmp35 := lang.Apply(tmp27, []any{tmp34, v10}) + tmp36 := lang.Apply(tmp16, []any{tmp20, tmp24, tmp35}) + tmp37 := lang.Apply(tmp13, []any{tmp36}) + tmp5 = tmp37 } // end let - return v5 + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // emit-hinted-impl { - v0 := lang.NewSymbol("emit-hinted-impl").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(163), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(163), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"), lang.NewVector(lang.NewSymbol("p"), lang.NewSymbol("fs")))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("emit-hinted-impl").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(163), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(163), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"), lang.NewVector(lang.NewSymbol("p"), lang.NewSymbol("fs")))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -31568,153 +31661,153 @@ func init() { _ = v3 v4 := args[1] _ = v4 - var v5 any + var tmp5 any { // let // let binding "vec__281" var v6 any = v4 _ = v6 // let binding "p" - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("nth")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v9, []any{v6, int64(0), nil}) - var v11 any = v10 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("nth")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp9, []any{v6, int64(0), nil}) + var v11 any = tmp10 _ = v11 // let binding "fs" - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("nth")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.Apply(v14, []any{v6, int64(1), nil}) - var v16 any = v15 + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("nth")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.Apply(tmp14, []any{v6, int64(1), nil}) + var v16 any = tmp15 _ = v16 - var v17 any + var tmp17 any { // let // let binding "hint" - var v18 lang.FnFunc - v18 = lang.NewFnFunc(func(args ...any) any { + var tmp18 lang.FnFunc + tmp18 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v19 := args[0] _ = v19 - var v20 any + var tmp20 any { // let // let binding "specs" - var v21 any - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("vector?")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("first")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.Apply(v27, []any{v19}) - v29 := lang.Apply(v24, []any{v28}) - if lang.IsTruthy(v29) { - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("list")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + var tmp21 any + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("vector?")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("first")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.Apply(tmp27, []any{v19}) + tmp29 := lang.Apply(tmp24, []any{tmp28}) + if lang.IsTruthy(tmp29) { + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("list")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) } - v32 := v31.Get() - v33 := lang.Apply(v32, []any{v19}) - v21 = v33 + tmp32 := tmp31.Get() + tmp33 := lang.Apply(tmp32, []any{v19}) + tmp21 = tmp33 } else { - v21 = v19 + tmp21 = v19 } - var v34 any = v21 + var v34 any = tmp21 _ = v34 - v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v36 := v35.FindInternedVar(lang.NewSymbol("map")) - if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) - } - v37 := v36.Get() - var v38 lang.FnFunc - v38 = lang.NewFnFunc(func(args ...any) any { + tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp36 := tmp35.FindInternedVar(lang.NewSymbol("map")) + if tmp36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) + } + tmp37 := tmp36.Get() + var tmp38 lang.FnFunc + tmp38 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v39 := args[0] _ = v39 - var v40 any + var tmp40 any { // let // let binding "vec__285" var v41 any = v39 _ = v41 // let binding "seq__286" - v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v43 := v42.FindInternedVar(lang.NewSymbol("seq")) - if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) + tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp43 := tmp42.FindInternedVar(lang.NewSymbol("seq")) + if tmp43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) } - v44 := v43.Get() - v45 := lang.Apply(v44, []any{v41}) - var v46 any = v45 + tmp44 := tmp43.Get() + tmp45 := lang.Apply(tmp44, []any{v41}) + var v46 any = tmp45 _ = v46 // let binding "first__287" - v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v48 := v47.FindInternedVar(lang.NewSymbol("first")) - if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) + tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp48 := tmp47.FindInternedVar(lang.NewSymbol("first")) + if tmp48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) } - v49 := v48.Get() - v50 := lang.Apply(v49, []any{v46}) - var v51 any = v50 + tmp49 := tmp48.Get() + tmp50 := lang.Apply(tmp49, []any{v46}) + var v51 any = tmp50 _ = v51 // let binding "seq__286" - v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v53 := v52.FindInternedVar(lang.NewSymbol("next")) - if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) + tmp52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp53 := tmp52.FindInternedVar(lang.NewSymbol("next")) + if tmp53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp53))) } - v54 := v53.Get() - v55 := lang.Apply(v54, []any{v46}) - var v56 any = v55 + tmp54 := tmp53.Get() + tmp55 := lang.Apply(tmp54, []any{v46}) + var v56 any = tmp55 _ = v56 // let binding "vec__288" var v57 any = v51 _ = v57 // let binding "seq__289" - v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v59 := v58.FindInternedVar(lang.NewSymbol("seq")) - if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) + tmp58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp59 := tmp58.FindInternedVar(lang.NewSymbol("seq")) + if tmp59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp59))) } - v60 := v59.Get() - v61 := lang.Apply(v60, []any{v57}) - var v62 any = v61 + tmp60 := tmp59.Get() + tmp61 := lang.Apply(tmp60, []any{v57}) + var v62 any = tmp61 _ = v62 // let binding "first__290" - v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v64 := v63.FindInternedVar(lang.NewSymbol("first")) - if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) + tmp63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp64 := tmp63.FindInternedVar(lang.NewSymbol("first")) + if tmp64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp64))) } - v65 := v64.Get() - v66 := lang.Apply(v65, []any{v62}) - var v67 any = v66 + tmp65 := tmp64.Get() + tmp66 := lang.Apply(tmp65, []any{v62}) + var v67 any = tmp66 _ = v67 // let binding "seq__289" - v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v69 := v68.FindInternedVar(lang.NewSymbol("next")) - if v69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) + tmp68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp69 := tmp68.FindInternedVar(lang.NewSymbol("next")) + if tmp69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp69))) } - v70 := v69.Get() - v71 := lang.Apply(v70, []any{v62}) - var v72 any = v71 + tmp70 := tmp69.Get() + tmp71 := lang.Apply(tmp70, []any{v62}) + var v72 any = tmp71 _ = v72 // let binding "target" var v73 any = v67 @@ -31725,540 +31818,541 @@ func init() { // let binding "body" var v75 any = v56 _ = v75 - v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v77 := v76.FindInternedVar(lang.NewSymbol("cons")) - if v77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) + tmp76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp77 := tmp76.FindInternedVar(lang.NewSymbol("cons")) + if tmp77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp77))) } - v78 := v77.Get() - v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v80 := v79.FindInternedVar(lang.NewSymbol("apply")) - if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) + tmp78 := tmp77.Get() + tmp79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp80 := tmp79.FindInternedVar(lang.NewSymbol("apply")) + if tmp80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp80))) } - v81 := v80.Get() - v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v83 := v82.FindInternedVar(lang.NewSymbol("vector")) - if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) + tmp81 := tmp80.Get() + tmp82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp83 := tmp82.FindInternedVar(lang.NewSymbol("vector")) + if tmp83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp83))) } - v84 := v83.Get() - v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v86 := v85.FindInternedVar(lang.NewSymbol("vary-meta")) - if v86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) + tmp84 := tmp83.Get() + tmp85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp86 := tmp85.FindInternedVar(lang.NewSymbol("vary-meta")) + if tmp86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp86))) } - v87 := v86.Get() - v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v89 := v88.FindInternedVar(lang.NewSymbol("assoc")) - if v89.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) + tmp87 := tmp86.Get() + tmp88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp89 := tmp88.FindInternedVar(lang.NewSymbol("assoc")) + if tmp89.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp89))) } - v90 := v89.Get() - v91 := lang.Apply(v87, []any{v73, v90, lang.NewKeyword("tag"), v3}) - v92 := lang.Apply(v81, []any{v84, v91, v74}) - v93 := lang.Apply(v78, []any{v92, v75}) - v40 = v93 + tmp90 := tmp89.Get() + tmp91 := lang.Apply(tmp87, []any{v73, tmp90, lang.NewKeyword("tag"), v3}) + tmp92 := lang.Apply(tmp81, []any{tmp84, tmp91, v74}) + tmp93 := lang.Apply(tmp78, []any{tmp92, v75}) + tmp40 = tmp93 } // end let - return v40 + return tmp40 }) - v39 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(168), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(170), lang.NewKeyword("end-column"), int(36)) - v40, err := lang.WithMeta(v38, v39.(lang.IPersistentMap)) + tmp39 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(168), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(170), lang.NewKeyword("end-column"), int(36)) + tmp40, err := lang.WithMeta(tmp38, tmp39.(lang.IPersistentMap)) if err != nil { panic(err) } - v41 := lang.Apply(v37, []any{v40, v34}) - v20 = v41 + tmp41 := lang.Apply(tmp37, []any{tmp40, v34}) + tmp20 = tmp41 } // end let - return v20 + return tmp20 }) - v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(164), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(171), lang.NewKeyword("end-column"), int(30)) - v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) + tmp19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(164), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(171), lang.NewKeyword("end-column"), int(30)) + tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) if err != nil { panic(err) } - var v21 any = v20 + var v21 any = tmp20 _ = v21 - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("zipmap")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("map")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - var v28 lang.FnFunc - v28 = lang.NewFnFunc(func(args ...any) any { + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("zipmap")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("map")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + var tmp28 lang.FnFunc + tmp28 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v29 := args[0] _ = v29 - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("keyword")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) - } - v32 := v31.Get() - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("name")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("first")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.Apply(v38, []any{v29}) - v40 := lang.Apply(v35, []any{v39}) - v41 := lang.Apply(v32, []any{v40}) - return v41 + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("keyword")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) + } + tmp32 := tmp31.Get() + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("name")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) + } + tmp35 := tmp34.Get() + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("first")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{v29}) + tmp40 := lang.Apply(tmp35, []any{tmp39}) + tmp41 := lang.Apply(tmp32, []any{tmp40}) + return tmp41 }) - v29 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(172), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(172), lang.NewKeyword("end-column"), int(46)) - v30, err := lang.WithMeta(v28, v29.(lang.IPersistentMap)) + tmp29 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(172), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(172), lang.NewKeyword("end-column"), int(46)) + tmp30, err := lang.WithMeta(tmp28, tmp29.(lang.IPersistentMap)) if err != nil { panic(err) } - v31 := lang.Apply(v27, []any{v30, v16}) - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("map")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + tmp31 := lang.Apply(tmp27, []any{tmp30, v16}) + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("map")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) } - v34 := v33.Get() - var v35 lang.FnFunc - v35 = lang.NewFnFunc(func(args ...any) any { + tmp34 := tmp33.Get() + var tmp35 lang.FnFunc + tmp35 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v36 := args[0] _ = v36 - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("cons")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("drop")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) - } - v42 := v41.Get() - v43 := lang.Apply(v42, []any{int64(1), v36}) - v44 := lang.Apply(v21, []any{v43}) - v45 := lang.Apply(v39, []any{lang.NewSymbol("glojure.core/fn"), v44}) - return v45 + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("cons")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("drop")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) + } + tmp42 := tmp41.Get() + tmp43 := lang.Apply(tmp42, []any{int64(1), v36}) + tmp44 := lang.Apply(v21, []any{tmp43}) + tmp45 := lang.Apply(tmp39, []any{lang.NewSymbol("glojure.core/fn"), tmp44}) + return tmp45 }) - v36 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(173), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(173), lang.NewKeyword("end-column"), int(49)) - v37, err := lang.WithMeta(v35, v36.(lang.IPersistentMap)) + tmp36 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(173), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(173), lang.NewKeyword("end-column"), int(49)) + tmp37, err := lang.WithMeta(tmp35, tmp36.(lang.IPersistentMap)) if err != nil { panic(err) } - v38 := lang.Apply(v34, []any{v37, v16}) - v39 := lang.Apply(v24, []any{v31, v38}) - v40 := lang.NewVector(v11, v39) - v41 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(172), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(173), lang.NewKeyword("end-column"), int(55)) - v42, err := lang.WithMeta(v40, v41.(lang.IPersistentMap)) + tmp38 := lang.Apply(tmp34, []any{tmp37, v16}) + tmp39 := lang.Apply(tmp24, []any{tmp31, tmp38}) + tmp40 := lang.NewVector(v11, tmp39) + tmp41 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(172), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(173), lang.NewKeyword("end-column"), int(55)) + tmp42, err := lang.WithMeta(tmp40, tmp41.(lang.IPersistentMap)) if err != nil { panic(err) } - v17 = v42 + tmp17 = tmp42 } // end let - v5 = v17 + tmp5 = tmp17 } // end let - return v5 + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // empty { - v0 := lang.NewSymbol("empty").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns an empty collection of the same category as coll, or nil", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5265), lang.NewKeyword("end-line"), int(5265))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("empty").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns an empty collection of the same category as coll, or nil", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5265), lang.NewKeyword("end-line"), int(5265))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{lang.IPersistentCollection, v3}) - if lang.IsTruthy(v8) { - v9, ok := lang.FieldOrMethod(v3, "empty") + var tmp4 any + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("instance?")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := reflect.TypeOf((*lang.IPersistentCollection)(nil)).Elem() + tmp9 := lang.Apply(tmp7, []any{tmp8, v3}) + if lang.IsTruthy(tmp9) { + tmp10, ok := lang.FieldOrMethod(v3, "empty") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "empty"))) } - var v10 any - switch reflect.TypeOf(v9).Kind() { + var tmp11 any + switch reflect.TypeOf(tmp10).Kind() { case reflect.Func: - v10 = lang.Apply(v9, nil) + tmp11 = lang.Apply(tmp10, nil) default: - v10 = v9 + tmp11 = tmp10 } - v4 = v10 + tmp4 = tmp11 } else { - v4 = nil } - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // empty? { - v0 := lang.NewSymbol("empty?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll has no items. To check the emptiness of a seq,\n please use the idiom (seq x) rather than (not (empty? x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6247), lang.NewKeyword("end-line"), int(6247))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("empty?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll has no items. To check the emptiness of a seq,\n please use the idiom (seq x) rather than (not (empty? x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6247), lang.NewKeyword("end-line"), int(6247))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("counted?")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v3}) - if lang.IsTruthy(v8) { - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("zero?")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("count")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.Apply(v14, []any{v3}) - v16 := lang.Apply(v11, []any{v15}) - v4 = v16 + var tmp4 any + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("counted?")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v3}) + if lang.IsTruthy(tmp8) { + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("zero?")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("count")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.Apply(tmp14, []any{v3}) + tmp16 := lang.Apply(tmp11, []any{tmp15}) + tmp4 = tmp16 } else { - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("not")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("not")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) } - v19 := v18.Get() - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("seq")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + tmp19 := tmp18.Get() + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("seq")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) } - v22 := v21.Get() - v23 := lang.Apply(v22, []any{v3}) - v24 := lang.Apply(v19, []any{v23}) - v4 = v24 + tmp22 := tmp21.Get() + tmp23 := lang.Apply(tmp22, []any{v3}) + tmp24 := lang.Apply(tmp19, []any{tmp23}) + tmp4 = tmp24 } - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // ensure { - v0 := lang.NewSymbol("ensure").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref"))), lang.NewKeyword("doc"), "Must be called in a transaction. Protects the ref from modification\n by other transactions. Returns the in-transaction-value of\n ref. Allows for more concurrency than (ref-set ref @ref)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2480), lang.NewKeyword("end-line"), int(2480))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("ensure").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref"))), lang.NewKeyword("doc"), "Must be called in a transaction. Protects the ref from modification\n by other transactions. Returns the in-transaction-value of\n ref. Allows for more concurrency than (ref-set ref @ref)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2480), lang.NewKeyword("end-line"), int(2480))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4, _ := lang.FieldOrMethod(v3, "touch") - if reflect.TypeOf(v4).Kind() != reflect.Func { + tmp4, _ := lang.FieldOrMethod(v3, "touch") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("touch is not a function"))) } - v5 := lang.Apply(v4, []any{}) - _ = v5 - v6, _ := lang.FieldOrMethod(v3, "deref") - if reflect.TypeOf(v6).Kind() != reflect.Func { + tmp5 := lang.Apply(tmp4, []any{}) + _ = tmp5 + tmp6, _ := lang.FieldOrMethod(v3, "deref") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("deref is not a function"))) } - v7 := lang.Apply(v6, []any{}) - return v7 + tmp7 := lang.Apply(tmp6, []any{}) + return tmp7 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // ensure-reduced { - v0 := lang.NewSymbol("ensure-reduced").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "If x is already reduced?, returns it, else returns (reduced x)", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2841), lang.NewKeyword("end-line"), int(2841))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("ensure-reduced").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "If x is already reduced?, returns it, else returns (reduced x)", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2841), lang.NewKeyword("end-line"), int(2841))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("reduced?")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v3}) - if lang.IsTruthy(v8) { - v4 = v3 + var tmp4 any + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("reduced?")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v3}) + if lang.IsTruthy(tmp8) { + tmp4 = v3 } else { - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("reduced")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("reduced")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) } - v11 := v10.Get() - v12 := lang.Apply(v11, []any{v3}) - v4 = v12 + tmp11 := tmp10.Get() + tmp12 := lang.Apply(tmp11, []any{v3}) + tmp4 = tmp12 } - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // enumeration-seq { - v0 := lang.NewSymbol("enumeration-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("e"))), lang.NewKeyword("doc"), "Returns a seq on a java.util.Enumeration", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5710), lang.NewKeyword("end-line"), int(5710))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("enumeration-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("e"))), lang.NewKeyword("doc"), "Returns a seq on a java.util.Enumeration", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5710), lang.NewKeyword("end-line"), int(5710))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.Apply(nil, []any{v3}) - return v4 + tmp4 := lang.Apply(nil, []any{v3}) + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // error-handler { - v0 := lang.NewSymbol("error-handler").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("doc"), "Returns the error-handler of agent a, or nil if there is none.\n See set-error-handler!", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2202), lang.NewKeyword("end-line"), int(2202))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("error-handler").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("doc"), "Returns the error-handler of agent a, or nil if there is none.\n See set-error-handler!", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2202), lang.NewKeyword("end-line"), int(2202))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4, ok := lang.FieldOrMethod(v3, "getErrorHandler") + tmp4, ok := lang.FieldOrMethod(v3, "getErrorHandler") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getErrorHandler"))) } - var v5 any - switch reflect.TypeOf(v4).Kind() { + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { case reflect.Func: - v5 = lang.Apply(v4, nil) + tmp5 = lang.Apply(tmp4, nil) default: - v5 = v4 + tmp5 = tmp4 } - return v5 + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // error-mode { - v0 := lang.NewSymbol("error-mode").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("doc"), "Returns the error-mode of agent a. See set-error-mode!", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2227), lang.NewKeyword("end-line"), int(2227))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("error-mode").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("doc"), "Returns the error-mode of agent a. See set-error-mode!", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2227), lang.NewKeyword("end-line"), int(2227))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4, ok := lang.FieldOrMethod(v3, "getErrorMode") + tmp4, ok := lang.FieldOrMethod(v3, "getErrorMode") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getErrorMode"))) } - var v5 any - switch reflect.TypeOf(v4).Kind() { + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { case reflect.Func: - v5 = lang.Apply(v4, nil) + tmp5 = lang.Apply(tmp4, nil) default: - v5 = v4 + tmp5 = tmp4 } - return v5 + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // eval { - v0 := lang.NewSymbol("eval").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("form"))), lang.NewKeyword("doc"), "Evaluates the form data structure (not text!) and returns the result.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3203), lang.NewKeyword("end-line"), int(3203))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("eval").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("form"))), lang.NewKeyword("doc"), "Evaluates the form data structure (not text!) and returns the result.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3203), lang.NewKeyword("end-line"), int(3203))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4, _ := lang.FieldOrMethod(runtime4.Compiler, "Eval") - if reflect.TypeOf(v4).Kind() != reflect.Func { + tmp4, _ := lang.FieldOrMethod(runtime4.Compiler, "Eval") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Eval is not a function"))) } - v5 := lang.Apply(v4, []any{v3}) - return v5 + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // even? { - v0 := lang.NewSymbol("even?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is even, throws an exception if n is not an integer", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1381), lang.NewKeyword("end-line"), int(1381))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("even?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is even, throws an exception if n is not an integer", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1381), lang.NewKeyword("end-line"), int(1381))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("integer?")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v3}) - if lang.IsTruthy(v8) { - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("zero?")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("bit-and")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.Apply(lang.UncheckedLongCast, []any{v3}) - v16 := lang.Apply(v14, []any{v15, int64(1)}) - v17 := lang.Apply(v11, []any{v16}) - v4 = v17 + var tmp4 any + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("integer?")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v3}) + if lang.IsTruthy(tmp8) { + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("zero?")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("bit-and")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.Apply(lang.UncheckedLongCast, []any{v3}) + tmp16 := lang.Apply(tmp14, []any{tmp15, int64(1)}) + tmp17 := lang.Apply(tmp11, []any{tmp16}) + tmp4 = tmp17 } else { - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("str")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("str")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) } - v20 := v19.Get() - v21 := lang.Apply(v20, []any{"Argument must be an integer: ", v3}) - v22 := lang.Apply(lang.NewIllegalArgumentError, []any{v21}) - panic(v22) + tmp20 := tmp19.Get() + tmp21 := lang.Apply(tmp20, []any{"Argument must be an integer: ", v3}) + tmp22 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp21}) + panic(tmp22) } - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // every-pred { - v0 := lang.NewSymbol("every-pred").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("p")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2"), lang.NewSymbol("p3")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2"), lang.NewSymbol("p3"), lang.NewSymbol("&"), lang.NewSymbol("ps"))), lang.NewKeyword("doc"), "Takes a set of predicates and returns a function f that returns true if all of its\n composing predicates return a logical true value against all of its arguments, else it returns\n false. Note that f is short-circuiting in that it will stop execution on the first\n argument that triggers a logical false result against the original predicates.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7422), lang.NewKeyword("end-line"), int(7422))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("every-pred").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("p")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2"), lang.NewSymbol("p3")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2"), lang.NewSymbol("p3"), lang.NewSymbol("&"), lang.NewSymbol("ps"))), lang.NewKeyword("doc"), "Takes a set of predicates and returns a function f that returns true if all of its\n composing predicates return a logical true value against all of its arguments, else it returns\n false. Note that f is short-circuiting in that it will stop execution on the first\n argument that triggers a logical false result against the original predicates.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7422), lang.NewKeyword("end-line"), int(7422))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - var v4 lang.FnFunc + var tmp4 lang.FnFunc { // function ep1 - v4 = lang.NewFnFunc(func(args ...any) any { + var v5 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: return true case 1: v6 := args[0] _ = v6 - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("boolean")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v3, []any{v6}) - v11 := lang.Apply(v9, []any{v10}) - return v11 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("boolean")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(v3, []any{v6}) + tmp11 := lang.Apply(tmp9, []any{tmp10}) + return tmp11 case 2: v6 := args[0] _ = v6 v7 := args[1] _ = v7 - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("boolean")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("boolean")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) } - v10 := v9.Get() - var v11 any + tmp10 := tmp9.Get() + var tmp11 any { // let // let binding "and__0__auto__" - v12 := lang.Apply(v3, []any{v6}) - var v13 any = v12 + tmp12 := lang.Apply(v3, []any{v6}) + var v13 any = tmp12 _ = v13 - var v14 any + var tmp14 any if lang.IsTruthy(v13) { - v15 := lang.Apply(v3, []any{v7}) - v14 = v15 + tmp15 := lang.Apply(v3, []any{v7}) + tmp14 = tmp15 } else { - v14 = v13 + tmp14 = v13 } - v11 = v14 + tmp11 = tmp14 } // end let - v12 := lang.Apply(v10, []any{v11}) - return v12 + tmp12 := lang.Apply(tmp10, []any{tmp11}) + return tmp12 case 3: v6 := args[0] _ = v6 @@ -32266,43 +32360,43 @@ func init() { _ = v7 v8 := args[2] _ = v8 - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("boolean")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("boolean")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) } - v11 := v10.Get() - var v12 any + tmp11 := tmp10.Get() + var tmp12 any { // let // let binding "and__0__auto__" - v13 := lang.Apply(v3, []any{v6}) - var v14 any = v13 + tmp13 := lang.Apply(v3, []any{v6}) + var v14 any = tmp13 _ = v14 - var v15 any + var tmp15 any if lang.IsTruthy(v14) { - var v16 any + var tmp16 any { // let // let binding "and__0__auto__" - v17 := lang.Apply(v3, []any{v7}) - var v18 any = v17 + tmp17 := lang.Apply(v3, []any{v7}) + var v18 any = tmp17 _ = v18 - var v19 any + var tmp19 any if lang.IsTruthy(v18) { - v20 := lang.Apply(v3, []any{v8}) - v19 = v20 + tmp20 := lang.Apply(v3, []any{v8}) + tmp19 = tmp20 } else { - v19 = v18 + tmp19 = v18 } - v16 = v19 + tmp16 = tmp19 } // end let - v15 = v16 + tmp15 = tmp16 } else { - v15 = v14 + tmp15 = v14 } - v12 = v15 + tmp12 = tmp15 } // end let - v13 := lang.Apply(v11, []any{v12}) - return v13 + tmp13 := lang.Apply(tmp11, []any{tmp12}) + return tmp13 default: if len(args) < 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -32313,140 +32407,142 @@ func init() { _ = v7 v8 := args[2] _ = v8 - v9 := lang.NewList(args[3:]...) - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("boolean")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - var v13 any + var v9 any = lang.NewList(args[3:]...) + _ = v9 + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("boolean")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + var tmp13 any { // let // let binding "and__0__auto__" - v14 := lang.Apply(v5, []any{v6, v7, v8}) - var v15 any = v14 + tmp14 := lang.Apply(v5, []any{v6, v7, v8}) + var v15 any = tmp14 _ = v15 - var v16 any + var tmp16 any if lang.IsTruthy(v15) { - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("every?")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("every?")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) } - v19 := v18.Get() - v20 := lang.Apply(v19, []any{v3, v9}) - v16 = v20 + tmp19 := tmp18.Get() + tmp20 := lang.Apply(tmp19, []any{v3, v9}) + tmp16 = tmp20 } else { - v16 = v15 + tmp16 = v15 } - v13 = v16 + tmp13 = tmp16 } // end let - v14 := lang.Apply(v12, []any{v13}) - return v14 + tmp14 := lang.Apply(tmp12, []any{tmp13}) + return tmp14 } }) - v5 := v4 + v5 = tmp4 _ = v5 } - v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7429), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7435), lang.NewKeyword("end-column"), int(56)) - v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) + tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7429), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7435), lang.NewKeyword("end-column"), int(56)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) if err != nil { panic(err) } - return v6 + return tmp6 case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - var v5 lang.FnFunc + var tmp5 lang.FnFunc { // function ep2 - v5 = lang.NewFnFunc(func(args ...any) any { + var v6 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: return true case 1: v7 := args[0] _ = v7 - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("boolean")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("boolean")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) } - v10 := v9.Get() - var v11 any + tmp10 := tmp9.Get() + var tmp11 any { // let // let binding "and__0__auto__" - v12 := lang.Apply(v3, []any{v7}) - var v13 any = v12 + tmp12 := lang.Apply(v3, []any{v7}) + var v13 any = tmp12 _ = v13 - var v14 any + var tmp14 any if lang.IsTruthy(v13) { - v15 := lang.Apply(v4, []any{v7}) - v14 = v15 + tmp15 := lang.Apply(v4, []any{v7}) + tmp14 = tmp15 } else { - v14 = v13 + tmp14 = v13 } - v11 = v14 + tmp11 = tmp14 } // end let - v12 := lang.Apply(v10, []any{v11}) - return v12 + tmp12 := lang.Apply(tmp10, []any{tmp11}) + return tmp12 case 2: v7 := args[0] _ = v7 v8 := args[1] _ = v8 - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("boolean")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("boolean")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) } - v11 := v10.Get() - var v12 any + tmp11 := tmp10.Get() + var tmp12 any { // let // let binding "and__0__auto__" - v13 := lang.Apply(v3, []any{v7}) - var v14 any = v13 + tmp13 := lang.Apply(v3, []any{v7}) + var v14 any = tmp13 _ = v14 - var v15 any + var tmp15 any if lang.IsTruthy(v14) { - var v16 any + var tmp16 any { // let // let binding "and__0__auto__" - v17 := lang.Apply(v3, []any{v8}) - var v18 any = v17 + tmp17 := lang.Apply(v3, []any{v8}) + var v18 any = tmp17 _ = v18 - var v19 any + var tmp19 any if lang.IsTruthy(v18) { - var v20 any + var tmp20 any { // let // let binding "and__0__auto__" - v21 := lang.Apply(v4, []any{v7}) - var v22 any = v21 + tmp21 := lang.Apply(v4, []any{v7}) + var v22 any = tmp21 _ = v22 - var v23 any + var tmp23 any if lang.IsTruthy(v22) { - v24 := lang.Apply(v4, []any{v8}) - v23 = v24 + tmp24 := lang.Apply(v4, []any{v8}) + tmp23 = tmp24 } else { - v23 = v22 + tmp23 = v22 } - v20 = v23 + tmp20 = tmp23 } // end let - v19 = v20 + tmp19 = tmp20 } else { - v19 = v18 + tmp19 = v18 } - v16 = v19 + tmp16 = tmp19 } // end let - v15 = v16 + tmp15 = tmp16 } else { - v15 = v14 + tmp15 = v14 } - v12 = v15 + tmp12 = tmp15 } // end let - v13 := lang.Apply(v11, []any{v12}) - return v13 + tmp13 := lang.Apply(tmp11, []any{tmp12}) + return tmp13 case 3: v7 := args[0] _ = v7 @@ -32454,85 +32550,85 @@ func init() { _ = v8 v9 := args[2] _ = v9 - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("boolean")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("boolean")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) } - v12 := v11.Get() - var v13 any + tmp12 := tmp11.Get() + var tmp13 any { // let // let binding "and__0__auto__" - v14 := lang.Apply(v3, []any{v7}) - var v15 any = v14 + tmp14 := lang.Apply(v3, []any{v7}) + var v15 any = tmp14 _ = v15 - var v16 any + var tmp16 any if lang.IsTruthy(v15) { - var v17 any + var tmp17 any { // let // let binding "and__0__auto__" - v18 := lang.Apply(v3, []any{v8}) - var v19 any = v18 + tmp18 := lang.Apply(v3, []any{v8}) + var v19 any = tmp18 _ = v19 - var v20 any + var tmp20 any if lang.IsTruthy(v19) { - var v21 any + var tmp21 any { // let // let binding "and__0__auto__" - v22 := lang.Apply(v3, []any{v9}) - var v23 any = v22 + tmp22 := lang.Apply(v3, []any{v9}) + var v23 any = tmp22 _ = v23 - var v24 any + var tmp24 any if lang.IsTruthy(v23) { - var v25 any + var tmp25 any { // let // let binding "and__0__auto__" - v26 := lang.Apply(v4, []any{v7}) - var v27 any = v26 + tmp26 := lang.Apply(v4, []any{v7}) + var v27 any = tmp26 _ = v27 - var v28 any + var tmp28 any if lang.IsTruthy(v27) { - var v29 any + var tmp29 any { // let // let binding "and__0__auto__" - v30 := lang.Apply(v4, []any{v8}) - var v31 any = v30 + tmp30 := lang.Apply(v4, []any{v8}) + var v31 any = tmp30 _ = v31 - var v32 any + var tmp32 any if lang.IsTruthy(v31) { - v33 := lang.Apply(v4, []any{v9}) - v32 = v33 + tmp33 := lang.Apply(v4, []any{v9}) + tmp32 = tmp33 } else { - v32 = v31 + tmp32 = v31 } - v29 = v32 + tmp29 = tmp32 } // end let - v28 = v29 + tmp28 = tmp29 } else { - v28 = v27 + tmp28 = v27 } - v25 = v28 + tmp25 = tmp28 } // end let - v24 = v25 + tmp24 = tmp25 } else { - v24 = v23 + tmp24 = v23 } - v21 = v24 + tmp21 = tmp24 } // end let - v20 = v21 + tmp20 = tmp21 } else { - v20 = v19 + tmp20 = v19 } - v17 = v20 + tmp17 = tmp20 } // end let - v16 = v17 + tmp16 = tmp17 } else { - v16 = v15 + tmp16 = v15 } - v13 = v16 + tmp13 = tmp16 } // end let - v14 := lang.Apply(v12, []any{v13}) - return v14 + tmp14 := lang.Apply(tmp12, []any{tmp13}) + return tmp14 default: if len(args) < 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -32543,76 +32639,77 @@ func init() { _ = v8 v9 := args[2] _ = v9 - v10 := lang.NewList(args[3:]...) - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("boolean")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - var v14 any + var v10 any = lang.NewList(args[3:]...) + _ = v10 + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("boolean")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + var tmp14 any { // let // let binding "and__0__auto__" - v15 := lang.Apply(v6, []any{v7, v8, v9}) - var v16 any = v15 + tmp15 := lang.Apply(v6, []any{v7, v8, v9}) + var v16 any = tmp15 _ = v16 - var v17 any + var tmp17 any if lang.IsTruthy(v16) { - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("every?")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("every?")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) } - v20 := v19.Get() - var v21 lang.FnFunc - v21 = lang.NewFnFunc(func(args ...any) any { + tmp20 := tmp19.Get() + var tmp21 lang.FnFunc + tmp21 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v22 := args[0] _ = v22 - var v23 any + var tmp23 any { // let // let binding "and__0__auto__" - v24 := lang.Apply(v3, []any{v22}) - var v25 any = v24 + tmp24 := lang.Apply(v3, []any{v22}) + var v25 any = tmp24 _ = v25 - var v26 any + var tmp26 any if lang.IsTruthy(v25) { - v27 := lang.Apply(v4, []any{v22}) - v26 = v27 + tmp27 := lang.Apply(v4, []any{v22}) + tmp26 = tmp27 } else { - v26 = v25 + tmp26 = v25 } - v23 = v26 + tmp23 = tmp26 } // end let - return v23 + return tmp23 }) - v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7443), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(7443), lang.NewKeyword("end-column"), int(65)) - v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) + tmp22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7443), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(7443), lang.NewKeyword("end-column"), int(65)) + tmp23, err := lang.WithMeta(tmp21, tmp22.(lang.IPersistentMap)) if err != nil { panic(err) } - v24 := lang.Apply(v20, []any{v23, v10}) - v17 = v24 + tmp24 := lang.Apply(tmp20, []any{tmp23, v10}) + tmp17 = tmp24 } else { - v17 = v16 + tmp17 = v16 } - v14 = v17 + tmp14 = tmp17 } // end let - v15 := lang.Apply(v13, []any{v14}) - return v15 + tmp15 := lang.Apply(tmp13, []any{tmp14}) + return tmp15 } }) - v6 := v5 + v6 = tmp5 _ = v6 } - v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7437), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7443), lang.NewKeyword("end-column"), int(75)) - v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) + tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7437), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7443), lang.NewKeyword("end-column"), int(75)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) if err != nil { panic(err) } - return v7 + return tmp7 case 3: v3 := args[0] _ = v3 @@ -32620,136 +32717,137 @@ func init() { _ = v4 v5 := args[2] _ = v5 - var v6 lang.FnFunc + var tmp6 lang.FnFunc { // function ep3 - v6 = lang.NewFnFunc(func(args ...any) any { + var v7 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: return true case 1: v8 := args[0] _ = v8 - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("boolean")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("boolean")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) } - v11 := v10.Get() - var v12 any + tmp11 := tmp10.Get() + var tmp12 any { // let // let binding "and__0__auto__" - v13 := lang.Apply(v3, []any{v8}) - var v14 any = v13 + tmp13 := lang.Apply(v3, []any{v8}) + var v14 any = tmp13 _ = v14 - var v15 any + var tmp15 any if lang.IsTruthy(v14) { - var v16 any + var tmp16 any { // let // let binding "and__0__auto__" - v17 := lang.Apply(v4, []any{v8}) - var v18 any = v17 + tmp17 := lang.Apply(v4, []any{v8}) + var v18 any = tmp17 _ = v18 - var v19 any + var tmp19 any if lang.IsTruthy(v18) { - v20 := lang.Apply(v5, []any{v8}) - v19 = v20 + tmp20 := lang.Apply(v5, []any{v8}) + tmp19 = tmp20 } else { - v19 = v18 + tmp19 = v18 } - v16 = v19 + tmp16 = tmp19 } // end let - v15 = v16 + tmp15 = tmp16 } else { - v15 = v14 + tmp15 = v14 } - v12 = v15 + tmp12 = tmp15 } // end let - v13 := lang.Apply(v11, []any{v12}) - return v13 + tmp13 := lang.Apply(tmp11, []any{tmp12}) + return tmp13 case 2: v8 := args[0] _ = v8 v9 := args[1] _ = v9 - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("boolean")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("boolean")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) } - v12 := v11.Get() - var v13 any + tmp12 := tmp11.Get() + var tmp13 any { // let // let binding "and__0__auto__" - v14 := lang.Apply(v3, []any{v8}) - var v15 any = v14 + tmp14 := lang.Apply(v3, []any{v8}) + var v15 any = tmp14 _ = v15 - var v16 any + var tmp16 any if lang.IsTruthy(v15) { - var v17 any + var tmp17 any { // let // let binding "and__0__auto__" - v18 := lang.Apply(v3, []any{v9}) - var v19 any = v18 + tmp18 := lang.Apply(v3, []any{v9}) + var v19 any = tmp18 _ = v19 - var v20 any + var tmp20 any if lang.IsTruthy(v19) { - var v21 any + var tmp21 any { // let // let binding "and__0__auto__" - v22 := lang.Apply(v4, []any{v8}) - var v23 any = v22 + tmp22 := lang.Apply(v4, []any{v8}) + var v23 any = tmp22 _ = v23 - var v24 any + var tmp24 any if lang.IsTruthy(v23) { - var v25 any + var tmp25 any { // let // let binding "and__0__auto__" - v26 := lang.Apply(v4, []any{v9}) - var v27 any = v26 + tmp26 := lang.Apply(v4, []any{v9}) + var v27 any = tmp26 _ = v27 - var v28 any + var tmp28 any if lang.IsTruthy(v27) { - var v29 any + var tmp29 any { // let // let binding "and__0__auto__" - v30 := lang.Apply(v5, []any{v8}) - var v31 any = v30 + tmp30 := lang.Apply(v5, []any{v8}) + var v31 any = tmp30 _ = v31 - var v32 any + var tmp32 any if lang.IsTruthy(v31) { - v33 := lang.Apply(v5, []any{v9}) - v32 = v33 + tmp33 := lang.Apply(v5, []any{v9}) + tmp32 = tmp33 } else { - v32 = v31 + tmp32 = v31 } - v29 = v32 + tmp29 = tmp32 } // end let - v28 = v29 + tmp28 = tmp29 } else { - v28 = v27 + tmp28 = v27 } - v25 = v28 + tmp25 = tmp28 } // end let - v24 = v25 + tmp24 = tmp25 } else { - v24 = v23 + tmp24 = v23 } - v21 = v24 + tmp21 = tmp24 } // end let - v20 = v21 + tmp20 = tmp21 } else { - v20 = v19 + tmp20 = v19 } - v17 = v20 + tmp17 = tmp20 } // end let - v16 = v17 + tmp16 = tmp17 } else { - v16 = v15 + tmp16 = v15 } - v13 = v16 + tmp13 = tmp16 } // end let - v14 := lang.Apply(v12, []any{v13}) - return v14 + tmp14 := lang.Apply(tmp12, []any{tmp13}) + return tmp14 case 3: v8 := args[0] _ = v8 @@ -32757,127 +32855,127 @@ func init() { _ = v9 v10 := args[2] _ = v10 - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("boolean")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("boolean")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) } - v13 := v12.Get() - var v14 any + tmp13 := tmp12.Get() + var tmp14 any { // let // let binding "and__0__auto__" - v15 := lang.Apply(v3, []any{v8}) - var v16 any = v15 + tmp15 := lang.Apply(v3, []any{v8}) + var v16 any = tmp15 _ = v16 - var v17 any + var tmp17 any if lang.IsTruthy(v16) { - var v18 any + var tmp18 any { // let // let binding "and__0__auto__" - v19 := lang.Apply(v3, []any{v9}) - var v20 any = v19 + tmp19 := lang.Apply(v3, []any{v9}) + var v20 any = tmp19 _ = v20 - var v21 any + var tmp21 any if lang.IsTruthy(v20) { - var v22 any + var tmp22 any { // let // let binding "and__0__auto__" - v23 := lang.Apply(v3, []any{v10}) - var v24 any = v23 + tmp23 := lang.Apply(v3, []any{v10}) + var v24 any = tmp23 _ = v24 - var v25 any + var tmp25 any if lang.IsTruthy(v24) { - var v26 any + var tmp26 any { // let // let binding "and__0__auto__" - v27 := lang.Apply(v4, []any{v8}) - var v28 any = v27 + tmp27 := lang.Apply(v4, []any{v8}) + var v28 any = tmp27 _ = v28 - var v29 any + var tmp29 any if lang.IsTruthy(v28) { - var v30 any + var tmp30 any { // let // let binding "and__0__auto__" - v31 := lang.Apply(v4, []any{v9}) - var v32 any = v31 + tmp31 := lang.Apply(v4, []any{v9}) + var v32 any = tmp31 _ = v32 - var v33 any + var tmp33 any if lang.IsTruthy(v32) { - var v34 any + var tmp34 any { // let // let binding "and__0__auto__" - v35 := lang.Apply(v4, []any{v10}) - var v36 any = v35 + tmp35 := lang.Apply(v4, []any{v10}) + var v36 any = tmp35 _ = v36 - var v37 any + var tmp37 any if lang.IsTruthy(v36) { - var v38 any + var tmp38 any { // let // let binding "and__0__auto__" - v39 := lang.Apply(v5, []any{v8}) - var v40 any = v39 + tmp39 := lang.Apply(v5, []any{v8}) + var v40 any = tmp39 _ = v40 - var v41 any + var tmp41 any if lang.IsTruthy(v40) { - var v42 any + var tmp42 any { // let // let binding "and__0__auto__" - v43 := lang.Apply(v5, []any{v9}) - var v44 any = v43 + tmp43 := lang.Apply(v5, []any{v9}) + var v44 any = tmp43 _ = v44 - var v45 any + var tmp45 any if lang.IsTruthy(v44) { - v46 := lang.Apply(v5, []any{v10}) - v45 = v46 + tmp46 := lang.Apply(v5, []any{v10}) + tmp45 = tmp46 } else { - v45 = v44 + tmp45 = v44 } - v42 = v45 + tmp42 = tmp45 } // end let - v41 = v42 + tmp41 = tmp42 } else { - v41 = v40 + tmp41 = v40 } - v38 = v41 + tmp38 = tmp41 } // end let - v37 = v38 + tmp37 = tmp38 } else { - v37 = v36 + tmp37 = v36 } - v34 = v37 + tmp34 = tmp37 } // end let - v33 = v34 + tmp33 = tmp34 } else { - v33 = v32 + tmp33 = v32 } - v30 = v33 + tmp30 = tmp33 } // end let - v29 = v30 + tmp29 = tmp30 } else { - v29 = v28 + tmp29 = v28 } - v26 = v29 + tmp26 = tmp29 } // end let - v25 = v26 + tmp25 = tmp26 } else { - v25 = v24 + tmp25 = v24 } - v22 = v25 + tmp22 = tmp25 } // end let - v21 = v22 + tmp21 = tmp22 } else { - v21 = v20 + tmp21 = v20 } - v18 = v21 + tmp18 = tmp21 } // end let - v17 = v18 + tmp17 = tmp18 } else { - v17 = v16 + tmp17 = v16 } - v14 = v17 + tmp14 = tmp17 } // end let - v15 := lang.Apply(v13, []any{v14}) - return v15 + tmp15 := lang.Apply(tmp13, []any{tmp14}) + return tmp15 default: if len(args) < 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -32888,90 +32986,91 @@ func init() { _ = v9 v10 := args[2] _ = v10 - v11 := lang.NewList(args[3:]...) - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("boolean")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - var v15 any + var v11 any = lang.NewList(args[3:]...) + _ = v11 + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("boolean")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + var tmp15 any { // let // let binding "and__0__auto__" - v16 := lang.Apply(v7, []any{v8, v9, v10}) - var v17 any = v16 + tmp16 := lang.Apply(v7, []any{v8, v9, v10}) + var v17 any = tmp16 _ = v17 - var v18 any + var tmp18 any if lang.IsTruthy(v17) { - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("every?")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("every?")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) } - v21 := v20.Get() - var v22 lang.FnFunc - v22 = lang.NewFnFunc(func(args ...any) any { + tmp21 := tmp20.Get() + var tmp22 lang.FnFunc + tmp22 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v23 := args[0] _ = v23 - var v24 any + var tmp24 any { // let // let binding "and__0__auto__" - v25 := lang.Apply(v3, []any{v23}) - var v26 any = v25 + tmp25 := lang.Apply(v3, []any{v23}) + var v26 any = tmp25 _ = v26 - var v27 any + var tmp27 any if lang.IsTruthy(v26) { - var v28 any + var tmp28 any { // let // let binding "and__0__auto__" - v29 := lang.Apply(v4, []any{v23}) - var v30 any = v29 + tmp29 := lang.Apply(v4, []any{v23}) + var v30 any = tmp29 _ = v30 - var v31 any + var tmp31 any if lang.IsTruthy(v30) { - v32 := lang.Apply(v5, []any{v23}) - v31 = v32 + tmp32 := lang.Apply(v5, []any{v23}) + tmp31 = tmp32 } else { - v31 = v30 + tmp31 = v30 } - v28 = v31 + tmp28 = tmp31 } // end let - v27 = v28 + tmp27 = tmp28 } else { - v27 = v26 + tmp27 = v26 } - v24 = v27 + tmp24 = tmp27 } // end let - return v24 + return tmp24 }) - v23 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7451), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(7451), lang.NewKeyword("end-column"), int(72)) - v24, err := lang.WithMeta(v22, v23.(lang.IPersistentMap)) + tmp23 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7451), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(7451), lang.NewKeyword("end-column"), int(72)) + tmp24, err := lang.WithMeta(tmp22, tmp23.(lang.IPersistentMap)) if err != nil { panic(err) } - v25 := lang.Apply(v21, []any{v24, v11}) - v18 = v25 + tmp25 := lang.Apply(tmp21, []any{tmp24, v11}) + tmp18 = tmp25 } else { - v18 = v17 + tmp18 = v17 } - v15 = v18 + tmp15 = tmp18 } // end let - v16 := lang.Apply(v14, []any{v15}) - return v16 + tmp16 := lang.Apply(tmp14, []any{tmp15}) + return tmp16 } }) - v7 := v6 + v7 = tmp6 _ = v7 } - v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7445), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7451), lang.NewKeyword("end-column"), int(82)) - v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) + tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7445), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7451), lang.NewKeyword("end-column"), int(82)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) if err != nil { panic(err) } - return v8 + return tmp8 default: if len(args) < 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -32982,93 +33081,95 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - var v7 any + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any { // let // let binding "ps" - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("list*")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v3, v4, v5, v6}) - var v12 any = v11 + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("list*")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v3, v4, v5, v6}) + var v12 any = tmp11 _ = v12 - var v13 lang.FnFunc + var tmp13 lang.FnFunc { // function epn - v13 = lang.NewFnFunc(func(args ...any) any { + var v14 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: return true case 1: v15 := args[0] _ = v15 - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("every?")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("every?")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) } - v18 := v17.Get() - var v19 lang.FnFunc - v19 = lang.NewFnFunc(func(args ...any) any { + tmp18 := tmp17.Get() + var tmp19 lang.FnFunc + tmp19 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v20 := args[0] _ = v20 - v21 := lang.Apply(v20, []any{v15}) - return v21 + tmp21 := lang.Apply(v20, []any{v15}) + return tmp21 }) - v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7456), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(7456), lang.NewKeyword("end-column"), int(28)) - v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) + tmp20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7456), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(7456), lang.NewKeyword("end-column"), int(28)) + tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) if err != nil { panic(err) } - v22 := lang.Apply(v18, []any{v21, v12}) - return v22 + tmp22 := lang.Apply(tmp18, []any{tmp21, v12}) + return tmp22 case 2: v15 := args[0] _ = v15 v16 := args[1] _ = v16 - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("every?")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("every?")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) } - v19 := v18.Get() - var v20 lang.FnFunc - v20 = lang.NewFnFunc(func(args ...any) any { + tmp19 := tmp18.Get() + var tmp20 lang.FnFunc + tmp20 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v21 := args[0] _ = v21 - var v22 any + var tmp22 any { // let // let binding "and__0__auto__" - v23 := lang.Apply(v21, []any{v15}) - var v24 any = v23 + tmp23 := lang.Apply(v21, []any{v15}) + var v24 any = tmp23 _ = v24 - var v25 any + var tmp25 any if lang.IsTruthy(v24) { - v26 := lang.Apply(v21, []any{v16}) - v25 = v26 + tmp26 := lang.Apply(v21, []any{v16}) + tmp25 = tmp26 } else { - v25 = v24 + tmp25 = v24 } - v22 = v25 + tmp22 = tmp25 } // end let - return v22 + return tmp22 }) - v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7457), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7457), lang.NewKeyword("end-column"), int(42)) - v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) + tmp21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7457), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7457), lang.NewKeyword("end-column"), int(42)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) if err != nil { panic(err) } - v23 := lang.Apply(v19, []any{v22, v12}) - return v23 + tmp23 := lang.Apply(tmp19, []any{tmp22, v12}) + return tmp23 case 3: v15 := args[0] _ = v15 @@ -33076,57 +33177,57 @@ func init() { _ = v16 v17 := args[2] _ = v17 - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("every?")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("every?")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) } - v20 := v19.Get() - var v21 lang.FnFunc - v21 = lang.NewFnFunc(func(args ...any) any { + tmp20 := tmp19.Get() + var tmp21 lang.FnFunc + tmp21 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v22 := args[0] _ = v22 - var v23 any + var tmp23 any { // let // let binding "and__0__auto__" - v24 := lang.Apply(v22, []any{v15}) - var v25 any = v24 + tmp24 := lang.Apply(v22, []any{v15}) + var v25 any = tmp24 _ = v25 - var v26 any + var tmp26 any if lang.IsTruthy(v25) { - var v27 any + var tmp27 any { // let // let binding "and__0__auto__" - v28 := lang.Apply(v22, []any{v16}) - var v29 any = v28 + tmp28 := lang.Apply(v22, []any{v16}) + var v29 any = tmp28 _ = v29 - var v30 any + var tmp30 any if lang.IsTruthy(v29) { - v31 := lang.Apply(v22, []any{v17}) - v30 = v31 + tmp31 := lang.Apply(v22, []any{v17}) + tmp30 = tmp31 } else { - v30 = v29 + tmp30 = v29 } - v27 = v30 + tmp27 = tmp30 } // end let - v26 = v27 + tmp26 = tmp27 } else { - v26 = v25 + tmp26 = v25 } - v23 = v26 + tmp23 = tmp26 } // end let - return v23 + return tmp23 }) - v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7458), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(7458), lang.NewKeyword("end-column"), int(50)) - v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) + tmp22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7458), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(7458), lang.NewKeyword("end-column"), int(50)) + tmp23, err := lang.WithMeta(tmp21, tmp22.(lang.IPersistentMap)) if err != nil { panic(err) } - v24 := lang.Apply(v20, []any{v23, v12}) - return v24 + tmp24 := lang.Apply(tmp20, []any{tmp23, v12}) + return tmp24 default: if len(args) < 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -33137,84 +33238,85 @@ func init() { _ = v16 v17 := args[2] _ = v17 - v18 := lang.NewList(args[3:]...) - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("boolean")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + var v18 any = lang.NewList(args[3:]...) + _ = v18 + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("boolean")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) } - v21 := v20.Get() - var v22 any + tmp21 := tmp20.Get() + var tmp22 any { // let // let binding "and__0__auto__" - v23 := lang.Apply(v14, []any{v15, v16, v17}) - var v24 any = v23 + tmp23 := lang.Apply(v14, []any{v15, v16, v17}) + var v24 any = tmp23 _ = v24 - var v25 any + var tmp25 any if lang.IsTruthy(v24) { - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("every?")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("every?")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) } - v28 := v27.Get() - var v29 lang.FnFunc - v29 = lang.NewFnFunc(func(args ...any) any { + tmp28 := tmp27.Get() + var tmp29 lang.FnFunc + tmp29 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v30 := args[0] _ = v30 - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("every?")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("every?")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{v30, v18}) - return v34 + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{v30, v18}) + return tmp34 }) - v30 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7460), lang.NewKeyword("column"), int(48), lang.NewKeyword("end-line"), int(7460), lang.NewKeyword("end-column"), int(63)) - v31, err := lang.WithMeta(v29, v30.(lang.IPersistentMap)) + tmp30 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7460), lang.NewKeyword("column"), int(48), lang.NewKeyword("end-line"), int(7460), lang.NewKeyword("end-column"), int(63)) + tmp31, err := lang.WithMeta(tmp29, tmp30.(lang.IPersistentMap)) if err != nil { panic(err) } - v32 := lang.Apply(v28, []any{v31, v12}) - v25 = v32 + tmp32 := lang.Apply(tmp28, []any{tmp31, v12}) + tmp25 = tmp32 } else { - v25 = v24 + tmp25 = v24 } - v22 = v25 + tmp22 = tmp25 } // end let - v23 := lang.Apply(v21, []any{v22}) - return v23 + tmp23 := lang.Apply(tmp21, []any{tmp22}) + return tmp23 } }) - v14 := v13 + v14 = tmp13 _ = v14 } - v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7454), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7460), lang.NewKeyword("end-column"), int(71)) - v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) + tmp14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7454), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7460), lang.NewKeyword("end-column"), int(71)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) if err != nil { panic(err) } - v7 = v15 + tmp7 = tmp15 } // end let - return v7 + return tmp7 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // every? { - v1 := reflect.TypeOf(false) - v0 := lang.NewSymbol("every?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if (pred x) is logical true for every x in coll, else\n false.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2664), lang.NewKeyword("end-line"), int(2664))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp1 := reflect.TypeOf(false) + tmp0 := lang.NewSymbol("every?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if (pred x) is logical true for every x in coll, else\n false.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2664), lang.NewKeyword("end-line"), int(2664))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -33223,170 +33325,167 @@ func init() { v5 := args[1] _ = v5 recur_loop_480: - var v6 any - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("nil?")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("seq")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{v5}) - v14 := lang.Apply(v9, []any{v13}) - if lang.IsTruthy(v14) { - v6 = true + var tmp6 any + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("nil?")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("seq")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{v5}) + tmp14 := lang.Apply(tmp9, []any{tmp13}) + if lang.IsTruthy(tmp14) { + tmp6 = true } else { - var v15 any - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("first")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{v5}) - v20 := lang.Apply(v4, []any{v19}) - if lang.IsTruthy(v20) { - var v21 any = v4 - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("next")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.Apply(v25, []any{v5}) - var v22 any = v26 - v4 = v21 - v5 = v22 + var tmp15 any + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("first")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{v5}) + tmp20 := lang.Apply(v4, []any{tmp19}) + if lang.IsTruthy(tmp20) { + var tmp21 any = v4 + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("next")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.Apply(tmp25, []any{v5}) + var tmp22 any = tmp26 + v4 = tmp21 + v5 = tmp22 goto recur_loop_480 } else { - var v27 any + var tmp27 any if lang.IsTruthy(lang.NewKeyword("else")) { - v27 = false + tmp27 = false } else { - v27 = nil } - v15 = v27 + tmp15 = tmp27 } - v6 = v15 + tmp6 = tmp15 } - return v6 + return tmp6 }) - v4 := reflect.TypeOf(false) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp4 := reflect.TypeOf(false) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // ex-cause { - v0 := lang.NewSymbol("ex-cause").WithMeta(lang.NewMap(lang.NewKeyword("tag"), nil, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ex"))), lang.NewKeyword("doc"), "Returns the cause of ex if ex is a Throwable.\n Otherwise returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4828), lang.NewKeyword("end-line"), int(4828))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("ex-cause").WithMeta(lang.NewMap(lang.NewKeyword("tag"), nil, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ex"))), lang.NewKeyword("doc"), "Returns the cause of ex if ex is a Throwable.\n Otherwise returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4828), lang.NewKeyword("end-line"), int(4828))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{lang.Throwable, v3}) - if lang.IsTruthy(v8) { - v9, ok := lang.FieldOrMethod(v3, "getCause") + var tmp4 any + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("instance?")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{lang.Throwable, v3}) + if lang.IsTruthy(tmp8) { + tmp9, ok := lang.FieldOrMethod(v3, "getCause") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getCause"))) } - var v10 any - switch reflect.TypeOf(v9).Kind() { + var tmp10 any + switch reflect.TypeOf(tmp9).Kind() { case reflect.Func: - v10 = lang.Apply(v9, nil) + tmp10 = lang.Apply(tmp9, nil) default: - v10 = v9 + tmp10 = tmp9 } - v4 = v10 + tmp4 = tmp10 } else { - v4 = nil } - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // ex-data { - v0 := lang.NewSymbol("ex-data").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ex"))), lang.NewKeyword("doc"), "Returns exception data (a map) if ex is an IExceptionInfo.\n Otherwise returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4812), lang.NewKeyword("end-line"), int(4812))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("ex-data").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ex"))), lang.NewKeyword("doc"), "Returns exception data (a map) if ex is an IExceptionInfo.\n Otherwise returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4812), lang.NewKeyword("end-line"), int(4812))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{nil, v3}) - if lang.IsTruthy(v8) { - v9, ok := lang.FieldOrMethod(v3, "getData") + var tmp4 any + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("instance?")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{nil, v3}) + if lang.IsTruthy(tmp8) { + tmp9, ok := lang.FieldOrMethod(v3, "getData") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getData"))) } - var v10 any - switch reflect.TypeOf(v9).Kind() { + var tmp10 any + switch reflect.TypeOf(tmp9).Kind() { case reflect.Func: - v10 = lang.Apply(v9, nil) + tmp10 = lang.Apply(tmp9, nil) default: - v10 = v9 + tmp10 = tmp9 } - v4 = v10 + tmp4 = tmp10 } else { - v4 = nil } - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // ex-info { - v0 := lang.NewSymbol("ex-info").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("msg"), lang.NewSymbol("map")), lang.NewVector(lang.NewSymbol("msg"), lang.NewSymbol("map"), lang.NewSymbol("cause"))), lang.NewKeyword("doc"), "Create an instance of ExceptionInfo, a RuntimeException subclass\n that carries a map of additional data.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4803), lang.NewKeyword("end-line"), int(4803))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("ex-info").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("msg"), lang.NewSymbol("map")), lang.NewVector(lang.NewSymbol("msg"), lang.NewSymbol("map"), lang.NewSymbol("cause"))), lang.NewKeyword("doc"), "Create an instance of ExceptionInfo, a RuntimeException subclass\n that carries a map of additional data.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4803), lang.NewKeyword("end-line"), int(4803))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("elide-top-frames")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(nil, []any{v3, v4}) - v9 := lang.Apply(v7, []any{v8, "glojure.core$ex_info"}) - return v9 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("elide-top-frames")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(nil, []any{v3, v4}) + tmp9 := lang.Apply(tmp7, []any{tmp8, "glojure.core$ex_info"}) + return tmp9 case 3: v3 := args[0] _ = v3 @@ -33394,72 +33493,71 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("elide-top-frames")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(nil, []any{v3, v4, v5}) - v10 := lang.Apply(v8, []any{v9, "glojure.core$ex_info"}) - return v10 + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("elide-top-frames")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.Apply(nil, []any{v3, v4, v5}) + tmp10 := lang.Apply(tmp8, []any{tmp9, "glojure.core$ex_info"}) + return tmp10 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // ex-message { - v0 := lang.NewSymbol("ex-message").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ex"))), lang.NewKeyword("doc"), "Returns the message attached to ex if ex is a Throwable.\n Otherwise returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4820), lang.NewKeyword("end-line"), int(4820))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("ex-message").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ex"))), lang.NewKeyword("doc"), "Returns the message attached to ex if ex is a Throwable.\n Otherwise returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4820), lang.NewKeyword("end-line"), int(4820))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{lang.Throwable, v3}) - if lang.IsTruthy(v8) { - v9, ok := lang.FieldOrMethod(v3, "getMessage") + var tmp4 any + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("instance?")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{lang.Throwable, v3}) + if lang.IsTruthy(tmp8) { + tmp9, ok := lang.FieldOrMethod(v3, "getMessage") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getMessage"))) } - var v10 any - switch reflect.TypeOf(v9).Kind() { + var tmp10 any + switch reflect.TypeOf(tmp9).Kind() { case reflect.Func: - v10 = lang.Apply(v9, nil) + tmp10 = lang.Apply(tmp9, nil) default: - v10 = v9 + tmp10 = tmp9 } - v4 = v10 + tmp4 = tmp10 } else { - v4 = nil } - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // extend { - v0 := lang.NewSymbol("extend").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atype"), lang.NewSymbol("&"), lang.NewSymbol("proto+mmaps"))), lang.NewKeyword("doc"), "Implementations of protocol methods can be provided using the extend construct:\n\n (extend AType\n AProtocol\n {:foo an-existing-fn\n :bar (fn [a b] ...)\n :baz (fn ([a]...) ([a b] ...)...)}\n BProtocol \n {...} \n ...)\n \n extend takes a type/class (or interface, see below), and one or more\n protocol + method map pairs. It will extend the polymorphism of the\n protocol's methods to call the supplied methods when an AType is\n provided as the first argument. \n\n Method maps are maps of the keyword-ized method names to ordinary\n fns. This facilitates easy reuse of existing fns and fn maps, for\n code reuse/mixins without derivation or composition. You can extend\n an interface to a protocol. This is primarily to facilitate interop\n with the host (e.g. Java) but opens the door to incidental multiple\n inheritance of implementation since a class can inherit from more\n than one interface, both of which extend the protocol. It is TBD how\n to specify which impl to use. You can extend a protocol on nil.\n\n If you are supplying the definitions explicitly (i.e. not reusing\n exsting functions or mixin maps), you may find it more convenient to\n use the extend-type or extend-protocol macros.\n\n Note that multiple independent extend clauses can exist for the same\n type, not all protocols need be defined in a single extend call.\n\n See also:\n extends?, satisfies?, extenders", lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(116), lang.NewKeyword("end-line"), int(116))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("extend").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atype"), lang.NewSymbol("&"), lang.NewSymbol("proto+mmaps"))), lang.NewKeyword("doc"), "Implementations of protocol methods can be provided using the extend construct:\n\n (extend AType\n AProtocol\n {:foo an-existing-fn\n :bar (fn [a b] ...)\n :baz (fn ([a]...) ([a b] ...)...)}\n BProtocol \n {...} \n ...)\n \n extend takes a type/class (or interface, see below), and one or more\n protocol + method map pairs. It will extend the polymorphism of the\n protocol's methods to call the supplied methods when an AType is\n provided as the first argument. \n\n Method maps are maps of the keyword-ized method names to ordinary\n fns. This facilitates easy reuse of existing fns and fn maps, for\n code reuse/mixins without derivation or composition. You can extend\n an interface to a protocol. This is primarily to facilitate interop\n with the host (e.g. Java) but opens the door to incidental multiple\n inheritance of implementation since a class can inherit from more\n than one interface, both of which extend the protocol. It is TBD how\n to specify which impl to use. You can extend a protocol on nil.\n\n If you are supplying the definitions explicitly (i.e. not reusing\n exsting functions or mixin maps), you may find it more convenient to\n use the extend-type or extend-protocol macros.\n\n Note that multiple independent extend clauses can exist for the same\n type, not all protocols need be defined in a single extend call.\n\n See also:\n extends?, satisfies?, extenders", lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(116), lang.NewKeyword("end-line"), int(116))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 1 { @@ -33467,25 +33565,26 @@ func init() { } v3 := args[0] _ = v3 - v4 := lang.NewList(args[1:]...) - var v5 any + var v4 any = lang.NewList(args[1:]...) + _ = v4 + var tmp5 any { // let // let binding "seq_262" - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("seq")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("partition")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.Apply(v11, []any{int64(2), v4}) - v13 := lang.Apply(v8, []any{v12}) - var v14 any = v13 + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("seq")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("partition")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.Apply(tmp11, []any{int64(2), v4}) + tmp13 := lang.Apply(tmp8, []any{tmp12}) + var v14 any = tmp13 _ = v14 // let binding "chunk_263" var v15 any = nil @@ -33497,75 +33596,74 @@ func init() { var v17 any = int64(0) _ = v17 for { - var v18 any - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("<")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{v17, v16}) - if lang.IsTruthy(v22) { - var v23 any + var tmp18 any + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("<")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, []any{v17, v16}) + if lang.IsTruthy(tmp22) { + var tmp23 any { // let // let binding "vec__266" - v24, _ := lang.FieldOrMethod(v15, "nth") - if reflect.TypeOf(v24).Kind() != reflect.Func { + tmp24, _ := lang.FieldOrMethod(v15, "nth") + if reflect.TypeOf(tmp24).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) } - v25 := lang.Apply(v24, []any{v17}) - var v26 any = v25 + tmp25 := lang.Apply(tmp24, []any{v17}) + var v26 any = tmp25 _ = v26 // let binding "proto" - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("nth")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("nth")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{v26, int64(0), nil}) - var v31 any = v30 + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{v26, int64(0), nil}) + var v31 any = tmp30 _ = v31 // let binding "mmap" - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("nth")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("nth")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{v26, int64(1), nil}) - var v36 any = v35 + tmp34 := tmp33.Get() + tmp35 := lang.Apply(tmp34, []any{v26, int64(1), nil}) + var v36 any = tmp35 _ = v36 - var v37 any - v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v39 := v38.FindInternedVar(lang.NewSymbol("protocol?")) - if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + var tmp37 any + tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp39 := tmp38.FindInternedVar(lang.NewSymbol("protocol?")) + if tmp39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) } - v40 := v39.Get() - v41 := lang.Apply(v40, []any{v31}) - if lang.IsTruthy(v41) { - v37 = nil + tmp40 := tmp39.Get() + tmp41 := lang.Apply(tmp40, []any{v31}) + if lang.IsTruthy(tmp41) { } else { - v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v43 := v42.FindInternedVar(lang.NewSymbol("str")) - if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) + tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp43 := tmp42.FindInternedVar(lang.NewSymbol("str")) + if tmp43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) } - v44 := v43.Get() - v45 := lang.Apply(v44, []any{v31, " is not a protocol"}) - v46 := lang.Apply(errors5.New, []any{v45}) - panic(v46) + tmp44 := tmp43.Get() + tmp45 := lang.Apply(tmp44, []any{v31, " is not a protocol"}) + tmp46 := lang.Apply(errors5.New, []any{tmp45}) + panic(tmp46) } - _ = v37 - v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v48 := v47.FindInternedVar(lang.NewSymbol("reduce1")) - if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) + _ = tmp37 + tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp48 := tmp47.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) } - v49 := v48.Get() - var v50 lang.FnFunc - v50 = lang.NewFnFunc(func(args ...any) any { + tmp49 := tmp48.Get() + var tmp50 lang.FnFunc + tmp50 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -33573,53 +33671,53 @@ func init() { _ = v51 v52 := args[1] _ = v52 - var v53 any + var tmp53 any { // let // let binding "vec__270" var v54 any = v52 _ = v54 // let binding "k" - v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v56 := v55.FindInternedVar(lang.NewSymbol("nth")) - if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) + tmp55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp56 := tmp55.FindInternedVar(lang.NewSymbol("nth")) + if tmp56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp56))) } - v57 := v56.Get() - v58 := lang.Apply(v57, []any{v54, int64(0), nil}) - var v59 any = v58 + tmp57 := tmp56.Get() + tmp58 := lang.Apply(tmp57, []any{v54, int64(0), nil}) + var v59 any = tmp58 _ = v59 // let binding "v" - v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v61 := v60.FindInternedVar(lang.NewSymbol("nth")) - if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) + tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp61 := tmp60.FindInternedVar(lang.NewSymbol("nth")) + if tmp61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) } - v62 := v61.Get() - v63 := lang.Apply(v62, []any{v54, int64(1), nil}) - var v64 any = v63 + tmp62 := tmp61.Get() + tmp63 := lang.Apply(tmp62, []any{v54, int64(1), nil}) + var v64 any = tmp63 _ = v64 - v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v66 := v65.FindInternedVar(lang.NewSymbol("get-in")) - if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) + tmp65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp66 := tmp65.FindInternedVar(lang.NewSymbol("get-in")) + if tmp66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp66))) } - v67 := v66.Get() - v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v69 := v68.FindInternedVar(lang.NewSymbol("deref")) - if v69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) + tmp67 := tmp66.Get() + tmp68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp69 := tmp68.FindInternedVar(lang.NewSymbol("deref")) + if tmp69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp69))) } - v70 := v69.Get() - v71 := lang.Apply(v70, []any{v31}) - v72 := lang.NewVector(lang.NewKeyword("multis"), v59) - v73 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(158), lang.NewKeyword("column"), int(33), lang.NewKeyword("end-line"), int(158), lang.NewKeyword("end-column"), int(43)) - v74, err := lang.WithMeta(v72, v73.(lang.IPersistentMap)) + tmp70 := tmp69.Get() + tmp71 := lang.Apply(tmp70, []any{v31}) + tmp72 := lang.NewVector(lang.NewKeyword("multis"), v59) + tmp73 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(158), lang.NewKeyword("column"), int(33), lang.NewKeyword("end-line"), int(158), lang.NewKeyword("end-column"), int(43)) + tmp74, err := lang.WithMeta(tmp72, tmp73.(lang.IPersistentMap)) if err != nil { panic(err) } - v75 := lang.Apply(v67, []any{v71, v74}) - var v76 lang.FnFunc - v76 = lang.NewFnFunc(func(args ...any) any { + tmp75 := lang.Apply(tmp67, []any{tmp71, tmp74}) + var tmp76 lang.FnFunc + tmp76 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 1 { @@ -33627,201 +33725,201 @@ func init() { } v77 := args[0] _ = v77 - v78 := lang.NewList(args[1:]...) - v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v80 := v79.FindInternedVar(lang.NewSymbol("apply")) - if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) + var v78 any = lang.NewList(args[1:]...) + _ = v78 + tmp79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp80 := tmp79.FindInternedVar(lang.NewSymbol("apply")) + if tmp80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp80))) } - v81 := v80.Get() - v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v83 := v82.FindInternedVar(lang.NewSymbol("cons")) - if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) + tmp81 := tmp80.Get() + tmp82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp83 := tmp82.FindInternedVar(lang.NewSymbol("cons")) + if tmp83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp83))) } - v84 := v83.Get() - v85 := lang.Apply(v84, []any{v77, v78}) - v86 := lang.Apply(v81, []any{v64, v85}) - return v86 + tmp84 := tmp83.Get() + tmp85 := lang.Apply(tmp84, []any{v77, v78}) + tmp86 := lang.Apply(tmp81, []any{v64, tmp85}) + return tmp86 } }) - v77, _ := lang.FieldOrMethod(v75, "AddMethod") - if reflect.TypeOf(v77).Kind() != reflect.Func { + tmp77, _ := lang.FieldOrMethod(tmp75, "AddMethod") + if reflect.TypeOf(tmp77).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("AddMethod is not a function"))) } - v78 := lang.Apply(v77, []any{v3, v76}) - v53 = v78 + tmp78 := lang.Apply(tmp77, []any{v3, tmp76}) + tmp53 = tmp78 } // end let - return v53 + return tmp53 }) - v51 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(156), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(160), lang.NewKeyword("end-column"), int(45)) - v52, err := lang.WithMeta(v50, v51.(lang.IPersistentMap)) + tmp51 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(156), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(160), lang.NewKeyword("end-column"), int(45)) + tmp52, err := lang.WithMeta(tmp50, tmp51.(lang.IPersistentMap)) if err != nil { panic(err) } - v53 := lang.Apply(v49, []any{v52, nil, v36}) - _ = v53 - var v54 any = v14 - var v55 any = v15 - var v56 any = v16 - v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v59 := v58.FindInternedVar(lang.NewSymbol("unchecked-inc")) - if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) + tmp53 := lang.Apply(tmp49, []any{tmp52, nil, v36}) + _ = tmp53 + var tmp54 any = v14 + var tmp55 any = v15 + var tmp56 any = v16 + tmp58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp59 := tmp58.FindInternedVar(lang.NewSymbol("unchecked-inc")) + if tmp59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp59))) } - v60 := v59.Get() - v61 := lang.Apply(v60, []any{v17}) - var v57 any = v61 - v14 = v54 - v15 = v55 - v16 = v56 - v17 = v57 + tmp60 := tmp59.Get() + tmp61 := lang.Apply(tmp60, []any{v17}) + var tmp57 any = tmp61 + v14 = tmp54 + v15 = tmp55 + v16 = tmp56 + v17 = tmp57 continue } // end let - v18 = v23 + tmp18 = tmp23 } else { - var v24 any + var tmp24 any { // let // let binding "temp__0__auto__" - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("seq")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("seq")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) } - v27 := v26.Get() - v28 := lang.Apply(v27, []any{v14}) - var v29 any = v28 + tmp27 := tmp26.Get() + tmp28 := lang.Apply(tmp27, []any{v14}) + var v29 any = tmp28 _ = v29 - var v30 any + var tmp30 any if lang.IsTruthy(v29) { - var v31 any + var tmp31 any { // let // let binding "seq_262" var v32 any = v29 _ = v32 - var v33 any - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("chunked-seq?")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + var tmp33 any + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("chunked-seq?")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) } - v36 := v35.Get() - v37 := lang.Apply(v36, []any{v32}) - if lang.IsTruthy(v37) { - var v38 any + tmp36 := tmp35.Get() + tmp37 := lang.Apply(tmp36, []any{v32}) + if lang.IsTruthy(tmp37) { + var tmp38 any { // let // let binding "c__0__auto__" - v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v40 := v39.FindInternedVar(lang.NewSymbol("chunk-first")) - if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) + tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp40 := tmp39.FindInternedVar(lang.NewSymbol("chunk-first")) + if tmp40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) } - v41 := v40.Get() - v42 := lang.Apply(v41, []any{v32}) - var v43 any = v42 + tmp41 := tmp40.Get() + tmp42 := lang.Apply(tmp41, []any{v32}) + var v43 any = tmp42 _ = v43 - v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v46 := v45.FindInternedVar(lang.NewSymbol("chunk-rest")) - if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) + tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp46 := tmp45.FindInternedVar(lang.NewSymbol("chunk-rest")) + if tmp46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) } - v47 := v46.Get() - v48 := lang.Apply(v47, []any{v32}) - var v44 any = v48 - var v49 any = v43 - v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v52 := v51.FindInternedVar(lang.NewSymbol("int")) - if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) + tmp47 := tmp46.Get() + tmp48 := lang.Apply(tmp47, []any{v32}) + var tmp44 any = tmp48 + var tmp49 any = v43 + tmp51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp52 := tmp51.FindInternedVar(lang.NewSymbol("int")) + if tmp52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp52))) } - v53 := v52.Get() - v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v55 := v54.FindInternedVar(lang.NewSymbol("count")) - if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) + tmp53 := tmp52.Get() + tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp55 := tmp54.FindInternedVar(lang.NewSymbol("count")) + if tmp55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) } - v56 := v55.Get() - v57 := lang.Apply(v56, []any{v43}) - v58 := lang.Apply(v53, []any{v57}) - var v50 any = v58 - v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v61 := v60.FindInternedVar(lang.NewSymbol("int")) - if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) + tmp56 := tmp55.Get() + tmp57 := lang.Apply(tmp56, []any{v43}) + tmp58 := lang.Apply(tmp53, []any{tmp57}) + var tmp50 any = tmp58 + tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp61 := tmp60.FindInternedVar(lang.NewSymbol("int")) + if tmp61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) } - v62 := v61.Get() - v63 := lang.Apply(v62, []any{int64(0)}) - var v59 any = v63 - v14 = v44 - v15 = v49 - v16 = v50 - v17 = v59 + tmp62 := tmp61.Get() + tmp63 := lang.Apply(tmp62, []any{int64(0)}) + var tmp59 any = tmp63 + v14 = tmp44 + v15 = tmp49 + v16 = tmp50 + v17 = tmp59 continue } // end let - v33 = v38 + tmp33 = tmp38 } else { - var v39 any + var tmp39 any { // let // let binding "vec__273" - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("first")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("first")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) } - v42 := v41.Get() - v43 := lang.Apply(v42, []any{v32}) - var v44 any = v43 + tmp42 := tmp41.Get() + tmp43 := lang.Apply(tmp42, []any{v32}) + var v44 any = tmp43 _ = v44 // let binding "proto" - v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v46 := v45.FindInternedVar(lang.NewSymbol("nth")) - if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) + tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp46 := tmp45.FindInternedVar(lang.NewSymbol("nth")) + if tmp46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) } - v47 := v46.Get() - v48 := lang.Apply(v47, []any{v44, int64(0), nil}) - var v49 any = v48 + tmp47 := tmp46.Get() + tmp48 := lang.Apply(tmp47, []any{v44, int64(0), nil}) + var v49 any = tmp48 _ = v49 // let binding "mmap" - v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v51 := v50.FindInternedVar(lang.NewSymbol("nth")) - if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) + tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp51 := tmp50.FindInternedVar(lang.NewSymbol("nth")) + if tmp51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) } - v52 := v51.Get() - v53 := lang.Apply(v52, []any{v44, int64(1), nil}) - var v54 any = v53 + tmp52 := tmp51.Get() + tmp53 := lang.Apply(tmp52, []any{v44, int64(1), nil}) + var v54 any = tmp53 _ = v54 - var v55 any - v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v57 := v56.FindInternedVar(lang.NewSymbol("protocol?")) - if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) + var tmp55 any + tmp56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp57 := tmp56.FindInternedVar(lang.NewSymbol("protocol?")) + if tmp57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp57))) } - v58 := v57.Get() - v59 := lang.Apply(v58, []any{v49}) - if lang.IsTruthy(v59) { - v55 = nil + tmp58 := tmp57.Get() + tmp59 := lang.Apply(tmp58, []any{v49}) + if lang.IsTruthy(tmp59) { } else { - v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v61 := v60.FindInternedVar(lang.NewSymbol("str")) - if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) + tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp61 := tmp60.FindInternedVar(lang.NewSymbol("str")) + if tmp61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) } - v62 := v61.Get() - v63 := lang.Apply(v62, []any{v49, " is not a protocol"}) - v64 := lang.Apply(errors5.New, []any{v63}) - panic(v64) + tmp62 := tmp61.Get() + tmp63 := lang.Apply(tmp62, []any{v49, " is not a protocol"}) + tmp64 := lang.Apply(errors5.New, []any{tmp63}) + panic(tmp64) } - _ = v55 - v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v66 := v65.FindInternedVar(lang.NewSymbol("reduce1")) - if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) + _ = tmp55 + tmp65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp66 := tmp65.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp66))) } - v67 := v66.Get() - var v68 lang.FnFunc - v68 = lang.NewFnFunc(func(args ...any) any { + tmp67 := tmp66.Get() + var tmp68 lang.FnFunc + tmp68 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -33829,53 +33927,53 @@ func init() { _ = v69 v70 := args[1] _ = v70 - var v71 any + var tmp71 any { // let // let binding "vec__277" var v72 any = v70 _ = v72 // let binding "k" - v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v74 := v73.FindInternedVar(lang.NewSymbol("nth")) - if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) + tmp73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp74 := tmp73.FindInternedVar(lang.NewSymbol("nth")) + if tmp74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp74))) } - v75 := v74.Get() - v76 := lang.Apply(v75, []any{v72, int64(0), nil}) - var v77 any = v76 + tmp75 := tmp74.Get() + tmp76 := lang.Apply(tmp75, []any{v72, int64(0), nil}) + var v77 any = tmp76 _ = v77 // let binding "v" - v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v79 := v78.FindInternedVar(lang.NewSymbol("nth")) - if v79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) + tmp78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp79 := tmp78.FindInternedVar(lang.NewSymbol("nth")) + if tmp79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp79))) } - v80 := v79.Get() - v81 := lang.Apply(v80, []any{v72, int64(1), nil}) - var v82 any = v81 + tmp80 := tmp79.Get() + tmp81 := lang.Apply(tmp80, []any{v72, int64(1), nil}) + var v82 any = tmp81 _ = v82 - v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v84 := v83.FindInternedVar(lang.NewSymbol("get-in")) - if v84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) + tmp83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp84 := tmp83.FindInternedVar(lang.NewSymbol("get-in")) + if tmp84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp84))) } - v85 := v84.Get() - v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v87 := v86.FindInternedVar(lang.NewSymbol("deref")) - if v87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) + tmp85 := tmp84.Get() + tmp86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp87 := tmp86.FindInternedVar(lang.NewSymbol("deref")) + if tmp87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp87))) } - v88 := v87.Get() - v89 := lang.Apply(v88, []any{v49}) - v90 := lang.NewVector(lang.NewKeyword("multis"), v77) - v91 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(158), lang.NewKeyword("column"), int(33), lang.NewKeyword("end-line"), int(158), lang.NewKeyword("end-column"), int(43)) - v92, err := lang.WithMeta(v90, v91.(lang.IPersistentMap)) + tmp88 := tmp87.Get() + tmp89 := lang.Apply(tmp88, []any{v49}) + tmp90 := lang.NewVector(lang.NewKeyword("multis"), v77) + tmp91 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(158), lang.NewKeyword("column"), int(33), lang.NewKeyword("end-line"), int(158), lang.NewKeyword("end-column"), int(43)) + tmp92, err := lang.WithMeta(tmp90, tmp91.(lang.IPersistentMap)) if err != nil { panic(err) } - v93 := lang.Apply(v85, []any{v89, v92}) - var v94 lang.FnFunc - v94 = lang.NewFnFunc(func(args ...any) any { + tmp93 := lang.Apply(tmp85, []any{tmp89, tmp92}) + var tmp94 lang.FnFunc + tmp94 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 1 { @@ -33883,87 +33981,87 @@ func init() { } v95 := args[0] _ = v95 - v96 := lang.NewList(args[1:]...) - v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v98 := v97.FindInternedVar(lang.NewSymbol("apply")) - if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) + var v96 any = lang.NewList(args[1:]...) + _ = v96 + tmp97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp98 := tmp97.FindInternedVar(lang.NewSymbol("apply")) + if tmp98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp98))) } - v99 := v98.Get() - v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v101 := v100.FindInternedVar(lang.NewSymbol("cons")) - if v101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) + tmp99 := tmp98.Get() + tmp100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp101 := tmp100.FindInternedVar(lang.NewSymbol("cons")) + if tmp101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp101))) } - v102 := v101.Get() - v103 := lang.Apply(v102, []any{v95, v96}) - v104 := lang.Apply(v99, []any{v82, v103}) - return v104 + tmp102 := tmp101.Get() + tmp103 := lang.Apply(tmp102, []any{v95, v96}) + tmp104 := lang.Apply(tmp99, []any{v82, tmp103}) + return tmp104 } }) - v95, _ := lang.FieldOrMethod(v93, "AddMethod") - if reflect.TypeOf(v95).Kind() != reflect.Func { + tmp95, _ := lang.FieldOrMethod(tmp93, "AddMethod") + if reflect.TypeOf(tmp95).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("AddMethod is not a function"))) } - v96 := lang.Apply(v95, []any{v3, v94}) - v71 = v96 + tmp96 := lang.Apply(tmp95, []any{v3, tmp94}) + tmp71 = tmp96 } // end let - return v71 + return tmp71 }) - v69 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(156), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(160), lang.NewKeyword("end-column"), int(45)) - v70, err := lang.WithMeta(v68, v69.(lang.IPersistentMap)) + tmp69 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(156), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(160), lang.NewKeyword("end-column"), int(45)) + tmp70, err := lang.WithMeta(tmp68, tmp69.(lang.IPersistentMap)) if err != nil { panic(err) } - v71 := lang.Apply(v67, []any{v70, nil, v54}) - _ = v71 - v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v74 := v73.FindInternedVar(lang.NewSymbol("next")) - if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) + tmp71 := lang.Apply(tmp67, []any{tmp70, nil, v54}) + _ = tmp71 + tmp73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp74 := tmp73.FindInternedVar(lang.NewSymbol("next")) + if tmp74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp74))) } - v75 := v74.Get() - v76 := lang.Apply(v75, []any{v32}) - var v72 any = v76 - var v77 any = nil - var v78 any = int64(0) - var v79 any = int64(0) - v14 = v72 - v15 = v77 - v16 = v78 - v17 = v79 + tmp75 := tmp74.Get() + tmp76 := lang.Apply(tmp75, []any{v32}) + var tmp72 any = tmp76 + var tmp77 any = nil + var tmp78 any = int64(0) + var tmp79 any = int64(0) + v14 = tmp72 + v15 = tmp77 + v16 = tmp78 + v17 = tmp79 continue } // end let - v33 = v39 + tmp33 = tmp39 } - v31 = v33 + tmp31 = tmp33 } // end let - v30 = v31 + tmp30 = tmp31 } else { - v30 = nil } - v24 = v30 + tmp24 = tmp30 } // end let - v18 = v24 + tmp18 = tmp24 } - v5 = v18 + tmp5 = tmp18 break } } // end let - return v5 + return tmp5 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // extend-protocol { - v0 := lang.NewSymbol("extend-protocol").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("p"), lang.NewSymbol("&"), lang.NewSymbol("specs"))), lang.NewKeyword("doc"), "Useful when you want to provide several implementations of the same\n protocol all at once. Takes a single protocol and the implementation\n of that protocol for one or more types.\n\n (extend-protocol Protocol\n AType\n (foo [x] ...)\n (bar [x y] ...)\n BType\n (foo [x] ...)\n (bar [x y] ...)\n AClass\n (foo [x] ...)\n (bar [x y] ...)\n nil\n (foo [x] ...)\n (bar [x y] ...))\n\n expands into:\n\n (do\n (clojure.core/extend-type AType Protocol \n (foo [x] ...) \n (bar [x y] ...))\n (clojure.core/extend-type BType Protocol \n (foo [x] ...) \n (bar [x y] ...))\n (clojure.core/extend-type AClass Protocol \n (foo [x] ...) \n (bar [x y] ...))\n (clojure.core/extend-type nil Protocol \n (foo [x] ...) \n (bar [x y] ...)))", lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(212), lang.NewKeyword("end-line"), int(212))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("extend-protocol").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("p"), lang.NewSymbol("&"), lang.NewSymbol("specs"))), lang.NewKeyword("doc"), "Useful when you want to provide several implementations of the same\n protocol all at once. Takes a single protocol and the implementation\n of that protocol for one or more types.\n\n (extend-protocol Protocol\n AType\n (foo [x] ...)\n (bar [x y] ...)\n BType\n (foo [x] ...)\n (bar [x y] ...)\n AClass\n (foo [x] ...)\n (bar [x y] ...)\n nil\n (foo [x] ...)\n (bar [x y] ...))\n\n expands into:\n\n (do\n (clojure.core/extend-type AType Protocol \n (foo [x] ...) \n (bar [x y] ...))\n (clojure.core/extend-type BType Protocol \n (foo [x] ...) \n (bar [x y] ...))\n (clojure.core/extend-type AClass Protocol \n (foo [x] ...) \n (bar [x y] ...))\n (clojure.core/extend-type nil Protocol \n (foo [x] ...) \n (bar [x y] ...)))", lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(212), lang.NewKeyword("end-line"), int(212))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 3 { @@ -33975,28 +34073,29 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("emit-extend-protocol")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("emit-extend-protocol")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) } - v9 := v8.Get() - v10 := lang.Apply(v9, []any{v5, v6}) - return v10 + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp9, []any{v5, v6}) + return tmp10 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // extend-type { - v0 := lang.NewSymbol("extend-type").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("t"), lang.NewSymbol("&"), lang.NewSymbol("specs"))), lang.NewKeyword("doc"), "A macro that expands into an extend call. Useful when you are\n supplying the definitions explicitly inline, extend-type\n automatically creates the maps required by extend. Propagates the\n class as a type hint on the first argument of all fns.\n\n (extend-type MyType \n Countable\n (cnt [c] ...)\n Foo\n (bar [x y] ...)\n (baz ([x] ...) ([x y & zs] ...)))\n\n expands into:\n\n (extend MyType\n Countable\n {:cnt (fn [c] ...)}\n Foo\n {:baz (fn ([x] ...) ([x y & zs] ...))\n :bar (fn [x y] ...)})", lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(180), lang.NewKeyword("end-line"), int(180))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("extend-type").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("t"), lang.NewSymbol("&"), lang.NewSymbol("specs"))), lang.NewKeyword("doc"), "A macro that expands into an extend call. Useful when you are\n supplying the definitions explicitly inline, extend-type\n automatically creates the maps required by extend. Propagates the\n class as a type hint on the first argument of all fns.\n\n (extend-type MyType \n Countable\n (cnt [c] ...)\n Foo\n (bar [x y] ...)\n (baz ([x] ...) ([x y & zs] ...)))\n\n expands into:\n\n (extend MyType\n Countable\n {:cnt (fn [c] ...)}\n Foo\n {:baz (fn ([x] ...) ([x y & zs] ...))\n :bar (fn [x y] ...)})", lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(180), lang.NewKeyword("end-line"), int(180))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 3 { @@ -34008,459 +34107,458 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("emit-extend-type")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("emit-extend-type")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) } - v9 := v8.Get() - v10 := lang.Apply(v9, []any{v5, v6}) - return v10 + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp9, []any{v5, v6}) + return tmp10 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // false? { - v1 := reflect.TypeOf(false) - v0 := lang.NewSymbol("false?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is the value false, false otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(504), lang.NewKeyword("end-line"), int(504))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp1 := reflect.TypeOf(false) + tmp0 := lang.NewSymbol("false?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is the value false, false otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(504), lang.NewKeyword("end-line"), int(504))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5 := lang.Apply(lang.Identical, []any{v4, false}) - return v5 + tmp5 := lang.Apply(lang.Identical, []any{v4, false}) + return tmp5 }) - v4 := reflect.TypeOf(false) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp4 := reflect.TypeOf(false) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // ffirst { - v0 := lang.NewSymbol("ffirst").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Same as (first (first x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(98), lang.NewKeyword("end-line"), int(102))).(*lang.Symbol) - var v2 lang.FnFunc + tmp0 := lang.NewSymbol("ffirst").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Same as (first (first x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(98), lang.NewKeyword("end-line"), int(102))).(*lang.Symbol) + var tmp2 lang.FnFunc { // function ffirst - v2 = lang.NewFnFunc(func(args ...any) any { + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("first")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("first")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v4}) - v12 := lang.Apply(v7, []any{v11}) - return v12 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("first")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("first")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v4}) + tmp12 := lang.Apply(tmp7, []any{tmp11}) + return tmp12 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(102), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(102), lang.NewKeyword("end-column"), int(50))).(lang.FnFunc) - v3 := v2 + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(102), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(102), lang.NewKeyword("end-column"), int(50))).(lang.FnFunc) + v3 = tmp2 _ = v3 } - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // file-seq { - v0 := lang.NewSymbol("file-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("dir"))), lang.NewKeyword("doc"), "A tree seq on java.io.Files", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4972), lang.NewKeyword("end-line"), int(4972))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("file-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("dir"))), lang.NewKeyword("doc"), "A tree seq on java.io.Files", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4972), lang.NewKeyword("end-line"), int(4972))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("tree-seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - var v7 lang.FnFunc - v7 = lang.NewFnFunc(func(args ...any) any { + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("tree-seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v8 := args[0] _ = v8 - v9, _ := lang.FieldOrMethod(v8, "isDirectory") - if reflect.TypeOf(v9).Kind() != reflect.Func { + tmp9, _ := lang.FieldOrMethod(v8, "isDirectory") + if reflect.TypeOf(tmp9).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("isDirectory is not a function"))) } - v10 := lang.Apply(v9, []any{}) - return v10 + tmp10 := lang.Apply(tmp9, []any{}) + return tmp10 }) - v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4978), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(4978), lang.NewKeyword("end-column"), int(47)) - v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) + tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4978), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(4978), lang.NewKeyword("end-column"), int(47)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) if err != nil { panic(err) } - var v10 lang.FnFunc - v10 = lang.NewFnFunc(func(args ...any) any { + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v11 := args[0] _ = v11 - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("seq")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15, _ := lang.FieldOrMethod(v11, "listFiles") - if reflect.TypeOf(v15).Kind() != reflect.Func { + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("seq")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15, _ := lang.FieldOrMethod(v11, "listFiles") + if reflect.TypeOf(tmp15).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("listFiles is not a function"))) } - v16 := lang.Apply(v15, []any{}) - v17 := lang.Apply(v14, []any{v16}) - return v17 + tmp16 := lang.Apply(tmp15, []any{}) + tmp17 := lang.Apply(tmp14, []any{tmp16}) + return tmp17 }) - v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4979), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(4979), lang.NewKeyword("end-column"), int(51)) - v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) + tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4979), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(4979), lang.NewKeyword("end-column"), int(51)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) if err != nil { panic(err) } - v13 := lang.Apply(v6, []any{v9, v12, v3}) - return v13 + tmp13 := lang.Apply(tmp6, []any{tmp9, tmp12, v3}) + return tmp13 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // filter { - v0 := lang.NewSymbol("filter").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred")), lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the items in coll for which\n (pred item) returns logical true. pred must be free of side-effects.\n Returns a transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2785), lang.NewKeyword("end-line"), int(2785))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("filter").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred")), lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the items in coll for which\n (pred item) returns logical true. pred must be free of side-effects.\n Returns a transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2785), lang.NewKeyword("end-line"), int(2785))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - var v4 lang.FnFunc - v4 = lang.NewFnFunc(func(args ...any) any { + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v5 := args[0] _ = v5 - var v6 lang.FnFunc - v6 = lang.NewFnFunc(func(args ...any) any { + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - v7 := lang.Apply(v5, nil) - return v7 + tmp7 := lang.Apply(v5, nil) + return tmp7 case 1: v7 := args[0] _ = v7 - v8 := lang.Apply(v5, []any{v7}) - return v8 + tmp8 := lang.Apply(v5, []any{v7}) + return tmp8 case 2: v7 := args[0] _ = v7 v8 := args[1] _ = v8 - var v9 any - v10 := lang.Apply(v3, []any{v8}) - if lang.IsTruthy(v10) { - v11 := lang.Apply(v5, []any{v7, v8}) - v9 = v11 + var tmp9 any + tmp10 := lang.Apply(v3, []any{v8}) + if lang.IsTruthy(tmp10) { + tmp11 := lang.Apply(v5, []any{v7, v8}) + tmp9 = tmp11 } else { - v9 = v7 + tmp9 = v7 } - return v9 + return tmp9 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2793), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(2799), lang.NewKeyword("end-column"), int(22)) - v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) + tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2793), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(2799), lang.NewKeyword("end-column"), int(22)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) if err != nil { panic(err) } - return v8 + return tmp8 }) - v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2792), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2799), lang.NewKeyword("end-column"), int(23)) - v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) + tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2792), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2799), lang.NewKeyword("end-column"), int(23)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) if err != nil { panic(err) } - return v6 + return tmp6 case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - var v5 lang.FnFunc - v5 = lang.NewFnFunc(func(args ...any) any { + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - var v6 any + var tmp6 any { // let // let binding "temp__0__auto__" - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("seq")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v9, []any{v4}) - var v11 any = v10 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("seq")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp9, []any{v4}) + var v11 any = tmp10 _ = v11 - var v12 any + var tmp12 any if lang.IsTruthy(v11) { - var v13 any + var tmp13 any { // let // let binding "s" var v14 any = v11 _ = v14 - var v15 any - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("chunked-seq?")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + var tmp15 any + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("chunked-seq?")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{v14}) - if lang.IsTruthy(v19) { - var v20 any + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{v14}) + if lang.IsTruthy(tmp19) { + var tmp20 any { // let // let binding "c" - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("chunk-first")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("chunk-first")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) } - v23 := v22.Get() - v24 := lang.Apply(v23, []any{v14}) - var v25 any = v24 + tmp23 := tmp22.Get() + tmp24 := lang.Apply(tmp23, []any{v14}) + var v25 any = tmp24 _ = v25 // let binding "size" - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("count")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("count")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) } - v28 := v27.Get() - v29 := lang.Apply(v28, []any{v25}) - var v30 any = v29 + tmp28 := tmp27.Get() + tmp29 := lang.Apply(tmp28, []any{v25}) + var v30 any = tmp29 _ = v30 // let binding "b" - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("chunk-buffer")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("chunk-buffer")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{v30}) - var v35 any = v34 + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{v30}) + var v35 any = tmp34 _ = v35 - var v36 any + var tmp36 any { // let // let binding "n__0__auto__" - v37 := lang.Apply(lang.LongCast, []any{v30}) - var v38 any = v37 + tmp37 := lang.Apply(lang.LongCast, []any{v30}) + var v38 any = tmp37 _ = v38 - var v39 any + var tmp39 any { // let // let binding "i" var v40 any = int64(0) _ = v40 for { - var v41 any - v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v43 := v42.FindInternedVar(lang.NewSymbol("<")) - if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) + var tmp41 any + tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp43 := tmp42.FindInternedVar(lang.NewSymbol("<")) + if tmp43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) } - v44 := v43.Get() - v45 := lang.Apply(v44, []any{v40, v38}) - if lang.IsTruthy(v45) { - var v46 any + tmp44 := tmp43.Get() + tmp45 := lang.Apply(tmp44, []any{v40, v38}) + if lang.IsTruthy(tmp45) { + var tmp46 any { // let // let binding "v" - v47, _ := lang.FieldOrMethod(v25, "nth") - if reflect.TypeOf(v47).Kind() != reflect.Func { + tmp47, _ := lang.FieldOrMethod(v25, "nth") + if reflect.TypeOf(tmp47).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) } - v48 := lang.Apply(v47, []any{v40}) - var v49 any = v48 + tmp48 := lang.Apply(tmp47, []any{v40}) + var v49 any = tmp48 _ = v49 - var v50 any - v51 := lang.Apply(v3, []any{v49}) - if lang.IsTruthy(v51) { - v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v53 := v52.FindInternedVar(lang.NewSymbol("chunk-append")) - if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) + var tmp50 any + tmp51 := lang.Apply(v3, []any{v49}) + if lang.IsTruthy(tmp51) { + tmp52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp53 := tmp52.FindInternedVar(lang.NewSymbol("chunk-append")) + if tmp53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp53))) } - v54 := v53.Get() - v55 := lang.Apply(v54, []any{v35, v49}) - v50 = v55 + tmp54 := tmp53.Get() + tmp55 := lang.Apply(tmp54, []any{v35, v49}) + tmp50 = tmp55 } else { - v50 = nil } - v46 = v50 + tmp46 = tmp50 } // end let - _ = v46 - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("unchecked-inc")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + _ = tmp46 + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("unchecked-inc")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v40}) - var v47 any = v51 - v40 = v47 + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v40}) + var tmp47 any = tmp51 + v40 = tmp47 continue } else { - v41 = nil } - v39 = v41 + tmp39 = tmp41 break } } // end let - v36 = v39 + tmp36 = tmp39 } // end let - _ = v36 - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("chunk-cons")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + _ = tmp36 + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("chunk-cons")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) } - v39 := v38.Get() - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("chunk")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + tmp39 := tmp38.Get() + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("chunk")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) } - v42 := v41.Get() - v43 := lang.Apply(v42, []any{v35}) - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("filter")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + tmp42 := tmp41.Get() + tmp43 := lang.Apply(tmp42, []any{v35}) + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("filter")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) } - v46 := v45.Get() - v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v48 := v47.FindInternedVar(lang.NewSymbol("chunk-rest")) - if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) + tmp46 := tmp45.Get() + tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp48 := tmp47.FindInternedVar(lang.NewSymbol("chunk-rest")) + if tmp48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) } - v49 := v48.Get() - v50 := lang.Apply(v49, []any{v14}) - v51 := lang.Apply(v46, []any{v3, v50}) - v52 := lang.Apply(v39, []any{v43, v51}) - v20 = v52 + tmp49 := tmp48.Get() + tmp50 := lang.Apply(tmp49, []any{v14}) + tmp51 := lang.Apply(tmp46, []any{v3, tmp50}) + tmp52 := lang.Apply(tmp39, []any{tmp43, tmp51}) + tmp20 = tmp52 } // end let - v15 = v20 + tmp15 = tmp20 } else { - var v21 any + var tmp21 any { // let // let binding "f" - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("first")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("first")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v14}) - var v26 any = v25 + tmp24 := tmp23.Get() + tmp25 := lang.Apply(tmp24, []any{v14}) + var v26 any = tmp25 _ = v26 // let binding "r" - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("rest")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("rest")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{v14}) - var v31 any = v30 + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{v14}) + var v31 any = tmp30 _ = v31 - var v32 any - v33 := lang.Apply(v3, []any{v26}) - if lang.IsTruthy(v33) { - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("cons")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + var tmp32 any + tmp33 := lang.Apply(v3, []any{v26}) + if lang.IsTruthy(tmp33) { + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("cons")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) } - v36 := v35.Get() - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("filter")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + tmp36 := tmp35.Get() + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("filter")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) } - v39 := v38.Get() - v40 := lang.Apply(v39, []any{v3, v31}) - v41 := lang.Apply(v36, []any{v26, v40}) - v32 = v41 + tmp39 := tmp38.Get() + tmp40 := lang.Apply(tmp39, []any{v3, v31}) + tmp41 := lang.Apply(tmp36, []any{v26, tmp40}) + tmp32 = tmp41 } else { - v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v43 := v42.FindInternedVar(lang.NewSymbol("filter")) - if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) + tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp43 := tmp42.FindInternedVar(lang.NewSymbol("filter")) + if tmp43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) } - v44 := v43.Get() - v45 := lang.Apply(v44, []any{v3, v31}) - v32 = v45 + tmp44 := tmp43.Get() + tmp45 := lang.Apply(tmp44, []any{v3, v31}) + tmp32 = tmp45 } - v21 = v32 + tmp21 = tmp32 } // end let - v15 = v21 + tmp15 = tmp21 } - v13 = v15 + tmp13 = tmp15 } // end let - v12 = v13 + tmp12 = tmp13 } else { - v12 = nil } - v6 = v12 + tmp6 = tmp12 } // end let - return v6 + return tmp6 }) - v6 := lang.Apply(lang.NewLazySeq, []any{v5}) - return v6 + tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) + return tmp6 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // filter-key { - v0 := lang.NewSymbol("filter-key").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("keyfn"), lang.NewSymbol("pred"), lang.NewSymbol("amap"))), lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4115), lang.NewKeyword("end-line"), int(4117), lang.NewKeyword("private"), true)).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("filter-key").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("keyfn"), lang.NewSymbol("pred"), lang.NewSymbol("amap"))), lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4115), lang.NewKeyword("end-line"), int(4117), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -34470,123 +34568,123 @@ func init() { _ = v4 v5 := args[2] _ = v5 - var v6 any + var tmp6 any { // let // let binding "ret" - v7 := lang.NewMap() - v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4118), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(4118), lang.NewKeyword("end-column"), int(17)) - v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) + tmp7 := lang.NewMap() + tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4118), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(4118), lang.NewKeyword("end-column"), int(17)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) if err != nil { panic(err) } - var v10 any = v9 + var v10 any = tmp9 _ = v10 // let binding "es" - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("seq")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{v5}) - var v15 any = v14 + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("seq")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{v5}) + var v15 any = tmp14 _ = v15 for { - var v16 any + var tmp16 any if lang.IsTruthy(v15) { - var v17 any - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("first")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.Apply(v20, []any{v15}) - v22 := lang.Apply(v3, []any{v21}) - v23 := lang.Apply(v4, []any{v22}) - if lang.IsTruthy(v23) { - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("assoc")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("key")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("first")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{v15}) - v35 := lang.Apply(v30, []any{v34}) - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("val")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v40 := v39.FindInternedVar(lang.NewSymbol("first")) - if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) - } - v41 := v40.Get() - v42 := lang.Apply(v41, []any{v15}) - v43 := lang.Apply(v38, []any{v42}) - v44 := lang.Apply(v27, []any{v10, v35, v43}) - var v24 any = v44 - v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v47 := v46.FindInternedVar(lang.NewSymbol("next")) - if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) - } - v48 := v47.Get() - v49 := lang.Apply(v48, []any{v15}) - var v45 any = v49 - v10 = v24 - v15 = v45 + var tmp17 any + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("first")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.Apply(tmp20, []any{v15}) + tmp22 := lang.Apply(v3, []any{tmp21}) + tmp23 := lang.Apply(v4, []any{tmp22}) + if lang.IsTruthy(tmp23) { + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("assoc")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("key")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("first")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{v15}) + tmp35 := lang.Apply(tmp30, []any{tmp34}) + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("val")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp40 := tmp39.FindInternedVar(lang.NewSymbol("first")) + if tmp40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) + } + tmp41 := tmp40.Get() + tmp42 := lang.Apply(tmp41, []any{v15}) + tmp43 := lang.Apply(tmp38, []any{tmp42}) + tmp44 := lang.Apply(tmp27, []any{v10, tmp35, tmp43}) + var tmp24 any = tmp44 + tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp47 := tmp46.FindInternedVar(lang.NewSymbol("next")) + if tmp47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) + } + tmp48 := tmp47.Get() + tmp49 := lang.Apply(tmp48, []any{v15}) + var tmp45 any = tmp49 + v10 = tmp24 + v15 = tmp45 continue } else { - var v50 any = v10 - v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v53 := v52.FindInternedVar(lang.NewSymbol("next")) - if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) - } - v54 := v53.Get() - v55 := lang.Apply(v54, []any{v15}) - var v51 any = v55 - v10 = v50 - v15 = v51 + var tmp50 any = v10 + tmp52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp53 := tmp52.FindInternedVar(lang.NewSymbol("next")) + if tmp53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp53))) + } + tmp54 := tmp53.Get() + tmp55 := lang.Apply(tmp54, []any{v15}) + var tmp51 any = tmp55 + v10 = tmp50 + v15 = tmp51 continue } - v16 = v17 + tmp16 = tmp17 } else { - v16 = v10 + tmp16 = v10 } - v6 = v16 + tmp6 = tmp16 break } } // end let - return v6 + return tmp6 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // filterv { - v0 := lang.NewSymbol("filterv").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a vector of the items in coll for which\n (pred item) returns logical true. pred must be free of side-effects.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6961), lang.NewKeyword("end-line"), int(6961))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("filterv").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a vector of the items in coll for which\n (pred item) returns logical true. pred must be free of side-effects.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6961), lang.NewKeyword("end-line"), int(6961))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -34594,20 +34692,20 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("persistent!")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("reduce")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - var v11 lang.FnFunc - v11 = lang.NewFnFunc(func(args ...any) any { + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("persistent!")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("reduce")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -34615,55 +34713,55 @@ func init() { _ = v12 v13 := args[1] _ = v13 - var v14 any - v15 := lang.Apply(v3, []any{v13}) - if lang.IsTruthy(v15) { - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("conj!")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{v12, v13}) - v14 = v19 + var tmp14 any + tmp15 := lang.Apply(v3, []any{v13}) + if lang.IsTruthy(tmp15) { + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("conj!")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{v12, v13}) + tmp14 = tmp19 } else { - v14 = v12 + tmp14 = v12 } - return v14 + return tmp14 }) - v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6967), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(6967), lang.NewKeyword("end-column"), int(52)) - v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) + tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6967), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(6967), lang.NewKeyword("end-column"), int(52)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) if err != nil { panic(err) } - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("transient")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("transient")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) } - v16 := v15.Get() - v17 := lang.NewVector() - v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6968), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(6968), lang.NewKeyword("end-column"), int(27)) - v19, err := lang.WithMeta(v17, v18.(lang.IPersistentMap)) + tmp16 := tmp15.Get() + tmp17 := lang.NewVector() + tmp18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6968), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(6968), lang.NewKeyword("end-column"), int(27)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) if err != nil { panic(err) } - v20 := lang.Apply(v16, []any{v19}) - v21 := lang.Apply(v10, []any{v13, v20, v4}) - v22 := lang.Apply(v7, []any{v21}) - return v22 + tmp20 := lang.Apply(tmp16, []any{tmp19}) + tmp21 := lang.Apply(tmp10, []any{tmp13, tmp20, v4}) + tmp22 := lang.Apply(tmp7, []any{tmp21}) + return tmp22 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // find { - v0 := lang.NewSymbol("find").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"))), lang.NewKeyword("doc"), "Returns the map entry for key, or nil if key not present.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1530), lang.NewKeyword("end-line"), int(1530))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("find").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"))), lang.NewKeyword("doc"), "Returns the map entry for key, or nil if key not present.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1530), lang.NewKeyword("end-line"), int(1530))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -34671,680 +34769,684 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5, _ := lang.FieldOrMethod(runtime4.RT, "Find") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(runtime4.RT, "Find") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Find is not a function"))) } - v6 := lang.Apply(v5, []any{v3, v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // find-keyword { - v1 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() - v0 := lang.NewSymbol("find-keyword").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name"))), lang.NewKeyword("doc"), "Returns a Keyword with the given namespace and name if one already\n exists. This function will not intern a new keyword. If the keyword\n has not already been interned, it will return nil. Do not use :\n in the keyword strings, it will be added automatically.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(618), lang.NewKeyword("end-line"), int(618))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp1 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() + tmp0 := lang.NewSymbol("find-keyword").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name"))), lang.NewKeyword("doc"), "Returns a Keyword with the given namespace and name if one already\n exists. This function will not intern a new keyword. If the keyword\n has not already been interned, it will return nil. Do not use :\n in the keyword strings, it will be added automatically.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(618), lang.NewKeyword("end-line"), int(618))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v4 := args[0] _ = v4 - var v5 any - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("keyword?")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{v4}) - if lang.IsTruthy(v9) { - v5 = v4 + var tmp5 any + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("keyword?")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.Apply(tmp8, []any{v4}) + if lang.IsTruthy(tmp9) { + tmp5 = v4 } else { - var v10 any - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("symbol?")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{v4}) - if lang.IsTruthy(v14) { - v15 := lang.Apply(nil, []any{v4}) - v10 = v15 + var tmp10 any + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("symbol?")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{v4}) + if lang.IsTruthy(tmp14) { + tmp15 := lang.Apply(nil, []any{v4}) + tmp10 = tmp15 } else { - var v16 any - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("string?")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.Apply(v19, []any{v4}) - if lang.IsTruthy(v20) { - v21 := lang.Apply(nil, []any{v4}) - v16 = v21 + var tmp16 any + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("string?")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.Apply(tmp19, []any{v4}) + if lang.IsTruthy(tmp20) { + tmp21 := lang.Apply(nil, []any{v4}) + tmp16 = tmp21 } else { - v16 = nil } - v10 = v16 + tmp10 = tmp16 } - v5 = v10 + tmp5 = tmp10 } - return v5 + return tmp5 case 2: v4 := args[0] _ = v4 v5 := args[1] _ = v5 - v6 := lang.Apply(nil, []any{v4, v5}) - return v6 + tmp6 := lang.Apply(nil, []any{v4, v5}) + return tmp6 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v4 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp4 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // find-ns { - v0 := lang.NewSymbol("find-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Returns the namespace named by the symbol or nil if it doesn't exist.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4125), lang.NewKeyword("end-line"), int(4125))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("find-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Returns the namespace named by the symbol or nil if it doesn't exist.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4125), lang.NewKeyword("end-line"), int(4125))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.Apply(lang.FindNamespace, []any{v3}) - return v4 + tmp4 := lang.Apply(lang.FindNamespace, []any{v3}) + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // find-var { - v0 := lang.NewSymbol("find-var").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Returns the global var named by the namespace-qualified symbol, or\n nil if no var with that name.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2013), lang.NewKeyword("end-line"), int(2013))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("find-var").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Returns the global var named by the namespace-qualified symbol, or\n nil if no var with that name.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2013), lang.NewKeyword("end-line"), int(2013))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4, _ := lang.FieldOrMethod(runtime4.RT, "FindVar") - if reflect.TypeOf(v4).Kind() != reflect.Func { + tmp4, _ := lang.FieldOrMethod(runtime4.RT, "FindVar") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("FindVar is not a function"))) } - v5 := lang.Apply(v4, []any{v3}) - return v5 + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // first { - v0 := lang.NewSymbol("first").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns the first item in the collection. Calls seq on its\n argument. If coll is nil, returns nil.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(47), lang.NewKeyword("end-line"), int(52))).(*lang.Symbol) - var v2 lang.FnFunc + tmp0 := lang.NewSymbol("first").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns the first item in the collection. Calls seq on its\n argument. If coll is nil, returns nil.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(47), lang.NewKeyword("end-line"), int(52))).(*lang.Symbol) + var tmp2 lang.FnFunc { // function first - v2 = lang.NewFnFunc(func(args ...any) any { + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5 := lang.Apply(lang.First, []any{v4}) - return v5 + tmp5 := lang.Apply(lang.First, []any{v4}) + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(52), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(52), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) - v3 := v2 + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(52), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(52), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + v3 = tmp2 _ = v3 } - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // fits-table? { - v0 := lang.NewSymbol("fits-table?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ints"))), lang.NewKeyword("doc"), "Returns true if the collection of ints can fit within the\n max-table-switch-size, false otherwise.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6625), lang.NewKeyword("end-line"), int(6625), lang.NewKeyword("private"), true)).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("fits-table?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ints"))), lang.NewKeyword("doc"), "Returns true if the collection of ints can fit within the\n max-table-switch-size, false otherwise.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6625), lang.NewKeyword("end-line"), int(6625), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("<")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("-")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("apply")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("max")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("seq")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{v3}) - v20 := lang.Apply(v12, []any{v15, v19}) - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("apply")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("min")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("seq")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{v3}) - v31 := lang.Apply(v23, []any{v26, v30}) - v32 := lang.Apply(v9, []any{v20, v31}) - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("max-switch-table-size")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - v36 := lang.Apply(v6, []any{v32, v35}) - return v36 - }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("<")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("-")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("apply")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("max")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("seq")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{v3}) + tmp20 := lang.Apply(tmp12, []any{tmp15, tmp19}) + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("apply")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("min")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("seq")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{v3}) + tmp31 := lang.Apply(tmp23, []any{tmp26, tmp30}) + tmp32 := lang.Apply(tmp9, []any{tmp20, tmp31}) + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("max-switch-table-size")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) + } + tmp35 := tmp34.Get() + tmp36 := lang.Apply(tmp6, []any{tmp32, tmp35}) + return tmp36 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // flatten { - v0 := lang.NewSymbol("flatten").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Takes any nested combination of sequential things (lists, vectors,\n etc.) and returns their contents as a single, flat lazy sequence.\n (flatten nil) returns an empty sequence.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7118), lang.NewKeyword("end-line"), int(7118))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("flatten").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Takes any nested combination of sequential things (lists, vectors,\n etc.) and returns their contents as a single, flat lazy sequence.\n (flatten nil) returns an empty sequence.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7118), lang.NewKeyword("end-line"), int(7118))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("filter")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("complement")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("sequential?")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v9, []any{v12}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("rest")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("tree-seq")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("sequential?")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("seq")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.Apply(v19, []any{v22, v25, v3}) - v27 := lang.Apply(v16, []any{v26}) - v28 := lang.Apply(v6, []any{v13, v27}) - return v28 - }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("filter")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("complement")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("sequential?")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp9, []any{tmp12}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("rest")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("tree-seq")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("sequential?")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("seq")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.Apply(tmp19, []any{tmp22, tmp25, v3}) + tmp27 := lang.Apply(tmp16, []any{tmp26}) + tmp28 := lang.Apply(tmp6, []any{tmp13, tmp27}) + return tmp28 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // float { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function float__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("concat")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("list")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("seq")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("concat")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - var v30 any - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - if lang.IsTruthy(v33) { - v30 = lang.NewSymbol("uncheckedFloatCast") + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + var tmp30 any + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + if lang.IsTruthy(tmp33) { + tmp30 = lang.NewSymbol("uncheckedFloatCast") } else { - v30 = lang.NewSymbol("floatCast") - } - v34 := lang.Apply(v29, []any{v30}) - v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v36 := v35.FindInternedVar(lang.NewSymbol("list")) - if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) - } - v37 := v36.Get() - v38 := lang.Apply(v37, []any{v3}) - v39 := lang.Apply(v26, []any{v34, v38}) - v40 := lang.Apply(v23, []any{v39}) - v41 := lang.Apply(v20, []any{v40}) - v42 := lang.Apply(v9, []any{v13, v17, v41}) - v43 := lang.Apply(v6, []any{v42}) - return v43 + tmp30 = lang.NewSymbol("floatCast") + } + tmp34 := lang.Apply(tmp29, []any{tmp30}) + tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp36 := tmp35.FindInternedVar(lang.NewSymbol("list")) + if tmp36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) + } + tmp37 := tmp36.Get() + tmp38 := lang.Apply(tmp37, []any{v3}) + tmp39 := lang.Apply(tmp26, []any{tmp34, tmp38}) + tmp40 := lang.Apply(tmp23, []any{tmp39}) + tmp41 := lang.Apply(tmp20, []any{tmp40}) + tmp42 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp41}) + tmp43 := lang.Apply(tmp6, []any{tmp42}) + return tmp43 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("float").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to float", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3487), lang.NewKeyword("end-line"), int(3487))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("float").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to float", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3487), lang.NewKeyword("end-line"), int(3487))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5 := lang.Apply(lang.FloatCast, []any{v4}) - return v5 + tmp5 := lang.Apply(lang.FloatCast, []any{v4}) + return tmp5 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // float-array { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function float-array__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v3 := lang.NewList(args[0:]...) - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("concat")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("list")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/FloatArray")}) - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("list")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("seq")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("concat")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) - v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v36 := v35.FindInternedVar(lang.NewSymbol("list")) - if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) - } - v37 := v36.Get() - v38 := lang.Apply(v37, []any{lang.NewSymbol("glojure.core/args")}) - v39 := lang.Apply(v30, []any{v34, v38}) - v40 := lang.Apply(v27, []any{v39}) - v41 := lang.Apply(v24, []any{v40}) - v42 := lang.Apply(v9, []any{v13, v17, v21, v41}) - v43 := lang.Apply(v6, []any{v42}) - return v43 + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.Apply(tmp20, []any{lang.NewSymbol("glojure.core/FloatArray")}) + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("list")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("seq")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("concat")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) + tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp36 := tmp35.FindInternedVar(lang.NewSymbol("list")) + if tmp36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) + } + tmp37 := tmp36.Get() + tmp38 := lang.Apply(tmp37, []any{lang.NewSymbol("glojure.core/args")}) + tmp39 := lang.Apply(tmp30, []any{tmp34, tmp38}) + tmp40 := lang.Apply(tmp27, []any{tmp39}) + tmp41 := lang.Apply(tmp24, []any{tmp40}) + tmp42 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp21, tmp41}) + tmp43 := lang.Apply(tmp6, []any{tmp42}) + return tmp43 } }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("float-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Creates an array of floats", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1), int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5301), lang.NewKeyword("end-line"), int(5301))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("float-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Creates an array of floats", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5301), lang.NewKeyword("end-line"), int(5301))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v4 := args[0] _ = v4 - v5, _ := lang.FieldOrMethod(lang.Numbers, "FloatArray") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "FloatArray") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("FloatArray is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 case 2: v4 := args[0] _ = v4 v5 := args[1] _ = v5 - v6, _ := lang.FieldOrMethod(lang.Numbers, "FloatArrayInit") - if reflect.TypeOf(v6).Kind() != reflect.Func { + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "FloatArrayInit") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("FloatArrayInit is not a function"))) } - v7 := lang.Apply(v6, []any{v4, v5}) - return v7 + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // float? { - v0 := lang.NewSymbol("float?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is a floating point number", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3605), lang.NewKeyword("end-line"), int(3605))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("float?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is a floating point number", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3605), lang.NewKeyword("end-line"), int(3605))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any + var tmp4 any { // let // let binding "or__0__auto__" - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{lang.Builtins["float64"], v3}) - var v9 any = v8 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("instance?")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{lang.Builtins["float64"], v3}) + var v9 any = tmp8 _ = v9 - var v10 any + var tmp10 any if lang.IsTruthy(v9) { - v10 = v9 + tmp10 = v9 } else { - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("instance?")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("instance?")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{lang.Builtins["float32"], v3}) - v10 = v14 + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{lang.Builtins["float32"], v3}) + tmp10 = tmp14 } - v4 = v10 + tmp4 = tmp10 } // end let - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // floats { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function floats - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("concat")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("list")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/Floats")}) - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("list")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v3}) - v26 := lang.Apply(v9, []any{v13, v17, v21, v25}) - v27 := lang.Apply(v6, []any{v26}) - return v27 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.Apply(tmp20, []any{lang.NewSymbol("glojure.core/Floats")}) + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("list")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.Apply(tmp24, []any{v3}) + tmp26 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp21, tmp25}) + tmp27 := lang.Apply(tmp6, []any{tmp26}) + return tmp27 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("floats").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Casts to float[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5392), lang.NewKeyword("end-line"), int(5392))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("floats").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Casts to float[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5392), lang.NewKeyword("end-line"), int(5392))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5, _ := lang.FieldOrMethod(lang.Numbers, "Floats") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Floats") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Floats is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // flush { - v0 := lang.NewSymbol("flush").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Flushes the output stream that is the current value of\n *out*", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3706), lang.NewKeyword("end-line"), int(3706))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("flush").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Flushes the output stream that is the current value of\n *out*", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3706), lang.NewKeyword("end-line"), int(3706))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v4 := v3.FindInternedVar(lang.NewSymbol("*out*")) - if v4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) + tmp3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp4 := tmp3.FindInternedVar(lang.NewSymbol("*out*")) + if tmp4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp4))) } - v5 := v4.Get() - v6, _ := lang.FieldOrMethod(v5, "Sync") - if reflect.TypeOf(v6).Kind() != reflect.Func { + tmp5 := tmp4.Get() + tmp6, _ := lang.FieldOrMethod(tmp5, "Sync") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Sync is not a function"))) } - v7 := lang.Apply(v6, []any{}) - _ = v7 + tmp7 := lang.Apply(tmp6, []any{}) + _ = tmp7 return nil }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // fn { - v0 := lang.NewSymbol("fn").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("sigs"))), lang.NewKeyword("doc"), "params => positional-params*, or positional-params* & rest-param\n positional-param => binding-form\n rest-param => binding-form\n binding-form => name, or destructuring-form\n\n Defines a function.\n\n See https://glojure.org/reference/special_forms#fn for more information", lang.NewKeyword("forms"), lang.NewVector(lang.NewList(lang.NewSymbol("fn"), lang.NewSymbol("name?"), lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("exprs*")), lang.NewList(lang.NewSymbol("fn"), lang.NewSymbol("name?"), lang.NewList(lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("exprs*")), lang.NewSymbol("+"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4533), lang.NewKeyword("end-line"), int(4533), lang.NewKeyword("special-form"), true)).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("fn").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("sigs"))), lang.NewKeyword("doc"), "params => positional-params*, or positional-params* & rest-param\n positional-param => binding-form\n rest-param => binding-form\n binding-form => name, or destructuring-form\n\n Defines a function.\n\n See https://glojure.org/reference/special_forms#fn for more information", lang.NewKeyword("forms"), lang.NewVector(lang.NewList(lang.NewSymbol("fn"), lang.NewSymbol("name?"), lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("exprs*")), lang.NewList(lang.NewSymbol("fn"), lang.NewSymbol("name?"), lang.NewList(lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("exprs*")), lang.NewSymbol("+"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4533), lang.NewKeyword("end-line"), int(4533), lang.NewKeyword("special-form"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 2 { @@ -35354,211 +35456,210 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.NewList(args[2:]...) - var v6 any + var v5 any = lang.NewList(args[2:]...) + _ = v5 + var tmp6 any { // let // let binding "name" - var v7 any - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("symbol?")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("first")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{v5}) - v15 := lang.Apply(v10, []any{v14}) - if lang.IsTruthy(v15) { - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("first")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{v5}) - v7 = v19 + var tmp7 any + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("symbol?")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("first")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{v5}) + tmp15 := lang.Apply(tmp10, []any{tmp14}) + if lang.IsTruthy(tmp15) { + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("first")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{v5}) + tmp7 = tmp19 } else { - v7 = nil } - var v20 any = v7 + var v20 any = tmp7 _ = v20 // let binding "sigs" - var v21 any + var tmp21 any if lang.IsTruthy(v20) { - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("next")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v5}) - v21 = v25 + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("next")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.Apply(tmp24, []any{v5}) + tmp21 = tmp25 } else { - v21 = v5 + tmp21 = v5 } - var v26 any = v21 + var v26 any = tmp21 _ = v26 // let binding "sigs" - var v27 any - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("vector?")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("first")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{v26}) - v35 := lang.Apply(v30, []any{v34}) - if lang.IsTruthy(v35) { - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("list")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.Apply(v38, []any{v26}) - v27 = v39 + var tmp27 any + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("vector?")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("first")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{v26}) + tmp35 := lang.Apply(tmp30, []any{tmp34}) + if lang.IsTruthy(tmp35) { + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{v26}) + tmp27 = tmp39 } else { - var v40 any - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("seq?")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) - } - v43 := v42.Get() - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("first")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) - } - v46 := v45.Get() - v47 := lang.Apply(v46, []any{v26}) - v48 := lang.Apply(v43, []any{v47}) - if lang.IsTruthy(v48) { - v40 = v26 + var tmp40 any + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("seq?")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("first")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) + } + tmp46 := tmp45.Get() + tmp47 := lang.Apply(tmp46, []any{v26}) + tmp48 := lang.Apply(tmp43, []any{tmp47}) + if lang.IsTruthy(tmp48) { + tmp40 = v26 } else { - var v49 any - v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v51 := v50.FindInternedVar(lang.NewSymbol("seq")) - if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) - } - v52 := v51.Get() - v53 := lang.Apply(v52, []any{v26}) - if lang.IsTruthy(v53) { - v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v55 := v54.FindInternedVar(lang.NewSymbol("str")) - if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) + var tmp49 any + tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp51 := tmp50.FindInternedVar(lang.NewSymbol("seq")) + if tmp51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) + } + tmp52 := tmp51.Get() + tmp53 := lang.Apply(tmp52, []any{v26}) + if lang.IsTruthy(tmp53) { + tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp55 := tmp54.FindInternedVar(lang.NewSymbol("str")) + if tmp55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) } - v56 := v55.Get() - v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v58 := v57.FindInternedVar(lang.NewSymbol("first")) - if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) + tmp56 := tmp55.Get() + tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp58 := tmp57.FindInternedVar(lang.NewSymbol("first")) + if tmp58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) } - v59 := v58.Get() - v60 := lang.Apply(v59, []any{v26}) - v61 := lang.Apply(v56, []any{"Parameter declaration ", v60, " should be a vector"}) - v49 = v61 + tmp59 := tmp58.Get() + tmp60 := lang.Apply(tmp59, []any{v26}) + tmp61 := lang.Apply(tmp56, []any{"Parameter declaration ", tmp60, " should be a vector"}) + tmp49 = tmp61 } else { - v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v63 := v62.FindInternedVar(lang.NewSymbol("str")) - if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) + tmp62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp63 := tmp62.FindInternedVar(lang.NewSymbol("str")) + if tmp63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp63))) } - v64 := v63.Get() - v65 := lang.Apply(v64, []any{"Parameter declaration missing"}) - v49 = v65 + tmp64 := tmp63.Get() + tmp65 := lang.Apply(tmp64, []any{"Parameter declaration missing"}) + tmp49 = tmp65 } - v66 := lang.Apply(lang.NewIllegalArgumentError, []any{v49}) - panic(v66) + tmp66 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp49}) + panic(tmp66) } - v27 = v40 + tmp27 = tmp40 } - var v67 any = v27 + var v67 any = tmp27 _ = v67 // let binding "psig" - var v68 lang.FnFunc - v68 = lang.NewFnFunc(func(args ...any) any { + var tmp68 lang.FnFunc + tmp68 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v69 := args[0] _ = v69 - var v70 any - v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v72 := v71.FindInternedVar(lang.NewSymbol("not")) - if v72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) - } - v73 := v72.Get() - v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v75 := v74.FindInternedVar(lang.NewSymbol("seq?")) - if v75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) - } - v76 := v75.Get() - v77 := lang.Apply(v76, []any{v69}) - v78 := lang.Apply(v73, []any{v77}) - if lang.IsTruthy(v78) { - v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v80 := v79.FindInternedVar(lang.NewSymbol("str")) - if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) - } - v81 := v80.Get() - v82 := lang.Apply(v81, []any{"Invalid signature ", v69, " should be a list"}) - v83 := lang.Apply(lang.NewIllegalArgumentError, []any{v82}) - panic(v83) + var tmp70 any + tmp71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp72 := tmp71.FindInternedVar(lang.NewSymbol("not")) + if tmp72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp72))) + } + tmp73 := tmp72.Get() + tmp74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp75 := tmp74.FindInternedVar(lang.NewSymbol("seq?")) + if tmp75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp75))) + } + tmp76 := tmp75.Get() + tmp77 := lang.Apply(tmp76, []any{v69}) + tmp78 := lang.Apply(tmp73, []any{tmp77}) + if lang.IsTruthy(tmp78) { + tmp79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp80 := tmp79.FindInternedVar(lang.NewSymbol("str")) + if tmp80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp80))) + } + tmp81 := tmp80.Get() + tmp82 := lang.Apply(tmp81, []any{"Invalid signature ", v69, " should be a list"}) + tmp83 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp82}) + panic(tmp83) } else { - v70 = nil } - _ = v70 - var v84 any + _ = tmp70 + var tmp84 any { // let // let binding "vec__13" var v85 any = v69 _ = v85 // let binding "seq__14" - v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v87 := v86.FindInternedVar(lang.NewSymbol("seq")) - if v87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) - } - v88 := v87.Get() - v89 := lang.Apply(v88, []any{v85}) - var v90 any = v89 + tmp86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp87 := tmp86.FindInternedVar(lang.NewSymbol("seq")) + if tmp87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp87))) + } + tmp88 := tmp87.Get() + tmp89 := lang.Apply(tmp88, []any{v85}) + var v90 any = tmp89 _ = v90 // let binding "first__15" - v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v92 := v91.FindInternedVar(lang.NewSymbol("first")) - if v92.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) - } - v93 := v92.Get() - v94 := lang.Apply(v93, []any{v90}) - var v95 any = v94 + tmp91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp92 := tmp91.FindInternedVar(lang.NewSymbol("first")) + if tmp92.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp92))) + } + tmp93 := tmp92.Get() + tmp94 := lang.Apply(tmp93, []any{v90}) + var v95 any = tmp94 _ = v95 // let binding "seq__14" - v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v97 := v96.FindInternedVar(lang.NewSymbol("next")) - if v97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) - } - v98 := v97.Get() - v99 := lang.Apply(v98, []any{v90}) - var v100 any = v99 + tmp96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp97 := tmp96.FindInternedVar(lang.NewSymbol("next")) + if tmp97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp97))) + } + tmp98 := tmp97.Get() + tmp99 := lang.Apply(tmp98, []any{v90}) + var v100 any = tmp99 _ = v100 // let binding "params" var v101 any = v95 @@ -35567,614 +35668,614 @@ func init() { var v102 any = v100 _ = v102 // let binding "_" - var v103 any - v104 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v105 := v104.FindInternedVar(lang.NewSymbol("not")) - if v105.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v105))) - } - v106 := v105.Get() - v107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v108 := v107.FindInternedVar(lang.NewSymbol("vector?")) - if v108.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v108))) - } - v109 := v108.Get() - v110 := lang.Apply(v109, []any{v101}) - v111 := lang.Apply(v106, []any{v110}) - if lang.IsTruthy(v111) { - var v112 any - v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v114 := v113.FindInternedVar(lang.NewSymbol("seq?")) - if v114.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) + var tmp103 any + tmp104 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp105 := tmp104.FindInternedVar(lang.NewSymbol("not")) + if tmp105.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp105))) + } + tmp106 := tmp105.Get() + tmp107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp108 := tmp107.FindInternedVar(lang.NewSymbol("vector?")) + if tmp108.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp108))) + } + tmp109 := tmp108.Get() + tmp110 := lang.Apply(tmp109, []any{v101}) + tmp111 := lang.Apply(tmp106, []any{tmp110}) + if lang.IsTruthy(tmp111) { + var tmp112 any + tmp113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp114 := tmp113.FindInternedVar(lang.NewSymbol("seq?")) + if tmp114.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp114))) } - v115 := v114.Get() - v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v117 := v116.FindInternedVar(lang.NewSymbol("first")) - if v117.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) + tmp115 := tmp114.Get() + tmp116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp117 := tmp116.FindInternedVar(lang.NewSymbol("first")) + if tmp117.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp117))) } - v118 := v117.Get() - v119 := lang.Apply(v118, []any{v67}) - v120 := lang.Apply(v115, []any{v119}) - if lang.IsTruthy(v120) { - v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v122 := v121.FindInternedVar(lang.NewSymbol("str")) - if v122.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) + tmp118 := tmp117.Get() + tmp119 := lang.Apply(tmp118, []any{v67}) + tmp120 := lang.Apply(tmp115, []any{tmp119}) + if lang.IsTruthy(tmp120) { + tmp121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp122 := tmp121.FindInternedVar(lang.NewSymbol("str")) + if tmp122.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp122))) } - v123 := v122.Get() - v124 := lang.Apply(v123, []any{"Parameter declaration ", v101, " should be a vector"}) - v112 = v124 + tmp123 := tmp122.Get() + tmp124 := lang.Apply(tmp123, []any{"Parameter declaration ", v101, " should be a vector"}) + tmp112 = tmp124 } else { - v125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v126 := v125.FindInternedVar(lang.NewSymbol("str")) - if v126.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v126))) + tmp125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp126 := tmp125.FindInternedVar(lang.NewSymbol("str")) + if tmp126.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp126))) } - v127 := v126.Get() - v128 := lang.Apply(v127, []any{"Invalid signature ", v69, " should be a list"}) - v112 = v128 + tmp127 := tmp126.Get() + tmp128 := lang.Apply(tmp127, []any{"Invalid signature ", v69, " should be a list"}) + tmp112 = tmp128 } - v129 := lang.Apply(lang.NewIllegalArgumentError, []any{v112}) - panic(v129) + tmp129 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp112}) + panic(tmp129) } else { - v103 = nil } - var v130 any = v103 + var v130 any = tmp103 _ = v130 // let binding "conds" - var v131 any - var v132 any + var tmp131 any + var tmp132 any { // let // let binding "and__0__auto__" - v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v134 := v133.FindInternedVar(lang.NewSymbol("next")) - if v134.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) + tmp133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp134 := tmp133.FindInternedVar(lang.NewSymbol("next")) + if tmp134.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp134))) } - v135 := v134.Get() - v136 := lang.Apply(v135, []any{v102}) - var v137 any = v136 + tmp135 := tmp134.Get() + tmp136 := lang.Apply(tmp135, []any{v102}) + var v137 any = tmp136 _ = v137 - var v138 any + var tmp138 any if lang.IsTruthy(v137) { - v139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v140 := v139.FindInternedVar(lang.NewSymbol("map?")) - if v140.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v140))) + tmp139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp140 := tmp139.FindInternedVar(lang.NewSymbol("map?")) + if tmp140.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp140))) } - v141 := v140.Get() - v142 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v143 := v142.FindInternedVar(lang.NewSymbol("first")) - if v143.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v143))) + tmp141 := tmp140.Get() + tmp142 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp143 := tmp142.FindInternedVar(lang.NewSymbol("first")) + if tmp143.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp143))) } - v144 := v143.Get() - v145 := lang.Apply(v144, []any{v102}) - v146 := lang.Apply(v141, []any{v145}) - v138 = v146 + tmp144 := tmp143.Get() + tmp145 := lang.Apply(tmp144, []any{v102}) + tmp146 := lang.Apply(tmp141, []any{tmp145}) + tmp138 = tmp146 } else { - v138 = v137 + tmp138 = v137 } - v132 = v138 + tmp132 = tmp138 } // end let - if lang.IsTruthy(v132) { - v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v134 := v133.FindInternedVar(lang.NewSymbol("first")) - if v134.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) + if lang.IsTruthy(tmp132) { + tmp133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp134 := tmp133.FindInternedVar(lang.NewSymbol("first")) + if tmp134.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp134))) } - v135 := v134.Get() - v136 := lang.Apply(v135, []any{v102}) - v131 = v136 + tmp135 := tmp134.Get() + tmp136 := lang.Apply(tmp135, []any{v102}) + tmp131 = tmp136 } else { - v131 = nil } - var v137 any = v131 + var v137 any = tmp131 _ = v137 // let binding "body" - var v138 any + var tmp138 any if lang.IsTruthy(v137) { - v139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v140 := v139.FindInternedVar(lang.NewSymbol("next")) - if v140.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v140))) + tmp139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp140 := tmp139.FindInternedVar(lang.NewSymbol("next")) + if tmp140.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp140))) } - v141 := v140.Get() - v142 := lang.Apply(v141, []any{v102}) - v138 = v142 + tmp141 := tmp140.Get() + tmp142 := lang.Apply(tmp141, []any{v102}) + tmp138 = tmp142 } else { - v138 = v102 + tmp138 = v102 } - var v143 any = v138 + var v143 any = tmp138 _ = v143 // let binding "conds" - var v144 any + var tmp144 any { // let // let binding "or__0__auto__" var v145 any = v137 _ = v145 - var v146 any + var tmp146 any if lang.IsTruthy(v145) { - v146 = v145 + tmp146 = v145 } else { - v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v148 := v147.FindInternedVar(lang.NewSymbol("meta")) - if v148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) + tmp147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp148 := tmp147.FindInternedVar(lang.NewSymbol("meta")) + if tmp148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp148))) } - v149 := v148.Get() - v150 := lang.Apply(v149, []any{v101}) - v146 = v150 + tmp149 := tmp148.Get() + tmp150 := lang.Apply(tmp149, []any{v101}) + tmp146 = tmp150 } - v144 = v146 + tmp144 = tmp146 } // end let - var v145 any = v144 + var v145 any = tmp144 _ = v145 // let binding "pre" - v146 := lang.Apply(lang.NewKeyword("pre"), []any{v145}) - var v147 any = v146 + tmp146 := lang.Apply(lang.NewKeyword("pre"), []any{v145}) + var v147 any = tmp146 _ = v147 // let binding "post" - v148 := lang.Apply(lang.NewKeyword("post"), []any{v145}) - var v149 any = v148 + tmp148 := lang.Apply(lang.NewKeyword("post"), []any{v145}) + var v149 any = tmp148 _ = v149 // let binding "body" - var v150 any + var tmp150 any if lang.IsTruthy(v149) { - v151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v152 := v151.FindInternedVar(lang.NewSymbol("seq")) - if v152.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v152))) + tmp151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp152 := tmp151.FindInternedVar(lang.NewSymbol("seq")) + if tmp152.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp152))) } - v153 := v152.Get() - v154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v155 := v154.FindInternedVar(lang.NewSymbol("concat")) - if v155.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v155))) + tmp153 := tmp152.Get() + tmp154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp155 := tmp154.FindInternedVar(lang.NewSymbol("concat")) + if tmp155.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp155))) } - v156 := v155.Get() - v157 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v158 := v157.FindInternedVar(lang.NewSymbol("list")) - if v158.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v158))) + tmp156 := tmp155.Get() + tmp157 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp158 := tmp157.FindInternedVar(lang.NewSymbol("list")) + if tmp158.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp158))) } - v159 := v158.Get() - v160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v161 := v160.FindInternedVar(lang.NewSymbol("seq")) - if v161.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v161))) + tmp159 := tmp158.Get() + tmp160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp161 := tmp160.FindInternedVar(lang.NewSymbol("seq")) + if tmp161.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp161))) } - v162 := v161.Get() - v163 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v164 := v163.FindInternedVar(lang.NewSymbol("concat")) - if v164.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v164))) + tmp162 := tmp161.Get() + tmp163 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp164 := tmp163.FindInternedVar(lang.NewSymbol("concat")) + if tmp164.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp164))) } - v165 := v164.Get() - v166 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v167 := v166.FindInternedVar(lang.NewSymbol("list")) - if v167.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v167))) + tmp165 := tmp164.Get() + tmp166 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp167 := tmp166.FindInternedVar(lang.NewSymbol("list")) + if tmp167.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp167))) } - v168 := v167.Get() - v169 := lang.Apply(v168, []any{lang.NewSymbol("glojure.core/let")}) - v170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v171 := v170.FindInternedVar(lang.NewSymbol("list")) - if v171.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v171))) + tmp168 := tmp167.Get() + tmp169 := lang.Apply(tmp168, []any{lang.NewSymbol("glojure.core/let")}) + tmp170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp171 := tmp170.FindInternedVar(lang.NewSymbol("list")) + if tmp171.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp171))) } - v172 := v171.Get() - v173 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v174 := v173.FindInternedVar(lang.NewSymbol("apply")) - if v174.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v174))) + tmp172 := tmp171.Get() + tmp173 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp174 := tmp173.FindInternedVar(lang.NewSymbol("apply")) + if tmp174.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp174))) } - v175 := v174.Get() - v176 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v177 := v176.FindInternedVar(lang.NewSymbol("vector")) - if v177.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v177))) + tmp175 := tmp174.Get() + tmp176 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp177 := tmp176.FindInternedVar(lang.NewSymbol("vector")) + if tmp177.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp177))) } - v178 := v177.Get() - v179 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v180 := v179.FindInternedVar(lang.NewSymbol("seq")) - if v180.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v180))) + tmp178 := tmp177.Get() + tmp179 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp180 := tmp179.FindInternedVar(lang.NewSymbol("seq")) + if tmp180.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp180))) } - v181 := v180.Get() - v182 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v183 := v182.FindInternedVar(lang.NewSymbol("concat")) - if v183.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v183))) + tmp181 := tmp180.Get() + tmp182 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp183 := tmp182.FindInternedVar(lang.NewSymbol("concat")) + if tmp183.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp183))) } - v184 := v183.Get() - v185 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v186 := v185.FindInternedVar(lang.NewSymbol("list")) - if v186.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v186))) + tmp184 := tmp183.Get() + tmp185 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp186 := tmp185.FindInternedVar(lang.NewSymbol("list")) + if tmp186.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp186))) } - v187 := v186.Get() - v188 := lang.Apply(v187, []any{lang.NewSymbol("%")}) - v189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v190 := v189.FindInternedVar(lang.NewSymbol("list")) - if v190.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v190))) + tmp187 := tmp186.Get() + tmp188 := lang.Apply(tmp187, []any{lang.NewSymbol("%")}) + tmp189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp190 := tmp189.FindInternedVar(lang.NewSymbol("list")) + if tmp190.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp190))) } - v191 := v190.Get() - var v192 any - v193 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v194 := v193.FindInternedVar(lang.NewSymbol("<")) - if v194.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v194))) + tmp191 := tmp190.Get() + var tmp192 any + tmp193 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp194 := tmp193.FindInternedVar(lang.NewSymbol("<")) + if tmp194.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp194))) } - v195 := v194.Get() - v196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v197 := v196.FindInternedVar(lang.NewSymbol("count")) - if v197.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v197))) + tmp195 := tmp194.Get() + tmp196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp197 := tmp196.FindInternedVar(lang.NewSymbol("count")) + if tmp197.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp197))) } - v198 := v197.Get() - v199 := lang.Apply(v198, []any{v143}) - v200 := lang.Apply(v195, []any{int64(1), v199}) - if lang.IsTruthy(v200) { - v201 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v202 := v201.FindInternedVar(lang.NewSymbol("seq")) - if v202.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v202))) + tmp198 := tmp197.Get() + tmp199 := lang.Apply(tmp198, []any{v143}) + tmp200 := lang.Apply(tmp195, []any{int64(1), tmp199}) + if lang.IsTruthy(tmp200) { + tmp201 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp202 := tmp201.FindInternedVar(lang.NewSymbol("seq")) + if tmp202.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp202))) } - v203 := v202.Get() - v204 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v205 := v204.FindInternedVar(lang.NewSymbol("concat")) - if v205.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v205))) + tmp203 := tmp202.Get() + tmp204 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp205 := tmp204.FindInternedVar(lang.NewSymbol("concat")) + if tmp205.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp205))) } - v206 := v205.Get() - v207 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v208 := v207.FindInternedVar(lang.NewSymbol("list")) - if v208.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v208))) + tmp206 := tmp205.Get() + tmp207 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp208 := tmp207.FindInternedVar(lang.NewSymbol("list")) + if tmp208.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp208))) } - v209 := v208.Get() - v210 := lang.Apply(v209, []any{lang.NewSymbol("do")}) - v211 := lang.Apply(v206, []any{v210, v143}) - v212 := lang.Apply(v203, []any{v211}) - v192 = v212 + tmp209 := tmp208.Get() + tmp210 := lang.Apply(tmp209, []any{lang.NewSymbol("do")}) + tmp211 := lang.Apply(tmp206, []any{tmp210, v143}) + tmp212 := lang.Apply(tmp203, []any{tmp211}) + tmp192 = tmp212 } else { - v213 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v214 := v213.FindInternedVar(lang.NewSymbol("first")) - if v214.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v214))) + tmp213 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp214 := tmp213.FindInternedVar(lang.NewSymbol("first")) + if tmp214.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp214))) } - v215 := v214.Get() - v216 := lang.Apply(v215, []any{v143}) - v192 = v216 + tmp215 := tmp214.Get() + tmp216 := lang.Apply(tmp215, []any{v143}) + tmp192 = tmp216 } - v217 := lang.Apply(v191, []any{v192}) - v218 := lang.Apply(v184, []any{v188, v217}) - v219 := lang.Apply(v181, []any{v218}) - v220 := lang.Apply(v175, []any{v178, v219}) - v221 := lang.Apply(v172, []any{v220}) - v222 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v223 := v222.FindInternedVar(lang.NewSymbol("map")) - if v223.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v223))) + tmp217 := lang.Apply(tmp191, []any{tmp192}) + tmp218 := lang.Apply(tmp184, []any{tmp188, tmp217}) + tmp219 := lang.Apply(tmp181, []any{tmp218}) + tmp220 := lang.Apply(tmp175, []any{tmp178, tmp219}) + tmp221 := lang.Apply(tmp172, []any{tmp220}) + tmp222 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp223 := tmp222.FindInternedVar(lang.NewSymbol("map")) + if tmp223.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp223))) } - v224 := v223.Get() - var v225 lang.FnFunc - v225 = lang.NewFnFunc(func(args ...any) any { + tmp224 := tmp223.Get() + var tmp225 lang.FnFunc + tmp225 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v226 := args[0] _ = v226 - v227 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v228 := v227.FindInternedVar(lang.NewSymbol("seq")) - if v228.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v228))) + tmp227 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp228 := tmp227.FindInternedVar(lang.NewSymbol("seq")) + if tmp228.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp228))) } - v229 := v228.Get() - v230 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v231 := v230.FindInternedVar(lang.NewSymbol("concat")) - if v231.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v231))) + tmp229 := tmp228.Get() + tmp230 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp231 := tmp230.FindInternedVar(lang.NewSymbol("concat")) + if tmp231.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp231))) } - v232 := v231.Get() - v233 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v234 := v233.FindInternedVar(lang.NewSymbol("list")) - if v234.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v234))) + tmp232 := tmp231.Get() + tmp233 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp234 := tmp233.FindInternedVar(lang.NewSymbol("list")) + if tmp234.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp234))) } - v235 := v234.Get() - v236 := lang.Apply(v235, []any{lang.NewSymbol("glojure.core/assert")}) - v237 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v238 := v237.FindInternedVar(lang.NewSymbol("list")) - if v238.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v238))) + tmp235 := tmp234.Get() + tmp236 := lang.Apply(tmp235, []any{lang.NewSymbol("glojure.core/assert")}) + tmp237 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp238 := tmp237.FindInternedVar(lang.NewSymbol("list")) + if tmp238.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp238))) } - v239 := v238.Get() - v240 := lang.Apply(v239, []any{v226}) - v241 := lang.Apply(v232, []any{v236, v240}) - v242 := lang.Apply(v229, []any{v241}) - return v242 + tmp239 := tmp238.Get() + tmp240 := lang.Apply(tmp239, []any{v226}) + tmp241 := lang.Apply(tmp232, []any{tmp236, tmp240}) + tmp242 := lang.Apply(tmp229, []any{tmp241}) + return tmp242 }) - v226 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4582), lang.NewKeyword("column"), int(41), lang.NewKeyword("end-line"), int(4582), lang.NewKeyword("end-column"), int(62)) - v227, err := lang.WithMeta(v225, v226.(lang.IPersistentMap)) + tmp226 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4582), lang.NewKeyword("column"), int(41), lang.NewKeyword("end-line"), int(4582), lang.NewKeyword("end-column"), int(62)) + tmp227, err := lang.WithMeta(tmp225, tmp226.(lang.IPersistentMap)) if err != nil { panic(err) } - v228 := lang.Apply(v224, []any{v227, v149}) - v229 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v230 := v229.FindInternedVar(lang.NewSymbol("list")) - if v230.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v230))) + tmp228 := lang.Apply(tmp224, []any{tmp227, v149}) + tmp229 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp230 := tmp229.FindInternedVar(lang.NewSymbol("list")) + if tmp230.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp230))) } - v231 := v230.Get() - v232 := lang.Apply(v231, []any{lang.NewSymbol("%")}) - v233 := lang.Apply(v165, []any{v169, v221, v228, v232}) - v234 := lang.Apply(v162, []any{v233}) - v235 := lang.Apply(v159, []any{v234}) - v236 := lang.Apply(v156, []any{v235}) - v237 := lang.Apply(v153, []any{v236}) - v150 = v237 + tmp231 := tmp230.Get() + tmp232 := lang.Apply(tmp231, []any{lang.NewSymbol("%")}) + tmp233 := lang.Apply(tmp165, []any{tmp169, tmp221, tmp228, tmp232}) + tmp234 := lang.Apply(tmp162, []any{tmp233}) + tmp235 := lang.Apply(tmp159, []any{tmp234}) + tmp236 := lang.Apply(tmp156, []any{tmp235}) + tmp237 := lang.Apply(tmp153, []any{tmp236}) + tmp150 = tmp237 } else { - v150 = v143 + tmp150 = v143 } - var v238 any = v150 + var v238 any = tmp150 _ = v238 // let binding "body" - var v239 any + var tmp239 any if lang.IsTruthy(v147) { - v240 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v241 := v240.FindInternedVar(lang.NewSymbol("concat")) - if v241.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v241))) + tmp240 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp241 := tmp240.FindInternedVar(lang.NewSymbol("concat")) + if tmp241.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp241))) } - v242 := v241.Get() - v243 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v244 := v243.FindInternedVar(lang.NewSymbol("map")) - if v244.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v244))) + tmp242 := tmp241.Get() + tmp243 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp244 := tmp243.FindInternedVar(lang.NewSymbol("map")) + if tmp244.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp244))) } - v245 := v244.Get() - var v246 lang.FnFunc - v246 = lang.NewFnFunc(func(args ...any) any { + tmp245 := tmp244.Get() + var tmp246 lang.FnFunc + tmp246 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v247 := args[0] _ = v247 - v248 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v249 := v248.FindInternedVar(lang.NewSymbol("seq")) - if v249.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v249))) + tmp248 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp249 := tmp248.FindInternedVar(lang.NewSymbol("seq")) + if tmp249.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp249))) } - v250 := v249.Get() - v251 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v252 := v251.FindInternedVar(lang.NewSymbol("concat")) - if v252.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v252))) + tmp250 := tmp249.Get() + tmp251 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp252 := tmp251.FindInternedVar(lang.NewSymbol("concat")) + if tmp252.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp252))) } - v253 := v252.Get() - v254 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v255 := v254.FindInternedVar(lang.NewSymbol("list")) - if v255.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v255))) + tmp253 := tmp252.Get() + tmp254 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp255 := tmp254.FindInternedVar(lang.NewSymbol("list")) + if tmp255.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp255))) } - v256 := v255.Get() - v257 := lang.Apply(v256, []any{lang.NewSymbol("glojure.core/assert")}) - v258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v259 := v258.FindInternedVar(lang.NewSymbol("list")) - if v259.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v259))) + tmp256 := tmp255.Get() + tmp257 := lang.Apply(tmp256, []any{lang.NewSymbol("glojure.core/assert")}) + tmp258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp259 := tmp258.FindInternedVar(lang.NewSymbol("list")) + if tmp259.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp259))) } - v260 := v259.Get() - v261 := lang.Apply(v260, []any{v247}) - v262 := lang.Apply(v253, []any{v257, v261}) - v263 := lang.Apply(v250, []any{v262}) - return v263 + tmp260 := tmp259.Get() + tmp261 := lang.Apply(tmp260, []any{v247}) + tmp262 := lang.Apply(tmp253, []any{tmp257, tmp261}) + tmp263 := lang.Apply(tmp250, []any{tmp262}) + return tmp263 }) - v247 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4586), lang.NewKeyword("column"), int(44), lang.NewKeyword("end-line"), int(4586), lang.NewKeyword("end-column"), int(65)) - v248, err := lang.WithMeta(v246, v247.(lang.IPersistentMap)) + tmp247 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4586), lang.NewKeyword("column"), int(44), lang.NewKeyword("end-line"), int(4586), lang.NewKeyword("end-column"), int(65)) + tmp248, err := lang.WithMeta(tmp246, tmp247.(lang.IPersistentMap)) if err != nil { panic(err) } - v249 := lang.Apply(v245, []any{v248, v147}) - v250 := lang.Apply(v242, []any{v249, v238}) - v239 = v250 + tmp249 := lang.Apply(tmp245, []any{tmp248, v147}) + tmp250 := lang.Apply(tmp242, []any{tmp249, v238}) + tmp239 = tmp250 } else { - v239 = v238 + tmp239 = v238 } - var v251 any = v239 + var v251 any = tmp239 _ = v251 - v252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v253 := v252.FindInternedVar(lang.NewSymbol("maybe-destructured")) - if v253.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v253))) - } - v254 := v253.Get() - v255 := lang.Apply(v254, []any{v101, v251}) - v84 = v255 + tmp252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp253 := tmp252.FindInternedVar(lang.NewSymbol("maybe-destructured")) + if tmp253.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp253))) + } + tmp254 := tmp253.Get() + tmp255 := lang.Apply(tmp254, []any{v101, v251}) + tmp84 = tmp255 } // end let - return v84 + return tmp84 }) - v69 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4558), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(4589), lang.NewKeyword("end-column"), int(53)) - v70, err := lang.WithMeta(v68, v69.(lang.IPersistentMap)) + tmp69 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4558), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(4589), lang.NewKeyword("end-column"), int(53)) + tmp70, err := lang.WithMeta(tmp68, tmp69.(lang.IPersistentMap)) if err != nil { panic(err) } - var v71 any = v70 + var v71 any = tmp70 _ = v71 // let binding "new-sigs" - v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v73 := v72.FindInternedVar(lang.NewSymbol("map")) - if v73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) - } - v74 := v73.Get() - v75 := lang.Apply(v74, []any{v71, v67}) - var v76 any = v75 + tmp72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp73 := tmp72.FindInternedVar(lang.NewSymbol("map")) + if tmp73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp73))) + } + tmp74 := tmp73.Get() + tmp75 := lang.Apply(tmp74, []any{v71, v67}) + var v76 any = tmp75 _ = v76 - v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v78 := v77.FindInternedVar(lang.NewSymbol("with-meta")) - if v78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) + tmp77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp78 := tmp77.FindInternedVar(lang.NewSymbol("with-meta")) + if tmp78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp78))) } - v79 := v78.Get() - var v80 any + tmp79 := tmp78.Get() + var tmp80 any if lang.IsTruthy(v20) { - v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v82 := v81.FindInternedVar(lang.NewSymbol("list*")) - if v82.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) - } - v83 := v82.Get() - v84 := lang.Apply(v83, []any{lang.NewSymbol("fn*"), v20, v76}) - v80 = v84 + tmp81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp82 := tmp81.FindInternedVar(lang.NewSymbol("list*")) + if tmp82.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp82))) + } + tmp83 := tmp82.Get() + tmp84 := lang.Apply(tmp83, []any{lang.NewSymbol("fn*"), v20, v76}) + tmp80 = tmp84 } else { - v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v86 := v85.FindInternedVar(lang.NewSymbol("cons")) - if v86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) - } - v87 := v86.Get() - v88 := lang.Apply(v87, []any{lang.NewSymbol("fn*"), v76}) - v80 = v88 - } - v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v90 := v89.FindInternedVar(lang.NewSymbol("meta")) - if v90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) - } - v91 := v90.Get() - v92 := lang.Apply(v91, []any{v3}) - v93 := lang.Apply(v79, []any{v80, v92}) - v6 = v93 + tmp85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp86 := tmp85.FindInternedVar(lang.NewSymbol("cons")) + if tmp86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp86))) + } + tmp87 := tmp86.Get() + tmp88 := lang.Apply(tmp87, []any{lang.NewSymbol("fn*"), v76}) + tmp80 = tmp88 + } + tmp89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp90 := tmp89.FindInternedVar(lang.NewSymbol("meta")) + if tmp90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp90))) + } + tmp91 := tmp90.Get() + tmp92 := lang.Apply(tmp91, []any{v3}) + tmp93 := lang.Apply(tmp79, []any{tmp80, tmp92}) + tmp6 = tmp93 } // end let - return v6 + return tmp6 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // fn? { - v0 := lang.NewSymbol("fn?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements Fn, i.e. is an object created via fn.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6216), lang.NewKeyword("end-line"), int(6216))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("fn?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements Fn, i.e. is an object created via fn.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6216), lang.NewKeyword("end-line"), int(6216))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) } - v6 := v5.Get() - v7 := lang.Apply(v6, []any{*runtime4.Fn, v3}) - return v7 + tmp6 := tmp5.Get() + tmp7 := reflect.TypeOf((*runtime4.Fn)(nil)) + tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) + return tmp8 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // fnext { - v0 := lang.NewSymbol("fnext").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Same as (first (next x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(112), lang.NewKeyword("end-line"), int(116))).(*lang.Symbol) - var v2 lang.FnFunc + tmp0 := lang.NewSymbol("fnext").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Same as (first (next x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(112), lang.NewKeyword("end-line"), int(116))).(*lang.Symbol) + var tmp2 lang.FnFunc { // function fnext - v2 = lang.NewFnFunc(func(args ...any) any { + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("first")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("next")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v4}) - v12 := lang.Apply(v7, []any{v11}) - return v12 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("first")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("next")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v4}) + tmp12 := lang.Apply(tmp7, []any{tmp11}) + return tmp12 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(116), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(116), lang.NewKeyword("end-column"), int(47))).(lang.FnFunc) - v3 := v2 + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(116), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(116), lang.NewKeyword("end-column"), int(47))).(lang.FnFunc) + v3 = tmp2 _ = v3 } - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // fnil { - v0 := lang.NewSymbol("fnil").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("z"))), lang.NewKeyword("doc"), "Takes a function f, and returns a function that calls f, replacing\n a nil first argument to f with the supplied value x. Higher arity\n versions can replace arguments in the second and third\n positions (y, z). Note that the function f can take any number of\n arguments, not just the one(s) being nil-patched.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6558), lang.NewKeyword("end-line"), int(6558))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("fnil").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("z"))), lang.NewKeyword("doc"), "Takes a function f, and returns a function that calls f, replacing\n a nil first argument to f with the supplied value x. Higher arity\n versions can replace arguments in the second and third\n positions (y, z). Note that the function f can take any number of\n arguments, not just the one(s) being nil-patched.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6558), lang.NewKeyword("end-line"), int(6558))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - var v5 lang.FnFunc - v5 = lang.NewFnFunc(func(args ...any) any { + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v6 := args[0] _ = v6 - var v7 any - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("nil?")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v6}) - if lang.IsTruthy(v11) { - v7 = v4 + var tmp7 any + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("nil?")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v6}) + if lang.IsTruthy(tmp11) { + tmp7 = v4 } else { - v7 = v6 + tmp7 = v6 } - v12 := lang.Apply(v3, []any{v7}) - return v12 + tmp12 := lang.Apply(v3, []any{tmp7}) + return tmp12 case 2: v6 := args[0] _ = v6 v7 := args[1] _ = v7 - var v8 any - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("nil?")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.Apply(v11, []any{v6}) - if lang.IsTruthy(v12) { - v8 = v4 + var tmp8 any + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("nil?")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.Apply(tmp11, []any{v6}) + if lang.IsTruthy(tmp12) { + tmp8 = v4 } else { - v8 = v6 + tmp8 = v6 } - v13 := lang.Apply(v3, []any{v8, v7}) - return v13 + tmp13 := lang.Apply(v3, []any{tmp8, v7}) + return tmp13 case 3: v6 := args[0] _ = v6 @@ -36182,21 +36283,21 @@ func init() { _ = v7 v8 := args[2] _ = v8 - var v9 any - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("nil?")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{v6}) - if lang.IsTruthy(v13) { - v9 = v4 + var tmp9 any + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("nil?")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{v6}) + if lang.IsTruthy(tmp13) { + tmp9 = v4 } else { - v9 = v6 + tmp9 = v6 } - v14 := lang.Apply(v3, []any{v9, v7, v8}) - return v14 + tmp14 := lang.Apply(v3, []any{tmp9, v7, v8}) + return tmp14 default: if len(args) < 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -36207,36 +36308,37 @@ func init() { _ = v7 v8 := args[2] _ = v8 - v9 := lang.NewList(args[3:]...) - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("apply")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - var v13 any - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("nil?")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{v6}) - if lang.IsTruthy(v17) { - v13 = v4 + var v9 any = lang.NewList(args[3:]...) + _ = v9 + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("apply")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + var tmp13 any + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("nil?")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{v6}) + if lang.IsTruthy(tmp17) { + tmp13 = v4 } else { - v13 = v6 + tmp13 = v6 } - v18 := lang.Apply(v12, []any{v3, v13, v7, v8, v9}) - return v18 + tmp18 := lang.Apply(tmp12, []any{v3, tmp13, v7, v8, v9}) + return tmp18 } }) - v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6567), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(6571), lang.NewKeyword("end-column"), int(55)) - v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) + tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6567), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(6571), lang.NewKeyword("end-column"), int(55)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) if err != nil { panic(err) } - return v7 + return tmp7 case 3: v3 := args[0] _ = v3 @@ -36244,42 +36346,42 @@ func init() { _ = v4 v5 := args[2] _ = v5 - var v6 lang.FnFunc - v6 = lang.NewFnFunc(func(args ...any) any { + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 2: v7 := args[0] _ = v7 v8 := args[1] _ = v8 - var v9 any - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("nil?")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{v7}) - if lang.IsTruthy(v13) { - v9 = v4 + var tmp9 any + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("nil?")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{v7}) + if lang.IsTruthy(tmp13) { + tmp9 = v4 } else { - v9 = v7 - } - var v14 any - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("nil?")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{v8}) - if lang.IsTruthy(v18) { - v14 = v5 + tmp9 = v7 + } + var tmp14 any + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("nil?")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{v8}) + if lang.IsTruthy(tmp18) { + tmp14 = v5 } else { - v14 = v8 + tmp14 = v8 } - v19 := lang.Apply(v3, []any{v9, v14}) - return v19 + tmp19 := lang.Apply(v3, []any{tmp9, tmp14}) + return tmp19 case 3: v7 := args[0] _ = v7 @@ -36287,34 +36389,34 @@ func init() { _ = v8 v9 := args[2] _ = v9 - var v10 any - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("nil?")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{v7}) - if lang.IsTruthy(v14) { - v10 = v4 + var tmp10 any + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("nil?")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{v7}) + if lang.IsTruthy(tmp14) { + tmp10 = v4 } else { - v10 = v7 - } - var v15 any - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("nil?")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{v8}) - if lang.IsTruthy(v19) { - v15 = v5 + tmp10 = v7 + } + var tmp15 any + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("nil?")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{v8}) + if lang.IsTruthy(tmp19) { + tmp15 = v5 } else { - v15 = v8 + tmp15 = v8 } - v20 := lang.Apply(v3, []any{v10, v15, v9}) - return v20 + tmp20 := lang.Apply(v3, []any{tmp10, tmp15, v9}) + return tmp20 default: if len(args) < 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -36325,49 +36427,50 @@ func init() { _ = v8 v9 := args[2] _ = v9 - v10 := lang.NewList(args[3:]...) - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("apply")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - var v14 any - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("nil?")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{v7}) - if lang.IsTruthy(v18) { - v14 = v4 + var v10 any = lang.NewList(args[3:]...) + _ = v10 + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("apply")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + var tmp14 any + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("nil?")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{v7}) + if lang.IsTruthy(tmp18) { + tmp14 = v4 } else { - v14 = v7 - } - var v19 any - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("nil?")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.Apply(v22, []any{v8}) - if lang.IsTruthy(v23) { - v19 = v5 + tmp14 = v7 + } + var tmp19 any + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("nil?")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.Apply(tmp22, []any{v8}) + if lang.IsTruthy(tmp23) { + tmp19 = v5 } else { - v19 = v8 + tmp19 = v8 } - v24 := lang.Apply(v13, []any{v3, v14, v19, v9, v10}) - return v24 + tmp24 := lang.Apply(tmp13, []any{v3, tmp14, tmp19, v9, v10}) + return tmp24 } }) - v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6573), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(6576), lang.NewKeyword("end-column"), int(71)) - v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) + tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6573), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(6576), lang.NewKeyword("end-column"), int(71)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) if err != nil { panic(err) } - return v8 + return tmp8 case 4: v3 := args[0] _ = v3 @@ -36377,42 +36480,42 @@ func init() { _ = v5 v6 := args[3] _ = v6 - var v7 lang.FnFunc - v7 = lang.NewFnFunc(func(args ...any) any { + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 2: v8 := args[0] _ = v8 v9 := args[1] _ = v9 - var v10 any - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("nil?")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{v8}) - if lang.IsTruthy(v14) { - v10 = v4 + var tmp10 any + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("nil?")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{v8}) + if lang.IsTruthy(tmp14) { + tmp10 = v4 } else { - v10 = v8 - } - var v15 any - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("nil?")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{v9}) - if lang.IsTruthy(v19) { - v15 = v5 + tmp10 = v8 + } + var tmp15 any + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("nil?")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{v9}) + if lang.IsTruthy(tmp19) { + tmp15 = v5 } else { - v15 = v9 + tmp15 = v9 } - v20 := lang.Apply(v3, []any{v10, v15}) - return v20 + tmp20 := lang.Apply(v3, []any{tmp10, tmp15}) + return tmp20 case 3: v8 := args[0] _ = v8 @@ -36420,47 +36523,47 @@ func init() { _ = v9 v10 := args[2] _ = v10 - var v11 any - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("nil?")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.Apply(v14, []any{v8}) - if lang.IsTruthy(v15) { - v11 = v4 + var tmp11 any + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("nil?")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.Apply(tmp14, []any{v8}) + if lang.IsTruthy(tmp15) { + tmp11 = v4 } else { - v11 = v8 - } - var v16 any - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("nil?")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.Apply(v19, []any{v9}) - if lang.IsTruthy(v20) { - v16 = v5 + tmp11 = v8 + } + var tmp16 any + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("nil?")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.Apply(tmp19, []any{v9}) + if lang.IsTruthy(tmp20) { + tmp16 = v5 } else { - v16 = v9 - } - var v21 any - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("nil?")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v10}) - if lang.IsTruthy(v25) { - v21 = v6 + tmp16 = v9 + } + var tmp21 any + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("nil?")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.Apply(tmp24, []any{v10}) + if lang.IsTruthy(tmp25) { + tmp21 = v6 } else { - v21 = v10 + tmp21 = v10 } - v26 := lang.Apply(v3, []any{v11, v16, v21}) - return v26 + tmp26 := lang.Apply(v3, []any{tmp11, tmp16, tmp21}) + return tmp26 default: if len(args) < 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -36471,77 +36574,78 @@ func init() { _ = v9 v10 := args[2] _ = v10 - v11 := lang.NewList(args[3:]...) - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("apply")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - var v15 any - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("nil?")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{v8}) - if lang.IsTruthy(v19) { - v15 = v4 + var v11 any = lang.NewList(args[3:]...) + _ = v11 + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("apply")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + var tmp15 any + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("nil?")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{v8}) + if lang.IsTruthy(tmp19) { + tmp15 = v4 } else { - v15 = v8 - } - var v20 any - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("nil?")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.Apply(v23, []any{v9}) - if lang.IsTruthy(v24) { - v20 = v5 + tmp15 = v8 + } + var tmp20 any + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("nil?")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.Apply(tmp23, []any{v9}) + if lang.IsTruthy(tmp24) { + tmp20 = v5 } else { - v20 = v9 - } - var v25 any - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("nil?")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) - } - v28 := v27.Get() - v29 := lang.Apply(v28, []any{v10}) - if lang.IsTruthy(v29) { - v25 = v6 + tmp20 = v9 + } + var tmp25 any + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("nil?")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) + } + tmp28 := tmp27.Get() + tmp29 := lang.Apply(tmp28, []any{v10}) + if lang.IsTruthy(tmp29) { + tmp25 = v6 } else { - v25 = v10 + tmp25 = v10 } - v30 := lang.Apply(v14, []any{v3, v15, v20, v25, v11}) - return v30 + tmp30 := lang.Apply(tmp14, []any{v3, tmp15, tmp20, tmp25, v11}) + return tmp30 } }) - v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6578), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(6581), lang.NewKeyword("end-column"), int(87)) - v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) + tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6578), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(6581), lang.NewKeyword("end-column"), int(87)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) if err != nil { panic(err) } - return v9 + return tmp9 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // for { - v0 := lang.NewSymbol("for").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("seq-exprs"), lang.NewSymbol("body-expr"))), lang.NewKeyword("doc"), "List comprehension. Takes a vector of one or more\n binding-form/collection-expr pairs, each followed by zero or more\n modifiers, and yields a lazy sequence of evaluations of expr.\n Collections are iterated in a nested fashion, rightmost fastest,\n and nested coll-exprs can refer to bindings created in prior\n binding-forms. Supported modifiers are: :let [binding-form expr ...],\n :while test, :when test.\n\n (take 100 (for [x (range 100000000) y (range 1000000) :while (< y x)] [x y]))", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4646), lang.NewKeyword("end-line"), int(4646))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("for").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("seq-exprs"), lang.NewSymbol("body-expr"))), lang.NewKeyword("doc"), "List comprehension. Takes a vector of one or more\n binding-form/collection-expr pairs, each followed by zero or more\n modifiers, and yields a lazy sequence of evaluations of expr.\n Collections are iterated in a nested fashion, rightmost fastest,\n and nested coll-exprs can refer to bindings created in prior\n binding-forms. Supported modifiers are: :let [binding-form expr ...],\n :while test, :when test.\n\n (take 100 (for [x (range 100000000) y (range 1000000) :while (< y x)] [x y]))", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4646), lang.NewKeyword("end-line"), int(4646))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 4 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -36553,118 +36657,115 @@ func init() { _ = v5 v6 := args[3] _ = v6 - var v7 any - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v5}) - if lang.IsTruthy(v11) { - v7 = nil + var tmp7 any + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("vector?")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v5}) + if lang.IsTruthy(tmp11) { } else { - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("str")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("first")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{v3}) - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("meta")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v3}) - v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) - v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) - v28 := lang.Apply(lang.NewIllegalArgumentError, []any{v27}) - panic(v28) - } - _ = v7 - var v29 any - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("even?")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) - } - v32 := v31.Get() - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("count")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - v36 := lang.Apply(v35, []any{v5}) - v37 := lang.Apply(v32, []any{v36}) - if lang.IsTruthy(v37) { - v29 = nil + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("str")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("first")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("*ns*")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("meta")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.Apply(tmp24, []any{v3}) + tmp26 := lang.Apply(lang.NewKeyword("line"), []any{tmp25}) + tmp27 := lang.Apply(tmp14, []any{tmp18, " requires ", "a vector for its binding", " in ", tmp21, ":", tmp26}) + tmp28 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp27}) + panic(tmp28) + } + _ = tmp7 + var tmp29 any + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("even?")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) + } + tmp32 := tmp31.Get() + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("count")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) + } + tmp35 := tmp34.Get() + tmp36 := lang.Apply(tmp35, []any{v5}) + tmp37 := lang.Apply(tmp32, []any{tmp36}) + if lang.IsTruthy(tmp37) { } else { - v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v39 := v38.FindInternedVar(lang.NewSymbol("str")) - if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) - } - v40 := v39.Get() - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("first")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) - } - v43 := v42.Get() - v44 := lang.Apply(v43, []any{v3}) - v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) - if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) - } - v47 := v46.Get() - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("meta")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v3}) - v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) - v53 := lang.Apply(v40, []any{v44, " requires ", "an even number of forms in binding vector", " in ", v47, ":", v52}) - v54 := lang.Apply(lang.NewIllegalArgumentError, []any{v53}) - panic(v54) - } - _ = v29 - _ = nil - var v55 any + tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp39 := tmp38.FindInternedVar(lang.NewSymbol("str")) + if tmp39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) + } + tmp40 := tmp39.Get() + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("first")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := lang.Apply(tmp43, []any{v3}) + tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp46 := tmp45.FindInternedVar(lang.NewSymbol("*ns*")) + if tmp46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) + } + tmp47 := tmp46.Get() + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("meta")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v3}) + tmp52 := lang.Apply(lang.NewKeyword("line"), []any{tmp51}) + tmp53 := lang.Apply(tmp40, []any{tmp44, " requires ", "an even number of forms in binding vector", " in ", tmp47, ":", tmp52}) + tmp54 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp53}) + panic(tmp54) + } + _ = tmp29 + var tmp55 any { // let // let binding "to-groups" - var v56 lang.FnFunc - v56 = lang.NewFnFunc(func(args ...any) any { + var tmp56 lang.FnFunc + tmp56 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v57 := args[0] _ = v57 - v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v59 := v58.FindInternedVar(lang.NewSymbol("reduce1")) - if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) - } - v60 := v59.Get() - var v61 lang.FnFunc - v61 = lang.NewFnFunc(func(args ...any) any { + tmp58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp59 := tmp58.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp59))) + } + tmp60 := tmp59.Get() + var tmp61 lang.FnFunc + tmp61 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -36672,255 +36773,257 @@ func init() { _ = v62 v63 := args[1] _ = v63 - var v64 any + var tmp64 any { // let // let binding "vec__24" var v65 any = v63 _ = v65 // let binding "k" - v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v67 := v66.FindInternedVar(lang.NewSymbol("nth")) - if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) - } - v68 := v67.Get() - v69 := lang.Apply(v68, []any{v65, int64(0), nil}) - var v70 any = v69 + tmp66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp67 := tmp66.FindInternedVar(lang.NewSymbol("nth")) + if tmp67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp67))) + } + tmp68 := tmp67.Get() + tmp69 := lang.Apply(tmp68, []any{v65, int64(0), nil}) + var v70 any = tmp69 _ = v70 // let binding "v" - v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v72 := v71.FindInternedVar(lang.NewSymbol("nth")) - if v72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) - } - v73 := v72.Get() - v74 := lang.Apply(v73, []any{v65, int64(1), nil}) - var v75 any = v74 + tmp71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp72 := tmp71.FindInternedVar(lang.NewSymbol("nth")) + if tmp72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp72))) + } + tmp73 := tmp72.Get() + tmp74 := lang.Apply(tmp73, []any{v65, int64(1), nil}) + var v75 any = tmp74 _ = v75 - var v76 any - v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v78 := v77.FindInternedVar(lang.NewSymbol("keyword?")) - if v78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) - } - v79 := v78.Get() - v80 := lang.Apply(v79, []any{v70}) - if lang.IsTruthy(v80) { - v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v82 := v81.FindInternedVar(lang.NewSymbol("conj")) - if v82.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) + var tmp76 any + tmp77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp78 := tmp77.FindInternedVar(lang.NewSymbol("keyword?")) + if tmp78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp78))) + } + tmp79 := tmp78.Get() + tmp80 := lang.Apply(tmp79, []any{v70}) + if lang.IsTruthy(tmp80) { + tmp81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp82 := tmp81.FindInternedVar(lang.NewSymbol("conj")) + if tmp82.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp82))) } - v83 := v82.Get() - v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v85 := v84.FindInternedVar(lang.NewSymbol("pop")) - if v85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) + tmp83 := tmp82.Get() + tmp84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp85 := tmp84.FindInternedVar(lang.NewSymbol("pop")) + if tmp85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp85))) } - v86 := v85.Get() - v87 := lang.Apply(v86, []any{v62}) - v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v89 := v88.FindInternedVar(lang.NewSymbol("conj")) - if v89.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) + tmp86 := tmp85.Get() + tmp87 := lang.Apply(tmp86, []any{v62}) + tmp88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp89 := tmp88.FindInternedVar(lang.NewSymbol("conj")) + if tmp89.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp89))) } - v90 := v89.Get() - v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v92 := v91.FindInternedVar(lang.NewSymbol("peek")) - if v92.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) + tmp90 := tmp89.Get() + tmp91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp92 := tmp91.FindInternedVar(lang.NewSymbol("peek")) + if tmp92.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp92))) } - v93 := v92.Get() - v94 := lang.Apply(v93, []any{v62}) - v95 := lang.NewVector(v70, v75) - v96 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4664), lang.NewKeyword("column"), int(72), lang.NewKeyword("end-line"), int(4664), lang.NewKeyword("end-column"), int(76)) - v97, err := lang.WithMeta(v95, v96.(lang.IPersistentMap)) + tmp93 := tmp92.Get() + tmp94 := lang.Apply(tmp93, []any{v62}) + tmp95 := lang.NewVector(v70, v75) + tmp96 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4664), lang.NewKeyword("column"), int(72), lang.NewKeyword("end-line"), int(4664), lang.NewKeyword("end-column"), int(76)) + tmp97, err := lang.WithMeta(tmp95, tmp96.(lang.IPersistentMap)) if err != nil { panic(err) } - v98 := lang.Apply(v90, []any{v94, v97}) - v99 := lang.Apply(v83, []any{v87, v98}) - v76 = v99 + tmp98 := lang.Apply(tmp90, []any{tmp94, tmp97}) + tmp99 := lang.Apply(tmp83, []any{tmp87, tmp98}) + tmp76 = tmp99 } else { - v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v101 := v100.FindInternedVar(lang.NewSymbol("conj")) - if v101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) + tmp100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp101 := tmp100.FindInternedVar(lang.NewSymbol("conj")) + if tmp101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp101))) } - v102 := v101.Get() - v103 := lang.NewVector(v70, v75) - v104 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4665), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(4665), lang.NewKeyword("end-column"), int(50)) - v105, err := lang.WithMeta(v103, v104.(lang.IPersistentMap)) + tmp102 := tmp101.Get() + tmp103 := lang.NewVector(v70, v75) + tmp104 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4665), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(4665), lang.NewKeyword("end-column"), int(50)) + tmp105, err := lang.WithMeta(tmp103, tmp104.(lang.IPersistentMap)) if err != nil { panic(err) } - v106 := lang.Apply(v102, []any{v62, v105}) - v76 = v106 + tmp106 := lang.Apply(tmp102, []any{v62, tmp105}) + tmp76 = tmp106 } - v64 = v76 + tmp64 = tmp76 } // end let - return v64 + return tmp64 }) - v62 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4662), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(4665), lang.NewKeyword("end-column"), int(53)) - v63, err := lang.WithMeta(v61, v62.(lang.IPersistentMap)) + tmp62 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4662), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(4665), lang.NewKeyword("end-column"), int(53)) + tmp63, err := lang.WithMeta(tmp61, tmp62.(lang.IPersistentMap)) if err != nil { panic(err) } - v64 := lang.NewVector() - v65 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4666), lang.NewKeyword("column"), int(29), lang.NewKeyword("end-line"), int(4666), lang.NewKeyword("end-column"), int(30)) - v66, err := lang.WithMeta(v64, v65.(lang.IPersistentMap)) + tmp64 := lang.NewVector() + tmp65 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4666), lang.NewKeyword("column"), int(29), lang.NewKeyword("end-line"), int(4666), lang.NewKeyword("end-column"), int(30)) + tmp66, err := lang.WithMeta(tmp64, tmp65.(lang.IPersistentMap)) if err != nil { panic(err) } - v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v68 := v67.FindInternedVar(lang.NewSymbol("partition")) - if v68.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) + tmp67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp68 := tmp67.FindInternedVar(lang.NewSymbol("partition")) + if tmp68.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp68))) } - v69 := v68.Get() - v70 := lang.Apply(v69, []any{int64(2), v57}) - v71 := lang.Apply(v60, []any{v63, v66, v70}) - return v71 + tmp69 := tmp68.Get() + tmp70 := lang.Apply(tmp69, []any{int64(2), v57}) + tmp71 := lang.Apply(tmp60, []any{tmp63, tmp66, tmp70}) + return tmp71 }) - v57 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4661), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(4666), lang.NewKeyword("end-column"), int(56)) - v58, err := lang.WithMeta(v56, v57.(lang.IPersistentMap)) + tmp57 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4661), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(4666), lang.NewKeyword("end-column"), int(56)) + tmp58, err := lang.WithMeta(tmp56, tmp57.(lang.IPersistentMap)) if err != nil { panic(err) } - var v59 any = v58 + var v59 any = tmp58 _ = v59 // let binding "err" - var v60 lang.FnFunc - v60 = lang.NewFnFunc(func(args ...any) any { + var tmp60 lang.FnFunc + tmp60 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v61 := lang.NewList(args[0:]...) - v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v63 := v62.FindInternedVar(lang.NewSymbol("apply")) - if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) + var v61 any = lang.NewList(args[0:]...) + _ = v61 + tmp62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp63 := tmp62.FindInternedVar(lang.NewSymbol("apply")) + if tmp63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp63))) } - v64 := v63.Get() - v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v66 := v65.FindInternedVar(lang.NewSymbol("str")) - if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) + tmp64 := tmp63.Get() + tmp65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp66 := tmp65.FindInternedVar(lang.NewSymbol("str")) + if tmp66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp66))) } - v67 := v66.Get() - v68 := lang.Apply(v64, []any{v67, v61}) - v69 := lang.Apply(lang.NewIllegalArgumentError, []any{v68}) - panic(v69) + tmp67 := tmp66.Get() + tmp68 := lang.Apply(tmp64, []any{tmp67, v61}) + tmp69 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp68}) + panic(tmp69) } }) - v61 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4667), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(4667), lang.NewKeyword("end-column"), int(125)) - v62, err := lang.WithMeta(v60, v61.(lang.IPersistentMap)) + tmp61 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4667), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(4667), lang.NewKeyword("end-column"), int(125)) + tmp62, err := lang.WithMeta(tmp60, tmp61.(lang.IPersistentMap)) if err != nil { panic(err) } - var v63 any = v62 + var v63 any = tmp62 _ = v63 // let binding "emit-bind" - var v64 lang.FnFunc + var tmp64 lang.FnFunc { // function emit-bind - v64 = lang.NewFnFunc(func(args ...any) any { + var v65 lang.FnFunc + tmp64 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v66 := args[0] _ = v66 - var v67 any + var tmp67 any { // let // let binding "vec__28" var v68 any = v66 _ = v68 // let binding "seq__29" - v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v70 := v69.FindInternedVar(lang.NewSymbol("seq")) - if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) - } - v71 := v70.Get() - v72 := lang.Apply(v71, []any{v68}) - var v73 any = v72 + tmp69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp70 := tmp69.FindInternedVar(lang.NewSymbol("seq")) + if tmp70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp70))) + } + tmp71 := tmp70.Get() + tmp72 := lang.Apply(tmp71, []any{v68}) + var v73 any = tmp72 _ = v73 // let binding "first__30" - v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v75 := v74.FindInternedVar(lang.NewSymbol("first")) - if v75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) - } - v76 := v75.Get() - v77 := lang.Apply(v76, []any{v73}) - var v78 any = v77 + tmp74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp75 := tmp74.FindInternedVar(lang.NewSymbol("first")) + if tmp75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp75))) + } + tmp76 := tmp75.Get() + tmp77 := lang.Apply(tmp76, []any{v73}) + var v78 any = tmp77 _ = v78 // let binding "seq__29" - v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v80 := v79.FindInternedVar(lang.NewSymbol("next")) - if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) - } - v81 := v80.Get() - v82 := lang.Apply(v81, []any{v73}) - var v83 any = v82 + tmp79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp80 := tmp79.FindInternedVar(lang.NewSymbol("next")) + if tmp80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp80))) + } + tmp81 := tmp80.Get() + tmp82 := lang.Apply(tmp81, []any{v73}) + var v83 any = tmp82 _ = v83 // let binding "vec__31" var v84 any = v78 _ = v84 // let binding "seq__32" - v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v86 := v85.FindInternedVar(lang.NewSymbol("seq")) - if v86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) - } - v87 := v86.Get() - v88 := lang.Apply(v87, []any{v84}) - var v89 any = v88 + tmp85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp86 := tmp85.FindInternedVar(lang.NewSymbol("seq")) + if tmp86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp86))) + } + tmp87 := tmp86.Get() + tmp88 := lang.Apply(tmp87, []any{v84}) + var v89 any = tmp88 _ = v89 // let binding "first__33" - v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v91 := v90.FindInternedVar(lang.NewSymbol("first")) - if v91.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) - } - v92 := v91.Get() - v93 := lang.Apply(v92, []any{v89}) - var v94 any = v93 + tmp90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp91 := tmp90.FindInternedVar(lang.NewSymbol("first")) + if tmp91.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp91))) + } + tmp92 := tmp91.Get() + tmp93 := lang.Apply(tmp92, []any{v89}) + var v94 any = tmp93 _ = v94 // let binding "seq__32" - v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v96 := v95.FindInternedVar(lang.NewSymbol("next")) - if v96.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) - } - v97 := v96.Get() - v98 := lang.Apply(v97, []any{v89}) - var v99 any = v98 + tmp95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp96 := tmp95.FindInternedVar(lang.NewSymbol("next")) + if tmp96.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp96))) + } + tmp97 := tmp96.Get() + tmp98 := lang.Apply(tmp97, []any{v89}) + var v99 any = tmp98 _ = v99 // let binding "bind" var v100 any = v94 _ = v100 // let binding "first__33" - v101 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v102 := v101.FindInternedVar(lang.NewSymbol("first")) - if v102.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v102))) - } - v103 := v102.Get() - v104 := lang.Apply(v103, []any{v99}) - var v105 any = v104 + tmp101 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp102 := tmp101.FindInternedVar(lang.NewSymbol("first")) + if tmp102.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp102))) + } + tmp103 := tmp102.Get() + tmp104 := lang.Apply(tmp103, []any{v99}) + var v105 any = tmp104 _ = v105 // let binding "seq__32" - v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v107 := v106.FindInternedVar(lang.NewSymbol("next")) - if v107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) - } - v108 := v107.Get() - v109 := lang.Apply(v108, []any{v99}) - var v110 any = v109 + tmp106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp107 := tmp106.FindInternedVar(lang.NewSymbol("next")) + if tmp107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp107))) + } + tmp108 := tmp107.Get() + tmp109 := lang.Apply(tmp108, []any{v99}) + var v110 any = tmp109 _ = v110 // let binding "expr" var v111 any = v105 @@ -36932,126 +37035,127 @@ func init() { var v113 any = v83 _ = v113 // let binding "vec__37" - v114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v115 := v114.FindInternedVar(lang.NewSymbol("nth")) - if v115.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v115))) - } - v116 := v115.Get() - v117 := lang.Apply(v116, []any{v113, int64(0), nil}) - var v118 any = v117 + tmp114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp115 := tmp114.FindInternedVar(lang.NewSymbol("nth")) + if tmp115.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp115))) + } + tmp116 := tmp115.Get() + tmp117 := lang.Apply(tmp116, []any{v113, int64(0), nil}) + var v118 any = tmp117 _ = v118 // let binding "_" - v119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v120 := v119.FindInternedVar(lang.NewSymbol("nth")) - if v120.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v120))) - } - v121 := v120.Get() - v122 := lang.Apply(v121, []any{v118, int64(0), nil}) - var v123 any = v122 + tmp119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp120 := tmp119.FindInternedVar(lang.NewSymbol("nth")) + if tmp120.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp120))) + } + tmp121 := tmp120.Get() + tmp122 := lang.Apply(tmp121, []any{v118, int64(0), nil}) + var v123 any = tmp122 _ = v123 // let binding "next-expr" - v124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v125 := v124.FindInternedVar(lang.NewSymbol("nth")) - if v125.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v125))) - } - v126 := v125.Get() - v127 := lang.Apply(v126, []any{v118, int64(1), nil}) - var v128 any = v127 + tmp124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp125 := tmp124.FindInternedVar(lang.NewSymbol("nth")) + if tmp125.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp125))) + } + tmp126 := tmp125.Get() + tmp127 := lang.Apply(tmp126, []any{v118, int64(1), nil}) + var v128 any = tmp127 _ = v128 // let binding "next-groups" var v129 any = v113 _ = v129 - var v130 any + var tmp130 any { // let // let binding "giter" - v131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v132 := v131.FindInternedVar(lang.NewSymbol("gensym")) - if v132.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v132))) + tmp131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp132 := tmp131.FindInternedVar(lang.NewSymbol("gensym")) + if tmp132.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp132))) } - v133 := v132.Get() - v134 := lang.Apply(v133, []any{"iter__"}) - var v135 any = v134 + tmp133 := tmp132.Get() + tmp134 := lang.Apply(tmp133, []any{"iter__"}) + var v135 any = tmp134 _ = v135 // let binding "gxs" - v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v137 := v136.FindInternedVar(lang.NewSymbol("gensym")) - if v137.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) + tmp136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp137 := tmp136.FindInternedVar(lang.NewSymbol("gensym")) + if tmp137.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp137))) } - v138 := v137.Get() - v139 := lang.Apply(v138, []any{"s__"}) - var v140 any = v139 + tmp138 := tmp137.Get() + tmp139 := lang.Apply(tmp138, []any{"s__"}) + var v140 any = tmp139 _ = v140 // let binding "do-mod" - var v141 lang.FnFunc + var tmp141 lang.FnFunc { // function do-mod - v141 = lang.NewFnFunc(func(args ...any) any { + var v142 lang.FnFunc + tmp141 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v143 := args[0] _ = v143 - var v144 any + var tmp144 any { // let // let binding "vec__41" var v145 any = v143 _ = v145 // let binding "seq__42" - v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v147 := v146.FindInternedVar(lang.NewSymbol("seq")) - if v147.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) + tmp146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp147 := tmp146.FindInternedVar(lang.NewSymbol("seq")) + if tmp147.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp147))) } - v148 := v147.Get() - v149 := lang.Apply(v148, []any{v145}) - var v150 any = v149 + tmp148 := tmp147.Get() + tmp149 := lang.Apply(tmp148, []any{v145}) + var v150 any = tmp149 _ = v150 // let binding "first__43" - v151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v152 := v151.FindInternedVar(lang.NewSymbol("first")) - if v152.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v152))) + tmp151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp152 := tmp151.FindInternedVar(lang.NewSymbol("first")) + if tmp152.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp152))) } - v153 := v152.Get() - v154 := lang.Apply(v153, []any{v150}) - var v155 any = v154 + tmp153 := tmp152.Get() + tmp154 := lang.Apply(tmp153, []any{v150}) + var v155 any = tmp154 _ = v155 // let binding "seq__42" - v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v157 := v156.FindInternedVar(lang.NewSymbol("next")) - if v157.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) + tmp156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp157 := tmp156.FindInternedVar(lang.NewSymbol("next")) + if tmp157.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp157))) } - v158 := v157.Get() - v159 := lang.Apply(v158, []any{v150}) - var v160 any = v159 + tmp158 := tmp157.Get() + tmp159 := lang.Apply(tmp158, []any{v150}) + var v160 any = tmp159 _ = v160 // let binding "vec__44" var v161 any = v155 _ = v161 // let binding "k" - v162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v163 := v162.FindInternedVar(lang.NewSymbol("nth")) - if v163.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v163))) + tmp162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp163 := tmp162.FindInternedVar(lang.NewSymbol("nth")) + if tmp163.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp163))) } - v164 := v163.Get() - v165 := lang.Apply(v164, []any{v161, int64(0), nil}) - var v166 any = v165 + tmp164 := tmp163.Get() + tmp165 := lang.Apply(tmp164, []any{v161, int64(0), nil}) + var v166 any = tmp165 _ = v166 // let binding "v" - v167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v168 := v167.FindInternedVar(lang.NewSymbol("nth")) - if v168.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v168))) + tmp167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp168 := tmp167.FindInternedVar(lang.NewSymbol("nth")) + if tmp168.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp168))) } - v169 := v168.Get() - v170 := lang.Apply(v169, []any{v161, int64(1), nil}) - var v171 any = v170 + tmp169 := tmp168.Get() + tmp170 := lang.Apply(tmp169, []any{v161, int64(1), nil}) + var v171 any = tmp170 _ = v171 // let binding "pair" var v172 any = v161 @@ -37059,1032 +37163,1032 @@ func init() { // let binding "etc" var v173 any = v160 _ = v173 - var v174 any - v175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v176 := v175.FindInternedVar(lang.NewSymbol("=")) - if v176.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v176))) + var tmp174 any + tmp175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp176 := tmp175.FindInternedVar(lang.NewSymbol("=")) + if tmp176.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp176))) } - v177 := v176.Get() - v178 := lang.Apply(v177, []any{v166, lang.NewKeyword("let")}) - if lang.IsTruthy(v178) { - v179 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v180 := v179.FindInternedVar(lang.NewSymbol("seq")) - if v180.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v180))) + tmp177 := tmp176.Get() + tmp178 := lang.Apply(tmp177, []any{v166, lang.NewKeyword("let")}) + if lang.IsTruthy(tmp178) { + tmp179 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp180 := tmp179.FindInternedVar(lang.NewSymbol("seq")) + if tmp180.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp180))) } - v181 := v180.Get() - v182 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v183 := v182.FindInternedVar(lang.NewSymbol("concat")) - if v183.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v183))) + tmp181 := tmp180.Get() + tmp182 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp183 := tmp182.FindInternedVar(lang.NewSymbol("concat")) + if tmp183.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp183))) } - v184 := v183.Get() - v185 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v186 := v185.FindInternedVar(lang.NewSymbol("list")) - if v186.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v186))) + tmp184 := tmp183.Get() + tmp185 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp186 := tmp185.FindInternedVar(lang.NewSymbol("list")) + if tmp186.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp186))) } - v187 := v186.Get() - v188 := lang.Apply(v187, []any{lang.NewSymbol("glojure.core/let")}) - v189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v190 := v189.FindInternedVar(lang.NewSymbol("list")) - if v190.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v190))) + tmp187 := tmp186.Get() + tmp188 := lang.Apply(tmp187, []any{lang.NewSymbol("glojure.core/let")}) + tmp189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp190 := tmp189.FindInternedVar(lang.NewSymbol("list")) + if tmp190.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp190))) } - v191 := v190.Get() - v192 := lang.Apply(v191, []any{v171}) - v193 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v194 := v193.FindInternedVar(lang.NewSymbol("list")) - if v194.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v194))) + tmp191 := tmp190.Get() + tmp192 := lang.Apply(tmp191, []any{v171}) + tmp193 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp194 := tmp193.FindInternedVar(lang.NewSymbol("list")) + if tmp194.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp194))) } - v195 := v194.Get() - v196 := lang.Apply(v142, []any{v173}) - v197 := lang.Apply(v195, []any{v196}) - v198 := lang.Apply(v184, []any{v188, v192, v197}) - v199 := lang.Apply(v181, []any{v198}) - v174 = v199 + tmp195 := tmp194.Get() + tmp196 := lang.Apply(v142, []any{v173}) + tmp197 := lang.Apply(tmp195, []any{tmp196}) + tmp198 := lang.Apply(tmp184, []any{tmp188, tmp192, tmp197}) + tmp199 := lang.Apply(tmp181, []any{tmp198}) + tmp174 = tmp199 } else { - var v200 any - v201 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v202 := v201.FindInternedVar(lang.NewSymbol("=")) - if v202.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v202))) + var tmp200 any + tmp201 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp202 := tmp201.FindInternedVar(lang.NewSymbol("=")) + if tmp202.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp202))) } - v203 := v202.Get() - v204 := lang.Apply(v203, []any{v166, lang.NewKeyword("while")}) - if lang.IsTruthy(v204) { - v205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v206 := v205.FindInternedVar(lang.NewSymbol("seq")) - if v206.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v206))) + tmp203 := tmp202.Get() + tmp204 := lang.Apply(tmp203, []any{v166, lang.NewKeyword("while")}) + if lang.IsTruthy(tmp204) { + tmp205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp206 := tmp205.FindInternedVar(lang.NewSymbol("seq")) + if tmp206.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp206))) } - v207 := v206.Get() - v208 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v209 := v208.FindInternedVar(lang.NewSymbol("concat")) - if v209.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v209))) + tmp207 := tmp206.Get() + tmp208 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp209 := tmp208.FindInternedVar(lang.NewSymbol("concat")) + if tmp209.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp209))) } - v210 := v209.Get() - v211 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v212 := v211.FindInternedVar(lang.NewSymbol("list")) - if v212.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v212))) + tmp210 := tmp209.Get() + tmp211 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp212 := tmp211.FindInternedVar(lang.NewSymbol("list")) + if tmp212.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp212))) } - v213 := v212.Get() - v214 := lang.Apply(v213, []any{lang.NewSymbol("glojure.core/when")}) - v215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v216 := v215.FindInternedVar(lang.NewSymbol("list")) - if v216.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v216))) + tmp213 := tmp212.Get() + tmp214 := lang.Apply(tmp213, []any{lang.NewSymbol("glojure.core/when")}) + tmp215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp216 := tmp215.FindInternedVar(lang.NewSymbol("list")) + if tmp216.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp216))) } - v217 := v216.Get() - v218 := lang.Apply(v217, []any{v171}) - v219 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v220 := v219.FindInternedVar(lang.NewSymbol("list")) - if v220.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v220))) + tmp217 := tmp216.Get() + tmp218 := lang.Apply(tmp217, []any{v171}) + tmp219 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp220 := tmp219.FindInternedVar(lang.NewSymbol("list")) + if tmp220.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp220))) } - v221 := v220.Get() - v222 := lang.Apply(v142, []any{v173}) - v223 := lang.Apply(v221, []any{v222}) - v224 := lang.Apply(v210, []any{v214, v218, v223}) - v225 := lang.Apply(v207, []any{v224}) - v200 = v225 + tmp221 := tmp220.Get() + tmp222 := lang.Apply(v142, []any{v173}) + tmp223 := lang.Apply(tmp221, []any{tmp222}) + tmp224 := lang.Apply(tmp210, []any{tmp214, tmp218, tmp223}) + tmp225 := lang.Apply(tmp207, []any{tmp224}) + tmp200 = tmp225 } else { - var v226 any - v227 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v228 := v227.FindInternedVar(lang.NewSymbol("=")) - if v228.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v228))) + var tmp226 any + tmp227 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp228 := tmp227.FindInternedVar(lang.NewSymbol("=")) + if tmp228.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp228))) } - v229 := v228.Get() - v230 := lang.Apply(v229, []any{v166, lang.NewKeyword("when")}) - if lang.IsTruthy(v230) { - v231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v232 := v231.FindInternedVar(lang.NewSymbol("seq")) - if v232.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v232))) + tmp229 := tmp228.Get() + tmp230 := lang.Apply(tmp229, []any{v166, lang.NewKeyword("when")}) + if lang.IsTruthy(tmp230) { + tmp231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp232 := tmp231.FindInternedVar(lang.NewSymbol("seq")) + if tmp232.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp232))) } - v233 := v232.Get() - v234 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v235 := v234.FindInternedVar(lang.NewSymbol("concat")) - if v235.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v235))) + tmp233 := tmp232.Get() + tmp234 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp235 := tmp234.FindInternedVar(lang.NewSymbol("concat")) + if tmp235.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp235))) } - v236 := v235.Get() - v237 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v238 := v237.FindInternedVar(lang.NewSymbol("list")) - if v238.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v238))) + tmp236 := tmp235.Get() + tmp237 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp238 := tmp237.FindInternedVar(lang.NewSymbol("list")) + if tmp238.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp238))) } - v239 := v238.Get() - v240 := lang.Apply(v239, []any{lang.NewSymbol("if")}) - v241 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v242 := v241.FindInternedVar(lang.NewSymbol("list")) - if v242.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v242))) + tmp239 := tmp238.Get() + tmp240 := lang.Apply(tmp239, []any{lang.NewSymbol("if")}) + tmp241 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp242 := tmp241.FindInternedVar(lang.NewSymbol("list")) + if tmp242.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp242))) } - v243 := v242.Get() - v244 := lang.Apply(v243, []any{v171}) - v245 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v246 := v245.FindInternedVar(lang.NewSymbol("list")) - if v246.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v246))) + tmp243 := tmp242.Get() + tmp244 := lang.Apply(tmp243, []any{v171}) + tmp245 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp246 := tmp245.FindInternedVar(lang.NewSymbol("list")) + if tmp246.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp246))) } - v247 := v246.Get() - v248 := lang.Apply(v142, []any{v173}) - v249 := lang.Apply(v247, []any{v248}) - v250 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v251 := v250.FindInternedVar(lang.NewSymbol("list")) - if v251.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v251))) + tmp247 := tmp246.Get() + tmp248 := lang.Apply(v142, []any{v173}) + tmp249 := lang.Apply(tmp247, []any{tmp248}) + tmp250 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp251 := tmp250.FindInternedVar(lang.NewSymbol("list")) + if tmp251.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp251))) } - v252 := v251.Get() - v253 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v254 := v253.FindInternedVar(lang.NewSymbol("seq")) - if v254.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v254))) + tmp252 := tmp251.Get() + tmp253 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp254 := tmp253.FindInternedVar(lang.NewSymbol("seq")) + if tmp254.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp254))) } - v255 := v254.Get() - v256 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v257 := v256.FindInternedVar(lang.NewSymbol("concat")) - if v257.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v257))) + tmp255 := tmp254.Get() + tmp256 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp257 := tmp256.FindInternedVar(lang.NewSymbol("concat")) + if tmp257.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp257))) } - v258 := v257.Get() - v259 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v260 := v259.FindInternedVar(lang.NewSymbol("list")) - if v260.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v260))) + tmp258 := tmp257.Get() + tmp259 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp260 := tmp259.FindInternedVar(lang.NewSymbol("list")) + if tmp260.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp260))) } - v261 := v260.Get() - v262 := lang.Apply(v261, []any{lang.NewSymbol("recur")}) - v263 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v264 := v263.FindInternedVar(lang.NewSymbol("list")) - if v264.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v264))) + tmp261 := tmp260.Get() + tmp262 := lang.Apply(tmp261, []any{lang.NewSymbol("recur")}) + tmp263 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp264 := tmp263.FindInternedVar(lang.NewSymbol("list")) + if tmp264.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp264))) } - v265 := v264.Get() - v266 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v267 := v266.FindInternedVar(lang.NewSymbol("seq")) - if v267.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v267))) + tmp265 := tmp264.Get() + tmp266 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp267 := tmp266.FindInternedVar(lang.NewSymbol("seq")) + if tmp267.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp267))) } - v268 := v267.Get() - v269 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v270 := v269.FindInternedVar(lang.NewSymbol("concat")) - if v270.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v270))) + tmp268 := tmp267.Get() + tmp269 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp270 := tmp269.FindInternedVar(lang.NewSymbol("concat")) + if tmp270.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp270))) } - v271 := v270.Get() - v272 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v273 := v272.FindInternedVar(lang.NewSymbol("list")) - if v273.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v273))) + tmp271 := tmp270.Get() + tmp272 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp273 := tmp272.FindInternedVar(lang.NewSymbol("list")) + if tmp273.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp273))) } - v274 := v273.Get() - v275 := lang.Apply(v274, []any{lang.NewSymbol("glojure.core/rest")}) - v276 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v277 := v276.FindInternedVar(lang.NewSymbol("list")) - if v277.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v277))) + tmp274 := tmp273.Get() + tmp275 := lang.Apply(tmp274, []any{lang.NewSymbol("glojure.core/rest")}) + tmp276 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp277 := tmp276.FindInternedVar(lang.NewSymbol("list")) + if tmp277.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp277))) } - v278 := v277.Get() - v279 := lang.Apply(v278, []any{v140}) - v280 := lang.Apply(v271, []any{v275, v279}) - v281 := lang.Apply(v268, []any{v280}) - v282 := lang.Apply(v265, []any{v281}) - v283 := lang.Apply(v258, []any{v262, v282}) - v284 := lang.Apply(v255, []any{v283}) - v285 := lang.Apply(v252, []any{v284}) - v286 := lang.Apply(v236, []any{v240, v244, v249, v285}) - v287 := lang.Apply(v233, []any{v286}) - v226 = v287 + tmp278 := tmp277.Get() + tmp279 := lang.Apply(tmp278, []any{v140}) + tmp280 := lang.Apply(tmp271, []any{tmp275, tmp279}) + tmp281 := lang.Apply(tmp268, []any{tmp280}) + tmp282 := lang.Apply(tmp265, []any{tmp281}) + tmp283 := lang.Apply(tmp258, []any{tmp262, tmp282}) + tmp284 := lang.Apply(tmp255, []any{tmp283}) + tmp285 := lang.Apply(tmp252, []any{tmp284}) + tmp286 := lang.Apply(tmp236, []any{tmp240, tmp244, tmp249, tmp285}) + tmp287 := lang.Apply(tmp233, []any{tmp286}) + tmp226 = tmp287 } else { - var v288 any - v289 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v290 := v289.FindInternedVar(lang.NewSymbol("keyword?")) - if v290.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v290))) + var tmp288 any + tmp289 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp290 := tmp289.FindInternedVar(lang.NewSymbol("keyword?")) + if tmp290.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp290))) } - v291 := v290.Get() - v292 := lang.Apply(v291, []any{v166}) - if lang.IsTruthy(v292) { - v293 := lang.Apply(v63, []any{"Invalid 'for' keyword ", v166}) - v288 = v293 + tmp291 := tmp290.Get() + tmp292 := lang.Apply(tmp291, []any{v166}) + if lang.IsTruthy(tmp292) { + tmp293 := lang.Apply(v63, []any{"Invalid 'for' keyword ", v166}) + tmp288 = tmp293 } else { - var v294 any + var tmp294 any if lang.IsTruthy(v129) { - v295 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v296 := v295.FindInternedVar(lang.NewSymbol("seq")) - if v296.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v296))) + tmp295 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp296 := tmp295.FindInternedVar(lang.NewSymbol("seq")) + if tmp296.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp296))) } - v297 := v296.Get() - v298 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v299 := v298.FindInternedVar(lang.NewSymbol("concat")) - if v299.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v299))) + tmp297 := tmp296.Get() + tmp298 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp299 := tmp298.FindInternedVar(lang.NewSymbol("concat")) + if tmp299.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp299))) } - v300 := v299.Get() - v301 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v302 := v301.FindInternedVar(lang.NewSymbol("list")) - if v302.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v302))) + tmp300 := tmp299.Get() + tmp301 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp302 := tmp301.FindInternedVar(lang.NewSymbol("list")) + if tmp302.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp302))) } - v303 := v302.Get() - v304 := lang.Apply(v303, []any{lang.NewSymbol("glojure.core/let")}) - v305 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v306 := v305.FindInternedVar(lang.NewSymbol("list")) - if v306.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v306))) + tmp303 := tmp302.Get() + tmp304 := lang.Apply(tmp303, []any{lang.NewSymbol("glojure.core/let")}) + tmp305 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp306 := tmp305.FindInternedVar(lang.NewSymbol("list")) + if tmp306.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp306))) } - v307 := v306.Get() - v308 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v309 := v308.FindInternedVar(lang.NewSymbol("apply")) - if v309.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v309))) + tmp307 := tmp306.Get() + tmp308 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp309 := tmp308.FindInternedVar(lang.NewSymbol("apply")) + if tmp309.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp309))) } - v310 := v309.Get() - v311 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v312 := v311.FindInternedVar(lang.NewSymbol("vector")) - if v312.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v312))) + tmp310 := tmp309.Get() + tmp311 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp312 := tmp311.FindInternedVar(lang.NewSymbol("vector")) + if tmp312.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp312))) } - v313 := v312.Get() - v314 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v315 := v314.FindInternedVar(lang.NewSymbol("seq")) - if v315.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v315))) + tmp313 := tmp312.Get() + tmp314 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp315 := tmp314.FindInternedVar(lang.NewSymbol("seq")) + if tmp315.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp315))) } - v316 := v315.Get() - v317 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v318 := v317.FindInternedVar(lang.NewSymbol("concat")) - if v318.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v318))) + tmp316 := tmp315.Get() + tmp317 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp318 := tmp317.FindInternedVar(lang.NewSymbol("concat")) + if tmp318.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp318))) } - v319 := v318.Get() - v320 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v321 := v320.FindInternedVar(lang.NewSymbol("list")) - if v321.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v321))) + tmp319 := tmp318.Get() + tmp320 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp321 := tmp320.FindInternedVar(lang.NewSymbol("list")) + if tmp321.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp321))) } - v322 := v321.Get() - v323 := lang.Apply(v322, []any{lang.NewSymbol("iterys__0__auto__")}) - v324 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v325 := v324.FindInternedVar(lang.NewSymbol("list")) - if v325.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v325))) + tmp322 := tmp321.Get() + tmp323 := lang.Apply(tmp322, []any{lang.NewSymbol("iterys__0__auto__")}) + tmp324 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp325 := tmp324.FindInternedVar(lang.NewSymbol("list")) + if tmp325.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp325))) } - v326 := v325.Get() - v327 := lang.Apply(v65, []any{v129}) - v328 := lang.Apply(v326, []any{v327}) - v329 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v330 := v329.FindInternedVar(lang.NewSymbol("list")) - if v330.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v330))) + tmp326 := tmp325.Get() + tmp327 := lang.Apply(v65, []any{v129}) + tmp328 := lang.Apply(tmp326, []any{tmp327}) + tmp329 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp330 := tmp329.FindInternedVar(lang.NewSymbol("list")) + if tmp330.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp330))) } - v331 := v330.Get() - v332 := lang.Apply(v331, []any{lang.NewSymbol("fs__1__auto__")}) - v333 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v334 := v333.FindInternedVar(lang.NewSymbol("list")) - if v334.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v334))) + tmp331 := tmp330.Get() + tmp332 := lang.Apply(tmp331, []any{lang.NewSymbol("fs__1__auto__")}) + tmp333 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp334 := tmp333.FindInternedVar(lang.NewSymbol("list")) + if tmp334.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp334))) } - v335 := v334.Get() - v336 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v337 := v336.FindInternedVar(lang.NewSymbol("seq")) - if v337.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v337))) + tmp335 := tmp334.Get() + tmp336 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp337 := tmp336.FindInternedVar(lang.NewSymbol("seq")) + if tmp337.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp337))) } - v338 := v337.Get() - v339 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v340 := v339.FindInternedVar(lang.NewSymbol("concat")) - if v340.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v340))) + tmp338 := tmp337.Get() + tmp339 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp340 := tmp339.FindInternedVar(lang.NewSymbol("concat")) + if tmp340.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp340))) } - v341 := v340.Get() - v342 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v343 := v342.FindInternedVar(lang.NewSymbol("list")) - if v343.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v343))) + tmp341 := tmp340.Get() + tmp342 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp343 := tmp342.FindInternedVar(lang.NewSymbol("list")) + if tmp343.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp343))) } - v344 := v343.Get() - v345 := lang.Apply(v344, []any{lang.NewSymbol("glojure.core/seq")}) - v346 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v347 := v346.FindInternedVar(lang.NewSymbol("list")) - if v347.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v347))) + tmp344 := tmp343.Get() + tmp345 := lang.Apply(tmp344, []any{lang.NewSymbol("glojure.core/seq")}) + tmp346 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp347 := tmp346.FindInternedVar(lang.NewSymbol("list")) + if tmp347.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp347))) } - v348 := v347.Get() - v349 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v350 := v349.FindInternedVar(lang.NewSymbol("seq")) - if v350.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v350))) + tmp348 := tmp347.Get() + tmp349 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp350 := tmp349.FindInternedVar(lang.NewSymbol("seq")) + if tmp350.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp350))) } - v351 := v350.Get() - v352 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v353 := v352.FindInternedVar(lang.NewSymbol("concat")) - if v353.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v353))) + tmp351 := tmp350.Get() + tmp352 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp353 := tmp352.FindInternedVar(lang.NewSymbol("concat")) + if tmp353.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp353))) } - v354 := v353.Get() - v355 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v356 := v355.FindInternedVar(lang.NewSymbol("list")) - if v356.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v356))) + tmp354 := tmp353.Get() + tmp355 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp356 := tmp355.FindInternedVar(lang.NewSymbol("list")) + if tmp356.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp356))) } - v357 := v356.Get() - v358 := lang.Apply(v357, []any{lang.NewSymbol("iterys__0__auto__")}) - v359 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v360 := v359.FindInternedVar(lang.NewSymbol("list")) - if v360.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v360))) + tmp357 := tmp356.Get() + tmp358 := lang.Apply(tmp357, []any{lang.NewSymbol("iterys__0__auto__")}) + tmp359 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp360 := tmp359.FindInternedVar(lang.NewSymbol("list")) + if tmp360.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp360))) } - v361 := v360.Get() - v362 := lang.Apply(v361, []any{v128}) - v363 := lang.Apply(v354, []any{v358, v362}) - v364 := lang.Apply(v351, []any{v363}) - v365 := lang.Apply(v348, []any{v364}) - v366 := lang.Apply(v341, []any{v345, v365}) - v367 := lang.Apply(v338, []any{v366}) - v368 := lang.Apply(v335, []any{v367}) - v369 := lang.Apply(v319, []any{v323, v328, v332, v368}) - v370 := lang.Apply(v316, []any{v369}) - v371 := lang.Apply(v310, []any{v313, v370}) - v372 := lang.Apply(v307, []any{v371}) - v373 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v374 := v373.FindInternedVar(lang.NewSymbol("list")) - if v374.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v374))) + tmp361 := tmp360.Get() + tmp362 := lang.Apply(tmp361, []any{v128}) + tmp363 := lang.Apply(tmp354, []any{tmp358, tmp362}) + tmp364 := lang.Apply(tmp351, []any{tmp363}) + tmp365 := lang.Apply(tmp348, []any{tmp364}) + tmp366 := lang.Apply(tmp341, []any{tmp345, tmp365}) + tmp367 := lang.Apply(tmp338, []any{tmp366}) + tmp368 := lang.Apply(tmp335, []any{tmp367}) + tmp369 := lang.Apply(tmp319, []any{tmp323, tmp328, tmp332, tmp368}) + tmp370 := lang.Apply(tmp316, []any{tmp369}) + tmp371 := lang.Apply(tmp310, []any{tmp313, tmp370}) + tmp372 := lang.Apply(tmp307, []any{tmp371}) + tmp373 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp374 := tmp373.FindInternedVar(lang.NewSymbol("list")) + if tmp374.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp374))) } - v375 := v374.Get() - v376 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v377 := v376.FindInternedVar(lang.NewSymbol("seq")) - if v377.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v377))) + tmp375 := tmp374.Get() + tmp376 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp377 := tmp376.FindInternedVar(lang.NewSymbol("seq")) + if tmp377.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp377))) } - v378 := v377.Get() - v379 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v380 := v379.FindInternedVar(lang.NewSymbol("concat")) - if v380.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v380))) + tmp378 := tmp377.Get() + tmp379 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp380 := tmp379.FindInternedVar(lang.NewSymbol("concat")) + if tmp380.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp380))) } - v381 := v380.Get() - v382 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v383 := v382.FindInternedVar(lang.NewSymbol("list")) - if v383.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v383))) + tmp381 := tmp380.Get() + tmp382 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp383 := tmp382.FindInternedVar(lang.NewSymbol("list")) + if tmp383.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp383))) } - v384 := v383.Get() - v385 := lang.Apply(v384, []any{lang.NewSymbol("if")}) - v386 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v387 := v386.FindInternedVar(lang.NewSymbol("list")) - if v387.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v387))) + tmp384 := tmp383.Get() + tmp385 := lang.Apply(tmp384, []any{lang.NewSymbol("if")}) + tmp386 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp387 := tmp386.FindInternedVar(lang.NewSymbol("list")) + if tmp387.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp387))) } - v388 := v387.Get() - v389 := lang.Apply(v388, []any{lang.NewSymbol("fs__1__auto__")}) - v390 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v391 := v390.FindInternedVar(lang.NewSymbol("list")) - if v391.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v391))) + tmp388 := tmp387.Get() + tmp389 := lang.Apply(tmp388, []any{lang.NewSymbol("fs__1__auto__")}) + tmp390 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp391 := tmp390.FindInternedVar(lang.NewSymbol("list")) + if tmp391.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp391))) } - v392 := v391.Get() - v393 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v394 := v393.FindInternedVar(lang.NewSymbol("seq")) - if v394.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v394))) + tmp392 := tmp391.Get() + tmp393 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp394 := tmp393.FindInternedVar(lang.NewSymbol("seq")) + if tmp394.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp394))) } - v395 := v394.Get() - v396 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v397 := v396.FindInternedVar(lang.NewSymbol("concat")) - if v397.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v397))) + tmp395 := tmp394.Get() + tmp396 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp397 := tmp396.FindInternedVar(lang.NewSymbol("concat")) + if tmp397.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp397))) } - v398 := v397.Get() - v399 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v400 := v399.FindInternedVar(lang.NewSymbol("list")) - if v400.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v400))) + tmp398 := tmp397.Get() + tmp399 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp400 := tmp399.FindInternedVar(lang.NewSymbol("list")) + if tmp400.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp400))) } - v401 := v400.Get() - v402 := lang.Apply(v401, []any{lang.NewSymbol("glojure.core/concat")}) - v403 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v404 := v403.FindInternedVar(lang.NewSymbol("list")) - if v404.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v404))) + tmp401 := tmp400.Get() + tmp402 := lang.Apply(tmp401, []any{lang.NewSymbol("glojure.core/concat")}) + tmp403 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp404 := tmp403.FindInternedVar(lang.NewSymbol("list")) + if tmp404.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp404))) } - v405 := v404.Get() - v406 := lang.Apply(v405, []any{lang.NewSymbol("fs__1__auto__")}) - v407 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v408 := v407.FindInternedVar(lang.NewSymbol("list")) - if v408.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v408))) + tmp405 := tmp404.Get() + tmp406 := lang.Apply(tmp405, []any{lang.NewSymbol("fs__1__auto__")}) + tmp407 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp408 := tmp407.FindInternedVar(lang.NewSymbol("list")) + if tmp408.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp408))) } - v409 := v408.Get() - v410 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v411 := v410.FindInternedVar(lang.NewSymbol("seq")) - if v411.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v411))) + tmp409 := tmp408.Get() + tmp410 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp411 := tmp410.FindInternedVar(lang.NewSymbol("seq")) + if tmp411.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp411))) } - v412 := v411.Get() - v413 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v414 := v413.FindInternedVar(lang.NewSymbol("concat")) - if v414.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v414))) + tmp412 := tmp411.Get() + tmp413 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp414 := tmp413.FindInternedVar(lang.NewSymbol("concat")) + if tmp414.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp414))) } - v415 := v414.Get() - v416 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v417 := v416.FindInternedVar(lang.NewSymbol("list")) - if v417.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v417))) + tmp415 := tmp414.Get() + tmp416 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp417 := tmp416.FindInternedVar(lang.NewSymbol("list")) + if tmp417.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp417))) } - v418 := v417.Get() - v419 := lang.Apply(v418, []any{v135}) - v420 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v421 := v420.FindInternedVar(lang.NewSymbol("list")) - if v421.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v421))) + tmp418 := tmp417.Get() + tmp419 := lang.Apply(tmp418, []any{v135}) + tmp420 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp421 := tmp420.FindInternedVar(lang.NewSymbol("list")) + if tmp421.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp421))) } - v422 := v421.Get() - v423 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v424 := v423.FindInternedVar(lang.NewSymbol("seq")) - if v424.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v424))) + tmp422 := tmp421.Get() + tmp423 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp424 := tmp423.FindInternedVar(lang.NewSymbol("seq")) + if tmp424.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp424))) } - v425 := v424.Get() - v426 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v427 := v426.FindInternedVar(lang.NewSymbol("concat")) - if v427.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v427))) + tmp425 := tmp424.Get() + tmp426 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp427 := tmp426.FindInternedVar(lang.NewSymbol("concat")) + if tmp427.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp427))) } - v428 := v427.Get() - v429 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v430 := v429.FindInternedVar(lang.NewSymbol("list")) - if v430.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v430))) + tmp428 := tmp427.Get() + tmp429 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp430 := tmp429.FindInternedVar(lang.NewSymbol("list")) + if tmp430.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp430))) } - v431 := v430.Get() - v432 := lang.Apply(v431, []any{lang.NewSymbol("glojure.core/rest")}) - v433 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v434 := v433.FindInternedVar(lang.NewSymbol("list")) - if v434.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v434))) + tmp431 := tmp430.Get() + tmp432 := lang.Apply(tmp431, []any{lang.NewSymbol("glojure.core/rest")}) + tmp433 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp434 := tmp433.FindInternedVar(lang.NewSymbol("list")) + if tmp434.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp434))) } - v435 := v434.Get() - v436 := lang.Apply(v435, []any{v140}) - v437 := lang.Apply(v428, []any{v432, v436}) - v438 := lang.Apply(v425, []any{v437}) - v439 := lang.Apply(v422, []any{v438}) - v440 := lang.Apply(v415, []any{v419, v439}) - v441 := lang.Apply(v412, []any{v440}) - v442 := lang.Apply(v409, []any{v441}) - v443 := lang.Apply(v398, []any{v402, v406, v442}) - v444 := lang.Apply(v395, []any{v443}) - v445 := lang.Apply(v392, []any{v444}) - v446 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v447 := v446.FindInternedVar(lang.NewSymbol("list")) - if v447.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v447))) + tmp435 := tmp434.Get() + tmp436 := lang.Apply(tmp435, []any{v140}) + tmp437 := lang.Apply(tmp428, []any{tmp432, tmp436}) + tmp438 := lang.Apply(tmp425, []any{tmp437}) + tmp439 := lang.Apply(tmp422, []any{tmp438}) + tmp440 := lang.Apply(tmp415, []any{tmp419, tmp439}) + tmp441 := lang.Apply(tmp412, []any{tmp440}) + tmp442 := lang.Apply(tmp409, []any{tmp441}) + tmp443 := lang.Apply(tmp398, []any{tmp402, tmp406, tmp442}) + tmp444 := lang.Apply(tmp395, []any{tmp443}) + tmp445 := lang.Apply(tmp392, []any{tmp444}) + tmp446 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp447 := tmp446.FindInternedVar(lang.NewSymbol("list")) + if tmp447.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp447))) } - v448 := v447.Get() - v449 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v450 := v449.FindInternedVar(lang.NewSymbol("seq")) - if v450.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v450))) + tmp448 := tmp447.Get() + tmp449 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp450 := tmp449.FindInternedVar(lang.NewSymbol("seq")) + if tmp450.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp450))) } - v451 := v450.Get() - v452 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v453 := v452.FindInternedVar(lang.NewSymbol("concat")) - if v453.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v453))) + tmp451 := tmp450.Get() + tmp452 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp453 := tmp452.FindInternedVar(lang.NewSymbol("concat")) + if tmp453.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp453))) } - v454 := v453.Get() - v455 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v456 := v455.FindInternedVar(lang.NewSymbol("list")) - if v456.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v456))) + tmp454 := tmp453.Get() + tmp455 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp456 := tmp455.FindInternedVar(lang.NewSymbol("list")) + if tmp456.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp456))) } - v457 := v456.Get() - v458 := lang.Apply(v457, []any{lang.NewSymbol("recur")}) - v459 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v460 := v459.FindInternedVar(lang.NewSymbol("list")) - if v460.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v460))) + tmp457 := tmp456.Get() + tmp458 := lang.Apply(tmp457, []any{lang.NewSymbol("recur")}) + tmp459 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp460 := tmp459.FindInternedVar(lang.NewSymbol("list")) + if tmp460.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp460))) } - v461 := v460.Get() - v462 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v463 := v462.FindInternedVar(lang.NewSymbol("seq")) - if v463.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v463))) + tmp461 := tmp460.Get() + tmp462 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp463 := tmp462.FindInternedVar(lang.NewSymbol("seq")) + if tmp463.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp463))) } - v464 := v463.Get() - v465 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v466 := v465.FindInternedVar(lang.NewSymbol("concat")) - if v466.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v466))) + tmp464 := tmp463.Get() + tmp465 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp466 := tmp465.FindInternedVar(lang.NewSymbol("concat")) + if tmp466.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp466))) } - v467 := v466.Get() - v468 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v469 := v468.FindInternedVar(lang.NewSymbol("list")) - if v469.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v469))) + tmp467 := tmp466.Get() + tmp468 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp469 := tmp468.FindInternedVar(lang.NewSymbol("list")) + if tmp469.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp469))) } - v470 := v469.Get() - v471 := lang.Apply(v470, []any{lang.NewSymbol("glojure.core/rest")}) - v472 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v473 := v472.FindInternedVar(lang.NewSymbol("list")) - if v473.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v473))) + tmp470 := tmp469.Get() + tmp471 := lang.Apply(tmp470, []any{lang.NewSymbol("glojure.core/rest")}) + tmp472 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp473 := tmp472.FindInternedVar(lang.NewSymbol("list")) + if tmp473.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp473))) } - v474 := v473.Get() - v475 := lang.Apply(v474, []any{v140}) - v476 := lang.Apply(v467, []any{v471, v475}) - v477 := lang.Apply(v464, []any{v476}) - v478 := lang.Apply(v461, []any{v477}) - v479 := lang.Apply(v454, []any{v458, v478}) - v480 := lang.Apply(v451, []any{v479}) - v481 := lang.Apply(v448, []any{v480}) - v482 := lang.Apply(v381, []any{v385, v389, v445, v481}) - v483 := lang.Apply(v378, []any{v482}) - v484 := lang.Apply(v375, []any{v483}) - v485 := lang.Apply(v300, []any{v304, v372, v484}) - v486 := lang.Apply(v297, []any{v485}) - v294 = v486 + tmp474 := tmp473.Get() + tmp475 := lang.Apply(tmp474, []any{v140}) + tmp476 := lang.Apply(tmp467, []any{tmp471, tmp475}) + tmp477 := lang.Apply(tmp464, []any{tmp476}) + tmp478 := lang.Apply(tmp461, []any{tmp477}) + tmp479 := lang.Apply(tmp454, []any{tmp458, tmp478}) + tmp480 := lang.Apply(tmp451, []any{tmp479}) + tmp481 := lang.Apply(tmp448, []any{tmp480}) + tmp482 := lang.Apply(tmp381, []any{tmp385, tmp389, tmp445, tmp481}) + tmp483 := lang.Apply(tmp378, []any{tmp482}) + tmp484 := lang.Apply(tmp375, []any{tmp483}) + tmp485 := lang.Apply(tmp300, []any{tmp304, tmp372, tmp484}) + tmp486 := lang.Apply(tmp297, []any{tmp485}) + tmp294 = tmp486 } else { - var v487 any + var tmp487 any if lang.IsTruthy(lang.NewKeyword("else")) { - v488 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v489 := v488.FindInternedVar(lang.NewSymbol("seq")) - if v489.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v489))) + tmp488 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp489 := tmp488.FindInternedVar(lang.NewSymbol("seq")) + if tmp489.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp489))) } - v490 := v489.Get() - v491 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v492 := v491.FindInternedVar(lang.NewSymbol("concat")) - if v492.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v492))) + tmp490 := tmp489.Get() + tmp491 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp492 := tmp491.FindInternedVar(lang.NewSymbol("concat")) + if tmp492.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp492))) } - v493 := v492.Get() - v494 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v495 := v494.FindInternedVar(lang.NewSymbol("list")) - if v495.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v495))) + tmp493 := tmp492.Get() + tmp494 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp495 := tmp494.FindInternedVar(lang.NewSymbol("list")) + if tmp495.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp495))) } - v496 := v495.Get() - v497 := lang.Apply(v496, []any{lang.NewSymbol("glojure.core/cons")}) - v498 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v499 := v498.FindInternedVar(lang.NewSymbol("list")) - if v499.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v499))) + tmp496 := tmp495.Get() + tmp497 := lang.Apply(tmp496, []any{lang.NewSymbol("glojure.core/cons")}) + tmp498 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp499 := tmp498.FindInternedVar(lang.NewSymbol("list")) + if tmp499.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp499))) } - v500 := v499.Get() - v501 := lang.Apply(v500, []any{v6}) - v502 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v503 := v502.FindInternedVar(lang.NewSymbol("list")) - if v503.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v503))) + tmp500 := tmp499.Get() + tmp501 := lang.Apply(tmp500, []any{v6}) + tmp502 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp503 := tmp502.FindInternedVar(lang.NewSymbol("list")) + if tmp503.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp503))) } - v504 := v503.Get() - v505 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v506 := v505.FindInternedVar(lang.NewSymbol("seq")) - if v506.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v506))) + tmp504 := tmp503.Get() + tmp505 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp506 := tmp505.FindInternedVar(lang.NewSymbol("seq")) + if tmp506.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp506))) } - v507 := v506.Get() - v508 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v509 := v508.FindInternedVar(lang.NewSymbol("concat")) - if v509.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v509))) + tmp507 := tmp506.Get() + tmp508 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp509 := tmp508.FindInternedVar(lang.NewSymbol("concat")) + if tmp509.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp509))) } - v510 := v509.Get() - v511 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v512 := v511.FindInternedVar(lang.NewSymbol("list")) - if v512.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v512))) + tmp510 := tmp509.Get() + tmp511 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp512 := tmp511.FindInternedVar(lang.NewSymbol("list")) + if tmp512.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp512))) } - v513 := v512.Get() - v514 := lang.Apply(v513, []any{v135}) - v515 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v516 := v515.FindInternedVar(lang.NewSymbol("list")) - if v516.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v516))) + tmp513 := tmp512.Get() + tmp514 := lang.Apply(tmp513, []any{v135}) + tmp515 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp516 := tmp515.FindInternedVar(lang.NewSymbol("list")) + if tmp516.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp516))) } - v517 := v516.Get() - v518 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v519 := v518.FindInternedVar(lang.NewSymbol("seq")) - if v519.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v519))) + tmp517 := tmp516.Get() + tmp518 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp519 := tmp518.FindInternedVar(lang.NewSymbol("seq")) + if tmp519.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp519))) } - v520 := v519.Get() - v521 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v522 := v521.FindInternedVar(lang.NewSymbol("concat")) - if v522.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v522))) + tmp520 := tmp519.Get() + tmp521 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp522 := tmp521.FindInternedVar(lang.NewSymbol("concat")) + if tmp522.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp522))) } - v523 := v522.Get() - v524 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v525 := v524.FindInternedVar(lang.NewSymbol("list")) - if v525.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v525))) + tmp523 := tmp522.Get() + tmp524 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp525 := tmp524.FindInternedVar(lang.NewSymbol("list")) + if tmp525.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp525))) } - v526 := v525.Get() - v527 := lang.Apply(v526, []any{lang.NewSymbol("glojure.core/rest")}) - v528 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v529 := v528.FindInternedVar(lang.NewSymbol("list")) - if v529.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v529))) + tmp526 := tmp525.Get() + tmp527 := lang.Apply(tmp526, []any{lang.NewSymbol("glojure.core/rest")}) + tmp528 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp529 := tmp528.FindInternedVar(lang.NewSymbol("list")) + if tmp529.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp529))) } - v530 := v529.Get() - v531 := lang.Apply(v530, []any{v140}) - v532 := lang.Apply(v523, []any{v527, v531}) - v533 := lang.Apply(v520, []any{v532}) - v534 := lang.Apply(v517, []any{v533}) - v535 := lang.Apply(v510, []any{v514, v534}) - v536 := lang.Apply(v507, []any{v535}) - v537 := lang.Apply(v504, []any{v536}) - v538 := lang.Apply(v493, []any{v497, v501, v537}) - v539 := lang.Apply(v490, []any{v538}) - v487 = v539 + tmp530 := tmp529.Get() + tmp531 := lang.Apply(tmp530, []any{v140}) + tmp532 := lang.Apply(tmp523, []any{tmp527, tmp531}) + tmp533 := lang.Apply(tmp520, []any{tmp532}) + tmp534 := lang.Apply(tmp517, []any{tmp533}) + tmp535 := lang.Apply(tmp510, []any{tmp514, tmp534}) + tmp536 := lang.Apply(tmp507, []any{tmp535}) + tmp537 := lang.Apply(tmp504, []any{tmp536}) + tmp538 := lang.Apply(tmp493, []any{tmp497, tmp501, tmp537}) + tmp539 := lang.Apply(tmp490, []any{tmp538}) + tmp487 = tmp539 } else { - v487 = nil } - v294 = v487 + tmp294 = tmp487 } - v288 = v294 + tmp288 = tmp294 } - v226 = v288 + tmp226 = tmp288 } - v200 = v226 + tmp200 = tmp226 } - v174 = v200 + tmp174 = tmp200 } - v144 = v174 + tmp144 = tmp174 } // end let - return v144 + return tmp144 }) - v142 := v141 + v142 = tmp141 _ = v142 } - v142 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4672), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(4687), lang.NewKeyword("end-column"), int(73)) - v143, err := lang.WithMeta(v141, v142.(lang.IPersistentMap)) + tmp142 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4672), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(4687), lang.NewKeyword("end-column"), int(73)) + tmp143, err := lang.WithMeta(tmp141, tmp142.(lang.IPersistentMap)) if err != nil { panic(err) } - var v144 any = v143 + var v144 any = tmp143 _ = v144 - var v145 any + var tmp145 any if lang.IsTruthy(v129) { - v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v147 := v146.FindInternedVar(lang.NewSymbol("seq")) - if v147.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) + tmp146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp147 := tmp146.FindInternedVar(lang.NewSymbol("seq")) + if tmp147.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp147))) } - v148 := v147.Get() - v149 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v150 := v149.FindInternedVar(lang.NewSymbol("concat")) - if v150.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v150))) + tmp148 := tmp147.Get() + tmp149 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp150 := tmp149.FindInternedVar(lang.NewSymbol("concat")) + if tmp150.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp150))) } - v151 := v150.Get() - v152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v153 := v152.FindInternedVar(lang.NewSymbol("list")) - if v153.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v153))) + tmp151 := tmp150.Get() + tmp152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp153 := tmp152.FindInternedVar(lang.NewSymbol("list")) + if tmp153.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp153))) } - v154 := v153.Get() - v155 := lang.Apply(v154, []any{lang.NewSymbol("glojure.core/fn")}) - v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v157 := v156.FindInternedVar(lang.NewSymbol("list")) - if v157.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) + tmp154 := tmp153.Get() + tmp155 := lang.Apply(tmp154, []any{lang.NewSymbol("glojure.core/fn")}) + tmp156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp157 := tmp156.FindInternedVar(lang.NewSymbol("list")) + if tmp157.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp157))) } - v158 := v157.Get() - v159 := lang.Apply(v158, []any{v135}) - v160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v161 := v160.FindInternedVar(lang.NewSymbol("list")) - if v161.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v161))) + tmp158 := tmp157.Get() + tmp159 := lang.Apply(tmp158, []any{v135}) + tmp160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp161 := tmp160.FindInternedVar(lang.NewSymbol("list")) + if tmp161.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp161))) } - v162 := v161.Get() - v163 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v164 := v163.FindInternedVar(lang.NewSymbol("apply")) - if v164.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v164))) + tmp162 := tmp161.Get() + tmp163 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp164 := tmp163.FindInternedVar(lang.NewSymbol("apply")) + if tmp164.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp164))) } - v165 := v164.Get() - v166 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v167 := v166.FindInternedVar(lang.NewSymbol("vector")) - if v167.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v167))) + tmp165 := tmp164.Get() + tmp166 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp167 := tmp166.FindInternedVar(lang.NewSymbol("vector")) + if tmp167.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp167))) } - v168 := v167.Get() - v169 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v170 := v169.FindInternedVar(lang.NewSymbol("seq")) - if v170.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v170))) + tmp168 := tmp167.Get() + tmp169 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp170 := tmp169.FindInternedVar(lang.NewSymbol("seq")) + if tmp170.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp170))) } - v171 := v170.Get() - v172 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v173 := v172.FindInternedVar(lang.NewSymbol("concat")) - if v173.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v173))) + tmp171 := tmp170.Get() + tmp172 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp173 := tmp172.FindInternedVar(lang.NewSymbol("concat")) + if tmp173.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp173))) } - v174 := v173.Get() - v175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v176 := v175.FindInternedVar(lang.NewSymbol("list")) - if v176.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v176))) + tmp174 := tmp173.Get() + tmp175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp176 := tmp175.FindInternedVar(lang.NewSymbol("list")) + if tmp176.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp176))) } - v177 := v176.Get() - v178 := lang.Apply(v177, []any{v140}) - v179 := lang.Apply(v174, []any{v178}) - v180 := lang.Apply(v171, []any{v179}) - v181 := lang.Apply(v165, []any{v168, v180}) - v182 := lang.Apply(v162, []any{v181}) - v183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v184 := v183.FindInternedVar(lang.NewSymbol("list")) - if v184.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v184))) + tmp177 := tmp176.Get() + tmp178 := lang.Apply(tmp177, []any{v140}) + tmp179 := lang.Apply(tmp174, []any{tmp178}) + tmp180 := lang.Apply(tmp171, []any{tmp179}) + tmp181 := lang.Apply(tmp165, []any{tmp168, tmp180}) + tmp182 := lang.Apply(tmp162, []any{tmp181}) + tmp183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp184 := tmp183.FindInternedVar(lang.NewSymbol("list")) + if tmp184.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp184))) } - v185 := v184.Get() - v186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v187 := v186.FindInternedVar(lang.NewSymbol("seq")) - if v187.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v187))) + tmp185 := tmp184.Get() + tmp186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp187 := tmp186.FindInternedVar(lang.NewSymbol("seq")) + if tmp187.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp187))) } - v188 := v187.Get() - v189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v190 := v189.FindInternedVar(lang.NewSymbol("concat")) - if v190.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v190))) + tmp188 := tmp187.Get() + tmp189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp190 := tmp189.FindInternedVar(lang.NewSymbol("concat")) + if tmp190.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp190))) } - v191 := v190.Get() - v192 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v193 := v192.FindInternedVar(lang.NewSymbol("list")) - if v193.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v193))) + tmp191 := tmp190.Get() + tmp192 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp193 := tmp192.FindInternedVar(lang.NewSymbol("list")) + if tmp193.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp193))) } - v194 := v193.Get() - v195 := lang.Apply(v194, []any{lang.NewSymbol("glojure.core/lazy-seq")}) - v196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v197 := v196.FindInternedVar(lang.NewSymbol("list")) - if v197.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v197))) + tmp194 := tmp193.Get() + tmp195 := lang.Apply(tmp194, []any{lang.NewSymbol("glojure.core/lazy-seq")}) + tmp196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp197 := tmp196.FindInternedVar(lang.NewSymbol("list")) + if tmp197.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp197))) } - v198 := v197.Get() - v199 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v200 := v199.FindInternedVar(lang.NewSymbol("seq")) - if v200.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v200))) + tmp198 := tmp197.Get() + tmp199 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp200 := tmp199.FindInternedVar(lang.NewSymbol("seq")) + if tmp200.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp200))) } - v201 := v200.Get() - v202 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v203 := v202.FindInternedVar(lang.NewSymbol("concat")) - if v203.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v203))) + tmp201 := tmp200.Get() + tmp202 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp203 := tmp202.FindInternedVar(lang.NewSymbol("concat")) + if tmp203.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp203))) } - v204 := v203.Get() - v205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v206 := v205.FindInternedVar(lang.NewSymbol("list")) - if v206.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v206))) + tmp204 := tmp203.Get() + tmp205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp206 := tmp205.FindInternedVar(lang.NewSymbol("list")) + if tmp206.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp206))) } - v207 := v206.Get() - v208 := lang.Apply(v207, []any{lang.NewSymbol("glojure.core/loop")}) - v209 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v210 := v209.FindInternedVar(lang.NewSymbol("list")) - if v210.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v210))) + tmp207 := tmp206.Get() + tmp208 := lang.Apply(tmp207, []any{lang.NewSymbol("glojure.core/loop")}) + tmp209 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp210 := tmp209.FindInternedVar(lang.NewSymbol("list")) + if tmp210.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp210))) } - v211 := v210.Get() - v212 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v213 := v212.FindInternedVar(lang.NewSymbol("apply")) - if v213.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v213))) + tmp211 := tmp210.Get() + tmp212 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp213 := tmp212.FindInternedVar(lang.NewSymbol("apply")) + if tmp213.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp213))) } - v214 := v213.Get() - v215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v216 := v215.FindInternedVar(lang.NewSymbol("vector")) - if v216.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v216))) + tmp214 := tmp213.Get() + tmp215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp216 := tmp215.FindInternedVar(lang.NewSymbol("vector")) + if tmp216.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp216))) } - v217 := v216.Get() - v218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v219 := v218.FindInternedVar(lang.NewSymbol("seq")) - if v219.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v219))) + tmp217 := tmp216.Get() + tmp218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp219 := tmp218.FindInternedVar(lang.NewSymbol("seq")) + if tmp219.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp219))) } - v220 := v219.Get() - v221 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v222 := v221.FindInternedVar(lang.NewSymbol("concat")) - if v222.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v222))) + tmp220 := tmp219.Get() + tmp221 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp222 := tmp221.FindInternedVar(lang.NewSymbol("concat")) + if tmp222.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp222))) } - v223 := v222.Get() - v224 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v225 := v224.FindInternedVar(lang.NewSymbol("list")) - if v225.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v225))) + tmp223 := tmp222.Get() + tmp224 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp225 := tmp224.FindInternedVar(lang.NewSymbol("list")) + if tmp225.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp225))) } - v226 := v225.Get() - v227 := lang.Apply(v226, []any{v140}) - v228 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v229 := v228.FindInternedVar(lang.NewSymbol("list")) - if v229.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v229))) + tmp226 := tmp225.Get() + tmp227 := lang.Apply(tmp226, []any{v140}) + tmp228 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp229 := tmp228.FindInternedVar(lang.NewSymbol("list")) + if tmp229.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp229))) } - v230 := v229.Get() - v231 := lang.Apply(v230, []any{v140}) - v232 := lang.Apply(v223, []any{v227, v231}) - v233 := lang.Apply(v220, []any{v232}) - v234 := lang.Apply(v214, []any{v217, v233}) - v235 := lang.Apply(v211, []any{v234}) - v236 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v237 := v236.FindInternedVar(lang.NewSymbol("list")) - if v237.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v237))) + tmp230 := tmp229.Get() + tmp231 := lang.Apply(tmp230, []any{v140}) + tmp232 := lang.Apply(tmp223, []any{tmp227, tmp231}) + tmp233 := lang.Apply(tmp220, []any{tmp232}) + tmp234 := lang.Apply(tmp214, []any{tmp217, tmp233}) + tmp235 := lang.Apply(tmp211, []any{tmp234}) + tmp236 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp237 := tmp236.FindInternedVar(lang.NewSymbol("list")) + if tmp237.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp237))) } - v238 := v237.Get() - v239 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v240 := v239.FindInternedVar(lang.NewSymbol("seq")) - if v240.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v240))) + tmp238 := tmp237.Get() + tmp239 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp240 := tmp239.FindInternedVar(lang.NewSymbol("seq")) + if tmp240.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp240))) } - v241 := v240.Get() - v242 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v243 := v242.FindInternedVar(lang.NewSymbol("concat")) - if v243.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v243))) + tmp241 := tmp240.Get() + tmp242 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp243 := tmp242.FindInternedVar(lang.NewSymbol("concat")) + if tmp243.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp243))) } - v244 := v243.Get() - v245 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v246 := v245.FindInternedVar(lang.NewSymbol("list")) - if v246.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v246))) + tmp244 := tmp243.Get() + tmp245 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp246 := tmp245.FindInternedVar(lang.NewSymbol("list")) + if tmp246.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp246))) } - v247 := v246.Get() - v248 := lang.Apply(v247, []any{lang.NewSymbol("glojure.core/when-first")}) - v249 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v250 := v249.FindInternedVar(lang.NewSymbol("list")) - if v250.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v250))) + tmp247 := tmp246.Get() + tmp248 := lang.Apply(tmp247, []any{lang.NewSymbol("glojure.core/when-first")}) + tmp249 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp250 := tmp249.FindInternedVar(lang.NewSymbol("list")) + if tmp250.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp250))) } - v251 := v250.Get() - v252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v253 := v252.FindInternedVar(lang.NewSymbol("apply")) - if v253.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v253))) + tmp251 := tmp250.Get() + tmp252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp253 := tmp252.FindInternedVar(lang.NewSymbol("apply")) + if tmp253.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp253))) } - v254 := v253.Get() - v255 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v256 := v255.FindInternedVar(lang.NewSymbol("vector")) - if v256.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v256))) + tmp254 := tmp253.Get() + tmp255 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp256 := tmp255.FindInternedVar(lang.NewSymbol("vector")) + if tmp256.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp256))) } - v257 := v256.Get() - v258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v259 := v258.FindInternedVar(lang.NewSymbol("seq")) - if v259.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v259))) + tmp257 := tmp256.Get() + tmp258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp259 := tmp258.FindInternedVar(lang.NewSymbol("seq")) + if tmp259.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp259))) } - v260 := v259.Get() - v261 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v262 := v261.FindInternedVar(lang.NewSymbol("concat")) - if v262.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v262))) + tmp260 := tmp259.Get() + tmp261 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp262 := tmp261.FindInternedVar(lang.NewSymbol("concat")) + if tmp262.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp262))) } - v263 := v262.Get() - v264 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v265 := v264.FindInternedVar(lang.NewSymbol("list")) - if v265.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v265))) + tmp263 := tmp262.Get() + tmp264 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp265 := tmp264.FindInternedVar(lang.NewSymbol("list")) + if tmp265.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp265))) } - v266 := v265.Get() - v267 := lang.Apply(v266, []any{v100}) - v268 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v269 := v268.FindInternedVar(lang.NewSymbol("list")) - if v269.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v269))) + tmp266 := tmp265.Get() + tmp267 := lang.Apply(tmp266, []any{v100}) + tmp268 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp269 := tmp268.FindInternedVar(lang.NewSymbol("list")) + if tmp269.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp269))) } - v270 := v269.Get() - v271 := lang.Apply(v270, []any{v140}) - v272 := lang.Apply(v263, []any{v267, v271}) - v273 := lang.Apply(v260, []any{v272}) - v274 := lang.Apply(v254, []any{v257, v273}) - v275 := lang.Apply(v251, []any{v274}) - v276 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v277 := v276.FindInternedVar(lang.NewSymbol("list")) - if v277.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v277))) + tmp270 := tmp269.Get() + tmp271 := lang.Apply(tmp270, []any{v140}) + tmp272 := lang.Apply(tmp263, []any{tmp267, tmp271}) + tmp273 := lang.Apply(tmp260, []any{tmp272}) + tmp274 := lang.Apply(tmp254, []any{tmp257, tmp273}) + tmp275 := lang.Apply(tmp251, []any{tmp274}) + tmp276 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp277 := tmp276.FindInternedVar(lang.NewSymbol("list")) + if tmp277.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp277))) } - v278 := v277.Get() - v279 := lang.Apply(v144, []any{v112}) - v280 := lang.Apply(v278, []any{v279}) - v281 := lang.Apply(v244, []any{v248, v275, v280}) - v282 := lang.Apply(v241, []any{v281}) - v283 := lang.Apply(v238, []any{v282}) - v284 := lang.Apply(v204, []any{v208, v235, v283}) - v285 := lang.Apply(v201, []any{v284}) - v286 := lang.Apply(v198, []any{v285}) - v287 := lang.Apply(v191, []any{v195, v286}) - v288 := lang.Apply(v188, []any{v287}) - v289 := lang.Apply(v185, []any{v288}) - v290 := lang.Apply(v151, []any{v155, v159, v182, v289}) - v291 := lang.Apply(v148, []any{v290}) - v145 = v291 + tmp278 := tmp277.Get() + tmp279 := lang.Apply(v144, []any{v112}) + tmp280 := lang.Apply(tmp278, []any{tmp279}) + tmp281 := lang.Apply(tmp244, []any{tmp248, tmp275, tmp280}) + tmp282 := lang.Apply(tmp241, []any{tmp281}) + tmp283 := lang.Apply(tmp238, []any{tmp282}) + tmp284 := lang.Apply(tmp204, []any{tmp208, tmp235, tmp283}) + tmp285 := lang.Apply(tmp201, []any{tmp284}) + tmp286 := lang.Apply(tmp198, []any{tmp285}) + tmp287 := lang.Apply(tmp191, []any{tmp195, tmp286}) + tmp288 := lang.Apply(tmp188, []any{tmp287}) + tmp289 := lang.Apply(tmp185, []any{tmp288}) + tmp290 := lang.Apply(tmp151, []any{tmp155, tmp159, tmp182, tmp289}) + tmp291 := lang.Apply(tmp148, []any{tmp290}) + tmp145 = tmp291 } else { - var v292 any + var tmp292 any { // let // let binding "gi" - v293 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v294 := v293.FindInternedVar(lang.NewSymbol("gensym")) - if v294.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v294))) + tmp293 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp294 := tmp293.FindInternedVar(lang.NewSymbol("gensym")) + if tmp294.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp294))) } - v295 := v294.Get() - v296 := lang.Apply(v295, []any{"i__"}) - var v297 any = v296 + tmp295 := tmp294.Get() + tmp296 := lang.Apply(tmp295, []any{"i__"}) + var v297 any = tmp296 _ = v297 // let binding "gb" - v298 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v299 := v298.FindInternedVar(lang.NewSymbol("gensym")) - if v299.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v299))) + tmp298 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp299 := tmp298.FindInternedVar(lang.NewSymbol("gensym")) + if tmp299.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp299))) } - v300 := v299.Get() - v301 := lang.Apply(v300, []any{"b__"}) - var v302 any = v301 + tmp300 := tmp299.Get() + tmp301 := lang.Apply(tmp300, []any{"b__"}) + var v302 any = tmp301 _ = v302 // let binding "do-cmod" - var v303 lang.FnFunc + var tmp303 lang.FnFunc { // function do-cmod - v303 = lang.NewFnFunc(func(args ...any) any { + var v304 lang.FnFunc + tmp303 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v305 := args[0] _ = v305 - var v306 any + var tmp306 any { // let // let binding "vec__48" var v307 any = v305 _ = v307 // let binding "seq__49" - v308 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v309 := v308.FindInternedVar(lang.NewSymbol("seq")) - if v309.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v309))) + tmp308 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp309 := tmp308.FindInternedVar(lang.NewSymbol("seq")) + if tmp309.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp309))) } - v310 := v309.Get() - v311 := lang.Apply(v310, []any{v307}) - var v312 any = v311 + tmp310 := tmp309.Get() + tmp311 := lang.Apply(tmp310, []any{v307}) + var v312 any = tmp311 _ = v312 // let binding "first__50" - v313 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v314 := v313.FindInternedVar(lang.NewSymbol("first")) - if v314.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v314))) + tmp313 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp314 := tmp313.FindInternedVar(lang.NewSymbol("first")) + if tmp314.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp314))) } - v315 := v314.Get() - v316 := lang.Apply(v315, []any{v312}) - var v317 any = v316 + tmp315 := tmp314.Get() + tmp316 := lang.Apply(tmp315, []any{v312}) + var v317 any = tmp316 _ = v317 // let binding "seq__49" - v318 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v319 := v318.FindInternedVar(lang.NewSymbol("next")) - if v319.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v319))) + tmp318 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp319 := tmp318.FindInternedVar(lang.NewSymbol("next")) + if tmp319.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp319))) } - v320 := v319.Get() - v321 := lang.Apply(v320, []any{v312}) - var v322 any = v321 + tmp320 := tmp319.Get() + tmp321 := lang.Apply(tmp320, []any{v312}) + var v322 any = tmp321 _ = v322 // let binding "vec__51" var v323 any = v317 _ = v323 // let binding "k" - v324 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v325 := v324.FindInternedVar(lang.NewSymbol("nth")) - if v325.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v325))) + tmp324 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp325 := tmp324.FindInternedVar(lang.NewSymbol("nth")) + if tmp325.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp325))) } - v326 := v325.Get() - v327 := lang.Apply(v326, []any{v323, int64(0), nil}) - var v328 any = v327 + tmp326 := tmp325.Get() + tmp327 := lang.Apply(tmp326, []any{v323, int64(0), nil}) + var v328 any = tmp327 _ = v328 // let binding "v" - v329 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v330 := v329.FindInternedVar(lang.NewSymbol("nth")) - if v330.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v330))) + tmp329 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp330 := tmp329.FindInternedVar(lang.NewSymbol("nth")) + if tmp330.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp330))) } - v331 := v330.Get() - v332 := lang.Apply(v331, []any{v323, int64(1), nil}) - var v333 any = v332 + tmp331 := tmp330.Get() + tmp332 := lang.Apply(tmp331, []any{v323, int64(1), nil}) + var v333 any = tmp332 _ = v333 // let binding "pair" var v334 any = v323 @@ -38092,1739 +38196,1738 @@ func init() { // let binding "etc" var v335 any = v322 _ = v335 - var v336 any - v337 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v338 := v337.FindInternedVar(lang.NewSymbol("=")) - if v338.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v338))) + var tmp336 any + tmp337 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp338 := tmp337.FindInternedVar(lang.NewSymbol("=")) + if tmp338.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp338))) } - v339 := v338.Get() - v340 := lang.Apply(v339, []any{v328, lang.NewKeyword("let")}) - if lang.IsTruthy(v340) { - v341 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v342 := v341.FindInternedVar(lang.NewSymbol("seq")) - if v342.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v342))) + tmp339 := tmp338.Get() + tmp340 := lang.Apply(tmp339, []any{v328, lang.NewKeyword("let")}) + if lang.IsTruthy(tmp340) { + tmp341 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp342 := tmp341.FindInternedVar(lang.NewSymbol("seq")) + if tmp342.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp342))) } - v343 := v342.Get() - v344 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v345 := v344.FindInternedVar(lang.NewSymbol("concat")) - if v345.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v345))) + tmp343 := tmp342.Get() + tmp344 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp345 := tmp344.FindInternedVar(lang.NewSymbol("concat")) + if tmp345.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp345))) } - v346 := v345.Get() - v347 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v348 := v347.FindInternedVar(lang.NewSymbol("list")) - if v348.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v348))) + tmp346 := tmp345.Get() + tmp347 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp348 := tmp347.FindInternedVar(lang.NewSymbol("list")) + if tmp348.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp348))) } - v349 := v348.Get() - v350 := lang.Apply(v349, []any{lang.NewSymbol("glojure.core/let")}) - v351 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v352 := v351.FindInternedVar(lang.NewSymbol("list")) - if v352.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v352))) + tmp349 := tmp348.Get() + tmp350 := lang.Apply(tmp349, []any{lang.NewSymbol("glojure.core/let")}) + tmp351 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp352 := tmp351.FindInternedVar(lang.NewSymbol("list")) + if tmp352.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp352))) } - v353 := v352.Get() - v354 := lang.Apply(v353, []any{v333}) - v355 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v356 := v355.FindInternedVar(lang.NewSymbol("list")) - if v356.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v356))) + tmp353 := tmp352.Get() + tmp354 := lang.Apply(tmp353, []any{v333}) + tmp355 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp356 := tmp355.FindInternedVar(lang.NewSymbol("list")) + if tmp356.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp356))) } - v357 := v356.Get() - v358 := lang.Apply(v304, []any{v335}) - v359 := lang.Apply(v357, []any{v358}) - v360 := lang.Apply(v346, []any{v350, v354, v359}) - v361 := lang.Apply(v343, []any{v360}) - v336 = v361 + tmp357 := tmp356.Get() + tmp358 := lang.Apply(v304, []any{v335}) + tmp359 := lang.Apply(tmp357, []any{tmp358}) + tmp360 := lang.Apply(tmp346, []any{tmp350, tmp354, tmp359}) + tmp361 := lang.Apply(tmp343, []any{tmp360}) + tmp336 = tmp361 } else { - var v362 any - v363 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v364 := v363.FindInternedVar(lang.NewSymbol("=")) - if v364.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v364))) + var tmp362 any + tmp363 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp364 := tmp363.FindInternedVar(lang.NewSymbol("=")) + if tmp364.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp364))) } - v365 := v364.Get() - v366 := lang.Apply(v365, []any{v328, lang.NewKeyword("while")}) - if lang.IsTruthy(v366) { - v367 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v368 := v367.FindInternedVar(lang.NewSymbol("seq")) - if v368.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v368))) + tmp365 := tmp364.Get() + tmp366 := lang.Apply(tmp365, []any{v328, lang.NewKeyword("while")}) + if lang.IsTruthy(tmp366) { + tmp367 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp368 := tmp367.FindInternedVar(lang.NewSymbol("seq")) + if tmp368.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp368))) } - v369 := v368.Get() - v370 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v371 := v370.FindInternedVar(lang.NewSymbol("concat")) - if v371.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v371))) + tmp369 := tmp368.Get() + tmp370 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp371 := tmp370.FindInternedVar(lang.NewSymbol("concat")) + if tmp371.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp371))) } - v372 := v371.Get() - v373 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v374 := v373.FindInternedVar(lang.NewSymbol("list")) - if v374.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v374))) + tmp372 := tmp371.Get() + tmp373 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp374 := tmp373.FindInternedVar(lang.NewSymbol("list")) + if tmp374.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp374))) } - v375 := v374.Get() - v376 := lang.Apply(v375, []any{lang.NewSymbol("glojure.core/when")}) - v377 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v378 := v377.FindInternedVar(lang.NewSymbol("list")) - if v378.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v378))) + tmp375 := tmp374.Get() + tmp376 := lang.Apply(tmp375, []any{lang.NewSymbol("glojure.core/when")}) + tmp377 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp378 := tmp377.FindInternedVar(lang.NewSymbol("list")) + if tmp378.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp378))) } - v379 := v378.Get() - v380 := lang.Apply(v379, []any{v333}) - v381 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v382 := v381.FindInternedVar(lang.NewSymbol("list")) - if v382.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v382))) + tmp379 := tmp378.Get() + tmp380 := lang.Apply(tmp379, []any{v333}) + tmp381 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp382 := tmp381.FindInternedVar(lang.NewSymbol("list")) + if tmp382.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp382))) } - v383 := v382.Get() - v384 := lang.Apply(v304, []any{v335}) - v385 := lang.Apply(v383, []any{v384}) - v386 := lang.Apply(v372, []any{v376, v380, v385}) - v387 := lang.Apply(v369, []any{v386}) - v362 = v387 + tmp383 := tmp382.Get() + tmp384 := lang.Apply(v304, []any{v335}) + tmp385 := lang.Apply(tmp383, []any{tmp384}) + tmp386 := lang.Apply(tmp372, []any{tmp376, tmp380, tmp385}) + tmp387 := lang.Apply(tmp369, []any{tmp386}) + tmp362 = tmp387 } else { - var v388 any - v389 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v390 := v389.FindInternedVar(lang.NewSymbol("=")) - if v390.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v390))) + var tmp388 any + tmp389 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp390 := tmp389.FindInternedVar(lang.NewSymbol("=")) + if tmp390.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp390))) } - v391 := v390.Get() - v392 := lang.Apply(v391, []any{v328, lang.NewKeyword("when")}) - if lang.IsTruthy(v392) { - v393 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v394 := v393.FindInternedVar(lang.NewSymbol("seq")) - if v394.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v394))) + tmp391 := tmp390.Get() + tmp392 := lang.Apply(tmp391, []any{v328, lang.NewKeyword("when")}) + if lang.IsTruthy(tmp392) { + tmp393 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp394 := tmp393.FindInternedVar(lang.NewSymbol("seq")) + if tmp394.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp394))) } - v395 := v394.Get() - v396 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v397 := v396.FindInternedVar(lang.NewSymbol("concat")) - if v397.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v397))) + tmp395 := tmp394.Get() + tmp396 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp397 := tmp396.FindInternedVar(lang.NewSymbol("concat")) + if tmp397.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp397))) } - v398 := v397.Get() - v399 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v400 := v399.FindInternedVar(lang.NewSymbol("list")) - if v400.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v400))) + tmp398 := tmp397.Get() + tmp399 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp400 := tmp399.FindInternedVar(lang.NewSymbol("list")) + if tmp400.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp400))) } - v401 := v400.Get() - v402 := lang.Apply(v401, []any{lang.NewSymbol("if")}) - v403 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v404 := v403.FindInternedVar(lang.NewSymbol("list")) - if v404.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v404))) + tmp401 := tmp400.Get() + tmp402 := lang.Apply(tmp401, []any{lang.NewSymbol("if")}) + tmp403 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp404 := tmp403.FindInternedVar(lang.NewSymbol("list")) + if tmp404.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp404))) } - v405 := v404.Get() - v406 := lang.Apply(v405, []any{v333}) - v407 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v408 := v407.FindInternedVar(lang.NewSymbol("list")) - if v408.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v408))) + tmp405 := tmp404.Get() + tmp406 := lang.Apply(tmp405, []any{v333}) + tmp407 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp408 := tmp407.FindInternedVar(lang.NewSymbol("list")) + if tmp408.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp408))) } - v409 := v408.Get() - v410 := lang.Apply(v304, []any{v335}) - v411 := lang.Apply(v409, []any{v410}) - v412 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v413 := v412.FindInternedVar(lang.NewSymbol("list")) - if v413.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v413))) + tmp409 := tmp408.Get() + tmp410 := lang.Apply(v304, []any{v335}) + tmp411 := lang.Apply(tmp409, []any{tmp410}) + tmp412 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp413 := tmp412.FindInternedVar(lang.NewSymbol("list")) + if tmp413.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp413))) } - v414 := v413.Get() - v415 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v416 := v415.FindInternedVar(lang.NewSymbol("seq")) - if v416.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v416))) + tmp414 := tmp413.Get() + tmp415 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp416 := tmp415.FindInternedVar(lang.NewSymbol("seq")) + if tmp416.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp416))) } - v417 := v416.Get() - v418 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v419 := v418.FindInternedVar(lang.NewSymbol("concat")) - if v419.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v419))) + tmp417 := tmp416.Get() + tmp418 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp419 := tmp418.FindInternedVar(lang.NewSymbol("concat")) + if tmp419.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp419))) } - v420 := v419.Get() - v421 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v422 := v421.FindInternedVar(lang.NewSymbol("list")) - if v422.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v422))) + tmp420 := tmp419.Get() + tmp421 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp422 := tmp421.FindInternedVar(lang.NewSymbol("list")) + if tmp422.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp422))) } - v423 := v422.Get() - v424 := lang.Apply(v423, []any{lang.NewSymbol("recur")}) - v425 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v426 := v425.FindInternedVar(lang.NewSymbol("list")) - if v426.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v426))) + tmp423 := tmp422.Get() + tmp424 := lang.Apply(tmp423, []any{lang.NewSymbol("recur")}) + tmp425 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp426 := tmp425.FindInternedVar(lang.NewSymbol("list")) + if tmp426.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp426))) } - v427 := v426.Get() - v428 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v429 := v428.FindInternedVar(lang.NewSymbol("seq")) - if v429.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v429))) + tmp427 := tmp426.Get() + tmp428 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp429 := tmp428.FindInternedVar(lang.NewSymbol("seq")) + if tmp429.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp429))) } - v430 := v429.Get() - v431 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v432 := v431.FindInternedVar(lang.NewSymbol("concat")) - if v432.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v432))) + tmp430 := tmp429.Get() + tmp431 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp432 := tmp431.FindInternedVar(lang.NewSymbol("concat")) + if tmp432.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp432))) } - v433 := v432.Get() - v434 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v435 := v434.FindInternedVar(lang.NewSymbol("list")) - if v435.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v435))) + tmp433 := tmp432.Get() + tmp434 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp435 := tmp434.FindInternedVar(lang.NewSymbol("list")) + if tmp435.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp435))) } - v436 := v435.Get() - v437 := lang.Apply(v436, []any{lang.NewSymbol("glojure.core/unchecked-inc")}) - v438 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v439 := v438.FindInternedVar(lang.NewSymbol("list")) - if v439.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v439))) + tmp436 := tmp435.Get() + tmp437 := lang.Apply(tmp436, []any{lang.NewSymbol("glojure.core/unchecked-inc")}) + tmp438 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp439 := tmp438.FindInternedVar(lang.NewSymbol("list")) + if tmp439.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp439))) } - v440 := v439.Get() - v441 := lang.Apply(v440, []any{v297}) - v442 := lang.Apply(v433, []any{v437, v441}) - v443 := lang.Apply(v430, []any{v442}) - v444 := lang.Apply(v427, []any{v443}) - v445 := lang.Apply(v420, []any{v424, v444}) - v446 := lang.Apply(v417, []any{v445}) - v447 := lang.Apply(v414, []any{v446}) - v448 := lang.Apply(v398, []any{v402, v406, v411, v447}) - v449 := lang.Apply(v395, []any{v448}) - v388 = v449 + tmp440 := tmp439.Get() + tmp441 := lang.Apply(tmp440, []any{v297}) + tmp442 := lang.Apply(tmp433, []any{tmp437, tmp441}) + tmp443 := lang.Apply(tmp430, []any{tmp442}) + tmp444 := lang.Apply(tmp427, []any{tmp443}) + tmp445 := lang.Apply(tmp420, []any{tmp424, tmp444}) + tmp446 := lang.Apply(tmp417, []any{tmp445}) + tmp447 := lang.Apply(tmp414, []any{tmp446}) + tmp448 := lang.Apply(tmp398, []any{tmp402, tmp406, tmp411, tmp447}) + tmp449 := lang.Apply(tmp395, []any{tmp448}) + tmp388 = tmp449 } else { - var v450 any - v451 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v452 := v451.FindInternedVar(lang.NewSymbol("keyword?")) - if v452.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v452))) + var tmp450 any + tmp451 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp452 := tmp451.FindInternedVar(lang.NewSymbol("keyword?")) + if tmp452.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp452))) } - v453 := v452.Get() - v454 := lang.Apply(v453, []any{v328}) - if lang.IsTruthy(v454) { - v455 := lang.Apply(v63, []any{"Invalid 'for' keyword ", v328}) - v450 = v455 + tmp453 := tmp452.Get() + tmp454 := lang.Apply(tmp453, []any{v328}) + if lang.IsTruthy(tmp454) { + tmp455 := lang.Apply(v63, []any{"Invalid 'for' keyword ", v328}) + tmp450 = tmp455 } else { - var v456 any + var tmp456 any if lang.IsTruthy(lang.NewKeyword("else")) { - v457 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v458 := v457.FindInternedVar(lang.NewSymbol("seq")) - if v458.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v458))) + tmp457 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp458 := tmp457.FindInternedVar(lang.NewSymbol("seq")) + if tmp458.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp458))) } - v459 := v458.Get() - v460 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v461 := v460.FindInternedVar(lang.NewSymbol("concat")) - if v461.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v461))) + tmp459 := tmp458.Get() + tmp460 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp461 := tmp460.FindInternedVar(lang.NewSymbol("concat")) + if tmp461.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp461))) } - v462 := v461.Get() - v463 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v464 := v463.FindInternedVar(lang.NewSymbol("list")) - if v464.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v464))) + tmp462 := tmp461.Get() + tmp463 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp464 := tmp463.FindInternedVar(lang.NewSymbol("list")) + if tmp464.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp464))) } - v465 := v464.Get() - v466 := lang.Apply(v465, []any{lang.NewSymbol("do")}) - v467 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v468 := v467.FindInternedVar(lang.NewSymbol("list")) - if v468.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v468))) + tmp465 := tmp464.Get() + tmp466 := lang.Apply(tmp465, []any{lang.NewSymbol("do")}) + tmp467 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp468 := tmp467.FindInternedVar(lang.NewSymbol("list")) + if tmp468.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp468))) } - v469 := v468.Get() - v470 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v471 := v470.FindInternedVar(lang.NewSymbol("seq")) - if v471.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v471))) + tmp469 := tmp468.Get() + tmp470 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp471 := tmp470.FindInternedVar(lang.NewSymbol("seq")) + if tmp471.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp471))) } - v472 := v471.Get() - v473 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v474 := v473.FindInternedVar(lang.NewSymbol("concat")) - if v474.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v474))) + tmp472 := tmp471.Get() + tmp473 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp474 := tmp473.FindInternedVar(lang.NewSymbol("concat")) + if tmp474.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp474))) } - v475 := v474.Get() - v476 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v477 := v476.FindInternedVar(lang.NewSymbol("list")) - if v477.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v477))) + tmp475 := tmp474.Get() + tmp476 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp477 := tmp476.FindInternedVar(lang.NewSymbol("list")) + if tmp477.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp477))) } - v478 := v477.Get() - v479 := lang.Apply(v478, []any{lang.NewSymbol("glojure.core/chunk-append")}) - v480 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v481 := v480.FindInternedVar(lang.NewSymbol("list")) - if v481.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v481))) + tmp478 := tmp477.Get() + tmp479 := lang.Apply(tmp478, []any{lang.NewSymbol("glojure.core/chunk-append")}) + tmp480 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp481 := tmp480.FindInternedVar(lang.NewSymbol("list")) + if tmp481.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp481))) } - v482 := v481.Get() - v483 := lang.Apply(v482, []any{v302}) - v484 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v485 := v484.FindInternedVar(lang.NewSymbol("list")) - if v485.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v485))) + tmp482 := tmp481.Get() + tmp483 := lang.Apply(tmp482, []any{v302}) + tmp484 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp485 := tmp484.FindInternedVar(lang.NewSymbol("list")) + if tmp485.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp485))) } - v486 := v485.Get() - v487 := lang.Apply(v486, []any{v6}) - v488 := lang.Apply(v475, []any{v479, v483, v487}) - v489 := lang.Apply(v472, []any{v488}) - v490 := lang.Apply(v469, []any{v489}) - v491 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v492 := v491.FindInternedVar(lang.NewSymbol("list")) - if v492.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v492))) + tmp486 := tmp485.Get() + tmp487 := lang.Apply(tmp486, []any{v6}) + tmp488 := lang.Apply(tmp475, []any{tmp479, tmp483, tmp487}) + tmp489 := lang.Apply(tmp472, []any{tmp488}) + tmp490 := lang.Apply(tmp469, []any{tmp489}) + tmp491 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp492 := tmp491.FindInternedVar(lang.NewSymbol("list")) + if tmp492.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp492))) } - v493 := v492.Get() - v494 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v495 := v494.FindInternedVar(lang.NewSymbol("seq")) - if v495.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v495))) + tmp493 := tmp492.Get() + tmp494 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp495 := tmp494.FindInternedVar(lang.NewSymbol("seq")) + if tmp495.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp495))) } - v496 := v495.Get() - v497 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v498 := v497.FindInternedVar(lang.NewSymbol("concat")) - if v498.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v498))) + tmp496 := tmp495.Get() + tmp497 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp498 := tmp497.FindInternedVar(lang.NewSymbol("concat")) + if tmp498.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp498))) } - v499 := v498.Get() - v500 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v501 := v500.FindInternedVar(lang.NewSymbol("list")) - if v501.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v501))) + tmp499 := tmp498.Get() + tmp500 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp501 := tmp500.FindInternedVar(lang.NewSymbol("list")) + if tmp501.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp501))) } - v502 := v501.Get() - v503 := lang.Apply(v502, []any{lang.NewSymbol("recur")}) - v504 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v505 := v504.FindInternedVar(lang.NewSymbol("list")) - if v505.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v505))) + tmp502 := tmp501.Get() + tmp503 := lang.Apply(tmp502, []any{lang.NewSymbol("recur")}) + tmp504 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp505 := tmp504.FindInternedVar(lang.NewSymbol("list")) + if tmp505.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp505))) } - v506 := v505.Get() - v507 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v508 := v507.FindInternedVar(lang.NewSymbol("seq")) - if v508.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v508))) + tmp506 := tmp505.Get() + tmp507 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp508 := tmp507.FindInternedVar(lang.NewSymbol("seq")) + if tmp508.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp508))) } - v509 := v508.Get() - v510 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v511 := v510.FindInternedVar(lang.NewSymbol("concat")) - if v511.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v511))) + tmp509 := tmp508.Get() + tmp510 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp511 := tmp510.FindInternedVar(lang.NewSymbol("concat")) + if tmp511.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp511))) } - v512 := v511.Get() - v513 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v514 := v513.FindInternedVar(lang.NewSymbol("list")) - if v514.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v514))) + tmp512 := tmp511.Get() + tmp513 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp514 := tmp513.FindInternedVar(lang.NewSymbol("list")) + if tmp514.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp514))) } - v515 := v514.Get() - v516 := lang.Apply(v515, []any{lang.NewSymbol("glojure.core/unchecked-inc")}) - v517 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v518 := v517.FindInternedVar(lang.NewSymbol("list")) - if v518.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v518))) + tmp515 := tmp514.Get() + tmp516 := lang.Apply(tmp515, []any{lang.NewSymbol("glojure.core/unchecked-inc")}) + tmp517 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp518 := tmp517.FindInternedVar(lang.NewSymbol("list")) + if tmp518.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp518))) } - v519 := v518.Get() - v520 := lang.Apply(v519, []any{v297}) - v521 := lang.Apply(v512, []any{v516, v520}) - v522 := lang.Apply(v509, []any{v521}) - v523 := lang.Apply(v506, []any{v522}) - v524 := lang.Apply(v499, []any{v503, v523}) - v525 := lang.Apply(v496, []any{v524}) - v526 := lang.Apply(v493, []any{v525}) - v527 := lang.Apply(v462, []any{v466, v490, v526}) - v528 := lang.Apply(v459, []any{v527}) - v456 = v528 + tmp519 := tmp518.Get() + tmp520 := lang.Apply(tmp519, []any{v297}) + tmp521 := lang.Apply(tmp512, []any{tmp516, tmp520}) + tmp522 := lang.Apply(tmp509, []any{tmp521}) + tmp523 := lang.Apply(tmp506, []any{tmp522}) + tmp524 := lang.Apply(tmp499, []any{tmp503, tmp523}) + tmp525 := lang.Apply(tmp496, []any{tmp524}) + tmp526 := lang.Apply(tmp493, []any{tmp525}) + tmp527 := lang.Apply(tmp462, []any{tmp466, tmp490, tmp526}) + tmp528 := lang.Apply(tmp459, []any{tmp527}) + tmp456 = tmp528 } else { - v456 = nil } - v450 = v456 + tmp450 = tmp456 } - v388 = v450 + tmp388 = tmp450 } - v362 = v388 + tmp362 = tmp388 } - v336 = v362 + tmp336 = tmp362 } - v306 = v336 + tmp306 = tmp336 } // end let - return v306 + return tmp306 }) - v304 := v303 + v304 = tmp303 _ = v304 } - v304 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4698), lang.NewKeyword("column"), int(39), lang.NewKeyword("end-line"), int(4710), lang.NewKeyword("end-column"), int(79)) - v305, err := lang.WithMeta(v303, v304.(lang.IPersistentMap)) + tmp304 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4698), lang.NewKeyword("column"), int(39), lang.NewKeyword("end-line"), int(4710), lang.NewKeyword("end-column"), int(79)) + tmp305, err := lang.WithMeta(tmp303, tmp304.(lang.IPersistentMap)) if err != nil { panic(err) } - var v306 any = v305 + var v306 any = tmp305 _ = v306 - v307 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v308 := v307.FindInternedVar(lang.NewSymbol("seq")) - if v308.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v308))) + tmp307 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp308 := tmp307.FindInternedVar(lang.NewSymbol("seq")) + if tmp308.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp308))) } - v309 := v308.Get() - v310 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v311 := v310.FindInternedVar(lang.NewSymbol("concat")) - if v311.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v311))) + tmp309 := tmp308.Get() + tmp310 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp311 := tmp310.FindInternedVar(lang.NewSymbol("concat")) + if tmp311.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp311))) } - v312 := v311.Get() - v313 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v314 := v313.FindInternedVar(lang.NewSymbol("list")) - if v314.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v314))) + tmp312 := tmp311.Get() + tmp313 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp314 := tmp313.FindInternedVar(lang.NewSymbol("list")) + if tmp314.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp314))) } - v315 := v314.Get() - v316 := lang.Apply(v315, []any{lang.NewSymbol("glojure.core/fn")}) - v317 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v318 := v317.FindInternedVar(lang.NewSymbol("list")) - if v318.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v318))) + tmp315 := tmp314.Get() + tmp316 := lang.Apply(tmp315, []any{lang.NewSymbol("glojure.core/fn")}) + tmp317 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp318 := tmp317.FindInternedVar(lang.NewSymbol("list")) + if tmp318.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp318))) } - v319 := v318.Get() - v320 := lang.Apply(v319, []any{v135}) - v321 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v322 := v321.FindInternedVar(lang.NewSymbol("list")) - if v322.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v322))) + tmp319 := tmp318.Get() + tmp320 := lang.Apply(tmp319, []any{v135}) + tmp321 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp322 := tmp321.FindInternedVar(lang.NewSymbol("list")) + if tmp322.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp322))) } - v323 := v322.Get() - v324 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v325 := v324.FindInternedVar(lang.NewSymbol("apply")) - if v325.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v325))) + tmp323 := tmp322.Get() + tmp324 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp325 := tmp324.FindInternedVar(lang.NewSymbol("apply")) + if tmp325.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp325))) } - v326 := v325.Get() - v327 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v328 := v327.FindInternedVar(lang.NewSymbol("vector")) - if v328.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v328))) + tmp326 := tmp325.Get() + tmp327 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp328 := tmp327.FindInternedVar(lang.NewSymbol("vector")) + if tmp328.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp328))) } - v329 := v328.Get() - v330 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v331 := v330.FindInternedVar(lang.NewSymbol("seq")) - if v331.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v331))) + tmp329 := tmp328.Get() + tmp330 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp331 := tmp330.FindInternedVar(lang.NewSymbol("seq")) + if tmp331.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp331))) } - v332 := v331.Get() - v333 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v334 := v333.FindInternedVar(lang.NewSymbol("concat")) - if v334.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v334))) + tmp332 := tmp331.Get() + tmp333 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp334 := tmp333.FindInternedVar(lang.NewSymbol("concat")) + if tmp334.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp334))) } - v335 := v334.Get() - v336 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v337 := v336.FindInternedVar(lang.NewSymbol("list")) - if v337.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v337))) + tmp335 := tmp334.Get() + tmp336 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp337 := tmp336.FindInternedVar(lang.NewSymbol("list")) + if tmp337.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp337))) } - v338 := v337.Get() - v339 := lang.Apply(v338, []any{v140}) - v340 := lang.Apply(v335, []any{v339}) - v341 := lang.Apply(v332, []any{v340}) - v342 := lang.Apply(v326, []any{v329, v341}) - v343 := lang.Apply(v323, []any{v342}) - v344 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v345 := v344.FindInternedVar(lang.NewSymbol("list")) - if v345.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v345))) + tmp338 := tmp337.Get() + tmp339 := lang.Apply(tmp338, []any{v140}) + tmp340 := lang.Apply(tmp335, []any{tmp339}) + tmp341 := lang.Apply(tmp332, []any{tmp340}) + tmp342 := lang.Apply(tmp326, []any{tmp329, tmp341}) + tmp343 := lang.Apply(tmp323, []any{tmp342}) + tmp344 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp345 := tmp344.FindInternedVar(lang.NewSymbol("list")) + if tmp345.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp345))) } - v346 := v345.Get() - v347 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v348 := v347.FindInternedVar(lang.NewSymbol("seq")) - if v348.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v348))) + tmp346 := tmp345.Get() + tmp347 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp348 := tmp347.FindInternedVar(lang.NewSymbol("seq")) + if tmp348.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp348))) } - v349 := v348.Get() - v350 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v351 := v350.FindInternedVar(lang.NewSymbol("concat")) - if v351.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v351))) + tmp349 := tmp348.Get() + tmp350 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp351 := tmp350.FindInternedVar(lang.NewSymbol("concat")) + if tmp351.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp351))) } - v352 := v351.Get() - v353 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v354 := v353.FindInternedVar(lang.NewSymbol("list")) - if v354.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v354))) + tmp352 := tmp351.Get() + tmp353 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp354 := tmp353.FindInternedVar(lang.NewSymbol("list")) + if tmp354.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp354))) } - v355 := v354.Get() - v356 := lang.Apply(v355, []any{lang.NewSymbol("glojure.core/lazy-seq")}) - v357 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v358 := v357.FindInternedVar(lang.NewSymbol("list")) - if v358.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v358))) + tmp355 := tmp354.Get() + tmp356 := lang.Apply(tmp355, []any{lang.NewSymbol("glojure.core/lazy-seq")}) + tmp357 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp358 := tmp357.FindInternedVar(lang.NewSymbol("list")) + if tmp358.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp358))) } - v359 := v358.Get() - v360 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v361 := v360.FindInternedVar(lang.NewSymbol("seq")) - if v361.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v361))) + tmp359 := tmp358.Get() + tmp360 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp361 := tmp360.FindInternedVar(lang.NewSymbol("seq")) + if tmp361.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp361))) } - v362 := v361.Get() - v363 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v364 := v363.FindInternedVar(lang.NewSymbol("concat")) - if v364.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v364))) + tmp362 := tmp361.Get() + tmp363 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp364 := tmp363.FindInternedVar(lang.NewSymbol("concat")) + if tmp364.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp364))) } - v365 := v364.Get() - v366 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v367 := v366.FindInternedVar(lang.NewSymbol("list")) - if v367.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v367))) + tmp365 := tmp364.Get() + tmp366 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp367 := tmp366.FindInternedVar(lang.NewSymbol("list")) + if tmp367.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp367))) } - v368 := v367.Get() - v369 := lang.Apply(v368, []any{lang.NewSymbol("glojure.core/loop")}) - v370 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v371 := v370.FindInternedVar(lang.NewSymbol("list")) - if v371.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v371))) + tmp368 := tmp367.Get() + tmp369 := lang.Apply(tmp368, []any{lang.NewSymbol("glojure.core/loop")}) + tmp370 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp371 := tmp370.FindInternedVar(lang.NewSymbol("list")) + if tmp371.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp371))) } - v372 := v371.Get() - v373 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v374 := v373.FindInternedVar(lang.NewSymbol("apply")) - if v374.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v374))) + tmp372 := tmp371.Get() + tmp373 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp374 := tmp373.FindInternedVar(lang.NewSymbol("apply")) + if tmp374.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp374))) } - v375 := v374.Get() - v376 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v377 := v376.FindInternedVar(lang.NewSymbol("vector")) - if v377.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v377))) + tmp375 := tmp374.Get() + tmp376 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp377 := tmp376.FindInternedVar(lang.NewSymbol("vector")) + if tmp377.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp377))) } - v378 := v377.Get() - v379 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v380 := v379.FindInternedVar(lang.NewSymbol("seq")) - if v380.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v380))) + tmp378 := tmp377.Get() + tmp379 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp380 := tmp379.FindInternedVar(lang.NewSymbol("seq")) + if tmp380.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp380))) } - v381 := v380.Get() - v382 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v383 := v382.FindInternedVar(lang.NewSymbol("concat")) - if v383.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v383))) + tmp381 := tmp380.Get() + tmp382 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp383 := tmp382.FindInternedVar(lang.NewSymbol("concat")) + if tmp383.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp383))) } - v384 := v383.Get() - v385 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v386 := v385.FindInternedVar(lang.NewSymbol("list")) - if v386.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v386))) + tmp384 := tmp383.Get() + tmp385 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp386 := tmp385.FindInternedVar(lang.NewSymbol("list")) + if tmp386.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp386))) } - v387 := v386.Get() - v388 := lang.Apply(v387, []any{v140}) - v389 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v390 := v389.FindInternedVar(lang.NewSymbol("list")) - if v390.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v390))) + tmp387 := tmp386.Get() + tmp388 := lang.Apply(tmp387, []any{v140}) + tmp389 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp390 := tmp389.FindInternedVar(lang.NewSymbol("list")) + if tmp390.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp390))) } - v391 := v390.Get() - v392 := lang.Apply(v391, []any{v140}) - v393 := lang.Apply(v384, []any{v388, v392}) - v394 := lang.Apply(v381, []any{v393}) - v395 := lang.Apply(v375, []any{v378, v394}) - v396 := lang.Apply(v372, []any{v395}) - v397 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v398 := v397.FindInternedVar(lang.NewSymbol("list")) - if v398.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v398))) + tmp391 := tmp390.Get() + tmp392 := lang.Apply(tmp391, []any{v140}) + tmp393 := lang.Apply(tmp384, []any{tmp388, tmp392}) + tmp394 := lang.Apply(tmp381, []any{tmp393}) + tmp395 := lang.Apply(tmp375, []any{tmp378, tmp394}) + tmp396 := lang.Apply(tmp372, []any{tmp395}) + tmp397 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp398 := tmp397.FindInternedVar(lang.NewSymbol("list")) + if tmp398.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp398))) } - v399 := v398.Get() - v400 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v401 := v400.FindInternedVar(lang.NewSymbol("seq")) - if v401.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v401))) + tmp399 := tmp398.Get() + tmp400 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp401 := tmp400.FindInternedVar(lang.NewSymbol("seq")) + if tmp401.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp401))) } - v402 := v401.Get() - v403 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v404 := v403.FindInternedVar(lang.NewSymbol("concat")) - if v404.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v404))) + tmp402 := tmp401.Get() + tmp403 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp404 := tmp403.FindInternedVar(lang.NewSymbol("concat")) + if tmp404.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp404))) } - v405 := v404.Get() - v406 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v407 := v406.FindInternedVar(lang.NewSymbol("list")) - if v407.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v407))) + tmp405 := tmp404.Get() + tmp406 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp407 := tmp406.FindInternedVar(lang.NewSymbol("list")) + if tmp407.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp407))) } - v408 := v407.Get() - v409 := lang.Apply(v408, []any{lang.NewSymbol("glojure.core/when-let")}) - v410 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v411 := v410.FindInternedVar(lang.NewSymbol("list")) - if v411.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v411))) + tmp408 := tmp407.Get() + tmp409 := lang.Apply(tmp408, []any{lang.NewSymbol("glojure.core/when-let")}) + tmp410 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp411 := tmp410.FindInternedVar(lang.NewSymbol("list")) + if tmp411.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp411))) } - v412 := v411.Get() - v413 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v414 := v413.FindInternedVar(lang.NewSymbol("apply")) - if v414.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v414))) + tmp412 := tmp411.Get() + tmp413 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp414 := tmp413.FindInternedVar(lang.NewSymbol("apply")) + if tmp414.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp414))) } - v415 := v414.Get() - v416 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v417 := v416.FindInternedVar(lang.NewSymbol("vector")) - if v417.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v417))) + tmp415 := tmp414.Get() + tmp416 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp417 := tmp416.FindInternedVar(lang.NewSymbol("vector")) + if tmp417.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp417))) } - v418 := v417.Get() - v419 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v420 := v419.FindInternedVar(lang.NewSymbol("seq")) - if v420.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v420))) + tmp418 := tmp417.Get() + tmp419 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp420 := tmp419.FindInternedVar(lang.NewSymbol("seq")) + if tmp420.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp420))) } - v421 := v420.Get() - v422 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v423 := v422.FindInternedVar(lang.NewSymbol("concat")) - if v423.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v423))) + tmp421 := tmp420.Get() + tmp422 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp423 := tmp422.FindInternedVar(lang.NewSymbol("concat")) + if tmp423.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp423))) } - v424 := v423.Get() - v425 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v426 := v425.FindInternedVar(lang.NewSymbol("list")) - if v426.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v426))) + tmp424 := tmp423.Get() + tmp425 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp426 := tmp425.FindInternedVar(lang.NewSymbol("list")) + if tmp426.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp426))) } - v427 := v426.Get() - v428 := lang.Apply(v427, []any{v140}) - v429 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v430 := v429.FindInternedVar(lang.NewSymbol("list")) - if v430.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v430))) + tmp427 := tmp426.Get() + tmp428 := lang.Apply(tmp427, []any{v140}) + tmp429 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp430 := tmp429.FindInternedVar(lang.NewSymbol("list")) + if tmp430.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp430))) } - v431 := v430.Get() - v432 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v433 := v432.FindInternedVar(lang.NewSymbol("seq")) - if v433.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v433))) + tmp431 := tmp430.Get() + tmp432 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp433 := tmp432.FindInternedVar(lang.NewSymbol("seq")) + if tmp433.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp433))) } - v434 := v433.Get() - v435 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v436 := v435.FindInternedVar(lang.NewSymbol("concat")) - if v436.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v436))) + tmp434 := tmp433.Get() + tmp435 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp436 := tmp435.FindInternedVar(lang.NewSymbol("concat")) + if tmp436.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp436))) } - v437 := v436.Get() - v438 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v439 := v438.FindInternedVar(lang.NewSymbol("list")) - if v439.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v439))) + tmp437 := tmp436.Get() + tmp438 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp439 := tmp438.FindInternedVar(lang.NewSymbol("list")) + if tmp439.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp439))) } - v440 := v439.Get() - v441 := lang.Apply(v440, []any{lang.NewSymbol("glojure.core/seq")}) - v442 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v443 := v442.FindInternedVar(lang.NewSymbol("list")) - if v443.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v443))) + tmp440 := tmp439.Get() + tmp441 := lang.Apply(tmp440, []any{lang.NewSymbol("glojure.core/seq")}) + tmp442 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp443 := tmp442.FindInternedVar(lang.NewSymbol("list")) + if tmp443.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp443))) } - v444 := v443.Get() - v445 := lang.Apply(v444, []any{v140}) - v446 := lang.Apply(v437, []any{v441, v445}) - v447 := lang.Apply(v434, []any{v446}) - v448 := lang.Apply(v431, []any{v447}) - v449 := lang.Apply(v424, []any{v428, v448}) - v450 := lang.Apply(v421, []any{v449}) - v451 := lang.Apply(v415, []any{v418, v450}) - v452 := lang.Apply(v412, []any{v451}) - v453 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v454 := v453.FindInternedVar(lang.NewSymbol("list")) - if v454.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v454))) + tmp444 := tmp443.Get() + tmp445 := lang.Apply(tmp444, []any{v140}) + tmp446 := lang.Apply(tmp437, []any{tmp441, tmp445}) + tmp447 := lang.Apply(tmp434, []any{tmp446}) + tmp448 := lang.Apply(tmp431, []any{tmp447}) + tmp449 := lang.Apply(tmp424, []any{tmp428, tmp448}) + tmp450 := lang.Apply(tmp421, []any{tmp449}) + tmp451 := lang.Apply(tmp415, []any{tmp418, tmp450}) + tmp452 := lang.Apply(tmp412, []any{tmp451}) + tmp453 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp454 := tmp453.FindInternedVar(lang.NewSymbol("list")) + if tmp454.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp454))) } - v455 := v454.Get() - v456 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v457 := v456.FindInternedVar(lang.NewSymbol("seq")) - if v457.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v457))) + tmp455 := tmp454.Get() + tmp456 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp457 := tmp456.FindInternedVar(lang.NewSymbol("seq")) + if tmp457.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp457))) } - v458 := v457.Get() - v459 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v460 := v459.FindInternedVar(lang.NewSymbol("concat")) - if v460.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v460))) + tmp458 := tmp457.Get() + tmp459 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp460 := tmp459.FindInternedVar(lang.NewSymbol("concat")) + if tmp460.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp460))) } - v461 := v460.Get() - v462 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v463 := v462.FindInternedVar(lang.NewSymbol("list")) - if v463.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v463))) + tmp461 := tmp460.Get() + tmp462 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp463 := tmp462.FindInternedVar(lang.NewSymbol("list")) + if tmp463.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp463))) } - v464 := v463.Get() - v465 := lang.Apply(v464, []any{lang.NewSymbol("if")}) - v466 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v467 := v466.FindInternedVar(lang.NewSymbol("list")) - if v467.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v467))) + tmp464 := tmp463.Get() + tmp465 := lang.Apply(tmp464, []any{lang.NewSymbol("if")}) + tmp466 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp467 := tmp466.FindInternedVar(lang.NewSymbol("list")) + if tmp467.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp467))) } - v468 := v467.Get() - v469 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v470 := v469.FindInternedVar(lang.NewSymbol("seq")) - if v470.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v470))) + tmp468 := tmp467.Get() + tmp469 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp470 := tmp469.FindInternedVar(lang.NewSymbol("seq")) + if tmp470.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp470))) } - v471 := v470.Get() - v472 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v473 := v472.FindInternedVar(lang.NewSymbol("concat")) - if v473.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v473))) + tmp471 := tmp470.Get() + tmp472 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp473 := tmp472.FindInternedVar(lang.NewSymbol("concat")) + if tmp473.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp473))) } - v474 := v473.Get() - v475 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v476 := v475.FindInternedVar(lang.NewSymbol("list")) - if v476.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v476))) + tmp474 := tmp473.Get() + tmp475 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp476 := tmp475.FindInternedVar(lang.NewSymbol("list")) + if tmp476.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp476))) } - v477 := v476.Get() - v478 := lang.Apply(v477, []any{lang.NewSymbol("glojure.core/chunked-seq?")}) - v479 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v480 := v479.FindInternedVar(lang.NewSymbol("list")) - if v480.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v480))) + tmp477 := tmp476.Get() + tmp478 := lang.Apply(tmp477, []any{lang.NewSymbol("glojure.core/chunked-seq?")}) + tmp479 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp480 := tmp479.FindInternedVar(lang.NewSymbol("list")) + if tmp480.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp480))) } - v481 := v480.Get() - v482 := lang.Apply(v481, []any{v140}) - v483 := lang.Apply(v474, []any{v478, v482}) - v484 := lang.Apply(v471, []any{v483}) - v485 := lang.Apply(v468, []any{v484}) - v486 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v487 := v486.FindInternedVar(lang.NewSymbol("list")) - if v487.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v487))) + tmp481 := tmp480.Get() + tmp482 := lang.Apply(tmp481, []any{v140}) + tmp483 := lang.Apply(tmp474, []any{tmp478, tmp482}) + tmp484 := lang.Apply(tmp471, []any{tmp483}) + tmp485 := lang.Apply(tmp468, []any{tmp484}) + tmp486 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp487 := tmp486.FindInternedVar(lang.NewSymbol("list")) + if tmp487.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp487))) } - v488 := v487.Get() - v489 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v490 := v489.FindInternedVar(lang.NewSymbol("seq")) - if v490.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v490))) + tmp488 := tmp487.Get() + tmp489 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp490 := tmp489.FindInternedVar(lang.NewSymbol("seq")) + if tmp490.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp490))) } - v491 := v490.Get() - v492 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v493 := v492.FindInternedVar(lang.NewSymbol("concat")) - if v493.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v493))) + tmp491 := tmp490.Get() + tmp492 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp493 := tmp492.FindInternedVar(lang.NewSymbol("concat")) + if tmp493.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp493))) } - v494 := v493.Get() - v495 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v496 := v495.FindInternedVar(lang.NewSymbol("list")) - if v496.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v496))) + tmp494 := tmp493.Get() + tmp495 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp496 := tmp495.FindInternedVar(lang.NewSymbol("list")) + if tmp496.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp496))) } - v497 := v496.Get() - v498 := lang.Apply(v497, []any{lang.NewSymbol("glojure.core/let")}) - v499 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v500 := v499.FindInternedVar(lang.NewSymbol("list")) - if v500.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v500))) + tmp497 := tmp496.Get() + tmp498 := lang.Apply(tmp497, []any{lang.NewSymbol("glojure.core/let")}) + tmp499 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp500 := tmp499.FindInternedVar(lang.NewSymbol("list")) + if tmp500.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp500))) } - v501 := v500.Get() - v502 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v503 := v502.FindInternedVar(lang.NewSymbol("apply")) - if v503.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v503))) + tmp501 := tmp500.Get() + tmp502 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp503 := tmp502.FindInternedVar(lang.NewSymbol("apply")) + if tmp503.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp503))) } - v504 := v503.Get() - v505 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v506 := v505.FindInternedVar(lang.NewSymbol("vector")) - if v506.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v506))) + tmp504 := tmp503.Get() + tmp505 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp506 := tmp505.FindInternedVar(lang.NewSymbol("vector")) + if tmp506.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp506))) } - v507 := v506.Get() - v508 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v509 := v508.FindInternedVar(lang.NewSymbol("seq")) - if v509.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v509))) + tmp507 := tmp506.Get() + tmp508 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp509 := tmp508.FindInternedVar(lang.NewSymbol("seq")) + if tmp509.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp509))) } - v510 := v509.Get() - v511 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v512 := v511.FindInternedVar(lang.NewSymbol("concat")) - if v512.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v512))) + tmp510 := tmp509.Get() + tmp511 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp512 := tmp511.FindInternedVar(lang.NewSymbol("concat")) + if tmp512.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp512))) } - v513 := v512.Get() - v514 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v515 := v514.FindInternedVar(lang.NewSymbol("list")) - if v515.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v515))) + tmp513 := tmp512.Get() + tmp514 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp515 := tmp514.FindInternedVar(lang.NewSymbol("list")) + if tmp515.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp515))) } - v516 := v515.Get() - v517 := lang.Apply(v516, []any{lang.NewSymbol("c__0__auto__")}) - v518 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v519 := v518.FindInternedVar(lang.NewSymbol("list")) - if v519.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v519))) + tmp516 := tmp515.Get() + tmp517 := lang.Apply(tmp516, []any{lang.NewSymbol("c__0__auto__")}) + tmp518 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp519 := tmp518.FindInternedVar(lang.NewSymbol("list")) + if tmp519.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp519))) } - v520 := v519.Get() - v521 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v522 := v521.FindInternedVar(lang.NewSymbol("seq")) - if v522.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v522))) + tmp520 := tmp519.Get() + tmp521 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp522 := tmp521.FindInternedVar(lang.NewSymbol("seq")) + if tmp522.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp522))) } - v523 := v522.Get() - v524 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v525 := v524.FindInternedVar(lang.NewSymbol("concat")) - if v525.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v525))) + tmp523 := tmp522.Get() + tmp524 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp525 := tmp524.FindInternedVar(lang.NewSymbol("concat")) + if tmp525.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp525))) } - v526 := v525.Get() - v527 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v528 := v527.FindInternedVar(lang.NewSymbol("list")) - if v528.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v528))) + tmp526 := tmp525.Get() + tmp527 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp528 := tmp527.FindInternedVar(lang.NewSymbol("list")) + if tmp528.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp528))) } - v529 := v528.Get() - v530 := lang.Apply(v529, []any{lang.NewSymbol("glojure.core/chunk-first")}) - v531 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v532 := v531.FindInternedVar(lang.NewSymbol("list")) - if v532.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v532))) + tmp529 := tmp528.Get() + tmp530 := lang.Apply(tmp529, []any{lang.NewSymbol("glojure.core/chunk-first")}) + tmp531 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp532 := tmp531.FindInternedVar(lang.NewSymbol("list")) + if tmp532.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp532))) } - v533 := v532.Get() - v534 := lang.Apply(v533, []any{v140}) - v535 := lang.Apply(v526, []any{v530, v534}) - v536 := lang.Apply(v523, []any{v535}) - v537 := lang.Apply(v520, []any{v536}) - v538 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v539 := v538.FindInternedVar(lang.NewSymbol("list")) - if v539.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v539))) + tmp533 := tmp532.Get() + tmp534 := lang.Apply(tmp533, []any{v140}) + tmp535 := lang.Apply(tmp526, []any{tmp530, tmp534}) + tmp536 := lang.Apply(tmp523, []any{tmp535}) + tmp537 := lang.Apply(tmp520, []any{tmp536}) + tmp538 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp539 := tmp538.FindInternedVar(lang.NewSymbol("list")) + if tmp539.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp539))) } - v540 := v539.Get() - v541 := lang.Apply(v540, []any{lang.NewSymbol("size__1__auto__")}) - v542 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v543 := v542.FindInternedVar(lang.NewSymbol("list")) - if v543.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v543))) + tmp540 := tmp539.Get() + tmp541 := lang.Apply(tmp540, []any{lang.NewSymbol("size__1__auto__")}) + tmp542 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp543 := tmp542.FindInternedVar(lang.NewSymbol("list")) + if tmp543.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp543))) } - v544 := v543.Get() - v545 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v546 := v545.FindInternedVar(lang.NewSymbol("seq")) - if v546.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v546))) + tmp544 := tmp543.Get() + tmp545 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp546 := tmp545.FindInternedVar(lang.NewSymbol("seq")) + if tmp546.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp546))) } - v547 := v546.Get() - v548 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v549 := v548.FindInternedVar(lang.NewSymbol("concat")) - if v549.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v549))) + tmp547 := tmp546.Get() + tmp548 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp549 := tmp548.FindInternedVar(lang.NewSymbol("concat")) + if tmp549.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp549))) } - v550 := v549.Get() - v551 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v552 := v551.FindInternedVar(lang.NewSymbol("list")) - if v552.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v552))) + tmp550 := tmp549.Get() + tmp551 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp552 := tmp551.FindInternedVar(lang.NewSymbol("list")) + if tmp552.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp552))) } - v553 := v552.Get() - v554 := lang.Apply(v553, []any{lang.NewSymbol("glojure.core/int")}) - v555 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v556 := v555.FindInternedVar(lang.NewSymbol("list")) - if v556.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v556))) + tmp553 := tmp552.Get() + tmp554 := lang.Apply(tmp553, []any{lang.NewSymbol("glojure.core/int")}) + tmp555 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp556 := tmp555.FindInternedVar(lang.NewSymbol("list")) + if tmp556.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp556))) } - v557 := v556.Get() - v558 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v559 := v558.FindInternedVar(lang.NewSymbol("seq")) - if v559.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v559))) + tmp557 := tmp556.Get() + tmp558 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp559 := tmp558.FindInternedVar(lang.NewSymbol("seq")) + if tmp559.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp559))) } - v560 := v559.Get() - v561 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v562 := v561.FindInternedVar(lang.NewSymbol("concat")) - if v562.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v562))) + tmp560 := tmp559.Get() + tmp561 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp562 := tmp561.FindInternedVar(lang.NewSymbol("concat")) + if tmp562.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp562))) } - v563 := v562.Get() - v564 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v565 := v564.FindInternedVar(lang.NewSymbol("list")) - if v565.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v565))) + tmp563 := tmp562.Get() + tmp564 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp565 := tmp564.FindInternedVar(lang.NewSymbol("list")) + if tmp565.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp565))) } - v566 := v565.Get() - v567 := lang.Apply(v566, []any{lang.NewSymbol("glojure.core/count")}) - v568 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v569 := v568.FindInternedVar(lang.NewSymbol("list")) - if v569.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v569))) + tmp566 := tmp565.Get() + tmp567 := lang.Apply(tmp566, []any{lang.NewSymbol("glojure.core/count")}) + tmp568 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp569 := tmp568.FindInternedVar(lang.NewSymbol("list")) + if tmp569.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp569))) } - v570 := v569.Get() - v571 := lang.Apply(v570, []any{lang.NewSymbol("c__0__auto__")}) - v572 := lang.Apply(v563, []any{v567, v571}) - v573 := lang.Apply(v560, []any{v572}) - v574 := lang.Apply(v557, []any{v573}) - v575 := lang.Apply(v550, []any{v554, v574}) - v576 := lang.Apply(v547, []any{v575}) - v577 := lang.Apply(v544, []any{v576}) - v578 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v579 := v578.FindInternedVar(lang.NewSymbol("list")) - if v579.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v579))) + tmp570 := tmp569.Get() + tmp571 := lang.Apply(tmp570, []any{lang.NewSymbol("c__0__auto__")}) + tmp572 := lang.Apply(tmp563, []any{tmp567, tmp571}) + tmp573 := lang.Apply(tmp560, []any{tmp572}) + tmp574 := lang.Apply(tmp557, []any{tmp573}) + tmp575 := lang.Apply(tmp550, []any{tmp554, tmp574}) + tmp576 := lang.Apply(tmp547, []any{tmp575}) + tmp577 := lang.Apply(tmp544, []any{tmp576}) + tmp578 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp579 := tmp578.FindInternedVar(lang.NewSymbol("list")) + if tmp579.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp579))) } - v580 := v579.Get() - v581 := lang.Apply(v580, []any{v302}) - v582 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v583 := v582.FindInternedVar(lang.NewSymbol("list")) - if v583.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v583))) + tmp580 := tmp579.Get() + tmp581 := lang.Apply(tmp580, []any{v302}) + tmp582 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp583 := tmp582.FindInternedVar(lang.NewSymbol("list")) + if tmp583.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp583))) } - v584 := v583.Get() - v585 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v586 := v585.FindInternedVar(lang.NewSymbol("seq")) - if v586.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v586))) + tmp584 := tmp583.Get() + tmp585 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp586 := tmp585.FindInternedVar(lang.NewSymbol("seq")) + if tmp586.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp586))) } - v587 := v586.Get() - v588 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v589 := v588.FindInternedVar(lang.NewSymbol("concat")) - if v589.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v589))) + tmp587 := tmp586.Get() + tmp588 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp589 := tmp588.FindInternedVar(lang.NewSymbol("concat")) + if tmp589.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp589))) } - v590 := v589.Get() - v591 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v592 := v591.FindInternedVar(lang.NewSymbol("list")) - if v592.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v592))) + tmp590 := tmp589.Get() + tmp591 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp592 := tmp591.FindInternedVar(lang.NewSymbol("list")) + if tmp592.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp592))) } - v593 := v592.Get() - v594 := lang.Apply(v593, []any{lang.NewSymbol("glojure.core/chunk-buffer")}) - v595 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v596 := v595.FindInternedVar(lang.NewSymbol("list")) - if v596.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v596))) + tmp593 := tmp592.Get() + tmp594 := lang.Apply(tmp593, []any{lang.NewSymbol("glojure.core/chunk-buffer")}) + tmp595 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp596 := tmp595.FindInternedVar(lang.NewSymbol("list")) + if tmp596.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp596))) } - v597 := v596.Get() - v598 := lang.Apply(v597, []any{lang.NewSymbol("size__1__auto__")}) - v599 := lang.Apply(v590, []any{v594, v598}) - v600 := lang.Apply(v587, []any{v599}) - v601 := lang.Apply(v584, []any{v600}) - v602 := lang.Apply(v513, []any{v517, v537, v541, v577, v581, v601}) - v603 := lang.Apply(v510, []any{v602}) - v604 := lang.Apply(v504, []any{v507, v603}) - v605 := lang.Apply(v501, []any{v604}) - v606 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v607 := v606.FindInternedVar(lang.NewSymbol("list")) - if v607.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v607))) + tmp597 := tmp596.Get() + tmp598 := lang.Apply(tmp597, []any{lang.NewSymbol("size__1__auto__")}) + tmp599 := lang.Apply(tmp590, []any{tmp594, tmp598}) + tmp600 := lang.Apply(tmp587, []any{tmp599}) + tmp601 := lang.Apply(tmp584, []any{tmp600}) + tmp602 := lang.Apply(tmp513, []any{tmp517, tmp537, tmp541, tmp577, tmp581, tmp601}) + tmp603 := lang.Apply(tmp510, []any{tmp602}) + tmp604 := lang.Apply(tmp504, []any{tmp507, tmp603}) + tmp605 := lang.Apply(tmp501, []any{tmp604}) + tmp606 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp607 := tmp606.FindInternedVar(lang.NewSymbol("list")) + if tmp607.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp607))) } - v608 := v607.Get() - v609 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v610 := v609.FindInternedVar(lang.NewSymbol("seq")) - if v610.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v610))) + tmp608 := tmp607.Get() + tmp609 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp610 := tmp609.FindInternedVar(lang.NewSymbol("seq")) + if tmp610.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp610))) } - v611 := v610.Get() - v612 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v613 := v612.FindInternedVar(lang.NewSymbol("concat")) - if v613.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v613))) + tmp611 := tmp610.Get() + tmp612 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp613 := tmp612.FindInternedVar(lang.NewSymbol("concat")) + if tmp613.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp613))) } - v614 := v613.Get() - v615 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v616 := v615.FindInternedVar(lang.NewSymbol("list")) - if v616.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v616))) + tmp614 := tmp613.Get() + tmp615 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp616 := tmp615.FindInternedVar(lang.NewSymbol("list")) + if tmp616.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp616))) } - v617 := v616.Get() - v618 := lang.Apply(v617, []any{lang.NewSymbol("if")}) - v619 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v620 := v619.FindInternedVar(lang.NewSymbol("list")) - if v620.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v620))) + tmp617 := tmp616.Get() + tmp618 := lang.Apply(tmp617, []any{lang.NewSymbol("if")}) + tmp619 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp620 := tmp619.FindInternedVar(lang.NewSymbol("list")) + if tmp620.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp620))) } - v621 := v620.Get() - v622 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v623 := v622.FindInternedVar(lang.NewSymbol("seq")) - if v623.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v623))) + tmp621 := tmp620.Get() + tmp622 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp623 := tmp622.FindInternedVar(lang.NewSymbol("seq")) + if tmp623.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp623))) } - v624 := v623.Get() - v625 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v626 := v625.FindInternedVar(lang.NewSymbol("concat")) - if v626.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v626))) + tmp624 := tmp623.Get() + tmp625 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp626 := tmp625.FindInternedVar(lang.NewSymbol("concat")) + if tmp626.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp626))) } - v627 := v626.Get() - v628 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v629 := v628.FindInternedVar(lang.NewSymbol("list")) - if v629.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v629))) + tmp627 := tmp626.Get() + tmp628 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp629 := tmp628.FindInternedVar(lang.NewSymbol("list")) + if tmp629.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp629))) } - v630 := v629.Get() - v631 := lang.Apply(v630, []any{lang.NewSymbol("glojure.core/loop")}) - v632 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v633 := v632.FindInternedVar(lang.NewSymbol("list")) - if v633.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v633))) + tmp630 := tmp629.Get() + tmp631 := lang.Apply(tmp630, []any{lang.NewSymbol("glojure.core/loop")}) + tmp632 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp633 := tmp632.FindInternedVar(lang.NewSymbol("list")) + if tmp633.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp633))) } - v634 := v633.Get() - v635 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v636 := v635.FindInternedVar(lang.NewSymbol("apply")) - if v636.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v636))) + tmp634 := tmp633.Get() + tmp635 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp636 := tmp635.FindInternedVar(lang.NewSymbol("apply")) + if tmp636.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp636))) } - v637 := v636.Get() - v638 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v639 := v638.FindInternedVar(lang.NewSymbol("vector")) - if v639.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v639))) + tmp637 := tmp636.Get() + tmp638 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp639 := tmp638.FindInternedVar(lang.NewSymbol("vector")) + if tmp639.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp639))) } - v640 := v639.Get() - v641 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v642 := v641.FindInternedVar(lang.NewSymbol("seq")) - if v642.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v642))) + tmp640 := tmp639.Get() + tmp641 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp642 := tmp641.FindInternedVar(lang.NewSymbol("seq")) + if tmp642.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp642))) } - v643 := v642.Get() - v644 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v645 := v644.FindInternedVar(lang.NewSymbol("concat")) - if v645.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v645))) + tmp643 := tmp642.Get() + tmp644 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp645 := tmp644.FindInternedVar(lang.NewSymbol("concat")) + if tmp645.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp645))) } - v646 := v645.Get() - v647 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v648 := v647.FindInternedVar(lang.NewSymbol("list")) - if v648.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v648))) + tmp646 := tmp645.Get() + tmp647 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp648 := tmp647.FindInternedVar(lang.NewSymbol("list")) + if tmp648.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp648))) } - v649 := v648.Get() - v650 := lang.Apply(v649, []any{v297}) - v651 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v652 := v651.FindInternedVar(lang.NewSymbol("list")) - if v652.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v652))) + tmp649 := tmp648.Get() + tmp650 := lang.Apply(tmp649, []any{v297}) + tmp651 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp652 := tmp651.FindInternedVar(lang.NewSymbol("list")) + if tmp652.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp652))) } - v653 := v652.Get() - v654 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v655 := v654.FindInternedVar(lang.NewSymbol("seq")) - if v655.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v655))) + tmp653 := tmp652.Get() + tmp654 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp655 := tmp654.FindInternedVar(lang.NewSymbol("seq")) + if tmp655.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp655))) } - v656 := v655.Get() - v657 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v658 := v657.FindInternedVar(lang.NewSymbol("concat")) - if v658.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v658))) + tmp656 := tmp655.Get() + tmp657 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp658 := tmp657.FindInternedVar(lang.NewSymbol("concat")) + if tmp658.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp658))) } - v659 := v658.Get() - v660 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v661 := v660.FindInternedVar(lang.NewSymbol("list")) - if v661.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v661))) + tmp659 := tmp658.Get() + tmp660 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp661 := tmp660.FindInternedVar(lang.NewSymbol("list")) + if tmp661.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp661))) } - v662 := v661.Get() - v663 := lang.Apply(v662, []any{lang.NewSymbol("glojure.core/int")}) - v664 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v665 := v664.FindInternedVar(lang.NewSymbol("list")) - if v665.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v665))) + tmp662 := tmp661.Get() + tmp663 := lang.Apply(tmp662, []any{lang.NewSymbol("glojure.core/int")}) + tmp664 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp665 := tmp664.FindInternedVar(lang.NewSymbol("list")) + if tmp665.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp665))) } - v666 := v665.Get() - v667 := lang.Apply(v666, []any{int64(0)}) - v668 := lang.Apply(v659, []any{v663, v667}) - v669 := lang.Apply(v656, []any{v668}) - v670 := lang.Apply(v653, []any{v669}) - v671 := lang.Apply(v646, []any{v650, v670}) - v672 := lang.Apply(v643, []any{v671}) - v673 := lang.Apply(v637, []any{v640, v672}) - v674 := lang.Apply(v634, []any{v673}) - v675 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v676 := v675.FindInternedVar(lang.NewSymbol("list")) - if v676.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v676))) + tmp666 := tmp665.Get() + tmp667 := lang.Apply(tmp666, []any{int64(0)}) + tmp668 := lang.Apply(tmp659, []any{tmp663, tmp667}) + tmp669 := lang.Apply(tmp656, []any{tmp668}) + tmp670 := lang.Apply(tmp653, []any{tmp669}) + tmp671 := lang.Apply(tmp646, []any{tmp650, tmp670}) + tmp672 := lang.Apply(tmp643, []any{tmp671}) + tmp673 := lang.Apply(tmp637, []any{tmp640, tmp672}) + tmp674 := lang.Apply(tmp634, []any{tmp673}) + tmp675 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp676 := tmp675.FindInternedVar(lang.NewSymbol("list")) + if tmp676.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp676))) } - v677 := v676.Get() - v678 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v679 := v678.FindInternedVar(lang.NewSymbol("seq")) - if v679.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v679))) + tmp677 := tmp676.Get() + tmp678 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp679 := tmp678.FindInternedVar(lang.NewSymbol("seq")) + if tmp679.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp679))) } - v680 := v679.Get() - v681 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v682 := v681.FindInternedVar(lang.NewSymbol("concat")) - if v682.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v682))) + tmp680 := tmp679.Get() + tmp681 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp682 := tmp681.FindInternedVar(lang.NewSymbol("concat")) + if tmp682.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp682))) } - v683 := v682.Get() - v684 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v685 := v684.FindInternedVar(lang.NewSymbol("list")) - if v685.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v685))) + tmp683 := tmp682.Get() + tmp684 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp685 := tmp684.FindInternedVar(lang.NewSymbol("list")) + if tmp685.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp685))) } - v686 := v685.Get() - v687 := lang.Apply(v686, []any{lang.NewSymbol("if")}) - v688 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v689 := v688.FindInternedVar(lang.NewSymbol("list")) - if v689.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v689))) + tmp686 := tmp685.Get() + tmp687 := lang.Apply(tmp686, []any{lang.NewSymbol("if")}) + tmp688 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp689 := tmp688.FindInternedVar(lang.NewSymbol("list")) + if tmp689.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp689))) } - v690 := v689.Get() - v691 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v692 := v691.FindInternedVar(lang.NewSymbol("seq")) - if v692.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v692))) + tmp690 := tmp689.Get() + tmp691 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp692 := tmp691.FindInternedVar(lang.NewSymbol("seq")) + if tmp692.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp692))) } - v693 := v692.Get() - v694 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v695 := v694.FindInternedVar(lang.NewSymbol("concat")) - if v695.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v695))) + tmp693 := tmp692.Get() + tmp694 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp695 := tmp694.FindInternedVar(lang.NewSymbol("concat")) + if tmp695.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp695))) } - v696 := v695.Get() - v697 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v698 := v697.FindInternedVar(lang.NewSymbol("list")) - if v698.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v698))) + tmp696 := tmp695.Get() + tmp697 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp698 := tmp697.FindInternedVar(lang.NewSymbol("list")) + if tmp698.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp698))) } - v699 := v698.Get() - v700 := lang.Apply(v699, []any{lang.NewSymbol("glojure.core/<")}) - v701 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v702 := v701.FindInternedVar(lang.NewSymbol("list")) - if v702.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v702))) + tmp699 := tmp698.Get() + tmp700 := lang.Apply(tmp699, []any{lang.NewSymbol("glojure.core/<")}) + tmp701 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp702 := tmp701.FindInternedVar(lang.NewSymbol("list")) + if tmp702.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp702))) } - v703 := v702.Get() - v704 := lang.Apply(v703, []any{v297}) - v705 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v706 := v705.FindInternedVar(lang.NewSymbol("list")) - if v706.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v706))) + tmp703 := tmp702.Get() + tmp704 := lang.Apply(tmp703, []any{v297}) + tmp705 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp706 := tmp705.FindInternedVar(lang.NewSymbol("list")) + if tmp706.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp706))) } - v707 := v706.Get() - v708 := lang.Apply(v707, []any{lang.NewSymbol("size__1__auto__")}) - v709 := lang.Apply(v696, []any{v700, v704, v708}) - v710 := lang.Apply(v693, []any{v709}) - v711 := lang.Apply(v690, []any{v710}) - v712 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v713 := v712.FindInternedVar(lang.NewSymbol("list")) - if v713.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v713))) + tmp707 := tmp706.Get() + tmp708 := lang.Apply(tmp707, []any{lang.NewSymbol("size__1__auto__")}) + tmp709 := lang.Apply(tmp696, []any{tmp700, tmp704, tmp708}) + tmp710 := lang.Apply(tmp693, []any{tmp709}) + tmp711 := lang.Apply(tmp690, []any{tmp710}) + tmp712 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp713 := tmp712.FindInternedVar(lang.NewSymbol("list")) + if tmp713.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp713))) } - v714 := v713.Get() - v715 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v716 := v715.FindInternedVar(lang.NewSymbol("seq")) - if v716.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v716))) + tmp714 := tmp713.Get() + tmp715 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp716 := tmp715.FindInternedVar(lang.NewSymbol("seq")) + if tmp716.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp716))) } - v717 := v716.Get() - v718 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v719 := v718.FindInternedVar(lang.NewSymbol("concat")) - if v719.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v719))) + tmp717 := tmp716.Get() + tmp718 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp719 := tmp718.FindInternedVar(lang.NewSymbol("concat")) + if tmp719.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp719))) } - v720 := v719.Get() - v721 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v722 := v721.FindInternedVar(lang.NewSymbol("list")) - if v722.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v722))) + tmp720 := tmp719.Get() + tmp721 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp722 := tmp721.FindInternedVar(lang.NewSymbol("list")) + if tmp722.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp722))) } - v723 := v722.Get() - v724 := lang.Apply(v723, []any{lang.NewSymbol("glojure.core/let")}) - v725 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v726 := v725.FindInternedVar(lang.NewSymbol("list")) - if v726.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v726))) + tmp723 := tmp722.Get() + tmp724 := lang.Apply(tmp723, []any{lang.NewSymbol("glojure.core/let")}) + tmp725 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp726 := tmp725.FindInternedVar(lang.NewSymbol("list")) + if tmp726.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp726))) } - v727 := v726.Get() - v728 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v729 := v728.FindInternedVar(lang.NewSymbol("apply")) - if v729.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v729))) + tmp727 := tmp726.Get() + tmp728 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp729 := tmp728.FindInternedVar(lang.NewSymbol("apply")) + if tmp729.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp729))) } - v730 := v729.Get() - v731 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v732 := v731.FindInternedVar(lang.NewSymbol("vector")) - if v732.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v732))) + tmp730 := tmp729.Get() + tmp731 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp732 := tmp731.FindInternedVar(lang.NewSymbol("vector")) + if tmp732.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp732))) } - v733 := v732.Get() - v734 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v735 := v734.FindInternedVar(lang.NewSymbol("seq")) - if v735.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v735))) + tmp733 := tmp732.Get() + tmp734 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp735 := tmp734.FindInternedVar(lang.NewSymbol("seq")) + if tmp735.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp735))) } - v736 := v735.Get() - v737 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v738 := v737.FindInternedVar(lang.NewSymbol("concat")) - if v738.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v738))) + tmp736 := tmp735.Get() + tmp737 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp738 := tmp737.FindInternedVar(lang.NewSymbol("concat")) + if tmp738.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp738))) } - v739 := v738.Get() - v740 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v741 := v740.FindInternedVar(lang.NewSymbol("list")) - if v741.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v741))) + tmp739 := tmp738.Get() + tmp740 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp741 := tmp740.FindInternedVar(lang.NewSymbol("list")) + if tmp741.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp741))) } - v742 := v741.Get() - v743 := lang.Apply(v742, []any{v100}) - v744 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v745 := v744.FindInternedVar(lang.NewSymbol("list")) - if v745.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v745))) + tmp742 := tmp741.Get() + tmp743 := lang.Apply(tmp742, []any{v100}) + tmp744 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp745 := tmp744.FindInternedVar(lang.NewSymbol("list")) + if tmp745.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp745))) } - v746 := v745.Get() - v747 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v748 := v747.FindInternedVar(lang.NewSymbol("seq")) - if v748.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v748))) + tmp746 := tmp745.Get() + tmp747 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp748 := tmp747.FindInternedVar(lang.NewSymbol("seq")) + if tmp748.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp748))) } - v749 := v748.Get() - v750 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v751 := v750.FindInternedVar(lang.NewSymbol("concat")) - if v751.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v751))) + tmp749 := tmp748.Get() + tmp750 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp751 := tmp750.FindInternedVar(lang.NewSymbol("concat")) + if tmp751.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp751))) } - v752 := v751.Get() - v753 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v754 := v753.FindInternedVar(lang.NewSymbol("list")) - if v754.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v754))) + tmp752 := tmp751.Get() + tmp753 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp754 := tmp753.FindInternedVar(lang.NewSymbol("list")) + if tmp754.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp754))) } - v755 := v754.Get() - v756 := lang.Apply(v755, []any{lang.NewSymbol(".nth")}) - v757 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v758 := v757.FindInternedVar(lang.NewSymbol("list")) - if v758.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v758))) + tmp755 := tmp754.Get() + tmp756 := lang.Apply(tmp755, []any{lang.NewSymbol(".nth")}) + tmp757 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp758 := tmp757.FindInternedVar(lang.NewSymbol("list")) + if tmp758.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp758))) } - v759 := v758.Get() - v760 := lang.Apply(v759, []any{lang.NewSymbol("c__0__auto__")}) - v761 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v762 := v761.FindInternedVar(lang.NewSymbol("list")) - if v762.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v762))) + tmp759 := tmp758.Get() + tmp760 := lang.Apply(tmp759, []any{lang.NewSymbol("c__0__auto__")}) + tmp761 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp762 := tmp761.FindInternedVar(lang.NewSymbol("list")) + if tmp762.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp762))) } - v763 := v762.Get() - v764 := lang.Apply(v763, []any{v297}) - v765 := lang.Apply(v752, []any{v756, v760, v764}) - v766 := lang.Apply(v749, []any{v765}) - v767 := lang.Apply(v746, []any{v766}) - v768 := lang.Apply(v739, []any{v743, v767}) - v769 := lang.Apply(v736, []any{v768}) - v770 := lang.Apply(v730, []any{v733, v769}) - v771 := lang.Apply(v727, []any{v770}) - v772 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v773 := v772.FindInternedVar(lang.NewSymbol("list")) - if v773.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v773))) + tmp763 := tmp762.Get() + tmp764 := lang.Apply(tmp763, []any{v297}) + tmp765 := lang.Apply(tmp752, []any{tmp756, tmp760, tmp764}) + tmp766 := lang.Apply(tmp749, []any{tmp765}) + tmp767 := lang.Apply(tmp746, []any{tmp766}) + tmp768 := lang.Apply(tmp739, []any{tmp743, tmp767}) + tmp769 := lang.Apply(tmp736, []any{tmp768}) + tmp770 := lang.Apply(tmp730, []any{tmp733, tmp769}) + tmp771 := lang.Apply(tmp727, []any{tmp770}) + tmp772 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp773 := tmp772.FindInternedVar(lang.NewSymbol("list")) + if tmp773.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp773))) } - v774 := v773.Get() - v775 := lang.Apply(v306, []any{v112}) - v776 := lang.Apply(v774, []any{v775}) - v777 := lang.Apply(v720, []any{v724, v771, v776}) - v778 := lang.Apply(v717, []any{v777}) - v779 := lang.Apply(v714, []any{v778}) - v780 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v781 := v780.FindInternedVar(lang.NewSymbol("list")) - if v781.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v781))) + tmp774 := tmp773.Get() + tmp775 := lang.Apply(v306, []any{v112}) + tmp776 := lang.Apply(tmp774, []any{tmp775}) + tmp777 := lang.Apply(tmp720, []any{tmp724, tmp771, tmp776}) + tmp778 := lang.Apply(tmp717, []any{tmp777}) + tmp779 := lang.Apply(tmp714, []any{tmp778}) + tmp780 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp781 := tmp780.FindInternedVar(lang.NewSymbol("list")) + if tmp781.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp781))) } - v782 := v781.Get() - v783 := lang.Apply(v782, []any{true}) - v784 := lang.Apply(v683, []any{v687, v711, v779, v783}) - v785 := lang.Apply(v680, []any{v784}) - v786 := lang.Apply(v677, []any{v785}) - v787 := lang.Apply(v627, []any{v631, v674, v786}) - v788 := lang.Apply(v624, []any{v787}) - v789 := lang.Apply(v621, []any{v788}) - v790 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v791 := v790.FindInternedVar(lang.NewSymbol("list")) - if v791.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v791))) + tmp782 := tmp781.Get() + tmp783 := lang.Apply(tmp782, []any{true}) + tmp784 := lang.Apply(tmp683, []any{tmp687, tmp711, tmp779, tmp783}) + tmp785 := lang.Apply(tmp680, []any{tmp784}) + tmp786 := lang.Apply(tmp677, []any{tmp785}) + tmp787 := lang.Apply(tmp627, []any{tmp631, tmp674, tmp786}) + tmp788 := lang.Apply(tmp624, []any{tmp787}) + tmp789 := lang.Apply(tmp621, []any{tmp788}) + tmp790 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp791 := tmp790.FindInternedVar(lang.NewSymbol("list")) + if tmp791.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp791))) } - v792 := v791.Get() - v793 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v794 := v793.FindInternedVar(lang.NewSymbol("seq")) - if v794.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v794))) + tmp792 := tmp791.Get() + tmp793 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp794 := tmp793.FindInternedVar(lang.NewSymbol("seq")) + if tmp794.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp794))) } - v795 := v794.Get() - v796 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v797 := v796.FindInternedVar(lang.NewSymbol("concat")) - if v797.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v797))) + tmp795 := tmp794.Get() + tmp796 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp797 := tmp796.FindInternedVar(lang.NewSymbol("concat")) + if tmp797.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp797))) } - v798 := v797.Get() - v799 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v800 := v799.FindInternedVar(lang.NewSymbol("list")) - if v800.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v800))) + tmp798 := tmp797.Get() + tmp799 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp800 := tmp799.FindInternedVar(lang.NewSymbol("list")) + if tmp800.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp800))) } - v801 := v800.Get() - v802 := lang.Apply(v801, []any{lang.NewSymbol("glojure.core/chunk-cons")}) - v803 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v804 := v803.FindInternedVar(lang.NewSymbol("list")) - if v804.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v804))) + tmp801 := tmp800.Get() + tmp802 := lang.Apply(tmp801, []any{lang.NewSymbol("glojure.core/chunk-cons")}) + tmp803 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp804 := tmp803.FindInternedVar(lang.NewSymbol("list")) + if tmp804.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp804))) } - v805 := v804.Get() - v806 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v807 := v806.FindInternedVar(lang.NewSymbol("seq")) - if v807.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v807))) + tmp805 := tmp804.Get() + tmp806 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp807 := tmp806.FindInternedVar(lang.NewSymbol("seq")) + if tmp807.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp807))) } - v808 := v807.Get() - v809 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v810 := v809.FindInternedVar(lang.NewSymbol("concat")) - if v810.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v810))) + tmp808 := tmp807.Get() + tmp809 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp810 := tmp809.FindInternedVar(lang.NewSymbol("concat")) + if tmp810.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp810))) } - v811 := v810.Get() - v812 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v813 := v812.FindInternedVar(lang.NewSymbol("list")) - if v813.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v813))) + tmp811 := tmp810.Get() + tmp812 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp813 := tmp812.FindInternedVar(lang.NewSymbol("list")) + if tmp813.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp813))) } - v814 := v813.Get() - v815 := lang.Apply(v814, []any{lang.NewSymbol("glojure.core/chunk")}) - v816 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v817 := v816.FindInternedVar(lang.NewSymbol("list")) - if v817.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v817))) + tmp814 := tmp813.Get() + tmp815 := lang.Apply(tmp814, []any{lang.NewSymbol("glojure.core/chunk")}) + tmp816 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp817 := tmp816.FindInternedVar(lang.NewSymbol("list")) + if tmp817.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp817))) } - v818 := v817.Get() - v819 := lang.Apply(v818, []any{v302}) - v820 := lang.Apply(v811, []any{v815, v819}) - v821 := lang.Apply(v808, []any{v820}) - v822 := lang.Apply(v805, []any{v821}) - v823 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v824 := v823.FindInternedVar(lang.NewSymbol("list")) - if v824.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v824))) + tmp818 := tmp817.Get() + tmp819 := lang.Apply(tmp818, []any{v302}) + tmp820 := lang.Apply(tmp811, []any{tmp815, tmp819}) + tmp821 := lang.Apply(tmp808, []any{tmp820}) + tmp822 := lang.Apply(tmp805, []any{tmp821}) + tmp823 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp824 := tmp823.FindInternedVar(lang.NewSymbol("list")) + if tmp824.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp824))) } - v825 := v824.Get() - v826 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v827 := v826.FindInternedVar(lang.NewSymbol("seq")) - if v827.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v827))) + tmp825 := tmp824.Get() + tmp826 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp827 := tmp826.FindInternedVar(lang.NewSymbol("seq")) + if tmp827.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp827))) } - v828 := v827.Get() - v829 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v830 := v829.FindInternedVar(lang.NewSymbol("concat")) - if v830.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v830))) + tmp828 := tmp827.Get() + tmp829 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp830 := tmp829.FindInternedVar(lang.NewSymbol("concat")) + if tmp830.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp830))) } - v831 := v830.Get() - v832 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v833 := v832.FindInternedVar(lang.NewSymbol("list")) - if v833.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v833))) + tmp831 := tmp830.Get() + tmp832 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp833 := tmp832.FindInternedVar(lang.NewSymbol("list")) + if tmp833.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp833))) } - v834 := v833.Get() - v835 := lang.Apply(v834, []any{v135}) - v836 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v837 := v836.FindInternedVar(lang.NewSymbol("list")) - if v837.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v837))) + tmp834 := tmp833.Get() + tmp835 := lang.Apply(tmp834, []any{v135}) + tmp836 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp837 := tmp836.FindInternedVar(lang.NewSymbol("list")) + if tmp837.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp837))) } - v838 := v837.Get() - v839 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v840 := v839.FindInternedVar(lang.NewSymbol("seq")) - if v840.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v840))) + tmp838 := tmp837.Get() + tmp839 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp840 := tmp839.FindInternedVar(lang.NewSymbol("seq")) + if tmp840.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp840))) } - v841 := v840.Get() - v842 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v843 := v842.FindInternedVar(lang.NewSymbol("concat")) - if v843.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v843))) + tmp841 := tmp840.Get() + tmp842 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp843 := tmp842.FindInternedVar(lang.NewSymbol("concat")) + if tmp843.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp843))) } - v844 := v843.Get() - v845 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v846 := v845.FindInternedVar(lang.NewSymbol("list")) - if v846.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v846))) + tmp844 := tmp843.Get() + tmp845 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp846 := tmp845.FindInternedVar(lang.NewSymbol("list")) + if tmp846.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp846))) } - v847 := v846.Get() - v848 := lang.Apply(v847, []any{lang.NewSymbol("glojure.core/chunk-rest")}) - v849 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v850 := v849.FindInternedVar(lang.NewSymbol("list")) - if v850.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v850))) + tmp847 := tmp846.Get() + tmp848 := lang.Apply(tmp847, []any{lang.NewSymbol("glojure.core/chunk-rest")}) + tmp849 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp850 := tmp849.FindInternedVar(lang.NewSymbol("list")) + if tmp850.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp850))) } - v851 := v850.Get() - v852 := lang.Apply(v851, []any{v140}) - v853 := lang.Apply(v844, []any{v848, v852}) - v854 := lang.Apply(v841, []any{v853}) - v855 := lang.Apply(v838, []any{v854}) - v856 := lang.Apply(v831, []any{v835, v855}) - v857 := lang.Apply(v828, []any{v856}) - v858 := lang.Apply(v825, []any{v857}) - v859 := lang.Apply(v798, []any{v802, v822, v858}) - v860 := lang.Apply(v795, []any{v859}) - v861 := lang.Apply(v792, []any{v860}) - v862 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v863 := v862.FindInternedVar(lang.NewSymbol("list")) - if v863.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v863))) + tmp851 := tmp850.Get() + tmp852 := lang.Apply(tmp851, []any{v140}) + tmp853 := lang.Apply(tmp844, []any{tmp848, tmp852}) + tmp854 := lang.Apply(tmp841, []any{tmp853}) + tmp855 := lang.Apply(tmp838, []any{tmp854}) + tmp856 := lang.Apply(tmp831, []any{tmp835, tmp855}) + tmp857 := lang.Apply(tmp828, []any{tmp856}) + tmp858 := lang.Apply(tmp825, []any{tmp857}) + tmp859 := lang.Apply(tmp798, []any{tmp802, tmp822, tmp858}) + tmp860 := lang.Apply(tmp795, []any{tmp859}) + tmp861 := lang.Apply(tmp792, []any{tmp860}) + tmp862 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp863 := tmp862.FindInternedVar(lang.NewSymbol("list")) + if tmp863.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp863))) } - v864 := v863.Get() - v865 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v866 := v865.FindInternedVar(lang.NewSymbol("seq")) - if v866.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v866))) + tmp864 := tmp863.Get() + tmp865 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp866 := tmp865.FindInternedVar(lang.NewSymbol("seq")) + if tmp866.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp866))) } - v867 := v866.Get() - v868 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v869 := v868.FindInternedVar(lang.NewSymbol("concat")) - if v869.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v869))) + tmp867 := tmp866.Get() + tmp868 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp869 := tmp868.FindInternedVar(lang.NewSymbol("concat")) + if tmp869.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp869))) } - v870 := v869.Get() - v871 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v872 := v871.FindInternedVar(lang.NewSymbol("list")) - if v872.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v872))) + tmp870 := tmp869.Get() + tmp871 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp872 := tmp871.FindInternedVar(lang.NewSymbol("list")) + if tmp872.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp872))) } - v873 := v872.Get() - v874 := lang.Apply(v873, []any{lang.NewSymbol("glojure.core/chunk-cons")}) - v875 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v876 := v875.FindInternedVar(lang.NewSymbol("list")) - if v876.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v876))) + tmp873 := tmp872.Get() + tmp874 := lang.Apply(tmp873, []any{lang.NewSymbol("glojure.core/chunk-cons")}) + tmp875 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp876 := tmp875.FindInternedVar(lang.NewSymbol("list")) + if tmp876.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp876))) } - v877 := v876.Get() - v878 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v879 := v878.FindInternedVar(lang.NewSymbol("seq")) - if v879.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v879))) + tmp877 := tmp876.Get() + tmp878 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp879 := tmp878.FindInternedVar(lang.NewSymbol("seq")) + if tmp879.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp879))) } - v880 := v879.Get() - v881 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v882 := v881.FindInternedVar(lang.NewSymbol("concat")) - if v882.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v882))) + tmp880 := tmp879.Get() + tmp881 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp882 := tmp881.FindInternedVar(lang.NewSymbol("concat")) + if tmp882.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp882))) } - v883 := v882.Get() - v884 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v885 := v884.FindInternedVar(lang.NewSymbol("list")) - if v885.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v885))) + tmp883 := tmp882.Get() + tmp884 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp885 := tmp884.FindInternedVar(lang.NewSymbol("list")) + if tmp885.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp885))) } - v886 := v885.Get() - v887 := lang.Apply(v886, []any{lang.NewSymbol("glojure.core/chunk")}) - v888 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v889 := v888.FindInternedVar(lang.NewSymbol("list")) - if v889.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v889))) + tmp886 := tmp885.Get() + tmp887 := lang.Apply(tmp886, []any{lang.NewSymbol("glojure.core/chunk")}) + tmp888 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp889 := tmp888.FindInternedVar(lang.NewSymbol("list")) + if tmp889.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp889))) } - v890 := v889.Get() - v891 := lang.Apply(v890, []any{v302}) - v892 := lang.Apply(v883, []any{v887, v891}) - v893 := lang.Apply(v880, []any{v892}) - v894 := lang.Apply(v877, []any{v893}) - v895 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v896 := v895.FindInternedVar(lang.NewSymbol("list")) - if v896.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v896))) + tmp890 := tmp889.Get() + tmp891 := lang.Apply(tmp890, []any{v302}) + tmp892 := lang.Apply(tmp883, []any{tmp887, tmp891}) + tmp893 := lang.Apply(tmp880, []any{tmp892}) + tmp894 := lang.Apply(tmp877, []any{tmp893}) + tmp895 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp896 := tmp895.FindInternedVar(lang.NewSymbol("list")) + if tmp896.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp896))) } - v897 := v896.Get() - v898 := lang.Apply(v897, []any{nil}) - v899 := lang.Apply(v870, []any{v874, v894, v898}) - v900 := lang.Apply(v867, []any{v899}) - v901 := lang.Apply(v864, []any{v900}) - v902 := lang.Apply(v614, []any{v618, v789, v861, v901}) - v903 := lang.Apply(v611, []any{v902}) - v904 := lang.Apply(v608, []any{v903}) - v905 := lang.Apply(v494, []any{v498, v605, v904}) - v906 := lang.Apply(v491, []any{v905}) - v907 := lang.Apply(v488, []any{v906}) - v908 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v909 := v908.FindInternedVar(lang.NewSymbol("list")) - if v909.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v909))) + tmp897 := tmp896.Get() + tmp898 := lang.Apply(tmp897, []any{nil}) + tmp899 := lang.Apply(tmp870, []any{tmp874, tmp894, tmp898}) + tmp900 := lang.Apply(tmp867, []any{tmp899}) + tmp901 := lang.Apply(tmp864, []any{tmp900}) + tmp902 := lang.Apply(tmp614, []any{tmp618, tmp789, tmp861, tmp901}) + tmp903 := lang.Apply(tmp611, []any{tmp902}) + tmp904 := lang.Apply(tmp608, []any{tmp903}) + tmp905 := lang.Apply(tmp494, []any{tmp498, tmp605, tmp904}) + tmp906 := lang.Apply(tmp491, []any{tmp905}) + tmp907 := lang.Apply(tmp488, []any{tmp906}) + tmp908 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp909 := tmp908.FindInternedVar(lang.NewSymbol("list")) + if tmp909.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp909))) } - v910 := v909.Get() - v911 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v912 := v911.FindInternedVar(lang.NewSymbol("seq")) - if v912.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v912))) + tmp910 := tmp909.Get() + tmp911 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp912 := tmp911.FindInternedVar(lang.NewSymbol("seq")) + if tmp912.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp912))) } - v913 := v912.Get() - v914 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v915 := v914.FindInternedVar(lang.NewSymbol("concat")) - if v915.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v915))) + tmp913 := tmp912.Get() + tmp914 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp915 := tmp914.FindInternedVar(lang.NewSymbol("concat")) + if tmp915.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp915))) } - v916 := v915.Get() - v917 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v918 := v917.FindInternedVar(lang.NewSymbol("list")) - if v918.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v918))) + tmp916 := tmp915.Get() + tmp917 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp918 := tmp917.FindInternedVar(lang.NewSymbol("list")) + if tmp918.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp918))) } - v919 := v918.Get() - v920 := lang.Apply(v919, []any{lang.NewSymbol("glojure.core/let")}) - v921 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v922 := v921.FindInternedVar(lang.NewSymbol("list")) - if v922.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v922))) + tmp919 := tmp918.Get() + tmp920 := lang.Apply(tmp919, []any{lang.NewSymbol("glojure.core/let")}) + tmp921 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp922 := tmp921.FindInternedVar(lang.NewSymbol("list")) + if tmp922.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp922))) } - v923 := v922.Get() - v924 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v925 := v924.FindInternedVar(lang.NewSymbol("apply")) - if v925.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v925))) + tmp923 := tmp922.Get() + tmp924 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp925 := tmp924.FindInternedVar(lang.NewSymbol("apply")) + if tmp925.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp925))) } - v926 := v925.Get() - v927 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v928 := v927.FindInternedVar(lang.NewSymbol("vector")) - if v928.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v928))) + tmp926 := tmp925.Get() + tmp927 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp928 := tmp927.FindInternedVar(lang.NewSymbol("vector")) + if tmp928.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp928))) } - v929 := v928.Get() - v930 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v931 := v930.FindInternedVar(lang.NewSymbol("seq")) - if v931.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v931))) + tmp929 := tmp928.Get() + tmp930 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp931 := tmp930.FindInternedVar(lang.NewSymbol("seq")) + if tmp931.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp931))) } - v932 := v931.Get() - v933 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v934 := v933.FindInternedVar(lang.NewSymbol("concat")) - if v934.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v934))) + tmp932 := tmp931.Get() + tmp933 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp934 := tmp933.FindInternedVar(lang.NewSymbol("concat")) + if tmp934.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp934))) } - v935 := v934.Get() - v936 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v937 := v936.FindInternedVar(lang.NewSymbol("list")) - if v937.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v937))) + tmp935 := tmp934.Get() + tmp936 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp937 := tmp936.FindInternedVar(lang.NewSymbol("list")) + if tmp937.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp937))) } - v938 := v937.Get() - v939 := lang.Apply(v938, []any{v100}) - v940 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v941 := v940.FindInternedVar(lang.NewSymbol("list")) - if v941.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v941))) + tmp938 := tmp937.Get() + tmp939 := lang.Apply(tmp938, []any{v100}) + tmp940 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp941 := tmp940.FindInternedVar(lang.NewSymbol("list")) + if tmp941.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp941))) } - v942 := v941.Get() - v943 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v944 := v943.FindInternedVar(lang.NewSymbol("seq")) - if v944.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v944))) + tmp942 := tmp941.Get() + tmp943 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp944 := tmp943.FindInternedVar(lang.NewSymbol("seq")) + if tmp944.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp944))) } - v945 := v944.Get() - v946 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v947 := v946.FindInternedVar(lang.NewSymbol("concat")) - if v947.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v947))) + tmp945 := tmp944.Get() + tmp946 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp947 := tmp946.FindInternedVar(lang.NewSymbol("concat")) + if tmp947.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp947))) } - v948 := v947.Get() - v949 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v950 := v949.FindInternedVar(lang.NewSymbol("list")) - if v950.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v950))) + tmp948 := tmp947.Get() + tmp949 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp950 := tmp949.FindInternedVar(lang.NewSymbol("list")) + if tmp950.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp950))) } - v951 := v950.Get() - v952 := lang.Apply(v951, []any{lang.NewSymbol("glojure.core/first")}) - v953 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v954 := v953.FindInternedVar(lang.NewSymbol("list")) - if v954.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v954))) + tmp951 := tmp950.Get() + tmp952 := lang.Apply(tmp951, []any{lang.NewSymbol("glojure.core/first")}) + tmp953 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp954 := tmp953.FindInternedVar(lang.NewSymbol("list")) + if tmp954.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp954))) } - v955 := v954.Get() - v956 := lang.Apply(v955, []any{v140}) - v957 := lang.Apply(v948, []any{v952, v956}) - v958 := lang.Apply(v945, []any{v957}) - v959 := lang.Apply(v942, []any{v958}) - v960 := lang.Apply(v935, []any{v939, v959}) - v961 := lang.Apply(v932, []any{v960}) - v962 := lang.Apply(v926, []any{v929, v961}) - v963 := lang.Apply(v923, []any{v962}) - v964 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v965 := v964.FindInternedVar(lang.NewSymbol("list")) - if v965.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v965))) + tmp955 := tmp954.Get() + tmp956 := lang.Apply(tmp955, []any{v140}) + tmp957 := lang.Apply(tmp948, []any{tmp952, tmp956}) + tmp958 := lang.Apply(tmp945, []any{tmp957}) + tmp959 := lang.Apply(tmp942, []any{tmp958}) + tmp960 := lang.Apply(tmp935, []any{tmp939, tmp959}) + tmp961 := lang.Apply(tmp932, []any{tmp960}) + tmp962 := lang.Apply(tmp926, []any{tmp929, tmp961}) + tmp963 := lang.Apply(tmp923, []any{tmp962}) + tmp964 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp965 := tmp964.FindInternedVar(lang.NewSymbol("list")) + if tmp965.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp965))) } - v966 := v965.Get() - v967 := lang.Apply(v144, []any{v112}) - v968 := lang.Apply(v966, []any{v967}) - v969 := lang.Apply(v916, []any{v920, v963, v968}) - v970 := lang.Apply(v913, []any{v969}) - v971 := lang.Apply(v910, []any{v970}) - v972 := lang.Apply(v461, []any{v465, v485, v907, v971}) - v973 := lang.Apply(v458, []any{v972}) - v974 := lang.Apply(v455, []any{v973}) - v975 := lang.Apply(v405, []any{v409, v452, v974}) - v976 := lang.Apply(v402, []any{v975}) - v977 := lang.Apply(v399, []any{v976}) - v978 := lang.Apply(v365, []any{v369, v396, v977}) - v979 := lang.Apply(v362, []any{v978}) - v980 := lang.Apply(v359, []any{v979}) - v981 := lang.Apply(v352, []any{v356, v980}) - v982 := lang.Apply(v349, []any{v981}) - v983 := lang.Apply(v346, []any{v982}) - v984 := lang.Apply(v312, []any{v316, v320, v343, v983}) - v985 := lang.Apply(v309, []any{v984}) - v292 = v985 + tmp966 := tmp965.Get() + tmp967 := lang.Apply(v144, []any{v112}) + tmp968 := lang.Apply(tmp966, []any{tmp967}) + tmp969 := lang.Apply(tmp916, []any{tmp920, tmp963, tmp968}) + tmp970 := lang.Apply(tmp913, []any{tmp969}) + tmp971 := lang.Apply(tmp910, []any{tmp970}) + tmp972 := lang.Apply(tmp461, []any{tmp465, tmp485, tmp907, tmp971}) + tmp973 := lang.Apply(tmp458, []any{tmp972}) + tmp974 := lang.Apply(tmp455, []any{tmp973}) + tmp975 := lang.Apply(tmp405, []any{tmp409, tmp452, tmp974}) + tmp976 := lang.Apply(tmp402, []any{tmp975}) + tmp977 := lang.Apply(tmp399, []any{tmp976}) + tmp978 := lang.Apply(tmp365, []any{tmp369, tmp396, tmp977}) + tmp979 := lang.Apply(tmp362, []any{tmp978}) + tmp980 := lang.Apply(tmp359, []any{tmp979}) + tmp981 := lang.Apply(tmp352, []any{tmp356, tmp980}) + tmp982 := lang.Apply(tmp349, []any{tmp981}) + tmp983 := lang.Apply(tmp346, []any{tmp982}) + tmp984 := lang.Apply(tmp312, []any{tmp316, tmp320, tmp343, tmp983}) + tmp985 := lang.Apply(tmp309, []any{tmp984}) + tmp292 = tmp985 } // end let - v145 = v292 + tmp145 = tmp292 } - v130 = v145 + tmp130 = tmp145 } // end let - v67 = v130 + tmp67 = tmp130 } // end let - return v67 + return tmp67 }) - v65 := v64 + v65 = tmp64 _ = v65 } - v65 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4668), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(4729), lang.NewKeyword("end-column"), int(68)) - v66, err := lang.WithMeta(v64, v65.(lang.IPersistentMap)) + tmp65 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4668), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(4729), lang.NewKeyword("end-column"), int(68)) + tmp66, err := lang.WithMeta(tmp64, tmp65.(lang.IPersistentMap)) if err != nil { panic(err) } - var v67 any = v66 + var v67 any = tmp66 _ = v67 - v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v69 := v68.FindInternedVar(lang.NewSymbol("seq")) - if v69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) - } - v70 := v69.Get() - v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v72 := v71.FindInternedVar(lang.NewSymbol("concat")) - if v72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) - } - v73 := v72.Get() - v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v75 := v74.FindInternedVar(lang.NewSymbol("list")) - if v75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) - } - v76 := v75.Get() - v77 := lang.Apply(v76, []any{lang.NewSymbol("glojure.core/let")}) - v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v79 := v78.FindInternedVar(lang.NewSymbol("list")) - if v79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) - } - v80 := v79.Get() - v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v82 := v81.FindInternedVar(lang.NewSymbol("apply")) - if v82.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) - } - v83 := v82.Get() - v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v85 := v84.FindInternedVar(lang.NewSymbol("vector")) - if v85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) - } - v86 := v85.Get() - v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v88 := v87.FindInternedVar(lang.NewSymbol("seq")) - if v88.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) - } - v89 := v88.Get() - v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v91 := v90.FindInternedVar(lang.NewSymbol("concat")) - if v91.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) - } - v92 := v91.Get() - v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v94 := v93.FindInternedVar(lang.NewSymbol("list")) - if v94.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) - } - v95 := v94.Get() - v96 := lang.Apply(v95, []any{lang.NewSymbol("iter__0__auto__")}) - v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v98 := v97.FindInternedVar(lang.NewSymbol("list")) - if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) - } - v99 := v98.Get() - v100 := lang.Apply(v59, []any{v5}) - v101 := lang.Apply(v67, []any{v100}) - v102 := lang.Apply(v99, []any{v101}) - v103 := lang.Apply(v92, []any{v96, v102}) - v104 := lang.Apply(v89, []any{v103}) - v105 := lang.Apply(v83, []any{v86, v104}) - v106 := lang.Apply(v80, []any{v105}) - v107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v108 := v107.FindInternedVar(lang.NewSymbol("list")) - if v108.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v108))) - } - v109 := v108.Get() - v110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v111 := v110.FindInternedVar(lang.NewSymbol("seq")) - if v111.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v111))) - } - v112 := v111.Get() - v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v114 := v113.FindInternedVar(lang.NewSymbol("concat")) - if v114.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) - } - v115 := v114.Get() - v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v117 := v116.FindInternedVar(lang.NewSymbol("list")) - if v117.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) - } - v118 := v117.Get() - v119 := lang.Apply(v118, []any{lang.NewSymbol("iter__0__auto__")}) - v120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v121 := v120.FindInternedVar(lang.NewSymbol("list")) - if v121.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v121))) - } - v122 := v121.Get() - v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v124 := v123.FindInternedVar(lang.NewSymbol("second")) - if v124.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) - } - v125 := v124.Get() - v126 := lang.Apply(v125, []any{v5}) - v127 := lang.Apply(v122, []any{v126}) - v128 := lang.Apply(v115, []any{v119, v127}) - v129 := lang.Apply(v112, []any{v128}) - v130 := lang.Apply(v109, []any{v129}) - v131 := lang.Apply(v73, []any{v77, v106, v130}) - v132 := lang.Apply(v70, []any{v131}) - v55 = v132 + tmp68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp69 := tmp68.FindInternedVar(lang.NewSymbol("seq")) + if tmp69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp69))) + } + tmp70 := tmp69.Get() + tmp71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp72 := tmp71.FindInternedVar(lang.NewSymbol("concat")) + if tmp72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp72))) + } + tmp73 := tmp72.Get() + tmp74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp75 := tmp74.FindInternedVar(lang.NewSymbol("list")) + if tmp75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp75))) + } + tmp76 := tmp75.Get() + tmp77 := lang.Apply(tmp76, []any{lang.NewSymbol("glojure.core/let")}) + tmp78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp79 := tmp78.FindInternedVar(lang.NewSymbol("list")) + if tmp79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp79))) + } + tmp80 := tmp79.Get() + tmp81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp82 := tmp81.FindInternedVar(lang.NewSymbol("apply")) + if tmp82.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp82))) + } + tmp83 := tmp82.Get() + tmp84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp85 := tmp84.FindInternedVar(lang.NewSymbol("vector")) + if tmp85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp85))) + } + tmp86 := tmp85.Get() + tmp87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp88 := tmp87.FindInternedVar(lang.NewSymbol("seq")) + if tmp88.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp88))) + } + tmp89 := tmp88.Get() + tmp90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp91 := tmp90.FindInternedVar(lang.NewSymbol("concat")) + if tmp91.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp91))) + } + tmp92 := tmp91.Get() + tmp93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp94 := tmp93.FindInternedVar(lang.NewSymbol("list")) + if tmp94.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp94))) + } + tmp95 := tmp94.Get() + tmp96 := lang.Apply(tmp95, []any{lang.NewSymbol("iter__0__auto__")}) + tmp97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp98 := tmp97.FindInternedVar(lang.NewSymbol("list")) + if tmp98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp98))) + } + tmp99 := tmp98.Get() + tmp100 := lang.Apply(v59, []any{v5}) + tmp101 := lang.Apply(v67, []any{tmp100}) + tmp102 := lang.Apply(tmp99, []any{tmp101}) + tmp103 := lang.Apply(tmp92, []any{tmp96, tmp102}) + tmp104 := lang.Apply(tmp89, []any{tmp103}) + tmp105 := lang.Apply(tmp83, []any{tmp86, tmp104}) + tmp106 := lang.Apply(tmp80, []any{tmp105}) + tmp107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp108 := tmp107.FindInternedVar(lang.NewSymbol("list")) + if tmp108.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp108))) + } + tmp109 := tmp108.Get() + tmp110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp111 := tmp110.FindInternedVar(lang.NewSymbol("seq")) + if tmp111.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp111))) + } + tmp112 := tmp111.Get() + tmp113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp114 := tmp113.FindInternedVar(lang.NewSymbol("concat")) + if tmp114.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp114))) + } + tmp115 := tmp114.Get() + tmp116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp117 := tmp116.FindInternedVar(lang.NewSymbol("list")) + if tmp117.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp117))) + } + tmp118 := tmp117.Get() + tmp119 := lang.Apply(tmp118, []any{lang.NewSymbol("iter__0__auto__")}) + tmp120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp121 := tmp120.FindInternedVar(lang.NewSymbol("list")) + if tmp121.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp121))) + } + tmp122 := tmp121.Get() + tmp123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp124 := tmp123.FindInternedVar(lang.NewSymbol("second")) + if tmp124.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp124))) + } + tmp125 := tmp124.Get() + tmp126 := lang.Apply(tmp125, []any{v5}) + tmp127 := lang.Apply(tmp122, []any{tmp126}) + tmp128 := lang.Apply(tmp115, []any{tmp119, tmp127}) + tmp129 := lang.Apply(tmp112, []any{tmp128}) + tmp130 := lang.Apply(tmp109, []any{tmp129}) + tmp131 := lang.Apply(tmp73, []any{tmp77, tmp106, tmp130}) + tmp132 := lang.Apply(tmp70, []any{tmp131}) + tmp55 = tmp132 } // end let - return v55 + return tmp55 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // force { - v0 := lang.NewSymbol("force").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "If x is a Delay, returns the (possibly cached) value of its expression, else returns x", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(754), lang.NewKeyword("end-line"), int(754))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("force").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "If x is a Delay, returns the (possibly cached) value of its expression, else returns x", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(754), lang.NewKeyword("end-line"), int(754))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4, _ := lang.FieldOrMethod(nil, "force") - if reflect.TypeOf(v4).Kind() != reflect.Func { + tmp4, _ := lang.FieldOrMethod(nil, "force") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("force is not a function"))) } - v5 := lang.Apply(v4, []any{v3}) - return v5 + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // format { - v0 := lang.NewSymbol("format").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fmt"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Formats a string using java.lang.String.format, see java.util.Formatter for format\n string syntax", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5717), lang.NewKeyword("end-line"), int(5717))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("format").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fmt"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Formats a string using java.lang.String.format, see java.util.Formatter for format\n string syntax", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5717), lang.NewKeyword("end-line"), int(5717))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 1 { @@ -39832,47 +39935,48 @@ func init() { } v3 := args[0] _ = v3 - v4 := lang.NewList(args[1:]...) - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("apply")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + var v4 any = lang.NewList(args[1:]...) + _ = v4 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("apply")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{fmt.Sprintf, v3, v4}) - return v8 + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{fmt.Sprintf, v3, v4}) + return tmp8 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // frequencies { - v0 := lang.NewSymbol("frequencies").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a map from distinct items in coll to the number of times\n they appear.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7185), lang.NewKeyword("end-line"), int(7185))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("frequencies").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a map from distinct items in coll to the number of times\n they appear.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7185), lang.NewKeyword("end-line"), int(7185))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("persistent!")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("reduce")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - var v10 lang.FnFunc - v10 = lang.NewFnFunc(func(args ...any) any { + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("persistent!")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("reduce")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -39880,62 +39984,62 @@ func init() { _ = v11 v12 := args[1] _ = v12 - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("assoc!")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("inc")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("get")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{v11, v12, int64(0)}) - v23 := lang.Apply(v18, []any{v22}) - v24 := lang.Apply(v15, []any{v11, v12, v23}) - return v24 + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("assoc!")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("inc")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("get")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, []any{v11, v12, int64(0)}) + tmp23 := lang.Apply(tmp18, []any{tmp22}) + tmp24 := lang.Apply(tmp15, []any{v11, v12, tmp23}) + return tmp24 }) - v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7192), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(7193), lang.NewKeyword("end-column"), int(54)) - v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) + tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7192), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(7193), lang.NewKeyword("end-column"), int(54)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) if err != nil { panic(err) } - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("transient")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("transient")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) } - v15 := v14.Get() - v16 := lang.NewMap() - v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7194), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(7194), lang.NewKeyword("end-column"), int(24)) - v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) + tmp15 := tmp14.Get() + tmp16 := lang.NewMap() + tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7194), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(7194), lang.NewKeyword("end-column"), int(24)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) if err != nil { panic(err) } - v19 := lang.Apply(v15, []any{v18}) - v20 := lang.Apply(v9, []any{v12, v19, v3}) - v21 := lang.Apply(v6, []any{v20}) - return v21 + tmp19 := lang.Apply(tmp15, []any{tmp18}) + tmp20 := lang.Apply(tmp9, []any{tmp12, tmp19, v3}) + tmp21 := lang.Apply(tmp6, []any{tmp20}) + return tmp21 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // future { - v0 := lang.NewSymbol("future").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Takes a body of expressions and yields a future object that will\n invoke the body in another thread, and will cache the result and\n return it on all subsequent calls to deref/@. If the computation has\n not yet finished, calls to deref/@ will block, unless the variant of\n deref with timeout is used. See also - realized?.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7009), lang.NewKeyword("end-line"), int(7009))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("future").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Takes a body of expressions and yields a future object that will\n invoke the body in another thread, and will cache the result and\n return it on all subsequent calls to deref/@. If the computation has\n not yet finished, calls to deref/@ will block, unless the variant of\n deref with timeout is used. See also - realized?.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7009), lang.NewKeyword("end-line"), int(7009))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 2 { @@ -39945,303 +40049,305 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.NewList(args[2:]...) - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("seq")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("concat")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("list")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.Apply(v14, []any{lang.NewSymbol("glojure.core/future-call")}) - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("list")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("seq")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("concat")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("list")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.Apply(v27, []any{lang.NewSymbol("fn*")}) - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("list")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("apply")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v36 := v35.FindInternedVar(lang.NewSymbol("vector")) - if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) - } - v37 := v36.Get() - v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v39 := v38.FindInternedVar(lang.NewSymbol("seq")) - if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) - } - v40 := v39.Get() - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("concat")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) - } - v43 := v42.Get() - v44 := lang.Apply(v43, nil) - v45 := lang.Apply(v40, []any{v44}) - v46 := lang.Apply(v34, []any{v37, v45}) - v47 := lang.Apply(v31, []any{v46}) - v48 := lang.Apply(v24, []any{v28, v47, v5}) - v49 := lang.Apply(v21, []any{v48}) - v50 := lang.Apply(v18, []any{v49}) - v51 := lang.Apply(v11, []any{v15, v50}) - v52 := lang.Apply(v8, []any{v51}) - return v52 - } - }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("seq")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("concat")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("list")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("glojure.core/future-call")}) + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("list")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("seq")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("concat")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("list")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.Apply(tmp27, []any{lang.NewSymbol("fn*")}) + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("list")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("apply")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp36 := tmp35.FindInternedVar(lang.NewSymbol("vector")) + if tmp36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) + } + tmp37 := tmp36.Get() + tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp39 := tmp38.FindInternedVar(lang.NewSymbol("seq")) + if tmp39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) + } + tmp40 := tmp39.Get() + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("concat")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := lang.Apply(tmp43, nil) + tmp45 := lang.Apply(tmp40, []any{tmp44}) + tmp46 := lang.Apply(tmp34, []any{tmp37, tmp45}) + tmp47 := lang.Apply(tmp31, []any{tmp46}) + tmp48 := lang.Apply(tmp24, []any{tmp28, tmp47, v5}) + tmp49 := lang.Apply(tmp21, []any{tmp48}) + tmp50 := lang.Apply(tmp18, []any{tmp49}) + tmp51 := lang.Apply(tmp11, []any{tmp15, tmp50}) + tmp52 := lang.Apply(tmp8, []any{tmp51}) + return tmp52 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // future-call { - v0 := lang.NewSymbol("future-call").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Takes a function of no args and yields a future object that will\n invoke the function in another thread, and will cache the result and\n return it on all subsequent calls to deref/@. If the computation has\n not yet finished, calls to deref/@ will block, unless the variant\n of deref with timeout is used. See also - realized?.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7003), lang.NewKeyword("end-line"), int(7003))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("future-call").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Takes a function of no args and yields a future object that will\n invoke the function in another thread, and will cache the result and\n return it on all subsequent calls to deref/@. If the computation has\n not yet finished, calls to deref/@ will block, unless the variant\n of deref with timeout is used. See also - realized?.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7003), lang.NewKeyword("end-line"), int(7003))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any + var tmp4 any { // let // let binding "f" - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("binding-conveyor-fn")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v3}) - var v9 any = v8 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("binding-conveyor-fn")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v3}) + var v9 any = tmp8 _ = v9 // let binding "fut" - v10 := lang.Apply(lang.AgentSubmit, []any{v9}) - var v11 any = v10 + tmp10 := lang.Apply(lang.AgentSubmit, []any{v9}) + var v11 any = tmp10 _ = v11 - v4 = v11 + tmp4 = v11 } // end let - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // future-cancel { - v0 := lang.NewSymbol("future-cancel").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Cancels the future, if possible.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7019), lang.NewKeyword("end-line"), int(7019))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("future-cancel").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Cancels the future, if possible.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7019), lang.NewKeyword("end-line"), int(7019))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4, _ := lang.FieldOrMethod(v3, "cancel") - if reflect.TypeOf(v4).Kind() != reflect.Func { + tmp4, _ := lang.FieldOrMethod(v3, "cancel") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("cancel is not a function"))) } - v5 := lang.Apply(v4, []any{true}) - return v5 + tmp5 := lang.Apply(tmp4, []any{true}) + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // future-cancelled? { - v0 := lang.NewSymbol("future-cancelled?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Returns true if future f is cancelled", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7025), lang.NewKeyword("end-line"), int(7025))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("future-cancelled?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Returns true if future f is cancelled", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7025), lang.NewKeyword("end-line"), int(7025))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4, ok := lang.FieldOrMethod(v3, "isCancelled") + tmp4, ok := lang.FieldOrMethod(v3, "isCancelled") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "isCancelled"))) } - var v5 any - switch reflect.TypeOf(v4).Kind() { + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { case reflect.Func: - v5 = lang.Apply(v4, nil) + tmp5 = lang.Apply(tmp4, nil) default: - v5 = v4 + tmp5 = tmp4 } - return v5 + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // future-done? { - v0 := lang.NewSymbol("future-done?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Returns true if future f is done", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6538), lang.NewKeyword("end-line"), int(6538))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("future-done?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Returns true if future f is done", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6538), lang.NewKeyword("end-line"), int(6538))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4, ok := lang.FieldOrMethod(v3, "isDone") + tmp4, ok := lang.FieldOrMethod(v3, "isDone") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "isDone"))) } - var v5 any - switch reflect.TypeOf(v4).Kind() { + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { case reflect.Func: - v5 = lang.Apply(v4, nil) + tmp5 = lang.Apply(tmp4, nil) default: - v5 = v4 + tmp5 = tmp4 } - return v5 + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // future? { - v0 := lang.NewSymbol("future?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is a future", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6532), lang.NewKeyword("end-line"), int(6532))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("future?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is a future", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6532), lang.NewKeyword("end-line"), int(6532))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) } - v6 := v5.Get() - v7 := lang.Apply(v6, []any{nil, v3}) - return v7 + tmp6 := tmp5.Get() + tmp7 := lang.Apply(tmp6, []any{nil, v3}) + return tmp7 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // gen-class { - v0 := lang.NewSymbol("gen-class").WithMeta(lang.NewMap()).(*lang.Symbol) - v1 := ns.Intern(v0) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp0 := lang.NewSymbol("gen-class").WithMeta(lang.NewMap()).(*lang.Symbol) + tmp1 := ns.Intern(tmp0) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // gensym { - v0 := lang.NewSymbol("gensym").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("prefix-string"))), lang.NewKeyword("doc"), "Returns a new symbol with a unique name. If a prefix string is\n supplied, the name is prefix# where # is some unique number. If\n prefix is not supplied, the prefix is 'G__'.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(599), lang.NewKeyword("end-line"), int(599))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("gensym").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("prefix-string"))), lang.NewKeyword("doc"), "Returns a new symbol with a unique name. If a prefix string is\n supplied, the name is prefix# where # is some unique number. If\n prefix is not supplied, the prefix is 'G__'.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(599), lang.NewKeyword("end-line"), int(599))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v4 := v3.FindInternedVar(lang.NewSymbol("gensym")) - if v4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) - } - v5 := v4.Get() - v6 := lang.Apply(v5, []any{"G__"}) - return v6 + tmp3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp4 := tmp3.FindInternedVar(lang.NewSymbol("gensym")) + if tmp4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp4))) + } + tmp5 := tmp4.Get() + tmp6 := lang.Apply(tmp5, []any{"G__"}) + return tmp6 case 1: v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("str")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("str")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10, _ := lang.FieldOrMethod(runtime4.RT, "NextID") - if reflect.TypeOf(v10).Kind() != reflect.Func { + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("str")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("str")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10, _ := lang.FieldOrMethod(runtime4.RT, "NextID") + if reflect.TypeOf(tmp10).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("NextID is not a function"))) } - v11 := lang.Apply(v10, []any{}) - v12 := lang.Apply(v9, []any{v11}) - v13 := lang.Apply(v6, []any{v3, v12}) - v14 := lang.Apply(lang.NewSymbol, []any{v13}) - return v14 + tmp11 := lang.Apply(tmp10, []any{}) + tmp12 := lang.Apply(tmp9, []any{tmp11}) + tmp13 := lang.Apply(tmp6, []any{v3, tmp12}) + tmp14 := lang.Apply(lang.NewSymbol, []any{tmp13}) + return tmp14 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // get { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function get__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 2 { @@ -40251,94 +40357,95 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.NewList(args[2:]...) - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("seq")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("concat")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("list")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.Apply(v14, []any{lang.NewSymbol(".")}) - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("list")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("list")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("seq")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("concat")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) - } - v28 := v27.Get() - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("list")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.Apply(v31, []any{lang.NewSymbol("glojure.core/Get")}) - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("list")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - v36 := lang.Apply(v35, []any{v3}) - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("list")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.Apply(v39, []any{v4}) - v41 := lang.Apply(v28, []any{v32, v36, v40, v5}) - v42 := lang.Apply(v25, []any{v41}) - v43 := lang.Apply(v22, []any{v42}) - v44 := lang.Apply(v11, []any{v15, v19, v43}) - v45 := lang.Apply(v8, []any{v44}) - return v45 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("seq")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("concat")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("list")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol(".")}) + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("list")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("list")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("seq")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("concat")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) + } + tmp28 := tmp27.Get() + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("list")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.Apply(tmp31, []any{lang.NewSymbol("glojure.core/Get")}) + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("list")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) + } + tmp35 := tmp34.Get() + tmp36 := lang.Apply(tmp35, []any{v3}) + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("list")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.Apply(tmp39, []any{v4}) + tmp41 := lang.Apply(tmp28, []any{tmp32, tmp36, tmp40, v5}) + tmp42 := lang.Apply(tmp25, []any{tmp41}) + tmp43 := lang.Apply(tmp22, []any{tmp42}) + tmp44 := lang.Apply(tmp11, []any{tmp15, tmp19, tmp43}) + tmp45 := lang.Apply(tmp8, []any{tmp44}) + return tmp45 } }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("get").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"), lang.NewSymbol("not-found"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the value mapped to key, not-found or nil if key not present\n in associative collection, set, string, array, or ILookup instance.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2), int64(3)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1489), lang.NewKeyword("end-line"), int(1489))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("get").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"), lang.NewSymbol("not-found"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the value mapped to key, not-found or nil if key not present\n in associative collection, set, string, array, or ILookup instance.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2), int64(3)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1489), lang.NewKeyword("end-line"), int(1489))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 2: v4 := args[0] _ = v4 v5 := args[1] _ = v5 - v6 := lang.Apply(lang.Get, []any{v4, v5}) - return v6 + tmp6 := lang.Apply(lang.Get, []any{v4, v5}) + return tmp6 case 3: v4 := args[0] _ = v4 @@ -40346,43 +40453,43 @@ func init() { _ = v5 v6 := args[2] _ = v6 - v7 := lang.Apply(lang.GetDefault, []any{v4, v5, v6}) - return v7 + tmp7 := lang.Apply(lang.GetDefault, []any{v4, v5, v6}) + return tmp7 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // get-in { - v0 := lang.NewSymbol("get-in").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("ks")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("ks"), lang.NewSymbol("not-found"))), lang.NewKeyword("doc"), "Returns the value in a nested associative structure,\n where ks is a sequence of keys. Returns nil if the key\n is not present, or the not-found value if supplied.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6128), lang.NewKeyword("end-line"), int(6128))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("get-in").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("ks")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("ks"), lang.NewSymbol("not-found"))), lang.NewKeyword("doc"), "Returns the value in a nested associative structure,\n where ks is a sequence of keys. Returns nil if the key\n is not present, or the not-found value if supplied.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6128), lang.NewKeyword("end-line"), int(6128))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("reduce1")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("get")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v7, []any{v10, v3, v4}) - return v11 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("get")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp7, []any{tmp10, v3, v4}) + return tmp11 case 3: v3 := args[0] _ = v3 @@ -40390,111 +40497,111 @@ func init() { _ = v4 v5 := args[2] _ = v5 - var v6 any + var tmp6 any { // let // let binding "sentinel" - v7 := lang.Apply(reflect.StructOf, []any{nil}) - v8 := lang.Apply(reflect.New, []any{v7}) - v9, ok := lang.FieldOrMethod(v8, "Interface") + tmp7 := lang.Apply(reflect.StructOf, []any{nil}) + tmp8 := lang.Apply(reflect.New, []any{tmp7}) + tmp9, ok := lang.FieldOrMethod(tmp8, "Interface") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "Interface"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp8, "Interface"))) } - var v10 any - switch reflect.TypeOf(v9).Kind() { + var tmp10 any + switch reflect.TypeOf(tmp9).Kind() { case reflect.Func: - v10 = lang.Apply(v9, nil) + tmp10 = lang.Apply(tmp9, nil) default: - v10 = v9 + tmp10 = tmp9 } - var v11 any = v10 + var v11 any = tmp10 _ = v11 // let binding "m" var v12 any = v3 _ = v12 // let binding "ks" - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("seq")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{v4}) - var v17 any = v16 + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("seq")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{v4}) + var v17 any = tmp16 _ = v17 for { - var v18 any + var tmp18 any if lang.IsTruthy(v17) { - var v19 any + var tmp19 any { // let // let binding "m" - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("get")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("get")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) } - v22 := v21.Get() - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("first")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + tmp22 := tmp21.Get() + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("first")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) } - v25 := v24.Get() - v26 := lang.Apply(v25, []any{v17}) - v27 := lang.Apply(v22, []any{v12, v26, v11}) - var v28 any = v27 + tmp25 := tmp24.Get() + tmp26 := lang.Apply(tmp25, []any{v17}) + tmp27 := lang.Apply(tmp22, []any{v12, tmp26, v11}) + var v28 any = tmp27 _ = v28 - var v29 any - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("identical?")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + var tmp29 any + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("identical?")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) } - v32 := v31.Get() - v33 := lang.Apply(v32, []any{v11, v28}) - if lang.IsTruthy(v33) { - v29 = v5 + tmp32 := tmp31.Get() + tmp33 := lang.Apply(tmp32, []any{v11, v28}) + if lang.IsTruthy(tmp33) { + tmp29 = v5 } else { - var v34 any = v11 - var v35 any = v28 - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("next")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + var tmp34 any = v11 + var tmp35 any = v28 + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("next")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) } - v39 := v38.Get() - v40 := lang.Apply(v39, []any{v17}) - var v36 any = v40 - v11 = v34 - v12 = v35 - v17 = v36 + tmp39 := tmp38.Get() + tmp40 := lang.Apply(tmp39, []any{v17}) + var tmp36 any = tmp40 + v11 = tmp34 + v12 = tmp35 + v17 = tmp36 continue } - v19 = v29 + tmp19 = tmp29 } // end let - v18 = v19 + tmp18 = tmp19 } else { - v18 = v12 + tmp18 = v12 } - v6 = v18 + tmp6 = tmp18 break } } // end let - return v6 + return tmp6 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // get-method { - v0 := lang.NewSymbol("get-method").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"), lang.NewSymbol("dispatch-val"))), lang.NewKeyword("doc"), "Given a multimethod and a dispatch value, returns the dispatch fn\n that would apply to that value, or nil if none apply and no default", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1815), lang.NewKeyword("end-line"), int(1815))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("get-method").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"), lang.NewSymbol("dispatch-val"))), lang.NewKeyword("doc"), "Given a multimethod and a dispatch value, returns the dispatch fn\n that would apply to that value, or nil if none apply and no default", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1815), lang.NewKeyword("end-line"), int(1815))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -40502,72 +40609,72 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5, _ := lang.FieldOrMethod(v3, "getMethod") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(v3, "getMethod") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("getMethod is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // get-thread-bindings { - v0 := lang.NewSymbol("get-thread-bindings").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Get a map with the Var/value pairs which is currently in effect for the\n current thread.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1937), lang.NewKeyword("end-line"), int(1937))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("get-thread-bindings").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Get a map with the Var/value pairs which is currently in effect for the\n current thread.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1937), lang.NewKeyword("end-line"), int(1937))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v3 := lang.Apply(nil, nil) - return v3 + tmp3 := lang.Apply(nil, nil) + return tmp3 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // get-validator { - v0 := lang.NewSymbol("get-validator").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("iref"))), lang.NewKeyword("doc"), "Gets the validator-fn for a var/ref/agent/atom.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2392), lang.NewKeyword("end-line"), int(2392))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("get-validator").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("iref"))), lang.NewKeyword("doc"), "Gets the validator-fn for a var/ref/agent/atom.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2392), lang.NewKeyword("end-line"), int(2392))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4, _ := lang.FieldOrMethod(v3, "getValidator") - if reflect.TypeOf(v4).Kind() != reflect.Func { + tmp4, _ := lang.FieldOrMethod(v3, "getValidator") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("getValidator is not a function"))) } - v5 := lang.Apply(v4, []any{}) - return v5 + tmp5 := lang.Apply(tmp4, []any{}) + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // global-hierarchy { - v0 := lang.NewSymbol("global-hierarchy").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5513), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(5514), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - v1 := ns.InternWithValue(v0, lang.NewMap(lang.NewKeyword("parents"), lang.NewMap(), lang.NewKeyword("descendants"), lang.NewMap(), lang.NewKeyword("ancestors"), lang.NewMap()), true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp0 := lang.NewSymbol("global-hierarchy").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5513), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(5514), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, lang.NewMap(lang.NewKeyword("parents"), lang.NewMap(), lang.NewKeyword("descendants"), lang.NewMap(), lang.NewKeyword("ancestors"), lang.NewMap()), true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // group-by { - v0 := lang.NewSymbol("group-by").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a map of the elements of coll keyed by the result of\n f on each element. The value at each key will be a vector of the\n corresponding elements, in the order they appeared in coll.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7128), lang.NewKeyword("end-line"), int(7128))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("group-by").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a map of the elements of coll keyed by the result of\n f on each element. The value at each key will be a vector of the\n corresponding elements, in the order they appeared in coll.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7128), lang.NewKeyword("end-line"), int(7128))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -40575,20 +40682,20 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("persistent!")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("reduce")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - var v11 lang.FnFunc - v11 = lang.NewFnFunc(func(args ...any) any { + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("persistent!")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("reduce")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -40596,372 +40703,375 @@ func init() { _ = v12 v13 := args[1] _ = v13 - var v14 any + var tmp14 any { // let // let binding "k" - v15 := lang.Apply(v3, []any{v13}) - var v16 any = v15 + tmp15 := lang.Apply(v3, []any{v13}) + var v16 any = tmp15 _ = v16 - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("assoc!")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("conj")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("get")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.NewVector() - v27 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7139), lang.NewKeyword("column"), int(40), lang.NewKeyword("end-line"), int(7139), lang.NewKeyword("end-column"), int(41)) - v28, err := lang.WithMeta(v26, v27.(lang.IPersistentMap)) + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("assoc!")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("conj")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("get")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.NewVector() + tmp27 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7139), lang.NewKeyword("column"), int(40), lang.NewKeyword("end-line"), int(7139), lang.NewKeyword("end-column"), int(41)) + tmp28, err := lang.WithMeta(tmp26, tmp27.(lang.IPersistentMap)) if err != nil { panic(err) } - v29 := lang.Apply(v25, []any{v12, v16, v28}) - v30 := lang.Apply(v22, []any{v29, v13}) - v31 := lang.Apply(v19, []any{v12, v16, v30}) - v14 = v31 + tmp29 := lang.Apply(tmp25, []any{v12, v16, tmp28}) + tmp30 := lang.Apply(tmp22, []any{tmp29, v13}) + tmp31 := lang.Apply(tmp19, []any{v12, v16, tmp30}) + tmp14 = tmp31 } // end let - return v14 + return tmp14 }) - v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7137), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(7139), lang.NewKeyword("end-column"), int(48)) - v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) + tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7137), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(7139), lang.NewKeyword("end-column"), int(48)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) if err != nil { panic(err) } - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("transient")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("transient")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) } - v16 := v15.Get() - v17 := lang.NewMap() - v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7140), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(7140), lang.NewKeyword("end-column"), int(17)) - v19, err := lang.WithMeta(v17, v18.(lang.IPersistentMap)) + tmp16 := tmp15.Get() + tmp17 := lang.NewMap() + tmp18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7140), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(7140), lang.NewKeyword("end-column"), int(17)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) if err != nil { panic(err) } - v20 := lang.Apply(v16, []any{v19}) - v21 := lang.Apply(v10, []any{v13, v20, v4}) - v22 := lang.Apply(v7, []any{v21}) - return v22 + tmp20 := lang.Apply(tmp16, []any{tmp19}) + tmp21 := lang.Apply(tmp10, []any{tmp13, tmp20, v4}) + tmp22 := lang.Apply(tmp7, []any{tmp21}) + return tmp22 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // halt-when { - v0 := lang.NewSymbol("halt-when").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred")), lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("retf"))), lang.NewKeyword("doc"), "Returns a transducer that ends transduction when pred returns true\n for an input. When retf is supplied it must be a fn of 2 arguments -\n it will be passed the (completed) result so far and the input that\n triggered the predicate, and its return value (if it does not throw\n an exception) will be the return value of the transducer. If retf\n is not supplied, the input that triggered the predicate will be\n returned. If the predicate never returns true the transduction is\n unaffected.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7657), lang.NewKeyword("end-line"), int(7657))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("halt-when").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred")), lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("retf"))), lang.NewKeyword("doc"), "Returns a transducer that ends transduction when pred returns true\n for an input. When retf is supplied it must be a fn of 2 arguments -\n it will be passed the (completed) result so far and the input that\n triggered the predicate, and its return value (if it does not throw\n an exception) will be the return value of the transducer. If retf\n is not supplied, the input that triggered the predicate will be\n returned. If the predicate never returns true the transduction is\n unaffected.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7657), lang.NewKeyword("end-line"), int(7657))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("halt-when")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.Apply(v6, []any{v3, nil}) - return v7 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("halt-when")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.Apply(tmp6, []any{v3, nil}) + return tmp7 case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - var v5 lang.FnFunc - v5 = lang.NewFnFunc(func(args ...any) any { + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v6 := args[0] _ = v6 - var v7 lang.FnFunc - v7 = lang.NewFnFunc(func(args ...any) any { + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - v8 := lang.Apply(v6, nil) - return v8 + tmp8 := lang.Apply(v6, nil) + return tmp8 case 1: v8 := args[0] _ = v8 - var v9 any - var v10 any + var tmp9 any + var tmp10 any { // let // let binding "and__0__auto__" - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("map?")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("map?")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{v8}) - var v15 any = v14 + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{v8}) + var v15 any = tmp14 _ = v15 - var v16 any + var tmp16 any if lang.IsTruthy(v15) { - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("contains?")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("contains?")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) } - v19 := v18.Get() - v20 := lang.Apply(v19, []any{v8, lang.NewKeyword("glojure.core/halt")}) - v16 = v20 + tmp19 := tmp18.Get() + tmp20 := lang.Apply(tmp19, []any{v8, lang.NewKeyword("glojure.core/halt")}) + tmp16 = tmp20 } else { - v16 = v15 + tmp16 = v15 } - v10 = v16 + tmp10 = tmp16 } // end let - if lang.IsTruthy(v10) { - v11 := lang.Apply(lang.NewKeyword("glojure.core/halt"), []any{v8}) - v9 = v11 + if lang.IsTruthy(tmp10) { + tmp11 := lang.Apply(lang.NewKeyword("glojure.core/halt"), []any{v8}) + tmp9 = tmp11 } else { - v12 := lang.Apply(v6, []any{v8}) - v9 = v12 + tmp12 := lang.Apply(v6, []any{v8}) + tmp9 = tmp12 } - return v9 + return tmp9 case 2: v8 := args[0] _ = v8 v9 := args[1] _ = v9 - var v10 any - v11 := lang.Apply(v3, []any{v9}) - if lang.IsTruthy(v11) { - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("reduced")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + var tmp10 any + tmp11 := lang.Apply(v3, []any{v9}) + if lang.IsTruthy(tmp11) { + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("reduced")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) } - v14 := v13.Get() - var v15 any + tmp14 := tmp13.Get() + var tmp15 any if lang.IsTruthy(v4) { - v16 := lang.Apply(v6, []any{v8}) - v17 := lang.Apply(v4, []any{v16, v9}) - v15 = v17 + tmp16 := lang.Apply(v6, []any{v8}) + tmp17 := lang.Apply(v4, []any{tmp16, v9}) + tmp15 = tmp17 } else { - v15 = v9 + tmp15 = v9 } - v18 := lang.NewMap(lang.NewKeyword("glojure.core/halt"), v15) - v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7678), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(7678), lang.NewKeyword("end-column"), int(72)) - v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) + tmp18 := lang.NewMap(lang.NewKeyword("glojure.core/halt"), tmp15) + tmp19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7678), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(7678), lang.NewKeyword("end-column"), int(72)) + tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) if err != nil { panic(err) } - v21 := lang.Apply(v14, []any{v20}) - v10 = v21 + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp10 = tmp21 } else { - v22 := lang.Apply(v6, []any{v8, v9}) - v10 = v22 + tmp22 := lang.Apply(v6, []any{v8, v9}) + tmp10 = tmp22 } - return v10 + return tmp10 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7670), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7679), lang.NewKeyword("end-column"), int(34)) - v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) + tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7670), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7679), lang.NewKeyword("end-column"), int(34)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) if err != nil { panic(err) } - return v9 + return tmp9 }) - v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7669), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7679), lang.NewKeyword("end-column"), int(35)) - v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) + tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7669), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7679), lang.NewKeyword("end-column"), int(35)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) if err != nil { panic(err) } - return v7 + return tmp7 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // hash { - v0 := lang.NewSymbol("hash").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns the hash code of its argument. Note this is the hash code\n consistent with =, and thus is different than .hashCode for Integer,\n Short, Byte and Clojure collections.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5189), lang.NewKeyword("end-line"), int(5189))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("hash").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns the hash code of its argument. Note this is the hash code\n consistent with =, and thus is different than .hashCode for Integer,\n Short, Byte and Clojure collections.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5189), lang.NewKeyword("end-line"), int(5189))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.Apply(lang.HashEq, []any{v3}) - return v4 + tmp4 := lang.Apply(lang.HashEq, []any{v3}) + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // hash-map { - v0 := lang.NewSymbol("hash-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keyvals"))), lang.NewKeyword("doc"), "keyval => key val\n Returns a new hash map with supplied mappings. If any keys are\n equal, they are handled as if by repeated uses of assoc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(378), lang.NewKeyword("end-line"), int(378))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("hash-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keyvals"))), lang.NewKeyword("doc"), "keyval => key val\n Returns a new hash map with supplied mappings. If any keys are\n equal, they are handled as if by repeated uses of assoc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(378), lang.NewKeyword("end-line"), int(378))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - v3 := lang.NewMap() - v4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(384), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(384), lang.NewKeyword("end-column"), int(8)) - v5, err := lang.WithMeta(v3, v4.(lang.IPersistentMap)) + tmp3 := lang.NewMap() + tmp4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(384), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(384), lang.NewKeyword("end-column"), int(8)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) if err != nil { panic(err) } - return v5 + return tmp5 default: if len(args) < 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v3 := lang.NewList(args[0:]...) - v4 := lang.Apply(lang.CreatePersistentHashMap, []any{v3}) - return v4 + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := lang.Apply(lang.CreatePersistentHashMap, []any{v3}) + return tmp4 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // hash-ordered-coll { - v0 := lang.NewSymbol("hash-ordered-coll").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns the hash code, consistent with =, for an external ordered\n collection implementing Iterable.\n See http://glojure.org/data_structures#hash for full algorithms.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5210), lang.NewKeyword("end-line"), int(5210))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("hash-ordered-coll").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns the hash code, consistent with =, for an external ordered\n collection implementing Iterable.\n See http://glojure.org/data_structures#hash for full algorithms.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5210), lang.NewKeyword("end-line"), int(5210))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.Apply(nil, []any{v3}) - return v4 + tmp4 := lang.Apply(nil, []any{v3}) + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // hash-set { - v0 := lang.NewSymbol("hash-set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keys"))), lang.NewKeyword("doc"), "Returns a new hash set with supplied keys. Any equal keys are\n handled as if by repeated uses of conj.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(388), lang.NewKeyword("end-line"), int(388))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("hash-set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keys"))), lang.NewKeyword("doc"), "Returns a new hash set with supplied keys. Any equal keys are\n handled as if by repeated uses of conj.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(388), lang.NewKeyword("end-line"), int(388))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - v3 := lang.CreatePersistentTreeSet() - v4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(393), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(393), lang.NewKeyword("end-column"), int(9)) - v5, err := lang.WithMeta(v3, v4.(lang.IPersistentMap)) + tmp3 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(393), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(393), lang.NewKeyword("end-column"), int(9)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) if err != nil { panic(err) } - return v5 + return tmp5 default: if len(args) < 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v3 := lang.NewList(args[0:]...) - v4 := lang.Apply(nil, []any{v3}) - return v4 + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := lang.Apply(nil, []any{v3}) + return tmp4 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // hash-unordered-coll { - v0 := lang.NewSymbol("hash-unordered-coll").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns the hash code, consistent with =, for an external unordered\n collection implementing Iterable. For maps, the iterator should\n return map entries whose hash is computed as\n (hash-ordered-coll [k v]).\n See http://glojure.org/data_structures#hash for full algorithms.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5219), lang.NewKeyword("end-line"), int(5219))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("hash-unordered-coll").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns the hash code, consistent with =, for an external unordered\n collection implementing Iterable. For maps, the iterator should\n return map entries whose hash is computed as\n (hash-ordered-coll [k v]).\n See http://glojure.org/data_structures#hash for full algorithms.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5219), lang.NewKeyword("end-line"), int(5219))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.Apply(nil, []any{v3}) - return v4 + tmp4 := lang.Apply(nil, []any{v3}) + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // ident? { - v0 := lang.NewSymbol("ident?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a symbol or keyword", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1608), lang.NewKeyword("end-line"), int(1608))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("ident?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a symbol or keyword", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1608), lang.NewKeyword("end-line"), int(1608))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any + var tmp4 any { // let // let binding "or__0__auto__" - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("keyword?")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v3}) - var v9 any = v8 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("keyword?")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v3}) + var v9 any = tmp8 _ = v9 - var v10 any + var tmp10 any if lang.IsTruthy(v9) { - v10 = v9 + tmp10 = v9 } else { - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("symbol?")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("symbol?")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{v3}) - v10 = v14 + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{v3}) + tmp10 = tmp14 } - v4 = v10 + tmp4 = tmp10 } // end let - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // identical? { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function identical?__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -40969,63 +41079,63 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("seq")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("concat")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("list")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("list")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{lang.NewSymbol("glojure.lang.Util")}) - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("list")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{lang.NewSymbol("glojure.core/identical")}) - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("list")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.Apply(v25, []any{v3}) - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{v4}) - v31 := lang.Apply(v10, []any{v14, v18, v22, v26, v30}) - v32 := lang.Apply(v7, []any{v31}) - return v32 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("concat")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("list")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol(".")}) + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("glojure.lang.Util")}) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("glojure.core/identical")}) + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.Apply(tmp25, []any{v3}) + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{v4}) + tmp31 := lang.Apply(tmp10, []any{tmp14, tmp18, tmp22, tmp26, tmp30}) + tmp32 := lang.Apply(tmp7, []any{tmp31}) + return tmp32 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("identical?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Tests if 2 arguments are the same object", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(768), lang.NewKeyword("end-line"), int(768))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("identical?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Tests if 2 arguments are the same object", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(768), lang.NewKeyword("end-line"), int(768))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -41033,20 +41143,20 @@ func init() { _ = v4 v5 := args[1] _ = v5 - v6 := lang.Apply(lang.Identical, []any{v4, v5}) - return v6 + tmp6 := lang.Apply(lang.Identical, []any{v4, v5}) + return tmp6 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // identity { - v0 := lang.NewSymbol("identity").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns its argument.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1446), lang.NewKeyword("end-line"), int(1446))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("identity").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns its argument.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1446), lang.NewKeyword("end-line"), int(1446))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -41054,17 +41164,17 @@ func init() { _ = v3 return v3 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // if-let { - v0 := lang.NewSymbol("if-let").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("then")), lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("then"), lang.NewSymbol("else"), lang.NewSymbol("&"), lang.NewSymbol("oldform"))), lang.NewKeyword("doc"), "bindings => binding-form test\n\n If test is true, evaluates then with binding-form bound to the value of \n test, if not, yields else", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1839), lang.NewKeyword("end-line"), int(1839))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("if-let").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("then")), lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("then"), lang.NewSymbol("else"), lang.NewSymbol("&"), lang.NewSymbol("oldform"))), lang.NewKeyword("doc"), "bindings => binding-form test\n\n If test is true, evaluates then with binding-form bound to the value of \n test, if not, yields else", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1839), lang.NewKeyword("end-line"), int(1839))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 4: v3 := args[0] @@ -41075,49 +41185,49 @@ func init() { _ = v5 v6 := args[3] _ = v6 - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("seq")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("concat")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("list")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/if-let")}) - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("list")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.Apply(v19, []any{v5}) - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("list")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.Apply(v23, []any{v6}) - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("list")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.Apply(v27, []any{nil}) - v29 := lang.Apply(v12, []any{v16, v20, v24, v28}) - v30 := lang.Apply(v9, []any{v29}) - return v30 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("seq")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("concat")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("list")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("glojure.core/if-let")}) + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("list")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.Apply(tmp19, []any{v5}) + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("list")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.Apply(tmp23, []any{v6}) + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("list")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.Apply(tmp27, []any{nil}) + tmp29 := lang.Apply(tmp12, []any{tmp16, tmp20, tmp24, tmp28}) + tmp30 := lang.Apply(tmp9, []any{tmp29}) + return tmp30 default: if len(args) < 5 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -41132,364 +41242,361 @@ func init() { _ = v6 v7 := args[4] _ = v7 - v8 := lang.NewList(args[5:]...) - var v9 any - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("vector?")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{v5}) - if lang.IsTruthy(v13) { - v9 = nil + var v8 any = lang.NewList(args[5:]...) + _ = v8 + var tmp9 any + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("vector?")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{v5}) + if lang.IsTruthy(tmp13) { } else { - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("str")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("first")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.Apply(v19, []any{v3}) - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("*ns*")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("meta")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.Apply(v26, []any{v3}) - v28 := lang.Apply(lang.NewKeyword("line"), []any{v27}) - v29 := lang.Apply(v16, []any{v20, " requires ", "a vector for its binding", " in ", v23, ":", v28}) - v30 := lang.Apply(lang.NewIllegalArgumentError, []any{v29}) - panic(v30) - } - _ = v9 - var v31 any - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("nil?")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{v8}) - if lang.IsTruthy(v35) { - v31 = nil + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("str")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("first")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.Apply(tmp19, []any{v3}) + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("*ns*")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("meta")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(lang.NewKeyword("line"), []any{tmp27}) + tmp29 := lang.Apply(tmp16, []any{tmp20, " requires ", "a vector for its binding", " in ", tmp23, ":", tmp28}) + tmp30 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp29}) + panic(tmp30) + } + _ = tmp9 + var tmp31 any + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("nil?")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.Apply(tmp34, []any{v8}) + if lang.IsTruthy(tmp35) { } else { - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("str")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v40 := v39.FindInternedVar(lang.NewSymbol("first")) - if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) - } - v41 := v40.Get() - v42 := lang.Apply(v41, []any{v3}) - v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v44 := v43.FindInternedVar(lang.NewSymbol("*ns*")) - if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) - } - v45 := v44.Get() - v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v47 := v46.FindInternedVar(lang.NewSymbol("meta")) - if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) - } - v48 := v47.Get() - v49 := lang.Apply(v48, []any{v3}) - v50 := lang.Apply(lang.NewKeyword("line"), []any{v49}) - v51 := lang.Apply(v38, []any{v42, " requires ", "1 or 2 forms after binding vector", " in ", v45, ":", v50}) - v52 := lang.Apply(lang.NewIllegalArgumentError, []any{v51}) - panic(v52) - } - _ = v31 - var v53 any - v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v55 := v54.FindInternedVar(lang.NewSymbol("=")) - if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) - } - v56 := v55.Get() - v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v58 := v57.FindInternedVar(lang.NewSymbol("count")) - if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) - } - v59 := v58.Get() - v60 := lang.Apply(v59, []any{v5}) - v61 := lang.Apply(v56, []any{int64(2), v60}) - if lang.IsTruthy(v61) { - v53 = nil + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("str")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp40 := tmp39.FindInternedVar(lang.NewSymbol("first")) + if tmp40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) + } + tmp41 := tmp40.Get() + tmp42 := lang.Apply(tmp41, []any{v3}) + tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp44 := tmp43.FindInternedVar(lang.NewSymbol("*ns*")) + if tmp44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) + } + tmp45 := tmp44.Get() + tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp47 := tmp46.FindInternedVar(lang.NewSymbol("meta")) + if tmp47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) + } + tmp48 := tmp47.Get() + tmp49 := lang.Apply(tmp48, []any{v3}) + tmp50 := lang.Apply(lang.NewKeyword("line"), []any{tmp49}) + tmp51 := lang.Apply(tmp38, []any{tmp42, " requires ", "1 or 2 forms after binding vector", " in ", tmp45, ":", tmp50}) + tmp52 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp51}) + panic(tmp52) + } + _ = tmp31 + var tmp53 any + tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp55 := tmp54.FindInternedVar(lang.NewSymbol("=")) + if tmp55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) + } + tmp56 := tmp55.Get() + tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp58 := tmp57.FindInternedVar(lang.NewSymbol("count")) + if tmp58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) + } + tmp59 := tmp58.Get() + tmp60 := lang.Apply(tmp59, []any{v5}) + tmp61 := lang.Apply(tmp56, []any{int64(2), tmp60}) + if lang.IsTruthy(tmp61) { } else { - v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v63 := v62.FindInternedVar(lang.NewSymbol("str")) - if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) - } - v64 := v63.Get() - v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v66 := v65.FindInternedVar(lang.NewSymbol("first")) - if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) - } - v67 := v66.Get() - v68 := lang.Apply(v67, []any{v3}) - v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v70 := v69.FindInternedVar(lang.NewSymbol("*ns*")) - if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) - } - v71 := v70.Get() - v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v73 := v72.FindInternedVar(lang.NewSymbol("meta")) - if v73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) - } - v74 := v73.Get() - v75 := lang.Apply(v74, []any{v3}) - v76 := lang.Apply(lang.NewKeyword("line"), []any{v75}) - v77 := lang.Apply(v64, []any{v68, " requires ", "exactly 2 forms in binding vector", " in ", v71, ":", v76}) - v78 := lang.Apply(lang.NewIllegalArgumentError, []any{v77}) - panic(v78) - } - _ = v53 - _ = nil - var v79 any + tmp62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp63 := tmp62.FindInternedVar(lang.NewSymbol("str")) + if tmp63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp63))) + } + tmp64 := tmp63.Get() + tmp65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp66 := tmp65.FindInternedVar(lang.NewSymbol("first")) + if tmp66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp66))) + } + tmp67 := tmp66.Get() + tmp68 := lang.Apply(tmp67, []any{v3}) + tmp69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp70 := tmp69.FindInternedVar(lang.NewSymbol("*ns*")) + if tmp70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp70))) + } + tmp71 := tmp70.Get() + tmp72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp73 := tmp72.FindInternedVar(lang.NewSymbol("meta")) + if tmp73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp73))) + } + tmp74 := tmp73.Get() + tmp75 := lang.Apply(tmp74, []any{v3}) + tmp76 := lang.Apply(lang.NewKeyword("line"), []any{tmp75}) + tmp77 := lang.Apply(tmp64, []any{tmp68, " requires ", "exactly 2 forms in binding vector", " in ", tmp71, ":", tmp76}) + tmp78 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp77}) + panic(tmp78) + } + _ = tmp53 + var tmp79 any { // let // let binding "form" - v80 := lang.Apply(v5, []any{int64(0)}) - var v81 any = v80 + tmp80 := lang.Apply(v5, []any{int64(0)}) + var v81 any = tmp80 _ = v81 // let binding "tst" - v82 := lang.Apply(v5, []any{int64(1)}) - var v83 any = v82 + tmp82 := lang.Apply(v5, []any{int64(1)}) + var v83 any = tmp82 _ = v83 - v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v85 := v84.FindInternedVar(lang.NewSymbol("seq")) - if v85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) - } - v86 := v85.Get() - v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v88 := v87.FindInternedVar(lang.NewSymbol("concat")) - if v88.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) - } - v89 := v88.Get() - v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v91 := v90.FindInternedVar(lang.NewSymbol("list")) - if v91.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) - } - v92 := v91.Get() - v93 := lang.Apply(v92, []any{lang.NewSymbol("glojure.core/let")}) - v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v95 := v94.FindInternedVar(lang.NewSymbol("list")) - if v95.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) - } - v96 := v95.Get() - v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v98 := v97.FindInternedVar(lang.NewSymbol("apply")) - if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) - } - v99 := v98.Get() - v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v101 := v100.FindInternedVar(lang.NewSymbol("vector")) - if v101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) - } - v102 := v101.Get() - v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v104 := v103.FindInternedVar(lang.NewSymbol("seq")) - if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) - } - v105 := v104.Get() - v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v107 := v106.FindInternedVar(lang.NewSymbol("concat")) - if v107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) - } - v108 := v107.Get() - v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v110 := v109.FindInternedVar(lang.NewSymbol("list")) - if v110.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) - } - v111 := v110.Get() - v112 := lang.Apply(v111, []any{lang.NewSymbol("temp__0__auto__")}) - v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v114 := v113.FindInternedVar(lang.NewSymbol("list")) - if v114.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) - } - v115 := v114.Get() - v116 := lang.Apply(v115, []any{v83}) - v117 := lang.Apply(v108, []any{v112, v116}) - v118 := lang.Apply(v105, []any{v117}) - v119 := lang.Apply(v99, []any{v102, v118}) - v120 := lang.Apply(v96, []any{v119}) - v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v122 := v121.FindInternedVar(lang.NewSymbol("list")) - if v122.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) - } - v123 := v122.Get() - v124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v125 := v124.FindInternedVar(lang.NewSymbol("seq")) - if v125.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v125))) - } - v126 := v125.Get() - v127 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v128 := v127.FindInternedVar(lang.NewSymbol("concat")) - if v128.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v128))) - } - v129 := v128.Get() - v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v131 := v130.FindInternedVar(lang.NewSymbol("list")) - if v131.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) - } - v132 := v131.Get() - v133 := lang.Apply(v132, []any{lang.NewSymbol("if")}) - v134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v135 := v134.FindInternedVar(lang.NewSymbol("list")) - if v135.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v135))) - } - v136 := v135.Get() - v137 := lang.Apply(v136, []any{lang.NewSymbol("temp__0__auto__")}) - v138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v139 := v138.FindInternedVar(lang.NewSymbol("list")) - if v139.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v139))) - } - v140 := v139.Get() - v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v142 := v141.FindInternedVar(lang.NewSymbol("seq")) - if v142.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) - } - v143 := v142.Get() - v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v145 := v144.FindInternedVar(lang.NewSymbol("concat")) - if v145.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) - } - v146 := v145.Get() - v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v148 := v147.FindInternedVar(lang.NewSymbol("list")) - if v148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) - } - v149 := v148.Get() - v150 := lang.Apply(v149, []any{lang.NewSymbol("glojure.core/let")}) - v151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v152 := v151.FindInternedVar(lang.NewSymbol("list")) - if v152.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v152))) - } - v153 := v152.Get() - v154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v155 := v154.FindInternedVar(lang.NewSymbol("apply")) - if v155.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v155))) - } - v156 := v155.Get() - v157 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v158 := v157.FindInternedVar(lang.NewSymbol("vector")) - if v158.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v158))) - } - v159 := v158.Get() - v160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v161 := v160.FindInternedVar(lang.NewSymbol("seq")) - if v161.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v161))) - } - v162 := v161.Get() - v163 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v164 := v163.FindInternedVar(lang.NewSymbol("concat")) - if v164.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v164))) - } - v165 := v164.Get() - v166 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v167 := v166.FindInternedVar(lang.NewSymbol("list")) - if v167.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v167))) - } - v168 := v167.Get() - v169 := lang.Apply(v168, []any{v81}) - v170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v171 := v170.FindInternedVar(lang.NewSymbol("list")) - if v171.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v171))) - } - v172 := v171.Get() - v173 := lang.Apply(v172, []any{lang.NewSymbol("temp__0__auto__")}) - v174 := lang.Apply(v165, []any{v169, v173}) - v175 := lang.Apply(v162, []any{v174}) - v176 := lang.Apply(v156, []any{v159, v175}) - v177 := lang.Apply(v153, []any{v176}) - v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v179 := v178.FindInternedVar(lang.NewSymbol("list")) - if v179.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) - } - v180 := v179.Get() - v181 := lang.Apply(v180, []any{v6}) - v182 := lang.Apply(v146, []any{v150, v177, v181}) - v183 := lang.Apply(v143, []any{v182}) - v184 := lang.Apply(v140, []any{v183}) - v185 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v186 := v185.FindInternedVar(lang.NewSymbol("list")) - if v186.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v186))) - } - v187 := v186.Get() - v188 := lang.Apply(v187, []any{v7}) - v189 := lang.Apply(v129, []any{v133, v137, v184, v188}) - v190 := lang.Apply(v126, []any{v189}) - v191 := lang.Apply(v123, []any{v190}) - v192 := lang.Apply(v89, []any{v93, v120, v191}) - v193 := lang.Apply(v86, []any{v192}) - v79 = v193 + tmp84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp85 := tmp84.FindInternedVar(lang.NewSymbol("seq")) + if tmp85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp85))) + } + tmp86 := tmp85.Get() + tmp87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp88 := tmp87.FindInternedVar(lang.NewSymbol("concat")) + if tmp88.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp88))) + } + tmp89 := tmp88.Get() + tmp90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp91 := tmp90.FindInternedVar(lang.NewSymbol("list")) + if tmp91.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp91))) + } + tmp92 := tmp91.Get() + tmp93 := lang.Apply(tmp92, []any{lang.NewSymbol("glojure.core/let")}) + tmp94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp95 := tmp94.FindInternedVar(lang.NewSymbol("list")) + if tmp95.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp95))) + } + tmp96 := tmp95.Get() + tmp97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp98 := tmp97.FindInternedVar(lang.NewSymbol("apply")) + if tmp98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp98))) + } + tmp99 := tmp98.Get() + tmp100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp101 := tmp100.FindInternedVar(lang.NewSymbol("vector")) + if tmp101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp101))) + } + tmp102 := tmp101.Get() + tmp103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp104 := tmp103.FindInternedVar(lang.NewSymbol("seq")) + if tmp104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp104))) + } + tmp105 := tmp104.Get() + tmp106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp107 := tmp106.FindInternedVar(lang.NewSymbol("concat")) + if tmp107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp107))) + } + tmp108 := tmp107.Get() + tmp109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp110 := tmp109.FindInternedVar(lang.NewSymbol("list")) + if tmp110.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp110))) + } + tmp111 := tmp110.Get() + tmp112 := lang.Apply(tmp111, []any{lang.NewSymbol("temp__0__auto__")}) + tmp113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp114 := tmp113.FindInternedVar(lang.NewSymbol("list")) + if tmp114.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp114))) + } + tmp115 := tmp114.Get() + tmp116 := lang.Apply(tmp115, []any{v83}) + tmp117 := lang.Apply(tmp108, []any{tmp112, tmp116}) + tmp118 := lang.Apply(tmp105, []any{tmp117}) + tmp119 := lang.Apply(tmp99, []any{tmp102, tmp118}) + tmp120 := lang.Apply(tmp96, []any{tmp119}) + tmp121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp122 := tmp121.FindInternedVar(lang.NewSymbol("list")) + if tmp122.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp122))) + } + tmp123 := tmp122.Get() + tmp124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp125 := tmp124.FindInternedVar(lang.NewSymbol("seq")) + if tmp125.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp125))) + } + tmp126 := tmp125.Get() + tmp127 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp128 := tmp127.FindInternedVar(lang.NewSymbol("concat")) + if tmp128.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp128))) + } + tmp129 := tmp128.Get() + tmp130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp131 := tmp130.FindInternedVar(lang.NewSymbol("list")) + if tmp131.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp131))) + } + tmp132 := tmp131.Get() + tmp133 := lang.Apply(tmp132, []any{lang.NewSymbol("if")}) + tmp134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp135 := tmp134.FindInternedVar(lang.NewSymbol("list")) + if tmp135.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp135))) + } + tmp136 := tmp135.Get() + tmp137 := lang.Apply(tmp136, []any{lang.NewSymbol("temp__0__auto__")}) + tmp138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp139 := tmp138.FindInternedVar(lang.NewSymbol("list")) + if tmp139.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp139))) + } + tmp140 := tmp139.Get() + tmp141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp142 := tmp141.FindInternedVar(lang.NewSymbol("seq")) + if tmp142.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp142))) + } + tmp143 := tmp142.Get() + tmp144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp145 := tmp144.FindInternedVar(lang.NewSymbol("concat")) + if tmp145.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp145))) + } + tmp146 := tmp145.Get() + tmp147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp148 := tmp147.FindInternedVar(lang.NewSymbol("list")) + if tmp148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp148))) + } + tmp149 := tmp148.Get() + tmp150 := lang.Apply(tmp149, []any{lang.NewSymbol("glojure.core/let")}) + tmp151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp152 := tmp151.FindInternedVar(lang.NewSymbol("list")) + if tmp152.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp152))) + } + tmp153 := tmp152.Get() + tmp154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp155 := tmp154.FindInternedVar(lang.NewSymbol("apply")) + if tmp155.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp155))) + } + tmp156 := tmp155.Get() + tmp157 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp158 := tmp157.FindInternedVar(lang.NewSymbol("vector")) + if tmp158.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp158))) + } + tmp159 := tmp158.Get() + tmp160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp161 := tmp160.FindInternedVar(lang.NewSymbol("seq")) + if tmp161.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp161))) + } + tmp162 := tmp161.Get() + tmp163 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp164 := tmp163.FindInternedVar(lang.NewSymbol("concat")) + if tmp164.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp164))) + } + tmp165 := tmp164.Get() + tmp166 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp167 := tmp166.FindInternedVar(lang.NewSymbol("list")) + if tmp167.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp167))) + } + tmp168 := tmp167.Get() + tmp169 := lang.Apply(tmp168, []any{v81}) + tmp170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp171 := tmp170.FindInternedVar(lang.NewSymbol("list")) + if tmp171.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp171))) + } + tmp172 := tmp171.Get() + tmp173 := lang.Apply(tmp172, []any{lang.NewSymbol("temp__0__auto__")}) + tmp174 := lang.Apply(tmp165, []any{tmp169, tmp173}) + tmp175 := lang.Apply(tmp162, []any{tmp174}) + tmp176 := lang.Apply(tmp156, []any{tmp159, tmp175}) + tmp177 := lang.Apply(tmp153, []any{tmp176}) + tmp178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp179 := tmp178.FindInternedVar(lang.NewSymbol("list")) + if tmp179.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp179))) + } + tmp180 := tmp179.Get() + tmp181 := lang.Apply(tmp180, []any{v6}) + tmp182 := lang.Apply(tmp146, []any{tmp150, tmp177, tmp181}) + tmp183 := lang.Apply(tmp143, []any{tmp182}) + tmp184 := lang.Apply(tmp140, []any{tmp183}) + tmp185 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp186 := tmp185.FindInternedVar(lang.NewSymbol("list")) + if tmp186.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp186))) + } + tmp187 := tmp186.Get() + tmp188 := lang.Apply(tmp187, []any{v7}) + tmp189 := lang.Apply(tmp129, []any{tmp133, tmp137, tmp184, tmp188}) + tmp190 := lang.Apply(tmp126, []any{tmp189}) + tmp191 := lang.Apply(tmp123, []any{tmp190}) + tmp192 := lang.Apply(tmp89, []any{tmp93, tmp120, tmp191}) + tmp193 := lang.Apply(tmp86, []any{tmp192}) + tmp79 = tmp193 } // end let - return v79 + return tmp79 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // if-not { - v0 := lang.NewSymbol("if-not").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("test"), lang.NewSymbol("then")), lang.NewVector(lang.NewSymbol("test"), lang.NewSymbol("then"), lang.NewSymbol("else"))), lang.NewKeyword("doc"), "Evaluates test. If logical false, evaluates and returns then expr, \n otherwise else expr, if supplied, else nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(760), lang.NewKeyword("end-line"), int(760))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("if-not").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("test"), lang.NewSymbol("then")), lang.NewVector(lang.NewSymbol("test"), lang.NewSymbol("then"), lang.NewSymbol("else"))), lang.NewKeyword("doc"), "Evaluates test. If logical false, evaluates and returns then expr, \n otherwise else expr, if supplied, else nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(760), lang.NewKeyword("end-line"), int(760))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 4: v3 := args[0] @@ -41500,49 +41607,49 @@ func init() { _ = v5 v6 := args[3] _ = v6 - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("seq")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("concat")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("list")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/if-not")}) - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("list")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.Apply(v19, []any{v5}) - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("list")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.Apply(v23, []any{v6}) - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("list")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.Apply(v27, []any{nil}) - v29 := lang.Apply(v12, []any{v16, v20, v24, v28}) - v30 := lang.Apply(v9, []any{v29}) - return v30 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("seq")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("concat")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("list")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("glojure.core/if-not")}) + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("list")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.Apply(tmp19, []any{v5}) + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("list")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.Apply(tmp23, []any{v6}) + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("list")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.Apply(tmp27, []any{nil}) + tmp29 := lang.Apply(tmp12, []any{tmp16, tmp20, tmp24, tmp28}) + tmp30 := lang.Apply(tmp9, []any{tmp29}) + return tmp30 case 5: v3 := args[0] _ = v3 @@ -41554,92 +41661,92 @@ func init() { _ = v6 v7 := args[4] _ = v7 - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("seq")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("concat")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("if")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("seq")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("concat")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/not")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{v5}) - v35 := lang.Apply(v26, []any{v30, v34}) - v36 := lang.Apply(v23, []any{v35}) - v37 := lang.Apply(v20, []any{v36}) - v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v39 := v38.FindInternedVar(lang.NewSymbol("list")) - if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) - } - v40 := v39.Get() - v41 := lang.Apply(v40, []any{v6}) - v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v43 := v42.FindInternedVar(lang.NewSymbol("list")) - if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) - } - v44 := v43.Get() - v45 := lang.Apply(v44, []any{v7}) - v46 := lang.Apply(v13, []any{v17, v37, v41, v45}) - v47 := lang.Apply(v10, []any{v46}) - return v47 + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("seq")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("concat")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("if")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/not")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{v5}) + tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) + tmp36 := lang.Apply(tmp23, []any{tmp35}) + tmp37 := lang.Apply(tmp20, []any{tmp36}) + tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp39 := tmp38.FindInternedVar(lang.NewSymbol("list")) + if tmp39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) + } + tmp40 := tmp39.Get() + tmp41 := lang.Apply(tmp40, []any{v6}) + tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp43 := tmp42.FindInternedVar(lang.NewSymbol("list")) + if tmp43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) + } + tmp44 := tmp43.Get() + tmp45 := lang.Apply(tmp44, []any{v7}) + tmp46 := lang.Apply(tmp13, []any{tmp17, tmp37, tmp41, tmp45}) + tmp47 := lang.Apply(tmp10, []any{tmp46}) + return tmp47 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // if-some { - v0 := lang.NewSymbol("if-some").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("then")), lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("then"), lang.NewSymbol("else"), lang.NewSymbol("&"), lang.NewSymbol("oldform"))), lang.NewKeyword("doc"), "bindings => binding-form test\n\n If test is not nil, evaluates then with binding-form bound to the\n value of test, if not, yields else", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1874), lang.NewKeyword("end-line"), int(1874))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("if-some").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("then")), lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("then"), lang.NewSymbol("else"), lang.NewSymbol("&"), lang.NewSymbol("oldform"))), lang.NewKeyword("doc"), "bindings => binding-form test\n\n If test is not nil, evaluates then with binding-form bound to the\n value of test, if not, yields else", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1874), lang.NewKeyword("end-line"), int(1874))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 4: v3 := args[0] @@ -41650,49 +41757,49 @@ func init() { _ = v5 v6 := args[3] _ = v6 - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("seq")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("concat")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("list")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/if-some")}) - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("list")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.Apply(v19, []any{v5}) - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("list")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.Apply(v23, []any{v6}) - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("list")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.Apply(v27, []any{nil}) - v29 := lang.Apply(v12, []any{v16, v20, v24, v28}) - v30 := lang.Apply(v9, []any{v29}) - return v30 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("seq")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("concat")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("list")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("glojure.core/if-some")}) + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("list")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.Apply(tmp19, []any{v5}) + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("list")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.Apply(tmp23, []any{v6}) + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("list")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.Apply(tmp27, []any{nil}) + tmp29 := lang.Apply(tmp12, []any{tmp16, tmp20, tmp24, tmp28}) + tmp30 := lang.Apply(tmp9, []any{tmp29}) + return tmp30 default: if len(args) < 5 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -41707,417 +41814,414 @@ func init() { _ = v6 v7 := args[4] _ = v7 - v8 := lang.NewList(args[5:]...) - var v9 any - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("vector?")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{v5}) - if lang.IsTruthy(v13) { - v9 = nil + var v8 any = lang.NewList(args[5:]...) + _ = v8 + var tmp9 any + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("vector?")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{v5}) + if lang.IsTruthy(tmp13) { } else { - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("str")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("first")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.Apply(v19, []any{v3}) - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("*ns*")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("meta")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.Apply(v26, []any{v3}) - v28 := lang.Apply(lang.NewKeyword("line"), []any{v27}) - v29 := lang.Apply(v16, []any{v20, " requires ", "a vector for its binding", " in ", v23, ":", v28}) - v30 := lang.Apply(lang.NewIllegalArgumentError, []any{v29}) - panic(v30) - } - _ = v9 - var v31 any - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("nil?")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{v8}) - if lang.IsTruthy(v35) { - v31 = nil + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("str")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("first")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.Apply(tmp19, []any{v3}) + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("*ns*")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("meta")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(lang.NewKeyword("line"), []any{tmp27}) + tmp29 := lang.Apply(tmp16, []any{tmp20, " requires ", "a vector for its binding", " in ", tmp23, ":", tmp28}) + tmp30 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp29}) + panic(tmp30) + } + _ = tmp9 + var tmp31 any + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("nil?")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.Apply(tmp34, []any{v8}) + if lang.IsTruthy(tmp35) { } else { - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("str")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v40 := v39.FindInternedVar(lang.NewSymbol("first")) - if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) - } - v41 := v40.Get() - v42 := lang.Apply(v41, []any{v3}) - v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v44 := v43.FindInternedVar(lang.NewSymbol("*ns*")) - if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) - } - v45 := v44.Get() - v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v47 := v46.FindInternedVar(lang.NewSymbol("meta")) - if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) - } - v48 := v47.Get() - v49 := lang.Apply(v48, []any{v3}) - v50 := lang.Apply(lang.NewKeyword("line"), []any{v49}) - v51 := lang.Apply(v38, []any{v42, " requires ", "1 or 2 forms after binding vector", " in ", v45, ":", v50}) - v52 := lang.Apply(lang.NewIllegalArgumentError, []any{v51}) - panic(v52) - } - _ = v31 - var v53 any - v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v55 := v54.FindInternedVar(lang.NewSymbol("=")) - if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) - } - v56 := v55.Get() - v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v58 := v57.FindInternedVar(lang.NewSymbol("count")) - if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) - } - v59 := v58.Get() - v60 := lang.Apply(v59, []any{v5}) - v61 := lang.Apply(v56, []any{int64(2), v60}) - if lang.IsTruthy(v61) { - v53 = nil + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("str")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp40 := tmp39.FindInternedVar(lang.NewSymbol("first")) + if tmp40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) + } + tmp41 := tmp40.Get() + tmp42 := lang.Apply(tmp41, []any{v3}) + tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp44 := tmp43.FindInternedVar(lang.NewSymbol("*ns*")) + if tmp44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) + } + tmp45 := tmp44.Get() + tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp47 := tmp46.FindInternedVar(lang.NewSymbol("meta")) + if tmp47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) + } + tmp48 := tmp47.Get() + tmp49 := lang.Apply(tmp48, []any{v3}) + tmp50 := lang.Apply(lang.NewKeyword("line"), []any{tmp49}) + tmp51 := lang.Apply(tmp38, []any{tmp42, " requires ", "1 or 2 forms after binding vector", " in ", tmp45, ":", tmp50}) + tmp52 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp51}) + panic(tmp52) + } + _ = tmp31 + var tmp53 any + tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp55 := tmp54.FindInternedVar(lang.NewSymbol("=")) + if tmp55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) + } + tmp56 := tmp55.Get() + tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp58 := tmp57.FindInternedVar(lang.NewSymbol("count")) + if tmp58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) + } + tmp59 := tmp58.Get() + tmp60 := lang.Apply(tmp59, []any{v5}) + tmp61 := lang.Apply(tmp56, []any{int64(2), tmp60}) + if lang.IsTruthy(tmp61) { } else { - v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v63 := v62.FindInternedVar(lang.NewSymbol("str")) - if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) - } - v64 := v63.Get() - v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v66 := v65.FindInternedVar(lang.NewSymbol("first")) - if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) - } - v67 := v66.Get() - v68 := lang.Apply(v67, []any{v3}) - v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v70 := v69.FindInternedVar(lang.NewSymbol("*ns*")) - if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) - } - v71 := v70.Get() - v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v73 := v72.FindInternedVar(lang.NewSymbol("meta")) - if v73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) - } - v74 := v73.Get() - v75 := lang.Apply(v74, []any{v3}) - v76 := lang.Apply(lang.NewKeyword("line"), []any{v75}) - v77 := lang.Apply(v64, []any{v68, " requires ", "exactly 2 forms in binding vector", " in ", v71, ":", v76}) - v78 := lang.Apply(lang.NewIllegalArgumentError, []any{v77}) - panic(v78) - } - _ = v53 - _ = nil - var v79 any + tmp62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp63 := tmp62.FindInternedVar(lang.NewSymbol("str")) + if tmp63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp63))) + } + tmp64 := tmp63.Get() + tmp65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp66 := tmp65.FindInternedVar(lang.NewSymbol("first")) + if tmp66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp66))) + } + tmp67 := tmp66.Get() + tmp68 := lang.Apply(tmp67, []any{v3}) + tmp69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp70 := tmp69.FindInternedVar(lang.NewSymbol("*ns*")) + if tmp70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp70))) + } + tmp71 := tmp70.Get() + tmp72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp73 := tmp72.FindInternedVar(lang.NewSymbol("meta")) + if tmp73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp73))) + } + tmp74 := tmp73.Get() + tmp75 := lang.Apply(tmp74, []any{v3}) + tmp76 := lang.Apply(lang.NewKeyword("line"), []any{tmp75}) + tmp77 := lang.Apply(tmp64, []any{tmp68, " requires ", "exactly 2 forms in binding vector", " in ", tmp71, ":", tmp76}) + tmp78 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp77}) + panic(tmp78) + } + _ = tmp53 + var tmp79 any { // let // let binding "form" - v80 := lang.Apply(v5, []any{int64(0)}) - var v81 any = v80 + tmp80 := lang.Apply(v5, []any{int64(0)}) + var v81 any = tmp80 _ = v81 // let binding "tst" - v82 := lang.Apply(v5, []any{int64(1)}) - var v83 any = v82 + tmp82 := lang.Apply(v5, []any{int64(1)}) + var v83 any = tmp82 _ = v83 - v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v85 := v84.FindInternedVar(lang.NewSymbol("seq")) - if v85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) - } - v86 := v85.Get() - v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v88 := v87.FindInternedVar(lang.NewSymbol("concat")) - if v88.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) - } - v89 := v88.Get() - v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v91 := v90.FindInternedVar(lang.NewSymbol("list")) - if v91.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) - } - v92 := v91.Get() - v93 := lang.Apply(v92, []any{lang.NewSymbol("glojure.core/let")}) - v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v95 := v94.FindInternedVar(lang.NewSymbol("list")) - if v95.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) - } - v96 := v95.Get() - v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v98 := v97.FindInternedVar(lang.NewSymbol("apply")) - if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) - } - v99 := v98.Get() - v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v101 := v100.FindInternedVar(lang.NewSymbol("vector")) - if v101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) - } - v102 := v101.Get() - v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v104 := v103.FindInternedVar(lang.NewSymbol("seq")) - if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) - } - v105 := v104.Get() - v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v107 := v106.FindInternedVar(lang.NewSymbol("concat")) - if v107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) - } - v108 := v107.Get() - v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v110 := v109.FindInternedVar(lang.NewSymbol("list")) - if v110.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) - } - v111 := v110.Get() - v112 := lang.Apply(v111, []any{lang.NewSymbol("temp__0__auto__")}) - v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v114 := v113.FindInternedVar(lang.NewSymbol("list")) - if v114.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) - } - v115 := v114.Get() - v116 := lang.Apply(v115, []any{v83}) - v117 := lang.Apply(v108, []any{v112, v116}) - v118 := lang.Apply(v105, []any{v117}) - v119 := lang.Apply(v99, []any{v102, v118}) - v120 := lang.Apply(v96, []any{v119}) - v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v122 := v121.FindInternedVar(lang.NewSymbol("list")) - if v122.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) - } - v123 := v122.Get() - v124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v125 := v124.FindInternedVar(lang.NewSymbol("seq")) - if v125.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v125))) - } - v126 := v125.Get() - v127 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v128 := v127.FindInternedVar(lang.NewSymbol("concat")) - if v128.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v128))) - } - v129 := v128.Get() - v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v131 := v130.FindInternedVar(lang.NewSymbol("list")) - if v131.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) - } - v132 := v131.Get() - v133 := lang.Apply(v132, []any{lang.NewSymbol("if")}) - v134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v135 := v134.FindInternedVar(lang.NewSymbol("list")) - if v135.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v135))) - } - v136 := v135.Get() - v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v138 := v137.FindInternedVar(lang.NewSymbol("seq")) - if v138.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) - } - v139 := v138.Get() - v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v141 := v140.FindInternedVar(lang.NewSymbol("concat")) - if v141.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) - } - v142 := v141.Get() - v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v144 := v143.FindInternedVar(lang.NewSymbol("list")) - if v144.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) - } - v145 := v144.Get() - v146 := lang.Apply(v145, []any{lang.NewSymbol("glojure.core/nil?")}) - v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v148 := v147.FindInternedVar(lang.NewSymbol("list")) - if v148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) - } - v149 := v148.Get() - v150 := lang.Apply(v149, []any{lang.NewSymbol("temp__0__auto__")}) - v151 := lang.Apply(v142, []any{v146, v150}) - v152 := lang.Apply(v139, []any{v151}) - v153 := lang.Apply(v136, []any{v152}) - v154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v155 := v154.FindInternedVar(lang.NewSymbol("list")) - if v155.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v155))) - } - v156 := v155.Get() - v157 := lang.Apply(v156, []any{v7}) - v158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v159 := v158.FindInternedVar(lang.NewSymbol("list")) - if v159.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v159))) - } - v160 := v159.Get() - v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v162 := v161.FindInternedVar(lang.NewSymbol("seq")) - if v162.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) - } - v163 := v162.Get() - v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v165 := v164.FindInternedVar(lang.NewSymbol("concat")) - if v165.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) - } - v166 := v165.Get() - v167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v168 := v167.FindInternedVar(lang.NewSymbol("list")) - if v168.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v168))) - } - v169 := v168.Get() - v170 := lang.Apply(v169, []any{lang.NewSymbol("glojure.core/let")}) - v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v172 := v171.FindInternedVar(lang.NewSymbol("list")) - if v172.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) - } - v173 := v172.Get() - v174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v175 := v174.FindInternedVar(lang.NewSymbol("apply")) - if v175.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v175))) - } - v176 := v175.Get() - v177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v178 := v177.FindInternedVar(lang.NewSymbol("vector")) - if v178.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v178))) - } - v179 := v178.Get() - v180 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v181 := v180.FindInternedVar(lang.NewSymbol("seq")) - if v181.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v181))) - } - v182 := v181.Get() - v183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v184 := v183.FindInternedVar(lang.NewSymbol("concat")) - if v184.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v184))) - } - v185 := v184.Get() - v186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v187 := v186.FindInternedVar(lang.NewSymbol("list")) - if v187.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v187))) - } - v188 := v187.Get() - v189 := lang.Apply(v188, []any{v81}) - v190 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v191 := v190.FindInternedVar(lang.NewSymbol("list")) - if v191.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v191))) - } - v192 := v191.Get() - v193 := lang.Apply(v192, []any{lang.NewSymbol("temp__0__auto__")}) - v194 := lang.Apply(v185, []any{v189, v193}) - v195 := lang.Apply(v182, []any{v194}) - v196 := lang.Apply(v176, []any{v179, v195}) - v197 := lang.Apply(v173, []any{v196}) - v198 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v199 := v198.FindInternedVar(lang.NewSymbol("list")) - if v199.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v199))) - } - v200 := v199.Get() - v201 := lang.Apply(v200, []any{v6}) - v202 := lang.Apply(v166, []any{v170, v197, v201}) - v203 := lang.Apply(v163, []any{v202}) - v204 := lang.Apply(v160, []any{v203}) - v205 := lang.Apply(v129, []any{v133, v153, v157, v204}) - v206 := lang.Apply(v126, []any{v205}) - v207 := lang.Apply(v123, []any{v206}) - v208 := lang.Apply(v89, []any{v93, v120, v207}) - v209 := lang.Apply(v86, []any{v208}) - v79 = v209 + tmp84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp85 := tmp84.FindInternedVar(lang.NewSymbol("seq")) + if tmp85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp85))) + } + tmp86 := tmp85.Get() + tmp87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp88 := tmp87.FindInternedVar(lang.NewSymbol("concat")) + if tmp88.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp88))) + } + tmp89 := tmp88.Get() + tmp90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp91 := tmp90.FindInternedVar(lang.NewSymbol("list")) + if tmp91.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp91))) + } + tmp92 := tmp91.Get() + tmp93 := lang.Apply(tmp92, []any{lang.NewSymbol("glojure.core/let")}) + tmp94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp95 := tmp94.FindInternedVar(lang.NewSymbol("list")) + if tmp95.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp95))) + } + tmp96 := tmp95.Get() + tmp97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp98 := tmp97.FindInternedVar(lang.NewSymbol("apply")) + if tmp98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp98))) + } + tmp99 := tmp98.Get() + tmp100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp101 := tmp100.FindInternedVar(lang.NewSymbol("vector")) + if tmp101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp101))) + } + tmp102 := tmp101.Get() + tmp103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp104 := tmp103.FindInternedVar(lang.NewSymbol("seq")) + if tmp104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp104))) + } + tmp105 := tmp104.Get() + tmp106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp107 := tmp106.FindInternedVar(lang.NewSymbol("concat")) + if tmp107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp107))) + } + tmp108 := tmp107.Get() + tmp109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp110 := tmp109.FindInternedVar(lang.NewSymbol("list")) + if tmp110.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp110))) + } + tmp111 := tmp110.Get() + tmp112 := lang.Apply(tmp111, []any{lang.NewSymbol("temp__0__auto__")}) + tmp113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp114 := tmp113.FindInternedVar(lang.NewSymbol("list")) + if tmp114.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp114))) + } + tmp115 := tmp114.Get() + tmp116 := lang.Apply(tmp115, []any{v83}) + tmp117 := lang.Apply(tmp108, []any{tmp112, tmp116}) + tmp118 := lang.Apply(tmp105, []any{tmp117}) + tmp119 := lang.Apply(tmp99, []any{tmp102, tmp118}) + tmp120 := lang.Apply(tmp96, []any{tmp119}) + tmp121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp122 := tmp121.FindInternedVar(lang.NewSymbol("list")) + if tmp122.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp122))) + } + tmp123 := tmp122.Get() + tmp124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp125 := tmp124.FindInternedVar(lang.NewSymbol("seq")) + if tmp125.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp125))) + } + tmp126 := tmp125.Get() + tmp127 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp128 := tmp127.FindInternedVar(lang.NewSymbol("concat")) + if tmp128.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp128))) + } + tmp129 := tmp128.Get() + tmp130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp131 := tmp130.FindInternedVar(lang.NewSymbol("list")) + if tmp131.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp131))) + } + tmp132 := tmp131.Get() + tmp133 := lang.Apply(tmp132, []any{lang.NewSymbol("if")}) + tmp134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp135 := tmp134.FindInternedVar(lang.NewSymbol("list")) + if tmp135.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp135))) + } + tmp136 := tmp135.Get() + tmp137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp138 := tmp137.FindInternedVar(lang.NewSymbol("seq")) + if tmp138.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp138))) + } + tmp139 := tmp138.Get() + tmp140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp141 := tmp140.FindInternedVar(lang.NewSymbol("concat")) + if tmp141.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp141))) + } + tmp142 := tmp141.Get() + tmp143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp144 := tmp143.FindInternedVar(lang.NewSymbol("list")) + if tmp144.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp144))) + } + tmp145 := tmp144.Get() + tmp146 := lang.Apply(tmp145, []any{lang.NewSymbol("glojure.core/nil?")}) + tmp147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp148 := tmp147.FindInternedVar(lang.NewSymbol("list")) + if tmp148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp148))) + } + tmp149 := tmp148.Get() + tmp150 := lang.Apply(tmp149, []any{lang.NewSymbol("temp__0__auto__")}) + tmp151 := lang.Apply(tmp142, []any{tmp146, tmp150}) + tmp152 := lang.Apply(tmp139, []any{tmp151}) + tmp153 := lang.Apply(tmp136, []any{tmp152}) + tmp154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp155 := tmp154.FindInternedVar(lang.NewSymbol("list")) + if tmp155.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp155))) + } + tmp156 := tmp155.Get() + tmp157 := lang.Apply(tmp156, []any{v7}) + tmp158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp159 := tmp158.FindInternedVar(lang.NewSymbol("list")) + if tmp159.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp159))) + } + tmp160 := tmp159.Get() + tmp161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp162 := tmp161.FindInternedVar(lang.NewSymbol("seq")) + if tmp162.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp162))) + } + tmp163 := tmp162.Get() + tmp164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp165 := tmp164.FindInternedVar(lang.NewSymbol("concat")) + if tmp165.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp165))) + } + tmp166 := tmp165.Get() + tmp167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp168 := tmp167.FindInternedVar(lang.NewSymbol("list")) + if tmp168.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp168))) + } + tmp169 := tmp168.Get() + tmp170 := lang.Apply(tmp169, []any{lang.NewSymbol("glojure.core/let")}) + tmp171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp172 := tmp171.FindInternedVar(lang.NewSymbol("list")) + if tmp172.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp172))) + } + tmp173 := tmp172.Get() + tmp174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp175 := tmp174.FindInternedVar(lang.NewSymbol("apply")) + if tmp175.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp175))) + } + tmp176 := tmp175.Get() + tmp177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp178 := tmp177.FindInternedVar(lang.NewSymbol("vector")) + if tmp178.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp178))) + } + tmp179 := tmp178.Get() + tmp180 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp181 := tmp180.FindInternedVar(lang.NewSymbol("seq")) + if tmp181.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp181))) + } + tmp182 := tmp181.Get() + tmp183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp184 := tmp183.FindInternedVar(lang.NewSymbol("concat")) + if tmp184.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp184))) + } + tmp185 := tmp184.Get() + tmp186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp187 := tmp186.FindInternedVar(lang.NewSymbol("list")) + if tmp187.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp187))) + } + tmp188 := tmp187.Get() + tmp189 := lang.Apply(tmp188, []any{v81}) + tmp190 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp191 := tmp190.FindInternedVar(lang.NewSymbol("list")) + if tmp191.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp191))) + } + tmp192 := tmp191.Get() + tmp193 := lang.Apply(tmp192, []any{lang.NewSymbol("temp__0__auto__")}) + tmp194 := lang.Apply(tmp185, []any{tmp189, tmp193}) + tmp195 := lang.Apply(tmp182, []any{tmp194}) + tmp196 := lang.Apply(tmp176, []any{tmp179, tmp195}) + tmp197 := lang.Apply(tmp173, []any{tmp196}) + tmp198 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp199 := tmp198.FindInternedVar(lang.NewSymbol("list")) + if tmp199.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp199))) + } + tmp200 := tmp199.Get() + tmp201 := lang.Apply(tmp200, []any{v6}) + tmp202 := lang.Apply(tmp166, []any{tmp170, tmp197, tmp201}) + tmp203 := lang.Apply(tmp163, []any{tmp202}) + tmp204 := lang.Apply(tmp160, []any{tmp203}) + tmp205 := lang.Apply(tmp129, []any{tmp133, tmp153, tmp157, tmp204}) + tmp206 := lang.Apply(tmp126, []any{tmp205}) + tmp207 := lang.Apply(tmp123, []any{tmp206}) + tmp208 := lang.Apply(tmp89, []any{tmp93, tmp120, tmp207}) + tmp209 := lang.Apply(tmp86, []any{tmp208}) + tmp79 = tmp209 } // end let - return v79 + return tmp79 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // ifn? { - v0 := lang.NewSymbol("ifn?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements IFn. Note that many data structures\n (e.g. sets and maps) implement IFn", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6209), lang.NewKeyword("end-line"), int(6209))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("ifn?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements IFn. Note that many data structures\n (e.g. sets and maps) implement IFn", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6209), lang.NewKeyword("end-line"), int(6209))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) } - v6 := v5.Get() - v7 := lang.Apply(v6, []any{nil, v3}) - return v7 + tmp6 := tmp5.Get() + tmp7 := lang.Apply(tmp6, []any{nil, v3}) + return tmp7 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // import { - v0 := lang.NewSymbol("import").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("import-symbols-or-lists"))), lang.NewKeyword("doc"), "import-list => (package-symbol class-name-symbols*)\n\n For each name in class-name-symbols, adds a mapping from name to the\n class named by package.name to the current namespace. Use :import in the ns\n macro in preference to calling this directly.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3426), lang.NewKeyword("end-line"), int(3426))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("import").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("import-symbols-or-lists"))), lang.NewKeyword("doc"), "import-list => (package-symbol class-name-symbols*)\n\n For each name in class-name-symbols, adds a mapping from name to the\n class named by package.name to the current namespace. Use :import in the ns\n macro in preference to calling this directly.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3426), lang.NewKeyword("end-line"), int(3426))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 2 { @@ -42127,134 +42231,135 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.NewList(args[2:]...) - var v6 any + var v5 any = lang.NewList(args[2:]...) + _ = v5 + var tmp6 any { // let // let binding "specs" - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("map")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - var v10 lang.FnFunc - v10 = lang.NewFnFunc(func(args ...any) any { + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("map")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v11 := args[0] _ = v11 - var v12 any - var v13 any + var tmp12 any + var tmp13 any { // let // let binding "and__0__auto__" - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("seq?")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{v11}) - var v18 any = v17 + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("seq?")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{v11}) + var v18 any = tmp17 _ = v18 - var v19 any + var tmp19 any if lang.IsTruthy(v18) { - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("=")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("=")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) } - v22 := v21.Get() - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("first")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + tmp22 := tmp21.Get() + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("first")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) } - v25 := v24.Get() - v26 := lang.Apply(v25, []any{v11}) - v27 := lang.Apply(v22, []any{lang.NewSymbol("quote"), v26}) - v19 = v27 + tmp25 := tmp24.Get() + tmp26 := lang.Apply(tmp25, []any{v11}) + tmp27 := lang.Apply(tmp22, []any{lang.NewSymbol("quote"), tmp26}) + tmp19 = tmp27 } else { - v19 = v18 + tmp19 = v18 } - v13 = v19 + tmp13 = tmp19 } // end let - if lang.IsTruthy(v13) { - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("second")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{v11}) - v12 = v17 + if lang.IsTruthy(tmp13) { + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("second")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{v11}) + tmp12 = tmp17 } else { - v12 = v11 + tmp12 = v11 } - return v12 + return tmp12 }) - v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3434), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(3434), lang.NewKeyword("end-column"), int(73)) - v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) + tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3434), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(3434), lang.NewKeyword("end-column"), int(73)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) if err != nil { panic(err) } - v13 := lang.Apply(v9, []any{v12, v5}) - var v14 any = v13 + tmp13 := lang.Apply(tmp9, []any{tmp12, v5}) + var v14 any = tmp13 _ = v14 - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("seq")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("concat")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("list")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.Apply(v23, []any{lang.NewSymbol("do")}) - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("map")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - var v28 lang.FnFunc - v28 = lang.NewFnFunc(func(args ...any) any { + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("seq")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("concat")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("list")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.Apply(tmp23, []any{lang.NewSymbol("do")}) + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("map")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + var tmp28 lang.FnFunc + tmp28 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v29 := args[0] _ = v29 - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("list")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) - } - v32 := v31.Get() - v33 := lang.Apply(v32, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Import"), v29}) - return v33 + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("list")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) + } + tmp32 := tmp31.Get() + tmp33 := lang.Apply(tmp32, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Import"), v29}) + return tmp33 }) - v29 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3436), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(3436), lang.NewKeyword("end-column"), int(73)) - v30, err := lang.WithMeta(v28, v29.(lang.IPersistentMap)) + tmp29 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3436), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(3436), lang.NewKeyword("end-column"), int(73)) + tmp30, err := lang.WithMeta(tmp28, tmp29.(lang.IPersistentMap)) if err != nil { panic(err) } - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("reduce1")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) } - v33 := v32.Get() - var v34 lang.FnFunc - v34 = lang.NewFnFunc(func(args ...any) any { + tmp33 := tmp32.Get() + var tmp34 lang.FnFunc + tmp34 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -42262,447 +42367,450 @@ func init() { _ = v35 v36 := args[1] _ = v36 - var v37 any - v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v39 := v38.FindInternedVar(lang.NewSymbol("symbol?")) - if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) - } - v40 := v39.Get() - v41 := lang.Apply(v40, []any{v36}) - if lang.IsTruthy(v41) { - v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v43 := v42.FindInternedVar(lang.NewSymbol("conj")) - if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) - } - v44 := v43.Get() - v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v46 := v45.FindInternedVar(lang.NewSymbol("name")) - if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) - } - v47 := v46.Get() - v48 := lang.Apply(v47, []any{v36}) - v49 := lang.Apply(v44, []any{v35, v48}) - v37 = v49 + var tmp37 any + tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp39 := tmp38.FindInternedVar(lang.NewSymbol("symbol?")) + if tmp39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) + } + tmp40 := tmp39.Get() + tmp41 := lang.Apply(tmp40, []any{v36}) + if lang.IsTruthy(tmp41) { + tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp43 := tmp42.FindInternedVar(lang.NewSymbol("conj")) + if tmp43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) + } + tmp44 := tmp43.Get() + tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp46 := tmp45.FindInternedVar(lang.NewSymbol("name")) + if tmp46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) + } + tmp47 := tmp46.Get() + tmp48 := lang.Apply(tmp47, []any{v36}) + tmp49 := lang.Apply(tmp44, []any{v35, tmp48}) + tmp37 = tmp49 } else { - var v50 any + var tmp50 any { // let // let binding "p" - v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v52 := v51.FindInternedVar(lang.NewSymbol("first")) - if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) + tmp51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp52 := tmp51.FindInternedVar(lang.NewSymbol("first")) + if tmp52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp52))) } - v53 := v52.Get() - v54 := lang.Apply(v53, []any{v36}) - var v55 any = v54 + tmp53 := tmp52.Get() + tmp54 := lang.Apply(tmp53, []any{v36}) + var v55 any = tmp54 _ = v55 // let binding "cs" - v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v57 := v56.FindInternedVar(lang.NewSymbol("rest")) - if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) + tmp56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp57 := tmp56.FindInternedVar(lang.NewSymbol("rest")) + if tmp57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp57))) } - v58 := v57.Get() - v59 := lang.Apply(v58, []any{v36}) - var v60 any = v59 + tmp58 := tmp57.Get() + tmp59 := lang.Apply(tmp58, []any{v36}) + var v60 any = tmp59 _ = v60 - v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v62 := v61.FindInternedVar(lang.NewSymbol("into1")) - if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) + tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp62 := tmp61.FindInternedVar(lang.NewSymbol("into1")) + if tmp62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) } - v63 := v62.Get() - v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v65 := v64.FindInternedVar(lang.NewSymbol("map")) - if v65.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) + tmp63 := tmp62.Get() + tmp64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp65 := tmp64.FindInternedVar(lang.NewSymbol("map")) + if tmp65.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp65))) } - v66 := v65.Get() - var v67 lang.FnFunc - v67 = lang.NewFnFunc(func(args ...any) any { + tmp66 := tmp65.Get() + var tmp67 lang.FnFunc + tmp67 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v68 := args[0] _ = v68 - v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v70 := v69.FindInternedVar(lang.NewSymbol("str")) - if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) + tmp69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp70 := tmp69.FindInternedVar(lang.NewSymbol("str")) + if tmp70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp70))) } - v71 := v70.Get() - v72 := lang.Apply(v71, []any{v55, ".", v68}) - return v72 + tmp71 := tmp70.Get() + tmp72 := lang.Apply(tmp71, []any{v55, ".", v68}) + return tmp72 }) - v68 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3441), lang.NewKeyword("column"), int(45), lang.NewKeyword("end-line"), int(3441), lang.NewKeyword("end-column"), int(58)) - v69, err := lang.WithMeta(v67, v68.(lang.IPersistentMap)) + tmp68 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3441), lang.NewKeyword("column"), int(45), lang.NewKeyword("end-line"), int(3441), lang.NewKeyword("end-column"), int(58)) + tmp69, err := lang.WithMeta(tmp67, tmp68.(lang.IPersistentMap)) if err != nil { panic(err) } - v70 := lang.Apply(v66, []any{v69, v60}) - v71 := lang.Apply(v63, []any{v35, v70}) - v50 = v71 + tmp70 := lang.Apply(tmp66, []any{tmp69, v60}) + tmp71 := lang.Apply(tmp63, []any{v35, tmp70}) + tmp50 = tmp71 } // end let - v37 = v50 + tmp37 = tmp50 } - return v37 + return tmp37 }) - v35 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3437), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(3441), lang.NewKeyword("end-column"), int(66)) - v36, err := lang.WithMeta(v34, v35.(lang.IPersistentMap)) + tmp35 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3437), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(3441), lang.NewKeyword("end-column"), int(66)) + tmp36, err := lang.WithMeta(tmp34, tmp35.(lang.IPersistentMap)) if err != nil { panic(err) } - v37 := lang.NewVector() - v38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3442), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(3442), lang.NewKeyword("end-column"), int(26)) - v39, err := lang.WithMeta(v37, v38.(lang.IPersistentMap)) + tmp37 := lang.NewVector() + tmp38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3442), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(3442), lang.NewKeyword("end-column"), int(26)) + tmp39, err := lang.WithMeta(tmp37, tmp38.(lang.IPersistentMap)) if err != nil { panic(err) } - v40 := lang.Apply(v33, []any{v36, v39, v14}) - v41 := lang.Apply(v27, []any{v30, v40}) - v42 := lang.Apply(v20, []any{v24, v41}) - v43 := lang.Apply(v17, []any{v42}) - v6 = v43 + tmp40 := lang.Apply(tmp33, []any{tmp36, tmp39, v14}) + tmp41 := lang.Apply(tmp27, []any{tmp30, tmp40}) + tmp42 := lang.Apply(tmp20, []any{tmp24, tmp41}) + tmp43 := lang.Apply(tmp17, []any{tmp42}) + tmp6 = tmp43 } // end let - return v6 + return tmp6 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // in-ns { - v0 := lang.NewSymbol("in-ns").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - v1 := ns.InternWithValue(v0, nil, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp0 := lang.NewSymbol("in-ns").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // inc { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function inc__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("concat")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("list")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("seq")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("concat")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - var v30 any - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - if lang.IsTruthy(v33) { - v30 = lang.NewSymbol("unchecked_inc") + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + var tmp30 any + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + if lang.IsTruthy(tmp33) { + tmp30 = lang.NewSymbol("unchecked_inc") } else { - v30 = lang.NewSymbol("inc") - } - v34 := lang.Apply(v29, []any{v30}) - v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v36 := v35.FindInternedVar(lang.NewSymbol("list")) - if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) - } - v37 := v36.Get() - v38 := lang.Apply(v37, []any{v3}) - v39 := lang.Apply(v26, []any{v34, v38}) - v40 := lang.Apply(v23, []any{v39}) - v41 := lang.Apply(v20, []any{v40}) - v42 := lang.Apply(v9, []any{v13, v17, v41}) - v43 := lang.Apply(v6, []any{v42}) - return v43 + tmp30 = lang.NewSymbol("inc") + } + tmp34 := lang.Apply(tmp29, []any{tmp30}) + tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp36 := tmp35.FindInternedVar(lang.NewSymbol("list")) + if tmp36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) + } + tmp37 := tmp36.Get() + tmp38 := lang.Apply(tmp37, []any{v3}) + tmp39 := lang.Apply(tmp26, []any{tmp34, tmp38}) + tmp40 := lang.Apply(tmp23, []any{tmp39}) + tmp41 := lang.Apply(tmp20, []any{tmp40}) + tmp42 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp41}) + tmp43 := lang.Apply(tmp6, []any{tmp42}) + return tmp43 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("inc").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns a number one greater than num. Does not auto-promote\n longs, will throw on overflow. See also: inc'", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(915), lang.NewKeyword("end-line"), int(915))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("inc").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns a number one greater than num. Does not auto-promote\n longs, will throw on overflow. See also: inc'", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(915), lang.NewKeyword("end-line"), int(915))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5, _ := lang.FieldOrMethod(lang.Numbers, "Inc") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Inc") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Inc is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // inc' { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function inc'__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("concat")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("list")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("seq")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("concat")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/IncP")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{v3}) - v35 := lang.Apply(v26, []any{v30, v34}) - v36 := lang.Apply(v23, []any{v35}) - v37 := lang.Apply(v20, []any{v36}) - v38 := lang.Apply(v9, []any{v13, v17, v37}) - v39 := lang.Apply(v6, []any{v38}) - return v39 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/IncP")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{v3}) + tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) + tmp36 := lang.Apply(tmp23, []any{tmp35}) + tmp37 := lang.Apply(tmp20, []any{tmp36}) + tmp38 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp37}) + tmp39 := lang.Apply(tmp6, []any{tmp38}) + return tmp39 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("inc'").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns a number one greater than num. Supports arbitrary precision.\n See also: inc", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(908), lang.NewKeyword("end-line"), int(908))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("inc'").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns a number one greater than num. Supports arbitrary precision.\n See also: inc", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(908), lang.NewKeyword("end-line"), int(908))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5, _ := lang.FieldOrMethod(lang.Numbers, "IncP") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "IncP") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("IncP is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // indexed? { - v0 := lang.NewSymbol("indexed?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return true if coll implements Indexed, indicating efficient lookup by index", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6263), lang.NewKeyword("end-line"), int(6263))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("indexed?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return true if coll implements Indexed, indicating efficient lookup by index", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6263), lang.NewKeyword("end-line"), int(6263))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) } - v6 := v5.Get() - v7 := lang.Apply(v6, []any{nil, v3}) - return v7 + tmp6 := tmp5.Get() + tmp7 := lang.Apply(tmp6, []any{nil, v3}) + return tmp7 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // infinite? { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function infinite?__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("concat")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("list")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol("Double/isInfinite")}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{v3}) - v18 := lang.Apply(v9, []any{v13, v17}) - v19 := lang.Apply(v6, []any{v18}) - return v19 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol("Double/isInfinite")}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := lang.Apply(tmp9, []any{tmp13, tmp17}) + tmp19 := lang.Apply(tmp6, []any{tmp18}) + return tmp19 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("infinite?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns true if num is negative or positive infinity, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)), lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7977), lang.NewKeyword("end-line"), int(7977))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("infinite?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns true if num is negative or positive infinity, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1)})), lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7977), lang.NewKeyword("end-line"), int(7977))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5 := lang.Apply(nil, []any{v4}) - return v5 + tmp5 := lang.Apply(nil, []any{v4}) + return tmp5 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // inst-ms { - v0 := lang.NewSymbol("inst-ms").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("inst"))), lang.NewKeyword("doc"), "Return the number of milliseconds since January 1, 1970, 00:00:00 GMT", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6831), lang.NewKeyword("end-line"), int(6831))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("inst-ms").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("inst"))), lang.NewKeyword("doc"), "Return the number of milliseconds since January 1, 1970, 00:00:00 GMT", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6831), lang.NewKeyword("end-line"), int(6831))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.Apply(nil, []any{v3}) - return v4 + tmp4 := lang.Apply(nil, []any{v3}) + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // inst? { - v0 := lang.NewSymbol("inst?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x satisfies Inst", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6837), lang.NewKeyword("end-line"), int(6837))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("inst?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x satisfies Inst", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6837), lang.NewKeyword("end-line"), int(6837))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -42710,18 +42818,19 @@ func init() { _ = v3 return nil }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // instance? { - v0 := lang.NewSymbol("instance?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Evaluates x and tests if it is an instance of the type\n t. Returns true or false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(139), lang.NewKeyword("end-line"), int(143))).(*lang.Symbol) - var v2 lang.FnFunc + tmp0 := lang.NewSymbol("instance?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Evaluates x and tests if it is an instance of the type\n t. Returns true or false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(139), lang.NewKeyword("end-line"), int(143))).(*lang.Symbol) + var tmp2 lang.FnFunc { // function instance? - v2 = lang.NewFnFunc(func(args ...any) any { + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -42729,480 +42838,482 @@ func init() { _ = v4 v5 := args[1] _ = v5 - v6 := lang.Apply(lang.HasType, []any{v4, v5}) - return v6 + tmp6 := lang.Apply(lang.HasType, []any{v4, v5}) + return tmp6 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(143), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(143), lang.NewKeyword("end-column"), int(85))).(lang.FnFunc) - v3 := v2 + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(143), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(143), lang.NewKeyword("end-column"), int(85))).(lang.FnFunc) + v3 = tmp2 _ = v3 } - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // int { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function int__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("concat")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("list")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("seq")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("concat")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - var v30 any - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - if lang.IsTruthy(v33) { - v30 = lang.NewSymbol("uncheckedIntCast") + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + var tmp30 any + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + if lang.IsTruthy(tmp33) { + tmp30 = lang.NewSymbol("uncheckedIntCast") } else { - v30 = lang.NewSymbol("intCast") - } - v34 := lang.Apply(v29, []any{v30}) - v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v36 := v35.FindInternedVar(lang.NewSymbol("list")) - if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) - } - v37 := v36.Get() - v38 := lang.Apply(v37, []any{v3}) - v39 := lang.Apply(v26, []any{v34, v38}) - v40 := lang.Apply(v23, []any{v39}) - v41 := lang.Apply(v20, []any{v40}) - v42 := lang.Apply(v9, []any{v13, v17, v41}) - v43 := lang.Apply(v6, []any{v42}) - return v43 + tmp30 = lang.NewSymbol("intCast") + } + tmp34 := lang.Apply(tmp29, []any{tmp30}) + tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp36 := tmp35.FindInternedVar(lang.NewSymbol("list")) + if tmp36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) + } + tmp37 := tmp36.Get() + tmp38 := lang.Apply(tmp37, []any{v3}) + tmp39 := lang.Apply(tmp26, []any{tmp34, tmp38}) + tmp40 := lang.Apply(tmp23, []any{tmp39}) + tmp41 := lang.Apply(tmp20, []any{tmp40}) + tmp42 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp41}) + tmp43 := lang.Apply(tmp6, []any{tmp42}) + return tmp43 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to int", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(875), lang.NewKeyword("end-line"), int(875))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to int", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(875), lang.NewKeyword("end-line"), int(875))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5, _ := lang.FieldOrMethod(runtime4.RT, "IntCast") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(runtime4.RT, "IntCast") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("IntCast is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // int-array { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function int-array__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v3 := lang.NewList(args[0:]...) - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("concat")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("list")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/IntArray")}) - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("list")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("seq")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("concat")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) - v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v36 := v35.FindInternedVar(lang.NewSymbol("list")) - if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) - } - v37 := v36.Get() - v38 := lang.Apply(v37, []any{lang.NewSymbol("glojure.core/args")}) - v39 := lang.Apply(v30, []any{v34, v38}) - v40 := lang.Apply(v27, []any{v39}) - v41 := lang.Apply(v24, []any{v40}) - v42 := lang.Apply(v9, []any{v13, v17, v21, v41}) - v43 := lang.Apply(v6, []any{v42}) - return v43 + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.Apply(tmp20, []any{lang.NewSymbol("glojure.core/IntArray")}) + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("list")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("seq")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("concat")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) + tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp36 := tmp35.FindInternedVar(lang.NewSymbol("list")) + if tmp36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) + } + tmp37 := tmp36.Get() + tmp38 := lang.Apply(tmp37, []any{lang.NewSymbol("glojure.core/args")}) + tmp39 := lang.Apply(tmp30, []any{tmp34, tmp38}) + tmp40 := lang.Apply(tmp27, []any{tmp39}) + tmp41 := lang.Apply(tmp24, []any{tmp40}) + tmp42 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp21, tmp41}) + tmp43 := lang.Apply(tmp6, []any{tmp42}) + return tmp43 } }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("int-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Creates an array of ints", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1), int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5356), lang.NewKeyword("end-line"), int(5356))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("int-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Creates an array of ints", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5356), lang.NewKeyword("end-line"), int(5356))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v4 := args[0] _ = v4 - v5, _ := lang.FieldOrMethod(lang.Numbers, "IntArray") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "IntArray") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("IntArray is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 case 2: v4 := args[0] _ = v4 v5 := args[1] _ = v5 - v6, _ := lang.FieldOrMethod(lang.Numbers, "IntArrayInit") - if reflect.TypeOf(v6).Kind() != reflect.Func { + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "IntArrayInit") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("IntArrayInit is not a function"))) } - v7 := lang.Apply(v6, []any{v4, v5}) - return v7 + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // int? { - v0 := lang.NewSymbol("int?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a fixed precision integer", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1395), lang.NewKeyword("end-line"), int(1395))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("int?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a fixed precision integer", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1395), lang.NewKeyword("end-line"), int(1395))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any + var tmp4 any { // let // let binding "or__0__auto__" - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{lang.Builtins["int64"], v3}) - var v9 any = v8 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("instance?")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{lang.Builtins["int64"], v3}) + var v9 any = tmp8 _ = v9 - var v10 any + var tmp10 any if lang.IsTruthy(v9) { - v10 = v9 + tmp10 = v9 } else { - var v11 any + var tmp11 any { // let // let binding "or__0__auto__" - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("instance?")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.Apply(v14, []any{nil, v3}) - var v16 any = v15 + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("instance?")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.Apply(tmp14, []any{nil, v3}) + var v16 any = tmp15 _ = v16 - var v17 any + var tmp17 any if lang.IsTruthy(v16) { - v17 = v16 + tmp17 = v16 } else { - var v18 any + var tmp18 any { // let // let binding "or__0__auto__" - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("instance?")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("instance?")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{nil, v3}) - var v23 any = v22 + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, []any{nil, v3}) + var v23 any = tmp22 _ = v23 - var v24 any + var tmp24 any if lang.IsTruthy(v23) { - v24 = v23 + tmp24 = v23 } else { - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("instance?")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("instance?")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) } - v27 := v26.Get() - v28 := lang.Apply(v27, []any{nil, v3}) - v24 = v28 + tmp27 := tmp26.Get() + tmp28 := lang.Apply(tmp27, []any{nil, v3}) + tmp24 = tmp28 } - v18 = v24 + tmp18 = tmp24 } // end let - v17 = v18 + tmp17 = tmp18 } - v11 = v17 + tmp11 = tmp17 } // end let - v10 = v11 + tmp10 = tmp11 } - v4 = v10 + tmp4 = tmp10 } // end let - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // integer? { - v0 := lang.NewSymbol("integer?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is an integer", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1379), lang.NewKeyword("end-line"), int(1379))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("integer?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is an integer", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1379), lang.NewKeyword("end-line"), int(1379))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.Apply(lang.IsInteger, []any{v3}) - return v4 + tmp4 := lang.Apply(lang.IsInteger, []any{v3}) + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // interleave { - v0 := lang.NewSymbol("interleave").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("c1")), lang.NewVector(lang.NewSymbol("c1"), lang.NewSymbol("c2")), lang.NewVector(lang.NewSymbol("c1"), lang.NewSymbol("c2"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Returns a lazy seq of the first item in each coll, then the second etc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4308), lang.NewKeyword("end-line"), int(4308))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("interleave").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("c1")), lang.NewVector(lang.NewSymbol("c1"), lang.NewSymbol("c2")), lang.NewVector(lang.NewSymbol("c1"), lang.NewSymbol("c2"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Returns a lazy seq of the first item in each coll, then the second etc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4308), lang.NewKeyword("end-line"), int(4308))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: return lang.NewList() case 1: v3 := args[0] _ = v3 - var v4 lang.FnFunc - v4 = lang.NewFnFunc(func(args ...any) any { + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } return v3 }) - v5 := lang.Apply(lang.NewLazySeq, []any{v4}) - return v5 + tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) + return tmp5 case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - var v5 lang.FnFunc - v5 = lang.NewFnFunc(func(args ...any) any { + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - var v6 any + var tmp6 any { // let // let binding "s1" - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("seq")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v9, []any{v3}) - var v11 any = v10 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("seq")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp9, []any{v3}) + var v11 any = tmp10 _ = v11 // let binding "s2" - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("seq")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.Apply(v14, []any{v4}) - var v16 any = v15 + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("seq")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.Apply(tmp14, []any{v4}) + var v16 any = tmp15 _ = v16 - var v17 any - var v18 any + var tmp17 any + var tmp18 any { // let // let binding "and__0__auto__" var v19 any = v11 _ = v19 - var v20 any + var tmp20 any if lang.IsTruthy(v19) { - v20 = v16 + tmp20 = v16 } else { - v20 = v19 + tmp20 = v19 } - v18 = v20 + tmp18 = tmp20 } // end let - if lang.IsTruthy(v18) { - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("cons")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("first")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v11}) - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("cons")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) - } - v28 := v27.Get() - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("first")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.Apply(v31, []any{v16}) - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("interleave")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("rest")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.Apply(v38, []any{v11}) - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("rest")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) - } - v42 := v41.Get() - v43 := lang.Apply(v42, []any{v16}) - v44 := lang.Apply(v35, []any{v39, v43}) - v45 := lang.Apply(v28, []any{v32, v44}) - v46 := lang.Apply(v21, []any{v25, v45}) - v17 = v46 + if lang.IsTruthy(tmp18) { + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("cons")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("first")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("cons")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) + } + tmp28 := tmp27.Get() + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("first")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.Apply(tmp31, []any{v16}) + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("interleave")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) + } + tmp35 := tmp34.Get() + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("rest")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{v11}) + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("rest")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) + } + tmp42 := tmp41.Get() + tmp43 := lang.Apply(tmp42, []any{v16}) + tmp44 := lang.Apply(tmp35, []any{tmp39, tmp43}) + tmp45 := lang.Apply(tmp28, []any{tmp32, tmp44}) + tmp46 := lang.Apply(tmp21, []any{tmp25, tmp45}) + tmp17 = tmp46 } else { - v17 = nil } - v6 = v17 + tmp6 = tmp17 } // end let - return v6 + return tmp6 }) - v6 := lang.Apply(lang.NewLazySeq, []any{v5}) - return v6 + tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) + return tmp6 default: if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -43211,169 +43322,168 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.NewList(args[2:]...) - var v6 lang.FnFunc - v6 = lang.NewFnFunc(func(args ...any) any { + var v5 any = lang.NewList(args[2:]...) + _ = v5 + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - var v7 any + var tmp7 any { // let // let binding "ss" - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("map")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("seq")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("conj")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{v5, v4, v3}) - v18 := lang.Apply(v10, []any{v13, v17}) - var v19 any = v18 + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("map")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("seq")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("conj")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{v5, v4, v3}) + tmp18 := lang.Apply(tmp10, []any{tmp13, tmp17}) + var v19 any = tmp18 _ = v19 - var v20 any - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("every?")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("identity")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.Apply(v23, []any{v26, v19}) - if lang.IsTruthy(v27) { - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("concat")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("map")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("first")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) - } - v36 := v35.Get() - v37 := lang.Apply(v33, []any{v36, v19}) - v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v39 := v38.FindInternedVar(lang.NewSymbol("apply")) - if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) - } - v40 := v39.Get() - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("interleave")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) - } - v43 := v42.Get() - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("map")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) - } - v46 := v45.Get() - v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v48 := v47.FindInternedVar(lang.NewSymbol("rest")) - if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) - } - v49 := v48.Get() - v50 := lang.Apply(v46, []any{v49, v19}) - v51 := lang.Apply(v40, []any{v43, v50}) - v52 := lang.Apply(v30, []any{v37, v51}) - v20 = v52 + var tmp20 any + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("every?")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("identity")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.Apply(tmp23, []any{tmp26, v19}) + if lang.IsTruthy(tmp27) { + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("concat")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("map")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("first")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.Apply(tmp33, []any{tmp36, v19}) + tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp39 := tmp38.FindInternedVar(lang.NewSymbol("apply")) + if tmp39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) + } + tmp40 := tmp39.Get() + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("interleave")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("map")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) + } + tmp46 := tmp45.Get() + tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp48 := tmp47.FindInternedVar(lang.NewSymbol("rest")) + if tmp48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) + } + tmp49 := tmp48.Get() + tmp50 := lang.Apply(tmp46, []any{tmp49, v19}) + tmp51 := lang.Apply(tmp40, []any{tmp43, tmp50}) + tmp52 := lang.Apply(tmp30, []any{tmp37, tmp51}) + tmp20 = tmp52 } else { - v20 = nil } - v7 = v20 + tmp7 = tmp20 } // end let - return v7 + return tmp7 }) - v7 := lang.Apply(lang.NewLazySeq, []any{v6}) - return v7 + tmp7 := lang.Apply(lang.NewLazySeq, []any{tmp6}) + return tmp7 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // intern { - v0 := lang.NewSymbol("intern").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name"), lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Finds or creates a var named by the symbol name in the namespace\n ns (which can be a symbol or a namespace), setting its root binding\n to val if supplied. The namespace must exist. The var will adopt any\n metadata from the name symbol. Returns the var.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6311), lang.NewKeyword("end-line"), int(6311))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("intern").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name"), lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Finds or creates a var named by the symbol name in the namespace\n ns (which can be a symbol or a namespace), setting its root binding\n to val if supplied. The namespace must exist. The var will adopt any\n metadata from the name symbol. Returns the var.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6311), lang.NewKeyword("end-line"), int(6311))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - var v5 any + var tmp5 any { // let // let binding "v" - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("the-ns")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{v3}) - v10 := lang.Apply(nil, []any{v9, v4}) - var v11 any = v10 + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("the-ns")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.Apply(tmp8, []any{v3}) + tmp10 := lang.Apply(nil, []any{tmp9, v4}) + var v11 any = tmp10 _ = v11 - var v12 any - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("meta")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{v4}) - if lang.IsTruthy(v16) { - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("meta")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.Apply(v19, []any{v4}) - v21, _ := lang.FieldOrMethod(v11, "setMeta") - if reflect.TypeOf(v21).Kind() != reflect.Func { + var tmp12 any + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("meta")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{v4}) + if lang.IsTruthy(tmp16) { + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("meta")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.Apply(tmp19, []any{v4}) + tmp21, _ := lang.FieldOrMethod(v11, "setMeta") + if reflect.TypeOf(tmp21).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMeta is not a function"))) } - v22 := lang.Apply(v21, []any{v20}) - v12 = v22 + tmp22 := lang.Apply(tmp21, []any{tmp20}) + tmp12 = tmp22 } else { - v12 = nil } - _ = v12 - v5 = v11 + _ = tmp12 + tmp5 = v11 } // end let - return v5 + return tmp5 case 3: v3 := args[0] _ = v3 @@ -43381,217 +43491,216 @@ func init() { _ = v4 v5 := args[2] _ = v5 - var v6 any + var tmp6 any { // let // let binding "v" - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("the-ns")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v9, []any{v3}) - v11 := lang.Apply(nil, []any{v10, v4, v5}) - var v12 any = v11 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("the-ns")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp9, []any{v3}) + tmp11 := lang.Apply(nil, []any{tmp10, v4, v5}) + var v12 any = tmp11 _ = v12 - var v13 any - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("meta")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{v4}) - if lang.IsTruthy(v17) { - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("meta")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.Apply(v20, []any{v4}) - v22, _ := lang.FieldOrMethod(v12, "setMeta") - if reflect.TypeOf(v22).Kind() != reflect.Func { + var tmp13 any + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("meta")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{v4}) + if lang.IsTruthy(tmp17) { + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("meta")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.Apply(tmp20, []any{v4}) + tmp22, _ := lang.FieldOrMethod(v12, "setMeta") + if reflect.TypeOf(tmp22).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMeta is not a function"))) } - v23 := lang.Apply(v22, []any{v21}) - v13 = v23 + tmp23 := lang.Apply(tmp22, []any{tmp21}) + tmp13 = tmp23 } else { - v13 = nil } - _ = v13 - v6 = v12 + _ = tmp13 + tmp6 = v12 } // end let - return v6 + return tmp6 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // interpose { - v0 := lang.NewSymbol("interpose").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sep")), lang.NewVector(lang.NewSymbol("sep"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy seq of the elements of coll separated by sep.\n Returns a stateful transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5230), lang.NewKeyword("end-line"), int(5230))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("interpose").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sep")), lang.NewVector(lang.NewSymbol("sep"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy seq of the elements of coll separated by sep.\n Returns a stateful transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5230), lang.NewKeyword("end-line"), int(5230))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - var v4 lang.FnFunc - v4 = lang.NewFnFunc(func(args ...any) any { + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v5 := args[0] _ = v5 - var v6 any + var tmp6 any { // let // let binding "started" - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("volatile!")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v9, []any{false}) - var v11 any = v10 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("volatile!")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp9, []any{false}) + var v11 any = tmp10 _ = v11 - var v12 lang.FnFunc - v12 = lang.NewFnFunc(func(args ...any) any { + var tmp12 lang.FnFunc + tmp12 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - v13 := lang.Apply(v5, nil) - return v13 + tmp13 := lang.Apply(v5, nil) + return tmp13 case 1: v13 := args[0] _ = v13 - v14 := lang.Apply(v5, []any{v13}) - return v14 + tmp14 := lang.Apply(v5, []any{v13}) + return tmp14 case 2: v13 := args[0] _ = v13 v14 := args[1] _ = v14 - var v15 any - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("deref")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + var tmp15 any + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("deref")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{v11}) - if lang.IsTruthy(v19) { - var v20 any + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{v11}) + if lang.IsTruthy(tmp19) { + var tmp20 any { // let // let binding "sepr" - v21 := lang.Apply(v5, []any{v13, v3}) - var v22 any = v21 + tmp21 := lang.Apply(v5, []any{v13, v3}) + var v22 any = tmp21 _ = v22 - var v23 any - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("reduced?")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + var tmp23 any + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("reduced?")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) } - v26 := v25.Get() - v27 := lang.Apply(v26, []any{v22}) - if lang.IsTruthy(v27) { - v23 = v22 + tmp26 := tmp25.Get() + tmp27 := lang.Apply(tmp26, []any{v22}) + if lang.IsTruthy(tmp27) { + tmp23 = v22 } else { - v28 := lang.Apply(v5, []any{v22, v14}) - v23 = v28 + tmp28 := lang.Apply(v5, []any{v22, v14}) + tmp23 = tmp28 } - v20 = v23 + tmp20 = tmp23 } // end let - v15 = v20 + tmp15 = tmp20 } else { - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("vreset!")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("vreset!")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) } - v23 := v22.Get() - v24 := lang.Apply(v23, []any{v11, true}) - _ = v24 - v25 := lang.Apply(v5, []any{v13, v14}) - v15 = v25 + tmp23 := tmp22.Get() + tmp24 := lang.Apply(tmp23, []any{v11, true}) + _ = tmp24 + tmp25 := lang.Apply(v5, []any{v13, v14}) + tmp15 = tmp25 } - return v15 + return tmp15 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5238), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(5249), lang.NewKeyword("end-column"), int(35)) - v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) + tmp13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5238), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(5249), lang.NewKeyword("end-column"), int(35)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) if err != nil { panic(err) } - v6 = v14 + tmp6 = tmp14 } // end let - return v6 + return tmp6 }) - v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5236), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(5249), lang.NewKeyword("end-column"), int(37)) - v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) + tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5236), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(5249), lang.NewKeyword("end-column"), int(37)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) if err != nil { panic(err) } - return v6 + return tmp6 case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("drop")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("interleave")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("repeat")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{v3}) - v15 := lang.Apply(v10, []any{v14, v4}) - v16 := lang.Apply(v7, []any{int64(1), v15}) - return v16 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("drop")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("interleave")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("repeat")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{v3}) + tmp15 := lang.Apply(tmp10, []any{tmp14, v4}) + tmp16 := lang.Apply(tmp7, []any{int64(1), tmp15}) + return tmp16 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // into { - v0 := lang.NewSymbol("into").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("to")), lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("from")), lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("xform"), lang.NewSymbol("from"))), lang.NewKeyword("doc"), "Returns a new coll consisting of to with all of the items of\n from conjoined. A transducer may be supplied.\n (into x) returns x. (into) returns [].", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6922), lang.NewKeyword("end-line"), int(6922))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("into").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("to")), lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("from")), lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("xform"), lang.NewSymbol("from"))), lang.NewKeyword("doc"), "Returns a new coll consisting of to with all of the items of\n from conjoined. A transducer may be supplied.\n (into x) returns x. (into) returns [].", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6922), lang.NewKeyword("end-line"), int(6922))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - v3 := lang.NewVector() - v4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6928), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(6928), lang.NewKeyword("end-column"), int(8)) - v5, err := lang.WithMeta(v3, v4.(lang.IPersistentMap)) + tmp3 := lang.NewVector() + tmp4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6928), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(6928), lang.NewKeyword("end-column"), int(8)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) if err != nil { panic(err) } - return v5 + return tmp5 case 1: v3 := args[0] _ = v3 @@ -43601,74 +43710,75 @@ func init() { _ = v3 v4 := args[1] _ = v4 - var v5 any - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{lang.IEditableCollection, v3}) - if lang.IsTruthy(v9) { - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("with-meta")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("persistent!")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("reduce")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("conj!")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("transient")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v3}) - v26 := lang.Apply(v18, []any{v21, v25, v4}) - v27 := lang.Apply(v15, []any{v26}) - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("meta")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.Apply(v30, []any{v3}) - v32 := lang.Apply(v12, []any{v27, v31}) - v5 = v32 + var tmp5 any + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("instance?")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := reflect.TypeOf((*lang.IEditableCollection)(nil)).Elem() + tmp10 := lang.Apply(tmp8, []any{tmp9, v3}) + if lang.IsTruthy(tmp10) { + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("with-meta")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("persistent!")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("reduce")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("conj!")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("transient")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.Apply(tmp25, []any{v3}) + tmp27 := lang.Apply(tmp19, []any{tmp22, tmp26, v4}) + tmp28 := lang.Apply(tmp16, []any{tmp27}) + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("meta")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.Apply(tmp31, []any{v3}) + tmp33 := lang.Apply(tmp13, []any{tmp28, tmp32}) + tmp5 = tmp33 } else { - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("reduce")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("conj")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.Apply(v35, []any{v38, v3, v4}) - v5 = v39 - } - return v5 + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("reduce")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("conj")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.Apply(tmp36, []any{tmp39, v3, v4}) + tmp5 = tmp40 + } + return tmp5 case 3: v3 := args[0] _ = v3 @@ -43676,164 +43786,165 @@ func init() { _ = v4 v5 := args[2] _ = v5 - var v6 any - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("instance?")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v9, []any{lang.IEditableCollection, v3}) - if lang.IsTruthy(v10) { - var v11 any + var tmp6 any + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("instance?")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := reflect.TypeOf((*lang.IEditableCollection)(nil)).Elem() + tmp11 := lang.Apply(tmp9, []any{tmp10, v3}) + if lang.IsTruthy(tmp11) { + var tmp12 any { // let // let binding "tm" - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("meta")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.Apply(v14, []any{v3}) - var v16 any = v15 - _ = v16 + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("meta")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{v3}) + var v17 any = tmp16 + _ = v17 // let binding "rf" - var v17 lang.FnFunc - v17 = lang.NewFnFunc(func(args ...any) any { + var tmp18 lang.FnFunc + tmp18 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: - v18 := args[0] - _ = v18 - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("with-meta")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + v19 := args[0] + _ = v19 + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("with-meta")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) } - v21 := v20.Get() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("persistent!")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + tmp22 := tmp21.Get() + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("persistent!")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v18}) - v26 := lang.Apply(v21, []any{v25, v16}) - return v26 + tmp25 := tmp24.Get() + tmp26 := lang.Apply(tmp25, []any{v19}) + tmp27 := lang.Apply(tmp22, []any{tmp26, v17}) + return tmp27 case 2: - v18 := args[0] - _ = v18 - v19 := args[1] + v19 := args[0] _ = v19 - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("conj!")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + v20 := args[1] + _ = v20 + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("conj!")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) } - v22 := v21.Get() - v23 := lang.Apply(v22, []any{v18, v19}) - return v23 + tmp23 := tmp22.Get() + tmp24 := lang.Apply(tmp23, []any{v19, v20}) + return tmp24 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6937), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(6939), lang.NewKeyword("end-column"), int(44)) - v19, err := lang.WithMeta(v17, v18.(lang.IPersistentMap)) + tmp19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6937), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(6939), lang.NewKeyword("end-column"), int(44)) + tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) if err != nil { panic(err) } - var v20 any = v19 - _ = v20 - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("transduce")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("transient")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.Apply(v26, []any{v3}) - v28 := lang.Apply(v23, []any{v4, v20, v27, v5}) - v11 = v28 + var v21 any = tmp20 + _ = v21 + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("transduce")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("transient")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.Apply(tmp27, []any{v3}) + tmp29 := lang.Apply(tmp24, []any{v4, v21, tmp28, v5}) + tmp12 = tmp29 } // end let - v6 = v11 + tmp6 = tmp12 } else { - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("transduce")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("conj")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v14, []any{v4, v17, v3, v5}) - v6 = v18 - } - return v6 + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("transduce")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("conj")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp15, []any{v4, tmp18, v3, v5}) + tmp6 = tmp19 + } + return tmp6 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // into-array { - v0 := lang.NewSymbol("into-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("aseq")), lang.NewVector(lang.NewSymbol("type"), lang.NewSymbol("aseq"))), lang.NewKeyword("doc"), "Returns an array with components set to the values in aseq. The array's\n component type is type if provided, or the type of the first value in\n aseq if present, or Object. All values in aseq must be compatible with\n the component type. Class objects for the primitive types can be obtained\n using, e.g., Integer/TYPE.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3444), lang.NewKeyword("end-line"), int(3444))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("into-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("aseq")), lang.NewVector(lang.NewSymbol("type"), lang.NewSymbol("aseq"))), lang.NewKeyword("doc"), "Returns an array with components set to the values in aseq. The array's\n component type is type if provided, or the type of the first value in\n aseq if present, or Object. All values in aseq must be compatible with\n the component type. Class objects for the primitive types can be obtained\n using, e.g., Integer/TYPE.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3444), lang.NewKeyword("end-line"), int(3444))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.Apply(v6, []any{v3}) - v8 := lang.Apply(nil, []any{v7}) - return v8 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.Apply(tmp6, []any{v3}) + tmp8 := lang.Apply(nil, []any{tmp7}) + return tmp8 case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("seq")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v4}) - v9 := lang.Apply(nil, []any{v3, v8}) - return v9 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v4}) + tmp9 := lang.Apply(nil, []any{v3, tmp8}) + return tmp9 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // into1 { - v0 := lang.NewSymbol("into1").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("from"))), lang.NewKeyword("doc"), "Returns a new coll consisting of to-coll with all of the items of\n from-coll conjoined.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3416), lang.NewKeyword("end-line"), int(3416), lang.NewKeyword("private"), true)).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("into1").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("from"))), lang.NewKeyword("doc"), "Returns a new coll consisting of to-coll with all of the items of\n from-coll conjoined.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3416), lang.NewKeyword("end-line"), int(3416), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -43841,150 +43952,152 @@ func init() { _ = v3 v4 := args[1] _ = v4 - var v5 any - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{lang.IEditableCollection, v3}) - if lang.IsTruthy(v9) { - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("persistent!")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("reduce1")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("conj!")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("transient")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{v3}) - v23 := lang.Apply(v15, []any{v18, v22, v4}) - v24 := lang.Apply(v12, []any{v23}) - v5 = v24 + var tmp5 any + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("instance?")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := reflect.TypeOf((*lang.IEditableCollection)(nil)).Elem() + tmp10 := lang.Apply(tmp8, []any{tmp9, v3}) + if lang.IsTruthy(tmp10) { + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("persistent!")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("conj!")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("transient")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.Apply(tmp22, []any{v3}) + tmp24 := lang.Apply(tmp16, []any{tmp19, tmp23, v4}) + tmp25 := lang.Apply(tmp13, []any{tmp24}) + tmp5 = tmp25 } else { - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("reduce1")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) } - v27 := v26.Get() - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("conj")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + tmp28 := tmp27.Get() + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("conj")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) } - v30 := v29.Get() - v31 := lang.Apply(v27, []any{v30, v3, v4}) - v5 = v31 + tmp31 := tmp30.Get() + tmp32 := lang.Apply(tmp28, []any{tmp31, v3, v4}) + tmp5 = tmp32 } - return v5 + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // ints { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function ints - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("concat")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("list")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/Ints")}) - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("list")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v3}) - v26 := lang.Apply(v9, []any{v13, v17, v21, v25}) - v27 := lang.Apply(v6, []any{v26}) - return v27 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.Apply(tmp20, []any{lang.NewSymbol("glojure.core/Ints")}) + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("list")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.Apply(tmp24, []any{v3}) + tmp26 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp21, tmp25}) + tmp27 := lang.Apply(tmp6, []any{tmp26}) + return tmp27 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("ints").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Casts to int[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5397), lang.NewKeyword("end-line"), int(5397))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("ints").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Casts to int[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5397), lang.NewKeyword("end-line"), int(5397))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5, _ := lang.FieldOrMethod(lang.Numbers, "Ints") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Ints") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Ints is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // io! { - v0 := lang.NewSymbol("io!").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "If an io! block occurs in a transaction, throws an\n IllegalStateException, else runs body in an implicit do. If the\n first expression in body is a literal string, will use that as the\n exception message.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(2504), lang.NewKeyword("end-line"), int(2504))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("io!").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "If an io! block occurs in a transaction, throws an\n IllegalStateException, else runs body in an implicit do. If the\n first expression in body is a literal string, will use that as the\n exception message.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(2504), lang.NewKeyword("end-line"), int(2504))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 2 { @@ -43994,251 +44107,251 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.NewList(args[2:]...) - var v6 any + var v5 any = lang.NewList(args[2:]...) + _ = v5 + var tmp6 any { // let // let binding "message" - var v7 any - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("string?")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("first")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{v5}) - v15 := lang.Apply(v10, []any{v14}) - if lang.IsTruthy(v15) { - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("first")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{v5}) - v7 = v19 + var tmp7 any + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("string?")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("first")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{v5}) + tmp15 := lang.Apply(tmp10, []any{tmp14}) + if lang.IsTruthy(tmp15) { + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("first")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{v5}) + tmp7 = tmp19 } else { - v7 = nil } - var v20 any = v7 + var v20 any = tmp7 _ = v20 // let binding "body" - var v21 any + var tmp21 any if lang.IsTruthy(v20) { - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("next")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v5}) - v21 = v25 + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("next")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.Apply(tmp24, []any{v5}) + tmp21 = tmp25 } else { - v21 = v5 + tmp21 = v5 } - var v26 any = v21 + var v26 any = tmp21 _ = v26 - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("seq")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("concat")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) - } - v32 := v31.Get() - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("list")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - v36 := lang.Apply(v35, []any{lang.NewSymbol("if")}) - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("list")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("seq")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) - } - v42 := v41.Get() - v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v44 := v43.FindInternedVar(lang.NewSymbol("concat")) - if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) - } - v45 := v44.Get() - v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v47 := v46.FindInternedVar(lang.NewSymbol("list")) - if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) - } - v48 := v47.Get() - v49 := lang.Apply(v48, []any{lang.NewSymbol("glojure.lang.LockingTransaction/isRunning")}) - v50 := lang.Apply(v45, []any{v49}) - v51 := lang.Apply(v42, []any{v50}) - v52 := lang.Apply(v39, []any{v51}) - v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v54 := v53.FindInternedVar(lang.NewSymbol("list")) - if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) - } - v55 := v54.Get() - v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v57 := v56.FindInternedVar(lang.NewSymbol("seq")) - if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) - } - v58 := v57.Get() - v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v60 := v59.FindInternedVar(lang.NewSymbol("concat")) - if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) - } - v61 := v60.Get() - v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v63 := v62.FindInternedVar(lang.NewSymbol("list")) - if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) - } - v64 := v63.Get() - v65 := lang.Apply(v64, []any{lang.NewSymbol("throw")}) - v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v67 := v66.FindInternedVar(lang.NewSymbol("list")) - if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) - } - v68 := v67.Get() - v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v70 := v69.FindInternedVar(lang.NewSymbol("seq")) - if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) - } - v71 := v70.Get() - v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v73 := v72.FindInternedVar(lang.NewSymbol("concat")) - if v73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) - } - v74 := v73.Get() - v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v76 := v75.FindInternedVar(lang.NewSymbol("list")) - if v76.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) - } - v77 := v76.Get() - v78 := lang.Apply(v77, []any{lang.NewSymbol("new")}) - v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v80 := v79.FindInternedVar(lang.NewSymbol("list")) - if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) - } - v81 := v80.Get() - v82 := lang.Apply(v81, []any{lang.NewSymbol("glojure.core/IllegalStateException")}) - v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v84 := v83.FindInternedVar(lang.NewSymbol("list")) - if v84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) - } - v85 := v84.Get() - var v86 any + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("seq")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("concat")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) + } + tmp32 := tmp31.Get() + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("list")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) + } + tmp35 := tmp34.Get() + tmp36 := lang.Apply(tmp35, []any{lang.NewSymbol("if")}) + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("list")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("seq")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) + } + tmp42 := tmp41.Get() + tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp44 := tmp43.FindInternedVar(lang.NewSymbol("concat")) + if tmp44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) + } + tmp45 := tmp44.Get() + tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp47 := tmp46.FindInternedVar(lang.NewSymbol("list")) + if tmp47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) + } + tmp48 := tmp47.Get() + tmp49 := lang.Apply(tmp48, []any{lang.NewSymbol("glojure.lang.LockingTransaction/isRunning")}) + tmp50 := lang.Apply(tmp45, []any{tmp49}) + tmp51 := lang.Apply(tmp42, []any{tmp50}) + tmp52 := lang.Apply(tmp39, []any{tmp51}) + tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp54 := tmp53.FindInternedVar(lang.NewSymbol("list")) + if tmp54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) + } + tmp55 := tmp54.Get() + tmp56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp57 := tmp56.FindInternedVar(lang.NewSymbol("seq")) + if tmp57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp57))) + } + tmp58 := tmp57.Get() + tmp59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp60 := tmp59.FindInternedVar(lang.NewSymbol("concat")) + if tmp60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp60))) + } + tmp61 := tmp60.Get() + tmp62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp63 := tmp62.FindInternedVar(lang.NewSymbol("list")) + if tmp63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp63))) + } + tmp64 := tmp63.Get() + tmp65 := lang.Apply(tmp64, []any{lang.NewSymbol("throw")}) + tmp66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp67 := tmp66.FindInternedVar(lang.NewSymbol("list")) + if tmp67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp67))) + } + tmp68 := tmp67.Get() + tmp69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp70 := tmp69.FindInternedVar(lang.NewSymbol("seq")) + if tmp70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp70))) + } + tmp71 := tmp70.Get() + tmp72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp73 := tmp72.FindInternedVar(lang.NewSymbol("concat")) + if tmp73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp73))) + } + tmp74 := tmp73.Get() + tmp75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp76 := tmp75.FindInternedVar(lang.NewSymbol("list")) + if tmp76.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp76))) + } + tmp77 := tmp76.Get() + tmp78 := lang.Apply(tmp77, []any{lang.NewSymbol("new")}) + tmp79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp80 := tmp79.FindInternedVar(lang.NewSymbol("list")) + if tmp80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp80))) + } + tmp81 := tmp80.Get() + tmp82 := lang.Apply(tmp81, []any{lang.NewSymbol("glojure.core/IllegalStateException")}) + tmp83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp84 := tmp83.FindInternedVar(lang.NewSymbol("list")) + if tmp84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp84))) + } + tmp85 := tmp84.Get() + var tmp86 any { // let // let binding "or__0__auto__" var v87 any = v20 _ = v87 - var v88 any + var tmp88 any if lang.IsTruthy(v87) { - v88 = v87 + tmp88 = v87 } else { - v88 = "I/O in transaction" + tmp88 = "I/O in transaction" } - v86 = v88 + tmp86 = tmp88 } // end let - v87 := lang.Apply(v85, []any{v86}) - v88 := lang.Apply(v74, []any{v78, v82, v87}) - v89 := lang.Apply(v71, []any{v88}) - v90 := lang.Apply(v68, []any{v89}) - v91 := lang.Apply(v61, []any{v65, v90}) - v92 := lang.Apply(v58, []any{v91}) - v93 := lang.Apply(v55, []any{v92}) - v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v95 := v94.FindInternedVar(lang.NewSymbol("list")) - if v95.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) - } - v96 := v95.Get() - v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v98 := v97.FindInternedVar(lang.NewSymbol("seq")) - if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) - } - v99 := v98.Get() - v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v101 := v100.FindInternedVar(lang.NewSymbol("concat")) - if v101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) - } - v102 := v101.Get() - v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v104 := v103.FindInternedVar(lang.NewSymbol("list")) - if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) - } - v105 := v104.Get() - v106 := lang.Apply(v105, []any{lang.NewSymbol("do")}) - v107 := lang.Apply(v102, []any{v106, v26}) - v108 := lang.Apply(v99, []any{v107}) - v109 := lang.Apply(v96, []any{v108}) - v110 := lang.Apply(v32, []any{v36, v52, v93, v109}) - v111 := lang.Apply(v29, []any{v110}) - v6 = v111 + tmp87 := lang.Apply(tmp85, []any{tmp86}) + tmp88 := lang.Apply(tmp74, []any{tmp78, tmp82, tmp87}) + tmp89 := lang.Apply(tmp71, []any{tmp88}) + tmp90 := lang.Apply(tmp68, []any{tmp89}) + tmp91 := lang.Apply(tmp61, []any{tmp65, tmp90}) + tmp92 := lang.Apply(tmp58, []any{tmp91}) + tmp93 := lang.Apply(tmp55, []any{tmp92}) + tmp94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp95 := tmp94.FindInternedVar(lang.NewSymbol("list")) + if tmp95.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp95))) + } + tmp96 := tmp95.Get() + tmp97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp98 := tmp97.FindInternedVar(lang.NewSymbol("seq")) + if tmp98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp98))) + } + tmp99 := tmp98.Get() + tmp100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp101 := tmp100.FindInternedVar(lang.NewSymbol("concat")) + if tmp101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp101))) + } + tmp102 := tmp101.Get() + tmp103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp104 := tmp103.FindInternedVar(lang.NewSymbol("list")) + if tmp104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp104))) + } + tmp105 := tmp104.Get() + tmp106 := lang.Apply(tmp105, []any{lang.NewSymbol("do")}) + tmp107 := lang.Apply(tmp102, []any{tmp106, v26}) + tmp108 := lang.Apply(tmp99, []any{tmp107}) + tmp109 := lang.Apply(tmp96, []any{tmp108}) + tmp110 := lang.Apply(tmp32, []any{tmp36, tmp52, tmp93, tmp109}) + tmp111 := lang.Apply(tmp29, []any{tmp110}) + tmp6 = tmp111 } // end let - return v6 + return tmp6 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // isa? { - v0 := lang.NewSymbol("isa?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("child"), lang.NewSymbol("parent")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("child"), lang.NewSymbol("parent"))), lang.NewKeyword("doc"), "Returns true if (= child parent), or child is directly or indirectly derived from\n parent, either via a Java type inheritance relationship or a\n relationship established via derive. h must be a hierarchy obtained\n from make-hierarchy, if not supplied defaults to the global\n hierarchy", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5543), lang.NewKeyword("end-line"), int(5543))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("isa?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("child"), lang.NewSymbol("parent")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("child"), lang.NewSymbol("parent"))), lang.NewKeyword("doc"), "Returns true if (= child parent), or child is directly or indirectly derived from\n parent, either via a Java type inheritance relationship or a\n relationship established via derive. h must be a hierarchy obtained\n from make-hierarchy, if not supplied defaults to the global\n hierarchy", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5543), lang.NewKeyword("end-line"), int(5543))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("isa?")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("global-hierarchy")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v7, []any{v10, v3, v4}) - return v11 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("isa?")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("global-hierarchy")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp7, []any{tmp10, v3, v4}) + return tmp11 case 3: v3 := args[0] _ = v3 @@ -44246,217 +44359,217 @@ func init() { _ = v4 v5 := args[2] _ = v5 - var v6 any + var tmp6 any { // let // let binding "or__0__auto__" - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("=")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v9, []any{v4, v5}) - var v11 any = v10 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("=")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + var v11 any = tmp10 _ = v11 - var v12 any + var tmp12 any if lang.IsTruthy(v11) { - v12 = v11 + tmp12 = v11 } else { - var v13 any + var tmp13 any { // let // let binding "or__0__auto__" - var v14 any + var tmp14 any { // let // let binding "and__0__auto__" - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("class?")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("class?")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{v5}) - var v19 any = v18 + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{v5}) + var v19 any = tmp18 _ = v19 - var v20 any + var tmp20 any if lang.IsTruthy(v19) { - var v21 any + var tmp21 any { // let // let binding "and__0__auto__" - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("class?")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("class?")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v4}) - var v26 any = v25 + tmp24 := tmp23.Get() + tmp25 := lang.Apply(tmp24, []any{v4}) + var v26 any = tmp25 _ = v26 - var v27 any + var tmp27 any if lang.IsTruthy(v26) { - v28, _ := lang.FieldOrMethod(v4, "AssignableTo") - if reflect.TypeOf(v28).Kind() != reflect.Func { + tmp28, _ := lang.FieldOrMethod(v4, "AssignableTo") + if reflect.TypeOf(tmp28).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("AssignableTo is not a function"))) } - v29 := lang.Apply(v28, []any{v5}) - v27 = v29 + tmp29 := lang.Apply(tmp28, []any{v5}) + tmp27 = tmp29 } else { - v27 = v26 + tmp27 = v26 } - v21 = v27 + tmp21 = tmp27 } // end let - v20 = v21 + tmp20 = tmp21 } else { - v20 = v19 + tmp20 = v19 } - v14 = v20 + tmp14 = tmp20 } // end let - var v15 any = v14 + var v15 any = tmp14 _ = v15 - var v16 any + var tmp16 any if lang.IsTruthy(v15) { - v16 = v15 + tmp16 = v15 } else { - var v17 any + var tmp17 any { // let // let binding "or__0__auto__" - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("contains?")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("contains?")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) } - v20 := v19.Get() - v21 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) - v22 := lang.Apply(v21, []any{v4}) - v23 := lang.Apply(v20, []any{v22, v5}) - var v24 any = v23 + tmp20 := tmp19.Get() + tmp21 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) + tmp22 := lang.Apply(tmp21, []any{v4}) + tmp23 := lang.Apply(tmp20, []any{tmp22, v5}) + var v24 any = tmp23 _ = v24 - var v25 any + var tmp25 any if lang.IsTruthy(v24) { - v25 = v24 + tmp25 = v24 } else { - var v26 any + var tmp26 any { // let // let binding "or__0__auto__" - var v27 any + var tmp27 any { // let // let binding "and__0__auto__" - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("class?")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("class?")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) } - v30 := v29.Get() - v31 := lang.Apply(v30, []any{v4}) - var v32 any = v31 + tmp30 := tmp29.Get() + tmp31 := lang.Apply(tmp30, []any{v4}) + var v32 any = tmp31 _ = v32 - var v33 any + var tmp33 any if lang.IsTruthy(v32) { - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("some")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("some")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) } - v36 := v35.Get() - var v37 lang.FnFunc - v37 = lang.NewFnFunc(func(args ...any) any { + tmp36 := tmp35.Get() + var tmp37 lang.FnFunc + tmp37 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v38 := args[0] _ = v38 - v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v40 := v39.FindInternedVar(lang.NewSymbol("contains?")) - if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) + tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp40 := tmp39.FindInternedVar(lang.NewSymbol("contains?")) + if tmp40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) } - v41 := v40.Get() - v42 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) - v43 := lang.Apply(v42, []any{v38}) - v44 := lang.Apply(v41, []any{v43, v5}) - return v44 + tmp41 := tmp40.Get() + tmp42 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) + tmp43 := lang.Apply(tmp42, []any{v38}) + tmp44 := lang.Apply(tmp41, []any{tmp43, v5}) + return tmp44 }) - v38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5556), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(5556), lang.NewKeyword("end-column"), int(71)) - v39, err := lang.WithMeta(v37, v38.(lang.IPersistentMap)) + tmp38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5556), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(5556), lang.NewKeyword("end-column"), int(71)) + tmp39, err := lang.WithMeta(tmp37, tmp38.(lang.IPersistentMap)) if err != nil { panic(err) } - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("supers")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("supers")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) } - v42 := v41.Get() - v43 := lang.Apply(v42, []any{v4}) - v44 := lang.Apply(v36, []any{v39, v43}) - v33 = v44 + tmp42 := tmp41.Get() + tmp43 := lang.Apply(tmp42, []any{v4}) + tmp44 := lang.Apply(tmp36, []any{tmp39, tmp43}) + tmp33 = tmp44 } else { - v33 = v32 + tmp33 = v32 } - v27 = v33 + tmp27 = tmp33 } // end let - var v28 any = v27 + var v28 any = tmp27 _ = v28 - var v29 any + var tmp29 any if lang.IsTruthy(v28) { - v29 = v28 + tmp29 = v28 } else { - var v30 any + var tmp30 any { // let // let binding "and__0__auto__" - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("vector?")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("vector?")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{v5}) - var v35 any = v34 + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{v5}) + var v35 any = tmp34 _ = v35 - var v36 any + var tmp36 any if lang.IsTruthy(v35) { - var v37 any + var tmp37 any { // let // let binding "and__0__auto__" - v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v39 := v38.FindInternedVar(lang.NewSymbol("vector?")) - if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp39 := tmp38.FindInternedVar(lang.NewSymbol("vector?")) + if tmp39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) } - v40 := v39.Get() - v41 := lang.Apply(v40, []any{v4}) - var v42 any = v41 + tmp40 := tmp39.Get() + tmp41 := lang.Apply(tmp40, []any{v4}) + var v42 any = tmp41 _ = v42 - var v43 any + var tmp43 any if lang.IsTruthy(v42) { - var v44 any + var tmp44 any { // let // let binding "and__0__auto__" - v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v46 := v45.FindInternedVar(lang.NewSymbol("=")) - if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) + tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp46 := tmp45.FindInternedVar(lang.NewSymbol("=")) + if tmp46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) } - v47 := v46.Get() - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("count")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + tmp47 := tmp46.Get() + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("count")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v5}) - v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v53 := v52.FindInternedVar(lang.NewSymbol("count")) - if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v5}) + tmp52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp53 := tmp52.FindInternedVar(lang.NewSymbol("count")) + if tmp53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp53))) } - v54 := v53.Get() - v55 := lang.Apply(v54, []any{v4}) - v56 := lang.Apply(v47, []any{v51, v55}) - var v57 any = v56 + tmp54 := tmp53.Get() + tmp55 := lang.Apply(tmp54, []any{v4}) + tmp56 := lang.Apply(tmp47, []any{tmp51, tmp55}) + var v57 any = tmp56 _ = v57 - var v58 any + var tmp58 any if lang.IsTruthy(v57) { - var v59 any + var tmp59 any { // let // let binding "ret" var v60 any = true @@ -44465,120 +44578,120 @@ func init() { var v61 any = int64(0) _ = v61 for { - var v62 any - var v63 any + var tmp62 any + var tmp63 any { // let // let binding "or__0__auto__" - v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v65 := v64.FindInternedVar(lang.NewSymbol("not")) - if v65.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) + tmp64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp65 := tmp64.FindInternedVar(lang.NewSymbol("not")) + if tmp65.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp65))) } - v66 := v65.Get() - v67 := lang.Apply(v66, []any{v60}) - var v68 any = v67 + tmp66 := tmp65.Get() + tmp67 := lang.Apply(tmp66, []any{v60}) + var v68 any = tmp67 _ = v68 - var v69 any + var tmp69 any if lang.IsTruthy(v68) { - v69 = v68 + tmp69 = v68 } else { - v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v71 := v70.FindInternedVar(lang.NewSymbol("=")) - if v71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) + tmp70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp71 := tmp70.FindInternedVar(lang.NewSymbol("=")) + if tmp71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp71))) } - v72 := v71.Get() - v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v74 := v73.FindInternedVar(lang.NewSymbol("count")) - if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) + tmp72 := tmp71.Get() + tmp73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp74 := tmp73.FindInternedVar(lang.NewSymbol("count")) + if tmp74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp74))) } - v75 := v74.Get() - v76 := lang.Apply(v75, []any{v5}) - v77 := lang.Apply(v72, []any{v61, v76}) - v69 = v77 + tmp75 := tmp74.Get() + tmp76 := lang.Apply(tmp75, []any{v5}) + tmp77 := lang.Apply(tmp72, []any{v61, tmp76}) + tmp69 = tmp77 } - v63 = v69 + tmp63 = tmp69 } // end let - if lang.IsTruthy(v63) { - v62 = v60 + if lang.IsTruthy(tmp63) { + tmp62 = v60 } else { - v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v66 := v65.FindInternedVar(lang.NewSymbol("isa?")) - if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) + tmp65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp66 := tmp65.FindInternedVar(lang.NewSymbol("isa?")) + if tmp66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp66))) } - v67 := v66.Get() - v68 := lang.Apply(v4, []any{v61}) - v69 := lang.Apply(v5, []any{v61}) - v70 := lang.Apply(v67, []any{v3, v68, v69}) - var v64 any = v70 - v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v73 := v72.FindInternedVar(lang.NewSymbol("inc")) - if v73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) + tmp67 := tmp66.Get() + tmp68 := lang.Apply(v4, []any{v61}) + tmp69 := lang.Apply(v5, []any{v61}) + tmp70 := lang.Apply(tmp67, []any{v3, tmp68, tmp69}) + var tmp64 any = tmp70 + tmp72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp73 := tmp72.FindInternedVar(lang.NewSymbol("inc")) + if tmp73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp73))) } - v74 := v73.Get() - v75 := lang.Apply(v74, []any{v61}) - var v71 any = v75 - v60 = v64 - v61 = v71 + tmp74 := tmp73.Get() + tmp75 := lang.Apply(tmp74, []any{v61}) + var tmp71 any = tmp75 + v60 = tmp64 + v61 = tmp71 continue } - v59 = v62 + tmp59 = tmp62 break } } // end let - v58 = v59 + tmp58 = tmp59 } else { - v58 = v57 + tmp58 = v57 } - v44 = v58 + tmp44 = tmp58 } // end let - v43 = v44 + tmp43 = tmp44 } else { - v43 = v42 + tmp43 = v42 } - v37 = v43 + tmp37 = tmp43 } // end let - v36 = v37 + tmp36 = tmp37 } else { - v36 = v35 + tmp36 = v35 } - v30 = v36 + tmp30 = tmp36 } // end let - v29 = v30 + tmp29 = tmp30 } - v26 = v29 + tmp26 = tmp29 } // end let - v25 = v26 + tmp25 = tmp26 } - v17 = v25 + tmp17 = tmp25 } // end let - v16 = v17 + tmp16 = tmp17 } - v13 = v16 + tmp13 = tmp16 } // end let - v12 = v13 + tmp12 = tmp13 } - v6 = v12 + tmp6 = tmp12 } // end let - return v6 + return tmp6 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // iterate { - v0 := lang.NewSymbol("iterate").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns a lazy (infinite!) sequence of x, (f x), (f (f x)) etc.\n f must be free of side-effects", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3011), lang.NewKeyword("end-line"), int(3011))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("iterate").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns a lazy (infinite!) sequence of x, (f x), (f (f x)) etc.\n f must be free of side-effects", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3011), lang.NewKeyword("end-line"), int(3011))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -44586,20 +44699,20 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.Apply(nil, []any{v3, v4}) - return v5 + tmp5 := lang.Apply(nil, []any{v3, v4}) + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // iteration { - v0 := lang.NewSymbol("iteration").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("step"), lang.NewSymbol("&"), lang.NewMap(lang.NewKeyword("keys"), lang.NewVector(lang.NewSymbol("somef"), lang.NewSymbol("vf"), lang.NewSymbol("kf"), lang.NewSymbol("initk")), lang.NewKeyword("or"), lang.NewMap(lang.NewSymbol("vf"), lang.NewSymbol("identity"), lang.NewSymbol("kf"), lang.NewSymbol("identity"), lang.NewSymbol("somef"), lang.NewSymbol("some?"), lang.NewSymbol("initk"), nil)))), lang.NewKeyword("doc"), "Creates a seqable/reducible via repeated calls to step,\n a function of some (continuation token) 'k'. The first call to step\n will be passed initk, returning 'ret'. Iff (somef ret) is true,\n (vf ret) will be included in the iteration, else iteration will\n terminate and vf/kf will not be called. If (kf ret) is non-nil it\n will be passed to the next step call, else iteration will terminate.\n\n This can be used e.g. to consume APIs that return paginated or batched data.\n\n step - (possibly impure) fn of 'k' -> 'ret'\n\n :somef - fn of 'ret' -> logical true/false, default 'some?'\n :vf - fn of 'ret' -> 'v', a value produced by the iteration, default 'identity'\n :kf - fn of 'ret' -> 'next-k' or nil (signaling 'do not continue'), default 'identity'\n :initk - the first value passed to step, default 'nil'\n\n It is presumed that step with non-initk is unreproducible/non-idempotent.\n If step with initk is unreproducible it is on the consumer to not consume twice.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7716), lang.NewKeyword("end-line"), int(7716))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("iteration").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("step"), lang.NewSymbol("&"), lang.NewMap(lang.NewKeyword("keys"), lang.NewVector(lang.NewSymbol("somef"), lang.NewSymbol("vf"), lang.NewSymbol("kf"), lang.NewSymbol("initk")), lang.NewKeyword("or"), lang.NewMap(lang.NewSymbol("vf"), lang.NewSymbol("identity"), lang.NewSymbol("kf"), lang.NewSymbol("identity"), lang.NewSymbol("somef"), lang.NewSymbol("some?"), lang.NewSymbol("initk"), nil)))), lang.NewKeyword("doc"), "Creates a seqable/reducible via repeated calls to step,\n a function of some (continuation token) 'k'. The first call to step\n will be passed initk, returning 'ret'. Iff (somef ret) is true,\n (vf ret) will be included in the iteration, else iteration will\n terminate and vf/kf will not be called. If (kf ret) is non-nil it\n will be passed to the next step call, else iteration will terminate.\n\n This can be used e.g. to consume APIs that return paginated or batched data.\n\n step - (possibly impure) fn of 'k' -> 'ret'\n\n :somef - fn of 'ret' -> logical true/false, default 'some?'\n :vf - fn of 'ret' -> 'v', a value produced by the iteration, default 'identity'\n :kf - fn of 'ret' -> 'next-k' or nil (signaling 'do not continue'), default 'identity'\n :initk - the first value passed to step, default 'nil'\n\n It is presumed that step with non-initk is unreproducible/non-idempotent.\n If step with initk is unreproducible it is on the consumer to not consume twice.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7716), lang.NewKeyword("end-line"), int(7716))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 1 { @@ -44607,385 +44720,385 @@ func init() { } v3 := args[0] _ = v3 - v4 := lang.NewList(args[1:]...) - var v5 any + var v4 any = lang.NewList(args[1:]...) + _ = v4 + var tmp5 any { // let // let binding "map__345" var v6 any = v4 _ = v6 // let binding "map__345" - var v7 any - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("seq?")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v6}) - if lang.IsTruthy(v11) { - var v12 any - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("next")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{v6}) - if lang.IsTruthy(v16) { - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("to-array")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.Apply(v19, []any{v6}) - v21 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{v20}) - v12 = v21 + var tmp7 any + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("seq?")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v6}) + if lang.IsTruthy(tmp11) { + var tmp12 any + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("next")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{v6}) + if lang.IsTruthy(tmp16) { + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("to-array")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.Apply(tmp19, []any{v6}) + tmp21 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{tmp20}) + tmp12 = tmp21 } else { - var v22 any - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("seq")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.Apply(v25, []any{v6}) - if lang.IsTruthy(v26) { - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("first")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + var tmp22 any + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("seq")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.Apply(tmp25, []any{v6}) + if lang.IsTruthy(tmp26) { + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("first")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{v6}) - v22 = v30 + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{v6}) + tmp22 = tmp30 } else { - v22 = nil } - v12 = v22 + tmp12 = tmp22 } - v7 = v12 + tmp7 = tmp12 } else { - v7 = v6 + tmp7 = v6 } - var v31 any = v7 + var v31 any = tmp7 _ = v31 // let binding "somef" - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("get")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v36 := v35.FindInternedVar(lang.NewSymbol("some?")) - if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) - } - v37 := v36.Get() - v38 := lang.Apply(v34, []any{v31, lang.NewKeyword("somef"), v37}) - var v39 any = v38 + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("get")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp36 := tmp35.FindInternedVar(lang.NewSymbol("some?")) + if tmp36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) + } + tmp37 := tmp36.Get() + tmp38 := lang.Apply(tmp34, []any{v31, lang.NewKeyword("somef"), tmp37}) + var v39 any = tmp38 _ = v39 // let binding "vf" - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("get")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) - } - v42 := v41.Get() - v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v44 := v43.FindInternedVar(lang.NewSymbol("identity")) - if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) - } - v45 := v44.Get() - v46 := lang.Apply(v42, []any{v31, lang.NewKeyword("vf"), v45}) - var v47 any = v46 + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("get")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) + } + tmp42 := tmp41.Get() + tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp44 := tmp43.FindInternedVar(lang.NewSymbol("identity")) + if tmp44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) + } + tmp45 := tmp44.Get() + tmp46 := lang.Apply(tmp42, []any{v31, lang.NewKeyword("vf"), tmp45}) + var v47 any = tmp46 _ = v47 // let binding "kf" - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("get")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v52 := v51.FindInternedVar(lang.NewSymbol("identity")) - if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) - } - v53 := v52.Get() - v54 := lang.Apply(v50, []any{v31, lang.NewKeyword("kf"), v53}) - var v55 any = v54 + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("get")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp52 := tmp51.FindInternedVar(lang.NewSymbol("identity")) + if tmp52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp52))) + } + tmp53 := tmp52.Get() + tmp54 := lang.Apply(tmp50, []any{v31, lang.NewKeyword("kf"), tmp53}) + var v55 any = tmp54 _ = v55 // let binding "initk" - v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v57 := v56.FindInternedVar(lang.NewSymbol("get")) - if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) - } - v58 := v57.Get() - v59 := lang.Apply(v58, []any{v31, lang.NewKeyword("initk"), nil}) - var v60 any = v59 + tmp56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp57 := tmp56.FindInternedVar(lang.NewSymbol("get")) + if tmp57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp57))) + } + tmp58 := tmp57.Get() + tmp59 := lang.Apply(tmp58, []any{v31, lang.NewKeyword("initk"), nil}) + var v60 any = tmp59 _ = v60 - v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v62 := v61.FindInternedVar(lang.NewSymbol("seq")) - if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) - } - v63 := v62.Get() - v64 := lang.NewVector(nil) - v65 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7743), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(7743), lang.NewKeyword("end-column"), int(11)) - v66, err := lang.WithMeta(v64, v65.(lang.IPersistentMap)) + tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp62 := tmp61.FindInternedVar(lang.NewSymbol("seq")) + if tmp62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) + } + tmp63 := tmp62.Get() + tmp64 := lang.NewVector(nil) + tmp65 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7743), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(7743), lang.NewKeyword("end-column"), int(11)) + tmp66, err := lang.WithMeta(tmp64, tmp65.(lang.IPersistentMap)) if err != nil { panic(err) } - var v67 lang.FnFunc + var tmp67 lang.FnFunc { // function next - v67 = lang.NewFnFunc(func(args ...any) any { + var v68 lang.FnFunc + tmp67 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v69 := args[0] _ = v69 - var v70 any - v71 := lang.Apply(v39, []any{v69}) - if lang.IsTruthy(v71) { - v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v73 := v72.FindInternedVar(lang.NewSymbol("cons")) - if v73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) + var tmp70 any + tmp71 := lang.Apply(v39, []any{v69}) + if lang.IsTruthy(tmp71) { + tmp72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp73 := tmp72.FindInternedVar(lang.NewSymbol("cons")) + if tmp73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp73))) } - v74 := v73.Get() - v75 := lang.Apply(v47, []any{v69}) - var v76 any + tmp74 := tmp73.Get() + tmp75 := lang.Apply(v47, []any{v69}) + var tmp76 any { // let // let binding "temp__0__auto__" - v77 := lang.Apply(v55, []any{v69}) - var v78 any = v77 + tmp77 := lang.Apply(v55, []any{v69}) + var v78 any = tmp77 _ = v78 - var v79 any - v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v81 := v80.FindInternedVar(lang.NewSymbol("nil?")) - if v81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) + var tmp79 any + tmp80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp81 := tmp80.FindInternedVar(lang.NewSymbol("nil?")) + if tmp81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp81))) } - v82 := v81.Get() - v83 := lang.Apply(v82, []any{v78}) - if lang.IsTruthy(v83) { - v79 = nil + tmp82 := tmp81.Get() + tmp83 := lang.Apply(tmp82, []any{v78}) + if lang.IsTruthy(tmp83) { } else { - var v84 any + var tmp84 any { // let // let binding "k" var v85 any = v78 _ = v85 - var v86 lang.FnFunc - v86 = lang.NewFnFunc(func(args ...any) any { + var tmp86 lang.FnFunc + tmp86 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v87 := lang.Apply(v3, []any{v85}) - v88 := lang.Apply(v68, []any{v87}) - return v88 + tmp87 := lang.Apply(v3, []any{v85}) + tmp88 := lang.Apply(v68, []any{tmp87}) + return tmp88 }) - v87 := lang.Apply(lang.NewLazySeq, []any{v86}) - v84 = v87 + tmp87 := lang.Apply(lang.NewLazySeq, []any{tmp86}) + tmp84 = tmp87 } // end let - v79 = v84 + tmp79 = tmp84 } - v76 = v79 + tmp76 = tmp79 } // end let - v77 := lang.Apply(v74, []any{v75, v76}) - v70 = v77 + tmp77 := lang.Apply(tmp74, []any{tmp75, tmp76}) + tmp70 = tmp77 } else { - v70 = nil } - return v70 + return tmp70 }) - v68 := v67 + v68 = tmp67 _ = v68 } - v68 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7744), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(7748), lang.NewKeyword("end-column"), int(51)) - v69, err := lang.WithMeta(v67, v68.(lang.IPersistentMap)) + tmp68 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7744), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(7748), lang.NewKeyword("end-column"), int(51)) + tmp69, err := lang.WithMeta(tmp67, tmp68.(lang.IPersistentMap)) if err != nil { panic(err) } - v70 := lang.Apply(v3, []any{v60}) - v71 := lang.Apply(v69, []any{v70}) - v72 := lang.Apply(v63, []any{v66, v71}) - v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v74 := v73.FindInternedVar(lang.NewSymbol("reduce")) - if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) - } - v75 := v74.Get() - v76 := lang.NewVector(nil, nil, nil) - v77 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7751), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(7751), lang.NewKeyword("end-column"), int(22)) - v78, err := lang.WithMeta(v76, v77.(lang.IPersistentMap)) + tmp70 := lang.Apply(v3, []any{v60}) + tmp71 := lang.Apply(tmp69, []any{tmp70}) + tmp72 := lang.Apply(tmp63, []any{tmp66, tmp71}) + tmp73 := reflect.TypeOf((*lang.IReduceInit)(nil)).Elem() + tmp74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp75 := tmp74.FindInternedVar(lang.NewSymbol("reduce")) + if tmp75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp75))) + } + tmp76 := tmp75.Get() + tmp77 := lang.NewVector(nil, nil, nil) + tmp78 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7751), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(7751), lang.NewKeyword("end-column"), int(22)) + tmp79, err := lang.WithMeta(tmp77, tmp78.(lang.IPersistentMap)) if err != nil { panic(err) } - var v79 any + var tmp80 any { // let // let binding "acc" - var v80 any = nil - _ = v80 + var v81 any = nil + _ = v81 // let binding "ret" - v81 := lang.Apply(v3, []any{v60}) - var v82 any = v81 - _ = v82 + tmp82 := lang.Apply(v3, []any{v60}) + var v83 any = tmp82 + _ = v83 for { - var v83 any - v84 := lang.Apply(v39, []any{v82}) - if lang.IsTruthy(v84) { - var v85 any + var tmp84 any + tmp85 := lang.Apply(v39, []any{v83}) + if lang.IsTruthy(tmp85) { + var tmp86 any { // let // let binding "acc" - v86 := lang.Apply(v47, []any{v82}) - v87 := lang.Apply(nil, []any{v80, v86}) - var v88 any = v87 - _ = v88 - var v89 any - v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v91 := v90.FindInternedVar(lang.NewSymbol("reduced?")) - if v91.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) + tmp87 := lang.Apply(v47, []any{v83}) + tmp88 := lang.Apply(nil, []any{v81, tmp87}) + var v89 any = tmp88 + _ = v89 + var tmp90 any + tmp91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp92 := tmp91.FindInternedVar(lang.NewSymbol("reduced?")) + if tmp92.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp92))) } - v92 := v91.Get() - v93 := lang.Apply(v92, []any{v88}) - if lang.IsTruthy(v93) { - v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v95 := v94.FindInternedVar(lang.NewSymbol("deref")) - if v95.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) + tmp93 := tmp92.Get() + tmp94 := lang.Apply(tmp93, []any{v89}) + if lang.IsTruthy(tmp94) { + tmp95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp96 := tmp95.FindInternedVar(lang.NewSymbol("deref")) + if tmp96.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp96))) } - v96 := v95.Get() - v97 := lang.Apply(v96, []any{v88}) - v89 = v97 + tmp97 := tmp96.Get() + tmp98 := lang.Apply(tmp97, []any{v89}) + tmp90 = tmp98 } else { - var v98 any + var tmp99 any { // let // let binding "temp__0__auto__" - v99 := lang.Apply(v55, []any{v82}) - var v100 any = v99 - _ = v100 - var v101 any - v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v103 := v102.FindInternedVar(lang.NewSymbol("nil?")) - if v103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) + tmp100 := lang.Apply(v55, []any{v83}) + var v101 any = tmp100 + _ = v101 + var tmp102 any + tmp103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp104 := tmp103.FindInternedVar(lang.NewSymbol("nil?")) + if tmp104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp104))) } - v104 := v103.Get() - v105 := lang.Apply(v104, []any{v100}) - if lang.IsTruthy(v105) { - v101 = v88 + tmp105 := tmp104.Get() + tmp106 := lang.Apply(tmp105, []any{v101}) + if lang.IsTruthy(tmp106) { + tmp102 = v89 } else { - var v106 any + var tmp107 any { // let // let binding "k" - var v107 any = v100 - _ = v107 - var v108 any = v88 - v110 := lang.Apply(v3, []any{v107}) - var v109 any = v110 - v80 = v108 - v82 = v109 + var v108 any = v101 + _ = v108 + var tmp109 any = v89 + tmp111 := lang.Apply(v3, []any{v108}) + var tmp110 any = tmp111 + v81 = tmp109 + v83 = tmp110 continue } // end let - v101 = v106 + tmp102 = tmp107 } - v98 = v101 + tmp99 = tmp102 } // end let - v89 = v98 + tmp90 = tmp99 } - v85 = v89 + tmp86 = tmp90 } // end let - v83 = v85 + tmp84 = tmp86 } else { - v83 = v80 + tmp84 = v81 } - v79 = v83 + tmp80 = tmp84 break } } // end let - v80 := lang.Apply(v75, []any{v78, v79}) - v81 := lang.Apply(nil, []any{nil, v72, lang.IReduceInit, v80}) - v5 = v81 + tmp81 := lang.Apply(tmp76, []any{tmp79, tmp80}) + tmp82 := lang.Apply(nil, []any{nil, tmp72, tmp73, tmp81}) + tmp5 = tmp82 } // end let - return v5 + return tmp5 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // iterator-seq { - v0 := lang.NewSymbol("iterator-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("iter"))), lang.NewKeyword("doc"), "Returns a seq on a java.util.Iterator. Note that most collections\n providing iterators implement Iterable and thus support seq directly.\n Seqs cache values, thus iterator-seq should not be used on any\n iterator that repeatedly returns the same mutable object.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5700), lang.NewKeyword("end-line"), int(5700))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("iterator-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("iter"))), lang.NewKeyword("doc"), "Returns a seq on a java.util.Iterator. Note that most collections\n providing iterators implement Iterable and thus support seq directly.\n Seqs cache values, thus iterator-seq should not be used on any\n iterator that repeatedly returns the same mutable object.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5700), lang.NewKeyword("end-line"), int(5700))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.Apply(nil, []any{v3}) - return v4 + tmp4 := lang.Apply(nil, []any{v3}) + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // juxt { - v0 := lang.NewSymbol("juxt").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("g")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("g"), lang.NewSymbol("h")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("g"), lang.NewSymbol("h"), lang.NewSymbol("&"), lang.NewSymbol("fs"))), lang.NewKeyword("doc"), "Takes a set of functions and returns a fn that is the juxtaposition\n of those fns. The returned fn takes a variable number of args, and\n returns a vector containing the result of applying each fn to the\n args (left-to-right).\n ((juxt a b c) x) => [(a x) (b x) (c x)]", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2568), lang.NewKeyword("end-line"), int(2568))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("juxt").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("g")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("g"), lang.NewSymbol("h")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("g"), lang.NewSymbol("h"), lang.NewSymbol("&"), lang.NewSymbol("fs"))), lang.NewKeyword("doc"), "Takes a set of functions and returns a fn that is the juxtaposition\n of those fns. The returned fn takes a variable number of args, and\n returns a vector containing the result of applying each fn to the\n args (left-to-right).\n ((juxt a b c) x) => [(a x) (b x) (c x)]", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2568), lang.NewKeyword("end-line"), int(2568))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - var v4 lang.FnFunc - v4 = lang.NewFnFunc(func(args ...any) any { + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - v5 := lang.Apply(v3, nil) - v6 := lang.NewVector(v5) - v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2578), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(2578), lang.NewKeyword("end-column"), int(16)) - v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) + tmp5 := lang.Apply(v3, nil) + tmp6 := lang.NewVector(tmp5) + tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2578), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(2578), lang.NewKeyword("end-column"), int(16)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) if err != nil { panic(err) } - return v8 + return tmp8 case 1: v5 := args[0] _ = v5 - v6 := lang.Apply(v3, []any{v5}) - v7 := lang.NewVector(v6) - v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2579), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(2579), lang.NewKeyword("end-column"), int(19)) - v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) + tmp6 := lang.Apply(v3, []any{v5}) + tmp7 := lang.NewVector(tmp6) + tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2579), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(2579), lang.NewKeyword("end-column"), int(19)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) if err != nil { panic(err) } - return v9 + return tmp9 case 2: v5 := args[0] _ = v5 v6 := args[1] _ = v6 - v7 := lang.Apply(v3, []any{v5, v6}) - v8 := lang.NewVector(v7) - v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2580), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(2580), lang.NewKeyword("end-column"), int(23)) - v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) + tmp7 := lang.Apply(v3, []any{v5, v6}) + tmp8 := lang.NewVector(tmp7) + tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2580), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(2580), lang.NewKeyword("end-column"), int(23)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) if err != nil { panic(err) } - return v10 + return tmp10 case 3: v5 := args[0] _ = v5 @@ -44993,14 +45106,14 @@ func init() { _ = v6 v7 := args[2] _ = v7 - v8 := lang.Apply(v3, []any{v5, v6, v7}) - v9 := lang.NewVector(v8) - v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2581), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(2581), lang.NewKeyword("end-column"), int(27)) - v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) + tmp8 := lang.Apply(v3, []any{v5, v6, v7}) + tmp9 := lang.NewVector(tmp8) + tmp10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2581), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(2581), lang.NewKeyword("end-column"), int(27)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) if err != nil { panic(err) } - return v11 + return tmp11 default: if len(args) < 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -45011,73 +45124,74 @@ func init() { _ = v6 v7 := args[2] _ = v7 - v8 := lang.NewList(args[3:]...) - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("apply")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.Apply(v11, []any{v3, v5, v6, v7, v8}) - v13 := lang.NewVector(v12) - v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2582), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(2582), lang.NewKeyword("end-column"), int(45)) - v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) + var v8 any = lang.NewList(args[3:]...) + _ = v8 + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("apply")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.Apply(tmp11, []any{v3, v5, v6, v7, v8}) + tmp13 := lang.NewVector(tmp12) + tmp14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2582), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(2582), lang.NewKeyword("end-column"), int(45)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) if err != nil { panic(err) } - return v15 + return tmp15 } }) - v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2577), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2582), lang.NewKeyword("end-column"), int(47)) - v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) + tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2577), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2582), lang.NewKeyword("end-column"), int(47)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) if err != nil { panic(err) } - return v6 + return tmp6 case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - var v5 lang.FnFunc - v5 = lang.NewFnFunc(func(args ...any) any { + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - v6 := lang.Apply(v3, nil) - v7 := lang.Apply(v4, nil) - v8 := lang.NewVector(v6, v7) - v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2585), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(2585), lang.NewKeyword("end-column"), int(20)) - v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) + tmp6 := lang.Apply(v3, nil) + tmp7 := lang.Apply(v4, nil) + tmp8 := lang.NewVector(tmp6, tmp7) + tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2585), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(2585), lang.NewKeyword("end-column"), int(20)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) if err != nil { panic(err) } - return v10 + return tmp10 case 1: v6 := args[0] _ = v6 - v7 := lang.Apply(v3, []any{v6}) - v8 := lang.Apply(v4, []any{v6}) - v9 := lang.NewVector(v7, v8) - v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2586), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(2586), lang.NewKeyword("end-column"), int(25)) - v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) + tmp7 := lang.Apply(v3, []any{v6}) + tmp8 := lang.Apply(v4, []any{v6}) + tmp9 := lang.NewVector(tmp7, tmp8) + tmp10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2586), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(2586), lang.NewKeyword("end-column"), int(25)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) if err != nil { panic(err) } - return v11 + return tmp11 case 2: v6 := args[0] _ = v6 v7 := args[1] _ = v7 - v8 := lang.Apply(v3, []any{v6, v7}) - v9 := lang.Apply(v4, []any{v6, v7}) - v10 := lang.NewVector(v8, v9) - v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2587), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(2587), lang.NewKeyword("end-column"), int(31)) - v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) + tmp8 := lang.Apply(v3, []any{v6, v7}) + tmp9 := lang.Apply(v4, []any{v6, v7}) + tmp10 := lang.NewVector(tmp8, tmp9) + tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2587), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(2587), lang.NewKeyword("end-column"), int(31)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) if err != nil { panic(err) } - return v12 + return tmp12 case 3: v6 := args[0] _ = v6 @@ -45085,15 +45199,15 @@ func init() { _ = v7 v8 := args[2] _ = v8 - v9 := lang.Apply(v3, []any{v6, v7, v8}) - v10 := lang.Apply(v4, []any{v6, v7, v8}) - v11 := lang.NewVector(v9, v10) - v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2588), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(2588), lang.NewKeyword("end-column"), int(37)) - v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) + tmp9 := lang.Apply(v3, []any{v6, v7, v8}) + tmp10 := lang.Apply(v4, []any{v6, v7, v8}) + tmp11 := lang.NewVector(tmp9, tmp10) + tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2588), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(2588), lang.NewKeyword("end-column"), int(37)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) if err != nil { panic(err) } - return v13 + return tmp13 default: if len(args) < 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -45104,36 +45218,37 @@ func init() { _ = v7 v8 := args[2] _ = v8 - v9 := lang.NewList(args[3:]...) - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("apply")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{v3, v6, v7, v8, v9}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("apply")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{v4, v6, v7, v8, v9}) - v18 := lang.NewVector(v13, v17) - v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2589), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(2589), lang.NewKeyword("end-column"), int(66)) - v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) + var v9 any = lang.NewList(args[3:]...) + _ = v9 + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("apply")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{v3, v6, v7, v8, v9}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("apply")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{v4, v6, v7, v8, v9}) + tmp18 := lang.NewVector(tmp13, tmp17) + tmp19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2589), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(2589), lang.NewKeyword("end-column"), int(66)) + tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) if err != nil { panic(err) } - return v20 + return tmp20 } }) - v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2584), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2589), lang.NewKeyword("end-column"), int(68)) - v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) + tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2584), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2589), lang.NewKeyword("end-column"), int(68)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) if err != nil { panic(err) } - return v7 + return tmp7 case 3: v3 := args[0] _ = v3 @@ -45141,48 +45256,48 @@ func init() { _ = v4 v5 := args[2] _ = v5 - var v6 lang.FnFunc - v6 = lang.NewFnFunc(func(args ...any) any { + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - v7 := lang.Apply(v3, nil) - v8 := lang.Apply(v4, nil) - v9 := lang.Apply(v5, nil) - v10 := lang.NewVector(v7, v8, v9) - v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2592), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(2592), lang.NewKeyword("end-column"), int(24)) - v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) + tmp7 := lang.Apply(v3, nil) + tmp8 := lang.Apply(v4, nil) + tmp9 := lang.Apply(v5, nil) + tmp10 := lang.NewVector(tmp7, tmp8, tmp9) + tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2592), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(2592), lang.NewKeyword("end-column"), int(24)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) if err != nil { panic(err) } - return v12 + return tmp12 case 1: v7 := args[0] _ = v7 - v8 := lang.Apply(v3, []any{v7}) - v9 := lang.Apply(v4, []any{v7}) - v10 := lang.Apply(v5, []any{v7}) - v11 := lang.NewVector(v8, v9, v10) - v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2593), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(2593), lang.NewKeyword("end-column"), int(31)) - v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) + tmp8 := lang.Apply(v3, []any{v7}) + tmp9 := lang.Apply(v4, []any{v7}) + tmp10 := lang.Apply(v5, []any{v7}) + tmp11 := lang.NewVector(tmp8, tmp9, tmp10) + tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2593), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(2593), lang.NewKeyword("end-column"), int(31)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) if err != nil { panic(err) } - return v13 + return tmp13 case 2: v7 := args[0] _ = v7 v8 := args[1] _ = v8 - v9 := lang.Apply(v3, []any{v7, v8}) - v10 := lang.Apply(v4, []any{v7, v8}) - v11 := lang.Apply(v5, []any{v7, v8}) - v12 := lang.NewVector(v9, v10, v11) - v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2594), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(2594), lang.NewKeyword("end-column"), int(39)) - v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) + tmp9 := lang.Apply(v3, []any{v7, v8}) + tmp10 := lang.Apply(v4, []any{v7, v8}) + tmp11 := lang.Apply(v5, []any{v7, v8}) + tmp12 := lang.NewVector(tmp9, tmp10, tmp11) + tmp13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2594), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(2594), lang.NewKeyword("end-column"), int(39)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) if err != nil { panic(err) } - return v14 + return tmp14 case 3: v7 := args[0] _ = v7 @@ -45190,16 +45305,16 @@ func init() { _ = v8 v9 := args[2] _ = v9 - v10 := lang.Apply(v3, []any{v7, v8, v9}) - v11 := lang.Apply(v4, []any{v7, v8, v9}) - v12 := lang.Apply(v5, []any{v7, v8, v9}) - v13 := lang.NewVector(v10, v11, v12) - v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2595), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(2595), lang.NewKeyword("end-column"), int(47)) - v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) + tmp10 := lang.Apply(v3, []any{v7, v8, v9}) + tmp11 := lang.Apply(v4, []any{v7, v8, v9}) + tmp12 := lang.Apply(v5, []any{v7, v8, v9}) + tmp13 := lang.NewVector(tmp10, tmp11, tmp12) + tmp14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2595), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(2595), lang.NewKeyword("end-column"), int(47)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) if err != nil { panic(err) } - return v15 + return tmp15 default: if len(args) < 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -45210,43 +45325,44 @@ func init() { _ = v8 v9 := args[2] _ = v9 - v10 := lang.NewList(args[3:]...) - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("apply")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{v3, v7, v8, v9, v10}) - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("apply")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{v4, v7, v8, v9, v10}) - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("apply")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{v5, v7, v8, v9, v10}) - v23 := lang.NewVector(v14, v18, v22) - v24 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2596), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(2596), lang.NewKeyword("end-column"), int(87)) - v25, err := lang.WithMeta(v23, v24.(lang.IPersistentMap)) + var v10 any = lang.NewList(args[3:]...) + _ = v10 + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("apply")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{v3, v7, v8, v9, v10}) + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("apply")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{v4, v7, v8, v9, v10}) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("apply")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, []any{v5, v7, v8, v9, v10}) + tmp23 := lang.NewVector(tmp14, tmp18, tmp22) + tmp24 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2596), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(2596), lang.NewKeyword("end-column"), int(87)) + tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) if err != nil { panic(err) } - return v25 + return tmp25 } }) - v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2591), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2596), lang.NewKeyword("end-column"), int(89)) - v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) + tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2591), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2596), lang.NewKeyword("end-column"), int(89)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) if err != nil { panic(err) } - return v8 + return tmp8 default: if len(args) < 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -45257,31 +45373,32 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - var v7 any + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any { // let // let binding "fs" - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("list*")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v3, v4, v5, v6}) - var v12 any = v11 + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("list*")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v3, v4, v5, v6}) + var v12 any = tmp11 _ = v12 - var v13 lang.FnFunc - v13 = lang.NewFnFunc(func(args ...any) any { + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("reduce1")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - var v17 lang.FnFunc - v17 = lang.NewFnFunc(func(args ...any) any { + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + var tmp17 lang.FnFunc + tmp17 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -45289,40 +45406,40 @@ func init() { _ = v18 v19 := args[1] _ = v19 - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("conj")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("conj")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) } - v22 := v21.Get() - v23 := lang.Apply(v19, nil) - v24 := lang.Apply(v22, []any{v18, v23}) - return v24 + tmp22 := tmp21.Get() + tmp23 := lang.Apply(v19, nil) + tmp24 := lang.Apply(tmp22, []any{v18, tmp23}) + return tmp24 }) - v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2600), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(2600), lang.NewKeyword("end-column"), int(37)) - v19, err := lang.WithMeta(v17, v18.(lang.IPersistentMap)) + tmp18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2600), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(2600), lang.NewKeyword("end-column"), int(37)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) if err != nil { panic(err) } - v20 := lang.NewVector() - v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2600), lang.NewKeyword("column"), int(39), lang.NewKeyword("end-line"), int(2600), lang.NewKeyword("end-column"), int(40)) - v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) + tmp20 := lang.NewVector() + tmp21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2600), lang.NewKeyword("column"), int(39), lang.NewKeyword("end-line"), int(2600), lang.NewKeyword("end-column"), int(40)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) if err != nil { panic(err) } - v23 := lang.Apply(v16, []any{v19, v22, v12}) - return v23 + tmp23 := lang.Apply(tmp16, []any{tmp19, tmp22, v12}) + return tmp23 case 1: v14 := args[0] _ = v14 - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("reduce1")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - var v18 lang.FnFunc - v18 = lang.NewFnFunc(func(args ...any) any { + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + var tmp18 lang.FnFunc + tmp18 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -45330,42 +45447,42 @@ func init() { _ = v19 v20 := args[1] _ = v20 - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("conj")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("conj")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) } - v23 := v22.Get() - v24 := lang.Apply(v20, []any{v14}) - v25 := lang.Apply(v23, []any{v19, v24}) - return v25 + tmp23 := tmp22.Get() + tmp24 := lang.Apply(v20, []any{v14}) + tmp25 := lang.Apply(tmp23, []any{v19, tmp24}) + return tmp25 }) - v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2601), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(2601), lang.NewKeyword("end-column"), int(40)) - v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) + tmp19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2601), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(2601), lang.NewKeyword("end-column"), int(40)) + tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) if err != nil { panic(err) } - v21 := lang.NewVector() - v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2601), lang.NewKeyword("column"), int(42), lang.NewKeyword("end-line"), int(2601), lang.NewKeyword("end-column"), int(43)) - v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) + tmp21 := lang.NewVector() + tmp22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2601), lang.NewKeyword("column"), int(42), lang.NewKeyword("end-line"), int(2601), lang.NewKeyword("end-column"), int(43)) + tmp23, err := lang.WithMeta(tmp21, tmp22.(lang.IPersistentMap)) if err != nil { panic(err) } - v24 := lang.Apply(v17, []any{v20, v23, v12}) - return v24 + tmp24 := lang.Apply(tmp17, []any{tmp20, tmp23, v12}) + return tmp24 case 2: v14 := args[0] _ = v14 v15 := args[1] _ = v15 - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("reduce1")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - var v19 lang.FnFunc - v19 = lang.NewFnFunc(func(args ...any) any { + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + var tmp19 lang.FnFunc + tmp19 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -45373,29 +45490,29 @@ func init() { _ = v20 v21 := args[1] _ = v21 - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("conj")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("conj")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) } - v24 := v23.Get() - v25 := lang.Apply(v21, []any{v14, v15}) - v26 := lang.Apply(v24, []any{v20, v25}) - return v26 + tmp24 := tmp23.Get() + tmp25 := lang.Apply(v21, []any{v14, v15}) + tmp26 := lang.Apply(tmp24, []any{v20, tmp25}) + return tmp26 }) - v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2602), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(2602), lang.NewKeyword("end-column"), int(44)) - v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) + tmp20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2602), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(2602), lang.NewKeyword("end-column"), int(44)) + tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) if err != nil { panic(err) } - v22 := lang.NewVector() - v23 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2602), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(2602), lang.NewKeyword("end-column"), int(47)) - v24, err := lang.WithMeta(v22, v23.(lang.IPersistentMap)) + tmp22 := lang.NewVector() + tmp23 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2602), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(2602), lang.NewKeyword("end-column"), int(47)) + tmp24, err := lang.WithMeta(tmp22, tmp23.(lang.IPersistentMap)) if err != nil { panic(err) } - v25 := lang.Apply(v18, []any{v21, v24, v12}) - return v25 + tmp25 := lang.Apply(tmp18, []any{tmp21, tmp24, v12}) + return tmp25 case 3: v14 := args[0] _ = v14 @@ -45403,14 +45520,14 @@ func init() { _ = v15 v16 := args[2] _ = v16 - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("reduce1")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - var v20 lang.FnFunc - v20 = lang.NewFnFunc(func(args ...any) any { + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + var tmp20 lang.FnFunc + tmp20 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -45418,29 +45535,29 @@ func init() { _ = v21 v22 := args[1] _ = v22 - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("conj")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("conj")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) } - v25 := v24.Get() - v26 := lang.Apply(v22, []any{v14, v15, v16}) - v27 := lang.Apply(v25, []any{v21, v26}) - return v27 + tmp25 := tmp24.Get() + tmp26 := lang.Apply(v22, []any{v14, v15, v16}) + tmp27 := lang.Apply(tmp25, []any{v21, tmp26}) + return tmp27 }) - v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2603), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(2603), lang.NewKeyword("end-column"), int(48)) - v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) + tmp21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2603), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(2603), lang.NewKeyword("end-column"), int(48)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) if err != nil { panic(err) } - v23 := lang.NewVector() - v24 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2603), lang.NewKeyword("column"), int(50), lang.NewKeyword("end-line"), int(2603), lang.NewKeyword("end-column"), int(51)) - v25, err := lang.WithMeta(v23, v24.(lang.IPersistentMap)) + tmp23 := lang.NewVector() + tmp24 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2603), lang.NewKeyword("column"), int(50), lang.NewKeyword("end-line"), int(2603), lang.NewKeyword("end-column"), int(51)) + tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) if err != nil { panic(err) } - v26 := lang.Apply(v19, []any{v22, v25, v12}) - return v26 + tmp26 := lang.Apply(tmp19, []any{tmp22, tmp25, v12}) + return tmp26 default: if len(args) < 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -45451,15 +45568,16 @@ func init() { _ = v15 v16 := args[2] _ = v16 - v17 := lang.NewList(args[3:]...) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("reduce1")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - var v21 lang.FnFunc - v21 = lang.NewFnFunc(func(args ...any) any { + var v17 any = lang.NewList(args[3:]...) + _ = v17 + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + var tmp21 lang.FnFunc + tmp21 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -45467,507 +45585,504 @@ func init() { _ = v22 v23 := args[1] _ = v23 - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("conj")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("conj")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("apply")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("apply")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{v23, v14, v15, v16, v17}) - v31 := lang.Apply(v26, []any{v22, v30}) - return v31 + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{v23, v14, v15, v16, v17}) + tmp31 := lang.Apply(tmp26, []any{v22, tmp30}) + return tmp31 }) - v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2604), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(2604), lang.NewKeyword("end-column"), int(66)) - v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) + tmp22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2604), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(2604), lang.NewKeyword("end-column"), int(66)) + tmp23, err := lang.WithMeta(tmp21, tmp22.(lang.IPersistentMap)) if err != nil { panic(err) } - v24 := lang.NewVector() - v25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2604), lang.NewKeyword("column"), int(68), lang.NewKeyword("end-line"), int(2604), lang.NewKeyword("end-column"), int(69)) - v26, err := lang.WithMeta(v24, v25.(lang.IPersistentMap)) + tmp24 := lang.NewVector() + tmp25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2604), lang.NewKeyword("column"), int(68), lang.NewKeyword("end-line"), int(2604), lang.NewKeyword("end-column"), int(69)) + tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) if err != nil { panic(err) } - v27 := lang.Apply(v20, []any{v23, v26, v12}) - return v27 + tmp27 := lang.Apply(tmp20, []any{tmp23, tmp26, v12}) + return tmp27 } }) - v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2599), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(2604), lang.NewKeyword("end-column"), int(75)) - v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) + tmp14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2599), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(2604), lang.NewKeyword("end-column"), int(75)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) if err != nil { panic(err) } - v7 = v15 + tmp7 = tmp15 } // end let - return v7 + return tmp7 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // keep { - v0 := lang.NewSymbol("keep").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the non-nil results of (f item). Note,\n this means false return values will be included. f must be free of\n side-effects. Returns a transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7339), lang.NewKeyword("end-line"), int(7339))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("keep").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the non-nil results of (f item). Note,\n this means false return values will be included. f must be free of\n side-effects. Returns a transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7339), lang.NewKeyword("end-line"), int(7339))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - var v4 lang.FnFunc - v4 = lang.NewFnFunc(func(args ...any) any { + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v5 := args[0] _ = v5 - var v6 lang.FnFunc - v6 = lang.NewFnFunc(func(args ...any) any { + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - v7 := lang.Apply(v5, nil) - return v7 + tmp7 := lang.Apply(v5, nil) + return tmp7 case 1: v7 := args[0] _ = v7 - v8 := lang.Apply(v5, []any{v7}) - return v8 + tmp8 := lang.Apply(v5, []any{v7}) + return tmp8 case 2: v7 := args[0] _ = v7 v8 := args[1] _ = v8 - var v9 any + var tmp9 any { // let // let binding "v" - v10 := lang.Apply(v3, []any{v8}) - var v11 any = v10 + tmp10 := lang.Apply(v3, []any{v8}) + var v11 any = tmp10 _ = v11 - var v12 any - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("nil?")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + var tmp12 any + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("nil?")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{v11}) - if lang.IsTruthy(v16) { - v12 = v7 + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{v11}) + if lang.IsTruthy(tmp16) { + tmp12 = v7 } else { - v17 := lang.Apply(v5, []any{v7, v11}) - v12 = v17 + tmp17 := lang.Apply(v5, []any{v7, v11}) + tmp12 = tmp17 } - v9 = v12 + tmp9 = tmp12 } // end let - return v9 + return tmp9 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7347), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7354), lang.NewKeyword("end-column"), int(31)) - v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) + tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7347), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7354), lang.NewKeyword("end-column"), int(31)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) if err != nil { panic(err) } - return v8 + return tmp8 }) - v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7346), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7354), lang.NewKeyword("end-column"), int(32)) - v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) + tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7346), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7354), lang.NewKeyword("end-column"), int(32)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) if err != nil { panic(err) } - return v6 + return tmp6 case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - var v5 lang.FnFunc - v5 = lang.NewFnFunc(func(args ...any) any { + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - var v6 any + var tmp6 any { // let // let binding "temp__0__auto__" - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("seq")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v9, []any{v4}) - var v11 any = v10 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("seq")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp9, []any{v4}) + var v11 any = tmp10 _ = v11 - var v12 any + var tmp12 any if lang.IsTruthy(v11) { - var v13 any + var tmp13 any { // let // let binding "s" var v14 any = v11 _ = v14 - var v15 any - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("chunked-seq?")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + var tmp15 any + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("chunked-seq?")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{v14}) - if lang.IsTruthy(v19) { - var v20 any + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{v14}) + if lang.IsTruthy(tmp19) { + var tmp20 any { // let // let binding "c" - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("chunk-first")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("chunk-first")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) } - v23 := v22.Get() - v24 := lang.Apply(v23, []any{v14}) - var v25 any = v24 + tmp23 := tmp22.Get() + tmp24 := lang.Apply(tmp23, []any{v14}) + var v25 any = tmp24 _ = v25 // let binding "size" - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("count")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("count")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) } - v28 := v27.Get() - v29 := lang.Apply(v28, []any{v25}) - var v30 any = v29 + tmp28 := tmp27.Get() + tmp29 := lang.Apply(tmp28, []any{v25}) + var v30 any = tmp29 _ = v30 // let binding "b" - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("chunk-buffer")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("chunk-buffer")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{v30}) - var v35 any = v34 + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{v30}) + var v35 any = tmp34 _ = v35 - var v36 any + var tmp36 any { // let // let binding "n__0__auto__" - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("long")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("long")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) } - v39 := v38.Get() - v40 := lang.Apply(v39, []any{v30}) - var v41 any = v40 + tmp39 := tmp38.Get() + tmp40 := lang.Apply(tmp39, []any{v30}) + var v41 any = tmp40 _ = v41 - var v42 any + var tmp42 any { // let // let binding "i" var v43 any = int64(0) _ = v43 for { - var v44 any - v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v46 := v45.FindInternedVar(lang.NewSymbol("<")) - if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) + var tmp44 any + tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp46 := tmp45.FindInternedVar(lang.NewSymbol("<")) + if tmp46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) } - v47 := v46.Get() - v48 := lang.Apply(v47, []any{v43, v41}) - if lang.IsTruthy(v48) { - var v49 any + tmp47 := tmp46.Get() + tmp48 := lang.Apply(tmp47, []any{v43, v41}) + if lang.IsTruthy(tmp48) { + var tmp49 any { // let // let binding "x" - v50, _ := lang.FieldOrMethod(v25, "nth") - if reflect.TypeOf(v50).Kind() != reflect.Func { + tmp50, _ := lang.FieldOrMethod(v25, "nth") + if reflect.TypeOf(tmp50).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) } - v51 := lang.Apply(v50, []any{v43}) - v52 := lang.Apply(v3, []any{v51}) - var v53 any = v52 + tmp51 := lang.Apply(tmp50, []any{v43}) + tmp52 := lang.Apply(v3, []any{tmp51}) + var v53 any = tmp52 _ = v53 - var v54 any - v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v56 := v55.FindInternedVar(lang.NewSymbol("nil?")) - if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) + var tmp54 any + tmp55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp56 := tmp55.FindInternedVar(lang.NewSymbol("nil?")) + if tmp56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp56))) } - v57 := v56.Get() - v58 := lang.Apply(v57, []any{v53}) - if lang.IsTruthy(v58) { - v54 = nil + tmp57 := tmp56.Get() + tmp58 := lang.Apply(tmp57, []any{v53}) + if lang.IsTruthy(tmp58) { } else { - v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v60 := v59.FindInternedVar(lang.NewSymbol("chunk-append")) - if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) + tmp59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp60 := tmp59.FindInternedVar(lang.NewSymbol("chunk-append")) + if tmp60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp60))) } - v61 := v60.Get() - v62 := lang.Apply(v61, []any{v35, v53}) - v54 = v62 + tmp61 := tmp60.Get() + tmp62 := lang.Apply(tmp61, []any{v35, v53}) + tmp54 = tmp62 } - v49 = v54 + tmp49 = tmp54 } // end let - _ = v49 - v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v52 := v51.FindInternedVar(lang.NewSymbol("unchecked-inc")) - if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) + _ = tmp49 + tmp51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp52 := tmp51.FindInternedVar(lang.NewSymbol("unchecked-inc")) + if tmp52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp52))) } - v53 := v52.Get() - v54 := lang.Apply(v53, []any{v43}) - var v50 any = v54 - v43 = v50 + tmp53 := tmp52.Get() + tmp54 := lang.Apply(tmp53, []any{v43}) + var tmp50 any = tmp54 + v43 = tmp50 continue } else { - v44 = nil } - v42 = v44 + tmp42 = tmp44 break } } // end let - v36 = v42 + tmp36 = tmp42 } // end let - _ = v36 - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("chunk-cons")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + _ = tmp36 + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("chunk-cons")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) } - v39 := v38.Get() - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("chunk")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + tmp39 := tmp38.Get() + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("chunk")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) } - v42 := v41.Get() - v43 := lang.Apply(v42, []any{v35}) - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("keep")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + tmp42 := tmp41.Get() + tmp43 := lang.Apply(tmp42, []any{v35}) + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("keep")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) } - v46 := v45.Get() - v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v48 := v47.FindInternedVar(lang.NewSymbol("chunk-rest")) - if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) + tmp46 := tmp45.Get() + tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp48 := tmp47.FindInternedVar(lang.NewSymbol("chunk-rest")) + if tmp48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) } - v49 := v48.Get() - v50 := lang.Apply(v49, []any{v14}) - v51 := lang.Apply(v46, []any{v3, v50}) - v52 := lang.Apply(v39, []any{v43, v51}) - v20 = v52 + tmp49 := tmp48.Get() + tmp50 := lang.Apply(tmp49, []any{v14}) + tmp51 := lang.Apply(tmp46, []any{v3, tmp50}) + tmp52 := lang.Apply(tmp39, []any{tmp43, tmp51}) + tmp20 = tmp52 } // end let - v15 = v20 + tmp15 = tmp20 } else { - var v21 any + var tmp21 any { // let // let binding "x" - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("first")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("first")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v14}) - v26 := lang.Apply(v3, []any{v25}) - var v27 any = v26 + tmp24 := tmp23.Get() + tmp25 := lang.Apply(tmp24, []any{v14}) + tmp26 := lang.Apply(v3, []any{tmp25}) + var v27 any = tmp26 _ = v27 - var v28 any - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("nil?")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + var tmp28 any + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("nil?")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) } - v31 := v30.Get() - v32 := lang.Apply(v31, []any{v27}) - if lang.IsTruthy(v32) { - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("keep")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + tmp31 := tmp30.Get() + tmp32 := lang.Apply(tmp31, []any{v27}) + if lang.IsTruthy(tmp32) { + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("keep")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) } - v35 := v34.Get() - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("rest")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + tmp35 := tmp34.Get() + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("rest")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) } - v38 := v37.Get() - v39 := lang.Apply(v38, []any{v14}) - v40 := lang.Apply(v35, []any{v3, v39}) - v28 = v40 + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{v14}) + tmp40 := lang.Apply(tmp35, []any{v3, tmp39}) + tmp28 = tmp40 } else { - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("cons")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("cons")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) } - v43 := v42.Get() - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("keep")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + tmp43 := tmp42.Get() + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("keep")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) } - v46 := v45.Get() - v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v48 := v47.FindInternedVar(lang.NewSymbol("rest")) - if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) + tmp46 := tmp45.Get() + tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp48 := tmp47.FindInternedVar(lang.NewSymbol("rest")) + if tmp48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) } - v49 := v48.Get() - v50 := lang.Apply(v49, []any{v14}) - v51 := lang.Apply(v46, []any{v3, v50}) - v52 := lang.Apply(v43, []any{v27, v51}) - v28 = v52 + tmp49 := tmp48.Get() + tmp50 := lang.Apply(tmp49, []any{v14}) + tmp51 := lang.Apply(tmp46, []any{v3, tmp50}) + tmp52 := lang.Apply(tmp43, []any{v27, tmp51}) + tmp28 = tmp52 } - v21 = v28 + tmp21 = tmp28 } // end let - v15 = v21 + tmp15 = tmp21 } - v13 = v15 + tmp13 = tmp15 } // end let - v12 = v13 + tmp12 = tmp13 } else { - v12 = nil } - v6 = v12 + tmp6 = tmp12 } // end let - return v6 + return tmp6 }) - v6 := lang.Apply(lang.NewLazySeq, []any{v5}) - return v6 + tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) + return tmp6 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // keep-indexed { - v0 := lang.NewSymbol("keep-indexed").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the non-nil results of (f index item). Note,\n this means false return values will be included. f must be free of\n side-effects. Returns a stateful transducer when no collection is\n provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7372), lang.NewKeyword("end-line"), int(7372))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("keep-indexed").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the non-nil results of (f index item). Note,\n this means false return values will be included. f must be free of\n side-effects. Returns a stateful transducer when no collection is\n provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7372), lang.NewKeyword("end-line"), int(7372))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - var v4 lang.FnFunc - v4 = lang.NewFnFunc(func(args ...any) any { + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v5 := args[0] _ = v5 - var v6 any + var tmp6 any { // let // let binding "iv" - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("volatile!")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v9, []any{int64(-1)}) - var v11 any = v10 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("volatile!")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp9, []any{int64(-1)}) + var v11 any = tmp10 _ = v11 - var v12 lang.FnFunc - v12 = lang.NewFnFunc(func(args ...any) any { + var tmp12 lang.FnFunc + tmp12 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - v13 := lang.Apply(v5, nil) - return v13 + tmp13 := lang.Apply(v5, nil) + return tmp13 case 1: v13 := args[0] _ = v13 - v14 := lang.Apply(v5, []any{v13}) - return v14 + tmp14 := lang.Apply(v5, []any{v13}) + return tmp14 case 2: v13 := args[0] _ = v13 v14 := args[1] _ = v14 - var v15 any + var tmp15 any { // let // let binding "i" - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("inc")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("inc")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) } - v18 := v17.Get() - v19, ok := lang.FieldOrMethod(v11, "Deref") + tmp18 := tmp17.Get() + tmp19, ok := lang.FieldOrMethod(v11, "Deref") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v11, "Deref"))) } - var v20 any - switch reflect.TypeOf(v19).Kind() { + var tmp20 any + switch reflect.TypeOf(tmp19).Kind() { case reflect.Func: - v20 = lang.Apply(v19, nil) + tmp20 = lang.Apply(tmp19, nil) default: - v20 = v19 + tmp20 = tmp19 } - v21 := lang.Apply(v18, []any{v20}) - v22, _ := lang.FieldOrMethod(v11, "reset") - if reflect.TypeOf(v22).Kind() != reflect.Func { + tmp21 := lang.Apply(tmp18, []any{tmp20}) + tmp22, _ := lang.FieldOrMethod(v11, "reset") + if reflect.TypeOf(tmp22).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) } - v23 := lang.Apply(v22, []any{v21}) - var v24 any = v23 + tmp23 := lang.Apply(tmp22, []any{tmp21}) + var v24 any = tmp23 _ = v24 // let binding "v" - v25 := lang.Apply(v3, []any{v24, v14}) - var v26 any = v25 + tmp25 := lang.Apply(v3, []any{v24, v14}) + var v26 any = tmp25 _ = v26 - var v27 any - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("nil?")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + var tmp27 any + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("nil?")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) } - v30 := v29.Get() - v31 := lang.Apply(v30, []any{v26}) - if lang.IsTruthy(v31) { - v27 = v13 + tmp30 := tmp29.Get() + tmp31 := lang.Apply(tmp30, []any{v26}) + if lang.IsTruthy(tmp31) { + tmp27 = v13 } else { - v32 := lang.Apply(v5, []any{v13, v26}) - v27 = v32 + tmp32 := lang.Apply(v5, []any{v13, v26}) + tmp27 = tmp32 } - v15 = v27 + tmp15 = tmp27 } // end let - return v15 + return tmp15 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7382), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7390), lang.NewKeyword("end-column"), int(33)) - v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) + tmp13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7382), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7390), lang.NewKeyword("end-column"), int(33)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) if err != nil { panic(err) } - v6 = v14 + tmp6 = tmp14 } // end let - return v6 + return tmp6 }) - v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7380), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7390), lang.NewKeyword("end-column"), int(35)) - v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) + tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7380), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7390), lang.NewKeyword("end-column"), int(35)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) if err != nil { panic(err) } - return v6 + return tmp6 case 2: v3 := args[0] _ = v3 @@ -45978,206 +46093,207 @@ func init() { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // key { - v0 := lang.NewSymbol("key").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("e"))), lang.NewKeyword("doc"), "Returns the key of the map entry.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1563), lang.NewKeyword("end-line"), int(1563))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("key").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("e"))), lang.NewKeyword("doc"), "Returns the key of the map entry.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1563), lang.NewKeyword("end-line"), int(1563))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4, _ := lang.FieldOrMethod(v3, "GetKey") - if reflect.TypeOf(v4).Kind() != reflect.Func { + tmp4, _ := lang.FieldOrMethod(v3, "GetKey") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("GetKey is not a function"))) } - v5 := lang.Apply(v4, []any{}) - return v5 + tmp5 := lang.Apply(tmp4, []any{}) + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // keys { - v0 := lang.NewSymbol("keys").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"))), lang.NewKeyword("doc"), "Returns a sequence of the map's keys, in the same order as (seq map).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1551), lang.NewKeyword("end-line"), int(1551))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("keys").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"))), lang.NewKeyword("doc"), "Returns a sequence of the map's keys, in the same order as (seq map).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1551), lang.NewKeyword("end-line"), int(1551))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.Apply(lang.Keys, []any{v3}) - return v4 + tmp4 := lang.Apply(lang.Keys, []any{v3}) + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // keyword { - v1 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() - v0 := lang.NewSymbol("keyword").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name"))), lang.NewKeyword("doc"), "Returns a Keyword with the given namespace and name. Do not use :\n in the keyword strings, it will be added automatically.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(609), lang.NewKeyword("end-line"), int(609))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp1 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() + tmp0 := lang.NewSymbol("keyword").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name"))), lang.NewKeyword("doc"), "Returns a Keyword with the given namespace and name. Do not use :\n in the keyword strings, it will be added automatically.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(609), lang.NewKeyword("end-line"), int(609))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v4 := args[0] _ = v4 - var v5 any - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("keyword?")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{v4}) - if lang.IsTruthy(v9) { - v5 = v4 + var tmp5 any + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("keyword?")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.Apply(tmp8, []any{v4}) + if lang.IsTruthy(tmp9) { + tmp5 = v4 } else { - var v10 any - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("symbol?")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{v4}) - if lang.IsTruthy(v14) { - v15 := lang.Apply(lang.InternKeywordSymbol, []any{v4}) - v10 = v15 + var tmp10 any + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("symbol?")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{v4}) + if lang.IsTruthy(tmp14) { + tmp15 := lang.Apply(lang.InternKeywordSymbol, []any{v4}) + tmp10 = tmp15 } else { - var v16 any - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("string?")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.Apply(v19, []any{v4}) - if lang.IsTruthy(v20) { - v21 := lang.Apply(lang.InternKeywordString, []any{v4}) - v16 = v21 + var tmp16 any + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("string?")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.Apply(tmp19, []any{v4}) + if lang.IsTruthy(tmp20) { + tmp21 := lang.Apply(lang.InternKeywordString, []any{v4}) + tmp16 = tmp21 } else { - v16 = nil } - v10 = v16 + tmp10 = tmp16 } - v5 = v10 + tmp5 = tmp10 } - return v5 + return tmp5 case 2: v4 := args[0] _ = v4 v5 := args[1] _ = v5 - v6 := lang.Apply(lang.InternKeyword, []any{v4, v5}) - return v6 + tmp6 := lang.Apply(lang.InternKeyword, []any{v4, v5}) + return tmp6 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v4 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp4 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // keyword? { - v0 := lang.NewSymbol("keyword?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a Keyword", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(563), lang.NewKeyword("end-line"), int(563))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("keyword?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a Keyword", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(563), lang.NewKeyword("end-line"), int(563))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) } - v6 := v5.Get() - v7 := lang.Apply(v6, []any{lang.Keyword, v3}) - return v7 + tmp6 := tmp5.Get() + tmp7 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() + tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) + return tmp8 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // last { - v0 := lang.NewSymbol("last").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return the last item in coll, in linear time", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(262), lang.NewKeyword("end-line"), int(266))).(*lang.Symbol) - var v2 lang.FnFunc + tmp0 := lang.NewSymbol("last").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return the last item in coll, in linear time", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(262), lang.NewKeyword("end-line"), int(266))).(*lang.Symbol) + var tmp2 lang.FnFunc { // function last - v2 = lang.NewFnFunc(func(args ...any) any { + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 recur_loop_32: - var v5 any - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("next")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{v4}) - if lang.IsTruthy(v9) { - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("next")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{v4}) - var v10 any = v14 - v4 = v10 + var tmp5 any + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("next")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.Apply(tmp8, []any{v4}) + if lang.IsTruthy(tmp9) { + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("next")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{v4}) + var tmp10 any = tmp14 + v4 = tmp10 goto recur_loop_32 } else { - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("first")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("first")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{v4}) - v5 = v18 + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{v4}) + tmp5 = tmp18 } - return v5 + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(266), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(269), lang.NewKeyword("end-column"), int(21))).(lang.FnFunc) - v3 := v2 + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(266), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(269), lang.NewKeyword("end-column"), int(21))).(lang.FnFunc) + v3 = tmp2 _ = v3 } - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // lazy-cat { - v0 := lang.NewSymbol("lazy-cat").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Expands to code which yields a lazy sequence of the concatenation\n of the supplied colls. Each coll expr is not evaluated until it is\n needed. \n\n (lazy-cat xs ys zs) === (concat (lazy-seq xs) (lazy-seq ys) (lazy-seq zs))", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4636), lang.NewKeyword("end-line"), int(4636))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("lazy-cat").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Expands to code which yields a lazy sequence of the concatenation\n of the supplied colls. Each coll expr is not evaluated until it is\n needed. \n\n (lazy-cat xs ys zs) === (concat (lazy-seq xs) (lazy-seq ys) (lazy-seq zs))", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4636), lang.NewKeyword("end-line"), int(4636))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 2 { @@ -46187,70 +46303,71 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.NewList(args[2:]...) - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("seq")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("concat")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("list")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.Apply(v14, []any{lang.NewSymbol("glojure.core/concat")}) - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("map")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - var v19 lang.FnFunc - v19 = lang.NewFnFunc(func(args ...any) any { + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("seq")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("concat")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("list")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("glojure.core/concat")}) + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("map")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + var tmp19 lang.FnFunc + tmp19 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v20 := args[0] _ = v20 - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("list")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.Apply(v23, []any{lang.NewSymbol("glojure.core/lazy-seq"), v20}) - return v24 + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("list")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.Apply(tmp23, []any{lang.NewSymbol("glojure.core/lazy-seq"), v20}) + return tmp24 }) - v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4644), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(4644), lang.NewKeyword("end-column"), int(37)) - v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) + tmp20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4644), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(4644), lang.NewKeyword("end-column"), int(37)) + tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) if err != nil { panic(err) } - v22 := lang.Apply(v18, []any{v21, v5}) - v23 := lang.Apply(v11, []any{v15, v22}) - v24 := lang.Apply(v8, []any{v23}) - return v24 + tmp22 := lang.Apply(tmp18, []any{tmp21, v5}) + tmp23 := lang.Apply(tmp11, []any{tmp15, tmp22}) + tmp24 := lang.Apply(tmp8, []any{tmp23}) + return tmp24 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // lazy-seq { - v0 := lang.NewSymbol("lazy-seq").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Takes a body of expressions that returns an ISeq or nil, and yields\n a Seqable object that will invoke the body only the first time seq\n is called, and will cache the result and return it on all subsequent\n seq calls. See also - realized?", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(676), lang.NewKeyword("end-line"), int(676))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("lazy-seq").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Takes a body of expressions that returns an ISeq or nil, and yields\n a Seqable object that will invoke the body only the first time seq\n is called, and will cache the result and return it on all subsequent\n seq calls. See also - realized?", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(676), lang.NewKeyword("end-line"), int(676))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 2 { @@ -46260,41 +46377,42 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.NewList(args[2:]...) - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("list")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("list*")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.NewVector() - v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(683), lang.NewKeyword("column"), int(101), lang.NewKeyword("end-line"), int(683), lang.NewKeyword("end-column"), int(102)) - v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("list")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("list*")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.NewVector() + tmp13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(683), lang.NewKeyword("column"), int(101), lang.NewKeyword("end-line"), int(683), lang.NewKeyword("end-column"), int(102)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) if err != nil { panic(err) } - v15 := lang.Apply(v11, []any{lang.NewSymbol("fn*"), v14, v5}) - v16 := lang.Apply(v8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewLazySeq"), v15}) - return v16 + tmp15 := lang.Apply(tmp11, []any{lang.NewSymbol("fn*"), tmp14, v5}) + tmp16 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewLazySeq"), tmp15}) + return tmp16 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // let { - v0 := lang.NewSymbol("let").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "binding => binding-form init-expr\n binding-form => name, or destructuring-form\n destructuring-form => map-destructure-form, or seq-destructure-form\n\n Evaluates the exprs in a lexical context in which the symbols in\n the binding-forms are bound to their respective init-exprs or parts\n therein.\n\n See https://glojure.org/reference/special_forms#binding-forms for\n more information about destructuring.", lang.NewKeyword("forms"), lang.NewVector(lang.NewList(lang.NewSymbol("let"), lang.NewVector(lang.NewSymbol("bindings*")), lang.NewSymbol("exprs*"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4496), lang.NewKeyword("end-line"), int(4496), lang.NewKeyword("special-form"), true)).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("let").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "binding => binding-form init-expr\n binding-form => name, or destructuring-form\n destructuring-form => map-destructure-form, or seq-destructure-form\n\n Evaluates the exprs in a lexical context in which the symbols in\n the binding-forms are bound to their respective init-exprs or parts\n therein.\n\n See https://glojure.org/reference/special_forms#binding-forms for\n more information about destructuring.", lang.NewKeyword("forms"), lang.NewVector(lang.NewList(lang.NewSymbol("let"), lang.NewVector(lang.NewSymbol("bindings*")), lang.NewSymbol("exprs*"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4496), lang.NewKeyword("end-line"), int(4496), lang.NewKeyword("special-form"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 3 { @@ -46306,150 +46424,148 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - var v7 any - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v5}) - if lang.IsTruthy(v11) { - v7 = nil + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("vector?")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v5}) + if lang.IsTruthy(tmp11) { } else { - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("str")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("first")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{v3}) - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("meta")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v3}) - v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) - v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) - v28 := lang.Apply(lang.NewIllegalArgumentError, []any{v27}) - panic(v28) - } - _ = v7 - var v29 any - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("even?")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) - } - v32 := v31.Get() - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("count")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - v36 := lang.Apply(v35, []any{v5}) - v37 := lang.Apply(v32, []any{v36}) - if lang.IsTruthy(v37) { - v29 = nil + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("str")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("first")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("*ns*")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("meta")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.Apply(tmp24, []any{v3}) + tmp26 := lang.Apply(lang.NewKeyword("line"), []any{tmp25}) + tmp27 := lang.Apply(tmp14, []any{tmp18, " requires ", "a vector for its binding", " in ", tmp21, ":", tmp26}) + tmp28 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp27}) + panic(tmp28) + } + _ = tmp7 + var tmp29 any + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("even?")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) + } + tmp32 := tmp31.Get() + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("count")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) + } + tmp35 := tmp34.Get() + tmp36 := lang.Apply(tmp35, []any{v5}) + tmp37 := lang.Apply(tmp32, []any{tmp36}) + if lang.IsTruthy(tmp37) { } else { - v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v39 := v38.FindInternedVar(lang.NewSymbol("str")) - if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) - } - v40 := v39.Get() - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("first")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) - } - v43 := v42.Get() - v44 := lang.Apply(v43, []any{v3}) - v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) - if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) - } - v47 := v46.Get() - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("meta")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v3}) - v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) - v53 := lang.Apply(v40, []any{v44, " requires ", "an even number of forms in binding vector", " in ", v47, ":", v52}) - v54 := lang.Apply(lang.NewIllegalArgumentError, []any{v53}) - panic(v54) - } - _ = v29 - _ = nil - v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v56 := v55.FindInternedVar(lang.NewSymbol("seq")) - if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) - } - v57 := v56.Get() - v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v59 := v58.FindInternedVar(lang.NewSymbol("concat")) - if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) - } - v60 := v59.Get() - v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v62 := v61.FindInternedVar(lang.NewSymbol("list")) - if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) - } - v63 := v62.Get() - v64 := lang.Apply(v63, []any{lang.NewSymbol("let*")}) - v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v66 := v65.FindInternedVar(lang.NewSymbol("list")) - if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) - } - v67 := v66.Get() - v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v69 := v68.FindInternedVar(lang.NewSymbol("destructure")) - if v69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) - } - v70 := v69.Get() - v71 := lang.Apply(v70, []any{v5}) - v72 := lang.Apply(v67, []any{v71}) - v73 := lang.Apply(v60, []any{v64, v72, v6}) - v74 := lang.Apply(v57, []any{v73}) - return v74 - } - }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp39 := tmp38.FindInternedVar(lang.NewSymbol("str")) + if tmp39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) + } + tmp40 := tmp39.Get() + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("first")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := lang.Apply(tmp43, []any{v3}) + tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp46 := tmp45.FindInternedVar(lang.NewSymbol("*ns*")) + if tmp46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) + } + tmp47 := tmp46.Get() + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("meta")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v3}) + tmp52 := lang.Apply(lang.NewKeyword("line"), []any{tmp51}) + tmp53 := lang.Apply(tmp40, []any{tmp44, " requires ", "an even number of forms in binding vector", " in ", tmp47, ":", tmp52}) + tmp54 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp53}) + panic(tmp54) + } + _ = tmp29 + tmp55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp56 := tmp55.FindInternedVar(lang.NewSymbol("seq")) + if tmp56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp56))) + } + tmp57 := tmp56.Get() + tmp58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp59 := tmp58.FindInternedVar(lang.NewSymbol("concat")) + if tmp59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp59))) + } + tmp60 := tmp59.Get() + tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp62 := tmp61.FindInternedVar(lang.NewSymbol("list")) + if tmp62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) + } + tmp63 := tmp62.Get() + tmp64 := lang.Apply(tmp63, []any{lang.NewSymbol("let*")}) + tmp65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp66 := tmp65.FindInternedVar(lang.NewSymbol("list")) + if tmp66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp66))) + } + tmp67 := tmp66.Get() + tmp68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp69 := tmp68.FindInternedVar(lang.NewSymbol("destructure")) + if tmp69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp69))) + } + tmp70 := tmp69.Get() + tmp71 := lang.Apply(tmp70, []any{v5}) + tmp72 := lang.Apply(tmp67, []any{tmp71}) + tmp73 := lang.Apply(tmp60, []any{tmp64, tmp72, v6}) + tmp74 := lang.Apply(tmp57, []any{tmp73}) + return tmp74 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // letfn { - v0 := lang.NewSymbol("letfn").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fnspecs"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "fnspec ==> (fname [params*] exprs) or (fname ([params*] exprs)+)\n\n Takes a vector of function specs and a body, and generates a set of\n bindings of functions to their names. All of the names are available\n in all of the definitions of the functions, as well as the body.", lang.NewKeyword("forms"), lang.NewVector(lang.NewList(lang.NewSymbol("letfn"), lang.NewVector(lang.NewSymbol("fnspecs*")), lang.NewSymbol("exprs*"))), lang.NewKeyword("url"), nil, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6545), lang.NewKeyword("end-line"), int(6545), lang.NewKeyword("special-form"), true)).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("letfn").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fnspecs"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "fnspec ==> (fname [params*] exprs) or (fname ([params*] exprs)+)\n\n Takes a vector of function specs and a body, and generates a set of\n bindings of functions to their names. All of the names are available\n in all of the definitions of the functions, as well as the body.", lang.NewKeyword("forms"), lang.NewVector(lang.NewList(lang.NewSymbol("letfn"), lang.NewVector(lang.NewSymbol("fnspecs*")), lang.NewSymbol("exprs*"))), lang.NewKeyword("url"), nil, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6545), lang.NewKeyword("end-line"), int(6545), lang.NewKeyword("special-form"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 3 { @@ -46461,286 +46577,287 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("seq")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("concat")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("list")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{lang.NewSymbol("letfn*")}) - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("list")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("vec")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("interleave")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("map")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) - } - v28 := v27.Get() - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("first")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.Apply(v28, []any{v31, v5}) - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("map")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - var v36 lang.FnFunc - v36 = lang.NewFnFunc(func(args ...any) any { + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("seq")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("concat")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("list")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("letfn*")}) + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("list")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("vec")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("interleave")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("map")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) + } + tmp28 := tmp27.Get() + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("first")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.Apply(tmp28, []any{tmp31, v5}) + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("map")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) + } + tmp35 := tmp34.Get() + var tmp36 lang.FnFunc + tmp36 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v37 := args[0] _ = v37 - v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v39 := v38.FindInternedVar(lang.NewSymbol("cons")) - if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) - } - v40 := v39.Get() - v41 := lang.Apply(v40, []any{lang.NewSymbol("glojure.core/fn"), v37}) - return v41 + tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp39 := tmp38.FindInternedVar(lang.NewSymbol("cons")) + if tmp39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) + } + tmp40 := tmp39.Get() + tmp41 := lang.Apply(tmp40, []any{lang.NewSymbol("glojure.core/fn"), v37}) + return tmp41 }) - v37 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6555), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(6555), lang.NewKeyword("end-column"), int(47)) - v38, err := lang.WithMeta(v36, v37.(lang.IPersistentMap)) + tmp37 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6555), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(6555), lang.NewKeyword("end-column"), int(47)) + tmp38, err := lang.WithMeta(tmp36, tmp37.(lang.IPersistentMap)) if err != nil { panic(err) } - v39 := lang.Apply(v35, []any{v38, v5}) - v40 := lang.Apply(v25, []any{v32, v39}) - v41 := lang.Apply(v22, []any{v40}) - v42 := lang.Apply(v19, []any{v41}) - v43 := lang.Apply(v12, []any{v16, v42, v6}) - v44 := lang.Apply(v9, []any{v43}) - return v44 + tmp39 := lang.Apply(tmp35, []any{tmp38, v5}) + tmp40 := lang.Apply(tmp25, []any{tmp32, tmp39}) + tmp41 := lang.Apply(tmp22, []any{tmp40}) + tmp42 := lang.Apply(tmp19, []any{tmp41}) + tmp43 := lang.Apply(tmp12, []any{tmp16, tmp42, v6}) + tmp44 := lang.Apply(tmp9, []any{tmp43}) + return tmp44 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // libspec? { - v0 := lang.NewSymbol("libspec?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is a libspec", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5848), lang.NewKeyword("end-line"), int(5848), lang.NewKeyword("private"), true)).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("libspec?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is a libspec", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5848), lang.NewKeyword("end-line"), int(5848), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any + var tmp4 any { // let // let binding "or__0__auto__" - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("symbol?")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v3}) - var v9 any = v8 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("symbol?")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v3}) + var v9 any = tmp8 _ = v9 - var v10 any + var tmp10 any if lang.IsTruthy(v9) { - v10 = v9 + tmp10 = v9 } else { - var v11 any + var tmp11 any { // let // let binding "and__0__auto__" - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("vector?")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.Apply(v14, []any{v3}) - var v16 any = v15 + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("vector?")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.Apply(tmp14, []any{v3}) + var v16 any = tmp15 _ = v16 - var v17 any + var tmp17 any if lang.IsTruthy(v16) { - var v18 any + var tmp18 any { // let // let binding "or__0__auto__" - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("nil?")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("nil?")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) } - v21 := v20.Get() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("second")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + tmp21 := tmp20.Get() + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("second")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v3}) - v26 := lang.Apply(v21, []any{v25}) - var v27 any = v26 + tmp24 := tmp23.Get() + tmp25 := lang.Apply(tmp24, []any{v3}) + tmp26 := lang.Apply(tmp21, []any{tmp25}) + var v27 any = tmp26 _ = v27 - var v28 any + var tmp28 any if lang.IsTruthy(v27) { - v28 = v27 + tmp28 = v27 } else { - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("keyword?")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("keyword?")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) } - v31 := v30.Get() - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("second")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + tmp31 := tmp30.Get() + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("second")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{v3}) - v36 := lang.Apply(v31, []any{v35}) - v28 = v36 + tmp34 := tmp33.Get() + tmp35 := lang.Apply(tmp34, []any{v3}) + tmp36 := lang.Apply(tmp31, []any{tmp35}) + tmp28 = tmp36 } - v18 = v28 + tmp18 = tmp28 } // end let - v17 = v18 + tmp17 = tmp18 } else { - v17 = v16 + tmp17 = v16 } - v11 = v17 + tmp11 = tmp17 } // end let - v10 = v11 + tmp10 = tmp11 } - v4 = v10 + tmp4 = tmp10 } // end let - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // lift-ns { - v0 := lang.NewSymbol("lift-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"))), lang.NewKeyword("doc"), "Returns [lifted-ns lifted-kvs] or nil if m can't be lifted.", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(261), lang.NewKeyword("end-line"), int(261), lang.NewKeyword("private"), true)).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("lift-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"))), lang.NewKeyword("doc"), "Returns [lifted-ns lifted-kvs] or nil if m can't be lifted.", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(261), lang.NewKeyword("end-line"), int(261), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("*print-namespace-maps*")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - if lang.IsTruthy(v7) { - var v8 any + var tmp4 any + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("*print-namespace-maps*")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + if lang.IsTruthy(tmp7) { + var tmp8 any { // let // let binding "ns" var v9 any = nil _ = v9 // let binding "G__221" - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("seq")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{v3}) - var v14 any = v13 + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("seq")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{v3}) + var v14 any = tmp13 _ = v14 // let binding "vec__222" var v15 any = v14 _ = v15 // let binding "seq__223" - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("seq")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{v15}) - var v20 any = v19 + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("seq")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{v15}) + var v20 any = tmp19 _ = v20 // let binding "first__224" - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("first")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.Apply(v23, []any{v20}) - var v25 any = v24 + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("first")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.Apply(tmp23, []any{v20}) + var v25 any = tmp24 _ = v25 // let binding "seq__223" - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("next")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) - } - v28 := v27.Get() - v29 := lang.Apply(v28, []any{v20}) - var v30 any = v29 + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("next")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) + } + tmp28 := tmp27.Get() + tmp29 := lang.Apply(tmp28, []any{v20}) + var v30 any = tmp29 _ = v30 // let binding "vec__225" var v31 any = v25 _ = v31 // let binding "k" - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("nth")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{v31, int64(0), nil}) - var v36 any = v35 + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("nth")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.Apply(tmp34, []any{v31, int64(0), nil}) + var v36 any = tmp35 _ = v36 // let binding "v" - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("nth")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.Apply(v39, []any{v31, int64(1), nil}) - var v41 any = v40 + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("nth")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.Apply(tmp39, []any{v31, int64(1), nil}) + var v41 any = tmp40 _ = v41 // let binding "entry" var v42 any = v31 @@ -46749,15 +46866,15 @@ func init() { var v43 any = v30 _ = v43 // let binding "kvs" - v44 := lang.NewVector() - v45 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(267), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(267), lang.NewKeyword("end-column"), int(17)) - v46, err := lang.WithMeta(v44, v45.(lang.IPersistentMap)) + tmp44 := lang.NewVector() + tmp45 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(267), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(267), lang.NewKeyword("end-column"), int(17)) + tmp46, err := lang.WithMeta(tmp44, tmp45.(lang.IPersistentMap)) if err != nil { panic(err) } - var v47 any = v46 + var v47 any = tmp46 _ = v47 - var v48 any + var tmp48 any { // let // let binding "ns" var v49 any = v9 @@ -46769,7 +46886,7 @@ func init() { var v51 any = v47 _ = v51 for { - var v52 any + var tmp52 any { // let // let binding "ns" var v53 any = v49 @@ -46778,57 +46895,57 @@ func init() { var v54 any = v50 _ = v54 // let binding "seq__229" - v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v56 := v55.FindInternedVar(lang.NewSymbol("seq")) - if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) + tmp55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp56 := tmp55.FindInternedVar(lang.NewSymbol("seq")) + if tmp56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp56))) } - v57 := v56.Get() - v58 := lang.Apply(v57, []any{v54}) - var v59 any = v58 + tmp57 := tmp56.Get() + tmp58 := lang.Apply(tmp57, []any{v54}) + var v59 any = tmp58 _ = v59 // let binding "first__230" - v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v61 := v60.FindInternedVar(lang.NewSymbol("first")) - if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) + tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp61 := tmp60.FindInternedVar(lang.NewSymbol("first")) + if tmp61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) } - v62 := v61.Get() - v63 := lang.Apply(v62, []any{v59}) - var v64 any = v63 + tmp62 := tmp61.Get() + tmp63 := lang.Apply(tmp62, []any{v59}) + var v64 any = tmp63 _ = v64 // let binding "seq__229" - v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v66 := v65.FindInternedVar(lang.NewSymbol("next")) - if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) + tmp65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp66 := tmp65.FindInternedVar(lang.NewSymbol("next")) + if tmp66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp66))) } - v67 := v66.Get() - v68 := lang.Apply(v67, []any{v59}) - var v69 any = v68 + tmp67 := tmp66.Get() + tmp68 := lang.Apply(tmp67, []any{v59}) + var v69 any = tmp68 _ = v69 // let binding "vec__231" var v70 any = v64 _ = v70 // let binding "k" - v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v72 := v71.FindInternedVar(lang.NewSymbol("nth")) - if v72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) + tmp71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp72 := tmp71.FindInternedVar(lang.NewSymbol("nth")) + if tmp72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp72))) } - v73 := v72.Get() - v74 := lang.Apply(v73, []any{v70, int64(0), nil}) - var v75 any = v74 + tmp73 := tmp72.Get() + tmp74 := lang.Apply(tmp73, []any{v70, int64(0), nil}) + var v75 any = tmp74 _ = v75 // let binding "v" - v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v77 := v76.FindInternedVar(lang.NewSymbol("nth")) - if v77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) + tmp76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp77 := tmp76.FindInternedVar(lang.NewSymbol("nth")) + if tmp77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp77))) } - v78 := v77.Get() - v79 := lang.Apply(v78, []any{v70, int64(1), nil}) - var v80 any = v79 + tmp78 := tmp77.Get() + tmp79 := lang.Apply(tmp78, []any{v70, int64(1), nil}) + var v80 any = tmp79 _ = v80 // let binding "entry" var v81 any = v70 @@ -46839,265 +46956,260 @@ func init() { // let binding "kvs" var v83 any = v51 _ = v83 - var v84 any + var tmp84 any if lang.IsTruthy(v81) { - var v85 any - v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v87 := v86.FindInternedVar(lang.NewSymbol("qualified-ident?")) - if v87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) + var tmp85 any + tmp86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp87 := tmp86.FindInternedVar(lang.NewSymbol("qualified-ident?")) + if tmp87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp87))) } - v88 := v87.Get() - v89 := lang.Apply(v88, []any{v75}) - if lang.IsTruthy(v89) { - var v90 any + tmp88 := tmp87.Get() + tmp89 := lang.Apply(tmp88, []any{v75}) + if lang.IsTruthy(tmp89) { + var tmp90 any if lang.IsTruthy(v53) { - var v91 any - v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v93 := v92.FindInternedVar(lang.NewSymbol("=")) - if v93.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) + var tmp91 any + tmp92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp93 := tmp92.FindInternedVar(lang.NewSymbol("=")) + if tmp93.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp93))) } - v94 := v93.Get() - v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v96 := v95.FindInternedVar(lang.NewSymbol("namespace")) - if v96.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) + tmp94 := tmp93.Get() + tmp95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp96 := tmp95.FindInternedVar(lang.NewSymbol("namespace")) + if tmp96.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp96))) } - v97 := v96.Get() - v98 := lang.Apply(v97, []any{v75}) - v99 := lang.Apply(v94, []any{v53, v98}) - if lang.IsTruthy(v99) { - var v100 any = v53 - var v101 any = v82 - v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v104 := v103.FindInternedVar(lang.NewSymbol("conj")) - if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) + tmp97 := tmp96.Get() + tmp98 := lang.Apply(tmp97, []any{v75}) + tmp99 := lang.Apply(tmp94, []any{v53, tmp98}) + if lang.IsTruthy(tmp99) { + var tmp100 any = v53 + var tmp101 any = v82 + tmp103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp104 := tmp103.FindInternedVar(lang.NewSymbol("conj")) + if tmp104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp104))) } - v105 := v104.Get() - v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v107 := v106.FindInternedVar(lang.NewSymbol("strip-ns")) - if v107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) + tmp105 := tmp104.Get() + tmp106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp107 := tmp106.FindInternedVar(lang.NewSymbol("strip-ns")) + if tmp107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp107))) } - v108 := v107.Get() - v109 := lang.Apply(v108, []any{v75}) - v110 := lang.NewVector(v109, v80) - v111 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(272), lang.NewKeyword("column"), int(43), lang.NewKeyword("end-line"), int(272), lang.NewKeyword("end-column"), int(58)) - v112, err := lang.WithMeta(v110, v111.(lang.IPersistentMap)) + tmp108 := tmp107.Get() + tmp109 := lang.Apply(tmp108, []any{v75}) + tmp110 := lang.NewVector(tmp109, v80) + tmp111 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(272), lang.NewKeyword("column"), int(43), lang.NewKeyword("end-line"), int(272), lang.NewKeyword("end-column"), int(58)) + tmp112, err := lang.WithMeta(tmp110, tmp111.(lang.IPersistentMap)) if err != nil { panic(err) } - v113 := lang.Apply(v105, []any{v83, v112}) - var v102 any = v113 - v49 = v100 - v50 = v101 - v51 = v102 + tmp113 := lang.Apply(tmp105, []any{v83, tmp112}) + var tmp102 any = tmp113 + v49 = tmp100 + v50 = tmp101 + v51 = tmp102 continue } else { - v91 = nil } - v90 = v91 + tmp90 = tmp91 } else { - var v114 any + var tmp114 any { // let // let binding "temp__0__auto__" - v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v116 := v115.FindInternedVar(lang.NewSymbol("namespace")) - if v116.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) + tmp115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp116 := tmp115.FindInternedVar(lang.NewSymbol("namespace")) + if tmp116.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp116))) } - v117 := v116.Get() - v118 := lang.Apply(v117, []any{v75}) - var v119 any = v118 + tmp117 := tmp116.Get() + tmp118 := lang.Apply(tmp117, []any{v75}) + var v119 any = tmp118 _ = v119 - var v120 any + var tmp120 any if lang.IsTruthy(v119) { - var v121 any + var tmp121 any { // let // let binding "new-ns" var v122 any = v119 _ = v122 - var v123 any = v122 - var v124 any = v82 - v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v127 := v126.FindInternedVar(lang.NewSymbol("conj")) - if v127.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) + var tmp123 any = v122 + var tmp124 any = v82 + tmp126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp127 := tmp126.FindInternedVar(lang.NewSymbol("conj")) + if tmp127.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp127))) } - v128 := v127.Get() - v129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v130 := v129.FindInternedVar(lang.NewSymbol("strip-ns")) - if v130.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v130))) + tmp128 := tmp127.Get() + tmp129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp130 := tmp129.FindInternedVar(lang.NewSymbol("strip-ns")) + if tmp130.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp130))) } - v131 := v130.Get() - v132 := lang.Apply(v131, []any{v75}) - v133 := lang.NewVector(v132, v80) - v134 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(274), lang.NewKeyword("column"), int(47), lang.NewKeyword("end-line"), int(274), lang.NewKeyword("end-column"), int(62)) - v135, err := lang.WithMeta(v133, v134.(lang.IPersistentMap)) + tmp131 := tmp130.Get() + tmp132 := lang.Apply(tmp131, []any{v75}) + tmp133 := lang.NewVector(tmp132, v80) + tmp134 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(274), lang.NewKeyword("column"), int(47), lang.NewKeyword("end-line"), int(274), lang.NewKeyword("end-column"), int(62)) + tmp135, err := lang.WithMeta(tmp133, tmp134.(lang.IPersistentMap)) if err != nil { panic(err) } - v136 := lang.Apply(v128, []any{v83, v135}) - var v125 any = v136 - v49 = v123 - v50 = v124 - v51 = v125 + tmp136 := lang.Apply(tmp128, []any{v83, tmp135}) + var tmp125 any = tmp136 + v49 = tmp123 + v50 = tmp124 + v51 = tmp125 continue } // end let - v120 = v121 + tmp120 = tmp121 } else { - v120 = nil } - v114 = v120 + tmp114 = tmp120 } // end let - v90 = v114 + tmp90 = tmp114 } - v85 = v90 + tmp85 = tmp90 } else { - v85 = nil } - v84 = v85 + tmp84 = tmp85 } else { - v115 := lang.NewVector(v53, v83) - v116 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(275), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(275), lang.NewKeyword("end-column"), int(16)) - v117, err := lang.WithMeta(v115, v116.(lang.IPersistentMap)) + tmp115 := lang.NewVector(v53, v83) + tmp116 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(275), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(275), lang.NewKeyword("end-column"), int(16)) + tmp117, err := lang.WithMeta(tmp115, tmp116.(lang.IPersistentMap)) if err != nil { panic(err) } - v84 = v117 + tmp84 = tmp117 } - v52 = v84 + tmp52 = tmp84 } // end let - v48 = v52 + tmp48 = tmp52 break } } // end let - v8 = v48 + tmp8 = tmp48 } // end let - v4 = v8 + tmp4 = tmp8 } else { - v4 = nil } - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // line-seq { - v0 := lang.NewSymbol("line-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rdr"))), lang.NewKeyword("doc"), "Returns the lines of text from rdr as a lazy sequence of strings.\n rdr must implement java.io.BufferedReader.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3068), lang.NewKeyword("end-line"), int(3068))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("line-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rdr"))), lang.NewKeyword("doc"), "Returns the lines of text from rdr as a lazy sequence of strings.\n rdr must implement java.io.BufferedReader.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3068), lang.NewKeyword("end-line"), int(3068))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any + var tmp4 any { // let // let binding "temp__0__auto__" - v5, ok := lang.FieldOrMethod(v3, "readLine") + tmp5, ok := lang.FieldOrMethod(v3, "readLine") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "readLine"))) } - var v6 any - switch reflect.TypeOf(v5).Kind() { + var tmp6 any + switch reflect.TypeOf(tmp5).Kind() { case reflect.Func: - v6 = lang.Apply(v5, nil) + tmp6 = lang.Apply(tmp5, nil) default: - v6 = v5 + tmp6 = tmp5 } - var v7 any = v6 + var v7 any = tmp6 _ = v7 - var v8 any + var tmp8 any if lang.IsTruthy(v7) { - var v9 any + var tmp9 any { // let // let binding "line" var v10 any = v7 _ = v10 - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("cons")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - var v14 lang.FnFunc - v14 = lang.NewFnFunc(func(args ...any) any { + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("cons")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("line-seq")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("line-seq")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{v3}) - return v18 + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{v3}) + return tmp18 }) - v15 := lang.Apply(lang.NewLazySeq, []any{v14}) - v16 := lang.Apply(v13, []any{v10, v15}) - v9 = v16 + tmp15 := lang.Apply(lang.NewLazySeq, []any{tmp14}) + tmp16 := lang.Apply(tmp13, []any{v10, tmp15}) + tmp9 = tmp16 } // end let - v8 = v9 + tmp8 = tmp9 } else { - v8 = nil } - v4 = v8 + tmp4 = tmp8 } // end let - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // list { - v0 := lang.NewSymbol("list").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("items"))), lang.NewKeyword("doc"), "Creates a new list containing the items.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(15), lang.NewKeyword("end-line"), int(18))).(*lang.Symbol) - v1 := ns.InternWithValue(v0, nil, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp0 := lang.NewSymbol("list").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("items"))), lang.NewKeyword("doc"), "Creates a new list containing the items.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(15), lang.NewKeyword("end-line"), int(18))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // list* { - v0 := lang.NewSymbol("list*").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Creates a new seq containing the items prepended to the rest, the\n last of which will be treated as a sequence.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(641), lang.NewKeyword("end-line"), int(641))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("list*").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Creates a new seq containing the items prepended to the rest, the\n last of which will be treated as a sequence.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(641), lang.NewKeyword("end-line"), int(641))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.Apply(v6, []any{v3}) - return v7 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.Apply(tmp6, []any{v3}) + return tmp7 case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("cons")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v3, v4}) - return v8 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("cons")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v3, v4}) + return tmp8 case 3: v3 := args[0] _ = v3 @@ -47105,21 +47217,21 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("cons")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("cons")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.Apply(v11, []any{v4, v5}) - v13 := lang.Apply(v8, []any{v3, v12}) - return v13 + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("cons")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("cons")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.Apply(tmp11, []any{v4, v5}) + tmp13 := lang.Apply(tmp8, []any{v3, tmp12}) + return tmp13 case 4: v3 := args[0] _ = v3 @@ -47129,28 +47241,28 @@ func init() { _ = v5 v6 := args[3] _ = v6 - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("cons")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("cons")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("cons")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{v5, v6}) - v17 := lang.Apply(v12, []any{v4, v16}) - v18 := lang.Apply(v9, []any{v3, v17}) - return v18 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("cons")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("cons")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("cons")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{v5, v6}) + tmp17 := lang.Apply(tmp12, []any{v4, tmp16}) + tmp18 := lang.Apply(tmp9, []any{v3, tmp17}) + return tmp18 default: if len(args) < 4 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -47163,98 +47275,101 @@ func init() { _ = v5 v6 := args[3] _ = v6 - v7 := lang.NewList(args[4:]...) - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("cons")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("cons")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("cons")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("cons")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("spread")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.Apply(v22, []any{v7}) - v24 := lang.Apply(v19, []any{v6, v23}) - v25 := lang.Apply(v16, []any{v5, v24}) - v26 := lang.Apply(v13, []any{v4, v25}) - v27 := lang.Apply(v10, []any{v3, v26}) - return v27 - } - }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + var v7 any = lang.NewList(args[4:]...) + _ = v7 + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("cons")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("cons")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("cons")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("cons")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("spread")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.Apply(tmp22, []any{v7}) + tmp24 := lang.Apply(tmp19, []any{v6, tmp23}) + tmp25 := lang.Apply(tmp16, []any{v5, tmp24}) + tmp26 := lang.Apply(tmp13, []any{v4, tmp25}) + tmp27 := lang.Apply(tmp10, []any{v3, tmp26}) + return tmp27 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // list? { - v0 := lang.NewSymbol("list?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements IPersistentList", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6198), lang.NewKeyword("end-line"), int(6198))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("list?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements IPersistentList", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6198), lang.NewKeyword("end-line"), int(6198))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) } - v6 := v5.Get() - v7 := lang.Apply(v6, []any{lang.IPersistentList, v3}) - return v7 + tmp6 := tmp5.Get() + tmp7 := reflect.TypeOf((*lang.IPersistentList)(nil)).Elem() + tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) + return tmp8 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // load { - v0 := lang.NewSymbol("load").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("paths"))), lang.NewKeyword("doc"), "Loads Clojure code from resources in classpath. A path is interpreted as\n classpath-relative if it begins with a slash or relative to the root\n directory for the current namespace otherwise.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("redef"), true, lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6095), lang.NewKeyword("end-line"), int(6095))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("load").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("paths"))), lang.NewKeyword("doc"), "Loads Clojure code from resources in classpath. A path is interpreted as\n classpath-relative if it begins with a slash or relative to the root\n directory for the current namespace otherwise.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("redef"), true, lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6095), lang.NewKeyword("end-line"), int(6095))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v3 := lang.NewList(args[0:]...) - var v4 any + var v3 any = lang.NewList(args[0:]...) + _ = v3 + var tmp4 any { // let // let binding "seq_133" - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("seq")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v3}) - var v9 any = v8 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v3}) + var v9 any = tmp8 _ = v9 // let binding "chunk_134" var v10 any = nil @@ -47266,495 +47381,492 @@ func init() { var v12 any = int64(0) _ = v12 for { - var v13 any - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("<")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{v12, v11}) - if lang.IsTruthy(v17) { - var v18 any + var tmp13 any + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("<")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{v12, v11}) + if lang.IsTruthy(tmp17) { + var tmp18 any { // let // let binding "path" - v19, _ := lang.FieldOrMethod(v10, "nth") - if reflect.TypeOf(v19).Kind() != reflect.Func { + tmp19, _ := lang.FieldOrMethod(v10, "nth") + if reflect.TypeOf(tmp19).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) } - v20 := lang.Apply(v19, []any{v12}) - var v21 any = v20 + tmp20 := lang.Apply(tmp19, []any{v12}) + var v21 any = tmp20 _ = v21 - var v22 any + var tmp22 any { // let // let binding "path" - var v23 any - v24 := lang.Apply(strings8.HasPrefix, []any{v21, "/"}) - if lang.IsTruthy(v24) { - v23 = v21 + var tmp23 any + tmp24 := lang.Apply(strings8.HasPrefix, []any{v21, "/"}) + if lang.IsTruthy(tmp24) { + tmp23 = v21 } else { - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("str")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("str")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) } - v27 := v26.Get() - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("root-directory")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + tmp27 := tmp26.Get() + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("root-directory")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) } - v30 := v29.Get() - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("ns-name")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + tmp30 := tmp29.Get() + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("ns-name")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) } - v33 := v32.Get() - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("*ns*")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + tmp33 := tmp32.Get() + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("*ns*")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) } - v36 := v35.Get() - v37 := lang.Apply(v33, []any{v36}) - v38 := lang.Apply(v30, []any{v37}) - v39 := lang.Apply(v27, []any{v38, lang.NewChar(47), v21}) - v23 = v39 + tmp36 := tmp35.Get() + tmp37 := lang.Apply(tmp33, []any{tmp36}) + tmp38 := lang.Apply(tmp30, []any{tmp37}) + tmp39 := lang.Apply(tmp27, []any{tmp38, lang.NewChar(47), v21}) + tmp23 = tmp39 } - var v40 any = v23 + var v40 any = tmp23 _ = v40 - var v41 any - v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v43 := v42.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) - if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) + var tmp41 any + tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp43 := tmp42.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) + if tmp43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) } - v44 := v43.Get() - if lang.IsTruthy(v44) { - v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v46 := v45.FindInternedVar(lang.NewSymbol("printf")) - if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) + tmp44 := tmp43.Get() + if lang.IsTruthy(tmp44) { + tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp46 := tmp45.FindInternedVar(lang.NewSymbol("printf")) + if tmp46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) } - v47 := v46.Get() - v48 := lang.Apply(v47, []any{"(glojure.core/load \"%s\")\n", v40}) - _ = v48 - v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v50 := v49.FindInternedVar(lang.NewSymbol("flush")) - if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) + tmp47 := tmp46.Get() + tmp48 := lang.Apply(tmp47, []any{"(glojure.core/load \"%s\")\n", v40}) + _ = tmp48 + tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp50 := tmp49.FindInternedVar(lang.NewSymbol("flush")) + if tmp50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) } - v51 := v50.Get() - v52 := lang.Apply(v51, nil) - v41 = v52 + tmp51 := tmp50.Get() + tmp52 := lang.Apply(tmp51, nil) + tmp41 = tmp52 } else { - v41 = nil } - _ = v41 - v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v54 := v53.FindInternedVar(lang.NewSymbol("check-cyclic-dependency")) - if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) + _ = tmp41 + tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp54 := tmp53.FindInternedVar(lang.NewSymbol("check-cyclic-dependency")) + if tmp54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) } - v55 := v54.Get() - v56 := lang.Apply(v55, []any{v40}) - _ = v56 - var v57 any - v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v59 := v58.FindInternedVar(lang.NewSymbol("=")) - if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) + tmp55 := tmp54.Get() + tmp56 := lang.Apply(tmp55, []any{v40}) + _ = tmp56 + var tmp57 any + tmp58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp59 := tmp58.FindInternedVar(lang.NewSymbol("=")) + if tmp59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp59))) } - v60 := v59.Get() - v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v62 := v61.FindInternedVar(lang.NewSymbol("first")) - if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) + tmp60 := tmp59.Get() + tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp62 := tmp61.FindInternedVar(lang.NewSymbol("first")) + if tmp62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) } - v63 := v62.Get() - v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v65 := v64.FindInternedVar(lang.NewSymbol("*pending-paths*")) - if v65.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) + tmp63 := tmp62.Get() + tmp64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp65 := tmp64.FindInternedVar(lang.NewSymbol("*pending-paths*")) + if tmp65.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp65))) } - v66 := v65.Get() - v67 := lang.Apply(v63, []any{v66}) - v68 := lang.Apply(v60, []any{v40, v67}) - if lang.IsTruthy(v68) { - v57 = nil + tmp66 := tmp65.Get() + tmp67 := lang.Apply(tmp63, []any{tmp66}) + tmp68 := lang.Apply(tmp60, []any{v40, tmp67}) + if lang.IsTruthy(tmp68) { } else { - var v69 any + var tmp69 any { // let - v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v71 := v70.FindInternedVar(lang.NewSymbol("push-thread-bindings")) - if v71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) + tmp70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp71 := tmp70.FindInternedVar(lang.NewSymbol("push-thread-bindings")) + if tmp71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp71))) } - v72 := v71.Get() - v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v74 := v73.FindInternedVar(lang.NewSymbol("hash-map")) - if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) + tmp72 := tmp71.Get() + tmp73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp74 := tmp73.FindInternedVar(lang.NewSymbol("hash-map")) + if tmp74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp74))) } - v75 := v74.Get() - v76 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*pending-paths*")) - v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v78 := v77.FindInternedVar(lang.NewSymbol("conj")) - if v78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) + tmp75 := tmp74.Get() + tmp76 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*pending-paths*")) + tmp77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp78 := tmp77.FindInternedVar(lang.NewSymbol("conj")) + if tmp78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp78))) } - v79 := v78.Get() - v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v81 := v80.FindInternedVar(lang.NewSymbol("*pending-paths*")) - if v81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) + tmp79 := tmp78.Get() + tmp80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp81 := tmp80.FindInternedVar(lang.NewSymbol("*pending-paths*")) + if tmp81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp81))) } - v82 := v81.Get() - v83 := lang.Apply(v79, []any{v82, v40}) - v84 := lang.Apply(v75, []any{v76, v83}) - v85 := lang.Apply(v72, []any{v84}) - _ = v85 - var v86 any + tmp82 := tmp81.Get() + tmp83 := lang.Apply(tmp79, []any{tmp82, v40}) + tmp84 := lang.Apply(tmp75, []any{tmp76, tmp83}) + tmp85 := lang.Apply(tmp72, []any{tmp84}) + _ = tmp85 + var tmp86 any func() { defer func() { - v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v88 := v87.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) - if v88.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) + tmp87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp88 := tmp87.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) + if tmp88.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp88))) } - v89 := v88.Get() - v90 := lang.Apply(v89, nil) + tmp89 := tmp88.Get() + tmp90 := lang.Apply(tmp89, nil) + _ = tmp90 }() - v91 := lang.Apply(strings8.TrimPrefix, []any{v40, "/"}) - v92, _ := lang.FieldOrMethod(runtime4.RT, "Load") - if reflect.TypeOf(v92).Kind() != reflect.Func { + tmp91 := lang.Apply(strings8.TrimPrefix, []any{v40, "/"}) + tmp92, _ := lang.FieldOrMethod(runtime4.RT, "Load") + if reflect.TypeOf(tmp92).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Load is not a function"))) } - v93 := lang.Apply(v92, []any{v91}) - v86 = v93 + tmp93 := lang.Apply(tmp92, []any{tmp91}) + tmp86 = tmp93 }() - v69 = v86 + tmp69 = tmp86 } // end let - v57 = v69 + tmp57 = tmp69 } - v22 = v57 + tmp22 = tmp57 } // end let - _ = v22 - var v23 any = v9 - var v24 any = v10 - var v25 any = v11 - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("unchecked-inc")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + _ = tmp22 + var tmp23 any = v9 + var tmp24 any = v10 + var tmp25 any = v11 + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("unchecked-inc")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{v12}) - var v26 any = v30 - v9 = v23 - v10 = v24 - v11 = v25 - v12 = v26 + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{v12}) + var tmp26 any = tmp30 + v9 = tmp23 + v10 = tmp24 + v11 = tmp25 + v12 = tmp26 continue } // end let - v13 = v18 + tmp13 = tmp18 } else { - var v19 any + var tmp19 any { // let // let binding "temp__0__auto__" - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("seq")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("seq")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) } - v22 := v21.Get() - v23 := lang.Apply(v22, []any{v9}) - var v24 any = v23 + tmp22 := tmp21.Get() + tmp23 := lang.Apply(tmp22, []any{v9}) + var v24 any = tmp23 _ = v24 - var v25 any + var tmp25 any if lang.IsTruthy(v24) { - var v26 any + var tmp26 any { // let // let binding "seq_133" var v27 any = v24 _ = v27 - var v28 any - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("chunked-seq?")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + var tmp28 any + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("chunked-seq?")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) } - v31 := v30.Get() - v32 := lang.Apply(v31, []any{v27}) - if lang.IsTruthy(v32) { - var v33 any + tmp31 := tmp30.Get() + tmp32 := lang.Apply(tmp31, []any{v27}) + if lang.IsTruthy(tmp32) { + var tmp33 any { // let // let binding "c__0__auto__" - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("chunk-first")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("chunk-first")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) } - v36 := v35.Get() - v37 := lang.Apply(v36, []any{v27}) - var v38 any = v37 + tmp36 := tmp35.Get() + tmp37 := lang.Apply(tmp36, []any{v27}) + var v38 any = tmp37 _ = v38 - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("chunk-rest")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("chunk-rest")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) } - v42 := v41.Get() - v43 := lang.Apply(v42, []any{v27}) - var v39 any = v43 - var v44 any = v38 - v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v47 := v46.FindInternedVar(lang.NewSymbol("int")) - if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) + tmp42 := tmp41.Get() + tmp43 := lang.Apply(tmp42, []any{v27}) + var tmp39 any = tmp43 + var tmp44 any = v38 + tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp47 := tmp46.FindInternedVar(lang.NewSymbol("int")) + if tmp47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) } - v48 := v47.Get() - v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v50 := v49.FindInternedVar(lang.NewSymbol("count")) - if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) + tmp48 := tmp47.Get() + tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp50 := tmp49.FindInternedVar(lang.NewSymbol("count")) + if tmp50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) } - v51 := v50.Get() - v52 := lang.Apply(v51, []any{v38}) - v53 := lang.Apply(v48, []any{v52}) - var v45 any = v53 - v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v56 := v55.FindInternedVar(lang.NewSymbol("int")) - if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) + tmp51 := tmp50.Get() + tmp52 := lang.Apply(tmp51, []any{v38}) + tmp53 := lang.Apply(tmp48, []any{tmp52}) + var tmp45 any = tmp53 + tmp55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp56 := tmp55.FindInternedVar(lang.NewSymbol("int")) + if tmp56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp56))) } - v57 := v56.Get() - v58 := lang.Apply(v57, []any{int64(0)}) - var v54 any = v58 - v9 = v39 - v10 = v44 - v11 = v45 - v12 = v54 + tmp57 := tmp56.Get() + tmp58 := lang.Apply(tmp57, []any{int64(0)}) + var tmp54 any = tmp58 + v9 = tmp39 + v10 = tmp44 + v11 = tmp45 + v12 = tmp54 continue } // end let - v28 = v33 + tmp28 = tmp33 } else { - var v34 any + var tmp34 any { // let // let binding "path" - v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v36 := v35.FindInternedVar(lang.NewSymbol("first")) - if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp36 := tmp35.FindInternedVar(lang.NewSymbol("first")) + if tmp36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) } - v37 := v36.Get() - v38 := lang.Apply(v37, []any{v27}) - var v39 any = v38 + tmp37 := tmp36.Get() + tmp38 := lang.Apply(tmp37, []any{v27}) + var v39 any = tmp38 _ = v39 - var v40 any + var tmp40 any { // let // let binding "path" - var v41 any - v42 := lang.Apply(strings8.HasPrefix, []any{v39, "/"}) - if lang.IsTruthy(v42) { - v41 = v39 + var tmp41 any + tmp42 := lang.Apply(strings8.HasPrefix, []any{v39, "/"}) + if lang.IsTruthy(tmp42) { + tmp41 = v39 } else { - v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v44 := v43.FindInternedVar(lang.NewSymbol("str")) - if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) + tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp44 := tmp43.FindInternedVar(lang.NewSymbol("str")) + if tmp44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) } - v45 := v44.Get() - v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v47 := v46.FindInternedVar(lang.NewSymbol("root-directory")) - if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) + tmp45 := tmp44.Get() + tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp47 := tmp46.FindInternedVar(lang.NewSymbol("root-directory")) + if tmp47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) } - v48 := v47.Get() - v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v50 := v49.FindInternedVar(lang.NewSymbol("ns-name")) - if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) + tmp48 := tmp47.Get() + tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp50 := tmp49.FindInternedVar(lang.NewSymbol("ns-name")) + if tmp50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) } - v51 := v50.Get() - v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v53 := v52.FindInternedVar(lang.NewSymbol("*ns*")) - if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) + tmp51 := tmp50.Get() + tmp52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp53 := tmp52.FindInternedVar(lang.NewSymbol("*ns*")) + if tmp53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp53))) } - v54 := v53.Get() - v55 := lang.Apply(v51, []any{v54}) - v56 := lang.Apply(v48, []any{v55}) - v57 := lang.Apply(v45, []any{v56, lang.NewChar(47), v39}) - v41 = v57 + tmp54 := tmp53.Get() + tmp55 := lang.Apply(tmp51, []any{tmp54}) + tmp56 := lang.Apply(tmp48, []any{tmp55}) + tmp57 := lang.Apply(tmp45, []any{tmp56, lang.NewChar(47), v39}) + tmp41 = tmp57 } - var v58 any = v41 + var v58 any = tmp41 _ = v58 - var v59 any - v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v61 := v60.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) - if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) + var tmp59 any + tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp61 := tmp60.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) + if tmp61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) } - v62 := v61.Get() - if lang.IsTruthy(v62) { - v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v64 := v63.FindInternedVar(lang.NewSymbol("printf")) - if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) + tmp62 := tmp61.Get() + if lang.IsTruthy(tmp62) { + tmp63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp64 := tmp63.FindInternedVar(lang.NewSymbol("printf")) + if tmp64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp64))) } - v65 := v64.Get() - v66 := lang.Apply(v65, []any{"(glojure.core/load \"%s\")\n", v58}) - _ = v66 - v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v68 := v67.FindInternedVar(lang.NewSymbol("flush")) - if v68.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) + tmp65 := tmp64.Get() + tmp66 := lang.Apply(tmp65, []any{"(glojure.core/load \"%s\")\n", v58}) + _ = tmp66 + tmp67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp68 := tmp67.FindInternedVar(lang.NewSymbol("flush")) + if tmp68.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp68))) } - v69 := v68.Get() - v70 := lang.Apply(v69, nil) - v59 = v70 + tmp69 := tmp68.Get() + tmp70 := lang.Apply(tmp69, nil) + tmp59 = tmp70 } else { - v59 = nil } - _ = v59 - v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v72 := v71.FindInternedVar(lang.NewSymbol("check-cyclic-dependency")) - if v72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) + _ = tmp59 + tmp71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp72 := tmp71.FindInternedVar(lang.NewSymbol("check-cyclic-dependency")) + if tmp72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp72))) } - v73 := v72.Get() - v74 := lang.Apply(v73, []any{v58}) - _ = v74 - var v75 any - v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v77 := v76.FindInternedVar(lang.NewSymbol("=")) - if v77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) + tmp73 := tmp72.Get() + tmp74 := lang.Apply(tmp73, []any{v58}) + _ = tmp74 + var tmp75 any + tmp76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp77 := tmp76.FindInternedVar(lang.NewSymbol("=")) + if tmp77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp77))) } - v78 := v77.Get() - v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v80 := v79.FindInternedVar(lang.NewSymbol("first")) - if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) + tmp78 := tmp77.Get() + tmp79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp80 := tmp79.FindInternedVar(lang.NewSymbol("first")) + if tmp80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp80))) } - v81 := v80.Get() - v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v83 := v82.FindInternedVar(lang.NewSymbol("*pending-paths*")) - if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) + tmp81 := tmp80.Get() + tmp82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp83 := tmp82.FindInternedVar(lang.NewSymbol("*pending-paths*")) + if tmp83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp83))) } - v84 := v83.Get() - v85 := lang.Apply(v81, []any{v84}) - v86 := lang.Apply(v78, []any{v58, v85}) - if lang.IsTruthy(v86) { - v75 = nil + tmp84 := tmp83.Get() + tmp85 := lang.Apply(tmp81, []any{tmp84}) + tmp86 := lang.Apply(tmp78, []any{v58, tmp85}) + if lang.IsTruthy(tmp86) { } else { - var v87 any + var tmp87 any { // let - v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v89 := v88.FindInternedVar(lang.NewSymbol("push-thread-bindings")) - if v89.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) + tmp88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp89 := tmp88.FindInternedVar(lang.NewSymbol("push-thread-bindings")) + if tmp89.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp89))) } - v90 := v89.Get() - v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v92 := v91.FindInternedVar(lang.NewSymbol("hash-map")) - if v92.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) + tmp90 := tmp89.Get() + tmp91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp92 := tmp91.FindInternedVar(lang.NewSymbol("hash-map")) + if tmp92.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp92))) } - v93 := v92.Get() - v94 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*pending-paths*")) - v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v96 := v95.FindInternedVar(lang.NewSymbol("conj")) - if v96.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) + tmp93 := tmp92.Get() + tmp94 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*pending-paths*")) + tmp95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp96 := tmp95.FindInternedVar(lang.NewSymbol("conj")) + if tmp96.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp96))) } - v97 := v96.Get() - v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v99 := v98.FindInternedVar(lang.NewSymbol("*pending-paths*")) - if v99.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) + tmp97 := tmp96.Get() + tmp98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp99 := tmp98.FindInternedVar(lang.NewSymbol("*pending-paths*")) + if tmp99.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp99))) } - v100 := v99.Get() - v101 := lang.Apply(v97, []any{v100, v58}) - v102 := lang.Apply(v93, []any{v94, v101}) - v103 := lang.Apply(v90, []any{v102}) - _ = v103 - var v104 any + tmp100 := tmp99.Get() + tmp101 := lang.Apply(tmp97, []any{tmp100, v58}) + tmp102 := lang.Apply(tmp93, []any{tmp94, tmp101}) + tmp103 := lang.Apply(tmp90, []any{tmp102}) + _ = tmp103 + var tmp104 any func() { defer func() { - v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v106 := v105.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) - if v106.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) + tmp105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp106 := tmp105.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) + if tmp106.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp106))) } - v107 := v106.Get() - v108 := lang.Apply(v107, nil) + tmp107 := tmp106.Get() + tmp108 := lang.Apply(tmp107, nil) + _ = tmp108 }() - v109 := lang.Apply(strings8.TrimPrefix, []any{v58, "/"}) - v110, _ := lang.FieldOrMethod(runtime4.RT, "Load") - if reflect.TypeOf(v110).Kind() != reflect.Func { + tmp109 := lang.Apply(strings8.TrimPrefix, []any{v58, "/"}) + tmp110, _ := lang.FieldOrMethod(runtime4.RT, "Load") + if reflect.TypeOf(tmp110).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Load is not a function"))) } - v111 := lang.Apply(v110, []any{v109}) - v104 = v111 + tmp111 := lang.Apply(tmp110, []any{tmp109}) + tmp104 = tmp111 }() - v87 = v104 + tmp87 = tmp104 } // end let - v75 = v87 + tmp75 = tmp87 } - v40 = v75 + tmp40 = tmp75 } // end let - _ = v40 - v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v43 := v42.FindInternedVar(lang.NewSymbol("next")) - if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) + _ = tmp40 + tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp43 := tmp42.FindInternedVar(lang.NewSymbol("next")) + if tmp43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) } - v44 := v43.Get() - v45 := lang.Apply(v44, []any{v27}) - var v41 any = v45 - var v46 any = nil - var v47 any = int64(0) - var v48 any = int64(0) - v9 = v41 - v10 = v46 - v11 = v47 - v12 = v48 + tmp44 := tmp43.Get() + tmp45 := lang.Apply(tmp44, []any{v27}) + var tmp41 any = tmp45 + var tmp46 any = nil + var tmp47 any = int64(0) + var tmp48 any = int64(0) + v9 = tmp41 + v10 = tmp46 + v11 = tmp47 + v12 = tmp48 continue } // end let - v28 = v34 + tmp28 = tmp34 } - v26 = v28 + tmp26 = tmp28 } // end let - v25 = v26 + tmp25 = tmp26 } else { - v25 = nil } - v19 = v25 + tmp19 = tmp25 } // end let - v13 = v19 + tmp13 = tmp19 } - v4 = v13 + tmp4 = tmp13 break } } // end let - return v4 + return tmp4 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // load-all { - v0 := lang.NewSymbol("load-all").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"), lang.NewSymbol("need-ns"), lang.NewSymbol("require"))), lang.NewKeyword("doc"), "Loads a lib given its name and forces a load of any libs it directly or\n indirectly loads. If need-ns, ensures that the associated namespace\n exists after loading. If require, records the load so any duplicate loads\n can be skipped.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5892), lang.NewKeyword("end-line"), int(5892), lang.NewKeyword("private"), true)).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("load-all").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"), lang.NewSymbol("need-ns"), lang.NewSymbol("require"))), lang.NewKeyword("doc"), "Loads a lib given its name and forces a load of any libs it directly or\n indirectly loads. If need-ns, ensures that the associated namespace\n exists after loading. If require, records the load so any duplicate loads\n can be skipped.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5892), lang.NewKeyword("end-line"), int(5892), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -47764,25 +47876,25 @@ func init() { _ = v4 v5 := args[2] _ = v5 - var v6 lang.FnFunc - v6 = lang.NewFnFunc(func(args ...any) any { + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("commute")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("commute")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("*loaded-libs*")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("*loaded-libs*")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) } - v12 := v11.Get() - var v13 lang.FnFunc - v13 = lang.NewFnFunc(func(args ...any) any { + tmp12 := tmp11.Get() + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -47790,115 +47902,116 @@ func init() { _ = v14 v15 := args[1] _ = v15 - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("reduce1")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("conj")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.Apply(v18, []any{v21, v14, v15}) - return v22 + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("conj")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp18, []any{tmp21, v14, v15}) + return tmp22 }) - v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5899), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(5899), lang.NewKeyword("end-column"), int(47)) - v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) + tmp14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5899), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(5899), lang.NewKeyword("end-column"), int(47)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) if err != nil { panic(err) } - var v16 any + var tmp16 any { // let - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("push-thread-bindings")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("hash-map")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*loaded-libs*")) - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("ref")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("sorted-set")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, nil) - v31 := lang.Apply(v26, []any{v30}) - v32 := lang.Apply(v22, []any{v23, v31}) - v33 := lang.Apply(v19, []any{v32}) - _ = v33 - var v34 any + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("push-thread-bindings")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("hash-map")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*loaded-libs*")) + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("ref")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("sorted-set")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, nil) + tmp31 := lang.Apply(tmp26, []any{tmp30}) + tmp32 := lang.Apply(tmp22, []any{tmp23, tmp31}) + tmp33 := lang.Apply(tmp19, []any{tmp32}) + _ = tmp33 + var tmp34 any func() { defer func() { - v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v36 := v35.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) - if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) - } - v37 := v36.Get() - v38 := lang.Apply(v37, nil) + tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp36 := tmp35.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) + if tmp36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) + } + tmp37 := tmp36.Get() + tmp38 := lang.Apply(tmp37, nil) + _ = tmp38 }() - v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v40 := v39.FindInternedVar(lang.NewSymbol("load-one")) - if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) - } - v41 := v40.Get() - v42 := lang.Apply(v41, []any{v3, v4, v5}) - _ = v42 - v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v44 := v43.FindInternedVar(lang.NewSymbol("deref")) - if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) - } - v45 := v44.Get() - v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v47 := v46.FindInternedVar(lang.NewSymbol("*loaded-libs*")) - if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) - } - v48 := v47.Get() - v49 := lang.Apply(v45, []any{v48}) - v34 = v49 + tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp40 := tmp39.FindInternedVar(lang.NewSymbol("load-one")) + if tmp40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) + } + tmp41 := tmp40.Get() + tmp42 := lang.Apply(tmp41, []any{v3, v4, v5}) + _ = tmp42 + tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp44 := tmp43.FindInternedVar(lang.NewSymbol("deref")) + if tmp44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) + } + tmp45 := tmp44.Get() + tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp47 := tmp46.FindInternedVar(lang.NewSymbol("*loaded-libs*")) + if tmp47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) + } + tmp48 := tmp47.Get() + tmp49 := lang.Apply(tmp45, []any{tmp48}) + tmp34 = tmp49 }() - v16 = v34 + tmp16 = tmp34 } // end let - v17 := lang.Apply(v9, []any{v12, v15, v16}) - return v17 + tmp17 := lang.Apply(tmp9, []any{tmp12, tmp15, tmp16}) + return tmp17 }) - v7, _ := lang.FieldOrMethod(lang.LockingTransaction, "RunInTransaction") - if reflect.TypeOf(v7).Kind() != reflect.Func { + tmp7, _ := lang.FieldOrMethod(lang.LockingTransaction, "RunInTransaction") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("RunInTransaction is not a function"))) } - v8 := lang.Apply(v7, []any{v6}) - return v8 + tmp8 := lang.Apply(tmp7, []any{tmp6}) + return tmp8 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // load-data-reader-file { - v0 := lang.NewSymbol("load-data-reader-file").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7836), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7836), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("mappings"), lang.NewSymbol("url"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("load-data-reader-file").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7836), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7836), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("mappings"), lang.NewSymbol("url"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -47906,177 +48019,178 @@ func init() { _ = v3 v4 := args[1] _ = v4 - var v5 any + var tmp5 any { // let // let binding "rdr" - v6, ok := lang.FieldOrMethod(v4, "openStream") + tmp6, ok := lang.FieldOrMethod(v4, "openStream") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "openStream"))) } - var v7 any - switch reflect.TypeOf(v6).Kind() { + var tmp7 any + switch reflect.TypeOf(tmp6).Kind() { case reflect.Func: - v7 = lang.Apply(v6, nil) + tmp7 = lang.Apply(tmp6, nil) default: - v7 = v6 + tmp7 = tmp6 } - v8 := lang.Apply(nil, []any{v7, "UTF-8"}) - v9 := lang.Apply(nil, []any{v8}) - var v10 any = v9 + tmp8 := lang.Apply(nil, []any{tmp7, "UTF-8"}) + tmp9 := lang.Apply(nil, []any{tmp8}) + var v10 any = tmp9 _ = v10 - var v11 any + var tmp11 any func() { defer func() { - v12, ok := lang.FieldOrMethod(v10, "close") + tmp12, ok := lang.FieldOrMethod(v10, "close") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v10, "close"))) } - var v13 any - switch reflect.TypeOf(v12).Kind() { + var tmp13 any + switch reflect.TypeOf(tmp12).Kind() { case reflect.Func: - v13 = lang.Apply(v12, nil) + tmp13 = lang.Apply(tmp12, nil) default: - v13 = v12 + tmp13 = tmp12 } + _ = tmp13 }() - var v14 any + var tmp14 any { // let - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("push-thread-bindings")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("hash-map")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*file*")) - v22, ok := lang.FieldOrMethod(v4, "getFile") + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("push-thread-bindings")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("hash-map")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*file*")) + tmp22, ok := lang.FieldOrMethod(v4, "getFile") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "getFile"))) } - var v23 any - switch reflect.TypeOf(v22).Kind() { + var tmp23 any + switch reflect.TypeOf(tmp22).Kind() { case reflect.Func: - v23 = lang.Apply(v22, nil) + tmp23 = lang.Apply(tmp22, nil) default: - v23 = v22 + tmp23 = tmp22 } - v24 := lang.Apply(v20, []any{v21, v23}) - v25 := lang.Apply(v17, []any{v24}) - _ = v25 - var v26 any + tmp24 := lang.Apply(tmp20, []any{tmp21, tmp23}) + tmp25 := lang.Apply(tmp17, []any{tmp24}) + _ = tmp25 + var tmp26 any func() { defer func() { - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) } - v29 := v28.Get() - v30 := lang.Apply(v29, nil) + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, nil) + _ = tmp30 }() - var v31 any + var tmp31 any { // let // let binding "read-opts" - var v32 any - v33, ok := lang.FieldOrMethod(v4, "getPath") + var tmp32 any + tmp33, ok := lang.FieldOrMethod(v4, "getPath") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "getPath"))) } - var v34 any - switch reflect.TypeOf(v33).Kind() { + var tmp34 any + switch reflect.TypeOf(tmp33).Kind() { case reflect.Func: - v34 = lang.Apply(v33, nil) + tmp34 = lang.Apply(tmp33, nil) default: - v34 = v33 + tmp34 = tmp33 } - v35, _ := lang.FieldOrMethod(v34, "endsWith") - if reflect.TypeOf(v35).Kind() != reflect.Func { + tmp35, _ := lang.FieldOrMethod(tmp34, "endsWith") + if reflect.TypeOf(tmp35).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("endsWith is not a function"))) } - v36 := lang.Apply(v35, []any{"cljc"}) - if lang.IsTruthy(v36) { - v37 := lang.NewMap(lang.NewKeyword("eof"), nil, lang.NewKeyword("read-cond"), lang.NewKeyword("allow")) - v38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7842), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7842), lang.NewKeyword("end-column"), int(52)) - v39, err := lang.WithMeta(v37, v38.(lang.IPersistentMap)) + tmp36 := lang.Apply(tmp35, []any{"cljc"}) + if lang.IsTruthy(tmp36) { + tmp37 := lang.NewMap(lang.NewKeyword("eof"), nil, lang.NewKeyword("read-cond"), lang.NewKeyword("allow")) + tmp38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7842), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7842), lang.NewKeyword("end-column"), int(52)) + tmp39, err := lang.WithMeta(tmp37, tmp38.(lang.IPersistentMap)) if err != nil { panic(err) } - v32 = v39 + tmp32 = tmp39 } else { - v40 := lang.NewMap(lang.NewKeyword("eof"), nil) - v41 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7843), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7843), lang.NewKeyword("end-column"), int(34)) - v42, err := lang.WithMeta(v40, v41.(lang.IPersistentMap)) + tmp40 := lang.NewMap(lang.NewKeyword("eof"), nil) + tmp41 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7843), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7843), lang.NewKeyword("end-column"), int(34)) + tmp42, err := lang.WithMeta(tmp40, tmp41.(lang.IPersistentMap)) if err != nil { panic(err) } - v32 = v42 + tmp32 = tmp42 } - var v43 any = v32 + var v43 any = tmp32 _ = v43 // let binding "new-mappings" - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("read")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("read")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) } - v46 := v45.Get() - v47 := lang.Apply(v46, []any{v43, v10}) - var v48 any = v47 + tmp46 := tmp45.Get() + tmp47 := lang.Apply(tmp46, []any{v43, v10}) + var v48 any = tmp47 _ = v48 - var v49 any - v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v51 := v50.FindInternedVar(lang.NewSymbol("not")) - if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) + var tmp49 any + tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp51 := tmp50.FindInternedVar(lang.NewSymbol("not")) + if tmp51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) } - v52 := v51.Get() - v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v54 := v53.FindInternedVar(lang.NewSymbol("map?")) - if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) + tmp52 := tmp51.Get() + tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp54 := tmp53.FindInternedVar(lang.NewSymbol("map?")) + if tmp54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) } - v55 := v54.Get() - v56 := lang.Apply(v55, []any{v48}) - v57 := lang.Apply(v52, []any{v56}) - if lang.IsTruthy(v57) { - v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v59 := v58.FindInternedVar(lang.NewSymbol("ex-info")) - if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) + tmp55 := tmp54.Get() + tmp56 := lang.Apply(tmp55, []any{v48}) + tmp57 := lang.Apply(tmp52, []any{tmp56}) + if lang.IsTruthy(tmp57) { + tmp58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp59 := tmp58.FindInternedVar(lang.NewSymbol("ex-info")) + if tmp59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp59))) } - v60 := v59.Get() - v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v62 := v61.FindInternedVar(lang.NewSymbol("str")) - if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) + tmp60 := tmp59.Get() + tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp62 := tmp61.FindInternedVar(lang.NewSymbol("str")) + if tmp62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) } - v63 := v62.Get() - v64 := lang.Apply(v63, []any{"Not a valid data-reader map"}) - v65 := lang.NewMap(lang.NewKeyword("url"), v4) - v66 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7847), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(7847), lang.NewKeyword("end-column"), int(36)) - v67, err := lang.WithMeta(v65, v66.(lang.IPersistentMap)) + tmp63 := tmp62.Get() + tmp64 := lang.Apply(tmp63, []any{"Not a valid data-reader map"}) + tmp65 := lang.NewMap(lang.NewKeyword("url"), v4) + tmp66 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7847), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(7847), lang.NewKeyword("end-column"), int(36)) + tmp67, err := lang.WithMeta(tmp65, tmp66.(lang.IPersistentMap)) if err != nil { panic(err) } - v68 := lang.Apply(v60, []any{v64, v67}) - panic(v68) + tmp68 := lang.Apply(tmp60, []any{tmp64, tmp67}) + panic(tmp68) } else { - v49 = nil } - _ = v49 - v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v70 := v69.FindInternedVar(lang.NewSymbol("reduce")) - if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) + _ = tmp49 + tmp69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp70 := tmp69.FindInternedVar(lang.NewSymbol("reduce")) + if tmp70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp70))) } - v71 := v70.Get() - var v72 lang.FnFunc - v72 = lang.NewFnFunc(func(args ...any) any { + tmp71 := tmp70.Get() + var tmp72 lang.FnFunc + tmp72 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -48084,240 +48198,238 @@ func init() { _ = v73 v74 := args[1] _ = v74 - var v75 any + var tmp75 any { // let // let binding "vec__347" var v76 any = v74 _ = v76 // let binding "k" - v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v78 := v77.FindInternedVar(lang.NewSymbol("nth")) - if v78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) + tmp77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp78 := tmp77.FindInternedVar(lang.NewSymbol("nth")) + if tmp78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp78))) } - v79 := v78.Get() - v80 := lang.Apply(v79, []any{v76, int64(0), nil}) - var v81 any = v80 + tmp79 := tmp78.Get() + tmp80 := lang.Apply(tmp79, []any{v76, int64(0), nil}) + var v81 any = tmp80 _ = v81 // let binding "v" - v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v83 := v82.FindInternedVar(lang.NewSymbol("nth")) - if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) + tmp82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp83 := tmp82.FindInternedVar(lang.NewSymbol("nth")) + if tmp83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp83))) } - v84 := v83.Get() - v85 := lang.Apply(v84, []any{v76, int64(1), nil}) - var v86 any = v85 + tmp84 := tmp83.Get() + tmp85 := lang.Apply(tmp84, []any{v76, int64(1), nil}) + var v86 any = tmp85 _ = v86 - var v87 any - v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v89 := v88.FindInternedVar(lang.NewSymbol("not")) - if v89.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) + var tmp87 any + tmp88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp89 := tmp88.FindInternedVar(lang.NewSymbol("not")) + if tmp89.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp89))) } - v90 := v89.Get() - v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v92 := v91.FindInternedVar(lang.NewSymbol("symbol?")) - if v92.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) + tmp90 := tmp89.Get() + tmp91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp92 := tmp91.FindInternedVar(lang.NewSymbol("symbol?")) + if tmp92.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp92))) } - v93 := v92.Get() - v94 := lang.Apply(v93, []any{v81}) - v95 := lang.Apply(v90, []any{v94}) - if lang.IsTruthy(v95) { - v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v97 := v96.FindInternedVar(lang.NewSymbol("ex-info")) - if v97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) + tmp93 := tmp92.Get() + tmp94 := lang.Apply(tmp93, []any{v81}) + tmp95 := lang.Apply(tmp90, []any{tmp94}) + if lang.IsTruthy(tmp95) { + tmp96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp97 := tmp96.FindInternedVar(lang.NewSymbol("ex-info")) + if tmp97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp97))) } - v98 := v97.Get() - v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v100 := v99.FindInternedVar(lang.NewSymbol("str")) - if v100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) + tmp98 := tmp97.Get() + tmp99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp100 := tmp99.FindInternedVar(lang.NewSymbol("str")) + if tmp100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp100))) } - v101 := v100.Get() - v102 := lang.Apply(v101, []any{"Invalid form in data-reader file"}) - v103 := lang.NewMap(lang.NewKeyword("url"), v4, lang.NewKeyword("form"), v81) - v104 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7852), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(7853), lang.NewKeyword("end-column"), int(38)) - v105, err := lang.WithMeta(v103, v104.(lang.IPersistentMap)) + tmp101 := tmp100.Get() + tmp102 := lang.Apply(tmp101, []any{"Invalid form in data-reader file"}) + tmp103 := lang.NewMap(lang.NewKeyword("url"), v4, lang.NewKeyword("form"), v81) + tmp104 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7852), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(7853), lang.NewKeyword("end-column"), int(38)) + tmp105, err := lang.WithMeta(tmp103, tmp104.(lang.IPersistentMap)) if err != nil { panic(err) } - v106 := lang.Apply(v98, []any{v102, v105}) - panic(v106) + tmp106 := lang.Apply(tmp98, []any{tmp102, tmp105}) + panic(tmp106) } else { - v87 = nil } - _ = v87 - var v107 any + _ = tmp87 + var tmp107 any { // let // let binding "v-var" - v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v109 := v108.FindInternedVar(lang.NewSymbol("data-reader-var")) - if v109.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) + tmp108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp109 := tmp108.FindInternedVar(lang.NewSymbol("data-reader-var")) + if tmp109.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp109))) } - v110 := v109.Get() - v111 := lang.Apply(v110, []any{v86}) - var v112 any = v111 + tmp110 := tmp109.Get() + tmp111 := lang.Apply(tmp110, []any{v86}) + var v112 any = tmp111 _ = v112 - var v113 any - var v114 any + var tmp113 any + var tmp114 any { // let // let binding "and__0__auto__" - v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v116 := v115.FindInternedVar(lang.NewSymbol("contains?")) - if v116.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) + tmp115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp116 := tmp115.FindInternedVar(lang.NewSymbol("contains?")) + if tmp116.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp116))) } - v117 := v116.Get() - v118 := lang.Apply(v117, []any{v3, v81}) - var v119 any = v118 + tmp117 := tmp116.Get() + tmp118 := lang.Apply(tmp117, []any{v3, v81}) + var v119 any = tmp118 _ = v119 - var v120 any + var tmp120 any if lang.IsTruthy(v119) { - v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v122 := v121.FindInternedVar(lang.NewSymbol("not=")) - if v122.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) + tmp121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp122 := tmp121.FindInternedVar(lang.NewSymbol("not=")) + if tmp122.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp122))) } - v123 := v122.Get() - v124 := lang.Apply(v3, []any{v81}) - v125 := lang.Apply(v123, []any{v124, v112}) - v120 = v125 + tmp123 := tmp122.Get() + tmp124 := lang.Apply(v3, []any{v81}) + tmp125 := lang.Apply(tmp123, []any{tmp124, v112}) + tmp120 = tmp125 } else { - v120 = v119 + tmp120 = v119 } - v114 = v120 + tmp114 = tmp120 } // end let - if lang.IsTruthy(v114) { - v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v116 := v115.FindInternedVar(lang.NewSymbol("ex-info")) - if v116.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) + if lang.IsTruthy(tmp114) { + tmp115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp116 := tmp115.FindInternedVar(lang.NewSymbol("ex-info")) + if tmp116.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp116))) } - v117 := v116.Get() - v118 := lang.NewMap(lang.NewKeyword("url"), v4, lang.NewKeyword("conflict"), v81, lang.NewKeyword("mappings"), v73) - v119 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7858), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(7860), lang.NewKeyword("end-column"), int(44)) - v120, err := lang.WithMeta(v118, v119.(lang.IPersistentMap)) + tmp117 := tmp116.Get() + tmp118 := lang.NewMap(lang.NewKeyword("url"), v4, lang.NewKeyword("conflict"), v81, lang.NewKeyword("mappings"), v73) + tmp119 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7858), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(7860), lang.NewKeyword("end-column"), int(44)) + tmp120, err := lang.WithMeta(tmp118, tmp119.(lang.IPersistentMap)) if err != nil { panic(err) } - v121 := lang.Apply(v117, []any{"Conflicting data-reader mapping", v120}) - panic(v121) + tmp121 := lang.Apply(tmp117, []any{"Conflicting data-reader mapping", tmp120}) + panic(tmp121) } else { - v113 = nil } - _ = v113 - v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v123 := v122.FindInternedVar(lang.NewSymbol("assoc")) - if v123.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) + _ = tmp113 + tmp122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp123 := tmp122.FindInternedVar(lang.NewSymbol("assoc")) + if tmp123.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp123))) } - v124 := v123.Get() - v125 := lang.Apply(v124, []any{v73, v81, v112}) - v107 = v125 + tmp124 := tmp123.Get() + tmp125 := lang.Apply(tmp124, []any{v73, v81, v112}) + tmp107 = tmp125 } // end let - v75 = v107 + tmp75 = tmp107 } // end let - return v75 + return tmp75 }) - v73 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7849), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(7861), lang.NewKeyword("end-column"), int(32)) - v74, err := lang.WithMeta(v72, v73.(lang.IPersistentMap)) + tmp73 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7849), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(7861), lang.NewKeyword("end-column"), int(32)) + tmp74, err := lang.WithMeta(tmp72, tmp73.(lang.IPersistentMap)) if err != nil { panic(err) } - v75 := lang.Apply(v71, []any{v74, v3, v48}) - v31 = v75 + tmp75 := lang.Apply(tmp71, []any{tmp74, v3, v48}) + tmp31 = tmp75 } // end let - v26 = v31 + tmp26 = tmp31 }() - v14 = v26 + tmp14 = tmp26 } // end let - v11 = v14 + tmp11 = tmp14 }() - v5 = v11 + tmp5 = tmp11 } // end let - return v5 + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // load-data-readers { - v0 := lang.NewSymbol("load-data-readers").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7865), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7865), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("load-data-readers").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7865), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7865), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v4 := v3.FindInternedVar(lang.NewSymbol("alter-var-root")) - if v4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) + tmp3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp4 := tmp3.FindInternedVar(lang.NewSymbol("alter-var-root")) + if tmp4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp4))) } - v5 := v4.Get() - v6 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*data-readers*")) - var v7 lang.FnFunc - v7 = lang.NewFnFunc(func(args ...any) any { + tmp5 := tmp4.Get() + tmp6 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*data-readers*")) + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v8 := args[0] _ = v8 - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("reduce")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("load-data-reader-file")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("data-reader-urls")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, nil) - v19 := lang.Apply(v11, []any{v14, v8, v18}) - return v19 + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("reduce")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("load-data-reader-file")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("data-reader-urls")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, nil) + tmp19 := lang.Apply(tmp11, []any{tmp14, v8, tmp18}) + return tmp19 }) - v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7867), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(7869), lang.NewKeyword("end-column"), int(57)) - v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) + tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7867), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(7869), lang.NewKeyword("end-column"), int(57)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) if err != nil { panic(err) } - v10 := lang.Apply(v5, []any{v6, v9}) - return v10 + tmp10 := lang.Apply(tmp5, []any{tmp6, tmp9}) + return tmp10 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // load-file { - v0 := lang.NewSymbol("load-file").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - v1 := ns.InternWithValue(v0, nil, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp0 := lang.NewSymbol("load-file").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // load-lib { - v0 := lang.NewSymbol("load-lib").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("prefix"), lang.NewSymbol("lib"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Loads a lib with options", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5904), lang.NewKeyword("end-line"), int(5904), lang.NewKeyword("private"), true)).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("load-lib").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("prefix"), lang.NewSymbol("lib"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Loads a lib with options", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5904), lang.NewKeyword("end-line"), int(5904), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 2 { @@ -48327,311 +48439,311 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.NewList(args[2:]...) - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("throw-if")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - var v9 any + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("throw-if")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + var tmp9 any { // let // let binding "and__0__auto__" var v10 any = v3 _ = v10 - var v11 any + var tmp11 any if lang.IsTruthy(v10) { - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("pos?")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("name")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{v4}) - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("int")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{lang.NewChar(46)}) - v23 := lang.Apply(strings8.Index, []any{v18, v22}) - v24 := lang.Apply(v14, []any{v23}) - v11 = v24 + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("pos?")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("name")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{v4}) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("int")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, []any{lang.NewChar(46)}) + tmp23 := lang.Apply(strings8.Index, []any{tmp18, tmp22}) + tmp24 := lang.Apply(tmp14, []any{tmp23}) + tmp11 = tmp24 } else { - v11 = v10 + tmp11 = v10 } - v9 = v11 + tmp9 = tmp11 } // end let - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("name")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{v4}) - v14 := lang.Apply(v8, []any{v9, "Found lib name '%s' containing period with prefix '%s'. lib names inside prefix lists must not contain periods", v13, v3}) - _ = v14 - var v15 any + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("name")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{v4}) + tmp14 := lang.Apply(tmp8, []any{tmp9, "Found lib name '%s' containing period with prefix '%s'. lib names inside prefix lists must not contain periods", tmp13, v3}) + _ = tmp14 + var tmp15 any { // let // let binding "lib" - var v16 any + var tmp16 any if lang.IsTruthy(v3) { - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("symbol")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("str")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.Apply(v22, []any{v3, lang.NewChar(46), v4}) - v24 := lang.Apply(v19, []any{v23}) - v16 = v24 + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("symbol")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("str")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.Apply(tmp22, []any{v3, lang.NewChar(46), v4}) + tmp24 := lang.Apply(tmp19, []any{tmp23}) + tmp16 = tmp24 } else { - v16 = v4 + tmp16 = v4 } - var v25 any = v16 + var v25 any = tmp16 _ = v25 // let binding "opts" - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("apply")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) - } - v28 := v27.Get() - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("hash-map")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.Apply(v28, []any{v31, v5}) - var v33 any = v32 + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("apply")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) + } + tmp28 := tmp27.Get() + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("hash-map")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.Apply(tmp28, []any{tmp31, v5}) + var v33 any = tmp32 _ = v33 // let binding "map__110" var v34 any = v33 _ = v34 // let binding "map__110" - var v35 any - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("seq?")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.Apply(v38, []any{v34}) - if lang.IsTruthy(v39) { - var v40 any - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("next")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) - } - v43 := v42.Get() - v44 := lang.Apply(v43, []any{v34}) - if lang.IsTruthy(v44) { - v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v46 := v45.FindInternedVar(lang.NewSymbol("to-array")) - if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) - } - v47 := v46.Get() - v48 := lang.Apply(v47, []any{v34}) - v49 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{v48}) - v40 = v49 + var tmp35 any + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("seq?")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{v34}) + if lang.IsTruthy(tmp39) { + var tmp40 any + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("next")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := lang.Apply(tmp43, []any{v34}) + if lang.IsTruthy(tmp44) { + tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp46 := tmp45.FindInternedVar(lang.NewSymbol("to-array")) + if tmp46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) + } + tmp47 := tmp46.Get() + tmp48 := lang.Apply(tmp47, []any{v34}) + tmp49 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{tmp48}) + tmp40 = tmp49 } else { - var v50 any - v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v52 := v51.FindInternedVar(lang.NewSymbol("seq")) - if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) - } - v53 := v52.Get() - v54 := lang.Apply(v53, []any{v34}) - if lang.IsTruthy(v54) { - v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v56 := v55.FindInternedVar(lang.NewSymbol("first")) - if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) + var tmp50 any + tmp51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp52 := tmp51.FindInternedVar(lang.NewSymbol("seq")) + if tmp52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp52))) + } + tmp53 := tmp52.Get() + tmp54 := lang.Apply(tmp53, []any{v34}) + if lang.IsTruthy(tmp54) { + tmp55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp56 := tmp55.FindInternedVar(lang.NewSymbol("first")) + if tmp56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp56))) } - v57 := v56.Get() - v58 := lang.Apply(v57, []any{v34}) - v50 = v58 + tmp57 := tmp56.Get() + tmp58 := lang.Apply(tmp57, []any{v34}) + tmp50 = tmp58 } else { - v50 = nil } - v40 = v50 + tmp40 = tmp50 } - v35 = v40 + tmp35 = tmp40 } else { - v35 = v34 + tmp35 = v34 } - var v59 any = v35 + var v59 any = tmp35 _ = v59 // let binding "as" - v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v61 := v60.FindInternedVar(lang.NewSymbol("get")) - if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) - } - v62 := v61.Get() - v63 := lang.Apply(v62, []any{v59, lang.NewKeyword("as")}) - var v64 any = v63 + tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp61 := tmp60.FindInternedVar(lang.NewSymbol("get")) + if tmp61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) + } + tmp62 := tmp61.Get() + tmp63 := lang.Apply(tmp62, []any{v59, lang.NewKeyword("as")}) + var v64 any = tmp63 _ = v64 // let binding "reload" - v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v66 := v65.FindInternedVar(lang.NewSymbol("get")) - if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) - } - v67 := v66.Get() - v68 := lang.Apply(v67, []any{v59, lang.NewKeyword("reload")}) - var v69 any = v68 + tmp65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp66 := tmp65.FindInternedVar(lang.NewSymbol("get")) + if tmp66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp66))) + } + tmp67 := tmp66.Get() + tmp68 := lang.Apply(tmp67, []any{v59, lang.NewKeyword("reload")}) + var v69 any = tmp68 _ = v69 // let binding "reload-all" - v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v71 := v70.FindInternedVar(lang.NewSymbol("get")) - if v71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) - } - v72 := v71.Get() - v73 := lang.Apply(v72, []any{v59, lang.NewKeyword("reload-all")}) - var v74 any = v73 + tmp70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp71 := tmp70.FindInternedVar(lang.NewSymbol("get")) + if tmp71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp71))) + } + tmp72 := tmp71.Get() + tmp73 := lang.Apply(tmp72, []any{v59, lang.NewKeyword("reload-all")}) + var v74 any = tmp73 _ = v74 // let binding "require" - v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v76 := v75.FindInternedVar(lang.NewSymbol("get")) - if v76.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) - } - v77 := v76.Get() - v78 := lang.Apply(v77, []any{v59, lang.NewKeyword("require")}) - var v79 any = v78 + tmp75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp76 := tmp75.FindInternedVar(lang.NewSymbol("get")) + if tmp76.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp76))) + } + tmp77 := tmp76.Get() + tmp78 := lang.Apply(tmp77, []any{v59, lang.NewKeyword("require")}) + var v79 any = tmp78 _ = v79 // let binding "use" - v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v81 := v80.FindInternedVar(lang.NewSymbol("get")) - if v81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) - } - v82 := v81.Get() - v83 := lang.Apply(v82, []any{v59, lang.NewKeyword("use")}) - var v84 any = v83 + tmp80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp81 := tmp80.FindInternedVar(lang.NewSymbol("get")) + if tmp81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp81))) + } + tmp82 := tmp81.Get() + tmp83 := lang.Apply(tmp82, []any{v59, lang.NewKeyword("use")}) + var v84 any = tmp83 _ = v84 // let binding "verbose" - v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v86 := v85.FindInternedVar(lang.NewSymbol("get")) - if v86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) - } - v87 := v86.Get() - v88 := lang.Apply(v87, []any{v59, lang.NewKeyword("verbose")}) - var v89 any = v88 + tmp85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp86 := tmp85.FindInternedVar(lang.NewSymbol("get")) + if tmp86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp86))) + } + tmp87 := tmp86.Get() + tmp88 := lang.Apply(tmp87, []any{v59, lang.NewKeyword("verbose")}) + var v89 any = tmp88 _ = v89 // let binding "as-alias" - v90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v91 := v90.FindInternedVar(lang.NewSymbol("get")) - if v91.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v91))) - } - v92 := v91.Get() - v93 := lang.Apply(v92, []any{v59, lang.NewKeyword("as-alias")}) - var v94 any = v93 + tmp90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp91 := tmp90.FindInternedVar(lang.NewSymbol("get")) + if tmp91.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp91))) + } + tmp92 := tmp91.Get() + tmp93 := lang.Apply(tmp92, []any{v59, lang.NewKeyword("as-alias")}) + var v94 any = tmp93 _ = v94 // let binding "loaded" - v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v96 := v95.FindInternedVar(lang.NewSymbol("contains?")) - if v96.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) - } - v97 := v96.Get() - v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v99 := v98.FindInternedVar(lang.NewSymbol("deref")) - if v99.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) - } - v100 := v99.Get() - v101 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v102 := v101.FindInternedVar(lang.NewSymbol("*loaded-libs*")) - if v102.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v102))) - } - v103 := v102.Get() - v104 := lang.Apply(v100, []any{v103}) - v105 := lang.Apply(v97, []any{v104, v25}) - var v106 any = v105 + tmp95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp96 := tmp95.FindInternedVar(lang.NewSymbol("contains?")) + if tmp96.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp96))) + } + tmp97 := tmp96.Get() + tmp98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp99 := tmp98.FindInternedVar(lang.NewSymbol("deref")) + if tmp99.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp99))) + } + tmp100 := tmp99.Get() + tmp101 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp102 := tmp101.FindInternedVar(lang.NewSymbol("*loaded-libs*")) + if tmp102.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp102))) + } + tmp103 := tmp102.Get() + tmp104 := lang.Apply(tmp100, []any{tmp103}) + tmp105 := lang.Apply(tmp97, []any{tmp104, v25}) + var v106 any = tmp105 _ = v106 // let binding "need-ns" - var v107 any + var tmp107 any { // let // let binding "or__0__auto__" var v108 any = v64 _ = v108 - var v109 any + var tmp109 any if lang.IsTruthy(v108) { - v109 = v108 + tmp109 = v108 } else { - v109 = v84 + tmp109 = v84 } - v107 = v109 + tmp107 = tmp109 } // end let - var v108 any = v107 + var v108 any = tmp107 _ = v108 // let binding "load" - var v109 any + var tmp109 any if lang.IsTruthy(v74) { - v110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v111 := v110.FindInternedVar(lang.NewSymbol("load-all")) - if v111.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v111))) + tmp110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp111 := tmp110.FindInternedVar(lang.NewSymbol("load-all")) + if tmp111.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp111))) } - v112 := v111.Get() - v109 = v112 + tmp112 := tmp111.Get() + tmp109 = tmp112 } else { - var v113 any + var tmp113 any if lang.IsTruthy(v69) { - v114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v115 := v114.FindInternedVar(lang.NewSymbol("load-one")) - if v115.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v115))) + tmp114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp115 := tmp114.FindInternedVar(lang.NewSymbol("load-one")) + if tmp115.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp115))) } - v116 := v115.Get() - v113 = v116 + tmp116 := tmp115.Get() + tmp113 = tmp116 } else { - var v117 any - v118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v119 := v118.FindInternedVar(lang.NewSymbol("not")) - if v119.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v119))) - } - v120 := v119.Get() - v121 := lang.Apply(v120, []any{v106}) - if lang.IsTruthy(v121) { - var v122 any + var tmp117 any + tmp118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp119 := tmp118.FindInternedVar(lang.NewSymbol("not")) + if tmp119.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp119))) + } + tmp120 := tmp119.Get() + tmp121 := lang.Apply(tmp120, []any{v106}) + if lang.IsTruthy(tmp121) { + var tmp122 any if lang.IsTruthy(v108) { - v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v124 := v123.FindInternedVar(lang.NewSymbol("load-one")) - if v124.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) + tmp123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp124 := tmp123.FindInternedVar(lang.NewSymbol("load-one")) + if tmp124.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp124))) } - v125 := v124.Get() - v122 = v125 + tmp125 := tmp124.Get() + tmp122 = tmp125 } else { - var v126 any + var tmp126 any if lang.IsTruthy(v94) { - var v127 lang.FnFunc - v127 = lang.NewFnFunc(func(args ...any) any { + var tmp127 lang.FnFunc + tmp127 = lang.NewFnFunc(func(args ...any) any { if len(args) != 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -48641,351 +48753,344 @@ func init() { _ = v129 v130 := args[2] _ = v130 - v131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v132 := v131.FindInternedVar(lang.NewSymbol("create-ns")) - if v132.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v132))) + tmp131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp132 := tmp131.FindInternedVar(lang.NewSymbol("create-ns")) + if tmp132.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp132))) } - v133 := v132.Get() - v134 := lang.Apply(v133, []any{v128}) - return v134 + tmp133 := tmp132.Get() + tmp134 := lang.Apply(tmp133, []any{v128}) + return tmp134 }) - v128 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5918), lang.NewKeyword("column"), int(48), lang.NewKeyword("end-line"), int(5918), lang.NewKeyword("end-column"), int(88)) - v129, err := lang.WithMeta(v127, v128.(lang.IPersistentMap)) + tmp128 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5918), lang.NewKeyword("column"), int(48), lang.NewKeyword("end-line"), int(5918), lang.NewKeyword("end-column"), int(88)) + tmp129, err := lang.WithMeta(tmp127, tmp128.(lang.IPersistentMap)) if err != nil { panic(err) } - v126 = v129 + tmp126 = tmp129 } else { - var v130 any + var tmp130 any if lang.IsTruthy(lang.NewKeyword("else")) { - v131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v132 := v131.FindInternedVar(lang.NewSymbol("load-one")) - if v132.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v132))) + tmp131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp132 := tmp131.FindInternedVar(lang.NewSymbol("load-one")) + if tmp132.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp132))) } - v133 := v132.Get() - v130 = v133 + tmp133 := tmp132.Get() + tmp130 = tmp133 } else { - v130 = nil } - v126 = v130 + tmp126 = tmp130 } - v122 = v126 + tmp122 = tmp126 } - v117 = v122 + tmp117 = tmp122 } else { - v117 = nil } - v113 = v117 + tmp113 = tmp117 } - v109 = v113 + tmp109 = tmp113 } - var v134 any = v109 + var v134 any = tmp109 _ = v134 // let binding "filter-opts" - v135 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v136 := v135.FindInternedVar(lang.NewSymbol("select-keys")) - if v136.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v136))) - } - v137 := v136.Get() - v138 := lang.Apply(v137, []any{v33, lang.NewList(lang.NewKeyword("exclude"), lang.NewKeyword("only"), lang.NewKeyword("rename"), lang.NewKeyword("refer"))}) - var v139 any = v138 + tmp135 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp136 := tmp135.FindInternedVar(lang.NewSymbol("select-keys")) + if tmp136.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp136))) + } + tmp137 := tmp136.Get() + tmp138 := lang.Apply(tmp137, []any{v33, lang.NewList(lang.NewKeyword("exclude"), lang.NewKeyword("only"), lang.NewKeyword("rename"), lang.NewKeyword("refer"))}) + var v139 any = tmp138 _ = v139 // let binding "undefined-on-entry" - v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v141 := v140.FindInternedVar(lang.NewSymbol("not")) - if v141.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) - } - v142 := v141.Get() - v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v144 := v143.FindInternedVar(lang.NewSymbol("find-ns")) - if v144.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) - } - v145 := v144.Get() - v146 := lang.Apply(v145, []any{v25}) - v147 := lang.Apply(v142, []any{v146}) - var v148 any = v147 + tmp140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp141 := tmp140.FindInternedVar(lang.NewSymbol("not")) + if tmp141.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp141))) + } + tmp142 := tmp141.Get() + tmp143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp144 := tmp143.FindInternedVar(lang.NewSymbol("find-ns")) + if tmp144.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp144))) + } + tmp145 := tmp144.Get() + tmp146 := lang.Apply(tmp145, []any{v25}) + tmp147 := lang.Apply(tmp142, []any{tmp146}) + var v148 any = tmp147 _ = v148 - var v149 any + var tmp149 any { // let - v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v151 := v150.FindInternedVar(lang.NewSymbol("push-thread-bindings")) - if v151.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) - } - v152 := v151.Get() - v153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v154 := v153.FindInternedVar(lang.NewSymbol("hash-map")) - if v154.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v154))) - } - v155 := v154.Get() - v156 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*loading-verbosely*")) - var v157 any + tmp150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp151 := tmp150.FindInternedVar(lang.NewSymbol("push-thread-bindings")) + if tmp151.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp151))) + } + tmp152 := tmp151.Get() + tmp153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp154 := tmp153.FindInternedVar(lang.NewSymbol("hash-map")) + if tmp154.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp154))) + } + tmp155 := tmp154.Get() + tmp156 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*loading-verbosely*")) + var tmp157 any { // let // let binding "or__0__auto__" - v158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v159 := v158.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) - if v159.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v159))) + tmp158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp159 := tmp158.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) + if tmp159.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp159))) } - v160 := v159.Get() - var v161 any = v160 + tmp160 := tmp159.Get() + var v161 any = tmp160 _ = v161 - var v162 any + var tmp162 any if lang.IsTruthy(v161) { - v162 = v161 + tmp162 = v161 } else { - v162 = v89 + tmp162 = v89 } - v157 = v162 + tmp157 = tmp162 } // end let - v158 := lang.Apply(v155, []any{v156, v157}) - v159 := lang.Apply(v152, []any{v158}) - _ = v159 - var v160 any + tmp158 := lang.Apply(tmp155, []any{tmp156, tmp157}) + tmp159 := lang.Apply(tmp152, []any{tmp158}) + _ = tmp159 + var tmp160 any func() { defer func() { - v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v162 := v161.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) - if v162.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) + tmp161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp162 := tmp161.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) + if tmp162.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp162))) } - v163 := v162.Get() - v164 := lang.Apply(v163, nil) + tmp163 := tmp162.Get() + tmp164 := lang.Apply(tmp163, nil) + _ = tmp164 }() - var v165 any + var tmp165 any if lang.IsTruthy(v134) { - var v166 any + var tmp166 any func() { defer func() { if r := recover(); r != nil { if lang.CatchMatches(r, lang.Builtins["any"]) { v167 := r _ = v167 - var v168 any + var tmp168 any if lang.IsTruthy(v148) { - v169 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v170 := v169.FindInternedVar(lang.NewSymbol("remove-ns")) - if v170.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v170))) + tmp169 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp170 := tmp169.FindInternedVar(lang.NewSymbol("remove-ns")) + if tmp170.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp170))) } - v171 := v170.Get() - v172 := lang.Apply(v171, []any{v25}) - v168 = v172 + tmp171 := tmp170.Get() + tmp172 := lang.Apply(tmp171, []any{v25}) + tmp168 = tmp172 } else { - v168 = nil } - _ = v168 + _ = tmp168 panic(v167) } else { panic(r) } } }() - v167 := lang.Apply(v134, []any{v25, v108, v79}) - v166 = v167 + tmp167 := lang.Apply(v134, []any{v25, v108, v79}) + tmp166 = tmp167 }() - v165 = v166 + tmp165 = tmp166 } else { - v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v169 := v168.FindInternedVar(lang.NewSymbol("throw-if")) - if v169.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) + tmp168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp169 := tmp168.FindInternedVar(lang.NewSymbol("throw-if")) + if tmp169.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp169))) } - v170 := v169.Get() - var v171 any + tmp170 := tmp169.Get() + var tmp171 any { // let // let binding "and__0__auto__" var v172 any = v108 _ = v172 - var v173 any + var tmp173 any if lang.IsTruthy(v172) { - v174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v175 := v174.FindInternedVar(lang.NewSymbol("not")) - if v175.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v175))) + tmp174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp175 := tmp174.FindInternedVar(lang.NewSymbol("not")) + if tmp175.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp175))) } - v176 := v175.Get() - v177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v178 := v177.FindInternedVar(lang.NewSymbol("find-ns")) - if v178.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v178))) + tmp176 := tmp175.Get() + tmp177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp178 := tmp177.FindInternedVar(lang.NewSymbol("find-ns")) + if tmp178.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp178))) } - v179 := v178.Get() - v180 := lang.Apply(v179, []any{v25}) - v181 := lang.Apply(v176, []any{v180}) - v173 = v181 + tmp179 := tmp178.Get() + tmp180 := lang.Apply(tmp179, []any{v25}) + tmp181 := lang.Apply(tmp176, []any{tmp180}) + tmp173 = tmp181 } else { - v173 = v172 + tmp173 = v172 } - v171 = v173 + tmp171 = tmp173 } // end let - v172 := lang.Apply(v170, []any{v171, "namespace '%s' not found", v25}) - v165 = v172 + tmp172 := lang.Apply(tmp170, []any{tmp171, "namespace '%s' not found", v25}) + tmp165 = tmp172 } - _ = v165 - var v173 any - var v174 any + _ = tmp165 + var tmp173 any + var tmp174 any { // let // let binding "and__0__auto__" var v175 any = v108 _ = v175 - var v176 any + var tmp176 any if lang.IsTruthy(v175) { - v177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v178 := v177.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) - if v178.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v178))) + tmp177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp178 := tmp177.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) + if tmp178.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp178))) } - v179 := v178.Get() - v176 = v179 + tmp179 := tmp178.Get() + tmp176 = tmp179 } else { - v176 = v175 + tmp176 = v175 } - v174 = v176 + tmp174 = tmp176 } // end let - if lang.IsTruthy(v174) { - v175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v176 := v175.FindInternedVar(lang.NewSymbol("printf")) - if v176.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v176))) + if lang.IsTruthy(tmp174) { + tmp175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp176 := tmp175.FindInternedVar(lang.NewSymbol("printf")) + if tmp176.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp176))) } - v177 := v176.Get() - v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v179 := v178.FindInternedVar(lang.NewSymbol("ns-name")) - if v179.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) + tmp177 := tmp176.Get() + tmp178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp179 := tmp178.FindInternedVar(lang.NewSymbol("ns-name")) + if tmp179.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp179))) } - v180 := v179.Get() - v181 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v182 := v181.FindInternedVar(lang.NewSymbol("*ns*")) - if v182.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v182))) + tmp180 := tmp179.Get() + tmp181 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp182 := tmp181.FindInternedVar(lang.NewSymbol("*ns*")) + if tmp182.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp182))) } - v183 := v182.Get() - v184 := lang.Apply(v180, []any{v183}) - v185 := lang.Apply(v177, []any{"(glojure.core/in-ns '%s)\n", v184}) - v173 = v185 + tmp183 := tmp182.Get() + tmp184 := lang.Apply(tmp180, []any{tmp183}) + tmp185 := lang.Apply(tmp177, []any{"(glojure.core/in-ns '%s)\n", tmp184}) + tmp173 = tmp185 } else { - v173 = nil } - _ = v173 - var v186 any + _ = tmp173 + var tmp186 any if lang.IsTruthy(v64) { - var v187 any - v188 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v189 := v188.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) - if v189.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v189))) + var tmp187 any + tmp188 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp189 := tmp188.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) + if tmp189.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp189))) } - v190 := v189.Get() - if lang.IsTruthy(v190) { - v191 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v192 := v191.FindInternedVar(lang.NewSymbol("printf")) - if v192.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v192))) + tmp190 := tmp189.Get() + if lang.IsTruthy(tmp190) { + tmp191 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp192 := tmp191.FindInternedVar(lang.NewSymbol("printf")) + if tmp192.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp192))) } - v193 := v192.Get() - v194 := lang.Apply(v193, []any{"(glojure.core/alias '%s '%s)\n", v64, v25}) - v187 = v194 + tmp193 := tmp192.Get() + tmp194 := lang.Apply(tmp193, []any{"(glojure.core/alias '%s '%s)\n", v64, v25}) + tmp187 = tmp194 } else { - v187 = nil } - _ = v187 - v195 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v196 := v195.FindInternedVar(lang.NewSymbol("alias")) - if v196.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v196))) + _ = tmp187 + tmp195 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp196 := tmp195.FindInternedVar(lang.NewSymbol("alias")) + if tmp196.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp196))) } - v197 := v196.Get() - v198 := lang.Apply(v197, []any{v64, v25}) - v186 = v198 + tmp197 := tmp196.Get() + tmp198 := lang.Apply(tmp197, []any{v64, v25}) + tmp186 = tmp198 } else { - v186 = nil } - _ = v186 - var v199 any + _ = tmp186 + var tmp199 any if lang.IsTruthy(v94) { - var v200 any - v201 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v202 := v201.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) - if v202.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v202))) + var tmp200 any + tmp201 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp202 := tmp201.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) + if tmp202.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp202))) } - v203 := v202.Get() - if lang.IsTruthy(v203) { - v204 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v205 := v204.FindInternedVar(lang.NewSymbol("printf")) - if v205.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v205))) + tmp203 := tmp202.Get() + if lang.IsTruthy(tmp203) { + tmp204 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp205 := tmp204.FindInternedVar(lang.NewSymbol("printf")) + if tmp205.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp205))) } - v206 := v205.Get() - v207 := lang.Apply(v206, []any{"(glojure.core/alias '%s '%s)\n", v94, v25}) - v200 = v207 + tmp206 := tmp205.Get() + tmp207 := lang.Apply(tmp206, []any{"(glojure.core/alias '%s '%s)\n", v94, v25}) + tmp200 = tmp207 } else { - v200 = nil } - _ = v200 - v208 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v209 := v208.FindInternedVar(lang.NewSymbol("alias")) - if v209.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v209))) + _ = tmp200 + tmp208 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp209 := tmp208.FindInternedVar(lang.NewSymbol("alias")) + if tmp209.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp209))) } - v210 := v209.Get() - v211 := lang.Apply(v210, []any{v94, v25}) - v199 = v211 + tmp210 := tmp209.Get() + tmp211 := lang.Apply(tmp210, []any{v94, v25}) + tmp199 = tmp211 } else { - v199 = nil } - _ = v199 - var v212 any - var v213 any + _ = tmp199 + var tmp212 any + var tmp213 any { // let // let binding "or__0__auto__" var v214 any = v84 _ = v214 - var v215 any + var tmp215 any if lang.IsTruthy(v214) { - v215 = v214 + tmp215 = v214 } else { - v216 := lang.Apply(lang.NewKeyword("refer"), []any{v139}) - v215 = v216 + tmp216 := lang.Apply(lang.NewKeyword("refer"), []any{v139}) + tmp215 = tmp216 } - v213 = v215 + tmp213 = tmp215 } // end let - if lang.IsTruthy(v213) { - var v214 any - v215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v216 := v215.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) - if v216.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v216))) + if lang.IsTruthy(tmp213) { + var tmp214 any + tmp215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp216 := tmp215.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) + if tmp216.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp216))) } - v217 := v216.Get() - if lang.IsTruthy(v217) { - v218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v219 := v218.FindInternedVar(lang.NewSymbol("printf")) - if v219.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v219))) + tmp217 := tmp216.Get() + if lang.IsTruthy(tmp217) { + tmp218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp219 := tmp218.FindInternedVar(lang.NewSymbol("printf")) + if tmp219.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp219))) } - v220 := v219.Get() - v221 := lang.Apply(v220, []any{"(glojure.core/refer '%s", v25}) - _ = v221 - var v222 any + tmp220 := tmp219.Get() + tmp221 := lang.Apply(tmp220, []any{"(glojure.core/refer '%s", v25}) + _ = tmp221 + var tmp222 any { // let // let binding "seq_111" - v223 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v224 := v223.FindInternedVar(lang.NewSymbol("seq")) - if v224.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v224))) + tmp223 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp224 := tmp223.FindInternedVar(lang.NewSymbol("seq")) + if tmp224.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp224))) } - v225 := v224.Get() - v226 := lang.Apply(v225, []any{v139}) - var v227 any = v226 + tmp225 := tmp224.Get() + tmp226 := lang.Apply(tmp225, []any{v139}) + var v227 any = tmp226 _ = v227 // let binding "chunk_112" var v228 any = nil @@ -48997,445 +49102,443 @@ func init() { var v230 any = int64(0) _ = v230 for { - var v231 any - v232 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v233 := v232.FindInternedVar(lang.NewSymbol("<")) - if v233.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v233))) + var tmp231 any + tmp232 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp233 := tmp232.FindInternedVar(lang.NewSymbol("<")) + if tmp233.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp233))) } - v234 := v233.Get() - v235 := lang.Apply(v234, []any{v230, v229}) - if lang.IsTruthy(v235) { - var v236 any + tmp234 := tmp233.Get() + tmp235 := lang.Apply(tmp234, []any{v230, v229}) + if lang.IsTruthy(tmp235) { + var tmp236 any { // let // let binding "opt" - v237, _ := lang.FieldOrMethod(v228, "nth") - if reflect.TypeOf(v237).Kind() != reflect.Func { + tmp237, _ := lang.FieldOrMethod(v228, "nth") + if reflect.TypeOf(tmp237).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) } - v238 := lang.Apply(v237, []any{v230}) - var v239 any = v238 + tmp238 := lang.Apply(tmp237, []any{v230}) + var v239 any = tmp238 _ = v239 - v240 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v241 := v240.FindInternedVar(lang.NewSymbol("printf")) - if v241.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v241))) + tmp240 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp241 := tmp240.FindInternedVar(lang.NewSymbol("printf")) + if tmp241.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp241))) } - v242 := v241.Get() - v243 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v244 := v243.FindInternedVar(lang.NewSymbol("key")) - if v244.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v244))) + tmp242 := tmp241.Get() + tmp243 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp244 := tmp243.FindInternedVar(lang.NewSymbol("key")) + if tmp244.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp244))) } - v245 := v244.Get() - v246 := lang.Apply(v245, []any{v239}) - v247 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v248 := v247.FindInternedVar(lang.NewSymbol("print-str")) - if v248.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v248))) + tmp245 := tmp244.Get() + tmp246 := lang.Apply(tmp245, []any{v239}) + tmp247 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp248 := tmp247.FindInternedVar(lang.NewSymbol("print-str")) + if tmp248.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp248))) } - v249 := v248.Get() - v250 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v251 := v250.FindInternedVar(lang.NewSymbol("val")) - if v251.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v251))) + tmp249 := tmp248.Get() + tmp250 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp251 := tmp250.FindInternedVar(lang.NewSymbol("val")) + if tmp251.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp251))) } - v252 := v251.Get() - v253 := lang.Apply(v252, []any{v239}) - v254 := lang.Apply(v249, []any{v253}) - v255 := lang.Apply(v242, []any{" %s '%s", v246, v254}) - _ = v255 - var v256 any = v227 - var v257 any = v228 - var v258 any = v229 - v260 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v261 := v260.FindInternedVar(lang.NewSymbol("unchecked-inc")) - if v261.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v261))) + tmp252 := tmp251.Get() + tmp253 := lang.Apply(tmp252, []any{v239}) + tmp254 := lang.Apply(tmp249, []any{tmp253}) + tmp255 := lang.Apply(tmp242, []any{" %s '%s", tmp246, tmp254}) + _ = tmp255 + var tmp256 any = v227 + var tmp257 any = v228 + var tmp258 any = v229 + tmp260 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp261 := tmp260.FindInternedVar(lang.NewSymbol("unchecked-inc")) + if tmp261.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp261))) } - v262 := v261.Get() - v263 := lang.Apply(v262, []any{v230}) - var v259 any = v263 - v227 = v256 - v228 = v257 - v229 = v258 - v230 = v259 + tmp262 := tmp261.Get() + tmp263 := lang.Apply(tmp262, []any{v230}) + var tmp259 any = tmp263 + v227 = tmp256 + v228 = tmp257 + v229 = tmp258 + v230 = tmp259 continue } // end let - v231 = v236 + tmp231 = tmp236 } else { - var v237 any + var tmp237 any { // let // let binding "temp__0__auto__" - v238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v239 := v238.FindInternedVar(lang.NewSymbol("seq")) - if v239.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v239))) + tmp238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp239 := tmp238.FindInternedVar(lang.NewSymbol("seq")) + if tmp239.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp239))) } - v240 := v239.Get() - v241 := lang.Apply(v240, []any{v227}) - var v242 any = v241 + tmp240 := tmp239.Get() + tmp241 := lang.Apply(tmp240, []any{v227}) + var v242 any = tmp241 _ = v242 - var v243 any + var tmp243 any if lang.IsTruthy(v242) { - var v244 any + var tmp244 any { // let // let binding "seq_111" var v245 any = v242 _ = v245 - var v246 any - v247 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v248 := v247.FindInternedVar(lang.NewSymbol("chunked-seq?")) - if v248.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v248))) + var tmp246 any + tmp247 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp248 := tmp247.FindInternedVar(lang.NewSymbol("chunked-seq?")) + if tmp248.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp248))) } - v249 := v248.Get() - v250 := lang.Apply(v249, []any{v245}) - if lang.IsTruthy(v250) { - var v251 any + tmp249 := tmp248.Get() + tmp250 := lang.Apply(tmp249, []any{v245}) + if lang.IsTruthy(tmp250) { + var tmp251 any { // let // let binding "c__0__auto__" - v252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v253 := v252.FindInternedVar(lang.NewSymbol("chunk-first")) - if v253.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v253))) + tmp252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp253 := tmp252.FindInternedVar(lang.NewSymbol("chunk-first")) + if tmp253.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp253))) } - v254 := v253.Get() - v255 := lang.Apply(v254, []any{v245}) - var v256 any = v255 + tmp254 := tmp253.Get() + tmp255 := lang.Apply(tmp254, []any{v245}) + var v256 any = tmp255 _ = v256 - v258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v259 := v258.FindInternedVar(lang.NewSymbol("chunk-rest")) - if v259.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v259))) + tmp258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp259 := tmp258.FindInternedVar(lang.NewSymbol("chunk-rest")) + if tmp259.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp259))) } - v260 := v259.Get() - v261 := lang.Apply(v260, []any{v245}) - var v257 any = v261 - var v262 any = v256 - v264 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v265 := v264.FindInternedVar(lang.NewSymbol("int")) - if v265.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v265))) + tmp260 := tmp259.Get() + tmp261 := lang.Apply(tmp260, []any{v245}) + var tmp257 any = tmp261 + var tmp262 any = v256 + tmp264 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp265 := tmp264.FindInternedVar(lang.NewSymbol("int")) + if tmp265.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp265))) } - v266 := v265.Get() - v267 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v268 := v267.FindInternedVar(lang.NewSymbol("count")) - if v268.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v268))) + tmp266 := tmp265.Get() + tmp267 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp268 := tmp267.FindInternedVar(lang.NewSymbol("count")) + if tmp268.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp268))) } - v269 := v268.Get() - v270 := lang.Apply(v269, []any{v256}) - v271 := lang.Apply(v266, []any{v270}) - var v263 any = v271 - v273 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v274 := v273.FindInternedVar(lang.NewSymbol("int")) - if v274.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v274))) + tmp269 := tmp268.Get() + tmp270 := lang.Apply(tmp269, []any{v256}) + tmp271 := lang.Apply(tmp266, []any{tmp270}) + var tmp263 any = tmp271 + tmp273 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp274 := tmp273.FindInternedVar(lang.NewSymbol("int")) + if tmp274.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp274))) } - v275 := v274.Get() - v276 := lang.Apply(v275, []any{int64(0)}) - var v272 any = v276 - v227 = v257 - v228 = v262 - v229 = v263 - v230 = v272 + tmp275 := tmp274.Get() + tmp276 := lang.Apply(tmp275, []any{int64(0)}) + var tmp272 any = tmp276 + v227 = tmp257 + v228 = tmp262 + v229 = tmp263 + v230 = tmp272 continue } // end let - v246 = v251 + tmp246 = tmp251 } else { - var v252 any + var tmp252 any { // let // let binding "opt" - v253 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v254 := v253.FindInternedVar(lang.NewSymbol("first")) - if v254.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v254))) + tmp253 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp254 := tmp253.FindInternedVar(lang.NewSymbol("first")) + if tmp254.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp254))) } - v255 := v254.Get() - v256 := lang.Apply(v255, []any{v245}) - var v257 any = v256 + tmp255 := tmp254.Get() + tmp256 := lang.Apply(tmp255, []any{v245}) + var v257 any = tmp256 _ = v257 - v258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v259 := v258.FindInternedVar(lang.NewSymbol("printf")) - if v259.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v259))) + tmp258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp259 := tmp258.FindInternedVar(lang.NewSymbol("printf")) + if tmp259.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp259))) } - v260 := v259.Get() - v261 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v262 := v261.FindInternedVar(lang.NewSymbol("key")) - if v262.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v262))) + tmp260 := tmp259.Get() + tmp261 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp262 := tmp261.FindInternedVar(lang.NewSymbol("key")) + if tmp262.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp262))) } - v263 := v262.Get() - v264 := lang.Apply(v263, []any{v257}) - v265 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v266 := v265.FindInternedVar(lang.NewSymbol("print-str")) - if v266.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v266))) + tmp263 := tmp262.Get() + tmp264 := lang.Apply(tmp263, []any{v257}) + tmp265 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp266 := tmp265.FindInternedVar(lang.NewSymbol("print-str")) + if tmp266.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp266))) } - v267 := v266.Get() - v268 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v269 := v268.FindInternedVar(lang.NewSymbol("val")) - if v269.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v269))) + tmp267 := tmp266.Get() + tmp268 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp269 := tmp268.FindInternedVar(lang.NewSymbol("val")) + if tmp269.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp269))) } - v270 := v269.Get() - v271 := lang.Apply(v270, []any{v257}) - v272 := lang.Apply(v267, []any{v271}) - v273 := lang.Apply(v260, []any{" %s '%s", v264, v272}) - _ = v273 - v275 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v276 := v275.FindInternedVar(lang.NewSymbol("next")) - if v276.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v276))) + tmp270 := tmp269.Get() + tmp271 := lang.Apply(tmp270, []any{v257}) + tmp272 := lang.Apply(tmp267, []any{tmp271}) + tmp273 := lang.Apply(tmp260, []any{" %s '%s", tmp264, tmp272}) + _ = tmp273 + tmp275 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp276 := tmp275.FindInternedVar(lang.NewSymbol("next")) + if tmp276.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp276))) } - v277 := v276.Get() - v278 := lang.Apply(v277, []any{v245}) - var v274 any = v278 - var v279 any = nil - var v280 any = int64(0) - var v281 any = int64(0) - v227 = v274 - v228 = v279 - v229 = v280 - v230 = v281 + tmp277 := tmp276.Get() + tmp278 := lang.Apply(tmp277, []any{v245}) + var tmp274 any = tmp278 + var tmp279 any = nil + var tmp280 any = int64(0) + var tmp281 any = int64(0) + v227 = tmp274 + v228 = tmp279 + v229 = tmp280 + v230 = tmp281 continue } // end let - v246 = v252 + tmp246 = tmp252 } - v244 = v246 + tmp244 = tmp246 } // end let - v243 = v244 + tmp243 = tmp244 } else { - v243 = nil } - v237 = v243 + tmp237 = tmp243 } // end let - v231 = v237 + tmp231 = tmp237 } - v222 = v231 + tmp222 = tmp231 break } } // end let - _ = v222 - v223 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v224 := v223.FindInternedVar(lang.NewSymbol("printf")) - if v224.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v224))) + _ = tmp222 + tmp223 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp224 := tmp223.FindInternedVar(lang.NewSymbol("printf")) + if tmp224.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp224))) } - v225 := v224.Get() - v226 := lang.Apply(v225, []any{")\n"}) - v214 = v226 + tmp225 := tmp224.Get() + tmp226 := lang.Apply(tmp225, []any{")\n"}) + tmp214 = tmp226 } else { - v214 = nil } - _ = v214 - v227 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v228 := v227.FindInternedVar(lang.NewSymbol("apply")) - if v228.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v228))) + _ = tmp214 + tmp227 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp228 := tmp227.FindInternedVar(lang.NewSymbol("apply")) + if tmp228.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp228))) } - v229 := v228.Get() - v230 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v231 := v230.FindInternedVar(lang.NewSymbol("refer")) - if v231.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v231))) + tmp229 := tmp228.Get() + tmp230 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp231 := tmp230.FindInternedVar(lang.NewSymbol("refer")) + if tmp231.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp231))) } - v232 := v231.Get() - v233 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v234 := v233.FindInternedVar(lang.NewSymbol("mapcat")) - if v234.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v234))) + tmp232 := tmp231.Get() + tmp233 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp234 := tmp233.FindInternedVar(lang.NewSymbol("mapcat")) + if tmp234.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp234))) } - v235 := v234.Get() - v236 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v237 := v236.FindInternedVar(lang.NewSymbol("seq")) - if v237.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v237))) + tmp235 := tmp234.Get() + tmp236 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp237 := tmp236.FindInternedVar(lang.NewSymbol("seq")) + if tmp237.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp237))) } - v238 := v237.Get() - v239 := lang.Apply(v235, []any{v238, v139}) - v240 := lang.Apply(v229, []any{v232, v25, v239}) - v212 = v240 + tmp238 := tmp237.Get() + tmp239 := lang.Apply(tmp235, []any{tmp238, v139}) + tmp240 := lang.Apply(tmp229, []any{tmp232, v25, tmp239}) + tmp212 = tmp240 } else { - v212 = nil } - v160 = v212 + tmp160 = tmp212 }() - v149 = v160 + tmp149 = tmp160 } // end let - v15 = v149 + tmp15 = tmp149 } // end let - return v15 + return tmp15 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // load-libs { - v0 := lang.NewSymbol("load-libs").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Loads libs, interpreting libspecs, prefix lists, and flags for\n forwarding to load-lib", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5951), lang.NewKeyword("end-line"), int(5951), lang.NewKeyword("private"), true)).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("load-libs").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Loads libs, interpreting libspecs, prefix lists, and flags for\n forwarding to load-lib", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5951), lang.NewKeyword("end-line"), int(5951), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v3 := lang.NewList(args[0:]...) - var v4 any + var v3 any = lang.NewList(args[0:]...) + _ = v3 + var tmp4 any { // let // let binding "flags" - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("filter")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("keyword?")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v7, []any{v10, v3}) - var v12 any = v11 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("filter")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("keyword?")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp7, []any{tmp10, v3}) + var v12 any = tmp11 _ = v12 // let binding "opts" - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("interleave")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("repeat")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{true}) - v20 := lang.Apply(v15, []any{v12, v19}) - var v21 any = v20 + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("interleave")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("repeat")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{true}) + tmp20 := lang.Apply(tmp15, []any{v12, tmp19}) + var v21 any = tmp20 _ = v21 // let binding "args" - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("filter")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("complement")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("keyword?")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.Apply(v27, []any{v30}) - v32 := lang.Apply(v24, []any{v31, v3}) - var v33 any = v32 + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("filter")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("complement")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("keyword?")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.Apply(tmp27, []any{tmp30}) + tmp32 := lang.Apply(tmp24, []any{tmp31, v3}) + var v33 any = tmp32 _ = v33 - var v34 any + var tmp34 any { // let // let binding "supported" - v35 := lang.CreatePersistentTreeSet(lang.NewKeyword("as"), lang.NewKeyword("reload"), lang.NewKeyword("reload-all"), lang.NewKeyword("require"), lang.NewKeyword("use"), lang.NewKeyword("verbose"), lang.NewKeyword("refer"), lang.NewKeyword("as-alias")) - v36 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5959), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(5959), lang.NewKeyword("end-column"), int(86)) - v37, err := lang.WithMeta(v35, v36.(lang.IPersistentMap)) + tmp35 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{lang.NewKeyword("as"), lang.NewKeyword("reload"), lang.NewKeyword("reload-all"), lang.NewKeyword("require"), lang.NewKeyword("use"), lang.NewKeyword("verbose"), lang.NewKeyword("refer"), lang.NewKeyword("as-alias")})) + tmp36 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5959), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(5959), lang.NewKeyword("end-column"), int(86)) + tmp37, err := lang.WithMeta(tmp35, tmp36.(lang.IPersistentMap)) if err != nil { panic(err) } - var v38 any = v37 + var v38 any = tmp37 _ = v38 // let binding "unsupported" - v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v40 := v39.FindInternedVar(lang.NewSymbol("seq")) - if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) - } - v41 := v40.Get() - v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v43 := v42.FindInternedVar(lang.NewSymbol("remove")) - if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) - } - v44 := v43.Get() - v45 := lang.Apply(v44, []any{v38, v12}) - v46 := lang.Apply(v41, []any{v45}) - var v47 any = v46 + tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp40 := tmp39.FindInternedVar(lang.NewSymbol("seq")) + if tmp40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) + } + tmp41 := tmp40.Get() + tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp43 := tmp42.FindInternedVar(lang.NewSymbol("remove")) + if tmp43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) + } + tmp44 := tmp43.Get() + tmp45 := lang.Apply(tmp44, []any{v38, v12}) + tmp46 := lang.Apply(tmp41, []any{tmp45}) + var v47 any = tmp46 _ = v47 - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("throw-if")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v52 := v51.FindInternedVar(lang.NewSymbol("apply")) - if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) - } - v53 := v52.Get() - v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v55 := v54.FindInternedVar(lang.NewSymbol("str")) - if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) - } - v56 := v55.Get() - v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v58 := v57.FindInternedVar(lang.NewSymbol("interpose")) - if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) - } - v59 := v58.Get() - v60 := lang.Apply(v59, []any{lang.NewChar(44), v47}) - v61 := lang.Apply(v53, []any{v56, "Unsupported option(s) supplied: ", v60}) - v62 := lang.Apply(v50, []any{v47, v61}) - v34 = v62 + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("throw-if")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp52 := tmp51.FindInternedVar(lang.NewSymbol("apply")) + if tmp52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp52))) + } + tmp53 := tmp52.Get() + tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp55 := tmp54.FindInternedVar(lang.NewSymbol("str")) + if tmp55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) + } + tmp56 := tmp55.Get() + tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp58 := tmp57.FindInternedVar(lang.NewSymbol("interpose")) + if tmp58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) + } + tmp59 := tmp58.Get() + tmp60 := lang.Apply(tmp59, []any{lang.NewChar(44), v47}) + tmp61 := lang.Apply(tmp53, []any{tmp56, "Unsupported option(s) supplied: ", tmp60}) + tmp62 := lang.Apply(tmp50, []any{v47, tmp61}) + tmp34 = tmp62 } // end let - _ = v34 - v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v36 := v35.FindInternedVar(lang.NewSymbol("throw-if")) - if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) - } - v37 := v36.Get() - v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v39 := v38.FindInternedVar(lang.NewSymbol("not")) - if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) - } - v40 := v39.Get() - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("seq")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) - } - v43 := v42.Get() - v44 := lang.Apply(v43, []any{v33}) - v45 := lang.Apply(v40, []any{v44}) - v46 := lang.Apply(v37, []any{v45, "Nothing specified to load"}) - _ = v46 - var v47 any + _ = tmp34 + tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp36 := tmp35.FindInternedVar(lang.NewSymbol("throw-if")) + if tmp36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) + } + tmp37 := tmp36.Get() + tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp39 := tmp38.FindInternedVar(lang.NewSymbol("not")) + if tmp39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) + } + tmp40 := tmp39.Get() + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("seq")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := lang.Apply(tmp43, []any{v33}) + tmp45 := lang.Apply(tmp40, []any{tmp44}) + tmp46 := lang.Apply(tmp37, []any{tmp45, "Nothing specified to load"}) + _ = tmp46 + var tmp47 any { // let // let binding "seq_115" - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("seq")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v33}) - var v52 any = v51 + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("seq")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v33}) + var v52 any = tmp51 _ = v52 // let binding "chunk_116" var v53 any = nil @@ -49447,90 +49550,90 @@ func init() { var v55 any = int64(0) _ = v55 for { - var v56 any - v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v58 := v57.FindInternedVar(lang.NewSymbol("<")) - if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) - } - v59 := v58.Get() - v60 := lang.Apply(v59, []any{v55, v54}) - if lang.IsTruthy(v60) { - var v61 any + var tmp56 any + tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp58 := tmp57.FindInternedVar(lang.NewSymbol("<")) + if tmp58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) + } + tmp59 := tmp58.Get() + tmp60 := lang.Apply(tmp59, []any{v55, v54}) + if lang.IsTruthy(tmp60) { + var tmp61 any { // let // let binding "arg" - v62, _ := lang.FieldOrMethod(v53, "nth") - if reflect.TypeOf(v62).Kind() != reflect.Func { + tmp62, _ := lang.FieldOrMethod(v53, "nth") + if reflect.TypeOf(tmp62).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) } - v63 := lang.Apply(v62, []any{v55}) - var v64 any = v63 + tmp63 := lang.Apply(tmp62, []any{v55}) + var v64 any = tmp63 _ = v64 - var v65 any - v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v67 := v66.FindInternedVar(lang.NewSymbol("libspec?")) - if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) + var tmp65 any + tmp66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp67 := tmp66.FindInternedVar(lang.NewSymbol("libspec?")) + if tmp67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp67))) } - v68 := v67.Get() - v69 := lang.Apply(v68, []any{v64}) - if lang.IsTruthy(v69) { - v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v71 := v70.FindInternedVar(lang.NewSymbol("apply")) - if v71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) + tmp68 := tmp67.Get() + tmp69 := lang.Apply(tmp68, []any{v64}) + if lang.IsTruthy(tmp69) { + tmp70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp71 := tmp70.FindInternedVar(lang.NewSymbol("apply")) + if tmp71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp71))) } - v72 := v71.Get() - v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v74 := v73.FindInternedVar(lang.NewSymbol("load-lib")) - if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) + tmp72 := tmp71.Get() + tmp73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp74 := tmp73.FindInternedVar(lang.NewSymbol("load-lib")) + if tmp74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp74))) } - v75 := v74.Get() - v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v77 := v76.FindInternedVar(lang.NewSymbol("prependss")) - if v77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) + tmp75 := tmp74.Get() + tmp76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp77 := tmp76.FindInternedVar(lang.NewSymbol("prependss")) + if tmp77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp77))) } - v78 := v77.Get() - v79 := lang.Apply(v78, []any{v64, v21}) - v80 := lang.Apply(v72, []any{v75, nil, v79}) - v65 = v80 + tmp78 := tmp77.Get() + tmp79 := lang.Apply(tmp78, []any{v64, v21}) + tmp80 := lang.Apply(tmp72, []any{tmp75, nil, tmp79}) + tmp65 = tmp80 } else { - var v81 any + var tmp81 any { // let // let binding "vec__119" var v82 any = v64 _ = v82 // let binding "seq__120" - v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v84 := v83.FindInternedVar(lang.NewSymbol("seq")) - if v84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) + tmp83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp84 := tmp83.FindInternedVar(lang.NewSymbol("seq")) + if tmp84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp84))) } - v85 := v84.Get() - v86 := lang.Apply(v85, []any{v82}) - var v87 any = v86 + tmp85 := tmp84.Get() + tmp86 := lang.Apply(tmp85, []any{v82}) + var v87 any = tmp86 _ = v87 // let binding "first__121" - v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v89 := v88.FindInternedVar(lang.NewSymbol("first")) - if v89.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) + tmp88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp89 := tmp88.FindInternedVar(lang.NewSymbol("first")) + if tmp89.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp89))) } - v90 := v89.Get() - v91 := lang.Apply(v90, []any{v87}) - var v92 any = v91 + tmp90 := tmp89.Get() + tmp91 := lang.Apply(tmp90, []any{v87}) + var v92 any = tmp91 _ = v92 // let binding "seq__120" - v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v94 := v93.FindInternedVar(lang.NewSymbol("next")) - if v94.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) + tmp93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp94 := tmp93.FindInternedVar(lang.NewSymbol("next")) + if tmp94.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp94))) } - v95 := v94.Get() - v96 := lang.Apply(v95, []any{v87}) - var v97 any = v96 + tmp95 := tmp94.Get() + tmp96 := lang.Apply(tmp95, []any{v87}) + var v97 any = tmp96 _ = v97 // let binding "prefix" var v98 any = v92 @@ -49538,32 +49641,32 @@ func init() { // let binding "args" var v99 any = v97 _ = v99 - v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v101 := v100.FindInternedVar(lang.NewSymbol("throw-if")) - if v101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) + tmp100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp101 := tmp100.FindInternedVar(lang.NewSymbol("throw-if")) + if tmp101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp101))) } - v102 := v101.Get() - v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v104 := v103.FindInternedVar(lang.NewSymbol("nil?")) - if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) + tmp102 := tmp101.Get() + tmp103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp104 := tmp103.FindInternedVar(lang.NewSymbol("nil?")) + if tmp104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp104))) } - v105 := v104.Get() - v106 := lang.Apply(v105, []any{v98}) - v107 := lang.Apply(v102, []any{v106, "prefix cannot be nil"}) - _ = v107 - var v108 any + tmp105 := tmp104.Get() + tmp106 := lang.Apply(tmp105, []any{v98}) + tmp107 := lang.Apply(tmp102, []any{tmp106, "prefix cannot be nil"}) + _ = tmp107 + var tmp108 any { // let // let binding "seq_122" - v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v110 := v109.FindInternedVar(lang.NewSymbol("seq")) - if v110.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) + tmp109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp110 := tmp109.FindInternedVar(lang.NewSymbol("seq")) + if tmp110.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp110))) } - v111 := v110.Get() - v112 := lang.Apply(v111, []any{v99}) - var v113 any = v112 + tmp111 := tmp110.Get() + tmp112 := lang.Apply(tmp111, []any{v99}) + var v113 any = tmp112 _ = v113 // let binding "chunk_123" var v114 any = nil @@ -49575,392 +49678,391 @@ func init() { var v116 any = int64(0) _ = v116 for { - var v117 any - v118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v119 := v118.FindInternedVar(lang.NewSymbol("<")) - if v119.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v119))) + var tmp117 any + tmp118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp119 := tmp118.FindInternedVar(lang.NewSymbol("<")) + if tmp119.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp119))) } - v120 := v119.Get() - v121 := lang.Apply(v120, []any{v116, v115}) - if lang.IsTruthy(v121) { - var v122 any + tmp120 := tmp119.Get() + tmp121 := lang.Apply(tmp120, []any{v116, v115}) + if lang.IsTruthy(tmp121) { + var tmp122 any { // let // let binding "arg" - v123, _ := lang.FieldOrMethod(v114, "nth") - if reflect.TypeOf(v123).Kind() != reflect.Func { + tmp123, _ := lang.FieldOrMethod(v114, "nth") + if reflect.TypeOf(tmp123).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) } - v124 := lang.Apply(v123, []any{v116}) - var v125 any = v124 + tmp124 := lang.Apply(tmp123, []any{v116}) + var v125 any = tmp124 _ = v125 - v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v127 := v126.FindInternedVar(lang.NewSymbol("apply")) - if v127.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) + tmp126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp127 := tmp126.FindInternedVar(lang.NewSymbol("apply")) + if tmp127.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp127))) } - v128 := v127.Get() - v129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v130 := v129.FindInternedVar(lang.NewSymbol("load-lib")) - if v130.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v130))) + tmp128 := tmp127.Get() + tmp129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp130 := tmp129.FindInternedVar(lang.NewSymbol("load-lib")) + if tmp130.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp130))) } - v131 := v130.Get() - v132 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v133 := v132.FindInternedVar(lang.NewSymbol("prependss")) - if v133.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v133))) + tmp131 := tmp130.Get() + tmp132 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp133 := tmp132.FindInternedVar(lang.NewSymbol("prependss")) + if tmp133.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp133))) } - v134 := v133.Get() - v135 := lang.Apply(v134, []any{v125, v21}) - v136 := lang.Apply(v128, []any{v131, v98, v135}) - _ = v136 - var v137 any = v113 - var v138 any = v114 - var v139 any = v115 - v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v142 := v141.FindInternedVar(lang.NewSymbol("unchecked-inc")) - if v142.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) + tmp134 := tmp133.Get() + tmp135 := lang.Apply(tmp134, []any{v125, v21}) + tmp136 := lang.Apply(tmp128, []any{tmp131, v98, tmp135}) + _ = tmp136 + var tmp137 any = v113 + var tmp138 any = v114 + var tmp139 any = v115 + tmp141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp142 := tmp141.FindInternedVar(lang.NewSymbol("unchecked-inc")) + if tmp142.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp142))) } - v143 := v142.Get() - v144 := lang.Apply(v143, []any{v116}) - var v140 any = v144 - v113 = v137 - v114 = v138 - v115 = v139 - v116 = v140 + tmp143 := tmp142.Get() + tmp144 := lang.Apply(tmp143, []any{v116}) + var tmp140 any = tmp144 + v113 = tmp137 + v114 = tmp138 + v115 = tmp139 + v116 = tmp140 continue } // end let - v117 = v122 + tmp117 = tmp122 } else { - var v123 any + var tmp123 any { // let // let binding "temp__0__auto__" - v124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v125 := v124.FindInternedVar(lang.NewSymbol("seq")) - if v125.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v125))) + tmp124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp125 := tmp124.FindInternedVar(lang.NewSymbol("seq")) + if tmp125.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp125))) } - v126 := v125.Get() - v127 := lang.Apply(v126, []any{v113}) - var v128 any = v127 + tmp126 := tmp125.Get() + tmp127 := lang.Apply(tmp126, []any{v113}) + var v128 any = tmp127 _ = v128 - var v129 any + var tmp129 any if lang.IsTruthy(v128) { - var v130 any + var tmp130 any { // let // let binding "seq_122" var v131 any = v128 _ = v131 - var v132 any - v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v134 := v133.FindInternedVar(lang.NewSymbol("chunked-seq?")) - if v134.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) + var tmp132 any + tmp133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp134 := tmp133.FindInternedVar(lang.NewSymbol("chunked-seq?")) + if tmp134.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp134))) } - v135 := v134.Get() - v136 := lang.Apply(v135, []any{v131}) - if lang.IsTruthy(v136) { - var v137 any + tmp135 := tmp134.Get() + tmp136 := lang.Apply(tmp135, []any{v131}) + if lang.IsTruthy(tmp136) { + var tmp137 any { // let // let binding "c__0__auto__" - v138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v139 := v138.FindInternedVar(lang.NewSymbol("chunk-first")) - if v139.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v139))) + tmp138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp139 := tmp138.FindInternedVar(lang.NewSymbol("chunk-first")) + if tmp139.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp139))) } - v140 := v139.Get() - v141 := lang.Apply(v140, []any{v131}) - var v142 any = v141 + tmp140 := tmp139.Get() + tmp141 := lang.Apply(tmp140, []any{v131}) + var v142 any = tmp141 _ = v142 - v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v145 := v144.FindInternedVar(lang.NewSymbol("chunk-rest")) - if v145.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) + tmp144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp145 := tmp144.FindInternedVar(lang.NewSymbol("chunk-rest")) + if tmp145.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp145))) } - v146 := v145.Get() - v147 := lang.Apply(v146, []any{v131}) - var v143 any = v147 - var v148 any = v142 - v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v151 := v150.FindInternedVar(lang.NewSymbol("int")) - if v151.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) + tmp146 := tmp145.Get() + tmp147 := lang.Apply(tmp146, []any{v131}) + var tmp143 any = tmp147 + var tmp148 any = v142 + tmp150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp151 := tmp150.FindInternedVar(lang.NewSymbol("int")) + if tmp151.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp151))) } - v152 := v151.Get() - v153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v154 := v153.FindInternedVar(lang.NewSymbol("count")) - if v154.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v154))) + tmp152 := tmp151.Get() + tmp153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp154 := tmp153.FindInternedVar(lang.NewSymbol("count")) + if tmp154.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp154))) } - v155 := v154.Get() - v156 := lang.Apply(v155, []any{v142}) - v157 := lang.Apply(v152, []any{v156}) - var v149 any = v157 - v159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v160 := v159.FindInternedVar(lang.NewSymbol("int")) - if v160.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v160))) + tmp155 := tmp154.Get() + tmp156 := lang.Apply(tmp155, []any{v142}) + tmp157 := lang.Apply(tmp152, []any{tmp156}) + var tmp149 any = tmp157 + tmp159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp160 := tmp159.FindInternedVar(lang.NewSymbol("int")) + if tmp160.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp160))) } - v161 := v160.Get() - v162 := lang.Apply(v161, []any{int64(0)}) - var v158 any = v162 - v113 = v143 - v114 = v148 - v115 = v149 - v116 = v158 + tmp161 := tmp160.Get() + tmp162 := lang.Apply(tmp161, []any{int64(0)}) + var tmp158 any = tmp162 + v113 = tmp143 + v114 = tmp148 + v115 = tmp149 + v116 = tmp158 continue } // end let - v132 = v137 + tmp132 = tmp137 } else { - var v138 any + var tmp138 any { // let // let binding "arg" - v139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v140 := v139.FindInternedVar(lang.NewSymbol("first")) - if v140.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v140))) + tmp139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp140 := tmp139.FindInternedVar(lang.NewSymbol("first")) + if tmp140.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp140))) } - v141 := v140.Get() - v142 := lang.Apply(v141, []any{v131}) - var v143 any = v142 + tmp141 := tmp140.Get() + tmp142 := lang.Apply(tmp141, []any{v131}) + var v143 any = tmp142 _ = v143 - v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v145 := v144.FindInternedVar(lang.NewSymbol("apply")) - if v145.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) + tmp144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp145 := tmp144.FindInternedVar(lang.NewSymbol("apply")) + if tmp145.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp145))) } - v146 := v145.Get() - v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v148 := v147.FindInternedVar(lang.NewSymbol("load-lib")) - if v148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) + tmp146 := tmp145.Get() + tmp147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp148 := tmp147.FindInternedVar(lang.NewSymbol("load-lib")) + if tmp148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp148))) } - v149 := v148.Get() - v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v151 := v150.FindInternedVar(lang.NewSymbol("prependss")) - if v151.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) + tmp149 := tmp148.Get() + tmp150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp151 := tmp150.FindInternedVar(lang.NewSymbol("prependss")) + if tmp151.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp151))) } - v152 := v151.Get() - v153 := lang.Apply(v152, []any{v143, v21}) - v154 := lang.Apply(v146, []any{v149, v98, v153}) - _ = v154 - v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v157 := v156.FindInternedVar(lang.NewSymbol("next")) - if v157.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) + tmp152 := tmp151.Get() + tmp153 := lang.Apply(tmp152, []any{v143, v21}) + tmp154 := lang.Apply(tmp146, []any{tmp149, v98, tmp153}) + _ = tmp154 + tmp156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp157 := tmp156.FindInternedVar(lang.NewSymbol("next")) + if tmp157.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp157))) } - v158 := v157.Get() - v159 := lang.Apply(v158, []any{v131}) - var v155 any = v159 - var v160 any = nil - var v161 any = int64(0) - var v162 any = int64(0) - v113 = v155 - v114 = v160 - v115 = v161 - v116 = v162 + tmp158 := tmp157.Get() + tmp159 := lang.Apply(tmp158, []any{v131}) + var tmp155 any = tmp159 + var tmp160 any = nil + var tmp161 any = int64(0) + var tmp162 any = int64(0) + v113 = tmp155 + v114 = tmp160 + v115 = tmp161 + v116 = tmp162 continue } // end let - v132 = v138 + tmp132 = tmp138 } - v130 = v132 + tmp130 = tmp132 } // end let - v129 = v130 + tmp129 = tmp130 } else { - v129 = nil } - v123 = v129 + tmp123 = tmp129 } // end let - v117 = v123 + tmp117 = tmp123 } - v108 = v117 + tmp108 = tmp117 break } } // end let - v81 = v108 + tmp81 = tmp108 } // end let - v65 = v81 + tmp65 = tmp81 } - _ = v65 - var v82 any = v52 - var v83 any = v53 - var v84 any = v54 - v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v87 := v86.FindInternedVar(lang.NewSymbol("unchecked-inc")) - if v87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) + _ = tmp65 + var tmp82 any = v52 + var tmp83 any = v53 + var tmp84 any = v54 + tmp86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp87 := tmp86.FindInternedVar(lang.NewSymbol("unchecked-inc")) + if tmp87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp87))) } - v88 := v87.Get() - v89 := lang.Apply(v88, []any{v55}) - var v85 any = v89 - v52 = v82 - v53 = v83 - v54 = v84 - v55 = v85 + tmp88 := tmp87.Get() + tmp89 := lang.Apply(tmp88, []any{v55}) + var tmp85 any = tmp89 + v52 = tmp82 + v53 = tmp83 + v54 = tmp84 + v55 = tmp85 continue } // end let - v56 = v61 + tmp56 = tmp61 } else { - var v62 any + var tmp62 any { // let // let binding "temp__0__auto__" - v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v64 := v63.FindInternedVar(lang.NewSymbol("seq")) - if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) + tmp63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp64 := tmp63.FindInternedVar(lang.NewSymbol("seq")) + if tmp64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp64))) } - v65 := v64.Get() - v66 := lang.Apply(v65, []any{v52}) - var v67 any = v66 + tmp65 := tmp64.Get() + tmp66 := lang.Apply(tmp65, []any{v52}) + var v67 any = tmp66 _ = v67 - var v68 any + var tmp68 any if lang.IsTruthy(v67) { - var v69 any + var tmp69 any { // let // let binding "seq_115" var v70 any = v67 _ = v70 - var v71 any - v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v73 := v72.FindInternedVar(lang.NewSymbol("chunked-seq?")) - if v73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) + var tmp71 any + tmp72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp73 := tmp72.FindInternedVar(lang.NewSymbol("chunked-seq?")) + if tmp73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp73))) } - v74 := v73.Get() - v75 := lang.Apply(v74, []any{v70}) - if lang.IsTruthy(v75) { - var v76 any + tmp74 := tmp73.Get() + tmp75 := lang.Apply(tmp74, []any{v70}) + if lang.IsTruthy(tmp75) { + var tmp76 any { // let // let binding "c__0__auto__" - v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v78 := v77.FindInternedVar(lang.NewSymbol("chunk-first")) - if v78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) + tmp77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp78 := tmp77.FindInternedVar(lang.NewSymbol("chunk-first")) + if tmp78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp78))) } - v79 := v78.Get() - v80 := lang.Apply(v79, []any{v70}) - var v81 any = v80 + tmp79 := tmp78.Get() + tmp80 := lang.Apply(tmp79, []any{v70}) + var v81 any = tmp80 _ = v81 - v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v84 := v83.FindInternedVar(lang.NewSymbol("chunk-rest")) - if v84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) + tmp83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp84 := tmp83.FindInternedVar(lang.NewSymbol("chunk-rest")) + if tmp84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp84))) } - v85 := v84.Get() - v86 := lang.Apply(v85, []any{v70}) - var v82 any = v86 - var v87 any = v81 - v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v90 := v89.FindInternedVar(lang.NewSymbol("int")) - if v90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) + tmp85 := tmp84.Get() + tmp86 := lang.Apply(tmp85, []any{v70}) + var tmp82 any = tmp86 + var tmp87 any = v81 + tmp89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp90 := tmp89.FindInternedVar(lang.NewSymbol("int")) + if tmp90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp90))) } - v91 := v90.Get() - v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v93 := v92.FindInternedVar(lang.NewSymbol("count")) - if v93.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) + tmp91 := tmp90.Get() + tmp92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp93 := tmp92.FindInternedVar(lang.NewSymbol("count")) + if tmp93.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp93))) } - v94 := v93.Get() - v95 := lang.Apply(v94, []any{v81}) - v96 := lang.Apply(v91, []any{v95}) - var v88 any = v96 - v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v99 := v98.FindInternedVar(lang.NewSymbol("int")) - if v99.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) + tmp94 := tmp93.Get() + tmp95 := lang.Apply(tmp94, []any{v81}) + tmp96 := lang.Apply(tmp91, []any{tmp95}) + var tmp88 any = tmp96 + tmp98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp99 := tmp98.FindInternedVar(lang.NewSymbol("int")) + if tmp99.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp99))) } - v100 := v99.Get() - v101 := lang.Apply(v100, []any{int64(0)}) - var v97 any = v101 - v52 = v82 - v53 = v87 - v54 = v88 - v55 = v97 + tmp100 := tmp99.Get() + tmp101 := lang.Apply(tmp100, []any{int64(0)}) + var tmp97 any = tmp101 + v52 = tmp82 + v53 = tmp87 + v54 = tmp88 + v55 = tmp97 continue } // end let - v71 = v76 + tmp71 = tmp76 } else { - var v77 any + var tmp77 any { // let // let binding "arg" - v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v79 := v78.FindInternedVar(lang.NewSymbol("first")) - if v79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) + tmp78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp79 := tmp78.FindInternedVar(lang.NewSymbol("first")) + if tmp79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp79))) } - v80 := v79.Get() - v81 := lang.Apply(v80, []any{v70}) - var v82 any = v81 + tmp80 := tmp79.Get() + tmp81 := lang.Apply(tmp80, []any{v70}) + var v82 any = tmp81 _ = v82 - var v83 any - v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v85 := v84.FindInternedVar(lang.NewSymbol("libspec?")) - if v85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) + var tmp83 any + tmp84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp85 := tmp84.FindInternedVar(lang.NewSymbol("libspec?")) + if tmp85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp85))) } - v86 := v85.Get() - v87 := lang.Apply(v86, []any{v82}) - if lang.IsTruthy(v87) { - v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v89 := v88.FindInternedVar(lang.NewSymbol("apply")) - if v89.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) + tmp86 := tmp85.Get() + tmp87 := lang.Apply(tmp86, []any{v82}) + if lang.IsTruthy(tmp87) { + tmp88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp89 := tmp88.FindInternedVar(lang.NewSymbol("apply")) + if tmp89.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp89))) } - v90 := v89.Get() - v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v92 := v91.FindInternedVar(lang.NewSymbol("load-lib")) - if v92.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) + tmp90 := tmp89.Get() + tmp91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp92 := tmp91.FindInternedVar(lang.NewSymbol("load-lib")) + if tmp92.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp92))) } - v93 := v92.Get() - v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v95 := v94.FindInternedVar(lang.NewSymbol("prependss")) - if v95.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) + tmp93 := tmp92.Get() + tmp94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp95 := tmp94.FindInternedVar(lang.NewSymbol("prependss")) + if tmp95.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp95))) } - v96 := v95.Get() - v97 := lang.Apply(v96, []any{v82, v21}) - v98 := lang.Apply(v90, []any{v93, nil, v97}) - v83 = v98 + tmp96 := tmp95.Get() + tmp97 := lang.Apply(tmp96, []any{v82, v21}) + tmp98 := lang.Apply(tmp90, []any{tmp93, nil, tmp97}) + tmp83 = tmp98 } else { - var v99 any + var tmp99 any { // let // let binding "vec__126" var v100 any = v82 _ = v100 // let binding "seq__127" - v101 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v102 := v101.FindInternedVar(lang.NewSymbol("seq")) - if v102.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v102))) + tmp101 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp102 := tmp101.FindInternedVar(lang.NewSymbol("seq")) + if tmp102.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp102))) } - v103 := v102.Get() - v104 := lang.Apply(v103, []any{v100}) - var v105 any = v104 + tmp103 := tmp102.Get() + tmp104 := lang.Apply(tmp103, []any{v100}) + var v105 any = tmp104 _ = v105 // let binding "first__128" - v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v107 := v106.FindInternedVar(lang.NewSymbol("first")) - if v107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) + tmp106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp107 := tmp106.FindInternedVar(lang.NewSymbol("first")) + if tmp107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp107))) } - v108 := v107.Get() - v109 := lang.Apply(v108, []any{v105}) - var v110 any = v109 + tmp108 := tmp107.Get() + tmp109 := lang.Apply(tmp108, []any{v105}) + var v110 any = tmp109 _ = v110 // let binding "seq__127" - v111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v112 := v111.FindInternedVar(lang.NewSymbol("next")) - if v112.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v112))) + tmp111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp112 := tmp111.FindInternedVar(lang.NewSymbol("next")) + if tmp112.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp112))) } - v113 := v112.Get() - v114 := lang.Apply(v113, []any{v105}) - var v115 any = v114 + tmp113 := tmp112.Get() + tmp114 := lang.Apply(tmp113, []any{v105}) + var v115 any = tmp114 _ = v115 // let binding "prefix" var v116 any = v110 @@ -49968,32 +50070,32 @@ func init() { // let binding "args" var v117 any = v115 _ = v117 - v118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v119 := v118.FindInternedVar(lang.NewSymbol("throw-if")) - if v119.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v119))) + tmp118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp119 := tmp118.FindInternedVar(lang.NewSymbol("throw-if")) + if tmp119.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp119))) } - v120 := v119.Get() - v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v122 := v121.FindInternedVar(lang.NewSymbol("nil?")) - if v122.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) + tmp120 := tmp119.Get() + tmp121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp122 := tmp121.FindInternedVar(lang.NewSymbol("nil?")) + if tmp122.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp122))) } - v123 := v122.Get() - v124 := lang.Apply(v123, []any{v116}) - v125 := lang.Apply(v120, []any{v124, "prefix cannot be nil"}) - _ = v125 - var v126 any + tmp123 := tmp122.Get() + tmp124 := lang.Apply(tmp123, []any{v116}) + tmp125 := lang.Apply(tmp120, []any{tmp124, "prefix cannot be nil"}) + _ = tmp125 + var tmp126 any { // let // let binding "seq_129" - v127 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v128 := v127.FindInternedVar(lang.NewSymbol("seq")) - if v128.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v128))) + tmp127 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp128 := tmp127.FindInternedVar(lang.NewSymbol("seq")) + if tmp128.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp128))) } - v129 := v128.Get() - v130 := lang.Apply(v129, []any{v117}) - var v131 any = v130 + tmp129 := tmp128.Get() + tmp130 := lang.Apply(tmp129, []any{v117}) + var v131 any = tmp130 _ = v131 // let binding "chunk_130" var v132 any = nil @@ -50005,265 +50107,263 @@ func init() { var v134 any = int64(0) _ = v134 for { - var v135 any - v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v137 := v136.FindInternedVar(lang.NewSymbol("<")) - if v137.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) + var tmp135 any + tmp136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp137 := tmp136.FindInternedVar(lang.NewSymbol("<")) + if tmp137.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp137))) } - v138 := v137.Get() - v139 := lang.Apply(v138, []any{v134, v133}) - if lang.IsTruthy(v139) { - var v140 any + tmp138 := tmp137.Get() + tmp139 := lang.Apply(tmp138, []any{v134, v133}) + if lang.IsTruthy(tmp139) { + var tmp140 any { // let // let binding "arg" - v141, _ := lang.FieldOrMethod(v132, "nth") - if reflect.TypeOf(v141).Kind() != reflect.Func { + tmp141, _ := lang.FieldOrMethod(v132, "nth") + if reflect.TypeOf(tmp141).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) } - v142 := lang.Apply(v141, []any{v134}) - var v143 any = v142 + tmp142 := lang.Apply(tmp141, []any{v134}) + var v143 any = tmp142 _ = v143 - v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v145 := v144.FindInternedVar(lang.NewSymbol("apply")) - if v145.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) + tmp144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp145 := tmp144.FindInternedVar(lang.NewSymbol("apply")) + if tmp145.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp145))) } - v146 := v145.Get() - v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v148 := v147.FindInternedVar(lang.NewSymbol("load-lib")) - if v148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) + tmp146 := tmp145.Get() + tmp147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp148 := tmp147.FindInternedVar(lang.NewSymbol("load-lib")) + if tmp148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp148))) } - v149 := v148.Get() - v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v151 := v150.FindInternedVar(lang.NewSymbol("prependss")) - if v151.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) + tmp149 := tmp148.Get() + tmp150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp151 := tmp150.FindInternedVar(lang.NewSymbol("prependss")) + if tmp151.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp151))) } - v152 := v151.Get() - v153 := lang.Apply(v152, []any{v143, v21}) - v154 := lang.Apply(v146, []any{v149, v116, v153}) - _ = v154 - var v155 any = v131 - var v156 any = v132 - var v157 any = v133 - v159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v160 := v159.FindInternedVar(lang.NewSymbol("unchecked-inc")) - if v160.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v160))) + tmp152 := tmp151.Get() + tmp153 := lang.Apply(tmp152, []any{v143, v21}) + tmp154 := lang.Apply(tmp146, []any{tmp149, v116, tmp153}) + _ = tmp154 + var tmp155 any = v131 + var tmp156 any = v132 + var tmp157 any = v133 + tmp159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp160 := tmp159.FindInternedVar(lang.NewSymbol("unchecked-inc")) + if tmp160.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp160))) } - v161 := v160.Get() - v162 := lang.Apply(v161, []any{v134}) - var v158 any = v162 - v131 = v155 - v132 = v156 - v133 = v157 - v134 = v158 + tmp161 := tmp160.Get() + tmp162 := lang.Apply(tmp161, []any{v134}) + var tmp158 any = tmp162 + v131 = tmp155 + v132 = tmp156 + v133 = tmp157 + v134 = tmp158 continue } // end let - v135 = v140 + tmp135 = tmp140 } else { - var v141 any + var tmp141 any { // let // let binding "temp__0__auto__" - v142 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v143 := v142.FindInternedVar(lang.NewSymbol("seq")) - if v143.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v143))) + tmp142 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp143 := tmp142.FindInternedVar(lang.NewSymbol("seq")) + if tmp143.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp143))) } - v144 := v143.Get() - v145 := lang.Apply(v144, []any{v131}) - var v146 any = v145 + tmp144 := tmp143.Get() + tmp145 := lang.Apply(tmp144, []any{v131}) + var v146 any = tmp145 _ = v146 - var v147 any + var tmp147 any if lang.IsTruthy(v146) { - var v148 any + var tmp148 any { // let // let binding "seq_129" var v149 any = v146 _ = v149 - var v150 any - v151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v152 := v151.FindInternedVar(lang.NewSymbol("chunked-seq?")) - if v152.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v152))) + var tmp150 any + tmp151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp152 := tmp151.FindInternedVar(lang.NewSymbol("chunked-seq?")) + if tmp152.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp152))) } - v153 := v152.Get() - v154 := lang.Apply(v153, []any{v149}) - if lang.IsTruthy(v154) { - var v155 any + tmp153 := tmp152.Get() + tmp154 := lang.Apply(tmp153, []any{v149}) + if lang.IsTruthy(tmp154) { + var tmp155 any { // let // let binding "c__0__auto__" - v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v157 := v156.FindInternedVar(lang.NewSymbol("chunk-first")) - if v157.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) + tmp156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp157 := tmp156.FindInternedVar(lang.NewSymbol("chunk-first")) + if tmp157.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp157))) } - v158 := v157.Get() - v159 := lang.Apply(v158, []any{v149}) - var v160 any = v159 + tmp158 := tmp157.Get() + tmp159 := lang.Apply(tmp158, []any{v149}) + var v160 any = tmp159 _ = v160 - v162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v163 := v162.FindInternedVar(lang.NewSymbol("chunk-rest")) - if v163.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v163))) + tmp162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp163 := tmp162.FindInternedVar(lang.NewSymbol("chunk-rest")) + if tmp163.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp163))) } - v164 := v163.Get() - v165 := lang.Apply(v164, []any{v149}) - var v161 any = v165 - var v166 any = v160 - v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v169 := v168.FindInternedVar(lang.NewSymbol("int")) - if v169.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) + tmp164 := tmp163.Get() + tmp165 := lang.Apply(tmp164, []any{v149}) + var tmp161 any = tmp165 + var tmp166 any = v160 + tmp168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp169 := tmp168.FindInternedVar(lang.NewSymbol("int")) + if tmp169.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp169))) } - v170 := v169.Get() - v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v172 := v171.FindInternedVar(lang.NewSymbol("count")) - if v172.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) + tmp170 := tmp169.Get() + tmp171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp172 := tmp171.FindInternedVar(lang.NewSymbol("count")) + if tmp172.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp172))) } - v173 := v172.Get() - v174 := lang.Apply(v173, []any{v160}) - v175 := lang.Apply(v170, []any{v174}) - var v167 any = v175 - v177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v178 := v177.FindInternedVar(lang.NewSymbol("int")) - if v178.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v178))) + tmp173 := tmp172.Get() + tmp174 := lang.Apply(tmp173, []any{v160}) + tmp175 := lang.Apply(tmp170, []any{tmp174}) + var tmp167 any = tmp175 + tmp177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp178 := tmp177.FindInternedVar(lang.NewSymbol("int")) + if tmp178.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp178))) } - v179 := v178.Get() - v180 := lang.Apply(v179, []any{int64(0)}) - var v176 any = v180 - v131 = v161 - v132 = v166 - v133 = v167 - v134 = v176 + tmp179 := tmp178.Get() + tmp180 := lang.Apply(tmp179, []any{int64(0)}) + var tmp176 any = tmp180 + v131 = tmp161 + v132 = tmp166 + v133 = tmp167 + v134 = tmp176 continue } // end let - v150 = v155 + tmp150 = tmp155 } else { - var v156 any + var tmp156 any { // let // let binding "arg" - v157 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v158 := v157.FindInternedVar(lang.NewSymbol("first")) - if v158.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v158))) + tmp157 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp158 := tmp157.FindInternedVar(lang.NewSymbol("first")) + if tmp158.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp158))) } - v159 := v158.Get() - v160 := lang.Apply(v159, []any{v149}) - var v161 any = v160 + tmp159 := tmp158.Get() + tmp160 := lang.Apply(tmp159, []any{v149}) + var v161 any = tmp160 _ = v161 - v162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v163 := v162.FindInternedVar(lang.NewSymbol("apply")) - if v163.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v163))) + tmp162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp163 := tmp162.FindInternedVar(lang.NewSymbol("apply")) + if tmp163.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp163))) } - v164 := v163.Get() - v165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v166 := v165.FindInternedVar(lang.NewSymbol("load-lib")) - if v166.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v166))) + tmp164 := tmp163.Get() + tmp165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp166 := tmp165.FindInternedVar(lang.NewSymbol("load-lib")) + if tmp166.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp166))) } - v167 := v166.Get() - v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v169 := v168.FindInternedVar(lang.NewSymbol("prependss")) - if v169.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) + tmp167 := tmp166.Get() + tmp168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp169 := tmp168.FindInternedVar(lang.NewSymbol("prependss")) + if tmp169.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp169))) } - v170 := v169.Get() - v171 := lang.Apply(v170, []any{v161, v21}) - v172 := lang.Apply(v164, []any{v167, v116, v171}) - _ = v172 - v174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v175 := v174.FindInternedVar(lang.NewSymbol("next")) - if v175.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v175))) + tmp170 := tmp169.Get() + tmp171 := lang.Apply(tmp170, []any{v161, v21}) + tmp172 := lang.Apply(tmp164, []any{tmp167, v116, tmp171}) + _ = tmp172 + tmp174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp175 := tmp174.FindInternedVar(lang.NewSymbol("next")) + if tmp175.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp175))) } - v176 := v175.Get() - v177 := lang.Apply(v176, []any{v149}) - var v173 any = v177 - var v178 any = nil - var v179 any = int64(0) - var v180 any = int64(0) - v131 = v173 - v132 = v178 - v133 = v179 - v134 = v180 + tmp176 := tmp175.Get() + tmp177 := lang.Apply(tmp176, []any{v149}) + var tmp173 any = tmp177 + var tmp178 any = nil + var tmp179 any = int64(0) + var tmp180 any = int64(0) + v131 = tmp173 + v132 = tmp178 + v133 = tmp179 + v134 = tmp180 continue } // end let - v150 = v156 + tmp150 = tmp156 } - v148 = v150 + tmp148 = tmp150 } // end let - v147 = v148 + tmp147 = tmp148 } else { - v147 = nil } - v141 = v147 + tmp141 = tmp147 } // end let - v135 = v141 + tmp135 = tmp141 } - v126 = v135 + tmp126 = tmp135 break } } // end let - v99 = v126 + tmp99 = tmp126 } // end let - v83 = v99 + tmp83 = tmp99 } - _ = v83 - v101 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v102 := v101.FindInternedVar(lang.NewSymbol("next")) - if v102.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v102))) + _ = tmp83 + tmp101 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp102 := tmp101.FindInternedVar(lang.NewSymbol("next")) + if tmp102.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp102))) } - v103 := v102.Get() - v104 := lang.Apply(v103, []any{v70}) - var v100 any = v104 - var v105 any = nil - var v106 any = int64(0) - var v107 any = int64(0) - v52 = v100 - v53 = v105 - v54 = v106 - v55 = v107 + tmp103 := tmp102.Get() + tmp104 := lang.Apply(tmp103, []any{v70}) + var tmp100 any = tmp104 + var tmp105 any = nil + var tmp106 any = int64(0) + var tmp107 any = int64(0) + v52 = tmp100 + v53 = tmp105 + v54 = tmp106 + v55 = tmp107 continue } // end let - v71 = v77 + tmp71 = tmp77 } - v69 = v71 + tmp69 = tmp71 } // end let - v68 = v69 + tmp68 = tmp69 } else { - v68 = nil } - v62 = v68 + tmp62 = tmp68 } // end let - v56 = v62 + tmp56 = tmp62 } - v47 = v56 + tmp47 = tmp56 break } } // end let - v4 = v47 + tmp4 = tmp47 } // end let - return v4 + return tmp4 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // load-one { - v0 := lang.NewSymbol("load-one").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"), lang.NewSymbol("need-ns"), lang.NewSymbol("require"))), lang.NewKeyword("doc"), "Loads a lib given its name. If need-ns, ensures that the associated\n namespace exists after loading. If require, records the load so any\n duplicate loads can be skipped.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5879), lang.NewKeyword("end-line"), int(5879), lang.NewKeyword("private"), true)).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("load-one").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"), lang.NewSymbol("need-ns"), lang.NewSymbol("require"))), lang.NewKeyword("doc"), "Loads a lib given its name. If need-ns, ensures that the associated\n namespace exists after loading. If require, records the load so any\n duplicate loads can be skipped.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5879), lang.NewKeyword("end-line"), int(5879), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -50273,199 +50373,198 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("load")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("root-resource")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.Apply(v11, []any{v3}) - v13 := lang.Apply(v8, []any{v12}) - _ = v13 - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("throw-if")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - var v17 any + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("load")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("root-resource")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.Apply(tmp11, []any{v3}) + tmp13 := lang.Apply(tmp8, []any{tmp12}) + _ = tmp13 + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("throw-if")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + var tmp17 any { // let // let binding "and__0__auto__" var v18 any = v4 _ = v18 - var v19 any + var tmp19 any if lang.IsTruthy(v18) { - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("not")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("find-ns")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.Apply(v25, []any{v3}) - v27 := lang.Apply(v22, []any{v26}) - v19 = v27 + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("not")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("find-ns")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.Apply(tmp25, []any{v3}) + tmp27 := lang.Apply(tmp22, []any{tmp26}) + tmp19 = tmp27 } else { - v19 = v18 + tmp19 = v18 } - v17 = v19 + tmp17 = tmp19 } // end let - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("root-resource")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.Apply(v20, []any{v3}) - v22 := lang.Apply(v16, []any{v17, "namespace '%s' not found after loading '%s'", v3, v21}) - _ = v22 - var v23 any + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("root-resource")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.Apply(tmp20, []any{v3}) + tmp22 := lang.Apply(tmp16, []any{tmp17, "namespace '%s' not found after loading '%s'", v3, tmp21}) + _ = tmp22 + var tmp23 any if lang.IsTruthy(v5) { - var v24 lang.FnFunc - v24 = lang.NewFnFunc(func(args ...any) any { + var tmp24 lang.FnFunc + tmp24 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("commute")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("*loaded-libs*")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("conj")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v27, []any{v30, v33, v3}) - return v34 + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("commute")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("*loaded-libs*")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("conj")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp27, []any{tmp30, tmp33, v3}) + return tmp34 }) - v25, _ := lang.FieldOrMethod(lang.LockingTransaction, "RunInTransaction") - if reflect.TypeOf(v25).Kind() != reflect.Func { + tmp25, _ := lang.FieldOrMethod(lang.LockingTransaction, "RunInTransaction") + if reflect.TypeOf(tmp25).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("RunInTransaction is not a function"))) } - v26 := lang.Apply(v25, []any{v24}) - v23 = v26 + tmp26 := lang.Apply(tmp25, []any{tmp24}) + tmp23 = tmp26 } else { - v23 = nil } - return v23 + return tmp23 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // load-reader { - v0 := lang.NewSymbol("load-reader").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rdr"))), lang.NewKeyword("doc"), "Sequentially read and evaluate the set of forms contained in the\n stream/file", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4081), lang.NewKeyword("end-line"), int(4081))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("load-reader").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rdr"))), lang.NewKeyword("doc"), "Sequentially read and evaluate the set of forms contained in the\n stream/file", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4081), lang.NewKeyword("end-line"), int(4081))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4, _ := lang.FieldOrMethod(runtime4.Compiler, "load") - if reflect.TypeOf(v4).Kind() != reflect.Func { + tmp4, _ := lang.FieldOrMethod(runtime4.Compiler, "load") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("load is not a function"))) } - v5 := lang.Apply(v4, []any{v3}) - return v5 + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // load-string { - v0 := lang.NewSymbol("load-string").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Sequentially read and evaluate the set of forms contained in the\n string", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4088), lang.NewKeyword("end-line"), int(4088))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("load-string").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Sequentially read and evaluate the set of forms contained in the\n string", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4088), lang.NewKeyword("end-line"), int(4088))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any + var tmp4 any { // let // let binding "rdr" - v5 := lang.Apply(nil, []any{v3}) - v6 := lang.Apply(nil, []any{v5}) - var v7 any = v6 + tmp5 := lang.Apply(nil, []any{v3}) + tmp6 := lang.Apply(nil, []any{tmp5}) + var v7 any = tmp6 _ = v7 - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("load-reader")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v7}) - v4 = v11 + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("load-reader")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v7}) + tmp4 = tmp11 } // end let - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // loaded-libs { - v0 := lang.NewSymbol("loaded-libs").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Returns a sorted set of symbols naming the currently loaded libs", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6090), lang.NewKeyword("end-line"), int(6090))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("loaded-libs").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Returns a sorted set of symbols naming the currently loaded libs", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6090), lang.NewKeyword("end-line"), int(6090))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v4 := v3.FindInternedVar(lang.NewSymbol("deref")) - if v4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) + tmp3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp4 := tmp3.FindInternedVar(lang.NewSymbol("deref")) + if tmp4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp4))) } - v5 := v4.Get() - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("*loaded-libs*")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + tmp5 := tmp4.Get() + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("*loaded-libs*")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) } - v8 := v7.Get() - v9 := lang.Apply(v5, []any{v8}) - return v9 + tmp8 := tmp7.Get() + tmp9 := lang.Apply(tmp5, []any{tmp8}) + return tmp9 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // locking { - v0 := lang.NewSymbol("locking").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Executes exprs in an implicit do, while holding the monitor of x.\n Will release the monitor of x in all circumstances.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1643), lang.NewKeyword("end-line"), int(1643))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("locking").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Executes exprs in an implicit do, while holding the monitor of x.\n Will release the monitor of x in all circumstances.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1643), lang.NewKeyword("end-line"), int(1643))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 3 { @@ -50477,614 +50576,619 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("seq")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("concat")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("list")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/let")}) - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("list")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("apply")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("vector")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("seq")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) - } - v28 := v27.Get() - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("concat")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("list")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{lang.NewSymbol("lockee__0__auto__")}) - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("list")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.Apply(v38, []any{v5}) - v40 := lang.Apply(v31, []any{v35, v39}) - v41 := lang.Apply(v28, []any{v40}) - v42 := lang.Apply(v22, []any{v25, v41}) - v43 := lang.Apply(v19, []any{v42}) - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("list")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) - } - v46 := v45.Get() - v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v48 := v47.FindInternedVar(lang.NewSymbol("seq")) - if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) - } - v49 := v48.Get() - v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v51 := v50.FindInternedVar(lang.NewSymbol("concat")) - if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) - } - v52 := v51.Get() - v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v54 := v53.FindInternedVar(lang.NewSymbol("list")) - if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) - } - v55 := v54.Get() - v56 := lang.Apply(v55, []any{lang.NewSymbol("try")}) - v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v58 := v57.FindInternedVar(lang.NewSymbol("list")) - if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) - } - v59 := v58.Get() - v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v61 := v60.FindInternedVar(lang.NewSymbol("seq")) - if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) - } - v62 := v61.Get() - v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v64 := v63.FindInternedVar(lang.NewSymbol("concat")) - if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) - } - v65 := v64.Get() - v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v67 := v66.FindInternedVar(lang.NewSymbol("list")) - if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) - } - v68 := v67.Get() - v69 := lang.Apply(v68, []any{lang.NewSymbol("glojure.core/let")}) - v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v71 := v70.FindInternedVar(lang.NewSymbol("list")) - if v71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) - } - v72 := v71.Get() - v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v74 := v73.FindInternedVar(lang.NewSymbol("apply")) - if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) - } - v75 := v74.Get() - v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v77 := v76.FindInternedVar(lang.NewSymbol("vector")) - if v77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) - } - v78 := v77.Get() - v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v80 := v79.FindInternedVar(lang.NewSymbol("seq")) - if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) - } - v81 := v80.Get() - v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v83 := v82.FindInternedVar(lang.NewSymbol("concat")) - if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) - } - v84 := v83.Get() - v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v86 := v85.FindInternedVar(lang.NewSymbol("list")) - if v86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) - } - v87 := v86.Get() - v88 := lang.Apply(v87, []any{lang.NewSymbol("locklocal__1__auto__")}) - v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v90 := v89.FindInternedVar(lang.NewSymbol("list")) - if v90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) - } - v91 := v90.Get() - v92 := lang.Apply(v91, []any{lang.NewSymbol("lockee__0__auto__")}) - v93 := lang.Apply(v84, []any{v88, v92}) - v94 := lang.Apply(v81, []any{v93}) - v95 := lang.Apply(v75, []any{v78, v94}) - v96 := lang.Apply(v72, []any{v95}) - v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v98 := v97.FindInternedVar(lang.NewSymbol("list")) - if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) - } - v99 := v98.Get() - v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v101 := v100.FindInternedVar(lang.NewSymbol("seq")) - if v101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) - } - v102 := v101.Get() - v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v104 := v103.FindInternedVar(lang.NewSymbol("concat")) - if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) - } - v105 := v104.Get() - v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v107 := v106.FindInternedVar(lang.NewSymbol("list")) - if v107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) - } - v108 := v107.Get() - v109 := lang.Apply(v108, []any{lang.NewSymbol("monitor-enter")}) - v110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v111 := v110.FindInternedVar(lang.NewSymbol("list")) - if v111.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v111))) - } - v112 := v111.Get() - v113 := lang.Apply(v112, []any{lang.NewSymbol("locklocal__1__auto__")}) - v114 := lang.Apply(v105, []any{v109, v113}) - v115 := lang.Apply(v102, []any{v114}) - v116 := lang.Apply(v99, []any{v115}) - v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v118 := v117.FindInternedVar(lang.NewSymbol("list")) - if v118.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) - } - v119 := v118.Get() - v120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v121 := v120.FindInternedVar(lang.NewSymbol("seq")) - if v121.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v121))) - } - v122 := v121.Get() - v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v124 := v123.FindInternedVar(lang.NewSymbol("concat")) - if v124.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) - } - v125 := v124.Get() - v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v127 := v126.FindInternedVar(lang.NewSymbol("list")) - if v127.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) - } - v128 := v127.Get() - v129 := lang.Apply(v128, []any{lang.NewSymbol("try")}) - v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v131 := v130.FindInternedVar(lang.NewSymbol("list")) - if v131.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) - } - v132 := v131.Get() - v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v134 := v133.FindInternedVar(lang.NewSymbol("seq")) - if v134.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) - } - v135 := v134.Get() - v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v137 := v136.FindInternedVar(lang.NewSymbol("concat")) - if v137.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) - } - v138 := v137.Get() - v139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v140 := v139.FindInternedVar(lang.NewSymbol("list")) - if v140.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v140))) - } - v141 := v140.Get() - v142 := lang.Apply(v141, []any{lang.NewSymbol("finally")}) - v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v144 := v143.FindInternedVar(lang.NewSymbol("list")) - if v144.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) - } - v145 := v144.Get() - v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v147 := v146.FindInternedVar(lang.NewSymbol("seq")) - if v147.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) - } - v148 := v147.Get() - v149 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v150 := v149.FindInternedVar(lang.NewSymbol("concat")) - if v150.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v150))) - } - v151 := v150.Get() - v152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v153 := v152.FindInternedVar(lang.NewSymbol("list")) - if v153.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v153))) - } - v154 := v153.Get() - v155 := lang.Apply(v154, []any{lang.NewSymbol("monitor-exit")}) - v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v157 := v156.FindInternedVar(lang.NewSymbol("list")) - if v157.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) - } - v158 := v157.Get() - v159 := lang.Apply(v158, []any{lang.NewSymbol("locklocal__1__auto__")}) - v160 := lang.Apply(v151, []any{v155, v159}) - v161 := lang.Apply(v148, []any{v160}) - v162 := lang.Apply(v145, []any{v161}) - v163 := lang.Apply(v138, []any{v142, v162}) - v164 := lang.Apply(v135, []any{v163}) - v165 := lang.Apply(v132, []any{v164}) - v166 := lang.Apply(v125, []any{v129, v6, v165}) - v167 := lang.Apply(v122, []any{v166}) - v168 := lang.Apply(v119, []any{v167}) - v169 := lang.Apply(v65, []any{v69, v96, v116, v168}) - v170 := lang.Apply(v62, []any{v169}) - v171 := lang.Apply(v59, []any{v170}) - v172 := lang.Apply(v52, []any{v56, v171}) - v173 := lang.Apply(v49, []any{v172}) - v174 := lang.Apply(v46, []any{v173}) - v175 := lang.Apply(v12, []any{v16, v43, v174}) - v176 := lang.Apply(v9, []any{v175}) - return v176 - } - }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("seq")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("concat")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("list")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("glojure.core/let")}) + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("list")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("apply")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("vector")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("seq")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) + } + tmp28 := tmp27.Get() + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("concat")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.Apply(tmp34, []any{lang.NewSymbol("lockee__0__auto__")}) + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{v5}) + tmp40 := lang.Apply(tmp31, []any{tmp35, tmp39}) + tmp41 := lang.Apply(tmp28, []any{tmp40}) + tmp42 := lang.Apply(tmp22, []any{tmp25, tmp41}) + tmp43 := lang.Apply(tmp19, []any{tmp42}) + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) + } + tmp46 := tmp45.Get() + tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp48 := tmp47.FindInternedVar(lang.NewSymbol("seq")) + if tmp48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) + } + tmp49 := tmp48.Get() + tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp51 := tmp50.FindInternedVar(lang.NewSymbol("concat")) + if tmp51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) + } + tmp52 := tmp51.Get() + tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp54 := tmp53.FindInternedVar(lang.NewSymbol("list")) + if tmp54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) + } + tmp55 := tmp54.Get() + tmp56 := lang.Apply(tmp55, []any{lang.NewSymbol("try")}) + tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp58 := tmp57.FindInternedVar(lang.NewSymbol("list")) + if tmp58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) + } + tmp59 := tmp58.Get() + tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp61 := tmp60.FindInternedVar(lang.NewSymbol("seq")) + if tmp61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) + } + tmp62 := tmp61.Get() + tmp63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp64 := tmp63.FindInternedVar(lang.NewSymbol("concat")) + if tmp64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp64))) + } + tmp65 := tmp64.Get() + tmp66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp67 := tmp66.FindInternedVar(lang.NewSymbol("list")) + if tmp67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp67))) + } + tmp68 := tmp67.Get() + tmp69 := lang.Apply(tmp68, []any{lang.NewSymbol("glojure.core/let")}) + tmp70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp71 := tmp70.FindInternedVar(lang.NewSymbol("list")) + if tmp71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp71))) + } + tmp72 := tmp71.Get() + tmp73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp74 := tmp73.FindInternedVar(lang.NewSymbol("apply")) + if tmp74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp74))) + } + tmp75 := tmp74.Get() + tmp76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp77 := tmp76.FindInternedVar(lang.NewSymbol("vector")) + if tmp77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp77))) + } + tmp78 := tmp77.Get() + tmp79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp80 := tmp79.FindInternedVar(lang.NewSymbol("seq")) + if tmp80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp80))) + } + tmp81 := tmp80.Get() + tmp82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp83 := tmp82.FindInternedVar(lang.NewSymbol("concat")) + if tmp83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp83))) + } + tmp84 := tmp83.Get() + tmp85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp86 := tmp85.FindInternedVar(lang.NewSymbol("list")) + if tmp86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp86))) + } + tmp87 := tmp86.Get() + tmp88 := lang.Apply(tmp87, []any{lang.NewSymbol("locklocal__1__auto__")}) + tmp89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp90 := tmp89.FindInternedVar(lang.NewSymbol("list")) + if tmp90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp90))) + } + tmp91 := tmp90.Get() + tmp92 := lang.Apply(tmp91, []any{lang.NewSymbol("lockee__0__auto__")}) + tmp93 := lang.Apply(tmp84, []any{tmp88, tmp92}) + tmp94 := lang.Apply(tmp81, []any{tmp93}) + tmp95 := lang.Apply(tmp75, []any{tmp78, tmp94}) + tmp96 := lang.Apply(tmp72, []any{tmp95}) + tmp97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp98 := tmp97.FindInternedVar(lang.NewSymbol("list")) + if tmp98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp98))) + } + tmp99 := tmp98.Get() + tmp100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp101 := tmp100.FindInternedVar(lang.NewSymbol("seq")) + if tmp101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp101))) + } + tmp102 := tmp101.Get() + tmp103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp104 := tmp103.FindInternedVar(lang.NewSymbol("concat")) + if tmp104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp104))) + } + tmp105 := tmp104.Get() + tmp106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp107 := tmp106.FindInternedVar(lang.NewSymbol("list")) + if tmp107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp107))) + } + tmp108 := tmp107.Get() + tmp109 := lang.Apply(tmp108, []any{lang.NewSymbol("monitor-enter")}) + tmp110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp111 := tmp110.FindInternedVar(lang.NewSymbol("list")) + if tmp111.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp111))) + } + tmp112 := tmp111.Get() + tmp113 := lang.Apply(tmp112, []any{lang.NewSymbol("locklocal__1__auto__")}) + tmp114 := lang.Apply(tmp105, []any{tmp109, tmp113}) + tmp115 := lang.Apply(tmp102, []any{tmp114}) + tmp116 := lang.Apply(tmp99, []any{tmp115}) + tmp117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp118 := tmp117.FindInternedVar(lang.NewSymbol("list")) + if tmp118.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp118))) + } + tmp119 := tmp118.Get() + tmp120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp121 := tmp120.FindInternedVar(lang.NewSymbol("seq")) + if tmp121.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp121))) + } + tmp122 := tmp121.Get() + tmp123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp124 := tmp123.FindInternedVar(lang.NewSymbol("concat")) + if tmp124.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp124))) + } + tmp125 := tmp124.Get() + tmp126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp127 := tmp126.FindInternedVar(lang.NewSymbol("list")) + if tmp127.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp127))) + } + tmp128 := tmp127.Get() + tmp129 := lang.Apply(tmp128, []any{lang.NewSymbol("try")}) + tmp130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp131 := tmp130.FindInternedVar(lang.NewSymbol("list")) + if tmp131.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp131))) + } + tmp132 := tmp131.Get() + tmp133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp134 := tmp133.FindInternedVar(lang.NewSymbol("seq")) + if tmp134.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp134))) + } + tmp135 := tmp134.Get() + tmp136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp137 := tmp136.FindInternedVar(lang.NewSymbol("concat")) + if tmp137.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp137))) + } + tmp138 := tmp137.Get() + tmp139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp140 := tmp139.FindInternedVar(lang.NewSymbol("list")) + if tmp140.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp140))) + } + tmp141 := tmp140.Get() + tmp142 := lang.Apply(tmp141, []any{lang.NewSymbol("finally")}) + tmp143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp144 := tmp143.FindInternedVar(lang.NewSymbol("list")) + if tmp144.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp144))) + } + tmp145 := tmp144.Get() + tmp146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp147 := tmp146.FindInternedVar(lang.NewSymbol("seq")) + if tmp147.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp147))) + } + tmp148 := tmp147.Get() + tmp149 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp150 := tmp149.FindInternedVar(lang.NewSymbol("concat")) + if tmp150.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp150))) + } + tmp151 := tmp150.Get() + tmp152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp153 := tmp152.FindInternedVar(lang.NewSymbol("list")) + if tmp153.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp153))) + } + tmp154 := tmp153.Get() + tmp155 := lang.Apply(tmp154, []any{lang.NewSymbol("monitor-exit")}) + tmp156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp157 := tmp156.FindInternedVar(lang.NewSymbol("list")) + if tmp157.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp157))) + } + tmp158 := tmp157.Get() + tmp159 := lang.Apply(tmp158, []any{lang.NewSymbol("locklocal__1__auto__")}) + tmp160 := lang.Apply(tmp151, []any{tmp155, tmp159}) + tmp161 := lang.Apply(tmp148, []any{tmp160}) + tmp162 := lang.Apply(tmp145, []any{tmp161}) + tmp163 := lang.Apply(tmp138, []any{tmp142, tmp162}) + tmp164 := lang.Apply(tmp135, []any{tmp163}) + tmp165 := lang.Apply(tmp132, []any{tmp164}) + tmp166 := lang.Apply(tmp125, []any{tmp129, v6, tmp165}) + tmp167 := lang.Apply(tmp122, []any{tmp166}) + tmp168 := lang.Apply(tmp119, []any{tmp167}) + tmp169 := lang.Apply(tmp65, []any{tmp69, tmp96, tmp116, tmp168}) + tmp170 := lang.Apply(tmp62, []any{tmp169}) + tmp171 := lang.Apply(tmp59, []any{tmp170}) + tmp172 := lang.Apply(tmp52, []any{tmp56, tmp171}) + tmp173 := lang.Apply(tmp49, []any{tmp172}) + tmp174 := lang.Apply(tmp46, []any{tmp173}) + tmp175 := lang.Apply(tmp12, []any{tmp16, tmp43, tmp174}) + tmp176 := lang.Apply(tmp9, []any{tmp175}) + return tmp176 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // long { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function long__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("concat")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("list")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("seq")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("concat")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/LongCast")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{v3}) - v35 := lang.Apply(v26, []any{v30, v34}) - v36 := lang.Apply(v23, []any{v35}) - v37 := lang.Apply(v20, []any{v36}) - v38 := lang.Apply(v9, []any{v13, v17, v37}) - v39 := lang.Apply(v6, []any{v38}) - return v39 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/LongCast")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{v3}) + tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) + tmp36 := lang.Apply(tmp23, []any{tmp35}) + tmp37 := lang.Apply(tmp20, []any{tmp36}) + tmp38 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp37}) + tmp39 := lang.Apply(tmp6, []any{tmp38}) + return tmp39 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("long").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to long", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3481), lang.NewKeyword("end-line"), int(3481))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("long").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to long", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3481), lang.NewKeyword("end-line"), int(3481))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5 := lang.Apply(lang.LongCast, []any{v4}) - return v5 + tmp5 := lang.Apply(lang.LongCast, []any{v4}) + return tmp5 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // long-array { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function long-array__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v3 := lang.NewList(args[0:]...) - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("concat")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("list")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/LongArray")}) - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("list")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("seq")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("concat")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) - v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v36 := v35.FindInternedVar(lang.NewSymbol("list")) - if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) - } - v37 := v36.Get() - v38 := lang.Apply(v37, []any{lang.NewSymbol("glojure.core/args")}) - v39 := lang.Apply(v30, []any{v34, v38}) - v40 := lang.Apply(v27, []any{v39}) - v41 := lang.Apply(v24, []any{v40}) - v42 := lang.Apply(v9, []any{v13, v17, v21, v41}) - v43 := lang.Apply(v6, []any{v42}) - return v43 + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.Apply(tmp20, []any{lang.NewSymbol("glojure.core/LongArray")}) + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("list")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("seq")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("concat")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) + tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp36 := tmp35.FindInternedVar(lang.NewSymbol("list")) + if tmp36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) + } + tmp37 := tmp36.Get() + tmp38 := lang.Apply(tmp37, []any{lang.NewSymbol("glojure.core/args")}) + tmp39 := lang.Apply(tmp30, []any{tmp34, tmp38}) + tmp40 := lang.Apply(tmp27, []any{tmp39}) + tmp41 := lang.Apply(tmp24, []any{tmp40}) + tmp42 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp21, tmp41}) + tmp43 := lang.Apply(tmp6, []any{tmp42}) + return tmp43 } }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("long-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Creates an array of longs", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1), int64(2)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5364), lang.NewKeyword("end-line"), int(5364))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("long-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Creates an array of longs", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5364), lang.NewKeyword("end-line"), int(5364))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v4 := args[0] _ = v4 - v5, _ := lang.FieldOrMethod(lang.Numbers, "LongArray") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "LongArray") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("LongArray is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 case 2: v4 := args[0] _ = v4 v5 := args[1] _ = v5 - v6, _ := lang.FieldOrMethod(lang.Numbers, "LongArrayInit") - if reflect.TypeOf(v6).Kind() != reflect.Func { + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "LongArrayInit") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("LongArrayInit is not a function"))) } - v7 := lang.Apply(v6, []any{v4, v5}) - return v7 + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // longs { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function longs - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("concat")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("list")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/Longs")}) - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("list")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v3}) - v26 := lang.Apply(v9, []any{v13, v17, v21, v25}) - v27 := lang.Apply(v6, []any{v26}) - return v27 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.Apply(tmp20, []any{lang.NewSymbol("glojure.core/Longs")}) + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("list")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.Apply(tmp24, []any{v3}) + tmp26 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp21, tmp25}) + tmp27 := lang.Apply(tmp6, []any{tmp26}) + return tmp27 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("longs").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Casts to long[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5407), lang.NewKeyword("end-line"), int(5407))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("longs").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Casts to long[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5407), lang.NewKeyword("end-line"), int(5407))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5, _ := lang.FieldOrMethod(lang.Numbers, "Longs") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Longs") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Longs is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // loop { - v0 := lang.NewSymbol("loop").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Evaluates the exprs in a lexical context in which the symbols in\n the binding-forms are bound to their respective init-exprs or parts\n therein. Acts as a recur target.", lang.NewKeyword("forms"), lang.NewVector(lang.NewList(lang.NewSymbol("loop"), lang.NewVector(lang.NewSymbol("bindings*")), lang.NewSymbol("exprs*"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4597), lang.NewKeyword("end-line"), int(4597), lang.NewKeyword("special-form"), true)).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("loop").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Evaluates the exprs in a lexical context in which the symbols in\n the binding-forms are bound to their respective init-exprs or parts\n therein. Acts as a recur target.", lang.NewKeyword("forms"), lang.NewVector(lang.NewList(lang.NewSymbol("loop"), lang.NewVector(lang.NewSymbol("bindings*")), lang.NewSymbol("exprs*"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4597), lang.NewKeyword("end-line"), int(4597), lang.NewKeyword("special-form"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 3 { @@ -51096,234 +51200,232 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - var v7 any - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v5}) - if lang.IsTruthy(v11) { - v7 = nil + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("vector?")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v5}) + if lang.IsTruthy(tmp11) { } else { - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("str")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("first")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{v3}) - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("meta")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v3}) - v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) - v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) - v28 := lang.Apply(lang.NewIllegalArgumentError, []any{v27}) - panic(v28) - } - _ = v7 - var v29 any - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("even?")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) - } - v32 := v31.Get() - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("count")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - v36 := lang.Apply(v35, []any{v5}) - v37 := lang.Apply(v32, []any{v36}) - if lang.IsTruthy(v37) { - v29 = nil + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("str")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("first")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("*ns*")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("meta")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.Apply(tmp24, []any{v3}) + tmp26 := lang.Apply(lang.NewKeyword("line"), []any{tmp25}) + tmp27 := lang.Apply(tmp14, []any{tmp18, " requires ", "a vector for its binding", " in ", tmp21, ":", tmp26}) + tmp28 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp27}) + panic(tmp28) + } + _ = tmp7 + var tmp29 any + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("even?")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) + } + tmp32 := tmp31.Get() + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("count")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) + } + tmp35 := tmp34.Get() + tmp36 := lang.Apply(tmp35, []any{v5}) + tmp37 := lang.Apply(tmp32, []any{tmp36}) + if lang.IsTruthy(tmp37) { } else { - v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v39 := v38.FindInternedVar(lang.NewSymbol("str")) - if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) - } - v40 := v39.Get() - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("first")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) - } - v43 := v42.Get() - v44 := lang.Apply(v43, []any{v3}) - v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) - if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) - } - v47 := v46.Get() - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("meta")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v3}) - v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) - v53 := lang.Apply(v40, []any{v44, " requires ", "an even number of forms in binding vector", " in ", v47, ":", v52}) - v54 := lang.Apply(lang.NewIllegalArgumentError, []any{v53}) - panic(v54) - } - _ = v29 - _ = nil - var v55 any + tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp39 := tmp38.FindInternedVar(lang.NewSymbol("str")) + if tmp39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) + } + tmp40 := tmp39.Get() + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("first")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := lang.Apply(tmp43, []any{v3}) + tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp46 := tmp45.FindInternedVar(lang.NewSymbol("*ns*")) + if tmp46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) + } + tmp47 := tmp46.Get() + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("meta")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v3}) + tmp52 := lang.Apply(lang.NewKeyword("line"), []any{tmp51}) + tmp53 := lang.Apply(tmp40, []any{tmp44, " requires ", "an even number of forms in binding vector", " in ", tmp47, ":", tmp52}) + tmp54 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp53}) + panic(tmp54) + } + _ = tmp29 + var tmp55 any { // let // let binding "db" - v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v57 := v56.FindInternedVar(lang.NewSymbol("destructure")) - if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) - } - v58 := v57.Get() - v59 := lang.Apply(v58, []any{v5}) - var v60 any = v59 + tmp56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp57 := tmp56.FindInternedVar(lang.NewSymbol("destructure")) + if tmp57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp57))) + } + tmp58 := tmp57.Get() + tmp59 := lang.Apply(tmp58, []any{v5}) + var v60 any = tmp59 _ = v60 - var v61 any - v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v63 := v62.FindInternedVar(lang.NewSymbol("=")) - if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) - } - v64 := v63.Get() - v65 := lang.Apply(v64, []any{v60, v5}) - if lang.IsTruthy(v65) { - v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v67 := v66.FindInternedVar(lang.NewSymbol("seq")) - if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) - } - v68 := v67.Get() - v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v70 := v69.FindInternedVar(lang.NewSymbol("concat")) - if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) - } - v71 := v70.Get() - v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v73 := v72.FindInternedVar(lang.NewSymbol("list")) - if v73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) - } - v74 := v73.Get() - v75 := lang.Apply(v74, []any{lang.NewSymbol("loop*")}) - v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v77 := v76.FindInternedVar(lang.NewSymbol("list")) - if v77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) - } - v78 := v77.Get() - v79 := lang.Apply(v78, []any{v5}) - v80 := lang.Apply(v71, []any{v75, v79, v6}) - v81 := lang.Apply(v68, []any{v80}) - v61 = v81 + var tmp61 any + tmp62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp63 := tmp62.FindInternedVar(lang.NewSymbol("=")) + if tmp63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp63))) + } + tmp64 := tmp63.Get() + tmp65 := lang.Apply(tmp64, []any{v60, v5}) + if lang.IsTruthy(tmp65) { + tmp66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp67 := tmp66.FindInternedVar(lang.NewSymbol("seq")) + if tmp67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp67))) + } + tmp68 := tmp67.Get() + tmp69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp70 := tmp69.FindInternedVar(lang.NewSymbol("concat")) + if tmp70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp70))) + } + tmp71 := tmp70.Get() + tmp72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp73 := tmp72.FindInternedVar(lang.NewSymbol("list")) + if tmp73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp73))) + } + tmp74 := tmp73.Get() + tmp75 := lang.Apply(tmp74, []any{lang.NewSymbol("loop*")}) + tmp76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp77 := tmp76.FindInternedVar(lang.NewSymbol("list")) + if tmp77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp77))) + } + tmp78 := tmp77.Get() + tmp79 := lang.Apply(tmp78, []any{v5}) + tmp80 := lang.Apply(tmp71, []any{tmp75, tmp79, v6}) + tmp81 := lang.Apply(tmp68, []any{tmp80}) + tmp61 = tmp81 } else { - var v82 any + var tmp82 any { // let // let binding "vs" - v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v84 := v83.FindInternedVar(lang.NewSymbol("take-nth")) - if v84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) - } - v85 := v84.Get() - v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v87 := v86.FindInternedVar(lang.NewSymbol("drop")) - if v87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) - } - v88 := v87.Get() - v89 := lang.Apply(v88, []any{int64(1), v5}) - v90 := lang.Apply(v85, []any{int64(2), v89}) - var v91 any = v90 + tmp83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp84 := tmp83.FindInternedVar(lang.NewSymbol("take-nth")) + if tmp84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp84))) + } + tmp85 := tmp84.Get() + tmp86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp87 := tmp86.FindInternedVar(lang.NewSymbol("drop")) + if tmp87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp87))) + } + tmp88 := tmp87.Get() + tmp89 := lang.Apply(tmp88, []any{int64(1), v5}) + tmp90 := lang.Apply(tmp85, []any{int64(2), tmp89}) + var v91 any = tmp90 _ = v91 // let binding "bs" - v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v93 := v92.FindInternedVar(lang.NewSymbol("take-nth")) - if v93.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) - } - v94 := v93.Get() - v95 := lang.Apply(v94, []any{int64(2), v5}) - var v96 any = v95 + tmp92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp93 := tmp92.FindInternedVar(lang.NewSymbol("take-nth")) + if tmp93.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp93))) + } + tmp94 := tmp93.Get() + tmp95 := lang.Apply(tmp94, []any{int64(2), v5}) + var v96 any = tmp95 _ = v96 // let binding "gs" - v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v98 := v97.FindInternedVar(lang.NewSymbol("map")) - if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) - } - v99 := v98.Get() - var v100 lang.FnFunc - v100 = lang.NewFnFunc(func(args ...any) any { + tmp97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp98 := tmp97.FindInternedVar(lang.NewSymbol("map")) + if tmp98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp98))) + } + tmp99 := tmp98.Get() + var tmp100 lang.FnFunc + tmp100 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v101 := args[0] _ = v101 - var v102 any - v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v104 := v103.FindInternedVar(lang.NewSymbol("symbol?")) - if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) + var tmp102 any + tmp103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp104 := tmp103.FindInternedVar(lang.NewSymbol("symbol?")) + if tmp104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp104))) } - v105 := v104.Get() - v106 := lang.Apply(v105, []any{v101}) - if lang.IsTruthy(v106) { - v102 = v101 + tmp105 := tmp104.Get() + tmp106 := lang.Apply(tmp105, []any{v101}) + if lang.IsTruthy(tmp106) { + tmp102 = v101 } else { - v107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v108 := v107.FindInternedVar(lang.NewSymbol("gensym")) - if v108.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v108))) + tmp107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp108 := tmp107.FindInternedVar(lang.NewSymbol("gensym")) + if tmp108.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp108))) } - v109 := v108.Get() - v110 := lang.Apply(v109, nil) - v102 = v110 + tmp109 := tmp108.Get() + tmp110 := lang.Apply(tmp109, nil) + tmp102 = tmp110 } - return v102 + return tmp102 }) - v101 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4611), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(4611), lang.NewKeyword("end-column"), int(58)) - v102, err := lang.WithMeta(v100, v101.(lang.IPersistentMap)) + tmp101 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4611), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(4611), lang.NewKeyword("end-column"), int(58)) + tmp102, err := lang.WithMeta(tmp100, tmp101.(lang.IPersistentMap)) if err != nil { panic(err) } - v103 := lang.Apply(v99, []any{v102, v96}) - var v104 any = v103 + tmp103 := lang.Apply(tmp99, []any{tmp102, v96}) + var v104 any = tmp103 _ = v104 // let binding "bfs" - v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v106 := v105.FindInternedVar(lang.NewSymbol("reduce1")) - if v106.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) - } - v107 := v106.Get() - var v108 lang.FnFunc - v108 = lang.NewFnFunc(func(args ...any) any { + tmp105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp106 := tmp105.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp106.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp106))) + } + tmp107 := tmp106.Get() + var tmp108 lang.FnFunc + tmp108 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -51331,339 +51433,339 @@ func init() { _ = v109 v110 := args[1] _ = v110 - var v111 any + var tmp111 any { // let // let binding "vec__17" var v112 any = v110 _ = v112 // let binding "b" - v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v114 := v113.FindInternedVar(lang.NewSymbol("nth")) - if v114.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) + tmp113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp114 := tmp113.FindInternedVar(lang.NewSymbol("nth")) + if tmp114.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp114))) } - v115 := v114.Get() - v116 := lang.Apply(v115, []any{v112, int64(0), nil}) - var v117 any = v116 + tmp115 := tmp114.Get() + tmp116 := lang.Apply(tmp115, []any{v112, int64(0), nil}) + var v117 any = tmp116 _ = v117 // let binding "v" - v118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v119 := v118.FindInternedVar(lang.NewSymbol("nth")) - if v119.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v119))) + tmp118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp119 := tmp118.FindInternedVar(lang.NewSymbol("nth")) + if tmp119.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp119))) } - v120 := v119.Get() - v121 := lang.Apply(v120, []any{v112, int64(1), nil}) - var v122 any = v121 + tmp120 := tmp119.Get() + tmp121 := lang.Apply(tmp120, []any{v112, int64(1), nil}) + var v122 any = tmp121 _ = v122 // let binding "g" - v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v124 := v123.FindInternedVar(lang.NewSymbol("nth")) - if v124.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) + tmp123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp124 := tmp123.FindInternedVar(lang.NewSymbol("nth")) + if tmp124.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp124))) } - v125 := v124.Get() - v126 := lang.Apply(v125, []any{v112, int64(2), nil}) - var v127 any = v126 + tmp125 := tmp124.Get() + tmp126 := lang.Apply(tmp125, []any{v112, int64(2), nil}) + var v127 any = tmp126 _ = v127 - var v128 any - v129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v130 := v129.FindInternedVar(lang.NewSymbol("symbol?")) - if v130.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v130))) + var tmp128 any + tmp129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp130 := tmp129.FindInternedVar(lang.NewSymbol("symbol?")) + if tmp130.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp130))) } - v131 := v130.Get() - v132 := lang.Apply(v131, []any{v117}) - if lang.IsTruthy(v132) { - v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v134 := v133.FindInternedVar(lang.NewSymbol("conj")) - if v134.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) + tmp131 := tmp130.Get() + tmp132 := lang.Apply(tmp131, []any{v117}) + if lang.IsTruthy(tmp132) { + tmp133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp134 := tmp133.FindInternedVar(lang.NewSymbol("conj")) + if tmp134.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp134))) } - v135 := v134.Get() - v136 := lang.Apply(v135, []any{v109, v127, v122}) - v128 = v136 + tmp135 := tmp134.Get() + tmp136 := lang.Apply(tmp135, []any{v109, v127, v122}) + tmp128 = tmp136 } else { - v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v138 := v137.FindInternedVar(lang.NewSymbol("conj")) - if v138.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) + tmp137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp138 := tmp137.FindInternedVar(lang.NewSymbol("conj")) + if tmp138.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp138))) } - v139 := v138.Get() - v140 := lang.Apply(v139, []any{v109, v127, v122, v117, v127}) - v128 = v140 + tmp139 := tmp138.Get() + tmp140 := lang.Apply(tmp139, []any{v109, v127, v122, v117, v127}) + tmp128 = tmp140 } - v111 = v128 + tmp111 = tmp128 } // end let - return v111 + return tmp111 }) - v109 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4612), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(4615), lang.NewKeyword("end-column"), int(50)) - v110, err := lang.WithMeta(v108, v109.(lang.IPersistentMap)) + tmp109 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4612), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(4615), lang.NewKeyword("end-column"), int(50)) + tmp110, err := lang.WithMeta(tmp108, tmp109.(lang.IPersistentMap)) if err != nil { panic(err) } - v111 := lang.NewVector() - v112 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4616), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(4616), lang.NewKeyword("end-column"), int(28)) - v113, err := lang.WithMeta(v111, v112.(lang.IPersistentMap)) + tmp111 := lang.NewVector() + tmp112 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4616), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(4616), lang.NewKeyword("end-column"), int(28)) + tmp113, err := lang.WithMeta(tmp111, tmp112.(lang.IPersistentMap)) if err != nil { panic(err) } - v114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v115 := v114.FindInternedVar(lang.NewSymbol("map")) - if v115.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v115))) - } - v116 := v115.Get() - v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v118 := v117.FindInternedVar(lang.NewSymbol("vector")) - if v118.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) - } - v119 := v118.Get() - v120 := lang.Apply(v116, []any{v119, v96, v91, v104}) - v121 := lang.Apply(v107, []any{v110, v113, v120}) - var v122 any = v121 + tmp114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp115 := tmp114.FindInternedVar(lang.NewSymbol("map")) + if tmp115.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp115))) + } + tmp116 := tmp115.Get() + tmp117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp118 := tmp117.FindInternedVar(lang.NewSymbol("vector")) + if tmp118.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp118))) + } + tmp119 := tmp118.Get() + tmp120 := lang.Apply(tmp116, []any{tmp119, v96, v91, v104}) + tmp121 := lang.Apply(tmp107, []any{tmp110, tmp113, tmp120}) + var v122 any = tmp121 _ = v122 - v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v124 := v123.FindInternedVar(lang.NewSymbol("seq")) - if v124.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) - } - v125 := v124.Get() - v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v127 := v126.FindInternedVar(lang.NewSymbol("concat")) - if v127.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) - } - v128 := v127.Get() - v129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v130 := v129.FindInternedVar(lang.NewSymbol("list")) - if v130.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v130))) - } - v131 := v130.Get() - v132 := lang.Apply(v131, []any{lang.NewSymbol("glojure.core/let")}) - v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v134 := v133.FindInternedVar(lang.NewSymbol("list")) - if v134.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) - } - v135 := v134.Get() - v136 := lang.Apply(v135, []any{v122}) - v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v138 := v137.FindInternedVar(lang.NewSymbol("list")) - if v138.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) - } - v139 := v138.Get() - v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v141 := v140.FindInternedVar(lang.NewSymbol("seq")) - if v141.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) - } - v142 := v141.Get() - v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v144 := v143.FindInternedVar(lang.NewSymbol("concat")) - if v144.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) - } - v145 := v144.Get() - v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v147 := v146.FindInternedVar(lang.NewSymbol("list")) - if v147.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) - } - v148 := v147.Get() - v149 := lang.Apply(v148, []any{lang.NewSymbol("loop*")}) - v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v151 := v150.FindInternedVar(lang.NewSymbol("list")) - if v151.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) - } - v152 := v151.Get() - v153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v154 := v153.FindInternedVar(lang.NewSymbol("vec")) - if v154.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v154))) - } - v155 := v154.Get() - v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v157 := v156.FindInternedVar(lang.NewSymbol("interleave")) - if v157.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) - } - v158 := v157.Get() - v159 := lang.Apply(v158, []any{v104, v104}) - v160 := lang.Apply(v155, []any{v159}) - v161 := lang.Apply(v152, []any{v160}) - v162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v163 := v162.FindInternedVar(lang.NewSymbol("list")) - if v163.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v163))) - } - v164 := v163.Get() - v165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v166 := v165.FindInternedVar(lang.NewSymbol("seq")) - if v166.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v166))) - } - v167 := v166.Get() - v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v169 := v168.FindInternedVar(lang.NewSymbol("concat")) - if v169.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) - } - v170 := v169.Get() - v171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v172 := v171.FindInternedVar(lang.NewSymbol("list")) - if v172.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v172))) - } - v173 := v172.Get() - v174 := lang.Apply(v173, []any{lang.NewSymbol("glojure.core/let")}) - v175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v176 := v175.FindInternedVar(lang.NewSymbol("list")) - if v176.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v176))) - } - v177 := v176.Get() - v178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v179 := v178.FindInternedVar(lang.NewSymbol("vec")) - if v179.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v179))) - } - v180 := v179.Get() - v181 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v182 := v181.FindInternedVar(lang.NewSymbol("interleave")) - if v182.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v182))) - } - v183 := v182.Get() - v184 := lang.Apply(v183, []any{v96, v104}) - v185 := lang.Apply(v180, []any{v184}) - v186 := lang.Apply(v177, []any{v185}) - v187 := lang.Apply(v170, []any{v174, v186, v6}) - v188 := lang.Apply(v167, []any{v187}) - v189 := lang.Apply(v164, []any{v188}) - v190 := lang.Apply(v145, []any{v149, v161, v189}) - v191 := lang.Apply(v142, []any{v190}) - v192 := lang.Apply(v139, []any{v191}) - v193 := lang.Apply(v128, []any{v132, v136, v192}) - v194 := lang.Apply(v125, []any{v193}) - v82 = v194 + tmp123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp124 := tmp123.FindInternedVar(lang.NewSymbol("seq")) + if tmp124.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp124))) + } + tmp125 := tmp124.Get() + tmp126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp127 := tmp126.FindInternedVar(lang.NewSymbol("concat")) + if tmp127.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp127))) + } + tmp128 := tmp127.Get() + tmp129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp130 := tmp129.FindInternedVar(lang.NewSymbol("list")) + if tmp130.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp130))) + } + tmp131 := tmp130.Get() + tmp132 := lang.Apply(tmp131, []any{lang.NewSymbol("glojure.core/let")}) + tmp133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp134 := tmp133.FindInternedVar(lang.NewSymbol("list")) + if tmp134.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp134))) + } + tmp135 := tmp134.Get() + tmp136 := lang.Apply(tmp135, []any{v122}) + tmp137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp138 := tmp137.FindInternedVar(lang.NewSymbol("list")) + if tmp138.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp138))) + } + tmp139 := tmp138.Get() + tmp140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp141 := tmp140.FindInternedVar(lang.NewSymbol("seq")) + if tmp141.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp141))) + } + tmp142 := tmp141.Get() + tmp143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp144 := tmp143.FindInternedVar(lang.NewSymbol("concat")) + if tmp144.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp144))) + } + tmp145 := tmp144.Get() + tmp146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp147 := tmp146.FindInternedVar(lang.NewSymbol("list")) + if tmp147.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp147))) + } + tmp148 := tmp147.Get() + tmp149 := lang.Apply(tmp148, []any{lang.NewSymbol("loop*")}) + tmp150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp151 := tmp150.FindInternedVar(lang.NewSymbol("list")) + if tmp151.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp151))) + } + tmp152 := tmp151.Get() + tmp153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp154 := tmp153.FindInternedVar(lang.NewSymbol("vec")) + if tmp154.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp154))) + } + tmp155 := tmp154.Get() + tmp156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp157 := tmp156.FindInternedVar(lang.NewSymbol("interleave")) + if tmp157.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp157))) + } + tmp158 := tmp157.Get() + tmp159 := lang.Apply(tmp158, []any{v104, v104}) + tmp160 := lang.Apply(tmp155, []any{tmp159}) + tmp161 := lang.Apply(tmp152, []any{tmp160}) + tmp162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp163 := tmp162.FindInternedVar(lang.NewSymbol("list")) + if tmp163.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp163))) + } + tmp164 := tmp163.Get() + tmp165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp166 := tmp165.FindInternedVar(lang.NewSymbol("seq")) + if tmp166.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp166))) + } + tmp167 := tmp166.Get() + tmp168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp169 := tmp168.FindInternedVar(lang.NewSymbol("concat")) + if tmp169.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp169))) + } + tmp170 := tmp169.Get() + tmp171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp172 := tmp171.FindInternedVar(lang.NewSymbol("list")) + if tmp172.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp172))) + } + tmp173 := tmp172.Get() + tmp174 := lang.Apply(tmp173, []any{lang.NewSymbol("glojure.core/let")}) + tmp175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp176 := tmp175.FindInternedVar(lang.NewSymbol("list")) + if tmp176.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp176))) + } + tmp177 := tmp176.Get() + tmp178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp179 := tmp178.FindInternedVar(lang.NewSymbol("vec")) + if tmp179.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp179))) + } + tmp180 := tmp179.Get() + tmp181 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp182 := tmp181.FindInternedVar(lang.NewSymbol("interleave")) + if tmp182.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp182))) + } + tmp183 := tmp182.Get() + tmp184 := lang.Apply(tmp183, []any{v96, v104}) + tmp185 := lang.Apply(tmp180, []any{tmp184}) + tmp186 := lang.Apply(tmp177, []any{tmp185}) + tmp187 := lang.Apply(tmp170, []any{tmp174, tmp186, v6}) + tmp188 := lang.Apply(tmp167, []any{tmp187}) + tmp189 := lang.Apply(tmp164, []any{tmp188}) + tmp190 := lang.Apply(tmp145, []any{tmp149, tmp161, tmp189}) + tmp191 := lang.Apply(tmp142, []any{tmp190}) + tmp192 := lang.Apply(tmp139, []any{tmp191}) + tmp193 := lang.Apply(tmp128, []any{tmp132, tmp136, tmp192}) + tmp194 := lang.Apply(tmp125, []any{tmp193}) + tmp82 = tmp194 } // end let - v61 = v82 + tmp61 = tmp82 } - v55 = v61 + tmp55 = tmp61 } // end let - return v55 + return tmp55 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // macroexpand { - v0 := lang.NewSymbol("macroexpand").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("form"))), lang.NewKeyword("doc"), "Repeatedly calls macroexpand-1 on form until it no longer\n represents a macro form, then returns it. Note neither\n macroexpand-1 nor macroexpand expand macros in subforms.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4025), lang.NewKeyword("end-line"), int(4025))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("macroexpand").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("form"))), lang.NewKeyword("doc"), "Repeatedly calls macroexpand-1 on form until it no longer\n represents a macro form, then returns it. Note neither\n macroexpand-1 nor macroexpand expand macros in subforms.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4025), lang.NewKeyword("end-line"), int(4025))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any + var tmp4 any { // let // let binding "ex" - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("macroexpand-1")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v3}) - var v9 any = v8 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("macroexpand-1")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v3}) + var v9 any = tmp8 _ = v9 - var v10 any - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("identical?")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{v9, v3}) - if lang.IsTruthy(v14) { - v10 = v3 + var tmp10 any + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("identical?")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{v9, v3}) + if lang.IsTruthy(tmp14) { + tmp10 = v3 } else { - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("macroexpand")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("macroexpand")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{v9}) - v10 = v18 + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{v9}) + tmp10 = tmp18 } - v4 = v10 + tmp4 = tmp10 } // end let - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // macroexpand-1 { - v0 := lang.NewSymbol("macroexpand-1").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("form"))), lang.NewKeyword("doc"), "If form represents a macro form, returns its expansion,\n else returns form.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4017), lang.NewKeyword("end-line"), int(4017))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("macroexpand-1").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("form"))), lang.NewKeyword("doc"), "If form represents a macro form, returns its expansion,\n else returns form.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4017), lang.NewKeyword("end-line"), int(4017))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4, _ := lang.FieldOrMethod(runtime4.Compiler, "macroexpand1") - if reflect.TypeOf(v4).Kind() != reflect.Func { + tmp4, _ := lang.FieldOrMethod(runtime4.Compiler, "macroexpand1") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("macroexpand1 is not a function"))) } - v5 := lang.Apply(v4, []any{v3}) - return v5 + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // make-array { - v0 := lang.NewSymbol("make-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("type"), lang.NewSymbol("len")), lang.NewVector(lang.NewSymbol("type"), lang.NewSymbol("dim"), lang.NewSymbol("&"), lang.NewSymbol("more-dims"))), lang.NewKeyword("doc"), "Creates and returns an array of instances of the specified class of\n the specified dimension(s). Note that a class object is required.\n Class objects can be obtained by using their imported or\n fully-qualified name. Class objects for the primitive types can be\n obtained using, e.g., Integer/TYPE.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3985), lang.NewKeyword("end-line"), int(3985))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("make-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("type"), lang.NewSymbol("len")), lang.NewVector(lang.NewSymbol("type"), lang.NewSymbol("dim"), lang.NewSymbol("&"), lang.NewSymbol("more-dims"))), lang.NewKeyword("doc"), "Creates and returns an array of instances of the specified class of\n the specified dimension(s). Note that a class object is required.\n Class objects can be obtained by using their imported or\n fully-qualified name. Class objects for the primitive types can be\n obtained using, e.g., Integer/TYPE.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3985), lang.NewKeyword("end-line"), int(3985))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("int")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v4}) - v9, _ := lang.FieldOrMethod(nil, "newInstance") - if reflect.TypeOf(v9).Kind() != reflect.Func { + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("int")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v4}) + tmp9, _ := lang.FieldOrMethod(nil, "newInstance") + if reflect.TypeOf(tmp9).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("newInstance is not a function"))) } - v10 := lang.Apply(v9, []any{v3, v8}) - return v10 + tmp10 := lang.Apply(tmp9, []any{v3, tmp8}) + return tmp10 default: if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -51672,207 +51774,207 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.NewList(args[2:]...) - var v6 any + var v5 any = lang.NewList(args[2:]...) + _ = v5 + var tmp6 any { // let // let binding "dims" - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("cons")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v9, []any{v4, v5}) - var v11 any = v10 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("cons")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + var v11 any = tmp10 _ = v11 // let binding "dimarray" - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("make-array")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("make-array")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) } - v14 := v13.Get() - v15, ok := lang.FieldOrMethod(nil, "TYPE") + tmp14 := tmp13.Get() + tmp15, ok := lang.FieldOrMethod(nil, "TYPE") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "TYPE"))) } - var v16 any - switch reflect.TypeOf(v15).Kind() { + var tmp16 any + switch reflect.TypeOf(tmp15).Kind() { case reflect.Func: - v16 = lang.Apply(v15, nil) + tmp16 = lang.Apply(tmp15, nil) default: - v16 = v15 + tmp16 = tmp15 } - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("count")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("count")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) } - v19 := v18.Get() - v20 := lang.Apply(v19, []any{v11}) - v21 := lang.Apply(v14, []any{v16, v20}) - var v22 any = v21 + tmp19 := tmp18.Get() + tmp20 := lang.Apply(tmp19, []any{v11}) + tmp21 := lang.Apply(tmp14, []any{tmp16, tmp20}) + var v22 any = tmp21 _ = v22 - var v23 any + var tmp23 any { // let // let binding "n__0__auto__" - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("long")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("alength")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{v22}) - v31 := lang.Apply(v26, []any{v30}) - var v32 any = v31 + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("long")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("alength")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{v22}) + tmp31 := lang.Apply(tmp26, []any{tmp30}) + var v32 any = tmp31 _ = v32 - var v33 any + var tmp33 any { // let // let binding "i" var v34 any = int64(0) _ = v34 for { - var v35 any - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("<")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + var tmp35 any + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("<")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) } - v38 := v37.Get() - v39 := lang.Apply(v38, []any{v34, v32}) - if lang.IsTruthy(v39) { - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("aset-int")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{v34, v32}) + if lang.IsTruthy(tmp39) { + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("aset-int")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) } - v42 := v41.Get() - v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v44 := v43.FindInternedVar(lang.NewSymbol("nth")) - if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) + tmp42 := tmp41.Get() + tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp44 := tmp43.FindInternedVar(lang.NewSymbol("nth")) + if tmp44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) } - v45 := v44.Get() - v46 := lang.Apply(v45, []any{v11, v34}) - v47 := lang.Apply(v42, []any{v22, v34, v46}) - _ = v47 - v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v50 := v49.FindInternedVar(lang.NewSymbol("unchecked-inc")) - if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) + tmp45 := tmp44.Get() + tmp46 := lang.Apply(tmp45, []any{v11, v34}) + tmp47 := lang.Apply(tmp42, []any{v22, v34, tmp46}) + _ = tmp47 + tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp50 := tmp49.FindInternedVar(lang.NewSymbol("unchecked-inc")) + if tmp50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) } - v51 := v50.Get() - v52 := lang.Apply(v51, []any{v34}) - var v48 any = v52 - v34 = v48 + tmp51 := tmp50.Get() + tmp52 := lang.Apply(tmp51, []any{v34}) + var tmp48 any = tmp52 + v34 = tmp48 continue } else { - v35 = nil } - v33 = v35 + tmp33 = tmp35 break } } // end let - v23 = v33 + tmp23 = tmp33 } // end let - _ = v23 - v24, _ := lang.FieldOrMethod(nil, "newInstance") - if reflect.TypeOf(v24).Kind() != reflect.Func { + _ = tmp23 + tmp24, _ := lang.FieldOrMethod(nil, "newInstance") + if reflect.TypeOf(tmp24).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("newInstance is not a function"))) } - v25 := lang.Apply(v24, []any{v3, v22}) - v6 = v25 + tmp25 := lang.Apply(tmp24, []any{v3, v22}) + tmp6 = tmp25 } // end let - return v6 + return tmp6 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // make-hierarchy { - v0 := lang.NewSymbol("make-hierarchy").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Creates a hierarchy object for use with derive, isa? etc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5507), lang.NewKeyword("end-line"), int(5507))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("make-hierarchy").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Creates a hierarchy object for use with derive, isa? etc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5507), lang.NewKeyword("end-line"), int(5507))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v3 := lang.NewMap() - v4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5511), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(5511), lang.NewKeyword("end-column"), int(17)) - v5, err := lang.WithMeta(v3, v4.(lang.IPersistentMap)) + tmp3 := lang.NewMap() + tmp4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5511), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(5511), lang.NewKeyword("end-column"), int(17)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) if err != nil { panic(err) } - v6 := lang.NewMap() - v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5511), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(5511), lang.NewKeyword("end-column"), int(33)) - v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) + tmp6 := lang.NewMap() + tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5511), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(5511), lang.NewKeyword("end-column"), int(33)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) if err != nil { panic(err) } - v9 := lang.NewMap() - v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5511), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(5511), lang.NewKeyword("end-column"), int(47)) - v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) + tmp9 := lang.NewMap() + tmp10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5511), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(5511), lang.NewKeyword("end-column"), int(47)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) if err != nil { panic(err) } - v12 := lang.NewMap(lang.NewKeyword("parents"), v5, lang.NewKeyword("descendants"), v8, lang.NewKeyword("ancestors"), v11) - v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5511), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(5511), lang.NewKeyword("end-column"), int(48)) - v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) + tmp12 := lang.NewMap(lang.NewKeyword("parents"), tmp5, lang.NewKeyword("descendants"), tmp8, lang.NewKeyword("ancestors"), tmp11) + tmp13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5511), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(5511), lang.NewKeyword("end-column"), int(48)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) if err != nil { panic(err) } - return v14 + return tmp14 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // map { - v0 := lang.NewSymbol("map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2"), lang.NewSymbol("c3")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2"), lang.NewSymbol("c3"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Returns a lazy sequence consisting of the result of applying f to\n the set of first items of each coll, followed by applying f to the\n set of second items in each coll, until any one of the colls is\n exhausted. Any remaining items in other colls are ignored. Function\n f should accept number-of-colls arguments. Returns a transducer when\n no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2719), lang.NewKeyword("end-line"), int(2719))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2"), lang.NewSymbol("c3")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2"), lang.NewSymbol("c3"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Returns a lazy sequence consisting of the result of applying f to\n the set of first items of each coll, followed by applying f to the\n set of second items in each coll, until any one of the colls is\n exhausted. Any remaining items in other colls are ignored. Function\n f should accept number-of-colls arguments. Returns a transducer when\n no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2719), lang.NewKeyword("end-line"), int(2719))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - var v4 lang.FnFunc - v4 = lang.NewFnFunc(func(args ...any) any { + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v5 := args[0] _ = v5 - var v6 lang.FnFunc - v6 = lang.NewFnFunc(func(args ...any) any { + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - v7 := lang.Apply(v5, nil) - return v7 + tmp7 := lang.Apply(v5, nil) + return tmp7 case 1: v7 := args[0] _ = v7 - v8 := lang.Apply(v5, []any{v7}) - return v8 + tmp8 := lang.Apply(v5, []any{v7}) + return tmp8 case 2: v7 := args[0] _ = v7 v8 := args[1] _ = v8 - v9 := lang.Apply(v3, []any{v8}) - v10 := lang.Apply(v5, []any{v7, v9}) - return v10 + tmp9 := lang.Apply(v3, []any{v8}) + tmp10 := lang.Apply(v5, []any{v7, tmp9}) + return tmp10 default: if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -51881,238 +51983,237 @@ func init() { _ = v7 v8 := args[1] _ = v8 - v9 := lang.NewList(args[2:]...) - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("apply")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{v3, v8, v9}) - v14 := lang.Apply(v5, []any{v7, v13}) - return v14 + var v9 any = lang.NewList(args[2:]...) + _ = v9 + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("apply")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{v3, v8, v9}) + tmp14 := lang.Apply(v5, []any{v7, tmp13}) + return tmp14 } }) - v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2730), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(2736), lang.NewKeyword("end-column"), int(47)) - v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) + tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2730), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(2736), lang.NewKeyword("end-column"), int(47)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) if err != nil { panic(err) } - return v8 + return tmp8 }) - v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2729), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2736), lang.NewKeyword("end-column"), int(48)) - v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) + tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2729), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2736), lang.NewKeyword("end-column"), int(48)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) if err != nil { panic(err) } - return v6 + return tmp6 case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - var v5 lang.FnFunc - v5 = lang.NewFnFunc(func(args ...any) any { + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - var v6 any + var tmp6 any { // let // let binding "temp__0__auto__" - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("seq")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v9, []any{v4}) - var v11 any = v10 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("seq")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp9, []any{v4}) + var v11 any = tmp10 _ = v11 - var v12 any + var tmp12 any if lang.IsTruthy(v11) { - var v13 any + var tmp13 any { // let // let binding "s" var v14 any = v11 _ = v14 - var v15 any - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("chunked-seq?")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + var tmp15 any + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("chunked-seq?")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{v14}) - if lang.IsTruthy(v19) { - var v20 any + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{v14}) + if lang.IsTruthy(tmp19) { + var tmp20 any { // let // let binding "c" - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("chunk-first")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("chunk-first")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) } - v23 := v22.Get() - v24 := lang.Apply(v23, []any{v14}) - var v25 any = v24 + tmp23 := tmp22.Get() + tmp24 := lang.Apply(tmp23, []any{v14}) + var v25 any = tmp24 _ = v25 // let binding "size" - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("int")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("int")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) } - v28 := v27.Get() - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("count")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + tmp28 := tmp27.Get() + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("count")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) } - v31 := v30.Get() - v32 := lang.Apply(v31, []any{v25}) - v33 := lang.Apply(v28, []any{v32}) - var v34 any = v33 + tmp31 := tmp30.Get() + tmp32 := lang.Apply(tmp31, []any{v25}) + tmp33 := lang.Apply(tmp28, []any{tmp32}) + var v34 any = tmp33 _ = v34 // let binding "b" - v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v36 := v35.FindInternedVar(lang.NewSymbol("chunk-buffer")) - if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp36 := tmp35.FindInternedVar(lang.NewSymbol("chunk-buffer")) + if tmp36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) } - v37 := v36.Get() - v38 := lang.Apply(v37, []any{v34}) - var v39 any = v38 + tmp37 := tmp36.Get() + tmp38 := lang.Apply(tmp37, []any{v34}) + var v39 any = tmp38 _ = v39 - var v40 any + var tmp40 any { // let // let binding "n__0__auto__" - v41 := lang.Apply(lang.LongCast, []any{v34}) - var v42 any = v41 + tmp41 := lang.Apply(lang.LongCast, []any{v34}) + var v42 any = tmp41 _ = v42 - var v43 any + var tmp43 any { // let // let binding "i" var v44 any = int64(0) _ = v44 for { - var v45 any - v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v47 := v46.FindInternedVar(lang.NewSymbol("<")) - if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) + var tmp45 any + tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp47 := tmp46.FindInternedVar(lang.NewSymbol("<")) + if tmp47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) } - v48 := v47.Get() - v49 := lang.Apply(v48, []any{v44, v42}) - if lang.IsTruthy(v49) { - v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v51 := v50.FindInternedVar(lang.NewSymbol("chunk-append")) - if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) + tmp48 := tmp47.Get() + tmp49 := lang.Apply(tmp48, []any{v44, v42}) + if lang.IsTruthy(tmp49) { + tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp51 := tmp50.FindInternedVar(lang.NewSymbol("chunk-append")) + if tmp51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) } - v52 := v51.Get() - v53, _ := lang.FieldOrMethod(v25, "nth") - if reflect.TypeOf(v53).Kind() != reflect.Func { + tmp52 := tmp51.Get() + tmp53, _ := lang.FieldOrMethod(v25, "nth") + if reflect.TypeOf(tmp53).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) } - v54 := lang.Apply(v53, []any{v44}) - v55 := lang.Apply(v3, []any{v54}) - v56 := lang.Apply(v52, []any{v39, v55}) - _ = v56 - v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v59 := v58.FindInternedVar(lang.NewSymbol("unchecked-inc")) - if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) + tmp54 := lang.Apply(tmp53, []any{v44}) + tmp55 := lang.Apply(v3, []any{tmp54}) + tmp56 := lang.Apply(tmp52, []any{v39, tmp55}) + _ = tmp56 + tmp58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp59 := tmp58.FindInternedVar(lang.NewSymbol("unchecked-inc")) + if tmp59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp59))) } - v60 := v59.Get() - v61 := lang.Apply(v60, []any{v44}) - var v57 any = v61 - v44 = v57 + tmp60 := tmp59.Get() + tmp61 := lang.Apply(tmp60, []any{v44}) + var tmp57 any = tmp61 + v44 = tmp57 continue } else { - v45 = nil } - v43 = v45 + tmp43 = tmp45 break } } // end let - v40 = v43 + tmp40 = tmp43 } // end let - _ = v40 - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("chunk-cons")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + _ = tmp40 + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("chunk-cons")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) } - v43 := v42.Get() - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("chunk")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + tmp43 := tmp42.Get() + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("chunk")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) } - v46 := v45.Get() - v47 := lang.Apply(v46, []any{v39}) - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("map")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + tmp46 := tmp45.Get() + tmp47 := lang.Apply(tmp46, []any{v39}) + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("map")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) } - v50 := v49.Get() - v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v52 := v51.FindInternedVar(lang.NewSymbol("chunk-rest")) - if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) + tmp50 := tmp49.Get() + tmp51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp52 := tmp51.FindInternedVar(lang.NewSymbol("chunk-rest")) + if tmp52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp52))) } - v53 := v52.Get() - v54 := lang.Apply(v53, []any{v14}) - v55 := lang.Apply(v50, []any{v3, v54}) - v56 := lang.Apply(v43, []any{v47, v55}) - v20 = v56 + tmp53 := tmp52.Get() + tmp54 := lang.Apply(tmp53, []any{v14}) + tmp55 := lang.Apply(tmp50, []any{v3, tmp54}) + tmp56 := lang.Apply(tmp43, []any{tmp47, tmp55}) + tmp20 = tmp56 } // end let - v15 = v20 + tmp15 = tmp20 } else { - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("cons")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("cons")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("first")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("first")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) } - v26 := v25.Get() - v27 := lang.Apply(v26, []any{v14}) - v28 := lang.Apply(v3, []any{v27}) - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("map")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + tmp26 := tmp25.Get() + tmp27 := lang.Apply(tmp26, []any{v14}) + tmp28 := lang.Apply(v3, []any{tmp27}) + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("map")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) } - v31 := v30.Get() - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("rest")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + tmp31 := tmp30.Get() + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("rest")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{v14}) - v36 := lang.Apply(v31, []any{v3, v35}) - v37 := lang.Apply(v23, []any{v28, v36}) - v15 = v37 + tmp34 := tmp33.Get() + tmp35 := lang.Apply(tmp34, []any{v14}) + tmp36 := lang.Apply(tmp31, []any{v3, tmp35}) + tmp37 := lang.Apply(tmp23, []any{tmp28, tmp36}) + tmp15 = tmp37 } - v13 = v15 + tmp13 = tmp15 } // end let - v12 = v13 + tmp12 = tmp13 } else { - v12 = nil } - v6 = v12 + tmp6 = tmp12 } // end let - return v6 + return tmp6 }) - v6 := lang.Apply(lang.NewLazySeq, []any{v5}) - return v6 + tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) + return tmp6 case 3: v3 := args[0] _ = v3 @@ -52120,101 +52221,100 @@ func init() { _ = v4 v5 := args[2] _ = v5 - var v6 lang.FnFunc - v6 = lang.NewFnFunc(func(args ...any) any { + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - var v7 any + var tmp7 any { // let // let binding "s1" - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("seq")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v4}) - var v12 any = v11 + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("seq")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v4}) + var v12 any = tmp11 _ = v12 // let binding "s2" - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("seq")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{v5}) - var v17 any = v16 + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("seq")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{v5}) + var v17 any = tmp16 _ = v17 - var v18 any - var v19 any + var tmp18 any + var tmp19 any { // let // let binding "and__0__auto__" var v20 any = v12 _ = v20 - var v21 any + var tmp21 any if lang.IsTruthy(v20) { - v21 = v17 + tmp21 = v17 } else { - v21 = v20 + tmp21 = v20 } - v19 = v21 + tmp19 = tmp21 } // end let - if lang.IsTruthy(v19) { - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("cons")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("first")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.Apply(v25, []any{v12}) - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("first")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{v17}) - v31 := lang.Apply(v3, []any{v26, v30}) - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("map")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v36 := v35.FindInternedVar(lang.NewSymbol("rest")) - if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) - } - v37 := v36.Get() - v38 := lang.Apply(v37, []any{v12}) - v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v40 := v39.FindInternedVar(lang.NewSymbol("rest")) - if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) - } - v41 := v40.Get() - v42 := lang.Apply(v41, []any{v17}) - v43 := lang.Apply(v34, []any{v3, v38, v42}) - v44 := lang.Apply(v22, []any{v31, v43}) - v18 = v44 + if lang.IsTruthy(tmp19) { + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("cons")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("first")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.Apply(tmp25, []any{v12}) + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("first")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{v17}) + tmp31 := lang.Apply(v3, []any{tmp26, tmp30}) + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("map")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp36 := tmp35.FindInternedVar(lang.NewSymbol("rest")) + if tmp36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) + } + tmp37 := tmp36.Get() + tmp38 := lang.Apply(tmp37, []any{v12}) + tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp40 := tmp39.FindInternedVar(lang.NewSymbol("rest")) + if tmp40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) + } + tmp41 := tmp40.Get() + tmp42 := lang.Apply(tmp41, []any{v17}) + tmp43 := lang.Apply(tmp34, []any{v3, tmp38, tmp42}) + tmp44 := lang.Apply(tmp22, []any{tmp31, tmp43}) + tmp18 = tmp44 } else { - v18 = nil } - v7 = v18 + tmp7 = tmp18 } // end let - return v7 + return tmp7 }) - v7 := lang.Apply(lang.NewLazySeq, []any{v6}) - return v7 + tmp7 := lang.Apply(lang.NewLazySeq, []any{tmp6}) + return tmp7 case 4: v3 := args[0] _ = v3 @@ -52224,138 +52324,137 @@ func init() { _ = v5 v6 := args[3] _ = v6 - var v7 lang.FnFunc - v7 = lang.NewFnFunc(func(args ...any) any { + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - var v8 any + var tmp8 any { // let // let binding "s1" - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("seq")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.Apply(v11, []any{v4}) - var v13 any = v12 + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("seq")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.Apply(tmp11, []any{v4}) + var v13 any = tmp12 _ = v13 // let binding "s2" - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("seq")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{v5}) - var v18 any = v17 + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("seq")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{v5}) + var v18 any = tmp17 _ = v18 // let binding "s3" - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("seq")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{v6}) - var v23 any = v22 + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("seq")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, []any{v6}) + var v23 any = tmp22 _ = v23 - var v24 any - var v25 any + var tmp24 any + var tmp25 any { // let // let binding "and__0__auto__" var v26 any = v13 _ = v26 - var v27 any + var tmp27 any if lang.IsTruthy(v26) { - var v28 any + var tmp28 any { // let // let binding "and__0__auto__" var v29 any = v18 _ = v29 - var v30 any + var tmp30 any if lang.IsTruthy(v29) { - v30 = v23 + tmp30 = v23 } else { - v30 = v29 + tmp30 = v29 } - v28 = v30 + tmp28 = tmp30 } // end let - v27 = v28 + tmp27 = tmp28 } else { - v27 = v26 + tmp27 = v26 } - v25 = v27 + tmp25 = tmp27 } // end let - if lang.IsTruthy(v25) { - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("cons")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) - } - v28 := v27.Get() - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("first")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.Apply(v31, []any{v13}) - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("first")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - v36 := lang.Apply(v35, []any{v18}) - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("first")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.Apply(v39, []any{v23}) - v41 := lang.Apply(v3, []any{v32, v36, v40}) - v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v43 := v42.FindInternedVar(lang.NewSymbol("map")) - if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) - } - v44 := v43.Get() - v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v46 := v45.FindInternedVar(lang.NewSymbol("rest")) - if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) - } - v47 := v46.Get() - v48 := lang.Apply(v47, []any{v13}) - v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v50 := v49.FindInternedVar(lang.NewSymbol("rest")) - if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) - } - v51 := v50.Get() - v52 := lang.Apply(v51, []any{v18}) - v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v54 := v53.FindInternedVar(lang.NewSymbol("rest")) - if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) - } - v55 := v54.Get() - v56 := lang.Apply(v55, []any{v23}) - v57 := lang.Apply(v44, []any{v3, v48, v52, v56}) - v58 := lang.Apply(v28, []any{v41, v57}) - v24 = v58 + if lang.IsTruthy(tmp25) { + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("cons")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) + } + tmp28 := tmp27.Get() + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("first")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.Apply(tmp31, []any{v13}) + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("first")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) + } + tmp35 := tmp34.Get() + tmp36 := lang.Apply(tmp35, []any{v18}) + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("first")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.Apply(tmp39, []any{v23}) + tmp41 := lang.Apply(v3, []any{tmp32, tmp36, tmp40}) + tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp43 := tmp42.FindInternedVar(lang.NewSymbol("map")) + if tmp43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) + } + tmp44 := tmp43.Get() + tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp46 := tmp45.FindInternedVar(lang.NewSymbol("rest")) + if tmp46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) + } + tmp47 := tmp46.Get() + tmp48 := lang.Apply(tmp47, []any{v13}) + tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp50 := tmp49.FindInternedVar(lang.NewSymbol("rest")) + if tmp50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) + } + tmp51 := tmp50.Get() + tmp52 := lang.Apply(tmp51, []any{v18}) + tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp54 := tmp53.FindInternedVar(lang.NewSymbol("rest")) + if tmp54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) + } + tmp55 := tmp54.Get() + tmp56 := lang.Apply(tmp55, []any{v23}) + tmp57 := lang.Apply(tmp44, []any{v3, tmp48, tmp52, tmp56}) + tmp58 := lang.Apply(tmp28, []any{tmp41, tmp57}) + tmp24 = tmp58 } else { - v24 = nil } - v8 = v24 + tmp8 = tmp24 } // end let - return v8 + return tmp8 }) - v8 := lang.Apply(lang.NewLazySeq, []any{v7}) - return v8 + tmp8 := lang.Apply(lang.NewLazySeq, []any{tmp7}) + return tmp8 default: if len(args) < 4 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -52368,272 +52467,274 @@ func init() { _ = v5 v6 := args[3] _ = v6 - v7 := lang.NewList(args[4:]...) - var v8 any + var v7 any = lang.NewList(args[4:]...) + _ = v7 + var tmp8 any { // let // let binding "step" - var v9 lang.FnFunc + var tmp9 lang.FnFunc { // function step - v9 = lang.NewFnFunc(func(args ...any) any { + var v10 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v11 := args[0] _ = v11 - var v12 lang.FnFunc - v12 = lang.NewFnFunc(func(args ...any) any { + var tmp12 lang.FnFunc + tmp12 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - var v13 any + var tmp13 any { // let // let binding "ss" - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("map")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("map")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) } - v16 := v15.Get() - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("seq")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + tmp16 := tmp15.Get() + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) } - v19 := v18.Get() - v20 := lang.Apply(v16, []any{v19, v11}) - var v21 any = v20 + tmp19 := tmp18.Get() + tmp20 := lang.Apply(tmp16, []any{tmp19, v11}) + var v21 any = tmp20 _ = v21 - var v22 any - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("every?")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + var tmp22 any + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("every?")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) } - v25 := v24.Get() - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("identity")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + tmp25 := tmp24.Get() + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("identity")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) } - v28 := v27.Get() - v29 := lang.Apply(v25, []any{v28, v21}) - if lang.IsTruthy(v29) { - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("cons")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + tmp28 := tmp27.Get() + tmp29 := lang.Apply(tmp25, []any{tmp28, v21}) + if lang.IsTruthy(tmp29) { + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("cons")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) } - v32 := v31.Get() - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("map")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + tmp32 := tmp31.Get() + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("map")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) } - v35 := v34.Get() - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("first")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + tmp35 := tmp34.Get() + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("first")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) } - v38 := v37.Get() - v39 := lang.Apply(v35, []any{v38, v21}) - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("map")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp35, []any{tmp38, v21}) + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("map")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) } - v42 := v41.Get() - v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v44 := v43.FindInternedVar(lang.NewSymbol("rest")) - if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) + tmp42 := tmp41.Get() + tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp44 := tmp43.FindInternedVar(lang.NewSymbol("rest")) + if tmp44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) } - v45 := v44.Get() - v46 := lang.Apply(v42, []any{v45, v21}) - v47 := lang.Apply(v10, []any{v46}) - v48 := lang.Apply(v32, []any{v39, v47}) - v22 = v48 + tmp45 := tmp44.Get() + tmp46 := lang.Apply(tmp42, []any{tmp45, v21}) + tmp47 := lang.Apply(v10, []any{tmp46}) + tmp48 := lang.Apply(tmp32, []any{tmp39, tmp47}) + tmp22 = tmp48 } else { - v22 = nil } - v13 = v22 + tmp13 = tmp22 } // end let - return v13 + return tmp13 }) - v13 := lang.Apply(lang.NewLazySeq, []any{v12}) - return v13 + tmp13 := lang.Apply(lang.NewLazySeq, []any{tmp12}) + return tmp13 }) - v10 := v9 + v10 = tmp9 _ = v10 } - v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2761), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(2765), lang.NewKeyword("end-column"), int(68)) - v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) + tmp10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2761), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(2765), lang.NewKeyword("end-column"), int(68)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) if err != nil { panic(err) } - var v12 any = v11 + var v12 any = tmp11 _ = v12 - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("map")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - var v16 lang.FnFunc - v16 = lang.NewFnFunc(func(args ...any) any { + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("map")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + var tmp16 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v17 := args[0] _ = v17 - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("apply")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.Apply(v20, []any{v3, v17}) - return v21 + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("apply")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.Apply(tmp20, []any{v3, v17}) + return tmp21 }) - v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2766), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(2766), lang.NewKeyword("end-column"), int(22)) - v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) + tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2766), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(2766), lang.NewKeyword("end-column"), int(22)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) if err != nil { panic(err) } - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("conj")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("conj")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{v7, v6, v5, v4}) - v23 := lang.Apply(v12, []any{v22}) - v24 := lang.Apply(v15, []any{v18, v23}) - v8 = v24 + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, []any{v7, v6, v5, v4}) + tmp23 := lang.Apply(v12, []any{tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp18, tmp23}) + tmp8 = tmp24 } // end let - return v8 + return tmp8 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // map-entry? { - v0 := lang.NewSymbol("map-entry?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a map entry", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.8", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1473), lang.NewKeyword("end-line"), int(1473))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("map-entry?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a map entry", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.8", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1473), lang.NewKeyword("end-line"), int(1473))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) } - v6 := v5.Get() - v7 := lang.Apply(v6, []any{lang.MapEntry, v3}) - return v7 + tmp6 := tmp5.Get() + tmp7 := reflect.TypeOf((*lang.MapEntry)(nil)).Elem() + tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) + return tmp8 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // map-indexed { - v0 := lang.NewSymbol("map-indexed").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence consisting of the result of applying f to 0\n and the first item of coll, followed by applying f to 1 and the second\n item in coll, etc, until coll is exhausted. Thus function f should\n accept 2 arguments, index and item. Returns a stateful transducer when\n no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7309), lang.NewKeyword("end-line"), int(7309))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("map-indexed").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence consisting of the result of applying f to 0\n and the first item of coll, followed by applying f to 1 and the second\n item in coll, etc, until coll is exhausted. Thus function f should\n accept 2 arguments, index and item. Returns a stateful transducer when\n no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7309), lang.NewKeyword("end-line"), int(7309))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - var v4 lang.FnFunc - v4 = lang.NewFnFunc(func(args ...any) any { + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v5 := args[0] _ = v5 - var v6 any + var tmp6 any { // let // let binding "i" - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("volatile!")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v9, []any{int64(-1)}) - var v11 any = v10 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("volatile!")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp9, []any{int64(-1)}) + var v11 any = tmp10 _ = v11 - var v12 lang.FnFunc - v12 = lang.NewFnFunc(func(args ...any) any { + var tmp12 lang.FnFunc + tmp12 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - v13 := lang.Apply(v5, nil) - return v13 + tmp13 := lang.Apply(v5, nil) + return tmp13 case 1: v13 := args[0] _ = v13 - v14 := lang.Apply(v5, []any{v13}) - return v14 + tmp14 := lang.Apply(v5, []any{v13}) + return tmp14 case 2: v13 := args[0] _ = v13 v14 := args[1] _ = v14 - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("inc")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("inc")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) } - v17 := v16.Get() - v18, ok := lang.FieldOrMethod(v11, "Deref") + tmp17 := tmp16.Get() + tmp18, ok := lang.FieldOrMethod(v11, "Deref") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v11, "Deref"))) } - var v19 any - switch reflect.TypeOf(v18).Kind() { + var tmp19 any + switch reflect.TypeOf(tmp18).Kind() { case reflect.Func: - v19 = lang.Apply(v18, nil) + tmp19 = lang.Apply(tmp18, nil) default: - v19 = v18 + tmp19 = tmp18 } - v20 := lang.Apply(v17, []any{v19}) - v21, _ := lang.FieldOrMethod(v11, "reset") - if reflect.TypeOf(v21).Kind() != reflect.Func { + tmp20 := lang.Apply(tmp17, []any{tmp19}) + tmp21, _ := lang.FieldOrMethod(v11, "reset") + if reflect.TypeOf(tmp21).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) } - v22 := lang.Apply(v21, []any{v20}) - v23 := lang.Apply(v3, []any{v22, v14}) - v24 := lang.Apply(v5, []any{v13, v23}) - return v24 + tmp22 := lang.Apply(tmp21, []any{tmp20}) + tmp23 := lang.Apply(v3, []any{tmp22, v14}) + tmp24 := lang.Apply(v5, []any{v13, tmp23}) + return tmp24 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7320), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7324), lang.NewKeyword("end-column"), int(48)) - v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) + tmp13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7320), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7324), lang.NewKeyword("end-column"), int(48)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) if err != nil { panic(err) } - v6 = v14 + tmp6 = tmp14 } // end let - return v6 + return tmp6 }) - v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7318), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7324), lang.NewKeyword("end-column"), int(50)) - v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) + tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7318), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7324), lang.NewKeyword("end-column"), int(50)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) if err != nil { panic(err) } - return v6 + return tmp6 case 2: v3 := args[0] _ = v3 @@ -52644,138 +52745,141 @@ func init() { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // map? { - v0 := lang.NewSymbol("map?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x implements IPersistentMap", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(167), lang.NewKeyword("end-line"), int(171))).(*lang.Symbol) - var v2 lang.FnFunc + tmp0 := lang.NewSymbol("map?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x implements IPersistentMap", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(167), lang.NewKeyword("end-line"), int(171))).(*lang.Symbol) + var tmp2 lang.FnFunc { // function map? - v2 = lang.NewFnFunc(func(args ...any) any { + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{lang.IPersistentMap, v4}) - return v8 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("instance?")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := reflect.TypeOf((*lang.IPersistentMap)(nil)).Elem() + tmp9 := lang.Apply(tmp7, []any{tmp8, v4}) + return tmp9 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(171), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(171), lang.NewKeyword("end-column"), int(97))).(lang.FnFunc) - v3 := v2 + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(171), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(171), lang.NewKeyword("end-column"), int(97))).(lang.FnFunc) + v3 = tmp2 _ = v3 } - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // mapcat { - v0 := lang.NewSymbol("mapcat").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Returns the result of applying concat to the result of applying map\n to f and colls. Thus function f should return a collection. Returns\n a transducer when no collections are provided", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2775), lang.NewKeyword("end-line"), int(2775))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("mapcat").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Returns the result of applying concat to the result of applying map\n to f and colls. Thus function f should return a collection. Returns\n a transducer when no collections are provided", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2775), lang.NewKeyword("end-line"), int(2775))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("comp")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("map")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v9, []any{v3}) - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("cat")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v6, []any{v10, v13}) - return v14 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("comp")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("map")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp9, []any{v3}) + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("cat")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp6, []any{tmp10, tmp13}) + return tmp14 default: if len(args) < 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.NewList(args[1:]...) - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("apply")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("concat")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("apply")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("map")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v13, []any{v16, v3, v4}) - v18 := lang.Apply(v7, []any{v10, v17}) - return v18 - } - }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + var v4 any = lang.NewList(args[1:]...) + _ = v4 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("apply")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("concat")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("apply")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("map")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp13, []any{tmp16, v3, v4}) + tmp18 := lang.Apply(tmp7, []any{tmp10, tmp17}) + return tmp18 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // mapv { - v0 := lang.NewSymbol("mapv").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2"), lang.NewSymbol("c3")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2"), lang.NewSymbol("c3"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Returns a vector consisting of the result of applying f to the\n set of first items of each coll, followed by applying f to the set\n of second items in each coll, until any one of the colls is\n exhausted. Any remaining items in other colls are ignored. Function\n f should accept number-of-colls arguments.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6943), lang.NewKeyword("end-line"), int(6943))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("mapv").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2"), lang.NewSymbol("c3")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2"), lang.NewSymbol("c3"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Returns a vector consisting of the result of applying f to the\n set of first items of each coll, followed by applying f to the set\n of second items in each coll, until any one of the colls is\n exhausted. Any remaining items in other colls are ignored. Function\n f should accept number-of-colls arguments.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6943), lang.NewKeyword("end-line"), int(6943))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("persistent!")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("reduce")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - var v11 lang.FnFunc - v11 = lang.NewFnFunc(func(args ...any) any { + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("persistent!")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("reduce")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -52783,37 +52887,37 @@ func init() { _ = v12 v13 := args[1] _ = v13 - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("conj!")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v3, []any{v13}) - v18 := lang.Apply(v16, []any{v12, v17}) - return v18 + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("conj!")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(v3, []any{v13}) + tmp18 := lang.Apply(tmp16, []any{v12, tmp17}) + return tmp18 }) - v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6952), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(6952), lang.NewKeyword("end-column"), int(43)) - v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) + tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6952), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(6952), lang.NewKeyword("end-column"), int(43)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) if err != nil { panic(err) } - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("transient")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("transient")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) } - v16 := v15.Get() - v17 := lang.NewVector() - v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6952), lang.NewKeyword("column"), int(56), lang.NewKeyword("end-line"), int(6952), lang.NewKeyword("end-column"), int(57)) - v19, err := lang.WithMeta(v17, v18.(lang.IPersistentMap)) + tmp16 := tmp15.Get() + tmp17 := lang.NewVector() + tmp18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6952), lang.NewKeyword("column"), int(56), lang.NewKeyword("end-line"), int(6952), lang.NewKeyword("end-column"), int(57)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) if err != nil { panic(err) } - v20 := lang.Apply(v16, []any{v19}) - v21 := lang.Apply(v10, []any{v13, v20, v4}) - v22 := lang.Apply(v7, []any{v21}) - return v22 + tmp20 := lang.Apply(tmp16, []any{tmp19}) + tmp21 := lang.Apply(tmp10, []any{tmp13, tmp20, v4}) + tmp22 := lang.Apply(tmp7, []any{tmp21}) + return tmp22 case 3: v3 := args[0] _ = v3 @@ -52821,27 +52925,27 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("into")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.NewVector() - v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6955), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(6955), lang.NewKeyword("end-column"), int(13)) - v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("into")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.NewVector() + tmp10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6955), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(6955), lang.NewKeyword("end-column"), int(13)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) if err != nil { panic(err) } - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("map")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("map")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) } - v14 := v13.Get() - v15 := lang.Apply(v14, []any{v3, v4, v5}) - v16 := lang.Apply(v8, []any{v11, v15}) - return v16 + tmp14 := tmp13.Get() + tmp15 := lang.Apply(tmp14, []any{v3, v4, v5}) + tmp16 := lang.Apply(tmp8, []any{tmp11, tmp15}) + return tmp16 case 4: v3 := args[0] _ = v3 @@ -52851,27 +52955,27 @@ func init() { _ = v5 v6 := args[3] _ = v6 - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("into")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.NewVector() - v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6957), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(6957), lang.NewKeyword("end-column"), int(13)) - v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("into")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.NewVector() + tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6957), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(6957), lang.NewKeyword("end-column"), int(13)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) if err != nil { panic(err) } - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("map")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("map")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{v3, v4, v5, v6}) - v17 := lang.Apply(v9, []any{v12, v16}) - return v17 + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{v3, v4, v5, v6}) + tmp17 := lang.Apply(tmp9, []any{tmp12, tmp16}) + return tmp17 default: if len(args) < 4 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -52884,228 +52988,229 @@ func init() { _ = v5 v6 := args[3] _ = v6 - v7 := lang.NewList(args[4:]...) - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("into")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.NewVector() - v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6959), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(6959), lang.NewKeyword("end-column"), int(13)) - v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) + var v7 any = lang.NewList(args[4:]...) + _ = v7 + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("into")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.NewVector() + tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6959), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(6959), lang.NewKeyword("end-column"), int(13)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) if err != nil { panic(err) } - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("apply")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("apply")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) } - v16 := v15.Get() - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("map")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + tmp16 := tmp15.Get() + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("map")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) } - v19 := v18.Get() - v20 := lang.Apply(v16, []any{v19, v3, v4, v5, v6, v7}) - v21 := lang.Apply(v10, []any{v13, v20}) - return v21 + tmp19 := tmp18.Get() + tmp20 := lang.Apply(tmp16, []any{tmp19, v3, v4, v5, v6, v7}) + tmp21 := lang.Apply(tmp10, []any{tmp13, tmp20}) + return tmp21 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // max { - var v1 lang.FnFunc - v1 = lang.NewFnFunc(func(args ...any) any { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v2 := args[0] _ = v2 - var v3 any + var tmp3 any { // let // let binding "op" - var v4 any - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - if lang.IsTruthy(v7) { - v4 = closed14 + var tmp4 any + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + if lang.IsTruthy(tmp7) { + tmp4 = closed14 } else { - v4 = closed14 + tmp4 = closed14 } - var v8 any = v4 + var v8 any = tmp4 _ = v8 - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("seq")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("concat")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("list")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("list")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("list")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("seq")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) - } - v28 := v27.Get() - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("concat")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("list")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{v8}) - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("list")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.Apply(v38, []any{v2}) - v40 := lang.Apply(v31, []any{v35, v39}) - v41 := lang.Apply(v28, []any{v40}) - v42 := lang.Apply(v25, []any{v41}) - v43 := lang.Apply(v14, []any{v18, v22, v42}) - v44 := lang.Apply(v11, []any{v43}) - v3 = v44 + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("seq")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("concat")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol(".")}) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("seq")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) + } + tmp28 := tmp27.Get() + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("concat")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.Apply(tmp34, []any{v8}) + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{v2}) + tmp40 := lang.Apply(tmp31, []any{tmp35, tmp39}) + tmp41 := lang.Apply(tmp28, []any{tmp40}) + tmp42 := lang.Apply(tmp25, []any{tmp41}) + tmp43 := lang.Apply(tmp14, []any{tmp18, tmp22, tmp42}) + tmp44 := lang.Apply(tmp11, []any{tmp43}) + tmp3 = tmp44 } // end let - return v3 + return tmp3 case 2: v2 := args[0] _ = v2 v3 := args[1] _ = v3 - var v4 any + var tmp4 any { // let // let binding "op" - var v5 any - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - if lang.IsTruthy(v8) { - v5 = closed14 + var tmp5 any + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + if lang.IsTruthy(tmp8) { + tmp5 = closed14 } else { - v5 = closed14 + tmp5 = closed14 } - var v9 any = v5 + var v9 any = tmp5 _ = v9 - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("seq")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("concat")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("list")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("list")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("list")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("seq")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("concat")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) - } - v32 := v31.Get() - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("list")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - v36 := lang.Apply(v35, []any{v9}) - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("list")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.Apply(v39, []any{v2}) - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("list")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) - } - v43 := v42.Get() - v44 := lang.Apply(v43, []any{v3}) - v45 := lang.Apply(v32, []any{v36, v40, v44}) - v46 := lang.Apply(v29, []any{v45}) - v47 := lang.Apply(v26, []any{v46}) - v48 := lang.Apply(v15, []any{v19, v23, v47}) - v49 := lang.Apply(v12, []any{v48}) - v4 = v49 + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("seq")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("concat")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("list")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{lang.NewSymbol(".")}) + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("list")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.Apply(tmp22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("list")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("seq")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("concat")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) + } + tmp32 := tmp31.Get() + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("list")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) + } + tmp35 := tmp34.Get() + tmp36 := lang.Apply(tmp35, []any{v9}) + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("list")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.Apply(tmp39, []any{v2}) + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("list")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := lang.Apply(tmp43, []any{v3}) + tmp45 := lang.Apply(tmp32, []any{tmp36, tmp40, tmp44}) + tmp46 := lang.Apply(tmp29, []any{tmp45}) + tmp47 := lang.Apply(tmp26, []any{tmp46}) + tmp48 := lang.Apply(tmp15, []any{tmp19, tmp23, tmp47}) + tmp49 := lang.Apply(tmp12, []any{tmp48}) + tmp4 = tmp49 } // end let - return v4 + return tmp4 default: if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -53114,32 +53219,33 @@ func init() { _ = v2 v3 := args[1] _ = v3 - v4 := lang.NewList(args[2:]...) - var v5 any + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any { // let // let binding "op" - var v6 any - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - if lang.IsTruthy(v9) { - v6 = closed14 + var tmp6 any + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + if lang.IsTruthy(tmp9) { + tmp6 = closed14 } else { - v6 = closed14 + tmp6 = closed14 } - var v10 any = v6 + var v10 any = tmp6 _ = v10 - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - var v14 lang.FnFunc - v14 = lang.NewFnFunc(func(args ...any) any { + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -53147,178 +53253,178 @@ func init() { _ = v15 v16 := args[1] _ = v16 - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("seq")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("concat")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("list")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("seq")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) - } - v36 := v35.Get() - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("concat")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("list")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) - } - v42 := v41.Get() - v43 := lang.Apply(v42, []any{v10}) - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("list")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) - } - v46 := v45.Get() - v47 := lang.Apply(v46, []any{v15}) - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("list")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v16}) - v52 := lang.Apply(v39, []any{v43, v47, v51}) - v53 := lang.Apply(v36, []any{v52}) - v54 := lang.Apply(v33, []any{v53}) - v55 := lang.Apply(v22, []any{v26, v30, v54}) - v56 := lang.Apply(v19, []any{v55}) - return v56 + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("concat")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol(".")}) + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) + } + tmp42 := tmp41.Get() + tmp43 := lang.Apply(tmp42, []any{v10}) + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) + } + tmp46 := tmp45.Get() + tmp47 := lang.Apply(tmp46, []any{v15}) + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v16}) + tmp52 := lang.Apply(tmp39, []any{tmp43, tmp47, tmp51}) + tmp53 := lang.Apply(tmp36, []any{tmp52}) + tmp54 := lang.Apply(tmp33, []any{tmp53}) + tmp55 := lang.Apply(tmp22, []any{tmp26, tmp30, tmp54}) + tmp56 := lang.Apply(tmp19, []any{tmp55}) + return tmp56 }) - v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) - v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) + tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) if err != nil { panic(err) } - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("seq")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("concat")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("list")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("seq")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) - } - v36 := v35.Get() - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("concat")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("list")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) - } - v42 := v41.Get() - v43 := lang.Apply(v42, []any{v10}) - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("list")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) - } - v46 := v45.Get() - v47 := lang.Apply(v46, []any{v2}) - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("list")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v3}) - v52 := lang.Apply(v39, []any{v43, v47, v51}) - v53 := lang.Apply(v36, []any{v52}) - v54 := lang.Apply(v33, []any{v53}) - v55 := lang.Apply(v22, []any{v26, v30, v54}) - v56 := lang.Apply(v19, []any{v55}) - v57 := lang.Apply(v13, []any{v16, v56, v4}) - v5 = v57 + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("concat")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol(".")}) + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) + } + tmp42 := tmp41.Get() + tmp43 := lang.Apply(tmp42, []any{v10}) + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) + } + tmp46 := tmp45.Get() + tmp47 := lang.Apply(tmp46, []any{v2}) + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v3}) + tmp52 := lang.Apply(tmp39, []any{tmp43, tmp47, tmp51}) + tmp53 := lang.Apply(tmp36, []any{tmp52}) + tmp54 := lang.Apply(tmp33, []any{tmp53}) + tmp55 := lang.Apply(tmp22, []any{tmp26, tmp30, tmp54}) + tmp56 := lang.Apply(tmp19, []any{tmp55}) + tmp57 := lang.Apply(tmp13, []any{tmp16, tmp56, v4}) + tmp5 = tmp57 } // end let - return v5 + return tmp5 } }) - v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp1 = tmp1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") - if reflect.TypeOf(v4).Kind() != reflect.Func { + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - v5 := lang.Apply(v4, []any{nil, int64(1)}) - return v5 + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v0 := lang.NewSymbol("max").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the greatest of the nums.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1108), lang.NewKeyword("end-line"), int(1108))).(*lang.Symbol) - var v4 lang.FnFunc - v4 = lang.NewFnFunc(func(args ...any) any { + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp0 := lang.NewSymbol("max").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the greatest of the nums.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), tmp2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1108), lang.NewKeyword("end-line"), int(1108))).(*lang.Symbol) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v5 := args[0] @@ -53329,12 +53435,12 @@ func init() { _ = v5 v6 := args[1] _ = v6 - v7, _ := lang.FieldOrMethod(lang.Numbers, "Max") - if reflect.TypeOf(v7).Kind() != reflect.Func { + tmp7, _ := lang.FieldOrMethod(lang.Numbers, "Max") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Max is not a function"))) } - v8 := lang.Apply(v7, []any{v5, v6}) - return v8 + tmp8 := lang.Apply(tmp7, []any{v5, v6}) + return tmp8 default: if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -53343,41 +53449,42 @@ func init() { _ = v5 v6 := args[1] _ = v6 - v7 := lang.NewList(args[2:]...) - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + var v7 any = lang.NewList(args[2:]...) + _ = v7 + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("max")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("max")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) } - v13 := v12.Get() - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("max")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + tmp13 := tmp12.Get() + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("max")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{v5, v6}) - v18 := lang.Apply(v10, []any{v13, v17, v7}) - return v18 + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{v5, v6}) + tmp18 := lang.Apply(tmp10, []any{tmp13, tmp17, v7}) + return tmp18 } }) - v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v3 := ns.InternWithValue(v0, v4, true) - if v0.Meta() != nil { - v3.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 := ns.InternWithValue(tmp0, tmp4, true) + if tmp0.Meta() != nil { + tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // max-key { - v0 := lang.NewSymbol("max-key").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Returns the x for which (k x), a number, is greatest.\n\n If there are multiple such xs, the last one is returned.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5013), lang.NewKeyword("end-line"), int(5013))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("max-key").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Returns the x for which (k x), a number, is greatest.\n\n If there are multiple such xs, the last one is returned.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5013), lang.NewKeyword("end-line"), int(5013))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 2: v3 := args[0] @@ -53392,22 +53499,22 @@ func init() { _ = v4 v5 := args[2] _ = v5 - var v6 any - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol(">")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v3, []any{v4}) - v11 := lang.Apply(v3, []any{v5}) - v12 := lang.Apply(v9, []any{v10, v11}) - if lang.IsTruthy(v12) { - v6 = v4 + var tmp6 any + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol(">")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(v3, []any{v4}) + tmp11 := lang.Apply(v3, []any{v5}) + tmp12 := lang.Apply(tmp9, []any{tmp10, tmp11}) + if lang.IsTruthy(tmp12) { + tmp6 = v4 } else { - v6 = v5 + tmp6 = v5 } - return v6 + return tmp6 default: if len(args) < 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -53418,66 +53525,67 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - var v7 any + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any { // let // let binding "kx" - v8 := lang.Apply(v3, []any{v4}) - var v9 any = v8 + tmp8 := lang.Apply(v3, []any{v4}) + var v9 any = tmp8 _ = v9 // let binding "ky" - v10 := lang.Apply(v3, []any{v5}) - var v11 any = v10 + tmp10 := lang.Apply(v3, []any{v5}) + var v11 any = tmp10 _ = v11 // let binding "vec__55" - var v12 any - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol(">")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{v9, v11}) - if lang.IsTruthy(v16) { - v17 := lang.NewVector(v4, v9) - v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5023), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(5023), lang.NewKeyword("end-column"), int(36)) - v19, err := lang.WithMeta(v17, v18.(lang.IPersistentMap)) + var tmp12 any + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol(">")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{v9, v11}) + if lang.IsTruthy(tmp16) { + tmp17 := lang.NewVector(v4, v9) + tmp18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5023), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(5023), lang.NewKeyword("end-column"), int(36)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) if err != nil { panic(err) } - v12 = v19 + tmp12 = tmp19 } else { - v20 := lang.NewVector(v5, v11) - v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5023), lang.NewKeyword("column"), int(38), lang.NewKeyword("end-line"), int(5023), lang.NewKeyword("end-column"), int(43)) - v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) + tmp20 := lang.NewVector(v5, v11) + tmp21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5023), lang.NewKeyword("column"), int(38), lang.NewKeyword("end-line"), int(5023), lang.NewKeyword("end-column"), int(43)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) if err != nil { panic(err) } - v12 = v22 + tmp12 = tmp22 } - var v23 any = v12 + var v23 any = tmp12 _ = v23 // let binding "v" - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("nth")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.Apply(v26, []any{v23, int64(0), nil}) - var v28 any = v27 + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("nth")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.Apply(tmp26, []any{v23, int64(0), nil}) + var v28 any = tmp27 _ = v28 // let binding "kv" - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("nth")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.Apply(v31, []any{v23, int64(1), nil}) - var v33 any = v32 + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("nth")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.Apply(tmp31, []any{v23, int64(1), nil}) + var v33 any = tmp32 _ = v33 - var v34 any + var tmp34 any { // let // let binding "v" var v35 any = v28 @@ -53489,105 +53597,105 @@ func init() { var v37 any = v6 _ = v37 for { - var v38 any + var tmp38 any if lang.IsTruthy(v37) { - var v39 any + var tmp39 any { // let // let binding "w" - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("first")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("first")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) } - v42 := v41.Get() - v43 := lang.Apply(v42, []any{v37}) - var v44 any = v43 + tmp42 := tmp41.Get() + tmp43 := lang.Apply(tmp42, []any{v37}) + var v44 any = tmp43 _ = v44 // let binding "kw" - v45 := lang.Apply(v3, []any{v44}) - var v46 any = v45 + tmp45 := lang.Apply(v3, []any{v44}) + var v46 any = tmp45 _ = v46 - var v47 any - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol(">=")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + var tmp47 any + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol(">=")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v46, v36}) - if lang.IsTruthy(v51) { - var v52 any = v44 - var v53 any = v46 - v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v56 := v55.FindInternedVar(lang.NewSymbol("next")) - if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v46, v36}) + if lang.IsTruthy(tmp51) { + var tmp52 any = v44 + var tmp53 any = v46 + tmp55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp56 := tmp55.FindInternedVar(lang.NewSymbol("next")) + if tmp56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp56))) } - v57 := v56.Get() - v58 := lang.Apply(v57, []any{v37}) - var v54 any = v58 - v35 = v52 - v36 = v53 - v37 = v54 + tmp57 := tmp56.Get() + tmp58 := lang.Apply(tmp57, []any{v37}) + var tmp54 any = tmp58 + v35 = tmp52 + v36 = tmp53 + v37 = tmp54 continue } else { - var v59 any = v35 - var v60 any = v36 - v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v63 := v62.FindInternedVar(lang.NewSymbol("next")) - if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) + var tmp59 any = v35 + var tmp60 any = v36 + tmp62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp63 := tmp62.FindInternedVar(lang.NewSymbol("next")) + if tmp63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp63))) } - v64 := v63.Get() - v65 := lang.Apply(v64, []any{v37}) - var v61 any = v65 - v35 = v59 - v36 = v60 - v37 = v61 + tmp64 := tmp63.Get() + tmp65 := lang.Apply(tmp64, []any{v37}) + var tmp61 any = tmp65 + v35 = tmp59 + v36 = tmp60 + v37 = tmp61 continue } - v39 = v47 + tmp39 = tmp47 } // end let - v38 = v39 + tmp38 = tmp39 } else { - v38 = v35 + tmp38 = v35 } - v34 = v38 + tmp34 = tmp38 break } } // end let - v7 = v34 + tmp7 = tmp34 } // end let - return v7 + return tmp7 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // max-mask-bits { - v0 := lang.NewSymbol("max-mask-bits").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6601), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(6601), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - v1 := ns.InternWithValue(v0, int64(13), true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp0 := lang.NewSymbol("max-mask-bits").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6601), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(6601), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, int64(13), true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // max-switch-table-size { - v0 := lang.NewSymbol("max-switch-table-size").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6602), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(6602), lang.NewKeyword("end-column"), int(36), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - v1 := ns.InternWithValue(v0, int64(8192), true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp0 := lang.NewSymbol("max-switch-table-size").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6602), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(6602), lang.NewKeyword("end-column"), int(36), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, int64(8192), true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // maybe-destructured { - v0 := lang.NewSymbol("maybe-destructured").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4514), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(4515), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("params"), lang.NewSymbol("body"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("maybe-destructured").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4514), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(4515), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("params"), lang.NewSymbol("body"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -53595,809 +53703,809 @@ func init() { _ = v3 v4 := args[1] _ = v4 - var v5 any - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("every?")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("symbol?")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.Apply(v8, []any{v11, v3}) - if lang.IsTruthy(v12) { - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("cons")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{v3, v4}) - v5 = v16 + var tmp5 any + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("every?")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("symbol?")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.Apply(tmp8, []any{tmp11, v3}) + if lang.IsTruthy(tmp12) { + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("cons")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{v3, v4}) + tmp5 = tmp16 } else { - var v17 any + var tmp17 any { // let // let binding "params" var v18 any = v3 _ = v18 // let binding "new-params" - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("with-meta")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.NewVector() - v23 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4520), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(4520), lang.NewKeyword("end-column"), int(35)) - v24, err := lang.WithMeta(v22, v23.(lang.IPersistentMap)) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("with-meta")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.NewVector() + tmp23 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4520), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(4520), lang.NewKeyword("end-column"), int(35)) + tmp24, err := lang.WithMeta(tmp22, tmp23.(lang.IPersistentMap)) if err != nil { panic(err) } - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("meta")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("meta")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) } - v27 := v26.Get() - v28 := lang.Apply(v27, []any{v18}) - v29 := lang.Apply(v21, []any{v24, v28}) - var v30 any = v29 + tmp27 := tmp26.Get() + tmp28 := lang.Apply(tmp27, []any{v18}) + tmp29 := lang.Apply(tmp21, []any{tmp24, tmp28}) + var v30 any = tmp29 _ = v30 // let binding "lets" - v31 := lang.NewVector() - v32 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4521), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(4521), lang.NewKeyword("end-column"), int(18)) - v33, err := lang.WithMeta(v31, v32.(lang.IPersistentMap)) + tmp31 := lang.NewVector() + tmp32 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4521), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(4521), lang.NewKeyword("end-column"), int(18)) + tmp33, err := lang.WithMeta(tmp31, tmp32.(lang.IPersistentMap)) if err != nil { panic(err) } - var v34 any = v33 + var v34 any = tmp33 _ = v34 for { - var v35 any + var tmp35 any if lang.IsTruthy(v18) { - var v36 any - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("symbol?")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("first")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) - } - v42 := v41.Get() - v43 := lang.Apply(v42, []any{v18}) - v44 := lang.Apply(v39, []any{v43}) - if lang.IsTruthy(v44) { - v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v47 := v46.FindInternedVar(lang.NewSymbol("next")) - if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) + var tmp36 any + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("symbol?")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("first")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) + } + tmp42 := tmp41.Get() + tmp43 := lang.Apply(tmp42, []any{v18}) + tmp44 := lang.Apply(tmp39, []any{tmp43}) + if lang.IsTruthy(tmp44) { + tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp47 := tmp46.FindInternedVar(lang.NewSymbol("next")) + if tmp47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) } - v48 := v47.Get() - v49 := lang.Apply(v48, []any{v18}) - var v45 any = v49 - v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v52 := v51.FindInternedVar(lang.NewSymbol("conj")) - if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) + tmp48 := tmp47.Get() + tmp49 := lang.Apply(tmp48, []any{v18}) + var tmp45 any = tmp49 + tmp51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp52 := tmp51.FindInternedVar(lang.NewSymbol("conj")) + if tmp52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp52))) } - v53 := v52.Get() - v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v55 := v54.FindInternedVar(lang.NewSymbol("first")) - if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) + tmp53 := tmp52.Get() + tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp55 := tmp54.FindInternedVar(lang.NewSymbol("first")) + if tmp55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) } - v56 := v55.Get() - v57 := lang.Apply(v56, []any{v18}) - v58 := lang.Apply(v53, []any{v30, v57}) - var v50 any = v58 - var v59 any = v34 - v18 = v45 - v30 = v50 - v34 = v59 + tmp56 := tmp55.Get() + tmp57 := lang.Apply(tmp56, []any{v18}) + tmp58 := lang.Apply(tmp53, []any{v30, tmp57}) + var tmp50 any = tmp58 + var tmp59 any = v34 + v18 = tmp45 + v30 = tmp50 + v34 = tmp59 continue } else { - var v60 any + var tmp60 any { // let // let binding "gparam" - v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v62 := v61.FindInternedVar(lang.NewSymbol("gensym")) - if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) + tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp62 := tmp61.FindInternedVar(lang.NewSymbol("gensym")) + if tmp62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) } - v63 := v62.Get() - v64 := lang.Apply(v63, []any{"p__"}) - var v65 any = v64 + tmp63 := tmp62.Get() + tmp64 := lang.Apply(tmp63, []any{"p__"}) + var v65 any = tmp64 _ = v65 - v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v68 := v67.FindInternedVar(lang.NewSymbol("next")) - if v68.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) + tmp67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp68 := tmp67.FindInternedVar(lang.NewSymbol("next")) + if tmp68.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp68))) } - v69 := v68.Get() - v70 := lang.Apply(v69, []any{v18}) - var v66 any = v70 - v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v73 := v72.FindInternedVar(lang.NewSymbol("conj")) - if v73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) + tmp69 := tmp68.Get() + tmp70 := lang.Apply(tmp69, []any{v18}) + var tmp66 any = tmp70 + tmp72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp73 := tmp72.FindInternedVar(lang.NewSymbol("conj")) + if tmp73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp73))) } - v74 := v73.Get() - v75 := lang.Apply(v74, []any{v30, v65}) - var v71 any = v75 - v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v78 := v77.FindInternedVar(lang.NewSymbol("conj")) - if v78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) + tmp74 := tmp73.Get() + tmp75 := lang.Apply(tmp74, []any{v30, v65}) + var tmp71 any = tmp75 + tmp77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp78 := tmp77.FindInternedVar(lang.NewSymbol("conj")) + if tmp78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp78))) } - v79 := v78.Get() - v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v81 := v80.FindInternedVar(lang.NewSymbol("conj")) - if v81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) + tmp79 := tmp78.Get() + tmp80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp81 := tmp80.FindInternedVar(lang.NewSymbol("conj")) + if tmp81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp81))) } - v82 := v81.Get() - v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v84 := v83.FindInternedVar(lang.NewSymbol("first")) - if v84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) + tmp82 := tmp81.Get() + tmp83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp84 := tmp83.FindInternedVar(lang.NewSymbol("first")) + if tmp84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp84))) } - v85 := v84.Get() - v86 := lang.Apply(v85, []any{v18}) - v87 := lang.Apply(v82, []any{v34, v86}) - v88 := lang.Apply(v79, []any{v87, v65}) - var v76 any = v88 - v18 = v66 - v30 = v71 - v34 = v76 + tmp85 := tmp84.Get() + tmp86 := lang.Apply(tmp85, []any{v18}) + tmp87 := lang.Apply(tmp82, []any{v34, tmp86}) + tmp88 := lang.Apply(tmp79, []any{tmp87, v65}) + var tmp76 any = tmp88 + v18 = tmp66 + v30 = tmp71 + v34 = tmp76 continue } // end let - v36 = v60 + tmp36 = tmp60 } - v35 = v36 + tmp35 = tmp36 } else { - v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v62 := v61.FindInternedVar(lang.NewSymbol("seq")) - if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) - } - v63 := v62.Get() - v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v65 := v64.FindInternedVar(lang.NewSymbol("concat")) - if v65.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) - } - v66 := v65.Get() - v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v68 := v67.FindInternedVar(lang.NewSymbol("list")) - if v68.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) - } - v69 := v68.Get() - v70 := lang.Apply(v69, []any{v30}) - v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v72 := v71.FindInternedVar(lang.NewSymbol("list")) - if v72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) - } - v73 := v72.Get() - v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v75 := v74.FindInternedVar(lang.NewSymbol("seq")) - if v75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) - } - v76 := v75.Get() - v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v78 := v77.FindInternedVar(lang.NewSymbol("concat")) - if v78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) - } - v79 := v78.Get() - v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v81 := v80.FindInternedVar(lang.NewSymbol("list")) - if v81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) - } - v82 := v81.Get() - v83 := lang.Apply(v82, []any{lang.NewSymbol("glojure.core/let")}) - v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v85 := v84.FindInternedVar(lang.NewSymbol("list")) - if v85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) - } - v86 := v85.Get() - v87 := lang.Apply(v86, []any{v34}) - v88 := lang.Apply(v79, []any{v83, v87, v4}) - v89 := lang.Apply(v76, []any{v88}) - v90 := lang.Apply(v73, []any{v89}) - v91 := lang.Apply(v66, []any{v70, v90}) - v92 := lang.Apply(v63, []any{v91}) - v35 = v92 - } - v17 = v35 + tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp62 := tmp61.FindInternedVar(lang.NewSymbol("seq")) + if tmp62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) + } + tmp63 := tmp62.Get() + tmp64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp65 := tmp64.FindInternedVar(lang.NewSymbol("concat")) + if tmp65.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp65))) + } + tmp66 := tmp65.Get() + tmp67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp68 := tmp67.FindInternedVar(lang.NewSymbol("list")) + if tmp68.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp68))) + } + tmp69 := tmp68.Get() + tmp70 := lang.Apply(tmp69, []any{v30}) + tmp71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp72 := tmp71.FindInternedVar(lang.NewSymbol("list")) + if tmp72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp72))) + } + tmp73 := tmp72.Get() + tmp74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp75 := tmp74.FindInternedVar(lang.NewSymbol("seq")) + if tmp75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp75))) + } + tmp76 := tmp75.Get() + tmp77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp78 := tmp77.FindInternedVar(lang.NewSymbol("concat")) + if tmp78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp78))) + } + tmp79 := tmp78.Get() + tmp80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp81 := tmp80.FindInternedVar(lang.NewSymbol("list")) + if tmp81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp81))) + } + tmp82 := tmp81.Get() + tmp83 := lang.Apply(tmp82, []any{lang.NewSymbol("glojure.core/let")}) + tmp84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp85 := tmp84.FindInternedVar(lang.NewSymbol("list")) + if tmp85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp85))) + } + tmp86 := tmp85.Get() + tmp87 := lang.Apply(tmp86, []any{v34}) + tmp88 := lang.Apply(tmp79, []any{tmp83, tmp87, v4}) + tmp89 := lang.Apply(tmp76, []any{tmp88}) + tmp90 := lang.Apply(tmp73, []any{tmp89}) + tmp91 := lang.Apply(tmp66, []any{tmp70, tmp90}) + tmp92 := lang.Apply(tmp63, []any{tmp91}) + tmp35 = tmp92 + } + tmp17 = tmp35 break } } // end let - v5 = v17 + tmp5 = tmp17 } - return v5 + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // maybe-min-hash { - v0 := lang.NewSymbol("maybe-min-hash").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("hashes"))), lang.NewKeyword("doc"), "takes a collection of hashes and returns [shift mask] or nil if none found", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6604), lang.NewKeyword("end-line"), int(6604), lang.NewKeyword("private"), true)).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("maybe-min-hash").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("hashes"))), lang.NewKeyword("doc"), "takes a collection of hashes and returns [shift mask] or nil if none found", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6604), lang.NewKeyword("end-line"), int(6604), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("first")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("filter")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - var v10 lang.FnFunc - v10 = lang.NewFnFunc(func(args ...any) any { + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("first")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("filter")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v11 := args[0] _ = v11 - var v12 any + var tmp12 any { // let // let binding "vec__151" var v13 any = v11 _ = v13 // let binding "s" - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("nth")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{v13, int64(0), nil}) - var v18 any = v17 + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("nth")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{v13, int64(0), nil}) + var v18 any = tmp17 _ = v18 // let binding "m" - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("nth")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{v13, int64(1), nil}) - var v23 any = v22 + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("nth")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, []any{v13, int64(1), nil}) + var v23 any = tmp22 _ = v23 - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("apply")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("distinct?")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("map")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) - } - v32 := v31.Get() - var v33 lang.FnFunc - v33 = lang.NewFnFunc(func(args ...any) any { + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("apply")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("distinct?")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("map")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) + } + tmp32 := tmp31.Get() + var tmp33 lang.FnFunc + tmp33 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v34 := args[0] _ = v34 - v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v36 := v35.FindInternedVar(lang.NewSymbol("shift-mask")) - if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) - } - v37 := v36.Get() - v38 := lang.Apply(v37, []any{v18, v23, v34}) - return v38 + tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp36 := tmp35.FindInternedVar(lang.NewSymbol("shift-mask")) + if tmp36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) + } + tmp37 := tmp36.Get() + tmp38 := lang.Apply(tmp37, []any{v18, v23, v34}) + return tmp38 }) - v34 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6609), lang.NewKeyword("column"), int(37), lang.NewKeyword("end-line"), int(6609), lang.NewKeyword("end-column"), int(55)) - v35, err := lang.WithMeta(v33, v34.(lang.IPersistentMap)) + tmp34 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6609), lang.NewKeyword("column"), int(37), lang.NewKeyword("end-line"), int(6609), lang.NewKeyword("end-column"), int(55)) + tmp35, err := lang.WithMeta(tmp33, tmp34.(lang.IPersistentMap)) if err != nil { panic(err) } - v36 := lang.Apply(v32, []any{v35, v3}) - v37 := lang.Apply(v26, []any{v29, v36}) - v12 = v37 + tmp36 := lang.Apply(tmp32, []any{tmp35, v3}) + tmp37 := lang.Apply(tmp26, []any{tmp29, tmp36}) + tmp12 = tmp37 } // end let - return v12 + return tmp12 }) - v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6608), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(6609), lang.NewKeyword("end-column"), int(65)) - v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) + tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6608), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(6609), lang.NewKeyword("end-column"), int(65)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) if err != nil { panic(err) } - var v13 any + var tmp13 any { // let // let binding "iter__0__auto__" - var v14 lang.FnFunc + var tmp14 lang.FnFunc { // function iter__154 - v14 = lang.NewFnFunc(func(args ...any) any { + var v15 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v16 := args[0] _ = v16 - var v17 lang.FnFunc - v17 = lang.NewFnFunc(func(args ...any) any { + var tmp17 lang.FnFunc + tmp17 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - var v18 any + var tmp18 any { // let // let binding "s__155" var v19 any = v16 _ = v19 for { - var v20 any + var tmp20 any { // let // let binding "temp__0__auto__" - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("seq")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) } - v23 := v22.Get() - v24 := lang.Apply(v23, []any{v19}) - var v25 any = v24 + tmp23 := tmp22.Get() + tmp24 := lang.Apply(tmp23, []any{v19}) + var v25 any = tmp24 _ = v25 - var v26 any + var tmp26 any if lang.IsTruthy(v25) { - var v27 any + var tmp27 any { // let // let binding "xs__0__auto__" var v28 any = v25 _ = v28 - var v29 any + var tmp29 any { // let // let binding "mask" - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("first")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("first")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) } - v32 := v31.Get() - v33 := lang.Apply(v32, []any{v28}) - var v34 any = v33 + tmp32 := tmp31.Get() + tmp33 := lang.Apply(tmp32, []any{v28}) + var v34 any = tmp33 _ = v34 - var v35 any + var tmp35 any { // let // let binding "iterys__0__auto__" - var v36 lang.FnFunc + var tmp36 lang.FnFunc { // function iter__156 - v36 = lang.NewFnFunc(func(args ...any) any { + var v37 lang.FnFunc + tmp36 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v38 := args[0] _ = v38 - var v39 lang.FnFunc - v39 = lang.NewFnFunc(func(args ...any) any { + var tmp39 lang.FnFunc + tmp39 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - var v40 any + var tmp40 any { // let // let binding "s__157" var v41 any = v38 _ = v41 for { - var v42 any + var tmp42 any { // let // let binding "temp__0__auto__" - v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v44 := v43.FindInternedVar(lang.NewSymbol("seq")) - if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) + tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp44 := tmp43.FindInternedVar(lang.NewSymbol("seq")) + if tmp44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) } - v45 := v44.Get() - v46 := lang.Apply(v45, []any{v41}) - var v47 any = v46 + tmp45 := tmp44.Get() + tmp46 := lang.Apply(tmp45, []any{v41}) + var v47 any = tmp46 _ = v47 - var v48 any + var tmp48 any if lang.IsTruthy(v47) { - var v49 any + var tmp49 any { // let // let binding "s__157" var v50 any = v47 _ = v50 - var v51 any - v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v53 := v52.FindInternedVar(lang.NewSymbol("chunked-seq?")) - if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) + var tmp51 any + tmp52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp53 := tmp52.FindInternedVar(lang.NewSymbol("chunked-seq?")) + if tmp53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp53))) } - v54 := v53.Get() - v55 := lang.Apply(v54, []any{v50}) - if lang.IsTruthy(v55) { - var v56 any + tmp54 := tmp53.Get() + tmp55 := lang.Apply(tmp54, []any{v50}) + if lang.IsTruthy(tmp55) { + var tmp56 any { // let // let binding "c__0__auto__" - v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v58 := v57.FindInternedVar(lang.NewSymbol("chunk-first")) - if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) + tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp58 := tmp57.FindInternedVar(lang.NewSymbol("chunk-first")) + if tmp58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) } - v59 := v58.Get() - v60 := lang.Apply(v59, []any{v50}) - var v61 any = v60 + tmp59 := tmp58.Get() + tmp60 := lang.Apply(tmp59, []any{v50}) + var v61 any = tmp60 _ = v61 // let binding "size__1__auto__" - v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v63 := v62.FindInternedVar(lang.NewSymbol("int")) - if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) + tmp62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp63 := tmp62.FindInternedVar(lang.NewSymbol("int")) + if tmp63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp63))) } - v64 := v63.Get() - v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v66 := v65.FindInternedVar(lang.NewSymbol("count")) - if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) + tmp64 := tmp63.Get() + tmp65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp66 := tmp65.FindInternedVar(lang.NewSymbol("count")) + if tmp66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp66))) } - v67 := v66.Get() - v68 := lang.Apply(v67, []any{v61}) - v69 := lang.Apply(v64, []any{v68}) - var v70 any = v69 + tmp67 := tmp66.Get() + tmp68 := lang.Apply(tmp67, []any{v61}) + tmp69 := lang.Apply(tmp64, []any{tmp68}) + var v70 any = tmp69 _ = v70 // let binding "b__159" - v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v72 := v71.FindInternedVar(lang.NewSymbol("chunk-buffer")) - if v72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) + tmp71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp72 := tmp71.FindInternedVar(lang.NewSymbol("chunk-buffer")) + if tmp72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp72))) } - v73 := v72.Get() - v74 := lang.Apply(v73, []any{v70}) - var v75 any = v74 + tmp73 := tmp72.Get() + tmp74 := lang.Apply(tmp73, []any{v70}) + var v75 any = tmp74 _ = v75 - var v76 any - var v77 any + var tmp76 any + var tmp77 any { // let // let binding "i__158" - v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v79 := v78.FindInternedVar(lang.NewSymbol("int")) - if v79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) + tmp78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp79 := tmp78.FindInternedVar(lang.NewSymbol("int")) + if tmp79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp79))) } - v80 := v79.Get() - v81 := lang.Apply(v80, []any{int64(0)}) - var v82 any = v81 + tmp80 := tmp79.Get() + tmp81 := lang.Apply(tmp80, []any{int64(0)}) + var v82 any = tmp81 _ = v82 for { - var v83 any - v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v85 := v84.FindInternedVar(lang.NewSymbol("<")) - if v85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) + var tmp83 any + tmp84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp85 := tmp84.FindInternedVar(lang.NewSymbol("<")) + if tmp85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp85))) } - v86 := v85.Get() - v87 := lang.Apply(v86, []any{v82, v70}) - if lang.IsTruthy(v87) { - var v88 any + tmp86 := tmp85.Get() + tmp87 := lang.Apply(tmp86, []any{v82, v70}) + if lang.IsTruthy(tmp87) { + var tmp88 any { // let // let binding "shift" - v89, _ := lang.FieldOrMethod(v61, "nth") - if reflect.TypeOf(v89).Kind() != reflect.Func { + tmp89, _ := lang.FieldOrMethod(v61, "nth") + if reflect.TypeOf(tmp89).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) } - v90 := lang.Apply(v89, []any{v82}) - var v91 any = v90 + tmp90 := lang.Apply(tmp89, []any{v82}) + var v91 any = tmp90 _ = v91 - v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v93 := v92.FindInternedVar(lang.NewSymbol("chunk-append")) - if v93.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) + tmp92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp93 := tmp92.FindInternedVar(lang.NewSymbol("chunk-append")) + if tmp93.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp93))) } - v94 := v93.Get() - v95 := lang.NewVector(v91, v34) - v96 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6612), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(6612), lang.NewKeyword("end-column"), int(26)) - v97, err := lang.WithMeta(v95, v96.(lang.IPersistentMap)) + tmp94 := tmp93.Get() + tmp95 := lang.NewVector(v91, v34) + tmp96 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6612), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(6612), lang.NewKeyword("end-column"), int(26)) + tmp97, err := lang.WithMeta(tmp95, tmp96.(lang.IPersistentMap)) if err != nil { panic(err) } - v98 := lang.Apply(v94, []any{v75, v97}) - _ = v98 - v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v101 := v100.FindInternedVar(lang.NewSymbol("unchecked-inc")) - if v101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) + tmp98 := lang.Apply(tmp94, []any{v75, tmp97}) + _ = tmp98 + tmp100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp101 := tmp100.FindInternedVar(lang.NewSymbol("unchecked-inc")) + if tmp101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp101))) } - v102 := v101.Get() - v103 := lang.Apply(v102, []any{v82}) - var v99 any = v103 - v82 = v99 + tmp102 := tmp101.Get() + tmp103 := lang.Apply(tmp102, []any{v82}) + var tmp99 any = tmp103 + v82 = tmp99 continue } // end let - v83 = v88 + tmp83 = tmp88 } else { - v83 = true + tmp83 = true } - v77 = v83 + tmp77 = tmp83 break } } // end let - if lang.IsTruthy(v77) { - v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v79 := v78.FindInternedVar(lang.NewSymbol("chunk-cons")) - if v79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) + if lang.IsTruthy(tmp77) { + tmp78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp79 := tmp78.FindInternedVar(lang.NewSymbol("chunk-cons")) + if tmp79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp79))) } - v80 := v79.Get() - v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v82 := v81.FindInternedVar(lang.NewSymbol("chunk")) - if v82.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) + tmp80 := tmp79.Get() + tmp81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp82 := tmp81.FindInternedVar(lang.NewSymbol("chunk")) + if tmp82.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp82))) } - v83 := v82.Get() - v84 := lang.Apply(v83, []any{v75}) - v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v86 := v85.FindInternedVar(lang.NewSymbol("chunk-rest")) - if v86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) + tmp83 := tmp82.Get() + tmp84 := lang.Apply(tmp83, []any{v75}) + tmp85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp86 := tmp85.FindInternedVar(lang.NewSymbol("chunk-rest")) + if tmp86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp86))) } - v87 := v86.Get() - v88 := lang.Apply(v87, []any{v50}) - v89 := lang.Apply(v37, []any{v88}) - v90 := lang.Apply(v80, []any{v84, v89}) - v76 = v90 + tmp87 := tmp86.Get() + tmp88 := lang.Apply(tmp87, []any{v50}) + tmp89 := lang.Apply(v37, []any{tmp88}) + tmp90 := lang.Apply(tmp80, []any{tmp84, tmp89}) + tmp76 = tmp90 } else { - v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v92 := v91.FindInternedVar(lang.NewSymbol("chunk-cons")) - if v92.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) + tmp91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp92 := tmp91.FindInternedVar(lang.NewSymbol("chunk-cons")) + if tmp92.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp92))) } - v93 := v92.Get() - v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v95 := v94.FindInternedVar(lang.NewSymbol("chunk")) - if v95.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) + tmp93 := tmp92.Get() + tmp94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp95 := tmp94.FindInternedVar(lang.NewSymbol("chunk")) + if tmp95.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp95))) } - v96 := v95.Get() - v97 := lang.Apply(v96, []any{v75}) - v98 := lang.Apply(v93, []any{v97, nil}) - v76 = v98 + tmp96 := tmp95.Get() + tmp97 := lang.Apply(tmp96, []any{v75}) + tmp98 := lang.Apply(tmp93, []any{tmp97, nil}) + tmp76 = tmp98 } - v56 = v76 + tmp56 = tmp76 } // end let - v51 = v56 + tmp51 = tmp56 } else { - var v57 any + var tmp57 any { // let // let binding "shift" - v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v59 := v58.FindInternedVar(lang.NewSymbol("first")) - if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) + tmp58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp59 := tmp58.FindInternedVar(lang.NewSymbol("first")) + if tmp59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp59))) } - v60 := v59.Get() - v61 := lang.Apply(v60, []any{v50}) - var v62 any = v61 + tmp60 := tmp59.Get() + tmp61 := lang.Apply(tmp60, []any{v50}) + var v62 any = tmp61 _ = v62 - v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v64 := v63.FindInternedVar(lang.NewSymbol("cons")) - if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) + tmp63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp64 := tmp63.FindInternedVar(lang.NewSymbol("cons")) + if tmp64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp64))) } - v65 := v64.Get() - v66 := lang.NewVector(v62, v34) - v67 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6612), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(6612), lang.NewKeyword("end-column"), int(26)) - v68, err := lang.WithMeta(v66, v67.(lang.IPersistentMap)) + tmp65 := tmp64.Get() + tmp66 := lang.NewVector(v62, v34) + tmp67 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6612), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(6612), lang.NewKeyword("end-column"), int(26)) + tmp68, err := lang.WithMeta(tmp66, tmp67.(lang.IPersistentMap)) if err != nil { panic(err) } - v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v70 := v69.FindInternedVar(lang.NewSymbol("rest")) - if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) + tmp69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp70 := tmp69.FindInternedVar(lang.NewSymbol("rest")) + if tmp70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp70))) } - v71 := v70.Get() - v72 := lang.Apply(v71, []any{v50}) - v73 := lang.Apply(v37, []any{v72}) - v74 := lang.Apply(v65, []any{v68, v73}) - v57 = v74 + tmp71 := tmp70.Get() + tmp72 := lang.Apply(tmp71, []any{v50}) + tmp73 := lang.Apply(v37, []any{tmp72}) + tmp74 := lang.Apply(tmp65, []any{tmp68, tmp73}) + tmp57 = tmp74 } // end let - v51 = v57 + tmp51 = tmp57 } - v49 = v51 + tmp49 = tmp51 } // end let - v48 = v49 + tmp48 = tmp49 } else { - v48 = nil } - v42 = v48 + tmp42 = tmp48 } // end let - v40 = v42 + tmp40 = tmp42 break } } // end let - return v40 + return tmp40 }) - v40 := lang.Apply(lang.NewLazySeq, []any{v39}) - return v40 + tmp40 := lang.Apply(lang.NewLazySeq, []any{tmp39}) + return tmp40 }) - v37 := v36 + v37 = tmp36 _ = v37 } - var v37 any = v36 + var v37 any = tmp36 _ = v37 // let binding "fs__1__auto__" - v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v39 := v38.FindInternedVar(lang.NewSymbol("seq")) - if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp39 := tmp38.FindInternedVar(lang.NewSymbol("seq")) + if tmp39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) } - v40 := v39.Get() - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("range")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + tmp40 := tmp39.Get() + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("range")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) } - v43 := v42.Get() - v44 := lang.Apply(v43, []any{int64(0), int64(31)}) - v45 := lang.Apply(v37, []any{v44}) - v46 := lang.Apply(v40, []any{v45}) - var v47 any = v46 + tmp43 := tmp42.Get() + tmp44 := lang.Apply(tmp43, []any{int64(0), int64(31)}) + tmp45 := lang.Apply(v37, []any{tmp44}) + tmp46 := lang.Apply(tmp40, []any{tmp45}) + var v47 any = tmp46 _ = v47 - var v48 any + var tmp48 any if lang.IsTruthy(v47) { - v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v50 := v49.FindInternedVar(lang.NewSymbol("concat")) - if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) + tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp50 := tmp49.FindInternedVar(lang.NewSymbol("concat")) + if tmp50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) } - v51 := v50.Get() - v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v53 := v52.FindInternedVar(lang.NewSymbol("rest")) - if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) + tmp51 := tmp50.Get() + tmp52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp53 := tmp52.FindInternedVar(lang.NewSymbol("rest")) + if tmp53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp53))) } - v54 := v53.Get() - v55 := lang.Apply(v54, []any{v19}) - v56 := lang.Apply(v15, []any{v55}) - v57 := lang.Apply(v51, []any{v47, v56}) - v48 = v57 + tmp54 := tmp53.Get() + tmp55 := lang.Apply(tmp54, []any{v19}) + tmp56 := lang.Apply(v15, []any{tmp55}) + tmp57 := lang.Apply(tmp51, []any{v47, tmp56}) + tmp48 = tmp57 } else { - v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v60 := v59.FindInternedVar(lang.NewSymbol("rest")) - if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) + tmp59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp60 := tmp59.FindInternedVar(lang.NewSymbol("rest")) + if tmp60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp60))) } - v61 := v60.Get() - v62 := lang.Apply(v61, []any{v19}) - var v58 any = v62 - v19 = v58 + tmp61 := tmp60.Get() + tmp62 := lang.Apply(tmp61, []any{v19}) + var tmp58 any = tmp62 + v19 = tmp58 continue } - v35 = v48 + tmp35 = tmp48 } // end let - v29 = v35 + tmp29 = tmp35 } // end let - v27 = v29 + tmp27 = tmp29 } // end let - v26 = v27 + tmp26 = tmp27 } else { - v26 = nil } - v20 = v26 + tmp20 = tmp26 } // end let - v18 = v20 + tmp18 = tmp20 break } } // end let - return v18 + return tmp18 }) - v18 := lang.Apply(lang.NewLazySeq, []any{v17}) - return v18 + tmp18 := lang.Apply(lang.NewLazySeq, []any{tmp17}) + return tmp18 }) - v15 := v14 + v15 = tmp14 _ = v15 } - var v15 any = v14 + var v15 any = tmp14 _ = v15 - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("map")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - var v19 lang.FnFunc - v19 = lang.NewFnFunc(func(args ...any) any { + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("map")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + var tmp19 lang.FnFunc + tmp19 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v20 := args[0] _ = v20 - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("dec")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("bit-shift-left")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.Apply(v26, []any{int64(1), v20}) - v28 := lang.Apply(v23, []any{v27}) - return v28 + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("dec")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("bit-shift-left")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.Apply(tmp26, []any{int64(1), v20}) + tmp28 := lang.Apply(tmp23, []any{tmp27}) + return tmp28 }) - v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6610), lang.NewKeyword("column"), int(29), lang.NewKeyword("end-line"), int(6610), lang.NewKeyword("end-column"), int(55)) - v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) + tmp20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6610), lang.NewKeyword("column"), int(29), lang.NewKeyword("end-line"), int(6610), lang.NewKeyword("end-column"), int(55)) + tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) if err != nil { panic(err) } - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("range")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("inc")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("max-mask-bits")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.Apply(v27, []any{v30}) - v32 := lang.Apply(v24, []any{int64(1), v31}) - v33 := lang.Apply(v18, []any{v21, v32}) - v34 := lang.Apply(v15, []any{v33}) - v13 = v34 + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("range")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("inc")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("max-mask-bits")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.Apply(tmp27, []any{tmp30}) + tmp32 := lang.Apply(tmp24, []any{int64(1), tmp31}) + tmp33 := lang.Apply(tmp18, []any{tmp21, tmp32}) + tmp34 := lang.Apply(v15, []any{tmp33}) + tmp13 = tmp34 } // end let - v14 := lang.Apply(v9, []any{v12, v13}) - v15 := lang.Apply(v6, []any{v14}) - return v15 + tmp14 := lang.Apply(tmp9, []any{tmp12, tmp13}) + tmp15 := lang.Apply(tmp6, []any{tmp14}) + return tmp15 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // memfn { - v0 := lang.NewSymbol("memfn").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Expands into code that creates a fn that expects to be passed an\n object and any args and calls the named instance method on the\n object passing the args. Use when you want to treat a Java method as\n a first-class fn. name may be type-hinted with the method receiver's\n type in order to avoid reflective calls.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3872), lang.NewKeyword("end-line"), int(3872))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("memfn").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Expands into code that creates a fn that expects to be passed an\n object and any args and calls the named instance method on the\n object passing the args. Use when you want to treat a Java method as\n a first-class fn. name may be type-hinted with the method receiver's\n type in order to avoid reflective calls.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3872), lang.NewKeyword("end-line"), int(3872))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 3 { @@ -54409,326 +54517,329 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - var v7 any + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any { // let // let binding "t" - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("with-meta")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("gensym")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{"target"}) - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("meta")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{v5}) - v19 := lang.Apply(v10, []any{v14, v18}) - var v20 any = v19 + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("with-meta")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("gensym")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{"target"}) + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("meta")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{v5}) + tmp19 := lang.Apply(tmp10, []any{tmp14, tmp18}) + var v20 any = tmp19 _ = v20 - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("seq")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("concat")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/fn")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("apply")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) - } - v36 := v35.Get() - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("vector")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("seq")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) - } - v42 := v41.Get() - v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v44 := v43.FindInternedVar(lang.NewSymbol("concat")) - if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) - } - v45 := v44.Get() - v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v47 := v46.FindInternedVar(lang.NewSymbol("list")) - if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) - } - v48 := v47.Get() - v49 := lang.Apply(v48, []any{v20}) - v50 := lang.Apply(v45, []any{v49, v6}) - v51 := lang.Apply(v42, []any{v50}) - v52 := lang.Apply(v36, []any{v39, v51}) - v53 := lang.Apply(v33, []any{v52}) - v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v55 := v54.FindInternedVar(lang.NewSymbol("list")) - if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) - } - v56 := v55.Get() - v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v58 := v57.FindInternedVar(lang.NewSymbol("seq")) - if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) - } - v59 := v58.Get() - v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v61 := v60.FindInternedVar(lang.NewSymbol("concat")) - if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) - } - v62 := v61.Get() - v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v64 := v63.FindInternedVar(lang.NewSymbol("list")) - if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) - } - v65 := v64.Get() - v66 := lang.Apply(v65, []any{lang.NewSymbol(".")}) - v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v68 := v67.FindInternedVar(lang.NewSymbol("list")) - if v68.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) - } - v69 := v68.Get() - v70 := lang.Apply(v69, []any{v20}) - v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v72 := v71.FindInternedVar(lang.NewSymbol("list")) - if v72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) - } - v73 := v72.Get() - v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v75 := v74.FindInternedVar(lang.NewSymbol("seq")) - if v75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) - } - v76 := v75.Get() - v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v78 := v77.FindInternedVar(lang.NewSymbol("concat")) - if v78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) - } - v79 := v78.Get() - v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v81 := v80.FindInternedVar(lang.NewSymbol("list")) - if v81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) - } - v82 := v81.Get() - v83 := lang.Apply(v82, []any{v5}) - v84 := lang.Apply(v79, []any{v83, v6}) - v85 := lang.Apply(v76, []any{v84}) - v86 := lang.Apply(v73, []any{v85}) - v87 := lang.Apply(v62, []any{v66, v70, v86}) - v88 := lang.Apply(v59, []any{v87}) - v89 := lang.Apply(v56, []any{v88}) - v90 := lang.Apply(v26, []any{v30, v53, v89}) - v91 := lang.Apply(v23, []any{v90}) - v7 = v91 + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/fn")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("apply")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("vector")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("seq")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) + } + tmp42 := tmp41.Get() + tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp44 := tmp43.FindInternedVar(lang.NewSymbol("concat")) + if tmp44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) + } + tmp45 := tmp44.Get() + tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp47 := tmp46.FindInternedVar(lang.NewSymbol("list")) + if tmp47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) + } + tmp48 := tmp47.Get() + tmp49 := lang.Apply(tmp48, []any{v20}) + tmp50 := lang.Apply(tmp45, []any{tmp49, v6}) + tmp51 := lang.Apply(tmp42, []any{tmp50}) + tmp52 := lang.Apply(tmp36, []any{tmp39, tmp51}) + tmp53 := lang.Apply(tmp33, []any{tmp52}) + tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp55 := tmp54.FindInternedVar(lang.NewSymbol("list")) + if tmp55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) + } + tmp56 := tmp55.Get() + tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp58 := tmp57.FindInternedVar(lang.NewSymbol("seq")) + if tmp58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) + } + tmp59 := tmp58.Get() + tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp61 := tmp60.FindInternedVar(lang.NewSymbol("concat")) + if tmp61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) + } + tmp62 := tmp61.Get() + tmp63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp64 := tmp63.FindInternedVar(lang.NewSymbol("list")) + if tmp64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp64))) + } + tmp65 := tmp64.Get() + tmp66 := lang.Apply(tmp65, []any{lang.NewSymbol(".")}) + tmp67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp68 := tmp67.FindInternedVar(lang.NewSymbol("list")) + if tmp68.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp68))) + } + tmp69 := tmp68.Get() + tmp70 := lang.Apply(tmp69, []any{v20}) + tmp71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp72 := tmp71.FindInternedVar(lang.NewSymbol("list")) + if tmp72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp72))) + } + tmp73 := tmp72.Get() + tmp74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp75 := tmp74.FindInternedVar(lang.NewSymbol("seq")) + if tmp75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp75))) + } + tmp76 := tmp75.Get() + tmp77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp78 := tmp77.FindInternedVar(lang.NewSymbol("concat")) + if tmp78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp78))) + } + tmp79 := tmp78.Get() + tmp80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp81 := tmp80.FindInternedVar(lang.NewSymbol("list")) + if tmp81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp81))) + } + tmp82 := tmp81.Get() + tmp83 := lang.Apply(tmp82, []any{v5}) + tmp84 := lang.Apply(tmp79, []any{tmp83, v6}) + tmp85 := lang.Apply(tmp76, []any{tmp84}) + tmp86 := lang.Apply(tmp73, []any{tmp85}) + tmp87 := lang.Apply(tmp62, []any{tmp66, tmp70, tmp86}) + tmp88 := lang.Apply(tmp59, []any{tmp87}) + tmp89 := lang.Apply(tmp56, []any{tmp88}) + tmp90 := lang.Apply(tmp26, []any{tmp30, tmp53, tmp89}) + tmp91 := lang.Apply(tmp23, []any{tmp90}) + tmp7 = tmp91 } // end let - return v7 + return tmp7 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // memoize { - v0 := lang.NewSymbol("memoize").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Returns a memoized version of a referentially transparent function. The\n memoized version of the function keeps a cache of the mapping from arguments\n to results and, when calls with the same arguments are repeated often, has\n higher performance at the expense of higher memory use.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6337), lang.NewKeyword("end-line"), int(6337))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("memoize").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Returns a memoized version of a referentially transparent function. The\n memoized version of the function keeps a cache of the mapping from arguments\n to results and, when calls with the same arguments are repeated often, has\n higher performance at the expense of higher memory use.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6337), lang.NewKeyword("end-line"), int(6337))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any + var tmp4 any { // let // let binding "mem" - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("atom")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.NewMap() - v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6345), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(6345), lang.NewKeyword("end-column"), int(20)) - v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("atom")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.NewMap() + tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6345), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(6345), lang.NewKeyword("end-column"), int(20)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) if err != nil { panic(err) } - v11 := lang.Apply(v7, []any{v10}) - var v12 any = v11 + tmp11 := lang.Apply(tmp7, []any{tmp10}) + var v12 any = tmp11 _ = v12 - var v13 lang.FnFunc - v13 = lang.NewFnFunc(func(args ...any) any { + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v14 := lang.NewList(args[0:]...) - var v15 any + var v14 any = lang.NewList(args[0:]...) + _ = v14 + var tmp15 any { // let // let binding "temp__0__auto__" - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("find")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("deref")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{v12}) - v23 := lang.Apply(v18, []any{v22, v14}) - var v24 any = v23 + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("find")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("deref")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, []any{v12}) + tmp23 := lang.Apply(tmp18, []any{tmp22, v14}) + var v24 any = tmp23 _ = v24 - var v25 any + var tmp25 any if lang.IsTruthy(v24) { - var v26 any + var tmp26 any { // let // let binding "e" var v27 any = v24 _ = v27 - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("val")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("val")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) } - v30 := v29.Get() - v31 := lang.Apply(v30, []any{v27}) - v26 = v31 + tmp30 := tmp29.Get() + tmp31 := lang.Apply(tmp30, []any{v27}) + tmp26 = tmp31 } // end let - v25 = v26 + tmp25 = tmp26 } else { - var v27 any + var tmp27 any { // let // let binding "ret" - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("apply")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("apply")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) } - v30 := v29.Get() - v31 := lang.Apply(v30, []any{v3, v14}) - var v32 any = v31 + tmp30 := tmp29.Get() + tmp31 := lang.Apply(tmp30, []any{v3, v14}) + var v32 any = tmp31 _ = v32 - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("swap!")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("swap!")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) } - v35 := v34.Get() - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("assoc")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + tmp35 := tmp34.Get() + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("assoc")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) } - v38 := v37.Get() - v39 := lang.Apply(v35, []any{v12, v38, v14, v32}) - _ = v39 - v27 = v32 + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp35, []any{v12, tmp38, v14, v32}) + _ = tmp39 + tmp27 = v32 } // end let - v25 = v27 + tmp25 = tmp27 } - v15 = v25 + tmp15 = tmp25 } // end let - return v15 + return tmp15 } }) - v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6346), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(6351), lang.NewKeyword("end-column"), int(16)) - v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) + tmp14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6346), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(6351), lang.NewKeyword("end-column"), int(16)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) if err != nil { panic(err) } - v4 = v15 + tmp4 = tmp15 } // end let - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // merge { - v0 := lang.NewSymbol("merge").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("maps"))), lang.NewKeyword("doc"), "Returns a map that consists of the rest of the maps conj-ed onto\n the first. If a key occurs in more than one map, the mapping from\n the latter (left-to-right) will be the mapping in the result.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3040), lang.NewKeyword("end-line"), int(3040))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("merge").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("maps"))), lang.NewKeyword("doc"), "Returns a map that consists of the rest of the maps conj-ed onto\n the first. If a key occurs in more than one map, the mapping from\n the latter (left-to-right) will be the mapping in the result.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3040), lang.NewKeyword("end-line"), int(3040))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v3 := lang.NewList(args[0:]...) - var v4 any - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("some")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("identity")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v7, []any{v10, v3}) - if lang.IsTruthy(v11) { - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("reduce1")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - var v15 lang.FnFunc - v15 = lang.NewFnFunc(func(args ...any) any { + var v3 any = lang.NewList(args[0:]...) + _ = v3 + var tmp4 any + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("some")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("identity")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp7, []any{tmp10, v3}) + if lang.IsTruthy(tmp11) { + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + var tmp15 lang.FnFunc + tmp15 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -54736,58 +54847,57 @@ func init() { _ = v16 v17 := args[1] _ = v17 - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("conj")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("conj")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) } - v20 := v19.Get() - var v21 any + tmp20 := tmp19.Get() + var tmp21 any { // let // let binding "or__0__auto__" var v22 any = v16 _ = v22 - var v23 any + var tmp23 any if lang.IsTruthy(v22) { - v23 = v22 + tmp23 = v22 } else { - v24 := lang.NewMap() - v25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3048), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(3048), lang.NewKeyword("end-column"), int(29)) - v26, err := lang.WithMeta(v24, v25.(lang.IPersistentMap)) + tmp24 := lang.NewMap() + tmp25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3048), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(3048), lang.NewKeyword("end-column"), int(29)) + tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) if err != nil { panic(err) } - v23 = v26 + tmp23 = tmp26 } - v21 = v23 + tmp21 = tmp23 } // end let - v22 := lang.Apply(v20, []any{v21, v17}) - return v22 + tmp22 := lang.Apply(tmp20, []any{tmp21, v17}) + return tmp22 }) - v16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3048), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(3048), lang.NewKeyword("end-column"), int(34)) - v17, err := lang.WithMeta(v15, v16.(lang.IPersistentMap)) + tmp16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3048), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(3048), lang.NewKeyword("end-column"), int(34)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) if err != nil { panic(err) } - v18 := lang.Apply(v14, []any{v17, v3}) - v4 = v18 + tmp18 := lang.Apply(tmp14, []any{tmp17, v3}) + tmp4 = tmp18 } else { - v4 = nil } - return v4 + return tmp4 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // merge-hash-collisions { - v0 := lang.NewSymbol("merge-hash-collisions").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr-sym"), lang.NewSymbol("default"), lang.NewSymbol("tests"), lang.NewSymbol("thens"))), lang.NewKeyword("doc"), "Takes a case expression, default expression, and a sequence of test constants\n and a corresponding sequence of then expressions. Returns a tuple of\n [tests thens skip-check-set] where no tests have the same hash. Each set of\n input test constants with the same hash is replaced with a single test\n constant (the case int), and their respective thens are combined into:\n (condp = expr\n test-1 then-1\n ...\n test-n then-n\n default).\n The skip-check is a set of case ints for which post-switch equivalence\n checking must not be done (the cases holding the above condp thens).", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6647), lang.NewKeyword("end-line"), int(6647), lang.NewKeyword("private"), true)).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("merge-hash-collisions").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr-sym"), lang.NewSymbol("default"), lang.NewSymbol("tests"), lang.NewSymbol("thens"))), lang.NewKeyword("doc"), "Takes a case expression, default expression, and a sequence of test constants\n and a corresponding sequence of then expressions. Returns a tuple of\n [tests thens skip-check-set] where no tests have the same hash. Each set of\n input test constants with the same hash is replaced with a single test\n constant (the case int), and their respective thens are combined into:\n (condp = expr\n test-1 then-1\n ...\n test-n then-n\n default).\n The skip-check is a set of case ints for which post-switch equivalence\n checking must not be done (the cases holding the above condp thens).", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6647), lang.NewKeyword("end-line"), int(6647), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 4 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -54799,19 +54909,19 @@ func init() { _ = v5 v6 := args[3] _ = v6 - var v7 any + var tmp7 any { // let // let binding "buckets" - var v8 any + var tmp8 any { // let // let binding "m" - v9 := lang.NewMap() - v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6661), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(6661), lang.NewKeyword("end-column"), int(27)) - v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) + tmp9 := lang.NewMap() + tmp10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6661), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(6661), lang.NewKeyword("end-column"), int(27)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) if err != nil { panic(err) } - var v12 any = v11 + var v12 any = tmp11 _ = v12 // let binding "ks" var v13 any = v5 @@ -54820,108 +54930,108 @@ func init() { var v14 any = v6 _ = v14 for { - var v15 any - var v16 any + var tmp15 any + var tmp16 any { // let // let binding "and__0__auto__" var v17 any = v13 _ = v17 - var v18 any + var tmp18 any if lang.IsTruthy(v17) { - v18 = v14 + tmp18 = v14 } else { - v18 = v17 + tmp18 = v17 } - v16 = v18 + tmp16 = tmp18 } // end let - if lang.IsTruthy(v16) { - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("update")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("first")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.Apply(v23, []any{v13}) - v25 := lang.Apply(lang.Hash, []any{v24}) - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("fnil")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) - } - v28 := v27.Get() - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("conj")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.NewVector() - v33 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6664), lang.NewKeyword("column"), int(102), lang.NewKeyword("end-line"), int(6664), lang.NewKeyword("end-column"), int(103)) - v34, err := lang.WithMeta(v32, v33.(lang.IPersistentMap)) + if lang.IsTruthy(tmp16) { + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("update")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("first")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.Apply(tmp23, []any{v13}) + tmp25 := lang.Apply(lang.Hash, []any{tmp24}) + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("fnil")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) + } + tmp28 := tmp27.Get() + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("conj")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.NewVector() + tmp33 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6664), lang.NewKeyword("column"), int(102), lang.NewKeyword("end-line"), int(6664), lang.NewKeyword("end-column"), int(103)) + tmp34, err := lang.WithMeta(tmp32, tmp33.(lang.IPersistentMap)) if err != nil { panic(err) } - v35 := lang.Apply(v28, []any{v31, v34}) - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("first")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.Apply(v38, []any{v13}) - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("first")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) - } - v42 := v41.Get() - v43 := lang.Apply(v42, []any{v14}) - v44 := lang.NewVector(v39, v43) - v45 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6664), lang.NewKeyword("column"), int(106), lang.NewKeyword("end-line"), int(6664), lang.NewKeyword("end-column"), int(128)) - v46, err := lang.WithMeta(v44, v45.(lang.IPersistentMap)) + tmp35 := lang.Apply(tmp28, []any{tmp31, tmp34}) + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("first")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{v13}) + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("first")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) + } + tmp42 := tmp41.Get() + tmp43 := lang.Apply(tmp42, []any{v14}) + tmp44 := lang.NewVector(tmp39, tmp43) + tmp45 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6664), lang.NewKeyword("column"), int(106), lang.NewKeyword("end-line"), int(6664), lang.NewKeyword("end-column"), int(128)) + tmp46, err := lang.WithMeta(tmp44, tmp45.(lang.IPersistentMap)) if err != nil { panic(err) } - v47 := lang.Apply(v20, []any{v12, v25, v35, v46}) - var v17 any = v47 - v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v50 := v49.FindInternedVar(lang.NewSymbol("next")) - if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) - } - v51 := v50.Get() - v52 := lang.Apply(v51, []any{v13}) - var v48 any = v52 - v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v55 := v54.FindInternedVar(lang.NewSymbol("next")) - if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) - } - v56 := v55.Get() - v57 := lang.Apply(v56, []any{v14}) - var v53 any = v57 - v12 = v17 - v13 = v48 - v14 = v53 + tmp47 := lang.Apply(tmp20, []any{v12, tmp25, tmp35, tmp46}) + var tmp17 any = tmp47 + tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp50 := tmp49.FindInternedVar(lang.NewSymbol("next")) + if tmp50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) + } + tmp51 := tmp50.Get() + tmp52 := lang.Apply(tmp51, []any{v13}) + var tmp48 any = tmp52 + tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp55 := tmp54.FindInternedVar(lang.NewSymbol("next")) + if tmp55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) + } + tmp56 := tmp55.Get() + tmp57 := lang.Apply(tmp56, []any{v14}) + var tmp53 any = tmp57 + v12 = tmp17 + v13 = tmp48 + v14 = tmp53 continue } else { - v15 = v12 + tmp15 = v12 } - v8 = v15 + tmp8 = tmp15 break } } // end let - var v9 any = v8 + var v9 any = tmp8 _ = v9 // let binding "assoc-multi" - var v10 lang.FnFunc - v10 = lang.NewFnFunc(func(args ...any) any { + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { if len(args) != 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -54931,131 +55041,131 @@ func init() { _ = v12 v13 := args[2] _ = v13 - var v14 any + var tmp14 any { // let // let binding "testexprs" - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("mapcat")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - var v18 lang.FnFunc - v18 = lang.NewFnFunc(func(args ...any) any { + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("mapcat")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + var tmp18 lang.FnFunc + tmp18 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v19 := args[0] _ = v19 - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("list")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("first")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.Apply(v25, []any{v19}) - v27 := lang.Apply(v22, []any{lang.NewSymbol("quote"), v26}) - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("second")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.Apply(v30, []any{v19}) - v32 := lang.NewVector(v27, v31) - v33 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6668), lang.NewKeyword("column"), int(56), lang.NewKeyword("end-line"), int(6668), lang.NewKeyword("end-column"), int(93)) - v34, err := lang.WithMeta(v32, v33.(lang.IPersistentMap)) + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("list")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("first")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.Apply(tmp25, []any{v19}) + tmp27 := lang.Apply(tmp22, []any{lang.NewSymbol("quote"), tmp26}) + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("second")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.Apply(tmp30, []any{v19}) + tmp32 := lang.NewVector(tmp27, tmp31) + tmp33 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6668), lang.NewKeyword("column"), int(56), lang.NewKeyword("end-line"), int(6668), lang.NewKeyword("end-column"), int(93)) + tmp34, err := lang.WithMeta(tmp32, tmp33.(lang.IPersistentMap)) if err != nil { panic(err) } - return v34 + return tmp34 }) - v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6668), lang.NewKeyword("column"), int(47), lang.NewKeyword("end-line"), int(6668), lang.NewKeyword("end-column"), int(94)) - v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) + tmp19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6668), lang.NewKeyword("column"), int(47), lang.NewKeyword("end-line"), int(6668), lang.NewKeyword("end-column"), int(94)) + tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) if err != nil { panic(err) } - v21 := lang.Apply(v17, []any{v20, v13}) - var v22 any = v21 + tmp21 := lang.Apply(tmp17, []any{tmp20, v13}) + var v22 any = tmp21 _ = v22 // let binding "expr" - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("seq")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("concat")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) - } - v28 := v27.Get() - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("list")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.Apply(v31, []any{lang.NewSymbol("glojure.core/condp")}) - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("list")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - v36 := lang.Apply(v35, []any{lang.NewSymbol("glojure.core/=")}) - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("list")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.Apply(v39, []any{v3}) - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("list")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) - } - v43 := v42.Get() - v44 := lang.Apply(v43, []any{v4}) - v45 := lang.Apply(v28, []any{v32, v36, v40, v22, v44}) - v46 := lang.Apply(v25, []any{v45}) - var v47 any = v46 + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("seq")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("concat")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) + } + tmp28 := tmp27.Get() + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("list")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.Apply(tmp31, []any{lang.NewSymbol("glojure.core/condp")}) + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("list")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) + } + tmp35 := tmp34.Get() + tmp36 := lang.Apply(tmp35, []any{lang.NewSymbol("glojure.core/=")}) + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("list")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.Apply(tmp39, []any{v3}) + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("list")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := lang.Apply(tmp43, []any{v4}) + tmp45 := lang.Apply(tmp28, []any{tmp32, tmp36, tmp40, v22, tmp44}) + tmp46 := lang.Apply(tmp25, []any{tmp45}) + var v47 any = tmp46 _ = v47 - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("assoc")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v11, v12, v47}) - v14 = v51 + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("assoc")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v11, v12, v47}) + tmp14 = tmp51 } // end let - return v14 + return tmp14 }) - v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6667), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(6670), lang.NewKeyword("end-column"), int(42)) - v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) + tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6667), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(6670), lang.NewKeyword("end-column"), int(42)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) if err != nil { panic(err) } - var v13 any = v12 + var v13 any = tmp12 _ = v13 // let binding "hmap" - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("reduce1")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - var v17 lang.FnFunc - v17 = lang.NewFnFunc(func(args ...any) any { + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + var tmp17 lang.FnFunc + tmp17 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -55063,204 +55173,204 @@ func init() { _ = v18 v19 := args[1] _ = v19 - var v20 any + var tmp20 any { // let // let binding "vec__164" var v21 any = v19 _ = v21 // let binding "h" - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("nth")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v21, int64(0), nil}) - var v26 any = v25 + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("nth")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.Apply(tmp24, []any{v21, int64(0), nil}) + var v26 any = tmp25 _ = v26 // let binding "bucket" - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("nth")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{v21, int64(1), nil}) - var v31 any = v30 + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("nth")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{v21, int64(1), nil}) + var v31 any = tmp30 _ = v31 - var v32 any - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("==")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("count")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.Apply(v38, []any{v31}) - v40 := lang.Apply(v35, []any{int64(1), v39}) - if lang.IsTruthy(v40) { - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("assoc")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) - } - v43 := v42.Get() - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("ffirst")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) - } - v46 := v45.Get() - v47 := lang.Apply(v46, []any{v31}) - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("second")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v52 := v51.FindInternedVar(lang.NewSymbol("first")) - if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) - } - v53 := v52.Get() - v54 := lang.Apply(v53, []any{v31}) - v55 := lang.Apply(v50, []any{v54}) - v56 := lang.Apply(v43, []any{v18, v47, v55}) - v32 = v56 + var tmp32 any + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("==")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) + } + tmp35 := tmp34.Get() + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("count")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{v31}) + tmp40 := lang.Apply(tmp35, []any{int64(1), tmp39}) + if lang.IsTruthy(tmp40) { + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("assoc")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("ffirst")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) + } + tmp46 := tmp45.Get() + tmp47 := lang.Apply(tmp46, []any{v31}) + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("second")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp52 := tmp51.FindInternedVar(lang.NewSymbol("first")) + if tmp52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp52))) + } + tmp53 := tmp52.Get() + tmp54 := lang.Apply(tmp53, []any{v31}) + tmp55 := lang.Apply(tmp50, []any{tmp54}) + tmp56 := lang.Apply(tmp43, []any{v18, tmp47, tmp55}) + tmp32 = tmp56 } else { - v57 := lang.Apply(v13, []any{v18, v26, v31}) - v32 = v57 + tmp57 := lang.Apply(v13, []any{v18, v26, v31}) + tmp32 = tmp57 } - v20 = v32 + tmp20 = tmp32 } // end let - return v20 + return tmp20 }) - v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6672), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(6675), lang.NewKeyword("end-column"), int(45)) - v19, err := lang.WithMeta(v17, v18.(lang.IPersistentMap)) + tmp18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6672), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(6675), lang.NewKeyword("end-column"), int(45)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) if err != nil { panic(err) } - v20 := lang.NewMap() - v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6676), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(6676), lang.NewKeyword("end-column"), int(17)) - v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) + tmp20 := lang.NewMap() + tmp21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6676), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(6676), lang.NewKeyword("end-column"), int(17)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) if err != nil { panic(err) } - v23 := lang.Apply(v16, []any{v19, v22, v9}) - var v24 any = v23 + tmp23 := lang.Apply(tmp16, []any{tmp19, tmp22, v9}) + var v24 any = tmp23 _ = v24 // let binding "skip-check" - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("into1")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.CreatePersistentTreeSet() - v29 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6680), lang.NewKeyword("column"), int(29), lang.NewKeyword("end-line"), int(6680), lang.NewKeyword("end-column"), int(31)) - v30, err := lang.WithMeta(v28, v29.(lang.IPersistentMap)) + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("into1")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp29 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6680), lang.NewKeyword("column"), int(29), lang.NewKeyword("end-line"), int(6680), lang.NewKeyword("end-column"), int(31)) + tmp30, err := lang.WithMeta(tmp28, tmp29.(lang.IPersistentMap)) if err != nil { panic(err) } - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("map")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("first")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) - } - v36 := v35.Get() - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("filter")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - var v40 lang.FnFunc - v40 = lang.NewFnFunc(func(args ...any) any { + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("map")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("first")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("filter")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + var tmp40 lang.FnFunc + tmp40 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v41 := args[0] _ = v41 - v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v43 := v42.FindInternedVar(lang.NewSymbol("<")) - if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) - } - v44 := v43.Get() - v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v46 := v45.FindInternedVar(lang.NewSymbol("count")) - if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) - } - v47 := v46.Get() - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("second")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v41}) - v52 := lang.Apply(v47, []any{v51}) - v53 := lang.Apply(v44, []any{int64(1), v52}) - return v53 + tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp43 := tmp42.FindInternedVar(lang.NewSymbol("<")) + if tmp43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) + } + tmp44 := tmp43.Get() + tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp46 := tmp45.FindInternedVar(lang.NewSymbol("count")) + if tmp46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) + } + tmp47 := tmp46.Get() + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("second")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v41}) + tmp52 := lang.Apply(tmp47, []any{tmp51}) + tmp53 := lang.Apply(tmp44, []any{int64(1), tmp52}) + return tmp53 }) - v41 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6678), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(6678), lang.NewKeyword("end-column"), int(54)) - v42, err := lang.WithMeta(v40, v41.(lang.IPersistentMap)) + tmp41 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6678), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(6678), lang.NewKeyword("end-column"), int(54)) + tmp42, err := lang.WithMeta(tmp40, tmp41.(lang.IPersistentMap)) if err != nil { panic(err) } - v43 := lang.Apply(v39, []any{v42, v9}) - v44 := lang.Apply(v33, []any{v36, v43}) - v45 := lang.Apply(v27, []any{v30, v44}) - var v46 any = v45 + tmp43 := lang.Apply(tmp39, []any{tmp42, v9}) + tmp44 := lang.Apply(tmp33, []any{tmp36, tmp43}) + tmp45 := lang.Apply(tmp27, []any{tmp30, tmp44}) + var v46 any = tmp45 _ = v46 - v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v48 := v47.FindInternedVar(lang.NewSymbol("keys")) - if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) - } - v49 := v48.Get() - v50 := lang.Apply(v49, []any{v24}) - v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v52 := v51.FindInternedVar(lang.NewSymbol("vals")) - if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) - } - v53 := v52.Get() - v54 := lang.Apply(v53, []any{v24}) - v55 := lang.NewVector(v50, v54, v46) - v56 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6681), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(6681), lang.NewKeyword("end-column"), int(40)) - v57, err := lang.WithMeta(v55, v56.(lang.IPersistentMap)) + tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp48 := tmp47.FindInternedVar(lang.NewSymbol("keys")) + if tmp48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) + } + tmp49 := tmp48.Get() + tmp50 := lang.Apply(tmp49, []any{v24}) + tmp51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp52 := tmp51.FindInternedVar(lang.NewSymbol("vals")) + if tmp52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp52))) + } + tmp53 := tmp52.Get() + tmp54 := lang.Apply(tmp53, []any{v24}) + tmp55 := lang.NewVector(tmp50, tmp54, v46) + tmp56 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6681), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(6681), lang.NewKeyword("end-column"), int(40)) + tmp57, err := lang.WithMeta(tmp55, tmp56.(lang.IPersistentMap)) if err != nil { panic(err) } - v7 = v57 + tmp7 = tmp57 } // end let - return v7 + return tmp7 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // merge-with { - v0 := lang.NewSymbol("merge-with").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("maps"))), lang.NewKeyword("doc"), "Returns a map that consists of the rest of the maps conj-ed onto\n the first. If a key occurs in more than one map, the mapping(s)\n from the latter (left-to-right) will be combined with the mapping in\n the result by calling (f val-in-result val-in-latter).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3050), lang.NewKeyword("end-line"), int(3050))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("merge-with").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("maps"))), lang.NewKeyword("doc"), "Returns a map that consists of the rest of the maps conj-ed onto\n the first. If a key occurs in more than one map, the mapping(s)\n from the latter (left-to-right) will be combined with the mapping in\n the result by calling (f val-in-result val-in-latter).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3050), lang.NewKeyword("end-line"), int(3050))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 1 { @@ -55268,27 +55378,28 @@ func init() { } v3 := args[0] _ = v3 - v4 := lang.NewList(args[1:]...) - var v5 any - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("some")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("identity")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.Apply(v8, []any{v11, v4}) - if lang.IsTruthy(v12) { - var v13 any + var v4 any = lang.NewList(args[1:]...) + _ = v4 + var tmp5 any + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("some")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("identity")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.Apply(tmp8, []any{tmp11, v4}) + if lang.IsTruthy(tmp12) { + var tmp13 any { // let // let binding "merge-entry" - var v14 lang.FnFunc - v14 = lang.NewFnFunc(func(args ...any) any { + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -55296,77 +55407,77 @@ func init() { _ = v15 v16 := args[1] _ = v16 - var v17 any + var tmp17 any { // let // let binding "k" - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("key")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("key")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) } - v20 := v19.Get() - v21 := lang.Apply(v20, []any{v16}) - var v22 any = v21 + tmp20 := tmp19.Get() + tmp21 := lang.Apply(tmp20, []any{v16}) + var v22 any = tmp21 _ = v22 // let binding "v" - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("val")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("val")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) } - v25 := v24.Get() - v26 := lang.Apply(v25, []any{v16}) - var v27 any = v26 + tmp25 := tmp24.Get() + tmp26 := lang.Apply(tmp25, []any{v16}) + var v27 any = tmp26 _ = v27 - var v28 any - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("contains?")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + var tmp28 any + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("contains?")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) } - v31 := v30.Get() - v32 := lang.Apply(v31, []any{v15, v22}) - if lang.IsTruthy(v32) { - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("assoc")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + tmp31 := tmp30.Get() + tmp32 := lang.Apply(tmp31, []any{v15, v22}) + if lang.IsTruthy(tmp32) { + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("assoc")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) } - v35 := v34.Get() - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("get")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + tmp35 := tmp34.Get() + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("get")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) } - v38 := v37.Get() - v39 := lang.Apply(v38, []any{v15, v22}) - v40 := lang.Apply(v3, []any{v39, v27}) - v41 := lang.Apply(v35, []any{v15, v22, v40}) - v28 = v41 + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{v15, v22}) + tmp40 := lang.Apply(v3, []any{tmp39, v27}) + tmp41 := lang.Apply(tmp35, []any{v15, v22, tmp40}) + tmp28 = tmp41 } else { - v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v43 := v42.FindInternedVar(lang.NewSymbol("assoc")) - if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) + tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp43 := tmp42.FindInternedVar(lang.NewSymbol("assoc")) + if tmp43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) } - v44 := v43.Get() - v45 := lang.Apply(v44, []any{v15, v22, v27}) - v28 = v45 + tmp44 := tmp43.Get() + tmp45 := lang.Apply(tmp44, []any{v15, v22, v27}) + tmp28 = tmp45 } - v17 = v28 + tmp17 = tmp28 } // end let - return v17 + return tmp17 }) - v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3059), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(3063), lang.NewKeyword("end-column"), int(23)) - v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) + tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3059), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(3063), lang.NewKeyword("end-column"), int(23)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) if err != nil { panic(err) } - var v17 any = v16 + var v17 any = tmp16 _ = v17 // let binding "merge2" - var v18 lang.FnFunc - v18 = lang.NewFnFunc(func(args ...any) any { + var tmp18 lang.FnFunc + tmp18 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -55374,331 +55485,331 @@ func init() { _ = v19 v20 := args[1] _ = v20 - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("reduce1")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) } - v23 := v22.Get() - var v24 any + tmp23 := tmp22.Get() + var tmp24 any { // let // let binding "or__0__auto__" var v25 any = v19 _ = v25 - var v26 any + var tmp26 any if lang.IsTruthy(v25) { - v26 = v25 + tmp26 = v25 } else { - v27 := lang.NewMap() - v28 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3065), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(3065), lang.NewKeyword("end-column"), int(35)) - v29, err := lang.WithMeta(v27, v28.(lang.IPersistentMap)) + tmp27 := lang.NewMap() + tmp28 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3065), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(3065), lang.NewKeyword("end-column"), int(35)) + tmp29, err := lang.WithMeta(tmp27, tmp28.(lang.IPersistentMap)) if err != nil { panic(err) } - v26 = v29 + tmp26 = tmp29 } - v24 = v26 + tmp24 = tmp26 } // end let - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("seq")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.Apply(v27, []any{v20}) - v29 := lang.Apply(v23, []any{v17, v24, v28}) - return v29 + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("seq")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.Apply(tmp27, []any{v20}) + tmp29 := lang.Apply(tmp23, []any{v17, tmp24, tmp28}) + return tmp29 }) - v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3064), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(3065), lang.NewKeyword("end-column"), int(47)) - v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) + tmp19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3064), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(3065), lang.NewKeyword("end-column"), int(47)) + tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) if err != nil { panic(err) } - var v21 any = v20 + var v21 any = tmp20 _ = v21 - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("reduce1")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v21, v4}) - v13 = v25 + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.Apply(tmp24, []any{v21, v4}) + tmp13 = tmp25 } // end let - v5 = v13 + tmp5 = tmp13 } else { - v5 = nil } - return v5 + return tmp5 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // meta { - v0 := lang.NewSymbol("meta").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("obj"))), lang.NewKeyword("doc"), "Returns the metadata of obj, returns nil if there is no metadata.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(202), lang.NewKeyword("end-line"), int(206))).(*lang.Symbol) - var v2 lang.FnFunc + tmp0 := lang.NewSymbol("meta").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("obj"))), lang.NewKeyword("doc"), "Returns the metadata of obj, returns nil if there is no metadata.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(202), lang.NewKeyword("end-line"), int(206))).(*lang.Symbol) + var tmp2 lang.FnFunc { // function meta - v2 = lang.NewFnFunc(func(args ...any) any { + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - var v5 any - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{lang.IMeta, v4}) - if lang.IsTruthy(v9) { - v10, ok := lang.FieldOrMethod(v4, "Meta") + var tmp5 any + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("instance?")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := reflect.TypeOf((*lang.IMeta)(nil)).Elem() + tmp10 := lang.Apply(tmp8, []any{tmp9, v4}) + if lang.IsTruthy(tmp10) { + tmp11, ok := lang.FieldOrMethod(v4, "Meta") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "Meta"))) } - var v11 any - switch reflect.TypeOf(v10).Kind() { + var tmp12 any + switch reflect.TypeOf(tmp11).Kind() { case reflect.Func: - v11 = lang.Apply(v10, nil) + tmp12 = lang.Apply(tmp11, nil) default: - v11 = v10 + tmp12 = tmp11 } - v5 = v11 + tmp5 = tmp12 } else { - v5 = nil } - return v5 + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(206), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(208), lang.NewKeyword("end-column"), int(21))).(lang.FnFunc) - v3 := v2 + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(206), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(208), lang.NewKeyword("end-column"), int(21))).(lang.FnFunc) + v3 = tmp2 _ = v3 } - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // methods { - v0 := lang.NewSymbol("methods").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"))), lang.NewKeyword("doc"), "Given a multimethod, returns a map of dispatch values -> dispatch fns", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1809), lang.NewKeyword("end-line"), int(1809))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("methods").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"))), lang.NewKeyword("doc"), "Given a multimethod, returns a map of dispatch values -> dispatch fns", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1809), lang.NewKeyword("end-line"), int(1809))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4, ok := lang.FieldOrMethod(v3, "getMethodTable") + tmp4, ok := lang.FieldOrMethod(v3, "getMethodTable") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getMethodTable"))) } - var v5 any - switch reflect.TypeOf(v4).Kind() { + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { case reflect.Func: - v5 = lang.Apply(v4, nil) + tmp5 = lang.Apply(tmp4, nil) default: - v5 = v4 + tmp5 = tmp4 } - return v5 + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // min { - var v1 lang.FnFunc - v1 = lang.NewFnFunc(func(args ...any) any { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v2 := args[0] _ = v2 - var v3 any + var tmp3 any { // let // let binding "op" - var v4 any - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - if lang.IsTruthy(v7) { - v4 = closed15 + var tmp4 any + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + if lang.IsTruthy(tmp7) { + tmp4 = closed15 } else { - v4 = closed15 + tmp4 = closed15 } - var v8 any = v4 + var v8 any = tmp4 _ = v8 - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("seq")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("concat")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("list")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{lang.NewSymbol(".")}) - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("list")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("list")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("seq")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) - } - v28 := v27.Get() - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("concat")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("list")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{v8}) - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("list")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.Apply(v38, []any{v2}) - v40 := lang.Apply(v31, []any{v35, v39}) - v41 := lang.Apply(v28, []any{v40}) - v42 := lang.Apply(v25, []any{v41}) - v43 := lang.Apply(v14, []any{v18, v22, v42}) - v44 := lang.Apply(v11, []any{v43}) - v3 = v44 + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("seq")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("concat")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol(".")}) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("seq")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) + } + tmp28 := tmp27.Get() + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("concat")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.Apply(tmp34, []any{v8}) + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{v2}) + tmp40 := lang.Apply(tmp31, []any{tmp35, tmp39}) + tmp41 := lang.Apply(tmp28, []any{tmp40}) + tmp42 := lang.Apply(tmp25, []any{tmp41}) + tmp43 := lang.Apply(tmp14, []any{tmp18, tmp22, tmp42}) + tmp44 := lang.Apply(tmp11, []any{tmp43}) + tmp3 = tmp44 } // end let - return v3 + return tmp3 case 2: v2 := args[0] _ = v2 v3 := args[1] _ = v3 - var v4 any + var tmp4 any { // let // let binding "op" - var v5 any - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - if lang.IsTruthy(v8) { - v5 = closed15 + var tmp5 any + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + if lang.IsTruthy(tmp8) { + tmp5 = closed15 } else { - v5 = closed15 + tmp5 = closed15 } - var v9 any = v5 + var v9 any = tmp5 _ = v9 - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("seq")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("concat")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("list")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{lang.NewSymbol(".")}) - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("list")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.Apply(v22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("list")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("seq")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("concat")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) - } - v32 := v31.Get() - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("list")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - v36 := lang.Apply(v35, []any{v9}) - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("list")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.Apply(v39, []any{v2}) - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("list")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) - } - v43 := v42.Get() - v44 := lang.Apply(v43, []any{v3}) - v45 := lang.Apply(v32, []any{v36, v40, v44}) - v46 := lang.Apply(v29, []any{v45}) - v47 := lang.Apply(v26, []any{v46}) - v48 := lang.Apply(v15, []any{v19, v23, v47}) - v49 := lang.Apply(v12, []any{v48}) - v4 = v49 + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("seq")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("concat")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("list")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{lang.NewSymbol(".")}) + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("list")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.Apply(tmp22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("list")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("seq")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("concat")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) + } + tmp32 := tmp31.Get() + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("list")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) + } + tmp35 := tmp34.Get() + tmp36 := lang.Apply(tmp35, []any{v9}) + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("list")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.Apply(tmp39, []any{v2}) + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("list")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := lang.Apply(tmp43, []any{v3}) + tmp45 := lang.Apply(tmp32, []any{tmp36, tmp40, tmp44}) + tmp46 := lang.Apply(tmp29, []any{tmp45}) + tmp47 := lang.Apply(tmp26, []any{tmp46}) + tmp48 := lang.Apply(tmp15, []any{tmp19, tmp23, tmp47}) + tmp49 := lang.Apply(tmp12, []any{tmp48}) + tmp4 = tmp49 } // end let - return v4 + return tmp4 default: if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -55707,32 +55818,33 @@ func init() { _ = v2 v3 := args[1] _ = v3 - v4 := lang.NewList(args[2:]...) - var v5 any + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any { // let // let binding "op" - var v6 any - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - if lang.IsTruthy(v9) { - v6 = closed15 + var tmp6 any + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + if lang.IsTruthy(tmp9) { + tmp6 = closed15 } else { - v6 = closed15 + tmp6 = closed15 } - var v10 any = v6 + var v10 any = tmp6 _ = v10 - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("reduce1")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - var v14 lang.FnFunc - v14 = lang.NewFnFunc(func(args ...any) any { + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -55740,178 +55852,178 @@ func init() { _ = v15 v16 := args[1] _ = v16 - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("seq")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("concat")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("list")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("seq")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) - } - v36 := v35.Get() - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("concat")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("list")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) - } - v42 := v41.Get() - v43 := lang.Apply(v42, []any{v10}) - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("list")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) - } - v46 := v45.Get() - v47 := lang.Apply(v46, []any{v15}) - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("list")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v16}) - v52 := lang.Apply(v39, []any{v43, v47, v51}) - v53 := lang.Apply(v36, []any{v52}) - v54 := lang.Apply(v33, []any{v53}) - v55 := lang.Apply(v22, []any{v26, v30, v54}) - v56 := lang.Apply(v19, []any{v55}) - return v56 + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("concat")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol(".")}) + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) + } + tmp42 := tmp41.Get() + tmp43 := lang.Apply(tmp42, []any{v10}) + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) + } + tmp46 := tmp45.Get() + tmp47 := lang.Apply(tmp46, []any{v15}) + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v16}) + tmp52 := lang.Apply(tmp39, []any{tmp43, tmp47, tmp51}) + tmp53 := lang.Apply(tmp36, []any{tmp52}) + tmp54 := lang.Apply(tmp33, []any{tmp53}) + tmp55 := lang.Apply(tmp22, []any{tmp26, tmp30, tmp54}) + tmp56 := lang.Apply(tmp19, []any{tmp55}) + return tmp56 }) - v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) - v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) + tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) if err != nil { panic(err) } - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("seq")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("concat")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("list")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.Apply(v25, []any{lang.NewSymbol(".")}) - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("seq")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) - } - v36 := v35.Get() - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("concat")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("list")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) - } - v42 := v41.Get() - v43 := lang.Apply(v42, []any{v10}) - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("list")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) - } - v46 := v45.Get() - v47 := lang.Apply(v46, []any{v2}) - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("list")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v3}) - v52 := lang.Apply(v39, []any{v43, v47, v51}) - v53 := lang.Apply(v36, []any{v52}) - v54 := lang.Apply(v33, []any{v53}) - v55 := lang.Apply(v22, []any{v26, v30, v54}) - v56 := lang.Apply(v19, []any{v55}) - v57 := lang.Apply(v13, []any{v16, v56, v4}) - v5 = v57 + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("concat")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol(".")}) + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) + } + tmp42 := tmp41.Get() + tmp43 := lang.Apply(tmp42, []any{v10}) + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) + } + tmp46 := tmp45.Get() + tmp47 := lang.Apply(tmp46, []any{v2}) + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v3}) + tmp52 := lang.Apply(tmp39, []any{tmp43, tmp47, tmp51}) + tmp53 := lang.Apply(tmp36, []any{tmp52}) + tmp54 := lang.Apply(tmp33, []any{tmp53}) + tmp55 := lang.Apply(tmp22, []any{tmp26, tmp30, tmp54}) + tmp56 := lang.Apply(tmp19, []any{tmp55}) + tmp57 := lang.Apply(tmp13, []any{tmp16, tmp56, v4}) + tmp5 = tmp57 } // end let - return v5 + return tmp5 } }) - v1 = v1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp1 = tmp1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") - if reflect.TypeOf(v4).Kind() != reflect.Func { + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - v5 := lang.Apply(v4, []any{nil, int64(1)}) - return v5 + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v0 := lang.NewSymbol("min").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the least of the nums.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), v2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1118), lang.NewKeyword("end-line"), int(1118))).(*lang.Symbol) - var v4 lang.FnFunc - v4 = lang.NewFnFunc(func(args ...any) any { + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp0 := lang.NewSymbol("min").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the least of the nums.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), tmp2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1118), lang.NewKeyword("end-line"), int(1118))).(*lang.Symbol) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v5 := args[0] @@ -55922,12 +56034,12 @@ func init() { _ = v5 v6 := args[1] _ = v6 - v7, _ := lang.FieldOrMethod(lang.Numbers, "Min") - if reflect.TypeOf(v7).Kind() != reflect.Func { + tmp7, _ := lang.FieldOrMethod(lang.Numbers, "Min") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Min is not a function"))) } - v8 := lang.Apply(v7, []any{v5, v6}) - return v8 + tmp8 := lang.Apply(tmp7, []any{v5, v6}) + return tmp8 default: if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -55936,41 +56048,42 @@ func init() { _ = v5 v6 := args[1] _ = v6 - v7 := lang.NewList(args[2:]...) - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("reduce1")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + var v7 any = lang.NewList(args[2:]...) + _ = v7 + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("min")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("min")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) } - v13 := v12.Get() - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("min")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + tmp13 := tmp12.Get() + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("min")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{v5, v6}) - v18 := lang.Apply(v10, []any{v13, v17, v7}) - return v18 + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{v5, v6}) + tmp18 := lang.Apply(tmp10, []any{tmp13, tmp17, v7}) + return tmp18 } }) - v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v3 := ns.InternWithValue(v0, v4, true) - if v0.Meta() != nil { - v3.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 := ns.InternWithValue(tmp0, tmp4, true) + if tmp0.Meta() != nil { + tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // min-key { - v0 := lang.NewSymbol("min-key").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Returns the x for which (k x), a number, is least.\n\n If there are multiple such xs, the last one is returned.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5033), lang.NewKeyword("end-line"), int(5033))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("min-key").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Returns the x for which (k x), a number, is least.\n\n If there are multiple such xs, the last one is returned.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5033), lang.NewKeyword("end-line"), int(5033))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 2: v3 := args[0] @@ -55985,22 +56098,22 @@ func init() { _ = v4 v5 := args[2] _ = v5 - var v6 any - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("<")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v3, []any{v4}) - v11 := lang.Apply(v3, []any{v5}) - v12 := lang.Apply(v9, []any{v10, v11}) - if lang.IsTruthy(v12) { - v6 = v4 + var tmp6 any + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("<")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(v3, []any{v4}) + tmp11 := lang.Apply(v3, []any{v5}) + tmp12 := lang.Apply(tmp9, []any{tmp10, tmp11}) + if lang.IsTruthy(tmp12) { + tmp6 = v4 } else { - v6 = v5 + tmp6 = v5 } - return v6 + return tmp6 default: if len(args) < 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -56011,66 +56124,67 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - var v7 any + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any { // let // let binding "kx" - v8 := lang.Apply(v3, []any{v4}) - var v9 any = v8 + tmp8 := lang.Apply(v3, []any{v4}) + var v9 any = tmp8 _ = v9 // let binding "ky" - v10 := lang.Apply(v3, []any{v5}) - var v11 any = v10 + tmp10 := lang.Apply(v3, []any{v5}) + var v11 any = tmp10 _ = v11 // let binding "vec__58" - var v12 any - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("<")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{v9, v11}) - if lang.IsTruthy(v16) { - v17 := lang.NewVector(v4, v9) - v18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5043), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(5043), lang.NewKeyword("end-column"), int(36)) - v19, err := lang.WithMeta(v17, v18.(lang.IPersistentMap)) + var tmp12 any + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("<")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{v9, v11}) + if lang.IsTruthy(tmp16) { + tmp17 := lang.NewVector(v4, v9) + tmp18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5043), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(5043), lang.NewKeyword("end-column"), int(36)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) if err != nil { panic(err) } - v12 = v19 + tmp12 = tmp19 } else { - v20 := lang.NewVector(v5, v11) - v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5043), lang.NewKeyword("column"), int(38), lang.NewKeyword("end-line"), int(5043), lang.NewKeyword("end-column"), int(43)) - v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) + tmp20 := lang.NewVector(v5, v11) + tmp21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5043), lang.NewKeyword("column"), int(38), lang.NewKeyword("end-line"), int(5043), lang.NewKeyword("end-column"), int(43)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) if err != nil { panic(err) } - v12 = v22 + tmp12 = tmp22 } - var v23 any = v12 + var v23 any = tmp12 _ = v23 // let binding "v" - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("nth")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.Apply(v26, []any{v23, int64(0), nil}) - var v28 any = v27 + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("nth")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.Apply(tmp26, []any{v23, int64(0), nil}) + var v28 any = tmp27 _ = v28 // let binding "kv" - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("nth")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.Apply(v31, []any{v23, int64(1), nil}) - var v33 any = v32 + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("nth")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.Apply(tmp31, []any{v23, int64(1), nil}) + var v33 any = tmp32 _ = v33 - var v34 any + var tmp34 any { // let // let binding "v" var v35 any = v28 @@ -56082,89 +56196,89 @@ func init() { var v37 any = v6 _ = v37 for { - var v38 any + var tmp38 any if lang.IsTruthy(v37) { - var v39 any + var tmp39 any { // let // let binding "w" - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("first")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("first")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) } - v42 := v41.Get() - v43 := lang.Apply(v42, []any{v37}) - var v44 any = v43 + tmp42 := tmp41.Get() + tmp43 := lang.Apply(tmp42, []any{v37}) + var v44 any = tmp43 _ = v44 // let binding "kw" - v45 := lang.Apply(v3, []any{v44}) - var v46 any = v45 + tmp45 := lang.Apply(v3, []any{v44}) + var v46 any = tmp45 _ = v46 - var v47 any - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("<=")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + var tmp47 any + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("<=")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v46, v36}) - if lang.IsTruthy(v51) { - var v52 any = v44 - var v53 any = v46 - v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v56 := v55.FindInternedVar(lang.NewSymbol("next")) - if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v46, v36}) + if lang.IsTruthy(tmp51) { + var tmp52 any = v44 + var tmp53 any = v46 + tmp55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp56 := tmp55.FindInternedVar(lang.NewSymbol("next")) + if tmp56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp56))) } - v57 := v56.Get() - v58 := lang.Apply(v57, []any{v37}) - var v54 any = v58 - v35 = v52 - v36 = v53 - v37 = v54 + tmp57 := tmp56.Get() + tmp58 := lang.Apply(tmp57, []any{v37}) + var tmp54 any = tmp58 + v35 = tmp52 + v36 = tmp53 + v37 = tmp54 continue } else { - var v59 any = v35 - var v60 any = v36 - v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v63 := v62.FindInternedVar(lang.NewSymbol("next")) - if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) + var tmp59 any = v35 + var tmp60 any = v36 + tmp62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp63 := tmp62.FindInternedVar(lang.NewSymbol("next")) + if tmp63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp63))) } - v64 := v63.Get() - v65 := lang.Apply(v64, []any{v37}) - var v61 any = v65 - v35 = v59 - v36 = v60 - v37 = v61 + tmp64 := tmp63.Get() + tmp65 := lang.Apply(tmp64, []any{v37}) + var tmp61 any = tmp65 + v35 = tmp59 + v36 = tmp60 + v37 = tmp61 continue } - v39 = v47 + tmp39 = tmp47 } // end let - v38 = v39 + tmp38 = tmp39 } else { - v38 = v35 + tmp38 = v35 } - v34 = v38 + tmp34 = tmp38 break } } // end let - v7 = v34 + tmp7 = tmp34 } // end let - return v7 + return tmp7 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // mix-collection-hash { - v0 := lang.NewSymbol("mix-collection-hash").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("hash-basis"), lang.NewSymbol("count"))), lang.NewKeyword("doc"), "Mix final collection hash for ordered or unordered collections.\n hash-basis is the combined collection hash, count is the number\n of elements included in the basis. Note this is the hash code\n consistent with =, different from .hashCode.\n See http://glojure.org/data_structures#hash for full algorithms.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5199), lang.NewKeyword("end-line"), int(5199))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("mix-collection-hash").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("hash-basis"), lang.NewSymbol("count"))), lang.NewKeyword("doc"), "Mix final collection hash for ordered or unordered collections.\n hash-basis is the combined collection hash, count is the number\n of elements included in the basis. Note this is the hash code\n consistent with =, different from .hashCode.\n See http://glojure.org/data_structures#hash for full algorithms.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5199), lang.NewKeyword("end-line"), int(5199))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -56172,20 +56286,20 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.Apply(nil, []any{v3, v4}) - return v5 + tmp5 := lang.Apply(nil, []any{v3, v4}) + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // mk-bound-fn { - v0 := lang.NewSymbol("mk-bound-fn").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5127), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(5127), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sc"), lang.NewSymbol("test"), lang.NewSymbol("key"))), lang.NewKeyword("private"), true, lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("mk-bound-fn").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5127), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(5127), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sc"), lang.NewSymbol("test"), lang.NewSymbol("key"))), lang.NewKeyword("private"), true, lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -56195,55 +56309,55 @@ func init() { _ = v4 v5 := args[2] _ = v5 - var v6 lang.FnFunc - v6 = lang.NewFnFunc(func(args ...any) any { + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v7 := args[0] _ = v7 - v8, ok := lang.FieldOrMethod(v3, "comparator") + tmp8, ok := lang.FieldOrMethod(v3, "comparator") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "comparator"))) } - var v9 any - switch reflect.TypeOf(v8).Kind() { + var tmp9 any + switch reflect.TypeOf(tmp8).Kind() { case reflect.Func: - v9 = lang.Apply(v8, nil) + tmp9 = lang.Apply(tmp8, nil) default: - v9 = v8 + tmp9 = tmp8 } - v10, _ := lang.FieldOrMethod(v3, "entryKey") - if reflect.TypeOf(v10).Kind() != reflect.Func { + tmp10, _ := lang.FieldOrMethod(v3, "entryKey") + if reflect.TypeOf(tmp10).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("entryKey is not a function"))) } - v11 := lang.Apply(v10, []any{v7}) - v12, _ := lang.FieldOrMethod(v9, "compare") - if reflect.TypeOf(v12).Kind() != reflect.Func { + tmp11 := lang.Apply(tmp10, []any{v7}) + tmp12, _ := lang.FieldOrMethod(tmp9, "compare") + if reflect.TypeOf(tmp12).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("compare is not a function"))) } - v13 := lang.Apply(v12, []any{v11, v5}) - v14 := lang.Apply(v4, []any{v13, int64(0)}) - return v14 + tmp13 := lang.Apply(tmp12, []any{tmp11, v5}) + tmp14 := lang.Apply(v4, []any{tmp13, int64(0)}) + return tmp14 }) - v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5130), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(5131), lang.NewKeyword("end-column"), int(64)) - v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) + tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5130), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(5131), lang.NewKeyword("end-column"), int(64)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) if err != nil { panic(err) } - return v8 + return tmp8 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // mod { - v0 := lang.NewSymbol("mod").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"), lang.NewSymbol("div"))), lang.NewKeyword("doc"), "Modulus of num and div. Truncates toward negative infinity.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3567), lang.NewKeyword("end-line"), int(3567))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("mod").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"), lang.NewSymbol("div"))), lang.NewKeyword("doc"), "Modulus of num and div. Truncates toward negative infinity.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3567), lang.NewKeyword("end-line"), int(3567))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -56251,351 +56365,351 @@ func init() { _ = v3 v4 := args[1] _ = v4 - var v5 any + var tmp5 any { // let // let binding "m" - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("rem")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{v3, v4}) - var v10 any = v9 + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("rem")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.Apply(tmp8, []any{v3, v4}) + var v10 any = tmp9 _ = v10 - var v11 any - var v12 any + var tmp11 any + var tmp12 any { // let // let binding "or__0__auto__" - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("zero?")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{v10}) - var v17 any = v16 + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("zero?")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{v10}) + var v17 any = tmp16 _ = v17 - var v18 any + var tmp18 any if lang.IsTruthy(v17) { - v18 = v17 + tmp18 = v17 } else { - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("=")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("pos?")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v3}) - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("pos?")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) - } - v28 := v27.Get() - v29 := lang.Apply(v28, []any{v4}) - v30 := lang.Apply(v21, []any{v25, v29}) - v18 = v30 - } - v12 = v18 + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("=")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("pos?")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.Apply(tmp24, []any{v3}) + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("pos?")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) + } + tmp28 := tmp27.Get() + tmp29 := lang.Apply(tmp28, []any{v4}) + tmp30 := lang.Apply(tmp21, []any{tmp25, tmp29}) + tmp18 = tmp30 + } + tmp12 = tmp18 } // end let - if lang.IsTruthy(v12) { - v11 = v10 + if lang.IsTruthy(tmp12) { + tmp11 = v10 } else { - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("+")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("+")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{v10, v4}) - v11 = v16 + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{v10, v4}) + tmp11 = tmp16 } - v5 = v11 + tmp5 = tmp11 } // end let - return v5 + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // name { - v1 := reflect.TypeOf("") - v0 := lang.NewSymbol("name").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns the name String of a string, symbol or keyword.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1585), lang.NewKeyword("end-line"), int(1585))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp1 := reflect.TypeOf("") + tmp0 := lang.NewSymbol("name").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns the name String of a string, symbol or keyword.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1585), lang.NewKeyword("end-line"), int(1585))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - var v5 any - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("string?")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{v4}) - if lang.IsTruthy(v9) { - v5 = v4 + var tmp5 any + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("string?")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.Apply(tmp8, []any{v4}) + if lang.IsTruthy(tmp9) { + tmp5 = v4 } else { - v10, _ := lang.FieldOrMethod(v4, "Name") - if reflect.TypeOf(v10).Kind() != reflect.Func { + tmp10, _ := lang.FieldOrMethod(v4, "Name") + if reflect.TypeOf(tmp10).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Name is not a function"))) } - v11 := lang.Apply(v10, []any{}) - v5 = v11 + tmp11 := lang.Apply(tmp10, []any{}) + tmp5 = tmp11 } - return v5 + return tmp5 }) - v4 := reflect.TypeOf("") - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp4 := reflect.TypeOf("") + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // namespace { - v1 := reflect.TypeOf("") - v0 := lang.NewSymbol("namespace").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns the namespace String of a symbol or keyword, or nil if not present.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1593), lang.NewKeyword("end-line"), int(1593))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp1 := reflect.TypeOf("") + tmp0 := lang.NewSymbol("namespace").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns the namespace String of a symbol or keyword, or nil if not present.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1593), lang.NewKeyword("end-line"), int(1593))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5, _ := lang.FieldOrMethod(v4, "Namespace") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(v4, "Namespace") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Namespace is not a function"))) } - v6 := lang.Apply(v5, []any{}) - return v6 + tmp6 := lang.Apply(tmp5, []any{}) + return tmp6 }) - v4 := reflect.TypeOf("") - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp4 := reflect.TypeOf("") + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // nary-inline { - v0 := lang.NewSymbol("nary-inline").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(948), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(948), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("op")), lang.NewVector(lang.NewSymbol("op"), lang.NewSymbol("unchecked-op"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("nary-inline").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(948), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(948), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("op")), lang.NewVector(lang.NewSymbol("op"), lang.NewSymbol("unchecked-op"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("nary-inline")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.Apply(v6, []any{v3, v3}) - return v7 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("nary-inline")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.Apply(tmp6, []any{v3, v3}) + return tmp7 case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - var v5 lang.FnFunc - v5 = lang.NewFnFunc(func(args ...any) any { + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v6 := args[0] _ = v6 - var v7 any + var tmp7 any { // let // let binding "op" - var v8 any - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - if lang.IsTruthy(v11) { - v8 = v4 + var tmp8 any + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + if lang.IsTruthy(tmp11) { + tmp8 = v4 } else { - v8 = v3 + tmp8 = v3 } - var v12 any = v8 + var v12 any = tmp8 _ = v12 - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("seq")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("concat")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("list")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{lang.NewSymbol(".")}) - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("list")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.Apply(v25, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("seq")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) - } - v32 := v31.Get() - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("concat")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("list")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.Apply(v38, []any{v12}) - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("list")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) - } - v42 := v41.Get() - v43 := lang.Apply(v42, []any{v6}) - v44 := lang.Apply(v35, []any{v39, v43}) - v45 := lang.Apply(v32, []any{v44}) - v46 := lang.Apply(v29, []any{v45}) - v47 := lang.Apply(v18, []any{v22, v26, v46}) - v48 := lang.Apply(v15, []any{v47}) - v7 = v48 + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("seq")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("concat")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol(".")}) + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("seq")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) + } + tmp32 := tmp31.Get() + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("concat")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) + } + tmp35 := tmp34.Get() + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{v12}) + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) + } + tmp42 := tmp41.Get() + tmp43 := lang.Apply(tmp42, []any{v6}) + tmp44 := lang.Apply(tmp35, []any{tmp39, tmp43}) + tmp45 := lang.Apply(tmp32, []any{tmp44}) + tmp46 := lang.Apply(tmp29, []any{tmp45}) + tmp47 := lang.Apply(tmp18, []any{tmp22, tmp26, tmp46}) + tmp48 := lang.Apply(tmp15, []any{tmp47}) + tmp7 = tmp48 } // end let - return v7 + return tmp7 case 2: v6 := args[0] _ = v6 v7 := args[1] _ = v7 - var v8 any + var tmp8 any { // let // let binding "op" - var v9 any - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - if lang.IsTruthy(v12) { - v9 = v4 + var tmp9 any + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + if lang.IsTruthy(tmp12) { + tmp9 = v4 } else { - v9 = v3 + tmp9 = v3 } - var v13 any = v9 + var v13 any = tmp9 _ = v13 - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("seq")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("concat")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("list")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.Apply(v22, []any{lang.NewSymbol(".")}) - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("list")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.Apply(v26, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("list")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("seq")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("concat")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) - } - v36 := v35.Get() - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("list")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.Apply(v39, []any{v13}) - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("list")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) - } - v43 := v42.Get() - v44 := lang.Apply(v43, []any{v6}) - v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v46 := v45.FindInternedVar(lang.NewSymbol("list")) - if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) - } - v47 := v46.Get() - v48 := lang.Apply(v47, []any{v7}) - v49 := lang.Apply(v36, []any{v40, v44, v48}) - v50 := lang.Apply(v33, []any{v49}) - v51 := lang.Apply(v30, []any{v50}) - v52 := lang.Apply(v19, []any{v23, v27, v51}) - v53 := lang.Apply(v16, []any{v52}) - v8 = v53 + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("seq")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("concat")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("list")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.Apply(tmp22, []any{lang.NewSymbol(".")}) + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("list")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.Apply(tmp26, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("list")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("seq")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("concat")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("list")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.Apply(tmp39, []any{v13}) + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("list")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := lang.Apply(tmp43, []any{v6}) + tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp46 := tmp45.FindInternedVar(lang.NewSymbol("list")) + if tmp46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) + } + tmp47 := tmp46.Get() + tmp48 := lang.Apply(tmp47, []any{v7}) + tmp49 := lang.Apply(tmp36, []any{tmp40, tmp44, tmp48}) + tmp50 := lang.Apply(tmp33, []any{tmp49}) + tmp51 := lang.Apply(tmp30, []any{tmp50}) + tmp52 := lang.Apply(tmp19, []any{tmp23, tmp27, tmp51}) + tmp53 := lang.Apply(tmp16, []any{tmp52}) + tmp8 = tmp53 } // end let - return v8 + return tmp8 default: if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -56604,32 +56718,33 @@ func init() { _ = v6 v7 := args[1] _ = v7 - v8 := lang.NewList(args[2:]...) - var v9 any + var v8 any = lang.NewList(args[2:]...) + _ = v8 + var tmp9 any { // let // let binding "op" - var v10 any - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - if lang.IsTruthy(v13) { - v10 = v4 + var tmp10 any + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + if lang.IsTruthy(tmp13) { + tmp10 = v4 } else { - v10 = v3 + tmp10 = v3 } - var v14 any = v10 + var v14 any = tmp10 _ = v14 - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("reduce1")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - var v18 lang.FnFunc - v18 = lang.NewFnFunc(func(args ...any) any { + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + var tmp18 lang.FnFunc + tmp18 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -56637,648 +56752,653 @@ func init() { _ = v19 v20 := args[1] _ = v20 - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("seq")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("concat")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol(".")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol(".")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v36 := v35.FindInternedVar(lang.NewSymbol("list")) - if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp36 := tmp35.FindInternedVar(lang.NewSymbol("list")) + if tmp36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) } - v37 := v36.Get() - v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v39 := v38.FindInternedVar(lang.NewSymbol("seq")) - if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + tmp37 := tmp36.Get() + tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp39 := tmp38.FindInternedVar(lang.NewSymbol("seq")) + if tmp39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) } - v40 := v39.Get() - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("concat")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + tmp40 := tmp39.Get() + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("concat")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) } - v43 := v42.Get() - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("list")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + tmp43 := tmp42.Get() + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) } - v46 := v45.Get() - v47 := lang.Apply(v46, []any{v14}) - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("list")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + tmp46 := tmp45.Get() + tmp47 := lang.Apply(tmp46, []any{v14}) + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v19}) - v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v53 := v52.FindInternedVar(lang.NewSymbol("list")) - if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v19}) + tmp52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp53 := tmp52.FindInternedVar(lang.NewSymbol("list")) + if tmp53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp53))) } - v54 := v53.Get() - v55 := lang.Apply(v54, []any{v20}) - v56 := lang.Apply(v43, []any{v47, v51, v55}) - v57 := lang.Apply(v40, []any{v56}) - v58 := lang.Apply(v37, []any{v57}) - v59 := lang.Apply(v26, []any{v30, v34, v58}) - v60 := lang.Apply(v23, []any{v59}) - return v60 + tmp54 := tmp53.Get() + tmp55 := lang.Apply(tmp54, []any{v20}) + tmp56 := lang.Apply(tmp43, []any{tmp47, tmp51, tmp55}) + tmp57 := lang.Apply(tmp40, []any{tmp56}) + tmp58 := lang.Apply(tmp37, []any{tmp57}) + tmp59 := lang.Apply(tmp26, []any{tmp30, tmp34, tmp58}) + tmp60 := lang.Apply(tmp23, []any{tmp59}) + return tmp60 }) - v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) - v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) + tmp19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) if err != nil { panic(err) } - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("seq")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("concat")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol(".")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v36 := v35.FindInternedVar(lang.NewSymbol("list")) - if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) - } - v37 := v36.Get() - v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v39 := v38.FindInternedVar(lang.NewSymbol("seq")) - if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) - } - v40 := v39.Get() - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("concat")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) - } - v43 := v42.Get() - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("list")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) - } - v46 := v45.Get() - v47 := lang.Apply(v46, []any{v14}) - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("list")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v6}) - v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v53 := v52.FindInternedVar(lang.NewSymbol("list")) - if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) - } - v54 := v53.Get() - v55 := lang.Apply(v54, []any{v7}) - v56 := lang.Apply(v43, []any{v47, v51, v55}) - v57 := lang.Apply(v40, []any{v56}) - v58 := lang.Apply(v37, []any{v57}) - v59 := lang.Apply(v26, []any{v30, v34, v58}) - v60 := lang.Apply(v23, []any{v59}) - v61 := lang.Apply(v17, []any{v20, v60, v8}) - v9 = v61 + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol(".")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp36 := tmp35.FindInternedVar(lang.NewSymbol("list")) + if tmp36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) + } + tmp37 := tmp36.Get() + tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp39 := tmp38.FindInternedVar(lang.NewSymbol("seq")) + if tmp39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) + } + tmp40 := tmp39.Get() + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("concat")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) + } + tmp46 := tmp45.Get() + tmp47 := lang.Apply(tmp46, []any{v14}) + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v6}) + tmp52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp53 := tmp52.FindInternedVar(lang.NewSymbol("list")) + if tmp53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp53))) + } + tmp54 := tmp53.Get() + tmp55 := lang.Apply(tmp54, []any{v7}) + tmp56 := lang.Apply(tmp43, []any{tmp47, tmp51, tmp55}) + tmp57 := lang.Apply(tmp40, []any{tmp56}) + tmp58 := lang.Apply(tmp37, []any{tmp57}) + tmp59 := lang.Apply(tmp26, []any{tmp30, tmp34, tmp58}) + tmp60 := lang.Apply(tmp23, []any{tmp59}) + tmp61 := lang.Apply(tmp17, []any{tmp20, tmp60, v8}) + tmp9 = tmp61 } // end let - return v9 + return tmp9 } }) - v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86)) - v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) + tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) if err != nil { panic(err) } - return v7 + return tmp7 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // nat-int? { - v0 := lang.NewSymbol("nat-int?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a non-negative fixed precision integer", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1415), lang.NewKeyword("end-line"), int(1415))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("nat-int?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a non-negative fixed precision integer", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1415), lang.NewKeyword("end-line"), int(1415))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any + var tmp4 any { // let // let binding "and__0__auto__" - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("int?")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v3}) - var v9 any = v8 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("int?")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v3}) + var v9 any = tmp8 _ = v9 - var v10 any + var tmp10 any if lang.IsTruthy(v9) { - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("not")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("neg?")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{v3}) - v18 := lang.Apply(v13, []any{v17}) - v10 = v18 + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("not")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("neg?")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := lang.Apply(tmp13, []any{tmp17}) + tmp10 = tmp18 } else { - v10 = v9 + tmp10 = v9 } - v4 = v10 + tmp4 = tmp10 } // end let - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // neg-int? { - v0 := lang.NewSymbol("neg-int?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a negative fixed precision integer", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1409), lang.NewKeyword("end-line"), int(1409))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("neg-int?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a negative fixed precision integer", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1409), lang.NewKeyword("end-line"), int(1409))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any + var tmp4 any { // let // let binding "and__0__auto__" - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("int?")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v3}) - var v9 any = v8 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("int?")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v3}) + var v9 any = tmp8 _ = v9 - var v10 any + var tmp10 any if lang.IsTruthy(v9) { - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("neg?")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{v3}) - v10 = v14 + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("neg?")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{v3}) + tmp10 = tmp14 } else { - v10 = v9 + tmp10 = v9 } - v4 = v10 + tmp4 = tmp10 } // end let - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // neg? { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function neg?__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("concat")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("list")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("seq")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("concat")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/IsNeg")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{v3}) - v35 := lang.Apply(v26, []any{v30, v34}) - v36 := lang.Apply(v23, []any{v35}) - v37 := lang.Apply(v20, []any{v36}) - v38 := lang.Apply(v9, []any{v13, v17, v37}) - v39 := lang.Apply(v6, []any{v38}) - return v39 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/IsNeg")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{v3}) + tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) + tmp36 := lang.Apply(tmp23, []any{tmp35}) + tmp37 := lang.Apply(tmp20, []any{tmp36}) + tmp38 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp37}) + tmp39 := lang.Apply(tmp6, []any{tmp38}) + return tmp39 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("neg?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns true if num is less than zero, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1259), lang.NewKeyword("end-line"), int(1259))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("neg?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns true if num is less than zero, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1259), lang.NewKeyword("end-line"), int(1259))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5, _ := lang.FieldOrMethod(lang.Numbers, "IsNeg") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "IsNeg") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("IsNeg is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // newline { - v0 := lang.NewSymbol("newline").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Writes a platform-specific newline to *out*", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3698), lang.NewKeyword("end-line"), int(3698))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("newline").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Writes a platform-specific newline to *out*", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3698), lang.NewKeyword("end-line"), int(3698))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v4 := v3.FindInternedVar(lang.NewSymbol("*out*")) - if v4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) + tmp3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp4 := tmp3.FindInternedVar(lang.NewSymbol("*out*")) + if tmp4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp4))) } - v5 := v4.Get() - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("system-newline")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + tmp5 := tmp4.Get() + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("system-newline")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) } - v8 := v7.Get() - v9 := lang.Apply(lang.AppendWriter, []any{v5, v8}) - _ = v9 + tmp8 := tmp7.Get() + tmp9 := lang.Apply(lang.AppendWriter, []any{tmp5, tmp8}) + _ = tmp9 return nil }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // next { - v1 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() - v0 := lang.NewSymbol("next").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a seq of the items after the first. Calls seq on its\n argument. If there are no more items, returns nil.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(55), lang.NewKeyword("end-line"), int(61))).(*lang.Symbol) - var v3 lang.FnFunc + tmp1 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() + tmp0 := lang.NewSymbol("next").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a seq of the items after the first. Calls seq on its\n argument. If there are no more items, returns nil.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(55), lang.NewKeyword("end-line"), int(61))).(*lang.Symbol) + var tmp3 lang.FnFunc { // function next - v3 = lang.NewFnFunc(func(args ...any) any { + var v4 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v5 := args[0] _ = v5 - v6 := lang.Apply(lang.Next, []any{v5}) - return v6 + tmp6 := lang.Apply(lang.Next, []any{v5}) + return tmp6 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(61), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(61), lang.NewKeyword("end-column"), int(77))).(lang.FnFunc) - v4 := v3 + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(61), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(61), lang.NewKeyword("end-column"), int(77))).(lang.FnFunc) + v4 = tmp3 _ = v4 } - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // nfirst { - v0 := lang.NewSymbol("nfirst").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Same as (next (first x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(105), lang.NewKeyword("end-line"), int(109))).(*lang.Symbol) - var v2 lang.FnFunc + tmp0 := lang.NewSymbol("nfirst").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Same as (next (first x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(105), lang.NewKeyword("end-line"), int(109))).(*lang.Symbol) + var tmp2 lang.FnFunc { // function nfirst - v2 = lang.NewFnFunc(func(args ...any) any { + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("next")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("first")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v4}) - v12 := lang.Apply(v7, []any{v11}) - return v12 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("next")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("first")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v4}) + tmp12 := lang.Apply(tmp7, []any{tmp11}) + return tmp12 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(109), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(109), lang.NewKeyword("end-column"), int(49))).(lang.FnFunc) - v3 := v2 + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(109), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(109), lang.NewKeyword("end-column"), int(49))).(lang.FnFunc) + v3 = tmp2 _ = v3 } - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // nil? { - v1 := reflect.TypeOf(false) - var v2 lang.FnFunc + tmp1 := reflect.TypeOf(false) + var tmp2 lang.FnFunc { // function nil?__inliner - v2 = lang.NewFnFunc(func(args ...any) any { + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("list")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Identical"), v4, nil}) - return v8 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("list")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Identical"), v4, nil}) + return tmp8 }) - v3 := v2 + v3 = tmp2 _ = v3 } - v0 := lang.NewSymbol("nil?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v2, lang.NewKeyword("doc"), "Returns true if x is nil, false otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(435), lang.NewKeyword("end-line"), int(435))).(*lang.Symbol) - var v4 lang.FnFunc - v4 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("nil?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp2, lang.NewKeyword("doc"), "Returns true if x is nil, false otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(435), lang.NewKeyword("end-line"), int(435))).(*lang.Symbol) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v5 := args[0] _ = v5 - v6 := lang.Apply(lang.IsNil, []any{v5}) - return v6 + tmp6 := lang.Apply(lang.IsNil, []any{v5}) + return tmp6 }) - v5 := reflect.TypeOf(false) - v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v5)).(lang.FnFunc) - v3 := ns.InternWithValue(v0, v4, true) - if v0.Meta() != nil { - v3.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp5 := reflect.TypeOf(false) + tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp5)).(lang.FnFunc) + tmp3 := ns.InternWithValue(tmp0, tmp4, true) + if tmp0.Meta() != nil { + tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // nnext { - v0 := lang.NewSymbol("nnext").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Same as (next (next x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(119), lang.NewKeyword("end-line"), int(123))).(*lang.Symbol) - var v2 lang.FnFunc + tmp0 := lang.NewSymbol("nnext").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Same as (next (next x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(119), lang.NewKeyword("end-line"), int(123))).(*lang.Symbol) + var tmp2 lang.FnFunc { // function nnext - v2 = lang.NewFnFunc(func(args ...any) any { + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("next")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("next")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v4}) - v12 := lang.Apply(v7, []any{v11}) - return v12 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("next")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("next")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v4}) + tmp12 := lang.Apply(tmp7, []any{tmp11}) + return tmp12 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(123), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(123), lang.NewKeyword("end-column"), int(46))).(lang.FnFunc) - v3 := v2 + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(123), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(123), lang.NewKeyword("end-column"), int(46))).(lang.FnFunc) + v3 = tmp2 _ = v3 } - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // normalize-slurp-opts { - v0 := lang.NewSymbol("normalize-slurp-opts").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6974), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(6974), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("opts"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("normalize-slurp-opts").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6974), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(6974), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("opts"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("string?")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("first")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v3}) - v12 := lang.Apply(v7, []any{v11}) - if lang.IsTruthy(v12) { - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("println")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{"WARNING: (slurp f enc) is deprecated, use (slurp f :encoding enc)."}) - _ = v16 - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("first")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.Apply(v19, []any{v3}) - v21 := lang.NewVector(lang.NewKeyword("encoding"), v20) - v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6979), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(6979), lang.NewKeyword("end-column"), int(30)) - v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) + var tmp4 any + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("string?")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("first")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v3}) + tmp12 := lang.Apply(tmp7, []any{tmp11}) + if lang.IsTruthy(tmp12) { + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("println")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{"WARNING: (slurp f enc) is deprecated, use (slurp f :encoding enc)."}) + _ = tmp16 + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("first")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.Apply(tmp19, []any{v3}) + tmp21 := lang.NewVector(lang.NewKeyword("encoding"), tmp20) + tmp22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6979), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(6979), lang.NewKeyword("end-column"), int(30)) + tmp23, err := lang.WithMeta(tmp21, tmp22.(lang.IPersistentMap)) if err != nil { panic(err) } - v4 = v23 + tmp4 = tmp23 } else { - v4 = v3 + tmp4 = v3 } - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // not { - v1 := reflect.TypeOf(false) - v0 := lang.NewSymbol("not").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is logical false, false otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(523), lang.NewKeyword("end-line"), int(523))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp1 := reflect.TypeOf(false) + tmp0 := lang.NewSymbol("not").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is logical false, false otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(523), lang.NewKeyword("end-line"), int(523))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - var v5 any + var tmp5 any if lang.IsTruthy(v4) { - v5 = false + tmp5 = false } else { - v5 = true + tmp5 = true } - return v5 + return tmp5 }) - v4 := reflect.TypeOf(false) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp4 := reflect.TypeOf(false) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // not-any? { - v1 := reflect.TypeOf(false) - v0 := lang.NewSymbol("not-any?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns false if (pred x) is logical true for any x in coll,\n else true.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(2696), lang.NewKeyword("end-line"), int(2701))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp1 := reflect.TypeOf(false) + tmp0 := lang.NewSymbol("not-any?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns false if (pred x) is logical true for any x in coll,\n else true.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(2696), lang.NewKeyword("end-line"), int(2701))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - v4 := lang.Apply(closed17, nil) - v5 := lang.Apply(closed16, []any{v4}) - return v5 + tmp4 := lang.Apply(closed17, nil) + tmp5 := lang.Apply(closed16, []any{tmp4}) + return tmp5 case 1: v4 := args[0] _ = v4 - v5 := lang.Apply(closed17, []any{v4}) - v6 := lang.Apply(closed16, []any{v5}) - return v6 + tmp5 := lang.Apply(closed17, []any{v4}) + tmp6 := lang.Apply(closed16, []any{tmp5}) + return tmp6 case 2: v4 := args[0] _ = v4 v5 := args[1] _ = v5 - v6 := lang.Apply(closed17, []any{v4, v5}) - v7 := lang.Apply(closed16, []any{v6}) - return v7 + tmp6 := lang.Apply(closed17, []any{v4, v5}) + tmp7 := lang.Apply(closed16, []any{tmp6}) + return tmp7 case 3: v4 := args[0] _ = v4 @@ -57286,9 +57406,9 @@ func init() { _ = v5 v6 := args[2] _ = v6 - v7 := lang.Apply(closed17, []any{v4, v5, v6}) - v8 := lang.Apply(closed16, []any{v7}) - return v8 + tmp7 := lang.Apply(closed17, []any{v4, v5, v6}) + tmp8 := lang.Apply(closed16, []any{tmp7}) + return tmp8 default: if len(args) < 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -57299,80 +57419,80 @@ func init() { _ = v5 v6 := args[2] _ = v6 - v7 := lang.NewList(args[3:]...) - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("apply")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + var v7 any = lang.NewList(args[3:]...) + _ = v7 + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("apply")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{closed17, v4, v5, v6, v7}) - v12 := lang.Apply(closed16, []any{v11}) - return v12 + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{closed17, v4, v5, v6, v7}) + tmp12 := lang.Apply(closed16, []any{tmp11}) + return tmp12 } }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2559), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2564), lang.NewKeyword("end-column"), int(49))).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2559), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2564), lang.NewKeyword("end-column"), int(49))).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // not-empty { - v0 := lang.NewSymbol("not-empty").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "If coll is empty, returns nil, else coll", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5516), lang.NewKeyword("end-line"), int(5516))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("not-empty").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "If coll is empty, returns nil, else coll", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5516), lang.NewKeyword("end-line"), int(5516))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("seq")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v3}) - if lang.IsTruthy(v8) { - v4 = v3 + var tmp4 any + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v3}) + if lang.IsTruthy(tmp8) { + tmp4 = v3 } else { - v4 = nil } - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // not-every? { - v1 := reflect.TypeOf(false) - v0 := lang.NewSymbol("not-every?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns false if (pred x) is logical true for every x in\n coll, else true.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(2677), lang.NewKeyword("end-line"), int(2682))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp1 := reflect.TypeOf(false) + tmp0 := lang.NewSymbol("not-every?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns false if (pred x) is logical true for every x in\n coll, else true.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(2677), lang.NewKeyword("end-line"), int(2682))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - v4 := lang.Apply(closed18, nil) - v5 := lang.Apply(closed16, []any{v4}) - return v5 + tmp4 := lang.Apply(closed18, nil) + tmp5 := lang.Apply(closed16, []any{tmp4}) + return tmp5 case 1: v4 := args[0] _ = v4 - v5 := lang.Apply(closed18, []any{v4}) - v6 := lang.Apply(closed16, []any{v5}) - return v6 + tmp5 := lang.Apply(closed18, []any{v4}) + tmp6 := lang.Apply(closed16, []any{tmp5}) + return tmp6 case 2: v4 := args[0] _ = v4 v5 := args[1] _ = v5 - v6 := lang.Apply(closed18, []any{v4, v5}) - v7 := lang.Apply(closed16, []any{v6}) - return v7 + tmp6 := lang.Apply(closed18, []any{v4, v5}) + tmp7 := lang.Apply(closed16, []any{tmp6}) + return tmp7 case 3: v4 := args[0] _ = v4 @@ -57380,9 +57500,9 @@ func init() { _ = v5 v6 := args[2] _ = v6 - v7 := lang.Apply(closed18, []any{v4, v5, v6}) - v8 := lang.Apply(closed16, []any{v7}) - return v8 + tmp7 := lang.Apply(closed18, []any{v4, v5, v6}) + tmp8 := lang.Apply(closed16, []any{tmp7}) + return tmp8 default: if len(args) < 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -57393,30 +57513,31 @@ func init() { _ = v5 v6 := args[2] _ = v6 - v7 := lang.NewList(args[3:]...) - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("apply")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + var v7 any = lang.NewList(args[3:]...) + _ = v7 + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("apply")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{closed18, v4, v5, v6, v7}) - v12 := lang.Apply(closed16, []any{v11}) - return v12 + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{closed18, v4, v5, v6, v7}) + tmp12 := lang.Apply(closed16, []any{tmp11}) + return tmp12 } }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2559), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2564), lang.NewKeyword("end-column"), int(49))).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2559), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2564), lang.NewKeyword("end-column"), int(49))).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // not= { - v1 := reflect.TypeOf(false) - v0 := lang.NewSymbol("not=").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Same as (not (= obj1 obj2))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(812), lang.NewKeyword("end-line"), int(812))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp1 := reflect.TypeOf(false) + tmp0 := lang.NewSymbol("not=").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Same as (not (= obj1 obj2))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(812), lang.NewKeyword("end-line"), int(812))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v4 := args[0] @@ -57427,21 +57548,21 @@ func init() { _ = v4 v5 := args[1] _ = v5 - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("not")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("=")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.Apply(v11, []any{v4, v5}) - v13 := lang.Apply(v8, []any{v12}) - return v13 + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("not")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("=")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.Apply(tmp11, []any{v4, v5}) + tmp13 := lang.Apply(tmp8, []any{tmp12}) + return tmp13 default: if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -57450,42 +57571,43 @@ func init() { _ = v4 v5 := args[1] _ = v5 - v6 := lang.NewList(args[2:]...) - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("not")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("not")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("apply")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("apply")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("=")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("=")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) } - v15 := v14.Get() - v16 := lang.Apply(v12, []any{v15, v4, v5, v6}) - v17 := lang.Apply(v9, []any{v16}) - return v17 + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp12, []any{tmp15, v4, v5, v6}) + tmp17 := lang.Apply(tmp9, []any{tmp16}) + return tmp17 } }) - v4 := reflect.TypeOf(false) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp4 := reflect.TypeOf(false) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // ns { - v0 := lang.NewSymbol("ns").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("docstring?"), lang.NewSymbol("attr-map?"), lang.NewSymbol("references*"))), lang.NewKeyword("doc"), "Sets *ns* to the namespace named by name (unevaluated), creating it\n if needed. references can be zero or more of: (:refer-glojure ...)\n (:require ...) (:use ...) (:import ...) (:load ...) (:gen-class)\n with the syntax of refer-glojure/require/use/import/load/gen-class\n respectively, except the arguments are unevaluated and need not be\n quoted. (:gen-class ...), when supplied, defaults to :name\n corresponding to the ns name, :main true, :impl-ns same as ns, and\n :init-impl-ns true. All options of gen-class are\n supported. The :gen-class directive is ignored when not\n compiling. If :gen-class is not supplied, when compiled only an\n nsname__init.class will be generated. If :refer-glojure is not used, a\n default (refer 'glojure.core) is used. Use of ns is preferred to\n individual calls to in-ns/require/use/import:\n\n (ns foo.bar\n (:refer-glojure :exclude [ancestors printf])\n (:require (glojure.contrib sql combinatorics))\n (:use (my.lib this that))\n (:import (java.util Date Timer Random)\n (java.sql Connection Statement)))", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5742), lang.NewKeyword("end-line"), int(5742))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("ns").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("docstring?"), lang.NewSymbol("attr-map?"), lang.NewSymbol("references*"))), lang.NewKeyword("doc"), "Sets *ns* to the namespace named by name (unevaluated), creating it\n if needed. references can be zero or more of: (:refer-glojure ...)\n (:require ...) (:use ...) (:import ...) (:load ...) (:gen-class)\n with the syntax of refer-glojure/require/use/import/load/gen-class\n respectively, except the arguments are unevaluated and need not be\n quoted. (:gen-class ...), when supplied, defaults to :name\n corresponding to the ns name, :main true, :impl-ns same as ns, and\n :init-impl-ns true. All options of gen-class are\n supported. The :gen-class directive is ignored when not\n compiling. If :gen-class is not supplied, when compiled only an\n nsname__init.class will be generated. If :refer-glojure is not used, a\n default (refer 'glojure.core) is used. Use of ns is preferred to\n individual calls to in-ns/require/use/import:\n\n (ns foo.bar\n (:refer-glojure :exclude [ancestors printf])\n (:require (glojure.contrib sql combinatorics))\n (:use (my.lib this that))\n (:import (java.util Date Timer Random)\n (java.sql Connection Statement)))", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5742), lang.NewKeyword("end-line"), int(5742))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 3 { @@ -57497,51 +57619,52 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - var v7 any + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any { // let // let binding "process-reference" - var v8 lang.FnFunc - v8 = lang.NewFnFunc(func(args ...any) any { + var tmp8 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v9 := args[0] _ = v9 - var v10 any + var tmp10 any { // let // let binding "vec__107" var v11 any = v9 _ = v11 // let binding "seq__108" - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("seq")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.Apply(v14, []any{v11}) - var v16 any = v15 + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("seq")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.Apply(tmp14, []any{v11}) + var v16 any = tmp15 _ = v16 // let binding "first__109" - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("first")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.Apply(v19, []any{v16}) - var v21 any = v20 + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("first")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.Apply(tmp19, []any{v16}) + var v21 any = tmp20 _ = v21 // let binding "seq__108" - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("next")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v16}) - var v26 any = v25 + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("next")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.Apply(tmp24, []any{v16}) + var v26 any = tmp25 _ = v26 // let binding "kname" var v27 any = v21 @@ -57549,1586 +57672,1584 @@ func init() { // let binding "args" var v28 any = v26 _ = v28 - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("seq")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("concat")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v36 := v35.FindInternedVar(lang.NewSymbol("list")) - if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) - } - v37 := v36.Get() - v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v39 := v38.FindInternedVar(lang.NewSymbol("symbol")) - if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) - } - v40 := v39.Get() - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("name")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) - } - v43 := v42.Get() - v44 := lang.Apply(v43, []any{v27}) - v45 := lang.Apply(v40, []any{"glojure.core", v44}) - v46 := lang.Apply(v37, []any{v45}) - v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v48 := v47.FindInternedVar(lang.NewSymbol("map")) - if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) - } - v49 := v48.Get() - var v50 lang.FnFunc - v50 = lang.NewFnFunc(func(args ...any) any { + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("seq")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("concat")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp36 := tmp35.FindInternedVar(lang.NewSymbol("list")) + if tmp36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) + } + tmp37 := tmp36.Get() + tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp39 := tmp38.FindInternedVar(lang.NewSymbol("symbol")) + if tmp39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) + } + tmp40 := tmp39.Get() + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("name")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := lang.Apply(tmp43, []any{v27}) + tmp45 := lang.Apply(tmp40, []any{"glojure.core", tmp44}) + tmp46 := lang.Apply(tmp37, []any{tmp45}) + tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp48 := tmp47.FindInternedVar(lang.NewSymbol("map")) + if tmp48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) + } + tmp49 := tmp48.Get() + var tmp50 lang.FnFunc + tmp50 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v51 := args[0] _ = v51 - v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v53 := v52.FindInternedVar(lang.NewSymbol("list")) - if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) + tmp52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp53 := tmp52.FindInternedVar(lang.NewSymbol("list")) + if tmp53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp53))) } - v54 := v53.Get() - v55 := lang.Apply(v54, []any{lang.NewSymbol("quote"), v51}) - return v55 + tmp54 := tmp53.Get() + tmp55 := lang.Apply(tmp54, []any{lang.NewSymbol("quote"), v51}) + return tmp55 }) - v51 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5769), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(5769), lang.NewKeyword("end-column"), int(36)) - v52, err := lang.WithMeta(v50, v51.(lang.IPersistentMap)) + tmp51 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5769), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(5769), lang.NewKeyword("end-column"), int(36)) + tmp52, err := lang.WithMeta(tmp50, tmp51.(lang.IPersistentMap)) if err != nil { panic(err) } - v53 := lang.Apply(v49, []any{v52, v28}) - v54 := lang.Apply(v34, []any{v46, v53}) - v55 := lang.Apply(v31, []any{v54}) - v10 = v55 + tmp53 := lang.Apply(tmp49, []any{tmp52, v28}) + tmp54 := lang.Apply(tmp34, []any{tmp46, tmp53}) + tmp55 := lang.Apply(tmp31, []any{tmp54}) + tmp10 = tmp55 } // end let - return v10 + return tmp10 }) - v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5767), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(5769), lang.NewKeyword("end-column"), int(44)) - v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) + tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5767), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(5769), lang.NewKeyword("end-column"), int(44)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) if err != nil { panic(err) } - var v11 any = v10 + var v11 any = tmp10 _ = v11 // let binding "docstring" - var v12 any - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("string?")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("first")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{v6}) - v20 := lang.Apply(v15, []any{v19}) - if lang.IsTruthy(v20) { - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("first")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.Apply(v23, []any{v6}) - v12 = v24 + var tmp12 any + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("string?")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("first")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{v6}) + tmp20 := lang.Apply(tmp15, []any{tmp19}) + if lang.IsTruthy(tmp20) { + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("first")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.Apply(tmp23, []any{v6}) + tmp12 = tmp24 } else { - v12 = nil } - var v25 any = v12 + var v25 any = tmp12 _ = v25 // let binding "references" - var v26 any + var tmp26 any if lang.IsTruthy(v25) { - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("next")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{v6}) - v26 = v30 + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("next")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{v6}) + tmp26 = tmp30 } else { - v26 = v6 + tmp26 = v6 } - var v31 any = v26 + var v31 any = tmp26 _ = v31 // let binding "name" - var v32 any + var tmp32 any if lang.IsTruthy(v25) { - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("vary-meta")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("assoc")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.Apply(v35, []any{v5, v38, lang.NewKeyword("doc"), v25}) - v32 = v39 + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("vary-meta")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) + } + tmp35 := tmp34.Get() + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("assoc")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp35, []any{v5, tmp38, lang.NewKeyword("doc"), v25}) + tmp32 = tmp39 } else { - v32 = v5 + tmp32 = v5 } - var v40 any = v32 + var v40 any = tmp32 _ = v40 // let binding "metadata" - var v41 any - v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v43 := v42.FindInternedVar(lang.NewSymbol("map?")) - if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) - } - v44 := v43.Get() - v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v46 := v45.FindInternedVar(lang.NewSymbol("first")) - if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) - } - v47 := v46.Get() - v48 := lang.Apply(v47, []any{v31}) - v49 := lang.Apply(v44, []any{v48}) - if lang.IsTruthy(v49) { - v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v51 := v50.FindInternedVar(lang.NewSymbol("first")) - if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) - } - v52 := v51.Get() - v53 := lang.Apply(v52, []any{v31}) - v41 = v53 + var tmp41 any + tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp43 := tmp42.FindInternedVar(lang.NewSymbol("map?")) + if tmp43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) + } + tmp44 := tmp43.Get() + tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp46 := tmp45.FindInternedVar(lang.NewSymbol("first")) + if tmp46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) + } + tmp47 := tmp46.Get() + tmp48 := lang.Apply(tmp47, []any{v31}) + tmp49 := lang.Apply(tmp44, []any{tmp48}) + if lang.IsTruthy(tmp49) { + tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp51 := tmp50.FindInternedVar(lang.NewSymbol("first")) + if tmp51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) + } + tmp52 := tmp51.Get() + tmp53 := lang.Apply(tmp52, []any{v31}) + tmp41 = tmp53 } else { - v41 = nil } - var v54 any = v41 + var v54 any = tmp41 _ = v54 // let binding "references" - var v55 any + var tmp55 any if lang.IsTruthy(v54) { - v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v57 := v56.FindInternedVar(lang.NewSymbol("next")) - if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) - } - v58 := v57.Get() - v59 := lang.Apply(v58, []any{v31}) - v55 = v59 + tmp56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp57 := tmp56.FindInternedVar(lang.NewSymbol("next")) + if tmp57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp57))) + } + tmp58 := tmp57.Get() + tmp59 := lang.Apply(tmp58, []any{v31}) + tmp55 = tmp59 } else { - v55 = v31 + tmp55 = v31 } - var v60 any = v55 + var v60 any = tmp55 _ = v60 // let binding "name" - var v61 any + var tmp61 any if lang.IsTruthy(v54) { - v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v63 := v62.FindInternedVar(lang.NewSymbol("vary-meta")) - if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) - } - v64 := v63.Get() - v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v66 := v65.FindInternedVar(lang.NewSymbol("merge")) - if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) - } - v67 := v66.Get() - v68 := lang.Apply(v64, []any{v40, v67, v54}) - v61 = v68 + tmp62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp63 := tmp62.FindInternedVar(lang.NewSymbol("vary-meta")) + if tmp63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp63))) + } + tmp64 := tmp63.Get() + tmp65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp66 := tmp65.FindInternedVar(lang.NewSymbol("merge")) + if tmp66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp66))) + } + tmp67 := tmp66.Get() + tmp68 := lang.Apply(tmp64, []any{v40, tmp67, v54}) + tmp61 = tmp68 } else { - v61 = v40 + tmp61 = v40 } - var v69 any = v61 + var v69 any = tmp61 _ = v69 // let binding "gen-class-clause" - v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v71 := v70.FindInternedVar(lang.NewSymbol("first")) - if v71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) - } - v72 := v71.Get() - v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v74 := v73.FindInternedVar(lang.NewSymbol("filter")) - if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) - } - v75 := v74.Get() - var v76 lang.FnFunc - v76 = lang.NewFnFunc(func(args ...any) any { + tmp70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp71 := tmp70.FindInternedVar(lang.NewSymbol("first")) + if tmp71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp71))) + } + tmp72 := tmp71.Get() + tmp73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp74 := tmp73.FindInternedVar(lang.NewSymbol("filter")) + if tmp74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp74))) + } + tmp75 := tmp74.Get() + var tmp76 lang.FnFunc + tmp76 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v77 := args[0] _ = v77 - v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v79 := v78.FindInternedVar(lang.NewSymbol("=")) - if v79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) - } - v80 := v79.Get() - v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v82 := v81.FindInternedVar(lang.NewSymbol("first")) - if v82.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) - } - v83 := v82.Get() - v84 := lang.Apply(v83, []any{v77}) - v85 := lang.Apply(v80, []any{lang.NewKeyword("gen-class"), v84}) - return v85 + tmp78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp79 := tmp78.FindInternedVar(lang.NewSymbol("=")) + if tmp79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp79))) + } + tmp80 := tmp79.Get() + tmp81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp82 := tmp81.FindInternedVar(lang.NewSymbol("first")) + if tmp82.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp82))) + } + tmp83 := tmp82.Get() + tmp84 := lang.Apply(tmp83, []any{v77}) + tmp85 := lang.Apply(tmp80, []any{lang.NewKeyword("gen-class"), tmp84}) + return tmp85 }) - v77 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5780), lang.NewKeyword("column"), int(41), lang.NewKeyword("end-line"), int(5780), lang.NewKeyword("end-column"), int(65)) - v78, err := lang.WithMeta(v76, v77.(lang.IPersistentMap)) + tmp77 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5780), lang.NewKeyword("column"), int(41), lang.NewKeyword("end-line"), int(5780), lang.NewKeyword("end-column"), int(65)) + tmp78, err := lang.WithMeta(tmp76, tmp77.(lang.IPersistentMap)) if err != nil { panic(err) } - v79 := lang.Apply(v75, []any{v78, v60}) - v80 := lang.Apply(v72, []any{v79}) - var v81 any = v80 + tmp79 := lang.Apply(tmp75, []any{tmp78, v60}) + tmp80 := lang.Apply(tmp72, []any{tmp79}) + var v81 any = tmp80 _ = v81 // let binding "gen-class-call" - var v82 any + var tmp82 any if lang.IsTruthy(v81) { - v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v84 := v83.FindInternedVar(lang.NewSymbol("list*")) - if v84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) - } - v85 := v84.Get() - v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v87 := v86.FindInternedVar(lang.NewSymbol("str")) - if v87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) - } - v88 := v87.Get() - v89 := lang.Apply(v88, []any{v69}) - v90, _ := lang.FieldOrMethod(v89, "replace") - if reflect.TypeOf(v90).Kind() != reflect.Func { + tmp83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp84 := tmp83.FindInternedVar(lang.NewSymbol("list*")) + if tmp84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp84))) + } + tmp85 := tmp84.Get() + tmp86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp87 := tmp86.FindInternedVar(lang.NewSymbol("str")) + if tmp87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp87))) + } + tmp88 := tmp87.Get() + tmp89 := lang.Apply(tmp88, []any{v69}) + tmp90, _ := lang.FieldOrMethod(tmp89, "replace") + if reflect.TypeOf(tmp90).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("replace is not a function"))) } - v91 := lang.Apply(v90, []any{lang.NewChar(45), lang.NewChar(95)}) - v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v93 := v92.FindInternedVar(lang.NewSymbol("next")) - if v93.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) + tmp91 := lang.Apply(tmp90, []any{lang.NewChar(45), lang.NewChar(95)}) + tmp92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp93 := tmp92.FindInternedVar(lang.NewSymbol("next")) + if tmp93.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp93))) } - v94 := v93.Get() - v95 := lang.Apply(v94, []any{v81}) - v96 := lang.Apply(v85, []any{lang.NewSymbol("glojure.core/gen-class"), lang.NewKeyword("name"), v91, lang.NewKeyword("impl-ns"), v69, lang.NewKeyword("main"), true, v95}) - v82 = v96 + tmp94 := tmp93.Get() + tmp95 := lang.Apply(tmp94, []any{v81}) + tmp96 := lang.Apply(tmp85, []any{lang.NewSymbol("glojure.core/gen-class"), lang.NewKeyword("name"), tmp91, lang.NewKeyword("impl-ns"), v69, lang.NewKeyword("main"), true, tmp95}) + tmp82 = tmp96 } else { - v82 = nil } - var v97 any = v82 + var v97 any = tmp82 _ = v97 // let binding "references" - v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v99 := v98.FindInternedVar(lang.NewSymbol("remove")) - if v99.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) - } - v100 := v99.Get() - var v101 lang.FnFunc - v101 = lang.NewFnFunc(func(args ...any) any { + tmp98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp99 := tmp98.FindInternedVar(lang.NewSymbol("remove")) + if tmp99.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp99))) + } + tmp100 := tmp99.Get() + var tmp101 lang.FnFunc + tmp101 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v102 := args[0] _ = v102 - v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v104 := v103.FindInternedVar(lang.NewSymbol("=")) - if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) - } - v105 := v104.Get() - v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v107 := v106.FindInternedVar(lang.NewSymbol("first")) - if v107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) - } - v108 := v107.Get() - v109 := lang.Apply(v108, []any{v102}) - v110 := lang.Apply(v105, []any{lang.NewKeyword("gen-class"), v109}) - return v110 + tmp103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp104 := tmp103.FindInternedVar(lang.NewSymbol("=")) + if tmp104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp104))) + } + tmp105 := tmp104.Get() + tmp106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp107 := tmp106.FindInternedVar(lang.NewSymbol("first")) + if tmp107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp107))) + } + tmp108 := tmp107.Get() + tmp109 := lang.Apply(tmp108, []any{v102}) + tmp110 := lang.Apply(tmp105, []any{lang.NewKeyword("gen-class"), tmp109}) + return tmp110 }) - v102 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5784), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(5784), lang.NewKeyword("end-column"), int(52)) - v103, err := lang.WithMeta(v101, v102.(lang.IPersistentMap)) + tmp102 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5784), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(5784), lang.NewKeyword("end-column"), int(52)) + tmp103, err := lang.WithMeta(tmp101, tmp102.(lang.IPersistentMap)) if err != nil { panic(err) } - v104 := lang.Apply(v100, []any{v103, v60}) - var v105 any = v104 + tmp104 := lang.Apply(tmp100, []any{tmp103, v60}) + var v105 any = tmp104 _ = v105 // let binding "name-metadata" - v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v107 := v106.FindInternedVar(lang.NewSymbol("meta")) - if v107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) - } - v108 := v107.Get() - v109 := lang.Apply(v108, []any{v69}) - var v110 any = v109 + tmp106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp107 := tmp106.FindInternedVar(lang.NewSymbol("meta")) + if tmp107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp107))) + } + tmp108 := tmp107.Get() + tmp109 := lang.Apply(tmp108, []any{v69}) + var v110 any = tmp109 _ = v110 - v111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v112 := v111.FindInternedVar(lang.NewSymbol("seq")) - if v112.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v112))) - } - v113 := v112.Get() - v114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v115 := v114.FindInternedVar(lang.NewSymbol("concat")) - if v115.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v115))) - } - v116 := v115.Get() - v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v118 := v117.FindInternedVar(lang.NewSymbol("list")) - if v118.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) - } - v119 := v118.Get() - v120 := lang.Apply(v119, []any{lang.NewSymbol("do")}) - v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v122 := v121.FindInternedVar(lang.NewSymbol("list")) - if v122.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) - } - v123 := v122.Get() - v124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v125 := v124.FindInternedVar(lang.NewSymbol("seq")) - if v125.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v125))) - } - v126 := v125.Get() - v127 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v128 := v127.FindInternedVar(lang.NewSymbol("concat")) - if v128.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v128))) - } - v129 := v128.Get() - v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v131 := v130.FindInternedVar(lang.NewSymbol("list")) - if v131.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) - } - v132 := v131.Get() - v133 := lang.Apply(v132, []any{lang.NewSymbol("glojure.core/in-ns")}) - v134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v135 := v134.FindInternedVar(lang.NewSymbol("list")) - if v135.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v135))) - } - v136 := v135.Get() - v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v138 := v137.FindInternedVar(lang.NewSymbol("seq")) - if v138.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) - } - v139 := v138.Get() - v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v141 := v140.FindInternedVar(lang.NewSymbol("concat")) - if v141.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) - } - v142 := v141.Get() - v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v144 := v143.FindInternedVar(lang.NewSymbol("list")) - if v144.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) - } - v145 := v144.Get() - v146 := lang.Apply(v145, []any{lang.NewSymbol("quote")}) - v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v148 := v147.FindInternedVar(lang.NewSymbol("list")) - if v148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) - } - v149 := v148.Get() - v150 := lang.Apply(v149, []any{v69}) - v151 := lang.Apply(v142, []any{v146, v150}) - v152 := lang.Apply(v139, []any{v151}) - v153 := lang.Apply(v136, []any{v152}) - v154 := lang.Apply(v129, []any{v133, v153}) - v155 := lang.Apply(v126, []any{v154}) - v156 := lang.Apply(v123, []any{v155}) - var v157 any + tmp111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp112 := tmp111.FindInternedVar(lang.NewSymbol("seq")) + if tmp112.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp112))) + } + tmp113 := tmp112.Get() + tmp114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp115 := tmp114.FindInternedVar(lang.NewSymbol("concat")) + if tmp115.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp115))) + } + tmp116 := tmp115.Get() + tmp117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp118 := tmp117.FindInternedVar(lang.NewSymbol("list")) + if tmp118.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp118))) + } + tmp119 := tmp118.Get() + tmp120 := lang.Apply(tmp119, []any{lang.NewSymbol("do")}) + tmp121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp122 := tmp121.FindInternedVar(lang.NewSymbol("list")) + if tmp122.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp122))) + } + tmp123 := tmp122.Get() + tmp124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp125 := tmp124.FindInternedVar(lang.NewSymbol("seq")) + if tmp125.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp125))) + } + tmp126 := tmp125.Get() + tmp127 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp128 := tmp127.FindInternedVar(lang.NewSymbol("concat")) + if tmp128.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp128))) + } + tmp129 := tmp128.Get() + tmp130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp131 := tmp130.FindInternedVar(lang.NewSymbol("list")) + if tmp131.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp131))) + } + tmp132 := tmp131.Get() + tmp133 := lang.Apply(tmp132, []any{lang.NewSymbol("glojure.core/in-ns")}) + tmp134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp135 := tmp134.FindInternedVar(lang.NewSymbol("list")) + if tmp135.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp135))) + } + tmp136 := tmp135.Get() + tmp137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp138 := tmp137.FindInternedVar(lang.NewSymbol("seq")) + if tmp138.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp138))) + } + tmp139 := tmp138.Get() + tmp140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp141 := tmp140.FindInternedVar(lang.NewSymbol("concat")) + if tmp141.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp141))) + } + tmp142 := tmp141.Get() + tmp143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp144 := tmp143.FindInternedVar(lang.NewSymbol("list")) + if tmp144.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp144))) + } + tmp145 := tmp144.Get() + tmp146 := lang.Apply(tmp145, []any{lang.NewSymbol("quote")}) + tmp147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp148 := tmp147.FindInternedVar(lang.NewSymbol("list")) + if tmp148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp148))) + } + tmp149 := tmp148.Get() + tmp150 := lang.Apply(tmp149, []any{v69}) + tmp151 := lang.Apply(tmp142, []any{tmp146, tmp150}) + tmp152 := lang.Apply(tmp139, []any{tmp151}) + tmp153 := lang.Apply(tmp136, []any{tmp152}) + tmp154 := lang.Apply(tmp129, []any{tmp133, tmp153}) + tmp155 := lang.Apply(tmp126, []any{tmp154}) + tmp156 := lang.Apply(tmp123, []any{tmp155}) + var tmp157 any if lang.IsTruthy(v110) { - v158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v159 := v158.FindInternedVar(lang.NewSymbol("seq")) - if v159.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v159))) - } - v160 := v159.Get() - v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v162 := v161.FindInternedVar(lang.NewSymbol("concat")) - if v162.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) - } - v163 := v162.Get() - v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v165 := v164.FindInternedVar(lang.NewSymbol("list")) - if v165.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) - } - v166 := v165.Get() - v167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v168 := v167.FindInternedVar(lang.NewSymbol("seq")) - if v168.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v168))) - } - v169 := v168.Get() - v170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v171 := v170.FindInternedVar(lang.NewSymbol("concat")) - if v171.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v171))) - } - v172 := v171.Get() - v173 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v174 := v173.FindInternedVar(lang.NewSymbol("list")) - if v174.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v174))) - } - v175 := v174.Get() - v176 := lang.Apply(v175, []any{lang.NewSymbol(".ResetMeta")}) - v177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v178 := v177.FindInternedVar(lang.NewSymbol("list")) - if v178.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v178))) - } - v179 := v178.Get() - v180 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v181 := v180.FindInternedVar(lang.NewSymbol("seq")) - if v181.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v181))) - } - v182 := v181.Get() - v183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v184 := v183.FindInternedVar(lang.NewSymbol("concat")) - if v184.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v184))) - } - v185 := v184.Get() - v186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v187 := v186.FindInternedVar(lang.NewSymbol("list")) - if v187.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v187))) - } - v188 := v187.Get() - v189 := lang.Apply(v188, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.FindNamespace")}) - v190 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v191 := v190.FindInternedVar(lang.NewSymbol("list")) - if v191.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v191))) - } - v192 := v191.Get() - v193 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v194 := v193.FindInternedVar(lang.NewSymbol("seq")) - if v194.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v194))) - } - v195 := v194.Get() - v196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v197 := v196.FindInternedVar(lang.NewSymbol("concat")) - if v197.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v197))) - } - v198 := v197.Get() - v199 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v200 := v199.FindInternedVar(lang.NewSymbol("list")) - if v200.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v200))) - } - v201 := v200.Get() - v202 := lang.Apply(v201, []any{lang.NewSymbol("quote")}) - v203 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v204 := v203.FindInternedVar(lang.NewSymbol("list")) - if v204.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v204))) - } - v205 := v204.Get() - v206 := lang.Apply(v205, []any{v69}) - v207 := lang.Apply(v198, []any{v202, v206}) - v208 := lang.Apply(v195, []any{v207}) - v209 := lang.Apply(v192, []any{v208}) - v210 := lang.Apply(v185, []any{v189, v209}) - v211 := lang.Apply(v182, []any{v210}) - v212 := lang.Apply(v179, []any{v211}) - v213 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v214 := v213.FindInternedVar(lang.NewSymbol("list")) - if v214.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v214))) - } - v215 := v214.Get() - v216 := lang.Apply(v215, []any{v110}) - v217 := lang.Apply(v172, []any{v176, v212, v216}) - v218 := lang.Apply(v169, []any{v217}) - v219 := lang.Apply(v166, []any{v218}) - v220 := lang.Apply(v163, []any{v219}) - v221 := lang.Apply(v160, []any{v220}) - v157 = v221 + tmp158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp159 := tmp158.FindInternedVar(lang.NewSymbol("seq")) + if tmp159.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp159))) + } + tmp160 := tmp159.Get() + tmp161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp162 := tmp161.FindInternedVar(lang.NewSymbol("concat")) + if tmp162.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp162))) + } + tmp163 := tmp162.Get() + tmp164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp165 := tmp164.FindInternedVar(lang.NewSymbol("list")) + if tmp165.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp165))) + } + tmp166 := tmp165.Get() + tmp167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp168 := tmp167.FindInternedVar(lang.NewSymbol("seq")) + if tmp168.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp168))) + } + tmp169 := tmp168.Get() + tmp170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp171 := tmp170.FindInternedVar(lang.NewSymbol("concat")) + if tmp171.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp171))) + } + tmp172 := tmp171.Get() + tmp173 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp174 := tmp173.FindInternedVar(lang.NewSymbol("list")) + if tmp174.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp174))) + } + tmp175 := tmp174.Get() + tmp176 := lang.Apply(tmp175, []any{lang.NewSymbol(".ResetMeta")}) + tmp177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp178 := tmp177.FindInternedVar(lang.NewSymbol("list")) + if tmp178.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp178))) + } + tmp179 := tmp178.Get() + tmp180 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp181 := tmp180.FindInternedVar(lang.NewSymbol("seq")) + if tmp181.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp181))) + } + tmp182 := tmp181.Get() + tmp183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp184 := tmp183.FindInternedVar(lang.NewSymbol("concat")) + if tmp184.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp184))) + } + tmp185 := tmp184.Get() + tmp186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp187 := tmp186.FindInternedVar(lang.NewSymbol("list")) + if tmp187.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp187))) + } + tmp188 := tmp187.Get() + tmp189 := lang.Apply(tmp188, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.FindNamespace")}) + tmp190 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp191 := tmp190.FindInternedVar(lang.NewSymbol("list")) + if tmp191.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp191))) + } + tmp192 := tmp191.Get() + tmp193 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp194 := tmp193.FindInternedVar(lang.NewSymbol("seq")) + if tmp194.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp194))) + } + tmp195 := tmp194.Get() + tmp196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp197 := tmp196.FindInternedVar(lang.NewSymbol("concat")) + if tmp197.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp197))) + } + tmp198 := tmp197.Get() + tmp199 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp200 := tmp199.FindInternedVar(lang.NewSymbol("list")) + if tmp200.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp200))) + } + tmp201 := tmp200.Get() + tmp202 := lang.Apply(tmp201, []any{lang.NewSymbol("quote")}) + tmp203 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp204 := tmp203.FindInternedVar(lang.NewSymbol("list")) + if tmp204.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp204))) + } + tmp205 := tmp204.Get() + tmp206 := lang.Apply(tmp205, []any{v69}) + tmp207 := lang.Apply(tmp198, []any{tmp202, tmp206}) + tmp208 := lang.Apply(tmp195, []any{tmp207}) + tmp209 := lang.Apply(tmp192, []any{tmp208}) + tmp210 := lang.Apply(tmp185, []any{tmp189, tmp209}) + tmp211 := lang.Apply(tmp182, []any{tmp210}) + tmp212 := lang.Apply(tmp179, []any{tmp211}) + tmp213 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp214 := tmp213.FindInternedVar(lang.NewSymbol("list")) + if tmp214.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp214))) + } + tmp215 := tmp214.Get() + tmp216 := lang.Apply(tmp215, []any{v110}) + tmp217 := lang.Apply(tmp172, []any{tmp176, tmp212, tmp216}) + tmp218 := lang.Apply(tmp169, []any{tmp217}) + tmp219 := lang.Apply(tmp166, []any{tmp218}) + tmp220 := lang.Apply(tmp163, []any{tmp219}) + tmp221 := lang.Apply(tmp160, []any{tmp220}) + tmp157 = tmp221 } else { - v157 = nil - } - v222 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v223 := v222.FindInternedVar(lang.NewSymbol("list")) - if v223.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v223))) - } - v224 := v223.Get() - v225 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v226 := v225.FindInternedVar(lang.NewSymbol("seq")) - if v226.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v226))) - } - v227 := v226.Get() - v228 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v229 := v228.FindInternedVar(lang.NewSymbol("concat")) - if v229.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v229))) - } - v230 := v229.Get() - v231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v232 := v231.FindInternedVar(lang.NewSymbol("list")) - if v232.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v232))) - } - v233 := v232.Get() - v234 := lang.Apply(v233, []any{lang.NewSymbol("glojure.core/with-loading-context")}) - var v235 any + } + tmp222 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp223 := tmp222.FindInternedVar(lang.NewSymbol("list")) + if tmp223.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp223))) + } + tmp224 := tmp223.Get() + tmp225 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp226 := tmp225.FindInternedVar(lang.NewSymbol("seq")) + if tmp226.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp226))) + } + tmp227 := tmp226.Get() + tmp228 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp229 := tmp228.FindInternedVar(lang.NewSymbol("concat")) + if tmp229.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp229))) + } + tmp230 := tmp229.Get() + tmp231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp232 := tmp231.FindInternedVar(lang.NewSymbol("list")) + if tmp232.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp232))) + } + tmp233 := tmp232.Get() + tmp234 := lang.Apply(tmp233, []any{lang.NewSymbol("glojure.core/with-loading-context")}) + var tmp235 any if lang.IsTruthy(v97) { - v236 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v237 := v236.FindInternedVar(lang.NewSymbol("list")) - if v237.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v237))) - } - v238 := v237.Get() - v239 := lang.Apply(v238, []any{v97}) - v235 = v239 + tmp236 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp237 := tmp236.FindInternedVar(lang.NewSymbol("list")) + if tmp237.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp237))) + } + tmp238 := tmp237.Get() + tmp239 := lang.Apply(tmp238, []any{v97}) + tmp235 = tmp239 } else { - v235 = nil } - var v240 any - var v241 any + var tmp240 any + var tmp241 any { // let // let binding "and__0__auto__" - v242 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v243 := v242.FindInternedVar(lang.NewSymbol("not=")) - if v243.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v243))) - } - v244 := v243.Get() - v245 := lang.Apply(v244, []any{v69, lang.NewSymbol("glojure.core")}) - var v246 any = v245 + tmp242 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp243 := tmp242.FindInternedVar(lang.NewSymbol("not=")) + if tmp243.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp243))) + } + tmp244 := tmp243.Get() + tmp245 := lang.Apply(tmp244, []any{v69, lang.NewSymbol("glojure.core")}) + var v246 any = tmp245 _ = v246 - var v247 any + var tmp247 any if lang.IsTruthy(v246) { - v248 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v249 := v248.FindInternedVar(lang.NewSymbol("not-any?")) - if v249.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v249))) - } - v250 := v249.Get() - var v251 lang.FnFunc - v251 = lang.NewFnFunc(func(args ...any) any { + tmp248 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp249 := tmp248.FindInternedVar(lang.NewSymbol("not-any?")) + if tmp249.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp249))) + } + tmp250 := tmp249.Get() + var tmp251 lang.FnFunc + tmp251 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v252 := args[0] _ = v252 - v253 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v254 := v253.FindInternedVar(lang.NewSymbol("=")) - if v254.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v254))) + tmp253 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp254 := tmp253.FindInternedVar(lang.NewSymbol("=")) + if tmp254.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp254))) } - v255 := v254.Get() - v256 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v257 := v256.FindInternedVar(lang.NewSymbol("first")) - if v257.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v257))) + tmp255 := tmp254.Get() + tmp256 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp257 := tmp256.FindInternedVar(lang.NewSymbol("first")) + if tmp257.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp257))) } - v258 := v257.Get() - v259 := lang.Apply(v258, []any{v252}) - v260 := lang.Apply(v255, []any{lang.NewKeyword("refer-glojure"), v259}) - return v260 + tmp258 := tmp257.Get() + tmp259 := lang.Apply(tmp258, []any{v252}) + tmp260 := lang.Apply(tmp255, []any{lang.NewKeyword("refer-glojure"), tmp259}) + return tmp260 }) - v252 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5793), lang.NewKeyword("column"), int(58), lang.NewKeyword("end-line"), int(5793), lang.NewKeyword("end-column"), int(86)) - v253, err := lang.WithMeta(v251, v252.(lang.IPersistentMap)) + tmp252 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5793), lang.NewKeyword("column"), int(58), lang.NewKeyword("end-line"), int(5793), lang.NewKeyword("end-column"), int(86)) + tmp253, err := lang.WithMeta(tmp251, tmp252.(lang.IPersistentMap)) if err != nil { panic(err) } - v254 := lang.Apply(v250, []any{v253, v105}) - v247 = v254 + tmp254 := lang.Apply(tmp250, []any{tmp253, v105}) + tmp247 = tmp254 } else { - v247 = v246 + tmp247 = v246 } - v241 = v247 + tmp241 = tmp247 } // end let - if lang.IsTruthy(v241) { - v242 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v243 := v242.FindInternedVar(lang.NewSymbol("seq")) - if v243.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v243))) - } - v244 := v243.Get() - v245 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v246 := v245.FindInternedVar(lang.NewSymbol("concat")) - if v246.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v246))) - } - v247 := v246.Get() - v248 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v249 := v248.FindInternedVar(lang.NewSymbol("list")) - if v249.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v249))) - } - v250 := v249.Get() - v251 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v252 := v251.FindInternedVar(lang.NewSymbol("seq")) - if v252.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v252))) - } - v253 := v252.Get() - v254 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v255 := v254.FindInternedVar(lang.NewSymbol("concat")) - if v255.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v255))) - } - v256 := v255.Get() - v257 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v258 := v257.FindInternedVar(lang.NewSymbol("list")) - if v258.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v258))) - } - v259 := v258.Get() - v260 := lang.Apply(v259, []any{lang.NewSymbol("glojure.core/refer")}) - v261 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v262 := v261.FindInternedVar(lang.NewSymbol("list")) - if v262.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v262))) - } - v263 := v262.Get() - v264 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v265 := v264.FindInternedVar(lang.NewSymbol("seq")) - if v265.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v265))) - } - v266 := v265.Get() - v267 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v268 := v267.FindInternedVar(lang.NewSymbol("concat")) - if v268.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v268))) - } - v269 := v268.Get() - v270 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v271 := v270.FindInternedVar(lang.NewSymbol("list")) - if v271.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v271))) - } - v272 := v271.Get() - v273 := lang.Apply(v272, []any{lang.NewSymbol("quote")}) - v274 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v275 := v274.FindInternedVar(lang.NewSymbol("list")) - if v275.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v275))) - } - v276 := v275.Get() - v277 := lang.Apply(v276, []any{lang.NewSymbol("glojure.core")}) - v278 := lang.Apply(v269, []any{v273, v277}) - v279 := lang.Apply(v266, []any{v278}) - v280 := lang.Apply(v263, []any{v279}) - v281 := lang.Apply(v256, []any{v260, v280}) - v282 := lang.Apply(v253, []any{v281}) - v283 := lang.Apply(v250, []any{v282}) - v284 := lang.Apply(v247, []any{v283}) - v285 := lang.Apply(v244, []any{v284}) - v240 = v285 + if lang.IsTruthy(tmp241) { + tmp242 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp243 := tmp242.FindInternedVar(lang.NewSymbol("seq")) + if tmp243.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp243))) + } + tmp244 := tmp243.Get() + tmp245 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp246 := tmp245.FindInternedVar(lang.NewSymbol("concat")) + if tmp246.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp246))) + } + tmp247 := tmp246.Get() + tmp248 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp249 := tmp248.FindInternedVar(lang.NewSymbol("list")) + if tmp249.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp249))) + } + tmp250 := tmp249.Get() + tmp251 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp252 := tmp251.FindInternedVar(lang.NewSymbol("seq")) + if tmp252.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp252))) + } + tmp253 := tmp252.Get() + tmp254 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp255 := tmp254.FindInternedVar(lang.NewSymbol("concat")) + if tmp255.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp255))) + } + tmp256 := tmp255.Get() + tmp257 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp258 := tmp257.FindInternedVar(lang.NewSymbol("list")) + if tmp258.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp258))) + } + tmp259 := tmp258.Get() + tmp260 := lang.Apply(tmp259, []any{lang.NewSymbol("glojure.core/refer")}) + tmp261 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp262 := tmp261.FindInternedVar(lang.NewSymbol("list")) + if tmp262.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp262))) + } + tmp263 := tmp262.Get() + tmp264 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp265 := tmp264.FindInternedVar(lang.NewSymbol("seq")) + if tmp265.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp265))) + } + tmp266 := tmp265.Get() + tmp267 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp268 := tmp267.FindInternedVar(lang.NewSymbol("concat")) + if tmp268.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp268))) + } + tmp269 := tmp268.Get() + tmp270 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp271 := tmp270.FindInternedVar(lang.NewSymbol("list")) + if tmp271.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp271))) + } + tmp272 := tmp271.Get() + tmp273 := lang.Apply(tmp272, []any{lang.NewSymbol("quote")}) + tmp274 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp275 := tmp274.FindInternedVar(lang.NewSymbol("list")) + if tmp275.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp275))) + } + tmp276 := tmp275.Get() + tmp277 := lang.Apply(tmp276, []any{lang.NewSymbol("glojure.core")}) + tmp278 := lang.Apply(tmp269, []any{tmp273, tmp277}) + tmp279 := lang.Apply(tmp266, []any{tmp278}) + tmp280 := lang.Apply(tmp263, []any{tmp279}) + tmp281 := lang.Apply(tmp256, []any{tmp260, tmp280}) + tmp282 := lang.Apply(tmp253, []any{tmp281}) + tmp283 := lang.Apply(tmp250, []any{tmp282}) + tmp284 := lang.Apply(tmp247, []any{tmp283}) + tmp285 := lang.Apply(tmp244, []any{tmp284}) + tmp240 = tmp285 } else { - v240 = nil - } - v286 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v287 := v286.FindInternedVar(lang.NewSymbol("map")) - if v287.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v287))) - } - v288 := v287.Get() - v289 := lang.Apply(v288, []any{v11, v105}) - v290 := lang.Apply(v230, []any{v234, v235, v240, v289}) - v291 := lang.Apply(v227, []any{v290}) - v292 := lang.Apply(v224, []any{v291}) - v293 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v294 := v293.FindInternedVar(lang.NewSymbol("list")) - if v294.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v294))) - } - v295 := v294.Get() - v296 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v297 := v296.FindInternedVar(lang.NewSymbol("seq")) - if v297.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v297))) - } - v298 := v297.Get() - v299 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v300 := v299.FindInternedVar(lang.NewSymbol("concat")) - if v300.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v300))) - } - v301 := v300.Get() - v302 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v303 := v302.FindInternedVar(lang.NewSymbol("list")) - if v303.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v303))) - } - v304 := v303.Get() - v305 := lang.Apply(v304, []any{lang.NewSymbol("if")}) - v306 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v307 := v306.FindInternedVar(lang.NewSymbol("list")) - if v307.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v307))) - } - v308 := v307.Get() - v309 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v310 := v309.FindInternedVar(lang.NewSymbol("seq")) - if v310.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v310))) - } - v311 := v310.Get() - v312 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v313 := v312.FindInternedVar(lang.NewSymbol("concat")) - if v313.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v313))) - } - v314 := v313.Get() - v315 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v316 := v315.FindInternedVar(lang.NewSymbol("list")) - if v316.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v316))) - } - v317 := v316.Get() - v318 := lang.Apply(v317, []any{lang.NewSymbol(".Equals")}) - v319 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v320 := v319.FindInternedVar(lang.NewSymbol("list")) - if v320.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v320))) - } - v321 := v320.Get() - v322 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v323 := v322.FindInternedVar(lang.NewSymbol("seq")) - if v323.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v323))) - } - v324 := v323.Get() - v325 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v326 := v325.FindInternedVar(lang.NewSymbol("concat")) - if v326.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v326))) - } - v327 := v326.Get() - v328 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v329 := v328.FindInternedVar(lang.NewSymbol("list")) - if v329.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v329))) - } - v330 := v329.Get() - v331 := lang.Apply(v330, []any{lang.NewSymbol("quote")}) - v332 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v333 := v332.FindInternedVar(lang.NewSymbol("list")) - if v333.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v333))) - } - v334 := v333.Get() - v335 := lang.Apply(v334, []any{v69}) - v336 := lang.Apply(v327, []any{v331, v335}) - v337 := lang.Apply(v324, []any{v336}) - v338 := lang.Apply(v321, []any{v337}) - v339 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v340 := v339.FindInternedVar(lang.NewSymbol("list")) - if v340.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v340))) - } - v341 := v340.Get() - v342 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v343 := v342.FindInternedVar(lang.NewSymbol("seq")) - if v343.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v343))) - } - v344 := v343.Get() - v345 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v346 := v345.FindInternedVar(lang.NewSymbol("concat")) - if v346.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v346))) - } - v347 := v346.Get() - v348 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v349 := v348.FindInternedVar(lang.NewSymbol("list")) - if v349.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v349))) - } - v350 := v349.Get() - v351 := lang.Apply(v350, []any{lang.NewSymbol("quote")}) - v352 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v353 := v352.FindInternedVar(lang.NewSymbol("list")) - if v353.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v353))) - } - v354 := v353.Get() - v355 := lang.Apply(v354, []any{lang.NewSymbol("glojure.core")}) - v356 := lang.Apply(v347, []any{v351, v355}) - v357 := lang.Apply(v344, []any{v356}) - v358 := lang.Apply(v341, []any{v357}) - v359 := lang.Apply(v314, []any{v318, v338, v358}) - v360 := lang.Apply(v311, []any{v359}) - v361 := lang.Apply(v308, []any{v360}) - v362 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v363 := v362.FindInternedVar(lang.NewSymbol("list")) - if v363.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v363))) - } - v364 := v363.Get() - v365 := lang.Apply(v364, []any{nil}) - v366 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v367 := v366.FindInternedVar(lang.NewSymbol("list")) - if v367.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v367))) - } - v368 := v367.Get() - v369 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v370 := v369.FindInternedVar(lang.NewSymbol("seq")) - if v370.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v370))) - } - v371 := v370.Get() - v372 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v373 := v372.FindInternedVar(lang.NewSymbol("concat")) - if v373.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v373))) - } - v374 := v373.Get() - v375 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v376 := v375.FindInternedVar(lang.NewSymbol("list")) - if v376.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v376))) - } - v377 := v376.Get() - v378 := lang.Apply(v377, []any{lang.NewSymbol("do")}) - v379 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v380 := v379.FindInternedVar(lang.NewSymbol("list")) - if v380.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v380))) - } - v381 := v380.Get() - v382 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v383 := v382.FindInternedVar(lang.NewSymbol("seq")) - if v383.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v383))) - } - v384 := v383.Get() - v385 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v386 := v385.FindInternedVar(lang.NewSymbol("concat")) - if v386.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v386))) - } - v387 := v386.Get() - v388 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v389 := v388.FindInternedVar(lang.NewSymbol("list")) - if v389.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v389))) - } - v390 := v389.Get() - v391 := lang.Apply(v390, []any{lang.NewSymbol("glojure.core/dosync")}) - v392 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v393 := v392.FindInternedVar(lang.NewSymbol("list")) - if v393.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v393))) - } - v394 := v393.Get() - v395 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v396 := v395.FindInternedVar(lang.NewSymbol("seq")) - if v396.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v396))) - } - v397 := v396.Get() - v398 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v399 := v398.FindInternedVar(lang.NewSymbol("concat")) - if v399.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v399))) - } - v400 := v399.Get() - v401 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v402 := v401.FindInternedVar(lang.NewSymbol("list")) - if v402.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v402))) - } - v403 := v402.Get() - v404 := lang.Apply(v403, []any{lang.NewSymbol("glojure.core/commute")}) - v405 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v406 := v405.FindInternedVar(lang.NewSymbol("list")) - if v406.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v406))) - } - v407 := v406.Get() - v408 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v409 := v408.FindInternedVar(lang.NewSymbol("seq")) - if v409.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v409))) - } - v410 := v409.Get() - v411 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v412 := v411.FindInternedVar(lang.NewSymbol("concat")) - if v412.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v412))) - } - v413 := v412.Get() - v414 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v415 := v414.FindInternedVar(lang.NewSymbol("list")) - if v415.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v415))) - } - v416 := v415.Get() - v417 := lang.Apply(v416, []any{lang.NewSymbol("glojure.core/deref")}) - v418 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v419 := v418.FindInternedVar(lang.NewSymbol("list")) - if v419.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v419))) - } - v420 := v419.Get() - v421 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v422 := v421.FindInternedVar(lang.NewSymbol("seq")) - if v422.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v422))) - } - v423 := v422.Get() - v424 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v425 := v424.FindInternedVar(lang.NewSymbol("concat")) - if v425.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v425))) - } - v426 := v425.Get() - v427 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v428 := v427.FindInternedVar(lang.NewSymbol("list")) - if v428.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v428))) - } - v429 := v428.Get() - v430 := lang.Apply(v429, []any{lang.NewSymbol("var")}) - v431 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v432 := v431.FindInternedVar(lang.NewSymbol("list")) - if v432.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v432))) - } - v433 := v432.Get() - v434 := lang.Apply(v433, []any{lang.NewSymbol("glojure.core/*loaded-libs*")}) - v435 := lang.Apply(v426, []any{v430, v434}) - v436 := lang.Apply(v423, []any{v435}) - v437 := lang.Apply(v420, []any{v436}) - v438 := lang.Apply(v413, []any{v417, v437}) - v439 := lang.Apply(v410, []any{v438}) - v440 := lang.Apply(v407, []any{v439}) - v441 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v442 := v441.FindInternedVar(lang.NewSymbol("list")) - if v442.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v442))) - } - v443 := v442.Get() - v444 := lang.Apply(v443, []any{lang.NewSymbol("glojure.core/conj")}) - v445 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v446 := v445.FindInternedVar(lang.NewSymbol("list")) - if v446.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v446))) - } - v447 := v446.Get() - v448 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v449 := v448.FindInternedVar(lang.NewSymbol("seq")) - if v449.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v449))) - } - v450 := v449.Get() - v451 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v452 := v451.FindInternedVar(lang.NewSymbol("concat")) - if v452.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v452))) - } - v453 := v452.Get() - v454 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v455 := v454.FindInternedVar(lang.NewSymbol("list")) - if v455.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v455))) - } - v456 := v455.Get() - v457 := lang.Apply(v456, []any{lang.NewSymbol("quote")}) - v458 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v459 := v458.FindInternedVar(lang.NewSymbol("list")) - if v459.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v459))) - } - v460 := v459.Get() - v461 := lang.Apply(v460, []any{v69}) - v462 := lang.Apply(v453, []any{v457, v461}) - v463 := lang.Apply(v450, []any{v462}) - v464 := lang.Apply(v447, []any{v463}) - v465 := lang.Apply(v400, []any{v404, v440, v444, v464}) - v466 := lang.Apply(v397, []any{v465}) - v467 := lang.Apply(v394, []any{v466}) - v468 := lang.Apply(v387, []any{v391, v467}) - v469 := lang.Apply(v384, []any{v468}) - v470 := lang.Apply(v381, []any{v469}) - v471 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v472 := v471.FindInternedVar(lang.NewSymbol("list")) - if v472.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v472))) - } - v473 := v472.Get() - v474 := lang.Apply(v473, []any{nil}) - v475 := lang.Apply(v374, []any{v378, v470, v474}) - v476 := lang.Apply(v371, []any{v475}) - v477 := lang.Apply(v368, []any{v476}) - v478 := lang.Apply(v301, []any{v305, v361, v365, v477}) - v479 := lang.Apply(v298, []any{v478}) - v480 := lang.Apply(v295, []any{v479}) - v481 := lang.Apply(v116, []any{v120, v156, v157, v292, v480}) - v482 := lang.Apply(v113, []any{v481}) - v7 = v482 + } + tmp286 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp287 := tmp286.FindInternedVar(lang.NewSymbol("map")) + if tmp287.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp287))) + } + tmp288 := tmp287.Get() + tmp289 := lang.Apply(tmp288, []any{v11, v105}) + tmp290 := lang.Apply(tmp230, []any{tmp234, tmp235, tmp240, tmp289}) + tmp291 := lang.Apply(tmp227, []any{tmp290}) + tmp292 := lang.Apply(tmp224, []any{tmp291}) + tmp293 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp294 := tmp293.FindInternedVar(lang.NewSymbol("list")) + if tmp294.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp294))) + } + tmp295 := tmp294.Get() + tmp296 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp297 := tmp296.FindInternedVar(lang.NewSymbol("seq")) + if tmp297.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp297))) + } + tmp298 := tmp297.Get() + tmp299 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp300 := tmp299.FindInternedVar(lang.NewSymbol("concat")) + if tmp300.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp300))) + } + tmp301 := tmp300.Get() + tmp302 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp303 := tmp302.FindInternedVar(lang.NewSymbol("list")) + if tmp303.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp303))) + } + tmp304 := tmp303.Get() + tmp305 := lang.Apply(tmp304, []any{lang.NewSymbol("if")}) + tmp306 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp307 := tmp306.FindInternedVar(lang.NewSymbol("list")) + if tmp307.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp307))) + } + tmp308 := tmp307.Get() + tmp309 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp310 := tmp309.FindInternedVar(lang.NewSymbol("seq")) + if tmp310.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp310))) + } + tmp311 := tmp310.Get() + tmp312 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp313 := tmp312.FindInternedVar(lang.NewSymbol("concat")) + if tmp313.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp313))) + } + tmp314 := tmp313.Get() + tmp315 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp316 := tmp315.FindInternedVar(lang.NewSymbol("list")) + if tmp316.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp316))) + } + tmp317 := tmp316.Get() + tmp318 := lang.Apply(tmp317, []any{lang.NewSymbol(".Equals")}) + tmp319 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp320 := tmp319.FindInternedVar(lang.NewSymbol("list")) + if tmp320.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp320))) + } + tmp321 := tmp320.Get() + tmp322 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp323 := tmp322.FindInternedVar(lang.NewSymbol("seq")) + if tmp323.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp323))) + } + tmp324 := tmp323.Get() + tmp325 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp326 := tmp325.FindInternedVar(lang.NewSymbol("concat")) + if tmp326.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp326))) + } + tmp327 := tmp326.Get() + tmp328 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp329 := tmp328.FindInternedVar(lang.NewSymbol("list")) + if tmp329.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp329))) + } + tmp330 := tmp329.Get() + tmp331 := lang.Apply(tmp330, []any{lang.NewSymbol("quote")}) + tmp332 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp333 := tmp332.FindInternedVar(lang.NewSymbol("list")) + if tmp333.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp333))) + } + tmp334 := tmp333.Get() + tmp335 := lang.Apply(tmp334, []any{v69}) + tmp336 := lang.Apply(tmp327, []any{tmp331, tmp335}) + tmp337 := lang.Apply(tmp324, []any{tmp336}) + tmp338 := lang.Apply(tmp321, []any{tmp337}) + tmp339 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp340 := tmp339.FindInternedVar(lang.NewSymbol("list")) + if tmp340.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp340))) + } + tmp341 := tmp340.Get() + tmp342 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp343 := tmp342.FindInternedVar(lang.NewSymbol("seq")) + if tmp343.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp343))) + } + tmp344 := tmp343.Get() + tmp345 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp346 := tmp345.FindInternedVar(lang.NewSymbol("concat")) + if tmp346.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp346))) + } + tmp347 := tmp346.Get() + tmp348 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp349 := tmp348.FindInternedVar(lang.NewSymbol("list")) + if tmp349.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp349))) + } + tmp350 := tmp349.Get() + tmp351 := lang.Apply(tmp350, []any{lang.NewSymbol("quote")}) + tmp352 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp353 := tmp352.FindInternedVar(lang.NewSymbol("list")) + if tmp353.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp353))) + } + tmp354 := tmp353.Get() + tmp355 := lang.Apply(tmp354, []any{lang.NewSymbol("glojure.core")}) + tmp356 := lang.Apply(tmp347, []any{tmp351, tmp355}) + tmp357 := lang.Apply(tmp344, []any{tmp356}) + tmp358 := lang.Apply(tmp341, []any{tmp357}) + tmp359 := lang.Apply(tmp314, []any{tmp318, tmp338, tmp358}) + tmp360 := lang.Apply(tmp311, []any{tmp359}) + tmp361 := lang.Apply(tmp308, []any{tmp360}) + tmp362 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp363 := tmp362.FindInternedVar(lang.NewSymbol("list")) + if tmp363.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp363))) + } + tmp364 := tmp363.Get() + tmp365 := lang.Apply(tmp364, []any{nil}) + tmp366 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp367 := tmp366.FindInternedVar(lang.NewSymbol("list")) + if tmp367.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp367))) + } + tmp368 := tmp367.Get() + tmp369 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp370 := tmp369.FindInternedVar(lang.NewSymbol("seq")) + if tmp370.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp370))) + } + tmp371 := tmp370.Get() + tmp372 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp373 := tmp372.FindInternedVar(lang.NewSymbol("concat")) + if tmp373.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp373))) + } + tmp374 := tmp373.Get() + tmp375 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp376 := tmp375.FindInternedVar(lang.NewSymbol("list")) + if tmp376.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp376))) + } + tmp377 := tmp376.Get() + tmp378 := lang.Apply(tmp377, []any{lang.NewSymbol("do")}) + tmp379 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp380 := tmp379.FindInternedVar(lang.NewSymbol("list")) + if tmp380.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp380))) + } + tmp381 := tmp380.Get() + tmp382 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp383 := tmp382.FindInternedVar(lang.NewSymbol("seq")) + if tmp383.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp383))) + } + tmp384 := tmp383.Get() + tmp385 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp386 := tmp385.FindInternedVar(lang.NewSymbol("concat")) + if tmp386.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp386))) + } + tmp387 := tmp386.Get() + tmp388 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp389 := tmp388.FindInternedVar(lang.NewSymbol("list")) + if tmp389.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp389))) + } + tmp390 := tmp389.Get() + tmp391 := lang.Apply(tmp390, []any{lang.NewSymbol("glojure.core/dosync")}) + tmp392 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp393 := tmp392.FindInternedVar(lang.NewSymbol("list")) + if tmp393.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp393))) + } + tmp394 := tmp393.Get() + tmp395 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp396 := tmp395.FindInternedVar(lang.NewSymbol("seq")) + if tmp396.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp396))) + } + tmp397 := tmp396.Get() + tmp398 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp399 := tmp398.FindInternedVar(lang.NewSymbol("concat")) + if tmp399.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp399))) + } + tmp400 := tmp399.Get() + tmp401 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp402 := tmp401.FindInternedVar(lang.NewSymbol("list")) + if tmp402.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp402))) + } + tmp403 := tmp402.Get() + tmp404 := lang.Apply(tmp403, []any{lang.NewSymbol("glojure.core/commute")}) + tmp405 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp406 := tmp405.FindInternedVar(lang.NewSymbol("list")) + if tmp406.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp406))) + } + tmp407 := tmp406.Get() + tmp408 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp409 := tmp408.FindInternedVar(lang.NewSymbol("seq")) + if tmp409.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp409))) + } + tmp410 := tmp409.Get() + tmp411 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp412 := tmp411.FindInternedVar(lang.NewSymbol("concat")) + if tmp412.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp412))) + } + tmp413 := tmp412.Get() + tmp414 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp415 := tmp414.FindInternedVar(lang.NewSymbol("list")) + if tmp415.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp415))) + } + tmp416 := tmp415.Get() + tmp417 := lang.Apply(tmp416, []any{lang.NewSymbol("glojure.core/deref")}) + tmp418 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp419 := tmp418.FindInternedVar(lang.NewSymbol("list")) + if tmp419.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp419))) + } + tmp420 := tmp419.Get() + tmp421 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp422 := tmp421.FindInternedVar(lang.NewSymbol("seq")) + if tmp422.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp422))) + } + tmp423 := tmp422.Get() + tmp424 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp425 := tmp424.FindInternedVar(lang.NewSymbol("concat")) + if tmp425.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp425))) + } + tmp426 := tmp425.Get() + tmp427 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp428 := tmp427.FindInternedVar(lang.NewSymbol("list")) + if tmp428.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp428))) + } + tmp429 := tmp428.Get() + tmp430 := lang.Apply(tmp429, []any{lang.NewSymbol("var")}) + tmp431 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp432 := tmp431.FindInternedVar(lang.NewSymbol("list")) + if tmp432.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp432))) + } + tmp433 := tmp432.Get() + tmp434 := lang.Apply(tmp433, []any{lang.NewSymbol("glojure.core/*loaded-libs*")}) + tmp435 := lang.Apply(tmp426, []any{tmp430, tmp434}) + tmp436 := lang.Apply(tmp423, []any{tmp435}) + tmp437 := lang.Apply(tmp420, []any{tmp436}) + tmp438 := lang.Apply(tmp413, []any{tmp417, tmp437}) + tmp439 := lang.Apply(tmp410, []any{tmp438}) + tmp440 := lang.Apply(tmp407, []any{tmp439}) + tmp441 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp442 := tmp441.FindInternedVar(lang.NewSymbol("list")) + if tmp442.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp442))) + } + tmp443 := tmp442.Get() + tmp444 := lang.Apply(tmp443, []any{lang.NewSymbol("glojure.core/conj")}) + tmp445 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp446 := tmp445.FindInternedVar(lang.NewSymbol("list")) + if tmp446.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp446))) + } + tmp447 := tmp446.Get() + tmp448 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp449 := tmp448.FindInternedVar(lang.NewSymbol("seq")) + if tmp449.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp449))) + } + tmp450 := tmp449.Get() + tmp451 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp452 := tmp451.FindInternedVar(lang.NewSymbol("concat")) + if tmp452.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp452))) + } + tmp453 := tmp452.Get() + tmp454 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp455 := tmp454.FindInternedVar(lang.NewSymbol("list")) + if tmp455.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp455))) + } + tmp456 := tmp455.Get() + tmp457 := lang.Apply(tmp456, []any{lang.NewSymbol("quote")}) + tmp458 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp459 := tmp458.FindInternedVar(lang.NewSymbol("list")) + if tmp459.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp459))) + } + tmp460 := tmp459.Get() + tmp461 := lang.Apply(tmp460, []any{v69}) + tmp462 := lang.Apply(tmp453, []any{tmp457, tmp461}) + tmp463 := lang.Apply(tmp450, []any{tmp462}) + tmp464 := lang.Apply(tmp447, []any{tmp463}) + tmp465 := lang.Apply(tmp400, []any{tmp404, tmp440, tmp444, tmp464}) + tmp466 := lang.Apply(tmp397, []any{tmp465}) + tmp467 := lang.Apply(tmp394, []any{tmp466}) + tmp468 := lang.Apply(tmp387, []any{tmp391, tmp467}) + tmp469 := lang.Apply(tmp384, []any{tmp468}) + tmp470 := lang.Apply(tmp381, []any{tmp469}) + tmp471 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp472 := tmp471.FindInternedVar(lang.NewSymbol("list")) + if tmp472.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp472))) + } + tmp473 := tmp472.Get() + tmp474 := lang.Apply(tmp473, []any{nil}) + tmp475 := lang.Apply(tmp374, []any{tmp378, tmp470, tmp474}) + tmp476 := lang.Apply(tmp371, []any{tmp475}) + tmp477 := lang.Apply(tmp368, []any{tmp476}) + tmp478 := lang.Apply(tmp301, []any{tmp305, tmp361, tmp365, tmp477}) + tmp479 := lang.Apply(tmp298, []any{tmp478}) + tmp480 := lang.Apply(tmp295, []any{tmp479}) + tmp481 := lang.Apply(tmp116, []any{tmp120, tmp156, tmp157, tmp292, tmp480}) + tmp482 := lang.Apply(tmp113, []any{tmp481}) + tmp7 = tmp482 } // end let - return v7 + return tmp7 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // ns-aliases { - v0 := lang.NewSymbol("ns-aliases").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of the aliases for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4273), lang.NewKeyword("end-line"), int(4273))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("ns-aliases").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of the aliases for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4273), lang.NewKeyword("end-line"), int(4273))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("the-ns")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.Apply(v6, []any{v3}) - v8, ok := lang.FieldOrMethod(v7, "getAliases") + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("the-ns")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.Apply(tmp6, []any{v3}) + tmp8, ok := lang.FieldOrMethod(tmp7, "getAliases") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "getAliases"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp7, "getAliases"))) } - var v9 any - switch reflect.TypeOf(v8).Kind() { + var tmp9 any + switch reflect.TypeOf(tmp8).Kind() { case reflect.Func: - v9 = lang.Apply(v8, nil) + tmp9 = lang.Apply(tmp8, nil) default: - v9 = v8 + tmp9 = tmp8 } - return v9 + return tmp9 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // ns-imports { - v0 := lang.NewSymbol("ns-imports").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of the import mappings for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4199), lang.NewKeyword("end-line"), int(4199))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("ns-imports").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of the import mappings for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4199), lang.NewKeyword("end-line"), int(4199))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("filter-key")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("val")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("partial")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("instance?")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.Apply(v12, []any{v15, reflect.Type}) - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("ns-map")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.Apply(v19, []any{v3}) - v21 := lang.Apply(v6, []any{v9, v16, v20}) - return v21 - }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("filter-key")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("val")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("partial")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("instance?")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := reflect.TypeOf((*reflect.Type)(nil)).Elem() + tmp17 := lang.Apply(tmp12, []any{tmp15, tmp16}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("ns-map")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.Apply(tmp20, []any{v3}) + tmp22 := lang.Apply(tmp6, []any{tmp9, tmp17, tmp21}) + return tmp22 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // ns-interns { - v0 := lang.NewSymbol("ns-interns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of the intern mappings for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4206), lang.NewKeyword("end-line"), int(4206))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("ns-interns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of the intern mappings for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4206), lang.NewKeyword("end-line"), int(4206))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any + var tmp4 any { // let // let binding "ns" - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("the-ns")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v3}) - var v9 any = v8 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("the-ns")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v3}) + var v9 any = tmp8 _ = v9 - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("filter-key")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("val")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - var v16 lang.FnFunc - v16 = lang.NewFnFunc(func(args ...any) any { + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("filter-key")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("val")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + var tmp16 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v17 := args[0] _ = v17 - var v18 any + var tmp18 any { // let // let binding "and__0__auto__" - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("instance?")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{*lang.Var, v17}) - var v23 any = v22 - _ = v23 - var v24 any - if lang.IsTruthy(v23) { - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("=")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("instance?")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := reflect.TypeOf((*lang.Var)(nil)) + tmp23 := lang.Apply(tmp21, []any{tmp22, v17}) + var v24 any = tmp23 + _ = v24 + var tmp25 any + if lang.IsTruthy(v24) { + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("=")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) } - v27 := v26.Get() - v28, ok := lang.FieldOrMethod(v17, "Namespace") + tmp28 := tmp27.Get() + tmp29, ok := lang.FieldOrMethod(v17, "Namespace") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v17, "Namespace"))) } - var v29 any - switch reflect.TypeOf(v28).Kind() { + var tmp30 any + switch reflect.TypeOf(tmp29).Kind() { case reflect.Func: - v29 = lang.Apply(v28, nil) + tmp30 = lang.Apply(tmp29, nil) default: - v29 = v28 + tmp30 = tmp29 } - v30 := lang.Apply(v27, []any{v9, v29}) - v24 = v30 + tmp31 := lang.Apply(tmp28, []any{v9, tmp30}) + tmp25 = tmp31 } else { - v24 = v23 + tmp25 = v24 } - v18 = v24 + tmp18 = tmp25 } // end let - return v18 + return tmp18 }) - v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4212), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(4213), lang.NewKeyword("end-column"), int(56)) - v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) + tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4212), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(4213), lang.NewKeyword("end-column"), int(56)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) if err != nil { panic(err) } - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("ns-map")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("ns-map")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{v9}) - v23 := lang.Apply(v12, []any{v15, v18, v22}) - v4 = v23 + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, []any{v9}) + tmp23 := lang.Apply(tmp12, []any{tmp15, tmp18, tmp22}) + tmp4 = tmp23 } // end let - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // ns-map { - v0 := lang.NewSymbol("ns-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of all the mappings for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4170), lang.NewKeyword("end-line"), int(4170))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("ns-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of all the mappings for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4170), lang.NewKeyword("end-line"), int(4170))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("the-ns")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.Apply(v6, []any{v3}) - v8, ok := lang.FieldOrMethod(v7, "Mappings") + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("the-ns")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.Apply(tmp6, []any{v3}) + tmp8, ok := lang.FieldOrMethod(tmp7, "Mappings") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "Mappings"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp7, "Mappings"))) } - var v9 any - switch reflect.TypeOf(v8).Kind() { + var tmp9 any + switch reflect.TypeOf(tmp8).Kind() { case reflect.Func: - v9 = lang.Apply(v8, nil) + tmp9 = lang.Apply(tmp8, nil) default: - v9 = v8 + tmp9 = tmp8 } - return v9 + return tmp9 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // ns-name { - v0 := lang.NewSymbol("ns-name").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns the name of the namespace, a symbol.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4163), lang.NewKeyword("end-line"), int(4163))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("ns-name").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns the name of the namespace, a symbol.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4163), lang.NewKeyword("end-line"), int(4163))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("the-ns")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.Apply(v6, []any{v3}) - v8, ok := lang.FieldOrMethod(v7, "Name") + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("the-ns")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.Apply(tmp6, []any{v3}) + tmp8, ok := lang.FieldOrMethod(tmp7, "Name") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "Name"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp7, "Name"))) } - var v9 any - switch reflect.TypeOf(v8).Kind() { + var tmp9 any + switch reflect.TypeOf(tmp8).Kind() { case reflect.Func: - v9 = lang.Apply(v8, nil) + tmp9 = lang.Apply(tmp8, nil) default: - v9 = v8 + tmp9 = tmp8 } - return v9 + return tmp9 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // ns-publics { - v0 := lang.NewSymbol("ns-publics").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of the public intern mappings for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4188), lang.NewKeyword("end-line"), int(4188))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("ns-publics").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of the public intern mappings for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4188), lang.NewKeyword("end-line"), int(4188))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any + var tmp4 any { // let // let binding "ns" - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("the-ns")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v3}) - var v9 any = v8 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("the-ns")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v3}) + var v9 any = tmp8 _ = v9 - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("filter-key")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("val")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - var v16 lang.FnFunc - v16 = lang.NewFnFunc(func(args ...any) any { + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("filter-key")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("val")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + var tmp16 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v17 := args[0] _ = v17 - var v18 any + var tmp18 any { // let // let binding "and__0__auto__" - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("instance?")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{*lang.Var, v17}) - var v23 any = v22 - _ = v23 - var v24 any - if lang.IsTruthy(v23) { - var v25 any + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("instance?")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := reflect.TypeOf((*lang.Var)(nil)) + tmp23 := lang.Apply(tmp21, []any{tmp22, v17}) + var v24 any = tmp23 + _ = v24 + var tmp25 any + if lang.IsTruthy(v24) { + var tmp26 any { // let // let binding "and__0__auto__" - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("=")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("=")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) } - v28 := v27.Get() - v29, ok := lang.FieldOrMethod(v17, "Namespace") + tmp29 := tmp28.Get() + tmp30, ok := lang.FieldOrMethod(v17, "Namespace") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v17, "Namespace"))) } - var v30 any - switch reflect.TypeOf(v29).Kind() { + var tmp31 any + switch reflect.TypeOf(tmp30).Kind() { case reflect.Func: - v30 = lang.Apply(v29, nil) + tmp31 = lang.Apply(tmp30, nil) default: - v30 = v29 + tmp31 = tmp30 } - v31 := lang.Apply(v28, []any{v9, v30}) - var v32 any = v31 - _ = v32 - var v33 any - if lang.IsTruthy(v32) { - v34, ok := lang.FieldOrMethod(v17, "IsPublic") + tmp32 := lang.Apply(tmp29, []any{v9, tmp31}) + var v33 any = tmp32 + _ = v33 + var tmp34 any + if lang.IsTruthy(v33) { + tmp35, ok := lang.FieldOrMethod(v17, "IsPublic") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v17, "IsPublic"))) } - var v35 any - switch reflect.TypeOf(v34).Kind() { + var tmp36 any + switch reflect.TypeOf(tmp35).Kind() { case reflect.Func: - v35 = lang.Apply(v34, nil) + tmp36 = lang.Apply(tmp35, nil) default: - v35 = v34 + tmp36 = tmp35 } - v33 = v35 + tmp34 = tmp36 } else { - v33 = v32 + tmp34 = v33 } - v25 = v33 + tmp26 = tmp34 } // end let - v24 = v25 + tmp25 = tmp26 } else { - v24 = v23 + tmp25 = v24 } - v18 = v24 + tmp18 = tmp25 } // end let - return v18 + return tmp18 }) - v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4194), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(4196), lang.NewKeyword("end-column"), int(48)) - v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) + tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4194), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(4196), lang.NewKeyword("end-column"), int(48)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) if err != nil { panic(err) } - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("ns-map")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("ns-map")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{v9}) - v23 := lang.Apply(v12, []any{v15, v18, v22}) - v4 = v23 + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, []any{v9}) + tmp23 := lang.Apply(tmp12, []any{tmp15, tmp18, tmp22}) + tmp4 = tmp23 } // end let - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // ns-refers { - v0 := lang.NewSymbol("ns-refers").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of the refer mappings for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4253), lang.NewKeyword("end-line"), int(4253))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("ns-refers").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of the refer mappings for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4253), lang.NewKeyword("end-line"), int(4253))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any + var tmp4 any { // let // let binding "ns" - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("the-ns")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v3}) - var v9 any = v8 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("the-ns")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v3}) + var v9 any = tmp8 _ = v9 - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("filter-key")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("val")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - var v16 lang.FnFunc - v16 = lang.NewFnFunc(func(args ...any) any { + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("filter-key")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("val")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + var tmp16 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v17 := args[0] _ = v17 - var v18 any + var tmp18 any { // let // let binding "and__0__auto__" - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("instance?")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{*lang.Var, v17}) - var v23 any = v22 - _ = v23 - var v24 any - if lang.IsTruthy(v23) { - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("not=")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("instance?")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := reflect.TypeOf((*lang.Var)(nil)) + tmp23 := lang.Apply(tmp21, []any{tmp22, v17}) + var v24 any = tmp23 + _ = v24 + var tmp25 any + if lang.IsTruthy(v24) { + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("not=")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) } - v27 := v26.Get() - v28, ok := lang.FieldOrMethod(v17, "Namespace") + tmp28 := tmp27.Get() + tmp29, ok := lang.FieldOrMethod(v17, "Namespace") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v17, "Namespace"))) } - var v29 any - switch reflect.TypeOf(v28).Kind() { + var tmp30 any + switch reflect.TypeOf(tmp29).Kind() { case reflect.Func: - v29 = lang.Apply(v28, nil) + tmp30 = lang.Apply(tmp29, nil) default: - v29 = v28 + tmp30 = tmp29 } - v30 := lang.Apply(v27, []any{v9, v29}) - v24 = v30 + tmp31 := lang.Apply(tmp28, []any{v9, tmp30}) + tmp25 = tmp31 } else { - v24 = v23 + tmp25 = v24 } - v18 = v24 + tmp18 = tmp25 } // end let - return v18 + return tmp18 }) - v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4259), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(4260), lang.NewKeyword("end-column"), int(59)) - v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) + tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4259), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(4260), lang.NewKeyword("end-column"), int(59)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) if err != nil { panic(err) } - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("ns-map")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("ns-map")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{v9}) - v23 := lang.Apply(v12, []any{v15, v18, v22}) - v4 = v23 + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, []any{v9}) + tmp23 := lang.Apply(tmp12, []any{tmp15, tmp18, tmp22}) + tmp4 = tmp23 } // end let - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // ns-resolve { - v0 := lang.NewSymbol("ns-resolve").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("sym")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("env"), lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Returns the var or Class to which a symbol will be resolved in the\n namespace (unless found in the environment), else nil. Note that\n if the symbol is fully qualified, the var/Class to which it resolves\n need not be present in the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4358), lang.NewKeyword("end-line"), int(4358))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("ns-resolve").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("sym")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("env"), lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Returns the var or Class to which a symbol will be resolved in the\n namespace (unless found in the environment), else nil. Note that\n if the symbol is fully qualified, the var/Class to which it resolves\n need not be present in the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4358), lang.NewKeyword("end-line"), int(4358))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("ns-resolve")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v3, nil, v4}) - return v8 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("ns-resolve")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v3, nil, v4}) + return tmp8 case 3: v3 := args[0] _ = v3 @@ -59136,47 +59257,46 @@ func init() { _ = v4 v5 := args[2] _ = v5 - var v6 any - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("contains?")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v9, []any{v4, v5}) - if lang.IsTruthy(v10) { - v6 = nil + var tmp6 any + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("contains?")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + if lang.IsTruthy(tmp10) { } else { - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("the-ns")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{v3}) - v15, _ := lang.FieldOrMethod(runtime4.Compiler, "maybeResolveIn") - if reflect.TypeOf(v15).Kind() != reflect.Func { + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("the-ns")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{v3}) + tmp15, _ := lang.FieldOrMethod(runtime4.Compiler, "maybeResolveIn") + if reflect.TypeOf(tmp15).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("maybeResolveIn is not a function"))) } - v16 := lang.Apply(v15, []any{v14, v5}) - v6 = v16 + tmp16 := lang.Apply(tmp15, []any{tmp14, v5}) + tmp6 = tmp16 } - return v6 + return tmp6 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // ns-unalias { - v0 := lang.NewSymbol("ns-unalias").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Removes the alias for the symbol from the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4280), lang.NewKeyword("end-line"), int(4280))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("ns-unalias").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Removes the alias for the symbol from the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4280), lang.NewKeyword("end-line"), int(4280))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -59184,31 +59304,31 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("the-ns")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v3}) - v9, _ := lang.FieldOrMethod(v8, "removeAlias") - if reflect.TypeOf(v9).Kind() != reflect.Func { + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("the-ns")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v3}) + tmp9, _ := lang.FieldOrMethod(tmp8, "removeAlias") + if reflect.TypeOf(tmp9).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("removeAlias is not a function"))) } - v10 := lang.Apply(v9, []any{v4}) - return v10 + tmp10 := lang.Apply(tmp9, []any{v4}) + return tmp10 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // ns-unmap { - v0 := lang.NewSymbol("ns-unmap").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Removes the mappings for the symbol from the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4177), lang.NewKeyword("end-line"), int(4177))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("ns-unmap").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Removes the mappings for the symbol from the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4177), lang.NewKeyword("end-line"), int(4177))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -59216,31 +59336,32 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("the-ns")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v3}) - v9, _ := lang.FieldOrMethod(v8, "unmap") - if reflect.TypeOf(v9).Kind() != reflect.Func { + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("the-ns")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v3}) + tmp9, _ := lang.FieldOrMethod(tmp8, "unmap") + if reflect.TypeOf(tmp9).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("unmap is not a function"))) } - v10 := lang.Apply(v9, []any{v4}) - return v10 + tmp10 := lang.Apply(tmp9, []any{v4}) + return tmp10 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // nth { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function nth__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 2 { @@ -59250,189 +59371,190 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.NewList(args[2:]...) - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("seq")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("concat")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("list")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.Apply(v14, []any{lang.NewSymbol(".")}) - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("list")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("list")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("seq")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("concat")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) - } - v28 := v27.Get() - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("list")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.Apply(v31, []any{lang.NewSymbol("glojure.core/Nth")}) - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("list")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("seq")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v40 := v39.FindInternedVar(lang.NewSymbol("concat")) - if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) - } - v41 := v40.Get() - v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v43 := v42.FindInternedVar(lang.NewSymbol("list")) - if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) - } - v44 := v43.Get() - v45 := lang.Apply(v44, []any{lang.NewSymbol("glojure.core/unquote")}) - v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v47 := v46.FindInternedVar(lang.NewSymbol("list")) - if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) - } - v48 := v47.Get() - v49 := lang.Apply(v48, []any{lang.NewSymbol("glojure.core/c")}) - v50 := lang.Apply(v41, []any{v45, v49}) - v51 := lang.Apply(v38, []any{v50}) - v52 := lang.Apply(v35, []any{v51}) - v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v54 := v53.FindInternedVar(lang.NewSymbol("list")) - if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) - } - v55 := v54.Get() - v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v57 := v56.FindInternedVar(lang.NewSymbol("seq")) - if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) - } - v58 := v57.Get() - v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v60 := v59.FindInternedVar(lang.NewSymbol("concat")) - if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) - } - v61 := v60.Get() - v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v63 := v62.FindInternedVar(lang.NewSymbol("list")) - if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) - } - v64 := v63.Get() - v65 := lang.Apply(v64, []any{lang.NewSymbol("glojure.core/unquote")}) - v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v67 := v66.FindInternedVar(lang.NewSymbol("list")) - if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) - } - v68 := v67.Get() - v69 := lang.Apply(v68, []any{lang.NewSymbol("glojure.core/i")}) - v70 := lang.Apply(v61, []any{v65, v69}) - v71 := lang.Apply(v58, []any{v70}) - v72 := lang.Apply(v55, []any{v71}) - v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v74 := v73.FindInternedVar(lang.NewSymbol("list")) - if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) - } - v75 := v74.Get() - v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v77 := v76.FindInternedVar(lang.NewSymbol("seq")) - if v77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) - } - v78 := v77.Get() - v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v80 := v79.FindInternedVar(lang.NewSymbol("concat")) - if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) - } - v81 := v80.Get() - v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v83 := v82.FindInternedVar(lang.NewSymbol("list")) - if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) - } - v84 := v83.Get() - v85 := lang.Apply(v84, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) - v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v87 := v86.FindInternedVar(lang.NewSymbol("list")) - if v87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) - } - v88 := v87.Get() - v89 := lang.Apply(v88, []any{lang.NewSymbol("glojure.core/nf")}) - v90 := lang.Apply(v81, []any{v85, v89}) - v91 := lang.Apply(v78, []any{v90}) - v92 := lang.Apply(v75, []any{v91}) - v93 := lang.Apply(v28, []any{v32, v52, v72, v92}) - v94 := lang.Apply(v25, []any{v93}) - v95 := lang.Apply(v22, []any{v94}) - v96 := lang.Apply(v11, []any{v15, v19, v95}) - v97 := lang.Apply(v8, []any{v96}) - return v97 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("seq")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("concat")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("list")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol(".")}) + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("list")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("list")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("seq")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("concat")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) + } + tmp28 := tmp27.Get() + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("list")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.Apply(tmp31, []any{lang.NewSymbol("glojure.core/Nth")}) + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("list")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) + } + tmp35 := tmp34.Get() + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("seq")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp40 := tmp39.FindInternedVar(lang.NewSymbol("concat")) + if tmp40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) + } + tmp41 := tmp40.Get() + tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp43 := tmp42.FindInternedVar(lang.NewSymbol("list")) + if tmp43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) + } + tmp44 := tmp43.Get() + tmp45 := lang.Apply(tmp44, []any{lang.NewSymbol("glojure.core/unquote")}) + tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp47 := tmp46.FindInternedVar(lang.NewSymbol("list")) + if tmp47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) + } + tmp48 := tmp47.Get() + tmp49 := lang.Apply(tmp48, []any{lang.NewSymbol("glojure.core/c")}) + tmp50 := lang.Apply(tmp41, []any{tmp45, tmp49}) + tmp51 := lang.Apply(tmp38, []any{tmp50}) + tmp52 := lang.Apply(tmp35, []any{tmp51}) + tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp54 := tmp53.FindInternedVar(lang.NewSymbol("list")) + if tmp54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) + } + tmp55 := tmp54.Get() + tmp56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp57 := tmp56.FindInternedVar(lang.NewSymbol("seq")) + if tmp57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp57))) + } + tmp58 := tmp57.Get() + tmp59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp60 := tmp59.FindInternedVar(lang.NewSymbol("concat")) + if tmp60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp60))) + } + tmp61 := tmp60.Get() + tmp62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp63 := tmp62.FindInternedVar(lang.NewSymbol("list")) + if tmp63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp63))) + } + tmp64 := tmp63.Get() + tmp65 := lang.Apply(tmp64, []any{lang.NewSymbol("glojure.core/unquote")}) + tmp66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp67 := tmp66.FindInternedVar(lang.NewSymbol("list")) + if tmp67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp67))) + } + tmp68 := tmp67.Get() + tmp69 := lang.Apply(tmp68, []any{lang.NewSymbol("glojure.core/i")}) + tmp70 := lang.Apply(tmp61, []any{tmp65, tmp69}) + tmp71 := lang.Apply(tmp58, []any{tmp70}) + tmp72 := lang.Apply(tmp55, []any{tmp71}) + tmp73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp74 := tmp73.FindInternedVar(lang.NewSymbol("list")) + if tmp74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp74))) + } + tmp75 := tmp74.Get() + tmp76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp77 := tmp76.FindInternedVar(lang.NewSymbol("seq")) + if tmp77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp77))) + } + tmp78 := tmp77.Get() + tmp79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp80 := tmp79.FindInternedVar(lang.NewSymbol("concat")) + if tmp80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp80))) + } + tmp81 := tmp80.Get() + tmp82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp83 := tmp82.FindInternedVar(lang.NewSymbol("list")) + if tmp83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp83))) + } + tmp84 := tmp83.Get() + tmp85 := lang.Apply(tmp84, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) + tmp86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp87 := tmp86.FindInternedVar(lang.NewSymbol("list")) + if tmp87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp87))) + } + tmp88 := tmp87.Get() + tmp89 := lang.Apply(tmp88, []any{lang.NewSymbol("glojure.core/nf")}) + tmp90 := lang.Apply(tmp81, []any{tmp85, tmp89}) + tmp91 := lang.Apply(tmp78, []any{tmp90}) + tmp92 := lang.Apply(tmp75, []any{tmp91}) + tmp93 := lang.Apply(tmp28, []any{tmp32, tmp52, tmp72, tmp92}) + tmp94 := lang.Apply(tmp25, []any{tmp93}) + tmp95 := lang.Apply(tmp22, []any{tmp94}) + tmp96 := lang.Apply(tmp11, []any{tmp15, tmp19, tmp95}) + tmp97 := lang.Apply(tmp8, []any{tmp96}) + return tmp97 } }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("nth").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("index")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("index"), lang.NewSymbol("not-found"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the value at the index. get returns nil if index out of\n bounds, nth throws an exception unless not-found is supplied. nth\n also works for strings, Java arrays, regex Matchers and Lists, and,\n in O(n) time, for sequences.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(2), int64(3)), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(882), lang.NewKeyword("end-line"), int(882))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("nth").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("index")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("index"), lang.NewSymbol("not-found"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the value at the index. get returns nil if index out of\n bounds, nth throws an exception unless not-found is supplied. nth\n also works for strings, Java arrays, regex Matchers and Lists, and,\n in O(n) time, for sequences.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2), int64(3)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(882), lang.NewKeyword("end-line"), int(882))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 2: v4 := args[0] _ = v4 v5 := args[1] _ = v5 - v6, _ := lang.FieldOrMethod(runtime4.RT, "Nth") - if reflect.TypeOf(v6).Kind() != reflect.Func { + tmp6, _ := lang.FieldOrMethod(runtime4.RT, "Nth") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Nth is not a function"))) } - v7 := lang.Apply(v6, []any{v4, v5}) - return v7 + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 case 3: v4 := args[0] _ = v4 @@ -59440,27 +59562,27 @@ func init() { _ = v5 v6 := args[2] _ = v6 - v7, _ := lang.FieldOrMethod(runtime4.RT, "NthDefault") - if reflect.TypeOf(v7).Kind() != reflect.Func { + tmp7, _ := lang.FieldOrMethod(runtime4.RT, "NthDefault") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("NthDefault is not a function"))) } - v8 := lang.Apply(v7, []any{v4, v5, v6}) - return v8 + tmp8 := lang.Apply(tmp7, []any{v4, v5, v6}) + return tmp8 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // nthnext { - v0 := lang.NewSymbol("nthnext").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns the nth next of coll, (seq coll) when n is 0.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3147), lang.NewKeyword("end-line"), int(3147))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("nthnext").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns the nth next of coll, (seq coll) when n is 0.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3147), lang.NewKeyword("end-line"), int(3147))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -59468,135 +59590,136 @@ func init() { _ = v3 v4 := args[1] _ = v4 - var v5 any - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{lang.IDrop, v3}) - if lang.IsTruthy(v9) { - var v10 any - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("pos?")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{v4}) - if lang.IsTruthy(v14) { - var v15 any - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("int?")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{v4}) - if lang.IsTruthy(v19) { - v15 = v4 + var tmp5 any + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("instance?")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := reflect.TypeOf((*lang.IDrop)(nil)).Elem() + tmp10 := lang.Apply(tmp8, []any{tmp9, v3}) + if lang.IsTruthy(tmp10) { + var tmp11 any + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("pos?")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.Apply(tmp14, []any{v4}) + if lang.IsTruthy(tmp15) { + var tmp16 any + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("int?")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.Apply(tmp19, []any{v4}) + if lang.IsTruthy(tmp20) { + tmp16 = v4 } else { - v20 := lang.Apply(nil, []any{v4}) - v15 = v20 + tmp21 := lang.Apply(nil, []any{v4}) + tmp16 = tmp21 } - v21, _ := lang.FieldOrMethod(v3, "drop") - if reflect.TypeOf(v21).Kind() != reflect.Func { + tmp22, _ := lang.FieldOrMethod(v3, "drop") + if reflect.TypeOf(tmp22).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("drop is not a function"))) } - v22 := lang.Apply(v21, []any{v15}) - v10 = v22 + tmp23 := lang.Apply(tmp22, []any{tmp16}) + tmp11 = tmp23 } else { - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("seq")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("seq")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) } - v25 := v24.Get() - v26 := lang.Apply(v25, []any{v3}) - v10 = v26 + tmp26 := tmp25.Get() + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp11 = tmp27 } - v5 = v10 + tmp5 = tmp11 } else { - var v27 any + var tmp28 any { // let // let binding "n" - var v28 any = v4 - _ = v28 + var v29 any = v4 + _ = v29 // let binding "xs" - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("seq")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.Apply(v31, []any{v3}) - var v33 any = v32 - _ = v33 + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("seq")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) + } + tmp32 := tmp31.Get() + tmp33 := lang.Apply(tmp32, []any{v3}) + var v34 any = tmp33 + _ = v34 for { - var v34 any - var v35 any + var tmp35 any + var tmp36 any { // let // let binding "and__0__auto__" - var v36 any = v33 - _ = v36 - var v37 any - if lang.IsTruthy(v36) { - v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v39 := v38.FindInternedVar(lang.NewSymbol("pos?")) - if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + var v37 any = v34 + _ = v37 + var tmp38 any + if lang.IsTruthy(v37) { + tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp40 := tmp39.FindInternedVar(lang.NewSymbol("pos?")) + if tmp40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) } - v40 := v39.Get() - v41 := lang.Apply(v40, []any{v28}) - v37 = v41 + tmp41 := tmp40.Get() + tmp42 := lang.Apply(tmp41, []any{v29}) + tmp38 = tmp42 } else { - v37 = v36 + tmp38 = v37 } - v35 = v37 + tmp36 = tmp38 } // end let - if lang.IsTruthy(v35) { - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("dec")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.Apply(v39, []any{v28}) - var v36 any = v40 - v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v43 := v42.FindInternedVar(lang.NewSymbol("next")) - if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) - } - v44 := v43.Get() - v45 := lang.Apply(v44, []any{v33}) - var v41 any = v45 - v28 = v36 - v33 = v41 + if lang.IsTruthy(tmp36) { + tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp39 := tmp38.FindInternedVar(lang.NewSymbol("dec")) + if tmp39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) + } + tmp40 := tmp39.Get() + tmp41 := lang.Apply(tmp40, []any{v29}) + var tmp37 any = tmp41 + tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp44 := tmp43.FindInternedVar(lang.NewSymbol("next")) + if tmp44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) + } + tmp45 := tmp44.Get() + tmp46 := lang.Apply(tmp45, []any{v34}) + var tmp42 any = tmp46 + v29 = tmp37 + v34 = tmp42 continue } else { - v34 = v33 + tmp35 = v34 } - v27 = v34 + tmp28 = tmp35 break } } // end let - v5 = v27 + tmp5 = tmp28 } - return v5 + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // nthrest { - v0 := lang.NewSymbol("nthrest").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns the nth rest of coll, coll when n is 0.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3161), lang.NewKeyword("end-line"), int(3161))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("nthrest").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns the nth rest of coll, coll when n is 0.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3161), lang.NewKeyword("end-line"), int(3161))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -59604,421 +59727,424 @@ func init() { _ = v3 v4 := args[1] _ = v4 - var v5 any - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("pos?")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{v4}) - if lang.IsTruthy(v9) { - var v10 any + var tmp5 any + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("pos?")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.Apply(tmp8, []any{v4}) + if lang.IsTruthy(tmp9) { + var tmp10 any { // let // let binding "or__0__auto__" - var v11 any - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("instance?")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.Apply(v14, []any{lang.IDrop, v3}) - if lang.IsTruthy(v15) { - var v16 any - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("int?")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.Apply(v19, []any{v4}) - if lang.IsTruthy(v20) { - v16 = v4 + var tmp11 any + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("instance?")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := reflect.TypeOf((*lang.IDrop)(nil)).Elem() + tmp16 := lang.Apply(tmp14, []any{tmp15, v3}) + if lang.IsTruthy(tmp16) { + var tmp17 any + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("int?")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.Apply(tmp20, []any{v4}) + if lang.IsTruthy(tmp21) { + tmp17 = v4 } else { - v21 := lang.Apply(nil, []any{v4}) - v16 = v21 + tmp22 := lang.Apply(nil, []any{v4}) + tmp17 = tmp22 } - v22, _ := lang.FieldOrMethod(v3, "drop") - if reflect.TypeOf(v22).Kind() != reflect.Func { + tmp23, _ := lang.FieldOrMethod(v3, "drop") + if reflect.TypeOf(tmp23).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("drop is not a function"))) } - v23 := lang.Apply(v22, []any{v16}) - v11 = v23 + tmp24 := lang.Apply(tmp23, []any{tmp17}) + tmp11 = tmp24 } else { - var v24 any + var tmp25 any { // let // let binding "n" - var v25 any = v4 - _ = v25 - // let binding "xs" - var v26 any = v3 + var v26 any = v4 _ = v26 + // let binding "xs" + var v27 any = v3 + _ = v27 for { - var v27 any + var tmp28 any { // let // let binding "temp__0__auto__" - var v28 any + var tmp29 any { // let // let binding "and__0__auto__" - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("pos?")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("pos?")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) } - v31 := v30.Get() - v32 := lang.Apply(v31, []any{v25}) - var v33 any = v32 - _ = v33 - var v34 any - if lang.IsTruthy(v33) { - v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v36 := v35.FindInternedVar(lang.NewSymbol("seq")) - if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + tmp32 := tmp31.Get() + tmp33 := lang.Apply(tmp32, []any{v26}) + var v34 any = tmp33 + _ = v34 + var tmp35 any + if lang.IsTruthy(v34) { + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("seq")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) } - v37 := v36.Get() - v38 := lang.Apply(v37, []any{v26}) - v34 = v38 + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{v27}) + tmp35 = tmp39 } else { - v34 = v33 + tmp35 = v34 } - v28 = v34 + tmp29 = tmp35 } // end let - var v29 any = v28 - _ = v29 - var v30 any - if lang.IsTruthy(v29) { - var v31 any + var v30 any = tmp29 + _ = v30 + var tmp31 any + if lang.IsTruthy(v30) { + var tmp32 any { // let // let binding "xs" - var v32 any = v29 - _ = v32 - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("dec")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + var v33 any = v30 + _ = v33 + tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp36 := tmp35.FindInternedVar(lang.NewSymbol("dec")) + if tmp36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) } - v36 := v35.Get() - v37 := lang.Apply(v36, []any{v25}) - var v33 any = v37 - v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v40 := v39.FindInternedVar(lang.NewSymbol("rest")) - if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) + tmp37 := tmp36.Get() + tmp38 := lang.Apply(tmp37, []any{v26}) + var tmp34 any = tmp38 + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("rest")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) } - v41 := v40.Get() - v42 := lang.Apply(v41, []any{v32}) - var v38 any = v42 - v25 = v33 - v26 = v38 + tmp42 := tmp41.Get() + tmp43 := lang.Apply(tmp42, []any{v33}) + var tmp39 any = tmp43 + v26 = tmp34 + v27 = tmp39 continue } // end let - v30 = v31 + tmp31 = tmp32 } else { - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("seq")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("seq")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{v26}) - v30 = v35 + tmp35 := tmp34.Get() + tmp36 := lang.Apply(tmp35, []any{v27}) + tmp31 = tmp36 } - v27 = v30 + tmp28 = tmp31 } // end let - v24 = v27 + tmp25 = tmp28 break } } // end let - v11 = v24 + tmp11 = tmp25 } - var v25 any = v11 - _ = v25 - var v26 any - if lang.IsTruthy(v25) { - v26 = v25 + var v26 any = tmp11 + _ = v26 + var tmp27 any + if lang.IsTruthy(v26) { + tmp27 = v26 } else { - v26 = lang.NewList() + tmp27 = lang.NewList() } - v10 = v26 + tmp10 = tmp27 } // end let - v5 = v10 + tmp5 = tmp10 } else { - v5 = v3 + tmp5 = v3 } - return v5 + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // num { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function num__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("concat")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("list")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("seq")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("concat")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/Num")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{v3}) - v35 := lang.Apply(v26, []any{v30, v34}) - v36 := lang.Apply(v23, []any{v35}) - v37 := lang.Apply(v20, []any{v36}) - v38 := lang.Apply(v9, []any{v13, v17, v37}) - v39 := lang.Apply(v6, []any{v38}) - return v39 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/Num")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{v3}) + tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) + tmp36 := lang.Apply(tmp23, []any{tmp35}) + tmp37 := lang.Apply(tmp20, []any{tmp36}) + tmp38 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp37}) + tmp39 := lang.Apply(tmp6, []any{tmp38}) + return tmp39 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("num").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to Number", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3474), lang.NewKeyword("end-line"), int(3474))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("num").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to Number", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3474), lang.NewKeyword("end-line"), int(3474))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5, _ := lang.FieldOrMethod(lang.Numbers, "Num") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Num") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Num is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // number? { - v0 := lang.NewSymbol("number?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is a Number", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3560), lang.NewKeyword("end-line"), int(3560))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("number?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is a Number", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3560), lang.NewKeyword("end-line"), int(3560))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.Apply(lang.IsNumber, []any{v3}) - return v4 + tmp4 := lang.Apply(lang.IsNumber, []any{v3}) + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // numerator { - v1 := reflect.TypeOf((*big6.Int)(nil)) - v0 := lang.NewSymbol("numerator").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("r"))), lang.NewKeyword("doc"), "Returns the numerator part of a Ratio.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3583), lang.NewKeyword("end-line"), int(3583))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp1 := reflect.TypeOf((*big6.Int)(nil)) + tmp0 := lang.NewSymbol("numerator").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("r"))), lang.NewKeyword("doc"), "Returns the numerator part of a Ratio.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3583), lang.NewKeyword("end-line"), int(3583))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5, ok := lang.FieldOrMethod(v4, "numerator") + tmp5, ok := lang.FieldOrMethod(v4, "numerator") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "numerator"))) } - var v6 any - switch reflect.TypeOf(v5).Kind() { + var tmp6 any + switch reflect.TypeOf(tmp5).Kind() { case reflect.Func: - v6 = lang.Apply(v5, nil) + tmp6 = lang.Apply(tmp5, nil) default: - v6 = v5 + tmp6 = tmp5 } - return v6 + return tmp6 }) - v4 := reflect.TypeOf((*big6.Int)(nil)) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp4 := reflect.TypeOf((*big6.Int)(nil)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // object-array { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function object-array__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("concat")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("list")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/Object_array")}) - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("list")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v3}) - v26 := lang.Apply(v9, []any{v13, v17, v21, v25}) - v27 := lang.Apply(v6, []any{v26}) - return v27 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.Apply(tmp20, []any{lang.NewSymbol("glojure.core/Object_array")}) + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("list")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.Apply(tmp24, []any{v3}) + tmp26 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp21, tmp25}) + tmp27 := lang.Apply(tmp6, []any{tmp26}) + return tmp27 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("object-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Creates an array of objects", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)), lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5349), lang.NewKeyword("end-line"), int(5349))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("object-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Creates an array of objects", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1)})), lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5349), lang.NewKeyword("end-line"), int(5349))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5, _ := lang.FieldOrMethod(runtime4.RT, "Object_array") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(runtime4.RT, "Object_array") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Object_array is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // odd? { - v0 := lang.NewSymbol("odd?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is odd, throws an exception if n is not an integer", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1389), lang.NewKeyword("end-line"), int(1389))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("odd?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is odd, throws an exception if n is not an integer", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1389), lang.NewKeyword("end-line"), int(1389))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("not")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("not")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("even?")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("even?")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) } - v9 := v8.Get() - v10 := lang.Apply(v9, []any{v3}) - v11 := lang.Apply(v6, []any{v10}) - return v11 + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp9, []any{v3}) + tmp11 := lang.Apply(tmp6, []any{tmp10}) + return tmp11 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // or { - v0 := lang.NewSymbol("or").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("next"))), lang.NewKeyword("doc"), "Evaluates exprs one at a time, from left to right. If a form\n returns a logical true value, or returns that value and doesn't\n evaluate any of the other expressions, otherwise it returns the\n value of the last expression. (or) returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(847), lang.NewKeyword("end-line"), int(847))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("or").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("next"))), lang.NewKeyword("doc"), "Evaluates exprs one at a time, from left to right. If a form\n returns a logical true value, or returns that value and doesn't\n evaluate any of the other expressions, otherwise it returns the\n value of the last expression. (or) returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(847), lang.NewKeyword("end-line"), int(847))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 2: v3 := args[0] @@ -60044,650 +60170,648 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("seq")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("concat")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("list")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/let")}) - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("list")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("apply")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("vector")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("seq")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) - } - v28 := v27.Get() - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("concat")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("list")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{lang.NewSymbol("or__0__auto__")}) - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("list")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.Apply(v38, []any{v5}) - v40 := lang.Apply(v31, []any{v35, v39}) - v41 := lang.Apply(v28, []any{v40}) - v42 := lang.Apply(v22, []any{v25, v41}) - v43 := lang.Apply(v19, []any{v42}) - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("list")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) - } - v46 := v45.Get() - v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v48 := v47.FindInternedVar(lang.NewSymbol("seq")) - if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) - } - v49 := v48.Get() - v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v51 := v50.FindInternedVar(lang.NewSymbol("concat")) - if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) - } - v52 := v51.Get() - v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v54 := v53.FindInternedVar(lang.NewSymbol("list")) - if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) - } - v55 := v54.Get() - v56 := lang.Apply(v55, []any{lang.NewSymbol("if")}) - v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v58 := v57.FindInternedVar(lang.NewSymbol("list")) - if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) - } - v59 := v58.Get() - v60 := lang.Apply(v59, []any{lang.NewSymbol("or__0__auto__")}) - v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v62 := v61.FindInternedVar(lang.NewSymbol("list")) - if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) - } - v63 := v62.Get() - v64 := lang.Apply(v63, []any{lang.NewSymbol("or__0__auto__")}) - v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v66 := v65.FindInternedVar(lang.NewSymbol("list")) - if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) - } - v67 := v66.Get() - v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v69 := v68.FindInternedVar(lang.NewSymbol("seq")) - if v69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) - } - v70 := v69.Get() - v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v72 := v71.FindInternedVar(lang.NewSymbol("concat")) - if v72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) - } - v73 := v72.Get() - v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v75 := v74.FindInternedVar(lang.NewSymbol("list")) - if v75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) - } - v76 := v75.Get() - v77 := lang.Apply(v76, []any{lang.NewSymbol("glojure.core/or")}) - v78 := lang.Apply(v73, []any{v77, v6}) - v79 := lang.Apply(v70, []any{v78}) - v80 := lang.Apply(v67, []any{v79}) - v81 := lang.Apply(v52, []any{v56, v60, v64, v80}) - v82 := lang.Apply(v49, []any{v81}) - v83 := lang.Apply(v46, []any{v82}) - v84 := lang.Apply(v12, []any{v16, v43, v83}) - v85 := lang.Apply(v9, []any{v84}) - return v85 - } - }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("seq")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("concat")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("list")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("glojure.core/let")}) + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("list")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("apply")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("vector")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("seq")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) + } + tmp28 := tmp27.Get() + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("concat")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.Apply(tmp34, []any{lang.NewSymbol("or__0__auto__")}) + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{v5}) + tmp40 := lang.Apply(tmp31, []any{tmp35, tmp39}) + tmp41 := lang.Apply(tmp28, []any{tmp40}) + tmp42 := lang.Apply(tmp22, []any{tmp25, tmp41}) + tmp43 := lang.Apply(tmp19, []any{tmp42}) + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) + } + tmp46 := tmp45.Get() + tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp48 := tmp47.FindInternedVar(lang.NewSymbol("seq")) + if tmp48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) + } + tmp49 := tmp48.Get() + tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp51 := tmp50.FindInternedVar(lang.NewSymbol("concat")) + if tmp51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) + } + tmp52 := tmp51.Get() + tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp54 := tmp53.FindInternedVar(lang.NewSymbol("list")) + if tmp54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) + } + tmp55 := tmp54.Get() + tmp56 := lang.Apply(tmp55, []any{lang.NewSymbol("if")}) + tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp58 := tmp57.FindInternedVar(lang.NewSymbol("list")) + if tmp58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) + } + tmp59 := tmp58.Get() + tmp60 := lang.Apply(tmp59, []any{lang.NewSymbol("or__0__auto__")}) + tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp62 := tmp61.FindInternedVar(lang.NewSymbol("list")) + if tmp62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) + } + tmp63 := tmp62.Get() + tmp64 := lang.Apply(tmp63, []any{lang.NewSymbol("or__0__auto__")}) + tmp65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp66 := tmp65.FindInternedVar(lang.NewSymbol("list")) + if tmp66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp66))) + } + tmp67 := tmp66.Get() + tmp68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp69 := tmp68.FindInternedVar(lang.NewSymbol("seq")) + if tmp69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp69))) + } + tmp70 := tmp69.Get() + tmp71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp72 := tmp71.FindInternedVar(lang.NewSymbol("concat")) + if tmp72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp72))) + } + tmp73 := tmp72.Get() + tmp74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp75 := tmp74.FindInternedVar(lang.NewSymbol("list")) + if tmp75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp75))) + } + tmp76 := tmp75.Get() + tmp77 := lang.Apply(tmp76, []any{lang.NewSymbol("glojure.core/or")}) + tmp78 := lang.Apply(tmp73, []any{tmp77, v6}) + tmp79 := lang.Apply(tmp70, []any{tmp78}) + tmp80 := lang.Apply(tmp67, []any{tmp79}) + tmp81 := lang.Apply(tmp52, []any{tmp56, tmp60, tmp64, tmp80}) + tmp82 := lang.Apply(tmp49, []any{tmp81}) + tmp83 := lang.Apply(tmp46, []any{tmp82}) + tmp84 := lang.Apply(tmp12, []any{tmp16, tmp43, tmp83}) + tmp85 := lang.Apply(tmp9, []any{tmp84}) + return tmp85 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // parents { - v0 := lang.NewSymbol("parents").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"))), lang.NewKeyword("doc"), "Returns the immediate parents of tag, either via a Java type\n inheritance relationship or a relationship established via derive. h\n must be a hierarchy obtained from make-hierarchy, if not supplied\n defaults to the global hierarchy", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5564), lang.NewKeyword("end-line"), int(5564))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("parents").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"))), lang.NewKeyword("doc"), "Returns the immediate parents of tag, either via a Java type\n inheritance relationship or a relationship established via derive. h\n must be a hierarchy obtained from make-hierarchy, if not supplied\n defaults to the global hierarchy", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5564), lang.NewKeyword("end-line"), int(5564))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("parents")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("global-hierarchy")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v6, []any{v9, v3}) - return v10 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("parents")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("global-hierarchy")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp6, []any{tmp9, v3}) + return tmp10 case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("not-empty")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("not-empty")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) } - v7 := v6.Get() - var v8 any + tmp7 := tmp6.Get() + var tmp8 any { // let // let binding "tp" - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("get")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.Apply(lang.NewKeyword("parents"), []any{v3}) - v13 := lang.Apply(v11, []any{v12, v4}) - var v14 any = v13 + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("get")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.Apply(lang.NewKeyword("parents"), []any{v3}) + tmp13 := lang.Apply(tmp11, []any{tmp12, v4}) + var v14 any = tmp13 _ = v14 - var v15 any - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("class?")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{v4}) - if lang.IsTruthy(v19) { - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("into1")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("set")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("bases")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) - } - v28 := v27.Get() - v29 := lang.Apply(v28, []any{v4}) - v30 := lang.Apply(v25, []any{v29}) - v31 := lang.Apply(v22, []any{v30, v14}) - v15 = v31 + var tmp15 any + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("class?")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{v4}) + if lang.IsTruthy(tmp19) { + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("into1")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("set")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("bases")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) + } + tmp28 := tmp27.Get() + tmp29 := lang.Apply(tmp28, []any{v4}) + tmp30 := lang.Apply(tmp25, []any{tmp29}) + tmp31 := lang.Apply(tmp22, []any{tmp30, v14}) + tmp15 = tmp31 } else { - v15 = v14 + tmp15 = v14 } - v8 = v15 + tmp8 = tmp15 } // end let - v9 := lang.Apply(v7, []any{v8}) - return v9 + tmp9 := lang.Apply(tmp7, []any{tmp8}) + return tmp9 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // parse-boolean { - v0 := lang.NewSymbol("parse-boolean").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse strings \"true\" or \"false\" and return a boolean, or nil if invalid", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7957), lang.NewKeyword("end-line"), int(7957))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("parse-boolean").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse strings \"true\" or \"false\" and return a boolean, or nil if invalid", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7957), lang.NewKeyword("end-line"), int(7957))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("string?")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v3}) - if lang.IsTruthy(v8) { - var v9 any + var tmp4 any + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("string?")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v3}) + if lang.IsTruthy(tmp8) { + var tmp9 any { // let // let binding "G__353" var v10 any = v3 _ = v10 - v9 = nil } // end let - v4 = v9 + tmp4 = tmp9 } else { - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("parsing-err")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("parsing-err")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{v3}) - v14 := lang.Apply(lang.NewIllegalArgumentError, []any{v13}) - panic(v14) + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp13}) + panic(tmp14) } - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // parse-double { - v0 := lang.NewSymbol("parse-double").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse string with floating point components and return a Double value,\n or nil if parse fails.\n\n Grammar: https://docs.oracle.com/javase/8/docs/api/java/lang/Double.html#valueOf-java.lang.String-", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7935), lang.NewKeyword("end-line"), int(7935))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("parse-double").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse string with floating point components and return a Double value,\n or nil if parse fails.\n\n Grammar: https://docs.oracle.com/javase/8/docs/api/java/lang/Double.html#valueOf-java.lang.String-", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7935), lang.NewKeyword("end-line"), int(7935))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("string?")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v3}) - if lang.IsTruthy(v8) { - var v9 any + var tmp4 any + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("string?")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v3}) + if lang.IsTruthy(tmp8) { + var tmp9 any { // let // let binding "result__3649__auto__" - v10 := lang.Apply(strconv9.ParseFloat, []any{v3, int64(64)}) - var v11 any = v10 + tmp10 := lang.Apply(strconv9.ParseFloat, []any{v3, int64(64)}) + var v11 any = tmp10 _ = v11 - var v12 any - v13 := lang.Apply(v11, []any{int64(1)}) - if lang.IsTruthy(v13) { - v12 = nil + var tmp12 any + tmp13 := lang.Apply(v11, []any{int64(1)}) + if lang.IsTruthy(tmp13) { } else { - v14 := lang.Apply(v11, []any{int64(0)}) - v12 = v14 + tmp14 := lang.Apply(v11, []any{int64(0)}) + tmp12 = tmp14 } - v9 = v12 + tmp9 = tmp12 } // end let - v4 = v9 + tmp4 = tmp9 } else { - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("parsing-err")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("parsing-err")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{v3}) - v14 := lang.Apply(lang.NewIllegalArgumentError, []any{v13}) - panic(v14) + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp13}) + panic(tmp14) } - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // parse-impls { - v0 := lang.NewSymbol("parse-impls").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(13), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(13), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("specs"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("parse-impls").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(13), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(13), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("specs"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any + var tmp4 any { // let // let binding "ret" - v5 := lang.NewMap() - v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(14), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(14), lang.NewKeyword("end-column"), int(15)) - v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) + tmp5 := lang.NewMap() + tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(14), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(14), lang.NewKeyword("end-column"), int(15)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) if err != nil { panic(err) } - var v8 any = v7 + var v8 any = tmp7 _ = v8 // let binding "s" var v9 any = v3 _ = v9 for { - var v10 any - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("seq")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{v9}) - if lang.IsTruthy(v14) { - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("assoc")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("first")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{v9}) - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("take-while")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("seq?")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) - } - v28 := v27.Get() - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("next")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.Apply(v31, []any{v9}) - v33 := lang.Apply(v25, []any{v28, v32}) - v34 := lang.Apply(v18, []any{v8, v22, v33}) - var v15 any = v34 - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("drop-while")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v40 := v39.FindInternedVar(lang.NewSymbol("seq?")) - if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) - } - v41 := v40.Get() - v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v43 := v42.FindInternedVar(lang.NewSymbol("next")) - if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) - } - v44 := v43.Get() - v45 := lang.Apply(v44, []any{v9}) - v46 := lang.Apply(v38, []any{v41, v45}) - var v35 any = v46 - v8 = v15 - v9 = v35 + var tmp10 any + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("seq")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{v9}) + if lang.IsTruthy(tmp14) { + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("assoc")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("first")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, []any{v9}) + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("take-while")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("seq?")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) + } + tmp28 := tmp27.Get() + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("next")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.Apply(tmp31, []any{v9}) + tmp33 := lang.Apply(tmp25, []any{tmp28, tmp32}) + tmp34 := lang.Apply(tmp18, []any{v8, tmp22, tmp33}) + var tmp15 any = tmp34 + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("drop-while")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp40 := tmp39.FindInternedVar(lang.NewSymbol("seq?")) + if tmp40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) + } + tmp41 := tmp40.Get() + tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp43 := tmp42.FindInternedVar(lang.NewSymbol("next")) + if tmp43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) + } + tmp44 := tmp43.Get() + tmp45 := lang.Apply(tmp44, []any{v9}) + tmp46 := lang.Apply(tmp38, []any{tmp41, tmp45}) + var tmp35 any = tmp46 + v8 = tmp15 + v9 = tmp35 continue } else { - v10 = v8 + tmp10 = v8 } - v4 = v10 + tmp4 = tmp10 break } } // end let - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // parse-long { - v0 := lang.NewSymbol("parse-long").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse string of decimal digits with optional leading -/+ and return a\n Long value, or nil if parse fails", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7926), lang.NewKeyword("end-line"), int(7926))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("parse-long").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse string of decimal digits with optional leading -/+ and return a\n Long value, or nil if parse fails", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7926), lang.NewKeyword("end-line"), int(7926))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("string?")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v3}) - if lang.IsTruthy(v8) { - var v9 any + var tmp4 any + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("string?")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v3}) + if lang.IsTruthy(tmp8) { + var tmp9 any { // let // let binding "result__3648__auto__" - v10 := lang.Apply(strconv9.ParseInt, []any{v3, int64(10), int64(64)}) - var v11 any = v10 + tmp10 := lang.Apply(strconv9.ParseInt, []any{v3, int64(10), int64(64)}) + var v11 any = tmp10 _ = v11 - var v12 any - v13 := lang.Apply(v11, []any{int64(1)}) - if lang.IsTruthy(v13) { - v12 = nil + var tmp12 any + tmp13 := lang.Apply(v11, []any{int64(1)}) + if lang.IsTruthy(tmp13) { } else { - v14 := lang.Apply(v11, []any{int64(0)}) - v12 = v14 + tmp14 := lang.Apply(v11, []any{int64(0)}) + tmp12 = tmp14 } - v9 = v12 + tmp9 = tmp12 } // end let - v4 = v9 + tmp4 = tmp9 } else { - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("parsing-err")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("parsing-err")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{v3}) - v14 := lang.Apply(lang.NewIllegalArgumentError, []any{v13}) - panic(v14) + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp13}) + panic(tmp14) } - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // parse-uuid { - v0 := lang.NewSymbol("parse-uuid").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse a string representing a UUID and return a java.util.UUID instance,\n or nil if parse fails.\n\n Grammar: https://docs.oracle.com/javase/8/docs/api/java/util/UUID.html#toString--", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7946), lang.NewKeyword("end-line"), int(7946))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("parse-uuid").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse a string representing a UUID and return a java.util.UUID instance,\n or nil if parse fails.\n\n Grammar: https://docs.oracle.com/javase/8/docs/api/java/util/UUID.html#toString--", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7946), lang.NewKeyword("end-line"), int(7946))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any + var tmp4 any func() { defer func() { if r := recover(); r != nil { - if lang.CatchMatches(r, *lang.IllegalArgumentError) { - v5 := r - _ = v5 - v4 = nil + tmp5 := reflect.TypeOf((*lang.IllegalArgumentError)(nil)) + if lang.CatchMatches(r, tmp5) { + v6 := r + _ = v6 } else { panic(r) } } }() - var v5 any + var tmp6 any { // let // let binding "vec__350" - v6 := lang.Apply(uuid10.Parse, []any{v3}) - var v7 any = v6 - _ = v7 + tmp7 := lang.Apply(uuid10.Parse, []any{v3}) + var v8 any = tmp7 + _ = v8 // let binding "uuid" - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("nth")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v7, int64(0), nil}) - var v12 any = v11 - _ = v12 + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("nth")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.Apply(tmp11, []any{v8, int64(0), nil}) + var v13 any = tmp12 + _ = v13 // let binding "err" - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("nth")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{v7, int64(1), nil}) - var v17 any = v16 - _ = v17 - var v18 any - if lang.IsTruthy(v17) { - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("str")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{"Error parsing UUID: ", v17}) - v23 := lang.Apply(lang.NewIllegalArgumentError, []any{v22}) - panic(v23) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("nth")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{v8, int64(1), nil}) + var v18 any = tmp17 + _ = v18 + var tmp19 any + if lang.IsTruthy(v18) { + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("str")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.Apply(tmp22, []any{"Error parsing UUID: ", v18}) + tmp24 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp23}) + panic(tmp24) } else { - v18 = v12 + tmp19 = v13 } - v5 = v18 + tmp6 = tmp19 } // end let - v4 = v5 + tmp4 = tmp6 }() - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // parsing-err { - v0 := lang.NewSymbol("parsing-err").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Construct message for parsing for non-string parsing error", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(7921), lang.NewKeyword("end-line"), int(7921), lang.NewKeyword("private"), true)).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("parsing-err").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Construct message for parsing for non-string parsing error", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(7921), lang.NewKeyword("end-line"), int(7921), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("str")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - var v7 any - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("nil?")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v3}) - if lang.IsTruthy(v11) { - v7 = "nil" + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("str")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + var tmp7 any + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("nil?")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v3}) + if lang.IsTruthy(tmp11) { + tmp7 = "nil" } else { - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("class")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.Apply(v14, []any{v3}) - v16, ok := lang.FieldOrMethod(v15, "Name") + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("class")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.Apply(tmp14, []any{v3}) + tmp16, ok := lang.FieldOrMethod(tmp15, "Name") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v15, "Name"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp15, "Name"))) } - var v17 any - switch reflect.TypeOf(v16).Kind() { + var tmp17 any + switch reflect.TypeOf(tmp16).Kind() { case reflect.Func: - v17 = lang.Apply(v16, nil) + tmp17 = lang.Apply(tmp16, nil) default: - v17 = v16 + tmp17 = tmp16 } - v7 = v17 + tmp7 = tmp17 } - v18 := lang.Apply(v6, []any{"Expected string, got ", v7}) - return v18 + tmp18 := lang.Apply(tmp6, []any{"Expected string, got ", tmp7}) + return tmp18 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // partial { - v0 := lang.NewSymbol("partial").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("arg1")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("arg1"), lang.NewSymbol("arg2")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("arg1"), lang.NewSymbol("arg2"), lang.NewSymbol("arg3")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("arg1"), lang.NewSymbol("arg2"), lang.NewSymbol("arg3"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Takes a function f and fewer than the normal arguments to f, and\n returns a fn that takes a variable number of additional args. When\n called, the returned function calls f with args + additional args.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2606), lang.NewKeyword("end-line"), int(2606))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("partial").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("arg1")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("arg1"), lang.NewSymbol("arg2")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("arg1"), lang.NewSymbol("arg2"), lang.NewSymbol("arg3")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("arg1"), lang.NewSymbol("arg2"), lang.NewSymbol("arg3"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Takes a function f and fewer than the normal arguments to f, and\n returns a fn that takes a variable number of additional args. When\n called, the returned function calls f with args + additional args.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2606), lang.NewKeyword("end-line"), int(2606))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] @@ -60698,24 +60822,24 @@ func init() { _ = v3 v4 := args[1] _ = v4 - var v5 lang.FnFunc - v5 = lang.NewFnFunc(func(args ...any) any { + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - v6 := lang.Apply(v3, []any{v4}) - return v6 + tmp6 := lang.Apply(v3, []any{v4}) + return tmp6 case 1: v6 := args[0] _ = v6 - v7 := lang.Apply(v3, []any{v4, v6}) - return v7 + tmp7 := lang.Apply(v3, []any{v4, v6}) + return tmp7 case 2: v6 := args[0] _ = v6 v7 := args[1] _ = v7 - v8 := lang.Apply(v3, []any{v4, v6, v7}) - return v8 + tmp8 := lang.Apply(v3, []any{v4, v6, v7}) + return tmp8 case 3: v6 := args[0] _ = v6 @@ -60723,8 +60847,8 @@ func init() { _ = v7 v8 := args[2] _ = v8 - v9 := lang.Apply(v3, []any{v4, v6, v7, v8}) - return v9 + tmp9 := lang.Apply(v3, []any{v4, v6, v7, v8}) + return tmp9 default: if len(args) < 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -60735,23 +60859,24 @@ func init() { _ = v7 v8 := args[2] _ = v8 - v9 := lang.NewList(args[3:]...) - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("apply")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + var v9 any = lang.NewList(args[3:]...) + _ = v9 + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("apply")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{v3, v4, v6, v7, v8, v9}) - return v13 + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{v3, v4, v6, v7, v8, v9}) + return tmp13 } }) - v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2614), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(2619), lang.NewKeyword("end-column"), int(48)) - v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) + tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2614), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(2619), lang.NewKeyword("end-column"), int(48)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) if err != nil { panic(err) } - return v7 + return tmp7 case 3: v3 := args[0] _ = v3 @@ -60759,24 +60884,24 @@ func init() { _ = v4 v5 := args[2] _ = v5 - var v6 lang.FnFunc - v6 = lang.NewFnFunc(func(args ...any) any { + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - v7 := lang.Apply(v3, []any{v4, v5}) - return v7 + tmp7 := lang.Apply(v3, []any{v4, v5}) + return tmp7 case 1: v7 := args[0] _ = v7 - v8 := lang.Apply(v3, []any{v4, v5, v7}) - return v8 + tmp8 := lang.Apply(v3, []any{v4, v5, v7}) + return tmp8 case 2: v7 := args[0] _ = v7 v8 := args[1] _ = v8 - v9 := lang.Apply(v3, []any{v4, v5, v7, v8}) - return v9 + tmp9 := lang.Apply(v3, []any{v4, v5, v7, v8}) + return tmp9 case 3: v7 := args[0] _ = v7 @@ -60784,8 +60909,8 @@ func init() { _ = v8 v9 := args[2] _ = v9 - v10 := lang.Apply(v3, []any{v4, v5, v7, v8, v9}) - return v10 + tmp10 := lang.Apply(v3, []any{v4, v5, v7, v8, v9}) + return tmp10 default: if len(args) < 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -60796,23 +60921,24 @@ func init() { _ = v8 v9 := args[2] _ = v9 - v10 := lang.NewList(args[3:]...) - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("apply")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + var v10 any = lang.NewList(args[3:]...) + _ = v10 + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("apply")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{v3, v4, v5, v7, v8, v9, v10}) - return v14 + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{v3, v4, v5, v7, v8, v9, v10}) + return tmp14 } }) - v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2621), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(2626), lang.NewKeyword("end-column"), int(53)) - v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) + tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2621), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(2626), lang.NewKeyword("end-column"), int(53)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) if err != nil { panic(err) } - return v8 + return tmp8 case 4: v3 := args[0] _ = v3 @@ -60822,24 +60948,24 @@ func init() { _ = v5 v6 := args[3] _ = v6 - var v7 lang.FnFunc - v7 = lang.NewFnFunc(func(args ...any) any { + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - v8 := lang.Apply(v3, []any{v4, v5, v6}) - return v8 + tmp8 := lang.Apply(v3, []any{v4, v5, v6}) + return tmp8 case 1: v8 := args[0] _ = v8 - v9 := lang.Apply(v3, []any{v4, v5, v6, v8}) - return v9 + tmp9 := lang.Apply(v3, []any{v4, v5, v6, v8}) + return tmp9 case 2: v8 := args[0] _ = v8 v9 := args[1] _ = v9 - v10 := lang.Apply(v3, []any{v4, v5, v6, v8, v9}) - return v10 + tmp10 := lang.Apply(v3, []any{v4, v5, v6, v8, v9}) + return tmp10 case 3: v8 := args[0] _ = v8 @@ -60847,8 +60973,8 @@ func init() { _ = v9 v10 := args[2] _ = v10 - v11 := lang.Apply(v3, []any{v4, v5, v6, v8, v9, v10}) - return v11 + tmp11 := lang.Apply(v3, []any{v4, v5, v6, v8, v9, v10}) + return tmp11 default: if len(args) < 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -60859,23 +60985,24 @@ func init() { _ = v9 v10 := args[2] _ = v10 - v11 := lang.NewList(args[3:]...) - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("apply")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + var v11 any = lang.NewList(args[3:]...) + _ = v11 + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("apply")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) } - v14 := v13.Get() - v15 := lang.Apply(v14, []any{v3, v4, v5, v6, v8, v9, v10, v11}) - return v15 + tmp14 := tmp13.Get() + tmp15 := lang.Apply(tmp14, []any{v3, v4, v5, v6, v8, v9, v10, v11}) + return tmp15 } }) - v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2628), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(2633), lang.NewKeyword("end-column"), int(58)) - v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) + tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2628), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(2633), lang.NewKeyword("end-column"), int(58)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) if err != nil { panic(err) } - return v9 + return tmp9 default: if len(args) < 4 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -60888,65 +61015,67 @@ func init() { _ = v5 v6 := args[3] _ = v6 - v7 := lang.NewList(args[4:]...) - var v8 lang.FnFunc - v8 = lang.NewFnFunc(func(args ...any) any { + var v7 any = lang.NewList(args[4:]...) + _ = v7 + var tmp8 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v9 := lang.NewList(args[0:]...) - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("apply")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("concat")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{v7, v9}) - v17 := lang.Apply(v12, []any{v3, v4, v5, v6, v16}) - return v17 + var v9 any = lang.NewList(args[0:]...) + _ = v9 + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("apply")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("concat")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{v7, v9}) + tmp17 := lang.Apply(tmp12, []any{v3, v4, v5, v6, tmp16}) + return tmp17 } }) - v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2635), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(2635), lang.NewKeyword("end-column"), int(60)) - v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) + tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2635), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(2635), lang.NewKeyword("end-column"), int(60)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) if err != nil { panic(err) } - return v10 + return tmp10 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // partition { - v0 := lang.NewSymbol("partition").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("pad"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of lists of n items each, at offsets step\n apart. If step is not supplied, defaults to n, i.e. the partitions\n do not overlap. If a pad collection is supplied, use its elements as\n necessary to complete last partition upto n items. In case there are\n not enough padding elements, return a partition with less than n items.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3177), lang.NewKeyword("end-line"), int(3177))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("partition").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("pad"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of lists of n items each, at offsets step\n apart. If step is not supplied, defaults to n, i.e. the partitions\n do not overlap. If a pad collection is supplied, use its elements as\n necessary to complete last partition upto n items. In case there are\n not enough padding elements, return a partition with less than n items.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3177), lang.NewKeyword("end-line"), int(3177))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("partition")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v3, v3, v4}) - return v8 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("partition")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v3, v3, v4}) + return tmp8 case 3: v3 := args[0] _ = v3 @@ -60954,104 +61083,102 @@ func init() { _ = v4 v5 := args[2] _ = v5 - var v6 lang.FnFunc - v6 = lang.NewFnFunc(func(args ...any) any { + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - var v7 any + var tmp7 any { // let // let binding "temp__0__auto__" - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("seq")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v5}) - var v12 any = v11 + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("seq")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v5}) + var v12 any = tmp11 _ = v12 - var v13 any + var tmp13 any if lang.IsTruthy(v12) { - var v14 any + var tmp14 any { // let // let binding "s" var v15 any = v12 _ = v15 - var v16 any + var tmp16 any { // let // let binding "p" - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("doall")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("doall")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) } - v19 := v18.Get() - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("take")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + tmp19 := tmp18.Get() + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("take")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) } - v22 := v21.Get() - v23 := lang.Apply(v22, []any{v3, v15}) - v24 := lang.Apply(v19, []any{v23}) - var v25 any = v24 + tmp22 := tmp21.Get() + tmp23 := lang.Apply(tmp22, []any{v3, v15}) + tmp24 := lang.Apply(tmp19, []any{tmp23}) + var v25 any = tmp24 _ = v25 - var v26 any - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("=")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + var tmp26 any + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("=")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) } - v29 := v28.Get() - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("count")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + tmp29 := tmp28.Get() + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("count")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) } - v32 := v31.Get() - v33 := lang.Apply(v32, []any{v25}) - v34 := lang.Apply(v29, []any{v3, v33}) - if lang.IsTruthy(v34) { - v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v36 := v35.FindInternedVar(lang.NewSymbol("cons")) - if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + tmp32 := tmp31.Get() + tmp33 := lang.Apply(tmp32, []any{v25}) + tmp34 := lang.Apply(tmp29, []any{v3, tmp33}) + if lang.IsTruthy(tmp34) { + tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp36 := tmp35.FindInternedVar(lang.NewSymbol("cons")) + if tmp36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) } - v37 := v36.Get() - v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v39 := v38.FindInternedVar(lang.NewSymbol("partition")) - if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + tmp37 := tmp36.Get() + tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp39 := tmp38.FindInternedVar(lang.NewSymbol("partition")) + if tmp39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) } - v40 := v39.Get() - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("nthrest")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + tmp40 := tmp39.Get() + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("nthrest")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) } - v43 := v42.Get() - v44 := lang.Apply(v43, []any{v15, v4}) - v45 := lang.Apply(v40, []any{v3, v4, v44}) - v46 := lang.Apply(v37, []any{v25, v45}) - v26 = v46 + tmp43 := tmp42.Get() + tmp44 := lang.Apply(tmp43, []any{v15, v4}) + tmp45 := lang.Apply(tmp40, []any{v3, v4, tmp44}) + tmp46 := lang.Apply(tmp37, []any{v25, tmp45}) + tmp26 = tmp46 } else { - v26 = nil } - v16 = v26 + tmp16 = tmp26 } // end let - v14 = v16 + tmp14 = tmp16 } // end let - v13 = v14 + tmp13 = tmp14 } else { - v13 = nil } - v7 = v13 + tmp7 = tmp13 } // end let - return v7 + return tmp7 }) - v7 := lang.Apply(lang.NewLazySeq, []any{v6}) - return v7 + tmp7 := lang.Apply(lang.NewLazySeq, []any{tmp6}) + return tmp7 case 4: v3 := args[0] _ = v3 @@ -61061,350 +61188,349 @@ func init() { _ = v5 v6 := args[3] _ = v6 - var v7 lang.FnFunc - v7 = lang.NewFnFunc(func(args ...any) any { + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - var v8 any + var tmp8 any { // let // let binding "temp__0__auto__" - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("seq")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.Apply(v11, []any{v6}) - var v13 any = v12 + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("seq")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.Apply(tmp11, []any{v6}) + var v13 any = tmp12 _ = v13 - var v14 any + var tmp14 any if lang.IsTruthy(v13) { - var v15 any + var tmp15 any { // let // let binding "s" var v16 any = v13 _ = v16 - var v17 any + var tmp17 any { // let // let binding "p" - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("doall")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("doall")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) } - v20 := v19.Get() - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("take")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + tmp20 := tmp19.Get() + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("take")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) } - v23 := v22.Get() - v24 := lang.Apply(v23, []any{v3, v16}) - v25 := lang.Apply(v20, []any{v24}) - var v26 any = v25 + tmp23 := tmp22.Get() + tmp24 := lang.Apply(tmp23, []any{v3, v16}) + tmp25 := lang.Apply(tmp20, []any{tmp24}) + var v26 any = tmp25 _ = v26 - var v27 any - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("=")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + var tmp27 any + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("=")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) } - v30 := v29.Get() - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("count")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + tmp30 := tmp29.Get() + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("count")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{v26}) - v35 := lang.Apply(v30, []any{v3, v34}) - if lang.IsTruthy(v35) { - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("cons")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{v26}) + tmp35 := lang.Apply(tmp30, []any{v3, tmp34}) + if lang.IsTruthy(tmp35) { + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("cons")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) } - v38 := v37.Get() - v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v40 := v39.FindInternedVar(lang.NewSymbol("partition")) - if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) + tmp38 := tmp37.Get() + tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp40 := tmp39.FindInternedVar(lang.NewSymbol("partition")) + if tmp40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) } - v41 := v40.Get() - v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v43 := v42.FindInternedVar(lang.NewSymbol("nthrest")) - if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) + tmp41 := tmp40.Get() + tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp43 := tmp42.FindInternedVar(lang.NewSymbol("nthrest")) + if tmp43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) } - v44 := v43.Get() - v45 := lang.Apply(v44, []any{v16, v4}) - v46 := lang.Apply(v41, []any{v3, v4, v5, v45}) - v47 := lang.Apply(v38, []any{v26, v46}) - v27 = v47 + tmp44 := tmp43.Get() + tmp45 := lang.Apply(tmp44, []any{v16, v4}) + tmp46 := lang.Apply(tmp41, []any{v3, v4, v5, tmp45}) + tmp47 := lang.Apply(tmp38, []any{v26, tmp46}) + tmp27 = tmp47 } else { - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("list")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) } - v50 := v49.Get() - v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v52 := v51.FindInternedVar(lang.NewSymbol("take")) - if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) + tmp50 := tmp49.Get() + tmp51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp52 := tmp51.FindInternedVar(lang.NewSymbol("take")) + if tmp52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp52))) } - v53 := v52.Get() - v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v55 := v54.FindInternedVar(lang.NewSymbol("concat")) - if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) + tmp53 := tmp52.Get() + tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp55 := tmp54.FindInternedVar(lang.NewSymbol("concat")) + if tmp55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) } - v56 := v55.Get() - v57 := lang.Apply(v56, []any{v26, v5}) - v58 := lang.Apply(v53, []any{v3, v57}) - v59 := lang.Apply(v50, []any{v58}) - v27 = v59 + tmp56 := tmp55.Get() + tmp57 := lang.Apply(tmp56, []any{v26, v5}) + tmp58 := lang.Apply(tmp53, []any{v3, tmp57}) + tmp59 := lang.Apply(tmp50, []any{tmp58}) + tmp27 = tmp59 } - v17 = v27 + tmp17 = tmp27 } // end let - v15 = v17 + tmp15 = tmp17 } // end let - v14 = v15 + tmp14 = tmp15 } else { - v14 = nil } - v8 = v14 + tmp8 = tmp14 } // end let - return v8 + return tmp8 }) - v8 := lang.Apply(lang.NewLazySeq, []any{v7}) - return v8 + tmp8 := lang.Apply(lang.NewLazySeq, []any{tmp7}) + return tmp8 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // partition-all { - v0 := lang.NewSymbol("partition-all").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of lists like partition, but may include\n partitions with fewer than n items at the end. Returns a stateful\n transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7222), lang.NewKeyword("end-line"), int(7222))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("partition-all").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of lists like partition, but may include\n partitions with fewer than n items at the end. Returns a stateful\n transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7222), lang.NewKeyword("end-line"), int(7222))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - var v4 lang.FnFunc - v4 = lang.NewFnFunc(func(args ...any) any { + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v5 := args[0] _ = v5 - var v6 any + var tmp6 any { // let // let binding "a" - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("to-array")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v9, []any{v3}) - v11 := lang.Apply(lang.NewArrayList, []any{v10}) - var v12 any = v11 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("to-array")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp9, []any{v3}) + tmp11 := lang.Apply(lang.NewArrayList, []any{tmp10}) + var v12 any = tmp11 _ = v12 - var v13 lang.FnFunc - v13 = lang.NewFnFunc(func(args ...any) any { + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - v14 := lang.Apply(v5, nil) - return v14 + tmp14 := lang.Apply(v5, nil) + return tmp14 case 1: v14 := args[0] _ = v14 - var v15 any + var tmp15 any { // let // let binding "result" - var v16 any - v17, ok := lang.FieldOrMethod(v12, "isEmpty") + var tmp16 any + tmp17, ok := lang.FieldOrMethod(v12, "isEmpty") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v12, "isEmpty"))) } - var v18 any - switch reflect.TypeOf(v17).Kind() { + var tmp18 any + switch reflect.TypeOf(tmp17).Kind() { case reflect.Func: - v18 = lang.Apply(v17, nil) + tmp18 = lang.Apply(tmp17, nil) default: - v18 = v17 + tmp18 = tmp17 } - if lang.IsTruthy(v18) { - v16 = v14 + if lang.IsTruthy(tmp18) { + tmp16 = v14 } else { - var v19 any + var tmp19 any { // let // let binding "v" - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("vec")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("vec")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) } - v22 := v21.Get() - v23, ok := lang.FieldOrMethod(v12, "toArray") + tmp22 := tmp21.Get() + tmp23, ok := lang.FieldOrMethod(v12, "toArray") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v12, "toArray"))) } - var v24 any - switch reflect.TypeOf(v23).Kind() { + var tmp24 any + switch reflect.TypeOf(tmp23).Kind() { case reflect.Func: - v24 = lang.Apply(v23, nil) + tmp24 = lang.Apply(tmp23, nil) default: - v24 = v23 + tmp24 = tmp23 } - v25 := lang.Apply(v22, []any{v24}) - var v26 any = v25 + tmp25 := lang.Apply(tmp22, []any{tmp24}) + var v26 any = tmp25 _ = v26 - v27, ok := lang.FieldOrMethod(v12, "clear") + tmp27, ok := lang.FieldOrMethod(v12, "clear") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v12, "clear"))) } - var v28 any - switch reflect.TypeOf(v27).Kind() { + var tmp28 any + switch reflect.TypeOf(tmp27).Kind() { case reflect.Func: - v28 = lang.Apply(v27, nil) + tmp28 = lang.Apply(tmp27, nil) default: - v28 = v27 + tmp28 = tmp27 } - _ = v28 - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("unreduced")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + _ = tmp28 + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("unreduced")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) } - v31 := v30.Get() - v32 := lang.Apply(v5, []any{v14, v26}) - v33 := lang.Apply(v31, []any{v32}) - v19 = v33 + tmp31 := tmp30.Get() + tmp32 := lang.Apply(v5, []any{v14, v26}) + tmp33 := lang.Apply(tmp31, []any{tmp32}) + tmp19 = tmp33 } // end let - v16 = v19 + tmp16 = tmp19 } - var v20 any = v16 + var v20 any = tmp16 _ = v20 - v21 := lang.Apply(v5, []any{v20}) - v15 = v21 + tmp21 := lang.Apply(v5, []any{v20}) + tmp15 = tmp21 } // end let - return v15 + return tmp15 case 2: v14 := args[0] _ = v14 v15 := args[1] _ = v15 - v16, _ := lang.FieldOrMethod(v12, "add") - if reflect.TypeOf(v16).Kind() != reflect.Func { + tmp16, _ := lang.FieldOrMethod(v12, "add") + if reflect.TypeOf(tmp16).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) } - v17 := lang.Apply(v16, []any{v15}) - _ = v17 - var v18 any - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("=")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + tmp17 := lang.Apply(tmp16, []any{v15}) + _ = tmp17 + var tmp18 any + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("=")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) } - v21 := v20.Get() - v22, ok := lang.FieldOrMethod(v12, "size") + tmp21 := tmp20.Get() + tmp22, ok := lang.FieldOrMethod(v12, "size") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v12, "size"))) } - var v23 any - switch reflect.TypeOf(v22).Kind() { + var tmp23 any + switch reflect.TypeOf(tmp22).Kind() { case reflect.Func: - v23 = lang.Apply(v22, nil) + tmp23 = lang.Apply(tmp22, nil) default: - v23 = v22 + tmp23 = tmp22 } - v24 := lang.Apply(v21, []any{v3, v23}) - if lang.IsTruthy(v24) { - var v25 any + tmp24 := lang.Apply(tmp21, []any{v3, tmp23}) + if lang.IsTruthy(tmp24) { + var tmp25 any { // let // let binding "v" - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("vec")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("vec")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) } - v28 := v27.Get() - v29, ok := lang.FieldOrMethod(v12, "toArray") + tmp28 := tmp27.Get() + tmp29, ok := lang.FieldOrMethod(v12, "toArray") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v12, "toArray"))) } - var v30 any - switch reflect.TypeOf(v29).Kind() { + var tmp30 any + switch reflect.TypeOf(tmp29).Kind() { case reflect.Func: - v30 = lang.Apply(v29, nil) + tmp30 = lang.Apply(tmp29, nil) default: - v30 = v29 + tmp30 = tmp29 } - v31 := lang.Apply(v28, []any{v30}) - var v32 any = v31 + tmp31 := lang.Apply(tmp28, []any{tmp30}) + var v32 any = tmp31 _ = v32 - v33, ok := lang.FieldOrMethod(v12, "clear") + tmp33, ok := lang.FieldOrMethod(v12, "clear") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v12, "clear"))) } - var v34 any - switch reflect.TypeOf(v33).Kind() { + var tmp34 any + switch reflect.TypeOf(tmp33).Kind() { case reflect.Func: - v34 = lang.Apply(v33, nil) + tmp34 = lang.Apply(tmp33, nil) default: - v34 = v33 + tmp34 = tmp33 } - _ = v34 - v35 := lang.Apply(v5, []any{v14, v32}) - v25 = v35 + _ = tmp34 + tmp35 := lang.Apply(v5, []any{v14, v32}) + tmp25 = tmp35 } // end let - v18 = v25 + tmp18 = tmp25 } else { - v18 = v14 + tmp18 = v14 } - return v18 + return tmp18 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7231), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7247), lang.NewKeyword("end-column"), int(23)) - v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) + tmp14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7231), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7247), lang.NewKeyword("end-column"), int(23)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) if err != nil { panic(err) } - v6 = v15 + tmp6 = tmp15 } // end let - return v6 + return tmp6 }) - v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7229), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7247), lang.NewKeyword("end-column"), int(25)) - v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) + tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7229), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7247), lang.NewKeyword("end-column"), int(25)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) if err != nil { panic(err) } - return v6 + return tmp6 case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("partition-all")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v3, v3, v4}) - return v8 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("partition-all")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v3, v3, v4}) + return tmp8 case 3: v3 := args[0] _ = v3 @@ -61412,529 +61538,526 @@ func init() { _ = v4 v5 := args[2] _ = v5 - var v6 lang.FnFunc - v6 = lang.NewFnFunc(func(args ...any) any { + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - var v7 any + var tmp7 any { // let // let binding "temp__0__auto__" - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("seq")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v5}) - var v12 any = v11 + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("seq")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v5}) + var v12 any = tmp11 _ = v12 - var v13 any + var tmp13 any if lang.IsTruthy(v12) { - var v14 any + var tmp14 any { // let // let binding "s" var v15 any = v12 _ = v15 - var v16 any + var tmp16 any { // let // let binding "seg" - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("doall")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("doall")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) } - v19 := v18.Get() - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("take")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + tmp19 := tmp18.Get() + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("take")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) } - v22 := v21.Get() - v23 := lang.Apply(v22, []any{v3, v15}) - v24 := lang.Apply(v19, []any{v23}) - var v25 any = v24 + tmp22 := tmp21.Get() + tmp23 := lang.Apply(tmp22, []any{v3, v15}) + tmp24 := lang.Apply(tmp19, []any{tmp23}) + var v25 any = tmp24 _ = v25 - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("cons")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("cons")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) } - v28 := v27.Get() - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("partition-all")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + tmp28 := tmp27.Get() + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("partition-all")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) } - v31 := v30.Get() - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("nthrest")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + tmp31 := tmp30.Get() + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("nthrest")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{v15, v4}) - v36 := lang.Apply(v31, []any{v3, v4, v35}) - v37 := lang.Apply(v28, []any{v25, v36}) - v16 = v37 + tmp34 := tmp33.Get() + tmp35 := lang.Apply(tmp34, []any{v15, v4}) + tmp36 := lang.Apply(tmp31, []any{v3, v4, tmp35}) + tmp37 := lang.Apply(tmp28, []any{v25, tmp36}) + tmp16 = tmp37 } // end let - v14 = v16 + tmp14 = tmp16 } // end let - v13 = v14 + tmp13 = tmp14 } else { - v13 = nil } - v7 = v13 + tmp7 = tmp13 } // end let - return v7 + return tmp7 }) - v7 := lang.Apply(lang.NewLazySeq, []any{v6}) - return v7 + tmp7 := lang.Apply(lang.NewLazySeq, []any{tmp6}) + return tmp7 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // partition-by { - v0 := lang.NewSymbol("partition-by").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Applies f to each value in coll, splitting it each time f returns a\n new value. Returns a lazy seq of partitions. Returns a stateful\n transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7142), lang.NewKeyword("end-line"), int(7142))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("partition-by").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Applies f to each value in coll, splitting it each time f returns a\n new value. Returns a lazy seq of partitions. Returns a stateful\n transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7142), lang.NewKeyword("end-line"), int(7142))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - var v4 lang.FnFunc - v4 = lang.NewFnFunc(func(args ...any) any { + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v5 := args[0] _ = v5 - var v6 any + var tmp6 any { // let // let binding "a" var v7 any = "unimplemented: new with non-constant class type" _ = v7 // let binding "pv" - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("volatile!")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{lang.NewKeyword("glojure.core/none")}) - var v12 any = v11 + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("volatile!")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{lang.NewKeyword("glojure.core/none")}) + var v12 any = tmp11 _ = v12 - var v13 lang.FnFunc - v13 = lang.NewFnFunc(func(args ...any) any { + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - v14 := lang.Apply(v5, nil) - return v14 + tmp14 := lang.Apply(v5, nil) + return tmp14 case 1: v14 := args[0] _ = v14 - var v15 any + var tmp15 any { // let // let binding "result" - var v16 any - v17, ok := lang.FieldOrMethod(v7, "isEmpty") + var tmp16 any + tmp17, ok := lang.FieldOrMethod(v7, "isEmpty") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "isEmpty"))) } - var v18 any - switch reflect.TypeOf(v17).Kind() { + var tmp18 any + switch reflect.TypeOf(tmp17).Kind() { case reflect.Func: - v18 = lang.Apply(v17, nil) + tmp18 = lang.Apply(tmp17, nil) default: - v18 = v17 + tmp18 = tmp17 } - if lang.IsTruthy(v18) { - v16 = v14 + if lang.IsTruthy(tmp18) { + tmp16 = v14 } else { - var v19 any + var tmp19 any { // let // let binding "v" - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("vec")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("vec")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) } - v22 := v21.Get() - v23, ok := lang.FieldOrMethod(v7, "toArray") + tmp22 := tmp21.Get() + tmp23, ok := lang.FieldOrMethod(v7, "toArray") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "toArray"))) } - var v24 any - switch reflect.TypeOf(v23).Kind() { + var tmp24 any + switch reflect.TypeOf(tmp23).Kind() { case reflect.Func: - v24 = lang.Apply(v23, nil) + tmp24 = lang.Apply(tmp23, nil) default: - v24 = v23 + tmp24 = tmp23 } - v25 := lang.Apply(v22, []any{v24}) - var v26 any = v25 + tmp25 := lang.Apply(tmp22, []any{tmp24}) + var v26 any = tmp25 _ = v26 - v27, ok := lang.FieldOrMethod(v7, "clear") + tmp27, ok := lang.FieldOrMethod(v7, "clear") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "clear"))) } - var v28 any - switch reflect.TypeOf(v27).Kind() { + var tmp28 any + switch reflect.TypeOf(tmp27).Kind() { case reflect.Func: - v28 = lang.Apply(v27, nil) + tmp28 = lang.Apply(tmp27, nil) default: - v28 = v27 + tmp28 = tmp27 } - _ = v28 - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("unreduced")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + _ = tmp28 + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("unreduced")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) } - v31 := v30.Get() - v32 := lang.Apply(v5, []any{v14, v26}) - v33 := lang.Apply(v31, []any{v32}) - v19 = v33 + tmp31 := tmp30.Get() + tmp32 := lang.Apply(v5, []any{v14, v26}) + tmp33 := lang.Apply(tmp31, []any{tmp32}) + tmp19 = tmp33 } // end let - v16 = v19 + tmp16 = tmp19 } - var v20 any = v16 + var v20 any = tmp16 _ = v20 - v21 := lang.Apply(v5, []any{v20}) - v15 = v21 + tmp21 := lang.Apply(v5, []any{v20}) + tmp15 = tmp21 } // end let - return v15 + return tmp15 case 2: v14 := args[0] _ = v14 v15 := args[1] _ = v15 - var v16 any + var tmp16 any { // let // let binding "pval" - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("deref")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("deref")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) } - v19 := v18.Get() - v20 := lang.Apply(v19, []any{v12}) - var v21 any = v20 + tmp19 := tmp18.Get() + tmp20 := lang.Apply(tmp19, []any{v12}) + var v21 any = tmp20 _ = v21 // let binding "val" - v22 := lang.Apply(v3, []any{v15}) - var v23 any = v22 + tmp22 := lang.Apply(v3, []any{v15}) + var v23 any = tmp22 _ = v23 - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("vreset!")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("vreset!")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) } - v26 := v25.Get() - v27 := lang.Apply(v26, []any{v12, v23}) - _ = v27 - var v28 any - var v29 any + tmp26 := tmp25.Get() + tmp27 := lang.Apply(tmp26, []any{v12, v23}) + _ = tmp27 + var tmp28 any + var tmp29 any { // let // let binding "or__0__auto__" - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("identical?")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("identical?")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) } - v32 := v31.Get() - v33 := lang.Apply(v32, []any{v21, lang.NewKeyword("glojure.core/none")}) - var v34 any = v33 + tmp32 := tmp31.Get() + tmp33 := lang.Apply(tmp32, []any{v21, lang.NewKeyword("glojure.core/none")}) + var v34 any = tmp33 _ = v34 - var v35 any + var tmp35 any if lang.IsTruthy(v34) { - v35 = v34 + tmp35 = v34 } else { - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("=")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("=")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) } - v38 := v37.Get() - v39 := lang.Apply(v38, []any{v23, v21}) - v35 = v39 + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{v23, v21}) + tmp35 = tmp39 } - v29 = v35 + tmp29 = tmp35 } // end let - if lang.IsTruthy(v29) { - v30, _ := lang.FieldOrMethod(v7, "add") - if reflect.TypeOf(v30).Kind() != reflect.Func { + if lang.IsTruthy(tmp29) { + tmp30, _ := lang.FieldOrMethod(v7, "add") + if reflect.TypeOf(tmp30).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) } - v31 := lang.Apply(v30, []any{v15}) - _ = v31 - v28 = v14 + tmp31 := lang.Apply(tmp30, []any{v15}) + _ = tmp31 + tmp28 = v14 } else { - var v32 any + var tmp32 any { // let // let binding "v" - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("vec")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("vec")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) } - v35 := v34.Get() - v36, ok := lang.FieldOrMethod(v7, "toArray") + tmp35 := tmp34.Get() + tmp36, ok := lang.FieldOrMethod(v7, "toArray") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "toArray"))) } - var v37 any - switch reflect.TypeOf(v36).Kind() { + var tmp37 any + switch reflect.TypeOf(tmp36).Kind() { case reflect.Func: - v37 = lang.Apply(v36, nil) + tmp37 = lang.Apply(tmp36, nil) default: - v37 = v36 + tmp37 = tmp36 } - v38 := lang.Apply(v35, []any{v37}) - var v39 any = v38 + tmp38 := lang.Apply(tmp35, []any{tmp37}) + var v39 any = tmp38 _ = v39 - v40, ok := lang.FieldOrMethod(v7, "clear") + tmp40, ok := lang.FieldOrMethod(v7, "clear") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "clear"))) } - var v41 any - switch reflect.TypeOf(v40).Kind() { + var tmp41 any + switch reflect.TypeOf(tmp40).Kind() { case reflect.Func: - v41 = lang.Apply(v40, nil) + tmp41 = lang.Apply(tmp40, nil) default: - v41 = v40 + tmp41 = tmp40 } - _ = v41 - var v42 any + _ = tmp41 + var tmp42 any { // let // let binding "ret" - v43 := lang.Apply(v5, []any{v14, v39}) - var v44 any = v43 + tmp43 := lang.Apply(v5, []any{v14, v39}) + var v44 any = tmp43 _ = v44 - var v45 any - v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v47 := v46.FindInternedVar(lang.NewSymbol("reduced?")) - if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) + var tmp45 any + tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp47 := tmp46.FindInternedVar(lang.NewSymbol("reduced?")) + if tmp47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) } - v48 := v47.Get() - v49 := lang.Apply(v48, []any{v44}) - if lang.IsTruthy(v49) { - v45 = nil + tmp48 := tmp47.Get() + tmp49 := lang.Apply(tmp48, []any{v44}) + if lang.IsTruthy(tmp49) { } else { - v50, _ := lang.FieldOrMethod(v7, "add") - if reflect.TypeOf(v50).Kind() != reflect.Func { + tmp50, _ := lang.FieldOrMethod(v7, "add") + if reflect.TypeOf(tmp50).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) } - v51 := lang.Apply(v50, []any{v15}) - v45 = v51 + tmp51 := lang.Apply(tmp50, []any{v15}) + tmp45 = tmp51 } - _ = v45 - v42 = v44 + _ = tmp45 + tmp42 = v44 } // end let - v32 = v42 + tmp32 = tmp42 } // end let - v28 = v32 + tmp28 = tmp32 } - v16 = v28 + tmp16 = tmp28 } // end let - return v16 + return tmp16 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7152), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(7176), lang.NewKeyword("end-column"), int(28)) - v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) + tmp14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7152), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(7176), lang.NewKeyword("end-column"), int(28)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) if err != nil { panic(err) } - v6 = v15 + tmp6 = tmp15 } // end let - return v6 + return tmp6 }) - v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7149), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(7176), lang.NewKeyword("end-column"), int(30)) - v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) + tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7149), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(7176), lang.NewKeyword("end-column"), int(30)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) if err != nil { panic(err) } - return v6 + return tmp6 case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - var v5 lang.FnFunc - v5 = lang.NewFnFunc(func(args ...any) any { + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - var v6 any + var tmp6 any { // let // let binding "temp__0__auto__" - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("seq")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v9, []any{v4}) - var v11 any = v10 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("seq")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp9, []any{v4}) + var v11 any = tmp10 _ = v11 - var v12 any + var tmp12 any if lang.IsTruthy(v11) { - var v13 any + var tmp13 any { // let // let binding "s" var v14 any = v11 _ = v14 - var v15 any + var tmp15 any { // let // let binding "fst" - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("first")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("first")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{v14}) - var v20 any = v19 + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{v14}) + var v20 any = tmp19 _ = v20 // let binding "fv" - v21 := lang.Apply(v3, []any{v20}) - var v22 any = v21 + tmp21 := lang.Apply(v3, []any{v20}) + var v22 any = tmp21 _ = v22 // let binding "run" - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("cons")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("cons")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) } - v25 := v24.Get() - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("take-while")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + tmp25 := tmp24.Get() + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("take-while")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) } - v28 := v27.Get() - var v29 lang.FnFunc - v29 = lang.NewFnFunc(func(args ...any) any { + tmp28 := tmp27.Get() + var tmp29 lang.FnFunc + tmp29 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v30 := args[0] _ = v30 - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("=")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("=")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) } - v33 := v32.Get() - v34 := lang.Apply(v3, []any{v30}) - v35 := lang.Apply(v33, []any{v22, v34}) - return v35 + tmp33 := tmp32.Get() + tmp34 := lang.Apply(v3, []any{v30}) + tmp35 := lang.Apply(tmp33, []any{v22, tmp34}) + return tmp35 }) - v30 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7182), lang.NewKeyword("column"), int(41), lang.NewKeyword("end-line"), int(7182), lang.NewKeyword("end-column"), int(53)) - v31, err := lang.WithMeta(v29, v30.(lang.IPersistentMap)) + tmp30 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7182), lang.NewKeyword("column"), int(41), lang.NewKeyword("end-line"), int(7182), lang.NewKeyword("end-column"), int(53)) + tmp31, err := lang.WithMeta(tmp29, tmp30.(lang.IPersistentMap)) if err != nil { panic(err) } - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("next")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("next")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{v14}) - v36 := lang.Apply(v28, []any{v31, v35}) - v37 := lang.Apply(v25, []any{v20, v36}) - var v38 any = v37 + tmp34 := tmp33.Get() + tmp35 := lang.Apply(tmp34, []any{v14}) + tmp36 := lang.Apply(tmp28, []any{tmp31, tmp35}) + tmp37 := lang.Apply(tmp25, []any{v20, tmp36}) + var v38 any = tmp37 _ = v38 - v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v40 := v39.FindInternedVar(lang.NewSymbol("cons")) - if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) + tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp40 := tmp39.FindInternedVar(lang.NewSymbol("cons")) + if tmp40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) } - v41 := v40.Get() - v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v43 := v42.FindInternedVar(lang.NewSymbol("partition-by")) - if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) + tmp41 := tmp40.Get() + tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp43 := tmp42.FindInternedVar(lang.NewSymbol("partition-by")) + if tmp43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) } - v44 := v43.Get() - var v45 lang.FnFunc - v45 = lang.NewFnFunc(func(args ...any) any { + tmp44 := tmp43.Get() + var tmp45 lang.FnFunc + tmp45 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v47 := v46.FindInternedVar(lang.NewSymbol("drop")) - if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) + tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp47 := tmp46.FindInternedVar(lang.NewSymbol("drop")) + if tmp47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) } - v48 := v47.Get() - v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v50 := v49.FindInternedVar(lang.NewSymbol("count")) - if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) + tmp48 := tmp47.Get() + tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp50 := tmp49.FindInternedVar(lang.NewSymbol("count")) + if tmp50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) } - v51 := v50.Get() - v52 := lang.Apply(v51, []any{v38}) - v53 := lang.Apply(v48, []any{v52, v14}) - return v53 + tmp51 := tmp50.Get() + tmp52 := lang.Apply(tmp51, []any{v38}) + tmp53 := lang.Apply(tmp48, []any{tmp52, v14}) + return tmp53 }) - v46 := lang.Apply(lang.NewLazySeq, []any{v45}) - v47 := lang.Apply(v44, []any{v3, v46}) - v48 := lang.Apply(v41, []any{v38, v47}) - v15 = v48 + tmp46 := lang.Apply(lang.NewLazySeq, []any{tmp45}) + tmp47 := lang.Apply(tmp44, []any{v3, tmp46}) + tmp48 := lang.Apply(tmp41, []any{v38, tmp47}) + tmp15 = tmp48 } // end let - v13 = v15 + tmp13 = tmp15 } // end let - v12 = v13 + tmp12 = tmp13 } else { - v12 = nil } - v6 = v12 + tmp6 = tmp12 } // end let - return v6 + return tmp6 }) - v6 := lang.Apply(lang.NewLazySeq, []any{v5}) - return v6 + tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) + return tmp6 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // partitionv { - v0 := lang.NewSymbol("partitionv").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("pad"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of vectors of n items each, at offsets step\n apart. If step is not supplied, defaults to n, i.e. the partitions\n do not overlap. If a pad collection is supplied, use its elements as\n necessary to complete last partition upto n items. In case there are\n not enough padding elements, return a partition with less than n items.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7262), lang.NewKeyword("end-line"), int(7262))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("partitionv").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("pad"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of vectors of n items each, at offsets step\n apart. If step is not supplied, defaults to n, i.e. the partitions\n do not overlap. If a pad collection is supplied, use its elements as\n necessary to complete last partition upto n items. In case there are\n not enough padding elements, return a partition with less than n items.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7262), lang.NewKeyword("end-line"), int(7262))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("partitionv")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v3, v3, v4}) - return v8 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("partitionv")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v3, v3, v4}) + return tmp8 case 3: v3 := args[0] _ = v3 @@ -61942,110 +62065,108 @@ func init() { _ = v4 v5 := args[2] _ = v5 - var v6 lang.FnFunc - v6 = lang.NewFnFunc(func(args ...any) any { + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - var v7 any + var tmp7 any { // let // let binding "temp__0__auto__" - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("seq")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v5}) - var v12 any = v11 + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("seq")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v5}) + var v12 any = tmp11 _ = v12 - var v13 any + var tmp13 any if lang.IsTruthy(v12) { - var v14 any + var tmp14 any { // let // let binding "s" var v15 any = v12 _ = v15 - var v16 any + var tmp16 any { // let // let binding "p" - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("into")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("into")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) } - v19 := v18.Get() - v20 := lang.NewVector() - v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7274), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(7274), lang.NewKeyword("end-column"), int(23)) - v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) + tmp19 := tmp18.Get() + tmp20 := lang.NewVector() + tmp21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7274), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(7274), lang.NewKeyword("end-column"), int(23)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) if err != nil { panic(err) } - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("take")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("take")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) } - v25 := v24.Get() - v26 := lang.Apply(v25, []any{v3}) - v27 := lang.Apply(v19, []any{v22, v26, v15}) - var v28 any = v27 + tmp25 := tmp24.Get() + tmp26 := lang.Apply(tmp25, []any{v3}) + tmp27 := lang.Apply(tmp19, []any{tmp22, tmp26, v15}) + var v28 any = tmp27 _ = v28 - var v29 any - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("=")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + var tmp29 any + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("=")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) } - v32 := v31.Get() - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("count")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + tmp32 := tmp31.Get() + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("count")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) } - v35 := v34.Get() - v36 := lang.Apply(v35, []any{v28}) - v37 := lang.Apply(v32, []any{v3, v36}) - if lang.IsTruthy(v37) { - v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v39 := v38.FindInternedVar(lang.NewSymbol("cons")) - if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + tmp35 := tmp34.Get() + tmp36 := lang.Apply(tmp35, []any{v28}) + tmp37 := lang.Apply(tmp32, []any{v3, tmp36}) + if lang.IsTruthy(tmp37) { + tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp39 := tmp38.FindInternedVar(lang.NewSymbol("cons")) + if tmp39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) } - v40 := v39.Get() - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("partitionv")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + tmp40 := tmp39.Get() + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("partitionv")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) } - v43 := v42.Get() - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("nthrest")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + tmp43 := tmp42.Get() + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("nthrest")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) } - v46 := v45.Get() - v47 := lang.Apply(v46, []any{v15, v4}) - v48 := lang.Apply(v43, []any{v3, v4, v47}) - v49 := lang.Apply(v40, []any{v28, v48}) - v29 = v49 + tmp46 := tmp45.Get() + tmp47 := lang.Apply(tmp46, []any{v15, v4}) + tmp48 := lang.Apply(tmp43, []any{v3, v4, tmp47}) + tmp49 := lang.Apply(tmp40, []any{v28, tmp48}) + tmp29 = tmp49 } else { - v29 = nil } - v16 = v29 + tmp16 = tmp29 } // end let - v14 = v16 + tmp14 = tmp16 } // end let - v13 = v14 + tmp13 = tmp14 } else { - v13 = nil } - v7 = v13 + tmp7 = tmp13 } // end let - return v7 + return tmp7 }) - v7 := lang.Apply(lang.NewLazySeq, []any{v6}) - return v7 + tmp7 := lang.Apply(lang.NewLazySeq, []any{tmp6}) + return tmp7 case 4: v3 := args[0] _ = v3 @@ -62055,184 +62176,183 @@ func init() { _ = v5 v6 := args[3] _ = v6 - var v7 lang.FnFunc - v7 = lang.NewFnFunc(func(args ...any) any { + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - var v8 any + var tmp8 any { // let // let binding "temp__0__auto__" - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("seq")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.Apply(v11, []any{v6}) - var v13 any = v12 + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("seq")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.Apply(tmp11, []any{v6}) + var v13 any = tmp12 _ = v13 - var v14 any + var tmp14 any if lang.IsTruthy(v13) { - var v15 any + var tmp15 any { // let // let binding "s" var v16 any = v13 _ = v16 - var v17 any + var tmp17 any { // let // let binding "p" - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("into")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("into")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) } - v20 := v19.Get() - v21 := lang.NewVector() - v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7280), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(7280), lang.NewKeyword("end-column"), int(23)) - v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) + tmp20 := tmp19.Get() + tmp21 := lang.NewVector() + tmp22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7280), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(7280), lang.NewKeyword("end-column"), int(23)) + tmp23, err := lang.WithMeta(tmp21, tmp22.(lang.IPersistentMap)) if err != nil { panic(err) } - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("take")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("take")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) } - v26 := v25.Get() - v27 := lang.Apply(v26, []any{v3}) - v28 := lang.Apply(v20, []any{v23, v27, v16}) - var v29 any = v28 + tmp26 := tmp25.Get() + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp20, []any{tmp23, tmp27, v16}) + var v29 any = tmp28 _ = v29 - var v30 any - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("=")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + var tmp30 any + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("=")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) } - v33 := v32.Get() - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("count")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + tmp33 := tmp32.Get() + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("count")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) } - v36 := v35.Get() - v37 := lang.Apply(v36, []any{v29}) - v38 := lang.Apply(v33, []any{v3, v37}) - if lang.IsTruthy(v38) { - v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v40 := v39.FindInternedVar(lang.NewSymbol("cons")) - if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) + tmp36 := tmp35.Get() + tmp37 := lang.Apply(tmp36, []any{v29}) + tmp38 := lang.Apply(tmp33, []any{v3, tmp37}) + if lang.IsTruthy(tmp38) { + tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp40 := tmp39.FindInternedVar(lang.NewSymbol("cons")) + if tmp40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) } - v41 := v40.Get() - v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v43 := v42.FindInternedVar(lang.NewSymbol("partitionv")) - if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) + tmp41 := tmp40.Get() + tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp43 := tmp42.FindInternedVar(lang.NewSymbol("partitionv")) + if tmp43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) } - v44 := v43.Get() - v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v46 := v45.FindInternedVar(lang.NewSymbol("nthrest")) - if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) + tmp44 := tmp43.Get() + tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp46 := tmp45.FindInternedVar(lang.NewSymbol("nthrest")) + if tmp46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) } - v47 := v46.Get() - v48 := lang.Apply(v47, []any{v16, v4}) - v49 := lang.Apply(v44, []any{v3, v4, v5, v48}) - v50 := lang.Apply(v41, []any{v29, v49}) - v30 = v50 + tmp47 := tmp46.Get() + tmp48 := lang.Apply(tmp47, []any{v16, v4}) + tmp49 := lang.Apply(tmp44, []any{v3, v4, v5, tmp48}) + tmp50 := lang.Apply(tmp41, []any{v29, tmp49}) + tmp30 = tmp50 } else { - v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v52 := v51.FindInternedVar(lang.NewSymbol("list")) - if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) + tmp51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp52 := tmp51.FindInternedVar(lang.NewSymbol("list")) + if tmp52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp52))) } - v53 := v52.Get() - v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v55 := v54.FindInternedVar(lang.NewSymbol("into")) - if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) + tmp53 := tmp52.Get() + tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp55 := tmp54.FindInternedVar(lang.NewSymbol("into")) + if tmp55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) } - v56 := v55.Get() - v57 := lang.NewVector() - v58 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7283), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(7283), lang.NewKeyword("end-column"), int(25)) - v59, err := lang.WithMeta(v57, v58.(lang.IPersistentMap)) + tmp56 := tmp55.Get() + tmp57 := lang.NewVector() + tmp58 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7283), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(7283), lang.NewKeyword("end-column"), int(25)) + tmp59, err := lang.WithMeta(tmp57, tmp58.(lang.IPersistentMap)) if err != nil { panic(err) } - v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v61 := v60.FindInternedVar(lang.NewSymbol("take")) - if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) + tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp61 := tmp60.FindInternedVar(lang.NewSymbol("take")) + if tmp61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) } - v62 := v61.Get() - v63 := lang.Apply(v62, []any{v3}) - v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v65 := v64.FindInternedVar(lang.NewSymbol("concat")) - if v65.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) + tmp62 := tmp61.Get() + tmp63 := lang.Apply(tmp62, []any{v3}) + tmp64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp65 := tmp64.FindInternedVar(lang.NewSymbol("concat")) + if tmp65.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp65))) } - v66 := v65.Get() - v67 := lang.Apply(v66, []any{v29, v5}) - v68 := lang.Apply(v56, []any{v59, v63, v67}) - v69 := lang.Apply(v53, []any{v68}) - v30 = v69 + tmp66 := tmp65.Get() + tmp67 := lang.Apply(tmp66, []any{v29, v5}) + tmp68 := lang.Apply(tmp56, []any{tmp59, tmp63, tmp67}) + tmp69 := lang.Apply(tmp53, []any{tmp68}) + tmp30 = tmp69 } - v17 = v30 + tmp17 = tmp30 } // end let - v15 = v17 + tmp15 = tmp17 } // end let - v14 = v15 + tmp14 = tmp15 } else { - v14 = nil } - v8 = v14 + tmp8 = tmp14 } // end let - return v8 + return tmp8 }) - v8 := lang.Apply(lang.NewLazySeq, []any{v7}) - return v8 + tmp8 := lang.Apply(lang.NewLazySeq, []any{tmp7}) + return tmp8 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // partitionv-all { - v0 := lang.NewSymbol("partitionv-all").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of vector partitions, but may include\n partitions with fewer than n items at the end.\n Returns a stateful transducer when no collection is provided.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7285), lang.NewKeyword("end-line"), int(7285))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("partitionv-all").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of vector partitions, but may include\n partitions with fewer than n items at the end.\n Returns a stateful transducer when no collection is provided.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7285), lang.NewKeyword("end-line"), int(7285))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("partition-all")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.Apply(v6, []any{v3}) - return v7 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("partition-all")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.Apply(tmp6, []any{v3}) + return tmp7 case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("partitionv-all")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v3, v3, v4}) - return v8 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("partitionv-all")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v3, v3, v4}) + return tmp8 case 3: v3 := args[0] _ = v3 @@ -62240,261 +62360,262 @@ func init() { _ = v4 v5 := args[2] _ = v5 - var v6 lang.FnFunc - v6 = lang.NewFnFunc(func(args ...any) any { + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - var v7 any + var tmp7 any { // let // let binding "temp__0__auto__" - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("seq")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v5}) - var v12 any = v11 + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("seq")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v5}) + var v12 any = tmp11 _ = v12 - var v13 any + var tmp13 any if lang.IsTruthy(v12) { - var v14 any + var tmp14 any { // let // let binding "s" var v15 any = v12 _ = v15 - var v16 any + var tmp16 any { // let // let binding "seg" - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("into")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("into")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) } - v19 := v18.Get() - v20 := lang.NewVector() - v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7297), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(7297), lang.NewKeyword("end-column"), int(25)) - v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) + tmp19 := tmp18.Get() + tmp20 := lang.NewVector() + tmp21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7297), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(7297), lang.NewKeyword("end-column"), int(25)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) if err != nil { panic(err) } - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("take")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("take")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) } - v25 := v24.Get() - v26 := lang.Apply(v25, []any{v3}) - v27 := lang.Apply(v19, []any{v22, v26, v5}) - var v28 any = v27 + tmp25 := tmp24.Get() + tmp26 := lang.Apply(tmp25, []any{v3}) + tmp27 := lang.Apply(tmp19, []any{tmp22, tmp26, v5}) + var v28 any = tmp27 _ = v28 - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("cons")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("cons")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) } - v31 := v30.Get() - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("partitionv-all")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + tmp31 := tmp30.Get() + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("partitionv-all")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) } - v34 := v33.Get() - v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v36 := v35.FindInternedVar(lang.NewSymbol("drop")) - if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + tmp34 := tmp33.Get() + tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp36 := tmp35.FindInternedVar(lang.NewSymbol("drop")) + if tmp36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) } - v37 := v36.Get() - v38 := lang.Apply(v37, []any{v4, v15}) - v39 := lang.Apply(v34, []any{v3, v4, v38}) - v40 := lang.Apply(v31, []any{v28, v39}) - v16 = v40 + tmp37 := tmp36.Get() + tmp38 := lang.Apply(tmp37, []any{v4, v15}) + tmp39 := lang.Apply(tmp34, []any{v3, v4, tmp38}) + tmp40 := lang.Apply(tmp31, []any{v28, tmp39}) + tmp16 = tmp40 } // end let - v14 = v16 + tmp14 = tmp16 } // end let - v13 = v14 + tmp13 = tmp14 } else { - v13 = nil } - v7 = v13 + tmp7 = tmp13 } // end let - return v7 + return tmp7 }) - v7 := lang.Apply(lang.NewLazySeq, []any{v6}) - return v7 + tmp7 := lang.Apply(lang.NewLazySeq, []any{tmp6}) + return tmp7 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // pcalls { - v0 := lang.NewSymbol("pcalls").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("fns"))), lang.NewKeyword("doc"), "Executes the no-arg fns in parallel, returning a lazy sequence of\n their values", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7056), lang.NewKeyword("end-line"), int(7056))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("pcalls").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("fns"))), lang.NewKeyword("doc"), "Executes the no-arg fns in parallel, returning a lazy sequence of\n their values", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7056), lang.NewKeyword("end-line"), int(7056))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v3 := lang.NewList(args[0:]...) - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("pmap")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - var v7 lang.FnFunc - v7 = lang.NewFnFunc(func(args ...any) any { + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("pmap")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v8 := args[0] _ = v8 - v9 := lang.Apply(v8, nil) - return v9 + tmp9 := lang.Apply(v8, nil) + return tmp9 }) - v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7061), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(7061), lang.NewKeyword("end-column"), int(20)) - v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) + tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7061), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(7061), lang.NewKeyword("end-column"), int(20)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) if err != nil { panic(err) } - v10 := lang.Apply(v6, []any{v9, v3}) - return v10 + tmp10 := lang.Apply(tmp6, []any{tmp9, v3}) + return tmp10 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // peek { - v0 := lang.NewSymbol("peek").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "For a list or queue, same as first, for a vector, same as, but much\n more efficient than, last. If the collection is empty, returns nil.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1455), lang.NewKeyword("end-line"), int(1455))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("peek").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "For a list or queue, same as first, for a vector, same as, but much\n more efficient than, last. If the collection is empty, returns nil.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1455), lang.NewKeyword("end-line"), int(1455))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4, _ := lang.FieldOrMethod(runtime4.RT, "Peek") - if reflect.TypeOf(v4).Kind() != reflect.Func { + tmp4, _ := lang.FieldOrMethod(runtime4.RT, "Peek") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Peek is not a function"))) } - v5 := lang.Apply(v4, []any{v3}) - return v5 + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // persistent! { - v0 := lang.NewSymbol("persistent!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a new, persistent version of the transient collection, in\n constant time. The transient collection cannot be used after this\n call, any such use will throw an exception.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3350), lang.NewKeyword("end-line"), int(3350))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("persistent!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a new, persistent version of the transient collection, in\n constant time. The transient collection cannot be used after this\n call, any such use will throw an exception.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3350), lang.NewKeyword("end-line"), int(3350))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4, ok := lang.FieldOrMethod(v3, "Persistent") + tmp4, ok := lang.FieldOrMethod(v3, "Persistent") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "Persistent"))) } - var v5 any - switch reflect.TypeOf(v4).Kind() { + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { case reflect.Func: - v5 = lang.Apply(v4, nil) + tmp5 = lang.Apply(tmp4, nil) default: - v5 = v4 + tmp5 = tmp4 } - return v5 + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // pmap { - v0 := lang.NewSymbol("pmap").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Like map, except f is applied in parallel. Semi-lazy in that the\n parallel computation stays ahead of the consumption, but doesn't\n realize the entire result unless required. Only useful for\n computationally intensive functions where the time of f dominates\n the coordination overhead.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7031), lang.NewKeyword("end-line"), int(7031))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("pmap").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Like map, except f is applied in parallel. Semi-lazy in that the\n parallel computation stays ahead of the consumption, but doesn't\n realize the entire result unless required. Only useful for\n computationally intensive functions where the time of f dominates\n the coordination overhead.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7031), lang.NewKeyword("end-line"), int(7031))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - var v5 any + var tmp5 any { // let // let binding "n" - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("+")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(runtime11.NumCPU, nil) - v10 := lang.Apply(v8, []any{int64(2), v9}) - var v11 any = v10 + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("+")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.Apply(runtime11.NumCPU, nil) + tmp10 := lang.Apply(tmp8, []any{int64(2), tmp9}) + var v11 any = tmp10 _ = v11 // let binding "rets" - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("map")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - var v15 lang.FnFunc - v15 = lang.NewFnFunc(func(args ...any) any { + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("map")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + var tmp15 lang.FnFunc + tmp15 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v16 := args[0] _ = v16 - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("future-call")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - var v20 lang.FnFunc - v20 = lang.NewFnFunc(func(args ...any) any { + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("future-call")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + var tmp20 lang.FnFunc + tmp20 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v21 := lang.Apply(v3, []any{v16}) - return v21 + tmp21 := lang.Apply(v3, []any{v16}) + return tmp21 }) - v21 := lang.Apply(v19, []any{v20}) - return v21 + tmp21 := lang.Apply(tmp19, []any{tmp20}) + return tmp21 }) - v16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7041), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7041), lang.NewKeyword("end-column"), int(34)) - v17, err := lang.WithMeta(v15, v16.(lang.IPersistentMap)) + tmp16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7041), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7041), lang.NewKeyword("end-column"), int(34)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) if err != nil { panic(err) } - v18 := lang.Apply(v14, []any{v17, v4}) - var v19 any = v18 + tmp18 := lang.Apply(tmp14, []any{tmp17, v4}) + var v19 any = tmp18 _ = v19 // let binding "step" - var v20 lang.FnFunc + var tmp20 lang.FnFunc { // function step - v20 = lang.NewFnFunc(func(args ...any) any { + var v21 lang.FnFunc + tmp20 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -62502,40 +62623,40 @@ func init() { _ = v22 v23 := args[1] _ = v23 - var v24 any + var tmp24 any { // let // let binding "vec__323" var v25 any = v22 _ = v25 // let binding "seq__324" - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("seq")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("seq")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) } - v28 := v27.Get() - v29 := lang.Apply(v28, []any{v25}) - var v30 any = v29 + tmp28 := tmp27.Get() + tmp29 := lang.Apply(tmp28, []any{v25}) + var v30 any = tmp29 _ = v30 // let binding "first__325" - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("first")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("first")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{v30}) - var v35 any = v34 + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{v30}) + var v35 any = tmp34 _ = v35 // let binding "seq__324" - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("next")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("next")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) } - v38 := v37.Get() - v39 := lang.Apply(v38, []any{v30}) - var v40 any = v39 + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{v30}) + var v40 any = tmp39 _ = v40 // let binding "x" var v41 any = v35 @@ -62546,101 +62667,101 @@ func init() { // let binding "vs" var v43 any = v25 _ = v43 - var v44 lang.FnFunc - v44 = lang.NewFnFunc(func(args ...any) any { + var tmp44 lang.FnFunc + tmp44 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - var v45 any + var tmp45 any { // let // let binding "temp__0__auto__" - v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v47 := v46.FindInternedVar(lang.NewSymbol("seq")) - if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) + tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp47 := tmp46.FindInternedVar(lang.NewSymbol("seq")) + if tmp47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) } - v48 := v47.Get() - v49 := lang.Apply(v48, []any{v23}) - var v50 any = v49 + tmp48 := tmp47.Get() + tmp49 := lang.Apply(tmp48, []any{v23}) + var v50 any = tmp49 _ = v50 - var v51 any + var tmp51 any if lang.IsTruthy(v50) { - var v52 any + var tmp52 any { // let // let binding "s" var v53 any = v50 _ = v53 - v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v55 := v54.FindInternedVar(lang.NewSymbol("cons")) - if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) + tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp55 := tmp54.FindInternedVar(lang.NewSymbol("cons")) + if tmp55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) } - v56 := v55.Get() - v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v58 := v57.FindInternedVar(lang.NewSymbol("deref")) - if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) + tmp56 := tmp55.Get() + tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp58 := tmp57.FindInternedVar(lang.NewSymbol("deref")) + if tmp58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) } - v59 := v58.Get() - v60 := lang.Apply(v59, []any{v41}) - v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v62 := v61.FindInternedVar(lang.NewSymbol("rest")) - if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) + tmp59 := tmp58.Get() + tmp60 := lang.Apply(tmp59, []any{v41}) + tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp62 := tmp61.FindInternedVar(lang.NewSymbol("rest")) + if tmp62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) } - v63 := v62.Get() - v64 := lang.Apply(v63, []any{v53}) - v65 := lang.Apply(v21, []any{v42, v64}) - v66 := lang.Apply(v56, []any{v60, v65}) - v52 = v66 + tmp63 := tmp62.Get() + tmp64 := lang.Apply(tmp63, []any{v53}) + tmp65 := lang.Apply(v21, []any{v42, tmp64}) + tmp66 := lang.Apply(tmp56, []any{tmp60, tmp65}) + tmp52 = tmp66 } // end let - v51 = v52 + tmp51 = tmp52 } else { - v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v54 := v53.FindInternedVar(lang.NewSymbol("map")) - if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) + tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp54 := tmp53.FindInternedVar(lang.NewSymbol("map")) + if tmp54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) } - v55 := v54.Get() - v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v57 := v56.FindInternedVar(lang.NewSymbol("deref")) - if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) + tmp55 := tmp54.Get() + tmp56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp57 := tmp56.FindInternedVar(lang.NewSymbol("deref")) + if tmp57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp57))) } - v58 := v57.Get() - v59 := lang.Apply(v55, []any{v58, v43}) - v51 = v59 + tmp58 := tmp57.Get() + tmp59 := lang.Apply(tmp55, []any{tmp58, v43}) + tmp51 = tmp59 } - v45 = v51 + tmp45 = tmp51 } // end let - return v45 + return tmp45 }) - v45 := lang.Apply(lang.NewLazySeq, []any{v44}) - v24 = v45 + tmp45 := lang.Apply(lang.NewLazySeq, []any{tmp44}) + tmp24 = tmp45 } // end let - return v24 + return tmp24 }) - v21 := v20 + v21 = tmp20 _ = v21 } - v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7042), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(7046), lang.NewKeyword("end-column"), int(36)) - v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) + tmp21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7042), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(7046), lang.NewKeyword("end-column"), int(36)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) if err != nil { panic(err) } - var v23 any = v22 + var v23 any = tmp22 _ = v23 - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("drop")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.Apply(v26, []any{v11, v19}) - v28 := lang.Apply(v23, []any{v19, v27}) - v5 = v28 + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("drop")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.Apply(tmp26, []any{v11, v19}) + tmp28 := lang.Apply(v23, []any{v19, tmp27}) + tmp5 = tmp28 } // end let - return v5 + return tmp5 default: if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -62649,485 +62770,488 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.NewList(args[2:]...) - var v6 any + var v5 any = lang.NewList(args[2:]...) + _ = v5 + var tmp6 any { // let // let binding "step" - var v7 lang.FnFunc + var tmp7 lang.FnFunc { // function step - v7 = lang.NewFnFunc(func(args ...any) any { + var v8 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v9 := args[0] _ = v9 - var v10 lang.FnFunc - v10 = lang.NewFnFunc(func(args ...any) any { + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - var v11 any + var tmp11 any { // let // let binding "ss" - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("map")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("map")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) } - v14 := v13.Get() - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("seq")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + tmp14 := tmp13.Get() + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("seq")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) } - v17 := v16.Get() - v18 := lang.Apply(v14, []any{v17, v9}) - var v19 any = v18 + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp14, []any{tmp17, v9}) + var v19 any = tmp18 _ = v19 - var v20 any - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("every?")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + var tmp20 any + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("every?")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("identity")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("identity")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) } - v26 := v25.Get() - v27 := lang.Apply(v23, []any{v26, v19}) - if lang.IsTruthy(v27) { - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("cons")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + tmp26 := tmp25.Get() + tmp27 := lang.Apply(tmp23, []any{tmp26, v19}) + if lang.IsTruthy(tmp27) { + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("cons")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) } - v30 := v29.Get() - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("map")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + tmp30 := tmp29.Get() + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("map")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) } - v33 := v32.Get() - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("first")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + tmp33 := tmp32.Get() + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("first")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) } - v36 := v35.Get() - v37 := lang.Apply(v33, []any{v36, v19}) - v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v39 := v38.FindInternedVar(lang.NewSymbol("map")) - if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + tmp36 := tmp35.Get() + tmp37 := lang.Apply(tmp33, []any{tmp36, v19}) + tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp39 := tmp38.FindInternedVar(lang.NewSymbol("map")) + if tmp39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) } - v40 := v39.Get() - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("rest")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + tmp40 := tmp39.Get() + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("rest")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) } - v43 := v42.Get() - v44 := lang.Apply(v40, []any{v43, v19}) - v45 := lang.Apply(v8, []any{v44}) - v46 := lang.Apply(v30, []any{v37, v45}) - v20 = v46 + tmp43 := tmp42.Get() + tmp44 := lang.Apply(tmp40, []any{tmp43, v19}) + tmp45 := lang.Apply(v8, []any{tmp44}) + tmp46 := lang.Apply(tmp30, []any{tmp37, tmp45}) + tmp20 = tmp46 } else { - v20 = nil } - v11 = v20 + tmp11 = tmp20 } // end let - return v11 + return tmp11 }) - v11 := lang.Apply(lang.NewLazySeq, []any{v10}) - return v11 + tmp11 := lang.Apply(lang.NewLazySeq, []any{tmp10}) + return tmp11 }) - v8 := v7 + v8 = tmp7 _ = v8 } - v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7049), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(7053), lang.NewKeyword("end-column"), int(67)) - v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) + tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7049), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(7053), lang.NewKeyword("end-column"), int(67)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) if err != nil { panic(err) } - var v10 any = v9 + var v10 any = tmp9 _ = v10 - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("pmap")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - var v14 lang.FnFunc - v14 = lang.NewFnFunc(func(args ...any) any { + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("pmap")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v15 := args[0] _ = v15 - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("apply")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{v3, v15}) - return v19 + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("apply")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{v3, v15}) + return tmp19 }) - v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7054), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(7054), lang.NewKeyword("end-column"), int(23)) - v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) + tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7054), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(7054), lang.NewKeyword("end-column"), int(23)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) if err != nil { panic(err) } - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("cons")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("cons")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) } - v19 := v18.Get() - v20 := lang.Apply(v19, []any{v4, v5}) - v21 := lang.Apply(v10, []any{v20}) - v22 := lang.Apply(v13, []any{v16, v21}) - v6 = v22 + tmp19 := tmp18.Get() + tmp20 := lang.Apply(tmp19, []any{v4, v5}) + tmp21 := lang.Apply(v10, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp16, tmp21}) + tmp6 = tmp22 } // end let - return v6 + return tmp6 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // pop { - v0 := lang.NewSymbol("pop").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "For a list or queue, returns a new list/queue without the first\n item, for a vector, returns a new vector without the last item. If\n the collection is empty, throws an exception. Note - not the same\n as next/butlast.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1462), lang.NewKeyword("end-line"), int(1462))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("pop").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "For a list or queue, returns a new list/queue without the first\n item, for a vector, returns a new vector without the last item. If\n the collection is empty, throws an exception. Note - not the same\n as next/butlast.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1462), lang.NewKeyword("end-line"), int(1462))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4, _ := lang.FieldOrMethod(runtime4.RT, "Pop") - if reflect.TypeOf(v4).Kind() != reflect.Func { + tmp4, _ := lang.FieldOrMethod(runtime4.RT, "Pop") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Pop is not a function"))) } - v5 := lang.Apply(v4, []any{v3}) - return v5 + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // pop! { - v0 := lang.NewSymbol("pop!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Removes the last item from a transient vector. If\n the collection is empty, throws an exception. Returns coll", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3393), lang.NewKeyword("end-line"), int(3393))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("pop!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Removes the last item from a transient vector. If\n the collection is empty, throws an exception. Returns coll", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3393), lang.NewKeyword("end-line"), int(3393))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4, ok := lang.FieldOrMethod(v3, "pop") + tmp4, ok := lang.FieldOrMethod(v3, "pop") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "pop"))) } - var v5 any - switch reflect.TypeOf(v4).Kind() { + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { case reflect.Func: - v5 = lang.Apply(v4, nil) + tmp5 = lang.Apply(tmp4, nil) default: - v5 = v4 + tmp5 = tmp4 } - return v5 + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // pop-thread-bindings { - v0 := lang.NewSymbol("pop-thread-bindings").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Pop one set of bindings pushed with push-binding before. It is an error to\n pop bindings without pushing before.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1929), lang.NewKeyword("end-line"), int(1929))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("pop-thread-bindings").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Pop one set of bindings pushed with push-binding before. It is an error to\n pop bindings without pushing before.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1929), lang.NewKeyword("end-line"), int(1929))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v3 := lang.Apply(lang.PopThreadBindings, nil) - return v3 + tmp3 := lang.Apply(lang.PopThreadBindings, nil) + return tmp3 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // pos-int? { - v0 := lang.NewSymbol("pos-int?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a positive fixed precision integer", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1403), lang.NewKeyword("end-line"), int(1403))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("pos-int?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a positive fixed precision integer", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1403), lang.NewKeyword("end-line"), int(1403))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any + var tmp4 any { // let // let binding "and__0__auto__" - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("int?")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v3}) - var v9 any = v8 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("int?")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v3}) + var v9 any = tmp8 _ = v9 - var v10 any + var tmp10 any if lang.IsTruthy(v9) { - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("pos?")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{v3}) - v10 = v14 + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("pos?")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{v3}) + tmp10 = tmp14 } else { - v10 = v9 + tmp10 = v9 } - v4 = v10 + tmp4 = tmp10 } // end let - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // pos? { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function pos?__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("concat")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("list")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("seq")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("concat")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/IsPos")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{v3}) - v35 := lang.Apply(v26, []any{v30, v34}) - v36 := lang.Apply(v23, []any{v35}) - v37 := lang.Apply(v20, []any{v36}) - v38 := lang.Apply(v9, []any{v13, v17, v37}) - v39 := lang.Apply(v6, []any{v38}) - return v39 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/IsPos")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{v3}) + tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) + tmp36 := lang.Apply(tmp23, []any{tmp35}) + tmp37 := lang.Apply(tmp20, []any{tmp36}) + tmp38 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp37}) + tmp39 := lang.Apply(tmp6, []any{tmp38}) + return tmp39 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("pos?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns true if num is greater than zero, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1252), lang.NewKeyword("end-line"), int(1252))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("pos?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns true if num is greater than zero, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1252), lang.NewKeyword("end-line"), int(1252))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5, _ := lang.FieldOrMethod(lang.Numbers, "IsPos") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "IsPos") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("IsPos is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // pr { - v0 := lang.NewSymbol("pr").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Prints the object(s) to the output stream that is the current value\n of *out*. Prints the object(s), separated by spaces if there is\n more than one. By default, pr and prn print in a way that objects\n can be read by the reader", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3678), lang.NewKeyword("end-line"), int(3678), lang.NewKeyword("dynamic"), true)).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("pr").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Prints the object(s) to the output stream that is the current value\n of *out*. Prints the object(s), separated by spaces if there is\n more than one. By default, pr and prn print in a way that objects\n can be read by the reader", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3678), lang.NewKeyword("end-line"), int(3678), lang.NewKeyword("dynamic"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: return nil case 1: v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("pr-on")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("*out*")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v6, []any{v3, v9}) - return v10 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("pr-on")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("*out*")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp6, []any{v3, tmp9}) + return tmp10 default: if len(args) < 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.NewList(args[1:]...) + var v4 any = lang.NewList(args[1:]...) + _ = v4 recur_loop_671: - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("pr")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v3}) - _ = v8 - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("*out*")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.Apply(lang.AppendWriter, []any{v11, lang.NewChar(32)}) - _ = v12 - var v13 any + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("pr")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v3}) + _ = tmp8 + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("*out*")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.Apply(lang.AppendWriter, []any{tmp11, lang.NewChar(32)}) + _ = tmp12 + var tmp13 any { // let // let binding "temp__0__auto__" - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("next")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{v4}) - var v18 any = v17 + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("next")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{v4}) + var v18 any = tmp17 _ = v18 - var v19 any + var tmp19 any if lang.IsTruthy(v18) { - var v20 any + var tmp20 any { // let // let binding "nmore" var v21 any = v18 _ = v21 - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("first")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.Apply(v25, []any{v4}) - var v22 any = v26 - var v27 any = v21 - v3 = v22 - v4 = v27 + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("first")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.Apply(tmp25, []any{v4}) + var tmp22 any = tmp26 + var tmp27 any = v21 + v3 = tmp22 + v4 = tmp27 goto recur_loop_671 } // end let - v19 = v20 + tmp19 = tmp20 } else { - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("apply")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("pr")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.Apply(v23, []any{v26, v4}) - v19 = v27 - } - v13 = v19 + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("apply")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("pr")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.Apply(tmp23, []any{tmp26, v4}) + tmp19 = tmp27 + } + tmp13 = tmp19 } // end let - return v13 + return tmp13 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // pr-on { - v0 := lang.NewSymbol("pr-on").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("w"))), lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3669), lang.NewKeyword("end-line"), int(3669), lang.NewKeyword("private"), true)).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("pr-on").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("w"))), lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3669), lang.NewKeyword("end-line"), int(3669), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -63135,129 +63259,131 @@ func init() { _ = v3 v4 := args[1] _ = v4 - var v5 any - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("*print-dup*")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - if lang.IsTruthy(v8) { - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("print-dup")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.Apply(v11, []any{v3, v4}) - v5 = v12 + var tmp5 any + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("*print-dup*")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + if lang.IsTruthy(tmp8) { + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("print-dup")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.Apply(tmp11, []any{v3, v4}) + tmp5 = tmp12 } else { - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("print-method")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("print-method")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{v3, v4}) - v5 = v16 + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{v3, v4}) + tmp5 = tmp16 } - _ = v5 + _ = tmp5 return nil }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // pr-str { - v1 := reflect.TypeOf("") - v0 := lang.NewSymbol("pr-str").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("xs"))), lang.NewKeyword("doc"), "pr to a string, returning it", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4758), lang.NewKeyword("end-line"), int(4758))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp1 := reflect.TypeOf("") + tmp0 := lang.NewSymbol("pr-str").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("xs"))), lang.NewKeyword("doc"), "pr to a string, returning it", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4758), lang.NewKeyword("end-line"), int(4758))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v4 := lang.NewList(args[0:]...) - var v5 any + var v4 any = lang.NewList(args[0:]...) + _ = v4 + var tmp5 any { // let // let binding "s__0__auto__" var v6 any = "unimplemented: new with non-constant class type" _ = v6 - var v7 any + var tmp7 any { // let - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("push-thread-bindings")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("hash-map")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*out*")) - v15 := lang.Apply(v13, []any{v14, v6}) - v16 := lang.Apply(v10, []any{v15}) - _ = v16 - var v17 any + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("push-thread-bindings")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("hash-map")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*out*")) + tmp15 := lang.Apply(tmp13, []any{tmp14, v6}) + tmp16 := lang.Apply(tmp10, []any{tmp15}) + _ = tmp16 + var tmp17 any func() { defer func() { - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) } - v20 := v19.Get() - v21 := lang.Apply(v20, nil) + tmp20 := tmp19.Get() + tmp21 := lang.Apply(tmp20, nil) + _ = tmp21 }() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("apply")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("pr")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.Apply(v24, []any{v27, v4}) - _ = v28 - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("str")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.Apply(v31, []any{v6}) - v17 = v32 + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("apply")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("pr")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.Apply(tmp24, []any{tmp27, v4}) + _ = tmp28 + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("str")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.Apply(tmp31, []any{v6}) + tmp17 = tmp32 }() - v7 = v17 + tmp7 = tmp17 } // end let - v5 = v7 + tmp5 = tmp7 } // end let - return v5 + return tmp5 } }) - v4 := reflect.TypeOf("") - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp4 := reflect.TypeOf("") + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // prefer-method { - v0 := lang.NewSymbol("prefer-method").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"), lang.NewSymbol("dispatch-val-x"), lang.NewSymbol("dispatch-val-y"))), lang.NewKeyword("doc"), "Causes the multimethod to prefer matches of dispatch-val-x over dispatch-val-y \n when there is a conflict", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1801), lang.NewKeyword("end-line"), int(1801))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("prefer-method").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"), lang.NewSymbol("dispatch-val-x"), lang.NewSymbol("dispatch-val-y"))), lang.NewKeyword("doc"), "Causes the multimethod to prefer matches of dispatch-val-x over dispatch-val-y \n when there is a conflict", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1801), lang.NewKeyword("end-line"), int(1801))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -63267,53 +63393,53 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6, _ := lang.FieldOrMethod(v3, "PreferMethod") - if reflect.TypeOf(v6).Kind() != reflect.Func { + tmp6, _ := lang.FieldOrMethod(v3, "PreferMethod") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("PreferMethod is not a function"))) } - v7 := lang.Apply(v6, []any{v4, v5}) - return v7 + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // prefers { - v0 := lang.NewSymbol("prefers").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"))), lang.NewKeyword("doc"), "Given a multimethod, returns a map of preferred value -> set of other values", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1822), lang.NewKeyword("end-line"), int(1822))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("prefers").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"))), lang.NewKeyword("doc"), "Given a multimethod, returns a map of preferred value -> set of other values", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1822), lang.NewKeyword("end-line"), int(1822))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4, ok := lang.FieldOrMethod(v3, "getPreferTable") + tmp4, ok := lang.FieldOrMethod(v3, "getPreferTable") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getPreferTable"))) } - var v5 any - switch reflect.TypeOf(v4).Kind() { + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { case reflect.Func: - v5 = lang.Apply(v4, nil) + tmp5 = lang.Apply(tmp4, nil) default: - v5 = v4 + tmp5 = tmp4 } - return v5 + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // prep-hashes { - v0 := lang.NewSymbol("prep-hashes").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr-sym"), lang.NewSymbol("default"), lang.NewSymbol("tests"), lang.NewSymbol("thens"))), lang.NewKeyword("doc"), "Takes a sequence of test constants and a corresponding sequence of then\n expressions. Returns a tuple of [shift mask case-map switch-type skip-check]\n where case-map is a map of int case values to [test then] tuples, switch-type\n is either :sparse or :compact, and skip-check is a set of case ints for which\n post-switch equivalence checking must not be done (occurs with hash\n collisions).", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6683), lang.NewKeyword("end-line"), int(6683), lang.NewKeyword("private"), true)).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("prep-hashes").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr-sym"), lang.NewSymbol("default"), lang.NewSymbol("tests"), lang.NewSymbol("thens"))), lang.NewKeyword("doc"), "Takes a sequence of test constants and a corresponding sequence of then\n expressions. Returns a tuple of [shift mask case-map switch-type skip-check]\n where case-map is a map of int case values to [test then] tuples, switch-type\n is either :sparse or :compact, and skip-check is a set of case ints for which\n post-switch equivalence checking must not be done (occurs with hash\n collisions).", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6683), lang.NewKeyword("end-line"), int(6683), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 4 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -63325,406 +63451,406 @@ func init() { _ = v5 v6 := args[3] _ = v6 - var v7 any + var tmp7 any { // let // let binding "hashcode" - var v8 lang.FnFunc - v8 = lang.NewFnFunc(func(args ...any) any { + var tmp8 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v9 := args[0] _ = v9 - v10 := lang.Apply(lang.Hash, []any{v9}) - return v10 + tmp10 := lang.Apply(lang.Hash, []any{v9}) + return tmp10 }) - v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6691), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(6691), lang.NewKeyword("end-column"), int(66)) - v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) + tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6691), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(6691), lang.NewKeyword("end-column"), int(66)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) if err != nil { panic(err) } - var v11 any = v10 + var v11 any = tmp10 _ = v11 // let binding "hashes" - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("into1")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.CreatePersistentTreeSet() - v16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6692), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(6692), lang.NewKeyword("end-column"), int(25)) - v17, err := lang.WithMeta(v15, v16.(lang.IPersistentMap)) + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("into1")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6692), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(6692), lang.NewKeyword("end-column"), int(25)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) if err != nil { panic(err) } - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("map")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("map")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) } - v20 := v19.Get() - v21 := lang.Apply(v20, []any{v11, v5}) - v22 := lang.Apply(v14, []any{v17, v21}) - var v23 any = v22 + tmp20 := tmp19.Get() + tmp21 := lang.Apply(tmp20, []any{v11, v5}) + tmp22 := lang.Apply(tmp14, []any{tmp17, tmp21}) + var v23 any = tmp22 _ = v23 - var v24 any - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("==")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("count")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.Apply(v30, []any{v5}) - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("count")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{v23}) - v36 := lang.Apply(v27, []any{v31, v35}) - if lang.IsTruthy(v36) { - var v37 any - v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v39 := v38.FindInternedVar(lang.NewSymbol("fits-table?")) - if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) - } - v40 := v39.Get() - v41 := lang.Apply(v40, []any{v23}) - if lang.IsTruthy(v41) { - v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v43 := v42.FindInternedVar(lang.NewSymbol("case-map")) - if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) - } - v44 := v43.Get() - v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v46 := v45.FindInternedVar(lang.NewSymbol("identity")) - if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) - } - v47 := v46.Get() - v48 := lang.Apply(v44, []any{v11, v47, v5, v6}) - v49 := lang.NewVector(int64(0), int64(0), v48, lang.NewKeyword("compact")) - v50 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6696), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(6696), lang.NewKeyword("end-column"), int(63)) - v51, err := lang.WithMeta(v49, v50.(lang.IPersistentMap)) + var tmp24 any + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("==")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("count")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.Apply(tmp30, []any{v5}) + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("count")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.Apply(tmp34, []any{v23}) + tmp36 := lang.Apply(tmp27, []any{tmp31, tmp35}) + if lang.IsTruthy(tmp36) { + var tmp37 any + tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp39 := tmp38.FindInternedVar(lang.NewSymbol("fits-table?")) + if tmp39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) + } + tmp40 := tmp39.Get() + tmp41 := lang.Apply(tmp40, []any{v23}) + if lang.IsTruthy(tmp41) { + tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp43 := tmp42.FindInternedVar(lang.NewSymbol("case-map")) + if tmp43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) + } + tmp44 := tmp43.Get() + tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp46 := tmp45.FindInternedVar(lang.NewSymbol("identity")) + if tmp46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) + } + tmp47 := tmp46.Get() + tmp48 := lang.Apply(tmp44, []any{v11, tmp47, v5, v6}) + tmp49 := lang.NewVector(int64(0), int64(0), tmp48, lang.NewKeyword("compact")) + tmp50 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6696), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(6696), lang.NewKeyword("end-column"), int(63)) + tmp51, err := lang.WithMeta(tmp49, tmp50.(lang.IPersistentMap)) if err != nil { panic(err) } - v37 = v51 + tmp37 = tmp51 } else { - var v52 any + var tmp52 any { // let // let binding "vec__167" - var v53 any + var tmp53 any { // let // let binding "or__0__auto__" - v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v55 := v54.FindInternedVar(lang.NewSymbol("maybe-min-hash")) - if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) + tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp55 := tmp54.FindInternedVar(lang.NewSymbol("maybe-min-hash")) + if tmp55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) } - v56 := v55.Get() - v57 := lang.Apply(v56, []any{v23}) - var v58 any = v57 + tmp56 := tmp55.Get() + tmp57 := lang.Apply(tmp56, []any{v23}) + var v58 any = tmp57 _ = v58 - var v59 any + var tmp59 any if lang.IsTruthy(v58) { - v59 = v58 + tmp59 = v58 } else { - v60 := lang.NewVector(int64(0), int64(0)) - v61 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6697), lang.NewKeyword("column"), int(56), lang.NewKeyword("end-line"), int(6697), lang.NewKeyword("end-column"), int(60)) - v62, err := lang.WithMeta(v60, v61.(lang.IPersistentMap)) + tmp60 := lang.NewVector(int64(0), int64(0)) + tmp61 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6697), lang.NewKeyword("column"), int(56), lang.NewKeyword("end-line"), int(6697), lang.NewKeyword("end-column"), int(60)) + tmp62, err := lang.WithMeta(tmp60, tmp61.(lang.IPersistentMap)) if err != nil { panic(err) } - v59 = v62 + tmp59 = tmp62 } - v53 = v59 + tmp53 = tmp59 } // end let - var v54 any = v53 + var v54 any = tmp53 _ = v54 // let binding "shift" - v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v56 := v55.FindInternedVar(lang.NewSymbol("nth")) - if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) - } - v57 := v56.Get() - v58 := lang.Apply(v57, []any{v54, int64(0), nil}) - var v59 any = v58 + tmp55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp56 := tmp55.FindInternedVar(lang.NewSymbol("nth")) + if tmp56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp56))) + } + tmp57 := tmp56.Get() + tmp58 := lang.Apply(tmp57, []any{v54, int64(0), nil}) + var v59 any = tmp58 _ = v59 // let binding "mask" - v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v61 := v60.FindInternedVar(lang.NewSymbol("nth")) - if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) - } - v62 := v61.Get() - v63 := lang.Apply(v62, []any{v54, int64(1), nil}) - var v64 any = v63 + tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp61 := tmp60.FindInternedVar(lang.NewSymbol("nth")) + if tmp61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) + } + tmp62 := tmp61.Get() + tmp63 := lang.Apply(tmp62, []any{v54, int64(1), nil}) + var v64 any = tmp63 _ = v64 - var v65 any - v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v67 := v66.FindInternedVar(lang.NewSymbol("zero?")) - if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) - } - v68 := v67.Get() - v69 := lang.Apply(v68, []any{v64}) - if lang.IsTruthy(v69) { - v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v71 := v70.FindInternedVar(lang.NewSymbol("case-map")) - if v71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) + var tmp65 any + tmp66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp67 := tmp66.FindInternedVar(lang.NewSymbol("zero?")) + if tmp67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp67))) + } + tmp68 := tmp67.Get() + tmp69 := lang.Apply(tmp68, []any{v64}) + if lang.IsTruthy(tmp69) { + tmp70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp71 := tmp70.FindInternedVar(lang.NewSymbol("case-map")) + if tmp71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp71))) } - v72 := v71.Get() - v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v74 := v73.FindInternedVar(lang.NewSymbol("identity")) - if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) + tmp72 := tmp71.Get() + tmp73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp74 := tmp73.FindInternedVar(lang.NewSymbol("identity")) + if tmp74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp74))) } - v75 := v74.Get() - v76 := lang.Apply(v72, []any{v11, v75, v5, v6}) - v77 := lang.NewVector(int64(0), int64(0), v76, lang.NewKeyword("sparse")) - v78 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6700), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(6700), lang.NewKeyword("end-column"), int(66)) - v79, err := lang.WithMeta(v77, v78.(lang.IPersistentMap)) + tmp75 := tmp74.Get() + tmp76 := lang.Apply(tmp72, []any{v11, tmp75, v5, v6}) + tmp77 := lang.NewVector(int64(0), int64(0), tmp76, lang.NewKeyword("sparse")) + tmp78 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6700), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(6700), lang.NewKeyword("end-column"), int(66)) + tmp79, err := lang.WithMeta(tmp77, tmp78.(lang.IPersistentMap)) if err != nil { panic(err) } - v65 = v79 + tmp65 = tmp79 } else { - v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v81 := v80.FindInternedVar(lang.NewSymbol("case-map")) - if v81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) + tmp80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp81 := tmp80.FindInternedVar(lang.NewSymbol("case-map")) + if tmp81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp81))) } - v82 := v81.Get() - var v83 lang.FnFunc - v83 = lang.NewFnFunc(func(args ...any) any { + tmp82 := tmp81.Get() + var tmp83 lang.FnFunc + tmp83 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v84 := args[0] _ = v84 - v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v86 := v85.FindInternedVar(lang.NewSymbol("shift-mask")) - if v86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) + tmp85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp86 := tmp85.FindInternedVar(lang.NewSymbol("shift-mask")) + if tmp86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp86))) } - v87 := v86.Get() - v88 := lang.Apply(v11, []any{v84}) - v89 := lang.Apply(v87, []any{v59, v64, v88}) - return v89 + tmp87 := tmp86.Get() + tmp88 := lang.Apply(v11, []any{v84}) + tmp89 := lang.Apply(tmp87, []any{v59, v64, tmp88}) + return tmp89 }) - v84 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6702), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(6702), lang.NewKeyword("end-column"), int(71)) - v85, err := lang.WithMeta(v83, v84.(lang.IPersistentMap)) + tmp84 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6702), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(6702), lang.NewKeyword("end-column"), int(71)) + tmp85, err := lang.WithMeta(tmp83, tmp84.(lang.IPersistentMap)) if err != nil { panic(err) } - v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v87 := v86.FindInternedVar(lang.NewSymbol("identity")) - if v87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) + tmp86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp87 := tmp86.FindInternedVar(lang.NewSymbol("identity")) + if tmp87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp87))) } - v88 := v87.Get() - v89 := lang.Apply(v82, []any{v85, v88, v5, v6}) - v90 := lang.NewVector(v59, v64, v89, lang.NewKeyword("compact")) - v91 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6702), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(6702), lang.NewKeyword("end-column"), int(103)) - v92, err := lang.WithMeta(v90, v91.(lang.IPersistentMap)) + tmp88 := tmp87.Get() + tmp89 := lang.Apply(tmp82, []any{tmp85, tmp88, v5, v6}) + tmp90 := lang.NewVector(v59, v64, tmp89, lang.NewKeyword("compact")) + tmp91 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6702), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(6702), lang.NewKeyword("end-column"), int(103)) + tmp92, err := lang.WithMeta(tmp90, tmp91.(lang.IPersistentMap)) if err != nil { panic(err) } - v65 = v92 + tmp65 = tmp92 } - v52 = v65 + tmp52 = tmp65 } // end let - v37 = v52 + tmp37 = tmp52 } - v24 = v37 + tmp24 = tmp37 } else { - var v53 any + var tmp53 any { // let // let binding "vec__170" - v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v55 := v54.FindInternedVar(lang.NewSymbol("merge-hash-collisions")) - if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) - } - v56 := v55.Get() - v57 := lang.Apply(v56, []any{v3, v4, v5, v6}) - var v58 any = v57 + tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp55 := tmp54.FindInternedVar(lang.NewSymbol("merge-hash-collisions")) + if tmp55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) + } + tmp56 := tmp55.Get() + tmp57 := lang.Apply(tmp56, []any{v3, v4, v5, v6}) + var v58 any = tmp57 _ = v58 // let binding "tests" - v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v60 := v59.FindInternedVar(lang.NewSymbol("nth")) - if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) - } - v61 := v60.Get() - v62 := lang.Apply(v61, []any{v58, int64(0), nil}) - var v63 any = v62 + tmp59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp60 := tmp59.FindInternedVar(lang.NewSymbol("nth")) + if tmp60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp60))) + } + tmp61 := tmp60.Get() + tmp62 := lang.Apply(tmp61, []any{v58, int64(0), nil}) + var v63 any = tmp62 _ = v63 // let binding "thens" - v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v65 := v64.FindInternedVar(lang.NewSymbol("nth")) - if v65.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) - } - v66 := v65.Get() - v67 := lang.Apply(v66, []any{v58, int64(1), nil}) - var v68 any = v67 + tmp64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp65 := tmp64.FindInternedVar(lang.NewSymbol("nth")) + if tmp65.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp65))) + } + tmp66 := tmp65.Get() + tmp67 := lang.Apply(tmp66, []any{v58, int64(1), nil}) + var v68 any = tmp67 _ = v68 // let binding "skip-check" - v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v70 := v69.FindInternedVar(lang.NewSymbol("nth")) - if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) - } - v71 := v70.Get() - v72 := lang.Apply(v71, []any{v58, int64(2), nil}) - var v73 any = v72 + tmp69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp70 := tmp69.FindInternedVar(lang.NewSymbol("nth")) + if tmp70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp70))) + } + tmp71 := tmp70.Get() + tmp72 := lang.Apply(tmp71, []any{v58, int64(2), nil}) + var v73 any = tmp72 _ = v73 // let binding "vec__173" - v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v75 := v74.FindInternedVar(lang.NewSymbol("prep-hashes")) - if v75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) - } - v76 := v75.Get() - v77 := lang.Apply(v76, []any{v3, v4, v63, v68}) - var v78 any = v77 + tmp74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp75 := tmp74.FindInternedVar(lang.NewSymbol("prep-hashes")) + if tmp75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp75))) + } + tmp76 := tmp75.Get() + tmp77 := lang.Apply(tmp76, []any{v3, v4, v63, v68}) + var v78 any = tmp77 _ = v78 // let binding "shift" - v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v80 := v79.FindInternedVar(lang.NewSymbol("nth")) - if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) - } - v81 := v80.Get() - v82 := lang.Apply(v81, []any{v78, int64(0), nil}) - var v83 any = v82 + tmp79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp80 := tmp79.FindInternedVar(lang.NewSymbol("nth")) + if tmp80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp80))) + } + tmp81 := tmp80.Get() + tmp82 := lang.Apply(tmp81, []any{v78, int64(0), nil}) + var v83 any = tmp82 _ = v83 // let binding "mask" - v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v85 := v84.FindInternedVar(lang.NewSymbol("nth")) - if v85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) - } - v86 := v85.Get() - v87 := lang.Apply(v86, []any{v78, int64(1), nil}) - var v88 any = v87 + tmp84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp85 := tmp84.FindInternedVar(lang.NewSymbol("nth")) + if tmp85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp85))) + } + tmp86 := tmp85.Get() + tmp87 := lang.Apply(tmp86, []any{v78, int64(1), nil}) + var v88 any = tmp87 _ = v88 // let binding "case-map" - v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v90 := v89.FindInternedVar(lang.NewSymbol("nth")) - if v90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) - } - v91 := v90.Get() - v92 := lang.Apply(v91, []any{v78, int64(2), nil}) - var v93 any = v92 + tmp89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp90 := tmp89.FindInternedVar(lang.NewSymbol("nth")) + if tmp90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp90))) + } + tmp91 := tmp90.Get() + tmp92 := lang.Apply(tmp91, []any{v78, int64(2), nil}) + var v93 any = tmp92 _ = v93 // let binding "switch-type" - v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v95 := v94.FindInternedVar(lang.NewSymbol("nth")) - if v95.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) - } - v96 := v95.Get() - v97 := lang.Apply(v96, []any{v78, int64(3), nil}) - var v98 any = v97 + tmp94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp95 := tmp94.FindInternedVar(lang.NewSymbol("nth")) + if tmp95.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp95))) + } + tmp96 := tmp95.Get() + tmp97 := lang.Apply(tmp96, []any{v78, int64(3), nil}) + var v98 any = tmp97 _ = v98 // let binding "skip-check" - var v99 any - v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v101 := v100.FindInternedVar(lang.NewSymbol("zero?")) - if v101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) - } - v102 := v101.Get() - v103 := lang.Apply(v102, []any{v88}) - if lang.IsTruthy(v103) { - v99 = v73 + var tmp99 any + tmp100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp101 := tmp100.FindInternedVar(lang.NewSymbol("zero?")) + if tmp101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp101))) + } + tmp102 := tmp101.Get() + tmp103 := lang.Apply(tmp102, []any{v88}) + if lang.IsTruthy(tmp103) { + tmp99 = v73 } else { - v104 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v105 := v104.FindInternedVar(lang.NewSymbol("into1")) - if v105.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v105))) - } - v106 := v105.Get() - v107 := lang.CreatePersistentTreeSet() - v108 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6708), lang.NewKeyword("column"), int(33), lang.NewKeyword("end-line"), int(6708), lang.NewKeyword("end-column"), int(35)) - v109, err := lang.WithMeta(v107, v108.(lang.IPersistentMap)) + tmp104 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp105 := tmp104.FindInternedVar(lang.NewSymbol("into1")) + if tmp105.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp105))) + } + tmp106 := tmp105.Get() + tmp107 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp108 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6708), lang.NewKeyword("column"), int(33), lang.NewKeyword("end-line"), int(6708), lang.NewKeyword("end-column"), int(35)) + tmp109, err := lang.WithMeta(tmp107, tmp108.(lang.IPersistentMap)) if err != nil { panic(err) } - v110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v111 := v110.FindInternedVar(lang.NewSymbol("map")) - if v111.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v111))) + tmp110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp111 := tmp110.FindInternedVar(lang.NewSymbol("map")) + if tmp111.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp111))) } - v112 := v111.Get() - var v113 lang.FnFunc - v113 = lang.NewFnFunc(func(args ...any) any { + tmp112 := tmp111.Get() + var tmp113 lang.FnFunc + tmp113 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v114 := args[0] _ = v114 - v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v116 := v115.FindInternedVar(lang.NewSymbol("shift-mask")) - if v116.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) + tmp115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp116 := tmp115.FindInternedVar(lang.NewSymbol("shift-mask")) + if tmp116.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp116))) } - v117 := v116.Get() - v118 := lang.Apply(v117, []any{v83, v88, v114}) - return v118 + tmp117 := tmp116.Get() + tmp118 := lang.Apply(tmp117, []any{v83, v88, v114}) + return tmp118 }) - v114 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6708), lang.NewKeyword("column"), int(42), lang.NewKeyword("end-line"), int(6708), lang.NewKeyword("end-column"), int(67)) - v115, err := lang.WithMeta(v113, v114.(lang.IPersistentMap)) + tmp114 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6708), lang.NewKeyword("column"), int(42), lang.NewKeyword("end-line"), int(6708), lang.NewKeyword("end-column"), int(67)) + tmp115, err := lang.WithMeta(tmp113, tmp114.(lang.IPersistentMap)) if err != nil { panic(err) } - v116 := lang.Apply(v112, []any{v115, v73}) - v117 := lang.Apply(v106, []any{v109, v116}) - v99 = v117 + tmp116 := lang.Apply(tmp112, []any{tmp115, v73}) + tmp117 := lang.Apply(tmp106, []any{tmp109, tmp116}) + tmp99 = tmp117 } - var v118 any = v99 + var v118 any = tmp99 _ = v118 - v119 := lang.NewVector(v83, v88, v93, v98, v118) - v120 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6709), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(6709), lang.NewKeyword("end-column"), int(52)) - v121, err := lang.WithMeta(v119, v120.(lang.IPersistentMap)) + tmp119 := lang.NewVector(v83, v88, v93, v98, v118) + tmp120 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6709), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(6709), lang.NewKeyword("end-column"), int(52)) + tmp121, err := lang.WithMeta(tmp119, tmp120.(lang.IPersistentMap)) if err != nil { panic(err) } - v53 = v121 + tmp53 = tmp121 } // end let - v24 = v53 + tmp24 = tmp53 } - v7 = v24 + tmp7 = tmp24 } // end let - return v7 + return tmp7 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // prep-ints { - v0 := lang.NewSymbol("prep-ints").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tests"), lang.NewSymbol("thens"))), lang.NewKeyword("doc"), "Takes a sequence of int-sized test constants and a corresponding sequence of\n then expressions. Returns a tuple of [shift mask case-map switch-type] where\n case-map is a map of int case values to [test then] tuples, and switch-type\n is either :sparse or :compact.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6631), lang.NewKeyword("end-line"), int(6631), lang.NewKeyword("private"), true)).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("prep-ints").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tests"), lang.NewSymbol("thens"))), lang.NewKeyword("doc"), "Takes a sequence of int-sized test constants and a corresponding sequence of\n then expressions. Returns a tuple of [shift mask case-map switch-type] where\n case-map is a map of int case values to [test then] tuples, and switch-type\n is either :sparse or :compact.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6631), lang.NewKeyword("end-line"), int(6631), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -63732,208 +63858,208 @@ func init() { _ = v3 v4 := args[1] _ = v4 - var v5 any - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("fits-table?")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{v3}) - if lang.IsTruthy(v9) { - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("case-map")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("int")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("int")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.Apply(v12, []any{v15, v18, v3, v4}) - v20 := lang.NewVector(int64(0), int64(0), v19, lang.NewKeyword("compact")) - v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6639), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(6639), lang.NewKeyword("end-column"), int(49)) - v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) + var tmp5 any + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("fits-table?")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.Apply(tmp8, []any{v3}) + if lang.IsTruthy(tmp9) { + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("case-map")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("int")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("int")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp12, []any{tmp15, tmp18, v3, v4}) + tmp20 := lang.NewVector(int64(0), int64(0), tmp19, lang.NewKeyword("compact")) + tmp21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6639), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(6639), lang.NewKeyword("end-column"), int(49)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) if err != nil { panic(err) } - v5 = v22 + tmp5 = tmp22 } else { - var v23 any + var tmp23 any { // let // let binding "vec__160" - var v24 any + var tmp24 any { // let // let binding "or__0__auto__" - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("maybe-min-hash")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("map")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("int")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v30, []any{v33, v3}) - v35 := lang.Apply(v27, []any{v34}) - var v36 any = v35 + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("maybe-min-hash")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("map")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("int")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp30, []any{tmp33, v3}) + tmp35 := lang.Apply(tmp27, []any{tmp34}) + var v36 any = tmp35 _ = v36 - var v37 any + var tmp37 any if lang.IsTruthy(v36) { - v37 = v36 + tmp37 = v36 } else { - v38 := lang.NewVector(int64(0), int64(0)) - v39 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6640), lang.NewKeyword("column"), int(61), lang.NewKeyword("end-line"), int(6640), lang.NewKeyword("end-column"), int(65)) - v40, err := lang.WithMeta(v38, v39.(lang.IPersistentMap)) + tmp38 := lang.NewVector(int64(0), int64(0)) + tmp39 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6640), lang.NewKeyword("column"), int(61), lang.NewKeyword("end-line"), int(6640), lang.NewKeyword("end-column"), int(65)) + tmp40, err := lang.WithMeta(tmp38, tmp39.(lang.IPersistentMap)) if err != nil { panic(err) } - v37 = v40 + tmp37 = tmp40 } - v24 = v37 + tmp24 = tmp37 } // end let - var v25 any = v24 + var v25 any = tmp24 _ = v25 // let binding "shift" - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("nth")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) - } - v28 := v27.Get() - v29 := lang.Apply(v28, []any{v25, int64(0), nil}) - var v30 any = v29 + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("nth")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) + } + tmp28 := tmp27.Get() + tmp29 := lang.Apply(tmp28, []any{v25, int64(0), nil}) + var v30 any = tmp29 _ = v30 // let binding "mask" - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("nth")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{v25, int64(1), nil}) - var v35 any = v34 + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("nth")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{v25, int64(1), nil}) + var v35 any = tmp34 _ = v35 - var v36 any - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("zero?")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.Apply(v39, []any{v35}) - if lang.IsTruthy(v40) { - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("case-map")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) - } - v43 := v42.Get() - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("int")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) - } - v46 := v45.Get() - v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v48 := v47.FindInternedVar(lang.NewSymbol("int")) - if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) - } - v49 := v48.Get() - v50 := lang.Apply(v43, []any{v46, v49, v3, v4}) - v51 := lang.NewVector(int64(0), int64(0), v50, lang.NewKeyword("sparse")) - v52 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6643), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(6643), lang.NewKeyword("end-column"), int(52)) - v53, err := lang.WithMeta(v51, v52.(lang.IPersistentMap)) + var tmp36 any + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("zero?")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.Apply(tmp39, []any{v35}) + if lang.IsTruthy(tmp40) { + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("case-map")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("int")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) + } + tmp46 := tmp45.Get() + tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp48 := tmp47.FindInternedVar(lang.NewSymbol("int")) + if tmp48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) + } + tmp49 := tmp48.Get() + tmp50 := lang.Apply(tmp43, []any{tmp46, tmp49, v3, v4}) + tmp51 := lang.NewVector(int64(0), int64(0), tmp50, lang.NewKeyword("sparse")) + tmp52 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6643), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(6643), lang.NewKeyword("end-column"), int(52)) + tmp53, err := lang.WithMeta(tmp51, tmp52.(lang.IPersistentMap)) if err != nil { panic(err) } - v36 = v53 + tmp36 = tmp53 } else { - v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v55 := v54.FindInternedVar(lang.NewSymbol("case-map")) - if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) - } - v56 := v55.Get() - var v57 lang.FnFunc - v57 = lang.NewFnFunc(func(args ...any) any { + tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp55 := tmp54.FindInternedVar(lang.NewSymbol("case-map")) + if tmp55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) + } + tmp56 := tmp55.Get() + var tmp57 lang.FnFunc + tmp57 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v58 := args[0] _ = v58 - v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v60 := v59.FindInternedVar(lang.NewSymbol("shift-mask")) - if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) - } - v61 := v60.Get() - v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v63 := v62.FindInternedVar(lang.NewSymbol("int")) - if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) - } - v64 := v63.Get() - v65 := lang.Apply(v64, []any{v58}) - v66 := lang.Apply(v61, []any{v30, v35, v65}) - return v66 + tmp59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp60 := tmp59.FindInternedVar(lang.NewSymbol("shift-mask")) + if tmp60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp60))) + } + tmp61 := tmp60.Get() + tmp62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp63 := tmp62.FindInternedVar(lang.NewSymbol("int")) + if tmp63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp63))) + } + tmp64 := tmp63.Get() + tmp65 := lang.Apply(tmp64, []any{v58}) + tmp66 := lang.Apply(tmp61, []any{v30, v35, tmp65}) + return tmp66 }) - v58 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6645), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(6645), lang.NewKeyword("end-column"), int(62)) - v59, err := lang.WithMeta(v57, v58.(lang.IPersistentMap)) + tmp58 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6645), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(6645), lang.NewKeyword("end-column"), int(62)) + tmp59, err := lang.WithMeta(tmp57, tmp58.(lang.IPersistentMap)) if err != nil { panic(err) } - v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v61 := v60.FindInternedVar(lang.NewSymbol("int")) - if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) + tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp61 := tmp60.FindInternedVar(lang.NewSymbol("int")) + if tmp61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) } - v62 := v61.Get() - v63 := lang.Apply(v56, []any{v59, v62, v3, v4}) - v64 := lang.NewVector(v30, v35, v63, lang.NewKeyword("compact")) - v65 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6645), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(6645), lang.NewKeyword("end-column"), int(89)) - v66, err := lang.WithMeta(v64, v65.(lang.IPersistentMap)) + tmp62 := tmp61.Get() + tmp63 := lang.Apply(tmp56, []any{tmp59, tmp62, v3, v4}) + tmp64 := lang.NewVector(v30, v35, tmp63, lang.NewKeyword("compact")) + tmp65 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6645), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(6645), lang.NewKeyword("end-column"), int(89)) + tmp66, err := lang.WithMeta(tmp64, tmp65.(lang.IPersistentMap)) if err != nil { panic(err) } - v36 = v66 + tmp36 = tmp66 } - v23 = v36 + tmp23 = tmp36 } // end let - v5 = v23 + tmp5 = tmp23 } - return v5 + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // prependss { - v0 := lang.NewSymbol("prependss").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Prepends a symbol or a seq to coll", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5857), lang.NewKeyword("end-line"), int(5857), lang.NewKeyword("private"), true)).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("prependss").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Prepends a symbol or a seq to coll", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5857), lang.NewKeyword("end-line"), int(5857), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -63941,53 +64067,53 @@ func init() { _ = v3 v4 := args[1] _ = v4 - var v5 any - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("symbol?")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{v3}) - if lang.IsTruthy(v9) { - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("cons")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{v3, v4}) - v5 = v13 + var tmp5 any + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("symbol?")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.Apply(tmp8, []any{v3}) + if lang.IsTruthy(tmp9) { + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("cons")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{v3, v4}) + tmp5 = tmp13 } else { - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("concat")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("concat")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{v3, v4}) - v5 = v17 + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{v3, v4}) + tmp5 = tmp17 } - return v5 + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // preserving-reduced { - v0 := lang.NewSymbol("preserving-reduced").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7638), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(7638), lang.NewKeyword("end-column"), int(34), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rf"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("preserving-reduced").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7638), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(7638), lang.NewKeyword("end-column"), int(34), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rf"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 lang.FnFunc - v4 = lang.NewFnFunc(func(args ...any) any { + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -63995,120 +64121,122 @@ func init() { _ = v5 v6 := args[1] _ = v6 - var v7 any + var tmp7 any { // let // let binding "ret" - v8 := lang.Apply(v3, []any{v5, v6}) - var v9 any = v8 + tmp8 := lang.Apply(v3, []any{v5, v6}) + var v9 any = tmp8 _ = v9 - var v10 any - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("reduced?")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{v9}) - if lang.IsTruthy(v14) { - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("reduced")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{v9}) - v10 = v18 + var tmp10 any + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("reduced?")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{v9}) + if lang.IsTruthy(tmp14) { + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("reduced")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{v9}) + tmp10 = tmp18 } else { - v10 = v9 + tmp10 = v9 } - v7 = v10 + tmp7 = tmp10 } // end let - return v7 + return tmp7 }) - v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7640), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(7643), lang.NewKeyword("end-column"), int(12)) - v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) + tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7640), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(7643), lang.NewKeyword("end-column"), int(12)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) if err != nil { panic(err) } - return v6 + return tmp6 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // print { - v0 := lang.NewSymbol("print").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Prints the object(s) to the output stream that is the current value\n of *out*. print and println produce output for human consumption.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3725), lang.NewKeyword("end-line"), int(3725))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("print").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Prints the object(s) to the output stream that is the current value\n of *out*. print and println produce output for human consumption.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3725), lang.NewKeyword("end-line"), int(3725))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v3 := lang.NewList(args[0:]...) - var v4 any + var v3 any = lang.NewList(args[0:]...) + _ = v3 + var tmp4 any { // let - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("push-thread-bindings")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("hash-map")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*print-readably*")) - v12 := lang.Apply(v10, []any{v11, nil}) - v13 := lang.Apply(v7, []any{v12}) - _ = v13 - var v14 any + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("push-thread-bindings")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("hash-map")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*print-readably*")) + tmp12 := lang.Apply(tmp10, []any{tmp11, nil}) + tmp13 := lang.Apply(tmp7, []any{tmp12}) + _ = tmp13 + var tmp14 any func() { defer func() { - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, nil) + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, nil) + _ = tmp18 }() - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("apply")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("pr")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.Apply(v21, []any{v24, v3}) - v14 = v25 + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("apply")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("pr")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.Apply(tmp21, []any{tmp24, v3}) + tmp14 = tmp25 }() - v4 = v14 + tmp4 = tmp14 } // end let - return v4 + return tmp4 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // print-ctor { - v0 := lang.NewSymbol("print-ctor").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(95), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(95), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("print-args"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("print-ctor").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(95), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(95), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("print-args"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -64118,62 +64246,62 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.Apply(lang.WriteWriter, []any{v5, "#=("}) - _ = v6 - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("class")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v9, []any{v3}) - v11, ok := lang.FieldOrMethod(v10, "Name") + tmp6 := lang.Apply(lang.WriteWriter, []any{v5, "#=("}) + _ = tmp6 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("class")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp9, []any{v3}) + tmp11, ok := lang.FieldOrMethod(tmp10, "Name") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v10, "Name"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp10, "Name"))) } - var v12 any - switch reflect.TypeOf(v11).Kind() { + var tmp12 any + switch reflect.TypeOf(tmp11).Kind() { case reflect.Func: - v12 = lang.Apply(v11, nil) + tmp12 = lang.Apply(tmp11, nil) default: - v12 = v11 + tmp12 = tmp11 } - v13 := lang.Apply(lang.WriteWriter, []any{v5, v12}) - _ = v13 - v14 := lang.Apply(lang.WriteWriter, []any{v5, ". "}) - _ = v14 - v15 := lang.Apply(v4, []any{v3, v5}) - _ = v15 - v16 := lang.Apply(lang.WriteWriter, []any{v5, ")"}) - return v16 + tmp13 := lang.Apply(lang.WriteWriter, []any{v5, tmp12}) + _ = tmp13 + tmp14 := lang.Apply(lang.WriteWriter, []any{v5, ". "}) + _ = tmp14 + tmp15 := lang.Apply(v4, []any{v3, v5}) + _ = tmp15 + tmp16 := lang.Apply(lang.WriteWriter, []any{v5, ")"}) + return tmp16 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // print-dup { - v0 := lang.NewSymbol("print-dup").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3667), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(3667), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - v1 := ns.InternWithValue(v0, nil, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp0 := lang.NewSymbol("print-dup").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3667), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(3667), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // print-initialized { - v0 := lang.NewSymbol("print-initialized").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(520), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(520), lang.NewKeyword("end-column"), int(39), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - v1 := ns.InternWithValue(v0, true, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp0 := lang.NewSymbol("print-initialized").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(520), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(520), lang.NewKeyword("end-column"), int(39), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, true, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // print-map { - v0 := lang.NewSymbol("print-map").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(252), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(252), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("print-one"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("print-map").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(252), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(252), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("print-one"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -64183,26 +64311,26 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("print-prefix-map")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("print-prefix-map")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{nil, v3, v4, v5}) - return v9 + tmp8 := tmp7.Get() + tmp9 := lang.Apply(tmp8, []any{nil, v3, v4, v5}) + return tmp9 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // print-meta { - v0 := lang.NewSymbol("print-meta").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(70), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(70), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("print-meta").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(70), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(70), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -64210,184 +64338,182 @@ func init() { _ = v3 v4 := args[1] _ = v4 - var v5 any + var tmp5 any { // let // let binding "temp__0__auto__" - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("meta")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{v3}) - var v10 any = v9 + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("meta")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.Apply(tmp8, []any{v3}) + var v10 any = tmp9 _ = v10 - var v11 any + var tmp11 any if lang.IsTruthy(v10) { - var v12 any + var tmp12 any { // let // let binding "m" var v13 any = v10 _ = v13 - var v14 any - var v15 any + var tmp14 any + var tmp15 any { // let // let binding "and__0__auto__" - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("pos?")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("count")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{v13}) - v23 := lang.Apply(v18, []any{v22}) - var v24 any = v23 + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("pos?")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("count")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, []any{v13}) + tmp23 := lang.Apply(tmp18, []any{tmp22}) + var v24 any = tmp23 _ = v24 - var v25 any + var tmp25 any if lang.IsTruthy(v24) { - var v26 any + var tmp26 any { // let // let binding "or__0__auto__" - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("*print-dup*")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("*print-dup*")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) } - v29 := v28.Get() - var v30 any = v29 + tmp29 := tmp28.Get() + var v30 any = tmp29 _ = v30 - var v31 any + var tmp31 any if lang.IsTruthy(v30) { - v31 = v30 + tmp31 = v30 } else { - var v32 any + var tmp32 any { // let // let binding "and__0__auto__" - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("*print-meta*")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("*print-meta*")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) } - v35 := v34.Get() - var v36 any = v35 + tmp35 := tmp34.Get() + var v36 any = tmp35 _ = v36 - var v37 any + var tmp37 any if lang.IsTruthy(v36) { - v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v39 := v38.FindInternedVar(lang.NewSymbol("*print-readably*")) - if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp39 := tmp38.FindInternedVar(lang.NewSymbol("*print-readably*")) + if tmp39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) } - v40 := v39.Get() - v37 = v40 + tmp40 := tmp39.Get() + tmp37 = tmp40 } else { - v37 = v36 + tmp37 = v36 } - v32 = v37 + tmp32 = tmp37 } // end let - v31 = v32 + tmp31 = tmp32 } - v26 = v31 + tmp26 = tmp31 } // end let - v25 = v26 + tmp25 = tmp26 } else { - v25 = v24 + tmp25 = v24 } - v15 = v25 + tmp15 = tmp25 } // end let - if lang.IsTruthy(v15) { - v16 := lang.Apply(lang.WriteWriter, []any{v4, "^"}) - _ = v16 - var v17 any - var v18 any + if lang.IsTruthy(tmp15) { + tmp16 := lang.Apply(lang.WriteWriter, []any{v4, "^"}) + _ = tmp16 + var tmp17 any + var tmp18 any { // let // let binding "and__0__auto__" - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("=")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("=")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) } - v21 := v20.Get() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("count")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + tmp21 := tmp20.Get() + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("count")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v13}) - v26 := lang.Apply(v21, []any{v25, int64(1)}) - var v27 any = v26 + tmp24 := tmp23.Get() + tmp25 := lang.Apply(tmp24, []any{v13}) + tmp26 := lang.Apply(tmp21, []any{tmp25, int64(1)}) + var v27 any = tmp26 _ = v27 - var v28 any + var tmp28 any if lang.IsTruthy(v27) { - v29 := lang.Apply(lang.NewKeyword("tag"), []any{v13}) - v28 = v29 + tmp29 := lang.Apply(lang.NewKeyword("tag"), []any{v13}) + tmp28 = tmp29 } else { - v28 = v27 + tmp28 = v27 } - v18 = v28 + tmp18 = tmp28 } // end let - if lang.IsTruthy(v18) { - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("pr-on")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) + if lang.IsTruthy(tmp18) { + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("pr-on")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) } - v21 := v20.Get() - v22 := lang.Apply(lang.NewKeyword("tag"), []any{v13}) - v23 := lang.Apply(v21, []any{v22, v4}) - v17 = v23 + tmp21 := tmp20.Get() + tmp22 := lang.Apply(lang.NewKeyword("tag"), []any{v13}) + tmp23 := lang.Apply(tmp21, []any{tmp22, v4}) + tmp17 = tmp23 } else { - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("pr-on")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("pr-on")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) } - v26 := v25.Get() - v27 := lang.Apply(v26, []any{v13, v4}) - v17 = v27 + tmp26 := tmp25.Get() + tmp27 := lang.Apply(tmp26, []any{v13, v4}) + tmp17 = tmp27 } - _ = v17 - v28 := lang.Apply(lang.WriteWriter, []any{v4, " "}) - v14 = v28 + _ = tmp17 + tmp28 := lang.Apply(lang.WriteWriter, []any{v4, " "}) + tmp14 = tmp28 } else { - v14 = nil } - v12 = v14 + tmp12 = tmp14 } // end let - v11 = v12 + tmp11 = tmp12 } else { - v11 = nil } - v5 = v11 + tmp5 = tmp11 } // end let - return v5 + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // print-method { - v0 := lang.NewSymbol("print-method").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3664), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(3664), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - v1 := ns.InternWithValue(v0, nil, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp0 := lang.NewSymbol("print-method").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3664), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(3664), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // print-object { - v0 := lang.NewSymbol("print-object").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(115), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(115), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("print-object").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(115), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(115), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -64395,33 +64521,33 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("print-tagged-object")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("print-tagged-object")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("str")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("str")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v3}) - v12 := lang.Apply(v7, []any{v3, v11, v4}) - return v12 + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v3}) + tmp12 := lang.Apply(tmp7, []any{v3, tmp11, v4}) + return tmp12 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // print-prefix-map { - v0 := lang.NewSymbol("print-prefix-map").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(243), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(243), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("prefix"), lang.NewSymbol("kvs"), lang.NewSymbol("print-one"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("print-prefix-map").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(243), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(243), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("prefix"), lang.NewSymbol("kvs"), lang.NewSymbol("print-one"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 4 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -64433,21 +64559,21 @@ func init() { _ = v5 v6 := args[3] _ = v6 - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("print-sequential")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("str")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{v3, "{"}) - var v14 lang.FnFunc - v14 = lang.NewFnFunc(func(args ...any) any { + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("print-sequential")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("str")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{v3, "{"}) + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -64455,59 +64581,59 @@ func init() { _ = v15 v16 := args[1] _ = v16 - var v17 any + var tmp17 any { // let // let binding "vec__212" var v18 any = v15 _ = v18 // let binding "k" - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("nth")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{v18, int64(0), nil}) - var v23 any = v22 + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("nth")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, []any{v18, int64(0), nil}) + var v23 any = tmp22 _ = v23 // let binding "v" - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("nth")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.Apply(v26, []any{v18, int64(1), nil}) - var v28 any = v27 + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("nth")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.Apply(tmp26, []any{v18, int64(1), nil}) + var v28 any = tmp27 _ = v28 - v29 := lang.Apply(v5, []any{v23, v16}) - _ = v29 - v30 := lang.Apply(lang.AppendWriter, []any{v16, lang.NewChar(32)}) - _ = v30 - v31 := lang.Apply(v5, []any{v28, v16}) - v17 = v31 + tmp29 := lang.Apply(v5, []any{v23, v16}) + _ = tmp29 + tmp30 := lang.Apply(lang.AppendWriter, []any{v16, lang.NewChar(32)}) + _ = tmp30 + tmp31 := lang.Apply(v5, []any{v28, v16}) + tmp17 = tmp31 } // end let - return v17 + return tmp17 }) - v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(246), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(247), lang.NewKeyword("end-column"), int(107)) - v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) + tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(246), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(247), lang.NewKeyword("end-column"), int(107)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) if err != nil { panic(err) } - v17 := lang.Apply(v9, []any{v13, v16, ", ", "}", v4, v6}) - return v17 + tmp17 := lang.Apply(tmp9, []any{tmp13, tmp16, ", ", "}", v4, v6}) + return tmp17 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // print-sequential { - v0 := lang.NewSymbol("print-sequential").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(46), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(46), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("begin"), lang.NewSymbol("print-one"), lang.NewSymbol("sep"), lang.NewSymbol("end"), lang.NewSymbol("sequence"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("print-sequential").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(46), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(46), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("begin"), lang.NewSymbol("print-one"), lang.NewSymbol("sep"), lang.NewSymbol("end"), lang.NewSymbol("sequence"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 6 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -64523,186 +64649,187 @@ func init() { _ = v7 v8 := args[5] _ = v8 - var v9 any + var tmp9 any { // let - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("push-thread-bindings")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("hash-map")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*print-level*")) - var v17 any + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("push-thread-bindings")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("hash-map")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*print-level*")) + var tmp17 any { // let // let binding "and__0__auto__" - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("not")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("*print-dup*")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.Apply(v20, []any{v23}) - var v25 any = v24 + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("not")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("*print-dup*")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.Apply(tmp20, []any{tmp23}) + var v25 any = tmp24 _ = v25 - var v26 any + var tmp26 any if lang.IsTruthy(v25) { - var v27 any + var tmp27 any { // let // let binding "and__0__auto__" - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("*print-level*")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("*print-level*")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) } - v30 := v29.Get() - var v31 any = v30 + tmp30 := tmp29.Get() + var v31 any = tmp30 _ = v31 - var v32 any + var tmp32 any if lang.IsTruthy(v31) { - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("dec")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("dec")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) } - v35 := v34.Get() - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("*print-level*")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) + tmp35 := tmp34.Get() + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("*print-level*")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) } - v38 := v37.Get() - v39 := lang.Apply(v35, []any{v38}) - v32 = v39 + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp35, []any{tmp38}) + tmp32 = tmp39 } else { - v32 = v31 + tmp32 = v31 } - v27 = v32 + tmp27 = tmp32 } // end let - v26 = v27 + tmp26 = tmp27 } else { - v26 = v25 + tmp26 = v25 } - v17 = v26 + tmp17 = tmp26 } // end let - v18 := lang.Apply(v15, []any{v16, v17}) - v19 := lang.Apply(v12, []any{v18}) - _ = v19 - var v20 any + tmp18 := lang.Apply(tmp15, []any{tmp16, tmp17}) + tmp19 := lang.Apply(tmp12, []any{tmp18}) + _ = tmp19 + var tmp20 any func() { defer func() { - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.Apply(v23, nil) + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.Apply(tmp23, nil) + _ = tmp24 }() - var v25 any - var v26 any + var tmp25 any + var tmp26 any { // let // let binding "and__0__auto__" - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("*print-level*")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("*print-level*")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) } - v29 := v28.Get() - var v30 any = v29 + tmp29 := tmp28.Get() + var v30 any = tmp29 _ = v30 - var v31 any + var tmp31 any if lang.IsTruthy(v30) { - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("neg?")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v36 := v35.FindInternedVar(lang.NewSymbol("*print-level*")) - if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) - } - v37 := v36.Get() - v38 := lang.Apply(v34, []any{v37}) - v31 = v38 + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("neg?")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp36 := tmp35.FindInternedVar(lang.NewSymbol("*print-level*")) + if tmp36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) + } + tmp37 := tmp36.Get() + tmp38 := lang.Apply(tmp34, []any{tmp37}) + tmp31 = tmp38 } else { - v31 = v30 + tmp31 = v30 } - v26 = v31 + tmp26 = tmp31 } // end let - if lang.IsTruthy(v26) { - v27 := lang.Apply(lang.WriteWriter, []any{v8, "#"}) - v25 = v27 + if lang.IsTruthy(tmp26) { + tmp27 := lang.Apply(lang.WriteWriter, []any{v8, "#"}) + tmp25 = tmp27 } else { - v28 := lang.Apply(lang.WriteWriter, []any{v8, v3}) - _ = v28 - var v29 any + tmp28 := lang.Apply(lang.WriteWriter, []any{v8, v3}) + _ = tmp28 + var tmp29 any { // let // let binding "temp__0__auto__" - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("seq")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) - } - v32 := v31.Get() - v33 := lang.Apply(v32, []any{v7}) - var v34 any = v33 + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("seq")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) + } + tmp32 := tmp31.Get() + tmp33 := lang.Apply(tmp32, []any{v7}) + var v34 any = tmp33 _ = v34 - var v35 any + var tmp35 any if lang.IsTruthy(v34) { - var v36 any + var tmp36 any { // let // let binding "xs" var v37 any = v34 _ = v37 - var v38 any - var v39 any + var tmp38 any + var tmp39 any { // let // let binding "and__0__auto__" - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("not")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("not")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) } - v42 := v41.Get() - v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v44 := v43.FindInternedVar(lang.NewSymbol("*print-dup*")) - if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) + tmp42 := tmp41.Get() + tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp44 := tmp43.FindInternedVar(lang.NewSymbol("*print-dup*")) + if tmp44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) } - v45 := v44.Get() - v46 := lang.Apply(v42, []any{v45}) - var v47 any = v46 + tmp45 := tmp44.Get() + tmp46 := lang.Apply(tmp42, []any{tmp45}) + var v47 any = tmp46 _ = v47 - var v48 any + var tmp48 any if lang.IsTruthy(v47) { - v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v50 := v49.FindInternedVar(lang.NewSymbol("*print-length*")) - if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) + tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp50 := tmp49.FindInternedVar(lang.NewSymbol("*print-length*")) + if tmp50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) } - v51 := v50.Get() - v48 = v51 + tmp51 := tmp50.Get() + tmp48 = tmp51 } else { - v48 = v47 + tmp48 = v47 } - v39 = v48 + tmp39 = tmp48 } // end let - if lang.IsTruthy(v39) { - var v40 any + if lang.IsTruthy(tmp39) { + var tmp40 any { // let // let binding "G__194" var v41 any = v37 @@ -64711,34 +64838,34 @@ func init() { var v42 any = v41 _ = v42 // let binding "seq__196" - v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v44 := v43.FindInternedVar(lang.NewSymbol("seq")) - if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) + tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp44 := tmp43.FindInternedVar(lang.NewSymbol("seq")) + if tmp44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) } - v45 := v44.Get() - v46 := lang.Apply(v45, []any{v42}) - var v47 any = v46 + tmp45 := tmp44.Get() + tmp46 := lang.Apply(tmp45, []any{v42}) + var v47 any = tmp46 _ = v47 // let binding "first__197" - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("first")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("first")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v47}) - var v52 any = v51 + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v47}) + var v52 any = tmp51 _ = v52 // let binding "seq__196" - v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v54 := v53.FindInternedVar(lang.NewSymbol("next")) - if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) + tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp54 := tmp53.FindInternedVar(lang.NewSymbol("next")) + if tmp54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) } - v55 := v54.Get() - v56 := lang.Apply(v55, []any{v47}) - var v57 any = v56 + tmp55 := tmp54.Get() + tmp56 := lang.Apply(tmp55, []any{v47}) + var v57 any = tmp56 _ = v57 // let binding "x" var v58 any = v52 @@ -64747,15 +64874,15 @@ func init() { var v59 any = v57 _ = v59 // let binding "print-length" - v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v61 := v60.FindInternedVar(lang.NewSymbol("*print-length*")) - if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) + tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp61 := tmp60.FindInternedVar(lang.NewSymbol("*print-length*")) + if tmp61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) } - v62 := v61.Get() - var v63 any = v62 + tmp62 := tmp61.Get() + var v63 any = tmp62 _ = v63 - var v64 any + var tmp64 any { // let // let binding "G__194" var v65 any = v41 @@ -64764,40 +64891,40 @@ func init() { var v66 any = v63 _ = v66 for { - var v67 any + var tmp67 any { // let // let binding "vec__198" var v68 any = v65 _ = v68 // let binding "seq__199" - v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v70 := v69.FindInternedVar(lang.NewSymbol("seq")) - if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) + tmp69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp70 := tmp69.FindInternedVar(lang.NewSymbol("seq")) + if tmp70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp70))) } - v71 := v70.Get() - v72 := lang.Apply(v71, []any{v68}) - var v73 any = v72 + tmp71 := tmp70.Get() + tmp72 := lang.Apply(tmp71, []any{v68}) + var v73 any = tmp72 _ = v73 // let binding "first__200" - v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v75 := v74.FindInternedVar(lang.NewSymbol("first")) - if v75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) + tmp74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp75 := tmp74.FindInternedVar(lang.NewSymbol("first")) + if tmp75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp75))) } - v76 := v75.Get() - v77 := lang.Apply(v76, []any{v73}) - var v78 any = v77 + tmp76 := tmp75.Get() + tmp77 := lang.Apply(tmp76, []any{v73}) + var v78 any = tmp77 _ = v78 // let binding "seq__199" - v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v80 := v79.FindInternedVar(lang.NewSymbol("next")) - if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) + tmp79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp80 := tmp79.FindInternedVar(lang.NewSymbol("next")) + if tmp80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp80))) } - v81 := v80.Get() - v82 := lang.Apply(v81, []any{v73}) - var v83 any = v82 + tmp81 := tmp80.Get() + tmp82 := lang.Apply(tmp81, []any{v73}) + var v83 any = tmp82 _ = v83 // let binding "x" var v84 any = v78 @@ -64808,52 +64935,51 @@ func init() { // let binding "print-length" var v86 any = v66 _ = v86 - var v87 any - v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v89 := v88.FindInternedVar(lang.NewSymbol("zero?")) - if v89.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) + var tmp87 any + tmp88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp89 := tmp88.FindInternedVar(lang.NewSymbol("zero?")) + if tmp89.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp89))) } - v90 := v89.Get() - v91 := lang.Apply(v90, []any{v86}) - if lang.IsTruthy(v91) { - v92 := lang.Apply(lang.WriteWriter, []any{v8, "..."}) - v87 = v92 + tmp90 := tmp89.Get() + tmp91 := lang.Apply(tmp90, []any{v86}) + if lang.IsTruthy(tmp91) { + tmp92 := lang.Apply(lang.WriteWriter, []any{v8, "..."}) + tmp87 = tmp92 } else { - v93 := lang.Apply(v4, []any{v84, v8}) - _ = v93 - var v94 any + tmp93 := lang.Apply(v4, []any{v84, v8}) + _ = tmp93 + var tmp94 any if lang.IsTruthy(v85) { - v95 := lang.Apply(lang.WriteWriter, []any{v8, v5}) - _ = v95 - var v96 any = v85 - v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v99 := v98.FindInternedVar(lang.NewSymbol("dec")) - if v99.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) + tmp95 := lang.Apply(lang.WriteWriter, []any{v8, v5}) + _ = tmp95 + var tmp96 any = v85 + tmp98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp99 := tmp98.FindInternedVar(lang.NewSymbol("dec")) + if tmp99.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp99))) } - v100 := v99.Get() - v101 := lang.Apply(v100, []any{v86}) - var v97 any = v101 - v65 = v96 - v66 = v97 + tmp100 := tmp99.Get() + tmp101 := lang.Apply(tmp100, []any{v86}) + var tmp97 any = tmp101 + v65 = tmp96 + v66 = tmp97 continue } else { - v94 = nil } - v87 = v94 + tmp87 = tmp94 } - v67 = v87 + tmp67 = tmp87 } // end let - v64 = v67 + tmp64 = tmp67 break } } // end let - v40 = v64 + tmp40 = tmp64 } // end let - v38 = v40 + tmp38 = tmp40 } else { - var v41 any + var tmp41 any { // let // let binding "G__204" var v42 any = v37 @@ -64862,34 +64988,34 @@ func init() { var v43 any = v42 _ = v43 // let binding "seq__206" - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("seq")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("seq")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) } - v46 := v45.Get() - v47 := lang.Apply(v46, []any{v43}) - var v48 any = v47 + tmp46 := tmp45.Get() + tmp47 := lang.Apply(tmp46, []any{v43}) + var v48 any = tmp47 _ = v48 // let binding "first__207" - v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v50 := v49.FindInternedVar(lang.NewSymbol("first")) - if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) + tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp50 := tmp49.FindInternedVar(lang.NewSymbol("first")) + if tmp50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) } - v51 := v50.Get() - v52 := lang.Apply(v51, []any{v48}) - var v53 any = v52 + tmp51 := tmp50.Get() + tmp52 := lang.Apply(tmp51, []any{v48}) + var v53 any = tmp52 _ = v53 // let binding "seq__206" - v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v55 := v54.FindInternedVar(lang.NewSymbol("next")) - if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) + tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp55 := tmp54.FindInternedVar(lang.NewSymbol("next")) + if tmp55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) } - v56 := v55.Get() - v57 := lang.Apply(v56, []any{v48}) - var v58 any = v57 + tmp56 := tmp55.Get() + tmp57 := lang.Apply(tmp56, []any{v48}) + var v58 any = tmp57 _ = v58 // let binding "x" var v59 any = v53 @@ -64897,46 +65023,46 @@ func init() { // let binding "xs" var v60 any = v58 _ = v60 - var v61 any + var tmp61 any { // let // let binding "G__204" var v62 any = v42 _ = v62 for { - var v63 any + var tmp63 any { // let // let binding "vec__208" var v64 any = v62 _ = v64 // let binding "seq__209" - v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v66 := v65.FindInternedVar(lang.NewSymbol("seq")) - if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) + tmp65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp66 := tmp65.FindInternedVar(lang.NewSymbol("seq")) + if tmp66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp66))) } - v67 := v66.Get() - v68 := lang.Apply(v67, []any{v64}) - var v69 any = v68 + tmp67 := tmp66.Get() + tmp68 := lang.Apply(tmp67, []any{v64}) + var v69 any = tmp68 _ = v69 // let binding "first__210" - v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v71 := v70.FindInternedVar(lang.NewSymbol("first")) - if v71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) + tmp70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp71 := tmp70.FindInternedVar(lang.NewSymbol("first")) + if tmp71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp71))) } - v72 := v71.Get() - v73 := lang.Apply(v72, []any{v69}) - var v74 any = v73 + tmp72 := tmp71.Get() + tmp73 := lang.Apply(tmp72, []any{v69}) + var v74 any = tmp73 _ = v74 // let binding "seq__209" - v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v76 := v75.FindInternedVar(lang.NewSymbol("next")) - if v76.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) + tmp75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp76 := tmp75.FindInternedVar(lang.NewSymbol("next")) + if tmp76.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp76))) } - v77 := v76.Get() - v78 := lang.Apply(v77, []any{v69}) - var v79 any = v78 + tmp77 := tmp76.Get() + tmp78 := lang.Apply(tmp77, []any{v69}) + var v79 any = tmp78 _ = v79 // let binding "x" var v80 any = v74 @@ -64944,57 +65070,55 @@ func init() { // let binding "xs" var v81 any = v79 _ = v81 - v82 := lang.Apply(v4, []any{v80, v8}) - _ = v82 - var v83 any + tmp82 := lang.Apply(v4, []any{v80, v8}) + _ = tmp82 + var tmp83 any if lang.IsTruthy(v81) { - v84 := lang.Apply(lang.WriteWriter, []any{v8, v5}) - _ = v84 - var v85 any = v81 - v62 = v85 + tmp84 := lang.Apply(lang.WriteWriter, []any{v8, v5}) + _ = tmp84 + var tmp85 any = v81 + v62 = tmp85 continue } else { - v83 = nil } - v63 = v83 + tmp63 = tmp83 } // end let - v61 = v63 + tmp61 = tmp63 break } } // end let - v41 = v61 + tmp41 = tmp61 } // end let - v38 = v41 + tmp38 = tmp41 } - v36 = v38 + tmp36 = tmp38 } // end let - v35 = v36 + tmp35 = tmp36 } else { - v35 = nil } - v29 = v35 + tmp29 = tmp35 } // end let - _ = v29 - v30 := lang.Apply(lang.WriteWriter, []any{v8, v6}) - v25 = v30 + _ = tmp29 + tmp30 := lang.Apply(lang.WriteWriter, []any{v8, v6}) + tmp25 = tmp30 } - v20 = v25 + tmp20 = tmp25 }() - v9 = v20 + tmp9 = tmp20 } // end let - return v9 + return tmp9 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // print-simple { - v0 := lang.NewSymbol("print-simple").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(81), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(81), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("print-simple").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(81), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(81), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -65002,118 +65126,120 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("print-meta")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v3, v4}) - _ = v8 - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("str")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.Apply(v11, []any{v3}) - v13 := lang.Apply(lang.WriteWriter, []any{v4, v12}) - return v13 - }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("print-meta")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v3, v4}) + _ = tmp8 + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("str")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.Apply(tmp11, []any{v3}) + tmp13 := lang.Apply(lang.WriteWriter, []any{v4, tmp12}) + return tmp13 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // print-str { - v1 := reflect.TypeOf("") - v0 := lang.NewSymbol("print-str").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("xs"))), lang.NewKeyword("doc"), "print to a string, returning it", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4776), lang.NewKeyword("end-line"), int(4776))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp1 := reflect.TypeOf("") + tmp0 := lang.NewSymbol("print-str").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("xs"))), lang.NewKeyword("doc"), "print to a string, returning it", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4776), lang.NewKeyword("end-line"), int(4776))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v4 := lang.NewList(args[0:]...) - var v5 any + var v4 any = lang.NewList(args[0:]...) + _ = v4 + var tmp5 any { // let // let binding "s__0__auto__" var v6 any = "unimplemented: new with non-constant class type" _ = v6 - var v7 any + var tmp7 any { // let - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("push-thread-bindings")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("hash-map")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*out*")) - v15 := lang.Apply(v13, []any{v14, v6}) - v16 := lang.Apply(v10, []any{v15}) - _ = v16 - var v17 any + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("push-thread-bindings")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("hash-map")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*out*")) + tmp15 := lang.Apply(tmp13, []any{tmp14, v6}) + tmp16 := lang.Apply(tmp10, []any{tmp15}) + _ = tmp16 + var tmp17 any func() { defer func() { - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) } - v20 := v19.Get() - v21 := lang.Apply(v20, nil) + tmp20 := tmp19.Get() + tmp21 := lang.Apply(tmp20, nil) + _ = tmp21 }() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("apply")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("print")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.Apply(v24, []any{v27, v4}) - _ = v28 - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("str")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.Apply(v31, []any{v6}) - v17 = v32 + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("apply")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("print")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.Apply(tmp24, []any{tmp27, v4}) + _ = tmp28 + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("str")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.Apply(tmp31, []any{v6}) + tmp17 = tmp32 }() - v7 = v17 + tmp7 = tmp17 } // end let - v5 = v7 + tmp5 = tmp7 } // end let - return v5 + return tmp5 } }) - v4 := reflect.TypeOf("") - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp4 := reflect.TypeOf("") + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // print-tagged-object { - v0 := lang.NewSymbol("print-tagged-object").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(102), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(102), lang.NewKeyword("end-column"), int(26), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("rep"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("print-tagged-object").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(102), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(102), lang.NewKeyword("end-column"), int(26), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("rep"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -65123,114 +65249,114 @@ func init() { _ = v4 v5 := args[2] _ = v5 - var v6 any - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("instance?")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v9, []any{lang.IMeta, v3}) - if lang.IsTruthy(v10) { - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("print-meta")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{v3, v5}) - v6 = v14 + var tmp6 any + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("instance?")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := reflect.TypeOf((*lang.IMeta)(nil)).Elem() + tmp11 := lang.Apply(tmp9, []any{tmp10, v3}) + if lang.IsTruthy(tmp11) { + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("print-meta")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.Apply(tmp14, []any{v3, v5}) + tmp6 = tmp15 } else { - v6 = nil } - _ = v6 - v15 := lang.Apply(lang.WriteWriter, []any{v5, "#object["}) - _ = v15 - var v16 any + _ = tmp6 + tmp16 := lang.Apply(lang.WriteWriter, []any{v5, "#object["}) + _ = tmp16 + var tmp17 any { // let // let binding "c" - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("class")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.Apply(v19, []any{v3}) - var v21 any = v20 - _ = v21 - var v22 any + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("class")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.Apply(tmp20, []any{v3}) + var v22 any = tmp21 + _ = v22 + var tmp23 any if lang.IsTruthy(false) { - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("print-method")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("print-method")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) } - v25 := v24.Get() - v26, ok := lang.FieldOrMethod(v21, "Name") + tmp26 := tmp25.Get() + tmp27, ok := lang.FieldOrMethod(v22, "Name") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v21, "Name"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v22, "Name"))) } - var v27 any - switch reflect.TypeOf(v26).Kind() { + var tmp28 any + switch reflect.TypeOf(tmp27).Kind() { case reflect.Func: - v27 = lang.Apply(v26, nil) + tmp28 = lang.Apply(tmp27, nil) default: - v27 = v26 + tmp28 = tmp27 } - v28 := lang.Apply(v25, []any{v27, v5}) - v22 = v28 + tmp29 := lang.Apply(tmp26, []any{tmp28, v5}) + tmp23 = tmp29 } else { - v29, ok := lang.FieldOrMethod(v21, "Name") + tmp30, ok := lang.FieldOrMethod(v22, "Name") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v21, "Name"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v22, "Name"))) } - var v30 any - switch reflect.TypeOf(v29).Kind() { + var tmp31 any + switch reflect.TypeOf(tmp30).Kind() { case reflect.Func: - v30 = lang.Apply(v29, nil) + tmp31 = lang.Apply(tmp30, nil) default: - v30 = v29 + tmp31 = tmp30 } - v31 := lang.Apply(lang.WriteWriter, []any{v5, v30}) - v22 = v31 + tmp32 := lang.Apply(lang.WriteWriter, []any{v5, tmp31}) + tmp23 = tmp32 } - v16 = v22 + tmp17 = tmp23 } // end let - _ = v16 - v17 := lang.Apply(lang.WriteWriter, []any{v5, " "}) - _ = v17 - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("format")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.Apply(lang.IdentityHash, []any{v3}) - v22 := lang.Apply(v20, []any{"0x%x ", v21}) - v23 := lang.Apply(lang.WriteWriter, []any{v5, v22}) - _ = v23 - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("print-method")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.Apply(v26, []any{v4, v5}) - _ = v27 - v28 := lang.Apply(lang.WriteWriter, []any{v5, "]"}) - return v28 - }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + _ = tmp17 + tmp18 := lang.Apply(lang.WriteWriter, []any{v5, " "}) + _ = tmp18 + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("format")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.Apply(lang.IdentityHash, []any{v3}) + tmp23 := lang.Apply(tmp21, []any{"0x%x ", tmp22}) + tmp24 := lang.Apply(lang.WriteWriter, []any{v5, tmp23}) + _ = tmp24 + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("print-method")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.Apply(tmp27, []any{v4, v5}) + _ = tmp28 + tmp29 := lang.Apply(lang.WriteWriter, []any{v5, "]"}) + return tmp29 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // print-throwable { - v0 := lang.NewSymbol("print-throwable").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(478), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(478), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("print-throwable").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(478), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(478), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -65238,287 +65364,283 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.Apply(lang.WriteWriter, []any{v4, "#error {\n :cause "}) - _ = v5 - var v6 any + tmp5 := lang.Apply(lang.WriteWriter, []any{v4, "#error {\n :cause "}) + _ = tmp5 + var tmp6 any { // let // let binding "map__253" - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("Throwable->map")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v9, []any{v3}) - var v11 any = v10 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("Throwable->map")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp9, []any{v3}) + var v11 any = tmp10 _ = v11 // let binding "map__253" - var v12 any - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("seq?")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{v11}) - if lang.IsTruthy(v16) { - var v17 any - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("next")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.Apply(v20, []any{v11}) - if lang.IsTruthy(v21) { - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("to-array")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v11}) - v26 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{v25}) - v17 = v26 + var tmp12 any + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("seq?")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{v11}) + if lang.IsTruthy(tmp16) { + var tmp17 any + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("next")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.Apply(tmp20, []any{v11}) + if lang.IsTruthy(tmp21) { + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("to-array")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{tmp25}) + tmp17 = tmp26 } else { - var v27 any - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("seq")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.Apply(v30, []any{v11}) - if lang.IsTruthy(v31) { - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("first")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{v11}) - v27 = v35 + var tmp27 any + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("seq")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.Apply(tmp30, []any{v11}) + if lang.IsTruthy(tmp31) { + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("first")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.Apply(tmp34, []any{v11}) + tmp27 = tmp35 } else { - v27 = nil } - v17 = v27 + tmp17 = tmp27 } - v12 = v17 + tmp12 = tmp17 } else { - v12 = v11 + tmp12 = v11 } - var v36 any = v12 + var v36 any = tmp12 _ = v36 // let binding "cause" - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("get")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.Apply(v39, []any{v36, lang.NewKeyword("cause")}) - var v41 any = v40 + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("get")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.Apply(tmp39, []any{v36, lang.NewKeyword("cause")}) + var v41 any = tmp40 _ = v41 // let binding "data" - v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v43 := v42.FindInternedVar(lang.NewSymbol("get")) - if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) - } - v44 := v43.Get() - v45 := lang.Apply(v44, []any{v36, lang.NewKeyword("data")}) - var v46 any = v45 + tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp43 := tmp42.FindInternedVar(lang.NewSymbol("get")) + if tmp43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) + } + tmp44 := tmp43.Get() + tmp45 := lang.Apply(tmp44, []any{v36, lang.NewKeyword("data")}) + var v46 any = tmp45 _ = v46 // let binding "via" - v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v48 := v47.FindInternedVar(lang.NewSymbol("get")) - if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) - } - v49 := v48.Get() - v50 := lang.Apply(v49, []any{v36, lang.NewKeyword("via")}) - var v51 any = v50 + tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp48 := tmp47.FindInternedVar(lang.NewSymbol("get")) + if tmp48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) + } + tmp49 := tmp48.Get() + tmp50 := lang.Apply(tmp49, []any{v36, lang.NewKeyword("via")}) + var v51 any = tmp50 _ = v51 // let binding "trace" - v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v53 := v52.FindInternedVar(lang.NewSymbol("get")) - if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) - } - v54 := v53.Get() - v55 := lang.Apply(v54, []any{v36, lang.NewKeyword("trace")}) - var v56 any = v55 + tmp52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp53 := tmp52.FindInternedVar(lang.NewSymbol("get")) + if tmp53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp53))) + } + tmp54 := tmp53.Get() + tmp55 := lang.Apply(tmp54, []any{v36, lang.NewKeyword("trace")}) + var v56 any = tmp55 _ = v56 // let binding "print-via" - var v57 lang.FnFunc - v57 = lang.NewFnFunc(func(args ...any) any { + var tmp57 lang.FnFunc + tmp57 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v58 := args[0] _ = v58 - v59 := lang.Apply(lang.WriteWriter, []any{v4, "{:type "}) - _ = v59 - v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v61 := v60.FindInternedVar(lang.NewSymbol("print-method")) - if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) - } - v62 := v61.Get() - v63 := lang.Apply(lang.NewKeyword("type"), []any{v58}) - v64 := lang.Apply(v62, []any{v63, v4}) - _ = v64 - v65 := lang.Apply(lang.WriteWriter, []any{v4, "\n :message "}) - _ = v65 - v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v67 := v66.FindInternedVar(lang.NewSymbol("print-method")) - if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) - } - v68 := v67.Get() - v69 := lang.Apply(lang.NewKeyword("message"), []any{v58}) - v70 := lang.Apply(v68, []any{v69, v4}) - _ = v70 - var v71 any + tmp59 := lang.Apply(lang.WriteWriter, []any{v4, "{:type "}) + _ = tmp59 + tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp61 := tmp60.FindInternedVar(lang.NewSymbol("print-method")) + if tmp61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) + } + tmp62 := tmp61.Get() + tmp63 := lang.Apply(lang.NewKeyword("type"), []any{v58}) + tmp64 := lang.Apply(tmp62, []any{tmp63, v4}) + _ = tmp64 + tmp65 := lang.Apply(lang.WriteWriter, []any{v4, "\n :message "}) + _ = tmp65 + tmp66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp67 := tmp66.FindInternedVar(lang.NewSymbol("print-method")) + if tmp67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp67))) + } + tmp68 := tmp67.Get() + tmp69 := lang.Apply(lang.NewKeyword("message"), []any{v58}) + tmp70 := lang.Apply(tmp68, []any{tmp69, v4}) + _ = tmp70 + var tmp71 any { // let // let binding "temp__0__auto__" - v72 := lang.Apply(lang.NewKeyword("data"), []any{v58}) - var v73 any = v72 + tmp72 := lang.Apply(lang.NewKeyword("data"), []any{v58}) + var v73 any = tmp72 _ = v73 - var v74 any + var tmp74 any if lang.IsTruthy(v73) { - var v75 any + var tmp75 any { // let // let binding "data" var v76 any = v73 _ = v76 - v77 := lang.Apply(lang.WriteWriter, []any{v4, "\n :data "}) - _ = v77 - v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v79 := v78.FindInternedVar(lang.NewSymbol("print-method")) - if v79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) + tmp77 := lang.Apply(lang.WriteWriter, []any{v4, "\n :data "}) + _ = tmp77 + tmp78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp79 := tmp78.FindInternedVar(lang.NewSymbol("print-method")) + if tmp79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp79))) } - v80 := v79.Get() - v81 := lang.Apply(v80, []any{v76, v4}) - v75 = v81 + tmp80 := tmp79.Get() + tmp81 := lang.Apply(tmp80, []any{v76, v4}) + tmp75 = tmp81 } // end let - v74 = v75 + tmp74 = tmp75 } else { - v74 = nil } - v71 = v74 + tmp71 = tmp74 } // end let - _ = v71 - var v72 any + _ = tmp71 + var tmp72 any { // let // let binding "temp__0__auto__" - v73 := lang.Apply(lang.NewKeyword("at"), []any{v58}) - var v74 any = v73 + tmp73 := lang.Apply(lang.NewKeyword("at"), []any{v58}) + var v74 any = tmp73 _ = v74 - var v75 any + var tmp75 any if lang.IsTruthy(v74) { - var v76 any + var tmp76 any { // let // let binding "at" var v77 any = v74 _ = v77 - v78 := lang.Apply(lang.WriteWriter, []any{v4, "\n :at "}) - _ = v78 - v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v80 := v79.FindInternedVar(lang.NewSymbol("print-method")) - if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) + tmp78 := lang.Apply(lang.WriteWriter, []any{v4, "\n :at "}) + _ = tmp78 + tmp79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp80 := tmp79.FindInternedVar(lang.NewSymbol("print-method")) + if tmp80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp80))) } - v81 := v80.Get() - v82 := lang.Apply(lang.NewKeyword("at"), []any{v58}) - v83 := lang.Apply(v81, []any{v82, v4}) - v76 = v83 + tmp81 := tmp80.Get() + tmp82 := lang.Apply(lang.NewKeyword("at"), []any{v58}) + tmp83 := lang.Apply(tmp81, []any{tmp82, v4}) + tmp76 = tmp83 } // end let - v75 = v76 + tmp75 = tmp76 } else { - v75 = nil } - v72 = v75 + tmp72 = tmp75 } // end let - _ = v72 - v73 := lang.Apply(lang.WriteWriter, []any{v4, "}"}) - return v73 + _ = tmp72 + tmp73 := lang.Apply(lang.WriteWriter, []any{v4, "}"}) + return tmp73 }) - v58 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(481), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(491), lang.NewKeyword("end-column"), int(73)) - v59, err := lang.WithMeta(v57, v58.(lang.IPersistentMap)) + tmp58 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(481), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(491), lang.NewKeyword("end-column"), int(73)) + tmp59, err := lang.WithMeta(tmp57, tmp58.(lang.IPersistentMap)) if err != nil { panic(err) } - var v60 any = v59 + var v60 any = tmp59 _ = v60 - v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v62 := v61.FindInternedVar(lang.NewSymbol("print-method")) - if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) - } - v63 := v62.Get() - v64 := lang.Apply(v63, []any{v41, v4}) - _ = v64 - var v65 any + tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp62 := tmp61.FindInternedVar(lang.NewSymbol("print-method")) + if tmp62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) + } + tmp63 := tmp62.Get() + tmp64 := lang.Apply(tmp63, []any{v41, v4}) + _ = tmp64 + var tmp65 any if lang.IsTruthy(v46) { - v66 := lang.Apply(lang.WriteWriter, []any{v4, "\n :data "}) - _ = v66 - v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v68 := v67.FindInternedVar(lang.NewSymbol("print-method")) - if v68.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) - } - v69 := v68.Get() - v70 := lang.Apply(v69, []any{v46, v4}) - v65 = v70 + tmp66 := lang.Apply(lang.WriteWriter, []any{v4, "\n :data "}) + _ = tmp66 + tmp67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp68 := tmp67.FindInternedVar(lang.NewSymbol("print-method")) + if tmp68.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp68))) + } + tmp69 := tmp68.Get() + tmp70 := lang.Apply(tmp69, []any{v46, v4}) + tmp65 = tmp70 } else { - v65 = nil } - _ = v65 - var v71 any + _ = tmp65 + var tmp71 any if lang.IsTruthy(v51) { - v72 := lang.Apply(lang.WriteWriter, []any{v4, "\n :via\n ["}) - _ = v72 - var v73 any + tmp72 := lang.Apply(lang.WriteWriter, []any{v4, "\n :via\n ["}) + _ = tmp72 + var tmp73 any { // let // let binding "temp__0__auto__" - v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v75 := v74.FindInternedVar(lang.NewSymbol("first")) - if v75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) - } - v76 := v75.Get() - v77 := lang.Apply(v76, []any{v51}) - var v78 any = v77 + tmp74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp75 := tmp74.FindInternedVar(lang.NewSymbol("first")) + if tmp75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp75))) + } + tmp76 := tmp75.Get() + tmp77 := lang.Apply(tmp76, []any{v51}) + var v78 any = tmp77 _ = v78 - var v79 any + var tmp79 any if lang.IsTruthy(v78) { - var v80 any + var tmp80 any { // let // let binding "fv" var v81 any = v78 _ = v81 - v82 := lang.Apply(v60, []any{v81}) - _ = v82 - var v83 any + tmp82 := lang.Apply(v60, []any{v81}) + _ = tmp82 + var tmp83 any { // let // let binding "seq_254" - v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v85 := v84.FindInternedVar(lang.NewSymbol("seq")) - if v85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) + tmp84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp85 := tmp84.FindInternedVar(lang.NewSymbol("seq")) + if tmp85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp85))) } - v86 := v85.Get() - v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v88 := v87.FindInternedVar(lang.NewSymbol("rest")) - if v88.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) + tmp86 := tmp85.Get() + tmp87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp88 := tmp87.FindInternedVar(lang.NewSymbol("rest")) + if tmp88.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp88))) } - v89 := v88.Get() - v90 := lang.Apply(v89, []any{v51}) - v91 := lang.Apply(v86, []any{v90}) - var v92 any = v91 + tmp89 := tmp88.Get() + tmp90 := lang.Apply(tmp89, []any{v51}) + tmp91 := lang.Apply(tmp86, []any{tmp90}) + var v92 any = tmp91 _ = v92 // let binding "chunk_255" var v93 any = nil @@ -65530,241 +65652,238 @@ func init() { var v95 any = int64(0) _ = v95 for { - var v96 any - v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v98 := v97.FindInternedVar(lang.NewSymbol("<")) - if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) + var tmp96 any + tmp97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp98 := tmp97.FindInternedVar(lang.NewSymbol("<")) + if tmp98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp98))) } - v99 := v98.Get() - v100 := lang.Apply(v99, []any{v95, v94}) - if lang.IsTruthy(v100) { - var v101 any + tmp99 := tmp98.Get() + tmp100 := lang.Apply(tmp99, []any{v95, v94}) + if lang.IsTruthy(tmp100) { + var tmp101 any { // let // let binding "v" - v102, _ := lang.FieldOrMethod(v93, "nth") - if reflect.TypeOf(v102).Kind() != reflect.Func { + tmp102, _ := lang.FieldOrMethod(v93, "nth") + if reflect.TypeOf(tmp102).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) } - v103 := lang.Apply(v102, []any{v95}) - var v104 any = v103 + tmp103 := lang.Apply(tmp102, []any{v95}) + var v104 any = tmp103 _ = v104 - v105 := lang.Apply(lang.WriteWriter, []any{v4, "\n "}) - _ = v105 - v106 := lang.Apply(v60, []any{v104}) - _ = v106 - var v107 any = v92 - var v108 any = v93 - var v109 any = v94 - v111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v112 := v111.FindInternedVar(lang.NewSymbol("unchecked-inc")) - if v112.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v112))) + tmp105 := lang.Apply(lang.WriteWriter, []any{v4, "\n "}) + _ = tmp105 + tmp106 := lang.Apply(v60, []any{v104}) + _ = tmp106 + var tmp107 any = v92 + var tmp108 any = v93 + var tmp109 any = v94 + tmp111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp112 := tmp111.FindInternedVar(lang.NewSymbol("unchecked-inc")) + if tmp112.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp112))) } - v113 := v112.Get() - v114 := lang.Apply(v113, []any{v95}) - var v110 any = v114 - v92 = v107 - v93 = v108 - v94 = v109 - v95 = v110 + tmp113 := tmp112.Get() + tmp114 := lang.Apply(tmp113, []any{v95}) + var tmp110 any = tmp114 + v92 = tmp107 + v93 = tmp108 + v94 = tmp109 + v95 = tmp110 continue } // end let - v96 = v101 + tmp96 = tmp101 } else { - var v102 any + var tmp102 any { // let // let binding "temp__0__auto__" - v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v104 := v103.FindInternedVar(lang.NewSymbol("seq")) - if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) + tmp103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp104 := tmp103.FindInternedVar(lang.NewSymbol("seq")) + if tmp104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp104))) } - v105 := v104.Get() - v106 := lang.Apply(v105, []any{v92}) - var v107 any = v106 + tmp105 := tmp104.Get() + tmp106 := lang.Apply(tmp105, []any{v92}) + var v107 any = tmp106 _ = v107 - var v108 any + var tmp108 any if lang.IsTruthy(v107) { - var v109 any + var tmp109 any { // let // let binding "seq_254" var v110 any = v107 _ = v110 - var v111 any - v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v113 := v112.FindInternedVar(lang.NewSymbol("chunked-seq?")) - if v113.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) + var tmp111 any + tmp112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp113 := tmp112.FindInternedVar(lang.NewSymbol("chunked-seq?")) + if tmp113.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp113))) } - v114 := v113.Get() - v115 := lang.Apply(v114, []any{v110}) - if lang.IsTruthy(v115) { - var v116 any + tmp114 := tmp113.Get() + tmp115 := lang.Apply(tmp114, []any{v110}) + if lang.IsTruthy(tmp115) { + var tmp116 any { // let // let binding "c__0__auto__" - v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v118 := v117.FindInternedVar(lang.NewSymbol("chunk-first")) - if v118.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) + tmp117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp118 := tmp117.FindInternedVar(lang.NewSymbol("chunk-first")) + if tmp118.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp118))) } - v119 := v118.Get() - v120 := lang.Apply(v119, []any{v110}) - var v121 any = v120 + tmp119 := tmp118.Get() + tmp120 := lang.Apply(tmp119, []any{v110}) + var v121 any = tmp120 _ = v121 - v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v124 := v123.FindInternedVar(lang.NewSymbol("chunk-rest")) - if v124.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) + tmp123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp124 := tmp123.FindInternedVar(lang.NewSymbol("chunk-rest")) + if tmp124.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp124))) } - v125 := v124.Get() - v126 := lang.Apply(v125, []any{v110}) - var v122 any = v126 - var v127 any = v121 - v129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v130 := v129.FindInternedVar(lang.NewSymbol("int")) - if v130.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v130))) + tmp125 := tmp124.Get() + tmp126 := lang.Apply(tmp125, []any{v110}) + var tmp122 any = tmp126 + var tmp127 any = v121 + tmp129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp130 := tmp129.FindInternedVar(lang.NewSymbol("int")) + if tmp130.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp130))) } - v131 := v130.Get() - v132 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v133 := v132.FindInternedVar(lang.NewSymbol("count")) - if v133.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v133))) + tmp131 := tmp130.Get() + tmp132 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp133 := tmp132.FindInternedVar(lang.NewSymbol("count")) + if tmp133.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp133))) } - v134 := v133.Get() - v135 := lang.Apply(v134, []any{v121}) - v136 := lang.Apply(v131, []any{v135}) - var v128 any = v136 - v138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v139 := v138.FindInternedVar(lang.NewSymbol("int")) - if v139.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v139))) + tmp134 := tmp133.Get() + tmp135 := lang.Apply(tmp134, []any{v121}) + tmp136 := lang.Apply(tmp131, []any{tmp135}) + var tmp128 any = tmp136 + tmp138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp139 := tmp138.FindInternedVar(lang.NewSymbol("int")) + if tmp139.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp139))) } - v140 := v139.Get() - v141 := lang.Apply(v140, []any{int64(0)}) - var v137 any = v141 - v92 = v122 - v93 = v127 - v94 = v128 - v95 = v137 + tmp140 := tmp139.Get() + tmp141 := lang.Apply(tmp140, []any{int64(0)}) + var tmp137 any = tmp141 + v92 = tmp122 + v93 = tmp127 + v94 = tmp128 + v95 = tmp137 continue } // end let - v111 = v116 + tmp111 = tmp116 } else { - var v117 any + var tmp117 any { // let // let binding "v" - v118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v119 := v118.FindInternedVar(lang.NewSymbol("first")) - if v119.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v119))) + tmp118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp119 := tmp118.FindInternedVar(lang.NewSymbol("first")) + if tmp119.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp119))) } - v120 := v119.Get() - v121 := lang.Apply(v120, []any{v110}) - var v122 any = v121 + tmp120 := tmp119.Get() + tmp121 := lang.Apply(tmp120, []any{v110}) + var v122 any = tmp121 _ = v122 - v123 := lang.Apply(lang.WriteWriter, []any{v4, "\n "}) - _ = v123 - v124 := lang.Apply(v60, []any{v122}) - _ = v124 - v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v127 := v126.FindInternedVar(lang.NewSymbol("next")) - if v127.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) + tmp123 := lang.Apply(lang.WriteWriter, []any{v4, "\n "}) + _ = tmp123 + tmp124 := lang.Apply(v60, []any{v122}) + _ = tmp124 + tmp126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp127 := tmp126.FindInternedVar(lang.NewSymbol("next")) + if tmp127.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp127))) } - v128 := v127.Get() - v129 := lang.Apply(v128, []any{v110}) - var v125 any = v129 - var v130 any = nil - var v131 any = int64(0) - var v132 any = int64(0) - v92 = v125 - v93 = v130 - v94 = v131 - v95 = v132 + tmp128 := tmp127.Get() + tmp129 := lang.Apply(tmp128, []any{v110}) + var tmp125 any = tmp129 + var tmp130 any = nil + var tmp131 any = int64(0) + var tmp132 any = int64(0) + v92 = tmp125 + v93 = tmp130 + v94 = tmp131 + v95 = tmp132 continue } // end let - v111 = v117 + tmp111 = tmp117 } - v109 = v111 + tmp109 = tmp111 } // end let - v108 = v109 + tmp108 = tmp109 } else { - v108 = nil } - v102 = v108 + tmp102 = tmp108 } // end let - v96 = v102 + tmp96 = tmp102 } - v83 = v96 + tmp83 = tmp96 break } } // end let - v80 = v83 + tmp80 = tmp83 } // end let - v79 = v80 + tmp79 = tmp80 } else { - v79 = nil } - v73 = v79 + tmp73 = tmp79 } // end let - _ = v73 - v74 := lang.Apply(lang.WriteWriter, []any{v4, "]"}) - v71 = v74 + _ = tmp73 + tmp74 := lang.Apply(lang.WriteWriter, []any{v4, "]"}) + tmp71 = tmp74 } else { - v71 = nil } - _ = v71 - var v75 any + _ = tmp71 + var tmp75 any if lang.IsTruthy(v56) { - v76 := lang.Apply(lang.WriteWriter, []any{v4, "\n :trace\n ["}) - _ = v76 - var v77 any + tmp76 := lang.Apply(lang.WriteWriter, []any{v4, "\n :trace\n ["}) + _ = tmp76 + var tmp77 any { // let // let binding "temp__0__auto__" - v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v79 := v78.FindInternedVar(lang.NewSymbol("first")) - if v79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) - } - v80 := v79.Get() - v81 := lang.Apply(v80, []any{v56}) - var v82 any = v81 + tmp78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp79 := tmp78.FindInternedVar(lang.NewSymbol("first")) + if tmp79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp79))) + } + tmp80 := tmp79.Get() + tmp81 := lang.Apply(tmp80, []any{v56}) + var v82 any = tmp81 _ = v82 - var v83 any + var tmp83 any if lang.IsTruthy(v82) { - var v84 any + var tmp84 any { // let // let binding "ft" var v85 any = v82 _ = v85 - v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v87 := v86.FindInternedVar(lang.NewSymbol("print-method")) - if v87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) + tmp86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp87 := tmp86.FindInternedVar(lang.NewSymbol("print-method")) + if tmp87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp87))) } - v88 := v87.Get() - v89 := lang.Apply(v88, []any{v85, v4}) - _ = v89 - var v90 any + tmp88 := tmp87.Get() + tmp89 := lang.Apply(tmp88, []any{v85, v4}) + _ = tmp89 + var tmp90 any { // let // let binding "seq_258" - v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v92 := v91.FindInternedVar(lang.NewSymbol("seq")) - if v92.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) + tmp91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp92 := tmp91.FindInternedVar(lang.NewSymbol("seq")) + if tmp92.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp92))) } - v93 := v92.Get() - v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v95 := v94.FindInternedVar(lang.NewSymbol("rest")) - if v95.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) + tmp93 := tmp92.Get() + tmp94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp95 := tmp94.FindInternedVar(lang.NewSymbol("rest")) + if tmp95.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp95))) } - v96 := v95.Get() - v97 := lang.Apply(v96, []any{v56}) - v98 := lang.Apply(v93, []any{v97}) - var v99 any = v98 + tmp96 := tmp95.Get() + tmp97 := lang.Apply(tmp96, []any{v56}) + tmp98 := lang.Apply(tmp93, []any{tmp97}) + var v99 any = tmp98 _ = v99 // let binding "chunk_259" var v100 any = nil @@ -65776,220 +65895,217 @@ func init() { var v102 any = int64(0) _ = v102 for { - var v103 any - v104 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v105 := v104.FindInternedVar(lang.NewSymbol("<")) - if v105.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v105))) + var tmp103 any + tmp104 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp105 := tmp104.FindInternedVar(lang.NewSymbol("<")) + if tmp105.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp105))) } - v106 := v105.Get() - v107 := lang.Apply(v106, []any{v102, v101}) - if lang.IsTruthy(v107) { - var v108 any + tmp106 := tmp105.Get() + tmp107 := lang.Apply(tmp106, []any{v102, v101}) + if lang.IsTruthy(tmp107) { + var tmp108 any { // let // let binding "t" - v109, _ := lang.FieldOrMethod(v100, "nth") - if reflect.TypeOf(v109).Kind() != reflect.Func { + tmp109, _ := lang.FieldOrMethod(v100, "nth") + if reflect.TypeOf(tmp109).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) } - v110 := lang.Apply(v109, []any{v102}) - var v111 any = v110 + tmp110 := lang.Apply(tmp109, []any{v102}) + var v111 any = tmp110 _ = v111 - v112 := lang.Apply(lang.WriteWriter, []any{v4, "\n "}) - _ = v112 - v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v114 := v113.FindInternedVar(lang.NewSymbol("print-method")) - if v114.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) + tmp112 := lang.Apply(lang.WriteWriter, []any{v4, "\n "}) + _ = tmp112 + tmp113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp114 := tmp113.FindInternedVar(lang.NewSymbol("print-method")) + if tmp114.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp114))) } - v115 := v114.Get() - v116 := lang.Apply(v115, []any{v111, v4}) - _ = v116 - var v117 any = v99 - var v118 any = v100 - var v119 any = v101 - v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v122 := v121.FindInternedVar(lang.NewSymbol("unchecked-inc")) - if v122.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) + tmp115 := tmp114.Get() + tmp116 := lang.Apply(tmp115, []any{v111, v4}) + _ = tmp116 + var tmp117 any = v99 + var tmp118 any = v100 + var tmp119 any = v101 + tmp121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp122 := tmp121.FindInternedVar(lang.NewSymbol("unchecked-inc")) + if tmp122.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp122))) } - v123 := v122.Get() - v124 := lang.Apply(v123, []any{v102}) - var v120 any = v124 - v99 = v117 - v100 = v118 - v101 = v119 - v102 = v120 + tmp123 := tmp122.Get() + tmp124 := lang.Apply(tmp123, []any{v102}) + var tmp120 any = tmp124 + v99 = tmp117 + v100 = tmp118 + v101 = tmp119 + v102 = tmp120 continue } // end let - v103 = v108 + tmp103 = tmp108 } else { - var v109 any + var tmp109 any { // let // let binding "temp__0__auto__" - v110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v111 := v110.FindInternedVar(lang.NewSymbol("seq")) - if v111.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v111))) + tmp110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp111 := tmp110.FindInternedVar(lang.NewSymbol("seq")) + if tmp111.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp111))) } - v112 := v111.Get() - v113 := lang.Apply(v112, []any{v99}) - var v114 any = v113 + tmp112 := tmp111.Get() + tmp113 := lang.Apply(tmp112, []any{v99}) + var v114 any = tmp113 _ = v114 - var v115 any + var tmp115 any if lang.IsTruthy(v114) { - var v116 any + var tmp116 any { // let // let binding "seq_258" var v117 any = v114 _ = v117 - var v118 any - v119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v120 := v119.FindInternedVar(lang.NewSymbol("chunked-seq?")) - if v120.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v120))) + var tmp118 any + tmp119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp120 := tmp119.FindInternedVar(lang.NewSymbol("chunked-seq?")) + if tmp120.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp120))) } - v121 := v120.Get() - v122 := lang.Apply(v121, []any{v117}) - if lang.IsTruthy(v122) { - var v123 any + tmp121 := tmp120.Get() + tmp122 := lang.Apply(tmp121, []any{v117}) + if lang.IsTruthy(tmp122) { + var tmp123 any { // let // let binding "c__0__auto__" - v124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v125 := v124.FindInternedVar(lang.NewSymbol("chunk-first")) - if v125.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v125))) + tmp124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp125 := tmp124.FindInternedVar(lang.NewSymbol("chunk-first")) + if tmp125.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp125))) } - v126 := v125.Get() - v127 := lang.Apply(v126, []any{v117}) - var v128 any = v127 + tmp126 := tmp125.Get() + tmp127 := lang.Apply(tmp126, []any{v117}) + var v128 any = tmp127 _ = v128 - v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v131 := v130.FindInternedVar(lang.NewSymbol("chunk-rest")) - if v131.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) + tmp130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp131 := tmp130.FindInternedVar(lang.NewSymbol("chunk-rest")) + if tmp131.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp131))) } - v132 := v131.Get() - v133 := lang.Apply(v132, []any{v117}) - var v129 any = v133 - var v134 any = v128 - v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v137 := v136.FindInternedVar(lang.NewSymbol("int")) - if v137.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) + tmp132 := tmp131.Get() + tmp133 := lang.Apply(tmp132, []any{v117}) + var tmp129 any = tmp133 + var tmp134 any = v128 + tmp136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp137 := tmp136.FindInternedVar(lang.NewSymbol("int")) + if tmp137.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp137))) } - v138 := v137.Get() - v139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v140 := v139.FindInternedVar(lang.NewSymbol("count")) - if v140.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v140))) + tmp138 := tmp137.Get() + tmp139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp140 := tmp139.FindInternedVar(lang.NewSymbol("count")) + if tmp140.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp140))) } - v141 := v140.Get() - v142 := lang.Apply(v141, []any{v128}) - v143 := lang.Apply(v138, []any{v142}) - var v135 any = v143 - v145 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v146 := v145.FindInternedVar(lang.NewSymbol("int")) - if v146.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v146))) + tmp141 := tmp140.Get() + tmp142 := lang.Apply(tmp141, []any{v128}) + tmp143 := lang.Apply(tmp138, []any{tmp142}) + var tmp135 any = tmp143 + tmp145 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp146 := tmp145.FindInternedVar(lang.NewSymbol("int")) + if tmp146.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp146))) } - v147 := v146.Get() - v148 := lang.Apply(v147, []any{int64(0)}) - var v144 any = v148 - v99 = v129 - v100 = v134 - v101 = v135 - v102 = v144 + tmp147 := tmp146.Get() + tmp148 := lang.Apply(tmp147, []any{int64(0)}) + var tmp144 any = tmp148 + v99 = tmp129 + v100 = tmp134 + v101 = tmp135 + v102 = tmp144 continue } // end let - v118 = v123 + tmp118 = tmp123 } else { - var v124 any + var tmp124 any { // let // let binding "t" - v125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v126 := v125.FindInternedVar(lang.NewSymbol("first")) - if v126.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v126))) + tmp125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp126 := tmp125.FindInternedVar(lang.NewSymbol("first")) + if tmp126.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp126))) } - v127 := v126.Get() - v128 := lang.Apply(v127, []any{v117}) - var v129 any = v128 + tmp127 := tmp126.Get() + tmp128 := lang.Apply(tmp127, []any{v117}) + var v129 any = tmp128 _ = v129 - v130 := lang.Apply(lang.WriteWriter, []any{v4, "\n "}) - _ = v130 - v131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v132 := v131.FindInternedVar(lang.NewSymbol("print-method")) - if v132.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v132))) + tmp130 := lang.Apply(lang.WriteWriter, []any{v4, "\n "}) + _ = tmp130 + tmp131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp132 := tmp131.FindInternedVar(lang.NewSymbol("print-method")) + if tmp132.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp132))) } - v133 := v132.Get() - v134 := lang.Apply(v133, []any{v129, v4}) - _ = v134 - v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v137 := v136.FindInternedVar(lang.NewSymbol("next")) - if v137.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) + tmp133 := tmp132.Get() + tmp134 := lang.Apply(tmp133, []any{v129, v4}) + _ = tmp134 + tmp136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp137 := tmp136.FindInternedVar(lang.NewSymbol("next")) + if tmp137.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp137))) } - v138 := v137.Get() - v139 := lang.Apply(v138, []any{v117}) - var v135 any = v139 - var v140 any = nil - var v141 any = int64(0) - var v142 any = int64(0) - v99 = v135 - v100 = v140 - v101 = v141 - v102 = v142 + tmp138 := tmp137.Get() + tmp139 := lang.Apply(tmp138, []any{v117}) + var tmp135 any = tmp139 + var tmp140 any = nil + var tmp141 any = int64(0) + var tmp142 any = int64(0) + v99 = tmp135 + v100 = tmp140 + v101 = tmp141 + v102 = tmp142 continue } // end let - v118 = v124 + tmp118 = tmp124 } - v116 = v118 + tmp116 = tmp118 } // end let - v115 = v116 + tmp115 = tmp116 } else { - v115 = nil } - v109 = v115 + tmp109 = tmp115 } // end let - v103 = v109 + tmp103 = tmp109 } - v90 = v103 + tmp90 = tmp103 break } } // end let - v84 = v90 + tmp84 = tmp90 } // end let - v83 = v84 + tmp83 = tmp84 } else { - v83 = nil } - v77 = v83 + tmp77 = tmp83 } // end let - _ = v77 - v78 := lang.Apply(lang.WriteWriter, []any{v4, "]"}) - v75 = v78 + _ = tmp77 + tmp78 := lang.Apply(lang.WriteWriter, []any{v4, "]"}) + tmp75 = tmp78 } else { - v75 = nil } - v6 = v75 + tmp6 = tmp75 } // end let - _ = v6 - v7 := lang.Apply(lang.WriteWriter, []any{v4, "}"}) - return v7 + _ = tmp6 + tmp7 := lang.Apply(lang.WriteWriter, []any{v4, "}"}) + return tmp7 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // printf { - v0 := lang.NewSymbol("printf").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fmt"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Prints formatted output, as per format", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5725), lang.NewKeyword("end-line"), int(5725))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("printf").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fmt"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Prints formatted output, as per format", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5725), lang.NewKeyword("end-line"), int(5725))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 1 { @@ -65997,584 +66113,592 @@ func init() { } v3 := args[0] _ = v3 - v4 := lang.NewList(args[1:]...) - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("print")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + var v4 any = lang.NewList(args[1:]...) + _ = v4 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("print")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("apply")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("apply")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("format")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("format")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) } - v13 := v12.Get() - v14 := lang.Apply(v10, []any{v13, v3, v4}) - v15 := lang.Apply(v7, []any{v14}) - return v15 + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp10, []any{tmp13, v3, v4}) + tmp15 := lang.Apply(tmp7, []any{tmp14}) + return tmp15 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // println { - v0 := lang.NewSymbol("println").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Same as print followed by (newline)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3734), lang.NewKeyword("end-line"), int(3734))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("println").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Same as print followed by (newline)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3734), lang.NewKeyword("end-line"), int(3734))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v3 := lang.NewList(args[0:]...) - var v4 any + var v3 any = lang.NewList(args[0:]...) + _ = v3 + var tmp4 any { // let - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("push-thread-bindings")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("hash-map")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*print-readably*")) - v12 := lang.Apply(v10, []any{v11, nil}) - v13 := lang.Apply(v7, []any{v12}) - _ = v13 - var v14 any + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("push-thread-bindings")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("hash-map")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*print-readably*")) + tmp12 := lang.Apply(tmp10, []any{tmp11, nil}) + tmp13 := lang.Apply(tmp7, []any{tmp12}) + _ = tmp13 + var tmp14 any func() { defer func() { - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, nil) + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, nil) + _ = tmp18 }() - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("apply")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("prn")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.Apply(v21, []any{v24, v3}) - v14 = v25 + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("apply")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("prn")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.Apply(tmp21, []any{tmp24, v3}) + tmp14 = tmp25 }() - v4 = v14 + tmp4 = tmp14 } // end let - return v4 + return tmp4 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // println-str { - v1 := reflect.TypeOf("") - v0 := lang.NewSymbol("println-str").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("xs"))), lang.NewKeyword("doc"), "println to a string, returning it", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4785), lang.NewKeyword("end-line"), int(4785))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp1 := reflect.TypeOf("") + tmp0 := lang.NewSymbol("println-str").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("xs"))), lang.NewKeyword("doc"), "println to a string, returning it", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4785), lang.NewKeyword("end-line"), int(4785))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v4 := lang.NewList(args[0:]...) - var v5 any + var v4 any = lang.NewList(args[0:]...) + _ = v4 + var tmp5 any { // let // let binding "s__0__auto__" var v6 any = "unimplemented: new with non-constant class type" _ = v6 - var v7 any + var tmp7 any { // let - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("push-thread-bindings")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("hash-map")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*out*")) - v15 := lang.Apply(v13, []any{v14, v6}) - v16 := lang.Apply(v10, []any{v15}) - _ = v16 - var v17 any + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("push-thread-bindings")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("hash-map")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*out*")) + tmp15 := lang.Apply(tmp13, []any{tmp14, v6}) + tmp16 := lang.Apply(tmp10, []any{tmp15}) + _ = tmp16 + var tmp17 any func() { defer func() { - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) } - v20 := v19.Get() - v21 := lang.Apply(v20, nil) + tmp20 := tmp19.Get() + tmp21 := lang.Apply(tmp20, nil) + _ = tmp21 }() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("apply")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("println")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.Apply(v24, []any{v27, v4}) - _ = v28 - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("str")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.Apply(v31, []any{v6}) - v17 = v32 + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("apply")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("println")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.Apply(tmp24, []any{tmp27, v4}) + _ = tmp28 + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("str")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.Apply(tmp31, []any{v6}) + tmp17 = tmp32 }() - v7 = v17 + tmp7 = tmp17 } // end let - v5 = v7 + tmp5 = tmp7 } // end let - return v5 + return tmp5 } }) - v4 := reflect.TypeOf("") - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp4 := reflect.TypeOf("") + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // prn { - v0 := lang.NewSymbol("prn").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Same as pr followed by (newline). Observes *flush-on-newline*", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3715), lang.NewKeyword("end-line"), int(3715))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("prn").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Same as pr followed by (newline). Observes *flush-on-newline*", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3715), lang.NewKeyword("end-line"), int(3715))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v3 := lang.NewList(args[0:]...) - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("apply")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("pr")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v6, []any{v9, v3}) - _ = v10 - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("newline")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, nil) - _ = v14 - var v15 any - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("*flush-on-newline*")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - if lang.IsTruthy(v18) { - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("flush")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.Apply(v21, nil) - v15 = v22 + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("apply")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("pr")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp6, []any{tmp9, v3}) + _ = tmp10 + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("newline")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, nil) + _ = tmp14 + var tmp15 any + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("*flush-on-newline*")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + if lang.IsTruthy(tmp18) { + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("flush")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, nil) + tmp15 = tmp22 } else { - v15 = nil } - return v15 + return tmp15 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // prn-str { - v1 := reflect.TypeOf("") - v0 := lang.NewSymbol("prn-str").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("xs"))), lang.NewKeyword("doc"), "prn to a string, returning it", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4767), lang.NewKeyword("end-line"), int(4767))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp1 := reflect.TypeOf("") + tmp0 := lang.NewSymbol("prn-str").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("xs"))), lang.NewKeyword("doc"), "prn to a string, returning it", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4767), lang.NewKeyword("end-line"), int(4767))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v4 := lang.NewList(args[0:]...) - var v5 any + var v4 any = lang.NewList(args[0:]...) + _ = v4 + var tmp5 any { // let // let binding "s__0__auto__" var v6 any = "unimplemented: new with non-constant class type" _ = v6 - var v7 any + var tmp7 any { // let - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("push-thread-bindings")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("hash-map")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*out*")) - v15 := lang.Apply(v13, []any{v14, v6}) - v16 := lang.Apply(v10, []any{v15}) - _ = v16 - var v17 any + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("push-thread-bindings")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("hash-map")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*out*")) + tmp15 := lang.Apply(tmp13, []any{tmp14, v6}) + tmp16 := lang.Apply(tmp10, []any{tmp15}) + _ = tmp16 + var tmp17 any func() { defer func() { - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) } - v20 := v19.Get() - v21 := lang.Apply(v20, nil) + tmp20 := tmp19.Get() + tmp21 := lang.Apply(tmp20, nil) + _ = tmp21 }() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("apply")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("prn")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.Apply(v24, []any{v27, v4}) - _ = v28 - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("str")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.Apply(v31, []any{v6}) - v17 = v32 + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("apply")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("prn")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.Apply(tmp24, []any{tmp27, v4}) + _ = tmp28 + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("str")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.Apply(tmp31, []any{v6}) + tmp17 = tmp32 }() - v7 = v17 + tmp7 = tmp17 } // end let - v5 = v7 + tmp5 = tmp7 } // end let - return v5 + return tmp5 } }) - v4 := reflect.TypeOf("") - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp4 := reflect.TypeOf("") + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // promise { - v0 := lang.NewSymbol("promise").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Returns a promise object that can be read with deref/@, and set,\n once only, with deliver. Calls to deref/@ prior to delivery will\n block, unless the variant of deref with timeout is used. All\n subsequent derefs will return the same delivered value without\n blocking. See also - realized?.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7078), lang.NewKeyword("end-line"), int(7078))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("promise").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Returns a promise object that can be read with deref/@, and set,\n once only, with deliver. Calls to deref/@ prior to delivery will\n block, unless the variant of deref with timeout is used. All\n subsequent derefs will return the same delivered value without\n blocking. See also - realized?.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7078), lang.NewKeyword("end-line"), int(7078))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - var v3 any + var tmp3 any { // let // let binding "d" - v4 := lang.Apply(nil, []any{int64(1)}) - var v5 any = v4 + tmp4 := lang.Apply(nil, []any{int64(1)}) + var v5 any = tmp4 _ = v5 // let binding "v" - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("atom")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{v5}) - var v10 any = v9 + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("atom")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.Apply(tmp8, []any{v5}) + var v10 any = tmp9 _ = v10 - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("deref")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.NewVector(nil) - v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7091), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(7091), lang.NewKeyword("end-column"), int(17)) - v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) + tmp11 := reflect.TypeOf((*lang.IDeref)(nil)).Elem() + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("deref")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.NewVector(nil) + tmp16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7091), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(7091), lang.NewKeyword("end-column"), int(17)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) if err != nil { panic(err) } - v17, ok := lang.FieldOrMethod(v5, "await") + tmp18, ok := lang.FieldOrMethod(v5, "await") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "await"))) } - var v18 any - switch reflect.TypeOf(v17).Kind() { + var tmp19 any + switch reflect.TypeOf(tmp18).Kind() { case reflect.Func: - v18 = lang.Apply(v17, nil) + tmp19 = lang.Apply(tmp18, nil) default: - v18 = v17 - } - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("deref")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{v10}) - v23 := lang.Apply(v13, []any{v16, v18, v22}) - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("deref")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.NewVector(nil, nil, nil) - v28 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7094), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(7094), lang.NewKeyword("end-column"), int(34)) - v29, err := lang.WithMeta(v27, v28.(lang.IPersistentMap)) + tmp19 = tmp18 + } + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("deref")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.Apply(tmp22, []any{v10}) + tmp24 := lang.Apply(tmp14, []any{tmp17, tmp19, tmp23}) + tmp25 := reflect.TypeOf((*lang.IBlockingDeref)(nil)).Elem() + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("deref")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) + } + tmp28 := tmp27.Get() + tmp29 := lang.NewVector(nil, nil, nil) + tmp30 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7094), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(7094), lang.NewKeyword("end-column"), int(34)) + tmp31, err := lang.WithMeta(tmp29, tmp30.(lang.IPersistentMap)) if err != nil { panic(err) } - var v30 any - v31, _ := lang.FieldOrMethod(v5, "await") - if reflect.TypeOf(v31).Kind() != reflect.Func { + var tmp32 any + tmp33, _ := lang.FieldOrMethod(v5, "await") + if reflect.TypeOf(tmp33).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) } - v32 := lang.Apply(v31, []any{nil, time7.Millisecond}) - if lang.IsTruthy(v32) { - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("deref")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + tmp34 := lang.Apply(tmp33, []any{nil, time7.Millisecond}) + if lang.IsTruthy(tmp34) { + tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp36 := tmp35.FindInternedVar(lang.NewSymbol("deref")) + if tmp36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) } - v35 := v34.Get() - v36 := lang.Apply(v35, []any{v10}) - v30 = v36 + tmp37 := tmp36.Get() + tmp38 := lang.Apply(tmp37, []any{v10}) + tmp32 = tmp38 } else { - v30 = nil } - v37 := lang.Apply(v26, []any{v29, v30}) - v38 := lang.NewVector(nil) - v39 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7099), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(7099), lang.NewKeyword("end-column"), int(24)) - v40, err := lang.WithMeta(v38, v39.(lang.IPersistentMap)) + tmp39 := lang.Apply(tmp28, []any{tmp31, tmp32}) + tmp40 := reflect.TypeOf((*lang.IPending)(nil)).Elem() + tmp41 := lang.NewVector(nil) + tmp42 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7099), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(7099), lang.NewKeyword("end-column"), int(24)) + tmp43, err := lang.WithMeta(tmp41, tmp42.(lang.IPersistentMap)) if err != nil { panic(err) } - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("zero?")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("zero?")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) } - v43 := v42.Get() - v44, ok := lang.FieldOrMethod(v5, "getCount") + tmp46 := tmp45.Get() + tmp47, ok := lang.FieldOrMethod(v5, "getCount") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "getCount"))) } - var v45 any - switch reflect.TypeOf(v44).Kind() { + var tmp48 any + switch reflect.TypeOf(tmp47).Kind() { case reflect.Func: - v45 = lang.Apply(v44, nil) + tmp48 = lang.Apply(tmp47, nil) default: - v45 = v44 + tmp48 = tmp47 } - v46 := lang.Apply(v43, []any{v45}) - v47 := lang.Apply(nil, []any{v40, v46}) - v48 := lang.NewVector(nil, nil) - v49 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7103), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(7103), lang.NewKeyword("end-column"), int(14)) - v50, err := lang.WithMeta(v48, v49.(lang.IPersistentMap)) + tmp49 := lang.Apply(tmp46, []any{tmp48}) + tmp50 := lang.Apply(nil, []any{tmp43, tmp49}) + tmp51 := lang.NewVector(nil, nil) + tmp52 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7103), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(7103), lang.NewKeyword("end-column"), int(14)) + tmp53, err := lang.WithMeta(tmp51, tmp52.(lang.IPersistentMap)) if err != nil { panic(err) } - var v51 any - var v52 any + var tmp54 any + var tmp55 any { // let // let binding "and__0__auto__" - v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v54 := v53.FindInternedVar(lang.NewSymbol("pos?")) - if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) + tmp56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp57 := tmp56.FindInternedVar(lang.NewSymbol("pos?")) + if tmp57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp57))) } - v55 := v54.Get() - v56, ok := lang.FieldOrMethod(v5, "getCount") + tmp58 := tmp57.Get() + tmp59, ok := lang.FieldOrMethod(v5, "getCount") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "getCount"))) } - var v57 any - switch reflect.TypeOf(v56).Kind() { + var tmp60 any + switch reflect.TypeOf(tmp59).Kind() { case reflect.Func: - v57 = lang.Apply(v56, nil) + tmp60 = lang.Apply(tmp59, nil) default: - v57 = v56 - } - v58 := lang.Apply(v55, []any{v57}) - var v59 any = v58 - _ = v59 - var v60 any - if lang.IsTruthy(v59) { - v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v62 := v61.FindInternedVar(lang.NewSymbol("compare-and-set!")) - if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) - } - v63 := v62.Get() - v64 := lang.Apply(v63, []any{v10, v5, nil}) - v60 = v64 + tmp60 = tmp59 + } + tmp61 := lang.Apply(tmp58, []any{tmp60}) + var v62 any = tmp61 + _ = v62 + var tmp63 any + if lang.IsTruthy(v62) { + tmp64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp65 := tmp64.FindInternedVar(lang.NewSymbol("compare-and-set!")) + if tmp65.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp65))) + } + tmp66 := tmp65.Get() + tmp67 := lang.Apply(tmp66, []any{v10, v5, nil}) + tmp63 = tmp67 } else { - v60 = v59 + tmp63 = v62 } - v52 = v60 + tmp55 = tmp63 } // end let - if lang.IsTruthy(v52) { - v53, ok := lang.FieldOrMethod(v5, "countDown") + if lang.IsTruthy(tmp55) { + tmp56, ok := lang.FieldOrMethod(v5, "countDown") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "countDown"))) } - var v54 any - switch reflect.TypeOf(v53).Kind() { + var tmp57 any + switch reflect.TypeOf(tmp56).Kind() { case reflect.Func: - v54 = lang.Apply(v53, nil) + tmp57 = lang.Apply(tmp56, nil) default: - v54 = v53 + tmp57 = tmp56 } - _ = v54 - v51 = nil + _ = tmp57 } else { - v51 = nil } - v55 := lang.Apply(nil, []any{v50, v51}) - v56 := lang.Apply(nil, []any{lang.IDeref, v23, lang.IBlockingDeref, v37, lang.IPending, v47, nil, v55}) - v3 = v56 + tmp58 := lang.Apply(nil, []any{tmp53, tmp54}) + tmp59 := lang.Apply(nil, []any{tmp11, tmp24, tmp25, tmp39, tmp40, tmp50, nil, tmp58}) + tmp3 = tmp59 } // end let - return v3 + return tmp3 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // protocol? { - v0 := lang.NewSymbol("protocol?").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(110), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(110), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("maybe-p"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("protocol?").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(110), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(110), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("maybe-p"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{lang.IAtom, v3}) - if lang.IsTruthy(v8) { - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("boolean")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("deref")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.Apply(v14, []any{v3}) - v16 := lang.Apply(lang.NewKeyword("on-interface"), []any{v15}) - v17 := lang.Apply(v11, []any{v16}) - v4 = v17 + var tmp4 any + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("instance?")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := reflect.TypeOf((*lang.IAtom)(nil)).Elem() + tmp9 := lang.Apply(tmp7, []any{tmp8, v3}) + if lang.IsTruthy(tmp9) { + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("boolean")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("deref")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(lang.NewKeyword("on-interface"), []any{tmp16}) + tmp18 := lang.Apply(tmp12, []any{tmp17}) + tmp4 = tmp18 } else { - v4 = false + tmp4 = false } - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // push-thread-bindings { - v0 := lang.NewSymbol("push-thread-bindings").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"))), lang.NewKeyword("doc"), "WARNING: This is a low-level function. Prefer high-level macros like\n binding where ever possible.\n\n Takes a map of Var/value pairs. Binds each Var to the associated value for\n the current thread. Each call *MUST* be accompanied by a matching call to\n pop-thread-bindings wrapped in a try-finally!\n \n (push-thread-bindings bindings)\n (try\n ...\n (finally\n (pop-thread-bindings)))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(26), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1911), lang.NewKeyword("end-line"), int(1911))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("push-thread-bindings").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"))), lang.NewKeyword("doc"), "WARNING: This is a low-level function. Prefer high-level macros like\n binding where ever possible.\n\n Takes a map of Var/value pairs. Binds each Var to the associated value for\n the current thread. Each call *MUST* be accompanied by a matching call to\n pop-thread-bindings wrapped in a try-finally!\n \n (push-thread-bindings bindings)\n (try\n ...\n (finally\n (pop-thread-bindings)))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(26), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1911), lang.NewKeyword("end-line"), int(1911))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.Apply(lang.PushThreadBindings, []any{v3}) - return v4 + tmp4 := lang.Apply(lang.PushThreadBindings, []any{v3}) + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // pvalues { - v0 := lang.NewSymbol("pvalues").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("exprs"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the values of the exprs, which are\n evaluated in parallel", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7063), lang.NewKeyword("end-line"), int(7063))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("pvalues").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("exprs"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the values of the exprs, which are\n evaluated in parallel", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7063), lang.NewKeyword("end-line"), int(7063))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 2 { @@ -66584,271 +66708,273 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.NewList(args[2:]...) - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("seq")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("concat")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("list")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.Apply(v14, []any{lang.NewSymbol("glojure.core/pcalls")}) - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("map")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - var v19 lang.FnFunc - v19 = lang.NewFnFunc(func(args ...any) any { + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("seq")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("concat")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("list")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("glojure.core/pcalls")}) + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("map")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + var tmp19 lang.FnFunc + tmp19 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v20 := args[0] _ = v20 - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("list")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.NewVector() - v25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7069), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(7069), lang.NewKeyword("end-column"), int(31)) - v26, err := lang.WithMeta(v24, v25.(lang.IPersistentMap)) + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("list")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.NewVector() + tmp25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7069), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(7069), lang.NewKeyword("end-column"), int(31)) + tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) if err != nil { panic(err) } - v27 := lang.Apply(v23, []any{lang.NewSymbol("glojure.core/fn"), v26, v20}) - return v27 + tmp27 := lang.Apply(tmp23, []any{lang.NewSymbol("glojure.core/fn"), tmp26, v20}) + return tmp27 }) - v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7069), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(7069), lang.NewKeyword("end-column"), int(34)) - v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) + tmp20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7069), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(7069), lang.NewKeyword("end-column"), int(34)) + tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) if err != nil { panic(err) } - v22 := lang.Apply(v18, []any{v21, v5}) - v23 := lang.Apply(v11, []any{v15, v22}) - v24 := lang.Apply(v8, []any{v23}) - return v24 + tmp22 := lang.Apply(tmp18, []any{tmp21, v5}) + tmp23 := lang.Apply(tmp11, []any{tmp15, tmp22}) + tmp24 := lang.Apply(tmp8, []any{tmp23}) + return tmp24 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // qualified-ident? { - v0 := lang.NewSymbol("qualified-ident?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a symbol or keyword with a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1618), lang.NewKeyword("end-line"), int(1618))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("qualified-ident?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a symbol or keyword with a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1618), lang.NewKeyword("end-line"), int(1618))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("boolean")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("boolean")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) } - v6 := v5.Get() - var v7 any + tmp6 := tmp5.Get() + var tmp7 any { // let // let binding "and__0__auto__" - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("ident?")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v3}) - var v12 any = v11 + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("ident?")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v3}) + var v12 any = tmp11 _ = v12 - var v13 any + var tmp13 any if lang.IsTruthy(v12) { - var v14 any + var tmp14 any { // let // let binding "and__0__auto__" - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("namespace")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{v3}) - var v19 any = v18 + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("namespace")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{v3}) + var v19 any = tmp18 _ = v19 - var v20 any + var tmp20 any if lang.IsTruthy(v19) { - v20 = true + tmp20 = true } else { - v20 = v19 + tmp20 = v19 } - v14 = v20 + tmp14 = tmp20 } // end let - v13 = v14 + tmp13 = tmp14 } else { - v13 = v12 + tmp13 = v12 } - v7 = v13 + tmp7 = tmp13 } // end let - v8 := lang.Apply(v6, []any{v7}) - return v8 + tmp8 := lang.Apply(tmp6, []any{tmp7}) + return tmp8 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // qualified-keyword? { - v0 := lang.NewSymbol("qualified-keyword?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a keyword with a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1638), lang.NewKeyword("end-line"), int(1638))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("qualified-keyword?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a keyword with a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1638), lang.NewKeyword("end-line"), int(1638))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("boolean")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("boolean")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) } - v6 := v5.Get() - var v7 any + tmp6 := tmp5.Get() + var tmp7 any { // let // let binding "and__0__auto__" - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("keyword?")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v3}) - var v12 any = v11 + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("keyword?")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v3}) + var v12 any = tmp11 _ = v12 - var v13 any + var tmp13 any if lang.IsTruthy(v12) { - var v14 any + var tmp14 any { // let // let binding "and__0__auto__" - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("namespace")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{v3}) - var v19 any = v18 + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("namespace")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{v3}) + var v19 any = tmp18 _ = v19 - var v20 any + var tmp20 any if lang.IsTruthy(v19) { - v20 = true + tmp20 = true } else { - v20 = v19 + tmp20 = v19 } - v14 = v20 + tmp14 = tmp20 } // end let - v13 = v14 + tmp13 = tmp14 } else { - v13 = v12 + tmp13 = v12 } - v7 = v13 + tmp7 = tmp13 } // end let - v8 := lang.Apply(v6, []any{v7}) - return v8 + tmp8 := lang.Apply(tmp6, []any{tmp7}) + return tmp8 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // qualified-symbol? { - v0 := lang.NewSymbol("qualified-symbol?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a symbol with a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1628), lang.NewKeyword("end-line"), int(1628))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("qualified-symbol?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a symbol with a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1628), lang.NewKeyword("end-line"), int(1628))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("boolean")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("boolean")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) } - v6 := v5.Get() - var v7 any + tmp6 := tmp5.Get() + var tmp7 any { // let // let binding "and__0__auto__" - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("symbol?")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v3}) - var v12 any = v11 + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("symbol?")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v3}) + var v12 any = tmp11 _ = v12 - var v13 any + var tmp13 any if lang.IsTruthy(v12) { - var v14 any + var tmp14 any { // let // let binding "and__0__auto__" - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("namespace")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{v3}) - var v19 any = v18 + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("namespace")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{v3}) + var v19 any = tmp18 _ = v19 - var v20 any + var tmp20 any if lang.IsTruthy(v19) { - v20 = true + tmp20 = true } else { - v20 = v19 + tmp20 = v19 } - v14 = v20 + tmp14 = tmp20 } // end let - v13 = v14 + tmp13 = tmp14 } else { - v13 = v12 + tmp13 = v12 } - v7 = v13 + tmp7 = tmp13 } // end let - v8 := lang.Apply(v6, []any{v7}) - return v8 + tmp8 := lang.Apply(tmp6, []any{tmp7}) + return tmp8 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // quot { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function quot__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -66856,84 +66982,84 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("seq")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("concat")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("list")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("list")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("list")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("seq")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("concat")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("list")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/Quotient")}) - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("list")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{v3}) - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("list")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.Apply(v38, []any{v4}) - v40 := lang.Apply(v27, []any{v31, v35, v39}) - v41 := lang.Apply(v24, []any{v40}) - v42 := lang.Apply(v21, []any{v41}) - v43 := lang.Apply(v10, []any{v14, v18, v42}) - v44 := lang.Apply(v7, []any{v43}) - return v44 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("concat")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("list")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol(".")}) + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("seq")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("concat")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("list")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.Apply(tmp30, []any{lang.NewSymbol("glojure.core/Quotient")}) + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.Apply(tmp34, []any{v3}) + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{v4}) + tmp40 := lang.Apply(tmp27, []any{tmp31, tmp35, tmp39}) + tmp41 := lang.Apply(tmp24, []any{tmp40}) + tmp42 := lang.Apply(tmp21, []any{tmp41}) + tmp43 := lang.Apply(tmp10, []any{tmp14, tmp18, tmp42}) + tmp44 := lang.Apply(tmp7, []any{tmp43}) + return tmp44 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("quot").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"), lang.NewSymbol("div"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "quot[ient] of dividing numerator by denominator.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1266), lang.NewKeyword("end-line"), int(1266))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("quot").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"), lang.NewSymbol("div"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "quot[ient] of dividing numerator by denominator.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1266), lang.NewKeyword("end-line"), int(1266))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -66941,321 +67067,321 @@ func init() { _ = v4 v5 := args[1] _ = v5 - v6, _ := lang.FieldOrMethod(lang.Numbers, "Quotient") - if reflect.TypeOf(v6).Kind() != reflect.Func { + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Quotient") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Quotient is not a function"))) } - v7 := lang.Apply(v6, []any{v4, v5}) - return v7 + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // rand { - v0 := lang.NewSymbol("rand").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns a random floating point number between 0 (inclusive) and\n n (default 1) (exclusive).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4935), lang.NewKeyword("end-line"), int(4935))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("rand").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns a random floating point number between 0 (inclusive) and\n n (default 1) (exclusive).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4935), lang.NewKeyword("end-line"), int(4935))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - v3 := lang.Apply(rand12.Float64, nil) - return v3 + tmp3 := lang.Apply(rand12.Float64, nil) + return tmp3 case 1: v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("*")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("rand")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v9, nil) - v11 := lang.Apply(v6, []any{v3, v10}) - return v11 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("*")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("rand")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp9, nil) + tmp11 := lang.Apply(tmp6, []any{v3, tmp10}) + return tmp11 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // rand-int { - v0 := lang.NewSymbol("rand-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns a random integer between 0 (inclusive) and n (exclusive).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4943), lang.NewKeyword("end-line"), int(4943))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("rand-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns a random integer between 0 (inclusive) and n (exclusive).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4943), lang.NewKeyword("end-line"), int(4943))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("int")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("int")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("rand")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("rand")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) } - v9 := v8.Get() - v10 := lang.Apply(v9, []any{v3}) - v11 := lang.Apply(v6, []any{v10}) - return v11 + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp9, []any{v3}) + tmp11 := lang.Apply(tmp6, []any{tmp10}) + return tmp11 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // rand-nth { - v0 := lang.NewSymbol("rand-nth").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return a random element of the (sequential) collection. Will have\n the same performance characteristics as nth for the given\n collection.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7213), lang.NewKeyword("end-line"), int(7213))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("rand-nth").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return a random element of the (sequential) collection. Will have\n the same performance characteristics as nth for the given\n collection.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7213), lang.NewKeyword("end-line"), int(7213))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("nth")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("rand-int")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("count")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{v3}) - v14 := lang.Apply(v9, []any{v13}) - v15 := lang.Apply(v6, []any{v3, v14}) - return v15 - }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("nth")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("rand-int")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("count")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(tmp9, []any{tmp13}) + tmp15 := lang.Apply(tmp6, []any{v3, tmp14}) + return tmp15 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // random-sample { - v0 := lang.NewSymbol("random-sample").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("prob")), lang.NewVector(lang.NewSymbol("prob"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns items from coll with random probability of prob (0.0 -\n 1.0). Returns a transducer when no collection is provided.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7699), lang.NewKeyword("end-line"), int(7699))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("random-sample").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("prob")), lang.NewVector(lang.NewSymbol("prob"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns items from coll with random probability of prob (0.0 -\n 1.0). Returns a transducer when no collection is provided.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7699), lang.NewKeyword("end-line"), int(7699))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("filter")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - var v7 lang.FnFunc - v7 = lang.NewFnFunc(func(args ...any) any { + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("filter")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v8 := args[0] _ = v8 - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("<")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("rand")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.Apply(v14, nil) - v16 := lang.Apply(v11, []any{v15, v3}) - return v16 + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("<")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("rand")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.Apply(tmp14, nil) + tmp16 := lang.Apply(tmp11, []any{tmp15, v3}) + return tmp16 }) - v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7704), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(7704), lang.NewKeyword("end-column"), int(37)) - v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) + tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7704), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(7704), lang.NewKeyword("end-column"), int(37)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) if err != nil { panic(err) } - v10 := lang.Apply(v6, []any{v9}) - return v10 + tmp10 := lang.Apply(tmp6, []any{tmp9}) + return tmp10 case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("filter")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - var v8 lang.FnFunc - v8 = lang.NewFnFunc(func(args ...any) any { + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("filter")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + var tmp8 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v9 := args[0] _ = v9 - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("<")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("rand")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.Apply(v15, nil) - v17 := lang.Apply(v12, []any{v16, v3}) - return v17 + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("<")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("rand")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, nil) + tmp17 := lang.Apply(tmp12, []any{tmp16, v3}) + return tmp17 }) - v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7706), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(7706), lang.NewKeyword("end-column"), int(37)) - v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) + tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7706), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(7706), lang.NewKeyword("end-column"), int(37)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) if err != nil { panic(err) } - v11 := lang.Apply(v7, []any{v10, v4}) - return v11 + tmp11 := lang.Apply(tmp7, []any{tmp10, v4}) + return tmp11 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // random-uuid { - v0 := lang.NewSymbol("random-uuid").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Returns a pseudo-randomly generated java.util.UUID instance (i.e. type 4).\n\n See: https://docs.oracle.com/javase/8/docs/api/java/util/UUID.html#randomUUID--", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6852), lang.NewKeyword("end-line"), int(6852))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("random-uuid").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Returns a pseudo-randomly generated java.util.UUID instance (i.e. type 4).\n\n See: https://docs.oracle.com/javase/8/docs/api/java/util/UUID.html#randomUUID--", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6852), lang.NewKeyword("end-line"), int(6852))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v3 := lang.Apply(uuid10.NewV7, nil) - return v3 + tmp3 := lang.Apply(uuid10.NewV7, nil) + return tmp3 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // range { - v0 := lang.NewSymbol("range").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("end")), lang.NewVector(lang.NewSymbol("start"), lang.NewSymbol("end")), lang.NewVector(lang.NewSymbol("start"), lang.NewSymbol("end"), lang.NewSymbol("step"))), lang.NewKeyword("doc"), "Returns a lazy seq of nums from start (inclusive) to end\n (exclusive), by step, where start defaults to 0, step to 1, and end to\n infinity. When step is equal to 0, returns an infinite sequence of\n start. When start is equal to end, returns empty list.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3018), lang.NewKeyword("end-line"), int(3018))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("range").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("end")), lang.NewVector(lang.NewSymbol("start"), lang.NewSymbol("end")), lang.NewVector(lang.NewSymbol("start"), lang.NewSymbol("end"), lang.NewSymbol("step"))), lang.NewKeyword("doc"), "Returns a lazy seq of nums from start (inclusive) to end\n (exclusive), by step, where start defaults to 0, step to 1, and end to\n infinity. When step is equal to 0, returns an infinite sequence of\n start. When start is equal to end, returns empty list.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3018), lang.NewKeyword("end-line"), int(3018))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v4 := v3.FindInternedVar(lang.NewSymbol("iterate")) - if v4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) - } - v5 := v4.Get() - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("inc'")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v5, []any{v8, int64(0)}) - return v9 + tmp3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp4 := tmp3.FindInternedVar(lang.NewSymbol("iterate")) + if tmp4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp4))) + } + tmp5 := tmp4.Get() + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("inc'")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.Apply(tmp5, []any{tmp8, int64(0)}) + return tmp9 case 1: v3 := args[0] _ = v3 - var v4 any - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("int?")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v3}) - if lang.IsTruthy(v8) { - v9 := lang.Apply(lang.NewLongRange, []any{int64(0), v3, int64(1)}) - v4 = v9 + var tmp4 any + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("int?")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v3}) + if lang.IsTruthy(tmp8) { + tmp9 := lang.Apply(lang.NewLongRange, []any{int64(0), v3, int64(1)}) + tmp4 = tmp9 } else { - v10 := lang.Apply(lang.NewRange, []any{int64(0), v3, int64(1)}) - v4 = v10 + tmp10 := lang.Apply(lang.NewRange, []any{int64(0), v3, int64(1)}) + tmp4 = tmp10 } - return v4 + return tmp4 case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - var v5 any - var v6 any + var tmp5 any + var tmp6 any { // let // let binding "and__0__auto__" - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("int?")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v9, []any{v3}) - var v11 any = v10 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("int?")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp9, []any{v3}) + var v11 any = tmp10 _ = v11 - var v12 any + var tmp12 any if lang.IsTruthy(v11) { - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("int?")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{v4}) - v12 = v16 + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("int?")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{v4}) + tmp12 = tmp16 } else { - v12 = v11 + tmp12 = v11 } - v6 = v12 + tmp6 = tmp12 } // end let - if lang.IsTruthy(v6) { - v7 := lang.Apply(lang.NewLongRange, []any{v3, v4, int64(1)}) - v5 = v7 + if lang.IsTruthy(tmp6) { + tmp7 := lang.Apply(lang.NewLongRange, []any{v3, v4, int64(1)}) + tmp5 = tmp7 } else { - v8 := lang.Apply(lang.NewRange, []any{v3, v4, int64(1)}) - v5 = v8 + tmp8 := lang.Apply(lang.NewRange, []any{v3, v4, int64(1)}) + tmp5 = tmp8 } - return v5 + return tmp5 case 3: v3 := args[0] _ = v3 @@ -67263,359 +67389,359 @@ func init() { _ = v4 v5 := args[2] _ = v5 - var v6 any - var v7 any + var tmp6 any + var tmp7 any { // let // let binding "and__0__auto__" - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("int?")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v3}) - var v12 any = v11 + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("int?")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v3}) + var v12 any = tmp11 _ = v12 - var v13 any + var tmp13 any if lang.IsTruthy(v12) { - var v14 any + var tmp14 any { // let // let binding "and__0__auto__" - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("int?")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{v4}) - var v19 any = v18 + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("int?")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{v4}) + var v19 any = tmp18 _ = v19 - var v20 any + var tmp20 any if lang.IsTruthy(v19) { - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("int?")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("int?")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) } - v23 := v22.Get() - v24 := lang.Apply(v23, []any{v5}) - v20 = v24 + tmp23 := tmp22.Get() + tmp24 := lang.Apply(tmp23, []any{v5}) + tmp20 = tmp24 } else { - v20 = v19 + tmp20 = v19 } - v14 = v20 + tmp14 = tmp20 } // end let - v13 = v14 + tmp13 = tmp14 } else { - v13 = v12 + tmp13 = v12 } - v7 = v13 + tmp7 = tmp13 } // end let - if lang.IsTruthy(v7) { - v8 := lang.Apply(lang.NewLongRange, []any{v3, v4, v5}) - v6 = v8 + if lang.IsTruthy(tmp7) { + tmp8 := lang.Apply(lang.NewLongRange, []any{v3, v4, v5}) + tmp6 = tmp8 } else { - v9 := lang.Apply(lang.NewRange, []any{v3, v4, v5}) - v6 = v9 + tmp9 := lang.Apply(lang.NewRange, []any{v3, v4, v5}) + tmp6 = tmp9 } - return v6 + return tmp6 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // ratio? { - v0 := lang.NewSymbol("ratio?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is a Ratio", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3577), lang.NewKeyword("end-line"), int(3577))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("ratio?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is a Ratio", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3577), lang.NewKeyword("end-line"), int(3577))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) } - v6 := v5.Get() - v7 := lang.Apply(v6, []any{*lang.Ratio, v3}) - return v7 + tmp6 := tmp5.Get() + tmp7 := reflect.TypeOf((*lang.Ratio)(nil)) + tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) + return tmp8 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // rational? { - v0 := lang.NewSymbol("rational?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is a rational number", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3613), lang.NewKeyword("end-line"), int(3613))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("rational?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is a rational number", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3613), lang.NewKeyword("end-line"), int(3613))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any + var tmp4 any { // let // let binding "or__0__auto__" - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("integer?")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v3}) - var v9 any = v8 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("integer?")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v3}) + var v9 any = tmp8 _ = v9 - var v10 any + var tmp10 any if lang.IsTruthy(v9) { - v10 = v9 + tmp10 = v9 } else { - var v11 any + var tmp11 any { // let // let binding "or__0__auto__" - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("ratio?")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.Apply(v14, []any{v3}) - var v16 any = v15 + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("ratio?")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.Apply(tmp14, []any{v3}) + var v16 any = tmp15 _ = v16 - var v17 any + var tmp17 any if lang.IsTruthy(v16) { - v17 = v16 + tmp17 = v16 } else { - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("decimal?")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("decimal?")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) } - v20 := v19.Get() - v21 := lang.Apply(v20, []any{v3}) - v17 = v21 + tmp20 := tmp19.Get() + tmp21 := lang.Apply(tmp20, []any{v3}) + tmp17 = tmp21 } - v11 = v17 + tmp11 = tmp17 } // end let - v10 = v11 + tmp10 = tmp11 } - v4 = v10 + tmp4 = tmp10 } // end let - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // rationalize { - v0 := lang.NewSymbol("rationalize").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("doc"), "returns the rational value of num", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1282), lang.NewKeyword("end-line"), int(1282))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("rationalize").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("doc"), "returns the rational value of num", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1282), lang.NewKeyword("end-line"), int(1282))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4, _ := lang.FieldOrMethod(lang.Numbers, "Rationalize") - if reflect.TypeOf(v4).Kind() != reflect.Func { + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Rationalize") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Rationalize is not a function"))) } - v5 := lang.Apply(v4, []any{v3}) - return v5 + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // re-find { - v0 := lang.NewSymbol("re-find").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m")), lang.NewVector(lang.NewSymbol("re"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns the next regex match, if any, of string to pattern, using\n java.util.regex.Matcher.find(). Uses re-groups to return the\n groups.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4922), lang.NewKeyword("end-line"), int(4922))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("re-find").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m")), lang.NewVector(lang.NewSymbol("re"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns the next regex match, if any, of string to pattern, using\n java.util.regex.Matcher.find(). Uses re-groups to return the\n groups.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4922), lang.NewKeyword("end-line"), int(4922))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - var v4 any - v5, _ := lang.FieldOrMethod(v3, "find") - if reflect.TypeOf(v5).Kind() != reflect.Func { + var tmp4 any + tmp5, _ := lang.FieldOrMethod(v3, "find") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("find is not a function"))) } - v6 := lang.Apply(v5, []any{}) - if lang.IsTruthy(v6) { - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("re-groups")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v9, []any{v3}) - v4 = v10 + tmp6 := lang.Apply(tmp5, []any{}) + if lang.IsTruthy(tmp6) { + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("re-groups")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp9, []any{v3}) + tmp4 = tmp10 } else { - v4 = nil } - return v4 + return tmp4 case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - var v5 any + var tmp5 any { // let // let binding "m" - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("re-matcher")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{v3, v4}) - var v10 any = v9 + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("re-matcher")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.Apply(tmp8, []any{v3, v4}) + var v10 any = tmp9 _ = v10 - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("re-find")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{v10}) - v5 = v14 + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("re-find")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{v10}) + tmp5 = tmp14 } // end let - return v5 + return tmp5 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // re-groups { - v0 := lang.NewSymbol("re-groups").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"))), lang.NewKeyword("doc"), "Returns the groups from the most recent match/find. If there are no\n nested groups, returns a string of the entire match. If there are\n nested groups, returns a vector of the groups, the first element\n being the entire match.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4882), lang.NewKeyword("end-line"), int(4882))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("re-groups").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"))), lang.NewKeyword("doc"), "Returns the groups from the most recent match/find. If there are no\n nested groups, returns a string of the entire match. If there are\n nested groups, returns a vector of the groups, the first element\n being the entire match.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4882), lang.NewKeyword("end-line"), int(4882))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any + var tmp4 any { // let // let binding "gc" - v5, _ := lang.FieldOrMethod(v3, "groupCount") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(v3, "groupCount") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("groupCount is not a function"))) } - v6 := lang.Apply(v5, []any{}) - var v7 any = v6 + tmp6 := lang.Apply(tmp5, []any{}) + var v7 any = tmp6 _ = v7 - var v8 any - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("zero?")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.Apply(v11, []any{v7}) - if lang.IsTruthy(v12) { - v13, _ := lang.FieldOrMethod(v3, "group") - if reflect.TypeOf(v13).Kind() != reflect.Func { + var tmp8 any + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("zero?")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.Apply(tmp11, []any{v7}) + if lang.IsTruthy(tmp12) { + tmp13, _ := lang.FieldOrMethod(v3, "group") + if reflect.TypeOf(tmp13).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("group is not a function"))) } - v14 := lang.Apply(v13, []any{}) - v8 = v14 + tmp14 := lang.Apply(tmp13, []any{}) + tmp8 = tmp14 } else { - var v15 any + var tmp15 any { // let // let binding "ret" - v16 := lang.NewVector() - v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4893), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(4893), lang.NewKeyword("end-column"), int(21)) - v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) + tmp16 := lang.NewVector() + tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4893), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(4893), lang.NewKeyword("end-column"), int(21)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) if err != nil { panic(err) } - var v19 any = v18 + var v19 any = tmp18 _ = v19 // let binding "c" var v20 any = int64(0) _ = v20 for { - var v21 any - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("<=")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v20, v7}) - if lang.IsTruthy(v25) { - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("conj")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + var tmp21 any + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("<=")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.Apply(tmp24, []any{v20, v7}) + if lang.IsTruthy(tmp25) { + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("conj")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) } - v29 := v28.Get() - v30, _ := lang.FieldOrMethod(v3, "groupInt") - if reflect.TypeOf(v30).Kind() != reflect.Func { + tmp29 := tmp28.Get() + tmp30, _ := lang.FieldOrMethod(v3, "groupInt") + if reflect.TypeOf(tmp30).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("groupInt is not a function"))) } - v31 := lang.Apply(v30, []any{v20}) - v32 := lang.Apply(v29, []any{v19, v31}) - var v26 any = v32 - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("inc")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + tmp31 := lang.Apply(tmp30, []any{v20}) + tmp32 := lang.Apply(tmp29, []any{v19, tmp31}) + var tmp26 any = tmp32 + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("inc")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) } - v36 := v35.Get() - v37 := lang.Apply(v36, []any{v20}) - var v33 any = v37 - v19 = v26 - v20 = v33 + tmp36 := tmp35.Get() + tmp37 := lang.Apply(tmp36, []any{v20}) + var tmp33 any = tmp37 + v19 = tmp26 + v20 = tmp33 continue } else { - v21 = v19 + tmp21 = v19 } - v15 = v21 + tmp15 = tmp21 break } } // end let - v8 = v15 + tmp8 = tmp15 } - v4 = v8 + tmp4 = tmp8 } // end let - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // re-matcher { - v1 := reflect.TypeOf((*lang.RegexpMatcher)(nil)) - v0 := lang.NewSymbol("re-matcher").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("re"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns an instance of java.util.regex.Matcher, for use, e.g. in\n re-find.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4873), lang.NewKeyword("end-line"), int(4873))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp1 := reflect.TypeOf((*lang.RegexpMatcher)(nil)) + tmp0 := lang.NewSymbol("re-matcher").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("re"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns an instance of java.util.regex.Matcher, for use, e.g. in\n re-find.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4873), lang.NewKeyword("end-line"), int(4873))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -67623,21 +67749,21 @@ func init() { _ = v4 v5 := args[1] _ = v5 - v6 := lang.Apply(lang.NewRegexpMatcher, []any{v4, v5}) - return v6 + tmp6 := lang.Apply(lang.NewRegexpMatcher, []any{v4, v5}) + return tmp6 }) - v4 := reflect.TypeOf((*lang.RegexpMatcher)(nil)) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp4 := reflect.TypeOf((*lang.RegexpMatcher)(nil)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // re-matches { - v0 := lang.NewSymbol("re-matches").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("re"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns the match, if any, of string to pattern, using\n java.util.regex.Matcher.matches(). Uses re-groups to return the\n groups.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4910), lang.NewKeyword("end-line"), int(4910))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("re-matches").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("re"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns the match, if any, of string to pattern, using\n java.util.regex.Matcher.matches(). Uses re-groups to return the\n groups.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4910), lang.NewKeyword("end-line"), int(4910))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -67645,85 +67771,85 @@ func init() { _ = v3 v4 := args[1] _ = v4 - var v5 any + var tmp5 any { // let // let binding "m" - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("re-matcher")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{v3, v4}) - var v10 any = v9 + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("re-matcher")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.Apply(tmp8, []any{v3, v4}) + var v10 any = tmp9 _ = v10 - var v11 any - v12, _ := lang.FieldOrMethod(v10, "matches") - if reflect.TypeOf(v12).Kind() != reflect.Func { + var tmp11 any + tmp12, _ := lang.FieldOrMethod(v10, "matches") + if reflect.TypeOf(tmp12).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("matches is not a function"))) } - v13 := lang.Apply(v12, []any{}) - if lang.IsTruthy(v13) { - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("re-groups")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{v10}) - v11 = v17 + tmp13 := lang.Apply(tmp12, []any{}) + if lang.IsTruthy(tmp13) { + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("re-groups")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{v10}) + tmp11 = tmp17 } else { - v11 = nil } - v5 = v11 + tmp5 = tmp11 } // end let - return v5 + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // re-pattern { - v1 := reflect.TypeOf((*regexp13.Regexp)(nil)) - v0 := lang.NewSymbol("re-pattern").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns an instance of java.util.regex.Pattern, for use, e.g. in\n re-matcher.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4863), lang.NewKeyword("end-line"), int(4863))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp1 := reflect.TypeOf((*regexp13.Regexp)(nil)) + tmp0 := lang.NewSymbol("re-pattern").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns an instance of java.util.regex.Pattern, for use, e.g. in\n re-matcher.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4863), lang.NewKeyword("end-line"), int(4863))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - var v5 any - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{*regexp13.Regexp, v4}) - if lang.IsTruthy(v9) { - v5 = v4 + var tmp5 any + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("instance?")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := reflect.TypeOf((*regexp13.Regexp)(nil)) + tmp10 := lang.Apply(tmp8, []any{tmp9, v4}) + if lang.IsTruthy(tmp10) { + tmp5 = v4 } else { - v10 := lang.Apply(regexp13.MustCompile, []any{v4}) - v5 = v10 + tmp11 := lang.Apply(regexp13.MustCompile, []any{v4}) + tmp5 = tmp11 } - return v5 + return tmp5 }) - v4 := reflect.TypeOf((*regexp13.Regexp)(nil)) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp4 := reflect.TypeOf((*regexp13.Regexp)(nil)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // re-seq { - v0 := lang.NewSymbol("re-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("re"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns a lazy sequence of successive matches of pattern in string,\n using java.util.regex.Matcher.find(), each such match processed with\n re-groups.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4898), lang.NewKeyword("end-line"), int(4898))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("re-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("re"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns a lazy sequence of successive matches of pattern in string,\n using java.util.regex.Matcher.find(), each such match processed with\n re-groups.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4898), lang.NewKeyword("end-line"), int(4898))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -67731,111 +67857,111 @@ func init() { _ = v3 v4 := args[1] _ = v4 - var v5 any + var tmp5 any { // let // let binding "m" - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("re-matcher")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{v3, v4}) - var v10 any = v9 + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("re-matcher")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.Apply(tmp8, []any{v3, v4}) + var v10 any = tmp9 _ = v10 - var v11 lang.FnFunc + var tmp11 lang.FnFunc { // function step - v11 = lang.NewFnFunc(func(args ...any) any { + var v12 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - var v13 any - v14, _ := lang.FieldOrMethod(v10, "find") - if reflect.TypeOf(v14).Kind() != reflect.Func { + var tmp13 any + tmp14, _ := lang.FieldOrMethod(v10, "find") + if reflect.TypeOf(tmp14).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("find is not a function"))) } - v15 := lang.Apply(v14, []any{}) - if lang.IsTruthy(v15) { - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("cons")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("re-groups")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{v10}) - var v23 lang.FnFunc - v23 = lang.NewFnFunc(func(args ...any) any { + tmp15 := lang.Apply(tmp14, []any{}) + if lang.IsTruthy(tmp15) { + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("cons")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("re-groups")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, []any{v10}) + var tmp23 lang.FnFunc + tmp23 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v24 := lang.Apply(v12, nil) - return v24 + tmp24 := lang.Apply(v12, nil) + return tmp24 }) - v24 := lang.Apply(lang.NewLazySeq, []any{v23}) - v25 := lang.Apply(v18, []any{v22, v24}) - v13 = v25 + tmp24 := lang.Apply(lang.NewLazySeq, []any{tmp23}) + tmp25 := lang.Apply(tmp18, []any{tmp22, tmp24}) + tmp13 = tmp25 } else { - v13 = nil } - return v13 + return tmp13 }) - v12 := v11 + v12 = tmp11 _ = v12 } - v12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4906), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(4908), lang.NewKeyword("end-column"), int(49)) - v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) + tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4906), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(4908), lang.NewKeyword("end-column"), int(49)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) if err != nil { panic(err) } - v14 := lang.Apply(v13, nil) - v5 = v14 + tmp14 := lang.Apply(tmp13, nil) + tmp5 = tmp14 } // end let - return v5 + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // read { - v0 := lang.NewSymbol("read").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("stream")), lang.NewVector(lang.NewSymbol("stream"), lang.NewSymbol("eof-error?"), lang.NewSymbol("eof-value")), lang.NewVector(lang.NewSymbol("stream"), lang.NewSymbol("eof-error?"), lang.NewSymbol("eof-value"), lang.NewSymbol("recursive?")), lang.NewVector(lang.NewSymbol("opts"), lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Reads the next object from stream, which must be an instance of\n java.io.PushbackReader or some derivee. stream defaults to the\n current value of *in*.\n\n Opts is a persistent map with valid keys:\n :read-cond - :allow to process reader conditionals, or\n :preserve to keep all branches\n :features - persistent set of feature keywords for reader conditionals\n :eof - on eof, return value unless :eofthrow, then throw.\n if not specified, will throw\n\n Note that read can execute code (controlled by *read-eval*),\n and as such should be used only with trusted sources.\n\n For data structure interop use glojure.edn/read", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3742), lang.NewKeyword("end-line"), int(3742))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("read").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("stream")), lang.NewVector(lang.NewSymbol("stream"), lang.NewSymbol("eof-error?"), lang.NewSymbol("eof-value")), lang.NewVector(lang.NewSymbol("stream"), lang.NewSymbol("eof-error?"), lang.NewSymbol("eof-value"), lang.NewSymbol("recursive?")), lang.NewVector(lang.NewSymbol("opts"), lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Reads the next object from stream, which must be an instance of\n java.io.PushbackReader or some derivee. stream defaults to the\n current value of *in*.\n\n Opts is a persistent map with valid keys:\n :read-cond - :allow to process reader conditionals, or\n :preserve to keep all branches\n :features - persistent set of feature keywords for reader conditionals\n :eof - on eof, return value unless :eofthrow, then throw.\n if not specified, will throw\n\n Note that read can execute code (controlled by *read-eval*),\n and as such should be used only with trusted sources.\n\n For data structure interop use glojure.edn/read", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3742), lang.NewKeyword("end-line"), int(3742))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v4 := v3.FindInternedVar(lang.NewSymbol("read")) - if v4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) - } - v5 := v4.Get() - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("*in*")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v5, []any{v8}) - return v9 + tmp3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp4 := tmp3.FindInternedVar(lang.NewSymbol("read")) + if tmp4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp4))) + } + tmp5 := tmp4.Get() + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("*in*")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.Apply(tmp5, []any{tmp8}) + return tmp9 case 1: v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("read")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.Apply(v6, []any{v3, true, nil}) - return v7 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("read")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.Apply(tmp6, []any{v3, true, nil}) + return tmp7 case 3: v3 := args[0] _ = v3 @@ -67843,14 +67969,14 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("read")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{v3, v4, v5, false}) - return v9 + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("read")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.Apply(tmp8, []any{v3, v4, v5, false}) + return tmp9 case 4: v3 := args[0] _ = v3 @@ -67860,72 +67986,72 @@ func init() { _ = v5 v6 := args[3] _ = v6 - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("boolean")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v9, []any{v4}) - v11, _ := lang.FieldOrMethod(nil, "read") - if reflect.TypeOf(v11).Kind() != reflect.Func { + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("boolean")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp9, []any{v4}) + tmp11, _ := lang.FieldOrMethod(nil, "read") + if reflect.TypeOf(tmp11).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("read is not a function"))) } - v12 := lang.Apply(v11, []any{v3, v10, v5, v6}) - return v12 + tmp12 := lang.Apply(tmp11, []any{v3, tmp10, v5, v6}) + return tmp12 case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - v5, _ := lang.FieldOrMethod(nil, "read") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(nil, "read") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("read is not a function"))) } - v6 := lang.Apply(v5, []any{v4, v3}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4, v3}) + return tmp6 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // read+string { - v0 := lang.NewSymbol("read+string").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("stream")), lang.NewVector(lang.NewSymbol("stream"), lang.NewSymbol("eof-error?"), lang.NewSymbol("eof-value")), lang.NewVector(lang.NewSymbol("stream"), lang.NewSymbol("eof-error?"), lang.NewSymbol("eof-value"), lang.NewSymbol("recursive?")), lang.NewVector(lang.NewSymbol("opts"), lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Like read, and taking the same args. stream must be a LineNumberingPushbackReader.\n Returns a vector containing the object read and the (whitespace-trimmed) string read.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3771), lang.NewKeyword("end-line"), int(3771))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("read+string").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("stream")), lang.NewVector(lang.NewSymbol("stream"), lang.NewSymbol("eof-error?"), lang.NewSymbol("eof-value")), lang.NewVector(lang.NewSymbol("stream"), lang.NewSymbol("eof-error?"), lang.NewSymbol("eof-value"), lang.NewSymbol("recursive?")), lang.NewVector(lang.NewSymbol("opts"), lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Like read, and taking the same args. stream must be a LineNumberingPushbackReader.\n Returns a vector containing the object read and the (whitespace-trimmed) string read.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3771), lang.NewKeyword("end-line"), int(3771))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v4 := v3.FindInternedVar(lang.NewSymbol("read+string")) - if v4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) - } - v5 := v4.Get() - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("*in*")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v5, []any{v8}) - return v9 + tmp3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp4 := tmp3.FindInternedVar(lang.NewSymbol("read+string")) + if tmp4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp4))) + } + tmp5 := tmp4.Get() + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("*in*")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.Apply(tmp5, []any{tmp8}) + return tmp9 case 1: v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("read+string")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.Apply(v6, []any{v3, true, nil}) - return v7 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("read+string")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.Apply(tmp6, []any{v3, true, nil}) + return tmp7 case 3: v3 := args[0] _ = v3 @@ -67933,14 +68059,14 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("read+string")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{v3, v4, v5, false}) - return v9 + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("read+string")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.Apply(tmp8, []any{v3, v4, v5, false}) + return tmp9 case 4: v3 := args[0] _ = v3 @@ -67950,293 +68076,293 @@ func init() { _ = v5 v6 := args[3] _ = v6 - var v7 any + var tmp7 any func() { defer func() { if r := recover(); r != nil { if lang.CatchMatches(r, lang.Throwable) { v8 := r _ = v8 - v9, ok := lang.FieldOrMethod(v3, "getString") + tmp9, ok := lang.FieldOrMethod(v3, "getString") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getString"))) } - var v10 any - switch reflect.TypeOf(v9).Kind() { + var tmp10 any + switch reflect.TypeOf(tmp9).Kind() { case reflect.Func: - v10 = lang.Apply(v9, nil) + tmp10 = lang.Apply(tmp9, nil) default: - v10 = v9 + tmp10 = tmp9 } - _ = v10 + _ = tmp10 panic(v8) } else { panic(r) } } }() - v8, ok := lang.FieldOrMethod(v3, "captureString") + tmp8, ok := lang.FieldOrMethod(v3, "captureString") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "captureString"))) } - var v9 any - switch reflect.TypeOf(v8).Kind() { + var tmp9 any + switch reflect.TypeOf(tmp8).Kind() { case reflect.Func: - v9 = lang.Apply(v8, nil) + tmp9 = lang.Apply(tmp8, nil) default: - v9 = v8 + tmp9 = tmp8 } - _ = v9 - var v10 any + _ = tmp9 + var tmp10 any { // let // let binding "o" - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("read")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{v3, v4, v5, v6}) - var v15 any = v14 + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("read")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{v3, v4, v5, v6}) + var v15 any = tmp14 _ = v15 // let binding "s" - v16, ok := lang.FieldOrMethod(v3, "getString") + tmp16, ok := lang.FieldOrMethod(v3, "getString") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getString"))) } - var v17 any - switch reflect.TypeOf(v16).Kind() { + var tmp17 any + switch reflect.TypeOf(tmp16).Kind() { case reflect.Func: - v17 = lang.Apply(v16, nil) + tmp17 = lang.Apply(tmp16, nil) default: - v17 = v16 + tmp17 = tmp16 } - v18, ok := lang.FieldOrMethod(v17, "trim") + tmp18, ok := lang.FieldOrMethod(tmp17, "trim") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v17, "trim"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp17, "trim"))) } - var v19 any - switch reflect.TypeOf(v18).Kind() { + var tmp19 any + switch reflect.TypeOf(tmp18).Kind() { case reflect.Func: - v19 = lang.Apply(v18, nil) + tmp19 = lang.Apply(tmp18, nil) default: - v19 = v18 + tmp19 = tmp18 } - var v20 any = v19 + var v20 any = tmp19 _ = v20 - v21 := lang.NewVector(v15, v20) - v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3783), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(3783), lang.NewKeyword("end-column"), int(12)) - v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) + tmp21 := lang.NewVector(v15, v20) + tmp22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3783), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(3783), lang.NewKeyword("end-column"), int(12)) + tmp23, err := lang.WithMeta(tmp21, tmp22.(lang.IPersistentMap)) if err != nil { panic(err) } - v10 = v23 + tmp10 = tmp23 } // end let - v7 = v10 + tmp7 = tmp10 }() - return v7 + return tmp7 case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - var v5 any + var tmp5 any func() { defer func() { if r := recover(); r != nil { if lang.CatchMatches(r, lang.Throwable) { v6 := r _ = v6 - v7, ok := lang.FieldOrMethod(v4, "getString") + tmp7, ok := lang.FieldOrMethod(v4, "getString") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "getString"))) } - var v8 any - switch reflect.TypeOf(v7).Kind() { + var tmp8 any + switch reflect.TypeOf(tmp7).Kind() { case reflect.Func: - v8 = lang.Apply(v7, nil) + tmp8 = lang.Apply(tmp7, nil) default: - v8 = v7 + tmp8 = tmp7 } - _ = v8 + _ = tmp8 panic(v6) } else { panic(r) } } }() - v6, ok := lang.FieldOrMethod(v4, "captureString") + tmp6, ok := lang.FieldOrMethod(v4, "captureString") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "captureString"))) } - var v7 any - switch reflect.TypeOf(v6).Kind() { + var tmp7 any + switch reflect.TypeOf(tmp6).Kind() { case reflect.Func: - v7 = lang.Apply(v6, nil) + tmp7 = lang.Apply(tmp6, nil) default: - v7 = v6 + tmp7 = tmp6 } - _ = v7 - var v8 any + _ = tmp7 + var tmp8 any { // let // let binding "o" - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("read")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.Apply(v11, []any{v3, v4}) - var v13 any = v12 + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("read")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.Apply(tmp11, []any{v3, v4}) + var v13 any = tmp12 _ = v13 // let binding "s" - v14, ok := lang.FieldOrMethod(v4, "getString") + tmp14, ok := lang.FieldOrMethod(v4, "getString") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "getString"))) } - var v15 any - switch reflect.TypeOf(v14).Kind() { + var tmp15 any + switch reflect.TypeOf(tmp14).Kind() { case reflect.Func: - v15 = lang.Apply(v14, nil) + tmp15 = lang.Apply(tmp14, nil) default: - v15 = v14 + tmp15 = tmp14 } - v16, ok := lang.FieldOrMethod(v15, "trim") + tmp16, ok := lang.FieldOrMethod(tmp15, "trim") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v15, "trim"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp15, "trim"))) } - var v17 any - switch reflect.TypeOf(v16).Kind() { + var tmp17 any + switch reflect.TypeOf(tmp16).Kind() { case reflect.Func: - v17 = lang.Apply(v16, nil) + tmp17 = lang.Apply(tmp16, nil) default: - v17 = v16 + tmp17 = tmp16 } - var v18 any = v17 + var v18 any = tmp17 _ = v18 - v19 := lang.NewVector(v13, v18) - v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3792), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(3792), lang.NewKeyword("end-column"), int(12)) - v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) + tmp19 := lang.NewVector(v13, v18) + tmp20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3792), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(3792), lang.NewKeyword("end-column"), int(12)) + tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) if err != nil { panic(err) } - v8 = v21 + tmp8 = tmp21 } // end let - v5 = v8 + tmp5 = tmp8 }() - return v5 + return tmp5 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // read-line { - v0 := lang.NewSymbol("read-line").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Reads the next line from stream that is the current value of *in* .", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3797), lang.NewKeyword("end-line"), int(3797))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("read-line").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Reads the next line from stream that is the current value of *in* .", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3797), lang.NewKeyword("end-line"), int(3797))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - var v3 any - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("*in*")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v6, []any{nil, v9}) - if lang.IsTruthy(v10) { - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("*in*")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14, ok := lang.FieldOrMethod(v13, "readLine") + var tmp3 any + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("*in*")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp6, []any{nil, tmp9}) + if lang.IsTruthy(tmp10) { + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("*in*")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14, ok := lang.FieldOrMethod(tmp13, "readLine") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v13, "readLine"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp13, "readLine"))) } - var v15 any - switch reflect.TypeOf(v14).Kind() { + var tmp15 any + switch reflect.TypeOf(tmp14).Kind() { case reflect.Func: - v15 = lang.Apply(v14, nil) + tmp15 = lang.Apply(tmp14, nil) default: - v15 = v14 + tmp15 = tmp14 } - v3 = v15 + tmp3 = tmp15 } else { - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("*in*")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("*in*")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) } - v18 := v17.Get() - v19, ok := lang.FieldOrMethod(v18, "readLine") + tmp18 := tmp17.Get() + tmp19, ok := lang.FieldOrMethod(tmp18, "readLine") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v18, "readLine"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp18, "readLine"))) } - var v20 any - switch reflect.TypeOf(v19).Kind() { + var tmp20 any + switch reflect.TypeOf(tmp19).Kind() { case reflect.Func: - v20 = lang.Apply(v19, nil) + tmp20 = lang.Apply(tmp19, nil) default: - v20 = v19 + tmp20 = tmp19 } - v3 = v20 + tmp3 = tmp20 } - return v3 + return tmp3 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // read-string { - v0 := lang.NewSymbol("read-string").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s")), lang.NewVector(lang.NewSymbol("opts"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Reads one object from the string s. Optionally include reader\n options, as specified in read.\n\n Note that read-string can execute code (controlled by *read-eval*),\n and as such should be used only with trusted sources.\n\n For data structure interop use glojure.edn/read-string", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3806), lang.NewKeyword("end-line"), int(3806))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("read-string").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s")), lang.NewVector(lang.NewSymbol("opts"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Reads one object from the string s. Optionally include reader\n options, as specified in read.\n\n Note that read-string can execute code (controlled by *read-eval*),\n and as such should be used only with trusted sources.\n\n For data structure interop use glojure.edn/read-string", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3806), lang.NewKeyword("end-line"), int(3806))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - v4 := lang.Apply(runtime4.RTReadString, []any{v3}) - return v4 + tmp4 := lang.Apply(runtime4.RTReadString, []any{v3}) + return tmp4 case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - v5 := lang.Apply(runtime4.RTReadString, []any{v4, v3}) - return v5 + tmp5 := lang.Apply(runtime4.RTReadString, []any{v4, v3}) + return tmp5 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // reader-conditional { - v0 := lang.NewSymbol("reader-conditional").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("form"), lang.NewSymbol("splicing?"))), lang.NewKeyword("doc"), "Construct a data representation of a reader conditional.\n If true, splicing? indicates read-cond-splicing.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7782), lang.NewKeyword("end-line"), int(7782))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("reader-conditional").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("form"), lang.NewSymbol("splicing?"))), lang.NewKeyword("doc"), "Construct a data representation of a reader conditional.\n If true, splicing? indicates read-cond-splicing.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7782), lang.NewKeyword("end-line"), int(7782))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -68244,106 +68370,107 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.Apply(nil, []any{v3, v4}) - return v5 + tmp5 := lang.Apply(nil, []any{v3, v4}) + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // reader-conditional? { - v0 := lang.NewSymbol("reader-conditional?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("value"))), lang.NewKeyword("doc"), "Return true if the value is the data representation of a reader conditional", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7776), lang.NewKeyword("end-line"), int(7776))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("reader-conditional?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("value"))), lang.NewKeyword("doc"), "Return true if the value is the data representation of a reader conditional", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7776), lang.NewKeyword("end-line"), int(7776))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) } - v6 := v5.Get() - v7 := lang.Apply(v6, []any{nil, v3}) - return v7 + tmp6 := tmp5.Get() + tmp7 := lang.Apply(tmp6, []any{nil, v3}) + return tmp7 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // realized? { - v0 := lang.NewSymbol("realized?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if a value has been produced for a promise, delay, future or lazy sequence.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7559), lang.NewKeyword("end-line"), int(7559))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("realized?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if a value has been produced for a promise, delay, future or lazy sequence.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7559), lang.NewKeyword("end-line"), int(7559))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4, ok := lang.FieldOrMethod(v3, "isRealized") + tmp4, ok := lang.FieldOrMethod(v3, "isRealized") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "isRealized"))) } - var v5 any - switch reflect.TypeOf(v4).Kind() { + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { case reflect.Func: - v5 = lang.Apply(v4, nil) + tmp5 = lang.Apply(tmp4, nil) default: - v5 = v4 + tmp5 = tmp4 } - return v5 + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // reduce { - v0 := lang.NewSymbol("reduce").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("val"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "f should be a function of 2 arguments. If val is not supplied,\n returns the result of applying f to the first 2 items in coll, then\n applying f to that result and the 3rd item, etc. If coll contains no\n items, f must accept no arguments as well, and reduce returns the\n result of calling f with no arguments. If coll has only 1 item, it\n is returned and f is not called. If val is supplied, returns the\n result of applying f to val and the first item in coll, then\n applying f to that result and the 2nd item, etc. If coll contains no\n items, returns val and f is not called.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6860), lang.NewKeyword("end-line"), int(6860))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("reduce").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("val"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "f should be a function of 2 arguments. If val is not supplied,\n returns the result of applying f to the first 2 items in coll, then\n applying f to that result and the 3rd item, etc. If coll contains no\n items, f must accept no arguments as well, and reduce returns the\n result of calling f with no arguments. If coll has only 1 item, it\n is returned and f is not called. If val is supplied, returns the\n result of applying f to val and the first item in coll, then\n applying f to that result and the 2nd item, etc. If coll contains no\n items, returns val and f is not called.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6860), lang.NewKeyword("end-line"), int(6860))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - var v5 any - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{lang.IReduce, v4}) - if lang.IsTruthy(v9) { - v10, _ := lang.FieldOrMethod(v4, "Reduce") - if reflect.TypeOf(v10).Kind() != reflect.Func { + var tmp5 any + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("instance?")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := reflect.TypeOf((*lang.IReduce)(nil)).Elem() + tmp10 := lang.Apply(tmp8, []any{tmp9, v4}) + if lang.IsTruthy(tmp10) { + tmp11, _ := lang.FieldOrMethod(v4, "Reduce") + if reflect.TypeOf(tmp11).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Reduce is not a function"))) } - v11 := lang.Apply(v10, []any{v3}) - v5 = v11 + tmp12 := lang.Apply(tmp11, []any{v3}) + tmp5 = tmp12 } else { - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core.protocols")) - v13 := v12.FindInternedVar(lang.NewSymbol("coll-reduce")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core.protocols")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("coll-reduce")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) } - v14 := v13.Get() - v15 := lang.Apply(v14, []any{v4, v3}) - v5 = v15 + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{v4, v3}) + tmp5 = tmp16 } - return v5 + return tmp5 case 3: v3 := args[0] _ = v3 @@ -68351,47 +68478,48 @@ func init() { _ = v4 v5 := args[2] _ = v5 - var v6 any - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("instance?")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v9, []any{lang.IReduceInit, v5}) - if lang.IsTruthy(v10) { - v11, _ := lang.FieldOrMethod(v5, "ReduceInit") - if reflect.TypeOf(v11).Kind() != reflect.Func { + var tmp6 any + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("instance?")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := reflect.TypeOf((*lang.IReduceInit)(nil)).Elem() + tmp11 := lang.Apply(tmp9, []any{tmp10, v5}) + if lang.IsTruthy(tmp11) { + tmp12, _ := lang.FieldOrMethod(v5, "ReduceInit") + if reflect.TypeOf(tmp12).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) } - v12 := lang.Apply(v11, []any{v3, v4}) - v6 = v12 + tmp13 := lang.Apply(tmp12, []any{v3, v4}) + tmp6 = tmp13 } else { - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core.protocols")) - v14 := v13.FindInternedVar(lang.NewSymbol("coll-reduce")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core.protocols")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("coll-reduce")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{v5, v3, v4}) - v6 = v16 + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{v5, v3, v4}) + tmp6 = tmp17 } - return v6 + return tmp6 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // reduce-kv { - v0 := lang.NewSymbol("reduce-kv").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Reduces an associative collection. f should be a function of 3\n arguments. Returns the result of applying f to init, the first key\n and the first value in coll, then applying f to that result and the\n 2nd key and value, etc. If coll contains no entries, returns init\n and f is not called. Note that reduce-kv is supported on vectors,\n where the keys will be the ordinals.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6882), lang.NewKeyword("end-line"), int(6882))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("reduce-kv").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Reduces an associative collection. f should be a function of 3\n arguments. Returns the result of applying f to init, the first key\n and the first value in coll, then applying f to that result and the\n 2nd key and value, etc. If coll contains no entries, returns init\n and f is not called. Note that reduce-kv is supported on vectors,\n where the keys will be the ordinals.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6882), lang.NewKeyword("end-line"), int(6882))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -68401,75 +68529,75 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core.protocols")) - v7 := v6.FindInternedVar(lang.NewSymbol("kv-reduce")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core.protocols")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("kv-reduce")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{v5, v3, v4}) - return v9 + tmp8 := tmp7.Get() + tmp9 := lang.Apply(tmp8, []any{v5, v3, v4}) + return tmp9 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // reduce1 { - v0 := lang.NewSymbol("reduce1").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(923), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(924), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("val"), lang.NewSymbol("coll"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("reduce1").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(923), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(924), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("val"), lang.NewSymbol("coll"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - var v5 any + var tmp5 any { // let // let binding "s" - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("seq")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{v4}) - var v10 any = v9 + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("seq")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.Apply(tmp8, []any{v4}) + var v10 any = tmp9 _ = v10 - var v11 any + var tmp11 any if lang.IsTruthy(v10) { - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("reduce1")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("first")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{v10}) - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("next")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{v10}) - v23 := lang.Apply(v14, []any{v3, v18, v22}) - v11 = v23 + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("first")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{v10}) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("next")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, []any{v10}) + tmp23 := lang.Apply(tmp14, []any{v3, tmp18, tmp22}) + tmp11 = tmp23 } else { - v24 := lang.Apply(v3, nil) - v11 = v24 + tmp24 := lang.Apply(v3, nil) + tmp11 = tmp24 } - v5 = v11 + tmp5 = tmp11 } // end let - return v5 + return tmp5 case 3: v3 := args[0] _ = v3 @@ -68478,251 +68606,252 @@ func init() { v5 := args[2] _ = v5 recur_loop_156: - var v6 any + var tmp6 any { // let // let binding "s" - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("seq")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v9, []any{v5}) - var v11 any = v10 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("seq")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp9, []any{v5}) + var v11 any = tmp10 _ = v11 - var v12 any + var tmp12 any if lang.IsTruthy(v11) { - var v13 any - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("chunked-seq?")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{v11}) - if lang.IsTruthy(v17) { - var v18 any = v3 - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("chunk-first")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.Apply(v22, []any{v11}) - v24, _ := lang.FieldOrMethod(v23, "ReduceInit") - if reflect.TypeOf(v24).Kind() != reflect.Func { + var tmp13 any + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("chunked-seq?")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{v11}) + if lang.IsTruthy(tmp17) { + var tmp18 any = v3 + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("chunk-first")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.Apply(tmp22, []any{v11}) + tmp24, _ := lang.FieldOrMethod(tmp23, "ReduceInit") + if reflect.TypeOf(tmp24).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) } - v25 := lang.Apply(v24, []any{v3, v4}) - var v19 any = v25 - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("chunk-next")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{v11}) - var v26 any = v30 - v3 = v18 - v4 = v19 - v5 = v26 + tmp25 := lang.Apply(tmp24, []any{v3, v4}) + var tmp19 any = tmp25 + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("chunk-next")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{v11}) + var tmp26 any = tmp30 + v3 = tmp18 + v4 = tmp19 + v5 = tmp26 goto recur_loop_156 } else { - var v31 any = v3 - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("first")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - v36 := lang.Apply(v35, []any{v11}) - v37 := lang.Apply(v3, []any{v4, v36}) - var v32 any = v37 - v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v40 := v39.FindInternedVar(lang.NewSymbol("next")) - if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) - } - v41 := v40.Get() - v42 := lang.Apply(v41, []any{v11}) - var v38 any = v42 - v3 = v31 - v4 = v32 - v5 = v38 + var tmp31 any = v3 + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("first")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) + } + tmp35 := tmp34.Get() + tmp36 := lang.Apply(tmp35, []any{v11}) + tmp37 := lang.Apply(v3, []any{v4, tmp36}) + var tmp32 any = tmp37 + tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp40 := tmp39.FindInternedVar(lang.NewSymbol("next")) + if tmp40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) + } + tmp41 := tmp40.Get() + tmp42 := lang.Apply(tmp41, []any{v11}) + var tmp38 any = tmp42 + v3 = tmp31 + v4 = tmp32 + v5 = tmp38 goto recur_loop_156 } - v12 = v13 + tmp12 = tmp13 } else { - v12 = v4 + tmp12 = v4 } - v6 = v12 + tmp6 = tmp12 } // end let - return v6 + return tmp6 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // reduced { - v0 := lang.NewSymbol("reduced").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Wraps x in a way such that a reduce will terminate with the value x", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2828), lang.NewKeyword("end-line"), int(2828))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("reduced").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Wraps x in a way such that a reduce will terminate with the value x", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2828), lang.NewKeyword("end-line"), int(2828))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.Apply(lang.NewReduced, []any{v3}) - return v4 + tmp4 := lang.Apply(lang.NewReduced, []any{v3}) + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // reduced? { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function reduced?__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("concat")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("list")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.IsReduced")}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{v3}) - v18 := lang.Apply(v9, []any{v13, v17}) - v19 := lang.Apply(v6, []any{v18}) - return v19 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.IsReduced")}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := lang.Apply(tmp9, []any{tmp13, tmp17}) + tmp19 := lang.Apply(tmp6, []any{tmp18}) + return tmp19 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("reduced?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns true if x is the result of a call to reduced", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1)), lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2834), lang.NewKeyword("end-line"), int(2834))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("reduced?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns true if x is the result of a call to reduced", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1)})), lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2834), lang.NewKeyword("end-line"), int(2834))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5 := lang.Apply(lang.IsReduced, []any{v4}) - return v5 + tmp5 := lang.Apply(lang.IsReduced, []any{v4}) + return tmp5 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // reductions { - v0 := lang.NewSymbol("reductions").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy seq of the intermediate values of the reduction (as\n per reduce) of coll by f, starting with init.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7196), lang.NewKeyword("end-line"), int(7196))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("reductions").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy seq of the intermediate values of the reduction (as\n per reduce) of coll by f, starting with init.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7196), lang.NewKeyword("end-line"), int(7196))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - var v5 lang.FnFunc - v5 = lang.NewFnFunc(func(args ...any) any { + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - var v6 any + var tmp6 any { // let // let binding "temp__0__auto__" - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("seq")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v9, []any{v4}) - var v11 any = v10 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("seq")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp9, []any{v4}) + var v11 any = tmp10 _ = v11 - var v12 any + var tmp12 any if lang.IsTruthy(v11) { - var v13 any + var tmp13 any { // let // let binding "s" var v14 any = v11 _ = v14 - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("reductions")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("reductions")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) } - v17 := v16.Get() - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("first")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + tmp17 := tmp16.Get() + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("first")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) } - v20 := v19.Get() - v21 := lang.Apply(v20, []any{v14}) - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("rest")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + tmp20 := tmp19.Get() + tmp21 := lang.Apply(tmp20, []any{v14}) + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("rest")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v14}) - v26 := lang.Apply(v17, []any{v3, v21, v25}) - v13 = v26 + tmp24 := tmp23.Get() + tmp25 := lang.Apply(tmp24, []any{v14}) + tmp26 := lang.Apply(tmp17, []any{v3, tmp21, tmp25}) + tmp13 = tmp26 } // end let - v12 = v13 + tmp12 = tmp13 } else { - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) } - v16 := v15.Get() - v17 := lang.Apply(v3, nil) - v18 := lang.Apply(v16, []any{v17}) - v12 = v18 + tmp16 := tmp15.Get() + tmp17 := lang.Apply(v3, nil) + tmp18 := lang.Apply(tmp16, []any{tmp17}) + tmp12 = tmp18 } - v6 = v12 + tmp6 = tmp12 } // end let - return v6 + return tmp6 }) - v6 := lang.Apply(lang.NewLazySeq, []any{v5}) - return v6 + tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) + return tmp6 case 3: v3 := args[0] _ = v3 @@ -68730,318 +68859,316 @@ func init() { _ = v4 v5 := args[2] _ = v5 - var v6 any - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("reduced?")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v9, []any{v4}) - if lang.IsTruthy(v10) { - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("list")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("deref")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{v4}) - v18 := lang.Apply(v13, []any{v17}) - v6 = v18 + var tmp6 any + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("reduced?")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp9, []any{v4}) + if lang.IsTruthy(tmp10) { + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("list")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("deref")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{v4}) + tmp18 := lang.Apply(tmp13, []any{tmp17}) + tmp6 = tmp18 } else { - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("cons")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - var v22 lang.FnFunc - v22 = lang.NewFnFunc(func(args ...any) any { + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("cons")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + var tmp22 lang.FnFunc + tmp22 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - var v23 any + var tmp23 any { // let // let binding "temp__0__auto__" - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("seq")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.Apply(v26, []any{v5}) - var v28 any = v27 + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("seq")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.Apply(tmp26, []any{v5}) + var v28 any = tmp27 _ = v28 - var v29 any + var tmp29 any if lang.IsTruthy(v28) { - var v30 any + var tmp30 any { // let // let binding "s" var v31 any = v28 _ = v31 - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("reductions")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("reductions")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) } - v34 := v33.Get() - v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v36 := v35.FindInternedVar(lang.NewSymbol("first")) - if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + tmp34 := tmp33.Get() + tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp36 := tmp35.FindInternedVar(lang.NewSymbol("first")) + if tmp36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) } - v37 := v36.Get() - v38 := lang.Apply(v37, []any{v31}) - v39 := lang.Apply(v3, []any{v4, v38}) - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("rest")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + tmp37 := tmp36.Get() + tmp38 := lang.Apply(tmp37, []any{v31}) + tmp39 := lang.Apply(v3, []any{v4, tmp38}) + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("rest")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) } - v42 := v41.Get() - v43 := lang.Apply(v42, []any{v31}) - v44 := lang.Apply(v34, []any{v3, v39, v43}) - v30 = v44 + tmp42 := tmp41.Get() + tmp43 := lang.Apply(tmp42, []any{v31}) + tmp44 := lang.Apply(tmp34, []any{v3, tmp39, tmp43}) + tmp30 = tmp44 } // end let - v29 = v30 + tmp29 = tmp30 } else { - v29 = nil } - v23 = v29 + tmp23 = tmp29 } // end let - return v23 + return tmp23 }) - v23 := lang.Apply(lang.NewLazySeq, []any{v22}) - v24 := lang.Apply(v21, []any{v4, v23}) - v6 = v24 + tmp23 := lang.Apply(lang.NewLazySeq, []any{tmp22}) + tmp24 := lang.Apply(tmp21, []any{v4, tmp23}) + tmp6 = tmp24 } - return v6 + return tmp6 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // ref { - v0 := lang.NewSymbol("ref").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Creates and returns a Ref with an initial value of x and zero or\n more options (in any order):\n\n :meta metadata-map\n\n :validator validate-fn\n\n :min-history (default 0)\n :max-history (default 10)\n\n If metadata-map is supplied, it will become the metadata on the\n ref. validate-fn must be nil or a side-effect-free fn of one\n argument, which will be passed the intended new state on any state\n change. If the new state is unacceptable, the validate-fn should\n return false or throw an exception. validate-fn will be called on\n transaction commit, when all refs have their final values.\n\n Normally refs accumulate history dynamically as needed to deal with\n read demands. If you know in advance you will need history you can\n set :min-history to ensure it will be available when first needed (instead\n of after a read fault). History is limited, and the limit can be set\n with :max-history.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2260), lang.NewKeyword("end-line"), int(2260))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("ref").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Creates and returns a Ref with an initial value of x and zero or\n more options (in any order):\n\n :meta metadata-map\n\n :validator validate-fn\n\n :min-history (default 0)\n :max-history (default 10)\n\n If metadata-map is supplied, it will become the metadata on the\n ref. validate-fn must be nil or a side-effect-free fn of one\n argument, which will be passed the intended new state on any state\n change. If the new state is unacceptable, the validate-fn should\n return false or throw an exception. validate-fn will be called on\n transaction commit, when all refs have their final values.\n\n Normally refs accumulate history dynamically as needed to deal with\n read demands. If you know in advance you will need history you can\n set :min-history to ensure it will be available when first needed (instead\n of after a read fault). History is limited, and the limit can be set\n with :max-history.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2260), lang.NewKeyword("end-line"), int(2260))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - v4 := lang.Apply(lang.NewRef, []any{v3}) - return v4 + tmp4 := lang.Apply(lang.NewRef, []any{v3}) + return tmp4 default: if len(args) < 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.NewList(args[1:]...) - var v5 any + var v4 any = lang.NewList(args[1:]...) + _ = v4 + var tmp5 any { // let // let binding "r" - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("setup-reference")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("ref")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.Apply(v11, []any{v3}) - v13 := lang.Apply(v8, []any{v12, v4}) - var v14 any = v13 + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("setup-reference")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("ref")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.Apply(tmp11, []any{v3}) + tmp13 := lang.Apply(tmp8, []any{tmp12, v4}) + var v14 any = tmp13 _ = v14 // let binding "opts" - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("apply")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("hash-map")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.Apply(v17, []any{v20, v4}) - var v22 any = v21 + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("apply")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("hash-map")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.Apply(tmp17, []any{tmp20, v4}) + var v22 any = tmp21 _ = v22 - var v23 any - v24 := lang.Apply(lang.NewKeyword("max-history"), []any{v22}) - if lang.IsTruthy(v24) { - v25 := lang.Apply(lang.NewKeyword("max-history"), []any{v22}) - v26, _ := lang.FieldOrMethod(v14, "setMaxHistory") - if reflect.TypeOf(v26).Kind() != reflect.Func { + var tmp23 any + tmp24 := lang.Apply(lang.NewKeyword("max-history"), []any{v22}) + if lang.IsTruthy(tmp24) { + tmp25 := lang.Apply(lang.NewKeyword("max-history"), []any{v22}) + tmp26, _ := lang.FieldOrMethod(v14, "setMaxHistory") + if reflect.TypeOf(tmp26).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMaxHistory is not a function"))) } - v27 := lang.Apply(v26, []any{v25}) - v23 = v27 + tmp27 := lang.Apply(tmp26, []any{tmp25}) + tmp23 = tmp27 } else { - v23 = nil } - _ = v23 - var v28 any - v29 := lang.Apply(lang.NewKeyword("min-history"), []any{v22}) - if lang.IsTruthy(v29) { - v30 := lang.Apply(lang.NewKeyword("min-history"), []any{v22}) - v31, _ := lang.FieldOrMethod(v14, "setMinHistory") - if reflect.TypeOf(v31).Kind() != reflect.Func { + _ = tmp23 + var tmp28 any + tmp29 := lang.Apply(lang.NewKeyword("min-history"), []any{v22}) + if lang.IsTruthy(tmp29) { + tmp30 := lang.Apply(lang.NewKeyword("min-history"), []any{v22}) + tmp31, _ := lang.FieldOrMethod(v14, "setMinHistory") + if reflect.TypeOf(tmp31).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMinHistory is not a function"))) } - v32 := lang.Apply(v31, []any{v30}) - v28 = v32 + tmp32 := lang.Apply(tmp31, []any{tmp30}) + tmp28 = tmp32 } else { - v28 = nil } - _ = v28 - v5 = v14 + _ = tmp28 + tmp5 = v14 } // end let - return v5 + return tmp5 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // ref-history-count { - v0 := lang.NewSymbol("ref-history-count").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref"))), lang.NewKeyword("doc"), "Returns the history count of a ref", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2455), lang.NewKeyword("end-line"), int(2455))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("ref-history-count").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref"))), lang.NewKeyword("doc"), "Returns the history count of a ref", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2455), lang.NewKeyword("end-line"), int(2455))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4, ok := lang.FieldOrMethod(v3, "getHistoryCount") + tmp4, ok := lang.FieldOrMethod(v3, "getHistoryCount") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getHistoryCount"))) } - var v5 any - switch reflect.TypeOf(v4).Kind() { + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { case reflect.Func: - v5 = lang.Apply(v4, nil) + tmp5 = lang.Apply(tmp4, nil) default: - v5 = v4 + tmp5 = tmp4 } - return v5 + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // ref-max-history { - v0 := lang.NewSymbol("ref-max-history").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref")), lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Gets the max-history of a ref, or sets it and returns the ref", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2471), lang.NewKeyword("end-line"), int(2471))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("ref-max-history").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref")), lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Gets the max-history of a ref, or sets it and returns the ref", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2471), lang.NewKeyword("end-line"), int(2471))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - v4, ok := lang.FieldOrMethod(v3, "getMaxHistory") + tmp4, ok := lang.FieldOrMethod(v3, "getMaxHistory") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getMaxHistory"))) } - var v5 any - switch reflect.TypeOf(v4).Kind() { + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { case reflect.Func: - v5 = lang.Apply(v4, nil) + tmp5 = lang.Apply(tmp4, nil) default: - v5 = v4 + tmp5 = tmp4 } - return v5 + return tmp5 case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - v5, _ := lang.FieldOrMethod(v3, "setMaxHistory") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(v3, "setMaxHistory") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMaxHistory is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // ref-min-history { - v0 := lang.NewSymbol("ref-min-history").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref")), lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Gets the min-history of a ref, or sets it and returns the ref", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2462), lang.NewKeyword("end-line"), int(2462))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("ref-min-history").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref")), lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Gets the min-history of a ref, or sets it and returns the ref", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2462), lang.NewKeyword("end-line"), int(2462))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - v4, ok := lang.FieldOrMethod(v3, "getMinHistory") + tmp4, ok := lang.FieldOrMethod(v3, "getMinHistory") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getMinHistory"))) } - var v5 any - switch reflect.TypeOf(v4).Kind() { + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { case reflect.Func: - v5 = lang.Apply(v4, nil) + tmp5 = lang.Apply(tmp4, nil) default: - v5 = v4 + tmp5 = tmp4 } - return v5 + return tmp5 case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - v5, _ := lang.FieldOrMethod(v3, "setMinHistory") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(v3, "setMinHistory") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMinHistory is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // ref-set { - v0 := lang.NewSymbol("ref-set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Must be called in a transaction. Sets the value of ref.\n Returns val.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2447), lang.NewKeyword("end-line"), int(2447))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("ref-set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Must be called in a transaction. Sets the value of ref.\n Returns val.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2447), lang.NewKeyword("end-line"), int(2447))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -69049,24 +69176,24 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5, _ := lang.FieldOrMethod(v3, "set") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(v3, "set") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("set is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // refer { - v0 := lang.NewSymbol("refer").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns-sym"), lang.NewSymbol("&"), lang.NewSymbol("filters"))), lang.NewKeyword("doc"), "refers to all public vars of ns, subject to filters.\n filters can include at most one each of:\n\n :exclude list-of-symbols\n :only list-of-symbols\n :rename map-of-fromsymbol-tosymbol\n\n For each public interned var in the namespace named by the symbol,\n adds a mapping from the name of the var to the var to the current\n namespace. Throws an exception if name is already mapped to\n something else in the current namespace. Filters can be used to\n select a subset, via inclusion or exclusion, or to provide a mapping\n to a symbol different from the var's name, in order to prevent\n clashes. Use :use in the ns macro in preference to calling this directly.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4216), lang.NewKeyword("end-line"), int(4216))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("refer").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns-sym"), lang.NewSymbol("&"), lang.NewSymbol("filters"))), lang.NewKeyword("doc"), "refers to all public vars of ns, subject to filters.\n filters can include at most one each of:\n\n :exclude list-of-symbols\n :only list-of-symbols\n :rename map-of-fromsymbol-tosymbol\n\n For each public interned var in the namespace named by the symbol,\n adds a mapping from the name of the var to the var to the current\n namespace. Throws an exception if name is already mapped to\n something else in the current namespace. Filters can be used to\n select a subset, via inclusion or exclusion, or to provide a mapping\n to a symbol different from the var's name, in order to prevent\n clashes. Use :use in the ns macro in preference to calling this directly.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4216), lang.NewKeyword("end-line"), int(4216))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 1 { @@ -69074,205 +69201,206 @@ func init() { } v3 := args[0] _ = v3 - v4 := lang.NewList(args[1:]...) - var v5 any + var v4 any = lang.NewList(args[1:]...) + _ = v4 + var tmp5 any { // let // let binding "ns" - var v6 any + var tmp6 any { // let // let binding "or__0__auto__" - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("find-ns")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v9, []any{v3}) - var v11 any = v10 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("find-ns")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp9, []any{v3}) + var v11 any = tmp10 _ = v11 - var v12 any + var tmp12 any if lang.IsTruthy(v11) { - v12 = v11 + tmp12 = v11 } else { - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("str")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("str")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{"No namespace: ", v3}) - v17 := lang.Apply(errors5.New, []any{v16}) - panic(v17) + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{"No namespace: ", v3}) + tmp17 := lang.Apply(errors5.New, []any{tmp16}) + panic(tmp17) } - v6 = v12 + tmp6 = tmp12 } // end let - var v7 any = v6 + var v7 any = tmp6 _ = v7 // let binding "fs" - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("apply")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("hash-map")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v10, []any{v13, v4}) - var v15 any = v14 + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("apply")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("hash-map")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp10, []any{tmp13, v4}) + var v15 any = tmp14 _ = v15 // let binding "nspublics" - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("ns-publics")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{v7}) - var v20 any = v19 + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("ns-publics")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{v7}) + var v20 any = tmp19 _ = v20 // let binding "rename" - var v21 any + var tmp21 any { // let // let binding "or__0__auto__" - v22 := lang.Apply(lang.NewKeyword("rename"), []any{v15}) - var v23 any = v22 + tmp22 := lang.Apply(lang.NewKeyword("rename"), []any{v15}) + var v23 any = tmp22 _ = v23 - var v24 any + var tmp24 any if lang.IsTruthy(v23) { - v24 = v23 + tmp24 = v23 } else { - v25 := lang.NewMap() - v26 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4236), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(4236), lang.NewKeyword("end-column"), int(36)) - v27, err := lang.WithMeta(v25, v26.(lang.IPersistentMap)) + tmp25 := lang.NewMap() + tmp26 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4236), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(4236), lang.NewKeyword("end-column"), int(36)) + tmp27, err := lang.WithMeta(tmp25, tmp26.(lang.IPersistentMap)) if err != nil { panic(err) } - v24 = v27 + tmp24 = tmp27 } - v21 = v24 + tmp21 = tmp24 } // end let - var v22 any = v21 + var v22 any = tmp21 _ = v22 // let binding "exclude" - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("set")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.Apply(lang.NewKeyword("exclude"), []any{v15}) - v27 := lang.Apply(v25, []any{v26}) - var v28 any = v27 + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("set")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.Apply(lang.NewKeyword("exclude"), []any{v15}) + tmp27 := lang.Apply(tmp25, []any{tmp26}) + var v28 any = tmp27 _ = v28 // let binding "to-do" - var v29 any - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("=")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) - } - v32 := v31.Get() - v33 := lang.Apply(lang.NewKeyword("refer"), []any{v15}) - v34 := lang.Apply(v32, []any{lang.NewKeyword("all"), v33}) - if lang.IsTruthy(v34) { - v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v36 := v35.FindInternedVar(lang.NewSymbol("keys")) - if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) - } - v37 := v36.Get() - v38 := lang.Apply(v37, []any{v20}) - v29 = v38 + var tmp29 any + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("=")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) + } + tmp32 := tmp31.Get() + tmp33 := lang.Apply(lang.NewKeyword("refer"), []any{v15}) + tmp34 := lang.Apply(tmp32, []any{lang.NewKeyword("all"), tmp33}) + if lang.IsTruthy(tmp34) { + tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp36 := tmp35.FindInternedVar(lang.NewSymbol("keys")) + if tmp36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) + } + tmp37 := tmp36.Get() + tmp38 := lang.Apply(tmp37, []any{v20}) + tmp29 = tmp38 } else { - var v39 any + var tmp39 any { // let // let binding "or__0__auto__" - v40 := lang.Apply(lang.NewKeyword("refer"), []any{v15}) - var v41 any = v40 + tmp40 := lang.Apply(lang.NewKeyword("refer"), []any{v15}) + var v41 any = tmp40 _ = v41 - var v42 any + var tmp42 any if lang.IsTruthy(v41) { - v42 = v41 + tmp42 = v41 } else { - var v43 any + var tmp43 any { // let // let binding "or__0__auto__" - v44 := lang.Apply(lang.NewKeyword("only"), []any{v15}) - var v45 any = v44 + tmp44 := lang.Apply(lang.NewKeyword("only"), []any{v15}) + var v45 any = tmp44 _ = v45 - var v46 any + var tmp46 any if lang.IsTruthy(v45) { - v46 = v45 + tmp46 = v45 } else { - v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v48 := v47.FindInternedVar(lang.NewSymbol("keys")) - if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) + tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp48 := tmp47.FindInternedVar(lang.NewSymbol("keys")) + if tmp48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) } - v49 := v48.Get() - v50 := lang.Apply(v49, []any{v20}) - v46 = v50 + tmp49 := tmp48.Get() + tmp50 := lang.Apply(tmp49, []any{v20}) + tmp46 = tmp50 } - v43 = v46 + tmp43 = tmp46 } // end let - v42 = v43 + tmp42 = tmp43 } - v39 = v42 + tmp39 = tmp42 } // end let - v29 = v39 + tmp29 = tmp39 } - var v40 any = v29 + var v40 any = tmp29 _ = v40 - var v41 any - var v42 any + var tmp41 any + var tmp42 any { // let // let binding "and__0__auto__" var v43 any = v40 _ = v43 - var v44 any + var tmp44 any if lang.IsTruthy(v43) { - v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v46 := v45.FindInternedVar(lang.NewSymbol("not")) - if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) - } - v47 := v46.Get() - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("instance?")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{lang.Sequential, v40}) - v52 := lang.Apply(v47, []any{v51}) - v44 = v52 + tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp46 := tmp45.FindInternedVar(lang.NewSymbol("not")) + if tmp46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) + } + tmp47 := tmp46.Get() + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("instance?")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := reflect.TypeOf((*lang.Sequential)(nil)).Elem() + tmp52 := lang.Apply(tmp50, []any{tmp51, v40}) + tmp53 := lang.Apply(tmp47, []any{tmp52}) + tmp44 = tmp53 } else { - v44 = v43 + tmp44 = v43 } - v42 = v44 + tmp42 = tmp44 } // end let - if lang.IsTruthy(v42) { - v43 := lang.Apply(errors5.New, []any{":only/:refer value must be a sequential collection of symbols"}) - panic(v43) + if lang.IsTruthy(tmp42) { + tmp43 := lang.Apply(errors5.New, []any{":only/:refer value must be a sequential collection of symbols"}) + panic(tmp43) } else { - v41 = nil } - _ = v41 - var v44 any + _ = tmp41 + var tmp44 any { // let // let binding "seq_9" - v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v46 := v45.FindInternedVar(lang.NewSymbol("seq")) - if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) - } - v47 := v46.Get() - v48 := lang.Apply(v47, []any{v40}) - var v49 any = v48 + tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp46 := tmp45.FindInternedVar(lang.NewSymbol("seq")) + if tmp46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) + } + tmp47 := tmp46.Get() + tmp48 := lang.Apply(tmp47, []any{v40}) + var v49 any = tmp48 _ = v49 // let binding "chunk_10" var v50 any = nil @@ -69284,281 +69412,276 @@ func init() { var v52 any = int64(0) _ = v52 for { - var v53 any - v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v55 := v54.FindInternedVar(lang.NewSymbol("<")) - if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) - } - v56 := v55.Get() - v57 := lang.Apply(v56, []any{v52, v51}) - if lang.IsTruthy(v57) { - var v58 any + var tmp53 any + tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp55 := tmp54.FindInternedVar(lang.NewSymbol("<")) + if tmp55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) + } + tmp56 := tmp55.Get() + tmp57 := lang.Apply(tmp56, []any{v52, v51}) + if lang.IsTruthy(tmp57) { + var tmp58 any { // let // let binding "sym" - v59, _ := lang.FieldOrMethod(v50, "nth") - if reflect.TypeOf(v59).Kind() != reflect.Func { + tmp59, _ := lang.FieldOrMethod(v50, "nth") + if reflect.TypeOf(tmp59).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) } - v60 := lang.Apply(v59, []any{v52}) - var v61 any = v60 + tmp60 := lang.Apply(tmp59, []any{v52}) + var v61 any = tmp60 _ = v61 - var v62 any - v63 := lang.Apply(v28, []any{v61}) - if lang.IsTruthy(v63) { - v62 = nil + var tmp62 any + tmp63 := lang.Apply(v28, []any{v61}) + if lang.IsTruthy(tmp63) { } else { - var v64 any + var tmp64 any { // let // let binding "v" - v65 := lang.Apply(v20, []any{v61}) - var v66 any = v65 + tmp65 := lang.Apply(v20, []any{v61}) + var v66 any = tmp65 _ = v66 - var v67 any + var tmp67 any if lang.IsTruthy(v66) { - v67 = nil } else { panic("unimplemented: new with non-constant class type") } - _ = v67 - v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v69 := v68.FindInternedVar(lang.NewSymbol("*ns*")) - if v69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) + _ = tmp67 + tmp68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp69 := tmp68.FindInternedVar(lang.NewSymbol("*ns*")) + if tmp69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp69))) } - v70 := v69.Get() - var v71 any + tmp70 := tmp69.Get() + var tmp71 any { // let // let binding "or__0__auto__" - v72 := lang.Apply(v22, []any{v61}) - var v73 any = v72 + tmp72 := lang.Apply(v22, []any{v61}) + var v73 any = tmp72 _ = v73 - var v74 any + var tmp74 any if lang.IsTruthy(v73) { - v74 = v73 + tmp74 = v73 } else { - v74 = v61 + tmp74 = v61 } - v71 = v74 + tmp71 = tmp74 } // end let - v72, _ := lang.FieldOrMethod(v70, "Refer") - if reflect.TypeOf(v72).Kind() != reflect.Func { + tmp72, _ := lang.FieldOrMethod(tmp70, "Refer") + if reflect.TypeOf(tmp72).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Refer is not a function"))) } - v73 := lang.Apply(v72, []any{v71, v66}) - v64 = v73 + tmp73 := lang.Apply(tmp72, []any{tmp71, v66}) + tmp64 = tmp73 } // end let - v62 = v64 + tmp62 = tmp64 } - _ = v62 - var v65 any = v49 - var v66 any = v50 - var v67 any = v51 - v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v70 := v69.FindInternedVar(lang.NewSymbol("unchecked-inc")) - if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) + _ = tmp62 + var tmp65 any = v49 + var tmp66 any = v50 + var tmp67 any = v51 + tmp69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp70 := tmp69.FindInternedVar(lang.NewSymbol("unchecked-inc")) + if tmp70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp70))) } - v71 := v70.Get() - v72 := lang.Apply(v71, []any{v52}) - var v68 any = v72 - v49 = v65 - v50 = v66 - v51 = v67 - v52 = v68 + tmp71 := tmp70.Get() + tmp72 := lang.Apply(tmp71, []any{v52}) + var tmp68 any = tmp72 + v49 = tmp65 + v50 = tmp66 + v51 = tmp67 + v52 = tmp68 continue } // end let - v53 = v58 + tmp53 = tmp58 } else { - var v59 any + var tmp59 any { // let // let binding "temp__0__auto__" - v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v61 := v60.FindInternedVar(lang.NewSymbol("seq")) - if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) + tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp61 := tmp60.FindInternedVar(lang.NewSymbol("seq")) + if tmp61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) } - v62 := v61.Get() - v63 := lang.Apply(v62, []any{v49}) - var v64 any = v63 + tmp62 := tmp61.Get() + tmp63 := lang.Apply(tmp62, []any{v49}) + var v64 any = tmp63 _ = v64 - var v65 any + var tmp65 any if lang.IsTruthy(v64) { - var v66 any + var tmp66 any { // let // let binding "seq_9" var v67 any = v64 _ = v67 - var v68 any - v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v70 := v69.FindInternedVar(lang.NewSymbol("chunked-seq?")) - if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) + var tmp68 any + tmp69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp70 := tmp69.FindInternedVar(lang.NewSymbol("chunked-seq?")) + if tmp70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp70))) } - v71 := v70.Get() - v72 := lang.Apply(v71, []any{v67}) - if lang.IsTruthy(v72) { - var v73 any + tmp71 := tmp70.Get() + tmp72 := lang.Apply(tmp71, []any{v67}) + if lang.IsTruthy(tmp72) { + var tmp73 any { // let // let binding "c__0__auto__" - v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v75 := v74.FindInternedVar(lang.NewSymbol("chunk-first")) - if v75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) + tmp74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp75 := tmp74.FindInternedVar(lang.NewSymbol("chunk-first")) + if tmp75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp75))) } - v76 := v75.Get() - v77 := lang.Apply(v76, []any{v67}) - var v78 any = v77 + tmp76 := tmp75.Get() + tmp77 := lang.Apply(tmp76, []any{v67}) + var v78 any = tmp77 _ = v78 - v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v81 := v80.FindInternedVar(lang.NewSymbol("chunk-rest")) - if v81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) + tmp80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp81 := tmp80.FindInternedVar(lang.NewSymbol("chunk-rest")) + if tmp81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp81))) } - v82 := v81.Get() - v83 := lang.Apply(v82, []any{v67}) - var v79 any = v83 - var v84 any = v78 - v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v87 := v86.FindInternedVar(lang.NewSymbol("int")) - if v87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) + tmp82 := tmp81.Get() + tmp83 := lang.Apply(tmp82, []any{v67}) + var tmp79 any = tmp83 + var tmp84 any = v78 + tmp86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp87 := tmp86.FindInternedVar(lang.NewSymbol("int")) + if tmp87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp87))) } - v88 := v87.Get() - v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v90 := v89.FindInternedVar(lang.NewSymbol("count")) - if v90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) + tmp88 := tmp87.Get() + tmp89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp90 := tmp89.FindInternedVar(lang.NewSymbol("count")) + if tmp90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp90))) } - v91 := v90.Get() - v92 := lang.Apply(v91, []any{v78}) - v93 := lang.Apply(v88, []any{v92}) - var v85 any = v93 - v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v96 := v95.FindInternedVar(lang.NewSymbol("int")) - if v96.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) + tmp91 := tmp90.Get() + tmp92 := lang.Apply(tmp91, []any{v78}) + tmp93 := lang.Apply(tmp88, []any{tmp92}) + var tmp85 any = tmp93 + tmp95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp96 := tmp95.FindInternedVar(lang.NewSymbol("int")) + if tmp96.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp96))) } - v97 := v96.Get() - v98 := lang.Apply(v97, []any{int64(0)}) - var v94 any = v98 - v49 = v79 - v50 = v84 - v51 = v85 - v52 = v94 + tmp97 := tmp96.Get() + tmp98 := lang.Apply(tmp97, []any{int64(0)}) + var tmp94 any = tmp98 + v49 = tmp79 + v50 = tmp84 + v51 = tmp85 + v52 = tmp94 continue } // end let - v68 = v73 + tmp68 = tmp73 } else { - var v74 any + var tmp74 any { // let // let binding "sym" - v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v76 := v75.FindInternedVar(lang.NewSymbol("first")) - if v76.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) + tmp75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp76 := tmp75.FindInternedVar(lang.NewSymbol("first")) + if tmp76.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp76))) } - v77 := v76.Get() - v78 := lang.Apply(v77, []any{v67}) - var v79 any = v78 + tmp77 := tmp76.Get() + tmp78 := lang.Apply(tmp77, []any{v67}) + var v79 any = tmp78 _ = v79 - var v80 any - v81 := lang.Apply(v28, []any{v79}) - if lang.IsTruthy(v81) { - v80 = nil + var tmp80 any + tmp81 := lang.Apply(v28, []any{v79}) + if lang.IsTruthy(tmp81) { } else { - var v82 any + var tmp82 any { // let // let binding "v" - v83 := lang.Apply(v20, []any{v79}) - var v84 any = v83 + tmp83 := lang.Apply(v20, []any{v79}) + var v84 any = tmp83 _ = v84 - var v85 any + var tmp85 any if lang.IsTruthy(v84) { - v85 = nil } else { panic("unimplemented: new with non-constant class type") } - _ = v85 - v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v87 := v86.FindInternedVar(lang.NewSymbol("*ns*")) - if v87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) + _ = tmp85 + tmp86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp87 := tmp86.FindInternedVar(lang.NewSymbol("*ns*")) + if tmp87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp87))) } - v88 := v87.Get() - var v89 any + tmp88 := tmp87.Get() + var tmp89 any { // let // let binding "or__0__auto__" - v90 := lang.Apply(v22, []any{v79}) - var v91 any = v90 + tmp90 := lang.Apply(v22, []any{v79}) + var v91 any = tmp90 _ = v91 - var v92 any + var tmp92 any if lang.IsTruthy(v91) { - v92 = v91 + tmp92 = v91 } else { - v92 = v79 + tmp92 = v79 } - v89 = v92 + tmp89 = tmp92 } // end let - v90, _ := lang.FieldOrMethod(v88, "Refer") - if reflect.TypeOf(v90).Kind() != reflect.Func { + tmp90, _ := lang.FieldOrMethod(tmp88, "Refer") + if reflect.TypeOf(tmp90).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Refer is not a function"))) } - v91 := lang.Apply(v90, []any{v89, v84}) - v82 = v91 + tmp91 := lang.Apply(tmp90, []any{tmp89, v84}) + tmp82 = tmp91 } // end let - v80 = v82 + tmp80 = tmp82 } - _ = v80 - v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v85 := v84.FindInternedVar(lang.NewSymbol("next")) - if v85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) + _ = tmp80 + tmp84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp85 := tmp84.FindInternedVar(lang.NewSymbol("next")) + if tmp85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp85))) } - v86 := v85.Get() - v87 := lang.Apply(v86, []any{v67}) - var v83 any = v87 - var v88 any = nil - var v89 any = int64(0) - var v90 any = int64(0) - v49 = v83 - v50 = v88 - v51 = v89 - v52 = v90 + tmp86 := tmp85.Get() + tmp87 := lang.Apply(tmp86, []any{v67}) + var tmp83 any = tmp87 + var tmp88 any = nil + var tmp89 any = int64(0) + var tmp90 any = int64(0) + v49 = tmp83 + v50 = tmp88 + v51 = tmp89 + v52 = tmp90 continue } // end let - v68 = v74 + tmp68 = tmp74 } - v66 = v68 + tmp66 = tmp68 } // end let - v65 = v66 + tmp65 = tmp66 } else { - v65 = nil } - v59 = v65 + tmp59 = tmp65 } // end let - v53 = v59 + tmp53 = tmp59 } - v44 = v53 + tmp44 = tmp53 break } } // end let - v5 = v44 + tmp5 = tmp44 } // end let - return v5 + return tmp5 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // refer-glojure { - v0 := lang.NewSymbol("refer-glojure").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("filters"))), lang.NewKeyword("doc"), "Same as (refer 'glojure.core )", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5800), lang.NewKeyword("end-line"), int(5800))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("refer-glojure").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("filters"))), lang.NewKeyword("doc"), "Same as (refer 'glojure.core )", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5800), lang.NewKeyword("end-line"), int(5800))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 2 { @@ -69568,94 +69691,96 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.NewList(args[2:]...) - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("seq")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("concat")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("list")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.Apply(v14, []any{lang.NewSymbol("glojure.core/refer")}) - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("list")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("seq")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("concat")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("list")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.Apply(v27, []any{lang.NewSymbol("quote")}) - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("list")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.Apply(v31, []any{lang.NewSymbol("glojure.core")}) - v33 := lang.Apply(v24, []any{v28, v32}) - v34 := lang.Apply(v21, []any{v33}) - v35 := lang.Apply(v18, []any{v34}) - v36 := lang.Apply(v11, []any{v15, v35, v5}) - v37 := lang.Apply(v8, []any{v36}) - return v37 - } - }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("seq")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("concat")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("list")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("glojure.core/refer")}) + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("list")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("seq")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("concat")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("list")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.Apply(tmp27, []any{lang.NewSymbol("quote")}) + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("list")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.Apply(tmp31, []any{lang.NewSymbol("glojure.core")}) + tmp33 := lang.Apply(tmp24, []any{tmp28, tmp32}) + tmp34 := lang.Apply(tmp21, []any{tmp33}) + tmp35 := lang.Apply(tmp18, []any{tmp34}) + tmp36 := lang.Apply(tmp11, []any{tmp15, tmp35, v5}) + tmp37 := lang.Apply(tmp8, []any{tmp36}) + return tmp37 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // release-pending-sends { - v0 := lang.NewSymbol("release-pending-sends").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Normally, actions sent directly or indirectly during another action\n are held until the action completes (changes the agent's\n state). This function can be used to dispatch any pending sent\n actions immediately. This has no impact on actions sent during a\n transaction, which are still held until commit. If no action is\n occurring, does nothing. Returns the number of actions dispatched.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2131), lang.NewKeyword("end-line"), int(2131))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("release-pending-sends").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Normally, actions sent directly or indirectly during another action\n are held until the action completes (changes the agent's\n state). This function can be used to dispatch any pending sent\n actions immediately. This has no impact on actions sent during a\n transaction, which are still held until commit. If no action is\n occurring, does nothing. Returns the number of actions dispatched.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2131), lang.NewKeyword("end-line"), int(2131))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v3 := lang.Apply(nil, nil) - return v3 + tmp3 := lang.Apply(nil, nil) + return tmp3 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // rem { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function rem__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -69663,84 +69788,84 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("seq")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("concat")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("list")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("list")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("list")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("seq")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("concat")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("list")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/Remainder")}) - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("list")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{v3}) - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("list")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.Apply(v38, []any{v4}) - v40 := lang.Apply(v27, []any{v31, v35, v39}) - v41 := lang.Apply(v24, []any{v40}) - v42 := lang.Apply(v21, []any{v41}) - v43 := lang.Apply(v10, []any{v14, v18, v42}) - v44 := lang.Apply(v7, []any{v43}) - return v44 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("concat")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("list")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol(".")}) + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("seq")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("concat")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("list")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.Apply(tmp30, []any{lang.NewSymbol("glojure.core/Remainder")}) + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.Apply(tmp34, []any{v3}) + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{v4}) + tmp40 := lang.Apply(tmp27, []any{tmp31, tmp35, tmp39}) + tmp41 := lang.Apply(tmp24, []any{tmp40}) + tmp42 := lang.Apply(tmp21, []any{tmp41}) + tmp43 := lang.Apply(tmp10, []any{tmp14, tmp18, tmp42}) + tmp44 := lang.Apply(tmp7, []any{tmp43}) + return tmp44 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("rem").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"), lang.NewSymbol("div"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "remainder of dividing numerator by denominator.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1274), lang.NewKeyword("end-line"), int(1274))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("rem").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"), lang.NewSymbol("div"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "remainder of dividing numerator by denominator.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1274), lang.NewKeyword("end-line"), int(1274))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -69748,107 +69873,107 @@ func init() { _ = v4 v5 := args[1] _ = v5 - v6, _ := lang.FieldOrMethod(lang.Numbers, "Remainder") - if reflect.TypeOf(v6).Kind() != reflect.Func { + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Remainder") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Remainder is not a function"))) } - v7 := lang.Apply(v6, []any{v4, v5}) - return v7 + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // remove { - v0 := lang.NewSymbol("remove").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred")), lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the items in coll for which\n (pred item) returns logical false. pred must be free of side-effects.\n Returns a transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2818), lang.NewKeyword("end-line"), int(2818))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("remove").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred")), lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the items in coll for which\n (pred item) returns logical false. pred must be free of side-effects.\n Returns a transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2818), lang.NewKeyword("end-line"), int(2818))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("filter")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("complement")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v9, []any{v3}) - v11 := lang.Apply(v6, []any{v10}) - return v11 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("filter")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("complement")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp9, []any{v3}) + tmp11 := lang.Apply(tmp6, []any{tmp10}) + return tmp11 case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("filter")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("complement")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v3}) - v12 := lang.Apply(v7, []any{v11, v4}) - return v12 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("filter")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("complement")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v3}) + tmp12 := lang.Apply(tmp7, []any{tmp11, v4}) + return tmp12 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // remove-all-methods { - v0 := lang.NewSymbol("remove-all-methods").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"))), lang.NewKeyword("doc"), "Removes all of the methods of multimethod.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1787), lang.NewKeyword("end-line"), int(1787))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("remove-all-methods").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"))), lang.NewKeyword("doc"), "Removes all of the methods of multimethod.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1787), lang.NewKeyword("end-line"), int(1787))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4, ok := lang.FieldOrMethod(v3, "reset") + tmp4, ok := lang.FieldOrMethod(v3, "reset") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "reset"))) } - var v5 any - switch reflect.TypeOf(v4).Kind() { + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { case reflect.Func: - v5 = lang.Apply(v4, nil) + tmp5 = lang.Apply(tmp4, nil) default: - v5 = v4 + tmp5 = tmp4 } - return v5 + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // remove-method { - v0 := lang.NewSymbol("remove-method").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"), lang.NewSymbol("dispatch-val"))), lang.NewKeyword("doc"), "Removes the method of multimethod associated with dispatch-value.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1794), lang.NewKeyword("end-line"), int(1794))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("remove-method").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"), lang.NewSymbol("dispatch-val"))), lang.NewKeyword("doc"), "Removes the method of multimethod associated with dispatch-value.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1794), lang.NewKeyword("end-line"), int(1794))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -69856,81 +69981,81 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5, _ := lang.FieldOrMethod(v3, "removeMethod") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(v3, "removeMethod") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("removeMethod is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // remove-ns { - v0 := lang.NewSymbol("remove-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Removes the namespace named by the symbol. Use with caution.\n Cannot be used to remove the glojure namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4139), lang.NewKeyword("end-line"), int(4139))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("remove-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Removes the namespace named by the symbol. Use with caution.\n Cannot be used to remove the glojure namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4139), lang.NewKeyword("end-line"), int(4139))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.Apply(lang.RemoveNamespace, []any{v3}) - return v4 + tmp4 := lang.Apply(lang.RemoveNamespace, []any{v3}) + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // remove-tap { - v0 := lang.NewSymbol("remove-tap").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Remove f from the tap set.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7883), lang.NewKeyword("end-line"), int(7883))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("remove-tap").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Remove f from the tap set.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7883), lang.NewKeyword("end-line"), int(7883))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("swap!")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("tapset")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("disj")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v6, []any{v9, v12, v3}) - _ = v13 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("swap!")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("tapset")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("disj")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp6, []any{tmp9, tmp12, v3}) + _ = tmp13 return nil }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // remove-watch { - v0 := lang.NewSymbol("remove-watch").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("reference"), lang.NewSymbol("key"))), lang.NewKeyword("doc"), "Removes a watch (set by add-watch) from a reference", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2160), lang.NewKeyword("end-line"), int(2160))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("remove-watch").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("reference"), lang.NewSymbol("key"))), lang.NewKeyword("doc"), "Removes a watch (set by add-watch) from a reference", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2160), lang.NewKeyword("end-line"), int(2160))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -69938,197 +70063,197 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5, _ := lang.FieldOrMethod(v3, "removeWatch") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(v3, "removeWatch") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("removeWatch is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // repeat { - v0 := lang.NewSymbol("repeat").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns a lazy (infinite!, or length n if supplied) sequence of xs.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2997), lang.NewKeyword("end-line"), int(2997))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("repeat").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns a lazy (infinite!, or length n if supplied) sequence of xs.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2997), lang.NewKeyword("end-line"), int(2997))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - v4 := lang.Apply(lang.NewRepeat, []any{v3}) - return v4 + tmp4 := lang.Apply(lang.NewRepeat, []any{v3}) + return tmp4 case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - v5 := lang.Apply(lang.NewRepeatN, []any{v3, v4}) - return v5 + tmp5 := lang.Apply(lang.NewRepeatN, []any{v3, v4}) + return tmp5 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // repeatedly { - v0 := lang.NewSymbol("repeatedly").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Takes a function of no args, presumably with side effects, and\n returns an infinite (or length n if supplied) lazy sequence of calls\n to it", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5167), lang.NewKeyword("end-line"), int(5167))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("repeatedly").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Takes a function of no args, presumably with side effects, and\n returns an infinite (or length n if supplied) lazy sequence of calls\n to it", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5167), lang.NewKeyword("end-line"), int(5167))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - var v4 lang.FnFunc - v4 = lang.NewFnFunc(func(args ...any) any { + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("cons")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v3, nil) - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("repeatedly")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.Apply(v11, []any{v3}) - v13 := lang.Apply(v7, []any{v8, v12}) - return v13 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("cons")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(v3, nil) + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("repeatedly")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.Apply(tmp11, []any{v3}) + tmp13 := lang.Apply(tmp7, []any{tmp8, tmp12}) + return tmp13 }) - v5 := lang.Apply(lang.NewLazySeq, []any{v4}) - return v5 + tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) + return tmp5 case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("take")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("repeatedly")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v4}) - v12 := lang.Apply(v7, []any{v3, v11}) - return v12 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("take")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("repeatedly")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v4}) + tmp12 := lang.Apply(tmp7, []any{v3, tmp11}) + return tmp12 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // replace { - v0 := lang.NewSymbol("replace").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("smap")), lang.NewVector(lang.NewSymbol("smap"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Given a map of replacement pairs and a vector/collection, returns a\n vector/seq with any elements = a key in smap replaced with the\n corresponding val in smap. Returns a transducer when no collection\n is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5082), lang.NewKeyword("end-line"), int(5082))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("replace").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("smap")), lang.NewVector(lang.NewSymbol("smap"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Given a map of replacement pairs and a vector/collection, returns a\n vector/seq with any elements = a key in smap replaced with the\n corresponding val in smap. Returns a transducer when no collection\n is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5082), lang.NewKeyword("end-line"), int(5082))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("map")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - var v7 lang.FnFunc - v7 = lang.NewFnFunc(func(args ...any) any { + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("map")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v8 := args[0] _ = v8 - var v9 any + var tmp9 any { // let // let binding "temp__0__auto__" - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("find")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{v3, v8}) - var v14 any = v13 + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("find")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{v3, v8}) + var v14 any = tmp13 _ = v14 - var v15 any + var tmp15 any if lang.IsTruthy(v14) { - var v16 any + var tmp16 any { // let // let binding "e" var v17 any = v14 _ = v17 - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("val")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("val")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) } - v20 := v19.Get() - v21 := lang.Apply(v20, []any{v17}) - v16 = v21 + tmp20 := tmp19.Get() + tmp21 := lang.Apply(tmp20, []any{v17}) + tmp16 = tmp21 } // end let - v15 = v16 + tmp15 = tmp16 } else { - v15 = v8 + tmp15 = v8 } - v9 = v15 + tmp9 = tmp15 } // end let - return v9 + return tmp9 }) - v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5090), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5090), lang.NewKeyword("end-column"), int(47)) - v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) + tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5090), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5090), lang.NewKeyword("end-column"), int(47)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) if err != nil { panic(err) } - v10 := lang.Apply(v6, []any{v9}) - return v10 + tmp10 := lang.Apply(tmp6, []any{tmp9}) + return tmp10 case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - var v5 any - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("vector?")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{v4}) - if lang.IsTruthy(v9) { - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("reduce1")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - var v13 lang.FnFunc - v13 = lang.NewFnFunc(func(args ...any) any { + var tmp5 any + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("vector?")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.Apply(tmp8, []any{v4}) + if lang.IsTruthy(tmp9) { + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -70136,151 +70261,151 @@ func init() { _ = v14 v15 := args[1] _ = v15 - var v16 any + var tmp16 any { // let // let binding "temp__0__auto__" - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("find")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("nth")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.Apply(v22, []any{v14, v15}) - v24 := lang.Apply(v19, []any{v3, v23}) - var v25 any = v24 + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("find")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("nth")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.Apply(tmp22, []any{v14, v15}) + tmp24 := lang.Apply(tmp19, []any{v3, tmp23}) + var v25 any = tmp24 _ = v25 - var v26 any + var tmp26 any if lang.IsTruthy(v25) { - var v27 any + var tmp27 any { // let // let binding "e" var v28 any = v25 _ = v28 - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("assoc")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("assoc")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) } - v31 := v30.Get() - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("val")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + tmp31 := tmp30.Get() + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("val")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{v28}) - v36 := lang.Apply(v31, []any{v14, v15, v35}) - v27 = v36 + tmp34 := tmp33.Get() + tmp35 := lang.Apply(tmp34, []any{v28}) + tmp36 := lang.Apply(tmp31, []any{v14, v15, tmp35}) + tmp27 = tmp36 } // end let - v26 = v27 + tmp26 = tmp27 } else { - v26 = v14 + tmp26 = v14 } - v16 = v26 + tmp16 = tmp26 } // end let - return v16 + return tmp16 }) - v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5093), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(5096), lang.NewKeyword("end-column"), int(23)) - v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) + tmp14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5093), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(5096), lang.NewKeyword("end-column"), int(23)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) if err != nil { panic(err) } - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("range")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("count")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{v4}) - v23 := lang.Apply(v18, []any{v22}) - v24 := lang.Apply(v12, []any{v15, v4, v23}) - v5 = v24 + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("range")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("count")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, []any{v4}) + tmp23 := lang.Apply(tmp18, []any{tmp22}) + tmp24 := lang.Apply(tmp12, []any{tmp15, v4, tmp23}) + tmp5 = tmp24 } else { - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("map")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - var v28 lang.FnFunc - v28 = lang.NewFnFunc(func(args ...any) any { + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("map")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + var tmp28 lang.FnFunc + tmp28 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v29 := args[0] _ = v29 - var v30 any + var tmp30 any { // let // let binding "temp__0__auto__" - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("find")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{v3, v29}) - var v35 any = v34 + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("find")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{v3, v29}) + var v35 any = tmp34 _ = v35 - var v36 any + var tmp36 any if lang.IsTruthy(v35) { - var v37 any + var tmp37 any { // let // let binding "e" var v38 any = v35 _ = v38 - v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v40 := v39.FindInternedVar(lang.NewSymbol("val")) - if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) + tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp40 := tmp39.FindInternedVar(lang.NewSymbol("val")) + if tmp40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) } - v41 := v40.Get() - v42 := lang.Apply(v41, []any{v38}) - v37 = v42 + tmp41 := tmp40.Get() + tmp42 := lang.Apply(tmp41, []any{v38}) + tmp37 = tmp42 } // end let - v36 = v37 + tmp36 = tmp37 } else { - v36 = v29 + tmp36 = v29 } - v30 = v36 + tmp30 = tmp36 } // end let - return v30 + return tmp30 }) - v29 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5098), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(5098), lang.NewKeyword("end-column"), int(49)) - v30, err := lang.WithMeta(v28, v29.(lang.IPersistentMap)) + tmp29 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5098), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(5098), lang.NewKeyword("end-column"), int(49)) + tmp30, err := lang.WithMeta(tmp28, tmp29.(lang.IPersistentMap)) if err != nil { panic(err) } - v31 := lang.Apply(v27, []any{v30, v4}) - v5 = v31 + tmp31 := lang.Apply(tmp27, []any{tmp30, v4}) + tmp5 = tmp31 } - return v5 + return tmp5 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // replicate { - v0 := lang.NewSymbol("replicate").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "DEPRECATED: Use 'repeat' instead.\n Returns a lazy seq of n xs.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("deprecated"), "1.3", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3004), lang.NewKeyword("end-line"), int(3004))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("replicate").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "DEPRECATED: Use 'repeat' instead.\n Returns a lazy seq of n xs.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("deprecated"), "1.3", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3004), lang.NewKeyword("end-line"), int(3004))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -70288,154 +70413,155 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("take")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("take")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("repeat")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("repeat")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v4}) - v12 := lang.Apply(v7, []any{v3, v11}) - return v12 + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v4}) + tmp12 := lang.Apply(tmp7, []any{v3, tmp11}) + return tmp12 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // require { - v0 := lang.NewSymbol("require").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Loads libs, skipping any that are already loaded. Each argument is\n either a libspec that identifies a lib, a prefix list that identifies\n multiple libs whose names share a common prefix, or a flag that modifies\n how all the identified libs are loaded. Use :require in the ns macro\n in preference to calling this directly.\n\n Libs\n\n A 'lib' is a named set of resources in classpath whose contents define a\n library of Clojure code. Lib names are symbols and each lib is associated\n with a Clojure namespace and a Java package that share its name. A lib's\n name also locates its root directory within classpath using Java's\n package name to classpath-relative path mapping. All resources in a lib\n should be contained in the directory structure under its root directory.\n All definitions a lib makes should be in its associated namespace.\n\n 'require loads a lib by loading its root resource. The root resource path\n is derived from the lib name in the following manner:\n Consider a lib named by the symbol 'x.y.z; it has the root directory\n /x/y/, and its root resource is /x/y/z.clj, or\n /x/y/z.cljc if /x/y/z.clj does not exist. The\n root resource should contain code to create the lib's\n namespace (usually by using the ns macro) and load any additional\n lib resources.\n\n Libspecs\n\n A libspec is a lib name or a vector containing a lib name followed by\n options expressed as sequential keywords and arguments.\n\n Recognized options:\n :as takes a symbol as its argument and makes that symbol an alias to the\n lib's namespace in the current namespace.\n :as-alias takes a symbol as its argument and aliases like :as, however\n the lib will not be loaded. If the lib has not been loaded, a new\n empty namespace will be created (as with create-ns).\n :refer takes a list of symbols to refer from the namespace or the :all\n keyword to bring in all public vars.\n\n Prefix Lists\n\n It's common for Clojure code to depend on several libs whose names have\n the same prefix. When specifying libs, prefix lists can be used to reduce\n repetition. A prefix list contains the shared prefix followed by libspecs\n with the shared prefix removed from the lib names. After removing the\n prefix, the names that remain must not contain any periods.\n\n Flags\n\n A flag is a keyword.\n Recognized flags: :reload, :reload-all, :verbose\n :reload forces loading of all the identified libs even if they are\n already loaded (has no effect on libspecs using :as-alias)\n :reload-all implies :reload and also forces loading of all libs that the\n identified libs directly or indirectly load via require or use\n (has no effect on libspecs using :as-alias)\n :verbose triggers printing information about each load, alias, and refer\n\n Example:\n\n The following would load the libraries glojure.zip and glojure.set\n abbreviated as 's'.\n\n (require '(glojure zip [set :as s]))", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5989), lang.NewKeyword("end-line"), int(5989))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("require").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Loads libs, skipping any that are already loaded. Each argument is\n either a libspec that identifies a lib, a prefix list that identifies\n multiple libs whose names share a common prefix, or a flag that modifies\n how all the identified libs are loaded. Use :require in the ns macro\n in preference to calling this directly.\n\n Libs\n\n A 'lib' is a named set of resources in classpath whose contents define a\n library of Clojure code. Lib names are symbols and each lib is associated\n with a Clojure namespace and a Java package that share its name. A lib's\n name also locates its root directory within classpath using Java's\n package name to classpath-relative path mapping. All resources in a lib\n should be contained in the directory structure under its root directory.\n All definitions a lib makes should be in its associated namespace.\n\n 'require loads a lib by loading its root resource. The root resource path\n is derived from the lib name in the following manner:\n Consider a lib named by the symbol 'x.y.z; it has the root directory\n /x/y/, and its root resource is /x/y/z.clj, or\n /x/y/z.cljc if /x/y/z.clj does not exist. The\n root resource should contain code to create the lib's\n namespace (usually by using the ns macro) and load any additional\n lib resources.\n\n Libspecs\n\n A libspec is a lib name or a vector containing a lib name followed by\n options expressed as sequential keywords and arguments.\n\n Recognized options:\n :as takes a symbol as its argument and makes that symbol an alias to the\n lib's namespace in the current namespace.\n :as-alias takes a symbol as its argument and aliases like :as, however\n the lib will not be loaded. If the lib has not been loaded, a new\n empty namespace will be created (as with create-ns).\n :refer takes a list of symbols to refer from the namespace or the :all\n keyword to bring in all public vars.\n\n Prefix Lists\n\n It's common for Clojure code to depend on several libs whose names have\n the same prefix. When specifying libs, prefix lists can be used to reduce\n repetition. A prefix list contains the shared prefix followed by libspecs\n with the shared prefix removed from the lib names. After removing the\n prefix, the names that remain must not contain any periods.\n\n Flags\n\n A flag is a keyword.\n Recognized flags: :reload, :reload-all, :verbose\n :reload forces loading of all the identified libs even if they are\n already loaded (has no effect on libspecs using :as-alias)\n :reload-all implies :reload and also forces loading of all libs that the\n identified libs directly or indirectly load via require or use\n (has no effect on libspecs using :as-alias)\n :verbose triggers printing information about each load, alias, and refer\n\n Example:\n\n The following would load the libraries glojure.zip and glojure.set\n abbreviated as 's'.\n\n (require '(glojure zip [set :as s]))", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5989), lang.NewKeyword("end-line"), int(5989))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v3 := lang.NewList(args[0:]...) - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("apply")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("apply")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("load-libs")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("load-libs")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) } - v9 := v8.Get() - v10 := lang.Apply(v6, []any{v9, lang.NewKeyword("require"), v3}) - return v10 + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp6, []any{tmp9, lang.NewKeyword("require"), v3}) + return tmp10 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // requiring-resolve { - v0 := lang.NewSymbol("requiring-resolve").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Resolves namespace-qualified sym per 'resolve'. If initial resolve\nfails, attempts to require sym's namespace and retries.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6068), lang.NewKeyword("end-line"), int(6068))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("requiring-resolve").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Resolves namespace-qualified sym per 'resolve'. If initial resolve\nfails, attempts to require sym's namespace and retries.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6068), lang.NewKeyword("end-line"), int(6068))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("qualified-symbol?")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v3}) - if lang.IsTruthy(v8) { - var v9 any + var tmp4 any + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("qualified-symbol?")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v3}) + if lang.IsTruthy(tmp8) { + var tmp9 any { // let // let binding "or__0__auto__" - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("resolve")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{v3}) - var v14 any = v13 + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("resolve")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{v3}) + var v14 any = tmp13 _ = v14 - var v15 any + var tmp15 any if lang.IsTruthy(v14) { - v15 = v14 + tmp15 = v14 } else { - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("serialized-require")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("symbol")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("namespace")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v3}) - v26 := lang.Apply(v21, []any{v25}) - v27 := lang.Apply(v18, []any{v26}) - _ = v27 - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("resolve")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.Apply(v30, []any{v3}) - v15 = v31 - } - v9 = v15 + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("serialized-require")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("symbol")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("namespace")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.Apply(tmp24, []any{v3}) + tmp26 := lang.Apply(tmp21, []any{tmp25}) + tmp27 := lang.Apply(tmp18, []any{tmp26}) + _ = tmp27 + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("resolve")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.Apply(tmp30, []any{v3}) + tmp15 = tmp31 + } + tmp9 = tmp15 } // end let - v4 = v9 + tmp4 = tmp9 } else { - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("str")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("str")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{"Not a qualified symbol: ", v3}) - v14 := lang.Apply(lang.NewIllegalArgumentError, []any{v13}) - panic(v14) + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{"Not a qualified symbol: ", v3}) + tmp14 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp13}) + panic(tmp14) } - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // reset! { - v0 := lang.NewSymbol("reset!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atom"), lang.NewSymbol("newval"))), lang.NewKeyword("doc"), "Sets the value of atom to newval without regard for the\n current value. Returns newval.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2368), lang.NewKeyword("end-line"), int(2368))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("reset!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atom"), lang.NewSymbol("newval"))), lang.NewKeyword("doc"), "Sets the value of atom to newval without regard for the\n current value. Returns newval.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2368), lang.NewKeyword("end-line"), int(2368))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -70443,24 +70569,24 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5, _ := lang.FieldOrMethod(v3, "reset") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(v3, "reset") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // reset-meta! { - v0 := lang.NewSymbol("reset-meta!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("iref"), lang.NewSymbol("metadata-map"))), lang.NewKeyword("doc"), "Atomically resets the metadata for a namespace/var/ref/agent/atom", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2408), lang.NewKeyword("end-line"), int(2408))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("reset-meta!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("iref"), lang.NewSymbol("metadata-map"))), lang.NewKeyword("doc"), "Atomically resets the metadata for a namespace/var/ref/agent/atom", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2408), lang.NewKeyword("end-line"), int(2408))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -70468,24 +70594,24 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5, _ := lang.FieldOrMethod(v3, "ResetMeta") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(v3, "ResetMeta") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("ResetMeta is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // reset-vals! { - v0 := lang.NewSymbol("reset-vals!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atom"), lang.NewSymbol("newval"))), lang.NewKeyword("doc"), "Sets the value of atom to newval. Returns [old new], the value of the\n atom before and after the reset.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2375), lang.NewKeyword("end-line"), int(2375))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("reset-vals!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atom"), lang.NewSymbol("newval"))), lang.NewKeyword("doc"), "Sets the value of atom to newval. Returns [old new], the value of the\n atom before and after the reset.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2375), lang.NewKeyword("end-line"), int(2375))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -70493,100 +70619,101 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5, _ := lang.FieldOrMethod(v3, "resetVals") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(v3, "resetVals") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("resetVals is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // resolve { - v0 := lang.NewSymbol("resolve").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym")), lang.NewVector(lang.NewSymbol("env"), lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "same as (ns-resolve *ns* symbol) or (ns-resolve *ns* &env symbol)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4371), lang.NewKeyword("end-line"), int(4371))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("resolve").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym")), lang.NewVector(lang.NewSymbol("env"), lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "same as (ns-resolve *ns* symbol) or (ns-resolve *ns* &env symbol)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4371), lang.NewKeyword("end-line"), int(4371))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("ns-resolve")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("*ns*")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v6, []any{v9, v3}) - return v10 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("ns-resolve")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("*ns*")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp6, []any{tmp9, v3}) + return tmp10 case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("ns-resolve")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("*ns*")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v7, []any{v10, v3, v4}) - return v11 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("ns-resolve")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("*ns*")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp7, []any{tmp10, v3, v4}) + return tmp11 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // rest { - v1 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() - v0 := lang.NewSymbol("rest").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a possibly empty seq of the items after the first. Calls seq on its\n argument.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(64), lang.NewKeyword("end-line"), int(70))).(*lang.Symbol) - var v3 lang.FnFunc + tmp1 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() + tmp0 := lang.NewSymbol("rest").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a possibly empty seq of the items after the first. Calls seq on its\n argument.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(64), lang.NewKeyword("end-line"), int(70))).(*lang.Symbol) + var tmp3 lang.FnFunc { // function rest - v3 = lang.NewFnFunc(func(args ...any) any { + var v4 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v5 := args[0] _ = v5 - v6 := lang.Apply(lang.Rest, []any{v5}) - return v6 + tmp6 := lang.Apply(lang.Rest, []any{v5}) + return tmp6 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(70), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(70), lang.NewKeyword("end-column"), int(77))).(lang.FnFunc) - v4 := v3 + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(70), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(70), lang.NewKeyword("end-column"), int(77))).(lang.FnFunc) + v4 = tmp3 _ = v4 } - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // restart-agent { - v0 := lang.NewSymbol("restart-agent").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("new-state"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "When an agent is failed, changes the agent state to new-state and\n then un-fails the agent so that sends are allowed again. If\n a :clear-actions true option is given, any actions queued on the\n agent that were being held while it was failed will be discarded,\n otherwise those held actions will proceed. The new-state must pass\n the validator if any, or restart will throw an exception and the\n agent will remain failed with its old state and error. Watchers, if\n any, will NOT be notified of the new state. Throws an exception if\n the agent is not failed.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2175), lang.NewKeyword("end-line"), int(2175))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("restart-agent").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("new-state"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "When an agent is failed, changes the agent state to new-state and\n then un-fails the agent so that sends are allowed again. If\n a :clear-actions true option is given, any actions queued on the\n agent that were being held while it was failed will be discarded,\n otherwise those held actions will proceed. The new-state must pass\n the validator if any, or restart will throw an exception and the\n agent will remain failed with its old state and error. Watchers, if\n any, will NOT be notified of the new state. Throws an exception if\n the agent is not failed.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2175), lang.NewKeyword("end-line"), int(2175))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 2 { @@ -70596,482 +70723,483 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.NewList(args[2:]...) - var v6 any + var v5 any = lang.NewList(args[2:]...) + _ = v5 + var tmp6 any { // let // let binding "opts" - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("apply")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("hash-map")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v9, []any{v12, v5}) - var v14 any = v13 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("apply")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("hash-map")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp9, []any{tmp12, v5}) + var v14 any = tmp13 _ = v14 - var v15 any - v16 := lang.Apply(lang.NewKeyword("clear-actions"), []any{v14}) - if lang.IsTruthy(v16) { - v15 = true + var tmp15 any + tmp16 := lang.Apply(lang.NewKeyword("clear-actions"), []any{v14}) + if lang.IsTruthy(tmp16) { + tmp15 = true } else { - v15 = false + tmp15 = false } - v17, _ := lang.FieldOrMethod(v3, "restart") - if reflect.TypeOf(v17).Kind() != reflect.Func { + tmp17, _ := lang.FieldOrMethod(v3, "restart") + if reflect.TypeOf(tmp17).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("restart is not a function"))) } - v18 := lang.Apply(v17, []any{v4, v15}) - v6 = v18 + tmp18 := lang.Apply(tmp17, []any{v4, tmp15}) + tmp6 = tmp18 } // end let - return v6 + return tmp6 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // resultset-seq { - v0 := lang.NewSymbol("resultset-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rs"))), lang.NewKeyword("doc"), "Creates and returns a lazy sequence of structmaps corresponding to\n the rows in the java.sql.ResultSet rs", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5681), lang.NewKeyword("end-line"), int(5681))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("resultset-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rs"))), lang.NewKeyword("doc"), "Creates and returns a lazy sequence of structmaps corresponding to\n the rows in the java.sql.ResultSet rs", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5681), lang.NewKeyword("end-line"), int(5681))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any + var tmp4 any { // let // let binding "rsmeta" - v5, _ := lang.FieldOrMethod(v3, "getMetaData") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(v3, "getMetaData") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("getMetaData is not a function"))) } - v6 := lang.Apply(v5, []any{}) - var v7 any = v6 + tmp6 := lang.Apply(tmp5, []any{}) + var v7 any = tmp6 _ = v7 // let binding "idxs" - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("range")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("inc")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14, _ := lang.FieldOrMethod(v7, "getColumnCount") - if reflect.TypeOf(v14).Kind() != reflect.Func { + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("range")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("inc")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14, _ := lang.FieldOrMethod(v7, "getColumnCount") + if reflect.TypeOf(tmp14).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("getColumnCount is not a function"))) } - v15 := lang.Apply(v14, []any{}) - v16 := lang.Apply(v13, []any{v15}) - v17 := lang.Apply(v10, []any{int64(1), v16}) - var v18 any = v17 + tmp15 := lang.Apply(tmp14, []any{}) + tmp16 := lang.Apply(tmp13, []any{tmp15}) + tmp17 := lang.Apply(tmp10, []any{int64(1), tmp16}) + var v18 any = tmp17 _ = v18 // let binding "keys" - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("map")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("comp")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("keyword")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - var v28 lang.FnFunc - v28 = lang.NewFnFunc(func(args ...any) any { + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("map")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("comp")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("keyword")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + var tmp28 lang.FnFunc + tmp28 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v29 := args[0] _ = v29 - v30, ok := lang.FieldOrMethod(v29, "toLowerCase") + tmp30, ok := lang.FieldOrMethod(v29, "toLowerCase") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v29, "toLowerCase"))) } - var v31 any - switch reflect.TypeOf(v30).Kind() { + var tmp31 any + switch reflect.TypeOf(tmp30).Kind() { case reflect.Func: - v31 = lang.Apply(v30, nil) + tmp31 = lang.Apply(tmp30, nil) default: - v31 = v30 + tmp31 = tmp30 } - return v31 + return tmp31 }) - v29 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5688), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(5688), lang.NewKeyword("end-column"), int(62)) - v30, err := lang.WithMeta(v28, v29.(lang.IPersistentMap)) + tmp29 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5688), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(5688), lang.NewKeyword("end-column"), int(62)) + tmp30, err := lang.WithMeta(tmp28, tmp29.(lang.IPersistentMap)) if err != nil { panic(err) } - v31 := lang.Apply(v24, []any{v27, v30}) - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("map")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) + tmp31 := lang.Apply(tmp24, []any{tmp27, tmp30}) + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("map")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) } - v34 := v33.Get() - var v35 lang.FnFunc - v35 = lang.NewFnFunc(func(args ...any) any { + tmp34 := tmp33.Get() + var tmp35 lang.FnFunc + tmp35 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v36 := args[0] _ = v36 - v37, _ := lang.FieldOrMethod(v7, "getColumnLabel") - if reflect.TypeOf(v37).Kind() != reflect.Func { + tmp37, _ := lang.FieldOrMethod(v7, "getColumnLabel") + if reflect.TypeOf(tmp37).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("getColumnLabel is not a function"))) } - v38 := lang.Apply(v37, []any{v36}) - return v38 + tmp38 := lang.Apply(tmp37, []any{v36}) + return tmp38 }) - v36 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5689), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(5689), lang.NewKeyword("end-column"), int(63)) - v37, err := lang.WithMeta(v35, v36.(lang.IPersistentMap)) + tmp36 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5689), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(5689), lang.NewKeyword("end-column"), int(63)) + tmp37, err := lang.WithMeta(tmp35, tmp36.(lang.IPersistentMap)) if err != nil { panic(err) } - v38 := lang.Apply(v34, []any{v37, v18}) - v39 := lang.Apply(v21, []any{v31, v38}) - var v40 any = v39 + tmp38 := lang.Apply(tmp34, []any{tmp37, v18}) + tmp39 := lang.Apply(tmp21, []any{tmp31, tmp38}) + var v40 any = tmp39 _ = v40 // let binding "check-keys" - var v41 any + var tmp41 any { // let // let binding "or__0__auto__" - v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v43 := v42.FindInternedVar(lang.NewSymbol("apply")) - if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) - } - v44 := v43.Get() - v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v46 := v45.FindInternedVar(lang.NewSymbol("distinct?")) - if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) - } - v47 := v46.Get() - v48 := lang.Apply(v44, []any{v47, v40}) - var v49 any = v48 + tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp43 := tmp42.FindInternedVar(lang.NewSymbol("apply")) + if tmp43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) + } + tmp44 := tmp43.Get() + tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp46 := tmp45.FindInternedVar(lang.NewSymbol("distinct?")) + if tmp46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) + } + tmp47 := tmp46.Get() + tmp48 := lang.Apply(tmp44, []any{tmp47, v40}) + var v49 any = tmp48 _ = v49 - var v50 any + var tmp50 any if lang.IsTruthy(v49) { - v50 = v49 + tmp50 = v49 } else { - v51 := lang.Apply(lang.NewError, []any{"ResultSet must have unique column labels"}) - panic(v51) + tmp51 := lang.Apply(lang.NewError, []any{"ResultSet must have unique column labels"}) + panic(tmp51) } - v41 = v50 + tmp41 = tmp50 } // end let - var v42 any = v41 + var v42 any = tmp41 _ = v42 // let binding "row-struct" - v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v44 := v43.FindInternedVar(lang.NewSymbol("apply")) - if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) - } - v45 := v44.Get() - v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v47 := v46.FindInternedVar(lang.NewSymbol("create-struct")) - if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) - } - v48 := v47.Get() - v49 := lang.Apply(v45, []any{v48, v40}) - var v50 any = v49 + tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp44 := tmp43.FindInternedVar(lang.NewSymbol("apply")) + if tmp44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) + } + tmp45 := tmp44.Get() + tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp47 := tmp46.FindInternedVar(lang.NewSymbol("create-struct")) + if tmp47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) + } + tmp48 := tmp47.Get() + tmp49 := lang.Apply(tmp45, []any{tmp48, v40}) + var v50 any = tmp49 _ = v50 // let binding "row-values" - var v51 lang.FnFunc - v51 = lang.NewFnFunc(func(args ...any) any { + var tmp51 lang.FnFunc + tmp51 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v53 := v52.FindInternedVar(lang.NewSymbol("map")) - if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) + tmp52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp53 := tmp52.FindInternedVar(lang.NewSymbol("map")) + if tmp53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp53))) } - v54 := v53.Get() - var v55 lang.FnFunc - v55 = lang.NewFnFunc(func(args ...any) any { + tmp54 := tmp53.Get() + var tmp55 lang.FnFunc + tmp55 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v56 := args[0] _ = v56 - v57, _ := lang.FieldOrMethod(v3, "getObject") - if reflect.TypeOf(v57).Kind() != reflect.Func { + tmp57, _ := lang.FieldOrMethod(v3, "getObject") + if reflect.TypeOf(tmp57).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("getObject is not a function"))) } - v58 := lang.Apply(v57, []any{v56}) - return v58 + tmp58 := lang.Apply(tmp57, []any{v56}) + return tmp58 }) - v56 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5694), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(5694), lang.NewKeyword("end-column"), int(71)) - v57, err := lang.WithMeta(v55, v56.(lang.IPersistentMap)) + tmp56 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5694), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(5694), lang.NewKeyword("end-column"), int(71)) + tmp57, err := lang.WithMeta(tmp55, tmp56.(lang.IPersistentMap)) if err != nil { panic(err) } - v58 := lang.Apply(v54, []any{v57, v18}) - return v58 + tmp58 := lang.Apply(tmp54, []any{tmp57, v18}) + return tmp58 }) - v52 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5694), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(5694), lang.NewKeyword("end-column"), int(78)) - v53, err := lang.WithMeta(v51, v52.(lang.IPersistentMap)) + tmp52 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5694), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(5694), lang.NewKeyword("end-column"), int(78)) + tmp53, err := lang.WithMeta(tmp51, tmp52.(lang.IPersistentMap)) if err != nil { panic(err) } - var v54 any = v53 + var v54 any = tmp53 _ = v54 // let binding "rows" - var v55 lang.FnFunc + var tmp55 lang.FnFunc { // function thisfn - v55 = lang.NewFnFunc(func(args ...any) any { + var v56 lang.FnFunc + tmp55 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - var v57 any - v58, _ := lang.FieldOrMethod(v3, "next") - if reflect.TypeOf(v58).Kind() != reflect.Func { + var tmp57 any + tmp58, _ := lang.FieldOrMethod(v3, "next") + if reflect.TypeOf(tmp58).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("next is not a function"))) } - v59 := lang.Apply(v58, []any{}) - if lang.IsTruthy(v59) { - v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v61 := v60.FindInternedVar(lang.NewSymbol("cons")) - if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) - } - v62 := v61.Get() - v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v64 := v63.FindInternedVar(lang.NewSymbol("apply")) - if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) - } - v65 := v64.Get() - v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v67 := v66.FindInternedVar(lang.NewSymbol("struct")) - if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) - } - v68 := v67.Get() - v69 := lang.Apply(v54, nil) - v70 := lang.Apply(v65, []any{v68, v50, v69}) - var v71 lang.FnFunc - v71 = lang.NewFnFunc(func(args ...any) any { + tmp59 := lang.Apply(tmp58, []any{}) + if lang.IsTruthy(tmp59) { + tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp61 := tmp60.FindInternedVar(lang.NewSymbol("cons")) + if tmp61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) + } + tmp62 := tmp61.Get() + tmp63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp64 := tmp63.FindInternedVar(lang.NewSymbol("apply")) + if tmp64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp64))) + } + tmp65 := tmp64.Get() + tmp66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp67 := tmp66.FindInternedVar(lang.NewSymbol("struct")) + if tmp67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp67))) + } + tmp68 := tmp67.Get() + tmp69 := lang.Apply(v54, nil) + tmp70 := lang.Apply(tmp65, []any{tmp68, v50, tmp69}) + var tmp71 lang.FnFunc + tmp71 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v72 := lang.Apply(v56, nil) - return v72 + tmp72 := lang.Apply(v56, nil) + return tmp72 }) - v72 := lang.Apply(lang.NewLazySeq, []any{v71}) - v73 := lang.Apply(v62, []any{v70, v72}) - v57 = v73 + tmp72 := lang.Apply(lang.NewLazySeq, []any{tmp71}) + tmp73 := lang.Apply(tmp62, []any{tmp70, tmp72}) + tmp57 = tmp73 } else { - v57 = nil } - return v57 + return tmp57 }) - v56 := v55 + v56 = tmp55 _ = v56 } - v56 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5695), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(5697), lang.NewKeyword("end-column"), int(86)) - v57, err := lang.WithMeta(v55, v56.(lang.IPersistentMap)) + tmp56 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5695), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(5697), lang.NewKeyword("end-column"), int(86)) + tmp57, err := lang.WithMeta(tmp55, tmp56.(lang.IPersistentMap)) if err != nil { panic(err) } - var v58 any = v57 + var v58 any = tmp57 _ = v58 - v59 := lang.Apply(v58, nil) - v4 = v59 + tmp59 := lang.Apply(v58, nil) + tmp4 = tmp59 } // end let - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // reverse { - v0 := lang.NewSymbol("reverse").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a seq of the items in coll in reverse order. Not lazy.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(940), lang.NewKeyword("end-line"), int(940))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("reverse").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a seq of the items in coll in reverse order. Not lazy.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(940), lang.NewKeyword("end-line"), int(940))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("reduce1")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("conj")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("conj")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) } - v9 := v8.Get() - v10 := lang.Apply(v6, []any{v9, lang.NewList(), v3}) - return v10 + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp6, []any{tmp9, lang.NewList(), v3}) + return tmp10 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // reversible? { - v0 := lang.NewSymbol("reversible?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements Reversible", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6257), lang.NewKeyword("end-line"), int(6257))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("reversible?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements Reversible", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6257), lang.NewKeyword("end-line"), int(6257))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) } - v6 := v5.Get() - v7 := lang.Apply(v6, []any{nil, v3}) - return v7 + tmp6 := tmp5.Get() + tmp7 := lang.Apply(tmp6, []any{nil, v3}) + return tmp7 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // root-directory { - v0 := lang.NewSymbol("root-directory").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"))), lang.NewKeyword("doc"), "Returns the root resource path for a lib", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5871), lang.NewKeyword("end-line"), int(5871), lang.NewKeyword("private"), true)).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("root-directory").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"))), lang.NewKeyword("doc"), "Returns the root resource path for a lib", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5871), lang.NewKeyword("end-line"), int(5871), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any + var tmp4 any { // let // let binding "d" - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("root-resource")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v3}) - var v9 any = v8 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("root-resource")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v3}) + var v9 any = tmp8 _ = v9 - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("subs")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(strings8.LastIndex, []any{v9, "/"}) - v14 := lang.Apply(v12, []any{v9, int64(0), v13}) - v4 = v14 + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("subs")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(strings8.LastIndex, []any{v9, "/"}) + tmp14 := lang.Apply(tmp12, []any{v9, int64(0), tmp13}) + tmp4 = tmp14 } // end let - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // root-resource { - v1 := reflect.TypeOf("") - v0 := lang.NewSymbol("root-resource").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"))), lang.NewKeyword("doc"), "Returns the root directory path for a lib", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5864), lang.NewKeyword("end-line"), int(5864), lang.NewKeyword("private"), true)).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp1 := reflect.TypeOf("") + tmp0 := lang.NewSymbol("root-resource").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"))), lang.NewKeyword("doc"), "Returns the root directory path for a lib", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5864), lang.NewKeyword("end-line"), int(5864), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("str")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("name")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v4}) - v12 := lang.Apply(strings8.ReplaceAll, []any{v11, "-", "_"}) - v13 := lang.Apply(strings8.ReplaceAll, []any{v12, ".", "/"}) - v14 := lang.Apply(v7, []any{lang.NewChar(47), v13}) - return v14 - }) - v4 := reflect.TypeOf("") - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("str")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("name")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v4}) + tmp12 := lang.Apply(strings8.ReplaceAll, []any{tmp11, "-", "_"}) + tmp13 := lang.Apply(strings8.ReplaceAll, []any{tmp12, ".", "/"}) + tmp14 := lang.Apply(tmp7, []any{lang.NewChar(47), tmp13}) + return tmp14 + }) + tmp4 := reflect.TypeOf("") + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // rseq { - v0 := lang.NewSymbol("rseq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rev"))), lang.NewKeyword("doc"), "Returns, in constant time, a seq of the items in rev (which\n can be a vector or sorted-map), in reverse order. If rev is empty returns nil", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1577), lang.NewKeyword("end-line"), int(1577))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("rseq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rev"))), lang.NewKeyword("doc"), "Returns, in constant time, a seq of the items in rev (which\n can be a vector or sorted-map), in reverse order. If rev is empty returns nil", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1577), lang.NewKeyword("end-line"), int(1577))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4, _ := lang.FieldOrMethod(v3, "rseq") - if reflect.TypeOf(v4).Kind() != reflect.Func { + tmp4, _ := lang.FieldOrMethod(v3, "rseq") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("rseq is not a function"))) } - v5 := lang.Apply(v4, []any{}) - return v5 + tmp5 := lang.Apply(tmp4, []any{}) + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // rsubseq { - v0 := lang.NewSymbol("rsubseq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sc"), lang.NewSymbol("test"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("sc"), lang.NewSymbol("start-test"), lang.NewSymbol("start-key"), lang.NewSymbol("end-test"), lang.NewSymbol("end-key"))), lang.NewKeyword("doc"), "sc must be a sorted collection, test(s) one of <, <=, > or\n >=. Returns a reverse seq of those entries with keys ek for\n which (test (.. sc comparator (compare ek key)) 0) is true", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5150), lang.NewKeyword("end-line"), int(5150))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("rsubseq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sc"), lang.NewSymbol("test"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("sc"), lang.NewSymbol("start-test"), lang.NewSymbol("start-key"), lang.NewSymbol("end-test"), lang.NewSymbol("end-key"))), lang.NewKeyword("doc"), "sc must be a sorted collection, test(s) one of <, <=, > or\n >=. Returns a reverse seq of those entries with keys ek for\n which (test (.. sc comparator (compare ek key)) 0) is true", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5150), lang.NewKeyword("end-line"), int(5150))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 3: v3 := args[0] @@ -71080,110 +71208,109 @@ func init() { _ = v4 v5 := args[2] _ = v5 - var v6 any + var tmp6 any { // let // let binding "include" - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("mk-bound-fn")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v9, []any{v3, v4, v5}) - var v11 any = v10 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("mk-bound-fn")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp9, []any{v3, v4, v5}) + var v11 any = tmp10 _ = v11 - var v12 any - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("<")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("<=")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.CreatePersistentTreeSet(v15, v18) - v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5158), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5158), lang.NewKeyword("end-column"), int(17)) - v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) + var tmp12 any + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("<")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("<=")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{tmp15, tmp18})) + tmp20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5158), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5158), lang.NewKeyword("end-column"), int(17)) + tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) if err != nil { panic(err) } - v22 := lang.Apply(v21, []any{v4}) - if lang.IsTruthy(v22) { - var v23 any + tmp22 := lang.Apply(tmp21, []any{v4}) + if lang.IsTruthy(tmp22) { + var tmp23 any { // let // let binding "temp__0__auto__" - v24, _ := lang.FieldOrMethod(v3, "seqFrom") - if reflect.TypeOf(v24).Kind() != reflect.Func { + tmp24, _ := lang.FieldOrMethod(v3, "seqFrom") + if reflect.TypeOf(tmp24).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("seqFrom is not a function"))) } - v25 := lang.Apply(v24, []any{v5, false}) - var v26 any = v25 + tmp25 := lang.Apply(tmp24, []any{v5, false}) + var v26 any = tmp25 _ = v26 - var v27 any + var tmp27 any if lang.IsTruthy(v26) { - var v28 any + var tmp28 any { // let // let binding "vec__74" var v29 any = v26 _ = v29 // let binding "e" - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("nth")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("nth")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) } - v32 := v31.Get() - v33 := lang.Apply(v32, []any{v29, int64(0), nil}) - var v34 any = v33 + tmp32 := tmp31.Get() + tmp33 := lang.Apply(tmp32, []any{v29, int64(0), nil}) + var v34 any = tmp33 _ = v34 // let binding "s" var v35 any = v29 _ = v35 - var v36 any - v37 := lang.Apply(v11, []any{v34}) - if lang.IsTruthy(v37) { - v36 = v35 + var tmp36 any + tmp37 := lang.Apply(v11, []any{v34}) + if lang.IsTruthy(tmp37) { + tmp36 = v35 } else { - v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v39 := v38.FindInternedVar(lang.NewSymbol("next")) - if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp39 := tmp38.FindInternedVar(lang.NewSymbol("next")) + if tmp39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) } - v40 := v39.Get() - v41 := lang.Apply(v40, []any{v35}) - v36 = v41 + tmp40 := tmp39.Get() + tmp41 := lang.Apply(tmp40, []any{v35}) + tmp36 = tmp41 } - v28 = v36 + tmp28 = tmp36 } // end let - v27 = v28 + tmp27 = tmp28 } else { - v27 = nil } - v23 = v27 + tmp23 = tmp27 } // end let - v12 = v23 + tmp12 = tmp23 } else { - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("take-while")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27, _ := lang.FieldOrMethod(v3, "seq") - if reflect.TypeOf(v27).Kind() != reflect.Func { + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("take-while")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27, _ := lang.FieldOrMethod(v3, "seq") + if reflect.TypeOf(tmp27).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("seq is not a function"))) } - v28 := lang.Apply(v27, []any{false}) - v29 := lang.Apply(v26, []any{v11, v28}) - v12 = v29 + tmp28 := lang.Apply(tmp27, []any{false}) + tmp29 := lang.Apply(tmp26, []any{v11, tmp28}) + tmp12 = tmp29 } - v6 = v12 + tmp6 = tmp12 } // end let - return v6 + return tmp6 case 5: v3 := args[0] _ = v3 @@ -71195,95 +71322,94 @@ func init() { _ = v6 v7 := args[4] _ = v7 - var v8 any + var tmp8 any { // let // let binding "temp__0__auto__" - v9, _ := lang.FieldOrMethod(v3, "seqFrom") - if reflect.TypeOf(v9).Kind() != reflect.Func { + tmp9, _ := lang.FieldOrMethod(v3, "seqFrom") + if reflect.TypeOf(tmp9).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("seqFrom is not a function"))) } - v10 := lang.Apply(v9, []any{v7, false}) - var v11 any = v10 + tmp10 := lang.Apply(tmp9, []any{v7, false}) + var v11 any = tmp10 _ = v11 - var v12 any + var tmp12 any if lang.IsTruthy(v11) { - var v13 any + var tmp13 any { // let // let binding "vec__77" var v14 any = v11 _ = v14 // let binding "e" - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("nth")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{v14, int64(0), nil}) - var v19 any = v18 + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("nth")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{v14, int64(0), nil}) + var v19 any = tmp18 _ = v19 // let binding "s" var v20 any = v14 _ = v20 - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("take-while")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("mk-bound-fn")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.Apply(v26, []any{v3, v4, v5}) - var v28 any - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("mk-bound-fn")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.Apply(v31, []any{v3, v6, v7}) - v33 := lang.Apply(v32, []any{v19}) - if lang.IsTruthy(v33) { - v28 = v20 + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("take-while")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("mk-bound-fn")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.Apply(tmp26, []any{v3, v4, v5}) + var tmp28 any + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("mk-bound-fn")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.Apply(tmp31, []any{v3, v6, v7}) + tmp33 := lang.Apply(tmp32, []any{v19}) + if lang.IsTruthy(tmp33) { + tmp28 = v20 } else { - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("next")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("next")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) } - v36 := v35.Get() - v37 := lang.Apply(v36, []any{v20}) - v28 = v37 + tmp36 := tmp35.Get() + tmp37 := lang.Apply(tmp36, []any{v20}) + tmp28 = tmp37 } - v38 := lang.Apply(v23, []any{v27, v28}) - v13 = v38 + tmp38 := lang.Apply(tmp23, []any{tmp27, tmp28}) + tmp13 = tmp38 } // end let - v12 = v13 + tmp12 = tmp13 } else { - v12 = nil } - v8 = v12 + tmp8 = tmp12 } // end let - return v8 + return tmp8 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // run! { - v0 := lang.NewSymbol("run!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("proc"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Runs the supplied procedure (via reduce), for purposes of side\n effects, on successive items in the collection. Returns nil", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7708), lang.NewKeyword("end-line"), int(7708))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("run!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("proc"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Runs the supplied procedure (via reduce), for purposes of side\n effects, on successive items in the collection. Returns nil", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7708), lang.NewKeyword("end-line"), int(7708))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -71291,14 +71417,14 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("reduce")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - var v8 lang.FnFunc - v8 = lang.NewFnFunc(func(args ...any) any { + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("reduce")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + var tmp8 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -71306,65 +71432,66 @@ func init() { _ = v9 v10 := args[1] _ = v10 - v11 := lang.Apply(v3, []any{v10}) - return v11 + tmp11 := lang.Apply(v3, []any{v10}) + return tmp11 }) - v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7713), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(7713), lang.NewKeyword("end-column"), int(20)) - v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) + tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7713), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(7713), lang.NewKeyword("end-column"), int(20)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) if err != nil { panic(err) } - v11 := lang.Apply(v7, []any{v10, nil, v4}) - _ = v11 + tmp11 := lang.Apply(tmp7, []any{tmp10, nil, v4}) + _ = tmp11 return nil }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // second { - v0 := lang.NewSymbol("second").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Same as (first (next x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(91), lang.NewKeyword("end-line"), int(95))).(*lang.Symbol) - var v2 lang.FnFunc + tmp0 := lang.NewSymbol("second").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Same as (first (next x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(91), lang.NewKeyword("end-line"), int(95))).(*lang.Symbol) + var tmp2 lang.FnFunc { // function second - v2 = lang.NewFnFunc(func(args ...any) any { + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("first")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("next")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v4}) - v12 := lang.Apply(v7, []any{v11}) - return v12 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("first")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("next")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v4}) + tmp12 := lang.Apply(tmp7, []any{tmp11}) + return tmp12 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(95), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(95), lang.NewKeyword("end-column"), int(49))).(lang.FnFunc) - v3 := v2 + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(95), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(95), lang.NewKeyword("end-column"), int(49))).(lang.FnFunc) + v3 = tmp2 _ = v3 } - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // select-keys { - v0 := lang.NewSymbol("select-keys").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("keyseq"))), lang.NewKeyword("doc"), "Returns a map containing only those entries in map whose key is in keys", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1536), lang.NewKeyword("end-line"), int(1536))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("select-keys").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("keyseq"))), lang.NewKeyword("doc"), "Returns a map containing only those entries in map whose key is in keys", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1536), lang.NewKeyword("end-line"), int(1536))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -71372,108 +71499,108 @@ func init() { _ = v3 v4 := args[1] _ = v4 - var v5 any + var tmp5 any { // let // let binding "ret" - v6 := lang.NewMap() - v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1541), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(1541), lang.NewKeyword("end-column"), int(17)) - v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) + tmp6 := lang.NewMap() + tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1541), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(1541), lang.NewKeyword("end-column"), int(17)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) if err != nil { panic(err) } - var v9 any = v8 + var v9 any = tmp8 _ = v9 // let binding "keys" - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("seq")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{v4}) - var v14 any = v13 + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("seq")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{v4}) + var v14 any = tmp13 _ = v14 for { - var v15 any + var tmp15 any if lang.IsTruthy(v14) { - var v16 any + var tmp16 any { // let // let binding "entry" - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("first")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.Apply(v19, []any{v14}) - v21, _ := lang.FieldOrMethod(runtime4.RT, "Find") - if reflect.TypeOf(v21).Kind() != reflect.Func { + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("first")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.Apply(tmp19, []any{v14}) + tmp21, _ := lang.FieldOrMethod(runtime4.RT, "Find") + if reflect.TypeOf(tmp21).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Find is not a function"))) } - v22 := lang.Apply(v21, []any{v3, v20}) - var v23 any = v22 + tmp22 := lang.Apply(tmp21, []any{v3, tmp20}) + var v23 any = tmp22 _ = v23 - var v25 any + var tmp25 any if lang.IsTruthy(v23) { - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("conj")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("conj")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) } - v28 := v27.Get() - v29 := lang.Apply(v28, []any{v9, v23}) - v25 = v29 + tmp28 := tmp27.Get() + tmp29 := lang.Apply(tmp28, []any{v9, v23}) + tmp25 = tmp29 } else { - v25 = v9 - } - var v24 any = v25 - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("next")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{v14}) - var v30 any = v34 - v9 = v24 - v14 = v30 + tmp25 = v9 + } + var tmp24 any = tmp25 + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("next")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{v14}) + var tmp30 any = tmp34 + v9 = tmp24 + v14 = tmp30 continue } // end let - v15 = v16 + tmp15 = tmp16 } else { - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("with-meta")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("meta")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.Apply(v22, []any{v3}) - v24 := lang.Apply(v19, []any{v9, v23}) - v15 = v24 - } - v5 = v15 + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("with-meta")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("meta")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.Apply(tmp22, []any{v3}) + tmp24 := lang.Apply(tmp19, []any{v9, tmp23}) + tmp15 = tmp24 + } + tmp5 = tmp15 break } } // end let - return v5 + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // send { - v0 := lang.NewSymbol("send").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Dispatch an action to an agent. Returns the agent immediately.\n Subsequently, in a thread from a thread pool, the state of the agent\n will be set to the value of:\n\n (apply action-fn state-of-agent args)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2109), lang.NewKeyword("end-line"), int(2109))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("send").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Dispatch an action to an agent. Returns the agent immediately.\n Subsequently, in a thread from a thread pool, the state of the agent\n will be set to the value of:\n\n (apply action-fn state-of-agent args)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2109), lang.NewKeyword("end-line"), int(2109))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 2 { @@ -71483,34 +71610,35 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.NewList(args[2:]...) - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("apply")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("apply")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) } - v8 := v7.Get() - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("send-via")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + tmp8 := tmp7.Get() + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("send-via")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) } - v11 := v10.Get() - v12 := lang.Apply(v8, []any{v11, nil, v3, v4, v5}) - return v12 + tmp11 := tmp10.Get() + tmp12 := lang.Apply(tmp8, []any{tmp11, nil, v3, v4, v5}) + return tmp12 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // send-off { - v0 := lang.NewSymbol("send-off").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Dispatch a potentially blocking action to an agent. Returns the\n agent immediately. Subsequently, in a separate thread, the state of\n the agent will be set to the value of:\n\n (apply action-fn state-of-agent args)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2120), lang.NewKeyword("end-line"), int(2120))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("send-off").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Dispatch a potentially blocking action to an agent. Returns the\n agent immediately. Subsequently, in a separate thread, the state of\n the agent will be set to the value of:\n\n (apply action-fn state-of-agent args)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2120), lang.NewKeyword("end-line"), int(2120))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 2 { @@ -71520,34 +71648,35 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.NewList(args[2:]...) - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("apply")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("apply")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) } - v8 := v7.Get() - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("send-via")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + tmp8 := tmp7.Get() + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("send-via")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) } - v11 := v10.Get() - v12 := lang.Apply(v8, []any{v11, nil, v3, v4, v5}) - return v12 + tmp11 := tmp10.Get() + tmp12 := lang.Apply(tmp8, []any{tmp11, nil, v3, v4, v5}) + return tmp12 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // send-via { - v0 := lang.NewSymbol("send-via").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("executor"), lang.NewSymbol("a"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Dispatch an action to an agent. Returns the agent immediately.\n Subsequently, in a thread supplied by executor, the state of the agent\n will be set to the value of:\n\n (apply action-fn state-of-agent args)", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2099), lang.NewKeyword("end-line"), int(2099))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("send-via").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("executor"), lang.NewSymbol("a"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Dispatch an action to an agent. Returns the agent immediately.\n Subsequently, in a thread supplied by executor, the state of the agent\n will be set to the value of:\n\n (apply action-fn state-of-agent args)", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2099), lang.NewKeyword("end-line"), int(2099))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 3 { @@ -71559,277 +71688,281 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - var v7 any + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any { // let - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("push-thread-bindings")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("hash-map")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*agent*")) - v15 := lang.Apply(v13, []any{v14, v4}) - v16 := lang.Apply(v10, []any{v15}) - _ = v16 - var v17 any + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("push-thread-bindings")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("hash-map")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*agent*")) + tmp15 := lang.Apply(tmp13, []any{tmp14, v4}) + tmp16 := lang.Apply(tmp10, []any{tmp15}) + _ = tmp16 + var tmp17 any func() { defer func() { - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.Apply(v20, nil) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.Apply(tmp20, nil) + _ = tmp21 }() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("binding-conveyor-fn")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v5}) - v17 = v25 + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("binding-conveyor-fn")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.Apply(tmp24, []any{v5}) + tmp17 = tmp25 }() - v7 = v17 + tmp7 = tmp17 } // end let - v8, _ := lang.FieldOrMethod(v4, "dispatch") - if reflect.TypeOf(v8).Kind() != reflect.Func { + tmp8, _ := lang.FieldOrMethod(v4, "dispatch") + if reflect.TypeOf(tmp8).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("dispatch is not a function"))) } - v9 := lang.Apply(v8, []any{v7, v6, v3}) - return v9 + tmp9 := lang.Apply(tmp8, []any{tmp7, v6, v3}) + return tmp9 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // seq { - v1 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() - v0 := lang.NewSymbol("seq").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a seq on the collection. If the collection is\n empty, returns nil. (seq nil) returns nil. seq also works on\n Strings, native Java arrays (of reference types) and any objects\n that implement Iterable. Note that seqs cache values, thus seq\n should not be used on any Iterable whose iterator repeatedly\n returns the same mutable object.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(4), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(126), lang.NewKeyword("end-line"), int(136))).(*lang.Symbol) - var v3 lang.FnFunc + tmp1 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() + tmp0 := lang.NewSymbol("seq").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a seq on the collection. If the collection is\n empty, returns nil. (seq nil) returns nil. seq also works on\n Strings, native Java arrays (of reference types) and any objects\n that implement Iterable. Note that seqs cache values, thus seq\n should not be used on any Iterable whose iterator repeatedly\n returns the same mutable object.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(4), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(126), lang.NewKeyword("end-line"), int(136))).(*lang.Symbol) + var tmp3 lang.FnFunc { // function seq - v3 = lang.NewFnFunc(func(args ...any) any { + var v4 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v5 := args[0] _ = v5 - v6 := lang.Apply(lang.Seq, []any{v5}) - return v6 + tmp6 := lang.Apply(lang.Seq, []any{v5}) + return tmp6 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(136), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(136), lang.NewKeyword("end-column"), int(126))).(lang.FnFunc) - v4 := v3 + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(136), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(136), lang.NewKeyword("end-column"), int(126))).(lang.FnFunc) + v4 = tmp3 _ = v4 } - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // seq-to-map-for-destructuring { - v0 := lang.NewSymbol("seq-to-map-for-destructuring").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Builds a map from a seq as described in\n https://glojure.org/reference/special_forms#keyword-arguments", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(34), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4390), lang.NewKeyword("end-line"), int(4390))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("seq-to-map-for-destructuring").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Builds a map from a seq as described in\n https://glojure.org/reference/special_forms#keyword-arguments", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(34), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4390), lang.NewKeyword("end-line"), int(4390))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("next")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v3}) - if lang.IsTruthy(v8) { - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("to-array")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.Apply(v11, []any{v3}) - v13 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{v12}) - v4 = v13 + var tmp4 any + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("next")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v3}) + if lang.IsTruthy(tmp8) { + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("to-array")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.Apply(tmp11, []any{v3}) + tmp13 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{tmp12}) + tmp4 = tmp13 } else { - var v14 any - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("seq")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{v3}) - if lang.IsTruthy(v18) { - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("first")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{v3}) - v14 = v22 + var tmp14 any + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("seq")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{v3}) + if lang.IsTruthy(tmp18) { + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("first")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp14 = tmp22 } else { - v14 = nil } - v4 = v14 + tmp4 = tmp14 } - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // seq? { - v0 := lang.NewSymbol("seq?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x implements ISeq", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(146), lang.NewKeyword("end-line"), int(150))).(*lang.Symbol) - var v2 lang.FnFunc + tmp0 := lang.NewSymbol("seq?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x implements ISeq", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(146), lang.NewKeyword("end-line"), int(150))).(*lang.Symbol) + var tmp2 lang.FnFunc { // function seq? - v2 = lang.NewFnFunc(func(args ...any) any { + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{lang.ISeq, v4}) - return v8 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("instance?")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() + tmp9 := lang.Apply(tmp7, []any{tmp8, v4}) + return tmp9 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(150), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(150), lang.NewKeyword("end-column"), int(87))).(lang.FnFunc) - v3 := v2 + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(150), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(150), lang.NewKeyword("end-column"), int(87))).(lang.FnFunc) + v3 = tmp2 _ = v3 } - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // seqable? { - v0 := lang.NewSymbol("seqable?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if the seq function is supported for x", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6204), lang.NewKeyword("end-line"), int(6204))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("seqable?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if the seq function is supported for x", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6204), lang.NewKeyword("end-line"), int(6204))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.Apply(nil, []any{v3}) - return v4 + tmp4 := lang.Apply(nil, []any{v3}) + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // seque { - v0 := lang.NewSymbol("seque").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s")), lang.NewVector(lang.NewSymbol("n-or-q"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Creates a queued seq on another (presumably lazy) seq s. The queued\n seq will produce a concrete seq in the background, and can get up to\n n items ahead of the consumer. n-or-q can be an integer n buffer\n size, or an instance of java.util.concurrent BlockingQueue. Note\n that reading from a seque can block if the reader gets ahead of the\n producer.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5419), lang.NewKeyword("end-line"), int(5419))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("seque").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s")), lang.NewVector(lang.NewSymbol("n-or-q"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Creates a queued seq on another (presumably lazy) seq s. The queued\n seq will produce a concrete seq in the background, and can get up to\n n items ahead of the consumer. n-or-q can be an integer n buffer\n size, or an instance of java.util.concurrent BlockingQueue. Note\n that reading from a seque can block if the reader gets ahead of the\n producer.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5419), lang.NewKeyword("end-line"), int(5419))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seque")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.Apply(v6, []any{int64(100), v3}) - return v7 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seque")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.Apply(tmp6, []any{int64(100), v3}) + return tmp7 case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - var v5 any + var tmp5 any { // let // let binding "q" - var v6 any - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("instance?")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v9, []any{nil, v3}) - if lang.IsTruthy(v10) { - v6 = v3 + var tmp6 any + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("instance?")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp9, []any{nil, v3}) + if lang.IsTruthy(tmp10) { + tmp6 = v3 } else { - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("int")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("int")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{v3}) - v15 := lang.Apply(nil, []any{v14}) - v6 = v15 + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{v3}) + tmp15 := lang.Apply(nil, []any{tmp14}) + tmp6 = tmp15 } - var v16 any = v6 + var v16 any = tmp6 _ = v16 // let binding "NIL" - v17 := lang.Apply(reflect.StructOf, []any{nil}) - v18 := lang.Apply(reflect.New, []any{v17}) - v19, ok := lang.FieldOrMethod(v18, "Interface") + tmp17 := lang.Apply(reflect.StructOf, []any{nil}) + tmp18 := lang.Apply(reflect.New, []any{tmp17}) + tmp19, ok := lang.FieldOrMethod(tmp18, "Interface") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v18, "Interface"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp18, "Interface"))) } - var v20 any - switch reflect.TypeOf(v19).Kind() { + var tmp20 any + switch reflect.TypeOf(tmp19).Kind() { case reflect.Func: - v20 = lang.Apply(v19, nil) + tmp20 = lang.Apply(tmp19, nil) default: - v20 = v19 + tmp20 = tmp19 } - var v21 any = v20 + var v21 any = tmp20 _ = v21 // let binding "agt" - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("agent")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - var v25 lang.FnFunc - v25 = lang.NewFnFunc(func(args ...any) any { + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("agent")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + var tmp25 lang.FnFunc + tmp25 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } return v4 }) - v26 := lang.Apply(lang.NewLazySeq, []any{v25}) - v27 := lang.Apply(v24, []any{v26}) - var v28 any = v27 + tmp26 := lang.Apply(lang.NewLazySeq, []any{tmp25}) + tmp27 := lang.Apply(tmp24, []any{tmp26}) + var v28 any = tmp27 _ = v28 // let binding "log-error" - var v29 lang.FnFunc - v29 = lang.NewFnFunc(func(args ...any) any { + var tmp29 lang.FnFunc + tmp29 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -71837,106 +71970,106 @@ func init() { _ = v30 v31 := args[1] _ = v31 - var v32 any - v33, _ := lang.FieldOrMethod(v30, "offer") - if reflect.TypeOf(v33).Kind() != reflect.Func { + var tmp32 any + tmp33, _ := lang.FieldOrMethod(v30, "offer") + if reflect.TypeOf(tmp33).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("offer is not a function"))) } - v34 := lang.Apply(v33, []any{v30}) - if lang.IsTruthy(v34) { + tmp34 := lang.Apply(tmp33, []any{v30}) + if lang.IsTruthy(tmp34) { panic(v31) } else { - v32 = v31 + tmp32 = v31 } - return v32 + return tmp32 }) - v30 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5435), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(5438), lang.NewKeyword("end-column"), int(26)) - v31, err := lang.WithMeta(v29, v30.(lang.IPersistentMap)) + tmp30 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5435), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(5438), lang.NewKeyword("end-column"), int(26)) + tmp31, err := lang.WithMeta(tmp29, tmp30.(lang.IPersistentMap)) if err != nil { panic(err) } - var v32 any = v31 + var v32 any = tmp31 _ = v32 // let binding "fill" - var v33 lang.FnFunc - v33 = lang.NewFnFunc(func(args ...any) any { + var tmp33 lang.FnFunc + tmp33 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v34 := args[0] _ = v34 - var v35 any + var tmp35 any if lang.IsTruthy(v34) { - var v36 any - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("instance?")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.Apply(v39, []any{nil, v34}) - if lang.IsTruthy(v40) { - v41 := lang.Apply(v32, []any{v16, v34}) - v36 = v41 + var tmp36 any + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("instance?")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.Apply(tmp39, []any{nil, v34}) + if lang.IsTruthy(tmp40) { + tmp41 := lang.Apply(v32, []any{v16, v34}) + tmp36 = tmp41 } else { - var v42 any + var tmp42 any func() { defer func() { if r := recover(); r != nil { if lang.CatchMatches(r, lang.Builtins["any"]) { v43 := r _ = v43 - v44 := lang.Apply(v32, []any{v16, v43}) - v42 = v44 + tmp44 := lang.Apply(v32, []any{v16, v43}) + tmp42 = tmp44 } else { panic(r) } } }() - var v43 any + var tmp43 any { // let // let binding "G__89" - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("seq")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("seq")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) } - v46 := v45.Get() - v47 := lang.Apply(v46, []any{v34}) - var v48 any = v47 + tmp46 := tmp45.Get() + tmp47 := lang.Apply(tmp46, []any{v34}) + var v48 any = tmp47 _ = v48 // let binding "vec__90" var v49 any = v48 _ = v49 // let binding "seq__91" - v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v51 := v50.FindInternedVar(lang.NewSymbol("seq")) - if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) + tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp51 := tmp50.FindInternedVar(lang.NewSymbol("seq")) + if tmp51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) } - v52 := v51.Get() - v53 := lang.Apply(v52, []any{v49}) - var v54 any = v53 + tmp52 := tmp51.Get() + tmp53 := lang.Apply(tmp52, []any{v49}) + var v54 any = tmp53 _ = v54 // let binding "first__92" - v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v56 := v55.FindInternedVar(lang.NewSymbol("first")) - if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) + tmp55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp56 := tmp55.FindInternedVar(lang.NewSymbol("first")) + if tmp56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp56))) } - v57 := v56.Get() - v58 := lang.Apply(v57, []any{v54}) - var v59 any = v58 + tmp57 := tmp56.Get() + tmp58 := lang.Apply(tmp57, []any{v54}) + var v59 any = tmp58 _ = v59 // let binding "seq__91" - v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v61 := v60.FindInternedVar(lang.NewSymbol("next")) - if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) + tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp61 := tmp60.FindInternedVar(lang.NewSymbol("next")) + if tmp61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) } - v62 := v61.Get() - v63 := lang.Apply(v62, []any{v54}) - var v64 any = v63 + tmp62 := tmp61.Get() + tmp63 := lang.Apply(tmp62, []any{v54}) + var v64 any = tmp63 _ = v64 // let binding "x" var v65 any = v59 @@ -71947,46 +72080,46 @@ func init() { // let binding "s" var v67 any = v49 _ = v67 - var v68 any + var tmp68 any { // let // let binding "G__89" var v69 any = v48 _ = v69 for { - var v70 any + var tmp70 any { // let // let binding "vec__93" var v71 any = v69 _ = v71 // let binding "seq__94" - v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v73 := v72.FindInternedVar(lang.NewSymbol("seq")) - if v73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) + tmp72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp73 := tmp72.FindInternedVar(lang.NewSymbol("seq")) + if tmp73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp73))) } - v74 := v73.Get() - v75 := lang.Apply(v74, []any{v71}) - var v76 any = v75 + tmp74 := tmp73.Get() + tmp75 := lang.Apply(tmp74, []any{v71}) + var v76 any = tmp75 _ = v76 // let binding "first__95" - v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v78 := v77.FindInternedVar(lang.NewSymbol("first")) - if v78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) + tmp77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp78 := tmp77.FindInternedVar(lang.NewSymbol("first")) + if tmp78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp78))) } - v79 := v78.Get() - v80 := lang.Apply(v79, []any{v76}) - var v81 any = v80 + tmp79 := tmp78.Get() + tmp80 := lang.Apply(tmp79, []any{v76}) + var v81 any = tmp80 _ = v81 // let binding "seq__94" - v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v83 := v82.FindInternedVar(lang.NewSymbol("next")) - if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) + tmp82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp83 := tmp82.FindInternedVar(lang.NewSymbol("next")) + if tmp83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp83))) } - v84 := v83.Get() - v85 := lang.Apply(v84, []any{v76}) - var v86 any = v85 + tmp84 := tmp83.Get() + tmp85 := lang.Apply(tmp84, []any{v76}) + var v86 any = tmp85 _ = v86 // let binding "x" var v87 any = v81 @@ -71997,264 +72130,261 @@ func init() { // let binding "s" var v89 any = v71 _ = v89 - var v90 any + var tmp90 any if lang.IsTruthy(v89) { - var v91 any - var v92 any - v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v94 := v93.FindInternedVar(lang.NewSymbol("nil?")) - if v94.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) + var tmp91 any + var tmp92 any + tmp93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp94 := tmp93.FindInternedVar(lang.NewSymbol("nil?")) + if tmp94.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp94))) } - v95 := v94.Get() - v96 := lang.Apply(v95, []any{v87}) - if lang.IsTruthy(v96) { - v92 = v21 + tmp95 := tmp94.Get() + tmp96 := lang.Apply(tmp95, []any{v87}) + if lang.IsTruthy(tmp96) { + tmp92 = v21 } else { - v92 = v87 + tmp92 = v87 } - v97, _ := lang.FieldOrMethod(v16, "offer") - if reflect.TypeOf(v97).Kind() != reflect.Func { + tmp97, _ := lang.FieldOrMethod(v16, "offer") + if reflect.TypeOf(tmp97).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("offer is not a function"))) } - v98 := lang.Apply(v97, []any{v92}) - if lang.IsTruthy(v98) { - var v99 any = v88 - v69 = v99 + tmp98 := lang.Apply(tmp97, []any{tmp92}) + if lang.IsTruthy(tmp98) { + var tmp99 any = v88 + v69 = tmp99 continue } else { - v91 = v89 + tmp91 = v89 } - v90 = v91 + tmp90 = tmp91 } else { - var v100 any - v101, _ := lang.FieldOrMethod(v16, "offer") - if reflect.TypeOf(v101).Kind() != reflect.Func { + var tmp100 any + tmp101, _ := lang.FieldOrMethod(v16, "offer") + if reflect.TypeOf(tmp101).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("offer is not a function"))) } - v102 := lang.Apply(v101, []any{v16}) - if lang.IsTruthy(v102) { - v100 = nil + tmp102 := lang.Apply(tmp101, []any{v16}) + if lang.IsTruthy(tmp102) { } else { - v100 = lang.NewList() + tmp100 = lang.NewList() } - v90 = v100 + tmp90 = tmp100 } - v70 = v90 + tmp70 = tmp90 } // end let - v68 = v70 + tmp68 = tmp70 break } } // end let - v43 = v68 + tmp43 = tmp68 } // end let - v42 = v43 + tmp42 = tmp43 }() - v36 = v42 + tmp36 = tmp42 } - v35 = v36 + tmp35 = tmp36 } else { - v35 = nil } - return v35 + return tmp35 }) - v34 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5439), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(5452), lang.NewKeyword("end-column"), int(44)) - v35, err := lang.WithMeta(v33, v34.(lang.IPersistentMap)) + tmp34 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5439), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(5452), lang.NewKeyword("end-column"), int(44)) + tmp35, err := lang.WithMeta(tmp33, tmp34.(lang.IPersistentMap)) if err != nil { panic(err) } - var v36 any = v35 + var v36 any = tmp35 _ = v36 // let binding "drain" - var v37 lang.FnFunc + var tmp37 lang.FnFunc { // function drain - v37 = lang.NewFnFunc(func(args ...any) any { + var v38 lang.FnFunc + tmp37 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - var v39 lang.FnFunc - v39 = lang.NewFnFunc(func(args ...any) any { + var tmp39 lang.FnFunc + tmp39 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - var v40 any + var tmp40 any { // let // let binding "x" - v41, ok := lang.FieldOrMethod(v16, "take") + tmp41, ok := lang.FieldOrMethod(v16, "take") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v16, "take"))) } - var v42 any - switch reflect.TypeOf(v41).Kind() { + var tmp42 any + switch reflect.TypeOf(tmp41).Kind() { case reflect.Func: - v42 = lang.Apply(v41, nil) + tmp42 = lang.Apply(tmp41, nil) default: - v42 = v41 + tmp42 = tmp41 } - var v43 any = v42 + var v43 any = tmp42 _ = v43 - var v44 any - v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v46 := v45.FindInternedVar(lang.NewSymbol("identical?")) - if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) + var tmp44 any + tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp46 := tmp45.FindInternedVar(lang.NewSymbol("identical?")) + if tmp46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) } - v47 := v46.Get() - v48 := lang.Apply(v47, []any{v43, v16}) - if lang.IsTruthy(v48) { - v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v50 := v49.FindInternedVar(lang.NewSymbol("deref")) - if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) + tmp47 := tmp46.Get() + tmp48 := lang.Apply(tmp47, []any{v43, v16}) + if lang.IsTruthy(tmp48) { + tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp50 := tmp49.FindInternedVar(lang.NewSymbol("deref")) + if tmp50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) } - v51 := v50.Get() - v52 := lang.Apply(v51, []any{v28}) - _ = v52 - v44 = nil + tmp51 := tmp50.Get() + tmp52 := lang.Apply(tmp51, []any{v28}) + _ = tmp52 } else { - v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v54 := v53.FindInternedVar(lang.NewSymbol("send-off")) - if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) + tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp54 := tmp53.FindInternedVar(lang.NewSymbol("send-off")) + if tmp54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) } - v55 := v54.Get() - v56 := lang.Apply(v55, []any{v28, v36}) - _ = v56 - v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v58 := v57.FindInternedVar(lang.NewSymbol("release-pending-sends")) - if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) + tmp55 := tmp54.Get() + tmp56 := lang.Apply(tmp55, []any{v28, v36}) + _ = tmp56 + tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp58 := tmp57.FindInternedVar(lang.NewSymbol("release-pending-sends")) + if tmp58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) } - v59 := v58.Get() - v60 := lang.Apply(v59, nil) - _ = v60 - v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v62 := v61.FindInternedVar(lang.NewSymbol("cons")) - if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) + tmp59 := tmp58.Get() + tmp60 := lang.Apply(tmp59, nil) + _ = tmp60 + tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp62 := tmp61.FindInternedVar(lang.NewSymbol("cons")) + if tmp62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) } - v63 := v62.Get() - var v64 any - v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v66 := v65.FindInternedVar(lang.NewSymbol("identical?")) - if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) + tmp63 := tmp62.Get() + var tmp64 any + tmp65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp66 := tmp65.FindInternedVar(lang.NewSymbol("identical?")) + if tmp66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp66))) } - v67 := v66.Get() - v68 := lang.Apply(v67, []any{v43, v21}) - if lang.IsTruthy(v68) { - v64 = nil + tmp67 := tmp66.Get() + tmp68 := lang.Apply(tmp67, []any{v43, v21}) + if lang.IsTruthy(tmp68) { } else { - v64 = v43 + tmp64 = v43 } - v69 := lang.Apply(v38, nil) - v70 := lang.Apply(v63, []any{v64, v69}) - v44 = v70 + tmp69 := lang.Apply(v38, nil) + tmp70 := lang.Apply(tmp63, []any{tmp64, tmp69}) + tmp44 = tmp70 } - v40 = v44 + tmp40 = tmp44 } // end let - return v40 + return tmp40 }) - v40 := lang.Apply(lang.NewLazySeq, []any{v39}) - return v40 + tmp40 := lang.Apply(lang.NewLazySeq, []any{tmp39}) + return tmp40 }) - v38 := v37 + v38 = tmp37 _ = v38 } - v38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5453), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(5461), lang.NewKeyword("end-column"), int(73)) - v39, err := lang.WithMeta(v37, v38.(lang.IPersistentMap)) + tmp38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5453), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(5461), lang.NewKeyword("end-column"), int(73)) + tmp39, err := lang.WithMeta(tmp37, tmp38.(lang.IPersistentMap)) if err != nil { panic(err) } - var v40 any = v39 + var v40 any = tmp39 _ = v40 - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("send-off")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) - } - v43 := v42.Get() - v44 := lang.Apply(v43, []any{v28, v36}) - _ = v44 - v45 := lang.Apply(v40, nil) - v5 = v45 + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("send-off")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := lang.Apply(tmp43, []any{v28, v36}) + _ = tmp44 + tmp45 := lang.Apply(v40, nil) + tmp5 = tmp45 } // end let - return v5 + return tmp5 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // sequence { - v0 := lang.NewSymbol("sequence").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("coll"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Coerces coll to a (possibly empty) sequence, if it is not already\n one. Will not force a lazy seq. (sequence nil) yields (), When a\n transducer is supplied, returns a lazy sequence of applications of\n the transform to the items in coll(s), i.e. to the set of first\n items of each coll, followed by the set of second\n items in each coll, until any one of the colls is exhausted. Any\n remaining items in other colls are ignored. The transform should accept\n number-of-colls arguments", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2639), lang.NewKeyword("end-line"), int(2639))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("sequence").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("coll"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Coerces coll to a (possibly empty) sequence, if it is not already\n one. Will not force a lazy seq. (sequence nil) yields (), When a\n transducer is supplied, returns a lazy sequence of applications of\n the transform to the items in coll(s), i.e. to the set of first\n items of each coll, followed by the set of second\n items in each coll, until any one of the colls is exhausted. Any\n remaining items in other colls are ignored. The transform should accept\n number-of-colls arguments", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2639), lang.NewKeyword("end-line"), int(2639))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - var v4 any - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("seq?")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v3}) - if lang.IsTruthy(v8) { - v4 = v3 + var tmp4 any + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq?")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v3}) + if lang.IsTruthy(tmp8) { + tmp4 = v3 } else { - var v9 any + var tmp9 any { // let // let binding "or__0__auto__" - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("seq")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{v3}) - var v14 any = v13 + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("seq")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{v3}) + var v14 any = tmp13 _ = v14 - var v15 any + var tmp15 any if lang.IsTruthy(v14) { - v15 = v14 + tmp15 = v14 } else { - v15 = lang.NewList() + tmp15 = lang.NewList() } - v9 = v15 + tmp9 = tmp15 } // end let - v4 = v9 + tmp4 = tmp9 } - return v4 + return tmp4 case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - var v5 any + var tmp5 any { // let // let binding "or__0__auto__" - v6 := lang.Apply(nil, []any{v4}) - v7 := lang.Apply(nil, []any{v3, v6}) - v8 := lang.Apply(nil, []any{v7}) - var v9 any = v8 + tmp6 := lang.Apply(nil, []any{v4}) + tmp7 := lang.Apply(nil, []any{v3, tmp6}) + tmp8 := lang.Apply(nil, []any{tmp7}) + var v9 any = tmp8 _ = v9 - var v10 any + var tmp10 any if lang.IsTruthy(v9) { - v10 = v9 + tmp10 = v9 } else { - v10 = lang.NewList() + tmp10 = lang.NewList() } - v5 = v10 + tmp5 = tmp10 } // end let - return v5 + return tmp5 default: if len(args) < 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -72263,265 +72393,270 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.NewList(args[2:]...) - var v6 any + var v5 any = lang.NewList(args[2:]...) + _ = v5 + var tmp6 any { // let // let binding "or__0__auto__" - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("map")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - var v10 lang.FnFunc - v10 = lang.NewFnFunc(func(args ...any) any { + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("map")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v11 := args[0] _ = v11 - v12 := lang.Apply(nil, []any{v11}) - return v12 + tmp12 := lang.Apply(nil, []any{v11}) + return tmp12 }) - v11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2661), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(2661), lang.NewKeyword("end-column"), int(41)) - v12, err := lang.WithMeta(v10, v11.(lang.IPersistentMap)) + tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2661), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(2661), lang.NewKeyword("end-column"), int(41)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) if err != nil { panic(err) } - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("cons")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{v4, v5}) - v17 := lang.Apply(v9, []any{v12, v16}) - v18 := lang.Apply(nil, []any{v3, v17}) - v19 := lang.Apply(nil, []any{v18}) - var v20 any = v19 + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("cons")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{v4, v5}) + tmp17 := lang.Apply(tmp9, []any{tmp12, tmp16}) + tmp18 := lang.Apply(nil, []any{v3, tmp17}) + tmp19 := lang.Apply(nil, []any{tmp18}) + var v20 any = tmp19 _ = v20 - var v21 any + var tmp21 any if lang.IsTruthy(v20) { - v21 = v20 + tmp21 = v20 } else { - v21 = lang.NewList() + tmp21 = lang.NewList() } - v6 = v21 + tmp6 = tmp21 } // end let - return v6 + return tmp6 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // sequential? { - v0 := lang.NewSymbol("sequential?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements Sequential", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6229), lang.NewKeyword("end-line"), int(6229))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("sequential?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements Sequential", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6229), lang.NewKeyword("end-line"), int(6229))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) } - v6 := v5.Get() - v7 := lang.Apply(v6, []any{lang.Sequential, v3}) - return v7 + tmp6 := tmp5.Get() + tmp7 := reflect.TypeOf((*lang.Sequential)(nil)).Elem() + tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) + return tmp8 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // serialized-require { - v0 := lang.NewSymbol("serialized-require").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Like 'require', but serializes loading.\n Interim function preferred over 'require' for known asynchronous loads.\n Future changes may make these equivalent.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6059), lang.NewKeyword("end-line"), int(6059), lang.NewKeyword("private"), true)).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("serialized-require").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Like 'require', but serializes loading.\n Interim function preferred over 'require' for known asynchronous loads.\n Future changes may make these equivalent.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6059), lang.NewKeyword("end-line"), int(6059), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v3 := lang.NewList(args[0:]...) - var v4 any + var v3 any = lang.NewList(args[0:]...) + _ = v3 + var tmp4 any { // let // let binding "lockee__0__auto__" var v5 any = nil _ = v5 - var v6 any + var tmp6 any func() { - var v7 any + var tmp7 any { // let // let binding "locklocal__1__auto__" var v8 any = v5 _ = v8 - v9 := lang.Apply(nil, []any{v8}) - _ = v9 - var v10 any + tmp9 := lang.Apply(nil, []any{v8}) + _ = tmp9 + var tmp10 any func() { defer func() { - v11 := lang.Apply(nil, []any{v8}) + tmp11 := lang.Apply(nil, []any{v8}) + _ = tmp11 }() - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("apply")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("apply")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) } - v14 := v13.Get() - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("require")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + tmp14 := tmp13.Get() + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("require")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) } - v17 := v16.Get() - v18 := lang.Apply(v14, []any{v17, v3}) - v10 = v18 + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp14, []any{tmp17, v3}) + tmp10 = tmp18 }() - v7 = v10 + tmp7 = tmp10 } // end let - v6 = v7 + tmp6 = tmp7 }() - v4 = v6 + tmp4 = tmp6 } // end let - return v4 + return tmp4 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // set { - v0 := lang.NewSymbol("set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a set of the distinct elements of coll.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4104), lang.NewKeyword("end-line"), int(4104))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a set of the distinct elements of coll.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4104), lang.NewKeyword("end-line"), int(4104))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("set?")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v3}) - if lang.IsTruthy(v8) { - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("with-meta")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.Apply(v11, []any{v3, nil}) - v4 = v12 + var tmp4 any + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("set?")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v3}) + if lang.IsTruthy(tmp8) { + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("with-meta")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.Apply(tmp11, []any{v3, nil}) + tmp4 = tmp12 } else { - var v13 any - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("instance?")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.IReduceInit, v3}) - if lang.IsTruthy(v17) { - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("persistent!")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("conj!")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("transient")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.CreatePersistentTreeSet() - v28 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4112), lang.NewKeyword("column"), int(108), lang.NewKeyword("end-line"), int(4112), lang.NewKeyword("end-column"), int(110)) - v29, err := lang.WithMeta(v27, v28.(lang.IPersistentMap)) + var tmp13 any + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("instance?")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := reflect.TypeOf((*lang.IReduceInit)(nil)).Elem() + tmp18 := lang.Apply(tmp16, []any{tmp17, v3}) + if lang.IsTruthy(tmp18) { + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("persistent!")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("conj!")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("transient")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp29 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4112), lang.NewKeyword("column"), int(108), lang.NewKeyword("end-line"), int(4112), lang.NewKeyword("end-column"), int(110)) + tmp30, err := lang.WithMeta(tmp28, tmp29.(lang.IPersistentMap)) if err != nil { panic(err) } - v30 := lang.Apply(v26, []any{v29}) - v31, _ := lang.FieldOrMethod(v3, "ReduceInit") - if reflect.TypeOf(v31).Kind() != reflect.Func { + tmp31 := lang.Apply(tmp27, []any{tmp30}) + tmp32, _ := lang.FieldOrMethod(v3, "ReduceInit") + if reflect.TypeOf(tmp32).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) } - v32 := lang.Apply(v31, []any{v23, v30}) - v33 := lang.Apply(v20, []any{v32}) - v13 = v33 + tmp33 := lang.Apply(tmp32, []any{tmp24, tmp31}) + tmp34 := lang.Apply(tmp21, []any{tmp33}) + tmp13 = tmp34 } else { - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("persistent!")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) - } - v36 := v35.Get() - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("reduce1")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("conj!")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) - } - v42 := v41.Get() - v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v44 := v43.FindInternedVar(lang.NewSymbol("transient")) - if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) - } - v45 := v44.Get() - v46 := lang.CreatePersistentTreeSet() - v47 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4113), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(4113), lang.NewKeyword("end-column"), int(48)) - v48, err := lang.WithMeta(v46, v47.(lang.IPersistentMap)) + tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp36 := tmp35.FindInternedVar(lang.NewSymbol("persistent!")) + if tmp36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) + } + tmp37 := tmp36.Get() + tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp39 := tmp38.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) + } + tmp40 := tmp39.Get() + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("conj!")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("transient")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) + } + tmp46 := tmp45.Get() + tmp47 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp48 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4113), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(4113), lang.NewKeyword("end-column"), int(48)) + tmp49, err := lang.WithMeta(tmp47, tmp48.(lang.IPersistentMap)) if err != nil { panic(err) } - v49 := lang.Apply(v45, []any{v48}) - v50 := lang.Apply(v39, []any{v42, v49, v3}) - v51 := lang.Apply(v36, []any{v50}) - v13 = v51 + tmp50 := lang.Apply(tmp46, []any{tmp49}) + tmp51 := lang.Apply(tmp40, []any{tmp43, tmp50, v3}) + tmp52 := lang.Apply(tmp37, []any{tmp51}) + tmp13 = tmp52 } - v4 = v13 + tmp4 = tmp13 } - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // set-agent-send-executor! { - v0 := lang.NewSymbol("set-agent-send-executor!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("executor"))), lang.NewKeyword("doc"), "Sets the ExecutorService to be used by send", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(30), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2087), lang.NewKeyword("end-line"), int(2087))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("set-agent-send-executor!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("executor"))), lang.NewKeyword("doc"), "Sets the ExecutorService to be used by send", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(30), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2087), lang.NewKeyword("end-line"), int(2087))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -72529,17 +72664,17 @@ func init() { _ = v3 return nil }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // set-agent-send-off-executor! { - v0 := lang.NewSymbol("set-agent-send-off-executor!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("executor"))), lang.NewKeyword("doc"), "Sets the ExecutorService to be used by send-off", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(34), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2093), lang.NewKeyword("end-line"), int(2093))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("set-agent-send-off-executor!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("executor"))), lang.NewKeyword("doc"), "Sets the ExecutorService to be used by send-off", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(34), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2093), lang.NewKeyword("end-line"), int(2093))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -72547,17 +72682,17 @@ func init() { _ = v3 return nil }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // set-error-handler! { - v0 := lang.NewSymbol("set-error-handler!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("handler-fn"))), lang.NewKeyword("doc"), "Sets the error-handler of agent a to handler-fn. If an action\n being run by the agent throws an exception or doesn't pass the\n validator fn, handler-fn will be called with two arguments: the\n agent and the exception.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2192), lang.NewKeyword("end-line"), int(2192))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("set-error-handler!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("handler-fn"))), lang.NewKeyword("doc"), "Sets the error-handler of agent a to handler-fn. If an action\n being run by the agent throws an exception or doesn't pass the\n validator fn, handler-fn will be called with two arguments: the\n agent and the exception.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2192), lang.NewKeyword("end-line"), int(2192))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -72565,24 +72700,24 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5, _ := lang.FieldOrMethod(v3, "setErrorHandler") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(v3, "setErrorHandler") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorHandler is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // set-error-mode! { - v0 := lang.NewSymbol("set-error-mode!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("mode-keyword"))), lang.NewKeyword("doc"), "Sets the error-mode of agent a to mode-keyword, which must be\n either :fail or :continue. If an action being run by the agent\n throws an exception or doesn't pass the validator fn, an\n error-handler may be called (see set-error-handler!), after which,\n if the mode is :continue, the agent will continue as if neither the\n action that caused the error nor the error itself ever happened.\n \n If the mode is :fail, the agent will become failed and will stop\n accepting new 'send' and 'send-off' actions, and any previously\n queued actions will be held until a 'restart-agent'. Deref will\n still work, returning the state of the agent before the error.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2210), lang.NewKeyword("end-line"), int(2210))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("set-error-mode!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("mode-keyword"))), lang.NewKeyword("doc"), "Sets the error-mode of agent a to mode-keyword, which must be\n either :fail or :continue. If an action being run by the agent\n throws an exception or doesn't pass the validator fn, an\n error-handler may be called (see set-error-handler!), after which,\n if the mode is :continue, the agent will continue as if neither the\n action that caused the error nor the error itself ever happened.\n \n If the mode is :fail, the agent will become failed and will stop\n accepting new 'send' and 'send-off' actions, and any previously\n queued actions will be held until a 'restart-agent'. Deref will\n still work, returning the state of the agent before the error.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2210), lang.NewKeyword("end-line"), int(2210))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -72590,24 +72725,24 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5, _ := lang.FieldOrMethod(v3, "setErrorMode") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(v3, "setErrorMode") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorMode is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // set-validator! { - v0 := lang.NewSymbol("set-validator!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("iref"), lang.NewSymbol("validator-fn"))), lang.NewKeyword("doc"), "Sets the validator-fn for a var/ref/agent/atom. validator-fn must be nil or a\n side-effect-free fn of one argument, which will be passed the intended\n new state on any state change. If the new state is unacceptable, the\n validator-fn should return false or throw an exception. If the current state (root\n value if var) is not acceptable to the new validator, an exception\n will be thrown and the validator will not be changed.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2381), lang.NewKeyword("end-line"), int(2381))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("set-validator!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("iref"), lang.NewSymbol("validator-fn"))), lang.NewKeyword("doc"), "Sets the validator-fn for a var/ref/agent/atom. validator-fn must be nil or a\n side-effect-free fn of one argument, which will be passed the intended\n new state on any state change. If the new state is unacceptable, the\n validator-fn should return false or throw an exception. If the current state (root\n value if var) is not acceptable to the new validator, an exception\n will be thrown and the validator will not be changed.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2381), lang.NewKeyword("end-line"), int(2381))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -72615,49 +72750,50 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5, _ := lang.FieldOrMethod(v3, "setValidator") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(v3, "setValidator") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("setValidator is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // set? { - v0 := lang.NewSymbol("set?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements IPersistentSet", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4098), lang.NewKeyword("end-line"), int(4098))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("set?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements IPersistentSet", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4098), lang.NewKeyword("end-line"), int(4098))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) } - v6 := v5.Get() - v7 := lang.Apply(v6, []any{lang.IPersistentSet, v3}) - return v7 + tmp6 := tmp5.Get() + tmp7 := reflect.TypeOf((*lang.IPersistentSet)(nil)).Elem() + tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) + return tmp8 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // setup-reference { - v0 := lang.NewSymbol("setup-reference").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2043), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(2044), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("r"), lang.NewSymbol("options"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("setup-reference").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2043), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(2044), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("r"), lang.NewSymbol("options"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -72665,67 +72801,65 @@ func init() { _ = v3 v4 := args[1] _ = v4 - var v5 any + var tmp5 any { // let // let binding "opts" - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("apply")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("hash-map")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.Apply(v8, []any{v11, v4}) - var v13 any = v12 + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("apply")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("hash-map")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.Apply(tmp8, []any{tmp11, v4}) + var v13 any = tmp12 _ = v13 - var v14 any - v15 := lang.Apply(lang.NewKeyword("meta"), []any{v13}) - if lang.IsTruthy(v15) { - v16 := lang.Apply(lang.NewKeyword("meta"), []any{v13}) - v17, _ := lang.FieldOrMethod(v3, "ResetMeta") - if reflect.TypeOf(v17).Kind() != reflect.Func { + var tmp14 any + tmp15 := lang.Apply(lang.NewKeyword("meta"), []any{v13}) + if lang.IsTruthy(tmp15) { + tmp16 := lang.Apply(lang.NewKeyword("meta"), []any{v13}) + tmp17, _ := lang.FieldOrMethod(v3, "ResetMeta") + if reflect.TypeOf(tmp17).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("ResetMeta is not a function"))) } - v18 := lang.Apply(v17, []any{v16}) - v14 = v18 + tmp18 := lang.Apply(tmp17, []any{tmp16}) + tmp14 = tmp18 } else { - v14 = nil } - _ = v14 - var v19 any - v20 := lang.Apply(lang.NewKeyword("validator"), []any{v13}) - if lang.IsTruthy(v20) { - v21 := lang.Apply(lang.NewKeyword("validator"), []any{v13}) - v22, _ := lang.FieldOrMethod(v3, "setValidator") - if reflect.TypeOf(v22).Kind() != reflect.Func { + _ = tmp14 + var tmp19 any + tmp20 := lang.Apply(lang.NewKeyword("validator"), []any{v13}) + if lang.IsTruthy(tmp20) { + tmp21 := lang.Apply(lang.NewKeyword("validator"), []any{v13}) + tmp22, _ := lang.FieldOrMethod(v3, "setValidator") + if reflect.TypeOf(tmp22).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("setValidator is not a function"))) } - v23 := lang.Apply(v22, []any{v21}) - v19 = v23 + tmp23 := lang.Apply(tmp22, []any{tmp21}) + tmp19 = tmp23 } else { - v19 = nil } - _ = v19 - v5 = v3 + _ = tmp19 + tmp5 = v3 } // end let - return v5 + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // shift-mask { - v0 := lang.NewSymbol("shift-mask").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6598), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(6598), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("shift"), lang.NewSymbol("mask"), lang.NewSymbol("x"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("shift-mask").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6598), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(6598), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("shift"), lang.NewSymbol("mask"), lang.NewSymbol("x"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -72735,931 +72869,936 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("bit-and")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("bit-and")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) } - v8 := v7.Get() - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("bit-shift-right")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + tmp8 := tmp7.Get() + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("bit-shift-right")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) } - v11 := v10.Get() - v12 := lang.Apply(v11, []any{v5, v3}) - v13 := lang.Apply(v8, []any{v12, v4}) - return v13 + tmp11 := tmp10.Get() + tmp12 := lang.Apply(tmp11, []any{v5, v3}) + tmp13 := lang.Apply(tmp8, []any{tmp12, v4}) + return tmp13 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // short { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function short__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("concat")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("list")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("seq")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("concat")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - var v30 any - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - if lang.IsTruthy(v33) { - v30 = lang.NewSymbol("uncheckedShortCast") + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + var tmp30 any + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + if lang.IsTruthy(tmp33) { + tmp30 = lang.NewSymbol("uncheckedShortCast") } else { - v30 = lang.NewSymbol("shortCast") - } - v34 := lang.Apply(v29, []any{v30}) - v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v36 := v35.FindInternedVar(lang.NewSymbol("list")) - if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) - } - v37 := v36.Get() - v38 := lang.Apply(v37, []any{v3}) - v39 := lang.Apply(v26, []any{v34, v38}) - v40 := lang.Apply(v23, []any{v39}) - v41 := lang.Apply(v20, []any{v40}) - v42 := lang.Apply(v9, []any{v13, v17, v41}) - v43 := lang.Apply(v6, []any{v42}) - return v43 + tmp30 = lang.NewSymbol("shortCast") + } + tmp34 := lang.Apply(tmp29, []any{tmp30}) + tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp36 := tmp35.FindInternedVar(lang.NewSymbol("list")) + if tmp36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) + } + tmp37 := tmp36.Get() + tmp38 := lang.Apply(tmp37, []any{v3}) + tmp39 := lang.Apply(tmp26, []any{tmp34, tmp38}) + tmp40 := lang.Apply(tmp23, []any{tmp39}) + tmp41 := lang.Apply(tmp20, []any{tmp40}) + tmp42 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp41}) + tmp43 := lang.Apply(tmp6, []any{tmp42}) + return tmp43 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("short").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to short", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3499), lang.NewKeyword("end-line"), int(3499))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("short").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to short", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3499), lang.NewKeyword("end-line"), int(3499))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5 := lang.Apply(lang.ShortCast, []any{v4}) - return v5 + tmp5 := lang.Apply(lang.ShortCast, []any{v4}) + return tmp5 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // short-array { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function short-array__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v3 := lang.NewList(args[0:]...) - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("concat")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("list")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/ShortArray")}) - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("list")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("seq")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("concat")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) - v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v36 := v35.FindInternedVar(lang.NewSymbol("list")) - if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) - } - v37 := v36.Get() - v38 := lang.Apply(v37, []any{lang.NewSymbol("glojure.core/args")}) - v39 := lang.Apply(v30, []any{v34, v38}) - v40 := lang.Apply(v27, []any{v39}) - v41 := lang.Apply(v24, []any{v40}) - v42 := lang.Apply(v9, []any{v13, v17, v21, v41}) - v43 := lang.Apply(v6, []any{v42}) - return v43 + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.Apply(tmp20, []any{lang.NewSymbol("glojure.core/ShortArray")}) + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("list")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("seq")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("concat")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) + tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp36 := tmp35.FindInternedVar(lang.NewSymbol("list")) + if tmp36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) + } + tmp37 := tmp36.Get() + tmp38 := lang.Apply(tmp37, []any{lang.NewSymbol("glojure.core/args")}) + tmp39 := lang.Apply(tmp30, []any{tmp34, tmp38}) + tmp40 := lang.Apply(tmp27, []any{tmp39}) + tmp41 := lang.Apply(tmp24, []any{tmp40}) + tmp42 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp21, tmp41}) + tmp43 := lang.Apply(tmp6, []any{tmp42}) + return tmp43 } }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("short-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Creates an array of shorts", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(int64(1), int64(2)), lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5333), lang.NewKeyword("end-line"), int(5333))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("short-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Creates an array of shorts", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5333), lang.NewKeyword("end-line"), int(5333))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v4 := args[0] _ = v4 - v5, _ := lang.FieldOrMethod(lang.Numbers, "ShortArray") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "ShortArray") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("ShortArray is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 case 2: v4 := args[0] _ = v4 v5 := args[1] _ = v5 - v6, _ := lang.FieldOrMethod(lang.Numbers, "ShortArrayInit") - if reflect.TypeOf(v6).Kind() != reflect.Func { + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "ShortArrayInit") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("ShortArrayInit is not a function"))) } - v7 := lang.Apply(v6, []any{v4, v5}) - return v7 + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // shorts { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function shorts - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("concat")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("list")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.Apply(v20, []any{lang.NewSymbol("glojure.core/Shorts")}) - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("list")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v3}) - v26 := lang.Apply(v9, []any{v13, v17, v21, v25}) - v27 := lang.Apply(v6, []any{v26}) - return v27 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.Apply(tmp20, []any{lang.NewSymbol("glojure.core/Shorts")}) + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("list")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.Apply(tmp24, []any{v3}) + tmp26 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp21, tmp25}) + tmp27 := lang.Apply(tmp6, []any{tmp26}) + return tmp27 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("shorts").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Casts to shorts[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5387), lang.NewKeyword("end-line"), int(5387))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("shorts").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Casts to shorts[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5387), lang.NewKeyword("end-line"), int(5387))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5, _ := lang.FieldOrMethod(lang.Numbers, "Shorts") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Shorts") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Shorts is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // shuffle { - v0 := lang.NewSymbol("shuffle").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return a random permutation of coll", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7300), lang.NewKeyword("end-line"), int(7300))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("shuffle").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return a random permutation of coll", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7300), lang.NewKeyword("end-line"), int(7300))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any + var tmp4 any { // let // let binding "al" - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("to-array")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v3}) - v9 := lang.Apply(lang.NewArrayList, []any{v8}) - var v10 any = v9 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("to-array")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v3}) + tmp9 := lang.Apply(lang.NewArrayList, []any{tmp8}) + var v10 any = tmp9 _ = v10 - v11 := lang.Apply(nil, []any{v10}) - _ = v11 - v12, ok := lang.FieldOrMethod(v10, "toArray") + tmp11 := lang.Apply(nil, []any{v10}) + _ = tmp11 + tmp12, ok := lang.FieldOrMethod(v10, "toArray") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v10, "toArray"))) } - var v13 any - switch reflect.TypeOf(v12).Kind() { + var tmp13 any + switch reflect.TypeOf(tmp12).Kind() { case reflect.Func: - v13 = lang.Apply(v12, nil) + tmp13 = lang.Apply(tmp12, nil) default: - v13 = v12 + tmp13 = tmp12 } - v14 := lang.Apply(nil, []any{v13}) - v4 = v14 + tmp14 := lang.Apply(nil, []any{tmp13}) + tmp4 = tmp14 } // end let - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // shutdown-agents { - v0 := lang.NewSymbol("shutdown-agents").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Initiates a shutdown of the thread pools that back the agent\n system. Running actions will complete, but no new actions will be\n accepted", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2252), lang.NewKeyword("end-line"), int(2252))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("shutdown-agents").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Initiates a shutdown of the thread pools that back the agent\n system. Running actions will complete, but no new actions will be\n accepted", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2252), lang.NewKeyword("end-line"), int(2252))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v3 := lang.Apply(lang.ShutdownAgents, nil) - return v3 + tmp3 := lang.Apply(lang.ShutdownAgents, nil) + return tmp3 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // sigs { - v0 := lang.NewSymbol("sigs").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(223), lang.NewKeyword("column"), int(2), lang.NewKeyword("end-line"), int(224), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("sigs").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(223), lang.NewKeyword("column"), int(2), lang.NewKeyword("end-line"), int(224), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("assert-valid-fdecl")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.Apply(v6, []any{v3}) - _ = v7 - var v8 any + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("assert-valid-fdecl")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.Apply(tmp6, []any{v3}) + _ = tmp7 + var tmp8 any { // let // let binding "asig" - var v9 lang.FnFunc - v9 = lang.NewFnFunc(func(args ...any) any { + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v10 := args[0] _ = v10 - var v11 any + var tmp11 any { // let // let binding "arglist" - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("first")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.Apply(v14, []any{v10}) - var v16 any = v15 + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("first")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.Apply(tmp14, []any{v10}) + var v16 any = tmp15 _ = v16 // let binding "arglist" - var v17 any - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("first")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.Apply(v20, []any{v16}) - v22 := lang.Apply(lang.Equals, []any{lang.NewSymbol("&form"), v21}) - if lang.IsTruthy(v22) { - v23 := lang.Apply(lang.Count, []any{v16}) - v24 := lang.Apply(lang.Subvec, []any{v16, int64(2), v23}) - v17 = v24 + var tmp17 any + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("first")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.Apply(tmp20, []any{v16}) + tmp22 := lang.Apply(lang.Equals, []any{lang.NewSymbol("&form"), tmp21}) + if lang.IsTruthy(tmp22) { + tmp23 := lang.Apply(lang.Count, []any{v16}) + tmp24 := lang.Apply(lang.Subvec, []any{v16, int64(2), tmp23}) + tmp17 = tmp24 } else { - v17 = v16 + tmp17 = v16 } - var v25 any = v17 + var v25 any = tmp17 _ = v25 // let binding "body" - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("next")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) - } - v28 := v27.Get() - v29 := lang.Apply(v28, []any{v10}) - var v30 any = v29 + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("next")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) + } + tmp28 := tmp27.Get() + tmp29 := lang.Apply(tmp28, []any{v10}) + var v30 any = tmp29 _ = v30 - var v31 any - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("map?")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v36 := v35.FindInternedVar(lang.NewSymbol("first")) - if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) - } - v37 := v36.Get() - v38 := lang.Apply(v37, []any{v30}) - v39 := lang.Apply(v34, []any{v38}) - if lang.IsTruthy(v39) { - var v40 any - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("next")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) - } - v43 := v42.Get() - v44 := lang.Apply(v43, []any{v30}) - if lang.IsTruthy(v44) { - v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v46 := v45.FindInternedVar(lang.NewSymbol("with-meta")) - if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) + var tmp31 any + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("map?")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp36 := tmp35.FindInternedVar(lang.NewSymbol("first")) + if tmp36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) + } + tmp37 := tmp36.Get() + tmp38 := lang.Apply(tmp37, []any{v30}) + tmp39 := lang.Apply(tmp34, []any{tmp38}) + if lang.IsTruthy(tmp39) { + var tmp40 any + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("next")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := lang.Apply(tmp43, []any{v30}) + if lang.IsTruthy(tmp44) { + tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp46 := tmp45.FindInternedVar(lang.NewSymbol("with-meta")) + if tmp46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) } - v47 := v46.Get() - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("conj")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) + tmp47 := tmp46.Get() + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("conj")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) } - v50 := v49.Get() - var v51 any - v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v53 := v52.FindInternedVar(lang.NewSymbol("meta")) - if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) + tmp50 := tmp49.Get() + var tmp51 any + tmp52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp53 := tmp52.FindInternedVar(lang.NewSymbol("meta")) + if tmp53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp53))) } - v54 := v53.Get() - v55 := lang.Apply(v54, []any{v25}) - if lang.IsTruthy(v55) { - v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v57 := v56.FindInternedVar(lang.NewSymbol("meta")) - if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) + tmp54 := tmp53.Get() + tmp55 := lang.Apply(tmp54, []any{v25}) + if lang.IsTruthy(tmp55) { + tmp56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp57 := tmp56.FindInternedVar(lang.NewSymbol("meta")) + if tmp57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp57))) } - v58 := v57.Get() - v59 := lang.Apply(v58, []any{v25}) - v51 = v59 + tmp58 := tmp57.Get() + tmp59 := lang.Apply(tmp58, []any{v25}) + tmp51 = tmp59 } else { - v60 := lang.NewMap() - v61 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(237), lang.NewKeyword("column"), int(77), lang.NewKeyword("end-line"), int(237), lang.NewKeyword("end-column"), int(78)) - v62, err := lang.WithMeta(v60, v61.(lang.IPersistentMap)) + tmp60 := lang.NewMap() + tmp61 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(237), lang.NewKeyword("column"), int(77), lang.NewKeyword("end-line"), int(237), lang.NewKeyword("end-column"), int(78)) + tmp62, err := lang.WithMeta(tmp60, tmp61.(lang.IPersistentMap)) if err != nil { panic(err) } - v51 = v62 + tmp51 = tmp62 } - v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v64 := v63.FindInternedVar(lang.NewSymbol("first")) - if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) + tmp63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp64 := tmp63.FindInternedVar(lang.NewSymbol("first")) + if tmp64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp64))) } - v65 := v64.Get() - v66 := lang.Apply(v65, []any{v30}) - v67 := lang.Apply(v50, []any{v51, v66}) - v68 := lang.Apply(v47, []any{v25, v67}) - v40 = v68 + tmp65 := tmp64.Get() + tmp66 := lang.Apply(tmp65, []any{v30}) + tmp67 := lang.Apply(tmp50, []any{tmp51, tmp66}) + tmp68 := lang.Apply(tmp47, []any{v25, tmp67}) + tmp40 = tmp68 } else { - v40 = v25 + tmp40 = v25 } - v31 = v40 + tmp31 = tmp40 } else { - v31 = v25 + tmp31 = v25 } - v11 = v31 + tmp11 = tmp31 } // end let - return v11 + return tmp11 }) - v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(228), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(239), lang.NewKeyword("end-column"), int(25)) - v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) + tmp10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(228), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(239), lang.NewKeyword("end-column"), int(25)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) if err != nil { panic(err) } - var v12 any = v11 + var v12 any = tmp11 _ = v12 // let binding "resolve-tag" - var v13 lang.FnFunc - v13 = lang.NewFnFunc(func(args ...any) any { + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v14 := args[0] _ = v14 - var v15 any + var tmp15 any { // let // let binding "m" - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("meta")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{v14}) - var v20 any = v19 + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("meta")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{v14}) + var v20 any = tmp19 _ = v20 // let binding "tag" - v21 := lang.Apply(lang.NewKeyword("tag"), []any{v20}) - var v22 any = v21 + tmp21 := lang.Apply(lang.NewKeyword("tag"), []any{v20}) + var v22 any = tmp21 _ = v22 - var v23 any - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("instance?")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.Apply(v26, []any{*lang.Symbol, v22}) - if lang.IsTruthy(v27) { - var v28 any - v29, ok := lang.FieldOrMethod(v22, "Name") + var tmp23 any + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("instance?")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := reflect.TypeOf((*lang.Symbol)(nil)) + tmp28 := lang.Apply(tmp26, []any{tmp27, v22}) + if lang.IsTruthy(tmp28) { + var tmp29 any + tmp30, ok := lang.FieldOrMethod(v22, "Name") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v22, "Name"))) } - var v30 any - switch reflect.TypeOf(v29).Kind() { + var tmp31 any + switch reflect.TypeOf(tmp30).Kind() { case reflect.Func: - v30 = lang.Apply(v29, nil) + tmp31 = lang.Apply(tmp30, nil) default: - v30 = v29 - } - v31 := lang.Apply(strings8.Index, []any{v30, "."}) - v32 := lang.Apply(lang.Equiv, []any{v31, int64(-1)}) - if lang.IsTruthy(v32) { - var v33 any - v34 := lang.Apply(lang.Equals, []any{nil, nil}) - if lang.IsTruthy(v34) { - var v35 any + tmp31 = tmp30 + } + tmp32 := lang.Apply(strings8.Index, []any{tmp31, "."}) + tmp33 := lang.Apply(lang.Equiv, []any{tmp32, int64(-1)}) + if lang.IsTruthy(tmp33) { + var tmp34 any + tmp35 := lang.Apply(lang.Equals, []any{nil, nil}) + if lang.IsTruthy(tmp35) { + var tmp36 any { // let // let binding "c" - var v36 any = nil - _ = v36 - var v37 any - if lang.IsTruthy(v36) { - v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v39 := v38.FindInternedVar(lang.NewSymbol("with-meta")) - if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + var v37 any = nil + _ = v37 + var tmp38 any + if lang.IsTruthy(v37) { + tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp40 := tmp39.FindInternedVar(lang.NewSymbol("with-meta")) + if tmp40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) } - v40 := v39.Get() - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("assoc")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + tmp41 := tmp40.Get() + tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp43 := tmp42.FindInternedVar(lang.NewSymbol("assoc")) + if tmp43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) } - v43 := v42.Get() - v44, ok := lang.FieldOrMethod(v36, "Name") + tmp44 := tmp43.Get() + tmp45, ok := lang.FieldOrMethod(v37, "Name") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v36, "Name"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v37, "Name"))) } - var v45 any - switch reflect.TypeOf(v44).Kind() { + var tmp46 any + switch reflect.TypeOf(tmp45).Kind() { case reflect.Func: - v45 = lang.Apply(v44, nil) + tmp46 = lang.Apply(tmp45, nil) default: - v45 = v44 + tmp46 = tmp45 } - v46 := lang.Apply(lang.NewSymbol, []any{v45}) - v47 := lang.Apply(v43, []any{v20, lang.NewKeyword("tag"), v46}) - v48 := lang.Apply(v40, []any{v14, v47}) - v37 = v48 + tmp47 := lang.Apply(lang.NewSymbol, []any{tmp46}) + tmp48 := lang.Apply(tmp44, []any{v20, lang.NewKeyword("tag"), tmp47}) + tmp49 := lang.Apply(tmp41, []any{v14, tmp48}) + tmp38 = tmp49 } else { - v37 = v14 + tmp38 = v14 } - v35 = v37 + tmp36 = tmp38 } // end let - v33 = v35 + tmp34 = tmp36 } else { - v33 = v14 + tmp34 = v14 } - v28 = v33 + tmp29 = tmp34 } else { - v28 = v14 + tmp29 = v14 } - v23 = v28 + tmp23 = tmp29 } else { - v23 = v14 + tmp23 = v14 } - v15 = v23 + tmp15 = tmp23 } // end let - return v15 + return tmp15 }) - v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(240), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(252), lang.NewKeyword("end-column"), int(37)) - v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) + tmp14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(240), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(252), lang.NewKeyword("end-column"), int(37)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) if err != nil { panic(err) } - var v16 any = v15 + var v16 any = tmp15 _ = v16 - var v17 any - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("seq?")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("first")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.Apply(v23, []any{v3}) - v25 := lang.Apply(v20, []any{v24}) - if lang.IsTruthy(v25) { - var v26 any + var tmp17 any + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("seq?")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("first")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.Apply(tmp23, []any{v3}) + tmp25 := lang.Apply(tmp20, []any{tmp24}) + if lang.IsTruthy(tmp25) { + var tmp26 any { // let // let binding "ret" - v27 := lang.NewVector() - v28 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(254), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(254), lang.NewKeyword("end-column"), int(20)) - v29, err := lang.WithMeta(v27, v28.(lang.IPersistentMap)) + tmp27 := lang.NewVector() + tmp28 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(254), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(254), lang.NewKeyword("end-column"), int(20)) + tmp29, err := lang.WithMeta(tmp27, tmp28.(lang.IPersistentMap)) if err != nil { panic(err) } - var v30 any = v29 + var v30 any = tmp29 _ = v30 // let binding "fdecls" var v31 any = v3 _ = v31 for { - var v32 any + var tmp32 any if lang.IsTruthy(v31) { - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("conj")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("conj")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) } - v36 := v35.Get() - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("first")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + tmp36 := tmp35.Get() + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("first")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) } - v39 := v38.Get() - v40 := lang.Apply(v39, []any{v31}) - v41 := lang.Apply(v12, []any{v40}) - v42 := lang.Apply(v16, []any{v41}) - v43 := lang.Apply(v36, []any{v30, v42}) - var v33 any = v43 - v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v46 := v45.FindInternedVar(lang.NewSymbol("next")) - if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) + tmp39 := tmp38.Get() + tmp40 := lang.Apply(tmp39, []any{v31}) + tmp41 := lang.Apply(v12, []any{tmp40}) + tmp42 := lang.Apply(v16, []any{tmp41}) + tmp43 := lang.Apply(tmp36, []any{v30, tmp42}) + var tmp33 any = tmp43 + tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp46 := tmp45.FindInternedVar(lang.NewSymbol("next")) + if tmp46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) } - v47 := v46.Get() - v48 := lang.Apply(v47, []any{v31}) - var v44 any = v48 - v30 = v33 - v31 = v44 + tmp47 := tmp46.Get() + tmp48 := lang.Apply(tmp47, []any{v31}) + var tmp44 any = tmp48 + v30 = tmp33 + v31 = tmp44 continue } else { - v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v50 := v49.FindInternedVar(lang.NewSymbol("seq")) - if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) + tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp50 := tmp49.FindInternedVar(lang.NewSymbol("seq")) + if tmp50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) } - v51 := v50.Get() - v52 := lang.Apply(v51, []any{v30}) - v32 = v52 + tmp51 := tmp50.Get() + tmp52 := lang.Apply(tmp51, []any{v30}) + tmp32 = tmp52 } - v26 = v32 + tmp26 = tmp32 break } } // end let - v17 = v26 + tmp17 = tmp26 } else { - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v12, []any{v3}) - v31 := lang.Apply(v16, []any{v30}) - v32 := lang.Apply(v29, []any{v31}) - v17 = v32 - } - v8 = v17 + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(v12, []any{v3}) + tmp31 := lang.Apply(v16, []any{tmp30}) + tmp32 := lang.Apply(tmp29, []any{tmp31}) + tmp17 = tmp32 + } + tmp8 = tmp17 } // end let - return v8 + return tmp8 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(225), lang.NewKeyword("column"), int(2), lang.NewKeyword("end-line"), int(258), lang.NewKeyword("end-column"), int(43))).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(225), lang.NewKeyword("column"), int(2), lang.NewKeyword("end-line"), int(258), lang.NewKeyword("end-column"), int(43))).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // simple-ident? { - v0 := lang.NewSymbol("simple-ident?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a symbol or keyword without a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1613), lang.NewKeyword("end-line"), int(1613))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("simple-ident?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a symbol or keyword without a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1613), lang.NewKeyword("end-line"), int(1613))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any + var tmp4 any { // let // let binding "and__0__auto__" - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("ident?")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v3}) - var v9 any = v8 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("ident?")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v3}) + var v9 any = tmp8 _ = v9 - var v10 any + var tmp10 any if lang.IsTruthy(v9) { - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("nil?")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("namespace")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{v3}) - v18 := lang.Apply(v13, []any{v17}) - v10 = v18 + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("nil?")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("namespace")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := lang.Apply(tmp13, []any{tmp17}) + tmp10 = tmp18 } else { - v10 = v9 + tmp10 = v9 } - v4 = v10 + tmp4 = tmp10 } // end let - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // simple-keyword? { - v0 := lang.NewSymbol("simple-keyword?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a keyword without a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1633), lang.NewKeyword("end-line"), int(1633))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("simple-keyword?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a keyword without a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1633), lang.NewKeyword("end-line"), int(1633))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any + var tmp4 any { // let // let binding "and__0__auto__" - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("keyword?")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v3}) - var v9 any = v8 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("keyword?")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v3}) + var v9 any = tmp8 _ = v9 - var v10 any + var tmp10 any if lang.IsTruthy(v9) { - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("nil?")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("namespace")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{v3}) - v18 := lang.Apply(v13, []any{v17}) - v10 = v18 + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("nil?")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("namespace")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := lang.Apply(tmp13, []any{tmp17}) + tmp10 = tmp18 } else { - v10 = v9 + tmp10 = v9 } - v4 = v10 + tmp4 = tmp10 } // end let - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // simple-symbol? { - v0 := lang.NewSymbol("simple-symbol?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a symbol without a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1623), lang.NewKeyword("end-line"), int(1623))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("simple-symbol?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a symbol without a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1623), lang.NewKeyword("end-line"), int(1623))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any + var tmp4 any { // let // let binding "and__0__auto__" - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("symbol?")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v3}) - var v9 any = v8 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("symbol?")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v3}) + var v9 any = tmp8 _ = v9 - var v10 any + var tmp10 any if lang.IsTruthy(v9) { - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("nil?")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("namespace")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{v3}) - v18 := lang.Apply(v13, []any{v17}) - v10 = v18 + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("nil?")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("namespace")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := lang.Apply(tmp13, []any{tmp17}) + tmp10 = tmp18 } else { - v10 = v9 + tmp10 = v9 } - v4 = v10 + tmp4 = tmp10 } // end let - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // slurp { - v1 := reflect.TypeOf("") - v0 := lang.NewSymbol("slurp").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("opts"))), lang.NewKeyword("doc"), "Opens a reader on f and reads all its contents, returning a string.\n See glojure.java.io/reader for a complete list of supported arguments.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6982), lang.NewKeyword("end-line"), int(6982))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp1 := reflect.TypeOf("") + tmp0 := lang.NewSymbol("slurp").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("opts"))), lang.NewKeyword("doc"), "Opens a reader on f and reads all its contents, returning a string.\n See glojure.java.io/reader for a complete list of supported arguments.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6982), lang.NewKeyword("end-line"), int(6982))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 1 { @@ -73667,85 +73806,87 @@ func init() { } v4 := args[0] _ = v4 - v5 := lang.NewList(args[1:]...) - var v6 any + var v5 any = lang.NewList(args[1:]...) + _ = v5 + var tmp6 any { // let // let binding "opts" - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("normalize-slurp-opts")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v9, []any{v5}) - var v11 any = v10 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("normalize-slurp-opts")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp9, []any{v5}) + var v11 any = tmp10 _ = v11 // let binding "sw" var v12 any = "unimplemented: new with non-constant class type" _ = v12 - var v13 any + var tmp13 any { // let // let binding "r" - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("apply")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.FindNamespace(lang.NewSymbol("glojure.go.io")) - v18 := v17.FindInternedVar(lang.NewSymbol("reader")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.Apply(v16, []any{v19, v4, v11}) - var v21 any = v20 + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("apply")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.go.io")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("reader")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.Apply(tmp16, []any{tmp19, v4, v11}) + var v21 any = tmp20 _ = v21 - var v22 any + var tmp22 any func() { defer func() { - v23, ok := lang.FieldOrMethod(v21, "close") + tmp23, ok := lang.FieldOrMethod(v21, "close") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v21, "close"))) } - var v24 any - switch reflect.TypeOf(v23).Kind() { + var tmp24 any + switch reflect.TypeOf(tmp23).Kind() { case reflect.Func: - v24 = lang.Apply(v23, nil) + tmp24 = lang.Apply(tmp23, nil) default: - v24 = v23 + tmp24 = tmp23 } + _ = tmp24 }() - v25 := lang.FindNamespace(lang.NewSymbol("glojure.go.io")) - v26 := v25.FindInternedVar(lang.NewSymbol("copy")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.Apply(v27, []any{v21, v12}) - _ = v28 - v29 := lang.Apply(lang.ToString, []any{v12}) - v22 = v29 + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.go.io")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("copy")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.Apply(tmp27, []any{v21, v12}) + _ = tmp28 + tmp29 := lang.Apply(lang.ToString, []any{v12}) + tmp22 = tmp29 }() - v13 = v22 + tmp13 = tmp22 } // end let - v6 = v13 + tmp6 = tmp13 } // end let - return v6 + return tmp6 } }) - v4 := reflect.TypeOf("") - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp4 := reflect.TypeOf("") + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // some { - v0 := lang.NewSymbol("some").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns the first logical true value of (pred x) for any x in coll,\n else nil. One common idiom is to use a set as pred, for example\n this will return :fred if :fred is in the sequence, otherwise nil:\n (some #{:fred} coll)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2684), lang.NewKeyword("end-line"), int(2684))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("some").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns the first logical true value of (pred x) for any x in coll,\n else nil. One common idiom is to use a set as pred, for example\n this will return :fred if :fred is in the sequence, otherwise nil:\n (some #{:fred} coll)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2684), lang.NewKeyword("end-line"), int(2684))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -73754,78 +73895,77 @@ func init() { v4 := args[1] _ = v4 recur_loop_481: - var v5 any + var tmp5 any { // let // let binding "temp__0__auto__" - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("seq")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{v4}) - var v10 any = v9 + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("seq")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.Apply(tmp8, []any{v4}) + var v10 any = tmp9 _ = v10 - var v11 any + var tmp11 any if lang.IsTruthy(v10) { - var v12 any + var tmp12 any { // let // let binding "s" var v13 any = v10 _ = v13 - var v14 any + var tmp14 any { // let // let binding "or__0__auto__" - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("first")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{v13}) - v19 := lang.Apply(v3, []any{v18}) - var v20 any = v19 + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("first")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{v13}) + tmp19 := lang.Apply(v3, []any{tmp18}) + var v20 any = tmp19 _ = v20 - var v21 any + var tmp21 any if lang.IsTruthy(v20) { - v21 = v20 + tmp21 = v20 } else { - var v22 any = v3 - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("next")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + var tmp22 any = v3 + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("next")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) } - v26 := v25.Get() - v27 := lang.Apply(v26, []any{v13}) - var v23 any = v27 - v3 = v22 - v4 = v23 + tmp26 := tmp25.Get() + tmp27 := lang.Apply(tmp26, []any{v13}) + var tmp23 any = tmp27 + v3 = tmp22 + v4 = tmp23 goto recur_loop_481 } - v14 = v21 + tmp14 = tmp21 } // end let - v12 = v14 + tmp12 = tmp14 } // end let - v11 = v12 + tmp11 = tmp12 } else { - v11 = nil } - v5 = v11 + tmp5 = tmp11 } // end let - return v5 + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // some-> { - v0 := lang.NewSymbol("some->").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "When expr is not nil, threads it into the first form (via ->),\n and when that result is not nil, through the next etc", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7610), lang.NewKeyword("end-line"), int(7610))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("some->").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "When expr is not nil, threads it into the first form (via ->),\n and when that result is not nil, through the next etc", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7610), lang.NewKeyword("end-line"), int(7610))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 3 { @@ -73837,281 +73977,282 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - var v7 any + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any { // let // let binding "g" - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("gensym")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, nil) - var v12 any = v11 + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("gensym")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, nil) + var v12 any = tmp11 _ = v12 // let binding "steps" - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("map")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - var v16 lang.FnFunc - v16 = lang.NewFnFunc(func(args ...any) any { + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("map")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + var tmp16 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v17 := args[0] _ = v17 - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("seq")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("concat")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("list")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.Apply(v26, []any{lang.NewSymbol("if")}) - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("list")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("seq")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("concat")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) - } - v36 := v35.Get() - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("list")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.Apply(v39, []any{lang.NewSymbol("glojure.core/nil?")}) - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("list")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) - } - v43 := v42.Get() - v44 := lang.Apply(v43, []any{v12}) - v45 := lang.Apply(v36, []any{v40, v44}) - v46 := lang.Apply(v33, []any{v45}) - v47 := lang.Apply(v30, []any{v46}) - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("list")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{nil}) - v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v53 := v52.FindInternedVar(lang.NewSymbol("list")) - if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) - } - v54 := v53.Get() - v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v56 := v55.FindInternedVar(lang.NewSymbol("seq")) - if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) - } - v57 := v56.Get() - v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v59 := v58.FindInternedVar(lang.NewSymbol("concat")) - if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) - } - v60 := v59.Get() - v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v62 := v61.FindInternedVar(lang.NewSymbol("list")) - if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) - } - v63 := v62.Get() - v64 := lang.Apply(v63, []any{lang.NewSymbol("glojure.core/->")}) - v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v66 := v65.FindInternedVar(lang.NewSymbol("list")) - if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) - } - v67 := v66.Get() - v68 := lang.Apply(v67, []any{v12}) - v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v70 := v69.FindInternedVar(lang.NewSymbol("list")) - if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) - } - v71 := v70.Get() - v72 := lang.Apply(v71, []any{v17}) - v73 := lang.Apply(v60, []any{v64, v68, v72}) - v74 := lang.Apply(v57, []any{v73}) - v75 := lang.Apply(v54, []any{v74}) - v76 := lang.Apply(v23, []any{v27, v47, v51, v75}) - v77 := lang.Apply(v20, []any{v76}) - return v77 + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("seq")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("concat")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("list")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.Apply(tmp26, []any{lang.NewSymbol("if")}) + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("list")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("seq")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("concat")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("list")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.Apply(tmp39, []any{lang.NewSymbol("glojure.core/nil?")}) + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("list")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := lang.Apply(tmp43, []any{v12}) + tmp45 := lang.Apply(tmp36, []any{tmp40, tmp44}) + tmp46 := lang.Apply(tmp33, []any{tmp45}) + tmp47 := lang.Apply(tmp30, []any{tmp46}) + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{nil}) + tmp52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp53 := tmp52.FindInternedVar(lang.NewSymbol("list")) + if tmp53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp53))) + } + tmp54 := tmp53.Get() + tmp55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp56 := tmp55.FindInternedVar(lang.NewSymbol("seq")) + if tmp56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp56))) + } + tmp57 := tmp56.Get() + tmp58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp59 := tmp58.FindInternedVar(lang.NewSymbol("concat")) + if tmp59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp59))) + } + tmp60 := tmp59.Get() + tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp62 := tmp61.FindInternedVar(lang.NewSymbol("list")) + if tmp62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) + } + tmp63 := tmp62.Get() + tmp64 := lang.Apply(tmp63, []any{lang.NewSymbol("glojure.core/->")}) + tmp65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp66 := tmp65.FindInternedVar(lang.NewSymbol("list")) + if tmp66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp66))) + } + tmp67 := tmp66.Get() + tmp68 := lang.Apply(tmp67, []any{v12}) + tmp69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp70 := tmp69.FindInternedVar(lang.NewSymbol("list")) + if tmp70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp70))) + } + tmp71 := tmp70.Get() + tmp72 := lang.Apply(tmp71, []any{v17}) + tmp73 := lang.Apply(tmp60, []any{tmp64, tmp68, tmp72}) + tmp74 := lang.Apply(tmp57, []any{tmp73}) + tmp75 := lang.Apply(tmp54, []any{tmp74}) + tmp76 := lang.Apply(tmp23, []any{tmp27, tmp47, tmp51, tmp75}) + tmp77 := lang.Apply(tmp20, []any{tmp76}) + return tmp77 }) - v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7616), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7616), lang.NewKeyword("end-column"), int(64)) - v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) + tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7616), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7616), lang.NewKeyword("end-column"), int(64)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) if err != nil { panic(err) } - v19 := lang.Apply(v15, []any{v18, v6}) - var v20 any = v19 + tmp19 := lang.Apply(tmp15, []any{tmp18, v6}) + var v20 any = tmp19 _ = v20 - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("seq")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("concat")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/let")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("apply")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) - } - v36 := v35.Get() - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("vector")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("seq")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) - } - v42 := v41.Get() - v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v44 := v43.FindInternedVar(lang.NewSymbol("concat")) - if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) - } - v45 := v44.Get() - v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v47 := v46.FindInternedVar(lang.NewSymbol("list")) - if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) - } - v48 := v47.Get() - v49 := lang.Apply(v48, []any{v12}) - v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v51 := v50.FindInternedVar(lang.NewSymbol("list")) - if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) - } - v52 := v51.Get() - v53 := lang.Apply(v52, []any{v5}) - v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v55 := v54.FindInternedVar(lang.NewSymbol("interleave")) - if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) - } - v56 := v55.Get() - v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v58 := v57.FindInternedVar(lang.NewSymbol("repeat")) - if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) - } - v59 := v58.Get() - v60 := lang.Apply(v59, []any{v12}) - v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v62 := v61.FindInternedVar(lang.NewSymbol("butlast")) - if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) - } - v63 := v62.Get() - v64 := lang.Apply(v63, []any{v20}) - v65 := lang.Apply(v56, []any{v60, v64}) - v66 := lang.Apply(v45, []any{v49, v53, v65}) - v67 := lang.Apply(v42, []any{v66}) - v68 := lang.Apply(v36, []any{v39, v67}) - v69 := lang.Apply(v33, []any{v68}) - v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v71 := v70.FindInternedVar(lang.NewSymbol("list")) - if v71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) - } - v72 := v71.Get() - var v73 any - v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v75 := v74.FindInternedVar(lang.NewSymbol("empty?")) - if v75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) - } - v76 := v75.Get() - v77 := lang.Apply(v76, []any{v20}) - if lang.IsTruthy(v77) { - v73 = v12 + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/let")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("apply")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("vector")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("seq")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) + } + tmp42 := tmp41.Get() + tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp44 := tmp43.FindInternedVar(lang.NewSymbol("concat")) + if tmp44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) + } + tmp45 := tmp44.Get() + tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp47 := tmp46.FindInternedVar(lang.NewSymbol("list")) + if tmp47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) + } + tmp48 := tmp47.Get() + tmp49 := lang.Apply(tmp48, []any{v12}) + tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp51 := tmp50.FindInternedVar(lang.NewSymbol("list")) + if tmp51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) + } + tmp52 := tmp51.Get() + tmp53 := lang.Apply(tmp52, []any{v5}) + tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp55 := tmp54.FindInternedVar(lang.NewSymbol("interleave")) + if tmp55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) + } + tmp56 := tmp55.Get() + tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp58 := tmp57.FindInternedVar(lang.NewSymbol("repeat")) + if tmp58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) + } + tmp59 := tmp58.Get() + tmp60 := lang.Apply(tmp59, []any{v12}) + tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp62 := tmp61.FindInternedVar(lang.NewSymbol("butlast")) + if tmp62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) + } + tmp63 := tmp62.Get() + tmp64 := lang.Apply(tmp63, []any{v20}) + tmp65 := lang.Apply(tmp56, []any{tmp60, tmp64}) + tmp66 := lang.Apply(tmp45, []any{tmp49, tmp53, tmp65}) + tmp67 := lang.Apply(tmp42, []any{tmp66}) + tmp68 := lang.Apply(tmp36, []any{tmp39, tmp67}) + tmp69 := lang.Apply(tmp33, []any{tmp68}) + tmp70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp71 := tmp70.FindInternedVar(lang.NewSymbol("list")) + if tmp71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp71))) + } + tmp72 := tmp71.Get() + var tmp73 any + tmp74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp75 := tmp74.FindInternedVar(lang.NewSymbol("empty?")) + if tmp75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp75))) + } + tmp76 := tmp75.Get() + tmp77 := lang.Apply(tmp76, []any{v20}) + if lang.IsTruthy(tmp77) { + tmp73 = v12 } else { - v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v79 := v78.FindInternedVar(lang.NewSymbol("last")) - if v79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) - } - v80 := v79.Get() - v81 := lang.Apply(v80, []any{v20}) - v73 = v81 - } - v82 := lang.Apply(v72, []any{v73}) - v83 := lang.Apply(v26, []any{v30, v69, v82}) - v84 := lang.Apply(v23, []any{v83}) - v7 = v84 + tmp78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp79 := tmp78.FindInternedVar(lang.NewSymbol("last")) + if tmp79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp79))) + } + tmp80 := tmp79.Get() + tmp81 := lang.Apply(tmp80, []any{v20}) + tmp73 = tmp81 + } + tmp82 := lang.Apply(tmp72, []any{tmp73}) + tmp83 := lang.Apply(tmp26, []any{tmp30, tmp69, tmp82}) + tmp84 := lang.Apply(tmp23, []any{tmp83}) + tmp7 = tmp84 } // end let - return v7 + return tmp7 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // some->> { - v0 := lang.NewSymbol("some->>").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "When expr is not nil, threads it into the first form (via ->>),\n and when that result is not nil, through the next etc", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7624), lang.NewKeyword("end-line"), int(7624))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("some->>").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "When expr is not nil, threads it into the first form (via ->>),\n and when that result is not nil, through the next etc", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7624), lang.NewKeyword("end-line"), int(7624))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 3 { @@ -74123,317 +74264,319 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - var v7 any + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any { // let // let binding "g" - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("gensym")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, nil) - var v12 any = v11 + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("gensym")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, nil) + var v12 any = tmp11 _ = v12 // let binding "steps" - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("map")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - var v16 lang.FnFunc - v16 = lang.NewFnFunc(func(args ...any) any { + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("map")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + var tmp16 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v17 := args[0] _ = v17 - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("seq")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("concat")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("list")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.Apply(v26, []any{lang.NewSymbol("if")}) - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("list")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("seq")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("concat")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) - } - v36 := v35.Get() - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("list")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.Apply(v39, []any{lang.NewSymbol("glojure.core/nil?")}) - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("list")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) - } - v43 := v42.Get() - v44 := lang.Apply(v43, []any{v12}) - v45 := lang.Apply(v36, []any{v40, v44}) - v46 := lang.Apply(v33, []any{v45}) - v47 := lang.Apply(v30, []any{v46}) - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("list")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{nil}) - v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v53 := v52.FindInternedVar(lang.NewSymbol("list")) - if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) - } - v54 := v53.Get() - v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v56 := v55.FindInternedVar(lang.NewSymbol("seq")) - if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) - } - v57 := v56.Get() - v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v59 := v58.FindInternedVar(lang.NewSymbol("concat")) - if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) - } - v60 := v59.Get() - v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v62 := v61.FindInternedVar(lang.NewSymbol("list")) - if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) - } - v63 := v62.Get() - v64 := lang.Apply(v63, []any{lang.NewSymbol("glojure.core/->>")}) - v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v66 := v65.FindInternedVar(lang.NewSymbol("list")) - if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) - } - v67 := v66.Get() - v68 := lang.Apply(v67, []any{v12}) - v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v70 := v69.FindInternedVar(lang.NewSymbol("list")) - if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) - } - v71 := v70.Get() - v72 := lang.Apply(v71, []any{v17}) - v73 := lang.Apply(v60, []any{v64, v68, v72}) - v74 := lang.Apply(v57, []any{v73}) - v75 := lang.Apply(v54, []any{v74}) - v76 := lang.Apply(v23, []any{v27, v47, v51, v75}) - v77 := lang.Apply(v20, []any{v76}) - return v77 + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("seq")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("concat")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("list")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.Apply(tmp26, []any{lang.NewSymbol("if")}) + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("list")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("seq")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("concat")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("list")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.Apply(tmp39, []any{lang.NewSymbol("glojure.core/nil?")}) + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("list")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := lang.Apply(tmp43, []any{v12}) + tmp45 := lang.Apply(tmp36, []any{tmp40, tmp44}) + tmp46 := lang.Apply(tmp33, []any{tmp45}) + tmp47 := lang.Apply(tmp30, []any{tmp46}) + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{nil}) + tmp52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp53 := tmp52.FindInternedVar(lang.NewSymbol("list")) + if tmp53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp53))) + } + tmp54 := tmp53.Get() + tmp55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp56 := tmp55.FindInternedVar(lang.NewSymbol("seq")) + if tmp56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp56))) + } + tmp57 := tmp56.Get() + tmp58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp59 := tmp58.FindInternedVar(lang.NewSymbol("concat")) + if tmp59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp59))) + } + tmp60 := tmp59.Get() + tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp62 := tmp61.FindInternedVar(lang.NewSymbol("list")) + if tmp62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) + } + tmp63 := tmp62.Get() + tmp64 := lang.Apply(tmp63, []any{lang.NewSymbol("glojure.core/->>")}) + tmp65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp66 := tmp65.FindInternedVar(lang.NewSymbol("list")) + if tmp66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp66))) + } + tmp67 := tmp66.Get() + tmp68 := lang.Apply(tmp67, []any{v12}) + tmp69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp70 := tmp69.FindInternedVar(lang.NewSymbol("list")) + if tmp70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp70))) + } + tmp71 := tmp70.Get() + tmp72 := lang.Apply(tmp71, []any{v17}) + tmp73 := lang.Apply(tmp60, []any{tmp64, tmp68, tmp72}) + tmp74 := lang.Apply(tmp57, []any{tmp73}) + tmp75 := lang.Apply(tmp54, []any{tmp74}) + tmp76 := lang.Apply(tmp23, []any{tmp27, tmp47, tmp51, tmp75}) + tmp77 := lang.Apply(tmp20, []any{tmp76}) + return tmp77 }) - v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7630), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7630), lang.NewKeyword("end-column"), int(65)) - v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) + tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7630), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7630), lang.NewKeyword("end-column"), int(65)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) if err != nil { panic(err) } - v19 := lang.Apply(v15, []any{v18, v6}) - var v20 any = v19 + tmp19 := lang.Apply(tmp15, []any{tmp18, v6}) + var v20 any = tmp19 _ = v20 - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("seq")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("concat")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/let")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("apply")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) - } - v36 := v35.Get() - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("vector")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("seq")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) - } - v42 := v41.Get() - v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v44 := v43.FindInternedVar(lang.NewSymbol("concat")) - if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) - } - v45 := v44.Get() - v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v47 := v46.FindInternedVar(lang.NewSymbol("list")) - if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) - } - v48 := v47.Get() - v49 := lang.Apply(v48, []any{v12}) - v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v51 := v50.FindInternedVar(lang.NewSymbol("list")) - if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) - } - v52 := v51.Get() - v53 := lang.Apply(v52, []any{v5}) - v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v55 := v54.FindInternedVar(lang.NewSymbol("interleave")) - if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) - } - v56 := v55.Get() - v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v58 := v57.FindInternedVar(lang.NewSymbol("repeat")) - if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) - } - v59 := v58.Get() - v60 := lang.Apply(v59, []any{v12}) - v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v62 := v61.FindInternedVar(lang.NewSymbol("butlast")) - if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) - } - v63 := v62.Get() - v64 := lang.Apply(v63, []any{v20}) - v65 := lang.Apply(v56, []any{v60, v64}) - v66 := lang.Apply(v45, []any{v49, v53, v65}) - v67 := lang.Apply(v42, []any{v66}) - v68 := lang.Apply(v36, []any{v39, v67}) - v69 := lang.Apply(v33, []any{v68}) - v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v71 := v70.FindInternedVar(lang.NewSymbol("list")) - if v71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) - } - v72 := v71.Get() - var v73 any - v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v75 := v74.FindInternedVar(lang.NewSymbol("empty?")) - if v75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) - } - v76 := v75.Get() - v77 := lang.Apply(v76, []any{v20}) - if lang.IsTruthy(v77) { - v73 = v12 + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/let")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("apply")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("vector")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("seq")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) + } + tmp42 := tmp41.Get() + tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp44 := tmp43.FindInternedVar(lang.NewSymbol("concat")) + if tmp44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) + } + tmp45 := tmp44.Get() + tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp47 := tmp46.FindInternedVar(lang.NewSymbol("list")) + if tmp47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) + } + tmp48 := tmp47.Get() + tmp49 := lang.Apply(tmp48, []any{v12}) + tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp51 := tmp50.FindInternedVar(lang.NewSymbol("list")) + if tmp51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) + } + tmp52 := tmp51.Get() + tmp53 := lang.Apply(tmp52, []any{v5}) + tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp55 := tmp54.FindInternedVar(lang.NewSymbol("interleave")) + if tmp55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) + } + tmp56 := tmp55.Get() + tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp58 := tmp57.FindInternedVar(lang.NewSymbol("repeat")) + if tmp58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) + } + tmp59 := tmp58.Get() + tmp60 := lang.Apply(tmp59, []any{v12}) + tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp62 := tmp61.FindInternedVar(lang.NewSymbol("butlast")) + if tmp62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) + } + tmp63 := tmp62.Get() + tmp64 := lang.Apply(tmp63, []any{v20}) + tmp65 := lang.Apply(tmp56, []any{tmp60, tmp64}) + tmp66 := lang.Apply(tmp45, []any{tmp49, tmp53, tmp65}) + tmp67 := lang.Apply(tmp42, []any{tmp66}) + tmp68 := lang.Apply(tmp36, []any{tmp39, tmp67}) + tmp69 := lang.Apply(tmp33, []any{tmp68}) + tmp70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp71 := tmp70.FindInternedVar(lang.NewSymbol("list")) + if tmp71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp71))) + } + tmp72 := tmp71.Get() + var tmp73 any + tmp74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp75 := tmp74.FindInternedVar(lang.NewSymbol("empty?")) + if tmp75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp75))) + } + tmp76 := tmp75.Get() + tmp77 := lang.Apply(tmp76, []any{v20}) + if lang.IsTruthy(tmp77) { + tmp73 = v12 } else { - v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v79 := v78.FindInternedVar(lang.NewSymbol("last")) - if v79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) - } - v80 := v79.Get() - v81 := lang.Apply(v80, []any{v20}) - v73 = v81 - } - v82 := lang.Apply(v72, []any{v73}) - v83 := lang.Apply(v26, []any{v30, v69, v82}) - v84 := lang.Apply(v23, []any{v83}) - v7 = v84 + tmp78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp79 := tmp78.FindInternedVar(lang.NewSymbol("last")) + if tmp79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp79))) + } + tmp80 := tmp79.Get() + tmp81 := lang.Apply(tmp80, []any{v20}) + tmp73 = tmp81 + } + tmp82 := lang.Apply(tmp72, []any{tmp73}) + tmp83 := lang.Apply(tmp26, []any{tmp30, tmp69, tmp82}) + tmp84 := lang.Apply(tmp23, []any{tmp83}) + tmp7 = tmp84 } // end let - return v7 + return tmp7 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // some-fn { - v0 := lang.NewSymbol("some-fn").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("p")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2"), lang.NewSymbol("p3")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2"), lang.NewSymbol("p3"), lang.NewSymbol("&"), lang.NewSymbol("ps"))), lang.NewKeyword("doc"), "Takes a set of predicates and returns a function f that returns the first logical true value\n returned by one of its composing predicates against any of its arguments, else it returns\n logical false. Note that f is short-circuiting in that it will stop execution on the first\n argument that triggers a logical true result against the original predicates.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7462), lang.NewKeyword("end-line"), int(7462))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("some-fn").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("p")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2"), lang.NewSymbol("p3")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2"), lang.NewSymbol("p3"), lang.NewSymbol("&"), lang.NewSymbol("ps"))), lang.NewKeyword("doc"), "Takes a set of predicates and returns a function f that returns the first logical true value\n returned by one of its composing predicates against any of its arguments, else it returns\n logical false. Note that f is short-circuiting in that it will stop execution on the first\n argument that triggers a logical true result against the original predicates.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7462), lang.NewKeyword("end-line"), int(7462))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - var v4 lang.FnFunc + var tmp4 lang.FnFunc { // function sp1 - v4 = lang.NewFnFunc(func(args ...any) any { + var v5 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: return nil case 1: v6 := args[0] _ = v6 - v7 := lang.Apply(v3, []any{v6}) - return v7 + tmp7 := lang.Apply(v3, []any{v6}) + return tmp7 case 2: v6 := args[0] _ = v6 v7 := args[1] _ = v7 - var v8 any + var tmp8 any { // let // let binding "or__0__auto__" - v9 := lang.Apply(v3, []any{v6}) - var v10 any = v9 + tmp9 := lang.Apply(v3, []any{v6}) + var v10 any = tmp9 _ = v10 - var v11 any + var tmp11 any if lang.IsTruthy(v10) { - v11 = v10 + tmp11 = v10 } else { - v12 := lang.Apply(v3, []any{v7}) - v11 = v12 + tmp12 := lang.Apply(v3, []any{v7}) + tmp11 = tmp12 } - v8 = v11 + tmp8 = tmp11 } // end let - return v8 + return tmp8 case 3: v6 := args[0] _ = v6 @@ -74441,36 +74584,36 @@ func init() { _ = v7 v8 := args[2] _ = v8 - var v9 any + var tmp9 any { // let // let binding "or__0__auto__" - v10 := lang.Apply(v3, []any{v6}) - var v11 any = v10 + tmp10 := lang.Apply(v3, []any{v6}) + var v11 any = tmp10 _ = v11 - var v12 any + var tmp12 any if lang.IsTruthy(v11) { - v12 = v11 + tmp12 = v11 } else { - var v13 any + var tmp13 any { // let // let binding "or__0__auto__" - v14 := lang.Apply(v3, []any{v7}) - var v15 any = v14 + tmp14 := lang.Apply(v3, []any{v7}) + var v15 any = tmp14 _ = v15 - var v16 any + var tmp16 any if lang.IsTruthy(v15) { - v16 = v15 + tmp16 = v15 } else { - v17 := lang.Apply(v3, []any{v8}) - v16 = v17 + tmp17 := lang.Apply(v3, []any{v8}) + tmp16 = tmp17 } - v13 = v16 + tmp13 = tmp16 } // end let - v12 = v13 + tmp12 = tmp13 } - v9 = v12 + tmp9 = tmp12 } // end let - return v9 + return tmp9 default: if len(args) < 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -74481,119 +74624,121 @@ func init() { _ = v7 v8 := args[2] _ = v8 - v9 := lang.NewList(args[3:]...) - var v10 any + var v9 any = lang.NewList(args[3:]...) + _ = v9 + var tmp10 any { // let // let binding "or__0__auto__" - v11 := lang.Apply(v5, []any{v6, v7, v8}) - var v12 any = v11 + tmp11 := lang.Apply(v5, []any{v6, v7, v8}) + var v12 any = tmp11 _ = v12 - var v13 any + var tmp13 any if lang.IsTruthy(v12) { - v13 = v12 + tmp13 = v12 } else { - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("some")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("some")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{v3, v9}) - v13 = v17 + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{v3, v9}) + tmp13 = tmp17 } - v10 = v13 + tmp10 = tmp13 } // end let - return v10 + return tmp10 } }) - v5 := v4 + v5 = tmp4 _ = v5 } - v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7469), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7475), lang.NewKeyword("end-column"), int(43)) - v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) + tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7469), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7475), lang.NewKeyword("end-column"), int(43)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) if err != nil { panic(err) } - return v6 + return tmp6 case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - var v5 lang.FnFunc + var tmp5 lang.FnFunc { // function sp2 - v5 = lang.NewFnFunc(func(args ...any) any { + var v6 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: return nil case 1: v7 := args[0] _ = v7 - var v8 any + var tmp8 any { // let // let binding "or__0__auto__" - v9 := lang.Apply(v3, []any{v7}) - var v10 any = v9 + tmp9 := lang.Apply(v3, []any{v7}) + var v10 any = tmp9 _ = v10 - var v11 any + var tmp11 any if lang.IsTruthy(v10) { - v11 = v10 + tmp11 = v10 } else { - v12 := lang.Apply(v4, []any{v7}) - v11 = v12 + tmp12 := lang.Apply(v4, []any{v7}) + tmp11 = tmp12 } - v8 = v11 + tmp8 = tmp11 } // end let - return v8 + return tmp8 case 2: v7 := args[0] _ = v7 v8 := args[1] _ = v8 - var v9 any + var tmp9 any { // let // let binding "or__0__auto__" - v10 := lang.Apply(v3, []any{v7}) - var v11 any = v10 + tmp10 := lang.Apply(v3, []any{v7}) + var v11 any = tmp10 _ = v11 - var v12 any + var tmp12 any if lang.IsTruthy(v11) { - v12 = v11 + tmp12 = v11 } else { - var v13 any + var tmp13 any { // let // let binding "or__0__auto__" - v14 := lang.Apply(v3, []any{v8}) - var v15 any = v14 + tmp14 := lang.Apply(v3, []any{v8}) + var v15 any = tmp14 _ = v15 - var v16 any + var tmp16 any if lang.IsTruthy(v15) { - v16 = v15 + tmp16 = v15 } else { - var v17 any + var tmp17 any { // let // let binding "or__0__auto__" - v18 := lang.Apply(v4, []any{v7}) - var v19 any = v18 + tmp18 := lang.Apply(v4, []any{v7}) + var v19 any = tmp18 _ = v19 - var v20 any + var tmp20 any if lang.IsTruthy(v19) { - v20 = v19 + tmp20 = v19 } else { - v21 := lang.Apply(v4, []any{v8}) - v20 = v21 + tmp21 := lang.Apply(v4, []any{v8}) + tmp20 = tmp21 } - v17 = v20 + tmp17 = tmp20 } // end let - v16 = v17 + tmp16 = tmp17 } - v13 = v16 + tmp13 = tmp16 } // end let - v12 = v13 + tmp12 = tmp13 } - v9 = v12 + tmp9 = tmp12 } // end let - return v9 + return tmp9 case 3: v7 := args[0] _ = v7 @@ -74601,78 +74746,78 @@ func init() { _ = v8 v9 := args[2] _ = v9 - var v10 any + var tmp10 any { // let // let binding "or__0__auto__" - v11 := lang.Apply(v3, []any{v7}) - var v12 any = v11 + tmp11 := lang.Apply(v3, []any{v7}) + var v12 any = tmp11 _ = v12 - var v13 any + var tmp13 any if lang.IsTruthy(v12) { - v13 = v12 + tmp13 = v12 } else { - var v14 any + var tmp14 any { // let // let binding "or__0__auto__" - v15 := lang.Apply(v3, []any{v8}) - var v16 any = v15 + tmp15 := lang.Apply(v3, []any{v8}) + var v16 any = tmp15 _ = v16 - var v17 any + var tmp17 any if lang.IsTruthy(v16) { - v17 = v16 + tmp17 = v16 } else { - var v18 any + var tmp18 any { // let // let binding "or__0__auto__" - v19 := lang.Apply(v3, []any{v9}) - var v20 any = v19 + tmp19 := lang.Apply(v3, []any{v9}) + var v20 any = tmp19 _ = v20 - var v21 any + var tmp21 any if lang.IsTruthy(v20) { - v21 = v20 + tmp21 = v20 } else { - var v22 any + var tmp22 any { // let // let binding "or__0__auto__" - v23 := lang.Apply(v4, []any{v7}) - var v24 any = v23 + tmp23 := lang.Apply(v4, []any{v7}) + var v24 any = tmp23 _ = v24 - var v25 any + var tmp25 any if lang.IsTruthy(v24) { - v25 = v24 + tmp25 = v24 } else { - var v26 any + var tmp26 any { // let // let binding "or__0__auto__" - v27 := lang.Apply(v4, []any{v8}) - var v28 any = v27 + tmp27 := lang.Apply(v4, []any{v8}) + var v28 any = tmp27 _ = v28 - var v29 any + var tmp29 any if lang.IsTruthy(v28) { - v29 = v28 + tmp29 = v28 } else { - v30 := lang.Apply(v4, []any{v9}) - v29 = v30 + tmp30 := lang.Apply(v4, []any{v9}) + tmp29 = tmp30 } - v26 = v29 + tmp26 = tmp29 } // end let - v25 = v26 + tmp25 = tmp26 } - v22 = v25 + tmp22 = tmp25 } // end let - v21 = v22 + tmp21 = tmp22 } - v18 = v21 + tmp18 = tmp21 } // end let - v17 = v18 + tmp17 = tmp18 } - v14 = v17 + tmp14 = tmp17 } // end let - v13 = v14 + tmp13 = tmp14 } - v10 = v13 + tmp10 = tmp13 } // end let - return v10 + return tmp10 default: if len(args) < 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -74683,69 +74828,70 @@ func init() { _ = v8 v9 := args[2] _ = v9 - v10 := lang.NewList(args[3:]...) - var v11 any + var v10 any = lang.NewList(args[3:]...) + _ = v10 + var tmp11 any { // let // let binding "or__0__auto__" - v12 := lang.Apply(v6, []any{v7, v8, v9}) - var v13 any = v12 + tmp12 := lang.Apply(v6, []any{v7, v8, v9}) + var v13 any = tmp12 _ = v13 - var v14 any + var tmp14 any if lang.IsTruthy(v13) { - v14 = v13 + tmp14 = v13 } else { - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("some")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("some")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) } - v17 := v16.Get() - var v18 lang.FnFunc - v18 = lang.NewFnFunc(func(args ...any) any { + tmp17 := tmp16.Get() + var tmp18 lang.FnFunc + tmp18 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v19 := args[0] _ = v19 - var v20 any + var tmp20 any { // let // let binding "or__0__auto__" - v21 := lang.Apply(v3, []any{v19}) - var v22 any = v21 + tmp21 := lang.Apply(v3, []any{v19}) + var v22 any = tmp21 _ = v22 - var v23 any + var tmp23 any if lang.IsTruthy(v22) { - v23 = v22 + tmp23 = v22 } else { - v24 := lang.Apply(v4, []any{v19}) - v23 = v24 + tmp24 := lang.Apply(v4, []any{v19}) + tmp23 = tmp24 } - v20 = v23 + tmp20 = tmp23 } // end let - return v20 + return tmp20 }) - v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7483), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(7483), lang.NewKeyword("end-column"), int(52)) - v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) + tmp19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7483), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(7483), lang.NewKeyword("end-column"), int(52)) + tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) if err != nil { panic(err) } - v21 := lang.Apply(v17, []any{v20, v10}) - v14 = v21 + tmp21 := lang.Apply(tmp17, []any{tmp20, v10}) + tmp14 = tmp21 } - v11 = v14 + tmp11 = tmp14 } // end let - return v11 + return tmp11 } }) - v6 := v5 + v6 = tmp5 _ = v6 } - v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7477), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7483), lang.NewKeyword("end-column"), int(61)) - v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) + tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7477), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7483), lang.NewKeyword("end-column"), int(61)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) if err != nil { panic(err) } - return v7 + return tmp7 case 3: v3 := args[0] _ = v3 @@ -74753,122 +74899,123 @@ func init() { _ = v4 v5 := args[2] _ = v5 - var v6 lang.FnFunc + var tmp6 lang.FnFunc { // function sp3 - v6 = lang.NewFnFunc(func(args ...any) any { + var v7 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: return nil case 1: v8 := args[0] _ = v8 - var v9 any + var tmp9 any { // let // let binding "or__0__auto__" - v10 := lang.Apply(v3, []any{v8}) - var v11 any = v10 + tmp10 := lang.Apply(v3, []any{v8}) + var v11 any = tmp10 _ = v11 - var v12 any + var tmp12 any if lang.IsTruthy(v11) { - v12 = v11 + tmp12 = v11 } else { - var v13 any + var tmp13 any { // let // let binding "or__0__auto__" - v14 := lang.Apply(v4, []any{v8}) - var v15 any = v14 + tmp14 := lang.Apply(v4, []any{v8}) + var v15 any = tmp14 _ = v15 - var v16 any + var tmp16 any if lang.IsTruthy(v15) { - v16 = v15 + tmp16 = v15 } else { - v17 := lang.Apply(v5, []any{v8}) - v16 = v17 + tmp17 := lang.Apply(v5, []any{v8}) + tmp16 = tmp17 } - v13 = v16 + tmp13 = tmp16 } // end let - v12 = v13 + tmp12 = tmp13 } - v9 = v12 + tmp9 = tmp12 } // end let - return v9 + return tmp9 case 2: v8 := args[0] _ = v8 v9 := args[1] _ = v9 - var v10 any + var tmp10 any { // let // let binding "or__0__auto__" - v11 := lang.Apply(v3, []any{v8}) - var v12 any = v11 + tmp11 := lang.Apply(v3, []any{v8}) + var v12 any = tmp11 _ = v12 - var v13 any + var tmp13 any if lang.IsTruthy(v12) { - v13 = v12 + tmp13 = v12 } else { - var v14 any + var tmp14 any { // let // let binding "or__0__auto__" - v15 := lang.Apply(v3, []any{v9}) - var v16 any = v15 + tmp15 := lang.Apply(v3, []any{v9}) + var v16 any = tmp15 _ = v16 - var v17 any + var tmp17 any if lang.IsTruthy(v16) { - v17 = v16 + tmp17 = v16 } else { - var v18 any + var tmp18 any { // let // let binding "or__0__auto__" - v19 := lang.Apply(v4, []any{v8}) - var v20 any = v19 + tmp19 := lang.Apply(v4, []any{v8}) + var v20 any = tmp19 _ = v20 - var v21 any + var tmp21 any if lang.IsTruthy(v20) { - v21 = v20 + tmp21 = v20 } else { - var v22 any + var tmp22 any { // let // let binding "or__0__auto__" - v23 := lang.Apply(v4, []any{v9}) - var v24 any = v23 + tmp23 := lang.Apply(v4, []any{v9}) + var v24 any = tmp23 _ = v24 - var v25 any + var tmp25 any if lang.IsTruthy(v24) { - v25 = v24 + tmp25 = v24 } else { - var v26 any + var tmp26 any { // let // let binding "or__0__auto__" - v27 := lang.Apply(v5, []any{v8}) - var v28 any = v27 + tmp27 := lang.Apply(v5, []any{v8}) + var v28 any = tmp27 _ = v28 - var v29 any + var tmp29 any if lang.IsTruthy(v28) { - v29 = v28 + tmp29 = v28 } else { - v30 := lang.Apply(v5, []any{v9}) - v29 = v30 + tmp30 := lang.Apply(v5, []any{v9}) + tmp29 = tmp30 } - v26 = v29 + tmp26 = tmp29 } // end let - v25 = v26 + tmp25 = tmp26 } - v22 = v25 + tmp22 = tmp25 } // end let - v21 = v22 + tmp21 = tmp22 } - v18 = v21 + tmp18 = tmp21 } // end let - v17 = v18 + tmp17 = tmp18 } - v14 = v17 + tmp14 = tmp17 } // end let - v13 = v14 + tmp13 = tmp14 } - v10 = v13 + tmp10 = tmp13 } // end let - return v10 + return tmp10 case 3: v8 := args[0] _ = v8 @@ -74876,120 +75023,120 @@ func init() { _ = v9 v10 := args[2] _ = v10 - var v11 any + var tmp11 any { // let // let binding "or__0__auto__" - v12 := lang.Apply(v3, []any{v8}) - var v13 any = v12 + tmp12 := lang.Apply(v3, []any{v8}) + var v13 any = tmp12 _ = v13 - var v14 any + var tmp14 any if lang.IsTruthy(v13) { - v14 = v13 + tmp14 = v13 } else { - var v15 any + var tmp15 any { // let // let binding "or__0__auto__" - v16 := lang.Apply(v3, []any{v9}) - var v17 any = v16 + tmp16 := lang.Apply(v3, []any{v9}) + var v17 any = tmp16 _ = v17 - var v18 any + var tmp18 any if lang.IsTruthy(v17) { - v18 = v17 + tmp18 = v17 } else { - var v19 any + var tmp19 any { // let // let binding "or__0__auto__" - v20 := lang.Apply(v3, []any{v10}) - var v21 any = v20 + tmp20 := lang.Apply(v3, []any{v10}) + var v21 any = tmp20 _ = v21 - var v22 any + var tmp22 any if lang.IsTruthy(v21) { - v22 = v21 + tmp22 = v21 } else { - var v23 any + var tmp23 any { // let // let binding "or__0__auto__" - v24 := lang.Apply(v4, []any{v8}) - var v25 any = v24 + tmp24 := lang.Apply(v4, []any{v8}) + var v25 any = tmp24 _ = v25 - var v26 any + var tmp26 any if lang.IsTruthy(v25) { - v26 = v25 + tmp26 = v25 } else { - var v27 any + var tmp27 any { // let // let binding "or__0__auto__" - v28 := lang.Apply(v4, []any{v9}) - var v29 any = v28 + tmp28 := lang.Apply(v4, []any{v9}) + var v29 any = tmp28 _ = v29 - var v30 any + var tmp30 any if lang.IsTruthy(v29) { - v30 = v29 + tmp30 = v29 } else { - var v31 any + var tmp31 any { // let // let binding "or__0__auto__" - v32 := lang.Apply(v4, []any{v10}) - var v33 any = v32 + tmp32 := lang.Apply(v4, []any{v10}) + var v33 any = tmp32 _ = v33 - var v34 any + var tmp34 any if lang.IsTruthy(v33) { - v34 = v33 + tmp34 = v33 } else { - var v35 any + var tmp35 any { // let // let binding "or__0__auto__" - v36 := lang.Apply(v5, []any{v8}) - var v37 any = v36 + tmp36 := lang.Apply(v5, []any{v8}) + var v37 any = tmp36 _ = v37 - var v38 any + var tmp38 any if lang.IsTruthy(v37) { - v38 = v37 + tmp38 = v37 } else { - var v39 any + var tmp39 any { // let // let binding "or__0__auto__" - v40 := lang.Apply(v5, []any{v9}) - var v41 any = v40 + tmp40 := lang.Apply(v5, []any{v9}) + var v41 any = tmp40 _ = v41 - var v42 any + var tmp42 any if lang.IsTruthy(v41) { - v42 = v41 + tmp42 = v41 } else { - v43 := lang.Apply(v5, []any{v10}) - v42 = v43 + tmp43 := lang.Apply(v5, []any{v10}) + tmp42 = tmp43 } - v39 = v42 + tmp39 = tmp42 } // end let - v38 = v39 + tmp38 = tmp39 } - v35 = v38 + tmp35 = tmp38 } // end let - v34 = v35 + tmp34 = tmp35 } - v31 = v34 + tmp31 = tmp34 } // end let - v30 = v31 + tmp30 = tmp31 } - v27 = v30 + tmp27 = tmp30 } // end let - v26 = v27 + tmp26 = tmp27 } - v23 = v26 + tmp23 = tmp26 } // end let - v22 = v23 + tmp22 = tmp23 } - v19 = v22 + tmp19 = tmp22 } // end let - v18 = v19 + tmp18 = tmp19 } - v15 = v18 + tmp15 = tmp18 } // end let - v14 = v15 + tmp14 = tmp15 } - v11 = v14 + tmp11 = tmp14 } // end let - return v11 + return tmp11 default: if len(args) < 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -75000,83 +75147,84 @@ func init() { _ = v9 v10 := args[2] _ = v10 - v11 := lang.NewList(args[3:]...) - var v12 any + var v11 any = lang.NewList(args[3:]...) + _ = v11 + var tmp12 any { // let // let binding "or__0__auto__" - v13 := lang.Apply(v7, []any{v8, v9, v10}) - var v14 any = v13 + tmp13 := lang.Apply(v7, []any{v8, v9, v10}) + var v14 any = tmp13 _ = v14 - var v15 any + var tmp15 any if lang.IsTruthy(v14) { - v15 = v14 + tmp15 = v14 } else { - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("some")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("some")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) } - v18 := v17.Get() - var v19 lang.FnFunc - v19 = lang.NewFnFunc(func(args ...any) any { + tmp18 := tmp17.Get() + var tmp19 lang.FnFunc + tmp19 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v20 := args[0] _ = v20 - var v21 any + var tmp21 any { // let // let binding "or__0__auto__" - v22 := lang.Apply(v3, []any{v20}) - var v23 any = v22 + tmp22 := lang.Apply(v3, []any{v20}) + var v23 any = tmp22 _ = v23 - var v24 any + var tmp24 any if lang.IsTruthy(v23) { - v24 = v23 + tmp24 = v23 } else { - var v25 any + var tmp25 any { // let // let binding "or__0__auto__" - v26 := lang.Apply(v4, []any{v20}) - var v27 any = v26 + tmp26 := lang.Apply(v4, []any{v20}) + var v27 any = tmp26 _ = v27 - var v28 any + var tmp28 any if lang.IsTruthy(v27) { - v28 = v27 + tmp28 = v27 } else { - v29 := lang.Apply(v5, []any{v20}) - v28 = v29 + tmp29 := lang.Apply(v5, []any{v20}) + tmp28 = tmp29 } - v25 = v28 + tmp25 = tmp28 } // end let - v24 = v25 + tmp24 = tmp25 } - v21 = v24 + tmp21 = tmp24 } // end let - return v21 + return tmp21 }) - v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7491), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(7491), lang.NewKeyword("end-column"), int(59)) - v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) + tmp20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7491), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(7491), lang.NewKeyword("end-column"), int(59)) + tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) if err != nil { panic(err) } - v22 := lang.Apply(v18, []any{v21, v11}) - v15 = v22 + tmp22 := lang.Apply(tmp18, []any{tmp21, v11}) + tmp15 = tmp22 } - v12 = v15 + tmp12 = tmp15 } // end let - return v12 + return tmp12 } }) - v7 := v6 + v7 = tmp6 _ = v7 } - v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7485), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7491), lang.NewKeyword("end-column"), int(68)) - v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) + tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7485), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7491), lang.NewKeyword("end-column"), int(68)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) if err != nil { panic(err) } - return v8 + return tmp8 default: if len(args) < 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -75087,93 +75235,95 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - var v7 any + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any { // let // let binding "ps" - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("list*")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v3, v4, v5, v6}) - var v12 any = v11 + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("list*")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v3, v4, v5, v6}) + var v12 any = tmp11 _ = v12 - var v13 lang.FnFunc + var tmp13 lang.FnFunc { // function spn - v13 = lang.NewFnFunc(func(args ...any) any { + var v14 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: return nil case 1: v15 := args[0] _ = v15 - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("some")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("some")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) } - v18 := v17.Get() - var v19 lang.FnFunc - v19 = lang.NewFnFunc(func(args ...any) any { + tmp18 := tmp17.Get() + var tmp19 lang.FnFunc + tmp19 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v20 := args[0] _ = v20 - v21 := lang.Apply(v20, []any{v15}) - return v21 + tmp21 := lang.Apply(v20, []any{v15}) + return tmp21 }) - v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7496), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(7496), lang.NewKeyword("end-column"), int(26)) - v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) + tmp20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7496), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(7496), lang.NewKeyword("end-column"), int(26)) + tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) if err != nil { panic(err) } - v22 := lang.Apply(v18, []any{v21, v12}) - return v22 + tmp22 := lang.Apply(tmp18, []any{tmp21, v12}) + return tmp22 case 2: v15 := args[0] _ = v15 v16 := args[1] _ = v16 - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("some")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("some")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) } - v19 := v18.Get() - var v20 lang.FnFunc - v20 = lang.NewFnFunc(func(args ...any) any { + tmp19 := tmp18.Get() + var tmp20 lang.FnFunc + tmp20 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v21 := args[0] _ = v21 - var v22 any + var tmp22 any { // let // let binding "or__0__auto__" - v23 := lang.Apply(v21, []any{v15}) - var v24 any = v23 + tmp23 := lang.Apply(v21, []any{v15}) + var v24 any = tmp23 _ = v24 - var v25 any + var tmp25 any if lang.IsTruthy(v24) { - v25 = v24 + tmp25 = v24 } else { - v26 := lang.Apply(v21, []any{v16}) - v25 = v26 + tmp26 := lang.Apply(v21, []any{v16}) + tmp25 = tmp26 } - v22 = v25 + tmp22 = tmp25 } // end let - return v22 + return tmp22 }) - v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7497), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(7497), lang.NewKeyword("end-column"), int(39)) - v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) + tmp21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7497), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(7497), lang.NewKeyword("end-column"), int(39)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) if err != nil { panic(err) } - v23 := lang.Apply(v19, []any{v22, v12}) - return v23 + tmp23 := lang.Apply(tmp19, []any{tmp22, v12}) + return tmp23 case 3: v15 := args[0] _ = v15 @@ -75181,57 +75331,57 @@ func init() { _ = v16 v17 := args[2] _ = v17 - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("some")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("some")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) } - v20 := v19.Get() - var v21 lang.FnFunc - v21 = lang.NewFnFunc(func(args ...any) any { + tmp20 := tmp19.Get() + var tmp21 lang.FnFunc + tmp21 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v22 := args[0] _ = v22 - var v23 any + var tmp23 any { // let // let binding "or__0__auto__" - v24 := lang.Apply(v22, []any{v15}) - var v25 any = v24 + tmp24 := lang.Apply(v22, []any{v15}) + var v25 any = tmp24 _ = v25 - var v26 any + var tmp26 any if lang.IsTruthy(v25) { - v26 = v25 + tmp26 = v25 } else { - var v27 any + var tmp27 any { // let // let binding "or__0__auto__" - v28 := lang.Apply(v22, []any{v16}) - var v29 any = v28 + tmp28 := lang.Apply(v22, []any{v16}) + var v29 any = tmp28 _ = v29 - var v30 any + var tmp30 any if lang.IsTruthy(v29) { - v30 = v29 + tmp30 = v29 } else { - v31 := lang.Apply(v22, []any{v17}) - v30 = v31 + tmp31 := lang.Apply(v22, []any{v17}) + tmp30 = tmp31 } - v27 = v30 + tmp27 = tmp30 } // end let - v26 = v27 + tmp26 = tmp27 } - v23 = v26 + tmp23 = tmp26 } // end let - return v23 + return tmp23 }) - v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7498), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7498), lang.NewKeyword("end-column"), int(47)) - v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) + tmp22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7498), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7498), lang.NewKeyword("end-column"), int(47)) + tmp23, err := lang.WithMeta(tmp21, tmp22.(lang.IPersistentMap)) if err != nil { panic(err) } - v24 := lang.Apply(v20, []any{v23, v12}) - return v24 + tmp24 := lang.Apply(tmp20, []any{tmp23, v12}) + return tmp24 default: if len(args) < 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -75242,219 +75392,220 @@ func init() { _ = v16 v17 := args[2] _ = v17 - v18 := lang.NewList(args[3:]...) - var v19 any + var v18 any = lang.NewList(args[3:]...) + _ = v18 + var tmp19 any { // let // let binding "or__0__auto__" - v20 := lang.Apply(v14, []any{v15, v16, v17}) - var v21 any = v20 + tmp20 := lang.Apply(v14, []any{v15, v16, v17}) + var v21 any = tmp20 _ = v21 - var v22 any + var tmp22 any if lang.IsTruthy(v21) { - v22 = v21 + tmp22 = v21 } else { - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("some")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("some")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) } - v25 := v24.Get() - var v26 lang.FnFunc - v26 = lang.NewFnFunc(func(args ...any) any { + tmp25 := tmp24.Get() + var tmp26 lang.FnFunc + tmp26 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v27 := args[0] _ = v27 - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("some")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("some")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) } - v30 := v29.Get() - v31 := lang.Apply(v30, []any{v27, v18}) - return v31 + tmp30 := tmp29.Get() + tmp31 := lang.Apply(tmp30, []any{v27, v18}) + return tmp31 }) - v27 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7500), lang.NewKeyword("column"), int(36), lang.NewKeyword("end-line"), int(7500), lang.NewKeyword("end-column"), int(49)) - v28, err := lang.WithMeta(v26, v27.(lang.IPersistentMap)) + tmp27 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7500), lang.NewKeyword("column"), int(36), lang.NewKeyword("end-line"), int(7500), lang.NewKeyword("end-column"), int(49)) + tmp28, err := lang.WithMeta(tmp26, tmp27.(lang.IPersistentMap)) if err != nil { panic(err) } - v29 := lang.Apply(v25, []any{v28, v12}) - v22 = v29 + tmp29 := lang.Apply(tmp25, []any{tmp28, v12}) + tmp22 = tmp29 } - v19 = v22 + tmp19 = tmp22 } // end let - return v19 + return tmp19 } }) - v14 := v13 + v14 = tmp13 _ = v14 } - v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7494), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7500), lang.NewKeyword("end-column"), int(56)) - v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) + tmp14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7494), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7500), lang.NewKeyword("end-column"), int(56)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) if err != nil { panic(err) } - v7 = v15 + tmp7 = tmp15 } // end let - return v7 + return tmp7 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // some? { - v1 := reflect.TypeOf(false) - v0 := lang.NewSymbol("some?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is not nil, false otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(530), lang.NewKeyword("end-line"), int(530))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp1 := reflect.TypeOf(false) + tmp0 := lang.NewSymbol("some?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is not nil, false otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(530), lang.NewKeyword("end-line"), int(530))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("not")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("not")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("nil?")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("nil?")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v4}) - v12 := lang.Apply(v7, []any{v11}) - return v12 + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v4}) + tmp12 := lang.Apply(tmp7, []any{tmp11}) + return tmp12 }) - v4 := reflect.TypeOf(false) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp4 := reflect.TypeOf(false) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // sort { - v0 := lang.NewSymbol("sort").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("comp"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a sorted sequence of the items in coll. If no comparator is\n supplied, uses compare. comparator must implement\n java.util.Comparator. Guaranteed to be stable: equal elements will\n not be reordered. If coll is a Java array, it will be modified. To\n avoid this, sort a copy of the array.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3085), lang.NewKeyword("end-line"), int(3085))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("sort").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("comp"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a sorted sequence of the items in coll. If no comparator is\n supplied, uses compare. comparator must implement\n java.util.Comparator. Guaranteed to be stable: equal elements will\n not be reordered. If coll is a Java array, it will be modified. To\n avoid this, sort a copy of the array.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3085), lang.NewKeyword("end-line"), int(3085))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("sort")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("compare")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v6, []any{v9, v3}) - return v10 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("sort")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("compare")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp6, []any{tmp9, v3}) + return tmp10 case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - var v5 any - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("seq")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{v4}) - if lang.IsTruthy(v9) { - var v10 any + var tmp5 any + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("seq")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.Apply(tmp8, []any{v4}) + if lang.IsTruthy(tmp9) { + var tmp10 any { // let // let binding "a" - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("to-array")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{v4}) - var v15 any = v14 + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("to-array")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{v4}) + var v15 any = tmp14 _ = v15 - v16 := lang.Apply(lang.SortSlice, []any{v15, v3}) - _ = v16 - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("with-meta")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("seq")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.Apply(v22, []any{v15}) - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("meta")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.Apply(v26, []any{v4}) - v28 := lang.Apply(v19, []any{v23, v27}) - v10 = v28 + tmp16 := lang.Apply(lang.SortSlice, []any{v15, v3}) + _ = tmp16 + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("with-meta")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("seq")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.Apply(tmp22, []any{v15}) + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("meta")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.Apply(tmp26, []any{v4}) + tmp28 := lang.Apply(tmp19, []any{tmp23, tmp27}) + tmp10 = tmp28 } // end let - v5 = v10 + tmp5 = tmp10 } else { - v5 = lang.NewList() + tmp5 = lang.NewList() } - return v5 + return tmp5 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // sort-by { - v0 := lang.NewSymbol("sort-by").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("keyfn"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("keyfn"), lang.NewSymbol("comp"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a sorted sequence of the items in coll, where the sort\n order is determined by comparing (keyfn item). If no comparator is\n supplied, uses compare. comparator must implement\n java.util.Comparator. Guaranteed to be stable: equal elements will\n not be reordered. If coll is a Java array, it will be modified. To\n avoid this, sort a copy of the array.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3102), lang.NewKeyword("end-line"), int(3102))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("sort-by").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("keyfn"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("keyfn"), lang.NewSymbol("comp"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a sorted sequence of the items in coll, where the sort\n order is determined by comparing (keyfn item). If no comparator is\n supplied, uses compare. comparator must implement\n java.util.Comparator. Guaranteed to be stable: equal elements will\n not be reordered. If coll is a Java array, it will be modified. To\n avoid this, sort a copy of the array.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3102), lang.NewKeyword("end-line"), int(3102))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("sort-by")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("compare")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v7, []any{v3, v10, v4}) - return v11 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("sort-by")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("compare")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp7, []any{v3, tmp10, v4}) + return tmp11 case 3: v3 := args[0] _ = v3 @@ -75462,14 +75613,14 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("sort")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - var v9 lang.FnFunc - v9 = lang.NewFnFunc(func(args ...any) any { + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("sort")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -75477,54 +75628,55 @@ func init() { _ = v10 v11 := args[1] _ = v11 - v12 := lang.Apply(v3, []any{v10}) - v13 := lang.Apply(v3, []any{v11}) - v14 := lang.Apply(v4, []any{v12, v13}) - return v14 + tmp12 := lang.Apply(v3, []any{v10}) + tmp13 := lang.Apply(v3, []any{v11}) + tmp14 := lang.Apply(v4, []any{tmp12, tmp13}) + return tmp14 }) - v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3114), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(3114), lang.NewKeyword("end-column"), int(46)) - v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) + tmp10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3114), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(3114), lang.NewKeyword("end-column"), int(46)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) if err != nil { panic(err) } - v12 := lang.Apply(v8, []any{v11, v5}) - return v12 + tmp12 := lang.Apply(tmp8, []any{tmp11, v5}) + return tmp12 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // sorted-map { - v0 := lang.NewSymbol("sorted-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keyvals"))), lang.NewKeyword("doc"), "keyval => key val\n Returns a new sorted map with supplied mappings. If any keys are\n equal, they are handled as if by repeated uses of assoc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(397), lang.NewKeyword("end-line"), int(397))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("sorted-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keyvals"))), lang.NewKeyword("doc"), "keyval => key val\n Returns a new sorted map with supplied mappings. If any keys are\n equal, they are handled as if by repeated uses of assoc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(397), lang.NewKeyword("end-line"), int(397))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v3 := lang.NewList(args[0:]...) - v4 := lang.Apply(lang.CreatePersistentTreeMap, []any{v3}) - return v4 + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := lang.Apply(lang.CreatePersistentTreeMap, []any{v3}) + return tmp4 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // sorted-map-by { - v0 := lang.NewSymbol("sorted-map-by").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("comparator"), lang.NewSymbol("&"), lang.NewSymbol("keyvals"))), lang.NewKeyword("doc"), "keyval => key val\n Returns a new sorted map with supplied mappings, using the supplied\n comparator. If any keys are equal, they are handled as if by\n repeated uses of assoc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(406), lang.NewKeyword("end-line"), int(406))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("sorted-map-by").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("comparator"), lang.NewSymbol("&"), lang.NewSymbol("keyvals"))), lang.NewKeyword("doc"), "keyval => key val\n Returns a new sorted map with supplied mappings, using the supplied\n comparator. If any keys are equal, they are handled as if by\n repeated uses of assoc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(406), lang.NewKeyword("end-line"), int(406))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 1 { @@ -75532,43 +75684,45 @@ func init() { } v3 := args[0] _ = v3 - v4 := lang.NewList(args[1:]...) - v5 := lang.Apply(nil, []any{v3, v4}) - return v5 + var v4 any = lang.NewList(args[1:]...) + _ = v4 + tmp5 := lang.Apply(nil, []any{v3, v4}) + return tmp5 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // sorted-set { - v0 := lang.NewSymbol("sorted-set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keys"))), lang.NewKeyword("doc"), "Returns a new sorted set with supplied keys. Any equal keys are\n handled as if by repeated uses of conj.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(416), lang.NewKeyword("end-line"), int(416))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("sorted-set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keys"))), lang.NewKeyword("doc"), "Returns a new sorted set with supplied keys. Any equal keys are\n handled as if by repeated uses of conj.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(416), lang.NewKeyword("end-line"), int(416))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v3 := lang.NewList(args[0:]...) - v4 := lang.Apply(lang.CreatePersistentTreeSet, []any{v3}) - return v4 + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := lang.Apply(lang.CreatePersistentTreeSet, []any{v3}) + return tmp4 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // sorted-set-by { - v0 := lang.NewSymbol("sorted-set-by").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("comparator"), lang.NewSymbol("&"), lang.NewSymbol("keys"))), lang.NewKeyword("doc"), "Returns a new sorted set with supplied keys, using the supplied\n comparator. Any equal keys are handled as if by repeated uses of\n conj.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(424), lang.NewKeyword("end-line"), int(424))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("sorted-set-by").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("comparator"), lang.NewSymbol("&"), lang.NewSymbol("keys"))), lang.NewKeyword("doc"), "Returns a new sorted set with supplied keys, using the supplied\n comparator. Any equal keys are handled as if by repeated uses of\n conj.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(424), lang.NewKeyword("end-line"), int(424))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 1 { @@ -75576,83 +75730,84 @@ func init() { } v3 := args[0] _ = v3 - v4 := lang.NewList(args[1:]...) - v5 := lang.Apply(lang.CreatePersistentTreeSetWithComparator, []any{v3, v4}) - return v5 + var v4 any = lang.NewList(args[1:]...) + _ = v4 + tmp5 := lang.Apply(lang.CreatePersistentTreeSetWithComparator, []any{v3, v4}) + return tmp5 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // sorted? { - v0 := lang.NewSymbol("sorted?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements Sorted", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6235), lang.NewKeyword("end-line"), int(6235))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("sorted?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements Sorted", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6235), lang.NewKeyword("end-line"), int(6235))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) } - v6 := v5.Get() - v7 := lang.Apply(v6, []any{nil, v3}) - return v7 + tmp6 := tmp5.Get() + tmp7 := lang.Apply(tmp6, []any{nil, v3}) + return tmp7 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // special-symbol? { - v0 := lang.NewSymbol("special-symbol?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns true if s names a special form", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4992), lang.NewKeyword("end-line"), int(4992))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("special-symbol?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns true if s names a special form", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4992), lang.NewKeyword("end-line"), int(4992))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("contains?")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("contains?")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) } - v6 := v5.Get() - v7, ok := lang.FieldOrMethod(runtime4.Compiler, "specials") + tmp6 := tmp5.Get() + tmp7, ok := lang.FieldOrMethod(runtime4.Compiler, "specials") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", runtime4.Compiler, "specials"))) } - var v8 any - switch reflect.TypeOf(v7).Kind() { + var tmp8 any + switch reflect.TypeOf(tmp7).Kind() { case reflect.Func: - v8 = lang.Apply(v7, nil) + tmp8 = lang.Apply(tmp7, nil) default: - v8 = v7 + tmp8 = tmp7 } - v9 := lang.Apply(v6, []any{v8, v3}) - return v9 + tmp9 := lang.Apply(tmp6, []any{tmp8, v3}) + return tmp9 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // spit { - v0 := lang.NewSymbol("spit").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("content"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Opposite of slurp. Opens f with writer, writes content, then\n closes f. Options passed to glojure.java.io/writer.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6994), lang.NewKeyword("end-line"), int(6994))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("spit").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("content"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Opposite of slurp. Opens f with writer, writes content, then\n closes f. Options passed to glojure.java.io/writer.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6994), lang.NewKeyword("end-line"), int(6994))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 2 { @@ -75662,60 +75817,62 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.NewList(args[2:]...) - var v6 any + var v5 any = lang.NewList(args[2:]...) + _ = v5 + var tmp6 any { // let // let binding "w" - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("apply")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v9, []any{nil, v3, v5}) - var v11 any = v10 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("apply")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp9, []any{nil, v3, v5}) + var v11 any = tmp10 _ = v11 - var v12 any + var tmp12 any func() { defer func() { - v13, ok := lang.FieldOrMethod(v11, "close") + tmp13, ok := lang.FieldOrMethod(v11, "close") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v11, "close"))) } - var v14 any - switch reflect.TypeOf(v13).Kind() { + var tmp14 any + switch reflect.TypeOf(tmp13).Kind() { case reflect.Func: - v14 = lang.Apply(v13, nil) + tmp14 = lang.Apply(tmp13, nil) default: - v14 = v13 + tmp14 = tmp13 } + _ = tmp14 }() - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("str")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{v4}) - v19 := lang.Apply(lang.WriteWriter, []any{v11, v18}) - v12 = v19 + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("str")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{v4}) + tmp19 := lang.Apply(lang.WriteWriter, []any{v11, tmp18}) + tmp12 = tmp19 }() - v6 = v12 + tmp6 = tmp12 } // end let - return v6 + return tmp6 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // split-at { - v0 := lang.NewSymbol("split-at").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a vector of [(take n coll) (drop n coll)]", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2983), lang.NewKeyword("end-line"), int(2983))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("split-at").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a vector of [(take n coll) (drop n coll)]", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2983), lang.NewKeyword("end-line"), int(2983))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -75723,39 +75880,39 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("take")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v3, v4}) - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("drop")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.Apply(v11, []any{v3, v4}) - v13 := lang.NewVector(v8, v12) - v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2988), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2988), lang.NewKeyword("end-column"), int(33)) - v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("take")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v3, v4}) + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("drop")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.Apply(tmp11, []any{v3, v4}) + tmp13 := lang.NewVector(tmp8, tmp12) + tmp14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2988), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2988), lang.NewKeyword("end-column"), int(33)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) if err != nil { panic(err) } - return v15 + return tmp15 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // split-with { - v0 := lang.NewSymbol("split-with").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a vector of [(take-while pred coll) (drop-while pred coll)]", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2990), lang.NewKeyword("end-line"), int(2990))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("split-with").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a vector of [(take-while pred coll) (drop-while pred coll)]", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2990), lang.NewKeyword("end-line"), int(2990))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -75763,39 +75920,39 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("take-while")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v3, v4}) - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("drop-while")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.Apply(v11, []any{v3, v4}) - v13 := lang.NewVector(v8, v12) - v14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2995), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2995), lang.NewKeyword("end-column"), int(51)) - v15, err := lang.WithMeta(v13, v14.(lang.IPersistentMap)) + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("take-while")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v3, v4}) + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("drop-while")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.Apply(tmp11, []any{v3, v4}) + tmp13 := lang.NewVector(tmp8, tmp12) + tmp14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2995), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2995), lang.NewKeyword("end-column"), int(51)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) if err != nil { panic(err) } - return v15 + return tmp15 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // splitv-at { - v0 := lang.NewSymbol("splitv-at").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a vector of [(into [] (take n) coll) (drop n coll)]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7256), lang.NewKeyword("end-line"), int(7256))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("splitv-at").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a vector of [(into [] (take n) coll) (drop n coll)]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7256), lang.NewKeyword("end-line"), int(7256))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -75803,182 +75960,181 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("into")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.NewVector() - v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7260), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(7260), lang.NewKeyword("end-column"), int(11)) - v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("into")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.NewVector() + tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7260), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(7260), lang.NewKeyword("end-column"), int(11)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) if err != nil { panic(err) } - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("take")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{v3}) - v15 := lang.Apply(v7, []any{v10, v14, v4}) - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("drop")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{v3, v4}) - v20 := lang.NewVector(v15, v19) - v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7260), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(7260), lang.NewKeyword("end-column"), int(41)) - v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("take")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{v3}) + tmp15 := lang.Apply(tmp7, []any{tmp10, tmp14, v4}) + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("drop")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{v3, v4}) + tmp20 := lang.NewVector(tmp15, tmp19) + tmp21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7260), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(7260), lang.NewKeyword("end-column"), int(41)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) if err != nil { panic(err) } - return v22 + return tmp22 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // spread { - v0 := lang.NewSymbol("spread").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("arglist"))), lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(632), lang.NewKeyword("end-line"), int(632), lang.NewKeyword("private"), true)).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("spread").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("arglist"))), lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(632), lang.NewKeyword("end-line"), int(632), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("nil?")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v3}) - if lang.IsTruthy(v8) { - v4 = nil + var tmp4 any + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("nil?")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v3}) + if lang.IsTruthy(tmp8) { } else { - var v9 any - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("nil?")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("next")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{v3}) - v17 := lang.Apply(v12, []any{v16}) - if lang.IsTruthy(v17) { - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("seq")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("first")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.Apply(v23, []any{v3}) - v25 := lang.Apply(v20, []any{v24}) - v9 = v25 + var tmp9 any + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("nil?")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("next")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp16}) + if lang.IsTruthy(tmp17) { + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("seq")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("first")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.Apply(tmp23, []any{v3}) + tmp25 := lang.Apply(tmp20, []any{tmp24}) + tmp9 = tmp25 } else { - var v26 any + var tmp26 any if lang.IsTruthy(lang.NewKeyword("else")) { - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("cons")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("first")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) - } - v32 := v31.Get() - v33 := lang.Apply(v32, []any{v3}) - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("spread")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) - } - v36 := v35.Get() - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("next")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.Apply(v39, []any{v3}) - v41 := lang.Apply(v36, []any{v40}) - v42 := lang.Apply(v29, []any{v33, v41}) - v26 = v42 + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("cons")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("first")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) + } + tmp32 := tmp31.Get() + tmp33 := lang.Apply(tmp32, []any{v3}) + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("spread")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("next")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.Apply(tmp39, []any{v3}) + tmp41 := lang.Apply(tmp36, []any{tmp40}) + tmp42 := lang.Apply(tmp29, []any{tmp33, tmp41}) + tmp26 = tmp42 } else { - v26 = nil } - v9 = v26 + tmp9 = tmp26 } - v4 = v9 + tmp4 = tmp9 } - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // str { - v1 := reflect.TypeOf("") - v0 := lang.NewSymbol("str").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("ys"))), lang.NewKeyword("doc"), "With no args, returns the empty string. With one arg x, returns\n x.toString(). (str nil) returns the empty string. With more than\n one arg, returns the concatenation of the str values of the args.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(543), lang.NewKeyword("end-line"), int(543))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp1 := reflect.TypeOf("") + tmp0 := lang.NewSymbol("str").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("ys"))), lang.NewKeyword("doc"), "With no args, returns the empty string. With one arg x, returns\n x.toString(). (str nil) returns the empty string. With more than\n one arg, returns the concatenation of the str values of the args.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(543), lang.NewKeyword("end-line"), int(543))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: return "" case 1: v4 := args[0] _ = v4 - var v5 any - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("nil?")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{v4}) - if lang.IsTruthy(v9) { - v5 = "" + var tmp5 any + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("nil?")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.Apply(tmp8, []any{v4}) + if lang.IsTruthy(tmp9) { + tmp5 = "" } else { - v10 := lang.Apply(lang.ToString, []any{v4}) - v5 = v10 + tmp10 := lang.Apply(lang.ToString, []any{v4}) + tmp5 = tmp10 } - return v5 + return tmp5 default: if len(args) < 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5 := lang.NewList(args[1:]...) - var v6 lang.FnFunc - v6 = lang.NewFnFunc(func(args ...any) any { + var v5 any = lang.NewList(args[1:]...) + _ = v5 + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -75987,158 +76143,159 @@ func init() { v8 := args[1] _ = v8 recur_loop_74: - var v9 any + var tmp9 any if lang.IsTruthy(v8) { - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("str")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("first")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{v8}) - v18 := lang.Apply(v13, []any{v17}) - v19, _ := lang.FieldOrMethod(v7, "WriteString") - if reflect.TypeOf(v19).Kind() != reflect.Func { + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("str")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("first")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{v8}) + tmp18 := lang.Apply(tmp13, []any{tmp17}) + tmp19, _ := lang.FieldOrMethod(v7, "WriteString") + if reflect.TypeOf(tmp19).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("WriteString is not a function"))) } - v20 := lang.Apply(v19, []any{v18}) - _ = v20 - var v10 any = v7 - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("next")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v8}) - var v21 any = v25 - v7 = v10 - v8 = v21 + tmp20 := lang.Apply(tmp19, []any{tmp18}) + _ = tmp20 + var tmp10 any = v7 + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("next")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.Apply(tmp24, []any{v8}) + var tmp21 any = tmp25 + v7 = tmp10 + v8 = tmp21 goto recur_loop_74 } else { - v26, ok := lang.FieldOrMethod(v7, "String") + tmp26, ok := lang.FieldOrMethod(v7, "String") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "String"))) } - var v27 any - switch reflect.TypeOf(v26).Kind() { + var tmp27 any + switch reflect.TypeOf(tmp26).Kind() { case reflect.Func: - v27 = lang.Apply(v26, nil) + tmp27 = lang.Apply(tmp26, nil) default: - v27 = v26 + tmp27 = tmp26 } - v9 = v27 + tmp9 = tmp27 } - return v9 + return tmp9 }) - v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(554), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(554), lang.NewKeyword("end-column"), int(127)) - v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) + tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(554), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(554), lang.NewKeyword("end-column"), int(127)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) if err != nil { panic(err) } - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("cons")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("cons")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) } - v11 := v10.Get() - v12 := lang.Apply(v11, []any{v4, v5}) - v13 := lang.Apply(v8, []any{"unimplemented: new with non-constant class type", v12}) - return v13 + tmp11 := tmp10.Get() + tmp12 := lang.Apply(tmp11, []any{v4, v5}) + tmp13 := lang.Apply(tmp8, []any{"unimplemented: new with non-constant class type", tmp12}) + return tmp13 } }) - v4 := reflect.TypeOf("") - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp4 := reflect.TypeOf("") + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // stream-into! { - v0 := lang.NewSymbol("stream-into!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("stream")), lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("xform"), lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Returns a new coll consisting of coll with all of the items of the\n stream conjoined. This is a terminal operation on the stream.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6810), lang.NewKeyword("end-line"), int(6810))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("stream-into!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("stream")), lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("xform"), lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Returns a new coll consisting of coll with all of the items of the\n stream conjoined. This is a terminal operation on the stream.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6810), lang.NewKeyword("end-line"), int(6810))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - var v5 any - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("instance?")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{lang.IEditableCollection, v3}) - if lang.IsTruthy(v9) { - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("with-meta")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("persistent!")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("stream-reduce!")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("conj!")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("transient")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v3}) - v26 := lang.Apply(v18, []any{v21, v25, v4}) - v27 := lang.Apply(v15, []any{v26}) - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("meta")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.Apply(v30, []any{v3}) - v32 := lang.Apply(v12, []any{v27, v31}) - v5 = v32 + var tmp5 any + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("instance?")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := reflect.TypeOf((*lang.IEditableCollection)(nil)).Elem() + tmp10 := lang.Apply(tmp8, []any{tmp9, v3}) + if lang.IsTruthy(tmp10) { + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("with-meta")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("persistent!")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("stream-reduce!")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("conj!")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("transient")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.Apply(tmp25, []any{v3}) + tmp27 := lang.Apply(tmp19, []any{tmp22, tmp26, v4}) + tmp28 := lang.Apply(tmp16, []any{tmp27}) + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("meta")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.Apply(tmp31, []any{v3}) + tmp33 := lang.Apply(tmp13, []any{tmp28, tmp32}) + tmp5 = tmp33 } else { - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("stream-reduce!")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("conj")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.Apply(v35, []any{v38, v3, v4}) - v5 = v39 - } - return v5 + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("stream-reduce!")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("conj")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.Apply(tmp36, []any{tmp39, v3, v4}) + tmp5 = tmp40 + } + return tmp5 case 3: v3 := args[0] _ = v3 @@ -76146,108 +76303,109 @@ func init() { _ = v4 v5 := args[2] _ = v5 - var v6 any - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("instance?")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v9, []any{lang.IEditableCollection, v3}) - if lang.IsTruthy(v10) { - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("with-meta")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("persistent!")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("stream-transduce!")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("conj!")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("transient")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.Apply(v25, []any{v3}) - v27 := lang.Apply(v19, []any{v4, v22, v26, v5}) - v28 := lang.Apply(v16, []any{v27}) - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("meta")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.Apply(v31, []any{v3}) - v33 := lang.Apply(v13, []any{v28, v32}) - v6 = v33 + var tmp6 any + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("instance?")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := reflect.TypeOf((*lang.IEditableCollection)(nil)).Elem() + tmp11 := lang.Apply(tmp9, []any{tmp10, v3}) + if lang.IsTruthy(tmp11) { + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("with-meta")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("persistent!")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("stream-transduce!")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("conj!")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("transient")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp20, []any{v4, tmp23, tmp27, v5}) + tmp29 := lang.Apply(tmp17, []any{tmp28}) + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("meta")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) + } + tmp32 := tmp31.Get() + tmp33 := lang.Apply(tmp32, []any{v3}) + tmp34 := lang.Apply(tmp14, []any{tmp29, tmp33}) + tmp6 = tmp34 } else { - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("stream-transduce!")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) - } - v36 := v35.Get() - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("conj")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.Apply(v36, []any{v4, v39, v3, v5}) - v6 = v40 - } - return v6 + tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp36 := tmp35.FindInternedVar(lang.NewSymbol("stream-transduce!")) + if tmp36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) + } + tmp37 := tmp36.Get() + tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp39 := tmp38.FindInternedVar(lang.NewSymbol("conj")) + if tmp39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) + } + tmp40 := tmp39.Get() + tmp41 := lang.Apply(tmp37, []any{v4, tmp40, v3, v5}) + tmp6 = tmp41 + } + return tmp6 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // stream-reduce! { - v0 := lang.NewSymbol("stream-reduce!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("s")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Works like reduce but takes a java.util.stream.BaseStream as its source.\n Honors 'reduced', is a terminal operation on the stream", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6784), lang.NewKeyword("end-line"), int(6784))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("stream-reduce!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("s")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Works like reduce but takes a java.util.stream.BaseStream as its source.\n Honors 'reduced', is a terminal operation on the stream", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6784), lang.NewKeyword("end-line"), int(6784))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - v5, ok := lang.FieldOrMethod(v4, "iterator") + tmp5, ok := lang.FieldOrMethod(v4, "iterator") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "iterator"))) } - var v6 any - switch reflect.TypeOf(v5).Kind() { + var tmp6 any + switch reflect.TypeOf(tmp5).Kind() { case reflect.Func: - v6 = lang.Apply(v5, nil) + tmp6 = lang.Apply(tmp5, nil) default: - v6 = v5 + tmp6 = tmp5 } - v7 := lang.Apply(nil, []any{v6, v3}) - return v7 + tmp7 := lang.Apply(nil, []any{tmp6, v3}) + return tmp7 case 3: v3 := args[0] _ = v3 @@ -76255,70 +76413,70 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6, ok := lang.FieldOrMethod(v5, "iterator") + tmp6, ok := lang.FieldOrMethod(v5, "iterator") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "iterator"))) } - var v7 any - switch reflect.TypeOf(v6).Kind() { + var tmp7 any + switch reflect.TypeOf(tmp6).Kind() { case reflect.Func: - v7 = lang.Apply(v6, nil) + tmp7 = lang.Apply(tmp6, nil) default: - v7 = v6 + tmp7 = tmp6 } - v8 := lang.Apply(nil, []any{v7, v3, v4}) - return v8 + tmp8 := lang.Apply(nil, []any{tmp7, v3, v4}) + return tmp8 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // stream-seq! { - v0 := lang.NewSymbol("stream-seq!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Takes a java.util.stream.BaseStream instance s and returns a seq of its\n contents. This is a terminal operation on the stream.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6793), lang.NewKeyword("end-line"), int(6793))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("stream-seq!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Takes a java.util.stream.BaseStream instance s and returns a seq of its\n contents. This is a terminal operation on the stream.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6793), lang.NewKeyword("end-line"), int(6793))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("iterator-seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("iterator-seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) } - v6 := v5.Get() - v7, ok := lang.FieldOrMethod(v3, "iterator") + tmp6 := tmp5.Get() + tmp7, ok := lang.FieldOrMethod(v3, "iterator") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "iterator"))) } - var v8 any - switch reflect.TypeOf(v7).Kind() { + var tmp8 any + switch reflect.TypeOf(tmp7).Kind() { case reflect.Func: - v8 = lang.Apply(v7, nil) + tmp8 = lang.Apply(tmp7, nil) default: - v8 = v7 + tmp8 = tmp7 } - v9 := lang.Apply(v6, []any{v8}) - return v9 + tmp9 := lang.Apply(tmp6, []any{tmp8}) + return tmp9 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // stream-transduce! { - v0 := lang.NewSymbol("stream-transduce!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("f"), lang.NewSymbol("stream")), lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Works like transduce but takes a java.util.stream.BaseStream as its source.\n This is a terminal operation on the stream.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6800), lang.NewKeyword("end-line"), int(6800))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("stream-transduce!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("f"), lang.NewSymbol("stream")), lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Works like transduce but takes a java.util.stream.BaseStream as its source.\n This is a terminal operation on the stream.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6800), lang.NewKeyword("end-line"), int(6800))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 3: v3 := args[0] @@ -76327,15 +76485,15 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("stream-transduce!")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v4, nil) - v10 := lang.Apply(v8, []any{v3, v4, v9, v5}) - return v10 + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("stream-transduce!")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.Apply(v4, nil) + tmp10 := lang.Apply(tmp8, []any{v3, v4, tmp9, v5}) + return tmp10 case 4: v3 := args[0] _ = v3 @@ -76345,129 +76503,130 @@ func init() { _ = v5 v6 := args[3] _ = v6 - var v7 any + var tmp7 any { // let // let binding "f" - v8 := lang.Apply(v3, []any{v4}) - var v9 any = v8 + tmp8 := lang.Apply(v3, []any{v4}) + var v9 any = tmp8 _ = v9 // let binding "ret" - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("stream-reduce!")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{v9, v5, v6}) - var v14 any = v13 + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("stream-reduce!")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{v9, v5, v6}) + var v14 any = tmp13 _ = v14 - v15 := lang.Apply(v9, []any{v14}) - v7 = v15 + tmp15 := lang.Apply(v9, []any{v14}) + tmp7 = tmp15 } // end let - return v7 + return tmp7 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // string? { - v0 := lang.NewSymbol("string?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a String", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(160), lang.NewKeyword("end-line"), int(164))).(*lang.Symbol) - var v2 lang.FnFunc + tmp0 := lang.NewSymbol("string?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a String", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(160), lang.NewKeyword("end-line"), int(164))).(*lang.Symbol) + var tmp2 lang.FnFunc { // function string? - v2 = lang.NewFnFunc(func(args ...any) any { + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{lang.Builtins["string"], v4}) - return v8 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("instance?")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{lang.Builtins["string"], v4}) + return tmp8 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(164), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(164), lang.NewKeyword("end-column"), int(58))).(lang.FnFunc) - v3 := v2 + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(164), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(164), lang.NewKeyword("end-column"), int(58))).(lang.FnFunc) + v3 = tmp2 _ = v3 } - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // strip-ns { - v0 := lang.NewSymbol("strip-ns").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(255), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(255), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("named"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("strip-ns").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(255), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(255), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("named"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("symbol?")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v3}) - if lang.IsTruthy(v8) { - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("symbol")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("name")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.Apply(v14, []any{v3}) - v16 := lang.Apply(v11, []any{nil, v15}) - v4 = v16 + var tmp4 any + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("symbol?")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v3}) + if lang.IsTruthy(tmp8) { + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("symbol")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("name")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.Apply(tmp14, []any{v3}) + tmp16 := lang.Apply(tmp11, []any{nil, tmp15}) + tmp4 = tmp16 } else { - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("keyword")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("keyword")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) } - v19 := v18.Get() - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("name")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + tmp19 := tmp18.Get() + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("name")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) } - v22 := v21.Get() - v23 := lang.Apply(v22, []any{v3}) - v24 := lang.Apply(v19, []any{nil, v23}) - v4 = v24 + tmp22 := tmp21.Get() + tmp23 := lang.Apply(tmp22, []any{v3}) + tmp24 := lang.Apply(tmp19, []any{nil, tmp23}) + tmp4 = tmp24 } - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // struct { - v0 := lang.NewSymbol("struct").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("&"), lang.NewSymbol("vals"))), lang.NewKeyword("doc"), "Returns a new structmap instance with the keys of the\n structure-basis. vals must be supplied for basis keys in order -\n where values are not supplied they will default to nil.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4061), lang.NewKeyword("end-line"), int(4061))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("struct").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("&"), lang.NewSymbol("vals"))), lang.NewKeyword("doc"), "Returns a new structmap instance with the keys of the\n structure-basis. vals must be supplied for basis keys in order -\n where values are not supplied they will default to nil.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4061), lang.NewKeyword("end-line"), int(4061))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 1 { @@ -76475,22 +76634,23 @@ func init() { } v3 := args[0] _ = v3 - v4 := lang.NewList(args[1:]...) - v5 := lang.Apply(lang.ConstructPersistentStructMap, []any{v3, v4}) - return v5 + var v4 any = lang.NewList(args[1:]...) + _ = v4 + tmp5 := lang.Apply(lang.ConstructPersistentStructMap, []any{v3, v4}) + return tmp5 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // struct-map { - v0 := lang.NewSymbol("struct-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("&"), lang.NewSymbol("inits"))), lang.NewKeyword("doc"), "Returns a new structmap instance with the keys of the\n structure-basis. keyvals may contain all, some or none of the basis\n keys - where values are not supplied they will default to nil.\n keyvals can also contain keys not in the basis.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4051), lang.NewKeyword("end-line"), int(4051))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("struct-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("&"), lang.NewSymbol("inits"))), lang.NewKeyword("doc"), "Returns a new structmap instance with the keys of the\n structure-basis. keyvals may contain all, some or none of the basis\n keys - where values are not supplied they will default to nil.\n keyvals can also contain keys not in the basis.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4051), lang.NewKeyword("end-line"), int(4051))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 1 { @@ -76498,30 +76658,31 @@ func init() { } v3 := args[0] _ = v3 - v4 := lang.NewList(args[1:]...) - v5 := lang.Apply(lang.CreatePersistentStructMap, []any{v3, v4}) - return v5 + var v4 any = lang.NewList(args[1:]...) + _ = v4 + tmp5 := lang.Apply(lang.CreatePersistentStructMap, []any{v3, v4}) + return tmp5 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // subs { - v0 := lang.NewSymbol("subs").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("start")), lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("start"), lang.NewSymbol("end"))), lang.NewKeyword("doc"), "Returns the substring of s beginning at start inclusive, and ending\n at end (defaults to length of string), exclusive.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5005), lang.NewKeyword("end-line"), int(5005))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("subs").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("start")), lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("start"), lang.NewSymbol("end"))), lang.NewKeyword("doc"), "Returns the substring of s beginning at start inclusive, and ending\n at end (defaults to length of string), exclusive.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5005), lang.NewKeyword("end-line"), int(5005))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - v5 := lang.Apply(lang.Builtins["slice"], []any{v3, v4}) - return v5 + tmp5 := lang.Apply(lang.Builtins["slice"], []any{v3, v4}) + return tmp5 case 3: v3 := args[0] _ = v3 @@ -76529,23 +76690,23 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.Apply(lang.Builtins["slice"], []any{v3, v4, v5}) - return v6 + tmp6 := lang.Apply(lang.Builtins["slice"], []any{v3, v4, v5}) + return tmp6 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // subseq { - v0 := lang.NewSymbol("subseq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sc"), lang.NewSymbol("test"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("sc"), lang.NewSymbol("start-test"), lang.NewSymbol("start-key"), lang.NewSymbol("end-test"), lang.NewSymbol("end-key"))), lang.NewKeyword("doc"), "sc must be a sorted collection, test(s) one of <, <=, > or\n >=. Returns a seq of those entries with keys ek for\n which (test (.. sc comparator (compare ek key)) 0) is true", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5133), lang.NewKeyword("end-line"), int(5133))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("subseq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sc"), lang.NewSymbol("test"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("sc"), lang.NewSymbol("start-test"), lang.NewSymbol("start-key"), lang.NewSymbol("end-test"), lang.NewSymbol("end-key"))), lang.NewKeyword("doc"), "sc must be a sorted collection, test(s) one of <, <=, > or\n >=. Returns a seq of those entries with keys ek for\n which (test (.. sc comparator (compare ek key)) 0) is true", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5133), lang.NewKeyword("end-line"), int(5133))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 3: v3 := args[0] @@ -76554,110 +76715,109 @@ func init() { _ = v4 v5 := args[2] _ = v5 - var v6 any + var tmp6 any { // let // let binding "include" - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("mk-bound-fn")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v9, []any{v3, v4, v5}) - var v11 any = v10 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("mk-bound-fn")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp9, []any{v3, v4, v5}) + var v11 any = tmp10 _ = v11 - var v12 any - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol(">")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol(">=")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.CreatePersistentTreeSet(v15, v18) - v20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5141), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5141), lang.NewKeyword("end-column"), int(17)) - v21, err := lang.WithMeta(v19, v20.(lang.IPersistentMap)) + var tmp12 any + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol(">")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol(">=")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{tmp15, tmp18})) + tmp20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5141), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5141), lang.NewKeyword("end-column"), int(17)) + tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) if err != nil { panic(err) } - v22 := lang.Apply(v21, []any{v4}) - if lang.IsTruthy(v22) { - var v23 any + tmp22 := lang.Apply(tmp21, []any{v4}) + if lang.IsTruthy(tmp22) { + var tmp23 any { // let // let binding "temp__0__auto__" - v24, _ := lang.FieldOrMethod(v3, "seqFrom") - if reflect.TypeOf(v24).Kind() != reflect.Func { + tmp24, _ := lang.FieldOrMethod(v3, "seqFrom") + if reflect.TypeOf(tmp24).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("seqFrom is not a function"))) } - v25 := lang.Apply(v24, []any{v5, true}) - var v26 any = v25 + tmp25 := lang.Apply(tmp24, []any{v5, true}) + var v26 any = tmp25 _ = v26 - var v27 any + var tmp27 any if lang.IsTruthy(v26) { - var v28 any + var tmp28 any { // let // let binding "vec__68" var v29 any = v26 _ = v29 // let binding "e" - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("nth")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("nth")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) } - v32 := v31.Get() - v33 := lang.Apply(v32, []any{v29, int64(0), nil}) - var v34 any = v33 + tmp32 := tmp31.Get() + tmp33 := lang.Apply(tmp32, []any{v29, int64(0), nil}) + var v34 any = tmp33 _ = v34 // let binding "s" var v35 any = v29 _ = v35 - var v36 any - v37 := lang.Apply(v11, []any{v34}) - if lang.IsTruthy(v37) { - v36 = v35 + var tmp36 any + tmp37 := lang.Apply(v11, []any{v34}) + if lang.IsTruthy(tmp37) { + tmp36 = v35 } else { - v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v39 := v38.FindInternedVar(lang.NewSymbol("next")) - if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp39 := tmp38.FindInternedVar(lang.NewSymbol("next")) + if tmp39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) } - v40 := v39.Get() - v41 := lang.Apply(v40, []any{v35}) - v36 = v41 + tmp40 := tmp39.Get() + tmp41 := lang.Apply(tmp40, []any{v35}) + tmp36 = tmp41 } - v28 = v36 + tmp28 = tmp36 } // end let - v27 = v28 + tmp27 = tmp28 } else { - v27 = nil } - v23 = v27 + tmp23 = tmp27 } // end let - v12 = v23 + tmp12 = tmp23 } else { - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("take-while")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27, _ := lang.FieldOrMethod(v3, "seq") - if reflect.TypeOf(v27).Kind() != reflect.Func { + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("take-while")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27, _ := lang.FieldOrMethod(v3, "seq") + if reflect.TypeOf(tmp27).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("seq is not a function"))) } - v28 := lang.Apply(v27, []any{true}) - v29 := lang.Apply(v26, []any{v11, v28}) - v12 = v29 + tmp28 := lang.Apply(tmp27, []any{true}) + tmp29 := lang.Apply(tmp26, []any{v11, tmp28}) + tmp12 = tmp29 } - v6 = v12 + tmp6 = tmp12 } // end let - return v6 + return tmp6 case 5: v3 := args[0] _ = v3 @@ -76669,116 +76829,115 @@ func init() { _ = v6 v7 := args[4] _ = v7 - var v8 any + var tmp8 any { // let // let binding "temp__0__auto__" - v9, _ := lang.FieldOrMethod(v3, "seqFrom") - if reflect.TypeOf(v9).Kind() != reflect.Func { + tmp9, _ := lang.FieldOrMethod(v3, "seqFrom") + if reflect.TypeOf(tmp9).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("seqFrom is not a function"))) } - v10 := lang.Apply(v9, []any{v5, true}) - var v11 any = v10 + tmp10 := lang.Apply(tmp9, []any{v5, true}) + var v11 any = tmp10 _ = v11 - var v12 any + var tmp12 any if lang.IsTruthy(v11) { - var v13 any + var tmp13 any { // let // let binding "vec__71" var v14 any = v11 _ = v14 // let binding "e" - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("nth")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{v14, int64(0), nil}) - var v19 any = v18 + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("nth")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{v14, int64(0), nil}) + var v19 any = tmp18 _ = v19 // let binding "s" var v20 any = v14 _ = v20 - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("take-while")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("mk-bound-fn")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.Apply(v26, []any{v3, v6, v7}) - var v28 any - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("mk-bound-fn")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.Apply(v31, []any{v3, v4, v5}) - v33 := lang.Apply(v32, []any{v19}) - if lang.IsTruthy(v33) { - v28 = v20 + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("take-while")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("mk-bound-fn")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.Apply(tmp26, []any{v3, v6, v7}) + var tmp28 any + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("mk-bound-fn")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.Apply(tmp31, []any{v3, v4, v5}) + tmp33 := lang.Apply(tmp32, []any{v19}) + if lang.IsTruthy(tmp33) { + tmp28 = v20 } else { - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("next")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("next")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) } - v36 := v35.Get() - v37 := lang.Apply(v36, []any{v20}) - v28 = v37 + tmp36 := tmp35.Get() + tmp37 := lang.Apply(tmp36, []any{v20}) + tmp28 = tmp37 } - v38 := lang.Apply(v23, []any{v27, v28}) - v13 = v38 + tmp38 := lang.Apply(tmp23, []any{tmp27, tmp28}) + tmp13 = tmp38 } // end let - v12 = v13 + tmp12 = tmp13 } else { - v12 = nil } - v8 = v12 + tmp8 = tmp12 } // end let - return v8 + return tmp8 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // subvec { - v0 := lang.NewSymbol("subvec").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("v"), lang.NewSymbol("start")), lang.NewVector(lang.NewSymbol("v"), lang.NewSymbol("start"), lang.NewSymbol("end"))), lang.NewKeyword("doc"), "Returns a persistent vector of the items in vector from\n start (inclusive) to end (exclusive). If end is not supplied,\n defaults to (count vector). This operation is O(1) and very fast, as\n the resulting vector shares structure with the original and no\n trimming is done.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3819), lang.NewKeyword("end-line"), int(3819))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("subvec").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("v"), lang.NewSymbol("start")), lang.NewVector(lang.NewSymbol("v"), lang.NewSymbol("start"), lang.NewSymbol("end"))), lang.NewKeyword("doc"), "Returns a persistent vector of the items in vector from\n start (inclusive) to end (exclusive). If end is not supplied,\n defaults to (count vector). This operation is O(1) and very fast, as\n the resulting vector shares structure with the original and no\n trimming is done.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3819), lang.NewKeyword("end-line"), int(3819))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("subvec")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("count")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v3}) - v12 := lang.Apply(v7, []any{v3, v4, v11}) - return v12 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("subvec")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("count")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v3}) + tmp12 := lang.Apply(tmp7, []any{v3, v4, tmp11}) + return tmp12 case 3: v3 := args[0] _ = v3 @@ -76786,141 +76945,141 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6, _ := lang.FieldOrMethod(runtime4.RT, "Subvec") - if reflect.TypeOf(v6).Kind() != reflect.Func { + tmp6, _ := lang.FieldOrMethod(runtime4.RT, "Subvec") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Subvec is not a function"))) } - v7 := lang.Apply(v6, []any{v3, v4, v5}) - return v7 + tmp7 := lang.Apply(tmp6, []any{v3, v4, v5}) + return tmp7 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // supers { - v0 := lang.NewSymbol("supers").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("class"))), lang.NewKeyword("doc"), "Returns the immediate and indirect superclasses and interfaces of c, if any", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5532), lang.NewKeyword("end-line"), int(5532))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("supers").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("class"))), lang.NewKeyword("doc"), "Returns the immediate and indirect superclasses and interfaces of c, if any", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5532), lang.NewKeyword("end-line"), int(5532))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any + var tmp4 any { // let // let binding "ret" - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("set")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("bases")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v3}) - v12 := lang.Apply(v7, []any{v11}) - var v13 any = v12 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("set")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("bases")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v3}) + tmp12 := lang.Apply(tmp7, []any{tmp11}) + var v13 any = tmp12 _ = v13 // let binding "cs" var v14 any = v13 _ = v14 for { - var v15 any - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("seq")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{v14}) - if lang.IsTruthy(v19) { - var v20 any + var tmp15 any + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("seq")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{v14}) + if lang.IsTruthy(tmp19) { + var tmp20 any { // let // let binding "c" - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("first")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.Apply(v23, []any{v14}) - var v25 any = v24 + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("first")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.Apply(tmp23, []any{v14}) + var v25 any = tmp24 _ = v25 // let binding "bs" - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("bases")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) - } - v28 := v27.Get() - v29 := lang.Apply(v28, []any{v25}) - var v30 any = v29 + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("bases")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) + } + tmp28 := tmp27.Get() + tmp29 := lang.Apply(tmp28, []any{v25}) + var v30 any = tmp29 _ = v30 - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("into1")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{v13, v30}) - var v31 any = v35 - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("into1")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("disj")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) - } - v42 := v41.Get() - v43 := lang.Apply(v42, []any{v14, v25}) - v44 := lang.Apply(v39, []any{v43, v30}) - var v36 any = v44 - v13 = v31 - v14 = v36 + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("into1")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.Apply(tmp34, []any{v13, v30}) + var tmp31 any = tmp35 + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("into1")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("disj")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) + } + tmp42 := tmp41.Get() + tmp43 := lang.Apply(tmp42, []any{v14, v25}) + tmp44 := lang.Apply(tmp39, []any{tmp43, v30}) + var tmp36 any = tmp44 + v13 = tmp31 + v14 = tmp36 continue } // end let - v15 = v20 + tmp15 = tmp20 } else { - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("not-empty")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("not-empty")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) } - v23 := v22.Get() - v24 := lang.Apply(v23, []any{v13}) - v15 = v24 + tmp23 := tmp22.Get() + tmp24 := lang.Apply(tmp23, []any{v13}) + tmp15 = tmp24 } - v4 = v15 + tmp4 = tmp15 break } } // end let - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // swap! { - v0 := lang.NewSymbol("swap!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atom"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Atomically swaps the value of atom to be:\n (apply f current-value-of-atom args). Note that f may be called\n multiple times, and thus should be free of side effects. Returns\n the value that was swapped in.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2343), lang.NewKeyword("end-line"), int(2343))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("swap!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atom"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Atomically swaps the value of atom to be:\n (apply f current-value-of-atom args). Note that f may be called\n multiple times, and thus should be free of side effects. Returns\n the value that was swapped in.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2343), lang.NewKeyword("end-line"), int(2343))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 2 { @@ -76930,26 +77089,27 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.NewList(args[2:]...) - v6, _ := lang.FieldOrMethod(v3, "swap") - if reflect.TypeOf(v6).Kind() != reflect.Func { + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6, _ := lang.FieldOrMethod(v3, "swap") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("swap is not a function"))) } - v7 := lang.Apply(v6, []any{v4, v5}) - return v7 + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // swap-vals! { - v0 := lang.NewSymbol("swap-vals!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atom"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Atomically swaps the value of atom to be:\n (apply f current-value-of-atom args). Note that f may be called\n multiple times, and thus should be free of side effects.\n Returns [old new], the value of the atom before and after the swap.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2352), lang.NewKeyword("end-line"), int(2352))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("swap-vals!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atom"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Atomically swaps the value of atom to be:\n (apply f current-value-of-atom args). Note that f may be called\n multiple times, and thus should be free of side effects.\n Returns [old new], the value of the atom before and after the swap.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2352), lang.NewKeyword("end-line"), int(2352))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 2 { @@ -76959,162 +77119,165 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.NewList(args[2:]...) - v6, _ := lang.FieldOrMethod(v3, "swapVals") - if reflect.TypeOf(v6).Kind() != reflect.Func { + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6, _ := lang.FieldOrMethod(v3, "swapVals") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("swapVals is not a function"))) } - v7 := lang.Apply(v6, []any{v4, v5}) - return v7 + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // symbol { - v1 := reflect.TypeOf((*lang.Symbol)(nil)) - v0 := lang.NewSymbol("symbol").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name"))), lang.NewKeyword("doc"), "Returns a Symbol with the given namespace and name. Arity-1 works\n on strings, keywords, and vars.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(584), lang.NewKeyword("end-line"), int(584))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp1 := reflect.TypeOf((*lang.Symbol)(nil)) + tmp0 := lang.NewSymbol("symbol").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name"))), lang.NewKeyword("doc"), "Returns a Symbol with the given namespace and name. Arity-1 works\n on strings, keywords, and vars.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(584), lang.NewKeyword("end-line"), int(584))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v4 := args[0] _ = v4 - var v5 any - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("symbol?")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{v4}) - if lang.IsTruthy(v9) { - v5 = v4 + var tmp5 any + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("symbol?")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.Apply(tmp8, []any{v4}) + if lang.IsTruthy(tmp9) { + tmp5 = v4 } else { - var v10 any - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("instance?")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{lang.Builtins["string"], v4}) - if lang.IsTruthy(v14) { - v15 := lang.Apply(lang.NewSymbol, []any{v4}) - v10 = v15 + var tmp10 any + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("instance?")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{lang.Builtins["string"], v4}) + if lang.IsTruthy(tmp14) { + tmp15 := lang.Apply(lang.NewSymbol, []any{v4}) + tmp10 = tmp15 } else { - var v16 any - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("instance?")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.Apply(v19, []any{*lang.Var, v4}) - if lang.IsTruthy(v20) { - v21, ok := lang.FieldOrMethod(v4, "toSymbol") + var tmp16 any + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("instance?")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := reflect.TypeOf((*lang.Var)(nil)) + tmp21 := lang.Apply(tmp19, []any{tmp20, v4}) + if lang.IsTruthy(tmp21) { + tmp22, ok := lang.FieldOrMethod(v4, "toSymbol") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "toSymbol"))) } - var v22 any - switch reflect.TypeOf(v21).Kind() { + var tmp23 any + switch reflect.TypeOf(tmp22).Kind() { case reflect.Func: - v22 = lang.Apply(v21, nil) + tmp23 = lang.Apply(tmp22, nil) default: - v22 = v21 + tmp23 = tmp22 } - v16 = v22 + tmp16 = tmp23 } else { - var v23 any - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("instance?")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.Apply(v26, []any{lang.Keyword, v4}) - if lang.IsTruthy(v27) { - v28, ok := lang.FieldOrMethod(v4, "sym") + var tmp24 any + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("instance?")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() + tmp29 := lang.Apply(tmp27, []any{tmp28, v4}) + if lang.IsTruthy(tmp29) { + tmp30, ok := lang.FieldOrMethod(v4, "sym") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "sym"))) } - var v29 any - switch reflect.TypeOf(v28).Kind() { + var tmp31 any + switch reflect.TypeOf(tmp30).Kind() { case reflect.Func: - v29 = lang.Apply(v28, nil) + tmp31 = lang.Apply(tmp30, nil) default: - v29 = v28 + tmp31 = tmp30 } - v23 = v29 + tmp24 = tmp31 } else { - var v30 any + var tmp32 any if lang.IsTruthy(lang.NewKeyword("else")) { - v31 := lang.Apply(lang.NewIllegalArgumentError, []any{"no conversion to symbol"}) - panic(v31) + tmp33 := lang.Apply(lang.NewIllegalArgumentError, []any{"no conversion to symbol"}) + panic(tmp33) } else { - v30 = nil } - v23 = v30 + tmp24 = tmp32 } - v16 = v23 + tmp16 = tmp24 } - v10 = v16 + tmp10 = tmp16 } - v5 = v10 + tmp5 = tmp10 } - return v5 + return tmp5 case 2: v4 := args[0] _ = v4 v5 := args[1] _ = v5 - v6 := lang.Apply(lang.InternSymbol, []any{v4, v5}) - return v6 + tmp6 := lang.Apply(lang.InternSymbol, []any{v4, v5}) + return tmp6 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v4 := reflect.TypeOf((*lang.Symbol)(nil)) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp4 := reflect.TypeOf((*lang.Symbol)(nil)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // symbol? { - v0 := lang.NewSymbol("symbol?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a Symbol", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(557), lang.NewKeyword("end-line"), int(557))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("symbol?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a Symbol", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(557), lang.NewKeyword("end-line"), int(557))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) } - v6 := v5.Get() - v7 := lang.Apply(v6, []any{*lang.Symbol, v3}) - return v7 + tmp6 := tmp5.Get() + tmp7 := reflect.TypeOf((*lang.Symbol)(nil)) + tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) + return tmp8 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // sync { - v0 := lang.NewSymbol("sync").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("flags-ignored-for-now"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "transaction-flags => TBD, pass nil for now\n\n Runs the exprs (in an implicit do) in a transaction that encompasses\n exprs and any nested calls. Starts a transaction if none is already\n running on this thread. Any uncaught exception will abort the\n transaction and flow out of sync. The exprs may be run more than\n once, but any effects on Refs will be atomic.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(2490), lang.NewKeyword("end-line"), int(2490))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("sync").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("flags-ignored-for-now"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "transaction-flags => TBD, pass nil for now\n\n Runs the exprs (in an implicit do) in a transaction that encompasses\n exprs and any nested calls. Starts a transaction if none is already\n running on this thread. Any uncaught exception will abort the\n transaction and flow out of sync. The exprs may be run more than\n once, but any effects on Refs will be atomic.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(2490), lang.NewKeyword("end-line"), int(2490))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 3 { @@ -77126,147 +77289,148 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("seq")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("concat")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("list")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{lang.NewSymbol(".")}) - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("list")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.Apply(v19, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.LockingTransaction")}) - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("list")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("seq")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("concat")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("list")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) - } - v32 := v31.Get() - v33 := lang.Apply(v32, []any{lang.NewSymbol("glojure.core/RunInTransaction")}) - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("list")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) - } - v36 := v35.Get() - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("seq")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("concat")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) - } - v42 := v41.Get() - v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v44 := v43.FindInternedVar(lang.NewSymbol("list")) - if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) - } - v45 := v44.Get() - v46 := lang.Apply(v45, []any{lang.NewSymbol("glojure.core/fn")}) - v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v48 := v47.FindInternedVar(lang.NewSymbol("list")) - if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) - } - v49 := v48.Get() - v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v51 := v50.FindInternedVar(lang.NewSymbol("apply")) - if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) - } - v52 := v51.Get() - v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v54 := v53.FindInternedVar(lang.NewSymbol("vector")) - if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) - } - v55 := v54.Get() - v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v57 := v56.FindInternedVar(lang.NewSymbol("seq")) - if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) - } - v58 := v57.Get() - v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v60 := v59.FindInternedVar(lang.NewSymbol("concat")) - if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) - } - v61 := v60.Get() - v62 := lang.Apply(v61, nil) - v63 := lang.Apply(v58, []any{v62}) - v64 := lang.Apply(v52, []any{v55, v63}) - v65 := lang.Apply(v49, []any{v64}) - v66 := lang.Apply(v42, []any{v46, v65, v6}) - v67 := lang.Apply(v39, []any{v66}) - v68 := lang.Apply(v36, []any{v67}) - v69 := lang.Apply(v29, []any{v33, v68}) - v70 := lang.Apply(v26, []any{v69}) - v71 := lang.Apply(v23, []any{v70}) - v72 := lang.Apply(v12, []any{v16, v20, v71}) - v73 := lang.Apply(v9, []any{v72}) - return v73 - } - }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("seq")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("concat")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("list")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("list")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.Apply(tmp19, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.LockingTransaction")}) + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("list")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("seq")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("concat")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("list")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) + } + tmp32 := tmp31.Get() + tmp33 := lang.Apply(tmp32, []any{lang.NewSymbol("glojure.core/RunInTransaction")}) + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("list")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("seq")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("concat")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) + } + tmp42 := tmp41.Get() + tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp44 := tmp43.FindInternedVar(lang.NewSymbol("list")) + if tmp44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) + } + tmp45 := tmp44.Get() + tmp46 := lang.Apply(tmp45, []any{lang.NewSymbol("glojure.core/fn")}) + tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp48 := tmp47.FindInternedVar(lang.NewSymbol("list")) + if tmp48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) + } + tmp49 := tmp48.Get() + tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp51 := tmp50.FindInternedVar(lang.NewSymbol("apply")) + if tmp51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) + } + tmp52 := tmp51.Get() + tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp54 := tmp53.FindInternedVar(lang.NewSymbol("vector")) + if tmp54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) + } + tmp55 := tmp54.Get() + tmp56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp57 := tmp56.FindInternedVar(lang.NewSymbol("seq")) + if tmp57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp57))) + } + tmp58 := tmp57.Get() + tmp59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp60 := tmp59.FindInternedVar(lang.NewSymbol("concat")) + if tmp60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp60))) + } + tmp61 := tmp60.Get() + tmp62 := lang.Apply(tmp61, nil) + tmp63 := lang.Apply(tmp58, []any{tmp62}) + tmp64 := lang.Apply(tmp52, []any{tmp55, tmp63}) + tmp65 := lang.Apply(tmp49, []any{tmp64}) + tmp66 := lang.Apply(tmp42, []any{tmp46, tmp65, v6}) + tmp67 := lang.Apply(tmp39, []any{tmp66}) + tmp68 := lang.Apply(tmp36, []any{tmp67}) + tmp69 := lang.Apply(tmp29, []any{tmp33, tmp68}) + tmp70 := lang.Apply(tmp26, []any{tmp69}) + tmp71 := lang.Apply(tmp23, []any{tmp70}) + tmp72 := lang.Apply(tmp12, []any{tmp16, tmp20, tmp71}) + tmp73 := lang.Apply(tmp9, []any{tmp72}) + return tmp73 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // system-newline { - v0 := lang.NewSymbol("system-newline").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3695), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(3695), lang.NewKeyword("end-column"), int(40), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - v1 := ns.InternWithValue(v0, "\n", true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp0 := lang.NewSymbol("system-newline").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3695), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(3695), lang.NewKeyword("end-column"), int(40), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, "\n", true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // tagged-literal { - v0 := lang.NewSymbol("tagged-literal").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag"), lang.NewSymbol("form"))), lang.NewKeyword("doc"), "Construct a data representation of a tagged literal from a\n tag symbol and a form.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7769), lang.NewKeyword("end-line"), int(7769))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("tagged-literal").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag"), lang.NewSymbol("form"))), lang.NewKeyword("doc"), "Construct a data representation of a tagged literal from a\n tag symbol and a form.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7769), lang.NewKeyword("end-line"), int(7769))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -77274,292 +77438,290 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.Apply(nil, []any{v3, v4}) - return v5 + tmp5 := lang.Apply(nil, []any{v3, v4}) + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // tagged-literal? { - v0 := lang.NewSymbol("tagged-literal?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("value"))), lang.NewKeyword("doc"), "Return true if the value is the data representation of a tagged literal", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7763), lang.NewKeyword("end-line"), int(7763))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("tagged-literal?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("value"))), lang.NewKeyword("doc"), "Return true if the value is the data representation of a tagged literal", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7763), lang.NewKeyword("end-line"), int(7763))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) } - v6 := v5.Get() - v7 := lang.Apply(v6, []any{nil, v3}) - return v7 + tmp6 := tmp5.Get() + tmp7 := lang.Apply(tmp6, []any{nil, v3}) + return tmp7 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // take { - v0 := lang.NewSymbol("take").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the first n items in coll, or all items if\n there are fewer than n. Returns a stateful transducer when\n no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2853), lang.NewKeyword("end-line"), int(2853))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("take").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the first n items in coll, or all items if\n there are fewer than n. Returns a stateful transducer when\n no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2853), lang.NewKeyword("end-line"), int(2853))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - var v4 lang.FnFunc - v4 = lang.NewFnFunc(func(args ...any) any { + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v5 := args[0] _ = v5 - var v6 any + var tmp6 any { // let // let binding "nv" - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("volatile!")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v9, []any{v3}) - var v11 any = v10 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("volatile!")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp9, []any{v3}) + var v11 any = tmp10 _ = v11 - var v12 lang.FnFunc - v12 = lang.NewFnFunc(func(args ...any) any { + var tmp12 lang.FnFunc + tmp12 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - v13 := lang.Apply(v5, nil) - return v13 + tmp13 := lang.Apply(v5, nil) + return tmp13 case 1: v13 := args[0] _ = v13 - v14 := lang.Apply(v5, []any{v13}) - return v14 + tmp14 := lang.Apply(v5, []any{v13}) + return tmp14 case 2: v13 := args[0] _ = v13 v14 := args[1] _ = v14 - var v15 any + var tmp15 any { // let // let binding "n" - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("deref")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("deref")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{v11}) - var v20 any = v19 + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{v11}) + var v20 any = tmp19 _ = v20 // let binding "nn" - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("dec")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("dec")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) } - v23 := v22.Get() - v24, ok := lang.FieldOrMethod(v11, "Deref") + tmp23 := tmp22.Get() + tmp24, ok := lang.FieldOrMethod(v11, "Deref") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v11, "Deref"))) } - var v25 any - switch reflect.TypeOf(v24).Kind() { + var tmp25 any + switch reflect.TypeOf(tmp24).Kind() { case reflect.Func: - v25 = lang.Apply(v24, nil) + tmp25 = lang.Apply(tmp24, nil) default: - v25 = v24 + tmp25 = tmp24 } - v26 := lang.Apply(v23, []any{v25}) - v27, _ := lang.FieldOrMethod(v11, "reset") - if reflect.TypeOf(v27).Kind() != reflect.Func { + tmp26 := lang.Apply(tmp23, []any{tmp25}) + tmp27, _ := lang.FieldOrMethod(v11, "reset") + if reflect.TypeOf(tmp27).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) } - v28 := lang.Apply(v27, []any{v26}) - var v29 any = v28 + tmp28 := lang.Apply(tmp27, []any{tmp26}) + var v29 any = tmp28 _ = v29 // let binding "result" - var v30 any - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("pos?")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + var tmp30 any + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("pos?")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{v20}) - if lang.IsTruthy(v34) { - v35 := lang.Apply(v5, []any{v13, v14}) - v30 = v35 + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{v20}) + if lang.IsTruthy(tmp34) { + tmp35 := lang.Apply(v5, []any{v13, v14}) + tmp30 = tmp35 } else { - v30 = v13 + tmp30 = v13 } - var v36 any = v30 + var v36 any = tmp30 _ = v36 - var v37 any - v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v39 := v38.FindInternedVar(lang.NewSymbol("not")) - if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + var tmp37 any + tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp39 := tmp38.FindInternedVar(lang.NewSymbol("not")) + if tmp39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) } - v40 := v39.Get() - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("pos?")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) + tmp40 := tmp39.Get() + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("pos?")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) } - v43 := v42.Get() - v44 := lang.Apply(v43, []any{v29}) - v45 := lang.Apply(v40, []any{v44}) - if lang.IsTruthy(v45) { - v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v47 := v46.FindInternedVar(lang.NewSymbol("ensure-reduced")) - if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) + tmp43 := tmp42.Get() + tmp44 := lang.Apply(tmp43, []any{v29}) + tmp45 := lang.Apply(tmp40, []any{tmp44}) + if lang.IsTruthy(tmp45) { + tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp47 := tmp46.FindInternedVar(lang.NewSymbol("ensure-reduced")) + if tmp47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) } - v48 := v47.Get() - v49 := lang.Apply(v48, []any{v36}) - v37 = v49 + tmp48 := tmp47.Get() + tmp49 := lang.Apply(tmp48, []any{v36}) + tmp37 = tmp49 } else { - v37 = v36 + tmp37 = v36 } - v15 = v37 + tmp15 = tmp37 } // end let - return v15 + return tmp15 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2862), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(2873), lang.NewKeyword("end-column"), int(28)) - v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) + tmp13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2862), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(2873), lang.NewKeyword("end-column"), int(28)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) if err != nil { panic(err) } - v6 = v14 + tmp6 = tmp14 } // end let - return v6 + return tmp6 }) - v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2860), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2873), lang.NewKeyword("end-column"), int(30)) - v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) + tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2860), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2873), lang.NewKeyword("end-column"), int(30)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) if err != nil { panic(err) } - return v6 + return tmp6 case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - var v5 lang.FnFunc - v5 = lang.NewFnFunc(func(args ...any) any { + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - var v6 any - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("pos?")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + var tmp6 any + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("pos?")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) } - v9 := v8.Get() - v10 := lang.Apply(v9, []any{v3}) - if lang.IsTruthy(v10) { - var v11 any + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp9, []any{v3}) + if lang.IsTruthy(tmp10) { + var tmp11 any { // let // let binding "temp__0__auto__" - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("seq")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.Apply(v14, []any{v4}) - var v16 any = v15 + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("seq")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.Apply(tmp14, []any{v4}) + var v16 any = tmp15 _ = v16 - var v17 any + var tmp17 any if lang.IsTruthy(v16) { - var v18 any + var tmp18 any { // let // let binding "s" var v19 any = v16 _ = v19 - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("cons")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("cons")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) } - v22 := v21.Get() - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("first")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + tmp22 := tmp21.Get() + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("first")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) } - v25 := v24.Get() - v26 := lang.Apply(v25, []any{v19}) - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("take")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) + tmp25 := tmp24.Get() + tmp26 := lang.Apply(tmp25, []any{v19}) + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("take")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) } - v29 := v28.Get() - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("dec")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) + tmp29 := tmp28.Get() + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("dec")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) } - v32 := v31.Get() - v33 := lang.Apply(v32, []any{v3}) - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("rest")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + tmp32 := tmp31.Get() + tmp33 := lang.Apply(tmp32, []any{v3}) + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("rest")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) } - v36 := v35.Get() - v37 := lang.Apply(v36, []any{v19}) - v38 := lang.Apply(v29, []any{v33, v37}) - v39 := lang.Apply(v22, []any{v26, v38}) - v18 = v39 + tmp36 := tmp35.Get() + tmp37 := lang.Apply(tmp36, []any{v19}) + tmp38 := lang.Apply(tmp29, []any{tmp33, tmp37}) + tmp39 := lang.Apply(tmp22, []any{tmp26, tmp38}) + tmp18 = tmp39 } // end let - v17 = v18 + tmp17 = tmp18 } else { - v17 = nil } - v11 = v17 + tmp11 = tmp17 } // end let - v6 = v11 + tmp6 = tmp11 } else { - v6 = nil } - return v6 + return tmp6 }) - v6 := lang.Apply(lang.NewLazySeq, []any{v5}) - return v6 + tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) + return tmp6 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // take-last { - v0 := lang.NewSymbol("take-last").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a seq of the last n items in coll. Depending on the type\n of coll may be no better than linear time. For vectors, see also subvec.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2939), lang.NewKeyword("end-line"), int(2939))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("take-last").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a seq of the last n items in coll. Depending on the type\n of coll may be no better than linear time. For vectors, see also subvec.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2939), lang.NewKeyword("end-line"), int(2939))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -77567,590 +77729,589 @@ func init() { _ = v3 v4 := args[1] _ = v4 - var v5 any + var tmp5 any { // let // let binding "s" - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("seq")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{v4}) - var v10 any = v9 + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("seq")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.Apply(tmp8, []any{v4}) + var v10 any = tmp9 _ = v10 // let binding "lead" - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("seq")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("drop")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{v3, v4}) - v18 := lang.Apply(v13, []any{v17}) - var v19 any = v18 + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("seq")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("drop")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{v3, v4}) + tmp18 := lang.Apply(tmp13, []any{tmp17}) + var v19 any = tmp18 _ = v19 for { - var v20 any + var tmp20 any if lang.IsTruthy(v19) { - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("next")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v10}) - var v21 any = v25 - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("next")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{v19}) - var v26 any = v30 - v10 = v21 - v19 = v26 + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("next")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.Apply(tmp24, []any{v10}) + var tmp21 any = tmp25 + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("next")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{v19}) + var tmp26 any = tmp30 + v10 = tmp21 + v19 = tmp26 continue } else { - v20 = v10 + tmp20 = v10 } - v5 = v20 + tmp5 = tmp20 break } } // end let - return v5 + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // take-nth { - v0 := lang.NewSymbol("take-nth").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy seq of every nth item in coll. Returns a stateful\n transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4287), lang.NewKeyword("end-line"), int(4287))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("take-nth").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy seq of every nth item in coll. Returns a stateful\n transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4287), lang.NewKeyword("end-line"), int(4287))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - var v4 lang.FnFunc - v4 = lang.NewFnFunc(func(args ...any) any { + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v5 := args[0] _ = v5 - var v6 any + var tmp6 any { // let // let binding "iv" - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("volatile!")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v9, []any{int64(-1)}) - var v11 any = v10 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("volatile!")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp9, []any{int64(-1)}) + var v11 any = tmp10 _ = v11 - var v12 lang.FnFunc - v12 = lang.NewFnFunc(func(args ...any) any { + var tmp12 lang.FnFunc + tmp12 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - v13 := lang.Apply(v5, nil) - return v13 + tmp13 := lang.Apply(v5, nil) + return tmp13 case 1: v13 := args[0] _ = v13 - v14 := lang.Apply(v5, []any{v13}) - return v14 + tmp14 := lang.Apply(v5, []any{v13}) + return tmp14 case 2: v13 := args[0] _ = v13 v14 := args[1] _ = v14 - var v15 any + var tmp15 any { // let // let binding "i" - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("inc")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("inc")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) } - v18 := v17.Get() - v19, ok := lang.FieldOrMethod(v11, "Deref") + tmp18 := tmp17.Get() + tmp19, ok := lang.FieldOrMethod(v11, "Deref") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v11, "Deref"))) } - var v20 any - switch reflect.TypeOf(v19).Kind() { + var tmp20 any + switch reflect.TypeOf(tmp19).Kind() { case reflect.Func: - v20 = lang.Apply(v19, nil) + tmp20 = lang.Apply(tmp19, nil) default: - v20 = v19 + tmp20 = tmp19 } - v21 := lang.Apply(v18, []any{v20}) - v22, _ := lang.FieldOrMethod(v11, "reset") - if reflect.TypeOf(v22).Kind() != reflect.Func { + tmp21 := lang.Apply(tmp18, []any{tmp20}) + tmp22, _ := lang.FieldOrMethod(v11, "reset") + if reflect.TypeOf(tmp22).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) } - v23 := lang.Apply(v22, []any{v21}) - var v24 any = v23 + tmp23 := lang.Apply(tmp22, []any{tmp21}) + var v24 any = tmp23 _ = v24 - var v25 any - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("zero?")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + var tmp25 any + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("zero?")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) } - v28 := v27.Get() - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("rem")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + tmp28 := tmp27.Get() + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("rem")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) } - v31 := v30.Get() - v32 := lang.Apply(v31, []any{v24, v3}) - v33 := lang.Apply(v28, []any{v32}) - if lang.IsTruthy(v33) { - v34 := lang.Apply(v5, []any{v13, v14}) - v25 = v34 + tmp31 := tmp30.Get() + tmp32 := lang.Apply(tmp31, []any{v24, v3}) + tmp33 := lang.Apply(tmp28, []any{tmp32}) + if lang.IsTruthy(tmp33) { + tmp34 := lang.Apply(v5, []any{v13, v14}) + tmp25 = tmp34 } else { - v25 = v13 + tmp25 = v13 } - v15 = v25 + tmp15 = tmp25 } // end let - return v15 + return tmp15 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4295), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(4302), lang.NewKeyword("end-column"), int(28)) - v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) + tmp13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4295), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(4302), lang.NewKeyword("end-column"), int(28)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) if err != nil { panic(err) } - v6 = v14 + tmp6 = tmp14 } // end let - return v6 + return tmp6 }) - v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4293), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(4302), lang.NewKeyword("end-column"), int(30)) - v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) + tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4293), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(4302), lang.NewKeyword("end-column"), int(30)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) if err != nil { panic(err) } - return v6 + return tmp6 case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - var v5 lang.FnFunc - v5 = lang.NewFnFunc(func(args ...any) any { + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - var v6 any + var tmp6 any { // let // let binding "temp__0__auto__" - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("seq")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v9, []any{v4}) - var v11 any = v10 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("seq")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp9, []any{v4}) + var v11 any = tmp10 _ = v11 - var v12 any + var tmp12 any if lang.IsTruthy(v11) { - var v13 any + var tmp13 any { // let // let binding "s" var v14 any = v11 _ = v14 - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("cons")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("cons")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) } - v17 := v16.Get() - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("first")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) + tmp17 := tmp16.Get() + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("first")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) } - v20 := v19.Get() - v21 := lang.Apply(v20, []any{v14}) - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("take-nth")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + tmp20 := tmp19.Get() + tmp21 := lang.Apply(tmp20, []any{v14}) + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("take-nth")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) } - v24 := v23.Get() - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("drop")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + tmp24 := tmp23.Get() + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("drop")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) } - v27 := v26.Get() - v28 := lang.Apply(v27, []any{v3, v14}) - v29 := lang.Apply(v24, []any{v3, v28}) - v30 := lang.Apply(v17, []any{v21, v29}) - v13 = v30 + tmp27 := tmp26.Get() + tmp28 := lang.Apply(tmp27, []any{v3, v14}) + tmp29 := lang.Apply(tmp24, []any{v3, tmp28}) + tmp30 := lang.Apply(tmp17, []any{tmp21, tmp29}) + tmp13 = tmp30 } // end let - v12 = v13 + tmp12 = tmp13 } else { - v12 = nil } - v6 = v12 + tmp6 = tmp12 } // end let - return v6 + return tmp6 }) - v6 := lang.Apply(lang.NewLazySeq, []any{v5}) - return v6 + tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) + return tmp6 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // take-while { - v0 := lang.NewSymbol("take-while").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred")), lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of successive items from coll while\n (pred item) returns logical true. pred must be free of side-effects.\n Returns a transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2880), lang.NewKeyword("end-line"), int(2880))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("take-while").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred")), lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of successive items from coll while\n (pred item) returns logical true. pred must be free of side-effects.\n Returns a transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2880), lang.NewKeyword("end-line"), int(2880))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - var v4 lang.FnFunc - v4 = lang.NewFnFunc(func(args ...any) any { + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v5 := args[0] _ = v5 - var v6 lang.FnFunc - v6 = lang.NewFnFunc(func(args ...any) any { + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - v7 := lang.Apply(v5, nil) - return v7 + tmp7 := lang.Apply(v5, nil) + return tmp7 case 1: v7 := args[0] _ = v7 - v8 := lang.Apply(v5, []any{v7}) - return v8 + tmp8 := lang.Apply(v5, []any{v7}) + return tmp8 case 2: v7 := args[0] _ = v7 v8 := args[1] _ = v8 - var v9 any - v10 := lang.Apply(v3, []any{v8}) - if lang.IsTruthy(v10) { - v11 := lang.Apply(v5, []any{v7, v8}) - v9 = v11 + var tmp9 any + tmp10 := lang.Apply(v3, []any{v8}) + if lang.IsTruthy(tmp10) { + tmp11 := lang.Apply(v5, []any{v7, v8}) + tmp9 = tmp11 } else { - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("reduced")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("reduced")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) } - v14 := v13.Get() - v15 := lang.Apply(v14, []any{v7}) - v9 = v15 + tmp14 := tmp13.Get() + tmp15 := lang.Apply(tmp14, []any{v7}) + tmp9 = tmp15 } - return v9 + return tmp9 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2888), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(2894), lang.NewKeyword("end-column"), int(33)) - v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) + tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2888), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(2894), lang.NewKeyword("end-column"), int(33)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) if err != nil { panic(err) } - return v8 + return tmp8 }) - v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2887), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2894), lang.NewKeyword("end-column"), int(34)) - v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) + tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2887), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2894), lang.NewKeyword("end-column"), int(34)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) if err != nil { panic(err) } - return v6 + return tmp6 case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - var v5 lang.FnFunc - v5 = lang.NewFnFunc(func(args ...any) any { + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - var v6 any + var tmp6 any { // let // let binding "temp__0__auto__" - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("seq")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v9, []any{v4}) - var v11 any = v10 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("seq")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp9, []any{v4}) + var v11 any = tmp10 _ = v11 - var v12 any + var tmp12 any if lang.IsTruthy(v11) { - var v13 any + var tmp13 any { // let // let binding "s" var v14 any = v11 _ = v14 - var v15 any - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("first")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + var tmp15 any + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("first")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{v14}) - v20 := lang.Apply(v3, []any{v19}) - if lang.IsTruthy(v20) { - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("cons")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{v14}) + tmp20 := lang.Apply(v3, []any{tmp19}) + if lang.IsTruthy(tmp20) { + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("cons")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("first")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("first")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) } - v26 := v25.Get() - v27 := lang.Apply(v26, []any{v14}) - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("take-while")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) + tmp26 := tmp25.Get() + tmp27 := lang.Apply(tmp26, []any{v14}) + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("take-while")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) } - v30 := v29.Get() - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("rest")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + tmp30 := tmp29.Get() + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("rest")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{v14}) - v35 := lang.Apply(v30, []any{v3, v34}) - v36 := lang.Apply(v23, []any{v27, v35}) - v15 = v36 + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{v14}) + tmp35 := lang.Apply(tmp30, []any{v3, tmp34}) + tmp36 := lang.Apply(tmp23, []any{tmp27, tmp35}) + tmp15 = tmp36 } else { - v15 = nil } - v13 = v15 + tmp13 = tmp15 } // end let - v12 = v13 + tmp12 = tmp13 } else { - v12 = nil } - v6 = v12 + tmp6 = tmp12 } // end let - return v6 + return tmp6 }) - v6 := lang.Apply(lang.NewLazySeq, []any{v5}) - return v6 + tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) + return tmp6 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // tapset { - v0 := lang.NewSymbol("tapset").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7882), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(7882), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - v2 := lang.NewAtom(lang.CreatePersistentTreeSet()) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp0 := lang.NewSymbol("tapset").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7882), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(7882), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp2 := lang.NewAtom(lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{}))) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // test { - v0 := lang.NewSymbol("test").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("v"))), lang.NewKeyword("doc"), "test [v] finds fn at key :test in var metadata and calls it,\n presuming failure will throw exception", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4853), lang.NewKeyword("end-line"), int(4853))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("test").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("v"))), lang.NewKeyword("doc"), "test [v] finds fn at key :test in var metadata and calls it,\n presuming failure will throw exception", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4853), lang.NewKeyword("end-line"), int(4853))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any + var tmp4 any { // let // let binding "f" - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("meta")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v3}) - v9 := lang.Apply(lang.NewKeyword("test"), []any{v8}) - var v10 any = v9 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("meta")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v3}) + tmp9 := lang.Apply(lang.NewKeyword("test"), []any{tmp8}) + var v10 any = tmp9 _ = v10 - var v11 any + var tmp11 any if lang.IsTruthy(v10) { - v12 := lang.Apply(v10, nil) - _ = v12 - v11 = lang.NewKeyword("ok") + tmp12 := lang.Apply(v10, nil) + _ = tmp12 + tmp11 = lang.NewKeyword("ok") } else { - v11 = lang.NewKeyword("no-test") + tmp11 = lang.NewKeyword("no-test") } - v4 = v11 + tmp4 = tmp11 } // end let - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // the-ns { - v0 := lang.NewSymbol("the-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "If passed a namespace, returns it. Else, when passed a symbol,\n returns the namespace named by it, throwing an exception if not\n found.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4152), lang.NewKeyword("end-line"), int(4152))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("the-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "If passed a namespace, returns it. Else, when passed a symbol,\n returns the namespace named by it, throwing an exception if not\n found.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4152), lang.NewKeyword("end-line"), int(4152))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{*lang.Namespace, v3}) - if lang.IsTruthy(v8) { - v4 = v3 + var tmp4 any + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("instance?")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := reflect.TypeOf((*lang.Namespace)(nil)) + tmp9 := lang.Apply(tmp7, []any{tmp8, v3}) + if lang.IsTruthy(tmp9) { + tmp4 = v3 } else { - var v9 any + var tmp10 any { // let // let binding "or__0__auto__" - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("find-ns")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{v3}) - var v14 any = v13 - _ = v14 - var v15 any - if lang.IsTruthy(v14) { - v15 = v14 + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("find-ns")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{v3}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + if lang.IsTruthy(v15) { + tmp16 = v15 } else { - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("str")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("str")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{"No namespace: ", v3, " found"}) - v20 := lang.Apply(lang.NewError, []any{v19}) - panic(v20) + tmp19 := tmp18.Get() + tmp20 := lang.Apply(tmp19, []any{"No namespace: ", v3, " found"}) + tmp21 := lang.Apply(lang.NewError, []any{tmp20}) + panic(tmp21) } - v9 = v15 + tmp10 = tmp16 } // end let - v4 = v9 + tmp4 = tmp10 } - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // thread-bound? { - v0 := lang.NewSymbol("thread-bound?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("vars"))), lang.NewKeyword("doc"), "Returns true if all of the vars provided as arguments have thread-local bindings.\n Implies that set!'ing the provided vars will succeed. Returns true if no vars are provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5499), lang.NewKeyword("end-line"), int(5499))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("thread-bound?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("vars"))), lang.NewKeyword("doc"), "Returns true if all of the vars provided as arguments have thread-local bindings.\n Implies that set!'ing the provided vars will succeed. Returns true if no vars are provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5499), lang.NewKeyword("end-line"), int(5499))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v3 := lang.NewList(args[0:]...) - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("every?")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - var v7 lang.FnFunc - v7 = lang.NewFnFunc(func(args ...any) any { + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("every?")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v8 := args[0] _ = v8 - v9, ok := lang.FieldOrMethod(v8, "getThreadBinding") + tmp9, ok := lang.FieldOrMethod(v8, "getThreadBinding") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "getThreadBinding"))) } - var v10 any - switch reflect.TypeOf(v9).Kind() { + var tmp10 any + switch reflect.TypeOf(tmp9).Kind() { case reflect.Func: - v10 = lang.Apply(v9, nil) + tmp10 = lang.Apply(tmp9, nil) default: - v10 = v9 + tmp10 = tmp9 } - return v10 + return tmp10 }) - v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5505), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5505), lang.NewKeyword("end-column"), int(78)) - v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) + tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5505), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5505), lang.NewKeyword("end-column"), int(78)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) if err != nil { panic(err) } - v10 := lang.Apply(v6, []any{v9, v3}) - return v10 + tmp10 := lang.Apply(tmp6, []any{tmp9, v3}) + return tmp10 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // throw-if { - v0 := lang.NewSymbol("throw-if").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("fmt"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Throws a CompilerException with a message if pred is true", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5832), lang.NewKeyword("end-line"), int(5832), lang.NewKeyword("private"), true)).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("throw-if").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("fmt"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Throws a CompilerException with a message if pred is true", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5832), lang.NewKeyword("end-line"), int(5832), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 2 { @@ -78160,159 +78321,159 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.NewList(args[2:]...) - var v6 any + var v5 any = lang.NewList(args[2:]...) + _ = v5 + var tmp6 any if lang.IsTruthy(v3) { - var v7 any + var tmp7 any { // let // let binding "message" - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("apply")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("format")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v10, []any{v13, v4, v5}) - var v15 any = v14 + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("apply")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("format")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp10, []any{tmp13, v4, v5}) + var v15 any = tmp14 _ = v15 // let binding "exception" - v16 := lang.Apply(lang.NewError, []any{v15}) - var v17 any = v16 + tmp16 := lang.Apply(lang.NewError, []any{v15}) + var v17 any = tmp16 _ = v17 // let binding "raw-trace" - v18, ok := lang.FieldOrMethod(v17, "getStackTrace") + tmp18, ok := lang.FieldOrMethod(v17, "getStackTrace") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v17, "getStackTrace"))) } - var v19 any - switch reflect.TypeOf(v18).Kind() { + var tmp19 any + switch reflect.TypeOf(tmp18).Kind() { case reflect.Func: - v19 = lang.Apply(v18, nil) + tmp19 = lang.Apply(tmp18, nil) default: - v19 = v18 + tmp19 = tmp18 } - var v20 any = v19 + var v20 any = tmp19 _ = v20 // let binding "boring?" - var v21 lang.FnFunc - v21 = lang.NewFnFunc(func(args ...any) any { + var tmp21 lang.FnFunc + tmp21 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v22 := args[0] _ = v22 - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("not=")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("not=")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) } - v25 := v24.Get() - v26, ok := lang.FieldOrMethod(v22, "getMethodName") + tmp25 := tmp24.Get() + tmp26, ok := lang.FieldOrMethod(v22, "getMethodName") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v22, "getMethodName"))) } - var v27 any - switch reflect.TypeOf(v26).Kind() { + var tmp27 any + switch reflect.TypeOf(tmp26).Kind() { case reflect.Func: - v27 = lang.Apply(v26, nil) + tmp27 = lang.Apply(tmp26, nil) default: - v27 = v26 + tmp27 = tmp26 } - v28 := lang.Apply(v25, []any{v27, "doInvoke"}) - return v28 + tmp28 := lang.Apply(tmp25, []any{tmp27, "doInvoke"}) + return tmp28 }) - v22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5839), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(5839), lang.NewKeyword("end-column"), int(74)) - v23, err := lang.WithMeta(v21, v22.(lang.IPersistentMap)) + tmp22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5839), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(5839), lang.NewKeyword("end-column"), int(74)) + tmp23, err := lang.WithMeta(tmp21, tmp22.(lang.IPersistentMap)) if err != nil { panic(err) } - var v24 any = v23 + var v24 any = tmp23 _ = v24 // let binding "trace" - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("into-array")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("drop")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("drop-while")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{v24, v20}) - v35 := lang.Apply(v30, []any{int64(2), v34}) - v36 := lang.Apply(v27, []any{nil, v35}) - var v37 any = v36 + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("into-array")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("drop")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("drop-while")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{v24, v20}) + tmp35 := lang.Apply(tmp30, []any{int64(2), tmp34}) + tmp36 := lang.Apply(tmp27, []any{nil, tmp35}) + var v37 any = tmp36 _ = v37 - v38, _ := lang.FieldOrMethod(v17, "setStackTrace") - if reflect.TypeOf(v38).Kind() != reflect.Func { + tmp38, _ := lang.FieldOrMethod(v17, "setStackTrace") + if reflect.TypeOf(tmp38).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("setStackTrace is not a function"))) } - v39 := lang.Apply(v38, []any{v37}) - _ = v39 - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("*file*")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + tmp39 := lang.Apply(tmp38, []any{v37}) + _ = tmp39 + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("*file*")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) } - v42 := v41.Get() - v43, ok := lang.FieldOrMethod(nil, "Deref") + tmp42 := tmp41.Get() + tmp43, ok := lang.FieldOrMethod(nil, "Deref") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "Deref"))) } - var v44 any - switch reflect.TypeOf(v43).Kind() { + var tmp44 any + switch reflect.TypeOf(tmp43).Kind() { case reflect.Func: - v44 = lang.Apply(v43, nil) + tmp44 = lang.Apply(tmp43, nil) default: - v44 = v43 + tmp44 = tmp43 } - v45, ok := lang.FieldOrMethod(nil, "Deref") + tmp45, ok := lang.FieldOrMethod(nil, "Deref") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "Deref"))) } - var v46 any - switch reflect.TypeOf(v45).Kind() { + var tmp46 any + switch reflect.TypeOf(tmp45).Kind() { case reflect.Func: - v46 = lang.Apply(v45, nil) + tmp46 = lang.Apply(tmp45, nil) default: - v46 = v45 + tmp46 = tmp45 } - v47 := lang.Apply(lang.NewCompilerError, []any{v42, v44, v46, v17}) - panic(v47) + tmp47 := lang.Apply(lang.NewCompilerError, []any{tmp42, tmp44, tmp46, v17}) + panic(tmp47) } // end let - v6 = v7 + tmp6 = tmp7 } else { - v6 = nil } - return v6 + return tmp6 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // time { - v0 := lang.NewSymbol("time").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"))), lang.NewKeyword("doc"), "Evaluates expr and prints the time it took. Returns the value of\n expr.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3885), lang.NewKeyword("end-line"), int(3885))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("time").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"))), lang.NewKeyword("doc"), "Evaluates expr and prints the time it took. Returns the value of\n expr.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3885), lang.NewKeyword("end-line"), int(3885))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -78322,590 +78483,591 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("seq")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("concat")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("list")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.Apply(v14, []any{lang.NewSymbol("glojure.core/let")}) - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("list")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("apply")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("vector")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("seq")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("concat")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{lang.NewSymbol("start__0__auto__")}) - v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v36 := v35.FindInternedVar(lang.NewSymbol("list")) - if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) - } - v37 := v36.Get() - v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v39 := v38.FindInternedVar(lang.NewSymbol("seq")) - if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) - } - v40 := v39.Get() - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("concat")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) - } - v43 := v42.Get() - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("list")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) - } - v46 := v45.Get() - v47 := lang.Apply(v46, []any{lang.NewSymbol(".UnixNano")}) - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("list")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v52 := v51.FindInternedVar(lang.NewSymbol("seq")) - if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) - } - v53 := v52.Get() - v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v55 := v54.FindInternedVar(lang.NewSymbol("concat")) - if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) - } - v56 := v55.Get() - v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v58 := v57.FindInternedVar(lang.NewSymbol("list")) - if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) - } - v59 := v58.Get() - v60 := lang.Apply(v59, []any{lang.NewSymbol("time.Now")}) - v61 := lang.Apply(v56, []any{v60}) - v62 := lang.Apply(v53, []any{v61}) - v63 := lang.Apply(v50, []any{v62}) - v64 := lang.Apply(v43, []any{v47, v63}) - v65 := lang.Apply(v40, []any{v64}) - v66 := lang.Apply(v37, []any{v65}) - v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v68 := v67.FindInternedVar(lang.NewSymbol("list")) - if v68.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) - } - v69 := v68.Get() - v70 := lang.Apply(v69, []any{lang.NewSymbol("ret__1__auto__")}) - v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v72 := v71.FindInternedVar(lang.NewSymbol("list")) - if v72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) - } - v73 := v72.Get() - v74 := lang.Apply(v73, []any{v5}) - v75 := lang.Apply(v30, []any{v34, v66, v70, v74}) - v76 := lang.Apply(v27, []any{v75}) - v77 := lang.Apply(v21, []any{v24, v76}) - v78 := lang.Apply(v18, []any{v77}) - v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v80 := v79.FindInternedVar(lang.NewSymbol("list")) - if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) - } - v81 := v80.Get() - v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v83 := v82.FindInternedVar(lang.NewSymbol("seq")) - if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) - } - v84 := v83.Get() - v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v86 := v85.FindInternedVar(lang.NewSymbol("concat")) - if v86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) - } - v87 := v86.Get() - v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v89 := v88.FindInternedVar(lang.NewSymbol("list")) - if v89.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) - } - v90 := v89.Get() - v91 := lang.Apply(v90, []any{lang.NewSymbol("glojure.core/prn")}) - v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v93 := v92.FindInternedVar(lang.NewSymbol("list")) - if v93.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) - } - v94 := v93.Get() - v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v96 := v95.FindInternedVar(lang.NewSymbol("seq")) - if v96.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) - } - v97 := v96.Get() - v98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v99 := v98.FindInternedVar(lang.NewSymbol("concat")) - if v99.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v99))) - } - v100 := v99.Get() - v101 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v102 := v101.FindInternedVar(lang.NewSymbol("list")) - if v102.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v102))) - } - v103 := v102.Get() - v104 := lang.Apply(v103, []any{lang.NewSymbol("glojure.core/str")}) - v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v106 := v105.FindInternedVar(lang.NewSymbol("list")) - if v106.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) - } - v107 := v106.Get() - v108 := lang.Apply(v107, []any{"Elapsed time: "}) - v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v110 := v109.FindInternedVar(lang.NewSymbol("list")) - if v110.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) - } - v111 := v110.Get() - v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v113 := v112.FindInternedVar(lang.NewSymbol("seq")) - if v113.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) - } - v114 := v113.Get() - v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v116 := v115.FindInternedVar(lang.NewSymbol("concat")) - if v116.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) - } - v117 := v116.Get() - v118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v119 := v118.FindInternedVar(lang.NewSymbol("list")) - if v119.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v119))) - } - v120 := v119.Get() - v121 := lang.Apply(v120, []any{lang.NewSymbol("glojure.core//")}) - v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v123 := v122.FindInternedVar(lang.NewSymbol("list")) - if v123.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) - } - v124 := v123.Get() - v125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v126 := v125.FindInternedVar(lang.NewSymbol("seq")) - if v126.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v126))) - } - v127 := v126.Get() - v128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v129 := v128.FindInternedVar(lang.NewSymbol("concat")) - if v129.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v129))) - } - v130 := v129.Get() - v131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v132 := v131.FindInternedVar(lang.NewSymbol("list")) - if v132.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v132))) - } - v133 := v132.Get() - v134 := lang.Apply(v133, []any{lang.NewSymbol("glojure.core/double")}) - v135 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v136 := v135.FindInternedVar(lang.NewSymbol("list")) - if v136.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v136))) - } - v137 := v136.Get() - v138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v139 := v138.FindInternedVar(lang.NewSymbol("seq")) - if v139.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v139))) - } - v140 := v139.Get() - v141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v142 := v141.FindInternedVar(lang.NewSymbol("concat")) - if v142.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v142))) - } - v143 := v142.Get() - v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v145 := v144.FindInternedVar(lang.NewSymbol("list")) - if v145.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) - } - v146 := v145.Get() - v147 := lang.Apply(v146, []any{lang.NewSymbol("glojure.core/-")}) - v148 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v149 := v148.FindInternedVar(lang.NewSymbol("list")) - if v149.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v149))) - } - v150 := v149.Get() - v151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v152 := v151.FindInternedVar(lang.NewSymbol("seq")) - if v152.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v152))) - } - v153 := v152.Get() - v154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v155 := v154.FindInternedVar(lang.NewSymbol("concat")) - if v155.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v155))) - } - v156 := v155.Get() - v157 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v158 := v157.FindInternedVar(lang.NewSymbol("list")) - if v158.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v158))) - } - v159 := v158.Get() - v160 := lang.Apply(v159, []any{lang.NewSymbol(".UnixNano")}) - v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v162 := v161.FindInternedVar(lang.NewSymbol("list")) - if v162.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) - } - v163 := v162.Get() - v164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v165 := v164.FindInternedVar(lang.NewSymbol("seq")) - if v165.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v165))) - } - v166 := v165.Get() - v167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v168 := v167.FindInternedVar(lang.NewSymbol("concat")) - if v168.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v168))) - } - v169 := v168.Get() - v170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v171 := v170.FindInternedVar(lang.NewSymbol("list")) - if v171.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v171))) - } - v172 := v171.Get() - v173 := lang.Apply(v172, []any{lang.NewSymbol("time.Now")}) - v174 := lang.Apply(v169, []any{v173}) - v175 := lang.Apply(v166, []any{v174}) - v176 := lang.Apply(v163, []any{v175}) - v177 := lang.Apply(v156, []any{v160, v176}) - v178 := lang.Apply(v153, []any{v177}) - v179 := lang.Apply(v150, []any{v178}) - v180 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v181 := v180.FindInternedVar(lang.NewSymbol("list")) - if v181.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v181))) - } - v182 := v181.Get() - v183 := lang.Apply(v182, []any{lang.NewSymbol("start__0__auto__")}) - v184 := lang.Apply(v143, []any{v147, v179, v183}) - v185 := lang.Apply(v140, []any{v184}) - v186 := lang.Apply(v137, []any{v185}) - v187 := lang.Apply(v130, []any{v134, v186}) - v188 := lang.Apply(v127, []any{v187}) - v189 := lang.Apply(v124, []any{v188}) - v190 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v191 := v190.FindInternedVar(lang.NewSymbol("list")) - if v191.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v191))) - } - v192 := v191.Get() - v193 := lang.Apply(v192, []any{nil}) - v194 := lang.Apply(v117, []any{v121, v189, v193}) - v195 := lang.Apply(v114, []any{v194}) - v196 := lang.Apply(v111, []any{v195}) - v197 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v198 := v197.FindInternedVar(lang.NewSymbol("list")) - if v198.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v198))) - } - v199 := v198.Get() - v200 := lang.Apply(v199, []any{" msecs"}) - v201 := lang.Apply(v100, []any{v104, v108, v196, v200}) - v202 := lang.Apply(v97, []any{v201}) - v203 := lang.Apply(v94, []any{v202}) - v204 := lang.Apply(v87, []any{v91, v203}) - v205 := lang.Apply(v84, []any{v204}) - v206 := lang.Apply(v81, []any{v205}) - v207 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v208 := v207.FindInternedVar(lang.NewSymbol("list")) - if v208.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v208))) - } - v209 := v208.Get() - v210 := lang.Apply(v209, []any{lang.NewSymbol("ret__1__auto__")}) - v211 := lang.Apply(v11, []any{v15, v78, v206, v210}) - v212 := lang.Apply(v8, []any{v211}) - return v212 - }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("seq")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("concat")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("list")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("glojure.core/let")}) + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("list")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("apply")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("vector")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("seq")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("concat")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{lang.NewSymbol("start__0__auto__")}) + tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp36 := tmp35.FindInternedVar(lang.NewSymbol("list")) + if tmp36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) + } + tmp37 := tmp36.Get() + tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp39 := tmp38.FindInternedVar(lang.NewSymbol("seq")) + if tmp39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) + } + tmp40 := tmp39.Get() + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("concat")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) + } + tmp46 := tmp45.Get() + tmp47 := lang.Apply(tmp46, []any{lang.NewSymbol(".UnixNano")}) + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp52 := tmp51.FindInternedVar(lang.NewSymbol("seq")) + if tmp52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp52))) + } + tmp53 := tmp52.Get() + tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp55 := tmp54.FindInternedVar(lang.NewSymbol("concat")) + if tmp55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) + } + tmp56 := tmp55.Get() + tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp58 := tmp57.FindInternedVar(lang.NewSymbol("list")) + if tmp58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) + } + tmp59 := tmp58.Get() + tmp60 := lang.Apply(tmp59, []any{lang.NewSymbol("time.Now")}) + tmp61 := lang.Apply(tmp56, []any{tmp60}) + tmp62 := lang.Apply(tmp53, []any{tmp61}) + tmp63 := lang.Apply(tmp50, []any{tmp62}) + tmp64 := lang.Apply(tmp43, []any{tmp47, tmp63}) + tmp65 := lang.Apply(tmp40, []any{tmp64}) + tmp66 := lang.Apply(tmp37, []any{tmp65}) + tmp67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp68 := tmp67.FindInternedVar(lang.NewSymbol("list")) + if tmp68.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp68))) + } + tmp69 := tmp68.Get() + tmp70 := lang.Apply(tmp69, []any{lang.NewSymbol("ret__1__auto__")}) + tmp71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp72 := tmp71.FindInternedVar(lang.NewSymbol("list")) + if tmp72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp72))) + } + tmp73 := tmp72.Get() + tmp74 := lang.Apply(tmp73, []any{v5}) + tmp75 := lang.Apply(tmp30, []any{tmp34, tmp66, tmp70, tmp74}) + tmp76 := lang.Apply(tmp27, []any{tmp75}) + tmp77 := lang.Apply(tmp21, []any{tmp24, tmp76}) + tmp78 := lang.Apply(tmp18, []any{tmp77}) + tmp79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp80 := tmp79.FindInternedVar(lang.NewSymbol("list")) + if tmp80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp80))) + } + tmp81 := tmp80.Get() + tmp82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp83 := tmp82.FindInternedVar(lang.NewSymbol("seq")) + if tmp83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp83))) + } + tmp84 := tmp83.Get() + tmp85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp86 := tmp85.FindInternedVar(lang.NewSymbol("concat")) + if tmp86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp86))) + } + tmp87 := tmp86.Get() + tmp88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp89 := tmp88.FindInternedVar(lang.NewSymbol("list")) + if tmp89.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp89))) + } + tmp90 := tmp89.Get() + tmp91 := lang.Apply(tmp90, []any{lang.NewSymbol("glojure.core/prn")}) + tmp92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp93 := tmp92.FindInternedVar(lang.NewSymbol("list")) + if tmp93.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp93))) + } + tmp94 := tmp93.Get() + tmp95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp96 := tmp95.FindInternedVar(lang.NewSymbol("seq")) + if tmp96.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp96))) + } + tmp97 := tmp96.Get() + tmp98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp99 := tmp98.FindInternedVar(lang.NewSymbol("concat")) + if tmp99.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp99))) + } + tmp100 := tmp99.Get() + tmp101 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp102 := tmp101.FindInternedVar(lang.NewSymbol("list")) + if tmp102.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp102))) + } + tmp103 := tmp102.Get() + tmp104 := lang.Apply(tmp103, []any{lang.NewSymbol("glojure.core/str")}) + tmp105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp106 := tmp105.FindInternedVar(lang.NewSymbol("list")) + if tmp106.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp106))) + } + tmp107 := tmp106.Get() + tmp108 := lang.Apply(tmp107, []any{"Elapsed time: "}) + tmp109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp110 := tmp109.FindInternedVar(lang.NewSymbol("list")) + if tmp110.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp110))) + } + tmp111 := tmp110.Get() + tmp112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp113 := tmp112.FindInternedVar(lang.NewSymbol("seq")) + if tmp113.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp113))) + } + tmp114 := tmp113.Get() + tmp115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp116 := tmp115.FindInternedVar(lang.NewSymbol("concat")) + if tmp116.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp116))) + } + tmp117 := tmp116.Get() + tmp118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp119 := tmp118.FindInternedVar(lang.NewSymbol("list")) + if tmp119.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp119))) + } + tmp120 := tmp119.Get() + tmp121 := lang.Apply(tmp120, []any{lang.NewSymbol("glojure.core//")}) + tmp122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp123 := tmp122.FindInternedVar(lang.NewSymbol("list")) + if tmp123.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp123))) + } + tmp124 := tmp123.Get() + tmp125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp126 := tmp125.FindInternedVar(lang.NewSymbol("seq")) + if tmp126.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp126))) + } + tmp127 := tmp126.Get() + tmp128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp129 := tmp128.FindInternedVar(lang.NewSymbol("concat")) + if tmp129.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp129))) + } + tmp130 := tmp129.Get() + tmp131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp132 := tmp131.FindInternedVar(lang.NewSymbol("list")) + if tmp132.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp132))) + } + tmp133 := tmp132.Get() + tmp134 := lang.Apply(tmp133, []any{lang.NewSymbol("glojure.core/double")}) + tmp135 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp136 := tmp135.FindInternedVar(lang.NewSymbol("list")) + if tmp136.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp136))) + } + tmp137 := tmp136.Get() + tmp138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp139 := tmp138.FindInternedVar(lang.NewSymbol("seq")) + if tmp139.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp139))) + } + tmp140 := tmp139.Get() + tmp141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp142 := tmp141.FindInternedVar(lang.NewSymbol("concat")) + if tmp142.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp142))) + } + tmp143 := tmp142.Get() + tmp144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp145 := tmp144.FindInternedVar(lang.NewSymbol("list")) + if tmp145.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp145))) + } + tmp146 := tmp145.Get() + tmp147 := lang.Apply(tmp146, []any{lang.NewSymbol("glojure.core/-")}) + tmp148 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp149 := tmp148.FindInternedVar(lang.NewSymbol("list")) + if tmp149.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp149))) + } + tmp150 := tmp149.Get() + tmp151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp152 := tmp151.FindInternedVar(lang.NewSymbol("seq")) + if tmp152.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp152))) + } + tmp153 := tmp152.Get() + tmp154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp155 := tmp154.FindInternedVar(lang.NewSymbol("concat")) + if tmp155.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp155))) + } + tmp156 := tmp155.Get() + tmp157 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp158 := tmp157.FindInternedVar(lang.NewSymbol("list")) + if tmp158.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp158))) + } + tmp159 := tmp158.Get() + tmp160 := lang.Apply(tmp159, []any{lang.NewSymbol(".UnixNano")}) + tmp161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp162 := tmp161.FindInternedVar(lang.NewSymbol("list")) + if tmp162.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp162))) + } + tmp163 := tmp162.Get() + tmp164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp165 := tmp164.FindInternedVar(lang.NewSymbol("seq")) + if tmp165.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp165))) + } + tmp166 := tmp165.Get() + tmp167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp168 := tmp167.FindInternedVar(lang.NewSymbol("concat")) + if tmp168.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp168))) + } + tmp169 := tmp168.Get() + tmp170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp171 := tmp170.FindInternedVar(lang.NewSymbol("list")) + if tmp171.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp171))) + } + tmp172 := tmp171.Get() + tmp173 := lang.Apply(tmp172, []any{lang.NewSymbol("time.Now")}) + tmp174 := lang.Apply(tmp169, []any{tmp173}) + tmp175 := lang.Apply(tmp166, []any{tmp174}) + tmp176 := lang.Apply(tmp163, []any{tmp175}) + tmp177 := lang.Apply(tmp156, []any{tmp160, tmp176}) + tmp178 := lang.Apply(tmp153, []any{tmp177}) + tmp179 := lang.Apply(tmp150, []any{tmp178}) + tmp180 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp181 := tmp180.FindInternedVar(lang.NewSymbol("list")) + if tmp181.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp181))) + } + tmp182 := tmp181.Get() + tmp183 := lang.Apply(tmp182, []any{lang.NewSymbol("start__0__auto__")}) + tmp184 := lang.Apply(tmp143, []any{tmp147, tmp179, tmp183}) + tmp185 := lang.Apply(tmp140, []any{tmp184}) + tmp186 := lang.Apply(tmp137, []any{tmp185}) + tmp187 := lang.Apply(tmp130, []any{tmp134, tmp186}) + tmp188 := lang.Apply(tmp127, []any{tmp187}) + tmp189 := lang.Apply(tmp124, []any{tmp188}) + tmp190 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp191 := tmp190.FindInternedVar(lang.NewSymbol("list")) + if tmp191.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp191))) + } + tmp192 := tmp191.Get() + tmp193 := lang.Apply(tmp192, []any{nil}) + tmp194 := lang.Apply(tmp117, []any{tmp121, tmp189, tmp193}) + tmp195 := lang.Apply(tmp114, []any{tmp194}) + tmp196 := lang.Apply(tmp111, []any{tmp195}) + tmp197 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp198 := tmp197.FindInternedVar(lang.NewSymbol("list")) + if tmp198.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp198))) + } + tmp199 := tmp198.Get() + tmp200 := lang.Apply(tmp199, []any{" msecs"}) + tmp201 := lang.Apply(tmp100, []any{tmp104, tmp108, tmp196, tmp200}) + tmp202 := lang.Apply(tmp97, []any{tmp201}) + tmp203 := lang.Apply(tmp94, []any{tmp202}) + tmp204 := lang.Apply(tmp87, []any{tmp91, tmp203}) + tmp205 := lang.Apply(tmp84, []any{tmp204}) + tmp206 := lang.Apply(tmp81, []any{tmp205}) + tmp207 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp208 := tmp207.FindInternedVar(lang.NewSymbol("list")) + if tmp208.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp208))) + } + tmp209 := tmp208.Get() + tmp210 := lang.Apply(tmp209, []any{lang.NewSymbol("ret__1__auto__")}) + tmp211 := lang.Apply(tmp11, []any{tmp15, tmp78, tmp206, tmp210}) + tmp212 := lang.Apply(tmp8, []any{tmp211}) + return tmp212 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // to-array { - v0 := lang.NewSymbol("to-array").WithMeta(lang.NewMap(lang.NewKeyword("tag"), "[Ljava.lang.Object;", lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns an array of Objects containing the contents of coll, which\n can be any Collection. Maps to java.util.Collection.toArray().", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(337), lang.NewKeyword("end-line"), int(337))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("to-array").WithMeta(lang.NewMap(lang.NewKeyword("tag"), "[Ljava.lang.Object;", lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns an array of Objects containing the contents of coll, which\n can be any Collection. Maps to java.util.Collection.toArray().", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(337), lang.NewKeyword("end-line"), int(337))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4, _ := lang.FieldOrMethod(runtime4.RT, "ToArray") - if reflect.TypeOf(v4).Kind() != reflect.Func { + tmp4, _ := lang.FieldOrMethod(runtime4.RT, "ToArray") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("ToArray is not a function"))) } - v5 := lang.Apply(v4, []any{v3}) - return v5 + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), "[Ljava.lang.Object;")).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), "[Ljava.lang.Object;")).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // to-array-2d { - v0 := lang.NewSymbol("to-array-2d").WithMeta(lang.NewMap(lang.NewKeyword("tag"), "[[Ljava.lang.Object;", lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a (potentially-ragged) 2-dimensional array of Objects\n containing the contents of coll, which can be any Collection of any\n Collection.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4002), lang.NewKeyword("end-line"), int(4002))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("to-array-2d").WithMeta(lang.NewMap(lang.NewKeyword("tag"), "[[Ljava.lang.Object;", lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a (potentially-ragged) 2-dimensional array of Objects\n containing the contents of coll, which can be any Collection of any\n Collection.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4002), lang.NewKeyword("end-line"), int(4002))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any + var tmp4 any { // let // let binding "ret" - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("make-array")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8, _ := lang.FieldOrMethod(reflect.Type, "forName") - if reflect.TypeOf(v8).Kind() != reflect.Func { + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("make-array")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := reflect.TypeOf((*reflect.Type)(nil)).Elem() + tmp9, _ := lang.FieldOrMethod(tmp8, "forName") + if reflect.TypeOf(tmp9).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("forName is not a function"))) } - v9 := lang.Apply(v8, []any{"[Ljava.lang.Object;"}) - v10, _ := lang.FieldOrMethod(v3, "size") - if reflect.TypeOf(v10).Kind() != reflect.Func { + tmp10 := lang.Apply(tmp9, []any{"[Ljava.lang.Object;"}) + tmp11, _ := lang.FieldOrMethod(v3, "size") + if reflect.TypeOf(tmp11).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("size is not a function"))) } - v11 := lang.Apply(v10, []any{}) - v12 := lang.Apply(v7, []any{v9, v11}) - var v13 any = v12 - _ = v13 - var v14 any + tmp12 := lang.Apply(tmp11, []any{}) + tmp13 := lang.Apply(tmp7, []any{tmp10, tmp12}) + var v14 any = tmp13 + _ = v14 + var tmp15 any { // let // let binding "i" - var v15 any = int64(0) - _ = v15 + var v16 any = int64(0) + _ = v16 // let binding "xs" - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("seq")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{v3}) - var v20 any = v19 - _ = v20 + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.Apply(tmp19, []any{v3}) + var v21 any = tmp20 + _ = v21 for { - var v21 any - if lang.IsTruthy(v20) { - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("aset")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("to-array")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("first")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.Apply(v30, []any{v20}) - v32 := lang.Apply(v27, []any{v31}) - v33 := lang.Apply(v24, []any{v13, v15, v32}) - _ = v33 - v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v36 := v35.FindInternedVar(lang.NewSymbol("inc")) - if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) - } - v37 := v36.Get() - v38 := lang.Apply(v37, []any{v15}) - var v34 any = v38 - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("next")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) - } - v42 := v41.Get() - v43 := lang.Apply(v42, []any{v20}) - var v39 any = v43 - v15 = v34 - v20 = v39 + var tmp22 any + if lang.IsTruthy(v21) { + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("aset")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("to-array")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) + } + tmp28 := tmp27.Get() + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("first")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.Apply(tmp31, []any{v21}) + tmp33 := lang.Apply(tmp28, []any{tmp32}) + tmp34 := lang.Apply(tmp25, []any{v14, v16, tmp33}) + _ = tmp34 + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("inc")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{v16}) + var tmp35 any = tmp39 + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("next")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := lang.Apply(tmp43, []any{v21}) + var tmp40 any = tmp44 + v16 = tmp35 + v21 = tmp40 continue } else { - v21 = nil } - v14 = v21 + tmp15 = tmp22 break } } // end let - _ = v14 - v4 = v13 + _ = tmp15 + tmp4 = v14 } // end let - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), "[[Ljava.lang.Object;")).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), "[[Ljava.lang.Object;")).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // trampoline { - v0 := lang.NewSymbol("trampoline").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "trampoline can be used to convert algorithms requiring mutual\n recursion without stack consumption. Calls f with supplied args, if\n any. If f returns a fn, calls that fn with no arguments, and\n continues to repeat, until the return value is not a fn, then\n returns that non-fn value. Note that if you want to return a fn as a\n final value, you must wrap it in some data structure and unpack it\n after trampoline returns.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6293), lang.NewKeyword("end-line"), int(6293))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("trampoline").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "trampoline can be used to convert algorithms requiring mutual\n recursion without stack consumption. Calls f with supplied args, if\n any. If f returns a fn, calls that fn with no arguments, and\n continues to repeat, until the return value is not a fn, then\n returns that non-fn value. Note that if you want to return a fn as a\n final value, you must wrap it in some data structure and unpack it\n after trampoline returns.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6293), lang.NewKeyword("end-line"), int(6293))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 recur_loop_1073: - var v4 any + var tmp4 any { // let // let binding "ret" - v5 := lang.Apply(v3, nil) - var v6 any = v5 + tmp5 := lang.Apply(v3, nil) + var v6 any = tmp5 _ = v6 - var v7 any - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("fn?")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v6}) - if lang.IsTruthy(v11) { - var v12 any = v6 - v3 = v12 + var tmp7 any + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("fn?")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v6}) + if lang.IsTruthy(tmp11) { + var tmp12 any = v6 + v3 = tmp12 goto recur_loop_1073 } else { - v7 = v6 + tmp7 = v6 } - v4 = v7 + tmp4 = tmp7 } // end let - return v4 + return tmp4 default: if len(args) < 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.NewList(args[1:]...) - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("trampoline")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - var v8 lang.FnFunc - v8 = lang.NewFnFunc(func(args ...any) any { + var v4 any = lang.NewList(args[1:]...) + _ = v4 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("trampoline")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + var tmp8 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("apply")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("apply")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) } - v11 := v10.Get() - v12 := lang.Apply(v11, []any{v3, v4}) - return v12 + tmp11 := tmp10.Get() + tmp12 := lang.Apply(tmp11, []any{v3, v4}) + return tmp12 }) - v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6309), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(6309), lang.NewKeyword("end-column"), int(32)) - v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) + tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6309), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(6309), lang.NewKeyword("end-column"), int(32)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) if err != nil { panic(err) } - v11 := lang.Apply(v7, []any{v10}) - return v11 + tmp11 := lang.Apply(tmp7, []any{tmp10}) + return tmp11 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // transduce { - v0 := lang.NewSymbol("transduce").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "reduce with a transformation of f (xf). If init is not\n supplied, (f) will be called to produce it. f should be a reducing\n step function that accepts both 1 and 2 arguments, if it accepts\n only 2 you can add the arity-1 with 'completing'. Returns the result\n of applying (the transformed) xf to init and the first item in coll,\n then applying xf to that result and the 2nd item, etc. If coll\n contains no items, returns init and f is not called. Note that\n certain transforms may inject or skip items.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6905), lang.NewKeyword("end-line"), int(6905))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("transduce").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "reduce with a transformation of f (xf). If init is not\n supplied, (f) will be called to produce it. f should be a reducing\n step function that accepts both 1 and 2 arguments, if it accepts\n only 2 you can add the arity-1 with 'completing'. Returns the result\n of applying (the transformed) xf to init and the first item in coll,\n then applying xf to that result and the 2nd item, etc. If coll\n contains no items, returns init and f is not called. Note that\n certain transforms may inject or skip items.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6905), lang.NewKeyword("end-line"), int(6905))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 3: v3 := args[0] @@ -78914,15 +79076,15 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("transduce")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v4, nil) - v10 := lang.Apply(v8, []any{v3, v4, v9, v5}) - return v10 + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("transduce")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.Apply(v4, nil) + tmp10 := lang.Apply(tmp8, []any{v3, v4, tmp9, v5}) + return tmp10 case 4: v3 := args[0] _ = v3 @@ -78932,88 +79094,89 @@ func init() { _ = v5 v6 := args[3] _ = v6 - var v7 any + var tmp7 any { // let // let binding "f" - v8 := lang.Apply(v3, []any{v4}) - var v9 any = v8 + tmp8 := lang.Apply(v3, []any{v4}) + var v9 any = tmp8 _ = v9 // let binding "ret" - var v10 any - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("instance?")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{lang.IReduceInit, v6}) - if lang.IsTruthy(v14) { - v15, _ := lang.FieldOrMethod(v6, "ReduceInit") - if reflect.TypeOf(v15).Kind() != reflect.Func { + var tmp10 any + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("instance?")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := reflect.TypeOf((*lang.IReduceInit)(nil)).Elem() + tmp15 := lang.Apply(tmp13, []any{tmp14, v6}) + if lang.IsTruthy(tmp15) { + tmp16, _ := lang.FieldOrMethod(v6, "ReduceInit") + if reflect.TypeOf(tmp16).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) } - v16 := lang.Apply(v15, []any{v9, v5}) - v10 = v16 + tmp17 := lang.Apply(tmp16, []any{v9, v5}) + tmp10 = tmp17 } else { - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core.protocols")) - v18 := v17.FindInternedVar(lang.NewSymbol("coll-reduce")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core.protocols")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("coll-reduce")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) } - v19 := v18.Get() - v20 := lang.Apply(v19, []any{v6, v9, v5}) - v10 = v20 + tmp20 := tmp19.Get() + tmp21 := lang.Apply(tmp20, []any{v6, v9, v5}) + tmp10 = tmp21 } - var v21 any = v10 - _ = v21 - v22 := lang.Apply(v9, []any{v21}) - v7 = v22 + var v22 any = tmp10 + _ = v22 + tmp23 := lang.Apply(v9, []any{v22}) + tmp7 = tmp23 } // end let - return v7 + return tmp7 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // transient { - v0 := lang.NewSymbol("transient").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a new, transient version of the collection, in constant time.\n\n Transients support a parallel set of 'changing' operations, with similar names\n followed by ! - assoc!, conj! etc. These do the same things as their persistent\n counterparts except the return values are themselves transient.\n\n Note in particular that transients are not designed to be bashed in-place. You\n must capture and use the return value in the next call. In this way, they support\n the same code structure as the functional persistent code they replace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3335), lang.NewKeyword("end-line"), int(3335))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("transient").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a new, transient version of the collection, in constant time.\n\n Transients support a parallel set of 'changing' operations, with similar names\n followed by ! - assoc!, conj! etc. These do the same things as their persistent\n counterparts except the return values are themselves transient.\n\n Note in particular that transients are not designed to be bashed in-place. You\n must capture and use the return value in the next call. In this way, they support\n the same code structure as the functional persistent code they replace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3335), lang.NewKeyword("end-line"), int(3335))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4, ok := lang.FieldOrMethod(v3, "AsTransient") + tmp4, ok := lang.FieldOrMethod(v3, "AsTransient") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "AsTransient"))) } - var v5 any - switch reflect.TypeOf(v4).Kind() { + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { case reflect.Func: - v5 = lang.Apply(v4, nil) + tmp5 = lang.Apply(tmp4, nil) default: - v5 = v4 + tmp5 = tmp4 } - return v5 + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // tree-seq { - v0 := lang.NewSymbol("tree-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("branch?"), lang.NewSymbol("children"), lang.NewSymbol("root"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the nodes in a tree, via a depth-first walk.\n branch? must be a fn of one arg that returns true if passed a node\n that can have children (but may not). children must be a fn of one\n arg that returns a sequence of the children. Will only be called on\n nodes for which branch? returns true. Root is the root node of the\n tree.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4955), lang.NewKeyword("end-line"), int(4955))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("tree-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("branch?"), lang.NewSymbol("children"), lang.NewSymbol("root"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the nodes in a tree, via a depth-first walk.\n branch? must be a fn of one arg that returns true if passed a node\n that can have children (but may not). children must be a fn of one\n arg that returns a sequence of the children. Will only be called on\n nodes for which branch? returns true. Root is the root node of the\n tree.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4955), lang.NewKeyword("end-line"), int(4955))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -79023,148 +79186,149 @@ func init() { _ = v4 v5 := args[2] _ = v5 - var v6 any + var tmp6 any { // let // let binding "walk" - var v7 lang.FnFunc + var tmp7 lang.FnFunc { // function walk - v7 = lang.NewFnFunc(func(args ...any) any { + var v8 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v9 := args[0] _ = v9 - var v10 lang.FnFunc - v10 = lang.NewFnFunc(func(args ...any) any { + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("cons")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - var v14 any - v15 := lang.Apply(v3, []any{v9}) - if lang.IsTruthy(v15) { - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("mapcat")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("cons")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + var tmp14 any + tmp15 := lang.Apply(v3, []any{v9}) + if lang.IsTruthy(tmp15) { + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("mapcat")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) } - v18 := v17.Get() - v19 := lang.Apply(v4, []any{v9}) - v20 := lang.Apply(v18, []any{v8, v19}) - v14 = v20 + tmp18 := tmp17.Get() + tmp19 := lang.Apply(v4, []any{v9}) + tmp20 := lang.Apply(tmp18, []any{v8, tmp19}) + tmp14 = tmp20 } else { - v14 = nil } - v21 := lang.Apply(v13, []any{v9, v14}) - return v21 + tmp21 := lang.Apply(tmp13, []any{v9, tmp14}) + return tmp21 }) - v11 := lang.Apply(lang.NewLazySeq, []any{v10}) - return v11 + tmp11 := lang.Apply(lang.NewLazySeq, []any{tmp10}) + return tmp11 }) - v8 := v7 + v8 = tmp7 _ = v8 } - v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4965), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(4969), lang.NewKeyword("end-column"), int(53)) - v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) + tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4965), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(4969), lang.NewKeyword("end-column"), int(53)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) if err != nil { panic(err) } - var v10 any = v9 + var v10 any = tmp9 _ = v10 - v11 := lang.Apply(v10, []any{v5}) - v6 = v11 + tmp11 := lang.Apply(v10, []any{v5}) + tmp6 = tmp11 } // end let - return v6 + return tmp6 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // true? { - v1 := reflect.TypeOf(false) - v0 := lang.NewSymbol("true?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is the value true, false otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(511), lang.NewKeyword("end-line"), int(511))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp1 := reflect.TypeOf(false) + tmp0 := lang.NewSymbol("true?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is the value true, false otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(511), lang.NewKeyword("end-line"), int(511))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5 := lang.Apply(lang.Identical, []any{v4, true}) - return v5 + tmp5 := lang.Apply(lang.Identical, []any{v4, true}) + return tmp5 }) - v4 := reflect.TypeOf(false) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp4 := reflect.TypeOf(false) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // type { - v0 := lang.NewSymbol("type").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns the :type metadata of x, or its Class if none", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3467), lang.NewKeyword("end-line"), int(3467))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("type").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns the :type metadata of x, or its Class if none", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3467), lang.NewKeyword("end-line"), int(3467))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any + var tmp4 any { // let // let binding "or__0__auto__" - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("get")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("meta")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v3}) - v12 := lang.Apply(v7, []any{v11, lang.NewKeyword("type")}) - var v13 any = v12 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("get")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("meta")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v3}) + tmp12 := lang.Apply(tmp7, []any{tmp11, lang.NewKeyword("type")}) + var v13 any = tmp12 _ = v13 - var v14 any + var tmp14 any if lang.IsTruthy(v13) { - v14 = v13 + tmp14 = v13 } else { - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("class")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("class")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{v3}) - v14 = v18 + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp14 = tmp18 } - v4 = v14 + tmp4 = tmp14 } // end let - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // unchecked-add { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function unchecked-add__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -79172,84 +79336,84 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("seq")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("concat")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("list")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("list")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("list")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("seq")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("concat")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("list")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/UncheckedAdd")}) - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("list")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{v3}) - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("list")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.Apply(v38, []any{v4}) - v40 := lang.Apply(v27, []any{v31, v35, v39}) - v41 := lang.Apply(v24, []any{v40}) - v42 := lang.Apply(v21, []any{v41}) - v43 := lang.Apply(v10, []any{v14, v18, v42}) - v44 := lang.Apply(v7, []any{v43}) - return v44 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("concat")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("list")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol(".")}) + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("seq")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("concat")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("list")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.Apply(tmp30, []any{lang.NewSymbol("glojure.core/UncheckedAdd")}) + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.Apply(tmp34, []any{v3}) + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{v4}) + tmp40 := lang.Apply(tmp27, []any{tmp31, tmp35, tmp39}) + tmp41 := lang.Apply(tmp24, []any{tmp40}) + tmp42 := lang.Apply(tmp21, []any{tmp41}) + tmp43 := lang.Apply(tmp10, []any{tmp14, tmp18, tmp42}) + tmp44 := lang.Apply(tmp7, []any{tmp43}) + return tmp44 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("unchecked-add").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the sum of x and y, both long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1203), lang.NewKeyword("end-line"), int(1203))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("unchecked-add").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the sum of x and y, both long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1203), lang.NewKeyword("end-line"), int(1203))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -79257,24 +79421,25 @@ func init() { _ = v4 v5 := args[1] _ = v5 - v6, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedAdd") - if reflect.TypeOf(v6).Kind() != reflect.Func { + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedAdd") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedAdd is not a function"))) } - v7 := lang.Apply(v6, []any{v4, v5}) - return v7 + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // unchecked-add-int { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function unchecked-add-int__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -79282,84 +79447,84 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("seq")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("concat")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("list")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("list")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("list")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("seq")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("concat")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("list")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/Unchecked_int_add")}) - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("list")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{v3}) - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("list")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.Apply(v38, []any{v4}) - v40 := lang.Apply(v27, []any{v31, v35, v39}) - v41 := lang.Apply(v24, []any{v40}) - v42 := lang.Apply(v21, []any{v41}) - v43 := lang.Apply(v10, []any{v14, v18, v42}) - v44 := lang.Apply(v7, []any{v43}) - return v44 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("concat")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("list")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol(".")}) + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("seq")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("concat")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("list")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.Apply(tmp30, []any{lang.NewSymbol("glojure.core/Unchecked_int_add")}) + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.Apply(tmp34, []any{v3}) + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{v4}) + tmp40 := lang.Apply(tmp27, []any{tmp31, tmp35, tmp39}) + tmp41 := lang.Apply(tmp24, []any{tmp40}) + tmp42 := lang.Apply(tmp21, []any{tmp41}) + tmp43 := lang.Apply(tmp10, []any{tmp14, tmp18, tmp42}) + tmp44 := lang.Apply(tmp7, []any{tmp43}) + return tmp44 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("unchecked-add-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the sum of x and y, both int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1196), lang.NewKeyword("end-line"), int(1196))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("unchecked-add-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the sum of x and y, both int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1196), lang.NewKeyword("end-line"), int(1196))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -79367,416 +79532,421 @@ func init() { _ = v4 v5 := args[1] _ = v5 - v6, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_add") - if reflect.TypeOf(v6).Kind() != reflect.Func { + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_add") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_add is not a function"))) } - v7 := lang.Apply(v6, []any{v4, v5}) - return v7 + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // unchecked-byte { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function unchecked-byte__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("concat")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("list")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("seq")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("concat")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/UncheckedByteCast")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{v3}) - v35 := lang.Apply(v26, []any{v30, v34}) - v36 := lang.Apply(v23, []any{v35}) - v37 := lang.Apply(v20, []any{v36}) - v38 := lang.Apply(v9, []any{v13, v17, v37}) - v39 := lang.Apply(v6, []any{v38}) - return v39 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/UncheckedByteCast")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{v3}) + tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) + tmp36 := lang.Apply(tmp23, []any{tmp35}) + tmp37 := lang.Apply(tmp20, []any{tmp36}) + tmp38 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp37}) + tmp39 := lang.Apply(tmp6, []any{tmp38}) + return tmp39 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("unchecked-byte").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to byte. Subject to rounding or truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3517), lang.NewKeyword("end-line"), int(3517))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("unchecked-byte").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to byte. Subject to rounding or truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3517), lang.NewKeyword("end-line"), int(3517))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5 := lang.Apply(lang.UncheckedByteCast, []any{v4}) - return v5 + tmp5 := lang.Apply(lang.UncheckedByteCast, []any{v4}) + return tmp5 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // unchecked-char { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function unchecked-char__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("concat")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("list")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("seq")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("concat")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/UncheckedCharCast")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{v3}) - v35 := lang.Apply(v26, []any{v30, v34}) - v36 := lang.Apply(v23, []any{v35}) - v37 := lang.Apply(v20, []any{v36}) - v38 := lang.Apply(v9, []any{v13, v17, v37}) - v39 := lang.Apply(v6, []any{v38}) - return v39 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/UncheckedCharCast")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{v3}) + tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) + tmp36 := lang.Apply(tmp23, []any{tmp35}) + tmp37 := lang.Apply(tmp20, []any{tmp36}) + tmp38 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp37}) + tmp39 := lang.Apply(tmp6, []any{tmp38}) + return tmp39 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("unchecked-char").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to char. Subject to rounding or truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3529), lang.NewKeyword("end-line"), int(3529))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("unchecked-char").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to char. Subject to rounding or truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3529), lang.NewKeyword("end-line"), int(3529))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5, _ := lang.FieldOrMethod(runtime4.RT, "UncheckedCharCast") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(runtime4.RT, "UncheckedCharCast") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedCharCast is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // unchecked-dec { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function unchecked-dec__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("concat")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("list")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("seq")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("concat")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/UncheckedDec")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{v3}) - v35 := lang.Apply(v26, []any{v30, v34}) - v36 := lang.Apply(v23, []any{v35}) - v37 := lang.Apply(v20, []any{v36}) - v38 := lang.Apply(v9, []any{v13, v17, v37}) - v39 := lang.Apply(v6, []any{v38}) - return v39 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/UncheckedDec")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{v3}) + tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) + tmp36 := lang.Apply(tmp23, []any{tmp35}) + tmp37 := lang.Apply(tmp20, []any{tmp36}) + tmp38 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp37}) + tmp39 := lang.Apply(tmp6, []any{tmp38}) + return tmp39 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("unchecked-dec").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns a number one less than x, a long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1175), lang.NewKeyword("end-line"), int(1175))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("unchecked-dec").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns a number one less than x, a long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1175), lang.NewKeyword("end-line"), int(1175))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedDec") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedDec") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedDec is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // unchecked-dec-int { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function unchecked-dec-int__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("concat")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("list")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("seq")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("concat")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/Unchecked_int_dec")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{v3}) - v35 := lang.Apply(v26, []any{v30, v34}) - v36 := lang.Apply(v23, []any{v35}) - v37 := lang.Apply(v20, []any{v36}) - v38 := lang.Apply(v9, []any{v13, v17, v37}) - v39 := lang.Apply(v6, []any{v38}) - return v39 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/Unchecked_int_dec")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{v3}) + tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) + tmp36 := lang.Apply(tmp23, []any{tmp35}) + tmp37 := lang.Apply(tmp20, []any{tmp36}) + tmp38 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp37}) + tmp39 := lang.Apply(tmp6, []any{tmp38}) + return tmp39 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("unchecked-dec-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns a number one less than x, an int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1168), lang.NewKeyword("end-line"), int(1168))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("unchecked-dec-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns a number one less than x, an int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1168), lang.NewKeyword("end-line"), int(1168))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_dec") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_dec") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_dec is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // unchecked-divide-int { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function unchecked-divide-int__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -79784,84 +79954,84 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("seq")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("concat")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("list")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("list")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("list")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("seq")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("concat")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("list")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/UncheckedIntDivide")}) - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("list")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{v3}) - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("list")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.Apply(v38, []any{v4}) - v40 := lang.Apply(v27, []any{v31, v35, v39}) - v41 := lang.Apply(v24, []any{v40}) - v42 := lang.Apply(v21, []any{v41}) - v43 := lang.Apply(v10, []any{v14, v18, v42}) - v44 := lang.Apply(v7, []any{v43}) - return v44 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("concat")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("list")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol(".")}) + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("seq")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("concat")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("list")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.Apply(tmp30, []any{lang.NewSymbol("glojure.core/UncheckedIntDivide")}) + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.Apply(tmp34, []any{v3}) + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{v4}) + tmp40 := lang.Apply(tmp27, []any{tmp31, tmp35, tmp39}) + tmp41 := lang.Apply(tmp24, []any{tmp40}) + tmp42 := lang.Apply(tmp21, []any{tmp41}) + tmp43 := lang.Apply(tmp10, []any{tmp14, tmp18, tmp42}) + tmp44 := lang.Apply(tmp7, []any{tmp43}) + return tmp44 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("unchecked-divide-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the division of x by y, both int.\n Note - uses a primitive operator subject to truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(26), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1238), lang.NewKeyword("end-line"), int(1238))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("unchecked-divide-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the division of x by y, both int.\n Note - uses a primitive operator subject to truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(26), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1238), lang.NewKeyword("end-line"), int(1238))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -79869,602 +80039,609 @@ func init() { _ = v4 v5 := args[1] _ = v5 - v6, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedIntDivide") - if reflect.TypeOf(v6).Kind() != reflect.Func { + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedIntDivide") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedIntDivide is not a function"))) } - v7 := lang.Apply(v6, []any{v4, v5}) - return v7 + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // unchecked-double { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function unchecked-double__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("concat")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("list")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("seq")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("concat")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/UncheckedDoubleCast")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{v3}) - v35 := lang.Apply(v26, []any{v30, v34}) - v36 := lang.Apply(v23, []any{v35}) - v37 := lang.Apply(v20, []any{v36}) - v38 := lang.Apply(v9, []any{v13, v17, v37}) - v39 := lang.Apply(v6, []any{v38}) - return v39 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/UncheckedDoubleCast")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{v3}) + tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) + tmp36 := lang.Apply(tmp23, []any{tmp35}) + tmp37 := lang.Apply(tmp20, []any{tmp36}) + tmp38 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp37}) + tmp39 := lang.Apply(tmp6, []any{tmp38}) + return tmp39 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("unchecked-double").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to double. Subject to rounding.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3553), lang.NewKeyword("end-line"), int(3553))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("unchecked-double").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to double. Subject to rounding.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3553), lang.NewKeyword("end-line"), int(3553))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5 := lang.Apply(lang.AsFloat64, []any{v4}) - return v5 + tmp5 := lang.Apply(lang.AsFloat64, []any{v4}) + return tmp5 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // unchecked-float { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function unchecked-float__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("concat")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("list")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("seq")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("concat")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/UncheckedFloatCast")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{v3}) - v35 := lang.Apply(v26, []any{v30, v34}) - v36 := lang.Apply(v23, []any{v35}) - v37 := lang.Apply(v20, []any{v36}) - v38 := lang.Apply(v9, []any{v13, v17, v37}) - v39 := lang.Apply(v6, []any{v38}) - return v39 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/UncheckedFloatCast")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{v3}) + tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) + tmp36 := lang.Apply(tmp23, []any{tmp35}) + tmp37 := lang.Apply(tmp20, []any{tmp36}) + tmp38 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp37}) + tmp39 := lang.Apply(tmp6, []any{tmp38}) + return tmp39 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("unchecked-float").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to float. Subject to rounding.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3547), lang.NewKeyword("end-line"), int(3547))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("unchecked-float").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to float. Subject to rounding.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3547), lang.NewKeyword("end-line"), int(3547))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5 := lang.Apply(lang.UncheckedFloatCast, []any{v4}) - return v5 + tmp5 := lang.Apply(lang.UncheckedFloatCast, []any{v4}) + return tmp5 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // unchecked-inc { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function unchecked-inc__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("concat")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("list")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("seq")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("concat")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/Unchecked_inc")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{v3}) - v35 := lang.Apply(v26, []any{v30, v34}) - v36 := lang.Apply(v23, []any{v35}) - v37 := lang.Apply(v20, []any{v36}) - v38 := lang.Apply(v9, []any{v13, v17, v37}) - v39 := lang.Apply(v6, []any{v38}) - return v39 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/Unchecked_inc")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{v3}) + tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) + tmp36 := lang.Apply(tmp23, []any{tmp35}) + tmp37 := lang.Apply(tmp20, []any{tmp36}) + tmp38 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp37}) + tmp39 := lang.Apply(tmp6, []any{tmp38}) + return tmp39 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("unchecked-inc").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns a number one greater than x, a long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1161), lang.NewKeyword("end-line"), int(1161))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("unchecked-inc").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns a number one greater than x, a long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1161), lang.NewKeyword("end-line"), int(1161))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_inc") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_inc") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_inc is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // unchecked-inc-int { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function unchecked-inc-int__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("concat")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("list")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("seq")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("concat")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/Unchecked_int_inc")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{v3}) - v35 := lang.Apply(v26, []any{v30, v34}) - v36 := lang.Apply(v23, []any{v35}) - v37 := lang.Apply(v20, []any{v36}) - v38 := lang.Apply(v9, []any{v13, v17, v37}) - v39 := lang.Apply(v6, []any{v38}) - return v39 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/Unchecked_int_inc")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{v3}) + tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) + tmp36 := lang.Apply(tmp23, []any{tmp35}) + tmp37 := lang.Apply(tmp20, []any{tmp36}) + tmp38 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp37}) + tmp39 := lang.Apply(tmp6, []any{tmp38}) + return tmp39 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("unchecked-inc-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns a number one greater than x, an int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1154), lang.NewKeyword("end-line"), int(1154))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("unchecked-inc-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns a number one greater than x, an int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1154), lang.NewKeyword("end-line"), int(1154))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_inc") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_inc") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_inc is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // unchecked-int { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function unchecked-int__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("concat")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("list")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("seq")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("concat")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/UncheckedIntCast")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{v3}) - v35 := lang.Apply(v26, []any{v30, v34}) - v36 := lang.Apply(v23, []any{v35}) - v37 := lang.Apply(v20, []any{v36}) - v38 := lang.Apply(v9, []any{v13, v17, v37}) - v39 := lang.Apply(v6, []any{v38}) - return v39 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/UncheckedIntCast")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{v3}) + tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) + tmp36 := lang.Apply(tmp23, []any{tmp35}) + tmp37 := lang.Apply(tmp20, []any{tmp36}) + tmp38 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp37}) + tmp39 := lang.Apply(tmp6, []any{tmp38}) + return tmp39 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("unchecked-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to int. Subject to rounding or truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3535), lang.NewKeyword("end-line"), int(3535))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("unchecked-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to int. Subject to rounding or truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3535), lang.NewKeyword("end-line"), int(3535))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5 := lang.Apply(lang.UncheckedIntCast, []any{v4}) - return v5 + tmp5 := lang.Apply(lang.UncheckedIntCast, []any{v4}) + return tmp5 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // unchecked-long { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function unchecked-long__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("concat")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("list")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("seq")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("concat")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/UncheckedLongCast")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{v3}) - v35 := lang.Apply(v26, []any{v30, v34}) - v36 := lang.Apply(v23, []any{v35}) - v37 := lang.Apply(v20, []any{v36}) - v38 := lang.Apply(v9, []any{v13, v17, v37}) - v39 := lang.Apply(v6, []any{v38}) - return v39 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/UncheckedLongCast")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{v3}) + tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) + tmp36 := lang.Apply(tmp23, []any{tmp35}) + tmp37 := lang.Apply(tmp20, []any{tmp36}) + tmp38 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp37}) + tmp39 := lang.Apply(tmp6, []any{tmp38}) + return tmp39 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("unchecked-long").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to long. Subject to rounding or truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3541), lang.NewKeyword("end-line"), int(3541))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("unchecked-long").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to long. Subject to rounding or truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3541), lang.NewKeyword("end-line"), int(3541))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5 := lang.Apply(lang.UncheckedLongCast, []any{v4}) - return v5 + tmp5 := lang.Apply(lang.UncheckedLongCast, []any{v4}) + return tmp5 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // unchecked-multiply { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function unchecked-multiply__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -80472,84 +80649,84 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("seq")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("concat")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("list")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("list")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("list")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("seq")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("concat")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("list")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/Unchecked_multiply")}) - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("list")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{v3}) - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("list")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.Apply(v38, []any{v4}) - v40 := lang.Apply(v27, []any{v31, v35, v39}) - v41 := lang.Apply(v24, []any{v40}) - v42 := lang.Apply(v21, []any{v41}) - v43 := lang.Apply(v10, []any{v14, v18, v42}) - v44 := lang.Apply(v7, []any{v43}) - return v44 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("concat")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("list")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol(".")}) + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("seq")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("concat")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("list")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.Apply(tmp30, []any{lang.NewSymbol("glojure.core/Unchecked_multiply")}) + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.Apply(tmp34, []any{v3}) + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{v4}) + tmp40 := lang.Apply(tmp27, []any{tmp31, tmp35, tmp39}) + tmp41 := lang.Apply(tmp24, []any{tmp40}) + tmp42 := lang.Apply(tmp21, []any{tmp41}) + tmp43 := lang.Apply(tmp10, []any{tmp14, tmp18, tmp42}) + tmp44 := lang.Apply(tmp7, []any{tmp43}) + return tmp44 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("unchecked-multiply").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the product of x and y, both long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1231), lang.NewKeyword("end-line"), int(1231))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("unchecked-multiply").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the product of x and y, both long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1231), lang.NewKeyword("end-line"), int(1231))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -80557,24 +80734,25 @@ func init() { _ = v4 v5 := args[1] _ = v5 - v6, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_multiply") - if reflect.TypeOf(v6).Kind() != reflect.Func { + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_multiply") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_multiply is not a function"))) } - v7 := lang.Apply(v6, []any{v4, v5}) - return v7 + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // unchecked-multiply-int { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function unchecked-multiply-int__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -80582,84 +80760,84 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("seq")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("concat")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("list")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("list")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("list")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("seq")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("concat")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("list")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/Unchecked_int_multiply")}) - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("list")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{v3}) - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("list")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.Apply(v38, []any{v4}) - v40 := lang.Apply(v27, []any{v31, v35, v39}) - v41 := lang.Apply(v24, []any{v40}) - v42 := lang.Apply(v21, []any{v41}) - v43 := lang.Apply(v10, []any{v14, v18, v42}) - v44 := lang.Apply(v7, []any{v43}) - return v44 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("concat")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("list")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol(".")}) + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("seq")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("concat")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("list")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.Apply(tmp30, []any{lang.NewSymbol("glojure.core/Unchecked_int_multiply")}) + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.Apply(tmp34, []any{v3}) + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{v4}) + tmp40 := lang.Apply(tmp27, []any{tmp31, tmp35, tmp39}) + tmp41 := lang.Apply(tmp24, []any{tmp40}) + tmp42 := lang.Apply(tmp21, []any{tmp41}) + tmp43 := lang.Apply(tmp10, []any{tmp14, tmp18, tmp42}) + tmp44 := lang.Apply(tmp7, []any{tmp43}) + return tmp44 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("unchecked-multiply-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the product of x and y, both int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1224), lang.NewKeyword("end-line"), int(1224))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("unchecked-multiply-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the product of x and y, both int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1224), lang.NewKeyword("end-line"), int(1224))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -80667,222 +80845,225 @@ func init() { _ = v4 v5 := args[1] _ = v5 - v6, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_multiply") - if reflect.TypeOf(v6).Kind() != reflect.Func { + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_multiply") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_multiply is not a function"))) } - v7 := lang.Apply(v6, []any{v4, v5}) - return v7 + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // unchecked-negate { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function unchecked-negate__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("concat")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("list")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("seq")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("concat")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/Unchecked_minus")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{v3}) - v35 := lang.Apply(v26, []any{v30, v34}) - v36 := lang.Apply(v23, []any{v35}) - v37 := lang.Apply(v20, []any{v36}) - v38 := lang.Apply(v9, []any{v13, v17, v37}) - v39 := lang.Apply(v6, []any{v38}) - return v39 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/Unchecked_minus")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{v3}) + tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) + tmp36 := lang.Apply(tmp23, []any{tmp35}) + tmp37 := lang.Apply(tmp20, []any{tmp36}) + tmp38 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp37}) + tmp39 := lang.Apply(tmp6, []any{tmp38}) + return tmp39 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("unchecked-negate").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the negation of x, a long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1189), lang.NewKeyword("end-line"), int(1189))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("unchecked-negate").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the negation of x, a long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1189), lang.NewKeyword("end-line"), int(1189))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_negate") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_negate") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_negate is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // unchecked-negate-int { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function unchecked-negate-int__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("concat")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("list")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("seq")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("concat")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/Unchecked_int_negate")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{v3}) - v35 := lang.Apply(v26, []any{v30, v34}) - v36 := lang.Apply(v23, []any{v35}) - v37 := lang.Apply(v20, []any{v36}) - v38 := lang.Apply(v9, []any{v13, v17, v37}) - v39 := lang.Apply(v6, []any{v38}) - return v39 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/Unchecked_int_negate")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{v3}) + tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) + tmp36 := lang.Apply(tmp23, []any{tmp35}) + tmp37 := lang.Apply(tmp20, []any{tmp36}) + tmp38 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp37}) + tmp39 := lang.Apply(tmp6, []any{tmp38}) + return tmp39 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("unchecked-negate-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the negation of x, an int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(26), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1182), lang.NewKeyword("end-line"), int(1182))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("unchecked-negate-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the negation of x, an int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(26), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1182), lang.NewKeyword("end-line"), int(1182))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_negate") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_negate") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_negate is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // unchecked-remainder-int { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function unchecked-remainder-int__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -80890,84 +81071,84 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("seq")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("concat")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("list")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("list")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("list")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("seq")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("concat")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("list")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/Unchecked_int_remainder")}) - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("list")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{v3}) - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("list")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.Apply(v38, []any{v4}) - v40 := lang.Apply(v27, []any{v31, v35, v39}) - v41 := lang.Apply(v24, []any{v40}) - v42 := lang.Apply(v21, []any{v41}) - v43 := lang.Apply(v10, []any{v14, v18, v42}) - v44 := lang.Apply(v7, []any{v43}) - return v44 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("concat")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("list")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol(".")}) + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("seq")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("concat")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("list")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.Apply(tmp30, []any{lang.NewSymbol("glojure.core/Unchecked_int_remainder")}) + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.Apply(tmp34, []any{v3}) + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{v4}) + tmp40 := lang.Apply(tmp27, []any{tmp31, tmp35, tmp39}) + tmp41 := lang.Apply(tmp24, []any{tmp40}) + tmp42 := lang.Apply(tmp21, []any{tmp41}) + tmp43 := lang.Apply(tmp10, []any{tmp14, tmp18, tmp42}) + tmp44 := lang.Apply(tmp7, []any{tmp43}) + return tmp44 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("unchecked-remainder-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the remainder of division of x by y, both int.\n Note - uses a primitive operator subject to truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(29), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1245), lang.NewKeyword("end-line"), int(1245))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("unchecked-remainder-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the remainder of division of x by y, both int.\n Note - uses a primitive operator subject to truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(29), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1245), lang.NewKeyword("end-line"), int(1245))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -80975,119 +81156,121 @@ func init() { _ = v4 v5 := args[1] _ = v5 - v6, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_remainder") - if reflect.TypeOf(v6).Kind() != reflect.Func { + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_remainder") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_remainder is not a function"))) } - v7 := lang.Apply(v6, []any{v4, v5}) - return v7 + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // unchecked-short { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function unchecked-short__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("concat")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("list")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("seq")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("concat")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/UncheckedShortCast")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{v3}) - v35 := lang.Apply(v26, []any{v30, v34}) - v36 := lang.Apply(v23, []any{v35}) - v37 := lang.Apply(v20, []any{v36}) - v38 := lang.Apply(v9, []any{v13, v17, v37}) - v39 := lang.Apply(v6, []any{v38}) - return v39 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/UncheckedShortCast")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{v3}) + tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) + tmp36 := lang.Apply(tmp23, []any{tmp35}) + tmp37 := lang.Apply(tmp20, []any{tmp36}) + tmp38 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp37}) + tmp39 := lang.Apply(tmp6, []any{tmp38}) + return tmp39 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("unchecked-short").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Coerce to short. Subject to rounding or truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3523), lang.NewKeyword("end-line"), int(3523))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("unchecked-short").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to short. Subject to rounding or truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3523), lang.NewKeyword("end-line"), int(3523))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5 := lang.Apply(lang.UncheckedShortCast, []any{v4}) - return v5 + tmp5 := lang.Apply(lang.UncheckedShortCast, []any{v4}) + return tmp5 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // unchecked-subtract { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function unchecked-subtract__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -81095,84 +81278,84 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("seq")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("concat")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("list")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("list")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("list")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("seq")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("concat")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("list")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/Unchecked_minus")}) - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("list")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{v3}) - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("list")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.Apply(v38, []any{v4}) - v40 := lang.Apply(v27, []any{v31, v35, v39}) - v41 := lang.Apply(v24, []any{v40}) - v42 := lang.Apply(v21, []any{v41}) - v43 := lang.Apply(v10, []any{v14, v18, v42}) - v44 := lang.Apply(v7, []any{v43}) - return v44 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("concat")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("list")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol(".")}) + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("seq")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("concat")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("list")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.Apply(tmp30, []any{lang.NewSymbol("glojure.core/Unchecked_minus")}) + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.Apply(tmp34, []any{v3}) + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{v4}) + tmp40 := lang.Apply(tmp27, []any{tmp31, tmp35, tmp39}) + tmp41 := lang.Apply(tmp24, []any{tmp40}) + tmp42 := lang.Apply(tmp21, []any{tmp41}) + tmp43 := lang.Apply(tmp10, []any{tmp14, tmp18, tmp42}) + tmp44 := lang.Apply(tmp7, []any{tmp43}) + return tmp44 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("unchecked-subtract").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the difference of x and y, both long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1217), lang.NewKeyword("end-line"), int(1217))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("unchecked-subtract").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the difference of x and y, both long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1217), lang.NewKeyword("end-line"), int(1217))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -81180,24 +81363,25 @@ func init() { _ = v4 v5 := args[1] _ = v5 - v6, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_minus") - if reflect.TypeOf(v6).Kind() != reflect.Func { + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_minus") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_minus is not a function"))) } - v7 := lang.Apply(v6, []any{v4, v5}) - return v7 + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // unchecked-subtract-int { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function unchecked-subtract-int__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -81205,84 +81389,84 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("seq")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("concat")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("list")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("list")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("list")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("seq")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("concat")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("list")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/Unchecked_int_subtract")}) - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("list")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{v3}) - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("list")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.Apply(v38, []any{v4}) - v40 := lang.Apply(v27, []any{v31, v35, v39}) - v41 := lang.Apply(v24, []any{v40}) - v42 := lang.Apply(v21, []any{v41}) - v43 := lang.Apply(v10, []any{v14, v18, v42}) - v44 := lang.Apply(v7, []any{v43}) - return v44 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("concat")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("list")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol(".")}) + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("seq")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("concat")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("list")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.Apply(tmp30, []any{lang.NewSymbol("glojure.core/Unchecked_int_subtract")}) + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.Apply(tmp34, []any{v3}) + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{v4}) + tmp40 := lang.Apply(tmp27, []any{tmp31, tmp35, tmp39}) + tmp41 := lang.Apply(tmp24, []any{tmp40}) + tmp42 := lang.Apply(tmp21, []any{tmp41}) + tmp43 := lang.Apply(tmp10, []any{tmp14, tmp18, tmp42}) + tmp44 := lang.Apply(tmp7, []any{tmp43}) + return tmp44 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("unchecked-subtract-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns the difference of x and y, both int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1210), lang.NewKeyword("end-line"), int(1210))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("unchecked-subtract-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the difference of x and y, both int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1210), lang.NewKeyword("end-line"), int(1210))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -81290,45 +81474,45 @@ func init() { _ = v4 v5 := args[1] _ = v5 - v6, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_subtract") - if reflect.TypeOf(v6).Kind() != reflect.Func { + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_subtract") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_subtract is not a function"))) } - v7 := lang.Apply(v6, []any{v4, v5}) - return v7 + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // underive { - v0 := lang.NewSymbol("underive").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag"), lang.NewSymbol("parent")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"), lang.NewSymbol("parent"))), lang.NewKeyword("doc"), "Removes a parent/child relationship between parent and\n tag. h must be a hierarchy obtained from make-hierarchy, if not\n supplied defaults to, and modifies, the global hierarchy.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5643), lang.NewKeyword("end-line"), int(5643))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("underive").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag"), lang.NewSymbol("parent")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"), lang.NewSymbol("parent"))), lang.NewKeyword("doc"), "Removes a parent/child relationship between parent and\n tag. h must be a hierarchy obtained from make-hierarchy, if not\n supplied defaults to, and modifies, the global hierarchy.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5643), lang.NewKeyword("end-line"), int(5643))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("alter-var-root")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("global-hierarchy")) - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("underive")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.Apply(v7, []any{v8, v11, v3, v4}) - _ = v12 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("alter-var-root")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("global-hierarchy")) + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("underive")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.Apply(tmp7, []any{tmp8, tmp11, v3, v4}) + _ = tmp12 return nil case 3: v3 := args[0] @@ -81337,157 +81521,157 @@ func init() { _ = v4 v5 := args[2] _ = v5 - var v6 any + var tmp6 any { // let // let binding "parentMap" - v7 := lang.Apply(lang.NewKeyword("parents"), []any{v3}) - var v8 any = v7 + tmp7 := lang.Apply(lang.NewKeyword("parents"), []any{v3}) + var v8 any = tmp7 _ = v8 // let binding "childsParents" - var v9 any - v10 := lang.Apply(v8, []any{v4}) - if lang.IsTruthy(v10) { - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("disj")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v8, []any{v4}) - v15 := lang.Apply(v13, []any{v14, v5}) - v9 = v15 + var tmp9 any + tmp10 := lang.Apply(v8, []any{v4}) + if lang.IsTruthy(tmp10) { + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("disj")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(v8, []any{v4}) + tmp15 := lang.Apply(tmp13, []any{tmp14, v5}) + tmp9 = tmp15 } else { - v16 := lang.CreatePersistentTreeSet() - v17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5652), lang.NewKeyword("column"), int(36), lang.NewKeyword("end-line"), int(5652), lang.NewKeyword("end-column"), int(38)) - v18, err := lang.WithMeta(v16, v17.(lang.IPersistentMap)) + tmp16 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5652), lang.NewKeyword("column"), int(36), lang.NewKeyword("end-line"), int(5652), lang.NewKeyword("end-column"), int(38)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) if err != nil { panic(err) } - v9 = v18 + tmp9 = tmp18 } - var v19 any = v9 + var v19 any = tmp9 _ = v19 // let binding "newParents" - var v20 any - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("not-empty")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.Apply(v23, []any{v19}) - if lang.IsTruthy(v24) { - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("assoc")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.Apply(v27, []any{v8, v4, v19}) - v20 = v28 + var tmp20 any + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("not-empty")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.Apply(tmp23, []any{v19}) + if lang.IsTruthy(tmp24) { + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("assoc")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.Apply(tmp27, []any{v8, v4, v19}) + tmp20 = tmp28 } else { - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("dissoc")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("dissoc")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) } - v31 := v30.Get() - v32 := lang.Apply(v31, []any{v8, v4}) - v20 = v32 + tmp31 := tmp30.Get() + tmp32 := lang.Apply(tmp31, []any{v8, v4}) + tmp20 = tmp32 } - var v33 any = v20 + var v33 any = tmp20 _ = v33 // let binding "deriv-seq" - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("flatten")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) - } - v36 := v35.Get() - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("map")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - var v40 lang.FnFunc - v40 = lang.NewFnFunc(func(args ...any) any { + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("flatten")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("map")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + var tmp40 lang.FnFunc + tmp40 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v41 := args[0] _ = v41 - v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v43 := v42.FindInternedVar(lang.NewSymbol("cons")) - if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) - } - v44 := v43.Get() - v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v46 := v45.FindInternedVar(lang.NewSymbol("key")) - if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) - } - v47 := v46.Get() - v48 := lang.Apply(v47, []any{v41}) - v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v50 := v49.FindInternedVar(lang.NewSymbol("interpose")) - if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) - } - v51 := v50.Get() - v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v53 := v52.FindInternedVar(lang.NewSymbol("key")) - if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) - } - v54 := v53.Get() - v55 := lang.Apply(v54, []any{v41}) - v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v57 := v56.FindInternedVar(lang.NewSymbol("val")) - if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) - } - v58 := v57.Get() - v59 := lang.Apply(v58, []any{v41}) - v60 := lang.Apply(v51, []any{v55, v59}) - v61 := lang.Apply(v44, []any{v48, v60}) - return v61 + tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp43 := tmp42.FindInternedVar(lang.NewSymbol("cons")) + if tmp43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) + } + tmp44 := tmp43.Get() + tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp46 := tmp45.FindInternedVar(lang.NewSymbol("key")) + if tmp46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) + } + tmp47 := tmp46.Get() + tmp48 := lang.Apply(tmp47, []any{v41}) + tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp50 := tmp49.FindInternedVar(lang.NewSymbol("interpose")) + if tmp50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) + } + tmp51 := tmp50.Get() + tmp52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp53 := tmp52.FindInternedVar(lang.NewSymbol("key")) + if tmp53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp53))) + } + tmp54 := tmp53.Get() + tmp55 := lang.Apply(tmp54, []any{v41}) + tmp56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp57 := tmp56.FindInternedVar(lang.NewSymbol("val")) + if tmp57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp57))) + } + tmp58 := tmp57.Get() + tmp59 := lang.Apply(tmp58, []any{v41}) + tmp60 := lang.Apply(tmp51, []any{tmp55, tmp59}) + tmp61 := lang.Apply(tmp44, []any{tmp48, tmp60}) + return tmp61 }) - v41 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5656), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(5656), lang.NewKeyword("end-column"), int(70)) - v42, err := lang.WithMeta(v40, v41.(lang.IPersistentMap)) + tmp41 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5656), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(5656), lang.NewKeyword("end-column"), int(70)) + tmp42, err := lang.WithMeta(tmp40, tmp41.(lang.IPersistentMap)) if err != nil { panic(err) } - v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v44 := v43.FindInternedVar(lang.NewSymbol("seq")) - if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) + tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp44 := tmp43.FindInternedVar(lang.NewSymbol("seq")) + if tmp44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) } - v45 := v44.Get() - v46 := lang.Apply(v45, []any{v33}) - v47 := lang.Apply(v39, []any{v42, v46}) - v48 := lang.Apply(v36, []any{v47}) - var v49 any = v48 + tmp45 := tmp44.Get() + tmp46 := lang.Apply(tmp45, []any{v33}) + tmp47 := lang.Apply(tmp39, []any{tmp42, tmp46}) + tmp48 := lang.Apply(tmp36, []any{tmp47}) + var v49 any = tmp48 _ = v49 - var v50 any - v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v52 := v51.FindInternedVar(lang.NewSymbol("contains?")) - if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) - } - v53 := v52.Get() - v54 := lang.Apply(v8, []any{v4}) - v55 := lang.Apply(v53, []any{v54, v5}) - if lang.IsTruthy(v55) { - v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v57 := v56.FindInternedVar(lang.NewSymbol("reduce1")) - if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) - } - v58 := v57.Get() - var v59 lang.FnFunc - v59 = lang.NewFnFunc(func(args ...any) any { + var tmp50 any + tmp51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp52 := tmp51.FindInternedVar(lang.NewSymbol("contains?")) + if tmp52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp52))) + } + tmp53 := tmp52.Get() + tmp54 := lang.Apply(v8, []any{v4}) + tmp55 := lang.Apply(tmp53, []any{tmp54, v5}) + if lang.IsTruthy(tmp55) { + tmp56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp57 := tmp56.FindInternedVar(lang.NewSymbol("reduce1")) + if tmp57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp57))) + } + tmp58 := tmp57.Get() + var tmp59 lang.FnFunc + tmp59 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -81495,117 +81679,118 @@ func init() { _ = v60 v61 := args[1] _ = v61 - v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v63 := v62.FindInternedVar(lang.NewSymbol("apply")) - if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) - } - v64 := v63.Get() - v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v66 := v65.FindInternedVar(lang.NewSymbol("derive")) - if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) - } - v67 := v66.Get() - v68 := lang.Apply(v64, []any{v67, v60, v61}) - return v68 + tmp62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp63 := tmp62.FindInternedVar(lang.NewSymbol("apply")) + if tmp63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp63))) + } + tmp64 := tmp63.Get() + tmp65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp66 := tmp65.FindInternedVar(lang.NewSymbol("derive")) + if tmp66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp66))) + } + tmp67 := tmp66.Get() + tmp68 := lang.Apply(tmp64, []any{tmp67, v60, v61}) + return tmp68 }) - v60 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5659), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5659), lang.NewKeyword("end-column"), int(31)) - v61, err := lang.WithMeta(v59, v60.(lang.IPersistentMap)) + tmp60 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5659), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5659), lang.NewKeyword("end-column"), int(31)) + tmp61, err := lang.WithMeta(tmp59, tmp60.(lang.IPersistentMap)) if err != nil { panic(err) } - v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v63 := v62.FindInternedVar(lang.NewSymbol("make-hierarchy")) - if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) - } - v64 := v63.Get() - v65 := lang.Apply(v64, nil) - v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v67 := v66.FindInternedVar(lang.NewSymbol("partition")) - if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) - } - v68 := v67.Get() - v69 := lang.Apply(v68, []any{int64(2), v49}) - v70 := lang.Apply(v58, []any{v61, v65, v69}) - v50 = v70 + tmp62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp63 := tmp62.FindInternedVar(lang.NewSymbol("make-hierarchy")) + if tmp63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp63))) + } + tmp64 := tmp63.Get() + tmp65 := lang.Apply(tmp64, nil) + tmp66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp67 := tmp66.FindInternedVar(lang.NewSymbol("partition")) + if tmp67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp67))) + } + tmp68 := tmp67.Get() + tmp69 := lang.Apply(tmp68, []any{int64(2), v49}) + tmp70 := lang.Apply(tmp58, []any{tmp61, tmp65, tmp69}) + tmp50 = tmp70 } else { - v50 = v3 + tmp50 = v3 } - v6 = v50 + tmp6 = tmp50 } // end let - return v6 + return tmp6 default: panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // unquote { - v0 := lang.NewSymbol("unquote").WithMeta(lang.NewMap()).(*lang.Symbol) - v1 := ns.Intern(v0) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp0 := lang.NewSymbol("unquote").WithMeta(lang.NewMap()).(*lang.Symbol) + tmp1 := ns.Intern(tmp0) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // unquote-splicing { - v0 := lang.NewSymbol("unquote-splicing").WithMeta(lang.NewMap()).(*lang.Symbol) - v1 := ns.Intern(v0) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp0 := lang.NewSymbol("unquote-splicing").WithMeta(lang.NewMap()).(*lang.Symbol) + tmp1 := ns.Intern(tmp0) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // unreduced { - v0 := lang.NewSymbol("unreduced").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "If x is reduced?, returns (deref x), else returns x", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2847), lang.NewKeyword("end-line"), int(2847))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("unreduced").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "If x is reduced?, returns (deref x), else returns x", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2847), lang.NewKeyword("end-line"), int(2847))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("reduced?")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v3}) - if lang.IsTruthy(v8) { - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("deref")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.Apply(v11, []any{v3}) - v4 = v12 + var tmp4 any + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("reduced?")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v3}) + if lang.IsTruthy(tmp8) { + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("deref")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.Apply(tmp11, []any{v3}) + tmp4 = tmp12 } else { - v4 = v3 + tmp4 = v3 } - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // unsigned-bit-shift-right { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function unsigned-bit-shift-right__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -81613,84 +81798,84 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("seq")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("concat")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("list")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{lang.NewSymbol(".")}) - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("list")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("list")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("seq")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("concat")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("list")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.Apply(v30, []any{lang.NewSymbol("glojure.core/UnsignedShiftRight")}) - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("list")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{v3}) - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("list")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.Apply(v38, []any{v4}) - v40 := lang.Apply(v27, []any{v31, v35, v39}) - v41 := lang.Apply(v24, []any{v40}) - v42 := lang.Apply(v21, []any{v41}) - v43 := lang.Apply(v10, []any{v14, v18, v42}) - v44 := lang.Apply(v7, []any{v43}) - return v44 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("concat")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("list")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol(".")}) + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("seq")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("concat")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("list")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.Apply(tmp30, []any{lang.NewSymbol("glojure.core/UnsignedShiftRight")}) + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.Apply(tmp34, []any{v3}) + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{v4}) + tmp40 := lang.Apply(tmp27, []any{tmp31, tmp35, tmp39}) + tmp41 := lang.Apply(tmp24, []any{tmp40}) + tmp42 := lang.Apply(tmp21, []any{tmp41}) + tmp43 := lang.Apply(tmp10, []any{tmp14, tmp18, tmp42}) + tmp44 := lang.Apply(tmp7, []any{tmp43}) + return tmp44 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("unsigned-bit-shift-right").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Bitwise shift right, without sign-extension.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(30), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1373), lang.NewKeyword("end-line"), int(1373))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("unsigned-bit-shift-right").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Bitwise shift right, without sign-extension.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(30), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1373), lang.NewKeyword("end-line"), int(1373))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -81698,24 +81883,24 @@ func init() { _ = v4 v5 := args[1] _ = v5 - v6, _ := lang.FieldOrMethod(lang.Numbers, "UnsignedShiftRight") - if reflect.TypeOf(v6).Kind() != reflect.Func { + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "UnsignedShiftRight") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("UnsignedShiftRight is not a function"))) } - v7 := lang.Apply(v6, []any{v4, v5}) - return v7 + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // update { - v0 := lang.NewSymbol("update").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f"), lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("z")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("z"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "'Updates' a value in an associative structure, where k is a\n key and f is a function that will take the old value\n and any supplied args and return the new value, and returns a new\n structure. If the key does not exist, nil is passed as the old value.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6174), lang.NewKeyword("end-line"), int(6174))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("update").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f"), lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("z")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("z"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "'Updates' a value in an associative structure, where k is a\n key and f is a function that will take the old value\n and any supplied args and return the new value, and returns a new\n structure. If the key does not exist, nil is passed as the old value.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6174), lang.NewKeyword("end-line"), int(6174))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 3: v3 := args[0] @@ -81724,22 +81909,22 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("assoc")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("get")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.Apply(v11, []any{v3, v4}) - v13 := lang.Apply(v5, []any{v12}) - v14 := lang.Apply(v8, []any{v3, v4, v13}) - return v14 + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("assoc")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("get")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.Apply(tmp11, []any{v3, v4}) + tmp13 := lang.Apply(v5, []any{tmp12}) + tmp14 := lang.Apply(tmp8, []any{v3, v4, tmp13}) + return tmp14 case 4: v3 := args[0] _ = v3 @@ -81749,22 +81934,22 @@ func init() { _ = v5 v6 := args[3] _ = v6 - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("assoc")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("get")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{v3, v4}) - v14 := lang.Apply(v5, []any{v13, v6}) - v15 := lang.Apply(v9, []any{v3, v4, v14}) - return v15 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("assoc")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("get")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{v3, v4}) + tmp14 := lang.Apply(v5, []any{tmp13, v6}) + tmp15 := lang.Apply(tmp9, []any{v3, v4, tmp14}) + return tmp15 case 5: v3 := args[0] _ = v3 @@ -81776,22 +81961,22 @@ func init() { _ = v6 v7 := args[4] _ = v7 - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("assoc")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("get")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{v3, v4}) - v15 := lang.Apply(v5, []any{v14, v6, v7}) - v16 := lang.Apply(v10, []any{v3, v4, v15}) - return v16 + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("assoc")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("get")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{v3, v4}) + tmp15 := lang.Apply(v5, []any{tmp14, v6, v7}) + tmp16 := lang.Apply(tmp10, []any{v3, v4, tmp15}) + return tmp16 case 6: v3 := args[0] _ = v3 @@ -81805,22 +81990,22 @@ func init() { _ = v7 v8 := args[5] _ = v8 - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("assoc")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("get")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.Apply(v14, []any{v3, v4}) - v16 := lang.Apply(v5, []any{v15, v6, v7, v8}) - v17 := lang.Apply(v11, []any{v3, v4, v16}) - return v17 + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("assoc")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("get")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.Apply(tmp14, []any{v3, v4}) + tmp16 := lang.Apply(v5, []any{tmp15, v6, v7, v8}) + tmp17 := lang.Apply(tmp11, []any{v3, v4, tmp16}) + return tmp17 default: if len(args) < 6 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -81837,42 +82022,43 @@ func init() { _ = v7 v8 := args[5] _ = v8 - v9 := lang.NewList(args[6:]...) - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("assoc")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + var v9 any = lang.NewList(args[6:]...) + _ = v9 + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("assoc")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("apply")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("apply")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) } - v15 := v14.Get() - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("get")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + tmp15 := tmp14.Get() + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("get")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{v3, v4}) - v20 := lang.Apply(v15, []any{v5, v19, v6, v7, v8, v9}) - v21 := lang.Apply(v12, []any{v3, v4, v20}) - return v21 + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{v3, v4}) + tmp20 := lang.Apply(tmp15, []any{v5, tmp19, v6, v7, v8, v9}) + tmp21 := lang.Apply(tmp12, []any{v3, v4, tmp20}) + return tmp21 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // update-in { - v0 := lang.NewSymbol("update-in").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("ks"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "'Updates' a value in a nested associative structure, where ks is a\n sequence of keys and f is a function that will take the old value\n and any supplied args and return the new value, and returns a new\n nested structure. If any levels do not exist, hash-maps will be\n created.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6158), lang.NewKeyword("end-line"), int(6158))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("update-in").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("ks"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "'Updates' a value in a nested associative structure, where ks is a\n sequence of keys and f is a function that will take the old value\n and any supplied args and return the new value, and returns a new\n nested structure. If any levels do not exist, hash-maps will be\n created.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6158), lang.NewKeyword("end-line"), int(6158))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 3 { @@ -81884,13 +82070,15 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - var v7 any + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any { // let // let binding "up" - var v8 lang.FnFunc + var tmp8 lang.FnFunc { // function up - v8 = lang.NewFnFunc(func(args ...any) any { + var v9 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { if len(args) != 4 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -81902,40 +82090,40 @@ func init() { _ = v12 v13 := args[3] _ = v13 - var v14 any + var tmp14 any { // let // let binding "vec__141" var v15 any = v11 _ = v15 // let binding "seq__142" - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("seq")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("seq")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) } - v18 := v17.Get() - v19 := lang.Apply(v18, []any{v15}) - var v20 any = v19 + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, []any{v15}) + var v20 any = tmp19 _ = v20 // let binding "first__143" - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("first")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("first")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) } - v23 := v22.Get() - v24 := lang.Apply(v23, []any{v20}) - var v25 any = v24 + tmp23 := tmp22.Get() + tmp24 := lang.Apply(tmp23, []any{v20}) + var v25 any = tmp24 _ = v25 // let binding "seq__142" - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("next")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("next")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) } - v28 := v27.Get() - v29 := lang.Apply(v28, []any{v20}) - var v30 any = v29 + tmp28 := tmp27.Get() + tmp29 := lang.Apply(tmp28, []any{v20}) + var v30 any = tmp29 _ = v30 // let binding "k" var v31 any = v25 @@ -81943,79 +82131,79 @@ func init() { // let binding "ks" var v32 any = v30 _ = v32 - var v33 any + var tmp33 any if lang.IsTruthy(v32) { - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("assoc")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("assoc")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) } - v36 := v35.Get() - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("get")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) + tmp36 := tmp35.Get() + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("get")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) } - v39 := v38.Get() - v40 := lang.Apply(v39, []any{v10, v31}) - v41 := lang.Apply(v9, []any{v40, v32, v12, v13}) - v42 := lang.Apply(v36, []any{v10, v31, v41}) - v33 = v42 + tmp39 := tmp38.Get() + tmp40 := lang.Apply(tmp39, []any{v10, v31}) + tmp41 := lang.Apply(v9, []any{tmp40, v32, v12, v13}) + tmp42 := lang.Apply(tmp36, []any{v10, v31, tmp41}) + tmp33 = tmp42 } else { - v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v44 := v43.FindInternedVar(lang.NewSymbol("assoc")) - if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) + tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp44 := tmp43.FindInternedVar(lang.NewSymbol("assoc")) + if tmp44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) } - v45 := v44.Get() - v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v47 := v46.FindInternedVar(lang.NewSymbol("apply")) - if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) + tmp45 := tmp44.Get() + tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp47 := tmp46.FindInternedVar(lang.NewSymbol("apply")) + if tmp47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) } - v48 := v47.Get() - v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v50 := v49.FindInternedVar(lang.NewSymbol("get")) - if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) + tmp48 := tmp47.Get() + tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp50 := tmp49.FindInternedVar(lang.NewSymbol("get")) + if tmp50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) } - v51 := v50.Get() - v52 := lang.Apply(v51, []any{v10, v31}) - v53 := lang.Apply(v48, []any{v12, v52, v13}) - v54 := lang.Apply(v45, []any{v10, v31, v53}) - v33 = v54 + tmp51 := tmp50.Get() + tmp52 := lang.Apply(tmp51, []any{v10, v31}) + tmp53 := lang.Apply(tmp48, []any{v12, tmp52, v13}) + tmp54 := lang.Apply(tmp45, []any{v10, v31, tmp53}) + tmp33 = tmp54 } - v14 = v33 + tmp14 = tmp33 } // end let - return v14 + return tmp14 }) - v9 := v8 + v9 = tmp8 _ = v9 } - v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6167), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(6171), lang.NewKeyword("end-column"), int(59)) - v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) + tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6167), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(6171), lang.NewKeyword("end-column"), int(59)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) if err != nil { panic(err) } - var v11 any = v10 + var v11 any = tmp10 _ = v11 - v12 := lang.Apply(v11, []any{v3, v4, v5, v6}) - v7 = v12 + tmp12 := lang.Apply(v11, []any{v3, v4, v5, v6}) + tmp7 = tmp12 } // end let - return v7 + return tmp7 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // update-keys { - v0 := lang.NewSymbol("update-keys").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("f"))), lang.NewKeyword("doc"), "m f => {(f k) v ...}\n\n Given a map m and a function f of 1-argument, returns a new map whose\n keys are the result of applying f to the keys of m, mapped to the\n corresponding values of m.\n f must return a unique key for each key of m, else the behavior is undefined.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7906), lang.NewKeyword("end-line"), int(7906))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("update-keys").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("f"))), lang.NewKeyword("doc"), "m f => {(f k) v ...}\n\n Given a map m and a function f of 1-argument, returns a new map whose\n keys are the result of applying f to the keys of m, mapped to the\n corresponding values of m.\n f must return a unique key for each key of m, else the behavior is undefined.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7906), lang.NewKeyword("end-line"), int(7906))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -82023,23 +82211,23 @@ func init() { _ = v3 v4 := args[1] _ = v4 - var v5 any + var tmp5 any { // let // let binding "ret" - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("persistent!")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("reduce-kv")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - var v12 lang.FnFunc - v12 = lang.NewFnFunc(func(args ...any) any { + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("persistent!")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("reduce-kv")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + var tmp12 lang.FnFunc + tmp12 = lang.NewFnFunc(func(args ...any) any { if len(args) != 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -82049,67 +82237,67 @@ func init() { _ = v14 v15 := args[2] _ = v15 - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("assoc!")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.Apply(v4, []any{v14}) - v20 := lang.Apply(v18, []any{v13, v19, v15}) - return v20 + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("assoc!")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.Apply(v4, []any{v14}) + tmp20 := lang.Apply(tmp18, []any{v13, tmp19, v15}) + return tmp20 }) - v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7916), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7916), lang.NewKeyword("end-column"), int(59)) - v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) + tmp13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7916), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7916), lang.NewKeyword("end-column"), int(59)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) if err != nil { panic(err) } - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("transient")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("transient")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) } - v17 := v16.Get() - v18 := lang.NewMap() - v19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7917), lang.NewKeyword("column"), int(36), lang.NewKeyword("end-line"), int(7917), lang.NewKeyword("end-column"), int(37)) - v20, err := lang.WithMeta(v18, v19.(lang.IPersistentMap)) + tmp17 := tmp16.Get() + tmp18 := lang.NewMap() + tmp19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7917), lang.NewKeyword("column"), int(36), lang.NewKeyword("end-line"), int(7917), lang.NewKeyword("end-column"), int(37)) + tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) if err != nil { panic(err) } - v21 := lang.Apply(v17, []any{v20}) - v22 := lang.Apply(v11, []any{v14, v21, v3}) - v23 := lang.Apply(v8, []any{v22}) - var v24 any = v23 + tmp21 := lang.Apply(tmp17, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp14, tmp21, v3}) + tmp23 := lang.Apply(tmp8, []any{tmp22}) + var v24 any = tmp23 _ = v24 - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("with-meta")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("meta")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.Apply(v30, []any{v3}) - v32 := lang.Apply(v27, []any{v24, v31}) - v5 = v32 + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("with-meta")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("meta")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.Apply(tmp30, []any{v3}) + tmp32 := lang.Apply(tmp27, []any{v24, tmp31}) + tmp5 = tmp32 } // end let - return v5 + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // update-vals { - v0 := lang.NewSymbol("update-vals").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("f"))), lang.NewKeyword("doc"), "m f => {k (f v) ...}\n\n Given a map m and a function f of 1-argument, returns a new map where the keys of m\n are mapped to result of applying f to the corresponding values of m.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7890), lang.NewKeyword("end-line"), int(7890))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("update-vals").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("f"))), lang.NewKeyword("doc"), "m f => {k (f v) ...}\n\n Given a map m and a function f of 1-argument, returns a new map where the keys of m\n are mapped to result of applying f to the corresponding values of m.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7890), lang.NewKeyword("end-line"), int(7890))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -82117,26 +82305,26 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("with-meta")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("persistent!")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("reduce-kv")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - var v14 lang.FnFunc - v14 = lang.NewFnFunc(func(args ...any) any { + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("with-meta")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("persistent!")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("reduce-kv")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { if len(args) != 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -82146,225 +82334,229 @@ func init() { _ = v16 v17 := args[2] _ = v17 - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("assoc!")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.Apply(v4, []any{v17}) - v22 := lang.Apply(v20, []any{v15, v16, v21}) - return v22 + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("assoc!")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.Apply(v4, []any{v17}) + tmp22 := lang.Apply(tmp20, []any{v15, v16, tmp21}) + return tmp22 }) - v15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7899), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(7899), lang.NewKeyword("end-column"), int(51)) - v16, err := lang.WithMeta(v14, v15.(lang.IPersistentMap)) + tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7899), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(7899), lang.NewKeyword("end-column"), int(51)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) if err != nil { panic(err) } - var v17 any - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("instance?")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.Apply(v20, []any{lang.IEditableCollection, v3}) - if lang.IsTruthy(v21) { - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("transient")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v3}) - v17 = v25 + var tmp17 any + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("instance?")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := reflect.TypeOf((*lang.IEditableCollection)(nil)).Elem() + tmp22 := lang.Apply(tmp20, []any{tmp21, v3}) + if lang.IsTruthy(tmp22) { + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("transient")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.Apply(tmp25, []any{v3}) + tmp17 = tmp26 } else { - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("transient")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) - } - v28 := v27.Get() - v29 := lang.NewMap() - v30 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7902), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(7902), lang.NewKeyword("end-column"), int(31)) - v31, err := lang.WithMeta(v29, v30.(lang.IPersistentMap)) + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("transient")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.NewMap() + tmp31 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7902), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(7902), lang.NewKeyword("end-column"), int(31)) + tmp32, err := lang.WithMeta(tmp30, tmp31.(lang.IPersistentMap)) if err != nil { panic(err) } - v32 := lang.Apply(v28, []any{v31}) - v17 = v32 + tmp33 := lang.Apply(tmp29, []any{tmp32}) + tmp17 = tmp33 } - v33 := lang.Apply(v13, []any{v16, v17, v3}) - v34 := lang.Apply(v10, []any{v33}) - v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v36 := v35.FindInternedVar(lang.NewSymbol("meta")) - if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) + tmp34 := lang.Apply(tmp13, []any{tmp16, tmp17, v3}) + tmp35 := lang.Apply(tmp10, []any{tmp34}) + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("meta")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) } - v37 := v36.Get() - v38 := lang.Apply(v37, []any{v3}) - v39 := lang.Apply(v7, []any{v34, v38}) - return v39 + tmp38 := tmp37.Get() + tmp39 := lang.Apply(tmp38, []any{v3}) + tmp40 := lang.Apply(tmp7, []any{tmp35, tmp39}) + return tmp40 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // uri? { - v0 := lang.NewSymbol("uri?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a java.net.URI", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7877), lang.NewKeyword("end-line"), int(7877))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("uri?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a java.net.URI", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7877), lang.NewKeyword("end-line"), int(7877))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) } - v6 := v5.Get() - v7 := lang.Apply(v6, []any{url14.URL, v3}) - return v7 + tmp6 := tmp5.Get() + tmp7 := reflect.TypeOf((*url14.URL)(nil)).Elem() + tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) + return tmp8 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // use { - v0 := lang.NewSymbol("use").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Like 'require, but also refers to each lib's namespace using\n glojure.core/refer. Use :use in the ns macro in preference to calling\n this directly.\n\n 'use accepts additional options in libspecs: :exclude, :only, :rename.\n The arguments and semantics for :exclude, :only, and :rename are the same\n as those documented for glojure.core/refer.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6079), lang.NewKeyword("end-line"), int(6079))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("use").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Like 'require, but also refers to each lib's namespace using\n glojure.core/refer. Use :use in the ns macro in preference to calling\n this directly.\n\n 'use accepts additional options in libspecs: :exclude, :only, :rename.\n The arguments and semantics for :exclude, :only, and :rename are the same\n as those documented for glojure.core/refer.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6079), lang.NewKeyword("end-line"), int(6079))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v3 := lang.NewList(args[0:]...) - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("apply")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("apply")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("load-libs")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("load-libs")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) } - v9 := v8.Get() - v10 := lang.Apply(v6, []any{v9, lang.NewKeyword("require"), lang.NewKeyword("use"), v3}) - return v10 + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp6, []any{tmp9, lang.NewKeyword("require"), lang.NewKeyword("use"), v3}) + return tmp10 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // uuid? { - v0 := lang.NewSymbol("uuid?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a java.util.UUID", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6847), lang.NewKeyword("end-line"), int(6847))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("uuid?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a java.util.UUID", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6847), lang.NewKeyword("end-line"), int(6847))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) } - v6 := v5.Get() - v7 := lang.Apply(v6, []any{uuid10.UUID, v3}) - return v7 + tmp6 := tmp5.Get() + tmp7 := reflect.TypeOf([16]uint8{}) + tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) + return tmp8 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // val { - v0 := lang.NewSymbol("val").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("e"))), lang.NewKeyword("doc"), "Returns the value in the map entry.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1570), lang.NewKeyword("end-line"), int(1570))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("val").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("e"))), lang.NewKeyword("doc"), "Returns the value in the map entry.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1570), lang.NewKeyword("end-line"), int(1570))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4, _ := lang.FieldOrMethod(v3, "GetValue") - if reflect.TypeOf(v4).Kind() != reflect.Func { + tmp4, _ := lang.FieldOrMethod(v3, "GetValue") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("GetValue is not a function"))) } - v5 := lang.Apply(v4, []any{}) - return v5 + tmp5 := lang.Apply(tmp4, []any{}) + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // vals { - v0 := lang.NewSymbol("vals").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"))), lang.NewKeyword("doc"), "Returns a sequence of the map's values, in the same order as (seq map).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1557), lang.NewKeyword("end-line"), int(1557))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("vals").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"))), lang.NewKeyword("doc"), "Returns a sequence of the map's values, in the same order as (seq map).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1557), lang.NewKeyword("end-line"), int(1557))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.Apply(lang.Vals, []any{v3}) - return v4 + tmp4 := lang.Apply(lang.Vals, []any{v3}) + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // var-get { - v0 := lang.NewSymbol("var-get").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Gets the value in the var object", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4326), lang.NewKeyword("end-line"), int(4326))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("var-get").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Gets the value in the var object", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4326), lang.NewKeyword("end-line"), int(4326))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4, _ := lang.FieldOrMethod(v3, "Get") - if reflect.TypeOf(v4).Kind() != reflect.Func { + tmp4, _ := lang.FieldOrMethod(v3, "Get") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Get is not a function"))) } - v5 := lang.Apply(v4, []any{}) - return v5 + tmp5 := lang.Apply(tmp4, []any{}) + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // var-set { - v0 := lang.NewSymbol("var-set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Sets the value in the var object to val. The var must be\n thread-locally bound.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4332), lang.NewKeyword("end-line"), int(4332))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("var-set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Sets the value in the var object to val. The var must be\n thread-locally bound.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4332), lang.NewKeyword("end-line"), int(4332))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -82372,49 +82564,50 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5, _ := lang.FieldOrMethod(v3, "Set") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(v3, "Set") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Set is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // var? { - v0 := lang.NewSymbol("var?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("v"))), lang.NewKeyword("doc"), "Returns true if v is of type glojure.lang.Var", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4999), lang.NewKeyword("end-line"), int(4999))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("var?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("v"))), lang.NewKeyword("doc"), "Returns true if v is of type glojure.lang.Var", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4999), lang.NewKeyword("end-line"), int(4999))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) } - v6 := v5.Get() - v7 := lang.Apply(v6, []any{*lang.Var, v3}) - return v7 + tmp6 := tmp5.Get() + tmp7 := reflect.TypeOf((*lang.Var)(nil)) + tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) + return tmp8 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // vary-meta { - v0 := lang.NewSymbol("vary-meta").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("obj"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Returns an object of the same type and value as obj, with\n (apply f (meta obj) args) as its metadata.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(668), lang.NewKeyword("end-line"), int(668))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("vary-meta").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("obj"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Returns an object of the same type and value as obj, with\n (apply f (meta obj) args) as its metadata.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(668), lang.NewKeyword("end-line"), int(668))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 2 { @@ -82424,126 +82617,128 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.NewList(args[2:]...) - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("with-meta")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("with-meta")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) } - v8 := v7.Get() - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("apply")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) + tmp8 := tmp7.Get() + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("apply")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) } - v11 := v10.Get() - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("meta")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) + tmp11 := tmp10.Get() + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("meta")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) } - v14 := v13.Get() - v15 := lang.Apply(v14, []any{v3}) - v16 := lang.Apply(v11, []any{v4, v15, v5}) - v17 := lang.Apply(v8, []any{v3, v16}) - return v17 + tmp14 := tmp13.Get() + tmp15 := lang.Apply(tmp14, []any{v3}) + tmp16 := lang.Apply(tmp11, []any{v4, tmp15, v5}) + tmp17 := lang.Apply(tmp8, []any{v3, tmp16}) + return tmp17 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // vec { - v0 := lang.NewSymbol("vec").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Creates a new vector containing the contents of coll. Java arrays\n will be aliased and should not be modified.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(366), lang.NewKeyword("end-line"), int(366))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("vec").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Creates a new vector containing the contents of coll. Java arrays\n will be aliased and should not be modified.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(366), lang.NewKeyword("end-line"), int(366))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("vector?")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{v3}) - if lang.IsTruthy(v8) { - var v9 any - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("instance?")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.IObj, v3}) - if lang.IsTruthy(v13) { - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("with-meta")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{v3, nil}) - v9 = v17 + var tmp4 any + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("vector?")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := lang.Apply(tmp7, []any{v3}) + if lang.IsTruthy(tmp8) { + var tmp9 any + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("instance?")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := reflect.TypeOf((*lang.IObj)(nil)).Elem() + tmp14 := lang.Apply(tmp12, []any{tmp13, v3}) + if lang.IsTruthy(tmp14) { + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("with-meta")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{v3, nil}) + tmp9 = tmp18 } else { - v18 := lang.Apply(lang.CreateLazilyPersistentVector, []any{v3}) - v9 = v18 + tmp19 := lang.Apply(lang.CreateLazilyPersistentVector, []any{v3}) + tmp9 = tmp19 } - v4 = v9 + tmp4 = tmp9 } else { - v19 := lang.Apply(lang.CreateLazilyPersistentVector, []any{v3}) - v4 = v19 + tmp20 := lang.Apply(lang.CreateLazilyPersistentVector, []any{v3}) + tmp4 = tmp20 } - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // vector { - v0 := lang.NewSymbol("vector").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("a")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d"), lang.NewSymbol("e")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d"), lang.NewSymbol("e"), lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d"), lang.NewSymbol("e"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Creates a new vector containing the args.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(352), lang.NewKeyword("end-line"), int(352))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("vector").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("a")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d"), lang.NewSymbol("e")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d"), lang.NewSymbol("e"), lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d"), lang.NewSymbol("e"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Creates a new vector containing the args.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(352), lang.NewKeyword("end-line"), int(352))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - v3 := lang.NewVector() - v4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(356), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(356), lang.NewKeyword("end-column"), int(8)) - v5, err := lang.WithMeta(v3, v4.(lang.IPersistentMap)) + tmp3 := lang.NewVector() + tmp4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(356), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(356), lang.NewKeyword("end-column"), int(8)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) if err != nil { panic(err) } - return v5 + return tmp5 case 1: v3 := args[0] _ = v3 - v4 := lang.NewVector(v3) - v5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(357), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(357), lang.NewKeyword("end-column"), int(10)) - v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) + tmp4 := lang.NewVector(v3) + tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(357), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(357), lang.NewKeyword("end-column"), int(10)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) if err != nil { panic(err) } - return v6 + return tmp6 case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - v5 := lang.NewVector(v3, v4) - v6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(358), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(358), lang.NewKeyword("end-column"), int(14)) - v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) + tmp5 := lang.NewVector(v3, v4) + tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(358), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(358), lang.NewKeyword("end-column"), int(14)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) if err != nil { panic(err) } - return v7 + return tmp7 case 3: v3 := args[0] _ = v3 @@ -82551,13 +82746,13 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewVector(v3, v4, v5) - v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(359), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(359), lang.NewKeyword("end-column"), int(18)) - v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) + tmp6 := lang.NewVector(v3, v4, v5) + tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(359), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(359), lang.NewKeyword("end-column"), int(18)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) if err != nil { panic(err) } - return v8 + return tmp8 case 4: v3 := args[0] _ = v3 @@ -82567,13 +82762,13 @@ func init() { _ = v5 v6 := args[3] _ = v6 - v7 := lang.NewVector(v3, v4, v5, v6) - v8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(360), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(360), lang.NewKeyword("end-column"), int(22)) - v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) + tmp7 := lang.NewVector(v3, v4, v5, v6) + tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(360), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(360), lang.NewKeyword("end-column"), int(22)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) if err != nil { panic(err) } - return v9 + return tmp9 case 5: v3 := args[0] _ = v3 @@ -82585,13 +82780,13 @@ func init() { _ = v6 v7 := args[4] _ = v7 - v8 := lang.NewVector(v3, v4, v5, v6, v7) - v9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(361), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(361), lang.NewKeyword("end-column"), int(25)) - v10, err := lang.WithMeta(v8, v9.(lang.IPersistentMap)) + tmp8 := lang.NewVector(v3, v4, v5, v6, v7) + tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(361), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(361), lang.NewKeyword("end-column"), int(25)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) if err != nil { panic(err) } - return v10 + return tmp10 case 6: v3 := args[0] _ = v3 @@ -82605,13 +82800,13 @@ func init() { _ = v7 v8 := args[5] _ = v8 - v9 := lang.NewVector(v3, v4, v5, v6, v7, v8) - v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(362), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(362), lang.NewKeyword("end-column"), int(29)) - v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) + tmp9 := lang.NewVector(v3, v4, v5, v6, v7, v8) + tmp10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(362), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(362), lang.NewKeyword("end-column"), int(29)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) if err != nil { panic(err) } - return v11 + return tmp11 default: if len(args) < 6 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -82628,139 +82823,143 @@ func init() { _ = v7 v8 := args[5] _ = v8 - v9 := lang.NewList(args[6:]...) - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("cons")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("cons")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("cons")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("cons")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("cons")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("cons")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.Apply(v27, []any{v8, v9}) - v29 := lang.Apply(v24, []any{v7, v28}) - v30 := lang.Apply(v21, []any{v6, v29}) - v31 := lang.Apply(v18, []any{v5, v30}) - v32 := lang.Apply(v15, []any{v4, v31}) - v33 := lang.Apply(v12, []any{v3, v32}) - v34 := lang.Apply(lang.CreateLazilyPersistentVector, []any{v33}) - return v34 - } - }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + var v9 any = lang.NewList(args[6:]...) + _ = v9 + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("cons")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("cons")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("cons")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("cons")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("cons")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("cons")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.Apply(tmp27, []any{v8, v9}) + tmp29 := lang.Apply(tmp24, []any{v7, tmp28}) + tmp30 := lang.Apply(tmp21, []any{v6, tmp29}) + tmp31 := lang.Apply(tmp18, []any{v5, tmp30}) + tmp32 := lang.Apply(tmp15, []any{v4, tmp31}) + tmp33 := lang.Apply(tmp12, []any{v3, tmp32}) + tmp34 := lang.Apply(lang.CreateLazilyPersistentVector, []any{tmp33}) + return tmp34 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // vector? { - v0 := lang.NewSymbol("vector?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x implements IPersistentVector", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(174), lang.NewKeyword("end-line"), int(178))).(*lang.Symbol) - var v2 lang.FnFunc + tmp0 := lang.NewSymbol("vector?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x implements IPersistentVector", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(174), lang.NewKeyword("end-line"), int(178))).(*lang.Symbol) + var tmp2 lang.FnFunc { // function vector? - v2 = lang.NewFnFunc(func(args ...any) any { + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v6 := v5.FindInternedVar(lang.NewSymbol("instance?")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) - } - v7 := v6.Get() - v8 := lang.Apply(v7, []any{lang.IPersistentVector, v4}) - return v8 + tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("instance?")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) + } + tmp7 := tmp6.Get() + tmp8 := reflect.TypeOf((*lang.IPersistentVector)(nil)).Elem() + tmp9 := lang.Apply(tmp7, []any{tmp8, v4}) + return tmp9 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(178), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(178), lang.NewKeyword("end-column"), int(106))).(lang.FnFunc) - v3 := v2 + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(178), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(178), lang.NewKeyword("end-column"), int(106))).(lang.FnFunc) + v3 = tmp2 _ = v3 } - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // volatile! { - v1 := reflect.TypeOf((*lang.Volatile)(nil)).Elem() - v0 := lang.NewSymbol("volatile!").WithMeta(lang.NewMap(lang.NewKeyword("tag"), v1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Creates and returns a Volatile with an initial value of val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2517), lang.NewKeyword("end-line"), int(2517))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp1 := reflect.TypeOf((*lang.Volatile)(nil)).Elem() + tmp0 := lang.NewSymbol("volatile!").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Creates and returns a Volatile with an initial value of val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2517), lang.NewKeyword("end-line"), int(2517))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5 := lang.Apply(lang.NewVolatile, []any{v4}) - return v5 + tmp5 := lang.Apply(lang.NewVolatile, []any{v4}) + return tmp5 }) - v4 := reflect.TypeOf((*lang.Volatile)(nil)).Elem() - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), v4)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp4 := reflect.TypeOf((*lang.Volatile)(nil)).Elem() + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // volatile? { - v0 := lang.NewSymbol("volatile?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is a volatile.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2540), lang.NewKeyword("end-line"), int(2540))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("volatile?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is a volatile.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2540), lang.NewKeyword("end-line"), int(2540))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("instance?")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) } - v6 := v5.Get() - v7 := lang.Apply(v6, []any{lang.Volatile, v3}) - return v7 + tmp6 := tmp5.Get() + tmp7 := reflect.TypeOf((*lang.Volatile)(nil)).Elem() + tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) + return tmp8 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // vreset! { - v0 := lang.NewSymbol("vreset!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("vol"), lang.NewSymbol("newval"))), lang.NewKeyword("doc"), "Sets the value of volatile to newval without regard for the\n current value. Returns newval.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2524), lang.NewKeyword("end-line"), int(2524))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("vreset!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("vol"), lang.NewSymbol("newval"))), lang.NewKeyword("doc"), "Sets the value of volatile to newval without regard for the\n current value. Returns newval.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2524), lang.NewKeyword("end-line"), int(2524))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -82768,24 +82967,24 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5, _ := lang.FieldOrMethod(v3, "reset") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(v3, "reset") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // vswap! { - v0 := lang.NewSymbol("vswap!").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("vol"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Non-atomically swaps the value of the volatile as if:\n (apply f current-value-of-vol args). Returns the value that\n was swapped in.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(2531), lang.NewKeyword("end-line"), int(2531))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("vswap!").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("vol"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Non-atomically swaps the value of the volatile as if:\n (apply f current-value-of-vol args). Returns the value that\n was swapped in.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(2531), lang.NewKeyword("end-line"), int(2531))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 4 { @@ -82799,132 +82998,133 @@ func init() { _ = v5 v6 := args[3] _ = v6 - v7 := lang.NewList(args[4:]...) - var v8 any + var v7 any = lang.NewList(args[4:]...) + _ = v7 + var tmp8 any { // let // let binding "v" - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("with-meta")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.NewMap(lang.NewKeyword("tag"), lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Volatile")) - v13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2537), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(2537), lang.NewKeyword("end-column"), int(81)) - v14, err := lang.WithMeta(v12, v13.(lang.IPersistentMap)) + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("with-meta")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.NewMap(lang.NewKeyword("tag"), lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Volatile")) + tmp13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2537), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(2537), lang.NewKeyword("end-column"), int(81)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) if err != nil { panic(err) } - v15 := lang.Apply(v11, []any{v5, v14}) - var v16 any = v15 + tmp15 := lang.Apply(tmp11, []any{v5, tmp14}) + var v16 any = tmp15 _ = v16 - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("seq")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("concat")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("list")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.Apply(v25, []any{lang.NewSymbol(".reset")}) - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{v16}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("seq")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) - } - v36 := v35.Get() - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("concat")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("list")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) - } - v42 := v41.Get() - v43 := lang.Apply(v42, []any{v6}) - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("list")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) - } - v46 := v45.Get() - v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v48 := v47.FindInternedVar(lang.NewSymbol("seq")) - if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) - } - v49 := v48.Get() - v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v51 := v50.FindInternedVar(lang.NewSymbol("concat")) - if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) - } - v52 := v51.Get() - v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v54 := v53.FindInternedVar(lang.NewSymbol("list")) - if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) - } - v55 := v54.Get() - v56 := lang.Apply(v55, []any{lang.NewSymbol(".Deref")}) - v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v58 := v57.FindInternedVar(lang.NewSymbol("list")) - if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) - } - v59 := v58.Get() - v60 := lang.Apply(v59, []any{v16}) - v61 := lang.Apply(v52, []any{v56, v60}) - v62 := lang.Apply(v49, []any{v61}) - v63 := lang.Apply(v46, []any{v62}) - v64 := lang.Apply(v39, []any{v43, v63, v7}) - v65 := lang.Apply(v36, []any{v64}) - v66 := lang.Apply(v33, []any{v65}) - v67 := lang.Apply(v22, []any{v26, v30, v66}) - v68 := lang.Apply(v19, []any{v67}) - v8 = v68 + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("concat")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol(".reset")}) + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{v16}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) + } + tmp42 := tmp41.Get() + tmp43 := lang.Apply(tmp42, []any{v6}) + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) + } + tmp46 := tmp45.Get() + tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp48 := tmp47.FindInternedVar(lang.NewSymbol("seq")) + if tmp48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) + } + tmp49 := tmp48.Get() + tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp51 := tmp50.FindInternedVar(lang.NewSymbol("concat")) + if tmp51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) + } + tmp52 := tmp51.Get() + tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp54 := tmp53.FindInternedVar(lang.NewSymbol("list")) + if tmp54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) + } + tmp55 := tmp54.Get() + tmp56 := lang.Apply(tmp55, []any{lang.NewSymbol(".Deref")}) + tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp58 := tmp57.FindInternedVar(lang.NewSymbol("list")) + if tmp58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) + } + tmp59 := tmp58.Get() + tmp60 := lang.Apply(tmp59, []any{v16}) + tmp61 := lang.Apply(tmp52, []any{tmp56, tmp60}) + tmp62 := lang.Apply(tmp49, []any{tmp61}) + tmp63 := lang.Apply(tmp46, []any{tmp62}) + tmp64 := lang.Apply(tmp39, []any{tmp43, tmp63, v7}) + tmp65 := lang.Apply(tmp36, []any{tmp64}) + tmp66 := lang.Apply(tmp33, []any{tmp65}) + tmp67 := lang.Apply(tmp22, []any{tmp26, tmp30, tmp66}) + tmp68 := lang.Apply(tmp19, []any{tmp67}) + tmp8 = tmp68 } // end let - return v8 + return tmp8 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // when { - v0 := lang.NewSymbol("when").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("test"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Evaluates test. If logical true, evaluates body in an implicit do.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(492), lang.NewKeyword("end-line"), int(492))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("when").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("test"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Evaluates test. If logical true, evaluates body in an implicit do.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(492), lang.NewKeyword("end-line"), int(492))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 3 { @@ -82936,35 +83136,36 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("list")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("list")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("cons")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("cons")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol("do"), v6}) - v14 := lang.Apply(v9, []any{lang.NewSymbol("if"), v5, v13}) - return v14 + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol("do"), v6}) + tmp14 := lang.Apply(tmp9, []any{lang.NewSymbol("if"), v5, tmp13}) + return tmp14 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // when-first { - v0 := lang.NewSymbol("when-first").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "bindings => x xs\n\n Roughly the same as (when (seq xs) (let [x (first xs)] body)) but xs is evaluated only once", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4622), lang.NewKeyword("end-line"), int(4622))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("when-first").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "bindings => x xs\n\n Roughly the same as (when (seq xs) (let [x (first xs)] body)) but xs is evaluated only once", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4622), lang.NewKeyword("end-line"), int(4622))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 3 { @@ -82976,343 +83177,341 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - var v7 any - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v5}) - if lang.IsTruthy(v11) { - v7 = nil + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("vector?")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v5}) + if lang.IsTruthy(tmp11) { } else { - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("str")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("first")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{v3}) - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("meta")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v3}) - v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) - v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) - v28 := lang.Apply(lang.NewIllegalArgumentError, []any{v27}) - panic(v28) - } - _ = v7 - var v29 any - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("=")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) - } - v32 := v31.Get() - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("count")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - v36 := lang.Apply(v35, []any{v5}) - v37 := lang.Apply(v32, []any{int64(2), v36}) - if lang.IsTruthy(v37) { - v29 = nil + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("str")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("first")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("*ns*")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("meta")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.Apply(tmp24, []any{v3}) + tmp26 := lang.Apply(lang.NewKeyword("line"), []any{tmp25}) + tmp27 := lang.Apply(tmp14, []any{tmp18, " requires ", "a vector for its binding", " in ", tmp21, ":", tmp26}) + tmp28 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp27}) + panic(tmp28) + } + _ = tmp7 + var tmp29 any + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("=")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) + } + tmp32 := tmp31.Get() + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("count")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) + } + tmp35 := tmp34.Get() + tmp36 := lang.Apply(tmp35, []any{v5}) + tmp37 := lang.Apply(tmp32, []any{int64(2), tmp36}) + if lang.IsTruthy(tmp37) { } else { - v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v39 := v38.FindInternedVar(lang.NewSymbol("str")) - if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) - } - v40 := v39.Get() - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("first")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) - } - v43 := v42.Get() - v44 := lang.Apply(v43, []any{v3}) - v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) - if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) - } - v47 := v46.Get() - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("meta")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v3}) - v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) - v53 := lang.Apply(v40, []any{v44, " requires ", "exactly 2 forms in binding vector", " in ", v47, ":", v52}) - v54 := lang.Apply(lang.NewIllegalArgumentError, []any{v53}) - panic(v54) - } - _ = v29 - _ = nil - var v55 any + tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp39 := tmp38.FindInternedVar(lang.NewSymbol("str")) + if tmp39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) + } + tmp40 := tmp39.Get() + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("first")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := lang.Apply(tmp43, []any{v3}) + tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp46 := tmp45.FindInternedVar(lang.NewSymbol("*ns*")) + if tmp46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) + } + tmp47 := tmp46.Get() + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("meta")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v3}) + tmp52 := lang.Apply(lang.NewKeyword("line"), []any{tmp51}) + tmp53 := lang.Apply(tmp40, []any{tmp44, " requires ", "exactly 2 forms in binding vector", " in ", tmp47, ":", tmp52}) + tmp54 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp53}) + panic(tmp54) + } + _ = tmp29 + var tmp55 any { // let // let binding "vec__20" var v56 any = v5 _ = v56 // let binding "x" - v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v58 := v57.FindInternedVar(lang.NewSymbol("nth")) - if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) - } - v59 := v58.Get() - v60 := lang.Apply(v59, []any{v56, int64(0), nil}) - var v61 any = v60 + tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp58 := tmp57.FindInternedVar(lang.NewSymbol("nth")) + if tmp58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) + } + tmp59 := tmp58.Get() + tmp60 := lang.Apply(tmp59, []any{v56, int64(0), nil}) + var v61 any = tmp60 _ = v61 // let binding "xs" - v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v63 := v62.FindInternedVar(lang.NewSymbol("nth")) - if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) - } - v64 := v63.Get() - v65 := lang.Apply(v64, []any{v56, int64(1), nil}) - var v66 any = v65 + tmp62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp63 := tmp62.FindInternedVar(lang.NewSymbol("nth")) + if tmp63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp63))) + } + tmp64 := tmp63.Get() + tmp65 := lang.Apply(tmp64, []any{v56, int64(1), nil}) + var v66 any = tmp65 _ = v66 - v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v68 := v67.FindInternedVar(lang.NewSymbol("seq")) - if v68.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) - } - v69 := v68.Get() - v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v71 := v70.FindInternedVar(lang.NewSymbol("concat")) - if v71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) - } - v72 := v71.Get() - v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v74 := v73.FindInternedVar(lang.NewSymbol("list")) - if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) - } - v75 := v74.Get() - v76 := lang.Apply(v75, []any{lang.NewSymbol("glojure.core/when-let")}) - v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v78 := v77.FindInternedVar(lang.NewSymbol("list")) - if v78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) - } - v79 := v78.Get() - v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v81 := v80.FindInternedVar(lang.NewSymbol("apply")) - if v81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) - } - v82 := v81.Get() - v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v84 := v83.FindInternedVar(lang.NewSymbol("vector")) - if v84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) - } - v85 := v84.Get() - v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v87 := v86.FindInternedVar(lang.NewSymbol("seq")) - if v87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) - } - v88 := v87.Get() - v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v90 := v89.FindInternedVar(lang.NewSymbol("concat")) - if v90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) - } - v91 := v90.Get() - v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v93 := v92.FindInternedVar(lang.NewSymbol("list")) - if v93.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) - } - v94 := v93.Get() - v95 := lang.Apply(v94, []any{lang.NewSymbol("xs__0__auto__")}) - v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v97 := v96.FindInternedVar(lang.NewSymbol("list")) - if v97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) - } - v98 := v97.Get() - v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v100 := v99.FindInternedVar(lang.NewSymbol("seq")) - if v100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) - } - v101 := v100.Get() - v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v103 := v102.FindInternedVar(lang.NewSymbol("concat")) - if v103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) - } - v104 := v103.Get() - v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v106 := v105.FindInternedVar(lang.NewSymbol("list")) - if v106.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) - } - v107 := v106.Get() - v108 := lang.Apply(v107, []any{lang.NewSymbol("glojure.core/seq")}) - v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v110 := v109.FindInternedVar(lang.NewSymbol("list")) - if v110.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) - } - v111 := v110.Get() - v112 := lang.Apply(v111, []any{v66}) - v113 := lang.Apply(v104, []any{v108, v112}) - v114 := lang.Apply(v101, []any{v113}) - v115 := lang.Apply(v98, []any{v114}) - v116 := lang.Apply(v91, []any{v95, v115}) - v117 := lang.Apply(v88, []any{v116}) - v118 := lang.Apply(v82, []any{v85, v117}) - v119 := lang.Apply(v79, []any{v118}) - v120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v121 := v120.FindInternedVar(lang.NewSymbol("list")) - if v121.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v121))) - } - v122 := v121.Get() - v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v124 := v123.FindInternedVar(lang.NewSymbol("seq")) - if v124.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) - } - v125 := v124.Get() - v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v127 := v126.FindInternedVar(lang.NewSymbol("concat")) - if v127.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) - } - v128 := v127.Get() - v129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v130 := v129.FindInternedVar(lang.NewSymbol("list")) - if v130.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v130))) - } - v131 := v130.Get() - v132 := lang.Apply(v131, []any{lang.NewSymbol("glojure.core/let")}) - v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v134 := v133.FindInternedVar(lang.NewSymbol("list")) - if v134.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) - } - v135 := v134.Get() - v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v137 := v136.FindInternedVar(lang.NewSymbol("apply")) - if v137.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) - } - v138 := v137.Get() - v139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v140 := v139.FindInternedVar(lang.NewSymbol("vector")) - if v140.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v140))) - } - v141 := v140.Get() - v142 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v143 := v142.FindInternedVar(lang.NewSymbol("seq")) - if v143.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v143))) - } - v144 := v143.Get() - v145 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v146 := v145.FindInternedVar(lang.NewSymbol("concat")) - if v146.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v146))) - } - v147 := v146.Get() - v148 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v149 := v148.FindInternedVar(lang.NewSymbol("list")) - if v149.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v149))) - } - v150 := v149.Get() - v151 := lang.Apply(v150, []any{v61}) - v152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v153 := v152.FindInternedVar(lang.NewSymbol("list")) - if v153.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v153))) - } - v154 := v153.Get() - v155 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v156 := v155.FindInternedVar(lang.NewSymbol("seq")) - if v156.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v156))) - } - v157 := v156.Get() - v158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v159 := v158.FindInternedVar(lang.NewSymbol("concat")) - if v159.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v159))) - } - v160 := v159.Get() - v161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v162 := v161.FindInternedVar(lang.NewSymbol("list")) - if v162.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v162))) - } - v163 := v162.Get() - v164 := lang.Apply(v163, []any{lang.NewSymbol("glojure.core/first")}) - v165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v166 := v165.FindInternedVar(lang.NewSymbol("list")) - if v166.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v166))) - } - v167 := v166.Get() - v168 := lang.Apply(v167, []any{lang.NewSymbol("xs__0__auto__")}) - v169 := lang.Apply(v160, []any{v164, v168}) - v170 := lang.Apply(v157, []any{v169}) - v171 := lang.Apply(v154, []any{v170}) - v172 := lang.Apply(v147, []any{v151, v171}) - v173 := lang.Apply(v144, []any{v172}) - v174 := lang.Apply(v138, []any{v141, v173}) - v175 := lang.Apply(v135, []any{v174}) - v176 := lang.Apply(v128, []any{v132, v175, v6}) - v177 := lang.Apply(v125, []any{v176}) - v178 := lang.Apply(v122, []any{v177}) - v179 := lang.Apply(v72, []any{v76, v119, v178}) - v180 := lang.Apply(v69, []any{v179}) - v55 = v180 + tmp67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp68 := tmp67.FindInternedVar(lang.NewSymbol("seq")) + if tmp68.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp68))) + } + tmp69 := tmp68.Get() + tmp70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp71 := tmp70.FindInternedVar(lang.NewSymbol("concat")) + if tmp71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp71))) + } + tmp72 := tmp71.Get() + tmp73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp74 := tmp73.FindInternedVar(lang.NewSymbol("list")) + if tmp74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp74))) + } + tmp75 := tmp74.Get() + tmp76 := lang.Apply(tmp75, []any{lang.NewSymbol("glojure.core/when-let")}) + tmp77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp78 := tmp77.FindInternedVar(lang.NewSymbol("list")) + if tmp78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp78))) + } + tmp79 := tmp78.Get() + tmp80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp81 := tmp80.FindInternedVar(lang.NewSymbol("apply")) + if tmp81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp81))) + } + tmp82 := tmp81.Get() + tmp83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp84 := tmp83.FindInternedVar(lang.NewSymbol("vector")) + if tmp84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp84))) + } + tmp85 := tmp84.Get() + tmp86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp87 := tmp86.FindInternedVar(lang.NewSymbol("seq")) + if tmp87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp87))) + } + tmp88 := tmp87.Get() + tmp89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp90 := tmp89.FindInternedVar(lang.NewSymbol("concat")) + if tmp90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp90))) + } + tmp91 := tmp90.Get() + tmp92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp93 := tmp92.FindInternedVar(lang.NewSymbol("list")) + if tmp93.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp93))) + } + tmp94 := tmp93.Get() + tmp95 := lang.Apply(tmp94, []any{lang.NewSymbol("xs__0__auto__")}) + tmp96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp97 := tmp96.FindInternedVar(lang.NewSymbol("list")) + if tmp97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp97))) + } + tmp98 := tmp97.Get() + tmp99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp100 := tmp99.FindInternedVar(lang.NewSymbol("seq")) + if tmp100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp100))) + } + tmp101 := tmp100.Get() + tmp102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp103 := tmp102.FindInternedVar(lang.NewSymbol("concat")) + if tmp103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp103))) + } + tmp104 := tmp103.Get() + tmp105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp106 := tmp105.FindInternedVar(lang.NewSymbol("list")) + if tmp106.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp106))) + } + tmp107 := tmp106.Get() + tmp108 := lang.Apply(tmp107, []any{lang.NewSymbol("glojure.core/seq")}) + tmp109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp110 := tmp109.FindInternedVar(lang.NewSymbol("list")) + if tmp110.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp110))) + } + tmp111 := tmp110.Get() + tmp112 := lang.Apply(tmp111, []any{v66}) + tmp113 := lang.Apply(tmp104, []any{tmp108, tmp112}) + tmp114 := lang.Apply(tmp101, []any{tmp113}) + tmp115 := lang.Apply(tmp98, []any{tmp114}) + tmp116 := lang.Apply(tmp91, []any{tmp95, tmp115}) + tmp117 := lang.Apply(tmp88, []any{tmp116}) + tmp118 := lang.Apply(tmp82, []any{tmp85, tmp117}) + tmp119 := lang.Apply(tmp79, []any{tmp118}) + tmp120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp121 := tmp120.FindInternedVar(lang.NewSymbol("list")) + if tmp121.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp121))) + } + tmp122 := tmp121.Get() + tmp123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp124 := tmp123.FindInternedVar(lang.NewSymbol("seq")) + if tmp124.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp124))) + } + tmp125 := tmp124.Get() + tmp126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp127 := tmp126.FindInternedVar(lang.NewSymbol("concat")) + if tmp127.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp127))) + } + tmp128 := tmp127.Get() + tmp129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp130 := tmp129.FindInternedVar(lang.NewSymbol("list")) + if tmp130.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp130))) + } + tmp131 := tmp130.Get() + tmp132 := lang.Apply(tmp131, []any{lang.NewSymbol("glojure.core/let")}) + tmp133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp134 := tmp133.FindInternedVar(lang.NewSymbol("list")) + if tmp134.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp134))) + } + tmp135 := tmp134.Get() + tmp136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp137 := tmp136.FindInternedVar(lang.NewSymbol("apply")) + if tmp137.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp137))) + } + tmp138 := tmp137.Get() + tmp139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp140 := tmp139.FindInternedVar(lang.NewSymbol("vector")) + if tmp140.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp140))) + } + tmp141 := tmp140.Get() + tmp142 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp143 := tmp142.FindInternedVar(lang.NewSymbol("seq")) + if tmp143.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp143))) + } + tmp144 := tmp143.Get() + tmp145 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp146 := tmp145.FindInternedVar(lang.NewSymbol("concat")) + if tmp146.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp146))) + } + tmp147 := tmp146.Get() + tmp148 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp149 := tmp148.FindInternedVar(lang.NewSymbol("list")) + if tmp149.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp149))) + } + tmp150 := tmp149.Get() + tmp151 := lang.Apply(tmp150, []any{v61}) + tmp152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp153 := tmp152.FindInternedVar(lang.NewSymbol("list")) + if tmp153.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp153))) + } + tmp154 := tmp153.Get() + tmp155 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp156 := tmp155.FindInternedVar(lang.NewSymbol("seq")) + if tmp156.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp156))) + } + tmp157 := tmp156.Get() + tmp158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp159 := tmp158.FindInternedVar(lang.NewSymbol("concat")) + if tmp159.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp159))) + } + tmp160 := tmp159.Get() + tmp161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp162 := tmp161.FindInternedVar(lang.NewSymbol("list")) + if tmp162.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp162))) + } + tmp163 := tmp162.Get() + tmp164 := lang.Apply(tmp163, []any{lang.NewSymbol("glojure.core/first")}) + tmp165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp166 := tmp165.FindInternedVar(lang.NewSymbol("list")) + if tmp166.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp166))) + } + tmp167 := tmp166.Get() + tmp168 := lang.Apply(tmp167, []any{lang.NewSymbol("xs__0__auto__")}) + tmp169 := lang.Apply(tmp160, []any{tmp164, tmp168}) + tmp170 := lang.Apply(tmp157, []any{tmp169}) + tmp171 := lang.Apply(tmp154, []any{tmp170}) + tmp172 := lang.Apply(tmp147, []any{tmp151, tmp171}) + tmp173 := lang.Apply(tmp144, []any{tmp172}) + tmp174 := lang.Apply(tmp138, []any{tmp141, tmp173}) + tmp175 := lang.Apply(tmp135, []any{tmp174}) + tmp176 := lang.Apply(tmp128, []any{tmp132, tmp175, v6}) + tmp177 := lang.Apply(tmp125, []any{tmp176}) + tmp178 := lang.Apply(tmp122, []any{tmp177}) + tmp179 := lang.Apply(tmp72, []any{tmp76, tmp119, tmp178}) + tmp180 := lang.Apply(tmp69, []any{tmp179}) + tmp55 = tmp180 } // end let - return v55 + return tmp55 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // when-let { - v0 := lang.NewSymbol("when-let").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "bindings => binding-form test\n\n When test is true, evaluates body with binding-form bound to the value of test", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1859), lang.NewKeyword("end-line"), int(1859))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("when-let").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "bindings => binding-form test\n\n When test is true, evaluates body with binding-form bound to the value of test", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1859), lang.NewKeyword("end-line"), int(1859))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 3 { @@ -83324,307 +83523,305 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - var v7 any - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v5}) - if lang.IsTruthy(v11) { - v7 = nil + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("vector?")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v5}) + if lang.IsTruthy(tmp11) { } else { - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("str")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("first")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{v3}) - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("meta")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v3}) - v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) - v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) - v28 := lang.Apply(lang.NewIllegalArgumentError, []any{v27}) - panic(v28) - } - _ = v7 - var v29 any - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("=")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) - } - v32 := v31.Get() - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("count")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - v36 := lang.Apply(v35, []any{v5}) - v37 := lang.Apply(v32, []any{int64(2), v36}) - if lang.IsTruthy(v37) { - v29 = nil + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("str")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("first")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("*ns*")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("meta")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.Apply(tmp24, []any{v3}) + tmp26 := lang.Apply(lang.NewKeyword("line"), []any{tmp25}) + tmp27 := lang.Apply(tmp14, []any{tmp18, " requires ", "a vector for its binding", " in ", tmp21, ":", tmp26}) + tmp28 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp27}) + panic(tmp28) + } + _ = tmp7 + var tmp29 any + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("=")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) + } + tmp32 := tmp31.Get() + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("count")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) + } + tmp35 := tmp34.Get() + tmp36 := lang.Apply(tmp35, []any{v5}) + tmp37 := lang.Apply(tmp32, []any{int64(2), tmp36}) + if lang.IsTruthy(tmp37) { } else { - v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v39 := v38.FindInternedVar(lang.NewSymbol("str")) - if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) - } - v40 := v39.Get() - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("first")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) - } - v43 := v42.Get() - v44 := lang.Apply(v43, []any{v3}) - v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) - if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) - } - v47 := v46.Get() - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("meta")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v3}) - v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) - v53 := lang.Apply(v40, []any{v44, " requires ", "exactly 2 forms in binding vector", " in ", v47, ":", v52}) - v54 := lang.Apply(lang.NewIllegalArgumentError, []any{v53}) - panic(v54) - } - _ = v29 - _ = nil - var v55 any + tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp39 := tmp38.FindInternedVar(lang.NewSymbol("str")) + if tmp39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) + } + tmp40 := tmp39.Get() + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("first")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := lang.Apply(tmp43, []any{v3}) + tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp46 := tmp45.FindInternedVar(lang.NewSymbol("*ns*")) + if tmp46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) + } + tmp47 := tmp46.Get() + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("meta")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v3}) + tmp52 := lang.Apply(lang.NewKeyword("line"), []any{tmp51}) + tmp53 := lang.Apply(tmp40, []any{tmp44, " requires ", "exactly 2 forms in binding vector", " in ", tmp47, ":", tmp52}) + tmp54 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp53}) + panic(tmp54) + } + _ = tmp29 + var tmp55 any { // let // let binding "form" - v56 := lang.Apply(v5, []any{int64(0)}) - var v57 any = v56 + tmp56 := lang.Apply(v5, []any{int64(0)}) + var v57 any = tmp56 _ = v57 // let binding "tst" - v58 := lang.Apply(v5, []any{int64(1)}) - var v59 any = v58 + tmp58 := lang.Apply(v5, []any{int64(1)}) + var v59 any = tmp58 _ = v59 - v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v61 := v60.FindInternedVar(lang.NewSymbol("seq")) - if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) - } - v62 := v61.Get() - v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v64 := v63.FindInternedVar(lang.NewSymbol("concat")) - if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) - } - v65 := v64.Get() - v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v67 := v66.FindInternedVar(lang.NewSymbol("list")) - if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) - } - v68 := v67.Get() - v69 := lang.Apply(v68, []any{lang.NewSymbol("glojure.core/let")}) - v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v71 := v70.FindInternedVar(lang.NewSymbol("list")) - if v71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) - } - v72 := v71.Get() - v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v74 := v73.FindInternedVar(lang.NewSymbol("apply")) - if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) - } - v75 := v74.Get() - v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v77 := v76.FindInternedVar(lang.NewSymbol("vector")) - if v77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) - } - v78 := v77.Get() - v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v80 := v79.FindInternedVar(lang.NewSymbol("seq")) - if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) - } - v81 := v80.Get() - v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v83 := v82.FindInternedVar(lang.NewSymbol("concat")) - if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) - } - v84 := v83.Get() - v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v86 := v85.FindInternedVar(lang.NewSymbol("list")) - if v86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) - } - v87 := v86.Get() - v88 := lang.Apply(v87, []any{lang.NewSymbol("temp__0__auto__")}) - v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v90 := v89.FindInternedVar(lang.NewSymbol("list")) - if v90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) - } - v91 := v90.Get() - v92 := lang.Apply(v91, []any{v59}) - v93 := lang.Apply(v84, []any{v88, v92}) - v94 := lang.Apply(v81, []any{v93}) - v95 := lang.Apply(v75, []any{v78, v94}) - v96 := lang.Apply(v72, []any{v95}) - v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v98 := v97.FindInternedVar(lang.NewSymbol("list")) - if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) - } - v99 := v98.Get() - v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v101 := v100.FindInternedVar(lang.NewSymbol("seq")) - if v101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) - } - v102 := v101.Get() - v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v104 := v103.FindInternedVar(lang.NewSymbol("concat")) - if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) - } - v105 := v104.Get() - v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v107 := v106.FindInternedVar(lang.NewSymbol("list")) - if v107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) - } - v108 := v107.Get() - v109 := lang.Apply(v108, []any{lang.NewSymbol("glojure.core/when")}) - v110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v111 := v110.FindInternedVar(lang.NewSymbol("list")) - if v111.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v111))) - } - v112 := v111.Get() - v113 := lang.Apply(v112, []any{lang.NewSymbol("temp__0__auto__")}) - v114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v115 := v114.FindInternedVar(lang.NewSymbol("list")) - if v115.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v115))) - } - v116 := v115.Get() - v117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v118 := v117.FindInternedVar(lang.NewSymbol("seq")) - if v118.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v118))) - } - v119 := v118.Get() - v120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v121 := v120.FindInternedVar(lang.NewSymbol("concat")) - if v121.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v121))) - } - v122 := v121.Get() - v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v124 := v123.FindInternedVar(lang.NewSymbol("list")) - if v124.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) - } - v125 := v124.Get() - v126 := lang.Apply(v125, []any{lang.NewSymbol("glojure.core/let")}) - v127 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v128 := v127.FindInternedVar(lang.NewSymbol("list")) - if v128.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v128))) - } - v129 := v128.Get() - v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v131 := v130.FindInternedVar(lang.NewSymbol("apply")) - if v131.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) - } - v132 := v131.Get() - v133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v134 := v133.FindInternedVar(lang.NewSymbol("vector")) - if v134.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v134))) - } - v135 := v134.Get() - v136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v137 := v136.FindInternedVar(lang.NewSymbol("seq")) - if v137.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v137))) - } - v138 := v137.Get() - v139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v140 := v139.FindInternedVar(lang.NewSymbol("concat")) - if v140.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v140))) - } - v141 := v140.Get() - v142 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v143 := v142.FindInternedVar(lang.NewSymbol("list")) - if v143.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v143))) - } - v144 := v143.Get() - v145 := lang.Apply(v144, []any{v57}) - v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v147 := v146.FindInternedVar(lang.NewSymbol("list")) - if v147.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) - } - v148 := v147.Get() - v149 := lang.Apply(v148, []any{lang.NewSymbol("temp__0__auto__")}) - v150 := lang.Apply(v141, []any{v145, v149}) - v151 := lang.Apply(v138, []any{v150}) - v152 := lang.Apply(v132, []any{v135, v151}) - v153 := lang.Apply(v129, []any{v152}) - v154 := lang.Apply(v122, []any{v126, v153, v6}) - v155 := lang.Apply(v119, []any{v154}) - v156 := lang.Apply(v116, []any{v155}) - v157 := lang.Apply(v105, []any{v109, v113, v156}) - v158 := lang.Apply(v102, []any{v157}) - v159 := lang.Apply(v99, []any{v158}) - v160 := lang.Apply(v65, []any{v69, v96, v159}) - v161 := lang.Apply(v62, []any{v160}) - v55 = v161 + tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp61 := tmp60.FindInternedVar(lang.NewSymbol("seq")) + if tmp61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) + } + tmp62 := tmp61.Get() + tmp63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp64 := tmp63.FindInternedVar(lang.NewSymbol("concat")) + if tmp64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp64))) + } + tmp65 := tmp64.Get() + tmp66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp67 := tmp66.FindInternedVar(lang.NewSymbol("list")) + if tmp67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp67))) + } + tmp68 := tmp67.Get() + tmp69 := lang.Apply(tmp68, []any{lang.NewSymbol("glojure.core/let")}) + tmp70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp71 := tmp70.FindInternedVar(lang.NewSymbol("list")) + if tmp71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp71))) + } + tmp72 := tmp71.Get() + tmp73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp74 := tmp73.FindInternedVar(lang.NewSymbol("apply")) + if tmp74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp74))) + } + tmp75 := tmp74.Get() + tmp76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp77 := tmp76.FindInternedVar(lang.NewSymbol("vector")) + if tmp77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp77))) + } + tmp78 := tmp77.Get() + tmp79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp80 := tmp79.FindInternedVar(lang.NewSymbol("seq")) + if tmp80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp80))) + } + tmp81 := tmp80.Get() + tmp82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp83 := tmp82.FindInternedVar(lang.NewSymbol("concat")) + if tmp83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp83))) + } + tmp84 := tmp83.Get() + tmp85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp86 := tmp85.FindInternedVar(lang.NewSymbol("list")) + if tmp86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp86))) + } + tmp87 := tmp86.Get() + tmp88 := lang.Apply(tmp87, []any{lang.NewSymbol("temp__0__auto__")}) + tmp89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp90 := tmp89.FindInternedVar(lang.NewSymbol("list")) + if tmp90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp90))) + } + tmp91 := tmp90.Get() + tmp92 := lang.Apply(tmp91, []any{v59}) + tmp93 := lang.Apply(tmp84, []any{tmp88, tmp92}) + tmp94 := lang.Apply(tmp81, []any{tmp93}) + tmp95 := lang.Apply(tmp75, []any{tmp78, tmp94}) + tmp96 := lang.Apply(tmp72, []any{tmp95}) + tmp97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp98 := tmp97.FindInternedVar(lang.NewSymbol("list")) + if tmp98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp98))) + } + tmp99 := tmp98.Get() + tmp100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp101 := tmp100.FindInternedVar(lang.NewSymbol("seq")) + if tmp101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp101))) + } + tmp102 := tmp101.Get() + tmp103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp104 := tmp103.FindInternedVar(lang.NewSymbol("concat")) + if tmp104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp104))) + } + tmp105 := tmp104.Get() + tmp106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp107 := tmp106.FindInternedVar(lang.NewSymbol("list")) + if tmp107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp107))) + } + tmp108 := tmp107.Get() + tmp109 := lang.Apply(tmp108, []any{lang.NewSymbol("glojure.core/when")}) + tmp110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp111 := tmp110.FindInternedVar(lang.NewSymbol("list")) + if tmp111.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp111))) + } + tmp112 := tmp111.Get() + tmp113 := lang.Apply(tmp112, []any{lang.NewSymbol("temp__0__auto__")}) + tmp114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp115 := tmp114.FindInternedVar(lang.NewSymbol("list")) + if tmp115.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp115))) + } + tmp116 := tmp115.Get() + tmp117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp118 := tmp117.FindInternedVar(lang.NewSymbol("seq")) + if tmp118.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp118))) + } + tmp119 := tmp118.Get() + tmp120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp121 := tmp120.FindInternedVar(lang.NewSymbol("concat")) + if tmp121.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp121))) + } + tmp122 := tmp121.Get() + tmp123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp124 := tmp123.FindInternedVar(lang.NewSymbol("list")) + if tmp124.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp124))) + } + tmp125 := tmp124.Get() + tmp126 := lang.Apply(tmp125, []any{lang.NewSymbol("glojure.core/let")}) + tmp127 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp128 := tmp127.FindInternedVar(lang.NewSymbol("list")) + if tmp128.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp128))) + } + tmp129 := tmp128.Get() + tmp130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp131 := tmp130.FindInternedVar(lang.NewSymbol("apply")) + if tmp131.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp131))) + } + tmp132 := tmp131.Get() + tmp133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp134 := tmp133.FindInternedVar(lang.NewSymbol("vector")) + if tmp134.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp134))) + } + tmp135 := tmp134.Get() + tmp136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp137 := tmp136.FindInternedVar(lang.NewSymbol("seq")) + if tmp137.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp137))) + } + tmp138 := tmp137.Get() + tmp139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp140 := tmp139.FindInternedVar(lang.NewSymbol("concat")) + if tmp140.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp140))) + } + tmp141 := tmp140.Get() + tmp142 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp143 := tmp142.FindInternedVar(lang.NewSymbol("list")) + if tmp143.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp143))) + } + tmp144 := tmp143.Get() + tmp145 := lang.Apply(tmp144, []any{v57}) + tmp146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp147 := tmp146.FindInternedVar(lang.NewSymbol("list")) + if tmp147.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp147))) + } + tmp148 := tmp147.Get() + tmp149 := lang.Apply(tmp148, []any{lang.NewSymbol("temp__0__auto__")}) + tmp150 := lang.Apply(tmp141, []any{tmp145, tmp149}) + tmp151 := lang.Apply(tmp138, []any{tmp150}) + tmp152 := lang.Apply(tmp132, []any{tmp135, tmp151}) + tmp153 := lang.Apply(tmp129, []any{tmp152}) + tmp154 := lang.Apply(tmp122, []any{tmp126, tmp153, v6}) + tmp155 := lang.Apply(tmp119, []any{tmp154}) + tmp156 := lang.Apply(tmp116, []any{tmp155}) + tmp157 := lang.Apply(tmp105, []any{tmp109, tmp113, tmp156}) + tmp158 := lang.Apply(tmp102, []any{tmp157}) + tmp159 := lang.Apply(tmp99, []any{tmp158}) + tmp160 := lang.Apply(tmp65, []any{tmp69, tmp96, tmp159}) + tmp161 := lang.Apply(tmp62, []any{tmp160}) + tmp55 = tmp161 } // end let - return v55 + return tmp55 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // when-not { - v0 := lang.NewSymbol("when-not").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("test"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Evaluates test. If logical false, evaluates body in an implicit do.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(498), lang.NewKeyword("end-line"), int(498))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("when-not").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("test"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Evaluates test. If logical false, evaluates body in an implicit do.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(498), lang.NewKeyword("end-line"), int(498))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 3 { @@ -83636,35 +83833,36 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("list")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("list")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("cons")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("cons")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol("do"), v6}) - v14 := lang.Apply(v9, []any{lang.NewSymbol("if"), v5, nil, v13}) - return v14 + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol("do"), v6}) + tmp14 := lang.Apply(tmp9, []any{lang.NewSymbol("if"), v5, nil, tmp13}) + return tmp14 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // when-some { - v0 := lang.NewSymbol("when-some").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "bindings => binding-form test\n\n When test is not nil, evaluates body with binding-form bound to the\n value of test", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1894), lang.NewKeyword("end-line"), int(1894))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("when-some").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "bindings => binding-form test\n\n When test is not nil, evaluates body with binding-form bound to the\n value of test", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1894), lang.NewKeyword("end-line"), int(1894))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 3 { @@ -83676,342 +83874,340 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - var v7 any - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v5}) - if lang.IsTruthy(v11) { - v7 = nil + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("vector?")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v5}) + if lang.IsTruthy(tmp11) { } else { - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("str")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("first")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{v3}) - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("meta")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v3}) - v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) - v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) - v28 := lang.Apply(lang.NewIllegalArgumentError, []any{v27}) - panic(v28) - } - _ = v7 - var v29 any - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("=")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) - } - v32 := v31.Get() - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("count")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - v36 := lang.Apply(v35, []any{v5}) - v37 := lang.Apply(v32, []any{int64(2), v36}) - if lang.IsTruthy(v37) { - v29 = nil + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("str")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("first")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("*ns*")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("meta")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.Apply(tmp24, []any{v3}) + tmp26 := lang.Apply(lang.NewKeyword("line"), []any{tmp25}) + tmp27 := lang.Apply(tmp14, []any{tmp18, " requires ", "a vector for its binding", " in ", tmp21, ":", tmp26}) + tmp28 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp27}) + panic(tmp28) + } + _ = tmp7 + var tmp29 any + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("=")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) + } + tmp32 := tmp31.Get() + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("count")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) + } + tmp35 := tmp34.Get() + tmp36 := lang.Apply(tmp35, []any{v5}) + tmp37 := lang.Apply(tmp32, []any{int64(2), tmp36}) + if lang.IsTruthy(tmp37) { } else { - v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v39 := v38.FindInternedVar(lang.NewSymbol("str")) - if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) - } - v40 := v39.Get() - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("first")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) - } - v43 := v42.Get() - v44 := lang.Apply(v43, []any{v3}) - v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) - if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) - } - v47 := v46.Get() - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("meta")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v3}) - v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) - v53 := lang.Apply(v40, []any{v44, " requires ", "exactly 2 forms in binding vector", " in ", v47, ":", v52}) - v54 := lang.Apply(lang.NewIllegalArgumentError, []any{v53}) - panic(v54) - } - _ = v29 - _ = nil - var v55 any + tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp39 := tmp38.FindInternedVar(lang.NewSymbol("str")) + if tmp39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) + } + tmp40 := tmp39.Get() + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("first")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := lang.Apply(tmp43, []any{v3}) + tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp46 := tmp45.FindInternedVar(lang.NewSymbol("*ns*")) + if tmp46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) + } + tmp47 := tmp46.Get() + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("meta")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v3}) + tmp52 := lang.Apply(lang.NewKeyword("line"), []any{tmp51}) + tmp53 := lang.Apply(tmp40, []any{tmp44, " requires ", "exactly 2 forms in binding vector", " in ", tmp47, ":", tmp52}) + tmp54 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp53}) + panic(tmp54) + } + _ = tmp29 + var tmp55 any { // let // let binding "form" - v56 := lang.Apply(v5, []any{int64(0)}) - var v57 any = v56 + tmp56 := lang.Apply(v5, []any{int64(0)}) + var v57 any = tmp56 _ = v57 // let binding "tst" - v58 := lang.Apply(v5, []any{int64(1)}) - var v59 any = v58 + tmp58 := lang.Apply(v5, []any{int64(1)}) + var v59 any = tmp58 _ = v59 - v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v61 := v60.FindInternedVar(lang.NewSymbol("seq")) - if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) - } - v62 := v61.Get() - v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v64 := v63.FindInternedVar(lang.NewSymbol("concat")) - if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) - } - v65 := v64.Get() - v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v67 := v66.FindInternedVar(lang.NewSymbol("list")) - if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) - } - v68 := v67.Get() - v69 := lang.Apply(v68, []any{lang.NewSymbol("glojure.core/let")}) - v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v71 := v70.FindInternedVar(lang.NewSymbol("list")) - if v71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) - } - v72 := v71.Get() - v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v74 := v73.FindInternedVar(lang.NewSymbol("apply")) - if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) - } - v75 := v74.Get() - v76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v77 := v76.FindInternedVar(lang.NewSymbol("vector")) - if v77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v77))) - } - v78 := v77.Get() - v79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v80 := v79.FindInternedVar(lang.NewSymbol("seq")) - if v80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v80))) - } - v81 := v80.Get() - v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v83 := v82.FindInternedVar(lang.NewSymbol("concat")) - if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) - } - v84 := v83.Get() - v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v86 := v85.FindInternedVar(lang.NewSymbol("list")) - if v86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) - } - v87 := v86.Get() - v88 := lang.Apply(v87, []any{lang.NewSymbol("temp__0__auto__")}) - v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v90 := v89.FindInternedVar(lang.NewSymbol("list")) - if v90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) - } - v91 := v90.Get() - v92 := lang.Apply(v91, []any{v59}) - v93 := lang.Apply(v84, []any{v88, v92}) - v94 := lang.Apply(v81, []any{v93}) - v95 := lang.Apply(v75, []any{v78, v94}) - v96 := lang.Apply(v72, []any{v95}) - v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v98 := v97.FindInternedVar(lang.NewSymbol("list")) - if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) - } - v99 := v98.Get() - v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v101 := v100.FindInternedVar(lang.NewSymbol("seq")) - if v101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) - } - v102 := v101.Get() - v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v104 := v103.FindInternedVar(lang.NewSymbol("concat")) - if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) - } - v105 := v104.Get() - v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v107 := v106.FindInternedVar(lang.NewSymbol("list")) - if v107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) - } - v108 := v107.Get() - v109 := lang.Apply(v108, []any{lang.NewSymbol("if")}) - v110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v111 := v110.FindInternedVar(lang.NewSymbol("list")) - if v111.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v111))) - } - v112 := v111.Get() - v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v114 := v113.FindInternedVar(lang.NewSymbol("seq")) - if v114.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) - } - v115 := v114.Get() - v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v117 := v116.FindInternedVar(lang.NewSymbol("concat")) - if v117.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) - } - v118 := v117.Get() - v119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v120 := v119.FindInternedVar(lang.NewSymbol("list")) - if v120.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v120))) - } - v121 := v120.Get() - v122 := lang.Apply(v121, []any{lang.NewSymbol("glojure.core/nil?")}) - v123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v124 := v123.FindInternedVar(lang.NewSymbol("list")) - if v124.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v124))) - } - v125 := v124.Get() - v126 := lang.Apply(v125, []any{lang.NewSymbol("temp__0__auto__")}) - v127 := lang.Apply(v118, []any{v122, v126}) - v128 := lang.Apply(v115, []any{v127}) - v129 := lang.Apply(v112, []any{v128}) - v130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v131 := v130.FindInternedVar(lang.NewSymbol("list")) - if v131.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v131))) - } - v132 := v131.Get() - v133 := lang.Apply(v132, []any{nil}) - v134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v135 := v134.FindInternedVar(lang.NewSymbol("list")) - if v135.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v135))) - } - v136 := v135.Get() - v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v138 := v137.FindInternedVar(lang.NewSymbol("seq")) - if v138.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) - } - v139 := v138.Get() - v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v141 := v140.FindInternedVar(lang.NewSymbol("concat")) - if v141.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) - } - v142 := v141.Get() - v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v144 := v143.FindInternedVar(lang.NewSymbol("list")) - if v144.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) - } - v145 := v144.Get() - v146 := lang.Apply(v145, []any{lang.NewSymbol("glojure.core/let")}) - v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v148 := v147.FindInternedVar(lang.NewSymbol("list")) - if v148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) - } - v149 := v148.Get() - v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v151 := v150.FindInternedVar(lang.NewSymbol("apply")) - if v151.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) - } - v152 := v151.Get() - v153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v154 := v153.FindInternedVar(lang.NewSymbol("vector")) - if v154.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v154))) - } - v155 := v154.Get() - v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v157 := v156.FindInternedVar(lang.NewSymbol("seq")) - if v157.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) - } - v158 := v157.Get() - v159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v160 := v159.FindInternedVar(lang.NewSymbol("concat")) - if v160.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v160))) - } - v161 := v160.Get() - v162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v163 := v162.FindInternedVar(lang.NewSymbol("list")) - if v163.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v163))) - } - v164 := v163.Get() - v165 := lang.Apply(v164, []any{v57}) - v166 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v167 := v166.FindInternedVar(lang.NewSymbol("list")) - if v167.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v167))) - } - v168 := v167.Get() - v169 := lang.Apply(v168, []any{lang.NewSymbol("temp__0__auto__")}) - v170 := lang.Apply(v161, []any{v165, v169}) - v171 := lang.Apply(v158, []any{v170}) - v172 := lang.Apply(v152, []any{v155, v171}) - v173 := lang.Apply(v149, []any{v172}) - v174 := lang.Apply(v142, []any{v146, v173, v6}) - v175 := lang.Apply(v139, []any{v174}) - v176 := lang.Apply(v136, []any{v175}) - v177 := lang.Apply(v105, []any{v109, v129, v133, v176}) - v178 := lang.Apply(v102, []any{v177}) - v179 := lang.Apply(v99, []any{v178}) - v180 := lang.Apply(v65, []any{v69, v96, v179}) - v181 := lang.Apply(v62, []any{v180}) - v55 = v181 + tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp61 := tmp60.FindInternedVar(lang.NewSymbol("seq")) + if tmp61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) + } + tmp62 := tmp61.Get() + tmp63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp64 := tmp63.FindInternedVar(lang.NewSymbol("concat")) + if tmp64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp64))) + } + tmp65 := tmp64.Get() + tmp66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp67 := tmp66.FindInternedVar(lang.NewSymbol("list")) + if tmp67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp67))) + } + tmp68 := tmp67.Get() + tmp69 := lang.Apply(tmp68, []any{lang.NewSymbol("glojure.core/let")}) + tmp70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp71 := tmp70.FindInternedVar(lang.NewSymbol("list")) + if tmp71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp71))) + } + tmp72 := tmp71.Get() + tmp73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp74 := tmp73.FindInternedVar(lang.NewSymbol("apply")) + if tmp74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp74))) + } + tmp75 := tmp74.Get() + tmp76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp77 := tmp76.FindInternedVar(lang.NewSymbol("vector")) + if tmp77.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp77))) + } + tmp78 := tmp77.Get() + tmp79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp80 := tmp79.FindInternedVar(lang.NewSymbol("seq")) + if tmp80.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp80))) + } + tmp81 := tmp80.Get() + tmp82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp83 := tmp82.FindInternedVar(lang.NewSymbol("concat")) + if tmp83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp83))) + } + tmp84 := tmp83.Get() + tmp85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp86 := tmp85.FindInternedVar(lang.NewSymbol("list")) + if tmp86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp86))) + } + tmp87 := tmp86.Get() + tmp88 := lang.Apply(tmp87, []any{lang.NewSymbol("temp__0__auto__")}) + tmp89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp90 := tmp89.FindInternedVar(lang.NewSymbol("list")) + if tmp90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp90))) + } + tmp91 := tmp90.Get() + tmp92 := lang.Apply(tmp91, []any{v59}) + tmp93 := lang.Apply(tmp84, []any{tmp88, tmp92}) + tmp94 := lang.Apply(tmp81, []any{tmp93}) + tmp95 := lang.Apply(tmp75, []any{tmp78, tmp94}) + tmp96 := lang.Apply(tmp72, []any{tmp95}) + tmp97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp98 := tmp97.FindInternedVar(lang.NewSymbol("list")) + if tmp98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp98))) + } + tmp99 := tmp98.Get() + tmp100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp101 := tmp100.FindInternedVar(lang.NewSymbol("seq")) + if tmp101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp101))) + } + tmp102 := tmp101.Get() + tmp103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp104 := tmp103.FindInternedVar(lang.NewSymbol("concat")) + if tmp104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp104))) + } + tmp105 := tmp104.Get() + tmp106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp107 := tmp106.FindInternedVar(lang.NewSymbol("list")) + if tmp107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp107))) + } + tmp108 := tmp107.Get() + tmp109 := lang.Apply(tmp108, []any{lang.NewSymbol("if")}) + tmp110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp111 := tmp110.FindInternedVar(lang.NewSymbol("list")) + if tmp111.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp111))) + } + tmp112 := tmp111.Get() + tmp113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp114 := tmp113.FindInternedVar(lang.NewSymbol("seq")) + if tmp114.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp114))) + } + tmp115 := tmp114.Get() + tmp116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp117 := tmp116.FindInternedVar(lang.NewSymbol("concat")) + if tmp117.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp117))) + } + tmp118 := tmp117.Get() + tmp119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp120 := tmp119.FindInternedVar(lang.NewSymbol("list")) + if tmp120.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp120))) + } + tmp121 := tmp120.Get() + tmp122 := lang.Apply(tmp121, []any{lang.NewSymbol("glojure.core/nil?")}) + tmp123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp124 := tmp123.FindInternedVar(lang.NewSymbol("list")) + if tmp124.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp124))) + } + tmp125 := tmp124.Get() + tmp126 := lang.Apply(tmp125, []any{lang.NewSymbol("temp__0__auto__")}) + tmp127 := lang.Apply(tmp118, []any{tmp122, tmp126}) + tmp128 := lang.Apply(tmp115, []any{tmp127}) + tmp129 := lang.Apply(tmp112, []any{tmp128}) + tmp130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp131 := tmp130.FindInternedVar(lang.NewSymbol("list")) + if tmp131.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp131))) + } + tmp132 := tmp131.Get() + tmp133 := lang.Apply(tmp132, []any{nil}) + tmp134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp135 := tmp134.FindInternedVar(lang.NewSymbol("list")) + if tmp135.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp135))) + } + tmp136 := tmp135.Get() + tmp137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp138 := tmp137.FindInternedVar(lang.NewSymbol("seq")) + if tmp138.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp138))) + } + tmp139 := tmp138.Get() + tmp140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp141 := tmp140.FindInternedVar(lang.NewSymbol("concat")) + if tmp141.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp141))) + } + tmp142 := tmp141.Get() + tmp143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp144 := tmp143.FindInternedVar(lang.NewSymbol("list")) + if tmp144.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp144))) + } + tmp145 := tmp144.Get() + tmp146 := lang.Apply(tmp145, []any{lang.NewSymbol("glojure.core/let")}) + tmp147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp148 := tmp147.FindInternedVar(lang.NewSymbol("list")) + if tmp148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp148))) + } + tmp149 := tmp148.Get() + tmp150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp151 := tmp150.FindInternedVar(lang.NewSymbol("apply")) + if tmp151.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp151))) + } + tmp152 := tmp151.Get() + tmp153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp154 := tmp153.FindInternedVar(lang.NewSymbol("vector")) + if tmp154.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp154))) + } + tmp155 := tmp154.Get() + tmp156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp157 := tmp156.FindInternedVar(lang.NewSymbol("seq")) + if tmp157.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp157))) + } + tmp158 := tmp157.Get() + tmp159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp160 := tmp159.FindInternedVar(lang.NewSymbol("concat")) + if tmp160.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp160))) + } + tmp161 := tmp160.Get() + tmp162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp163 := tmp162.FindInternedVar(lang.NewSymbol("list")) + if tmp163.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp163))) + } + tmp164 := tmp163.Get() + tmp165 := lang.Apply(tmp164, []any{v57}) + tmp166 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp167 := tmp166.FindInternedVar(lang.NewSymbol("list")) + if tmp167.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp167))) + } + tmp168 := tmp167.Get() + tmp169 := lang.Apply(tmp168, []any{lang.NewSymbol("temp__0__auto__")}) + tmp170 := lang.Apply(tmp161, []any{tmp165, tmp169}) + tmp171 := lang.Apply(tmp158, []any{tmp170}) + tmp172 := lang.Apply(tmp152, []any{tmp155, tmp171}) + tmp173 := lang.Apply(tmp149, []any{tmp172}) + tmp174 := lang.Apply(tmp142, []any{tmp146, tmp173, v6}) + tmp175 := lang.Apply(tmp139, []any{tmp174}) + tmp176 := lang.Apply(tmp136, []any{tmp175}) + tmp177 := lang.Apply(tmp105, []any{tmp109, tmp129, tmp133, tmp176}) + tmp178 := lang.Apply(tmp102, []any{tmp177}) + tmp179 := lang.Apply(tmp99, []any{tmp178}) + tmp180 := lang.Apply(tmp65, []any{tmp69, tmp96, tmp179}) + tmp181 := lang.Apply(tmp62, []any{tmp180}) + tmp55 = tmp181 } // end let - return v55 + return tmp55 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // while { - v0 := lang.NewSymbol("while").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("test"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Repeatedly executes body while test expression is true. Presumes\n some side-effect will cause test to become false/nil. Returns nil", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6327), lang.NewKeyword("end-line"), int(6327))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("while").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("test"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Repeatedly executes body while test expression is true. Presumes\n some side-effect will cause test to become false/nil. Returns nil", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6327), lang.NewKeyword("end-line"), int(6327))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 3 { @@ -84023,139 +84219,140 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("seq")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("concat")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("list")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/loop")}) - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("list")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("apply")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("vector")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("seq")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) - } - v28 := v27.Get() - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("concat")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.Apply(v31, nil) - v33 := lang.Apply(v28, []any{v32}) - v34 := lang.Apply(v22, []any{v25, v33}) - v35 := lang.Apply(v19, []any{v34}) - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("list")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v40 := v39.FindInternedVar(lang.NewSymbol("seq")) - if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) - } - v41 := v40.Get() - v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v43 := v42.FindInternedVar(lang.NewSymbol("concat")) - if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) - } - v44 := v43.Get() - v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v46 := v45.FindInternedVar(lang.NewSymbol("list")) - if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) - } - v47 := v46.Get() - v48 := lang.Apply(v47, []any{lang.NewSymbol("glojure.core/when")}) - v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v50 := v49.FindInternedVar(lang.NewSymbol("list")) - if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) - } - v51 := v50.Get() - v52 := lang.Apply(v51, []any{v5}) - v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v54 := v53.FindInternedVar(lang.NewSymbol("list")) - if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) - } - v55 := v54.Get() - v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v57 := v56.FindInternedVar(lang.NewSymbol("seq")) - if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) - } - v58 := v57.Get() - v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v60 := v59.FindInternedVar(lang.NewSymbol("concat")) - if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) - } - v61 := v60.Get() - v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v63 := v62.FindInternedVar(lang.NewSymbol("list")) - if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) - } - v64 := v63.Get() - v65 := lang.Apply(v64, []any{lang.NewSymbol("recur")}) - v66 := lang.Apply(v61, []any{v65}) - v67 := lang.Apply(v58, []any{v66}) - v68 := lang.Apply(v55, []any{v67}) - v69 := lang.Apply(v44, []any{v48, v52, v6, v68}) - v70 := lang.Apply(v41, []any{v69}) - v71 := lang.Apply(v38, []any{v70}) - v72 := lang.Apply(v12, []any{v16, v35, v71}) - v73 := lang.Apply(v9, []any{v72}) - return v73 - } - }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("seq")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("concat")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("list")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("glojure.core/loop")}) + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("list")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("apply")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("vector")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("seq")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) + } + tmp28 := tmp27.Get() + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("concat")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.Apply(tmp31, nil) + tmp33 := lang.Apply(tmp28, []any{tmp32}) + tmp34 := lang.Apply(tmp22, []any{tmp25, tmp33}) + tmp35 := lang.Apply(tmp19, []any{tmp34}) + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp40 := tmp39.FindInternedVar(lang.NewSymbol("seq")) + if tmp40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) + } + tmp41 := tmp40.Get() + tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp43 := tmp42.FindInternedVar(lang.NewSymbol("concat")) + if tmp43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) + } + tmp44 := tmp43.Get() + tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp46 := tmp45.FindInternedVar(lang.NewSymbol("list")) + if tmp46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) + } + tmp47 := tmp46.Get() + tmp48 := lang.Apply(tmp47, []any{lang.NewSymbol("glojure.core/when")}) + tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp50 := tmp49.FindInternedVar(lang.NewSymbol("list")) + if tmp50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) + } + tmp51 := tmp50.Get() + tmp52 := lang.Apply(tmp51, []any{v5}) + tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp54 := tmp53.FindInternedVar(lang.NewSymbol("list")) + if tmp54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) + } + tmp55 := tmp54.Get() + tmp56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp57 := tmp56.FindInternedVar(lang.NewSymbol("seq")) + if tmp57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp57))) + } + tmp58 := tmp57.Get() + tmp59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp60 := tmp59.FindInternedVar(lang.NewSymbol("concat")) + if tmp60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp60))) + } + tmp61 := tmp60.Get() + tmp62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp63 := tmp62.FindInternedVar(lang.NewSymbol("list")) + if tmp63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp63))) + } + tmp64 := tmp63.Get() + tmp65 := lang.Apply(tmp64, []any{lang.NewSymbol("recur")}) + tmp66 := lang.Apply(tmp61, []any{tmp65}) + tmp67 := lang.Apply(tmp58, []any{tmp66}) + tmp68 := lang.Apply(tmp55, []any{tmp67}) + tmp69 := lang.Apply(tmp44, []any{tmp48, tmp52, v6, tmp68}) + tmp70 := lang.Apply(tmp41, []any{tmp69}) + tmp71 := lang.Apply(tmp38, []any{tmp70}) + tmp72 := lang.Apply(tmp12, []any{tmp16, tmp35, tmp71}) + tmp73 := lang.Apply(tmp9, []any{tmp72}) + return tmp73 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // with-bindings { - v0 := lang.NewSymbol("with-bindings").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("binding-map"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Takes a map of Var/value pairs. Installs for the given Vars the associated\n values as thread-local bindings. Then executes body. Pops the installed\n bindings after body was evaluated. Returns the value of body.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1984), lang.NewKeyword("end-line"), int(1984))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("with-bindings").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("binding-map"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Takes a map of Var/value pairs. Installs for the given Vars the associated\n values as thread-local bindings. Then executes body. Pops the installed\n bindings after body was evaluated. Returns the value of body.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1984), lang.NewKeyword("end-line"), int(1984))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 3 { @@ -84167,111 +84364,112 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("seq")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("concat")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("list")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/with-bindings*")}) - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("list")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.Apply(v19, []any{v5}) - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("list")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("seq")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("concat")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("list")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) - } - v32 := v31.Get() - v33 := lang.Apply(v32, []any{lang.NewSymbol("glojure.core/fn")}) - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("list")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) - } - v36 := v35.Get() - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("apply")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("vector")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) - } - v42 := v41.Get() - v43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v44 := v43.FindInternedVar(lang.NewSymbol("seq")) - if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) - } - v45 := v44.Get() - v46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v47 := v46.FindInternedVar(lang.NewSymbol("concat")) - if v47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v47))) - } - v48 := v47.Get() - v49 := lang.Apply(v48, nil) - v50 := lang.Apply(v45, []any{v49}) - v51 := lang.Apply(v39, []any{v42, v50}) - v52 := lang.Apply(v36, []any{v51}) - v53 := lang.Apply(v29, []any{v33, v52, v6}) - v54 := lang.Apply(v26, []any{v53}) - v55 := lang.Apply(v23, []any{v54}) - v56 := lang.Apply(v12, []any{v16, v20, v55}) - v57 := lang.Apply(v9, []any{v56}) - return v57 - } - }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("seq")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("concat")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("list")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("glojure.core/with-bindings*")}) + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("list")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.Apply(tmp19, []any{v5}) + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("list")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("seq")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("concat")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("list")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) + } + tmp32 := tmp31.Get() + tmp33 := lang.Apply(tmp32, []any{lang.NewSymbol("glojure.core/fn")}) + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("list")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("apply")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("vector")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) + } + tmp42 := tmp41.Get() + tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp44 := tmp43.FindInternedVar(lang.NewSymbol("seq")) + if tmp44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) + } + tmp45 := tmp44.Get() + tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp47 := tmp46.FindInternedVar(lang.NewSymbol("concat")) + if tmp47.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) + } + tmp48 := tmp47.Get() + tmp49 := lang.Apply(tmp48, nil) + tmp50 := lang.Apply(tmp45, []any{tmp49}) + tmp51 := lang.Apply(tmp39, []any{tmp42, tmp50}) + tmp52 := lang.Apply(tmp36, []any{tmp51}) + tmp53 := lang.Apply(tmp29, []any{tmp33, tmp52, v6}) + tmp54 := lang.Apply(tmp26, []any{tmp53}) + tmp55 := lang.Apply(tmp23, []any{tmp54}) + tmp56 := lang.Apply(tmp12, []any{tmp16, tmp20, tmp55}) + tmp57 := lang.Apply(tmp9, []any{tmp56}) + return tmp57 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // with-bindings* { - v0 := lang.NewSymbol("with-bindings*").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("binding-map"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Takes a map of Var/value pairs. Installs for the given Vars the associated\n values as thread-local bindings. Then calls f with the supplied arguments.\n Pops the installed bindings after f returned. Returns whatever f returns.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1971), lang.NewKeyword("end-line"), int(1971))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("with-bindings*").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("binding-map"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Takes a map of Var/value pairs. Installs for the given Vars the associated\n values as thread-local bindings. Then calls f with the supplied arguments.\n Pops the installed bindings after f returned. Returns whatever f returns.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1971), lang.NewKeyword("end-line"), int(1971))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 2 { @@ -84281,49 +84479,51 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.NewList(args[2:]...) - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("push-thread-bindings")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{v3}) - _ = v9 - var v10 any + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("push-thread-bindings")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.Apply(tmp8, []any{v3}) + _ = tmp9 + var tmp10 any func() { defer func() { - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) - } - v13 := v12.Get() - v14 := lang.Apply(v13, nil) + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, nil) + _ = tmp14 }() - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("apply")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{v4, v5}) - v10 = v18 + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("apply")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{v4, v5}) + tmp10 = tmp18 }() - return v10 + return tmp10 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // with-in-str { - v0 := lang.NewSymbol("with-in-str").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Evaluates body in a context in which *in* is bound to a fresh\n StringReader initialized with the string s.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4749), lang.NewKeyword("end-line"), int(4749))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("with-in-str").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Evaluates body in a context in which *in* is bound to a fresh\n StringReader initialized with the string s.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4749), lang.NewKeyword("end-line"), int(4749))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 3 { @@ -84335,229 +84535,230 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("seq")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("concat")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("list")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/with-open")}) - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("list")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("apply")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("vector")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("seq")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) - } - v28 := v27.Get() - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("concat")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("list")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.Apply(v34, []any{lang.NewSymbol("s__0__auto__")}) - v36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v37 := v36.FindInternedVar(lang.NewSymbol("list")) - if v37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v37))) - } - v38 := v37.Get() - v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v40 := v39.FindInternedVar(lang.NewSymbol("seq")) - if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) - } - v41 := v40.Get() - v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v43 := v42.FindInternedVar(lang.NewSymbol("concat")) - if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) - } - v44 := v43.Get() - v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v46 := v45.FindInternedVar(lang.NewSymbol("list")) - if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) - } - v47 := v46.Get() - v48 := lang.Apply(v47, []any{lang.NewSymbol("glojure.core/->")}) - v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v50 := v49.FindInternedVar(lang.NewSymbol("list")) - if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) - } - v51 := v50.Get() - v52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v53 := v52.FindInternedVar(lang.NewSymbol("seq")) - if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) - } - v54 := v53.Get() - v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v56 := v55.FindInternedVar(lang.NewSymbol("concat")) - if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) - } - v57 := v56.Get() - v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v59 := v58.FindInternedVar(lang.NewSymbol("list")) - if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) - } - v60 := v59.Get() - v61 := lang.Apply(v60, []any{lang.NewSymbol("java.io.StringReader.")}) - v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v63 := v62.FindInternedVar(lang.NewSymbol("list")) - if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) - } - v64 := v63.Get() - v65 := lang.Apply(v64, []any{v5}) - v66 := lang.Apply(v57, []any{v61, v65}) - v67 := lang.Apply(v54, []any{v66}) - v68 := lang.Apply(v51, []any{v67}) - v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v70 := v69.FindInternedVar(lang.NewSymbol("list")) - if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) - } - v71 := v70.Get() - v72 := lang.Apply(v71, []any{lang.NewSymbol("glojure.lang.LineNumberingPushbackReader.")}) - v73 := lang.Apply(v44, []any{v48, v68, v72}) - v74 := lang.Apply(v41, []any{v73}) - v75 := lang.Apply(v38, []any{v74}) - v76 := lang.Apply(v31, []any{v35, v75}) - v77 := lang.Apply(v28, []any{v76}) - v78 := lang.Apply(v22, []any{v25, v77}) - v79 := lang.Apply(v19, []any{v78}) - v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v81 := v80.FindInternedVar(lang.NewSymbol("list")) - if v81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) - } - v82 := v81.Get() - v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v84 := v83.FindInternedVar(lang.NewSymbol("seq")) - if v84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) - } - v85 := v84.Get() - v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v87 := v86.FindInternedVar(lang.NewSymbol("concat")) - if v87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) - } - v88 := v87.Get() - v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v90 := v89.FindInternedVar(lang.NewSymbol("list")) - if v90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) - } - v91 := v90.Get() - v92 := lang.Apply(v91, []any{lang.NewSymbol("glojure.core/binding")}) - v93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v94 := v93.FindInternedVar(lang.NewSymbol("list")) - if v94.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v94))) - } - v95 := v94.Get() - v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v97 := v96.FindInternedVar(lang.NewSymbol("apply")) - if v97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) - } - v98 := v97.Get() - v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v100 := v99.FindInternedVar(lang.NewSymbol("vector")) - if v100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) - } - v101 := v100.Get() - v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v103 := v102.FindInternedVar(lang.NewSymbol("seq")) - if v103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) - } - v104 := v103.Get() - v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v106 := v105.FindInternedVar(lang.NewSymbol("concat")) - if v106.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) - } - v107 := v106.Get() - v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v109 := v108.FindInternedVar(lang.NewSymbol("list")) - if v109.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) - } - v110 := v109.Get() - v111 := lang.Apply(v110, []any{lang.NewSymbol("glojure.core/*in*")}) - v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v113 := v112.FindInternedVar(lang.NewSymbol("list")) - if v113.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) - } - v114 := v113.Get() - v115 := lang.Apply(v114, []any{lang.NewSymbol("s__0__auto__")}) - v116 := lang.Apply(v107, []any{v111, v115}) - v117 := lang.Apply(v104, []any{v116}) - v118 := lang.Apply(v98, []any{v101, v117}) - v119 := lang.Apply(v95, []any{v118}) - v120 := lang.Apply(v88, []any{v92, v119, v6}) - v121 := lang.Apply(v85, []any{v120}) - v122 := lang.Apply(v82, []any{v121}) - v123 := lang.Apply(v12, []any{v16, v79, v122}) - v124 := lang.Apply(v9, []any{v123}) - return v124 - } - }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("seq")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("concat")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("list")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("glojure.core/with-open")}) + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("list")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("apply")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("vector")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("seq")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) + } + tmp28 := tmp27.Get() + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("concat")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.Apply(tmp34, []any{lang.NewSymbol("s__0__auto__")}) + tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) + if tmp37.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) + } + tmp38 := tmp37.Get() + tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp40 := tmp39.FindInternedVar(lang.NewSymbol("seq")) + if tmp40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) + } + tmp41 := tmp40.Get() + tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp43 := tmp42.FindInternedVar(lang.NewSymbol("concat")) + if tmp43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) + } + tmp44 := tmp43.Get() + tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp46 := tmp45.FindInternedVar(lang.NewSymbol("list")) + if tmp46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) + } + tmp47 := tmp46.Get() + tmp48 := lang.Apply(tmp47, []any{lang.NewSymbol("glojure.core/->")}) + tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp50 := tmp49.FindInternedVar(lang.NewSymbol("list")) + if tmp50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) + } + tmp51 := tmp50.Get() + tmp52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp53 := tmp52.FindInternedVar(lang.NewSymbol("seq")) + if tmp53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp53))) + } + tmp54 := tmp53.Get() + tmp55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp56 := tmp55.FindInternedVar(lang.NewSymbol("concat")) + if tmp56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp56))) + } + tmp57 := tmp56.Get() + tmp58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp59 := tmp58.FindInternedVar(lang.NewSymbol("list")) + if tmp59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp59))) + } + tmp60 := tmp59.Get() + tmp61 := lang.Apply(tmp60, []any{lang.NewSymbol("java.io.StringReader.")}) + tmp62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp63 := tmp62.FindInternedVar(lang.NewSymbol("list")) + if tmp63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp63))) + } + tmp64 := tmp63.Get() + tmp65 := lang.Apply(tmp64, []any{v5}) + tmp66 := lang.Apply(tmp57, []any{tmp61, tmp65}) + tmp67 := lang.Apply(tmp54, []any{tmp66}) + tmp68 := lang.Apply(tmp51, []any{tmp67}) + tmp69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp70 := tmp69.FindInternedVar(lang.NewSymbol("list")) + if tmp70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp70))) + } + tmp71 := tmp70.Get() + tmp72 := lang.Apply(tmp71, []any{lang.NewSymbol("glojure.lang.LineNumberingPushbackReader.")}) + tmp73 := lang.Apply(tmp44, []any{tmp48, tmp68, tmp72}) + tmp74 := lang.Apply(tmp41, []any{tmp73}) + tmp75 := lang.Apply(tmp38, []any{tmp74}) + tmp76 := lang.Apply(tmp31, []any{tmp35, tmp75}) + tmp77 := lang.Apply(tmp28, []any{tmp76}) + tmp78 := lang.Apply(tmp22, []any{tmp25, tmp77}) + tmp79 := lang.Apply(tmp19, []any{tmp78}) + tmp80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp81 := tmp80.FindInternedVar(lang.NewSymbol("list")) + if tmp81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp81))) + } + tmp82 := tmp81.Get() + tmp83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp84 := tmp83.FindInternedVar(lang.NewSymbol("seq")) + if tmp84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp84))) + } + tmp85 := tmp84.Get() + tmp86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp87 := tmp86.FindInternedVar(lang.NewSymbol("concat")) + if tmp87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp87))) + } + tmp88 := tmp87.Get() + tmp89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp90 := tmp89.FindInternedVar(lang.NewSymbol("list")) + if tmp90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp90))) + } + tmp91 := tmp90.Get() + tmp92 := lang.Apply(tmp91, []any{lang.NewSymbol("glojure.core/binding")}) + tmp93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp94 := tmp93.FindInternedVar(lang.NewSymbol("list")) + if tmp94.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp94))) + } + tmp95 := tmp94.Get() + tmp96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp97 := tmp96.FindInternedVar(lang.NewSymbol("apply")) + if tmp97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp97))) + } + tmp98 := tmp97.Get() + tmp99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp100 := tmp99.FindInternedVar(lang.NewSymbol("vector")) + if tmp100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp100))) + } + tmp101 := tmp100.Get() + tmp102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp103 := tmp102.FindInternedVar(lang.NewSymbol("seq")) + if tmp103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp103))) + } + tmp104 := tmp103.Get() + tmp105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp106 := tmp105.FindInternedVar(lang.NewSymbol("concat")) + if tmp106.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp106))) + } + tmp107 := tmp106.Get() + tmp108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp109 := tmp108.FindInternedVar(lang.NewSymbol("list")) + if tmp109.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp109))) + } + tmp110 := tmp109.Get() + tmp111 := lang.Apply(tmp110, []any{lang.NewSymbol("glojure.core/*in*")}) + tmp112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp113 := tmp112.FindInternedVar(lang.NewSymbol("list")) + if tmp113.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp113))) + } + tmp114 := tmp113.Get() + tmp115 := lang.Apply(tmp114, []any{lang.NewSymbol("s__0__auto__")}) + tmp116 := lang.Apply(tmp107, []any{tmp111, tmp115}) + tmp117 := lang.Apply(tmp104, []any{tmp116}) + tmp118 := lang.Apply(tmp98, []any{tmp101, tmp117}) + tmp119 := lang.Apply(tmp95, []any{tmp118}) + tmp120 := lang.Apply(tmp88, []any{tmp92, tmp119, v6}) + tmp121 := lang.Apply(tmp85, []any{tmp120}) + tmp122 := lang.Apply(tmp82, []any{tmp121}) + tmp123 := lang.Apply(tmp12, []any{tmp16, tmp79, tmp122}) + tmp124 := lang.Apply(tmp9, []any{tmp123}) + return tmp124 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // with-loading-context { - v0 := lang.NewSymbol("with-loading-context").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5734), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5734), lang.NewKeyword("end-column"), int(30), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("macro"), true)).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("with-loading-context").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5734), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5734), lang.NewKeyword("end-column"), int(30), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("macro"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 2 { @@ -84567,250 +84768,251 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.NewList(args[2:]...) - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("seq")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("concat")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("list")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("seq")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("concat")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("list")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.Apply(v23, []any{lang.NewSymbol("glojure.core/fn")}) - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("list")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.Apply(v27, []any{lang.NewSymbol("loading__0__auto__")}) - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("list")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v33 := v32.FindInternedVar(lang.NewSymbol("apply")) - if v33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v33))) - } - v34 := v33.Get() - v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v36 := v35.FindInternedVar(lang.NewSymbol("vector")) - if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) - } - v37 := v36.Get() - v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v39 := v38.FindInternedVar(lang.NewSymbol("seq")) - if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) - } - v40 := v39.Get() - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("concat")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) - } - v43 := v42.Get() - v44 := lang.Apply(v43, nil) - v45 := lang.Apply(v40, []any{v44}) - v46 := lang.Apply(v34, []any{v37, v45}) - v47 := lang.Apply(v31, []any{v46}) - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("list")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v52 := v51.FindInternedVar(lang.NewSymbol("seq")) - if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) - } - v53 := v52.Get() - v54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v55 := v54.FindInternedVar(lang.NewSymbol("concat")) - if v55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v55))) - } - v56 := v55.Get() - v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v58 := v57.FindInternedVar(lang.NewSymbol("list")) - if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) - } - v59 := v58.Get() - v60 := lang.Apply(v59, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.PushThreadBindings")}) - v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v62 := v61.FindInternedVar(lang.NewSymbol("list")) - if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) - } - v63 := v62.Get() - v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v65 := v64.FindInternedVar(lang.NewSymbol("apply")) - if v65.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) - } - v66 := v65.Get() - v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v68 := v67.FindInternedVar(lang.NewSymbol("hash-map")) - if v68.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) - } - v69 := v68.Get() - v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v71 := v70.FindInternedVar(lang.NewSymbol("seq")) - if v71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) - } - v72 := v71.Get() - v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v74 := v73.FindInternedVar(lang.NewSymbol("concat")) - if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) - } - v75 := v74.Get() - v76 := lang.Apply(v75, nil) - v77 := lang.Apply(v72, []any{v76}) - v78 := lang.Apply(v66, []any{v69, v77}) - v79 := lang.Apply(v63, []any{v78}) - v80 := lang.Apply(v56, []any{v60, v79}) - v81 := lang.Apply(v53, []any{v80}) - v82 := lang.Apply(v50, []any{v81}) - v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v84 := v83.FindInternedVar(lang.NewSymbol("list")) - if v84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) - } - v85 := v84.Get() - v86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v87 := v86.FindInternedVar(lang.NewSymbol("seq")) - if v87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v87))) - } - v88 := v87.Get() - v89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v90 := v89.FindInternedVar(lang.NewSymbol("concat")) - if v90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v90))) - } - v91 := v90.Get() - v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v93 := v92.FindInternedVar(lang.NewSymbol("list")) - if v93.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) - } - v94 := v93.Get() - v95 := lang.Apply(v94, []any{lang.NewSymbol("try")}) - v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v97 := v96.FindInternedVar(lang.NewSymbol("list")) - if v97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) - } - v98 := v97.Get() - v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v100 := v99.FindInternedVar(lang.NewSymbol("seq")) - if v100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) - } - v101 := v100.Get() - v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v103 := v102.FindInternedVar(lang.NewSymbol("concat")) - if v103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) - } - v104 := v103.Get() - v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v106 := v105.FindInternedVar(lang.NewSymbol("list")) - if v106.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) - } - v107 := v106.Get() - v108 := lang.Apply(v107, []any{lang.NewSymbol("finally")}) - v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v110 := v109.FindInternedVar(lang.NewSymbol("list")) - if v110.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) - } - v111 := v110.Get() - v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v113 := v112.FindInternedVar(lang.NewSymbol("seq")) - if v113.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) - } - v114 := v113.Get() - v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v116 := v115.FindInternedVar(lang.NewSymbol("concat")) - if v116.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) - } - v117 := v116.Get() - v118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v119 := v118.FindInternedVar(lang.NewSymbol("list")) - if v119.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v119))) - } - v120 := v119.Get() - v121 := lang.Apply(v120, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.PopThreadBindings")}) - v122 := lang.Apply(v117, []any{v121}) - v123 := lang.Apply(v114, []any{v122}) - v124 := lang.Apply(v111, []any{v123}) - v125 := lang.Apply(v104, []any{v108, v124}) - v126 := lang.Apply(v101, []any{v125}) - v127 := lang.Apply(v98, []any{v126}) - v128 := lang.Apply(v91, []any{v95, v5, v127}) - v129 := lang.Apply(v88, []any{v128}) - v130 := lang.Apply(v85, []any{v129}) - v131 := lang.Apply(v20, []any{v24, v28, v47, v82, v130}) - v132 := lang.Apply(v17, []any{v131}) - v133 := lang.Apply(v14, []any{v132}) - v134 := lang.Apply(v11, []any{v133}) - v135 := lang.Apply(v8, []any{v134}) - return v135 - } - }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("seq")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("concat")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("list")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("seq")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("concat")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("list")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.Apply(tmp23, []any{lang.NewSymbol("glojure.core/fn")}) + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("list")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.Apply(tmp27, []any{lang.NewSymbol("loading__0__auto__")}) + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("list")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp33 := tmp32.FindInternedVar(lang.NewSymbol("apply")) + if tmp33.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) + } + tmp34 := tmp33.Get() + tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp36 := tmp35.FindInternedVar(lang.NewSymbol("vector")) + if tmp36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) + } + tmp37 := tmp36.Get() + tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp39 := tmp38.FindInternedVar(lang.NewSymbol("seq")) + if tmp39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) + } + tmp40 := tmp39.Get() + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("concat")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := lang.Apply(tmp43, nil) + tmp45 := lang.Apply(tmp40, []any{tmp44}) + tmp46 := lang.Apply(tmp34, []any{tmp37, tmp45}) + tmp47 := lang.Apply(tmp31, []any{tmp46}) + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp52 := tmp51.FindInternedVar(lang.NewSymbol("seq")) + if tmp52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp52))) + } + tmp53 := tmp52.Get() + tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp55 := tmp54.FindInternedVar(lang.NewSymbol("concat")) + if tmp55.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) + } + tmp56 := tmp55.Get() + tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp58 := tmp57.FindInternedVar(lang.NewSymbol("list")) + if tmp58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) + } + tmp59 := tmp58.Get() + tmp60 := lang.Apply(tmp59, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.PushThreadBindings")}) + tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp62 := tmp61.FindInternedVar(lang.NewSymbol("list")) + if tmp62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) + } + tmp63 := tmp62.Get() + tmp64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp65 := tmp64.FindInternedVar(lang.NewSymbol("apply")) + if tmp65.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp65))) + } + tmp66 := tmp65.Get() + tmp67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp68 := tmp67.FindInternedVar(lang.NewSymbol("hash-map")) + if tmp68.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp68))) + } + tmp69 := tmp68.Get() + tmp70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp71 := tmp70.FindInternedVar(lang.NewSymbol("seq")) + if tmp71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp71))) + } + tmp72 := tmp71.Get() + tmp73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp74 := tmp73.FindInternedVar(lang.NewSymbol("concat")) + if tmp74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp74))) + } + tmp75 := tmp74.Get() + tmp76 := lang.Apply(tmp75, nil) + tmp77 := lang.Apply(tmp72, []any{tmp76}) + tmp78 := lang.Apply(tmp66, []any{tmp69, tmp77}) + tmp79 := lang.Apply(tmp63, []any{tmp78}) + tmp80 := lang.Apply(tmp56, []any{tmp60, tmp79}) + tmp81 := lang.Apply(tmp53, []any{tmp80}) + tmp82 := lang.Apply(tmp50, []any{tmp81}) + tmp83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp84 := tmp83.FindInternedVar(lang.NewSymbol("list")) + if tmp84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp84))) + } + tmp85 := tmp84.Get() + tmp86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp87 := tmp86.FindInternedVar(lang.NewSymbol("seq")) + if tmp87.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp87))) + } + tmp88 := tmp87.Get() + tmp89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp90 := tmp89.FindInternedVar(lang.NewSymbol("concat")) + if tmp90.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp90))) + } + tmp91 := tmp90.Get() + tmp92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp93 := tmp92.FindInternedVar(lang.NewSymbol("list")) + if tmp93.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp93))) + } + tmp94 := tmp93.Get() + tmp95 := lang.Apply(tmp94, []any{lang.NewSymbol("try")}) + tmp96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp97 := tmp96.FindInternedVar(lang.NewSymbol("list")) + if tmp97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp97))) + } + tmp98 := tmp97.Get() + tmp99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp100 := tmp99.FindInternedVar(lang.NewSymbol("seq")) + if tmp100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp100))) + } + tmp101 := tmp100.Get() + tmp102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp103 := tmp102.FindInternedVar(lang.NewSymbol("concat")) + if tmp103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp103))) + } + tmp104 := tmp103.Get() + tmp105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp106 := tmp105.FindInternedVar(lang.NewSymbol("list")) + if tmp106.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp106))) + } + tmp107 := tmp106.Get() + tmp108 := lang.Apply(tmp107, []any{lang.NewSymbol("finally")}) + tmp109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp110 := tmp109.FindInternedVar(lang.NewSymbol("list")) + if tmp110.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp110))) + } + tmp111 := tmp110.Get() + tmp112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp113 := tmp112.FindInternedVar(lang.NewSymbol("seq")) + if tmp113.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp113))) + } + tmp114 := tmp113.Get() + tmp115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp116 := tmp115.FindInternedVar(lang.NewSymbol("concat")) + if tmp116.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp116))) + } + tmp117 := tmp116.Get() + tmp118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp119 := tmp118.FindInternedVar(lang.NewSymbol("list")) + if tmp119.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp119))) + } + tmp120 := tmp119.Get() + tmp121 := lang.Apply(tmp120, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.PopThreadBindings")}) + tmp122 := lang.Apply(tmp117, []any{tmp121}) + tmp123 := lang.Apply(tmp114, []any{tmp122}) + tmp124 := lang.Apply(tmp111, []any{tmp123}) + tmp125 := lang.Apply(tmp104, []any{tmp108, tmp124}) + tmp126 := lang.Apply(tmp101, []any{tmp125}) + tmp127 := lang.Apply(tmp98, []any{tmp126}) + tmp128 := lang.Apply(tmp91, []any{tmp95, v5, tmp127}) + tmp129 := lang.Apply(tmp88, []any{tmp128}) + tmp130 := lang.Apply(tmp85, []any{tmp129}) + tmp131 := lang.Apply(tmp20, []any{tmp24, tmp28, tmp47, tmp82, tmp130}) + tmp132 := lang.Apply(tmp17, []any{tmp131}) + tmp133 := lang.Apply(tmp14, []any{tmp132}) + tmp134 := lang.Apply(tmp11, []any{tmp133}) + tmp135 := lang.Apply(tmp8, []any{tmp134}) + return tmp135 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // with-local-vars { - v0 := lang.NewSymbol("with-local-vars").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name-vals-vec"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "varbinding=> symbol init-expr\n\n Executes the exprs in a context in which the symbols are bound to\n vars with per-thread bindings to the init-exprs. The symbols refer\n to the var objects themselves, and must be accessed with var-get and\n var-set", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4339), lang.NewKeyword("end-line"), int(4339))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("with-local-vars").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name-vals-vec"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "varbinding=> symbol init-expr\n\n Executes the exprs in a context in which the symbols are bound to\n vars with per-thread bindings to the init-exprs. The symbols refer\n to the var objects themselves, and must be accessed with var-get and\n var-set", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4339), lang.NewKeyword("end-line"), int(4339))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 3 { @@ -84822,338 +85024,337 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - var v7 any - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v5}) - if lang.IsTruthy(v11) { - v7 = nil + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("vector?")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v5}) + if lang.IsTruthy(tmp11) { } else { - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("str")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("first")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{v3}) - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("meta")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v3}) - v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) - v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) - v28 := lang.Apply(lang.NewIllegalArgumentError, []any{v27}) - panic(v28) - } - _ = v7 - var v29 any - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("even?")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) - } - v32 := v31.Get() - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("count")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - v36 := lang.Apply(v35, []any{v5}) - v37 := lang.Apply(v32, []any{v36}) - if lang.IsTruthy(v37) { - v29 = nil + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("str")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("first")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("*ns*")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("meta")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.Apply(tmp24, []any{v3}) + tmp26 := lang.Apply(lang.NewKeyword("line"), []any{tmp25}) + tmp27 := lang.Apply(tmp14, []any{tmp18, " requires ", "a vector for its binding", " in ", tmp21, ":", tmp26}) + tmp28 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp27}) + panic(tmp28) + } + _ = tmp7 + var tmp29 any + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("even?")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) + } + tmp32 := tmp31.Get() + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("count")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) + } + tmp35 := tmp34.Get() + tmp36 := lang.Apply(tmp35, []any{v5}) + tmp37 := lang.Apply(tmp32, []any{tmp36}) + if lang.IsTruthy(tmp37) { } else { - v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v39 := v38.FindInternedVar(lang.NewSymbol("str")) - if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) - } - v40 := v39.Get() - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("first")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) - } - v43 := v42.Get() - v44 := lang.Apply(v43, []any{v3}) - v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) - if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) - } - v47 := v46.Get() - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("meta")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v3}) - v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) - v53 := lang.Apply(v40, []any{v44, " requires ", "an even number of forms in binding vector", " in ", v47, ":", v52}) - v54 := lang.Apply(lang.NewIllegalArgumentError, []any{v53}) - panic(v54) - } - _ = v29 - _ = nil - v55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v56 := v55.FindInternedVar(lang.NewSymbol("seq")) - if v56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v56))) - } - v57 := v56.Get() - v58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v59 := v58.FindInternedVar(lang.NewSymbol("concat")) - if v59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v59))) - } - v60 := v59.Get() - v61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v62 := v61.FindInternedVar(lang.NewSymbol("list")) - if v62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v62))) - } - v63 := v62.Get() - v64 := lang.Apply(v63, []any{lang.NewSymbol("glojure.core/let")}) - v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v66 := v65.FindInternedVar(lang.NewSymbol("list")) - if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) - } - v67 := v66.Get() - v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v69 := v68.FindInternedVar(lang.NewSymbol("apply")) - if v69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) - } - v70 := v69.Get() - v71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v72 := v71.FindInternedVar(lang.NewSymbol("vector")) - if v72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v72))) - } - v73 := v72.Get() - v74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v75 := v74.FindInternedVar(lang.NewSymbol("seq")) - if v75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v75))) - } - v76 := v75.Get() - v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v78 := v77.FindInternedVar(lang.NewSymbol("concat")) - if v78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) - } - v79 := v78.Get() - v80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v81 := v80.FindInternedVar(lang.NewSymbol("interleave")) - if v81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v81))) - } - v82 := v81.Get() - v83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v84 := v83.FindInternedVar(lang.NewSymbol("take-nth")) - if v84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v84))) - } - v85 := v84.Get() - v86 := lang.Apply(v85, []any{int64(2), v5}) - v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v88 := v87.FindInternedVar(lang.NewSymbol("repeat")) - if v88.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) - } - v89 := v88.Get() - v90 := lang.Apply(v89, []any{lang.NewList(lang.NewSymbol(".."), lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.*Var"), lang.NewSymbol("create"), lang.NewSymbol("setDynamic"))}) - v91 := lang.Apply(v82, []any{v86, v90}) - v92 := lang.Apply(v79, []any{v91}) - v93 := lang.Apply(v76, []any{v92}) - v94 := lang.Apply(v70, []any{v73, v93}) - v95 := lang.Apply(v67, []any{v94}) - v96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v97 := v96.FindInternedVar(lang.NewSymbol("list")) - if v97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v97))) - } - v98 := v97.Get() - v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v100 := v99.FindInternedVar(lang.NewSymbol("seq")) - if v100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) - } - v101 := v100.Get() - v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v103 := v102.FindInternedVar(lang.NewSymbol("concat")) - if v103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) - } - v104 := v103.Get() - v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v106 := v105.FindInternedVar(lang.NewSymbol("list")) - if v106.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) - } - v107 := v106.Get() - v108 := lang.Apply(v107, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.PushThreadBindings")}) - v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v110 := v109.FindInternedVar(lang.NewSymbol("list")) - if v110.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) - } - v111 := v110.Get() - v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v113 := v112.FindInternedVar(lang.NewSymbol("apply")) - if v113.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) - } - v114 := v113.Get() - v115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v116 := v115.FindInternedVar(lang.NewSymbol("hash-map")) - if v116.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v116))) - } - v117 := v116.Get() - v118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v119 := v118.FindInternedVar(lang.NewSymbol("seq")) - if v119.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v119))) - } - v120 := v119.Get() - v121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v122 := v121.FindInternedVar(lang.NewSymbol("concat")) - if v122.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v122))) - } - v123 := v122.Get() - v124 := lang.Apply(v123, nil) - v125 := lang.Apply(v120, []any{v124}) - v126 := lang.Apply(v114, []any{v117, v125}) - v127 := lang.Apply(v111, []any{v126}) - v128 := lang.Apply(v104, []any{v108, v127}) - v129 := lang.Apply(v101, []any{v128}) - v130 := lang.Apply(v98, []any{v129}) - v131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v132 := v131.FindInternedVar(lang.NewSymbol("list")) - if v132.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v132))) - } - v133 := v132.Get() - v134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v135 := v134.FindInternedVar(lang.NewSymbol("seq")) - if v135.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v135))) - } - v136 := v135.Get() - v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v138 := v137.FindInternedVar(lang.NewSymbol("concat")) - if v138.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) - } - v139 := v138.Get() - v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v141 := v140.FindInternedVar(lang.NewSymbol("list")) - if v141.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) - } - v142 := v141.Get() - v143 := lang.Apply(v142, []any{lang.NewSymbol("try")}) - v144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v145 := v144.FindInternedVar(lang.NewSymbol("list")) - if v145.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v145))) - } - v146 := v145.Get() - v147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v148 := v147.FindInternedVar(lang.NewSymbol("seq")) - if v148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v148))) - } - v149 := v148.Get() - v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v151 := v150.FindInternedVar(lang.NewSymbol("concat")) - if v151.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) - } - v152 := v151.Get() - v153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v154 := v153.FindInternedVar(lang.NewSymbol("list")) - if v154.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v154))) - } - v155 := v154.Get() - v156 := lang.Apply(v155, []any{lang.NewSymbol("finally")}) - v157 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v158 := v157.FindInternedVar(lang.NewSymbol("list")) - if v158.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v158))) - } - v159 := v158.Get() - v160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v161 := v160.FindInternedVar(lang.NewSymbol("seq")) - if v161.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v161))) - } - v162 := v161.Get() - v163 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v164 := v163.FindInternedVar(lang.NewSymbol("concat")) - if v164.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v164))) - } - v165 := v164.Get() - v166 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v167 := v166.FindInternedVar(lang.NewSymbol("list")) - if v167.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v167))) - } - v168 := v167.Get() - v169 := lang.Apply(v168, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.PopThreadBindings")}) - v170 := lang.Apply(v165, []any{v169}) - v171 := lang.Apply(v162, []any{v170}) - v172 := lang.Apply(v159, []any{v171}) - v173 := lang.Apply(v152, []any{v156, v172}) - v174 := lang.Apply(v149, []any{v173}) - v175 := lang.Apply(v146, []any{v174}) - v176 := lang.Apply(v139, []any{v143, v6, v175}) - v177 := lang.Apply(v136, []any{v176}) - v178 := lang.Apply(v133, []any{v177}) - v179 := lang.Apply(v60, []any{v64, v95, v130, v178}) - v180 := lang.Apply(v57, []any{v179}) - return v180 - } - }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp39 := tmp38.FindInternedVar(lang.NewSymbol("str")) + if tmp39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) + } + tmp40 := tmp39.Get() + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("first")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := lang.Apply(tmp43, []any{v3}) + tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp46 := tmp45.FindInternedVar(lang.NewSymbol("*ns*")) + if tmp46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) + } + tmp47 := tmp46.Get() + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("meta")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v3}) + tmp52 := lang.Apply(lang.NewKeyword("line"), []any{tmp51}) + tmp53 := lang.Apply(tmp40, []any{tmp44, " requires ", "an even number of forms in binding vector", " in ", tmp47, ":", tmp52}) + tmp54 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp53}) + panic(tmp54) + } + _ = tmp29 + tmp55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp56 := tmp55.FindInternedVar(lang.NewSymbol("seq")) + if tmp56.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp56))) + } + tmp57 := tmp56.Get() + tmp58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp59 := tmp58.FindInternedVar(lang.NewSymbol("concat")) + if tmp59.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp59))) + } + tmp60 := tmp59.Get() + tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp62 := tmp61.FindInternedVar(lang.NewSymbol("list")) + if tmp62.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) + } + tmp63 := tmp62.Get() + tmp64 := lang.Apply(tmp63, []any{lang.NewSymbol("glojure.core/let")}) + tmp65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp66 := tmp65.FindInternedVar(lang.NewSymbol("list")) + if tmp66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp66))) + } + tmp67 := tmp66.Get() + tmp68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp69 := tmp68.FindInternedVar(lang.NewSymbol("apply")) + if tmp69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp69))) + } + tmp70 := tmp69.Get() + tmp71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp72 := tmp71.FindInternedVar(lang.NewSymbol("vector")) + if tmp72.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp72))) + } + tmp73 := tmp72.Get() + tmp74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp75 := tmp74.FindInternedVar(lang.NewSymbol("seq")) + if tmp75.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp75))) + } + tmp76 := tmp75.Get() + tmp77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp78 := tmp77.FindInternedVar(lang.NewSymbol("concat")) + if tmp78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp78))) + } + tmp79 := tmp78.Get() + tmp80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp81 := tmp80.FindInternedVar(lang.NewSymbol("interleave")) + if tmp81.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp81))) + } + tmp82 := tmp81.Get() + tmp83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp84 := tmp83.FindInternedVar(lang.NewSymbol("take-nth")) + if tmp84.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp84))) + } + tmp85 := tmp84.Get() + tmp86 := lang.Apply(tmp85, []any{int64(2), v5}) + tmp87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp88 := tmp87.FindInternedVar(lang.NewSymbol("repeat")) + if tmp88.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp88))) + } + tmp89 := tmp88.Get() + tmp90 := lang.Apply(tmp89, []any{lang.NewList(lang.NewSymbol(".."), lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.*Var"), lang.NewSymbol("create"), lang.NewSymbol("setDynamic"))}) + tmp91 := lang.Apply(tmp82, []any{tmp86, tmp90}) + tmp92 := lang.Apply(tmp79, []any{tmp91}) + tmp93 := lang.Apply(tmp76, []any{tmp92}) + tmp94 := lang.Apply(tmp70, []any{tmp73, tmp93}) + tmp95 := lang.Apply(tmp67, []any{tmp94}) + tmp96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp97 := tmp96.FindInternedVar(lang.NewSymbol("list")) + if tmp97.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp97))) + } + tmp98 := tmp97.Get() + tmp99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp100 := tmp99.FindInternedVar(lang.NewSymbol("seq")) + if tmp100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp100))) + } + tmp101 := tmp100.Get() + tmp102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp103 := tmp102.FindInternedVar(lang.NewSymbol("concat")) + if tmp103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp103))) + } + tmp104 := tmp103.Get() + tmp105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp106 := tmp105.FindInternedVar(lang.NewSymbol("list")) + if tmp106.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp106))) + } + tmp107 := tmp106.Get() + tmp108 := lang.Apply(tmp107, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.PushThreadBindings")}) + tmp109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp110 := tmp109.FindInternedVar(lang.NewSymbol("list")) + if tmp110.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp110))) + } + tmp111 := tmp110.Get() + tmp112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp113 := tmp112.FindInternedVar(lang.NewSymbol("apply")) + if tmp113.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp113))) + } + tmp114 := tmp113.Get() + tmp115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp116 := tmp115.FindInternedVar(lang.NewSymbol("hash-map")) + if tmp116.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp116))) + } + tmp117 := tmp116.Get() + tmp118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp119 := tmp118.FindInternedVar(lang.NewSymbol("seq")) + if tmp119.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp119))) + } + tmp120 := tmp119.Get() + tmp121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp122 := tmp121.FindInternedVar(lang.NewSymbol("concat")) + if tmp122.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp122))) + } + tmp123 := tmp122.Get() + tmp124 := lang.Apply(tmp123, nil) + tmp125 := lang.Apply(tmp120, []any{tmp124}) + tmp126 := lang.Apply(tmp114, []any{tmp117, tmp125}) + tmp127 := lang.Apply(tmp111, []any{tmp126}) + tmp128 := lang.Apply(tmp104, []any{tmp108, tmp127}) + tmp129 := lang.Apply(tmp101, []any{tmp128}) + tmp130 := lang.Apply(tmp98, []any{tmp129}) + tmp131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp132 := tmp131.FindInternedVar(lang.NewSymbol("list")) + if tmp132.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp132))) + } + tmp133 := tmp132.Get() + tmp134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp135 := tmp134.FindInternedVar(lang.NewSymbol("seq")) + if tmp135.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp135))) + } + tmp136 := tmp135.Get() + tmp137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp138 := tmp137.FindInternedVar(lang.NewSymbol("concat")) + if tmp138.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp138))) + } + tmp139 := tmp138.Get() + tmp140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp141 := tmp140.FindInternedVar(lang.NewSymbol("list")) + if tmp141.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp141))) + } + tmp142 := tmp141.Get() + tmp143 := lang.Apply(tmp142, []any{lang.NewSymbol("try")}) + tmp144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp145 := tmp144.FindInternedVar(lang.NewSymbol("list")) + if tmp145.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp145))) + } + tmp146 := tmp145.Get() + tmp147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp148 := tmp147.FindInternedVar(lang.NewSymbol("seq")) + if tmp148.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp148))) + } + tmp149 := tmp148.Get() + tmp150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp151 := tmp150.FindInternedVar(lang.NewSymbol("concat")) + if tmp151.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp151))) + } + tmp152 := tmp151.Get() + tmp153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp154 := tmp153.FindInternedVar(lang.NewSymbol("list")) + if tmp154.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp154))) + } + tmp155 := tmp154.Get() + tmp156 := lang.Apply(tmp155, []any{lang.NewSymbol("finally")}) + tmp157 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp158 := tmp157.FindInternedVar(lang.NewSymbol("list")) + if tmp158.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp158))) + } + tmp159 := tmp158.Get() + tmp160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp161 := tmp160.FindInternedVar(lang.NewSymbol("seq")) + if tmp161.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp161))) + } + tmp162 := tmp161.Get() + tmp163 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp164 := tmp163.FindInternedVar(lang.NewSymbol("concat")) + if tmp164.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp164))) + } + tmp165 := tmp164.Get() + tmp166 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp167 := tmp166.FindInternedVar(lang.NewSymbol("list")) + if tmp167.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp167))) + } + tmp168 := tmp167.Get() + tmp169 := lang.Apply(tmp168, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.PopThreadBindings")}) + tmp170 := lang.Apply(tmp165, []any{tmp169}) + tmp171 := lang.Apply(tmp162, []any{tmp170}) + tmp172 := lang.Apply(tmp159, []any{tmp171}) + tmp173 := lang.Apply(tmp152, []any{tmp156, tmp172}) + tmp174 := lang.Apply(tmp149, []any{tmp173}) + tmp175 := lang.Apply(tmp146, []any{tmp174}) + tmp176 := lang.Apply(tmp139, []any{tmp143, v6, tmp175}) + tmp177 := lang.Apply(tmp136, []any{tmp176}) + tmp178 := lang.Apply(tmp133, []any{tmp177}) + tmp179 := lang.Apply(tmp60, []any{tmp64, tmp95, tmp130, tmp178}) + tmp180 := lang.Apply(tmp57, []any{tmp179}) + return tmp180 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // with-meta { - v0 := lang.NewSymbol("with-meta").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("obj"), lang.NewSymbol("m"))), lang.NewKeyword("doc"), "Returns an object of the same type and value as obj, with\n map m as its metadata.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(211), lang.NewKeyword("end-line"), int(216))).(*lang.Symbol) - var v2 lang.FnFunc + tmp0 := lang.NewSymbol("with-meta").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("obj"), lang.NewSymbol("m"))), lang.NewKeyword("doc"), "Returns an object of the same type and value as obj, with\n map m as its metadata.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(211), lang.NewKeyword("end-line"), int(216))).(*lang.Symbol) + var tmp2 lang.FnFunc { // function with-meta - v2 = lang.NewFnFunc(func(args ...any) any { + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -85161,27 +85362,27 @@ func init() { _ = v4 v5 := args[1] _ = v5 - v6, _ := lang.FieldOrMethod(v4, "WithMeta") - if reflect.TypeOf(v6).Kind() != reflect.Func { + tmp6, _ := lang.FieldOrMethod(v4, "WithMeta") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("WithMeta is not a function"))) } - v7 := lang.Apply(v6, []any{v5}) - return v7 + tmp7 := lang.Apply(tmp6, []any{v5}) + return tmp7 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(216), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(217), lang.NewKeyword("end-column"), int(32))).(lang.FnFunc) - v3 := v2 + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(216), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(217), lang.NewKeyword("end-column"), int(32))).(lang.FnFunc) + v3 = tmp2 _ = v3 } - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // with-open { - v0 := lang.NewSymbol("with-open").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "bindings => [name init ...]\n\n Evaluates body in a try expression with names bound to the values\n of the inits, and a finally clause that calls (.close name) on each\n name in reverse order.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3832), lang.NewKeyword("end-line"), int(3832))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("with-open").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "bindings => [name init ...]\n\n Evaluates body in a try expression with names bound to the values\n of the inits, and a finally clause that calls (.close name) on each\n name in reverse order.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3832), lang.NewKeyword("end-line"), int(3832))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 3 { @@ -85193,353 +85394,350 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - var v7 any - v8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v9 := v8.FindInternedVar(lang.NewSymbol("vector?")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) - } - v10 := v9.Get() - v11 := lang.Apply(v10, []any{v5}) - if lang.IsTruthy(v11) { - v7 = nil + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("vector?")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.Apply(tmp10, []any{v5}) + if lang.IsTruthy(tmp11) { } else { - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("str")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v16 := v15.FindInternedVar(lang.NewSymbol("first")) - if v16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v16))) - } - v17 := v16.Get() - v18 := lang.Apply(v17, []any{v3}) - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("*ns*")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("meta")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v3}) - v26 := lang.Apply(lang.NewKeyword("line"), []any{v25}) - v27 := lang.Apply(v14, []any{v18, " requires ", "a vector for its binding", " in ", v21, ":", v26}) - v28 := lang.Apply(lang.NewIllegalArgumentError, []any{v27}) - panic(v28) - } - _ = v7 - var v29 any - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("even?")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) - } - v32 := v31.Get() - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("count")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) - } - v35 := v34.Get() - v36 := lang.Apply(v35, []any{v5}) - v37 := lang.Apply(v32, []any{v36}) - if lang.IsTruthy(v37) { - v29 = nil + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("str")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp16 := tmp15.FindInternedVar(lang.NewSymbol("first")) + if tmp16.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) + } + tmp17 := tmp16.Get() + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("*ns*")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("meta")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.Apply(tmp24, []any{v3}) + tmp26 := lang.Apply(lang.NewKeyword("line"), []any{tmp25}) + tmp27 := lang.Apply(tmp14, []any{tmp18, " requires ", "a vector for its binding", " in ", tmp21, ":", tmp26}) + tmp28 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp27}) + panic(tmp28) + } + _ = tmp7 + var tmp29 any + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("even?")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) + } + tmp32 := tmp31.Get() + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("count")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) + } + tmp35 := tmp34.Get() + tmp36 := lang.Apply(tmp35, []any{v5}) + tmp37 := lang.Apply(tmp32, []any{tmp36}) + if lang.IsTruthy(tmp37) { } else { - v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v39 := v38.FindInternedVar(lang.NewSymbol("str")) - if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) - } - v40 := v39.Get() - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("first")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) - } - v43 := v42.Get() - v44 := lang.Apply(v43, []any{v3}) - v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v46 := v45.FindInternedVar(lang.NewSymbol("*ns*")) - if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) - } - v47 := v46.Get() - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("meta")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{v3}) - v52 := lang.Apply(lang.NewKeyword("line"), []any{v51}) - v53 := lang.Apply(v40, []any{v44, " requires ", "an even number of forms in binding vector", " in ", v47, ":", v52}) - v54 := lang.Apply(lang.NewIllegalArgumentError, []any{v53}) - panic(v54) - } - _ = v29 - _ = nil - var v55 any - v56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v57 := v56.FindInternedVar(lang.NewSymbol("=")) - if v57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v57))) - } - v58 := v57.Get() - v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v60 := v59.FindInternedVar(lang.NewSymbol("count")) - if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) - } - v61 := v60.Get() - v62 := lang.Apply(v61, []any{v5}) - v63 := lang.Apply(v58, []any{v62, int64(0)}) - if lang.IsTruthy(v63) { - v64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v65 := v64.FindInternedVar(lang.NewSymbol("seq")) - if v65.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v65))) - } - v66 := v65.Get() - v67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v68 := v67.FindInternedVar(lang.NewSymbol("concat")) - if v68.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v68))) - } - v69 := v68.Get() - v70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v71 := v70.FindInternedVar(lang.NewSymbol("list")) - if v71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v71))) - } - v72 := v71.Get() - v73 := lang.Apply(v72, []any{lang.NewSymbol("do")}) - v74 := lang.Apply(v69, []any{v73, v6}) - v75 := lang.Apply(v66, []any{v74}) - v55 = v75 + tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp39 := tmp38.FindInternedVar(lang.NewSymbol("str")) + if tmp39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) + } + tmp40 := tmp39.Get() + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("first")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := lang.Apply(tmp43, []any{v3}) + tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp46 := tmp45.FindInternedVar(lang.NewSymbol("*ns*")) + if tmp46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) + } + tmp47 := tmp46.Get() + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("meta")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{v3}) + tmp52 := lang.Apply(lang.NewKeyword("line"), []any{tmp51}) + tmp53 := lang.Apply(tmp40, []any{tmp44, " requires ", "an even number of forms in binding vector", " in ", tmp47, ":", tmp52}) + tmp54 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp53}) + panic(tmp54) + } + _ = tmp29 + var tmp55 any + tmp56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp57 := tmp56.FindInternedVar(lang.NewSymbol("=")) + if tmp57.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp57))) + } + tmp58 := tmp57.Get() + tmp59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp60 := tmp59.FindInternedVar(lang.NewSymbol("count")) + if tmp60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp60))) + } + tmp61 := tmp60.Get() + tmp62 := lang.Apply(tmp61, []any{v5}) + tmp63 := lang.Apply(tmp58, []any{tmp62, int64(0)}) + if lang.IsTruthy(tmp63) { + tmp64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp65 := tmp64.FindInternedVar(lang.NewSymbol("seq")) + if tmp65.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp65))) + } + tmp66 := tmp65.Get() + tmp67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp68 := tmp67.FindInternedVar(lang.NewSymbol("concat")) + if tmp68.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp68))) + } + tmp69 := tmp68.Get() + tmp70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp71 := tmp70.FindInternedVar(lang.NewSymbol("list")) + if tmp71.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp71))) + } + tmp72 := tmp71.Get() + tmp73 := lang.Apply(tmp72, []any{lang.NewSymbol("do")}) + tmp74 := lang.Apply(tmp69, []any{tmp73, v6}) + tmp75 := lang.Apply(tmp66, []any{tmp74}) + tmp55 = tmp75 } else { - var v76 any - v77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v78 := v77.FindInternedVar(lang.NewSymbol("symbol?")) - if v78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v78))) - } - v79 := v78.Get() - v80 := lang.Apply(v5, []any{int64(0)}) - v81 := lang.Apply(v79, []any{v80}) - if lang.IsTruthy(v81) { - v82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v83 := v82.FindInternedVar(lang.NewSymbol("seq")) - if v83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v83))) - } - v84 := v83.Get() - v85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v86 := v85.FindInternedVar(lang.NewSymbol("concat")) - if v86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v86))) - } - v87 := v86.Get() - v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v89 := v88.FindInternedVar(lang.NewSymbol("list")) - if v89.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) - } - v90 := v89.Get() - v91 := lang.Apply(v90, []any{lang.NewSymbol("glojure.core/let")}) - v92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v93 := v92.FindInternedVar(lang.NewSymbol("list")) - if v93.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v93))) - } - v94 := v93.Get() - v95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v96 := v95.FindInternedVar(lang.NewSymbol("subvec")) - if v96.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v96))) - } - v97 := v96.Get() - v98 := lang.Apply(v97, []any{v5, int64(0), int64(2)}) - v99 := lang.Apply(v94, []any{v98}) - v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v101 := v100.FindInternedVar(lang.NewSymbol("list")) - if v101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) - } - v102 := v101.Get() - v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v104 := v103.FindInternedVar(lang.NewSymbol("seq")) - if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) - } - v105 := v104.Get() - v106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v107 := v106.FindInternedVar(lang.NewSymbol("concat")) - if v107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v107))) - } - v108 := v107.Get() - v109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v110 := v109.FindInternedVar(lang.NewSymbol("list")) - if v110.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v110))) - } - v111 := v110.Get() - v112 := lang.Apply(v111, []any{lang.NewSymbol("try")}) - v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v114 := v113.FindInternedVar(lang.NewSymbol("list")) - if v114.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) - } - v115 := v114.Get() - v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v117 := v116.FindInternedVar(lang.NewSymbol("seq")) - if v117.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) - } - v118 := v117.Get() - v119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v120 := v119.FindInternedVar(lang.NewSymbol("concat")) - if v120.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v120))) - } - v121 := v120.Get() - v122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v123 := v122.FindInternedVar(lang.NewSymbol("list")) - if v123.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v123))) - } - v124 := v123.Get() - v125 := lang.Apply(v124, []any{lang.NewSymbol("glojure.core/with-open")}) - v126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v127 := v126.FindInternedVar(lang.NewSymbol("list")) - if v127.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v127))) - } - v128 := v127.Get() - v129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v130 := v129.FindInternedVar(lang.NewSymbol("subvec")) - if v130.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v130))) - } - v131 := v130.Get() - v132 := lang.Apply(v131, []any{v5, int64(2)}) - v133 := lang.Apply(v128, []any{v132}) - v134 := lang.Apply(v121, []any{v125, v133, v6}) - v135 := lang.Apply(v118, []any{v134}) - v136 := lang.Apply(v115, []any{v135}) - v137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v138 := v137.FindInternedVar(lang.NewSymbol("list")) - if v138.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v138))) - } - v139 := v138.Get() - v140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v141 := v140.FindInternedVar(lang.NewSymbol("seq")) - if v141.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v141))) - } - v142 := v141.Get() - v143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v144 := v143.FindInternedVar(lang.NewSymbol("concat")) - if v144.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v144))) - } - v145 := v144.Get() - v146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v147 := v146.FindInternedVar(lang.NewSymbol("list")) - if v147.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v147))) - } - v148 := v147.Get() - v149 := lang.Apply(v148, []any{lang.NewSymbol("finally")}) - v150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v151 := v150.FindInternedVar(lang.NewSymbol("list")) - if v151.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v151))) - } - v152 := v151.Get() - v153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v154 := v153.FindInternedVar(lang.NewSymbol("seq")) - if v154.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v154))) - } - v155 := v154.Get() - v156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v157 := v156.FindInternedVar(lang.NewSymbol("concat")) - if v157.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v157))) - } - v158 := v157.Get() - v159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v160 := v159.FindInternedVar(lang.NewSymbol("list")) - if v160.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v160))) - } - v161 := v160.Get() - v162 := lang.Apply(v161, []any{lang.NewSymbol(".")}) - v163 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v164 := v163.FindInternedVar(lang.NewSymbol("list")) - if v164.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v164))) - } - v165 := v164.Get() - v166 := lang.Apply(v5, []any{int64(0)}) - v167 := lang.Apply(v165, []any{v166}) - v168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v169 := v168.FindInternedVar(lang.NewSymbol("list")) - if v169.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v169))) - } - v170 := v169.Get() - v171 := lang.Apply(v170, []any{lang.NewSymbol("close")}) - v172 := lang.Apply(v158, []any{v162, v167, v171}) - v173 := lang.Apply(v155, []any{v172}) - v174 := lang.Apply(v152, []any{v173}) - v175 := lang.Apply(v145, []any{v149, v174}) - v176 := lang.Apply(v142, []any{v175}) - v177 := lang.Apply(v139, []any{v176}) - v178 := lang.Apply(v108, []any{v112, v136, v177}) - v179 := lang.Apply(v105, []any{v178}) - v180 := lang.Apply(v102, []any{v179}) - v181 := lang.Apply(v87, []any{v91, v99, v180}) - v182 := lang.Apply(v84, []any{v181}) - v76 = v182 + var tmp76 any + tmp77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp78 := tmp77.FindInternedVar(lang.NewSymbol("symbol?")) + if tmp78.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp78))) + } + tmp79 := tmp78.Get() + tmp80 := lang.Apply(v5, []any{int64(0)}) + tmp81 := lang.Apply(tmp79, []any{tmp80}) + if lang.IsTruthy(tmp81) { + tmp82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp83 := tmp82.FindInternedVar(lang.NewSymbol("seq")) + if tmp83.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp83))) + } + tmp84 := tmp83.Get() + tmp85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp86 := tmp85.FindInternedVar(lang.NewSymbol("concat")) + if tmp86.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp86))) + } + tmp87 := tmp86.Get() + tmp88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp89 := tmp88.FindInternedVar(lang.NewSymbol("list")) + if tmp89.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp89))) + } + tmp90 := tmp89.Get() + tmp91 := lang.Apply(tmp90, []any{lang.NewSymbol("glojure.core/let")}) + tmp92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp93 := tmp92.FindInternedVar(lang.NewSymbol("list")) + if tmp93.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp93))) + } + tmp94 := tmp93.Get() + tmp95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp96 := tmp95.FindInternedVar(lang.NewSymbol("subvec")) + if tmp96.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp96))) + } + tmp97 := tmp96.Get() + tmp98 := lang.Apply(tmp97, []any{v5, int64(0), int64(2)}) + tmp99 := lang.Apply(tmp94, []any{tmp98}) + tmp100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp101 := tmp100.FindInternedVar(lang.NewSymbol("list")) + if tmp101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp101))) + } + tmp102 := tmp101.Get() + tmp103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp104 := tmp103.FindInternedVar(lang.NewSymbol("seq")) + if tmp104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp104))) + } + tmp105 := tmp104.Get() + tmp106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp107 := tmp106.FindInternedVar(lang.NewSymbol("concat")) + if tmp107.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp107))) + } + tmp108 := tmp107.Get() + tmp109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp110 := tmp109.FindInternedVar(lang.NewSymbol("list")) + if tmp110.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp110))) + } + tmp111 := tmp110.Get() + tmp112 := lang.Apply(tmp111, []any{lang.NewSymbol("try")}) + tmp113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp114 := tmp113.FindInternedVar(lang.NewSymbol("list")) + if tmp114.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp114))) + } + tmp115 := tmp114.Get() + tmp116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp117 := tmp116.FindInternedVar(lang.NewSymbol("seq")) + if tmp117.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp117))) + } + tmp118 := tmp117.Get() + tmp119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp120 := tmp119.FindInternedVar(lang.NewSymbol("concat")) + if tmp120.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp120))) + } + tmp121 := tmp120.Get() + tmp122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp123 := tmp122.FindInternedVar(lang.NewSymbol("list")) + if tmp123.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp123))) + } + tmp124 := tmp123.Get() + tmp125 := lang.Apply(tmp124, []any{lang.NewSymbol("glojure.core/with-open")}) + tmp126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp127 := tmp126.FindInternedVar(lang.NewSymbol("list")) + if tmp127.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp127))) + } + tmp128 := tmp127.Get() + tmp129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp130 := tmp129.FindInternedVar(lang.NewSymbol("subvec")) + if tmp130.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp130))) + } + tmp131 := tmp130.Get() + tmp132 := lang.Apply(tmp131, []any{v5, int64(2)}) + tmp133 := lang.Apply(tmp128, []any{tmp132}) + tmp134 := lang.Apply(tmp121, []any{tmp125, tmp133, v6}) + tmp135 := lang.Apply(tmp118, []any{tmp134}) + tmp136 := lang.Apply(tmp115, []any{tmp135}) + tmp137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp138 := tmp137.FindInternedVar(lang.NewSymbol("list")) + if tmp138.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp138))) + } + tmp139 := tmp138.Get() + tmp140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp141 := tmp140.FindInternedVar(lang.NewSymbol("seq")) + if tmp141.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp141))) + } + tmp142 := tmp141.Get() + tmp143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp144 := tmp143.FindInternedVar(lang.NewSymbol("concat")) + if tmp144.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp144))) + } + tmp145 := tmp144.Get() + tmp146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp147 := tmp146.FindInternedVar(lang.NewSymbol("list")) + if tmp147.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp147))) + } + tmp148 := tmp147.Get() + tmp149 := lang.Apply(tmp148, []any{lang.NewSymbol("finally")}) + tmp150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp151 := tmp150.FindInternedVar(lang.NewSymbol("list")) + if tmp151.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp151))) + } + tmp152 := tmp151.Get() + tmp153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp154 := tmp153.FindInternedVar(lang.NewSymbol("seq")) + if tmp154.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp154))) + } + tmp155 := tmp154.Get() + tmp156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp157 := tmp156.FindInternedVar(lang.NewSymbol("concat")) + if tmp157.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp157))) + } + tmp158 := tmp157.Get() + tmp159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp160 := tmp159.FindInternedVar(lang.NewSymbol("list")) + if tmp160.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp160))) + } + tmp161 := tmp160.Get() + tmp162 := lang.Apply(tmp161, []any{lang.NewSymbol(".")}) + tmp163 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp164 := tmp163.FindInternedVar(lang.NewSymbol("list")) + if tmp164.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp164))) + } + tmp165 := tmp164.Get() + tmp166 := lang.Apply(v5, []any{int64(0)}) + tmp167 := lang.Apply(tmp165, []any{tmp166}) + tmp168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp169 := tmp168.FindInternedVar(lang.NewSymbol("list")) + if tmp169.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp169))) + } + tmp170 := tmp169.Get() + tmp171 := lang.Apply(tmp170, []any{lang.NewSymbol("close")}) + tmp172 := lang.Apply(tmp158, []any{tmp162, tmp167, tmp171}) + tmp173 := lang.Apply(tmp155, []any{tmp172}) + tmp174 := lang.Apply(tmp152, []any{tmp173}) + tmp175 := lang.Apply(tmp145, []any{tmp149, tmp174}) + tmp176 := lang.Apply(tmp142, []any{tmp175}) + tmp177 := lang.Apply(tmp139, []any{tmp176}) + tmp178 := lang.Apply(tmp108, []any{tmp112, tmp136, tmp177}) + tmp179 := lang.Apply(tmp105, []any{tmp178}) + tmp180 := lang.Apply(tmp102, []any{tmp179}) + tmp181 := lang.Apply(tmp87, []any{tmp91, tmp99, tmp180}) + tmp182 := lang.Apply(tmp84, []any{tmp181}) + tmp76 = tmp182 } else { - var v183 any + var tmp183 any if lang.IsTruthy(lang.NewKeyword("else")) { - v184 := lang.Apply(lang.NewIllegalArgumentError, []any{"with-open only allows Symbols in bindings"}) - panic(v184) + tmp184 := lang.Apply(lang.NewIllegalArgumentError, []any{"with-open only allows Symbols in bindings"}) + panic(tmp184) } else { - v183 = nil } - v76 = v183 + tmp76 = tmp183 } - v55 = v76 + tmp55 = tmp76 } - return v55 + return tmp55 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // with-out-str { - v0 := lang.NewSymbol("with-out-str").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Evaluates exprs in a context in which *out* is bound to a fresh\n StringWriter. Returns the string created by any nested printing\n calls.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4738), lang.NewKeyword("end-line"), int(4738))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("with-out-str").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Evaluates exprs in a context in which *out* is bound to a fresh\n StringWriter. Returns the string created by any nested printing\n calls.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4738), lang.NewKeyword("end-line"), int(4738))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 2 { @@ -85549,229 +85747,230 @@ func init() { _ = v3 v4 := args[1] _ = v4 - v5 := lang.NewList(args[2:]...) - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("seq")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("concat")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("list")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.Apply(v14, []any{lang.NewSymbol("glojure.core/let")}) - v16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v17 := v16.FindInternedVar(lang.NewSymbol("list")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("apply")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("vector")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("seq")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("concat")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{lang.NewSymbol("s__0__auto__")}) - v35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v36 := v35.FindInternedVar(lang.NewSymbol("list")) - if v36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v36))) - } - v37 := v36.Get() - v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v39 := v38.FindInternedVar(lang.NewSymbol("seq")) - if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) - } - v40 := v39.Get() - v41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v42 := v41.FindInternedVar(lang.NewSymbol("concat")) - if v42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v42))) - } - v43 := v42.Get() - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("list")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) - } - v46 := v45.Get() - v47 := lang.Apply(v46, []any{lang.NewSymbol("new")}) - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("list")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.Apply(v50, []any{lang.NewSymbol("strings.Builder")}) - v52 := lang.Apply(v43, []any{v47, v51}) - v53 := lang.Apply(v40, []any{v52}) - v54 := lang.Apply(v37, []any{v53}) - v55 := lang.Apply(v30, []any{v34, v54}) - v56 := lang.Apply(v27, []any{v55}) - v57 := lang.Apply(v21, []any{v24, v56}) - v58 := lang.Apply(v18, []any{v57}) - v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v60 := v59.FindInternedVar(lang.NewSymbol("list")) - if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) - } - v61 := v60.Get() - v62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v63 := v62.FindInternedVar(lang.NewSymbol("seq")) - if v63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v63))) - } - v64 := v63.Get() - v65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v66 := v65.FindInternedVar(lang.NewSymbol("concat")) - if v66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v66))) - } - v67 := v66.Get() - v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v69 := v68.FindInternedVar(lang.NewSymbol("list")) - if v69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) - } - v70 := v69.Get() - v71 := lang.Apply(v70, []any{lang.NewSymbol("glojure.core/binding")}) - v72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v73 := v72.FindInternedVar(lang.NewSymbol("list")) - if v73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v73))) - } - v74 := v73.Get() - v75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v76 := v75.FindInternedVar(lang.NewSymbol("apply")) - if v76.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v76))) - } - v77 := v76.Get() - v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v79 := v78.FindInternedVar(lang.NewSymbol("vector")) - if v79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) - } - v80 := v79.Get() - v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v82 := v81.FindInternedVar(lang.NewSymbol("seq")) - if v82.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) - } - v83 := v82.Get() - v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v85 := v84.FindInternedVar(lang.NewSymbol("concat")) - if v85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) - } - v86 := v85.Get() - v87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v88 := v87.FindInternedVar(lang.NewSymbol("list")) - if v88.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v88))) - } - v89 := v88.Get() - v90 := lang.Apply(v89, []any{lang.NewSymbol("glojure.core/*out*")}) - v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v92 := v91.FindInternedVar(lang.NewSymbol("list")) - if v92.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) - } - v93 := v92.Get() - v94 := lang.Apply(v93, []any{lang.NewSymbol("s__0__auto__")}) - v95 := lang.Apply(v86, []any{v90, v94}) - v96 := lang.Apply(v83, []any{v95}) - v97 := lang.Apply(v77, []any{v80, v96}) - v98 := lang.Apply(v74, []any{v97}) - v99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v100 := v99.FindInternedVar(lang.NewSymbol("list")) - if v100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v100))) - } - v101 := v100.Get() - v102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v103 := v102.FindInternedVar(lang.NewSymbol("seq")) - if v103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v103))) - } - v104 := v103.Get() - v105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v106 := v105.FindInternedVar(lang.NewSymbol("concat")) - if v106.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v106))) - } - v107 := v106.Get() - v108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v109 := v108.FindInternedVar(lang.NewSymbol("list")) - if v109.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v109))) - } - v110 := v109.Get() - v111 := lang.Apply(v110, []any{lang.NewSymbol("glojure.core/str")}) - v112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v113 := v112.FindInternedVar(lang.NewSymbol("list")) - if v113.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v113))) - } - v114 := v113.Get() - v115 := lang.Apply(v114, []any{lang.NewSymbol("s__0__auto__")}) - v116 := lang.Apply(v107, []any{v111, v115}) - v117 := lang.Apply(v104, []any{v116}) - v118 := lang.Apply(v101, []any{v117}) - v119 := lang.Apply(v67, []any{v71, v98, v5, v118}) - v120 := lang.Apply(v64, []any{v119}) - v121 := lang.Apply(v61, []any{v120}) - v122 := lang.Apply(v11, []any{v15, v58, v121}) - v123 := lang.Apply(v8, []any{v122}) - return v123 - } - }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("seq")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("concat")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("list")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("glojure.core/let")}) + tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("list")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("apply")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("vector")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("seq")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("concat")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{lang.NewSymbol("s__0__auto__")}) + tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp36 := tmp35.FindInternedVar(lang.NewSymbol("list")) + if tmp36.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) + } + tmp37 := tmp36.Get() + tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp39 := tmp38.FindInternedVar(lang.NewSymbol("seq")) + if tmp39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) + } + tmp40 := tmp39.Get() + tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp42 := tmp41.FindInternedVar(lang.NewSymbol("concat")) + if tmp42.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) + } + tmp43 := tmp42.Get() + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) + } + tmp46 := tmp45.Get() + tmp47 := lang.Apply(tmp46, []any{lang.NewSymbol("new")}) + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.Apply(tmp50, []any{lang.NewSymbol("strings.Builder")}) + tmp52 := lang.Apply(tmp43, []any{tmp47, tmp51}) + tmp53 := lang.Apply(tmp40, []any{tmp52}) + tmp54 := lang.Apply(tmp37, []any{tmp53}) + tmp55 := lang.Apply(tmp30, []any{tmp34, tmp54}) + tmp56 := lang.Apply(tmp27, []any{tmp55}) + tmp57 := lang.Apply(tmp21, []any{tmp24, tmp56}) + tmp58 := lang.Apply(tmp18, []any{tmp57}) + tmp59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp60 := tmp59.FindInternedVar(lang.NewSymbol("list")) + if tmp60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp60))) + } + tmp61 := tmp60.Get() + tmp62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp63 := tmp62.FindInternedVar(lang.NewSymbol("seq")) + if tmp63.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp63))) + } + tmp64 := tmp63.Get() + tmp65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp66 := tmp65.FindInternedVar(lang.NewSymbol("concat")) + if tmp66.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp66))) + } + tmp67 := tmp66.Get() + tmp68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp69 := tmp68.FindInternedVar(lang.NewSymbol("list")) + if tmp69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp69))) + } + tmp70 := tmp69.Get() + tmp71 := lang.Apply(tmp70, []any{lang.NewSymbol("glojure.core/binding")}) + tmp72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp73 := tmp72.FindInternedVar(lang.NewSymbol("list")) + if tmp73.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp73))) + } + tmp74 := tmp73.Get() + tmp75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp76 := tmp75.FindInternedVar(lang.NewSymbol("apply")) + if tmp76.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp76))) + } + tmp77 := tmp76.Get() + tmp78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp79 := tmp78.FindInternedVar(lang.NewSymbol("vector")) + if tmp79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp79))) + } + tmp80 := tmp79.Get() + tmp81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp82 := tmp81.FindInternedVar(lang.NewSymbol("seq")) + if tmp82.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp82))) + } + tmp83 := tmp82.Get() + tmp84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp85 := tmp84.FindInternedVar(lang.NewSymbol("concat")) + if tmp85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp85))) + } + tmp86 := tmp85.Get() + tmp87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp88 := tmp87.FindInternedVar(lang.NewSymbol("list")) + if tmp88.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp88))) + } + tmp89 := tmp88.Get() + tmp90 := lang.Apply(tmp89, []any{lang.NewSymbol("glojure.core/*out*")}) + tmp91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp92 := tmp91.FindInternedVar(lang.NewSymbol("list")) + if tmp92.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp92))) + } + tmp93 := tmp92.Get() + tmp94 := lang.Apply(tmp93, []any{lang.NewSymbol("s__0__auto__")}) + tmp95 := lang.Apply(tmp86, []any{tmp90, tmp94}) + tmp96 := lang.Apply(tmp83, []any{tmp95}) + tmp97 := lang.Apply(tmp77, []any{tmp80, tmp96}) + tmp98 := lang.Apply(tmp74, []any{tmp97}) + tmp99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp100 := tmp99.FindInternedVar(lang.NewSymbol("list")) + if tmp100.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp100))) + } + tmp101 := tmp100.Get() + tmp102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp103 := tmp102.FindInternedVar(lang.NewSymbol("seq")) + if tmp103.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp103))) + } + tmp104 := tmp103.Get() + tmp105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp106 := tmp105.FindInternedVar(lang.NewSymbol("concat")) + if tmp106.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp106))) + } + tmp107 := tmp106.Get() + tmp108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp109 := tmp108.FindInternedVar(lang.NewSymbol("list")) + if tmp109.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp109))) + } + tmp110 := tmp109.Get() + tmp111 := lang.Apply(tmp110, []any{lang.NewSymbol("glojure.core/str")}) + tmp112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp113 := tmp112.FindInternedVar(lang.NewSymbol("list")) + if tmp113.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp113))) + } + tmp114 := tmp113.Get() + tmp115 := lang.Apply(tmp114, []any{lang.NewSymbol("s__0__auto__")}) + tmp116 := lang.Apply(tmp107, []any{tmp111, tmp115}) + tmp117 := lang.Apply(tmp104, []any{tmp116}) + tmp118 := lang.Apply(tmp101, []any{tmp117}) + tmp119 := lang.Apply(tmp67, []any{tmp71, tmp98, v5, tmp118}) + tmp120 := lang.Apply(tmp64, []any{tmp119}) + tmp121 := lang.Apply(tmp61, []any{tmp120}) + tmp122 := lang.Apply(tmp11, []any{tmp15, tmp58, tmp121}) + tmp123 := lang.Apply(tmp8, []any{tmp122}) + return tmp123 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // with-precision { - v0 := lang.NewSymbol("with-precision").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("precision"), lang.NewSymbol("&"), lang.NewSymbol("exprs"))), lang.NewKeyword("doc"), "Sets the precision and rounding mode to be used for BigDecimal operations.\n\n Usage: (with-precision 10 (/ 1M 3))\n or: (with-precision 10 :rounding HALF_DOWN (/ 1M 3))\n\n The rounding mode is one of CEILING, FLOOR, HALF_UP, HALF_DOWN,\n HALF_EVEN, UP, DOWN and UNNECESSARY; it defaults to HALF_UP.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5110), lang.NewKeyword("end-line"), int(5110))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("with-precision").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("precision"), lang.NewSymbol("&"), lang.NewSymbol("exprs"))), lang.NewKeyword("doc"), "Sets the precision and rounding mode to be used for BigDecimal operations.\n\n Usage: (with-precision 10 (/ 1M 3))\n or: (with-precision 10 :rounding HALF_DOWN (/ 1M 3))\n\n The rounding mode is one of CEILING, FLOOR, HALF_UP, HALF_DOWN,\n HALF_EVEN, UP, DOWN and UNNECESSARY; it defaults to HALF_UP.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5110), lang.NewKeyword("end-line"), int(5110))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 3 { @@ -85783,254 +85982,255 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - var v7 any + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any { // let // let binding "vec__65" - var v8 any - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("=")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v13 := v12.FindInternedVar(lang.NewSymbol("first")) - if v13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v13))) - } - v14 := v13.Get() - v15 := lang.Apply(v14, []any{v6}) - v16 := lang.Apply(v11, []any{v15, lang.NewKeyword("rounding")}) - if lang.IsTruthy(v16) { - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("next")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("next")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.Apply(v22, []any{v6}) - v24 := lang.Apply(v19, []any{v23}) - v25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v26 := v25.FindInternedVar(lang.NewSymbol("seq")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("concat")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("seq")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) - } - v36 := v35.Get() - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("concat")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("list")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) - } - v42 := v41.Get() - v43 := lang.Apply(v42, []any{lang.NewSymbol(".")}) - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("list")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) - } - v46 := v45.Get() - v47 := lang.Apply(v46, []any{lang.NewSymbol("java.math.RoundingMode")}) - v48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v49 := v48.FindInternedVar(lang.NewSymbol("list")) - if v49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v49))) - } - v50 := v49.Get() - v51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v52 := v51.FindInternedVar(lang.NewSymbol("second")) - if v52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v52))) - } - v53 := v52.Get() - v54 := lang.Apply(v53, []any{v6}) - v55 := lang.Apply(v50, []any{v54}) - v56 := lang.Apply(v39, []any{v43, v47, v55}) - v57 := lang.Apply(v36, []any{v56}) - v58 := lang.Apply(v33, []any{v57}) - v59 := lang.Apply(v30, []any{v58}) - v60 := lang.Apply(v27, []any{v59}) - v61 := lang.NewVector(v24, v60) - v62 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5121), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(5122), lang.NewKeyword("end-column"), int(69)) - v63, err := lang.WithMeta(v61, v62.(lang.IPersistentMap)) + var tmp8 any + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("=")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp13 := tmp12.FindInternedVar(lang.NewSymbol("first")) + if tmp13.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) + } + tmp14 := tmp13.Get() + tmp15 := lang.Apply(tmp14, []any{v6}) + tmp16 := lang.Apply(tmp11, []any{tmp15, lang.NewKeyword("rounding")}) + if lang.IsTruthy(tmp16) { + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("next")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("next")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.Apply(tmp22, []any{v6}) + tmp24 := lang.Apply(tmp19, []any{tmp23}) + tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("seq")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("concat")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) + } + tmp42 := tmp41.Get() + tmp43 := lang.Apply(tmp42, []any{lang.NewSymbol(".")}) + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) + } + tmp46 := tmp45.Get() + tmp47 := lang.Apply(tmp46, []any{lang.NewSymbol("java.math.RoundingMode")}) + tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) + if tmp49.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) + } + tmp50 := tmp49.Get() + tmp51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp52 := tmp51.FindInternedVar(lang.NewSymbol("second")) + if tmp52.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp52))) + } + tmp53 := tmp52.Get() + tmp54 := lang.Apply(tmp53, []any{v6}) + tmp55 := lang.Apply(tmp50, []any{tmp54}) + tmp56 := lang.Apply(tmp39, []any{tmp43, tmp47, tmp55}) + tmp57 := lang.Apply(tmp36, []any{tmp56}) + tmp58 := lang.Apply(tmp33, []any{tmp57}) + tmp59 := lang.Apply(tmp30, []any{tmp58}) + tmp60 := lang.Apply(tmp27, []any{tmp59}) + tmp61 := lang.NewVector(tmp24, tmp60) + tmp62 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5121), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(5122), lang.NewKeyword("end-column"), int(69)) + tmp63, err := lang.WithMeta(tmp61, tmp62.(lang.IPersistentMap)) if err != nil { panic(err) } - v8 = v63 + tmp8 = tmp63 } else { - v64 := lang.NewVector(v6, nil) - v65 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5123), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(5123), lang.NewKeyword("end-column"), int(33)) - v66, err := lang.WithMeta(v64, v65.(lang.IPersistentMap)) + tmp64 := lang.NewVector(v6, nil) + tmp65 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5123), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(5123), lang.NewKeyword("end-column"), int(33)) + tmp66, err := lang.WithMeta(tmp64, tmp65.(lang.IPersistentMap)) if err != nil { panic(err) } - v8 = v66 + tmp8 = tmp66 } - var v67 any = v8 + var v67 any = tmp8 _ = v67 // let binding "body" - v68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v69 := v68.FindInternedVar(lang.NewSymbol("nth")) - if v69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v69))) - } - v70 := v69.Get() - v71 := lang.Apply(v70, []any{v67, int64(0), nil}) - var v72 any = v71 + tmp68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp69 := tmp68.FindInternedVar(lang.NewSymbol("nth")) + if tmp69.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp69))) + } + tmp70 := tmp69.Get() + tmp71 := lang.Apply(tmp70, []any{v67, int64(0), nil}) + var v72 any = tmp71 _ = v72 // let binding "rm" - v73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v74 := v73.FindInternedVar(lang.NewSymbol("nth")) - if v74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v74))) - } - v75 := v74.Get() - v76 := lang.Apply(v75, []any{v67, int64(1), nil}) - var v77 any = v76 + tmp73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp74 := tmp73.FindInternedVar(lang.NewSymbol("nth")) + if tmp74.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp74))) + } + tmp75 := tmp74.Get() + tmp76 := lang.Apply(tmp75, []any{v67, int64(1), nil}) + var v77 any = tmp76 _ = v77 - v78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v79 := v78.FindInternedVar(lang.NewSymbol("seq")) - if v79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v79))) - } - v80 := v79.Get() - v81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v82 := v81.FindInternedVar(lang.NewSymbol("concat")) - if v82.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v82))) - } - v83 := v82.Get() - v84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v85 := v84.FindInternedVar(lang.NewSymbol("list")) - if v85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v85))) - } - v86 := v85.Get() - v87 := lang.Apply(v86, []any{lang.NewSymbol("glojure.core/binding")}) - v88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v89 := v88.FindInternedVar(lang.NewSymbol("list")) - if v89.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v89))) - } - v90 := v89.Get() - v91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v92 := v91.FindInternedVar(lang.NewSymbol("apply")) - if v92.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v92))) - } - v93 := v92.Get() - v94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v95 := v94.FindInternedVar(lang.NewSymbol("vector")) - if v95.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v95))) - } - v96 := v95.Get() - v97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v98 := v97.FindInternedVar(lang.NewSymbol("seq")) - if v98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v98))) - } - v99 := v98.Get() - v100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v101 := v100.FindInternedVar(lang.NewSymbol("concat")) - if v101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v101))) - } - v102 := v101.Get() - v103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v104 := v103.FindInternedVar(lang.NewSymbol("list")) - if v104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v104))) - } - v105 := v104.Get() - v106 := lang.Apply(v105, []any{lang.NewSymbol("glojure.core/*math-context*")}) - v107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v108 := v107.FindInternedVar(lang.NewSymbol("list")) - if v108.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v108))) - } - v109 := v108.Get() - v110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v111 := v110.FindInternedVar(lang.NewSymbol("seq")) - if v111.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v111))) - } - v112 := v111.Get() - v113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v114 := v113.FindInternedVar(lang.NewSymbol("concat")) - if v114.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v114))) - } - v115 := v114.Get() - v116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v117 := v116.FindInternedVar(lang.NewSymbol("list")) - if v117.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v117))) - } - v118 := v117.Get() - v119 := lang.Apply(v118, []any{lang.NewSymbol("java.math.MathContext.")}) - v120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v121 := v120.FindInternedVar(lang.NewSymbol("list")) - if v121.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v121))) - } - v122 := v121.Get() - v123 := lang.Apply(v122, []any{v5}) - v124 := lang.Apply(v115, []any{v119, v123, v77}) - v125 := lang.Apply(v112, []any{v124}) - v126 := lang.Apply(v109, []any{v125}) - v127 := lang.Apply(v102, []any{v106, v126}) - v128 := lang.Apply(v99, []any{v127}) - v129 := lang.Apply(v93, []any{v96, v128}) - v130 := lang.Apply(v90, []any{v129}) - v131 := lang.Apply(v83, []any{v87, v130, v72}) - v132 := lang.Apply(v80, []any{v131}) - v7 = v132 + tmp78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp79 := tmp78.FindInternedVar(lang.NewSymbol("seq")) + if tmp79.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp79))) + } + tmp80 := tmp79.Get() + tmp81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp82 := tmp81.FindInternedVar(lang.NewSymbol("concat")) + if tmp82.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp82))) + } + tmp83 := tmp82.Get() + tmp84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp85 := tmp84.FindInternedVar(lang.NewSymbol("list")) + if tmp85.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp85))) + } + tmp86 := tmp85.Get() + tmp87 := lang.Apply(tmp86, []any{lang.NewSymbol("glojure.core/binding")}) + tmp88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp89 := tmp88.FindInternedVar(lang.NewSymbol("list")) + if tmp89.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp89))) + } + tmp90 := tmp89.Get() + tmp91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp92 := tmp91.FindInternedVar(lang.NewSymbol("apply")) + if tmp92.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp92))) + } + tmp93 := tmp92.Get() + tmp94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp95 := tmp94.FindInternedVar(lang.NewSymbol("vector")) + if tmp95.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp95))) + } + tmp96 := tmp95.Get() + tmp97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp98 := tmp97.FindInternedVar(lang.NewSymbol("seq")) + if tmp98.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp98))) + } + tmp99 := tmp98.Get() + tmp100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp101 := tmp100.FindInternedVar(lang.NewSymbol("concat")) + if tmp101.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp101))) + } + tmp102 := tmp101.Get() + tmp103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp104 := tmp103.FindInternedVar(lang.NewSymbol("list")) + if tmp104.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp104))) + } + tmp105 := tmp104.Get() + tmp106 := lang.Apply(tmp105, []any{lang.NewSymbol("glojure.core/*math-context*")}) + tmp107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp108 := tmp107.FindInternedVar(lang.NewSymbol("list")) + if tmp108.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp108))) + } + tmp109 := tmp108.Get() + tmp110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp111 := tmp110.FindInternedVar(lang.NewSymbol("seq")) + if tmp111.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp111))) + } + tmp112 := tmp111.Get() + tmp113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp114 := tmp113.FindInternedVar(lang.NewSymbol("concat")) + if tmp114.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp114))) + } + tmp115 := tmp114.Get() + tmp116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp117 := tmp116.FindInternedVar(lang.NewSymbol("list")) + if tmp117.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp117))) + } + tmp118 := tmp117.Get() + tmp119 := lang.Apply(tmp118, []any{lang.NewSymbol("java.math.MathContext.")}) + tmp120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp121 := tmp120.FindInternedVar(lang.NewSymbol("list")) + if tmp121.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp121))) + } + tmp122 := tmp121.Get() + tmp123 := lang.Apply(tmp122, []any{v5}) + tmp124 := lang.Apply(tmp115, []any{tmp119, tmp123, v77}) + tmp125 := lang.Apply(tmp112, []any{tmp124}) + tmp126 := lang.Apply(tmp109, []any{tmp125}) + tmp127 := lang.Apply(tmp102, []any{tmp106, tmp126}) + tmp128 := lang.Apply(tmp99, []any{tmp127}) + tmp129 := lang.Apply(tmp93, []any{tmp96, tmp128}) + tmp130 := lang.Apply(tmp90, []any{tmp129}) + tmp131 := lang.Apply(tmp83, []any{tmp87, tmp130, v72}) + tmp132 := lang.Apply(tmp80, []any{tmp131}) + tmp7 = tmp132 } // end let - return v7 + return tmp7 } }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // with-redefs { - v0 := lang.NewSymbol("with-redefs").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "binding => var-symbol temp-value-expr\n\n Temporarily redefines Vars while executing the body. The\n temp-value-exprs will be evaluated and each resulting value will\n replace in parallel the root value of its Var. After the body is\n executed, the root values of all the Vars will be set back to their\n old values. These temporary changes will be visible in all threads.\n Useful for mocking out functions during testing.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7544), lang.NewKeyword("end-line"), int(7544))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("with-redefs").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "binding => var-symbol temp-value-expr\n\n Temporarily redefines Vars while executing the body. The\n temp-value-exprs will be evaluated and each resulting value will\n replace in parallel the root value of its Var. After the body is\n executed, the root values of all the Vars will be set back to their\n old values. These temporary changes will be visible in all threads.\n Useful for mocking out functions during testing.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7544), lang.NewKeyword("end-line"), int(7544))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: if len(args) < 3 { @@ -86042,167 +86242,168 @@ func init() { _ = v4 v5 := args[2] _ = v5 - v6 := lang.NewList(args[3:]...) - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("seq")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("concat")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("list")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{lang.NewSymbol("glojure.core/with-redefs-fn")}) - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("list")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v21 := v20.FindInternedVar(lang.NewSymbol("zipmap")) - if v21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v21))) - } - v22 := v21.Get() - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("map")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) - } - v25 := v24.Get() - var v26 lang.FnFunc - v26 = lang.NewFnFunc(func(args ...any) any { + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("seq")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("concat")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("list")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("glojure.core/with-redefs-fn")}) + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("list")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp21 := tmp20.FindInternedVar(lang.NewSymbol("zipmap")) + if tmp21.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) + } + tmp22 := tmp21.Get() + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("map")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) + } + tmp25 := tmp24.Get() + var tmp26 lang.FnFunc + tmp26 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v27 := args[0] _ = v27 - v28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v29 := v28.FindInternedVar(lang.NewSymbol("list")) - if v29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v29))) - } - v30 := v29.Get() - v31 := lang.Apply(v30, []any{lang.NewSymbol("var"), v27}) - return v31 + tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp29 := tmp28.FindInternedVar(lang.NewSymbol("list")) + if tmp29.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) + } + tmp30 := tmp29.Get() + tmp31 := lang.Apply(tmp30, []any{lang.NewSymbol("var"), v27}) + return tmp31 }) - v27 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7555), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(7555), lang.NewKeyword("end-column"), int(47)) - v28, err := lang.WithMeta(v26, v27.(lang.IPersistentMap)) + tmp27 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7555), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(7555), lang.NewKeyword("end-column"), int(47)) + tmp28, err := lang.WithMeta(tmp26, tmp27.(lang.IPersistentMap)) if err != nil { panic(err) } - v29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v30 := v29.FindInternedVar(lang.NewSymbol("take-nth")) - if v30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v30))) - } - v31 := v30.Get() - v32 := lang.Apply(v31, []any{int64(2), v5}) - v33 := lang.Apply(v25, []any{v28, v32}) - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("take-nth")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) - } - v36 := v35.Get() - v37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v38 := v37.FindInternedVar(lang.NewSymbol("next")) - if v38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v38))) - } - v39 := v38.Get() - v40 := lang.Apply(v39, []any{v5}) - v41 := lang.Apply(v36, []any{int64(2), v40}) - v42 := lang.Apply(v22, []any{v33, v41}) - v43 := lang.Apply(v19, []any{v42}) - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("list")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) - } - v46 := v45.Get() - v47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v48 := v47.FindInternedVar(lang.NewSymbol("seq")) - if v48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v48))) - } - v49 := v48.Get() - v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v51 := v50.FindInternedVar(lang.NewSymbol("concat")) - if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) - } - v52 := v51.Get() - v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v54 := v53.FindInternedVar(lang.NewSymbol("list")) - if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) - } - v55 := v54.Get() - v56 := lang.Apply(v55, []any{lang.NewSymbol("glojure.core/fn")}) - v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v58 := v57.FindInternedVar(lang.NewSymbol("list")) - if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) - } - v59 := v58.Get() - v60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v61 := v60.FindInternedVar(lang.NewSymbol("apply")) - if v61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v61))) - } - v62 := v61.Get() - v63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v64 := v63.FindInternedVar(lang.NewSymbol("vector")) - if v64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v64))) - } - v65 := v64.Get() - v66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v67 := v66.FindInternedVar(lang.NewSymbol("seq")) - if v67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v67))) - } - v68 := v67.Get() - v69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v70 := v69.FindInternedVar(lang.NewSymbol("concat")) - if v70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v70))) - } - v71 := v70.Get() - v72 := lang.Apply(v71, nil) - v73 := lang.Apply(v68, []any{v72}) - v74 := lang.Apply(v62, []any{v65, v73}) - v75 := lang.Apply(v59, []any{v74}) - v76 := lang.Apply(v52, []any{v56, v75, v6}) - v77 := lang.Apply(v49, []any{v76}) - v78 := lang.Apply(v46, []any{v77}) - v79 := lang.Apply(v12, []any{v16, v43, v78}) - v80 := lang.Apply(v9, []any{v79}) - return v80 - } - }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp30 := tmp29.FindInternedVar(lang.NewSymbol("take-nth")) + if tmp30.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) + } + tmp31 := tmp30.Get() + tmp32 := lang.Apply(tmp31, []any{int64(2), v5}) + tmp33 := lang.Apply(tmp25, []any{tmp28, tmp32}) + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("take-nth")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp38 := tmp37.FindInternedVar(lang.NewSymbol("next")) + if tmp38.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) + } + tmp39 := tmp38.Get() + tmp40 := lang.Apply(tmp39, []any{v5}) + tmp41 := lang.Apply(tmp36, []any{int64(2), tmp40}) + tmp42 := lang.Apply(tmp22, []any{tmp33, tmp41}) + tmp43 := lang.Apply(tmp19, []any{tmp42}) + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) + } + tmp46 := tmp45.Get() + tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp48 := tmp47.FindInternedVar(lang.NewSymbol("seq")) + if tmp48.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) + } + tmp49 := tmp48.Get() + tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp51 := tmp50.FindInternedVar(lang.NewSymbol("concat")) + if tmp51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) + } + tmp52 := tmp51.Get() + tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp54 := tmp53.FindInternedVar(lang.NewSymbol("list")) + if tmp54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) + } + tmp55 := tmp54.Get() + tmp56 := lang.Apply(tmp55, []any{lang.NewSymbol("glojure.core/fn")}) + tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp58 := tmp57.FindInternedVar(lang.NewSymbol("list")) + if tmp58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) + } + tmp59 := tmp58.Get() + tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp61 := tmp60.FindInternedVar(lang.NewSymbol("apply")) + if tmp61.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) + } + tmp62 := tmp61.Get() + tmp63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp64 := tmp63.FindInternedVar(lang.NewSymbol("vector")) + if tmp64.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp64))) + } + tmp65 := tmp64.Get() + tmp66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp67 := tmp66.FindInternedVar(lang.NewSymbol("seq")) + if tmp67.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp67))) + } + tmp68 := tmp67.Get() + tmp69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp70 := tmp69.FindInternedVar(lang.NewSymbol("concat")) + if tmp70.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp70))) + } + tmp71 := tmp70.Get() + tmp72 := lang.Apply(tmp71, nil) + tmp73 := lang.Apply(tmp68, []any{tmp72}) + tmp74 := lang.Apply(tmp62, []any{tmp65, tmp73}) + tmp75 := lang.Apply(tmp59, []any{tmp74}) + tmp76 := lang.Apply(tmp52, []any{tmp56, tmp75, v6}) + tmp77 := lang.Apply(tmp49, []any{tmp76}) + tmp78 := lang.Apply(tmp46, []any{tmp77}) + tmp79 := lang.Apply(tmp12, []any{tmp16, tmp43, tmp78}) + tmp80 := lang.Apply(tmp9, []any{tmp79}) + return tmp80 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // with-redefs-fn { - v0 := lang.NewSymbol("with-redefs-fn").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("binding-map"), lang.NewSymbol("func"))), lang.NewKeyword("doc"), "Temporarily redefines Vars during a call to func. Each val of\n binding-map will replace the root value of its key which must be\n a Var. After func is called with no args, the root values of all\n the Vars will be set back to their old values. These temporary\n changes will be visible in all threads. Useful for mocking out\n functions during testing.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7524), lang.NewKeyword("end-line"), int(7524))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("with-redefs-fn").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("binding-map"), lang.NewSymbol("func"))), lang.NewKeyword("doc"), "Temporarily redefines Vars during a call to func. Each val of\n binding-map will replace the root value of its key which must be\n a Var. After func is called with no args, the root values of all\n the Vars will be set back to their old values. These temporary\n changes will be visible in all threads. Useful for mocking out\n functions during testing.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7524), lang.NewKeyword("end-line"), int(7524))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -86210,27 +86411,27 @@ func init() { _ = v3 v4 := args[1] _ = v4 - var v5 any + var tmp5 any { // let // let binding "root-bind" - var v6 lang.FnFunc - v6 = lang.NewFnFunc(func(args ...any) any { + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v7 := args[0] _ = v7 - var v8 any + var tmp8 any { // let // let binding "seq_326" - v9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v10 := v9.FindInternedVar(lang.NewSymbol("seq")) - if v10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v10))) - } - v11 := v10.Get() - v12 := lang.Apply(v11, []any{v7}) - var v13 any = v12 + tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp10 := tmp9.FindInternedVar(lang.NewSymbol("seq")) + if tmp10.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) + } + tmp11 := tmp10.Get() + tmp12 := lang.Apply(tmp11, []any{v7}) + var v13 any = tmp12 _ = v13 // let binding "chunk_327" var v14 any = nil @@ -86242,461 +86443,462 @@ func init() { var v16 any = int64(0) _ = v16 for { - var v17 any - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("<")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.Apply(v20, []any{v16, v15}) - if lang.IsTruthy(v21) { - var v22 any + var tmp17 any + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("<")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.Apply(tmp20, []any{v16, v15}) + if lang.IsTruthy(tmp21) { + var tmp22 any { // let // let binding "vec__330" - v23, _ := lang.FieldOrMethod(v14, "nth") - if reflect.TypeOf(v23).Kind() != reflect.Func { + tmp23, _ := lang.FieldOrMethod(v14, "nth") + if reflect.TypeOf(tmp23).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) } - v24 := lang.Apply(v23, []any{v16}) - var v25 any = v24 + tmp24 := lang.Apply(tmp23, []any{v16}) + var v25 any = tmp24 _ = v25 // let binding "a-var" - v26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v27 := v26.FindInternedVar(lang.NewSymbol("nth")) - if v27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v27))) + tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp27 := tmp26.FindInternedVar(lang.NewSymbol("nth")) + if tmp27.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) } - v28 := v27.Get() - v29 := lang.Apply(v28, []any{v25, int64(0), nil}) - var v30 any = v29 + tmp28 := tmp27.Get() + tmp29 := lang.Apply(tmp28, []any{v25, int64(0), nil}) + var v30 any = tmp29 _ = v30 // let binding "a-val" - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("nth")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("nth")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{v25, int64(1), nil}) - var v35 any = v34 + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{v25, int64(1), nil}) + var v35 any = tmp34 _ = v35 - v36, _ := lang.FieldOrMethod(v30, "bindRoot") - if reflect.TypeOf(v36).Kind() != reflect.Func { + tmp36, _ := lang.FieldOrMethod(v30, "bindRoot") + if reflect.TypeOf(tmp36).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("bindRoot is not a function"))) } - v37 := lang.Apply(v36, []any{v35}) - _ = v37 - var v38 any = v13 - var v39 any = v14 - var v40 any = v15 - v42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v43 := v42.FindInternedVar(lang.NewSymbol("unchecked-inc")) - if v43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v43))) + tmp37 := lang.Apply(tmp36, []any{v35}) + _ = tmp37 + var tmp38 any = v13 + var tmp39 any = v14 + var tmp40 any = v15 + tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp43 := tmp42.FindInternedVar(lang.NewSymbol("unchecked-inc")) + if tmp43.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) } - v44 := v43.Get() - v45 := lang.Apply(v44, []any{v16}) - var v41 any = v45 - v13 = v38 - v14 = v39 - v15 = v40 - v16 = v41 + tmp44 := tmp43.Get() + tmp45 := lang.Apply(tmp44, []any{v16}) + var tmp41 any = tmp45 + v13 = tmp38 + v14 = tmp39 + v15 = tmp40 + v16 = tmp41 continue } // end let - v17 = v22 + tmp17 = tmp22 } else { - var v23 any + var tmp23 any { // let // let binding "temp__0__auto__" - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("seq")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("seq")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) } - v26 := v25.Get() - v27 := lang.Apply(v26, []any{v13}) - var v28 any = v27 + tmp26 := tmp25.Get() + tmp27 := lang.Apply(tmp26, []any{v13}) + var v28 any = tmp27 _ = v28 - var v29 any + var tmp29 any if lang.IsTruthy(v28) { - var v30 any + var tmp30 any { // let // let binding "seq_326" var v31 any = v28 _ = v31 - var v32 any - v33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v34 := v33.FindInternedVar(lang.NewSymbol("chunked-seq?")) - if v34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v34))) + var tmp32 any + tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp34 := tmp33.FindInternedVar(lang.NewSymbol("chunked-seq?")) + if tmp34.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) } - v35 := v34.Get() - v36 := lang.Apply(v35, []any{v31}) - if lang.IsTruthy(v36) { - var v37 any + tmp35 := tmp34.Get() + tmp36 := lang.Apply(tmp35, []any{v31}) + if lang.IsTruthy(tmp36) { + var tmp37 any { // let // let binding "c__0__auto__" - v38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v39 := v38.FindInternedVar(lang.NewSymbol("chunk-first")) - if v39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v39))) + tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp39 := tmp38.FindInternedVar(lang.NewSymbol("chunk-first")) + if tmp39.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) } - v40 := v39.Get() - v41 := lang.Apply(v40, []any{v31}) - var v42 any = v41 + tmp40 := tmp39.Get() + tmp41 := lang.Apply(tmp40, []any{v31}) + var v42 any = tmp41 _ = v42 - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("chunk-rest")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("chunk-rest")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) } - v46 := v45.Get() - v47 := lang.Apply(v46, []any{v31}) - var v43 any = v47 - var v48 any = v42 - v50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v51 := v50.FindInternedVar(lang.NewSymbol("int")) - if v51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v51))) + tmp46 := tmp45.Get() + tmp47 := lang.Apply(tmp46, []any{v31}) + var tmp43 any = tmp47 + var tmp48 any = v42 + tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp51 := tmp50.FindInternedVar(lang.NewSymbol("int")) + if tmp51.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) } - v52 := v51.Get() - v53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v54 := v53.FindInternedVar(lang.NewSymbol("count")) - if v54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v54))) + tmp52 := tmp51.Get() + tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp54 := tmp53.FindInternedVar(lang.NewSymbol("count")) + if tmp54.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) } - v55 := v54.Get() - v56 := lang.Apply(v55, []any{v42}) - v57 := lang.Apply(v52, []any{v56}) - var v49 any = v57 - v59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v60 := v59.FindInternedVar(lang.NewSymbol("int")) - if v60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v60))) + tmp55 := tmp54.Get() + tmp56 := lang.Apply(tmp55, []any{v42}) + tmp57 := lang.Apply(tmp52, []any{tmp56}) + var tmp49 any = tmp57 + tmp59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp60 := tmp59.FindInternedVar(lang.NewSymbol("int")) + if tmp60.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp60))) } - v61 := v60.Get() - v62 := lang.Apply(v61, []any{int64(0)}) - var v58 any = v62 - v13 = v43 - v14 = v48 - v15 = v49 - v16 = v58 + tmp61 := tmp60.Get() + tmp62 := lang.Apply(tmp61, []any{int64(0)}) + var tmp58 any = tmp62 + v13 = tmp43 + v14 = tmp48 + v15 = tmp49 + v16 = tmp58 continue } // end let - v32 = v37 + tmp32 = tmp37 } else { - var v38 any + var tmp38 any { // let // let binding "vec__333" - v39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v40 := v39.FindInternedVar(lang.NewSymbol("first")) - if v40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v40))) + tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp40 := tmp39.FindInternedVar(lang.NewSymbol("first")) + if tmp40.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) } - v41 := v40.Get() - v42 := lang.Apply(v41, []any{v31}) - var v43 any = v42 + tmp41 := tmp40.Get() + tmp42 := lang.Apply(tmp41, []any{v31}) + var v43 any = tmp42 _ = v43 // let binding "a-var" - v44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v45 := v44.FindInternedVar(lang.NewSymbol("nth")) - if v45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v45))) + tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp45 := tmp44.FindInternedVar(lang.NewSymbol("nth")) + if tmp45.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) } - v46 := v45.Get() - v47 := lang.Apply(v46, []any{v43, int64(0), nil}) - var v48 any = v47 + tmp46 := tmp45.Get() + tmp47 := lang.Apply(tmp46, []any{v43, int64(0), nil}) + var v48 any = tmp47 _ = v48 // let binding "a-val" - v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v50 := v49.FindInternedVar(lang.NewSymbol("nth")) - if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) + tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp50 := tmp49.FindInternedVar(lang.NewSymbol("nth")) + if tmp50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) } - v51 := v50.Get() - v52 := lang.Apply(v51, []any{v43, int64(1), nil}) - var v53 any = v52 + tmp51 := tmp50.Get() + tmp52 := lang.Apply(tmp51, []any{v43, int64(1), nil}) + var v53 any = tmp52 _ = v53 - v54, _ := lang.FieldOrMethod(v48, "bindRoot") - if reflect.TypeOf(v54).Kind() != reflect.Func { + tmp54, _ := lang.FieldOrMethod(v48, "bindRoot") + if reflect.TypeOf(tmp54).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("bindRoot is not a function"))) } - v55 := lang.Apply(v54, []any{v53}) - _ = v55 - v57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v58 := v57.FindInternedVar(lang.NewSymbol("next")) - if v58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v58))) + tmp55 := lang.Apply(tmp54, []any{v53}) + _ = tmp55 + tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp58 := tmp57.FindInternedVar(lang.NewSymbol("next")) + if tmp58.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) } - v59 := v58.Get() - v60 := lang.Apply(v59, []any{v31}) - var v56 any = v60 - var v61 any = nil - var v62 any = int64(0) - var v63 any = int64(0) - v13 = v56 - v14 = v61 - v15 = v62 - v16 = v63 + tmp59 := tmp58.Get() + tmp60 := lang.Apply(tmp59, []any{v31}) + var tmp56 any = tmp60 + var tmp61 any = nil + var tmp62 any = int64(0) + var tmp63 any = int64(0) + v13 = tmp56 + v14 = tmp61 + v15 = tmp62 + v16 = tmp63 continue } // end let - v32 = v38 + tmp32 = tmp38 } - v30 = v32 + tmp30 = tmp32 } // end let - v29 = v30 + tmp29 = tmp30 } else { - v29 = nil } - v23 = v29 + tmp23 = tmp29 } // end let - v17 = v23 + tmp17 = tmp23 } - v8 = v17 + tmp8 = tmp17 break } } // end let - return v8 + return tmp8 }) - v7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7533), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(7535), lang.NewKeyword("end-column"), int(93)) - v8, err := lang.WithMeta(v6, v7.(lang.IPersistentMap)) + tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7533), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(7535), lang.NewKeyword("end-column"), int(93)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) if err != nil { panic(err) } - var v9 any = v8 + var v9 any = tmp8 _ = v9 // let binding "old-vals" - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("zipmap")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("keys")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.Apply(v15, []any{v3}) - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("map")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - var v20 lang.FnFunc - v20 = lang.NewFnFunc(func(args ...any) any { + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("zipmap")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("keys")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("map")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + var tmp20 lang.FnFunc + tmp20 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v21 := args[0] _ = v21 - v22, ok := lang.FieldOrMethod(v21, "getRawRoot") + tmp22, ok := lang.FieldOrMethod(v21, "getRawRoot") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v21, "getRawRoot"))) } - var v23 any - switch reflect.TypeOf(v22).Kind() { + var tmp23 any + switch reflect.TypeOf(tmp22).Kind() { case reflect.Func: - v23 = lang.Apply(v22, nil) + tmp23 = lang.Apply(tmp22, nil) default: - v23 = v22 + tmp23 = tmp22 } - return v23 + return tmp23 }) - v21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7537), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(7537), lang.NewKeyword("end-column"), int(92)) - v22, err := lang.WithMeta(v20, v21.(lang.IPersistentMap)) + tmp21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7537), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(7537), lang.NewKeyword("end-column"), int(92)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) if err != nil { panic(err) } - v23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v24 := v23.FindInternedVar(lang.NewSymbol("keys")) - if v24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v24))) + tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp24 := tmp23.FindInternedVar(lang.NewSymbol("keys")) + if tmp24.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) } - v25 := v24.Get() - v26 := lang.Apply(v25, []any{v3}) - v27 := lang.Apply(v19, []any{v22, v26}) - v28 := lang.Apply(v12, []any{v16, v27}) - var v29 any = v28 + tmp25 := tmp24.Get() + tmp26 := lang.Apply(tmp25, []any{v3}) + tmp27 := lang.Apply(tmp19, []any{tmp22, tmp26}) + tmp28 := lang.Apply(tmp12, []any{tmp16, tmp27}) + var v29 any = tmp28 _ = v29 - var v30 any + var tmp30 any func() { defer func() { - v31 := lang.Apply(v9, []any{v29}) + tmp31 := lang.Apply(v9, []any{v29}) + _ = tmp31 }() - v32 := lang.Apply(v9, []any{v3}) - _ = v32 - v33 := lang.Apply(v4, nil) - v30 = v33 + tmp32 := lang.Apply(v9, []any{v3}) + _ = tmp32 + tmp33 := lang.Apply(v4, nil) + tmp30 = tmp33 }() - v5 = v30 + tmp5 = tmp30 } // end let - return v5 + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // xml-seq { - v0 := lang.NewSymbol("xml-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("root"))), lang.NewKeyword("doc"), "A tree seq on the xml elements as per xml/parse", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4982), lang.NewKeyword("end-line"), int(4982))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("xml-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("root"))), lang.NewKeyword("doc"), "A tree seq on the xml elements as per xml/parse", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4982), lang.NewKeyword("end-line"), int(4982))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("tree-seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("complement")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("string?")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v9, []any{v12}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("comp")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("seq")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) - } - v19 := v18.Get() - v20 := lang.Apply(v16, []any{v19, lang.NewKeyword("content")}) - v21 := lang.Apply(v6, []any{v13, v20, v3}) - return v21 - }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("tree-seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("complement")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("string?")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp9, []any{tmp12}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("comp")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) + } + tmp19 := tmp18.Get() + tmp20 := lang.Apply(tmp16, []any{tmp19, lang.NewKeyword("content")}) + tmp21 := lang.Apply(tmp6, []any{tmp13, tmp20, v3}) + return tmp21 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // zero? { - var v1 lang.FnFunc + var tmp1 lang.FnFunc { // function zero?__inliner - v1 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("seq")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v8 := v7.FindInternedVar(lang.NewSymbol("concat")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v11 := v10.FindInternedVar(lang.NewSymbol("list")) - if v11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v11))) - } - v12 := v11.Get() - v13 := lang.Apply(v12, []any{lang.NewSymbol(".")}) - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("list")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - v18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v19 := v18.FindInternedVar(lang.NewSymbol("list")) - if v19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v19))) - } - v20 := v19.Get() - v21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v22 := v21.FindInternedVar(lang.NewSymbol("seq")) - if v22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v22))) - } - v23 := v22.Get() - v24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v25 := v24.FindInternedVar(lang.NewSymbol("concat")) - if v25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v25))) - } - v26 := v25.Get() - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("list")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.Apply(v29, []any{lang.NewSymbol("glojure.core/IsZero")}) - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("list")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.Apply(v33, []any{v3}) - v35 := lang.Apply(v26, []any{v30, v34}) - v36 := lang.Apply(v23, []any{v35}) - v37 := lang.Apply(v20, []any{v36}) - v38 := lang.Apply(v9, []any{v13, v17, v37}) - v39 := lang.Apply(v6, []any{v38}) - return v39 + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) + if tmp19.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) + } + tmp20 := tmp19.Get() + tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) + if tmp22.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) + } + tmp23 := tmp22.Get() + tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) + if tmp25.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) + } + tmp26 := tmp25.Get() + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/IsZero")}) + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.Apply(tmp33, []any{v3}) + tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) + tmp36 := lang.Apply(tmp23, []any{tmp35}) + tmp37 := lang.Apply(tmp20, []any{tmp36}) + tmp38 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp37}) + tmp39 := lang.Apply(tmp6, []any{tmp38}) + return tmp39 }) - v2 := v1 + v2 = tmp1 _ = v2 } - v0 := lang.NewSymbol("zero?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), v1, lang.NewKeyword("doc"), "Returns true if num is zero, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(860), lang.NewKeyword("end-line"), int(860))).(*lang.Symbol) - var v3 lang.FnFunc - v3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("zero?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns true if num is zero, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(860), lang.NewKeyword("end-line"), int(860))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v4 := args[0] _ = v4 - v5, _ := lang.FieldOrMethod(lang.Numbers, "IsZero") - if reflect.TypeOf(v5).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "IsZero") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("IsZero is not a function"))) } - v6 := lang.Apply(v5, []any{v4}) - return v6 + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 }) - v3 = v3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v2 := ns.InternWithValue(v0, v3, true) - if v0.Meta() != nil { - v2.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // zipmap { - v0 := lang.NewSymbol("zipmap").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("keys"), lang.NewSymbol("vals"))), lang.NewKeyword("doc"), "Returns a map with the keys mapped to the corresponding vals.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6583), lang.NewKeyword("end-line"), int(6583))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("zipmap").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("keys"), lang.NewSymbol("vals"))), lang.NewKeyword("doc"), "Returns a map with the keys mapped to the corresponding vals.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6583), lang.NewKeyword("end-line"), int(6583))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 2 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -86704,122 +86906,122 @@ func init() { _ = v3 v4 := args[1] _ = v4 - var v5 any + var tmp5 any { // let // let binding "map" - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("transient")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) - } - v8 := v7.Get() - v9 := lang.NewMap() - v10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6588), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(6588), lang.NewKeyword("end-column"), int(28)) - v11, err := lang.WithMeta(v9, v10.(lang.IPersistentMap)) + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("transient")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.NewMap() + tmp10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6588), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(6588), lang.NewKeyword("end-column"), int(28)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) if err != nil { panic(err) } - v12 := lang.Apply(v8, []any{v11}) - var v13 any = v12 + tmp12 := lang.Apply(tmp8, []any{tmp11}) + var v13 any = tmp12 _ = v13 // let binding "ks" - v14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v15 := v14.FindInternedVar(lang.NewSymbol("seq")) - if v15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v15))) - } - v16 := v15.Get() - v17 := lang.Apply(v16, []any{v3}) - var v18 any = v17 + tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("seq")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{v3}) + var v18 any = tmp17 _ = v18 // let binding "vs" - v19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v20 := v19.FindInternedVar(lang.NewSymbol("seq")) - if v20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v20))) - } - v21 := v20.Get() - v22 := lang.Apply(v21, []any{v4}) - var v23 any = v22 + tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp20 := tmp19.FindInternedVar(lang.NewSymbol("seq")) + if tmp20.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) + } + tmp21 := tmp20.Get() + tmp22 := lang.Apply(tmp21, []any{v4}) + var v23 any = tmp22 _ = v23 for { - var v24 any - var v25 any + var tmp24 any + var tmp25 any { // let // let binding "and__0__auto__" var v26 any = v18 _ = v26 - var v27 any + var tmp27 any if lang.IsTruthy(v26) { - v27 = v23 + tmp27 = v23 } else { - v27 = v26 + tmp27 = v26 } - v25 = v27 + tmp25 = tmp27 } // end let - if lang.IsTruthy(v25) { - v27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v28 := v27.FindInternedVar(lang.NewSymbol("assoc!")) - if v28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v28))) - } - v29 := v28.Get() - v30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v31 := v30.FindInternedVar(lang.NewSymbol("first")) - if v31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v31))) - } - v32 := v31.Get() - v33 := lang.Apply(v32, []any{v18}) - v34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v35 := v34.FindInternedVar(lang.NewSymbol("first")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) - } - v36 := v35.Get() - v37 := lang.Apply(v36, []any{v23}) - v38 := lang.Apply(v29, []any{v13, v33, v37}) - var v26 any = v38 - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("next")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) - } - v42 := v41.Get() - v43 := lang.Apply(v42, []any{v18}) - var v39 any = v43 - v45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v46 := v45.FindInternedVar(lang.NewSymbol("next")) - if v46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v46))) - } - v47 := v46.Get() - v48 := lang.Apply(v47, []any{v23}) - var v44 any = v48 - v13 = v26 - v18 = v39 - v23 = v44 + if lang.IsTruthy(tmp25) { + tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp28 := tmp27.FindInternedVar(lang.NewSymbol("assoc!")) + if tmp28.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) + } + tmp29 := tmp28.Get() + tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp31 := tmp30.FindInternedVar(lang.NewSymbol("first")) + if tmp31.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) + } + tmp32 := tmp31.Get() + tmp33 := lang.Apply(tmp32, []any{v18}) + tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("first")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.Apply(tmp36, []any{v23}) + tmp38 := lang.Apply(tmp29, []any{v13, tmp33, tmp37}) + var tmp26 any = tmp38 + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("next")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) + } + tmp42 := tmp41.Get() + tmp43 := lang.Apply(tmp42, []any{v18}) + var tmp39 any = tmp43 + tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp46 := tmp45.FindInternedVar(lang.NewSymbol("next")) + if tmp46.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) + } + tmp47 := tmp46.Get() + tmp48 := lang.Apply(tmp47, []any{v23}) + var tmp44 any = tmp48 + v13 = tmp26 + v18 = tmp39 + v23 = tmp44 continue } else { - v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v50 := v49.FindInternedVar(lang.NewSymbol("persistent!")) - if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) + tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp50 := tmp49.FindInternedVar(lang.NewSymbol("persistent!")) + if tmp50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) } - v51 := v50.Get() - v52 := lang.Apply(v51, []any{v13}) - v24 = v52 + tmp51 := tmp50.Get() + tmp52 := lang.Apply(tmp51, []any{v13}) + tmp24 = tmp52 } - v5 = v24 + tmp5 = tmp24 break } } // end let - return v5 + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } } diff --git a/pkg/codegen/testdata/codegen/test/def_simple.go b/pkg/codegen/testdata/codegen/test/def_simple.go index 854fe012..34f08016 100644 --- a/pkg/codegen/testdata/codegen/test/def_simple.go +++ b/pkg/codegen/testdata/codegen/test/def_simple.go @@ -14,10 +14,10 @@ func init() { _ = ns // foo { - v0 := lang.NewSymbol("foo").WithMeta(lang.NewMap()).(*lang.Symbol) - v1 := ns.Intern(v0) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp0 := lang.NewSymbol("foo").WithMeta(lang.NewMap()).(*lang.Symbol) + tmp1 := ns.Intern(tmp0) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } } diff --git a/pkg/codegen/testdata/codegen/test/fn_closure.go b/pkg/codegen/testdata/codegen/test/fn_closure.go index 6726df74..8467de01 100644 --- a/pkg/codegen/testdata/codegen/test/fn_closure.go +++ b/pkg/codegen/testdata/codegen/test/fn_closure.go @@ -15,8 +15,8 @@ func init() { } var closed1 any { - v0 := lang.NewAtom(int64(0)) - closed1 = v0 + tmp0 := lang.NewAtom(int64(0)) + closed1 = tmp0 } // reference fmt to avoid unused import error @@ -25,144 +25,144 @@ func init() { _ = ns // -main { - v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), lang.NewVector(int64(42), int64(1)), lang.NewKeyword("file"), "codegen/test/fn_closure.glj", lang.NewKeyword("line"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(13), lang.NewKeyword("end-column"), int(38), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.fn-closure")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), lang.NewVector(int64(42), int64(1)), lang.NewKeyword("file"), "codegen/test/fn_closure.glj", lang.NewKeyword("line"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(13), lang.NewKeyword("end-column"), int(38), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.fn-closure")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v3 := lang.FindNamespace(lang.NewSymbol("codegen.test.fn-closure")) - v4 := v3.FindInternedVar(lang.NewSymbol("inc-atom")) - if v4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) + tmp3 := lang.FindNamespace(lang.NewSymbol("codegen.test.fn-closure")) + tmp4 := tmp3.FindInternedVar(lang.NewSymbol("inc-atom")) + if tmp4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp4))) } - v5 := v4.Get() - v6 := lang.Apply(v5, nil) - _ = v6 - v7 := lang.FindNamespace(lang.NewSymbol("codegen.test.fn-closure")) - v8 := v7.FindInternedVar(lang.NewSymbol("closed")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + tmp5 := tmp4.Get() + tmp6 := lang.Apply(tmp5, nil) + _ = tmp6 + tmp7 := lang.FindNamespace(lang.NewSymbol("codegen.test.fn-closure")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("closed")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) } - v9 := v8.Get() - v10 := lang.Apply(v9, nil) - v11 := lang.FindNamespace(lang.NewSymbol("codegen.test.fn-closure")) - v12 := v11.FindInternedVar(lang.NewSymbol("get-atom")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp9, nil) + tmp11 := lang.FindNamespace(lang.NewSymbol("codegen.test.fn-closure")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("get-atom")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) } - v13 := v12.Get() - v14 := lang.Apply(v13, nil) - v15 := lang.NewVector(v10, v14) - v16 := lang.NewMap(lang.NewKeyword("file"), "codegen/test/fn_closure.glj", lang.NewKeyword("line"), int(15), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(16), lang.NewKeyword("end-column"), int(14)) - v17, err := lang.WithMeta(v15, v16.(lang.IPersistentMap)) + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, nil) + tmp15 := lang.NewVector(tmp10, tmp14) + tmp16 := lang.NewMap(lang.NewKeyword("file"), "codegen/test/fn_closure.glj", lang.NewKeyword("line"), int(15), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(16), lang.NewKeyword("end-column"), int(14)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) if err != nil { panic(err) } - return v17 + return tmp17 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // closed { - v0 := lang.NewSymbol("closed").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/fn_closure.glj", lang.NewKeyword("line"), int(5), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(5), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.fn-closure")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("closed").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/fn_closure.glj", lang.NewKeyword("line"), int(5), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(5), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.fn-closure")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } return closed0 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/fn_closure.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(49))).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/fn_closure.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(49))).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // gen-closure { - v0 := lang.NewSymbol("gen-closure").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/fn_closure.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("the-result"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.fn-closure")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("gen-closure").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/fn_closure.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("the-result"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.fn-closure")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 lang.FnFunc - v4 = lang.NewFnFunc(func(args ...any) any { + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } return v3 }) - v5 := lang.NewMap(lang.NewKeyword("file"), "codegen/test/fn_closure.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(49)) - v6, err := lang.WithMeta(v4, v5.(lang.IPersistentMap)) + tmp5 := lang.NewMap(lang.NewKeyword("file"), "codegen/test/fn_closure.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(49)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) if err != nil { panic(err) } - return v6 + return tmp6 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // get-atom { - v0 := lang.NewSymbol("get-atom").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/fn_closure.glj", lang.NewKeyword("line"), int(10), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(10), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.fn-closure")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("get-atom").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/fn_closure.glj", lang.NewKeyword("line"), int(10), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(10), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.fn-closure")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v4 := v3.FindInternedVar(lang.NewSymbol("deref")) - if v4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) + tmp3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp4 := tmp3.FindInternedVar(lang.NewSymbol("deref")) + if tmp4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp4))) } - v5 := v4.Get() - v6 := lang.Apply(v5, []any{closed1}) - return v6 + tmp5 := tmp4.Get() + tmp6 := lang.Apply(tmp5, []any{closed1}) + return tmp6 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // inc-atom { - v0 := lang.NewSymbol("inc-atom").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/fn_closure.glj", lang.NewKeyword("line"), int(8), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(8), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.fn-closure")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("inc-atom").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/fn_closure.glj", lang.NewKeyword("line"), int(8), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(8), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.fn-closure")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v4 := v3.FindInternedVar(lang.NewSymbol("swap!")) - if v4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) + tmp3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp4 := tmp3.FindInternedVar(lang.NewSymbol("swap!")) + if tmp4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp4))) } - v5 := v4.Get() - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("inc")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + tmp5 := tmp4.Get() + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("inc")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) } - v8 := v7.Get() - v9 := lang.Apply(v5, []any{closed1, v8}) - return v9 + tmp8 := tmp7.Get() + tmp9 := lang.Apply(tmp5, []any{closed1, tmp8}) + return tmp9 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } } diff --git a/pkg/codegen/testdata/codegen/test/fn_recur.go b/pkg/codegen/testdata/codegen/test/fn_recur.go index bbfdff3c..bf04077f 100644 --- a/pkg/codegen/testdata/codegen/test/fn_recur.go +++ b/pkg/codegen/testdata/codegen/test/fn_recur.go @@ -14,43 +14,44 @@ func init() { _ = ns // -main { - v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), int64(55), lang.NewKeyword("file"), "codegen/test/fn_recur.glj", lang.NewKeyword("line"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(12), lang.NewKeyword("end-column"), int(34), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.fn-recur")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), int64(55), lang.NewKeyword("file"), "codegen/test/fn_recur.glj", lang.NewKeyword("line"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(12), lang.NewKeyword("end-column"), int(34), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.fn-recur")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v3 := lang.FindNamespace(lang.NewSymbol("codegen.test.fn-recur")) - v4 := v3.FindInternedVar(lang.NewSymbol("fib")) - if v4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) + tmp3 := lang.FindNamespace(lang.NewSymbol("codegen.test.fn-recur")) + tmp4 := tmp3.FindInternedVar(lang.NewSymbol("fib")) + if tmp4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp4))) } - v5 := v4.Get() - v6 := lang.Apply(v5, []any{int64(10)}) - return v6 + tmp5 := tmp4.Get() + tmp6 := lang.Apply(tmp5, []any{int64(10)}) + return tmp6 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // fib { - v0 := lang.NewSymbol("fib").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/fn_recur.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Calculates the nth Fibonacci number using iteration with recur.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.fn-recur")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("fib").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/fn_recur.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Calculates the nth Fibonacci number using iteration with recur.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.fn-recur")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 1 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } v3 := args[0] _ = v3 - var v4 any + var tmp4 any { // let // let binding "fib-helper" - var v5 lang.FnFunc + var tmp5 lang.FnFunc { // function fib-helper - v5 = lang.NewFnFunc(func(args ...any) any { + var v6 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { if len(args) != 3 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } @@ -61,60 +62,60 @@ func init() { v9 := args[2] _ = v9 recur_loop_1612: - var v10 any - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("=")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + var tmp10 any + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("=")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{v9, v3}) - if lang.IsTruthy(v14) { - v10 = v7 + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{v9, v3}) + if lang.IsTruthy(tmp14) { + tmp10 = v7 } else { - var v15 any = v8 - v17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v18 := v17.FindInternedVar(lang.NewSymbol("+")) - if v18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v18))) + var tmp15 any = v8 + tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp18 := tmp17.FindInternedVar(lang.NewSymbol("+")) + if tmp18.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) } - v19 := v18.Get() - v20 := lang.Apply(v19, []any{v7, v8}) - var v16 any = v20 - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("inc")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + tmp19 := tmp18.Get() + tmp20 := lang.Apply(tmp19, []any{v7, v8}) + var tmp16 any = tmp20 + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("inc")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) } - v24 := v23.Get() - v25 := lang.Apply(v24, []any{v9}) - var v21 any = v25 - v7 = v15 - v8 = v16 - v9 = v21 + tmp24 := tmp23.Get() + tmp25 := lang.Apply(tmp24, []any{v9}) + var tmp21 any = tmp25 + v7 = tmp15 + v8 = tmp16 + v9 = tmp21 goto recur_loop_1612 } - return v10 + return tmp10 }) - v6 := v5 + v6 = tmp5 _ = v6 } - v6 := lang.NewMap(lang.NewKeyword("file"), "codegen/test/fn_recur.glj", lang.NewKeyword("line"), int(6), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(9), lang.NewKeyword("end-column"), int(50)) - v7, err := lang.WithMeta(v5, v6.(lang.IPersistentMap)) + tmp6 := lang.NewMap(lang.NewKeyword("file"), "codegen/test/fn_recur.glj", lang.NewKeyword("line"), int(6), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(9), lang.NewKeyword("end-column"), int(50)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) if err != nil { panic(err) } - var v8 any = v7 + var v8 any = tmp7 _ = v8 - v9 := lang.Apply(v8, []any{int64(0), int64(1), int64(0)}) - v4 = v9 + tmp9 := lang.Apply(v8, []any{int64(0), int64(1), int64(0)}) + tmp4 = tmp9 } // end let - return v4 + return tmp4 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } } diff --git a/pkg/codegen/testdata/codegen/test/loop_simple.go b/pkg/codegen/testdata/codegen/test/loop_simple.go index 14641a34..ae4aef2d 100644 --- a/pkg/codegen/testdata/codegen/test/loop_simple.go +++ b/pkg/codegen/testdata/codegen/test/loop_simple.go @@ -14,73 +14,73 @@ func init() { _ = ns // -main { - v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), int64(10), lang.NewKeyword("file"), "codegen/test/loop_simple.glj", lang.NewKeyword("line"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(10), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.loop-simple")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), int64(10), lang.NewKeyword("file"), "codegen/test/loop_simple.glj", lang.NewKeyword("line"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(10), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.loop-simple")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v3 := lang.FindNamespace(lang.NewSymbol("codegen.test.loop-simple")) - v4 := v3.FindInternedVar(lang.NewSymbol("simple-loop")) - if v4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) + tmp3 := lang.FindNamespace(lang.NewSymbol("codegen.test.loop-simple")) + tmp4 := tmp3.FindInternedVar(lang.NewSymbol("simple-loop")) + if tmp4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp4))) } - v5 := v4.Get() - v6 := lang.Apply(v5, nil) - return v6 + tmp5 := tmp4.Get() + tmp6 := lang.Apply(tmp5, nil) + return tmp6 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // simple-loop { - v0 := lang.NewSymbol("simple-loop").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/loop_simple.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.loop-simple")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("simple-loop").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/loop_simple.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.loop-simple")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - var v3 any + var tmp3 any { // let // let binding "i" var v4 any = int64(0) _ = v4 for { - var v5 any - v6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v7 := v6.FindInternedVar(lang.NewSymbol("<")) - if v7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v7))) + var tmp5 any + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("<")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) } - v8 := v7.Get() - v9 := lang.Apply(v8, []any{v4, int64(10)}) - if lang.IsTruthy(v9) { - v11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v12 := v11.FindInternedVar(lang.NewSymbol("inc")) - if v12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v12))) + tmp8 := tmp7.Get() + tmp9 := lang.Apply(tmp8, []any{v4, int64(10)}) + if lang.IsTruthy(tmp9) { + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("inc")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) } - v13 := v12.Get() - v14 := lang.Apply(v13, []any{v4}) - var v10 any = v14 - v4 = v10 + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{v4}) + var tmp10 any = tmp14 + v4 = tmp10 continue } else { - v5 = v4 + tmp5 = v4 } - v3 = v5 + tmp3 = tmp5 break } } // end let - return v3 + return tmp3 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } } diff --git a/pkg/codegen/testdata/codegen/test/maybe_class.go b/pkg/codegen/testdata/codegen/test/maybe_class.go index e66462e6..fedb603c 100644 --- a/pkg/codegen/testdata/codegen/test/maybe_class.go +++ b/pkg/codegen/testdata/codegen/test/maybe_class.go @@ -15,26 +15,26 @@ func init() { _ = ns // -main { - v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), lang.NewVector("1", "2", "3"), lang.NewKeyword("file"), "codegen/test/maybe_class.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(45), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.maybe-class")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), lang.NewVector("1", "2", "3"), lang.NewKeyword("file"), "codegen/test/maybe_class.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(45), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.maybe-class")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v4 := v3.FindInternedVar(lang.NewSymbol("vec")) - if v4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) + tmp3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp4 := tmp3.FindInternedVar(lang.NewSymbol("vec")) + if tmp4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp4))) } - v5 := v4.Get() - v6 := lang.Apply(strings2.Split, []any{"1,2,3", ","}) - v7 := lang.Apply(v5, []any{v6}) - return v7 + tmp5 := tmp4.Get() + tmp6 := lang.Apply(strings2.Split, []any{"1,2,3", ","}) + tmp7 := lang.Apply(tmp5, []any{tmp6}) + return tmp7 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } } diff --git a/pkg/codegen/testdata/codegen/test/multifn.glj b/pkg/codegen/testdata/codegen/test/multifn.glj new file mode 100644 index 00000000..b01af278 --- /dev/null +++ b/pkg/codegen/testdata/codegen/test/multifn.glj @@ -0,0 +1,9 @@ +(ns codegen.test.multifn) + +(defmulti add "a multimethod for addition" (fn [a b] (type a))) +(defmethod add go/int64 [a b] (str "int64: " (+ a b))) +(defmethod add go/float64 [a b] (str "float64: " (+ a b))) +(defmethod add :default [a b] (str "default: " a " " b)) + +(defn ^{:expected-output "int64: 7 float64: 8.0 default: 3 4"} -main [] + (str (add 3 4) " " (add 3.5 4.5) " " (add "3" "4"))) diff --git a/pkg/codegen/testdata/codegen/test/quote_simple.go b/pkg/codegen/testdata/codegen/test/quote_simple.go index ad0d5a66..dc973b58 100644 --- a/pkg/codegen/testdata/codegen/test/quote_simple.go +++ b/pkg/codegen/testdata/codegen/test/quote_simple.go @@ -14,18 +14,18 @@ func init() { _ = ns // -main { - v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), lang.NewList(int64(1), int64(2), int64(3)), lang.NewKeyword("file"), "codegen/test/quote_simple.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(44), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.quote-simple")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), lang.NewList(int64(1), int64(2), int64(3)), lang.NewKeyword("file"), "codegen/test/quote_simple.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(44), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.quote-simple")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } return lang.NewList(int64(1), int64(2), int64(3)) }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } } diff --git a/pkg/codegen/testdata/codegen/test/ref.glj b/pkg/codegen/testdata/codegen/test/ref.glj new file mode 100644 index 00000000..df4cbe42 --- /dev/null +++ b/pkg/codegen/testdata/codegen/test/ref.glj @@ -0,0 +1,10 @@ +(ns codegen.test.ref) + +(def test-ref + "A reference to a set." + (ref #{1 2 3})) + +(defn + ^{:expected-output #{1 2 3}} + -main [] + @test-ref) diff --git a/pkg/codegen/testdata/codegen/test/ref.go b/pkg/codegen/testdata/codegen/test/ref.go new file mode 100644 index 00000000..f011bf0d --- /dev/null +++ b/pkg/codegen/testdata/codegen/test/ref.go @@ -0,0 +1,53 @@ +// Code generated by glojure codegen. DO NOT EDIT. + +package generated + +import ( + fmt "fmt" + lang "github.com/glojurelang/glojure/pkg/lang" +) + +func init() { + // reference fmt to avoid unused import error + _ = fmt.Printf + ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.ref")) + _ = ns + // -main + { + tmp0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2), int64(3)})), lang.NewKeyword("file"), "codegen/test/ref.glj", lang.NewKeyword("line"), int(8), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(9), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.ref")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + tmp3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp4 := tmp3.FindInternedVar(lang.NewSymbol("deref")) + if tmp4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp4))) + } + tmp5 := tmp4.Get() + tmp6 := lang.FindNamespace(lang.NewSymbol("codegen.test.ref")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("test-ref")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.Apply(tmp5, []any{tmp8}) + return tmp9 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // test-ref + { + tmp0 := lang.NewSymbol("test-ref").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/ref.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("doc"), "A reference to a set.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.ref")))).(*lang.Symbol) + tmp2 := lang.NewRef(lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2), int64(3)}))) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } +} diff --git a/pkg/codegen/testdata/codegen/test/the_var.go b/pkg/codegen/testdata/codegen/test/the_var.go index 7657f608..f2674402 100644 --- a/pkg/codegen/testdata/codegen/test/the_var.go +++ b/pkg/codegen/testdata/codegen/test/the_var.go @@ -15,38 +15,38 @@ func init() { _ = ns // -main { - v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), int64(42), lang.NewKeyword("file"), "codegen/test/the_var.glj", lang.NewKeyword("line"), int(5), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(5), lang.NewKeyword("end-column"), int(34), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.the-var")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), int64(42), lang.NewKeyword("file"), "codegen/test/the_var.glj", lang.NewKeyword("line"), int(5), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(5), lang.NewKeyword("end-column"), int(34), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.the-var")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v3 := lang.InternVarName(lang.NewSymbol("codegen.test.the-var"), lang.NewSymbol("foo")) - v4, ok := lang.FieldOrMethod(v3, "get") + tmp3 := lang.InternVarName(lang.NewSymbol("codegen.test.the-var"), lang.NewSymbol("foo")) + tmp4, ok := lang.FieldOrMethod(tmp3, "get") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "get"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp3, "get"))) } - var v5 any - switch reflect.TypeOf(v4).Kind() { + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { case reflect.Func: - v5 = lang.Apply(v4, nil) + tmp5 = lang.Apply(tmp4, nil) default: - v5 = v4 + tmp5 = tmp4 } - return v5 + return tmp5 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // foo { - v0 := lang.NewSymbol("foo").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/the_var.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.the-var")))).(*lang.Symbol) - v1 := ns.InternWithValue(v0, int64(42), true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp0 := lang.NewSymbol("foo").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/the_var.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.the-var")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, int64(42), true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } } diff --git a/pkg/codegen/testdata/codegen/test/throw_simple.go b/pkg/codegen/testdata/codegen/test/throw_simple.go index b7d50246..438ebc6c 100644 --- a/pkg/codegen/testdata/codegen/test/throw_simple.go +++ b/pkg/codegen/testdata/codegen/test/throw_simple.go @@ -14,18 +14,18 @@ func init() { _ = ns // -main { - v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-throw"), "uncaught error", lang.NewKeyword("file"), "codegen/test/throw_simple.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(47), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.throw-simple")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-throw"), "uncaught error", lang.NewKeyword("file"), "codegen/test/throw_simple.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(47), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.throw-simple")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } panic("uncaught error") }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } } diff --git a/pkg/codegen/testdata/codegen/test/try_advanced.go b/pkg/codegen/testdata/codegen/test/try_advanced.go index a5de465c..b2ef24a8 100644 --- a/pkg/codegen/testdata/codegen/test/try_advanced.go +++ b/pkg/codegen/testdata/codegen/test/try_advanced.go @@ -14,125 +14,121 @@ func init() { _ = ns // -main { - v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), "advanced tests passed", lang.NewKeyword("file"), "codegen/test/try_advanced.glj", lang.NewKeyword("line"), int(30), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(30), lang.NewKeyword("end-column"), int(55), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-advanced")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), "advanced tests passed", lang.NewKeyword("file"), "codegen/test/try_advanced.glj", lang.NewKeyword("line"), int(30), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(30), lang.NewKeyword("end-column"), int(55), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-advanced")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - var v3 any - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("=")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) - } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("codegen.test.try-advanced")) - v8 := v7.FindInternedVar(lang.NewSymbol("try-custom-value")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) - } - v9 := v8.Get() - v10 := lang.Apply(v9, nil) - v11 := lang.Apply(v6, []any{v10, "custom error"}) - if lang.IsTruthy(v11) { - v3 = nil + var tmp3 any + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("=")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) + } + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("codegen.test.try-advanced")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("try-custom-value")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) + } + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp9, nil) + tmp11 := lang.Apply(tmp6, []any{tmp10, "custom error"}) + if lang.IsTruthy(tmp11) { } else { panic("try-custom-value failed") } - _ = v3 - var v12 any - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("=")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) - } - v15 := v14.Get() - v16 := lang.FindNamespace(lang.NewSymbol("codegen.test.try-advanced")) - v17 := v16.FindInternedVar(lang.NewSymbol("catch-binding-scope")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) - } - v18 := v17.Get() - v19 := lang.Apply(v18, nil) - v20 := lang.Apply(v15, []any{v19, "test"}) - if lang.IsTruthy(v20) { - v12 = nil + _ = tmp3 + var tmp12 any + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("=")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.FindNamespace(lang.NewSymbol("codegen.test.try-advanced")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("catch-binding-scope")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) + } + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, nil) + tmp20 := lang.Apply(tmp15, []any{tmp19, "test"}) + if lang.IsTruthy(tmp20) { } else { panic("catch-binding-scope failed") } - _ = v12 - var v21 any - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("=")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) - } - v24 := v23.Get() - v25 := lang.FindNamespace(lang.NewSymbol("codegen.test.try-advanced")) - v26 := v25.FindInternedVar(lang.NewSymbol("catch-binding-scope-2")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) - } - v27 := v26.Get() - v28 := lang.Apply(v27, nil) - v29 := lang.Apply(v24, []any{v28, "outer"}) - if lang.IsTruthy(v29) { - v21 = nil + _ = tmp12 + var tmp21 any + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("=")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) + } + tmp24 := tmp23.Get() + tmp25 := lang.FindNamespace(lang.NewSymbol("codegen.test.try-advanced")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("catch-binding-scope-2")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) + } + tmp27 := tmp26.Get() + tmp28 := lang.Apply(tmp27, nil) + tmp29 := lang.Apply(tmp24, []any{tmp28, "outer"}) + if lang.IsTruthy(tmp29) { } else { panic("catch-binding-scope-2 failed") } - _ = v21 - var v30 any - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("=")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) - } - v33 := v32.Get() - v34 := lang.FindNamespace(lang.NewSymbol("codegen.test.try-advanced")) - v35 := v34.FindInternedVar(lang.NewSymbol("finally-with-return")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) - } - v36 := v35.Get() - v37 := lang.Apply(v36, nil) - v38 := lang.Apply(v33, []any{v37, int64(42)}) - if lang.IsTruthy(v38) { - v30 = nil + _ = tmp21 + var tmp30 any + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("=")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) + } + tmp33 := tmp32.Get() + tmp34 := lang.FindNamespace(lang.NewSymbol("codegen.test.try-advanced")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("finally-with-return")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) + } + tmp36 := tmp35.Get() + tmp37 := lang.Apply(tmp36, nil) + tmp38 := lang.Apply(tmp33, []any{tmp37, int64(42)}) + if lang.IsTruthy(tmp38) { } else { panic("finally-with-return failed") } - _ = v30 + _ = tmp30 return "advanced tests passed" }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // catch-binding-scope { - v0 := lang.NewSymbol("catch-binding-scope").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_advanced.glj", lang.NewKeyword("line"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(9), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-advanced")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("catch-binding-scope").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_advanced.glj", lang.NewKeyword("line"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(9), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-advanced")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - var v3 any + var tmp3 any { // let // let binding "e" var v4 any = "outer" _ = v4 - var v5 any + var tmp5 any func() { defer func() { if r := recover(); r != nil { if lang.CatchMatches(r, lang.Builtins["any"]) { v6 := r _ = v6 - v5 = v6 + tmp5 = v6 } else { panic(r) } @@ -140,37 +136,37 @@ func init() { }() panic("test") }() - v3 = v5 + tmp3 = tmp5 } // end let - return v3 + return tmp3 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // catch-binding-scope-2 { - v0 := lang.NewSymbol("catch-binding-scope-2").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_advanced.glj", lang.NewKeyword("line"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(16), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-advanced")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("catch-binding-scope-2").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_advanced.glj", lang.NewKeyword("line"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(16), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-advanced")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - var v3 any + var tmp3 any { // let // let binding "e" var v4 any = "outer" _ = v4 - var v5 any + var tmp5 any func() { defer func() { if r := recover(); r != nil { if lang.CatchMatches(r, lang.Builtins["any"]) { v6 := r _ = v6 - v5 = v6 + tmp5 = v6 } else { panic(r) } @@ -178,55 +174,56 @@ func init() { }() panic("test") }() - _ = v5 - v3 = v4 + _ = tmp5 + tmp3 = v4 } // end let - return v3 + return tmp3 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // finally-with-return { - v0 := lang.NewSymbol("finally-with-return").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_advanced.glj", lang.NewKeyword("line"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(24), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-advanced")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("finally-with-return").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_advanced.glj", lang.NewKeyword("line"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(24), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-advanced")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - var v3 any + var tmp3 any func() { defer func() { + _ = int64(100) }() - v3 = int64(42) + tmp3 = int64(42) }() - return v3 + return tmp3 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // try-custom-value { - v0 := lang.NewSymbol("try-custom-value").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_advanced.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-advanced")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("try-custom-value").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_advanced.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-advanced")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - var v3 any + var tmp3 any func() { defer func() { if r := recover(); r != nil { if lang.CatchMatches(r, lang.Builtins["any"]) { v4 := r _ = v4 - v3 = v4 + tmp3 = v4 } else { panic(r) } @@ -234,12 +231,12 @@ func init() { }() panic("custom error") }() - return v3 + return tmp3 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } } diff --git a/pkg/codegen/testdata/codegen/test/try_basic.go b/pkg/codegen/testdata/codegen/test/try_basic.go index 81d9d9cf..be1f2f36 100644 --- a/pkg/codegen/testdata/codegen/test/try_basic.go +++ b/pkg/codegen/testdata/codegen/test/try_basic.go @@ -14,206 +14,200 @@ func init() { _ = ns // -main { - v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), "all tests passed", lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(43), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(43), lang.NewKeyword("end-column"), int(50), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), "all tests passed", lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(43), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(43), lang.NewKeyword("end-column"), int(50), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - var v3 any - v4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v5 := v4.FindInternedVar(lang.NewSymbol("=")) - if v5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v5))) + var tmp3 any + tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp5 := tmp4.FindInternedVar(lang.NewSymbol("=")) + if tmp5.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) } - v6 := v5.Get() - v7 := lang.FindNamespace(lang.NewSymbol("codegen.test.try-basic")) - v8 := v7.FindInternedVar(lang.NewSymbol("basic-try")) - if v8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v8))) + tmp6 := tmp5.Get() + tmp7 := lang.FindNamespace(lang.NewSymbol("codegen.test.try-basic")) + tmp8 := tmp7.FindInternedVar(lang.NewSymbol("basic-try")) + if tmp8.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) } - v9 := v8.Get() - v10 := lang.Apply(v9, nil) - v11 := lang.Apply(v6, []any{v10, "success"}) - if lang.IsTruthy(v11) { - v3 = nil + tmp9 := tmp8.Get() + tmp10 := lang.Apply(tmp9, nil) + tmp11 := lang.Apply(tmp6, []any{tmp10, "success"}) + if lang.IsTruthy(tmp11) { } else { panic("basic-try failed") } - _ = v3 - var v12 any - v13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v14 := v13.FindInternedVar(lang.NewSymbol("=")) - if v14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v14))) + _ = tmp3 + var tmp12 any + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("=")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) } - v15 := v14.Get() - v16 := lang.FindNamespace(lang.NewSymbol("codegen.test.try-basic")) - v17 := v16.FindInternedVar(lang.NewSymbol("try-with-throw")) - if v17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v17))) + tmp15 := tmp14.Get() + tmp16 := lang.FindNamespace(lang.NewSymbol("codegen.test.try-basic")) + tmp17 := tmp16.FindInternedVar(lang.NewSymbol("try-with-throw")) + if tmp17.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) } - v18 := v17.Get() - v19 := lang.Apply(v18, nil) - v20 := lang.Apply(v15, []any{v19, "caught exception"}) - if lang.IsTruthy(v20) { - v12 = nil + tmp18 := tmp17.Get() + tmp19 := lang.Apply(tmp18, nil) + tmp20 := lang.Apply(tmp15, []any{tmp19, "caught exception"}) + if lang.IsTruthy(tmp20) { } else { panic("try-with-throw failed") } - _ = v12 - var v21 any - v22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v23 := v22.FindInternedVar(lang.NewSymbol("=")) - if v23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v23))) + _ = tmp12 + var tmp21 any + tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp23 := tmp22.FindInternedVar(lang.NewSymbol("=")) + if tmp23.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) } - v24 := v23.Get() - v25 := lang.FindNamespace(lang.NewSymbol("codegen.test.try-basic")) - v26 := v25.FindInternedVar(lang.NewSymbol("try-no-catch")) - if v26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v26))) + tmp24 := tmp23.Get() + tmp25 := lang.FindNamespace(lang.NewSymbol("codegen.test.try-basic")) + tmp26 := tmp25.FindInternedVar(lang.NewSymbol("try-no-catch")) + if tmp26.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) } - v27 := v26.Get() - v28 := lang.Apply(v27, nil) - v29 := lang.Apply(v24, []any{v28, "just body"}) - if lang.IsTruthy(v29) { - v21 = nil + tmp27 := tmp26.Get() + tmp28 := lang.Apply(tmp27, nil) + tmp29 := lang.Apply(tmp24, []any{tmp28, "just body"}) + if lang.IsTruthy(tmp29) { } else { panic("try-no-catch failed") } - _ = v21 - var v30 any - v31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v32 := v31.FindInternedVar(lang.NewSymbol("=")) - if v32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v32))) + _ = tmp21 + var tmp30 any + tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp32 := tmp31.FindInternedVar(lang.NewSymbol("=")) + if tmp32.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) } - v33 := v32.Get() - v34 := lang.FindNamespace(lang.NewSymbol("codegen.test.try-basic")) - v35 := v34.FindInternedVar(lang.NewSymbol("try-finally-only")) - if v35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v35))) + tmp33 := tmp32.Get() + tmp34 := lang.FindNamespace(lang.NewSymbol("codegen.test.try-basic")) + tmp35 := tmp34.FindInternedVar(lang.NewSymbol("try-finally-only")) + if tmp35.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) } - v36 := v35.Get() - v37 := lang.Apply(v36, nil) - v38 := lang.Apply(v33, []any{v37, "body"}) - if lang.IsTruthy(v38) { - v30 = nil + tmp36 := tmp35.Get() + tmp37 := lang.Apply(tmp36, nil) + tmp38 := lang.Apply(tmp33, []any{tmp37, "body"}) + if lang.IsTruthy(tmp38) { } else { panic("try-finally-only failed") } - _ = v30 - var v39 any - v40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v41 := v40.FindInternedVar(lang.NewSymbol("=")) - if v41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v41))) + _ = tmp30 + var tmp39 any + tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp41 := tmp40.FindInternedVar(lang.NewSymbol("=")) + if tmp41.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) } - v42 := v41.Get() - v43 := lang.FindNamespace(lang.NewSymbol("codegen.test.try-basic")) - v44 := v43.FindInternedVar(lang.NewSymbol("try-catch-finally")) - if v44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v44))) + tmp42 := tmp41.Get() + tmp43 := lang.FindNamespace(lang.NewSymbol("codegen.test.try-basic")) + tmp44 := tmp43.FindInternedVar(lang.NewSymbol("try-catch-finally")) + if tmp44.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) } - v45 := v44.Get() - v46 := lang.Apply(v45, nil) - v47 := lang.Apply(v42, []any{v46, "caught"}) - if lang.IsTruthy(v47) { - v39 = nil + tmp45 := tmp44.Get() + tmp46 := lang.Apply(tmp45, nil) + tmp47 := lang.Apply(tmp42, []any{tmp46, "caught"}) + if lang.IsTruthy(tmp47) { } else { panic("try-catch-finally failed") } - _ = v39 - var v48 any - v49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v50 := v49.FindInternedVar(lang.NewSymbol("=")) - if v50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v50))) + _ = tmp39 + var tmp48 any + tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp50 := tmp49.FindInternedVar(lang.NewSymbol("=")) + if tmp50.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) } - v51 := v50.Get() - v52 := lang.FindNamespace(lang.NewSymbol("codegen.test.try-basic")) - v53 := v52.FindInternedVar(lang.NewSymbol("nested-try")) - if v53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v53))) + tmp51 := tmp50.Get() + tmp52 := lang.FindNamespace(lang.NewSymbol("codegen.test.try-basic")) + tmp53 := tmp52.FindInternedVar(lang.NewSymbol("nested-try")) + if tmp53.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp53))) } - v54 := v53.Get() - v55 := lang.Apply(v54, nil) - v56 := lang.Apply(v51, []any{v55, "inner caught"}) - if lang.IsTruthy(v56) { - v48 = nil + tmp54 := tmp53.Get() + tmp55 := lang.Apply(tmp54, nil) + tmp56 := lang.Apply(tmp51, []any{tmp55, "inner caught"}) + if lang.IsTruthy(tmp56) { } else { panic("nested-try failed") } - _ = v48 + _ = tmp48 return "all tests passed" }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // basic-try { - v0 := lang.NewSymbol("basic-try").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("basic-try").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - var v3 any + var tmp3 any func() { defer func() { if r := recover(); r != nil { if lang.CatchMatches(r, lang.Builtins["any"]) { v4 := r _ = v4 - v3 = "caught" + tmp3 = "caught" } else { panic(r) } } }() - v3 = "success" + tmp3 = "success" }() - return v3 + return tmp3 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // nested-try { - v0 := lang.NewSymbol("nested-try").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(34), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(34), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("nested-try").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(34), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(34), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - var v3 any + var tmp3 any func() { defer func() { if r := recover(); r != nil { if lang.CatchMatches(r, lang.Builtins["any"]) { v4 := r _ = v4 - v3 = "outer caught" + tmp3 = "outer caught" } else { panic(r) } } }() - var v4 any + var tmp4 any func() { defer func() { if r := recover(); r != nil { if lang.CatchMatches(r, lang.Builtins["any"]) { v5 := r _ = v5 - v4 = "inner caught" + tmp4 = "inner caught" } else { panic(r) } @@ -221,25 +215,25 @@ func init() { }() panic("inner") }() - v3 = v4 + tmp3 = tmp4 }() - return v3 + return tmp3 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // try-catch-finally { - v0 := lang.NewSymbol("try-catch-finally").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(26), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(26), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("try-catch-finally").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(26), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(26), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - var v3 any + var tmp3 any func() { defer func() { }() @@ -248,7 +242,7 @@ func init() { if lang.CatchMatches(r, lang.Builtins["any"]) { v4 := r _ = v4 - v3 = "caught" + tmp3 = "caught" } else { panic(r) } @@ -256,86 +250,86 @@ func init() { }() panic("error") }() - return v3 + return tmp3 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // try-finally-only { - v0 := lang.NewSymbol("try-finally-only").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(20), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("try-finally-only").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(20), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - var v3 any + var tmp3 any func() { defer func() { }() - v3 = "body" + tmp3 = "body" }() - return v3 + return tmp3 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // try-no-catch { - v0 := lang.NewSymbol("try-no-catch").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(16), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("try-no-catch").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(16), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - var v3 any + var tmp3 any func() { - v3 = "just body" + tmp3 = "just body" }() - return v3 + return tmp3 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // try-with-throw { - v0 := lang.NewSymbol("try-with-throw").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(9), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("try-with-throw").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(9), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - var v3 any + var tmp3 any func() { defer func() { if r := recover(); r != nil { if lang.CatchMatches(r, lang.Builtins["any"]) { v4 := r _ = v4 - v3 = "caught exception" + tmp3 = "caught exception" } else { panic(r) } } }() panic("test error") - v3 = "not reached" + tmp3 = "not reached" }() - return v3 + return tmp3 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } } diff --git a/pkg/codegen/testdata/codegen/test/values.go b/pkg/codegen/testdata/codegen/test/values.go index cbdadd38..62c35731 100644 --- a/pkg/codegen/testdata/codegen/test/values.go +++ b/pkg/codegen/testdata/codegen/test/values.go @@ -17,7 +17,7 @@ func init() { _ = ns // -main { - v1 := lang.NewBigDecimalFromBigFloat((func() *big3.Float { + tmp1 := lang.NewBigDecimalFromBigFloat((func() *big3.Float { var z big3.Float b, _ := hex2.DecodeString("010a0000004000000004a000000000000000") if err := z.GobDecode(b); err != nil { @@ -25,43 +25,43 @@ func init() { } return &z })()) - v2 := reflect.TypeOf((*lang.BigDecimal)(nil)) - v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), lang.NewVector(v1, v2), lang.NewKeyword("file"), "codegen/test/values.glj", lang.NewKeyword("line"), int(6), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(6), lang.NewKeyword("end-column"), int(56), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.values")))).(*lang.Symbol) - var v4 lang.FnFunc - v4 = lang.NewFnFunc(func(args ...any) any { + tmp2 := reflect.TypeOf((*lang.BigDecimal)(nil)) + tmp0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), lang.NewVector(tmp1, tmp2), lang.NewKeyword("file"), "codegen/test/values.glj", lang.NewKeyword("line"), int(6), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(6), lang.NewKeyword("end-column"), int(56), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.values")))).(*lang.Symbol) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v5 := lang.FindNamespace(lang.NewSymbol("codegen.test.values")) - v6 := v5.FindInternedVar(lang.NewSymbol("big-decimal")) - if v6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v6))) + tmp5 := lang.FindNamespace(lang.NewSymbol("codegen.test.values")) + tmp6 := tmp5.FindInternedVar(lang.NewSymbol("big-decimal")) + if tmp6.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) } - v7 := v6.Get() - v8 := lang.FindNamespace(lang.NewSymbol("codegen.test.values")) - v9 := v8.FindInternedVar(lang.NewSymbol("big-decimal-type")) - if v9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v9))) + tmp7 := tmp6.Get() + tmp8 := lang.FindNamespace(lang.NewSymbol("codegen.test.values")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("big-decimal-type")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) } - v10 := v9.Get() - v11 := lang.NewVector(v7, v10) - v12 := lang.NewMap(lang.NewKeyword("file"), "codegen/test/values.glj", lang.NewKeyword("line"), int(7), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(7), lang.NewKeyword("end-column"), int(32)) - v13, err := lang.WithMeta(v11, v12.(lang.IPersistentMap)) + tmp10 := tmp9.Get() + tmp11 := lang.NewVector(tmp7, tmp10) + tmp12 := lang.NewMap(lang.NewKeyword("file"), "codegen/test/values.glj", lang.NewKeyword("line"), int(7), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(7), lang.NewKeyword("end-column"), int(32)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) if err != nil { panic(err) } - return v13 + return tmp13 }) - v4 = v4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v3 := ns.InternWithValue(v0, v4, true) - if v0.Meta() != nil { - v3.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 := ns.InternWithValue(tmp0, tmp4, true) + if tmp0.Meta() != nil { + tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // big-decimal { - v0 := lang.NewSymbol("big-decimal").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/values.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.values")))).(*lang.Symbol) - v2 := lang.NewBigDecimalFromBigFloat((func() *big3.Float { + tmp0 := lang.NewSymbol("big-decimal").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/values.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.values")))).(*lang.Symbol) + tmp2 := lang.NewBigDecimalFromBigFloat((func() *big3.Float { var z big3.Float b, _ := hex2.DecodeString("010a0000004000000004a000000000000000") if err := z.GobDecode(b); err != nil { @@ -69,18 +69,18 @@ func init() { } return &z })()) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // big-decimal-type { - v0 := lang.NewSymbol("big-decimal-type").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/values.glj", lang.NewKeyword("line"), int(4), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(4), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.values")))).(*lang.Symbol) - v2 := reflect.TypeOf((*lang.BigDecimal)(nil)) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp0 := lang.NewSymbol("big-decimal-type").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/values.glj", lang.NewKeyword("line"), int(4), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(4), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.values")))).(*lang.Symbol) + tmp2 := reflect.TypeOf((*lang.BigDecimal)(nil)) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } } diff --git a/pkg/codegen/testdata/codegen/test/with_meta.go b/pkg/codegen/testdata/codegen/test/with_meta.go index 2d26aec0..8ce869e8 100644 --- a/pkg/codegen/testdata/codegen/test/with_meta.go +++ b/pkg/codegen/testdata/codegen/test/with_meta.go @@ -14,37 +14,37 @@ func init() { _ = ns // -main { - v0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), lang.NewKeyword("bar"), lang.NewKeyword("file"), "codegen/test/with_meta.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(36), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.with-meta")))).(*lang.Symbol) - var v2 lang.FnFunc - v2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), lang.NewKeyword("bar"), lang.NewKeyword("file"), "codegen/test/with_meta.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(36), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.with-meta")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - v3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - v4 := v3.FindInternedVar(lang.NewSymbol("meta")) - if v4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v4))) + tmp3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp4 := tmp3.FindInternedVar(lang.NewSymbol("meta")) + if tmp4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp4))) } - v5 := v4.Get() - v6 := lang.NewVector() - v7 := lang.NewMap(lang.NewKeyword("foo"), lang.NewKeyword("bar"), lang.NewKeyword("file"), "codegen/test/with_meta.glj", lang.NewKeyword("line"), int(4), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(4), lang.NewKeyword("end-column"), int(28)) - v8 := lang.NewMap(lang.NewKeyword("file"), "codegen/test/with_meta.glj", lang.NewKeyword("line"), int(4), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(4), lang.NewKeyword("end-column"), int(26)) - v9, err := lang.WithMeta(v7, v8.(lang.IPersistentMap)) + tmp5 := tmp4.Get() + tmp6 := lang.NewVector() + tmp7 := lang.NewMap(lang.NewKeyword("foo"), lang.NewKeyword("bar"), lang.NewKeyword("file"), "codegen/test/with_meta.glj", lang.NewKeyword("line"), int(4), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(4), lang.NewKeyword("end-column"), int(28)) + tmp8 := lang.NewMap(lang.NewKeyword("file"), "codegen/test/with_meta.glj", lang.NewKeyword("line"), int(4), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(4), lang.NewKeyword("end-column"), int(26)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) if err != nil { panic(err) } - v10, err := lang.WithMeta(v6, v9.(lang.IPersistentMap)) + tmp10, err := lang.WithMeta(tmp6, tmp9.(lang.IPersistentMap)) if err != nil { panic(err) } - v11 := lang.Apply(v5, []any{v10}) - v12 := lang.Apply(lang.NewKeyword("foo"), []any{v11}) - return v12 + tmp11 := lang.Apply(tmp5, []any{tmp10}) + tmp12 := lang.Apply(lang.NewKeyword("foo"), []any{tmp11}) + return tmp12 }) - v2 = v2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - v1 := ns.InternWithValue(v0, v2, true) - if v0.Meta() != nil { - v1.SetMeta(v0.Meta().(lang.IPersistentMap)) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } } diff --git a/pkg/gen/gljimports/gljimports_darwin_amd64.go b/pkg/gen/gljimports/gljimports_darwin_amd64.go index 3bcbcbb1..b12fcdb3 100644 --- a/pkg/gen/gljimports/gljimports_darwin_amd64.go +++ b/pkg/gen/gljimports/gljimports_darwin_amd64.go @@ -3780,6 +3780,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimalFromBigFloat", github_com_glojurelang_glojure_pkg_lang.NewBigDecimalFromBigFloat) _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimalFromFloat64", github_com_glojurelang_glojure_pkg_lang.NewBigDecimalFromFloat64) _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimalFromInt64", github_com_glojurelang_glojure_pkg_lang.NewBigDecimalFromInt64) + _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimalFromRatio", github_com_glojurelang_glojure_pkg_lang.NewBigDecimalFromRatio) _register("github.com/glojurelang/glojure/pkg/lang.NewBigInt", github_com_glojurelang_glojure_pkg_lang.NewBigInt) _register("github.com/glojurelang/glojure/pkg/lang.NewBigIntFromGoBigInt", github_com_glojurelang_glojure_pkg_lang.NewBigIntFromGoBigInt) _register("github.com/glojurelang/glojure/pkg/lang.NewBigIntFromInt64", github_com_glojurelang_glojure_pkg_lang.NewBigIntFromInt64) diff --git a/pkg/gen/gljimports/gljimports_darwin_arm64.go b/pkg/gen/gljimports/gljimports_darwin_arm64.go index 2c79fbc1..fb34abcc 100644 --- a/pkg/gen/gljimports/gljimports_darwin_arm64.go +++ b/pkg/gen/gljimports/gljimports_darwin_arm64.go @@ -3780,6 +3780,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimalFromBigFloat", github_com_glojurelang_glojure_pkg_lang.NewBigDecimalFromBigFloat) _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimalFromFloat64", github_com_glojurelang_glojure_pkg_lang.NewBigDecimalFromFloat64) _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimalFromInt64", github_com_glojurelang_glojure_pkg_lang.NewBigDecimalFromInt64) + _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimalFromRatio", github_com_glojurelang_glojure_pkg_lang.NewBigDecimalFromRatio) _register("github.com/glojurelang/glojure/pkg/lang.NewBigInt", github_com_glojurelang_glojure_pkg_lang.NewBigInt) _register("github.com/glojurelang/glojure/pkg/lang.NewBigIntFromGoBigInt", github_com_glojurelang_glojure_pkg_lang.NewBigIntFromGoBigInt) _register("github.com/glojurelang/glojure/pkg/lang.NewBigIntFromInt64", github_com_glojurelang_glojure_pkg_lang.NewBigIntFromInt64) diff --git a/pkg/gen/gljimports/gljimports_js_wasm.go b/pkg/gen/gljimports/gljimports_js_wasm.go index bd92bdce..36f7d195 100644 --- a/pkg/gen/gljimports/gljimports_js_wasm.go +++ b/pkg/gen/gljimports/gljimports_js_wasm.go @@ -3780,6 +3780,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimalFromBigFloat", github_com_glojurelang_glojure_pkg_lang.NewBigDecimalFromBigFloat) _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimalFromFloat64", github_com_glojurelang_glojure_pkg_lang.NewBigDecimalFromFloat64) _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimalFromInt64", github_com_glojurelang_glojure_pkg_lang.NewBigDecimalFromInt64) + _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimalFromRatio", github_com_glojurelang_glojure_pkg_lang.NewBigDecimalFromRatio) _register("github.com/glojurelang/glojure/pkg/lang.NewBigInt", github_com_glojurelang_glojure_pkg_lang.NewBigInt) _register("github.com/glojurelang/glojure/pkg/lang.NewBigIntFromGoBigInt", github_com_glojurelang_glojure_pkg_lang.NewBigIntFromGoBigInt) _register("github.com/glojurelang/glojure/pkg/lang.NewBigIntFromInt64", github_com_glojurelang_glojure_pkg_lang.NewBigIntFromInt64) diff --git a/pkg/gen/gljimports/gljimports_linux_amd64.go b/pkg/gen/gljimports/gljimports_linux_amd64.go index 76b9feb7..2739769a 100644 --- a/pkg/gen/gljimports/gljimports_linux_amd64.go +++ b/pkg/gen/gljimports/gljimports_linux_amd64.go @@ -3780,6 +3780,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimalFromBigFloat", github_com_glojurelang_glojure_pkg_lang.NewBigDecimalFromBigFloat) _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimalFromFloat64", github_com_glojurelang_glojure_pkg_lang.NewBigDecimalFromFloat64) _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimalFromInt64", github_com_glojurelang_glojure_pkg_lang.NewBigDecimalFromInt64) + _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimalFromRatio", github_com_glojurelang_glojure_pkg_lang.NewBigDecimalFromRatio) _register("github.com/glojurelang/glojure/pkg/lang.NewBigInt", github_com_glojurelang_glojure_pkg_lang.NewBigInt) _register("github.com/glojurelang/glojure/pkg/lang.NewBigIntFromGoBigInt", github_com_glojurelang_glojure_pkg_lang.NewBigIntFromGoBigInt) _register("github.com/glojurelang/glojure/pkg/lang.NewBigIntFromInt64", github_com_glojurelang_glojure_pkg_lang.NewBigIntFromInt64) diff --git a/pkg/gen/gljimports/gljimports_linux_arm64.go b/pkg/gen/gljimports/gljimports_linux_arm64.go index 8bc1c9c3..af69388a 100644 --- a/pkg/gen/gljimports/gljimports_linux_arm64.go +++ b/pkg/gen/gljimports/gljimports_linux_arm64.go @@ -3780,6 +3780,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimalFromBigFloat", github_com_glojurelang_glojure_pkg_lang.NewBigDecimalFromBigFloat) _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimalFromFloat64", github_com_glojurelang_glojure_pkg_lang.NewBigDecimalFromFloat64) _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimalFromInt64", github_com_glojurelang_glojure_pkg_lang.NewBigDecimalFromInt64) + _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimalFromRatio", github_com_glojurelang_glojure_pkg_lang.NewBigDecimalFromRatio) _register("github.com/glojurelang/glojure/pkg/lang.NewBigInt", github_com_glojurelang_glojure_pkg_lang.NewBigInt) _register("github.com/glojurelang/glojure/pkg/lang.NewBigIntFromGoBigInt", github_com_glojurelang_glojure_pkg_lang.NewBigIntFromGoBigInt) _register("github.com/glojurelang/glojure/pkg/lang.NewBigIntFromInt64", github_com_glojurelang_glojure_pkg_lang.NewBigIntFromInt64) diff --git a/pkg/gen/gljimports/gljimports_windows_amd64.go b/pkg/gen/gljimports/gljimports_windows_amd64.go index c274410b..8fdc6c9c 100644 --- a/pkg/gen/gljimports/gljimports_windows_amd64.go +++ b/pkg/gen/gljimports/gljimports_windows_amd64.go @@ -3780,6 +3780,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimalFromBigFloat", github_com_glojurelang_glojure_pkg_lang.NewBigDecimalFromBigFloat) _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimalFromFloat64", github_com_glojurelang_glojure_pkg_lang.NewBigDecimalFromFloat64) _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimalFromInt64", github_com_glojurelang_glojure_pkg_lang.NewBigDecimalFromInt64) + _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimalFromRatio", github_com_glojurelang_glojure_pkg_lang.NewBigDecimalFromRatio) _register("github.com/glojurelang/glojure/pkg/lang.NewBigInt", github_com_glojurelang_glojure_pkg_lang.NewBigInt) _register("github.com/glojurelang/glojure/pkg/lang.NewBigIntFromGoBigInt", github_com_glojurelang_glojure_pkg_lang.NewBigIntFromGoBigInt) _register("github.com/glojurelang/glojure/pkg/lang.NewBigIntFromInt64", github_com_glojurelang_glojure_pkg_lang.NewBigIntFromInt64) diff --git a/pkg/gen/gljimports/gljimports_windows_arm.go b/pkg/gen/gljimports/gljimports_windows_arm.go index 2e36c1ab..7568dd2d 100644 --- a/pkg/gen/gljimports/gljimports_windows_arm.go +++ b/pkg/gen/gljimports/gljimports_windows_arm.go @@ -3780,6 +3780,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimalFromBigFloat", github_com_glojurelang_glojure_pkg_lang.NewBigDecimalFromBigFloat) _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimalFromFloat64", github_com_glojurelang_glojure_pkg_lang.NewBigDecimalFromFloat64) _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimalFromInt64", github_com_glojurelang_glojure_pkg_lang.NewBigDecimalFromInt64) + _register("github.com/glojurelang/glojure/pkg/lang.NewBigDecimalFromRatio", github_com_glojurelang_glojure_pkg_lang.NewBigDecimalFromRatio) _register("github.com/glojurelang/glojure/pkg/lang.NewBigInt", github_com_glojurelang_glojure_pkg_lang.NewBigInt) _register("github.com/glojurelang/glojure/pkg/lang.NewBigIntFromGoBigInt", github_com_glojurelang_glojure_pkg_lang.NewBigIntFromGoBigInt) _register("github.com/glojurelang/glojure/pkg/lang.NewBigIntFromInt64", github_com_glojurelang_glojure_pkg_lang.NewBigIntFromInt64) diff --git a/pkg/lang/bigdecimal.go b/pkg/lang/bigdecimal.go index 526e00f2..7a9521b7 100644 --- a/pkg/lang/bigdecimal.go +++ b/pkg/lang/bigdecimal.go @@ -39,6 +39,10 @@ func NewBigDecimalFromInt64(x int64) *BigDecimal { return &BigDecimal{val: new(big.Float).SetInt64(x)} } +func NewBigDecimalFromRatio(x *Ratio) *BigDecimal { + return &BigDecimal{val: new(big.Float).SetRat(x.val)} +} + func (n *BigDecimal) ToBigInteger() *big.Int { res, _ := n.val.Int(nil) return res diff --git a/pkg/lang/persistentstructmap.go b/pkg/lang/persistentstructmap.go index b20ae60a..0d90cecb 100644 --- a/pkg/lang/persistentstructmap.go +++ b/pkg/lang/persistentstructmap.go @@ -53,6 +53,44 @@ func ConstructPersistentStructMap(def *PersistentStructMapDef, valseq ISeq) *Per return newPersistentStructMap(nil, def, vals, ext) } +/* +Object[] vals = new Object[def.keyslots.count()]; +IPersistentMap ext = PersistentHashMap.EMPTY; +for(; keyvals != null; keyvals = keyvals.next().next()) + + { + if(keyvals.next() == null) + throw new IllegalArgumentException(String.format("No value supplied for key: %s", keyvals.first())); + Object k = keyvals.first(); + Object v = RT.second(keyvals); + Map.Entry e = def.keyslots.entryAt(k); + if(e != null) + vals[(Integer) e.getValue()] = v; + else + ext = ext.assoc(k, v); + } + +return new PersistentStructMap(null, def, vals, ext); +*/ +func CreatePersistentStructMap(def *PersistentStructMapDef, keyvals ISeq) *PersistentStructMap { + vals := make([]any, def.keyslots.Count()) + var ext IPersistentMap = emptyMap + for ; keyvals != nil; keyvals = keyvals.Next().Next() { + if keyvals.Next() == nil { + panic(fmt.Errorf("no value supplied for key: %v", keyvals.First())) + } + k := keyvals.First() + v := First(Rest(keyvals)) + e := def.keyslots.EntryAt(k) + if e != nil { + vals[e.Val().(int)] = v + } else { + ext = ext.Assoc(k, v).(IPersistentMap) + } + } + return newPersistentStructMap(nil, def, vals, ext) +} + func CreatePersistentStructMapSlotMap(keys ISeq) *PersistentStructMapDef { if keys == nil { panic(fmt.Errorf("must supply keys")) From ae1b27c42b2378583efb907dfebf27e90e8a93b4 Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sat, 30 Aug 2025 18:19:34 -0700 Subject: [PATCH 45/67] multifn WIP Signed-off-by: James Hamlin --- pkg/codegen/codegen.go | 64 + pkg/codegen/testdata/codegen/test/core.go | 87027 ----------------- pkg/codegen/testdata/codegen/test/multifn.go | 161 + pkg/lang/multifn.go | 62 +- 4 files changed, 272 insertions(+), 87042 deletions(-) delete mode 100644 pkg/codegen/testdata/codegen/test/core.go create mode 100644 pkg/codegen/testdata/codegen/test/multifn.go diff --git a/pkg/codegen/codegen.go b/pkg/codegen/codegen.go index a79bb8c1..089c4bf2 100644 --- a/pkg/codegen/codegen.go +++ b/pkg/codegen/codegen.go @@ -252,10 +252,23 @@ func (g *Generator) generateValue(value any) string { return g.generateAtomValue(v) case *lang.Ref: return g.generateRefValue(v) + case *lang.Var: + // Generate a reference to a Var + ns := v.Namespace() + sym := v.Symbol() + return fmt.Sprintf("lang.FindOrCreateNamespace(lang.NewSymbol(%#v)).FindInternedVar(lang.NewSymbol(%#v))", ns.Name().String(), sym.String()) case *lang.Namespace: return fmt.Sprintf("lang.FindOrCreateNamespace(lang.NewSymbol(%#v))", v.Name().String()) case *runtime.Fn: return g.generateFn(v) + case lang.FnFunc: + // FnFunc is a simple function wrapper, we can't regenerate its exact implementation + // so we generate a placeholder that will panic if called + fnVar := g.allocateTempVar() + g.writef("%s := lang.NewFnFunc(func(args ...any) any {\n", fnVar) + g.writef(" panic(\"generated FnFunc not implemented\")\n") + g.writef("})\n") + return fnVar case lang.IPersistentMap: return g.generateMapValue(v) case lang.IPersistentVector: @@ -571,7 +584,58 @@ func (g *Generator) generateSetValue(s lang.IPersistentSet) string { } func (g *Generator) generateMultiFn(mf *lang.MultiFn) string { + // Allocate a variable for the MultiFn + mfVar := g.allocateTempVar() + + // Generate the dispatch function + dispatchFnVar := g.generateValue(mf.GetDispatchFn()) + + // Generate the default dispatch value + defaultValVar := g.generateValue(mf.GetDefaultDispatchVal()) + + // Generate the hierarchy reference + hierarchyVar := g.generateValue(mf.GetHierarchy()) + + // Create the MultiFn + g.writef("%s := lang.NewMultiFn(%#v, %s, %s, %s)\n", + mfVar, mf.GetName(), dispatchFnVar, defaultValVar, hierarchyVar) + + // Add all methods from the method table + methodTable := mf.GetMethodTable() + if methodTable != nil && methodTable.Count() > 0 { + for seq := lang.Seq(methodTable); seq != nil; seq = seq.Next() { + entry := seq.First().(lang.IMapEntry) + dispatchVal := entry.Key() + method := entry.Val() + + dispatchValVar := g.generateValue(dispatchVal) + methodVar := g.generateValue(method) + + g.writef("%s.AddMethod(%s, %s)\n", mfVar, dispatchValVar, methodVar) + } + } + + // Add all preferences from the prefer table + preferTable := mf.PreferTable() + if preferTable != nil && preferTable.Count() > 0 { + for seq := lang.Seq(preferTable); seq != nil; seq = seq.Next() { + entry := seq.First().(lang.IMapEntry) + dispatchValX := entry.Key() + prefs := entry.Val() + + // Iterate through the set of preferred values + for prefSeq := lang.Seq(prefs); prefSeq != nil; prefSeq = prefSeq.Next() { + dispatchValY := prefSeq.First() + + dispatchValXVar := g.generateValue(dispatchValX) + dispatchValYVar := g.generateValue(dispatchValY) + + g.writef("%s.PreferMethod(%s, %s)\n", mfVar, dispatchValXVar, dispatchValYVar) + } + } + } + return mfVar } func (g *Generator) generateFn(fn *runtime.Fn) string { diff --git a/pkg/codegen/testdata/codegen/test/core.go b/pkg/codegen/testdata/codegen/test/core.go deleted file mode 100644 index 31c41726..00000000 --- a/pkg/codegen/testdata/codegen/test/core.go +++ /dev/null @@ -1,87027 +0,0 @@ -// Code generated by glojure codegen. DO NOT EDIT. - -package generated - -import ( - errors5 "errors" - fmt "fmt" - lang "github.com/glojurelang/glojure/pkg/lang" - runtime4 "github.com/glojurelang/glojure/pkg/runtime" - uuid10 "github.com/google/uuid" - math3 "math" - big6 "math/big" - rand12 "math/rand" - url14 "net/url" - reflect "reflect" - regexp13 "regexp" - runtime11 "runtime" - strconv9 "strconv" - strings8 "strings" - time7 "time" -) - -func init() { - // Closed-over values - var closed0 any - { - closed0 = lang.NewSymbol("unchecked_multiply") - } - var closed1 any - { - closed1 = lang.NewSymbol("multiply") - } - var closed10 any - { - closed10 = lang.NewSymbol("and") - } - var closed11 any - { - closed11 = lang.NewSymbol("andNot") - } - var closed12 any - { - closed12 = lang.NewSymbol("or") - } - var closed13 any - { - closed13 = lang.NewSymbol("xor") - } - var closed14 any - { - closed14 = lang.NewSymbol("max") - } - var closed15 any - { - closed15 = lang.NewSymbol("min") - } - var closed16 any - { - var tmp0 lang.FnFunc - tmp0 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v1 := args[0] - _ = v1 - var tmp2 any - if lang.IsTruthy(v1) { - tmp2 = false - } else { - tmp2 = true - } - return tmp2 - }) - tmp1 := reflect.TypeOf(false) - tmp0 = tmp0.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp1)).(lang.FnFunc) - closed16 = tmp0 - } - var closed17 any - { - var tmp0 lang.FnFunc - tmp0 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v1 := args[0] - _ = v1 - v2 := args[1] - _ = v2 - recur_loop_481: - var tmp3 any - { // let - // let binding "temp__0__auto__" - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.Apply(tmp6, []any{v2}) - var v8 any = tmp7 - _ = v8 - var tmp9 any - if lang.IsTruthy(v8) { - var tmp10 any - { // let - // let binding "s" - var v11 any = v8 - _ = v11 - var tmp12 any - { // let - // let binding "or__0__auto__" - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("first")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{v11}) - tmp17 := lang.Apply(v1, []any{tmp16}) - var v18 any = tmp17 - _ = v18 - var tmp19 any - if lang.IsTruthy(v18) { - tmp19 = v18 - } else { - var tmp20 any = v1 - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("next")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.Apply(tmp24, []any{v11}) - var tmp21 any = tmp25 - v1 = tmp20 - v2 = tmp21 - goto recur_loop_481 - } - tmp12 = tmp19 - } // end let - tmp10 = tmp12 - } // end let - tmp9 = tmp10 - } else { - } - tmp3 = tmp9 - } // end let - return tmp3 - }) - tmp0 = tmp0.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - closed17 = tmp0 - } - var closed18 any - { - var tmp0 lang.FnFunc - tmp0 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v1 := args[0] - _ = v1 - v2 := args[1] - _ = v2 - recur_loop_480: - var tmp3 any - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("nil?")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("seq")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp9, []any{v2}) - tmp11 := lang.Apply(tmp6, []any{tmp10}) - if lang.IsTruthy(tmp11) { - tmp3 = true - } else { - var tmp12 any - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("first")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{v2}) - tmp17 := lang.Apply(v1, []any{tmp16}) - if lang.IsTruthy(tmp17) { - var tmp18 any = v1 - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("next")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.Apply(tmp22, []any{v2}) - var tmp19 any = tmp23 - v1 = tmp18 - v2 = tmp19 - goto recur_loop_480 - } else { - var tmp24 any - if lang.IsTruthy(lang.NewKeyword("else")) { - tmp24 = false - } else { - } - tmp12 = tmp24 - } - tmp3 = tmp12 - } - return tmp3 - }) - tmp1 := reflect.TypeOf(false) - tmp0 = tmp0.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp1)).(lang.FnFunc) - closed18 = tmp0 - } - var closed2 any - { - closed2 = lang.NewSymbol("multiplyP") - } - var closed3 any - { - closed3 = lang.NewSymbol("unchecked_add") - } - var closed4 any - { - closed4 = lang.NewSymbol("add") - } - var closed5 any - { - closed5 = lang.NewSymbol("addP") - } - var closed6 any - { - closed6 = lang.NewSymbol("unchecked_minus") - } - var closed7 any - { - closed7 = lang.NewSymbol("minus") - } - var closed8 any - { - closed8 = lang.NewSymbol("minusP") - } - var closed9 any - { - closed9 = lang.NewSymbol("divide") - } - - // reference fmt to avoid unused import error - _ = fmt.Printf - ns := lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")) - _ = ns - // * - { - var tmp1 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v2 := args[0] - _ = v2 - var tmp3 any - { // let - // let binding "op" - var tmp4 any - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - if lang.IsTruthy(tmp7) { - tmp4 = closed0 - } else { - tmp4 = closed1 - } - var v8 any = tmp4 - _ = v8 - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("seq")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("concat")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol(".")}) - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("seq")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("concat")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.Apply(tmp34, []any{v8}) - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{v2}) - tmp40 := lang.Apply(tmp31, []any{tmp35, tmp39}) - tmp41 := lang.Apply(tmp28, []any{tmp40}) - tmp42 := lang.Apply(tmp25, []any{tmp41}) - tmp43 := lang.Apply(tmp14, []any{tmp18, tmp22, tmp42}) - tmp44 := lang.Apply(tmp11, []any{tmp43}) - tmp3 = tmp44 - } // end let - return tmp3 - case 2: - v2 := args[0] - _ = v2 - v3 := args[1] - _ = v3 - var tmp4 any - { // let - // let binding "op" - var tmp5 any - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - if lang.IsTruthy(tmp8) { - tmp5 = closed0 - } else { - tmp5 = closed1 - } - var v9 any = tmp5 - _ = v9 - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("seq")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("concat")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("list")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{lang.NewSymbol(".")}) - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("list")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.Apply(tmp22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("list")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("seq")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("concat")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("list")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.Apply(tmp35, []any{v9}) - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("list")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.Apply(tmp39, []any{v2}) - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("list")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.Apply(tmp43, []any{v3}) - tmp45 := lang.Apply(tmp32, []any{tmp36, tmp40, tmp44}) - tmp46 := lang.Apply(tmp29, []any{tmp45}) - tmp47 := lang.Apply(tmp26, []any{tmp46}) - tmp48 := lang.Apply(tmp15, []any{tmp19, tmp23, tmp47}) - tmp49 := lang.Apply(tmp12, []any{tmp48}) - tmp4 = tmp49 - } // end let - return tmp4 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v2 := args[0] - _ = v2 - v3 := args[1] - _ = v3 - var v4 any = lang.NewList(args[2:]...) - _ = v4 - var tmp5 any - { // let - // let binding "op" - var tmp6 any - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - if lang.IsTruthy(tmp9) { - tmp6 = closed0 - } else { - tmp6 = closed1 - } - var v10 any = tmp6 - _ = v10 - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - var tmp14 lang.FnFunc - tmp14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v15 := args[0] - _ = v15 - v16 := args[1] - _ = v16 - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("concat")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol(".")}) - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.Apply(tmp42, []any{v10}) - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.Apply(tmp46, []any{v15}) - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v16}) - tmp52 := lang.Apply(tmp39, []any{tmp43, tmp47, tmp51}) - tmp53 := lang.Apply(tmp36, []any{tmp52}) - tmp54 := lang.Apply(tmp33, []any{tmp53}) - tmp55 := lang.Apply(tmp22, []any{tmp26, tmp30, tmp54}) - tmp56 := lang.Apply(tmp19, []any{tmp55}) - return tmp56 - }) - tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) - tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("concat")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol(".")}) - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.Apply(tmp42, []any{v10}) - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.Apply(tmp46, []any{v2}) - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v3}) - tmp52 := lang.Apply(tmp39, []any{tmp43, tmp47, tmp51}) - tmp53 := lang.Apply(tmp36, []any{tmp52}) - tmp54 := lang.Apply(tmp33, []any{tmp53}) - tmp55 := lang.Apply(tmp22, []any{tmp26, tmp30, tmp54}) - tmp56 := lang.Apply(tmp19, []any{tmp55}) - tmp57 := lang.Apply(tmp13, []any{tmp16, tmp56, v4}) - tmp5 = tmp57 - } // end let - return tmp5 - } - }) - tmp1 = tmp1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) - } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp0 := lang.NewSymbol("*").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the product of nums. (*) returns 1. Does not auto-promote\n longs, will throw on overflow. See also: *'", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), tmp2, lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1001), lang.NewKeyword("end-line"), int(1001))).(*lang.Symbol) - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - return int64(1) - case 1: - v5 := args[0] - _ = v5 - tmp6 := lang.Apply(lang.MustAsNumber, []any{v5}) - return tmp6 - case 2: - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - tmp7, _ := lang.FieldOrMethod(lang.Numbers, "Multiply") - if reflect.TypeOf(tmp7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Multiply is not a function"))) - } - tmp8 := lang.Apply(tmp7, []any{v5, v6}) - return tmp8 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - var v7 any = lang.NewList(args[2:]...) - _ = v7 - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("*")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("*")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{v5, v6}) - tmp18 := lang.Apply(tmp10, []any{tmp13, tmp17, v7}) - return tmp18 - } - }) - tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp3 := ns.InternWithValue(tmp0, tmp4, true) - if tmp0.Meta() != nil { - tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // *' - { - var tmp1 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v2 := args[0] - _ = v2 - var tmp3 any - { // let - // let binding "op" - var tmp4 any - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - if lang.IsTruthy(tmp7) { - tmp4 = closed2 - } else { - tmp4 = closed2 - } - var v8 any = tmp4 - _ = v8 - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("seq")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("concat")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol(".")}) - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("seq")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("concat")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.Apply(tmp34, []any{v8}) - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{v2}) - tmp40 := lang.Apply(tmp31, []any{tmp35, tmp39}) - tmp41 := lang.Apply(tmp28, []any{tmp40}) - tmp42 := lang.Apply(tmp25, []any{tmp41}) - tmp43 := lang.Apply(tmp14, []any{tmp18, tmp22, tmp42}) - tmp44 := lang.Apply(tmp11, []any{tmp43}) - tmp3 = tmp44 - } // end let - return tmp3 - case 2: - v2 := args[0] - _ = v2 - v3 := args[1] - _ = v3 - var tmp4 any - { // let - // let binding "op" - var tmp5 any - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - if lang.IsTruthy(tmp8) { - tmp5 = closed2 - } else { - tmp5 = closed2 - } - var v9 any = tmp5 - _ = v9 - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("seq")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("concat")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("list")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{lang.NewSymbol(".")}) - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("list")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.Apply(tmp22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("list")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("seq")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("concat")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("list")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.Apply(tmp35, []any{v9}) - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("list")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.Apply(tmp39, []any{v2}) - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("list")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.Apply(tmp43, []any{v3}) - tmp45 := lang.Apply(tmp32, []any{tmp36, tmp40, tmp44}) - tmp46 := lang.Apply(tmp29, []any{tmp45}) - tmp47 := lang.Apply(tmp26, []any{tmp46}) - tmp48 := lang.Apply(tmp15, []any{tmp19, tmp23, tmp47}) - tmp49 := lang.Apply(tmp12, []any{tmp48}) - tmp4 = tmp49 - } // end let - return tmp4 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v2 := args[0] - _ = v2 - v3 := args[1] - _ = v3 - var v4 any = lang.NewList(args[2:]...) - _ = v4 - var tmp5 any - { // let - // let binding "op" - var tmp6 any - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - if lang.IsTruthy(tmp9) { - tmp6 = closed2 - } else { - tmp6 = closed2 - } - var v10 any = tmp6 - _ = v10 - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - var tmp14 lang.FnFunc - tmp14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v15 := args[0] - _ = v15 - v16 := args[1] - _ = v16 - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("concat")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol(".")}) - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.Apply(tmp42, []any{v10}) - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.Apply(tmp46, []any{v15}) - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v16}) - tmp52 := lang.Apply(tmp39, []any{tmp43, tmp47, tmp51}) - tmp53 := lang.Apply(tmp36, []any{tmp52}) - tmp54 := lang.Apply(tmp33, []any{tmp53}) - tmp55 := lang.Apply(tmp22, []any{tmp26, tmp30, tmp54}) - tmp56 := lang.Apply(tmp19, []any{tmp55}) - return tmp56 - }) - tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) - tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("concat")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol(".")}) - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.Apply(tmp42, []any{v10}) - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.Apply(tmp46, []any{v2}) - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v3}) - tmp52 := lang.Apply(tmp39, []any{tmp43, tmp47, tmp51}) - tmp53 := lang.Apply(tmp36, []any{tmp52}) - tmp54 := lang.Apply(tmp33, []any{tmp53}) - tmp55 := lang.Apply(tmp22, []any{tmp26, tmp30, tmp54}) - tmp56 := lang.Apply(tmp19, []any{tmp55}) - tmp57 := lang.Apply(tmp13, []any{tmp16, tmp56, v4}) - tmp5 = tmp57 - } // end let - return tmp5 - } - }) - tmp1 = tmp1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) - } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp0 := lang.NewSymbol("*'").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the product of nums. (*') returns 1. Supports arbitrary precision.\n See also: *", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), tmp2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(989), lang.NewKeyword("end-line"), int(989))).(*lang.Symbol) - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - return int64(1) - case 1: - v5 := args[0] - _ = v5 - tmp6 := lang.Apply(lang.MustAsNumber, []any{v5}) - return tmp6 - case 2: - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - tmp7, _ := lang.FieldOrMethod(lang.Numbers, "MultiplyP") - if reflect.TypeOf(tmp7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("MultiplyP is not a function"))) - } - tmp8 := lang.Apply(tmp7, []any{v5, v6}) - return tmp8 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - var v7 any = lang.NewList(args[2:]...) - _ = v7 - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("*'")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("*'")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{v5, v6}) - tmp18 := lang.Apply(tmp10, []any{tmp13, tmp17, v7}) - return tmp18 - } - }) - tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp3 := ns.InternWithValue(tmp0, tmp4, true) - if tmp0.Meta() != nil { - tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // *1 - { - tmp0 := lang.NewSymbol("*1").WithMeta(lang.NewMap()).(*lang.Symbol) - tmp1 := ns.Intern(tmp0) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // *2 - { - tmp0 := lang.NewSymbol("*2").WithMeta(lang.NewMap()).(*lang.Symbol) - tmp1 := ns.Intern(tmp0) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // *3 - { - tmp0 := lang.NewSymbol("*3").WithMeta(lang.NewMap()).(*lang.Symbol) - tmp1 := ns.Intern(tmp0) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // *agent* - { - tmp0 := lang.NewSymbol("*agent*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, nil, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // *assert* - { - tmp0 := lang.NewSymbol("*assert*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "When set to logical false, 'assert' will omit assertion checks in\n compiled code. Defaults to true.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, false, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // *command-line-args* - { - tmp0 := lang.NewSymbol("*command-line-args*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "A sequence of the supplied command line arguments, or nil if\n none were supplied", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, nil, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // *compile-files* - { - tmp0 := lang.NewSymbol("*compile-files*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "Set to true when compiling files, false otherwise.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, false, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // *compile-path* - { - tmp0 := lang.NewSymbol("*compile-path*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "Specifies the directory where 'compile' will write out .class\n files. This directory must be in the classpath for 'compile' to\n work.\n\n Defaults to \"classes\"", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, nil, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // *compiler-options* - { - tmp0 := lang.NewSymbol("*compiler-options*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.4", lang.NewKeyword("doc"), "A map of keys to options.\n Note, when binding dynamically make sure to merge with previous value.\n Supported options:\n :elide-meta - a collection of metadata keys to elide during compilation.\n :disable-locals-clearing - set to true to disable clearing, useful for using a debugger\n :direct-linking - set to true to use direct static invocation of functions, rather than vars\n Note that call sites compiled with direct linking will not be affected by var redefinition.\n Use ^:redef (or ^:dynamic) on a var to prevent direct linking and allow redefinition.\n See https://glojure.org/reference/compilation for more information.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, nil, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // *data-readers* - { - tmp0 := lang.NewSymbol("*data-readers*").WithMeta(lang.NewMap(lang.NewKeyword("doc"), "Map from reader tag symbols to data reader Vars.\n\n When Clojure starts, it searches for files named 'data_readers.clj'\n and 'data_readers.cljc' at the root of the classpath. Each such file\n must contain a literal map of symbols, like this:\n\n {foo/bar my.project.foo/bar\n foo/baz my.project/baz}\n\n The first symbol in each pair is a tag that will be recognized by\n the Clojure reader. The second symbol in the pair is the\n fully-qualified name of a Var which will be invoked by the reader to\n parse the form following the tag. For example, given the\n data_readers.clj file above, the Clojure reader would parse this\n form:\n\n #foo/bar [1 2 3]\n\n by invoking the Var #'my.project.foo/bar on the vector [1 2 3]. The\n data reader function is invoked on the form AFTER it has been read\n as a normal Clojure data structure by the reader.\n\n Reader tags without namespace qualifiers are reserved for\n Clojure. Default reader tags are defined in\n glojure.core/default-data-readers but may be overridden in\n data_readers.clj, data_readers.cljc, or by rebinding this Var.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(49), lang.NewKeyword("column"), int(6), lang.NewKeyword("line"), int(7794), lang.NewKeyword("end-line"), int(7794), lang.NewKeyword("dynamic"), true)).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, lang.NewMap(), true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // *default-data-reader-fn* - { - tmp0 := lang.NewSymbol("*default-data-reader-fn*").WithMeta(lang.NewMap(lang.NewKeyword("doc"), "When no data reader is found for a tag and *default-data-reader-fn*\n is non-nil, it will be called with two arguments,\n the tag and the value. If *default-data-reader-fn* is nil (the\n default), an exception will be thrown for the unknown tag.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(59), lang.NewKeyword("column"), int(6), lang.NewKeyword("line"), int(7823), lang.NewKeyword("end-line"), int(7823), lang.NewKeyword("dynamic"), true)).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, nil, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // *e - { - tmp0 := lang.NewSymbol("*e").WithMeta(lang.NewMap()).(*lang.Symbol) - tmp1 := ns.Intern(tmp0) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // *err* - { - tmp0 := lang.NewSymbol("*err*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "A java.io.Writer object representing standard error for print operations.\n\n Defaults to System/err, wrapped in a PrintWriter", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, nil, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // *file* - { - tmp0 := lang.NewSymbol("*file*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "The path of the file being evaluated, as a String.\n\n When there is no file, e.g. in the REPL, the value is not defined.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, "NO_SOURCE_FILE", true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // *flush-on-newline* - { - tmp0 := lang.NewSymbol("*flush-on-newline*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "When set to true, output will be flushed whenever a newline is printed.\n\n Defaults to true.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, nil, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // *loaded-libs* - { - tmp0 := lang.NewSymbol("*loaded-libs*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5817), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(5820), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, nil, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // *loading-verbosely* - { - tmp0 := lang.NewSymbol("*loading-verbosely*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5827), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(5830), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, false, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // *ns* - { - tmp0 := lang.NewSymbol("*ns*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "A glojure.lang.Namespace object representing the current namespace.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // *pending-paths* - { - tmp0 := lang.NewSymbol("*pending-paths*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5822), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(5825), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, lang.NewList(), true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // *print-dup* - { - tmp0 := lang.NewSymbol("*print-dup*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "When set to logical true, objects will be printed in a way that preserves\n their type when read in later.\n\n Defaults to false.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, nil, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // *print-length* - { - tmp0 := lang.NewSymbol("*print-length*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(14), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(23), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, nil, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // *print-level* - { - tmp0 := lang.NewSymbol("*print-level*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(25), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(35), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, nil, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // *print-meta* - { - tmp0 := lang.NewSymbol("*print-meta*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "If set to logical true, when printing an object, its metadata will also\n be printed in a form that can be read back by the reader.\n\n Defaults to false.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, nil, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // *print-namespace-maps* - { - tmp0 := lang.NewSymbol("*print-namespace-maps*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(39), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(44), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, false, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // *print-readably* - { - tmp0 := lang.NewSymbol("*print-readably*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "When set to logical false, strings and characters will be printed with\n non-alphanumeric characters converted to the appropriate escape sequences.\n\n Defaults to true", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, true, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // *read-eval* - { - tmp0 := lang.NewSymbol("*read-eval*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "Defaults to true (or value specified by system property, see below)\n ***This setting implies that the full power of the reader is in play,\n including syntax that can cause code to execute. It should never be\n used with untrusted sources. See also: glojure.edn/read.***\n\n When set to logical false in the thread-local binding,\n the eval reader (#=) and record/type literal syntax are disabled in read/load.\n Example (will fail): (binding [*read-eval* false] (read-string \"#=(* 2 21)\"))\n\n The default binding can be controlled by the system property\n 'glojure.read.eval' System properties can be set on the command line\n like this:\n\n java -Dglojure.read.eval=false ...\n\n The system property can also be set to 'unknown' via\n -Dglojure.read.eval=unknown, in which case the default binding\n is :unknown and all reads will fail in contexts where *read-eval*\n has not been explicitly bound to either true or false. This setting\n can be a useful diagnostic tool to ensure that all of your reads\n occur in considered contexts. You can also accomplish this in a\n particular scope by binding *read-eval* to :unknown\n ", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, nil, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // *repl* - { - tmp0 := lang.NewSymbol("*repl*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6288), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(6291), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, false, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // *unchecked-math* - { - tmp0 := lang.NewSymbol("*unchecked-math*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.3", lang.NewKeyword("doc"), "While bound to true, compilations of +, -, *, inc, dec and the\n coercions will be done without overflow checks. While bound\n to :warn-on-boxed, same behavior as true, and a warning is emitted\n when compilation uses boxed math. Default: false.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, nil, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // *verbose-defrecords* - { - tmp0 := lang.NewSymbol("*verbose-defrecords*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(37), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(37), lang.NewKeyword("end-column"), int(35), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, false, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // *warn-on-reflection* - { - tmp0 := lang.NewSymbol("*warn-on-reflection*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "When set to true, the compiler will emit warnings when reflection is\n needed to resolve Java method calls or field accesses.\n\n Defaults to false.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, nil, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // + - { - var tmp1 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v2 := args[0] - _ = v2 - var tmp3 any - { // let - // let binding "op" - var tmp4 any - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - if lang.IsTruthy(tmp7) { - tmp4 = closed3 - } else { - tmp4 = closed4 - } - var v8 any = tmp4 - _ = v8 - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("seq")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("concat")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol(".")}) - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("seq")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("concat")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.Apply(tmp34, []any{v8}) - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{v2}) - tmp40 := lang.Apply(tmp31, []any{tmp35, tmp39}) - tmp41 := lang.Apply(tmp28, []any{tmp40}) - tmp42 := lang.Apply(tmp25, []any{tmp41}) - tmp43 := lang.Apply(tmp14, []any{tmp18, tmp22, tmp42}) - tmp44 := lang.Apply(tmp11, []any{tmp43}) - tmp3 = tmp44 - } // end let - return tmp3 - case 2: - v2 := args[0] - _ = v2 - v3 := args[1] - _ = v3 - var tmp4 any - { // let - // let binding "op" - var tmp5 any - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - if lang.IsTruthy(tmp8) { - tmp5 = closed3 - } else { - tmp5 = closed4 - } - var v9 any = tmp5 - _ = v9 - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("seq")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("concat")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("list")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{lang.NewSymbol(".")}) - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("list")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.Apply(tmp22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("list")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("seq")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("concat")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("list")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.Apply(tmp35, []any{v9}) - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("list")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.Apply(tmp39, []any{v2}) - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("list")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.Apply(tmp43, []any{v3}) - tmp45 := lang.Apply(tmp32, []any{tmp36, tmp40, tmp44}) - tmp46 := lang.Apply(tmp29, []any{tmp45}) - tmp47 := lang.Apply(tmp26, []any{tmp46}) - tmp48 := lang.Apply(tmp15, []any{tmp19, tmp23, tmp47}) - tmp49 := lang.Apply(tmp12, []any{tmp48}) - tmp4 = tmp49 - } // end let - return tmp4 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v2 := args[0] - _ = v2 - v3 := args[1] - _ = v3 - var v4 any = lang.NewList(args[2:]...) - _ = v4 - var tmp5 any - { // let - // let binding "op" - var tmp6 any - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - if lang.IsTruthy(tmp9) { - tmp6 = closed3 - } else { - tmp6 = closed4 - } - var v10 any = tmp6 - _ = v10 - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - var tmp14 lang.FnFunc - tmp14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v15 := args[0] - _ = v15 - v16 := args[1] - _ = v16 - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("concat")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol(".")}) - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.Apply(tmp42, []any{v10}) - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.Apply(tmp46, []any{v15}) - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v16}) - tmp52 := lang.Apply(tmp39, []any{tmp43, tmp47, tmp51}) - tmp53 := lang.Apply(tmp36, []any{tmp52}) - tmp54 := lang.Apply(tmp33, []any{tmp53}) - tmp55 := lang.Apply(tmp22, []any{tmp26, tmp30, tmp54}) - tmp56 := lang.Apply(tmp19, []any{tmp55}) - return tmp56 - }) - tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) - tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("concat")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol(".")}) - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.Apply(tmp42, []any{v10}) - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.Apply(tmp46, []any{v2}) - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v3}) - tmp52 := lang.Apply(tmp39, []any{tmp43, tmp47, tmp51}) - tmp53 := lang.Apply(tmp36, []any{tmp52}) - tmp54 := lang.Apply(tmp33, []any{tmp53}) - tmp55 := lang.Apply(tmp22, []any{tmp26, tmp30, tmp54}) - tmp56 := lang.Apply(tmp19, []any{tmp55}) - tmp57 := lang.Apply(tmp13, []any{tmp16, tmp56, v4}) - tmp5 = tmp57 - } // end let - return tmp5 - } - }) - tmp1 = tmp1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) - } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp0 := lang.NewSymbol("+").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the sum of nums. (+) returns 0. Does not auto-promote\n longs, will throw on overflow. See also: +'", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), tmp2, lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(977), lang.NewKeyword("end-line"), int(977))).(*lang.Symbol) - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - return int64(0) - case 1: - v5 := args[0] - _ = v5 - tmp6 := lang.Apply(lang.MustAsNumber, []any{v5}) - return tmp6 - case 2: - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - tmp7, _ := lang.FieldOrMethod(lang.Numbers, "Add") - if reflect.TypeOf(tmp7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Add is not a function"))) - } - tmp8 := lang.Apply(tmp7, []any{v5, v6}) - return tmp8 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - var v7 any = lang.NewList(args[2:]...) - _ = v7 - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("+")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("+")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{v5, v6}) - tmp18 := lang.Apply(tmp10, []any{tmp13, tmp17, v7}) - return tmp18 - } - }) - tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp3 := ns.InternWithValue(tmp0, tmp4, true) - if tmp0.Meta() != nil { - tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // +' - { - var tmp1 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v2 := args[0] - _ = v2 - var tmp3 any - { // let - // let binding "op" - var tmp4 any - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - if lang.IsTruthy(tmp7) { - tmp4 = closed5 - } else { - tmp4 = closed5 - } - var v8 any = tmp4 - _ = v8 - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("seq")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("concat")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol(".")}) - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("seq")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("concat")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.Apply(tmp34, []any{v8}) - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{v2}) - tmp40 := lang.Apply(tmp31, []any{tmp35, tmp39}) - tmp41 := lang.Apply(tmp28, []any{tmp40}) - tmp42 := lang.Apply(tmp25, []any{tmp41}) - tmp43 := lang.Apply(tmp14, []any{tmp18, tmp22, tmp42}) - tmp44 := lang.Apply(tmp11, []any{tmp43}) - tmp3 = tmp44 - } // end let - return tmp3 - case 2: - v2 := args[0] - _ = v2 - v3 := args[1] - _ = v3 - var tmp4 any - { // let - // let binding "op" - var tmp5 any - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - if lang.IsTruthy(tmp8) { - tmp5 = closed5 - } else { - tmp5 = closed5 - } - var v9 any = tmp5 - _ = v9 - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("seq")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("concat")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("list")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{lang.NewSymbol(".")}) - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("list")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.Apply(tmp22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("list")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("seq")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("concat")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("list")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.Apply(tmp35, []any{v9}) - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("list")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.Apply(tmp39, []any{v2}) - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("list")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.Apply(tmp43, []any{v3}) - tmp45 := lang.Apply(tmp32, []any{tmp36, tmp40, tmp44}) - tmp46 := lang.Apply(tmp29, []any{tmp45}) - tmp47 := lang.Apply(tmp26, []any{tmp46}) - tmp48 := lang.Apply(tmp15, []any{tmp19, tmp23, tmp47}) - tmp49 := lang.Apply(tmp12, []any{tmp48}) - tmp4 = tmp49 - } // end let - return tmp4 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v2 := args[0] - _ = v2 - v3 := args[1] - _ = v3 - var v4 any = lang.NewList(args[2:]...) - _ = v4 - var tmp5 any - { // let - // let binding "op" - var tmp6 any - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - if lang.IsTruthy(tmp9) { - tmp6 = closed5 - } else { - tmp6 = closed5 - } - var v10 any = tmp6 - _ = v10 - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - var tmp14 lang.FnFunc - tmp14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v15 := args[0] - _ = v15 - v16 := args[1] - _ = v16 - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("concat")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol(".")}) - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.Apply(tmp42, []any{v10}) - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.Apply(tmp46, []any{v15}) - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v16}) - tmp52 := lang.Apply(tmp39, []any{tmp43, tmp47, tmp51}) - tmp53 := lang.Apply(tmp36, []any{tmp52}) - tmp54 := lang.Apply(tmp33, []any{tmp53}) - tmp55 := lang.Apply(tmp22, []any{tmp26, tmp30, tmp54}) - tmp56 := lang.Apply(tmp19, []any{tmp55}) - return tmp56 - }) - tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) - tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("concat")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol(".")}) - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.Apply(tmp42, []any{v10}) - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.Apply(tmp46, []any{v2}) - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v3}) - tmp52 := lang.Apply(tmp39, []any{tmp43, tmp47, tmp51}) - tmp53 := lang.Apply(tmp36, []any{tmp52}) - tmp54 := lang.Apply(tmp33, []any{tmp53}) - tmp55 := lang.Apply(tmp22, []any{tmp26, tmp30, tmp54}) - tmp56 := lang.Apply(tmp19, []any{tmp55}) - tmp57 := lang.Apply(tmp13, []any{tmp16, tmp56, v4}) - tmp5 = tmp57 - } // end let - return tmp5 - } - }) - tmp1 = tmp1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) - } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp0 := lang.NewSymbol("+'").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the sum of nums. (+') returns 0. Supports arbitrary precision.\n See also: +", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), tmp2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(965), lang.NewKeyword("end-line"), int(965))).(*lang.Symbol) - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - return int64(0) - case 1: - v5 := args[0] - _ = v5 - tmp6 := lang.Apply(lang.MustAsNumber, []any{v5}) - return tmp6 - case 2: - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - tmp7, _ := lang.FieldOrMethod(lang.Numbers, "AddP") - if reflect.TypeOf(tmp7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("AddP is not a function"))) - } - tmp8 := lang.Apply(tmp7, []any{v5, v6}) - return tmp8 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - var v7 any = lang.NewList(args[2:]...) - _ = v7 - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("+'")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("+'")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{v5, v6}) - tmp18 := lang.Apply(tmp10, []any{tmp13, tmp17, v7}) - return tmp18 - } - }) - tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp3 := ns.InternWithValue(tmp0, tmp4, true) - if tmp0.Meta() != nil { - tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // - - { - var tmp1 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v2 := args[0] - _ = v2 - var tmp3 any - { // let - // let binding "op" - var tmp4 any - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - if lang.IsTruthy(tmp7) { - tmp4 = closed6 - } else { - tmp4 = closed7 - } - var v8 any = tmp4 - _ = v8 - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("seq")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("concat")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol(".")}) - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("seq")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("concat")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.Apply(tmp34, []any{v8}) - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{v2}) - tmp40 := lang.Apply(tmp31, []any{tmp35, tmp39}) - tmp41 := lang.Apply(tmp28, []any{tmp40}) - tmp42 := lang.Apply(tmp25, []any{tmp41}) - tmp43 := lang.Apply(tmp14, []any{tmp18, tmp22, tmp42}) - tmp44 := lang.Apply(tmp11, []any{tmp43}) - tmp3 = tmp44 - } // end let - return tmp3 - case 2: - v2 := args[0] - _ = v2 - v3 := args[1] - _ = v3 - var tmp4 any - { // let - // let binding "op" - var tmp5 any - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - if lang.IsTruthy(tmp8) { - tmp5 = closed6 - } else { - tmp5 = closed7 - } - var v9 any = tmp5 - _ = v9 - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("seq")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("concat")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("list")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{lang.NewSymbol(".")}) - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("list")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.Apply(tmp22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("list")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("seq")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("concat")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("list")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.Apply(tmp35, []any{v9}) - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("list")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.Apply(tmp39, []any{v2}) - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("list")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.Apply(tmp43, []any{v3}) - tmp45 := lang.Apply(tmp32, []any{tmp36, tmp40, tmp44}) - tmp46 := lang.Apply(tmp29, []any{tmp45}) - tmp47 := lang.Apply(tmp26, []any{tmp46}) - tmp48 := lang.Apply(tmp15, []any{tmp19, tmp23, tmp47}) - tmp49 := lang.Apply(tmp12, []any{tmp48}) - tmp4 = tmp49 - } // end let - return tmp4 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v2 := args[0] - _ = v2 - v3 := args[1] - _ = v3 - var v4 any = lang.NewList(args[2:]...) - _ = v4 - var tmp5 any - { // let - // let binding "op" - var tmp6 any - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - if lang.IsTruthy(tmp9) { - tmp6 = closed6 - } else { - tmp6 = closed7 - } - var v10 any = tmp6 - _ = v10 - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - var tmp14 lang.FnFunc - tmp14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v15 := args[0] - _ = v15 - v16 := args[1] - _ = v16 - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("concat")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol(".")}) - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.Apply(tmp42, []any{v10}) - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.Apply(tmp46, []any{v15}) - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v16}) - tmp52 := lang.Apply(tmp39, []any{tmp43, tmp47, tmp51}) - tmp53 := lang.Apply(tmp36, []any{tmp52}) - tmp54 := lang.Apply(tmp33, []any{tmp53}) - tmp55 := lang.Apply(tmp22, []any{tmp26, tmp30, tmp54}) - tmp56 := lang.Apply(tmp19, []any{tmp55}) - return tmp56 - }) - tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) - tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("concat")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol(".")}) - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.Apply(tmp42, []any{v10}) - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.Apply(tmp46, []any{v2}) - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v3}) - tmp52 := lang.Apply(tmp39, []any{tmp43, tmp47, tmp51}) - tmp53 := lang.Apply(tmp36, []any{tmp52}) - tmp54 := lang.Apply(tmp33, []any{tmp53}) - tmp55 := lang.Apply(tmp22, []any{tmp26, tmp30, tmp54}) - tmp56 := lang.Apply(tmp19, []any{tmp55}) - tmp57 := lang.Apply(tmp13, []any{tmp16, tmp56, v4}) - tmp5 = tmp57 - } // end let - return tmp5 - } - }) - tmp1 = tmp1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) - } - tmp5 := lang.Apply(tmp4, []any{nil, int64(0)}) - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp0 := lang.NewSymbol("-").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "If no ys are supplied, returns the negation of x, else subtracts\n the ys from x and returns the result. Does not auto-promote\n longs, will throw on overflow. See also: -'", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), tmp2, lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1036), lang.NewKeyword("end-line"), int(1036))).(*lang.Symbol) - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v5 := args[0] - _ = v5 - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("*")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(tmp8, []any{int64(-1), v5}) - return tmp9 - case 2: - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - tmp7, _ := lang.FieldOrMethod(lang.Numbers, "Minus") - if reflect.TypeOf(tmp7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Minus is not a function"))) - } - tmp8 := lang.Apply(tmp7, []any{v5, v6}) - return tmp8 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - var v7 any = lang.NewList(args[2:]...) - _ = v7 - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("-")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("-")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{v5, v6}) - tmp18 := lang.Apply(tmp10, []any{tmp13, tmp17, v7}) - return tmp18 - } - }) - tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp3 := ns.InternWithValue(tmp0, tmp4, true) - if tmp0.Meta() != nil { - tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // -' - { - var tmp1 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v2 := args[0] - _ = v2 - var tmp3 any - { // let - // let binding "op" - var tmp4 any - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - if lang.IsTruthy(tmp7) { - tmp4 = closed8 - } else { - tmp4 = closed8 - } - var v8 any = tmp4 - _ = v8 - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("seq")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("concat")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol(".")}) - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("seq")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("concat")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.Apply(tmp34, []any{v8}) - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{v2}) - tmp40 := lang.Apply(tmp31, []any{tmp35, tmp39}) - tmp41 := lang.Apply(tmp28, []any{tmp40}) - tmp42 := lang.Apply(tmp25, []any{tmp41}) - tmp43 := lang.Apply(tmp14, []any{tmp18, tmp22, tmp42}) - tmp44 := lang.Apply(tmp11, []any{tmp43}) - tmp3 = tmp44 - } // end let - return tmp3 - case 2: - v2 := args[0] - _ = v2 - v3 := args[1] - _ = v3 - var tmp4 any - { // let - // let binding "op" - var tmp5 any - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - if lang.IsTruthy(tmp8) { - tmp5 = closed8 - } else { - tmp5 = closed8 - } - var v9 any = tmp5 - _ = v9 - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("seq")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("concat")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("list")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{lang.NewSymbol(".")}) - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("list")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.Apply(tmp22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("list")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("seq")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("concat")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("list")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.Apply(tmp35, []any{v9}) - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("list")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.Apply(tmp39, []any{v2}) - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("list")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.Apply(tmp43, []any{v3}) - tmp45 := lang.Apply(tmp32, []any{tmp36, tmp40, tmp44}) - tmp46 := lang.Apply(tmp29, []any{tmp45}) - tmp47 := lang.Apply(tmp26, []any{tmp46}) - tmp48 := lang.Apply(tmp15, []any{tmp19, tmp23, tmp47}) - tmp49 := lang.Apply(tmp12, []any{tmp48}) - tmp4 = tmp49 - } // end let - return tmp4 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v2 := args[0] - _ = v2 - v3 := args[1] - _ = v3 - var v4 any = lang.NewList(args[2:]...) - _ = v4 - var tmp5 any - { // let - // let binding "op" - var tmp6 any - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - if lang.IsTruthy(tmp9) { - tmp6 = closed8 - } else { - tmp6 = closed8 - } - var v10 any = tmp6 - _ = v10 - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - var tmp14 lang.FnFunc - tmp14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v15 := args[0] - _ = v15 - v16 := args[1] - _ = v16 - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("concat")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol(".")}) - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.Apply(tmp42, []any{v10}) - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.Apply(tmp46, []any{v15}) - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v16}) - tmp52 := lang.Apply(tmp39, []any{tmp43, tmp47, tmp51}) - tmp53 := lang.Apply(tmp36, []any{tmp52}) - tmp54 := lang.Apply(tmp33, []any{tmp53}) - tmp55 := lang.Apply(tmp22, []any{tmp26, tmp30, tmp54}) - tmp56 := lang.Apply(tmp19, []any{tmp55}) - return tmp56 - }) - tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) - tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("concat")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol(".")}) - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.Apply(tmp42, []any{v10}) - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.Apply(tmp46, []any{v2}) - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v3}) - tmp52 := lang.Apply(tmp39, []any{tmp43, tmp47, tmp51}) - tmp53 := lang.Apply(tmp36, []any{tmp52}) - tmp54 := lang.Apply(tmp33, []any{tmp53}) - tmp55 := lang.Apply(tmp22, []any{tmp26, tmp30, tmp54}) - tmp56 := lang.Apply(tmp19, []any{tmp55}) - tmp57 := lang.Apply(tmp13, []any{tmp16, tmp56, v4}) - tmp5 = tmp57 - } // end let - return tmp5 - } - }) - tmp1 = tmp1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) - } - tmp5 := lang.Apply(tmp4, []any{nil, int64(0)}) - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp0 := lang.NewSymbol("-'").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "If no ys are supplied, returns the negation of x, else subtracts\n the ys from x and returns the result. Supports arbitrary precision.\n See also: -", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), tmp2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1024), lang.NewKeyword("end-line"), int(1024))).(*lang.Symbol) - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v5 := args[0] - _ = v5 - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("*'")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(tmp8, []any{int64(-1), v5}) - return tmp9 - case 2: - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - tmp7, _ := lang.FieldOrMethod(lang.Numbers, "MinusP") - if reflect.TypeOf(tmp7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("MinusP is not a function"))) - } - tmp8 := lang.Apply(tmp7, []any{v5, v6}) - return tmp8 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - var v7 any = lang.NewList(args[2:]...) - _ = v7 - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("-'")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("-'")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{v5, v6}) - tmp18 := lang.Apply(tmp10, []any{tmp13, tmp17, v7}) - return tmp18 - } - }) - tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp3 := ns.InternWithValue(tmp0, tmp4, true) - if tmp0.Meta() != nil { - tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // -> - { - tmp0 := lang.NewSymbol("->").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "Threads the expr through the forms. Inserts x as the\n second item in the first form, making a list of it if it is not a\n list already. If there are more forms, inserts the first form as the\n second item in second form, etc.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1675), lang.NewKeyword("end-line"), int(1675))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any - { // let - // let binding "x" - var v8 any = v5 - _ = v8 - // let binding "forms" - var v9 any = v6 - _ = v9 - for { - var tmp10 any - if lang.IsTruthy(v9) { - var tmp11 any - { // let - // let binding "form" - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("first")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.Apply(tmp14, []any{v9}) - var v16 any = tmp15 - _ = v16 - // let binding "threaded" - var tmp17 any - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("seq?")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.Apply(tmp20, []any{v16}) - if lang.IsTruthy(tmp21) { - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("with-meta")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("seq")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("concat")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("first")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.Apply(tmp36, []any{v16}) - tmp38 := lang.Apply(tmp33, []any{tmp37}) - tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp40 := tmp39.FindInternedVar(lang.NewSymbol("list")) - if tmp40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) - } - tmp41 := tmp40.Get() - tmp42 := lang.Apply(tmp41, []any{v8}) - tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp44 := tmp43.FindInternedVar(lang.NewSymbol("next")) - if tmp44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) - } - tmp45 := tmp44.Get() - tmp46 := lang.Apply(tmp45, []any{v16}) - tmp47 := lang.Apply(tmp30, []any{tmp38, tmp42, tmp46}) - tmp48 := lang.Apply(tmp27, []any{tmp47}) - tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp50 := tmp49.FindInternedVar(lang.NewSymbol("meta")) - if tmp50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) - } - tmp51 := tmp50.Get() - tmp52 := lang.Apply(tmp51, []any{v16}) - tmp53 := lang.Apply(tmp24, []any{tmp48, tmp52}) - tmp17 = tmp53 - } else { - tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp55 := tmp54.FindInternedVar(lang.NewSymbol("list")) - if tmp55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) - } - tmp56 := tmp55.Get() - tmp57 := lang.Apply(tmp56, []any{v16, v8}) - tmp17 = tmp57 - } - var v58 any = tmp17 - _ = v58 - var tmp59 any = v58 - tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp62 := tmp61.FindInternedVar(lang.NewSymbol("next")) - if tmp62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) - } - tmp63 := tmp62.Get() - tmp64 := lang.Apply(tmp63, []any{v9}) - var tmp60 any = tmp64 - v8 = tmp59 - v9 = tmp60 - continue - } // end let - tmp10 = tmp11 - } else { - tmp10 = v8 - } - tmp7 = tmp10 - break - } - } // end let - return tmp7 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // ->> - { - tmp0 := lang.NewSymbol("->>").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "Threads the expr through the forms. Inserts x as the\n last item in the first form, making a list of it if it is not a\n list already. If there are more forms, inserts the first form as the\n last item in second form, etc.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1691), lang.NewKeyword("end-line"), int(1691))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any - { // let - // let binding "x" - var v8 any = v5 - _ = v8 - // let binding "forms" - var v9 any = v6 - _ = v9 - for { - var tmp10 any - if lang.IsTruthy(v9) { - var tmp11 any - { // let - // let binding "form" - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("first")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.Apply(tmp14, []any{v9}) - var v16 any = tmp15 - _ = v16 - // let binding "threaded" - var tmp17 any - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("seq?")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.Apply(tmp20, []any{v16}) - if lang.IsTruthy(tmp21) { - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("with-meta")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("seq")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("concat")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("first")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.Apply(tmp36, []any{v16}) - tmp38 := lang.Apply(tmp33, []any{tmp37}) - tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp40 := tmp39.FindInternedVar(lang.NewSymbol("next")) - if tmp40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) - } - tmp41 := tmp40.Get() - tmp42 := lang.Apply(tmp41, []any{v16}) - tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp44 := tmp43.FindInternedVar(lang.NewSymbol("list")) - if tmp44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) - } - tmp45 := tmp44.Get() - tmp46 := lang.Apply(tmp45, []any{v8}) - tmp47 := lang.Apply(tmp30, []any{tmp38, tmp42, tmp46}) - tmp48 := lang.Apply(tmp27, []any{tmp47}) - tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp50 := tmp49.FindInternedVar(lang.NewSymbol("meta")) - if tmp50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) - } - tmp51 := tmp50.Get() - tmp52 := lang.Apply(tmp51, []any{v16}) - tmp53 := lang.Apply(tmp24, []any{tmp48, tmp52}) - tmp17 = tmp53 - } else { - tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp55 := tmp54.FindInternedVar(lang.NewSymbol("list")) - if tmp55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) - } - tmp56 := tmp55.Get() - tmp57 := lang.Apply(tmp56, []any{v16, v8}) - tmp17 = tmp57 - } - var v58 any = tmp17 - _ = v58 - var tmp59 any = v58 - tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp62 := tmp61.FindInternedVar(lang.NewSymbol("next")) - if tmp62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) - } - tmp63 := tmp62.Get() - tmp64 := lang.Apply(tmp63, []any{v9}) - var tmp60 any = tmp64 - v8 = tmp59 - v9 = tmp60 - continue - } // end let - tmp10 = tmp11 - } else { - tmp10 = v8 - } - tmp7 = tmp10 - break - } - } // end let - return tmp7 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // -protocols - { - tmp0 := lang.NewSymbol("-protocols").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("doc"), "Private store of protocols. Go's reflection capabilities\n don't yet support a native interface-based implementation, so\n protocols are implemented in Glojure as maps from type to protocol\n method implementations.", lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(21), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(26), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - tmp3 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("coll-reduce"), nil), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("coll-reduce"), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("f"), lang.NewSymbol("val")))))) - tmp4 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("internal-reduce"), nil), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("internal-reduce"), lang.NewVector(lang.NewSymbol("seq"), lang.NewSymbol("f"), lang.NewSymbol("start")))))) - tmp5 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("kv-reduce"), nil), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("kv-reduce"), lang.NewVector(lang.NewSymbol("amap"), lang.NewSymbol("f"), lang.NewSymbol("init")))))) - tmp6 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("datafy"), nil), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("datafy"), lang.NewVector(lang.NewSymbol("o")), "return a representation of o as data (default identity)")))) - tmp7 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("nav"), nil), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("nav"), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("k"), lang.NewSymbol("v")), "return (possibly transformed) v in the context of coll and k (a key/index or nil),\ndefaults to returning v.")))) - tmp8 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("make-reader"), nil, lang.NewKeyword("make-writer"), nil, lang.NewKeyword("make-input-stream"), nil, lang.NewKeyword("make-output-stream"), nil), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("make-reader"), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("opts")), "Creates an io.Reader. See also IOFactory docs."), lang.NewList(lang.NewSymbol("make-writer"), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("opts")), "Creates an io.Reader. See also IOFactory docs."), lang.NewList(lang.NewSymbol("make-input-stream"), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("opts")), "Creates a BufferedInputStream. See also IOFactory docs."), lang.NewList(lang.NewSymbol("make-output-stream"), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("opts")), "Creates a BufferedOutputStream. See also IOFactory docs.")))) - tmp2 := lang.NewAtom(lang.NewMap(lang.NewSymbol("CollReduce"), tmp3, lang.NewSymbol("InternalReduce"), tmp4, lang.NewSymbol("IKVReduce"), tmp5, lang.NewSymbol("Datafiable"), tmp6, lang.NewSymbol("Navigable"), tmp7, lang.NewSymbol("IOFactory"), tmp8)) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // .. - { - tmp0 := lang.NewSymbol("..").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("form")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("form"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "form => fieldName-symbol or (instanceMethodName-symbol args*)\n\n Expands into a member access (.) of the first member on the first\n argument, followed by the next member on the result, etc. For\n instance:\n\n (.. System (getProperties) (get \"os.name\"))\n\n expands to:\n\n (. (. System (getProperties)) (get \"os.name\"))\n\n but is easier to write, read, and understand.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1657), lang.NewKeyword("end-line"), int(1657))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 4: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("seq")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("concat")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("list")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("list")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.Apply(tmp19, []any{v5}) - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("list")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.Apply(tmp23, []any{v6}) - tmp25 := lang.Apply(tmp12, []any{tmp16, tmp20, tmp24}) - tmp26 := lang.Apply(tmp9, []any{tmp25}) - return tmp26 - default: - if len(args) < 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - var v7 any = lang.NewList(args[4:]...) - _ = v7 - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("seq")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("concat")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("..")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol(".")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{v5}) - tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp36 := tmp35.FindInternedVar(lang.NewSymbol("list")) - if tmp36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) - } - tmp37 := tmp36.Get() - tmp38 := lang.Apply(tmp37, []any{v6}) - tmp39 := lang.Apply(tmp26, []any{tmp30, tmp34, tmp38}) - tmp40 := lang.Apply(tmp23, []any{tmp39}) - tmp41 := lang.Apply(tmp20, []any{tmp40}) - tmp42 := lang.Apply(tmp13, []any{tmp17, tmp41, v7}) - tmp43 := lang.Apply(tmp10, []any{tmp42}) - return tmp43 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // / - { - var tmp1 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v2 := args[0] - _ = v2 - var tmp3 any - { // let - // let binding "op" - var tmp4 any - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - if lang.IsTruthy(tmp7) { - tmp4 = closed9 - } else { - tmp4 = closed9 - } - var v8 any = tmp4 - _ = v8 - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("seq")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("concat")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol(".")}) - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("seq")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("concat")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.Apply(tmp34, []any{v8}) - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{v2}) - tmp40 := lang.Apply(tmp31, []any{tmp35, tmp39}) - tmp41 := lang.Apply(tmp28, []any{tmp40}) - tmp42 := lang.Apply(tmp25, []any{tmp41}) - tmp43 := lang.Apply(tmp14, []any{tmp18, tmp22, tmp42}) - tmp44 := lang.Apply(tmp11, []any{tmp43}) - tmp3 = tmp44 - } // end let - return tmp3 - case 2: - v2 := args[0] - _ = v2 - v3 := args[1] - _ = v3 - var tmp4 any - { // let - // let binding "op" - var tmp5 any - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - if lang.IsTruthy(tmp8) { - tmp5 = closed9 - } else { - tmp5 = closed9 - } - var v9 any = tmp5 - _ = v9 - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("seq")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("concat")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("list")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{lang.NewSymbol(".")}) - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("list")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.Apply(tmp22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("list")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("seq")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("concat")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("list")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.Apply(tmp35, []any{v9}) - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("list")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.Apply(tmp39, []any{v2}) - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("list")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.Apply(tmp43, []any{v3}) - tmp45 := lang.Apply(tmp32, []any{tmp36, tmp40, tmp44}) - tmp46 := lang.Apply(tmp29, []any{tmp45}) - tmp47 := lang.Apply(tmp26, []any{tmp46}) - tmp48 := lang.Apply(tmp15, []any{tmp19, tmp23, tmp47}) - tmp49 := lang.Apply(tmp12, []any{tmp48}) - tmp4 = tmp49 - } // end let - return tmp4 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v2 := args[0] - _ = v2 - v3 := args[1] - _ = v3 - var v4 any = lang.NewList(args[2:]...) - _ = v4 - var tmp5 any - { // let - // let binding "op" - var tmp6 any - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - if lang.IsTruthy(tmp9) { - tmp6 = closed9 - } else { - tmp6 = closed9 - } - var v10 any = tmp6 - _ = v10 - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - var tmp14 lang.FnFunc - tmp14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v15 := args[0] - _ = v15 - v16 := args[1] - _ = v16 - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("concat")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol(".")}) - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.Apply(tmp42, []any{v10}) - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.Apply(tmp46, []any{v15}) - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v16}) - tmp52 := lang.Apply(tmp39, []any{tmp43, tmp47, tmp51}) - tmp53 := lang.Apply(tmp36, []any{tmp52}) - tmp54 := lang.Apply(tmp33, []any{tmp53}) - tmp55 := lang.Apply(tmp22, []any{tmp26, tmp30, tmp54}) - tmp56 := lang.Apply(tmp19, []any{tmp55}) - return tmp56 - }) - tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) - tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("concat")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol(".")}) - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.Apply(tmp42, []any{v10}) - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.Apply(tmp46, []any{v2}) - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v3}) - tmp52 := lang.Apply(tmp39, []any{tmp43, tmp47, tmp51}) - tmp53 := lang.Apply(tmp36, []any{tmp52}) - tmp54 := lang.Apply(tmp33, []any{tmp53}) - tmp55 := lang.Apply(tmp22, []any{tmp26, tmp30, tmp54}) - tmp56 := lang.Apply(tmp19, []any{tmp55}) - tmp57 := lang.Apply(tmp13, []any{tmp16, tmp56, v4}) - tmp5 = tmp57 - } // end let - return tmp5 - } - }) - tmp1 = tmp1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) - } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp0 := lang.NewSymbol("/").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "If no denominators are supplied, returns 1/numerator,\n else returns numerator divided by all of the denominators.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), tmp2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1013), lang.NewKeyword("end-line"), int(1013))).(*lang.Symbol) - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v5 := args[0] - _ = v5 - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("/")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(tmp8, []any{int64(1), v5}) - return tmp9 - case 2: - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - tmp7, _ := lang.FieldOrMethod(lang.Numbers, "Divide") - if reflect.TypeOf(tmp7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Divide is not a function"))) - } - tmp8 := lang.Apply(tmp7, []any{v5, v6}) - return tmp8 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - var v7 any = lang.NewList(args[2:]...) - _ = v7 - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("/")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("/")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{v5, v6}) - tmp18 := lang.Apply(tmp10, []any{tmp13, tmp17, v7}) - return tmp18 - } - }) - tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp3 := ns.InternWithValue(tmp0, tmp4, true) - if tmp0.Meta() != nil { - tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // < - { - var tmp1 lang.FnFunc - { // function <__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("concat")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("list")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol(".")}) - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("seq")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("concat")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("list")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.Apply(tmp30, []any{lang.NewSymbol("glojure.core/Lt")}) - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.Apply(tmp34, []any{v3}) - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{v4}) - tmp40 := lang.Apply(tmp27, []any{tmp31, tmp35, tmp39}) - tmp41 := lang.Apply(tmp24, []any{tmp40}) - tmp42 := lang.Apply(tmp21, []any{tmp41}) - tmp43 := lang.Apply(tmp10, []any{tmp14, tmp18, tmp42}) - tmp44 := lang.Apply(tmp7, []any{tmp43}) - return tmp44 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("<").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns non-nil if nums are in monotonically increasing order,\n otherwise false.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(893), lang.NewKeyword("end-line"), int(893))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v4 := args[0] - _ = v4 - return true - case 2: - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Lt") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Lt is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - var v6 any = lang.NewList(args[2:]...) - _ = v6 - recur_loop_150: - var tmp7 any - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("<")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v4, v5}) - if lang.IsTruthy(tmp11) { - var tmp12 any - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("next")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{v6}) - if lang.IsTruthy(tmp16) { - var tmp17 any = v5 - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("first")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, []any{v6}) - var tmp18 any = tmp22 - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("next")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.Apply(tmp26, []any{v6}) - var tmp23 any = tmp27 - v4 = tmp17 - v5 = tmp18 - v6 = tmp23 - goto recur_loop_150 - } else { - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("<")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("first")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{v6}) - tmp35 := lang.Apply(tmp30, []any{v5, tmp34}) - tmp12 = tmp35 - } - tmp7 = tmp12 - } else { - tmp7 = false - } - return tmp7 - } - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // <= - { - var tmp1 lang.FnFunc - { // function <=__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("concat")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("list")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol(".")}) - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("seq")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("concat")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("list")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.Apply(tmp30, []any{lang.NewSymbol("glojure.core/Lte")}) - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.Apply(tmp34, []any{v3}) - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{v4}) - tmp40 := lang.Apply(tmp27, []any{tmp31, tmp35, tmp39}) - tmp41 := lang.Apply(tmp24, []any{tmp40}) - tmp42 := lang.Apply(tmp21, []any{tmp41}) - tmp43 := lang.Apply(tmp10, []any{tmp14, tmp18, tmp42}) - tmp44 := lang.Apply(tmp7, []any{tmp43}) - return tmp44 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("<=").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns non-nil if nums are in monotonically non-decreasing order,\n otherwise false.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1048), lang.NewKeyword("end-line"), int(1048))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v4 := args[0] - _ = v4 - return true - case 2: - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Lte") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Lte is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - var v6 any = lang.NewList(args[2:]...) - _ = v6 - recur_loop_194: - var tmp7 any - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("<=")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v4, v5}) - if lang.IsTruthy(tmp11) { - var tmp12 any - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("next")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{v6}) - if lang.IsTruthy(tmp16) { - var tmp17 any = v5 - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("first")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, []any{v6}) - var tmp18 any = tmp22 - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("next")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.Apply(tmp26, []any{v6}) - var tmp23 any = tmp27 - v4 = tmp17 - v5 = tmp18 - v6 = tmp23 - goto recur_loop_194 - } else { - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("<=")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("first")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{v6}) - tmp35 := lang.Apply(tmp30, []any{v5, tmp34}) - tmp12 = tmp35 - } - tmp7 = tmp12 - } else { - tmp7 = false - } - return tmp7 - } - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // = - { - var tmp1 lang.FnFunc - { // function =__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("concat")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("list")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol(".")}) - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("glojure.lang.Util")}) - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("glojure.core/equiv")}) - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.Apply(tmp25, []any{v3}) - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{v4}) - tmp31 := lang.Apply(tmp10, []any{tmp14, tmp18, tmp22, tmp26, tmp30}) - tmp32 := lang.Apply(tmp7, []any{tmp31}) - return tmp32 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("=").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Equality. Returns true if x equals y, false if not. Same as\n Java x.equals(y) except it also works for nil, and compares\n numbers and collections in a type-independent manner. Clojure's immutable data\n structures define equals() (and thus =) as a value, not an identity,\n comparison.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(776), lang.NewKeyword("end-line"), int(776))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v4 := args[0] - _ = v4 - return true - case 2: - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6 := lang.Apply(lang.Equiv, []any{v4, v5}) - return tmp6 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - var v6 any = lang.NewList(args[2:]...) - _ = v6 - recur_loop_126: - var tmp7 any - tmp8 := lang.Apply(lang.Equiv, []any{v4, v5}) - if lang.IsTruthy(tmp8) { - var tmp9 any - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("next")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{v6}) - if lang.IsTruthy(tmp13) { - var tmp14 any = v5 - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("first")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{v6}) - var tmp15 any = tmp19 - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("next")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.Apply(tmp23, []any{v6}) - var tmp20 any = tmp24 - v4 = tmp14 - v5 = tmp15 - v6 = tmp20 - goto recur_loop_126 - } else { - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("first")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.Apply(tmp27, []any{v6}) - tmp29 := lang.Apply(lang.Equiv, []any{v5, tmp28}) - tmp9 = tmp29 - } - tmp7 = tmp9 - } else { - tmp7 = false - } - return tmp7 - } - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // == - { - var tmp1 lang.FnFunc - { // function ==__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("concat")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("list")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol(".")}) - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("seq")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("concat")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("list")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.Apply(tmp30, []any{lang.NewSymbol("glojure.core/Equiv")}) - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.Apply(tmp34, []any{v3}) - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{v4}) - tmp40 := lang.Apply(tmp27, []any{tmp31, tmp35, tmp39}) - tmp41 := lang.Apply(tmp24, []any{tmp40}) - tmp42 := lang.Apply(tmp21, []any{tmp41}) - tmp43 := lang.Apply(tmp10, []any{tmp14, tmp18, tmp42}) - tmp44 := lang.Apply(tmp7, []any{tmp43}) - return tmp44 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("==").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns non-nil if nums all have the equivalent\n value (type-independent), otherwise false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1093), lang.NewKeyword("end-line"), int(1093))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v4 := args[0] - _ = v4 - return true - case 2: - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Equiv") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Equiv is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - var v6 any = lang.NewList(args[2:]...) - _ = v6 - recur_loop_206: - var tmp7 any - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("==")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v4, v5}) - if lang.IsTruthy(tmp11) { - var tmp12 any - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("next")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{v6}) - if lang.IsTruthy(tmp16) { - var tmp17 any = v5 - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("first")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, []any{v6}) - var tmp18 any = tmp22 - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("next")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.Apply(tmp26, []any{v6}) - var tmp23 any = tmp27 - v4 = tmp17 - v5 = tmp18 - v6 = tmp23 - goto recur_loop_206 - } else { - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("==")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("first")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{v6}) - tmp35 := lang.Apply(tmp30, []any{v5, tmp34}) - tmp12 = tmp35 - } - tmp7 = tmp12 - } else { - tmp7 = false - } - return tmp7 - } - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // > - { - var tmp1 lang.FnFunc - { // function >__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("concat")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("list")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol(".")}) - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("seq")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("concat")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("list")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.Apply(tmp30, []any{lang.NewSymbol("glojure.core/Gt")}) - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.Apply(tmp34, []any{v3}) - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{v4}) - tmp40 := lang.Apply(tmp27, []any{tmp31, tmp35, tmp39}) - tmp41 := lang.Apply(tmp24, []any{tmp40}) - tmp42 := lang.Apply(tmp21, []any{tmp41}) - tmp43 := lang.Apply(tmp10, []any{tmp14, tmp18, tmp42}) - tmp44 := lang.Apply(tmp7, []any{tmp43}) - return tmp44 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol(">").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns non-nil if nums are in monotonically decreasing order,\n otherwise false.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1063), lang.NewKeyword("end-line"), int(1063))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v4 := args[0] - _ = v4 - return true - case 2: - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Gt") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - var v6 any = lang.NewList(args[2:]...) - _ = v6 - recur_loop_198: - var tmp7 any - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol(">")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v4, v5}) - if lang.IsTruthy(tmp11) { - var tmp12 any - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("next")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{v6}) - if lang.IsTruthy(tmp16) { - var tmp17 any = v5 - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("first")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, []any{v6}) - var tmp18 any = tmp22 - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("next")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.Apply(tmp26, []any{v6}) - var tmp23 any = tmp27 - v4 = tmp17 - v5 = tmp18 - v6 = tmp23 - goto recur_loop_198 - } else { - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol(">")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("first")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{v6}) - tmp35 := lang.Apply(tmp30, []any{v5, tmp34}) - tmp12 = tmp35 - } - tmp7 = tmp12 - } else { - tmp7 = false - } - return tmp7 - } - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // >0? - { - tmp0 := lang.NewSymbol(">0?").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(963), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(963), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) - } - tmp5 := lang.Apply(tmp4, []any{nil, int64(0)}) - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // >1? - { - tmp0 := lang.NewSymbol(">1?").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(962), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(962), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) - } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // >= - { - var tmp1 lang.FnFunc - { // function >=__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("concat")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("list")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol(".")}) - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("seq")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("concat")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("list")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.Apply(tmp30, []any{lang.NewSymbol("glojure.core/Gte")}) - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.Apply(tmp34, []any{v3}) - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{v4}) - tmp40 := lang.Apply(tmp27, []any{tmp31, tmp35, tmp39}) - tmp41 := lang.Apply(tmp24, []any{tmp40}) - tmp42 := lang.Apply(tmp21, []any{tmp41}) - tmp43 := lang.Apply(tmp10, []any{tmp14, tmp18, tmp42}) - tmp44 := lang.Apply(tmp7, []any{tmp43}) - return tmp44 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol(">=").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns non-nil if nums are in monotonically non-increasing order,\n otherwise false.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1078), lang.NewKeyword("end-line"), int(1078))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v4 := args[0] - _ = v4 - return true - case 2: - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Gte") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gte is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - var v6 any = lang.NewList(args[2:]...) - _ = v6 - recur_loop_202: - var tmp7 any - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol(">=")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v4, v5}) - if lang.IsTruthy(tmp11) { - var tmp12 any - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("next")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{v6}) - if lang.IsTruthy(tmp16) { - var tmp17 any = v5 - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("first")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, []any{v6}) - var tmp18 any = tmp22 - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("next")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.Apply(tmp26, []any{v6}) - var tmp23 any = tmp27 - v4 = tmp17 - v5 = tmp18 - v6 = tmp23 - goto recur_loop_202 - } else { - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol(">=")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("first")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{v6}) - tmp35 := lang.Apply(tmp30, []any{v5, tmp34}) - tmp12 = tmp35 - } - tmp7 = tmp12 - } else { - tmp7 = false - } - return tmp7 - } - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // NaN? - { - var tmp1 lang.FnFunc - { // function NaN?__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol("math.IsNaN")}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{v3}) - tmp18 := lang.Apply(tmp9, []any{tmp13, tmp17}) - tmp19 := lang.Apply(tmp6, []any{tmp18}) - return tmp19 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("NaN?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns true if num is NaN, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1)})), lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7968), lang.NewKeyword("end-line"), int(7968))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5 := lang.Apply(math3.IsNaN, []any{v4}) - return tmp5 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // StackTraceElement->vec - { - tmp0 := lang.NewSymbol("StackTraceElement->vec").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"))), lang.NewKeyword("doc"), "Constructs a data representation for a StackTraceElement: [class method file line]", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(436), lang.NewKeyword("end-line"), int(436))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("symbol")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7, ok := lang.FieldOrMethod(v3, "getClassName") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getClassName"))) - } - var tmp8 any - switch reflect.TypeOf(tmp7).Kind() { - case reflect.Func: - tmp8 = lang.Apply(tmp7, nil) - default: - tmp8 = tmp7 - } - tmp9 := lang.Apply(tmp6, []any{tmp8}) - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("symbol")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13, ok := lang.FieldOrMethod(v3, "getMethodName") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getMethodName"))) - } - var tmp14 any - switch reflect.TypeOf(tmp13).Kind() { - case reflect.Func: - tmp14 = lang.Apply(tmp13, nil) - default: - tmp14 = tmp13 - } - tmp15 := lang.Apply(tmp12, []any{tmp14}) - tmp16, ok := lang.FieldOrMethod(v3, "getFileName") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getFileName"))) - } - var tmp17 any - switch reflect.TypeOf(tmp16).Kind() { - case reflect.Func: - tmp17 = lang.Apply(tmp16, nil) - default: - tmp17 = tmp16 - } - tmp18, ok := lang.FieldOrMethod(v3, "getLineNumber") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getLineNumber"))) - } - var tmp19 any - switch reflect.TypeOf(tmp18).Kind() { - case reflect.Func: - tmp19 = lang.Apply(tmp18, nil) - default: - tmp19 = tmp18 - } - tmp20 := lang.NewVector(tmp9, tmp15, tmp17, tmp19) - tmp21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(440), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(440), lang.NewKeyword("end-column"), int(94)) - tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp22 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // Throwable->map - { - tmp0 := lang.NewSymbol("Throwable->map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"))), lang.NewKeyword("doc"), "Constructs a data representation for a Throwable with keys:\n :cause - root cause message\n :phase - error phase\n :via - cause chain, with cause keys:\n :type - exception class symbol\n :message - exception message\n :data - ex-data\n :at - top stack element\n :trace - root cause stack elements", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(442), lang.NewKeyword("end-line"), int(442))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "base" - var tmp5 lang.FnFunc - tmp5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v6 := args[0] - _ = v6 - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("merge")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("symbol")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("class")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{v6}) - tmp17, ok := lang.FieldOrMethod(tmp16, "Name") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp16, "Name"))) - } - var tmp18 any - switch reflect.TypeOf(tmp17).Kind() { - case reflect.Func: - tmp18 = lang.Apply(tmp17, nil) - default: - tmp18 = tmp17 - } - tmp19 := lang.Apply(tmp12, []any{tmp18}) - tmp20 := lang.NewMap(lang.NewKeyword("type"), tmp19) - tmp21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(455), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(455), lang.NewKeyword("end-column"), int(56)) - tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var tmp23 any - { // let - // let binding "temp__0__auto__" - tmp24, ok := lang.FieldOrMethod(v6, "getLocalizedMessage") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "getLocalizedMessage"))) - } - var tmp25 any - switch reflect.TypeOf(tmp24).Kind() { - case reflect.Func: - tmp25 = lang.Apply(tmp24, nil) - default: - tmp25 = tmp24 - } - var v26 any = tmp25 - _ = v26 - var tmp27 any - if lang.IsTruthy(v26) { - var tmp28 any - { // let - // let binding "msg" - var v29 any = v26 - _ = v29 - tmp30 := lang.NewMap(lang.NewKeyword("message"), v29) - tmp31 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(457), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(457), lang.NewKeyword("end-column"), int(33)) - tmp32, err := lang.WithMeta(tmp30, tmp31.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp28 = tmp32 - } // end let - tmp27 = tmp28 - } else { - } - tmp23 = tmp27 - } // end let - var tmp24 any - { // let - // let binding "temp__0__auto__" - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("ex-data")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.Apply(tmp27, []any{v6}) - var v29 any = tmp28 - _ = v29 - var tmp30 any - if lang.IsTruthy(v29) { - var tmp31 any - { // let - // let binding "ed" - var v32 any = v29 - _ = v32 - tmp33 := lang.NewMap(lang.NewKeyword("data"), v32) - tmp34 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(459), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(459), lang.NewKeyword("end-column"), int(29)) - tmp35, err := lang.WithMeta(tmp33, tmp34.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp31 = tmp35 - } // end let - tmp30 = tmp31 - } else { - } - tmp24 = tmp30 - } // end let - var tmp25 any - { // let - // let binding "st" - tmp26, ok := lang.FieldOrMethod(v6, "getStackTrace") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "getStackTrace"))) - } - var tmp27 any - switch reflect.TypeOf(tmp26).Kind() { - case reflect.Func: - tmp27 = lang.Apply(tmp26, nil) - default: - tmp27 = tmp26 - } - var v28 any = tmp27 - _ = v28 - var tmp29 any - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("pos?")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("alength")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.Apply(tmp35, []any{v28}) - tmp37 := lang.Apply(tmp32, []any{tmp36}) - if lang.IsTruthy(tmp37) { - tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp39 := tmp38.FindInternedVar(lang.NewSymbol("StackTraceElement->vec")) - if tmp39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) - } - tmp40 := tmp39.Get() - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("aget")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.Apply(tmp43, []any{v28, int64(0)}) - tmp45 := lang.Apply(tmp40, []any{tmp44}) - tmp46 := lang.NewMap(lang.NewKeyword("at"), tmp45) - tmp47 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(462), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(462), lang.NewKeyword("end-column"), int(63)) - tmp48, err := lang.WithMeta(tmp46, tmp47.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp29 = tmp48 - } else { - } - tmp25 = tmp29 - } // end let - tmp26 := lang.Apply(tmp9, []any{tmp22, tmp23, tmp24, tmp25}) - return tmp26 - }) - tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(454), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(462), lang.NewKeyword("end-column"), int(67)) - tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v8 any = tmp7 - _ = v8 - // let binding "via" - var tmp9 any - { // let - // let binding "via" - tmp10 := lang.NewVector() - tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(463), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(463), lang.NewKeyword("end-column"), int(25)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v13 any = tmp12 - _ = v13 - // let binding "t" - var v14 any = v3 - _ = v14 - for { - var tmp15 any - if lang.IsTruthy(v14) { - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("conj")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.Apply(tmp19, []any{v13, v14}) - var tmp16 any = tmp20 - tmp22, ok := lang.FieldOrMethod(v14, "getCause") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v14, "getCause"))) - } - var tmp23 any - switch reflect.TypeOf(tmp22).Kind() { - case reflect.Func: - tmp23 = lang.Apply(tmp22, nil) - default: - tmp23 = tmp22 - } - var tmp21 any = tmp23 - v13 = tmp16 - v14 = tmp21 - continue - } else { - tmp15 = v13 - } - tmp9 = tmp15 - break - } - } // end let - var v10 any = tmp9 - _ = v10 - // let binding "root" - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("peek")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{v10}) - var v15 any = tmp14 - _ = v15 - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("merge")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("vec")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("map")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.Apply(tmp24, []any{v8, v10}) - tmp26 := lang.Apply(tmp21, []any{tmp25}) - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("vec")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("map")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("StackTraceElement->vec")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - var tmp36 any - { // let - // let binding "or__0__auto__" - var v37 any = v15 - _ = v37 - var tmp38 any - if lang.IsTruthy(v37) { - tmp38 = v37 - } else { - tmp38 = v3 - } - tmp36 = tmp38 - } // end let - tmp37, ok := lang.FieldOrMethod(tmp36, "getStackTrace") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp36, "getStackTrace"))) - } - var tmp38 any - switch reflect.TypeOf(tmp37).Kind() { - case reflect.Func: - tmp38 = lang.Apply(tmp37, nil) - default: - tmp38 = tmp37 - } - tmp39 := lang.Apply(tmp32, []any{tmp35, tmp38}) - tmp40 := lang.Apply(tmp29, []any{tmp39}) - tmp41 := lang.NewMap(lang.NewKeyword("via"), tmp26, lang.NewKeyword("trace"), tmp40) - tmp42 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(468), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(470), lang.NewKeyword("end-column"), int(111)) - tmp43, err := lang.WithMeta(tmp41, tmp42.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var tmp44 any - { // let - // let binding "temp__0__auto__" - tmp45, ok := lang.FieldOrMethod(v15, "getLocalizedMessage") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v15, "getLocalizedMessage"))) - } - var tmp46 any - switch reflect.TypeOf(tmp45).Kind() { - case reflect.Func: - tmp46 = lang.Apply(tmp45, nil) - default: - tmp46 = tmp45 - } - var v47 any = tmp46 - _ = v47 - var tmp48 any - if lang.IsTruthy(v47) { - var tmp49 any - { // let - // let binding "root-msg" - var v50 any = v47 - _ = v50 - tmp51 := lang.NewMap(lang.NewKeyword("cause"), v50) - tmp52 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(472), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(472), lang.NewKeyword("end-column"), int(25)) - tmp53, err := lang.WithMeta(tmp51, tmp52.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp49 = tmp53 - } // end let - tmp48 = tmp49 - } else { - } - tmp44 = tmp48 - } // end let - var tmp45 any - { // let - // let binding "temp__0__auto__" - tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp47 := tmp46.FindInternedVar(lang.NewSymbol("ex-data")) - if tmp47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) - } - tmp48 := tmp47.Get() - tmp49 := lang.Apply(tmp48, []any{v15}) - var v50 any = tmp49 - _ = v50 - var tmp51 any - if lang.IsTruthy(v50) { - var tmp52 any - { // let - // let binding "data" - var v53 any = v50 - _ = v53 - tmp54 := lang.NewMap(lang.NewKeyword("data"), v53) - tmp55 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(474), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(474), lang.NewKeyword("end-column"), int(20)) - tmp56, err := lang.WithMeta(tmp54, tmp55.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp52 = tmp56 - } // end let - tmp51 = tmp52 - } else { - } - tmp45 = tmp51 - } // end let - var tmp46 any - { // let - // let binding "temp__0__auto__" - tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp48 := tmp47.FindInternedVar(lang.NewSymbol("ex-data")) - if tmp48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) - } - tmp49 := tmp48.Get() - tmp50 := lang.Apply(tmp49, []any{v3}) - tmp51 := lang.Apply(lang.NewKeyword("glojure.error/phase"), []any{tmp50}) - var v52 any = tmp51 - _ = v52 - var tmp53 any - if lang.IsTruthy(v52) { - var tmp54 any - { // let - // let binding "phase" - var v55 any = v52 - _ = v55 - tmp56 := lang.NewMap(lang.NewKeyword("phase"), v55) - tmp57 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(476), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(476), lang.NewKeyword("end-column"), int(22)) - tmp58, err := lang.WithMeta(tmp56, tmp57.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp54 = tmp58 - } // end let - tmp53 = tmp54 - } else { - } - tmp46 = tmp53 - } // end let - tmp47 := lang.Apply(tmp18, []any{tmp43, tmp44, tmp45, tmp46}) - tmp4 = tmp47 - } // end let - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // abs - { - var tmp1 lang.FnFunc - { // function abs__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Abs")}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{v3}) - tmp18 := lang.Apply(tmp9, []any{tmp13, tmp17}) - tmp19 := lang.Apply(tmp6, []any{tmp18}) - return tmp19 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("abs").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the absolute value of a.\n If a is Long/MIN_VALUE => Long/MIN_VALUE\n If a is a double and zero => +0.0\n If a is a double and ##Inf or ##-Inf => ##Inf\n If a is a double and ##NaN => ##NaN", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1)})), lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1128), lang.NewKeyword("end-line"), int(1128))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5 := lang.Apply(lang.Abs, []any{v4}) - return tmp5 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // accessor - { - tmp0 := lang.NewSymbol("accessor").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("key"))), lang.NewKeyword("doc"), "Returns a fn that, given an instance of a structmap with the basis,\n returns the value at the key. The key must be in the basis. The\n returned function should be (slightly) more efficient than using\n get, but such use of accessors should be limited to known\n performance-critical areas.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4070), lang.NewKeyword("end-line"), int(4070))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5, _ := lang.FieldOrMethod(nil, "getAccessor") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("getAccessor is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v3, v4}) - return tmp6 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // aclone - { - var tmp1 lang.FnFunc - { // function aclone__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/Aclone")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{v3}) - tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) - tmp36 := lang.Apply(tmp23, []any{tmp35}) - tmp37 := lang.Apply(tmp20, []any{tmp36}) - tmp38 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp37}) - tmp39 := lang.Apply(tmp6, []any{tmp38}) - return tmp39 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("aclone").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns a clone of the Java array. Works on arrays of known\n types.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3904), lang.NewKeyword("end-line"), int(3904))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(runtime4.RT, "Aclone") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Aclone is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // add-classpath - { - tmp0 := lang.NewSymbol("add-classpath").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("url"))), lang.NewKeyword("doc"), "DEPRECATED \n\n Adds the url (String or URL object) to the classpath per\n URLClassLoader.addURL", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("deprecated"), "1.1", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5176), lang.NewKeyword("end-line"), int(5176))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("println")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.Apply(tmp6, []any{"WARNING: add-classpath is deprecated"}) - _ = tmp7 - tmp8 := lang.Apply(nil, []any{v3}) - return tmp8 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // add-doc-and-meta - { - tmp0 := lang.NewSymbol("add-doc-and-meta").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("docstring"), lang.NewSymbol("meta"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(26), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6400), lang.NewKeyword("end-line"), int(6400), lang.NewKeyword("private"), true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 5 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - v7 := args[4] - _ = v7 - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("seq")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("concat")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("glojure.core/alter-meta!")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("var")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{v5}) - tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) - tmp36 := lang.Apply(tmp23, []any{tmp35}) - tmp37 := lang.Apply(tmp20, []any{tmp36}) - tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp39 := tmp38.FindInternedVar(lang.NewSymbol("list")) - if tmp39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) - } - tmp40 := tmp39.Get() - tmp41 := lang.Apply(tmp40, []any{lang.NewSymbol("glojure.core/merge")}) - tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp43 := tmp42.FindInternedVar(lang.NewSymbol("list")) - if tmp43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) - } - tmp44 := tmp43.Get() - tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp46 := tmp45.FindInternedVar(lang.NewSymbol("seq")) - if tmp46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) - } - tmp47 := tmp46.Get() - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("concat")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp52 := tmp51.FindInternedVar(lang.NewSymbol("list")) - if tmp52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp52))) - } - tmp53 := tmp52.Get() - tmp54 := lang.Apply(tmp53, []any{lang.NewSymbol("glojure.core/assoc")}) - tmp55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp56 := tmp55.FindInternedVar(lang.NewSymbol("list")) - if tmp56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp56))) - } - tmp57 := tmp56.Get() - tmp58 := lang.Apply(tmp57, []any{v7}) - tmp59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp60 := tmp59.FindInternedVar(lang.NewSymbol("list")) - if tmp60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp60))) - } - tmp61 := tmp60.Get() - tmp62 := lang.Apply(tmp61, []any{lang.NewKeyword("doc")}) - tmp63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp64 := tmp63.FindInternedVar(lang.NewSymbol("list")) - if tmp64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp64))) - } - tmp65 := tmp64.Get() - tmp66 := lang.Apply(tmp65, []any{v6}) - tmp67 := lang.Apply(tmp50, []any{tmp54, tmp58, tmp62, tmp66}) - tmp68 := lang.Apply(tmp47, []any{tmp67}) - tmp69 := lang.Apply(tmp44, []any{tmp68}) - tmp70 := lang.Apply(tmp13, []any{tmp17, tmp37, tmp41, tmp69}) - tmp71 := lang.Apply(tmp10, []any{tmp70}) - return tmp71 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // add-watch - { - tmp0 := lang.NewSymbol("add-watch").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("reference"), lang.NewSymbol("key"), lang.NewSymbol("fn"))), lang.NewKeyword("doc"), "Adds a watch function to an agent/atom/var/ref reference. The watch\n fn must be a fn of 4 args: a key, the reference, its old-state, its\n new-state. Whenever the reference's state might have been changed,\n any registered watches will have their functions called. The watch fn\n will be called synchronously, on the agent's thread if an agent,\n before any pending sends if agent or ref. Note that an atom's or\n ref's state may have changed again prior to the fn call, so use\n old/new-state rather than derefing the reference. Note also that watch\n fns may be called from multiple threads simultaneously. Var watchers\n are triggered only by root binding changes, not thread-local\n set!s. Keys must be unique per reference, and can be used to remove\n the watch with remove-watch, but are otherwise considered opaque by\n the watch mechanism.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2142), lang.NewKeyword("end-line"), int(2142))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6, _ := lang.FieldOrMethod(v3, "addWatch") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("addWatch is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // agent - { - tmp0 := lang.NewSymbol("agent").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("state"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Creates and returns an agent with an initial value of state and\n zero or more options (in any order):\n\n :meta metadata-map\n\n :validator validate-fn\n\n :error-handler handler-fn\n\n :error-mode mode-keyword\n\n If metadata-map is supplied, it will become the metadata on the\n agent. validate-fn must be nil or a side-effect-free fn of one\n argument, which will be passed the intended new state on any state\n change. If the new state is unacceptable, the validate-fn should\n return false or throw an exception. handler-fn is called if an\n action throws an exception or if validate-fn rejects a new state --\n see set-error-handler! for details. The mode-keyword may be either\n :continue (the default if an error-handler is given) or :fail (the\n default if no error-handler is given) -- see set-error-mode! for\n details.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2052), lang.NewKeyword("end-line"), int(2052))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var v4 any = lang.NewList(args[1:]...) - _ = v4 - var tmp5 any - { // let - // let binding "a" - var v6 any = "unimplemented: new with non-constant class type" - _ = v6 - // let binding "opts" - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("apply")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("hash-map")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp9, []any{tmp12, v4}) - var v14 any = tmp13 - _ = v14 - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("setup-reference")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{v6, v4}) - _ = tmp18 - var tmp19 any - tmp20 := lang.Apply(lang.NewKeyword("error-handler"), []any{v14}) - if lang.IsTruthy(tmp20) { - tmp21 := lang.Apply(lang.NewKeyword("error-handler"), []any{v14}) - tmp22, _ := lang.FieldOrMethod(v6, "setErrorHandler") - if reflect.TypeOf(tmp22).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorHandler is not a function"))) - } - tmp23 := lang.Apply(tmp22, []any{tmp21}) - tmp19 = tmp23 - } else { - } - _ = tmp19 - var tmp24 any - { // let - // let binding "or__0__auto__" - tmp25 := lang.Apply(lang.NewKeyword("error-mode"), []any{v14}) - var v26 any = tmp25 - _ = v26 - var tmp27 any - if lang.IsTruthy(v26) { - tmp27 = v26 - } else { - var tmp28 any - tmp29 := lang.Apply(lang.NewKeyword("error-handler"), []any{v14}) - if lang.IsTruthy(tmp29) { - tmp28 = lang.NewKeyword("continue") - } else { - tmp28 = lang.NewKeyword("fail") - } - tmp27 = tmp28 - } - tmp24 = tmp27 - } // end let - tmp25, _ := lang.FieldOrMethod(v6, "setErrorMode") - if reflect.TypeOf(tmp25).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorMode is not a function"))) - } - tmp26 := lang.Apply(tmp25, []any{tmp24}) - _ = tmp26 - tmp5 = v6 - } // end let - return tmp5 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // agent-error - { - tmp0 := lang.NewSymbol("agent-error").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("doc"), "Returns the exception thrown during an asynchronous action of the\n agent if the agent is failed. Returns nil if the agent is not\n failed.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2167), lang.NewKeyword("end-line"), int(2167))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4, ok := lang.FieldOrMethod(v3, "getError") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getError"))) - } - var tmp5 any - switch reflect.TypeOf(tmp4).Kind() { - case reflect.Func: - tmp5 = lang.Apply(tmp4, nil) - default: - tmp5 = tmp4 - } - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // agent-errors - { - tmp0 := lang.NewSymbol("agent-errors").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("doc"), "DEPRECATED: Use 'agent-error' instead.\n Returns a sequence of the exceptions thrown during asynchronous\n actions of the agent.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("deprecated"), "1.2", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2234), lang.NewKeyword("end-line"), int(2234))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "temp__0__auto__" - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("agent-error")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v3}) - var v9 any = tmp8 - _ = v9 - var tmp10 any - if lang.IsTruthy(v9) { - var tmp11 any - { // let - // let binding "e" - var v12 any = v9 - _ = v12 - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("list")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{v12}) - tmp11 = tmp16 - } // end let - tmp10 = tmp11 - } else { - } - tmp4 = tmp10 - } // end let - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // aget - { - var tmp1 lang.FnFunc - { // function aget__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("concat")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("list")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol(".")}) - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("seq")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("concat")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("list")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.Apply(tmp30, []any{lang.NewSymbol("glojure.core/Aget")}) - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.Apply(tmp34, []any{v3}) - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp40 := tmp39.FindInternedVar(lang.NewSymbol("seq")) - if tmp40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) - } - tmp41 := tmp40.Get() - tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp43 := tmp42.FindInternedVar(lang.NewSymbol("concat")) - if tmp43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) - } - tmp44 := tmp43.Get() - tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp46 := tmp45.FindInternedVar(lang.NewSymbol("list")) - if tmp46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) - } - tmp47 := tmp46.Get() - tmp48 := lang.Apply(tmp47, []any{lang.NewSymbol("glojure.core/int")}) - tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp50 := tmp49.FindInternedVar(lang.NewSymbol("list")) - if tmp50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) - } - tmp51 := tmp50.Get() - tmp52 := lang.Apply(tmp51, []any{v4}) - tmp53 := lang.Apply(tmp44, []any{tmp48, tmp52}) - tmp54 := lang.Apply(tmp41, []any{tmp53}) - tmp55 := lang.Apply(tmp38, []any{tmp54}) - tmp56 := lang.Apply(tmp27, []any{tmp31, tmp35, tmp55}) - tmp57 := lang.Apply(tmp24, []any{tmp56}) - tmp58 := lang.Apply(tmp21, []any{tmp57}) - tmp59 := lang.Apply(tmp10, []any{tmp14, tmp18, tmp58}) - tmp60 := lang.Apply(tmp7, []any{tmp59}) - return tmp60 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("aget").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("&"), lang.NewSymbol("idxs"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the value at the index/indices. Works on Java arrays of all\n types.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3911), lang.NewKeyword("end-line"), int(3911))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6 := lang.Apply(lang.Get, []any{v4, v5}) - return tmp6 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - var v6 any = lang.NewList(args[2:]...) - _ = v6 - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("apply")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("aget")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("aget")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{v4, v5}) - tmp17 := lang.Apply(tmp9, []any{tmp12, tmp16, v6}) - return tmp17 - } - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // alength - { - var tmp1 lang.FnFunc - { // function alength__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/Alength")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{v3}) - tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) - tmp36 := lang.Apply(tmp23, []any{tmp35}) - tmp37 := lang.Apply(tmp20, []any{tmp36}) - tmp38 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp37}) - tmp39 := lang.Apply(tmp6, []any{tmp38}) - return tmp39 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("alength").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the length of the Java array. Works on arrays of all\n types.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3897), lang.NewKeyword("end-line"), int(3897))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(runtime4.RT, "Alength") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Alength is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // alias - { - tmp0 := lang.NewSymbol("alias").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("alias"), lang.NewSymbol("namespace-sym"))), lang.NewKeyword("doc"), "Add an alias in the current namespace to another\n namespace. Arguments are two symbols: the alias to be used, and\n the symbolic name of the target namespace. Use :as in the ns macro in preference\n to calling this directly.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4263), lang.NewKeyword("end-line"), int(4263))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("*ns*")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("the-ns")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v4}) - tmp12, _ := lang.FieldOrMethod(tmp7, "AddAlias") - if reflect.TypeOf(tmp12).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("AddAlias is not a function"))) - } - tmp13 := lang.Apply(tmp12, []any{v3, tmp11}) - return tmp13 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // all-ns - { - tmp0 := lang.NewSymbol("all-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Returns a sequence of all namespaces.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4146), lang.NewKeyword("end-line"), int(4146))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - tmp3 := lang.Apply(nil, nil) - return tmp3 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // alter - { - tmp0 := lang.NewSymbol("alter").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("fun"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Must be called in a transaction. Sets the in-transaction-value of\n ref to:\n\n (apply fun in-transaction-value-of-ref args)\n\n and returns the in-transaction-value of ref.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2435), lang.NewKeyword("end-line"), int(2435))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - tmp6, _ := lang.FieldOrMethod(v3, "alter") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("alter is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // alter-meta! - { - tmp0 := lang.NewSymbol("alter-meta!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("iref"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Atomically sets the metadata for a namespace/var/ref/agent/atom to be:\n\n (apply f its-current-meta args)\n\n f must be free of side-effects", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2398), lang.NewKeyword("end-line"), int(2398))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - tmp6, _ := lang.FieldOrMethod(v3, "AlterMeta") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("AlterMeta is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // alter-var-root - { - tmp0 := lang.NewSymbol("alter-var-root").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("v"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Atomically alters the root binding of var v by applying f to its\n current value plus any args", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5484), lang.NewKeyword("end-line"), int(5484))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - tmp6, _ := lang.FieldOrMethod(v3, "alterRoot") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("alterRoot is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // amap - { - tmp0 := lang.NewSymbol("amap").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("idx"), lang.NewSymbol("ret"), lang.NewSymbol("expr"))), lang.NewKeyword("doc"), "Maps an expression across an array a, using an index named idx, and\n return value named ret, initialized to a clone of a, then setting \n each element of ret to the evaluation of expr, returning the new \n array ret.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5273), lang.NewKeyword("end-line"), int(5273))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 6 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - v7 := args[4] - _ = v7 - v8 := args[5] - _ = v8 - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("seq")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("concat")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("glojure.core/let")}) - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("apply")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("vector")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("seq")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("concat")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("list")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.Apply(tmp36, []any{lang.NewSymbol("a__0__auto__")}) - tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp39 := tmp38.FindInternedVar(lang.NewSymbol("list")) - if tmp39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) - } - tmp40 := tmp39.Get() - tmp41 := lang.Apply(tmp40, []any{v5}) - tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp43 := tmp42.FindInternedVar(lang.NewSymbol("list")) - if tmp43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) - } - tmp44 := tmp43.Get() - tmp45 := lang.Apply(tmp44, []any{lang.NewSymbol("l__1__auto__")}) - tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp47 := tmp46.FindInternedVar(lang.NewSymbol("list")) - if tmp47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) - } - tmp48 := tmp47.Get() - tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp50 := tmp49.FindInternedVar(lang.NewSymbol("seq")) - if tmp50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) - } - tmp51 := tmp50.Get() - tmp52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp53 := tmp52.FindInternedVar(lang.NewSymbol("concat")) - if tmp53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp53))) - } - tmp54 := tmp53.Get() - tmp55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp56 := tmp55.FindInternedVar(lang.NewSymbol("list")) - if tmp56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp56))) - } - tmp57 := tmp56.Get() - tmp58 := lang.Apply(tmp57, []any{lang.NewSymbol("glojure.core/alength")}) - tmp59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp60 := tmp59.FindInternedVar(lang.NewSymbol("list")) - if tmp60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp60))) - } - tmp61 := tmp60.Get() - tmp62 := lang.Apply(tmp61, []any{lang.NewSymbol("a__0__auto__")}) - tmp63 := lang.Apply(tmp54, []any{tmp58, tmp62}) - tmp64 := lang.Apply(tmp51, []any{tmp63}) - tmp65 := lang.Apply(tmp48, []any{tmp64}) - tmp66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp67 := tmp66.FindInternedVar(lang.NewSymbol("list")) - if tmp67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp67))) - } - tmp68 := tmp67.Get() - tmp69 := lang.Apply(tmp68, []any{v7}) - tmp70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp71 := tmp70.FindInternedVar(lang.NewSymbol("list")) - if tmp71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp71))) - } - tmp72 := tmp71.Get() - tmp73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp74 := tmp73.FindInternedVar(lang.NewSymbol("seq")) - if tmp74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp74))) - } - tmp75 := tmp74.Get() - tmp76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp77 := tmp76.FindInternedVar(lang.NewSymbol("concat")) - if tmp77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp77))) - } - tmp78 := tmp77.Get() - tmp79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp80 := tmp79.FindInternedVar(lang.NewSymbol("list")) - if tmp80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp80))) - } - tmp81 := tmp80.Get() - tmp82 := lang.Apply(tmp81, []any{lang.NewSymbol("glojure.core/aclone")}) - tmp83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp84 := tmp83.FindInternedVar(lang.NewSymbol("list")) - if tmp84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp84))) - } - tmp85 := tmp84.Get() - tmp86 := lang.Apply(tmp85, []any{lang.NewSymbol("a__0__auto__")}) - tmp87 := lang.Apply(tmp78, []any{tmp82, tmp86}) - tmp88 := lang.Apply(tmp75, []any{tmp87}) - tmp89 := lang.Apply(tmp72, []any{tmp88}) - tmp90 := lang.Apply(tmp33, []any{tmp37, tmp41, tmp45, tmp65, tmp69, tmp89}) - tmp91 := lang.Apply(tmp30, []any{tmp90}) - tmp92 := lang.Apply(tmp24, []any{tmp27, tmp91}) - tmp93 := lang.Apply(tmp21, []any{tmp92}) - tmp94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp95 := tmp94.FindInternedVar(lang.NewSymbol("list")) - if tmp95.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp95))) - } - tmp96 := tmp95.Get() - tmp97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp98 := tmp97.FindInternedVar(lang.NewSymbol("seq")) - if tmp98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp98))) - } - tmp99 := tmp98.Get() - tmp100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp101 := tmp100.FindInternedVar(lang.NewSymbol("concat")) - if tmp101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp101))) - } - tmp102 := tmp101.Get() - tmp103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp104 := tmp103.FindInternedVar(lang.NewSymbol("list")) - if tmp104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp104))) - } - tmp105 := tmp104.Get() - tmp106 := lang.Apply(tmp105, []any{lang.NewSymbol("glojure.core/loop")}) - tmp107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp108 := tmp107.FindInternedVar(lang.NewSymbol("list")) - if tmp108.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp108))) - } - tmp109 := tmp108.Get() - tmp110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp111 := tmp110.FindInternedVar(lang.NewSymbol("apply")) - if tmp111.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp111))) - } - tmp112 := tmp111.Get() - tmp113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp114 := tmp113.FindInternedVar(lang.NewSymbol("vector")) - if tmp114.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp114))) - } - tmp115 := tmp114.Get() - tmp116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp117 := tmp116.FindInternedVar(lang.NewSymbol("seq")) - if tmp117.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp117))) - } - tmp118 := tmp117.Get() - tmp119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp120 := tmp119.FindInternedVar(lang.NewSymbol("concat")) - if tmp120.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp120))) - } - tmp121 := tmp120.Get() - tmp122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp123 := tmp122.FindInternedVar(lang.NewSymbol("list")) - if tmp123.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp123))) - } - tmp124 := tmp123.Get() - tmp125 := lang.Apply(tmp124, []any{v6}) - tmp126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp127 := tmp126.FindInternedVar(lang.NewSymbol("list")) - if tmp127.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp127))) - } - tmp128 := tmp127.Get() - tmp129 := lang.Apply(tmp128, []any{int64(0)}) - tmp130 := lang.Apply(tmp121, []any{tmp125, tmp129}) - tmp131 := lang.Apply(tmp118, []any{tmp130}) - tmp132 := lang.Apply(tmp112, []any{tmp115, tmp131}) - tmp133 := lang.Apply(tmp109, []any{tmp132}) - tmp134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp135 := tmp134.FindInternedVar(lang.NewSymbol("list")) - if tmp135.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp135))) - } - tmp136 := tmp135.Get() - tmp137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp138 := tmp137.FindInternedVar(lang.NewSymbol("seq")) - if tmp138.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp138))) - } - tmp139 := tmp138.Get() - tmp140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp141 := tmp140.FindInternedVar(lang.NewSymbol("concat")) - if tmp141.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp141))) - } - tmp142 := tmp141.Get() - tmp143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp144 := tmp143.FindInternedVar(lang.NewSymbol("list")) - if tmp144.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp144))) - } - tmp145 := tmp144.Get() - tmp146 := lang.Apply(tmp145, []any{lang.NewSymbol("if")}) - tmp147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp148 := tmp147.FindInternedVar(lang.NewSymbol("list")) - if tmp148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp148))) - } - tmp149 := tmp148.Get() - tmp150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp151 := tmp150.FindInternedVar(lang.NewSymbol("seq")) - if tmp151.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp151))) - } - tmp152 := tmp151.Get() - tmp153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp154 := tmp153.FindInternedVar(lang.NewSymbol("concat")) - if tmp154.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp154))) - } - tmp155 := tmp154.Get() - tmp156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp157 := tmp156.FindInternedVar(lang.NewSymbol("list")) - if tmp157.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp157))) - } - tmp158 := tmp157.Get() - tmp159 := lang.Apply(tmp158, []any{lang.NewSymbol("glojure.core/<")}) - tmp160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp161 := tmp160.FindInternedVar(lang.NewSymbol("list")) - if tmp161.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp161))) - } - tmp162 := tmp161.Get() - tmp163 := lang.Apply(tmp162, []any{v6}) - tmp164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp165 := tmp164.FindInternedVar(lang.NewSymbol("list")) - if tmp165.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp165))) - } - tmp166 := tmp165.Get() - tmp167 := lang.Apply(tmp166, []any{lang.NewSymbol("l__1__auto__")}) - tmp168 := lang.Apply(tmp155, []any{tmp159, tmp163, tmp167}) - tmp169 := lang.Apply(tmp152, []any{tmp168}) - tmp170 := lang.Apply(tmp149, []any{tmp169}) - tmp171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp172 := tmp171.FindInternedVar(lang.NewSymbol("list")) - if tmp172.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp172))) - } - tmp173 := tmp172.Get() - tmp174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp175 := tmp174.FindInternedVar(lang.NewSymbol("seq")) - if tmp175.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp175))) - } - tmp176 := tmp175.Get() - tmp177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp178 := tmp177.FindInternedVar(lang.NewSymbol("concat")) - if tmp178.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp178))) - } - tmp179 := tmp178.Get() - tmp180 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp181 := tmp180.FindInternedVar(lang.NewSymbol("list")) - if tmp181.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp181))) - } - tmp182 := tmp181.Get() - tmp183 := lang.Apply(tmp182, []any{lang.NewSymbol("do")}) - tmp184 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp185 := tmp184.FindInternedVar(lang.NewSymbol("list")) - if tmp185.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp185))) - } - tmp186 := tmp185.Get() - tmp187 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp188 := tmp187.FindInternedVar(lang.NewSymbol("seq")) - if tmp188.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp188))) - } - tmp189 := tmp188.Get() - tmp190 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp191 := tmp190.FindInternedVar(lang.NewSymbol("concat")) - if tmp191.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp191))) - } - tmp192 := tmp191.Get() - tmp193 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp194 := tmp193.FindInternedVar(lang.NewSymbol("list")) - if tmp194.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp194))) - } - tmp195 := tmp194.Get() - tmp196 := lang.Apply(tmp195, []any{lang.NewSymbol("glojure.core/aset")}) - tmp197 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp198 := tmp197.FindInternedVar(lang.NewSymbol("list")) - if tmp198.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp198))) - } - tmp199 := tmp198.Get() - tmp200 := lang.Apply(tmp199, []any{v7}) - tmp201 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp202 := tmp201.FindInternedVar(lang.NewSymbol("list")) - if tmp202.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp202))) - } - tmp203 := tmp202.Get() - tmp204 := lang.Apply(tmp203, []any{v6}) - tmp205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp206 := tmp205.FindInternedVar(lang.NewSymbol("list")) - if tmp206.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp206))) - } - tmp207 := tmp206.Get() - tmp208 := lang.Apply(tmp207, []any{v8}) - tmp209 := lang.Apply(tmp192, []any{tmp196, tmp200, tmp204, tmp208}) - tmp210 := lang.Apply(tmp189, []any{tmp209}) - tmp211 := lang.Apply(tmp186, []any{tmp210}) - tmp212 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp213 := tmp212.FindInternedVar(lang.NewSymbol("list")) - if tmp213.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp213))) - } - tmp214 := tmp213.Get() - tmp215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp216 := tmp215.FindInternedVar(lang.NewSymbol("seq")) - if tmp216.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp216))) - } - tmp217 := tmp216.Get() - tmp218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp219 := tmp218.FindInternedVar(lang.NewSymbol("concat")) - if tmp219.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp219))) - } - tmp220 := tmp219.Get() - tmp221 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp222 := tmp221.FindInternedVar(lang.NewSymbol("list")) - if tmp222.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp222))) - } - tmp223 := tmp222.Get() - tmp224 := lang.Apply(tmp223, []any{lang.NewSymbol("recur")}) - tmp225 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp226 := tmp225.FindInternedVar(lang.NewSymbol("list")) - if tmp226.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp226))) - } - tmp227 := tmp226.Get() - tmp228 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp229 := tmp228.FindInternedVar(lang.NewSymbol("seq")) - if tmp229.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp229))) - } - tmp230 := tmp229.Get() - tmp231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp232 := tmp231.FindInternedVar(lang.NewSymbol("concat")) - if tmp232.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp232))) - } - tmp233 := tmp232.Get() - tmp234 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp235 := tmp234.FindInternedVar(lang.NewSymbol("list")) - if tmp235.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp235))) - } - tmp236 := tmp235.Get() - tmp237 := lang.Apply(tmp236, []any{lang.NewSymbol("glojure.core/unchecked-inc")}) - tmp238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp239 := tmp238.FindInternedVar(lang.NewSymbol("list")) - if tmp239.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp239))) - } - tmp240 := tmp239.Get() - tmp241 := lang.Apply(tmp240, []any{v6}) - tmp242 := lang.Apply(tmp233, []any{tmp237, tmp241}) - tmp243 := lang.Apply(tmp230, []any{tmp242}) - tmp244 := lang.Apply(tmp227, []any{tmp243}) - tmp245 := lang.Apply(tmp220, []any{tmp224, tmp244}) - tmp246 := lang.Apply(tmp217, []any{tmp245}) - tmp247 := lang.Apply(tmp214, []any{tmp246}) - tmp248 := lang.Apply(tmp179, []any{tmp183, tmp211, tmp247}) - tmp249 := lang.Apply(tmp176, []any{tmp248}) - tmp250 := lang.Apply(tmp173, []any{tmp249}) - tmp251 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp252 := tmp251.FindInternedVar(lang.NewSymbol("list")) - if tmp252.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp252))) - } - tmp253 := tmp252.Get() - tmp254 := lang.Apply(tmp253, []any{v7}) - tmp255 := lang.Apply(tmp142, []any{tmp146, tmp170, tmp250, tmp254}) - tmp256 := lang.Apply(tmp139, []any{tmp255}) - tmp257 := lang.Apply(tmp136, []any{tmp256}) - tmp258 := lang.Apply(tmp102, []any{tmp106, tmp133, tmp257}) - tmp259 := lang.Apply(tmp99, []any{tmp258}) - tmp260 := lang.Apply(tmp96, []any{tmp259}) - tmp261 := lang.Apply(tmp14, []any{tmp18, tmp93, tmp260}) - tmp262 := lang.Apply(tmp11, []any{tmp261}) - return tmp262 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // ancestors - { - tmp0 := lang.NewSymbol("ancestors").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"))), lang.NewKeyword("doc"), "Returns the immediate and indirect parents of tag, either via a Java type\n inheritance relationship or a relationship established via derive. h\n must be a hierarchy obtained from make-hierarchy, if not supplied\n defaults to the global hierarchy", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5577), lang.NewKeyword("end-line"), int(5577))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("ancestors")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("global-hierarchy")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp6, []any{tmp9, v3}) - return tmp10 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("not-empty")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - var tmp8 any - { // let - // let binding "ta" - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("get")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) - tmp13 := lang.Apply(tmp11, []any{tmp12, v4}) - var v14 any = tmp13 - _ = v14 - var tmp15 any - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("class?")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{v4}) - if lang.IsTruthy(tmp19) { - var tmp20 any - { // let - // let binding "superclasses" - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("set")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("supers")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.Apply(tmp26, []any{v4}) - tmp28 := lang.Apply(tmp23, []any{tmp27}) - var v29 any = tmp28 - _ = v29 - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("into1")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("cons")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp40 := tmp39.FindInternedVar(lang.NewSymbol("map")) - if tmp40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) - } - tmp41 := tmp40.Get() - var tmp42 lang.FnFunc - tmp42 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v43 := args[0] - _ = v43 - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("get")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) - tmp48 := lang.Apply(tmp46, []any{tmp47, v43}) - return tmp48 - }) - tmp43 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5590), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(5590), lang.NewKeyword("end-column"), int(54)) - tmp44, err := lang.WithMeta(tmp42, tmp43.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp45 := lang.Apply(tmp41, []any{tmp44, v29}) - tmp46 := lang.Apply(tmp38, []any{v14, tmp45}) - tmp47 := lang.Apply(tmp32, []any{tmp35, v29, tmp46}) - tmp20 = tmp47 - } // end let - tmp15 = tmp20 - } else { - tmp15 = v14 - } - tmp8 = tmp15 - } // end let - tmp9 := lang.Apply(tmp7, []any{tmp8}) - return tmp9 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // and - { - tmp0 := lang.NewSymbol("and").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("next"))), lang.NewKeyword("doc"), "Evaluates exprs one at a time, from left to right. If a form\n returns logical false (nil or false), and returns that value and\n doesn't evaluate any of the other expressions, otherwise it returns\n the value of the last expr. (and) returns true.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(835), lang.NewKeyword("end-line"), int(835))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - return true - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - return v5 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("seq")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("concat")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("list")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("glojure.core/let")}) - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("list")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("apply")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("vector")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("seq")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("concat")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.Apply(tmp34, []any{lang.NewSymbol("and__0__auto__")}) - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{v5}) - tmp40 := lang.Apply(tmp31, []any{tmp35, tmp39}) - tmp41 := lang.Apply(tmp28, []any{tmp40}) - tmp42 := lang.Apply(tmp22, []any{tmp25, tmp41}) - tmp43 := lang.Apply(tmp19, []any{tmp42}) - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp48 := tmp47.FindInternedVar(lang.NewSymbol("seq")) - if tmp48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) - } - tmp49 := tmp48.Get() - tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp51 := tmp50.FindInternedVar(lang.NewSymbol("concat")) - if tmp51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) - } - tmp52 := tmp51.Get() - tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp54 := tmp53.FindInternedVar(lang.NewSymbol("list")) - if tmp54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) - } - tmp55 := tmp54.Get() - tmp56 := lang.Apply(tmp55, []any{lang.NewSymbol("if")}) - tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp58 := tmp57.FindInternedVar(lang.NewSymbol("list")) - if tmp58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) - } - tmp59 := tmp58.Get() - tmp60 := lang.Apply(tmp59, []any{lang.NewSymbol("and__0__auto__")}) - tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp62 := tmp61.FindInternedVar(lang.NewSymbol("list")) - if tmp62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) - } - tmp63 := tmp62.Get() - tmp64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp65 := tmp64.FindInternedVar(lang.NewSymbol("seq")) - if tmp65.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp65))) - } - tmp66 := tmp65.Get() - tmp67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp68 := tmp67.FindInternedVar(lang.NewSymbol("concat")) - if tmp68.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp68))) - } - tmp69 := tmp68.Get() - tmp70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp71 := tmp70.FindInternedVar(lang.NewSymbol("list")) - if tmp71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp71))) - } - tmp72 := tmp71.Get() - tmp73 := lang.Apply(tmp72, []any{lang.NewSymbol("glojure.core/and")}) - tmp74 := lang.Apply(tmp69, []any{tmp73, v6}) - tmp75 := lang.Apply(tmp66, []any{tmp74}) - tmp76 := lang.Apply(tmp63, []any{tmp75}) - tmp77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp78 := tmp77.FindInternedVar(lang.NewSymbol("list")) - if tmp78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp78))) - } - tmp79 := tmp78.Get() - tmp80 := lang.Apply(tmp79, []any{lang.NewSymbol("and__0__auto__")}) - tmp81 := lang.Apply(tmp52, []any{tmp56, tmp60, tmp76, tmp80}) - tmp82 := lang.Apply(tmp49, []any{tmp81}) - tmp83 := lang.Apply(tmp46, []any{tmp82}) - tmp84 := lang.Apply(tmp12, []any{tmp16, tmp43, tmp83}) - tmp85 := lang.Apply(tmp9, []any{tmp84}) - return tmp85 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // any? - { - tmp1 := reflect.TypeOf(false) - tmp0 := lang.NewSymbol("any?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true given any argument.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(537), lang.NewKeyword("end-line"), int(537))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - return true - }) - tmp4 := reflect.TypeOf(false) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // apply - { - tmp0 := lang.NewSymbol("apply").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("z"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Applies fn f to the argument list formed by prepending intervening arguments to args.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(653), lang.NewKeyword("end-line"), int(653))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v4}) - tmp9 := lang.Apply(lang.Apply, []any{v3, tmp8}) - return tmp9 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("list*")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(tmp8, []any{v4, v5}) - tmp10 := lang.Apply(lang.Apply, []any{v3, tmp9}) - return tmp10 - case 4: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("list*")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp9, []any{v4, v5, v6}) - tmp11 := lang.Apply(lang.Apply, []any{v3, tmp10}) - return tmp11 - case 5: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - v7 := args[4] - _ = v7 - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("list*")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v4, v5, v6, v7}) - tmp12 := lang.Apply(lang.Apply, []any{v3, tmp11}) - return tmp12 - default: - if len(args) < 5 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - v7 := args[4] - _ = v7 - var v8 any = lang.NewList(args[5:]...) - _ = v8 - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("cons")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("cons")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("cons")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("cons")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("spread")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.Apply(tmp23, []any{v8}) - tmp25 := lang.Apply(tmp20, []any{v7, tmp24}) - tmp26 := lang.Apply(tmp17, []any{v6, tmp25}) - tmp27 := lang.Apply(tmp14, []any{v5, tmp26}) - tmp28 := lang.Apply(tmp11, []any{v4, tmp27}) - tmp29 := lang.Apply(lang.Apply, []any{v3, tmp28}) - return tmp29 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // areduce - { - tmp0 := lang.NewSymbol("areduce").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("idx"), lang.NewSymbol("ret"), lang.NewSymbol("init"), lang.NewSymbol("expr"))), lang.NewKeyword("doc"), "Reduces an expression across an array a, using an index named idx,\n and return value named ret, initialized to init, setting ret to the \n evaluation of expr at each step, returning ret.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5289), lang.NewKeyword("end-line"), int(5289))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 7 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - v7 := args[4] - _ = v7 - v8 := args[5] - _ = v8 - v9 := args[6] - _ = v9 - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("seq")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("concat")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("list")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{lang.NewSymbol("glojure.core/let")}) - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("list")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("apply")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("vector")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("seq")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("concat")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp36 := tmp35.FindInternedVar(lang.NewSymbol("list")) - if tmp36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) - } - tmp37 := tmp36.Get() - tmp38 := lang.Apply(tmp37, []any{lang.NewSymbol("a__0__auto__")}) - tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp40 := tmp39.FindInternedVar(lang.NewSymbol("list")) - if tmp40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) - } - tmp41 := tmp40.Get() - tmp42 := lang.Apply(tmp41, []any{v5}) - tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp44 := tmp43.FindInternedVar(lang.NewSymbol("list")) - if tmp44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) - } - tmp45 := tmp44.Get() - tmp46 := lang.Apply(tmp45, []any{lang.NewSymbol("l__1__auto__")}) - tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp48 := tmp47.FindInternedVar(lang.NewSymbol("list")) - if tmp48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) - } - tmp49 := tmp48.Get() - tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp51 := tmp50.FindInternedVar(lang.NewSymbol("seq")) - if tmp51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) - } - tmp52 := tmp51.Get() - tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp54 := tmp53.FindInternedVar(lang.NewSymbol("concat")) - if tmp54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) - } - tmp55 := tmp54.Get() - tmp56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp57 := tmp56.FindInternedVar(lang.NewSymbol("list")) - if tmp57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp57))) - } - tmp58 := tmp57.Get() - tmp59 := lang.Apply(tmp58, []any{lang.NewSymbol("glojure.core/alength")}) - tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp61 := tmp60.FindInternedVar(lang.NewSymbol("list")) - if tmp61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) - } - tmp62 := tmp61.Get() - tmp63 := lang.Apply(tmp62, []any{lang.NewSymbol("a__0__auto__")}) - tmp64 := lang.Apply(tmp55, []any{tmp59, tmp63}) - tmp65 := lang.Apply(tmp52, []any{tmp64}) - tmp66 := lang.Apply(tmp49, []any{tmp65}) - tmp67 := lang.Apply(tmp34, []any{tmp38, tmp42, tmp46, tmp66}) - tmp68 := lang.Apply(tmp31, []any{tmp67}) - tmp69 := lang.Apply(tmp25, []any{tmp28, tmp68}) - tmp70 := lang.Apply(tmp22, []any{tmp69}) - tmp71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp72 := tmp71.FindInternedVar(lang.NewSymbol("list")) - if tmp72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp72))) - } - tmp73 := tmp72.Get() - tmp74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp75 := tmp74.FindInternedVar(lang.NewSymbol("seq")) - if tmp75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp75))) - } - tmp76 := tmp75.Get() - tmp77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp78 := tmp77.FindInternedVar(lang.NewSymbol("concat")) - if tmp78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp78))) - } - tmp79 := tmp78.Get() - tmp80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp81 := tmp80.FindInternedVar(lang.NewSymbol("list")) - if tmp81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp81))) - } - tmp82 := tmp81.Get() - tmp83 := lang.Apply(tmp82, []any{lang.NewSymbol("glojure.core/loop")}) - tmp84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp85 := tmp84.FindInternedVar(lang.NewSymbol("list")) - if tmp85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp85))) - } - tmp86 := tmp85.Get() - tmp87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp88 := tmp87.FindInternedVar(lang.NewSymbol("apply")) - if tmp88.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp88))) - } - tmp89 := tmp88.Get() - tmp90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp91 := tmp90.FindInternedVar(lang.NewSymbol("vector")) - if tmp91.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp91))) - } - tmp92 := tmp91.Get() - tmp93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp94 := tmp93.FindInternedVar(lang.NewSymbol("seq")) - if tmp94.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp94))) - } - tmp95 := tmp94.Get() - tmp96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp97 := tmp96.FindInternedVar(lang.NewSymbol("concat")) - if tmp97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp97))) - } - tmp98 := tmp97.Get() - tmp99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp100 := tmp99.FindInternedVar(lang.NewSymbol("list")) - if tmp100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp100))) - } - tmp101 := tmp100.Get() - tmp102 := lang.Apply(tmp101, []any{v6}) - tmp103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp104 := tmp103.FindInternedVar(lang.NewSymbol("list")) - if tmp104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp104))) - } - tmp105 := tmp104.Get() - tmp106 := lang.Apply(tmp105, []any{int64(0)}) - tmp107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp108 := tmp107.FindInternedVar(lang.NewSymbol("list")) - if tmp108.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp108))) - } - tmp109 := tmp108.Get() - tmp110 := lang.Apply(tmp109, []any{v7}) - tmp111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp112 := tmp111.FindInternedVar(lang.NewSymbol("list")) - if tmp112.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp112))) - } - tmp113 := tmp112.Get() - tmp114 := lang.Apply(tmp113, []any{v8}) - tmp115 := lang.Apply(tmp98, []any{tmp102, tmp106, tmp110, tmp114}) - tmp116 := lang.Apply(tmp95, []any{tmp115}) - tmp117 := lang.Apply(tmp89, []any{tmp92, tmp116}) - tmp118 := lang.Apply(tmp86, []any{tmp117}) - tmp119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp120 := tmp119.FindInternedVar(lang.NewSymbol("list")) - if tmp120.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp120))) - } - tmp121 := tmp120.Get() - tmp122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp123 := tmp122.FindInternedVar(lang.NewSymbol("seq")) - if tmp123.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp123))) - } - tmp124 := tmp123.Get() - tmp125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp126 := tmp125.FindInternedVar(lang.NewSymbol("concat")) - if tmp126.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp126))) - } - tmp127 := tmp126.Get() - tmp128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp129 := tmp128.FindInternedVar(lang.NewSymbol("list")) - if tmp129.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp129))) - } - tmp130 := tmp129.Get() - tmp131 := lang.Apply(tmp130, []any{lang.NewSymbol("if")}) - tmp132 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp133 := tmp132.FindInternedVar(lang.NewSymbol("list")) - if tmp133.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp133))) - } - tmp134 := tmp133.Get() - tmp135 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp136 := tmp135.FindInternedVar(lang.NewSymbol("seq")) - if tmp136.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp136))) - } - tmp137 := tmp136.Get() - tmp138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp139 := tmp138.FindInternedVar(lang.NewSymbol("concat")) - if tmp139.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp139))) - } - tmp140 := tmp139.Get() - tmp141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp142 := tmp141.FindInternedVar(lang.NewSymbol("list")) - if tmp142.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp142))) - } - tmp143 := tmp142.Get() - tmp144 := lang.Apply(tmp143, []any{lang.NewSymbol("glojure.core/<")}) - tmp145 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp146 := tmp145.FindInternedVar(lang.NewSymbol("list")) - if tmp146.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp146))) - } - tmp147 := tmp146.Get() - tmp148 := lang.Apply(tmp147, []any{v6}) - tmp149 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp150 := tmp149.FindInternedVar(lang.NewSymbol("list")) - if tmp150.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp150))) - } - tmp151 := tmp150.Get() - tmp152 := lang.Apply(tmp151, []any{lang.NewSymbol("l__1__auto__")}) - tmp153 := lang.Apply(tmp140, []any{tmp144, tmp148, tmp152}) - tmp154 := lang.Apply(tmp137, []any{tmp153}) - tmp155 := lang.Apply(tmp134, []any{tmp154}) - tmp156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp157 := tmp156.FindInternedVar(lang.NewSymbol("list")) - if tmp157.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp157))) - } - tmp158 := tmp157.Get() - tmp159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp160 := tmp159.FindInternedVar(lang.NewSymbol("seq")) - if tmp160.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp160))) - } - tmp161 := tmp160.Get() - tmp162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp163 := tmp162.FindInternedVar(lang.NewSymbol("concat")) - if tmp163.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp163))) - } - tmp164 := tmp163.Get() - tmp165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp166 := tmp165.FindInternedVar(lang.NewSymbol("list")) - if tmp166.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp166))) - } - tmp167 := tmp166.Get() - tmp168 := lang.Apply(tmp167, []any{lang.NewSymbol("recur")}) - tmp169 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp170 := tmp169.FindInternedVar(lang.NewSymbol("list")) - if tmp170.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp170))) - } - tmp171 := tmp170.Get() - tmp172 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp173 := tmp172.FindInternedVar(lang.NewSymbol("seq")) - if tmp173.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp173))) - } - tmp174 := tmp173.Get() - tmp175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp176 := tmp175.FindInternedVar(lang.NewSymbol("concat")) - if tmp176.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp176))) - } - tmp177 := tmp176.Get() - tmp178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp179 := tmp178.FindInternedVar(lang.NewSymbol("list")) - if tmp179.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp179))) - } - tmp180 := tmp179.Get() - tmp181 := lang.Apply(tmp180, []any{lang.NewSymbol("glojure.core/unchecked-inc-int")}) - tmp182 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp183 := tmp182.FindInternedVar(lang.NewSymbol("list")) - if tmp183.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp183))) - } - tmp184 := tmp183.Get() - tmp185 := lang.Apply(tmp184, []any{v6}) - tmp186 := lang.Apply(tmp177, []any{tmp181, tmp185}) - tmp187 := lang.Apply(tmp174, []any{tmp186}) - tmp188 := lang.Apply(tmp171, []any{tmp187}) - tmp189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp190 := tmp189.FindInternedVar(lang.NewSymbol("list")) - if tmp190.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp190))) - } - tmp191 := tmp190.Get() - tmp192 := lang.Apply(tmp191, []any{v9}) - tmp193 := lang.Apply(tmp164, []any{tmp168, tmp188, tmp192}) - tmp194 := lang.Apply(tmp161, []any{tmp193}) - tmp195 := lang.Apply(tmp158, []any{tmp194}) - tmp196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp197 := tmp196.FindInternedVar(lang.NewSymbol("list")) - if tmp197.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp197))) - } - tmp198 := tmp197.Get() - tmp199 := lang.Apply(tmp198, []any{v7}) - tmp200 := lang.Apply(tmp127, []any{tmp131, tmp155, tmp195, tmp199}) - tmp201 := lang.Apply(tmp124, []any{tmp200}) - tmp202 := lang.Apply(tmp121, []any{tmp201}) - tmp203 := lang.Apply(tmp79, []any{tmp83, tmp118, tmp202}) - tmp204 := lang.Apply(tmp76, []any{tmp203}) - tmp205 := lang.Apply(tmp73, []any{tmp204}) - tmp206 := lang.Apply(tmp15, []any{tmp19, tmp70, tmp205}) - tmp207 := lang.Apply(tmp12, []any{tmp206}) - return tmp207 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // array - { - tmp0 := lang.NewSymbol("array").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3457), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3458), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("items"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var v3 any = lang.NewList(args[0:]...) - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("into-array")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.Apply(tmp6, []any{v3}) - return tmp7 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // array-map - { - tmp0 := lang.NewSymbol("array-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keyvals"))), lang.NewKeyword("doc"), "Constructs an array-map. If any keys are equal, they are handled as\n if by repeated uses of assoc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4378), lang.NewKeyword("end-line"), int(4378))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp3, ok := lang.FieldOrMethod(nil, "EMPTY") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "EMPTY"))) - } - var tmp4 any - switch reflect.TypeOf(tmp3).Kind() { - case reflect.Func: - tmp4 = lang.Apply(tmp3, nil) - default: - tmp4 = tmp3 - } - return tmp4 - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var v3 any = lang.NewList(args[0:]...) - _ = v3 - var tmp4 any - { // let - // let binding "ary" - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("to-array")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v3}) - var v9 any = tmp8 - _ = v9 - var tmp10 any - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("odd?")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("alength")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{v9}) - tmp18 := lang.Apply(tmp13, []any{tmp17}) - if lang.IsTruthy(tmp18) { - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("str")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("last")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.Apply(tmp24, []any{v3}) - tmp26 := lang.Apply(tmp21, []any{"No value supplied for key: ", tmp25}) - tmp27 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp26}) - panic(tmp27) - } else { - tmp28 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{v9}) - tmp10 = tmp28 - } - tmp4 = tmp10 - } // end let - return tmp4 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // as-> - { - tmp0 := lang.NewSymbol("as->").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "Binds name to expr, evaluates the first form in the lexical context\n of that binding, then binds name to that result, repeating for each\n successive form, returning the result of the last form.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7598), lang.NewKeyword("end-line"), int(7598))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - var v7 any = lang.NewList(args[4:]...) - _ = v7 - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("seq")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("concat")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("glojure.core/let")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("apply")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("vector")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("seq")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("concat")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("list")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.Apply(tmp35, []any{v6}) - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("list")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.Apply(tmp39, []any{v5}) - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("interleave")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("repeat")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.Apply(tmp46, []any{v6}) - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("butlast")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v7}) - tmp52 := lang.Apply(tmp43, []any{tmp47, tmp51}) - tmp53 := lang.Apply(tmp32, []any{tmp36, tmp40, tmp52}) - tmp54 := lang.Apply(tmp29, []any{tmp53}) - tmp55 := lang.Apply(tmp23, []any{tmp26, tmp54}) - tmp56 := lang.Apply(tmp20, []any{tmp55}) - tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp58 := tmp57.FindInternedVar(lang.NewSymbol("list")) - if tmp58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) - } - tmp59 := tmp58.Get() - var tmp60 any - tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp62 := tmp61.FindInternedVar(lang.NewSymbol("empty?")) - if tmp62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) - } - tmp63 := tmp62.Get() - tmp64 := lang.Apply(tmp63, []any{v7}) - if lang.IsTruthy(tmp64) { - tmp60 = v6 - } else { - tmp65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp66 := tmp65.FindInternedVar(lang.NewSymbol("last")) - if tmp66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp66))) - } - tmp67 := tmp66.Get() - tmp68 := lang.Apply(tmp67, []any{v7}) - tmp60 = tmp68 - } - tmp69 := lang.Apply(tmp59, []any{tmp60}) - tmp70 := lang.Apply(tmp13, []any{tmp17, tmp56, tmp69}) - tmp71 := lang.Apply(tmp10, []any{tmp70}) - return tmp71 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // aset - { - var tmp1 lang.FnFunc - { // function aset__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("seq")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("concat")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("list")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol(".")}) - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("list")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("list")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("seq")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("concat")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("list")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.Apply(tmp31, []any{lang.NewSymbol("glojure.core/Aset")}) - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("list")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.Apply(tmp35, []any{v3}) - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("list")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("seq")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp44 := tmp43.FindInternedVar(lang.NewSymbol("concat")) - if tmp44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) - } - tmp45 := tmp44.Get() - tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp47 := tmp46.FindInternedVar(lang.NewSymbol("list")) - if tmp47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) - } - tmp48 := tmp47.Get() - tmp49 := lang.Apply(tmp48, []any{lang.NewSymbol("glojure.core/int")}) - tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp51 := tmp50.FindInternedVar(lang.NewSymbol("list")) - if tmp51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) - } - tmp52 := tmp51.Get() - tmp53 := lang.Apply(tmp52, []any{v4}) - tmp54 := lang.Apply(tmp45, []any{tmp49, tmp53}) - tmp55 := lang.Apply(tmp42, []any{tmp54}) - tmp56 := lang.Apply(tmp39, []any{tmp55}) - tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp58 := tmp57.FindInternedVar(lang.NewSymbol("list")) - if tmp58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) - } - tmp59 := tmp58.Get() - tmp60 := lang.Apply(tmp59, []any{v5}) - tmp61 := lang.Apply(tmp28, []any{tmp32, tmp36, tmp56, tmp60}) - tmp62 := lang.Apply(tmp25, []any{tmp61}) - tmp63 := lang.Apply(tmp22, []any{tmp62}) - tmp64 := lang.Apply(tmp11, []any{tmp15, tmp19, tmp63}) - tmp65 := lang.Apply(tmp8, []any{tmp64}) - return tmp65 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("aset").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on Java arrays of\n reference types. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(3)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3922), lang.NewKeyword("end-line"), int(3922))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 3: - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - v6 := args[2] - _ = v6 - tmp7 := lang.Apply(lang.SliceSet, []any{v4, v5, v6}) - _ = tmp7 - return v6 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - v6 := args[2] - _ = v6 - var v7 any = lang.NewList(args[3:]...) - _ = v7 - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("apply")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("aset")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("aget")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{v4, v5}) - tmp18 := lang.Apply(tmp10, []any{tmp13, tmp17, v6, v7}) - return tmp18 - } - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // aset-boolean - { - tmp0 := lang.NewSymbol("aset-boolean").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of boolean. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3956), lang.NewKeyword("end-line"), int(3958))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("boolean")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(tmp8, []any{v5}) - tmp10, _ := lang.FieldOrMethod(nil, "setBoolean") - if reflect.TypeOf(tmp10).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setBoolean is not a function"))) - } - tmp11 := lang.Apply(tmp10, []any{v3, v4, tmp9}) - _ = tmp11 - return v5 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("apply")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("aset-boolean")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("aget")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{v3, v4}) - tmp17 := lang.Apply(tmp9, []any{tmp12, tmp16, v5, v6}) - return tmp17 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // aset-byte - { - tmp0 := lang.NewSymbol("aset-byte").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of byte. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3976), lang.NewKeyword("end-line"), int(3978))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("byte")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(tmp8, []any{v5}) - tmp10, _ := lang.FieldOrMethod(nil, "setByte") - if reflect.TypeOf(tmp10).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setByte is not a function"))) - } - tmp11 := lang.Apply(tmp10, []any{v3, v4, tmp9}) - _ = tmp11 - return v5 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("apply")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("aset-byte")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("aget")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{v3, v4}) - tmp17 := lang.Apply(tmp9, []any{tmp12, tmp16, v5, v6}) - return tmp17 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // aset-char - { - tmp0 := lang.NewSymbol("aset-char").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of char. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3981), lang.NewKeyword("end-line"), int(3983))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("char")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(tmp8, []any{v5}) - tmp10, _ := lang.FieldOrMethod(nil, "setChar") - if reflect.TypeOf(tmp10).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setChar is not a function"))) - } - tmp11 := lang.Apply(tmp10, []any{v3, v4, tmp9}) - _ = tmp11 - return v5 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("apply")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("aset-char")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("aget")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{v3, v4}) - tmp17 := lang.Apply(tmp9, []any{tmp12, tmp16, v5, v6}) - return tmp17 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // aset-double - { - tmp0 := lang.NewSymbol("aset-double").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of double. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3966), lang.NewKeyword("end-line"), int(3968))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("double")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(tmp8, []any{v5}) - tmp10, _ := lang.FieldOrMethod(nil, "setDouble") - if reflect.TypeOf(tmp10).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setDouble is not a function"))) - } - tmp11 := lang.Apply(tmp10, []any{v3, v4, tmp9}) - _ = tmp11 - return v5 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("apply")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("aset-double")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("aget")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{v3, v4}) - tmp17 := lang.Apply(tmp9, []any{tmp12, tmp16, v5, v6}) - return tmp17 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // aset-float - { - tmp0 := lang.NewSymbol("aset-float").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of float. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3961), lang.NewKeyword("end-line"), int(3963))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("float")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(tmp8, []any{v5}) - tmp10, _ := lang.FieldOrMethod(nil, "setFloat") - if reflect.TypeOf(tmp10).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setFloat is not a function"))) - } - tmp11 := lang.Apply(tmp10, []any{v3, v4, tmp9}) - _ = tmp11 - return v5 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("apply")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("aset-float")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("aget")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{v3, v4}) - tmp17 := lang.Apply(tmp9, []any{tmp12, tmp16, v5, v6}) - return tmp17 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // aset-int - { - tmp0 := lang.NewSymbol("aset-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of int. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3946), lang.NewKeyword("end-line"), int(3948))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("int")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(tmp8, []any{v5}) - tmp10, _ := lang.FieldOrMethod(nil, "setInt") - if reflect.TypeOf(tmp10).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setInt is not a function"))) - } - tmp11 := lang.Apply(tmp10, []any{v3, v4, tmp9}) - _ = tmp11 - return v5 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("apply")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("aset-int")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("aget")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{v3, v4}) - tmp17 := lang.Apply(tmp9, []any{tmp12, tmp16, v5, v6}) - return tmp17 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // aset-long - { - tmp0 := lang.NewSymbol("aset-long").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of long. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3951), lang.NewKeyword("end-line"), int(3953))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("long")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(tmp8, []any{v5}) - tmp10, _ := lang.FieldOrMethod(nil, "setLong") - if reflect.TypeOf(tmp10).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setLong is not a function"))) - } - tmp11 := lang.Apply(tmp10, []any{v3, v4, tmp9}) - _ = tmp11 - return v5 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("apply")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("aset-long")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("aget")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{v3, v4}) - tmp17 := lang.Apply(tmp9, []any{tmp12, tmp16, v5, v6}) - return tmp17 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // aset-short - { - tmp0 := lang.NewSymbol("aset-short").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of short. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3971), lang.NewKeyword("end-line"), int(3973))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("short")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(tmp8, []any{v5}) - tmp10, _ := lang.FieldOrMethod(nil, "setShort") - if reflect.TypeOf(tmp10).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setShort is not a function"))) - } - tmp11 := lang.Apply(tmp10, []any{v3, v4, tmp9}) - _ = tmp11 - return v5 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("apply")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("aset-short")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("aget")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{v3, v4}) - tmp17 := lang.Apply(tmp9, []any{tmp12, tmp16, v5, v6}) - return tmp17 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // assert - { - tmp0 := lang.NewSymbol("assert").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("message"))), lang.NewKeyword("doc"), "Evaluates expression x and throws an AssertionError with optional\n message if x does not evaluate to logical true.\n\n Assertion checks are omitted from compiled code if '*assert*' is\n false.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4837), lang.NewKeyword("end-line"), int(4837))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var tmp6 any - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("*assert*")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - if lang.IsTruthy(tmp9) { - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("seq")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("concat")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("list")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{lang.NewSymbol("glojure.core/when-not")}) - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("list")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.Apply(tmp22, []any{v5}) - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("list")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("seq")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("concat")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("list")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.Apply(tmp35, []any{lang.NewSymbol("throw")}) - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("list")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("seq")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp44 := tmp43.FindInternedVar(lang.NewSymbol("concat")) - if tmp44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) - } - tmp45 := tmp44.Get() - tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp47 := tmp46.FindInternedVar(lang.NewSymbol("list")) - if tmp47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) - } - tmp48 := tmp47.Get() - tmp49 := lang.Apply(tmp48, []any{lang.NewSymbol("new")}) - tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp51 := tmp50.FindInternedVar(lang.NewSymbol("list")) - if tmp51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) - } - tmp52 := tmp51.Get() - tmp53 := lang.Apply(tmp52, []any{lang.NewSymbol("glojure.core/AssertionError")}) - tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp55 := tmp54.FindInternedVar(lang.NewSymbol("list")) - if tmp55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) - } - tmp56 := tmp55.Get() - tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp58 := tmp57.FindInternedVar(lang.NewSymbol("seq")) - if tmp58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) - } - tmp59 := tmp58.Get() - tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp61 := tmp60.FindInternedVar(lang.NewSymbol("concat")) - if tmp61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) - } - tmp62 := tmp61.Get() - tmp63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp64 := tmp63.FindInternedVar(lang.NewSymbol("list")) - if tmp64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp64))) - } - tmp65 := tmp64.Get() - tmp66 := lang.Apply(tmp65, []any{lang.NewSymbol("glojure.core/str")}) - tmp67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp68 := tmp67.FindInternedVar(lang.NewSymbol("list")) - if tmp68.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp68))) - } - tmp69 := tmp68.Get() - tmp70 := lang.Apply(tmp69, []any{"Assert failed: "}) - tmp71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp72 := tmp71.FindInternedVar(lang.NewSymbol("list")) - if tmp72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp72))) - } - tmp73 := tmp72.Get() - tmp74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp75 := tmp74.FindInternedVar(lang.NewSymbol("seq")) - if tmp75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp75))) - } - tmp76 := tmp75.Get() - tmp77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp78 := tmp77.FindInternedVar(lang.NewSymbol("concat")) - if tmp78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp78))) - } - tmp79 := tmp78.Get() - tmp80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp81 := tmp80.FindInternedVar(lang.NewSymbol("list")) - if tmp81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp81))) - } - tmp82 := tmp81.Get() - tmp83 := lang.Apply(tmp82, []any{lang.NewSymbol("glojure.core/pr-str")}) - tmp84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp85 := tmp84.FindInternedVar(lang.NewSymbol("list")) - if tmp85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp85))) - } - tmp86 := tmp85.Get() - tmp87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp88 := tmp87.FindInternedVar(lang.NewSymbol("seq")) - if tmp88.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp88))) - } - tmp89 := tmp88.Get() - tmp90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp91 := tmp90.FindInternedVar(lang.NewSymbol("concat")) - if tmp91.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp91))) - } - tmp92 := tmp91.Get() - tmp93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp94 := tmp93.FindInternedVar(lang.NewSymbol("list")) - if tmp94.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp94))) - } - tmp95 := tmp94.Get() - tmp96 := lang.Apply(tmp95, []any{lang.NewSymbol("quote")}) - tmp97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp98 := tmp97.FindInternedVar(lang.NewSymbol("list")) - if tmp98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp98))) - } - tmp99 := tmp98.Get() - tmp100 := lang.Apply(tmp99, []any{v5}) - tmp101 := lang.Apply(tmp92, []any{tmp96, tmp100}) - tmp102 := lang.Apply(tmp89, []any{tmp101}) - tmp103 := lang.Apply(tmp86, []any{tmp102}) - tmp104 := lang.Apply(tmp79, []any{tmp83, tmp103}) - tmp105 := lang.Apply(tmp76, []any{tmp104}) - tmp106 := lang.Apply(tmp73, []any{tmp105}) - tmp107 := lang.Apply(tmp62, []any{tmp66, tmp70, tmp106}) - tmp108 := lang.Apply(tmp59, []any{tmp107}) - tmp109 := lang.Apply(tmp56, []any{tmp108}) - tmp110 := lang.Apply(tmp45, []any{tmp49, tmp53, tmp109}) - tmp111 := lang.Apply(tmp42, []any{tmp110}) - tmp112 := lang.Apply(tmp39, []any{tmp111}) - tmp113 := lang.Apply(tmp32, []any{tmp36, tmp112}) - tmp114 := lang.Apply(tmp29, []any{tmp113}) - tmp115 := lang.Apply(tmp26, []any{tmp114}) - tmp116 := lang.Apply(tmp15, []any{tmp19, tmp23, tmp115}) - tmp117 := lang.Apply(tmp12, []any{tmp116}) - tmp6 = tmp117 - } else { - } - return tmp6 - case 4: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - var tmp7 any - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("*assert*")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - if lang.IsTruthy(tmp10) { - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("seq")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("concat")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("list")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.Apply(tmp19, []any{lang.NewSymbol("glojure.core/when-not")}) - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("list")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.Apply(tmp23, []any{v5}) - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("list")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("seq")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("concat")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("list")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.Apply(tmp36, []any{lang.NewSymbol("throw")}) - tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp39 := tmp38.FindInternedVar(lang.NewSymbol("list")) - if tmp39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) - } - tmp40 := tmp39.Get() - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("seq")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("concat")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp48 := tmp47.FindInternedVar(lang.NewSymbol("list")) - if tmp48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) - } - tmp49 := tmp48.Get() - tmp50 := lang.Apply(tmp49, []any{lang.NewSymbol("new")}) - tmp51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp52 := tmp51.FindInternedVar(lang.NewSymbol("list")) - if tmp52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp52))) - } - tmp53 := tmp52.Get() - tmp54 := lang.Apply(tmp53, []any{lang.NewSymbol("glojure.core/AssertionError")}) - tmp55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp56 := tmp55.FindInternedVar(lang.NewSymbol("list")) - if tmp56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp56))) - } - tmp57 := tmp56.Get() - tmp58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp59 := tmp58.FindInternedVar(lang.NewSymbol("seq")) - if tmp59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp59))) - } - tmp60 := tmp59.Get() - tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp62 := tmp61.FindInternedVar(lang.NewSymbol("concat")) - if tmp62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) - } - tmp63 := tmp62.Get() - tmp64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp65 := tmp64.FindInternedVar(lang.NewSymbol("list")) - if tmp65.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp65))) - } - tmp66 := tmp65.Get() - tmp67 := lang.Apply(tmp66, []any{lang.NewSymbol("glojure.core/str")}) - tmp68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp69 := tmp68.FindInternedVar(lang.NewSymbol("list")) - if tmp69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp69))) - } - tmp70 := tmp69.Get() - tmp71 := lang.Apply(tmp70, []any{"Assert failed: "}) - tmp72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp73 := tmp72.FindInternedVar(lang.NewSymbol("list")) - if tmp73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp73))) - } - tmp74 := tmp73.Get() - tmp75 := lang.Apply(tmp74, []any{v6}) - tmp76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp77 := tmp76.FindInternedVar(lang.NewSymbol("list")) - if tmp77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp77))) - } - tmp78 := tmp77.Get() - tmp79 := lang.Apply(tmp78, []any{"\n"}) - tmp80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp81 := tmp80.FindInternedVar(lang.NewSymbol("list")) - if tmp81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp81))) - } - tmp82 := tmp81.Get() - tmp83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp84 := tmp83.FindInternedVar(lang.NewSymbol("seq")) - if tmp84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp84))) - } - tmp85 := tmp84.Get() - tmp86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp87 := tmp86.FindInternedVar(lang.NewSymbol("concat")) - if tmp87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp87))) - } - tmp88 := tmp87.Get() - tmp89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp90 := tmp89.FindInternedVar(lang.NewSymbol("list")) - if tmp90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp90))) - } - tmp91 := tmp90.Get() - tmp92 := lang.Apply(tmp91, []any{lang.NewSymbol("glojure.core/pr-str")}) - tmp93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp94 := tmp93.FindInternedVar(lang.NewSymbol("list")) - if tmp94.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp94))) - } - tmp95 := tmp94.Get() - tmp96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp97 := tmp96.FindInternedVar(lang.NewSymbol("seq")) - if tmp97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp97))) - } - tmp98 := tmp97.Get() - tmp99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp100 := tmp99.FindInternedVar(lang.NewSymbol("concat")) - if tmp100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp100))) - } - tmp101 := tmp100.Get() - tmp102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp103 := tmp102.FindInternedVar(lang.NewSymbol("list")) - if tmp103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp103))) - } - tmp104 := tmp103.Get() - tmp105 := lang.Apply(tmp104, []any{lang.NewSymbol("quote")}) - tmp106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp107 := tmp106.FindInternedVar(lang.NewSymbol("list")) - if tmp107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp107))) - } - tmp108 := tmp107.Get() - tmp109 := lang.Apply(tmp108, []any{v5}) - tmp110 := lang.Apply(tmp101, []any{tmp105, tmp109}) - tmp111 := lang.Apply(tmp98, []any{tmp110}) - tmp112 := lang.Apply(tmp95, []any{tmp111}) - tmp113 := lang.Apply(tmp88, []any{tmp92, tmp112}) - tmp114 := lang.Apply(tmp85, []any{tmp113}) - tmp115 := lang.Apply(tmp82, []any{tmp114}) - tmp116 := lang.Apply(tmp63, []any{tmp67, tmp71, tmp75, tmp79, tmp115}) - tmp117 := lang.Apply(tmp60, []any{tmp116}) - tmp118 := lang.Apply(tmp57, []any{tmp117}) - tmp119 := lang.Apply(tmp46, []any{tmp50, tmp54, tmp118}) - tmp120 := lang.Apply(tmp43, []any{tmp119}) - tmp121 := lang.Apply(tmp40, []any{tmp120}) - tmp122 := lang.Apply(tmp33, []any{tmp37, tmp121}) - tmp123 := lang.Apply(tmp30, []any{tmp122}) - tmp124 := lang.Apply(tmp27, []any{tmp123}) - tmp125 := lang.Apply(tmp16, []any{tmp20, tmp24, tmp124}) - tmp126 := lang.Apply(tmp13, []any{tmp125}) - tmp7 = tmp126 - } else { - } - return tmp7 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // assert-args - { - tmp0 := lang.NewSymbol("assert-args").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("pairs"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(38), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1830), lang.NewKeyword("end-line"), int(1830), lang.NewKeyword("private"), true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("seq")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("concat")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("list")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("do")}) - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("list")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("seq")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("concat")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("list")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.Apply(tmp27, []any{lang.NewSymbol("glojure.core/when-not")}) - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("list")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("first")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.Apply(tmp34, []any{v5}) - tmp36 := lang.Apply(tmp31, []any{tmp35}) - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("list")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("seq")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp44 := tmp43.FindInternedVar(lang.NewSymbol("concat")) - if tmp44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) - } - tmp45 := tmp44.Get() - tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp47 := tmp46.FindInternedVar(lang.NewSymbol("list")) - if tmp47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) - } - tmp48 := tmp47.Get() - tmp49 := lang.Apply(tmp48, []any{lang.NewSymbol("throw")}) - tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp51 := tmp50.FindInternedVar(lang.NewSymbol("list")) - if tmp51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) - } - tmp52 := tmp51.Get() - tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp54 := tmp53.FindInternedVar(lang.NewSymbol("seq")) - if tmp54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) - } - tmp55 := tmp54.Get() - tmp56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp57 := tmp56.FindInternedVar(lang.NewSymbol("concat")) - if tmp57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp57))) - } - tmp58 := tmp57.Get() - tmp59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp60 := tmp59.FindInternedVar(lang.NewSymbol("list")) - if tmp60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp60))) - } - tmp61 := tmp60.Get() - tmp62 := lang.Apply(tmp61, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewIllegalArgumentError")}) - tmp63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp64 := tmp63.FindInternedVar(lang.NewSymbol("list")) - if tmp64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp64))) - } - tmp65 := tmp64.Get() - tmp66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp67 := tmp66.FindInternedVar(lang.NewSymbol("seq")) - if tmp67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp67))) - } - tmp68 := tmp67.Get() - tmp69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp70 := tmp69.FindInternedVar(lang.NewSymbol("concat")) - if tmp70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp70))) - } - tmp71 := tmp70.Get() - tmp72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp73 := tmp72.FindInternedVar(lang.NewSymbol("list")) - if tmp73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp73))) - } - tmp74 := tmp73.Get() - tmp75 := lang.Apply(tmp74, []any{lang.NewSymbol("glojure.core/str")}) - tmp76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp77 := tmp76.FindInternedVar(lang.NewSymbol("list")) - if tmp77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp77))) - } - tmp78 := tmp77.Get() - tmp79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp80 := tmp79.FindInternedVar(lang.NewSymbol("seq")) - if tmp80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp80))) - } - tmp81 := tmp80.Get() - tmp82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp83 := tmp82.FindInternedVar(lang.NewSymbol("concat")) - if tmp83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp83))) - } - tmp84 := tmp83.Get() - tmp85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp86 := tmp85.FindInternedVar(lang.NewSymbol("list")) - if tmp86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp86))) - } - tmp87 := tmp86.Get() - tmp88 := lang.Apply(tmp87, []any{lang.NewSymbol("glojure.core/first")}) - tmp89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp90 := tmp89.FindInternedVar(lang.NewSymbol("list")) - if tmp90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp90))) - } - tmp91 := tmp90.Get() - tmp92 := lang.Apply(tmp91, []any{lang.NewSymbol("&form")}) - tmp93 := lang.Apply(tmp84, []any{tmp88, tmp92}) - tmp94 := lang.Apply(tmp81, []any{tmp93}) - tmp95 := lang.Apply(tmp78, []any{tmp94}) - tmp96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp97 := tmp96.FindInternedVar(lang.NewSymbol("list")) - if tmp97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp97))) - } - tmp98 := tmp97.Get() - tmp99 := lang.Apply(tmp98, []any{" requires "}) - tmp100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp101 := tmp100.FindInternedVar(lang.NewSymbol("list")) - if tmp101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp101))) - } - tmp102 := tmp101.Get() - tmp103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp104 := tmp103.FindInternedVar(lang.NewSymbol("second")) - if tmp104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp104))) - } - tmp105 := tmp104.Get() - tmp106 := lang.Apply(tmp105, []any{v5}) - tmp107 := lang.Apply(tmp102, []any{tmp106}) - tmp108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp109 := tmp108.FindInternedVar(lang.NewSymbol("list")) - if tmp109.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp109))) - } - tmp110 := tmp109.Get() - tmp111 := lang.Apply(tmp110, []any{" in "}) - tmp112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp113 := tmp112.FindInternedVar(lang.NewSymbol("list")) - if tmp113.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp113))) - } - tmp114 := tmp113.Get() - tmp115 := lang.Apply(tmp114, []any{lang.NewSymbol("*ns*")}) - tmp116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp117 := tmp116.FindInternedVar(lang.NewSymbol("list")) - if tmp117.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp117))) - } - tmp118 := tmp117.Get() - tmp119 := lang.Apply(tmp118, []any{":"}) - tmp120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp121 := tmp120.FindInternedVar(lang.NewSymbol("list")) - if tmp121.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp121))) - } - tmp122 := tmp121.Get() - tmp123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp124 := tmp123.FindInternedVar(lang.NewSymbol("seq")) - if tmp124.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp124))) - } - tmp125 := tmp124.Get() - tmp126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp127 := tmp126.FindInternedVar(lang.NewSymbol("concat")) - if tmp127.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp127))) - } - tmp128 := tmp127.Get() - tmp129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp130 := tmp129.FindInternedVar(lang.NewSymbol("list")) - if tmp130.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp130))) - } - tmp131 := tmp130.Get() - tmp132 := lang.Apply(tmp131, []any{lang.NewKeyword("line")}) - tmp133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp134 := tmp133.FindInternedVar(lang.NewSymbol("list")) - if tmp134.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp134))) - } - tmp135 := tmp134.Get() - tmp136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp137 := tmp136.FindInternedVar(lang.NewSymbol("seq")) - if tmp137.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp137))) - } - tmp138 := tmp137.Get() - tmp139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp140 := tmp139.FindInternedVar(lang.NewSymbol("concat")) - if tmp140.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp140))) - } - tmp141 := tmp140.Get() - tmp142 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp143 := tmp142.FindInternedVar(lang.NewSymbol("list")) - if tmp143.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp143))) - } - tmp144 := tmp143.Get() - tmp145 := lang.Apply(tmp144, []any{lang.NewSymbol("glojure.core/meta")}) - tmp146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp147 := tmp146.FindInternedVar(lang.NewSymbol("list")) - if tmp147.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp147))) - } - tmp148 := tmp147.Get() - tmp149 := lang.Apply(tmp148, []any{lang.NewSymbol("&form")}) - tmp150 := lang.Apply(tmp141, []any{tmp145, tmp149}) - tmp151 := lang.Apply(tmp138, []any{tmp150}) - tmp152 := lang.Apply(tmp135, []any{tmp151}) - tmp153 := lang.Apply(tmp128, []any{tmp132, tmp152}) - tmp154 := lang.Apply(tmp125, []any{tmp153}) - tmp155 := lang.Apply(tmp122, []any{tmp154}) - tmp156 := lang.Apply(tmp71, []any{tmp75, tmp95, tmp99, tmp107, tmp111, tmp115, tmp119, tmp155}) - tmp157 := lang.Apply(tmp68, []any{tmp156}) - tmp158 := lang.Apply(tmp65, []any{tmp157}) - tmp159 := lang.Apply(tmp58, []any{tmp62, tmp158}) - tmp160 := lang.Apply(tmp55, []any{tmp159}) - tmp161 := lang.Apply(tmp52, []any{tmp160}) - tmp162 := lang.Apply(tmp45, []any{tmp49, tmp161}) - tmp163 := lang.Apply(tmp42, []any{tmp162}) - tmp164 := lang.Apply(tmp39, []any{tmp163}) - tmp165 := lang.Apply(tmp24, []any{tmp28, tmp36, tmp164}) - tmp166 := lang.Apply(tmp21, []any{tmp165}) - tmp167 := lang.Apply(tmp18, []any{tmp166}) - tmp168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp169 := tmp168.FindInternedVar(lang.NewSymbol("list")) - if tmp169.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp169))) - } - tmp170 := tmp169.Get() - var tmp171 any - { // let - // let binding "more" - tmp172 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp173 := tmp172.FindInternedVar(lang.NewSymbol("nnext")) - if tmp173.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp173))) - } - tmp174 := tmp173.Get() - tmp175 := lang.Apply(tmp174, []any{v5}) - var v176 any = tmp175 - _ = v176 - var tmp177 any - if lang.IsTruthy(v176) { - tmp178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp179 := tmp178.FindInternedVar(lang.NewSymbol("list*")) - if tmp179.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp179))) - } - tmp180 := tmp179.Get() - tmp181 := lang.Apply(tmp180, []any{lang.NewSymbol("glojure.core/assert-args"), v176}) - tmp177 = tmp181 - } else { - } - tmp171 = tmp177 - } // end let - tmp172 := lang.Apply(tmp170, []any{tmp171}) - tmp173 := lang.Apply(tmp11, []any{tmp15, tmp167, tmp172}) - tmp174 := lang.Apply(tmp8, []any{tmp173}) - return tmp174 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // assert-valid-fdecl - { - tmp0 := lang.NewSymbol("assert-valid-fdecl").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fdecl"))), lang.NewKeyword("doc"), "A good fdecl looks like (([a] ...) ([a b] ...)) near the end of defn.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(42), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(7502), lang.NewKeyword("end-line"), int(7502), lang.NewKeyword("private"), true, lang.NewKeyword("dynamic"), true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("empty?")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v3}) - if lang.IsTruthy(tmp8) { - tmp9 := lang.Apply(lang.NewIllegalArgumentError, []any{"Parameter declaration missing"}) - panic(tmp9) - } else { - } - _ = tmp4 - var tmp10 any - { // let - // let binding "argdecls" - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("map")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - var tmp14 lang.FnFunc - tmp14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v15 := args[0] - _ = v15 - var tmp16 any - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq?")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.Apply(tmp19, []any{v15}) - if lang.IsTruthy(tmp20) { - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("first")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.Apply(tmp23, []any{v15}) - tmp16 = tmp24 - } else { - var tmp25 any - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("seq?")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("first")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.Apply(tmp31, []any{v3}) - tmp33 := lang.Apply(tmp28, []any{tmp32}) - if lang.IsTruthy(tmp33) { - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("str")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.Apply(tmp36, []any{"Invalid signature \"", v15, "\" should be a list"}) - tmp25 = tmp37 - } else { - tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp39 := tmp38.FindInternedVar(lang.NewSymbol("str")) - if tmp39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) - } - tmp40 := tmp39.Get() - tmp41 := lang.Apply(tmp40, []any{"Parameter declaration \"", v15, "\" should be a vector"}) - tmp25 = tmp41 - } - tmp42 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp25}) - panic(tmp42) - } - return tmp16 - }) - tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7508), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7517), lang.NewKeyword("end-column"), int(59)) - tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp17 := lang.Apply(tmp13, []any{tmp16, v3}) - var v18 any = tmp17 - _ = v18 - // let binding "bad-args" - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("seq")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("remove")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - var tmp25 lang.FnFunc - tmp25 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v26 := args[0] - _ = v26 - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("vector?")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{v26}) - return tmp30 - }) - tmp26 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7519), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(7519), lang.NewKeyword("end-column"), int(42)) - tmp27, err := lang.WithMeta(tmp25, tmp26.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp28 := lang.Apply(tmp24, []any{tmp27, v18}) - tmp29 := lang.Apply(tmp21, []any{tmp28}) - var v30 any = tmp29 - _ = v30 - var tmp31 any - if lang.IsTruthy(v30) { - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("str")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp36 := tmp35.FindInternedVar(lang.NewSymbol("first")) - if tmp36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) - } - tmp37 := tmp36.Get() - tmp38 := lang.Apply(tmp37, []any{v30}) - tmp39 := lang.Apply(tmp34, []any{"Parameter declaration \"", tmp38, "\" should be a vector"}) - tmp40 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp39}) - panic(tmp40) - } else { - } - tmp10 = tmp31 - } // end let - return tmp10 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // assoc - { - tmp0 := lang.NewSymbol("assoc").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"), lang.NewSymbol("val"), lang.NewSymbol("&"), lang.NewSymbol("kvs"))), lang.NewKeyword("doc"), "assoc[iate]. When applied to a map, returns a new map of the\n same (hashed/sorted) type, that contains the mapping of key(s) to\n val(s). When applied to a vector, returns a new vector that\n contains val at index. Note - index must be <= (count vector).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(181), lang.NewKeyword("end-line"), int(188))).(*lang.Symbol) - var tmp2 lang.FnFunc - { // function assoc - var v3 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 3: - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - v6 := args[2] - _ = v6 - tmp7 := lang.Apply(lang.Assoc, []any{v4, v5, v6}) - return tmp7 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - v6 := args[2] - _ = v6 - var v7 any = lang.NewList(args[3:]...) - _ = v7 - recur_loop_24: - var tmp8 any - { // let - // let binding "ret" - tmp9 := lang.Apply(lang.Assoc, []any{v4, v5, v6}) - var v10 any = tmp9 - _ = v10 - var tmp11 any - if lang.IsTruthy(v7) { - var tmp12 any - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("next")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{v7}) - if lang.IsTruthy(tmp16) { - var tmp17 any = v10 - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("first")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, []any{v7}) - var tmp18 any = tmp22 - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("second")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.Apply(tmp26, []any{v7}) - var tmp23 any = tmp27 - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("nnext")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.Apply(tmp31, []any{v7}) - var tmp28 any = tmp32 - v4 = tmp17 - v5 = tmp18 - v6 = tmp23 - v7 = tmp28 - goto recur_loop_24 - } else { - tmp33 := lang.Apply(lang.NewIllegalArgumentError, []any{"assoc expects even number of arguments after map/vector, found odd number"}) - panic(tmp33) - } - tmp11 = tmp12 - } else { - tmp11 = v10 - } - tmp8 = tmp11 - } // end let - return tmp8 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(189), lang.NewKeyword("column"), int(2), lang.NewKeyword("end-line"), int(198), lang.NewKeyword("end-column"), int(15))).(lang.FnFunc) - v3 = tmp2 - _ = v3 - } - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // assoc! - { - tmp0 := lang.NewSymbol("assoc!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("key"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("key"), lang.NewSymbol("val"), lang.NewSymbol("&"), lang.NewSymbol("kvs"))), lang.NewKeyword("doc"), "When applied to a transient map, adds mapping of key(s) to\n val(s). When applied to a transient vector, sets the val at index.\n Note - index must be <= (count vector). Returns coll.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3369), lang.NewKeyword("end-line"), int(3369))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6, _ := lang.FieldOrMethod(v3, "Assoc") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Assoc is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - recur_loop_609: - var tmp7 any - { // let - // let binding "ret" - tmp8, _ := lang.FieldOrMethod(v3, "Assoc") - if reflect.TypeOf(tmp8).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Assoc is not a function"))) - } - tmp9 := lang.Apply(tmp8, []any{v4, v5}) - var v10 any = tmp9 - _ = v10 - var tmp11 any - if lang.IsTruthy(v6) { - var tmp12 any = v10 - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("first")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{v6}) - var tmp13 any = tmp17 - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("second")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, []any{v6}) - var tmp18 any = tmp22 - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("nnext")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.Apply(tmp26, []any{v6}) - var tmp23 any = tmp27 - v3 = tmp12 - v4 = tmp13 - v5 = tmp18 - v6 = tmp23 - goto recur_loop_609 - } else { - tmp11 = v10 - } - tmp7 = tmp11 - } // end let - return tmp7 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // assoc-in - { - tmp0 := lang.NewSymbol("assoc-in").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("&"), lang.NewSymbol("ks")), lang.NewSymbol("v"))), lang.NewKeyword("doc"), "Associates a value in a nested associative structure, where ks is a\n sequence of keys and v is the new value and returns a new nested structure.\n If any levels do not exist, hash-maps will be created.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6147), lang.NewKeyword("end-line"), int(6147))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var tmp6 any - { // let - // let binding "vec__138" - var v7 any = v4 - _ = v7 - // let binding "seq__139" - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("seq")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v7}) - var v12 any = tmp11 - _ = v12 - // let binding "first__140" - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("first")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{v12}) - var v17 any = tmp16 - _ = v17 - // let binding "seq__139" - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("next")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.Apply(tmp20, []any{v12}) - var v22 any = tmp21 - _ = v22 - // let binding "k" - var v23 any = v17 - _ = v23 - // let binding "ks" - var v24 any = v22 - _ = v24 - var tmp25 any - if lang.IsTruthy(v24) { - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("assoc")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("assoc-in")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("get")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.Apply(tmp34, []any{v3, v23}) - tmp36 := lang.Apply(tmp31, []any{tmp35, v24, v5}) - tmp37 := lang.Apply(tmp28, []any{v3, v23, tmp36}) - tmp25 = tmp37 - } else { - tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp39 := tmp38.FindInternedVar(lang.NewSymbol("assoc")) - if tmp39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) - } - tmp40 := tmp39.Get() - tmp41 := lang.Apply(tmp40, []any{v3, v23, v5}) - tmp25 = tmp41 - } - tmp6 = tmp25 - } // end let - return tmp6 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // associative? - { - tmp0 := lang.NewSymbol("associative?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements Associative", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6223), lang.NewKeyword("end-line"), int(6223))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.Apply(tmp6, []any{nil, v3}) - return tmp7 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // atom - { - tmp0 := lang.NewSymbol("atom").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Creates and returns an Atom with an initial value of x and zero or\n more options (in any order):\n\n :meta metadata-map\n\n :validator validate-fn\n\n If metadata-map is supplied, it will become the metadata on the\n atom. validate-fn must be nil or a side-effect-free fn of one\n argument, which will be passed the intended new state on any state\n change. If the new state is unacceptable, the validate-fn should\n return false or throw an exception.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2325), lang.NewKeyword("end-line"), int(2325))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - tmp4 := lang.Apply(lang.NewAtom, []any{v3}) - return tmp4 - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var v4 any = lang.NewList(args[1:]...) - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("setup-reference")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("atom")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v3}) - tmp12 := lang.Apply(tmp7, []any{tmp11, v4}) - return tmp12 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // await - { - tmp0 := lang.NewSymbol("await").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("agents"))), lang.NewKeyword("doc"), "Blocks the current thread (indefinitely!) until all actions\n dispatched thus far, from this thread or agent, to the agent(s) have\n occurred. Will block on failed agents. Will never return if\n a failed agent is restarted with :clear-actions true or shutdown-agents was called.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3267), lang.NewKeyword("end-line"), int(3267))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var v3 any = lang.NewList(args[0:]...) - _ = v3 - var tmp4 any - tmp5 := lang.Apply(nil, nil) - if lang.IsTruthy(tmp5) { - panic("unimplemented: new with non-constant class type") - } else { - var tmp6 any - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("*agent*")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - if lang.IsTruthy(tmp9) { - tmp10 := lang.Apply(errors5.New, []any{"Can't await in agent action"}) - panic(tmp10) - } else { - } - _ = tmp6 - var tmp11 any - { // let - // let binding "latch" - var v12 any = "unimplemented: new with non-constant class type" - _ = v12 - // let binding "count-down" - var tmp13 lang.FnFunc - tmp13 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v14 := args[0] - _ = v14 - tmp15, _ := lang.FieldOrMethod(v12, "countDown") - if reflect.TypeOf(tmp15).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("countDown is not a function"))) - } - tmp16 := lang.Apply(tmp15, []any{}) - _ = tmp16 - return v14 - }) - tmp14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3279), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(3279), lang.NewKeyword("end-column"), int(61)) - tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v16 any = tmp15 - _ = v16 - var tmp17 any - { // let - // let binding "seq_1" - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("seq")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.Apply(tmp20, []any{v3}) - var v22 any = tmp21 - _ = v22 - // let binding "chunk_2" - var v23 any = nil - _ = v23 - // let binding "count_3" - var v24 any = int64(0) - _ = v24 - // let binding "i_4" - var v25 any = int64(0) - _ = v25 - for { - var tmp26 any - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("<")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{v25, v24}) - if lang.IsTruthy(tmp30) { - var tmp31 any - { // let - // let binding "agent" - tmp32, _ := lang.FieldOrMethod(v23, "nth") - if reflect.TypeOf(tmp32).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) - } - tmp33 := lang.Apply(tmp32, []any{v25}) - var v34 any = tmp33 - _ = v34 - tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp36 := tmp35.FindInternedVar(lang.NewSymbol("send")) - if tmp36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) - } - tmp37 := tmp36.Get() - tmp38 := lang.Apply(tmp37, []any{v34, v16}) - _ = tmp38 - var tmp39 any = v22 - var tmp40 any = v23 - var tmp41 any = v24 - tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp44 := tmp43.FindInternedVar(lang.NewSymbol("unchecked-inc")) - if tmp44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) - } - tmp45 := tmp44.Get() - tmp46 := lang.Apply(tmp45, []any{v25}) - var tmp42 any = tmp46 - v22 = tmp39 - v23 = tmp40 - v24 = tmp41 - v25 = tmp42 - continue - } // end let - tmp26 = tmp31 - } else { - var tmp32 any - { // let - // let binding "temp__0__auto__" - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("seq")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.Apply(tmp35, []any{v22}) - var v37 any = tmp36 - _ = v37 - var tmp38 any - if lang.IsTruthy(v37) { - var tmp39 any - { // let - // let binding "seq_1" - var v40 any = v37 - _ = v40 - var tmp41 any - tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp43 := tmp42.FindInternedVar(lang.NewSymbol("chunked-seq?")) - if tmp43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) - } - tmp44 := tmp43.Get() - tmp45 := lang.Apply(tmp44, []any{v40}) - if lang.IsTruthy(tmp45) { - var tmp46 any - { // let - // let binding "c__0__auto__" - tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp48 := tmp47.FindInternedVar(lang.NewSymbol("chunk-first")) - if tmp48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) - } - tmp49 := tmp48.Get() - tmp50 := lang.Apply(tmp49, []any{v40}) - var v51 any = tmp50 - _ = v51 - tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp54 := tmp53.FindInternedVar(lang.NewSymbol("chunk-rest")) - if tmp54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) - } - tmp55 := tmp54.Get() - tmp56 := lang.Apply(tmp55, []any{v40}) - var tmp52 any = tmp56 - var tmp57 any = v51 - tmp59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp60 := tmp59.FindInternedVar(lang.NewSymbol("int")) - if tmp60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp60))) - } - tmp61 := tmp60.Get() - tmp62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp63 := tmp62.FindInternedVar(lang.NewSymbol("count")) - if tmp63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp63))) - } - tmp64 := tmp63.Get() - tmp65 := lang.Apply(tmp64, []any{v51}) - tmp66 := lang.Apply(tmp61, []any{tmp65}) - var tmp58 any = tmp66 - tmp68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp69 := tmp68.FindInternedVar(lang.NewSymbol("int")) - if tmp69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp69))) - } - tmp70 := tmp69.Get() - tmp71 := lang.Apply(tmp70, []any{int64(0)}) - var tmp67 any = tmp71 - v22 = tmp52 - v23 = tmp57 - v24 = tmp58 - v25 = tmp67 - continue - } // end let - tmp41 = tmp46 - } else { - var tmp47 any - { // let - // let binding "agent" - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("first")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v40}) - var v52 any = tmp51 - _ = v52 - tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp54 := tmp53.FindInternedVar(lang.NewSymbol("send")) - if tmp54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) - } - tmp55 := tmp54.Get() - tmp56 := lang.Apply(tmp55, []any{v52, v16}) - _ = tmp56 - tmp58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp59 := tmp58.FindInternedVar(lang.NewSymbol("next")) - if tmp59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp59))) - } - tmp60 := tmp59.Get() - tmp61 := lang.Apply(tmp60, []any{v40}) - var tmp57 any = tmp61 - var tmp62 any = nil - var tmp63 any = int64(0) - var tmp64 any = int64(0) - v22 = tmp57 - v23 = tmp62 - v24 = tmp63 - v25 = tmp64 - continue - } // end let - tmp41 = tmp47 - } - tmp39 = tmp41 - } // end let - tmp38 = tmp39 - } else { - } - tmp32 = tmp38 - } // end let - tmp26 = tmp32 - } - tmp17 = tmp26 - break - } - } // end let - _ = tmp17 - tmp18, _ := lang.FieldOrMethod(v12, "await") - if reflect.TypeOf(tmp18).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) - } - tmp19 := lang.Apply(tmp18, []any{}) - tmp11 = tmp19 - } // end let - tmp4 = tmp11 - } - return tmp4 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // await-for - { - tmp0 := lang.NewSymbol("await-for").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("timeout-ms"), lang.NewSymbol("&"), lang.NewSymbol("agents"))), lang.NewKeyword("doc"), "Blocks the current thread until all actions dispatched thus\n far (from this thread or agent) to the agents have occurred, or the\n timeout (in milliseconds) has elapsed. Returns logical false if\n returning due to timeout, logical true otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3289), lang.NewKeyword("end-line"), int(3289))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var v4 any = lang.NewList(args[1:]...) - _ = v4 - var tmp5 any - tmp6 := lang.Apply(nil, nil) - if lang.IsTruthy(tmp6) { - panic("unimplemented: new with non-constant class type") - } else { - var tmp7 any - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("*agent*")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - if lang.IsTruthy(tmp10) { - tmp11 := lang.Apply(errors5.New, []any{"Can't await in agent action"}) - panic(tmp11) - } else { - } - _ = tmp7 - var tmp12 any - { // let - // let binding "latch" - var v13 any = "unimplemented: new with non-constant class type" - _ = v13 - // let binding "count-down" - var tmp14 lang.FnFunc - tmp14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v15 := args[0] - _ = v15 - tmp16, _ := lang.FieldOrMethod(v13, "countDown") - if reflect.TypeOf(tmp16).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("countDown is not a function"))) - } - tmp17 := lang.Apply(tmp16, []any{}) - _ = tmp17 - return v15 - }) - tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3301), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(3301), lang.NewKeyword("end-column"), int(62)) - tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v17 any = tmp16 - _ = v17 - var tmp18 any - { // let - // let binding "seq_5" - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("seq")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, []any{v4}) - var v23 any = tmp22 - _ = v23 - // let binding "chunk_6" - var v24 any = nil - _ = v24 - // let binding "count_7" - var v25 any = int64(0) - _ = v25 - // let binding "i_8" - var v26 any = int64(0) - _ = v26 - for { - var tmp27 any - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("<")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.Apply(tmp30, []any{v26, v25}) - if lang.IsTruthy(tmp31) { - var tmp32 any - { // let - // let binding "agent" - tmp33, _ := lang.FieldOrMethod(v24, "nth") - if reflect.TypeOf(tmp33).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) - } - tmp34 := lang.Apply(tmp33, []any{v26}) - var v35 any = tmp34 - _ = v35 - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("send")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{v35, v17}) - _ = tmp39 - var tmp40 any = v23 - var tmp41 any = v24 - var tmp42 any = v25 - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("unchecked-inc")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.Apply(tmp46, []any{v26}) - var tmp43 any = tmp47 - v23 = tmp40 - v24 = tmp41 - v25 = tmp42 - v26 = tmp43 - continue - } // end let - tmp27 = tmp32 - } else { - var tmp33 any - { // let - // let binding "temp__0__auto__" - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.Apply(tmp36, []any{v23}) - var v38 any = tmp37 - _ = v38 - var tmp39 any - if lang.IsTruthy(v38) { - var tmp40 any - { // let - // let binding "seq_5" - var v41 any = v38 - _ = v41 - var tmp42 any - tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp44 := tmp43.FindInternedVar(lang.NewSymbol("chunked-seq?")) - if tmp44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) - } - tmp45 := tmp44.Get() - tmp46 := lang.Apply(tmp45, []any{v41}) - if lang.IsTruthy(tmp46) { - var tmp47 any - { // let - // let binding "c__0__auto__" - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("chunk-first")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v41}) - var v52 any = tmp51 - _ = v52 - tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp55 := tmp54.FindInternedVar(lang.NewSymbol("chunk-rest")) - if tmp55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) - } - tmp56 := tmp55.Get() - tmp57 := lang.Apply(tmp56, []any{v41}) - var tmp53 any = tmp57 - var tmp58 any = v52 - tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp61 := tmp60.FindInternedVar(lang.NewSymbol("int")) - if tmp61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) - } - tmp62 := tmp61.Get() - tmp63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp64 := tmp63.FindInternedVar(lang.NewSymbol("count")) - if tmp64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp64))) - } - tmp65 := tmp64.Get() - tmp66 := lang.Apply(tmp65, []any{v52}) - tmp67 := lang.Apply(tmp62, []any{tmp66}) - var tmp59 any = tmp67 - tmp69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp70 := tmp69.FindInternedVar(lang.NewSymbol("int")) - if tmp70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp70))) - } - tmp71 := tmp70.Get() - tmp72 := lang.Apply(tmp71, []any{int64(0)}) - var tmp68 any = tmp72 - v23 = tmp53 - v24 = tmp58 - v25 = tmp59 - v26 = tmp68 - continue - } // end let - tmp42 = tmp47 - } else { - var tmp48 any - { // let - // let binding "agent" - tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp50 := tmp49.FindInternedVar(lang.NewSymbol("first")) - if tmp50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) - } - tmp51 := tmp50.Get() - tmp52 := lang.Apply(tmp51, []any{v41}) - var v53 any = tmp52 - _ = v53 - tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp55 := tmp54.FindInternedVar(lang.NewSymbol("send")) - if tmp55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) - } - tmp56 := tmp55.Get() - tmp57 := lang.Apply(tmp56, []any{v53, v17}) - _ = tmp57 - tmp59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp60 := tmp59.FindInternedVar(lang.NewSymbol("next")) - if tmp60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp60))) - } - tmp61 := tmp60.Get() - tmp62 := lang.Apply(tmp61, []any{v41}) - var tmp58 any = tmp62 - var tmp63 any = nil - var tmp64 any = int64(0) - var tmp65 any = int64(0) - v23 = tmp58 - v24 = tmp63 - v25 = tmp64 - v26 = tmp65 - continue - } // end let - tmp42 = tmp48 - } - tmp40 = tmp42 - } // end let - tmp39 = tmp40 - } else { - } - tmp33 = tmp39 - } // end let - tmp27 = tmp33 - } - tmp18 = tmp27 - break - } - } // end let - _ = tmp18 - tmp19, ok := lang.FieldOrMethod(nil, "MILLISECONDS") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "MILLISECONDS"))) - } - var tmp20 any - switch reflect.TypeOf(tmp19).Kind() { - case reflect.Func: - tmp20 = lang.Apply(tmp19, nil) - default: - tmp20 = tmp19 - } - tmp21, _ := lang.FieldOrMethod(v13, "await") - if reflect.TypeOf(tmp21).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) - } - tmp22 := lang.Apply(tmp21, []any{v3, tmp20}) - tmp12 = tmp22 - } // end let - tmp5 = tmp12 - } - return tmp5 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // await1 - { - tmp0 := lang.NewSymbol("await1").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3284), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3284), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("pos?")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8, ok := lang.FieldOrMethod(v3, "getQueueCount") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getQueueCount"))) - } - var tmp9 any - switch reflect.TypeOf(tmp8).Kind() { - case reflect.Func: - tmp9 = lang.Apply(tmp8, nil) - default: - tmp9 = tmp8 - } - tmp10 := lang.Apply(tmp7, []any{tmp9}) - if lang.IsTruthy(tmp10) { - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("await")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{v3}) - tmp4 = tmp14 - } else { - } - _ = tmp4 - return v3 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // bases - { - tmp0 := lang.NewSymbol("bases").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"))), lang.NewKeyword("doc"), "Returns the immediate superclass and direct interfaces of c, if any", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5522), lang.NewKeyword("end-line"), int(5522))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - if lang.IsTruthy(v3) { - var tmp5 any - { // let - // let binding "i" - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("seq")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(tmp8, []any{nil}) - var v10 any = tmp9 - _ = v10 - // let binding "s" - var v11 any = nil - _ = v11 - var tmp12 any - if lang.IsTruthy(v11) { - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("cons")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{v11, v10}) - tmp12 = tmp16 - } else { - tmp12 = v10 - } - tmp5 = tmp12 - } // end let - tmp4 = tmp5 - } else { - } - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // bigdec - { - tmp1 := reflect.TypeOf((*lang.BigDecimal)(nil)) - tmp0 := lang.NewSymbol("bigdec").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Coerce to BigDecimal", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3648), lang.NewKeyword("end-line"), int(3648))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - var tmp5 any - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("decimal?")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(tmp8, []any{v4}) - if lang.IsTruthy(tmp9) { - tmp5 = v4 - } else { - var tmp10 any - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("float?")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{v4}) - if lang.IsTruthy(tmp14) { - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("double")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{v4}) - tmp19 := lang.Apply(lang.NewBigDecimalFromFloat64, []any{tmp18}) - tmp10 = tmp19 - } else { - var tmp20 any - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("ratio?")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.Apply(tmp23, []any{v4}) - if lang.IsTruthy(tmp24) { - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("/")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.Apply(lang.NewBigDecimalFromRatio, []any{v4}) - tmp29, ok := lang.FieldOrMethod(v4, "denominator") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "denominator"))) - } - var tmp30 any - switch reflect.TypeOf(tmp29).Kind() { - case reflect.Func: - tmp30 = lang.Apply(tmp29, nil) - default: - tmp30 = tmp29 - } - tmp31 := lang.Apply(tmp27, []any{tmp28, tmp30}) - tmp20 = tmp31 - } else { - var tmp32 any - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("instance?")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := reflect.TypeOf((*lang.BigInt)(nil)) - tmp37 := lang.Apply(tmp35, []any{tmp36, v4}) - if lang.IsTruthy(tmp37) { - tmp38, ok := lang.FieldOrMethod(v4, "toBigDecimal") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "toBigDecimal"))) - } - var tmp39 any - switch reflect.TypeOf(tmp38).Kind() { - case reflect.Func: - tmp39 = lang.Apply(tmp38, nil) - default: - tmp39 = tmp38 - } - tmp32 = tmp39 - } else { - var tmp40 any - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("instance?")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := reflect.TypeOf((*big6.Int)(nil)) - tmp45 := lang.Apply(tmp43, []any{tmp44, v4}) - if lang.IsTruthy(tmp45) { - tmp46 := lang.Apply(lang.NewBigDecimal, []any{v4}) - tmp40 = tmp46 - } else { - var tmp47 any - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("number?")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v4}) - if lang.IsTruthy(tmp51) { - tmp52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp53 := tmp52.FindInternedVar(lang.NewSymbol("long")) - if tmp53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp53))) - } - tmp54 := tmp53.Get() - tmp55 := lang.Apply(tmp54, []any{v4}) - tmp56 := lang.Apply(lang.NewBigDecimalFromInt64, []any{tmp55}) - tmp47 = tmp56 - } else { - var tmp57 any - if lang.IsTruthy(lang.NewKeyword("else")) { - tmp58 := lang.Apply(lang.NewBigDecimal, []any{v4}) - tmp57 = tmp58 - } else { - } - tmp47 = tmp57 - } - tmp40 = tmp47 - } - tmp32 = tmp40 - } - tmp20 = tmp32 - } - tmp10 = tmp20 - } - tmp5 = tmp10 - } - return tmp5 - }) - tmp4 := reflect.TypeOf((*lang.BigDecimal)(nil)) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // bigint - { - tmp1 := reflect.TypeOf((*lang.BigInt)(nil)) - tmp0 := lang.NewSymbol("bigint").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Coerce to BigInt", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3620), lang.NewKeyword("end-line"), int(3620))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - var tmp5 any - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("instance?")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := reflect.TypeOf((*lang.BigInt)(nil)) - tmp10 := lang.Apply(tmp8, []any{tmp9, v4}) - if lang.IsTruthy(tmp10) { - tmp5 = v4 - } else { - var tmp11 any - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("instance?")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := reflect.TypeOf((*big6.Int)(nil)) - tmp16 := lang.Apply(tmp14, []any{tmp15, v4}) - if lang.IsTruthy(tmp16) { - tmp17 := lang.Apply(lang.NewBigIntFromGoBigInt, []any{v4}) - tmp11 = tmp17 - } else { - var tmp18 any - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("decimal?")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, []any{v4}) - if lang.IsTruthy(tmp22) { - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("bigint")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26, ok := lang.FieldOrMethod(v4, "toBigInteger") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "toBigInteger"))) - } - var tmp27 any - switch reflect.TypeOf(tmp26).Kind() { - case reflect.Func: - tmp27 = lang.Apply(tmp26, nil) - default: - tmp27 = tmp26 - } - tmp28 := lang.Apply(tmp25, []any{tmp27}) - tmp18 = tmp28 - } else { - var tmp29 any - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("float?")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.Apply(tmp32, []any{v4}) - if lang.IsTruthy(tmp33) { - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("bigint")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("double")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.Apply(tmp39, []any{v4}) - tmp41 := lang.Apply(lang.NewBigDecimalFromFloat64, []any{tmp40}) - tmp42 := lang.Apply(tmp36, []any{tmp41}) - tmp29 = tmp42 - } else { - var tmp43 any - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("ratio?")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.Apply(tmp46, []any{v4}) - if lang.IsTruthy(tmp47) { - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("bigint")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51, ok := lang.FieldOrMethod(v4, "bigIntegerValue") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "bigIntegerValue"))) - } - var tmp52 any - switch reflect.TypeOf(tmp51).Kind() { - case reflect.Func: - tmp52 = lang.Apply(tmp51, nil) - default: - tmp52 = tmp51 - } - tmp53 := lang.Apply(tmp50, []any{tmp52}) - tmp43 = tmp53 - } else { - var tmp54 any - tmp55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp56 := tmp55.FindInternedVar(lang.NewSymbol("number?")) - if tmp56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp56))) - } - tmp57 := tmp56.Get() - tmp58 := lang.Apply(tmp57, []any{v4}) - if lang.IsTruthy(tmp58) { - tmp59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp60 := tmp59.FindInternedVar(lang.NewSymbol("long")) - if tmp60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp60))) - } - tmp61 := tmp60.Get() - tmp62 := lang.Apply(tmp61, []any{v4}) - tmp63 := lang.Apply(lang.NewBigIntFromInt64, []any{tmp62}) - tmp54 = tmp63 - } else { - var tmp64 any - if lang.IsTruthy(lang.NewKeyword("else")) { - tmp65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp66 := tmp65.FindInternedVar(lang.NewSymbol("bigint")) - if tmp66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp66))) - } - tmp67 := tmp66.Get() - tmp68 := lang.Apply(lang.NewBigInt, []any{v4}) - tmp69 := lang.Apply(tmp67, []any{tmp68}) - tmp64 = tmp69 - } else { - } - tmp54 = tmp64 - } - tmp43 = tmp54 - } - tmp29 = tmp43 - } - tmp18 = tmp29 - } - tmp11 = tmp18 - } - tmp5 = tmp11 - } - return tmp5 - }) - tmp4 := reflect.TypeOf((*lang.BigInt)(nil)) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // biginteger - { - tmp1 := reflect.TypeOf((*big6.Int)(nil)) - tmp0 := lang.NewSymbol("biginteger").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Coerce to BigInteger", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3634), lang.NewKeyword("end-line"), int(3634))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - var tmp5 any - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("instance?")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := reflect.TypeOf((*big6.Int)(nil)) - tmp10 := lang.Apply(tmp8, []any{tmp9, v4}) - if lang.IsTruthy(tmp10) { - tmp5 = v4 - } else { - var tmp11 any - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("instance?")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := reflect.TypeOf((*lang.BigInt)(nil)) - tmp16 := lang.Apply(tmp14, []any{tmp15, v4}) - if lang.IsTruthy(tmp16) { - tmp17, ok := lang.FieldOrMethod(v4, "toBigInteger") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "toBigInteger"))) - } - var tmp18 any - switch reflect.TypeOf(tmp17).Kind() { - case reflect.Func: - tmp18 = lang.Apply(tmp17, nil) - default: - tmp18 = tmp17 - } - tmp11 = tmp18 - } else { - var tmp19 any - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("decimal?")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.Apply(tmp22, []any{v4}) - if lang.IsTruthy(tmp23) { - tmp24, ok := lang.FieldOrMethod(v4, "toBigInteger") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "toBigInteger"))) - } - var tmp25 any - switch reflect.TypeOf(tmp24).Kind() { - case reflect.Func: - tmp25 = lang.Apply(tmp24, nil) - default: - tmp25 = tmp24 - } - tmp19 = tmp25 - } else { - var tmp26 any - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("float?")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{v4}) - if lang.IsTruthy(tmp30) { - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("double")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{v4}) - tmp35 := lang.Apply(lang.NewBigDecimalFromFloat64, []any{tmp34}) - tmp36, ok := lang.FieldOrMethod(tmp35, "toBigInteger") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp35, "toBigInteger"))) - } - var tmp37 any - switch reflect.TypeOf(tmp36).Kind() { - case reflect.Func: - tmp37 = lang.Apply(tmp36, nil) - default: - tmp37 = tmp36 - } - tmp26 = tmp37 - } else { - var tmp38 any - tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp40 := tmp39.FindInternedVar(lang.NewSymbol("ratio?")) - if tmp40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) - } - tmp41 := tmp40.Get() - tmp42 := lang.Apply(tmp41, []any{v4}) - if lang.IsTruthy(tmp42) { - tmp43, ok := lang.FieldOrMethod(v4, "bigIntegerValue") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "bigIntegerValue"))) - } - var tmp44 any - switch reflect.TypeOf(tmp43).Kind() { - case reflect.Func: - tmp44 = lang.Apply(tmp43, nil) - default: - tmp44 = tmp43 - } - tmp38 = tmp44 - } else { - var tmp45 any - tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp47 := tmp46.FindInternedVar(lang.NewSymbol("number?")) - if tmp47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) - } - tmp48 := tmp47.Get() - tmp49 := lang.Apply(tmp48, []any{v4}) - if lang.IsTruthy(tmp49) { - tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp51 := tmp50.FindInternedVar(lang.NewSymbol("long")) - if tmp51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) - } - tmp52 := tmp51.Get() - tmp53 := lang.Apply(tmp52, []any{v4}) - tmp54 := lang.Apply(big6.NewInt, []any{tmp53}) - tmp45 = tmp54 - } else { - var tmp55 any - if lang.IsTruthy(lang.NewKeyword("else")) { - tmp56 := lang.Apply(lang.NewBigInt, []any{v4}) - tmp55 = tmp56 - } else { - } - tmp45 = tmp55 - } - tmp38 = tmp45 - } - tmp26 = tmp38 - } - tmp19 = tmp26 - } - tmp11 = tmp19 - } - tmp5 = tmp11 - } - return tmp5 - }) - tmp4 := reflect.TypeOf((*big6.Int)(nil)) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // binding - { - tmp0 := lang.NewSymbol("binding").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "binding => var-symbol init-expr\n\n Creates new bindings for the (already-existing) vars, with the\n supplied initial values, executes the exprs in an implicit do, then\n re-establishes the bindings that existed before. The new bindings\n are made in parallel (unlike let); all init-exprs are evaluated\n before the vars are bound to their new values.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1945), lang.NewKeyword("end-line"), int(1945))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("vector?")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v5}) - if lang.IsTruthy(tmp11) { - } else { - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("str")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("first")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{v3}) - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("*ns*")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("meta")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.Apply(tmp24, []any{v3}) - tmp26 := lang.Apply(lang.NewKeyword("line"), []any{tmp25}) - tmp27 := lang.Apply(tmp14, []any{tmp18, " requires ", "a vector for its binding", " in ", tmp21, ":", tmp26}) - tmp28 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp27}) - panic(tmp28) - } - _ = tmp7 - var tmp29 any - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("even?")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("count")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.Apply(tmp35, []any{v5}) - tmp37 := lang.Apply(tmp32, []any{tmp36}) - if lang.IsTruthy(tmp37) { - } else { - tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp39 := tmp38.FindInternedVar(lang.NewSymbol("str")) - if tmp39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) - } - tmp40 := tmp39.Get() - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("first")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.Apply(tmp43, []any{v3}) - tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp46 := tmp45.FindInternedVar(lang.NewSymbol("*ns*")) - if tmp46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) - } - tmp47 := tmp46.Get() - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("meta")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v3}) - tmp52 := lang.Apply(lang.NewKeyword("line"), []any{tmp51}) - tmp53 := lang.Apply(tmp40, []any{tmp44, " requires ", "an even number of forms in binding vector", " in ", tmp47, ":", tmp52}) - tmp54 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp53}) - panic(tmp54) - } - _ = tmp29 - var tmp55 any - { // let - // let binding "var-ize" - var tmp56 lang.FnFunc - tmp56 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v57 := args[0] - _ = v57 - var tmp58 any - { // let - // let binding "ret" - tmp59 := lang.NewVector() - tmp60 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1959), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(1959), lang.NewKeyword("end-column"), int(31)) - tmp61, err := lang.WithMeta(tmp59, tmp60.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v62 any = tmp61 - _ = v62 - // let binding "vvs" - tmp63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp64 := tmp63.FindInternedVar(lang.NewSymbol("seq")) - if tmp64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp64))) - } - tmp65 := tmp64.Get() - tmp66 := lang.Apply(tmp65, []any{v57}) - var v67 any = tmp66 - _ = v67 - for { - var tmp68 any - if lang.IsTruthy(v67) { - tmp70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp71 := tmp70.FindInternedVar(lang.NewSymbol("conj")) - if tmp71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp71))) - } - tmp72 := tmp71.Get() - tmp73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp74 := tmp73.FindInternedVar(lang.NewSymbol("conj")) - if tmp74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp74))) - } - tmp75 := tmp74.Get() - tmp76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp77 := tmp76.FindInternedVar(lang.NewSymbol("seq")) - if tmp77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp77))) - } - tmp78 := tmp77.Get() - tmp79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp80 := tmp79.FindInternedVar(lang.NewSymbol("concat")) - if tmp80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp80))) - } - tmp81 := tmp80.Get() - tmp82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp83 := tmp82.FindInternedVar(lang.NewSymbol("list")) - if tmp83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp83))) - } - tmp84 := tmp83.Get() - tmp85 := lang.Apply(tmp84, []any{lang.NewSymbol("var")}) - tmp86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp87 := tmp86.FindInternedVar(lang.NewSymbol("list")) - if tmp87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp87))) - } - tmp88 := tmp87.Get() - tmp89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp90 := tmp89.FindInternedVar(lang.NewSymbol("first")) - if tmp90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp90))) - } - tmp91 := tmp90.Get() - tmp92 := lang.Apply(tmp91, []any{v67}) - tmp93 := lang.Apply(tmp88, []any{tmp92}) - tmp94 := lang.Apply(tmp81, []any{tmp85, tmp93}) - tmp95 := lang.Apply(tmp78, []any{tmp94}) - tmp96 := lang.Apply(tmp75, []any{v62, tmp95}) - tmp97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp98 := tmp97.FindInternedVar(lang.NewSymbol("second")) - if tmp98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp98))) - } - tmp99 := tmp98.Get() - tmp100 := lang.Apply(tmp99, []any{v67}) - tmp101 := lang.Apply(tmp72, []any{tmp96, tmp100}) - var tmp69 any = tmp101 - tmp103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp104 := tmp103.FindInternedVar(lang.NewSymbol("next")) - if tmp104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp104))) - } - tmp105 := tmp104.Get() - tmp106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp107 := tmp106.FindInternedVar(lang.NewSymbol("next")) - if tmp107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp107))) - } - tmp108 := tmp107.Get() - tmp109 := lang.Apply(tmp108, []any{v67}) - tmp110 := lang.Apply(tmp105, []any{tmp109}) - var tmp102 any = tmp110 - v62 = tmp69 - v67 = tmp102 - continue - } else { - tmp111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp112 := tmp111.FindInternedVar(lang.NewSymbol("seq")) - if tmp112.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp112))) - } - tmp113 := tmp112.Get() - tmp114 := lang.Apply(tmp113, []any{v62}) - tmp68 = tmp114 - } - tmp58 = tmp68 - break - } - } // end let - return tmp58 - }) - tmp57 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1958), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(1963), lang.NewKeyword("end-column"), int(34)) - tmp58, err := lang.WithMeta(tmp56, tmp57.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v59 any = tmp58 - _ = v59 - tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp61 := tmp60.FindInternedVar(lang.NewSymbol("seq")) - if tmp61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) - } - tmp62 := tmp61.Get() - tmp63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp64 := tmp63.FindInternedVar(lang.NewSymbol("concat")) - if tmp64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp64))) - } - tmp65 := tmp64.Get() - tmp66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp67 := tmp66.FindInternedVar(lang.NewSymbol("list")) - if tmp67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp67))) - } - tmp68 := tmp67.Get() - tmp69 := lang.Apply(tmp68, []any{lang.NewSymbol("glojure.core/let")}) - tmp70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp71 := tmp70.FindInternedVar(lang.NewSymbol("list")) - if tmp71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp71))) - } - tmp72 := tmp71.Get() - tmp73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp74 := tmp73.FindInternedVar(lang.NewSymbol("apply")) - if tmp74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp74))) - } - tmp75 := tmp74.Get() - tmp76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp77 := tmp76.FindInternedVar(lang.NewSymbol("vector")) - if tmp77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp77))) - } - tmp78 := tmp77.Get() - tmp79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp80 := tmp79.FindInternedVar(lang.NewSymbol("seq")) - if tmp80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp80))) - } - tmp81 := tmp80.Get() - tmp82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp83 := tmp82.FindInternedVar(lang.NewSymbol("concat")) - if tmp83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp83))) - } - tmp84 := tmp83.Get() - tmp85 := lang.Apply(tmp84, nil) - tmp86 := lang.Apply(tmp81, []any{tmp85}) - tmp87 := lang.Apply(tmp75, []any{tmp78, tmp86}) - tmp88 := lang.Apply(tmp72, []any{tmp87}) - tmp89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp90 := tmp89.FindInternedVar(lang.NewSymbol("list")) - if tmp90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp90))) - } - tmp91 := tmp90.Get() - tmp92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp93 := tmp92.FindInternedVar(lang.NewSymbol("seq")) - if tmp93.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp93))) - } - tmp94 := tmp93.Get() - tmp95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp96 := tmp95.FindInternedVar(lang.NewSymbol("concat")) - if tmp96.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp96))) - } - tmp97 := tmp96.Get() - tmp98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp99 := tmp98.FindInternedVar(lang.NewSymbol("list")) - if tmp99.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp99))) - } - tmp100 := tmp99.Get() - tmp101 := lang.Apply(tmp100, []any{lang.NewSymbol("glojure.core/push-thread-bindings")}) - tmp102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp103 := tmp102.FindInternedVar(lang.NewSymbol("list")) - if tmp103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp103))) - } - tmp104 := tmp103.Get() - tmp105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp106 := tmp105.FindInternedVar(lang.NewSymbol("seq")) - if tmp106.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp106))) - } - tmp107 := tmp106.Get() - tmp108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp109 := tmp108.FindInternedVar(lang.NewSymbol("concat")) - if tmp109.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp109))) - } - tmp110 := tmp109.Get() - tmp111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp112 := tmp111.FindInternedVar(lang.NewSymbol("list")) - if tmp112.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp112))) - } - tmp113 := tmp112.Get() - tmp114 := lang.Apply(tmp113, []any{lang.NewSymbol("glojure.core/hash-map")}) - tmp115 := lang.Apply(v59, []any{v5}) - tmp116 := lang.Apply(tmp110, []any{tmp114, tmp115}) - tmp117 := lang.Apply(tmp107, []any{tmp116}) - tmp118 := lang.Apply(tmp104, []any{tmp117}) - tmp119 := lang.Apply(tmp97, []any{tmp101, tmp118}) - tmp120 := lang.Apply(tmp94, []any{tmp119}) - tmp121 := lang.Apply(tmp91, []any{tmp120}) - tmp122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp123 := tmp122.FindInternedVar(lang.NewSymbol("list")) - if tmp123.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp123))) - } - tmp124 := tmp123.Get() - tmp125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp126 := tmp125.FindInternedVar(lang.NewSymbol("seq")) - if tmp126.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp126))) - } - tmp127 := tmp126.Get() - tmp128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp129 := tmp128.FindInternedVar(lang.NewSymbol("concat")) - if tmp129.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp129))) - } - tmp130 := tmp129.Get() - tmp131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp132 := tmp131.FindInternedVar(lang.NewSymbol("list")) - if tmp132.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp132))) - } - tmp133 := tmp132.Get() - tmp134 := lang.Apply(tmp133, []any{lang.NewSymbol("try")}) - tmp135 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp136 := tmp135.FindInternedVar(lang.NewSymbol("list")) - if tmp136.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp136))) - } - tmp137 := tmp136.Get() - tmp138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp139 := tmp138.FindInternedVar(lang.NewSymbol("seq")) - if tmp139.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp139))) - } - tmp140 := tmp139.Get() - tmp141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp142 := tmp141.FindInternedVar(lang.NewSymbol("concat")) - if tmp142.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp142))) - } - tmp143 := tmp142.Get() - tmp144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp145 := tmp144.FindInternedVar(lang.NewSymbol("list")) - if tmp145.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp145))) - } - tmp146 := tmp145.Get() - tmp147 := lang.Apply(tmp146, []any{lang.NewSymbol("finally")}) - tmp148 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp149 := tmp148.FindInternedVar(lang.NewSymbol("list")) - if tmp149.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp149))) - } - tmp150 := tmp149.Get() - tmp151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp152 := tmp151.FindInternedVar(lang.NewSymbol("seq")) - if tmp152.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp152))) - } - tmp153 := tmp152.Get() - tmp154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp155 := tmp154.FindInternedVar(lang.NewSymbol("concat")) - if tmp155.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp155))) - } - tmp156 := tmp155.Get() - tmp157 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp158 := tmp157.FindInternedVar(lang.NewSymbol("list")) - if tmp158.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp158))) - } - tmp159 := tmp158.Get() - tmp160 := lang.Apply(tmp159, []any{lang.NewSymbol("glojure.core/pop-thread-bindings")}) - tmp161 := lang.Apply(tmp156, []any{tmp160}) - tmp162 := lang.Apply(tmp153, []any{tmp161}) - tmp163 := lang.Apply(tmp150, []any{tmp162}) - tmp164 := lang.Apply(tmp143, []any{tmp147, tmp163}) - tmp165 := lang.Apply(tmp140, []any{tmp164}) - tmp166 := lang.Apply(tmp137, []any{tmp165}) - tmp167 := lang.Apply(tmp130, []any{tmp134, v6, tmp166}) - tmp168 := lang.Apply(tmp127, []any{tmp167}) - tmp169 := lang.Apply(tmp124, []any{tmp168}) - tmp170 := lang.Apply(tmp65, []any{tmp69, tmp88, tmp121, tmp169}) - tmp171 := lang.Apply(tmp62, []any{tmp170}) - tmp55 = tmp171 - } // end let - return tmp55 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // binding-conveyor-fn - { - tmp0 := lang.NewSymbol("binding-conveyor-fn").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2020), lang.NewKeyword("end-line"), int(2020), lang.NewKeyword("private"), true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "frame" - tmp5 := lang.Apply(lang.CloneThreadBindingFrame, nil) - var v6 any = tmp5 - _ = v6 - var tmp7 lang.FnFunc - tmp7 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp8 := lang.Apply(lang.ResetThreadBindingFrame, []any{v6}) - _ = tmp8 - tmp9 := lang.Apply(v3, nil) - return tmp9 - case 1: - v8 := args[0] - _ = v8 - tmp9 := lang.Apply(lang.ResetThreadBindingFrame, []any{v6}) - _ = tmp9 - tmp10 := lang.Apply(v3, []any{v8}) - return tmp10 - case 2: - v8 := args[0] - _ = v8 - v9 := args[1] - _ = v9 - tmp10 := lang.Apply(lang.ResetThreadBindingFrame, []any{v6}) - _ = tmp10 - tmp11 := lang.Apply(v3, []any{v8, v9}) - return tmp11 - case 3: - v8 := args[0] - _ = v8 - v9 := args[1] - _ = v9 - v10 := args[2] - _ = v10 - tmp11 := lang.Apply(lang.ResetThreadBindingFrame, []any{v6}) - _ = tmp11 - tmp12 := lang.Apply(v3, []any{v8, v9, v10}) - return tmp12 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v8 := args[0] - _ = v8 - v9 := args[1] - _ = v9 - v10 := args[2] - _ = v10 - var v11 any = lang.NewList(args[3:]...) - _ = v11 - tmp12 := lang.Apply(lang.ResetThreadBindingFrame, []any{v6}) - _ = tmp12 - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("apply")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{v3, v8, v9, v10, v11}) - return tmp16 - } - }) - tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2025), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2040), lang.NewKeyword("end-column"), int(31)) - tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp4 = tmp9 - } // end let - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // bit-and - { - var tmp1 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v2 := args[0] - _ = v2 - var tmp3 any - { // let - // let binding "op" - var tmp4 any - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - if lang.IsTruthy(tmp7) { - tmp4 = closed10 - } else { - tmp4 = closed10 - } - var v8 any = tmp4 - _ = v8 - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("seq")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("concat")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol(".")}) - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("seq")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("concat")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.Apply(tmp34, []any{v8}) - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{v2}) - tmp40 := lang.Apply(tmp31, []any{tmp35, tmp39}) - tmp41 := lang.Apply(tmp28, []any{tmp40}) - tmp42 := lang.Apply(tmp25, []any{tmp41}) - tmp43 := lang.Apply(tmp14, []any{tmp18, tmp22, tmp42}) - tmp44 := lang.Apply(tmp11, []any{tmp43}) - tmp3 = tmp44 - } // end let - return tmp3 - case 2: - v2 := args[0] - _ = v2 - v3 := args[1] - _ = v3 - var tmp4 any - { // let - // let binding "op" - var tmp5 any - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - if lang.IsTruthy(tmp8) { - tmp5 = closed10 - } else { - tmp5 = closed10 - } - var v9 any = tmp5 - _ = v9 - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("seq")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("concat")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("list")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{lang.NewSymbol(".")}) - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("list")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.Apply(tmp22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("list")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("seq")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("concat")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("list")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.Apply(tmp35, []any{v9}) - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("list")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.Apply(tmp39, []any{v2}) - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("list")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.Apply(tmp43, []any{v3}) - tmp45 := lang.Apply(tmp32, []any{tmp36, tmp40, tmp44}) - tmp46 := lang.Apply(tmp29, []any{tmp45}) - tmp47 := lang.Apply(tmp26, []any{tmp46}) - tmp48 := lang.Apply(tmp15, []any{tmp19, tmp23, tmp47}) - tmp49 := lang.Apply(tmp12, []any{tmp48}) - tmp4 = tmp49 - } // end let - return tmp4 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v2 := args[0] - _ = v2 - v3 := args[1] - _ = v3 - var v4 any = lang.NewList(args[2:]...) - _ = v4 - var tmp5 any - { // let - // let binding "op" - var tmp6 any - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - if lang.IsTruthy(tmp9) { - tmp6 = closed10 - } else { - tmp6 = closed10 - } - var v10 any = tmp6 - _ = v10 - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - var tmp14 lang.FnFunc - tmp14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v15 := args[0] - _ = v15 - v16 := args[1] - _ = v16 - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("concat")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol(".")}) - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.Apply(tmp42, []any{v10}) - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.Apply(tmp46, []any{v15}) - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v16}) - tmp52 := lang.Apply(tmp39, []any{tmp43, tmp47, tmp51}) - tmp53 := lang.Apply(tmp36, []any{tmp52}) - tmp54 := lang.Apply(tmp33, []any{tmp53}) - tmp55 := lang.Apply(tmp22, []any{tmp26, tmp30, tmp54}) - tmp56 := lang.Apply(tmp19, []any{tmp55}) - return tmp56 - }) - tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) - tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("concat")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol(".")}) - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.Apply(tmp42, []any{v10}) - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.Apply(tmp46, []any{v2}) - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v3}) - tmp52 := lang.Apply(tmp39, []any{tmp43, tmp47, tmp51}) - tmp53 := lang.Apply(tmp36, []any{tmp52}) - tmp54 := lang.Apply(tmp33, []any{tmp53}) - tmp55 := lang.Apply(tmp22, []any{tmp26, tmp30, tmp54}) - tmp56 := lang.Apply(tmp19, []any{tmp55}) - tmp57 := lang.Apply(tmp13, []any{tmp16, tmp56, v4}) - tmp5 = tmp57 - } // end let - return tmp5 - } - }) - tmp1 = tmp1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) - } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp0 := lang.NewSymbol("bit-and").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Bitwise and", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), tmp2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1298), lang.NewKeyword("end-line"), int(1298))).(*lang.Symbol) - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - tmp7, _ := lang.FieldOrMethod(lang.Numbers, "And") - if reflect.TypeOf(tmp7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("And is not a function"))) - } - tmp8 := lang.Apply(tmp7, []any{v5, v6}) - return tmp8 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - var v7 any = lang.NewList(args[2:]...) - _ = v7 - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("bit-and")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("bit-and")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{v5, v6}) - tmp18 := lang.Apply(tmp10, []any{tmp13, tmp17, v7}) - return tmp18 - } - }) - tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp3 := ns.InternWithValue(tmp0, tmp4, true) - if tmp0.Meta() != nil { - tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // bit-and-not - { - var tmp1 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v2 := args[0] - _ = v2 - var tmp3 any - { // let - // let binding "op" - var tmp4 any - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - if lang.IsTruthy(tmp7) { - tmp4 = closed11 - } else { - tmp4 = closed11 - } - var v8 any = tmp4 - _ = v8 - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("seq")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("concat")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol(".")}) - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("seq")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("concat")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.Apply(tmp34, []any{v8}) - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{v2}) - tmp40 := lang.Apply(tmp31, []any{tmp35, tmp39}) - tmp41 := lang.Apply(tmp28, []any{tmp40}) - tmp42 := lang.Apply(tmp25, []any{tmp41}) - tmp43 := lang.Apply(tmp14, []any{tmp18, tmp22, tmp42}) - tmp44 := lang.Apply(tmp11, []any{tmp43}) - tmp3 = tmp44 - } // end let - return tmp3 - case 2: - v2 := args[0] - _ = v2 - v3 := args[1] - _ = v3 - var tmp4 any - { // let - // let binding "op" - var tmp5 any - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - if lang.IsTruthy(tmp8) { - tmp5 = closed11 - } else { - tmp5 = closed11 - } - var v9 any = tmp5 - _ = v9 - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("seq")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("concat")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("list")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{lang.NewSymbol(".")}) - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("list")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.Apply(tmp22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("list")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("seq")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("concat")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("list")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.Apply(tmp35, []any{v9}) - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("list")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.Apply(tmp39, []any{v2}) - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("list")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.Apply(tmp43, []any{v3}) - tmp45 := lang.Apply(tmp32, []any{tmp36, tmp40, tmp44}) - tmp46 := lang.Apply(tmp29, []any{tmp45}) - tmp47 := lang.Apply(tmp26, []any{tmp46}) - tmp48 := lang.Apply(tmp15, []any{tmp19, tmp23, tmp47}) - tmp49 := lang.Apply(tmp12, []any{tmp48}) - tmp4 = tmp49 - } // end let - return tmp4 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v2 := args[0] - _ = v2 - v3 := args[1] - _ = v3 - var v4 any = lang.NewList(args[2:]...) - _ = v4 - var tmp5 any - { // let - // let binding "op" - var tmp6 any - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - if lang.IsTruthy(tmp9) { - tmp6 = closed11 - } else { - tmp6 = closed11 - } - var v10 any = tmp6 - _ = v10 - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - var tmp14 lang.FnFunc - tmp14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v15 := args[0] - _ = v15 - v16 := args[1] - _ = v16 - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("concat")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol(".")}) - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.Apply(tmp42, []any{v10}) - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.Apply(tmp46, []any{v15}) - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v16}) - tmp52 := lang.Apply(tmp39, []any{tmp43, tmp47, tmp51}) - tmp53 := lang.Apply(tmp36, []any{tmp52}) - tmp54 := lang.Apply(tmp33, []any{tmp53}) - tmp55 := lang.Apply(tmp22, []any{tmp26, tmp30, tmp54}) - tmp56 := lang.Apply(tmp19, []any{tmp55}) - return tmp56 - }) - tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) - tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("concat")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol(".")}) - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.Apply(tmp42, []any{v10}) - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.Apply(tmp46, []any{v2}) - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v3}) - tmp52 := lang.Apply(tmp39, []any{tmp43, tmp47, tmp51}) - tmp53 := lang.Apply(tmp36, []any{tmp52}) - tmp54 := lang.Apply(tmp33, []any{tmp53}) - tmp55 := lang.Apply(tmp22, []any{tmp26, tmp30, tmp54}) - tmp56 := lang.Apply(tmp19, []any{tmp55}) - tmp57 := lang.Apply(tmp13, []any{tmp16, tmp56, v4}) - tmp5 = tmp57 - } // end let - return tmp5 - } - }) - tmp1 = tmp1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) - } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp0 := lang.NewSymbol("bit-and-not").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Bitwise and with complement", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), tmp2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1325), lang.NewKeyword("end-line"), int(1325))).(*lang.Symbol) - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - tmp7, _ := lang.FieldOrMethod(lang.Numbers, "AndNot") - if reflect.TypeOf(tmp7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("AndNot is not a function"))) - } - tmp8 := lang.Apply(tmp7, []any{v5, v6}) - return tmp8 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - var v7 any = lang.NewList(args[2:]...) - _ = v7 - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("bit-and-not")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("bit-and-not")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{v5, v6}) - tmp18 := lang.Apply(tmp10, []any{tmp13, tmp17, v7}) - return tmp18 - } - }) - tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp3 := ns.InternWithValue(tmp0, tmp4, true) - if tmp0.Meta() != nil { - tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // bit-clear - { - tmp0 := lang.NewSymbol("bit-clear").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Clear bit at index n", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1336), lang.NewKeyword("end-line"), int(1336))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "ClearBit") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ClearBit is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v3, v4}) - return tmp6 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // bit-flip - { - tmp0 := lang.NewSymbol("bit-flip").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Flip bit at index n", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1348), lang.NewKeyword("end-line"), int(1348))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "FlipBit") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("FlipBit is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v3, v4}) - return tmp6 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // bit-not - { - var tmp1 lang.FnFunc - { // function bit-not__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/Not")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{v3}) - tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) - tmp36 := lang.Apply(tmp23, []any{tmp35}) - tmp37 := lang.Apply(tmp20, []any{tmp36}) - tmp38 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp37}) - tmp39 := lang.Apply(tmp6, []any{tmp38}) - return tmp39 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("bit-not").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Bitwise complement", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1291), lang.NewKeyword("end-line"), int(1291))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Not") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Not is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // bit-or - { - var tmp1 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v2 := args[0] - _ = v2 - var tmp3 any - { // let - // let binding "op" - var tmp4 any - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - if lang.IsTruthy(tmp7) { - tmp4 = closed12 - } else { - tmp4 = closed12 - } - var v8 any = tmp4 - _ = v8 - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("seq")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("concat")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol(".")}) - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("seq")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("concat")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.Apply(tmp34, []any{v8}) - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{v2}) - tmp40 := lang.Apply(tmp31, []any{tmp35, tmp39}) - tmp41 := lang.Apply(tmp28, []any{tmp40}) - tmp42 := lang.Apply(tmp25, []any{tmp41}) - tmp43 := lang.Apply(tmp14, []any{tmp18, tmp22, tmp42}) - tmp44 := lang.Apply(tmp11, []any{tmp43}) - tmp3 = tmp44 - } // end let - return tmp3 - case 2: - v2 := args[0] - _ = v2 - v3 := args[1] - _ = v3 - var tmp4 any - { // let - // let binding "op" - var tmp5 any - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - if lang.IsTruthy(tmp8) { - tmp5 = closed12 - } else { - tmp5 = closed12 - } - var v9 any = tmp5 - _ = v9 - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("seq")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("concat")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("list")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{lang.NewSymbol(".")}) - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("list")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.Apply(tmp22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("list")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("seq")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("concat")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("list")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.Apply(tmp35, []any{v9}) - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("list")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.Apply(tmp39, []any{v2}) - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("list")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.Apply(tmp43, []any{v3}) - tmp45 := lang.Apply(tmp32, []any{tmp36, tmp40, tmp44}) - tmp46 := lang.Apply(tmp29, []any{tmp45}) - tmp47 := lang.Apply(tmp26, []any{tmp46}) - tmp48 := lang.Apply(tmp15, []any{tmp19, tmp23, tmp47}) - tmp49 := lang.Apply(tmp12, []any{tmp48}) - tmp4 = tmp49 - } // end let - return tmp4 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v2 := args[0] - _ = v2 - v3 := args[1] - _ = v3 - var v4 any = lang.NewList(args[2:]...) - _ = v4 - var tmp5 any - { // let - // let binding "op" - var tmp6 any - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - if lang.IsTruthy(tmp9) { - tmp6 = closed12 - } else { - tmp6 = closed12 - } - var v10 any = tmp6 - _ = v10 - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - var tmp14 lang.FnFunc - tmp14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v15 := args[0] - _ = v15 - v16 := args[1] - _ = v16 - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("concat")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol(".")}) - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.Apply(tmp42, []any{v10}) - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.Apply(tmp46, []any{v15}) - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v16}) - tmp52 := lang.Apply(tmp39, []any{tmp43, tmp47, tmp51}) - tmp53 := lang.Apply(tmp36, []any{tmp52}) - tmp54 := lang.Apply(tmp33, []any{tmp53}) - tmp55 := lang.Apply(tmp22, []any{tmp26, tmp30, tmp54}) - tmp56 := lang.Apply(tmp19, []any{tmp55}) - return tmp56 - }) - tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) - tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("concat")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol(".")}) - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.Apply(tmp42, []any{v10}) - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.Apply(tmp46, []any{v2}) - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v3}) - tmp52 := lang.Apply(tmp39, []any{tmp43, tmp47, tmp51}) - tmp53 := lang.Apply(tmp36, []any{tmp52}) - tmp54 := lang.Apply(tmp33, []any{tmp53}) - tmp55 := lang.Apply(tmp22, []any{tmp26, tmp30, tmp54}) - tmp56 := lang.Apply(tmp19, []any{tmp55}) - tmp57 := lang.Apply(tmp13, []any{tmp16, tmp56, v4}) - tmp5 = tmp57 - } // end let - return tmp5 - } - }) - tmp1 = tmp1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) - } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp0 := lang.NewSymbol("bit-or").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Bitwise or", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), tmp2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1307), lang.NewKeyword("end-line"), int(1307))).(*lang.Symbol) - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - tmp7, _ := lang.FieldOrMethod(lang.Numbers, "Or") - if reflect.TypeOf(tmp7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Or is not a function"))) - } - tmp8 := lang.Apply(tmp7, []any{v5, v6}) - return tmp8 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - var v7 any = lang.NewList(args[2:]...) - _ = v7 - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("bit-or")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("bit-or")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{v5, v6}) - tmp18 := lang.Apply(tmp10, []any{tmp13, tmp17, v7}) - return tmp18 - } - }) - tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp3 := ns.InternWithValue(tmp0, tmp4, true) - if tmp0.Meta() != nil { - tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // bit-set - { - tmp0 := lang.NewSymbol("bit-set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Set bit at index n", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1342), lang.NewKeyword("end-line"), int(1342))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "SetBit") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("SetBit is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v3, v4}) - return tmp6 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // bit-shift-left - { - var tmp1 lang.FnFunc - { // function bit-shift-left__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("concat")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("list")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol(".")}) - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("seq")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("concat")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("list")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.Apply(tmp30, []any{lang.NewSymbol("glojure.core/ShiftLeft")}) - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.Apply(tmp34, []any{v3}) - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{v4}) - tmp40 := lang.Apply(tmp27, []any{tmp31, tmp35, tmp39}) - tmp41 := lang.Apply(tmp24, []any{tmp40}) - tmp42 := lang.Apply(tmp21, []any{tmp41}) - tmp43 := lang.Apply(tmp10, []any{tmp14, tmp18, tmp42}) - tmp44 := lang.Apply(tmp7, []any{tmp43}) - return tmp44 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("bit-shift-left").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Bitwise shift left", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1361), lang.NewKeyword("end-line"), int(1361))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "ShiftLeft") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ShiftLeft is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // bit-shift-right - { - var tmp1 lang.FnFunc - { // function bit-shift-right__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("concat")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("list")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol(".")}) - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("seq")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("concat")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("list")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.Apply(tmp30, []any{lang.NewSymbol("glojure.core/ShiftRight")}) - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.Apply(tmp34, []any{v3}) - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{v4}) - tmp40 := lang.Apply(tmp27, []any{tmp31, tmp35, tmp39}) - tmp41 := lang.Apply(tmp24, []any{tmp40}) - tmp42 := lang.Apply(tmp21, []any{tmp41}) - tmp43 := lang.Apply(tmp10, []any{tmp14, tmp18, tmp42}) - tmp44 := lang.Apply(tmp7, []any{tmp43}) - return tmp44 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("bit-shift-right").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Bitwise shift right", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1367), lang.NewKeyword("end-line"), int(1367))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "ShiftRight") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ShiftRight is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // bit-test - { - tmp0 := lang.NewSymbol("bit-test").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Test bit at index n", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1354), lang.NewKeyword("end-line"), int(1354))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "TestBit") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("TestBit is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v3, v4}) - return tmp6 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // bit-xor - { - var tmp1 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v2 := args[0] - _ = v2 - var tmp3 any - { // let - // let binding "op" - var tmp4 any - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - if lang.IsTruthy(tmp7) { - tmp4 = closed13 - } else { - tmp4 = closed13 - } - var v8 any = tmp4 - _ = v8 - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("seq")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("concat")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol(".")}) - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("seq")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("concat")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.Apply(tmp34, []any{v8}) - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{v2}) - tmp40 := lang.Apply(tmp31, []any{tmp35, tmp39}) - tmp41 := lang.Apply(tmp28, []any{tmp40}) - tmp42 := lang.Apply(tmp25, []any{tmp41}) - tmp43 := lang.Apply(tmp14, []any{tmp18, tmp22, tmp42}) - tmp44 := lang.Apply(tmp11, []any{tmp43}) - tmp3 = tmp44 - } // end let - return tmp3 - case 2: - v2 := args[0] - _ = v2 - v3 := args[1] - _ = v3 - var tmp4 any - { // let - // let binding "op" - var tmp5 any - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - if lang.IsTruthy(tmp8) { - tmp5 = closed13 - } else { - tmp5 = closed13 - } - var v9 any = tmp5 - _ = v9 - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("seq")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("concat")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("list")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{lang.NewSymbol(".")}) - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("list")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.Apply(tmp22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("list")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("seq")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("concat")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("list")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.Apply(tmp35, []any{v9}) - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("list")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.Apply(tmp39, []any{v2}) - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("list")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.Apply(tmp43, []any{v3}) - tmp45 := lang.Apply(tmp32, []any{tmp36, tmp40, tmp44}) - tmp46 := lang.Apply(tmp29, []any{tmp45}) - tmp47 := lang.Apply(tmp26, []any{tmp46}) - tmp48 := lang.Apply(tmp15, []any{tmp19, tmp23, tmp47}) - tmp49 := lang.Apply(tmp12, []any{tmp48}) - tmp4 = tmp49 - } // end let - return tmp4 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v2 := args[0] - _ = v2 - v3 := args[1] - _ = v3 - var v4 any = lang.NewList(args[2:]...) - _ = v4 - var tmp5 any - { // let - // let binding "op" - var tmp6 any - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - if lang.IsTruthy(tmp9) { - tmp6 = closed13 - } else { - tmp6 = closed13 - } - var v10 any = tmp6 - _ = v10 - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - var tmp14 lang.FnFunc - tmp14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v15 := args[0] - _ = v15 - v16 := args[1] - _ = v16 - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("concat")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol(".")}) - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.Apply(tmp42, []any{v10}) - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.Apply(tmp46, []any{v15}) - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v16}) - tmp52 := lang.Apply(tmp39, []any{tmp43, tmp47, tmp51}) - tmp53 := lang.Apply(tmp36, []any{tmp52}) - tmp54 := lang.Apply(tmp33, []any{tmp53}) - tmp55 := lang.Apply(tmp22, []any{tmp26, tmp30, tmp54}) - tmp56 := lang.Apply(tmp19, []any{tmp55}) - return tmp56 - }) - tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) - tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("concat")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol(".")}) - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.Apply(tmp42, []any{v10}) - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.Apply(tmp46, []any{v2}) - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v3}) - tmp52 := lang.Apply(tmp39, []any{tmp43, tmp47, tmp51}) - tmp53 := lang.Apply(tmp36, []any{tmp52}) - tmp54 := lang.Apply(tmp33, []any{tmp53}) - tmp55 := lang.Apply(tmp22, []any{tmp26, tmp30, tmp54}) - tmp56 := lang.Apply(tmp19, []any{tmp55}) - tmp57 := lang.Apply(tmp13, []any{tmp16, tmp56, v4}) - tmp5 = tmp57 - } // end let - return tmp5 - } - }) - tmp1 = tmp1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) - } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp0 := lang.NewSymbol("bit-xor").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Bitwise exclusive or", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), tmp2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1316), lang.NewKeyword("end-line"), int(1316))).(*lang.Symbol) - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - tmp7, _ := lang.FieldOrMethod(lang.Numbers, "Xor") - if reflect.TypeOf(tmp7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Xor is not a function"))) - } - tmp8 := lang.Apply(tmp7, []any{v5, v6}) - return tmp8 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - var v7 any = lang.NewList(args[2:]...) - _ = v7 - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("bit-xor")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("bit-xor")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{v5, v6}) - tmp18 := lang.Apply(tmp10, []any{tmp13, tmp17, v7}) - return tmp18 - } - }) - tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp3 := ns.InternWithValue(tmp0, tmp4, true) - if tmp0.Meta() != nil { - tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // boolean - { - var tmp1 lang.FnFunc - { // function boolean__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/BooleanCast")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{v3}) - tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) - tmp36 := lang.Apply(tmp23, []any{tmp35}) - tmp37 := lang.Apply(tmp20, []any{tmp36}) - tmp38 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp37}) - tmp39 := lang.Apply(tmp6, []any{tmp38}) - return tmp39 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("boolean").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to boolean", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1601), lang.NewKeyword("end-line"), int(1601))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(runtime4.RT, "BooleanCast") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("BooleanCast is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // boolean-array - { - var tmp1 lang.FnFunc - { // function boolean-array__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var v3 any = lang.NewList(args[0:]...) - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.Apply(tmp20, []any{lang.NewSymbol("glojure.core/BooleanArray")}) - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("list")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("seq")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("concat")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) - tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp36 := tmp35.FindInternedVar(lang.NewSymbol("list")) - if tmp36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) - } - tmp37 := tmp36.Get() - tmp38 := lang.Apply(tmp37, []any{lang.NewSymbol("glojure.core/args")}) - tmp39 := lang.Apply(tmp30, []any{tmp34, tmp38}) - tmp40 := lang.Apply(tmp27, []any{tmp39}) - tmp41 := lang.Apply(tmp24, []any{tmp40}) - tmp42 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp21, tmp41}) - tmp43 := lang.Apply(tmp6, []any{tmp42}) - return tmp43 - } - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("boolean-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Creates an array of booleans", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5309), lang.NewKeyword("end-line"), int(5309))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "BooleanArray") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("BooleanArray is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - case 2: - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "BooleanArrayInit") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("BooleanArrayInit is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // boolean? - { - tmp0 := lang.NewSymbol("boolean?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a Boolean", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(518), lang.NewKeyword("end-line"), int(518))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.Apply(tmp6, []any{lang.Builtins["bool"], v3}) - return tmp7 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // booleans - { - var tmp1 lang.FnFunc - { // function booleans - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.Apply(tmp20, []any{lang.NewSymbol("glojure.core/Booleans")}) - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("list")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.Apply(tmp24, []any{v3}) - tmp26 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp21, tmp25}) - tmp27 := lang.Apply(tmp6, []any{tmp26}) - return tmp27 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("booleans").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Casts to boolean[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5372), lang.NewKeyword("end-line"), int(5372))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Booleans") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Booleans is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // bound-fn - { - tmp0 := lang.NewSymbol("bound-fn").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("fntail"))), lang.NewKeyword("doc"), "Returns a function defined by the given fntail, which will install the\n same bindings in effect as in the thread at the time bound-fn was called.\n This may be used to define a helper function which runs on a different\n thread, but needs the same bindings in place.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(2004), lang.NewKeyword("end-line"), int(2004))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("seq")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("concat")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("list")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("glojure.core/bound-fn*")}) - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("list")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("seq")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("concat")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("list")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.Apply(tmp27, []any{lang.NewSymbol("glojure.core/fn")}) - tmp29 := lang.Apply(tmp24, []any{tmp28, v5}) - tmp30 := lang.Apply(tmp21, []any{tmp29}) - tmp31 := lang.Apply(tmp18, []any{tmp30}) - tmp32 := lang.Apply(tmp11, []any{tmp15, tmp31}) - tmp33 := lang.Apply(tmp8, []any{tmp32}) - return tmp33 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // bound-fn* - { - tmp0 := lang.NewSymbol("bound-fn*").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Returns a function, which will install the same bindings in effect as in\n the thread at the time bound-fn* was called and then call f with any given\n arguments. This may be used to define a helper function which runs on a\n different thread, but needs the same bindings in place.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1992), lang.NewKeyword("end-line"), int(1992))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "bindings" - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("get-thread-bindings")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, nil) - var v9 any = tmp8 - _ = v9 - var tmp10 lang.FnFunc - tmp10 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var v11 any = lang.NewList(args[0:]...) - _ = v11 - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("apply")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("with-bindings*")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp14, []any{tmp17, v9, v3, v11}) - return tmp18 - } - }) - tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2001), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2002), lang.NewKeyword("end-column"), int(45)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp4 = tmp12 - } // end let - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // bound? - { - tmp0 := lang.NewSymbol("bound?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("vars"))), lang.NewKeyword("doc"), "Returns true if all of the vars provided as arguments have any bound value, root or thread-local.\n Implies that deref'ing the provided vars will succeed. Returns true if no vars are provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5491), lang.NewKeyword("end-line"), int(5491))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var v3 any = lang.NewList(args[0:]...) - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("every?")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - var tmp7 lang.FnFunc - tmp7 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v8 := args[0] - _ = v8 - tmp9, ok := lang.FieldOrMethod(v8, "isBound") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "isBound"))) - } - var tmp10 any - switch reflect.TypeOf(tmp9).Kind() { - case reflect.Func: - tmp10 = lang.Apply(tmp9, nil) - default: - tmp10 = tmp9 - } - return tmp10 - }) - tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5497), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5497), lang.NewKeyword("end-column"), int(69)) - tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp10 := lang.Apply(tmp6, []any{tmp9, v3}) - return tmp10 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // bounded-count - { - tmp0 := lang.NewSymbol("bounded-count").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "If coll is counted? returns its count, else will count at most the first n\n elements of coll using its seq", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7410), lang.NewKeyword("end-line"), int(7410))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("counted?")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(tmp8, []any{v4}) - if lang.IsTruthy(tmp9) { - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("count")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{v4}) - tmp5 = tmp13 - } else { - var tmp14 any - { // let - // let binding "i" - var v15 any = int64(0) - _ = v15 - // let binding "s" - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("seq")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{v4}) - var v20 any = tmp19 - _ = v20 - for { - var tmp21 any - var tmp22 any - { // let - // let binding "and__0__auto__" - var v23 any = v20 - _ = v23 - var tmp24 any - if lang.IsTruthy(v23) { - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("<")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.Apply(tmp27, []any{v15, v3}) - tmp24 = tmp28 - } else { - tmp24 = v23 - } - tmp22 = tmp24 - } // end let - if lang.IsTruthy(tmp22) { - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("inc")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.Apply(tmp26, []any{v15}) - var tmp23 any = tmp27 - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("next")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.Apply(tmp31, []any{v20}) - var tmp28 any = tmp32 - v15 = tmp23 - v20 = tmp28 - continue - } else { - tmp21 = v15 - } - tmp14 = tmp21 - break - } - } // end let - tmp5 = tmp14 - } - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // butlast - { - tmp0 := lang.NewSymbol("butlast").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return a seq of all but the last item in coll, in linear time", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(272), lang.NewKeyword("end-line"), int(276))).(*lang.Symbol) - var tmp2 lang.FnFunc - { // function butlast - var v3 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - var tmp5 any - { // let - // let binding "ret" - tmp6 := lang.NewVector() - tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(277), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(277), lang.NewKeyword("end-column"), int(24)) - tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v9 any = tmp8 - _ = v9 - // let binding "s" - var v10 any = v4 - _ = v10 - for { - var tmp11 any - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("next")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.Apply(tmp14, []any{v10}) - if lang.IsTruthy(tmp15) { - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("conj")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("first")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.Apply(tmp22, []any{v10}) - tmp24 := lang.Apply(tmp19, []any{v9, tmp23}) - var tmp16 any = tmp24 - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("next")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.Apply(tmp28, []any{v10}) - var tmp25 any = tmp29 - v9 = tmp16 - v10 = tmp25 - continue - } else { - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("seq")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.Apply(tmp32, []any{v9}) - tmp11 = tmp33 - } - tmp5 = tmp11 - break - } - } // end let - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(276), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(280), lang.NewKeyword("end-column"), int(27))).(lang.FnFunc) - v3 = tmp2 - _ = v3 - } - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // byte - { - var tmp1 lang.FnFunc - { // function byte__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - var tmp30 any - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - if lang.IsTruthy(tmp33) { - tmp30 = lang.NewSymbol("uncheckedByteCast") - } else { - tmp30 = lang.NewSymbol("byteCast") - } - tmp34 := lang.Apply(tmp29, []any{tmp30}) - tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp36 := tmp35.FindInternedVar(lang.NewSymbol("list")) - if tmp36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) - } - tmp37 := tmp36.Get() - tmp38 := lang.Apply(tmp37, []any{v3}) - tmp39 := lang.Apply(tmp26, []any{tmp34, tmp38}) - tmp40 := lang.Apply(tmp23, []any{tmp39}) - tmp41 := lang.Apply(tmp20, []any{tmp40}) - tmp42 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp41}) - tmp43 := lang.Apply(tmp6, []any{tmp42}) - return tmp43 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("byte").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to byte", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3505), lang.NewKeyword("end-line"), int(3505))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5 := lang.Apply(lang.ByteCast, []any{v4}) - return tmp5 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // byte-array - { - var tmp1 lang.FnFunc - { // function byte-array__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var v3 any = lang.NewList(args[0:]...) - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.Apply(tmp20, []any{lang.NewSymbol("glojure.core/ByteArray")}) - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("list")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("seq")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("concat")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) - tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp36 := tmp35.FindInternedVar(lang.NewSymbol("list")) - if tmp36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) - } - tmp37 := tmp36.Get() - tmp38 := lang.Apply(tmp37, []any{lang.NewSymbol("glojure.core/args")}) - tmp39 := lang.Apply(tmp30, []any{tmp34, tmp38}) - tmp40 := lang.Apply(tmp27, []any{tmp39}) - tmp41 := lang.Apply(tmp24, []any{tmp40}) - tmp42 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp21, tmp41}) - tmp43 := lang.Apply(tmp6, []any{tmp42}) - return tmp43 - } - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("byte-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Creates an array of bytes", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5317), lang.NewKeyword("end-line"), int(5317))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "ByteArray") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ByteArray is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - case 2: - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "ByteArrayInit") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ByteArrayInit is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // bytes - { - var tmp1 lang.FnFunc - { // function bytes - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.Apply(tmp20, []any{lang.NewSymbol("glojure.core/Bytes")}) - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("list")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.Apply(tmp24, []any{v3}) - tmp26 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp21, tmp25}) - tmp27 := lang.Apply(tmp6, []any{tmp26}) - return tmp27 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("bytes").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Casts to bytes[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5377), lang.NewKeyword("end-line"), int(5377))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Bytes") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Bytes is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // bytes? - { - tmp0 := lang.NewSymbol("bytes?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a byte array", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5412), lang.NewKeyword("end-line"), int(5412))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("nil?")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v3}) - if lang.IsTruthy(tmp8) { - tmp4 = false - } else { - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("=")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("class")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.Apply(tmp14, []any{v3}) - tmp16, ok := lang.FieldOrMethod(tmp15, "getComponentType") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp15, "getComponentType"))) - } - var tmp17 any - switch reflect.TypeOf(tmp16).Kind() { - case reflect.Func: - tmp17 = lang.Apply(tmp16, nil) - default: - tmp17 = tmp16 - } - tmp18 := lang.Apply(tmp11, []any{tmp17, nil}) - tmp4 = tmp18 - } - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // case - { - tmp0 := lang.NewSymbol("case").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("e"), lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes an expression, and a set of clauses.\n\n Each clause can take the form of either:\n\n test-constant result-expr\n\n (test-constant1 ... test-constantN) result-expr\n\n The test-constants are not evaluated. They must be compile-time\n literals, and need not be quoted. If the expression is equal to a\n test-constant, the corresponding result-expr is returned. A single\n default expression can follow the clauses, and its value will be\n returned if no clause matches. If no default expression is provided\n and no clause matches, an IllegalArgumentException is thrown.\n\n Unlike cond and condp, case does a constant-time dispatch, the\n clauses are not considered sequentially. All manner of constant\n expressions are acceptable in case, including numbers, strings,\n symbols, keywords, and (Clojure) composites thereof. Note that since\n lists are used to group multiple constants that map to the same\n expression, a vector can be used to match a list if needed. The\n test-constants need not be all of the same type.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6712), lang.NewKeyword("end-line"), int(6712))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any - { // let - // let binding "ge" - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("with-meta")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("gensym")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, nil) - tmp15 := reflect.TypeOf((*lang.Object)(nil)).Elem() - tmp16 := lang.NewMap(lang.NewKeyword("tag"), tmp15) - tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6738), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(6738), lang.NewKeyword("end-column"), int(84)) - tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp19 := lang.Apply(tmp10, []any{tmp14, tmp18}) - var v20 any = tmp19 - _ = v20 - // let binding "default" - var tmp21 any - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("odd?")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("count")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.Apply(tmp27, []any{v6}) - tmp29 := lang.Apply(tmp24, []any{tmp28}) - if lang.IsTruthy(tmp29) { - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("last")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.Apply(tmp32, []any{v6}) - tmp21 = tmp33 - } else { - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.Apply(tmp42, []any{lang.NewSymbol("throw")}) - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp48 := tmp47.FindInternedVar(lang.NewSymbol("seq")) - if tmp48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) - } - tmp49 := tmp48.Get() - tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp51 := tmp50.FindInternedVar(lang.NewSymbol("concat")) - if tmp51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) - } - tmp52 := tmp51.Get() - tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp54 := tmp53.FindInternedVar(lang.NewSymbol("list")) - if tmp54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) - } - tmp55 := tmp54.Get() - tmp56 := lang.Apply(tmp55, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewIllegalArgumentError")}) - tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp58 := tmp57.FindInternedVar(lang.NewSymbol("list")) - if tmp58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) - } - tmp59 := tmp58.Get() - tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp61 := tmp60.FindInternedVar(lang.NewSymbol("seq")) - if tmp61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) - } - tmp62 := tmp61.Get() - tmp63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp64 := tmp63.FindInternedVar(lang.NewSymbol("concat")) - if tmp64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp64))) - } - tmp65 := tmp64.Get() - tmp66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp67 := tmp66.FindInternedVar(lang.NewSymbol("list")) - if tmp67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp67))) - } - tmp68 := tmp67.Get() - tmp69 := lang.Apply(tmp68, []any{lang.NewSymbol("glojure.core/str")}) - tmp70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp71 := tmp70.FindInternedVar(lang.NewSymbol("list")) - if tmp71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp71))) - } - tmp72 := tmp71.Get() - tmp73 := lang.Apply(tmp72, []any{"No matching clause: "}) - tmp74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp75 := tmp74.FindInternedVar(lang.NewSymbol("list")) - if tmp75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp75))) - } - tmp76 := tmp75.Get() - tmp77 := lang.Apply(tmp76, []any{v20}) - tmp78 := lang.Apply(tmp65, []any{tmp69, tmp73, tmp77}) - tmp79 := lang.Apply(tmp62, []any{tmp78}) - tmp80 := lang.Apply(tmp59, []any{tmp79}) - tmp81 := lang.Apply(tmp52, []any{tmp56, tmp80}) - tmp82 := lang.Apply(tmp49, []any{tmp81}) - tmp83 := lang.Apply(tmp46, []any{tmp82}) - tmp84 := lang.Apply(tmp39, []any{tmp43, tmp83}) - tmp85 := lang.Apply(tmp36, []any{tmp84}) - tmp21 = tmp85 - } - var v86 any = tmp21 - _ = v86 - var tmp87 any - tmp88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp89 := tmp88.FindInternedVar(lang.NewSymbol(">")) - if tmp89.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp89))) - } - tmp90 := tmp89.Get() - tmp91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp92 := tmp91.FindInternedVar(lang.NewSymbol("count")) - if tmp92.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp92))) - } - tmp93 := tmp92.Get() - tmp94 := lang.Apply(tmp93, []any{v6}) - tmp95 := lang.Apply(tmp90, []any{int64(2), tmp94}) - if lang.IsTruthy(tmp95) { - tmp96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp97 := tmp96.FindInternedVar(lang.NewSymbol("seq")) - if tmp97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp97))) - } - tmp98 := tmp97.Get() - tmp99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp100 := tmp99.FindInternedVar(lang.NewSymbol("concat")) - if tmp100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp100))) - } - tmp101 := tmp100.Get() - tmp102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp103 := tmp102.FindInternedVar(lang.NewSymbol("list")) - if tmp103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp103))) - } - tmp104 := tmp103.Get() - tmp105 := lang.Apply(tmp104, []any{lang.NewSymbol("glojure.core/let")}) - tmp106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp107 := tmp106.FindInternedVar(lang.NewSymbol("list")) - if tmp107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp107))) - } - tmp108 := tmp107.Get() - tmp109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp110 := tmp109.FindInternedVar(lang.NewSymbol("apply")) - if tmp110.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp110))) - } - tmp111 := tmp110.Get() - tmp112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp113 := tmp112.FindInternedVar(lang.NewSymbol("vector")) - if tmp113.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp113))) - } - tmp114 := tmp113.Get() - tmp115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp116 := tmp115.FindInternedVar(lang.NewSymbol("seq")) - if tmp116.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp116))) - } - tmp117 := tmp116.Get() - tmp118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp119 := tmp118.FindInternedVar(lang.NewSymbol("concat")) - if tmp119.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp119))) - } - tmp120 := tmp119.Get() - tmp121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp122 := tmp121.FindInternedVar(lang.NewSymbol("list")) - if tmp122.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp122))) - } - tmp123 := tmp122.Get() - tmp124 := lang.Apply(tmp123, []any{v20}) - tmp125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp126 := tmp125.FindInternedVar(lang.NewSymbol("list")) - if tmp126.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp126))) - } - tmp127 := tmp126.Get() - tmp128 := lang.Apply(tmp127, []any{v5}) - tmp129 := lang.Apply(tmp120, []any{tmp124, tmp128}) - tmp130 := lang.Apply(tmp117, []any{tmp129}) - tmp131 := lang.Apply(tmp111, []any{tmp114, tmp130}) - tmp132 := lang.Apply(tmp108, []any{tmp131}) - tmp133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp134 := tmp133.FindInternedVar(lang.NewSymbol("list")) - if tmp134.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp134))) - } - tmp135 := tmp134.Get() - tmp136 := lang.Apply(tmp135, []any{v86}) - tmp137 := lang.Apply(tmp101, []any{tmp105, tmp132, tmp136}) - tmp138 := lang.Apply(tmp98, []any{tmp137}) - tmp87 = tmp138 - } else { - var tmp139 any - { // let - // let binding "pairs" - tmp140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp141 := tmp140.FindInternedVar(lang.NewSymbol("partition")) - if tmp141.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp141))) - } - tmp142 := tmp141.Get() - tmp143 := lang.Apply(tmp142, []any{int64(2), v6}) - var v144 any = tmp143 - _ = v144 - // let binding "assoc-test" - var tmp145 lang.FnFunc - { // function assoc-test - var v146 lang.FnFunc - tmp145 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v147 := args[0] - _ = v147 - v148 := args[1] - _ = v148 - v149 := args[2] - _ = v149 - var tmp150 any - tmp151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp152 := tmp151.FindInternedVar(lang.NewSymbol("contains?")) - if tmp152.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp152))) - } - tmp153 := tmp152.Get() - tmp154 := lang.Apply(tmp153, []any{v147, v148}) - if lang.IsTruthy(tmp154) { - tmp155 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp156 := tmp155.FindInternedVar(lang.NewSymbol("str")) - if tmp156.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp156))) - } - tmp157 := tmp156.Get() - tmp158 := lang.Apply(tmp157, []any{"Duplicate case test constant: ", v148}) - tmp159 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp158}) - panic(tmp159) - } else { - tmp160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp161 := tmp160.FindInternedVar(lang.NewSymbol("assoc")) - if tmp161.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp161))) - } - tmp162 := tmp161.Get() - tmp163 := lang.Apply(tmp162, []any{v147, v148, v149}) - tmp150 = tmp163 - } - return tmp150 - }) - v146 = tmp145 - _ = v146 - } - tmp146 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6745), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(6748), lang.NewKeyword("end-column"), int(48)) - tmp147, err := lang.WithMeta(tmp145, tmp146.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v148 any = tmp147 - _ = v148 - // let binding "pairs" - tmp149 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp150 := tmp149.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp150.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp150))) - } - tmp151 := tmp150.Get() - var tmp152 lang.FnFunc - tmp152 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v153 := args[0] - _ = v153 - v154 := args[1] - _ = v154 - var tmp155 any - { // let - // let binding "vec__177" - var v156 any = v154 - _ = v156 - // let binding "test" - tmp157 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp158 := tmp157.FindInternedVar(lang.NewSymbol("nth")) - if tmp158.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp158))) - } - tmp159 := tmp158.Get() - tmp160 := lang.Apply(tmp159, []any{v156, int64(0), nil}) - var v161 any = tmp160 - _ = v161 - // let binding "expr" - tmp162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp163 := tmp162.FindInternedVar(lang.NewSymbol("nth")) - if tmp163.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp163))) - } - tmp164 := tmp163.Get() - tmp165 := lang.Apply(tmp164, []any{v156, int64(1), nil}) - var v166 any = tmp165 - _ = v166 - var tmp167 any - tmp168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp169 := tmp168.FindInternedVar(lang.NewSymbol("seq?")) - if tmp169.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp169))) - } - tmp170 := tmp169.Get() - tmp171 := lang.Apply(tmp170, []any{v161}) - if lang.IsTruthy(tmp171) { - tmp172 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp173 := tmp172.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp173.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp173))) - } - tmp174 := tmp173.Get() - var tmp175 lang.FnFunc - tmp175 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v176 := args[0] - _ = v176 - v177 := args[1] - _ = v177 - tmp178 := lang.Apply(v148, []any{v176, v177, v166}) - return tmp178 - }) - tmp176 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6752), lang.NewKeyword("column"), int(37), lang.NewKeyword("end-line"), int(6752), lang.NewKeyword("end-column"), int(60)) - tmp177, err := lang.WithMeta(tmp175, tmp176.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp178 := lang.Apply(tmp174, []any{tmp177, v153, v161}) - tmp167 = tmp178 - } else { - tmp179 := lang.Apply(v148, []any{v153, v161, v166}) - tmp167 = tmp179 - } - tmp155 = tmp167 - } // end let - return tmp155 - }) - tmp153 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6750), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(6753), lang.NewKeyword("end-column"), int(53)) - tmp154, err := lang.WithMeta(tmp152, tmp153.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp155 := lang.NewMap() - tmp156 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6754), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(6754), lang.NewKeyword("end-column"), int(25)) - tmp157, err := lang.WithMeta(tmp155, tmp156.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp158 := lang.Apply(tmp151, []any{tmp154, tmp157, v144}) - var v159 any = tmp158 - _ = v159 - // let binding "tests" - tmp160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp161 := tmp160.FindInternedVar(lang.NewSymbol("keys")) - if tmp161.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp161))) - } - tmp162 := tmp161.Get() - tmp163 := lang.Apply(tmp162, []any{v159}) - var v164 any = tmp163 - _ = v164 - // let binding "thens" - tmp165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp166 := tmp165.FindInternedVar(lang.NewSymbol("vals")) - if tmp166.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp166))) - } - tmp167 := tmp166.Get() - tmp168 := lang.Apply(tmp167, []any{v159}) - var v169 any = tmp168 - _ = v169 - // let binding "mode" - var tmp170 any - tmp171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp172 := tmp171.FindInternedVar(lang.NewSymbol("every?")) - if tmp172.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp172))) - } - tmp173 := tmp172.Get() - var tmp174 lang.FnFunc - tmp174 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v175 := args[0] - _ = v175 - var tmp176 any - { // let - // let binding "and__0__auto__" - tmp177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp178 := tmp177.FindInternedVar(lang.NewSymbol("integer?")) - if tmp178.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp178))) - } - tmp179 := tmp178.Get() - tmp180 := lang.Apply(tmp179, []any{v175}) - var v181 any = tmp180 - _ = v181 - var tmp182 any - if lang.IsTruthy(v181) { - tmp183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp184 := tmp183.FindInternedVar(lang.NewSymbol("<=")) - if tmp184.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp184))) - } - tmp185 := tmp184.Get() - tmp186 := lang.Apply(tmp185, []any{math3.MinInt, v175, math3.MaxInt}) - tmp182 = tmp186 - } else { - tmp182 = v181 - } - tmp176 = tmp182 - } // end let - return tmp176 - }) - tmp175 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6758), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(6758), lang.NewKeyword("end-column"), int(77)) - tmp176, err := lang.WithMeta(tmp174, tmp175.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp177 := lang.Apply(tmp173, []any{tmp176, v164}) - if lang.IsTruthy(tmp177) { - tmp170 = lang.NewKeyword("ints") - } else { - var tmp178 any - tmp179 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp180 := tmp179.FindInternedVar(lang.NewSymbol("every?")) - if tmp180.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp180))) - } - tmp181 := tmp180.Get() - tmp182 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp183 := tmp182.FindInternedVar(lang.NewSymbol("keyword?")) - if tmp183.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp183))) - } - tmp184 := tmp183.Get() - tmp185 := lang.Apply(tmp181, []any{tmp184, v164}) - if lang.IsTruthy(tmp185) { - tmp178 = lang.NewKeyword("identity") - } else { - var tmp186 any - if lang.IsTruthy(lang.NewKeyword("else")) { - tmp186 = lang.NewKeyword("hashes") - } else { - } - tmp178 = tmp186 - } - tmp170 = tmp178 - } - var v187 any = tmp170 - _ = v187 - var tmp188 any - { // let - // let binding "pred__180" - tmp189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp190 := tmp189.FindInternedVar(lang.NewSymbol("=")) - if tmp190.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp190))) - } - tmp191 := tmp190.Get() - var v192 any = tmp191 - _ = v192 - // let binding "expr__181" - var v193 any = v187 - _ = v193 - var tmp194 any - tmp195 := lang.Apply(v192, []any{lang.NewKeyword("ints"), v193}) - if lang.IsTruthy(tmp195) { - var tmp196 any - { // let - // let binding "vec__182" - tmp197 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp198 := tmp197.FindInternedVar(lang.NewSymbol("prep-ints")) - if tmp198.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp198))) - } - tmp199 := tmp198.Get() - tmp200 := lang.Apply(tmp199, []any{v164, v169}) - var v201 any = tmp200 - _ = v201 - // let binding "shift" - tmp202 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp203 := tmp202.FindInternedVar(lang.NewSymbol("nth")) - if tmp203.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp203))) - } - tmp204 := tmp203.Get() - tmp205 := lang.Apply(tmp204, []any{v201, int64(0), nil}) - var v206 any = tmp205 - _ = v206 - // let binding "mask" - tmp207 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp208 := tmp207.FindInternedVar(lang.NewSymbol("nth")) - if tmp208.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp208))) - } - tmp209 := tmp208.Get() - tmp210 := lang.Apply(tmp209, []any{v201, int64(1), nil}) - var v211 any = tmp210 - _ = v211 - // let binding "imap" - tmp212 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp213 := tmp212.FindInternedVar(lang.NewSymbol("nth")) - if tmp213.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp213))) - } - tmp214 := tmp213.Get() - tmp215 := lang.Apply(tmp214, []any{v201, int64(2), nil}) - var v216 any = tmp215 - _ = v216 - // let binding "switch-type" - tmp217 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp218 := tmp217.FindInternedVar(lang.NewSymbol("nth")) - if tmp218.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp218))) - } - tmp219 := tmp218.Get() - tmp220 := lang.Apply(tmp219, []any{v201, int64(3), nil}) - var v221 any = tmp220 - _ = v221 - tmp222 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp223 := tmp222.FindInternedVar(lang.NewSymbol("seq")) - if tmp223.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp223))) - } - tmp224 := tmp223.Get() - tmp225 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp226 := tmp225.FindInternedVar(lang.NewSymbol("concat")) - if tmp226.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp226))) - } - tmp227 := tmp226.Get() - tmp228 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp229 := tmp228.FindInternedVar(lang.NewSymbol("list")) - if tmp229.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp229))) - } - tmp230 := tmp229.Get() - tmp231 := lang.Apply(tmp230, []any{lang.NewSymbol("glojure.core/let")}) - tmp232 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp233 := tmp232.FindInternedVar(lang.NewSymbol("list")) - if tmp233.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp233))) - } - tmp234 := tmp233.Get() - tmp235 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp236 := tmp235.FindInternedVar(lang.NewSymbol("apply")) - if tmp236.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp236))) - } - tmp237 := tmp236.Get() - tmp238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp239 := tmp238.FindInternedVar(lang.NewSymbol("vector")) - if tmp239.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp239))) - } - tmp240 := tmp239.Get() - tmp241 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp242 := tmp241.FindInternedVar(lang.NewSymbol("seq")) - if tmp242.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp242))) - } - tmp243 := tmp242.Get() - tmp244 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp245 := tmp244.FindInternedVar(lang.NewSymbol("concat")) - if tmp245.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp245))) - } - tmp246 := tmp245.Get() - tmp247 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp248 := tmp247.FindInternedVar(lang.NewSymbol("list")) - if tmp248.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp248))) - } - tmp249 := tmp248.Get() - tmp250 := lang.Apply(tmp249, []any{v20}) - tmp251 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp252 := tmp251.FindInternedVar(lang.NewSymbol("list")) - if tmp252.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp252))) - } - tmp253 := tmp252.Get() - tmp254 := lang.Apply(tmp253, []any{v5}) - tmp255 := lang.Apply(tmp246, []any{tmp250, tmp254}) - tmp256 := lang.Apply(tmp243, []any{tmp255}) - tmp257 := lang.Apply(tmp237, []any{tmp240, tmp256}) - tmp258 := lang.Apply(tmp234, []any{tmp257}) - tmp259 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp260 := tmp259.FindInternedVar(lang.NewSymbol("list")) - if tmp260.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp260))) - } - tmp261 := tmp260.Get() - tmp262 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp263 := tmp262.FindInternedVar(lang.NewSymbol("seq")) - if tmp263.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp263))) - } - tmp264 := tmp263.Get() - tmp265 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp266 := tmp265.FindInternedVar(lang.NewSymbol("concat")) - if tmp266.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp266))) - } - tmp267 := tmp266.Get() - tmp268 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp269 := tmp268.FindInternedVar(lang.NewSymbol("list")) - if tmp269.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp269))) - } - tmp270 := tmp269.Get() - tmp271 := lang.Apply(tmp270, []any{lang.NewSymbol("case*")}) - tmp272 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp273 := tmp272.FindInternedVar(lang.NewSymbol("list")) - if tmp273.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp273))) - } - tmp274 := tmp273.Get() - tmp275 := lang.Apply(tmp274, []any{v20}) - tmp276 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp277 := tmp276.FindInternedVar(lang.NewSymbol("list")) - if tmp277.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp277))) - } - tmp278 := tmp277.Get() - tmp279 := lang.Apply(tmp278, []any{v206}) - tmp280 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp281 := tmp280.FindInternedVar(lang.NewSymbol("list")) - if tmp281.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp281))) - } - tmp282 := tmp281.Get() - tmp283 := lang.Apply(tmp282, []any{v211}) - tmp284 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp285 := tmp284.FindInternedVar(lang.NewSymbol("list")) - if tmp285.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp285))) - } - tmp286 := tmp285.Get() - tmp287 := lang.Apply(tmp286, []any{v86}) - tmp288 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp289 := tmp288.FindInternedVar(lang.NewSymbol("list")) - if tmp289.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp289))) - } - tmp290 := tmp289.Get() - tmp291 := lang.Apply(tmp290, []any{v216}) - tmp292 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp293 := tmp292.FindInternedVar(lang.NewSymbol("list")) - if tmp293.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp293))) - } - tmp294 := tmp293.Get() - tmp295 := lang.Apply(tmp294, []any{v221}) - tmp296 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp297 := tmp296.FindInternedVar(lang.NewSymbol("list")) - if tmp297.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp297))) - } - tmp298 := tmp297.Get() - tmp299 := lang.Apply(tmp298, []any{lang.NewKeyword("int")}) - tmp300 := lang.Apply(tmp267, []any{tmp271, tmp275, tmp279, tmp283, tmp287, tmp291, tmp295, tmp299}) - tmp301 := lang.Apply(tmp264, []any{tmp300}) - tmp302 := lang.Apply(tmp261, []any{tmp301}) - tmp303 := lang.Apply(tmp227, []any{tmp231, tmp258, tmp302}) - tmp304 := lang.Apply(tmp224, []any{tmp303}) - tmp196 = tmp304 - } // end let - tmp194 = tmp196 - } else { - var tmp197 any - tmp198 := lang.Apply(v192, []any{lang.NewKeyword("hashes"), v193}) - if lang.IsTruthy(tmp198) { - var tmp199 any - { // let - // let binding "vec__185" - tmp200 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp201 := tmp200.FindInternedVar(lang.NewSymbol("prep-hashes")) - if tmp201.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp201))) - } - tmp202 := tmp201.Get() - tmp203 := lang.Apply(tmp202, []any{v20, v86, v164, v169}) - var v204 any = tmp203 - _ = v204 - // let binding "shift" - tmp205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp206 := tmp205.FindInternedVar(lang.NewSymbol("nth")) - if tmp206.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp206))) - } - tmp207 := tmp206.Get() - tmp208 := lang.Apply(tmp207, []any{v204, int64(0), nil}) - var v209 any = tmp208 - _ = v209 - // let binding "mask" - tmp210 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp211 := tmp210.FindInternedVar(lang.NewSymbol("nth")) - if tmp211.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp211))) - } - tmp212 := tmp211.Get() - tmp213 := lang.Apply(tmp212, []any{v204, int64(1), nil}) - var v214 any = tmp213 - _ = v214 - // let binding "imap" - tmp215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp216 := tmp215.FindInternedVar(lang.NewSymbol("nth")) - if tmp216.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp216))) - } - tmp217 := tmp216.Get() - tmp218 := lang.Apply(tmp217, []any{v204, int64(2), nil}) - var v219 any = tmp218 - _ = v219 - // let binding "switch-type" - tmp220 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp221 := tmp220.FindInternedVar(lang.NewSymbol("nth")) - if tmp221.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp221))) - } - tmp222 := tmp221.Get() - tmp223 := lang.Apply(tmp222, []any{v204, int64(3), nil}) - var v224 any = tmp223 - _ = v224 - // let binding "skip-check" - tmp225 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp226 := tmp225.FindInternedVar(lang.NewSymbol("nth")) - if tmp226.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp226))) - } - tmp227 := tmp226.Get() - tmp228 := lang.Apply(tmp227, []any{v204, int64(4), nil}) - var v229 any = tmp228 - _ = v229 - tmp230 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp231 := tmp230.FindInternedVar(lang.NewSymbol("seq")) - if tmp231.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp231))) - } - tmp232 := tmp231.Get() - tmp233 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp234 := tmp233.FindInternedVar(lang.NewSymbol("concat")) - if tmp234.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp234))) - } - tmp235 := tmp234.Get() - tmp236 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp237 := tmp236.FindInternedVar(lang.NewSymbol("list")) - if tmp237.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp237))) - } - tmp238 := tmp237.Get() - tmp239 := lang.Apply(tmp238, []any{lang.NewSymbol("glojure.core/let")}) - tmp240 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp241 := tmp240.FindInternedVar(lang.NewSymbol("list")) - if tmp241.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp241))) - } - tmp242 := tmp241.Get() - tmp243 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp244 := tmp243.FindInternedVar(lang.NewSymbol("apply")) - if tmp244.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp244))) - } - tmp245 := tmp244.Get() - tmp246 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp247 := tmp246.FindInternedVar(lang.NewSymbol("vector")) - if tmp247.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp247))) - } - tmp248 := tmp247.Get() - tmp249 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp250 := tmp249.FindInternedVar(lang.NewSymbol("seq")) - if tmp250.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp250))) - } - tmp251 := tmp250.Get() - tmp252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp253 := tmp252.FindInternedVar(lang.NewSymbol("concat")) - if tmp253.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp253))) - } - tmp254 := tmp253.Get() - tmp255 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp256 := tmp255.FindInternedVar(lang.NewSymbol("list")) - if tmp256.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp256))) - } - tmp257 := tmp256.Get() - tmp258 := lang.Apply(tmp257, []any{v20}) - tmp259 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp260 := tmp259.FindInternedVar(lang.NewSymbol("list")) - if tmp260.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp260))) - } - tmp261 := tmp260.Get() - tmp262 := lang.Apply(tmp261, []any{v5}) - tmp263 := lang.Apply(tmp254, []any{tmp258, tmp262}) - tmp264 := lang.Apply(tmp251, []any{tmp263}) - tmp265 := lang.Apply(tmp245, []any{tmp248, tmp264}) - tmp266 := lang.Apply(tmp242, []any{tmp265}) - tmp267 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp268 := tmp267.FindInternedVar(lang.NewSymbol("list")) - if tmp268.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp268))) - } - tmp269 := tmp268.Get() - tmp270 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp271 := tmp270.FindInternedVar(lang.NewSymbol("seq")) - if tmp271.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp271))) - } - tmp272 := tmp271.Get() - tmp273 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp274 := tmp273.FindInternedVar(lang.NewSymbol("concat")) - if tmp274.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp274))) - } - tmp275 := tmp274.Get() - tmp276 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp277 := tmp276.FindInternedVar(lang.NewSymbol("list")) - if tmp277.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp277))) - } - tmp278 := tmp277.Get() - tmp279 := lang.Apply(tmp278, []any{lang.NewSymbol("case*")}) - tmp280 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp281 := tmp280.FindInternedVar(lang.NewSymbol("list")) - if tmp281.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp281))) - } - tmp282 := tmp281.Get() - tmp283 := lang.Apply(tmp282, []any{v20}) - tmp284 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp285 := tmp284.FindInternedVar(lang.NewSymbol("list")) - if tmp285.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp285))) - } - tmp286 := tmp285.Get() - tmp287 := lang.Apply(tmp286, []any{v209}) - tmp288 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp289 := tmp288.FindInternedVar(lang.NewSymbol("list")) - if tmp289.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp289))) - } - tmp290 := tmp289.Get() - tmp291 := lang.Apply(tmp290, []any{v214}) - tmp292 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp293 := tmp292.FindInternedVar(lang.NewSymbol("list")) - if tmp293.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp293))) - } - tmp294 := tmp293.Get() - tmp295 := lang.Apply(tmp294, []any{v86}) - tmp296 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp297 := tmp296.FindInternedVar(lang.NewSymbol("list")) - if tmp297.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp297))) - } - tmp298 := tmp297.Get() - tmp299 := lang.Apply(tmp298, []any{v219}) - tmp300 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp301 := tmp300.FindInternedVar(lang.NewSymbol("list")) - if tmp301.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp301))) - } - tmp302 := tmp301.Get() - tmp303 := lang.Apply(tmp302, []any{v224}) - tmp304 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp305 := tmp304.FindInternedVar(lang.NewSymbol("list")) - if tmp305.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp305))) - } - tmp306 := tmp305.Get() - tmp307 := lang.Apply(tmp306, []any{lang.NewKeyword("hash-equiv")}) - tmp308 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp309 := tmp308.FindInternedVar(lang.NewSymbol("list")) - if tmp309.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp309))) - } - tmp310 := tmp309.Get() - tmp311 := lang.Apply(tmp310, []any{v229}) - tmp312 := lang.Apply(tmp275, []any{tmp279, tmp283, tmp287, tmp291, tmp295, tmp299, tmp303, tmp307, tmp311}) - tmp313 := lang.Apply(tmp272, []any{tmp312}) - tmp314 := lang.Apply(tmp269, []any{tmp313}) - tmp315 := lang.Apply(tmp235, []any{tmp239, tmp266, tmp314}) - tmp316 := lang.Apply(tmp232, []any{tmp315}) - tmp199 = tmp316 - } // end let - tmp197 = tmp199 - } else { - var tmp200 any - tmp201 := lang.Apply(v192, []any{lang.NewKeyword("identity"), v193}) - if lang.IsTruthy(tmp201) { - var tmp202 any - { // let - // let binding "vec__188" - tmp203 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp204 := tmp203.FindInternedVar(lang.NewSymbol("prep-hashes")) - if tmp204.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp204))) - } - tmp205 := tmp204.Get() - tmp206 := lang.Apply(tmp205, []any{v20, v86, v164, v169}) - var v207 any = tmp206 - _ = v207 - // let binding "shift" - tmp208 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp209 := tmp208.FindInternedVar(lang.NewSymbol("nth")) - if tmp209.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp209))) - } - tmp210 := tmp209.Get() - tmp211 := lang.Apply(tmp210, []any{v207, int64(0), nil}) - var v212 any = tmp211 - _ = v212 - // let binding "mask" - tmp213 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp214 := tmp213.FindInternedVar(lang.NewSymbol("nth")) - if tmp214.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp214))) - } - tmp215 := tmp214.Get() - tmp216 := lang.Apply(tmp215, []any{v207, int64(1), nil}) - var v217 any = tmp216 - _ = v217 - // let binding "imap" - tmp218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp219 := tmp218.FindInternedVar(lang.NewSymbol("nth")) - if tmp219.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp219))) - } - tmp220 := tmp219.Get() - tmp221 := lang.Apply(tmp220, []any{v207, int64(2), nil}) - var v222 any = tmp221 - _ = v222 - // let binding "switch-type" - tmp223 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp224 := tmp223.FindInternedVar(lang.NewSymbol("nth")) - if tmp224.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp224))) - } - tmp225 := tmp224.Get() - tmp226 := lang.Apply(tmp225, []any{v207, int64(3), nil}) - var v227 any = tmp226 - _ = v227 - // let binding "skip-check" - tmp228 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp229 := tmp228.FindInternedVar(lang.NewSymbol("nth")) - if tmp229.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp229))) - } - tmp230 := tmp229.Get() - tmp231 := lang.Apply(tmp230, []any{v207, int64(4), nil}) - var v232 any = tmp231 - _ = v232 - tmp233 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp234 := tmp233.FindInternedVar(lang.NewSymbol("seq")) - if tmp234.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp234))) - } - tmp235 := tmp234.Get() - tmp236 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp237 := tmp236.FindInternedVar(lang.NewSymbol("concat")) - if tmp237.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp237))) - } - tmp238 := tmp237.Get() - tmp239 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp240 := tmp239.FindInternedVar(lang.NewSymbol("list")) - if tmp240.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp240))) - } - tmp241 := tmp240.Get() - tmp242 := lang.Apply(tmp241, []any{lang.NewSymbol("glojure.core/let")}) - tmp243 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp244 := tmp243.FindInternedVar(lang.NewSymbol("list")) - if tmp244.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp244))) - } - tmp245 := tmp244.Get() - tmp246 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp247 := tmp246.FindInternedVar(lang.NewSymbol("apply")) - if tmp247.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp247))) - } - tmp248 := tmp247.Get() - tmp249 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp250 := tmp249.FindInternedVar(lang.NewSymbol("vector")) - if tmp250.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp250))) - } - tmp251 := tmp250.Get() - tmp252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp253 := tmp252.FindInternedVar(lang.NewSymbol("seq")) - if tmp253.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp253))) - } - tmp254 := tmp253.Get() - tmp255 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp256 := tmp255.FindInternedVar(lang.NewSymbol("concat")) - if tmp256.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp256))) - } - tmp257 := tmp256.Get() - tmp258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp259 := tmp258.FindInternedVar(lang.NewSymbol("list")) - if tmp259.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp259))) - } - tmp260 := tmp259.Get() - tmp261 := lang.Apply(tmp260, []any{v20}) - tmp262 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp263 := tmp262.FindInternedVar(lang.NewSymbol("list")) - if tmp263.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp263))) - } - tmp264 := tmp263.Get() - tmp265 := lang.Apply(tmp264, []any{v5}) - tmp266 := lang.Apply(tmp257, []any{tmp261, tmp265}) - tmp267 := lang.Apply(tmp254, []any{tmp266}) - tmp268 := lang.Apply(tmp248, []any{tmp251, tmp267}) - tmp269 := lang.Apply(tmp245, []any{tmp268}) - tmp270 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp271 := tmp270.FindInternedVar(lang.NewSymbol("list")) - if tmp271.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp271))) - } - tmp272 := tmp271.Get() - tmp273 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp274 := tmp273.FindInternedVar(lang.NewSymbol("seq")) - if tmp274.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp274))) - } - tmp275 := tmp274.Get() - tmp276 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp277 := tmp276.FindInternedVar(lang.NewSymbol("concat")) - if tmp277.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp277))) - } - tmp278 := tmp277.Get() - tmp279 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp280 := tmp279.FindInternedVar(lang.NewSymbol("list")) - if tmp280.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp280))) - } - tmp281 := tmp280.Get() - tmp282 := lang.Apply(tmp281, []any{lang.NewSymbol("case*")}) - tmp283 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp284 := tmp283.FindInternedVar(lang.NewSymbol("list")) - if tmp284.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp284))) - } - tmp285 := tmp284.Get() - tmp286 := lang.Apply(tmp285, []any{v20}) - tmp287 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp288 := tmp287.FindInternedVar(lang.NewSymbol("list")) - if tmp288.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp288))) - } - tmp289 := tmp288.Get() - tmp290 := lang.Apply(tmp289, []any{v212}) - tmp291 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp292 := tmp291.FindInternedVar(lang.NewSymbol("list")) - if tmp292.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp292))) - } - tmp293 := tmp292.Get() - tmp294 := lang.Apply(tmp293, []any{v217}) - tmp295 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp296 := tmp295.FindInternedVar(lang.NewSymbol("list")) - if tmp296.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp296))) - } - tmp297 := tmp296.Get() - tmp298 := lang.Apply(tmp297, []any{v86}) - tmp299 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp300 := tmp299.FindInternedVar(lang.NewSymbol("list")) - if tmp300.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp300))) - } - tmp301 := tmp300.Get() - tmp302 := lang.Apply(tmp301, []any{v222}) - tmp303 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp304 := tmp303.FindInternedVar(lang.NewSymbol("list")) - if tmp304.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp304))) - } - tmp305 := tmp304.Get() - tmp306 := lang.Apply(tmp305, []any{v227}) - tmp307 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp308 := tmp307.FindInternedVar(lang.NewSymbol("list")) - if tmp308.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp308))) - } - tmp309 := tmp308.Get() - tmp310 := lang.Apply(tmp309, []any{lang.NewKeyword("hash-identity")}) - tmp311 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp312 := tmp311.FindInternedVar(lang.NewSymbol("list")) - if tmp312.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp312))) - } - tmp313 := tmp312.Get() - tmp314 := lang.Apply(tmp313, []any{v232}) - tmp315 := lang.Apply(tmp278, []any{tmp282, tmp286, tmp290, tmp294, tmp298, tmp302, tmp306, tmp310, tmp314}) - tmp316 := lang.Apply(tmp275, []any{tmp315}) - tmp317 := lang.Apply(tmp272, []any{tmp316}) - tmp318 := lang.Apply(tmp238, []any{tmp242, tmp269, tmp317}) - tmp319 := lang.Apply(tmp235, []any{tmp318}) - tmp202 = tmp319 - } // end let - tmp200 = tmp202 - } else { - tmp203 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp204 := tmp203.FindInternedVar(lang.NewSymbol("str")) - if tmp204.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp204))) - } - tmp205 := tmp204.Get() - tmp206 := lang.Apply(tmp205, []any{"No matching clause: ", v193}) - tmp207 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp206}) - panic(tmp207) - } - tmp197 = tmp200 - } - tmp194 = tmp197 - } - tmp188 = tmp194 - } // end let - tmp139 = tmp188 - } // end let - tmp87 = tmp139 - } - tmp7 = tmp87 - } // end let - return tmp7 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // case-map - { - tmp0 := lang.NewSymbol("case-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("case-f"), lang.NewSymbol("test-f"), lang.NewSymbol("tests"), lang.NewSymbol("thens"))), lang.NewKeyword("doc"), "Transforms a sequence of test constants and a corresponding sequence of then\n expressions into a sorted map to be consumed by case*. The form of the map\n entries are {(case-f test) [(test-f test) then]}.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6614), lang.NewKeyword("end-line"), int(6614), lang.NewKeyword("private"), true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("into1")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("sorted-map")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, nil) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("zipmap")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("map")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.Apply(tmp19, []any{v3, v5}) - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("map")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("vector")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("map")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{v4, v5}) - tmp31 := lang.Apply(tmp23, []any{tmp26, tmp30, v6}) - tmp32 := lang.Apply(tmp16, []any{tmp20, tmp31}) - tmp33 := lang.Apply(tmp9, []any{tmp13, tmp32}) - return tmp33 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // cast - { - tmp0 := lang.NewSymbol("cast").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Throws a ClassCastException if x is not a c, else returns x.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(345), lang.NewKeyword("end-line"), int(345))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5, _ := lang.FieldOrMethod(v3, "cast") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("cast is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // cat - { - tmp0 := lang.NewSymbol("cat").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rf"))), lang.NewKeyword("doc"), "A transducer which concatenates the contents of each input, which must be a\n collection, into the reduction.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7645), lang.NewKeyword("end-line"), int(7645))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "rrf" - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("preserving-reduced")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v3}) - var v9 any = tmp8 - _ = v9 - var tmp10 lang.FnFunc - tmp10 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp11 := lang.Apply(v3, nil) - return tmp11 - case 1: - v11 := args[0] - _ = v11 - tmp12 := lang.Apply(v3, []any{v11}) - return tmp12 - case 2: - v11 := args[0] - _ = v11 - v12 := args[1] - _ = v12 - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("reduce")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{v9, v11, v12}) - return tmp16 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7651), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(7655), lang.NewKeyword("end-column"), int(36)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp4 = tmp12 - } // end let - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // char - { - var tmp1 lang.FnFunc - { // function char__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - var tmp30 any - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - if lang.IsTruthy(tmp33) { - tmp30 = lang.NewSymbol("uncheckedCharCast") - } else { - tmp30 = lang.NewSymbol("charCast") - } - tmp34 := lang.Apply(tmp29, []any{tmp30}) - tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp36 := tmp35.FindInternedVar(lang.NewSymbol("list")) - if tmp36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) - } - tmp37 := tmp36.Get() - tmp38 := lang.Apply(tmp37, []any{v3}) - tmp39 := lang.Apply(tmp26, []any{tmp34, tmp38}) - tmp40 := lang.Apply(tmp23, []any{tmp39}) - tmp41 := lang.Apply(tmp20, []any{tmp40}) - tmp42 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp41}) - tmp43 := lang.Apply(tmp6, []any{tmp42}) - return tmp43 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("char").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to char", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3511), lang.NewKeyword("end-line"), int(3511))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(runtime4.RT, "CharCast") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("CharCast is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // char-array - { - var tmp1 lang.FnFunc - { // function char-array__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var v3 any = lang.NewList(args[0:]...) - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.Apply(tmp20, []any{lang.NewSymbol("glojure.core/CharArray")}) - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("list")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("seq")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("concat")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) - tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp36 := tmp35.FindInternedVar(lang.NewSymbol("list")) - if tmp36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) - } - tmp37 := tmp36.Get() - tmp38 := lang.Apply(tmp37, []any{lang.NewSymbol("glojure.core/args")}) - tmp39 := lang.Apply(tmp30, []any{tmp34, tmp38}) - tmp40 := lang.Apply(tmp27, []any{tmp39}) - tmp41 := lang.Apply(tmp24, []any{tmp40}) - tmp42 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp21, tmp41}) - tmp43 := lang.Apply(tmp6, []any{tmp42}) - return tmp43 - } - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("char-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Creates an array of chars", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5325), lang.NewKeyword("end-line"), int(5325))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "CharArray") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("CharArray is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - case 2: - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "CharArrayInit") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("CharArrayInit is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // char-escape-string - { - tmp1 := reflect.TypeOf("") - tmp0 := lang.NewSymbol("char-escape-string").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("doc"), "Returns escape string for char or nil if none", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(6), lang.NewKeyword("line"), int(214), lang.NewKeyword("end-line"), int(217))).(*lang.Symbol) - tmp2 := ns.InternWithValue(tmp0, lang.NewMap(lang.NewChar(10), "\\n", lang.NewChar(9), "\\t", lang.NewChar(13), "\\r", lang.NewChar(34), "\\\"", lang.NewChar(92), "\\\\", lang.NewChar(12), "\\f", lang.NewChar(8), "\\b"), true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // char-name-string - { - tmp1 := reflect.TypeOf("") - tmp0 := lang.NewSymbol("char-name-string").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("doc"), "Returns name string for char or nil if none", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(6), lang.NewKeyword("line"), int(335), lang.NewKeyword("end-line"), int(338))).(*lang.Symbol) - tmp2 := ns.InternWithValue(tmp0, lang.NewMap(lang.NewChar(10), "newline", lang.NewChar(9), "tab", lang.NewChar(32), "space", lang.NewChar(8), "backspace", lang.NewChar(12), "formfeed", lang.NewChar(13), "return"), true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // char? - { - tmp0 := lang.NewSymbol("char?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a Character", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(153), lang.NewKeyword("end-line"), int(157))).(*lang.Symbol) - var tmp2 lang.FnFunc - { // function char? - var v3 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("instance?")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := reflect.TypeOf(int32(0)) - tmp9 := lang.Apply(tmp7, []any{tmp8, v4}) - return tmp9 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(157), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(157), lang.NewKeyword("end-column"), int(89))).(lang.FnFunc) - v3 = tmp2 - _ = v3 - } - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // chars - { - var tmp1 lang.FnFunc - { // function chars - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.Apply(tmp20, []any{lang.NewSymbol("glojure.core/Chars")}) - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("list")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.Apply(tmp24, []any{v3}) - tmp26 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp21, tmp25}) - tmp27 := lang.Apply(tmp6, []any{tmp26}) - return tmp27 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("chars").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Casts to chars[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5382), lang.NewKeyword("end-line"), int(5382))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Chars") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Chars is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // check-cyclic-dependency - { - tmp0 := lang.NewSymbol("check-cyclic-dependency").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("path"))), lang.NewKeyword("doc"), "Detects and rejects non-trivial cyclic load dependencies. The\n exception message shows the dependency chain with the cycle\n highlighted. Ignores the trivial case of a file attempting to load\n itself because that can occur when a gen-class'd class loads its\n implementation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(30), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5974), lang.NewKeyword("end-line"), int(5974), lang.NewKeyword("private"), true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("some")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{v3})) - tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5981), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(5981), lang.NewKeyword("end-column"), int(21)) - tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("rest")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("*pending-paths*")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp13, []any{tmp16}) - tmp18 := lang.Apply(tmp7, []any{tmp10, tmp17}) - if lang.IsTruthy(tmp18) { - var tmp19 any - { // let - // let binding "pending" - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("map")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - var tmp23 lang.FnFunc - tmp23 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v24 := args[0] - _ = v24 - var tmp25 any - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("=")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.Apply(tmp28, []any{v24, v3}) - if lang.IsTruthy(tmp29) { - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("str")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.Apply(tmp32, []any{"[ ", v24, " ]"}) - tmp25 = tmp33 - } else { - tmp25 = v24 - } - return tmp25 - }) - tmp24 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5982), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(5982), lang.NewKeyword("end-column"), int(59)) - tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("cons")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("*pending-paths*")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.Apply(tmp28, []any{v3, tmp31}) - tmp33 := lang.Apply(tmp22, []any{tmp25, tmp32}) - var v34 any = tmp33 - _ = v34 - // let binding "chain" - tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp36 := tmp35.FindInternedVar(lang.NewSymbol("apply")) - if tmp36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) - } - tmp37 := tmp36.Get() - tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp39 := tmp38.FindInternedVar(lang.NewSymbol("str")) - if tmp39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) - } - tmp40 := tmp39.Get() - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("interpose")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.Apply(tmp43, []any{"->", v34}) - tmp45 := lang.Apply(tmp37, []any{tmp40, tmp44}) - var v46 any = tmp45 - _ = v46 - tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp48 := tmp47.FindInternedVar(lang.NewSymbol("throw-if")) - if tmp48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) - } - tmp49 := tmp48.Get() - tmp50 := lang.Apply(tmp49, []any{true, "Cyclic load dependency: %s", v46}) - tmp19 = tmp50 - } // end let - tmp4 = tmp19 - } else { - } - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // check-valid-options - { - tmp0 := lang.NewSymbol("check-valid-options").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("options"), lang.NewSymbol("&"), lang.NewSymbol("valid-keys"))), lang.NewKeyword("doc"), "Throws an exception if the given option map contains keys not listed\n as valid, else returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(35), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1709), lang.NewKeyword("end-line"), int(1709), lang.NewKeyword("private"), true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var v4 any = lang.NewList(args[1:]...) - _ = v4 - var tmp5 any - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("seq")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("apply")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("disj")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("apply")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("hash-set")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("keys")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.Apply(tmp23, []any{v3}) - tmp25 := lang.Apply(tmp17, []any{tmp20, tmp24}) - tmp26 := lang.Apply(tmp11, []any{tmp14, tmp25, v4}) - tmp27 := lang.Apply(tmp8, []any{tmp26}) - if lang.IsTruthy(tmp27) { - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("apply")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("str")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("first")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.Apply(tmp36, []any{v4}) - tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp39 := tmp38.FindInternedVar(lang.NewSymbol("map")) - if tmp39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) - } - tmp40 := tmp39.Get() - var tmp41 lang.FnFunc - tmp41 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v42 := args[0] - _ = v42 - tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp44 := tmp43.FindInternedVar(lang.NewSymbol("str")) - if tmp44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) - } - tmp45 := tmp44.Get() - tmp46 := lang.Apply(tmp45, []any{", ", v42}) - return tmp46 - }) - tmp42 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1718), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(1718), lang.NewKeyword("end-column"), int(28)) - tmp43, err := lang.WithMeta(tmp41, tmp42.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("rest")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.Apply(tmp46, []any{v4}) - tmp48 := lang.Apply(tmp40, []any{tmp43, tmp47}) - tmp49 := lang.Apply(tmp30, []any{tmp33, "Only these options are valid: ", tmp37, tmp48}) - tmp50 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp49}) - panic(tmp50) - } else { - } - return tmp5 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // chunk - { - tmp0 := lang.NewSymbol("chunk").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(691), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(691), lang.NewKeyword("end-column"), int(41), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("b"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4, ok := lang.FieldOrMethod(v3, "chunk") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "chunk"))) - } - var tmp5 any - switch reflect.TypeOf(tmp4).Kind() { - case reflect.Func: - tmp5 = lang.Apply(tmp4, nil) - default: - tmp5 = tmp4 - } - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // chunk-append - { - tmp0 := lang.NewSymbol("chunk-append").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(688), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(688), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("b"), lang.NewSymbol("x"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5, _ := lang.FieldOrMethod(v3, "add") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // chunk-buffer - { - tmp0 := lang.NewSymbol("chunk-buffer").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(685), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(685), lang.NewKeyword("end-column"), int(53), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("capacity"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.Apply(lang.NewChunkBuffer, []any{v3}) - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // chunk-cons - { - tmp0 := lang.NewSymbol("chunk-cons").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(703), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(703), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("chunk"), lang.NewSymbol("rest"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - tmp6 := lang.Apply(lang.Count, []any{v3}) - tmp7 := lang.Apply(lang.IsZero, []any{tmp6}) - if lang.IsTruthy(tmp7) { - tmp5 = v4 - } else { - tmp8 := lang.Apply(lang.NewChunkedCons, []any{v3, v4}) - tmp5 = tmp8 - } - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // chunk-first - { - tmp0 := lang.NewSymbol("chunk-first").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(694), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(694), lang.NewKeyword("end-column"), int(48), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4, ok := lang.FieldOrMethod(v3, "chunkedFirst") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "chunkedFirst"))) - } - var tmp5 any - switch reflect.TypeOf(tmp4).Kind() { - case reflect.Func: - tmp5 = lang.Apply(tmp4, nil) - default: - tmp5 = tmp4 - } - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // chunk-next - { - tmp0 := lang.NewSymbol("chunk-next").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(700), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(700), lang.NewKeyword("end-column"), int(71), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4, ok := lang.FieldOrMethod(v3, "chunkedNext") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "chunkedNext"))) - } - var tmp5 any - switch reflect.TypeOf(tmp4).Kind() { - case reflect.Func: - tmp5 = lang.Apply(tmp4, nil) - default: - tmp5 = tmp4 - } - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // chunk-rest - { - tmp0 := lang.NewSymbol("chunk-rest").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(697), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(697), lang.NewKeyword("end-column"), int(71), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4, ok := lang.FieldOrMethod(v3, "chunkedMore") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "chunkedMore"))) - } - var tmp5 any - switch reflect.TypeOf(tmp4).Kind() { - case reflect.Func: - tmp5 = lang.Apply(tmp4, nil) - default: - tmp5 = tmp4 - } - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // chunked-seq? - { - tmp0 := lang.NewSymbol("chunked-seq?").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(708), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(708), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := reflect.TypeOf((*lang.IChunkedSeq)(nil)).Elem() - tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) - return tmp8 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // class - { - tmp0 := lang.NewSymbol("class").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns the Class of x", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3461), lang.NewKeyword("end-line"), int(3461))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("nil?")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v3}) - if lang.IsTruthy(tmp8) { - tmp4 = v3 - } else { - tmp9 := lang.Apply(lang.TypeOf, []any{v3}) - tmp4 = tmp9 - } - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // class? - { - tmp0 := lang.NewSymbol("class?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is an instance of Class", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5465), lang.NewKeyword("end-line"), int(5465))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := reflect.TypeOf((*reflect.Type)(nil)).Elem() - tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) - return tmp8 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // clear-agent-errors - { - tmp0 := lang.NewSymbol("clear-agent-errors").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("doc"), "DEPRECATED: Use 'restart-agent' instead.\n Clears any exceptions thrown during asynchronous actions of the\n agent, allowing subsequent actions to occur.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("deprecated"), "1.2", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2244), lang.NewKeyword("end-line"), int(2244))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("restart-agent")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7, ok := lang.FieldOrMethod(v3, "Deref") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "Deref"))) - } - var tmp8 any - switch reflect.TypeOf(tmp7).Kind() { - case reflect.Func: - tmp8 = lang.Apply(tmp7, nil) - default: - tmp8 = tmp7 - } - tmp9 := lang.Apply(tmp6, []any{v3, tmp8}) - return tmp9 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // coll? - { - tmp0 := lang.NewSymbol("coll?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements IPersistentCollection", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6192), lang.NewKeyword("end-line"), int(6192))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := reflect.TypeOf((*lang.IPersistentCollection)(nil)).Elem() - tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) - return tmp8 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // comment - { - tmp0 := lang.NewSymbol("comment").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Ignores body, yields nil", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4733), lang.NewKeyword("end-line"), int(4733))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - return nil - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // commute - { - tmp0 := lang.NewSymbol("commute").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("fun"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Must be called in a transaction. Sets the in-transaction-value of\n ref to:\n\n (apply fun in-transaction-value-of-ref args)\n\n and returns the in-transaction-value of ref.\n\n At the commit point of the transaction, sets the value of ref to be:\n\n (apply fun most-recently-committed-value-of-ref args)\n\n Thus fun should be commutative, or, failing that, you must accept\n last-one-in-wins behavior. commute allows for more concurrency than\n ref-set.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2414), lang.NewKeyword("end-line"), int(2414))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - tmp6, _ := lang.FieldOrMethod(v3, "Commute") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Commute is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // comp - { - tmp0 := lang.NewSymbol("comp").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("g")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("g"), lang.NewSymbol("&"), lang.NewSymbol("fs"))), lang.NewKeyword("doc"), "Takes a set of functions and returns a fn that is the composition\n of those fns. The returned fn takes a variable number of args,\n applies the rightmost of fns to the args, the next\n fn (right-to-left) to the result, etc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2549), lang.NewKeyword("end-line"), int(2549))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp4 := tmp3.FindInternedVar(lang.NewSymbol("identity")) - if tmp4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp4))) - } - tmp5 := tmp4.Get() - return tmp5 - case 1: - v3 := args[0] - _ = v3 - return v3 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 lang.FnFunc - tmp5 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp6 := lang.Apply(v4, nil) - tmp7 := lang.Apply(v3, []any{tmp6}) - return tmp7 - case 1: - v6 := args[0] - _ = v6 - tmp7 := lang.Apply(v4, []any{v6}) - tmp8 := lang.Apply(v3, []any{tmp7}) - return tmp8 - case 2: - v6 := args[0] - _ = v6 - v7 := args[1] - _ = v7 - tmp8 := lang.Apply(v4, []any{v6, v7}) - tmp9 := lang.Apply(v3, []any{tmp8}) - return tmp9 - case 3: - v6 := args[0] - _ = v6 - v7 := args[1] - _ = v7 - v8 := args[2] - _ = v8 - tmp9 := lang.Apply(v4, []any{v6, v7, v8}) - tmp10 := lang.Apply(v3, []any{tmp9}) - return tmp10 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v6 := args[0] - _ = v6 - v7 := args[1] - _ = v7 - v8 := args[2] - _ = v8 - var v9 any = lang.NewList(args[3:]...) - _ = v9 - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("apply")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{v4, v6, v7, v8, v9}) - tmp14 := lang.Apply(v3, []any{tmp13}) - return tmp14 - } - }) - tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2559), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2564), lang.NewKeyword("end-column"), int(49)) - tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp7 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("comp")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("list*")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.Apply(tmp14, []any{v3, v4, v5}) - tmp16 := lang.Apply(tmp8, []any{tmp11, tmp15}) - return tmp16 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // comparator - { - tmp0 := lang.NewSymbol("comparator").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"))), lang.NewKeyword("doc"), "Returns an implementation of java.util.Comparator based upon pred.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3077), lang.NewKeyword("end-line"), int(3077))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - var tmp7 any - tmp8 := lang.Apply(v3, []any{v5, v6}) - if lang.IsTruthy(tmp8) { - tmp7 = int64(-1) - } else { - var tmp9 any - tmp10 := lang.Apply(v3, []any{v6, v5}) - if lang.IsTruthy(tmp10) { - tmp9 = int64(1) - } else { - var tmp11 any - if lang.IsTruthy(lang.NewKeyword("else")) { - tmp11 = int64(0) - } else { - } - tmp9 = tmp11 - } - tmp7 = tmp9 - } - return tmp7 - }) - tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3082), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(3083), lang.NewKeyword("end-column"), int(48)) - tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp6 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // compare - { - var tmp1 lang.FnFunc - { // function compare__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("concat")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("list")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol(".")}) - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("glojure.lang.Util")}) - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("glojure.core/compare")}) - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.Apply(tmp25, []any{v3}) - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{v4}) - tmp31 := lang.Apply(tmp10, []any{tmp14, tmp18, tmp22, tmp26, tmp30}) - tmp32 := lang.Apply(tmp7, []any{tmp31}) - return tmp32 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("compare").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Comparator. Returns a negative number, zero, or a positive number\n when x is logically 'less than', 'equal to', or 'greater than'\n y. Same as Java x.compareTo(y) except it also works for nil, and\n compares numbers and collections in a type-independent manner. x\n must implement Comparable", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(824), lang.NewKeyword("end-line"), int(824))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6 := lang.Apply(lang.Compare, []any{v4, v5}) - return tmp6 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // compare-and-set! - { - tmp0 := lang.NewSymbol("compare-and-set!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atom"), lang.NewSymbol("oldval"), lang.NewSymbol("newval"))), lang.NewKeyword("doc"), "Atomically sets the value of atom to newval if and only if the\n current value of the atom is identical to oldval. Returns true if\n set happened, else false", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2360), lang.NewKeyword("end-line"), int(2360))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6, _ := lang.FieldOrMethod(v3, "compareAndSet") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("compareAndSet is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // compile - { - tmp0 := lang.NewSymbol("compile").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"))), lang.NewKeyword("doc"), "Compiles the namespace named by the symbol lib into a set of\n classfiles. The source for the lib must be in a proper\n classpath-relative directory. The output files will go into the\n directory specified by *compile-path*, and that directory too must\n be in the classpath.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6114), lang.NewKeyword("end-line"), int(6114))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - { // let - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("push-thread-bindings")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("hash-map")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*compile-files*")) - tmp12 := lang.Apply(tmp10, []any{tmp11, true}) - tmp13 := lang.Apply(tmp7, []any{tmp12}) - _ = tmp13 - var tmp14 any - func() { - defer func() { - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, nil) - _ = tmp18 - }() - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("load-one")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, []any{v3, true, true}) - tmp14 = tmp22 - }() - tmp4 = tmp14 - } // end let - _ = tmp4 - return v3 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // complement - { - tmp0 := lang.NewSymbol("complement").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Takes a fn f and returns a fn that takes the same arguments as f,\n has the same effects, if any, and returns the opposite truth value.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1428), lang.NewKeyword("end-line"), int(1428))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("not")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(v3, nil) - tmp9 := lang.Apply(tmp7, []any{tmp8}) - return tmp9 - case 1: - v5 := args[0] - _ = v5 - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("not")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(v3, []any{v5}) - tmp10 := lang.Apply(tmp8, []any{tmp9}) - return tmp10 - case 2: - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("not")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(v3, []any{v5, v6}) - tmp11 := lang.Apply(tmp9, []any{tmp10}) - return tmp11 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - var v7 any = lang.NewList(args[2:]...) - _ = v7 - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("not")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("apply")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{v3, v5, v6, v7}) - tmp15 := lang.Apply(tmp10, []any{tmp14}) - return tmp15 - } - }) - tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1434), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(1438), lang.NewKeyword("end-column"), int(40)) - tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp6 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // completing - { - tmp0 := lang.NewSymbol("completing").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("cf"))), lang.NewKeyword("doc"), "Takes a reducing function f of 2 args and returns a fn suitable for\n transduce by adding an arity-1 signature that calls cf (default -\n identity) on the result argument.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6893), lang.NewKeyword("end-line"), int(6893))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("completing")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("identity")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp6, []any{v3, tmp9}) - return tmp10 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 lang.FnFunc - tmp5 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp6 := lang.Apply(v3, nil) - return tmp6 - case 1: - v6 := args[0] - _ = v6 - tmp7 := lang.Apply(v4, []any{v6}) - return tmp7 - case 2: - v6 := args[0] - _ = v6 - v7 := args[1] - _ = v7 - tmp8 := lang.Apply(v3, []any{v6, v7}) - return tmp8 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6900), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(6903), lang.NewKeyword("end-column"), int(23)) - tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp7 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // concat - { - tmp0 := lang.NewSymbol("concat").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("zs"))), lang.NewKeyword("doc"), "Returns a lazy seq representing the concatenation of the elements in the supplied colls.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(711), lang.NewKeyword("end-line"), int(711))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - return nil - }) - tmp4 := lang.Apply(lang.NewLazySeq, []any{tmp3}) - return tmp4 - case 1: - v3 := args[0] - _ = v3 - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - return v3 - }) - tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) - return tmp5 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 lang.FnFunc - tmp5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var tmp6 any - { // let - // let binding "s" - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("seq")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp9, []any{v3}) - var v11 any = tmp10 - _ = v11 - var tmp12 any - if lang.IsTruthy(v11) { - var tmp13 any - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("chunked-seq?")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{v11}) - if lang.IsTruthy(tmp17) { - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("chunk-cons")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("chunk-first")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.Apply(tmp23, []any{v11}) - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("concat")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("chunk-rest")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.Apply(tmp30, []any{v11}) - tmp32 := lang.Apply(tmp27, []any{tmp31, v4}) - tmp33 := lang.Apply(tmp20, []any{tmp24, tmp32}) - tmp13 = tmp33 - } else { - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("cons")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("first")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.Apply(tmp39, []any{v11}) - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("concat")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("rest")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.Apply(tmp46, []any{v11}) - tmp48 := lang.Apply(tmp43, []any{tmp47, v4}) - tmp49 := lang.Apply(tmp36, []any{tmp40, tmp48}) - tmp13 = tmp49 - } - tmp12 = tmp13 - } else { - tmp12 = v4 - } - tmp6 = tmp12 - } // end let - return tmp6 - }) - tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) - return tmp6 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - var tmp6 any - { // let - // let binding "cat" - var tmp7 lang.FnFunc - { // function cat - var v8 lang.FnFunc - tmp7 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v9 := args[0] - _ = v9 - v10 := args[1] - _ = v10 - var tmp11 lang.FnFunc - tmp11 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var tmp12 any - { // let - // let binding "xys" - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("seq")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{v9}) - var v17 any = tmp16 - _ = v17 - var tmp18 any - if lang.IsTruthy(v17) { - var tmp19 any - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("chunked-seq?")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.Apply(tmp22, []any{v17}) - if lang.IsTruthy(tmp23) { - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("chunk-cons")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("chunk-first")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{v17}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("chunk-rest")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{v17}) - tmp35 := lang.Apply(v8, []any{tmp34, v10}) - tmp36 := lang.Apply(tmp26, []any{tmp30, tmp35}) - tmp19 = tmp36 - } else { - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("cons")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("first")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.Apply(tmp42, []any{v17}) - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("rest")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.Apply(tmp46, []any{v17}) - tmp48 := lang.Apply(v8, []any{tmp47, v10}) - tmp49 := lang.Apply(tmp39, []any{tmp43, tmp48}) - tmp19 = tmp49 - } - tmp18 = tmp19 - } else { - var tmp50 any - if lang.IsTruthy(v10) { - tmp51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp52 := tmp51.FindInternedVar(lang.NewSymbol("first")) - if tmp52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp52))) - } - tmp53 := tmp52.Get() - tmp54 := lang.Apply(tmp53, []any{v10}) - tmp55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp56 := tmp55.FindInternedVar(lang.NewSymbol("next")) - if tmp56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp56))) - } - tmp57 := tmp56.Get() - tmp58 := lang.Apply(tmp57, []any{v10}) - tmp59 := lang.Apply(v8, []any{tmp54, tmp58}) - tmp50 = tmp59 - } else { - } - tmp18 = tmp50 - } - tmp12 = tmp18 - } // end let - return tmp12 - }) - tmp12 := lang.Apply(lang.NewLazySeq, []any{tmp11}) - return tmp12 - }) - v8 = tmp7 - _ = v8 - } - tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(726), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(735), lang.NewKeyword("end-column"), int(56)) - tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v10 any = tmp9 - _ = v10 - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("concat")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{v3, v4}) - tmp15 := lang.Apply(v10, []any{tmp14, v5}) - tmp6 = tmp15 - } // end let - return tmp6 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // cond - { - tmp0 := lang.NewSymbol("cond").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes a set of test/expr pairs. It evaluates each test one at a\n time. If a test returns logical true, cond evaluates and returns\n the value of the corresponding expr and doesn't evaluate any of the\n other tests or exprs. (cond) returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(569), lang.NewKeyword("end-line"), int(569))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - var tmp6 any - if lang.IsTruthy(v5) { - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("list")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("first")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{v5}) - var tmp14 any - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("next")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{v5}) - if lang.IsTruthy(tmp18) { - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("second")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, []any{v5}) - tmp14 = tmp22 - } else { - tmp23 := lang.Apply(lang.NewIllegalArgumentError, []any{"cond requires an even number of forms"}) - panic(tmp23) - } - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("cons")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("next")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("next")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.Apply(tmp32, []any{v5}) - tmp34 := lang.Apply(tmp29, []any{tmp33}) - tmp35 := lang.Apply(tmp26, []any{lang.NewSymbol("glojure.core/cond"), tmp34}) - tmp36 := lang.Apply(tmp9, []any{lang.NewSymbol("if"), tmp13, tmp14, tmp35}) - tmp6 = tmp36 - } else { - } - return tmp6 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // cond-> - { - tmp0 := lang.NewSymbol("cond->").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes an expression and a set of test/form pairs. Threads expr (via ->)\n through each form for which the corresponding test\n expression is true. Note that, unlike cond branching, cond-> threading does\n not short circuit after the first true test expression.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7564), lang.NewKeyword("end-line"), int(7564))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any - { // let - // let binding "g" - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("gensym")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, nil) - var v12 any = tmp11 - _ = v12 - // let binding "steps" - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("map")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - var tmp16 lang.FnFunc - tmp16 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v17 := args[0] - _ = v17 - var tmp18 any - { // let - // let binding "vec__337" - var v19 any = v17 - _ = v19 - // let binding "test" - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("nth")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.Apply(tmp22, []any{v19, int64(0), nil}) - var v24 any = tmp23 - _ = v24 - // let binding "step" - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("nth")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.Apply(tmp27, []any{v19, int64(1), nil}) - var v29 any = tmp28 - _ = v29 - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("seq")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("concat")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{lang.NewSymbol("if")}) - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.Apply(tmp42, []any{v24}) - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp48 := tmp47.FindInternedVar(lang.NewSymbol("seq")) - if tmp48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) - } - tmp49 := tmp48.Get() - tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp51 := tmp50.FindInternedVar(lang.NewSymbol("concat")) - if tmp51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) - } - tmp52 := tmp51.Get() - tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp54 := tmp53.FindInternedVar(lang.NewSymbol("list")) - if tmp54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) - } - tmp55 := tmp54.Get() - tmp56 := lang.Apply(tmp55, []any{lang.NewSymbol("glojure.core/->")}) - tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp58 := tmp57.FindInternedVar(lang.NewSymbol("list")) - if tmp58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) - } - tmp59 := tmp58.Get() - tmp60 := lang.Apply(tmp59, []any{v12}) - tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp62 := tmp61.FindInternedVar(lang.NewSymbol("list")) - if tmp62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) - } - tmp63 := tmp62.Get() - tmp64 := lang.Apply(tmp63, []any{v29}) - tmp65 := lang.Apply(tmp52, []any{tmp56, tmp60, tmp64}) - tmp66 := lang.Apply(tmp49, []any{tmp65}) - tmp67 := lang.Apply(tmp46, []any{tmp66}) - tmp68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp69 := tmp68.FindInternedVar(lang.NewSymbol("list")) - if tmp69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp69))) - } - tmp70 := tmp69.Get() - tmp71 := lang.Apply(tmp70, []any{v12}) - tmp72 := lang.Apply(tmp35, []any{tmp39, tmp43, tmp67, tmp71}) - tmp73 := lang.Apply(tmp32, []any{tmp72}) - tmp18 = tmp73 - } // end let - return tmp18 - }) - tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7573), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7573), lang.NewKeyword("end-column"), int(66)) - tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("partition")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, []any{int64(2), v6}) - tmp23 := lang.Apply(tmp15, []any{tmp18, tmp22}) - var v24 any = tmp23 - _ = v24 - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("seq")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("concat")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{lang.NewSymbol("glojure.core/let")}) - tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp36 := tmp35.FindInternedVar(lang.NewSymbol("list")) - if tmp36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) - } - tmp37 := tmp36.Get() - tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp39 := tmp38.FindInternedVar(lang.NewSymbol("apply")) - if tmp39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) - } - tmp40 := tmp39.Get() - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("vector")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("seq")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp48 := tmp47.FindInternedVar(lang.NewSymbol("concat")) - if tmp48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) - } - tmp49 := tmp48.Get() - tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp51 := tmp50.FindInternedVar(lang.NewSymbol("list")) - if tmp51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) - } - tmp52 := tmp51.Get() - tmp53 := lang.Apply(tmp52, []any{v12}) - tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp55 := tmp54.FindInternedVar(lang.NewSymbol("list")) - if tmp55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) - } - tmp56 := tmp55.Get() - tmp57 := lang.Apply(tmp56, []any{v5}) - tmp58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp59 := tmp58.FindInternedVar(lang.NewSymbol("interleave")) - if tmp59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp59))) - } - tmp60 := tmp59.Get() - tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp62 := tmp61.FindInternedVar(lang.NewSymbol("repeat")) - if tmp62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) - } - tmp63 := tmp62.Get() - tmp64 := lang.Apply(tmp63, []any{v12}) - tmp65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp66 := tmp65.FindInternedVar(lang.NewSymbol("butlast")) - if tmp66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp66))) - } - tmp67 := tmp66.Get() - tmp68 := lang.Apply(tmp67, []any{v24}) - tmp69 := lang.Apply(tmp60, []any{tmp64, tmp68}) - tmp70 := lang.Apply(tmp49, []any{tmp53, tmp57, tmp69}) - tmp71 := lang.Apply(tmp46, []any{tmp70}) - tmp72 := lang.Apply(tmp40, []any{tmp43, tmp71}) - tmp73 := lang.Apply(tmp37, []any{tmp72}) - tmp74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp75 := tmp74.FindInternedVar(lang.NewSymbol("list")) - if tmp75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp75))) - } - tmp76 := tmp75.Get() - var tmp77 any - tmp78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp79 := tmp78.FindInternedVar(lang.NewSymbol("empty?")) - if tmp79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp79))) - } - tmp80 := tmp79.Get() - tmp81 := lang.Apply(tmp80, []any{v24}) - if lang.IsTruthy(tmp81) { - tmp77 = v12 - } else { - tmp82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp83 := tmp82.FindInternedVar(lang.NewSymbol("last")) - if tmp83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp83))) - } - tmp84 := tmp83.Get() - tmp85 := lang.Apply(tmp84, []any{v24}) - tmp77 = tmp85 - } - tmp86 := lang.Apply(tmp76, []any{tmp77}) - tmp87 := lang.Apply(tmp30, []any{tmp34, tmp73, tmp86}) - tmp88 := lang.Apply(tmp27, []any{tmp87}) - tmp7 = tmp88 - } // end let - return tmp7 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // cond->> - { - tmp0 := lang.NewSymbol("cond->>").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes an expression and a set of test/form pairs. Threads expr (via ->>)\n through each form for which the corresponding test expression\n is true. Note that, unlike cond branching, cond->> threading does not short circuit\n after the first true test expression.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7581), lang.NewKeyword("end-line"), int(7581))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any - { // let - // let binding "g" - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("gensym")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, nil) - var v12 any = tmp11 - _ = v12 - // let binding "steps" - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("map")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - var tmp16 lang.FnFunc - tmp16 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v17 := args[0] - _ = v17 - var tmp18 any - { // let - // let binding "vec__341" - var v19 any = v17 - _ = v19 - // let binding "test" - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("nth")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.Apply(tmp22, []any{v19, int64(0), nil}) - var v24 any = tmp23 - _ = v24 - // let binding "step" - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("nth")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.Apply(tmp27, []any{v19, int64(1), nil}) - var v29 any = tmp28 - _ = v29 - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("seq")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("concat")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{lang.NewSymbol("if")}) - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.Apply(tmp42, []any{v24}) - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp48 := tmp47.FindInternedVar(lang.NewSymbol("seq")) - if tmp48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) - } - tmp49 := tmp48.Get() - tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp51 := tmp50.FindInternedVar(lang.NewSymbol("concat")) - if tmp51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) - } - tmp52 := tmp51.Get() - tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp54 := tmp53.FindInternedVar(lang.NewSymbol("list")) - if tmp54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) - } - tmp55 := tmp54.Get() - tmp56 := lang.Apply(tmp55, []any{lang.NewSymbol("glojure.core/->>")}) - tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp58 := tmp57.FindInternedVar(lang.NewSymbol("list")) - if tmp58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) - } - tmp59 := tmp58.Get() - tmp60 := lang.Apply(tmp59, []any{v12}) - tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp62 := tmp61.FindInternedVar(lang.NewSymbol("list")) - if tmp62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) - } - tmp63 := tmp62.Get() - tmp64 := lang.Apply(tmp63, []any{v29}) - tmp65 := lang.Apply(tmp52, []any{tmp56, tmp60, tmp64}) - tmp66 := lang.Apply(tmp49, []any{tmp65}) - tmp67 := lang.Apply(tmp46, []any{tmp66}) - tmp68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp69 := tmp68.FindInternedVar(lang.NewSymbol("list")) - if tmp69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp69))) - } - tmp70 := tmp69.Get() - tmp71 := lang.Apply(tmp70, []any{v12}) - tmp72 := lang.Apply(tmp35, []any{tmp39, tmp43, tmp67, tmp71}) - tmp73 := lang.Apply(tmp32, []any{tmp72}) - tmp18 = tmp73 - } // end let - return tmp18 - }) - tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7590), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7590), lang.NewKeyword("end-column"), int(67)) - tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("partition")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, []any{int64(2), v6}) - tmp23 := lang.Apply(tmp15, []any{tmp18, tmp22}) - var v24 any = tmp23 - _ = v24 - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("seq")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("concat")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{lang.NewSymbol("glojure.core/let")}) - tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp36 := tmp35.FindInternedVar(lang.NewSymbol("list")) - if tmp36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) - } - tmp37 := tmp36.Get() - tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp39 := tmp38.FindInternedVar(lang.NewSymbol("apply")) - if tmp39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) - } - tmp40 := tmp39.Get() - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("vector")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("seq")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp48 := tmp47.FindInternedVar(lang.NewSymbol("concat")) - if tmp48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) - } - tmp49 := tmp48.Get() - tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp51 := tmp50.FindInternedVar(lang.NewSymbol("list")) - if tmp51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) - } - tmp52 := tmp51.Get() - tmp53 := lang.Apply(tmp52, []any{v12}) - tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp55 := tmp54.FindInternedVar(lang.NewSymbol("list")) - if tmp55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) - } - tmp56 := tmp55.Get() - tmp57 := lang.Apply(tmp56, []any{v5}) - tmp58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp59 := tmp58.FindInternedVar(lang.NewSymbol("interleave")) - if tmp59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp59))) - } - tmp60 := tmp59.Get() - tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp62 := tmp61.FindInternedVar(lang.NewSymbol("repeat")) - if tmp62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) - } - tmp63 := tmp62.Get() - tmp64 := lang.Apply(tmp63, []any{v12}) - tmp65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp66 := tmp65.FindInternedVar(lang.NewSymbol("butlast")) - if tmp66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp66))) - } - tmp67 := tmp66.Get() - tmp68 := lang.Apply(tmp67, []any{v24}) - tmp69 := lang.Apply(tmp60, []any{tmp64, tmp68}) - tmp70 := lang.Apply(tmp49, []any{tmp53, tmp57, tmp69}) - tmp71 := lang.Apply(tmp46, []any{tmp70}) - tmp72 := lang.Apply(tmp40, []any{tmp43, tmp71}) - tmp73 := lang.Apply(tmp37, []any{tmp72}) - tmp74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp75 := tmp74.FindInternedVar(lang.NewSymbol("list")) - if tmp75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp75))) - } - tmp76 := tmp75.Get() - var tmp77 any - tmp78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp79 := tmp78.FindInternedVar(lang.NewSymbol("empty?")) - if tmp79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp79))) - } - tmp80 := tmp79.Get() - tmp81 := lang.Apply(tmp80, []any{v24}) - if lang.IsTruthy(tmp81) { - tmp77 = v12 - } else { - tmp82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp83 := tmp82.FindInternedVar(lang.NewSymbol("last")) - if tmp83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp83))) - } - tmp84 := tmp83.Get() - tmp85 := lang.Apply(tmp84, []any{v24}) - tmp77 = tmp85 - } - tmp86 := lang.Apply(tmp76, []any{tmp77}) - tmp87 := lang.Apply(tmp30, []any{tmp34, tmp73, tmp86}) - tmp88 := lang.Apply(tmp27, []any{tmp87}) - tmp7 = tmp88 - } // end let - return tmp7 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // condp - { - tmp0 := lang.NewSymbol("condp").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes a binary predicate, an expression, and a set of clauses.\n Each clause can take the form of either:\n\n test-expr result-expr\n\n test-expr :>> result-fn\n\n Note :>> is an ordinary keyword.\n\n For each clause, (pred test-expr expr) is evaluated. If it returns\n logical true, the clause is a match. If a binary clause matches, the\n result-expr is returned, if a ternary clause matches, its result-fn,\n which must be a unary function, is called with the result of the\n predicate as its argument, the result of that call being the return\n value of condp. A single default expression can follow the clauses,\n and its value will be returned if no clause matches. If no default\n expression is provided and no clause matches, an\n IllegalArgumentException is thrown.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6353), lang.NewKeyword("end-line"), int(6353))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - var v7 any = lang.NewList(args[4:]...) - _ = v7 - var tmp8 any - { // let - // let binding "gpred" - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("gensym")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.Apply(tmp11, []any{"pred__"}) - var v13 any = tmp12 - _ = v13 - // let binding "gexpr" - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("gensym")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{"expr__"}) - var v18 any = tmp17 - _ = v18 - // let binding "emit" - var tmp19 lang.FnFunc - { // function emit - var v20 lang.FnFunc - tmp19 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v21 := args[0] - _ = v21 - v22 := args[1] - _ = v22 - v23 := args[2] - _ = v23 - var tmp24 any - { // let - // let binding "vec__144" - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("split-at")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - var tmp28 any - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("=")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("second")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.Apply(tmp34, []any{v23}) - tmp36 := lang.Apply(tmp31, []any{lang.NewKeyword(">>"), tmp35}) - if lang.IsTruthy(tmp36) { - tmp28 = int64(3) - } else { - tmp28 = int64(2) - } - tmp37 := lang.Apply(tmp27, []any{tmp28, v23}) - var v38 any = tmp37 - _ = v38 - // let binding "vec__147" - tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp40 := tmp39.FindInternedVar(lang.NewSymbol("nth")) - if tmp40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) - } - tmp41 := tmp40.Get() - tmp42 := lang.Apply(tmp41, []any{v38, int64(0), nil}) - var v43 any = tmp42 - _ = v43 - // let binding "a" - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("nth")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.Apply(tmp46, []any{v43, int64(0), nil}) - var v48 any = tmp47 - _ = v48 - // let binding "b" - tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp50 := tmp49.FindInternedVar(lang.NewSymbol("nth")) - if tmp50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) - } - tmp51 := tmp50.Get() - tmp52 := lang.Apply(tmp51, []any{v43, int64(1), nil}) - var v53 any = tmp52 - _ = v53 - // let binding "c" - tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp55 := tmp54.FindInternedVar(lang.NewSymbol("nth")) - if tmp55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) - } - tmp56 := tmp55.Get() - tmp57 := lang.Apply(tmp56, []any{v43, int64(2), nil}) - var v58 any = tmp57 - _ = v58 - // let binding "clause" - var v59 any = v43 - _ = v59 - // let binding "more" - tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp61 := tmp60.FindInternedVar(lang.NewSymbol("nth")) - if tmp61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) - } - tmp62 := tmp61.Get() - tmp63 := lang.Apply(tmp62, []any{v38, int64(1), nil}) - var v64 any = tmp63 - _ = v64 - // let binding "n" - tmp65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp66 := tmp65.FindInternedVar(lang.NewSymbol("count")) - if tmp66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp66))) - } - tmp67 := tmp66.Get() - tmp68 := lang.Apply(tmp67, []any{v59}) - var v69 any = tmp68 - _ = v69 - var tmp70 any - tmp71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp72 := tmp71.FindInternedVar(lang.NewSymbol("=")) - if tmp72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp72))) - } - tmp73 := tmp72.Get() - tmp74 := lang.Apply(tmp73, []any{int64(0), v69}) - if lang.IsTruthy(tmp74) { - tmp75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp76 := tmp75.FindInternedVar(lang.NewSymbol("seq")) - if tmp76.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp76))) - } - tmp77 := tmp76.Get() - tmp78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp79 := tmp78.FindInternedVar(lang.NewSymbol("concat")) - if tmp79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp79))) - } - tmp80 := tmp79.Get() - tmp81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp82 := tmp81.FindInternedVar(lang.NewSymbol("list")) - if tmp82.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp82))) - } - tmp83 := tmp82.Get() - tmp84 := lang.Apply(tmp83, []any{lang.NewSymbol("throw")}) - tmp85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp86 := tmp85.FindInternedVar(lang.NewSymbol("list")) - if tmp86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp86))) - } - tmp87 := tmp86.Get() - tmp88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp89 := tmp88.FindInternedVar(lang.NewSymbol("seq")) - if tmp89.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp89))) - } - tmp90 := tmp89.Get() - tmp91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp92 := tmp91.FindInternedVar(lang.NewSymbol("concat")) - if tmp92.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp92))) - } - tmp93 := tmp92.Get() - tmp94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp95 := tmp94.FindInternedVar(lang.NewSymbol("list")) - if tmp95.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp95))) - } - tmp96 := tmp95.Get() - tmp97 := lang.Apply(tmp96, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewIllegalArgumentError")}) - tmp98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp99 := tmp98.FindInternedVar(lang.NewSymbol("list")) - if tmp99.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp99))) - } - tmp100 := tmp99.Get() - tmp101 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp102 := tmp101.FindInternedVar(lang.NewSymbol("seq")) - if tmp102.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp102))) - } - tmp103 := tmp102.Get() - tmp104 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp105 := tmp104.FindInternedVar(lang.NewSymbol("concat")) - if tmp105.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp105))) - } - tmp106 := tmp105.Get() - tmp107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp108 := tmp107.FindInternedVar(lang.NewSymbol("list")) - if tmp108.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp108))) - } - tmp109 := tmp108.Get() - tmp110 := lang.Apply(tmp109, []any{lang.NewSymbol("glojure.core/str")}) - tmp111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp112 := tmp111.FindInternedVar(lang.NewSymbol("list")) - if tmp112.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp112))) - } - tmp113 := tmp112.Get() - tmp114 := lang.Apply(tmp113, []any{"No matching clause: "}) - tmp115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp116 := tmp115.FindInternedVar(lang.NewSymbol("list")) - if tmp116.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp116))) - } - tmp117 := tmp116.Get() - tmp118 := lang.Apply(tmp117, []any{v22}) - tmp119 := lang.Apply(tmp106, []any{tmp110, tmp114, tmp118}) - tmp120 := lang.Apply(tmp103, []any{tmp119}) - tmp121 := lang.Apply(tmp100, []any{tmp120}) - tmp122 := lang.Apply(tmp93, []any{tmp97, tmp121}) - tmp123 := lang.Apply(tmp90, []any{tmp122}) - tmp124 := lang.Apply(tmp87, []any{tmp123}) - tmp125 := lang.Apply(tmp80, []any{tmp84, tmp124}) - tmp126 := lang.Apply(tmp77, []any{tmp125}) - tmp70 = tmp126 - } else { - var tmp127 any - tmp128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp129 := tmp128.FindInternedVar(lang.NewSymbol("=")) - if tmp129.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp129))) - } - tmp130 := tmp129.Get() - tmp131 := lang.Apply(tmp130, []any{int64(1), v69}) - if lang.IsTruthy(tmp131) { - tmp127 = v48 - } else { - var tmp132 any - tmp133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp134 := tmp133.FindInternedVar(lang.NewSymbol("=")) - if tmp134.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp134))) - } - tmp135 := tmp134.Get() - tmp136 := lang.Apply(tmp135, []any{int64(2), v69}) - if lang.IsTruthy(tmp136) { - tmp137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp138 := tmp137.FindInternedVar(lang.NewSymbol("seq")) - if tmp138.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp138))) - } - tmp139 := tmp138.Get() - tmp140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp141 := tmp140.FindInternedVar(lang.NewSymbol("concat")) - if tmp141.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp141))) - } - tmp142 := tmp141.Get() - tmp143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp144 := tmp143.FindInternedVar(lang.NewSymbol("list")) - if tmp144.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp144))) - } - tmp145 := tmp144.Get() - tmp146 := lang.Apply(tmp145, []any{lang.NewSymbol("if")}) - tmp147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp148 := tmp147.FindInternedVar(lang.NewSymbol("list")) - if tmp148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp148))) - } - tmp149 := tmp148.Get() - tmp150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp151 := tmp150.FindInternedVar(lang.NewSymbol("seq")) - if tmp151.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp151))) - } - tmp152 := tmp151.Get() - tmp153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp154 := tmp153.FindInternedVar(lang.NewSymbol("concat")) - if tmp154.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp154))) - } - tmp155 := tmp154.Get() - tmp156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp157 := tmp156.FindInternedVar(lang.NewSymbol("list")) - if tmp157.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp157))) - } - tmp158 := tmp157.Get() - tmp159 := lang.Apply(tmp158, []any{v21}) - tmp160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp161 := tmp160.FindInternedVar(lang.NewSymbol("list")) - if tmp161.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp161))) - } - tmp162 := tmp161.Get() - tmp163 := lang.Apply(tmp162, []any{v48}) - tmp164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp165 := tmp164.FindInternedVar(lang.NewSymbol("list")) - if tmp165.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp165))) - } - tmp166 := tmp165.Get() - tmp167 := lang.Apply(tmp166, []any{v22}) - tmp168 := lang.Apply(tmp155, []any{tmp159, tmp163, tmp167}) - tmp169 := lang.Apply(tmp152, []any{tmp168}) - tmp170 := lang.Apply(tmp149, []any{tmp169}) - tmp171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp172 := tmp171.FindInternedVar(lang.NewSymbol("list")) - if tmp172.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp172))) - } - tmp173 := tmp172.Get() - tmp174 := lang.Apply(tmp173, []any{v53}) - tmp175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp176 := tmp175.FindInternedVar(lang.NewSymbol("list")) - if tmp176.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp176))) - } - tmp177 := tmp176.Get() - tmp178 := lang.Apply(v20, []any{v21, v22, v64}) - tmp179 := lang.Apply(tmp177, []any{tmp178}) - tmp180 := lang.Apply(tmp142, []any{tmp146, tmp170, tmp174, tmp179}) - tmp181 := lang.Apply(tmp139, []any{tmp180}) - tmp132 = tmp181 - } else { - var tmp182 any - if lang.IsTruthy(lang.NewKeyword("else")) { - tmp183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp184 := tmp183.FindInternedVar(lang.NewSymbol("seq")) - if tmp184.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp184))) - } - tmp185 := tmp184.Get() - tmp186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp187 := tmp186.FindInternedVar(lang.NewSymbol("concat")) - if tmp187.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp187))) - } - tmp188 := tmp187.Get() - tmp189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp190 := tmp189.FindInternedVar(lang.NewSymbol("list")) - if tmp190.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp190))) - } - tmp191 := tmp190.Get() - tmp192 := lang.Apply(tmp191, []any{lang.NewSymbol("glojure.core/if-let")}) - tmp193 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp194 := tmp193.FindInternedVar(lang.NewSymbol("list")) - if tmp194.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp194))) - } - tmp195 := tmp194.Get() - tmp196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp197 := tmp196.FindInternedVar(lang.NewSymbol("apply")) - if tmp197.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp197))) - } - tmp198 := tmp197.Get() - tmp199 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp200 := tmp199.FindInternedVar(lang.NewSymbol("vector")) - if tmp200.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp200))) - } - tmp201 := tmp200.Get() - tmp202 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp203 := tmp202.FindInternedVar(lang.NewSymbol("seq")) - if tmp203.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp203))) - } - tmp204 := tmp203.Get() - tmp205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp206 := tmp205.FindInternedVar(lang.NewSymbol("concat")) - if tmp206.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp206))) - } - tmp207 := tmp206.Get() - tmp208 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp209 := tmp208.FindInternedVar(lang.NewSymbol("list")) - if tmp209.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp209))) - } - tmp210 := tmp209.Get() - tmp211 := lang.Apply(tmp210, []any{lang.NewSymbol("p__0__auto__")}) - tmp212 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp213 := tmp212.FindInternedVar(lang.NewSymbol("list")) - if tmp213.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp213))) - } - tmp214 := tmp213.Get() - tmp215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp216 := tmp215.FindInternedVar(lang.NewSymbol("seq")) - if tmp216.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp216))) - } - tmp217 := tmp216.Get() - tmp218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp219 := tmp218.FindInternedVar(lang.NewSymbol("concat")) - if tmp219.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp219))) - } - tmp220 := tmp219.Get() - tmp221 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp222 := tmp221.FindInternedVar(lang.NewSymbol("list")) - if tmp222.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp222))) - } - tmp223 := tmp222.Get() - tmp224 := lang.Apply(tmp223, []any{v21}) - tmp225 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp226 := tmp225.FindInternedVar(lang.NewSymbol("list")) - if tmp226.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp226))) - } - tmp227 := tmp226.Get() - tmp228 := lang.Apply(tmp227, []any{v48}) - tmp229 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp230 := tmp229.FindInternedVar(lang.NewSymbol("list")) - if tmp230.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp230))) - } - tmp231 := tmp230.Get() - tmp232 := lang.Apply(tmp231, []any{v22}) - tmp233 := lang.Apply(tmp220, []any{tmp224, tmp228, tmp232}) - tmp234 := lang.Apply(tmp217, []any{tmp233}) - tmp235 := lang.Apply(tmp214, []any{tmp234}) - tmp236 := lang.Apply(tmp207, []any{tmp211, tmp235}) - tmp237 := lang.Apply(tmp204, []any{tmp236}) - tmp238 := lang.Apply(tmp198, []any{tmp201, tmp237}) - tmp239 := lang.Apply(tmp195, []any{tmp238}) - tmp240 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp241 := tmp240.FindInternedVar(lang.NewSymbol("list")) - if tmp241.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp241))) - } - tmp242 := tmp241.Get() - tmp243 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp244 := tmp243.FindInternedVar(lang.NewSymbol("seq")) - if tmp244.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp244))) - } - tmp245 := tmp244.Get() - tmp246 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp247 := tmp246.FindInternedVar(lang.NewSymbol("concat")) - if tmp247.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp247))) - } - tmp248 := tmp247.Get() - tmp249 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp250 := tmp249.FindInternedVar(lang.NewSymbol("list")) - if tmp250.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp250))) - } - tmp251 := tmp250.Get() - tmp252 := lang.Apply(tmp251, []any{v58}) - tmp253 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp254 := tmp253.FindInternedVar(lang.NewSymbol("list")) - if tmp254.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp254))) - } - tmp255 := tmp254.Get() - tmp256 := lang.Apply(tmp255, []any{lang.NewSymbol("p__0__auto__")}) - tmp257 := lang.Apply(tmp248, []any{tmp252, tmp256}) - tmp258 := lang.Apply(tmp245, []any{tmp257}) - tmp259 := lang.Apply(tmp242, []any{tmp258}) - tmp260 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp261 := tmp260.FindInternedVar(lang.NewSymbol("list")) - if tmp261.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp261))) - } - tmp262 := tmp261.Get() - tmp263 := lang.Apply(v20, []any{v21, v22, v64}) - tmp264 := lang.Apply(tmp262, []any{tmp263}) - tmp265 := lang.Apply(tmp188, []any{tmp192, tmp239, tmp259, tmp264}) - tmp266 := lang.Apply(tmp185, []any{tmp265}) - tmp182 = tmp266 - } else { - } - tmp132 = tmp182 - } - tmp127 = tmp132 - } - tmp70 = tmp127 - } - tmp24 = tmp70 - } // end let - return tmp24 - }) - v20 = tmp19 - _ = v20 - } - tmp20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6377), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(6389), lang.NewKeyword("end-column"), int(53)) - tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v22 any = tmp21 - _ = v22 - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("seq")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("concat")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("list")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.Apply(tmp31, []any{lang.NewSymbol("glojure.core/let")}) - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("list")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("apply")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp40 := tmp39.FindInternedVar(lang.NewSymbol("vector")) - if tmp40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) - } - tmp41 := tmp40.Get() - tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp43 := tmp42.FindInternedVar(lang.NewSymbol("seq")) - if tmp43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) - } - tmp44 := tmp43.Get() - tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp46 := tmp45.FindInternedVar(lang.NewSymbol("concat")) - if tmp46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) - } - tmp47 := tmp46.Get() - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v13}) - tmp52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp53 := tmp52.FindInternedVar(lang.NewSymbol("list")) - if tmp53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp53))) - } - tmp54 := tmp53.Get() - tmp55 := lang.Apply(tmp54, []any{v5}) - tmp56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp57 := tmp56.FindInternedVar(lang.NewSymbol("list")) - if tmp57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp57))) - } - tmp58 := tmp57.Get() - tmp59 := lang.Apply(tmp58, []any{v18}) - tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp61 := tmp60.FindInternedVar(lang.NewSymbol("list")) - if tmp61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) - } - tmp62 := tmp61.Get() - tmp63 := lang.Apply(tmp62, []any{v6}) - tmp64 := lang.Apply(tmp47, []any{tmp51, tmp55, tmp59, tmp63}) - tmp65 := lang.Apply(tmp44, []any{tmp64}) - tmp66 := lang.Apply(tmp38, []any{tmp41, tmp65}) - tmp67 := lang.Apply(tmp35, []any{tmp66}) - tmp68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp69 := tmp68.FindInternedVar(lang.NewSymbol("list")) - if tmp69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp69))) - } - tmp70 := tmp69.Get() - tmp71 := lang.Apply(v22, []any{v13, v18, v7}) - tmp72 := lang.Apply(tmp70, []any{tmp71}) - tmp73 := lang.Apply(tmp28, []any{tmp32, tmp67, tmp72}) - tmp74 := lang.Apply(tmp25, []any{tmp73}) - tmp8 = tmp74 - } // end let - return tmp8 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // conj - { - tmp0 := lang.NewSymbol("conj").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("xs"))), lang.NewKeyword("doc"), "conj[oin]. Returns a new collection with the xs\n 'added'. (conj nil item) returns (item).\n (conj coll) returns coll. (conj) returns [].\n The 'addition' may happen at different 'places' depending\n on the concrete type.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(73), lang.NewKeyword("end-line"), int(81))).(*lang.Symbol) - var tmp2 lang.FnFunc - { // function conj - var v3 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp4 := lang.NewVector() - tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(82), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(82), lang.NewKeyword("end-column"), int(14)) - tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp6 - case 1: - v4 := args[0] - _ = v4 - return v4 - case 2: - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6 := lang.Apply(lang.Conj, []any{v4, v5}) - return tmp6 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - var v6 any = lang.NewList(args[2:]...) - _ = v6 - recur_loop_10: - var tmp7 any - if lang.IsTruthy(v6) { - tmp9 := lang.Apply(lang.Conj, []any{v4, v5}) - var tmp8 any = tmp9 - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("first")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{v6}) - var tmp10 any = tmp14 - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("next")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{v6}) - var tmp15 any = tmp19 - v4 = tmp8 - v5 = tmp10 - v6 = tmp15 - goto recur_loop_10 - } else { - tmp20 := lang.Apply(lang.Conj, []any{v4, v5}) - tmp7 = tmp20 - } - return tmp7 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(81), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(88), lang.NewKeyword("end-column"), int(67))).(lang.FnFunc) - v3 = tmp2 - _ = v3 - } - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // conj! - { - tmp0 := lang.NewSymbol("conj!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Adds x to the transient collection, and return coll. The 'addition'\n may happen at different 'places' depending on the concrete type.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3359), lang.NewKeyword("end-line"), int(3359))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp4 := tmp3.FindInternedVar(lang.NewSymbol("transient")) - if tmp4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp4))) - } - tmp5 := tmp4.Get() - tmp6 := lang.NewVector() - tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3364), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(3364), lang.NewKeyword("end-column"), int(19)) - tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp9 := lang.Apply(tmp5, []any{tmp8}) - return tmp9 - case 1: - v3 := args[0] - _ = v3 - return v3 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5, _ := lang.FieldOrMethod(v3, "Conj") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Conj is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // cons - { - tmp0 := lang.NewSymbol("cons").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("seq"))), lang.NewKeyword("doc"), "Returns a new seq where x is the first element and seq is\n the rest.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(21), lang.NewKeyword("end-line"), int(27))).(*lang.Symbol) - var tmp2 lang.FnFunc - { // function cons - var v3 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6 := lang.Apply(lang.NewCons, []any{v4, v5}) - return tmp6 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(27), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(27), lang.NewKeyword("end-column"), int(89))).(lang.FnFunc) - v3 = tmp2 - _ = v3 - } - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // constantly - { - tmp0 := lang.NewSymbol("constantly").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns a function that takes any number of arguments and returns x.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1440), lang.NewKeyword("end-line"), int(1440))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var v5 any = lang.NewList(args[0:]...) - _ = v5 - return v3 - } - }) - tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1444), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(1444), lang.NewKeyword("end-column"), int(21)) - tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp6 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // contains? - { - tmp0 := lang.NewSymbol("contains?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("key"))), lang.NewKeyword("doc"), "Returns true if key is present in the given collection, otherwise\n returns false. Note that for numerically indexed collections like\n vectors and Java arrays, this tests if the numeric key is within the\n range of indexes. 'contains?' operates constant or logarithmic time;\n it will not perform a linear search for a value. See also 'some'.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1479), lang.NewKeyword("end-line"), int(1479))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5, _ := lang.FieldOrMethod(runtime4.RT, "Contains") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Contains is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v3, v4}) - return tmp6 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // count - { - var tmp1 lang.FnFunc - { // function count__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/Count")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{v3}) - tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) - tmp36 := lang.Apply(tmp23, []any{tmp35}) - tmp37 := lang.Apply(tmp20, []any{tmp36}) - tmp38 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp37}) - tmp39 := lang.Apply(tmp6, []any{tmp38}) - return tmp39 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("count").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the number of items in the collection. (count nil) returns\n 0. Also works on strings, arrays, and Java Collections and Maps", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(867), lang.NewKeyword("end-line"), int(867))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5 := lang.Apply(lang.Count, []any{v4}) - return tmp5 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // counted? - { - tmp0 := lang.NewSymbol("counted?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements count in constant time", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6241), lang.NewKeyword("end-line"), int(6241))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := reflect.TypeOf((*lang.Counted)(nil)).Elem() - tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) - return tmp8 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // create-ns - { - tmp0 := lang.NewSymbol("create-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Create a new namespace named by the symbol if one doesn't already\n exist, returns it or the already-existing namespace of the same\n name.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4131), lang.NewKeyword("end-line"), int(4131))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.Apply(nil, []any{v3}) - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // create-struct - { - tmp0 := lang.NewSymbol("create-struct").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keys"))), lang.NewKeyword("doc"), "Returns a structure basis object.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4037), lang.NewKeyword("end-line"), int(4037))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var v3 any = lang.NewList(args[0:]...) - _ = v3 - tmp4 := lang.Apply(lang.CreatePersistentStructMapSlotMap, []any{v3}) - return tmp4 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // cycle - { - tmp0 := lang.NewSymbol("cycle").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy (infinite!) sequence of repetitions of the items in coll.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2977), lang.NewKeyword("end-line"), int(2977))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.Apply(tmp6, []any{v3}) - tmp8 := lang.Apply(lang.NewCycle, []any{tmp7}) - return tmp8 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // data-reader-urls - { - tmp0 := lang.NewSymbol("data-reader-urls").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7830), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7830), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - return lang.NewList() - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // data-reader-var - { - tmp0 := lang.NewSymbol("data-reader-var").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7832), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7832), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("intern")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("create-ns")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("symbol")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("namespace")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{v3}) - tmp17 := lang.Apply(tmp12, []any{tmp16}) - tmp18 := lang.Apply(tmp9, []any{tmp17}) - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("symbol")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("name")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.Apply(tmp24, []any{v3}) - tmp26 := lang.Apply(tmp21, []any{tmp25}) - tmp27 := lang.Apply(tmp6, []any{tmp18, tmp26}) - return tmp27 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // dec - { - var tmp1 lang.FnFunc - { // function dec__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - var tmp30 any - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - if lang.IsTruthy(tmp33) { - tmp30 = lang.NewSymbol("unchecked_dec") - } else { - tmp30 = lang.NewSymbol("dec") - } - tmp34 := lang.Apply(tmp29, []any{tmp30}) - tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp36 := tmp35.FindInternedVar(lang.NewSymbol("list")) - if tmp36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) - } - tmp37 := tmp36.Get() - tmp38 := lang.Apply(tmp37, []any{v3}) - tmp39 := lang.Apply(tmp26, []any{tmp34, tmp38}) - tmp40 := lang.Apply(tmp23, []any{tmp39}) - tmp41 := lang.Apply(tmp20, []any{tmp40}) - tmp42 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp41}) - tmp43 := lang.Apply(tmp6, []any{tmp42}) - return tmp43 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("dec").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns a number one less than num. Does not auto-promote\n longs, will throw on overflow. See also: dec'", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1147), lang.NewKeyword("end-line"), int(1147))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Dec") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Dec is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // dec' - { - var tmp1 lang.FnFunc - { // function dec'__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/DecP")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{v3}) - tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) - tmp36 := lang.Apply(tmp23, []any{tmp35}) - tmp37 := lang.Apply(tmp20, []any{tmp36}) - tmp38 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp37}) - tmp39 := lang.Apply(tmp6, []any{tmp38}) - return tmp39 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("dec'").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns a number one less than num. Supports arbitrary precision.\n See also: dec", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1140), lang.NewKeyword("end-line"), int(1140))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "DecP") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("DecP is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // decimal? - { - tmp0 := lang.NewSymbol("decimal?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is a BigDecimal", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3599), lang.NewKeyword("end-line"), int(3599))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := reflect.TypeOf((*lang.BigDecimal)(nil)) - tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) - return tmp8 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // declare - { - tmp0 := lang.NewSymbol("declare").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("names"))), lang.NewKeyword("doc"), "defs the supplied var names with no bindings, useful for making forward declarations.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(2768), lang.NewKeyword("end-line"), int(2768))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("seq")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("concat")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("list")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("do")}) - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("map")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - var tmp19 lang.FnFunc - tmp19 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v20 := args[0] - _ = v20 - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("list")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("vary-meta")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("assoc")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp26, []any{v20, tmp29, lang.NewKeyword("declared"), true}) - tmp31 := lang.Apply(tmp23, []any{lang.NewSymbol("def"), tmp30}) - return tmp31 - }) - tmp20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2771), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(2771), lang.NewKeyword("end-column"), int(71)) - tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp22 := lang.Apply(tmp18, []any{tmp21, v5}) - tmp23 := lang.Apply(tmp11, []any{tmp15, tmp22}) - tmp24 := lang.Apply(tmp8, []any{tmp23}) - return tmp24 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // dedupe - { - tmp0 := lang.NewSymbol("dedupe").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence removing consecutive duplicates in coll.\n Returns a transducer when no collection is provided.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7681), lang.NewKeyword("end-line"), int(7681))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - var tmp5 any - { // let - // let binding "pv" - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("volatile!")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(tmp8, []any{lang.NewKeyword("glojure.core/none")}) - var v10 any = tmp9 - _ = v10 - var tmp11 lang.FnFunc - tmp11 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp12 := lang.Apply(v4, nil) - return tmp12 - case 1: - v12 := args[0] - _ = v12 - tmp13 := lang.Apply(v4, []any{v12}) - return tmp13 - case 2: - v12 := args[0] - _ = v12 - v13 := args[1] - _ = v13 - var tmp14 any - { // let - // let binding "prior" - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("deref")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{v10}) - var v19 any = tmp18 - _ = v19 - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("vreset!")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.Apply(tmp22, []any{v10, v13}) - _ = tmp23 - var tmp24 any - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("=")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.Apply(tmp27, []any{v19, v13}) - if lang.IsTruthy(tmp28) { - tmp24 = v12 - } else { - tmp29 := lang.Apply(v4, []any{v12, v13}) - tmp24 = tmp29 - } - tmp14 = tmp24 - } // end let - return tmp14 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7688), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7696), lang.NewKeyword("end-column"), int(37)) - tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp5 = tmp13 - } // end let - return tmp5 - }) - tmp4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7686), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7696), lang.NewKeyword("end-column"), int(39)) - tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp5 - case 1: - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("sequence")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("dedupe")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp9, nil) - tmp11 := lang.Apply(tmp6, []any{tmp10, v3}) - return tmp11 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // def-aset - { - tmp0 := lang.NewSymbol("def-aset").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("method"), lang.NewSymbol("coerce"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3935), lang.NewKeyword("end-line"), int(3936), lang.NewKeyword("private"), true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 5 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - v7 := args[4] - _ = v7 - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("seq")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("concat")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("glojure.core/defn")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.Apply(tmp20, []any{v5}) - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("list")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("apply")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("hash-map")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("seq")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("concat")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("list")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.Apply(tmp39, []any{lang.NewKeyword("arglists")}) - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("list")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("seq")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp48 := tmp47.FindInternedVar(lang.NewSymbol("concat")) - if tmp48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) - } - tmp49 := tmp48.Get() - tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp51 := tmp50.FindInternedVar(lang.NewSymbol("list")) - if tmp51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) - } - tmp52 := tmp51.Get() - tmp53 := lang.Apply(tmp52, []any{lang.NewSymbol("quote")}) - tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp55 := tmp54.FindInternedVar(lang.NewSymbol("list")) - if tmp55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) - } - tmp56 := tmp55.Get() - tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp58 := tmp57.FindInternedVar(lang.NewSymbol("seq")) - if tmp58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) - } - tmp59 := tmp58.Get() - tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp61 := tmp60.FindInternedVar(lang.NewSymbol("concat")) - if tmp61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) - } - tmp62 := tmp61.Get() - tmp63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp64 := tmp63.FindInternedVar(lang.NewSymbol("list")) - if tmp64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp64))) - } - tmp65 := tmp64.Get() - tmp66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp67 := tmp66.FindInternedVar(lang.NewSymbol("apply")) - if tmp67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp67))) - } - tmp68 := tmp67.Get() - tmp69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp70 := tmp69.FindInternedVar(lang.NewSymbol("vector")) - if tmp70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp70))) - } - tmp71 := tmp70.Get() - tmp72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp73 := tmp72.FindInternedVar(lang.NewSymbol("seq")) - if tmp73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp73))) - } - tmp74 := tmp73.Get() - tmp75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp76 := tmp75.FindInternedVar(lang.NewSymbol("concat")) - if tmp76.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp76))) - } - tmp77 := tmp76.Get() - tmp78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp79 := tmp78.FindInternedVar(lang.NewSymbol("list")) - if tmp79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp79))) - } - tmp80 := tmp79.Get() - tmp81 := lang.Apply(tmp80, []any{lang.NewSymbol("array")}) - tmp82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp83 := tmp82.FindInternedVar(lang.NewSymbol("list")) - if tmp83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp83))) - } - tmp84 := tmp83.Get() - tmp85 := lang.Apply(tmp84, []any{lang.NewSymbol("idx")}) - tmp86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp87 := tmp86.FindInternedVar(lang.NewSymbol("list")) - if tmp87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp87))) - } - tmp88 := tmp87.Get() - tmp89 := lang.Apply(tmp88, []any{lang.NewSymbol("val")}) - tmp90 := lang.Apply(tmp77, []any{tmp81, tmp85, tmp89}) - tmp91 := lang.Apply(tmp74, []any{tmp90}) - tmp92 := lang.Apply(tmp68, []any{tmp71, tmp91}) - tmp93 := lang.Apply(tmp65, []any{tmp92}) - tmp94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp95 := tmp94.FindInternedVar(lang.NewSymbol("list")) - if tmp95.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp95))) - } - tmp96 := tmp95.Get() - tmp97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp98 := tmp97.FindInternedVar(lang.NewSymbol("apply")) - if tmp98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp98))) - } - tmp99 := tmp98.Get() - tmp100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp101 := tmp100.FindInternedVar(lang.NewSymbol("vector")) - if tmp101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp101))) - } - tmp102 := tmp101.Get() - tmp103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp104 := tmp103.FindInternedVar(lang.NewSymbol("seq")) - if tmp104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp104))) - } - tmp105 := tmp104.Get() - tmp106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp107 := tmp106.FindInternedVar(lang.NewSymbol("concat")) - if tmp107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp107))) - } - tmp108 := tmp107.Get() - tmp109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp110 := tmp109.FindInternedVar(lang.NewSymbol("list")) - if tmp110.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp110))) - } - tmp111 := tmp110.Get() - tmp112 := lang.Apply(tmp111, []any{lang.NewSymbol("array")}) - tmp113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp114 := tmp113.FindInternedVar(lang.NewSymbol("list")) - if tmp114.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp114))) - } - tmp115 := tmp114.Get() - tmp116 := lang.Apply(tmp115, []any{lang.NewSymbol("idx")}) - tmp117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp118 := tmp117.FindInternedVar(lang.NewSymbol("list")) - if tmp118.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp118))) - } - tmp119 := tmp118.Get() - tmp120 := lang.Apply(tmp119, []any{lang.NewSymbol("idx2")}) - tmp121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp122 := tmp121.FindInternedVar(lang.NewSymbol("list")) - if tmp122.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp122))) - } - tmp123 := tmp122.Get() - tmp124 := lang.Apply(tmp123, []any{lang.NewSymbol("&")}) - tmp125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp126 := tmp125.FindInternedVar(lang.NewSymbol("list")) - if tmp126.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp126))) - } - tmp127 := tmp126.Get() - tmp128 := lang.Apply(tmp127, []any{lang.NewSymbol("idxv")}) - tmp129 := lang.Apply(tmp108, []any{tmp112, tmp116, tmp120, tmp124, tmp128}) - tmp130 := lang.Apply(tmp105, []any{tmp129}) - tmp131 := lang.Apply(tmp99, []any{tmp102, tmp130}) - tmp132 := lang.Apply(tmp96, []any{tmp131}) - tmp133 := lang.Apply(tmp62, []any{tmp93, tmp132}) - tmp134 := lang.Apply(tmp59, []any{tmp133}) - tmp135 := lang.Apply(tmp56, []any{tmp134}) - tmp136 := lang.Apply(tmp49, []any{tmp53, tmp135}) - tmp137 := lang.Apply(tmp46, []any{tmp136}) - tmp138 := lang.Apply(tmp43, []any{tmp137}) - tmp139 := lang.Apply(tmp36, []any{tmp40, tmp138}) - tmp140 := lang.Apply(tmp33, []any{tmp139}) - tmp141 := lang.Apply(tmp27, []any{tmp30, tmp140}) - tmp142 := lang.Apply(tmp24, []any{tmp141}) - tmp143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp144 := tmp143.FindInternedVar(lang.NewSymbol("list")) - if tmp144.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp144))) - } - tmp145 := tmp144.Get() - tmp146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp147 := tmp146.FindInternedVar(lang.NewSymbol("seq")) - if tmp147.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp147))) - } - tmp148 := tmp147.Get() - tmp149 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp150 := tmp149.FindInternedVar(lang.NewSymbol("concat")) - if tmp150.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp150))) - } - tmp151 := tmp150.Get() - tmp152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp153 := tmp152.FindInternedVar(lang.NewSymbol("list")) - if tmp153.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp153))) - } - tmp154 := tmp153.Get() - tmp155 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp156 := tmp155.FindInternedVar(lang.NewSymbol("apply")) - if tmp156.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp156))) - } - tmp157 := tmp156.Get() - tmp158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp159 := tmp158.FindInternedVar(lang.NewSymbol("vector")) - if tmp159.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp159))) - } - tmp160 := tmp159.Get() - tmp161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp162 := tmp161.FindInternedVar(lang.NewSymbol("seq")) - if tmp162.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp162))) - } - tmp163 := tmp162.Get() - tmp164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp165 := tmp164.FindInternedVar(lang.NewSymbol("concat")) - if tmp165.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp165))) - } - tmp166 := tmp165.Get() - tmp167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp168 := tmp167.FindInternedVar(lang.NewSymbol("list")) - if tmp168.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp168))) - } - tmp169 := tmp168.Get() - tmp170 := lang.Apply(tmp169, []any{lang.NewSymbol("array__0__auto__")}) - tmp171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp172 := tmp171.FindInternedVar(lang.NewSymbol("list")) - if tmp172.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp172))) - } - tmp173 := tmp172.Get() - tmp174 := lang.Apply(tmp173, []any{lang.NewSymbol("idx__1__auto__")}) - tmp175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp176 := tmp175.FindInternedVar(lang.NewSymbol("list")) - if tmp176.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp176))) - } - tmp177 := tmp176.Get() - tmp178 := lang.Apply(tmp177, []any{lang.NewSymbol("val__2__auto__")}) - tmp179 := lang.Apply(tmp166, []any{tmp170, tmp174, tmp178}) - tmp180 := lang.Apply(tmp163, []any{tmp179}) - tmp181 := lang.Apply(tmp157, []any{tmp160, tmp180}) - tmp182 := lang.Apply(tmp154, []any{tmp181}) - tmp183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp184 := tmp183.FindInternedVar(lang.NewSymbol("list")) - if tmp184.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp184))) - } - tmp185 := tmp184.Get() - tmp186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp187 := tmp186.FindInternedVar(lang.NewSymbol("seq")) - if tmp187.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp187))) - } - tmp188 := tmp187.Get() - tmp189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp190 := tmp189.FindInternedVar(lang.NewSymbol("concat")) - if tmp190.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp190))) - } - tmp191 := tmp190.Get() - tmp192 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp193 := tmp192.FindInternedVar(lang.NewSymbol("list")) - if tmp193.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp193))) - } - tmp194 := tmp193.Get() - tmp195 := lang.Apply(tmp194, []any{lang.NewSymbol(".")}) - tmp196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp197 := tmp196.FindInternedVar(lang.NewSymbol("list")) - if tmp197.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp197))) - } - tmp198 := tmp197.Get() - tmp199 := lang.Apply(tmp198, []any{lang.NewSymbol("glojure.core/Array")}) - tmp200 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp201 := tmp200.FindInternedVar(lang.NewSymbol("list")) - if tmp201.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp201))) - } - tmp202 := tmp201.Get() - tmp203 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp204 := tmp203.FindInternedVar(lang.NewSymbol("seq")) - if tmp204.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp204))) - } - tmp205 := tmp204.Get() - tmp206 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp207 := tmp206.FindInternedVar(lang.NewSymbol("concat")) - if tmp207.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp207))) - } - tmp208 := tmp207.Get() - tmp209 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp210 := tmp209.FindInternedVar(lang.NewSymbol("list")) - if tmp210.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp210))) - } - tmp211 := tmp210.Get() - tmp212 := lang.Apply(tmp211, []any{v6}) - tmp213 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp214 := tmp213.FindInternedVar(lang.NewSymbol("list")) - if tmp214.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp214))) - } - tmp215 := tmp214.Get() - tmp216 := lang.Apply(tmp215, []any{lang.NewSymbol("array__0__auto__")}) - tmp217 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp218 := tmp217.FindInternedVar(lang.NewSymbol("list")) - if tmp218.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp218))) - } - tmp219 := tmp218.Get() - tmp220 := lang.Apply(tmp219, []any{lang.NewSymbol("idx__1__auto__")}) - tmp221 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp222 := tmp221.FindInternedVar(lang.NewSymbol("list")) - if tmp222.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp222))) - } - tmp223 := tmp222.Get() - tmp224 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp225 := tmp224.FindInternedVar(lang.NewSymbol("seq")) - if tmp225.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp225))) - } - tmp226 := tmp225.Get() - tmp227 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp228 := tmp227.FindInternedVar(lang.NewSymbol("concat")) - if tmp228.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp228))) - } - tmp229 := tmp228.Get() - tmp230 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp231 := tmp230.FindInternedVar(lang.NewSymbol("list")) - if tmp231.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp231))) - } - tmp232 := tmp231.Get() - tmp233 := lang.Apply(tmp232, []any{v7}) - tmp234 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp235 := tmp234.FindInternedVar(lang.NewSymbol("list")) - if tmp235.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp235))) - } - tmp236 := tmp235.Get() - tmp237 := lang.Apply(tmp236, []any{lang.NewSymbol("val__2__auto__")}) - tmp238 := lang.Apply(tmp229, []any{tmp233, tmp237}) - tmp239 := lang.Apply(tmp226, []any{tmp238}) - tmp240 := lang.Apply(tmp223, []any{tmp239}) - tmp241 := lang.Apply(tmp208, []any{tmp212, tmp216, tmp220, tmp240}) - tmp242 := lang.Apply(tmp205, []any{tmp241}) - tmp243 := lang.Apply(tmp202, []any{tmp242}) - tmp244 := lang.Apply(tmp191, []any{tmp195, tmp199, tmp243}) - tmp245 := lang.Apply(tmp188, []any{tmp244}) - tmp246 := lang.Apply(tmp185, []any{tmp245}) - tmp247 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp248 := tmp247.FindInternedVar(lang.NewSymbol("list")) - if tmp248.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp248))) - } - tmp249 := tmp248.Get() - tmp250 := lang.Apply(tmp249, []any{lang.NewSymbol("val__2__auto__")}) - tmp251 := lang.Apply(tmp151, []any{tmp182, tmp246, tmp250}) - tmp252 := lang.Apply(tmp148, []any{tmp251}) - tmp253 := lang.Apply(tmp145, []any{tmp252}) - tmp254 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp255 := tmp254.FindInternedVar(lang.NewSymbol("list")) - if tmp255.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp255))) - } - tmp256 := tmp255.Get() - tmp257 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp258 := tmp257.FindInternedVar(lang.NewSymbol("seq")) - if tmp258.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp258))) - } - tmp259 := tmp258.Get() - tmp260 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp261 := tmp260.FindInternedVar(lang.NewSymbol("concat")) - if tmp261.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp261))) - } - tmp262 := tmp261.Get() - tmp263 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp264 := tmp263.FindInternedVar(lang.NewSymbol("list")) - if tmp264.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp264))) - } - tmp265 := tmp264.Get() - tmp266 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp267 := tmp266.FindInternedVar(lang.NewSymbol("apply")) - if tmp267.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp267))) - } - tmp268 := tmp267.Get() - tmp269 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp270 := tmp269.FindInternedVar(lang.NewSymbol("vector")) - if tmp270.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp270))) - } - tmp271 := tmp270.Get() - tmp272 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp273 := tmp272.FindInternedVar(lang.NewSymbol("seq")) - if tmp273.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp273))) - } - tmp274 := tmp273.Get() - tmp275 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp276 := tmp275.FindInternedVar(lang.NewSymbol("concat")) - if tmp276.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp276))) - } - tmp277 := tmp276.Get() - tmp278 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp279 := tmp278.FindInternedVar(lang.NewSymbol("list")) - if tmp279.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp279))) - } - tmp280 := tmp279.Get() - tmp281 := lang.Apply(tmp280, []any{lang.NewSymbol("array__0__auto__")}) - tmp282 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp283 := tmp282.FindInternedVar(lang.NewSymbol("list")) - if tmp283.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp283))) - } - tmp284 := tmp283.Get() - tmp285 := lang.Apply(tmp284, []any{lang.NewSymbol("idx__1__auto__")}) - tmp286 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp287 := tmp286.FindInternedVar(lang.NewSymbol("list")) - if tmp287.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp287))) - } - tmp288 := tmp287.Get() - tmp289 := lang.Apply(tmp288, []any{lang.NewSymbol("idx2__3__auto__")}) - tmp290 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp291 := tmp290.FindInternedVar(lang.NewSymbol("list")) - if tmp291.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp291))) - } - tmp292 := tmp291.Get() - tmp293 := lang.Apply(tmp292, []any{lang.NewSymbol("&")}) - tmp294 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp295 := tmp294.FindInternedVar(lang.NewSymbol("list")) - if tmp295.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp295))) - } - tmp296 := tmp295.Get() - tmp297 := lang.Apply(tmp296, []any{lang.NewSymbol("idxv__4__auto__")}) - tmp298 := lang.Apply(tmp277, []any{tmp281, tmp285, tmp289, tmp293, tmp297}) - tmp299 := lang.Apply(tmp274, []any{tmp298}) - tmp300 := lang.Apply(tmp268, []any{tmp271, tmp299}) - tmp301 := lang.Apply(tmp265, []any{tmp300}) - tmp302 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp303 := tmp302.FindInternedVar(lang.NewSymbol("list")) - if tmp303.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp303))) - } - tmp304 := tmp303.Get() - tmp305 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp306 := tmp305.FindInternedVar(lang.NewSymbol("seq")) - if tmp306.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp306))) - } - tmp307 := tmp306.Get() - tmp308 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp309 := tmp308.FindInternedVar(lang.NewSymbol("concat")) - if tmp309.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp309))) - } - tmp310 := tmp309.Get() - tmp311 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp312 := tmp311.FindInternedVar(lang.NewSymbol("list")) - if tmp312.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp312))) - } - tmp313 := tmp312.Get() - tmp314 := lang.Apply(tmp313, []any{lang.NewSymbol("glojure.core/apply")}) - tmp315 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp316 := tmp315.FindInternedVar(lang.NewSymbol("list")) - if tmp316.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp316))) - } - tmp317 := tmp316.Get() - tmp318 := lang.Apply(tmp317, []any{v5}) - tmp319 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp320 := tmp319.FindInternedVar(lang.NewSymbol("list")) - if tmp320.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp320))) - } - tmp321 := tmp320.Get() - tmp322 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp323 := tmp322.FindInternedVar(lang.NewSymbol("seq")) - if tmp323.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp323))) - } - tmp324 := tmp323.Get() - tmp325 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp326 := tmp325.FindInternedVar(lang.NewSymbol("concat")) - if tmp326.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp326))) - } - tmp327 := tmp326.Get() - tmp328 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp329 := tmp328.FindInternedVar(lang.NewSymbol("list")) - if tmp329.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp329))) - } - tmp330 := tmp329.Get() - tmp331 := lang.Apply(tmp330, []any{lang.NewSymbol("glojure.core/aget")}) - tmp332 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp333 := tmp332.FindInternedVar(lang.NewSymbol("list")) - if tmp333.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp333))) - } - tmp334 := tmp333.Get() - tmp335 := lang.Apply(tmp334, []any{lang.NewSymbol("array__0__auto__")}) - tmp336 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp337 := tmp336.FindInternedVar(lang.NewSymbol("list")) - if tmp337.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp337))) - } - tmp338 := tmp337.Get() - tmp339 := lang.Apply(tmp338, []any{lang.NewSymbol("idx__1__auto__")}) - tmp340 := lang.Apply(tmp327, []any{tmp331, tmp335, tmp339}) - tmp341 := lang.Apply(tmp324, []any{tmp340}) - tmp342 := lang.Apply(tmp321, []any{tmp341}) - tmp343 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp344 := tmp343.FindInternedVar(lang.NewSymbol("list")) - if tmp344.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp344))) - } - tmp345 := tmp344.Get() - tmp346 := lang.Apply(tmp345, []any{lang.NewSymbol("idx2__3__auto__")}) - tmp347 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp348 := tmp347.FindInternedVar(lang.NewSymbol("list")) - if tmp348.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp348))) - } - tmp349 := tmp348.Get() - tmp350 := lang.Apply(tmp349, []any{lang.NewSymbol("idxv__4__auto__")}) - tmp351 := lang.Apply(tmp310, []any{tmp314, tmp318, tmp342, tmp346, tmp350}) - tmp352 := lang.Apply(tmp307, []any{tmp351}) - tmp353 := lang.Apply(tmp304, []any{tmp352}) - tmp354 := lang.Apply(tmp262, []any{tmp301, tmp353}) - tmp355 := lang.Apply(tmp259, []any{tmp354}) - tmp356 := lang.Apply(tmp256, []any{tmp355}) - tmp357 := lang.Apply(tmp13, []any{tmp17, tmp21, tmp142, tmp253, tmp356}) - tmp358 := lang.Apply(tmp10, []any{tmp357}) - return tmp358 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // definline - { - tmp0 := lang.NewSymbol("definline").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("decl"))), lang.NewKeyword("doc"), "Experimental - like defmacro, except defines a named function whose\n body is the expansion, calls to which may be expanded inline as if\n it were a macro. Cannot be used with variadic (&) args.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5253), lang.NewKeyword("end-line"), int(5253))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any - { // let - // let binding "vec__80" - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("split-with")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("comp")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("not")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("vector?")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.Apply(tmp13, []any{tmp16, tmp19}) - tmp21 := lang.Apply(tmp10, []any{tmp20, v6}) - var v22 any = tmp21 - _ = v22 - // let binding "pre-args" - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("nth")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.Apply(tmp25, []any{v22, int64(0), nil}) - var v27 any = tmp26 - _ = v27 - // let binding "vec__83" - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("nth")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.Apply(tmp30, []any{v22, int64(1), nil}) - var v32 any = tmp31 - _ = v32 - // let binding "args" - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("nth")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.Apply(tmp35, []any{v32, int64(0), nil}) - var v37 any = tmp36 - _ = v37 - // let binding "expr" - tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp39 := tmp38.FindInternedVar(lang.NewSymbol("nth")) - if tmp39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) - } - tmp40 := tmp39.Get() - tmp41 := lang.Apply(tmp40, []any{v32, int64(1), nil}) - var v42 any = tmp41 - _ = v42 - tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp44 := tmp43.FindInternedVar(lang.NewSymbol("seq")) - if tmp44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) - } - tmp45 := tmp44.Get() - tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp47 := tmp46.FindInternedVar(lang.NewSymbol("concat")) - if tmp47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) - } - tmp48 := tmp47.Get() - tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp50 := tmp49.FindInternedVar(lang.NewSymbol("list")) - if tmp50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) - } - tmp51 := tmp50.Get() - tmp52 := lang.Apply(tmp51, []any{lang.NewSymbol("do")}) - tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp54 := tmp53.FindInternedVar(lang.NewSymbol("list")) - if tmp54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) - } - tmp55 := tmp54.Get() - tmp56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp57 := tmp56.FindInternedVar(lang.NewSymbol("seq")) - if tmp57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp57))) - } - tmp58 := tmp57.Get() - tmp59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp60 := tmp59.FindInternedVar(lang.NewSymbol("concat")) - if tmp60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp60))) - } - tmp61 := tmp60.Get() - tmp62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp63 := tmp62.FindInternedVar(lang.NewSymbol("list")) - if tmp63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp63))) - } - tmp64 := tmp63.Get() - tmp65 := lang.Apply(tmp64, []any{lang.NewSymbol("glojure.core/defn")}) - tmp66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp67 := tmp66.FindInternedVar(lang.NewSymbol("list")) - if tmp67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp67))) - } - tmp68 := tmp67.Get() - tmp69 := lang.Apply(tmp68, []any{v5}) - tmp70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp71 := tmp70.FindInternedVar(lang.NewSymbol("list")) - if tmp71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp71))) - } - tmp72 := tmp71.Get() - tmp73 := lang.Apply(tmp72, []any{v37}) - tmp74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp75 := tmp74.FindInternedVar(lang.NewSymbol("list")) - if tmp75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp75))) - } - tmp76 := tmp75.Get() - tmp77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp78 := tmp77.FindInternedVar(lang.NewSymbol("apply")) - if tmp78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp78))) - } - tmp79 := tmp78.Get() - tmp80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp81 := tmp80.FindInternedVar(lang.NewSymbol("eval")) - if tmp81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp81))) - } - tmp82 := tmp81.Get() - tmp83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp84 := tmp83.FindInternedVar(lang.NewSymbol("list")) - if tmp84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp84))) - } - tmp85 := tmp84.Get() - tmp86 := lang.Apply(tmp85, []any{lang.NewSymbol("glojure.core/fn"), v37, v42}) - tmp87 := lang.Apply(tmp82, []any{tmp86}) - tmp88 := lang.Apply(tmp79, []any{tmp87, v37}) - tmp89 := lang.Apply(tmp76, []any{tmp88}) - tmp90 := lang.Apply(tmp61, []any{tmp65, tmp69, v27, tmp73, tmp89}) - tmp91 := lang.Apply(tmp58, []any{tmp90}) - tmp92 := lang.Apply(tmp55, []any{tmp91}) - tmp93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp94 := tmp93.FindInternedVar(lang.NewSymbol("list")) - if tmp94.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp94))) - } - tmp95 := tmp94.Get() - tmp96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp97 := tmp96.FindInternedVar(lang.NewSymbol("seq")) - if tmp97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp97))) - } - tmp98 := tmp97.Get() - tmp99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp100 := tmp99.FindInternedVar(lang.NewSymbol("concat")) - if tmp100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp100))) - } - tmp101 := tmp100.Get() - tmp102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp103 := tmp102.FindInternedVar(lang.NewSymbol("list")) - if tmp103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp103))) - } - tmp104 := tmp103.Get() - tmp105 := lang.Apply(tmp104, []any{lang.NewSymbol("glojure.core/alter-meta!")}) - tmp106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp107 := tmp106.FindInternedVar(lang.NewSymbol("list")) - if tmp107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp107))) - } - tmp108 := tmp107.Get() - tmp109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp110 := tmp109.FindInternedVar(lang.NewSymbol("seq")) - if tmp110.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp110))) - } - tmp111 := tmp110.Get() - tmp112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp113 := tmp112.FindInternedVar(lang.NewSymbol("concat")) - if tmp113.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp113))) - } - tmp114 := tmp113.Get() - tmp115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp116 := tmp115.FindInternedVar(lang.NewSymbol("list")) - if tmp116.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp116))) - } - tmp117 := tmp116.Get() - tmp118 := lang.Apply(tmp117, []any{lang.NewSymbol("var")}) - tmp119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp120 := tmp119.FindInternedVar(lang.NewSymbol("list")) - if tmp120.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp120))) - } - tmp121 := tmp120.Get() - tmp122 := lang.Apply(tmp121, []any{v5}) - tmp123 := lang.Apply(tmp114, []any{tmp118, tmp122}) - tmp124 := lang.Apply(tmp111, []any{tmp123}) - tmp125 := lang.Apply(tmp108, []any{tmp124}) - tmp126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp127 := tmp126.FindInternedVar(lang.NewSymbol("list")) - if tmp127.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp127))) - } - tmp128 := tmp127.Get() - tmp129 := lang.Apply(tmp128, []any{lang.NewSymbol("glojure.core/assoc")}) - tmp130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp131 := tmp130.FindInternedVar(lang.NewSymbol("list")) - if tmp131.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp131))) - } - tmp132 := tmp131.Get() - tmp133 := lang.Apply(tmp132, []any{lang.NewKeyword("inline")}) - tmp134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp135 := tmp134.FindInternedVar(lang.NewSymbol("list")) - if tmp135.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp135))) - } - tmp136 := tmp135.Get() - tmp137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp138 := tmp137.FindInternedVar(lang.NewSymbol("seq")) - if tmp138.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp138))) - } - tmp139 := tmp138.Get() - tmp140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp141 := tmp140.FindInternedVar(lang.NewSymbol("concat")) - if tmp141.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp141))) - } - tmp142 := tmp141.Get() - tmp143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp144 := tmp143.FindInternedVar(lang.NewSymbol("list")) - if tmp144.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp144))) - } - tmp145 := tmp144.Get() - tmp146 := lang.Apply(tmp145, []any{lang.NewSymbol("glojure.core/fn")}) - tmp147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp148 := tmp147.FindInternedVar(lang.NewSymbol("list")) - if tmp148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp148))) - } - tmp149 := tmp148.Get() - tmp150 := lang.Apply(tmp149, []any{v5}) - tmp151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp152 := tmp151.FindInternedVar(lang.NewSymbol("list")) - if tmp152.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp152))) - } - tmp153 := tmp152.Get() - tmp154 := lang.Apply(tmp153, []any{v37}) - tmp155 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp156 := tmp155.FindInternedVar(lang.NewSymbol("list")) - if tmp156.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp156))) - } - tmp157 := tmp156.Get() - tmp158 := lang.Apply(tmp157, []any{v42}) - tmp159 := lang.Apply(tmp142, []any{tmp146, tmp150, tmp154, tmp158}) - tmp160 := lang.Apply(tmp139, []any{tmp159}) - tmp161 := lang.Apply(tmp136, []any{tmp160}) - tmp162 := lang.Apply(tmp101, []any{tmp105, tmp125, tmp129, tmp133, tmp161}) - tmp163 := lang.Apply(tmp98, []any{tmp162}) - tmp164 := lang.Apply(tmp95, []any{tmp163}) - tmp165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp166 := tmp165.FindInternedVar(lang.NewSymbol("list")) - if tmp166.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp166))) - } - tmp167 := tmp166.Get() - tmp168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp169 := tmp168.FindInternedVar(lang.NewSymbol("seq")) - if tmp169.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp169))) - } - tmp170 := tmp169.Get() - tmp171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp172 := tmp171.FindInternedVar(lang.NewSymbol("concat")) - if tmp172.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp172))) - } - tmp173 := tmp172.Get() - tmp174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp175 := tmp174.FindInternedVar(lang.NewSymbol("list")) - if tmp175.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp175))) - } - tmp176 := tmp175.Get() - tmp177 := lang.Apply(tmp176, []any{lang.NewSymbol("var")}) - tmp178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp179 := tmp178.FindInternedVar(lang.NewSymbol("list")) - if tmp179.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp179))) - } - tmp180 := tmp179.Get() - tmp181 := lang.Apply(tmp180, []any{v5}) - tmp182 := lang.Apply(tmp173, []any{tmp177, tmp181}) - tmp183 := lang.Apply(tmp170, []any{tmp182}) - tmp184 := lang.Apply(tmp167, []any{tmp183}) - tmp185 := lang.Apply(tmp48, []any{tmp52, tmp92, tmp164, tmp184}) - tmp186 := lang.Apply(tmp45, []any{tmp185}) - tmp7 = tmp186 - } // end let - return tmp7 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // defmacro - { - tmp0 := lang.NewSymbol("defmacro").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("doc-string?"), lang.NewSymbol("attr-map?"), lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("body")), lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("doc-string?"), lang.NewSymbol("attr-map?"), lang.NewList(lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("body")), lang.NewSymbol("+"), lang.NewSymbol("attr-map?"))), lang.NewKeyword("doc"), "Like defn, but the resulting function name is declared as a\n macro and will be used as a macro by the compiler when it is\n called.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(445), lang.NewKeyword("end-line"), int(451))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any - { // let - // let binding "prefix" - var tmp8 any - { // let - // let binding "p" - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("list")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.Apply(tmp11, []any{v5}) - var v13 any = tmp12 - _ = v13 - // let binding "args" - var v14 any = v6 - _ = v14 - for { - var tmp15 any - { // let - // let binding "f" - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("first")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{v14}) - var v20 any = tmp19 - _ = v20 - var tmp21 any - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("string?")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.Apply(tmp24, []any{v20}) - if lang.IsTruthy(tmp25) { - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("cons")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{v20, v13}) - var tmp26 any = tmp30 - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("next")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.Apply(tmp34, []any{v14}) - var tmp31 any = tmp35 - v13 = tmp26 - v14 = tmp31 - continue - } else { - var tmp36 any - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("map?")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.Apply(tmp39, []any{v20}) - if lang.IsTruthy(tmp40) { - tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp43 := tmp42.FindInternedVar(lang.NewSymbol("cons")) - if tmp43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) - } - tmp44 := tmp43.Get() - tmp45 := lang.Apply(tmp44, []any{v20, v13}) - var tmp41 any = tmp45 - tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp48 := tmp47.FindInternedVar(lang.NewSymbol("next")) - if tmp48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) - } - tmp49 := tmp48.Get() - tmp50 := lang.Apply(tmp49, []any{v14}) - var tmp46 any = tmp50 - v13 = tmp41 - v14 = tmp46 - continue - } else { - tmp36 = v13 - } - tmp21 = tmp36 - } - tmp15 = tmp21 - } // end let - tmp8 = tmp15 - break - } - } // end let - var v9 any = tmp8 - _ = v9 - // let binding "fdecl" - var tmp10 any - { // let - // let binding "fd" - var v11 any = v6 - _ = v11 - for { - var tmp12 any - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("string?")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("first")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{v11}) - tmp20 := lang.Apply(tmp15, []any{tmp19}) - if lang.IsTruthy(tmp20) { - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("next")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.Apply(tmp24, []any{v11}) - var tmp21 any = tmp25 - v11 = tmp21 - continue - } else { - var tmp26 any - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("map?")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("first")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.Apply(tmp32, []any{v11}) - tmp34 := lang.Apply(tmp29, []any{tmp33}) - if lang.IsTruthy(tmp34) { - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("next")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{v11}) - var tmp35 any = tmp39 - v11 = tmp35 - continue - } else { - tmp26 = v11 - } - tmp12 = tmp26 - } - tmp10 = tmp12 - break - } - } // end let - var v11 any = tmp10 - _ = v11 - // let binding "fdecl" - var tmp12 any - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("vector?")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("first")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{v11}) - tmp20 := lang.Apply(tmp15, []any{tmp19}) - if lang.IsTruthy(tmp20) { - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("list")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.Apply(tmp23, []any{v11}) - tmp12 = tmp24 - } else { - tmp12 = v11 - } - var v25 any = tmp12 - _ = v25 - // let binding "add-implicit-args" - var tmp26 lang.FnFunc - tmp26 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v27 := args[0] - _ = v27 - var tmp28 any - { // let - // let binding "args" - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("first")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.Apply(tmp31, []any{v27}) - var v33 any = tmp32 - _ = v33 - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("cons")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("vec")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("cons")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp44 := tmp43.FindInternedVar(lang.NewSymbol("cons")) - if tmp44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) - } - tmp45 := tmp44.Get() - tmp46 := lang.Apply(tmp45, []any{lang.NewSymbol("&env"), v33}) - tmp47 := lang.Apply(tmp42, []any{lang.NewSymbol("&form"), tmp46}) - tmp48 := lang.Apply(tmp39, []any{tmp47}) - tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp50 := tmp49.FindInternedVar(lang.NewSymbol("next")) - if tmp50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) - } - tmp51 := tmp50.Get() - tmp52 := lang.Apply(tmp51, []any{v27}) - tmp53 := lang.Apply(tmp36, []any{tmp48, tmp52}) - tmp28 = tmp53 - } // end let - return tmp28 - }) - tmp27 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(469), lang.NewKeyword("column"), int(38), lang.NewKeyword("end-line"), int(471), lang.NewKeyword("end-column"), int(87)) - tmp28, err := lang.WithMeta(tmp26, tmp27.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v29 any = tmp28 - _ = v29 - // let binding "add-args" - var tmp30 lang.FnFunc - tmp30 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v31 := args[0] - _ = v31 - v32 := args[1] - _ = v32 - recur_loop_61: - var tmp33 any - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("nil?")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.Apply(tmp36, []any{v32}) - if lang.IsTruthy(tmp37) { - tmp33 = v31 - } else { - var tmp38 any - { // let - // let binding "d" - tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp40 := tmp39.FindInternedVar(lang.NewSymbol("first")) - if tmp40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) - } - tmp41 := tmp40.Get() - tmp42 := lang.Apply(tmp41, []any{v32}) - var v43 any = tmp42 - _ = v43 - var tmp44 any - tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp46 := tmp45.FindInternedVar(lang.NewSymbol("map?")) - if tmp46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) - } - tmp47 := tmp46.Get() - tmp48 := lang.Apply(tmp47, []any{v43}) - if lang.IsTruthy(tmp48) { - tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp50 := tmp49.FindInternedVar(lang.NewSymbol("conj")) - if tmp50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) - } - tmp51 := tmp50.Get() - tmp52 := lang.Apply(tmp51, []any{v31, v43}) - tmp44 = tmp52 - } else { - tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp55 := tmp54.FindInternedVar(lang.NewSymbol("conj")) - if tmp55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) - } - tmp56 := tmp55.Get() - tmp57 := lang.Apply(v29, []any{v43}) - tmp58 := lang.Apply(tmp56, []any{v31, tmp57}) - var tmp53 any = tmp58 - tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp61 := tmp60.FindInternedVar(lang.NewSymbol("next")) - if tmp61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) - } - tmp62 := tmp61.Get() - tmp63 := lang.Apply(tmp62, []any{v32}) - var tmp59 any = tmp63 - v31 = tmp53 - v32 = tmp59 - goto recur_loop_61 - } - tmp38 = tmp44 - } // end let - tmp33 = tmp38 - } - return tmp33 - }) - tmp31 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(472), lang.NewKeyword("column"), int(29), lang.NewKeyword("end-line"), int(478), lang.NewKeyword("end-column"), int(90)) - tmp32, err := lang.WithMeta(tmp30, tmp31.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v33 any = tmp32 - _ = v33 - // let binding "fdecl" - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.NewVector() - tmp38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(479), lang.NewKeyword("column"), int(41), lang.NewKeyword("end-line"), int(479), lang.NewKeyword("end-column"), int(42)) - tmp39, err := lang.WithMeta(tmp37, tmp38.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp40 := lang.Apply(v33, []any{tmp39, v25}) - tmp41 := lang.Apply(tmp36, []any{tmp40}) - var v42 any = tmp41 - _ = v42 - // let binding "decl" - var tmp43 any - { // let - // let binding "p" - var v44 any = v9 - _ = v44 - // let binding "d" - var v45 any = v42 - _ = v45 - for { - var tmp46 any - if lang.IsTruthy(v44) { - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("next")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v44}) - var tmp47 any = tmp51 - tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp54 := tmp53.FindInternedVar(lang.NewSymbol("cons")) - if tmp54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) - } - tmp55 := tmp54.Get() - tmp56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp57 := tmp56.FindInternedVar(lang.NewSymbol("first")) - if tmp57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp57))) - } - tmp58 := tmp57.Get() - tmp59 := lang.Apply(tmp58, []any{v44}) - tmp60 := lang.Apply(tmp55, []any{tmp59, v45}) - var tmp52 any = tmp60 - v44 = tmp47 - v45 = tmp52 - continue - } else { - tmp46 = v45 - } - tmp43 = tmp46 - break - } - } // end let - var v44 any = tmp43 - _ = v44 - tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp46 := tmp45.FindInternedVar(lang.NewSymbol("list")) - if tmp46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) - } - tmp47 := tmp46.Get() - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("cons")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{lang.NewSymbol("glojure.core/defn"), v44}) - tmp52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp53 := tmp52.FindInternedVar(lang.NewSymbol("list")) - if tmp53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp53))) - } - tmp54 := tmp53.Get() - tmp55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp56 := tmp55.FindInternedVar(lang.NewSymbol("list")) - if tmp56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp56))) - } - tmp57 := tmp56.Get() - tmp58 := lang.Apply(tmp57, []any{lang.NewSymbol("var"), v5}) - tmp59 := lang.Apply(tmp54, []any{lang.NewSymbol("."), tmp58, lang.NewList(lang.NewSymbol("SetMacro"))}) - tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp61 := tmp60.FindInternedVar(lang.NewSymbol("list")) - if tmp61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) - } - tmp62 := tmp61.Get() - tmp63 := lang.Apply(tmp62, []any{lang.NewSymbol("var"), v5}) - tmp64 := lang.Apply(tmp47, []any{lang.NewSymbol("do"), tmp51, tmp59, tmp63}) - tmp7 = tmp64 - } // end let - return tmp7 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(451), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(487), lang.NewKeyword("end-column"), int(40))).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // defmethod - { - tmp0 := lang.NewSymbol("defmethod").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"), lang.NewSymbol("dispatch-val"), lang.NewSymbol("&"), lang.NewSymbol("fn-tail"))), lang.NewKeyword("doc"), "Creates and installs a new method of multimethod associated with dispatch-value. ", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1781), lang.NewKeyword("end-line"), int(1781))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - var v7 any = lang.NewList(args[4:]...) - _ = v7 - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("seq")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("concat")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol(".")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("with-meta")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.NewMap(lang.NewKeyword("tag"), lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.*MultiFn")) - tmp25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1785), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(1785), lang.NewKeyword("end-column"), int(82)) - tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp27 := lang.Apply(tmp23, []any{v5, tmp26}) - tmp28 := lang.Apply(tmp20, []any{tmp27}) - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("list")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.Apply(tmp31, []any{lang.NewSymbol("glojure.core/AddMethod")}) - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("list")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.Apply(tmp35, []any{v6}) - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("list")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("seq")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp44 := tmp43.FindInternedVar(lang.NewSymbol("concat")) - if tmp44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) - } - tmp45 := tmp44.Get() - tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp47 := tmp46.FindInternedVar(lang.NewSymbol("list")) - if tmp47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) - } - tmp48 := tmp47.Get() - tmp49 := lang.Apply(tmp48, []any{lang.NewSymbol("glojure.core/fn")}) - tmp50 := lang.Apply(tmp45, []any{tmp49, v7}) - tmp51 := lang.Apply(tmp42, []any{tmp50}) - tmp52 := lang.Apply(tmp39, []any{tmp51}) - tmp53 := lang.Apply(tmp13, []any{tmp17, tmp28, tmp32, tmp36, tmp52}) - tmp54 := lang.Apply(tmp10, []any{tmp53}) - return tmp54 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // defmulti - { - tmp0 := lang.NewSymbol("defmulti").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("docstring?"), lang.NewSymbol("attr-map?"), lang.NewSymbol("dispatch-fn"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Creates a new multimethod with the associated dispatch function.\n The docstring and attr-map are optional.\n\n Options are key-value pairs and may be one of:\n\n :default\n\n The default dispatch value, defaults to :default\n\n :hierarchy\n\n The value used for hierarchical dispatch (e.g. ::square is-a ::shape)\n\n Hierarchies are type-like relationships that do not depend upon type\n inheritance. By default Clojure's multimethods dispatch off of a\n global hierarchy map. However, a hierarchy relationship can be\n created with the derive function used to augment the root ancestor\n created with make-hierarchy.\n\n Multimethods expect the value of the hierarchy option to be supplied as\n a reference type e.g. a var (i.e. via the Var-quote dispatch macro #'\n or the var special form).", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1723), lang.NewKeyword("end-line"), int(1723))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any - { // let - // let binding "docstring" - var tmp8 any - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("string?")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("first")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.Apply(tmp14, []any{v6}) - tmp16 := lang.Apply(tmp11, []any{tmp15}) - if lang.IsTruthy(tmp16) { - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("first")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.Apply(tmp19, []any{v6}) - tmp8 = tmp20 - } else { - } - var v21 any = tmp8 - _ = v21 - // let binding "options" - var tmp22 any - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("string?")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("first")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.Apply(tmp28, []any{v6}) - tmp30 := lang.Apply(tmp25, []any{tmp29}) - if lang.IsTruthy(tmp30) { - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("next")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{v6}) - tmp22 = tmp34 - } else { - tmp22 = v6 - } - var v35 any = tmp22 - _ = v35 - // let binding "m" - var tmp36 any - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("map?")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("first")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.Apply(tmp42, []any{v35}) - tmp44 := lang.Apply(tmp39, []any{tmp43}) - if lang.IsTruthy(tmp44) { - tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp46 := tmp45.FindInternedVar(lang.NewSymbol("first")) - if tmp46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) - } - tmp47 := tmp46.Get() - tmp48 := lang.Apply(tmp47, []any{v35}) - tmp36 = tmp48 - } else { - tmp49 := lang.NewMap() - tmp50 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1757), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(1757), lang.NewKeyword("end-column"), int(24)) - tmp51, err := lang.WithMeta(tmp49, tmp50.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp36 = tmp51 - } - var v52 any = tmp36 - _ = v52 - // let binding "options" - var tmp53 any - tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp55 := tmp54.FindInternedVar(lang.NewSymbol("map?")) - if tmp55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) - } - tmp56 := tmp55.Get() - tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp58 := tmp57.FindInternedVar(lang.NewSymbol("first")) - if tmp58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) - } - tmp59 := tmp58.Get() - tmp60 := lang.Apply(tmp59, []any{v35}) - tmp61 := lang.Apply(tmp56, []any{tmp60}) - if lang.IsTruthy(tmp61) { - tmp62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp63 := tmp62.FindInternedVar(lang.NewSymbol("next")) - if tmp63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp63))) - } - tmp64 := tmp63.Get() - tmp65 := lang.Apply(tmp64, []any{v35}) - tmp53 = tmp65 - } else { - tmp53 = v35 - } - var v66 any = tmp53 - _ = v66 - // let binding "dispatch-fn" - tmp67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp68 := tmp67.FindInternedVar(lang.NewSymbol("first")) - if tmp68.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp68))) - } - tmp69 := tmp68.Get() - tmp70 := lang.Apply(tmp69, []any{v66}) - var v71 any = tmp70 - _ = v71 - // let binding "options" - tmp72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp73 := tmp72.FindInternedVar(lang.NewSymbol("next")) - if tmp73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp73))) - } - tmp74 := tmp73.Get() - tmp75 := lang.Apply(tmp74, []any{v66}) - var v76 any = tmp75 - _ = v76 - // let binding "m" - var tmp77 any - if lang.IsTruthy(v21) { - tmp78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp79 := tmp78.FindInternedVar(lang.NewSymbol("assoc")) - if tmp79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp79))) - } - tmp80 := tmp79.Get() - tmp81 := lang.Apply(tmp80, []any{v52, lang.NewKeyword("doc"), v21}) - tmp77 = tmp81 - } else { - tmp77 = v52 - } - var v82 any = tmp77 - _ = v82 - // let binding "m" - var tmp83 any - tmp84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp85 := tmp84.FindInternedVar(lang.NewSymbol("meta")) - if tmp85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp85))) - } - tmp86 := tmp85.Get() - tmp87 := lang.Apply(tmp86, []any{v5}) - if lang.IsTruthy(tmp87) { - tmp88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp89 := tmp88.FindInternedVar(lang.NewSymbol("conj")) - if tmp89.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp89))) - } - tmp90 := tmp89.Get() - tmp91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp92 := tmp91.FindInternedVar(lang.NewSymbol("meta")) - if tmp92.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp92))) - } - tmp93 := tmp92.Get() - tmp94 := lang.Apply(tmp93, []any{v5}) - tmp95 := lang.Apply(tmp90, []any{tmp94, v82}) - tmp83 = tmp95 - } else { - tmp83 = v82 - } - var v96 any = tmp83 - _ = v96 - // let binding "mm-name" - tmp97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp98 := tmp97.FindInternedVar(lang.NewSymbol("with-meta")) - if tmp98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp98))) - } - tmp99 := tmp98.Get() - tmp100 := lang.Apply(tmp99, []any{v5, v96}) - var v101 any = tmp100 - _ = v101 - var tmp102 any - tmp103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp104 := tmp103.FindInternedVar(lang.NewSymbol("=")) - if tmp104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp104))) - } - tmp105 := tmp104.Get() - tmp106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp107 := tmp106.FindInternedVar(lang.NewSymbol("count")) - if tmp107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp107))) - } - tmp108 := tmp107.Get() - tmp109 := lang.Apply(tmp108, []any{v76}) - tmp110 := lang.Apply(tmp105, []any{tmp109, int64(1)}) - if lang.IsTruthy(tmp110) { - tmp111 := lang.Apply(lang.NewError, []any{"The syntax for defmulti has changed. Example: (defmulti name dispatch-fn :default dispatch-value)"}) - panic(tmp111) - } else { - } - _ = tmp102 - var tmp112 any - { // let - // let binding "options" - tmp113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp114 := tmp113.FindInternedVar(lang.NewSymbol("apply")) - if tmp114.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp114))) - } - tmp115 := tmp114.Get() - tmp116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp117 := tmp116.FindInternedVar(lang.NewSymbol("hash-map")) - if tmp117.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp117))) - } - tmp118 := tmp117.Get() - tmp119 := lang.Apply(tmp115, []any{tmp118, v76}) - var v120 any = tmp119 - _ = v120 - // let binding "default" - tmp121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp122 := tmp121.FindInternedVar(lang.NewSymbol("get")) - if tmp122.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp122))) - } - tmp123 := tmp122.Get() - tmp124 := lang.Apply(tmp123, []any{v120, lang.NewKeyword("default"), lang.NewKeyword("default")}) - var v125 any = tmp124 - _ = v125 - // let binding "hierarchy" - tmp126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp127 := tmp126.FindInternedVar(lang.NewSymbol("get")) - if tmp127.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp127))) - } - tmp128 := tmp127.Get() - tmp129 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("global-hierarchy")) - tmp130 := lang.Apply(tmp128, []any{v120, lang.NewKeyword("hierarchy"), tmp129}) - var v131 any = tmp130 - _ = v131 - tmp132 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp133 := tmp132.FindInternedVar(lang.NewSymbol("check-valid-options")) - if tmp133.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp133))) - } - tmp134 := tmp133.Get() - tmp135 := lang.Apply(tmp134, []any{v120, lang.NewKeyword("default"), lang.NewKeyword("hierarchy")}) - _ = tmp135 - tmp136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp137 := tmp136.FindInternedVar(lang.NewSymbol("seq")) - if tmp137.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp137))) - } - tmp138 := tmp137.Get() - tmp139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp140 := tmp139.FindInternedVar(lang.NewSymbol("concat")) - if tmp140.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp140))) - } - tmp141 := tmp140.Get() - tmp142 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp143 := tmp142.FindInternedVar(lang.NewSymbol("list")) - if tmp143.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp143))) - } - tmp144 := tmp143.Get() - tmp145 := lang.Apply(tmp144, []any{lang.NewSymbol("glojure.core/let")}) - tmp146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp147 := tmp146.FindInternedVar(lang.NewSymbol("list")) - if tmp147.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp147))) - } - tmp148 := tmp147.Get() - tmp149 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp150 := tmp149.FindInternedVar(lang.NewSymbol("apply")) - if tmp150.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp150))) - } - tmp151 := tmp150.Get() - tmp152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp153 := tmp152.FindInternedVar(lang.NewSymbol("vector")) - if tmp153.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp153))) - } - tmp154 := tmp153.Get() - tmp155 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp156 := tmp155.FindInternedVar(lang.NewSymbol("seq")) - if tmp156.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp156))) - } - tmp157 := tmp156.Get() - tmp158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp159 := tmp158.FindInternedVar(lang.NewSymbol("concat")) - if tmp159.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp159))) - } - tmp160 := tmp159.Get() - tmp161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp162 := tmp161.FindInternedVar(lang.NewSymbol("list")) - if tmp162.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp162))) - } - tmp163 := tmp162.Get() - tmp164 := lang.Apply(tmp163, []any{lang.NewSymbol("v__0__auto__")}) - tmp165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp166 := tmp165.FindInternedVar(lang.NewSymbol("list")) - if tmp166.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp166))) - } - tmp167 := tmp166.Get() - tmp168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp169 := tmp168.FindInternedVar(lang.NewSymbol("seq")) - if tmp169.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp169))) - } - tmp170 := tmp169.Get() - tmp171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp172 := tmp171.FindInternedVar(lang.NewSymbol("concat")) - if tmp172.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp172))) - } - tmp173 := tmp172.Get() - tmp174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp175 := tmp174.FindInternedVar(lang.NewSymbol("list")) - if tmp175.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp175))) - } - tmp176 := tmp175.Get() - tmp177 := lang.Apply(tmp176, []any{lang.NewSymbol("def")}) - tmp178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp179 := tmp178.FindInternedVar(lang.NewSymbol("list")) - if tmp179.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp179))) - } - tmp180 := tmp179.Get() - tmp181 := lang.Apply(tmp180, []any{v101}) - tmp182 := lang.Apply(tmp173, []any{tmp177, tmp181}) - tmp183 := lang.Apply(tmp170, []any{tmp182}) - tmp184 := lang.Apply(tmp167, []any{tmp183}) - tmp185 := lang.Apply(tmp160, []any{tmp164, tmp184}) - tmp186 := lang.Apply(tmp157, []any{tmp185}) - tmp187 := lang.Apply(tmp151, []any{tmp154, tmp186}) - tmp188 := lang.Apply(tmp148, []any{tmp187}) - tmp189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp190 := tmp189.FindInternedVar(lang.NewSymbol("list")) - if tmp190.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp190))) - } - tmp191 := tmp190.Get() - tmp192 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp193 := tmp192.FindInternedVar(lang.NewSymbol("seq")) - if tmp193.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp193))) - } - tmp194 := tmp193.Get() - tmp195 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp196 := tmp195.FindInternedVar(lang.NewSymbol("concat")) - if tmp196.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp196))) - } - tmp197 := tmp196.Get() - tmp198 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp199 := tmp198.FindInternedVar(lang.NewSymbol("list")) - if tmp199.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp199))) - } - tmp200 := tmp199.Get() - tmp201 := lang.Apply(tmp200, []any{lang.NewSymbol("glojure.core/when-not")}) - tmp202 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp203 := tmp202.FindInternedVar(lang.NewSymbol("list")) - if tmp203.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp203))) - } - tmp204 := tmp203.Get() - tmp205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp206 := tmp205.FindInternedVar(lang.NewSymbol("seq")) - if tmp206.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp206))) - } - tmp207 := tmp206.Get() - tmp208 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp209 := tmp208.FindInternedVar(lang.NewSymbol("concat")) - if tmp209.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp209))) - } - tmp210 := tmp209.Get() - tmp211 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp212 := tmp211.FindInternedVar(lang.NewSymbol("list")) - if tmp212.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp212))) - } - tmp213 := tmp212.Get() - tmp214 := lang.Apply(tmp213, []any{lang.NewSymbol("glojure.core/and")}) - tmp215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp216 := tmp215.FindInternedVar(lang.NewSymbol("list")) - if tmp216.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp216))) - } - tmp217 := tmp216.Get() - tmp218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp219 := tmp218.FindInternedVar(lang.NewSymbol("seq")) - if tmp219.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp219))) - } - tmp220 := tmp219.Get() - tmp221 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp222 := tmp221.FindInternedVar(lang.NewSymbol("concat")) - if tmp222.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp222))) - } - tmp223 := tmp222.Get() - tmp224 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp225 := tmp224.FindInternedVar(lang.NewSymbol("list")) - if tmp225.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp225))) - } - tmp226 := tmp225.Get() - tmp227 := lang.Apply(tmp226, []any{lang.NewSymbol(".HasRoot")}) - tmp228 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp229 := tmp228.FindInternedVar(lang.NewSymbol("list")) - if tmp229.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp229))) - } - tmp230 := tmp229.Get() - tmp231 := lang.Apply(tmp230, []any{lang.NewSymbol("v__0__auto__")}) - tmp232 := lang.Apply(tmp223, []any{tmp227, tmp231}) - tmp233 := lang.Apply(tmp220, []any{tmp232}) - tmp234 := lang.Apply(tmp217, []any{tmp233}) - tmp235 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp236 := tmp235.FindInternedVar(lang.NewSymbol("list")) - if tmp236.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp236))) - } - tmp237 := tmp236.Get() - tmp238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp239 := tmp238.FindInternedVar(lang.NewSymbol("seq")) - if tmp239.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp239))) - } - tmp240 := tmp239.Get() - tmp241 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp242 := tmp241.FindInternedVar(lang.NewSymbol("concat")) - if tmp242.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp242))) - } - tmp243 := tmp242.Get() - tmp244 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp245 := tmp244.FindInternedVar(lang.NewSymbol("list")) - if tmp245.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp245))) - } - tmp246 := tmp245.Get() - tmp247 := lang.Apply(tmp246, []any{lang.NewSymbol("glojure.core/instance?")}) - tmp248 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp249 := tmp248.FindInternedVar(lang.NewSymbol("list")) - if tmp249.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp249))) - } - tmp250 := tmp249.Get() - tmp251 := lang.Apply(tmp250, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.*MultiFn")}) - tmp252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp253 := tmp252.FindInternedVar(lang.NewSymbol("list")) - if tmp253.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp253))) - } - tmp254 := tmp253.Get() - tmp255 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp256 := tmp255.FindInternedVar(lang.NewSymbol("seq")) - if tmp256.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp256))) - } - tmp257 := tmp256.Get() - tmp258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp259 := tmp258.FindInternedVar(lang.NewSymbol("concat")) - if tmp259.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp259))) - } - tmp260 := tmp259.Get() - tmp261 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp262 := tmp261.FindInternedVar(lang.NewSymbol("list")) - if tmp262.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp262))) - } - tmp263 := tmp262.Get() - tmp264 := lang.Apply(tmp263, []any{lang.NewSymbol("glojure.core/deref")}) - tmp265 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp266 := tmp265.FindInternedVar(lang.NewSymbol("list")) - if tmp266.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp266))) - } - tmp267 := tmp266.Get() - tmp268 := lang.Apply(tmp267, []any{lang.NewSymbol("v__0__auto__")}) - tmp269 := lang.Apply(tmp260, []any{tmp264, tmp268}) - tmp270 := lang.Apply(tmp257, []any{tmp269}) - tmp271 := lang.Apply(tmp254, []any{tmp270}) - tmp272 := lang.Apply(tmp243, []any{tmp247, tmp251, tmp271}) - tmp273 := lang.Apply(tmp240, []any{tmp272}) - tmp274 := lang.Apply(tmp237, []any{tmp273}) - tmp275 := lang.Apply(tmp210, []any{tmp214, tmp234, tmp274}) - tmp276 := lang.Apply(tmp207, []any{tmp275}) - tmp277 := lang.Apply(tmp204, []any{tmp276}) - tmp278 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp279 := tmp278.FindInternedVar(lang.NewSymbol("list")) - if tmp279.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp279))) - } - tmp280 := tmp279.Get() - tmp281 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp282 := tmp281.FindInternedVar(lang.NewSymbol("seq")) - if tmp282.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp282))) - } - tmp283 := tmp282.Get() - tmp284 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp285 := tmp284.FindInternedVar(lang.NewSymbol("concat")) - if tmp285.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp285))) - } - tmp286 := tmp285.Get() - tmp287 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp288 := tmp287.FindInternedVar(lang.NewSymbol("list")) - if tmp288.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp288))) - } - tmp289 := tmp288.Get() - tmp290 := lang.Apply(tmp289, []any{lang.NewSymbol("def")}) - tmp291 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp292 := tmp291.FindInternedVar(lang.NewSymbol("list")) - if tmp292.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp292))) - } - tmp293 := tmp292.Get() - tmp294 := lang.Apply(tmp293, []any{v101}) - tmp295 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp296 := tmp295.FindInternedVar(lang.NewSymbol("list")) - if tmp296.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp296))) - } - tmp297 := tmp296.Get() - tmp298 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp299 := tmp298.FindInternedVar(lang.NewSymbol("seq")) - if tmp299.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp299))) - } - tmp300 := tmp299.Get() - tmp301 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp302 := tmp301.FindInternedVar(lang.NewSymbol("concat")) - if tmp302.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp302))) - } - tmp303 := tmp302.Get() - tmp304 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp305 := tmp304.FindInternedVar(lang.NewSymbol("list")) - if tmp305.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp305))) - } - tmp306 := tmp305.Get() - tmp307 := lang.Apply(tmp306, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewMultiFn")}) - tmp308 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp309 := tmp308.FindInternedVar(lang.NewSymbol("list")) - if tmp309.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp309))) - } - tmp310 := tmp309.Get() - tmp311 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp312 := tmp311.FindInternedVar(lang.NewSymbol("name")) - if tmp312.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp312))) - } - tmp313 := tmp312.Get() - tmp314 := lang.Apply(tmp313, []any{v101}) - tmp315 := lang.Apply(tmp310, []any{tmp314}) - tmp316 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp317 := tmp316.FindInternedVar(lang.NewSymbol("list")) - if tmp317.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp317))) - } - tmp318 := tmp317.Get() - tmp319 := lang.Apply(tmp318, []any{v71}) - tmp320 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp321 := tmp320.FindInternedVar(lang.NewSymbol("list")) - if tmp321.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp321))) - } - tmp322 := tmp321.Get() - tmp323 := lang.Apply(tmp322, []any{v125}) - tmp324 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp325 := tmp324.FindInternedVar(lang.NewSymbol("list")) - if tmp325.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp325))) - } - tmp326 := tmp325.Get() - tmp327 := lang.Apply(tmp326, []any{v131}) - tmp328 := lang.Apply(tmp303, []any{tmp307, tmp315, tmp319, tmp323, tmp327}) - tmp329 := lang.Apply(tmp300, []any{tmp328}) - tmp330 := lang.Apply(tmp297, []any{tmp329}) - tmp331 := lang.Apply(tmp286, []any{tmp290, tmp294, tmp330}) - tmp332 := lang.Apply(tmp283, []any{tmp331}) - tmp333 := lang.Apply(tmp280, []any{tmp332}) - tmp334 := lang.Apply(tmp197, []any{tmp201, tmp277, tmp333}) - tmp335 := lang.Apply(tmp194, []any{tmp334}) - tmp336 := lang.Apply(tmp191, []any{tmp335}) - tmp337 := lang.Apply(tmp141, []any{tmp145, tmp188, tmp336}) - tmp338 := lang.Apply(tmp138, []any{tmp337}) - tmp112 = tmp338 - } // end let - tmp7 = tmp112 - } // end let - return tmp7 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // defn - { - tmp0 := lang.NewSymbol("defn").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("doc-string?"), lang.NewSymbol("attr-map?"), lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("prepost-map?"), lang.NewSymbol("body")), lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("doc-string?"), lang.NewSymbol("attr-map?"), lang.NewList(lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("prepost-map?"), lang.NewSymbol("body")), lang.NewSymbol("+"), lang.NewSymbol("attr-map?"))), lang.NewKeyword("doc"), "Same as (def name (fn [params* ] exprs*)) or (def\n name (fn ([params* ] exprs*)+)) with any doc-string or attrs added\n to the var metadata. prepost-map defines a map with optional keys\n :pre and :post that contain collections of pre or post conditions.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(284), lang.NewKeyword("end-line"), int(291))).(*lang.Symbol) - var tmp2 lang.FnFunc - { // function defn - var v3 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - v6 := args[2] - _ = v6 - var v7 any = lang.NewList(args[3:]...) - _ = v7 - var tmp8 any - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("instance?")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := reflect.TypeOf((*lang.Symbol)(nil)) - tmp13 := lang.Apply(tmp11, []any{tmp12, v6}) - if lang.IsTruthy(tmp13) { - } else { - tmp14 := lang.Apply(lang.NewIllegalArgumentError, []any{"First argument to defn must be a symbol"}) - panic(tmp14) - } - _ = tmp8 - var tmp15 any - { // let - // let binding "m" - var tmp16 any - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("string?")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("first")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.Apply(tmp22, []any{v7}) - tmp24 := lang.Apply(tmp19, []any{tmp23}) - if lang.IsTruthy(tmp24) { - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("first")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.Apply(tmp27, []any{v7}) - tmp29 := lang.NewMap(lang.NewKeyword("doc"), tmp28) - tmp30 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(297), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(297), lang.NewKeyword("end-column"), int(38)) - tmp31, err := lang.WithMeta(tmp29, tmp30.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp16 = tmp31 - } else { - tmp32 := lang.NewMap() - tmp33 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(298), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(298), lang.NewKeyword("end-column"), int(20)) - tmp34, err := lang.WithMeta(tmp32, tmp33.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp16 = tmp34 - } - var v35 any = tmp16 - _ = v35 - // let binding "fdecl" - var tmp36 any - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("string?")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("first")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.Apply(tmp42, []any{v7}) - tmp44 := lang.Apply(tmp39, []any{tmp43}) - if lang.IsTruthy(tmp44) { - tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp46 := tmp45.FindInternedVar(lang.NewSymbol("next")) - if tmp46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) - } - tmp47 := tmp46.Get() - tmp48 := lang.Apply(tmp47, []any{v7}) - tmp36 = tmp48 - } else { - tmp36 = v7 - } - var v49 any = tmp36 - _ = v49 - // let binding "m" - var tmp50 any - tmp51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp52 := tmp51.FindInternedVar(lang.NewSymbol("map?")) - if tmp52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp52))) - } - tmp53 := tmp52.Get() - tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp55 := tmp54.FindInternedVar(lang.NewSymbol("first")) - if tmp55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) - } - tmp56 := tmp55.Get() - tmp57 := lang.Apply(tmp56, []any{v49}) - tmp58 := lang.Apply(tmp53, []any{tmp57}) - if lang.IsTruthy(tmp58) { - tmp59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp60 := tmp59.FindInternedVar(lang.NewSymbol("conj")) - if tmp60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp60))) - } - tmp61 := tmp60.Get() - tmp62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp63 := tmp62.FindInternedVar(lang.NewSymbol("first")) - if tmp63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp63))) - } - tmp64 := tmp63.Get() - tmp65 := lang.Apply(tmp64, []any{v49}) - tmp66 := lang.Apply(tmp61, []any{v35, tmp65}) - tmp50 = tmp66 - } else { - tmp50 = v35 - } - var v67 any = tmp50 - _ = v67 - // let binding "fdecl" - var tmp68 any - tmp69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp70 := tmp69.FindInternedVar(lang.NewSymbol("map?")) - if tmp70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp70))) - } - tmp71 := tmp70.Get() - tmp72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp73 := tmp72.FindInternedVar(lang.NewSymbol("first")) - if tmp73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp73))) - } - tmp74 := tmp73.Get() - tmp75 := lang.Apply(tmp74, []any{v49}) - tmp76 := lang.Apply(tmp71, []any{tmp75}) - if lang.IsTruthy(tmp76) { - tmp77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp78 := tmp77.FindInternedVar(lang.NewSymbol("next")) - if tmp78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp78))) - } - tmp79 := tmp78.Get() - tmp80 := lang.Apply(tmp79, []any{v49}) - tmp68 = tmp80 - } else { - tmp68 = v49 - } - var v81 any = tmp68 - _ = v81 - // let binding "fdecl" - var tmp82 any - tmp83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp84 := tmp83.FindInternedVar(lang.NewSymbol("vector?")) - if tmp84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp84))) - } - tmp85 := tmp84.Get() - tmp86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp87 := tmp86.FindInternedVar(lang.NewSymbol("first")) - if tmp87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp87))) - } - tmp88 := tmp87.Get() - tmp89 := lang.Apply(tmp88, []any{v81}) - tmp90 := lang.Apply(tmp85, []any{tmp89}) - if lang.IsTruthy(tmp90) { - tmp91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp92 := tmp91.FindInternedVar(lang.NewSymbol("list")) - if tmp92.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp92))) - } - tmp93 := tmp92.Get() - tmp94 := lang.Apply(tmp93, []any{v81}) - tmp82 = tmp94 - } else { - tmp82 = v81 - } - var v95 any = tmp82 - _ = v95 - // let binding "m" - var tmp96 any - tmp97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp98 := tmp97.FindInternedVar(lang.NewSymbol("map?")) - if tmp98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp98))) - } - tmp99 := tmp98.Get() - tmp100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp101 := tmp100.FindInternedVar(lang.NewSymbol("last")) - if tmp101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp101))) - } - tmp102 := tmp101.Get() - tmp103 := lang.Apply(tmp102, []any{v95}) - tmp104 := lang.Apply(tmp99, []any{tmp103}) - if lang.IsTruthy(tmp104) { - tmp105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp106 := tmp105.FindInternedVar(lang.NewSymbol("conj")) - if tmp106.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp106))) - } - tmp107 := tmp106.Get() - tmp108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp109 := tmp108.FindInternedVar(lang.NewSymbol("last")) - if tmp109.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp109))) - } - tmp110 := tmp109.Get() - tmp111 := lang.Apply(tmp110, []any{v95}) - tmp112 := lang.Apply(tmp107, []any{v67, tmp111}) - tmp96 = tmp112 - } else { - tmp96 = v67 - } - var v113 any = tmp96 - _ = v113 - // let binding "fdecl" - var tmp114 any - tmp115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp116 := tmp115.FindInternedVar(lang.NewSymbol("map?")) - if tmp116.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp116))) - } - tmp117 := tmp116.Get() - tmp118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp119 := tmp118.FindInternedVar(lang.NewSymbol("last")) - if tmp119.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp119))) - } - tmp120 := tmp119.Get() - tmp121 := lang.Apply(tmp120, []any{v95}) - tmp122 := lang.Apply(tmp117, []any{tmp121}) - if lang.IsTruthy(tmp122) { - tmp123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp124 := tmp123.FindInternedVar(lang.NewSymbol("butlast")) - if tmp124.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp124))) - } - tmp125 := tmp124.Get() - tmp126 := lang.Apply(tmp125, []any{v95}) - tmp114 = tmp126 - } else { - tmp114 = v95 - } - var v127 any = tmp114 - _ = v127 - // let binding "m" - tmp128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp129 := tmp128.FindInternedVar(lang.NewSymbol("conj")) - if tmp129.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp129))) - } - tmp130 := tmp129.Get() - tmp131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp132 := tmp131.FindInternedVar(lang.NewSymbol("list")) - if tmp132.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp132))) - } - tmp133 := tmp132.Get() - tmp134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp135 := tmp134.FindInternedVar(lang.NewSymbol("sigs")) - if tmp135.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp135))) - } - tmp136 := tmp135.Get() - tmp137 := lang.Apply(tmp136, []any{v127}) - tmp138 := lang.Apply(tmp133, []any{lang.NewSymbol("quote"), tmp137}) - tmp139 := lang.NewMap(lang.NewKeyword("arglists"), tmp138) - tmp140 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(317), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(317), lang.NewKeyword("end-column"), int(60)) - tmp141, err := lang.WithMeta(tmp139, tmp140.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp142 := lang.Apply(tmp130, []any{tmp141, v113}) - var v143 any = tmp142 - _ = v143 - // let binding "m" - var tmp144 any - { // let - // let binding "inline" - tmp145 := lang.Apply(lang.NewKeyword("inline"), []any{v143}) - var v146 any = tmp145 - _ = v146 - // let binding "ifn" - tmp147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp148 := tmp147.FindInternedVar(lang.NewSymbol("first")) - if tmp148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp148))) - } - tmp149 := tmp148.Get() - tmp150 := lang.Apply(tmp149, []any{v146}) - var v151 any = tmp150 - _ = v151 - // let binding "iname" - tmp152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp153 := tmp152.FindInternedVar(lang.NewSymbol("second")) - if tmp153.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp153))) - } - tmp154 := tmp153.Get() - tmp155 := lang.Apply(tmp154, []any{v146}) - var v156 any = tmp155 - _ = v156 - var tmp157 any - var tmp158 any - tmp159 := lang.Apply(lang.Equiv, []any{lang.NewSymbol("fn"), v151}) - if lang.IsTruthy(tmp159) { - var tmp160 any - tmp161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp162 := tmp161.FindInternedVar(lang.NewSymbol("instance?")) - if tmp162.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp162))) - } - tmp163 := tmp162.Get() - tmp164 := reflect.TypeOf((*lang.Symbol)(nil)) - tmp165 := lang.Apply(tmp163, []any{tmp164, v156}) - if lang.IsTruthy(tmp165) { - tmp160 = false - } else { - tmp160 = true - } - tmp158 = tmp160 - } else { - } - if lang.IsTruthy(tmp158) { - tmp166 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp167 := tmp166.FindInternedVar(lang.NewSymbol("assoc")) - if tmp167.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp167))) - } - tmp168 := tmp167.Get() - tmp169 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp170 := tmp169.FindInternedVar(lang.NewSymbol("cons")) - if tmp170.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp170))) - } - tmp171 := tmp170.Get() - tmp172 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp173 := tmp172.FindInternedVar(lang.NewSymbol("cons")) - if tmp173.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp173))) - } - tmp174 := tmp173.Get() - tmp175, ok := lang.FieldOrMethod(v6, "Name") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "Name"))) - } - var tmp176 any - switch reflect.TypeOf(tmp175).Kind() { - case reflect.Func: - tmp176 = lang.Apply(tmp175, nil) - default: - tmp176 = tmp175 - } - tmp177 := lang.Apply(lang.ConcatStrings, []any{tmp176, "__inliner"}) - tmp178 := lang.Apply(lang.NewSymbol, []any{tmp177}) - tmp179 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp180 := tmp179.FindInternedVar(lang.NewSymbol("next")) - if tmp180.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp180))) - } - tmp181 := tmp180.Get() - tmp182 := lang.Apply(tmp181, []any{v146}) - tmp183 := lang.Apply(tmp174, []any{tmp178, tmp182}) - tmp184 := lang.Apply(tmp171, []any{v151, tmp183}) - tmp185 := lang.Apply(tmp168, []any{v143, lang.NewKeyword("inline"), tmp184}) - tmp157 = tmp185 - } else { - tmp157 = v143 - } - tmp144 = tmp157 - } // end let - var v145 any = tmp144 - _ = v145 - // let binding "m" - tmp146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp147 := tmp146.FindInternedVar(lang.NewSymbol("conj")) - if tmp147.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp147))) - } - tmp148 := tmp147.Get() - var tmp149 any - tmp150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp151 := tmp150.FindInternedVar(lang.NewSymbol("meta")) - if tmp151.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp151))) - } - tmp152 := tmp151.Get() - tmp153 := lang.Apply(tmp152, []any{v6}) - if lang.IsTruthy(tmp153) { - tmp154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp155 := tmp154.FindInternedVar(lang.NewSymbol("meta")) - if tmp155.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp155))) - } - tmp156 := tmp155.Get() - tmp157 := lang.Apply(tmp156, []any{v6}) - tmp149 = tmp157 - } else { - tmp158 := lang.NewMap() - tmp159 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(328), lang.NewKeyword("column"), int(51), lang.NewKeyword("end-line"), int(328), lang.NewKeyword("end-column"), int(52)) - tmp160, err := lang.WithMeta(tmp158, tmp159.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp149 = tmp160 - } - tmp161 := lang.Apply(tmp148, []any{tmp149, v145}) - var v162 any = tmp161 - _ = v162 - tmp163 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp164 := tmp163.FindInternedVar(lang.NewSymbol("list")) - if tmp164.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp164))) - } - tmp165 := tmp164.Get() - tmp166 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp167 := tmp166.FindInternedVar(lang.NewSymbol("with-meta")) - if tmp167.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp167))) - } - tmp168 := tmp167.Get() - tmp169 := lang.Apply(tmp168, []any{v6, v162}) - tmp170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp171 := tmp170.FindInternedVar(lang.NewSymbol("with-meta")) - if tmp171.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp171))) - } - tmp172 := tmp171.Get() - tmp173 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp174 := tmp173.FindInternedVar(lang.NewSymbol("cons")) - if tmp174.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp174))) - } - tmp175 := tmp174.Get() - tmp176 := lang.Apply(tmp175, []any{lang.NewSymbol("glojure.core/fn"), v127}) - tmp177 := lang.Apply(lang.NewKeyword("tag"), []any{v162}) - tmp178 := lang.NewMap(lang.NewKeyword("rettag"), tmp177) - tmp179 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(333), lang.NewKeyword("column"), int(37), lang.NewKeyword("end-line"), int(333), lang.NewKeyword("end-column"), int(54)) - tmp180, err := lang.WithMeta(tmp178, tmp179.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp181 := lang.Apply(tmp172, []any{tmp176, tmp180}) - tmp182 := lang.Apply(tmp165, []any{lang.NewSymbol("def"), tmp169, tmp181}) - tmp15 = tmp182 - } // end let - return tmp15 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(291), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(333), lang.NewKeyword("end-column"), int(58))).(lang.FnFunc) - v3 = tmp2 - _ = v3 - } - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // defn- - { - tmp0 := lang.NewSymbol("defn-").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("decls"))), lang.NewKeyword("doc"), "same as defn, yielding non-public def", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4949), lang.NewKeyword("end-line"), int(4949))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("list*")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("with-meta")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("assoc")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("meta")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{v5}) - tmp20 := lang.Apply(tmp15, []any{tmp19, lang.NewKeyword("private"), true}) - tmp21 := lang.Apply(tmp12, []any{v5, tmp20}) - tmp22 := lang.Apply(tmp9, []any{lang.NewSymbol("glojure.core/defn"), tmp21, v6}) - return tmp22 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // defonce - { - tmp0 := lang.NewSymbol("defonce").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("expr"))), lang.NewKeyword("doc"), "defs name to have the root value of the expr iff the named var has no root value,\n else expr is unevaluated", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5806), lang.NewKeyword("end-line"), int(5806))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("seq")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("concat")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("list")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("glojure.core/let")}) - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("list")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("apply")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("vector")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("seq")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("concat")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.Apply(tmp34, []any{lang.NewSymbol("v__0__auto__")}) - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp40 := tmp39.FindInternedVar(lang.NewSymbol("seq")) - if tmp40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) - } - tmp41 := tmp40.Get() - tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp43 := tmp42.FindInternedVar(lang.NewSymbol("concat")) - if tmp43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) - } - tmp44 := tmp43.Get() - tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp46 := tmp45.FindInternedVar(lang.NewSymbol("list")) - if tmp46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) - } - tmp47 := tmp46.Get() - tmp48 := lang.Apply(tmp47, []any{lang.NewSymbol("def")}) - tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp50 := tmp49.FindInternedVar(lang.NewSymbol("list")) - if tmp50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) - } - tmp51 := tmp50.Get() - tmp52 := lang.Apply(tmp51, []any{v5}) - tmp53 := lang.Apply(tmp44, []any{tmp48, tmp52}) - tmp54 := lang.Apply(tmp41, []any{tmp53}) - tmp55 := lang.Apply(tmp38, []any{tmp54}) - tmp56 := lang.Apply(tmp31, []any{tmp35, tmp55}) - tmp57 := lang.Apply(tmp28, []any{tmp56}) - tmp58 := lang.Apply(tmp22, []any{tmp25, tmp57}) - tmp59 := lang.Apply(tmp19, []any{tmp58}) - tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp61 := tmp60.FindInternedVar(lang.NewSymbol("list")) - if tmp61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) - } - tmp62 := tmp61.Get() - tmp63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp64 := tmp63.FindInternedVar(lang.NewSymbol("seq")) - if tmp64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp64))) - } - tmp65 := tmp64.Get() - tmp66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp67 := tmp66.FindInternedVar(lang.NewSymbol("concat")) - if tmp67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp67))) - } - tmp68 := tmp67.Get() - tmp69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp70 := tmp69.FindInternedVar(lang.NewSymbol("list")) - if tmp70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp70))) - } - tmp71 := tmp70.Get() - tmp72 := lang.Apply(tmp71, []any{lang.NewSymbol("glojure.core/when-not")}) - tmp73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp74 := tmp73.FindInternedVar(lang.NewSymbol("list")) - if tmp74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp74))) - } - tmp75 := tmp74.Get() - tmp76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp77 := tmp76.FindInternedVar(lang.NewSymbol("seq")) - if tmp77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp77))) - } - tmp78 := tmp77.Get() - tmp79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp80 := tmp79.FindInternedVar(lang.NewSymbol("concat")) - if tmp80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp80))) - } - tmp81 := tmp80.Get() - tmp82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp83 := tmp82.FindInternedVar(lang.NewSymbol("list")) - if tmp83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp83))) - } - tmp84 := tmp83.Get() - tmp85 := lang.Apply(tmp84, []any{lang.NewSymbol(".HasRoot")}) - tmp86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp87 := tmp86.FindInternedVar(lang.NewSymbol("list")) - if tmp87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp87))) - } - tmp88 := tmp87.Get() - tmp89 := lang.Apply(tmp88, []any{lang.NewSymbol("v__0__auto__")}) - tmp90 := lang.Apply(tmp81, []any{tmp85, tmp89}) - tmp91 := lang.Apply(tmp78, []any{tmp90}) - tmp92 := lang.Apply(tmp75, []any{tmp91}) - tmp93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp94 := tmp93.FindInternedVar(lang.NewSymbol("list")) - if tmp94.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp94))) - } - tmp95 := tmp94.Get() - tmp96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp97 := tmp96.FindInternedVar(lang.NewSymbol("seq")) - if tmp97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp97))) - } - tmp98 := tmp97.Get() - tmp99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp100 := tmp99.FindInternedVar(lang.NewSymbol("concat")) - if tmp100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp100))) - } - tmp101 := tmp100.Get() - tmp102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp103 := tmp102.FindInternedVar(lang.NewSymbol("list")) - if tmp103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp103))) - } - tmp104 := tmp103.Get() - tmp105 := lang.Apply(tmp104, []any{lang.NewSymbol("def")}) - tmp106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp107 := tmp106.FindInternedVar(lang.NewSymbol("list")) - if tmp107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp107))) - } - tmp108 := tmp107.Get() - tmp109 := lang.Apply(tmp108, []any{v5}) - tmp110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp111 := tmp110.FindInternedVar(lang.NewSymbol("list")) - if tmp111.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp111))) - } - tmp112 := tmp111.Get() - tmp113 := lang.Apply(tmp112, []any{v6}) - tmp114 := lang.Apply(tmp101, []any{tmp105, tmp109, tmp113}) - tmp115 := lang.Apply(tmp98, []any{tmp114}) - tmp116 := lang.Apply(tmp95, []any{tmp115}) - tmp117 := lang.Apply(tmp68, []any{tmp72, tmp92, tmp116}) - tmp118 := lang.Apply(tmp65, []any{tmp117}) - tmp119 := lang.Apply(tmp62, []any{tmp118}) - tmp120 := lang.Apply(tmp12, []any{tmp16, tmp59, tmp119}) - tmp121 := lang.Apply(tmp9, []any{tmp120}) - return tmp121 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // defprotocol - { - tmp0 := lang.NewSymbol("defprotocol").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("opts+sigs"))), lang.NewKeyword("doc"), "A protocol is a named set of named methods and their signatures:\n (defprotocol AProtocolName\n\n ;optional doc string\n \"A doc string for AProtocol abstraction\"\n\n ;options\n :extend-via-metadata true\n\n ;method signatures\n (bar [this a b] \"bar docs\")\n (baz [this a] [this a b] [this a b c] \"baz docs\"))\n\n No implementations are provided. Docs can be specified for the\n protocol overall and for each method. The above yields a set of\n polymorphic functions and a protocol object. All are\n namespace-qualified by the ns enclosing the definition The resulting\n functions dispatch on the type of their first argument, which is\n required and corresponds to the implicit target object ('this' in \n Java parlance). defprotocol is dynamic, has no special compile-time \n effect, and defines no new types or classes. Implementations of \n the protocol methods can be provided using extend.\n\n When :extend-via-metadata is true, values can extend protocols by\n adding metadata where keys are fully-qualified protocol function\n symbols and values are function implementations. Protocol\n implementations are checked first for direct definitions (defrecord,\n deftype, reify), then metadata definitions, then external\n extensions (extend, extend-type, extend-protocol)\n\n defprotocol will automatically generate a corresponding interface,\n with the same name as the protocol, i.e. given a protocol:\n my.ns/Protocol, an interface: my.ns.Protocol. The interface will\n have methods corresponding to the protocol functions, and the\n protocol will automatically work with instances of the interface.\n\n Note that you should not use this interface with deftype or\n reify, as they support the protocol directly:\n\n (defprotocol P \n (foo [this]) \n (bar-me [this] [this y]))\n\n (deftype Foo [a b c] \n P\n (foo [this] a)\n (bar-me [this] b)\n (bar-me [this y] (+ c y)))\n \n (bar-me (Foo. 1 2 3) 42)\n => 45\n\n (foo \n (let [x 42]\n (reify P \n (foo [this] 17)\n (bar-me [this] x)\n (bar-me [this y] x))))\n => 17", lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(28), lang.NewKeyword("end-line"), int(28))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any - { // let - // let binding "doc" - var tmp8 any - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("string?")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("first")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.Apply(tmp14, []any{v6}) - tmp16 := lang.Apply(tmp11, []any{tmp15}) - if lang.IsTruthy(tmp16) { - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("first")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.Apply(tmp19, []any{v6}) - tmp8 = tmp20 - } else { - } - var v21 any = tmp8 - _ = v21 - // let binding "opts+sigs" - var tmp22 any - if lang.IsTruthy(v21) { - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("rest")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.Apply(tmp25, []any{v6}) - tmp22 = tmp26 - } else { - tmp22 = v6 - } - var v27 any = tmp22 - _ = v27 - // let binding "opts" - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("take-while")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - var tmp31 lang.FnFunc - tmp31 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v32 := args[0] - _ = v32 - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("not")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("seq?")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{v32}) - tmp40 := lang.Apply(tmp35, []any{tmp39}) - return tmp40 - }) - tmp32 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(92), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(92), lang.NewKeyword("end-column"), int(40)) - tmp33, err := lang.WithMeta(tmp31, tmp32.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp34 := lang.Apply(tmp30, []any{tmp33, v27}) - var v35 any = tmp34 - _ = v35 - // let binding "sigs" - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("drop-while")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - var tmp39 lang.FnFunc - tmp39 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v40 := args[0] - _ = v40 - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("not")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("seq?")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.Apply(tmp46, []any{v40}) - tmp48 := lang.Apply(tmp43, []any{tmp47}) - return tmp48 - }) - tmp40 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(93), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(93), lang.NewKeyword("end-column"), int(40)) - tmp41, err := lang.WithMeta(tmp39, tmp40.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp42 := lang.Apply(tmp38, []any{tmp41, v27}) - var v43 any = tmp42 - _ = v43 - // let binding "opts" - var tmp44 any - tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp46 := tmp45.FindInternedVar(lang.NewSymbol("=")) - if tmp46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) - } - tmp47 := tmp46.Get() - tmp48 := lang.Apply(tmp47, []any{v43, v35}) - if lang.IsTruthy(tmp48) { - } else { - tmp44 = v35 - } - var v49 any = tmp44 - _ = v49 - tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp51 := tmp50.FindInternedVar(lang.NewSymbol("seq")) - if tmp51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) - } - tmp52 := tmp51.Get() - tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp54 := tmp53.FindInternedVar(lang.NewSymbol("concat")) - if tmp54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) - } - tmp55 := tmp54.Get() - tmp56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp57 := tmp56.FindInternedVar(lang.NewSymbol("list")) - if tmp57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp57))) - } - tmp58 := tmp57.Get() - tmp59 := lang.Apply(tmp58, []any{lang.NewSymbol("do")}) - tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp61 := tmp60.FindInternedVar(lang.NewSymbol("list")) - if tmp61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) - } - tmp62 := tmp61.Get() - tmp63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp64 := tmp63.FindInternedVar(lang.NewSymbol("seq")) - if tmp64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp64))) - } - tmp65 := tmp64.Get() - tmp66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp67 := tmp66.FindInternedVar(lang.NewSymbol("concat")) - if tmp67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp67))) - } - tmp68 := tmp67.Get() - tmp69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp70 := tmp69.FindInternedVar(lang.NewSymbol("list")) - if tmp70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp70))) - } - tmp71 := tmp70.Get() - tmp72 := lang.Apply(tmp71, []any{lang.NewSymbol("def")}) - tmp73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp74 := tmp73.FindInternedVar(lang.NewSymbol("list")) - if tmp74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp74))) - } - tmp75 := tmp74.Get() - tmp76 := lang.Apply(tmp75, []any{v5}) - tmp77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp78 := tmp77.FindInternedVar(lang.NewSymbol("list")) - if tmp78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp78))) - } - tmp79 := tmp78.Get() - tmp80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp81 := tmp80.FindInternedVar(lang.NewSymbol("seq")) - if tmp81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp81))) - } - tmp82 := tmp81.Get() - tmp83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp84 := tmp83.FindInternedVar(lang.NewSymbol("concat")) - if tmp84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp84))) - } - tmp85 := tmp84.Get() - tmp86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp87 := tmp86.FindInternedVar(lang.NewSymbol("list")) - if tmp87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp87))) - } - tmp88 := tmp87.Get() - tmp89 := lang.Apply(tmp88, []any{lang.NewSymbol("glojure.core/atom")}) - tmp90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp91 := tmp90.FindInternedVar(lang.NewSymbol("list")) - if tmp91.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp91))) - } - tmp92 := tmp91.Get() - tmp93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp94 := tmp93.FindInternedVar(lang.NewSymbol("apply")) - if tmp94.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp94))) - } - tmp95 := tmp94.Get() - tmp96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp97 := tmp96.FindInternedVar(lang.NewSymbol("hash-map")) - if tmp97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp97))) - } - tmp98 := tmp97.Get() - tmp99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp100 := tmp99.FindInternedVar(lang.NewSymbol("seq")) - if tmp100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp100))) - } - tmp101 := tmp100.Get() - tmp102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp103 := tmp102.FindInternedVar(lang.NewSymbol("concat")) - if tmp103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp103))) - } - tmp104 := tmp103.Get() - tmp105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp106 := tmp105.FindInternedVar(lang.NewSymbol("list")) - if tmp106.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp106))) - } - tmp107 := tmp106.Get() - tmp108 := lang.Apply(tmp107, []any{lang.NewKeyword("on-interface")}) - tmp109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp110 := tmp109.FindInternedVar(lang.NewSymbol("list")) - if tmp110.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp110))) - } - tmp111 := tmp110.Get() - tmp112 := lang.Apply(tmp111, []any{true}) - tmp113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp114 := tmp113.FindInternedVar(lang.NewSymbol("list")) - if tmp114.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp114))) - } - tmp115 := tmp114.Get() - tmp116 := lang.Apply(tmp115, []any{lang.NewKeyword("sigs")}) - tmp117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp118 := tmp117.FindInternedVar(lang.NewSymbol("list")) - if tmp118.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp118))) - } - tmp119 := tmp118.Get() - tmp120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp121 := tmp120.FindInternedVar(lang.NewSymbol("seq")) - if tmp121.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp121))) - } - tmp122 := tmp121.Get() - tmp123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp124 := tmp123.FindInternedVar(lang.NewSymbol("concat")) - if tmp124.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp124))) - } - tmp125 := tmp124.Get() - tmp126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp127 := tmp126.FindInternedVar(lang.NewSymbol("list")) - if tmp127.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp127))) - } - tmp128 := tmp127.Get() - tmp129 := lang.Apply(tmp128, []any{lang.NewSymbol("quote")}) - tmp130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp131 := tmp130.FindInternedVar(lang.NewSymbol("list")) - if tmp131.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp131))) - } - tmp132 := tmp131.Get() - tmp133 := lang.Apply(tmp132, []any{v43}) - tmp134 := lang.Apply(tmp125, []any{tmp129, tmp133}) - tmp135 := lang.Apply(tmp122, []any{tmp134}) - tmp136 := lang.Apply(tmp119, []any{tmp135}) - tmp137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp138 := tmp137.FindInternedVar(lang.NewSymbol("list")) - if tmp138.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp138))) - } - tmp139 := tmp138.Get() - tmp140 := lang.Apply(tmp139, []any{lang.NewKeyword("multis")}) - tmp141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp142 := tmp141.FindInternedVar(lang.NewSymbol("list")) - if tmp142.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp142))) - } - tmp143 := tmp142.Get() - tmp144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp145 := tmp144.FindInternedVar(lang.NewSymbol("apply")) - if tmp145.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp145))) - } - tmp146 := tmp145.Get() - tmp147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp148 := tmp147.FindInternedVar(lang.NewSymbol("hash-map")) - if tmp148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp148))) - } - tmp149 := tmp148.Get() - tmp150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp151 := tmp150.FindInternedVar(lang.NewSymbol("seq")) - if tmp151.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp151))) - } - tmp152 := tmp151.Get() - tmp153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp154 := tmp153.FindInternedVar(lang.NewSymbol("concat")) - if tmp154.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp154))) - } - tmp155 := tmp154.Get() - tmp156 := lang.Apply(tmp155, nil) - tmp157 := lang.Apply(tmp152, []any{tmp156}) - tmp158 := lang.Apply(tmp146, []any{tmp149, tmp157}) - tmp159 := lang.Apply(tmp143, []any{tmp158}) - tmp160 := lang.Apply(tmp104, []any{tmp108, tmp112, tmp116, tmp136, tmp140, tmp159}) - tmp161 := lang.Apply(tmp101, []any{tmp160}) - tmp162 := lang.Apply(tmp95, []any{tmp98, tmp161}) - tmp163 := lang.Apply(tmp92, []any{tmp162}) - tmp164 := lang.Apply(tmp85, []any{tmp89, tmp163}) - tmp165 := lang.Apply(tmp82, []any{tmp164}) - tmp166 := lang.Apply(tmp79, []any{tmp165}) - tmp167 := lang.Apply(tmp68, []any{tmp72, tmp76, tmp166}) - tmp168 := lang.Apply(tmp65, []any{tmp167}) - tmp169 := lang.Apply(tmp62, []any{tmp168}) - tmp170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp171 := tmp170.FindInternedVar(lang.NewSymbol("list")) - if tmp171.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp171))) - } - tmp172 := tmp171.Get() - tmp173 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp174 := tmp173.FindInternedVar(lang.NewSymbol("seq")) - if tmp174.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp174))) - } - tmp175 := tmp174.Get() - tmp176 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp177 := tmp176.FindInternedVar(lang.NewSymbol("concat")) - if tmp177.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp177))) - } - tmp178 := tmp177.Get() - tmp179 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp180 := tmp179.FindInternedVar(lang.NewSymbol("list")) - if tmp180.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp180))) - } - tmp181 := tmp180.Get() - tmp182 := lang.Apply(tmp181, []any{lang.NewSymbol("glojure.core/swap!")}) - tmp183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp184 := tmp183.FindInternedVar(lang.NewSymbol("list")) - if tmp184.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp184))) - } - tmp185 := tmp184.Get() - tmp186 := lang.Apply(tmp185, []any{lang.NewSymbol("glojure.core/-protocols")}) - tmp187 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp188 := tmp187.FindInternedVar(lang.NewSymbol("list")) - if tmp188.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp188))) - } - tmp189 := tmp188.Get() - tmp190 := lang.Apply(tmp189, []any{lang.NewSymbol("glojure.core/assoc")}) - tmp191 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp192 := tmp191.FindInternedVar(lang.NewSymbol("list")) - if tmp192.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp192))) - } - tmp193 := tmp192.Get() - tmp194 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp195 := tmp194.FindInternedVar(lang.NewSymbol("seq")) - if tmp195.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp195))) - } - tmp196 := tmp195.Get() - tmp197 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp198 := tmp197.FindInternedVar(lang.NewSymbol("concat")) - if tmp198.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp198))) - } - tmp199 := tmp198.Get() - tmp200 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp201 := tmp200.FindInternedVar(lang.NewSymbol("list")) - if tmp201.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp201))) - } - tmp202 := tmp201.Get() - tmp203 := lang.Apply(tmp202, []any{lang.NewSymbol("quote")}) - tmp204 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp205 := tmp204.FindInternedVar(lang.NewSymbol("list")) - if tmp205.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp205))) - } - tmp206 := tmp205.Get() - tmp207 := lang.Apply(tmp206, []any{v5}) - tmp208 := lang.Apply(tmp199, []any{tmp203, tmp207}) - tmp209 := lang.Apply(tmp196, []any{tmp208}) - tmp210 := lang.Apply(tmp193, []any{tmp209}) - tmp211 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp212 := tmp211.FindInternedVar(lang.NewSymbol("list")) - if tmp212.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp212))) - } - tmp213 := tmp212.Get() - tmp214 := lang.Apply(tmp213, []any{v5}) - tmp215 := lang.Apply(tmp178, []any{tmp182, tmp186, tmp190, tmp210, tmp214}) - tmp216 := lang.Apply(tmp175, []any{tmp215}) - tmp217 := lang.Apply(tmp172, []any{tmp216}) - tmp218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp219 := tmp218.FindInternedVar(lang.NewSymbol("map")) - if tmp219.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp219))) - } - tmp220 := tmp219.Get() - var tmp221 lang.FnFunc - tmp221 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v222 := args[0] - _ = v222 - tmp223 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp224 := tmp223.FindInternedVar(lang.NewSymbol("seq")) - if tmp224.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp224))) - } - tmp225 := tmp224.Get() - tmp226 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp227 := tmp226.FindInternedVar(lang.NewSymbol("concat")) - if tmp227.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp227))) - } - tmp228 := tmp227.Get() - tmp229 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp230 := tmp229.FindInternedVar(lang.NewSymbol("list")) - if tmp230.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp230))) - } - tmp231 := tmp230.Get() - tmp232 := lang.Apply(tmp231, []any{lang.NewSymbol("do")}) - tmp233 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp234 := tmp233.FindInternedVar(lang.NewSymbol("list")) - if tmp234.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp234))) - } - tmp235 := tmp234.Get() - tmp236 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp237 := tmp236.FindInternedVar(lang.NewSymbol("seq")) - if tmp237.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp237))) - } - tmp238 := tmp237.Get() - tmp239 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp240 := tmp239.FindInternedVar(lang.NewSymbol("concat")) - if tmp240.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp240))) - } - tmp241 := tmp240.Get() - tmp242 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp243 := tmp242.FindInternedVar(lang.NewSymbol("list")) - if tmp243.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp243))) - } - tmp244 := tmp243.Get() - tmp245 := lang.Apply(tmp244, []any{lang.NewSymbol("glojure.core/defmulti")}) - tmp246 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp247 := tmp246.FindInternedVar(lang.NewSymbol("list")) - if tmp247.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp247))) - } - tmp248 := tmp247.Get() - tmp249 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp250 := tmp249.FindInternedVar(lang.NewSymbol("first")) - if tmp250.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp250))) - } - tmp251 := tmp250.Get() - tmp252 := lang.Apply(tmp251, []any{v222}) - tmp253 := lang.Apply(tmp248, []any{tmp252}) - tmp254 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp255 := tmp254.FindInternedVar(lang.NewSymbol("list")) - if tmp255.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp255))) - } - tmp256 := tmp255.Get() - tmp257 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp258 := tmp257.FindInternedVar(lang.NewSymbol("seq")) - if tmp258.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp258))) - } - tmp259 := tmp258.Get() - tmp260 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp261 := tmp260.FindInternedVar(lang.NewSymbol("concat")) - if tmp261.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp261))) - } - tmp262 := tmp261.Get() - tmp263 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp264 := tmp263.FindInternedVar(lang.NewSymbol("list")) - if tmp264.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp264))) - } - tmp265 := tmp264.Get() - tmp266 := lang.Apply(tmp265, []any{lang.NewSymbol("glojure.core/fn")}) - tmp267 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp268 := tmp267.FindInternedVar(lang.NewSymbol("list")) - if tmp268.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp268))) - } - tmp269 := tmp268.Get() - tmp270 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp271 := tmp270.FindInternedVar(lang.NewSymbol("apply")) - if tmp271.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp271))) - } - tmp272 := tmp271.Get() - tmp273 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp274 := tmp273.FindInternedVar(lang.NewSymbol("vector")) - if tmp274.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp274))) - } - tmp275 := tmp274.Get() - tmp276 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp277 := tmp276.FindInternedVar(lang.NewSymbol("seq")) - if tmp277.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp277))) - } - tmp278 := tmp277.Get() - tmp279 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp280 := tmp279.FindInternedVar(lang.NewSymbol("concat")) - if tmp280.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp280))) - } - tmp281 := tmp280.Get() - tmp282 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp283 := tmp282.FindInternedVar(lang.NewSymbol("list")) - if tmp283.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp283))) - } - tmp284 := tmp283.Get() - tmp285 := lang.Apply(tmp284, []any{lang.NewSymbol("this")}) - tmp286 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp287 := tmp286.FindInternedVar(lang.NewSymbol("list")) - if tmp287.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp287))) - } - tmp288 := tmp287.Get() - tmp289 := lang.Apply(tmp288, []any{lang.NewSymbol("&")}) - tmp290 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp291 := tmp290.FindInternedVar(lang.NewSymbol("list")) - if tmp291.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp291))) - } - tmp292 := tmp291.Get() - tmp293 := lang.Apply(tmp292, []any{lang.NewSymbol("args")}) - tmp294 := lang.Apply(tmp281, []any{tmp285, tmp289, tmp293}) - tmp295 := lang.Apply(tmp278, []any{tmp294}) - tmp296 := lang.Apply(tmp272, []any{tmp275, tmp295}) - tmp297 := lang.Apply(tmp269, []any{tmp296}) - tmp298 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp299 := tmp298.FindInternedVar(lang.NewSymbol("list")) - if tmp299.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp299))) - } - tmp300 := tmp299.Get() - tmp301 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp302 := tmp301.FindInternedVar(lang.NewSymbol("seq")) - if tmp302.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp302))) - } - tmp303 := tmp302.Get() - tmp304 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp305 := tmp304.FindInternedVar(lang.NewSymbol("concat")) - if tmp305.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp305))) - } - tmp306 := tmp305.Get() - tmp307 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp308 := tmp307.FindInternedVar(lang.NewSymbol("list")) - if tmp308.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp308))) - } - tmp309 := tmp308.Get() - tmp310 := lang.Apply(tmp309, []any{lang.NewSymbol("glojure.core/class")}) - tmp311 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp312 := tmp311.FindInternedVar(lang.NewSymbol("list")) - if tmp312.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp312))) - } - tmp313 := tmp312.Get() - tmp314 := lang.Apply(tmp313, []any{lang.NewSymbol("this")}) - tmp315 := lang.Apply(tmp306, []any{tmp310, tmp314}) - tmp316 := lang.Apply(tmp303, []any{tmp315}) - tmp317 := lang.Apply(tmp300, []any{tmp316}) - tmp318 := lang.Apply(tmp262, []any{tmp266, tmp297, tmp317}) - tmp319 := lang.Apply(tmp259, []any{tmp318}) - tmp320 := lang.Apply(tmp256, []any{tmp319}) - tmp321 := lang.Apply(tmp241, []any{tmp245, tmp253, tmp320}) - tmp322 := lang.Apply(tmp238, []any{tmp321}) - tmp323 := lang.Apply(tmp235, []any{tmp322}) - tmp324 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp325 := tmp324.FindInternedVar(lang.NewSymbol("list")) - if tmp325.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp325))) - } - tmp326 := tmp325.Get() - tmp327 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp328 := tmp327.FindInternedVar(lang.NewSymbol("seq")) - if tmp328.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp328))) - } - tmp329 := tmp328.Get() - tmp330 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp331 := tmp330.FindInternedVar(lang.NewSymbol("concat")) - if tmp331.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp331))) - } - tmp332 := tmp331.Get() - tmp333 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp334 := tmp333.FindInternedVar(lang.NewSymbol("list")) - if tmp334.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp334))) - } - tmp335 := tmp334.Get() - tmp336 := lang.Apply(tmp335, []any{lang.NewSymbol("glojure.core/swap!")}) - tmp337 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp338 := tmp337.FindInternedVar(lang.NewSymbol("list")) - if tmp338.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp338))) - } - tmp339 := tmp338.Get() - tmp340 := lang.Apply(tmp339, []any{v5}) - tmp341 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp342 := tmp341.FindInternedVar(lang.NewSymbol("list")) - if tmp342.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp342))) - } - tmp343 := tmp342.Get() - tmp344 := lang.Apply(tmp343, []any{lang.NewSymbol("glojure.core/assoc-in")}) - tmp345 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp346 := tmp345.FindInternedVar(lang.NewSymbol("list")) - if tmp346.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp346))) - } - tmp347 := tmp346.Get() - tmp348 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp349 := tmp348.FindInternedVar(lang.NewSymbol("apply")) - if tmp349.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp349))) - } - tmp350 := tmp349.Get() - tmp351 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp352 := tmp351.FindInternedVar(lang.NewSymbol("vector")) - if tmp352.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp352))) - } - tmp353 := tmp352.Get() - tmp354 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp355 := tmp354.FindInternedVar(lang.NewSymbol("seq")) - if tmp355.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp355))) - } - tmp356 := tmp355.Get() - tmp357 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp358 := tmp357.FindInternedVar(lang.NewSymbol("concat")) - if tmp358.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp358))) - } - tmp359 := tmp358.Get() - tmp360 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp361 := tmp360.FindInternedVar(lang.NewSymbol("list")) - if tmp361.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp361))) - } - tmp362 := tmp361.Get() - tmp363 := lang.Apply(tmp362, []any{lang.NewKeyword("multis")}) - tmp364 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp365 := tmp364.FindInternedVar(lang.NewSymbol("list")) - if tmp365.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp365))) - } - tmp366 := tmp365.Get() - tmp367 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp368 := tmp367.FindInternedVar(lang.NewSymbol("seq")) - if tmp368.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp368))) - } - tmp369 := tmp368.Get() - tmp370 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp371 := tmp370.FindInternedVar(lang.NewSymbol("concat")) - if tmp371.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp371))) - } - tmp372 := tmp371.Get() - tmp373 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp374 := tmp373.FindInternedVar(lang.NewSymbol("list")) - if tmp374.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp374))) - } - tmp375 := tmp374.Get() - tmp376 := lang.Apply(tmp375, []any{lang.NewSymbol("glojure.core/keyword")}) - tmp377 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp378 := tmp377.FindInternedVar(lang.NewSymbol("list")) - if tmp378.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp378))) - } - tmp379 := tmp378.Get() - tmp380 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp381 := tmp380.FindInternedVar(lang.NewSymbol("seq")) - if tmp381.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp381))) - } - tmp382 := tmp381.Get() - tmp383 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp384 := tmp383.FindInternedVar(lang.NewSymbol("concat")) - if tmp384.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp384))) - } - tmp385 := tmp384.Get() - tmp386 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp387 := tmp386.FindInternedVar(lang.NewSymbol("list")) - if tmp387.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp387))) - } - tmp388 := tmp387.Get() - tmp389 := lang.Apply(tmp388, []any{lang.NewSymbol("quote")}) - tmp390 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp391 := tmp390.FindInternedVar(lang.NewSymbol("list")) - if tmp391.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp391))) - } - tmp392 := tmp391.Get() - tmp393 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp394 := tmp393.FindInternedVar(lang.NewSymbol("first")) - if tmp394.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp394))) - } - tmp395 := tmp394.Get() - tmp396 := lang.Apply(tmp395, []any{v222}) - tmp397 := lang.Apply(tmp392, []any{tmp396}) - tmp398 := lang.Apply(tmp385, []any{tmp389, tmp397}) - tmp399 := lang.Apply(tmp382, []any{tmp398}) - tmp400 := lang.Apply(tmp379, []any{tmp399}) - tmp401 := lang.Apply(tmp372, []any{tmp376, tmp400}) - tmp402 := lang.Apply(tmp369, []any{tmp401}) - tmp403 := lang.Apply(tmp366, []any{tmp402}) - tmp404 := lang.Apply(tmp359, []any{tmp363, tmp403}) - tmp405 := lang.Apply(tmp356, []any{tmp404}) - tmp406 := lang.Apply(tmp350, []any{tmp353, tmp405}) - tmp407 := lang.Apply(tmp347, []any{tmp406}) - tmp408 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp409 := tmp408.FindInternedVar(lang.NewSymbol("list")) - if tmp409.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp409))) - } - tmp410 := tmp409.Get() - tmp411 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp412 := tmp411.FindInternedVar(lang.NewSymbol("first")) - if tmp412.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp412))) - } - tmp413 := tmp412.Get() - tmp414 := lang.Apply(tmp413, []any{v222}) - tmp415 := lang.Apply(tmp410, []any{tmp414}) - tmp416 := lang.Apply(tmp332, []any{tmp336, tmp340, tmp344, tmp407, tmp415}) - tmp417 := lang.Apply(tmp329, []any{tmp416}) - tmp418 := lang.Apply(tmp326, []any{tmp417}) - tmp419 := lang.Apply(tmp228, []any{tmp232, tmp323, tmp418}) - tmp420 := lang.Apply(tmp225, []any{tmp419}) - return tmp420 - }) - tmp222 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(102), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(104), lang.NewKeyword("end-column"), int(90)) - tmp223, err := lang.WithMeta(tmp221, tmp222.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp224 := lang.Apply(tmp220, []any{tmp223, v43}) - tmp225 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp226 := tmp225.FindInternedVar(lang.NewSymbol("list")) - if tmp226.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp226))) - } - tmp227 := tmp226.Get() - tmp228 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp229 := tmp228.FindInternedVar(lang.NewSymbol("seq")) - if tmp229.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp229))) - } - tmp230 := tmp229.Get() - tmp231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp232 := tmp231.FindInternedVar(lang.NewSymbol("concat")) - if tmp232.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp232))) - } - tmp233 := tmp232.Get() - tmp234 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp235 := tmp234.FindInternedVar(lang.NewSymbol("list")) - if tmp235.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp235))) - } - tmp236 := tmp235.Get() - tmp237 := lang.Apply(tmp236, []any{lang.NewSymbol("var")}) - tmp238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp239 := tmp238.FindInternedVar(lang.NewSymbol("list")) - if tmp239.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp239))) - } - tmp240 := tmp239.Get() - tmp241 := lang.Apply(tmp240, []any{v5}) - tmp242 := lang.Apply(tmp233, []any{tmp237, tmp241}) - tmp243 := lang.Apply(tmp230, []any{tmp242}) - tmp244 := lang.Apply(tmp227, []any{tmp243}) - tmp245 := lang.Apply(tmp55, []any{tmp59, tmp169, tmp217, tmp224, tmp244}) - tmp246 := lang.Apply(tmp52, []any{tmp245}) - tmp7 = tmp246 - } // end let - return tmp7 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // defstruct - { - tmp0 := lang.NewSymbol("defstruct").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("keys"))), lang.NewKeyword("doc"), "Same as (def name (create-struct keys...))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4044), lang.NewKeyword("end-line"), int(4044))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("seq")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("concat")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("list")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("def")}) - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("list")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.Apply(tmp19, []any{v5}) - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("list")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("seq")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("concat")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("list")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.Apply(tmp32, []any{lang.NewSymbol("glojure.core/create-struct")}) - tmp34 := lang.Apply(tmp29, []any{tmp33, v6}) - tmp35 := lang.Apply(tmp26, []any{tmp34}) - tmp36 := lang.Apply(tmp23, []any{tmp35}) - tmp37 := lang.Apply(tmp12, []any{tmp16, tmp20, tmp36}) - tmp38 := lang.Apply(tmp9, []any{tmp37}) - return tmp38 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // delay - { - tmp0 := lang.NewSymbol("delay").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Takes a body of expressions and yields a Delay object that will\n invoke the body only the first time it is forced (with force or deref/@), and\n will cache the result and return it on all subsequent force\n calls. See also - realized?", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(739), lang.NewKeyword("end-line"), int(739))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("list")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("list*")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.NewVector() - tmp13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(746), lang.NewKeyword("column"), int(62), lang.NewKeyword("end-line"), int(746), lang.NewKeyword("end-column"), int(63)) - tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp15 := lang.Apply(tmp11, []any{lang.NewSymbol("fn*"), tmp14, v5}) - tmp16 := lang.Apply(tmp8, []any{lang.NewSymbol("new"), lang.NewSymbol("glojure.lang.Delay"), tmp15}) - return tmp16 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // delay? - { - tmp0 := lang.NewSymbol("delay?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "returns true if x is a Delay created with delay", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(748), lang.NewKeyword("end-line"), int(748))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.Apply(tmp6, []any{nil, v3}) - return tmp7 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // deliver - { - tmp0 := lang.NewSymbol("deliver").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("promise"), lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Delivers the supplied value to the promise, releasing any pending\n derefs. A subsequent call to deliver on a promise will have no effect.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7109), lang.NewKeyword("end-line"), int(7109))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.Apply(v3, []any{v4}) - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // denominator - { - tmp1 := reflect.TypeOf((*big6.Int)(nil)) - tmp0 := lang.NewSymbol("denominator").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("r"))), lang.NewKeyword("doc"), "Returns the denominator part of a Ratio.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3591), lang.NewKeyword("end-line"), int(3591))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5, ok := lang.FieldOrMethod(v4, "denominator") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "denominator"))) - } - var tmp6 any - switch reflect.TypeOf(tmp5).Kind() { - case reflect.Func: - tmp6 = lang.Apply(tmp5, nil) - default: - tmp6 = tmp5 - } - return tmp6 - }) - tmp4 := reflect.TypeOf((*big6.Int)(nil)) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // deref - { - tmp0 := lang.NewSymbol("deref").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref")), lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("timeout-ms"), lang.NewSymbol("timeout-val"))), lang.NewKeyword("doc"), "Also reader macro: @ref/@agent/@var/@atom/@delay/@future/@promise. Within a transaction,\n returns the in-transaction-value of ref, else returns the\n most-recently-committed value of ref. When applied to a var, agent\n or atom, returns its current state. When applied to a delay, forces\n it if not already forced. When applied to a future, will block if\n computation not complete. When applied to a promise, will block\n until a value is delivered. The variant taking a timeout can be\n used for blocking references (futures and promises), and will return\n timeout-val if the timeout (in milliseconds) is reached before a\n value is available. See also - realized?.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2304), lang.NewKeyword("end-line"), int(2304))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("instance?")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := reflect.TypeOf((*lang.IDeref)(nil)).Elem() - tmp9 := lang.Apply(tmp7, []any{tmp8, v3}) - if lang.IsTruthy(tmp9) { - tmp10, ok := lang.FieldOrMethod(v3, "Deref") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "Deref"))) - } - var tmp11 any - switch reflect.TypeOf(tmp10).Kind() { - case reflect.Func: - tmp11 = lang.Apply(tmp10, nil) - default: - tmp11 = tmp10 - } - tmp4 = tmp11 - } else { - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("deref-future")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.Apply(tmp14, []any{v3}) - tmp4 = tmp15 - } - return tmp4 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var tmp6 any - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("instance?")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := reflect.TypeOf((*lang.IBlockingDeref)(nil)).Elem() - tmp11 := lang.Apply(tmp9, []any{tmp10, v3}) - if lang.IsTruthy(tmp11) { - tmp12, _ := lang.FieldOrMethod(v3, "DerefWithTimeout") - if reflect.TypeOf(tmp12).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("DerefWithTimeout is not a function"))) - } - tmp13 := lang.Apply(tmp12, []any{v4, v5}) - tmp6 = tmp13 - } else { - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("deref-future")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{v3, v4, v5}) - tmp6 = tmp17 - } - return tmp6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // deref-as-map - { - tmp0 := lang.NewSymbol("deref-as-map").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(408), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(408), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "pending" - var tmp5 any - { // let - // let binding "and__0__auto__" - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("instance?")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := reflect.TypeOf((*lang.IPending)(nil)).Elem() - tmp10 := lang.Apply(tmp8, []any{tmp9, v3}) - var v11 any = tmp10 - _ = v11 - var tmp12 any - if lang.IsTruthy(v11) { - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("not")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16, ok := lang.FieldOrMethod(v3, "isRealized") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "isRealized"))) - } - var tmp17 any - switch reflect.TypeOf(tmp16).Kind() { - case reflect.Func: - tmp17 = lang.Apply(tmp16, nil) - default: - tmp17 = tmp16 - } - tmp18 := lang.Apply(tmp15, []any{tmp17}) - tmp12 = tmp18 - } else { - tmp12 = v11 - } - tmp5 = tmp12 - } // end let - var v6 any = tmp5 - _ = v6 - // let binding "vec__250" - var tmp7 any - if lang.IsTruthy(v6) { - } else { - var tmp8 any - func() { - defer func() { - if r := recover(); r != nil { - if lang.CatchMatches(r, lang.Throwable) { - v9 := r - _ = v9 - tmp10 := lang.NewVector(true, v9) - tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(415), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(415), lang.NewKeyword("end-column"), int(25)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp8 = tmp12 - } else { - panic(r) - } - } - }() - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("deref")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.Apply(tmp11, []any{v3}) - tmp13 := lang.NewVector(false, tmp12) - tmp14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(413), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(413), lang.NewKeyword("end-column"), int(32)) - tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp8 = tmp15 - }() - tmp7 = tmp8 - } - var v16 any = tmp7 - _ = v16 - // let binding "ex" - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("nth")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.Apply(tmp19, []any{v16, int64(0), nil}) - var v21 any = tmp20 - _ = v21 - // let binding "val" - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("nth")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.Apply(tmp24, []any{v16, int64(1), nil}) - var v26 any = tmp25 - _ = v26 - var tmp27 any - var tmp28 any - { // let - // let binding "or__0__auto__" - var v29 any = v21 - _ = v29 - var tmp30 any - if lang.IsTruthy(v29) { - tmp30 = v29 - } else { - var tmp31 any - { // let - // let binding "and__0__auto__" - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("instance?")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := reflect.TypeOf((*lang.Agent)(nil)) - tmp36 := lang.Apply(tmp34, []any{tmp35, v3}) - var v37 any = tmp36 - _ = v37 - var tmp38 any - if lang.IsTruthy(v37) { - tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp40 := tmp39.FindInternedVar(lang.NewSymbol("agent-error")) - if tmp40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) - } - tmp41 := tmp40.Get() - tmp42 := lang.Apply(tmp41, []any{v3}) - tmp38 = tmp42 - } else { - tmp38 = v37 - } - tmp31 = tmp38 - } // end let - tmp30 = tmp31 - } - tmp28 = tmp30 - } // end let - if lang.IsTruthy(tmp28) { - tmp27 = lang.NewKeyword("failed") - } else { - var tmp29 any - if lang.IsTruthy(v6) { - tmp29 = lang.NewKeyword("pending") - } else { - var tmp30 any - if lang.IsTruthy(lang.NewKeyword("else")) { - tmp30 = lang.NewKeyword("ready") - } else { - } - tmp29 = tmp30 - } - tmp27 = tmp29 - } - tmp31 := lang.NewMap(lang.NewKeyword("status"), tmp27, lang.NewKeyword("val"), v26) - tmp32 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(416), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(429), lang.NewKeyword("end-column"), int(14)) - tmp33, err := lang.WithMeta(tmp31, tmp32.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp4 = tmp33 - } // end let - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // deref-future - { - tmp0 := lang.NewSymbol("deref-future").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2296), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(2296), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fut")), lang.NewVector(lang.NewSymbol("fut"), lang.NewSymbol("timeout-ms"), lang.NewSymbol("timeout-val"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - tmp4, ok := lang.FieldOrMethod(v3, "Get") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "Get"))) - } - var tmp5 any - switch reflect.TypeOf(tmp4).Kind() { - case reflect.Func: - tmp5 = lang.Apply(tmp4, nil) - default: - tmp5 = tmp4 - } - return tmp5 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var tmp6 any - func() { - defer func() { - if r := recover(); r != nil { - tmp7 := reflect.TypeOf((*lang.TimeoutError)(nil)).Elem() - if lang.CatchMatches(r, tmp7) { - v8 := r - _ = v8 - tmp6 = v5 - } else { - panic(r) - } - } - }() - tmp8, _ := lang.FieldOrMethod(v3, "Get") - if reflect.TypeOf(tmp8).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Get is not a function"))) - } - tmp9 := lang.Apply(tmp8, []any{v4, time7.Millisecond}) - tmp6 = tmp9 - }() - return tmp6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // derive - { - tmp0 := lang.NewSymbol("derive").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag"), lang.NewSymbol("parent")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"), lang.NewSymbol("parent"))), lang.NewKeyword("doc"), "Establishes a parent/child relationship between parent and\n tag. Parent must be a namespace-qualified symbol or keyword and\n child can be either a namespace-qualified symbol or keyword or a\n class. h must be a hierarchy obtained from make-hierarchy, if not\n supplied defaults to, and modifies, the global hierarchy.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5605), lang.NewKeyword("end-line"), int(5605))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("alter-var-root")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("global-hierarchy")) - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("derive")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.Apply(tmp7, []any{tmp8, tmp11, v3, v4}) - _ = tmp12 - return nil - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var tmp6 any - { // let - // let binding "tp" - tmp7 := lang.Apply(lang.NewKeyword("parents"), []any{v3}) - var v8 any = tmp7 - _ = v8 - // let binding "td" - tmp9 := lang.Apply(lang.NewKeyword("descendants"), []any{v3}) - var v10 any = tmp9 - _ = v10 - // let binding "ta" - tmp11 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) - var v12 any = tmp11 - _ = v12 - // let binding "tf" - var tmp13 lang.FnFunc - tmp13 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 5 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v14 := args[0] - _ = v14 - v15 := args[1] - _ = v15 - v16 := args[2] - _ = v16 - v17 := args[3] - _ = v17 - v18 := args[4] - _ = v18 - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - var tmp22 lang.FnFunc - tmp22 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v23 := args[0] - _ = v23 - v24 := args[1] - _ = v24 - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("assoc")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("conj")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("get")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) - tmp38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5628), lang.NewKeyword("column"), int(61), lang.NewKeyword("end-line"), int(5628), lang.NewKeyword("end-column"), int(63)) - tmp39, err := lang.WithMeta(tmp37, tmp38.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp40 := lang.Apply(tmp36, []any{v18, v24, tmp39}) - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("cons")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.Apply(v18, []any{v17}) - tmp45 := lang.Apply(tmp43, []any{v17, tmp44}) - tmp46 := lang.Apply(tmp30, []any{tmp33, tmp40, tmp45}) - tmp47 := lang.Apply(tmp27, []any{v23, v24, tmp46}) - return tmp47 - }) - tmp23 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5626), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(5628), lang.NewKeyword("end-column"), int(98)) - tmp24, err := lang.WithMeta(tmp22, tmp23.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("cons")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.Apply(v16, []any{v15}) - tmp29 := lang.Apply(tmp27, []any{v15, tmp28}) - tmp30 := lang.Apply(tmp21, []any{tmp24, v14, tmp29}) - return tmp30 - }) - tmp14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5625), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(5629), lang.NewKeyword("end-column"), int(56)) - tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v16 any = tmp15 - _ = v16 - var tmp17 any - { // let - // let binding "or__0__auto__" - var tmp18 any - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("contains?")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(v8, []any{v4}) - tmp23 := lang.Apply(tmp21, []any{tmp22, v5}) - if lang.IsTruthy(tmp23) { - } else { - var tmp24 any - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("contains?")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.Apply(v12, []any{v4}) - tmp29 := lang.Apply(tmp27, []any{tmp28, v5}) - if lang.IsTruthy(tmp29) { - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("print-str")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.Apply(tmp32, []any{v4, "already has", v5, "as ancestor"}) - tmp34 := lang.Apply(lang.NewError, []any{tmp33}) - panic(tmp34) - } else { - } - _ = tmp24 - var tmp35 any - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("contains?")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(v12, []any{v5}) - tmp40 := lang.Apply(tmp38, []any{tmp39, v4}) - if lang.IsTruthy(tmp40) { - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("print-str")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.Apply(tmp43, []any{"Cyclic derivation:", v5, "has", v4, "as ancestor"}) - tmp45 := lang.Apply(lang.NewError, []any{tmp44}) - panic(tmp45) - } else { - } - _ = tmp35 - tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp47 := tmp46.FindInternedVar(lang.NewSymbol("assoc")) - if tmp47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) - } - tmp48 := tmp47.Get() - tmp49 := lang.Apply(lang.NewKeyword("parents"), []any{v3}) - tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp51 := tmp50.FindInternedVar(lang.NewSymbol("conj")) - if tmp51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) - } - tmp52 := tmp51.Get() - tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp54 := tmp53.FindInternedVar(lang.NewSymbol("get")) - if tmp54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) - } - tmp55 := tmp54.Get() - tmp56 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) - tmp57 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5636), lang.NewKeyword("column"), int(61), lang.NewKeyword("end-line"), int(5636), lang.NewKeyword("end-column"), int(63)) - tmp58, err := lang.WithMeta(tmp56, tmp57.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp59 := lang.Apply(tmp55, []any{v8, v4, tmp58}) - tmp60 := lang.Apply(tmp52, []any{tmp59, v5}) - tmp61 := lang.Apply(tmp48, []any{tmp49, v4, tmp60}) - tmp62 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) - tmp63 := lang.Apply(v16, []any{tmp62, v4, v10, v5, v12}) - tmp64 := lang.Apply(lang.NewKeyword("descendants"), []any{v3}) - tmp65 := lang.Apply(v16, []any{tmp64, v5, v12, v4, v10}) - tmp66 := lang.NewMap(lang.NewKeyword("parents"), tmp61, lang.NewKeyword("ancestors"), tmp63, lang.NewKeyword("descendants"), tmp65) - tmp67 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5636), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(5638), lang.NewKeyword("end-column"), int(61)) - tmp68, err := lang.WithMeta(tmp66, tmp67.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp18 = tmp68 - } - var v69 any = tmp18 - _ = v69 - var tmp70 any - if lang.IsTruthy(v69) { - tmp70 = v69 - } else { - tmp70 = v3 - } - tmp17 = tmp70 - } // end let - tmp6 = tmp17 - } // end let - return tmp6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // descendants - { - tmp0 := lang.NewSymbol("descendants").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"))), lang.NewKeyword("doc"), "Returns the immediate and indirect children of tag, through a\n relationship established via derive. h must be a hierarchy obtained\n from make-hierarchy, if not supplied defaults to the global\n hierarchy. Note: does not work on Java type inheritance\n relationships.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5593), lang.NewKeyword("end-line"), int(5593))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("descendants")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("global-hierarchy")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp6, []any{tmp9, v3}) - return tmp10 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("class?")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(tmp8, []any{v4}) - if lang.IsTruthy(tmp9) { - tmp10 := lang.Apply(lang.NewUnsupportedOperationError, []any{"Can't get descendants of classes"}) - panic(tmp10) - } else { - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("not-empty")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("get")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(lang.NewKeyword("descendants"), []any{v3}) - tmp18 := lang.Apply(tmp16, []any{tmp17, v4}) - tmp19 := lang.Apply(tmp13, []any{tmp18}) - tmp5 = tmp19 - } - return tmp5 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // destructure - { - tmp0 := lang.NewSymbol("destructure").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4400), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(4400), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "bents" - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("partition")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{int64(2), v3}) - var v9 any = tmp8 - _ = v9 - // let binding "pb" - var tmp10 lang.FnFunc - { // function pb - var v11 lang.FnFunc - tmp10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v12 := args[0] - _ = v12 - v13 := args[1] - _ = v13 - v14 := args[2] - _ = v14 - var tmp15 any - { // let - // let binding "pvec" - var tmp16 lang.FnFunc - tmp16 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v17 := args[0] - _ = v17 - v18 := args[1] - _ = v18 - v19 := args[2] - _ = v19 - var tmp20 any - { // let - // let binding "gvec" - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("gensym")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.Apply(tmp23, []any{"vec__"}) - var v25 any = tmp24 - _ = v25 - // let binding "gseq" - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("gensym")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.Apply(tmp28, []any{"seq__"}) - var v30 any = tmp29 - _ = v30 - // let binding "gfirst" - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("gensym")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{"first__"}) - var v35 any = tmp34 - _ = v35 - // let binding "has-rest" - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("some")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{lang.NewSymbol("&")})) - tmp40 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4408), lang.NewKeyword("column"), int(43), lang.NewKeyword("end-line"), int(4408), lang.NewKeyword("end-column"), int(47)) - tmp41, err := lang.WithMeta(tmp39, tmp40.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp42 := lang.Apply(tmp38, []any{tmp41, v18}) - var v43 any = tmp42 - _ = v43 - var tmp44 any - { // let - // let binding "ret" - var tmp45 any - { // let - // let binding "ret" - tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp47 := tmp46.FindInternedVar(lang.NewSymbol("conj")) - if tmp47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) - } - tmp48 := tmp47.Get() - tmp49 := lang.Apply(tmp48, []any{v17, v25, v19}) - var v50 any = tmp49 - _ = v50 - var tmp51 any - if lang.IsTruthy(v43) { - tmp52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp53 := tmp52.FindInternedVar(lang.NewSymbol("conj")) - if tmp53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp53))) - } - tmp54 := tmp53.Get() - tmp55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp56 := tmp55.FindInternedVar(lang.NewSymbol("list")) - if tmp56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp56))) - } - tmp57 := tmp56.Get() - tmp58 := lang.Apply(tmp57, []any{lang.NewSymbol("glojure.core/seq"), v25}) - tmp59 := lang.Apply(tmp54, []any{v50, v30, tmp58}) - tmp51 = tmp59 - } else { - tmp51 = v50 - } - tmp45 = tmp51 - } // end let - var v46 any = tmp45 - _ = v46 - // let binding "n" - var v47 any = int64(0) - _ = v47 - // let binding "bs" - var v48 any = v18 - _ = v48 - // let binding "seen-rest?" - var v49 any = false - _ = v49 - for { - var tmp50 any - tmp51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp52 := tmp51.FindInternedVar(lang.NewSymbol("seq")) - if tmp52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp52))) - } - tmp53 := tmp52.Get() - tmp54 := lang.Apply(tmp53, []any{v48}) - if lang.IsTruthy(tmp54) { - var tmp55 any - { // let - // let binding "firstb" - tmp56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp57 := tmp56.FindInternedVar(lang.NewSymbol("first")) - if tmp57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp57))) - } - tmp58 := tmp57.Get() - tmp59 := lang.Apply(tmp58, []any{v48}) - var v60 any = tmp59 - _ = v60 - var tmp61 any - tmp62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp63 := tmp62.FindInternedVar(lang.NewSymbol("=")) - if tmp63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp63))) - } - tmp64 := tmp63.Get() - tmp65 := lang.Apply(tmp64, []any{v60, lang.NewSymbol("&")}) - if lang.IsTruthy(tmp65) { - tmp67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp68 := tmp67.FindInternedVar(lang.NewSymbol("second")) - if tmp68.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp68))) - } - tmp69 := tmp68.Get() - tmp70 := lang.Apply(tmp69, []any{v48}) - tmp71 := lang.Apply(v11, []any{v46, tmp70, v30}) - var tmp66 any = tmp71 - var tmp72 any = v47 - tmp74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp75 := tmp74.FindInternedVar(lang.NewSymbol("nnext")) - if tmp75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp75))) - } - tmp76 := tmp75.Get() - tmp77 := lang.Apply(tmp76, []any{v48}) - var tmp73 any = tmp77 - var tmp78 any = true - v46 = tmp66 - v47 = tmp72 - v48 = tmp73 - v49 = tmp78 - continue - } else { - var tmp79 any - tmp80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp81 := tmp80.FindInternedVar(lang.NewSymbol("=")) - if tmp81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp81))) - } - tmp82 := tmp81.Get() - tmp83 := lang.Apply(tmp82, []any{v60, lang.NewKeyword("as")}) - if lang.IsTruthy(tmp83) { - tmp84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp85 := tmp84.FindInternedVar(lang.NewSymbol("second")) - if tmp85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp85))) - } - tmp86 := tmp85.Get() - tmp87 := lang.Apply(tmp86, []any{v48}) - tmp88 := lang.Apply(v11, []any{v46, tmp87, v25}) - tmp79 = tmp88 - } else { - var tmp89 any - if lang.IsTruthy(lang.NewKeyword("else")) { - var tmp90 any - if lang.IsTruthy(v49) { - tmp91 := lang.Apply(errors5.New, []any{"Unsupported binding form, only :as can follow & parameter"}) - panic(tmp91) - } else { - var tmp93 any - if lang.IsTruthy(v43) { - tmp94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp95 := tmp94.FindInternedVar(lang.NewSymbol("conj")) - if tmp95.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp95))) - } - tmp96 := tmp95.Get() - tmp97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp98 := tmp97.FindInternedVar(lang.NewSymbol("seq")) - if tmp98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp98))) - } - tmp99 := tmp98.Get() - tmp100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp101 := tmp100.FindInternedVar(lang.NewSymbol("concat")) - if tmp101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp101))) - } - tmp102 := tmp101.Get() - tmp103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp104 := tmp103.FindInternedVar(lang.NewSymbol("list")) - if tmp104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp104))) - } - tmp105 := tmp104.Get() - tmp106 := lang.Apply(tmp105, []any{lang.NewSymbol("glojure.core/first")}) - tmp107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp108 := tmp107.FindInternedVar(lang.NewSymbol("list")) - if tmp108.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp108))) - } - tmp109 := tmp108.Get() - tmp110 := lang.Apply(tmp109, []any{v30}) - tmp111 := lang.Apply(tmp102, []any{tmp106, tmp110}) - tmp112 := lang.Apply(tmp99, []any{tmp111}) - tmp113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp114 := tmp113.FindInternedVar(lang.NewSymbol("seq")) - if tmp114.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp114))) - } - tmp115 := tmp114.Get() - tmp116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp117 := tmp116.FindInternedVar(lang.NewSymbol("concat")) - if tmp117.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp117))) - } - tmp118 := tmp117.Get() - tmp119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp120 := tmp119.FindInternedVar(lang.NewSymbol("list")) - if tmp120.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp120))) - } - tmp121 := tmp120.Get() - tmp122 := lang.Apply(tmp121, []any{lang.NewSymbol("glojure.core/next")}) - tmp123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp124 := tmp123.FindInternedVar(lang.NewSymbol("list")) - if tmp124.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp124))) - } - tmp125 := tmp124.Get() - tmp126 := lang.Apply(tmp125, []any{v30}) - tmp127 := lang.Apply(tmp118, []any{tmp122, tmp126}) - tmp128 := lang.Apply(tmp115, []any{tmp127}) - tmp129 := lang.Apply(tmp96, []any{v46, v35, tmp112, v30, tmp128}) - tmp93 = tmp129 - } else { - tmp93 = v46 - } - var tmp130 any - if lang.IsTruthy(v43) { - tmp130 = v35 - } else { - tmp131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp132 := tmp131.FindInternedVar(lang.NewSymbol("list")) - if tmp132.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp132))) - } - tmp133 := tmp132.Get() - tmp134 := lang.Apply(tmp133, []any{lang.NewSymbol("glojure.core/nth"), v25, v47, nil}) - tmp130 = tmp134 - } - tmp135 := lang.Apply(v11, []any{tmp93, v60, tmp130}) - var tmp92 any = tmp135 - tmp137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp138 := tmp137.FindInternedVar(lang.NewSymbol("inc")) - if tmp138.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp138))) - } - tmp139 := tmp138.Get() - tmp140 := lang.Apply(tmp139, []any{v47}) - var tmp136 any = tmp140 - tmp142 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp143 := tmp142.FindInternedVar(lang.NewSymbol("next")) - if tmp143.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp143))) - } - tmp144 := tmp143.Get() - tmp145 := lang.Apply(tmp144, []any{v48}) - var tmp141 any = tmp145 - var tmp146 any = v49 - v46 = tmp92 - v47 = tmp136 - v48 = tmp141 - v49 = tmp146 - continue - } - tmp89 = tmp90 - } else { - } - tmp79 = tmp89 - } - tmp61 = tmp79 - } - tmp55 = tmp61 - } // end let - tmp50 = tmp55 - } else { - tmp50 = v46 - } - tmp44 = tmp50 - break - } - } // end let - tmp20 = tmp44 - } // end let - return tmp20 - }) - tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4404), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(4438), lang.NewKeyword("end-column"), int(34)) - tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v19 any = tmp18 - _ = v19 - // let binding "pmap" - var tmp20 lang.FnFunc - tmp20 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v21 := args[0] - _ = v21 - v22 := args[1] - _ = v22 - v23 := args[2] - _ = v23 - var tmp24 any - { // let - // let binding "gmap" - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("gensym")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.Apply(tmp27, []any{"map__"}) - var v29 any = tmp28 - _ = v29 - // let binding "gmapseq" - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("with-meta")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.NewMap(lang.NewKeyword("tag"), lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.ISeq")) - tmp34 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4442), lang.NewKeyword("column"), int(52), lang.NewKeyword("end-line"), int(4442), lang.NewKeyword("end-column"), int(103)) - tmp35, err := lang.WithMeta(tmp33, tmp34.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp36 := lang.Apply(tmp32, []any{v29, tmp35}) - var v37 any = tmp36 - _ = v37 - // let binding "defaults" - tmp38 := lang.Apply(lang.NewKeyword("or"), []any{v22}) - var v39 any = tmp38 - _ = v39 - var tmp40 any - { // let - // let binding "ret" - var tmp41 lang.FnFunc - tmp41 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v42 := args[0] - _ = v42 - var tmp43 any - tmp44 := lang.Apply(lang.NewKeyword("as"), []any{v22}) - if lang.IsTruthy(tmp44) { - tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp46 := tmp45.FindInternedVar(lang.NewSymbol("conj")) - if tmp46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) - } - tmp47 := tmp46.Get() - tmp48 := lang.Apply(lang.NewKeyword("as"), []any{v22}) - tmp49 := lang.Apply(tmp47, []any{v42, tmp48, v29}) - tmp43 = tmp49 - } else { - tmp43 = v42 - } - return tmp43 - }) - tmp42 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4450), lang.NewKeyword("column"), int(40), lang.NewKeyword("end-line"), int(4453), lang.NewKeyword("end-column"), int(48)) - tmp43, err := lang.WithMeta(tmp41, tmp42.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("conj")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp48 := tmp47.FindInternedVar(lang.NewSymbol("conj")) - if tmp48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) - } - tmp49 := tmp48.Get() - tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp51 := tmp50.FindInternedVar(lang.NewSymbol("conj")) - if tmp51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) - } - tmp52 := tmp51.Get() - tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp54 := tmp53.FindInternedVar(lang.NewSymbol("conj")) - if tmp54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) - } - tmp55 := tmp54.Get() - tmp56 := lang.Apply(tmp55, []any{v21, v29}) - tmp57 := lang.Apply(tmp52, []any{tmp56, v23}) - tmp58 := lang.Apply(tmp49, []any{tmp57, v29}) - tmp59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp60 := tmp59.FindInternedVar(lang.NewSymbol("seq")) - if tmp60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp60))) - } - tmp61 := tmp60.Get() - tmp62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp63 := tmp62.FindInternedVar(lang.NewSymbol("concat")) - if tmp63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp63))) - } - tmp64 := tmp63.Get() - tmp65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp66 := tmp65.FindInternedVar(lang.NewSymbol("list")) - if tmp66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp66))) - } - tmp67 := tmp66.Get() - tmp68 := lang.Apply(tmp67, []any{lang.NewSymbol("if")}) - tmp69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp70 := tmp69.FindInternedVar(lang.NewSymbol("list")) - if tmp70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp70))) - } - tmp71 := tmp70.Get() - tmp72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp73 := tmp72.FindInternedVar(lang.NewSymbol("seq")) - if tmp73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp73))) - } - tmp74 := tmp73.Get() - tmp75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp76 := tmp75.FindInternedVar(lang.NewSymbol("concat")) - if tmp76.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp76))) - } - tmp77 := tmp76.Get() - tmp78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp79 := tmp78.FindInternedVar(lang.NewSymbol("list")) - if tmp79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp79))) - } - tmp80 := tmp79.Get() - tmp81 := lang.Apply(tmp80, []any{lang.NewSymbol("glojure.core/seq?")}) - tmp82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp83 := tmp82.FindInternedVar(lang.NewSymbol("list")) - if tmp83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp83))) - } - tmp84 := tmp83.Get() - tmp85 := lang.Apply(tmp84, []any{v29}) - tmp86 := lang.Apply(tmp77, []any{tmp81, tmp85}) - tmp87 := lang.Apply(tmp74, []any{tmp86}) - tmp88 := lang.Apply(tmp71, []any{tmp87}) - tmp89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp90 := tmp89.FindInternedVar(lang.NewSymbol("list")) - if tmp90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp90))) - } - tmp91 := tmp90.Get() - tmp92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp93 := tmp92.FindInternedVar(lang.NewSymbol("seq")) - if tmp93.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp93))) - } - tmp94 := tmp93.Get() - tmp95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp96 := tmp95.FindInternedVar(lang.NewSymbol("concat")) - if tmp96.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp96))) - } - tmp97 := tmp96.Get() - tmp98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp99 := tmp98.FindInternedVar(lang.NewSymbol("list")) - if tmp99.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp99))) - } - tmp100 := tmp99.Get() - tmp101 := lang.Apply(tmp100, []any{lang.NewSymbol("if")}) - tmp102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp103 := tmp102.FindInternedVar(lang.NewSymbol("list")) - if tmp103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp103))) - } - tmp104 := tmp103.Get() - tmp105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp106 := tmp105.FindInternedVar(lang.NewSymbol("seq")) - if tmp106.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp106))) - } - tmp107 := tmp106.Get() - tmp108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp109 := tmp108.FindInternedVar(lang.NewSymbol("concat")) - if tmp109.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp109))) - } - tmp110 := tmp109.Get() - tmp111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp112 := tmp111.FindInternedVar(lang.NewSymbol("list")) - if tmp112.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp112))) - } - tmp113 := tmp112.Get() - tmp114 := lang.Apply(tmp113, []any{lang.NewSymbol("glojure.core/next")}) - tmp115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp116 := tmp115.FindInternedVar(lang.NewSymbol("list")) - if tmp116.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp116))) - } - tmp117 := tmp116.Get() - tmp118 := lang.Apply(tmp117, []any{v37}) - tmp119 := lang.Apply(tmp110, []any{tmp114, tmp118}) - tmp120 := lang.Apply(tmp107, []any{tmp119}) - tmp121 := lang.Apply(tmp104, []any{tmp120}) - tmp122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp123 := tmp122.FindInternedVar(lang.NewSymbol("list")) - if tmp123.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp123))) - } - tmp124 := tmp123.Get() - tmp125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp126 := tmp125.FindInternedVar(lang.NewSymbol("seq")) - if tmp126.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp126))) - } - tmp127 := tmp126.Get() - tmp128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp129 := tmp128.FindInternedVar(lang.NewSymbol("concat")) - if tmp129.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp129))) - } - tmp130 := tmp129.Get() - tmp131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp132 := tmp131.FindInternedVar(lang.NewSymbol("list")) - if tmp132.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp132))) - } - tmp133 := tmp132.Get() - tmp134 := lang.Apply(tmp133, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewPersistentArrayMapAsIfByAssoc")}) - tmp135 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp136 := tmp135.FindInternedVar(lang.NewSymbol("list")) - if tmp136.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp136))) - } - tmp137 := tmp136.Get() - tmp138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp139 := tmp138.FindInternedVar(lang.NewSymbol("seq")) - if tmp139.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp139))) - } - tmp140 := tmp139.Get() - tmp141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp142 := tmp141.FindInternedVar(lang.NewSymbol("concat")) - if tmp142.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp142))) - } - tmp143 := tmp142.Get() - tmp144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp145 := tmp144.FindInternedVar(lang.NewSymbol("list")) - if tmp145.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp145))) - } - tmp146 := tmp145.Get() - tmp147 := lang.Apply(tmp146, []any{lang.NewSymbol("glojure.core/to-array")}) - tmp148 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp149 := tmp148.FindInternedVar(lang.NewSymbol("list")) - if tmp149.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp149))) - } - tmp150 := tmp149.Get() - tmp151 := lang.Apply(tmp150, []any{v37}) - tmp152 := lang.Apply(tmp143, []any{tmp147, tmp151}) - tmp153 := lang.Apply(tmp140, []any{tmp152}) - tmp154 := lang.Apply(tmp137, []any{tmp153}) - tmp155 := lang.Apply(tmp130, []any{tmp134, tmp154}) - tmp156 := lang.Apply(tmp127, []any{tmp155}) - tmp157 := lang.Apply(tmp124, []any{tmp156}) - tmp158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp159 := tmp158.FindInternedVar(lang.NewSymbol("list")) - if tmp159.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp159))) - } - tmp160 := tmp159.Get() - tmp161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp162 := tmp161.FindInternedVar(lang.NewSymbol("seq")) - if tmp162.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp162))) - } - tmp163 := tmp162.Get() - tmp164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp165 := tmp164.FindInternedVar(lang.NewSymbol("concat")) - if tmp165.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp165))) - } - tmp166 := tmp165.Get() - tmp167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp168 := tmp167.FindInternedVar(lang.NewSymbol("list")) - if tmp168.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp168))) - } - tmp169 := tmp168.Get() - tmp170 := lang.Apply(tmp169, []any{lang.NewSymbol("if")}) - tmp171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp172 := tmp171.FindInternedVar(lang.NewSymbol("list")) - if tmp172.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp172))) - } - tmp173 := tmp172.Get() - tmp174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp175 := tmp174.FindInternedVar(lang.NewSymbol("seq")) - if tmp175.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp175))) - } - tmp176 := tmp175.Get() - tmp177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp178 := tmp177.FindInternedVar(lang.NewSymbol("concat")) - if tmp178.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp178))) - } - tmp179 := tmp178.Get() - tmp180 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp181 := tmp180.FindInternedVar(lang.NewSymbol("list")) - if tmp181.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp181))) - } - tmp182 := tmp181.Get() - tmp183 := lang.Apply(tmp182, []any{lang.NewSymbol("glojure.core/seq")}) - tmp184 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp185 := tmp184.FindInternedVar(lang.NewSymbol("list")) - if tmp185.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp185))) - } - tmp186 := tmp185.Get() - tmp187 := lang.Apply(tmp186, []any{v37}) - tmp188 := lang.Apply(tmp179, []any{tmp183, tmp187}) - tmp189 := lang.Apply(tmp176, []any{tmp188}) - tmp190 := lang.Apply(tmp173, []any{tmp189}) - tmp191 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp192 := tmp191.FindInternedVar(lang.NewSymbol("list")) - if tmp192.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp192))) - } - tmp193 := tmp192.Get() - tmp194 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp195 := tmp194.FindInternedVar(lang.NewSymbol("seq")) - if tmp195.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp195))) - } - tmp196 := tmp195.Get() - tmp197 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp198 := tmp197.FindInternedVar(lang.NewSymbol("concat")) - if tmp198.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp198))) - } - tmp199 := tmp198.Get() - tmp200 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp201 := tmp200.FindInternedVar(lang.NewSymbol("list")) - if tmp201.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp201))) - } - tmp202 := tmp201.Get() - tmp203 := lang.Apply(tmp202, []any{lang.NewSymbol("glojure.core/first")}) - tmp204 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp205 := tmp204.FindInternedVar(lang.NewSymbol("list")) - if tmp205.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp205))) - } - tmp206 := tmp205.Get() - tmp207 := lang.Apply(tmp206, []any{v37}) - tmp208 := lang.Apply(tmp199, []any{tmp203, tmp207}) - tmp209 := lang.Apply(tmp196, []any{tmp208}) - tmp210 := lang.Apply(tmp193, []any{tmp209}) - tmp211 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp212 := tmp211.FindInternedVar(lang.NewSymbol("list")) - if tmp212.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp212))) - } - tmp213 := tmp212.Get() - tmp214 := lang.Apply(tmp213, []any{lang.NewSymbol("glojure.lang.PersistentArrayMap/EMPTY")}) - tmp215 := lang.Apply(tmp166, []any{tmp170, tmp190, tmp210, tmp214}) - tmp216 := lang.Apply(tmp163, []any{tmp215}) - tmp217 := lang.Apply(tmp160, []any{tmp216}) - tmp218 := lang.Apply(tmp97, []any{tmp101, tmp121, tmp157, tmp217}) - tmp219 := lang.Apply(tmp94, []any{tmp218}) - tmp220 := lang.Apply(tmp91, []any{tmp219}) - tmp221 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp222 := tmp221.FindInternedVar(lang.NewSymbol("list")) - if tmp222.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp222))) - } - tmp223 := tmp222.Get() - tmp224 := lang.Apply(tmp223, []any{v29}) - tmp225 := lang.Apply(tmp64, []any{tmp68, tmp88, tmp220, tmp224}) - tmp226 := lang.Apply(tmp61, []any{tmp225}) - tmp227 := lang.Apply(tmp46, []any{tmp58, tmp226}) - tmp228 := lang.Apply(tmp43, []any{tmp227}) - var v229 any = tmp228 - _ = v229 - // let binding "bes" - var tmp230 any - { // let - // let binding "transforms" - tmp231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp232 := tmp231.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp232.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp232))) - } - tmp233 := tmp232.Get() - var tmp234 lang.FnFunc - tmp234 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v235 := args[0] - _ = v235 - v236 := args[1] - _ = v236 - var tmp237 any - tmp238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp239 := tmp238.FindInternedVar(lang.NewSymbol("keyword?")) - if tmp239.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp239))) - } - tmp240 := tmp239.Get() - tmp241 := lang.Apply(tmp240, []any{v236}) - if lang.IsTruthy(tmp241) { - var tmp242 any - { // let - // let binding "mkns" - tmp243 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp244 := tmp243.FindInternedVar(lang.NewSymbol("namespace")) - if tmp244.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp244))) - } - tmp245 := tmp244.Get() - tmp246 := lang.Apply(tmp245, []any{v236}) - var v247 any = tmp246 - _ = v247 - // let binding "mkn" - tmp248 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp249 := tmp248.FindInternedVar(lang.NewSymbol("name")) - if tmp249.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp249))) - } - tmp250 := tmp249.Get() - tmp251 := lang.Apply(tmp250, []any{v236}) - var v252 any = tmp251 - _ = v252 - var tmp253 any - tmp254 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp255 := tmp254.FindInternedVar(lang.NewSymbol("=")) - if tmp255.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp255))) - } - tmp256 := tmp255.Get() - tmp257 := lang.Apply(tmp256, []any{v252, "keys"}) - if lang.IsTruthy(tmp257) { - tmp258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp259 := tmp258.FindInternedVar(lang.NewSymbol("assoc")) - if tmp259.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp259))) - } - tmp260 := tmp259.Get() - var tmp261 lang.FnFunc - tmp261 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v262 := args[0] - _ = v262 - tmp263 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp264 := tmp263.FindInternedVar(lang.NewSymbol("keyword")) - if tmp264.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp264))) - } - tmp265 := tmp264.Get() - var tmp266 any - { // let - // let binding "or__0__auto__" - var v267 any = v247 - _ = v267 - var tmp268 any - if lang.IsTruthy(v267) { - tmp268 = v267 - } else { - tmp269 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp270 := tmp269.FindInternedVar(lang.NewSymbol("namespace")) - if tmp270.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp270))) - } - tmp271 := tmp270.Get() - tmp272 := lang.Apply(tmp271, []any{v262}) - tmp268 = tmp272 - } - tmp266 = tmp268 - } // end let - tmp267 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp268 := tmp267.FindInternedVar(lang.NewSymbol("name")) - if tmp268.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp268))) - } - tmp269 := tmp268.Get() - tmp270 := lang.Apply(tmp269, []any{v262}) - tmp271 := lang.Apply(tmp265, []any{tmp266, tmp270}) - return tmp271 - }) - tmp262 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4460), lang.NewKeyword("column"), int(93), lang.NewKeyword("end-line"), int(4460), lang.NewKeyword("end-column"), int(135)) - tmp263, err := lang.WithMeta(tmp261, tmp262.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp264 := lang.Apply(tmp260, []any{v235, v236, tmp263}) - tmp253 = tmp264 - } else { - var tmp265 any - tmp266 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp267 := tmp266.FindInternedVar(lang.NewSymbol("=")) - if tmp267.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp267))) - } - tmp268 := tmp267.Get() - tmp269 := lang.Apply(tmp268, []any{v252, "syms"}) - if lang.IsTruthy(tmp269) { - tmp270 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp271 := tmp270.FindInternedVar(lang.NewSymbol("assoc")) - if tmp271.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp271))) - } - tmp272 := tmp271.Get() - var tmp273 lang.FnFunc - tmp273 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v274 := args[0] - _ = v274 - tmp275 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp276 := tmp275.FindInternedVar(lang.NewSymbol("list")) - if tmp276.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp276))) - } - tmp277 := tmp276.Get() - tmp278 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp279 := tmp278.FindInternedVar(lang.NewSymbol("symbol")) - if tmp279.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp279))) - } - tmp280 := tmp279.Get() - var tmp281 any - { // let - // let binding "or__0__auto__" - var v282 any = v247 - _ = v282 - var tmp283 any - if lang.IsTruthy(v282) { - tmp283 = v282 - } else { - tmp284 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp285 := tmp284.FindInternedVar(lang.NewSymbol("namespace")) - if tmp285.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp285))) - } - tmp286 := tmp285.Get() - tmp287 := lang.Apply(tmp286, []any{v274}) - tmp283 = tmp287 - } - tmp281 = tmp283 - } // end let - tmp282 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp283 := tmp282.FindInternedVar(lang.NewSymbol("name")) - if tmp283.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp283))) - } - tmp284 := tmp283.Get() - tmp285 := lang.Apply(tmp284, []any{v274}) - tmp286 := lang.Apply(tmp280, []any{tmp281, tmp285}) - tmp287 := lang.Apply(tmp277, []any{lang.NewSymbol("quote"), tmp286}) - return tmp287 - }) - tmp274 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4461), lang.NewKeyword("column"), int(93), lang.NewKeyword("end-line"), int(4461), lang.NewKeyword("end-column"), int(148)) - tmp275, err := lang.WithMeta(tmp273, tmp274.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp276 := lang.Apply(tmp272, []any{v235, v236, tmp275}) - tmp265 = tmp276 - } else { - var tmp277 any - tmp278 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp279 := tmp278.FindInternedVar(lang.NewSymbol("=")) - if tmp279.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp279))) - } - tmp280 := tmp279.Get() - tmp281 := lang.Apply(tmp280, []any{v252, "strs"}) - if lang.IsTruthy(tmp281) { - tmp282 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp283 := tmp282.FindInternedVar(lang.NewSymbol("assoc")) - if tmp283.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp283))) - } - tmp284 := tmp283.Get() - tmp285 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp286 := tmp285.FindInternedVar(lang.NewSymbol("str")) - if tmp286.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp286))) - } - tmp287 := tmp286.Get() - tmp288 := lang.Apply(tmp284, []any{v235, v236, tmp287}) - tmp277 = tmp288 - } else { - var tmp289 any - if lang.IsTruthy(lang.NewKeyword("else")) { - tmp289 = v235 - } else { - } - tmp277 = tmp289 - } - tmp265 = tmp277 - } - tmp253 = tmp265 - } - tmp242 = tmp253 - } // end let - tmp237 = tmp242 - } else { - tmp237 = v235 - } - return tmp237 - }) - tmp235 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4456), lang.NewKeyword("column"), int(45), lang.NewKeyword("end-line"), int(4464), lang.NewKeyword("end-column"), int(60)) - tmp236, err := lang.WithMeta(tmp234, tmp235.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp237 := lang.NewMap() - tmp238 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4465), lang.NewKeyword("column"), int(45), lang.NewKeyword("end-line"), int(4465), lang.NewKeyword("end-column"), int(46)) - tmp239, err := lang.WithMeta(tmp237, tmp238.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp240 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp241 := tmp240.FindInternedVar(lang.NewSymbol("keys")) - if tmp241.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp241))) - } - tmp242 := tmp241.Get() - tmp243 := lang.Apply(tmp242, []any{v22}) - tmp244 := lang.Apply(tmp233, []any{tmp236, tmp239, tmp243}) - var v245 any = tmp244 - _ = v245 - tmp246 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp247 := tmp246.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp247.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp247))) - } - tmp248 := tmp247.Get() - var tmp249 lang.FnFunc - tmp249 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v250 := args[0] - _ = v250 - v251 := args[1] - _ = v251 - tmp252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp253 := tmp252.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp253.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp253))) - } - tmp254 := tmp253.Get() - var tmp255 lang.FnFunc - tmp255 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v256 := args[0] - _ = v256 - v257 := args[1] - _ = v257 - tmp258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp259 := tmp258.FindInternedVar(lang.NewSymbol("assoc")) - if tmp259.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp259))) - } - tmp260 := tmp259.Get() - tmp261 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp262 := tmp261.FindInternedVar(lang.NewSymbol("val")) - if tmp262.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp262))) - } - tmp263 := tmp262.Get() - tmp264 := lang.Apply(tmp263, []any{v251}) - tmp265 := lang.Apply(tmp264, []any{v257}) - tmp266 := lang.Apply(tmp260, []any{v256, v257, tmp265}) - return tmp266 - }) - tmp256 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4469), lang.NewKeyword("column"), int(52), lang.NewKeyword("end-line"), int(4469), lang.NewKeyword("end-column"), int(82)) - tmp257, err := lang.WithMeta(tmp255, tmp256.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp259 := tmp258.FindInternedVar(lang.NewSymbol("dissoc")) - if tmp259.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp259))) - } - tmp260 := tmp259.Get() - tmp261 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp262 := tmp261.FindInternedVar(lang.NewSymbol("key")) - if tmp262.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp262))) - } - tmp263 := tmp262.Get() - tmp264 := lang.Apply(tmp263, []any{v251}) - tmp265 := lang.Apply(tmp260, []any{v250, tmp264}) - tmp266 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp267 := tmp266.FindInternedVar(lang.NewSymbol("key")) - if tmp267.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp267))) - } - tmp268 := tmp267.Get() - tmp269 := lang.Apply(tmp268, []any{v251}) - tmp270 := lang.Apply(tmp269, []any{v250}) - tmp271 := lang.Apply(tmp254, []any{tmp257, tmp265, tmp270}) - return tmp271 - }) - tmp250 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4468), lang.NewKeyword("column"), int(41), lang.NewKeyword("end-line"), int(4471), lang.NewKeyword("end-column"), int(70)) - tmp251, err := lang.WithMeta(tmp249, tmp250.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp253 := tmp252.FindInternedVar(lang.NewSymbol("dissoc")) - if tmp253.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp253))) - } - tmp254 := tmp253.Get() - tmp255 := lang.Apply(tmp254, []any{v22, lang.NewKeyword("as"), lang.NewKeyword("or")}) - tmp256 := lang.Apply(tmp248, []any{tmp251, tmp255, v245}) - tmp230 = tmp256 - } // end let - var v231 any = tmp230 - _ = v231 - for { - var tmp232 any - tmp233 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp234 := tmp233.FindInternedVar(lang.NewSymbol("seq")) - if tmp234.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp234))) - } - tmp235 := tmp234.Get() - tmp236 := lang.Apply(tmp235, []any{v231}) - if lang.IsTruthy(tmp236) { - var tmp237 any - { // let - // let binding "bb" - tmp238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp239 := tmp238.FindInternedVar(lang.NewSymbol("key")) - if tmp239.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp239))) - } - tmp240 := tmp239.Get() - tmp241 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp242 := tmp241.FindInternedVar(lang.NewSymbol("first")) - if tmp242.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp242))) - } - tmp243 := tmp242.Get() - tmp244 := lang.Apply(tmp243, []any{v231}) - tmp245 := lang.Apply(tmp240, []any{tmp244}) - var v246 any = tmp245 - _ = v246 - // let binding "bk" - tmp247 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp248 := tmp247.FindInternedVar(lang.NewSymbol("val")) - if tmp248.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp248))) - } - tmp249 := tmp248.Get() - tmp250 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp251 := tmp250.FindInternedVar(lang.NewSymbol("first")) - if tmp251.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp251))) - } - tmp252 := tmp251.Get() - tmp253 := lang.Apply(tmp252, []any{v231}) - tmp254 := lang.Apply(tmp249, []any{tmp253}) - var v255 any = tmp254 - _ = v255 - // let binding "local" - var tmp256 any - tmp257 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp258 := tmp257.FindInternedVar(lang.NewSymbol("instance?")) - if tmp258.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp258))) - } - tmp259 := tmp258.Get() - tmp260 := reflect.TypeOf((*lang.Named)(nil)).Elem() - tmp261 := lang.Apply(tmp259, []any{tmp260, v246}) - if lang.IsTruthy(tmp261) { - tmp262 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp263 := tmp262.FindInternedVar(lang.NewSymbol("with-meta")) - if tmp263.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp263))) - } - tmp264 := tmp263.Get() - tmp265 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp266 := tmp265.FindInternedVar(lang.NewSymbol("symbol")) - if tmp266.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp266))) - } - tmp267 := tmp266.Get() - tmp268 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp269 := tmp268.FindInternedVar(lang.NewSymbol("name")) - if tmp269.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp269))) - } - tmp270 := tmp269.Get() - tmp271 := lang.Apply(tmp270, []any{v246}) - tmp272 := lang.Apply(tmp267, []any{nil, tmp271}) - tmp273 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp274 := tmp273.FindInternedVar(lang.NewSymbol("meta")) - if tmp274.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp274))) - } - tmp275 := tmp274.Get() - tmp276 := lang.Apply(tmp275, []any{v246}) - tmp277 := lang.Apply(tmp264, []any{tmp272, tmp276}) - tmp256 = tmp277 - } else { - tmp256 = v246 - } - var v278 any = tmp256 - _ = v278 - // let binding "bv" - var tmp279 any - tmp280 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp281 := tmp280.FindInternedVar(lang.NewSymbol("contains?")) - if tmp281.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp281))) - } - tmp282 := tmp281.Get() - tmp283 := lang.Apply(tmp282, []any{v39, v278}) - if lang.IsTruthy(tmp283) { - tmp284 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp285 := tmp284.FindInternedVar(lang.NewSymbol("list")) - if tmp285.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp285))) - } - tmp286 := tmp285.Get() - tmp287 := lang.Apply(v39, []any{v278}) - tmp288 := lang.Apply(tmp286, []any{lang.NewSymbol("glojure.core/get"), v29, v255, tmp287}) - tmp279 = tmp288 - } else { - tmp289 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp290 := tmp289.FindInternedVar(lang.NewSymbol("list")) - if tmp290.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp290))) - } - tmp291 := tmp290.Get() - tmp292 := lang.Apply(tmp291, []any{lang.NewSymbol("glojure.core/get"), v29, v255}) - tmp279 = tmp292 - } - var v293 any = tmp279 - _ = v293 - var tmp295 any - tmp296 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp297 := tmp296.FindInternedVar(lang.NewSymbol("ident?")) - if tmp297.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp297))) - } - tmp298 := tmp297.Get() - tmp299 := lang.Apply(tmp298, []any{v246}) - if lang.IsTruthy(tmp299) { - tmp300 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp301 := tmp300.FindInternedVar(lang.NewSymbol("conj")) - if tmp301.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp301))) - } - tmp302 := tmp301.Get() - tmp303 := lang.Apply(tmp302, []any{v229, v278, v293}) - tmp295 = tmp303 - } else { - tmp304 := lang.Apply(v11, []any{v229, v246, v293}) - tmp295 = tmp304 - } - var tmp294 any = tmp295 - tmp306 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp307 := tmp306.FindInternedVar(lang.NewSymbol("next")) - if tmp307.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp307))) - } - tmp308 := tmp307.Get() - tmp309 := lang.Apply(tmp308, []any{v231}) - var tmp305 any = tmp309 - v229 = tmp294 - v231 = tmp305 - continue - } // end let - tmp232 = tmp237 - } else { - tmp232 = v229 - } - tmp40 = tmp232 - break - } - } // end let - tmp24 = tmp40 - } // end let - return tmp24 - }) - tmp21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4440), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(4485), lang.NewKeyword("end-column"), int(34)) - tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v23 any = tmp22 - _ = v23 - var tmp24 any - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("symbol?")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.Apply(tmp27, []any{v13}) - if lang.IsTruthy(tmp28) { - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("conj")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("conj")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.Apply(tmp34, []any{v12, v13}) - tmp36 := lang.Apply(tmp31, []any{tmp35, v14}) - tmp24 = tmp36 - } else { - var tmp37 any - tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp39 := tmp38.FindInternedVar(lang.NewSymbol("vector?")) - if tmp39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) - } - tmp40 := tmp39.Get() - tmp41 := lang.Apply(tmp40, []any{v13}) - if lang.IsTruthy(tmp41) { - tmp42 := lang.Apply(v19, []any{v12, v13, v14}) - tmp37 = tmp42 - } else { - var tmp43 any - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("map?")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.Apply(tmp46, []any{v13}) - if lang.IsTruthy(tmp47) { - tmp48 := lang.Apply(v23, []any{v12, v13, v14}) - tmp43 = tmp48 - } else { - var tmp49 any - if lang.IsTruthy(lang.NewKeyword("else")) { - tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp51 := tmp50.FindInternedVar(lang.NewSymbol("str")) - if tmp51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) - } - tmp52 := tmp51.Get() - tmp53 := lang.Apply(tmp52, []any{"Unsupported binding form: ", v13}) - tmp54 := lang.Apply(errors5.New, []any{tmp53}) - panic(tmp54) - } else { - } - tmp43 = tmp49 - } - tmp37 = tmp43 - } - tmp24 = tmp37 - } - tmp15 = tmp24 - } // end let - return tmp15 - }) - v11 = tmp10 - _ = v11 - } - tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4402), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(4490), lang.NewKeyword("end-column"), int(82)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v13 any = tmp12 - _ = v13 - // let binding "process-entry" - var tmp14 lang.FnFunc - tmp14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v15 := args[0] - _ = v15 - v16 := args[1] - _ = v16 - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("first")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.Apply(tmp19, []any{v16}) - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("second")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.Apply(tmp23, []any{v16}) - tmp25 := lang.Apply(v13, []any{v15, tmp20, tmp24}) - return tmp25 - }) - tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4491), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(4491), lang.NewKeyword("end-column"), int(66)) - tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v17 any = tmp16 - _ = v17 - var tmp18 any - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("every?")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("symbol?")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("map")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("first")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.Apply(tmp27, []any{tmp30, v9}) - tmp32 := lang.Apply(tmp21, []any{tmp24, tmp31}) - if lang.IsTruthy(tmp32) { - tmp18 = v3 - } else { - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.NewVector() - tmp37 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4494), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(4494), lang.NewKeyword("end-column"), int(31)) - tmp38, err := lang.WithMeta(tmp36, tmp37.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp39 := lang.Apply(tmp35, []any{v17, tmp38, v9}) - tmp18 = tmp39 - } - tmp4 = tmp18 - } // end let - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // disj - { - tmp0 := lang.NewSymbol("disj").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("set")), lang.NewVector(lang.NewSymbol("set"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("set"), lang.NewSymbol("key"), lang.NewSymbol("&"), lang.NewSymbol("ks"))), lang.NewKeyword("doc"), "disj[oin]. Returns a new set of the same (hashed/sorted) type, that\n does not contain key(s).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1514), lang.NewKeyword("end-line"), int(1514))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - return v3 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - if lang.IsTruthy(v3) { - tmp6, _ := lang.FieldOrMethod(v3, "Disjoin") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Disjoin is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4}) - tmp5 = tmp7 - } else { - } - return tmp5 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - recur_loop_304: - var tmp6 any - if lang.IsTruthy(v3) { - var tmp7 any - { // let - // let binding "ret" - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("disj")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v3, v4}) - var v12 any = tmp11 - _ = v12 - var tmp13 any - if lang.IsTruthy(v5) { - var tmp14 any = v12 - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("first")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{v5}) - var tmp15 any = tmp19 - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("next")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.Apply(tmp23, []any{v5}) - var tmp20 any = tmp24 - v3 = tmp14 - v4 = tmp15 - v5 = tmp20 - goto recur_loop_304 - } else { - tmp13 = v12 - } - tmp7 = tmp13 - } // end let - tmp6 = tmp7 - } else { - } - return tmp6 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // disj! - { - tmp0 := lang.NewSymbol("disj!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("set")), lang.NewVector(lang.NewSymbol("set"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("set"), lang.NewSymbol("key"), lang.NewSymbol("&"), lang.NewSymbol("ks"))), lang.NewKeyword("doc"), "disj[oin]. Returns a transient set of the same (hashed/sorted) type, that\n does not contain key(s).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3401), lang.NewKeyword("end-line"), int(3401))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - return v3 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5, _ := lang.FieldOrMethod(v3, "Disjoin") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Disjoin is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - recur_loop_615: - var tmp6 any - { // let - // let binding "ret" - tmp7, _ := lang.FieldOrMethod(v3, "Disjoin") - if reflect.TypeOf(tmp7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Disjoin is not a function"))) - } - tmp8 := lang.Apply(tmp7, []any{v4}) - var v9 any = tmp8 - _ = v9 - var tmp10 any - if lang.IsTruthy(v5) { - var tmp11 any = v9 - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("first")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{v5}) - var tmp12 any = tmp16 - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("next")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.Apply(tmp20, []any{v5}) - var tmp17 any = tmp21 - v3 = tmp11 - v4 = tmp12 - v5 = tmp17 - goto recur_loop_615 - } else { - tmp10 = v9 - } - tmp6 = tmp10 - } // end let - return tmp6 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // dissoc - { - tmp0 := lang.NewSymbol("dissoc").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map")), lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"), lang.NewSymbol("&"), lang.NewSymbol("ks"))), lang.NewKeyword("doc"), "dissoc[iate]. Returns a new map of the same (hashed/sorted) type,\n that does not contain a mapping for key(s).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1500), lang.NewKeyword("end-line"), int(1500))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - return v3 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5, _ := lang.FieldOrMethod(runtime4.RT, "Dissoc") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Dissoc is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v3, v4}) - return tmp6 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - recur_loop_301: - var tmp6 any - { // let - // let binding "ret" - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("dissoc")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp9, []any{v3, v4}) - var v11 any = tmp10 - _ = v11 - var tmp12 any - if lang.IsTruthy(v5) { - var tmp13 any = v11 - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("first")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{v5}) - var tmp14 any = tmp18 - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("next")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.Apply(tmp22, []any{v5}) - var tmp19 any = tmp23 - v3 = tmp13 - v4 = tmp14 - v5 = tmp19 - goto recur_loop_301 - } else { - tmp12 = v11 - } - tmp6 = tmp12 - } // end let - return tmp6 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // dissoc! - { - tmp0 := lang.NewSymbol("dissoc!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"), lang.NewSymbol("&"), lang.NewSymbol("ks"))), lang.NewKeyword("doc"), "Returns a transient map that doesn't contain a mapping for key(s).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3382), lang.NewKeyword("end-line"), int(3382))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5, _ := lang.FieldOrMethod(v3, "without") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("without is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - recur_loop_611: - var tmp6 any - { // let - // let binding "ret" - tmp7, _ := lang.FieldOrMethod(v3, "without") - if reflect.TypeOf(tmp7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("without is not a function"))) - } - tmp8 := lang.Apply(tmp7, []any{v4}) - var v9 any = tmp8 - _ = v9 - var tmp10 any - if lang.IsTruthy(v5) { - var tmp11 any = v9 - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("first")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{v5}) - var tmp12 any = tmp16 - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("next")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.Apply(tmp20, []any{v5}) - var tmp17 any = tmp21 - v3 = tmp11 - v4 = tmp12 - v5 = tmp17 - goto recur_loop_611 - } else { - tmp10 = v9 - } - tmp6 = tmp10 - } // end let - return tmp6 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // distinct - { - tmp0 := lang.NewSymbol("distinct").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the elements of coll with duplicates removed.\n Returns a stateful transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5053), lang.NewKeyword("end-line"), int(5053))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - var tmp5 any - { // let - // let binding "seen" - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("volatile!")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) - tmp10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5060), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(5060), lang.NewKeyword("end-column"), int(30)) - tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp12 := lang.Apply(tmp8, []any{tmp11}) - var v13 any = tmp12 - _ = v13 - var tmp14 lang.FnFunc - tmp14 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp15 := lang.Apply(v4, nil) - return tmp15 - case 1: - v15 := args[0] - _ = v15 - tmp16 := lang.Apply(v4, []any{v15}) - return tmp16 - case 2: - v15 := args[0] - _ = v15 - v16 := args[1] - _ = v16 - var tmp17 any - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("contains?")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("deref")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.Apply(tmp23, []any{v13}) - tmp25 := lang.Apply(tmp20, []any{tmp24, v16}) - if lang.IsTruthy(tmp25) { - tmp17 = v15 - } else { - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("conj")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29, ok := lang.FieldOrMethod(v13, "Deref") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v13, "Deref"))) - } - var tmp30 any - switch reflect.TypeOf(tmp29).Kind() { - case reflect.Func: - tmp30 = lang.Apply(tmp29, nil) - default: - tmp30 = tmp29 - } - tmp31 := lang.Apply(tmp28, []any{tmp30, v16}) - tmp32, _ := lang.FieldOrMethod(v13, "reset") - if reflect.TypeOf(tmp32).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) - } - tmp33 := lang.Apply(tmp32, []any{tmp31}) - _ = tmp33 - tmp34 := lang.Apply(v4, []any{v15, v16}) - tmp17 = tmp34 - } - return tmp17 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5061), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(5068), lang.NewKeyword("end-column"), int(37)) - tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp5 = tmp16 - } // end let - return tmp5 - }) - tmp4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5059), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(5068), lang.NewKeyword("end-column"), int(39)) - tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp5 - case 1: - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "step" - var tmp5 lang.FnFunc - { // function step - var v6 lang.FnFunc - tmp5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v7 := args[0] - _ = v7 - v8 := args[1] - _ = v8 - var tmp9 lang.FnFunc - tmp9 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var tmp10 lang.FnFunc - tmp10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v11 := args[0] - _ = v11 - v12 := args[1] - _ = v12 - recur_loop_877: - var tmp13 any - { // let - // let binding "vec__62" - var v14 any = v11 - _ = v14 - // let binding "f" - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("nth")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{v14, int64(0), nil}) - var v19 any = tmp18 - _ = v19 - // let binding "xs" - var v20 any = v14 - _ = v20 - var tmp21 any - { // let - // let binding "temp__0__auto__" - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("seq")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.Apply(tmp24, []any{v20}) - var v26 any = tmp25 - _ = v26 - var tmp27 any - if lang.IsTruthy(v26) { - var tmp28 any - { // let - // let binding "s" - var v29 any = v26 - _ = v29 - var tmp30 any - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("contains?")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{v12, v19}) - if lang.IsTruthy(tmp34) { - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("rest")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{v29}) - var tmp35 any = tmp39 - var tmp40 any = v12 - v11 = tmp35 - v12 = tmp40 - goto recur_loop_877 - } else { - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("cons")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("rest")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.Apply(tmp46, []any{v29}) - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("conj")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v12, v19}) - tmp52 := lang.Apply(v6, []any{tmp47, tmp51}) - tmp53 := lang.Apply(tmp43, []any{v19, tmp52}) - tmp30 = tmp53 - } - tmp28 = tmp30 - } // end let - tmp27 = tmp28 - } else { - } - tmp21 = tmp27 - } // end let - tmp13 = tmp21 - } // end let - return tmp13 - }) - tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5072), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(5076), lang.NewKeyword("end-column"), int(66)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp13 := lang.Apply(tmp12, []any{v7, v8}) - return tmp13 - }) - tmp10 := lang.Apply(lang.NewLazySeq, []any{tmp9}) - return tmp10 - }) - v6 = tmp5 - _ = v6 - } - tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5070), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(5077), lang.NewKeyword("end-column"), int(29)) - tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v8 any = tmp7 - _ = v8 - tmp9 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) - tmp10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5078), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(5078), lang.NewKeyword("end-column"), int(19)) - tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp12 := lang.Apply(v8, []any{v3, tmp11}) - tmp4 = tmp12 - } // end let - return tmp4 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // distinct? - { - tmp1 := reflect.TypeOf(false) - tmp0 := lang.NewSymbol("distinct?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Returns true if no two of the arguments are =", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5664), lang.NewKeyword("end-line"), int(5664))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v4 := args[0] - _ = v4 - return true - case 2: - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("not")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("=")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.Apply(tmp11, []any{v4, v5}) - tmp13 := lang.Apply(tmp8, []any{tmp12}) - return tmp13 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - var v6 any = lang.NewList(args[2:]...) - _ = v6 - var tmp7 any - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("not=")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v4, v5}) - if lang.IsTruthy(tmp11) { - var tmp12 any - { // let - // let binding "s" - tmp13 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{v4, v5})) - tmp14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5673), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(5673), lang.NewKeyword("end-column"), int(20)) - tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v16 any = tmp15 - _ = v16 - // let binding "G__99" - var v17 any = v6 - _ = v17 - // let binding "vec__100" - var v18 any = v17 - _ = v18 - // let binding "seq__101" - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("seq")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, []any{v18}) - var v23 any = tmp22 - _ = v23 - // let binding "first__102" - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("first")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.Apply(tmp26, []any{v23}) - var v28 any = tmp27 - _ = v28 - // let binding "seq__101" - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("next")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.Apply(tmp31, []any{v23}) - var v33 any = tmp32 - _ = v33 - // let binding "x" - var v34 any = v28 - _ = v34 - // let binding "etc" - var v35 any = v33 - _ = v35 - // let binding "xs" - var v36 any = v18 - _ = v36 - var tmp37 any - { // let - // let binding "s" - var v38 any = v16 - _ = v38 - // let binding "G__99" - var v39 any = v17 - _ = v39 - for { - var tmp40 any - { // let - // let binding "s" - var v41 any = v38 - _ = v41 - // let binding "vec__103" - var v42 any = v39 - _ = v42 - // let binding "seq__104" - tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp44 := tmp43.FindInternedVar(lang.NewSymbol("seq")) - if tmp44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) - } - tmp45 := tmp44.Get() - tmp46 := lang.Apply(tmp45, []any{v42}) - var v47 any = tmp46 - _ = v47 - // let binding "first__105" - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("first")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v47}) - var v52 any = tmp51 - _ = v52 - // let binding "seq__104" - tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp54 := tmp53.FindInternedVar(lang.NewSymbol("next")) - if tmp54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) - } - tmp55 := tmp54.Get() - tmp56 := lang.Apply(tmp55, []any{v47}) - var v57 any = tmp56 - _ = v57 - // let binding "x" - var v58 any = v52 - _ = v58 - // let binding "etc" - var v59 any = v57 - _ = v59 - // let binding "xs" - var v60 any = v42 - _ = v60 - var tmp61 any - if lang.IsTruthy(v60) { - var tmp62 any - tmp63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp64 := tmp63.FindInternedVar(lang.NewSymbol("contains?")) - if tmp64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp64))) - } - tmp65 := tmp64.Get() - tmp66 := lang.Apply(tmp65, []any{v41, v58}) - if lang.IsTruthy(tmp66) { - tmp62 = false - } else { - tmp68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp69 := tmp68.FindInternedVar(lang.NewSymbol("conj")) - if tmp69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp69))) - } - tmp70 := tmp69.Get() - tmp71 := lang.Apply(tmp70, []any{v41, v58}) - var tmp67 any = tmp71 - var tmp72 any = v59 - v38 = tmp67 - v39 = tmp72 - continue - } - tmp61 = tmp62 - } else { - tmp61 = true - } - tmp40 = tmp61 - } // end let - tmp37 = tmp40 - break - } - } // end let - tmp12 = tmp37 - } // end let - tmp7 = tmp12 - } else { - tmp7 = false - } - return tmp7 - } - }) - tmp4 := reflect.TypeOf(false) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // doall - { - tmp0 := lang.NewSymbol("doall").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "When lazy sequences are produced via functions that have side\n effects, any effects other than those needed to produce the first\n element in the seq do not occur until the seq is consumed. doall can\n be used to force any effects. Walks through the successive nexts of\n the seq, retains the head and returns it, thus causing the entire\n seq to reside in memory at one time.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3131), lang.NewKeyword("end-line"), int(3131))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("dorun")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.Apply(tmp6, []any{v3}) - _ = tmp7 - return v3 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("dorun")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v3, v4}) - _ = tmp8 - return v4 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // dorun - { - tmp0 := lang.NewSymbol("dorun").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "When lazy sequences are produced via functions that have side\n effects, any effects other than those needed to produce the first\n element in the seq do not occur until the seq is consumed. dorun can\n be used to force any effects. Walks through the successive nexts of\n the seq, does not retain the head and returns nil.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3116), lang.NewKeyword("end-line"), int(3116))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - recur_loop_579: - var tmp4 any - { // let - // let binding "temp__0__auto__" - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v3}) - var v9 any = tmp8 - _ = v9 - var tmp10 any - if lang.IsTruthy(v9) { - var tmp11 any - { // let - // let binding "s" - var v12 any = v9 - _ = v12 - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("next")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{v12}) - var tmp13 any = tmp17 - v3 = tmp13 - goto recur_loop_579 - } // end let - tmp10 = tmp11 - } else { - } - tmp4 = tmp10 - } // end let - return tmp4 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - recur_loop_580: - var tmp5 any - var tmp6 any - { // let - // let binding "and__0__auto__" - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("seq")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp9, []any{v4}) - var v11 any = tmp10 - _ = v11 - var tmp12 any - if lang.IsTruthy(v11) { - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("pos?")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{v3}) - tmp12 = tmp16 - } else { - tmp12 = v11 - } - tmp6 = tmp12 - } // end let - if lang.IsTruthy(tmp6) { - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("dec")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v3}) - var tmp7 any = tmp11 - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("next")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{v4}) - var tmp12 any = tmp16 - v3 = tmp7 - v4 = tmp12 - goto recur_loop_580 - } else { - } - return tmp5 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // doseq - { - tmp0 := lang.NewSymbol("doseq").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("seq-exprs"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Repeatedly executes body (presumably for side-effects) with\n bindings and filtering as provided by \"for\". Does not retain\n the head of the sequence. Returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3209), lang.NewKeyword("end-line"), int(3209))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("vector?")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v5}) - if lang.IsTruthy(tmp11) { - } else { - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("str")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("first")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{v3}) - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("*ns*")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("meta")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.Apply(tmp24, []any{v3}) - tmp26 := lang.Apply(lang.NewKeyword("line"), []any{tmp25}) - tmp27 := lang.Apply(tmp14, []any{tmp18, " requires ", "a vector for its binding", " in ", tmp21, ":", tmp26}) - tmp28 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp27}) - panic(tmp28) - } - _ = tmp7 - var tmp29 any - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("even?")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("count")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.Apply(tmp35, []any{v5}) - tmp37 := lang.Apply(tmp32, []any{tmp36}) - if lang.IsTruthy(tmp37) { - } else { - tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp39 := tmp38.FindInternedVar(lang.NewSymbol("str")) - if tmp39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) - } - tmp40 := tmp39.Get() - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("first")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.Apply(tmp43, []any{v3}) - tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp46 := tmp45.FindInternedVar(lang.NewSymbol("*ns*")) - if tmp46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) - } - tmp47 := tmp46.Get() - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("meta")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v3}) - tmp52 := lang.Apply(lang.NewKeyword("line"), []any{tmp51}) - tmp53 := lang.Apply(tmp40, []any{tmp44, " requires ", "an even number of forms in binding vector", " in ", tmp47, ":", tmp52}) - tmp54 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp53}) - panic(tmp54) - } - _ = tmp29 - var tmp55 any - { // let - // let binding "step" - var tmp56 lang.FnFunc - { // function step - var v57 lang.FnFunc - tmp56 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v58 := args[0] - _ = v58 - v59 := args[1] - _ = v59 - var tmp60 any - tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp62 := tmp61.FindInternedVar(lang.NewSymbol("not")) - if tmp62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) - } - tmp63 := tmp62.Get() - tmp64 := lang.Apply(tmp63, []any{v59}) - if lang.IsTruthy(tmp64) { - tmp65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp66 := tmp65.FindInternedVar(lang.NewSymbol("seq")) - if tmp66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp66))) - } - tmp67 := tmp66.Get() - tmp68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp69 := tmp68.FindInternedVar(lang.NewSymbol("concat")) - if tmp69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp69))) - } - tmp70 := tmp69.Get() - tmp71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp72 := tmp71.FindInternedVar(lang.NewSymbol("list")) - if tmp72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp72))) - } - tmp73 := tmp72.Get() - tmp74 := lang.Apply(tmp73, []any{lang.NewSymbol("do")}) - tmp75 := lang.Apply(tmp70, []any{tmp74, v6}) - tmp76 := lang.Apply(tmp67, []any{tmp75}) - tmp77 := lang.NewVector(true, tmp76) - tmp78 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3220), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(3220), lang.NewKeyword("end-column"), int(36)) - tmp79, err := lang.WithMeta(tmp77, tmp78.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp60 = tmp79 - } else { - var tmp80 any - { // let - // let binding "k" - tmp81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp82 := tmp81.FindInternedVar(lang.NewSymbol("first")) - if tmp82.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp82))) - } - tmp83 := tmp82.Get() - tmp84 := lang.Apply(tmp83, []any{v59}) - var v85 any = tmp84 - _ = v85 - // let binding "v" - tmp86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp87 := tmp86.FindInternedVar(lang.NewSymbol("second")) - if tmp87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp87))) - } - tmp88 := tmp87.Get() - tmp89 := lang.Apply(tmp88, []any{v59}) - var v90 any = tmp89 - _ = v90 - var tmp91 any - tmp92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp93 := tmp92.FindInternedVar(lang.NewSymbol("keyword?")) - if tmp93.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp93))) - } - tmp94 := tmp93.Get() - tmp95 := lang.Apply(tmp94, []any{v85}) - if lang.IsTruthy(tmp95) { - var tmp96 any - { // let - // let binding "steppair" - tmp97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp98 := tmp97.FindInternedVar(lang.NewSymbol("nnext")) - if tmp98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp98))) - } - tmp99 := tmp98.Get() - tmp100 := lang.Apply(tmp99, []any{v59}) - tmp101 := lang.Apply(v57, []any{v58, tmp100}) - var v102 any = tmp101 - _ = v102 - // let binding "needrec" - tmp103 := lang.Apply(v102, []any{int64(0)}) - var v104 any = tmp103 - _ = v104 - // let binding "subform" - tmp105 := lang.Apply(v102, []any{int64(1)}) - var v106 any = tmp105 - _ = v106 - var tmp107 any - tmp108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp109 := tmp108.FindInternedVar(lang.NewSymbol("=")) - if tmp109.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp109))) - } - tmp110 := tmp109.Get() - tmp111 := lang.Apply(tmp110, []any{v85, lang.NewKeyword("let")}) - if lang.IsTruthy(tmp111) { - tmp112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp113 := tmp112.FindInternedVar(lang.NewSymbol("seq")) - if tmp113.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp113))) - } - tmp114 := tmp113.Get() - tmp115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp116 := tmp115.FindInternedVar(lang.NewSymbol("concat")) - if tmp116.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp116))) - } - tmp117 := tmp116.Get() - tmp118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp119 := tmp118.FindInternedVar(lang.NewSymbol("list")) - if tmp119.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp119))) - } - tmp120 := tmp119.Get() - tmp121 := lang.Apply(tmp120, []any{lang.NewSymbol("glojure.core/let")}) - tmp122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp123 := tmp122.FindInternedVar(lang.NewSymbol("list")) - if tmp123.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp123))) - } - tmp124 := tmp123.Get() - tmp125 := lang.Apply(tmp124, []any{v90}) - tmp126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp127 := tmp126.FindInternedVar(lang.NewSymbol("list")) - if tmp127.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp127))) - } - tmp128 := tmp127.Get() - tmp129 := lang.Apply(tmp128, []any{v106}) - tmp130 := lang.Apply(tmp117, []any{tmp121, tmp125, tmp129}) - tmp131 := lang.Apply(tmp114, []any{tmp130}) - tmp132 := lang.NewVector(v104, tmp131) - tmp133 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3228), lang.NewKeyword("column"), int(37), lang.NewKeyword("end-line"), int(3228), lang.NewKeyword("end-column"), int(64)) - tmp134, err := lang.WithMeta(tmp132, tmp133.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp107 = tmp134 - } else { - var tmp135 any - tmp136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp137 := tmp136.FindInternedVar(lang.NewSymbol("=")) - if tmp137.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp137))) - } - tmp138 := tmp137.Get() - tmp139 := lang.Apply(tmp138, []any{v85, lang.NewKeyword("while")}) - if lang.IsTruthy(tmp139) { - tmp140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp141 := tmp140.FindInternedVar(lang.NewSymbol("seq")) - if tmp141.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp141))) - } - tmp142 := tmp141.Get() - tmp143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp144 := tmp143.FindInternedVar(lang.NewSymbol("concat")) - if tmp144.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp144))) - } - tmp145 := tmp144.Get() - tmp146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp147 := tmp146.FindInternedVar(lang.NewSymbol("list")) - if tmp147.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp147))) - } - tmp148 := tmp147.Get() - tmp149 := lang.Apply(tmp148, []any{lang.NewSymbol("glojure.core/when")}) - tmp150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp151 := tmp150.FindInternedVar(lang.NewSymbol("list")) - if tmp151.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp151))) - } - tmp152 := tmp151.Get() - tmp153 := lang.Apply(tmp152, []any{v90}) - tmp154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp155 := tmp154.FindInternedVar(lang.NewSymbol("list")) - if tmp155.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp155))) - } - tmp156 := tmp155.Get() - tmp157 := lang.Apply(tmp156, []any{v106}) - var tmp158 any - if lang.IsTruthy(v104) { - tmp159 := lang.NewVector(v58) - tmp160 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3231), lang.NewKeyword("column"), int(65), lang.NewKeyword("end-line"), int(3231), lang.NewKeyword("end-column"), int(73)) - tmp161, err := lang.WithMeta(tmp159, tmp160.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp158 = tmp161 - } else { - } - tmp162 := lang.Apply(tmp145, []any{tmp149, tmp153, tmp157, tmp158}) - tmp163 := lang.Apply(tmp142, []any{tmp162}) - tmp164 := lang.NewVector(false, tmp163) - tmp165 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3229), lang.NewKeyword("column"), int(39), lang.NewKeyword("end-line"), int(3231), lang.NewKeyword("end-column"), int(76)) - tmp166, err := lang.WithMeta(tmp164, tmp165.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp135 = tmp166 - } else { - var tmp167 any - tmp168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp169 := tmp168.FindInternedVar(lang.NewSymbol("=")) - if tmp169.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp169))) - } - tmp170 := tmp169.Get() - tmp171 := lang.Apply(tmp170, []any{v85, lang.NewKeyword("when")}) - if lang.IsTruthy(tmp171) { - tmp172 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp173 := tmp172.FindInternedVar(lang.NewSymbol("seq")) - if tmp173.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp173))) - } - tmp174 := tmp173.Get() - tmp175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp176 := tmp175.FindInternedVar(lang.NewSymbol("concat")) - if tmp176.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp176))) - } - tmp177 := tmp176.Get() - tmp178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp179 := tmp178.FindInternedVar(lang.NewSymbol("list")) - if tmp179.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp179))) - } - tmp180 := tmp179.Get() - tmp181 := lang.Apply(tmp180, []any{lang.NewSymbol("if")}) - tmp182 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp183 := tmp182.FindInternedVar(lang.NewSymbol("list")) - if tmp183.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp183))) - } - tmp184 := tmp183.Get() - tmp185 := lang.Apply(tmp184, []any{v90}) - tmp186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp187 := tmp186.FindInternedVar(lang.NewSymbol("list")) - if tmp187.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp187))) - } - tmp188 := tmp187.Get() - tmp189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp190 := tmp189.FindInternedVar(lang.NewSymbol("seq")) - if tmp190.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp190))) - } - tmp191 := tmp190.Get() - tmp192 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp193 := tmp192.FindInternedVar(lang.NewSymbol("concat")) - if tmp193.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp193))) - } - tmp194 := tmp193.Get() - tmp195 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp196 := tmp195.FindInternedVar(lang.NewSymbol("list")) - if tmp196.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp196))) - } - tmp197 := tmp196.Get() - tmp198 := lang.Apply(tmp197, []any{lang.NewSymbol("do")}) - tmp199 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp200 := tmp199.FindInternedVar(lang.NewSymbol("list")) - if tmp200.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp200))) - } - tmp201 := tmp200.Get() - tmp202 := lang.Apply(tmp201, []any{v106}) - var tmp203 any - if lang.IsTruthy(v104) { - tmp204 := lang.NewVector(v58) - tmp205 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3235), lang.NewKeyword("column"), int(66), lang.NewKeyword("end-line"), int(3235), lang.NewKeyword("end-column"), int(74)) - tmp206, err := lang.WithMeta(tmp204, tmp205.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp203 = tmp206 - } else { - } - tmp207 := lang.Apply(tmp194, []any{tmp198, tmp202, tmp203}) - tmp208 := lang.Apply(tmp191, []any{tmp207}) - tmp209 := lang.Apply(tmp188, []any{tmp208}) - tmp210 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp211 := tmp210.FindInternedVar(lang.NewSymbol("list")) - if tmp211.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp211))) - } - tmp212 := tmp211.Get() - tmp213 := lang.Apply(tmp212, []any{v58}) - tmp214 := lang.Apply(tmp177, []any{tmp181, tmp185, tmp209, tmp213}) - tmp215 := lang.Apply(tmp174, []any{tmp214}) - tmp216 := lang.NewVector(false, tmp215) - tmp217 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3232), lang.NewKeyword("column"), int(38), lang.NewKeyword("end-line"), int(3236), lang.NewKeyword("end-column"), int(57)) - tmp218, err := lang.WithMeta(tmp216, tmp217.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp167 = tmp218 - } else { - } - tmp135 = tmp167 - } - tmp107 = tmp135 - } - tmp96 = tmp107 - } // end let - tmp91 = tmp96 - } else { - var tmp97 any - { // let - // let binding "seq-" - tmp98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp99 := tmp98.FindInternedVar(lang.NewSymbol("gensym")) - if tmp99.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp99))) - } - tmp100 := tmp99.Get() - tmp101 := lang.Apply(tmp100, []any{"seq_"}) - var v102 any = tmp101 - _ = v102 - // let binding "chunk-" - tmp103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp104 := tmp103.FindInternedVar(lang.NewSymbol("with-meta")) - if tmp104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp104))) - } - tmp105 := tmp104.Get() - tmp106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp107 := tmp106.FindInternedVar(lang.NewSymbol("gensym")) - if tmp107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp107))) - } - tmp108 := tmp107.Get() - tmp109 := lang.Apply(tmp108, []any{"chunk_"}) - tmp110 := lang.NewMap(lang.NewKeyword("tag"), lang.NewSymbol("glojure.lang.IChunk")) - tmp111 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3239), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(3239), lang.NewKeyword("end-column"), int(72)) - tmp112, err := lang.WithMeta(tmp110, tmp111.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp113 := lang.Apply(tmp105, []any{tmp109, tmp112}) - var v114 any = tmp113 - _ = v114 - // let binding "count-" - tmp115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp116 := tmp115.FindInternedVar(lang.NewSymbol("gensym")) - if tmp116.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp116))) - } - tmp117 := tmp116.Get() - tmp118 := lang.Apply(tmp117, []any{"count_"}) - var v119 any = tmp118 - _ = v119 - // let binding "i-" - tmp120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp121 := tmp120.FindInternedVar(lang.NewSymbol("gensym")) - if tmp121.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp121))) - } - tmp122 := tmp121.Get() - tmp123 := lang.Apply(tmp122, []any{"i_"}) - var v124 any = tmp123 - _ = v124 - // let binding "recform" - tmp125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp126 := tmp125.FindInternedVar(lang.NewSymbol("seq")) - if tmp126.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp126))) - } - tmp127 := tmp126.Get() - tmp128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp129 := tmp128.FindInternedVar(lang.NewSymbol("concat")) - if tmp129.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp129))) - } - tmp130 := tmp129.Get() - tmp131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp132 := tmp131.FindInternedVar(lang.NewSymbol("list")) - if tmp132.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp132))) - } - tmp133 := tmp132.Get() - tmp134 := lang.Apply(tmp133, []any{lang.NewSymbol("recur")}) - tmp135 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp136 := tmp135.FindInternedVar(lang.NewSymbol("list")) - if tmp136.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp136))) - } - tmp137 := tmp136.Get() - tmp138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp139 := tmp138.FindInternedVar(lang.NewSymbol("seq")) - if tmp139.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp139))) - } - tmp140 := tmp139.Get() - tmp141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp142 := tmp141.FindInternedVar(lang.NewSymbol("concat")) - if tmp142.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp142))) - } - tmp143 := tmp142.Get() - tmp144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp145 := tmp144.FindInternedVar(lang.NewSymbol("list")) - if tmp145.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp145))) - } - tmp146 := tmp145.Get() - tmp147 := lang.Apply(tmp146, []any{lang.NewSymbol("glojure.core/next")}) - tmp148 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp149 := tmp148.FindInternedVar(lang.NewSymbol("list")) - if tmp149.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp149))) - } - tmp150 := tmp149.Get() - tmp151 := lang.Apply(tmp150, []any{v102}) - tmp152 := lang.Apply(tmp143, []any{tmp147, tmp151}) - tmp153 := lang.Apply(tmp140, []any{tmp152}) - tmp154 := lang.Apply(tmp137, []any{tmp153}) - tmp155 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp156 := tmp155.FindInternedVar(lang.NewSymbol("list")) - if tmp156.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp156))) - } - tmp157 := tmp156.Get() - tmp158 := lang.Apply(tmp157, []any{nil}) - tmp159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp160 := tmp159.FindInternedVar(lang.NewSymbol("list")) - if tmp160.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp160))) - } - tmp161 := tmp160.Get() - tmp162 := lang.Apply(tmp161, []any{int64(0)}) - tmp163 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp164 := tmp163.FindInternedVar(lang.NewSymbol("list")) - if tmp164.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp164))) - } - tmp165 := tmp164.Get() - tmp166 := lang.Apply(tmp165, []any{int64(0)}) - tmp167 := lang.Apply(tmp130, []any{tmp134, tmp154, tmp158, tmp162, tmp166}) - tmp168 := lang.Apply(tmp127, []any{tmp167}) - var v169 any = tmp168 - _ = v169 - // let binding "steppair" - tmp170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp171 := tmp170.FindInternedVar(lang.NewSymbol("nnext")) - if tmp171.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp171))) - } - tmp172 := tmp171.Get() - tmp173 := lang.Apply(tmp172, []any{v59}) - tmp174 := lang.Apply(v57, []any{v169, tmp173}) - var v175 any = tmp174 - _ = v175 - // let binding "needrec" - tmp176 := lang.Apply(v175, []any{int64(0)}) - var v177 any = tmp176 - _ = v177 - // let binding "subform" - tmp178 := lang.Apply(v175, []any{int64(1)}) - var v179 any = tmp178 - _ = v179 - // let binding "recform-chunk" - tmp180 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp181 := tmp180.FindInternedVar(lang.NewSymbol("seq")) - if tmp181.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp181))) - } - tmp182 := tmp181.Get() - tmp183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp184 := tmp183.FindInternedVar(lang.NewSymbol("concat")) - if tmp184.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp184))) - } - tmp185 := tmp184.Get() - tmp186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp187 := tmp186.FindInternedVar(lang.NewSymbol("list")) - if tmp187.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp187))) - } - tmp188 := tmp187.Get() - tmp189 := lang.Apply(tmp188, []any{lang.NewSymbol("recur")}) - tmp190 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp191 := tmp190.FindInternedVar(lang.NewSymbol("list")) - if tmp191.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp191))) - } - tmp192 := tmp191.Get() - tmp193 := lang.Apply(tmp192, []any{v102}) - tmp194 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp195 := tmp194.FindInternedVar(lang.NewSymbol("list")) - if tmp195.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp195))) - } - tmp196 := tmp195.Get() - tmp197 := lang.Apply(tmp196, []any{v114}) - tmp198 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp199 := tmp198.FindInternedVar(lang.NewSymbol("list")) - if tmp199.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp199))) - } - tmp200 := tmp199.Get() - tmp201 := lang.Apply(tmp200, []any{v119}) - tmp202 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp203 := tmp202.FindInternedVar(lang.NewSymbol("list")) - if tmp203.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp203))) - } - tmp204 := tmp203.Get() - tmp205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp206 := tmp205.FindInternedVar(lang.NewSymbol("seq")) - if tmp206.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp206))) - } - tmp207 := tmp206.Get() - tmp208 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp209 := tmp208.FindInternedVar(lang.NewSymbol("concat")) - if tmp209.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp209))) - } - tmp210 := tmp209.Get() - tmp211 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp212 := tmp211.FindInternedVar(lang.NewSymbol("list")) - if tmp212.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp212))) - } - tmp213 := tmp212.Get() - tmp214 := lang.Apply(tmp213, []any{lang.NewSymbol("glojure.core/unchecked-inc")}) - tmp215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp216 := tmp215.FindInternedVar(lang.NewSymbol("list")) - if tmp216.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp216))) - } - tmp217 := tmp216.Get() - tmp218 := lang.Apply(tmp217, []any{v124}) - tmp219 := lang.Apply(tmp210, []any{tmp214, tmp218}) - tmp220 := lang.Apply(tmp207, []any{tmp219}) - tmp221 := lang.Apply(tmp204, []any{tmp220}) - tmp222 := lang.Apply(tmp185, []any{tmp189, tmp193, tmp197, tmp201, tmp221}) - tmp223 := lang.Apply(tmp182, []any{tmp222}) - var v224 any = tmp223 - _ = v224 - // let binding "steppair-chunk" - tmp225 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp226 := tmp225.FindInternedVar(lang.NewSymbol("nnext")) - if tmp226.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp226))) - } - tmp227 := tmp226.Get() - tmp228 := lang.Apply(tmp227, []any{v59}) - tmp229 := lang.Apply(v57, []any{v224, tmp228}) - var v230 any = tmp229 - _ = v230 - // let binding "subform-chunk" - tmp231 := lang.Apply(v230, []any{int64(1)}) - var v232 any = tmp231 - _ = v232 - tmp233 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp234 := tmp233.FindInternedVar(lang.NewSymbol("seq")) - if tmp234.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp234))) - } - tmp235 := tmp234.Get() - tmp236 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp237 := tmp236.FindInternedVar(lang.NewSymbol("concat")) - if tmp237.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp237))) - } - tmp238 := tmp237.Get() - tmp239 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp240 := tmp239.FindInternedVar(lang.NewSymbol("list")) - if tmp240.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp240))) - } - tmp241 := tmp240.Get() - tmp242 := lang.Apply(tmp241, []any{lang.NewSymbol("glojure.core/loop")}) - tmp243 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp244 := tmp243.FindInternedVar(lang.NewSymbol("list")) - if tmp244.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp244))) - } - tmp245 := tmp244.Get() - tmp246 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp247 := tmp246.FindInternedVar(lang.NewSymbol("apply")) - if tmp247.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp247))) - } - tmp248 := tmp247.Get() - tmp249 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp250 := tmp249.FindInternedVar(lang.NewSymbol("vector")) - if tmp250.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp250))) - } - tmp251 := tmp250.Get() - tmp252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp253 := tmp252.FindInternedVar(lang.NewSymbol("seq")) - if tmp253.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp253))) - } - tmp254 := tmp253.Get() - tmp255 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp256 := tmp255.FindInternedVar(lang.NewSymbol("concat")) - if tmp256.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp256))) - } - tmp257 := tmp256.Get() - tmp258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp259 := tmp258.FindInternedVar(lang.NewSymbol("list")) - if tmp259.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp259))) - } - tmp260 := tmp259.Get() - tmp261 := lang.Apply(tmp260, []any{v102}) - tmp262 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp263 := tmp262.FindInternedVar(lang.NewSymbol("list")) - if tmp263.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp263))) - } - tmp264 := tmp263.Get() - tmp265 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp266 := tmp265.FindInternedVar(lang.NewSymbol("seq")) - if tmp266.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp266))) - } - tmp267 := tmp266.Get() - tmp268 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp269 := tmp268.FindInternedVar(lang.NewSymbol("concat")) - if tmp269.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp269))) - } - tmp270 := tmp269.Get() - tmp271 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp272 := tmp271.FindInternedVar(lang.NewSymbol("list")) - if tmp272.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp272))) - } - tmp273 := tmp272.Get() - tmp274 := lang.Apply(tmp273, []any{lang.NewSymbol("glojure.core/seq")}) - tmp275 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp276 := tmp275.FindInternedVar(lang.NewSymbol("list")) - if tmp276.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp276))) - } - tmp277 := tmp276.Get() - tmp278 := lang.Apply(tmp277, []any{v90}) - tmp279 := lang.Apply(tmp270, []any{tmp274, tmp278}) - tmp280 := lang.Apply(tmp267, []any{tmp279}) - tmp281 := lang.Apply(tmp264, []any{tmp280}) - tmp282 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp283 := tmp282.FindInternedVar(lang.NewSymbol("list")) - if tmp283.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp283))) - } - tmp284 := tmp283.Get() - tmp285 := lang.Apply(tmp284, []any{v114}) - tmp286 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp287 := tmp286.FindInternedVar(lang.NewSymbol("list")) - if tmp287.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp287))) - } - tmp288 := tmp287.Get() - tmp289 := lang.Apply(tmp288, []any{nil}) - tmp290 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp291 := tmp290.FindInternedVar(lang.NewSymbol("list")) - if tmp291.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp291))) - } - tmp292 := tmp291.Get() - tmp293 := lang.Apply(tmp292, []any{v119}) - tmp294 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp295 := tmp294.FindInternedVar(lang.NewSymbol("list")) - if tmp295.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp295))) - } - tmp296 := tmp295.Get() - tmp297 := lang.Apply(tmp296, []any{int64(0)}) - tmp298 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp299 := tmp298.FindInternedVar(lang.NewSymbol("list")) - if tmp299.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp299))) - } - tmp300 := tmp299.Get() - tmp301 := lang.Apply(tmp300, []any{v124}) - tmp302 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp303 := tmp302.FindInternedVar(lang.NewSymbol("list")) - if tmp303.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp303))) - } - tmp304 := tmp303.Get() - tmp305 := lang.Apply(tmp304, []any{int64(0)}) - tmp306 := lang.Apply(tmp257, []any{tmp261, tmp281, tmp285, tmp289, tmp293, tmp297, tmp301, tmp305}) - tmp307 := lang.Apply(tmp254, []any{tmp306}) - tmp308 := lang.Apply(tmp248, []any{tmp251, tmp307}) - tmp309 := lang.Apply(tmp245, []any{tmp308}) - tmp310 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp311 := tmp310.FindInternedVar(lang.NewSymbol("list")) - if tmp311.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp311))) - } - tmp312 := tmp311.Get() - tmp313 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp314 := tmp313.FindInternedVar(lang.NewSymbol("seq")) - if tmp314.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp314))) - } - tmp315 := tmp314.Get() - tmp316 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp317 := tmp316.FindInternedVar(lang.NewSymbol("concat")) - if tmp317.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp317))) - } - tmp318 := tmp317.Get() - tmp319 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp320 := tmp319.FindInternedVar(lang.NewSymbol("list")) - if tmp320.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp320))) - } - tmp321 := tmp320.Get() - tmp322 := lang.Apply(tmp321, []any{lang.NewSymbol("if")}) - tmp323 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp324 := tmp323.FindInternedVar(lang.NewSymbol("list")) - if tmp324.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp324))) - } - tmp325 := tmp324.Get() - tmp326 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp327 := tmp326.FindInternedVar(lang.NewSymbol("seq")) - if tmp327.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp327))) - } - tmp328 := tmp327.Get() - tmp329 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp330 := tmp329.FindInternedVar(lang.NewSymbol("concat")) - if tmp330.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp330))) - } - tmp331 := tmp330.Get() - tmp332 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp333 := tmp332.FindInternedVar(lang.NewSymbol("list")) - if tmp333.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp333))) - } - tmp334 := tmp333.Get() - tmp335 := lang.Apply(tmp334, []any{lang.NewSymbol("glojure.core/<")}) - tmp336 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp337 := tmp336.FindInternedVar(lang.NewSymbol("list")) - if tmp337.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp337))) - } - tmp338 := tmp337.Get() - tmp339 := lang.Apply(tmp338, []any{v124}) - tmp340 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp341 := tmp340.FindInternedVar(lang.NewSymbol("list")) - if tmp341.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp341))) - } - tmp342 := tmp341.Get() - tmp343 := lang.Apply(tmp342, []any{v119}) - tmp344 := lang.Apply(tmp331, []any{tmp335, tmp339, tmp343}) - tmp345 := lang.Apply(tmp328, []any{tmp344}) - tmp346 := lang.Apply(tmp325, []any{tmp345}) - tmp347 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp348 := tmp347.FindInternedVar(lang.NewSymbol("list")) - if tmp348.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp348))) - } - tmp349 := tmp348.Get() - tmp350 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp351 := tmp350.FindInternedVar(lang.NewSymbol("seq")) - if tmp351.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp351))) - } - tmp352 := tmp351.Get() - tmp353 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp354 := tmp353.FindInternedVar(lang.NewSymbol("concat")) - if tmp354.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp354))) - } - tmp355 := tmp354.Get() - tmp356 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp357 := tmp356.FindInternedVar(lang.NewSymbol("list")) - if tmp357.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp357))) - } - tmp358 := tmp357.Get() - tmp359 := lang.Apply(tmp358, []any{lang.NewSymbol("glojure.core/let")}) - tmp360 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp361 := tmp360.FindInternedVar(lang.NewSymbol("list")) - if tmp361.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp361))) - } - tmp362 := tmp361.Get() - tmp363 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp364 := tmp363.FindInternedVar(lang.NewSymbol("apply")) - if tmp364.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp364))) - } - tmp365 := tmp364.Get() - tmp366 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp367 := tmp366.FindInternedVar(lang.NewSymbol("vector")) - if tmp367.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp367))) - } - tmp368 := tmp367.Get() - tmp369 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp370 := tmp369.FindInternedVar(lang.NewSymbol("seq")) - if tmp370.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp370))) - } - tmp371 := tmp370.Get() - tmp372 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp373 := tmp372.FindInternedVar(lang.NewSymbol("concat")) - if tmp373.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp373))) - } - tmp374 := tmp373.Get() - tmp375 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp376 := tmp375.FindInternedVar(lang.NewSymbol("list")) - if tmp376.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp376))) - } - tmp377 := tmp376.Get() - tmp378 := lang.Apply(tmp377, []any{v85}) - tmp379 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp380 := tmp379.FindInternedVar(lang.NewSymbol("list")) - if tmp380.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp380))) - } - tmp381 := tmp380.Get() - tmp382 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp383 := tmp382.FindInternedVar(lang.NewSymbol("seq")) - if tmp383.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp383))) - } - tmp384 := tmp383.Get() - tmp385 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp386 := tmp385.FindInternedVar(lang.NewSymbol("concat")) - if tmp386.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp386))) - } - tmp387 := tmp386.Get() - tmp388 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp389 := tmp388.FindInternedVar(lang.NewSymbol("list")) - if tmp389.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp389))) - } - tmp390 := tmp389.Get() - tmp391 := lang.Apply(tmp390, []any{lang.NewSymbol(".nth")}) - tmp392 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp393 := tmp392.FindInternedVar(lang.NewSymbol("list")) - if tmp393.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp393))) - } - tmp394 := tmp393.Get() - tmp395 := lang.Apply(tmp394, []any{v114}) - tmp396 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp397 := tmp396.FindInternedVar(lang.NewSymbol("list")) - if tmp397.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp397))) - } - tmp398 := tmp397.Get() - tmp399 := lang.Apply(tmp398, []any{v124}) - tmp400 := lang.Apply(tmp387, []any{tmp391, tmp395, tmp399}) - tmp401 := lang.Apply(tmp384, []any{tmp400}) - tmp402 := lang.Apply(tmp381, []any{tmp401}) - tmp403 := lang.Apply(tmp374, []any{tmp378, tmp402}) - tmp404 := lang.Apply(tmp371, []any{tmp403}) - tmp405 := lang.Apply(tmp365, []any{tmp368, tmp404}) - tmp406 := lang.Apply(tmp362, []any{tmp405}) - tmp407 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp408 := tmp407.FindInternedVar(lang.NewSymbol("list")) - if tmp408.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp408))) - } - tmp409 := tmp408.Get() - tmp410 := lang.Apply(tmp409, []any{v232}) - var tmp411 any - if lang.IsTruthy(v177) { - tmp412 := lang.NewVector(v224) - tmp413 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3256), lang.NewKeyword("column"), int(48), lang.NewKeyword("end-line"), int(3256), lang.NewKeyword("end-column"), int(62)) - tmp414, err := lang.WithMeta(tmp412, tmp413.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp411 = tmp414 - } else { - } - tmp415 := lang.Apply(tmp355, []any{tmp359, tmp406, tmp410, tmp411}) - tmp416 := lang.Apply(tmp352, []any{tmp415}) - tmp417 := lang.Apply(tmp349, []any{tmp416}) - tmp418 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp419 := tmp418.FindInternedVar(lang.NewSymbol("list")) - if tmp419.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp419))) - } - tmp420 := tmp419.Get() - tmp421 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp422 := tmp421.FindInternedVar(lang.NewSymbol("seq")) - if tmp422.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp422))) - } - tmp423 := tmp422.Get() - tmp424 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp425 := tmp424.FindInternedVar(lang.NewSymbol("concat")) - if tmp425.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp425))) - } - tmp426 := tmp425.Get() - tmp427 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp428 := tmp427.FindInternedVar(lang.NewSymbol("list")) - if tmp428.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp428))) - } - tmp429 := tmp428.Get() - tmp430 := lang.Apply(tmp429, []any{lang.NewSymbol("glojure.core/when-let")}) - tmp431 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp432 := tmp431.FindInternedVar(lang.NewSymbol("list")) - if tmp432.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp432))) - } - tmp433 := tmp432.Get() - tmp434 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp435 := tmp434.FindInternedVar(lang.NewSymbol("apply")) - if tmp435.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp435))) - } - tmp436 := tmp435.Get() - tmp437 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp438 := tmp437.FindInternedVar(lang.NewSymbol("vector")) - if tmp438.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp438))) - } - tmp439 := tmp438.Get() - tmp440 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp441 := tmp440.FindInternedVar(lang.NewSymbol("seq")) - if tmp441.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp441))) - } - tmp442 := tmp441.Get() - tmp443 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp444 := tmp443.FindInternedVar(lang.NewSymbol("concat")) - if tmp444.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp444))) - } - tmp445 := tmp444.Get() - tmp446 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp447 := tmp446.FindInternedVar(lang.NewSymbol("list")) - if tmp447.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp447))) - } - tmp448 := tmp447.Get() - tmp449 := lang.Apply(tmp448, []any{v102}) - tmp450 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp451 := tmp450.FindInternedVar(lang.NewSymbol("list")) - if tmp451.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp451))) - } - tmp452 := tmp451.Get() - tmp453 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp454 := tmp453.FindInternedVar(lang.NewSymbol("seq")) - if tmp454.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp454))) - } - tmp455 := tmp454.Get() - tmp456 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp457 := tmp456.FindInternedVar(lang.NewSymbol("concat")) - if tmp457.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp457))) - } - tmp458 := tmp457.Get() - tmp459 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp460 := tmp459.FindInternedVar(lang.NewSymbol("list")) - if tmp460.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp460))) - } - tmp461 := tmp460.Get() - tmp462 := lang.Apply(tmp461, []any{lang.NewSymbol("glojure.core/seq")}) - tmp463 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp464 := tmp463.FindInternedVar(lang.NewSymbol("list")) - if tmp464.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp464))) - } - tmp465 := tmp464.Get() - tmp466 := lang.Apply(tmp465, []any{v102}) - tmp467 := lang.Apply(tmp458, []any{tmp462, tmp466}) - tmp468 := lang.Apply(tmp455, []any{tmp467}) - tmp469 := lang.Apply(tmp452, []any{tmp468}) - tmp470 := lang.Apply(tmp445, []any{tmp449, tmp469}) - tmp471 := lang.Apply(tmp442, []any{tmp470}) - tmp472 := lang.Apply(tmp436, []any{tmp439, tmp471}) - tmp473 := lang.Apply(tmp433, []any{tmp472}) - tmp474 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp475 := tmp474.FindInternedVar(lang.NewSymbol("list")) - if tmp475.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp475))) - } - tmp476 := tmp475.Get() - tmp477 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp478 := tmp477.FindInternedVar(lang.NewSymbol("seq")) - if tmp478.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp478))) - } - tmp479 := tmp478.Get() - tmp480 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp481 := tmp480.FindInternedVar(lang.NewSymbol("concat")) - if tmp481.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp481))) - } - tmp482 := tmp481.Get() - tmp483 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp484 := tmp483.FindInternedVar(lang.NewSymbol("list")) - if tmp484.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp484))) - } - tmp485 := tmp484.Get() - tmp486 := lang.Apply(tmp485, []any{lang.NewSymbol("if")}) - tmp487 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp488 := tmp487.FindInternedVar(lang.NewSymbol("list")) - if tmp488.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp488))) - } - tmp489 := tmp488.Get() - tmp490 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp491 := tmp490.FindInternedVar(lang.NewSymbol("seq")) - if tmp491.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp491))) - } - tmp492 := tmp491.Get() - tmp493 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp494 := tmp493.FindInternedVar(lang.NewSymbol("concat")) - if tmp494.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp494))) - } - tmp495 := tmp494.Get() - tmp496 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp497 := tmp496.FindInternedVar(lang.NewSymbol("list")) - if tmp497.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp497))) - } - tmp498 := tmp497.Get() - tmp499 := lang.Apply(tmp498, []any{lang.NewSymbol("glojure.core/chunked-seq?")}) - tmp500 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp501 := tmp500.FindInternedVar(lang.NewSymbol("list")) - if tmp501.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp501))) - } - tmp502 := tmp501.Get() - tmp503 := lang.Apply(tmp502, []any{v102}) - tmp504 := lang.Apply(tmp495, []any{tmp499, tmp503}) - tmp505 := lang.Apply(tmp492, []any{tmp504}) - tmp506 := lang.Apply(tmp489, []any{tmp505}) - tmp507 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp508 := tmp507.FindInternedVar(lang.NewSymbol("list")) - if tmp508.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp508))) - } - tmp509 := tmp508.Get() - tmp510 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp511 := tmp510.FindInternedVar(lang.NewSymbol("seq")) - if tmp511.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp511))) - } - tmp512 := tmp511.Get() - tmp513 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp514 := tmp513.FindInternedVar(lang.NewSymbol("concat")) - if tmp514.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp514))) - } - tmp515 := tmp514.Get() - tmp516 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp517 := tmp516.FindInternedVar(lang.NewSymbol("list")) - if tmp517.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp517))) - } - tmp518 := tmp517.Get() - tmp519 := lang.Apply(tmp518, []any{lang.NewSymbol("glojure.core/let")}) - tmp520 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp521 := tmp520.FindInternedVar(lang.NewSymbol("list")) - if tmp521.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp521))) - } - tmp522 := tmp521.Get() - tmp523 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp524 := tmp523.FindInternedVar(lang.NewSymbol("apply")) - if tmp524.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp524))) - } - tmp525 := tmp524.Get() - tmp526 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp527 := tmp526.FindInternedVar(lang.NewSymbol("vector")) - if tmp527.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp527))) - } - tmp528 := tmp527.Get() - tmp529 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp530 := tmp529.FindInternedVar(lang.NewSymbol("seq")) - if tmp530.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp530))) - } - tmp531 := tmp530.Get() - tmp532 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp533 := tmp532.FindInternedVar(lang.NewSymbol("concat")) - if tmp533.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp533))) - } - tmp534 := tmp533.Get() - tmp535 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp536 := tmp535.FindInternedVar(lang.NewSymbol("list")) - if tmp536.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp536))) - } - tmp537 := tmp536.Get() - tmp538 := lang.Apply(tmp537, []any{lang.NewSymbol("c__0__auto__")}) - tmp539 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp540 := tmp539.FindInternedVar(lang.NewSymbol("list")) - if tmp540.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp540))) - } - tmp541 := tmp540.Get() - tmp542 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp543 := tmp542.FindInternedVar(lang.NewSymbol("seq")) - if tmp543.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp543))) - } - tmp544 := tmp543.Get() - tmp545 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp546 := tmp545.FindInternedVar(lang.NewSymbol("concat")) - if tmp546.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp546))) - } - tmp547 := tmp546.Get() - tmp548 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp549 := tmp548.FindInternedVar(lang.NewSymbol("list")) - if tmp549.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp549))) - } - tmp550 := tmp549.Get() - tmp551 := lang.Apply(tmp550, []any{lang.NewSymbol("glojure.core/chunk-first")}) - tmp552 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp553 := tmp552.FindInternedVar(lang.NewSymbol("list")) - if tmp553.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp553))) - } - tmp554 := tmp553.Get() - tmp555 := lang.Apply(tmp554, []any{v102}) - tmp556 := lang.Apply(tmp547, []any{tmp551, tmp555}) - tmp557 := lang.Apply(tmp544, []any{tmp556}) - tmp558 := lang.Apply(tmp541, []any{tmp557}) - tmp559 := lang.Apply(tmp534, []any{tmp538, tmp558}) - tmp560 := lang.Apply(tmp531, []any{tmp559}) - tmp561 := lang.Apply(tmp525, []any{tmp528, tmp560}) - tmp562 := lang.Apply(tmp522, []any{tmp561}) - tmp563 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp564 := tmp563.FindInternedVar(lang.NewSymbol("list")) - if tmp564.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp564))) - } - tmp565 := tmp564.Get() - tmp566 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp567 := tmp566.FindInternedVar(lang.NewSymbol("seq")) - if tmp567.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp567))) - } - tmp568 := tmp567.Get() - tmp569 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp570 := tmp569.FindInternedVar(lang.NewSymbol("concat")) - if tmp570.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp570))) - } - tmp571 := tmp570.Get() - tmp572 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp573 := tmp572.FindInternedVar(lang.NewSymbol("list")) - if tmp573.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp573))) - } - tmp574 := tmp573.Get() - tmp575 := lang.Apply(tmp574, []any{lang.NewSymbol("recur")}) - tmp576 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp577 := tmp576.FindInternedVar(lang.NewSymbol("list")) - if tmp577.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp577))) - } - tmp578 := tmp577.Get() - tmp579 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp580 := tmp579.FindInternedVar(lang.NewSymbol("seq")) - if tmp580.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp580))) - } - tmp581 := tmp580.Get() - tmp582 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp583 := tmp582.FindInternedVar(lang.NewSymbol("concat")) - if tmp583.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp583))) - } - tmp584 := tmp583.Get() - tmp585 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp586 := tmp585.FindInternedVar(lang.NewSymbol("list")) - if tmp586.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp586))) - } - tmp587 := tmp586.Get() - tmp588 := lang.Apply(tmp587, []any{lang.NewSymbol("glojure.core/chunk-rest")}) - tmp589 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp590 := tmp589.FindInternedVar(lang.NewSymbol("list")) - if tmp590.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp590))) - } - tmp591 := tmp590.Get() - tmp592 := lang.Apply(tmp591, []any{v102}) - tmp593 := lang.Apply(tmp584, []any{tmp588, tmp592}) - tmp594 := lang.Apply(tmp581, []any{tmp593}) - tmp595 := lang.Apply(tmp578, []any{tmp594}) - tmp596 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp597 := tmp596.FindInternedVar(lang.NewSymbol("list")) - if tmp597.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp597))) - } - tmp598 := tmp597.Get() - tmp599 := lang.Apply(tmp598, []any{lang.NewSymbol("c__0__auto__")}) - tmp600 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp601 := tmp600.FindInternedVar(lang.NewSymbol("list")) - if tmp601.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp601))) - } - tmp602 := tmp601.Get() - tmp603 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp604 := tmp603.FindInternedVar(lang.NewSymbol("seq")) - if tmp604.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp604))) - } - tmp605 := tmp604.Get() - tmp606 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp607 := tmp606.FindInternedVar(lang.NewSymbol("concat")) - if tmp607.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp607))) - } - tmp608 := tmp607.Get() - tmp609 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp610 := tmp609.FindInternedVar(lang.NewSymbol("list")) - if tmp610.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp610))) - } - tmp611 := tmp610.Get() - tmp612 := lang.Apply(tmp611, []any{lang.NewSymbol("glojure.core/int")}) - tmp613 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp614 := tmp613.FindInternedVar(lang.NewSymbol("list")) - if tmp614.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp614))) - } - tmp615 := tmp614.Get() - tmp616 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp617 := tmp616.FindInternedVar(lang.NewSymbol("seq")) - if tmp617.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp617))) - } - tmp618 := tmp617.Get() - tmp619 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp620 := tmp619.FindInternedVar(lang.NewSymbol("concat")) - if tmp620.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp620))) - } - tmp621 := tmp620.Get() - tmp622 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp623 := tmp622.FindInternedVar(lang.NewSymbol("list")) - if tmp623.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp623))) - } - tmp624 := tmp623.Get() - tmp625 := lang.Apply(tmp624, []any{lang.NewSymbol("glojure.core/count")}) - tmp626 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp627 := tmp626.FindInternedVar(lang.NewSymbol("list")) - if tmp627.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp627))) - } - tmp628 := tmp627.Get() - tmp629 := lang.Apply(tmp628, []any{lang.NewSymbol("c__0__auto__")}) - tmp630 := lang.Apply(tmp621, []any{tmp625, tmp629}) - tmp631 := lang.Apply(tmp618, []any{tmp630}) - tmp632 := lang.Apply(tmp615, []any{tmp631}) - tmp633 := lang.Apply(tmp608, []any{tmp612, tmp632}) - tmp634 := lang.Apply(tmp605, []any{tmp633}) - tmp635 := lang.Apply(tmp602, []any{tmp634}) - tmp636 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp637 := tmp636.FindInternedVar(lang.NewSymbol("list")) - if tmp637.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp637))) - } - tmp638 := tmp637.Get() - tmp639 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp640 := tmp639.FindInternedVar(lang.NewSymbol("seq")) - if tmp640.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp640))) - } - tmp641 := tmp640.Get() - tmp642 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp643 := tmp642.FindInternedVar(lang.NewSymbol("concat")) - if tmp643.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp643))) - } - tmp644 := tmp643.Get() - tmp645 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp646 := tmp645.FindInternedVar(lang.NewSymbol("list")) - if tmp646.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp646))) - } - tmp647 := tmp646.Get() - tmp648 := lang.Apply(tmp647, []any{lang.NewSymbol("glojure.core/int")}) - tmp649 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp650 := tmp649.FindInternedVar(lang.NewSymbol("list")) - if tmp650.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp650))) - } - tmp651 := tmp650.Get() - tmp652 := lang.Apply(tmp651, []any{int64(0)}) - tmp653 := lang.Apply(tmp644, []any{tmp648, tmp652}) - tmp654 := lang.Apply(tmp641, []any{tmp653}) - tmp655 := lang.Apply(tmp638, []any{tmp654}) - tmp656 := lang.Apply(tmp571, []any{tmp575, tmp595, tmp599, tmp635, tmp655}) - tmp657 := lang.Apply(tmp568, []any{tmp656}) - tmp658 := lang.Apply(tmp565, []any{tmp657}) - tmp659 := lang.Apply(tmp515, []any{tmp519, tmp562, tmp658}) - tmp660 := lang.Apply(tmp512, []any{tmp659}) - tmp661 := lang.Apply(tmp509, []any{tmp660}) - tmp662 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp663 := tmp662.FindInternedVar(lang.NewSymbol("list")) - if tmp663.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp663))) - } - tmp664 := tmp663.Get() - tmp665 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp666 := tmp665.FindInternedVar(lang.NewSymbol("seq")) - if tmp666.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp666))) - } - tmp667 := tmp666.Get() - tmp668 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp669 := tmp668.FindInternedVar(lang.NewSymbol("concat")) - if tmp669.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp669))) - } - tmp670 := tmp669.Get() - tmp671 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp672 := tmp671.FindInternedVar(lang.NewSymbol("list")) - if tmp672.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp672))) - } - tmp673 := tmp672.Get() - tmp674 := lang.Apply(tmp673, []any{lang.NewSymbol("glojure.core/let")}) - tmp675 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp676 := tmp675.FindInternedVar(lang.NewSymbol("list")) - if tmp676.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp676))) - } - tmp677 := tmp676.Get() - tmp678 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp679 := tmp678.FindInternedVar(lang.NewSymbol("apply")) - if tmp679.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp679))) - } - tmp680 := tmp679.Get() - tmp681 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp682 := tmp681.FindInternedVar(lang.NewSymbol("vector")) - if tmp682.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp682))) - } - tmp683 := tmp682.Get() - tmp684 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp685 := tmp684.FindInternedVar(lang.NewSymbol("seq")) - if tmp685.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp685))) - } - tmp686 := tmp685.Get() - tmp687 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp688 := tmp687.FindInternedVar(lang.NewSymbol("concat")) - if tmp688.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp688))) - } - tmp689 := tmp688.Get() - tmp690 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp691 := tmp690.FindInternedVar(lang.NewSymbol("list")) - if tmp691.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp691))) - } - tmp692 := tmp691.Get() - tmp693 := lang.Apply(tmp692, []any{v85}) - tmp694 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp695 := tmp694.FindInternedVar(lang.NewSymbol("list")) - if tmp695.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp695))) - } - tmp696 := tmp695.Get() - tmp697 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp698 := tmp697.FindInternedVar(lang.NewSymbol("seq")) - if tmp698.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp698))) - } - tmp699 := tmp698.Get() - tmp700 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp701 := tmp700.FindInternedVar(lang.NewSymbol("concat")) - if tmp701.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp701))) - } - tmp702 := tmp701.Get() - tmp703 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp704 := tmp703.FindInternedVar(lang.NewSymbol("list")) - if tmp704.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp704))) - } - tmp705 := tmp704.Get() - tmp706 := lang.Apply(tmp705, []any{lang.NewSymbol("glojure.core/first")}) - tmp707 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp708 := tmp707.FindInternedVar(lang.NewSymbol("list")) - if tmp708.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp708))) - } - tmp709 := tmp708.Get() - tmp710 := lang.Apply(tmp709, []any{v102}) - tmp711 := lang.Apply(tmp702, []any{tmp706, tmp710}) - tmp712 := lang.Apply(tmp699, []any{tmp711}) - tmp713 := lang.Apply(tmp696, []any{tmp712}) - tmp714 := lang.Apply(tmp689, []any{tmp693, tmp713}) - tmp715 := lang.Apply(tmp686, []any{tmp714}) - tmp716 := lang.Apply(tmp680, []any{tmp683, tmp715}) - tmp717 := lang.Apply(tmp677, []any{tmp716}) - tmp718 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp719 := tmp718.FindInternedVar(lang.NewSymbol("list")) - if tmp719.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp719))) - } - tmp720 := tmp719.Get() - tmp721 := lang.Apply(tmp720, []any{v179}) - var tmp722 any - if lang.IsTruthy(v177) { - tmp723 := lang.NewVector(v169) - tmp724 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3264), lang.NewKeyword("column"), int(52), lang.NewKeyword("end-line"), int(3264), lang.NewKeyword("end-column"), int(60)) - tmp725, err := lang.WithMeta(tmp723, tmp724.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp722 = tmp725 - } else { - } - tmp726 := lang.Apply(tmp670, []any{tmp674, tmp717, tmp721, tmp722}) - tmp727 := lang.Apply(tmp667, []any{tmp726}) - tmp728 := lang.Apply(tmp664, []any{tmp727}) - tmp729 := lang.Apply(tmp482, []any{tmp486, tmp506, tmp661, tmp728}) - tmp730 := lang.Apply(tmp479, []any{tmp729}) - tmp731 := lang.Apply(tmp476, []any{tmp730}) - tmp732 := lang.Apply(tmp426, []any{tmp430, tmp473, tmp731}) - tmp733 := lang.Apply(tmp423, []any{tmp732}) - tmp734 := lang.Apply(tmp420, []any{tmp733}) - tmp735 := lang.Apply(tmp318, []any{tmp322, tmp346, tmp417, tmp734}) - tmp736 := lang.Apply(tmp315, []any{tmp735}) - tmp737 := lang.Apply(tmp312, []any{tmp736}) - tmp738 := lang.Apply(tmp238, []any{tmp242, tmp309, tmp737}) - tmp739 := lang.Apply(tmp235, []any{tmp738}) - tmp740 := lang.NewVector(true, tmp739) - tmp741 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3250), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(3264), lang.NewKeyword("end-column"), int(67)) - tmp742, err := lang.WithMeta(tmp740, tmp741.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp97 = tmp742 - } // end let - tmp91 = tmp97 - } - tmp80 = tmp91 - } // end let - tmp60 = tmp80 - } - return tmp60 - }) - v57 = tmp56 - _ = v57 - } - tmp57 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3218), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(3264), lang.NewKeyword("end-column"), int(72)) - tmp58, err := lang.WithMeta(tmp56, tmp57.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v59 any = tmp58 - _ = v59 - tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp61 := tmp60.FindInternedVar(lang.NewSymbol("nth")) - if tmp61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) - } - tmp62 := tmp61.Get() - tmp63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp64 := tmp63.FindInternedVar(lang.NewSymbol("seq")) - if tmp64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp64))) - } - tmp65 := tmp64.Get() - tmp66 := lang.Apply(tmp65, []any{v5}) - tmp67 := lang.Apply(v59, []any{nil, tmp66}) - tmp68 := lang.Apply(tmp62, []any{tmp67, int64(1)}) - tmp55 = tmp68 - } // end let - return tmp55 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // dosync - { - tmp0 := lang.NewSymbol("dosync").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("exprs"))), lang.NewKeyword("doc"), "Runs the exprs (in an implicit do) in a transaction that encompasses\n exprs and any nested calls. Starts a transaction if none is already\n running on this thread. Any uncaught exception will abort the\n transaction and flow out of dosync. The exprs may be run more than\n once, but any effects on Refs will be atomic.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5100), lang.NewKeyword("end-line"), int(5100))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("seq")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("concat")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("list")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("glojure.core/sync")}) - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("list")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{nil}) - tmp20 := lang.Apply(tmp11, []any{tmp15, tmp19, v5}) - tmp21 := lang.Apply(tmp8, []any{tmp20}) - return tmp21 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // dotimes - { - tmp0 := lang.NewSymbol("dotimes").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "bindings => name n\n\n Repeatedly executes body (presumably for side-effects) with name\n bound to integers from 0 through n-1.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3306), lang.NewKeyword("end-line"), int(3306))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("vector?")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v5}) - if lang.IsTruthy(tmp11) { - } else { - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("str")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("first")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{v3}) - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("*ns*")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("meta")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.Apply(tmp24, []any{v3}) - tmp26 := lang.Apply(lang.NewKeyword("line"), []any{tmp25}) - tmp27 := lang.Apply(tmp14, []any{tmp18, " requires ", "a vector for its binding", " in ", tmp21, ":", tmp26}) - tmp28 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp27}) - panic(tmp28) - } - _ = tmp7 - var tmp29 any - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("=")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("count")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.Apply(tmp35, []any{v5}) - tmp37 := lang.Apply(tmp32, []any{int64(2), tmp36}) - if lang.IsTruthy(tmp37) { - } else { - tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp39 := tmp38.FindInternedVar(lang.NewSymbol("str")) - if tmp39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) - } - tmp40 := tmp39.Get() - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("first")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.Apply(tmp43, []any{v3}) - tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp46 := tmp45.FindInternedVar(lang.NewSymbol("*ns*")) - if tmp46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) - } - tmp47 := tmp46.Get() - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("meta")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v3}) - tmp52 := lang.Apply(lang.NewKeyword("line"), []any{tmp51}) - tmp53 := lang.Apply(tmp40, []any{tmp44, " requires ", "exactly 2 forms in binding vector", " in ", tmp47, ":", tmp52}) - tmp54 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp53}) - panic(tmp54) - } - _ = tmp29 - var tmp55 any - { // let - // let binding "i" - tmp56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp57 := tmp56.FindInternedVar(lang.NewSymbol("first")) - if tmp57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp57))) - } - tmp58 := tmp57.Get() - tmp59 := lang.Apply(tmp58, []any{v5}) - var v60 any = tmp59 - _ = v60 - // let binding "n" - tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp62 := tmp61.FindInternedVar(lang.NewSymbol("second")) - if tmp62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) - } - tmp63 := tmp62.Get() - tmp64 := lang.Apply(tmp63, []any{v5}) - var v65 any = tmp64 - _ = v65 - tmp66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp67 := tmp66.FindInternedVar(lang.NewSymbol("seq")) - if tmp67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp67))) - } - tmp68 := tmp67.Get() - tmp69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp70 := tmp69.FindInternedVar(lang.NewSymbol("concat")) - if tmp70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp70))) - } - tmp71 := tmp70.Get() - tmp72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp73 := tmp72.FindInternedVar(lang.NewSymbol("list")) - if tmp73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp73))) - } - tmp74 := tmp73.Get() - tmp75 := lang.Apply(tmp74, []any{lang.NewSymbol("glojure.core/let")}) - tmp76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp77 := tmp76.FindInternedVar(lang.NewSymbol("list")) - if tmp77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp77))) - } - tmp78 := tmp77.Get() - tmp79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp80 := tmp79.FindInternedVar(lang.NewSymbol("apply")) - if tmp80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp80))) - } - tmp81 := tmp80.Get() - tmp82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp83 := tmp82.FindInternedVar(lang.NewSymbol("vector")) - if tmp83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp83))) - } - tmp84 := tmp83.Get() - tmp85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp86 := tmp85.FindInternedVar(lang.NewSymbol("seq")) - if tmp86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp86))) - } - tmp87 := tmp86.Get() - tmp88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp89 := tmp88.FindInternedVar(lang.NewSymbol("concat")) - if tmp89.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp89))) - } - tmp90 := tmp89.Get() - tmp91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp92 := tmp91.FindInternedVar(lang.NewSymbol("list")) - if tmp92.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp92))) - } - tmp93 := tmp92.Get() - tmp94 := lang.Apply(tmp93, []any{lang.NewSymbol("n__0__auto__")}) - tmp95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp96 := tmp95.FindInternedVar(lang.NewSymbol("list")) - if tmp96.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp96))) - } - tmp97 := tmp96.Get() - tmp98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp99 := tmp98.FindInternedVar(lang.NewSymbol("seq")) - if tmp99.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp99))) - } - tmp100 := tmp99.Get() - tmp101 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp102 := tmp101.FindInternedVar(lang.NewSymbol("concat")) - if tmp102.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp102))) - } - tmp103 := tmp102.Get() - tmp104 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp105 := tmp104.FindInternedVar(lang.NewSymbol("list")) - if tmp105.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp105))) - } - tmp106 := tmp105.Get() - tmp107 := lang.Apply(tmp106, []any{lang.NewSymbol("glojure.core/long")}) - tmp108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp109 := tmp108.FindInternedVar(lang.NewSymbol("list")) - if tmp109.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp109))) - } - tmp110 := tmp109.Get() - tmp111 := lang.Apply(tmp110, []any{v65}) - tmp112 := lang.Apply(tmp103, []any{tmp107, tmp111}) - tmp113 := lang.Apply(tmp100, []any{tmp112}) - tmp114 := lang.Apply(tmp97, []any{tmp113}) - tmp115 := lang.Apply(tmp90, []any{tmp94, tmp114}) - tmp116 := lang.Apply(tmp87, []any{tmp115}) - tmp117 := lang.Apply(tmp81, []any{tmp84, tmp116}) - tmp118 := lang.Apply(tmp78, []any{tmp117}) - tmp119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp120 := tmp119.FindInternedVar(lang.NewSymbol("list")) - if tmp120.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp120))) - } - tmp121 := tmp120.Get() - tmp122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp123 := tmp122.FindInternedVar(lang.NewSymbol("seq")) - if tmp123.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp123))) - } - tmp124 := tmp123.Get() - tmp125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp126 := tmp125.FindInternedVar(lang.NewSymbol("concat")) - if tmp126.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp126))) - } - tmp127 := tmp126.Get() - tmp128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp129 := tmp128.FindInternedVar(lang.NewSymbol("list")) - if tmp129.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp129))) - } - tmp130 := tmp129.Get() - tmp131 := lang.Apply(tmp130, []any{lang.NewSymbol("glojure.core/loop")}) - tmp132 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp133 := tmp132.FindInternedVar(lang.NewSymbol("list")) - if tmp133.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp133))) - } - tmp134 := tmp133.Get() - tmp135 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp136 := tmp135.FindInternedVar(lang.NewSymbol("apply")) - if tmp136.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp136))) - } - tmp137 := tmp136.Get() - tmp138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp139 := tmp138.FindInternedVar(lang.NewSymbol("vector")) - if tmp139.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp139))) - } - tmp140 := tmp139.Get() - tmp141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp142 := tmp141.FindInternedVar(lang.NewSymbol("seq")) - if tmp142.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp142))) - } - tmp143 := tmp142.Get() - tmp144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp145 := tmp144.FindInternedVar(lang.NewSymbol("concat")) - if tmp145.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp145))) - } - tmp146 := tmp145.Get() - tmp147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp148 := tmp147.FindInternedVar(lang.NewSymbol("list")) - if tmp148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp148))) - } - tmp149 := tmp148.Get() - tmp150 := lang.Apply(tmp149, []any{v60}) - tmp151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp152 := tmp151.FindInternedVar(lang.NewSymbol("list")) - if tmp152.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp152))) - } - tmp153 := tmp152.Get() - tmp154 := lang.Apply(tmp153, []any{int64(0)}) - tmp155 := lang.Apply(tmp146, []any{tmp150, tmp154}) - tmp156 := lang.Apply(tmp143, []any{tmp155}) - tmp157 := lang.Apply(tmp137, []any{tmp140, tmp156}) - tmp158 := lang.Apply(tmp134, []any{tmp157}) - tmp159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp160 := tmp159.FindInternedVar(lang.NewSymbol("list")) - if tmp160.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp160))) - } - tmp161 := tmp160.Get() - tmp162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp163 := tmp162.FindInternedVar(lang.NewSymbol("seq")) - if tmp163.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp163))) - } - tmp164 := tmp163.Get() - tmp165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp166 := tmp165.FindInternedVar(lang.NewSymbol("concat")) - if tmp166.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp166))) - } - tmp167 := tmp166.Get() - tmp168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp169 := tmp168.FindInternedVar(lang.NewSymbol("list")) - if tmp169.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp169))) - } - tmp170 := tmp169.Get() - tmp171 := lang.Apply(tmp170, []any{lang.NewSymbol("glojure.core/when")}) - tmp172 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp173 := tmp172.FindInternedVar(lang.NewSymbol("list")) - if tmp173.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp173))) - } - tmp174 := tmp173.Get() - tmp175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp176 := tmp175.FindInternedVar(lang.NewSymbol("seq")) - if tmp176.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp176))) - } - tmp177 := tmp176.Get() - tmp178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp179 := tmp178.FindInternedVar(lang.NewSymbol("concat")) - if tmp179.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp179))) - } - tmp180 := tmp179.Get() - tmp181 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp182 := tmp181.FindInternedVar(lang.NewSymbol("list")) - if tmp182.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp182))) - } - tmp183 := tmp182.Get() - tmp184 := lang.Apply(tmp183, []any{lang.NewSymbol("glojure.core/<")}) - tmp185 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp186 := tmp185.FindInternedVar(lang.NewSymbol("list")) - if tmp186.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp186))) - } - tmp187 := tmp186.Get() - tmp188 := lang.Apply(tmp187, []any{v60}) - tmp189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp190 := tmp189.FindInternedVar(lang.NewSymbol("list")) - if tmp190.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp190))) - } - tmp191 := tmp190.Get() - tmp192 := lang.Apply(tmp191, []any{lang.NewSymbol("n__0__auto__")}) - tmp193 := lang.Apply(tmp180, []any{tmp184, tmp188, tmp192}) - tmp194 := lang.Apply(tmp177, []any{tmp193}) - tmp195 := lang.Apply(tmp174, []any{tmp194}) - tmp196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp197 := tmp196.FindInternedVar(lang.NewSymbol("list")) - if tmp197.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp197))) - } - tmp198 := tmp197.Get() - tmp199 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp200 := tmp199.FindInternedVar(lang.NewSymbol("seq")) - if tmp200.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp200))) - } - tmp201 := tmp200.Get() - tmp202 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp203 := tmp202.FindInternedVar(lang.NewSymbol("concat")) - if tmp203.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp203))) - } - tmp204 := tmp203.Get() - tmp205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp206 := tmp205.FindInternedVar(lang.NewSymbol("list")) - if tmp206.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp206))) - } - tmp207 := tmp206.Get() - tmp208 := lang.Apply(tmp207, []any{lang.NewSymbol("recur")}) - tmp209 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp210 := tmp209.FindInternedVar(lang.NewSymbol("list")) - if tmp210.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp210))) - } - tmp211 := tmp210.Get() - tmp212 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp213 := tmp212.FindInternedVar(lang.NewSymbol("seq")) - if tmp213.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp213))) - } - tmp214 := tmp213.Get() - tmp215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp216 := tmp215.FindInternedVar(lang.NewSymbol("concat")) - if tmp216.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp216))) - } - tmp217 := tmp216.Get() - tmp218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp219 := tmp218.FindInternedVar(lang.NewSymbol("list")) - if tmp219.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp219))) - } - tmp220 := tmp219.Get() - tmp221 := lang.Apply(tmp220, []any{lang.NewSymbol("glojure.core/unchecked-inc")}) - tmp222 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp223 := tmp222.FindInternedVar(lang.NewSymbol("list")) - if tmp223.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp223))) - } - tmp224 := tmp223.Get() - tmp225 := lang.Apply(tmp224, []any{v60}) - tmp226 := lang.Apply(tmp217, []any{tmp221, tmp225}) - tmp227 := lang.Apply(tmp214, []any{tmp226}) - tmp228 := lang.Apply(tmp211, []any{tmp227}) - tmp229 := lang.Apply(tmp204, []any{tmp208, tmp228}) - tmp230 := lang.Apply(tmp201, []any{tmp229}) - tmp231 := lang.Apply(tmp198, []any{tmp230}) - tmp232 := lang.Apply(tmp167, []any{tmp171, tmp195, v6, tmp231}) - tmp233 := lang.Apply(tmp164, []any{tmp232}) - tmp234 := lang.Apply(tmp161, []any{tmp233}) - tmp235 := lang.Apply(tmp127, []any{tmp131, tmp158, tmp234}) - tmp236 := lang.Apply(tmp124, []any{tmp235}) - tmp237 := lang.Apply(tmp121, []any{tmp236}) - tmp238 := lang.Apply(tmp71, []any{tmp75, tmp118, tmp237}) - tmp239 := lang.Apply(tmp68, []any{tmp238}) - tmp55 = tmp239 - } // end let - return tmp55 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // doto - { - tmp0 := lang.NewSymbol("doto").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "Evaluates x then calls all of the methods and functions with the\n value of x supplied at the front of the given arguments. The forms\n are evaluated in order. Returns x.\n\n (doto (new java.util.HashMap) (.put \"a\" 1) (.put \"b\" 2))", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3853), lang.NewKeyword("end-line"), int(3853))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any - { // let - // let binding "gx" - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("gensym")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, nil) - var v12 any = tmp11 - _ = v12 - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("seq")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("concat")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("glojure.core/let")}) - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("apply")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("vector")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("seq")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp36 := tmp35.FindInternedVar(lang.NewSymbol("concat")) - if tmp36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) - } - tmp37 := tmp36.Get() - tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp39 := tmp38.FindInternedVar(lang.NewSymbol("list")) - if tmp39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) - } - tmp40 := tmp39.Get() - tmp41 := lang.Apply(tmp40, []any{v12}) - tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp43 := tmp42.FindInternedVar(lang.NewSymbol("list")) - if tmp43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) - } - tmp44 := tmp43.Get() - tmp45 := lang.Apply(tmp44, []any{v5}) - tmp46 := lang.Apply(tmp37, []any{tmp41, tmp45}) - tmp47 := lang.Apply(tmp34, []any{tmp46}) - tmp48 := lang.Apply(tmp28, []any{tmp31, tmp47}) - tmp49 := lang.Apply(tmp25, []any{tmp48}) - tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp51 := tmp50.FindInternedVar(lang.NewSymbol("map")) - if tmp51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) - } - tmp52 := tmp51.Get() - var tmp53 lang.FnFunc - tmp53 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v54 := args[0] - _ = v54 - tmp55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp56 := tmp55.FindInternedVar(lang.NewSymbol("with-meta")) - if tmp56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp56))) - } - tmp57 := tmp56.Get() - var tmp58 any - tmp59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp60 := tmp59.FindInternedVar(lang.NewSymbol("seq?")) - if tmp60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp60))) - } - tmp61 := tmp60.Get() - tmp62 := lang.Apply(tmp61, []any{v54}) - if lang.IsTruthy(tmp62) { - tmp63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp64 := tmp63.FindInternedVar(lang.NewSymbol("seq")) - if tmp64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp64))) - } - tmp65 := tmp64.Get() - tmp66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp67 := tmp66.FindInternedVar(lang.NewSymbol("concat")) - if tmp67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp67))) - } - tmp68 := tmp67.Get() - tmp69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp70 := tmp69.FindInternedVar(lang.NewSymbol("list")) - if tmp70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp70))) - } - tmp71 := tmp70.Get() - tmp72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp73 := tmp72.FindInternedVar(lang.NewSymbol("first")) - if tmp73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp73))) - } - tmp74 := tmp73.Get() - tmp75 := lang.Apply(tmp74, []any{v54}) - tmp76 := lang.Apply(tmp71, []any{tmp75}) - tmp77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp78 := tmp77.FindInternedVar(lang.NewSymbol("list")) - if tmp78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp78))) - } - tmp79 := tmp78.Get() - tmp80 := lang.Apply(tmp79, []any{v12}) - tmp81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp82 := tmp81.FindInternedVar(lang.NewSymbol("next")) - if tmp82.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp82))) - } - tmp83 := tmp82.Get() - tmp84 := lang.Apply(tmp83, []any{v54}) - tmp85 := lang.Apply(tmp68, []any{tmp76, tmp80, tmp84}) - tmp86 := lang.Apply(tmp65, []any{tmp85}) - tmp58 = tmp86 - } else { - tmp87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp88 := tmp87.FindInternedVar(lang.NewSymbol("seq")) - if tmp88.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp88))) - } - tmp89 := tmp88.Get() - tmp90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp91 := tmp90.FindInternedVar(lang.NewSymbol("concat")) - if tmp91.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp91))) - } - tmp92 := tmp91.Get() - tmp93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp94 := tmp93.FindInternedVar(lang.NewSymbol("list")) - if tmp94.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp94))) - } - tmp95 := tmp94.Get() - tmp96 := lang.Apply(tmp95, []any{v54}) - tmp97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp98 := tmp97.FindInternedVar(lang.NewSymbol("list")) - if tmp98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp98))) - } - tmp99 := tmp98.Get() - tmp100 := lang.Apply(tmp99, []any{v12}) - tmp101 := lang.Apply(tmp92, []any{tmp96, tmp100}) - tmp102 := lang.Apply(tmp89, []any{tmp101}) - tmp58 = tmp102 - } - tmp103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp104 := tmp103.FindInternedVar(lang.NewSymbol("meta")) - if tmp104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp104))) - } - tmp105 := tmp104.Get() - tmp106 := lang.Apply(tmp105, []any{v54}) - tmp107 := lang.Apply(tmp57, []any{tmp58, tmp106}) - return tmp107 - }) - tmp54 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3863), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(3868), lang.NewKeyword("end-column"), int(30)) - tmp55, err := lang.WithMeta(tmp53, tmp54.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp56 := lang.Apply(tmp52, []any{tmp55, v6}) - tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp58 := tmp57.FindInternedVar(lang.NewSymbol("list")) - if tmp58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) - } - tmp59 := tmp58.Get() - tmp60 := lang.Apply(tmp59, []any{v12}) - tmp61 := lang.Apply(tmp18, []any{tmp22, tmp49, tmp56, tmp60}) - tmp62 := lang.Apply(tmp15, []any{tmp61}) - tmp7 = tmp62 - } // end let - return tmp7 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // double - { - var tmp1 lang.FnFunc - { // function double__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/DoubleCast")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{v3}) - tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) - tmp36 := lang.Apply(tmp23, []any{tmp35}) - tmp37 := lang.Apply(tmp20, []any{tmp36}) - tmp38 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp37}) - tmp39 := lang.Apply(tmp6, []any{tmp38}) - return tmp39 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("double").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to double", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3493), lang.NewKeyword("end-line"), int(3493))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5 := lang.Apply(lang.AsFloat64, []any{v4}) - return tmp5 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // double-array - { - var tmp1 lang.FnFunc - { // function double-array__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var v3 any = lang.NewList(args[0:]...) - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.Apply(tmp20, []any{lang.NewSymbol("glojure.core/DoubleArray")}) - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("list")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("seq")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("concat")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) - tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp36 := tmp35.FindInternedVar(lang.NewSymbol("list")) - if tmp36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) - } - tmp37 := tmp36.Get() - tmp38 := lang.Apply(tmp37, []any{lang.NewSymbol("glojure.core/args")}) - tmp39 := lang.Apply(tmp30, []any{tmp34, tmp38}) - tmp40 := lang.Apply(tmp27, []any{tmp39}) - tmp41 := lang.Apply(tmp24, []any{tmp40}) - tmp42 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp21, tmp41}) - tmp43 := lang.Apply(tmp6, []any{tmp42}) - return tmp43 - } - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("double-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Creates an array of doubles", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5341), lang.NewKeyword("end-line"), int(5341))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "DoubleArray") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("DoubleArray is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - case 2: - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "DoubleArrayInit") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("DoubleArrayInit is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // double? - { - tmp0 := lang.NewSymbol("double?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a Double", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1421), lang.NewKeyword("end-line"), int(1421))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.Apply(tmp6, []any{lang.Builtins["float64"], v3}) - return tmp7 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // doubles - { - var tmp1 lang.FnFunc - { // function doubles - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.Apply(tmp20, []any{lang.NewSymbol("glojure.core/Doubles")}) - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("list")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.Apply(tmp24, []any{v3}) - tmp26 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp21, tmp25}) - tmp27 := lang.Apply(tmp6, []any{tmp26}) - return tmp27 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("doubles").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Casts to double[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5402), lang.NewKeyword("end-line"), int(5402))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Doubles") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Doubles is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // drop - { - tmp0 := lang.NewSymbol("drop").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a laziness-preserving sequence of all but the first n items in coll.\n Returns a stateful transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2901), lang.NewKeyword("end-line"), int(2901))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v5 := args[0] - _ = v5 - var tmp6 any - { // let - // let binding "nv" - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("volatile!")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp9, []any{v3}) - var v11 any = tmp10 - _ = v11 - var tmp12 lang.FnFunc - tmp12 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp13 := lang.Apply(v5, nil) - return tmp13 - case 1: - v13 := args[0] - _ = v13 - tmp14 := lang.Apply(v5, []any{v13}) - return tmp14 - case 2: - v13 := args[0] - _ = v13 - v14 := args[1] - _ = v14 - var tmp15 any - { // let - // let binding "n" - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("deref")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{v11}) - var v20 any = tmp19 - _ = v20 - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("dec")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24, ok := lang.FieldOrMethod(v11, "Deref") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v11, "Deref"))) - } - var tmp25 any - switch reflect.TypeOf(tmp24).Kind() { - case reflect.Func: - tmp25 = lang.Apply(tmp24, nil) - default: - tmp25 = tmp24 - } - tmp26 := lang.Apply(tmp23, []any{tmp25}) - tmp27, _ := lang.FieldOrMethod(v11, "reset") - if reflect.TypeOf(tmp27).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) - } - tmp28 := lang.Apply(tmp27, []any{tmp26}) - _ = tmp28 - var tmp29 any - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("pos?")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.Apply(tmp32, []any{v20}) - if lang.IsTruthy(tmp33) { - tmp29 = v13 - } else { - tmp34 := lang.Apply(v5, []any{v13, v14}) - tmp29 = tmp34 - } - tmp15 = tmp29 - } // end let - return tmp15 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2909), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(2917), lang.NewKeyword("end-column"), int(39)) - tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp6 = tmp14 - } // end let - return tmp6 - }) - tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2907), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2917), lang.NewKeyword("end-column"), int(41)) - tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp6 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("instance?")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := reflect.TypeOf((*lang.IDrop)(nil)).Elem() - tmp10 := lang.Apply(tmp8, []any{tmp9, v4}) - if lang.IsTruthy(tmp10) { - var tmp11 any - { // let - // let binding "or__0__auto__" - var tmp12 any - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("pos?")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{v3}) - if lang.IsTruthy(tmp16) { - var tmp17 any - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("int?")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.Apply(tmp20, []any{v3}) - if lang.IsTruthy(tmp21) { - tmp17 = v3 - } else { - tmp22 := lang.Apply(nil, []any{v3}) - tmp17 = tmp22 - } - tmp23, _ := lang.FieldOrMethod(v4, "drop") - if reflect.TypeOf(tmp23).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("drop is not a function"))) - } - tmp24 := lang.Apply(tmp23, []any{tmp17}) - tmp12 = tmp24 - } else { - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("seq")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.Apply(tmp27, []any{v4}) - tmp12 = tmp28 - } - var v29 any = tmp12 - _ = v29 - var tmp30 any - if lang.IsTruthy(v29) { - tmp30 = v29 - } else { - tmp30 = lang.NewList() - } - tmp11 = tmp30 - } // end let - tmp5 = tmp11 - } else { - var tmp12 any - { // let - // let binding "step" - var tmp13 lang.FnFunc - tmp13 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v14 := args[0] - _ = v14 - v15 := args[1] - _ = v15 - recur_loop_539: - var tmp16 any - { // let - // let binding "s" - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.Apply(tmp19, []any{v15}) - var v21 any = tmp20 - _ = v21 - var tmp22 any - var tmp23 any - { // let - // let binding "and__0__auto__" - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("pos?")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.Apply(tmp26, []any{v14}) - var v28 any = tmp27 - _ = v28 - var tmp29 any - if lang.IsTruthy(v28) { - tmp29 = v21 - } else { - tmp29 = v28 - } - tmp23 = tmp29 - } // end let - if lang.IsTruthy(tmp23) { - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("dec")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.Apply(tmp27, []any{v14}) - var tmp24 any = tmp28 - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("rest")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.Apply(tmp32, []any{v21}) - var tmp29 any = tmp33 - v14 = tmp24 - v15 = tmp29 - goto recur_loop_539 - } else { - tmp22 = v21 - } - tmp16 = tmp22 - } // end let - return tmp16 - }) - tmp14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2925), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(2929), lang.NewKeyword("end-column"), int(28)) - tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v16 any = tmp15 - _ = v16 - var tmp17 lang.FnFunc - tmp17 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - tmp18 := lang.Apply(v16, []any{v3, v4}) - return tmp18 - }) - tmp18 := lang.Apply(lang.NewLazySeq, []any{tmp17}) - tmp12 = tmp18 - } // end let - tmp5 = tmp12 - } - return tmp5 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // drop-last - { - tmp0 := lang.NewSymbol("drop-last").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return a lazy sequence of all but the last n (default 1) items in coll", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2932), lang.NewKeyword("end-line"), int(2932))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("drop-last")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.Apply(tmp6, []any{int64(1), v3}) - return tmp7 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("map")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - var tmp8 lang.FnFunc - tmp8 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v9 := args[0] - _ = v9 - v10 := args[1] - _ = v10 - return v9 - }) - tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2937), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(2937), lang.NewKeyword("end-column"), int(29)) - tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("drop")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{v3, v4}) - tmp15 := lang.Apply(tmp7, []any{tmp10, v4, tmp14}) - return tmp15 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // drop-while - { - tmp0 := lang.NewSymbol("drop-while").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred")), lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the items in coll starting from the\n first item for which (pred item) returns logical false. Returns a\n stateful transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2950), lang.NewKeyword("end-line"), int(2950))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v5 := args[0] - _ = v5 - var tmp6 any - { // let - // let binding "dv" - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("volatile!")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp9, []any{true}) - var v11 any = tmp10 - _ = v11 - var tmp12 lang.FnFunc - tmp12 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp13 := lang.Apply(v5, nil) - return tmp13 - case 1: - v13 := args[0] - _ = v13 - tmp14 := lang.Apply(v5, []any{v13}) - return tmp14 - case 2: - v13 := args[0] - _ = v13 - v14 := args[1] - _ = v14 - var tmp15 any - { // let - // let binding "drop?" - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("deref")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{v11}) - var v20 any = tmp19 - _ = v20 - var tmp21 any - var tmp22 any - { // let - // let binding "and__0__auto__" - var v23 any = v20 - _ = v23 - var tmp24 any - if lang.IsTruthy(v23) { - tmp25 := lang.Apply(v3, []any{v14}) - tmp24 = tmp25 - } else { - tmp24 = v23 - } - tmp22 = tmp24 - } // end let - if lang.IsTruthy(tmp22) { - tmp21 = v13 - } else { - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("vreset!")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.Apply(tmp25, []any{v11, nil}) - _ = tmp26 - tmp27 := lang.Apply(v5, []any{v13, v14}) - tmp21 = tmp27 - } - tmp15 = tmp21 - } // end let - return tmp15 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2959), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(2968), lang.NewKeyword("end-column"), int(42)) - tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp6 = tmp14 - } // end let - return tmp6 - }) - tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2957), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2968), lang.NewKeyword("end-column"), int(44)) - tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp6 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - { // let - // let binding "step" - var tmp6 lang.FnFunc - tmp6 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v7 := args[0] - _ = v7 - v8 := args[1] - _ = v8 - recur_loop_552: - var tmp9 any - { // let - // let binding "s" - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("seq")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{v8}) - var v14 any = tmp13 - _ = v14 - var tmp15 any - var tmp16 any - { // let - // let binding "and__0__auto__" - var v17 any = v14 - _ = v17 - var tmp18 any - if lang.IsTruthy(v17) { - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("first")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, []any{v14}) - tmp23 := lang.Apply(v7, []any{tmp22}) - tmp18 = tmp23 - } else { - tmp18 = v17 - } - tmp16 = tmp18 - } // end let - if lang.IsTruthy(tmp16) { - var tmp17 any = v7 - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("rest")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, []any{v14}) - var tmp18 any = tmp22 - v7 = tmp17 - v8 = tmp18 - goto recur_loop_552 - } else { - tmp15 = v14 - } - tmp9 = tmp15 - } // end let - return tmp9 - }) - tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2970), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(2974), lang.NewKeyword("end-column"), int(26)) - tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v9 any = tmp8 - _ = v9 - var tmp10 lang.FnFunc - tmp10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - tmp11 := lang.Apply(v9, []any{v3, v4}) - return tmp11 - }) - tmp11 := lang.Apply(lang.NewLazySeq, []any{tmp10}) - tmp5 = tmp11 - } // end let - return tmp5 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // elide-top-frames - { - tmp0 := lang.NewSymbol("elide-top-frames").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4794), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(4794), lang.NewKeyword("end-column"), int(32), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ex"), lang.NewSymbol("class-name"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - { // let - // let binding "tr" - tmp6, ok := lang.FieldOrMethod(v3, "getStackTrace") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getStackTrace"))) - } - var tmp7 any - switch reflect.TypeOf(tmp6).Kind() { - case reflect.Func: - tmp7 = lang.Apply(tmp6, nil) - default: - tmp7 = tmp6 - } - var v8 any = tmp7 - _ = v8 - var tmp9 any - { // let - // let binding "G__54" - var v10 any = v3 - _ = v10 - var tmp11 any - if lang.IsTruthy(v8) { - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("into-array")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("drop-while")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - var tmp18 lang.FnFunc - tmp18 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v19 := args[0] - _ = v19 - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("=")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23, ok := lang.FieldOrMethod(v19, "getClassName") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v19, "getClassName"))) - } - var tmp24 any - switch reflect.TypeOf(tmp23).Kind() { - case reflect.Func: - tmp24 = lang.Apply(tmp23, nil) - default: - tmp24 = tmp23 - } - tmp25 := lang.Apply(tmp22, []any{v4, tmp24}) - return tmp25 - }) - tmp19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4801), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(4801), lang.NewKeyword("end-column"), int(77)) - tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp21 := lang.Apply(tmp17, []any{tmp20, v8}) - tmp22 := lang.Apply(tmp14, []any{nil, tmp21}) - tmp11 = tmp22 - } else { - } - tmp23, _ := lang.FieldOrMethod(v10, "setStackTrace") - if reflect.TypeOf(tmp23).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setStackTrace is not a function"))) - } - tmp24 := lang.Apply(tmp23, []any{tmp11}) - _ = tmp24 - tmp9 = v10 - } // end let - tmp5 = tmp9 - } // end let - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // emit-extend-protocol - { - tmp0 := lang.NewSymbol("emit-extend-protocol").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(205), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(205), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("p"), lang.NewSymbol("specs"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - { // let - // let binding "impls" - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("parse-impls")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(tmp8, []any{v4}) - var v10 any = tmp9 - _ = v10 - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("seq")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("concat")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("list")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.Apply(tmp19, []any{lang.NewSymbol("do")}) - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("map")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - var tmp24 lang.FnFunc - tmp24 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v25 := args[0] - _ = v25 - var tmp26 any - { // let - // let binding "vec__292" - var v27 any = v25 - _ = v27 - // let binding "t" - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("nth")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.Apply(tmp30, []any{v27, int64(0), nil}) - var v32 any = tmp31 - _ = v32 - // let binding "fs" - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("nth")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.Apply(tmp35, []any{v27, int64(1), nil}) - var v37 any = tmp36 - _ = v37 - tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp39 := tmp38.FindInternedVar(lang.NewSymbol("seq")) - if tmp39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) - } - tmp40 := tmp39.Get() - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("concat")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.Apply(tmp46, []any{lang.NewSymbol("glojure.core/extend-type")}) - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v32}) - tmp52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp53 := tmp52.FindInternedVar(lang.NewSymbol("list")) - if tmp53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp53))) - } - tmp54 := tmp53.Get() - tmp55 := lang.Apply(tmp54, []any{v3}) - tmp56 := lang.Apply(tmp43, []any{tmp47, tmp51, tmp55, v37}) - tmp57 := lang.Apply(tmp40, []any{tmp56}) - tmp26 = tmp57 - } // end let - return tmp26 - }) - tmp25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(208), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(209), lang.NewKeyword("end-column"), int(42)) - tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp27 := lang.Apply(tmp23, []any{tmp26, v10}) - tmp28 := lang.Apply(tmp16, []any{tmp20, tmp27}) - tmp29 := lang.Apply(tmp13, []any{tmp28}) - tmp5 = tmp29 - } // end let - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // emit-extend-type - { - tmp0 := lang.NewSymbol("emit-extend-type").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(175), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(175), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"), lang.NewSymbol("specs"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - { // let - // let binding "impls" - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("parse-impls")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(tmp8, []any{v4}) - var v10 any = tmp9 - _ = v10 - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("seq")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("concat")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("list")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.Apply(tmp19, []any{lang.NewSymbol("glojure.core/extend")}) - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("list")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.Apply(tmp23, []any{v3}) - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("mapcat")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("partial")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("emit-hinted-impl")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp30, []any{tmp33, v3}) - tmp35 := lang.Apply(tmp27, []any{tmp34, v10}) - tmp36 := lang.Apply(tmp16, []any{tmp20, tmp24, tmp35}) - tmp37 := lang.Apply(tmp13, []any{tmp36}) - tmp5 = tmp37 - } // end let - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // emit-hinted-impl - { - tmp0 := lang.NewSymbol("emit-hinted-impl").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(163), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(163), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"), lang.NewVector(lang.NewSymbol("p"), lang.NewSymbol("fs")))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - { // let - // let binding "vec__281" - var v6 any = v4 - _ = v6 - // let binding "p" - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("nth")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp9, []any{v6, int64(0), nil}) - var v11 any = tmp10 - _ = v11 - // let binding "fs" - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("nth")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.Apply(tmp14, []any{v6, int64(1), nil}) - var v16 any = tmp15 - _ = v16 - var tmp17 any - { // let - // let binding "hint" - var tmp18 lang.FnFunc - tmp18 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v19 := args[0] - _ = v19 - var tmp20 any - { // let - // let binding "specs" - var tmp21 any - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("vector?")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("first")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.Apply(tmp27, []any{v19}) - tmp29 := lang.Apply(tmp24, []any{tmp28}) - if lang.IsTruthy(tmp29) { - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("list")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.Apply(tmp32, []any{v19}) - tmp21 = tmp33 - } else { - tmp21 = v19 - } - var v34 any = tmp21 - _ = v34 - tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp36 := tmp35.FindInternedVar(lang.NewSymbol("map")) - if tmp36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) - } - tmp37 := tmp36.Get() - var tmp38 lang.FnFunc - tmp38 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v39 := args[0] - _ = v39 - var tmp40 any - { // let - // let binding "vec__285" - var v41 any = v39 - _ = v41 - // let binding "seq__286" - tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp43 := tmp42.FindInternedVar(lang.NewSymbol("seq")) - if tmp43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) - } - tmp44 := tmp43.Get() - tmp45 := lang.Apply(tmp44, []any{v41}) - var v46 any = tmp45 - _ = v46 - // let binding "first__287" - tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp48 := tmp47.FindInternedVar(lang.NewSymbol("first")) - if tmp48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) - } - tmp49 := tmp48.Get() - tmp50 := lang.Apply(tmp49, []any{v46}) - var v51 any = tmp50 - _ = v51 - // let binding "seq__286" - tmp52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp53 := tmp52.FindInternedVar(lang.NewSymbol("next")) - if tmp53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp53))) - } - tmp54 := tmp53.Get() - tmp55 := lang.Apply(tmp54, []any{v46}) - var v56 any = tmp55 - _ = v56 - // let binding "vec__288" - var v57 any = v51 - _ = v57 - // let binding "seq__289" - tmp58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp59 := tmp58.FindInternedVar(lang.NewSymbol("seq")) - if tmp59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp59))) - } - tmp60 := tmp59.Get() - tmp61 := lang.Apply(tmp60, []any{v57}) - var v62 any = tmp61 - _ = v62 - // let binding "first__290" - tmp63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp64 := tmp63.FindInternedVar(lang.NewSymbol("first")) - if tmp64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp64))) - } - tmp65 := tmp64.Get() - tmp66 := lang.Apply(tmp65, []any{v62}) - var v67 any = tmp66 - _ = v67 - // let binding "seq__289" - tmp68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp69 := tmp68.FindInternedVar(lang.NewSymbol("next")) - if tmp69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp69))) - } - tmp70 := tmp69.Get() - tmp71 := lang.Apply(tmp70, []any{v62}) - var v72 any = tmp71 - _ = v72 - // let binding "target" - var v73 any = v67 - _ = v73 - // let binding "args" - var v74 any = v72 - _ = v74 - // let binding "body" - var v75 any = v56 - _ = v75 - tmp76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp77 := tmp76.FindInternedVar(lang.NewSymbol("cons")) - if tmp77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp77))) - } - tmp78 := tmp77.Get() - tmp79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp80 := tmp79.FindInternedVar(lang.NewSymbol("apply")) - if tmp80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp80))) - } - tmp81 := tmp80.Get() - tmp82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp83 := tmp82.FindInternedVar(lang.NewSymbol("vector")) - if tmp83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp83))) - } - tmp84 := tmp83.Get() - tmp85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp86 := tmp85.FindInternedVar(lang.NewSymbol("vary-meta")) - if tmp86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp86))) - } - tmp87 := tmp86.Get() - tmp88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp89 := tmp88.FindInternedVar(lang.NewSymbol("assoc")) - if tmp89.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp89))) - } - tmp90 := tmp89.Get() - tmp91 := lang.Apply(tmp87, []any{v73, tmp90, lang.NewKeyword("tag"), v3}) - tmp92 := lang.Apply(tmp81, []any{tmp84, tmp91, v74}) - tmp93 := lang.Apply(tmp78, []any{tmp92, v75}) - tmp40 = tmp93 - } // end let - return tmp40 - }) - tmp39 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(168), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(170), lang.NewKeyword("end-column"), int(36)) - tmp40, err := lang.WithMeta(tmp38, tmp39.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp41 := lang.Apply(tmp37, []any{tmp40, v34}) - tmp20 = tmp41 - } // end let - return tmp20 - }) - tmp19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(164), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(171), lang.NewKeyword("end-column"), int(30)) - tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v21 any = tmp20 - _ = v21 - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("zipmap")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("map")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - var tmp28 lang.FnFunc - tmp28 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v29 := args[0] - _ = v29 - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("keyword")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("name")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("first")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{v29}) - tmp40 := lang.Apply(tmp35, []any{tmp39}) - tmp41 := lang.Apply(tmp32, []any{tmp40}) - return tmp41 - }) - tmp29 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(172), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(172), lang.NewKeyword("end-column"), int(46)) - tmp30, err := lang.WithMeta(tmp28, tmp29.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp31 := lang.Apply(tmp27, []any{tmp30, v16}) - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("map")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - var tmp35 lang.FnFunc - tmp35 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v36 := args[0] - _ = v36 - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("cons")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("drop")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.Apply(tmp42, []any{int64(1), v36}) - tmp44 := lang.Apply(v21, []any{tmp43}) - tmp45 := lang.Apply(tmp39, []any{lang.NewSymbol("glojure.core/fn"), tmp44}) - return tmp45 - }) - tmp36 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(173), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(173), lang.NewKeyword("end-column"), int(49)) - tmp37, err := lang.WithMeta(tmp35, tmp36.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp38 := lang.Apply(tmp34, []any{tmp37, v16}) - tmp39 := lang.Apply(tmp24, []any{tmp31, tmp38}) - tmp40 := lang.NewVector(v11, tmp39) - tmp41 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(172), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(173), lang.NewKeyword("end-column"), int(55)) - tmp42, err := lang.WithMeta(tmp40, tmp41.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp17 = tmp42 - } // end let - tmp5 = tmp17 - } // end let - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // empty - { - tmp0 := lang.NewSymbol("empty").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns an empty collection of the same category as coll, or nil", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5265), lang.NewKeyword("end-line"), int(5265))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("instance?")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := reflect.TypeOf((*lang.IPersistentCollection)(nil)).Elem() - tmp9 := lang.Apply(tmp7, []any{tmp8, v3}) - if lang.IsTruthy(tmp9) { - tmp10, ok := lang.FieldOrMethod(v3, "empty") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "empty"))) - } - var tmp11 any - switch reflect.TypeOf(tmp10).Kind() { - case reflect.Func: - tmp11 = lang.Apply(tmp10, nil) - default: - tmp11 = tmp10 - } - tmp4 = tmp11 - } else { - } - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // empty? - { - tmp0 := lang.NewSymbol("empty?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll has no items. To check the emptiness of a seq,\n please use the idiom (seq x) rather than (not (empty? x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6247), lang.NewKeyword("end-line"), int(6247))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("counted?")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v3}) - if lang.IsTruthy(tmp8) { - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("zero?")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("count")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.Apply(tmp14, []any{v3}) - tmp16 := lang.Apply(tmp11, []any{tmp15}) - tmp4 = tmp16 - } else { - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("not")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("seq")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.Apply(tmp22, []any{v3}) - tmp24 := lang.Apply(tmp19, []any{tmp23}) - tmp4 = tmp24 - } - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // ensure - { - tmp0 := lang.NewSymbol("ensure").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref"))), lang.NewKeyword("doc"), "Must be called in a transaction. Protects the ref from modification\n by other transactions. Returns the in-transaction-value of\n ref. Allows for more concurrency than (ref-set ref @ref)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2480), lang.NewKeyword("end-line"), int(2480))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4, _ := lang.FieldOrMethod(v3, "touch") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("touch is not a function"))) - } - tmp5 := lang.Apply(tmp4, []any{}) - _ = tmp5 - tmp6, _ := lang.FieldOrMethod(v3, "deref") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("deref is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{}) - return tmp7 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // ensure-reduced - { - tmp0 := lang.NewSymbol("ensure-reduced").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "If x is already reduced?, returns it, else returns (reduced x)", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2841), lang.NewKeyword("end-line"), int(2841))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("reduced?")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v3}) - if lang.IsTruthy(tmp8) { - tmp4 = v3 - } else { - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("reduced")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.Apply(tmp11, []any{v3}) - tmp4 = tmp12 - } - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // enumeration-seq - { - tmp0 := lang.NewSymbol("enumeration-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("e"))), lang.NewKeyword("doc"), "Returns a seq on a java.util.Enumeration", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5710), lang.NewKeyword("end-line"), int(5710))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.Apply(nil, []any{v3}) - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // error-handler - { - tmp0 := lang.NewSymbol("error-handler").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("doc"), "Returns the error-handler of agent a, or nil if there is none.\n See set-error-handler!", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2202), lang.NewKeyword("end-line"), int(2202))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4, ok := lang.FieldOrMethod(v3, "getErrorHandler") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getErrorHandler"))) - } - var tmp5 any - switch reflect.TypeOf(tmp4).Kind() { - case reflect.Func: - tmp5 = lang.Apply(tmp4, nil) - default: - tmp5 = tmp4 - } - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // error-mode - { - tmp0 := lang.NewSymbol("error-mode").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("doc"), "Returns the error-mode of agent a. See set-error-mode!", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2227), lang.NewKeyword("end-line"), int(2227))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4, ok := lang.FieldOrMethod(v3, "getErrorMode") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getErrorMode"))) - } - var tmp5 any - switch reflect.TypeOf(tmp4).Kind() { - case reflect.Func: - tmp5 = lang.Apply(tmp4, nil) - default: - tmp5 = tmp4 - } - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // eval - { - tmp0 := lang.NewSymbol("eval").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("form"))), lang.NewKeyword("doc"), "Evaluates the form data structure (not text!) and returns the result.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3203), lang.NewKeyword("end-line"), int(3203))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4, _ := lang.FieldOrMethod(runtime4.Compiler, "Eval") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Eval is not a function"))) - } - tmp5 := lang.Apply(tmp4, []any{v3}) - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // even? - { - tmp0 := lang.NewSymbol("even?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is even, throws an exception if n is not an integer", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1381), lang.NewKeyword("end-line"), int(1381))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("integer?")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v3}) - if lang.IsTruthy(tmp8) { - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("zero?")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("bit-and")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.Apply(lang.UncheckedLongCast, []any{v3}) - tmp16 := lang.Apply(tmp14, []any{tmp15, int64(1)}) - tmp17 := lang.Apply(tmp11, []any{tmp16}) - tmp4 = tmp17 - } else { - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("str")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.Apply(tmp20, []any{"Argument must be an integer: ", v3}) - tmp22 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp21}) - panic(tmp22) - } - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // every-pred - { - tmp0 := lang.NewSymbol("every-pred").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("p")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2"), lang.NewSymbol("p3")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2"), lang.NewSymbol("p3"), lang.NewSymbol("&"), lang.NewSymbol("ps"))), lang.NewKeyword("doc"), "Takes a set of predicates and returns a function f that returns true if all of its\n composing predicates return a logical true value against all of its arguments, else it returns\n false. Note that f is short-circuiting in that it will stop execution on the first\n argument that triggers a logical false result against the original predicates.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7422), lang.NewKeyword("end-line"), int(7422))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - var tmp4 lang.FnFunc - { // function ep1 - var v5 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - return true - case 1: - v6 := args[0] - _ = v6 - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("boolean")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(v3, []any{v6}) - tmp11 := lang.Apply(tmp9, []any{tmp10}) - return tmp11 - case 2: - v6 := args[0] - _ = v6 - v7 := args[1] - _ = v7 - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("boolean")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - var tmp11 any - { // let - // let binding "and__0__auto__" - tmp12 := lang.Apply(v3, []any{v6}) - var v13 any = tmp12 - _ = v13 - var tmp14 any - if lang.IsTruthy(v13) { - tmp15 := lang.Apply(v3, []any{v7}) - tmp14 = tmp15 - } else { - tmp14 = v13 - } - tmp11 = tmp14 - } // end let - tmp12 := lang.Apply(tmp10, []any{tmp11}) - return tmp12 - case 3: - v6 := args[0] - _ = v6 - v7 := args[1] - _ = v7 - v8 := args[2] - _ = v8 - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("boolean")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - var tmp12 any - { // let - // let binding "and__0__auto__" - tmp13 := lang.Apply(v3, []any{v6}) - var v14 any = tmp13 - _ = v14 - var tmp15 any - if lang.IsTruthy(v14) { - var tmp16 any - { // let - // let binding "and__0__auto__" - tmp17 := lang.Apply(v3, []any{v7}) - var v18 any = tmp17 - _ = v18 - var tmp19 any - if lang.IsTruthy(v18) { - tmp20 := lang.Apply(v3, []any{v8}) - tmp19 = tmp20 - } else { - tmp19 = v18 - } - tmp16 = tmp19 - } // end let - tmp15 = tmp16 - } else { - tmp15 = v14 - } - tmp12 = tmp15 - } // end let - tmp13 := lang.Apply(tmp11, []any{tmp12}) - return tmp13 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v6 := args[0] - _ = v6 - v7 := args[1] - _ = v7 - v8 := args[2] - _ = v8 - var v9 any = lang.NewList(args[3:]...) - _ = v9 - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("boolean")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - var tmp13 any - { // let - // let binding "and__0__auto__" - tmp14 := lang.Apply(v5, []any{v6, v7, v8}) - var v15 any = tmp14 - _ = v15 - var tmp16 any - if lang.IsTruthy(v15) { - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("every?")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.Apply(tmp19, []any{v3, v9}) - tmp16 = tmp20 - } else { - tmp16 = v15 - } - tmp13 = tmp16 - } // end let - tmp14 := lang.Apply(tmp12, []any{tmp13}) - return tmp14 - } - }) - v5 = tmp4 - _ = v5 - } - tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7429), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7435), lang.NewKeyword("end-column"), int(56)) - tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp6 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 lang.FnFunc - { // function ep2 - var v6 lang.FnFunc - tmp5 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - return true - case 1: - v7 := args[0] - _ = v7 - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("boolean")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - var tmp11 any - { // let - // let binding "and__0__auto__" - tmp12 := lang.Apply(v3, []any{v7}) - var v13 any = tmp12 - _ = v13 - var tmp14 any - if lang.IsTruthy(v13) { - tmp15 := lang.Apply(v4, []any{v7}) - tmp14 = tmp15 - } else { - tmp14 = v13 - } - tmp11 = tmp14 - } // end let - tmp12 := lang.Apply(tmp10, []any{tmp11}) - return tmp12 - case 2: - v7 := args[0] - _ = v7 - v8 := args[1] - _ = v8 - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("boolean")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - var tmp12 any - { // let - // let binding "and__0__auto__" - tmp13 := lang.Apply(v3, []any{v7}) - var v14 any = tmp13 - _ = v14 - var tmp15 any - if lang.IsTruthy(v14) { - var tmp16 any - { // let - // let binding "and__0__auto__" - tmp17 := lang.Apply(v3, []any{v8}) - var v18 any = tmp17 - _ = v18 - var tmp19 any - if lang.IsTruthy(v18) { - var tmp20 any - { // let - // let binding "and__0__auto__" - tmp21 := lang.Apply(v4, []any{v7}) - var v22 any = tmp21 - _ = v22 - var tmp23 any - if lang.IsTruthy(v22) { - tmp24 := lang.Apply(v4, []any{v8}) - tmp23 = tmp24 - } else { - tmp23 = v22 - } - tmp20 = tmp23 - } // end let - tmp19 = tmp20 - } else { - tmp19 = v18 - } - tmp16 = tmp19 - } // end let - tmp15 = tmp16 - } else { - tmp15 = v14 - } - tmp12 = tmp15 - } // end let - tmp13 := lang.Apply(tmp11, []any{tmp12}) - return tmp13 - case 3: - v7 := args[0] - _ = v7 - v8 := args[1] - _ = v8 - v9 := args[2] - _ = v9 - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("boolean")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - var tmp13 any - { // let - // let binding "and__0__auto__" - tmp14 := lang.Apply(v3, []any{v7}) - var v15 any = tmp14 - _ = v15 - var tmp16 any - if lang.IsTruthy(v15) { - var tmp17 any - { // let - // let binding "and__0__auto__" - tmp18 := lang.Apply(v3, []any{v8}) - var v19 any = tmp18 - _ = v19 - var tmp20 any - if lang.IsTruthy(v19) { - var tmp21 any - { // let - // let binding "and__0__auto__" - tmp22 := lang.Apply(v3, []any{v9}) - var v23 any = tmp22 - _ = v23 - var tmp24 any - if lang.IsTruthy(v23) { - var tmp25 any - { // let - // let binding "and__0__auto__" - tmp26 := lang.Apply(v4, []any{v7}) - var v27 any = tmp26 - _ = v27 - var tmp28 any - if lang.IsTruthy(v27) { - var tmp29 any - { // let - // let binding "and__0__auto__" - tmp30 := lang.Apply(v4, []any{v8}) - var v31 any = tmp30 - _ = v31 - var tmp32 any - if lang.IsTruthy(v31) { - tmp33 := lang.Apply(v4, []any{v9}) - tmp32 = tmp33 - } else { - tmp32 = v31 - } - tmp29 = tmp32 - } // end let - tmp28 = tmp29 - } else { - tmp28 = v27 - } - tmp25 = tmp28 - } // end let - tmp24 = tmp25 - } else { - tmp24 = v23 - } - tmp21 = tmp24 - } // end let - tmp20 = tmp21 - } else { - tmp20 = v19 - } - tmp17 = tmp20 - } // end let - tmp16 = tmp17 - } else { - tmp16 = v15 - } - tmp13 = tmp16 - } // end let - tmp14 := lang.Apply(tmp12, []any{tmp13}) - return tmp14 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v7 := args[0] - _ = v7 - v8 := args[1] - _ = v8 - v9 := args[2] - _ = v9 - var v10 any = lang.NewList(args[3:]...) - _ = v10 - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("boolean")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - var tmp14 any - { // let - // let binding "and__0__auto__" - tmp15 := lang.Apply(v6, []any{v7, v8, v9}) - var v16 any = tmp15 - _ = v16 - var tmp17 any - if lang.IsTruthy(v16) { - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("every?")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - var tmp21 lang.FnFunc - tmp21 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v22 := args[0] - _ = v22 - var tmp23 any - { // let - // let binding "and__0__auto__" - tmp24 := lang.Apply(v3, []any{v22}) - var v25 any = tmp24 - _ = v25 - var tmp26 any - if lang.IsTruthy(v25) { - tmp27 := lang.Apply(v4, []any{v22}) - tmp26 = tmp27 - } else { - tmp26 = v25 - } - tmp23 = tmp26 - } // end let - return tmp23 - }) - tmp22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7443), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(7443), lang.NewKeyword("end-column"), int(65)) - tmp23, err := lang.WithMeta(tmp21, tmp22.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp24 := lang.Apply(tmp20, []any{tmp23, v10}) - tmp17 = tmp24 - } else { - tmp17 = v16 - } - tmp14 = tmp17 - } // end let - tmp15 := lang.Apply(tmp13, []any{tmp14}) - return tmp15 - } - }) - v6 = tmp5 - _ = v6 - } - tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7437), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7443), lang.NewKeyword("end-column"), int(75)) - tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp7 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var tmp6 lang.FnFunc - { // function ep3 - var v7 lang.FnFunc - tmp6 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - return true - case 1: - v8 := args[0] - _ = v8 - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("boolean")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - var tmp12 any - { // let - // let binding "and__0__auto__" - tmp13 := lang.Apply(v3, []any{v8}) - var v14 any = tmp13 - _ = v14 - var tmp15 any - if lang.IsTruthy(v14) { - var tmp16 any - { // let - // let binding "and__0__auto__" - tmp17 := lang.Apply(v4, []any{v8}) - var v18 any = tmp17 - _ = v18 - var tmp19 any - if lang.IsTruthy(v18) { - tmp20 := lang.Apply(v5, []any{v8}) - tmp19 = tmp20 - } else { - tmp19 = v18 - } - tmp16 = tmp19 - } // end let - tmp15 = tmp16 - } else { - tmp15 = v14 - } - tmp12 = tmp15 - } // end let - tmp13 := lang.Apply(tmp11, []any{tmp12}) - return tmp13 - case 2: - v8 := args[0] - _ = v8 - v9 := args[1] - _ = v9 - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("boolean")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - var tmp13 any - { // let - // let binding "and__0__auto__" - tmp14 := lang.Apply(v3, []any{v8}) - var v15 any = tmp14 - _ = v15 - var tmp16 any - if lang.IsTruthy(v15) { - var tmp17 any - { // let - // let binding "and__0__auto__" - tmp18 := lang.Apply(v3, []any{v9}) - var v19 any = tmp18 - _ = v19 - var tmp20 any - if lang.IsTruthy(v19) { - var tmp21 any - { // let - // let binding "and__0__auto__" - tmp22 := lang.Apply(v4, []any{v8}) - var v23 any = tmp22 - _ = v23 - var tmp24 any - if lang.IsTruthy(v23) { - var tmp25 any - { // let - // let binding "and__0__auto__" - tmp26 := lang.Apply(v4, []any{v9}) - var v27 any = tmp26 - _ = v27 - var tmp28 any - if lang.IsTruthy(v27) { - var tmp29 any - { // let - // let binding "and__0__auto__" - tmp30 := lang.Apply(v5, []any{v8}) - var v31 any = tmp30 - _ = v31 - var tmp32 any - if lang.IsTruthy(v31) { - tmp33 := lang.Apply(v5, []any{v9}) - tmp32 = tmp33 - } else { - tmp32 = v31 - } - tmp29 = tmp32 - } // end let - tmp28 = tmp29 - } else { - tmp28 = v27 - } - tmp25 = tmp28 - } // end let - tmp24 = tmp25 - } else { - tmp24 = v23 - } - tmp21 = tmp24 - } // end let - tmp20 = tmp21 - } else { - tmp20 = v19 - } - tmp17 = tmp20 - } // end let - tmp16 = tmp17 - } else { - tmp16 = v15 - } - tmp13 = tmp16 - } // end let - tmp14 := lang.Apply(tmp12, []any{tmp13}) - return tmp14 - case 3: - v8 := args[0] - _ = v8 - v9 := args[1] - _ = v9 - v10 := args[2] - _ = v10 - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("boolean")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - var tmp14 any - { // let - // let binding "and__0__auto__" - tmp15 := lang.Apply(v3, []any{v8}) - var v16 any = tmp15 - _ = v16 - var tmp17 any - if lang.IsTruthy(v16) { - var tmp18 any - { // let - // let binding "and__0__auto__" - tmp19 := lang.Apply(v3, []any{v9}) - var v20 any = tmp19 - _ = v20 - var tmp21 any - if lang.IsTruthy(v20) { - var tmp22 any - { // let - // let binding "and__0__auto__" - tmp23 := lang.Apply(v3, []any{v10}) - var v24 any = tmp23 - _ = v24 - var tmp25 any - if lang.IsTruthy(v24) { - var tmp26 any - { // let - // let binding "and__0__auto__" - tmp27 := lang.Apply(v4, []any{v8}) - var v28 any = tmp27 - _ = v28 - var tmp29 any - if lang.IsTruthy(v28) { - var tmp30 any - { // let - // let binding "and__0__auto__" - tmp31 := lang.Apply(v4, []any{v9}) - var v32 any = tmp31 - _ = v32 - var tmp33 any - if lang.IsTruthy(v32) { - var tmp34 any - { // let - // let binding "and__0__auto__" - tmp35 := lang.Apply(v4, []any{v10}) - var v36 any = tmp35 - _ = v36 - var tmp37 any - if lang.IsTruthy(v36) { - var tmp38 any - { // let - // let binding "and__0__auto__" - tmp39 := lang.Apply(v5, []any{v8}) - var v40 any = tmp39 - _ = v40 - var tmp41 any - if lang.IsTruthy(v40) { - var tmp42 any - { // let - // let binding "and__0__auto__" - tmp43 := lang.Apply(v5, []any{v9}) - var v44 any = tmp43 - _ = v44 - var tmp45 any - if lang.IsTruthy(v44) { - tmp46 := lang.Apply(v5, []any{v10}) - tmp45 = tmp46 - } else { - tmp45 = v44 - } - tmp42 = tmp45 - } // end let - tmp41 = tmp42 - } else { - tmp41 = v40 - } - tmp38 = tmp41 - } // end let - tmp37 = tmp38 - } else { - tmp37 = v36 - } - tmp34 = tmp37 - } // end let - tmp33 = tmp34 - } else { - tmp33 = v32 - } - tmp30 = tmp33 - } // end let - tmp29 = tmp30 - } else { - tmp29 = v28 - } - tmp26 = tmp29 - } // end let - tmp25 = tmp26 - } else { - tmp25 = v24 - } - tmp22 = tmp25 - } // end let - tmp21 = tmp22 - } else { - tmp21 = v20 - } - tmp18 = tmp21 - } // end let - tmp17 = tmp18 - } else { - tmp17 = v16 - } - tmp14 = tmp17 - } // end let - tmp15 := lang.Apply(tmp13, []any{tmp14}) - return tmp15 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v8 := args[0] - _ = v8 - v9 := args[1] - _ = v9 - v10 := args[2] - _ = v10 - var v11 any = lang.NewList(args[3:]...) - _ = v11 - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("boolean")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - var tmp15 any - { // let - // let binding "and__0__auto__" - tmp16 := lang.Apply(v7, []any{v8, v9, v10}) - var v17 any = tmp16 - _ = v17 - var tmp18 any - if lang.IsTruthy(v17) { - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("every?")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - var tmp22 lang.FnFunc - tmp22 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v23 := args[0] - _ = v23 - var tmp24 any - { // let - // let binding "and__0__auto__" - tmp25 := lang.Apply(v3, []any{v23}) - var v26 any = tmp25 - _ = v26 - var tmp27 any - if lang.IsTruthy(v26) { - var tmp28 any - { // let - // let binding "and__0__auto__" - tmp29 := lang.Apply(v4, []any{v23}) - var v30 any = tmp29 - _ = v30 - var tmp31 any - if lang.IsTruthy(v30) { - tmp32 := lang.Apply(v5, []any{v23}) - tmp31 = tmp32 - } else { - tmp31 = v30 - } - tmp28 = tmp31 - } // end let - tmp27 = tmp28 - } else { - tmp27 = v26 - } - tmp24 = tmp27 - } // end let - return tmp24 - }) - tmp23 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7451), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(7451), lang.NewKeyword("end-column"), int(72)) - tmp24, err := lang.WithMeta(tmp22, tmp23.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp25 := lang.Apply(tmp21, []any{tmp24, v11}) - tmp18 = tmp25 - } else { - tmp18 = v17 - } - tmp15 = tmp18 - } // end let - tmp16 := lang.Apply(tmp14, []any{tmp15}) - return tmp16 - } - }) - v7 = tmp6 - _ = v7 - } - tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7445), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7451), lang.NewKeyword("end-column"), int(82)) - tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp8 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any - { // let - // let binding "ps" - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("list*")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v3, v4, v5, v6}) - var v12 any = tmp11 - _ = v12 - var tmp13 lang.FnFunc - { // function epn - var v14 lang.FnFunc - tmp13 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - return true - case 1: - v15 := args[0] - _ = v15 - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("every?")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - var tmp19 lang.FnFunc - tmp19 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v20 := args[0] - _ = v20 - tmp21 := lang.Apply(v20, []any{v15}) - return tmp21 - }) - tmp20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7456), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(7456), lang.NewKeyword("end-column"), int(28)) - tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp22 := lang.Apply(tmp18, []any{tmp21, v12}) - return tmp22 - case 2: - v15 := args[0] - _ = v15 - v16 := args[1] - _ = v16 - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("every?")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - var tmp20 lang.FnFunc - tmp20 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v21 := args[0] - _ = v21 - var tmp22 any - { // let - // let binding "and__0__auto__" - tmp23 := lang.Apply(v21, []any{v15}) - var v24 any = tmp23 - _ = v24 - var tmp25 any - if lang.IsTruthy(v24) { - tmp26 := lang.Apply(v21, []any{v16}) - tmp25 = tmp26 - } else { - tmp25 = v24 - } - tmp22 = tmp25 - } // end let - return tmp22 - }) - tmp21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7457), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7457), lang.NewKeyword("end-column"), int(42)) - tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp23 := lang.Apply(tmp19, []any{tmp22, v12}) - return tmp23 - case 3: - v15 := args[0] - _ = v15 - v16 := args[1] - _ = v16 - v17 := args[2] - _ = v17 - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("every?")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - var tmp21 lang.FnFunc - tmp21 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v22 := args[0] - _ = v22 - var tmp23 any - { // let - // let binding "and__0__auto__" - tmp24 := lang.Apply(v22, []any{v15}) - var v25 any = tmp24 - _ = v25 - var tmp26 any - if lang.IsTruthy(v25) { - var tmp27 any - { // let - // let binding "and__0__auto__" - tmp28 := lang.Apply(v22, []any{v16}) - var v29 any = tmp28 - _ = v29 - var tmp30 any - if lang.IsTruthy(v29) { - tmp31 := lang.Apply(v22, []any{v17}) - tmp30 = tmp31 - } else { - tmp30 = v29 - } - tmp27 = tmp30 - } // end let - tmp26 = tmp27 - } else { - tmp26 = v25 - } - tmp23 = tmp26 - } // end let - return tmp23 - }) - tmp22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7458), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(7458), lang.NewKeyword("end-column"), int(50)) - tmp23, err := lang.WithMeta(tmp21, tmp22.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp24 := lang.Apply(tmp20, []any{tmp23, v12}) - return tmp24 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v15 := args[0] - _ = v15 - v16 := args[1] - _ = v16 - v17 := args[2] - _ = v17 - var v18 any = lang.NewList(args[3:]...) - _ = v18 - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("boolean")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - var tmp22 any - { // let - // let binding "and__0__auto__" - tmp23 := lang.Apply(v14, []any{v15, v16, v17}) - var v24 any = tmp23 - _ = v24 - var tmp25 any - if lang.IsTruthy(v24) { - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("every?")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - var tmp29 lang.FnFunc - tmp29 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v30 := args[0] - _ = v30 - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("every?")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{v30, v18}) - return tmp34 - }) - tmp30 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7460), lang.NewKeyword("column"), int(48), lang.NewKeyword("end-line"), int(7460), lang.NewKeyword("end-column"), int(63)) - tmp31, err := lang.WithMeta(tmp29, tmp30.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp32 := lang.Apply(tmp28, []any{tmp31, v12}) - tmp25 = tmp32 - } else { - tmp25 = v24 - } - tmp22 = tmp25 - } // end let - tmp23 := lang.Apply(tmp21, []any{tmp22}) - return tmp23 - } - }) - v14 = tmp13 - _ = v14 - } - tmp14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7454), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7460), lang.NewKeyword("end-column"), int(71)) - tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp7 = tmp15 - } // end let - return tmp7 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // every? - { - tmp1 := reflect.TypeOf(false) - tmp0 := lang.NewSymbol("every?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if (pred x) is logical true for every x in coll, else\n false.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2664), lang.NewKeyword("end-line"), int(2664))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - recur_loop_480: - var tmp6 any - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("nil?")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("seq")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{v5}) - tmp14 := lang.Apply(tmp9, []any{tmp13}) - if lang.IsTruthy(tmp14) { - tmp6 = true - } else { - var tmp15 any - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("first")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{v5}) - tmp20 := lang.Apply(v4, []any{tmp19}) - if lang.IsTruthy(tmp20) { - var tmp21 any = v4 - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("next")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.Apply(tmp25, []any{v5}) - var tmp22 any = tmp26 - v4 = tmp21 - v5 = tmp22 - goto recur_loop_480 - } else { - var tmp27 any - if lang.IsTruthy(lang.NewKeyword("else")) { - tmp27 = false - } else { - } - tmp15 = tmp27 - } - tmp6 = tmp15 - } - return tmp6 - }) - tmp4 := reflect.TypeOf(false) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // ex-cause - { - tmp0 := lang.NewSymbol("ex-cause").WithMeta(lang.NewMap(lang.NewKeyword("tag"), nil, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ex"))), lang.NewKeyword("doc"), "Returns the cause of ex if ex is a Throwable.\n Otherwise returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4828), lang.NewKeyword("end-line"), int(4828))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("instance?")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{lang.Throwable, v3}) - if lang.IsTruthy(tmp8) { - tmp9, ok := lang.FieldOrMethod(v3, "getCause") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getCause"))) - } - var tmp10 any - switch reflect.TypeOf(tmp9).Kind() { - case reflect.Func: - tmp10 = lang.Apply(tmp9, nil) - default: - tmp10 = tmp9 - } - tmp4 = tmp10 - } else { - } - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // ex-data - { - tmp0 := lang.NewSymbol("ex-data").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ex"))), lang.NewKeyword("doc"), "Returns exception data (a map) if ex is an IExceptionInfo.\n Otherwise returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4812), lang.NewKeyword("end-line"), int(4812))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("instance?")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{nil, v3}) - if lang.IsTruthy(tmp8) { - tmp9, ok := lang.FieldOrMethod(v3, "getData") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getData"))) - } - var tmp10 any - switch reflect.TypeOf(tmp9).Kind() { - case reflect.Func: - tmp10 = lang.Apply(tmp9, nil) - default: - tmp10 = tmp9 - } - tmp4 = tmp10 - } else { - } - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // ex-info - { - tmp0 := lang.NewSymbol("ex-info").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("msg"), lang.NewSymbol("map")), lang.NewVector(lang.NewSymbol("msg"), lang.NewSymbol("map"), lang.NewSymbol("cause"))), lang.NewKeyword("doc"), "Create an instance of ExceptionInfo, a RuntimeException subclass\n that carries a map of additional data.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4803), lang.NewKeyword("end-line"), int(4803))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("elide-top-frames")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(nil, []any{v3, v4}) - tmp9 := lang.Apply(tmp7, []any{tmp8, "glojure.core$ex_info"}) - return tmp9 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("elide-top-frames")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(nil, []any{v3, v4, v5}) - tmp10 := lang.Apply(tmp8, []any{tmp9, "glojure.core$ex_info"}) - return tmp10 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // ex-message - { - tmp0 := lang.NewSymbol("ex-message").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ex"))), lang.NewKeyword("doc"), "Returns the message attached to ex if ex is a Throwable.\n Otherwise returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4820), lang.NewKeyword("end-line"), int(4820))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("instance?")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{lang.Throwable, v3}) - if lang.IsTruthy(tmp8) { - tmp9, ok := lang.FieldOrMethod(v3, "getMessage") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getMessage"))) - } - var tmp10 any - switch reflect.TypeOf(tmp9).Kind() { - case reflect.Func: - tmp10 = lang.Apply(tmp9, nil) - default: - tmp10 = tmp9 - } - tmp4 = tmp10 - } else { - } - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // extend - { - tmp0 := lang.NewSymbol("extend").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atype"), lang.NewSymbol("&"), lang.NewSymbol("proto+mmaps"))), lang.NewKeyword("doc"), "Implementations of protocol methods can be provided using the extend construct:\n\n (extend AType\n AProtocol\n {:foo an-existing-fn\n :bar (fn [a b] ...)\n :baz (fn ([a]...) ([a b] ...)...)}\n BProtocol \n {...} \n ...)\n \n extend takes a type/class (or interface, see below), and one or more\n protocol + method map pairs. It will extend the polymorphism of the\n protocol's methods to call the supplied methods when an AType is\n provided as the first argument. \n\n Method maps are maps of the keyword-ized method names to ordinary\n fns. This facilitates easy reuse of existing fns and fn maps, for\n code reuse/mixins without derivation or composition. You can extend\n an interface to a protocol. This is primarily to facilitate interop\n with the host (e.g. Java) but opens the door to incidental multiple\n inheritance of implementation since a class can inherit from more\n than one interface, both of which extend the protocol. It is TBD how\n to specify which impl to use. You can extend a protocol on nil.\n\n If you are supplying the definitions explicitly (i.e. not reusing\n exsting functions or mixin maps), you may find it more convenient to\n use the extend-type or extend-protocol macros.\n\n Note that multiple independent extend clauses can exist for the same\n type, not all protocols need be defined in a single extend call.\n\n See also:\n extends?, satisfies?, extenders", lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(116), lang.NewKeyword("end-line"), int(116))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var v4 any = lang.NewList(args[1:]...) - _ = v4 - var tmp5 any - { // let - // let binding "seq_262" - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("seq")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("partition")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.Apply(tmp11, []any{int64(2), v4}) - tmp13 := lang.Apply(tmp8, []any{tmp12}) - var v14 any = tmp13 - _ = v14 - // let binding "chunk_263" - var v15 any = nil - _ = v15 - // let binding "count_264" - var v16 any = int64(0) - _ = v16 - // let binding "i_265" - var v17 any = int64(0) - _ = v17 - for { - var tmp18 any - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("<")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, []any{v17, v16}) - if lang.IsTruthy(tmp22) { - var tmp23 any - { // let - // let binding "vec__266" - tmp24, _ := lang.FieldOrMethod(v15, "nth") - if reflect.TypeOf(tmp24).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) - } - tmp25 := lang.Apply(tmp24, []any{v17}) - var v26 any = tmp25 - _ = v26 - // let binding "proto" - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("nth")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{v26, int64(0), nil}) - var v31 any = tmp30 - _ = v31 - // let binding "mmap" - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("nth")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.Apply(tmp34, []any{v26, int64(1), nil}) - var v36 any = tmp35 - _ = v36 - var tmp37 any - tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp39 := tmp38.FindInternedVar(lang.NewSymbol("protocol?")) - if tmp39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) - } - tmp40 := tmp39.Get() - tmp41 := lang.Apply(tmp40, []any{v31}) - if lang.IsTruthy(tmp41) { - } else { - tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp43 := tmp42.FindInternedVar(lang.NewSymbol("str")) - if tmp43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) - } - tmp44 := tmp43.Get() - tmp45 := lang.Apply(tmp44, []any{v31, " is not a protocol"}) - tmp46 := lang.Apply(errors5.New, []any{tmp45}) - panic(tmp46) - } - _ = tmp37 - tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp48 := tmp47.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) - } - tmp49 := tmp48.Get() - var tmp50 lang.FnFunc - tmp50 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v51 := args[0] - _ = v51 - v52 := args[1] - _ = v52 - var tmp53 any - { // let - // let binding "vec__270" - var v54 any = v52 - _ = v54 - // let binding "k" - tmp55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp56 := tmp55.FindInternedVar(lang.NewSymbol("nth")) - if tmp56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp56))) - } - tmp57 := tmp56.Get() - tmp58 := lang.Apply(tmp57, []any{v54, int64(0), nil}) - var v59 any = tmp58 - _ = v59 - // let binding "v" - tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp61 := tmp60.FindInternedVar(lang.NewSymbol("nth")) - if tmp61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) - } - tmp62 := tmp61.Get() - tmp63 := lang.Apply(tmp62, []any{v54, int64(1), nil}) - var v64 any = tmp63 - _ = v64 - tmp65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp66 := tmp65.FindInternedVar(lang.NewSymbol("get-in")) - if tmp66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp66))) - } - tmp67 := tmp66.Get() - tmp68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp69 := tmp68.FindInternedVar(lang.NewSymbol("deref")) - if tmp69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp69))) - } - tmp70 := tmp69.Get() - tmp71 := lang.Apply(tmp70, []any{v31}) - tmp72 := lang.NewVector(lang.NewKeyword("multis"), v59) - tmp73 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(158), lang.NewKeyword("column"), int(33), lang.NewKeyword("end-line"), int(158), lang.NewKeyword("end-column"), int(43)) - tmp74, err := lang.WithMeta(tmp72, tmp73.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp75 := lang.Apply(tmp67, []any{tmp71, tmp74}) - var tmp76 lang.FnFunc - tmp76 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v77 := args[0] - _ = v77 - var v78 any = lang.NewList(args[1:]...) - _ = v78 - tmp79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp80 := tmp79.FindInternedVar(lang.NewSymbol("apply")) - if tmp80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp80))) - } - tmp81 := tmp80.Get() - tmp82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp83 := tmp82.FindInternedVar(lang.NewSymbol("cons")) - if tmp83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp83))) - } - tmp84 := tmp83.Get() - tmp85 := lang.Apply(tmp84, []any{v77, v78}) - tmp86 := lang.Apply(tmp81, []any{v64, tmp85}) - return tmp86 - } - }) - tmp77, _ := lang.FieldOrMethod(tmp75, "AddMethod") - if reflect.TypeOf(tmp77).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("AddMethod is not a function"))) - } - tmp78 := lang.Apply(tmp77, []any{v3, tmp76}) - tmp53 = tmp78 - } // end let - return tmp53 - }) - tmp51 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(156), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(160), lang.NewKeyword("end-column"), int(45)) - tmp52, err := lang.WithMeta(tmp50, tmp51.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp53 := lang.Apply(tmp49, []any{tmp52, nil, v36}) - _ = tmp53 - var tmp54 any = v14 - var tmp55 any = v15 - var tmp56 any = v16 - tmp58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp59 := tmp58.FindInternedVar(lang.NewSymbol("unchecked-inc")) - if tmp59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp59))) - } - tmp60 := tmp59.Get() - tmp61 := lang.Apply(tmp60, []any{v17}) - var tmp57 any = tmp61 - v14 = tmp54 - v15 = tmp55 - v16 = tmp56 - v17 = tmp57 - continue - } // end let - tmp18 = tmp23 - } else { - var tmp24 any - { // let - // let binding "temp__0__auto__" - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("seq")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.Apply(tmp27, []any{v14}) - var v29 any = tmp28 - _ = v29 - var tmp30 any - if lang.IsTruthy(v29) { - var tmp31 any - { // let - // let binding "seq_262" - var v32 any = v29 - _ = v32 - var tmp33 any - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("chunked-seq?")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.Apply(tmp36, []any{v32}) - if lang.IsTruthy(tmp37) { - var tmp38 any - { // let - // let binding "c__0__auto__" - tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp40 := tmp39.FindInternedVar(lang.NewSymbol("chunk-first")) - if tmp40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) - } - tmp41 := tmp40.Get() - tmp42 := lang.Apply(tmp41, []any{v32}) - var v43 any = tmp42 - _ = v43 - tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp46 := tmp45.FindInternedVar(lang.NewSymbol("chunk-rest")) - if tmp46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) - } - tmp47 := tmp46.Get() - tmp48 := lang.Apply(tmp47, []any{v32}) - var tmp44 any = tmp48 - var tmp49 any = v43 - tmp51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp52 := tmp51.FindInternedVar(lang.NewSymbol("int")) - if tmp52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp52))) - } - tmp53 := tmp52.Get() - tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp55 := tmp54.FindInternedVar(lang.NewSymbol("count")) - if tmp55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) - } - tmp56 := tmp55.Get() - tmp57 := lang.Apply(tmp56, []any{v43}) - tmp58 := lang.Apply(tmp53, []any{tmp57}) - var tmp50 any = tmp58 - tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp61 := tmp60.FindInternedVar(lang.NewSymbol("int")) - if tmp61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) - } - tmp62 := tmp61.Get() - tmp63 := lang.Apply(tmp62, []any{int64(0)}) - var tmp59 any = tmp63 - v14 = tmp44 - v15 = tmp49 - v16 = tmp50 - v17 = tmp59 - continue - } // end let - tmp33 = tmp38 - } else { - var tmp39 any - { // let - // let binding "vec__273" - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("first")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.Apply(tmp42, []any{v32}) - var v44 any = tmp43 - _ = v44 - // let binding "proto" - tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp46 := tmp45.FindInternedVar(lang.NewSymbol("nth")) - if tmp46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) - } - tmp47 := tmp46.Get() - tmp48 := lang.Apply(tmp47, []any{v44, int64(0), nil}) - var v49 any = tmp48 - _ = v49 - // let binding "mmap" - tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp51 := tmp50.FindInternedVar(lang.NewSymbol("nth")) - if tmp51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) - } - tmp52 := tmp51.Get() - tmp53 := lang.Apply(tmp52, []any{v44, int64(1), nil}) - var v54 any = tmp53 - _ = v54 - var tmp55 any - tmp56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp57 := tmp56.FindInternedVar(lang.NewSymbol("protocol?")) - if tmp57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp57))) - } - tmp58 := tmp57.Get() - tmp59 := lang.Apply(tmp58, []any{v49}) - if lang.IsTruthy(tmp59) { - } else { - tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp61 := tmp60.FindInternedVar(lang.NewSymbol("str")) - if tmp61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) - } - tmp62 := tmp61.Get() - tmp63 := lang.Apply(tmp62, []any{v49, " is not a protocol"}) - tmp64 := lang.Apply(errors5.New, []any{tmp63}) - panic(tmp64) - } - _ = tmp55 - tmp65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp66 := tmp65.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp66))) - } - tmp67 := tmp66.Get() - var tmp68 lang.FnFunc - tmp68 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v69 := args[0] - _ = v69 - v70 := args[1] - _ = v70 - var tmp71 any - { // let - // let binding "vec__277" - var v72 any = v70 - _ = v72 - // let binding "k" - tmp73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp74 := tmp73.FindInternedVar(lang.NewSymbol("nth")) - if tmp74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp74))) - } - tmp75 := tmp74.Get() - tmp76 := lang.Apply(tmp75, []any{v72, int64(0), nil}) - var v77 any = tmp76 - _ = v77 - // let binding "v" - tmp78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp79 := tmp78.FindInternedVar(lang.NewSymbol("nth")) - if tmp79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp79))) - } - tmp80 := tmp79.Get() - tmp81 := lang.Apply(tmp80, []any{v72, int64(1), nil}) - var v82 any = tmp81 - _ = v82 - tmp83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp84 := tmp83.FindInternedVar(lang.NewSymbol("get-in")) - if tmp84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp84))) - } - tmp85 := tmp84.Get() - tmp86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp87 := tmp86.FindInternedVar(lang.NewSymbol("deref")) - if tmp87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp87))) - } - tmp88 := tmp87.Get() - tmp89 := lang.Apply(tmp88, []any{v49}) - tmp90 := lang.NewVector(lang.NewKeyword("multis"), v77) - tmp91 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(158), lang.NewKeyword("column"), int(33), lang.NewKeyword("end-line"), int(158), lang.NewKeyword("end-column"), int(43)) - tmp92, err := lang.WithMeta(tmp90, tmp91.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp93 := lang.Apply(tmp85, []any{tmp89, tmp92}) - var tmp94 lang.FnFunc - tmp94 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v95 := args[0] - _ = v95 - var v96 any = lang.NewList(args[1:]...) - _ = v96 - tmp97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp98 := tmp97.FindInternedVar(lang.NewSymbol("apply")) - if tmp98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp98))) - } - tmp99 := tmp98.Get() - tmp100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp101 := tmp100.FindInternedVar(lang.NewSymbol("cons")) - if tmp101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp101))) - } - tmp102 := tmp101.Get() - tmp103 := lang.Apply(tmp102, []any{v95, v96}) - tmp104 := lang.Apply(tmp99, []any{v82, tmp103}) - return tmp104 - } - }) - tmp95, _ := lang.FieldOrMethod(tmp93, "AddMethod") - if reflect.TypeOf(tmp95).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("AddMethod is not a function"))) - } - tmp96 := lang.Apply(tmp95, []any{v3, tmp94}) - tmp71 = tmp96 - } // end let - return tmp71 - }) - tmp69 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(156), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(160), lang.NewKeyword("end-column"), int(45)) - tmp70, err := lang.WithMeta(tmp68, tmp69.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp71 := lang.Apply(tmp67, []any{tmp70, nil, v54}) - _ = tmp71 - tmp73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp74 := tmp73.FindInternedVar(lang.NewSymbol("next")) - if tmp74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp74))) - } - tmp75 := tmp74.Get() - tmp76 := lang.Apply(tmp75, []any{v32}) - var tmp72 any = tmp76 - var tmp77 any = nil - var tmp78 any = int64(0) - var tmp79 any = int64(0) - v14 = tmp72 - v15 = tmp77 - v16 = tmp78 - v17 = tmp79 - continue - } // end let - tmp33 = tmp39 - } - tmp31 = tmp33 - } // end let - tmp30 = tmp31 - } else { - } - tmp24 = tmp30 - } // end let - tmp18 = tmp24 - } - tmp5 = tmp18 - break - } - } // end let - return tmp5 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // extend-protocol - { - tmp0 := lang.NewSymbol("extend-protocol").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("p"), lang.NewSymbol("&"), lang.NewSymbol("specs"))), lang.NewKeyword("doc"), "Useful when you want to provide several implementations of the same\n protocol all at once. Takes a single protocol and the implementation\n of that protocol for one or more types.\n\n (extend-protocol Protocol\n AType\n (foo [x] ...)\n (bar [x y] ...)\n BType\n (foo [x] ...)\n (bar [x y] ...)\n AClass\n (foo [x] ...)\n (bar [x y] ...)\n nil\n (foo [x] ...)\n (bar [x y] ...))\n\n expands into:\n\n (do\n (clojure.core/extend-type AType Protocol \n (foo [x] ...) \n (bar [x y] ...))\n (clojure.core/extend-type BType Protocol \n (foo [x] ...) \n (bar [x y] ...))\n (clojure.core/extend-type AClass Protocol \n (foo [x] ...) \n (bar [x y] ...))\n (clojure.core/extend-type nil Protocol \n (foo [x] ...) \n (bar [x y] ...)))", lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(212), lang.NewKeyword("end-line"), int(212))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("emit-extend-protocol")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp9, []any{v5, v6}) - return tmp10 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // extend-type - { - tmp0 := lang.NewSymbol("extend-type").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("t"), lang.NewSymbol("&"), lang.NewSymbol("specs"))), lang.NewKeyword("doc"), "A macro that expands into an extend call. Useful when you are\n supplying the definitions explicitly inline, extend-type\n automatically creates the maps required by extend. Propagates the\n class as a type hint on the first argument of all fns.\n\n (extend-type MyType \n Countable\n (cnt [c] ...)\n Foo\n (bar [x y] ...)\n (baz ([x] ...) ([x y & zs] ...)))\n\n expands into:\n\n (extend MyType\n Countable\n {:cnt (fn [c] ...)}\n Foo\n {:baz (fn ([x] ...) ([x y & zs] ...))\n :bar (fn [x y] ...)})", lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(180), lang.NewKeyword("end-line"), int(180))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("emit-extend-type")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp9, []any{v5, v6}) - return tmp10 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // false? - { - tmp1 := reflect.TypeOf(false) - tmp0 := lang.NewSymbol("false?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is the value false, false otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(504), lang.NewKeyword("end-line"), int(504))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5 := lang.Apply(lang.Identical, []any{v4, false}) - return tmp5 - }) - tmp4 := reflect.TypeOf(false) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // ffirst - { - tmp0 := lang.NewSymbol("ffirst").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Same as (first (first x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(98), lang.NewKeyword("end-line"), int(102))).(*lang.Symbol) - var tmp2 lang.FnFunc - { // function ffirst - var v3 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("first")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("first")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v4}) - tmp12 := lang.Apply(tmp7, []any{tmp11}) - return tmp12 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(102), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(102), lang.NewKeyword("end-column"), int(50))).(lang.FnFunc) - v3 = tmp2 - _ = v3 - } - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // file-seq - { - tmp0 := lang.NewSymbol("file-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("dir"))), lang.NewKeyword("doc"), "A tree seq on java.io.Files", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4972), lang.NewKeyword("end-line"), int(4972))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("tree-seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - var tmp7 lang.FnFunc - tmp7 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v8 := args[0] - _ = v8 - tmp9, _ := lang.FieldOrMethod(v8, "isDirectory") - if reflect.TypeOf(tmp9).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("isDirectory is not a function"))) - } - tmp10 := lang.Apply(tmp9, []any{}) - return tmp10 - }) - tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4978), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(4978), lang.NewKeyword("end-column"), int(47)) - tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var tmp10 lang.FnFunc - tmp10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v11 := args[0] - _ = v11 - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("seq")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15, _ := lang.FieldOrMethod(v11, "listFiles") - if reflect.TypeOf(tmp15).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("listFiles is not a function"))) - } - tmp16 := lang.Apply(tmp15, []any{}) - tmp17 := lang.Apply(tmp14, []any{tmp16}) - return tmp17 - }) - tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4979), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(4979), lang.NewKeyword("end-column"), int(51)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp13 := lang.Apply(tmp6, []any{tmp9, tmp12, v3}) - return tmp13 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // filter - { - tmp0 := lang.NewSymbol("filter").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred")), lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the items in coll for which\n (pred item) returns logical true. pred must be free of side-effects.\n Returns a transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2785), lang.NewKeyword("end-line"), int(2785))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v5 := args[0] - _ = v5 - var tmp6 lang.FnFunc - tmp6 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp7 := lang.Apply(v5, nil) - return tmp7 - case 1: - v7 := args[0] - _ = v7 - tmp8 := lang.Apply(v5, []any{v7}) - return tmp8 - case 2: - v7 := args[0] - _ = v7 - v8 := args[1] - _ = v8 - var tmp9 any - tmp10 := lang.Apply(v3, []any{v8}) - if lang.IsTruthy(tmp10) { - tmp11 := lang.Apply(v5, []any{v7, v8}) - tmp9 = tmp11 - } else { - tmp9 = v7 - } - return tmp9 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2793), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(2799), lang.NewKeyword("end-column"), int(22)) - tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp8 - }) - tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2792), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2799), lang.NewKeyword("end-column"), int(23)) - tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp6 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 lang.FnFunc - tmp5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var tmp6 any - { // let - // let binding "temp__0__auto__" - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("seq")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp9, []any{v4}) - var v11 any = tmp10 - _ = v11 - var tmp12 any - if lang.IsTruthy(v11) { - var tmp13 any - { // let - // let binding "s" - var v14 any = v11 - _ = v14 - var tmp15 any - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("chunked-seq?")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{v14}) - if lang.IsTruthy(tmp19) { - var tmp20 any - { // let - // let binding "c" - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("chunk-first")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.Apply(tmp23, []any{v14}) - var v25 any = tmp24 - _ = v25 - // let binding "size" - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("count")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.Apply(tmp28, []any{v25}) - var v30 any = tmp29 - _ = v30 - // let binding "b" - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("chunk-buffer")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{v30}) - var v35 any = tmp34 - _ = v35 - var tmp36 any - { // let - // let binding "n__0__auto__" - tmp37 := lang.Apply(lang.LongCast, []any{v30}) - var v38 any = tmp37 - _ = v38 - var tmp39 any - { // let - // let binding "i" - var v40 any = int64(0) - _ = v40 - for { - var tmp41 any - tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp43 := tmp42.FindInternedVar(lang.NewSymbol("<")) - if tmp43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) - } - tmp44 := tmp43.Get() - tmp45 := lang.Apply(tmp44, []any{v40, v38}) - if lang.IsTruthy(tmp45) { - var tmp46 any - { // let - // let binding "v" - tmp47, _ := lang.FieldOrMethod(v25, "nth") - if reflect.TypeOf(tmp47).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) - } - tmp48 := lang.Apply(tmp47, []any{v40}) - var v49 any = tmp48 - _ = v49 - var tmp50 any - tmp51 := lang.Apply(v3, []any{v49}) - if lang.IsTruthy(tmp51) { - tmp52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp53 := tmp52.FindInternedVar(lang.NewSymbol("chunk-append")) - if tmp53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp53))) - } - tmp54 := tmp53.Get() - tmp55 := lang.Apply(tmp54, []any{v35, v49}) - tmp50 = tmp55 - } else { - } - tmp46 = tmp50 - } // end let - _ = tmp46 - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("unchecked-inc")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v40}) - var tmp47 any = tmp51 - v40 = tmp47 - continue - } else { - } - tmp39 = tmp41 - break - } - } // end let - tmp36 = tmp39 - } // end let - _ = tmp36 - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("chunk-cons")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("chunk")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.Apply(tmp42, []any{v35}) - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("filter")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp48 := tmp47.FindInternedVar(lang.NewSymbol("chunk-rest")) - if tmp48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) - } - tmp49 := tmp48.Get() - tmp50 := lang.Apply(tmp49, []any{v14}) - tmp51 := lang.Apply(tmp46, []any{v3, tmp50}) - tmp52 := lang.Apply(tmp39, []any{tmp43, tmp51}) - tmp20 = tmp52 - } // end let - tmp15 = tmp20 - } else { - var tmp21 any - { // let - // let binding "f" - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("first")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.Apply(tmp24, []any{v14}) - var v26 any = tmp25 - _ = v26 - // let binding "r" - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("rest")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{v14}) - var v31 any = tmp30 - _ = v31 - var tmp32 any - tmp33 := lang.Apply(v3, []any{v26}) - if lang.IsTruthy(tmp33) { - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("cons")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("filter")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.Apply(tmp39, []any{v3, v31}) - tmp41 := lang.Apply(tmp36, []any{v26, tmp40}) - tmp32 = tmp41 - } else { - tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp43 := tmp42.FindInternedVar(lang.NewSymbol("filter")) - if tmp43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) - } - tmp44 := tmp43.Get() - tmp45 := lang.Apply(tmp44, []any{v3, v31}) - tmp32 = tmp45 - } - tmp21 = tmp32 - } // end let - tmp15 = tmp21 - } - tmp13 = tmp15 - } // end let - tmp12 = tmp13 - } else { - } - tmp6 = tmp12 - } // end let - return tmp6 - }) - tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) - return tmp6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // filter-key - { - tmp0 := lang.NewSymbol("filter-key").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("keyfn"), lang.NewSymbol("pred"), lang.NewSymbol("amap"))), lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4115), lang.NewKeyword("end-line"), int(4117), lang.NewKeyword("private"), true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var tmp6 any - { // let - // let binding "ret" - tmp7 := lang.NewMap() - tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4118), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(4118), lang.NewKeyword("end-column"), int(17)) - tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v10 any = tmp9 - _ = v10 - // let binding "es" - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("seq")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{v5}) - var v15 any = tmp14 - _ = v15 - for { - var tmp16 any - if lang.IsTruthy(v15) { - var tmp17 any - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("first")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.Apply(tmp20, []any{v15}) - tmp22 := lang.Apply(v3, []any{tmp21}) - tmp23 := lang.Apply(v4, []any{tmp22}) - if lang.IsTruthy(tmp23) { - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("assoc")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("key")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("first")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{v15}) - tmp35 := lang.Apply(tmp30, []any{tmp34}) - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("val")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp40 := tmp39.FindInternedVar(lang.NewSymbol("first")) - if tmp40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) - } - tmp41 := tmp40.Get() - tmp42 := lang.Apply(tmp41, []any{v15}) - tmp43 := lang.Apply(tmp38, []any{tmp42}) - tmp44 := lang.Apply(tmp27, []any{v10, tmp35, tmp43}) - var tmp24 any = tmp44 - tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp47 := tmp46.FindInternedVar(lang.NewSymbol("next")) - if tmp47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) - } - tmp48 := tmp47.Get() - tmp49 := lang.Apply(tmp48, []any{v15}) - var tmp45 any = tmp49 - v10 = tmp24 - v15 = tmp45 - continue - } else { - var tmp50 any = v10 - tmp52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp53 := tmp52.FindInternedVar(lang.NewSymbol("next")) - if tmp53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp53))) - } - tmp54 := tmp53.Get() - tmp55 := lang.Apply(tmp54, []any{v15}) - var tmp51 any = tmp55 - v10 = tmp50 - v15 = tmp51 - continue - } - tmp16 = tmp17 - } else { - tmp16 = v10 - } - tmp6 = tmp16 - break - } - } // end let - return tmp6 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // filterv - { - tmp0 := lang.NewSymbol("filterv").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a vector of the items in coll for which\n (pred item) returns logical true. pred must be free of side-effects.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6961), lang.NewKeyword("end-line"), int(6961))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("persistent!")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("reduce")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - var tmp11 lang.FnFunc - tmp11 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v12 := args[0] - _ = v12 - v13 := args[1] - _ = v13 - var tmp14 any - tmp15 := lang.Apply(v3, []any{v13}) - if lang.IsTruthy(tmp15) { - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("conj!")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{v12, v13}) - tmp14 = tmp19 - } else { - tmp14 = v12 - } - return tmp14 - }) - tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6967), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(6967), lang.NewKeyword("end-column"), int(52)) - tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("transient")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.NewVector() - tmp18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6968), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(6968), lang.NewKeyword("end-column"), int(27)) - tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp20 := lang.Apply(tmp16, []any{tmp19}) - tmp21 := lang.Apply(tmp10, []any{tmp13, tmp20, v4}) - tmp22 := lang.Apply(tmp7, []any{tmp21}) - return tmp22 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // find - { - tmp0 := lang.NewSymbol("find").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"))), lang.NewKeyword("doc"), "Returns the map entry for key, or nil if key not present.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1530), lang.NewKeyword("end-line"), int(1530))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5, _ := lang.FieldOrMethod(runtime4.RT, "Find") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Find is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v3, v4}) - return tmp6 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // find-keyword - { - tmp1 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() - tmp0 := lang.NewSymbol("find-keyword").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name"))), lang.NewKeyword("doc"), "Returns a Keyword with the given namespace and name if one already\n exists. This function will not intern a new keyword. If the keyword\n has not already been interned, it will return nil. Do not use :\n in the keyword strings, it will be added automatically.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(618), lang.NewKeyword("end-line"), int(618))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v4 := args[0] - _ = v4 - var tmp5 any - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("keyword?")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(tmp8, []any{v4}) - if lang.IsTruthy(tmp9) { - tmp5 = v4 - } else { - var tmp10 any - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("symbol?")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{v4}) - if lang.IsTruthy(tmp14) { - tmp15 := lang.Apply(nil, []any{v4}) - tmp10 = tmp15 - } else { - var tmp16 any - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("string?")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.Apply(tmp19, []any{v4}) - if lang.IsTruthy(tmp20) { - tmp21 := lang.Apply(nil, []any{v4}) - tmp16 = tmp21 - } else { - } - tmp10 = tmp16 - } - tmp5 = tmp10 - } - return tmp5 - case 2: - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6 := lang.Apply(nil, []any{v4, v5}) - return tmp6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp4 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // find-ns - { - tmp0 := lang.NewSymbol("find-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Returns the namespace named by the symbol or nil if it doesn't exist.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4125), lang.NewKeyword("end-line"), int(4125))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.Apply(lang.FindNamespace, []any{v3}) - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // find-var - { - tmp0 := lang.NewSymbol("find-var").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Returns the global var named by the namespace-qualified symbol, or\n nil if no var with that name.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2013), lang.NewKeyword("end-line"), int(2013))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4, _ := lang.FieldOrMethod(runtime4.RT, "FindVar") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("FindVar is not a function"))) - } - tmp5 := lang.Apply(tmp4, []any{v3}) - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // first - { - tmp0 := lang.NewSymbol("first").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns the first item in the collection. Calls seq on its\n argument. If coll is nil, returns nil.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(47), lang.NewKeyword("end-line"), int(52))).(*lang.Symbol) - var tmp2 lang.FnFunc - { // function first - var v3 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5 := lang.Apply(lang.First, []any{v4}) - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(52), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(52), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) - v3 = tmp2 - _ = v3 - } - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // fits-table? - { - tmp0 := lang.NewSymbol("fits-table?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ints"))), lang.NewKeyword("doc"), "Returns true if the collection of ints can fit within the\n max-table-switch-size, false otherwise.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6625), lang.NewKeyword("end-line"), int(6625), lang.NewKeyword("private"), true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("<")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("-")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("apply")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("max")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("seq")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{v3}) - tmp20 := lang.Apply(tmp12, []any{tmp15, tmp19}) - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("apply")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("min")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("seq")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{v3}) - tmp31 := lang.Apply(tmp23, []any{tmp26, tmp30}) - tmp32 := lang.Apply(tmp9, []any{tmp20, tmp31}) - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("max-switch-table-size")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.Apply(tmp6, []any{tmp32, tmp35}) - return tmp36 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // flatten - { - tmp0 := lang.NewSymbol("flatten").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Takes any nested combination of sequential things (lists, vectors,\n etc.) and returns their contents as a single, flat lazy sequence.\n (flatten nil) returns an empty sequence.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7118), lang.NewKeyword("end-line"), int(7118))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("filter")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("complement")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("sequential?")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp9, []any{tmp12}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("rest")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("tree-seq")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("sequential?")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("seq")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.Apply(tmp19, []any{tmp22, tmp25, v3}) - tmp27 := lang.Apply(tmp16, []any{tmp26}) - tmp28 := lang.Apply(tmp6, []any{tmp13, tmp27}) - return tmp28 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // float - { - var tmp1 lang.FnFunc - { // function float__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - var tmp30 any - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - if lang.IsTruthy(tmp33) { - tmp30 = lang.NewSymbol("uncheckedFloatCast") - } else { - tmp30 = lang.NewSymbol("floatCast") - } - tmp34 := lang.Apply(tmp29, []any{tmp30}) - tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp36 := tmp35.FindInternedVar(lang.NewSymbol("list")) - if tmp36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) - } - tmp37 := tmp36.Get() - tmp38 := lang.Apply(tmp37, []any{v3}) - tmp39 := lang.Apply(tmp26, []any{tmp34, tmp38}) - tmp40 := lang.Apply(tmp23, []any{tmp39}) - tmp41 := lang.Apply(tmp20, []any{tmp40}) - tmp42 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp41}) - tmp43 := lang.Apply(tmp6, []any{tmp42}) - return tmp43 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("float").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to float", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3487), lang.NewKeyword("end-line"), int(3487))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5 := lang.Apply(lang.FloatCast, []any{v4}) - return tmp5 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // float-array - { - var tmp1 lang.FnFunc - { // function float-array__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var v3 any = lang.NewList(args[0:]...) - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.Apply(tmp20, []any{lang.NewSymbol("glojure.core/FloatArray")}) - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("list")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("seq")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("concat")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) - tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp36 := tmp35.FindInternedVar(lang.NewSymbol("list")) - if tmp36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) - } - tmp37 := tmp36.Get() - tmp38 := lang.Apply(tmp37, []any{lang.NewSymbol("glojure.core/args")}) - tmp39 := lang.Apply(tmp30, []any{tmp34, tmp38}) - tmp40 := lang.Apply(tmp27, []any{tmp39}) - tmp41 := lang.Apply(tmp24, []any{tmp40}) - tmp42 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp21, tmp41}) - tmp43 := lang.Apply(tmp6, []any{tmp42}) - return tmp43 - } - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("float-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Creates an array of floats", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5301), lang.NewKeyword("end-line"), int(5301))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "FloatArray") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("FloatArray is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - case 2: - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "FloatArrayInit") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("FloatArrayInit is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // float? - { - tmp0 := lang.NewSymbol("float?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is a floating point number", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3605), lang.NewKeyword("end-line"), int(3605))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "or__0__auto__" - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("instance?")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{lang.Builtins["float64"], v3}) - var v9 any = tmp8 - _ = v9 - var tmp10 any - if lang.IsTruthy(v9) { - tmp10 = v9 - } else { - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("instance?")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{lang.Builtins["float32"], v3}) - tmp10 = tmp14 - } - tmp4 = tmp10 - } // end let - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // floats - { - var tmp1 lang.FnFunc - { // function floats - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.Apply(tmp20, []any{lang.NewSymbol("glojure.core/Floats")}) - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("list")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.Apply(tmp24, []any{v3}) - tmp26 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp21, tmp25}) - tmp27 := lang.Apply(tmp6, []any{tmp26}) - return tmp27 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("floats").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Casts to float[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5392), lang.NewKeyword("end-line"), int(5392))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Floats") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Floats is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // flush - { - tmp0 := lang.NewSymbol("flush").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Flushes the output stream that is the current value of\n *out*", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3706), lang.NewKeyword("end-line"), int(3706))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - tmp3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp4 := tmp3.FindInternedVar(lang.NewSymbol("*out*")) - if tmp4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp4))) - } - tmp5 := tmp4.Get() - tmp6, _ := lang.FieldOrMethod(tmp5, "Sync") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Sync is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{}) - _ = tmp7 - return nil - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // fn - { - tmp0 := lang.NewSymbol("fn").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("sigs"))), lang.NewKeyword("doc"), "params => positional-params*, or positional-params* & rest-param\n positional-param => binding-form\n rest-param => binding-form\n binding-form => name, or destructuring-form\n\n Defines a function.\n\n See https://glojure.org/reference/special_forms#fn for more information", lang.NewKeyword("forms"), lang.NewVector(lang.NewList(lang.NewSymbol("fn"), lang.NewSymbol("name?"), lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("exprs*")), lang.NewList(lang.NewSymbol("fn"), lang.NewSymbol("name?"), lang.NewList(lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("exprs*")), lang.NewSymbol("+"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4533), lang.NewKeyword("end-line"), int(4533), lang.NewKeyword("special-form"), true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - var tmp6 any - { // let - // let binding "name" - var tmp7 any - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("symbol?")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("first")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{v5}) - tmp15 := lang.Apply(tmp10, []any{tmp14}) - if lang.IsTruthy(tmp15) { - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("first")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{v5}) - tmp7 = tmp19 - } else { - } - var v20 any = tmp7 - _ = v20 - // let binding "sigs" - var tmp21 any - if lang.IsTruthy(v20) { - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("next")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.Apply(tmp24, []any{v5}) - tmp21 = tmp25 - } else { - tmp21 = v5 - } - var v26 any = tmp21 - _ = v26 - // let binding "sigs" - var tmp27 any - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("vector?")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("first")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{v26}) - tmp35 := lang.Apply(tmp30, []any{tmp34}) - if lang.IsTruthy(tmp35) { - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{v26}) - tmp27 = tmp39 - } else { - var tmp40 any - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("seq?")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("first")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.Apply(tmp46, []any{v26}) - tmp48 := lang.Apply(tmp43, []any{tmp47}) - if lang.IsTruthy(tmp48) { - tmp40 = v26 - } else { - var tmp49 any - tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp51 := tmp50.FindInternedVar(lang.NewSymbol("seq")) - if tmp51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) - } - tmp52 := tmp51.Get() - tmp53 := lang.Apply(tmp52, []any{v26}) - if lang.IsTruthy(tmp53) { - tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp55 := tmp54.FindInternedVar(lang.NewSymbol("str")) - if tmp55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) - } - tmp56 := tmp55.Get() - tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp58 := tmp57.FindInternedVar(lang.NewSymbol("first")) - if tmp58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) - } - tmp59 := tmp58.Get() - tmp60 := lang.Apply(tmp59, []any{v26}) - tmp61 := lang.Apply(tmp56, []any{"Parameter declaration ", tmp60, " should be a vector"}) - tmp49 = tmp61 - } else { - tmp62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp63 := tmp62.FindInternedVar(lang.NewSymbol("str")) - if tmp63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp63))) - } - tmp64 := tmp63.Get() - tmp65 := lang.Apply(tmp64, []any{"Parameter declaration missing"}) - tmp49 = tmp65 - } - tmp66 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp49}) - panic(tmp66) - } - tmp27 = tmp40 - } - var v67 any = tmp27 - _ = v67 - // let binding "psig" - var tmp68 lang.FnFunc - tmp68 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v69 := args[0] - _ = v69 - var tmp70 any - tmp71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp72 := tmp71.FindInternedVar(lang.NewSymbol("not")) - if tmp72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp72))) - } - tmp73 := tmp72.Get() - tmp74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp75 := tmp74.FindInternedVar(lang.NewSymbol("seq?")) - if tmp75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp75))) - } - tmp76 := tmp75.Get() - tmp77 := lang.Apply(tmp76, []any{v69}) - tmp78 := lang.Apply(tmp73, []any{tmp77}) - if lang.IsTruthy(tmp78) { - tmp79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp80 := tmp79.FindInternedVar(lang.NewSymbol("str")) - if tmp80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp80))) - } - tmp81 := tmp80.Get() - tmp82 := lang.Apply(tmp81, []any{"Invalid signature ", v69, " should be a list"}) - tmp83 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp82}) - panic(tmp83) - } else { - } - _ = tmp70 - var tmp84 any - { // let - // let binding "vec__13" - var v85 any = v69 - _ = v85 - // let binding "seq__14" - tmp86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp87 := tmp86.FindInternedVar(lang.NewSymbol("seq")) - if tmp87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp87))) - } - tmp88 := tmp87.Get() - tmp89 := lang.Apply(tmp88, []any{v85}) - var v90 any = tmp89 - _ = v90 - // let binding "first__15" - tmp91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp92 := tmp91.FindInternedVar(lang.NewSymbol("first")) - if tmp92.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp92))) - } - tmp93 := tmp92.Get() - tmp94 := lang.Apply(tmp93, []any{v90}) - var v95 any = tmp94 - _ = v95 - // let binding "seq__14" - tmp96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp97 := tmp96.FindInternedVar(lang.NewSymbol("next")) - if tmp97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp97))) - } - tmp98 := tmp97.Get() - tmp99 := lang.Apply(tmp98, []any{v90}) - var v100 any = tmp99 - _ = v100 - // let binding "params" - var v101 any = v95 - _ = v101 - // let binding "body" - var v102 any = v100 - _ = v102 - // let binding "_" - var tmp103 any - tmp104 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp105 := tmp104.FindInternedVar(lang.NewSymbol("not")) - if tmp105.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp105))) - } - tmp106 := tmp105.Get() - tmp107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp108 := tmp107.FindInternedVar(lang.NewSymbol("vector?")) - if tmp108.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp108))) - } - tmp109 := tmp108.Get() - tmp110 := lang.Apply(tmp109, []any{v101}) - tmp111 := lang.Apply(tmp106, []any{tmp110}) - if lang.IsTruthy(tmp111) { - var tmp112 any - tmp113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp114 := tmp113.FindInternedVar(lang.NewSymbol("seq?")) - if tmp114.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp114))) - } - tmp115 := tmp114.Get() - tmp116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp117 := tmp116.FindInternedVar(lang.NewSymbol("first")) - if tmp117.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp117))) - } - tmp118 := tmp117.Get() - tmp119 := lang.Apply(tmp118, []any{v67}) - tmp120 := lang.Apply(tmp115, []any{tmp119}) - if lang.IsTruthy(tmp120) { - tmp121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp122 := tmp121.FindInternedVar(lang.NewSymbol("str")) - if tmp122.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp122))) - } - tmp123 := tmp122.Get() - tmp124 := lang.Apply(tmp123, []any{"Parameter declaration ", v101, " should be a vector"}) - tmp112 = tmp124 - } else { - tmp125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp126 := tmp125.FindInternedVar(lang.NewSymbol("str")) - if tmp126.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp126))) - } - tmp127 := tmp126.Get() - tmp128 := lang.Apply(tmp127, []any{"Invalid signature ", v69, " should be a list"}) - tmp112 = tmp128 - } - tmp129 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp112}) - panic(tmp129) - } else { - } - var v130 any = tmp103 - _ = v130 - // let binding "conds" - var tmp131 any - var tmp132 any - { // let - // let binding "and__0__auto__" - tmp133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp134 := tmp133.FindInternedVar(lang.NewSymbol("next")) - if tmp134.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp134))) - } - tmp135 := tmp134.Get() - tmp136 := lang.Apply(tmp135, []any{v102}) - var v137 any = tmp136 - _ = v137 - var tmp138 any - if lang.IsTruthy(v137) { - tmp139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp140 := tmp139.FindInternedVar(lang.NewSymbol("map?")) - if tmp140.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp140))) - } - tmp141 := tmp140.Get() - tmp142 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp143 := tmp142.FindInternedVar(lang.NewSymbol("first")) - if tmp143.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp143))) - } - tmp144 := tmp143.Get() - tmp145 := lang.Apply(tmp144, []any{v102}) - tmp146 := lang.Apply(tmp141, []any{tmp145}) - tmp138 = tmp146 - } else { - tmp138 = v137 - } - tmp132 = tmp138 - } // end let - if lang.IsTruthy(tmp132) { - tmp133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp134 := tmp133.FindInternedVar(lang.NewSymbol("first")) - if tmp134.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp134))) - } - tmp135 := tmp134.Get() - tmp136 := lang.Apply(tmp135, []any{v102}) - tmp131 = tmp136 - } else { - } - var v137 any = tmp131 - _ = v137 - // let binding "body" - var tmp138 any - if lang.IsTruthy(v137) { - tmp139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp140 := tmp139.FindInternedVar(lang.NewSymbol("next")) - if tmp140.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp140))) - } - tmp141 := tmp140.Get() - tmp142 := lang.Apply(tmp141, []any{v102}) - tmp138 = tmp142 - } else { - tmp138 = v102 - } - var v143 any = tmp138 - _ = v143 - // let binding "conds" - var tmp144 any - { // let - // let binding "or__0__auto__" - var v145 any = v137 - _ = v145 - var tmp146 any - if lang.IsTruthy(v145) { - tmp146 = v145 - } else { - tmp147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp148 := tmp147.FindInternedVar(lang.NewSymbol("meta")) - if tmp148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp148))) - } - tmp149 := tmp148.Get() - tmp150 := lang.Apply(tmp149, []any{v101}) - tmp146 = tmp150 - } - tmp144 = tmp146 - } // end let - var v145 any = tmp144 - _ = v145 - // let binding "pre" - tmp146 := lang.Apply(lang.NewKeyword("pre"), []any{v145}) - var v147 any = tmp146 - _ = v147 - // let binding "post" - tmp148 := lang.Apply(lang.NewKeyword("post"), []any{v145}) - var v149 any = tmp148 - _ = v149 - // let binding "body" - var tmp150 any - if lang.IsTruthy(v149) { - tmp151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp152 := tmp151.FindInternedVar(lang.NewSymbol("seq")) - if tmp152.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp152))) - } - tmp153 := tmp152.Get() - tmp154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp155 := tmp154.FindInternedVar(lang.NewSymbol("concat")) - if tmp155.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp155))) - } - tmp156 := tmp155.Get() - tmp157 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp158 := tmp157.FindInternedVar(lang.NewSymbol("list")) - if tmp158.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp158))) - } - tmp159 := tmp158.Get() - tmp160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp161 := tmp160.FindInternedVar(lang.NewSymbol("seq")) - if tmp161.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp161))) - } - tmp162 := tmp161.Get() - tmp163 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp164 := tmp163.FindInternedVar(lang.NewSymbol("concat")) - if tmp164.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp164))) - } - tmp165 := tmp164.Get() - tmp166 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp167 := tmp166.FindInternedVar(lang.NewSymbol("list")) - if tmp167.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp167))) - } - tmp168 := tmp167.Get() - tmp169 := lang.Apply(tmp168, []any{lang.NewSymbol("glojure.core/let")}) - tmp170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp171 := tmp170.FindInternedVar(lang.NewSymbol("list")) - if tmp171.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp171))) - } - tmp172 := tmp171.Get() - tmp173 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp174 := tmp173.FindInternedVar(lang.NewSymbol("apply")) - if tmp174.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp174))) - } - tmp175 := tmp174.Get() - tmp176 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp177 := tmp176.FindInternedVar(lang.NewSymbol("vector")) - if tmp177.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp177))) - } - tmp178 := tmp177.Get() - tmp179 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp180 := tmp179.FindInternedVar(lang.NewSymbol("seq")) - if tmp180.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp180))) - } - tmp181 := tmp180.Get() - tmp182 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp183 := tmp182.FindInternedVar(lang.NewSymbol("concat")) - if tmp183.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp183))) - } - tmp184 := tmp183.Get() - tmp185 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp186 := tmp185.FindInternedVar(lang.NewSymbol("list")) - if tmp186.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp186))) - } - tmp187 := tmp186.Get() - tmp188 := lang.Apply(tmp187, []any{lang.NewSymbol("%")}) - tmp189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp190 := tmp189.FindInternedVar(lang.NewSymbol("list")) - if tmp190.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp190))) - } - tmp191 := tmp190.Get() - var tmp192 any - tmp193 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp194 := tmp193.FindInternedVar(lang.NewSymbol("<")) - if tmp194.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp194))) - } - tmp195 := tmp194.Get() - tmp196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp197 := tmp196.FindInternedVar(lang.NewSymbol("count")) - if tmp197.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp197))) - } - tmp198 := tmp197.Get() - tmp199 := lang.Apply(tmp198, []any{v143}) - tmp200 := lang.Apply(tmp195, []any{int64(1), tmp199}) - if lang.IsTruthy(tmp200) { - tmp201 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp202 := tmp201.FindInternedVar(lang.NewSymbol("seq")) - if tmp202.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp202))) - } - tmp203 := tmp202.Get() - tmp204 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp205 := tmp204.FindInternedVar(lang.NewSymbol("concat")) - if tmp205.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp205))) - } - tmp206 := tmp205.Get() - tmp207 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp208 := tmp207.FindInternedVar(lang.NewSymbol("list")) - if tmp208.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp208))) - } - tmp209 := tmp208.Get() - tmp210 := lang.Apply(tmp209, []any{lang.NewSymbol("do")}) - tmp211 := lang.Apply(tmp206, []any{tmp210, v143}) - tmp212 := lang.Apply(tmp203, []any{tmp211}) - tmp192 = tmp212 - } else { - tmp213 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp214 := tmp213.FindInternedVar(lang.NewSymbol("first")) - if tmp214.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp214))) - } - tmp215 := tmp214.Get() - tmp216 := lang.Apply(tmp215, []any{v143}) - tmp192 = tmp216 - } - tmp217 := lang.Apply(tmp191, []any{tmp192}) - tmp218 := lang.Apply(tmp184, []any{tmp188, tmp217}) - tmp219 := lang.Apply(tmp181, []any{tmp218}) - tmp220 := lang.Apply(tmp175, []any{tmp178, tmp219}) - tmp221 := lang.Apply(tmp172, []any{tmp220}) - tmp222 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp223 := tmp222.FindInternedVar(lang.NewSymbol("map")) - if tmp223.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp223))) - } - tmp224 := tmp223.Get() - var tmp225 lang.FnFunc - tmp225 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v226 := args[0] - _ = v226 - tmp227 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp228 := tmp227.FindInternedVar(lang.NewSymbol("seq")) - if tmp228.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp228))) - } - tmp229 := tmp228.Get() - tmp230 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp231 := tmp230.FindInternedVar(lang.NewSymbol("concat")) - if tmp231.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp231))) - } - tmp232 := tmp231.Get() - tmp233 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp234 := tmp233.FindInternedVar(lang.NewSymbol("list")) - if tmp234.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp234))) - } - tmp235 := tmp234.Get() - tmp236 := lang.Apply(tmp235, []any{lang.NewSymbol("glojure.core/assert")}) - tmp237 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp238 := tmp237.FindInternedVar(lang.NewSymbol("list")) - if tmp238.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp238))) - } - tmp239 := tmp238.Get() - tmp240 := lang.Apply(tmp239, []any{v226}) - tmp241 := lang.Apply(tmp232, []any{tmp236, tmp240}) - tmp242 := lang.Apply(tmp229, []any{tmp241}) - return tmp242 - }) - tmp226 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4582), lang.NewKeyword("column"), int(41), lang.NewKeyword("end-line"), int(4582), lang.NewKeyword("end-column"), int(62)) - tmp227, err := lang.WithMeta(tmp225, tmp226.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp228 := lang.Apply(tmp224, []any{tmp227, v149}) - tmp229 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp230 := tmp229.FindInternedVar(lang.NewSymbol("list")) - if tmp230.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp230))) - } - tmp231 := tmp230.Get() - tmp232 := lang.Apply(tmp231, []any{lang.NewSymbol("%")}) - tmp233 := lang.Apply(tmp165, []any{tmp169, tmp221, tmp228, tmp232}) - tmp234 := lang.Apply(tmp162, []any{tmp233}) - tmp235 := lang.Apply(tmp159, []any{tmp234}) - tmp236 := lang.Apply(tmp156, []any{tmp235}) - tmp237 := lang.Apply(tmp153, []any{tmp236}) - tmp150 = tmp237 - } else { - tmp150 = v143 - } - var v238 any = tmp150 - _ = v238 - // let binding "body" - var tmp239 any - if lang.IsTruthy(v147) { - tmp240 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp241 := tmp240.FindInternedVar(lang.NewSymbol("concat")) - if tmp241.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp241))) - } - tmp242 := tmp241.Get() - tmp243 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp244 := tmp243.FindInternedVar(lang.NewSymbol("map")) - if tmp244.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp244))) - } - tmp245 := tmp244.Get() - var tmp246 lang.FnFunc - tmp246 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v247 := args[0] - _ = v247 - tmp248 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp249 := tmp248.FindInternedVar(lang.NewSymbol("seq")) - if tmp249.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp249))) - } - tmp250 := tmp249.Get() - tmp251 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp252 := tmp251.FindInternedVar(lang.NewSymbol("concat")) - if tmp252.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp252))) - } - tmp253 := tmp252.Get() - tmp254 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp255 := tmp254.FindInternedVar(lang.NewSymbol("list")) - if tmp255.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp255))) - } - tmp256 := tmp255.Get() - tmp257 := lang.Apply(tmp256, []any{lang.NewSymbol("glojure.core/assert")}) - tmp258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp259 := tmp258.FindInternedVar(lang.NewSymbol("list")) - if tmp259.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp259))) - } - tmp260 := tmp259.Get() - tmp261 := lang.Apply(tmp260, []any{v247}) - tmp262 := lang.Apply(tmp253, []any{tmp257, tmp261}) - tmp263 := lang.Apply(tmp250, []any{tmp262}) - return tmp263 - }) - tmp247 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4586), lang.NewKeyword("column"), int(44), lang.NewKeyword("end-line"), int(4586), lang.NewKeyword("end-column"), int(65)) - tmp248, err := lang.WithMeta(tmp246, tmp247.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp249 := lang.Apply(tmp245, []any{tmp248, v147}) - tmp250 := lang.Apply(tmp242, []any{tmp249, v238}) - tmp239 = tmp250 - } else { - tmp239 = v238 - } - var v251 any = tmp239 - _ = v251 - tmp252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp253 := tmp252.FindInternedVar(lang.NewSymbol("maybe-destructured")) - if tmp253.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp253))) - } - tmp254 := tmp253.Get() - tmp255 := lang.Apply(tmp254, []any{v101, v251}) - tmp84 = tmp255 - } // end let - return tmp84 - }) - tmp69 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4558), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(4589), lang.NewKeyword("end-column"), int(53)) - tmp70, err := lang.WithMeta(tmp68, tmp69.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v71 any = tmp70 - _ = v71 - // let binding "new-sigs" - tmp72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp73 := tmp72.FindInternedVar(lang.NewSymbol("map")) - if tmp73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp73))) - } - tmp74 := tmp73.Get() - tmp75 := lang.Apply(tmp74, []any{v71, v67}) - var v76 any = tmp75 - _ = v76 - tmp77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp78 := tmp77.FindInternedVar(lang.NewSymbol("with-meta")) - if tmp78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp78))) - } - tmp79 := tmp78.Get() - var tmp80 any - if lang.IsTruthy(v20) { - tmp81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp82 := tmp81.FindInternedVar(lang.NewSymbol("list*")) - if tmp82.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp82))) - } - tmp83 := tmp82.Get() - tmp84 := lang.Apply(tmp83, []any{lang.NewSymbol("fn*"), v20, v76}) - tmp80 = tmp84 - } else { - tmp85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp86 := tmp85.FindInternedVar(lang.NewSymbol("cons")) - if tmp86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp86))) - } - tmp87 := tmp86.Get() - tmp88 := lang.Apply(tmp87, []any{lang.NewSymbol("fn*"), v76}) - tmp80 = tmp88 - } - tmp89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp90 := tmp89.FindInternedVar(lang.NewSymbol("meta")) - if tmp90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp90))) - } - tmp91 := tmp90.Get() - tmp92 := lang.Apply(tmp91, []any{v3}) - tmp93 := lang.Apply(tmp79, []any{tmp80, tmp92}) - tmp6 = tmp93 - } // end let - return tmp6 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // fn? - { - tmp0 := lang.NewSymbol("fn?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements Fn, i.e. is an object created via fn.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6216), lang.NewKeyword("end-line"), int(6216))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := reflect.TypeOf((*runtime4.Fn)(nil)) - tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) - return tmp8 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // fnext - { - tmp0 := lang.NewSymbol("fnext").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Same as (first (next x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(112), lang.NewKeyword("end-line"), int(116))).(*lang.Symbol) - var tmp2 lang.FnFunc - { // function fnext - var v3 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("first")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("next")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v4}) - tmp12 := lang.Apply(tmp7, []any{tmp11}) - return tmp12 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(116), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(116), lang.NewKeyword("end-column"), int(47))).(lang.FnFunc) - v3 = tmp2 - _ = v3 - } - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // fnil - { - tmp0 := lang.NewSymbol("fnil").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("z"))), lang.NewKeyword("doc"), "Takes a function f, and returns a function that calls f, replacing\n a nil first argument to f with the supplied value x. Higher arity\n versions can replace arguments in the second and third\n positions (y, z). Note that the function f can take any number of\n arguments, not just the one(s) being nil-patched.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6558), lang.NewKeyword("end-line"), int(6558))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 lang.FnFunc - tmp5 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v6 := args[0] - _ = v6 - var tmp7 any - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("nil?")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v6}) - if lang.IsTruthy(tmp11) { - tmp7 = v4 - } else { - tmp7 = v6 - } - tmp12 := lang.Apply(v3, []any{tmp7}) - return tmp12 - case 2: - v6 := args[0] - _ = v6 - v7 := args[1] - _ = v7 - var tmp8 any - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("nil?")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.Apply(tmp11, []any{v6}) - if lang.IsTruthy(tmp12) { - tmp8 = v4 - } else { - tmp8 = v6 - } - tmp13 := lang.Apply(v3, []any{tmp8, v7}) - return tmp13 - case 3: - v6 := args[0] - _ = v6 - v7 := args[1] - _ = v7 - v8 := args[2] - _ = v8 - var tmp9 any - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("nil?")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{v6}) - if lang.IsTruthy(tmp13) { - tmp9 = v4 - } else { - tmp9 = v6 - } - tmp14 := lang.Apply(v3, []any{tmp9, v7, v8}) - return tmp14 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v6 := args[0] - _ = v6 - v7 := args[1] - _ = v7 - v8 := args[2] - _ = v8 - var v9 any = lang.NewList(args[3:]...) - _ = v9 - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("apply")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - var tmp13 any - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("nil?")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{v6}) - if lang.IsTruthy(tmp17) { - tmp13 = v4 - } else { - tmp13 = v6 - } - tmp18 := lang.Apply(tmp12, []any{v3, tmp13, v7, v8, v9}) - return tmp18 - } - }) - tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6567), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(6571), lang.NewKeyword("end-column"), int(55)) - tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp7 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var tmp6 lang.FnFunc - tmp6 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: - v7 := args[0] - _ = v7 - v8 := args[1] - _ = v8 - var tmp9 any - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("nil?")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{v7}) - if lang.IsTruthy(tmp13) { - tmp9 = v4 - } else { - tmp9 = v7 - } - var tmp14 any - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("nil?")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{v8}) - if lang.IsTruthy(tmp18) { - tmp14 = v5 - } else { - tmp14 = v8 - } - tmp19 := lang.Apply(v3, []any{tmp9, tmp14}) - return tmp19 - case 3: - v7 := args[0] - _ = v7 - v8 := args[1] - _ = v8 - v9 := args[2] - _ = v9 - var tmp10 any - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("nil?")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{v7}) - if lang.IsTruthy(tmp14) { - tmp10 = v4 - } else { - tmp10 = v7 - } - var tmp15 any - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("nil?")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{v8}) - if lang.IsTruthy(tmp19) { - tmp15 = v5 - } else { - tmp15 = v8 - } - tmp20 := lang.Apply(v3, []any{tmp10, tmp15, v9}) - return tmp20 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v7 := args[0] - _ = v7 - v8 := args[1] - _ = v8 - v9 := args[2] - _ = v9 - var v10 any = lang.NewList(args[3:]...) - _ = v10 - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("apply")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - var tmp14 any - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("nil?")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{v7}) - if lang.IsTruthy(tmp18) { - tmp14 = v4 - } else { - tmp14 = v7 - } - var tmp19 any - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("nil?")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.Apply(tmp22, []any{v8}) - if lang.IsTruthy(tmp23) { - tmp19 = v5 - } else { - tmp19 = v8 - } - tmp24 := lang.Apply(tmp13, []any{v3, tmp14, tmp19, v9, v10}) - return tmp24 - } - }) - tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6573), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(6576), lang.NewKeyword("end-column"), int(71)) - tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp8 - case 4: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - var tmp7 lang.FnFunc - tmp7 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: - v8 := args[0] - _ = v8 - v9 := args[1] - _ = v9 - var tmp10 any - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("nil?")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{v8}) - if lang.IsTruthy(tmp14) { - tmp10 = v4 - } else { - tmp10 = v8 - } - var tmp15 any - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("nil?")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{v9}) - if lang.IsTruthy(tmp19) { - tmp15 = v5 - } else { - tmp15 = v9 - } - tmp20 := lang.Apply(v3, []any{tmp10, tmp15}) - return tmp20 - case 3: - v8 := args[0] - _ = v8 - v9 := args[1] - _ = v9 - v10 := args[2] - _ = v10 - var tmp11 any - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("nil?")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.Apply(tmp14, []any{v8}) - if lang.IsTruthy(tmp15) { - tmp11 = v4 - } else { - tmp11 = v8 - } - var tmp16 any - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("nil?")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.Apply(tmp19, []any{v9}) - if lang.IsTruthy(tmp20) { - tmp16 = v5 - } else { - tmp16 = v9 - } - var tmp21 any - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("nil?")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.Apply(tmp24, []any{v10}) - if lang.IsTruthy(tmp25) { - tmp21 = v6 - } else { - tmp21 = v10 - } - tmp26 := lang.Apply(v3, []any{tmp11, tmp16, tmp21}) - return tmp26 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v8 := args[0] - _ = v8 - v9 := args[1] - _ = v9 - v10 := args[2] - _ = v10 - var v11 any = lang.NewList(args[3:]...) - _ = v11 - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("apply")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - var tmp15 any - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("nil?")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{v8}) - if lang.IsTruthy(tmp19) { - tmp15 = v4 - } else { - tmp15 = v8 - } - var tmp20 any - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("nil?")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.Apply(tmp23, []any{v9}) - if lang.IsTruthy(tmp24) { - tmp20 = v5 - } else { - tmp20 = v9 - } - var tmp25 any - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("nil?")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.Apply(tmp28, []any{v10}) - if lang.IsTruthy(tmp29) { - tmp25 = v6 - } else { - tmp25 = v10 - } - tmp30 := lang.Apply(tmp14, []any{v3, tmp15, tmp20, tmp25, v11}) - return tmp30 - } - }) - tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6578), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(6581), lang.NewKeyword("end-column"), int(87)) - tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp9 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // for - { - tmp0 := lang.NewSymbol("for").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("seq-exprs"), lang.NewSymbol("body-expr"))), lang.NewKeyword("doc"), "List comprehension. Takes a vector of one or more\n binding-form/collection-expr pairs, each followed by zero or more\n modifiers, and yields a lazy sequence of evaluations of expr.\n Collections are iterated in a nested fashion, rightmost fastest,\n and nested coll-exprs can refer to bindings created in prior\n binding-forms. Supported modifiers are: :let [binding-form expr ...],\n :while test, :when test.\n\n (take 100 (for [x (range 100000000) y (range 1000000) :while (< y x)] [x y]))", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4646), lang.NewKeyword("end-line"), int(4646))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - var tmp7 any - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("vector?")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v5}) - if lang.IsTruthy(tmp11) { - } else { - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("str")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("first")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{v3}) - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("*ns*")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("meta")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.Apply(tmp24, []any{v3}) - tmp26 := lang.Apply(lang.NewKeyword("line"), []any{tmp25}) - tmp27 := lang.Apply(tmp14, []any{tmp18, " requires ", "a vector for its binding", " in ", tmp21, ":", tmp26}) - tmp28 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp27}) - panic(tmp28) - } - _ = tmp7 - var tmp29 any - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("even?")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("count")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.Apply(tmp35, []any{v5}) - tmp37 := lang.Apply(tmp32, []any{tmp36}) - if lang.IsTruthy(tmp37) { - } else { - tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp39 := tmp38.FindInternedVar(lang.NewSymbol("str")) - if tmp39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) - } - tmp40 := tmp39.Get() - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("first")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.Apply(tmp43, []any{v3}) - tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp46 := tmp45.FindInternedVar(lang.NewSymbol("*ns*")) - if tmp46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) - } - tmp47 := tmp46.Get() - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("meta")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v3}) - tmp52 := lang.Apply(lang.NewKeyword("line"), []any{tmp51}) - tmp53 := lang.Apply(tmp40, []any{tmp44, " requires ", "an even number of forms in binding vector", " in ", tmp47, ":", tmp52}) - tmp54 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp53}) - panic(tmp54) - } - _ = tmp29 - var tmp55 any - { // let - // let binding "to-groups" - var tmp56 lang.FnFunc - tmp56 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v57 := args[0] - _ = v57 - tmp58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp59 := tmp58.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp59))) - } - tmp60 := tmp59.Get() - var tmp61 lang.FnFunc - tmp61 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v62 := args[0] - _ = v62 - v63 := args[1] - _ = v63 - var tmp64 any - { // let - // let binding "vec__24" - var v65 any = v63 - _ = v65 - // let binding "k" - tmp66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp67 := tmp66.FindInternedVar(lang.NewSymbol("nth")) - if tmp67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp67))) - } - tmp68 := tmp67.Get() - tmp69 := lang.Apply(tmp68, []any{v65, int64(0), nil}) - var v70 any = tmp69 - _ = v70 - // let binding "v" - tmp71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp72 := tmp71.FindInternedVar(lang.NewSymbol("nth")) - if tmp72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp72))) - } - tmp73 := tmp72.Get() - tmp74 := lang.Apply(tmp73, []any{v65, int64(1), nil}) - var v75 any = tmp74 - _ = v75 - var tmp76 any - tmp77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp78 := tmp77.FindInternedVar(lang.NewSymbol("keyword?")) - if tmp78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp78))) - } - tmp79 := tmp78.Get() - tmp80 := lang.Apply(tmp79, []any{v70}) - if lang.IsTruthy(tmp80) { - tmp81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp82 := tmp81.FindInternedVar(lang.NewSymbol("conj")) - if tmp82.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp82))) - } - tmp83 := tmp82.Get() - tmp84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp85 := tmp84.FindInternedVar(lang.NewSymbol("pop")) - if tmp85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp85))) - } - tmp86 := tmp85.Get() - tmp87 := lang.Apply(tmp86, []any{v62}) - tmp88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp89 := tmp88.FindInternedVar(lang.NewSymbol("conj")) - if tmp89.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp89))) - } - tmp90 := tmp89.Get() - tmp91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp92 := tmp91.FindInternedVar(lang.NewSymbol("peek")) - if tmp92.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp92))) - } - tmp93 := tmp92.Get() - tmp94 := lang.Apply(tmp93, []any{v62}) - tmp95 := lang.NewVector(v70, v75) - tmp96 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4664), lang.NewKeyword("column"), int(72), lang.NewKeyword("end-line"), int(4664), lang.NewKeyword("end-column"), int(76)) - tmp97, err := lang.WithMeta(tmp95, tmp96.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp98 := lang.Apply(tmp90, []any{tmp94, tmp97}) - tmp99 := lang.Apply(tmp83, []any{tmp87, tmp98}) - tmp76 = tmp99 - } else { - tmp100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp101 := tmp100.FindInternedVar(lang.NewSymbol("conj")) - if tmp101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp101))) - } - tmp102 := tmp101.Get() - tmp103 := lang.NewVector(v70, v75) - tmp104 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4665), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(4665), lang.NewKeyword("end-column"), int(50)) - tmp105, err := lang.WithMeta(tmp103, tmp104.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp106 := lang.Apply(tmp102, []any{v62, tmp105}) - tmp76 = tmp106 - } - tmp64 = tmp76 - } // end let - return tmp64 - }) - tmp62 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4662), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(4665), lang.NewKeyword("end-column"), int(53)) - tmp63, err := lang.WithMeta(tmp61, tmp62.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp64 := lang.NewVector() - tmp65 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4666), lang.NewKeyword("column"), int(29), lang.NewKeyword("end-line"), int(4666), lang.NewKeyword("end-column"), int(30)) - tmp66, err := lang.WithMeta(tmp64, tmp65.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp68 := tmp67.FindInternedVar(lang.NewSymbol("partition")) - if tmp68.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp68))) - } - tmp69 := tmp68.Get() - tmp70 := lang.Apply(tmp69, []any{int64(2), v57}) - tmp71 := lang.Apply(tmp60, []any{tmp63, tmp66, tmp70}) - return tmp71 - }) - tmp57 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4661), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(4666), lang.NewKeyword("end-column"), int(56)) - tmp58, err := lang.WithMeta(tmp56, tmp57.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v59 any = tmp58 - _ = v59 - // let binding "err" - var tmp60 lang.FnFunc - tmp60 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var v61 any = lang.NewList(args[0:]...) - _ = v61 - tmp62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp63 := tmp62.FindInternedVar(lang.NewSymbol("apply")) - if tmp63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp63))) - } - tmp64 := tmp63.Get() - tmp65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp66 := tmp65.FindInternedVar(lang.NewSymbol("str")) - if tmp66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp66))) - } - tmp67 := tmp66.Get() - tmp68 := lang.Apply(tmp64, []any{tmp67, v61}) - tmp69 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp68}) - panic(tmp69) - } - }) - tmp61 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4667), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(4667), lang.NewKeyword("end-column"), int(125)) - tmp62, err := lang.WithMeta(tmp60, tmp61.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v63 any = tmp62 - _ = v63 - // let binding "emit-bind" - var tmp64 lang.FnFunc - { // function emit-bind - var v65 lang.FnFunc - tmp64 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v66 := args[0] - _ = v66 - var tmp67 any - { // let - // let binding "vec__28" - var v68 any = v66 - _ = v68 - // let binding "seq__29" - tmp69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp70 := tmp69.FindInternedVar(lang.NewSymbol("seq")) - if tmp70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp70))) - } - tmp71 := tmp70.Get() - tmp72 := lang.Apply(tmp71, []any{v68}) - var v73 any = tmp72 - _ = v73 - // let binding "first__30" - tmp74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp75 := tmp74.FindInternedVar(lang.NewSymbol("first")) - if tmp75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp75))) - } - tmp76 := tmp75.Get() - tmp77 := lang.Apply(tmp76, []any{v73}) - var v78 any = tmp77 - _ = v78 - // let binding "seq__29" - tmp79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp80 := tmp79.FindInternedVar(lang.NewSymbol("next")) - if tmp80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp80))) - } - tmp81 := tmp80.Get() - tmp82 := lang.Apply(tmp81, []any{v73}) - var v83 any = tmp82 - _ = v83 - // let binding "vec__31" - var v84 any = v78 - _ = v84 - // let binding "seq__32" - tmp85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp86 := tmp85.FindInternedVar(lang.NewSymbol("seq")) - if tmp86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp86))) - } - tmp87 := tmp86.Get() - tmp88 := lang.Apply(tmp87, []any{v84}) - var v89 any = tmp88 - _ = v89 - // let binding "first__33" - tmp90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp91 := tmp90.FindInternedVar(lang.NewSymbol("first")) - if tmp91.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp91))) - } - tmp92 := tmp91.Get() - tmp93 := lang.Apply(tmp92, []any{v89}) - var v94 any = tmp93 - _ = v94 - // let binding "seq__32" - tmp95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp96 := tmp95.FindInternedVar(lang.NewSymbol("next")) - if tmp96.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp96))) - } - tmp97 := tmp96.Get() - tmp98 := lang.Apply(tmp97, []any{v89}) - var v99 any = tmp98 - _ = v99 - // let binding "bind" - var v100 any = v94 - _ = v100 - // let binding "first__33" - tmp101 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp102 := tmp101.FindInternedVar(lang.NewSymbol("first")) - if tmp102.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp102))) - } - tmp103 := tmp102.Get() - tmp104 := lang.Apply(tmp103, []any{v99}) - var v105 any = tmp104 - _ = v105 - // let binding "seq__32" - tmp106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp107 := tmp106.FindInternedVar(lang.NewSymbol("next")) - if tmp107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp107))) - } - tmp108 := tmp107.Get() - tmp109 := lang.Apply(tmp108, []any{v99}) - var v110 any = tmp109 - _ = v110 - // let binding "expr" - var v111 any = v105 - _ = v111 - // let binding "mod-pairs" - var v112 any = v110 - _ = v112 - // let binding "vec__34" - var v113 any = v83 - _ = v113 - // let binding "vec__37" - tmp114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp115 := tmp114.FindInternedVar(lang.NewSymbol("nth")) - if tmp115.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp115))) - } - tmp116 := tmp115.Get() - tmp117 := lang.Apply(tmp116, []any{v113, int64(0), nil}) - var v118 any = tmp117 - _ = v118 - // let binding "_" - tmp119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp120 := tmp119.FindInternedVar(lang.NewSymbol("nth")) - if tmp120.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp120))) - } - tmp121 := tmp120.Get() - tmp122 := lang.Apply(tmp121, []any{v118, int64(0), nil}) - var v123 any = tmp122 - _ = v123 - // let binding "next-expr" - tmp124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp125 := tmp124.FindInternedVar(lang.NewSymbol("nth")) - if tmp125.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp125))) - } - tmp126 := tmp125.Get() - tmp127 := lang.Apply(tmp126, []any{v118, int64(1), nil}) - var v128 any = tmp127 - _ = v128 - // let binding "next-groups" - var v129 any = v113 - _ = v129 - var tmp130 any - { // let - // let binding "giter" - tmp131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp132 := tmp131.FindInternedVar(lang.NewSymbol("gensym")) - if tmp132.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp132))) - } - tmp133 := tmp132.Get() - tmp134 := lang.Apply(tmp133, []any{"iter__"}) - var v135 any = tmp134 - _ = v135 - // let binding "gxs" - tmp136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp137 := tmp136.FindInternedVar(lang.NewSymbol("gensym")) - if tmp137.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp137))) - } - tmp138 := tmp137.Get() - tmp139 := lang.Apply(tmp138, []any{"s__"}) - var v140 any = tmp139 - _ = v140 - // let binding "do-mod" - var tmp141 lang.FnFunc - { // function do-mod - var v142 lang.FnFunc - tmp141 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v143 := args[0] - _ = v143 - var tmp144 any - { // let - // let binding "vec__41" - var v145 any = v143 - _ = v145 - // let binding "seq__42" - tmp146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp147 := tmp146.FindInternedVar(lang.NewSymbol("seq")) - if tmp147.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp147))) - } - tmp148 := tmp147.Get() - tmp149 := lang.Apply(tmp148, []any{v145}) - var v150 any = tmp149 - _ = v150 - // let binding "first__43" - tmp151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp152 := tmp151.FindInternedVar(lang.NewSymbol("first")) - if tmp152.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp152))) - } - tmp153 := tmp152.Get() - tmp154 := lang.Apply(tmp153, []any{v150}) - var v155 any = tmp154 - _ = v155 - // let binding "seq__42" - tmp156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp157 := tmp156.FindInternedVar(lang.NewSymbol("next")) - if tmp157.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp157))) - } - tmp158 := tmp157.Get() - tmp159 := lang.Apply(tmp158, []any{v150}) - var v160 any = tmp159 - _ = v160 - // let binding "vec__44" - var v161 any = v155 - _ = v161 - // let binding "k" - tmp162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp163 := tmp162.FindInternedVar(lang.NewSymbol("nth")) - if tmp163.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp163))) - } - tmp164 := tmp163.Get() - tmp165 := lang.Apply(tmp164, []any{v161, int64(0), nil}) - var v166 any = tmp165 - _ = v166 - // let binding "v" - tmp167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp168 := tmp167.FindInternedVar(lang.NewSymbol("nth")) - if tmp168.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp168))) - } - tmp169 := tmp168.Get() - tmp170 := lang.Apply(tmp169, []any{v161, int64(1), nil}) - var v171 any = tmp170 - _ = v171 - // let binding "pair" - var v172 any = v161 - _ = v172 - // let binding "etc" - var v173 any = v160 - _ = v173 - var tmp174 any - tmp175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp176 := tmp175.FindInternedVar(lang.NewSymbol("=")) - if tmp176.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp176))) - } - tmp177 := tmp176.Get() - tmp178 := lang.Apply(tmp177, []any{v166, lang.NewKeyword("let")}) - if lang.IsTruthy(tmp178) { - tmp179 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp180 := tmp179.FindInternedVar(lang.NewSymbol("seq")) - if tmp180.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp180))) - } - tmp181 := tmp180.Get() - tmp182 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp183 := tmp182.FindInternedVar(lang.NewSymbol("concat")) - if tmp183.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp183))) - } - tmp184 := tmp183.Get() - tmp185 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp186 := tmp185.FindInternedVar(lang.NewSymbol("list")) - if tmp186.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp186))) - } - tmp187 := tmp186.Get() - tmp188 := lang.Apply(tmp187, []any{lang.NewSymbol("glojure.core/let")}) - tmp189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp190 := tmp189.FindInternedVar(lang.NewSymbol("list")) - if tmp190.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp190))) - } - tmp191 := tmp190.Get() - tmp192 := lang.Apply(tmp191, []any{v171}) - tmp193 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp194 := tmp193.FindInternedVar(lang.NewSymbol("list")) - if tmp194.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp194))) - } - tmp195 := tmp194.Get() - tmp196 := lang.Apply(v142, []any{v173}) - tmp197 := lang.Apply(tmp195, []any{tmp196}) - tmp198 := lang.Apply(tmp184, []any{tmp188, tmp192, tmp197}) - tmp199 := lang.Apply(tmp181, []any{tmp198}) - tmp174 = tmp199 - } else { - var tmp200 any - tmp201 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp202 := tmp201.FindInternedVar(lang.NewSymbol("=")) - if tmp202.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp202))) - } - tmp203 := tmp202.Get() - tmp204 := lang.Apply(tmp203, []any{v166, lang.NewKeyword("while")}) - if lang.IsTruthy(tmp204) { - tmp205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp206 := tmp205.FindInternedVar(lang.NewSymbol("seq")) - if tmp206.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp206))) - } - tmp207 := tmp206.Get() - tmp208 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp209 := tmp208.FindInternedVar(lang.NewSymbol("concat")) - if tmp209.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp209))) - } - tmp210 := tmp209.Get() - tmp211 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp212 := tmp211.FindInternedVar(lang.NewSymbol("list")) - if tmp212.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp212))) - } - tmp213 := tmp212.Get() - tmp214 := lang.Apply(tmp213, []any{lang.NewSymbol("glojure.core/when")}) - tmp215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp216 := tmp215.FindInternedVar(lang.NewSymbol("list")) - if tmp216.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp216))) - } - tmp217 := tmp216.Get() - tmp218 := lang.Apply(tmp217, []any{v171}) - tmp219 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp220 := tmp219.FindInternedVar(lang.NewSymbol("list")) - if tmp220.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp220))) - } - tmp221 := tmp220.Get() - tmp222 := lang.Apply(v142, []any{v173}) - tmp223 := lang.Apply(tmp221, []any{tmp222}) - tmp224 := lang.Apply(tmp210, []any{tmp214, tmp218, tmp223}) - tmp225 := lang.Apply(tmp207, []any{tmp224}) - tmp200 = tmp225 - } else { - var tmp226 any - tmp227 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp228 := tmp227.FindInternedVar(lang.NewSymbol("=")) - if tmp228.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp228))) - } - tmp229 := tmp228.Get() - tmp230 := lang.Apply(tmp229, []any{v166, lang.NewKeyword("when")}) - if lang.IsTruthy(tmp230) { - tmp231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp232 := tmp231.FindInternedVar(lang.NewSymbol("seq")) - if tmp232.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp232))) - } - tmp233 := tmp232.Get() - tmp234 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp235 := tmp234.FindInternedVar(lang.NewSymbol("concat")) - if tmp235.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp235))) - } - tmp236 := tmp235.Get() - tmp237 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp238 := tmp237.FindInternedVar(lang.NewSymbol("list")) - if tmp238.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp238))) - } - tmp239 := tmp238.Get() - tmp240 := lang.Apply(tmp239, []any{lang.NewSymbol("if")}) - tmp241 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp242 := tmp241.FindInternedVar(lang.NewSymbol("list")) - if tmp242.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp242))) - } - tmp243 := tmp242.Get() - tmp244 := lang.Apply(tmp243, []any{v171}) - tmp245 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp246 := tmp245.FindInternedVar(lang.NewSymbol("list")) - if tmp246.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp246))) - } - tmp247 := tmp246.Get() - tmp248 := lang.Apply(v142, []any{v173}) - tmp249 := lang.Apply(tmp247, []any{tmp248}) - tmp250 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp251 := tmp250.FindInternedVar(lang.NewSymbol("list")) - if tmp251.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp251))) - } - tmp252 := tmp251.Get() - tmp253 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp254 := tmp253.FindInternedVar(lang.NewSymbol("seq")) - if tmp254.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp254))) - } - tmp255 := tmp254.Get() - tmp256 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp257 := tmp256.FindInternedVar(lang.NewSymbol("concat")) - if tmp257.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp257))) - } - tmp258 := tmp257.Get() - tmp259 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp260 := tmp259.FindInternedVar(lang.NewSymbol("list")) - if tmp260.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp260))) - } - tmp261 := tmp260.Get() - tmp262 := lang.Apply(tmp261, []any{lang.NewSymbol("recur")}) - tmp263 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp264 := tmp263.FindInternedVar(lang.NewSymbol("list")) - if tmp264.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp264))) - } - tmp265 := tmp264.Get() - tmp266 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp267 := tmp266.FindInternedVar(lang.NewSymbol("seq")) - if tmp267.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp267))) - } - tmp268 := tmp267.Get() - tmp269 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp270 := tmp269.FindInternedVar(lang.NewSymbol("concat")) - if tmp270.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp270))) - } - tmp271 := tmp270.Get() - tmp272 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp273 := tmp272.FindInternedVar(lang.NewSymbol("list")) - if tmp273.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp273))) - } - tmp274 := tmp273.Get() - tmp275 := lang.Apply(tmp274, []any{lang.NewSymbol("glojure.core/rest")}) - tmp276 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp277 := tmp276.FindInternedVar(lang.NewSymbol("list")) - if tmp277.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp277))) - } - tmp278 := tmp277.Get() - tmp279 := lang.Apply(tmp278, []any{v140}) - tmp280 := lang.Apply(tmp271, []any{tmp275, tmp279}) - tmp281 := lang.Apply(tmp268, []any{tmp280}) - tmp282 := lang.Apply(tmp265, []any{tmp281}) - tmp283 := lang.Apply(tmp258, []any{tmp262, tmp282}) - tmp284 := lang.Apply(tmp255, []any{tmp283}) - tmp285 := lang.Apply(tmp252, []any{tmp284}) - tmp286 := lang.Apply(tmp236, []any{tmp240, tmp244, tmp249, tmp285}) - tmp287 := lang.Apply(tmp233, []any{tmp286}) - tmp226 = tmp287 - } else { - var tmp288 any - tmp289 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp290 := tmp289.FindInternedVar(lang.NewSymbol("keyword?")) - if tmp290.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp290))) - } - tmp291 := tmp290.Get() - tmp292 := lang.Apply(tmp291, []any{v166}) - if lang.IsTruthy(tmp292) { - tmp293 := lang.Apply(v63, []any{"Invalid 'for' keyword ", v166}) - tmp288 = tmp293 - } else { - var tmp294 any - if lang.IsTruthy(v129) { - tmp295 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp296 := tmp295.FindInternedVar(lang.NewSymbol("seq")) - if tmp296.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp296))) - } - tmp297 := tmp296.Get() - tmp298 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp299 := tmp298.FindInternedVar(lang.NewSymbol("concat")) - if tmp299.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp299))) - } - tmp300 := tmp299.Get() - tmp301 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp302 := tmp301.FindInternedVar(lang.NewSymbol("list")) - if tmp302.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp302))) - } - tmp303 := tmp302.Get() - tmp304 := lang.Apply(tmp303, []any{lang.NewSymbol("glojure.core/let")}) - tmp305 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp306 := tmp305.FindInternedVar(lang.NewSymbol("list")) - if tmp306.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp306))) - } - tmp307 := tmp306.Get() - tmp308 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp309 := tmp308.FindInternedVar(lang.NewSymbol("apply")) - if tmp309.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp309))) - } - tmp310 := tmp309.Get() - tmp311 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp312 := tmp311.FindInternedVar(lang.NewSymbol("vector")) - if tmp312.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp312))) - } - tmp313 := tmp312.Get() - tmp314 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp315 := tmp314.FindInternedVar(lang.NewSymbol("seq")) - if tmp315.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp315))) - } - tmp316 := tmp315.Get() - tmp317 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp318 := tmp317.FindInternedVar(lang.NewSymbol("concat")) - if tmp318.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp318))) - } - tmp319 := tmp318.Get() - tmp320 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp321 := tmp320.FindInternedVar(lang.NewSymbol("list")) - if tmp321.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp321))) - } - tmp322 := tmp321.Get() - tmp323 := lang.Apply(tmp322, []any{lang.NewSymbol("iterys__0__auto__")}) - tmp324 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp325 := tmp324.FindInternedVar(lang.NewSymbol("list")) - if tmp325.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp325))) - } - tmp326 := tmp325.Get() - tmp327 := lang.Apply(v65, []any{v129}) - tmp328 := lang.Apply(tmp326, []any{tmp327}) - tmp329 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp330 := tmp329.FindInternedVar(lang.NewSymbol("list")) - if tmp330.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp330))) - } - tmp331 := tmp330.Get() - tmp332 := lang.Apply(tmp331, []any{lang.NewSymbol("fs__1__auto__")}) - tmp333 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp334 := tmp333.FindInternedVar(lang.NewSymbol("list")) - if tmp334.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp334))) - } - tmp335 := tmp334.Get() - tmp336 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp337 := tmp336.FindInternedVar(lang.NewSymbol("seq")) - if tmp337.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp337))) - } - tmp338 := tmp337.Get() - tmp339 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp340 := tmp339.FindInternedVar(lang.NewSymbol("concat")) - if tmp340.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp340))) - } - tmp341 := tmp340.Get() - tmp342 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp343 := tmp342.FindInternedVar(lang.NewSymbol("list")) - if tmp343.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp343))) - } - tmp344 := tmp343.Get() - tmp345 := lang.Apply(tmp344, []any{lang.NewSymbol("glojure.core/seq")}) - tmp346 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp347 := tmp346.FindInternedVar(lang.NewSymbol("list")) - if tmp347.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp347))) - } - tmp348 := tmp347.Get() - tmp349 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp350 := tmp349.FindInternedVar(lang.NewSymbol("seq")) - if tmp350.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp350))) - } - tmp351 := tmp350.Get() - tmp352 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp353 := tmp352.FindInternedVar(lang.NewSymbol("concat")) - if tmp353.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp353))) - } - tmp354 := tmp353.Get() - tmp355 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp356 := tmp355.FindInternedVar(lang.NewSymbol("list")) - if tmp356.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp356))) - } - tmp357 := tmp356.Get() - tmp358 := lang.Apply(tmp357, []any{lang.NewSymbol("iterys__0__auto__")}) - tmp359 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp360 := tmp359.FindInternedVar(lang.NewSymbol("list")) - if tmp360.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp360))) - } - tmp361 := tmp360.Get() - tmp362 := lang.Apply(tmp361, []any{v128}) - tmp363 := lang.Apply(tmp354, []any{tmp358, tmp362}) - tmp364 := lang.Apply(tmp351, []any{tmp363}) - tmp365 := lang.Apply(tmp348, []any{tmp364}) - tmp366 := lang.Apply(tmp341, []any{tmp345, tmp365}) - tmp367 := lang.Apply(tmp338, []any{tmp366}) - tmp368 := lang.Apply(tmp335, []any{tmp367}) - tmp369 := lang.Apply(tmp319, []any{tmp323, tmp328, tmp332, tmp368}) - tmp370 := lang.Apply(tmp316, []any{tmp369}) - tmp371 := lang.Apply(tmp310, []any{tmp313, tmp370}) - tmp372 := lang.Apply(tmp307, []any{tmp371}) - tmp373 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp374 := tmp373.FindInternedVar(lang.NewSymbol("list")) - if tmp374.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp374))) - } - tmp375 := tmp374.Get() - tmp376 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp377 := tmp376.FindInternedVar(lang.NewSymbol("seq")) - if tmp377.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp377))) - } - tmp378 := tmp377.Get() - tmp379 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp380 := tmp379.FindInternedVar(lang.NewSymbol("concat")) - if tmp380.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp380))) - } - tmp381 := tmp380.Get() - tmp382 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp383 := tmp382.FindInternedVar(lang.NewSymbol("list")) - if tmp383.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp383))) - } - tmp384 := tmp383.Get() - tmp385 := lang.Apply(tmp384, []any{lang.NewSymbol("if")}) - tmp386 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp387 := tmp386.FindInternedVar(lang.NewSymbol("list")) - if tmp387.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp387))) - } - tmp388 := tmp387.Get() - tmp389 := lang.Apply(tmp388, []any{lang.NewSymbol("fs__1__auto__")}) - tmp390 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp391 := tmp390.FindInternedVar(lang.NewSymbol("list")) - if tmp391.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp391))) - } - tmp392 := tmp391.Get() - tmp393 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp394 := tmp393.FindInternedVar(lang.NewSymbol("seq")) - if tmp394.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp394))) - } - tmp395 := tmp394.Get() - tmp396 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp397 := tmp396.FindInternedVar(lang.NewSymbol("concat")) - if tmp397.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp397))) - } - tmp398 := tmp397.Get() - tmp399 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp400 := tmp399.FindInternedVar(lang.NewSymbol("list")) - if tmp400.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp400))) - } - tmp401 := tmp400.Get() - tmp402 := lang.Apply(tmp401, []any{lang.NewSymbol("glojure.core/concat")}) - tmp403 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp404 := tmp403.FindInternedVar(lang.NewSymbol("list")) - if tmp404.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp404))) - } - tmp405 := tmp404.Get() - tmp406 := lang.Apply(tmp405, []any{lang.NewSymbol("fs__1__auto__")}) - tmp407 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp408 := tmp407.FindInternedVar(lang.NewSymbol("list")) - if tmp408.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp408))) - } - tmp409 := tmp408.Get() - tmp410 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp411 := tmp410.FindInternedVar(lang.NewSymbol("seq")) - if tmp411.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp411))) - } - tmp412 := tmp411.Get() - tmp413 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp414 := tmp413.FindInternedVar(lang.NewSymbol("concat")) - if tmp414.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp414))) - } - tmp415 := tmp414.Get() - tmp416 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp417 := tmp416.FindInternedVar(lang.NewSymbol("list")) - if tmp417.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp417))) - } - tmp418 := tmp417.Get() - tmp419 := lang.Apply(tmp418, []any{v135}) - tmp420 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp421 := tmp420.FindInternedVar(lang.NewSymbol("list")) - if tmp421.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp421))) - } - tmp422 := tmp421.Get() - tmp423 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp424 := tmp423.FindInternedVar(lang.NewSymbol("seq")) - if tmp424.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp424))) - } - tmp425 := tmp424.Get() - tmp426 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp427 := tmp426.FindInternedVar(lang.NewSymbol("concat")) - if tmp427.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp427))) - } - tmp428 := tmp427.Get() - tmp429 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp430 := tmp429.FindInternedVar(lang.NewSymbol("list")) - if tmp430.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp430))) - } - tmp431 := tmp430.Get() - tmp432 := lang.Apply(tmp431, []any{lang.NewSymbol("glojure.core/rest")}) - tmp433 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp434 := tmp433.FindInternedVar(lang.NewSymbol("list")) - if tmp434.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp434))) - } - tmp435 := tmp434.Get() - tmp436 := lang.Apply(tmp435, []any{v140}) - tmp437 := lang.Apply(tmp428, []any{tmp432, tmp436}) - tmp438 := lang.Apply(tmp425, []any{tmp437}) - tmp439 := lang.Apply(tmp422, []any{tmp438}) - tmp440 := lang.Apply(tmp415, []any{tmp419, tmp439}) - tmp441 := lang.Apply(tmp412, []any{tmp440}) - tmp442 := lang.Apply(tmp409, []any{tmp441}) - tmp443 := lang.Apply(tmp398, []any{tmp402, tmp406, tmp442}) - tmp444 := lang.Apply(tmp395, []any{tmp443}) - tmp445 := lang.Apply(tmp392, []any{tmp444}) - tmp446 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp447 := tmp446.FindInternedVar(lang.NewSymbol("list")) - if tmp447.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp447))) - } - tmp448 := tmp447.Get() - tmp449 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp450 := tmp449.FindInternedVar(lang.NewSymbol("seq")) - if tmp450.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp450))) - } - tmp451 := tmp450.Get() - tmp452 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp453 := tmp452.FindInternedVar(lang.NewSymbol("concat")) - if tmp453.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp453))) - } - tmp454 := tmp453.Get() - tmp455 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp456 := tmp455.FindInternedVar(lang.NewSymbol("list")) - if tmp456.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp456))) - } - tmp457 := tmp456.Get() - tmp458 := lang.Apply(tmp457, []any{lang.NewSymbol("recur")}) - tmp459 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp460 := tmp459.FindInternedVar(lang.NewSymbol("list")) - if tmp460.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp460))) - } - tmp461 := tmp460.Get() - tmp462 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp463 := tmp462.FindInternedVar(lang.NewSymbol("seq")) - if tmp463.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp463))) - } - tmp464 := tmp463.Get() - tmp465 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp466 := tmp465.FindInternedVar(lang.NewSymbol("concat")) - if tmp466.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp466))) - } - tmp467 := tmp466.Get() - tmp468 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp469 := tmp468.FindInternedVar(lang.NewSymbol("list")) - if tmp469.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp469))) - } - tmp470 := tmp469.Get() - tmp471 := lang.Apply(tmp470, []any{lang.NewSymbol("glojure.core/rest")}) - tmp472 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp473 := tmp472.FindInternedVar(lang.NewSymbol("list")) - if tmp473.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp473))) - } - tmp474 := tmp473.Get() - tmp475 := lang.Apply(tmp474, []any{v140}) - tmp476 := lang.Apply(tmp467, []any{tmp471, tmp475}) - tmp477 := lang.Apply(tmp464, []any{tmp476}) - tmp478 := lang.Apply(tmp461, []any{tmp477}) - tmp479 := lang.Apply(tmp454, []any{tmp458, tmp478}) - tmp480 := lang.Apply(tmp451, []any{tmp479}) - tmp481 := lang.Apply(tmp448, []any{tmp480}) - tmp482 := lang.Apply(tmp381, []any{tmp385, tmp389, tmp445, tmp481}) - tmp483 := lang.Apply(tmp378, []any{tmp482}) - tmp484 := lang.Apply(tmp375, []any{tmp483}) - tmp485 := lang.Apply(tmp300, []any{tmp304, tmp372, tmp484}) - tmp486 := lang.Apply(tmp297, []any{tmp485}) - tmp294 = tmp486 - } else { - var tmp487 any - if lang.IsTruthy(lang.NewKeyword("else")) { - tmp488 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp489 := tmp488.FindInternedVar(lang.NewSymbol("seq")) - if tmp489.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp489))) - } - tmp490 := tmp489.Get() - tmp491 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp492 := tmp491.FindInternedVar(lang.NewSymbol("concat")) - if tmp492.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp492))) - } - tmp493 := tmp492.Get() - tmp494 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp495 := tmp494.FindInternedVar(lang.NewSymbol("list")) - if tmp495.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp495))) - } - tmp496 := tmp495.Get() - tmp497 := lang.Apply(tmp496, []any{lang.NewSymbol("glojure.core/cons")}) - tmp498 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp499 := tmp498.FindInternedVar(lang.NewSymbol("list")) - if tmp499.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp499))) - } - tmp500 := tmp499.Get() - tmp501 := lang.Apply(tmp500, []any{v6}) - tmp502 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp503 := tmp502.FindInternedVar(lang.NewSymbol("list")) - if tmp503.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp503))) - } - tmp504 := tmp503.Get() - tmp505 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp506 := tmp505.FindInternedVar(lang.NewSymbol("seq")) - if tmp506.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp506))) - } - tmp507 := tmp506.Get() - tmp508 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp509 := tmp508.FindInternedVar(lang.NewSymbol("concat")) - if tmp509.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp509))) - } - tmp510 := tmp509.Get() - tmp511 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp512 := tmp511.FindInternedVar(lang.NewSymbol("list")) - if tmp512.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp512))) - } - tmp513 := tmp512.Get() - tmp514 := lang.Apply(tmp513, []any{v135}) - tmp515 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp516 := tmp515.FindInternedVar(lang.NewSymbol("list")) - if tmp516.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp516))) - } - tmp517 := tmp516.Get() - tmp518 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp519 := tmp518.FindInternedVar(lang.NewSymbol("seq")) - if tmp519.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp519))) - } - tmp520 := tmp519.Get() - tmp521 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp522 := tmp521.FindInternedVar(lang.NewSymbol("concat")) - if tmp522.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp522))) - } - tmp523 := tmp522.Get() - tmp524 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp525 := tmp524.FindInternedVar(lang.NewSymbol("list")) - if tmp525.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp525))) - } - tmp526 := tmp525.Get() - tmp527 := lang.Apply(tmp526, []any{lang.NewSymbol("glojure.core/rest")}) - tmp528 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp529 := tmp528.FindInternedVar(lang.NewSymbol("list")) - if tmp529.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp529))) - } - tmp530 := tmp529.Get() - tmp531 := lang.Apply(tmp530, []any{v140}) - tmp532 := lang.Apply(tmp523, []any{tmp527, tmp531}) - tmp533 := lang.Apply(tmp520, []any{tmp532}) - tmp534 := lang.Apply(tmp517, []any{tmp533}) - tmp535 := lang.Apply(tmp510, []any{tmp514, tmp534}) - tmp536 := lang.Apply(tmp507, []any{tmp535}) - tmp537 := lang.Apply(tmp504, []any{tmp536}) - tmp538 := lang.Apply(tmp493, []any{tmp497, tmp501, tmp537}) - tmp539 := lang.Apply(tmp490, []any{tmp538}) - tmp487 = tmp539 - } else { - } - tmp294 = tmp487 - } - tmp288 = tmp294 - } - tmp226 = tmp288 - } - tmp200 = tmp226 - } - tmp174 = tmp200 - } - tmp144 = tmp174 - } // end let - return tmp144 - }) - v142 = tmp141 - _ = v142 - } - tmp142 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4672), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(4687), lang.NewKeyword("end-column"), int(73)) - tmp143, err := lang.WithMeta(tmp141, tmp142.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v144 any = tmp143 - _ = v144 - var tmp145 any - if lang.IsTruthy(v129) { - tmp146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp147 := tmp146.FindInternedVar(lang.NewSymbol("seq")) - if tmp147.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp147))) - } - tmp148 := tmp147.Get() - tmp149 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp150 := tmp149.FindInternedVar(lang.NewSymbol("concat")) - if tmp150.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp150))) - } - tmp151 := tmp150.Get() - tmp152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp153 := tmp152.FindInternedVar(lang.NewSymbol("list")) - if tmp153.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp153))) - } - tmp154 := tmp153.Get() - tmp155 := lang.Apply(tmp154, []any{lang.NewSymbol("glojure.core/fn")}) - tmp156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp157 := tmp156.FindInternedVar(lang.NewSymbol("list")) - if tmp157.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp157))) - } - tmp158 := tmp157.Get() - tmp159 := lang.Apply(tmp158, []any{v135}) - tmp160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp161 := tmp160.FindInternedVar(lang.NewSymbol("list")) - if tmp161.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp161))) - } - tmp162 := tmp161.Get() - tmp163 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp164 := tmp163.FindInternedVar(lang.NewSymbol("apply")) - if tmp164.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp164))) - } - tmp165 := tmp164.Get() - tmp166 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp167 := tmp166.FindInternedVar(lang.NewSymbol("vector")) - if tmp167.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp167))) - } - tmp168 := tmp167.Get() - tmp169 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp170 := tmp169.FindInternedVar(lang.NewSymbol("seq")) - if tmp170.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp170))) - } - tmp171 := tmp170.Get() - tmp172 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp173 := tmp172.FindInternedVar(lang.NewSymbol("concat")) - if tmp173.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp173))) - } - tmp174 := tmp173.Get() - tmp175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp176 := tmp175.FindInternedVar(lang.NewSymbol("list")) - if tmp176.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp176))) - } - tmp177 := tmp176.Get() - tmp178 := lang.Apply(tmp177, []any{v140}) - tmp179 := lang.Apply(tmp174, []any{tmp178}) - tmp180 := lang.Apply(tmp171, []any{tmp179}) - tmp181 := lang.Apply(tmp165, []any{tmp168, tmp180}) - tmp182 := lang.Apply(tmp162, []any{tmp181}) - tmp183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp184 := tmp183.FindInternedVar(lang.NewSymbol("list")) - if tmp184.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp184))) - } - tmp185 := tmp184.Get() - tmp186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp187 := tmp186.FindInternedVar(lang.NewSymbol("seq")) - if tmp187.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp187))) - } - tmp188 := tmp187.Get() - tmp189 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp190 := tmp189.FindInternedVar(lang.NewSymbol("concat")) - if tmp190.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp190))) - } - tmp191 := tmp190.Get() - tmp192 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp193 := tmp192.FindInternedVar(lang.NewSymbol("list")) - if tmp193.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp193))) - } - tmp194 := tmp193.Get() - tmp195 := lang.Apply(tmp194, []any{lang.NewSymbol("glojure.core/lazy-seq")}) - tmp196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp197 := tmp196.FindInternedVar(lang.NewSymbol("list")) - if tmp197.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp197))) - } - tmp198 := tmp197.Get() - tmp199 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp200 := tmp199.FindInternedVar(lang.NewSymbol("seq")) - if tmp200.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp200))) - } - tmp201 := tmp200.Get() - tmp202 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp203 := tmp202.FindInternedVar(lang.NewSymbol("concat")) - if tmp203.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp203))) - } - tmp204 := tmp203.Get() - tmp205 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp206 := tmp205.FindInternedVar(lang.NewSymbol("list")) - if tmp206.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp206))) - } - tmp207 := tmp206.Get() - tmp208 := lang.Apply(tmp207, []any{lang.NewSymbol("glojure.core/loop")}) - tmp209 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp210 := tmp209.FindInternedVar(lang.NewSymbol("list")) - if tmp210.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp210))) - } - tmp211 := tmp210.Get() - tmp212 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp213 := tmp212.FindInternedVar(lang.NewSymbol("apply")) - if tmp213.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp213))) - } - tmp214 := tmp213.Get() - tmp215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp216 := tmp215.FindInternedVar(lang.NewSymbol("vector")) - if tmp216.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp216))) - } - tmp217 := tmp216.Get() - tmp218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp219 := tmp218.FindInternedVar(lang.NewSymbol("seq")) - if tmp219.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp219))) - } - tmp220 := tmp219.Get() - tmp221 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp222 := tmp221.FindInternedVar(lang.NewSymbol("concat")) - if tmp222.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp222))) - } - tmp223 := tmp222.Get() - tmp224 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp225 := tmp224.FindInternedVar(lang.NewSymbol("list")) - if tmp225.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp225))) - } - tmp226 := tmp225.Get() - tmp227 := lang.Apply(tmp226, []any{v140}) - tmp228 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp229 := tmp228.FindInternedVar(lang.NewSymbol("list")) - if tmp229.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp229))) - } - tmp230 := tmp229.Get() - tmp231 := lang.Apply(tmp230, []any{v140}) - tmp232 := lang.Apply(tmp223, []any{tmp227, tmp231}) - tmp233 := lang.Apply(tmp220, []any{tmp232}) - tmp234 := lang.Apply(tmp214, []any{tmp217, tmp233}) - tmp235 := lang.Apply(tmp211, []any{tmp234}) - tmp236 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp237 := tmp236.FindInternedVar(lang.NewSymbol("list")) - if tmp237.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp237))) - } - tmp238 := tmp237.Get() - tmp239 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp240 := tmp239.FindInternedVar(lang.NewSymbol("seq")) - if tmp240.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp240))) - } - tmp241 := tmp240.Get() - tmp242 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp243 := tmp242.FindInternedVar(lang.NewSymbol("concat")) - if tmp243.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp243))) - } - tmp244 := tmp243.Get() - tmp245 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp246 := tmp245.FindInternedVar(lang.NewSymbol("list")) - if tmp246.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp246))) - } - tmp247 := tmp246.Get() - tmp248 := lang.Apply(tmp247, []any{lang.NewSymbol("glojure.core/when-first")}) - tmp249 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp250 := tmp249.FindInternedVar(lang.NewSymbol("list")) - if tmp250.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp250))) - } - tmp251 := tmp250.Get() - tmp252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp253 := tmp252.FindInternedVar(lang.NewSymbol("apply")) - if tmp253.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp253))) - } - tmp254 := tmp253.Get() - tmp255 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp256 := tmp255.FindInternedVar(lang.NewSymbol("vector")) - if tmp256.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp256))) - } - tmp257 := tmp256.Get() - tmp258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp259 := tmp258.FindInternedVar(lang.NewSymbol("seq")) - if tmp259.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp259))) - } - tmp260 := tmp259.Get() - tmp261 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp262 := tmp261.FindInternedVar(lang.NewSymbol("concat")) - if tmp262.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp262))) - } - tmp263 := tmp262.Get() - tmp264 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp265 := tmp264.FindInternedVar(lang.NewSymbol("list")) - if tmp265.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp265))) - } - tmp266 := tmp265.Get() - tmp267 := lang.Apply(tmp266, []any{v100}) - tmp268 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp269 := tmp268.FindInternedVar(lang.NewSymbol("list")) - if tmp269.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp269))) - } - tmp270 := tmp269.Get() - tmp271 := lang.Apply(tmp270, []any{v140}) - tmp272 := lang.Apply(tmp263, []any{tmp267, tmp271}) - tmp273 := lang.Apply(tmp260, []any{tmp272}) - tmp274 := lang.Apply(tmp254, []any{tmp257, tmp273}) - tmp275 := lang.Apply(tmp251, []any{tmp274}) - tmp276 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp277 := tmp276.FindInternedVar(lang.NewSymbol("list")) - if tmp277.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp277))) - } - tmp278 := tmp277.Get() - tmp279 := lang.Apply(v144, []any{v112}) - tmp280 := lang.Apply(tmp278, []any{tmp279}) - tmp281 := lang.Apply(tmp244, []any{tmp248, tmp275, tmp280}) - tmp282 := lang.Apply(tmp241, []any{tmp281}) - tmp283 := lang.Apply(tmp238, []any{tmp282}) - tmp284 := lang.Apply(tmp204, []any{tmp208, tmp235, tmp283}) - tmp285 := lang.Apply(tmp201, []any{tmp284}) - tmp286 := lang.Apply(tmp198, []any{tmp285}) - tmp287 := lang.Apply(tmp191, []any{tmp195, tmp286}) - tmp288 := lang.Apply(tmp188, []any{tmp287}) - tmp289 := lang.Apply(tmp185, []any{tmp288}) - tmp290 := lang.Apply(tmp151, []any{tmp155, tmp159, tmp182, tmp289}) - tmp291 := lang.Apply(tmp148, []any{tmp290}) - tmp145 = tmp291 - } else { - var tmp292 any - { // let - // let binding "gi" - tmp293 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp294 := tmp293.FindInternedVar(lang.NewSymbol("gensym")) - if tmp294.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp294))) - } - tmp295 := tmp294.Get() - tmp296 := lang.Apply(tmp295, []any{"i__"}) - var v297 any = tmp296 - _ = v297 - // let binding "gb" - tmp298 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp299 := tmp298.FindInternedVar(lang.NewSymbol("gensym")) - if tmp299.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp299))) - } - tmp300 := tmp299.Get() - tmp301 := lang.Apply(tmp300, []any{"b__"}) - var v302 any = tmp301 - _ = v302 - // let binding "do-cmod" - var tmp303 lang.FnFunc - { // function do-cmod - var v304 lang.FnFunc - tmp303 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v305 := args[0] - _ = v305 - var tmp306 any - { // let - // let binding "vec__48" - var v307 any = v305 - _ = v307 - // let binding "seq__49" - tmp308 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp309 := tmp308.FindInternedVar(lang.NewSymbol("seq")) - if tmp309.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp309))) - } - tmp310 := tmp309.Get() - tmp311 := lang.Apply(tmp310, []any{v307}) - var v312 any = tmp311 - _ = v312 - // let binding "first__50" - tmp313 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp314 := tmp313.FindInternedVar(lang.NewSymbol("first")) - if tmp314.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp314))) - } - tmp315 := tmp314.Get() - tmp316 := lang.Apply(tmp315, []any{v312}) - var v317 any = tmp316 - _ = v317 - // let binding "seq__49" - tmp318 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp319 := tmp318.FindInternedVar(lang.NewSymbol("next")) - if tmp319.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp319))) - } - tmp320 := tmp319.Get() - tmp321 := lang.Apply(tmp320, []any{v312}) - var v322 any = tmp321 - _ = v322 - // let binding "vec__51" - var v323 any = v317 - _ = v323 - // let binding "k" - tmp324 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp325 := tmp324.FindInternedVar(lang.NewSymbol("nth")) - if tmp325.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp325))) - } - tmp326 := tmp325.Get() - tmp327 := lang.Apply(tmp326, []any{v323, int64(0), nil}) - var v328 any = tmp327 - _ = v328 - // let binding "v" - tmp329 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp330 := tmp329.FindInternedVar(lang.NewSymbol("nth")) - if tmp330.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp330))) - } - tmp331 := tmp330.Get() - tmp332 := lang.Apply(tmp331, []any{v323, int64(1), nil}) - var v333 any = tmp332 - _ = v333 - // let binding "pair" - var v334 any = v323 - _ = v334 - // let binding "etc" - var v335 any = v322 - _ = v335 - var tmp336 any - tmp337 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp338 := tmp337.FindInternedVar(lang.NewSymbol("=")) - if tmp338.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp338))) - } - tmp339 := tmp338.Get() - tmp340 := lang.Apply(tmp339, []any{v328, lang.NewKeyword("let")}) - if lang.IsTruthy(tmp340) { - tmp341 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp342 := tmp341.FindInternedVar(lang.NewSymbol("seq")) - if tmp342.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp342))) - } - tmp343 := tmp342.Get() - tmp344 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp345 := tmp344.FindInternedVar(lang.NewSymbol("concat")) - if tmp345.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp345))) - } - tmp346 := tmp345.Get() - tmp347 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp348 := tmp347.FindInternedVar(lang.NewSymbol("list")) - if tmp348.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp348))) - } - tmp349 := tmp348.Get() - tmp350 := lang.Apply(tmp349, []any{lang.NewSymbol("glojure.core/let")}) - tmp351 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp352 := tmp351.FindInternedVar(lang.NewSymbol("list")) - if tmp352.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp352))) - } - tmp353 := tmp352.Get() - tmp354 := lang.Apply(tmp353, []any{v333}) - tmp355 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp356 := tmp355.FindInternedVar(lang.NewSymbol("list")) - if tmp356.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp356))) - } - tmp357 := tmp356.Get() - tmp358 := lang.Apply(v304, []any{v335}) - tmp359 := lang.Apply(tmp357, []any{tmp358}) - tmp360 := lang.Apply(tmp346, []any{tmp350, tmp354, tmp359}) - tmp361 := lang.Apply(tmp343, []any{tmp360}) - tmp336 = tmp361 - } else { - var tmp362 any - tmp363 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp364 := tmp363.FindInternedVar(lang.NewSymbol("=")) - if tmp364.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp364))) - } - tmp365 := tmp364.Get() - tmp366 := lang.Apply(tmp365, []any{v328, lang.NewKeyword("while")}) - if lang.IsTruthy(tmp366) { - tmp367 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp368 := tmp367.FindInternedVar(lang.NewSymbol("seq")) - if tmp368.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp368))) - } - tmp369 := tmp368.Get() - tmp370 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp371 := tmp370.FindInternedVar(lang.NewSymbol("concat")) - if tmp371.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp371))) - } - tmp372 := tmp371.Get() - tmp373 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp374 := tmp373.FindInternedVar(lang.NewSymbol("list")) - if tmp374.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp374))) - } - tmp375 := tmp374.Get() - tmp376 := lang.Apply(tmp375, []any{lang.NewSymbol("glojure.core/when")}) - tmp377 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp378 := tmp377.FindInternedVar(lang.NewSymbol("list")) - if tmp378.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp378))) - } - tmp379 := tmp378.Get() - tmp380 := lang.Apply(tmp379, []any{v333}) - tmp381 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp382 := tmp381.FindInternedVar(lang.NewSymbol("list")) - if tmp382.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp382))) - } - tmp383 := tmp382.Get() - tmp384 := lang.Apply(v304, []any{v335}) - tmp385 := lang.Apply(tmp383, []any{tmp384}) - tmp386 := lang.Apply(tmp372, []any{tmp376, tmp380, tmp385}) - tmp387 := lang.Apply(tmp369, []any{tmp386}) - tmp362 = tmp387 - } else { - var tmp388 any - tmp389 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp390 := tmp389.FindInternedVar(lang.NewSymbol("=")) - if tmp390.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp390))) - } - tmp391 := tmp390.Get() - tmp392 := lang.Apply(tmp391, []any{v328, lang.NewKeyword("when")}) - if lang.IsTruthy(tmp392) { - tmp393 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp394 := tmp393.FindInternedVar(lang.NewSymbol("seq")) - if tmp394.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp394))) - } - tmp395 := tmp394.Get() - tmp396 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp397 := tmp396.FindInternedVar(lang.NewSymbol("concat")) - if tmp397.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp397))) - } - tmp398 := tmp397.Get() - tmp399 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp400 := tmp399.FindInternedVar(lang.NewSymbol("list")) - if tmp400.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp400))) - } - tmp401 := tmp400.Get() - tmp402 := lang.Apply(tmp401, []any{lang.NewSymbol("if")}) - tmp403 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp404 := tmp403.FindInternedVar(lang.NewSymbol("list")) - if tmp404.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp404))) - } - tmp405 := tmp404.Get() - tmp406 := lang.Apply(tmp405, []any{v333}) - tmp407 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp408 := tmp407.FindInternedVar(lang.NewSymbol("list")) - if tmp408.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp408))) - } - tmp409 := tmp408.Get() - tmp410 := lang.Apply(v304, []any{v335}) - tmp411 := lang.Apply(tmp409, []any{tmp410}) - tmp412 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp413 := tmp412.FindInternedVar(lang.NewSymbol("list")) - if tmp413.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp413))) - } - tmp414 := tmp413.Get() - tmp415 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp416 := tmp415.FindInternedVar(lang.NewSymbol("seq")) - if tmp416.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp416))) - } - tmp417 := tmp416.Get() - tmp418 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp419 := tmp418.FindInternedVar(lang.NewSymbol("concat")) - if tmp419.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp419))) - } - tmp420 := tmp419.Get() - tmp421 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp422 := tmp421.FindInternedVar(lang.NewSymbol("list")) - if tmp422.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp422))) - } - tmp423 := tmp422.Get() - tmp424 := lang.Apply(tmp423, []any{lang.NewSymbol("recur")}) - tmp425 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp426 := tmp425.FindInternedVar(lang.NewSymbol("list")) - if tmp426.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp426))) - } - tmp427 := tmp426.Get() - tmp428 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp429 := tmp428.FindInternedVar(lang.NewSymbol("seq")) - if tmp429.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp429))) - } - tmp430 := tmp429.Get() - tmp431 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp432 := tmp431.FindInternedVar(lang.NewSymbol("concat")) - if tmp432.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp432))) - } - tmp433 := tmp432.Get() - tmp434 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp435 := tmp434.FindInternedVar(lang.NewSymbol("list")) - if tmp435.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp435))) - } - tmp436 := tmp435.Get() - tmp437 := lang.Apply(tmp436, []any{lang.NewSymbol("glojure.core/unchecked-inc")}) - tmp438 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp439 := tmp438.FindInternedVar(lang.NewSymbol("list")) - if tmp439.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp439))) - } - tmp440 := tmp439.Get() - tmp441 := lang.Apply(tmp440, []any{v297}) - tmp442 := lang.Apply(tmp433, []any{tmp437, tmp441}) - tmp443 := lang.Apply(tmp430, []any{tmp442}) - tmp444 := lang.Apply(tmp427, []any{tmp443}) - tmp445 := lang.Apply(tmp420, []any{tmp424, tmp444}) - tmp446 := lang.Apply(tmp417, []any{tmp445}) - tmp447 := lang.Apply(tmp414, []any{tmp446}) - tmp448 := lang.Apply(tmp398, []any{tmp402, tmp406, tmp411, tmp447}) - tmp449 := lang.Apply(tmp395, []any{tmp448}) - tmp388 = tmp449 - } else { - var tmp450 any - tmp451 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp452 := tmp451.FindInternedVar(lang.NewSymbol("keyword?")) - if tmp452.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp452))) - } - tmp453 := tmp452.Get() - tmp454 := lang.Apply(tmp453, []any{v328}) - if lang.IsTruthy(tmp454) { - tmp455 := lang.Apply(v63, []any{"Invalid 'for' keyword ", v328}) - tmp450 = tmp455 - } else { - var tmp456 any - if lang.IsTruthy(lang.NewKeyword("else")) { - tmp457 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp458 := tmp457.FindInternedVar(lang.NewSymbol("seq")) - if tmp458.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp458))) - } - tmp459 := tmp458.Get() - tmp460 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp461 := tmp460.FindInternedVar(lang.NewSymbol("concat")) - if tmp461.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp461))) - } - tmp462 := tmp461.Get() - tmp463 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp464 := tmp463.FindInternedVar(lang.NewSymbol("list")) - if tmp464.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp464))) - } - tmp465 := tmp464.Get() - tmp466 := lang.Apply(tmp465, []any{lang.NewSymbol("do")}) - tmp467 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp468 := tmp467.FindInternedVar(lang.NewSymbol("list")) - if tmp468.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp468))) - } - tmp469 := tmp468.Get() - tmp470 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp471 := tmp470.FindInternedVar(lang.NewSymbol("seq")) - if tmp471.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp471))) - } - tmp472 := tmp471.Get() - tmp473 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp474 := tmp473.FindInternedVar(lang.NewSymbol("concat")) - if tmp474.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp474))) - } - tmp475 := tmp474.Get() - tmp476 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp477 := tmp476.FindInternedVar(lang.NewSymbol("list")) - if tmp477.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp477))) - } - tmp478 := tmp477.Get() - tmp479 := lang.Apply(tmp478, []any{lang.NewSymbol("glojure.core/chunk-append")}) - tmp480 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp481 := tmp480.FindInternedVar(lang.NewSymbol("list")) - if tmp481.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp481))) - } - tmp482 := tmp481.Get() - tmp483 := lang.Apply(tmp482, []any{v302}) - tmp484 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp485 := tmp484.FindInternedVar(lang.NewSymbol("list")) - if tmp485.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp485))) - } - tmp486 := tmp485.Get() - tmp487 := lang.Apply(tmp486, []any{v6}) - tmp488 := lang.Apply(tmp475, []any{tmp479, tmp483, tmp487}) - tmp489 := lang.Apply(tmp472, []any{tmp488}) - tmp490 := lang.Apply(tmp469, []any{tmp489}) - tmp491 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp492 := tmp491.FindInternedVar(lang.NewSymbol("list")) - if tmp492.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp492))) - } - tmp493 := tmp492.Get() - tmp494 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp495 := tmp494.FindInternedVar(lang.NewSymbol("seq")) - if tmp495.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp495))) - } - tmp496 := tmp495.Get() - tmp497 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp498 := tmp497.FindInternedVar(lang.NewSymbol("concat")) - if tmp498.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp498))) - } - tmp499 := tmp498.Get() - tmp500 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp501 := tmp500.FindInternedVar(lang.NewSymbol("list")) - if tmp501.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp501))) - } - tmp502 := tmp501.Get() - tmp503 := lang.Apply(tmp502, []any{lang.NewSymbol("recur")}) - tmp504 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp505 := tmp504.FindInternedVar(lang.NewSymbol("list")) - if tmp505.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp505))) - } - tmp506 := tmp505.Get() - tmp507 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp508 := tmp507.FindInternedVar(lang.NewSymbol("seq")) - if tmp508.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp508))) - } - tmp509 := tmp508.Get() - tmp510 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp511 := tmp510.FindInternedVar(lang.NewSymbol("concat")) - if tmp511.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp511))) - } - tmp512 := tmp511.Get() - tmp513 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp514 := tmp513.FindInternedVar(lang.NewSymbol("list")) - if tmp514.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp514))) - } - tmp515 := tmp514.Get() - tmp516 := lang.Apply(tmp515, []any{lang.NewSymbol("glojure.core/unchecked-inc")}) - tmp517 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp518 := tmp517.FindInternedVar(lang.NewSymbol("list")) - if tmp518.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp518))) - } - tmp519 := tmp518.Get() - tmp520 := lang.Apply(tmp519, []any{v297}) - tmp521 := lang.Apply(tmp512, []any{tmp516, tmp520}) - tmp522 := lang.Apply(tmp509, []any{tmp521}) - tmp523 := lang.Apply(tmp506, []any{tmp522}) - tmp524 := lang.Apply(tmp499, []any{tmp503, tmp523}) - tmp525 := lang.Apply(tmp496, []any{tmp524}) - tmp526 := lang.Apply(tmp493, []any{tmp525}) - tmp527 := lang.Apply(tmp462, []any{tmp466, tmp490, tmp526}) - tmp528 := lang.Apply(tmp459, []any{tmp527}) - tmp456 = tmp528 - } else { - } - tmp450 = tmp456 - } - tmp388 = tmp450 - } - tmp362 = tmp388 - } - tmp336 = tmp362 - } - tmp306 = tmp336 - } // end let - return tmp306 - }) - v304 = tmp303 - _ = v304 - } - tmp304 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4698), lang.NewKeyword("column"), int(39), lang.NewKeyword("end-line"), int(4710), lang.NewKeyword("end-column"), int(79)) - tmp305, err := lang.WithMeta(tmp303, tmp304.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v306 any = tmp305 - _ = v306 - tmp307 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp308 := tmp307.FindInternedVar(lang.NewSymbol("seq")) - if tmp308.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp308))) - } - tmp309 := tmp308.Get() - tmp310 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp311 := tmp310.FindInternedVar(lang.NewSymbol("concat")) - if tmp311.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp311))) - } - tmp312 := tmp311.Get() - tmp313 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp314 := tmp313.FindInternedVar(lang.NewSymbol("list")) - if tmp314.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp314))) - } - tmp315 := tmp314.Get() - tmp316 := lang.Apply(tmp315, []any{lang.NewSymbol("glojure.core/fn")}) - tmp317 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp318 := tmp317.FindInternedVar(lang.NewSymbol("list")) - if tmp318.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp318))) - } - tmp319 := tmp318.Get() - tmp320 := lang.Apply(tmp319, []any{v135}) - tmp321 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp322 := tmp321.FindInternedVar(lang.NewSymbol("list")) - if tmp322.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp322))) - } - tmp323 := tmp322.Get() - tmp324 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp325 := tmp324.FindInternedVar(lang.NewSymbol("apply")) - if tmp325.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp325))) - } - tmp326 := tmp325.Get() - tmp327 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp328 := tmp327.FindInternedVar(lang.NewSymbol("vector")) - if tmp328.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp328))) - } - tmp329 := tmp328.Get() - tmp330 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp331 := tmp330.FindInternedVar(lang.NewSymbol("seq")) - if tmp331.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp331))) - } - tmp332 := tmp331.Get() - tmp333 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp334 := tmp333.FindInternedVar(lang.NewSymbol("concat")) - if tmp334.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp334))) - } - tmp335 := tmp334.Get() - tmp336 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp337 := tmp336.FindInternedVar(lang.NewSymbol("list")) - if tmp337.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp337))) - } - tmp338 := tmp337.Get() - tmp339 := lang.Apply(tmp338, []any{v140}) - tmp340 := lang.Apply(tmp335, []any{tmp339}) - tmp341 := lang.Apply(tmp332, []any{tmp340}) - tmp342 := lang.Apply(tmp326, []any{tmp329, tmp341}) - tmp343 := lang.Apply(tmp323, []any{tmp342}) - tmp344 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp345 := tmp344.FindInternedVar(lang.NewSymbol("list")) - if tmp345.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp345))) - } - tmp346 := tmp345.Get() - tmp347 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp348 := tmp347.FindInternedVar(lang.NewSymbol("seq")) - if tmp348.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp348))) - } - tmp349 := tmp348.Get() - tmp350 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp351 := tmp350.FindInternedVar(lang.NewSymbol("concat")) - if tmp351.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp351))) - } - tmp352 := tmp351.Get() - tmp353 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp354 := tmp353.FindInternedVar(lang.NewSymbol("list")) - if tmp354.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp354))) - } - tmp355 := tmp354.Get() - tmp356 := lang.Apply(tmp355, []any{lang.NewSymbol("glojure.core/lazy-seq")}) - tmp357 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp358 := tmp357.FindInternedVar(lang.NewSymbol("list")) - if tmp358.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp358))) - } - tmp359 := tmp358.Get() - tmp360 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp361 := tmp360.FindInternedVar(lang.NewSymbol("seq")) - if tmp361.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp361))) - } - tmp362 := tmp361.Get() - tmp363 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp364 := tmp363.FindInternedVar(lang.NewSymbol("concat")) - if tmp364.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp364))) - } - tmp365 := tmp364.Get() - tmp366 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp367 := tmp366.FindInternedVar(lang.NewSymbol("list")) - if tmp367.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp367))) - } - tmp368 := tmp367.Get() - tmp369 := lang.Apply(tmp368, []any{lang.NewSymbol("glojure.core/loop")}) - tmp370 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp371 := tmp370.FindInternedVar(lang.NewSymbol("list")) - if tmp371.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp371))) - } - tmp372 := tmp371.Get() - tmp373 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp374 := tmp373.FindInternedVar(lang.NewSymbol("apply")) - if tmp374.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp374))) - } - tmp375 := tmp374.Get() - tmp376 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp377 := tmp376.FindInternedVar(lang.NewSymbol("vector")) - if tmp377.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp377))) - } - tmp378 := tmp377.Get() - tmp379 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp380 := tmp379.FindInternedVar(lang.NewSymbol("seq")) - if tmp380.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp380))) - } - tmp381 := tmp380.Get() - tmp382 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp383 := tmp382.FindInternedVar(lang.NewSymbol("concat")) - if tmp383.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp383))) - } - tmp384 := tmp383.Get() - tmp385 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp386 := tmp385.FindInternedVar(lang.NewSymbol("list")) - if tmp386.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp386))) - } - tmp387 := tmp386.Get() - tmp388 := lang.Apply(tmp387, []any{v140}) - tmp389 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp390 := tmp389.FindInternedVar(lang.NewSymbol("list")) - if tmp390.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp390))) - } - tmp391 := tmp390.Get() - tmp392 := lang.Apply(tmp391, []any{v140}) - tmp393 := lang.Apply(tmp384, []any{tmp388, tmp392}) - tmp394 := lang.Apply(tmp381, []any{tmp393}) - tmp395 := lang.Apply(tmp375, []any{tmp378, tmp394}) - tmp396 := lang.Apply(tmp372, []any{tmp395}) - tmp397 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp398 := tmp397.FindInternedVar(lang.NewSymbol("list")) - if tmp398.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp398))) - } - tmp399 := tmp398.Get() - tmp400 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp401 := tmp400.FindInternedVar(lang.NewSymbol("seq")) - if tmp401.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp401))) - } - tmp402 := tmp401.Get() - tmp403 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp404 := tmp403.FindInternedVar(lang.NewSymbol("concat")) - if tmp404.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp404))) - } - tmp405 := tmp404.Get() - tmp406 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp407 := tmp406.FindInternedVar(lang.NewSymbol("list")) - if tmp407.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp407))) - } - tmp408 := tmp407.Get() - tmp409 := lang.Apply(tmp408, []any{lang.NewSymbol("glojure.core/when-let")}) - tmp410 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp411 := tmp410.FindInternedVar(lang.NewSymbol("list")) - if tmp411.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp411))) - } - tmp412 := tmp411.Get() - tmp413 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp414 := tmp413.FindInternedVar(lang.NewSymbol("apply")) - if tmp414.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp414))) - } - tmp415 := tmp414.Get() - tmp416 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp417 := tmp416.FindInternedVar(lang.NewSymbol("vector")) - if tmp417.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp417))) - } - tmp418 := tmp417.Get() - tmp419 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp420 := tmp419.FindInternedVar(lang.NewSymbol("seq")) - if tmp420.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp420))) - } - tmp421 := tmp420.Get() - tmp422 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp423 := tmp422.FindInternedVar(lang.NewSymbol("concat")) - if tmp423.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp423))) - } - tmp424 := tmp423.Get() - tmp425 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp426 := tmp425.FindInternedVar(lang.NewSymbol("list")) - if tmp426.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp426))) - } - tmp427 := tmp426.Get() - tmp428 := lang.Apply(tmp427, []any{v140}) - tmp429 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp430 := tmp429.FindInternedVar(lang.NewSymbol("list")) - if tmp430.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp430))) - } - tmp431 := tmp430.Get() - tmp432 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp433 := tmp432.FindInternedVar(lang.NewSymbol("seq")) - if tmp433.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp433))) - } - tmp434 := tmp433.Get() - tmp435 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp436 := tmp435.FindInternedVar(lang.NewSymbol("concat")) - if tmp436.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp436))) - } - tmp437 := tmp436.Get() - tmp438 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp439 := tmp438.FindInternedVar(lang.NewSymbol("list")) - if tmp439.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp439))) - } - tmp440 := tmp439.Get() - tmp441 := lang.Apply(tmp440, []any{lang.NewSymbol("glojure.core/seq")}) - tmp442 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp443 := tmp442.FindInternedVar(lang.NewSymbol("list")) - if tmp443.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp443))) - } - tmp444 := tmp443.Get() - tmp445 := lang.Apply(tmp444, []any{v140}) - tmp446 := lang.Apply(tmp437, []any{tmp441, tmp445}) - tmp447 := lang.Apply(tmp434, []any{tmp446}) - tmp448 := lang.Apply(tmp431, []any{tmp447}) - tmp449 := lang.Apply(tmp424, []any{tmp428, tmp448}) - tmp450 := lang.Apply(tmp421, []any{tmp449}) - tmp451 := lang.Apply(tmp415, []any{tmp418, tmp450}) - tmp452 := lang.Apply(tmp412, []any{tmp451}) - tmp453 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp454 := tmp453.FindInternedVar(lang.NewSymbol("list")) - if tmp454.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp454))) - } - tmp455 := tmp454.Get() - tmp456 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp457 := tmp456.FindInternedVar(lang.NewSymbol("seq")) - if tmp457.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp457))) - } - tmp458 := tmp457.Get() - tmp459 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp460 := tmp459.FindInternedVar(lang.NewSymbol("concat")) - if tmp460.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp460))) - } - tmp461 := tmp460.Get() - tmp462 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp463 := tmp462.FindInternedVar(lang.NewSymbol("list")) - if tmp463.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp463))) - } - tmp464 := tmp463.Get() - tmp465 := lang.Apply(tmp464, []any{lang.NewSymbol("if")}) - tmp466 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp467 := tmp466.FindInternedVar(lang.NewSymbol("list")) - if tmp467.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp467))) - } - tmp468 := tmp467.Get() - tmp469 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp470 := tmp469.FindInternedVar(lang.NewSymbol("seq")) - if tmp470.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp470))) - } - tmp471 := tmp470.Get() - tmp472 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp473 := tmp472.FindInternedVar(lang.NewSymbol("concat")) - if tmp473.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp473))) - } - tmp474 := tmp473.Get() - tmp475 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp476 := tmp475.FindInternedVar(lang.NewSymbol("list")) - if tmp476.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp476))) - } - tmp477 := tmp476.Get() - tmp478 := lang.Apply(tmp477, []any{lang.NewSymbol("glojure.core/chunked-seq?")}) - tmp479 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp480 := tmp479.FindInternedVar(lang.NewSymbol("list")) - if tmp480.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp480))) - } - tmp481 := tmp480.Get() - tmp482 := lang.Apply(tmp481, []any{v140}) - tmp483 := lang.Apply(tmp474, []any{tmp478, tmp482}) - tmp484 := lang.Apply(tmp471, []any{tmp483}) - tmp485 := lang.Apply(tmp468, []any{tmp484}) - tmp486 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp487 := tmp486.FindInternedVar(lang.NewSymbol("list")) - if tmp487.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp487))) - } - tmp488 := tmp487.Get() - tmp489 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp490 := tmp489.FindInternedVar(lang.NewSymbol("seq")) - if tmp490.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp490))) - } - tmp491 := tmp490.Get() - tmp492 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp493 := tmp492.FindInternedVar(lang.NewSymbol("concat")) - if tmp493.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp493))) - } - tmp494 := tmp493.Get() - tmp495 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp496 := tmp495.FindInternedVar(lang.NewSymbol("list")) - if tmp496.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp496))) - } - tmp497 := tmp496.Get() - tmp498 := lang.Apply(tmp497, []any{lang.NewSymbol("glojure.core/let")}) - tmp499 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp500 := tmp499.FindInternedVar(lang.NewSymbol("list")) - if tmp500.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp500))) - } - tmp501 := tmp500.Get() - tmp502 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp503 := tmp502.FindInternedVar(lang.NewSymbol("apply")) - if tmp503.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp503))) - } - tmp504 := tmp503.Get() - tmp505 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp506 := tmp505.FindInternedVar(lang.NewSymbol("vector")) - if tmp506.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp506))) - } - tmp507 := tmp506.Get() - tmp508 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp509 := tmp508.FindInternedVar(lang.NewSymbol("seq")) - if tmp509.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp509))) - } - tmp510 := tmp509.Get() - tmp511 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp512 := tmp511.FindInternedVar(lang.NewSymbol("concat")) - if tmp512.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp512))) - } - tmp513 := tmp512.Get() - tmp514 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp515 := tmp514.FindInternedVar(lang.NewSymbol("list")) - if tmp515.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp515))) - } - tmp516 := tmp515.Get() - tmp517 := lang.Apply(tmp516, []any{lang.NewSymbol("c__0__auto__")}) - tmp518 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp519 := tmp518.FindInternedVar(lang.NewSymbol("list")) - if tmp519.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp519))) - } - tmp520 := tmp519.Get() - tmp521 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp522 := tmp521.FindInternedVar(lang.NewSymbol("seq")) - if tmp522.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp522))) - } - tmp523 := tmp522.Get() - tmp524 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp525 := tmp524.FindInternedVar(lang.NewSymbol("concat")) - if tmp525.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp525))) - } - tmp526 := tmp525.Get() - tmp527 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp528 := tmp527.FindInternedVar(lang.NewSymbol("list")) - if tmp528.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp528))) - } - tmp529 := tmp528.Get() - tmp530 := lang.Apply(tmp529, []any{lang.NewSymbol("glojure.core/chunk-first")}) - tmp531 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp532 := tmp531.FindInternedVar(lang.NewSymbol("list")) - if tmp532.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp532))) - } - tmp533 := tmp532.Get() - tmp534 := lang.Apply(tmp533, []any{v140}) - tmp535 := lang.Apply(tmp526, []any{tmp530, tmp534}) - tmp536 := lang.Apply(tmp523, []any{tmp535}) - tmp537 := lang.Apply(tmp520, []any{tmp536}) - tmp538 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp539 := tmp538.FindInternedVar(lang.NewSymbol("list")) - if tmp539.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp539))) - } - tmp540 := tmp539.Get() - tmp541 := lang.Apply(tmp540, []any{lang.NewSymbol("size__1__auto__")}) - tmp542 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp543 := tmp542.FindInternedVar(lang.NewSymbol("list")) - if tmp543.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp543))) - } - tmp544 := tmp543.Get() - tmp545 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp546 := tmp545.FindInternedVar(lang.NewSymbol("seq")) - if tmp546.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp546))) - } - tmp547 := tmp546.Get() - tmp548 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp549 := tmp548.FindInternedVar(lang.NewSymbol("concat")) - if tmp549.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp549))) - } - tmp550 := tmp549.Get() - tmp551 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp552 := tmp551.FindInternedVar(lang.NewSymbol("list")) - if tmp552.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp552))) - } - tmp553 := tmp552.Get() - tmp554 := lang.Apply(tmp553, []any{lang.NewSymbol("glojure.core/int")}) - tmp555 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp556 := tmp555.FindInternedVar(lang.NewSymbol("list")) - if tmp556.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp556))) - } - tmp557 := tmp556.Get() - tmp558 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp559 := tmp558.FindInternedVar(lang.NewSymbol("seq")) - if tmp559.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp559))) - } - tmp560 := tmp559.Get() - tmp561 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp562 := tmp561.FindInternedVar(lang.NewSymbol("concat")) - if tmp562.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp562))) - } - tmp563 := tmp562.Get() - tmp564 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp565 := tmp564.FindInternedVar(lang.NewSymbol("list")) - if tmp565.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp565))) - } - tmp566 := tmp565.Get() - tmp567 := lang.Apply(tmp566, []any{lang.NewSymbol("glojure.core/count")}) - tmp568 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp569 := tmp568.FindInternedVar(lang.NewSymbol("list")) - if tmp569.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp569))) - } - tmp570 := tmp569.Get() - tmp571 := lang.Apply(tmp570, []any{lang.NewSymbol("c__0__auto__")}) - tmp572 := lang.Apply(tmp563, []any{tmp567, tmp571}) - tmp573 := lang.Apply(tmp560, []any{tmp572}) - tmp574 := lang.Apply(tmp557, []any{tmp573}) - tmp575 := lang.Apply(tmp550, []any{tmp554, tmp574}) - tmp576 := lang.Apply(tmp547, []any{tmp575}) - tmp577 := lang.Apply(tmp544, []any{tmp576}) - tmp578 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp579 := tmp578.FindInternedVar(lang.NewSymbol("list")) - if tmp579.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp579))) - } - tmp580 := tmp579.Get() - tmp581 := lang.Apply(tmp580, []any{v302}) - tmp582 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp583 := tmp582.FindInternedVar(lang.NewSymbol("list")) - if tmp583.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp583))) - } - tmp584 := tmp583.Get() - tmp585 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp586 := tmp585.FindInternedVar(lang.NewSymbol("seq")) - if tmp586.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp586))) - } - tmp587 := tmp586.Get() - tmp588 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp589 := tmp588.FindInternedVar(lang.NewSymbol("concat")) - if tmp589.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp589))) - } - tmp590 := tmp589.Get() - tmp591 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp592 := tmp591.FindInternedVar(lang.NewSymbol("list")) - if tmp592.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp592))) - } - tmp593 := tmp592.Get() - tmp594 := lang.Apply(tmp593, []any{lang.NewSymbol("glojure.core/chunk-buffer")}) - tmp595 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp596 := tmp595.FindInternedVar(lang.NewSymbol("list")) - if tmp596.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp596))) - } - tmp597 := tmp596.Get() - tmp598 := lang.Apply(tmp597, []any{lang.NewSymbol("size__1__auto__")}) - tmp599 := lang.Apply(tmp590, []any{tmp594, tmp598}) - tmp600 := lang.Apply(tmp587, []any{tmp599}) - tmp601 := lang.Apply(tmp584, []any{tmp600}) - tmp602 := lang.Apply(tmp513, []any{tmp517, tmp537, tmp541, tmp577, tmp581, tmp601}) - tmp603 := lang.Apply(tmp510, []any{tmp602}) - tmp604 := lang.Apply(tmp504, []any{tmp507, tmp603}) - tmp605 := lang.Apply(tmp501, []any{tmp604}) - tmp606 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp607 := tmp606.FindInternedVar(lang.NewSymbol("list")) - if tmp607.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp607))) - } - tmp608 := tmp607.Get() - tmp609 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp610 := tmp609.FindInternedVar(lang.NewSymbol("seq")) - if tmp610.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp610))) - } - tmp611 := tmp610.Get() - tmp612 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp613 := tmp612.FindInternedVar(lang.NewSymbol("concat")) - if tmp613.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp613))) - } - tmp614 := tmp613.Get() - tmp615 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp616 := tmp615.FindInternedVar(lang.NewSymbol("list")) - if tmp616.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp616))) - } - tmp617 := tmp616.Get() - tmp618 := lang.Apply(tmp617, []any{lang.NewSymbol("if")}) - tmp619 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp620 := tmp619.FindInternedVar(lang.NewSymbol("list")) - if tmp620.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp620))) - } - tmp621 := tmp620.Get() - tmp622 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp623 := tmp622.FindInternedVar(lang.NewSymbol("seq")) - if tmp623.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp623))) - } - tmp624 := tmp623.Get() - tmp625 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp626 := tmp625.FindInternedVar(lang.NewSymbol("concat")) - if tmp626.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp626))) - } - tmp627 := tmp626.Get() - tmp628 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp629 := tmp628.FindInternedVar(lang.NewSymbol("list")) - if tmp629.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp629))) - } - tmp630 := tmp629.Get() - tmp631 := lang.Apply(tmp630, []any{lang.NewSymbol("glojure.core/loop")}) - tmp632 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp633 := tmp632.FindInternedVar(lang.NewSymbol("list")) - if tmp633.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp633))) - } - tmp634 := tmp633.Get() - tmp635 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp636 := tmp635.FindInternedVar(lang.NewSymbol("apply")) - if tmp636.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp636))) - } - tmp637 := tmp636.Get() - tmp638 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp639 := tmp638.FindInternedVar(lang.NewSymbol("vector")) - if tmp639.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp639))) - } - tmp640 := tmp639.Get() - tmp641 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp642 := tmp641.FindInternedVar(lang.NewSymbol("seq")) - if tmp642.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp642))) - } - tmp643 := tmp642.Get() - tmp644 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp645 := tmp644.FindInternedVar(lang.NewSymbol("concat")) - if tmp645.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp645))) - } - tmp646 := tmp645.Get() - tmp647 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp648 := tmp647.FindInternedVar(lang.NewSymbol("list")) - if tmp648.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp648))) - } - tmp649 := tmp648.Get() - tmp650 := lang.Apply(tmp649, []any{v297}) - tmp651 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp652 := tmp651.FindInternedVar(lang.NewSymbol("list")) - if tmp652.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp652))) - } - tmp653 := tmp652.Get() - tmp654 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp655 := tmp654.FindInternedVar(lang.NewSymbol("seq")) - if tmp655.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp655))) - } - tmp656 := tmp655.Get() - tmp657 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp658 := tmp657.FindInternedVar(lang.NewSymbol("concat")) - if tmp658.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp658))) - } - tmp659 := tmp658.Get() - tmp660 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp661 := tmp660.FindInternedVar(lang.NewSymbol("list")) - if tmp661.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp661))) - } - tmp662 := tmp661.Get() - tmp663 := lang.Apply(tmp662, []any{lang.NewSymbol("glojure.core/int")}) - tmp664 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp665 := tmp664.FindInternedVar(lang.NewSymbol("list")) - if tmp665.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp665))) - } - tmp666 := tmp665.Get() - tmp667 := lang.Apply(tmp666, []any{int64(0)}) - tmp668 := lang.Apply(tmp659, []any{tmp663, tmp667}) - tmp669 := lang.Apply(tmp656, []any{tmp668}) - tmp670 := lang.Apply(tmp653, []any{tmp669}) - tmp671 := lang.Apply(tmp646, []any{tmp650, tmp670}) - tmp672 := lang.Apply(tmp643, []any{tmp671}) - tmp673 := lang.Apply(tmp637, []any{tmp640, tmp672}) - tmp674 := lang.Apply(tmp634, []any{tmp673}) - tmp675 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp676 := tmp675.FindInternedVar(lang.NewSymbol("list")) - if tmp676.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp676))) - } - tmp677 := tmp676.Get() - tmp678 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp679 := tmp678.FindInternedVar(lang.NewSymbol("seq")) - if tmp679.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp679))) - } - tmp680 := tmp679.Get() - tmp681 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp682 := tmp681.FindInternedVar(lang.NewSymbol("concat")) - if tmp682.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp682))) - } - tmp683 := tmp682.Get() - tmp684 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp685 := tmp684.FindInternedVar(lang.NewSymbol("list")) - if tmp685.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp685))) - } - tmp686 := tmp685.Get() - tmp687 := lang.Apply(tmp686, []any{lang.NewSymbol("if")}) - tmp688 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp689 := tmp688.FindInternedVar(lang.NewSymbol("list")) - if tmp689.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp689))) - } - tmp690 := tmp689.Get() - tmp691 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp692 := tmp691.FindInternedVar(lang.NewSymbol("seq")) - if tmp692.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp692))) - } - tmp693 := tmp692.Get() - tmp694 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp695 := tmp694.FindInternedVar(lang.NewSymbol("concat")) - if tmp695.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp695))) - } - tmp696 := tmp695.Get() - tmp697 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp698 := tmp697.FindInternedVar(lang.NewSymbol("list")) - if tmp698.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp698))) - } - tmp699 := tmp698.Get() - tmp700 := lang.Apply(tmp699, []any{lang.NewSymbol("glojure.core/<")}) - tmp701 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp702 := tmp701.FindInternedVar(lang.NewSymbol("list")) - if tmp702.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp702))) - } - tmp703 := tmp702.Get() - tmp704 := lang.Apply(tmp703, []any{v297}) - tmp705 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp706 := tmp705.FindInternedVar(lang.NewSymbol("list")) - if tmp706.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp706))) - } - tmp707 := tmp706.Get() - tmp708 := lang.Apply(tmp707, []any{lang.NewSymbol("size__1__auto__")}) - tmp709 := lang.Apply(tmp696, []any{tmp700, tmp704, tmp708}) - tmp710 := lang.Apply(tmp693, []any{tmp709}) - tmp711 := lang.Apply(tmp690, []any{tmp710}) - tmp712 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp713 := tmp712.FindInternedVar(lang.NewSymbol("list")) - if tmp713.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp713))) - } - tmp714 := tmp713.Get() - tmp715 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp716 := tmp715.FindInternedVar(lang.NewSymbol("seq")) - if tmp716.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp716))) - } - tmp717 := tmp716.Get() - tmp718 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp719 := tmp718.FindInternedVar(lang.NewSymbol("concat")) - if tmp719.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp719))) - } - tmp720 := tmp719.Get() - tmp721 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp722 := tmp721.FindInternedVar(lang.NewSymbol("list")) - if tmp722.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp722))) - } - tmp723 := tmp722.Get() - tmp724 := lang.Apply(tmp723, []any{lang.NewSymbol("glojure.core/let")}) - tmp725 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp726 := tmp725.FindInternedVar(lang.NewSymbol("list")) - if tmp726.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp726))) - } - tmp727 := tmp726.Get() - tmp728 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp729 := tmp728.FindInternedVar(lang.NewSymbol("apply")) - if tmp729.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp729))) - } - tmp730 := tmp729.Get() - tmp731 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp732 := tmp731.FindInternedVar(lang.NewSymbol("vector")) - if tmp732.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp732))) - } - tmp733 := tmp732.Get() - tmp734 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp735 := tmp734.FindInternedVar(lang.NewSymbol("seq")) - if tmp735.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp735))) - } - tmp736 := tmp735.Get() - tmp737 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp738 := tmp737.FindInternedVar(lang.NewSymbol("concat")) - if tmp738.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp738))) - } - tmp739 := tmp738.Get() - tmp740 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp741 := tmp740.FindInternedVar(lang.NewSymbol("list")) - if tmp741.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp741))) - } - tmp742 := tmp741.Get() - tmp743 := lang.Apply(tmp742, []any{v100}) - tmp744 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp745 := tmp744.FindInternedVar(lang.NewSymbol("list")) - if tmp745.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp745))) - } - tmp746 := tmp745.Get() - tmp747 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp748 := tmp747.FindInternedVar(lang.NewSymbol("seq")) - if tmp748.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp748))) - } - tmp749 := tmp748.Get() - tmp750 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp751 := tmp750.FindInternedVar(lang.NewSymbol("concat")) - if tmp751.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp751))) - } - tmp752 := tmp751.Get() - tmp753 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp754 := tmp753.FindInternedVar(lang.NewSymbol("list")) - if tmp754.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp754))) - } - tmp755 := tmp754.Get() - tmp756 := lang.Apply(tmp755, []any{lang.NewSymbol(".nth")}) - tmp757 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp758 := tmp757.FindInternedVar(lang.NewSymbol("list")) - if tmp758.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp758))) - } - tmp759 := tmp758.Get() - tmp760 := lang.Apply(tmp759, []any{lang.NewSymbol("c__0__auto__")}) - tmp761 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp762 := tmp761.FindInternedVar(lang.NewSymbol("list")) - if tmp762.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp762))) - } - tmp763 := tmp762.Get() - tmp764 := lang.Apply(tmp763, []any{v297}) - tmp765 := lang.Apply(tmp752, []any{tmp756, tmp760, tmp764}) - tmp766 := lang.Apply(tmp749, []any{tmp765}) - tmp767 := lang.Apply(tmp746, []any{tmp766}) - tmp768 := lang.Apply(tmp739, []any{tmp743, tmp767}) - tmp769 := lang.Apply(tmp736, []any{tmp768}) - tmp770 := lang.Apply(tmp730, []any{tmp733, tmp769}) - tmp771 := lang.Apply(tmp727, []any{tmp770}) - tmp772 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp773 := tmp772.FindInternedVar(lang.NewSymbol("list")) - if tmp773.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp773))) - } - tmp774 := tmp773.Get() - tmp775 := lang.Apply(v306, []any{v112}) - tmp776 := lang.Apply(tmp774, []any{tmp775}) - tmp777 := lang.Apply(tmp720, []any{tmp724, tmp771, tmp776}) - tmp778 := lang.Apply(tmp717, []any{tmp777}) - tmp779 := lang.Apply(tmp714, []any{tmp778}) - tmp780 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp781 := tmp780.FindInternedVar(lang.NewSymbol("list")) - if tmp781.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp781))) - } - tmp782 := tmp781.Get() - tmp783 := lang.Apply(tmp782, []any{true}) - tmp784 := lang.Apply(tmp683, []any{tmp687, tmp711, tmp779, tmp783}) - tmp785 := lang.Apply(tmp680, []any{tmp784}) - tmp786 := lang.Apply(tmp677, []any{tmp785}) - tmp787 := lang.Apply(tmp627, []any{tmp631, tmp674, tmp786}) - tmp788 := lang.Apply(tmp624, []any{tmp787}) - tmp789 := lang.Apply(tmp621, []any{tmp788}) - tmp790 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp791 := tmp790.FindInternedVar(lang.NewSymbol("list")) - if tmp791.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp791))) - } - tmp792 := tmp791.Get() - tmp793 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp794 := tmp793.FindInternedVar(lang.NewSymbol("seq")) - if tmp794.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp794))) - } - tmp795 := tmp794.Get() - tmp796 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp797 := tmp796.FindInternedVar(lang.NewSymbol("concat")) - if tmp797.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp797))) - } - tmp798 := tmp797.Get() - tmp799 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp800 := tmp799.FindInternedVar(lang.NewSymbol("list")) - if tmp800.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp800))) - } - tmp801 := tmp800.Get() - tmp802 := lang.Apply(tmp801, []any{lang.NewSymbol("glojure.core/chunk-cons")}) - tmp803 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp804 := tmp803.FindInternedVar(lang.NewSymbol("list")) - if tmp804.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp804))) - } - tmp805 := tmp804.Get() - tmp806 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp807 := tmp806.FindInternedVar(lang.NewSymbol("seq")) - if tmp807.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp807))) - } - tmp808 := tmp807.Get() - tmp809 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp810 := tmp809.FindInternedVar(lang.NewSymbol("concat")) - if tmp810.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp810))) - } - tmp811 := tmp810.Get() - tmp812 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp813 := tmp812.FindInternedVar(lang.NewSymbol("list")) - if tmp813.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp813))) - } - tmp814 := tmp813.Get() - tmp815 := lang.Apply(tmp814, []any{lang.NewSymbol("glojure.core/chunk")}) - tmp816 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp817 := tmp816.FindInternedVar(lang.NewSymbol("list")) - if tmp817.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp817))) - } - tmp818 := tmp817.Get() - tmp819 := lang.Apply(tmp818, []any{v302}) - tmp820 := lang.Apply(tmp811, []any{tmp815, tmp819}) - tmp821 := lang.Apply(tmp808, []any{tmp820}) - tmp822 := lang.Apply(tmp805, []any{tmp821}) - tmp823 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp824 := tmp823.FindInternedVar(lang.NewSymbol("list")) - if tmp824.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp824))) - } - tmp825 := tmp824.Get() - tmp826 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp827 := tmp826.FindInternedVar(lang.NewSymbol("seq")) - if tmp827.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp827))) - } - tmp828 := tmp827.Get() - tmp829 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp830 := tmp829.FindInternedVar(lang.NewSymbol("concat")) - if tmp830.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp830))) - } - tmp831 := tmp830.Get() - tmp832 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp833 := tmp832.FindInternedVar(lang.NewSymbol("list")) - if tmp833.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp833))) - } - tmp834 := tmp833.Get() - tmp835 := lang.Apply(tmp834, []any{v135}) - tmp836 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp837 := tmp836.FindInternedVar(lang.NewSymbol("list")) - if tmp837.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp837))) - } - tmp838 := tmp837.Get() - tmp839 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp840 := tmp839.FindInternedVar(lang.NewSymbol("seq")) - if tmp840.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp840))) - } - tmp841 := tmp840.Get() - tmp842 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp843 := tmp842.FindInternedVar(lang.NewSymbol("concat")) - if tmp843.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp843))) - } - tmp844 := tmp843.Get() - tmp845 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp846 := tmp845.FindInternedVar(lang.NewSymbol("list")) - if tmp846.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp846))) - } - tmp847 := tmp846.Get() - tmp848 := lang.Apply(tmp847, []any{lang.NewSymbol("glojure.core/chunk-rest")}) - tmp849 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp850 := tmp849.FindInternedVar(lang.NewSymbol("list")) - if tmp850.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp850))) - } - tmp851 := tmp850.Get() - tmp852 := lang.Apply(tmp851, []any{v140}) - tmp853 := lang.Apply(tmp844, []any{tmp848, tmp852}) - tmp854 := lang.Apply(tmp841, []any{tmp853}) - tmp855 := lang.Apply(tmp838, []any{tmp854}) - tmp856 := lang.Apply(tmp831, []any{tmp835, tmp855}) - tmp857 := lang.Apply(tmp828, []any{tmp856}) - tmp858 := lang.Apply(tmp825, []any{tmp857}) - tmp859 := lang.Apply(tmp798, []any{tmp802, tmp822, tmp858}) - tmp860 := lang.Apply(tmp795, []any{tmp859}) - tmp861 := lang.Apply(tmp792, []any{tmp860}) - tmp862 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp863 := tmp862.FindInternedVar(lang.NewSymbol("list")) - if tmp863.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp863))) - } - tmp864 := tmp863.Get() - tmp865 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp866 := tmp865.FindInternedVar(lang.NewSymbol("seq")) - if tmp866.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp866))) - } - tmp867 := tmp866.Get() - tmp868 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp869 := tmp868.FindInternedVar(lang.NewSymbol("concat")) - if tmp869.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp869))) - } - tmp870 := tmp869.Get() - tmp871 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp872 := tmp871.FindInternedVar(lang.NewSymbol("list")) - if tmp872.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp872))) - } - tmp873 := tmp872.Get() - tmp874 := lang.Apply(tmp873, []any{lang.NewSymbol("glojure.core/chunk-cons")}) - tmp875 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp876 := tmp875.FindInternedVar(lang.NewSymbol("list")) - if tmp876.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp876))) - } - tmp877 := tmp876.Get() - tmp878 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp879 := tmp878.FindInternedVar(lang.NewSymbol("seq")) - if tmp879.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp879))) - } - tmp880 := tmp879.Get() - tmp881 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp882 := tmp881.FindInternedVar(lang.NewSymbol("concat")) - if tmp882.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp882))) - } - tmp883 := tmp882.Get() - tmp884 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp885 := tmp884.FindInternedVar(lang.NewSymbol("list")) - if tmp885.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp885))) - } - tmp886 := tmp885.Get() - tmp887 := lang.Apply(tmp886, []any{lang.NewSymbol("glojure.core/chunk")}) - tmp888 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp889 := tmp888.FindInternedVar(lang.NewSymbol("list")) - if tmp889.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp889))) - } - tmp890 := tmp889.Get() - tmp891 := lang.Apply(tmp890, []any{v302}) - tmp892 := lang.Apply(tmp883, []any{tmp887, tmp891}) - tmp893 := lang.Apply(tmp880, []any{tmp892}) - tmp894 := lang.Apply(tmp877, []any{tmp893}) - tmp895 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp896 := tmp895.FindInternedVar(lang.NewSymbol("list")) - if tmp896.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp896))) - } - tmp897 := tmp896.Get() - tmp898 := lang.Apply(tmp897, []any{nil}) - tmp899 := lang.Apply(tmp870, []any{tmp874, tmp894, tmp898}) - tmp900 := lang.Apply(tmp867, []any{tmp899}) - tmp901 := lang.Apply(tmp864, []any{tmp900}) - tmp902 := lang.Apply(tmp614, []any{tmp618, tmp789, tmp861, tmp901}) - tmp903 := lang.Apply(tmp611, []any{tmp902}) - tmp904 := lang.Apply(tmp608, []any{tmp903}) - tmp905 := lang.Apply(tmp494, []any{tmp498, tmp605, tmp904}) - tmp906 := lang.Apply(tmp491, []any{tmp905}) - tmp907 := lang.Apply(tmp488, []any{tmp906}) - tmp908 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp909 := tmp908.FindInternedVar(lang.NewSymbol("list")) - if tmp909.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp909))) - } - tmp910 := tmp909.Get() - tmp911 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp912 := tmp911.FindInternedVar(lang.NewSymbol("seq")) - if tmp912.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp912))) - } - tmp913 := tmp912.Get() - tmp914 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp915 := tmp914.FindInternedVar(lang.NewSymbol("concat")) - if tmp915.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp915))) - } - tmp916 := tmp915.Get() - tmp917 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp918 := tmp917.FindInternedVar(lang.NewSymbol("list")) - if tmp918.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp918))) - } - tmp919 := tmp918.Get() - tmp920 := lang.Apply(tmp919, []any{lang.NewSymbol("glojure.core/let")}) - tmp921 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp922 := tmp921.FindInternedVar(lang.NewSymbol("list")) - if tmp922.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp922))) - } - tmp923 := tmp922.Get() - tmp924 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp925 := tmp924.FindInternedVar(lang.NewSymbol("apply")) - if tmp925.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp925))) - } - tmp926 := tmp925.Get() - tmp927 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp928 := tmp927.FindInternedVar(lang.NewSymbol("vector")) - if tmp928.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp928))) - } - tmp929 := tmp928.Get() - tmp930 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp931 := tmp930.FindInternedVar(lang.NewSymbol("seq")) - if tmp931.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp931))) - } - tmp932 := tmp931.Get() - tmp933 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp934 := tmp933.FindInternedVar(lang.NewSymbol("concat")) - if tmp934.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp934))) - } - tmp935 := tmp934.Get() - tmp936 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp937 := tmp936.FindInternedVar(lang.NewSymbol("list")) - if tmp937.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp937))) - } - tmp938 := tmp937.Get() - tmp939 := lang.Apply(tmp938, []any{v100}) - tmp940 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp941 := tmp940.FindInternedVar(lang.NewSymbol("list")) - if tmp941.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp941))) - } - tmp942 := tmp941.Get() - tmp943 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp944 := tmp943.FindInternedVar(lang.NewSymbol("seq")) - if tmp944.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp944))) - } - tmp945 := tmp944.Get() - tmp946 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp947 := tmp946.FindInternedVar(lang.NewSymbol("concat")) - if tmp947.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp947))) - } - tmp948 := tmp947.Get() - tmp949 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp950 := tmp949.FindInternedVar(lang.NewSymbol("list")) - if tmp950.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp950))) - } - tmp951 := tmp950.Get() - tmp952 := lang.Apply(tmp951, []any{lang.NewSymbol("glojure.core/first")}) - tmp953 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp954 := tmp953.FindInternedVar(lang.NewSymbol("list")) - if tmp954.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp954))) - } - tmp955 := tmp954.Get() - tmp956 := lang.Apply(tmp955, []any{v140}) - tmp957 := lang.Apply(tmp948, []any{tmp952, tmp956}) - tmp958 := lang.Apply(tmp945, []any{tmp957}) - tmp959 := lang.Apply(tmp942, []any{tmp958}) - tmp960 := lang.Apply(tmp935, []any{tmp939, tmp959}) - tmp961 := lang.Apply(tmp932, []any{tmp960}) - tmp962 := lang.Apply(tmp926, []any{tmp929, tmp961}) - tmp963 := lang.Apply(tmp923, []any{tmp962}) - tmp964 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp965 := tmp964.FindInternedVar(lang.NewSymbol("list")) - if tmp965.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp965))) - } - tmp966 := tmp965.Get() - tmp967 := lang.Apply(v144, []any{v112}) - tmp968 := lang.Apply(tmp966, []any{tmp967}) - tmp969 := lang.Apply(tmp916, []any{tmp920, tmp963, tmp968}) - tmp970 := lang.Apply(tmp913, []any{tmp969}) - tmp971 := lang.Apply(tmp910, []any{tmp970}) - tmp972 := lang.Apply(tmp461, []any{tmp465, tmp485, tmp907, tmp971}) - tmp973 := lang.Apply(tmp458, []any{tmp972}) - tmp974 := lang.Apply(tmp455, []any{tmp973}) - tmp975 := lang.Apply(tmp405, []any{tmp409, tmp452, tmp974}) - tmp976 := lang.Apply(tmp402, []any{tmp975}) - tmp977 := lang.Apply(tmp399, []any{tmp976}) - tmp978 := lang.Apply(tmp365, []any{tmp369, tmp396, tmp977}) - tmp979 := lang.Apply(tmp362, []any{tmp978}) - tmp980 := lang.Apply(tmp359, []any{tmp979}) - tmp981 := lang.Apply(tmp352, []any{tmp356, tmp980}) - tmp982 := lang.Apply(tmp349, []any{tmp981}) - tmp983 := lang.Apply(tmp346, []any{tmp982}) - tmp984 := lang.Apply(tmp312, []any{tmp316, tmp320, tmp343, tmp983}) - tmp985 := lang.Apply(tmp309, []any{tmp984}) - tmp292 = tmp985 - } // end let - tmp145 = tmp292 - } - tmp130 = tmp145 - } // end let - tmp67 = tmp130 - } // end let - return tmp67 - }) - v65 = tmp64 - _ = v65 - } - tmp65 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4668), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(4729), lang.NewKeyword("end-column"), int(68)) - tmp66, err := lang.WithMeta(tmp64, tmp65.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v67 any = tmp66 - _ = v67 - tmp68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp69 := tmp68.FindInternedVar(lang.NewSymbol("seq")) - if tmp69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp69))) - } - tmp70 := tmp69.Get() - tmp71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp72 := tmp71.FindInternedVar(lang.NewSymbol("concat")) - if tmp72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp72))) - } - tmp73 := tmp72.Get() - tmp74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp75 := tmp74.FindInternedVar(lang.NewSymbol("list")) - if tmp75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp75))) - } - tmp76 := tmp75.Get() - tmp77 := lang.Apply(tmp76, []any{lang.NewSymbol("glojure.core/let")}) - tmp78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp79 := tmp78.FindInternedVar(lang.NewSymbol("list")) - if tmp79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp79))) - } - tmp80 := tmp79.Get() - tmp81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp82 := tmp81.FindInternedVar(lang.NewSymbol("apply")) - if tmp82.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp82))) - } - tmp83 := tmp82.Get() - tmp84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp85 := tmp84.FindInternedVar(lang.NewSymbol("vector")) - if tmp85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp85))) - } - tmp86 := tmp85.Get() - tmp87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp88 := tmp87.FindInternedVar(lang.NewSymbol("seq")) - if tmp88.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp88))) - } - tmp89 := tmp88.Get() - tmp90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp91 := tmp90.FindInternedVar(lang.NewSymbol("concat")) - if tmp91.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp91))) - } - tmp92 := tmp91.Get() - tmp93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp94 := tmp93.FindInternedVar(lang.NewSymbol("list")) - if tmp94.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp94))) - } - tmp95 := tmp94.Get() - tmp96 := lang.Apply(tmp95, []any{lang.NewSymbol("iter__0__auto__")}) - tmp97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp98 := tmp97.FindInternedVar(lang.NewSymbol("list")) - if tmp98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp98))) - } - tmp99 := tmp98.Get() - tmp100 := lang.Apply(v59, []any{v5}) - tmp101 := lang.Apply(v67, []any{tmp100}) - tmp102 := lang.Apply(tmp99, []any{tmp101}) - tmp103 := lang.Apply(tmp92, []any{tmp96, tmp102}) - tmp104 := lang.Apply(tmp89, []any{tmp103}) - tmp105 := lang.Apply(tmp83, []any{tmp86, tmp104}) - tmp106 := lang.Apply(tmp80, []any{tmp105}) - tmp107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp108 := tmp107.FindInternedVar(lang.NewSymbol("list")) - if tmp108.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp108))) - } - tmp109 := tmp108.Get() - tmp110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp111 := tmp110.FindInternedVar(lang.NewSymbol("seq")) - if tmp111.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp111))) - } - tmp112 := tmp111.Get() - tmp113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp114 := tmp113.FindInternedVar(lang.NewSymbol("concat")) - if tmp114.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp114))) - } - tmp115 := tmp114.Get() - tmp116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp117 := tmp116.FindInternedVar(lang.NewSymbol("list")) - if tmp117.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp117))) - } - tmp118 := tmp117.Get() - tmp119 := lang.Apply(tmp118, []any{lang.NewSymbol("iter__0__auto__")}) - tmp120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp121 := tmp120.FindInternedVar(lang.NewSymbol("list")) - if tmp121.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp121))) - } - tmp122 := tmp121.Get() - tmp123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp124 := tmp123.FindInternedVar(lang.NewSymbol("second")) - if tmp124.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp124))) - } - tmp125 := tmp124.Get() - tmp126 := lang.Apply(tmp125, []any{v5}) - tmp127 := lang.Apply(tmp122, []any{tmp126}) - tmp128 := lang.Apply(tmp115, []any{tmp119, tmp127}) - tmp129 := lang.Apply(tmp112, []any{tmp128}) - tmp130 := lang.Apply(tmp109, []any{tmp129}) - tmp131 := lang.Apply(tmp73, []any{tmp77, tmp106, tmp130}) - tmp132 := lang.Apply(tmp70, []any{tmp131}) - tmp55 = tmp132 - } // end let - return tmp55 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // force - { - tmp0 := lang.NewSymbol("force").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "If x is a Delay, returns the (possibly cached) value of its expression, else returns x", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(754), lang.NewKeyword("end-line"), int(754))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4, _ := lang.FieldOrMethod(nil, "force") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("force is not a function"))) - } - tmp5 := lang.Apply(tmp4, []any{v3}) - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // format - { - tmp0 := lang.NewSymbol("format").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fmt"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Formats a string using java.lang.String.format, see java.util.Formatter for format\n string syntax", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5717), lang.NewKeyword("end-line"), int(5717))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var v4 any = lang.NewList(args[1:]...) - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("apply")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{fmt.Sprintf, v3, v4}) - return tmp8 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // frequencies - { - tmp0 := lang.NewSymbol("frequencies").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a map from distinct items in coll to the number of times\n they appear.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7185), lang.NewKeyword("end-line"), int(7185))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("persistent!")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("reduce")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - var tmp10 lang.FnFunc - tmp10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v11 := args[0] - _ = v11 - v12 := args[1] - _ = v12 - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("assoc!")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("inc")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("get")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, []any{v11, v12, int64(0)}) - tmp23 := lang.Apply(tmp18, []any{tmp22}) - tmp24 := lang.Apply(tmp15, []any{v11, v12, tmp23}) - return tmp24 - }) - tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7192), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(7193), lang.NewKeyword("end-column"), int(54)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("transient")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.NewMap() - tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7194), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(7194), lang.NewKeyword("end-column"), int(24)) - tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp19 := lang.Apply(tmp15, []any{tmp18}) - tmp20 := lang.Apply(tmp9, []any{tmp12, tmp19, v3}) - tmp21 := lang.Apply(tmp6, []any{tmp20}) - return tmp21 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // future - { - tmp0 := lang.NewSymbol("future").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Takes a body of expressions and yields a future object that will\n invoke the body in another thread, and will cache the result and\n return it on all subsequent calls to deref/@. If the computation has\n not yet finished, calls to deref/@ will block, unless the variant of\n deref with timeout is used. See also - realized?.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7009), lang.NewKeyword("end-line"), int(7009))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("seq")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("concat")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("list")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("glojure.core/future-call")}) - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("list")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("seq")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("concat")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("list")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.Apply(tmp27, []any{lang.NewSymbol("fn*")}) - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("list")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("apply")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp36 := tmp35.FindInternedVar(lang.NewSymbol("vector")) - if tmp36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) - } - tmp37 := tmp36.Get() - tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp39 := tmp38.FindInternedVar(lang.NewSymbol("seq")) - if tmp39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) - } - tmp40 := tmp39.Get() - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("concat")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.Apply(tmp43, nil) - tmp45 := lang.Apply(tmp40, []any{tmp44}) - tmp46 := lang.Apply(tmp34, []any{tmp37, tmp45}) - tmp47 := lang.Apply(tmp31, []any{tmp46}) - tmp48 := lang.Apply(tmp24, []any{tmp28, tmp47, v5}) - tmp49 := lang.Apply(tmp21, []any{tmp48}) - tmp50 := lang.Apply(tmp18, []any{tmp49}) - tmp51 := lang.Apply(tmp11, []any{tmp15, tmp50}) - tmp52 := lang.Apply(tmp8, []any{tmp51}) - return tmp52 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // future-call - { - tmp0 := lang.NewSymbol("future-call").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Takes a function of no args and yields a future object that will\n invoke the function in another thread, and will cache the result and\n return it on all subsequent calls to deref/@. If the computation has\n not yet finished, calls to deref/@ will block, unless the variant\n of deref with timeout is used. See also - realized?.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7003), lang.NewKeyword("end-line"), int(7003))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "f" - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("binding-conveyor-fn")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v3}) - var v9 any = tmp8 - _ = v9 - // let binding "fut" - tmp10 := lang.Apply(lang.AgentSubmit, []any{v9}) - var v11 any = tmp10 - _ = v11 - tmp4 = v11 - } // end let - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // future-cancel - { - tmp0 := lang.NewSymbol("future-cancel").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Cancels the future, if possible.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7019), lang.NewKeyword("end-line"), int(7019))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4, _ := lang.FieldOrMethod(v3, "cancel") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("cancel is not a function"))) - } - tmp5 := lang.Apply(tmp4, []any{true}) - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // future-cancelled? - { - tmp0 := lang.NewSymbol("future-cancelled?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Returns true if future f is cancelled", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7025), lang.NewKeyword("end-line"), int(7025))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4, ok := lang.FieldOrMethod(v3, "isCancelled") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "isCancelled"))) - } - var tmp5 any - switch reflect.TypeOf(tmp4).Kind() { - case reflect.Func: - tmp5 = lang.Apply(tmp4, nil) - default: - tmp5 = tmp4 - } - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // future-done? - { - tmp0 := lang.NewSymbol("future-done?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Returns true if future f is done", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6538), lang.NewKeyword("end-line"), int(6538))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4, ok := lang.FieldOrMethod(v3, "isDone") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "isDone"))) - } - var tmp5 any - switch reflect.TypeOf(tmp4).Kind() { - case reflect.Func: - tmp5 = lang.Apply(tmp4, nil) - default: - tmp5 = tmp4 - } - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // future? - { - tmp0 := lang.NewSymbol("future?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is a future", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6532), lang.NewKeyword("end-line"), int(6532))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.Apply(tmp6, []any{nil, v3}) - return tmp7 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // gen-class - { - tmp0 := lang.NewSymbol("gen-class").WithMeta(lang.NewMap()).(*lang.Symbol) - tmp1 := ns.Intern(tmp0) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // gensym - { - tmp0 := lang.NewSymbol("gensym").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("prefix-string"))), lang.NewKeyword("doc"), "Returns a new symbol with a unique name. If a prefix string is\n supplied, the name is prefix# where # is some unique number. If\n prefix is not supplied, the prefix is 'G__'.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(599), lang.NewKeyword("end-line"), int(599))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp4 := tmp3.FindInternedVar(lang.NewSymbol("gensym")) - if tmp4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp4))) - } - tmp5 := tmp4.Get() - tmp6 := lang.Apply(tmp5, []any{"G__"}) - return tmp6 - case 1: - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("str")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("str")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10, _ := lang.FieldOrMethod(runtime4.RT, "NextID") - if reflect.TypeOf(tmp10).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("NextID is not a function"))) - } - tmp11 := lang.Apply(tmp10, []any{}) - tmp12 := lang.Apply(tmp9, []any{tmp11}) - tmp13 := lang.Apply(tmp6, []any{v3, tmp12}) - tmp14 := lang.Apply(lang.NewSymbol, []any{tmp13}) - return tmp14 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // get - { - var tmp1 lang.FnFunc - { // function get__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("seq")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("concat")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("list")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol(".")}) - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("list")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("list")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("seq")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("concat")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("list")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.Apply(tmp31, []any{lang.NewSymbol("glojure.core/Get")}) - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("list")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.Apply(tmp35, []any{v3}) - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("list")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.Apply(tmp39, []any{v4}) - tmp41 := lang.Apply(tmp28, []any{tmp32, tmp36, tmp40, v5}) - tmp42 := lang.Apply(tmp25, []any{tmp41}) - tmp43 := lang.Apply(tmp22, []any{tmp42}) - tmp44 := lang.Apply(tmp11, []any{tmp15, tmp19, tmp43}) - tmp45 := lang.Apply(tmp8, []any{tmp44}) - return tmp45 - } - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("get").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"), lang.NewSymbol("not-found"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the value mapped to key, not-found or nil if key not present\n in associative collection, set, string, array, or ILookup instance.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2), int64(3)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1489), lang.NewKeyword("end-line"), int(1489))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6 := lang.Apply(lang.Get, []any{v4, v5}) - return tmp6 - case 3: - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - v6 := args[2] - _ = v6 - tmp7 := lang.Apply(lang.GetDefault, []any{v4, v5, v6}) - return tmp7 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // get-in - { - tmp0 := lang.NewSymbol("get-in").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("ks")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("ks"), lang.NewSymbol("not-found"))), lang.NewKeyword("doc"), "Returns the value in a nested associative structure,\n where ks is a sequence of keys. Returns nil if the key\n is not present, or the not-found value if supplied.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6128), lang.NewKeyword("end-line"), int(6128))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("get")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp7, []any{tmp10, v3, v4}) - return tmp11 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var tmp6 any - { // let - // let binding "sentinel" - tmp7 := lang.Apply(reflect.StructOf, []any{nil}) - tmp8 := lang.Apply(reflect.New, []any{tmp7}) - tmp9, ok := lang.FieldOrMethod(tmp8, "Interface") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp8, "Interface"))) - } - var tmp10 any - switch reflect.TypeOf(tmp9).Kind() { - case reflect.Func: - tmp10 = lang.Apply(tmp9, nil) - default: - tmp10 = tmp9 - } - var v11 any = tmp10 - _ = v11 - // let binding "m" - var v12 any = v3 - _ = v12 - // let binding "ks" - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("seq")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{v4}) - var v17 any = tmp16 - _ = v17 - for { - var tmp18 any - if lang.IsTruthy(v17) { - var tmp19 any - { // let - // let binding "m" - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("get")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("first")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.Apply(tmp25, []any{v17}) - tmp27 := lang.Apply(tmp22, []any{v12, tmp26, v11}) - var v28 any = tmp27 - _ = v28 - var tmp29 any - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("identical?")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.Apply(tmp32, []any{v11, v28}) - if lang.IsTruthy(tmp33) { - tmp29 = v5 - } else { - var tmp34 any = v11 - var tmp35 any = v28 - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("next")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.Apply(tmp39, []any{v17}) - var tmp36 any = tmp40 - v11 = tmp34 - v12 = tmp35 - v17 = tmp36 - continue - } - tmp19 = tmp29 - } // end let - tmp18 = tmp19 - } else { - tmp18 = v12 - } - tmp6 = tmp18 - break - } - } // end let - return tmp6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // get-method - { - tmp0 := lang.NewSymbol("get-method").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"), lang.NewSymbol("dispatch-val"))), lang.NewKeyword("doc"), "Given a multimethod and a dispatch value, returns the dispatch fn\n that would apply to that value, or nil if none apply and no default", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1815), lang.NewKeyword("end-line"), int(1815))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5, _ := lang.FieldOrMethod(v3, "getMethod") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("getMethod is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // get-thread-bindings - { - tmp0 := lang.NewSymbol("get-thread-bindings").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Get a map with the Var/value pairs which is currently in effect for the\n current thread.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1937), lang.NewKeyword("end-line"), int(1937))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - tmp3 := lang.Apply(nil, nil) - return tmp3 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // get-validator - { - tmp0 := lang.NewSymbol("get-validator").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("iref"))), lang.NewKeyword("doc"), "Gets the validator-fn for a var/ref/agent/atom.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2392), lang.NewKeyword("end-line"), int(2392))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4, _ := lang.FieldOrMethod(v3, "getValidator") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("getValidator is not a function"))) - } - tmp5 := lang.Apply(tmp4, []any{}) - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // global-hierarchy - { - tmp0 := lang.NewSymbol("global-hierarchy").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5513), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(5514), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, lang.NewMap(lang.NewKeyword("parents"), lang.NewMap(), lang.NewKeyword("descendants"), lang.NewMap(), lang.NewKeyword("ancestors"), lang.NewMap()), true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // group-by - { - tmp0 := lang.NewSymbol("group-by").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a map of the elements of coll keyed by the result of\n f on each element. The value at each key will be a vector of the\n corresponding elements, in the order they appeared in coll.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7128), lang.NewKeyword("end-line"), int(7128))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("persistent!")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("reduce")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - var tmp11 lang.FnFunc - tmp11 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v12 := args[0] - _ = v12 - v13 := args[1] - _ = v13 - var tmp14 any - { // let - // let binding "k" - tmp15 := lang.Apply(v3, []any{v13}) - var v16 any = tmp15 - _ = v16 - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("assoc!")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("conj")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("get")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.NewVector() - tmp27 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7139), lang.NewKeyword("column"), int(40), lang.NewKeyword("end-line"), int(7139), lang.NewKeyword("end-column"), int(41)) - tmp28, err := lang.WithMeta(tmp26, tmp27.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp29 := lang.Apply(tmp25, []any{v12, v16, tmp28}) - tmp30 := lang.Apply(tmp22, []any{tmp29, v13}) - tmp31 := lang.Apply(tmp19, []any{v12, v16, tmp30}) - tmp14 = tmp31 - } // end let - return tmp14 - }) - tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7137), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(7139), lang.NewKeyword("end-column"), int(48)) - tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("transient")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.NewMap() - tmp18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7140), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(7140), lang.NewKeyword("end-column"), int(17)) - tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp20 := lang.Apply(tmp16, []any{tmp19}) - tmp21 := lang.Apply(tmp10, []any{tmp13, tmp20, v4}) - tmp22 := lang.Apply(tmp7, []any{tmp21}) - return tmp22 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // halt-when - { - tmp0 := lang.NewSymbol("halt-when").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred")), lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("retf"))), lang.NewKeyword("doc"), "Returns a transducer that ends transduction when pred returns true\n for an input. When retf is supplied it must be a fn of 2 arguments -\n it will be passed the (completed) result so far and the input that\n triggered the predicate, and its return value (if it does not throw\n an exception) will be the return value of the transducer. If retf\n is not supplied, the input that triggered the predicate will be\n returned. If the predicate never returns true the transduction is\n unaffected.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7657), lang.NewKeyword("end-line"), int(7657))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("halt-when")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.Apply(tmp6, []any{v3, nil}) - return tmp7 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 lang.FnFunc - tmp5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v6 := args[0] - _ = v6 - var tmp7 lang.FnFunc - tmp7 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp8 := lang.Apply(v6, nil) - return tmp8 - case 1: - v8 := args[0] - _ = v8 - var tmp9 any - var tmp10 any - { // let - // let binding "and__0__auto__" - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("map?")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{v8}) - var v15 any = tmp14 - _ = v15 - var tmp16 any - if lang.IsTruthy(v15) { - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("contains?")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.Apply(tmp19, []any{v8, lang.NewKeyword("glojure.core/halt")}) - tmp16 = tmp20 - } else { - tmp16 = v15 - } - tmp10 = tmp16 - } // end let - if lang.IsTruthy(tmp10) { - tmp11 := lang.Apply(lang.NewKeyword("glojure.core/halt"), []any{v8}) - tmp9 = tmp11 - } else { - tmp12 := lang.Apply(v6, []any{v8}) - tmp9 = tmp12 - } - return tmp9 - case 2: - v8 := args[0] - _ = v8 - v9 := args[1] - _ = v9 - var tmp10 any - tmp11 := lang.Apply(v3, []any{v9}) - if lang.IsTruthy(tmp11) { - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("reduced")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - var tmp15 any - if lang.IsTruthy(v4) { - tmp16 := lang.Apply(v6, []any{v8}) - tmp17 := lang.Apply(v4, []any{tmp16, v9}) - tmp15 = tmp17 - } else { - tmp15 = v9 - } - tmp18 := lang.NewMap(lang.NewKeyword("glojure.core/halt"), tmp15) - tmp19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7678), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(7678), lang.NewKeyword("end-column"), int(72)) - tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp21 := lang.Apply(tmp14, []any{tmp20}) - tmp10 = tmp21 - } else { - tmp22 := lang.Apply(v6, []any{v8, v9}) - tmp10 = tmp22 - } - return tmp10 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7670), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7679), lang.NewKeyword("end-column"), int(34)) - tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp9 - }) - tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7669), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7679), lang.NewKeyword("end-column"), int(35)) - tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp7 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // hash - { - tmp0 := lang.NewSymbol("hash").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns the hash code of its argument. Note this is the hash code\n consistent with =, and thus is different than .hashCode for Integer,\n Short, Byte and Clojure collections.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5189), lang.NewKeyword("end-line"), int(5189))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.Apply(lang.HashEq, []any{v3}) - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // hash-map - { - tmp0 := lang.NewSymbol("hash-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keyvals"))), lang.NewKeyword("doc"), "keyval => key val\n Returns a new hash map with supplied mappings. If any keys are\n equal, they are handled as if by repeated uses of assoc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(378), lang.NewKeyword("end-line"), int(378))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp3 := lang.NewMap() - tmp4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(384), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(384), lang.NewKeyword("end-column"), int(8)) - tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp5 - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var v3 any = lang.NewList(args[0:]...) - _ = v3 - tmp4 := lang.Apply(lang.CreatePersistentHashMap, []any{v3}) - return tmp4 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // hash-ordered-coll - { - tmp0 := lang.NewSymbol("hash-ordered-coll").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns the hash code, consistent with =, for an external ordered\n collection implementing Iterable.\n See http://glojure.org/data_structures#hash for full algorithms.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5210), lang.NewKeyword("end-line"), int(5210))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.Apply(nil, []any{v3}) - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // hash-set - { - tmp0 := lang.NewSymbol("hash-set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keys"))), lang.NewKeyword("doc"), "Returns a new hash set with supplied keys. Any equal keys are\n handled as if by repeated uses of conj.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(388), lang.NewKeyword("end-line"), int(388))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp3 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) - tmp4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(393), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(393), lang.NewKeyword("end-column"), int(9)) - tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp5 - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var v3 any = lang.NewList(args[0:]...) - _ = v3 - tmp4 := lang.Apply(nil, []any{v3}) - return tmp4 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // hash-unordered-coll - { - tmp0 := lang.NewSymbol("hash-unordered-coll").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns the hash code, consistent with =, for an external unordered\n collection implementing Iterable. For maps, the iterator should\n return map entries whose hash is computed as\n (hash-ordered-coll [k v]).\n See http://glojure.org/data_structures#hash for full algorithms.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5219), lang.NewKeyword("end-line"), int(5219))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.Apply(nil, []any{v3}) - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // ident? - { - tmp0 := lang.NewSymbol("ident?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a symbol or keyword", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1608), lang.NewKeyword("end-line"), int(1608))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "or__0__auto__" - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("keyword?")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v3}) - var v9 any = tmp8 - _ = v9 - var tmp10 any - if lang.IsTruthy(v9) { - tmp10 = v9 - } else { - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("symbol?")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{v3}) - tmp10 = tmp14 - } - tmp4 = tmp10 - } // end let - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // identical? - { - var tmp1 lang.FnFunc - { // function identical?__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("concat")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("list")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol(".")}) - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("glojure.lang.Util")}) - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("glojure.core/identical")}) - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.Apply(tmp25, []any{v3}) - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{v4}) - tmp31 := lang.Apply(tmp10, []any{tmp14, tmp18, tmp22, tmp26, tmp30}) - tmp32 := lang.Apply(tmp7, []any{tmp31}) - return tmp32 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("identical?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Tests if 2 arguments are the same object", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(768), lang.NewKeyword("end-line"), int(768))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6 := lang.Apply(lang.Identical, []any{v4, v5}) - return tmp6 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // identity - { - tmp0 := lang.NewSymbol("identity").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns its argument.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1446), lang.NewKeyword("end-line"), int(1446))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - return v3 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // if-let - { - tmp0 := lang.NewSymbol("if-let").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("then")), lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("then"), lang.NewSymbol("else"), lang.NewSymbol("&"), lang.NewSymbol("oldform"))), lang.NewKeyword("doc"), "bindings => binding-form test\n\n If test is true, evaluates then with binding-form bound to the value of \n test, if not, yields else", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1839), lang.NewKeyword("end-line"), int(1839))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 4: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("seq")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("concat")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("list")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("glojure.core/if-let")}) - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("list")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.Apply(tmp19, []any{v5}) - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("list")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.Apply(tmp23, []any{v6}) - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("list")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.Apply(tmp27, []any{nil}) - tmp29 := lang.Apply(tmp12, []any{tmp16, tmp20, tmp24, tmp28}) - tmp30 := lang.Apply(tmp9, []any{tmp29}) - return tmp30 - default: - if len(args) < 5 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - v7 := args[4] - _ = v7 - var v8 any = lang.NewList(args[5:]...) - _ = v8 - var tmp9 any - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("vector?")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{v5}) - if lang.IsTruthy(tmp13) { - } else { - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("str")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("first")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.Apply(tmp19, []any{v3}) - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("*ns*")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("meta")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.Apply(tmp26, []any{v3}) - tmp28 := lang.Apply(lang.NewKeyword("line"), []any{tmp27}) - tmp29 := lang.Apply(tmp16, []any{tmp20, " requires ", "a vector for its binding", " in ", tmp23, ":", tmp28}) - tmp30 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp29}) - panic(tmp30) - } - _ = tmp9 - var tmp31 any - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("nil?")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.Apply(tmp34, []any{v8}) - if lang.IsTruthy(tmp35) { - } else { - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("str")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp40 := tmp39.FindInternedVar(lang.NewSymbol("first")) - if tmp40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) - } - tmp41 := tmp40.Get() - tmp42 := lang.Apply(tmp41, []any{v3}) - tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp44 := tmp43.FindInternedVar(lang.NewSymbol("*ns*")) - if tmp44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) - } - tmp45 := tmp44.Get() - tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp47 := tmp46.FindInternedVar(lang.NewSymbol("meta")) - if tmp47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) - } - tmp48 := tmp47.Get() - tmp49 := lang.Apply(tmp48, []any{v3}) - tmp50 := lang.Apply(lang.NewKeyword("line"), []any{tmp49}) - tmp51 := lang.Apply(tmp38, []any{tmp42, " requires ", "1 or 2 forms after binding vector", " in ", tmp45, ":", tmp50}) - tmp52 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp51}) - panic(tmp52) - } - _ = tmp31 - var tmp53 any - tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp55 := tmp54.FindInternedVar(lang.NewSymbol("=")) - if tmp55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) - } - tmp56 := tmp55.Get() - tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp58 := tmp57.FindInternedVar(lang.NewSymbol("count")) - if tmp58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) - } - tmp59 := tmp58.Get() - tmp60 := lang.Apply(tmp59, []any{v5}) - tmp61 := lang.Apply(tmp56, []any{int64(2), tmp60}) - if lang.IsTruthy(tmp61) { - } else { - tmp62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp63 := tmp62.FindInternedVar(lang.NewSymbol("str")) - if tmp63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp63))) - } - tmp64 := tmp63.Get() - tmp65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp66 := tmp65.FindInternedVar(lang.NewSymbol("first")) - if tmp66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp66))) - } - tmp67 := tmp66.Get() - tmp68 := lang.Apply(tmp67, []any{v3}) - tmp69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp70 := tmp69.FindInternedVar(lang.NewSymbol("*ns*")) - if tmp70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp70))) - } - tmp71 := tmp70.Get() - tmp72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp73 := tmp72.FindInternedVar(lang.NewSymbol("meta")) - if tmp73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp73))) - } - tmp74 := tmp73.Get() - tmp75 := lang.Apply(tmp74, []any{v3}) - tmp76 := lang.Apply(lang.NewKeyword("line"), []any{tmp75}) - tmp77 := lang.Apply(tmp64, []any{tmp68, " requires ", "exactly 2 forms in binding vector", " in ", tmp71, ":", tmp76}) - tmp78 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp77}) - panic(tmp78) - } - _ = tmp53 - var tmp79 any - { // let - // let binding "form" - tmp80 := lang.Apply(v5, []any{int64(0)}) - var v81 any = tmp80 - _ = v81 - // let binding "tst" - tmp82 := lang.Apply(v5, []any{int64(1)}) - var v83 any = tmp82 - _ = v83 - tmp84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp85 := tmp84.FindInternedVar(lang.NewSymbol("seq")) - if tmp85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp85))) - } - tmp86 := tmp85.Get() - tmp87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp88 := tmp87.FindInternedVar(lang.NewSymbol("concat")) - if tmp88.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp88))) - } - tmp89 := tmp88.Get() - tmp90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp91 := tmp90.FindInternedVar(lang.NewSymbol("list")) - if tmp91.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp91))) - } - tmp92 := tmp91.Get() - tmp93 := lang.Apply(tmp92, []any{lang.NewSymbol("glojure.core/let")}) - tmp94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp95 := tmp94.FindInternedVar(lang.NewSymbol("list")) - if tmp95.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp95))) - } - tmp96 := tmp95.Get() - tmp97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp98 := tmp97.FindInternedVar(lang.NewSymbol("apply")) - if tmp98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp98))) - } - tmp99 := tmp98.Get() - tmp100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp101 := tmp100.FindInternedVar(lang.NewSymbol("vector")) - if tmp101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp101))) - } - tmp102 := tmp101.Get() - tmp103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp104 := tmp103.FindInternedVar(lang.NewSymbol("seq")) - if tmp104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp104))) - } - tmp105 := tmp104.Get() - tmp106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp107 := tmp106.FindInternedVar(lang.NewSymbol("concat")) - if tmp107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp107))) - } - tmp108 := tmp107.Get() - tmp109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp110 := tmp109.FindInternedVar(lang.NewSymbol("list")) - if tmp110.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp110))) - } - tmp111 := tmp110.Get() - tmp112 := lang.Apply(tmp111, []any{lang.NewSymbol("temp__0__auto__")}) - tmp113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp114 := tmp113.FindInternedVar(lang.NewSymbol("list")) - if tmp114.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp114))) - } - tmp115 := tmp114.Get() - tmp116 := lang.Apply(tmp115, []any{v83}) - tmp117 := lang.Apply(tmp108, []any{tmp112, tmp116}) - tmp118 := lang.Apply(tmp105, []any{tmp117}) - tmp119 := lang.Apply(tmp99, []any{tmp102, tmp118}) - tmp120 := lang.Apply(tmp96, []any{tmp119}) - tmp121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp122 := tmp121.FindInternedVar(lang.NewSymbol("list")) - if tmp122.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp122))) - } - tmp123 := tmp122.Get() - tmp124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp125 := tmp124.FindInternedVar(lang.NewSymbol("seq")) - if tmp125.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp125))) - } - tmp126 := tmp125.Get() - tmp127 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp128 := tmp127.FindInternedVar(lang.NewSymbol("concat")) - if tmp128.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp128))) - } - tmp129 := tmp128.Get() - tmp130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp131 := tmp130.FindInternedVar(lang.NewSymbol("list")) - if tmp131.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp131))) - } - tmp132 := tmp131.Get() - tmp133 := lang.Apply(tmp132, []any{lang.NewSymbol("if")}) - tmp134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp135 := tmp134.FindInternedVar(lang.NewSymbol("list")) - if tmp135.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp135))) - } - tmp136 := tmp135.Get() - tmp137 := lang.Apply(tmp136, []any{lang.NewSymbol("temp__0__auto__")}) - tmp138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp139 := tmp138.FindInternedVar(lang.NewSymbol("list")) - if tmp139.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp139))) - } - tmp140 := tmp139.Get() - tmp141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp142 := tmp141.FindInternedVar(lang.NewSymbol("seq")) - if tmp142.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp142))) - } - tmp143 := tmp142.Get() - tmp144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp145 := tmp144.FindInternedVar(lang.NewSymbol("concat")) - if tmp145.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp145))) - } - tmp146 := tmp145.Get() - tmp147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp148 := tmp147.FindInternedVar(lang.NewSymbol("list")) - if tmp148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp148))) - } - tmp149 := tmp148.Get() - tmp150 := lang.Apply(tmp149, []any{lang.NewSymbol("glojure.core/let")}) - tmp151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp152 := tmp151.FindInternedVar(lang.NewSymbol("list")) - if tmp152.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp152))) - } - tmp153 := tmp152.Get() - tmp154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp155 := tmp154.FindInternedVar(lang.NewSymbol("apply")) - if tmp155.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp155))) - } - tmp156 := tmp155.Get() - tmp157 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp158 := tmp157.FindInternedVar(lang.NewSymbol("vector")) - if tmp158.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp158))) - } - tmp159 := tmp158.Get() - tmp160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp161 := tmp160.FindInternedVar(lang.NewSymbol("seq")) - if tmp161.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp161))) - } - tmp162 := tmp161.Get() - tmp163 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp164 := tmp163.FindInternedVar(lang.NewSymbol("concat")) - if tmp164.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp164))) - } - tmp165 := tmp164.Get() - tmp166 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp167 := tmp166.FindInternedVar(lang.NewSymbol("list")) - if tmp167.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp167))) - } - tmp168 := tmp167.Get() - tmp169 := lang.Apply(tmp168, []any{v81}) - tmp170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp171 := tmp170.FindInternedVar(lang.NewSymbol("list")) - if tmp171.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp171))) - } - tmp172 := tmp171.Get() - tmp173 := lang.Apply(tmp172, []any{lang.NewSymbol("temp__0__auto__")}) - tmp174 := lang.Apply(tmp165, []any{tmp169, tmp173}) - tmp175 := lang.Apply(tmp162, []any{tmp174}) - tmp176 := lang.Apply(tmp156, []any{tmp159, tmp175}) - tmp177 := lang.Apply(tmp153, []any{tmp176}) - tmp178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp179 := tmp178.FindInternedVar(lang.NewSymbol("list")) - if tmp179.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp179))) - } - tmp180 := tmp179.Get() - tmp181 := lang.Apply(tmp180, []any{v6}) - tmp182 := lang.Apply(tmp146, []any{tmp150, tmp177, tmp181}) - tmp183 := lang.Apply(tmp143, []any{tmp182}) - tmp184 := lang.Apply(tmp140, []any{tmp183}) - tmp185 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp186 := tmp185.FindInternedVar(lang.NewSymbol("list")) - if tmp186.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp186))) - } - tmp187 := tmp186.Get() - tmp188 := lang.Apply(tmp187, []any{v7}) - tmp189 := lang.Apply(tmp129, []any{tmp133, tmp137, tmp184, tmp188}) - tmp190 := lang.Apply(tmp126, []any{tmp189}) - tmp191 := lang.Apply(tmp123, []any{tmp190}) - tmp192 := lang.Apply(tmp89, []any{tmp93, tmp120, tmp191}) - tmp193 := lang.Apply(tmp86, []any{tmp192}) - tmp79 = tmp193 - } // end let - return tmp79 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // if-not - { - tmp0 := lang.NewSymbol("if-not").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("test"), lang.NewSymbol("then")), lang.NewVector(lang.NewSymbol("test"), lang.NewSymbol("then"), lang.NewSymbol("else"))), lang.NewKeyword("doc"), "Evaluates test. If logical false, evaluates and returns then expr, \n otherwise else expr, if supplied, else nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(760), lang.NewKeyword("end-line"), int(760))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 4: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("seq")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("concat")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("list")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("glojure.core/if-not")}) - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("list")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.Apply(tmp19, []any{v5}) - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("list")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.Apply(tmp23, []any{v6}) - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("list")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.Apply(tmp27, []any{nil}) - tmp29 := lang.Apply(tmp12, []any{tmp16, tmp20, tmp24, tmp28}) - tmp30 := lang.Apply(tmp9, []any{tmp29}) - return tmp30 - case 5: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - v7 := args[4] - _ = v7 - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("seq")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("concat")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("if")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/not")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{v5}) - tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) - tmp36 := lang.Apply(tmp23, []any{tmp35}) - tmp37 := lang.Apply(tmp20, []any{tmp36}) - tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp39 := tmp38.FindInternedVar(lang.NewSymbol("list")) - if tmp39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) - } - tmp40 := tmp39.Get() - tmp41 := lang.Apply(tmp40, []any{v6}) - tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp43 := tmp42.FindInternedVar(lang.NewSymbol("list")) - if tmp43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) - } - tmp44 := tmp43.Get() - tmp45 := lang.Apply(tmp44, []any{v7}) - tmp46 := lang.Apply(tmp13, []any{tmp17, tmp37, tmp41, tmp45}) - tmp47 := lang.Apply(tmp10, []any{tmp46}) - return tmp47 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // if-some - { - tmp0 := lang.NewSymbol("if-some").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("then")), lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("then"), lang.NewSymbol("else"), lang.NewSymbol("&"), lang.NewSymbol("oldform"))), lang.NewKeyword("doc"), "bindings => binding-form test\n\n If test is not nil, evaluates then with binding-form bound to the\n value of test, if not, yields else", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1874), lang.NewKeyword("end-line"), int(1874))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 4: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("seq")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("concat")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("list")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("glojure.core/if-some")}) - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("list")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.Apply(tmp19, []any{v5}) - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("list")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.Apply(tmp23, []any{v6}) - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("list")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.Apply(tmp27, []any{nil}) - tmp29 := lang.Apply(tmp12, []any{tmp16, tmp20, tmp24, tmp28}) - tmp30 := lang.Apply(tmp9, []any{tmp29}) - return tmp30 - default: - if len(args) < 5 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - v7 := args[4] - _ = v7 - var v8 any = lang.NewList(args[5:]...) - _ = v8 - var tmp9 any - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("vector?")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{v5}) - if lang.IsTruthy(tmp13) { - } else { - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("str")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("first")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.Apply(tmp19, []any{v3}) - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("*ns*")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("meta")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.Apply(tmp26, []any{v3}) - tmp28 := lang.Apply(lang.NewKeyword("line"), []any{tmp27}) - tmp29 := lang.Apply(tmp16, []any{tmp20, " requires ", "a vector for its binding", " in ", tmp23, ":", tmp28}) - tmp30 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp29}) - panic(tmp30) - } - _ = tmp9 - var tmp31 any - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("nil?")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.Apply(tmp34, []any{v8}) - if lang.IsTruthy(tmp35) { - } else { - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("str")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp40 := tmp39.FindInternedVar(lang.NewSymbol("first")) - if tmp40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) - } - tmp41 := tmp40.Get() - tmp42 := lang.Apply(tmp41, []any{v3}) - tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp44 := tmp43.FindInternedVar(lang.NewSymbol("*ns*")) - if tmp44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) - } - tmp45 := tmp44.Get() - tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp47 := tmp46.FindInternedVar(lang.NewSymbol("meta")) - if tmp47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) - } - tmp48 := tmp47.Get() - tmp49 := lang.Apply(tmp48, []any{v3}) - tmp50 := lang.Apply(lang.NewKeyword("line"), []any{tmp49}) - tmp51 := lang.Apply(tmp38, []any{tmp42, " requires ", "1 or 2 forms after binding vector", " in ", tmp45, ":", tmp50}) - tmp52 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp51}) - panic(tmp52) - } - _ = tmp31 - var tmp53 any - tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp55 := tmp54.FindInternedVar(lang.NewSymbol("=")) - if tmp55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) - } - tmp56 := tmp55.Get() - tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp58 := tmp57.FindInternedVar(lang.NewSymbol("count")) - if tmp58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) - } - tmp59 := tmp58.Get() - tmp60 := lang.Apply(tmp59, []any{v5}) - tmp61 := lang.Apply(tmp56, []any{int64(2), tmp60}) - if lang.IsTruthy(tmp61) { - } else { - tmp62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp63 := tmp62.FindInternedVar(lang.NewSymbol("str")) - if tmp63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp63))) - } - tmp64 := tmp63.Get() - tmp65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp66 := tmp65.FindInternedVar(lang.NewSymbol("first")) - if tmp66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp66))) - } - tmp67 := tmp66.Get() - tmp68 := lang.Apply(tmp67, []any{v3}) - tmp69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp70 := tmp69.FindInternedVar(lang.NewSymbol("*ns*")) - if tmp70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp70))) - } - tmp71 := tmp70.Get() - tmp72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp73 := tmp72.FindInternedVar(lang.NewSymbol("meta")) - if tmp73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp73))) - } - tmp74 := tmp73.Get() - tmp75 := lang.Apply(tmp74, []any{v3}) - tmp76 := lang.Apply(lang.NewKeyword("line"), []any{tmp75}) - tmp77 := lang.Apply(tmp64, []any{tmp68, " requires ", "exactly 2 forms in binding vector", " in ", tmp71, ":", tmp76}) - tmp78 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp77}) - panic(tmp78) - } - _ = tmp53 - var tmp79 any - { // let - // let binding "form" - tmp80 := lang.Apply(v5, []any{int64(0)}) - var v81 any = tmp80 - _ = v81 - // let binding "tst" - tmp82 := lang.Apply(v5, []any{int64(1)}) - var v83 any = tmp82 - _ = v83 - tmp84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp85 := tmp84.FindInternedVar(lang.NewSymbol("seq")) - if tmp85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp85))) - } - tmp86 := tmp85.Get() - tmp87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp88 := tmp87.FindInternedVar(lang.NewSymbol("concat")) - if tmp88.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp88))) - } - tmp89 := tmp88.Get() - tmp90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp91 := tmp90.FindInternedVar(lang.NewSymbol("list")) - if tmp91.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp91))) - } - tmp92 := tmp91.Get() - tmp93 := lang.Apply(tmp92, []any{lang.NewSymbol("glojure.core/let")}) - tmp94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp95 := tmp94.FindInternedVar(lang.NewSymbol("list")) - if tmp95.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp95))) - } - tmp96 := tmp95.Get() - tmp97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp98 := tmp97.FindInternedVar(lang.NewSymbol("apply")) - if tmp98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp98))) - } - tmp99 := tmp98.Get() - tmp100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp101 := tmp100.FindInternedVar(lang.NewSymbol("vector")) - if tmp101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp101))) - } - tmp102 := tmp101.Get() - tmp103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp104 := tmp103.FindInternedVar(lang.NewSymbol("seq")) - if tmp104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp104))) - } - tmp105 := tmp104.Get() - tmp106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp107 := tmp106.FindInternedVar(lang.NewSymbol("concat")) - if tmp107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp107))) - } - tmp108 := tmp107.Get() - tmp109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp110 := tmp109.FindInternedVar(lang.NewSymbol("list")) - if tmp110.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp110))) - } - tmp111 := tmp110.Get() - tmp112 := lang.Apply(tmp111, []any{lang.NewSymbol("temp__0__auto__")}) - tmp113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp114 := tmp113.FindInternedVar(lang.NewSymbol("list")) - if tmp114.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp114))) - } - tmp115 := tmp114.Get() - tmp116 := lang.Apply(tmp115, []any{v83}) - tmp117 := lang.Apply(tmp108, []any{tmp112, tmp116}) - tmp118 := lang.Apply(tmp105, []any{tmp117}) - tmp119 := lang.Apply(tmp99, []any{tmp102, tmp118}) - tmp120 := lang.Apply(tmp96, []any{tmp119}) - tmp121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp122 := tmp121.FindInternedVar(lang.NewSymbol("list")) - if tmp122.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp122))) - } - tmp123 := tmp122.Get() - tmp124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp125 := tmp124.FindInternedVar(lang.NewSymbol("seq")) - if tmp125.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp125))) - } - tmp126 := tmp125.Get() - tmp127 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp128 := tmp127.FindInternedVar(lang.NewSymbol("concat")) - if tmp128.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp128))) - } - tmp129 := tmp128.Get() - tmp130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp131 := tmp130.FindInternedVar(lang.NewSymbol("list")) - if tmp131.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp131))) - } - tmp132 := tmp131.Get() - tmp133 := lang.Apply(tmp132, []any{lang.NewSymbol("if")}) - tmp134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp135 := tmp134.FindInternedVar(lang.NewSymbol("list")) - if tmp135.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp135))) - } - tmp136 := tmp135.Get() - tmp137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp138 := tmp137.FindInternedVar(lang.NewSymbol("seq")) - if tmp138.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp138))) - } - tmp139 := tmp138.Get() - tmp140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp141 := tmp140.FindInternedVar(lang.NewSymbol("concat")) - if tmp141.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp141))) - } - tmp142 := tmp141.Get() - tmp143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp144 := tmp143.FindInternedVar(lang.NewSymbol("list")) - if tmp144.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp144))) - } - tmp145 := tmp144.Get() - tmp146 := lang.Apply(tmp145, []any{lang.NewSymbol("glojure.core/nil?")}) - tmp147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp148 := tmp147.FindInternedVar(lang.NewSymbol("list")) - if tmp148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp148))) - } - tmp149 := tmp148.Get() - tmp150 := lang.Apply(tmp149, []any{lang.NewSymbol("temp__0__auto__")}) - tmp151 := lang.Apply(tmp142, []any{tmp146, tmp150}) - tmp152 := lang.Apply(tmp139, []any{tmp151}) - tmp153 := lang.Apply(tmp136, []any{tmp152}) - tmp154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp155 := tmp154.FindInternedVar(lang.NewSymbol("list")) - if tmp155.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp155))) - } - tmp156 := tmp155.Get() - tmp157 := lang.Apply(tmp156, []any{v7}) - tmp158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp159 := tmp158.FindInternedVar(lang.NewSymbol("list")) - if tmp159.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp159))) - } - tmp160 := tmp159.Get() - tmp161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp162 := tmp161.FindInternedVar(lang.NewSymbol("seq")) - if tmp162.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp162))) - } - tmp163 := tmp162.Get() - tmp164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp165 := tmp164.FindInternedVar(lang.NewSymbol("concat")) - if tmp165.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp165))) - } - tmp166 := tmp165.Get() - tmp167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp168 := tmp167.FindInternedVar(lang.NewSymbol("list")) - if tmp168.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp168))) - } - tmp169 := tmp168.Get() - tmp170 := lang.Apply(tmp169, []any{lang.NewSymbol("glojure.core/let")}) - tmp171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp172 := tmp171.FindInternedVar(lang.NewSymbol("list")) - if tmp172.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp172))) - } - tmp173 := tmp172.Get() - tmp174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp175 := tmp174.FindInternedVar(lang.NewSymbol("apply")) - if tmp175.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp175))) - } - tmp176 := tmp175.Get() - tmp177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp178 := tmp177.FindInternedVar(lang.NewSymbol("vector")) - if tmp178.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp178))) - } - tmp179 := tmp178.Get() - tmp180 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp181 := tmp180.FindInternedVar(lang.NewSymbol("seq")) - if tmp181.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp181))) - } - tmp182 := tmp181.Get() - tmp183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp184 := tmp183.FindInternedVar(lang.NewSymbol("concat")) - if tmp184.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp184))) - } - tmp185 := tmp184.Get() - tmp186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp187 := tmp186.FindInternedVar(lang.NewSymbol("list")) - if tmp187.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp187))) - } - tmp188 := tmp187.Get() - tmp189 := lang.Apply(tmp188, []any{v81}) - tmp190 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp191 := tmp190.FindInternedVar(lang.NewSymbol("list")) - if tmp191.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp191))) - } - tmp192 := tmp191.Get() - tmp193 := lang.Apply(tmp192, []any{lang.NewSymbol("temp__0__auto__")}) - tmp194 := lang.Apply(tmp185, []any{tmp189, tmp193}) - tmp195 := lang.Apply(tmp182, []any{tmp194}) - tmp196 := lang.Apply(tmp176, []any{tmp179, tmp195}) - tmp197 := lang.Apply(tmp173, []any{tmp196}) - tmp198 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp199 := tmp198.FindInternedVar(lang.NewSymbol("list")) - if tmp199.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp199))) - } - tmp200 := tmp199.Get() - tmp201 := lang.Apply(tmp200, []any{v6}) - tmp202 := lang.Apply(tmp166, []any{tmp170, tmp197, tmp201}) - tmp203 := lang.Apply(tmp163, []any{tmp202}) - tmp204 := lang.Apply(tmp160, []any{tmp203}) - tmp205 := lang.Apply(tmp129, []any{tmp133, tmp153, tmp157, tmp204}) - tmp206 := lang.Apply(tmp126, []any{tmp205}) - tmp207 := lang.Apply(tmp123, []any{tmp206}) - tmp208 := lang.Apply(tmp89, []any{tmp93, tmp120, tmp207}) - tmp209 := lang.Apply(tmp86, []any{tmp208}) - tmp79 = tmp209 - } // end let - return tmp79 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // ifn? - { - tmp0 := lang.NewSymbol("ifn?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements IFn. Note that many data structures\n (e.g. sets and maps) implement IFn", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6209), lang.NewKeyword("end-line"), int(6209))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.Apply(tmp6, []any{nil, v3}) - return tmp7 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // import - { - tmp0 := lang.NewSymbol("import").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("import-symbols-or-lists"))), lang.NewKeyword("doc"), "import-list => (package-symbol class-name-symbols*)\n\n For each name in class-name-symbols, adds a mapping from name to the\n class named by package.name to the current namespace. Use :import in the ns\n macro in preference to calling this directly.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3426), lang.NewKeyword("end-line"), int(3426))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - var tmp6 any - { // let - // let binding "specs" - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("map")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - var tmp10 lang.FnFunc - tmp10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v11 := args[0] - _ = v11 - var tmp12 any - var tmp13 any - { // let - // let binding "and__0__auto__" - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("seq?")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{v11}) - var v18 any = tmp17 - _ = v18 - var tmp19 any - if lang.IsTruthy(v18) { - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("=")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("first")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.Apply(tmp25, []any{v11}) - tmp27 := lang.Apply(tmp22, []any{lang.NewSymbol("quote"), tmp26}) - tmp19 = tmp27 - } else { - tmp19 = v18 - } - tmp13 = tmp19 - } // end let - if lang.IsTruthy(tmp13) { - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("second")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{v11}) - tmp12 = tmp17 - } else { - tmp12 = v11 - } - return tmp12 - }) - tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3434), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(3434), lang.NewKeyword("end-column"), int(73)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp13 := lang.Apply(tmp9, []any{tmp12, v5}) - var v14 any = tmp13 - _ = v14 - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("seq")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("concat")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("list")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.Apply(tmp23, []any{lang.NewSymbol("do")}) - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("map")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - var tmp28 lang.FnFunc - tmp28 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v29 := args[0] - _ = v29 - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("list")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.Apply(tmp32, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Import"), v29}) - return tmp33 - }) - tmp29 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3436), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(3436), lang.NewKeyword("end-column"), int(73)) - tmp30, err := lang.WithMeta(tmp28, tmp29.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - var tmp34 lang.FnFunc - tmp34 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v35 := args[0] - _ = v35 - v36 := args[1] - _ = v36 - var tmp37 any - tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp39 := tmp38.FindInternedVar(lang.NewSymbol("symbol?")) - if tmp39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) - } - tmp40 := tmp39.Get() - tmp41 := lang.Apply(tmp40, []any{v36}) - if lang.IsTruthy(tmp41) { - tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp43 := tmp42.FindInternedVar(lang.NewSymbol("conj")) - if tmp43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) - } - tmp44 := tmp43.Get() - tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp46 := tmp45.FindInternedVar(lang.NewSymbol("name")) - if tmp46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) - } - tmp47 := tmp46.Get() - tmp48 := lang.Apply(tmp47, []any{v36}) - tmp49 := lang.Apply(tmp44, []any{v35, tmp48}) - tmp37 = tmp49 - } else { - var tmp50 any - { // let - // let binding "p" - tmp51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp52 := tmp51.FindInternedVar(lang.NewSymbol("first")) - if tmp52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp52))) - } - tmp53 := tmp52.Get() - tmp54 := lang.Apply(tmp53, []any{v36}) - var v55 any = tmp54 - _ = v55 - // let binding "cs" - tmp56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp57 := tmp56.FindInternedVar(lang.NewSymbol("rest")) - if tmp57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp57))) - } - tmp58 := tmp57.Get() - tmp59 := lang.Apply(tmp58, []any{v36}) - var v60 any = tmp59 - _ = v60 - tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp62 := tmp61.FindInternedVar(lang.NewSymbol("into1")) - if tmp62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) - } - tmp63 := tmp62.Get() - tmp64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp65 := tmp64.FindInternedVar(lang.NewSymbol("map")) - if tmp65.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp65))) - } - tmp66 := tmp65.Get() - var tmp67 lang.FnFunc - tmp67 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v68 := args[0] - _ = v68 - tmp69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp70 := tmp69.FindInternedVar(lang.NewSymbol("str")) - if tmp70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp70))) - } - tmp71 := tmp70.Get() - tmp72 := lang.Apply(tmp71, []any{v55, ".", v68}) - return tmp72 - }) - tmp68 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3441), lang.NewKeyword("column"), int(45), lang.NewKeyword("end-line"), int(3441), lang.NewKeyword("end-column"), int(58)) - tmp69, err := lang.WithMeta(tmp67, tmp68.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp70 := lang.Apply(tmp66, []any{tmp69, v60}) - tmp71 := lang.Apply(tmp63, []any{v35, tmp70}) - tmp50 = tmp71 - } // end let - tmp37 = tmp50 - } - return tmp37 - }) - tmp35 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3437), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(3441), lang.NewKeyword("end-column"), int(66)) - tmp36, err := lang.WithMeta(tmp34, tmp35.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp37 := lang.NewVector() - tmp38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3442), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(3442), lang.NewKeyword("end-column"), int(26)) - tmp39, err := lang.WithMeta(tmp37, tmp38.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp40 := lang.Apply(tmp33, []any{tmp36, tmp39, v14}) - tmp41 := lang.Apply(tmp27, []any{tmp30, tmp40}) - tmp42 := lang.Apply(tmp20, []any{tmp24, tmp41}) - tmp43 := lang.Apply(tmp17, []any{tmp42}) - tmp6 = tmp43 - } // end let - return tmp6 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // in-ns - { - tmp0 := lang.NewSymbol("in-ns").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, nil, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // inc - { - var tmp1 lang.FnFunc - { // function inc__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - var tmp30 any - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - if lang.IsTruthy(tmp33) { - tmp30 = lang.NewSymbol("unchecked_inc") - } else { - tmp30 = lang.NewSymbol("inc") - } - tmp34 := lang.Apply(tmp29, []any{tmp30}) - tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp36 := tmp35.FindInternedVar(lang.NewSymbol("list")) - if tmp36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) - } - tmp37 := tmp36.Get() - tmp38 := lang.Apply(tmp37, []any{v3}) - tmp39 := lang.Apply(tmp26, []any{tmp34, tmp38}) - tmp40 := lang.Apply(tmp23, []any{tmp39}) - tmp41 := lang.Apply(tmp20, []any{tmp40}) - tmp42 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp41}) - tmp43 := lang.Apply(tmp6, []any{tmp42}) - return tmp43 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("inc").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns a number one greater than num. Does not auto-promote\n longs, will throw on overflow. See also: inc'", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(915), lang.NewKeyword("end-line"), int(915))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Inc") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Inc is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // inc' - { - var tmp1 lang.FnFunc - { // function inc'__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/IncP")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{v3}) - tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) - tmp36 := lang.Apply(tmp23, []any{tmp35}) - tmp37 := lang.Apply(tmp20, []any{tmp36}) - tmp38 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp37}) - tmp39 := lang.Apply(tmp6, []any{tmp38}) - return tmp39 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("inc'").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns a number one greater than num. Supports arbitrary precision.\n See also: inc", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(908), lang.NewKeyword("end-line"), int(908))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "IncP") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("IncP is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // indexed? - { - tmp0 := lang.NewSymbol("indexed?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return true if coll implements Indexed, indicating efficient lookup by index", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6263), lang.NewKeyword("end-line"), int(6263))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.Apply(tmp6, []any{nil, v3}) - return tmp7 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // infinite? - { - var tmp1 lang.FnFunc - { // function infinite?__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol("Double/isInfinite")}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{v3}) - tmp18 := lang.Apply(tmp9, []any{tmp13, tmp17}) - tmp19 := lang.Apply(tmp6, []any{tmp18}) - return tmp19 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("infinite?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns true if num is negative or positive infinity, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1)})), lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7977), lang.NewKeyword("end-line"), int(7977))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5 := lang.Apply(nil, []any{v4}) - return tmp5 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // inst-ms - { - tmp0 := lang.NewSymbol("inst-ms").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("inst"))), lang.NewKeyword("doc"), "Return the number of milliseconds since January 1, 1970, 00:00:00 GMT", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6831), lang.NewKeyword("end-line"), int(6831))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.Apply(nil, []any{v3}) - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // inst? - { - tmp0 := lang.NewSymbol("inst?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x satisfies Inst", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6837), lang.NewKeyword("end-line"), int(6837))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - return nil - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // instance? - { - tmp0 := lang.NewSymbol("instance?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Evaluates x and tests if it is an instance of the type\n t. Returns true or false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(139), lang.NewKeyword("end-line"), int(143))).(*lang.Symbol) - var tmp2 lang.FnFunc - { // function instance? - var v3 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6 := lang.Apply(lang.HasType, []any{v4, v5}) - return tmp6 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(143), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(143), lang.NewKeyword("end-column"), int(85))).(lang.FnFunc) - v3 = tmp2 - _ = v3 - } - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // int - { - var tmp1 lang.FnFunc - { // function int__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - var tmp30 any - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - if lang.IsTruthy(tmp33) { - tmp30 = lang.NewSymbol("uncheckedIntCast") - } else { - tmp30 = lang.NewSymbol("intCast") - } - tmp34 := lang.Apply(tmp29, []any{tmp30}) - tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp36 := tmp35.FindInternedVar(lang.NewSymbol("list")) - if tmp36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) - } - tmp37 := tmp36.Get() - tmp38 := lang.Apply(tmp37, []any{v3}) - tmp39 := lang.Apply(tmp26, []any{tmp34, tmp38}) - tmp40 := lang.Apply(tmp23, []any{tmp39}) - tmp41 := lang.Apply(tmp20, []any{tmp40}) - tmp42 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp41}) - tmp43 := lang.Apply(tmp6, []any{tmp42}) - return tmp43 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to int", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(875), lang.NewKeyword("end-line"), int(875))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(runtime4.RT, "IntCast") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("IntCast is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // int-array - { - var tmp1 lang.FnFunc - { // function int-array__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var v3 any = lang.NewList(args[0:]...) - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.Apply(tmp20, []any{lang.NewSymbol("glojure.core/IntArray")}) - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("list")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("seq")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("concat")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) - tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp36 := tmp35.FindInternedVar(lang.NewSymbol("list")) - if tmp36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) - } - tmp37 := tmp36.Get() - tmp38 := lang.Apply(tmp37, []any{lang.NewSymbol("glojure.core/args")}) - tmp39 := lang.Apply(tmp30, []any{tmp34, tmp38}) - tmp40 := lang.Apply(tmp27, []any{tmp39}) - tmp41 := lang.Apply(tmp24, []any{tmp40}) - tmp42 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp21, tmp41}) - tmp43 := lang.Apply(tmp6, []any{tmp42}) - return tmp43 - } - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("int-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Creates an array of ints", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5356), lang.NewKeyword("end-line"), int(5356))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "IntArray") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("IntArray is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - case 2: - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "IntArrayInit") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("IntArrayInit is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // int? - { - tmp0 := lang.NewSymbol("int?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a fixed precision integer", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1395), lang.NewKeyword("end-line"), int(1395))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "or__0__auto__" - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("instance?")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{lang.Builtins["int64"], v3}) - var v9 any = tmp8 - _ = v9 - var tmp10 any - if lang.IsTruthy(v9) { - tmp10 = v9 - } else { - var tmp11 any - { // let - // let binding "or__0__auto__" - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("instance?")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.Apply(tmp14, []any{nil, v3}) - var v16 any = tmp15 - _ = v16 - var tmp17 any - if lang.IsTruthy(v16) { - tmp17 = v16 - } else { - var tmp18 any - { // let - // let binding "or__0__auto__" - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("instance?")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, []any{nil, v3}) - var v23 any = tmp22 - _ = v23 - var tmp24 any - if lang.IsTruthy(v23) { - tmp24 = v23 - } else { - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("instance?")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.Apply(tmp27, []any{nil, v3}) - tmp24 = tmp28 - } - tmp18 = tmp24 - } // end let - tmp17 = tmp18 - } - tmp11 = tmp17 - } // end let - tmp10 = tmp11 - } - tmp4 = tmp10 - } // end let - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // integer? - { - tmp0 := lang.NewSymbol("integer?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is an integer", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1379), lang.NewKeyword("end-line"), int(1379))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.Apply(lang.IsInteger, []any{v3}) - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // interleave - { - tmp0 := lang.NewSymbol("interleave").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("c1")), lang.NewVector(lang.NewSymbol("c1"), lang.NewSymbol("c2")), lang.NewVector(lang.NewSymbol("c1"), lang.NewSymbol("c2"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Returns a lazy seq of the first item in each coll, then the second etc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4308), lang.NewKeyword("end-line"), int(4308))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - return lang.NewList() - case 1: - v3 := args[0] - _ = v3 - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - return v3 - }) - tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) - return tmp5 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 lang.FnFunc - tmp5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var tmp6 any - { // let - // let binding "s1" - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("seq")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp9, []any{v3}) - var v11 any = tmp10 - _ = v11 - // let binding "s2" - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("seq")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.Apply(tmp14, []any{v4}) - var v16 any = tmp15 - _ = v16 - var tmp17 any - var tmp18 any - { // let - // let binding "and__0__auto__" - var v19 any = v11 - _ = v19 - var tmp20 any - if lang.IsTruthy(v19) { - tmp20 = v16 - } else { - tmp20 = v19 - } - tmp18 = tmp20 - } // end let - if lang.IsTruthy(tmp18) { - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("cons")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("first")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.Apply(tmp24, []any{v11}) - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("cons")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("first")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.Apply(tmp31, []any{v16}) - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("interleave")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("rest")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{v11}) - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("rest")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.Apply(tmp42, []any{v16}) - tmp44 := lang.Apply(tmp35, []any{tmp39, tmp43}) - tmp45 := lang.Apply(tmp28, []any{tmp32, tmp44}) - tmp46 := lang.Apply(tmp21, []any{tmp25, tmp45}) - tmp17 = tmp46 - } else { - } - tmp6 = tmp17 - } // end let - return tmp6 - }) - tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) - return tmp6 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - var tmp6 lang.FnFunc - tmp6 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var tmp7 any - { // let - // let binding "ss" - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("map")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("seq")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("conj")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{v5, v4, v3}) - tmp18 := lang.Apply(tmp10, []any{tmp13, tmp17}) - var v19 any = tmp18 - _ = v19 - var tmp20 any - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("every?")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("identity")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.Apply(tmp23, []any{tmp26, v19}) - if lang.IsTruthy(tmp27) { - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("concat")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("map")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("first")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.Apply(tmp33, []any{tmp36, v19}) - tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp39 := tmp38.FindInternedVar(lang.NewSymbol("apply")) - if tmp39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) - } - tmp40 := tmp39.Get() - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("interleave")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("map")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp48 := tmp47.FindInternedVar(lang.NewSymbol("rest")) - if tmp48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) - } - tmp49 := tmp48.Get() - tmp50 := lang.Apply(tmp46, []any{tmp49, v19}) - tmp51 := lang.Apply(tmp40, []any{tmp43, tmp50}) - tmp52 := lang.Apply(tmp30, []any{tmp37, tmp51}) - tmp20 = tmp52 - } else { - } - tmp7 = tmp20 - } // end let - return tmp7 - }) - tmp7 := lang.Apply(lang.NewLazySeq, []any{tmp6}) - return tmp7 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // intern - { - tmp0 := lang.NewSymbol("intern").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name"), lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Finds or creates a var named by the symbol name in the namespace\n ns (which can be a symbol or a namespace), setting its root binding\n to val if supplied. The namespace must exist. The var will adopt any\n metadata from the name symbol. Returns the var.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6311), lang.NewKeyword("end-line"), int(6311))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - { // let - // let binding "v" - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("the-ns")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(tmp8, []any{v3}) - tmp10 := lang.Apply(nil, []any{tmp9, v4}) - var v11 any = tmp10 - _ = v11 - var tmp12 any - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("meta")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{v4}) - if lang.IsTruthy(tmp16) { - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("meta")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.Apply(tmp19, []any{v4}) - tmp21, _ := lang.FieldOrMethod(v11, "setMeta") - if reflect.TypeOf(tmp21).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMeta is not a function"))) - } - tmp22 := lang.Apply(tmp21, []any{tmp20}) - tmp12 = tmp22 - } else { - } - _ = tmp12 - tmp5 = v11 - } // end let - return tmp5 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var tmp6 any - { // let - // let binding "v" - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("the-ns")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp9, []any{v3}) - tmp11 := lang.Apply(nil, []any{tmp10, v4, v5}) - var v12 any = tmp11 - _ = v12 - var tmp13 any - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("meta")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{v4}) - if lang.IsTruthy(tmp17) { - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("meta")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.Apply(tmp20, []any{v4}) - tmp22, _ := lang.FieldOrMethod(v12, "setMeta") - if reflect.TypeOf(tmp22).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMeta is not a function"))) - } - tmp23 := lang.Apply(tmp22, []any{tmp21}) - tmp13 = tmp23 - } else { - } - _ = tmp13 - tmp6 = v12 - } // end let - return tmp6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // interpose - { - tmp0 := lang.NewSymbol("interpose").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sep")), lang.NewVector(lang.NewSymbol("sep"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy seq of the elements of coll separated by sep.\n Returns a stateful transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5230), lang.NewKeyword("end-line"), int(5230))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v5 := args[0] - _ = v5 - var tmp6 any - { // let - // let binding "started" - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("volatile!")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp9, []any{false}) - var v11 any = tmp10 - _ = v11 - var tmp12 lang.FnFunc - tmp12 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp13 := lang.Apply(v5, nil) - return tmp13 - case 1: - v13 := args[0] - _ = v13 - tmp14 := lang.Apply(v5, []any{v13}) - return tmp14 - case 2: - v13 := args[0] - _ = v13 - v14 := args[1] - _ = v14 - var tmp15 any - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("deref")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{v11}) - if lang.IsTruthy(tmp19) { - var tmp20 any - { // let - // let binding "sepr" - tmp21 := lang.Apply(v5, []any{v13, v3}) - var v22 any = tmp21 - _ = v22 - var tmp23 any - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("reduced?")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.Apply(tmp26, []any{v22}) - if lang.IsTruthy(tmp27) { - tmp23 = v22 - } else { - tmp28 := lang.Apply(v5, []any{v22, v14}) - tmp23 = tmp28 - } - tmp20 = tmp23 - } // end let - tmp15 = tmp20 - } else { - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("vreset!")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.Apply(tmp23, []any{v11, true}) - _ = tmp24 - tmp25 := lang.Apply(v5, []any{v13, v14}) - tmp15 = tmp25 - } - return tmp15 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5238), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(5249), lang.NewKeyword("end-column"), int(35)) - tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp6 = tmp14 - } // end let - return tmp6 - }) - tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5236), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(5249), lang.NewKeyword("end-column"), int(37)) - tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp6 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("drop")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("interleave")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("repeat")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{v3}) - tmp15 := lang.Apply(tmp10, []any{tmp14, v4}) - tmp16 := lang.Apply(tmp7, []any{int64(1), tmp15}) - return tmp16 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // into - { - tmp0 := lang.NewSymbol("into").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("to")), lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("from")), lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("xform"), lang.NewSymbol("from"))), lang.NewKeyword("doc"), "Returns a new coll consisting of to with all of the items of\n from conjoined. A transducer may be supplied.\n (into x) returns x. (into) returns [].", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6922), lang.NewKeyword("end-line"), int(6922))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp3 := lang.NewVector() - tmp4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6928), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(6928), lang.NewKeyword("end-column"), int(8)) - tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp5 - case 1: - v3 := args[0] - _ = v3 - return v3 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("instance?")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := reflect.TypeOf((*lang.IEditableCollection)(nil)).Elem() - tmp10 := lang.Apply(tmp8, []any{tmp9, v3}) - if lang.IsTruthy(tmp10) { - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("with-meta")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("persistent!")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("reduce")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("conj!")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("transient")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.Apply(tmp25, []any{v3}) - tmp27 := lang.Apply(tmp19, []any{tmp22, tmp26, v4}) - tmp28 := lang.Apply(tmp16, []any{tmp27}) - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("meta")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.Apply(tmp31, []any{v3}) - tmp33 := lang.Apply(tmp13, []any{tmp28, tmp32}) - tmp5 = tmp33 - } else { - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("reduce")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("conj")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.Apply(tmp36, []any{tmp39, v3, v4}) - tmp5 = tmp40 - } - return tmp5 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var tmp6 any - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("instance?")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := reflect.TypeOf((*lang.IEditableCollection)(nil)).Elem() - tmp11 := lang.Apply(tmp9, []any{tmp10, v3}) - if lang.IsTruthy(tmp11) { - var tmp12 any - { // let - // let binding "tm" - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("meta")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{v3}) - var v17 any = tmp16 - _ = v17 - // let binding "rf" - var tmp18 lang.FnFunc - tmp18 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v19 := args[0] - _ = v19 - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("with-meta")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("persistent!")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.Apply(tmp25, []any{v19}) - tmp27 := lang.Apply(tmp22, []any{tmp26, v17}) - return tmp27 - case 2: - v19 := args[0] - _ = v19 - v20 := args[1] - _ = v20 - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("conj!")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.Apply(tmp23, []any{v19, v20}) - return tmp24 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6937), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(6939), lang.NewKeyword("end-column"), int(44)) - tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v21 any = tmp20 - _ = v21 - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("transduce")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("transient")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.Apply(tmp27, []any{v3}) - tmp29 := lang.Apply(tmp24, []any{v4, v21, tmp28, v5}) - tmp12 = tmp29 - } // end let - tmp6 = tmp12 - } else { - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("transduce")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("conj")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp15, []any{v4, tmp18, v3, v5}) - tmp6 = tmp19 - } - return tmp6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // into-array - { - tmp0 := lang.NewSymbol("into-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("aseq")), lang.NewVector(lang.NewSymbol("type"), lang.NewSymbol("aseq"))), lang.NewKeyword("doc"), "Returns an array with components set to the values in aseq. The array's\n component type is type if provided, or the type of the first value in\n aseq if present, or Object. All values in aseq must be compatible with\n the component type. Class objects for the primitive types can be obtained\n using, e.g., Integer/TYPE.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3444), lang.NewKeyword("end-line"), int(3444))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.Apply(tmp6, []any{v3}) - tmp8 := lang.Apply(nil, []any{tmp7}) - return tmp8 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v4}) - tmp9 := lang.Apply(nil, []any{v3, tmp8}) - return tmp9 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // into1 - { - tmp0 := lang.NewSymbol("into1").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("from"))), lang.NewKeyword("doc"), "Returns a new coll consisting of to-coll with all of the items of\n from-coll conjoined.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3416), lang.NewKeyword("end-line"), int(3416), lang.NewKeyword("private"), true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("instance?")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := reflect.TypeOf((*lang.IEditableCollection)(nil)).Elem() - tmp10 := lang.Apply(tmp8, []any{tmp9, v3}) - if lang.IsTruthy(tmp10) { - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("persistent!")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("conj!")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("transient")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.Apply(tmp22, []any{v3}) - tmp24 := lang.Apply(tmp16, []any{tmp19, tmp23, v4}) - tmp25 := lang.Apply(tmp13, []any{tmp24}) - tmp5 = tmp25 - } else { - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("conj")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.Apply(tmp28, []any{tmp31, v3, v4}) - tmp5 = tmp32 - } - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // ints - { - var tmp1 lang.FnFunc - { // function ints - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.Apply(tmp20, []any{lang.NewSymbol("glojure.core/Ints")}) - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("list")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.Apply(tmp24, []any{v3}) - tmp26 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp21, tmp25}) - tmp27 := lang.Apply(tmp6, []any{tmp26}) - return tmp27 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("ints").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Casts to int[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5397), lang.NewKeyword("end-line"), int(5397))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Ints") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Ints is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // io! - { - tmp0 := lang.NewSymbol("io!").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "If an io! block occurs in a transaction, throws an\n IllegalStateException, else runs body in an implicit do. If the\n first expression in body is a literal string, will use that as the\n exception message.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(2504), lang.NewKeyword("end-line"), int(2504))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - var tmp6 any - { // let - // let binding "message" - var tmp7 any - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("string?")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("first")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{v5}) - tmp15 := lang.Apply(tmp10, []any{tmp14}) - if lang.IsTruthy(tmp15) { - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("first")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{v5}) - tmp7 = tmp19 - } else { - } - var v20 any = tmp7 - _ = v20 - // let binding "body" - var tmp21 any - if lang.IsTruthy(v20) { - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("next")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.Apply(tmp24, []any{v5}) - tmp21 = tmp25 - } else { - tmp21 = v5 - } - var v26 any = tmp21 - _ = v26 - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("seq")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("concat")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("list")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.Apply(tmp35, []any{lang.NewSymbol("if")}) - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("list")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("seq")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp44 := tmp43.FindInternedVar(lang.NewSymbol("concat")) - if tmp44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) - } - tmp45 := tmp44.Get() - tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp47 := tmp46.FindInternedVar(lang.NewSymbol("list")) - if tmp47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) - } - tmp48 := tmp47.Get() - tmp49 := lang.Apply(tmp48, []any{lang.NewSymbol("glojure.lang.LockingTransaction/isRunning")}) - tmp50 := lang.Apply(tmp45, []any{tmp49}) - tmp51 := lang.Apply(tmp42, []any{tmp50}) - tmp52 := lang.Apply(tmp39, []any{tmp51}) - tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp54 := tmp53.FindInternedVar(lang.NewSymbol("list")) - if tmp54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) - } - tmp55 := tmp54.Get() - tmp56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp57 := tmp56.FindInternedVar(lang.NewSymbol("seq")) - if tmp57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp57))) - } - tmp58 := tmp57.Get() - tmp59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp60 := tmp59.FindInternedVar(lang.NewSymbol("concat")) - if tmp60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp60))) - } - tmp61 := tmp60.Get() - tmp62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp63 := tmp62.FindInternedVar(lang.NewSymbol("list")) - if tmp63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp63))) - } - tmp64 := tmp63.Get() - tmp65 := lang.Apply(tmp64, []any{lang.NewSymbol("throw")}) - tmp66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp67 := tmp66.FindInternedVar(lang.NewSymbol("list")) - if tmp67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp67))) - } - tmp68 := tmp67.Get() - tmp69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp70 := tmp69.FindInternedVar(lang.NewSymbol("seq")) - if tmp70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp70))) - } - tmp71 := tmp70.Get() - tmp72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp73 := tmp72.FindInternedVar(lang.NewSymbol("concat")) - if tmp73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp73))) - } - tmp74 := tmp73.Get() - tmp75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp76 := tmp75.FindInternedVar(lang.NewSymbol("list")) - if tmp76.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp76))) - } - tmp77 := tmp76.Get() - tmp78 := lang.Apply(tmp77, []any{lang.NewSymbol("new")}) - tmp79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp80 := tmp79.FindInternedVar(lang.NewSymbol("list")) - if tmp80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp80))) - } - tmp81 := tmp80.Get() - tmp82 := lang.Apply(tmp81, []any{lang.NewSymbol("glojure.core/IllegalStateException")}) - tmp83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp84 := tmp83.FindInternedVar(lang.NewSymbol("list")) - if tmp84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp84))) - } - tmp85 := tmp84.Get() - var tmp86 any - { // let - // let binding "or__0__auto__" - var v87 any = v20 - _ = v87 - var tmp88 any - if lang.IsTruthy(v87) { - tmp88 = v87 - } else { - tmp88 = "I/O in transaction" - } - tmp86 = tmp88 - } // end let - tmp87 := lang.Apply(tmp85, []any{tmp86}) - tmp88 := lang.Apply(tmp74, []any{tmp78, tmp82, tmp87}) - tmp89 := lang.Apply(tmp71, []any{tmp88}) - tmp90 := lang.Apply(tmp68, []any{tmp89}) - tmp91 := lang.Apply(tmp61, []any{tmp65, tmp90}) - tmp92 := lang.Apply(tmp58, []any{tmp91}) - tmp93 := lang.Apply(tmp55, []any{tmp92}) - tmp94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp95 := tmp94.FindInternedVar(lang.NewSymbol("list")) - if tmp95.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp95))) - } - tmp96 := tmp95.Get() - tmp97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp98 := tmp97.FindInternedVar(lang.NewSymbol("seq")) - if tmp98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp98))) - } - tmp99 := tmp98.Get() - tmp100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp101 := tmp100.FindInternedVar(lang.NewSymbol("concat")) - if tmp101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp101))) - } - tmp102 := tmp101.Get() - tmp103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp104 := tmp103.FindInternedVar(lang.NewSymbol("list")) - if tmp104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp104))) - } - tmp105 := tmp104.Get() - tmp106 := lang.Apply(tmp105, []any{lang.NewSymbol("do")}) - tmp107 := lang.Apply(tmp102, []any{tmp106, v26}) - tmp108 := lang.Apply(tmp99, []any{tmp107}) - tmp109 := lang.Apply(tmp96, []any{tmp108}) - tmp110 := lang.Apply(tmp32, []any{tmp36, tmp52, tmp93, tmp109}) - tmp111 := lang.Apply(tmp29, []any{tmp110}) - tmp6 = tmp111 - } // end let - return tmp6 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // isa? - { - tmp0 := lang.NewSymbol("isa?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("child"), lang.NewSymbol("parent")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("child"), lang.NewSymbol("parent"))), lang.NewKeyword("doc"), "Returns true if (= child parent), or child is directly or indirectly derived from\n parent, either via a Java type inheritance relationship or a\n relationship established via derive. h must be a hierarchy obtained\n from make-hierarchy, if not supplied defaults to the global\n hierarchy", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5543), lang.NewKeyword("end-line"), int(5543))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("isa?")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("global-hierarchy")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp7, []any{tmp10, v3, v4}) - return tmp11 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var tmp6 any - { // let - // let binding "or__0__auto__" - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("=")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp9, []any{v4, v5}) - var v11 any = tmp10 - _ = v11 - var tmp12 any - if lang.IsTruthy(v11) { - tmp12 = v11 - } else { - var tmp13 any - { // let - // let binding "or__0__auto__" - var tmp14 any - { // let - // let binding "and__0__auto__" - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("class?")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{v5}) - var v19 any = tmp18 - _ = v19 - var tmp20 any - if lang.IsTruthy(v19) { - var tmp21 any - { // let - // let binding "and__0__auto__" - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("class?")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.Apply(tmp24, []any{v4}) - var v26 any = tmp25 - _ = v26 - var tmp27 any - if lang.IsTruthy(v26) { - tmp28, _ := lang.FieldOrMethod(v4, "AssignableTo") - if reflect.TypeOf(tmp28).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("AssignableTo is not a function"))) - } - tmp29 := lang.Apply(tmp28, []any{v5}) - tmp27 = tmp29 - } else { - tmp27 = v26 - } - tmp21 = tmp27 - } // end let - tmp20 = tmp21 - } else { - tmp20 = v19 - } - tmp14 = tmp20 - } // end let - var v15 any = tmp14 - _ = v15 - var tmp16 any - if lang.IsTruthy(v15) { - tmp16 = v15 - } else { - var tmp17 any - { // let - // let binding "or__0__auto__" - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("contains?")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) - tmp22 := lang.Apply(tmp21, []any{v4}) - tmp23 := lang.Apply(tmp20, []any{tmp22, v5}) - var v24 any = tmp23 - _ = v24 - var tmp25 any - if lang.IsTruthy(v24) { - tmp25 = v24 - } else { - var tmp26 any - { // let - // let binding "or__0__auto__" - var tmp27 any - { // let - // let binding "and__0__auto__" - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("class?")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.Apply(tmp30, []any{v4}) - var v32 any = tmp31 - _ = v32 - var tmp33 any - if lang.IsTruthy(v32) { - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("some")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - var tmp37 lang.FnFunc - tmp37 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v38 := args[0] - _ = v38 - tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp40 := tmp39.FindInternedVar(lang.NewSymbol("contains?")) - if tmp40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) - } - tmp41 := tmp40.Get() - tmp42 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) - tmp43 := lang.Apply(tmp42, []any{v38}) - tmp44 := lang.Apply(tmp41, []any{tmp43, v5}) - return tmp44 - }) - tmp38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5556), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(5556), lang.NewKeyword("end-column"), int(71)) - tmp39, err := lang.WithMeta(tmp37, tmp38.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("supers")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.Apply(tmp42, []any{v4}) - tmp44 := lang.Apply(tmp36, []any{tmp39, tmp43}) - tmp33 = tmp44 - } else { - tmp33 = v32 - } - tmp27 = tmp33 - } // end let - var v28 any = tmp27 - _ = v28 - var tmp29 any - if lang.IsTruthy(v28) { - tmp29 = v28 - } else { - var tmp30 any - { // let - // let binding "and__0__auto__" - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("vector?")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{v5}) - var v35 any = tmp34 - _ = v35 - var tmp36 any - if lang.IsTruthy(v35) { - var tmp37 any - { // let - // let binding "and__0__auto__" - tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp39 := tmp38.FindInternedVar(lang.NewSymbol("vector?")) - if tmp39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) - } - tmp40 := tmp39.Get() - tmp41 := lang.Apply(tmp40, []any{v4}) - var v42 any = tmp41 - _ = v42 - var tmp43 any - if lang.IsTruthy(v42) { - var tmp44 any - { // let - // let binding "and__0__auto__" - tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp46 := tmp45.FindInternedVar(lang.NewSymbol("=")) - if tmp46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) - } - tmp47 := tmp46.Get() - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("count")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v5}) - tmp52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp53 := tmp52.FindInternedVar(lang.NewSymbol("count")) - if tmp53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp53))) - } - tmp54 := tmp53.Get() - tmp55 := lang.Apply(tmp54, []any{v4}) - tmp56 := lang.Apply(tmp47, []any{tmp51, tmp55}) - var v57 any = tmp56 - _ = v57 - var tmp58 any - if lang.IsTruthy(v57) { - var tmp59 any - { // let - // let binding "ret" - var v60 any = true - _ = v60 - // let binding "i" - var v61 any = int64(0) - _ = v61 - for { - var tmp62 any - var tmp63 any - { // let - // let binding "or__0__auto__" - tmp64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp65 := tmp64.FindInternedVar(lang.NewSymbol("not")) - if tmp65.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp65))) - } - tmp66 := tmp65.Get() - tmp67 := lang.Apply(tmp66, []any{v60}) - var v68 any = tmp67 - _ = v68 - var tmp69 any - if lang.IsTruthy(v68) { - tmp69 = v68 - } else { - tmp70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp71 := tmp70.FindInternedVar(lang.NewSymbol("=")) - if tmp71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp71))) - } - tmp72 := tmp71.Get() - tmp73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp74 := tmp73.FindInternedVar(lang.NewSymbol("count")) - if tmp74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp74))) - } - tmp75 := tmp74.Get() - tmp76 := lang.Apply(tmp75, []any{v5}) - tmp77 := lang.Apply(tmp72, []any{v61, tmp76}) - tmp69 = tmp77 - } - tmp63 = tmp69 - } // end let - if lang.IsTruthy(tmp63) { - tmp62 = v60 - } else { - tmp65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp66 := tmp65.FindInternedVar(lang.NewSymbol("isa?")) - if tmp66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp66))) - } - tmp67 := tmp66.Get() - tmp68 := lang.Apply(v4, []any{v61}) - tmp69 := lang.Apply(v5, []any{v61}) - tmp70 := lang.Apply(tmp67, []any{v3, tmp68, tmp69}) - var tmp64 any = tmp70 - tmp72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp73 := tmp72.FindInternedVar(lang.NewSymbol("inc")) - if tmp73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp73))) - } - tmp74 := tmp73.Get() - tmp75 := lang.Apply(tmp74, []any{v61}) - var tmp71 any = tmp75 - v60 = tmp64 - v61 = tmp71 - continue - } - tmp59 = tmp62 - break - } - } // end let - tmp58 = tmp59 - } else { - tmp58 = v57 - } - tmp44 = tmp58 - } // end let - tmp43 = tmp44 - } else { - tmp43 = v42 - } - tmp37 = tmp43 - } // end let - tmp36 = tmp37 - } else { - tmp36 = v35 - } - tmp30 = tmp36 - } // end let - tmp29 = tmp30 - } - tmp26 = tmp29 - } // end let - tmp25 = tmp26 - } - tmp17 = tmp25 - } // end let - tmp16 = tmp17 - } - tmp13 = tmp16 - } // end let - tmp12 = tmp13 - } - tmp6 = tmp12 - } // end let - return tmp6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // iterate - { - tmp0 := lang.NewSymbol("iterate").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns a lazy (infinite!) sequence of x, (f x), (f (f x)) etc.\n f must be free of side-effects", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3011), lang.NewKeyword("end-line"), int(3011))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.Apply(nil, []any{v3, v4}) - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // iteration - { - tmp0 := lang.NewSymbol("iteration").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("step"), lang.NewSymbol("&"), lang.NewMap(lang.NewKeyword("keys"), lang.NewVector(lang.NewSymbol("somef"), lang.NewSymbol("vf"), lang.NewSymbol("kf"), lang.NewSymbol("initk")), lang.NewKeyword("or"), lang.NewMap(lang.NewSymbol("vf"), lang.NewSymbol("identity"), lang.NewSymbol("kf"), lang.NewSymbol("identity"), lang.NewSymbol("somef"), lang.NewSymbol("some?"), lang.NewSymbol("initk"), nil)))), lang.NewKeyword("doc"), "Creates a seqable/reducible via repeated calls to step,\n a function of some (continuation token) 'k'. The first call to step\n will be passed initk, returning 'ret'. Iff (somef ret) is true,\n (vf ret) will be included in the iteration, else iteration will\n terminate and vf/kf will not be called. If (kf ret) is non-nil it\n will be passed to the next step call, else iteration will terminate.\n\n This can be used e.g. to consume APIs that return paginated or batched data.\n\n step - (possibly impure) fn of 'k' -> 'ret'\n\n :somef - fn of 'ret' -> logical true/false, default 'some?'\n :vf - fn of 'ret' -> 'v', a value produced by the iteration, default 'identity'\n :kf - fn of 'ret' -> 'next-k' or nil (signaling 'do not continue'), default 'identity'\n :initk - the first value passed to step, default 'nil'\n\n It is presumed that step with non-initk is unreproducible/non-idempotent.\n If step with initk is unreproducible it is on the consumer to not consume twice.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7716), lang.NewKeyword("end-line"), int(7716))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var v4 any = lang.NewList(args[1:]...) - _ = v4 - var tmp5 any - { // let - // let binding "map__345" - var v6 any = v4 - _ = v6 - // let binding "map__345" - var tmp7 any - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("seq?")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v6}) - if lang.IsTruthy(tmp11) { - var tmp12 any - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("next")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{v6}) - if lang.IsTruthy(tmp16) { - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("to-array")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.Apply(tmp19, []any{v6}) - tmp21 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{tmp20}) - tmp12 = tmp21 - } else { - var tmp22 any - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("seq")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.Apply(tmp25, []any{v6}) - if lang.IsTruthy(tmp26) { - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("first")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{v6}) - tmp22 = tmp30 - } else { - } - tmp12 = tmp22 - } - tmp7 = tmp12 - } else { - tmp7 = v6 - } - var v31 any = tmp7 - _ = v31 - // let binding "somef" - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("get")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp36 := tmp35.FindInternedVar(lang.NewSymbol("some?")) - if tmp36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) - } - tmp37 := tmp36.Get() - tmp38 := lang.Apply(tmp34, []any{v31, lang.NewKeyword("somef"), tmp37}) - var v39 any = tmp38 - _ = v39 - // let binding "vf" - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("get")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp44 := tmp43.FindInternedVar(lang.NewSymbol("identity")) - if tmp44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) - } - tmp45 := tmp44.Get() - tmp46 := lang.Apply(tmp42, []any{v31, lang.NewKeyword("vf"), tmp45}) - var v47 any = tmp46 - _ = v47 - // let binding "kf" - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("get")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp52 := tmp51.FindInternedVar(lang.NewSymbol("identity")) - if tmp52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp52))) - } - tmp53 := tmp52.Get() - tmp54 := lang.Apply(tmp50, []any{v31, lang.NewKeyword("kf"), tmp53}) - var v55 any = tmp54 - _ = v55 - // let binding "initk" - tmp56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp57 := tmp56.FindInternedVar(lang.NewSymbol("get")) - if tmp57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp57))) - } - tmp58 := tmp57.Get() - tmp59 := lang.Apply(tmp58, []any{v31, lang.NewKeyword("initk"), nil}) - var v60 any = tmp59 - _ = v60 - tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp62 := tmp61.FindInternedVar(lang.NewSymbol("seq")) - if tmp62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) - } - tmp63 := tmp62.Get() - tmp64 := lang.NewVector(nil) - tmp65 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7743), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(7743), lang.NewKeyword("end-column"), int(11)) - tmp66, err := lang.WithMeta(tmp64, tmp65.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var tmp67 lang.FnFunc - { // function next - var v68 lang.FnFunc - tmp67 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v69 := args[0] - _ = v69 - var tmp70 any - tmp71 := lang.Apply(v39, []any{v69}) - if lang.IsTruthy(tmp71) { - tmp72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp73 := tmp72.FindInternedVar(lang.NewSymbol("cons")) - if tmp73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp73))) - } - tmp74 := tmp73.Get() - tmp75 := lang.Apply(v47, []any{v69}) - var tmp76 any - { // let - // let binding "temp__0__auto__" - tmp77 := lang.Apply(v55, []any{v69}) - var v78 any = tmp77 - _ = v78 - var tmp79 any - tmp80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp81 := tmp80.FindInternedVar(lang.NewSymbol("nil?")) - if tmp81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp81))) - } - tmp82 := tmp81.Get() - tmp83 := lang.Apply(tmp82, []any{v78}) - if lang.IsTruthy(tmp83) { - } else { - var tmp84 any - { // let - // let binding "k" - var v85 any = v78 - _ = v85 - var tmp86 lang.FnFunc - tmp86 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - tmp87 := lang.Apply(v3, []any{v85}) - tmp88 := lang.Apply(v68, []any{tmp87}) - return tmp88 - }) - tmp87 := lang.Apply(lang.NewLazySeq, []any{tmp86}) - tmp84 = tmp87 - } // end let - tmp79 = tmp84 - } - tmp76 = tmp79 - } // end let - tmp77 := lang.Apply(tmp74, []any{tmp75, tmp76}) - tmp70 = tmp77 - } else { - } - return tmp70 - }) - v68 = tmp67 - _ = v68 - } - tmp68 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7744), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(7748), lang.NewKeyword("end-column"), int(51)) - tmp69, err := lang.WithMeta(tmp67, tmp68.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp70 := lang.Apply(v3, []any{v60}) - tmp71 := lang.Apply(tmp69, []any{tmp70}) - tmp72 := lang.Apply(tmp63, []any{tmp66, tmp71}) - tmp73 := reflect.TypeOf((*lang.IReduceInit)(nil)).Elem() - tmp74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp75 := tmp74.FindInternedVar(lang.NewSymbol("reduce")) - if tmp75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp75))) - } - tmp76 := tmp75.Get() - tmp77 := lang.NewVector(nil, nil, nil) - tmp78 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7751), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(7751), lang.NewKeyword("end-column"), int(22)) - tmp79, err := lang.WithMeta(tmp77, tmp78.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var tmp80 any - { // let - // let binding "acc" - var v81 any = nil - _ = v81 - // let binding "ret" - tmp82 := lang.Apply(v3, []any{v60}) - var v83 any = tmp82 - _ = v83 - for { - var tmp84 any - tmp85 := lang.Apply(v39, []any{v83}) - if lang.IsTruthy(tmp85) { - var tmp86 any - { // let - // let binding "acc" - tmp87 := lang.Apply(v47, []any{v83}) - tmp88 := lang.Apply(nil, []any{v81, tmp87}) - var v89 any = tmp88 - _ = v89 - var tmp90 any - tmp91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp92 := tmp91.FindInternedVar(lang.NewSymbol("reduced?")) - if tmp92.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp92))) - } - tmp93 := tmp92.Get() - tmp94 := lang.Apply(tmp93, []any{v89}) - if lang.IsTruthy(tmp94) { - tmp95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp96 := tmp95.FindInternedVar(lang.NewSymbol("deref")) - if tmp96.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp96))) - } - tmp97 := tmp96.Get() - tmp98 := lang.Apply(tmp97, []any{v89}) - tmp90 = tmp98 - } else { - var tmp99 any - { // let - // let binding "temp__0__auto__" - tmp100 := lang.Apply(v55, []any{v83}) - var v101 any = tmp100 - _ = v101 - var tmp102 any - tmp103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp104 := tmp103.FindInternedVar(lang.NewSymbol("nil?")) - if tmp104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp104))) - } - tmp105 := tmp104.Get() - tmp106 := lang.Apply(tmp105, []any{v101}) - if lang.IsTruthy(tmp106) { - tmp102 = v89 - } else { - var tmp107 any - { // let - // let binding "k" - var v108 any = v101 - _ = v108 - var tmp109 any = v89 - tmp111 := lang.Apply(v3, []any{v108}) - var tmp110 any = tmp111 - v81 = tmp109 - v83 = tmp110 - continue - } // end let - tmp102 = tmp107 - } - tmp99 = tmp102 - } // end let - tmp90 = tmp99 - } - tmp86 = tmp90 - } // end let - tmp84 = tmp86 - } else { - tmp84 = v81 - } - tmp80 = tmp84 - break - } - } // end let - tmp81 := lang.Apply(tmp76, []any{tmp79, tmp80}) - tmp82 := lang.Apply(nil, []any{nil, tmp72, tmp73, tmp81}) - tmp5 = tmp82 - } // end let - return tmp5 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // iterator-seq - { - tmp0 := lang.NewSymbol("iterator-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("iter"))), lang.NewKeyword("doc"), "Returns a seq on a java.util.Iterator. Note that most collections\n providing iterators implement Iterable and thus support seq directly.\n Seqs cache values, thus iterator-seq should not be used on any\n iterator that repeatedly returns the same mutable object.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5700), lang.NewKeyword("end-line"), int(5700))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.Apply(nil, []any{v3}) - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // juxt - { - tmp0 := lang.NewSymbol("juxt").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("g")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("g"), lang.NewSymbol("h")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("g"), lang.NewSymbol("h"), lang.NewSymbol("&"), lang.NewSymbol("fs"))), lang.NewKeyword("doc"), "Takes a set of functions and returns a fn that is the juxtaposition\n of those fns. The returned fn takes a variable number of args, and\n returns a vector containing the result of applying each fn to the\n args (left-to-right).\n ((juxt a b c) x) => [(a x) (b x) (c x)]", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2568), lang.NewKeyword("end-line"), int(2568))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp5 := lang.Apply(v3, nil) - tmp6 := lang.NewVector(tmp5) - tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2578), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(2578), lang.NewKeyword("end-column"), int(16)) - tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp8 - case 1: - v5 := args[0] - _ = v5 - tmp6 := lang.Apply(v3, []any{v5}) - tmp7 := lang.NewVector(tmp6) - tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2579), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(2579), lang.NewKeyword("end-column"), int(19)) - tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp9 - case 2: - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - tmp7 := lang.Apply(v3, []any{v5, v6}) - tmp8 := lang.NewVector(tmp7) - tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2580), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(2580), lang.NewKeyword("end-column"), int(23)) - tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp10 - case 3: - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - v7 := args[2] - _ = v7 - tmp8 := lang.Apply(v3, []any{v5, v6, v7}) - tmp9 := lang.NewVector(tmp8) - tmp10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2581), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(2581), lang.NewKeyword("end-column"), int(27)) - tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp11 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - v7 := args[2] - _ = v7 - var v8 any = lang.NewList(args[3:]...) - _ = v8 - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("apply")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.Apply(tmp11, []any{v3, v5, v6, v7, v8}) - tmp13 := lang.NewVector(tmp12) - tmp14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2582), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(2582), lang.NewKeyword("end-column"), int(45)) - tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp15 - } - }) - tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2577), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2582), lang.NewKeyword("end-column"), int(47)) - tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp6 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 lang.FnFunc - tmp5 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp6 := lang.Apply(v3, nil) - tmp7 := lang.Apply(v4, nil) - tmp8 := lang.NewVector(tmp6, tmp7) - tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2585), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(2585), lang.NewKeyword("end-column"), int(20)) - tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp10 - case 1: - v6 := args[0] - _ = v6 - tmp7 := lang.Apply(v3, []any{v6}) - tmp8 := lang.Apply(v4, []any{v6}) - tmp9 := lang.NewVector(tmp7, tmp8) - tmp10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2586), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(2586), lang.NewKeyword("end-column"), int(25)) - tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp11 - case 2: - v6 := args[0] - _ = v6 - v7 := args[1] - _ = v7 - tmp8 := lang.Apply(v3, []any{v6, v7}) - tmp9 := lang.Apply(v4, []any{v6, v7}) - tmp10 := lang.NewVector(tmp8, tmp9) - tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2587), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(2587), lang.NewKeyword("end-column"), int(31)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp12 - case 3: - v6 := args[0] - _ = v6 - v7 := args[1] - _ = v7 - v8 := args[2] - _ = v8 - tmp9 := lang.Apply(v3, []any{v6, v7, v8}) - tmp10 := lang.Apply(v4, []any{v6, v7, v8}) - tmp11 := lang.NewVector(tmp9, tmp10) - tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2588), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(2588), lang.NewKeyword("end-column"), int(37)) - tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp13 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v6 := args[0] - _ = v6 - v7 := args[1] - _ = v7 - v8 := args[2] - _ = v8 - var v9 any = lang.NewList(args[3:]...) - _ = v9 - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("apply")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{v3, v6, v7, v8, v9}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("apply")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{v4, v6, v7, v8, v9}) - tmp18 := lang.NewVector(tmp13, tmp17) - tmp19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2589), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(2589), lang.NewKeyword("end-column"), int(66)) - tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp20 - } - }) - tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2584), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2589), lang.NewKeyword("end-column"), int(68)) - tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp7 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var tmp6 lang.FnFunc - tmp6 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp7 := lang.Apply(v3, nil) - tmp8 := lang.Apply(v4, nil) - tmp9 := lang.Apply(v5, nil) - tmp10 := lang.NewVector(tmp7, tmp8, tmp9) - tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2592), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(2592), lang.NewKeyword("end-column"), int(24)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp12 - case 1: - v7 := args[0] - _ = v7 - tmp8 := lang.Apply(v3, []any{v7}) - tmp9 := lang.Apply(v4, []any{v7}) - tmp10 := lang.Apply(v5, []any{v7}) - tmp11 := lang.NewVector(tmp8, tmp9, tmp10) - tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2593), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(2593), lang.NewKeyword("end-column"), int(31)) - tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp13 - case 2: - v7 := args[0] - _ = v7 - v8 := args[1] - _ = v8 - tmp9 := lang.Apply(v3, []any{v7, v8}) - tmp10 := lang.Apply(v4, []any{v7, v8}) - tmp11 := lang.Apply(v5, []any{v7, v8}) - tmp12 := lang.NewVector(tmp9, tmp10, tmp11) - tmp13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2594), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(2594), lang.NewKeyword("end-column"), int(39)) - tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp14 - case 3: - v7 := args[0] - _ = v7 - v8 := args[1] - _ = v8 - v9 := args[2] - _ = v9 - tmp10 := lang.Apply(v3, []any{v7, v8, v9}) - tmp11 := lang.Apply(v4, []any{v7, v8, v9}) - tmp12 := lang.Apply(v5, []any{v7, v8, v9}) - tmp13 := lang.NewVector(tmp10, tmp11, tmp12) - tmp14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2595), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(2595), lang.NewKeyword("end-column"), int(47)) - tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp15 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v7 := args[0] - _ = v7 - v8 := args[1] - _ = v8 - v9 := args[2] - _ = v9 - var v10 any = lang.NewList(args[3:]...) - _ = v10 - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("apply")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{v3, v7, v8, v9, v10}) - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("apply")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{v4, v7, v8, v9, v10}) - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("apply")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, []any{v5, v7, v8, v9, v10}) - tmp23 := lang.NewVector(tmp14, tmp18, tmp22) - tmp24 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2596), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(2596), lang.NewKeyword("end-column"), int(87)) - tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp25 - } - }) - tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2591), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2596), lang.NewKeyword("end-column"), int(89)) - tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp8 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any - { // let - // let binding "fs" - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("list*")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v3, v4, v5, v6}) - var v12 any = tmp11 - _ = v12 - var tmp13 lang.FnFunc - tmp13 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - var tmp17 lang.FnFunc - tmp17 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v18 := args[0] - _ = v18 - v19 := args[1] - _ = v19 - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("conj")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.Apply(v19, nil) - tmp24 := lang.Apply(tmp22, []any{v18, tmp23}) - return tmp24 - }) - tmp18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2600), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(2600), lang.NewKeyword("end-column"), int(37)) - tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp20 := lang.NewVector() - tmp21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2600), lang.NewKeyword("column"), int(39), lang.NewKeyword("end-line"), int(2600), lang.NewKeyword("end-column"), int(40)) - tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp23 := lang.Apply(tmp16, []any{tmp19, tmp22, v12}) - return tmp23 - case 1: - v14 := args[0] - _ = v14 - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - var tmp18 lang.FnFunc - tmp18 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v19 := args[0] - _ = v19 - v20 := args[1] - _ = v20 - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("conj")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.Apply(v20, []any{v14}) - tmp25 := lang.Apply(tmp23, []any{v19, tmp24}) - return tmp25 - }) - tmp19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2601), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(2601), lang.NewKeyword("end-column"), int(40)) - tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp21 := lang.NewVector() - tmp22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2601), lang.NewKeyword("column"), int(42), lang.NewKeyword("end-line"), int(2601), lang.NewKeyword("end-column"), int(43)) - tmp23, err := lang.WithMeta(tmp21, tmp22.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp24 := lang.Apply(tmp17, []any{tmp20, tmp23, v12}) - return tmp24 - case 2: - v14 := args[0] - _ = v14 - v15 := args[1] - _ = v15 - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - var tmp19 lang.FnFunc - tmp19 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v20 := args[0] - _ = v20 - v21 := args[1] - _ = v21 - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("conj")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.Apply(v21, []any{v14, v15}) - tmp26 := lang.Apply(tmp24, []any{v20, tmp25}) - return tmp26 - }) - tmp20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2602), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(2602), lang.NewKeyword("end-column"), int(44)) - tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp22 := lang.NewVector() - tmp23 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2602), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(2602), lang.NewKeyword("end-column"), int(47)) - tmp24, err := lang.WithMeta(tmp22, tmp23.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp25 := lang.Apply(tmp18, []any{tmp21, tmp24, v12}) - return tmp25 - case 3: - v14 := args[0] - _ = v14 - v15 := args[1] - _ = v15 - v16 := args[2] - _ = v16 - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - var tmp20 lang.FnFunc - tmp20 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v21 := args[0] - _ = v21 - v22 := args[1] - _ = v22 - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("conj")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.Apply(v22, []any{v14, v15, v16}) - tmp27 := lang.Apply(tmp25, []any{v21, tmp26}) - return tmp27 - }) - tmp21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2603), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(2603), lang.NewKeyword("end-column"), int(48)) - tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp23 := lang.NewVector() - tmp24 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2603), lang.NewKeyword("column"), int(50), lang.NewKeyword("end-line"), int(2603), lang.NewKeyword("end-column"), int(51)) - tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp26 := lang.Apply(tmp19, []any{tmp22, tmp25, v12}) - return tmp26 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v14 := args[0] - _ = v14 - v15 := args[1] - _ = v15 - v16 := args[2] - _ = v16 - var v17 any = lang.NewList(args[3:]...) - _ = v17 - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - var tmp21 lang.FnFunc - tmp21 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v22 := args[0] - _ = v22 - v23 := args[1] - _ = v23 - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("conj")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("apply")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{v23, v14, v15, v16, v17}) - tmp31 := lang.Apply(tmp26, []any{v22, tmp30}) - return tmp31 - }) - tmp22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2604), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(2604), lang.NewKeyword("end-column"), int(66)) - tmp23, err := lang.WithMeta(tmp21, tmp22.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp24 := lang.NewVector() - tmp25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2604), lang.NewKeyword("column"), int(68), lang.NewKeyword("end-line"), int(2604), lang.NewKeyword("end-column"), int(69)) - tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp27 := lang.Apply(tmp20, []any{tmp23, tmp26, v12}) - return tmp27 - } - }) - tmp14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2599), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(2604), lang.NewKeyword("end-column"), int(75)) - tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp7 = tmp15 - } // end let - return tmp7 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // keep - { - tmp0 := lang.NewSymbol("keep").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the non-nil results of (f item). Note,\n this means false return values will be included. f must be free of\n side-effects. Returns a transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7339), lang.NewKeyword("end-line"), int(7339))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v5 := args[0] - _ = v5 - var tmp6 lang.FnFunc - tmp6 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp7 := lang.Apply(v5, nil) - return tmp7 - case 1: - v7 := args[0] - _ = v7 - tmp8 := lang.Apply(v5, []any{v7}) - return tmp8 - case 2: - v7 := args[0] - _ = v7 - v8 := args[1] - _ = v8 - var tmp9 any - { // let - // let binding "v" - tmp10 := lang.Apply(v3, []any{v8}) - var v11 any = tmp10 - _ = v11 - var tmp12 any - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("nil?")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{v11}) - if lang.IsTruthy(tmp16) { - tmp12 = v7 - } else { - tmp17 := lang.Apply(v5, []any{v7, v11}) - tmp12 = tmp17 - } - tmp9 = tmp12 - } // end let - return tmp9 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7347), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7354), lang.NewKeyword("end-column"), int(31)) - tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp8 - }) - tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7346), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7354), lang.NewKeyword("end-column"), int(32)) - tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp6 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 lang.FnFunc - tmp5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var tmp6 any - { // let - // let binding "temp__0__auto__" - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("seq")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp9, []any{v4}) - var v11 any = tmp10 - _ = v11 - var tmp12 any - if lang.IsTruthy(v11) { - var tmp13 any - { // let - // let binding "s" - var v14 any = v11 - _ = v14 - var tmp15 any - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("chunked-seq?")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{v14}) - if lang.IsTruthy(tmp19) { - var tmp20 any - { // let - // let binding "c" - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("chunk-first")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.Apply(tmp23, []any{v14}) - var v25 any = tmp24 - _ = v25 - // let binding "size" - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("count")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.Apply(tmp28, []any{v25}) - var v30 any = tmp29 - _ = v30 - // let binding "b" - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("chunk-buffer")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{v30}) - var v35 any = tmp34 - _ = v35 - var tmp36 any - { // let - // let binding "n__0__auto__" - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("long")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.Apply(tmp39, []any{v30}) - var v41 any = tmp40 - _ = v41 - var tmp42 any - { // let - // let binding "i" - var v43 any = int64(0) - _ = v43 - for { - var tmp44 any - tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp46 := tmp45.FindInternedVar(lang.NewSymbol("<")) - if tmp46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) - } - tmp47 := tmp46.Get() - tmp48 := lang.Apply(tmp47, []any{v43, v41}) - if lang.IsTruthy(tmp48) { - var tmp49 any - { // let - // let binding "x" - tmp50, _ := lang.FieldOrMethod(v25, "nth") - if reflect.TypeOf(tmp50).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) - } - tmp51 := lang.Apply(tmp50, []any{v43}) - tmp52 := lang.Apply(v3, []any{tmp51}) - var v53 any = tmp52 - _ = v53 - var tmp54 any - tmp55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp56 := tmp55.FindInternedVar(lang.NewSymbol("nil?")) - if tmp56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp56))) - } - tmp57 := tmp56.Get() - tmp58 := lang.Apply(tmp57, []any{v53}) - if lang.IsTruthy(tmp58) { - } else { - tmp59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp60 := tmp59.FindInternedVar(lang.NewSymbol("chunk-append")) - if tmp60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp60))) - } - tmp61 := tmp60.Get() - tmp62 := lang.Apply(tmp61, []any{v35, v53}) - tmp54 = tmp62 - } - tmp49 = tmp54 - } // end let - _ = tmp49 - tmp51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp52 := tmp51.FindInternedVar(lang.NewSymbol("unchecked-inc")) - if tmp52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp52))) - } - tmp53 := tmp52.Get() - tmp54 := lang.Apply(tmp53, []any{v43}) - var tmp50 any = tmp54 - v43 = tmp50 - continue - } else { - } - tmp42 = tmp44 - break - } - } // end let - tmp36 = tmp42 - } // end let - _ = tmp36 - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("chunk-cons")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("chunk")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.Apply(tmp42, []any{v35}) - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("keep")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp48 := tmp47.FindInternedVar(lang.NewSymbol("chunk-rest")) - if tmp48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) - } - tmp49 := tmp48.Get() - tmp50 := lang.Apply(tmp49, []any{v14}) - tmp51 := lang.Apply(tmp46, []any{v3, tmp50}) - tmp52 := lang.Apply(tmp39, []any{tmp43, tmp51}) - tmp20 = tmp52 - } // end let - tmp15 = tmp20 - } else { - var tmp21 any - { // let - // let binding "x" - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("first")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.Apply(tmp24, []any{v14}) - tmp26 := lang.Apply(v3, []any{tmp25}) - var v27 any = tmp26 - _ = v27 - var tmp28 any - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("nil?")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.Apply(tmp31, []any{v27}) - if lang.IsTruthy(tmp32) { - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("keep")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("rest")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{v14}) - tmp40 := lang.Apply(tmp35, []any{v3, tmp39}) - tmp28 = tmp40 - } else { - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("cons")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("keep")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp48 := tmp47.FindInternedVar(lang.NewSymbol("rest")) - if tmp48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) - } - tmp49 := tmp48.Get() - tmp50 := lang.Apply(tmp49, []any{v14}) - tmp51 := lang.Apply(tmp46, []any{v3, tmp50}) - tmp52 := lang.Apply(tmp43, []any{v27, tmp51}) - tmp28 = tmp52 - } - tmp21 = tmp28 - } // end let - tmp15 = tmp21 - } - tmp13 = tmp15 - } // end let - tmp12 = tmp13 - } else { - } - tmp6 = tmp12 - } // end let - return tmp6 - }) - tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) - return tmp6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // keep-indexed - { - tmp0 := lang.NewSymbol("keep-indexed").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the non-nil results of (f index item). Note,\n this means false return values will be included. f must be free of\n side-effects. Returns a stateful transducer when no collection is\n provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7372), lang.NewKeyword("end-line"), int(7372))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v5 := args[0] - _ = v5 - var tmp6 any - { // let - // let binding "iv" - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("volatile!")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp9, []any{int64(-1)}) - var v11 any = tmp10 - _ = v11 - var tmp12 lang.FnFunc - tmp12 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp13 := lang.Apply(v5, nil) - return tmp13 - case 1: - v13 := args[0] - _ = v13 - tmp14 := lang.Apply(v5, []any{v13}) - return tmp14 - case 2: - v13 := args[0] - _ = v13 - v14 := args[1] - _ = v14 - var tmp15 any - { // let - // let binding "i" - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("inc")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19, ok := lang.FieldOrMethod(v11, "Deref") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v11, "Deref"))) - } - var tmp20 any - switch reflect.TypeOf(tmp19).Kind() { - case reflect.Func: - tmp20 = lang.Apply(tmp19, nil) - default: - tmp20 = tmp19 - } - tmp21 := lang.Apply(tmp18, []any{tmp20}) - tmp22, _ := lang.FieldOrMethod(v11, "reset") - if reflect.TypeOf(tmp22).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) - } - tmp23 := lang.Apply(tmp22, []any{tmp21}) - var v24 any = tmp23 - _ = v24 - // let binding "v" - tmp25 := lang.Apply(v3, []any{v24, v14}) - var v26 any = tmp25 - _ = v26 - var tmp27 any - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("nil?")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.Apply(tmp30, []any{v26}) - if lang.IsTruthy(tmp31) { - tmp27 = v13 - } else { - tmp32 := lang.Apply(v5, []any{v13, v26}) - tmp27 = tmp32 - } - tmp15 = tmp27 - } // end let - return tmp15 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7382), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7390), lang.NewKeyword("end-column"), int(33)) - tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp6 = tmp14 - } // end let - return tmp6 - }) - tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7380), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7390), lang.NewKeyword("end-column"), int(35)) - tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp6 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - return nil - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // key - { - tmp0 := lang.NewSymbol("key").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("e"))), lang.NewKeyword("doc"), "Returns the key of the map entry.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1563), lang.NewKeyword("end-line"), int(1563))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4, _ := lang.FieldOrMethod(v3, "GetKey") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("GetKey is not a function"))) - } - tmp5 := lang.Apply(tmp4, []any{}) - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // keys - { - tmp0 := lang.NewSymbol("keys").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"))), lang.NewKeyword("doc"), "Returns a sequence of the map's keys, in the same order as (seq map).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1551), lang.NewKeyword("end-line"), int(1551))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.Apply(lang.Keys, []any{v3}) - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // keyword - { - tmp1 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() - tmp0 := lang.NewSymbol("keyword").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name"))), lang.NewKeyword("doc"), "Returns a Keyword with the given namespace and name. Do not use :\n in the keyword strings, it will be added automatically.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(609), lang.NewKeyword("end-line"), int(609))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v4 := args[0] - _ = v4 - var tmp5 any - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("keyword?")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(tmp8, []any{v4}) - if lang.IsTruthy(tmp9) { - tmp5 = v4 - } else { - var tmp10 any - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("symbol?")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{v4}) - if lang.IsTruthy(tmp14) { - tmp15 := lang.Apply(lang.InternKeywordSymbol, []any{v4}) - tmp10 = tmp15 - } else { - var tmp16 any - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("string?")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.Apply(tmp19, []any{v4}) - if lang.IsTruthy(tmp20) { - tmp21 := lang.Apply(lang.InternKeywordString, []any{v4}) - tmp16 = tmp21 - } else { - } - tmp10 = tmp16 - } - tmp5 = tmp10 - } - return tmp5 - case 2: - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6 := lang.Apply(lang.InternKeyword, []any{v4, v5}) - return tmp6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp4 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // keyword? - { - tmp0 := lang.NewSymbol("keyword?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a Keyword", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(563), lang.NewKeyword("end-line"), int(563))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() - tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) - return tmp8 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // last - { - tmp0 := lang.NewSymbol("last").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return the last item in coll, in linear time", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(262), lang.NewKeyword("end-line"), int(266))).(*lang.Symbol) - var tmp2 lang.FnFunc - { // function last - var v3 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - recur_loop_32: - var tmp5 any - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("next")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(tmp8, []any{v4}) - if lang.IsTruthy(tmp9) { - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("next")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{v4}) - var tmp10 any = tmp14 - v4 = tmp10 - goto recur_loop_32 - } else { - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("first")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{v4}) - tmp5 = tmp18 - } - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(266), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(269), lang.NewKeyword("end-column"), int(21))).(lang.FnFunc) - v3 = tmp2 - _ = v3 - } - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // lazy-cat - { - tmp0 := lang.NewSymbol("lazy-cat").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Expands to code which yields a lazy sequence of the concatenation\n of the supplied colls. Each coll expr is not evaluated until it is\n needed. \n\n (lazy-cat xs ys zs) === (concat (lazy-seq xs) (lazy-seq ys) (lazy-seq zs))", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4636), lang.NewKeyword("end-line"), int(4636))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("seq")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("concat")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("list")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("glojure.core/concat")}) - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("map")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - var tmp19 lang.FnFunc - tmp19 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v20 := args[0] - _ = v20 - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("list")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.Apply(tmp23, []any{lang.NewSymbol("glojure.core/lazy-seq"), v20}) - return tmp24 - }) - tmp20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4644), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(4644), lang.NewKeyword("end-column"), int(37)) - tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp22 := lang.Apply(tmp18, []any{tmp21, v5}) - tmp23 := lang.Apply(tmp11, []any{tmp15, tmp22}) - tmp24 := lang.Apply(tmp8, []any{tmp23}) - return tmp24 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // lazy-seq - { - tmp0 := lang.NewSymbol("lazy-seq").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Takes a body of expressions that returns an ISeq or nil, and yields\n a Seqable object that will invoke the body only the first time seq\n is called, and will cache the result and return it on all subsequent\n seq calls. See also - realized?", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(676), lang.NewKeyword("end-line"), int(676))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("list")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("list*")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.NewVector() - tmp13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(683), lang.NewKeyword("column"), int(101), lang.NewKeyword("end-line"), int(683), lang.NewKeyword("end-column"), int(102)) - tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp15 := lang.Apply(tmp11, []any{lang.NewSymbol("fn*"), tmp14, v5}) - tmp16 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewLazySeq"), tmp15}) - return tmp16 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // let - { - tmp0 := lang.NewSymbol("let").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "binding => binding-form init-expr\n binding-form => name, or destructuring-form\n destructuring-form => map-destructure-form, or seq-destructure-form\n\n Evaluates the exprs in a lexical context in which the symbols in\n the binding-forms are bound to their respective init-exprs or parts\n therein.\n\n See https://glojure.org/reference/special_forms#binding-forms for\n more information about destructuring.", lang.NewKeyword("forms"), lang.NewVector(lang.NewList(lang.NewSymbol("let"), lang.NewVector(lang.NewSymbol("bindings*")), lang.NewSymbol("exprs*"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4496), lang.NewKeyword("end-line"), int(4496), lang.NewKeyword("special-form"), true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("vector?")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v5}) - if lang.IsTruthy(tmp11) { - } else { - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("str")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("first")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{v3}) - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("*ns*")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("meta")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.Apply(tmp24, []any{v3}) - tmp26 := lang.Apply(lang.NewKeyword("line"), []any{tmp25}) - tmp27 := lang.Apply(tmp14, []any{tmp18, " requires ", "a vector for its binding", " in ", tmp21, ":", tmp26}) - tmp28 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp27}) - panic(tmp28) - } - _ = tmp7 - var tmp29 any - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("even?")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("count")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.Apply(tmp35, []any{v5}) - tmp37 := lang.Apply(tmp32, []any{tmp36}) - if lang.IsTruthy(tmp37) { - } else { - tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp39 := tmp38.FindInternedVar(lang.NewSymbol("str")) - if tmp39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) - } - tmp40 := tmp39.Get() - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("first")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.Apply(tmp43, []any{v3}) - tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp46 := tmp45.FindInternedVar(lang.NewSymbol("*ns*")) - if tmp46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) - } - tmp47 := tmp46.Get() - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("meta")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v3}) - tmp52 := lang.Apply(lang.NewKeyword("line"), []any{tmp51}) - tmp53 := lang.Apply(tmp40, []any{tmp44, " requires ", "an even number of forms in binding vector", " in ", tmp47, ":", tmp52}) - tmp54 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp53}) - panic(tmp54) - } - _ = tmp29 - tmp55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp56 := tmp55.FindInternedVar(lang.NewSymbol("seq")) - if tmp56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp56))) - } - tmp57 := tmp56.Get() - tmp58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp59 := tmp58.FindInternedVar(lang.NewSymbol("concat")) - if tmp59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp59))) - } - tmp60 := tmp59.Get() - tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp62 := tmp61.FindInternedVar(lang.NewSymbol("list")) - if tmp62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) - } - tmp63 := tmp62.Get() - tmp64 := lang.Apply(tmp63, []any{lang.NewSymbol("let*")}) - tmp65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp66 := tmp65.FindInternedVar(lang.NewSymbol("list")) - if tmp66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp66))) - } - tmp67 := tmp66.Get() - tmp68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp69 := tmp68.FindInternedVar(lang.NewSymbol("destructure")) - if tmp69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp69))) - } - tmp70 := tmp69.Get() - tmp71 := lang.Apply(tmp70, []any{v5}) - tmp72 := lang.Apply(tmp67, []any{tmp71}) - tmp73 := lang.Apply(tmp60, []any{tmp64, tmp72, v6}) - tmp74 := lang.Apply(tmp57, []any{tmp73}) - return tmp74 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // letfn - { - tmp0 := lang.NewSymbol("letfn").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fnspecs"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "fnspec ==> (fname [params*] exprs) or (fname ([params*] exprs)+)\n\n Takes a vector of function specs and a body, and generates a set of\n bindings of functions to their names. All of the names are available\n in all of the definitions of the functions, as well as the body.", lang.NewKeyword("forms"), lang.NewVector(lang.NewList(lang.NewSymbol("letfn"), lang.NewVector(lang.NewSymbol("fnspecs*")), lang.NewSymbol("exprs*"))), lang.NewKeyword("url"), nil, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6545), lang.NewKeyword("end-line"), int(6545), lang.NewKeyword("special-form"), true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("seq")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("concat")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("list")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("letfn*")}) - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("list")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("vec")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("interleave")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("map")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("first")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.Apply(tmp28, []any{tmp31, v5}) - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("map")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - var tmp36 lang.FnFunc - tmp36 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v37 := args[0] - _ = v37 - tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp39 := tmp38.FindInternedVar(lang.NewSymbol("cons")) - if tmp39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) - } - tmp40 := tmp39.Get() - tmp41 := lang.Apply(tmp40, []any{lang.NewSymbol("glojure.core/fn"), v37}) - return tmp41 - }) - tmp37 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6555), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(6555), lang.NewKeyword("end-column"), int(47)) - tmp38, err := lang.WithMeta(tmp36, tmp37.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp39 := lang.Apply(tmp35, []any{tmp38, v5}) - tmp40 := lang.Apply(tmp25, []any{tmp32, tmp39}) - tmp41 := lang.Apply(tmp22, []any{tmp40}) - tmp42 := lang.Apply(tmp19, []any{tmp41}) - tmp43 := lang.Apply(tmp12, []any{tmp16, tmp42, v6}) - tmp44 := lang.Apply(tmp9, []any{tmp43}) - return tmp44 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // libspec? - { - tmp0 := lang.NewSymbol("libspec?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is a libspec", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5848), lang.NewKeyword("end-line"), int(5848), lang.NewKeyword("private"), true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "or__0__auto__" - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("symbol?")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v3}) - var v9 any = tmp8 - _ = v9 - var tmp10 any - if lang.IsTruthy(v9) { - tmp10 = v9 - } else { - var tmp11 any - { // let - // let binding "and__0__auto__" - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("vector?")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.Apply(tmp14, []any{v3}) - var v16 any = tmp15 - _ = v16 - var tmp17 any - if lang.IsTruthy(v16) { - var tmp18 any - { // let - // let binding "or__0__auto__" - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("nil?")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("second")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.Apply(tmp24, []any{v3}) - tmp26 := lang.Apply(tmp21, []any{tmp25}) - var v27 any = tmp26 - _ = v27 - var tmp28 any - if lang.IsTruthy(v27) { - tmp28 = v27 - } else { - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("keyword?")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("second")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.Apply(tmp34, []any{v3}) - tmp36 := lang.Apply(tmp31, []any{tmp35}) - tmp28 = tmp36 - } - tmp18 = tmp28 - } // end let - tmp17 = tmp18 - } else { - tmp17 = v16 - } - tmp11 = tmp17 - } // end let - tmp10 = tmp11 - } - tmp4 = tmp10 - } // end let - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // lift-ns - { - tmp0 := lang.NewSymbol("lift-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"))), lang.NewKeyword("doc"), "Returns [lifted-ns lifted-kvs] or nil if m can't be lifted.", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(261), lang.NewKeyword("end-line"), int(261), lang.NewKeyword("private"), true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("*print-namespace-maps*")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - if lang.IsTruthy(tmp7) { - var tmp8 any - { // let - // let binding "ns" - var v9 any = nil - _ = v9 - // let binding "G__221" - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("seq")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{v3}) - var v14 any = tmp13 - _ = v14 - // let binding "vec__222" - var v15 any = v14 - _ = v15 - // let binding "seq__223" - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("seq")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{v15}) - var v20 any = tmp19 - _ = v20 - // let binding "first__224" - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("first")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.Apply(tmp23, []any{v20}) - var v25 any = tmp24 - _ = v25 - // let binding "seq__223" - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("next")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.Apply(tmp28, []any{v20}) - var v30 any = tmp29 - _ = v30 - // let binding "vec__225" - var v31 any = v25 - _ = v31 - // let binding "k" - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("nth")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.Apply(tmp34, []any{v31, int64(0), nil}) - var v36 any = tmp35 - _ = v36 - // let binding "v" - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("nth")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.Apply(tmp39, []any{v31, int64(1), nil}) - var v41 any = tmp40 - _ = v41 - // let binding "entry" - var v42 any = v31 - _ = v42 - // let binding "entries" - var v43 any = v30 - _ = v43 - // let binding "kvs" - tmp44 := lang.NewVector() - tmp45 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(267), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(267), lang.NewKeyword("end-column"), int(17)) - tmp46, err := lang.WithMeta(tmp44, tmp45.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v47 any = tmp46 - _ = v47 - var tmp48 any - { // let - // let binding "ns" - var v49 any = v9 - _ = v49 - // let binding "G__221" - var v50 any = v14 - _ = v50 - // let binding "kvs" - var v51 any = v47 - _ = v51 - for { - var tmp52 any - { // let - // let binding "ns" - var v53 any = v49 - _ = v53 - // let binding "vec__228" - var v54 any = v50 - _ = v54 - // let binding "seq__229" - tmp55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp56 := tmp55.FindInternedVar(lang.NewSymbol("seq")) - if tmp56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp56))) - } - tmp57 := tmp56.Get() - tmp58 := lang.Apply(tmp57, []any{v54}) - var v59 any = tmp58 - _ = v59 - // let binding "first__230" - tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp61 := tmp60.FindInternedVar(lang.NewSymbol("first")) - if tmp61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) - } - tmp62 := tmp61.Get() - tmp63 := lang.Apply(tmp62, []any{v59}) - var v64 any = tmp63 - _ = v64 - // let binding "seq__229" - tmp65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp66 := tmp65.FindInternedVar(lang.NewSymbol("next")) - if tmp66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp66))) - } - tmp67 := tmp66.Get() - tmp68 := lang.Apply(tmp67, []any{v59}) - var v69 any = tmp68 - _ = v69 - // let binding "vec__231" - var v70 any = v64 - _ = v70 - // let binding "k" - tmp71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp72 := tmp71.FindInternedVar(lang.NewSymbol("nth")) - if tmp72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp72))) - } - tmp73 := tmp72.Get() - tmp74 := lang.Apply(tmp73, []any{v70, int64(0), nil}) - var v75 any = tmp74 - _ = v75 - // let binding "v" - tmp76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp77 := tmp76.FindInternedVar(lang.NewSymbol("nth")) - if tmp77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp77))) - } - tmp78 := tmp77.Get() - tmp79 := lang.Apply(tmp78, []any{v70, int64(1), nil}) - var v80 any = tmp79 - _ = v80 - // let binding "entry" - var v81 any = v70 - _ = v81 - // let binding "entries" - var v82 any = v69 - _ = v82 - // let binding "kvs" - var v83 any = v51 - _ = v83 - var tmp84 any - if lang.IsTruthy(v81) { - var tmp85 any - tmp86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp87 := tmp86.FindInternedVar(lang.NewSymbol("qualified-ident?")) - if tmp87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp87))) - } - tmp88 := tmp87.Get() - tmp89 := lang.Apply(tmp88, []any{v75}) - if lang.IsTruthy(tmp89) { - var tmp90 any - if lang.IsTruthy(v53) { - var tmp91 any - tmp92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp93 := tmp92.FindInternedVar(lang.NewSymbol("=")) - if tmp93.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp93))) - } - tmp94 := tmp93.Get() - tmp95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp96 := tmp95.FindInternedVar(lang.NewSymbol("namespace")) - if tmp96.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp96))) - } - tmp97 := tmp96.Get() - tmp98 := lang.Apply(tmp97, []any{v75}) - tmp99 := lang.Apply(tmp94, []any{v53, tmp98}) - if lang.IsTruthy(tmp99) { - var tmp100 any = v53 - var tmp101 any = v82 - tmp103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp104 := tmp103.FindInternedVar(lang.NewSymbol("conj")) - if tmp104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp104))) - } - tmp105 := tmp104.Get() - tmp106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp107 := tmp106.FindInternedVar(lang.NewSymbol("strip-ns")) - if tmp107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp107))) - } - tmp108 := tmp107.Get() - tmp109 := lang.Apply(tmp108, []any{v75}) - tmp110 := lang.NewVector(tmp109, v80) - tmp111 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(272), lang.NewKeyword("column"), int(43), lang.NewKeyword("end-line"), int(272), lang.NewKeyword("end-column"), int(58)) - tmp112, err := lang.WithMeta(tmp110, tmp111.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp113 := lang.Apply(tmp105, []any{v83, tmp112}) - var tmp102 any = tmp113 - v49 = tmp100 - v50 = tmp101 - v51 = tmp102 - continue - } else { - } - tmp90 = tmp91 - } else { - var tmp114 any - { // let - // let binding "temp__0__auto__" - tmp115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp116 := tmp115.FindInternedVar(lang.NewSymbol("namespace")) - if tmp116.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp116))) - } - tmp117 := tmp116.Get() - tmp118 := lang.Apply(tmp117, []any{v75}) - var v119 any = tmp118 - _ = v119 - var tmp120 any - if lang.IsTruthy(v119) { - var tmp121 any - { // let - // let binding "new-ns" - var v122 any = v119 - _ = v122 - var tmp123 any = v122 - var tmp124 any = v82 - tmp126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp127 := tmp126.FindInternedVar(lang.NewSymbol("conj")) - if tmp127.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp127))) - } - tmp128 := tmp127.Get() - tmp129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp130 := tmp129.FindInternedVar(lang.NewSymbol("strip-ns")) - if tmp130.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp130))) - } - tmp131 := tmp130.Get() - tmp132 := lang.Apply(tmp131, []any{v75}) - tmp133 := lang.NewVector(tmp132, v80) - tmp134 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(274), lang.NewKeyword("column"), int(47), lang.NewKeyword("end-line"), int(274), lang.NewKeyword("end-column"), int(62)) - tmp135, err := lang.WithMeta(tmp133, tmp134.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp136 := lang.Apply(tmp128, []any{v83, tmp135}) - var tmp125 any = tmp136 - v49 = tmp123 - v50 = tmp124 - v51 = tmp125 - continue - } // end let - tmp120 = tmp121 - } else { - } - tmp114 = tmp120 - } // end let - tmp90 = tmp114 - } - tmp85 = tmp90 - } else { - } - tmp84 = tmp85 - } else { - tmp115 := lang.NewVector(v53, v83) - tmp116 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(275), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(275), lang.NewKeyword("end-column"), int(16)) - tmp117, err := lang.WithMeta(tmp115, tmp116.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp84 = tmp117 - } - tmp52 = tmp84 - } // end let - tmp48 = tmp52 - break - } - } // end let - tmp8 = tmp48 - } // end let - tmp4 = tmp8 - } else { - } - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // line-seq - { - tmp0 := lang.NewSymbol("line-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rdr"))), lang.NewKeyword("doc"), "Returns the lines of text from rdr as a lazy sequence of strings.\n rdr must implement java.io.BufferedReader.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3068), lang.NewKeyword("end-line"), int(3068))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "temp__0__auto__" - tmp5, ok := lang.FieldOrMethod(v3, "readLine") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "readLine"))) - } - var tmp6 any - switch reflect.TypeOf(tmp5).Kind() { - case reflect.Func: - tmp6 = lang.Apply(tmp5, nil) - default: - tmp6 = tmp5 - } - var v7 any = tmp6 - _ = v7 - var tmp8 any - if lang.IsTruthy(v7) { - var tmp9 any - { // let - // let binding "line" - var v10 any = v7 - _ = v10 - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("cons")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - var tmp14 lang.FnFunc - tmp14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("line-seq")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{v3}) - return tmp18 - }) - tmp15 := lang.Apply(lang.NewLazySeq, []any{tmp14}) - tmp16 := lang.Apply(tmp13, []any{v10, tmp15}) - tmp9 = tmp16 - } // end let - tmp8 = tmp9 - } else { - } - tmp4 = tmp8 - } // end let - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // list - { - tmp0 := lang.NewSymbol("list").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("items"))), lang.NewKeyword("doc"), "Creates a new list containing the items.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(15), lang.NewKeyword("end-line"), int(18))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, nil, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // list* - { - tmp0 := lang.NewSymbol("list*").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Creates a new seq containing the items prepended to the rest, the\n last of which will be treated as a sequence.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(641), lang.NewKeyword("end-line"), int(641))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.Apply(tmp6, []any{v3}) - return tmp7 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("cons")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v3, v4}) - return tmp8 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("cons")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("cons")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.Apply(tmp11, []any{v4, v5}) - tmp13 := lang.Apply(tmp8, []any{v3, tmp12}) - return tmp13 - case 4: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("cons")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("cons")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("cons")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{v5, v6}) - tmp17 := lang.Apply(tmp12, []any{v4, tmp16}) - tmp18 := lang.Apply(tmp9, []any{v3, tmp17}) - return tmp18 - default: - if len(args) < 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - var v7 any = lang.NewList(args[4:]...) - _ = v7 - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("cons")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("cons")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("cons")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("cons")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("spread")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.Apply(tmp22, []any{v7}) - tmp24 := lang.Apply(tmp19, []any{v6, tmp23}) - tmp25 := lang.Apply(tmp16, []any{v5, tmp24}) - tmp26 := lang.Apply(tmp13, []any{v4, tmp25}) - tmp27 := lang.Apply(tmp10, []any{v3, tmp26}) - return tmp27 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // list? - { - tmp0 := lang.NewSymbol("list?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements IPersistentList", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6198), lang.NewKeyword("end-line"), int(6198))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := reflect.TypeOf((*lang.IPersistentList)(nil)).Elem() - tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) - return tmp8 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // load - { - tmp0 := lang.NewSymbol("load").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("paths"))), lang.NewKeyword("doc"), "Loads Clojure code from resources in classpath. A path is interpreted as\n classpath-relative if it begins with a slash or relative to the root\n directory for the current namespace otherwise.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("redef"), true, lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6095), lang.NewKeyword("end-line"), int(6095))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var v3 any = lang.NewList(args[0:]...) - _ = v3 - var tmp4 any - { // let - // let binding "seq_133" - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v3}) - var v9 any = tmp8 - _ = v9 - // let binding "chunk_134" - var v10 any = nil - _ = v10 - // let binding "count_135" - var v11 any = int64(0) - _ = v11 - // let binding "i_136" - var v12 any = int64(0) - _ = v12 - for { - var tmp13 any - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("<")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{v12, v11}) - if lang.IsTruthy(tmp17) { - var tmp18 any - { // let - // let binding "path" - tmp19, _ := lang.FieldOrMethod(v10, "nth") - if reflect.TypeOf(tmp19).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) - } - tmp20 := lang.Apply(tmp19, []any{v12}) - var v21 any = tmp20 - _ = v21 - var tmp22 any - { // let - // let binding "path" - var tmp23 any - tmp24 := lang.Apply(strings8.HasPrefix, []any{v21, "/"}) - if lang.IsTruthy(tmp24) { - tmp23 = v21 - } else { - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("str")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("root-directory")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("ns-name")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("*ns*")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.Apply(tmp33, []any{tmp36}) - tmp38 := lang.Apply(tmp30, []any{tmp37}) - tmp39 := lang.Apply(tmp27, []any{tmp38, lang.NewChar(47), v21}) - tmp23 = tmp39 - } - var v40 any = tmp23 - _ = v40 - var tmp41 any - tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp43 := tmp42.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) - if tmp43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) - } - tmp44 := tmp43.Get() - if lang.IsTruthy(tmp44) { - tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp46 := tmp45.FindInternedVar(lang.NewSymbol("printf")) - if tmp46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) - } - tmp47 := tmp46.Get() - tmp48 := lang.Apply(tmp47, []any{"(glojure.core/load \"%s\")\n", v40}) - _ = tmp48 - tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp50 := tmp49.FindInternedVar(lang.NewSymbol("flush")) - if tmp50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) - } - tmp51 := tmp50.Get() - tmp52 := lang.Apply(tmp51, nil) - tmp41 = tmp52 - } else { - } - _ = tmp41 - tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp54 := tmp53.FindInternedVar(lang.NewSymbol("check-cyclic-dependency")) - if tmp54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) - } - tmp55 := tmp54.Get() - tmp56 := lang.Apply(tmp55, []any{v40}) - _ = tmp56 - var tmp57 any - tmp58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp59 := tmp58.FindInternedVar(lang.NewSymbol("=")) - if tmp59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp59))) - } - tmp60 := tmp59.Get() - tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp62 := tmp61.FindInternedVar(lang.NewSymbol("first")) - if tmp62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) - } - tmp63 := tmp62.Get() - tmp64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp65 := tmp64.FindInternedVar(lang.NewSymbol("*pending-paths*")) - if tmp65.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp65))) - } - tmp66 := tmp65.Get() - tmp67 := lang.Apply(tmp63, []any{tmp66}) - tmp68 := lang.Apply(tmp60, []any{v40, tmp67}) - if lang.IsTruthy(tmp68) { - } else { - var tmp69 any - { // let - tmp70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp71 := tmp70.FindInternedVar(lang.NewSymbol("push-thread-bindings")) - if tmp71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp71))) - } - tmp72 := tmp71.Get() - tmp73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp74 := tmp73.FindInternedVar(lang.NewSymbol("hash-map")) - if tmp74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp74))) - } - tmp75 := tmp74.Get() - tmp76 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*pending-paths*")) - tmp77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp78 := tmp77.FindInternedVar(lang.NewSymbol("conj")) - if tmp78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp78))) - } - tmp79 := tmp78.Get() - tmp80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp81 := tmp80.FindInternedVar(lang.NewSymbol("*pending-paths*")) - if tmp81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp81))) - } - tmp82 := tmp81.Get() - tmp83 := lang.Apply(tmp79, []any{tmp82, v40}) - tmp84 := lang.Apply(tmp75, []any{tmp76, tmp83}) - tmp85 := lang.Apply(tmp72, []any{tmp84}) - _ = tmp85 - var tmp86 any - func() { - defer func() { - tmp87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp88 := tmp87.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) - if tmp88.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp88))) - } - tmp89 := tmp88.Get() - tmp90 := lang.Apply(tmp89, nil) - _ = tmp90 - }() - tmp91 := lang.Apply(strings8.TrimPrefix, []any{v40, "/"}) - tmp92, _ := lang.FieldOrMethod(runtime4.RT, "Load") - if reflect.TypeOf(tmp92).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Load is not a function"))) - } - tmp93 := lang.Apply(tmp92, []any{tmp91}) - tmp86 = tmp93 - }() - tmp69 = tmp86 - } // end let - tmp57 = tmp69 - } - tmp22 = tmp57 - } // end let - _ = tmp22 - var tmp23 any = v9 - var tmp24 any = v10 - var tmp25 any = v11 - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("unchecked-inc")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{v12}) - var tmp26 any = tmp30 - v9 = tmp23 - v10 = tmp24 - v11 = tmp25 - v12 = tmp26 - continue - } // end let - tmp13 = tmp18 - } else { - var tmp19 any - { // let - // let binding "temp__0__auto__" - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("seq")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.Apply(tmp22, []any{v9}) - var v24 any = tmp23 - _ = v24 - var tmp25 any - if lang.IsTruthy(v24) { - var tmp26 any - { // let - // let binding "seq_133" - var v27 any = v24 - _ = v27 - var tmp28 any - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("chunked-seq?")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.Apply(tmp31, []any{v27}) - if lang.IsTruthy(tmp32) { - var tmp33 any - { // let - // let binding "c__0__auto__" - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("chunk-first")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.Apply(tmp36, []any{v27}) - var v38 any = tmp37 - _ = v38 - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("chunk-rest")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.Apply(tmp42, []any{v27}) - var tmp39 any = tmp43 - var tmp44 any = v38 - tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp47 := tmp46.FindInternedVar(lang.NewSymbol("int")) - if tmp47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) - } - tmp48 := tmp47.Get() - tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp50 := tmp49.FindInternedVar(lang.NewSymbol("count")) - if tmp50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) - } - tmp51 := tmp50.Get() - tmp52 := lang.Apply(tmp51, []any{v38}) - tmp53 := lang.Apply(tmp48, []any{tmp52}) - var tmp45 any = tmp53 - tmp55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp56 := tmp55.FindInternedVar(lang.NewSymbol("int")) - if tmp56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp56))) - } - tmp57 := tmp56.Get() - tmp58 := lang.Apply(tmp57, []any{int64(0)}) - var tmp54 any = tmp58 - v9 = tmp39 - v10 = tmp44 - v11 = tmp45 - v12 = tmp54 - continue - } // end let - tmp28 = tmp33 - } else { - var tmp34 any - { // let - // let binding "path" - tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp36 := tmp35.FindInternedVar(lang.NewSymbol("first")) - if tmp36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) - } - tmp37 := tmp36.Get() - tmp38 := lang.Apply(tmp37, []any{v27}) - var v39 any = tmp38 - _ = v39 - var tmp40 any - { // let - // let binding "path" - var tmp41 any - tmp42 := lang.Apply(strings8.HasPrefix, []any{v39, "/"}) - if lang.IsTruthy(tmp42) { - tmp41 = v39 - } else { - tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp44 := tmp43.FindInternedVar(lang.NewSymbol("str")) - if tmp44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) - } - tmp45 := tmp44.Get() - tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp47 := tmp46.FindInternedVar(lang.NewSymbol("root-directory")) - if tmp47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) - } - tmp48 := tmp47.Get() - tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp50 := tmp49.FindInternedVar(lang.NewSymbol("ns-name")) - if tmp50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) - } - tmp51 := tmp50.Get() - tmp52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp53 := tmp52.FindInternedVar(lang.NewSymbol("*ns*")) - if tmp53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp53))) - } - tmp54 := tmp53.Get() - tmp55 := lang.Apply(tmp51, []any{tmp54}) - tmp56 := lang.Apply(tmp48, []any{tmp55}) - tmp57 := lang.Apply(tmp45, []any{tmp56, lang.NewChar(47), v39}) - tmp41 = tmp57 - } - var v58 any = tmp41 - _ = v58 - var tmp59 any - tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp61 := tmp60.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) - if tmp61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) - } - tmp62 := tmp61.Get() - if lang.IsTruthy(tmp62) { - tmp63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp64 := tmp63.FindInternedVar(lang.NewSymbol("printf")) - if tmp64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp64))) - } - tmp65 := tmp64.Get() - tmp66 := lang.Apply(tmp65, []any{"(glojure.core/load \"%s\")\n", v58}) - _ = tmp66 - tmp67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp68 := tmp67.FindInternedVar(lang.NewSymbol("flush")) - if tmp68.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp68))) - } - tmp69 := tmp68.Get() - tmp70 := lang.Apply(tmp69, nil) - tmp59 = tmp70 - } else { - } - _ = tmp59 - tmp71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp72 := tmp71.FindInternedVar(lang.NewSymbol("check-cyclic-dependency")) - if tmp72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp72))) - } - tmp73 := tmp72.Get() - tmp74 := lang.Apply(tmp73, []any{v58}) - _ = tmp74 - var tmp75 any - tmp76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp77 := tmp76.FindInternedVar(lang.NewSymbol("=")) - if tmp77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp77))) - } - tmp78 := tmp77.Get() - tmp79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp80 := tmp79.FindInternedVar(lang.NewSymbol("first")) - if tmp80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp80))) - } - tmp81 := tmp80.Get() - tmp82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp83 := tmp82.FindInternedVar(lang.NewSymbol("*pending-paths*")) - if tmp83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp83))) - } - tmp84 := tmp83.Get() - tmp85 := lang.Apply(tmp81, []any{tmp84}) - tmp86 := lang.Apply(tmp78, []any{v58, tmp85}) - if lang.IsTruthy(tmp86) { - } else { - var tmp87 any - { // let - tmp88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp89 := tmp88.FindInternedVar(lang.NewSymbol("push-thread-bindings")) - if tmp89.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp89))) - } - tmp90 := tmp89.Get() - tmp91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp92 := tmp91.FindInternedVar(lang.NewSymbol("hash-map")) - if tmp92.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp92))) - } - tmp93 := tmp92.Get() - tmp94 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*pending-paths*")) - tmp95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp96 := tmp95.FindInternedVar(lang.NewSymbol("conj")) - if tmp96.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp96))) - } - tmp97 := tmp96.Get() - tmp98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp99 := tmp98.FindInternedVar(lang.NewSymbol("*pending-paths*")) - if tmp99.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp99))) - } - tmp100 := tmp99.Get() - tmp101 := lang.Apply(tmp97, []any{tmp100, v58}) - tmp102 := lang.Apply(tmp93, []any{tmp94, tmp101}) - tmp103 := lang.Apply(tmp90, []any{tmp102}) - _ = tmp103 - var tmp104 any - func() { - defer func() { - tmp105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp106 := tmp105.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) - if tmp106.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp106))) - } - tmp107 := tmp106.Get() - tmp108 := lang.Apply(tmp107, nil) - _ = tmp108 - }() - tmp109 := lang.Apply(strings8.TrimPrefix, []any{v58, "/"}) - tmp110, _ := lang.FieldOrMethod(runtime4.RT, "Load") - if reflect.TypeOf(tmp110).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Load is not a function"))) - } - tmp111 := lang.Apply(tmp110, []any{tmp109}) - tmp104 = tmp111 - }() - tmp87 = tmp104 - } // end let - tmp75 = tmp87 - } - tmp40 = tmp75 - } // end let - _ = tmp40 - tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp43 := tmp42.FindInternedVar(lang.NewSymbol("next")) - if tmp43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) - } - tmp44 := tmp43.Get() - tmp45 := lang.Apply(tmp44, []any{v27}) - var tmp41 any = tmp45 - var tmp46 any = nil - var tmp47 any = int64(0) - var tmp48 any = int64(0) - v9 = tmp41 - v10 = tmp46 - v11 = tmp47 - v12 = tmp48 - continue - } // end let - tmp28 = tmp34 - } - tmp26 = tmp28 - } // end let - tmp25 = tmp26 - } else { - } - tmp19 = tmp25 - } // end let - tmp13 = tmp19 - } - tmp4 = tmp13 - break - } - } // end let - return tmp4 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // load-all - { - tmp0 := lang.NewSymbol("load-all").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"), lang.NewSymbol("need-ns"), lang.NewSymbol("require"))), lang.NewKeyword("doc"), "Loads a lib given its name and forces a load of any libs it directly or\n indirectly loads. If need-ns, ensures that the associated namespace\n exists after loading. If require, records the load so any duplicate loads\n can be skipped.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5892), lang.NewKeyword("end-line"), int(5892), lang.NewKeyword("private"), true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var tmp6 lang.FnFunc - tmp6 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("commute")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("*loaded-libs*")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - var tmp13 lang.FnFunc - tmp13 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v14 := args[0] - _ = v14 - v15 := args[1] - _ = v15 - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("conj")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp18, []any{tmp21, v14, v15}) - return tmp22 - }) - tmp14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5899), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(5899), lang.NewKeyword("end-column"), int(47)) - tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var tmp16 any - { // let - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("push-thread-bindings")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("hash-map")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*loaded-libs*")) - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("ref")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("sorted-set")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, nil) - tmp31 := lang.Apply(tmp26, []any{tmp30}) - tmp32 := lang.Apply(tmp22, []any{tmp23, tmp31}) - tmp33 := lang.Apply(tmp19, []any{tmp32}) - _ = tmp33 - var tmp34 any - func() { - defer func() { - tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp36 := tmp35.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) - if tmp36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) - } - tmp37 := tmp36.Get() - tmp38 := lang.Apply(tmp37, nil) - _ = tmp38 - }() - tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp40 := tmp39.FindInternedVar(lang.NewSymbol("load-one")) - if tmp40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) - } - tmp41 := tmp40.Get() - tmp42 := lang.Apply(tmp41, []any{v3, v4, v5}) - _ = tmp42 - tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp44 := tmp43.FindInternedVar(lang.NewSymbol("deref")) - if tmp44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) - } - tmp45 := tmp44.Get() - tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp47 := tmp46.FindInternedVar(lang.NewSymbol("*loaded-libs*")) - if tmp47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) - } - tmp48 := tmp47.Get() - tmp49 := lang.Apply(tmp45, []any{tmp48}) - tmp34 = tmp49 - }() - tmp16 = tmp34 - } // end let - tmp17 := lang.Apply(tmp9, []any{tmp12, tmp15, tmp16}) - return tmp17 - }) - tmp7, _ := lang.FieldOrMethod(lang.LockingTransaction, "RunInTransaction") - if reflect.TypeOf(tmp7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("RunInTransaction is not a function"))) - } - tmp8 := lang.Apply(tmp7, []any{tmp6}) - return tmp8 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // load-data-reader-file - { - tmp0 := lang.NewSymbol("load-data-reader-file").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7836), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7836), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("mappings"), lang.NewSymbol("url"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - { // let - // let binding "rdr" - tmp6, ok := lang.FieldOrMethod(v4, "openStream") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "openStream"))) - } - var tmp7 any - switch reflect.TypeOf(tmp6).Kind() { - case reflect.Func: - tmp7 = lang.Apply(tmp6, nil) - default: - tmp7 = tmp6 - } - tmp8 := lang.Apply(nil, []any{tmp7, "UTF-8"}) - tmp9 := lang.Apply(nil, []any{tmp8}) - var v10 any = tmp9 - _ = v10 - var tmp11 any - func() { - defer func() { - tmp12, ok := lang.FieldOrMethod(v10, "close") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v10, "close"))) - } - var tmp13 any - switch reflect.TypeOf(tmp12).Kind() { - case reflect.Func: - tmp13 = lang.Apply(tmp12, nil) - default: - tmp13 = tmp12 - } - _ = tmp13 - }() - var tmp14 any - { // let - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("push-thread-bindings")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("hash-map")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*file*")) - tmp22, ok := lang.FieldOrMethod(v4, "getFile") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "getFile"))) - } - var tmp23 any - switch reflect.TypeOf(tmp22).Kind() { - case reflect.Func: - tmp23 = lang.Apply(tmp22, nil) - default: - tmp23 = tmp22 - } - tmp24 := lang.Apply(tmp20, []any{tmp21, tmp23}) - tmp25 := lang.Apply(tmp17, []any{tmp24}) - _ = tmp25 - var tmp26 any - func() { - defer func() { - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, nil) - _ = tmp30 - }() - var tmp31 any - { // let - // let binding "read-opts" - var tmp32 any - tmp33, ok := lang.FieldOrMethod(v4, "getPath") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "getPath"))) - } - var tmp34 any - switch reflect.TypeOf(tmp33).Kind() { - case reflect.Func: - tmp34 = lang.Apply(tmp33, nil) - default: - tmp34 = tmp33 - } - tmp35, _ := lang.FieldOrMethod(tmp34, "endsWith") - if reflect.TypeOf(tmp35).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("endsWith is not a function"))) - } - tmp36 := lang.Apply(tmp35, []any{"cljc"}) - if lang.IsTruthy(tmp36) { - tmp37 := lang.NewMap(lang.NewKeyword("eof"), nil, lang.NewKeyword("read-cond"), lang.NewKeyword("allow")) - tmp38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7842), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7842), lang.NewKeyword("end-column"), int(52)) - tmp39, err := lang.WithMeta(tmp37, tmp38.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp32 = tmp39 - } else { - tmp40 := lang.NewMap(lang.NewKeyword("eof"), nil) - tmp41 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7843), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7843), lang.NewKeyword("end-column"), int(34)) - tmp42, err := lang.WithMeta(tmp40, tmp41.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp32 = tmp42 - } - var v43 any = tmp32 - _ = v43 - // let binding "new-mappings" - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("read")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.Apply(tmp46, []any{v43, v10}) - var v48 any = tmp47 - _ = v48 - var tmp49 any - tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp51 := tmp50.FindInternedVar(lang.NewSymbol("not")) - if tmp51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) - } - tmp52 := tmp51.Get() - tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp54 := tmp53.FindInternedVar(lang.NewSymbol("map?")) - if tmp54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) - } - tmp55 := tmp54.Get() - tmp56 := lang.Apply(tmp55, []any{v48}) - tmp57 := lang.Apply(tmp52, []any{tmp56}) - if lang.IsTruthy(tmp57) { - tmp58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp59 := tmp58.FindInternedVar(lang.NewSymbol("ex-info")) - if tmp59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp59))) - } - tmp60 := tmp59.Get() - tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp62 := tmp61.FindInternedVar(lang.NewSymbol("str")) - if tmp62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) - } - tmp63 := tmp62.Get() - tmp64 := lang.Apply(tmp63, []any{"Not a valid data-reader map"}) - tmp65 := lang.NewMap(lang.NewKeyword("url"), v4) - tmp66 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7847), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(7847), lang.NewKeyword("end-column"), int(36)) - tmp67, err := lang.WithMeta(tmp65, tmp66.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp68 := lang.Apply(tmp60, []any{tmp64, tmp67}) - panic(tmp68) - } else { - } - _ = tmp49 - tmp69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp70 := tmp69.FindInternedVar(lang.NewSymbol("reduce")) - if tmp70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp70))) - } - tmp71 := tmp70.Get() - var tmp72 lang.FnFunc - tmp72 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v73 := args[0] - _ = v73 - v74 := args[1] - _ = v74 - var tmp75 any - { // let - // let binding "vec__347" - var v76 any = v74 - _ = v76 - // let binding "k" - tmp77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp78 := tmp77.FindInternedVar(lang.NewSymbol("nth")) - if tmp78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp78))) - } - tmp79 := tmp78.Get() - tmp80 := lang.Apply(tmp79, []any{v76, int64(0), nil}) - var v81 any = tmp80 - _ = v81 - // let binding "v" - tmp82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp83 := tmp82.FindInternedVar(lang.NewSymbol("nth")) - if tmp83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp83))) - } - tmp84 := tmp83.Get() - tmp85 := lang.Apply(tmp84, []any{v76, int64(1), nil}) - var v86 any = tmp85 - _ = v86 - var tmp87 any - tmp88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp89 := tmp88.FindInternedVar(lang.NewSymbol("not")) - if tmp89.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp89))) - } - tmp90 := tmp89.Get() - tmp91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp92 := tmp91.FindInternedVar(lang.NewSymbol("symbol?")) - if tmp92.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp92))) - } - tmp93 := tmp92.Get() - tmp94 := lang.Apply(tmp93, []any{v81}) - tmp95 := lang.Apply(tmp90, []any{tmp94}) - if lang.IsTruthy(tmp95) { - tmp96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp97 := tmp96.FindInternedVar(lang.NewSymbol("ex-info")) - if tmp97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp97))) - } - tmp98 := tmp97.Get() - tmp99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp100 := tmp99.FindInternedVar(lang.NewSymbol("str")) - if tmp100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp100))) - } - tmp101 := tmp100.Get() - tmp102 := lang.Apply(tmp101, []any{"Invalid form in data-reader file"}) - tmp103 := lang.NewMap(lang.NewKeyword("url"), v4, lang.NewKeyword("form"), v81) - tmp104 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7852), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(7853), lang.NewKeyword("end-column"), int(38)) - tmp105, err := lang.WithMeta(tmp103, tmp104.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp106 := lang.Apply(tmp98, []any{tmp102, tmp105}) - panic(tmp106) - } else { - } - _ = tmp87 - var tmp107 any - { // let - // let binding "v-var" - tmp108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp109 := tmp108.FindInternedVar(lang.NewSymbol("data-reader-var")) - if tmp109.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp109))) - } - tmp110 := tmp109.Get() - tmp111 := lang.Apply(tmp110, []any{v86}) - var v112 any = tmp111 - _ = v112 - var tmp113 any - var tmp114 any - { // let - // let binding "and__0__auto__" - tmp115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp116 := tmp115.FindInternedVar(lang.NewSymbol("contains?")) - if tmp116.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp116))) - } - tmp117 := tmp116.Get() - tmp118 := lang.Apply(tmp117, []any{v3, v81}) - var v119 any = tmp118 - _ = v119 - var tmp120 any - if lang.IsTruthy(v119) { - tmp121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp122 := tmp121.FindInternedVar(lang.NewSymbol("not=")) - if tmp122.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp122))) - } - tmp123 := tmp122.Get() - tmp124 := lang.Apply(v3, []any{v81}) - tmp125 := lang.Apply(tmp123, []any{tmp124, v112}) - tmp120 = tmp125 - } else { - tmp120 = v119 - } - tmp114 = tmp120 - } // end let - if lang.IsTruthy(tmp114) { - tmp115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp116 := tmp115.FindInternedVar(lang.NewSymbol("ex-info")) - if tmp116.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp116))) - } - tmp117 := tmp116.Get() - tmp118 := lang.NewMap(lang.NewKeyword("url"), v4, lang.NewKeyword("conflict"), v81, lang.NewKeyword("mappings"), v73) - tmp119 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7858), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(7860), lang.NewKeyword("end-column"), int(44)) - tmp120, err := lang.WithMeta(tmp118, tmp119.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp121 := lang.Apply(tmp117, []any{"Conflicting data-reader mapping", tmp120}) - panic(tmp121) - } else { - } - _ = tmp113 - tmp122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp123 := tmp122.FindInternedVar(lang.NewSymbol("assoc")) - if tmp123.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp123))) - } - tmp124 := tmp123.Get() - tmp125 := lang.Apply(tmp124, []any{v73, v81, v112}) - tmp107 = tmp125 - } // end let - tmp75 = tmp107 - } // end let - return tmp75 - }) - tmp73 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7849), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(7861), lang.NewKeyword("end-column"), int(32)) - tmp74, err := lang.WithMeta(tmp72, tmp73.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp75 := lang.Apply(tmp71, []any{tmp74, v3, v48}) - tmp31 = tmp75 - } // end let - tmp26 = tmp31 - }() - tmp14 = tmp26 - } // end let - tmp11 = tmp14 - }() - tmp5 = tmp11 - } // end let - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // load-data-readers - { - tmp0 := lang.NewSymbol("load-data-readers").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7865), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7865), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - tmp3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp4 := tmp3.FindInternedVar(lang.NewSymbol("alter-var-root")) - if tmp4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp4))) - } - tmp5 := tmp4.Get() - tmp6 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*data-readers*")) - var tmp7 lang.FnFunc - tmp7 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v8 := args[0] - _ = v8 - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("reduce")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("load-data-reader-file")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("data-reader-urls")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, nil) - tmp19 := lang.Apply(tmp11, []any{tmp14, v8, tmp18}) - return tmp19 - }) - tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7867), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(7869), lang.NewKeyword("end-column"), int(57)) - tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp10 := lang.Apply(tmp5, []any{tmp6, tmp9}) - return tmp10 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // load-file - { - tmp0 := lang.NewSymbol("load-file").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, nil, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // load-lib - { - tmp0 := lang.NewSymbol("load-lib").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("prefix"), lang.NewSymbol("lib"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Loads a lib with options", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5904), lang.NewKeyword("end-line"), int(5904), lang.NewKeyword("private"), true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("throw-if")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - var tmp9 any - { // let - // let binding "and__0__auto__" - var v10 any = v3 - _ = v10 - var tmp11 any - if lang.IsTruthy(v10) { - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("pos?")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("name")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{v4}) - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("int")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, []any{lang.NewChar(46)}) - tmp23 := lang.Apply(strings8.Index, []any{tmp18, tmp22}) - tmp24 := lang.Apply(tmp14, []any{tmp23}) - tmp11 = tmp24 - } else { - tmp11 = v10 - } - tmp9 = tmp11 - } // end let - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("name")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{v4}) - tmp14 := lang.Apply(tmp8, []any{tmp9, "Found lib name '%s' containing period with prefix '%s'. lib names inside prefix lists must not contain periods", tmp13, v3}) - _ = tmp14 - var tmp15 any - { // let - // let binding "lib" - var tmp16 any - if lang.IsTruthy(v3) { - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("symbol")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("str")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.Apply(tmp22, []any{v3, lang.NewChar(46), v4}) - tmp24 := lang.Apply(tmp19, []any{tmp23}) - tmp16 = tmp24 - } else { - tmp16 = v4 - } - var v25 any = tmp16 - _ = v25 - // let binding "opts" - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("apply")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("hash-map")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.Apply(tmp28, []any{tmp31, v5}) - var v33 any = tmp32 - _ = v33 - // let binding "map__110" - var v34 any = v33 - _ = v34 - // let binding "map__110" - var tmp35 any - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("seq?")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{v34}) - if lang.IsTruthy(tmp39) { - var tmp40 any - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("next")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.Apply(tmp43, []any{v34}) - if lang.IsTruthy(tmp44) { - tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp46 := tmp45.FindInternedVar(lang.NewSymbol("to-array")) - if tmp46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) - } - tmp47 := tmp46.Get() - tmp48 := lang.Apply(tmp47, []any{v34}) - tmp49 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{tmp48}) - tmp40 = tmp49 - } else { - var tmp50 any - tmp51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp52 := tmp51.FindInternedVar(lang.NewSymbol("seq")) - if tmp52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp52))) - } - tmp53 := tmp52.Get() - tmp54 := lang.Apply(tmp53, []any{v34}) - if lang.IsTruthy(tmp54) { - tmp55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp56 := tmp55.FindInternedVar(lang.NewSymbol("first")) - if tmp56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp56))) - } - tmp57 := tmp56.Get() - tmp58 := lang.Apply(tmp57, []any{v34}) - tmp50 = tmp58 - } else { - } - tmp40 = tmp50 - } - tmp35 = tmp40 - } else { - tmp35 = v34 - } - var v59 any = tmp35 - _ = v59 - // let binding "as" - tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp61 := tmp60.FindInternedVar(lang.NewSymbol("get")) - if tmp61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) - } - tmp62 := tmp61.Get() - tmp63 := lang.Apply(tmp62, []any{v59, lang.NewKeyword("as")}) - var v64 any = tmp63 - _ = v64 - // let binding "reload" - tmp65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp66 := tmp65.FindInternedVar(lang.NewSymbol("get")) - if tmp66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp66))) - } - tmp67 := tmp66.Get() - tmp68 := lang.Apply(tmp67, []any{v59, lang.NewKeyword("reload")}) - var v69 any = tmp68 - _ = v69 - // let binding "reload-all" - tmp70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp71 := tmp70.FindInternedVar(lang.NewSymbol("get")) - if tmp71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp71))) - } - tmp72 := tmp71.Get() - tmp73 := lang.Apply(tmp72, []any{v59, lang.NewKeyword("reload-all")}) - var v74 any = tmp73 - _ = v74 - // let binding "require" - tmp75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp76 := tmp75.FindInternedVar(lang.NewSymbol("get")) - if tmp76.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp76))) - } - tmp77 := tmp76.Get() - tmp78 := lang.Apply(tmp77, []any{v59, lang.NewKeyword("require")}) - var v79 any = tmp78 - _ = v79 - // let binding "use" - tmp80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp81 := tmp80.FindInternedVar(lang.NewSymbol("get")) - if tmp81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp81))) - } - tmp82 := tmp81.Get() - tmp83 := lang.Apply(tmp82, []any{v59, lang.NewKeyword("use")}) - var v84 any = tmp83 - _ = v84 - // let binding "verbose" - tmp85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp86 := tmp85.FindInternedVar(lang.NewSymbol("get")) - if tmp86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp86))) - } - tmp87 := tmp86.Get() - tmp88 := lang.Apply(tmp87, []any{v59, lang.NewKeyword("verbose")}) - var v89 any = tmp88 - _ = v89 - // let binding "as-alias" - tmp90 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp91 := tmp90.FindInternedVar(lang.NewSymbol("get")) - if tmp91.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp91))) - } - tmp92 := tmp91.Get() - tmp93 := lang.Apply(tmp92, []any{v59, lang.NewKeyword("as-alias")}) - var v94 any = tmp93 - _ = v94 - // let binding "loaded" - tmp95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp96 := tmp95.FindInternedVar(lang.NewSymbol("contains?")) - if tmp96.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp96))) - } - tmp97 := tmp96.Get() - tmp98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp99 := tmp98.FindInternedVar(lang.NewSymbol("deref")) - if tmp99.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp99))) - } - tmp100 := tmp99.Get() - tmp101 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp102 := tmp101.FindInternedVar(lang.NewSymbol("*loaded-libs*")) - if tmp102.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp102))) - } - tmp103 := tmp102.Get() - tmp104 := lang.Apply(tmp100, []any{tmp103}) - tmp105 := lang.Apply(tmp97, []any{tmp104, v25}) - var v106 any = tmp105 - _ = v106 - // let binding "need-ns" - var tmp107 any - { // let - // let binding "or__0__auto__" - var v108 any = v64 - _ = v108 - var tmp109 any - if lang.IsTruthy(v108) { - tmp109 = v108 - } else { - tmp109 = v84 - } - tmp107 = tmp109 - } // end let - var v108 any = tmp107 - _ = v108 - // let binding "load" - var tmp109 any - if lang.IsTruthy(v74) { - tmp110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp111 := tmp110.FindInternedVar(lang.NewSymbol("load-all")) - if tmp111.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp111))) - } - tmp112 := tmp111.Get() - tmp109 = tmp112 - } else { - var tmp113 any - if lang.IsTruthy(v69) { - tmp114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp115 := tmp114.FindInternedVar(lang.NewSymbol("load-one")) - if tmp115.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp115))) - } - tmp116 := tmp115.Get() - tmp113 = tmp116 - } else { - var tmp117 any - tmp118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp119 := tmp118.FindInternedVar(lang.NewSymbol("not")) - if tmp119.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp119))) - } - tmp120 := tmp119.Get() - tmp121 := lang.Apply(tmp120, []any{v106}) - if lang.IsTruthy(tmp121) { - var tmp122 any - if lang.IsTruthy(v108) { - tmp123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp124 := tmp123.FindInternedVar(lang.NewSymbol("load-one")) - if tmp124.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp124))) - } - tmp125 := tmp124.Get() - tmp122 = tmp125 - } else { - var tmp126 any - if lang.IsTruthy(v94) { - var tmp127 lang.FnFunc - tmp127 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v128 := args[0] - _ = v128 - v129 := args[1] - _ = v129 - v130 := args[2] - _ = v130 - tmp131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp132 := tmp131.FindInternedVar(lang.NewSymbol("create-ns")) - if tmp132.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp132))) - } - tmp133 := tmp132.Get() - tmp134 := lang.Apply(tmp133, []any{v128}) - return tmp134 - }) - tmp128 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5918), lang.NewKeyword("column"), int(48), lang.NewKeyword("end-line"), int(5918), lang.NewKeyword("end-column"), int(88)) - tmp129, err := lang.WithMeta(tmp127, tmp128.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp126 = tmp129 - } else { - var tmp130 any - if lang.IsTruthy(lang.NewKeyword("else")) { - tmp131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp132 := tmp131.FindInternedVar(lang.NewSymbol("load-one")) - if tmp132.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp132))) - } - tmp133 := tmp132.Get() - tmp130 = tmp133 - } else { - } - tmp126 = tmp130 - } - tmp122 = tmp126 - } - tmp117 = tmp122 - } else { - } - tmp113 = tmp117 - } - tmp109 = tmp113 - } - var v134 any = tmp109 - _ = v134 - // let binding "filter-opts" - tmp135 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp136 := tmp135.FindInternedVar(lang.NewSymbol("select-keys")) - if tmp136.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp136))) - } - tmp137 := tmp136.Get() - tmp138 := lang.Apply(tmp137, []any{v33, lang.NewList(lang.NewKeyword("exclude"), lang.NewKeyword("only"), lang.NewKeyword("rename"), lang.NewKeyword("refer"))}) - var v139 any = tmp138 - _ = v139 - // let binding "undefined-on-entry" - tmp140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp141 := tmp140.FindInternedVar(lang.NewSymbol("not")) - if tmp141.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp141))) - } - tmp142 := tmp141.Get() - tmp143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp144 := tmp143.FindInternedVar(lang.NewSymbol("find-ns")) - if tmp144.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp144))) - } - tmp145 := tmp144.Get() - tmp146 := lang.Apply(tmp145, []any{v25}) - tmp147 := lang.Apply(tmp142, []any{tmp146}) - var v148 any = tmp147 - _ = v148 - var tmp149 any - { // let - tmp150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp151 := tmp150.FindInternedVar(lang.NewSymbol("push-thread-bindings")) - if tmp151.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp151))) - } - tmp152 := tmp151.Get() - tmp153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp154 := tmp153.FindInternedVar(lang.NewSymbol("hash-map")) - if tmp154.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp154))) - } - tmp155 := tmp154.Get() - tmp156 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*loading-verbosely*")) - var tmp157 any - { // let - // let binding "or__0__auto__" - tmp158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp159 := tmp158.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) - if tmp159.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp159))) - } - tmp160 := tmp159.Get() - var v161 any = tmp160 - _ = v161 - var tmp162 any - if lang.IsTruthy(v161) { - tmp162 = v161 - } else { - tmp162 = v89 - } - tmp157 = tmp162 - } // end let - tmp158 := lang.Apply(tmp155, []any{tmp156, tmp157}) - tmp159 := lang.Apply(tmp152, []any{tmp158}) - _ = tmp159 - var tmp160 any - func() { - defer func() { - tmp161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp162 := tmp161.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) - if tmp162.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp162))) - } - tmp163 := tmp162.Get() - tmp164 := lang.Apply(tmp163, nil) - _ = tmp164 - }() - var tmp165 any - if lang.IsTruthy(v134) { - var tmp166 any - func() { - defer func() { - if r := recover(); r != nil { - if lang.CatchMatches(r, lang.Builtins["any"]) { - v167 := r - _ = v167 - var tmp168 any - if lang.IsTruthy(v148) { - tmp169 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp170 := tmp169.FindInternedVar(lang.NewSymbol("remove-ns")) - if tmp170.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp170))) - } - tmp171 := tmp170.Get() - tmp172 := lang.Apply(tmp171, []any{v25}) - tmp168 = tmp172 - } else { - } - _ = tmp168 - panic(v167) - } else { - panic(r) - } - } - }() - tmp167 := lang.Apply(v134, []any{v25, v108, v79}) - tmp166 = tmp167 - }() - tmp165 = tmp166 - } else { - tmp168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp169 := tmp168.FindInternedVar(lang.NewSymbol("throw-if")) - if tmp169.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp169))) - } - tmp170 := tmp169.Get() - var tmp171 any - { // let - // let binding "and__0__auto__" - var v172 any = v108 - _ = v172 - var tmp173 any - if lang.IsTruthy(v172) { - tmp174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp175 := tmp174.FindInternedVar(lang.NewSymbol("not")) - if tmp175.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp175))) - } - tmp176 := tmp175.Get() - tmp177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp178 := tmp177.FindInternedVar(lang.NewSymbol("find-ns")) - if tmp178.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp178))) - } - tmp179 := tmp178.Get() - tmp180 := lang.Apply(tmp179, []any{v25}) - tmp181 := lang.Apply(tmp176, []any{tmp180}) - tmp173 = tmp181 - } else { - tmp173 = v172 - } - tmp171 = tmp173 - } // end let - tmp172 := lang.Apply(tmp170, []any{tmp171, "namespace '%s' not found", v25}) - tmp165 = tmp172 - } - _ = tmp165 - var tmp173 any - var tmp174 any - { // let - // let binding "and__0__auto__" - var v175 any = v108 - _ = v175 - var tmp176 any - if lang.IsTruthy(v175) { - tmp177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp178 := tmp177.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) - if tmp178.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp178))) - } - tmp179 := tmp178.Get() - tmp176 = tmp179 - } else { - tmp176 = v175 - } - tmp174 = tmp176 - } // end let - if lang.IsTruthy(tmp174) { - tmp175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp176 := tmp175.FindInternedVar(lang.NewSymbol("printf")) - if tmp176.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp176))) - } - tmp177 := tmp176.Get() - tmp178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp179 := tmp178.FindInternedVar(lang.NewSymbol("ns-name")) - if tmp179.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp179))) - } - tmp180 := tmp179.Get() - tmp181 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp182 := tmp181.FindInternedVar(lang.NewSymbol("*ns*")) - if tmp182.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp182))) - } - tmp183 := tmp182.Get() - tmp184 := lang.Apply(tmp180, []any{tmp183}) - tmp185 := lang.Apply(tmp177, []any{"(glojure.core/in-ns '%s)\n", tmp184}) - tmp173 = tmp185 - } else { - } - _ = tmp173 - var tmp186 any - if lang.IsTruthy(v64) { - var tmp187 any - tmp188 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp189 := tmp188.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) - if tmp189.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp189))) - } - tmp190 := tmp189.Get() - if lang.IsTruthy(tmp190) { - tmp191 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp192 := tmp191.FindInternedVar(lang.NewSymbol("printf")) - if tmp192.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp192))) - } - tmp193 := tmp192.Get() - tmp194 := lang.Apply(tmp193, []any{"(glojure.core/alias '%s '%s)\n", v64, v25}) - tmp187 = tmp194 - } else { - } - _ = tmp187 - tmp195 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp196 := tmp195.FindInternedVar(lang.NewSymbol("alias")) - if tmp196.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp196))) - } - tmp197 := tmp196.Get() - tmp198 := lang.Apply(tmp197, []any{v64, v25}) - tmp186 = tmp198 - } else { - } - _ = tmp186 - var tmp199 any - if lang.IsTruthy(v94) { - var tmp200 any - tmp201 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp202 := tmp201.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) - if tmp202.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp202))) - } - tmp203 := tmp202.Get() - if lang.IsTruthy(tmp203) { - tmp204 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp205 := tmp204.FindInternedVar(lang.NewSymbol("printf")) - if tmp205.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp205))) - } - tmp206 := tmp205.Get() - tmp207 := lang.Apply(tmp206, []any{"(glojure.core/alias '%s '%s)\n", v94, v25}) - tmp200 = tmp207 - } else { - } - _ = tmp200 - tmp208 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp209 := tmp208.FindInternedVar(lang.NewSymbol("alias")) - if tmp209.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp209))) - } - tmp210 := tmp209.Get() - tmp211 := lang.Apply(tmp210, []any{v94, v25}) - tmp199 = tmp211 - } else { - } - _ = tmp199 - var tmp212 any - var tmp213 any - { // let - // let binding "or__0__auto__" - var v214 any = v84 - _ = v214 - var tmp215 any - if lang.IsTruthy(v214) { - tmp215 = v214 - } else { - tmp216 := lang.Apply(lang.NewKeyword("refer"), []any{v139}) - tmp215 = tmp216 - } - tmp213 = tmp215 - } // end let - if lang.IsTruthy(tmp213) { - var tmp214 any - tmp215 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp216 := tmp215.FindInternedVar(lang.NewSymbol("*loading-verbosely*")) - if tmp216.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp216))) - } - tmp217 := tmp216.Get() - if lang.IsTruthy(tmp217) { - tmp218 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp219 := tmp218.FindInternedVar(lang.NewSymbol("printf")) - if tmp219.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp219))) - } - tmp220 := tmp219.Get() - tmp221 := lang.Apply(tmp220, []any{"(glojure.core/refer '%s", v25}) - _ = tmp221 - var tmp222 any - { // let - // let binding "seq_111" - tmp223 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp224 := tmp223.FindInternedVar(lang.NewSymbol("seq")) - if tmp224.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp224))) - } - tmp225 := tmp224.Get() - tmp226 := lang.Apply(tmp225, []any{v139}) - var v227 any = tmp226 - _ = v227 - // let binding "chunk_112" - var v228 any = nil - _ = v228 - // let binding "count_113" - var v229 any = int64(0) - _ = v229 - // let binding "i_114" - var v230 any = int64(0) - _ = v230 - for { - var tmp231 any - tmp232 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp233 := tmp232.FindInternedVar(lang.NewSymbol("<")) - if tmp233.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp233))) - } - tmp234 := tmp233.Get() - tmp235 := lang.Apply(tmp234, []any{v230, v229}) - if lang.IsTruthy(tmp235) { - var tmp236 any - { // let - // let binding "opt" - tmp237, _ := lang.FieldOrMethod(v228, "nth") - if reflect.TypeOf(tmp237).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) - } - tmp238 := lang.Apply(tmp237, []any{v230}) - var v239 any = tmp238 - _ = v239 - tmp240 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp241 := tmp240.FindInternedVar(lang.NewSymbol("printf")) - if tmp241.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp241))) - } - tmp242 := tmp241.Get() - tmp243 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp244 := tmp243.FindInternedVar(lang.NewSymbol("key")) - if tmp244.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp244))) - } - tmp245 := tmp244.Get() - tmp246 := lang.Apply(tmp245, []any{v239}) - tmp247 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp248 := tmp247.FindInternedVar(lang.NewSymbol("print-str")) - if tmp248.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp248))) - } - tmp249 := tmp248.Get() - tmp250 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp251 := tmp250.FindInternedVar(lang.NewSymbol("val")) - if tmp251.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp251))) - } - tmp252 := tmp251.Get() - tmp253 := lang.Apply(tmp252, []any{v239}) - tmp254 := lang.Apply(tmp249, []any{tmp253}) - tmp255 := lang.Apply(tmp242, []any{" %s '%s", tmp246, tmp254}) - _ = tmp255 - var tmp256 any = v227 - var tmp257 any = v228 - var tmp258 any = v229 - tmp260 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp261 := tmp260.FindInternedVar(lang.NewSymbol("unchecked-inc")) - if tmp261.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp261))) - } - tmp262 := tmp261.Get() - tmp263 := lang.Apply(tmp262, []any{v230}) - var tmp259 any = tmp263 - v227 = tmp256 - v228 = tmp257 - v229 = tmp258 - v230 = tmp259 - continue - } // end let - tmp231 = tmp236 - } else { - var tmp237 any - { // let - // let binding "temp__0__auto__" - tmp238 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp239 := tmp238.FindInternedVar(lang.NewSymbol("seq")) - if tmp239.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp239))) - } - tmp240 := tmp239.Get() - tmp241 := lang.Apply(tmp240, []any{v227}) - var v242 any = tmp241 - _ = v242 - var tmp243 any - if lang.IsTruthy(v242) { - var tmp244 any - { // let - // let binding "seq_111" - var v245 any = v242 - _ = v245 - var tmp246 any - tmp247 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp248 := tmp247.FindInternedVar(lang.NewSymbol("chunked-seq?")) - if tmp248.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp248))) - } - tmp249 := tmp248.Get() - tmp250 := lang.Apply(tmp249, []any{v245}) - if lang.IsTruthy(tmp250) { - var tmp251 any - { // let - // let binding "c__0__auto__" - tmp252 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp253 := tmp252.FindInternedVar(lang.NewSymbol("chunk-first")) - if tmp253.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp253))) - } - tmp254 := tmp253.Get() - tmp255 := lang.Apply(tmp254, []any{v245}) - var v256 any = tmp255 - _ = v256 - tmp258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp259 := tmp258.FindInternedVar(lang.NewSymbol("chunk-rest")) - if tmp259.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp259))) - } - tmp260 := tmp259.Get() - tmp261 := lang.Apply(tmp260, []any{v245}) - var tmp257 any = tmp261 - var tmp262 any = v256 - tmp264 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp265 := tmp264.FindInternedVar(lang.NewSymbol("int")) - if tmp265.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp265))) - } - tmp266 := tmp265.Get() - tmp267 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp268 := tmp267.FindInternedVar(lang.NewSymbol("count")) - if tmp268.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp268))) - } - tmp269 := tmp268.Get() - tmp270 := lang.Apply(tmp269, []any{v256}) - tmp271 := lang.Apply(tmp266, []any{tmp270}) - var tmp263 any = tmp271 - tmp273 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp274 := tmp273.FindInternedVar(lang.NewSymbol("int")) - if tmp274.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp274))) - } - tmp275 := tmp274.Get() - tmp276 := lang.Apply(tmp275, []any{int64(0)}) - var tmp272 any = tmp276 - v227 = tmp257 - v228 = tmp262 - v229 = tmp263 - v230 = tmp272 - continue - } // end let - tmp246 = tmp251 - } else { - var tmp252 any - { // let - // let binding "opt" - tmp253 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp254 := tmp253.FindInternedVar(lang.NewSymbol("first")) - if tmp254.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp254))) - } - tmp255 := tmp254.Get() - tmp256 := lang.Apply(tmp255, []any{v245}) - var v257 any = tmp256 - _ = v257 - tmp258 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp259 := tmp258.FindInternedVar(lang.NewSymbol("printf")) - if tmp259.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp259))) - } - tmp260 := tmp259.Get() - tmp261 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp262 := tmp261.FindInternedVar(lang.NewSymbol("key")) - if tmp262.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp262))) - } - tmp263 := tmp262.Get() - tmp264 := lang.Apply(tmp263, []any{v257}) - tmp265 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp266 := tmp265.FindInternedVar(lang.NewSymbol("print-str")) - if tmp266.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp266))) - } - tmp267 := tmp266.Get() - tmp268 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp269 := tmp268.FindInternedVar(lang.NewSymbol("val")) - if tmp269.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp269))) - } - tmp270 := tmp269.Get() - tmp271 := lang.Apply(tmp270, []any{v257}) - tmp272 := lang.Apply(tmp267, []any{tmp271}) - tmp273 := lang.Apply(tmp260, []any{" %s '%s", tmp264, tmp272}) - _ = tmp273 - tmp275 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp276 := tmp275.FindInternedVar(lang.NewSymbol("next")) - if tmp276.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp276))) - } - tmp277 := tmp276.Get() - tmp278 := lang.Apply(tmp277, []any{v245}) - var tmp274 any = tmp278 - var tmp279 any = nil - var tmp280 any = int64(0) - var tmp281 any = int64(0) - v227 = tmp274 - v228 = tmp279 - v229 = tmp280 - v230 = tmp281 - continue - } // end let - tmp246 = tmp252 - } - tmp244 = tmp246 - } // end let - tmp243 = tmp244 - } else { - } - tmp237 = tmp243 - } // end let - tmp231 = tmp237 - } - tmp222 = tmp231 - break - } - } // end let - _ = tmp222 - tmp223 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp224 := tmp223.FindInternedVar(lang.NewSymbol("printf")) - if tmp224.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp224))) - } - tmp225 := tmp224.Get() - tmp226 := lang.Apply(tmp225, []any{")\n"}) - tmp214 = tmp226 - } else { - } - _ = tmp214 - tmp227 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp228 := tmp227.FindInternedVar(lang.NewSymbol("apply")) - if tmp228.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp228))) - } - tmp229 := tmp228.Get() - tmp230 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp231 := tmp230.FindInternedVar(lang.NewSymbol("refer")) - if tmp231.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp231))) - } - tmp232 := tmp231.Get() - tmp233 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp234 := tmp233.FindInternedVar(lang.NewSymbol("mapcat")) - if tmp234.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp234))) - } - tmp235 := tmp234.Get() - tmp236 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp237 := tmp236.FindInternedVar(lang.NewSymbol("seq")) - if tmp237.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp237))) - } - tmp238 := tmp237.Get() - tmp239 := lang.Apply(tmp235, []any{tmp238, v139}) - tmp240 := lang.Apply(tmp229, []any{tmp232, v25, tmp239}) - tmp212 = tmp240 - } else { - } - tmp160 = tmp212 - }() - tmp149 = tmp160 - } // end let - tmp15 = tmp149 - } // end let - return tmp15 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // load-libs - { - tmp0 := lang.NewSymbol("load-libs").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Loads libs, interpreting libspecs, prefix lists, and flags for\n forwarding to load-lib", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5951), lang.NewKeyword("end-line"), int(5951), lang.NewKeyword("private"), true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var v3 any = lang.NewList(args[0:]...) - _ = v3 - var tmp4 any - { // let - // let binding "flags" - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("filter")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("keyword?")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp7, []any{tmp10, v3}) - var v12 any = tmp11 - _ = v12 - // let binding "opts" - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("interleave")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("repeat")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{true}) - tmp20 := lang.Apply(tmp15, []any{v12, tmp19}) - var v21 any = tmp20 - _ = v21 - // let binding "args" - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("filter")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("complement")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("keyword?")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.Apply(tmp27, []any{tmp30}) - tmp32 := lang.Apply(tmp24, []any{tmp31, v3}) - var v33 any = tmp32 - _ = v33 - var tmp34 any - { // let - // let binding "supported" - tmp35 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{lang.NewKeyword("as"), lang.NewKeyword("reload"), lang.NewKeyword("reload-all"), lang.NewKeyword("require"), lang.NewKeyword("use"), lang.NewKeyword("verbose"), lang.NewKeyword("refer"), lang.NewKeyword("as-alias")})) - tmp36 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5959), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(5959), lang.NewKeyword("end-column"), int(86)) - tmp37, err := lang.WithMeta(tmp35, tmp36.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v38 any = tmp37 - _ = v38 - // let binding "unsupported" - tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp40 := tmp39.FindInternedVar(lang.NewSymbol("seq")) - if tmp40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) - } - tmp41 := tmp40.Get() - tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp43 := tmp42.FindInternedVar(lang.NewSymbol("remove")) - if tmp43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) - } - tmp44 := tmp43.Get() - tmp45 := lang.Apply(tmp44, []any{v38, v12}) - tmp46 := lang.Apply(tmp41, []any{tmp45}) - var v47 any = tmp46 - _ = v47 - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("throw-if")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp52 := tmp51.FindInternedVar(lang.NewSymbol("apply")) - if tmp52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp52))) - } - tmp53 := tmp52.Get() - tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp55 := tmp54.FindInternedVar(lang.NewSymbol("str")) - if tmp55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) - } - tmp56 := tmp55.Get() - tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp58 := tmp57.FindInternedVar(lang.NewSymbol("interpose")) - if tmp58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) - } - tmp59 := tmp58.Get() - tmp60 := lang.Apply(tmp59, []any{lang.NewChar(44), v47}) - tmp61 := lang.Apply(tmp53, []any{tmp56, "Unsupported option(s) supplied: ", tmp60}) - tmp62 := lang.Apply(tmp50, []any{v47, tmp61}) - tmp34 = tmp62 - } // end let - _ = tmp34 - tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp36 := tmp35.FindInternedVar(lang.NewSymbol("throw-if")) - if tmp36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) - } - tmp37 := tmp36.Get() - tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp39 := tmp38.FindInternedVar(lang.NewSymbol("not")) - if tmp39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) - } - tmp40 := tmp39.Get() - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("seq")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.Apply(tmp43, []any{v33}) - tmp45 := lang.Apply(tmp40, []any{tmp44}) - tmp46 := lang.Apply(tmp37, []any{tmp45, "Nothing specified to load"}) - _ = tmp46 - var tmp47 any - { // let - // let binding "seq_115" - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("seq")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v33}) - var v52 any = tmp51 - _ = v52 - // let binding "chunk_116" - var v53 any = nil - _ = v53 - // let binding "count_117" - var v54 any = int64(0) - _ = v54 - // let binding "i_118" - var v55 any = int64(0) - _ = v55 - for { - var tmp56 any - tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp58 := tmp57.FindInternedVar(lang.NewSymbol("<")) - if tmp58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) - } - tmp59 := tmp58.Get() - tmp60 := lang.Apply(tmp59, []any{v55, v54}) - if lang.IsTruthy(tmp60) { - var tmp61 any - { // let - // let binding "arg" - tmp62, _ := lang.FieldOrMethod(v53, "nth") - if reflect.TypeOf(tmp62).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) - } - tmp63 := lang.Apply(tmp62, []any{v55}) - var v64 any = tmp63 - _ = v64 - var tmp65 any - tmp66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp67 := tmp66.FindInternedVar(lang.NewSymbol("libspec?")) - if tmp67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp67))) - } - tmp68 := tmp67.Get() - tmp69 := lang.Apply(tmp68, []any{v64}) - if lang.IsTruthy(tmp69) { - tmp70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp71 := tmp70.FindInternedVar(lang.NewSymbol("apply")) - if tmp71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp71))) - } - tmp72 := tmp71.Get() - tmp73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp74 := tmp73.FindInternedVar(lang.NewSymbol("load-lib")) - if tmp74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp74))) - } - tmp75 := tmp74.Get() - tmp76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp77 := tmp76.FindInternedVar(lang.NewSymbol("prependss")) - if tmp77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp77))) - } - tmp78 := tmp77.Get() - tmp79 := lang.Apply(tmp78, []any{v64, v21}) - tmp80 := lang.Apply(tmp72, []any{tmp75, nil, tmp79}) - tmp65 = tmp80 - } else { - var tmp81 any - { // let - // let binding "vec__119" - var v82 any = v64 - _ = v82 - // let binding "seq__120" - tmp83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp84 := tmp83.FindInternedVar(lang.NewSymbol("seq")) - if tmp84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp84))) - } - tmp85 := tmp84.Get() - tmp86 := lang.Apply(tmp85, []any{v82}) - var v87 any = tmp86 - _ = v87 - // let binding "first__121" - tmp88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp89 := tmp88.FindInternedVar(lang.NewSymbol("first")) - if tmp89.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp89))) - } - tmp90 := tmp89.Get() - tmp91 := lang.Apply(tmp90, []any{v87}) - var v92 any = tmp91 - _ = v92 - // let binding "seq__120" - tmp93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp94 := tmp93.FindInternedVar(lang.NewSymbol("next")) - if tmp94.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp94))) - } - tmp95 := tmp94.Get() - tmp96 := lang.Apply(tmp95, []any{v87}) - var v97 any = tmp96 - _ = v97 - // let binding "prefix" - var v98 any = v92 - _ = v98 - // let binding "args" - var v99 any = v97 - _ = v99 - tmp100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp101 := tmp100.FindInternedVar(lang.NewSymbol("throw-if")) - if tmp101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp101))) - } - tmp102 := tmp101.Get() - tmp103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp104 := tmp103.FindInternedVar(lang.NewSymbol("nil?")) - if tmp104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp104))) - } - tmp105 := tmp104.Get() - tmp106 := lang.Apply(tmp105, []any{v98}) - tmp107 := lang.Apply(tmp102, []any{tmp106, "prefix cannot be nil"}) - _ = tmp107 - var tmp108 any - { // let - // let binding "seq_122" - tmp109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp110 := tmp109.FindInternedVar(lang.NewSymbol("seq")) - if tmp110.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp110))) - } - tmp111 := tmp110.Get() - tmp112 := lang.Apply(tmp111, []any{v99}) - var v113 any = tmp112 - _ = v113 - // let binding "chunk_123" - var v114 any = nil - _ = v114 - // let binding "count_124" - var v115 any = int64(0) - _ = v115 - // let binding "i_125" - var v116 any = int64(0) - _ = v116 - for { - var tmp117 any - tmp118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp119 := tmp118.FindInternedVar(lang.NewSymbol("<")) - if tmp119.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp119))) - } - tmp120 := tmp119.Get() - tmp121 := lang.Apply(tmp120, []any{v116, v115}) - if lang.IsTruthy(tmp121) { - var tmp122 any - { // let - // let binding "arg" - tmp123, _ := lang.FieldOrMethod(v114, "nth") - if reflect.TypeOf(tmp123).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) - } - tmp124 := lang.Apply(tmp123, []any{v116}) - var v125 any = tmp124 - _ = v125 - tmp126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp127 := tmp126.FindInternedVar(lang.NewSymbol("apply")) - if tmp127.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp127))) - } - tmp128 := tmp127.Get() - tmp129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp130 := tmp129.FindInternedVar(lang.NewSymbol("load-lib")) - if tmp130.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp130))) - } - tmp131 := tmp130.Get() - tmp132 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp133 := tmp132.FindInternedVar(lang.NewSymbol("prependss")) - if tmp133.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp133))) - } - tmp134 := tmp133.Get() - tmp135 := lang.Apply(tmp134, []any{v125, v21}) - tmp136 := lang.Apply(tmp128, []any{tmp131, v98, tmp135}) - _ = tmp136 - var tmp137 any = v113 - var tmp138 any = v114 - var tmp139 any = v115 - tmp141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp142 := tmp141.FindInternedVar(lang.NewSymbol("unchecked-inc")) - if tmp142.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp142))) - } - tmp143 := tmp142.Get() - tmp144 := lang.Apply(tmp143, []any{v116}) - var tmp140 any = tmp144 - v113 = tmp137 - v114 = tmp138 - v115 = tmp139 - v116 = tmp140 - continue - } // end let - tmp117 = tmp122 - } else { - var tmp123 any - { // let - // let binding "temp__0__auto__" - tmp124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp125 := tmp124.FindInternedVar(lang.NewSymbol("seq")) - if tmp125.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp125))) - } - tmp126 := tmp125.Get() - tmp127 := lang.Apply(tmp126, []any{v113}) - var v128 any = tmp127 - _ = v128 - var tmp129 any - if lang.IsTruthy(v128) { - var tmp130 any - { // let - // let binding "seq_122" - var v131 any = v128 - _ = v131 - var tmp132 any - tmp133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp134 := tmp133.FindInternedVar(lang.NewSymbol("chunked-seq?")) - if tmp134.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp134))) - } - tmp135 := tmp134.Get() - tmp136 := lang.Apply(tmp135, []any{v131}) - if lang.IsTruthy(tmp136) { - var tmp137 any - { // let - // let binding "c__0__auto__" - tmp138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp139 := tmp138.FindInternedVar(lang.NewSymbol("chunk-first")) - if tmp139.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp139))) - } - tmp140 := tmp139.Get() - tmp141 := lang.Apply(tmp140, []any{v131}) - var v142 any = tmp141 - _ = v142 - tmp144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp145 := tmp144.FindInternedVar(lang.NewSymbol("chunk-rest")) - if tmp145.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp145))) - } - tmp146 := tmp145.Get() - tmp147 := lang.Apply(tmp146, []any{v131}) - var tmp143 any = tmp147 - var tmp148 any = v142 - tmp150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp151 := tmp150.FindInternedVar(lang.NewSymbol("int")) - if tmp151.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp151))) - } - tmp152 := tmp151.Get() - tmp153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp154 := tmp153.FindInternedVar(lang.NewSymbol("count")) - if tmp154.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp154))) - } - tmp155 := tmp154.Get() - tmp156 := lang.Apply(tmp155, []any{v142}) - tmp157 := lang.Apply(tmp152, []any{tmp156}) - var tmp149 any = tmp157 - tmp159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp160 := tmp159.FindInternedVar(lang.NewSymbol("int")) - if tmp160.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp160))) - } - tmp161 := tmp160.Get() - tmp162 := lang.Apply(tmp161, []any{int64(0)}) - var tmp158 any = tmp162 - v113 = tmp143 - v114 = tmp148 - v115 = tmp149 - v116 = tmp158 - continue - } // end let - tmp132 = tmp137 - } else { - var tmp138 any - { // let - // let binding "arg" - tmp139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp140 := tmp139.FindInternedVar(lang.NewSymbol("first")) - if tmp140.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp140))) - } - tmp141 := tmp140.Get() - tmp142 := lang.Apply(tmp141, []any{v131}) - var v143 any = tmp142 - _ = v143 - tmp144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp145 := tmp144.FindInternedVar(lang.NewSymbol("apply")) - if tmp145.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp145))) - } - tmp146 := tmp145.Get() - tmp147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp148 := tmp147.FindInternedVar(lang.NewSymbol("load-lib")) - if tmp148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp148))) - } - tmp149 := tmp148.Get() - tmp150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp151 := tmp150.FindInternedVar(lang.NewSymbol("prependss")) - if tmp151.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp151))) - } - tmp152 := tmp151.Get() - tmp153 := lang.Apply(tmp152, []any{v143, v21}) - tmp154 := lang.Apply(tmp146, []any{tmp149, v98, tmp153}) - _ = tmp154 - tmp156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp157 := tmp156.FindInternedVar(lang.NewSymbol("next")) - if tmp157.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp157))) - } - tmp158 := tmp157.Get() - tmp159 := lang.Apply(tmp158, []any{v131}) - var tmp155 any = tmp159 - var tmp160 any = nil - var tmp161 any = int64(0) - var tmp162 any = int64(0) - v113 = tmp155 - v114 = tmp160 - v115 = tmp161 - v116 = tmp162 - continue - } // end let - tmp132 = tmp138 - } - tmp130 = tmp132 - } // end let - tmp129 = tmp130 - } else { - } - tmp123 = tmp129 - } // end let - tmp117 = tmp123 - } - tmp108 = tmp117 - break - } - } // end let - tmp81 = tmp108 - } // end let - tmp65 = tmp81 - } - _ = tmp65 - var tmp82 any = v52 - var tmp83 any = v53 - var tmp84 any = v54 - tmp86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp87 := tmp86.FindInternedVar(lang.NewSymbol("unchecked-inc")) - if tmp87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp87))) - } - tmp88 := tmp87.Get() - tmp89 := lang.Apply(tmp88, []any{v55}) - var tmp85 any = tmp89 - v52 = tmp82 - v53 = tmp83 - v54 = tmp84 - v55 = tmp85 - continue - } // end let - tmp56 = tmp61 - } else { - var tmp62 any - { // let - // let binding "temp__0__auto__" - tmp63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp64 := tmp63.FindInternedVar(lang.NewSymbol("seq")) - if tmp64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp64))) - } - tmp65 := tmp64.Get() - tmp66 := lang.Apply(tmp65, []any{v52}) - var v67 any = tmp66 - _ = v67 - var tmp68 any - if lang.IsTruthy(v67) { - var tmp69 any - { // let - // let binding "seq_115" - var v70 any = v67 - _ = v70 - var tmp71 any - tmp72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp73 := tmp72.FindInternedVar(lang.NewSymbol("chunked-seq?")) - if tmp73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp73))) - } - tmp74 := tmp73.Get() - tmp75 := lang.Apply(tmp74, []any{v70}) - if lang.IsTruthy(tmp75) { - var tmp76 any - { // let - // let binding "c__0__auto__" - tmp77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp78 := tmp77.FindInternedVar(lang.NewSymbol("chunk-first")) - if tmp78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp78))) - } - tmp79 := tmp78.Get() - tmp80 := lang.Apply(tmp79, []any{v70}) - var v81 any = tmp80 - _ = v81 - tmp83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp84 := tmp83.FindInternedVar(lang.NewSymbol("chunk-rest")) - if tmp84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp84))) - } - tmp85 := tmp84.Get() - tmp86 := lang.Apply(tmp85, []any{v70}) - var tmp82 any = tmp86 - var tmp87 any = v81 - tmp89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp90 := tmp89.FindInternedVar(lang.NewSymbol("int")) - if tmp90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp90))) - } - tmp91 := tmp90.Get() - tmp92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp93 := tmp92.FindInternedVar(lang.NewSymbol("count")) - if tmp93.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp93))) - } - tmp94 := tmp93.Get() - tmp95 := lang.Apply(tmp94, []any{v81}) - tmp96 := lang.Apply(tmp91, []any{tmp95}) - var tmp88 any = tmp96 - tmp98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp99 := tmp98.FindInternedVar(lang.NewSymbol("int")) - if tmp99.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp99))) - } - tmp100 := tmp99.Get() - tmp101 := lang.Apply(tmp100, []any{int64(0)}) - var tmp97 any = tmp101 - v52 = tmp82 - v53 = tmp87 - v54 = tmp88 - v55 = tmp97 - continue - } // end let - tmp71 = tmp76 - } else { - var tmp77 any - { // let - // let binding "arg" - tmp78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp79 := tmp78.FindInternedVar(lang.NewSymbol("first")) - if tmp79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp79))) - } - tmp80 := tmp79.Get() - tmp81 := lang.Apply(tmp80, []any{v70}) - var v82 any = tmp81 - _ = v82 - var tmp83 any - tmp84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp85 := tmp84.FindInternedVar(lang.NewSymbol("libspec?")) - if tmp85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp85))) - } - tmp86 := tmp85.Get() - tmp87 := lang.Apply(tmp86, []any{v82}) - if lang.IsTruthy(tmp87) { - tmp88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp89 := tmp88.FindInternedVar(lang.NewSymbol("apply")) - if tmp89.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp89))) - } - tmp90 := tmp89.Get() - tmp91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp92 := tmp91.FindInternedVar(lang.NewSymbol("load-lib")) - if tmp92.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp92))) - } - tmp93 := tmp92.Get() - tmp94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp95 := tmp94.FindInternedVar(lang.NewSymbol("prependss")) - if tmp95.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp95))) - } - tmp96 := tmp95.Get() - tmp97 := lang.Apply(tmp96, []any{v82, v21}) - tmp98 := lang.Apply(tmp90, []any{tmp93, nil, tmp97}) - tmp83 = tmp98 - } else { - var tmp99 any - { // let - // let binding "vec__126" - var v100 any = v82 - _ = v100 - // let binding "seq__127" - tmp101 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp102 := tmp101.FindInternedVar(lang.NewSymbol("seq")) - if tmp102.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp102))) - } - tmp103 := tmp102.Get() - tmp104 := lang.Apply(tmp103, []any{v100}) - var v105 any = tmp104 - _ = v105 - // let binding "first__128" - tmp106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp107 := tmp106.FindInternedVar(lang.NewSymbol("first")) - if tmp107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp107))) - } - tmp108 := tmp107.Get() - tmp109 := lang.Apply(tmp108, []any{v105}) - var v110 any = tmp109 - _ = v110 - // let binding "seq__127" - tmp111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp112 := tmp111.FindInternedVar(lang.NewSymbol("next")) - if tmp112.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp112))) - } - tmp113 := tmp112.Get() - tmp114 := lang.Apply(tmp113, []any{v105}) - var v115 any = tmp114 - _ = v115 - // let binding "prefix" - var v116 any = v110 - _ = v116 - // let binding "args" - var v117 any = v115 - _ = v117 - tmp118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp119 := tmp118.FindInternedVar(lang.NewSymbol("throw-if")) - if tmp119.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp119))) - } - tmp120 := tmp119.Get() - tmp121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp122 := tmp121.FindInternedVar(lang.NewSymbol("nil?")) - if tmp122.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp122))) - } - tmp123 := tmp122.Get() - tmp124 := lang.Apply(tmp123, []any{v116}) - tmp125 := lang.Apply(tmp120, []any{tmp124, "prefix cannot be nil"}) - _ = tmp125 - var tmp126 any - { // let - // let binding "seq_129" - tmp127 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp128 := tmp127.FindInternedVar(lang.NewSymbol("seq")) - if tmp128.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp128))) - } - tmp129 := tmp128.Get() - tmp130 := lang.Apply(tmp129, []any{v117}) - var v131 any = tmp130 - _ = v131 - // let binding "chunk_130" - var v132 any = nil - _ = v132 - // let binding "count_131" - var v133 any = int64(0) - _ = v133 - // let binding "i_132" - var v134 any = int64(0) - _ = v134 - for { - var tmp135 any - tmp136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp137 := tmp136.FindInternedVar(lang.NewSymbol("<")) - if tmp137.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp137))) - } - tmp138 := tmp137.Get() - tmp139 := lang.Apply(tmp138, []any{v134, v133}) - if lang.IsTruthy(tmp139) { - var tmp140 any - { // let - // let binding "arg" - tmp141, _ := lang.FieldOrMethod(v132, "nth") - if reflect.TypeOf(tmp141).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) - } - tmp142 := lang.Apply(tmp141, []any{v134}) - var v143 any = tmp142 - _ = v143 - tmp144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp145 := tmp144.FindInternedVar(lang.NewSymbol("apply")) - if tmp145.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp145))) - } - tmp146 := tmp145.Get() - tmp147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp148 := tmp147.FindInternedVar(lang.NewSymbol("load-lib")) - if tmp148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp148))) - } - tmp149 := tmp148.Get() - tmp150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp151 := tmp150.FindInternedVar(lang.NewSymbol("prependss")) - if tmp151.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp151))) - } - tmp152 := tmp151.Get() - tmp153 := lang.Apply(tmp152, []any{v143, v21}) - tmp154 := lang.Apply(tmp146, []any{tmp149, v116, tmp153}) - _ = tmp154 - var tmp155 any = v131 - var tmp156 any = v132 - var tmp157 any = v133 - tmp159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp160 := tmp159.FindInternedVar(lang.NewSymbol("unchecked-inc")) - if tmp160.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp160))) - } - tmp161 := tmp160.Get() - tmp162 := lang.Apply(tmp161, []any{v134}) - var tmp158 any = tmp162 - v131 = tmp155 - v132 = tmp156 - v133 = tmp157 - v134 = tmp158 - continue - } // end let - tmp135 = tmp140 - } else { - var tmp141 any - { // let - // let binding "temp__0__auto__" - tmp142 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp143 := tmp142.FindInternedVar(lang.NewSymbol("seq")) - if tmp143.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp143))) - } - tmp144 := tmp143.Get() - tmp145 := lang.Apply(tmp144, []any{v131}) - var v146 any = tmp145 - _ = v146 - var tmp147 any - if lang.IsTruthy(v146) { - var tmp148 any - { // let - // let binding "seq_129" - var v149 any = v146 - _ = v149 - var tmp150 any - tmp151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp152 := tmp151.FindInternedVar(lang.NewSymbol("chunked-seq?")) - if tmp152.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp152))) - } - tmp153 := tmp152.Get() - tmp154 := lang.Apply(tmp153, []any{v149}) - if lang.IsTruthy(tmp154) { - var tmp155 any - { // let - // let binding "c__0__auto__" - tmp156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp157 := tmp156.FindInternedVar(lang.NewSymbol("chunk-first")) - if tmp157.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp157))) - } - tmp158 := tmp157.Get() - tmp159 := lang.Apply(tmp158, []any{v149}) - var v160 any = tmp159 - _ = v160 - tmp162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp163 := tmp162.FindInternedVar(lang.NewSymbol("chunk-rest")) - if tmp163.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp163))) - } - tmp164 := tmp163.Get() - tmp165 := lang.Apply(tmp164, []any{v149}) - var tmp161 any = tmp165 - var tmp166 any = v160 - tmp168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp169 := tmp168.FindInternedVar(lang.NewSymbol("int")) - if tmp169.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp169))) - } - tmp170 := tmp169.Get() - tmp171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp172 := tmp171.FindInternedVar(lang.NewSymbol("count")) - if tmp172.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp172))) - } - tmp173 := tmp172.Get() - tmp174 := lang.Apply(tmp173, []any{v160}) - tmp175 := lang.Apply(tmp170, []any{tmp174}) - var tmp167 any = tmp175 - tmp177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp178 := tmp177.FindInternedVar(lang.NewSymbol("int")) - if tmp178.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp178))) - } - tmp179 := tmp178.Get() - tmp180 := lang.Apply(tmp179, []any{int64(0)}) - var tmp176 any = tmp180 - v131 = tmp161 - v132 = tmp166 - v133 = tmp167 - v134 = tmp176 - continue - } // end let - tmp150 = tmp155 - } else { - var tmp156 any - { // let - // let binding "arg" - tmp157 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp158 := tmp157.FindInternedVar(lang.NewSymbol("first")) - if tmp158.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp158))) - } - tmp159 := tmp158.Get() - tmp160 := lang.Apply(tmp159, []any{v149}) - var v161 any = tmp160 - _ = v161 - tmp162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp163 := tmp162.FindInternedVar(lang.NewSymbol("apply")) - if tmp163.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp163))) - } - tmp164 := tmp163.Get() - tmp165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp166 := tmp165.FindInternedVar(lang.NewSymbol("load-lib")) - if tmp166.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp166))) - } - tmp167 := tmp166.Get() - tmp168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp169 := tmp168.FindInternedVar(lang.NewSymbol("prependss")) - if tmp169.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp169))) - } - tmp170 := tmp169.Get() - tmp171 := lang.Apply(tmp170, []any{v161, v21}) - tmp172 := lang.Apply(tmp164, []any{tmp167, v116, tmp171}) - _ = tmp172 - tmp174 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp175 := tmp174.FindInternedVar(lang.NewSymbol("next")) - if tmp175.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp175))) - } - tmp176 := tmp175.Get() - tmp177 := lang.Apply(tmp176, []any{v149}) - var tmp173 any = tmp177 - var tmp178 any = nil - var tmp179 any = int64(0) - var tmp180 any = int64(0) - v131 = tmp173 - v132 = tmp178 - v133 = tmp179 - v134 = tmp180 - continue - } // end let - tmp150 = tmp156 - } - tmp148 = tmp150 - } // end let - tmp147 = tmp148 - } else { - } - tmp141 = tmp147 - } // end let - tmp135 = tmp141 - } - tmp126 = tmp135 - break - } - } // end let - tmp99 = tmp126 - } // end let - tmp83 = tmp99 - } - _ = tmp83 - tmp101 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp102 := tmp101.FindInternedVar(lang.NewSymbol("next")) - if tmp102.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp102))) - } - tmp103 := tmp102.Get() - tmp104 := lang.Apply(tmp103, []any{v70}) - var tmp100 any = tmp104 - var tmp105 any = nil - var tmp106 any = int64(0) - var tmp107 any = int64(0) - v52 = tmp100 - v53 = tmp105 - v54 = tmp106 - v55 = tmp107 - continue - } // end let - tmp71 = tmp77 - } - tmp69 = tmp71 - } // end let - tmp68 = tmp69 - } else { - } - tmp62 = tmp68 - } // end let - tmp56 = tmp62 - } - tmp47 = tmp56 - break - } - } // end let - tmp4 = tmp47 - } // end let - return tmp4 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // load-one - { - tmp0 := lang.NewSymbol("load-one").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"), lang.NewSymbol("need-ns"), lang.NewSymbol("require"))), lang.NewKeyword("doc"), "Loads a lib given its name. If need-ns, ensures that the associated\n namespace exists after loading. If require, records the load so any\n duplicate loads can be skipped.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5879), lang.NewKeyword("end-line"), int(5879), lang.NewKeyword("private"), true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("load")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("root-resource")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.Apply(tmp11, []any{v3}) - tmp13 := lang.Apply(tmp8, []any{tmp12}) - _ = tmp13 - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("throw-if")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - var tmp17 any - { // let - // let binding "and__0__auto__" - var v18 any = v4 - _ = v18 - var tmp19 any - if lang.IsTruthy(v18) { - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("not")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("find-ns")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.Apply(tmp25, []any{v3}) - tmp27 := lang.Apply(tmp22, []any{tmp26}) - tmp19 = tmp27 - } else { - tmp19 = v18 - } - tmp17 = tmp19 - } // end let - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("root-resource")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.Apply(tmp20, []any{v3}) - tmp22 := lang.Apply(tmp16, []any{tmp17, "namespace '%s' not found after loading '%s'", v3, tmp21}) - _ = tmp22 - var tmp23 any - if lang.IsTruthy(v5) { - var tmp24 lang.FnFunc - tmp24 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("commute")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("*loaded-libs*")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("conj")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp27, []any{tmp30, tmp33, v3}) - return tmp34 - }) - tmp25, _ := lang.FieldOrMethod(lang.LockingTransaction, "RunInTransaction") - if reflect.TypeOf(tmp25).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("RunInTransaction is not a function"))) - } - tmp26 := lang.Apply(tmp25, []any{tmp24}) - tmp23 = tmp26 - } else { - } - return tmp23 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // load-reader - { - tmp0 := lang.NewSymbol("load-reader").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rdr"))), lang.NewKeyword("doc"), "Sequentially read and evaluate the set of forms contained in the\n stream/file", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4081), lang.NewKeyword("end-line"), int(4081))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4, _ := lang.FieldOrMethod(runtime4.Compiler, "load") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("load is not a function"))) - } - tmp5 := lang.Apply(tmp4, []any{v3}) - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // load-string - { - tmp0 := lang.NewSymbol("load-string").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Sequentially read and evaluate the set of forms contained in the\n string", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4088), lang.NewKeyword("end-line"), int(4088))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "rdr" - tmp5 := lang.Apply(nil, []any{v3}) - tmp6 := lang.Apply(nil, []any{tmp5}) - var v7 any = tmp6 - _ = v7 - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("load-reader")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v7}) - tmp4 = tmp11 - } // end let - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // loaded-libs - { - tmp0 := lang.NewSymbol("loaded-libs").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Returns a sorted set of symbols naming the currently loaded libs", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6090), lang.NewKeyword("end-line"), int(6090))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - tmp3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp4 := tmp3.FindInternedVar(lang.NewSymbol("deref")) - if tmp4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp4))) - } - tmp5 := tmp4.Get() - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("*loaded-libs*")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(tmp5, []any{tmp8}) - return tmp9 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // locking - { - tmp0 := lang.NewSymbol("locking").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Executes exprs in an implicit do, while holding the monitor of x.\n Will release the monitor of x in all circumstances.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1643), lang.NewKeyword("end-line"), int(1643))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("seq")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("concat")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("list")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("glojure.core/let")}) - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("list")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("apply")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("vector")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("seq")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("concat")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.Apply(tmp34, []any{lang.NewSymbol("lockee__0__auto__")}) - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{v5}) - tmp40 := lang.Apply(tmp31, []any{tmp35, tmp39}) - tmp41 := lang.Apply(tmp28, []any{tmp40}) - tmp42 := lang.Apply(tmp22, []any{tmp25, tmp41}) - tmp43 := lang.Apply(tmp19, []any{tmp42}) - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp48 := tmp47.FindInternedVar(lang.NewSymbol("seq")) - if tmp48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) - } - tmp49 := tmp48.Get() - tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp51 := tmp50.FindInternedVar(lang.NewSymbol("concat")) - if tmp51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) - } - tmp52 := tmp51.Get() - tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp54 := tmp53.FindInternedVar(lang.NewSymbol("list")) - if tmp54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) - } - tmp55 := tmp54.Get() - tmp56 := lang.Apply(tmp55, []any{lang.NewSymbol("try")}) - tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp58 := tmp57.FindInternedVar(lang.NewSymbol("list")) - if tmp58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) - } - tmp59 := tmp58.Get() - tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp61 := tmp60.FindInternedVar(lang.NewSymbol("seq")) - if tmp61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) - } - tmp62 := tmp61.Get() - tmp63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp64 := tmp63.FindInternedVar(lang.NewSymbol("concat")) - if tmp64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp64))) - } - tmp65 := tmp64.Get() - tmp66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp67 := tmp66.FindInternedVar(lang.NewSymbol("list")) - if tmp67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp67))) - } - tmp68 := tmp67.Get() - tmp69 := lang.Apply(tmp68, []any{lang.NewSymbol("glojure.core/let")}) - tmp70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp71 := tmp70.FindInternedVar(lang.NewSymbol("list")) - if tmp71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp71))) - } - tmp72 := tmp71.Get() - tmp73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp74 := tmp73.FindInternedVar(lang.NewSymbol("apply")) - if tmp74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp74))) - } - tmp75 := tmp74.Get() - tmp76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp77 := tmp76.FindInternedVar(lang.NewSymbol("vector")) - if tmp77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp77))) - } - tmp78 := tmp77.Get() - tmp79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp80 := tmp79.FindInternedVar(lang.NewSymbol("seq")) - if tmp80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp80))) - } - tmp81 := tmp80.Get() - tmp82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp83 := tmp82.FindInternedVar(lang.NewSymbol("concat")) - if tmp83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp83))) - } - tmp84 := tmp83.Get() - tmp85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp86 := tmp85.FindInternedVar(lang.NewSymbol("list")) - if tmp86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp86))) - } - tmp87 := tmp86.Get() - tmp88 := lang.Apply(tmp87, []any{lang.NewSymbol("locklocal__1__auto__")}) - tmp89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp90 := tmp89.FindInternedVar(lang.NewSymbol("list")) - if tmp90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp90))) - } - tmp91 := tmp90.Get() - tmp92 := lang.Apply(tmp91, []any{lang.NewSymbol("lockee__0__auto__")}) - tmp93 := lang.Apply(tmp84, []any{tmp88, tmp92}) - tmp94 := lang.Apply(tmp81, []any{tmp93}) - tmp95 := lang.Apply(tmp75, []any{tmp78, tmp94}) - tmp96 := lang.Apply(tmp72, []any{tmp95}) - tmp97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp98 := tmp97.FindInternedVar(lang.NewSymbol("list")) - if tmp98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp98))) - } - tmp99 := tmp98.Get() - tmp100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp101 := tmp100.FindInternedVar(lang.NewSymbol("seq")) - if tmp101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp101))) - } - tmp102 := tmp101.Get() - tmp103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp104 := tmp103.FindInternedVar(lang.NewSymbol("concat")) - if tmp104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp104))) - } - tmp105 := tmp104.Get() - tmp106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp107 := tmp106.FindInternedVar(lang.NewSymbol("list")) - if tmp107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp107))) - } - tmp108 := tmp107.Get() - tmp109 := lang.Apply(tmp108, []any{lang.NewSymbol("monitor-enter")}) - tmp110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp111 := tmp110.FindInternedVar(lang.NewSymbol("list")) - if tmp111.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp111))) - } - tmp112 := tmp111.Get() - tmp113 := lang.Apply(tmp112, []any{lang.NewSymbol("locklocal__1__auto__")}) - tmp114 := lang.Apply(tmp105, []any{tmp109, tmp113}) - tmp115 := lang.Apply(tmp102, []any{tmp114}) - tmp116 := lang.Apply(tmp99, []any{tmp115}) - tmp117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp118 := tmp117.FindInternedVar(lang.NewSymbol("list")) - if tmp118.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp118))) - } - tmp119 := tmp118.Get() - tmp120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp121 := tmp120.FindInternedVar(lang.NewSymbol("seq")) - if tmp121.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp121))) - } - tmp122 := tmp121.Get() - tmp123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp124 := tmp123.FindInternedVar(lang.NewSymbol("concat")) - if tmp124.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp124))) - } - tmp125 := tmp124.Get() - tmp126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp127 := tmp126.FindInternedVar(lang.NewSymbol("list")) - if tmp127.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp127))) - } - tmp128 := tmp127.Get() - tmp129 := lang.Apply(tmp128, []any{lang.NewSymbol("try")}) - tmp130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp131 := tmp130.FindInternedVar(lang.NewSymbol("list")) - if tmp131.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp131))) - } - tmp132 := tmp131.Get() - tmp133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp134 := tmp133.FindInternedVar(lang.NewSymbol("seq")) - if tmp134.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp134))) - } - tmp135 := tmp134.Get() - tmp136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp137 := tmp136.FindInternedVar(lang.NewSymbol("concat")) - if tmp137.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp137))) - } - tmp138 := tmp137.Get() - tmp139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp140 := tmp139.FindInternedVar(lang.NewSymbol("list")) - if tmp140.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp140))) - } - tmp141 := tmp140.Get() - tmp142 := lang.Apply(tmp141, []any{lang.NewSymbol("finally")}) - tmp143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp144 := tmp143.FindInternedVar(lang.NewSymbol("list")) - if tmp144.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp144))) - } - tmp145 := tmp144.Get() - tmp146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp147 := tmp146.FindInternedVar(lang.NewSymbol("seq")) - if tmp147.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp147))) - } - tmp148 := tmp147.Get() - tmp149 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp150 := tmp149.FindInternedVar(lang.NewSymbol("concat")) - if tmp150.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp150))) - } - tmp151 := tmp150.Get() - tmp152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp153 := tmp152.FindInternedVar(lang.NewSymbol("list")) - if tmp153.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp153))) - } - tmp154 := tmp153.Get() - tmp155 := lang.Apply(tmp154, []any{lang.NewSymbol("monitor-exit")}) - tmp156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp157 := tmp156.FindInternedVar(lang.NewSymbol("list")) - if tmp157.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp157))) - } - tmp158 := tmp157.Get() - tmp159 := lang.Apply(tmp158, []any{lang.NewSymbol("locklocal__1__auto__")}) - tmp160 := lang.Apply(tmp151, []any{tmp155, tmp159}) - tmp161 := lang.Apply(tmp148, []any{tmp160}) - tmp162 := lang.Apply(tmp145, []any{tmp161}) - tmp163 := lang.Apply(tmp138, []any{tmp142, tmp162}) - tmp164 := lang.Apply(tmp135, []any{tmp163}) - tmp165 := lang.Apply(tmp132, []any{tmp164}) - tmp166 := lang.Apply(tmp125, []any{tmp129, v6, tmp165}) - tmp167 := lang.Apply(tmp122, []any{tmp166}) - tmp168 := lang.Apply(tmp119, []any{tmp167}) - tmp169 := lang.Apply(tmp65, []any{tmp69, tmp96, tmp116, tmp168}) - tmp170 := lang.Apply(tmp62, []any{tmp169}) - tmp171 := lang.Apply(tmp59, []any{tmp170}) - tmp172 := lang.Apply(tmp52, []any{tmp56, tmp171}) - tmp173 := lang.Apply(tmp49, []any{tmp172}) - tmp174 := lang.Apply(tmp46, []any{tmp173}) - tmp175 := lang.Apply(tmp12, []any{tmp16, tmp43, tmp174}) - tmp176 := lang.Apply(tmp9, []any{tmp175}) - return tmp176 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // long - { - var tmp1 lang.FnFunc - { // function long__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/LongCast")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{v3}) - tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) - tmp36 := lang.Apply(tmp23, []any{tmp35}) - tmp37 := lang.Apply(tmp20, []any{tmp36}) - tmp38 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp37}) - tmp39 := lang.Apply(tmp6, []any{tmp38}) - return tmp39 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("long").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to long", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3481), lang.NewKeyword("end-line"), int(3481))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5 := lang.Apply(lang.LongCast, []any{v4}) - return tmp5 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // long-array - { - var tmp1 lang.FnFunc - { // function long-array__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var v3 any = lang.NewList(args[0:]...) - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.Apply(tmp20, []any{lang.NewSymbol("glojure.core/LongArray")}) - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("list")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("seq")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("concat")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) - tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp36 := tmp35.FindInternedVar(lang.NewSymbol("list")) - if tmp36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) - } - tmp37 := tmp36.Get() - tmp38 := lang.Apply(tmp37, []any{lang.NewSymbol("glojure.core/args")}) - tmp39 := lang.Apply(tmp30, []any{tmp34, tmp38}) - tmp40 := lang.Apply(tmp27, []any{tmp39}) - tmp41 := lang.Apply(tmp24, []any{tmp40}) - tmp42 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp21, tmp41}) - tmp43 := lang.Apply(tmp6, []any{tmp42}) - return tmp43 - } - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("long-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Creates an array of longs", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5364), lang.NewKeyword("end-line"), int(5364))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "LongArray") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("LongArray is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - case 2: - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "LongArrayInit") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("LongArrayInit is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // longs - { - var tmp1 lang.FnFunc - { // function longs - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.Apply(tmp20, []any{lang.NewSymbol("glojure.core/Longs")}) - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("list")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.Apply(tmp24, []any{v3}) - tmp26 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp21, tmp25}) - tmp27 := lang.Apply(tmp6, []any{tmp26}) - return tmp27 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("longs").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Casts to long[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5407), lang.NewKeyword("end-line"), int(5407))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Longs") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Longs is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // loop - { - tmp0 := lang.NewSymbol("loop").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Evaluates the exprs in a lexical context in which the symbols in\n the binding-forms are bound to their respective init-exprs or parts\n therein. Acts as a recur target.", lang.NewKeyword("forms"), lang.NewVector(lang.NewList(lang.NewSymbol("loop"), lang.NewVector(lang.NewSymbol("bindings*")), lang.NewSymbol("exprs*"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4597), lang.NewKeyword("end-line"), int(4597), lang.NewKeyword("special-form"), true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("vector?")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v5}) - if lang.IsTruthy(tmp11) { - } else { - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("str")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("first")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{v3}) - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("*ns*")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("meta")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.Apply(tmp24, []any{v3}) - tmp26 := lang.Apply(lang.NewKeyword("line"), []any{tmp25}) - tmp27 := lang.Apply(tmp14, []any{tmp18, " requires ", "a vector for its binding", " in ", tmp21, ":", tmp26}) - tmp28 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp27}) - panic(tmp28) - } - _ = tmp7 - var tmp29 any - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("even?")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("count")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.Apply(tmp35, []any{v5}) - tmp37 := lang.Apply(tmp32, []any{tmp36}) - if lang.IsTruthy(tmp37) { - } else { - tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp39 := tmp38.FindInternedVar(lang.NewSymbol("str")) - if tmp39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) - } - tmp40 := tmp39.Get() - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("first")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.Apply(tmp43, []any{v3}) - tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp46 := tmp45.FindInternedVar(lang.NewSymbol("*ns*")) - if tmp46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) - } - tmp47 := tmp46.Get() - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("meta")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v3}) - tmp52 := lang.Apply(lang.NewKeyword("line"), []any{tmp51}) - tmp53 := lang.Apply(tmp40, []any{tmp44, " requires ", "an even number of forms in binding vector", " in ", tmp47, ":", tmp52}) - tmp54 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp53}) - panic(tmp54) - } - _ = tmp29 - var tmp55 any - { // let - // let binding "db" - tmp56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp57 := tmp56.FindInternedVar(lang.NewSymbol("destructure")) - if tmp57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp57))) - } - tmp58 := tmp57.Get() - tmp59 := lang.Apply(tmp58, []any{v5}) - var v60 any = tmp59 - _ = v60 - var tmp61 any - tmp62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp63 := tmp62.FindInternedVar(lang.NewSymbol("=")) - if tmp63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp63))) - } - tmp64 := tmp63.Get() - tmp65 := lang.Apply(tmp64, []any{v60, v5}) - if lang.IsTruthy(tmp65) { - tmp66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp67 := tmp66.FindInternedVar(lang.NewSymbol("seq")) - if tmp67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp67))) - } - tmp68 := tmp67.Get() - tmp69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp70 := tmp69.FindInternedVar(lang.NewSymbol("concat")) - if tmp70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp70))) - } - tmp71 := tmp70.Get() - tmp72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp73 := tmp72.FindInternedVar(lang.NewSymbol("list")) - if tmp73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp73))) - } - tmp74 := tmp73.Get() - tmp75 := lang.Apply(tmp74, []any{lang.NewSymbol("loop*")}) - tmp76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp77 := tmp76.FindInternedVar(lang.NewSymbol("list")) - if tmp77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp77))) - } - tmp78 := tmp77.Get() - tmp79 := lang.Apply(tmp78, []any{v5}) - tmp80 := lang.Apply(tmp71, []any{tmp75, tmp79, v6}) - tmp81 := lang.Apply(tmp68, []any{tmp80}) - tmp61 = tmp81 - } else { - var tmp82 any - { // let - // let binding "vs" - tmp83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp84 := tmp83.FindInternedVar(lang.NewSymbol("take-nth")) - if tmp84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp84))) - } - tmp85 := tmp84.Get() - tmp86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp87 := tmp86.FindInternedVar(lang.NewSymbol("drop")) - if tmp87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp87))) - } - tmp88 := tmp87.Get() - tmp89 := lang.Apply(tmp88, []any{int64(1), v5}) - tmp90 := lang.Apply(tmp85, []any{int64(2), tmp89}) - var v91 any = tmp90 - _ = v91 - // let binding "bs" - tmp92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp93 := tmp92.FindInternedVar(lang.NewSymbol("take-nth")) - if tmp93.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp93))) - } - tmp94 := tmp93.Get() - tmp95 := lang.Apply(tmp94, []any{int64(2), v5}) - var v96 any = tmp95 - _ = v96 - // let binding "gs" - tmp97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp98 := tmp97.FindInternedVar(lang.NewSymbol("map")) - if tmp98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp98))) - } - tmp99 := tmp98.Get() - var tmp100 lang.FnFunc - tmp100 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v101 := args[0] - _ = v101 - var tmp102 any - tmp103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp104 := tmp103.FindInternedVar(lang.NewSymbol("symbol?")) - if tmp104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp104))) - } - tmp105 := tmp104.Get() - tmp106 := lang.Apply(tmp105, []any{v101}) - if lang.IsTruthy(tmp106) { - tmp102 = v101 - } else { - tmp107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp108 := tmp107.FindInternedVar(lang.NewSymbol("gensym")) - if tmp108.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp108))) - } - tmp109 := tmp108.Get() - tmp110 := lang.Apply(tmp109, nil) - tmp102 = tmp110 - } - return tmp102 - }) - tmp101 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4611), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(4611), lang.NewKeyword("end-column"), int(58)) - tmp102, err := lang.WithMeta(tmp100, tmp101.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp103 := lang.Apply(tmp99, []any{tmp102, v96}) - var v104 any = tmp103 - _ = v104 - // let binding "bfs" - tmp105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp106 := tmp105.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp106.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp106))) - } - tmp107 := tmp106.Get() - var tmp108 lang.FnFunc - tmp108 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v109 := args[0] - _ = v109 - v110 := args[1] - _ = v110 - var tmp111 any - { // let - // let binding "vec__17" - var v112 any = v110 - _ = v112 - // let binding "b" - tmp113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp114 := tmp113.FindInternedVar(lang.NewSymbol("nth")) - if tmp114.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp114))) - } - tmp115 := tmp114.Get() - tmp116 := lang.Apply(tmp115, []any{v112, int64(0), nil}) - var v117 any = tmp116 - _ = v117 - // let binding "v" - tmp118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp119 := tmp118.FindInternedVar(lang.NewSymbol("nth")) - if tmp119.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp119))) - } - tmp120 := tmp119.Get() - tmp121 := lang.Apply(tmp120, []any{v112, int64(1), nil}) - var v122 any = tmp121 - _ = v122 - // let binding "g" - tmp123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp124 := tmp123.FindInternedVar(lang.NewSymbol("nth")) - if tmp124.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp124))) - } - tmp125 := tmp124.Get() - tmp126 := lang.Apply(tmp125, []any{v112, int64(2), nil}) - var v127 any = tmp126 - _ = v127 - var tmp128 any - tmp129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp130 := tmp129.FindInternedVar(lang.NewSymbol("symbol?")) - if tmp130.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp130))) - } - tmp131 := tmp130.Get() - tmp132 := lang.Apply(tmp131, []any{v117}) - if lang.IsTruthy(tmp132) { - tmp133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp134 := tmp133.FindInternedVar(lang.NewSymbol("conj")) - if tmp134.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp134))) - } - tmp135 := tmp134.Get() - tmp136 := lang.Apply(tmp135, []any{v109, v127, v122}) - tmp128 = tmp136 - } else { - tmp137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp138 := tmp137.FindInternedVar(lang.NewSymbol("conj")) - if tmp138.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp138))) - } - tmp139 := tmp138.Get() - tmp140 := lang.Apply(tmp139, []any{v109, v127, v122, v117, v127}) - tmp128 = tmp140 - } - tmp111 = tmp128 - } // end let - return tmp111 - }) - tmp109 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4612), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(4615), lang.NewKeyword("end-column"), int(50)) - tmp110, err := lang.WithMeta(tmp108, tmp109.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp111 := lang.NewVector() - tmp112 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4616), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(4616), lang.NewKeyword("end-column"), int(28)) - tmp113, err := lang.WithMeta(tmp111, tmp112.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp115 := tmp114.FindInternedVar(lang.NewSymbol("map")) - if tmp115.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp115))) - } - tmp116 := tmp115.Get() - tmp117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp118 := tmp117.FindInternedVar(lang.NewSymbol("vector")) - if tmp118.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp118))) - } - tmp119 := tmp118.Get() - tmp120 := lang.Apply(tmp116, []any{tmp119, v96, v91, v104}) - tmp121 := lang.Apply(tmp107, []any{tmp110, tmp113, tmp120}) - var v122 any = tmp121 - _ = v122 - tmp123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp124 := tmp123.FindInternedVar(lang.NewSymbol("seq")) - if tmp124.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp124))) - } - tmp125 := tmp124.Get() - tmp126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp127 := tmp126.FindInternedVar(lang.NewSymbol("concat")) - if tmp127.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp127))) - } - tmp128 := tmp127.Get() - tmp129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp130 := tmp129.FindInternedVar(lang.NewSymbol("list")) - if tmp130.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp130))) - } - tmp131 := tmp130.Get() - tmp132 := lang.Apply(tmp131, []any{lang.NewSymbol("glojure.core/let")}) - tmp133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp134 := tmp133.FindInternedVar(lang.NewSymbol("list")) - if tmp134.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp134))) - } - tmp135 := tmp134.Get() - tmp136 := lang.Apply(tmp135, []any{v122}) - tmp137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp138 := tmp137.FindInternedVar(lang.NewSymbol("list")) - if tmp138.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp138))) - } - tmp139 := tmp138.Get() - tmp140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp141 := tmp140.FindInternedVar(lang.NewSymbol("seq")) - if tmp141.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp141))) - } - tmp142 := tmp141.Get() - tmp143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp144 := tmp143.FindInternedVar(lang.NewSymbol("concat")) - if tmp144.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp144))) - } - tmp145 := tmp144.Get() - tmp146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp147 := tmp146.FindInternedVar(lang.NewSymbol("list")) - if tmp147.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp147))) - } - tmp148 := tmp147.Get() - tmp149 := lang.Apply(tmp148, []any{lang.NewSymbol("loop*")}) - tmp150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp151 := tmp150.FindInternedVar(lang.NewSymbol("list")) - if tmp151.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp151))) - } - tmp152 := tmp151.Get() - tmp153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp154 := tmp153.FindInternedVar(lang.NewSymbol("vec")) - if tmp154.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp154))) - } - tmp155 := tmp154.Get() - tmp156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp157 := tmp156.FindInternedVar(lang.NewSymbol("interleave")) - if tmp157.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp157))) - } - tmp158 := tmp157.Get() - tmp159 := lang.Apply(tmp158, []any{v104, v104}) - tmp160 := lang.Apply(tmp155, []any{tmp159}) - tmp161 := lang.Apply(tmp152, []any{tmp160}) - tmp162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp163 := tmp162.FindInternedVar(lang.NewSymbol("list")) - if tmp163.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp163))) - } - tmp164 := tmp163.Get() - tmp165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp166 := tmp165.FindInternedVar(lang.NewSymbol("seq")) - if tmp166.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp166))) - } - tmp167 := tmp166.Get() - tmp168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp169 := tmp168.FindInternedVar(lang.NewSymbol("concat")) - if tmp169.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp169))) - } - tmp170 := tmp169.Get() - tmp171 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp172 := tmp171.FindInternedVar(lang.NewSymbol("list")) - if tmp172.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp172))) - } - tmp173 := tmp172.Get() - tmp174 := lang.Apply(tmp173, []any{lang.NewSymbol("glojure.core/let")}) - tmp175 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp176 := tmp175.FindInternedVar(lang.NewSymbol("list")) - if tmp176.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp176))) - } - tmp177 := tmp176.Get() - tmp178 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp179 := tmp178.FindInternedVar(lang.NewSymbol("vec")) - if tmp179.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp179))) - } - tmp180 := tmp179.Get() - tmp181 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp182 := tmp181.FindInternedVar(lang.NewSymbol("interleave")) - if tmp182.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp182))) - } - tmp183 := tmp182.Get() - tmp184 := lang.Apply(tmp183, []any{v96, v104}) - tmp185 := lang.Apply(tmp180, []any{tmp184}) - tmp186 := lang.Apply(tmp177, []any{tmp185}) - tmp187 := lang.Apply(tmp170, []any{tmp174, tmp186, v6}) - tmp188 := lang.Apply(tmp167, []any{tmp187}) - tmp189 := lang.Apply(tmp164, []any{tmp188}) - tmp190 := lang.Apply(tmp145, []any{tmp149, tmp161, tmp189}) - tmp191 := lang.Apply(tmp142, []any{tmp190}) - tmp192 := lang.Apply(tmp139, []any{tmp191}) - tmp193 := lang.Apply(tmp128, []any{tmp132, tmp136, tmp192}) - tmp194 := lang.Apply(tmp125, []any{tmp193}) - tmp82 = tmp194 - } // end let - tmp61 = tmp82 - } - tmp55 = tmp61 - } // end let - return tmp55 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // macroexpand - { - tmp0 := lang.NewSymbol("macroexpand").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("form"))), lang.NewKeyword("doc"), "Repeatedly calls macroexpand-1 on form until it no longer\n represents a macro form, then returns it. Note neither\n macroexpand-1 nor macroexpand expand macros in subforms.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4025), lang.NewKeyword("end-line"), int(4025))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "ex" - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("macroexpand-1")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v3}) - var v9 any = tmp8 - _ = v9 - var tmp10 any - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("identical?")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{v9, v3}) - if lang.IsTruthy(tmp14) { - tmp10 = v3 - } else { - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("macroexpand")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{v9}) - tmp10 = tmp18 - } - tmp4 = tmp10 - } // end let - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // macroexpand-1 - { - tmp0 := lang.NewSymbol("macroexpand-1").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("form"))), lang.NewKeyword("doc"), "If form represents a macro form, returns its expansion,\n else returns form.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4017), lang.NewKeyword("end-line"), int(4017))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4, _ := lang.FieldOrMethod(runtime4.Compiler, "macroexpand1") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("macroexpand1 is not a function"))) - } - tmp5 := lang.Apply(tmp4, []any{v3}) - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // make-array - { - tmp0 := lang.NewSymbol("make-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("type"), lang.NewSymbol("len")), lang.NewVector(lang.NewSymbol("type"), lang.NewSymbol("dim"), lang.NewSymbol("&"), lang.NewSymbol("more-dims"))), lang.NewKeyword("doc"), "Creates and returns an array of instances of the specified class of\n the specified dimension(s). Note that a class object is required.\n Class objects can be obtained by using their imported or\n fully-qualified name. Class objects for the primitive types can be\n obtained using, e.g., Integer/TYPE.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3985), lang.NewKeyword("end-line"), int(3985))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("int")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v4}) - tmp9, _ := lang.FieldOrMethod(nil, "newInstance") - if reflect.TypeOf(tmp9).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("newInstance is not a function"))) - } - tmp10 := lang.Apply(tmp9, []any{v3, tmp8}) - return tmp10 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - var tmp6 any - { // let - // let binding "dims" - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("cons")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp9, []any{v4, v5}) - var v11 any = tmp10 - _ = v11 - // let binding "dimarray" - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("make-array")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15, ok := lang.FieldOrMethod(nil, "TYPE") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "TYPE"))) - } - var tmp16 any - switch reflect.TypeOf(tmp15).Kind() { - case reflect.Func: - tmp16 = lang.Apply(tmp15, nil) - default: - tmp16 = tmp15 - } - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("count")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.Apply(tmp19, []any{v11}) - tmp21 := lang.Apply(tmp14, []any{tmp16, tmp20}) - var v22 any = tmp21 - _ = v22 - var tmp23 any - { // let - // let binding "n__0__auto__" - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("long")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("alength")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{v22}) - tmp31 := lang.Apply(tmp26, []any{tmp30}) - var v32 any = tmp31 - _ = v32 - var tmp33 any - { // let - // let binding "i" - var v34 any = int64(0) - _ = v34 - for { - var tmp35 any - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("<")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{v34, v32}) - if lang.IsTruthy(tmp39) { - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("aset-int")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp44 := tmp43.FindInternedVar(lang.NewSymbol("nth")) - if tmp44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) - } - tmp45 := tmp44.Get() - tmp46 := lang.Apply(tmp45, []any{v11, v34}) - tmp47 := lang.Apply(tmp42, []any{v22, v34, tmp46}) - _ = tmp47 - tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp50 := tmp49.FindInternedVar(lang.NewSymbol("unchecked-inc")) - if tmp50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) - } - tmp51 := tmp50.Get() - tmp52 := lang.Apply(tmp51, []any{v34}) - var tmp48 any = tmp52 - v34 = tmp48 - continue - } else { - } - tmp33 = tmp35 - break - } - } // end let - tmp23 = tmp33 - } // end let - _ = tmp23 - tmp24, _ := lang.FieldOrMethod(nil, "newInstance") - if reflect.TypeOf(tmp24).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("newInstance is not a function"))) - } - tmp25 := lang.Apply(tmp24, []any{v3, v22}) - tmp6 = tmp25 - } // end let - return tmp6 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // make-hierarchy - { - tmp0 := lang.NewSymbol("make-hierarchy").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Creates a hierarchy object for use with derive, isa? etc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5507), lang.NewKeyword("end-line"), int(5507))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - tmp3 := lang.NewMap() - tmp4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5511), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(5511), lang.NewKeyword("end-column"), int(17)) - tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp6 := lang.NewMap() - tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5511), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(5511), lang.NewKeyword("end-column"), int(33)) - tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp9 := lang.NewMap() - tmp10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5511), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(5511), lang.NewKeyword("end-column"), int(47)) - tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp12 := lang.NewMap(lang.NewKeyword("parents"), tmp5, lang.NewKeyword("descendants"), tmp8, lang.NewKeyword("ancestors"), tmp11) - tmp13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5511), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(5511), lang.NewKeyword("end-column"), int(48)) - tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp14 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // map - { - tmp0 := lang.NewSymbol("map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2"), lang.NewSymbol("c3")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2"), lang.NewSymbol("c3"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Returns a lazy sequence consisting of the result of applying f to\n the set of first items of each coll, followed by applying f to the\n set of second items in each coll, until any one of the colls is\n exhausted. Any remaining items in other colls are ignored. Function\n f should accept number-of-colls arguments. Returns a transducer when\n no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2719), lang.NewKeyword("end-line"), int(2719))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v5 := args[0] - _ = v5 - var tmp6 lang.FnFunc - tmp6 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp7 := lang.Apply(v5, nil) - return tmp7 - case 1: - v7 := args[0] - _ = v7 - tmp8 := lang.Apply(v5, []any{v7}) - return tmp8 - case 2: - v7 := args[0] - _ = v7 - v8 := args[1] - _ = v8 - tmp9 := lang.Apply(v3, []any{v8}) - tmp10 := lang.Apply(v5, []any{v7, tmp9}) - return tmp10 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v7 := args[0] - _ = v7 - v8 := args[1] - _ = v8 - var v9 any = lang.NewList(args[2:]...) - _ = v9 - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("apply")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{v3, v8, v9}) - tmp14 := lang.Apply(v5, []any{v7, tmp13}) - return tmp14 - } - }) - tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2730), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(2736), lang.NewKeyword("end-column"), int(47)) - tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp8 - }) - tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2729), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2736), lang.NewKeyword("end-column"), int(48)) - tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp6 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 lang.FnFunc - tmp5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var tmp6 any - { // let - // let binding "temp__0__auto__" - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("seq")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp9, []any{v4}) - var v11 any = tmp10 - _ = v11 - var tmp12 any - if lang.IsTruthy(v11) { - var tmp13 any - { // let - // let binding "s" - var v14 any = v11 - _ = v14 - var tmp15 any - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("chunked-seq?")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{v14}) - if lang.IsTruthy(tmp19) { - var tmp20 any - { // let - // let binding "c" - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("chunk-first")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.Apply(tmp23, []any{v14}) - var v25 any = tmp24 - _ = v25 - // let binding "size" - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("int")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("count")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.Apply(tmp31, []any{v25}) - tmp33 := lang.Apply(tmp28, []any{tmp32}) - var v34 any = tmp33 - _ = v34 - // let binding "b" - tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp36 := tmp35.FindInternedVar(lang.NewSymbol("chunk-buffer")) - if tmp36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) - } - tmp37 := tmp36.Get() - tmp38 := lang.Apply(tmp37, []any{v34}) - var v39 any = tmp38 - _ = v39 - var tmp40 any - { // let - // let binding "n__0__auto__" - tmp41 := lang.Apply(lang.LongCast, []any{v34}) - var v42 any = tmp41 - _ = v42 - var tmp43 any - { // let - // let binding "i" - var v44 any = int64(0) - _ = v44 - for { - var tmp45 any - tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp47 := tmp46.FindInternedVar(lang.NewSymbol("<")) - if tmp47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) - } - tmp48 := tmp47.Get() - tmp49 := lang.Apply(tmp48, []any{v44, v42}) - if lang.IsTruthy(tmp49) { - tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp51 := tmp50.FindInternedVar(lang.NewSymbol("chunk-append")) - if tmp51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) - } - tmp52 := tmp51.Get() - tmp53, _ := lang.FieldOrMethod(v25, "nth") - if reflect.TypeOf(tmp53).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) - } - tmp54 := lang.Apply(tmp53, []any{v44}) - tmp55 := lang.Apply(v3, []any{tmp54}) - tmp56 := lang.Apply(tmp52, []any{v39, tmp55}) - _ = tmp56 - tmp58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp59 := tmp58.FindInternedVar(lang.NewSymbol("unchecked-inc")) - if tmp59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp59))) - } - tmp60 := tmp59.Get() - tmp61 := lang.Apply(tmp60, []any{v44}) - var tmp57 any = tmp61 - v44 = tmp57 - continue - } else { - } - tmp43 = tmp45 - break - } - } // end let - tmp40 = tmp43 - } // end let - _ = tmp40 - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("chunk-cons")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("chunk")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.Apply(tmp46, []any{v39}) - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("map")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp52 := tmp51.FindInternedVar(lang.NewSymbol("chunk-rest")) - if tmp52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp52))) - } - tmp53 := tmp52.Get() - tmp54 := lang.Apply(tmp53, []any{v14}) - tmp55 := lang.Apply(tmp50, []any{v3, tmp54}) - tmp56 := lang.Apply(tmp43, []any{tmp47, tmp55}) - tmp20 = tmp56 - } // end let - tmp15 = tmp20 - } else { - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("cons")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("first")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.Apply(tmp26, []any{v14}) - tmp28 := lang.Apply(v3, []any{tmp27}) - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("map")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("rest")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.Apply(tmp34, []any{v14}) - tmp36 := lang.Apply(tmp31, []any{v3, tmp35}) - tmp37 := lang.Apply(tmp23, []any{tmp28, tmp36}) - tmp15 = tmp37 - } - tmp13 = tmp15 - } // end let - tmp12 = tmp13 - } else { - } - tmp6 = tmp12 - } // end let - return tmp6 - }) - tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) - return tmp6 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var tmp6 lang.FnFunc - tmp6 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var tmp7 any - { // let - // let binding "s1" - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("seq")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v4}) - var v12 any = tmp11 - _ = v12 - // let binding "s2" - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("seq")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{v5}) - var v17 any = tmp16 - _ = v17 - var tmp18 any - var tmp19 any - { // let - // let binding "and__0__auto__" - var v20 any = v12 - _ = v20 - var tmp21 any - if lang.IsTruthy(v20) { - tmp21 = v17 - } else { - tmp21 = v20 - } - tmp19 = tmp21 - } // end let - if lang.IsTruthy(tmp19) { - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("cons")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("first")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.Apply(tmp25, []any{v12}) - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("first")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{v17}) - tmp31 := lang.Apply(v3, []any{tmp26, tmp30}) - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("map")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp36 := tmp35.FindInternedVar(lang.NewSymbol("rest")) - if tmp36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) - } - tmp37 := tmp36.Get() - tmp38 := lang.Apply(tmp37, []any{v12}) - tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp40 := tmp39.FindInternedVar(lang.NewSymbol("rest")) - if tmp40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) - } - tmp41 := tmp40.Get() - tmp42 := lang.Apply(tmp41, []any{v17}) - tmp43 := lang.Apply(tmp34, []any{v3, tmp38, tmp42}) - tmp44 := lang.Apply(tmp22, []any{tmp31, tmp43}) - tmp18 = tmp44 - } else { - } - tmp7 = tmp18 - } // end let - return tmp7 - }) - tmp7 := lang.Apply(lang.NewLazySeq, []any{tmp6}) - return tmp7 - case 4: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - var tmp7 lang.FnFunc - tmp7 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var tmp8 any - { // let - // let binding "s1" - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("seq")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.Apply(tmp11, []any{v4}) - var v13 any = tmp12 - _ = v13 - // let binding "s2" - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("seq")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{v5}) - var v18 any = tmp17 - _ = v18 - // let binding "s3" - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("seq")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, []any{v6}) - var v23 any = tmp22 - _ = v23 - var tmp24 any - var tmp25 any - { // let - // let binding "and__0__auto__" - var v26 any = v13 - _ = v26 - var tmp27 any - if lang.IsTruthy(v26) { - var tmp28 any - { // let - // let binding "and__0__auto__" - var v29 any = v18 - _ = v29 - var tmp30 any - if lang.IsTruthy(v29) { - tmp30 = v23 - } else { - tmp30 = v29 - } - tmp28 = tmp30 - } // end let - tmp27 = tmp28 - } else { - tmp27 = v26 - } - tmp25 = tmp27 - } // end let - if lang.IsTruthy(tmp25) { - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("cons")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("first")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.Apply(tmp31, []any{v13}) - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("first")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.Apply(tmp35, []any{v18}) - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("first")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.Apply(tmp39, []any{v23}) - tmp41 := lang.Apply(v3, []any{tmp32, tmp36, tmp40}) - tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp43 := tmp42.FindInternedVar(lang.NewSymbol("map")) - if tmp43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) - } - tmp44 := tmp43.Get() - tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp46 := tmp45.FindInternedVar(lang.NewSymbol("rest")) - if tmp46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) - } - tmp47 := tmp46.Get() - tmp48 := lang.Apply(tmp47, []any{v13}) - tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp50 := tmp49.FindInternedVar(lang.NewSymbol("rest")) - if tmp50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) - } - tmp51 := tmp50.Get() - tmp52 := lang.Apply(tmp51, []any{v18}) - tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp54 := tmp53.FindInternedVar(lang.NewSymbol("rest")) - if tmp54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) - } - tmp55 := tmp54.Get() - tmp56 := lang.Apply(tmp55, []any{v23}) - tmp57 := lang.Apply(tmp44, []any{v3, tmp48, tmp52, tmp56}) - tmp58 := lang.Apply(tmp28, []any{tmp41, tmp57}) - tmp24 = tmp58 - } else { - } - tmp8 = tmp24 - } // end let - return tmp8 - }) - tmp8 := lang.Apply(lang.NewLazySeq, []any{tmp7}) - return tmp8 - default: - if len(args) < 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - var v7 any = lang.NewList(args[4:]...) - _ = v7 - var tmp8 any - { // let - // let binding "step" - var tmp9 lang.FnFunc - { // function step - var v10 lang.FnFunc - tmp9 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v11 := args[0] - _ = v11 - var tmp12 lang.FnFunc - tmp12 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var tmp13 any - { // let - // let binding "ss" - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("map")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.Apply(tmp16, []any{tmp19, v11}) - var v21 any = tmp20 - _ = v21 - var tmp22 any - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("every?")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("identity")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.Apply(tmp25, []any{tmp28, v21}) - if lang.IsTruthy(tmp29) { - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("cons")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("map")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("first")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp35, []any{tmp38, v21}) - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("map")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp44 := tmp43.FindInternedVar(lang.NewSymbol("rest")) - if tmp44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) - } - tmp45 := tmp44.Get() - tmp46 := lang.Apply(tmp42, []any{tmp45, v21}) - tmp47 := lang.Apply(v10, []any{tmp46}) - tmp48 := lang.Apply(tmp32, []any{tmp39, tmp47}) - tmp22 = tmp48 - } else { - } - tmp13 = tmp22 - } // end let - return tmp13 - }) - tmp13 := lang.Apply(lang.NewLazySeq, []any{tmp12}) - return tmp13 - }) - v10 = tmp9 - _ = v10 - } - tmp10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2761), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(2765), lang.NewKeyword("end-column"), int(68)) - tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v12 any = tmp11 - _ = v12 - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("map")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - var tmp16 lang.FnFunc - tmp16 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v17 := args[0] - _ = v17 - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("apply")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.Apply(tmp20, []any{v3, v17}) - return tmp21 - }) - tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2766), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(2766), lang.NewKeyword("end-column"), int(22)) - tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("conj")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, []any{v7, v6, v5, v4}) - tmp23 := lang.Apply(v12, []any{tmp22}) - tmp24 := lang.Apply(tmp15, []any{tmp18, tmp23}) - tmp8 = tmp24 - } // end let - return tmp8 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // map-entry? - { - tmp0 := lang.NewSymbol("map-entry?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a map entry", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.8", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1473), lang.NewKeyword("end-line"), int(1473))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := reflect.TypeOf((*lang.MapEntry)(nil)).Elem() - tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) - return tmp8 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // map-indexed - { - tmp0 := lang.NewSymbol("map-indexed").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence consisting of the result of applying f to 0\n and the first item of coll, followed by applying f to 1 and the second\n item in coll, etc, until coll is exhausted. Thus function f should\n accept 2 arguments, index and item. Returns a stateful transducer when\n no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7309), lang.NewKeyword("end-line"), int(7309))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v5 := args[0] - _ = v5 - var tmp6 any - { // let - // let binding "i" - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("volatile!")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp9, []any{int64(-1)}) - var v11 any = tmp10 - _ = v11 - var tmp12 lang.FnFunc - tmp12 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp13 := lang.Apply(v5, nil) - return tmp13 - case 1: - v13 := args[0] - _ = v13 - tmp14 := lang.Apply(v5, []any{v13}) - return tmp14 - case 2: - v13 := args[0] - _ = v13 - v14 := args[1] - _ = v14 - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("inc")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18, ok := lang.FieldOrMethod(v11, "Deref") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v11, "Deref"))) - } - var tmp19 any - switch reflect.TypeOf(tmp18).Kind() { - case reflect.Func: - tmp19 = lang.Apply(tmp18, nil) - default: - tmp19 = tmp18 - } - tmp20 := lang.Apply(tmp17, []any{tmp19}) - tmp21, _ := lang.FieldOrMethod(v11, "reset") - if reflect.TypeOf(tmp21).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) - } - tmp22 := lang.Apply(tmp21, []any{tmp20}) - tmp23 := lang.Apply(v3, []any{tmp22, v14}) - tmp24 := lang.Apply(v5, []any{v13, tmp23}) - return tmp24 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7320), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7324), lang.NewKeyword("end-column"), int(48)) - tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp6 = tmp14 - } // end let - return tmp6 - }) - tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7318), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7324), lang.NewKeyword("end-column"), int(50)) - tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp6 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - return nil - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // map? - { - tmp0 := lang.NewSymbol("map?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x implements IPersistentMap", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(167), lang.NewKeyword("end-line"), int(171))).(*lang.Symbol) - var tmp2 lang.FnFunc - { // function map? - var v3 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("instance?")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := reflect.TypeOf((*lang.IPersistentMap)(nil)).Elem() - tmp9 := lang.Apply(tmp7, []any{tmp8, v4}) - return tmp9 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(171), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(171), lang.NewKeyword("end-column"), int(97))).(lang.FnFunc) - v3 = tmp2 - _ = v3 - } - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // mapcat - { - tmp0 := lang.NewSymbol("mapcat").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Returns the result of applying concat to the result of applying map\n to f and colls. Thus function f should return a collection. Returns\n a transducer when no collections are provided", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2775), lang.NewKeyword("end-line"), int(2775))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("comp")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("map")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp9, []any{v3}) - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("cat")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp6, []any{tmp10, tmp13}) - return tmp14 - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var v4 any = lang.NewList(args[1:]...) - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("apply")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("concat")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("apply")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("map")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp13, []any{tmp16, v3, v4}) - tmp18 := lang.Apply(tmp7, []any{tmp10, tmp17}) - return tmp18 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // mapv - { - tmp0 := lang.NewSymbol("mapv").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2"), lang.NewSymbol("c3")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2"), lang.NewSymbol("c3"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Returns a vector consisting of the result of applying f to the\n set of first items of each coll, followed by applying f to the set\n of second items in each coll, until any one of the colls is\n exhausted. Any remaining items in other colls are ignored. Function\n f should accept number-of-colls arguments.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6943), lang.NewKeyword("end-line"), int(6943))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("persistent!")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("reduce")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - var tmp11 lang.FnFunc - tmp11 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v12 := args[0] - _ = v12 - v13 := args[1] - _ = v13 - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("conj!")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(v3, []any{v13}) - tmp18 := lang.Apply(tmp16, []any{v12, tmp17}) - return tmp18 - }) - tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6952), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(6952), lang.NewKeyword("end-column"), int(43)) - tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("transient")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.NewVector() - tmp18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6952), lang.NewKeyword("column"), int(56), lang.NewKeyword("end-line"), int(6952), lang.NewKeyword("end-column"), int(57)) - tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp20 := lang.Apply(tmp16, []any{tmp19}) - tmp21 := lang.Apply(tmp10, []any{tmp13, tmp20, v4}) - tmp22 := lang.Apply(tmp7, []any{tmp21}) - return tmp22 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("into")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.NewVector() - tmp10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6955), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(6955), lang.NewKeyword("end-column"), int(13)) - tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("map")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.Apply(tmp14, []any{v3, v4, v5}) - tmp16 := lang.Apply(tmp8, []any{tmp11, tmp15}) - return tmp16 - case 4: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("into")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.NewVector() - tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6957), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(6957), lang.NewKeyword("end-column"), int(13)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("map")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{v3, v4, v5, v6}) - tmp17 := lang.Apply(tmp9, []any{tmp12, tmp16}) - return tmp17 - default: - if len(args) < 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - var v7 any = lang.NewList(args[4:]...) - _ = v7 - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("into")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.NewVector() - tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6959), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(6959), lang.NewKeyword("end-column"), int(13)) - tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("apply")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("map")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.Apply(tmp16, []any{tmp19, v3, v4, v5, v6, v7}) - tmp21 := lang.Apply(tmp10, []any{tmp13, tmp20}) - return tmp21 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // max - { - var tmp1 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v2 := args[0] - _ = v2 - var tmp3 any - { // let - // let binding "op" - var tmp4 any - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - if lang.IsTruthy(tmp7) { - tmp4 = closed14 - } else { - tmp4 = closed14 - } - var v8 any = tmp4 - _ = v8 - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("seq")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("concat")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol(".")}) - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("seq")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("concat")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.Apply(tmp34, []any{v8}) - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{v2}) - tmp40 := lang.Apply(tmp31, []any{tmp35, tmp39}) - tmp41 := lang.Apply(tmp28, []any{tmp40}) - tmp42 := lang.Apply(tmp25, []any{tmp41}) - tmp43 := lang.Apply(tmp14, []any{tmp18, tmp22, tmp42}) - tmp44 := lang.Apply(tmp11, []any{tmp43}) - tmp3 = tmp44 - } // end let - return tmp3 - case 2: - v2 := args[0] - _ = v2 - v3 := args[1] - _ = v3 - var tmp4 any - { // let - // let binding "op" - var tmp5 any - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - if lang.IsTruthy(tmp8) { - tmp5 = closed14 - } else { - tmp5 = closed14 - } - var v9 any = tmp5 - _ = v9 - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("seq")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("concat")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("list")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{lang.NewSymbol(".")}) - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("list")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.Apply(tmp22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("list")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("seq")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("concat")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("list")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.Apply(tmp35, []any{v9}) - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("list")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.Apply(tmp39, []any{v2}) - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("list")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.Apply(tmp43, []any{v3}) - tmp45 := lang.Apply(tmp32, []any{tmp36, tmp40, tmp44}) - tmp46 := lang.Apply(tmp29, []any{tmp45}) - tmp47 := lang.Apply(tmp26, []any{tmp46}) - tmp48 := lang.Apply(tmp15, []any{tmp19, tmp23, tmp47}) - tmp49 := lang.Apply(tmp12, []any{tmp48}) - tmp4 = tmp49 - } // end let - return tmp4 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v2 := args[0] - _ = v2 - v3 := args[1] - _ = v3 - var v4 any = lang.NewList(args[2:]...) - _ = v4 - var tmp5 any - { // let - // let binding "op" - var tmp6 any - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - if lang.IsTruthy(tmp9) { - tmp6 = closed14 - } else { - tmp6 = closed14 - } - var v10 any = tmp6 - _ = v10 - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - var tmp14 lang.FnFunc - tmp14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v15 := args[0] - _ = v15 - v16 := args[1] - _ = v16 - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("concat")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol(".")}) - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.Apply(tmp42, []any{v10}) - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.Apply(tmp46, []any{v15}) - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v16}) - tmp52 := lang.Apply(tmp39, []any{tmp43, tmp47, tmp51}) - tmp53 := lang.Apply(tmp36, []any{tmp52}) - tmp54 := lang.Apply(tmp33, []any{tmp53}) - tmp55 := lang.Apply(tmp22, []any{tmp26, tmp30, tmp54}) - tmp56 := lang.Apply(tmp19, []any{tmp55}) - return tmp56 - }) - tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) - tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("concat")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol(".")}) - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.Apply(tmp42, []any{v10}) - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.Apply(tmp46, []any{v2}) - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v3}) - tmp52 := lang.Apply(tmp39, []any{tmp43, tmp47, tmp51}) - tmp53 := lang.Apply(tmp36, []any{tmp52}) - tmp54 := lang.Apply(tmp33, []any{tmp53}) - tmp55 := lang.Apply(tmp22, []any{tmp26, tmp30, tmp54}) - tmp56 := lang.Apply(tmp19, []any{tmp55}) - tmp57 := lang.Apply(tmp13, []any{tmp16, tmp56, v4}) - tmp5 = tmp57 - } // end let - return tmp5 - } - }) - tmp1 = tmp1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) - } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp0 := lang.NewSymbol("max").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the greatest of the nums.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), tmp2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1108), lang.NewKeyword("end-line"), int(1108))).(*lang.Symbol) - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v5 := args[0] - _ = v5 - return v5 - case 2: - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - tmp7, _ := lang.FieldOrMethod(lang.Numbers, "Max") - if reflect.TypeOf(tmp7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Max is not a function"))) - } - tmp8 := lang.Apply(tmp7, []any{v5, v6}) - return tmp8 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - var v7 any = lang.NewList(args[2:]...) - _ = v7 - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("max")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("max")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{v5, v6}) - tmp18 := lang.Apply(tmp10, []any{tmp13, tmp17, v7}) - return tmp18 - } - }) - tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp3 := ns.InternWithValue(tmp0, tmp4, true) - if tmp0.Meta() != nil { - tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // max-key - { - tmp0 := lang.NewSymbol("max-key").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Returns the x for which (k x), a number, is greatest.\n\n If there are multiple such xs, the last one is returned.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5013), lang.NewKeyword("end-line"), int(5013))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - return v4 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var tmp6 any - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol(">")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(v3, []any{v4}) - tmp11 := lang.Apply(v3, []any{v5}) - tmp12 := lang.Apply(tmp9, []any{tmp10, tmp11}) - if lang.IsTruthy(tmp12) { - tmp6 = v4 - } else { - tmp6 = v5 - } - return tmp6 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any - { // let - // let binding "kx" - tmp8 := lang.Apply(v3, []any{v4}) - var v9 any = tmp8 - _ = v9 - // let binding "ky" - tmp10 := lang.Apply(v3, []any{v5}) - var v11 any = tmp10 - _ = v11 - // let binding "vec__55" - var tmp12 any - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol(">")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{v9, v11}) - if lang.IsTruthy(tmp16) { - tmp17 := lang.NewVector(v4, v9) - tmp18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5023), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(5023), lang.NewKeyword("end-column"), int(36)) - tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp12 = tmp19 - } else { - tmp20 := lang.NewVector(v5, v11) - tmp21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5023), lang.NewKeyword("column"), int(38), lang.NewKeyword("end-line"), int(5023), lang.NewKeyword("end-column"), int(43)) - tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp12 = tmp22 - } - var v23 any = tmp12 - _ = v23 - // let binding "v" - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("nth")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.Apply(tmp26, []any{v23, int64(0), nil}) - var v28 any = tmp27 - _ = v28 - // let binding "kv" - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("nth")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.Apply(tmp31, []any{v23, int64(1), nil}) - var v33 any = tmp32 - _ = v33 - var tmp34 any - { // let - // let binding "v" - var v35 any = v28 - _ = v35 - // let binding "kv" - var v36 any = v33 - _ = v36 - // let binding "more" - var v37 any = v6 - _ = v37 - for { - var tmp38 any - if lang.IsTruthy(v37) { - var tmp39 any - { // let - // let binding "w" - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("first")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.Apply(tmp42, []any{v37}) - var v44 any = tmp43 - _ = v44 - // let binding "kw" - tmp45 := lang.Apply(v3, []any{v44}) - var v46 any = tmp45 - _ = v46 - var tmp47 any - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol(">=")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v46, v36}) - if lang.IsTruthy(tmp51) { - var tmp52 any = v44 - var tmp53 any = v46 - tmp55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp56 := tmp55.FindInternedVar(lang.NewSymbol("next")) - if tmp56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp56))) - } - tmp57 := tmp56.Get() - tmp58 := lang.Apply(tmp57, []any{v37}) - var tmp54 any = tmp58 - v35 = tmp52 - v36 = tmp53 - v37 = tmp54 - continue - } else { - var tmp59 any = v35 - var tmp60 any = v36 - tmp62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp63 := tmp62.FindInternedVar(lang.NewSymbol("next")) - if tmp63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp63))) - } - tmp64 := tmp63.Get() - tmp65 := lang.Apply(tmp64, []any{v37}) - var tmp61 any = tmp65 - v35 = tmp59 - v36 = tmp60 - v37 = tmp61 - continue - } - tmp39 = tmp47 - } // end let - tmp38 = tmp39 - } else { - tmp38 = v35 - } - tmp34 = tmp38 - break - } - } // end let - tmp7 = tmp34 - } // end let - return tmp7 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // max-mask-bits - { - tmp0 := lang.NewSymbol("max-mask-bits").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6601), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(6601), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, int64(13), true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // max-switch-table-size - { - tmp0 := lang.NewSymbol("max-switch-table-size").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6602), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(6602), lang.NewKeyword("end-column"), int(36), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, int64(8192), true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // maybe-destructured - { - tmp0 := lang.NewSymbol("maybe-destructured").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4514), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(4515), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("params"), lang.NewSymbol("body"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("every?")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("symbol?")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.Apply(tmp8, []any{tmp11, v3}) - if lang.IsTruthy(tmp12) { - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("cons")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{v3, v4}) - tmp5 = tmp16 - } else { - var tmp17 any - { // let - // let binding "params" - var v18 any = v3 - _ = v18 - // let binding "new-params" - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("with-meta")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.NewVector() - tmp23 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4520), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(4520), lang.NewKeyword("end-column"), int(35)) - tmp24, err := lang.WithMeta(tmp22, tmp23.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("meta")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.Apply(tmp27, []any{v18}) - tmp29 := lang.Apply(tmp21, []any{tmp24, tmp28}) - var v30 any = tmp29 - _ = v30 - // let binding "lets" - tmp31 := lang.NewVector() - tmp32 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4521), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(4521), lang.NewKeyword("end-column"), int(18)) - tmp33, err := lang.WithMeta(tmp31, tmp32.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v34 any = tmp33 - _ = v34 - for { - var tmp35 any - if lang.IsTruthy(v18) { - var tmp36 any - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("symbol?")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("first")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.Apply(tmp42, []any{v18}) - tmp44 := lang.Apply(tmp39, []any{tmp43}) - if lang.IsTruthy(tmp44) { - tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp47 := tmp46.FindInternedVar(lang.NewSymbol("next")) - if tmp47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) - } - tmp48 := tmp47.Get() - tmp49 := lang.Apply(tmp48, []any{v18}) - var tmp45 any = tmp49 - tmp51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp52 := tmp51.FindInternedVar(lang.NewSymbol("conj")) - if tmp52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp52))) - } - tmp53 := tmp52.Get() - tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp55 := tmp54.FindInternedVar(lang.NewSymbol("first")) - if tmp55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) - } - tmp56 := tmp55.Get() - tmp57 := lang.Apply(tmp56, []any{v18}) - tmp58 := lang.Apply(tmp53, []any{v30, tmp57}) - var tmp50 any = tmp58 - var tmp59 any = v34 - v18 = tmp45 - v30 = tmp50 - v34 = tmp59 - continue - } else { - var tmp60 any - { // let - // let binding "gparam" - tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp62 := tmp61.FindInternedVar(lang.NewSymbol("gensym")) - if tmp62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) - } - tmp63 := tmp62.Get() - tmp64 := lang.Apply(tmp63, []any{"p__"}) - var v65 any = tmp64 - _ = v65 - tmp67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp68 := tmp67.FindInternedVar(lang.NewSymbol("next")) - if tmp68.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp68))) - } - tmp69 := tmp68.Get() - tmp70 := lang.Apply(tmp69, []any{v18}) - var tmp66 any = tmp70 - tmp72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp73 := tmp72.FindInternedVar(lang.NewSymbol("conj")) - if tmp73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp73))) - } - tmp74 := tmp73.Get() - tmp75 := lang.Apply(tmp74, []any{v30, v65}) - var tmp71 any = tmp75 - tmp77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp78 := tmp77.FindInternedVar(lang.NewSymbol("conj")) - if tmp78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp78))) - } - tmp79 := tmp78.Get() - tmp80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp81 := tmp80.FindInternedVar(lang.NewSymbol("conj")) - if tmp81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp81))) - } - tmp82 := tmp81.Get() - tmp83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp84 := tmp83.FindInternedVar(lang.NewSymbol("first")) - if tmp84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp84))) - } - tmp85 := tmp84.Get() - tmp86 := lang.Apply(tmp85, []any{v18}) - tmp87 := lang.Apply(tmp82, []any{v34, tmp86}) - tmp88 := lang.Apply(tmp79, []any{tmp87, v65}) - var tmp76 any = tmp88 - v18 = tmp66 - v30 = tmp71 - v34 = tmp76 - continue - } // end let - tmp36 = tmp60 - } - tmp35 = tmp36 - } else { - tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp62 := tmp61.FindInternedVar(lang.NewSymbol("seq")) - if tmp62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) - } - tmp63 := tmp62.Get() - tmp64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp65 := tmp64.FindInternedVar(lang.NewSymbol("concat")) - if tmp65.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp65))) - } - tmp66 := tmp65.Get() - tmp67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp68 := tmp67.FindInternedVar(lang.NewSymbol("list")) - if tmp68.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp68))) - } - tmp69 := tmp68.Get() - tmp70 := lang.Apply(tmp69, []any{v30}) - tmp71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp72 := tmp71.FindInternedVar(lang.NewSymbol("list")) - if tmp72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp72))) - } - tmp73 := tmp72.Get() - tmp74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp75 := tmp74.FindInternedVar(lang.NewSymbol("seq")) - if tmp75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp75))) - } - tmp76 := tmp75.Get() - tmp77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp78 := tmp77.FindInternedVar(lang.NewSymbol("concat")) - if tmp78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp78))) - } - tmp79 := tmp78.Get() - tmp80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp81 := tmp80.FindInternedVar(lang.NewSymbol("list")) - if tmp81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp81))) - } - tmp82 := tmp81.Get() - tmp83 := lang.Apply(tmp82, []any{lang.NewSymbol("glojure.core/let")}) - tmp84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp85 := tmp84.FindInternedVar(lang.NewSymbol("list")) - if tmp85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp85))) - } - tmp86 := tmp85.Get() - tmp87 := lang.Apply(tmp86, []any{v34}) - tmp88 := lang.Apply(tmp79, []any{tmp83, tmp87, v4}) - tmp89 := lang.Apply(tmp76, []any{tmp88}) - tmp90 := lang.Apply(tmp73, []any{tmp89}) - tmp91 := lang.Apply(tmp66, []any{tmp70, tmp90}) - tmp92 := lang.Apply(tmp63, []any{tmp91}) - tmp35 = tmp92 - } - tmp17 = tmp35 - break - } - } // end let - tmp5 = tmp17 - } - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // maybe-min-hash - { - tmp0 := lang.NewSymbol("maybe-min-hash").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("hashes"))), lang.NewKeyword("doc"), "takes a collection of hashes and returns [shift mask] or nil if none found", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6604), lang.NewKeyword("end-line"), int(6604), lang.NewKeyword("private"), true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("first")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("filter")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - var tmp10 lang.FnFunc - tmp10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v11 := args[0] - _ = v11 - var tmp12 any - { // let - // let binding "vec__151" - var v13 any = v11 - _ = v13 - // let binding "s" - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("nth")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{v13, int64(0), nil}) - var v18 any = tmp17 - _ = v18 - // let binding "m" - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("nth")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, []any{v13, int64(1), nil}) - var v23 any = tmp22 - _ = v23 - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("apply")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("distinct?")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("map")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - var tmp33 lang.FnFunc - tmp33 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v34 := args[0] - _ = v34 - tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp36 := tmp35.FindInternedVar(lang.NewSymbol("shift-mask")) - if tmp36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) - } - tmp37 := tmp36.Get() - tmp38 := lang.Apply(tmp37, []any{v18, v23, v34}) - return tmp38 - }) - tmp34 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6609), lang.NewKeyword("column"), int(37), lang.NewKeyword("end-line"), int(6609), lang.NewKeyword("end-column"), int(55)) - tmp35, err := lang.WithMeta(tmp33, tmp34.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp36 := lang.Apply(tmp32, []any{tmp35, v3}) - tmp37 := lang.Apply(tmp26, []any{tmp29, tmp36}) - tmp12 = tmp37 - } // end let - return tmp12 - }) - tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6608), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(6609), lang.NewKeyword("end-column"), int(65)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var tmp13 any - { // let - // let binding "iter__0__auto__" - var tmp14 lang.FnFunc - { // function iter__154 - var v15 lang.FnFunc - tmp14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v16 := args[0] - _ = v16 - var tmp17 lang.FnFunc - tmp17 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var tmp18 any - { // let - // let binding "s__155" - var v19 any = v16 - _ = v19 - for { - var tmp20 any - { // let - // let binding "temp__0__auto__" - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.Apply(tmp23, []any{v19}) - var v25 any = tmp24 - _ = v25 - var tmp26 any - if lang.IsTruthy(v25) { - var tmp27 any - { // let - // let binding "xs__0__auto__" - var v28 any = v25 - _ = v28 - var tmp29 any - { // let - // let binding "mask" - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("first")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.Apply(tmp32, []any{v28}) - var v34 any = tmp33 - _ = v34 - var tmp35 any - { // let - // let binding "iterys__0__auto__" - var tmp36 lang.FnFunc - { // function iter__156 - var v37 lang.FnFunc - tmp36 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v38 := args[0] - _ = v38 - var tmp39 lang.FnFunc - tmp39 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var tmp40 any - { // let - // let binding "s__157" - var v41 any = v38 - _ = v41 - for { - var tmp42 any - { // let - // let binding "temp__0__auto__" - tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp44 := tmp43.FindInternedVar(lang.NewSymbol("seq")) - if tmp44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) - } - tmp45 := tmp44.Get() - tmp46 := lang.Apply(tmp45, []any{v41}) - var v47 any = tmp46 - _ = v47 - var tmp48 any - if lang.IsTruthy(v47) { - var tmp49 any - { // let - // let binding "s__157" - var v50 any = v47 - _ = v50 - var tmp51 any - tmp52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp53 := tmp52.FindInternedVar(lang.NewSymbol("chunked-seq?")) - if tmp53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp53))) - } - tmp54 := tmp53.Get() - tmp55 := lang.Apply(tmp54, []any{v50}) - if lang.IsTruthy(tmp55) { - var tmp56 any - { // let - // let binding "c__0__auto__" - tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp58 := tmp57.FindInternedVar(lang.NewSymbol("chunk-first")) - if tmp58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) - } - tmp59 := tmp58.Get() - tmp60 := lang.Apply(tmp59, []any{v50}) - var v61 any = tmp60 - _ = v61 - // let binding "size__1__auto__" - tmp62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp63 := tmp62.FindInternedVar(lang.NewSymbol("int")) - if tmp63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp63))) - } - tmp64 := tmp63.Get() - tmp65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp66 := tmp65.FindInternedVar(lang.NewSymbol("count")) - if tmp66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp66))) - } - tmp67 := tmp66.Get() - tmp68 := lang.Apply(tmp67, []any{v61}) - tmp69 := lang.Apply(tmp64, []any{tmp68}) - var v70 any = tmp69 - _ = v70 - // let binding "b__159" - tmp71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp72 := tmp71.FindInternedVar(lang.NewSymbol("chunk-buffer")) - if tmp72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp72))) - } - tmp73 := tmp72.Get() - tmp74 := lang.Apply(tmp73, []any{v70}) - var v75 any = tmp74 - _ = v75 - var tmp76 any - var tmp77 any - { // let - // let binding "i__158" - tmp78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp79 := tmp78.FindInternedVar(lang.NewSymbol("int")) - if tmp79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp79))) - } - tmp80 := tmp79.Get() - tmp81 := lang.Apply(tmp80, []any{int64(0)}) - var v82 any = tmp81 - _ = v82 - for { - var tmp83 any - tmp84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp85 := tmp84.FindInternedVar(lang.NewSymbol("<")) - if tmp85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp85))) - } - tmp86 := tmp85.Get() - tmp87 := lang.Apply(tmp86, []any{v82, v70}) - if lang.IsTruthy(tmp87) { - var tmp88 any - { // let - // let binding "shift" - tmp89, _ := lang.FieldOrMethod(v61, "nth") - if reflect.TypeOf(tmp89).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) - } - tmp90 := lang.Apply(tmp89, []any{v82}) - var v91 any = tmp90 - _ = v91 - tmp92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp93 := tmp92.FindInternedVar(lang.NewSymbol("chunk-append")) - if tmp93.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp93))) - } - tmp94 := tmp93.Get() - tmp95 := lang.NewVector(v91, v34) - tmp96 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6612), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(6612), lang.NewKeyword("end-column"), int(26)) - tmp97, err := lang.WithMeta(tmp95, tmp96.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp98 := lang.Apply(tmp94, []any{v75, tmp97}) - _ = tmp98 - tmp100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp101 := tmp100.FindInternedVar(lang.NewSymbol("unchecked-inc")) - if tmp101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp101))) - } - tmp102 := tmp101.Get() - tmp103 := lang.Apply(tmp102, []any{v82}) - var tmp99 any = tmp103 - v82 = tmp99 - continue - } // end let - tmp83 = tmp88 - } else { - tmp83 = true - } - tmp77 = tmp83 - break - } - } // end let - if lang.IsTruthy(tmp77) { - tmp78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp79 := tmp78.FindInternedVar(lang.NewSymbol("chunk-cons")) - if tmp79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp79))) - } - tmp80 := tmp79.Get() - tmp81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp82 := tmp81.FindInternedVar(lang.NewSymbol("chunk")) - if tmp82.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp82))) - } - tmp83 := tmp82.Get() - tmp84 := lang.Apply(tmp83, []any{v75}) - tmp85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp86 := tmp85.FindInternedVar(lang.NewSymbol("chunk-rest")) - if tmp86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp86))) - } - tmp87 := tmp86.Get() - tmp88 := lang.Apply(tmp87, []any{v50}) - tmp89 := lang.Apply(v37, []any{tmp88}) - tmp90 := lang.Apply(tmp80, []any{tmp84, tmp89}) - tmp76 = tmp90 - } else { - tmp91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp92 := tmp91.FindInternedVar(lang.NewSymbol("chunk-cons")) - if tmp92.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp92))) - } - tmp93 := tmp92.Get() - tmp94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp95 := tmp94.FindInternedVar(lang.NewSymbol("chunk")) - if tmp95.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp95))) - } - tmp96 := tmp95.Get() - tmp97 := lang.Apply(tmp96, []any{v75}) - tmp98 := lang.Apply(tmp93, []any{tmp97, nil}) - tmp76 = tmp98 - } - tmp56 = tmp76 - } // end let - tmp51 = tmp56 - } else { - var tmp57 any - { // let - // let binding "shift" - tmp58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp59 := tmp58.FindInternedVar(lang.NewSymbol("first")) - if tmp59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp59))) - } - tmp60 := tmp59.Get() - tmp61 := lang.Apply(tmp60, []any{v50}) - var v62 any = tmp61 - _ = v62 - tmp63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp64 := tmp63.FindInternedVar(lang.NewSymbol("cons")) - if tmp64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp64))) - } - tmp65 := tmp64.Get() - tmp66 := lang.NewVector(v62, v34) - tmp67 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6612), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(6612), lang.NewKeyword("end-column"), int(26)) - tmp68, err := lang.WithMeta(tmp66, tmp67.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp70 := tmp69.FindInternedVar(lang.NewSymbol("rest")) - if tmp70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp70))) - } - tmp71 := tmp70.Get() - tmp72 := lang.Apply(tmp71, []any{v50}) - tmp73 := lang.Apply(v37, []any{tmp72}) - tmp74 := lang.Apply(tmp65, []any{tmp68, tmp73}) - tmp57 = tmp74 - } // end let - tmp51 = tmp57 - } - tmp49 = tmp51 - } // end let - tmp48 = tmp49 - } else { - } - tmp42 = tmp48 - } // end let - tmp40 = tmp42 - break - } - } // end let - return tmp40 - }) - tmp40 := lang.Apply(lang.NewLazySeq, []any{tmp39}) - return tmp40 - }) - v37 = tmp36 - _ = v37 - } - var v37 any = tmp36 - _ = v37 - // let binding "fs__1__auto__" - tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp39 := tmp38.FindInternedVar(lang.NewSymbol("seq")) - if tmp39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) - } - tmp40 := tmp39.Get() - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("range")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.Apply(tmp43, []any{int64(0), int64(31)}) - tmp45 := lang.Apply(v37, []any{tmp44}) - tmp46 := lang.Apply(tmp40, []any{tmp45}) - var v47 any = tmp46 - _ = v47 - var tmp48 any - if lang.IsTruthy(v47) { - tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp50 := tmp49.FindInternedVar(lang.NewSymbol("concat")) - if tmp50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) - } - tmp51 := tmp50.Get() - tmp52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp53 := tmp52.FindInternedVar(lang.NewSymbol("rest")) - if tmp53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp53))) - } - tmp54 := tmp53.Get() - tmp55 := lang.Apply(tmp54, []any{v19}) - tmp56 := lang.Apply(v15, []any{tmp55}) - tmp57 := lang.Apply(tmp51, []any{v47, tmp56}) - tmp48 = tmp57 - } else { - tmp59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp60 := tmp59.FindInternedVar(lang.NewSymbol("rest")) - if tmp60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp60))) - } - tmp61 := tmp60.Get() - tmp62 := lang.Apply(tmp61, []any{v19}) - var tmp58 any = tmp62 - v19 = tmp58 - continue - } - tmp35 = tmp48 - } // end let - tmp29 = tmp35 - } // end let - tmp27 = tmp29 - } // end let - tmp26 = tmp27 - } else { - } - tmp20 = tmp26 - } // end let - tmp18 = tmp20 - break - } - } // end let - return tmp18 - }) - tmp18 := lang.Apply(lang.NewLazySeq, []any{tmp17}) - return tmp18 - }) - v15 = tmp14 - _ = v15 - } - var v15 any = tmp14 - _ = v15 - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("map")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - var tmp19 lang.FnFunc - tmp19 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v20 := args[0] - _ = v20 - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("dec")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("bit-shift-left")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.Apply(tmp26, []any{int64(1), v20}) - tmp28 := lang.Apply(tmp23, []any{tmp27}) - return tmp28 - }) - tmp20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6610), lang.NewKeyword("column"), int(29), lang.NewKeyword("end-line"), int(6610), lang.NewKeyword("end-column"), int(55)) - tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("range")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("inc")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("max-mask-bits")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.Apply(tmp27, []any{tmp30}) - tmp32 := lang.Apply(tmp24, []any{int64(1), tmp31}) - tmp33 := lang.Apply(tmp18, []any{tmp21, tmp32}) - tmp34 := lang.Apply(v15, []any{tmp33}) - tmp13 = tmp34 - } // end let - tmp14 := lang.Apply(tmp9, []any{tmp12, tmp13}) - tmp15 := lang.Apply(tmp6, []any{tmp14}) - return tmp15 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // memfn - { - tmp0 := lang.NewSymbol("memfn").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Expands into code that creates a fn that expects to be passed an\n object and any args and calls the named instance method on the\n object passing the args. Use when you want to treat a Java method as\n a first-class fn. name may be type-hinted with the method receiver's\n type in order to avoid reflective calls.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3872), lang.NewKeyword("end-line"), int(3872))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any - { // let - // let binding "t" - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("with-meta")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("gensym")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{"target"}) - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("meta")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{v5}) - tmp19 := lang.Apply(tmp10, []any{tmp14, tmp18}) - var v20 any = tmp19 - _ = v20 - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/fn")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("apply")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("vector")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("seq")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp44 := tmp43.FindInternedVar(lang.NewSymbol("concat")) - if tmp44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) - } - tmp45 := tmp44.Get() - tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp47 := tmp46.FindInternedVar(lang.NewSymbol("list")) - if tmp47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) - } - tmp48 := tmp47.Get() - tmp49 := lang.Apply(tmp48, []any{v20}) - tmp50 := lang.Apply(tmp45, []any{tmp49, v6}) - tmp51 := lang.Apply(tmp42, []any{tmp50}) - tmp52 := lang.Apply(tmp36, []any{tmp39, tmp51}) - tmp53 := lang.Apply(tmp33, []any{tmp52}) - tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp55 := tmp54.FindInternedVar(lang.NewSymbol("list")) - if tmp55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) - } - tmp56 := tmp55.Get() - tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp58 := tmp57.FindInternedVar(lang.NewSymbol("seq")) - if tmp58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) - } - tmp59 := tmp58.Get() - tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp61 := tmp60.FindInternedVar(lang.NewSymbol("concat")) - if tmp61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) - } - tmp62 := tmp61.Get() - tmp63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp64 := tmp63.FindInternedVar(lang.NewSymbol("list")) - if tmp64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp64))) - } - tmp65 := tmp64.Get() - tmp66 := lang.Apply(tmp65, []any{lang.NewSymbol(".")}) - tmp67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp68 := tmp67.FindInternedVar(lang.NewSymbol("list")) - if tmp68.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp68))) - } - tmp69 := tmp68.Get() - tmp70 := lang.Apply(tmp69, []any{v20}) - tmp71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp72 := tmp71.FindInternedVar(lang.NewSymbol("list")) - if tmp72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp72))) - } - tmp73 := tmp72.Get() - tmp74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp75 := tmp74.FindInternedVar(lang.NewSymbol("seq")) - if tmp75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp75))) - } - tmp76 := tmp75.Get() - tmp77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp78 := tmp77.FindInternedVar(lang.NewSymbol("concat")) - if tmp78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp78))) - } - tmp79 := tmp78.Get() - tmp80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp81 := tmp80.FindInternedVar(lang.NewSymbol("list")) - if tmp81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp81))) - } - tmp82 := tmp81.Get() - tmp83 := lang.Apply(tmp82, []any{v5}) - tmp84 := lang.Apply(tmp79, []any{tmp83, v6}) - tmp85 := lang.Apply(tmp76, []any{tmp84}) - tmp86 := lang.Apply(tmp73, []any{tmp85}) - tmp87 := lang.Apply(tmp62, []any{tmp66, tmp70, tmp86}) - tmp88 := lang.Apply(tmp59, []any{tmp87}) - tmp89 := lang.Apply(tmp56, []any{tmp88}) - tmp90 := lang.Apply(tmp26, []any{tmp30, tmp53, tmp89}) - tmp91 := lang.Apply(tmp23, []any{tmp90}) - tmp7 = tmp91 - } // end let - return tmp7 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // memoize - { - tmp0 := lang.NewSymbol("memoize").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Returns a memoized version of a referentially transparent function. The\n memoized version of the function keeps a cache of the mapping from arguments\n to results and, when calls with the same arguments are repeated often, has\n higher performance at the expense of higher memory use.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6337), lang.NewKeyword("end-line"), int(6337))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "mem" - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("atom")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.NewMap() - tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6345), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(6345), lang.NewKeyword("end-column"), int(20)) - tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp11 := lang.Apply(tmp7, []any{tmp10}) - var v12 any = tmp11 - _ = v12 - var tmp13 lang.FnFunc - tmp13 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var v14 any = lang.NewList(args[0:]...) - _ = v14 - var tmp15 any - { // let - // let binding "temp__0__auto__" - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("find")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("deref")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, []any{v12}) - tmp23 := lang.Apply(tmp18, []any{tmp22, v14}) - var v24 any = tmp23 - _ = v24 - var tmp25 any - if lang.IsTruthy(v24) { - var tmp26 any - { // let - // let binding "e" - var v27 any = v24 - _ = v27 - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("val")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.Apply(tmp30, []any{v27}) - tmp26 = tmp31 - } // end let - tmp25 = tmp26 - } else { - var tmp27 any - { // let - // let binding "ret" - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("apply")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.Apply(tmp30, []any{v3, v14}) - var v32 any = tmp31 - _ = v32 - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("swap!")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("assoc")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp35, []any{v12, tmp38, v14, v32}) - _ = tmp39 - tmp27 = v32 - } // end let - tmp25 = tmp27 - } - tmp15 = tmp25 - } // end let - return tmp15 - } - }) - tmp14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6346), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(6351), lang.NewKeyword("end-column"), int(16)) - tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp4 = tmp15 - } // end let - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // merge - { - tmp0 := lang.NewSymbol("merge").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("maps"))), lang.NewKeyword("doc"), "Returns a map that consists of the rest of the maps conj-ed onto\n the first. If a key occurs in more than one map, the mapping from\n the latter (left-to-right) will be the mapping in the result.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3040), lang.NewKeyword("end-line"), int(3040))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var v3 any = lang.NewList(args[0:]...) - _ = v3 - var tmp4 any - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("some")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("identity")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp7, []any{tmp10, v3}) - if lang.IsTruthy(tmp11) { - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - var tmp15 lang.FnFunc - tmp15 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v16 := args[0] - _ = v16 - v17 := args[1] - _ = v17 - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("conj")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - var tmp21 any - { // let - // let binding "or__0__auto__" - var v22 any = v16 - _ = v22 - var tmp23 any - if lang.IsTruthy(v22) { - tmp23 = v22 - } else { - tmp24 := lang.NewMap() - tmp25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3048), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(3048), lang.NewKeyword("end-column"), int(29)) - tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp23 = tmp26 - } - tmp21 = tmp23 - } // end let - tmp22 := lang.Apply(tmp20, []any{tmp21, v17}) - return tmp22 - }) - tmp16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3048), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(3048), lang.NewKeyword("end-column"), int(34)) - tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp18 := lang.Apply(tmp14, []any{tmp17, v3}) - tmp4 = tmp18 - } else { - } - return tmp4 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // merge-hash-collisions - { - tmp0 := lang.NewSymbol("merge-hash-collisions").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr-sym"), lang.NewSymbol("default"), lang.NewSymbol("tests"), lang.NewSymbol("thens"))), lang.NewKeyword("doc"), "Takes a case expression, default expression, and a sequence of test constants\n and a corresponding sequence of then expressions. Returns a tuple of\n [tests thens skip-check-set] where no tests have the same hash. Each set of\n input test constants with the same hash is replaced with a single test\n constant (the case int), and their respective thens are combined into:\n (condp = expr\n test-1 then-1\n ...\n test-n then-n\n default).\n The skip-check is a set of case ints for which post-switch equivalence\n checking must not be done (the cases holding the above condp thens).", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6647), lang.NewKeyword("end-line"), int(6647), lang.NewKeyword("private"), true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - var tmp7 any - { // let - // let binding "buckets" - var tmp8 any - { // let - // let binding "m" - tmp9 := lang.NewMap() - tmp10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6661), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(6661), lang.NewKeyword("end-column"), int(27)) - tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v12 any = tmp11 - _ = v12 - // let binding "ks" - var v13 any = v5 - _ = v13 - // let binding "vs" - var v14 any = v6 - _ = v14 - for { - var tmp15 any - var tmp16 any - { // let - // let binding "and__0__auto__" - var v17 any = v13 - _ = v17 - var tmp18 any - if lang.IsTruthy(v17) { - tmp18 = v14 - } else { - tmp18 = v17 - } - tmp16 = tmp18 - } // end let - if lang.IsTruthy(tmp16) { - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("update")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("first")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.Apply(tmp23, []any{v13}) - tmp25 := lang.Apply(lang.Hash, []any{tmp24}) - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("fnil")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("conj")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.NewVector() - tmp33 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6664), lang.NewKeyword("column"), int(102), lang.NewKeyword("end-line"), int(6664), lang.NewKeyword("end-column"), int(103)) - tmp34, err := lang.WithMeta(tmp32, tmp33.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp35 := lang.Apply(tmp28, []any{tmp31, tmp34}) - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("first")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{v13}) - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("first")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.Apply(tmp42, []any{v14}) - tmp44 := lang.NewVector(tmp39, tmp43) - tmp45 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6664), lang.NewKeyword("column"), int(106), lang.NewKeyword("end-line"), int(6664), lang.NewKeyword("end-column"), int(128)) - tmp46, err := lang.WithMeta(tmp44, tmp45.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp47 := lang.Apply(tmp20, []any{v12, tmp25, tmp35, tmp46}) - var tmp17 any = tmp47 - tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp50 := tmp49.FindInternedVar(lang.NewSymbol("next")) - if tmp50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) - } - tmp51 := tmp50.Get() - tmp52 := lang.Apply(tmp51, []any{v13}) - var tmp48 any = tmp52 - tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp55 := tmp54.FindInternedVar(lang.NewSymbol("next")) - if tmp55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) - } - tmp56 := tmp55.Get() - tmp57 := lang.Apply(tmp56, []any{v14}) - var tmp53 any = tmp57 - v12 = tmp17 - v13 = tmp48 - v14 = tmp53 - continue - } else { - tmp15 = v12 - } - tmp8 = tmp15 - break - } - } // end let - var v9 any = tmp8 - _ = v9 - // let binding "assoc-multi" - var tmp10 lang.FnFunc - tmp10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v11 := args[0] - _ = v11 - v12 := args[1] - _ = v12 - v13 := args[2] - _ = v13 - var tmp14 any - { // let - // let binding "testexprs" - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("mapcat")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - var tmp18 lang.FnFunc - tmp18 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v19 := args[0] - _ = v19 - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("list")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("first")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.Apply(tmp25, []any{v19}) - tmp27 := lang.Apply(tmp22, []any{lang.NewSymbol("quote"), tmp26}) - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("second")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.Apply(tmp30, []any{v19}) - tmp32 := lang.NewVector(tmp27, tmp31) - tmp33 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6668), lang.NewKeyword("column"), int(56), lang.NewKeyword("end-line"), int(6668), lang.NewKeyword("end-column"), int(93)) - tmp34, err := lang.WithMeta(tmp32, tmp33.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp34 - }) - tmp19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6668), lang.NewKeyword("column"), int(47), lang.NewKeyword("end-line"), int(6668), lang.NewKeyword("end-column"), int(94)) - tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp21 := lang.Apply(tmp17, []any{tmp20, v13}) - var v22 any = tmp21 - _ = v22 - // let binding "expr" - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("seq")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("concat")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("list")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.Apply(tmp31, []any{lang.NewSymbol("glojure.core/condp")}) - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("list")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.Apply(tmp35, []any{lang.NewSymbol("glojure.core/=")}) - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("list")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.Apply(tmp39, []any{v3}) - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("list")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.Apply(tmp43, []any{v4}) - tmp45 := lang.Apply(tmp28, []any{tmp32, tmp36, tmp40, v22, tmp44}) - tmp46 := lang.Apply(tmp25, []any{tmp45}) - var v47 any = tmp46 - _ = v47 - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("assoc")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v11, v12, v47}) - tmp14 = tmp51 - } // end let - return tmp14 - }) - tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6667), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(6670), lang.NewKeyword("end-column"), int(42)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v13 any = tmp12 - _ = v13 - // let binding "hmap" - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - var tmp17 lang.FnFunc - tmp17 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v18 := args[0] - _ = v18 - v19 := args[1] - _ = v19 - var tmp20 any - { // let - // let binding "vec__164" - var v21 any = v19 - _ = v21 - // let binding "h" - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("nth")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.Apply(tmp24, []any{v21, int64(0), nil}) - var v26 any = tmp25 - _ = v26 - // let binding "bucket" - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("nth")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{v21, int64(1), nil}) - var v31 any = tmp30 - _ = v31 - var tmp32 any - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("==")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("count")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{v31}) - tmp40 := lang.Apply(tmp35, []any{int64(1), tmp39}) - if lang.IsTruthy(tmp40) { - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("assoc")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("ffirst")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.Apply(tmp46, []any{v31}) - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("second")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp52 := tmp51.FindInternedVar(lang.NewSymbol("first")) - if tmp52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp52))) - } - tmp53 := tmp52.Get() - tmp54 := lang.Apply(tmp53, []any{v31}) - tmp55 := lang.Apply(tmp50, []any{tmp54}) - tmp56 := lang.Apply(tmp43, []any{v18, tmp47, tmp55}) - tmp32 = tmp56 - } else { - tmp57 := lang.Apply(v13, []any{v18, v26, v31}) - tmp32 = tmp57 - } - tmp20 = tmp32 - } // end let - return tmp20 - }) - tmp18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6672), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(6675), lang.NewKeyword("end-column"), int(45)) - tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp20 := lang.NewMap() - tmp21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6676), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(6676), lang.NewKeyword("end-column"), int(17)) - tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp23 := lang.Apply(tmp16, []any{tmp19, tmp22, v9}) - var v24 any = tmp23 - _ = v24 - // let binding "skip-check" - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("into1")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) - tmp29 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6680), lang.NewKeyword("column"), int(29), lang.NewKeyword("end-line"), int(6680), lang.NewKeyword("end-column"), int(31)) - tmp30, err := lang.WithMeta(tmp28, tmp29.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("map")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("first")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("filter")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - var tmp40 lang.FnFunc - tmp40 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v41 := args[0] - _ = v41 - tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp43 := tmp42.FindInternedVar(lang.NewSymbol("<")) - if tmp43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) - } - tmp44 := tmp43.Get() - tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp46 := tmp45.FindInternedVar(lang.NewSymbol("count")) - if tmp46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) - } - tmp47 := tmp46.Get() - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("second")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v41}) - tmp52 := lang.Apply(tmp47, []any{tmp51}) - tmp53 := lang.Apply(tmp44, []any{int64(1), tmp52}) - return tmp53 - }) - tmp41 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6678), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(6678), lang.NewKeyword("end-column"), int(54)) - tmp42, err := lang.WithMeta(tmp40, tmp41.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp43 := lang.Apply(tmp39, []any{tmp42, v9}) - tmp44 := lang.Apply(tmp33, []any{tmp36, tmp43}) - tmp45 := lang.Apply(tmp27, []any{tmp30, tmp44}) - var v46 any = tmp45 - _ = v46 - tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp48 := tmp47.FindInternedVar(lang.NewSymbol("keys")) - if tmp48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) - } - tmp49 := tmp48.Get() - tmp50 := lang.Apply(tmp49, []any{v24}) - tmp51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp52 := tmp51.FindInternedVar(lang.NewSymbol("vals")) - if tmp52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp52))) - } - tmp53 := tmp52.Get() - tmp54 := lang.Apply(tmp53, []any{v24}) - tmp55 := lang.NewVector(tmp50, tmp54, v46) - tmp56 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6681), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(6681), lang.NewKeyword("end-column"), int(40)) - tmp57, err := lang.WithMeta(tmp55, tmp56.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp7 = tmp57 - } // end let - return tmp7 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // merge-with - { - tmp0 := lang.NewSymbol("merge-with").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("maps"))), lang.NewKeyword("doc"), "Returns a map that consists of the rest of the maps conj-ed onto\n the first. If a key occurs in more than one map, the mapping(s)\n from the latter (left-to-right) will be combined with the mapping in\n the result by calling (f val-in-result val-in-latter).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3050), lang.NewKeyword("end-line"), int(3050))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var v4 any = lang.NewList(args[1:]...) - _ = v4 - var tmp5 any - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("some")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("identity")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.Apply(tmp8, []any{tmp11, v4}) - if lang.IsTruthy(tmp12) { - var tmp13 any - { // let - // let binding "merge-entry" - var tmp14 lang.FnFunc - tmp14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v15 := args[0] - _ = v15 - v16 := args[1] - _ = v16 - var tmp17 any - { // let - // let binding "k" - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("key")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.Apply(tmp20, []any{v16}) - var v22 any = tmp21 - _ = v22 - // let binding "v" - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("val")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.Apply(tmp25, []any{v16}) - var v27 any = tmp26 - _ = v27 - var tmp28 any - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("contains?")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.Apply(tmp31, []any{v15, v22}) - if lang.IsTruthy(tmp32) { - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("assoc")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("get")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{v15, v22}) - tmp40 := lang.Apply(v3, []any{tmp39, v27}) - tmp41 := lang.Apply(tmp35, []any{v15, v22, tmp40}) - tmp28 = tmp41 - } else { - tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp43 := tmp42.FindInternedVar(lang.NewSymbol("assoc")) - if tmp43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) - } - tmp44 := tmp43.Get() - tmp45 := lang.Apply(tmp44, []any{v15, v22, v27}) - tmp28 = tmp45 - } - tmp17 = tmp28 - } // end let - return tmp17 - }) - tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3059), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(3063), lang.NewKeyword("end-column"), int(23)) - tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v17 any = tmp16 - _ = v17 - // let binding "merge2" - var tmp18 lang.FnFunc - tmp18 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v19 := args[0] - _ = v19 - v20 := args[1] - _ = v20 - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - var tmp24 any - { // let - // let binding "or__0__auto__" - var v25 any = v19 - _ = v25 - var tmp26 any - if lang.IsTruthy(v25) { - tmp26 = v25 - } else { - tmp27 := lang.NewMap() - tmp28 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3065), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(3065), lang.NewKeyword("end-column"), int(35)) - tmp29, err := lang.WithMeta(tmp27, tmp28.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp26 = tmp29 - } - tmp24 = tmp26 - } // end let - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("seq")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.Apply(tmp27, []any{v20}) - tmp29 := lang.Apply(tmp23, []any{v17, tmp24, tmp28}) - return tmp29 - }) - tmp19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3064), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(3065), lang.NewKeyword("end-column"), int(47)) - tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v21 any = tmp20 - _ = v21 - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.Apply(tmp24, []any{v21, v4}) - tmp13 = tmp25 - } // end let - tmp5 = tmp13 - } else { - } - return tmp5 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // meta - { - tmp0 := lang.NewSymbol("meta").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("obj"))), lang.NewKeyword("doc"), "Returns the metadata of obj, returns nil if there is no metadata.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(202), lang.NewKeyword("end-line"), int(206))).(*lang.Symbol) - var tmp2 lang.FnFunc - { // function meta - var v3 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - var tmp5 any - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("instance?")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := reflect.TypeOf((*lang.IMeta)(nil)).Elem() - tmp10 := lang.Apply(tmp8, []any{tmp9, v4}) - if lang.IsTruthy(tmp10) { - tmp11, ok := lang.FieldOrMethod(v4, "Meta") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "Meta"))) - } - var tmp12 any - switch reflect.TypeOf(tmp11).Kind() { - case reflect.Func: - tmp12 = lang.Apply(tmp11, nil) - default: - tmp12 = tmp11 - } - tmp5 = tmp12 - } else { - } - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(206), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(208), lang.NewKeyword("end-column"), int(21))).(lang.FnFunc) - v3 = tmp2 - _ = v3 - } - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // methods - { - tmp0 := lang.NewSymbol("methods").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"))), lang.NewKeyword("doc"), "Given a multimethod, returns a map of dispatch values -> dispatch fns", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1809), lang.NewKeyword("end-line"), int(1809))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4, ok := lang.FieldOrMethod(v3, "getMethodTable") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getMethodTable"))) - } - var tmp5 any - switch reflect.TypeOf(tmp4).Kind() { - case reflect.Func: - tmp5 = lang.Apply(tmp4, nil) - default: - tmp5 = tmp4 - } - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // min - { - var tmp1 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v2 := args[0] - _ = v2 - var tmp3 any - { // let - // let binding "op" - var tmp4 any - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - if lang.IsTruthy(tmp7) { - tmp4 = closed15 - } else { - tmp4 = closed15 - } - var v8 any = tmp4 - _ = v8 - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("seq")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("concat")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol(".")}) - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("seq")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("concat")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.Apply(tmp34, []any{v8}) - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{v2}) - tmp40 := lang.Apply(tmp31, []any{tmp35, tmp39}) - tmp41 := lang.Apply(tmp28, []any{tmp40}) - tmp42 := lang.Apply(tmp25, []any{tmp41}) - tmp43 := lang.Apply(tmp14, []any{tmp18, tmp22, tmp42}) - tmp44 := lang.Apply(tmp11, []any{tmp43}) - tmp3 = tmp44 - } // end let - return tmp3 - case 2: - v2 := args[0] - _ = v2 - v3 := args[1] - _ = v3 - var tmp4 any - { // let - // let binding "op" - var tmp5 any - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - if lang.IsTruthy(tmp8) { - tmp5 = closed15 - } else { - tmp5 = closed15 - } - var v9 any = tmp5 - _ = v9 - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("seq")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("concat")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("list")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{lang.NewSymbol(".")}) - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("list")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.Apply(tmp22, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("list")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("seq")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("concat")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("list")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.Apply(tmp35, []any{v9}) - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("list")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.Apply(tmp39, []any{v2}) - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("list")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.Apply(tmp43, []any{v3}) - tmp45 := lang.Apply(tmp32, []any{tmp36, tmp40, tmp44}) - tmp46 := lang.Apply(tmp29, []any{tmp45}) - tmp47 := lang.Apply(tmp26, []any{tmp46}) - tmp48 := lang.Apply(tmp15, []any{tmp19, tmp23, tmp47}) - tmp49 := lang.Apply(tmp12, []any{tmp48}) - tmp4 = tmp49 - } // end let - return tmp4 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v2 := args[0] - _ = v2 - v3 := args[1] - _ = v3 - var v4 any = lang.NewList(args[2:]...) - _ = v4 - var tmp5 any - { // let - // let binding "op" - var tmp6 any - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - if lang.IsTruthy(tmp9) { - tmp6 = closed15 - } else { - tmp6 = closed15 - } - var v10 any = tmp6 - _ = v10 - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - var tmp14 lang.FnFunc - tmp14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v15 := args[0] - _ = v15 - v16 := args[1] - _ = v16 - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("concat")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol(".")}) - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.Apply(tmp42, []any{v10}) - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.Apply(tmp46, []any{v15}) - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v16}) - tmp52 := lang.Apply(tmp39, []any{tmp43, tmp47, tmp51}) - tmp53 := lang.Apply(tmp36, []any{tmp52}) - tmp54 := lang.Apply(tmp33, []any{tmp53}) - tmp55 := lang.Apply(tmp22, []any{tmp26, tmp30, tmp54}) - tmp56 := lang.Apply(tmp19, []any{tmp55}) - return tmp56 - }) - tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) - tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("concat")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol(".")}) - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.Apply(tmp42, []any{v10}) - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.Apply(tmp46, []any{v2}) - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v3}) - tmp52 := lang.Apply(tmp39, []any{tmp43, tmp47, tmp51}) - tmp53 := lang.Apply(tmp36, []any{tmp52}) - tmp54 := lang.Apply(tmp33, []any{tmp53}) - tmp55 := lang.Apply(tmp22, []any{tmp26, tmp30, tmp54}) - tmp56 := lang.Apply(tmp19, []any{tmp55}) - tmp57 := lang.Apply(tmp13, []any{tmp16, tmp56, v4}) - tmp5 = tmp57 - } // end let - return tmp5 - } - }) - tmp1 = tmp1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) - } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp0 := lang.NewSymbol("min").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the least of the nums.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), tmp2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1118), lang.NewKeyword("end-line"), int(1118))).(*lang.Symbol) - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v5 := args[0] - _ = v5 - return v5 - case 2: - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - tmp7, _ := lang.FieldOrMethod(lang.Numbers, "Min") - if reflect.TypeOf(tmp7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Min is not a function"))) - } - tmp8 := lang.Apply(tmp7, []any{v5, v6}) - return tmp8 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - var v7 any = lang.NewList(args[2:]...) - _ = v7 - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("min")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("min")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{v5, v6}) - tmp18 := lang.Apply(tmp10, []any{tmp13, tmp17, v7}) - return tmp18 - } - }) - tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp3 := ns.InternWithValue(tmp0, tmp4, true) - if tmp0.Meta() != nil { - tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // min-key - { - tmp0 := lang.NewSymbol("min-key").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Returns the x for which (k x), a number, is least.\n\n If there are multiple such xs, the last one is returned.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5033), lang.NewKeyword("end-line"), int(5033))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - return v4 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var tmp6 any - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("<")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(v3, []any{v4}) - tmp11 := lang.Apply(v3, []any{v5}) - tmp12 := lang.Apply(tmp9, []any{tmp10, tmp11}) - if lang.IsTruthy(tmp12) { - tmp6 = v4 - } else { - tmp6 = v5 - } - return tmp6 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any - { // let - // let binding "kx" - tmp8 := lang.Apply(v3, []any{v4}) - var v9 any = tmp8 - _ = v9 - // let binding "ky" - tmp10 := lang.Apply(v3, []any{v5}) - var v11 any = tmp10 - _ = v11 - // let binding "vec__58" - var tmp12 any - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("<")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{v9, v11}) - if lang.IsTruthy(tmp16) { - tmp17 := lang.NewVector(v4, v9) - tmp18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5043), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(5043), lang.NewKeyword("end-column"), int(36)) - tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp12 = tmp19 - } else { - tmp20 := lang.NewVector(v5, v11) - tmp21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5043), lang.NewKeyword("column"), int(38), lang.NewKeyword("end-line"), int(5043), lang.NewKeyword("end-column"), int(43)) - tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp12 = tmp22 - } - var v23 any = tmp12 - _ = v23 - // let binding "v" - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("nth")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.Apply(tmp26, []any{v23, int64(0), nil}) - var v28 any = tmp27 - _ = v28 - // let binding "kv" - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("nth")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.Apply(tmp31, []any{v23, int64(1), nil}) - var v33 any = tmp32 - _ = v33 - var tmp34 any - { // let - // let binding "v" - var v35 any = v28 - _ = v35 - // let binding "kv" - var v36 any = v33 - _ = v36 - // let binding "more" - var v37 any = v6 - _ = v37 - for { - var tmp38 any - if lang.IsTruthy(v37) { - var tmp39 any - { // let - // let binding "w" - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("first")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.Apply(tmp42, []any{v37}) - var v44 any = tmp43 - _ = v44 - // let binding "kw" - tmp45 := lang.Apply(v3, []any{v44}) - var v46 any = tmp45 - _ = v46 - var tmp47 any - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("<=")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v46, v36}) - if lang.IsTruthy(tmp51) { - var tmp52 any = v44 - var tmp53 any = v46 - tmp55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp56 := tmp55.FindInternedVar(lang.NewSymbol("next")) - if tmp56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp56))) - } - tmp57 := tmp56.Get() - tmp58 := lang.Apply(tmp57, []any{v37}) - var tmp54 any = tmp58 - v35 = tmp52 - v36 = tmp53 - v37 = tmp54 - continue - } else { - var tmp59 any = v35 - var tmp60 any = v36 - tmp62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp63 := tmp62.FindInternedVar(lang.NewSymbol("next")) - if tmp63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp63))) - } - tmp64 := tmp63.Get() - tmp65 := lang.Apply(tmp64, []any{v37}) - var tmp61 any = tmp65 - v35 = tmp59 - v36 = tmp60 - v37 = tmp61 - continue - } - tmp39 = tmp47 - } // end let - tmp38 = tmp39 - } else { - tmp38 = v35 - } - tmp34 = tmp38 - break - } - } // end let - tmp7 = tmp34 - } // end let - return tmp7 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // mix-collection-hash - { - tmp0 := lang.NewSymbol("mix-collection-hash").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("hash-basis"), lang.NewSymbol("count"))), lang.NewKeyword("doc"), "Mix final collection hash for ordered or unordered collections.\n hash-basis is the combined collection hash, count is the number\n of elements included in the basis. Note this is the hash code\n consistent with =, different from .hashCode.\n See http://glojure.org/data_structures#hash for full algorithms.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5199), lang.NewKeyword("end-line"), int(5199))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.Apply(nil, []any{v3, v4}) - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // mk-bound-fn - { - tmp0 := lang.NewSymbol("mk-bound-fn").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5127), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(5127), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sc"), lang.NewSymbol("test"), lang.NewSymbol("key"))), lang.NewKeyword("private"), true, lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var tmp6 lang.FnFunc - tmp6 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v7 := args[0] - _ = v7 - tmp8, ok := lang.FieldOrMethod(v3, "comparator") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "comparator"))) - } - var tmp9 any - switch reflect.TypeOf(tmp8).Kind() { - case reflect.Func: - tmp9 = lang.Apply(tmp8, nil) - default: - tmp9 = tmp8 - } - tmp10, _ := lang.FieldOrMethod(v3, "entryKey") - if reflect.TypeOf(tmp10).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("entryKey is not a function"))) - } - tmp11 := lang.Apply(tmp10, []any{v7}) - tmp12, _ := lang.FieldOrMethod(tmp9, "compare") - if reflect.TypeOf(tmp12).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("compare is not a function"))) - } - tmp13 := lang.Apply(tmp12, []any{tmp11, v5}) - tmp14 := lang.Apply(v4, []any{tmp13, int64(0)}) - return tmp14 - }) - tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5130), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(5131), lang.NewKeyword("end-column"), int(64)) - tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp8 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // mod - { - tmp0 := lang.NewSymbol("mod").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"), lang.NewSymbol("div"))), lang.NewKeyword("doc"), "Modulus of num and div. Truncates toward negative infinity.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3567), lang.NewKeyword("end-line"), int(3567))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - { // let - // let binding "m" - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("rem")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(tmp8, []any{v3, v4}) - var v10 any = tmp9 - _ = v10 - var tmp11 any - var tmp12 any - { // let - // let binding "or__0__auto__" - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("zero?")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{v10}) - var v17 any = tmp16 - _ = v17 - var tmp18 any - if lang.IsTruthy(v17) { - tmp18 = v17 - } else { - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("=")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("pos?")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.Apply(tmp24, []any{v3}) - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("pos?")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.Apply(tmp28, []any{v4}) - tmp30 := lang.Apply(tmp21, []any{tmp25, tmp29}) - tmp18 = tmp30 - } - tmp12 = tmp18 - } // end let - if lang.IsTruthy(tmp12) { - tmp11 = v10 - } else { - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("+")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{v10, v4}) - tmp11 = tmp16 - } - tmp5 = tmp11 - } // end let - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // name - { - tmp1 := reflect.TypeOf("") - tmp0 := lang.NewSymbol("name").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns the name String of a string, symbol or keyword.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1585), lang.NewKeyword("end-line"), int(1585))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - var tmp5 any - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("string?")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(tmp8, []any{v4}) - if lang.IsTruthy(tmp9) { - tmp5 = v4 - } else { - tmp10, _ := lang.FieldOrMethod(v4, "Name") - if reflect.TypeOf(tmp10).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Name is not a function"))) - } - tmp11 := lang.Apply(tmp10, []any{}) - tmp5 = tmp11 - } - return tmp5 - }) - tmp4 := reflect.TypeOf("") - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // namespace - { - tmp1 := reflect.TypeOf("") - tmp0 := lang.NewSymbol("namespace").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns the namespace String of a symbol or keyword, or nil if not present.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1593), lang.NewKeyword("end-line"), int(1593))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(v4, "Namespace") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Namespace is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{}) - return tmp6 - }) - tmp4 := reflect.TypeOf("") - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // nary-inline - { - tmp0 := lang.NewSymbol("nary-inline").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(948), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(948), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("op")), lang.NewVector(lang.NewSymbol("op"), lang.NewSymbol("unchecked-op"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("nary-inline")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.Apply(tmp6, []any{v3, v3}) - return tmp7 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 lang.FnFunc - tmp5 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v6 := args[0] - _ = v6 - var tmp7 any - { // let - // let binding "op" - var tmp8 any - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - if lang.IsTruthy(tmp11) { - tmp8 = v4 - } else { - tmp8 = v3 - } - var v12 any = tmp8 - _ = v12 - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("seq")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("concat")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol(".")}) - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("seq")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("concat")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{v12}) - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.Apply(tmp42, []any{v6}) - tmp44 := lang.Apply(tmp35, []any{tmp39, tmp43}) - tmp45 := lang.Apply(tmp32, []any{tmp44}) - tmp46 := lang.Apply(tmp29, []any{tmp45}) - tmp47 := lang.Apply(tmp18, []any{tmp22, tmp26, tmp46}) - tmp48 := lang.Apply(tmp15, []any{tmp47}) - tmp7 = tmp48 - } // end let - return tmp7 - case 2: - v6 := args[0] - _ = v6 - v7 := args[1] - _ = v7 - var tmp8 any - { // let - // let binding "op" - var tmp9 any - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - if lang.IsTruthy(tmp12) { - tmp9 = v4 - } else { - tmp9 = v3 - } - var v13 any = tmp9 - _ = v13 - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("seq")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("concat")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("list")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.Apply(tmp22, []any{lang.NewSymbol(".")}) - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("list")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.Apply(tmp26, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("list")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("seq")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("concat")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("list")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.Apply(tmp39, []any{v13}) - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("list")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.Apply(tmp43, []any{v6}) - tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp46 := tmp45.FindInternedVar(lang.NewSymbol("list")) - if tmp46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) - } - tmp47 := tmp46.Get() - tmp48 := lang.Apply(tmp47, []any{v7}) - tmp49 := lang.Apply(tmp36, []any{tmp40, tmp44, tmp48}) - tmp50 := lang.Apply(tmp33, []any{tmp49}) - tmp51 := lang.Apply(tmp30, []any{tmp50}) - tmp52 := lang.Apply(tmp19, []any{tmp23, tmp27, tmp51}) - tmp53 := lang.Apply(tmp16, []any{tmp52}) - tmp8 = tmp53 - } // end let - return tmp8 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v6 := args[0] - _ = v6 - v7 := args[1] - _ = v7 - var v8 any = lang.NewList(args[2:]...) - _ = v8 - var tmp9 any - { // let - // let binding "op" - var tmp10 any - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - if lang.IsTruthy(tmp13) { - tmp10 = v4 - } else { - tmp10 = v3 - } - var v14 any = tmp10 - _ = v14 - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - var tmp18 lang.FnFunc - tmp18 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v19 := args[0] - _ = v19 - v20 := args[1] - _ = v20 - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol(".")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp36 := tmp35.FindInternedVar(lang.NewSymbol("list")) - if tmp36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) - } - tmp37 := tmp36.Get() - tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp39 := tmp38.FindInternedVar(lang.NewSymbol("seq")) - if tmp39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) - } - tmp40 := tmp39.Get() - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("concat")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.Apply(tmp46, []any{v14}) - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v19}) - tmp52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp53 := tmp52.FindInternedVar(lang.NewSymbol("list")) - if tmp53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp53))) - } - tmp54 := tmp53.Get() - tmp55 := lang.Apply(tmp54, []any{v20}) - tmp56 := lang.Apply(tmp43, []any{tmp47, tmp51, tmp55}) - tmp57 := lang.Apply(tmp40, []any{tmp56}) - tmp58 := lang.Apply(tmp37, []any{tmp57}) - tmp59 := lang.Apply(tmp26, []any{tmp30, tmp34, tmp58}) - tmp60 := lang.Apply(tmp23, []any{tmp59}) - return tmp60 - }) - tmp19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) - tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol(".")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp36 := tmp35.FindInternedVar(lang.NewSymbol("list")) - if tmp36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) - } - tmp37 := tmp36.Get() - tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp39 := tmp38.FindInternedVar(lang.NewSymbol("seq")) - if tmp39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) - } - tmp40 := tmp39.Get() - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("concat")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.Apply(tmp46, []any{v14}) - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v6}) - tmp52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp53 := tmp52.FindInternedVar(lang.NewSymbol("list")) - if tmp53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp53))) - } - tmp54 := tmp53.Get() - tmp55 := lang.Apply(tmp54, []any{v7}) - tmp56 := lang.Apply(tmp43, []any{tmp47, tmp51, tmp55}) - tmp57 := lang.Apply(tmp40, []any{tmp56}) - tmp58 := lang.Apply(tmp37, []any{tmp57}) - tmp59 := lang.Apply(tmp26, []any{tmp30, tmp34, tmp58}) - tmp60 := lang.Apply(tmp23, []any{tmp59}) - tmp61 := lang.Apply(tmp17, []any{tmp20, tmp60, v8}) - tmp9 = tmp61 - } // end let - return tmp9 - } - }) - tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86)) - tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp7 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // nat-int? - { - tmp0 := lang.NewSymbol("nat-int?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a non-negative fixed precision integer", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1415), lang.NewKeyword("end-line"), int(1415))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "and__0__auto__" - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("int?")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v3}) - var v9 any = tmp8 - _ = v9 - var tmp10 any - if lang.IsTruthy(v9) { - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("not")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("neg?")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{v3}) - tmp18 := lang.Apply(tmp13, []any{tmp17}) - tmp10 = tmp18 - } else { - tmp10 = v9 - } - tmp4 = tmp10 - } // end let - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // neg-int? - { - tmp0 := lang.NewSymbol("neg-int?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a negative fixed precision integer", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1409), lang.NewKeyword("end-line"), int(1409))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "and__0__auto__" - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("int?")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v3}) - var v9 any = tmp8 - _ = v9 - var tmp10 any - if lang.IsTruthy(v9) { - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("neg?")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{v3}) - tmp10 = tmp14 - } else { - tmp10 = v9 - } - tmp4 = tmp10 - } // end let - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // neg? - { - var tmp1 lang.FnFunc - { // function neg?__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/IsNeg")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{v3}) - tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) - tmp36 := lang.Apply(tmp23, []any{tmp35}) - tmp37 := lang.Apply(tmp20, []any{tmp36}) - tmp38 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp37}) - tmp39 := lang.Apply(tmp6, []any{tmp38}) - return tmp39 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("neg?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns true if num is less than zero, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1259), lang.NewKeyword("end-line"), int(1259))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "IsNeg") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("IsNeg is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // newline - { - tmp0 := lang.NewSymbol("newline").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Writes a platform-specific newline to *out*", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3698), lang.NewKeyword("end-line"), int(3698))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - tmp3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp4 := tmp3.FindInternedVar(lang.NewSymbol("*out*")) - if tmp4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp4))) - } - tmp5 := tmp4.Get() - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("system-newline")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(lang.AppendWriter, []any{tmp5, tmp8}) - _ = tmp9 - return nil - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // next - { - tmp1 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() - tmp0 := lang.NewSymbol("next").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a seq of the items after the first. Calls seq on its\n argument. If there are no more items, returns nil.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(55), lang.NewKeyword("end-line"), int(61))).(*lang.Symbol) - var tmp3 lang.FnFunc - { // function next - var v4 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v5 := args[0] - _ = v5 - tmp6 := lang.Apply(lang.Next, []any{v5}) - return tmp6 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(61), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(61), lang.NewKeyword("end-column"), int(77))).(lang.FnFunc) - v4 = tmp3 - _ = v4 - } - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // nfirst - { - tmp0 := lang.NewSymbol("nfirst").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Same as (next (first x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(105), lang.NewKeyword("end-line"), int(109))).(*lang.Symbol) - var tmp2 lang.FnFunc - { // function nfirst - var v3 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("next")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("first")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v4}) - tmp12 := lang.Apply(tmp7, []any{tmp11}) - return tmp12 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(109), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(109), lang.NewKeyword("end-column"), int(49))).(lang.FnFunc) - v3 = tmp2 - _ = v3 - } - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // nil? - { - tmp1 := reflect.TypeOf(false) - var tmp2 lang.FnFunc - { // function nil?__inliner - var v3 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("list")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Identical"), v4, nil}) - return tmp8 - }) - v3 = tmp2 - _ = v3 - } - tmp0 := lang.NewSymbol("nil?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp2, lang.NewKeyword("doc"), "Returns true if x is nil, false otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(435), lang.NewKeyword("end-line"), int(435))).(*lang.Symbol) - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v5 := args[0] - _ = v5 - tmp6 := lang.Apply(lang.IsNil, []any{v5}) - return tmp6 - }) - tmp5 := reflect.TypeOf(false) - tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp5)).(lang.FnFunc) - tmp3 := ns.InternWithValue(tmp0, tmp4, true) - if tmp0.Meta() != nil { - tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // nnext - { - tmp0 := lang.NewSymbol("nnext").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Same as (next (next x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(119), lang.NewKeyword("end-line"), int(123))).(*lang.Symbol) - var tmp2 lang.FnFunc - { // function nnext - var v3 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("next")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("next")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v4}) - tmp12 := lang.Apply(tmp7, []any{tmp11}) - return tmp12 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(123), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(123), lang.NewKeyword("end-column"), int(46))).(lang.FnFunc) - v3 = tmp2 - _ = v3 - } - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // normalize-slurp-opts - { - tmp0 := lang.NewSymbol("normalize-slurp-opts").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6974), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(6974), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("opts"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("string?")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("first")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v3}) - tmp12 := lang.Apply(tmp7, []any{tmp11}) - if lang.IsTruthy(tmp12) { - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("println")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{"WARNING: (slurp f enc) is deprecated, use (slurp f :encoding enc)."}) - _ = tmp16 - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("first")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.Apply(tmp19, []any{v3}) - tmp21 := lang.NewVector(lang.NewKeyword("encoding"), tmp20) - tmp22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6979), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(6979), lang.NewKeyword("end-column"), int(30)) - tmp23, err := lang.WithMeta(tmp21, tmp22.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp4 = tmp23 - } else { - tmp4 = v3 - } - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // not - { - tmp1 := reflect.TypeOf(false) - tmp0 := lang.NewSymbol("not").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is logical false, false otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(523), lang.NewKeyword("end-line"), int(523))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - var tmp5 any - if lang.IsTruthy(v4) { - tmp5 = false - } else { - tmp5 = true - } - return tmp5 - }) - tmp4 := reflect.TypeOf(false) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // not-any? - { - tmp1 := reflect.TypeOf(false) - tmp0 := lang.NewSymbol("not-any?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns false if (pred x) is logical true for any x in coll,\n else true.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(2696), lang.NewKeyword("end-line"), int(2701))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp4 := lang.Apply(closed17, nil) - tmp5 := lang.Apply(closed16, []any{tmp4}) - return tmp5 - case 1: - v4 := args[0] - _ = v4 - tmp5 := lang.Apply(closed17, []any{v4}) - tmp6 := lang.Apply(closed16, []any{tmp5}) - return tmp6 - case 2: - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6 := lang.Apply(closed17, []any{v4, v5}) - tmp7 := lang.Apply(closed16, []any{tmp6}) - return tmp7 - case 3: - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - v6 := args[2] - _ = v6 - tmp7 := lang.Apply(closed17, []any{v4, v5, v6}) - tmp8 := lang.Apply(closed16, []any{tmp7}) - return tmp8 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - v6 := args[2] - _ = v6 - var v7 any = lang.NewList(args[3:]...) - _ = v7 - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("apply")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{closed17, v4, v5, v6, v7}) - tmp12 := lang.Apply(closed16, []any{tmp11}) - return tmp12 - } - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2559), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2564), lang.NewKeyword("end-column"), int(49))).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // not-empty - { - tmp0 := lang.NewSymbol("not-empty").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "If coll is empty, returns nil, else coll", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5516), lang.NewKeyword("end-line"), int(5516))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v3}) - if lang.IsTruthy(tmp8) { - tmp4 = v3 - } else { - } - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // not-every? - { - tmp1 := reflect.TypeOf(false) - tmp0 := lang.NewSymbol("not-every?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns false if (pred x) is logical true for every x in\n coll, else true.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(2677), lang.NewKeyword("end-line"), int(2682))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp4 := lang.Apply(closed18, nil) - tmp5 := lang.Apply(closed16, []any{tmp4}) - return tmp5 - case 1: - v4 := args[0] - _ = v4 - tmp5 := lang.Apply(closed18, []any{v4}) - tmp6 := lang.Apply(closed16, []any{tmp5}) - return tmp6 - case 2: - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6 := lang.Apply(closed18, []any{v4, v5}) - tmp7 := lang.Apply(closed16, []any{tmp6}) - return tmp7 - case 3: - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - v6 := args[2] - _ = v6 - tmp7 := lang.Apply(closed18, []any{v4, v5, v6}) - tmp8 := lang.Apply(closed16, []any{tmp7}) - return tmp8 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - v6 := args[2] - _ = v6 - var v7 any = lang.NewList(args[3:]...) - _ = v7 - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("apply")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{closed18, v4, v5, v6, v7}) - tmp12 := lang.Apply(closed16, []any{tmp11}) - return tmp12 - } - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2559), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2564), lang.NewKeyword("end-column"), int(49))).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // not= - { - tmp1 := reflect.TypeOf(false) - tmp0 := lang.NewSymbol("not=").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Same as (not (= obj1 obj2))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(812), lang.NewKeyword("end-line"), int(812))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v4 := args[0] - _ = v4 - return false - case 2: - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("not")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("=")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.Apply(tmp11, []any{v4, v5}) - tmp13 := lang.Apply(tmp8, []any{tmp12}) - return tmp13 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - var v6 any = lang.NewList(args[2:]...) - _ = v6 - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("not")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("apply")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("=")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp12, []any{tmp15, v4, v5, v6}) - tmp17 := lang.Apply(tmp9, []any{tmp16}) - return tmp17 - } - }) - tmp4 := reflect.TypeOf(false) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // ns - { - tmp0 := lang.NewSymbol("ns").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("docstring?"), lang.NewSymbol("attr-map?"), lang.NewSymbol("references*"))), lang.NewKeyword("doc"), "Sets *ns* to the namespace named by name (unevaluated), creating it\n if needed. references can be zero or more of: (:refer-glojure ...)\n (:require ...) (:use ...) (:import ...) (:load ...) (:gen-class)\n with the syntax of refer-glojure/require/use/import/load/gen-class\n respectively, except the arguments are unevaluated and need not be\n quoted. (:gen-class ...), when supplied, defaults to :name\n corresponding to the ns name, :main true, :impl-ns same as ns, and\n :init-impl-ns true. All options of gen-class are\n supported. The :gen-class directive is ignored when not\n compiling. If :gen-class is not supplied, when compiled only an\n nsname__init.class will be generated. If :refer-glojure is not used, a\n default (refer 'glojure.core) is used. Use of ns is preferred to\n individual calls to in-ns/require/use/import:\n\n (ns foo.bar\n (:refer-glojure :exclude [ancestors printf])\n (:require (glojure.contrib sql combinatorics))\n (:use (my.lib this that))\n (:import (java.util Date Timer Random)\n (java.sql Connection Statement)))", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5742), lang.NewKeyword("end-line"), int(5742))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any - { // let - // let binding "process-reference" - var tmp8 lang.FnFunc - tmp8 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v9 := args[0] - _ = v9 - var tmp10 any - { // let - // let binding "vec__107" - var v11 any = v9 - _ = v11 - // let binding "seq__108" - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("seq")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.Apply(tmp14, []any{v11}) - var v16 any = tmp15 - _ = v16 - // let binding "first__109" - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("first")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.Apply(tmp19, []any{v16}) - var v21 any = tmp20 - _ = v21 - // let binding "seq__108" - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("next")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.Apply(tmp24, []any{v16}) - var v26 any = tmp25 - _ = v26 - // let binding "kname" - var v27 any = v21 - _ = v27 - // let binding "args" - var v28 any = v26 - _ = v28 - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("seq")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("concat")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp36 := tmp35.FindInternedVar(lang.NewSymbol("list")) - if tmp36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) - } - tmp37 := tmp36.Get() - tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp39 := tmp38.FindInternedVar(lang.NewSymbol("symbol")) - if tmp39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) - } - tmp40 := tmp39.Get() - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("name")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.Apply(tmp43, []any{v27}) - tmp45 := lang.Apply(tmp40, []any{"glojure.core", tmp44}) - tmp46 := lang.Apply(tmp37, []any{tmp45}) - tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp48 := tmp47.FindInternedVar(lang.NewSymbol("map")) - if tmp48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) - } - tmp49 := tmp48.Get() - var tmp50 lang.FnFunc - tmp50 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v51 := args[0] - _ = v51 - tmp52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp53 := tmp52.FindInternedVar(lang.NewSymbol("list")) - if tmp53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp53))) - } - tmp54 := tmp53.Get() - tmp55 := lang.Apply(tmp54, []any{lang.NewSymbol("quote"), v51}) - return tmp55 - }) - tmp51 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5769), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(5769), lang.NewKeyword("end-column"), int(36)) - tmp52, err := lang.WithMeta(tmp50, tmp51.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp53 := lang.Apply(tmp49, []any{tmp52, v28}) - tmp54 := lang.Apply(tmp34, []any{tmp46, tmp53}) - tmp55 := lang.Apply(tmp31, []any{tmp54}) - tmp10 = tmp55 - } // end let - return tmp10 - }) - tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5767), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(5769), lang.NewKeyword("end-column"), int(44)) - tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v11 any = tmp10 - _ = v11 - // let binding "docstring" - var tmp12 any - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("string?")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("first")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{v6}) - tmp20 := lang.Apply(tmp15, []any{tmp19}) - if lang.IsTruthy(tmp20) { - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("first")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.Apply(tmp23, []any{v6}) - tmp12 = tmp24 - } else { - } - var v25 any = tmp12 - _ = v25 - // let binding "references" - var tmp26 any - if lang.IsTruthy(v25) { - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("next")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{v6}) - tmp26 = tmp30 - } else { - tmp26 = v6 - } - var v31 any = tmp26 - _ = v31 - // let binding "name" - var tmp32 any - if lang.IsTruthy(v25) { - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("vary-meta")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("assoc")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp35, []any{v5, tmp38, lang.NewKeyword("doc"), v25}) - tmp32 = tmp39 - } else { - tmp32 = v5 - } - var v40 any = tmp32 - _ = v40 - // let binding "metadata" - var tmp41 any - tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp43 := tmp42.FindInternedVar(lang.NewSymbol("map?")) - if tmp43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) - } - tmp44 := tmp43.Get() - tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp46 := tmp45.FindInternedVar(lang.NewSymbol("first")) - if tmp46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) - } - tmp47 := tmp46.Get() - tmp48 := lang.Apply(tmp47, []any{v31}) - tmp49 := lang.Apply(tmp44, []any{tmp48}) - if lang.IsTruthy(tmp49) { - tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp51 := tmp50.FindInternedVar(lang.NewSymbol("first")) - if tmp51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) - } - tmp52 := tmp51.Get() - tmp53 := lang.Apply(tmp52, []any{v31}) - tmp41 = tmp53 - } else { - } - var v54 any = tmp41 - _ = v54 - // let binding "references" - var tmp55 any - if lang.IsTruthy(v54) { - tmp56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp57 := tmp56.FindInternedVar(lang.NewSymbol("next")) - if tmp57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp57))) - } - tmp58 := tmp57.Get() - tmp59 := lang.Apply(tmp58, []any{v31}) - tmp55 = tmp59 - } else { - tmp55 = v31 - } - var v60 any = tmp55 - _ = v60 - // let binding "name" - var tmp61 any - if lang.IsTruthy(v54) { - tmp62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp63 := tmp62.FindInternedVar(lang.NewSymbol("vary-meta")) - if tmp63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp63))) - } - tmp64 := tmp63.Get() - tmp65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp66 := tmp65.FindInternedVar(lang.NewSymbol("merge")) - if tmp66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp66))) - } - tmp67 := tmp66.Get() - tmp68 := lang.Apply(tmp64, []any{v40, tmp67, v54}) - tmp61 = tmp68 - } else { - tmp61 = v40 - } - var v69 any = tmp61 - _ = v69 - // let binding "gen-class-clause" - tmp70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp71 := tmp70.FindInternedVar(lang.NewSymbol("first")) - if tmp71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp71))) - } - tmp72 := tmp71.Get() - tmp73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp74 := tmp73.FindInternedVar(lang.NewSymbol("filter")) - if tmp74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp74))) - } - tmp75 := tmp74.Get() - var tmp76 lang.FnFunc - tmp76 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v77 := args[0] - _ = v77 - tmp78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp79 := tmp78.FindInternedVar(lang.NewSymbol("=")) - if tmp79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp79))) - } - tmp80 := tmp79.Get() - tmp81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp82 := tmp81.FindInternedVar(lang.NewSymbol("first")) - if tmp82.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp82))) - } - tmp83 := tmp82.Get() - tmp84 := lang.Apply(tmp83, []any{v77}) - tmp85 := lang.Apply(tmp80, []any{lang.NewKeyword("gen-class"), tmp84}) - return tmp85 - }) - tmp77 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5780), lang.NewKeyword("column"), int(41), lang.NewKeyword("end-line"), int(5780), lang.NewKeyword("end-column"), int(65)) - tmp78, err := lang.WithMeta(tmp76, tmp77.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp79 := lang.Apply(tmp75, []any{tmp78, v60}) - tmp80 := lang.Apply(tmp72, []any{tmp79}) - var v81 any = tmp80 - _ = v81 - // let binding "gen-class-call" - var tmp82 any - if lang.IsTruthy(v81) { - tmp83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp84 := tmp83.FindInternedVar(lang.NewSymbol("list*")) - if tmp84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp84))) - } - tmp85 := tmp84.Get() - tmp86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp87 := tmp86.FindInternedVar(lang.NewSymbol("str")) - if tmp87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp87))) - } - tmp88 := tmp87.Get() - tmp89 := lang.Apply(tmp88, []any{v69}) - tmp90, _ := lang.FieldOrMethod(tmp89, "replace") - if reflect.TypeOf(tmp90).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("replace is not a function"))) - } - tmp91 := lang.Apply(tmp90, []any{lang.NewChar(45), lang.NewChar(95)}) - tmp92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp93 := tmp92.FindInternedVar(lang.NewSymbol("next")) - if tmp93.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp93))) - } - tmp94 := tmp93.Get() - tmp95 := lang.Apply(tmp94, []any{v81}) - tmp96 := lang.Apply(tmp85, []any{lang.NewSymbol("glojure.core/gen-class"), lang.NewKeyword("name"), tmp91, lang.NewKeyword("impl-ns"), v69, lang.NewKeyword("main"), true, tmp95}) - tmp82 = tmp96 - } else { - } - var v97 any = tmp82 - _ = v97 - // let binding "references" - tmp98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp99 := tmp98.FindInternedVar(lang.NewSymbol("remove")) - if tmp99.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp99))) - } - tmp100 := tmp99.Get() - var tmp101 lang.FnFunc - tmp101 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v102 := args[0] - _ = v102 - tmp103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp104 := tmp103.FindInternedVar(lang.NewSymbol("=")) - if tmp104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp104))) - } - tmp105 := tmp104.Get() - tmp106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp107 := tmp106.FindInternedVar(lang.NewSymbol("first")) - if tmp107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp107))) - } - tmp108 := tmp107.Get() - tmp109 := lang.Apply(tmp108, []any{v102}) - tmp110 := lang.Apply(tmp105, []any{lang.NewKeyword("gen-class"), tmp109}) - return tmp110 - }) - tmp102 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5784), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(5784), lang.NewKeyword("end-column"), int(52)) - tmp103, err := lang.WithMeta(tmp101, tmp102.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp104 := lang.Apply(tmp100, []any{tmp103, v60}) - var v105 any = tmp104 - _ = v105 - // let binding "name-metadata" - tmp106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp107 := tmp106.FindInternedVar(lang.NewSymbol("meta")) - if tmp107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp107))) - } - tmp108 := tmp107.Get() - tmp109 := lang.Apply(tmp108, []any{v69}) - var v110 any = tmp109 - _ = v110 - tmp111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp112 := tmp111.FindInternedVar(lang.NewSymbol("seq")) - if tmp112.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp112))) - } - tmp113 := tmp112.Get() - tmp114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp115 := tmp114.FindInternedVar(lang.NewSymbol("concat")) - if tmp115.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp115))) - } - tmp116 := tmp115.Get() - tmp117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp118 := tmp117.FindInternedVar(lang.NewSymbol("list")) - if tmp118.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp118))) - } - tmp119 := tmp118.Get() - tmp120 := lang.Apply(tmp119, []any{lang.NewSymbol("do")}) - tmp121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp122 := tmp121.FindInternedVar(lang.NewSymbol("list")) - if tmp122.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp122))) - } - tmp123 := tmp122.Get() - tmp124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp125 := tmp124.FindInternedVar(lang.NewSymbol("seq")) - if tmp125.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp125))) - } - tmp126 := tmp125.Get() - tmp127 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp128 := tmp127.FindInternedVar(lang.NewSymbol("concat")) - if tmp128.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp128))) - } - tmp129 := tmp128.Get() - tmp130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp131 := tmp130.FindInternedVar(lang.NewSymbol("list")) - if tmp131.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp131))) - } - tmp132 := tmp131.Get() - tmp133 := lang.Apply(tmp132, []any{lang.NewSymbol("glojure.core/in-ns")}) - tmp134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp135 := tmp134.FindInternedVar(lang.NewSymbol("list")) - if tmp135.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp135))) - } - tmp136 := tmp135.Get() - tmp137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp138 := tmp137.FindInternedVar(lang.NewSymbol("seq")) - if tmp138.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp138))) - } - tmp139 := tmp138.Get() - tmp140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp141 := tmp140.FindInternedVar(lang.NewSymbol("concat")) - if tmp141.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp141))) - } - tmp142 := tmp141.Get() - tmp143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp144 := tmp143.FindInternedVar(lang.NewSymbol("list")) - if tmp144.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp144))) - } - tmp145 := tmp144.Get() - tmp146 := lang.Apply(tmp145, []any{lang.NewSymbol("quote")}) - tmp147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp148 := tmp147.FindInternedVar(lang.NewSymbol("list")) - if tmp148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp148))) - } - tmp149 := tmp148.Get() - tmp150 := lang.Apply(tmp149, []any{v69}) - tmp151 := lang.Apply(tmp142, []any{tmp146, tmp150}) - tmp152 := lang.Apply(tmp139, []any{tmp151}) - tmp153 := lang.Apply(tmp136, []any{tmp152}) - tmp154 := lang.Apply(tmp129, []any{tmp133, tmp153}) - tmp155 := lang.Apply(tmp126, []any{tmp154}) - tmp156 := lang.Apply(tmp123, []any{tmp155}) - var tmp157 any - if lang.IsTruthy(v110) { - tmp158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp159 := tmp158.FindInternedVar(lang.NewSymbol("seq")) - if tmp159.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp159))) - } - tmp160 := tmp159.Get() - tmp161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp162 := tmp161.FindInternedVar(lang.NewSymbol("concat")) - if tmp162.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp162))) - } - tmp163 := tmp162.Get() - tmp164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp165 := tmp164.FindInternedVar(lang.NewSymbol("list")) - if tmp165.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp165))) - } - tmp166 := tmp165.Get() - tmp167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp168 := tmp167.FindInternedVar(lang.NewSymbol("seq")) - if tmp168.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp168))) - } - tmp169 := tmp168.Get() - tmp170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp171 := tmp170.FindInternedVar(lang.NewSymbol("concat")) - if tmp171.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp171))) - } - tmp172 := tmp171.Get() - tmp173 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp174 := tmp173.FindInternedVar(lang.NewSymbol("list")) - if tmp174.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp174))) - } - tmp175 := tmp174.Get() - tmp176 := lang.Apply(tmp175, []any{lang.NewSymbol(".ResetMeta")}) - tmp177 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp178 := tmp177.FindInternedVar(lang.NewSymbol("list")) - if tmp178.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp178))) - } - tmp179 := tmp178.Get() - tmp180 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp181 := tmp180.FindInternedVar(lang.NewSymbol("seq")) - if tmp181.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp181))) - } - tmp182 := tmp181.Get() - tmp183 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp184 := tmp183.FindInternedVar(lang.NewSymbol("concat")) - if tmp184.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp184))) - } - tmp185 := tmp184.Get() - tmp186 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp187 := tmp186.FindInternedVar(lang.NewSymbol("list")) - if tmp187.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp187))) - } - tmp188 := tmp187.Get() - tmp189 := lang.Apply(tmp188, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.FindNamespace")}) - tmp190 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp191 := tmp190.FindInternedVar(lang.NewSymbol("list")) - if tmp191.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp191))) - } - tmp192 := tmp191.Get() - tmp193 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp194 := tmp193.FindInternedVar(lang.NewSymbol("seq")) - if tmp194.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp194))) - } - tmp195 := tmp194.Get() - tmp196 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp197 := tmp196.FindInternedVar(lang.NewSymbol("concat")) - if tmp197.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp197))) - } - tmp198 := tmp197.Get() - tmp199 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp200 := tmp199.FindInternedVar(lang.NewSymbol("list")) - if tmp200.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp200))) - } - tmp201 := tmp200.Get() - tmp202 := lang.Apply(tmp201, []any{lang.NewSymbol("quote")}) - tmp203 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp204 := tmp203.FindInternedVar(lang.NewSymbol("list")) - if tmp204.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp204))) - } - tmp205 := tmp204.Get() - tmp206 := lang.Apply(tmp205, []any{v69}) - tmp207 := lang.Apply(tmp198, []any{tmp202, tmp206}) - tmp208 := lang.Apply(tmp195, []any{tmp207}) - tmp209 := lang.Apply(tmp192, []any{tmp208}) - tmp210 := lang.Apply(tmp185, []any{tmp189, tmp209}) - tmp211 := lang.Apply(tmp182, []any{tmp210}) - tmp212 := lang.Apply(tmp179, []any{tmp211}) - tmp213 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp214 := tmp213.FindInternedVar(lang.NewSymbol("list")) - if tmp214.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp214))) - } - tmp215 := tmp214.Get() - tmp216 := lang.Apply(tmp215, []any{v110}) - tmp217 := lang.Apply(tmp172, []any{tmp176, tmp212, tmp216}) - tmp218 := lang.Apply(tmp169, []any{tmp217}) - tmp219 := lang.Apply(tmp166, []any{tmp218}) - tmp220 := lang.Apply(tmp163, []any{tmp219}) - tmp221 := lang.Apply(tmp160, []any{tmp220}) - tmp157 = tmp221 - } else { - } - tmp222 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp223 := tmp222.FindInternedVar(lang.NewSymbol("list")) - if tmp223.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp223))) - } - tmp224 := tmp223.Get() - tmp225 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp226 := tmp225.FindInternedVar(lang.NewSymbol("seq")) - if tmp226.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp226))) - } - tmp227 := tmp226.Get() - tmp228 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp229 := tmp228.FindInternedVar(lang.NewSymbol("concat")) - if tmp229.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp229))) - } - tmp230 := tmp229.Get() - tmp231 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp232 := tmp231.FindInternedVar(lang.NewSymbol("list")) - if tmp232.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp232))) - } - tmp233 := tmp232.Get() - tmp234 := lang.Apply(tmp233, []any{lang.NewSymbol("glojure.core/with-loading-context")}) - var tmp235 any - if lang.IsTruthy(v97) { - tmp236 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp237 := tmp236.FindInternedVar(lang.NewSymbol("list")) - if tmp237.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp237))) - } - tmp238 := tmp237.Get() - tmp239 := lang.Apply(tmp238, []any{v97}) - tmp235 = tmp239 - } else { - } - var tmp240 any - var tmp241 any - { // let - // let binding "and__0__auto__" - tmp242 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp243 := tmp242.FindInternedVar(lang.NewSymbol("not=")) - if tmp243.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp243))) - } - tmp244 := tmp243.Get() - tmp245 := lang.Apply(tmp244, []any{v69, lang.NewSymbol("glojure.core")}) - var v246 any = tmp245 - _ = v246 - var tmp247 any - if lang.IsTruthy(v246) { - tmp248 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp249 := tmp248.FindInternedVar(lang.NewSymbol("not-any?")) - if tmp249.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp249))) - } - tmp250 := tmp249.Get() - var tmp251 lang.FnFunc - tmp251 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v252 := args[0] - _ = v252 - tmp253 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp254 := tmp253.FindInternedVar(lang.NewSymbol("=")) - if tmp254.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp254))) - } - tmp255 := tmp254.Get() - tmp256 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp257 := tmp256.FindInternedVar(lang.NewSymbol("first")) - if tmp257.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp257))) - } - tmp258 := tmp257.Get() - tmp259 := lang.Apply(tmp258, []any{v252}) - tmp260 := lang.Apply(tmp255, []any{lang.NewKeyword("refer-glojure"), tmp259}) - return tmp260 - }) - tmp252 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5793), lang.NewKeyword("column"), int(58), lang.NewKeyword("end-line"), int(5793), lang.NewKeyword("end-column"), int(86)) - tmp253, err := lang.WithMeta(tmp251, tmp252.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp254 := lang.Apply(tmp250, []any{tmp253, v105}) - tmp247 = tmp254 - } else { - tmp247 = v246 - } - tmp241 = tmp247 - } // end let - if lang.IsTruthy(tmp241) { - tmp242 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp243 := tmp242.FindInternedVar(lang.NewSymbol("seq")) - if tmp243.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp243))) - } - tmp244 := tmp243.Get() - tmp245 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp246 := tmp245.FindInternedVar(lang.NewSymbol("concat")) - if tmp246.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp246))) - } - tmp247 := tmp246.Get() - tmp248 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp249 := tmp248.FindInternedVar(lang.NewSymbol("list")) - if tmp249.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp249))) - } - tmp250 := tmp249.Get() - tmp251 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp252 := tmp251.FindInternedVar(lang.NewSymbol("seq")) - if tmp252.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp252))) - } - tmp253 := tmp252.Get() - tmp254 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp255 := tmp254.FindInternedVar(lang.NewSymbol("concat")) - if tmp255.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp255))) - } - tmp256 := tmp255.Get() - tmp257 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp258 := tmp257.FindInternedVar(lang.NewSymbol("list")) - if tmp258.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp258))) - } - tmp259 := tmp258.Get() - tmp260 := lang.Apply(tmp259, []any{lang.NewSymbol("glojure.core/refer")}) - tmp261 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp262 := tmp261.FindInternedVar(lang.NewSymbol("list")) - if tmp262.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp262))) - } - tmp263 := tmp262.Get() - tmp264 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp265 := tmp264.FindInternedVar(lang.NewSymbol("seq")) - if tmp265.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp265))) - } - tmp266 := tmp265.Get() - tmp267 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp268 := tmp267.FindInternedVar(lang.NewSymbol("concat")) - if tmp268.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp268))) - } - tmp269 := tmp268.Get() - tmp270 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp271 := tmp270.FindInternedVar(lang.NewSymbol("list")) - if tmp271.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp271))) - } - tmp272 := tmp271.Get() - tmp273 := lang.Apply(tmp272, []any{lang.NewSymbol("quote")}) - tmp274 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp275 := tmp274.FindInternedVar(lang.NewSymbol("list")) - if tmp275.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp275))) - } - tmp276 := tmp275.Get() - tmp277 := lang.Apply(tmp276, []any{lang.NewSymbol("glojure.core")}) - tmp278 := lang.Apply(tmp269, []any{tmp273, tmp277}) - tmp279 := lang.Apply(tmp266, []any{tmp278}) - tmp280 := lang.Apply(tmp263, []any{tmp279}) - tmp281 := lang.Apply(tmp256, []any{tmp260, tmp280}) - tmp282 := lang.Apply(tmp253, []any{tmp281}) - tmp283 := lang.Apply(tmp250, []any{tmp282}) - tmp284 := lang.Apply(tmp247, []any{tmp283}) - tmp285 := lang.Apply(tmp244, []any{tmp284}) - tmp240 = tmp285 - } else { - } - tmp286 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp287 := tmp286.FindInternedVar(lang.NewSymbol("map")) - if tmp287.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp287))) - } - tmp288 := tmp287.Get() - tmp289 := lang.Apply(tmp288, []any{v11, v105}) - tmp290 := lang.Apply(tmp230, []any{tmp234, tmp235, tmp240, tmp289}) - tmp291 := lang.Apply(tmp227, []any{tmp290}) - tmp292 := lang.Apply(tmp224, []any{tmp291}) - tmp293 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp294 := tmp293.FindInternedVar(lang.NewSymbol("list")) - if tmp294.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp294))) - } - tmp295 := tmp294.Get() - tmp296 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp297 := tmp296.FindInternedVar(lang.NewSymbol("seq")) - if tmp297.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp297))) - } - tmp298 := tmp297.Get() - tmp299 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp300 := tmp299.FindInternedVar(lang.NewSymbol("concat")) - if tmp300.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp300))) - } - tmp301 := tmp300.Get() - tmp302 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp303 := tmp302.FindInternedVar(lang.NewSymbol("list")) - if tmp303.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp303))) - } - tmp304 := tmp303.Get() - tmp305 := lang.Apply(tmp304, []any{lang.NewSymbol("if")}) - tmp306 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp307 := tmp306.FindInternedVar(lang.NewSymbol("list")) - if tmp307.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp307))) - } - tmp308 := tmp307.Get() - tmp309 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp310 := tmp309.FindInternedVar(lang.NewSymbol("seq")) - if tmp310.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp310))) - } - tmp311 := tmp310.Get() - tmp312 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp313 := tmp312.FindInternedVar(lang.NewSymbol("concat")) - if tmp313.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp313))) - } - tmp314 := tmp313.Get() - tmp315 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp316 := tmp315.FindInternedVar(lang.NewSymbol("list")) - if tmp316.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp316))) - } - tmp317 := tmp316.Get() - tmp318 := lang.Apply(tmp317, []any{lang.NewSymbol(".Equals")}) - tmp319 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp320 := tmp319.FindInternedVar(lang.NewSymbol("list")) - if tmp320.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp320))) - } - tmp321 := tmp320.Get() - tmp322 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp323 := tmp322.FindInternedVar(lang.NewSymbol("seq")) - if tmp323.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp323))) - } - tmp324 := tmp323.Get() - tmp325 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp326 := tmp325.FindInternedVar(lang.NewSymbol("concat")) - if tmp326.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp326))) - } - tmp327 := tmp326.Get() - tmp328 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp329 := tmp328.FindInternedVar(lang.NewSymbol("list")) - if tmp329.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp329))) - } - tmp330 := tmp329.Get() - tmp331 := lang.Apply(tmp330, []any{lang.NewSymbol("quote")}) - tmp332 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp333 := tmp332.FindInternedVar(lang.NewSymbol("list")) - if tmp333.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp333))) - } - tmp334 := tmp333.Get() - tmp335 := lang.Apply(tmp334, []any{v69}) - tmp336 := lang.Apply(tmp327, []any{tmp331, tmp335}) - tmp337 := lang.Apply(tmp324, []any{tmp336}) - tmp338 := lang.Apply(tmp321, []any{tmp337}) - tmp339 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp340 := tmp339.FindInternedVar(lang.NewSymbol("list")) - if tmp340.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp340))) - } - tmp341 := tmp340.Get() - tmp342 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp343 := tmp342.FindInternedVar(lang.NewSymbol("seq")) - if tmp343.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp343))) - } - tmp344 := tmp343.Get() - tmp345 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp346 := tmp345.FindInternedVar(lang.NewSymbol("concat")) - if tmp346.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp346))) - } - tmp347 := tmp346.Get() - tmp348 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp349 := tmp348.FindInternedVar(lang.NewSymbol("list")) - if tmp349.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp349))) - } - tmp350 := tmp349.Get() - tmp351 := lang.Apply(tmp350, []any{lang.NewSymbol("quote")}) - tmp352 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp353 := tmp352.FindInternedVar(lang.NewSymbol("list")) - if tmp353.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp353))) - } - tmp354 := tmp353.Get() - tmp355 := lang.Apply(tmp354, []any{lang.NewSymbol("glojure.core")}) - tmp356 := lang.Apply(tmp347, []any{tmp351, tmp355}) - tmp357 := lang.Apply(tmp344, []any{tmp356}) - tmp358 := lang.Apply(tmp341, []any{tmp357}) - tmp359 := lang.Apply(tmp314, []any{tmp318, tmp338, tmp358}) - tmp360 := lang.Apply(tmp311, []any{tmp359}) - tmp361 := lang.Apply(tmp308, []any{tmp360}) - tmp362 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp363 := tmp362.FindInternedVar(lang.NewSymbol("list")) - if tmp363.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp363))) - } - tmp364 := tmp363.Get() - tmp365 := lang.Apply(tmp364, []any{nil}) - tmp366 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp367 := tmp366.FindInternedVar(lang.NewSymbol("list")) - if tmp367.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp367))) - } - tmp368 := tmp367.Get() - tmp369 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp370 := tmp369.FindInternedVar(lang.NewSymbol("seq")) - if tmp370.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp370))) - } - tmp371 := tmp370.Get() - tmp372 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp373 := tmp372.FindInternedVar(lang.NewSymbol("concat")) - if tmp373.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp373))) - } - tmp374 := tmp373.Get() - tmp375 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp376 := tmp375.FindInternedVar(lang.NewSymbol("list")) - if tmp376.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp376))) - } - tmp377 := tmp376.Get() - tmp378 := lang.Apply(tmp377, []any{lang.NewSymbol("do")}) - tmp379 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp380 := tmp379.FindInternedVar(lang.NewSymbol("list")) - if tmp380.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp380))) - } - tmp381 := tmp380.Get() - tmp382 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp383 := tmp382.FindInternedVar(lang.NewSymbol("seq")) - if tmp383.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp383))) - } - tmp384 := tmp383.Get() - tmp385 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp386 := tmp385.FindInternedVar(lang.NewSymbol("concat")) - if tmp386.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp386))) - } - tmp387 := tmp386.Get() - tmp388 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp389 := tmp388.FindInternedVar(lang.NewSymbol("list")) - if tmp389.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp389))) - } - tmp390 := tmp389.Get() - tmp391 := lang.Apply(tmp390, []any{lang.NewSymbol("glojure.core/dosync")}) - tmp392 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp393 := tmp392.FindInternedVar(lang.NewSymbol("list")) - if tmp393.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp393))) - } - tmp394 := tmp393.Get() - tmp395 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp396 := tmp395.FindInternedVar(lang.NewSymbol("seq")) - if tmp396.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp396))) - } - tmp397 := tmp396.Get() - tmp398 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp399 := tmp398.FindInternedVar(lang.NewSymbol("concat")) - if tmp399.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp399))) - } - tmp400 := tmp399.Get() - tmp401 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp402 := tmp401.FindInternedVar(lang.NewSymbol("list")) - if tmp402.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp402))) - } - tmp403 := tmp402.Get() - tmp404 := lang.Apply(tmp403, []any{lang.NewSymbol("glojure.core/commute")}) - tmp405 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp406 := tmp405.FindInternedVar(lang.NewSymbol("list")) - if tmp406.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp406))) - } - tmp407 := tmp406.Get() - tmp408 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp409 := tmp408.FindInternedVar(lang.NewSymbol("seq")) - if tmp409.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp409))) - } - tmp410 := tmp409.Get() - tmp411 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp412 := tmp411.FindInternedVar(lang.NewSymbol("concat")) - if tmp412.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp412))) - } - tmp413 := tmp412.Get() - tmp414 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp415 := tmp414.FindInternedVar(lang.NewSymbol("list")) - if tmp415.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp415))) - } - tmp416 := tmp415.Get() - tmp417 := lang.Apply(tmp416, []any{lang.NewSymbol("glojure.core/deref")}) - tmp418 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp419 := tmp418.FindInternedVar(lang.NewSymbol("list")) - if tmp419.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp419))) - } - tmp420 := tmp419.Get() - tmp421 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp422 := tmp421.FindInternedVar(lang.NewSymbol("seq")) - if tmp422.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp422))) - } - tmp423 := tmp422.Get() - tmp424 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp425 := tmp424.FindInternedVar(lang.NewSymbol("concat")) - if tmp425.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp425))) - } - tmp426 := tmp425.Get() - tmp427 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp428 := tmp427.FindInternedVar(lang.NewSymbol("list")) - if tmp428.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp428))) - } - tmp429 := tmp428.Get() - tmp430 := lang.Apply(tmp429, []any{lang.NewSymbol("var")}) - tmp431 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp432 := tmp431.FindInternedVar(lang.NewSymbol("list")) - if tmp432.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp432))) - } - tmp433 := tmp432.Get() - tmp434 := lang.Apply(tmp433, []any{lang.NewSymbol("glojure.core/*loaded-libs*")}) - tmp435 := lang.Apply(tmp426, []any{tmp430, tmp434}) - tmp436 := lang.Apply(tmp423, []any{tmp435}) - tmp437 := lang.Apply(tmp420, []any{tmp436}) - tmp438 := lang.Apply(tmp413, []any{tmp417, tmp437}) - tmp439 := lang.Apply(tmp410, []any{tmp438}) - tmp440 := lang.Apply(tmp407, []any{tmp439}) - tmp441 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp442 := tmp441.FindInternedVar(lang.NewSymbol("list")) - if tmp442.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp442))) - } - tmp443 := tmp442.Get() - tmp444 := lang.Apply(tmp443, []any{lang.NewSymbol("glojure.core/conj")}) - tmp445 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp446 := tmp445.FindInternedVar(lang.NewSymbol("list")) - if tmp446.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp446))) - } - tmp447 := tmp446.Get() - tmp448 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp449 := tmp448.FindInternedVar(lang.NewSymbol("seq")) - if tmp449.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp449))) - } - tmp450 := tmp449.Get() - tmp451 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp452 := tmp451.FindInternedVar(lang.NewSymbol("concat")) - if tmp452.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp452))) - } - tmp453 := tmp452.Get() - tmp454 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp455 := tmp454.FindInternedVar(lang.NewSymbol("list")) - if tmp455.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp455))) - } - tmp456 := tmp455.Get() - tmp457 := lang.Apply(tmp456, []any{lang.NewSymbol("quote")}) - tmp458 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp459 := tmp458.FindInternedVar(lang.NewSymbol("list")) - if tmp459.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp459))) - } - tmp460 := tmp459.Get() - tmp461 := lang.Apply(tmp460, []any{v69}) - tmp462 := lang.Apply(tmp453, []any{tmp457, tmp461}) - tmp463 := lang.Apply(tmp450, []any{tmp462}) - tmp464 := lang.Apply(tmp447, []any{tmp463}) - tmp465 := lang.Apply(tmp400, []any{tmp404, tmp440, tmp444, tmp464}) - tmp466 := lang.Apply(tmp397, []any{tmp465}) - tmp467 := lang.Apply(tmp394, []any{tmp466}) - tmp468 := lang.Apply(tmp387, []any{tmp391, tmp467}) - tmp469 := lang.Apply(tmp384, []any{tmp468}) - tmp470 := lang.Apply(tmp381, []any{tmp469}) - tmp471 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp472 := tmp471.FindInternedVar(lang.NewSymbol("list")) - if tmp472.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp472))) - } - tmp473 := tmp472.Get() - tmp474 := lang.Apply(tmp473, []any{nil}) - tmp475 := lang.Apply(tmp374, []any{tmp378, tmp470, tmp474}) - tmp476 := lang.Apply(tmp371, []any{tmp475}) - tmp477 := lang.Apply(tmp368, []any{tmp476}) - tmp478 := lang.Apply(tmp301, []any{tmp305, tmp361, tmp365, tmp477}) - tmp479 := lang.Apply(tmp298, []any{tmp478}) - tmp480 := lang.Apply(tmp295, []any{tmp479}) - tmp481 := lang.Apply(tmp116, []any{tmp120, tmp156, tmp157, tmp292, tmp480}) - tmp482 := lang.Apply(tmp113, []any{tmp481}) - tmp7 = tmp482 - } // end let - return tmp7 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // ns-aliases - { - tmp0 := lang.NewSymbol("ns-aliases").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of the aliases for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4273), lang.NewKeyword("end-line"), int(4273))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("the-ns")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.Apply(tmp6, []any{v3}) - tmp8, ok := lang.FieldOrMethod(tmp7, "getAliases") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp7, "getAliases"))) - } - var tmp9 any - switch reflect.TypeOf(tmp8).Kind() { - case reflect.Func: - tmp9 = lang.Apply(tmp8, nil) - default: - tmp9 = tmp8 - } - return tmp9 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // ns-imports - { - tmp0 := lang.NewSymbol("ns-imports").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of the import mappings for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4199), lang.NewKeyword("end-line"), int(4199))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("filter-key")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("val")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("partial")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("instance?")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := reflect.TypeOf((*reflect.Type)(nil)).Elem() - tmp17 := lang.Apply(tmp12, []any{tmp15, tmp16}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("ns-map")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.Apply(tmp20, []any{v3}) - tmp22 := lang.Apply(tmp6, []any{tmp9, tmp17, tmp21}) - return tmp22 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // ns-interns - { - tmp0 := lang.NewSymbol("ns-interns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of the intern mappings for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4206), lang.NewKeyword("end-line"), int(4206))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "ns" - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("the-ns")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v3}) - var v9 any = tmp8 - _ = v9 - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("filter-key")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("val")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - var tmp16 lang.FnFunc - tmp16 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v17 := args[0] - _ = v17 - var tmp18 any - { // let - // let binding "and__0__auto__" - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("instance?")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := reflect.TypeOf((*lang.Var)(nil)) - tmp23 := lang.Apply(tmp21, []any{tmp22, v17}) - var v24 any = tmp23 - _ = v24 - var tmp25 any - if lang.IsTruthy(v24) { - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("=")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29, ok := lang.FieldOrMethod(v17, "Namespace") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v17, "Namespace"))) - } - var tmp30 any - switch reflect.TypeOf(tmp29).Kind() { - case reflect.Func: - tmp30 = lang.Apply(tmp29, nil) - default: - tmp30 = tmp29 - } - tmp31 := lang.Apply(tmp28, []any{v9, tmp30}) - tmp25 = tmp31 - } else { - tmp25 = v24 - } - tmp18 = tmp25 - } // end let - return tmp18 - }) - tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4212), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(4213), lang.NewKeyword("end-column"), int(56)) - tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("ns-map")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, []any{v9}) - tmp23 := lang.Apply(tmp12, []any{tmp15, tmp18, tmp22}) - tmp4 = tmp23 - } // end let - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // ns-map - { - tmp0 := lang.NewSymbol("ns-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of all the mappings for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4170), lang.NewKeyword("end-line"), int(4170))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("the-ns")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.Apply(tmp6, []any{v3}) - tmp8, ok := lang.FieldOrMethod(tmp7, "Mappings") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp7, "Mappings"))) - } - var tmp9 any - switch reflect.TypeOf(tmp8).Kind() { - case reflect.Func: - tmp9 = lang.Apply(tmp8, nil) - default: - tmp9 = tmp8 - } - return tmp9 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // ns-name - { - tmp0 := lang.NewSymbol("ns-name").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns the name of the namespace, a symbol.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4163), lang.NewKeyword("end-line"), int(4163))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("the-ns")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.Apply(tmp6, []any{v3}) - tmp8, ok := lang.FieldOrMethod(tmp7, "Name") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp7, "Name"))) - } - var tmp9 any - switch reflect.TypeOf(tmp8).Kind() { - case reflect.Func: - tmp9 = lang.Apply(tmp8, nil) - default: - tmp9 = tmp8 - } - return tmp9 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // ns-publics - { - tmp0 := lang.NewSymbol("ns-publics").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of the public intern mappings for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4188), lang.NewKeyword("end-line"), int(4188))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "ns" - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("the-ns")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v3}) - var v9 any = tmp8 - _ = v9 - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("filter-key")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("val")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - var tmp16 lang.FnFunc - tmp16 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v17 := args[0] - _ = v17 - var tmp18 any - { // let - // let binding "and__0__auto__" - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("instance?")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := reflect.TypeOf((*lang.Var)(nil)) - tmp23 := lang.Apply(tmp21, []any{tmp22, v17}) - var v24 any = tmp23 - _ = v24 - var tmp25 any - if lang.IsTruthy(v24) { - var tmp26 any - { // let - // let binding "and__0__auto__" - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("=")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30, ok := lang.FieldOrMethod(v17, "Namespace") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v17, "Namespace"))) - } - var tmp31 any - switch reflect.TypeOf(tmp30).Kind() { - case reflect.Func: - tmp31 = lang.Apply(tmp30, nil) - default: - tmp31 = tmp30 - } - tmp32 := lang.Apply(tmp29, []any{v9, tmp31}) - var v33 any = tmp32 - _ = v33 - var tmp34 any - if lang.IsTruthy(v33) { - tmp35, ok := lang.FieldOrMethod(v17, "IsPublic") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v17, "IsPublic"))) - } - var tmp36 any - switch reflect.TypeOf(tmp35).Kind() { - case reflect.Func: - tmp36 = lang.Apply(tmp35, nil) - default: - tmp36 = tmp35 - } - tmp34 = tmp36 - } else { - tmp34 = v33 - } - tmp26 = tmp34 - } // end let - tmp25 = tmp26 - } else { - tmp25 = v24 - } - tmp18 = tmp25 - } // end let - return tmp18 - }) - tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4194), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(4196), lang.NewKeyword("end-column"), int(48)) - tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("ns-map")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, []any{v9}) - tmp23 := lang.Apply(tmp12, []any{tmp15, tmp18, tmp22}) - tmp4 = tmp23 - } // end let - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // ns-refers - { - tmp0 := lang.NewSymbol("ns-refers").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of the refer mappings for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4253), lang.NewKeyword("end-line"), int(4253))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "ns" - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("the-ns")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v3}) - var v9 any = tmp8 - _ = v9 - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("filter-key")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("val")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - var tmp16 lang.FnFunc - tmp16 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v17 := args[0] - _ = v17 - var tmp18 any - { // let - // let binding "and__0__auto__" - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("instance?")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := reflect.TypeOf((*lang.Var)(nil)) - tmp23 := lang.Apply(tmp21, []any{tmp22, v17}) - var v24 any = tmp23 - _ = v24 - var tmp25 any - if lang.IsTruthy(v24) { - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("not=")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29, ok := lang.FieldOrMethod(v17, "Namespace") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v17, "Namespace"))) - } - var tmp30 any - switch reflect.TypeOf(tmp29).Kind() { - case reflect.Func: - tmp30 = lang.Apply(tmp29, nil) - default: - tmp30 = tmp29 - } - tmp31 := lang.Apply(tmp28, []any{v9, tmp30}) - tmp25 = tmp31 - } else { - tmp25 = v24 - } - tmp18 = tmp25 - } // end let - return tmp18 - }) - tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4259), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(4260), lang.NewKeyword("end-column"), int(59)) - tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("ns-map")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, []any{v9}) - tmp23 := lang.Apply(tmp12, []any{tmp15, tmp18, tmp22}) - tmp4 = tmp23 - } // end let - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // ns-resolve - { - tmp0 := lang.NewSymbol("ns-resolve").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("sym")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("env"), lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Returns the var or Class to which a symbol will be resolved in the\n namespace (unless found in the environment), else nil. Note that\n if the symbol is fully qualified, the var/Class to which it resolves\n need not be present in the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4358), lang.NewKeyword("end-line"), int(4358))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("ns-resolve")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v3, nil, v4}) - return tmp8 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var tmp6 any - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("contains?")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp9, []any{v4, v5}) - if lang.IsTruthy(tmp10) { - } else { - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("the-ns")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{v3}) - tmp15, _ := lang.FieldOrMethod(runtime4.Compiler, "maybeResolveIn") - if reflect.TypeOf(tmp15).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("maybeResolveIn is not a function"))) - } - tmp16 := lang.Apply(tmp15, []any{tmp14, v5}) - tmp6 = tmp16 - } - return tmp6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // ns-unalias - { - tmp0 := lang.NewSymbol("ns-unalias").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Removes the alias for the symbol from the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4280), lang.NewKeyword("end-line"), int(4280))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("the-ns")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v3}) - tmp9, _ := lang.FieldOrMethod(tmp8, "removeAlias") - if reflect.TypeOf(tmp9).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("removeAlias is not a function"))) - } - tmp10 := lang.Apply(tmp9, []any{v4}) - return tmp10 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // ns-unmap - { - tmp0 := lang.NewSymbol("ns-unmap").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Removes the mappings for the symbol from the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4177), lang.NewKeyword("end-line"), int(4177))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("the-ns")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v3}) - tmp9, _ := lang.FieldOrMethod(tmp8, "unmap") - if reflect.TypeOf(tmp9).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("unmap is not a function"))) - } - tmp10 := lang.Apply(tmp9, []any{v4}) - return tmp10 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // nth - { - var tmp1 lang.FnFunc - { // function nth__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("seq")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("concat")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("list")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol(".")}) - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("list")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("list")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("seq")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("concat")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("list")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.Apply(tmp31, []any{lang.NewSymbol("glojure.core/Nth")}) - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("list")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("seq")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp40 := tmp39.FindInternedVar(lang.NewSymbol("concat")) - if tmp40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) - } - tmp41 := tmp40.Get() - tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp43 := tmp42.FindInternedVar(lang.NewSymbol("list")) - if tmp43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) - } - tmp44 := tmp43.Get() - tmp45 := lang.Apply(tmp44, []any{lang.NewSymbol("glojure.core/unquote")}) - tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp47 := tmp46.FindInternedVar(lang.NewSymbol("list")) - if tmp47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) - } - tmp48 := tmp47.Get() - tmp49 := lang.Apply(tmp48, []any{lang.NewSymbol("glojure.core/c")}) - tmp50 := lang.Apply(tmp41, []any{tmp45, tmp49}) - tmp51 := lang.Apply(tmp38, []any{tmp50}) - tmp52 := lang.Apply(tmp35, []any{tmp51}) - tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp54 := tmp53.FindInternedVar(lang.NewSymbol("list")) - if tmp54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) - } - tmp55 := tmp54.Get() - tmp56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp57 := tmp56.FindInternedVar(lang.NewSymbol("seq")) - if tmp57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp57))) - } - tmp58 := tmp57.Get() - tmp59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp60 := tmp59.FindInternedVar(lang.NewSymbol("concat")) - if tmp60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp60))) - } - tmp61 := tmp60.Get() - tmp62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp63 := tmp62.FindInternedVar(lang.NewSymbol("list")) - if tmp63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp63))) - } - tmp64 := tmp63.Get() - tmp65 := lang.Apply(tmp64, []any{lang.NewSymbol("glojure.core/unquote")}) - tmp66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp67 := tmp66.FindInternedVar(lang.NewSymbol("list")) - if tmp67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp67))) - } - tmp68 := tmp67.Get() - tmp69 := lang.Apply(tmp68, []any{lang.NewSymbol("glojure.core/i")}) - tmp70 := lang.Apply(tmp61, []any{tmp65, tmp69}) - tmp71 := lang.Apply(tmp58, []any{tmp70}) - tmp72 := lang.Apply(tmp55, []any{tmp71}) - tmp73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp74 := tmp73.FindInternedVar(lang.NewSymbol("list")) - if tmp74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp74))) - } - tmp75 := tmp74.Get() - tmp76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp77 := tmp76.FindInternedVar(lang.NewSymbol("seq")) - if tmp77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp77))) - } - tmp78 := tmp77.Get() - tmp79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp80 := tmp79.FindInternedVar(lang.NewSymbol("concat")) - if tmp80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp80))) - } - tmp81 := tmp80.Get() - tmp82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp83 := tmp82.FindInternedVar(lang.NewSymbol("list")) - if tmp83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp83))) - } - tmp84 := tmp83.Get() - tmp85 := lang.Apply(tmp84, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) - tmp86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp87 := tmp86.FindInternedVar(lang.NewSymbol("list")) - if tmp87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp87))) - } - tmp88 := tmp87.Get() - tmp89 := lang.Apply(tmp88, []any{lang.NewSymbol("glojure.core/nf")}) - tmp90 := lang.Apply(tmp81, []any{tmp85, tmp89}) - tmp91 := lang.Apply(tmp78, []any{tmp90}) - tmp92 := lang.Apply(tmp75, []any{tmp91}) - tmp93 := lang.Apply(tmp28, []any{tmp32, tmp52, tmp72, tmp92}) - tmp94 := lang.Apply(tmp25, []any{tmp93}) - tmp95 := lang.Apply(tmp22, []any{tmp94}) - tmp96 := lang.Apply(tmp11, []any{tmp15, tmp19, tmp95}) - tmp97 := lang.Apply(tmp8, []any{tmp96}) - return tmp97 - } - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("nth").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("index")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("index"), lang.NewSymbol("not-found"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the value at the index. get returns nil if index out of\n bounds, nth throws an exception unless not-found is supplied. nth\n also works for strings, Java arrays, regex Matchers and Lists, and,\n in O(n) time, for sequences.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2), int64(3)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(882), lang.NewKeyword("end-line"), int(882))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6, _ := lang.FieldOrMethod(runtime4.RT, "Nth") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Nth is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 - case 3: - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - v6 := args[2] - _ = v6 - tmp7, _ := lang.FieldOrMethod(runtime4.RT, "NthDefault") - if reflect.TypeOf(tmp7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("NthDefault is not a function"))) - } - tmp8 := lang.Apply(tmp7, []any{v4, v5, v6}) - return tmp8 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // nthnext - { - tmp0 := lang.NewSymbol("nthnext").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns the nth next of coll, (seq coll) when n is 0.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3147), lang.NewKeyword("end-line"), int(3147))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("instance?")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := reflect.TypeOf((*lang.IDrop)(nil)).Elem() - tmp10 := lang.Apply(tmp8, []any{tmp9, v3}) - if lang.IsTruthy(tmp10) { - var tmp11 any - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("pos?")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.Apply(tmp14, []any{v4}) - if lang.IsTruthy(tmp15) { - var tmp16 any - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("int?")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.Apply(tmp19, []any{v4}) - if lang.IsTruthy(tmp20) { - tmp16 = v4 - } else { - tmp21 := lang.Apply(nil, []any{v4}) - tmp16 = tmp21 - } - tmp22, _ := lang.FieldOrMethod(v3, "drop") - if reflect.TypeOf(tmp22).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("drop is not a function"))) - } - tmp23 := lang.Apply(tmp22, []any{tmp16}) - tmp11 = tmp23 - } else { - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("seq")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.Apply(tmp26, []any{v3}) - tmp11 = tmp27 - } - tmp5 = tmp11 - } else { - var tmp28 any - { // let - // let binding "n" - var v29 any = v4 - _ = v29 - // let binding "xs" - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("seq")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.Apply(tmp32, []any{v3}) - var v34 any = tmp33 - _ = v34 - for { - var tmp35 any - var tmp36 any - { // let - // let binding "and__0__auto__" - var v37 any = v34 - _ = v37 - var tmp38 any - if lang.IsTruthy(v37) { - tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp40 := tmp39.FindInternedVar(lang.NewSymbol("pos?")) - if tmp40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) - } - tmp41 := tmp40.Get() - tmp42 := lang.Apply(tmp41, []any{v29}) - tmp38 = tmp42 - } else { - tmp38 = v37 - } - tmp36 = tmp38 - } // end let - if lang.IsTruthy(tmp36) { - tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp39 := tmp38.FindInternedVar(lang.NewSymbol("dec")) - if tmp39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) - } - tmp40 := tmp39.Get() - tmp41 := lang.Apply(tmp40, []any{v29}) - var tmp37 any = tmp41 - tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp44 := tmp43.FindInternedVar(lang.NewSymbol("next")) - if tmp44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) - } - tmp45 := tmp44.Get() - tmp46 := lang.Apply(tmp45, []any{v34}) - var tmp42 any = tmp46 - v29 = tmp37 - v34 = tmp42 - continue - } else { - tmp35 = v34 - } - tmp28 = tmp35 - break - } - } // end let - tmp5 = tmp28 - } - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // nthrest - { - tmp0 := lang.NewSymbol("nthrest").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns the nth rest of coll, coll when n is 0.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3161), lang.NewKeyword("end-line"), int(3161))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("pos?")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(tmp8, []any{v4}) - if lang.IsTruthy(tmp9) { - var tmp10 any - { // let - // let binding "or__0__auto__" - var tmp11 any - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("instance?")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := reflect.TypeOf((*lang.IDrop)(nil)).Elem() - tmp16 := lang.Apply(tmp14, []any{tmp15, v3}) - if lang.IsTruthy(tmp16) { - var tmp17 any - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("int?")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.Apply(tmp20, []any{v4}) - if lang.IsTruthy(tmp21) { - tmp17 = v4 - } else { - tmp22 := lang.Apply(nil, []any{v4}) - tmp17 = tmp22 - } - tmp23, _ := lang.FieldOrMethod(v3, "drop") - if reflect.TypeOf(tmp23).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("drop is not a function"))) - } - tmp24 := lang.Apply(tmp23, []any{tmp17}) - tmp11 = tmp24 - } else { - var tmp25 any - { // let - // let binding "n" - var v26 any = v4 - _ = v26 - // let binding "xs" - var v27 any = v3 - _ = v27 - for { - var tmp28 any - { // let - // let binding "temp__0__auto__" - var tmp29 any - { // let - // let binding "and__0__auto__" - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("pos?")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.Apply(tmp32, []any{v26}) - var v34 any = tmp33 - _ = v34 - var tmp35 any - if lang.IsTruthy(v34) { - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("seq")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{v27}) - tmp35 = tmp39 - } else { - tmp35 = v34 - } - tmp29 = tmp35 - } // end let - var v30 any = tmp29 - _ = v30 - var tmp31 any - if lang.IsTruthy(v30) { - var tmp32 any - { // let - // let binding "xs" - var v33 any = v30 - _ = v33 - tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp36 := tmp35.FindInternedVar(lang.NewSymbol("dec")) - if tmp36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) - } - tmp37 := tmp36.Get() - tmp38 := lang.Apply(tmp37, []any{v26}) - var tmp34 any = tmp38 - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("rest")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.Apply(tmp42, []any{v33}) - var tmp39 any = tmp43 - v26 = tmp34 - v27 = tmp39 - continue - } // end let - tmp31 = tmp32 - } else { - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("seq")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.Apply(tmp35, []any{v27}) - tmp31 = tmp36 - } - tmp28 = tmp31 - } // end let - tmp25 = tmp28 - break - } - } // end let - tmp11 = tmp25 - } - var v26 any = tmp11 - _ = v26 - var tmp27 any - if lang.IsTruthy(v26) { - tmp27 = v26 - } else { - tmp27 = lang.NewList() - } - tmp10 = tmp27 - } // end let - tmp5 = tmp10 - } else { - tmp5 = v3 - } - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // num - { - var tmp1 lang.FnFunc - { // function num__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/Num")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{v3}) - tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) - tmp36 := lang.Apply(tmp23, []any{tmp35}) - tmp37 := lang.Apply(tmp20, []any{tmp36}) - tmp38 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp37}) - tmp39 := lang.Apply(tmp6, []any{tmp38}) - return tmp39 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("num").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to Number", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3474), lang.NewKeyword("end-line"), int(3474))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Num") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Num is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // number? - { - tmp0 := lang.NewSymbol("number?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is a Number", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3560), lang.NewKeyword("end-line"), int(3560))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.Apply(lang.IsNumber, []any{v3}) - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // numerator - { - tmp1 := reflect.TypeOf((*big6.Int)(nil)) - tmp0 := lang.NewSymbol("numerator").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("r"))), lang.NewKeyword("doc"), "Returns the numerator part of a Ratio.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3583), lang.NewKeyword("end-line"), int(3583))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5, ok := lang.FieldOrMethod(v4, "numerator") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "numerator"))) - } - var tmp6 any - switch reflect.TypeOf(tmp5).Kind() { - case reflect.Func: - tmp6 = lang.Apply(tmp5, nil) - default: - tmp6 = tmp5 - } - return tmp6 - }) - tmp4 := reflect.TypeOf((*big6.Int)(nil)) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // object-array - { - var tmp1 lang.FnFunc - { // function object-array__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.Apply(tmp20, []any{lang.NewSymbol("glojure.core/Object_array")}) - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("list")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.Apply(tmp24, []any{v3}) - tmp26 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp21, tmp25}) - tmp27 := lang.Apply(tmp6, []any{tmp26}) - return tmp27 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("object-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Creates an array of objects", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1)})), lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5349), lang.NewKeyword("end-line"), int(5349))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(runtime4.RT, "Object_array") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Object_array is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // odd? - { - tmp0 := lang.NewSymbol("odd?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is odd, throws an exception if n is not an integer", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1389), lang.NewKeyword("end-line"), int(1389))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("not")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("even?")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp9, []any{v3}) - tmp11 := lang.Apply(tmp6, []any{tmp10}) - return tmp11 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // or - { - tmp0 := lang.NewSymbol("or").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("next"))), lang.NewKeyword("doc"), "Evaluates exprs one at a time, from left to right. If a form\n returns a logical true value, or returns that value and doesn't\n evaluate any of the other expressions, otherwise it returns the\n value of the last expression. (or) returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(847), lang.NewKeyword("end-line"), int(847))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - return nil - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - return v5 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("seq")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("concat")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("list")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("glojure.core/let")}) - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("list")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("apply")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("vector")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("seq")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("concat")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.Apply(tmp34, []any{lang.NewSymbol("or__0__auto__")}) - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{v5}) - tmp40 := lang.Apply(tmp31, []any{tmp35, tmp39}) - tmp41 := lang.Apply(tmp28, []any{tmp40}) - tmp42 := lang.Apply(tmp22, []any{tmp25, tmp41}) - tmp43 := lang.Apply(tmp19, []any{tmp42}) - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp48 := tmp47.FindInternedVar(lang.NewSymbol("seq")) - if tmp48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) - } - tmp49 := tmp48.Get() - tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp51 := tmp50.FindInternedVar(lang.NewSymbol("concat")) - if tmp51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) - } - tmp52 := tmp51.Get() - tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp54 := tmp53.FindInternedVar(lang.NewSymbol("list")) - if tmp54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) - } - tmp55 := tmp54.Get() - tmp56 := lang.Apply(tmp55, []any{lang.NewSymbol("if")}) - tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp58 := tmp57.FindInternedVar(lang.NewSymbol("list")) - if tmp58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) - } - tmp59 := tmp58.Get() - tmp60 := lang.Apply(tmp59, []any{lang.NewSymbol("or__0__auto__")}) - tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp62 := tmp61.FindInternedVar(lang.NewSymbol("list")) - if tmp62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) - } - tmp63 := tmp62.Get() - tmp64 := lang.Apply(tmp63, []any{lang.NewSymbol("or__0__auto__")}) - tmp65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp66 := tmp65.FindInternedVar(lang.NewSymbol("list")) - if tmp66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp66))) - } - tmp67 := tmp66.Get() - tmp68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp69 := tmp68.FindInternedVar(lang.NewSymbol("seq")) - if tmp69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp69))) - } - tmp70 := tmp69.Get() - tmp71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp72 := tmp71.FindInternedVar(lang.NewSymbol("concat")) - if tmp72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp72))) - } - tmp73 := tmp72.Get() - tmp74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp75 := tmp74.FindInternedVar(lang.NewSymbol("list")) - if tmp75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp75))) - } - tmp76 := tmp75.Get() - tmp77 := lang.Apply(tmp76, []any{lang.NewSymbol("glojure.core/or")}) - tmp78 := lang.Apply(tmp73, []any{tmp77, v6}) - tmp79 := lang.Apply(tmp70, []any{tmp78}) - tmp80 := lang.Apply(tmp67, []any{tmp79}) - tmp81 := lang.Apply(tmp52, []any{tmp56, tmp60, tmp64, tmp80}) - tmp82 := lang.Apply(tmp49, []any{tmp81}) - tmp83 := lang.Apply(tmp46, []any{tmp82}) - tmp84 := lang.Apply(tmp12, []any{tmp16, tmp43, tmp83}) - tmp85 := lang.Apply(tmp9, []any{tmp84}) - return tmp85 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // parents - { - tmp0 := lang.NewSymbol("parents").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"))), lang.NewKeyword("doc"), "Returns the immediate parents of tag, either via a Java type\n inheritance relationship or a relationship established via derive. h\n must be a hierarchy obtained from make-hierarchy, if not supplied\n defaults to the global hierarchy", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5564), lang.NewKeyword("end-line"), int(5564))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("parents")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("global-hierarchy")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp6, []any{tmp9, v3}) - return tmp10 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("not-empty")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - var tmp8 any - { // let - // let binding "tp" - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("get")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.Apply(lang.NewKeyword("parents"), []any{v3}) - tmp13 := lang.Apply(tmp11, []any{tmp12, v4}) - var v14 any = tmp13 - _ = v14 - var tmp15 any - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("class?")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{v4}) - if lang.IsTruthy(tmp19) { - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("into1")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("set")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("bases")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.Apply(tmp28, []any{v4}) - tmp30 := lang.Apply(tmp25, []any{tmp29}) - tmp31 := lang.Apply(tmp22, []any{tmp30, v14}) - tmp15 = tmp31 - } else { - tmp15 = v14 - } - tmp8 = tmp15 - } // end let - tmp9 := lang.Apply(tmp7, []any{tmp8}) - return tmp9 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // parse-boolean - { - tmp0 := lang.NewSymbol("parse-boolean").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse strings \"true\" or \"false\" and return a boolean, or nil if invalid", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7957), lang.NewKeyword("end-line"), int(7957))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("string?")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v3}) - if lang.IsTruthy(tmp8) { - var tmp9 any - { // let - // let binding "G__353" - var v10 any = v3 - _ = v10 - } // end let - tmp4 = tmp9 - } else { - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("parsing-err")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{v3}) - tmp14 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp13}) - panic(tmp14) - } - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // parse-double - { - tmp0 := lang.NewSymbol("parse-double").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse string with floating point components and return a Double value,\n or nil if parse fails.\n\n Grammar: https://docs.oracle.com/javase/8/docs/api/java/lang/Double.html#valueOf-java.lang.String-", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7935), lang.NewKeyword("end-line"), int(7935))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("string?")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v3}) - if lang.IsTruthy(tmp8) { - var tmp9 any - { // let - // let binding "result__3649__auto__" - tmp10 := lang.Apply(strconv9.ParseFloat, []any{v3, int64(64)}) - var v11 any = tmp10 - _ = v11 - var tmp12 any - tmp13 := lang.Apply(v11, []any{int64(1)}) - if lang.IsTruthy(tmp13) { - } else { - tmp14 := lang.Apply(v11, []any{int64(0)}) - tmp12 = tmp14 - } - tmp9 = tmp12 - } // end let - tmp4 = tmp9 - } else { - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("parsing-err")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{v3}) - tmp14 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp13}) - panic(tmp14) - } - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // parse-impls - { - tmp0 := lang.NewSymbol("parse-impls").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(13), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(13), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("specs"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "ret" - tmp5 := lang.NewMap() - tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(14), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(14), lang.NewKeyword("end-column"), int(15)) - tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v8 any = tmp7 - _ = v8 - // let binding "s" - var v9 any = v3 - _ = v9 - for { - var tmp10 any - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("seq")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{v9}) - if lang.IsTruthy(tmp14) { - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("assoc")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("first")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, []any{v9}) - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("take-while")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("seq?")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("next")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.Apply(tmp31, []any{v9}) - tmp33 := lang.Apply(tmp25, []any{tmp28, tmp32}) - tmp34 := lang.Apply(tmp18, []any{v8, tmp22, tmp33}) - var tmp15 any = tmp34 - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("drop-while")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp40 := tmp39.FindInternedVar(lang.NewSymbol("seq?")) - if tmp40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) - } - tmp41 := tmp40.Get() - tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp43 := tmp42.FindInternedVar(lang.NewSymbol("next")) - if tmp43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) - } - tmp44 := tmp43.Get() - tmp45 := lang.Apply(tmp44, []any{v9}) - tmp46 := lang.Apply(tmp38, []any{tmp41, tmp45}) - var tmp35 any = tmp46 - v8 = tmp15 - v9 = tmp35 - continue - } else { - tmp10 = v8 - } - tmp4 = tmp10 - break - } - } // end let - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // parse-long - { - tmp0 := lang.NewSymbol("parse-long").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse string of decimal digits with optional leading -/+ and return a\n Long value, or nil if parse fails", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7926), lang.NewKeyword("end-line"), int(7926))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("string?")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v3}) - if lang.IsTruthy(tmp8) { - var tmp9 any - { // let - // let binding "result__3648__auto__" - tmp10 := lang.Apply(strconv9.ParseInt, []any{v3, int64(10), int64(64)}) - var v11 any = tmp10 - _ = v11 - var tmp12 any - tmp13 := lang.Apply(v11, []any{int64(1)}) - if lang.IsTruthy(tmp13) { - } else { - tmp14 := lang.Apply(v11, []any{int64(0)}) - tmp12 = tmp14 - } - tmp9 = tmp12 - } // end let - tmp4 = tmp9 - } else { - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("parsing-err")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{v3}) - tmp14 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp13}) - panic(tmp14) - } - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // parse-uuid - { - tmp0 := lang.NewSymbol("parse-uuid").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse a string representing a UUID and return a java.util.UUID instance,\n or nil if parse fails.\n\n Grammar: https://docs.oracle.com/javase/8/docs/api/java/util/UUID.html#toString--", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7946), lang.NewKeyword("end-line"), int(7946))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - func() { - defer func() { - if r := recover(); r != nil { - tmp5 := reflect.TypeOf((*lang.IllegalArgumentError)(nil)) - if lang.CatchMatches(r, tmp5) { - v6 := r - _ = v6 - } else { - panic(r) - } - } - }() - var tmp6 any - { // let - // let binding "vec__350" - tmp7 := lang.Apply(uuid10.Parse, []any{v3}) - var v8 any = tmp7 - _ = v8 - // let binding "uuid" - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("nth")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.Apply(tmp11, []any{v8, int64(0), nil}) - var v13 any = tmp12 - _ = v13 - // let binding "err" - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("nth")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{v8, int64(1), nil}) - var v18 any = tmp17 - _ = v18 - var tmp19 any - if lang.IsTruthy(v18) { - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("str")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.Apply(tmp22, []any{"Error parsing UUID: ", v18}) - tmp24 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp23}) - panic(tmp24) - } else { - tmp19 = v13 - } - tmp6 = tmp19 - } // end let - tmp4 = tmp6 - }() - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // parsing-err - { - tmp0 := lang.NewSymbol("parsing-err").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Construct message for parsing for non-string parsing error", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(7921), lang.NewKeyword("end-line"), int(7921), lang.NewKeyword("private"), true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("str")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - var tmp7 any - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("nil?")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v3}) - if lang.IsTruthy(tmp11) { - tmp7 = "nil" - } else { - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("class")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.Apply(tmp14, []any{v3}) - tmp16, ok := lang.FieldOrMethod(tmp15, "Name") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp15, "Name"))) - } - var tmp17 any - switch reflect.TypeOf(tmp16).Kind() { - case reflect.Func: - tmp17 = lang.Apply(tmp16, nil) - default: - tmp17 = tmp16 - } - tmp7 = tmp17 - } - tmp18 := lang.Apply(tmp6, []any{"Expected string, got ", tmp7}) - return tmp18 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // partial - { - tmp0 := lang.NewSymbol("partial").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("arg1")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("arg1"), lang.NewSymbol("arg2")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("arg1"), lang.NewSymbol("arg2"), lang.NewSymbol("arg3")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("arg1"), lang.NewSymbol("arg2"), lang.NewSymbol("arg3"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Takes a function f and fewer than the normal arguments to f, and\n returns a fn that takes a variable number of additional args. When\n called, the returned function calls f with args + additional args.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2606), lang.NewKeyword("end-line"), int(2606))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - return v3 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 lang.FnFunc - tmp5 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp6 := lang.Apply(v3, []any{v4}) - return tmp6 - case 1: - v6 := args[0] - _ = v6 - tmp7 := lang.Apply(v3, []any{v4, v6}) - return tmp7 - case 2: - v6 := args[0] - _ = v6 - v7 := args[1] - _ = v7 - tmp8 := lang.Apply(v3, []any{v4, v6, v7}) - return tmp8 - case 3: - v6 := args[0] - _ = v6 - v7 := args[1] - _ = v7 - v8 := args[2] - _ = v8 - tmp9 := lang.Apply(v3, []any{v4, v6, v7, v8}) - return tmp9 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v6 := args[0] - _ = v6 - v7 := args[1] - _ = v7 - v8 := args[2] - _ = v8 - var v9 any = lang.NewList(args[3:]...) - _ = v9 - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("apply")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{v3, v4, v6, v7, v8, v9}) - return tmp13 - } - }) - tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2614), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(2619), lang.NewKeyword("end-column"), int(48)) - tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp7 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var tmp6 lang.FnFunc - tmp6 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp7 := lang.Apply(v3, []any{v4, v5}) - return tmp7 - case 1: - v7 := args[0] - _ = v7 - tmp8 := lang.Apply(v3, []any{v4, v5, v7}) - return tmp8 - case 2: - v7 := args[0] - _ = v7 - v8 := args[1] - _ = v8 - tmp9 := lang.Apply(v3, []any{v4, v5, v7, v8}) - return tmp9 - case 3: - v7 := args[0] - _ = v7 - v8 := args[1] - _ = v8 - v9 := args[2] - _ = v9 - tmp10 := lang.Apply(v3, []any{v4, v5, v7, v8, v9}) - return tmp10 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v7 := args[0] - _ = v7 - v8 := args[1] - _ = v8 - v9 := args[2] - _ = v9 - var v10 any = lang.NewList(args[3:]...) - _ = v10 - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("apply")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{v3, v4, v5, v7, v8, v9, v10}) - return tmp14 - } - }) - tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2621), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(2626), lang.NewKeyword("end-column"), int(53)) - tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp8 - case 4: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - var tmp7 lang.FnFunc - tmp7 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp8 := lang.Apply(v3, []any{v4, v5, v6}) - return tmp8 - case 1: - v8 := args[0] - _ = v8 - tmp9 := lang.Apply(v3, []any{v4, v5, v6, v8}) - return tmp9 - case 2: - v8 := args[0] - _ = v8 - v9 := args[1] - _ = v9 - tmp10 := lang.Apply(v3, []any{v4, v5, v6, v8, v9}) - return tmp10 - case 3: - v8 := args[0] - _ = v8 - v9 := args[1] - _ = v9 - v10 := args[2] - _ = v10 - tmp11 := lang.Apply(v3, []any{v4, v5, v6, v8, v9, v10}) - return tmp11 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v8 := args[0] - _ = v8 - v9 := args[1] - _ = v9 - v10 := args[2] - _ = v10 - var v11 any = lang.NewList(args[3:]...) - _ = v11 - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("apply")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.Apply(tmp14, []any{v3, v4, v5, v6, v8, v9, v10, v11}) - return tmp15 - } - }) - tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2628), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(2633), lang.NewKeyword("end-column"), int(58)) - tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp9 - default: - if len(args) < 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - var v7 any = lang.NewList(args[4:]...) - _ = v7 - var tmp8 lang.FnFunc - tmp8 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var v9 any = lang.NewList(args[0:]...) - _ = v9 - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("apply")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("concat")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{v7, v9}) - tmp17 := lang.Apply(tmp12, []any{v3, v4, v5, v6, tmp16}) - return tmp17 - } - }) - tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2635), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(2635), lang.NewKeyword("end-column"), int(60)) - tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp10 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // partition - { - tmp0 := lang.NewSymbol("partition").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("pad"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of lists of n items each, at offsets step\n apart. If step is not supplied, defaults to n, i.e. the partitions\n do not overlap. If a pad collection is supplied, use its elements as\n necessary to complete last partition upto n items. In case there are\n not enough padding elements, return a partition with less than n items.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3177), lang.NewKeyword("end-line"), int(3177))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("partition")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v3, v3, v4}) - return tmp8 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var tmp6 lang.FnFunc - tmp6 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var tmp7 any - { // let - // let binding "temp__0__auto__" - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("seq")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v5}) - var v12 any = tmp11 - _ = v12 - var tmp13 any - if lang.IsTruthy(v12) { - var tmp14 any - { // let - // let binding "s" - var v15 any = v12 - _ = v15 - var tmp16 any - { // let - // let binding "p" - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("doall")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("take")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.Apply(tmp22, []any{v3, v15}) - tmp24 := lang.Apply(tmp19, []any{tmp23}) - var v25 any = tmp24 - _ = v25 - var tmp26 any - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("=")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("count")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.Apply(tmp32, []any{v25}) - tmp34 := lang.Apply(tmp29, []any{v3, tmp33}) - if lang.IsTruthy(tmp34) { - tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp36 := tmp35.FindInternedVar(lang.NewSymbol("cons")) - if tmp36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) - } - tmp37 := tmp36.Get() - tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp39 := tmp38.FindInternedVar(lang.NewSymbol("partition")) - if tmp39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) - } - tmp40 := tmp39.Get() - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("nthrest")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.Apply(tmp43, []any{v15, v4}) - tmp45 := lang.Apply(tmp40, []any{v3, v4, tmp44}) - tmp46 := lang.Apply(tmp37, []any{v25, tmp45}) - tmp26 = tmp46 - } else { - } - tmp16 = tmp26 - } // end let - tmp14 = tmp16 - } // end let - tmp13 = tmp14 - } else { - } - tmp7 = tmp13 - } // end let - return tmp7 - }) - tmp7 := lang.Apply(lang.NewLazySeq, []any{tmp6}) - return tmp7 - case 4: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - var tmp7 lang.FnFunc - tmp7 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var tmp8 any - { // let - // let binding "temp__0__auto__" - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("seq")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.Apply(tmp11, []any{v6}) - var v13 any = tmp12 - _ = v13 - var tmp14 any - if lang.IsTruthy(v13) { - var tmp15 any - { // let - // let binding "s" - var v16 any = v13 - _ = v16 - var tmp17 any - { // let - // let binding "p" - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("doall")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("take")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.Apply(tmp23, []any{v3, v16}) - tmp25 := lang.Apply(tmp20, []any{tmp24}) - var v26 any = tmp25 - _ = v26 - var tmp27 any - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("=")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("count")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{v26}) - tmp35 := lang.Apply(tmp30, []any{v3, tmp34}) - if lang.IsTruthy(tmp35) { - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("cons")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp40 := tmp39.FindInternedVar(lang.NewSymbol("partition")) - if tmp40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) - } - tmp41 := tmp40.Get() - tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp43 := tmp42.FindInternedVar(lang.NewSymbol("nthrest")) - if tmp43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) - } - tmp44 := tmp43.Get() - tmp45 := lang.Apply(tmp44, []any{v16, v4}) - tmp46 := lang.Apply(tmp41, []any{v3, v4, v5, tmp45}) - tmp47 := lang.Apply(tmp38, []any{v26, tmp46}) - tmp27 = tmp47 - } else { - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp52 := tmp51.FindInternedVar(lang.NewSymbol("take")) - if tmp52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp52))) - } - tmp53 := tmp52.Get() - tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp55 := tmp54.FindInternedVar(lang.NewSymbol("concat")) - if tmp55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) - } - tmp56 := tmp55.Get() - tmp57 := lang.Apply(tmp56, []any{v26, v5}) - tmp58 := lang.Apply(tmp53, []any{v3, tmp57}) - tmp59 := lang.Apply(tmp50, []any{tmp58}) - tmp27 = tmp59 - } - tmp17 = tmp27 - } // end let - tmp15 = tmp17 - } // end let - tmp14 = tmp15 - } else { - } - tmp8 = tmp14 - } // end let - return tmp8 - }) - tmp8 := lang.Apply(lang.NewLazySeq, []any{tmp7}) - return tmp8 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // partition-all - { - tmp0 := lang.NewSymbol("partition-all").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of lists like partition, but may include\n partitions with fewer than n items at the end. Returns a stateful\n transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7222), lang.NewKeyword("end-line"), int(7222))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v5 := args[0] - _ = v5 - var tmp6 any - { // let - // let binding "a" - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("to-array")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp9, []any{v3}) - tmp11 := lang.Apply(lang.NewArrayList, []any{tmp10}) - var v12 any = tmp11 - _ = v12 - var tmp13 lang.FnFunc - tmp13 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp14 := lang.Apply(v5, nil) - return tmp14 - case 1: - v14 := args[0] - _ = v14 - var tmp15 any - { // let - // let binding "result" - var tmp16 any - tmp17, ok := lang.FieldOrMethod(v12, "isEmpty") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v12, "isEmpty"))) - } - var tmp18 any - switch reflect.TypeOf(tmp17).Kind() { - case reflect.Func: - tmp18 = lang.Apply(tmp17, nil) - default: - tmp18 = tmp17 - } - if lang.IsTruthy(tmp18) { - tmp16 = v14 - } else { - var tmp19 any - { // let - // let binding "v" - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("vec")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23, ok := lang.FieldOrMethod(v12, "toArray") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v12, "toArray"))) - } - var tmp24 any - switch reflect.TypeOf(tmp23).Kind() { - case reflect.Func: - tmp24 = lang.Apply(tmp23, nil) - default: - tmp24 = tmp23 - } - tmp25 := lang.Apply(tmp22, []any{tmp24}) - var v26 any = tmp25 - _ = v26 - tmp27, ok := lang.FieldOrMethod(v12, "clear") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v12, "clear"))) - } - var tmp28 any - switch reflect.TypeOf(tmp27).Kind() { - case reflect.Func: - tmp28 = lang.Apply(tmp27, nil) - default: - tmp28 = tmp27 - } - _ = tmp28 - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("unreduced")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.Apply(v5, []any{v14, v26}) - tmp33 := lang.Apply(tmp31, []any{tmp32}) - tmp19 = tmp33 - } // end let - tmp16 = tmp19 - } - var v20 any = tmp16 - _ = v20 - tmp21 := lang.Apply(v5, []any{v20}) - tmp15 = tmp21 - } // end let - return tmp15 - case 2: - v14 := args[0] - _ = v14 - v15 := args[1] - _ = v15 - tmp16, _ := lang.FieldOrMethod(v12, "add") - if reflect.TypeOf(tmp16).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) - } - tmp17 := lang.Apply(tmp16, []any{v15}) - _ = tmp17 - var tmp18 any - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("=")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22, ok := lang.FieldOrMethod(v12, "size") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v12, "size"))) - } - var tmp23 any - switch reflect.TypeOf(tmp22).Kind() { - case reflect.Func: - tmp23 = lang.Apply(tmp22, nil) - default: - tmp23 = tmp22 - } - tmp24 := lang.Apply(tmp21, []any{v3, tmp23}) - if lang.IsTruthy(tmp24) { - var tmp25 any - { // let - // let binding "v" - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("vec")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29, ok := lang.FieldOrMethod(v12, "toArray") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v12, "toArray"))) - } - var tmp30 any - switch reflect.TypeOf(tmp29).Kind() { - case reflect.Func: - tmp30 = lang.Apply(tmp29, nil) - default: - tmp30 = tmp29 - } - tmp31 := lang.Apply(tmp28, []any{tmp30}) - var v32 any = tmp31 - _ = v32 - tmp33, ok := lang.FieldOrMethod(v12, "clear") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v12, "clear"))) - } - var tmp34 any - switch reflect.TypeOf(tmp33).Kind() { - case reflect.Func: - tmp34 = lang.Apply(tmp33, nil) - default: - tmp34 = tmp33 - } - _ = tmp34 - tmp35 := lang.Apply(v5, []any{v14, v32}) - tmp25 = tmp35 - } // end let - tmp18 = tmp25 - } else { - tmp18 = v14 - } - return tmp18 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7231), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7247), lang.NewKeyword("end-column"), int(23)) - tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp6 = tmp15 - } // end let - return tmp6 - }) - tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7229), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7247), lang.NewKeyword("end-column"), int(25)) - tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp6 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("partition-all")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v3, v3, v4}) - return tmp8 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var tmp6 lang.FnFunc - tmp6 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var tmp7 any - { // let - // let binding "temp__0__auto__" - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("seq")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v5}) - var v12 any = tmp11 - _ = v12 - var tmp13 any - if lang.IsTruthy(v12) { - var tmp14 any - { // let - // let binding "s" - var v15 any = v12 - _ = v15 - var tmp16 any - { // let - // let binding "seg" - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("doall")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("take")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.Apply(tmp22, []any{v3, v15}) - tmp24 := lang.Apply(tmp19, []any{tmp23}) - var v25 any = tmp24 - _ = v25 - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("cons")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("partition-all")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("nthrest")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.Apply(tmp34, []any{v15, v4}) - tmp36 := lang.Apply(tmp31, []any{v3, v4, tmp35}) - tmp37 := lang.Apply(tmp28, []any{v25, tmp36}) - tmp16 = tmp37 - } // end let - tmp14 = tmp16 - } // end let - tmp13 = tmp14 - } else { - } - tmp7 = tmp13 - } // end let - return tmp7 - }) - tmp7 := lang.Apply(lang.NewLazySeq, []any{tmp6}) - return tmp7 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // partition-by - { - tmp0 := lang.NewSymbol("partition-by").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Applies f to each value in coll, splitting it each time f returns a\n new value. Returns a lazy seq of partitions. Returns a stateful\n transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7142), lang.NewKeyword("end-line"), int(7142))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v5 := args[0] - _ = v5 - var tmp6 any - { // let - // let binding "a" - var v7 any = "unimplemented: new with non-constant class type" - _ = v7 - // let binding "pv" - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("volatile!")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{lang.NewKeyword("glojure.core/none")}) - var v12 any = tmp11 - _ = v12 - var tmp13 lang.FnFunc - tmp13 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp14 := lang.Apply(v5, nil) - return tmp14 - case 1: - v14 := args[0] - _ = v14 - var tmp15 any - { // let - // let binding "result" - var tmp16 any - tmp17, ok := lang.FieldOrMethod(v7, "isEmpty") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "isEmpty"))) - } - var tmp18 any - switch reflect.TypeOf(tmp17).Kind() { - case reflect.Func: - tmp18 = lang.Apply(tmp17, nil) - default: - tmp18 = tmp17 - } - if lang.IsTruthy(tmp18) { - tmp16 = v14 - } else { - var tmp19 any - { // let - // let binding "v" - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("vec")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23, ok := lang.FieldOrMethod(v7, "toArray") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "toArray"))) - } - var tmp24 any - switch reflect.TypeOf(tmp23).Kind() { - case reflect.Func: - tmp24 = lang.Apply(tmp23, nil) - default: - tmp24 = tmp23 - } - tmp25 := lang.Apply(tmp22, []any{tmp24}) - var v26 any = tmp25 - _ = v26 - tmp27, ok := lang.FieldOrMethod(v7, "clear") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "clear"))) - } - var tmp28 any - switch reflect.TypeOf(tmp27).Kind() { - case reflect.Func: - tmp28 = lang.Apply(tmp27, nil) - default: - tmp28 = tmp27 - } - _ = tmp28 - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("unreduced")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.Apply(v5, []any{v14, v26}) - tmp33 := lang.Apply(tmp31, []any{tmp32}) - tmp19 = tmp33 - } // end let - tmp16 = tmp19 - } - var v20 any = tmp16 - _ = v20 - tmp21 := lang.Apply(v5, []any{v20}) - tmp15 = tmp21 - } // end let - return tmp15 - case 2: - v14 := args[0] - _ = v14 - v15 := args[1] - _ = v15 - var tmp16 any - { // let - // let binding "pval" - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("deref")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.Apply(tmp19, []any{v12}) - var v21 any = tmp20 - _ = v21 - // let binding "val" - tmp22 := lang.Apply(v3, []any{v15}) - var v23 any = tmp22 - _ = v23 - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("vreset!")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.Apply(tmp26, []any{v12, v23}) - _ = tmp27 - var tmp28 any - var tmp29 any - { // let - // let binding "or__0__auto__" - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("identical?")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.Apply(tmp32, []any{v21, lang.NewKeyword("glojure.core/none")}) - var v34 any = tmp33 - _ = v34 - var tmp35 any - if lang.IsTruthy(v34) { - tmp35 = v34 - } else { - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("=")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{v23, v21}) - tmp35 = tmp39 - } - tmp29 = tmp35 - } // end let - if lang.IsTruthy(tmp29) { - tmp30, _ := lang.FieldOrMethod(v7, "add") - if reflect.TypeOf(tmp30).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) - } - tmp31 := lang.Apply(tmp30, []any{v15}) - _ = tmp31 - tmp28 = v14 - } else { - var tmp32 any - { // let - // let binding "v" - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("vec")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36, ok := lang.FieldOrMethod(v7, "toArray") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "toArray"))) - } - var tmp37 any - switch reflect.TypeOf(tmp36).Kind() { - case reflect.Func: - tmp37 = lang.Apply(tmp36, nil) - default: - tmp37 = tmp36 - } - tmp38 := lang.Apply(tmp35, []any{tmp37}) - var v39 any = tmp38 - _ = v39 - tmp40, ok := lang.FieldOrMethod(v7, "clear") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "clear"))) - } - var tmp41 any - switch reflect.TypeOf(tmp40).Kind() { - case reflect.Func: - tmp41 = lang.Apply(tmp40, nil) - default: - tmp41 = tmp40 - } - _ = tmp41 - var tmp42 any - { // let - // let binding "ret" - tmp43 := lang.Apply(v5, []any{v14, v39}) - var v44 any = tmp43 - _ = v44 - var tmp45 any - tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp47 := tmp46.FindInternedVar(lang.NewSymbol("reduced?")) - if tmp47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) - } - tmp48 := tmp47.Get() - tmp49 := lang.Apply(tmp48, []any{v44}) - if lang.IsTruthy(tmp49) { - } else { - tmp50, _ := lang.FieldOrMethod(v7, "add") - if reflect.TypeOf(tmp50).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) - } - tmp51 := lang.Apply(tmp50, []any{v15}) - tmp45 = tmp51 - } - _ = tmp45 - tmp42 = v44 - } // end let - tmp32 = tmp42 - } // end let - tmp28 = tmp32 - } - tmp16 = tmp28 - } // end let - return tmp16 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7152), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(7176), lang.NewKeyword("end-column"), int(28)) - tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp6 = tmp15 - } // end let - return tmp6 - }) - tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7149), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(7176), lang.NewKeyword("end-column"), int(30)) - tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp6 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 lang.FnFunc - tmp5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var tmp6 any - { // let - // let binding "temp__0__auto__" - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("seq")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp9, []any{v4}) - var v11 any = tmp10 - _ = v11 - var tmp12 any - if lang.IsTruthy(v11) { - var tmp13 any - { // let - // let binding "s" - var v14 any = v11 - _ = v14 - var tmp15 any - { // let - // let binding "fst" - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("first")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{v14}) - var v20 any = tmp19 - _ = v20 - // let binding "fv" - tmp21 := lang.Apply(v3, []any{v20}) - var v22 any = tmp21 - _ = v22 - // let binding "run" - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("cons")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("take-while")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - var tmp29 lang.FnFunc - tmp29 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v30 := args[0] - _ = v30 - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("=")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(v3, []any{v30}) - tmp35 := lang.Apply(tmp33, []any{v22, tmp34}) - return tmp35 - }) - tmp30 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7182), lang.NewKeyword("column"), int(41), lang.NewKeyword("end-line"), int(7182), lang.NewKeyword("end-column"), int(53)) - tmp31, err := lang.WithMeta(tmp29, tmp30.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("next")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.Apply(tmp34, []any{v14}) - tmp36 := lang.Apply(tmp28, []any{tmp31, tmp35}) - tmp37 := lang.Apply(tmp25, []any{v20, tmp36}) - var v38 any = tmp37 - _ = v38 - tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp40 := tmp39.FindInternedVar(lang.NewSymbol("cons")) - if tmp40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) - } - tmp41 := tmp40.Get() - tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp43 := tmp42.FindInternedVar(lang.NewSymbol("partition-by")) - if tmp43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) - } - tmp44 := tmp43.Get() - var tmp45 lang.FnFunc - tmp45 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp47 := tmp46.FindInternedVar(lang.NewSymbol("drop")) - if tmp47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) - } - tmp48 := tmp47.Get() - tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp50 := tmp49.FindInternedVar(lang.NewSymbol("count")) - if tmp50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) - } - tmp51 := tmp50.Get() - tmp52 := lang.Apply(tmp51, []any{v38}) - tmp53 := lang.Apply(tmp48, []any{tmp52, v14}) - return tmp53 - }) - tmp46 := lang.Apply(lang.NewLazySeq, []any{tmp45}) - tmp47 := lang.Apply(tmp44, []any{v3, tmp46}) - tmp48 := lang.Apply(tmp41, []any{v38, tmp47}) - tmp15 = tmp48 - } // end let - tmp13 = tmp15 - } // end let - tmp12 = tmp13 - } else { - } - tmp6 = tmp12 - } // end let - return tmp6 - }) - tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) - return tmp6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // partitionv - { - tmp0 := lang.NewSymbol("partitionv").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("pad"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of vectors of n items each, at offsets step\n apart. If step is not supplied, defaults to n, i.e. the partitions\n do not overlap. If a pad collection is supplied, use its elements as\n necessary to complete last partition upto n items. In case there are\n not enough padding elements, return a partition with less than n items.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7262), lang.NewKeyword("end-line"), int(7262))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("partitionv")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v3, v3, v4}) - return tmp8 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var tmp6 lang.FnFunc - tmp6 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var tmp7 any - { // let - // let binding "temp__0__auto__" - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("seq")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v5}) - var v12 any = tmp11 - _ = v12 - var tmp13 any - if lang.IsTruthy(v12) { - var tmp14 any - { // let - // let binding "s" - var v15 any = v12 - _ = v15 - var tmp16 any - { // let - // let binding "p" - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("into")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.NewVector() - tmp21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7274), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(7274), lang.NewKeyword("end-column"), int(23)) - tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("take")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.Apply(tmp25, []any{v3}) - tmp27 := lang.Apply(tmp19, []any{tmp22, tmp26, v15}) - var v28 any = tmp27 - _ = v28 - var tmp29 any - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("=")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("count")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.Apply(tmp35, []any{v28}) - tmp37 := lang.Apply(tmp32, []any{v3, tmp36}) - if lang.IsTruthy(tmp37) { - tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp39 := tmp38.FindInternedVar(lang.NewSymbol("cons")) - if tmp39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) - } - tmp40 := tmp39.Get() - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("partitionv")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("nthrest")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.Apply(tmp46, []any{v15, v4}) - tmp48 := lang.Apply(tmp43, []any{v3, v4, tmp47}) - tmp49 := lang.Apply(tmp40, []any{v28, tmp48}) - tmp29 = tmp49 - } else { - } - tmp16 = tmp29 - } // end let - tmp14 = tmp16 - } // end let - tmp13 = tmp14 - } else { - } - tmp7 = tmp13 - } // end let - return tmp7 - }) - tmp7 := lang.Apply(lang.NewLazySeq, []any{tmp6}) - return tmp7 - case 4: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - var tmp7 lang.FnFunc - tmp7 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var tmp8 any - { // let - // let binding "temp__0__auto__" - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("seq")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.Apply(tmp11, []any{v6}) - var v13 any = tmp12 - _ = v13 - var tmp14 any - if lang.IsTruthy(v13) { - var tmp15 any - { // let - // let binding "s" - var v16 any = v13 - _ = v16 - var tmp17 any - { // let - // let binding "p" - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("into")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.NewVector() - tmp22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7280), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(7280), lang.NewKeyword("end-column"), int(23)) - tmp23, err := lang.WithMeta(tmp21, tmp22.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("take")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.Apply(tmp26, []any{v3}) - tmp28 := lang.Apply(tmp20, []any{tmp23, tmp27, v16}) - var v29 any = tmp28 - _ = v29 - var tmp30 any - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("=")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("count")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.Apply(tmp36, []any{v29}) - tmp38 := lang.Apply(tmp33, []any{v3, tmp37}) - if lang.IsTruthy(tmp38) { - tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp40 := tmp39.FindInternedVar(lang.NewSymbol("cons")) - if tmp40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) - } - tmp41 := tmp40.Get() - tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp43 := tmp42.FindInternedVar(lang.NewSymbol("partitionv")) - if tmp43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) - } - tmp44 := tmp43.Get() - tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp46 := tmp45.FindInternedVar(lang.NewSymbol("nthrest")) - if tmp46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) - } - tmp47 := tmp46.Get() - tmp48 := lang.Apply(tmp47, []any{v16, v4}) - tmp49 := lang.Apply(tmp44, []any{v3, v4, v5, tmp48}) - tmp50 := lang.Apply(tmp41, []any{v29, tmp49}) - tmp30 = tmp50 - } else { - tmp51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp52 := tmp51.FindInternedVar(lang.NewSymbol("list")) - if tmp52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp52))) - } - tmp53 := tmp52.Get() - tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp55 := tmp54.FindInternedVar(lang.NewSymbol("into")) - if tmp55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) - } - tmp56 := tmp55.Get() - tmp57 := lang.NewVector() - tmp58 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7283), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(7283), lang.NewKeyword("end-column"), int(25)) - tmp59, err := lang.WithMeta(tmp57, tmp58.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp61 := tmp60.FindInternedVar(lang.NewSymbol("take")) - if tmp61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) - } - tmp62 := tmp61.Get() - tmp63 := lang.Apply(tmp62, []any{v3}) - tmp64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp65 := tmp64.FindInternedVar(lang.NewSymbol("concat")) - if tmp65.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp65))) - } - tmp66 := tmp65.Get() - tmp67 := lang.Apply(tmp66, []any{v29, v5}) - tmp68 := lang.Apply(tmp56, []any{tmp59, tmp63, tmp67}) - tmp69 := lang.Apply(tmp53, []any{tmp68}) - tmp30 = tmp69 - } - tmp17 = tmp30 - } // end let - tmp15 = tmp17 - } // end let - tmp14 = tmp15 - } else { - } - tmp8 = tmp14 - } // end let - return tmp8 - }) - tmp8 := lang.Apply(lang.NewLazySeq, []any{tmp7}) - return tmp8 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // partitionv-all - { - tmp0 := lang.NewSymbol("partitionv-all").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of vector partitions, but may include\n partitions with fewer than n items at the end.\n Returns a stateful transducer when no collection is provided.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7285), lang.NewKeyword("end-line"), int(7285))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("partition-all")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.Apply(tmp6, []any{v3}) - return tmp7 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("partitionv-all")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v3, v3, v4}) - return tmp8 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var tmp6 lang.FnFunc - tmp6 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var tmp7 any - { // let - // let binding "temp__0__auto__" - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("seq")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v5}) - var v12 any = tmp11 - _ = v12 - var tmp13 any - if lang.IsTruthy(v12) { - var tmp14 any - { // let - // let binding "s" - var v15 any = v12 - _ = v15 - var tmp16 any - { // let - // let binding "seg" - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("into")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.NewVector() - tmp21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7297), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(7297), lang.NewKeyword("end-column"), int(25)) - tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("take")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.Apply(tmp25, []any{v3}) - tmp27 := lang.Apply(tmp19, []any{tmp22, tmp26, v5}) - var v28 any = tmp27 - _ = v28 - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("cons")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("partitionv-all")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp36 := tmp35.FindInternedVar(lang.NewSymbol("drop")) - if tmp36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) - } - tmp37 := tmp36.Get() - tmp38 := lang.Apply(tmp37, []any{v4, v15}) - tmp39 := lang.Apply(tmp34, []any{v3, v4, tmp38}) - tmp40 := lang.Apply(tmp31, []any{v28, tmp39}) - tmp16 = tmp40 - } // end let - tmp14 = tmp16 - } // end let - tmp13 = tmp14 - } else { - } - tmp7 = tmp13 - } // end let - return tmp7 - }) - tmp7 := lang.Apply(lang.NewLazySeq, []any{tmp6}) - return tmp7 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // pcalls - { - tmp0 := lang.NewSymbol("pcalls").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("fns"))), lang.NewKeyword("doc"), "Executes the no-arg fns in parallel, returning a lazy sequence of\n their values", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7056), lang.NewKeyword("end-line"), int(7056))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var v3 any = lang.NewList(args[0:]...) - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("pmap")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - var tmp7 lang.FnFunc - tmp7 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v8 := args[0] - _ = v8 - tmp9 := lang.Apply(v8, nil) - return tmp9 - }) - tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7061), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(7061), lang.NewKeyword("end-column"), int(20)) - tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp10 := lang.Apply(tmp6, []any{tmp9, v3}) - return tmp10 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // peek - { - tmp0 := lang.NewSymbol("peek").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "For a list or queue, same as first, for a vector, same as, but much\n more efficient than, last. If the collection is empty, returns nil.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1455), lang.NewKeyword("end-line"), int(1455))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4, _ := lang.FieldOrMethod(runtime4.RT, "Peek") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Peek is not a function"))) - } - tmp5 := lang.Apply(tmp4, []any{v3}) - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // persistent! - { - tmp0 := lang.NewSymbol("persistent!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a new, persistent version of the transient collection, in\n constant time. The transient collection cannot be used after this\n call, any such use will throw an exception.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3350), lang.NewKeyword("end-line"), int(3350))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4, ok := lang.FieldOrMethod(v3, "Persistent") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "Persistent"))) - } - var tmp5 any - switch reflect.TypeOf(tmp4).Kind() { - case reflect.Func: - tmp5 = lang.Apply(tmp4, nil) - default: - tmp5 = tmp4 - } - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // pmap - { - tmp0 := lang.NewSymbol("pmap").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Like map, except f is applied in parallel. Semi-lazy in that the\n parallel computation stays ahead of the consumption, but doesn't\n realize the entire result unless required. Only useful for\n computationally intensive functions where the time of f dominates\n the coordination overhead.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7031), lang.NewKeyword("end-line"), int(7031))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - { // let - // let binding "n" - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("+")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(runtime11.NumCPU, nil) - tmp10 := lang.Apply(tmp8, []any{int64(2), tmp9}) - var v11 any = tmp10 - _ = v11 - // let binding "rets" - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("map")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - var tmp15 lang.FnFunc - tmp15 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v16 := args[0] - _ = v16 - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("future-call")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - var tmp20 lang.FnFunc - tmp20 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - tmp21 := lang.Apply(v3, []any{v16}) - return tmp21 - }) - tmp21 := lang.Apply(tmp19, []any{tmp20}) - return tmp21 - }) - tmp16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7041), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7041), lang.NewKeyword("end-column"), int(34)) - tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp18 := lang.Apply(tmp14, []any{tmp17, v4}) - var v19 any = tmp18 - _ = v19 - // let binding "step" - var tmp20 lang.FnFunc - { // function step - var v21 lang.FnFunc - tmp20 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v22 := args[0] - _ = v22 - v23 := args[1] - _ = v23 - var tmp24 any - { // let - // let binding "vec__323" - var v25 any = v22 - _ = v25 - // let binding "seq__324" - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("seq")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.Apply(tmp28, []any{v25}) - var v30 any = tmp29 - _ = v30 - // let binding "first__325" - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("first")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{v30}) - var v35 any = tmp34 - _ = v35 - // let binding "seq__324" - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("next")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{v30}) - var v40 any = tmp39 - _ = v40 - // let binding "x" - var v41 any = v35 - _ = v41 - // let binding "xs" - var v42 any = v40 - _ = v42 - // let binding "vs" - var v43 any = v25 - _ = v43 - var tmp44 lang.FnFunc - tmp44 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var tmp45 any - { // let - // let binding "temp__0__auto__" - tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp47 := tmp46.FindInternedVar(lang.NewSymbol("seq")) - if tmp47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) - } - tmp48 := tmp47.Get() - tmp49 := lang.Apply(tmp48, []any{v23}) - var v50 any = tmp49 - _ = v50 - var tmp51 any - if lang.IsTruthy(v50) { - var tmp52 any - { // let - // let binding "s" - var v53 any = v50 - _ = v53 - tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp55 := tmp54.FindInternedVar(lang.NewSymbol("cons")) - if tmp55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) - } - tmp56 := tmp55.Get() - tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp58 := tmp57.FindInternedVar(lang.NewSymbol("deref")) - if tmp58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) - } - tmp59 := tmp58.Get() - tmp60 := lang.Apply(tmp59, []any{v41}) - tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp62 := tmp61.FindInternedVar(lang.NewSymbol("rest")) - if tmp62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) - } - tmp63 := tmp62.Get() - tmp64 := lang.Apply(tmp63, []any{v53}) - tmp65 := lang.Apply(v21, []any{v42, tmp64}) - tmp66 := lang.Apply(tmp56, []any{tmp60, tmp65}) - tmp52 = tmp66 - } // end let - tmp51 = tmp52 - } else { - tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp54 := tmp53.FindInternedVar(lang.NewSymbol("map")) - if tmp54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) - } - tmp55 := tmp54.Get() - tmp56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp57 := tmp56.FindInternedVar(lang.NewSymbol("deref")) - if tmp57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp57))) - } - tmp58 := tmp57.Get() - tmp59 := lang.Apply(tmp55, []any{tmp58, v43}) - tmp51 = tmp59 - } - tmp45 = tmp51 - } // end let - return tmp45 - }) - tmp45 := lang.Apply(lang.NewLazySeq, []any{tmp44}) - tmp24 = tmp45 - } // end let - return tmp24 - }) - v21 = tmp20 - _ = v21 - } - tmp21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7042), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(7046), lang.NewKeyword("end-column"), int(36)) - tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v23 any = tmp22 - _ = v23 - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("drop")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.Apply(tmp26, []any{v11, v19}) - tmp28 := lang.Apply(v23, []any{v19, tmp27}) - tmp5 = tmp28 - } // end let - return tmp5 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - var tmp6 any - { // let - // let binding "step" - var tmp7 lang.FnFunc - { // function step - var v8 lang.FnFunc - tmp7 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v9 := args[0] - _ = v9 - var tmp10 lang.FnFunc - tmp10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var tmp11 any - { // let - // let binding "ss" - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("map")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("seq")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp14, []any{tmp17, v9}) - var v19 any = tmp18 - _ = v19 - var tmp20 any - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("every?")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("identity")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.Apply(tmp23, []any{tmp26, v19}) - if lang.IsTruthy(tmp27) { - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("cons")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("map")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("first")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.Apply(tmp33, []any{tmp36, v19}) - tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp39 := tmp38.FindInternedVar(lang.NewSymbol("map")) - if tmp39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) - } - tmp40 := tmp39.Get() - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("rest")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.Apply(tmp40, []any{tmp43, v19}) - tmp45 := lang.Apply(v8, []any{tmp44}) - tmp46 := lang.Apply(tmp30, []any{tmp37, tmp45}) - tmp20 = tmp46 - } else { - } - tmp11 = tmp20 - } // end let - return tmp11 - }) - tmp11 := lang.Apply(lang.NewLazySeq, []any{tmp10}) - return tmp11 - }) - v8 = tmp7 - _ = v8 - } - tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7049), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(7053), lang.NewKeyword("end-column"), int(67)) - tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v10 any = tmp9 - _ = v10 - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("pmap")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - var tmp14 lang.FnFunc - tmp14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v15 := args[0] - _ = v15 - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("apply")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{v3, v15}) - return tmp19 - }) - tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7054), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(7054), lang.NewKeyword("end-column"), int(23)) - tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("cons")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.Apply(tmp19, []any{v4, v5}) - tmp21 := lang.Apply(v10, []any{tmp20}) - tmp22 := lang.Apply(tmp13, []any{tmp16, tmp21}) - tmp6 = tmp22 - } // end let - return tmp6 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // pop - { - tmp0 := lang.NewSymbol("pop").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "For a list or queue, returns a new list/queue without the first\n item, for a vector, returns a new vector without the last item. If\n the collection is empty, throws an exception. Note - not the same\n as next/butlast.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1462), lang.NewKeyword("end-line"), int(1462))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4, _ := lang.FieldOrMethod(runtime4.RT, "Pop") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Pop is not a function"))) - } - tmp5 := lang.Apply(tmp4, []any{v3}) - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // pop! - { - tmp0 := lang.NewSymbol("pop!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Removes the last item from a transient vector. If\n the collection is empty, throws an exception. Returns coll", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3393), lang.NewKeyword("end-line"), int(3393))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4, ok := lang.FieldOrMethod(v3, "pop") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "pop"))) - } - var tmp5 any - switch reflect.TypeOf(tmp4).Kind() { - case reflect.Func: - tmp5 = lang.Apply(tmp4, nil) - default: - tmp5 = tmp4 - } - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // pop-thread-bindings - { - tmp0 := lang.NewSymbol("pop-thread-bindings").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Pop one set of bindings pushed with push-binding before. It is an error to\n pop bindings without pushing before.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1929), lang.NewKeyword("end-line"), int(1929))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - tmp3 := lang.Apply(lang.PopThreadBindings, nil) - return tmp3 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // pos-int? - { - tmp0 := lang.NewSymbol("pos-int?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a positive fixed precision integer", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1403), lang.NewKeyword("end-line"), int(1403))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "and__0__auto__" - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("int?")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v3}) - var v9 any = tmp8 - _ = v9 - var tmp10 any - if lang.IsTruthy(v9) { - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("pos?")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{v3}) - tmp10 = tmp14 - } else { - tmp10 = v9 - } - tmp4 = tmp10 - } // end let - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // pos? - { - var tmp1 lang.FnFunc - { // function pos?__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/IsPos")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{v3}) - tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) - tmp36 := lang.Apply(tmp23, []any{tmp35}) - tmp37 := lang.Apply(tmp20, []any{tmp36}) - tmp38 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp37}) - tmp39 := lang.Apply(tmp6, []any{tmp38}) - return tmp39 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("pos?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns true if num is greater than zero, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1252), lang.NewKeyword("end-line"), int(1252))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "IsPos") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("IsPos is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // pr - { - tmp0 := lang.NewSymbol("pr").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Prints the object(s) to the output stream that is the current value\n of *out*. Prints the object(s), separated by spaces if there is\n more than one. By default, pr and prn print in a way that objects\n can be read by the reader", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3678), lang.NewKeyword("end-line"), int(3678), lang.NewKeyword("dynamic"), true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - return nil - case 1: - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("pr-on")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("*out*")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp6, []any{v3, tmp9}) - return tmp10 - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var v4 any = lang.NewList(args[1:]...) - _ = v4 - recur_loop_671: - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("pr")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v3}) - _ = tmp8 - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("*out*")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.Apply(lang.AppendWriter, []any{tmp11, lang.NewChar(32)}) - _ = tmp12 - var tmp13 any - { // let - // let binding "temp__0__auto__" - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("next")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{v4}) - var v18 any = tmp17 - _ = v18 - var tmp19 any - if lang.IsTruthy(v18) { - var tmp20 any - { // let - // let binding "nmore" - var v21 any = v18 - _ = v21 - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("first")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.Apply(tmp25, []any{v4}) - var tmp22 any = tmp26 - var tmp27 any = v21 - v3 = tmp22 - v4 = tmp27 - goto recur_loop_671 - } // end let - tmp19 = tmp20 - } else { - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("apply")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("pr")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.Apply(tmp23, []any{tmp26, v4}) - tmp19 = tmp27 - } - tmp13 = tmp19 - } // end let - return tmp13 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // pr-on - { - tmp0 := lang.NewSymbol("pr-on").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("w"))), lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3669), lang.NewKeyword("end-line"), int(3669), lang.NewKeyword("private"), true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("*print-dup*")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - if lang.IsTruthy(tmp8) { - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("print-dup")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.Apply(tmp11, []any{v3, v4}) - tmp5 = tmp12 - } else { - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("print-method")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{v3, v4}) - tmp5 = tmp16 - } - _ = tmp5 - return nil - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // pr-str - { - tmp1 := reflect.TypeOf("") - tmp0 := lang.NewSymbol("pr-str").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("xs"))), lang.NewKeyword("doc"), "pr to a string, returning it", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4758), lang.NewKeyword("end-line"), int(4758))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var v4 any = lang.NewList(args[0:]...) - _ = v4 - var tmp5 any - { // let - // let binding "s__0__auto__" - var v6 any = "unimplemented: new with non-constant class type" - _ = v6 - var tmp7 any - { // let - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("push-thread-bindings")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("hash-map")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*out*")) - tmp15 := lang.Apply(tmp13, []any{tmp14, v6}) - tmp16 := lang.Apply(tmp10, []any{tmp15}) - _ = tmp16 - var tmp17 any - func() { - defer func() { - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.Apply(tmp20, nil) - _ = tmp21 - }() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("apply")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("pr")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.Apply(tmp24, []any{tmp27, v4}) - _ = tmp28 - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("str")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.Apply(tmp31, []any{v6}) - tmp17 = tmp32 - }() - tmp7 = tmp17 - } // end let - tmp5 = tmp7 - } // end let - return tmp5 - } - }) - tmp4 := reflect.TypeOf("") - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // prefer-method - { - tmp0 := lang.NewSymbol("prefer-method").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"), lang.NewSymbol("dispatch-val-x"), lang.NewSymbol("dispatch-val-y"))), lang.NewKeyword("doc"), "Causes the multimethod to prefer matches of dispatch-val-x over dispatch-val-y \n when there is a conflict", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1801), lang.NewKeyword("end-line"), int(1801))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6, _ := lang.FieldOrMethod(v3, "PreferMethod") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("PreferMethod is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // prefers - { - tmp0 := lang.NewSymbol("prefers").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"))), lang.NewKeyword("doc"), "Given a multimethod, returns a map of preferred value -> set of other values", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1822), lang.NewKeyword("end-line"), int(1822))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4, ok := lang.FieldOrMethod(v3, "getPreferTable") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getPreferTable"))) - } - var tmp5 any - switch reflect.TypeOf(tmp4).Kind() { - case reflect.Func: - tmp5 = lang.Apply(tmp4, nil) - default: - tmp5 = tmp4 - } - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // prep-hashes - { - tmp0 := lang.NewSymbol("prep-hashes").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr-sym"), lang.NewSymbol("default"), lang.NewSymbol("tests"), lang.NewSymbol("thens"))), lang.NewKeyword("doc"), "Takes a sequence of test constants and a corresponding sequence of then\n expressions. Returns a tuple of [shift mask case-map switch-type skip-check]\n where case-map is a map of int case values to [test then] tuples, switch-type\n is either :sparse or :compact, and skip-check is a set of case ints for which\n post-switch equivalence checking must not be done (occurs with hash\n collisions).", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6683), lang.NewKeyword("end-line"), int(6683), lang.NewKeyword("private"), true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - var tmp7 any - { // let - // let binding "hashcode" - var tmp8 lang.FnFunc - tmp8 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v9 := args[0] - _ = v9 - tmp10 := lang.Apply(lang.Hash, []any{v9}) - return tmp10 - }) - tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6691), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(6691), lang.NewKeyword("end-column"), int(66)) - tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v11 any = tmp10 - _ = v11 - // let binding "hashes" - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("into1")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) - tmp16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6692), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(6692), lang.NewKeyword("end-column"), int(25)) - tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("map")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.Apply(tmp20, []any{v11, v5}) - tmp22 := lang.Apply(tmp14, []any{tmp17, tmp21}) - var v23 any = tmp22 - _ = v23 - var tmp24 any - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("==")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("count")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.Apply(tmp30, []any{v5}) - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("count")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.Apply(tmp34, []any{v23}) - tmp36 := lang.Apply(tmp27, []any{tmp31, tmp35}) - if lang.IsTruthy(tmp36) { - var tmp37 any - tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp39 := tmp38.FindInternedVar(lang.NewSymbol("fits-table?")) - if tmp39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) - } - tmp40 := tmp39.Get() - tmp41 := lang.Apply(tmp40, []any{v23}) - if lang.IsTruthy(tmp41) { - tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp43 := tmp42.FindInternedVar(lang.NewSymbol("case-map")) - if tmp43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) - } - tmp44 := tmp43.Get() - tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp46 := tmp45.FindInternedVar(lang.NewSymbol("identity")) - if tmp46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) - } - tmp47 := tmp46.Get() - tmp48 := lang.Apply(tmp44, []any{v11, tmp47, v5, v6}) - tmp49 := lang.NewVector(int64(0), int64(0), tmp48, lang.NewKeyword("compact")) - tmp50 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6696), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(6696), lang.NewKeyword("end-column"), int(63)) - tmp51, err := lang.WithMeta(tmp49, tmp50.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp37 = tmp51 - } else { - var tmp52 any - { // let - // let binding "vec__167" - var tmp53 any - { // let - // let binding "or__0__auto__" - tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp55 := tmp54.FindInternedVar(lang.NewSymbol("maybe-min-hash")) - if tmp55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) - } - tmp56 := tmp55.Get() - tmp57 := lang.Apply(tmp56, []any{v23}) - var v58 any = tmp57 - _ = v58 - var tmp59 any - if lang.IsTruthy(v58) { - tmp59 = v58 - } else { - tmp60 := lang.NewVector(int64(0), int64(0)) - tmp61 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6697), lang.NewKeyword("column"), int(56), lang.NewKeyword("end-line"), int(6697), lang.NewKeyword("end-column"), int(60)) - tmp62, err := lang.WithMeta(tmp60, tmp61.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp59 = tmp62 - } - tmp53 = tmp59 - } // end let - var v54 any = tmp53 - _ = v54 - // let binding "shift" - tmp55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp56 := tmp55.FindInternedVar(lang.NewSymbol("nth")) - if tmp56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp56))) - } - tmp57 := tmp56.Get() - tmp58 := lang.Apply(tmp57, []any{v54, int64(0), nil}) - var v59 any = tmp58 - _ = v59 - // let binding "mask" - tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp61 := tmp60.FindInternedVar(lang.NewSymbol("nth")) - if tmp61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) - } - tmp62 := tmp61.Get() - tmp63 := lang.Apply(tmp62, []any{v54, int64(1), nil}) - var v64 any = tmp63 - _ = v64 - var tmp65 any - tmp66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp67 := tmp66.FindInternedVar(lang.NewSymbol("zero?")) - if tmp67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp67))) - } - tmp68 := tmp67.Get() - tmp69 := lang.Apply(tmp68, []any{v64}) - if lang.IsTruthy(tmp69) { - tmp70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp71 := tmp70.FindInternedVar(lang.NewSymbol("case-map")) - if tmp71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp71))) - } - tmp72 := tmp71.Get() - tmp73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp74 := tmp73.FindInternedVar(lang.NewSymbol("identity")) - if tmp74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp74))) - } - tmp75 := tmp74.Get() - tmp76 := lang.Apply(tmp72, []any{v11, tmp75, v5, v6}) - tmp77 := lang.NewVector(int64(0), int64(0), tmp76, lang.NewKeyword("sparse")) - tmp78 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6700), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(6700), lang.NewKeyword("end-column"), int(66)) - tmp79, err := lang.WithMeta(tmp77, tmp78.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp65 = tmp79 - } else { - tmp80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp81 := tmp80.FindInternedVar(lang.NewSymbol("case-map")) - if tmp81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp81))) - } - tmp82 := tmp81.Get() - var tmp83 lang.FnFunc - tmp83 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v84 := args[0] - _ = v84 - tmp85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp86 := tmp85.FindInternedVar(lang.NewSymbol("shift-mask")) - if tmp86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp86))) - } - tmp87 := tmp86.Get() - tmp88 := lang.Apply(v11, []any{v84}) - tmp89 := lang.Apply(tmp87, []any{v59, v64, tmp88}) - return tmp89 - }) - tmp84 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6702), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(6702), lang.NewKeyword("end-column"), int(71)) - tmp85, err := lang.WithMeta(tmp83, tmp84.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp87 := tmp86.FindInternedVar(lang.NewSymbol("identity")) - if tmp87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp87))) - } - tmp88 := tmp87.Get() - tmp89 := lang.Apply(tmp82, []any{tmp85, tmp88, v5, v6}) - tmp90 := lang.NewVector(v59, v64, tmp89, lang.NewKeyword("compact")) - tmp91 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6702), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(6702), lang.NewKeyword("end-column"), int(103)) - tmp92, err := lang.WithMeta(tmp90, tmp91.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp65 = tmp92 - } - tmp52 = tmp65 - } // end let - tmp37 = tmp52 - } - tmp24 = tmp37 - } else { - var tmp53 any - { // let - // let binding "vec__170" - tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp55 := tmp54.FindInternedVar(lang.NewSymbol("merge-hash-collisions")) - if tmp55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) - } - tmp56 := tmp55.Get() - tmp57 := lang.Apply(tmp56, []any{v3, v4, v5, v6}) - var v58 any = tmp57 - _ = v58 - // let binding "tests" - tmp59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp60 := tmp59.FindInternedVar(lang.NewSymbol("nth")) - if tmp60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp60))) - } - tmp61 := tmp60.Get() - tmp62 := lang.Apply(tmp61, []any{v58, int64(0), nil}) - var v63 any = tmp62 - _ = v63 - // let binding "thens" - tmp64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp65 := tmp64.FindInternedVar(lang.NewSymbol("nth")) - if tmp65.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp65))) - } - tmp66 := tmp65.Get() - tmp67 := lang.Apply(tmp66, []any{v58, int64(1), nil}) - var v68 any = tmp67 - _ = v68 - // let binding "skip-check" - tmp69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp70 := tmp69.FindInternedVar(lang.NewSymbol("nth")) - if tmp70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp70))) - } - tmp71 := tmp70.Get() - tmp72 := lang.Apply(tmp71, []any{v58, int64(2), nil}) - var v73 any = tmp72 - _ = v73 - // let binding "vec__173" - tmp74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp75 := tmp74.FindInternedVar(lang.NewSymbol("prep-hashes")) - if tmp75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp75))) - } - tmp76 := tmp75.Get() - tmp77 := lang.Apply(tmp76, []any{v3, v4, v63, v68}) - var v78 any = tmp77 - _ = v78 - // let binding "shift" - tmp79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp80 := tmp79.FindInternedVar(lang.NewSymbol("nth")) - if tmp80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp80))) - } - tmp81 := tmp80.Get() - tmp82 := lang.Apply(tmp81, []any{v78, int64(0), nil}) - var v83 any = tmp82 - _ = v83 - // let binding "mask" - tmp84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp85 := tmp84.FindInternedVar(lang.NewSymbol("nth")) - if tmp85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp85))) - } - tmp86 := tmp85.Get() - tmp87 := lang.Apply(tmp86, []any{v78, int64(1), nil}) - var v88 any = tmp87 - _ = v88 - // let binding "case-map" - tmp89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp90 := tmp89.FindInternedVar(lang.NewSymbol("nth")) - if tmp90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp90))) - } - tmp91 := tmp90.Get() - tmp92 := lang.Apply(tmp91, []any{v78, int64(2), nil}) - var v93 any = tmp92 - _ = v93 - // let binding "switch-type" - tmp94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp95 := tmp94.FindInternedVar(lang.NewSymbol("nth")) - if tmp95.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp95))) - } - tmp96 := tmp95.Get() - tmp97 := lang.Apply(tmp96, []any{v78, int64(3), nil}) - var v98 any = tmp97 - _ = v98 - // let binding "skip-check" - var tmp99 any - tmp100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp101 := tmp100.FindInternedVar(lang.NewSymbol("zero?")) - if tmp101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp101))) - } - tmp102 := tmp101.Get() - tmp103 := lang.Apply(tmp102, []any{v88}) - if lang.IsTruthy(tmp103) { - tmp99 = v73 - } else { - tmp104 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp105 := tmp104.FindInternedVar(lang.NewSymbol("into1")) - if tmp105.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp105))) - } - tmp106 := tmp105.Get() - tmp107 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) - tmp108 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6708), lang.NewKeyword("column"), int(33), lang.NewKeyword("end-line"), int(6708), lang.NewKeyword("end-column"), int(35)) - tmp109, err := lang.WithMeta(tmp107, tmp108.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp111 := tmp110.FindInternedVar(lang.NewSymbol("map")) - if tmp111.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp111))) - } - tmp112 := tmp111.Get() - var tmp113 lang.FnFunc - tmp113 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v114 := args[0] - _ = v114 - tmp115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp116 := tmp115.FindInternedVar(lang.NewSymbol("shift-mask")) - if tmp116.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp116))) - } - tmp117 := tmp116.Get() - tmp118 := lang.Apply(tmp117, []any{v83, v88, v114}) - return tmp118 - }) - tmp114 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6708), lang.NewKeyword("column"), int(42), lang.NewKeyword("end-line"), int(6708), lang.NewKeyword("end-column"), int(67)) - tmp115, err := lang.WithMeta(tmp113, tmp114.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp116 := lang.Apply(tmp112, []any{tmp115, v73}) - tmp117 := lang.Apply(tmp106, []any{tmp109, tmp116}) - tmp99 = tmp117 - } - var v118 any = tmp99 - _ = v118 - tmp119 := lang.NewVector(v83, v88, v93, v98, v118) - tmp120 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6709), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(6709), lang.NewKeyword("end-column"), int(52)) - tmp121, err := lang.WithMeta(tmp119, tmp120.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp53 = tmp121 - } // end let - tmp24 = tmp53 - } - tmp7 = tmp24 - } // end let - return tmp7 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // prep-ints - { - tmp0 := lang.NewSymbol("prep-ints").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tests"), lang.NewSymbol("thens"))), lang.NewKeyword("doc"), "Takes a sequence of int-sized test constants and a corresponding sequence of\n then expressions. Returns a tuple of [shift mask case-map switch-type] where\n case-map is a map of int case values to [test then] tuples, and switch-type\n is either :sparse or :compact.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6631), lang.NewKeyword("end-line"), int(6631), lang.NewKeyword("private"), true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("fits-table?")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(tmp8, []any{v3}) - if lang.IsTruthy(tmp9) { - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("case-map")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("int")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("int")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp12, []any{tmp15, tmp18, v3, v4}) - tmp20 := lang.NewVector(int64(0), int64(0), tmp19, lang.NewKeyword("compact")) - tmp21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6639), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(6639), lang.NewKeyword("end-column"), int(49)) - tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp5 = tmp22 - } else { - var tmp23 any - { // let - // let binding "vec__160" - var tmp24 any - { // let - // let binding "or__0__auto__" - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("maybe-min-hash")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("map")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("int")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp30, []any{tmp33, v3}) - tmp35 := lang.Apply(tmp27, []any{tmp34}) - var v36 any = tmp35 - _ = v36 - var tmp37 any - if lang.IsTruthy(v36) { - tmp37 = v36 - } else { - tmp38 := lang.NewVector(int64(0), int64(0)) - tmp39 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6640), lang.NewKeyword("column"), int(61), lang.NewKeyword("end-line"), int(6640), lang.NewKeyword("end-column"), int(65)) - tmp40, err := lang.WithMeta(tmp38, tmp39.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp37 = tmp40 - } - tmp24 = tmp37 - } // end let - var v25 any = tmp24 - _ = v25 - // let binding "shift" - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("nth")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.Apply(tmp28, []any{v25, int64(0), nil}) - var v30 any = tmp29 - _ = v30 - // let binding "mask" - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("nth")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{v25, int64(1), nil}) - var v35 any = tmp34 - _ = v35 - var tmp36 any - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("zero?")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.Apply(tmp39, []any{v35}) - if lang.IsTruthy(tmp40) { - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("case-map")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("int")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp48 := tmp47.FindInternedVar(lang.NewSymbol("int")) - if tmp48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) - } - tmp49 := tmp48.Get() - tmp50 := lang.Apply(tmp43, []any{tmp46, tmp49, v3, v4}) - tmp51 := lang.NewVector(int64(0), int64(0), tmp50, lang.NewKeyword("sparse")) - tmp52 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6643), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(6643), lang.NewKeyword("end-column"), int(52)) - tmp53, err := lang.WithMeta(tmp51, tmp52.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp36 = tmp53 - } else { - tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp55 := tmp54.FindInternedVar(lang.NewSymbol("case-map")) - if tmp55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) - } - tmp56 := tmp55.Get() - var tmp57 lang.FnFunc - tmp57 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v58 := args[0] - _ = v58 - tmp59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp60 := tmp59.FindInternedVar(lang.NewSymbol("shift-mask")) - if tmp60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp60))) - } - tmp61 := tmp60.Get() - tmp62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp63 := tmp62.FindInternedVar(lang.NewSymbol("int")) - if tmp63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp63))) - } - tmp64 := tmp63.Get() - tmp65 := lang.Apply(tmp64, []any{v58}) - tmp66 := lang.Apply(tmp61, []any{v30, v35, tmp65}) - return tmp66 - }) - tmp58 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6645), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(6645), lang.NewKeyword("end-column"), int(62)) - tmp59, err := lang.WithMeta(tmp57, tmp58.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp61 := tmp60.FindInternedVar(lang.NewSymbol("int")) - if tmp61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) - } - tmp62 := tmp61.Get() - tmp63 := lang.Apply(tmp56, []any{tmp59, tmp62, v3, v4}) - tmp64 := lang.NewVector(v30, v35, tmp63, lang.NewKeyword("compact")) - tmp65 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6645), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(6645), lang.NewKeyword("end-column"), int(89)) - tmp66, err := lang.WithMeta(tmp64, tmp65.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp36 = tmp66 - } - tmp23 = tmp36 - } // end let - tmp5 = tmp23 - } - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // prependss - { - tmp0 := lang.NewSymbol("prependss").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Prepends a symbol or a seq to coll", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5857), lang.NewKeyword("end-line"), int(5857), lang.NewKeyword("private"), true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("symbol?")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(tmp8, []any{v3}) - if lang.IsTruthy(tmp9) { - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("cons")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{v3, v4}) - tmp5 = tmp13 - } else { - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("concat")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{v3, v4}) - tmp5 = tmp17 - } - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // preserving-reduced - { - tmp0 := lang.NewSymbol("preserving-reduced").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7638), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(7638), lang.NewKeyword("end-column"), int(34), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rf"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - var tmp7 any - { // let - // let binding "ret" - tmp8 := lang.Apply(v3, []any{v5, v6}) - var v9 any = tmp8 - _ = v9 - var tmp10 any - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("reduced?")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{v9}) - if lang.IsTruthy(tmp14) { - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("reduced")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{v9}) - tmp10 = tmp18 - } else { - tmp10 = v9 - } - tmp7 = tmp10 - } // end let - return tmp7 - }) - tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7640), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(7643), lang.NewKeyword("end-column"), int(12)) - tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp6 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // print - { - tmp0 := lang.NewSymbol("print").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Prints the object(s) to the output stream that is the current value\n of *out*. print and println produce output for human consumption.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3725), lang.NewKeyword("end-line"), int(3725))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var v3 any = lang.NewList(args[0:]...) - _ = v3 - var tmp4 any - { // let - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("push-thread-bindings")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("hash-map")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*print-readably*")) - tmp12 := lang.Apply(tmp10, []any{tmp11, nil}) - tmp13 := lang.Apply(tmp7, []any{tmp12}) - _ = tmp13 - var tmp14 any - func() { - defer func() { - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, nil) - _ = tmp18 - }() - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("apply")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("pr")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.Apply(tmp21, []any{tmp24, v3}) - tmp14 = tmp25 - }() - tmp4 = tmp14 - } // end let - return tmp4 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // print-ctor - { - tmp0 := lang.NewSymbol("print-ctor").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(95), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(95), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("print-args"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6 := lang.Apply(lang.WriteWriter, []any{v5, "#=("}) - _ = tmp6 - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("class")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp9, []any{v3}) - tmp11, ok := lang.FieldOrMethod(tmp10, "Name") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp10, "Name"))) - } - var tmp12 any - switch reflect.TypeOf(tmp11).Kind() { - case reflect.Func: - tmp12 = lang.Apply(tmp11, nil) - default: - tmp12 = tmp11 - } - tmp13 := lang.Apply(lang.WriteWriter, []any{v5, tmp12}) - _ = tmp13 - tmp14 := lang.Apply(lang.WriteWriter, []any{v5, ". "}) - _ = tmp14 - tmp15 := lang.Apply(v4, []any{v3, v5}) - _ = tmp15 - tmp16 := lang.Apply(lang.WriteWriter, []any{v5, ")"}) - return tmp16 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // print-dup - { - tmp0 := lang.NewSymbol("print-dup").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3667), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(3667), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, nil, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // print-initialized - { - tmp0 := lang.NewSymbol("print-initialized").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(520), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(520), lang.NewKeyword("end-column"), int(39), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, true, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // print-map - { - tmp0 := lang.NewSymbol("print-map").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(252), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(252), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("print-one"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("print-prefix-map")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(tmp8, []any{nil, v3, v4, v5}) - return tmp9 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // print-meta - { - tmp0 := lang.NewSymbol("print-meta").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(70), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(70), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - { // let - // let binding "temp__0__auto__" - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("meta")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(tmp8, []any{v3}) - var v10 any = tmp9 - _ = v10 - var tmp11 any - if lang.IsTruthy(v10) { - var tmp12 any - { // let - // let binding "m" - var v13 any = v10 - _ = v13 - var tmp14 any - var tmp15 any - { // let - // let binding "and__0__auto__" - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("pos?")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("count")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, []any{v13}) - tmp23 := lang.Apply(tmp18, []any{tmp22}) - var v24 any = tmp23 - _ = v24 - var tmp25 any - if lang.IsTruthy(v24) { - var tmp26 any - { // let - // let binding "or__0__auto__" - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("*print-dup*")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - var v30 any = tmp29 - _ = v30 - var tmp31 any - if lang.IsTruthy(v30) { - tmp31 = v30 - } else { - var tmp32 any - { // let - // let binding "and__0__auto__" - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("*print-meta*")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - var v36 any = tmp35 - _ = v36 - var tmp37 any - if lang.IsTruthy(v36) { - tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp39 := tmp38.FindInternedVar(lang.NewSymbol("*print-readably*")) - if tmp39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) - } - tmp40 := tmp39.Get() - tmp37 = tmp40 - } else { - tmp37 = v36 - } - tmp32 = tmp37 - } // end let - tmp31 = tmp32 - } - tmp26 = tmp31 - } // end let - tmp25 = tmp26 - } else { - tmp25 = v24 - } - tmp15 = tmp25 - } // end let - if lang.IsTruthy(tmp15) { - tmp16 := lang.Apply(lang.WriteWriter, []any{v4, "^"}) - _ = tmp16 - var tmp17 any - var tmp18 any - { // let - // let binding "and__0__auto__" - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("=")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("count")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.Apply(tmp24, []any{v13}) - tmp26 := lang.Apply(tmp21, []any{tmp25, int64(1)}) - var v27 any = tmp26 - _ = v27 - var tmp28 any - if lang.IsTruthy(v27) { - tmp29 := lang.Apply(lang.NewKeyword("tag"), []any{v13}) - tmp28 = tmp29 - } else { - tmp28 = v27 - } - tmp18 = tmp28 - } // end let - if lang.IsTruthy(tmp18) { - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("pr-on")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(lang.NewKeyword("tag"), []any{v13}) - tmp23 := lang.Apply(tmp21, []any{tmp22, v4}) - tmp17 = tmp23 - } else { - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("pr-on")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.Apply(tmp26, []any{v13, v4}) - tmp17 = tmp27 - } - _ = tmp17 - tmp28 := lang.Apply(lang.WriteWriter, []any{v4, " "}) - tmp14 = tmp28 - } else { - } - tmp12 = tmp14 - } // end let - tmp11 = tmp12 - } else { - } - tmp5 = tmp11 - } // end let - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // print-method - { - tmp0 := lang.NewSymbol("print-method").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3664), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(3664), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, nil, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // print-object - { - tmp0 := lang.NewSymbol("print-object").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(115), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(115), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("print-tagged-object")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("str")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v3}) - tmp12 := lang.Apply(tmp7, []any{v3, tmp11, v4}) - return tmp12 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // print-prefix-map - { - tmp0 := lang.NewSymbol("print-prefix-map").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(243), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(243), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("prefix"), lang.NewSymbol("kvs"), lang.NewSymbol("print-one"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("print-sequential")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("str")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{v3, "{"}) - var tmp14 lang.FnFunc - tmp14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v15 := args[0] - _ = v15 - v16 := args[1] - _ = v16 - var tmp17 any - { // let - // let binding "vec__212" - var v18 any = v15 - _ = v18 - // let binding "k" - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("nth")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, []any{v18, int64(0), nil}) - var v23 any = tmp22 - _ = v23 - // let binding "v" - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("nth")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.Apply(tmp26, []any{v18, int64(1), nil}) - var v28 any = tmp27 - _ = v28 - tmp29 := lang.Apply(v5, []any{v23, v16}) - _ = tmp29 - tmp30 := lang.Apply(lang.AppendWriter, []any{v16, lang.NewChar(32)}) - _ = tmp30 - tmp31 := lang.Apply(v5, []any{v28, v16}) - tmp17 = tmp31 - } // end let - return tmp17 - }) - tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(246), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(247), lang.NewKeyword("end-column"), int(107)) - tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp17 := lang.Apply(tmp9, []any{tmp13, tmp16, ", ", "}", v4, v6}) - return tmp17 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // print-sequential - { - tmp0 := lang.NewSymbol("print-sequential").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(46), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(46), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("begin"), lang.NewSymbol("print-one"), lang.NewSymbol("sep"), lang.NewSymbol("end"), lang.NewSymbol("sequence"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 6 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - v7 := args[4] - _ = v7 - v8 := args[5] - _ = v8 - var tmp9 any - { // let - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("push-thread-bindings")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("hash-map")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*print-level*")) - var tmp17 any - { // let - // let binding "and__0__auto__" - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("not")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("*print-dup*")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.Apply(tmp20, []any{tmp23}) - var v25 any = tmp24 - _ = v25 - var tmp26 any - if lang.IsTruthy(v25) { - var tmp27 any - { // let - // let binding "and__0__auto__" - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("*print-level*")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - var v31 any = tmp30 - _ = v31 - var tmp32 any - if lang.IsTruthy(v31) { - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("dec")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("*print-level*")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp35, []any{tmp38}) - tmp32 = tmp39 - } else { - tmp32 = v31 - } - tmp27 = tmp32 - } // end let - tmp26 = tmp27 - } else { - tmp26 = v25 - } - tmp17 = tmp26 - } // end let - tmp18 := lang.Apply(tmp15, []any{tmp16, tmp17}) - tmp19 := lang.Apply(tmp12, []any{tmp18}) - _ = tmp19 - var tmp20 any - func() { - defer func() { - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.Apply(tmp23, nil) - _ = tmp24 - }() - var tmp25 any - var tmp26 any - { // let - // let binding "and__0__auto__" - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("*print-level*")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - var v30 any = tmp29 - _ = v30 - var tmp31 any - if lang.IsTruthy(v30) { - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("neg?")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp36 := tmp35.FindInternedVar(lang.NewSymbol("*print-level*")) - if tmp36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) - } - tmp37 := tmp36.Get() - tmp38 := lang.Apply(tmp34, []any{tmp37}) - tmp31 = tmp38 - } else { - tmp31 = v30 - } - tmp26 = tmp31 - } // end let - if lang.IsTruthy(tmp26) { - tmp27 := lang.Apply(lang.WriteWriter, []any{v8, "#"}) - tmp25 = tmp27 - } else { - tmp28 := lang.Apply(lang.WriteWriter, []any{v8, v3}) - _ = tmp28 - var tmp29 any - { // let - // let binding "temp__0__auto__" - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("seq")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.Apply(tmp32, []any{v7}) - var v34 any = tmp33 - _ = v34 - var tmp35 any - if lang.IsTruthy(v34) { - var tmp36 any - { // let - // let binding "xs" - var v37 any = v34 - _ = v37 - var tmp38 any - var tmp39 any - { // let - // let binding "and__0__auto__" - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("not")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp44 := tmp43.FindInternedVar(lang.NewSymbol("*print-dup*")) - if tmp44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) - } - tmp45 := tmp44.Get() - tmp46 := lang.Apply(tmp42, []any{tmp45}) - var v47 any = tmp46 - _ = v47 - var tmp48 any - if lang.IsTruthy(v47) { - tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp50 := tmp49.FindInternedVar(lang.NewSymbol("*print-length*")) - if tmp50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) - } - tmp51 := tmp50.Get() - tmp48 = tmp51 - } else { - tmp48 = v47 - } - tmp39 = tmp48 - } // end let - if lang.IsTruthy(tmp39) { - var tmp40 any - { // let - // let binding "G__194" - var v41 any = v37 - _ = v41 - // let binding "vec__195" - var v42 any = v41 - _ = v42 - // let binding "seq__196" - tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp44 := tmp43.FindInternedVar(lang.NewSymbol("seq")) - if tmp44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) - } - tmp45 := tmp44.Get() - tmp46 := lang.Apply(tmp45, []any{v42}) - var v47 any = tmp46 - _ = v47 - // let binding "first__197" - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("first")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v47}) - var v52 any = tmp51 - _ = v52 - // let binding "seq__196" - tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp54 := tmp53.FindInternedVar(lang.NewSymbol("next")) - if tmp54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) - } - tmp55 := tmp54.Get() - tmp56 := lang.Apply(tmp55, []any{v47}) - var v57 any = tmp56 - _ = v57 - // let binding "x" - var v58 any = v52 - _ = v58 - // let binding "xs" - var v59 any = v57 - _ = v59 - // let binding "print-length" - tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp61 := tmp60.FindInternedVar(lang.NewSymbol("*print-length*")) - if tmp61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) - } - tmp62 := tmp61.Get() - var v63 any = tmp62 - _ = v63 - var tmp64 any - { // let - // let binding "G__194" - var v65 any = v41 - _ = v65 - // let binding "print-length" - var v66 any = v63 - _ = v66 - for { - var tmp67 any - { // let - // let binding "vec__198" - var v68 any = v65 - _ = v68 - // let binding "seq__199" - tmp69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp70 := tmp69.FindInternedVar(lang.NewSymbol("seq")) - if tmp70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp70))) - } - tmp71 := tmp70.Get() - tmp72 := lang.Apply(tmp71, []any{v68}) - var v73 any = tmp72 - _ = v73 - // let binding "first__200" - tmp74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp75 := tmp74.FindInternedVar(lang.NewSymbol("first")) - if tmp75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp75))) - } - tmp76 := tmp75.Get() - tmp77 := lang.Apply(tmp76, []any{v73}) - var v78 any = tmp77 - _ = v78 - // let binding "seq__199" - tmp79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp80 := tmp79.FindInternedVar(lang.NewSymbol("next")) - if tmp80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp80))) - } - tmp81 := tmp80.Get() - tmp82 := lang.Apply(tmp81, []any{v73}) - var v83 any = tmp82 - _ = v83 - // let binding "x" - var v84 any = v78 - _ = v84 - // let binding "xs" - var v85 any = v83 - _ = v85 - // let binding "print-length" - var v86 any = v66 - _ = v86 - var tmp87 any - tmp88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp89 := tmp88.FindInternedVar(lang.NewSymbol("zero?")) - if tmp89.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp89))) - } - tmp90 := tmp89.Get() - tmp91 := lang.Apply(tmp90, []any{v86}) - if lang.IsTruthy(tmp91) { - tmp92 := lang.Apply(lang.WriteWriter, []any{v8, "..."}) - tmp87 = tmp92 - } else { - tmp93 := lang.Apply(v4, []any{v84, v8}) - _ = tmp93 - var tmp94 any - if lang.IsTruthy(v85) { - tmp95 := lang.Apply(lang.WriteWriter, []any{v8, v5}) - _ = tmp95 - var tmp96 any = v85 - tmp98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp99 := tmp98.FindInternedVar(lang.NewSymbol("dec")) - if tmp99.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp99))) - } - tmp100 := tmp99.Get() - tmp101 := lang.Apply(tmp100, []any{v86}) - var tmp97 any = tmp101 - v65 = tmp96 - v66 = tmp97 - continue - } else { - } - tmp87 = tmp94 - } - tmp67 = tmp87 - } // end let - tmp64 = tmp67 - break - } - } // end let - tmp40 = tmp64 - } // end let - tmp38 = tmp40 - } else { - var tmp41 any - { // let - // let binding "G__204" - var v42 any = v37 - _ = v42 - // let binding "vec__205" - var v43 any = v42 - _ = v43 - // let binding "seq__206" - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("seq")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.Apply(tmp46, []any{v43}) - var v48 any = tmp47 - _ = v48 - // let binding "first__207" - tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp50 := tmp49.FindInternedVar(lang.NewSymbol("first")) - if tmp50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) - } - tmp51 := tmp50.Get() - tmp52 := lang.Apply(tmp51, []any{v48}) - var v53 any = tmp52 - _ = v53 - // let binding "seq__206" - tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp55 := tmp54.FindInternedVar(lang.NewSymbol("next")) - if tmp55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) - } - tmp56 := tmp55.Get() - tmp57 := lang.Apply(tmp56, []any{v48}) - var v58 any = tmp57 - _ = v58 - // let binding "x" - var v59 any = v53 - _ = v59 - // let binding "xs" - var v60 any = v58 - _ = v60 - var tmp61 any - { // let - // let binding "G__204" - var v62 any = v42 - _ = v62 - for { - var tmp63 any - { // let - // let binding "vec__208" - var v64 any = v62 - _ = v64 - // let binding "seq__209" - tmp65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp66 := tmp65.FindInternedVar(lang.NewSymbol("seq")) - if tmp66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp66))) - } - tmp67 := tmp66.Get() - tmp68 := lang.Apply(tmp67, []any{v64}) - var v69 any = tmp68 - _ = v69 - // let binding "first__210" - tmp70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp71 := tmp70.FindInternedVar(lang.NewSymbol("first")) - if tmp71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp71))) - } - tmp72 := tmp71.Get() - tmp73 := lang.Apply(tmp72, []any{v69}) - var v74 any = tmp73 - _ = v74 - // let binding "seq__209" - tmp75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp76 := tmp75.FindInternedVar(lang.NewSymbol("next")) - if tmp76.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp76))) - } - tmp77 := tmp76.Get() - tmp78 := lang.Apply(tmp77, []any{v69}) - var v79 any = tmp78 - _ = v79 - // let binding "x" - var v80 any = v74 - _ = v80 - // let binding "xs" - var v81 any = v79 - _ = v81 - tmp82 := lang.Apply(v4, []any{v80, v8}) - _ = tmp82 - var tmp83 any - if lang.IsTruthy(v81) { - tmp84 := lang.Apply(lang.WriteWriter, []any{v8, v5}) - _ = tmp84 - var tmp85 any = v81 - v62 = tmp85 - continue - } else { - } - tmp63 = tmp83 - } // end let - tmp61 = tmp63 - break - } - } // end let - tmp41 = tmp61 - } // end let - tmp38 = tmp41 - } - tmp36 = tmp38 - } // end let - tmp35 = tmp36 - } else { - } - tmp29 = tmp35 - } // end let - _ = tmp29 - tmp30 := lang.Apply(lang.WriteWriter, []any{v8, v6}) - tmp25 = tmp30 - } - tmp20 = tmp25 - }() - tmp9 = tmp20 - } // end let - return tmp9 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // print-simple - { - tmp0 := lang.NewSymbol("print-simple").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(81), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(81), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("print-meta")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v3, v4}) - _ = tmp8 - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("str")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.Apply(tmp11, []any{v3}) - tmp13 := lang.Apply(lang.WriteWriter, []any{v4, tmp12}) - return tmp13 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // print-str - { - tmp1 := reflect.TypeOf("") - tmp0 := lang.NewSymbol("print-str").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("xs"))), lang.NewKeyword("doc"), "print to a string, returning it", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4776), lang.NewKeyword("end-line"), int(4776))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var v4 any = lang.NewList(args[0:]...) - _ = v4 - var tmp5 any - { // let - // let binding "s__0__auto__" - var v6 any = "unimplemented: new with non-constant class type" - _ = v6 - var tmp7 any - { // let - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("push-thread-bindings")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("hash-map")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*out*")) - tmp15 := lang.Apply(tmp13, []any{tmp14, v6}) - tmp16 := lang.Apply(tmp10, []any{tmp15}) - _ = tmp16 - var tmp17 any - func() { - defer func() { - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.Apply(tmp20, nil) - _ = tmp21 - }() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("apply")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("print")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.Apply(tmp24, []any{tmp27, v4}) - _ = tmp28 - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("str")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.Apply(tmp31, []any{v6}) - tmp17 = tmp32 - }() - tmp7 = tmp17 - } // end let - tmp5 = tmp7 - } // end let - return tmp5 - } - }) - tmp4 := reflect.TypeOf("") - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // print-tagged-object - { - tmp0 := lang.NewSymbol("print-tagged-object").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(102), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(102), lang.NewKeyword("end-column"), int(26), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("rep"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var tmp6 any - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("instance?")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := reflect.TypeOf((*lang.IMeta)(nil)).Elem() - tmp11 := lang.Apply(tmp9, []any{tmp10, v3}) - if lang.IsTruthy(tmp11) { - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("print-meta")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.Apply(tmp14, []any{v3, v5}) - tmp6 = tmp15 - } else { - } - _ = tmp6 - tmp16 := lang.Apply(lang.WriteWriter, []any{v5, "#object["}) - _ = tmp16 - var tmp17 any - { // let - // let binding "c" - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("class")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.Apply(tmp20, []any{v3}) - var v22 any = tmp21 - _ = v22 - var tmp23 any - if lang.IsTruthy(false) { - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("print-method")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27, ok := lang.FieldOrMethod(v22, "Name") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v22, "Name"))) - } - var tmp28 any - switch reflect.TypeOf(tmp27).Kind() { - case reflect.Func: - tmp28 = lang.Apply(tmp27, nil) - default: - tmp28 = tmp27 - } - tmp29 := lang.Apply(tmp26, []any{tmp28, v5}) - tmp23 = tmp29 - } else { - tmp30, ok := lang.FieldOrMethod(v22, "Name") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v22, "Name"))) - } - var tmp31 any - switch reflect.TypeOf(tmp30).Kind() { - case reflect.Func: - tmp31 = lang.Apply(tmp30, nil) - default: - tmp31 = tmp30 - } - tmp32 := lang.Apply(lang.WriteWriter, []any{v5, tmp31}) - tmp23 = tmp32 - } - tmp17 = tmp23 - } // end let - _ = tmp17 - tmp18 := lang.Apply(lang.WriteWriter, []any{v5, " "}) - _ = tmp18 - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("format")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(lang.IdentityHash, []any{v3}) - tmp23 := lang.Apply(tmp21, []any{"0x%x ", tmp22}) - tmp24 := lang.Apply(lang.WriteWriter, []any{v5, tmp23}) - _ = tmp24 - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("print-method")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.Apply(tmp27, []any{v4, v5}) - _ = tmp28 - tmp29 := lang.Apply(lang.WriteWriter, []any{v5, "]"}) - return tmp29 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // print-throwable - { - tmp0 := lang.NewSymbol("print-throwable").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(478), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(478), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.Apply(lang.WriteWriter, []any{v4, "#error {\n :cause "}) - _ = tmp5 - var tmp6 any - { // let - // let binding "map__253" - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("Throwable->map")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp9, []any{v3}) - var v11 any = tmp10 - _ = v11 - // let binding "map__253" - var tmp12 any - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("seq?")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{v11}) - if lang.IsTruthy(tmp16) { - var tmp17 any - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("next")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.Apply(tmp20, []any{v11}) - if lang.IsTruthy(tmp21) { - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("to-array")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.Apply(tmp24, []any{v11}) - tmp26 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{tmp25}) - tmp17 = tmp26 - } else { - var tmp27 any - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("seq")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.Apply(tmp30, []any{v11}) - if lang.IsTruthy(tmp31) { - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("first")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.Apply(tmp34, []any{v11}) - tmp27 = tmp35 - } else { - } - tmp17 = tmp27 - } - tmp12 = tmp17 - } else { - tmp12 = v11 - } - var v36 any = tmp12 - _ = v36 - // let binding "cause" - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("get")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.Apply(tmp39, []any{v36, lang.NewKeyword("cause")}) - var v41 any = tmp40 - _ = v41 - // let binding "data" - tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp43 := tmp42.FindInternedVar(lang.NewSymbol("get")) - if tmp43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) - } - tmp44 := tmp43.Get() - tmp45 := lang.Apply(tmp44, []any{v36, lang.NewKeyword("data")}) - var v46 any = tmp45 - _ = v46 - // let binding "via" - tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp48 := tmp47.FindInternedVar(lang.NewSymbol("get")) - if tmp48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) - } - tmp49 := tmp48.Get() - tmp50 := lang.Apply(tmp49, []any{v36, lang.NewKeyword("via")}) - var v51 any = tmp50 - _ = v51 - // let binding "trace" - tmp52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp53 := tmp52.FindInternedVar(lang.NewSymbol("get")) - if tmp53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp53))) - } - tmp54 := tmp53.Get() - tmp55 := lang.Apply(tmp54, []any{v36, lang.NewKeyword("trace")}) - var v56 any = tmp55 - _ = v56 - // let binding "print-via" - var tmp57 lang.FnFunc - tmp57 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v58 := args[0] - _ = v58 - tmp59 := lang.Apply(lang.WriteWriter, []any{v4, "{:type "}) - _ = tmp59 - tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp61 := tmp60.FindInternedVar(lang.NewSymbol("print-method")) - if tmp61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) - } - tmp62 := tmp61.Get() - tmp63 := lang.Apply(lang.NewKeyword("type"), []any{v58}) - tmp64 := lang.Apply(tmp62, []any{tmp63, v4}) - _ = tmp64 - tmp65 := lang.Apply(lang.WriteWriter, []any{v4, "\n :message "}) - _ = tmp65 - tmp66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp67 := tmp66.FindInternedVar(lang.NewSymbol("print-method")) - if tmp67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp67))) - } - tmp68 := tmp67.Get() - tmp69 := lang.Apply(lang.NewKeyword("message"), []any{v58}) - tmp70 := lang.Apply(tmp68, []any{tmp69, v4}) - _ = tmp70 - var tmp71 any - { // let - // let binding "temp__0__auto__" - tmp72 := lang.Apply(lang.NewKeyword("data"), []any{v58}) - var v73 any = tmp72 - _ = v73 - var tmp74 any - if lang.IsTruthy(v73) { - var tmp75 any - { // let - // let binding "data" - var v76 any = v73 - _ = v76 - tmp77 := lang.Apply(lang.WriteWriter, []any{v4, "\n :data "}) - _ = tmp77 - tmp78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp79 := tmp78.FindInternedVar(lang.NewSymbol("print-method")) - if tmp79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp79))) - } - tmp80 := tmp79.Get() - tmp81 := lang.Apply(tmp80, []any{v76, v4}) - tmp75 = tmp81 - } // end let - tmp74 = tmp75 - } else { - } - tmp71 = tmp74 - } // end let - _ = tmp71 - var tmp72 any - { // let - // let binding "temp__0__auto__" - tmp73 := lang.Apply(lang.NewKeyword("at"), []any{v58}) - var v74 any = tmp73 - _ = v74 - var tmp75 any - if lang.IsTruthy(v74) { - var tmp76 any - { // let - // let binding "at" - var v77 any = v74 - _ = v77 - tmp78 := lang.Apply(lang.WriteWriter, []any{v4, "\n :at "}) - _ = tmp78 - tmp79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp80 := tmp79.FindInternedVar(lang.NewSymbol("print-method")) - if tmp80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp80))) - } - tmp81 := tmp80.Get() - tmp82 := lang.Apply(lang.NewKeyword("at"), []any{v58}) - tmp83 := lang.Apply(tmp81, []any{tmp82, v4}) - tmp76 = tmp83 - } // end let - tmp75 = tmp76 - } else { - } - tmp72 = tmp75 - } // end let - _ = tmp72 - tmp73 := lang.Apply(lang.WriteWriter, []any{v4, "}"}) - return tmp73 - }) - tmp58 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(481), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(491), lang.NewKeyword("end-column"), int(73)) - tmp59, err := lang.WithMeta(tmp57, tmp58.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v60 any = tmp59 - _ = v60 - tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp62 := tmp61.FindInternedVar(lang.NewSymbol("print-method")) - if tmp62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) - } - tmp63 := tmp62.Get() - tmp64 := lang.Apply(tmp63, []any{v41, v4}) - _ = tmp64 - var tmp65 any - if lang.IsTruthy(v46) { - tmp66 := lang.Apply(lang.WriteWriter, []any{v4, "\n :data "}) - _ = tmp66 - tmp67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp68 := tmp67.FindInternedVar(lang.NewSymbol("print-method")) - if tmp68.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp68))) - } - tmp69 := tmp68.Get() - tmp70 := lang.Apply(tmp69, []any{v46, v4}) - tmp65 = tmp70 - } else { - } - _ = tmp65 - var tmp71 any - if lang.IsTruthy(v51) { - tmp72 := lang.Apply(lang.WriteWriter, []any{v4, "\n :via\n ["}) - _ = tmp72 - var tmp73 any - { // let - // let binding "temp__0__auto__" - tmp74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp75 := tmp74.FindInternedVar(lang.NewSymbol("first")) - if tmp75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp75))) - } - tmp76 := tmp75.Get() - tmp77 := lang.Apply(tmp76, []any{v51}) - var v78 any = tmp77 - _ = v78 - var tmp79 any - if lang.IsTruthy(v78) { - var tmp80 any - { // let - // let binding "fv" - var v81 any = v78 - _ = v81 - tmp82 := lang.Apply(v60, []any{v81}) - _ = tmp82 - var tmp83 any - { // let - // let binding "seq_254" - tmp84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp85 := tmp84.FindInternedVar(lang.NewSymbol("seq")) - if tmp85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp85))) - } - tmp86 := tmp85.Get() - tmp87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp88 := tmp87.FindInternedVar(lang.NewSymbol("rest")) - if tmp88.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp88))) - } - tmp89 := tmp88.Get() - tmp90 := lang.Apply(tmp89, []any{v51}) - tmp91 := lang.Apply(tmp86, []any{tmp90}) - var v92 any = tmp91 - _ = v92 - // let binding "chunk_255" - var v93 any = nil - _ = v93 - // let binding "count_256" - var v94 any = int64(0) - _ = v94 - // let binding "i_257" - var v95 any = int64(0) - _ = v95 - for { - var tmp96 any - tmp97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp98 := tmp97.FindInternedVar(lang.NewSymbol("<")) - if tmp98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp98))) - } - tmp99 := tmp98.Get() - tmp100 := lang.Apply(tmp99, []any{v95, v94}) - if lang.IsTruthy(tmp100) { - var tmp101 any - { // let - // let binding "v" - tmp102, _ := lang.FieldOrMethod(v93, "nth") - if reflect.TypeOf(tmp102).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) - } - tmp103 := lang.Apply(tmp102, []any{v95}) - var v104 any = tmp103 - _ = v104 - tmp105 := lang.Apply(lang.WriteWriter, []any{v4, "\n "}) - _ = tmp105 - tmp106 := lang.Apply(v60, []any{v104}) - _ = tmp106 - var tmp107 any = v92 - var tmp108 any = v93 - var tmp109 any = v94 - tmp111 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp112 := tmp111.FindInternedVar(lang.NewSymbol("unchecked-inc")) - if tmp112.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp112))) - } - tmp113 := tmp112.Get() - tmp114 := lang.Apply(tmp113, []any{v95}) - var tmp110 any = tmp114 - v92 = tmp107 - v93 = tmp108 - v94 = tmp109 - v95 = tmp110 - continue - } // end let - tmp96 = tmp101 - } else { - var tmp102 any - { // let - // let binding "temp__0__auto__" - tmp103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp104 := tmp103.FindInternedVar(lang.NewSymbol("seq")) - if tmp104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp104))) - } - tmp105 := tmp104.Get() - tmp106 := lang.Apply(tmp105, []any{v92}) - var v107 any = tmp106 - _ = v107 - var tmp108 any - if lang.IsTruthy(v107) { - var tmp109 any - { // let - // let binding "seq_254" - var v110 any = v107 - _ = v110 - var tmp111 any - tmp112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp113 := tmp112.FindInternedVar(lang.NewSymbol("chunked-seq?")) - if tmp113.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp113))) - } - tmp114 := tmp113.Get() - tmp115 := lang.Apply(tmp114, []any{v110}) - if lang.IsTruthy(tmp115) { - var tmp116 any - { // let - // let binding "c__0__auto__" - tmp117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp118 := tmp117.FindInternedVar(lang.NewSymbol("chunk-first")) - if tmp118.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp118))) - } - tmp119 := tmp118.Get() - tmp120 := lang.Apply(tmp119, []any{v110}) - var v121 any = tmp120 - _ = v121 - tmp123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp124 := tmp123.FindInternedVar(lang.NewSymbol("chunk-rest")) - if tmp124.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp124))) - } - tmp125 := tmp124.Get() - tmp126 := lang.Apply(tmp125, []any{v110}) - var tmp122 any = tmp126 - var tmp127 any = v121 - tmp129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp130 := tmp129.FindInternedVar(lang.NewSymbol("int")) - if tmp130.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp130))) - } - tmp131 := tmp130.Get() - tmp132 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp133 := tmp132.FindInternedVar(lang.NewSymbol("count")) - if tmp133.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp133))) - } - tmp134 := tmp133.Get() - tmp135 := lang.Apply(tmp134, []any{v121}) - tmp136 := lang.Apply(tmp131, []any{tmp135}) - var tmp128 any = tmp136 - tmp138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp139 := tmp138.FindInternedVar(lang.NewSymbol("int")) - if tmp139.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp139))) - } - tmp140 := tmp139.Get() - tmp141 := lang.Apply(tmp140, []any{int64(0)}) - var tmp137 any = tmp141 - v92 = tmp122 - v93 = tmp127 - v94 = tmp128 - v95 = tmp137 - continue - } // end let - tmp111 = tmp116 - } else { - var tmp117 any - { // let - // let binding "v" - tmp118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp119 := tmp118.FindInternedVar(lang.NewSymbol("first")) - if tmp119.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp119))) - } - tmp120 := tmp119.Get() - tmp121 := lang.Apply(tmp120, []any{v110}) - var v122 any = tmp121 - _ = v122 - tmp123 := lang.Apply(lang.WriteWriter, []any{v4, "\n "}) - _ = tmp123 - tmp124 := lang.Apply(v60, []any{v122}) - _ = tmp124 - tmp126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp127 := tmp126.FindInternedVar(lang.NewSymbol("next")) - if tmp127.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp127))) - } - tmp128 := tmp127.Get() - tmp129 := lang.Apply(tmp128, []any{v110}) - var tmp125 any = tmp129 - var tmp130 any = nil - var tmp131 any = int64(0) - var tmp132 any = int64(0) - v92 = tmp125 - v93 = tmp130 - v94 = tmp131 - v95 = tmp132 - continue - } // end let - tmp111 = tmp117 - } - tmp109 = tmp111 - } // end let - tmp108 = tmp109 - } else { - } - tmp102 = tmp108 - } // end let - tmp96 = tmp102 - } - tmp83 = tmp96 - break - } - } // end let - tmp80 = tmp83 - } // end let - tmp79 = tmp80 - } else { - } - tmp73 = tmp79 - } // end let - _ = tmp73 - tmp74 := lang.Apply(lang.WriteWriter, []any{v4, "]"}) - tmp71 = tmp74 - } else { - } - _ = tmp71 - var tmp75 any - if lang.IsTruthy(v56) { - tmp76 := lang.Apply(lang.WriteWriter, []any{v4, "\n :trace\n ["}) - _ = tmp76 - var tmp77 any - { // let - // let binding "temp__0__auto__" - tmp78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp79 := tmp78.FindInternedVar(lang.NewSymbol("first")) - if tmp79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp79))) - } - tmp80 := tmp79.Get() - tmp81 := lang.Apply(tmp80, []any{v56}) - var v82 any = tmp81 - _ = v82 - var tmp83 any - if lang.IsTruthy(v82) { - var tmp84 any - { // let - // let binding "ft" - var v85 any = v82 - _ = v85 - tmp86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp87 := tmp86.FindInternedVar(lang.NewSymbol("print-method")) - if tmp87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp87))) - } - tmp88 := tmp87.Get() - tmp89 := lang.Apply(tmp88, []any{v85, v4}) - _ = tmp89 - var tmp90 any - { // let - // let binding "seq_258" - tmp91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp92 := tmp91.FindInternedVar(lang.NewSymbol("seq")) - if tmp92.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp92))) - } - tmp93 := tmp92.Get() - tmp94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp95 := tmp94.FindInternedVar(lang.NewSymbol("rest")) - if tmp95.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp95))) - } - tmp96 := tmp95.Get() - tmp97 := lang.Apply(tmp96, []any{v56}) - tmp98 := lang.Apply(tmp93, []any{tmp97}) - var v99 any = tmp98 - _ = v99 - // let binding "chunk_259" - var v100 any = nil - _ = v100 - // let binding "count_260" - var v101 any = int64(0) - _ = v101 - // let binding "i_261" - var v102 any = int64(0) - _ = v102 - for { - var tmp103 any - tmp104 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp105 := tmp104.FindInternedVar(lang.NewSymbol("<")) - if tmp105.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp105))) - } - tmp106 := tmp105.Get() - tmp107 := lang.Apply(tmp106, []any{v102, v101}) - if lang.IsTruthy(tmp107) { - var tmp108 any - { // let - // let binding "t" - tmp109, _ := lang.FieldOrMethod(v100, "nth") - if reflect.TypeOf(tmp109).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) - } - tmp110 := lang.Apply(tmp109, []any{v102}) - var v111 any = tmp110 - _ = v111 - tmp112 := lang.Apply(lang.WriteWriter, []any{v4, "\n "}) - _ = tmp112 - tmp113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp114 := tmp113.FindInternedVar(lang.NewSymbol("print-method")) - if tmp114.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp114))) - } - tmp115 := tmp114.Get() - tmp116 := lang.Apply(tmp115, []any{v111, v4}) - _ = tmp116 - var tmp117 any = v99 - var tmp118 any = v100 - var tmp119 any = v101 - tmp121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp122 := tmp121.FindInternedVar(lang.NewSymbol("unchecked-inc")) - if tmp122.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp122))) - } - tmp123 := tmp122.Get() - tmp124 := lang.Apply(tmp123, []any{v102}) - var tmp120 any = tmp124 - v99 = tmp117 - v100 = tmp118 - v101 = tmp119 - v102 = tmp120 - continue - } // end let - tmp103 = tmp108 - } else { - var tmp109 any - { // let - // let binding "temp__0__auto__" - tmp110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp111 := tmp110.FindInternedVar(lang.NewSymbol("seq")) - if tmp111.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp111))) - } - tmp112 := tmp111.Get() - tmp113 := lang.Apply(tmp112, []any{v99}) - var v114 any = tmp113 - _ = v114 - var tmp115 any - if lang.IsTruthy(v114) { - var tmp116 any - { // let - // let binding "seq_258" - var v117 any = v114 - _ = v117 - var tmp118 any - tmp119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp120 := tmp119.FindInternedVar(lang.NewSymbol("chunked-seq?")) - if tmp120.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp120))) - } - tmp121 := tmp120.Get() - tmp122 := lang.Apply(tmp121, []any{v117}) - if lang.IsTruthy(tmp122) { - var tmp123 any - { // let - // let binding "c__0__auto__" - tmp124 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp125 := tmp124.FindInternedVar(lang.NewSymbol("chunk-first")) - if tmp125.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp125))) - } - tmp126 := tmp125.Get() - tmp127 := lang.Apply(tmp126, []any{v117}) - var v128 any = tmp127 - _ = v128 - tmp130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp131 := tmp130.FindInternedVar(lang.NewSymbol("chunk-rest")) - if tmp131.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp131))) - } - tmp132 := tmp131.Get() - tmp133 := lang.Apply(tmp132, []any{v117}) - var tmp129 any = tmp133 - var tmp134 any = v128 - tmp136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp137 := tmp136.FindInternedVar(lang.NewSymbol("int")) - if tmp137.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp137))) - } - tmp138 := tmp137.Get() - tmp139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp140 := tmp139.FindInternedVar(lang.NewSymbol("count")) - if tmp140.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp140))) - } - tmp141 := tmp140.Get() - tmp142 := lang.Apply(tmp141, []any{v128}) - tmp143 := lang.Apply(tmp138, []any{tmp142}) - var tmp135 any = tmp143 - tmp145 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp146 := tmp145.FindInternedVar(lang.NewSymbol("int")) - if tmp146.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp146))) - } - tmp147 := tmp146.Get() - tmp148 := lang.Apply(tmp147, []any{int64(0)}) - var tmp144 any = tmp148 - v99 = tmp129 - v100 = tmp134 - v101 = tmp135 - v102 = tmp144 - continue - } // end let - tmp118 = tmp123 - } else { - var tmp124 any - { // let - // let binding "t" - tmp125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp126 := tmp125.FindInternedVar(lang.NewSymbol("first")) - if tmp126.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp126))) - } - tmp127 := tmp126.Get() - tmp128 := lang.Apply(tmp127, []any{v117}) - var v129 any = tmp128 - _ = v129 - tmp130 := lang.Apply(lang.WriteWriter, []any{v4, "\n "}) - _ = tmp130 - tmp131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp132 := tmp131.FindInternedVar(lang.NewSymbol("print-method")) - if tmp132.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp132))) - } - tmp133 := tmp132.Get() - tmp134 := lang.Apply(tmp133, []any{v129, v4}) - _ = tmp134 - tmp136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp137 := tmp136.FindInternedVar(lang.NewSymbol("next")) - if tmp137.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp137))) - } - tmp138 := tmp137.Get() - tmp139 := lang.Apply(tmp138, []any{v117}) - var tmp135 any = tmp139 - var tmp140 any = nil - var tmp141 any = int64(0) - var tmp142 any = int64(0) - v99 = tmp135 - v100 = tmp140 - v101 = tmp141 - v102 = tmp142 - continue - } // end let - tmp118 = tmp124 - } - tmp116 = tmp118 - } // end let - tmp115 = tmp116 - } else { - } - tmp109 = tmp115 - } // end let - tmp103 = tmp109 - } - tmp90 = tmp103 - break - } - } // end let - tmp84 = tmp90 - } // end let - tmp83 = tmp84 - } else { - } - tmp77 = tmp83 - } // end let - _ = tmp77 - tmp78 := lang.Apply(lang.WriteWriter, []any{v4, "]"}) - tmp75 = tmp78 - } else { - } - tmp6 = tmp75 - } // end let - _ = tmp6 - tmp7 := lang.Apply(lang.WriteWriter, []any{v4, "}"}) - return tmp7 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // printf - { - tmp0 := lang.NewSymbol("printf").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fmt"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Prints formatted output, as per format", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5725), lang.NewKeyword("end-line"), int(5725))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var v4 any = lang.NewList(args[1:]...) - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("print")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("apply")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("format")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp10, []any{tmp13, v3, v4}) - tmp15 := lang.Apply(tmp7, []any{tmp14}) - return tmp15 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // println - { - tmp0 := lang.NewSymbol("println").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Same as print followed by (newline)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3734), lang.NewKeyword("end-line"), int(3734))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var v3 any = lang.NewList(args[0:]...) - _ = v3 - var tmp4 any - { // let - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("push-thread-bindings")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("hash-map")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*print-readably*")) - tmp12 := lang.Apply(tmp10, []any{tmp11, nil}) - tmp13 := lang.Apply(tmp7, []any{tmp12}) - _ = tmp13 - var tmp14 any - func() { - defer func() { - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, nil) - _ = tmp18 - }() - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("apply")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("prn")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.Apply(tmp21, []any{tmp24, v3}) - tmp14 = tmp25 - }() - tmp4 = tmp14 - } // end let - return tmp4 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // println-str - { - tmp1 := reflect.TypeOf("") - tmp0 := lang.NewSymbol("println-str").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("xs"))), lang.NewKeyword("doc"), "println to a string, returning it", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4785), lang.NewKeyword("end-line"), int(4785))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var v4 any = lang.NewList(args[0:]...) - _ = v4 - var tmp5 any - { // let - // let binding "s__0__auto__" - var v6 any = "unimplemented: new with non-constant class type" - _ = v6 - var tmp7 any - { // let - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("push-thread-bindings")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("hash-map")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*out*")) - tmp15 := lang.Apply(tmp13, []any{tmp14, v6}) - tmp16 := lang.Apply(tmp10, []any{tmp15}) - _ = tmp16 - var tmp17 any - func() { - defer func() { - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.Apply(tmp20, nil) - _ = tmp21 - }() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("apply")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("println")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.Apply(tmp24, []any{tmp27, v4}) - _ = tmp28 - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("str")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.Apply(tmp31, []any{v6}) - tmp17 = tmp32 - }() - tmp7 = tmp17 - } // end let - tmp5 = tmp7 - } // end let - return tmp5 - } - }) - tmp4 := reflect.TypeOf("") - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // prn - { - tmp0 := lang.NewSymbol("prn").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Same as pr followed by (newline). Observes *flush-on-newline*", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3715), lang.NewKeyword("end-line"), int(3715))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var v3 any = lang.NewList(args[0:]...) - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("apply")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("pr")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp6, []any{tmp9, v3}) - _ = tmp10 - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("newline")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, nil) - _ = tmp14 - var tmp15 any - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("*flush-on-newline*")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - if lang.IsTruthy(tmp18) { - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("flush")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, nil) - tmp15 = tmp22 - } else { - } - return tmp15 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // prn-str - { - tmp1 := reflect.TypeOf("") - tmp0 := lang.NewSymbol("prn-str").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("xs"))), lang.NewKeyword("doc"), "prn to a string, returning it", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4767), lang.NewKeyword("end-line"), int(4767))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var v4 any = lang.NewList(args[0:]...) - _ = v4 - var tmp5 any - { // let - // let binding "s__0__auto__" - var v6 any = "unimplemented: new with non-constant class type" - _ = v6 - var tmp7 any - { // let - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("push-thread-bindings")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("hash-map")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*out*")) - tmp15 := lang.Apply(tmp13, []any{tmp14, v6}) - tmp16 := lang.Apply(tmp10, []any{tmp15}) - _ = tmp16 - var tmp17 any - func() { - defer func() { - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.Apply(tmp20, nil) - _ = tmp21 - }() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("apply")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("prn")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.Apply(tmp24, []any{tmp27, v4}) - _ = tmp28 - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("str")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.Apply(tmp31, []any{v6}) - tmp17 = tmp32 - }() - tmp7 = tmp17 - } // end let - tmp5 = tmp7 - } // end let - return tmp5 - } - }) - tmp4 := reflect.TypeOf("") - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // promise - { - tmp0 := lang.NewSymbol("promise").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Returns a promise object that can be read with deref/@, and set,\n once only, with deliver. Calls to deref/@ prior to delivery will\n block, unless the variant of deref with timeout is used. All\n subsequent derefs will return the same delivered value without\n blocking. See also - realized?.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7078), lang.NewKeyword("end-line"), int(7078))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var tmp3 any - { // let - // let binding "d" - tmp4 := lang.Apply(nil, []any{int64(1)}) - var v5 any = tmp4 - _ = v5 - // let binding "v" - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("atom")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(tmp8, []any{v5}) - var v10 any = tmp9 - _ = v10 - tmp11 := reflect.TypeOf((*lang.IDeref)(nil)).Elem() - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("deref")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.NewVector(nil) - tmp16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7091), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(7091), lang.NewKeyword("end-column"), int(17)) - tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp18, ok := lang.FieldOrMethod(v5, "await") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "await"))) - } - var tmp19 any - switch reflect.TypeOf(tmp18).Kind() { - case reflect.Func: - tmp19 = lang.Apply(tmp18, nil) - default: - tmp19 = tmp18 - } - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("deref")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.Apply(tmp22, []any{v10}) - tmp24 := lang.Apply(tmp14, []any{tmp17, tmp19, tmp23}) - tmp25 := reflect.TypeOf((*lang.IBlockingDeref)(nil)).Elem() - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("deref")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.NewVector(nil, nil, nil) - tmp30 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7094), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(7094), lang.NewKeyword("end-column"), int(34)) - tmp31, err := lang.WithMeta(tmp29, tmp30.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var tmp32 any - tmp33, _ := lang.FieldOrMethod(v5, "await") - if reflect.TypeOf(tmp33).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) - } - tmp34 := lang.Apply(tmp33, []any{nil, time7.Millisecond}) - if lang.IsTruthy(tmp34) { - tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp36 := tmp35.FindInternedVar(lang.NewSymbol("deref")) - if tmp36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) - } - tmp37 := tmp36.Get() - tmp38 := lang.Apply(tmp37, []any{v10}) - tmp32 = tmp38 - } else { - } - tmp39 := lang.Apply(tmp28, []any{tmp31, tmp32}) - tmp40 := reflect.TypeOf((*lang.IPending)(nil)).Elem() - tmp41 := lang.NewVector(nil) - tmp42 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7099), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(7099), lang.NewKeyword("end-column"), int(24)) - tmp43, err := lang.WithMeta(tmp41, tmp42.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("zero?")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47, ok := lang.FieldOrMethod(v5, "getCount") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "getCount"))) - } - var tmp48 any - switch reflect.TypeOf(tmp47).Kind() { - case reflect.Func: - tmp48 = lang.Apply(tmp47, nil) - default: - tmp48 = tmp47 - } - tmp49 := lang.Apply(tmp46, []any{tmp48}) - tmp50 := lang.Apply(nil, []any{tmp43, tmp49}) - tmp51 := lang.NewVector(nil, nil) - tmp52 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7103), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(7103), lang.NewKeyword("end-column"), int(14)) - tmp53, err := lang.WithMeta(tmp51, tmp52.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var tmp54 any - var tmp55 any - { // let - // let binding "and__0__auto__" - tmp56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp57 := tmp56.FindInternedVar(lang.NewSymbol("pos?")) - if tmp57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp57))) - } - tmp58 := tmp57.Get() - tmp59, ok := lang.FieldOrMethod(v5, "getCount") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "getCount"))) - } - var tmp60 any - switch reflect.TypeOf(tmp59).Kind() { - case reflect.Func: - tmp60 = lang.Apply(tmp59, nil) - default: - tmp60 = tmp59 - } - tmp61 := lang.Apply(tmp58, []any{tmp60}) - var v62 any = tmp61 - _ = v62 - var tmp63 any - if lang.IsTruthy(v62) { - tmp64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp65 := tmp64.FindInternedVar(lang.NewSymbol("compare-and-set!")) - if tmp65.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp65))) - } - tmp66 := tmp65.Get() - tmp67 := lang.Apply(tmp66, []any{v10, v5, nil}) - tmp63 = tmp67 - } else { - tmp63 = v62 - } - tmp55 = tmp63 - } // end let - if lang.IsTruthy(tmp55) { - tmp56, ok := lang.FieldOrMethod(v5, "countDown") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "countDown"))) - } - var tmp57 any - switch reflect.TypeOf(tmp56).Kind() { - case reflect.Func: - tmp57 = lang.Apply(tmp56, nil) - default: - tmp57 = tmp56 - } - _ = tmp57 - } else { - } - tmp58 := lang.Apply(nil, []any{tmp53, tmp54}) - tmp59 := lang.Apply(nil, []any{tmp11, tmp24, tmp25, tmp39, tmp40, tmp50, nil, tmp58}) - tmp3 = tmp59 - } // end let - return tmp3 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // protocol? - { - tmp0 := lang.NewSymbol("protocol?").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(110), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(110), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("maybe-p"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("instance?")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := reflect.TypeOf((*lang.IAtom)(nil)).Elem() - tmp9 := lang.Apply(tmp7, []any{tmp8, v3}) - if lang.IsTruthy(tmp9) { - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("boolean")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("deref")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{v3}) - tmp17 := lang.Apply(lang.NewKeyword("on-interface"), []any{tmp16}) - tmp18 := lang.Apply(tmp12, []any{tmp17}) - tmp4 = tmp18 - } else { - tmp4 = false - } - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // push-thread-bindings - { - tmp0 := lang.NewSymbol("push-thread-bindings").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"))), lang.NewKeyword("doc"), "WARNING: This is a low-level function. Prefer high-level macros like\n binding where ever possible.\n\n Takes a map of Var/value pairs. Binds each Var to the associated value for\n the current thread. Each call *MUST* be accompanied by a matching call to\n pop-thread-bindings wrapped in a try-finally!\n \n (push-thread-bindings bindings)\n (try\n ...\n (finally\n (pop-thread-bindings)))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(26), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1911), lang.NewKeyword("end-line"), int(1911))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.Apply(lang.PushThreadBindings, []any{v3}) - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // pvalues - { - tmp0 := lang.NewSymbol("pvalues").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("exprs"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the values of the exprs, which are\n evaluated in parallel", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7063), lang.NewKeyword("end-line"), int(7063))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("seq")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("concat")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("list")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("glojure.core/pcalls")}) - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("map")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - var tmp19 lang.FnFunc - tmp19 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v20 := args[0] - _ = v20 - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("list")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.NewVector() - tmp25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7069), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(7069), lang.NewKeyword("end-column"), int(31)) - tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp27 := lang.Apply(tmp23, []any{lang.NewSymbol("glojure.core/fn"), tmp26, v20}) - return tmp27 - }) - tmp20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7069), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(7069), lang.NewKeyword("end-column"), int(34)) - tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp22 := lang.Apply(tmp18, []any{tmp21, v5}) - tmp23 := lang.Apply(tmp11, []any{tmp15, tmp22}) - tmp24 := lang.Apply(tmp8, []any{tmp23}) - return tmp24 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // qualified-ident? - { - tmp0 := lang.NewSymbol("qualified-ident?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a symbol or keyword with a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1618), lang.NewKeyword("end-line"), int(1618))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("boolean")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - var tmp7 any - { // let - // let binding "and__0__auto__" - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("ident?")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v3}) - var v12 any = tmp11 - _ = v12 - var tmp13 any - if lang.IsTruthy(v12) { - var tmp14 any - { // let - // let binding "and__0__auto__" - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("namespace")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{v3}) - var v19 any = tmp18 - _ = v19 - var tmp20 any - if lang.IsTruthy(v19) { - tmp20 = true - } else { - tmp20 = v19 - } - tmp14 = tmp20 - } // end let - tmp13 = tmp14 - } else { - tmp13 = v12 - } - tmp7 = tmp13 - } // end let - tmp8 := lang.Apply(tmp6, []any{tmp7}) - return tmp8 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // qualified-keyword? - { - tmp0 := lang.NewSymbol("qualified-keyword?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a keyword with a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1638), lang.NewKeyword("end-line"), int(1638))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("boolean")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - var tmp7 any - { // let - // let binding "and__0__auto__" - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("keyword?")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v3}) - var v12 any = tmp11 - _ = v12 - var tmp13 any - if lang.IsTruthy(v12) { - var tmp14 any - { // let - // let binding "and__0__auto__" - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("namespace")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{v3}) - var v19 any = tmp18 - _ = v19 - var tmp20 any - if lang.IsTruthy(v19) { - tmp20 = true - } else { - tmp20 = v19 - } - tmp14 = tmp20 - } // end let - tmp13 = tmp14 - } else { - tmp13 = v12 - } - tmp7 = tmp13 - } // end let - tmp8 := lang.Apply(tmp6, []any{tmp7}) - return tmp8 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // qualified-symbol? - { - tmp0 := lang.NewSymbol("qualified-symbol?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a symbol with a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1628), lang.NewKeyword("end-line"), int(1628))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("boolean")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - var tmp7 any - { // let - // let binding "and__0__auto__" - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("symbol?")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v3}) - var v12 any = tmp11 - _ = v12 - var tmp13 any - if lang.IsTruthy(v12) { - var tmp14 any - { // let - // let binding "and__0__auto__" - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("namespace")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{v3}) - var v19 any = tmp18 - _ = v19 - var tmp20 any - if lang.IsTruthy(v19) { - tmp20 = true - } else { - tmp20 = v19 - } - tmp14 = tmp20 - } // end let - tmp13 = tmp14 - } else { - tmp13 = v12 - } - tmp7 = tmp13 - } // end let - tmp8 := lang.Apply(tmp6, []any{tmp7}) - return tmp8 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // quot - { - var tmp1 lang.FnFunc - { // function quot__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("concat")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("list")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol(".")}) - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("seq")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("concat")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("list")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.Apply(tmp30, []any{lang.NewSymbol("glojure.core/Quotient")}) - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.Apply(tmp34, []any{v3}) - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{v4}) - tmp40 := lang.Apply(tmp27, []any{tmp31, tmp35, tmp39}) - tmp41 := lang.Apply(tmp24, []any{tmp40}) - tmp42 := lang.Apply(tmp21, []any{tmp41}) - tmp43 := lang.Apply(tmp10, []any{tmp14, tmp18, tmp42}) - tmp44 := lang.Apply(tmp7, []any{tmp43}) - return tmp44 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("quot").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"), lang.NewSymbol("div"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "quot[ient] of dividing numerator by denominator.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1266), lang.NewKeyword("end-line"), int(1266))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Quotient") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Quotient is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // rand - { - tmp0 := lang.NewSymbol("rand").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns a random floating point number between 0 (inclusive) and\n n (default 1) (exclusive).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4935), lang.NewKeyword("end-line"), int(4935))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp3 := lang.Apply(rand12.Float64, nil) - return tmp3 - case 1: - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("*")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("rand")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp9, nil) - tmp11 := lang.Apply(tmp6, []any{v3, tmp10}) - return tmp11 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // rand-int - { - tmp0 := lang.NewSymbol("rand-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns a random integer between 0 (inclusive) and n (exclusive).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4943), lang.NewKeyword("end-line"), int(4943))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("int")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("rand")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp9, []any{v3}) - tmp11 := lang.Apply(tmp6, []any{tmp10}) - return tmp11 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // rand-nth - { - tmp0 := lang.NewSymbol("rand-nth").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return a random element of the (sequential) collection. Will have\n the same performance characteristics as nth for the given\n collection.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7213), lang.NewKeyword("end-line"), int(7213))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("nth")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("rand-int")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("count")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{v3}) - tmp14 := lang.Apply(tmp9, []any{tmp13}) - tmp15 := lang.Apply(tmp6, []any{v3, tmp14}) - return tmp15 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // random-sample - { - tmp0 := lang.NewSymbol("random-sample").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("prob")), lang.NewVector(lang.NewSymbol("prob"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns items from coll with random probability of prob (0.0 -\n 1.0). Returns a transducer when no collection is provided.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7699), lang.NewKeyword("end-line"), int(7699))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("filter")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - var tmp7 lang.FnFunc - tmp7 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v8 := args[0] - _ = v8 - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("<")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("rand")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.Apply(tmp14, nil) - tmp16 := lang.Apply(tmp11, []any{tmp15, v3}) - return tmp16 - }) - tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7704), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(7704), lang.NewKeyword("end-column"), int(37)) - tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp10 := lang.Apply(tmp6, []any{tmp9}) - return tmp10 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("filter")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - var tmp8 lang.FnFunc - tmp8 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v9 := args[0] - _ = v9 - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("<")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("rand")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, nil) - tmp17 := lang.Apply(tmp12, []any{tmp16, v3}) - return tmp17 - }) - tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7706), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(7706), lang.NewKeyword("end-column"), int(37)) - tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp11 := lang.Apply(tmp7, []any{tmp10, v4}) - return tmp11 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // random-uuid - { - tmp0 := lang.NewSymbol("random-uuid").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Returns a pseudo-randomly generated java.util.UUID instance (i.e. type 4).\n\n See: https://docs.oracle.com/javase/8/docs/api/java/util/UUID.html#randomUUID--", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6852), lang.NewKeyword("end-line"), int(6852))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - tmp3 := lang.Apply(uuid10.NewV7, nil) - return tmp3 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // range - { - tmp0 := lang.NewSymbol("range").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("end")), lang.NewVector(lang.NewSymbol("start"), lang.NewSymbol("end")), lang.NewVector(lang.NewSymbol("start"), lang.NewSymbol("end"), lang.NewSymbol("step"))), lang.NewKeyword("doc"), "Returns a lazy seq of nums from start (inclusive) to end\n (exclusive), by step, where start defaults to 0, step to 1, and end to\n infinity. When step is equal to 0, returns an infinite sequence of\n start. When start is equal to end, returns empty list.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3018), lang.NewKeyword("end-line"), int(3018))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp4 := tmp3.FindInternedVar(lang.NewSymbol("iterate")) - if tmp4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp4))) - } - tmp5 := tmp4.Get() - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("inc'")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(tmp5, []any{tmp8, int64(0)}) - return tmp9 - case 1: - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("int?")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v3}) - if lang.IsTruthy(tmp8) { - tmp9 := lang.Apply(lang.NewLongRange, []any{int64(0), v3, int64(1)}) - tmp4 = tmp9 - } else { - tmp10 := lang.Apply(lang.NewRange, []any{int64(0), v3, int64(1)}) - tmp4 = tmp10 - } - return tmp4 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - var tmp6 any - { // let - // let binding "and__0__auto__" - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("int?")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp9, []any{v3}) - var v11 any = tmp10 - _ = v11 - var tmp12 any - if lang.IsTruthy(v11) { - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("int?")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{v4}) - tmp12 = tmp16 - } else { - tmp12 = v11 - } - tmp6 = tmp12 - } // end let - if lang.IsTruthy(tmp6) { - tmp7 := lang.Apply(lang.NewLongRange, []any{v3, v4, int64(1)}) - tmp5 = tmp7 - } else { - tmp8 := lang.Apply(lang.NewRange, []any{v3, v4, int64(1)}) - tmp5 = tmp8 - } - return tmp5 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var tmp6 any - var tmp7 any - { // let - // let binding "and__0__auto__" - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("int?")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v3}) - var v12 any = tmp11 - _ = v12 - var tmp13 any - if lang.IsTruthy(v12) { - var tmp14 any - { // let - // let binding "and__0__auto__" - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("int?")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{v4}) - var v19 any = tmp18 - _ = v19 - var tmp20 any - if lang.IsTruthy(v19) { - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("int?")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.Apply(tmp23, []any{v5}) - tmp20 = tmp24 - } else { - tmp20 = v19 - } - tmp14 = tmp20 - } // end let - tmp13 = tmp14 - } else { - tmp13 = v12 - } - tmp7 = tmp13 - } // end let - if lang.IsTruthy(tmp7) { - tmp8 := lang.Apply(lang.NewLongRange, []any{v3, v4, v5}) - tmp6 = tmp8 - } else { - tmp9 := lang.Apply(lang.NewRange, []any{v3, v4, v5}) - tmp6 = tmp9 - } - return tmp6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // ratio? - { - tmp0 := lang.NewSymbol("ratio?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is a Ratio", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3577), lang.NewKeyword("end-line"), int(3577))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := reflect.TypeOf((*lang.Ratio)(nil)) - tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) - return tmp8 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // rational? - { - tmp0 := lang.NewSymbol("rational?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is a rational number", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3613), lang.NewKeyword("end-line"), int(3613))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "or__0__auto__" - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("integer?")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v3}) - var v9 any = tmp8 - _ = v9 - var tmp10 any - if lang.IsTruthy(v9) { - tmp10 = v9 - } else { - var tmp11 any - { // let - // let binding "or__0__auto__" - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("ratio?")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.Apply(tmp14, []any{v3}) - var v16 any = tmp15 - _ = v16 - var tmp17 any - if lang.IsTruthy(v16) { - tmp17 = v16 - } else { - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("decimal?")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.Apply(tmp20, []any{v3}) - tmp17 = tmp21 - } - tmp11 = tmp17 - } // end let - tmp10 = tmp11 - } - tmp4 = tmp10 - } // end let - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // rationalize - { - tmp0 := lang.NewSymbol("rationalize").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("doc"), "returns the rational value of num", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1282), lang.NewKeyword("end-line"), int(1282))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Rationalize") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Rationalize is not a function"))) - } - tmp5 := lang.Apply(tmp4, []any{v3}) - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // re-find - { - tmp0 := lang.NewSymbol("re-find").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m")), lang.NewVector(lang.NewSymbol("re"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns the next regex match, if any, of string to pattern, using\n java.util.regex.Matcher.find(). Uses re-groups to return the\n groups.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4922), lang.NewKeyword("end-line"), int(4922))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - var tmp4 any - tmp5, _ := lang.FieldOrMethod(v3, "find") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("find is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{}) - if lang.IsTruthy(tmp6) { - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("re-groups")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp9, []any{v3}) - tmp4 = tmp10 - } else { - } - return tmp4 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - { // let - // let binding "m" - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("re-matcher")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(tmp8, []any{v3, v4}) - var v10 any = tmp9 - _ = v10 - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("re-find")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{v10}) - tmp5 = tmp14 - } // end let - return tmp5 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // re-groups - { - tmp0 := lang.NewSymbol("re-groups").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"))), lang.NewKeyword("doc"), "Returns the groups from the most recent match/find. If there are no\n nested groups, returns a string of the entire match. If there are\n nested groups, returns a vector of the groups, the first element\n being the entire match.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4882), lang.NewKeyword("end-line"), int(4882))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "gc" - tmp5, _ := lang.FieldOrMethod(v3, "groupCount") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("groupCount is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{}) - var v7 any = tmp6 - _ = v7 - var tmp8 any - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("zero?")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.Apply(tmp11, []any{v7}) - if lang.IsTruthy(tmp12) { - tmp13, _ := lang.FieldOrMethod(v3, "group") - if reflect.TypeOf(tmp13).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("group is not a function"))) - } - tmp14 := lang.Apply(tmp13, []any{}) - tmp8 = tmp14 - } else { - var tmp15 any - { // let - // let binding "ret" - tmp16 := lang.NewVector() - tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4893), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(4893), lang.NewKeyword("end-column"), int(21)) - tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v19 any = tmp18 - _ = v19 - // let binding "c" - var v20 any = int64(0) - _ = v20 - for { - var tmp21 any - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("<=")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.Apply(tmp24, []any{v20, v7}) - if lang.IsTruthy(tmp25) { - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("conj")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30, _ := lang.FieldOrMethod(v3, "groupInt") - if reflect.TypeOf(tmp30).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("groupInt is not a function"))) - } - tmp31 := lang.Apply(tmp30, []any{v20}) - tmp32 := lang.Apply(tmp29, []any{v19, tmp31}) - var tmp26 any = tmp32 - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("inc")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.Apply(tmp36, []any{v20}) - var tmp33 any = tmp37 - v19 = tmp26 - v20 = tmp33 - continue - } else { - tmp21 = v19 - } - tmp15 = tmp21 - break - } - } // end let - tmp8 = tmp15 - } - tmp4 = tmp8 - } // end let - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // re-matcher - { - tmp1 := reflect.TypeOf((*lang.RegexpMatcher)(nil)) - tmp0 := lang.NewSymbol("re-matcher").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("re"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns an instance of java.util.regex.Matcher, for use, e.g. in\n re-find.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4873), lang.NewKeyword("end-line"), int(4873))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6 := lang.Apply(lang.NewRegexpMatcher, []any{v4, v5}) - return tmp6 - }) - tmp4 := reflect.TypeOf((*lang.RegexpMatcher)(nil)) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // re-matches - { - tmp0 := lang.NewSymbol("re-matches").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("re"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns the match, if any, of string to pattern, using\n java.util.regex.Matcher.matches(). Uses re-groups to return the\n groups.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4910), lang.NewKeyword("end-line"), int(4910))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - { // let - // let binding "m" - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("re-matcher")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(tmp8, []any{v3, v4}) - var v10 any = tmp9 - _ = v10 - var tmp11 any - tmp12, _ := lang.FieldOrMethod(v10, "matches") - if reflect.TypeOf(tmp12).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("matches is not a function"))) - } - tmp13 := lang.Apply(tmp12, []any{}) - if lang.IsTruthy(tmp13) { - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("re-groups")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{v10}) - tmp11 = tmp17 - } else { - } - tmp5 = tmp11 - } // end let - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // re-pattern - { - tmp1 := reflect.TypeOf((*regexp13.Regexp)(nil)) - tmp0 := lang.NewSymbol("re-pattern").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns an instance of java.util.regex.Pattern, for use, e.g. in\n re-matcher.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4863), lang.NewKeyword("end-line"), int(4863))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - var tmp5 any - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("instance?")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := reflect.TypeOf((*regexp13.Regexp)(nil)) - tmp10 := lang.Apply(tmp8, []any{tmp9, v4}) - if lang.IsTruthy(tmp10) { - tmp5 = v4 - } else { - tmp11 := lang.Apply(regexp13.MustCompile, []any{v4}) - tmp5 = tmp11 - } - return tmp5 - }) - tmp4 := reflect.TypeOf((*regexp13.Regexp)(nil)) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // re-seq - { - tmp0 := lang.NewSymbol("re-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("re"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns a lazy sequence of successive matches of pattern in string,\n using java.util.regex.Matcher.find(), each such match processed with\n re-groups.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4898), lang.NewKeyword("end-line"), int(4898))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - { // let - // let binding "m" - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("re-matcher")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(tmp8, []any{v3, v4}) - var v10 any = tmp9 - _ = v10 - var tmp11 lang.FnFunc - { // function step - var v12 lang.FnFunc - tmp11 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var tmp13 any - tmp14, _ := lang.FieldOrMethod(v10, "find") - if reflect.TypeOf(tmp14).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("find is not a function"))) - } - tmp15 := lang.Apply(tmp14, []any{}) - if lang.IsTruthy(tmp15) { - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("cons")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("re-groups")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, []any{v10}) - var tmp23 lang.FnFunc - tmp23 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - tmp24 := lang.Apply(v12, nil) - return tmp24 - }) - tmp24 := lang.Apply(lang.NewLazySeq, []any{tmp23}) - tmp25 := lang.Apply(tmp18, []any{tmp22, tmp24}) - tmp13 = tmp25 - } else { - } - return tmp13 - }) - v12 = tmp11 - _ = v12 - } - tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4906), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(4908), lang.NewKeyword("end-column"), int(49)) - tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp14 := lang.Apply(tmp13, nil) - tmp5 = tmp14 - } // end let - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // read - { - tmp0 := lang.NewSymbol("read").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("stream")), lang.NewVector(lang.NewSymbol("stream"), lang.NewSymbol("eof-error?"), lang.NewSymbol("eof-value")), lang.NewVector(lang.NewSymbol("stream"), lang.NewSymbol("eof-error?"), lang.NewSymbol("eof-value"), lang.NewSymbol("recursive?")), lang.NewVector(lang.NewSymbol("opts"), lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Reads the next object from stream, which must be an instance of\n java.io.PushbackReader or some derivee. stream defaults to the\n current value of *in*.\n\n Opts is a persistent map with valid keys:\n :read-cond - :allow to process reader conditionals, or\n :preserve to keep all branches\n :features - persistent set of feature keywords for reader conditionals\n :eof - on eof, return value unless :eofthrow, then throw.\n if not specified, will throw\n\n Note that read can execute code (controlled by *read-eval*),\n and as such should be used only with trusted sources.\n\n For data structure interop use glojure.edn/read", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3742), lang.NewKeyword("end-line"), int(3742))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp4 := tmp3.FindInternedVar(lang.NewSymbol("read")) - if tmp4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp4))) - } - tmp5 := tmp4.Get() - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("*in*")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(tmp5, []any{tmp8}) - return tmp9 - case 1: - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("read")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.Apply(tmp6, []any{v3, true, nil}) - return tmp7 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("read")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(tmp8, []any{v3, v4, v5, false}) - return tmp9 - case 4: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("boolean")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp9, []any{v4}) - tmp11, _ := lang.FieldOrMethod(nil, "read") - if reflect.TypeOf(tmp11).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("read is not a function"))) - } - tmp12 := lang.Apply(tmp11, []any{v3, tmp10, v5, v6}) - return tmp12 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5, _ := lang.FieldOrMethod(nil, "read") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("read is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4, v3}) - return tmp6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // read+string - { - tmp0 := lang.NewSymbol("read+string").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("stream")), lang.NewVector(lang.NewSymbol("stream"), lang.NewSymbol("eof-error?"), lang.NewSymbol("eof-value")), lang.NewVector(lang.NewSymbol("stream"), lang.NewSymbol("eof-error?"), lang.NewSymbol("eof-value"), lang.NewSymbol("recursive?")), lang.NewVector(lang.NewSymbol("opts"), lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Like read, and taking the same args. stream must be a LineNumberingPushbackReader.\n Returns a vector containing the object read and the (whitespace-trimmed) string read.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3771), lang.NewKeyword("end-line"), int(3771))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp4 := tmp3.FindInternedVar(lang.NewSymbol("read+string")) - if tmp4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp4))) - } - tmp5 := tmp4.Get() - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("*in*")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(tmp5, []any{tmp8}) - return tmp9 - case 1: - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("read+string")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.Apply(tmp6, []any{v3, true, nil}) - return tmp7 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("read+string")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(tmp8, []any{v3, v4, v5, false}) - return tmp9 - case 4: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - var tmp7 any - func() { - defer func() { - if r := recover(); r != nil { - if lang.CatchMatches(r, lang.Throwable) { - v8 := r - _ = v8 - tmp9, ok := lang.FieldOrMethod(v3, "getString") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getString"))) - } - var tmp10 any - switch reflect.TypeOf(tmp9).Kind() { - case reflect.Func: - tmp10 = lang.Apply(tmp9, nil) - default: - tmp10 = tmp9 - } - _ = tmp10 - panic(v8) - } else { - panic(r) - } - } - }() - tmp8, ok := lang.FieldOrMethod(v3, "captureString") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "captureString"))) - } - var tmp9 any - switch reflect.TypeOf(tmp8).Kind() { - case reflect.Func: - tmp9 = lang.Apply(tmp8, nil) - default: - tmp9 = tmp8 - } - _ = tmp9 - var tmp10 any - { // let - // let binding "o" - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("read")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{v3, v4, v5, v6}) - var v15 any = tmp14 - _ = v15 - // let binding "s" - tmp16, ok := lang.FieldOrMethod(v3, "getString") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getString"))) - } - var tmp17 any - switch reflect.TypeOf(tmp16).Kind() { - case reflect.Func: - tmp17 = lang.Apply(tmp16, nil) - default: - tmp17 = tmp16 - } - tmp18, ok := lang.FieldOrMethod(tmp17, "trim") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp17, "trim"))) - } - var tmp19 any - switch reflect.TypeOf(tmp18).Kind() { - case reflect.Func: - tmp19 = lang.Apply(tmp18, nil) - default: - tmp19 = tmp18 - } - var v20 any = tmp19 - _ = v20 - tmp21 := lang.NewVector(v15, v20) - tmp22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3783), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(3783), lang.NewKeyword("end-column"), int(12)) - tmp23, err := lang.WithMeta(tmp21, tmp22.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp10 = tmp23 - } // end let - tmp7 = tmp10 - }() - return tmp7 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - func() { - defer func() { - if r := recover(); r != nil { - if lang.CatchMatches(r, lang.Throwable) { - v6 := r - _ = v6 - tmp7, ok := lang.FieldOrMethod(v4, "getString") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "getString"))) - } - var tmp8 any - switch reflect.TypeOf(tmp7).Kind() { - case reflect.Func: - tmp8 = lang.Apply(tmp7, nil) - default: - tmp8 = tmp7 - } - _ = tmp8 - panic(v6) - } else { - panic(r) - } - } - }() - tmp6, ok := lang.FieldOrMethod(v4, "captureString") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "captureString"))) - } - var tmp7 any - switch reflect.TypeOf(tmp6).Kind() { - case reflect.Func: - tmp7 = lang.Apply(tmp6, nil) - default: - tmp7 = tmp6 - } - _ = tmp7 - var tmp8 any - { // let - // let binding "o" - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("read")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.Apply(tmp11, []any{v3, v4}) - var v13 any = tmp12 - _ = v13 - // let binding "s" - tmp14, ok := lang.FieldOrMethod(v4, "getString") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "getString"))) - } - var tmp15 any - switch reflect.TypeOf(tmp14).Kind() { - case reflect.Func: - tmp15 = lang.Apply(tmp14, nil) - default: - tmp15 = tmp14 - } - tmp16, ok := lang.FieldOrMethod(tmp15, "trim") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp15, "trim"))) - } - var tmp17 any - switch reflect.TypeOf(tmp16).Kind() { - case reflect.Func: - tmp17 = lang.Apply(tmp16, nil) - default: - tmp17 = tmp16 - } - var v18 any = tmp17 - _ = v18 - tmp19 := lang.NewVector(v13, v18) - tmp20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3792), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(3792), lang.NewKeyword("end-column"), int(12)) - tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp8 = tmp21 - } // end let - tmp5 = tmp8 - }() - return tmp5 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // read-line - { - tmp0 := lang.NewSymbol("read-line").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Reads the next line from stream that is the current value of *in* .", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3797), lang.NewKeyword("end-line"), int(3797))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var tmp3 any - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("*in*")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp6, []any{nil, tmp9}) - if lang.IsTruthy(tmp10) { - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("*in*")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14, ok := lang.FieldOrMethod(tmp13, "readLine") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp13, "readLine"))) - } - var tmp15 any - switch reflect.TypeOf(tmp14).Kind() { - case reflect.Func: - tmp15 = lang.Apply(tmp14, nil) - default: - tmp15 = tmp14 - } - tmp3 = tmp15 - } else { - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("*in*")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19, ok := lang.FieldOrMethod(tmp18, "readLine") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp18, "readLine"))) - } - var tmp20 any - switch reflect.TypeOf(tmp19).Kind() { - case reflect.Func: - tmp20 = lang.Apply(tmp19, nil) - default: - tmp20 = tmp19 - } - tmp3 = tmp20 - } - return tmp3 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // read-string - { - tmp0 := lang.NewSymbol("read-string").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s")), lang.NewVector(lang.NewSymbol("opts"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Reads one object from the string s. Optionally include reader\n options, as specified in read.\n\n Note that read-string can execute code (controlled by *read-eval*),\n and as such should be used only with trusted sources.\n\n For data structure interop use glojure.edn/read-string", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3806), lang.NewKeyword("end-line"), int(3806))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - tmp4 := lang.Apply(runtime4.RTReadString, []any{v3}) - return tmp4 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.Apply(runtime4.RTReadString, []any{v4, v3}) - return tmp5 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // reader-conditional - { - tmp0 := lang.NewSymbol("reader-conditional").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("form"), lang.NewSymbol("splicing?"))), lang.NewKeyword("doc"), "Construct a data representation of a reader conditional.\n If true, splicing? indicates read-cond-splicing.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7782), lang.NewKeyword("end-line"), int(7782))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.Apply(nil, []any{v3, v4}) - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // reader-conditional? - { - tmp0 := lang.NewSymbol("reader-conditional?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("value"))), lang.NewKeyword("doc"), "Return true if the value is the data representation of a reader conditional", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7776), lang.NewKeyword("end-line"), int(7776))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.Apply(tmp6, []any{nil, v3}) - return tmp7 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // realized? - { - tmp0 := lang.NewSymbol("realized?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if a value has been produced for a promise, delay, future or lazy sequence.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7559), lang.NewKeyword("end-line"), int(7559))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4, ok := lang.FieldOrMethod(v3, "isRealized") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "isRealized"))) - } - var tmp5 any - switch reflect.TypeOf(tmp4).Kind() { - case reflect.Func: - tmp5 = lang.Apply(tmp4, nil) - default: - tmp5 = tmp4 - } - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // reduce - { - tmp0 := lang.NewSymbol("reduce").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("val"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "f should be a function of 2 arguments. If val is not supplied,\n returns the result of applying f to the first 2 items in coll, then\n applying f to that result and the 3rd item, etc. If coll contains no\n items, f must accept no arguments as well, and reduce returns the\n result of calling f with no arguments. If coll has only 1 item, it\n is returned and f is not called. If val is supplied, returns the\n result of applying f to val and the first item in coll, then\n applying f to that result and the 2nd item, etc. If coll contains no\n items, returns val and f is not called.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6860), lang.NewKeyword("end-line"), int(6860))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("instance?")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := reflect.TypeOf((*lang.IReduce)(nil)).Elem() - tmp10 := lang.Apply(tmp8, []any{tmp9, v4}) - if lang.IsTruthy(tmp10) { - tmp11, _ := lang.FieldOrMethod(v4, "Reduce") - if reflect.TypeOf(tmp11).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Reduce is not a function"))) - } - tmp12 := lang.Apply(tmp11, []any{v3}) - tmp5 = tmp12 - } else { - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core.protocols")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("coll-reduce")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{v4, v3}) - tmp5 = tmp16 - } - return tmp5 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var tmp6 any - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("instance?")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := reflect.TypeOf((*lang.IReduceInit)(nil)).Elem() - tmp11 := lang.Apply(tmp9, []any{tmp10, v5}) - if lang.IsTruthy(tmp11) { - tmp12, _ := lang.FieldOrMethod(v5, "ReduceInit") - if reflect.TypeOf(tmp12).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) - } - tmp13 := lang.Apply(tmp12, []any{v3, v4}) - tmp6 = tmp13 - } else { - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core.protocols")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("coll-reduce")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{v5, v3, v4}) - tmp6 = tmp17 - } - return tmp6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // reduce-kv - { - tmp0 := lang.NewSymbol("reduce-kv").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Reduces an associative collection. f should be a function of 3\n arguments. Returns the result of applying f to init, the first key\n and the first value in coll, then applying f to that result and the\n 2nd key and value, etc. If coll contains no entries, returns init\n and f is not called. Note that reduce-kv is supported on vectors,\n where the keys will be the ordinals.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6882), lang.NewKeyword("end-line"), int(6882))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core.protocols")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("kv-reduce")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(tmp8, []any{v5, v3, v4}) - return tmp9 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // reduce1 - { - tmp0 := lang.NewSymbol("reduce1").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(923), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(924), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("val"), lang.NewSymbol("coll"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - { // let - // let binding "s" - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("seq")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(tmp8, []any{v4}) - var v10 any = tmp9 - _ = v10 - var tmp11 any - if lang.IsTruthy(v10) { - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("first")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{v10}) - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("next")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, []any{v10}) - tmp23 := lang.Apply(tmp14, []any{v3, tmp18, tmp22}) - tmp11 = tmp23 - } else { - tmp24 := lang.Apply(v3, nil) - tmp11 = tmp24 - } - tmp5 = tmp11 - } // end let - return tmp5 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - recur_loop_156: - var tmp6 any - { // let - // let binding "s" - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("seq")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp9, []any{v5}) - var v11 any = tmp10 - _ = v11 - var tmp12 any - if lang.IsTruthy(v11) { - var tmp13 any - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("chunked-seq?")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{v11}) - if lang.IsTruthy(tmp17) { - var tmp18 any = v3 - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("chunk-first")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.Apply(tmp22, []any{v11}) - tmp24, _ := lang.FieldOrMethod(tmp23, "ReduceInit") - if reflect.TypeOf(tmp24).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) - } - tmp25 := lang.Apply(tmp24, []any{v3, v4}) - var tmp19 any = tmp25 - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("chunk-next")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{v11}) - var tmp26 any = tmp30 - v3 = tmp18 - v4 = tmp19 - v5 = tmp26 - goto recur_loop_156 - } else { - var tmp31 any = v3 - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("first")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.Apply(tmp35, []any{v11}) - tmp37 := lang.Apply(v3, []any{v4, tmp36}) - var tmp32 any = tmp37 - tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp40 := tmp39.FindInternedVar(lang.NewSymbol("next")) - if tmp40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) - } - tmp41 := tmp40.Get() - tmp42 := lang.Apply(tmp41, []any{v11}) - var tmp38 any = tmp42 - v3 = tmp31 - v4 = tmp32 - v5 = tmp38 - goto recur_loop_156 - } - tmp12 = tmp13 - } else { - tmp12 = v4 - } - tmp6 = tmp12 - } // end let - return tmp6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // reduced - { - tmp0 := lang.NewSymbol("reduced").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Wraps x in a way such that a reduce will terminate with the value x", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2828), lang.NewKeyword("end-line"), int(2828))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.Apply(lang.NewReduced, []any{v3}) - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // reduced? - { - var tmp1 lang.FnFunc - { // function reduced?__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.IsReduced")}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{v3}) - tmp18 := lang.Apply(tmp9, []any{tmp13, tmp17}) - tmp19 := lang.Apply(tmp6, []any{tmp18}) - return tmp19 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("reduced?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns true if x is the result of a call to reduced", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1)})), lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2834), lang.NewKeyword("end-line"), int(2834))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5 := lang.Apply(lang.IsReduced, []any{v4}) - return tmp5 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // reductions - { - tmp0 := lang.NewSymbol("reductions").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy seq of the intermediate values of the reduction (as\n per reduce) of coll by f, starting with init.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7196), lang.NewKeyword("end-line"), int(7196))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 lang.FnFunc - tmp5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var tmp6 any - { // let - // let binding "temp__0__auto__" - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("seq")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp9, []any{v4}) - var v11 any = tmp10 - _ = v11 - var tmp12 any - if lang.IsTruthy(v11) { - var tmp13 any - { // let - // let binding "s" - var v14 any = v11 - _ = v14 - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("reductions")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("first")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.Apply(tmp20, []any{v14}) - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("rest")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.Apply(tmp24, []any{v14}) - tmp26 := lang.Apply(tmp17, []any{v3, tmp21, tmp25}) - tmp13 = tmp26 - } // end let - tmp12 = tmp13 - } else { - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(v3, nil) - tmp18 := lang.Apply(tmp16, []any{tmp17}) - tmp12 = tmp18 - } - tmp6 = tmp12 - } // end let - return tmp6 - }) - tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) - return tmp6 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var tmp6 any - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("reduced?")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp9, []any{v4}) - if lang.IsTruthy(tmp10) { - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("list")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("deref")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{v4}) - tmp18 := lang.Apply(tmp13, []any{tmp17}) - tmp6 = tmp18 - } else { - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("cons")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - var tmp22 lang.FnFunc - tmp22 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var tmp23 any - { // let - // let binding "temp__0__auto__" - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("seq")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.Apply(tmp26, []any{v5}) - var v28 any = tmp27 - _ = v28 - var tmp29 any - if lang.IsTruthy(v28) { - var tmp30 any - { // let - // let binding "s" - var v31 any = v28 - _ = v31 - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("reductions")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp36 := tmp35.FindInternedVar(lang.NewSymbol("first")) - if tmp36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) - } - tmp37 := tmp36.Get() - tmp38 := lang.Apply(tmp37, []any{v31}) - tmp39 := lang.Apply(v3, []any{v4, tmp38}) - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("rest")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.Apply(tmp42, []any{v31}) - tmp44 := lang.Apply(tmp34, []any{v3, tmp39, tmp43}) - tmp30 = tmp44 - } // end let - tmp29 = tmp30 - } else { - } - tmp23 = tmp29 - } // end let - return tmp23 - }) - tmp23 := lang.Apply(lang.NewLazySeq, []any{tmp22}) - tmp24 := lang.Apply(tmp21, []any{v4, tmp23}) - tmp6 = tmp24 - } - return tmp6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // ref - { - tmp0 := lang.NewSymbol("ref").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Creates and returns a Ref with an initial value of x and zero or\n more options (in any order):\n\n :meta metadata-map\n\n :validator validate-fn\n\n :min-history (default 0)\n :max-history (default 10)\n\n If metadata-map is supplied, it will become the metadata on the\n ref. validate-fn must be nil or a side-effect-free fn of one\n argument, which will be passed the intended new state on any state\n change. If the new state is unacceptable, the validate-fn should\n return false or throw an exception. validate-fn will be called on\n transaction commit, when all refs have their final values.\n\n Normally refs accumulate history dynamically as needed to deal with\n read demands. If you know in advance you will need history you can\n set :min-history to ensure it will be available when first needed (instead\n of after a read fault). History is limited, and the limit can be set\n with :max-history.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2260), lang.NewKeyword("end-line"), int(2260))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - tmp4 := lang.Apply(lang.NewRef, []any{v3}) - return tmp4 - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var v4 any = lang.NewList(args[1:]...) - _ = v4 - var tmp5 any - { // let - // let binding "r" - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("setup-reference")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("ref")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.Apply(tmp11, []any{v3}) - tmp13 := lang.Apply(tmp8, []any{tmp12, v4}) - var v14 any = tmp13 - _ = v14 - // let binding "opts" - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("apply")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("hash-map")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.Apply(tmp17, []any{tmp20, v4}) - var v22 any = tmp21 - _ = v22 - var tmp23 any - tmp24 := lang.Apply(lang.NewKeyword("max-history"), []any{v22}) - if lang.IsTruthy(tmp24) { - tmp25 := lang.Apply(lang.NewKeyword("max-history"), []any{v22}) - tmp26, _ := lang.FieldOrMethod(v14, "setMaxHistory") - if reflect.TypeOf(tmp26).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMaxHistory is not a function"))) - } - tmp27 := lang.Apply(tmp26, []any{tmp25}) - tmp23 = tmp27 - } else { - } - _ = tmp23 - var tmp28 any - tmp29 := lang.Apply(lang.NewKeyword("min-history"), []any{v22}) - if lang.IsTruthy(tmp29) { - tmp30 := lang.Apply(lang.NewKeyword("min-history"), []any{v22}) - tmp31, _ := lang.FieldOrMethod(v14, "setMinHistory") - if reflect.TypeOf(tmp31).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMinHistory is not a function"))) - } - tmp32 := lang.Apply(tmp31, []any{tmp30}) - tmp28 = tmp32 - } else { - } - _ = tmp28 - tmp5 = v14 - } // end let - return tmp5 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // ref-history-count - { - tmp0 := lang.NewSymbol("ref-history-count").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref"))), lang.NewKeyword("doc"), "Returns the history count of a ref", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2455), lang.NewKeyword("end-line"), int(2455))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4, ok := lang.FieldOrMethod(v3, "getHistoryCount") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getHistoryCount"))) - } - var tmp5 any - switch reflect.TypeOf(tmp4).Kind() { - case reflect.Func: - tmp5 = lang.Apply(tmp4, nil) - default: - tmp5 = tmp4 - } - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // ref-max-history - { - tmp0 := lang.NewSymbol("ref-max-history").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref")), lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Gets the max-history of a ref, or sets it and returns the ref", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2471), lang.NewKeyword("end-line"), int(2471))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - tmp4, ok := lang.FieldOrMethod(v3, "getMaxHistory") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getMaxHistory"))) - } - var tmp5 any - switch reflect.TypeOf(tmp4).Kind() { - case reflect.Func: - tmp5 = lang.Apply(tmp4, nil) - default: - tmp5 = tmp4 - } - return tmp5 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5, _ := lang.FieldOrMethod(v3, "setMaxHistory") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMaxHistory is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // ref-min-history - { - tmp0 := lang.NewSymbol("ref-min-history").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref")), lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Gets the min-history of a ref, or sets it and returns the ref", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2462), lang.NewKeyword("end-line"), int(2462))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - tmp4, ok := lang.FieldOrMethod(v3, "getMinHistory") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getMinHistory"))) - } - var tmp5 any - switch reflect.TypeOf(tmp4).Kind() { - case reflect.Func: - tmp5 = lang.Apply(tmp4, nil) - default: - tmp5 = tmp4 - } - return tmp5 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5, _ := lang.FieldOrMethod(v3, "setMinHistory") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMinHistory is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // ref-set - { - tmp0 := lang.NewSymbol("ref-set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Must be called in a transaction. Sets the value of ref.\n Returns val.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2447), lang.NewKeyword("end-line"), int(2447))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5, _ := lang.FieldOrMethod(v3, "set") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("set is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // refer - { - tmp0 := lang.NewSymbol("refer").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns-sym"), lang.NewSymbol("&"), lang.NewSymbol("filters"))), lang.NewKeyword("doc"), "refers to all public vars of ns, subject to filters.\n filters can include at most one each of:\n\n :exclude list-of-symbols\n :only list-of-symbols\n :rename map-of-fromsymbol-tosymbol\n\n For each public interned var in the namespace named by the symbol,\n adds a mapping from the name of the var to the var to the current\n namespace. Throws an exception if name is already mapped to\n something else in the current namespace. Filters can be used to\n select a subset, via inclusion or exclusion, or to provide a mapping\n to a symbol different from the var's name, in order to prevent\n clashes. Use :use in the ns macro in preference to calling this directly.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4216), lang.NewKeyword("end-line"), int(4216))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var v4 any = lang.NewList(args[1:]...) - _ = v4 - var tmp5 any - { // let - // let binding "ns" - var tmp6 any - { // let - // let binding "or__0__auto__" - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("find-ns")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp9, []any{v3}) - var v11 any = tmp10 - _ = v11 - var tmp12 any - if lang.IsTruthy(v11) { - tmp12 = v11 - } else { - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("str")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{"No namespace: ", v3}) - tmp17 := lang.Apply(errors5.New, []any{tmp16}) - panic(tmp17) - } - tmp6 = tmp12 - } // end let - var v7 any = tmp6 - _ = v7 - // let binding "fs" - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("apply")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("hash-map")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp10, []any{tmp13, v4}) - var v15 any = tmp14 - _ = v15 - // let binding "nspublics" - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("ns-publics")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{v7}) - var v20 any = tmp19 - _ = v20 - // let binding "rename" - var tmp21 any - { // let - // let binding "or__0__auto__" - tmp22 := lang.Apply(lang.NewKeyword("rename"), []any{v15}) - var v23 any = tmp22 - _ = v23 - var tmp24 any - if lang.IsTruthy(v23) { - tmp24 = v23 - } else { - tmp25 := lang.NewMap() - tmp26 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4236), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(4236), lang.NewKeyword("end-column"), int(36)) - tmp27, err := lang.WithMeta(tmp25, tmp26.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp24 = tmp27 - } - tmp21 = tmp24 - } // end let - var v22 any = tmp21 - _ = v22 - // let binding "exclude" - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("set")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.Apply(lang.NewKeyword("exclude"), []any{v15}) - tmp27 := lang.Apply(tmp25, []any{tmp26}) - var v28 any = tmp27 - _ = v28 - // let binding "to-do" - var tmp29 any - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("=")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.Apply(lang.NewKeyword("refer"), []any{v15}) - tmp34 := lang.Apply(tmp32, []any{lang.NewKeyword("all"), tmp33}) - if lang.IsTruthy(tmp34) { - tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp36 := tmp35.FindInternedVar(lang.NewSymbol("keys")) - if tmp36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) - } - tmp37 := tmp36.Get() - tmp38 := lang.Apply(tmp37, []any{v20}) - tmp29 = tmp38 - } else { - var tmp39 any - { // let - // let binding "or__0__auto__" - tmp40 := lang.Apply(lang.NewKeyword("refer"), []any{v15}) - var v41 any = tmp40 - _ = v41 - var tmp42 any - if lang.IsTruthy(v41) { - tmp42 = v41 - } else { - var tmp43 any - { // let - // let binding "or__0__auto__" - tmp44 := lang.Apply(lang.NewKeyword("only"), []any{v15}) - var v45 any = tmp44 - _ = v45 - var tmp46 any - if lang.IsTruthy(v45) { - tmp46 = v45 - } else { - tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp48 := tmp47.FindInternedVar(lang.NewSymbol("keys")) - if tmp48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) - } - tmp49 := tmp48.Get() - tmp50 := lang.Apply(tmp49, []any{v20}) - tmp46 = tmp50 - } - tmp43 = tmp46 - } // end let - tmp42 = tmp43 - } - tmp39 = tmp42 - } // end let - tmp29 = tmp39 - } - var v40 any = tmp29 - _ = v40 - var tmp41 any - var tmp42 any - { // let - // let binding "and__0__auto__" - var v43 any = v40 - _ = v43 - var tmp44 any - if lang.IsTruthy(v43) { - tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp46 := tmp45.FindInternedVar(lang.NewSymbol("not")) - if tmp46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) - } - tmp47 := tmp46.Get() - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("instance?")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := reflect.TypeOf((*lang.Sequential)(nil)).Elem() - tmp52 := lang.Apply(tmp50, []any{tmp51, v40}) - tmp53 := lang.Apply(tmp47, []any{tmp52}) - tmp44 = tmp53 - } else { - tmp44 = v43 - } - tmp42 = tmp44 - } // end let - if lang.IsTruthy(tmp42) { - tmp43 := lang.Apply(errors5.New, []any{":only/:refer value must be a sequential collection of symbols"}) - panic(tmp43) - } else { - } - _ = tmp41 - var tmp44 any - { // let - // let binding "seq_9" - tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp46 := tmp45.FindInternedVar(lang.NewSymbol("seq")) - if tmp46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) - } - tmp47 := tmp46.Get() - tmp48 := lang.Apply(tmp47, []any{v40}) - var v49 any = tmp48 - _ = v49 - // let binding "chunk_10" - var v50 any = nil - _ = v50 - // let binding "count_11" - var v51 any = int64(0) - _ = v51 - // let binding "i_12" - var v52 any = int64(0) - _ = v52 - for { - var tmp53 any - tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp55 := tmp54.FindInternedVar(lang.NewSymbol("<")) - if tmp55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) - } - tmp56 := tmp55.Get() - tmp57 := lang.Apply(tmp56, []any{v52, v51}) - if lang.IsTruthy(tmp57) { - var tmp58 any - { // let - // let binding "sym" - tmp59, _ := lang.FieldOrMethod(v50, "nth") - if reflect.TypeOf(tmp59).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) - } - tmp60 := lang.Apply(tmp59, []any{v52}) - var v61 any = tmp60 - _ = v61 - var tmp62 any - tmp63 := lang.Apply(v28, []any{v61}) - if lang.IsTruthy(tmp63) { - } else { - var tmp64 any - { // let - // let binding "v" - tmp65 := lang.Apply(v20, []any{v61}) - var v66 any = tmp65 - _ = v66 - var tmp67 any - if lang.IsTruthy(v66) { - } else { - panic("unimplemented: new with non-constant class type") - } - _ = tmp67 - tmp68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp69 := tmp68.FindInternedVar(lang.NewSymbol("*ns*")) - if tmp69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp69))) - } - tmp70 := tmp69.Get() - var tmp71 any - { // let - // let binding "or__0__auto__" - tmp72 := lang.Apply(v22, []any{v61}) - var v73 any = tmp72 - _ = v73 - var tmp74 any - if lang.IsTruthy(v73) { - tmp74 = v73 - } else { - tmp74 = v61 - } - tmp71 = tmp74 - } // end let - tmp72, _ := lang.FieldOrMethod(tmp70, "Refer") - if reflect.TypeOf(tmp72).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Refer is not a function"))) - } - tmp73 := lang.Apply(tmp72, []any{tmp71, v66}) - tmp64 = tmp73 - } // end let - tmp62 = tmp64 - } - _ = tmp62 - var tmp65 any = v49 - var tmp66 any = v50 - var tmp67 any = v51 - tmp69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp70 := tmp69.FindInternedVar(lang.NewSymbol("unchecked-inc")) - if tmp70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp70))) - } - tmp71 := tmp70.Get() - tmp72 := lang.Apply(tmp71, []any{v52}) - var tmp68 any = tmp72 - v49 = tmp65 - v50 = tmp66 - v51 = tmp67 - v52 = tmp68 - continue - } // end let - tmp53 = tmp58 - } else { - var tmp59 any - { // let - // let binding "temp__0__auto__" - tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp61 := tmp60.FindInternedVar(lang.NewSymbol("seq")) - if tmp61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) - } - tmp62 := tmp61.Get() - tmp63 := lang.Apply(tmp62, []any{v49}) - var v64 any = tmp63 - _ = v64 - var tmp65 any - if lang.IsTruthy(v64) { - var tmp66 any - { // let - // let binding "seq_9" - var v67 any = v64 - _ = v67 - var tmp68 any - tmp69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp70 := tmp69.FindInternedVar(lang.NewSymbol("chunked-seq?")) - if tmp70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp70))) - } - tmp71 := tmp70.Get() - tmp72 := lang.Apply(tmp71, []any{v67}) - if lang.IsTruthy(tmp72) { - var tmp73 any - { // let - // let binding "c__0__auto__" - tmp74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp75 := tmp74.FindInternedVar(lang.NewSymbol("chunk-first")) - if tmp75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp75))) - } - tmp76 := tmp75.Get() - tmp77 := lang.Apply(tmp76, []any{v67}) - var v78 any = tmp77 - _ = v78 - tmp80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp81 := tmp80.FindInternedVar(lang.NewSymbol("chunk-rest")) - if tmp81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp81))) - } - tmp82 := tmp81.Get() - tmp83 := lang.Apply(tmp82, []any{v67}) - var tmp79 any = tmp83 - var tmp84 any = v78 - tmp86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp87 := tmp86.FindInternedVar(lang.NewSymbol("int")) - if tmp87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp87))) - } - tmp88 := tmp87.Get() - tmp89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp90 := tmp89.FindInternedVar(lang.NewSymbol("count")) - if tmp90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp90))) - } - tmp91 := tmp90.Get() - tmp92 := lang.Apply(tmp91, []any{v78}) - tmp93 := lang.Apply(tmp88, []any{tmp92}) - var tmp85 any = tmp93 - tmp95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp96 := tmp95.FindInternedVar(lang.NewSymbol("int")) - if tmp96.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp96))) - } - tmp97 := tmp96.Get() - tmp98 := lang.Apply(tmp97, []any{int64(0)}) - var tmp94 any = tmp98 - v49 = tmp79 - v50 = tmp84 - v51 = tmp85 - v52 = tmp94 - continue - } // end let - tmp68 = tmp73 - } else { - var tmp74 any - { // let - // let binding "sym" - tmp75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp76 := tmp75.FindInternedVar(lang.NewSymbol("first")) - if tmp76.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp76))) - } - tmp77 := tmp76.Get() - tmp78 := lang.Apply(tmp77, []any{v67}) - var v79 any = tmp78 - _ = v79 - var tmp80 any - tmp81 := lang.Apply(v28, []any{v79}) - if lang.IsTruthy(tmp81) { - } else { - var tmp82 any - { // let - // let binding "v" - tmp83 := lang.Apply(v20, []any{v79}) - var v84 any = tmp83 - _ = v84 - var tmp85 any - if lang.IsTruthy(v84) { - } else { - panic("unimplemented: new with non-constant class type") - } - _ = tmp85 - tmp86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp87 := tmp86.FindInternedVar(lang.NewSymbol("*ns*")) - if tmp87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp87))) - } - tmp88 := tmp87.Get() - var tmp89 any - { // let - // let binding "or__0__auto__" - tmp90 := lang.Apply(v22, []any{v79}) - var v91 any = tmp90 - _ = v91 - var tmp92 any - if lang.IsTruthy(v91) { - tmp92 = v91 - } else { - tmp92 = v79 - } - tmp89 = tmp92 - } // end let - tmp90, _ := lang.FieldOrMethod(tmp88, "Refer") - if reflect.TypeOf(tmp90).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Refer is not a function"))) - } - tmp91 := lang.Apply(tmp90, []any{tmp89, v84}) - tmp82 = tmp91 - } // end let - tmp80 = tmp82 - } - _ = tmp80 - tmp84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp85 := tmp84.FindInternedVar(lang.NewSymbol("next")) - if tmp85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp85))) - } - tmp86 := tmp85.Get() - tmp87 := lang.Apply(tmp86, []any{v67}) - var tmp83 any = tmp87 - var tmp88 any = nil - var tmp89 any = int64(0) - var tmp90 any = int64(0) - v49 = tmp83 - v50 = tmp88 - v51 = tmp89 - v52 = tmp90 - continue - } // end let - tmp68 = tmp74 - } - tmp66 = tmp68 - } // end let - tmp65 = tmp66 - } else { - } - tmp59 = tmp65 - } // end let - tmp53 = tmp59 - } - tmp44 = tmp53 - break - } - } // end let - tmp5 = tmp44 - } // end let - return tmp5 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // refer-glojure - { - tmp0 := lang.NewSymbol("refer-glojure").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("filters"))), lang.NewKeyword("doc"), "Same as (refer 'glojure.core )", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5800), lang.NewKeyword("end-line"), int(5800))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("seq")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("concat")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("list")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("glojure.core/refer")}) - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("list")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("seq")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("concat")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("list")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.Apply(tmp27, []any{lang.NewSymbol("quote")}) - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("list")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.Apply(tmp31, []any{lang.NewSymbol("glojure.core")}) - tmp33 := lang.Apply(tmp24, []any{tmp28, tmp32}) - tmp34 := lang.Apply(tmp21, []any{tmp33}) - tmp35 := lang.Apply(tmp18, []any{tmp34}) - tmp36 := lang.Apply(tmp11, []any{tmp15, tmp35, v5}) - tmp37 := lang.Apply(tmp8, []any{tmp36}) - return tmp37 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // release-pending-sends - { - tmp0 := lang.NewSymbol("release-pending-sends").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Normally, actions sent directly or indirectly during another action\n are held until the action completes (changes the agent's\n state). This function can be used to dispatch any pending sent\n actions immediately. This has no impact on actions sent during a\n transaction, which are still held until commit. If no action is\n occurring, does nothing. Returns the number of actions dispatched.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2131), lang.NewKeyword("end-line"), int(2131))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - tmp3 := lang.Apply(nil, nil) - return tmp3 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // rem - { - var tmp1 lang.FnFunc - { // function rem__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("concat")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("list")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol(".")}) - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("seq")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("concat")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("list")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.Apply(tmp30, []any{lang.NewSymbol("glojure.core/Remainder")}) - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.Apply(tmp34, []any{v3}) - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{v4}) - tmp40 := lang.Apply(tmp27, []any{tmp31, tmp35, tmp39}) - tmp41 := lang.Apply(tmp24, []any{tmp40}) - tmp42 := lang.Apply(tmp21, []any{tmp41}) - tmp43 := lang.Apply(tmp10, []any{tmp14, tmp18, tmp42}) - tmp44 := lang.Apply(tmp7, []any{tmp43}) - return tmp44 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("rem").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"), lang.NewSymbol("div"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "remainder of dividing numerator by denominator.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1274), lang.NewKeyword("end-line"), int(1274))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Remainder") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Remainder is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // remove - { - tmp0 := lang.NewSymbol("remove").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred")), lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the items in coll for which\n (pred item) returns logical false. pred must be free of side-effects.\n Returns a transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2818), lang.NewKeyword("end-line"), int(2818))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("filter")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("complement")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp9, []any{v3}) - tmp11 := lang.Apply(tmp6, []any{tmp10}) - return tmp11 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("filter")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("complement")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v3}) - tmp12 := lang.Apply(tmp7, []any{tmp11, v4}) - return tmp12 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // remove-all-methods - { - tmp0 := lang.NewSymbol("remove-all-methods").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"))), lang.NewKeyword("doc"), "Removes all of the methods of multimethod.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1787), lang.NewKeyword("end-line"), int(1787))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4, ok := lang.FieldOrMethod(v3, "reset") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "reset"))) - } - var tmp5 any - switch reflect.TypeOf(tmp4).Kind() { - case reflect.Func: - tmp5 = lang.Apply(tmp4, nil) - default: - tmp5 = tmp4 - } - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // remove-method - { - tmp0 := lang.NewSymbol("remove-method").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"), lang.NewSymbol("dispatch-val"))), lang.NewKeyword("doc"), "Removes the method of multimethod associated with dispatch-value.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1794), lang.NewKeyword("end-line"), int(1794))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5, _ := lang.FieldOrMethod(v3, "removeMethod") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("removeMethod is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // remove-ns - { - tmp0 := lang.NewSymbol("remove-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Removes the namespace named by the symbol. Use with caution.\n Cannot be used to remove the glojure namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4139), lang.NewKeyword("end-line"), int(4139))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.Apply(lang.RemoveNamespace, []any{v3}) - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // remove-tap - { - tmp0 := lang.NewSymbol("remove-tap").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Remove f from the tap set.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7883), lang.NewKeyword("end-line"), int(7883))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("swap!")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("tapset")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("disj")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp6, []any{tmp9, tmp12, v3}) - _ = tmp13 - return nil - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // remove-watch - { - tmp0 := lang.NewSymbol("remove-watch").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("reference"), lang.NewSymbol("key"))), lang.NewKeyword("doc"), "Removes a watch (set by add-watch) from a reference", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2160), lang.NewKeyword("end-line"), int(2160))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5, _ := lang.FieldOrMethod(v3, "removeWatch") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("removeWatch is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // repeat - { - tmp0 := lang.NewSymbol("repeat").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns a lazy (infinite!, or length n if supplied) sequence of xs.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2997), lang.NewKeyword("end-line"), int(2997))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - tmp4 := lang.Apply(lang.NewRepeat, []any{v3}) - return tmp4 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.Apply(lang.NewRepeatN, []any{v3, v4}) - return tmp5 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // repeatedly - { - tmp0 := lang.NewSymbol("repeatedly").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Takes a function of no args, presumably with side effects, and\n returns an infinite (or length n if supplied) lazy sequence of calls\n to it", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5167), lang.NewKeyword("end-line"), int(5167))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("cons")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(v3, nil) - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("repeatedly")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.Apply(tmp11, []any{v3}) - tmp13 := lang.Apply(tmp7, []any{tmp8, tmp12}) - return tmp13 - }) - tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) - return tmp5 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("take")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("repeatedly")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v4}) - tmp12 := lang.Apply(tmp7, []any{v3, tmp11}) - return tmp12 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // replace - { - tmp0 := lang.NewSymbol("replace").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("smap")), lang.NewVector(lang.NewSymbol("smap"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Given a map of replacement pairs and a vector/collection, returns a\n vector/seq with any elements = a key in smap replaced with the\n corresponding val in smap. Returns a transducer when no collection\n is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5082), lang.NewKeyword("end-line"), int(5082))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("map")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - var tmp7 lang.FnFunc - tmp7 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v8 := args[0] - _ = v8 - var tmp9 any - { // let - // let binding "temp__0__auto__" - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("find")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{v3, v8}) - var v14 any = tmp13 - _ = v14 - var tmp15 any - if lang.IsTruthy(v14) { - var tmp16 any - { // let - // let binding "e" - var v17 any = v14 - _ = v17 - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("val")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.Apply(tmp20, []any{v17}) - tmp16 = tmp21 - } // end let - tmp15 = tmp16 - } else { - tmp15 = v8 - } - tmp9 = tmp15 - } // end let - return tmp9 - }) - tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5090), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5090), lang.NewKeyword("end-column"), int(47)) - tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp10 := lang.Apply(tmp6, []any{tmp9}) - return tmp10 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("vector?")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(tmp8, []any{v4}) - if lang.IsTruthy(tmp9) { - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - var tmp13 lang.FnFunc - tmp13 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v14 := args[0] - _ = v14 - v15 := args[1] - _ = v15 - var tmp16 any - { // let - // let binding "temp__0__auto__" - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("find")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("nth")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.Apply(tmp22, []any{v14, v15}) - tmp24 := lang.Apply(tmp19, []any{v3, tmp23}) - var v25 any = tmp24 - _ = v25 - var tmp26 any - if lang.IsTruthy(v25) { - var tmp27 any - { // let - // let binding "e" - var v28 any = v25 - _ = v28 - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("assoc")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("val")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.Apply(tmp34, []any{v28}) - tmp36 := lang.Apply(tmp31, []any{v14, v15, tmp35}) - tmp27 = tmp36 - } // end let - tmp26 = tmp27 - } else { - tmp26 = v14 - } - tmp16 = tmp26 - } // end let - return tmp16 - }) - tmp14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5093), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(5096), lang.NewKeyword("end-column"), int(23)) - tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("range")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("count")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, []any{v4}) - tmp23 := lang.Apply(tmp18, []any{tmp22}) - tmp24 := lang.Apply(tmp12, []any{tmp15, v4, tmp23}) - tmp5 = tmp24 - } else { - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("map")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - var tmp28 lang.FnFunc - tmp28 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v29 := args[0] - _ = v29 - var tmp30 any - { // let - // let binding "temp__0__auto__" - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("find")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{v3, v29}) - var v35 any = tmp34 - _ = v35 - var tmp36 any - if lang.IsTruthy(v35) { - var tmp37 any - { // let - // let binding "e" - var v38 any = v35 - _ = v38 - tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp40 := tmp39.FindInternedVar(lang.NewSymbol("val")) - if tmp40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) - } - tmp41 := tmp40.Get() - tmp42 := lang.Apply(tmp41, []any{v38}) - tmp37 = tmp42 - } // end let - tmp36 = tmp37 - } else { - tmp36 = v29 - } - tmp30 = tmp36 - } // end let - return tmp30 - }) - tmp29 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5098), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(5098), lang.NewKeyword("end-column"), int(49)) - tmp30, err := lang.WithMeta(tmp28, tmp29.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp31 := lang.Apply(tmp27, []any{tmp30, v4}) - tmp5 = tmp31 - } - return tmp5 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // replicate - { - tmp0 := lang.NewSymbol("replicate").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "DEPRECATED: Use 'repeat' instead.\n Returns a lazy seq of n xs.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("deprecated"), "1.3", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3004), lang.NewKeyword("end-line"), int(3004))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("take")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("repeat")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v4}) - tmp12 := lang.Apply(tmp7, []any{v3, tmp11}) - return tmp12 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // require - { - tmp0 := lang.NewSymbol("require").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Loads libs, skipping any that are already loaded. Each argument is\n either a libspec that identifies a lib, a prefix list that identifies\n multiple libs whose names share a common prefix, or a flag that modifies\n how all the identified libs are loaded. Use :require in the ns macro\n in preference to calling this directly.\n\n Libs\n\n A 'lib' is a named set of resources in classpath whose contents define a\n library of Clojure code. Lib names are symbols and each lib is associated\n with a Clojure namespace and a Java package that share its name. A lib's\n name also locates its root directory within classpath using Java's\n package name to classpath-relative path mapping. All resources in a lib\n should be contained in the directory structure under its root directory.\n All definitions a lib makes should be in its associated namespace.\n\n 'require loads a lib by loading its root resource. The root resource path\n is derived from the lib name in the following manner:\n Consider a lib named by the symbol 'x.y.z; it has the root directory\n /x/y/, and its root resource is /x/y/z.clj, or\n /x/y/z.cljc if /x/y/z.clj does not exist. The\n root resource should contain code to create the lib's\n namespace (usually by using the ns macro) and load any additional\n lib resources.\n\n Libspecs\n\n A libspec is a lib name or a vector containing a lib name followed by\n options expressed as sequential keywords and arguments.\n\n Recognized options:\n :as takes a symbol as its argument and makes that symbol an alias to the\n lib's namespace in the current namespace.\n :as-alias takes a symbol as its argument and aliases like :as, however\n the lib will not be loaded. If the lib has not been loaded, a new\n empty namespace will be created (as with create-ns).\n :refer takes a list of symbols to refer from the namespace or the :all\n keyword to bring in all public vars.\n\n Prefix Lists\n\n It's common for Clojure code to depend on several libs whose names have\n the same prefix. When specifying libs, prefix lists can be used to reduce\n repetition. A prefix list contains the shared prefix followed by libspecs\n with the shared prefix removed from the lib names. After removing the\n prefix, the names that remain must not contain any periods.\n\n Flags\n\n A flag is a keyword.\n Recognized flags: :reload, :reload-all, :verbose\n :reload forces loading of all the identified libs even if they are\n already loaded (has no effect on libspecs using :as-alias)\n :reload-all implies :reload and also forces loading of all libs that the\n identified libs directly or indirectly load via require or use\n (has no effect on libspecs using :as-alias)\n :verbose triggers printing information about each load, alias, and refer\n\n Example:\n\n The following would load the libraries glojure.zip and glojure.set\n abbreviated as 's'.\n\n (require '(glojure zip [set :as s]))", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5989), lang.NewKeyword("end-line"), int(5989))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var v3 any = lang.NewList(args[0:]...) - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("apply")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("load-libs")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp6, []any{tmp9, lang.NewKeyword("require"), v3}) - return tmp10 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // requiring-resolve - { - tmp0 := lang.NewSymbol("requiring-resolve").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Resolves namespace-qualified sym per 'resolve'. If initial resolve\nfails, attempts to require sym's namespace and retries.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6068), lang.NewKeyword("end-line"), int(6068))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("qualified-symbol?")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v3}) - if lang.IsTruthy(tmp8) { - var tmp9 any - { // let - // let binding "or__0__auto__" - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("resolve")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{v3}) - var v14 any = tmp13 - _ = v14 - var tmp15 any - if lang.IsTruthy(v14) { - tmp15 = v14 - } else { - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("serialized-require")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("symbol")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("namespace")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.Apply(tmp24, []any{v3}) - tmp26 := lang.Apply(tmp21, []any{tmp25}) - tmp27 := lang.Apply(tmp18, []any{tmp26}) - _ = tmp27 - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("resolve")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.Apply(tmp30, []any{v3}) - tmp15 = tmp31 - } - tmp9 = tmp15 - } // end let - tmp4 = tmp9 - } else { - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("str")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{"Not a qualified symbol: ", v3}) - tmp14 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp13}) - panic(tmp14) - } - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // reset! - { - tmp0 := lang.NewSymbol("reset!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atom"), lang.NewSymbol("newval"))), lang.NewKeyword("doc"), "Sets the value of atom to newval without regard for the\n current value. Returns newval.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2368), lang.NewKeyword("end-line"), int(2368))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5, _ := lang.FieldOrMethod(v3, "reset") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // reset-meta! - { - tmp0 := lang.NewSymbol("reset-meta!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("iref"), lang.NewSymbol("metadata-map"))), lang.NewKeyword("doc"), "Atomically resets the metadata for a namespace/var/ref/agent/atom", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2408), lang.NewKeyword("end-line"), int(2408))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5, _ := lang.FieldOrMethod(v3, "ResetMeta") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ResetMeta is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // reset-vals! - { - tmp0 := lang.NewSymbol("reset-vals!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atom"), lang.NewSymbol("newval"))), lang.NewKeyword("doc"), "Sets the value of atom to newval. Returns [old new], the value of the\n atom before and after the reset.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2375), lang.NewKeyword("end-line"), int(2375))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5, _ := lang.FieldOrMethod(v3, "resetVals") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("resetVals is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // resolve - { - tmp0 := lang.NewSymbol("resolve").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym")), lang.NewVector(lang.NewSymbol("env"), lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "same as (ns-resolve *ns* symbol) or (ns-resolve *ns* &env symbol)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4371), lang.NewKeyword("end-line"), int(4371))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("ns-resolve")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("*ns*")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp6, []any{tmp9, v3}) - return tmp10 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("ns-resolve")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("*ns*")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp7, []any{tmp10, v3, v4}) - return tmp11 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // rest - { - tmp1 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() - tmp0 := lang.NewSymbol("rest").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a possibly empty seq of the items after the first. Calls seq on its\n argument.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(64), lang.NewKeyword("end-line"), int(70))).(*lang.Symbol) - var tmp3 lang.FnFunc - { // function rest - var v4 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v5 := args[0] - _ = v5 - tmp6 := lang.Apply(lang.Rest, []any{v5}) - return tmp6 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(70), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(70), lang.NewKeyword("end-column"), int(77))).(lang.FnFunc) - v4 = tmp3 - _ = v4 - } - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // restart-agent - { - tmp0 := lang.NewSymbol("restart-agent").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("new-state"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "When an agent is failed, changes the agent state to new-state and\n then un-fails the agent so that sends are allowed again. If\n a :clear-actions true option is given, any actions queued on the\n agent that were being held while it was failed will be discarded,\n otherwise those held actions will proceed. The new-state must pass\n the validator if any, or restart will throw an exception and the\n agent will remain failed with its old state and error. Watchers, if\n any, will NOT be notified of the new state. Throws an exception if\n the agent is not failed.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2175), lang.NewKeyword("end-line"), int(2175))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - var tmp6 any - { // let - // let binding "opts" - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("apply")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("hash-map")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp9, []any{tmp12, v5}) - var v14 any = tmp13 - _ = v14 - var tmp15 any - tmp16 := lang.Apply(lang.NewKeyword("clear-actions"), []any{v14}) - if lang.IsTruthy(tmp16) { - tmp15 = true - } else { - tmp15 = false - } - tmp17, _ := lang.FieldOrMethod(v3, "restart") - if reflect.TypeOf(tmp17).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("restart is not a function"))) - } - tmp18 := lang.Apply(tmp17, []any{v4, tmp15}) - tmp6 = tmp18 - } // end let - return tmp6 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // resultset-seq - { - tmp0 := lang.NewSymbol("resultset-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rs"))), lang.NewKeyword("doc"), "Creates and returns a lazy sequence of structmaps corresponding to\n the rows in the java.sql.ResultSet rs", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5681), lang.NewKeyword("end-line"), int(5681))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "rsmeta" - tmp5, _ := lang.FieldOrMethod(v3, "getMetaData") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("getMetaData is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{}) - var v7 any = tmp6 - _ = v7 - // let binding "idxs" - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("range")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("inc")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14, _ := lang.FieldOrMethod(v7, "getColumnCount") - if reflect.TypeOf(tmp14).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("getColumnCount is not a function"))) - } - tmp15 := lang.Apply(tmp14, []any{}) - tmp16 := lang.Apply(tmp13, []any{tmp15}) - tmp17 := lang.Apply(tmp10, []any{int64(1), tmp16}) - var v18 any = tmp17 - _ = v18 - // let binding "keys" - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("map")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("comp")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("keyword")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - var tmp28 lang.FnFunc - tmp28 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v29 := args[0] - _ = v29 - tmp30, ok := lang.FieldOrMethod(v29, "toLowerCase") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v29, "toLowerCase"))) - } - var tmp31 any - switch reflect.TypeOf(tmp30).Kind() { - case reflect.Func: - tmp31 = lang.Apply(tmp30, nil) - default: - tmp31 = tmp30 - } - return tmp31 - }) - tmp29 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5688), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(5688), lang.NewKeyword("end-column"), int(62)) - tmp30, err := lang.WithMeta(tmp28, tmp29.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp31 := lang.Apply(tmp24, []any{tmp27, tmp30}) - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("map")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - var tmp35 lang.FnFunc - tmp35 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v36 := args[0] - _ = v36 - tmp37, _ := lang.FieldOrMethod(v7, "getColumnLabel") - if reflect.TypeOf(tmp37).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("getColumnLabel is not a function"))) - } - tmp38 := lang.Apply(tmp37, []any{v36}) - return tmp38 - }) - tmp36 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5689), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(5689), lang.NewKeyword("end-column"), int(63)) - tmp37, err := lang.WithMeta(tmp35, tmp36.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp38 := lang.Apply(tmp34, []any{tmp37, v18}) - tmp39 := lang.Apply(tmp21, []any{tmp31, tmp38}) - var v40 any = tmp39 - _ = v40 - // let binding "check-keys" - var tmp41 any - { // let - // let binding "or__0__auto__" - tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp43 := tmp42.FindInternedVar(lang.NewSymbol("apply")) - if tmp43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) - } - tmp44 := tmp43.Get() - tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp46 := tmp45.FindInternedVar(lang.NewSymbol("distinct?")) - if tmp46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) - } - tmp47 := tmp46.Get() - tmp48 := lang.Apply(tmp44, []any{tmp47, v40}) - var v49 any = tmp48 - _ = v49 - var tmp50 any - if lang.IsTruthy(v49) { - tmp50 = v49 - } else { - tmp51 := lang.Apply(lang.NewError, []any{"ResultSet must have unique column labels"}) - panic(tmp51) - } - tmp41 = tmp50 - } // end let - var v42 any = tmp41 - _ = v42 - // let binding "row-struct" - tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp44 := tmp43.FindInternedVar(lang.NewSymbol("apply")) - if tmp44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) - } - tmp45 := tmp44.Get() - tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp47 := tmp46.FindInternedVar(lang.NewSymbol("create-struct")) - if tmp47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) - } - tmp48 := tmp47.Get() - tmp49 := lang.Apply(tmp45, []any{tmp48, v40}) - var v50 any = tmp49 - _ = v50 - // let binding "row-values" - var tmp51 lang.FnFunc - tmp51 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - tmp52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp53 := tmp52.FindInternedVar(lang.NewSymbol("map")) - if tmp53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp53))) - } - tmp54 := tmp53.Get() - var tmp55 lang.FnFunc - tmp55 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v56 := args[0] - _ = v56 - tmp57, _ := lang.FieldOrMethod(v3, "getObject") - if reflect.TypeOf(tmp57).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("getObject is not a function"))) - } - tmp58 := lang.Apply(tmp57, []any{v56}) - return tmp58 - }) - tmp56 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5694), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(5694), lang.NewKeyword("end-column"), int(71)) - tmp57, err := lang.WithMeta(tmp55, tmp56.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp58 := lang.Apply(tmp54, []any{tmp57, v18}) - return tmp58 - }) - tmp52 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5694), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(5694), lang.NewKeyword("end-column"), int(78)) - tmp53, err := lang.WithMeta(tmp51, tmp52.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v54 any = tmp53 - _ = v54 - // let binding "rows" - var tmp55 lang.FnFunc - { // function thisfn - var v56 lang.FnFunc - tmp55 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var tmp57 any - tmp58, _ := lang.FieldOrMethod(v3, "next") - if reflect.TypeOf(tmp58).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("next is not a function"))) - } - tmp59 := lang.Apply(tmp58, []any{}) - if lang.IsTruthy(tmp59) { - tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp61 := tmp60.FindInternedVar(lang.NewSymbol("cons")) - if tmp61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) - } - tmp62 := tmp61.Get() - tmp63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp64 := tmp63.FindInternedVar(lang.NewSymbol("apply")) - if tmp64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp64))) - } - tmp65 := tmp64.Get() - tmp66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp67 := tmp66.FindInternedVar(lang.NewSymbol("struct")) - if tmp67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp67))) - } - tmp68 := tmp67.Get() - tmp69 := lang.Apply(v54, nil) - tmp70 := lang.Apply(tmp65, []any{tmp68, v50, tmp69}) - var tmp71 lang.FnFunc - tmp71 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - tmp72 := lang.Apply(v56, nil) - return tmp72 - }) - tmp72 := lang.Apply(lang.NewLazySeq, []any{tmp71}) - tmp73 := lang.Apply(tmp62, []any{tmp70, tmp72}) - tmp57 = tmp73 - } else { - } - return tmp57 - }) - v56 = tmp55 - _ = v56 - } - tmp56 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5695), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(5697), lang.NewKeyword("end-column"), int(86)) - tmp57, err := lang.WithMeta(tmp55, tmp56.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v58 any = tmp57 - _ = v58 - tmp59 := lang.Apply(v58, nil) - tmp4 = tmp59 - } // end let - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // reverse - { - tmp0 := lang.NewSymbol("reverse").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a seq of the items in coll in reverse order. Not lazy.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(940), lang.NewKeyword("end-line"), int(940))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("conj")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp6, []any{tmp9, lang.NewList(), v3}) - return tmp10 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // reversible? - { - tmp0 := lang.NewSymbol("reversible?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements Reversible", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6257), lang.NewKeyword("end-line"), int(6257))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.Apply(tmp6, []any{nil, v3}) - return tmp7 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // root-directory - { - tmp0 := lang.NewSymbol("root-directory").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"))), lang.NewKeyword("doc"), "Returns the root resource path for a lib", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5871), lang.NewKeyword("end-line"), int(5871), lang.NewKeyword("private"), true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "d" - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("root-resource")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v3}) - var v9 any = tmp8 - _ = v9 - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("subs")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(strings8.LastIndex, []any{v9, "/"}) - tmp14 := lang.Apply(tmp12, []any{v9, int64(0), tmp13}) - tmp4 = tmp14 - } // end let - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // root-resource - { - tmp1 := reflect.TypeOf("") - tmp0 := lang.NewSymbol("root-resource").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"))), lang.NewKeyword("doc"), "Returns the root directory path for a lib", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5864), lang.NewKeyword("end-line"), int(5864), lang.NewKeyword("private"), true)).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("str")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("name")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v4}) - tmp12 := lang.Apply(strings8.ReplaceAll, []any{tmp11, "-", "_"}) - tmp13 := lang.Apply(strings8.ReplaceAll, []any{tmp12, ".", "/"}) - tmp14 := lang.Apply(tmp7, []any{lang.NewChar(47), tmp13}) - return tmp14 - }) - tmp4 := reflect.TypeOf("") - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // rseq - { - tmp0 := lang.NewSymbol("rseq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rev"))), lang.NewKeyword("doc"), "Returns, in constant time, a seq of the items in rev (which\n can be a vector or sorted-map), in reverse order. If rev is empty returns nil", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1577), lang.NewKeyword("end-line"), int(1577))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4, _ := lang.FieldOrMethod(v3, "rseq") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("rseq is not a function"))) - } - tmp5 := lang.Apply(tmp4, []any{}) - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // rsubseq - { - tmp0 := lang.NewSymbol("rsubseq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sc"), lang.NewSymbol("test"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("sc"), lang.NewSymbol("start-test"), lang.NewSymbol("start-key"), lang.NewSymbol("end-test"), lang.NewSymbol("end-key"))), lang.NewKeyword("doc"), "sc must be a sorted collection, test(s) one of <, <=, > or\n >=. Returns a reverse seq of those entries with keys ek for\n which (test (.. sc comparator (compare ek key)) 0) is true", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5150), lang.NewKeyword("end-line"), int(5150))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var tmp6 any - { // let - // let binding "include" - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("mk-bound-fn")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp9, []any{v3, v4, v5}) - var v11 any = tmp10 - _ = v11 - var tmp12 any - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("<")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("<=")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{tmp15, tmp18})) - tmp20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5158), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5158), lang.NewKeyword("end-column"), int(17)) - tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp22 := lang.Apply(tmp21, []any{v4}) - if lang.IsTruthy(tmp22) { - var tmp23 any - { // let - // let binding "temp__0__auto__" - tmp24, _ := lang.FieldOrMethod(v3, "seqFrom") - if reflect.TypeOf(tmp24).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("seqFrom is not a function"))) - } - tmp25 := lang.Apply(tmp24, []any{v5, false}) - var v26 any = tmp25 - _ = v26 - var tmp27 any - if lang.IsTruthy(v26) { - var tmp28 any - { // let - // let binding "vec__74" - var v29 any = v26 - _ = v29 - // let binding "e" - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("nth")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.Apply(tmp32, []any{v29, int64(0), nil}) - var v34 any = tmp33 - _ = v34 - // let binding "s" - var v35 any = v29 - _ = v35 - var tmp36 any - tmp37 := lang.Apply(v11, []any{v34}) - if lang.IsTruthy(tmp37) { - tmp36 = v35 - } else { - tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp39 := tmp38.FindInternedVar(lang.NewSymbol("next")) - if tmp39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) - } - tmp40 := tmp39.Get() - tmp41 := lang.Apply(tmp40, []any{v35}) - tmp36 = tmp41 - } - tmp28 = tmp36 - } // end let - tmp27 = tmp28 - } else { - } - tmp23 = tmp27 - } // end let - tmp12 = tmp23 - } else { - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("take-while")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27, _ := lang.FieldOrMethod(v3, "seq") - if reflect.TypeOf(tmp27).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("seq is not a function"))) - } - tmp28 := lang.Apply(tmp27, []any{false}) - tmp29 := lang.Apply(tmp26, []any{v11, tmp28}) - tmp12 = tmp29 - } - tmp6 = tmp12 - } // end let - return tmp6 - case 5: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - v7 := args[4] - _ = v7 - var tmp8 any - { // let - // let binding "temp__0__auto__" - tmp9, _ := lang.FieldOrMethod(v3, "seqFrom") - if reflect.TypeOf(tmp9).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("seqFrom is not a function"))) - } - tmp10 := lang.Apply(tmp9, []any{v7, false}) - var v11 any = tmp10 - _ = v11 - var tmp12 any - if lang.IsTruthy(v11) { - var tmp13 any - { // let - // let binding "vec__77" - var v14 any = v11 - _ = v14 - // let binding "e" - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("nth")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{v14, int64(0), nil}) - var v19 any = tmp18 - _ = v19 - // let binding "s" - var v20 any = v14 - _ = v20 - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("take-while")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("mk-bound-fn")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.Apply(tmp26, []any{v3, v4, v5}) - var tmp28 any - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("mk-bound-fn")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.Apply(tmp31, []any{v3, v6, v7}) - tmp33 := lang.Apply(tmp32, []any{v19}) - if lang.IsTruthy(tmp33) { - tmp28 = v20 - } else { - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("next")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.Apply(tmp36, []any{v20}) - tmp28 = tmp37 - } - tmp38 := lang.Apply(tmp23, []any{tmp27, tmp28}) - tmp13 = tmp38 - } // end let - tmp12 = tmp13 - } else { - } - tmp8 = tmp12 - } // end let - return tmp8 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // run! - { - tmp0 := lang.NewSymbol("run!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("proc"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Runs the supplied procedure (via reduce), for purposes of side\n effects, on successive items in the collection. Returns nil", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7708), lang.NewKeyword("end-line"), int(7708))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("reduce")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - var tmp8 lang.FnFunc - tmp8 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v9 := args[0] - _ = v9 - v10 := args[1] - _ = v10 - tmp11 := lang.Apply(v3, []any{v10}) - return tmp11 - }) - tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7713), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(7713), lang.NewKeyword("end-column"), int(20)) - tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp11 := lang.Apply(tmp7, []any{tmp10, nil, v4}) - _ = tmp11 - return nil - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // second - { - tmp0 := lang.NewSymbol("second").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Same as (first (next x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(91), lang.NewKeyword("end-line"), int(95))).(*lang.Symbol) - var tmp2 lang.FnFunc - { // function second - var v3 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("first")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("next")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v4}) - tmp12 := lang.Apply(tmp7, []any{tmp11}) - return tmp12 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(95), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(95), lang.NewKeyword("end-column"), int(49))).(lang.FnFunc) - v3 = tmp2 - _ = v3 - } - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // select-keys - { - tmp0 := lang.NewSymbol("select-keys").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("keyseq"))), lang.NewKeyword("doc"), "Returns a map containing only those entries in map whose key is in keys", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1536), lang.NewKeyword("end-line"), int(1536))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - { // let - // let binding "ret" - tmp6 := lang.NewMap() - tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1541), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(1541), lang.NewKeyword("end-column"), int(17)) - tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v9 any = tmp8 - _ = v9 - // let binding "keys" - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("seq")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{v4}) - var v14 any = tmp13 - _ = v14 - for { - var tmp15 any - if lang.IsTruthy(v14) { - var tmp16 any - { // let - // let binding "entry" - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("first")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.Apply(tmp19, []any{v14}) - tmp21, _ := lang.FieldOrMethod(runtime4.RT, "Find") - if reflect.TypeOf(tmp21).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Find is not a function"))) - } - tmp22 := lang.Apply(tmp21, []any{v3, tmp20}) - var v23 any = tmp22 - _ = v23 - var tmp25 any - if lang.IsTruthy(v23) { - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("conj")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.Apply(tmp28, []any{v9, v23}) - tmp25 = tmp29 - } else { - tmp25 = v9 - } - var tmp24 any = tmp25 - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("next")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{v14}) - var tmp30 any = tmp34 - v9 = tmp24 - v14 = tmp30 - continue - } // end let - tmp15 = tmp16 - } else { - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("with-meta")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("meta")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.Apply(tmp22, []any{v3}) - tmp24 := lang.Apply(tmp19, []any{v9, tmp23}) - tmp15 = tmp24 - } - tmp5 = tmp15 - break - } - } // end let - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // send - { - tmp0 := lang.NewSymbol("send").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Dispatch an action to an agent. Returns the agent immediately.\n Subsequently, in a thread from a thread pool, the state of the agent\n will be set to the value of:\n\n (apply action-fn state-of-agent args)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2109), lang.NewKeyword("end-line"), int(2109))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("apply")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("send-via")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.Apply(tmp8, []any{tmp11, nil, v3, v4, v5}) - return tmp12 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // send-off - { - tmp0 := lang.NewSymbol("send-off").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Dispatch a potentially blocking action to an agent. Returns the\n agent immediately. Subsequently, in a separate thread, the state of\n the agent will be set to the value of:\n\n (apply action-fn state-of-agent args)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2120), lang.NewKeyword("end-line"), int(2120))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("apply")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("send-via")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.Apply(tmp8, []any{tmp11, nil, v3, v4, v5}) - return tmp12 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // send-via - { - tmp0 := lang.NewSymbol("send-via").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("executor"), lang.NewSymbol("a"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Dispatch an action to an agent. Returns the agent immediately.\n Subsequently, in a thread supplied by executor, the state of the agent\n will be set to the value of:\n\n (apply action-fn state-of-agent args)", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2099), lang.NewKeyword("end-line"), int(2099))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any - { // let - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("push-thread-bindings")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("hash-map")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*agent*")) - tmp15 := lang.Apply(tmp13, []any{tmp14, v4}) - tmp16 := lang.Apply(tmp10, []any{tmp15}) - _ = tmp16 - var tmp17 any - func() { - defer func() { - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.Apply(tmp20, nil) - _ = tmp21 - }() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("binding-conveyor-fn")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.Apply(tmp24, []any{v5}) - tmp17 = tmp25 - }() - tmp7 = tmp17 - } // end let - tmp8, _ := lang.FieldOrMethod(v4, "dispatch") - if reflect.TypeOf(tmp8).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("dispatch is not a function"))) - } - tmp9 := lang.Apply(tmp8, []any{tmp7, v6, v3}) - return tmp9 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // seq - { - tmp1 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() - tmp0 := lang.NewSymbol("seq").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a seq on the collection. If the collection is\n empty, returns nil. (seq nil) returns nil. seq also works on\n Strings, native Java arrays (of reference types) and any objects\n that implement Iterable. Note that seqs cache values, thus seq\n should not be used on any Iterable whose iterator repeatedly\n returns the same mutable object.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(4), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(126), lang.NewKeyword("end-line"), int(136))).(*lang.Symbol) - var tmp3 lang.FnFunc - { // function seq - var v4 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v5 := args[0] - _ = v5 - tmp6 := lang.Apply(lang.Seq, []any{v5}) - return tmp6 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(136), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(136), lang.NewKeyword("end-column"), int(126))).(lang.FnFunc) - v4 = tmp3 - _ = v4 - } - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // seq-to-map-for-destructuring - { - tmp0 := lang.NewSymbol("seq-to-map-for-destructuring").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Builds a map from a seq as described in\n https://glojure.org/reference/special_forms#keyword-arguments", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(34), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4390), lang.NewKeyword("end-line"), int(4390))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("next")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v3}) - if lang.IsTruthy(tmp8) { - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("to-array")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.Apply(tmp11, []any{v3}) - tmp13 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{tmp12}) - tmp4 = tmp13 - } else { - var tmp14 any - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("seq")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{v3}) - if lang.IsTruthy(tmp18) { - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("first")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, []any{v3}) - tmp14 = tmp22 - } else { - } - tmp4 = tmp14 - } - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // seq? - { - tmp0 := lang.NewSymbol("seq?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x implements ISeq", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(146), lang.NewKeyword("end-line"), int(150))).(*lang.Symbol) - var tmp2 lang.FnFunc - { // function seq? - var v3 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("instance?")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() - tmp9 := lang.Apply(tmp7, []any{tmp8, v4}) - return tmp9 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(150), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(150), lang.NewKeyword("end-column"), int(87))).(lang.FnFunc) - v3 = tmp2 - _ = v3 - } - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // seqable? - { - tmp0 := lang.NewSymbol("seqable?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if the seq function is supported for x", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6204), lang.NewKeyword("end-line"), int(6204))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.Apply(nil, []any{v3}) - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // seque - { - tmp0 := lang.NewSymbol("seque").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s")), lang.NewVector(lang.NewSymbol("n-or-q"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Creates a queued seq on another (presumably lazy) seq s. The queued\n seq will produce a concrete seq in the background, and can get up to\n n items ahead of the consumer. n-or-q can be an integer n buffer\n size, or an instance of java.util.concurrent BlockingQueue. Note\n that reading from a seque can block if the reader gets ahead of the\n producer.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5419), lang.NewKeyword("end-line"), int(5419))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seque")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.Apply(tmp6, []any{int64(100), v3}) - return tmp7 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - { // let - // let binding "q" - var tmp6 any - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("instance?")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp9, []any{nil, v3}) - if lang.IsTruthy(tmp10) { - tmp6 = v3 - } else { - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("int")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{v3}) - tmp15 := lang.Apply(nil, []any{tmp14}) - tmp6 = tmp15 - } - var v16 any = tmp6 - _ = v16 - // let binding "NIL" - tmp17 := lang.Apply(reflect.StructOf, []any{nil}) - tmp18 := lang.Apply(reflect.New, []any{tmp17}) - tmp19, ok := lang.FieldOrMethod(tmp18, "Interface") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp18, "Interface"))) - } - var tmp20 any - switch reflect.TypeOf(tmp19).Kind() { - case reflect.Func: - tmp20 = lang.Apply(tmp19, nil) - default: - tmp20 = tmp19 - } - var v21 any = tmp20 - _ = v21 - // let binding "agt" - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("agent")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - var tmp25 lang.FnFunc - tmp25 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - return v4 - }) - tmp26 := lang.Apply(lang.NewLazySeq, []any{tmp25}) - tmp27 := lang.Apply(tmp24, []any{tmp26}) - var v28 any = tmp27 - _ = v28 - // let binding "log-error" - var tmp29 lang.FnFunc - tmp29 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v30 := args[0] - _ = v30 - v31 := args[1] - _ = v31 - var tmp32 any - tmp33, _ := lang.FieldOrMethod(v30, "offer") - if reflect.TypeOf(tmp33).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("offer is not a function"))) - } - tmp34 := lang.Apply(tmp33, []any{v30}) - if lang.IsTruthy(tmp34) { - panic(v31) - } else { - tmp32 = v31 - } - return tmp32 - }) - tmp30 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5435), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(5438), lang.NewKeyword("end-column"), int(26)) - tmp31, err := lang.WithMeta(tmp29, tmp30.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v32 any = tmp31 - _ = v32 - // let binding "fill" - var tmp33 lang.FnFunc - tmp33 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v34 := args[0] - _ = v34 - var tmp35 any - if lang.IsTruthy(v34) { - var tmp36 any - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("instance?")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.Apply(tmp39, []any{nil, v34}) - if lang.IsTruthy(tmp40) { - tmp41 := lang.Apply(v32, []any{v16, v34}) - tmp36 = tmp41 - } else { - var tmp42 any - func() { - defer func() { - if r := recover(); r != nil { - if lang.CatchMatches(r, lang.Builtins["any"]) { - v43 := r - _ = v43 - tmp44 := lang.Apply(v32, []any{v16, v43}) - tmp42 = tmp44 - } else { - panic(r) - } - } - }() - var tmp43 any - { // let - // let binding "G__89" - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("seq")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.Apply(tmp46, []any{v34}) - var v48 any = tmp47 - _ = v48 - // let binding "vec__90" - var v49 any = v48 - _ = v49 - // let binding "seq__91" - tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp51 := tmp50.FindInternedVar(lang.NewSymbol("seq")) - if tmp51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) - } - tmp52 := tmp51.Get() - tmp53 := lang.Apply(tmp52, []any{v49}) - var v54 any = tmp53 - _ = v54 - // let binding "first__92" - tmp55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp56 := tmp55.FindInternedVar(lang.NewSymbol("first")) - if tmp56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp56))) - } - tmp57 := tmp56.Get() - tmp58 := lang.Apply(tmp57, []any{v54}) - var v59 any = tmp58 - _ = v59 - // let binding "seq__91" - tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp61 := tmp60.FindInternedVar(lang.NewSymbol("next")) - if tmp61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) - } - tmp62 := tmp61.Get() - tmp63 := lang.Apply(tmp62, []any{v54}) - var v64 any = tmp63 - _ = v64 - // let binding "x" - var v65 any = v59 - _ = v65 - // let binding "xs" - var v66 any = v64 - _ = v66 - // let binding "s" - var v67 any = v49 - _ = v67 - var tmp68 any - { // let - // let binding "G__89" - var v69 any = v48 - _ = v69 - for { - var tmp70 any - { // let - // let binding "vec__93" - var v71 any = v69 - _ = v71 - // let binding "seq__94" - tmp72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp73 := tmp72.FindInternedVar(lang.NewSymbol("seq")) - if tmp73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp73))) - } - tmp74 := tmp73.Get() - tmp75 := lang.Apply(tmp74, []any{v71}) - var v76 any = tmp75 - _ = v76 - // let binding "first__95" - tmp77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp78 := tmp77.FindInternedVar(lang.NewSymbol("first")) - if tmp78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp78))) - } - tmp79 := tmp78.Get() - tmp80 := lang.Apply(tmp79, []any{v76}) - var v81 any = tmp80 - _ = v81 - // let binding "seq__94" - tmp82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp83 := tmp82.FindInternedVar(lang.NewSymbol("next")) - if tmp83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp83))) - } - tmp84 := tmp83.Get() - tmp85 := lang.Apply(tmp84, []any{v76}) - var v86 any = tmp85 - _ = v86 - // let binding "x" - var v87 any = v81 - _ = v87 - // let binding "xs" - var v88 any = v86 - _ = v88 - // let binding "s" - var v89 any = v71 - _ = v89 - var tmp90 any - if lang.IsTruthy(v89) { - var tmp91 any - var tmp92 any - tmp93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp94 := tmp93.FindInternedVar(lang.NewSymbol("nil?")) - if tmp94.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp94))) - } - tmp95 := tmp94.Get() - tmp96 := lang.Apply(tmp95, []any{v87}) - if lang.IsTruthy(tmp96) { - tmp92 = v21 - } else { - tmp92 = v87 - } - tmp97, _ := lang.FieldOrMethod(v16, "offer") - if reflect.TypeOf(tmp97).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("offer is not a function"))) - } - tmp98 := lang.Apply(tmp97, []any{tmp92}) - if lang.IsTruthy(tmp98) { - var tmp99 any = v88 - v69 = tmp99 - continue - } else { - tmp91 = v89 - } - tmp90 = tmp91 - } else { - var tmp100 any - tmp101, _ := lang.FieldOrMethod(v16, "offer") - if reflect.TypeOf(tmp101).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("offer is not a function"))) - } - tmp102 := lang.Apply(tmp101, []any{v16}) - if lang.IsTruthy(tmp102) { - } else { - tmp100 = lang.NewList() - } - tmp90 = tmp100 - } - tmp70 = tmp90 - } // end let - tmp68 = tmp70 - break - } - } // end let - tmp43 = tmp68 - } // end let - tmp42 = tmp43 - }() - tmp36 = tmp42 - } - tmp35 = tmp36 - } else { - } - return tmp35 - }) - tmp34 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5439), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(5452), lang.NewKeyword("end-column"), int(44)) - tmp35, err := lang.WithMeta(tmp33, tmp34.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v36 any = tmp35 - _ = v36 - // let binding "drain" - var tmp37 lang.FnFunc - { // function drain - var v38 lang.FnFunc - tmp37 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var tmp39 lang.FnFunc - tmp39 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var tmp40 any - { // let - // let binding "x" - tmp41, ok := lang.FieldOrMethod(v16, "take") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v16, "take"))) - } - var tmp42 any - switch reflect.TypeOf(tmp41).Kind() { - case reflect.Func: - tmp42 = lang.Apply(tmp41, nil) - default: - tmp42 = tmp41 - } - var v43 any = tmp42 - _ = v43 - var tmp44 any - tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp46 := tmp45.FindInternedVar(lang.NewSymbol("identical?")) - if tmp46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) - } - tmp47 := tmp46.Get() - tmp48 := lang.Apply(tmp47, []any{v43, v16}) - if lang.IsTruthy(tmp48) { - tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp50 := tmp49.FindInternedVar(lang.NewSymbol("deref")) - if tmp50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) - } - tmp51 := tmp50.Get() - tmp52 := lang.Apply(tmp51, []any{v28}) - _ = tmp52 - } else { - tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp54 := tmp53.FindInternedVar(lang.NewSymbol("send-off")) - if tmp54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) - } - tmp55 := tmp54.Get() - tmp56 := lang.Apply(tmp55, []any{v28, v36}) - _ = tmp56 - tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp58 := tmp57.FindInternedVar(lang.NewSymbol("release-pending-sends")) - if tmp58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) - } - tmp59 := tmp58.Get() - tmp60 := lang.Apply(tmp59, nil) - _ = tmp60 - tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp62 := tmp61.FindInternedVar(lang.NewSymbol("cons")) - if tmp62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) - } - tmp63 := tmp62.Get() - var tmp64 any - tmp65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp66 := tmp65.FindInternedVar(lang.NewSymbol("identical?")) - if tmp66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp66))) - } - tmp67 := tmp66.Get() - tmp68 := lang.Apply(tmp67, []any{v43, v21}) - if lang.IsTruthy(tmp68) { - } else { - tmp64 = v43 - } - tmp69 := lang.Apply(v38, nil) - tmp70 := lang.Apply(tmp63, []any{tmp64, tmp69}) - tmp44 = tmp70 - } - tmp40 = tmp44 - } // end let - return tmp40 - }) - tmp40 := lang.Apply(lang.NewLazySeq, []any{tmp39}) - return tmp40 - }) - v38 = tmp37 - _ = v38 - } - tmp38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5453), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(5461), lang.NewKeyword("end-column"), int(73)) - tmp39, err := lang.WithMeta(tmp37, tmp38.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v40 any = tmp39 - _ = v40 - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("send-off")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.Apply(tmp43, []any{v28, v36}) - _ = tmp44 - tmp45 := lang.Apply(v40, nil) - tmp5 = tmp45 - } // end let - return tmp5 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // sequence - { - tmp0 := lang.NewSymbol("sequence").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("coll"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Coerces coll to a (possibly empty) sequence, if it is not already\n one. Will not force a lazy seq. (sequence nil) yields (), When a\n transducer is supplied, returns a lazy sequence of applications of\n the transform to the items in coll(s), i.e. to the set of first\n items of each coll, followed by the set of second\n items in each coll, until any one of the colls is exhausted. Any\n remaining items in other colls are ignored. The transform should accept\n number-of-colls arguments", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2639), lang.NewKeyword("end-line"), int(2639))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq?")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v3}) - if lang.IsTruthy(tmp8) { - tmp4 = v3 - } else { - var tmp9 any - { // let - // let binding "or__0__auto__" - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("seq")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{v3}) - var v14 any = tmp13 - _ = v14 - var tmp15 any - if lang.IsTruthy(v14) { - tmp15 = v14 - } else { - tmp15 = lang.NewList() - } - tmp9 = tmp15 - } // end let - tmp4 = tmp9 - } - return tmp4 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - { // let - // let binding "or__0__auto__" - tmp6 := lang.Apply(nil, []any{v4}) - tmp7 := lang.Apply(nil, []any{v3, tmp6}) - tmp8 := lang.Apply(nil, []any{tmp7}) - var v9 any = tmp8 - _ = v9 - var tmp10 any - if lang.IsTruthy(v9) { - tmp10 = v9 - } else { - tmp10 = lang.NewList() - } - tmp5 = tmp10 - } // end let - return tmp5 - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - var tmp6 any - { // let - // let binding "or__0__auto__" - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("map")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - var tmp10 lang.FnFunc - tmp10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v11 := args[0] - _ = v11 - tmp12 := lang.Apply(nil, []any{v11}) - return tmp12 - }) - tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2661), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(2661), lang.NewKeyword("end-column"), int(41)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("cons")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{v4, v5}) - tmp17 := lang.Apply(tmp9, []any{tmp12, tmp16}) - tmp18 := lang.Apply(nil, []any{v3, tmp17}) - tmp19 := lang.Apply(nil, []any{tmp18}) - var v20 any = tmp19 - _ = v20 - var tmp21 any - if lang.IsTruthy(v20) { - tmp21 = v20 - } else { - tmp21 = lang.NewList() - } - tmp6 = tmp21 - } // end let - return tmp6 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // sequential? - { - tmp0 := lang.NewSymbol("sequential?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements Sequential", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6229), lang.NewKeyword("end-line"), int(6229))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := reflect.TypeOf((*lang.Sequential)(nil)).Elem() - tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) - return tmp8 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // serialized-require - { - tmp0 := lang.NewSymbol("serialized-require").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Like 'require', but serializes loading.\n Interim function preferred over 'require' for known asynchronous loads.\n Future changes may make these equivalent.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6059), lang.NewKeyword("end-line"), int(6059), lang.NewKeyword("private"), true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var v3 any = lang.NewList(args[0:]...) - _ = v3 - var tmp4 any - { // let - // let binding "lockee__0__auto__" - var v5 any = nil - _ = v5 - var tmp6 any - func() { - var tmp7 any - { // let - // let binding "locklocal__1__auto__" - var v8 any = v5 - _ = v8 - tmp9 := lang.Apply(nil, []any{v8}) - _ = tmp9 - var tmp10 any - func() { - defer func() { - tmp11 := lang.Apply(nil, []any{v8}) - _ = tmp11 - }() - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("apply")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("require")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp14, []any{tmp17, v3}) - tmp10 = tmp18 - }() - tmp7 = tmp10 - } // end let - tmp6 = tmp7 - }() - tmp4 = tmp6 - } // end let - return tmp4 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // set - { - tmp0 := lang.NewSymbol("set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a set of the distinct elements of coll.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4104), lang.NewKeyword("end-line"), int(4104))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("set?")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v3}) - if lang.IsTruthy(tmp8) { - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("with-meta")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.Apply(tmp11, []any{v3, nil}) - tmp4 = tmp12 - } else { - var tmp13 any - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("instance?")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := reflect.TypeOf((*lang.IReduceInit)(nil)).Elem() - tmp18 := lang.Apply(tmp16, []any{tmp17, v3}) - if lang.IsTruthy(tmp18) { - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("persistent!")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("conj!")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("transient")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) - tmp29 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4112), lang.NewKeyword("column"), int(108), lang.NewKeyword("end-line"), int(4112), lang.NewKeyword("end-column"), int(110)) - tmp30, err := lang.WithMeta(tmp28, tmp29.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp31 := lang.Apply(tmp27, []any{tmp30}) - tmp32, _ := lang.FieldOrMethod(v3, "ReduceInit") - if reflect.TypeOf(tmp32).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) - } - tmp33 := lang.Apply(tmp32, []any{tmp24, tmp31}) - tmp34 := lang.Apply(tmp21, []any{tmp33}) - tmp13 = tmp34 - } else { - tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp36 := tmp35.FindInternedVar(lang.NewSymbol("persistent!")) - if tmp36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) - } - tmp37 := tmp36.Get() - tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp39 := tmp38.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) - } - tmp40 := tmp39.Get() - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("conj!")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("transient")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) - tmp48 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4113), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(4113), lang.NewKeyword("end-column"), int(48)) - tmp49, err := lang.WithMeta(tmp47, tmp48.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp50 := lang.Apply(tmp46, []any{tmp49}) - tmp51 := lang.Apply(tmp40, []any{tmp43, tmp50, v3}) - tmp52 := lang.Apply(tmp37, []any{tmp51}) - tmp13 = tmp52 - } - tmp4 = tmp13 - } - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // set-agent-send-executor! - { - tmp0 := lang.NewSymbol("set-agent-send-executor!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("executor"))), lang.NewKeyword("doc"), "Sets the ExecutorService to be used by send", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(30), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2087), lang.NewKeyword("end-line"), int(2087))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - return nil - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // set-agent-send-off-executor! - { - tmp0 := lang.NewSymbol("set-agent-send-off-executor!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("executor"))), lang.NewKeyword("doc"), "Sets the ExecutorService to be used by send-off", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(34), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2093), lang.NewKeyword("end-line"), int(2093))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - return nil - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // set-error-handler! - { - tmp0 := lang.NewSymbol("set-error-handler!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("handler-fn"))), lang.NewKeyword("doc"), "Sets the error-handler of agent a to handler-fn. If an action\n being run by the agent throws an exception or doesn't pass the\n validator fn, handler-fn will be called with two arguments: the\n agent and the exception.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2192), lang.NewKeyword("end-line"), int(2192))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5, _ := lang.FieldOrMethod(v3, "setErrorHandler") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorHandler is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // set-error-mode! - { - tmp0 := lang.NewSymbol("set-error-mode!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("mode-keyword"))), lang.NewKeyword("doc"), "Sets the error-mode of agent a to mode-keyword, which must be\n either :fail or :continue. If an action being run by the agent\n throws an exception or doesn't pass the validator fn, an\n error-handler may be called (see set-error-handler!), after which,\n if the mode is :continue, the agent will continue as if neither the\n action that caused the error nor the error itself ever happened.\n \n If the mode is :fail, the agent will become failed and will stop\n accepting new 'send' and 'send-off' actions, and any previously\n queued actions will be held until a 'restart-agent'. Deref will\n still work, returning the state of the agent before the error.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2210), lang.NewKeyword("end-line"), int(2210))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5, _ := lang.FieldOrMethod(v3, "setErrorMode") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorMode is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // set-validator! - { - tmp0 := lang.NewSymbol("set-validator!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("iref"), lang.NewSymbol("validator-fn"))), lang.NewKeyword("doc"), "Sets the validator-fn for a var/ref/agent/atom. validator-fn must be nil or a\n side-effect-free fn of one argument, which will be passed the intended\n new state on any state change. If the new state is unacceptable, the\n validator-fn should return false or throw an exception. If the current state (root\n value if var) is not acceptable to the new validator, an exception\n will be thrown and the validator will not be changed.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2381), lang.NewKeyword("end-line"), int(2381))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5, _ := lang.FieldOrMethod(v3, "setValidator") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setValidator is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // set? - { - tmp0 := lang.NewSymbol("set?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements IPersistentSet", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4098), lang.NewKeyword("end-line"), int(4098))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := reflect.TypeOf((*lang.IPersistentSet)(nil)).Elem() - tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) - return tmp8 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // setup-reference - { - tmp0 := lang.NewSymbol("setup-reference").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2043), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(2044), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("r"), lang.NewSymbol("options"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - { // let - // let binding "opts" - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("apply")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("hash-map")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.Apply(tmp8, []any{tmp11, v4}) - var v13 any = tmp12 - _ = v13 - var tmp14 any - tmp15 := lang.Apply(lang.NewKeyword("meta"), []any{v13}) - if lang.IsTruthy(tmp15) { - tmp16 := lang.Apply(lang.NewKeyword("meta"), []any{v13}) - tmp17, _ := lang.FieldOrMethod(v3, "ResetMeta") - if reflect.TypeOf(tmp17).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ResetMeta is not a function"))) - } - tmp18 := lang.Apply(tmp17, []any{tmp16}) - tmp14 = tmp18 - } else { - } - _ = tmp14 - var tmp19 any - tmp20 := lang.Apply(lang.NewKeyword("validator"), []any{v13}) - if lang.IsTruthy(tmp20) { - tmp21 := lang.Apply(lang.NewKeyword("validator"), []any{v13}) - tmp22, _ := lang.FieldOrMethod(v3, "setValidator") - if reflect.TypeOf(tmp22).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setValidator is not a function"))) - } - tmp23 := lang.Apply(tmp22, []any{tmp21}) - tmp19 = tmp23 - } else { - } - _ = tmp19 - tmp5 = v3 - } // end let - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // shift-mask - { - tmp0 := lang.NewSymbol("shift-mask").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6598), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(6598), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("shift"), lang.NewSymbol("mask"), lang.NewSymbol("x"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("bit-and")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("bit-shift-right")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.Apply(tmp11, []any{v5, v3}) - tmp13 := lang.Apply(tmp8, []any{tmp12, v4}) - return tmp13 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // short - { - var tmp1 lang.FnFunc - { // function short__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - var tmp30 any - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("*unchecked-math*")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - if lang.IsTruthy(tmp33) { - tmp30 = lang.NewSymbol("uncheckedShortCast") - } else { - tmp30 = lang.NewSymbol("shortCast") - } - tmp34 := lang.Apply(tmp29, []any{tmp30}) - tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp36 := tmp35.FindInternedVar(lang.NewSymbol("list")) - if tmp36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) - } - tmp37 := tmp36.Get() - tmp38 := lang.Apply(tmp37, []any{v3}) - tmp39 := lang.Apply(tmp26, []any{tmp34, tmp38}) - tmp40 := lang.Apply(tmp23, []any{tmp39}) - tmp41 := lang.Apply(tmp20, []any{tmp40}) - tmp42 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp41}) - tmp43 := lang.Apply(tmp6, []any{tmp42}) - return tmp43 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("short").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to short", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3499), lang.NewKeyword("end-line"), int(3499))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5 := lang.Apply(lang.ShortCast, []any{v4}) - return tmp5 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // short-array - { - var tmp1 lang.FnFunc - { // function short-array__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var v3 any = lang.NewList(args[0:]...) - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.Apply(tmp20, []any{lang.NewSymbol("glojure.core/ShortArray")}) - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("list")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("seq")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("concat")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) - tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp36 := tmp35.FindInternedVar(lang.NewSymbol("list")) - if tmp36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) - } - tmp37 := tmp36.Get() - tmp38 := lang.Apply(tmp37, []any{lang.NewSymbol("glojure.core/args")}) - tmp39 := lang.Apply(tmp30, []any{tmp34, tmp38}) - tmp40 := lang.Apply(tmp27, []any{tmp39}) - tmp41 := lang.Apply(tmp24, []any{tmp40}) - tmp42 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp21, tmp41}) - tmp43 := lang.Apply(tmp6, []any{tmp42}) - return tmp43 - } - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("short-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Creates an array of shorts", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5333), lang.NewKeyword("end-line"), int(5333))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "ShortArray") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ShortArray is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - case 2: - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "ShortArrayInit") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ShortArrayInit is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // shorts - { - var tmp1 lang.FnFunc - { // function shorts - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.Apply(tmp20, []any{lang.NewSymbol("glojure.core/Shorts")}) - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("list")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.Apply(tmp24, []any{v3}) - tmp26 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp21, tmp25}) - tmp27 := lang.Apply(tmp6, []any{tmp26}) - return tmp27 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("shorts").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Casts to shorts[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5387), lang.NewKeyword("end-line"), int(5387))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Shorts") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Shorts is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // shuffle - { - tmp0 := lang.NewSymbol("shuffle").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return a random permutation of coll", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7300), lang.NewKeyword("end-line"), int(7300))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "al" - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("to-array")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v3}) - tmp9 := lang.Apply(lang.NewArrayList, []any{tmp8}) - var v10 any = tmp9 - _ = v10 - tmp11 := lang.Apply(nil, []any{v10}) - _ = tmp11 - tmp12, ok := lang.FieldOrMethod(v10, "toArray") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v10, "toArray"))) - } - var tmp13 any - switch reflect.TypeOf(tmp12).Kind() { - case reflect.Func: - tmp13 = lang.Apply(tmp12, nil) - default: - tmp13 = tmp12 - } - tmp14 := lang.Apply(nil, []any{tmp13}) - tmp4 = tmp14 - } // end let - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // shutdown-agents - { - tmp0 := lang.NewSymbol("shutdown-agents").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Initiates a shutdown of the thread pools that back the agent\n system. Running actions will complete, but no new actions will be\n accepted", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2252), lang.NewKeyword("end-line"), int(2252))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - tmp3 := lang.Apply(lang.ShutdownAgents, nil) - return tmp3 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // sigs - { - tmp0 := lang.NewSymbol("sigs").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(223), lang.NewKeyword("column"), int(2), lang.NewKeyword("end-line"), int(224), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("assert-valid-fdecl")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.Apply(tmp6, []any{v3}) - _ = tmp7 - var tmp8 any - { // let - // let binding "asig" - var tmp9 lang.FnFunc - tmp9 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v10 := args[0] - _ = v10 - var tmp11 any - { // let - // let binding "arglist" - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("first")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.Apply(tmp14, []any{v10}) - var v16 any = tmp15 - _ = v16 - // let binding "arglist" - var tmp17 any - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("first")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.Apply(tmp20, []any{v16}) - tmp22 := lang.Apply(lang.Equals, []any{lang.NewSymbol("&form"), tmp21}) - if lang.IsTruthy(tmp22) { - tmp23 := lang.Apply(lang.Count, []any{v16}) - tmp24 := lang.Apply(lang.Subvec, []any{v16, int64(2), tmp23}) - tmp17 = tmp24 - } else { - tmp17 = v16 - } - var v25 any = tmp17 - _ = v25 - // let binding "body" - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("next")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.Apply(tmp28, []any{v10}) - var v30 any = tmp29 - _ = v30 - var tmp31 any - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("map?")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp36 := tmp35.FindInternedVar(lang.NewSymbol("first")) - if tmp36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) - } - tmp37 := tmp36.Get() - tmp38 := lang.Apply(tmp37, []any{v30}) - tmp39 := lang.Apply(tmp34, []any{tmp38}) - if lang.IsTruthy(tmp39) { - var tmp40 any - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("next")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.Apply(tmp43, []any{v30}) - if lang.IsTruthy(tmp44) { - tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp46 := tmp45.FindInternedVar(lang.NewSymbol("with-meta")) - if tmp46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) - } - tmp47 := tmp46.Get() - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("conj")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - var tmp51 any - tmp52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp53 := tmp52.FindInternedVar(lang.NewSymbol("meta")) - if tmp53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp53))) - } - tmp54 := tmp53.Get() - tmp55 := lang.Apply(tmp54, []any{v25}) - if lang.IsTruthy(tmp55) { - tmp56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp57 := tmp56.FindInternedVar(lang.NewSymbol("meta")) - if tmp57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp57))) - } - tmp58 := tmp57.Get() - tmp59 := lang.Apply(tmp58, []any{v25}) - tmp51 = tmp59 - } else { - tmp60 := lang.NewMap() - tmp61 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(237), lang.NewKeyword("column"), int(77), lang.NewKeyword("end-line"), int(237), lang.NewKeyword("end-column"), int(78)) - tmp62, err := lang.WithMeta(tmp60, tmp61.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp51 = tmp62 - } - tmp63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp64 := tmp63.FindInternedVar(lang.NewSymbol("first")) - if tmp64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp64))) - } - tmp65 := tmp64.Get() - tmp66 := lang.Apply(tmp65, []any{v30}) - tmp67 := lang.Apply(tmp50, []any{tmp51, tmp66}) - tmp68 := lang.Apply(tmp47, []any{v25, tmp67}) - tmp40 = tmp68 - } else { - tmp40 = v25 - } - tmp31 = tmp40 - } else { - tmp31 = v25 - } - tmp11 = tmp31 - } // end let - return tmp11 - }) - tmp10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(228), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(239), lang.NewKeyword("end-column"), int(25)) - tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v12 any = tmp11 - _ = v12 - // let binding "resolve-tag" - var tmp13 lang.FnFunc - tmp13 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v14 := args[0] - _ = v14 - var tmp15 any - { // let - // let binding "m" - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("meta")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{v14}) - var v20 any = tmp19 - _ = v20 - // let binding "tag" - tmp21 := lang.Apply(lang.NewKeyword("tag"), []any{v20}) - var v22 any = tmp21 - _ = v22 - var tmp23 any - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("instance?")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := reflect.TypeOf((*lang.Symbol)(nil)) - tmp28 := lang.Apply(tmp26, []any{tmp27, v22}) - if lang.IsTruthy(tmp28) { - var tmp29 any - tmp30, ok := lang.FieldOrMethod(v22, "Name") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v22, "Name"))) - } - var tmp31 any - switch reflect.TypeOf(tmp30).Kind() { - case reflect.Func: - tmp31 = lang.Apply(tmp30, nil) - default: - tmp31 = tmp30 - } - tmp32 := lang.Apply(strings8.Index, []any{tmp31, "."}) - tmp33 := lang.Apply(lang.Equiv, []any{tmp32, int64(-1)}) - if lang.IsTruthy(tmp33) { - var tmp34 any - tmp35 := lang.Apply(lang.Equals, []any{nil, nil}) - if lang.IsTruthy(tmp35) { - var tmp36 any - { // let - // let binding "c" - var v37 any = nil - _ = v37 - var tmp38 any - if lang.IsTruthy(v37) { - tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp40 := tmp39.FindInternedVar(lang.NewSymbol("with-meta")) - if tmp40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) - } - tmp41 := tmp40.Get() - tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp43 := tmp42.FindInternedVar(lang.NewSymbol("assoc")) - if tmp43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) - } - tmp44 := tmp43.Get() - tmp45, ok := lang.FieldOrMethod(v37, "Name") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v37, "Name"))) - } - var tmp46 any - switch reflect.TypeOf(tmp45).Kind() { - case reflect.Func: - tmp46 = lang.Apply(tmp45, nil) - default: - tmp46 = tmp45 - } - tmp47 := lang.Apply(lang.NewSymbol, []any{tmp46}) - tmp48 := lang.Apply(tmp44, []any{v20, lang.NewKeyword("tag"), tmp47}) - tmp49 := lang.Apply(tmp41, []any{v14, tmp48}) - tmp38 = tmp49 - } else { - tmp38 = v14 - } - tmp36 = tmp38 - } // end let - tmp34 = tmp36 - } else { - tmp34 = v14 - } - tmp29 = tmp34 - } else { - tmp29 = v14 - } - tmp23 = tmp29 - } else { - tmp23 = v14 - } - tmp15 = tmp23 - } // end let - return tmp15 - }) - tmp14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(240), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(252), lang.NewKeyword("end-column"), int(37)) - tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v16 any = tmp15 - _ = v16 - var tmp17 any - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("seq?")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("first")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.Apply(tmp23, []any{v3}) - tmp25 := lang.Apply(tmp20, []any{tmp24}) - if lang.IsTruthy(tmp25) { - var tmp26 any - { // let - // let binding "ret" - tmp27 := lang.NewVector() - tmp28 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(254), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(254), lang.NewKeyword("end-column"), int(20)) - tmp29, err := lang.WithMeta(tmp27, tmp28.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v30 any = tmp29 - _ = v30 - // let binding "fdecls" - var v31 any = v3 - _ = v31 - for { - var tmp32 any - if lang.IsTruthy(v31) { - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("conj")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("first")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.Apply(tmp39, []any{v31}) - tmp41 := lang.Apply(v12, []any{tmp40}) - tmp42 := lang.Apply(v16, []any{tmp41}) - tmp43 := lang.Apply(tmp36, []any{v30, tmp42}) - var tmp33 any = tmp43 - tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp46 := tmp45.FindInternedVar(lang.NewSymbol("next")) - if tmp46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) - } - tmp47 := tmp46.Get() - tmp48 := lang.Apply(tmp47, []any{v31}) - var tmp44 any = tmp48 - v30 = tmp33 - v31 = tmp44 - continue - } else { - tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp50 := tmp49.FindInternedVar(lang.NewSymbol("seq")) - if tmp50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) - } - tmp51 := tmp50.Get() - tmp52 := lang.Apply(tmp51, []any{v30}) - tmp32 = tmp52 - } - tmp26 = tmp32 - break - } - } // end let - tmp17 = tmp26 - } else { - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(v12, []any{v3}) - tmp31 := lang.Apply(v16, []any{tmp30}) - tmp32 := lang.Apply(tmp29, []any{tmp31}) - tmp17 = tmp32 - } - tmp8 = tmp17 - } // end let - return tmp8 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(225), lang.NewKeyword("column"), int(2), lang.NewKeyword("end-line"), int(258), lang.NewKeyword("end-column"), int(43))).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // simple-ident? - { - tmp0 := lang.NewSymbol("simple-ident?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a symbol or keyword without a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1613), lang.NewKeyword("end-line"), int(1613))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "and__0__auto__" - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("ident?")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v3}) - var v9 any = tmp8 - _ = v9 - var tmp10 any - if lang.IsTruthy(v9) { - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("nil?")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("namespace")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{v3}) - tmp18 := lang.Apply(tmp13, []any{tmp17}) - tmp10 = tmp18 - } else { - tmp10 = v9 - } - tmp4 = tmp10 - } // end let - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // simple-keyword? - { - tmp0 := lang.NewSymbol("simple-keyword?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a keyword without a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1633), lang.NewKeyword("end-line"), int(1633))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "and__0__auto__" - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("keyword?")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v3}) - var v9 any = tmp8 - _ = v9 - var tmp10 any - if lang.IsTruthy(v9) { - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("nil?")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("namespace")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{v3}) - tmp18 := lang.Apply(tmp13, []any{tmp17}) - tmp10 = tmp18 - } else { - tmp10 = v9 - } - tmp4 = tmp10 - } // end let - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // simple-symbol? - { - tmp0 := lang.NewSymbol("simple-symbol?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a symbol without a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1623), lang.NewKeyword("end-line"), int(1623))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "and__0__auto__" - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("symbol?")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v3}) - var v9 any = tmp8 - _ = v9 - var tmp10 any - if lang.IsTruthy(v9) { - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("nil?")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("namespace")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{v3}) - tmp18 := lang.Apply(tmp13, []any{tmp17}) - tmp10 = tmp18 - } else { - tmp10 = v9 - } - tmp4 = tmp10 - } // end let - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // slurp - { - tmp1 := reflect.TypeOf("") - tmp0 := lang.NewSymbol("slurp").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("opts"))), lang.NewKeyword("doc"), "Opens a reader on f and reads all its contents, returning a string.\n See glojure.java.io/reader for a complete list of supported arguments.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6982), lang.NewKeyword("end-line"), int(6982))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - var v5 any = lang.NewList(args[1:]...) - _ = v5 - var tmp6 any - { // let - // let binding "opts" - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("normalize-slurp-opts")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp9, []any{v5}) - var v11 any = tmp10 - _ = v11 - // let binding "sw" - var v12 any = "unimplemented: new with non-constant class type" - _ = v12 - var tmp13 any - { // let - // let binding "r" - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("apply")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.go.io")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("reader")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.Apply(tmp16, []any{tmp19, v4, v11}) - var v21 any = tmp20 - _ = v21 - var tmp22 any - func() { - defer func() { - tmp23, ok := lang.FieldOrMethod(v21, "close") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v21, "close"))) - } - var tmp24 any - switch reflect.TypeOf(tmp23).Kind() { - case reflect.Func: - tmp24 = lang.Apply(tmp23, nil) - default: - tmp24 = tmp23 - } - _ = tmp24 - }() - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.go.io")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("copy")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.Apply(tmp27, []any{v21, v12}) - _ = tmp28 - tmp29 := lang.Apply(lang.ToString, []any{v12}) - tmp22 = tmp29 - }() - tmp13 = tmp22 - } // end let - tmp6 = tmp13 - } // end let - return tmp6 - } - }) - tmp4 := reflect.TypeOf("") - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // some - { - tmp0 := lang.NewSymbol("some").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns the first logical true value of (pred x) for any x in coll,\n else nil. One common idiom is to use a set as pred, for example\n this will return :fred if :fred is in the sequence, otherwise nil:\n (some #{:fred} coll)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2684), lang.NewKeyword("end-line"), int(2684))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - recur_loop_481: - var tmp5 any - { // let - // let binding "temp__0__auto__" - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("seq")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(tmp8, []any{v4}) - var v10 any = tmp9 - _ = v10 - var tmp11 any - if lang.IsTruthy(v10) { - var tmp12 any - { // let - // let binding "s" - var v13 any = v10 - _ = v13 - var tmp14 any - { // let - // let binding "or__0__auto__" - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("first")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{v13}) - tmp19 := lang.Apply(v3, []any{tmp18}) - var v20 any = tmp19 - _ = v20 - var tmp21 any - if lang.IsTruthy(v20) { - tmp21 = v20 - } else { - var tmp22 any = v3 - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("next")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.Apply(tmp26, []any{v13}) - var tmp23 any = tmp27 - v3 = tmp22 - v4 = tmp23 - goto recur_loop_481 - } - tmp14 = tmp21 - } // end let - tmp12 = tmp14 - } // end let - tmp11 = tmp12 - } else { - } - tmp5 = tmp11 - } // end let - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // some-> - { - tmp0 := lang.NewSymbol("some->").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "When expr is not nil, threads it into the first form (via ->),\n and when that result is not nil, through the next etc", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7610), lang.NewKeyword("end-line"), int(7610))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any - { // let - // let binding "g" - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("gensym")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, nil) - var v12 any = tmp11 - _ = v12 - // let binding "steps" - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("map")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - var tmp16 lang.FnFunc - tmp16 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v17 := args[0] - _ = v17 - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("seq")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("concat")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("list")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.Apply(tmp26, []any{lang.NewSymbol("if")}) - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("list")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("seq")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("concat")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("list")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.Apply(tmp39, []any{lang.NewSymbol("glojure.core/nil?")}) - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("list")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.Apply(tmp43, []any{v12}) - tmp45 := lang.Apply(tmp36, []any{tmp40, tmp44}) - tmp46 := lang.Apply(tmp33, []any{tmp45}) - tmp47 := lang.Apply(tmp30, []any{tmp46}) - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{nil}) - tmp52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp53 := tmp52.FindInternedVar(lang.NewSymbol("list")) - if tmp53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp53))) - } - tmp54 := tmp53.Get() - tmp55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp56 := tmp55.FindInternedVar(lang.NewSymbol("seq")) - if tmp56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp56))) - } - tmp57 := tmp56.Get() - tmp58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp59 := tmp58.FindInternedVar(lang.NewSymbol("concat")) - if tmp59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp59))) - } - tmp60 := tmp59.Get() - tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp62 := tmp61.FindInternedVar(lang.NewSymbol("list")) - if tmp62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) - } - tmp63 := tmp62.Get() - tmp64 := lang.Apply(tmp63, []any{lang.NewSymbol("glojure.core/->")}) - tmp65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp66 := tmp65.FindInternedVar(lang.NewSymbol("list")) - if tmp66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp66))) - } - tmp67 := tmp66.Get() - tmp68 := lang.Apply(tmp67, []any{v12}) - tmp69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp70 := tmp69.FindInternedVar(lang.NewSymbol("list")) - if tmp70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp70))) - } - tmp71 := tmp70.Get() - tmp72 := lang.Apply(tmp71, []any{v17}) - tmp73 := lang.Apply(tmp60, []any{tmp64, tmp68, tmp72}) - tmp74 := lang.Apply(tmp57, []any{tmp73}) - tmp75 := lang.Apply(tmp54, []any{tmp74}) - tmp76 := lang.Apply(tmp23, []any{tmp27, tmp47, tmp51, tmp75}) - tmp77 := lang.Apply(tmp20, []any{tmp76}) - return tmp77 - }) - tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7616), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7616), lang.NewKeyword("end-column"), int(64)) - tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp19 := lang.Apply(tmp15, []any{tmp18, v6}) - var v20 any = tmp19 - _ = v20 - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/let")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("apply")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("vector")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("seq")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp44 := tmp43.FindInternedVar(lang.NewSymbol("concat")) - if tmp44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) - } - tmp45 := tmp44.Get() - tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp47 := tmp46.FindInternedVar(lang.NewSymbol("list")) - if tmp47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) - } - tmp48 := tmp47.Get() - tmp49 := lang.Apply(tmp48, []any{v12}) - tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp51 := tmp50.FindInternedVar(lang.NewSymbol("list")) - if tmp51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) - } - tmp52 := tmp51.Get() - tmp53 := lang.Apply(tmp52, []any{v5}) - tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp55 := tmp54.FindInternedVar(lang.NewSymbol("interleave")) - if tmp55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) - } - tmp56 := tmp55.Get() - tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp58 := tmp57.FindInternedVar(lang.NewSymbol("repeat")) - if tmp58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) - } - tmp59 := tmp58.Get() - tmp60 := lang.Apply(tmp59, []any{v12}) - tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp62 := tmp61.FindInternedVar(lang.NewSymbol("butlast")) - if tmp62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) - } - tmp63 := tmp62.Get() - tmp64 := lang.Apply(tmp63, []any{v20}) - tmp65 := lang.Apply(tmp56, []any{tmp60, tmp64}) - tmp66 := lang.Apply(tmp45, []any{tmp49, tmp53, tmp65}) - tmp67 := lang.Apply(tmp42, []any{tmp66}) - tmp68 := lang.Apply(tmp36, []any{tmp39, tmp67}) - tmp69 := lang.Apply(tmp33, []any{tmp68}) - tmp70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp71 := tmp70.FindInternedVar(lang.NewSymbol("list")) - if tmp71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp71))) - } - tmp72 := tmp71.Get() - var tmp73 any - tmp74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp75 := tmp74.FindInternedVar(lang.NewSymbol("empty?")) - if tmp75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp75))) - } - tmp76 := tmp75.Get() - tmp77 := lang.Apply(tmp76, []any{v20}) - if lang.IsTruthy(tmp77) { - tmp73 = v12 - } else { - tmp78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp79 := tmp78.FindInternedVar(lang.NewSymbol("last")) - if tmp79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp79))) - } - tmp80 := tmp79.Get() - tmp81 := lang.Apply(tmp80, []any{v20}) - tmp73 = tmp81 - } - tmp82 := lang.Apply(tmp72, []any{tmp73}) - tmp83 := lang.Apply(tmp26, []any{tmp30, tmp69, tmp82}) - tmp84 := lang.Apply(tmp23, []any{tmp83}) - tmp7 = tmp84 - } // end let - return tmp7 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // some->> - { - tmp0 := lang.NewSymbol("some->>").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "When expr is not nil, threads it into the first form (via ->>),\n and when that result is not nil, through the next etc", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7624), lang.NewKeyword("end-line"), int(7624))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any - { // let - // let binding "g" - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("gensym")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, nil) - var v12 any = tmp11 - _ = v12 - // let binding "steps" - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("map")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - var tmp16 lang.FnFunc - tmp16 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v17 := args[0] - _ = v17 - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("seq")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("concat")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("list")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.Apply(tmp26, []any{lang.NewSymbol("if")}) - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("list")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("seq")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("concat")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("list")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.Apply(tmp39, []any{lang.NewSymbol("glojure.core/nil?")}) - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("list")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.Apply(tmp43, []any{v12}) - tmp45 := lang.Apply(tmp36, []any{tmp40, tmp44}) - tmp46 := lang.Apply(tmp33, []any{tmp45}) - tmp47 := lang.Apply(tmp30, []any{tmp46}) - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{nil}) - tmp52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp53 := tmp52.FindInternedVar(lang.NewSymbol("list")) - if tmp53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp53))) - } - tmp54 := tmp53.Get() - tmp55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp56 := tmp55.FindInternedVar(lang.NewSymbol("seq")) - if tmp56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp56))) - } - tmp57 := tmp56.Get() - tmp58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp59 := tmp58.FindInternedVar(lang.NewSymbol("concat")) - if tmp59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp59))) - } - tmp60 := tmp59.Get() - tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp62 := tmp61.FindInternedVar(lang.NewSymbol("list")) - if tmp62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) - } - tmp63 := tmp62.Get() - tmp64 := lang.Apply(tmp63, []any{lang.NewSymbol("glojure.core/->>")}) - tmp65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp66 := tmp65.FindInternedVar(lang.NewSymbol("list")) - if tmp66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp66))) - } - tmp67 := tmp66.Get() - tmp68 := lang.Apply(tmp67, []any{v12}) - tmp69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp70 := tmp69.FindInternedVar(lang.NewSymbol("list")) - if tmp70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp70))) - } - tmp71 := tmp70.Get() - tmp72 := lang.Apply(tmp71, []any{v17}) - tmp73 := lang.Apply(tmp60, []any{tmp64, tmp68, tmp72}) - tmp74 := lang.Apply(tmp57, []any{tmp73}) - tmp75 := lang.Apply(tmp54, []any{tmp74}) - tmp76 := lang.Apply(tmp23, []any{tmp27, tmp47, tmp51, tmp75}) - tmp77 := lang.Apply(tmp20, []any{tmp76}) - return tmp77 - }) - tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7630), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7630), lang.NewKeyword("end-column"), int(65)) - tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp19 := lang.Apply(tmp15, []any{tmp18, v6}) - var v20 any = tmp19 - _ = v20 - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/let")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("apply")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("vector")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("seq")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp44 := tmp43.FindInternedVar(lang.NewSymbol("concat")) - if tmp44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) - } - tmp45 := tmp44.Get() - tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp47 := tmp46.FindInternedVar(lang.NewSymbol("list")) - if tmp47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) - } - tmp48 := tmp47.Get() - tmp49 := lang.Apply(tmp48, []any{v12}) - tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp51 := tmp50.FindInternedVar(lang.NewSymbol("list")) - if tmp51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) - } - tmp52 := tmp51.Get() - tmp53 := lang.Apply(tmp52, []any{v5}) - tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp55 := tmp54.FindInternedVar(lang.NewSymbol("interleave")) - if tmp55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) - } - tmp56 := tmp55.Get() - tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp58 := tmp57.FindInternedVar(lang.NewSymbol("repeat")) - if tmp58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) - } - tmp59 := tmp58.Get() - tmp60 := lang.Apply(tmp59, []any{v12}) - tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp62 := tmp61.FindInternedVar(lang.NewSymbol("butlast")) - if tmp62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) - } - tmp63 := tmp62.Get() - tmp64 := lang.Apply(tmp63, []any{v20}) - tmp65 := lang.Apply(tmp56, []any{tmp60, tmp64}) - tmp66 := lang.Apply(tmp45, []any{tmp49, tmp53, tmp65}) - tmp67 := lang.Apply(tmp42, []any{tmp66}) - tmp68 := lang.Apply(tmp36, []any{tmp39, tmp67}) - tmp69 := lang.Apply(tmp33, []any{tmp68}) - tmp70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp71 := tmp70.FindInternedVar(lang.NewSymbol("list")) - if tmp71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp71))) - } - tmp72 := tmp71.Get() - var tmp73 any - tmp74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp75 := tmp74.FindInternedVar(lang.NewSymbol("empty?")) - if tmp75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp75))) - } - tmp76 := tmp75.Get() - tmp77 := lang.Apply(tmp76, []any{v20}) - if lang.IsTruthy(tmp77) { - tmp73 = v12 - } else { - tmp78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp79 := tmp78.FindInternedVar(lang.NewSymbol("last")) - if tmp79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp79))) - } - tmp80 := tmp79.Get() - tmp81 := lang.Apply(tmp80, []any{v20}) - tmp73 = tmp81 - } - tmp82 := lang.Apply(tmp72, []any{tmp73}) - tmp83 := lang.Apply(tmp26, []any{tmp30, tmp69, tmp82}) - tmp84 := lang.Apply(tmp23, []any{tmp83}) - tmp7 = tmp84 - } // end let - return tmp7 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // some-fn - { - tmp0 := lang.NewSymbol("some-fn").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("p")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2"), lang.NewSymbol("p3")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2"), lang.NewSymbol("p3"), lang.NewSymbol("&"), lang.NewSymbol("ps"))), lang.NewKeyword("doc"), "Takes a set of predicates and returns a function f that returns the first logical true value\n returned by one of its composing predicates against any of its arguments, else it returns\n logical false. Note that f is short-circuiting in that it will stop execution on the first\n argument that triggers a logical true result against the original predicates.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7462), lang.NewKeyword("end-line"), int(7462))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - var tmp4 lang.FnFunc - { // function sp1 - var v5 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - return nil - case 1: - v6 := args[0] - _ = v6 - tmp7 := lang.Apply(v3, []any{v6}) - return tmp7 - case 2: - v6 := args[0] - _ = v6 - v7 := args[1] - _ = v7 - var tmp8 any - { // let - // let binding "or__0__auto__" - tmp9 := lang.Apply(v3, []any{v6}) - var v10 any = tmp9 - _ = v10 - var tmp11 any - if lang.IsTruthy(v10) { - tmp11 = v10 - } else { - tmp12 := lang.Apply(v3, []any{v7}) - tmp11 = tmp12 - } - tmp8 = tmp11 - } // end let - return tmp8 - case 3: - v6 := args[0] - _ = v6 - v7 := args[1] - _ = v7 - v8 := args[2] - _ = v8 - var tmp9 any - { // let - // let binding "or__0__auto__" - tmp10 := lang.Apply(v3, []any{v6}) - var v11 any = tmp10 - _ = v11 - var tmp12 any - if lang.IsTruthy(v11) { - tmp12 = v11 - } else { - var tmp13 any - { // let - // let binding "or__0__auto__" - tmp14 := lang.Apply(v3, []any{v7}) - var v15 any = tmp14 - _ = v15 - var tmp16 any - if lang.IsTruthy(v15) { - tmp16 = v15 - } else { - tmp17 := lang.Apply(v3, []any{v8}) - tmp16 = tmp17 - } - tmp13 = tmp16 - } // end let - tmp12 = tmp13 - } - tmp9 = tmp12 - } // end let - return tmp9 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v6 := args[0] - _ = v6 - v7 := args[1] - _ = v7 - v8 := args[2] - _ = v8 - var v9 any = lang.NewList(args[3:]...) - _ = v9 - var tmp10 any - { // let - // let binding "or__0__auto__" - tmp11 := lang.Apply(v5, []any{v6, v7, v8}) - var v12 any = tmp11 - _ = v12 - var tmp13 any - if lang.IsTruthy(v12) { - tmp13 = v12 - } else { - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("some")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{v3, v9}) - tmp13 = tmp17 - } - tmp10 = tmp13 - } // end let - return tmp10 - } - }) - v5 = tmp4 - _ = v5 - } - tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7469), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7475), lang.NewKeyword("end-column"), int(43)) - tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp6 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 lang.FnFunc - { // function sp2 - var v6 lang.FnFunc - tmp5 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - return nil - case 1: - v7 := args[0] - _ = v7 - var tmp8 any - { // let - // let binding "or__0__auto__" - tmp9 := lang.Apply(v3, []any{v7}) - var v10 any = tmp9 - _ = v10 - var tmp11 any - if lang.IsTruthy(v10) { - tmp11 = v10 - } else { - tmp12 := lang.Apply(v4, []any{v7}) - tmp11 = tmp12 - } - tmp8 = tmp11 - } // end let - return tmp8 - case 2: - v7 := args[0] - _ = v7 - v8 := args[1] - _ = v8 - var tmp9 any - { // let - // let binding "or__0__auto__" - tmp10 := lang.Apply(v3, []any{v7}) - var v11 any = tmp10 - _ = v11 - var tmp12 any - if lang.IsTruthy(v11) { - tmp12 = v11 - } else { - var tmp13 any - { // let - // let binding "or__0__auto__" - tmp14 := lang.Apply(v3, []any{v8}) - var v15 any = tmp14 - _ = v15 - var tmp16 any - if lang.IsTruthy(v15) { - tmp16 = v15 - } else { - var tmp17 any - { // let - // let binding "or__0__auto__" - tmp18 := lang.Apply(v4, []any{v7}) - var v19 any = tmp18 - _ = v19 - var tmp20 any - if lang.IsTruthy(v19) { - tmp20 = v19 - } else { - tmp21 := lang.Apply(v4, []any{v8}) - tmp20 = tmp21 - } - tmp17 = tmp20 - } // end let - tmp16 = tmp17 - } - tmp13 = tmp16 - } // end let - tmp12 = tmp13 - } - tmp9 = tmp12 - } // end let - return tmp9 - case 3: - v7 := args[0] - _ = v7 - v8 := args[1] - _ = v8 - v9 := args[2] - _ = v9 - var tmp10 any - { // let - // let binding "or__0__auto__" - tmp11 := lang.Apply(v3, []any{v7}) - var v12 any = tmp11 - _ = v12 - var tmp13 any - if lang.IsTruthy(v12) { - tmp13 = v12 - } else { - var tmp14 any - { // let - // let binding "or__0__auto__" - tmp15 := lang.Apply(v3, []any{v8}) - var v16 any = tmp15 - _ = v16 - var tmp17 any - if lang.IsTruthy(v16) { - tmp17 = v16 - } else { - var tmp18 any - { // let - // let binding "or__0__auto__" - tmp19 := lang.Apply(v3, []any{v9}) - var v20 any = tmp19 - _ = v20 - var tmp21 any - if lang.IsTruthy(v20) { - tmp21 = v20 - } else { - var tmp22 any - { // let - // let binding "or__0__auto__" - tmp23 := lang.Apply(v4, []any{v7}) - var v24 any = tmp23 - _ = v24 - var tmp25 any - if lang.IsTruthy(v24) { - tmp25 = v24 - } else { - var tmp26 any - { // let - // let binding "or__0__auto__" - tmp27 := lang.Apply(v4, []any{v8}) - var v28 any = tmp27 - _ = v28 - var tmp29 any - if lang.IsTruthy(v28) { - tmp29 = v28 - } else { - tmp30 := lang.Apply(v4, []any{v9}) - tmp29 = tmp30 - } - tmp26 = tmp29 - } // end let - tmp25 = tmp26 - } - tmp22 = tmp25 - } // end let - tmp21 = tmp22 - } - tmp18 = tmp21 - } // end let - tmp17 = tmp18 - } - tmp14 = tmp17 - } // end let - tmp13 = tmp14 - } - tmp10 = tmp13 - } // end let - return tmp10 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v7 := args[0] - _ = v7 - v8 := args[1] - _ = v8 - v9 := args[2] - _ = v9 - var v10 any = lang.NewList(args[3:]...) - _ = v10 - var tmp11 any - { // let - // let binding "or__0__auto__" - tmp12 := lang.Apply(v6, []any{v7, v8, v9}) - var v13 any = tmp12 - _ = v13 - var tmp14 any - if lang.IsTruthy(v13) { - tmp14 = v13 - } else { - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("some")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - var tmp18 lang.FnFunc - tmp18 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v19 := args[0] - _ = v19 - var tmp20 any - { // let - // let binding "or__0__auto__" - tmp21 := lang.Apply(v3, []any{v19}) - var v22 any = tmp21 - _ = v22 - var tmp23 any - if lang.IsTruthy(v22) { - tmp23 = v22 - } else { - tmp24 := lang.Apply(v4, []any{v19}) - tmp23 = tmp24 - } - tmp20 = tmp23 - } // end let - return tmp20 - }) - tmp19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7483), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(7483), lang.NewKeyword("end-column"), int(52)) - tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp21 := lang.Apply(tmp17, []any{tmp20, v10}) - tmp14 = tmp21 - } - tmp11 = tmp14 - } // end let - return tmp11 - } - }) - v6 = tmp5 - _ = v6 - } - tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7477), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7483), lang.NewKeyword("end-column"), int(61)) - tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp7 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var tmp6 lang.FnFunc - { // function sp3 - var v7 lang.FnFunc - tmp6 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - return nil - case 1: - v8 := args[0] - _ = v8 - var tmp9 any - { // let - // let binding "or__0__auto__" - tmp10 := lang.Apply(v3, []any{v8}) - var v11 any = tmp10 - _ = v11 - var tmp12 any - if lang.IsTruthy(v11) { - tmp12 = v11 - } else { - var tmp13 any - { // let - // let binding "or__0__auto__" - tmp14 := lang.Apply(v4, []any{v8}) - var v15 any = tmp14 - _ = v15 - var tmp16 any - if lang.IsTruthy(v15) { - tmp16 = v15 - } else { - tmp17 := lang.Apply(v5, []any{v8}) - tmp16 = tmp17 - } - tmp13 = tmp16 - } // end let - tmp12 = tmp13 - } - tmp9 = tmp12 - } // end let - return tmp9 - case 2: - v8 := args[0] - _ = v8 - v9 := args[1] - _ = v9 - var tmp10 any - { // let - // let binding "or__0__auto__" - tmp11 := lang.Apply(v3, []any{v8}) - var v12 any = tmp11 - _ = v12 - var tmp13 any - if lang.IsTruthy(v12) { - tmp13 = v12 - } else { - var tmp14 any - { // let - // let binding "or__0__auto__" - tmp15 := lang.Apply(v3, []any{v9}) - var v16 any = tmp15 - _ = v16 - var tmp17 any - if lang.IsTruthy(v16) { - tmp17 = v16 - } else { - var tmp18 any - { // let - // let binding "or__0__auto__" - tmp19 := lang.Apply(v4, []any{v8}) - var v20 any = tmp19 - _ = v20 - var tmp21 any - if lang.IsTruthy(v20) { - tmp21 = v20 - } else { - var tmp22 any - { // let - // let binding "or__0__auto__" - tmp23 := lang.Apply(v4, []any{v9}) - var v24 any = tmp23 - _ = v24 - var tmp25 any - if lang.IsTruthy(v24) { - tmp25 = v24 - } else { - var tmp26 any - { // let - // let binding "or__0__auto__" - tmp27 := lang.Apply(v5, []any{v8}) - var v28 any = tmp27 - _ = v28 - var tmp29 any - if lang.IsTruthy(v28) { - tmp29 = v28 - } else { - tmp30 := lang.Apply(v5, []any{v9}) - tmp29 = tmp30 - } - tmp26 = tmp29 - } // end let - tmp25 = tmp26 - } - tmp22 = tmp25 - } // end let - tmp21 = tmp22 - } - tmp18 = tmp21 - } // end let - tmp17 = tmp18 - } - tmp14 = tmp17 - } // end let - tmp13 = tmp14 - } - tmp10 = tmp13 - } // end let - return tmp10 - case 3: - v8 := args[0] - _ = v8 - v9 := args[1] - _ = v9 - v10 := args[2] - _ = v10 - var tmp11 any - { // let - // let binding "or__0__auto__" - tmp12 := lang.Apply(v3, []any{v8}) - var v13 any = tmp12 - _ = v13 - var tmp14 any - if lang.IsTruthy(v13) { - tmp14 = v13 - } else { - var tmp15 any - { // let - // let binding "or__0__auto__" - tmp16 := lang.Apply(v3, []any{v9}) - var v17 any = tmp16 - _ = v17 - var tmp18 any - if lang.IsTruthy(v17) { - tmp18 = v17 - } else { - var tmp19 any - { // let - // let binding "or__0__auto__" - tmp20 := lang.Apply(v3, []any{v10}) - var v21 any = tmp20 - _ = v21 - var tmp22 any - if lang.IsTruthy(v21) { - tmp22 = v21 - } else { - var tmp23 any - { // let - // let binding "or__0__auto__" - tmp24 := lang.Apply(v4, []any{v8}) - var v25 any = tmp24 - _ = v25 - var tmp26 any - if lang.IsTruthy(v25) { - tmp26 = v25 - } else { - var tmp27 any - { // let - // let binding "or__0__auto__" - tmp28 := lang.Apply(v4, []any{v9}) - var v29 any = tmp28 - _ = v29 - var tmp30 any - if lang.IsTruthy(v29) { - tmp30 = v29 - } else { - var tmp31 any - { // let - // let binding "or__0__auto__" - tmp32 := lang.Apply(v4, []any{v10}) - var v33 any = tmp32 - _ = v33 - var tmp34 any - if lang.IsTruthy(v33) { - tmp34 = v33 - } else { - var tmp35 any - { // let - // let binding "or__0__auto__" - tmp36 := lang.Apply(v5, []any{v8}) - var v37 any = tmp36 - _ = v37 - var tmp38 any - if lang.IsTruthy(v37) { - tmp38 = v37 - } else { - var tmp39 any - { // let - // let binding "or__0__auto__" - tmp40 := lang.Apply(v5, []any{v9}) - var v41 any = tmp40 - _ = v41 - var tmp42 any - if lang.IsTruthy(v41) { - tmp42 = v41 - } else { - tmp43 := lang.Apply(v5, []any{v10}) - tmp42 = tmp43 - } - tmp39 = tmp42 - } // end let - tmp38 = tmp39 - } - tmp35 = tmp38 - } // end let - tmp34 = tmp35 - } - tmp31 = tmp34 - } // end let - tmp30 = tmp31 - } - tmp27 = tmp30 - } // end let - tmp26 = tmp27 - } - tmp23 = tmp26 - } // end let - tmp22 = tmp23 - } - tmp19 = tmp22 - } // end let - tmp18 = tmp19 - } - tmp15 = tmp18 - } // end let - tmp14 = tmp15 - } - tmp11 = tmp14 - } // end let - return tmp11 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v8 := args[0] - _ = v8 - v9 := args[1] - _ = v9 - v10 := args[2] - _ = v10 - var v11 any = lang.NewList(args[3:]...) - _ = v11 - var tmp12 any - { // let - // let binding "or__0__auto__" - tmp13 := lang.Apply(v7, []any{v8, v9, v10}) - var v14 any = tmp13 - _ = v14 - var tmp15 any - if lang.IsTruthy(v14) { - tmp15 = v14 - } else { - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("some")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - var tmp19 lang.FnFunc - tmp19 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v20 := args[0] - _ = v20 - var tmp21 any - { // let - // let binding "or__0__auto__" - tmp22 := lang.Apply(v3, []any{v20}) - var v23 any = tmp22 - _ = v23 - var tmp24 any - if lang.IsTruthy(v23) { - tmp24 = v23 - } else { - var tmp25 any - { // let - // let binding "or__0__auto__" - tmp26 := lang.Apply(v4, []any{v20}) - var v27 any = tmp26 - _ = v27 - var tmp28 any - if lang.IsTruthy(v27) { - tmp28 = v27 - } else { - tmp29 := lang.Apply(v5, []any{v20}) - tmp28 = tmp29 - } - tmp25 = tmp28 - } // end let - tmp24 = tmp25 - } - tmp21 = tmp24 - } // end let - return tmp21 - }) - tmp20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7491), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(7491), lang.NewKeyword("end-column"), int(59)) - tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp22 := lang.Apply(tmp18, []any{tmp21, v11}) - tmp15 = tmp22 - } - tmp12 = tmp15 - } // end let - return tmp12 - } - }) - v7 = tmp6 - _ = v7 - } - tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7485), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7491), lang.NewKeyword("end-column"), int(68)) - tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp8 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any - { // let - // let binding "ps" - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("list*")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v3, v4, v5, v6}) - var v12 any = tmp11 - _ = v12 - var tmp13 lang.FnFunc - { // function spn - var v14 lang.FnFunc - tmp13 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - return nil - case 1: - v15 := args[0] - _ = v15 - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("some")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - var tmp19 lang.FnFunc - tmp19 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v20 := args[0] - _ = v20 - tmp21 := lang.Apply(v20, []any{v15}) - return tmp21 - }) - tmp20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7496), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(7496), lang.NewKeyword("end-column"), int(26)) - tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp22 := lang.Apply(tmp18, []any{tmp21, v12}) - return tmp22 - case 2: - v15 := args[0] - _ = v15 - v16 := args[1] - _ = v16 - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("some")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - var tmp20 lang.FnFunc - tmp20 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v21 := args[0] - _ = v21 - var tmp22 any - { // let - // let binding "or__0__auto__" - tmp23 := lang.Apply(v21, []any{v15}) - var v24 any = tmp23 - _ = v24 - var tmp25 any - if lang.IsTruthy(v24) { - tmp25 = v24 - } else { - tmp26 := lang.Apply(v21, []any{v16}) - tmp25 = tmp26 - } - tmp22 = tmp25 - } // end let - return tmp22 - }) - tmp21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7497), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(7497), lang.NewKeyword("end-column"), int(39)) - tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp23 := lang.Apply(tmp19, []any{tmp22, v12}) - return tmp23 - case 3: - v15 := args[0] - _ = v15 - v16 := args[1] - _ = v16 - v17 := args[2] - _ = v17 - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("some")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - var tmp21 lang.FnFunc - tmp21 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v22 := args[0] - _ = v22 - var tmp23 any - { // let - // let binding "or__0__auto__" - tmp24 := lang.Apply(v22, []any{v15}) - var v25 any = tmp24 - _ = v25 - var tmp26 any - if lang.IsTruthy(v25) { - tmp26 = v25 - } else { - var tmp27 any - { // let - // let binding "or__0__auto__" - tmp28 := lang.Apply(v22, []any{v16}) - var v29 any = tmp28 - _ = v29 - var tmp30 any - if lang.IsTruthy(v29) { - tmp30 = v29 - } else { - tmp31 := lang.Apply(v22, []any{v17}) - tmp30 = tmp31 - } - tmp27 = tmp30 - } // end let - tmp26 = tmp27 - } - tmp23 = tmp26 - } // end let - return tmp23 - }) - tmp22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7498), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7498), lang.NewKeyword("end-column"), int(47)) - tmp23, err := lang.WithMeta(tmp21, tmp22.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp24 := lang.Apply(tmp20, []any{tmp23, v12}) - return tmp24 - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v15 := args[0] - _ = v15 - v16 := args[1] - _ = v16 - v17 := args[2] - _ = v17 - var v18 any = lang.NewList(args[3:]...) - _ = v18 - var tmp19 any - { // let - // let binding "or__0__auto__" - tmp20 := lang.Apply(v14, []any{v15, v16, v17}) - var v21 any = tmp20 - _ = v21 - var tmp22 any - if lang.IsTruthy(v21) { - tmp22 = v21 - } else { - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("some")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - var tmp26 lang.FnFunc - tmp26 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v27 := args[0] - _ = v27 - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("some")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.Apply(tmp30, []any{v27, v18}) - return tmp31 - }) - tmp27 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7500), lang.NewKeyword("column"), int(36), lang.NewKeyword("end-line"), int(7500), lang.NewKeyword("end-column"), int(49)) - tmp28, err := lang.WithMeta(tmp26, tmp27.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp29 := lang.Apply(tmp25, []any{tmp28, v12}) - tmp22 = tmp29 - } - tmp19 = tmp22 - } // end let - return tmp19 - } - }) - v14 = tmp13 - _ = v14 - } - tmp14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7494), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7500), lang.NewKeyword("end-column"), int(56)) - tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp7 = tmp15 - } // end let - return tmp7 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // some? - { - tmp1 := reflect.TypeOf(false) - tmp0 := lang.NewSymbol("some?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is not nil, false otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(530), lang.NewKeyword("end-line"), int(530))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("not")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("nil?")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v4}) - tmp12 := lang.Apply(tmp7, []any{tmp11}) - return tmp12 - }) - tmp4 := reflect.TypeOf(false) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // sort - { - tmp0 := lang.NewSymbol("sort").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("comp"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a sorted sequence of the items in coll. If no comparator is\n supplied, uses compare. comparator must implement\n java.util.Comparator. Guaranteed to be stable: equal elements will\n not be reordered. If coll is a Java array, it will be modified. To\n avoid this, sort a copy of the array.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3085), lang.NewKeyword("end-line"), int(3085))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("sort")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("compare")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp6, []any{tmp9, v3}) - return tmp10 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("seq")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(tmp8, []any{v4}) - if lang.IsTruthy(tmp9) { - var tmp10 any - { // let - // let binding "a" - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("to-array")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{v4}) - var v15 any = tmp14 - _ = v15 - tmp16 := lang.Apply(lang.SortSlice, []any{v15, v3}) - _ = tmp16 - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("with-meta")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("seq")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.Apply(tmp22, []any{v15}) - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("meta")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.Apply(tmp26, []any{v4}) - tmp28 := lang.Apply(tmp19, []any{tmp23, tmp27}) - tmp10 = tmp28 - } // end let - tmp5 = tmp10 - } else { - tmp5 = lang.NewList() - } - return tmp5 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // sort-by - { - tmp0 := lang.NewSymbol("sort-by").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("keyfn"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("keyfn"), lang.NewSymbol("comp"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a sorted sequence of the items in coll, where the sort\n order is determined by comparing (keyfn item). If no comparator is\n supplied, uses compare. comparator must implement\n java.util.Comparator. Guaranteed to be stable: equal elements will\n not be reordered. If coll is a Java array, it will be modified. To\n avoid this, sort a copy of the array.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3102), lang.NewKeyword("end-line"), int(3102))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("sort-by")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("compare")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp7, []any{v3, tmp10, v4}) - return tmp11 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("sort")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - var tmp9 lang.FnFunc - tmp9 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v10 := args[0] - _ = v10 - v11 := args[1] - _ = v11 - tmp12 := lang.Apply(v3, []any{v10}) - tmp13 := lang.Apply(v3, []any{v11}) - tmp14 := lang.Apply(v4, []any{tmp12, tmp13}) - return tmp14 - }) - tmp10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3114), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(3114), lang.NewKeyword("end-column"), int(46)) - tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp12 := lang.Apply(tmp8, []any{tmp11, v5}) - return tmp12 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // sorted-map - { - tmp0 := lang.NewSymbol("sorted-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keyvals"))), lang.NewKeyword("doc"), "keyval => key val\n Returns a new sorted map with supplied mappings. If any keys are\n equal, they are handled as if by repeated uses of assoc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(397), lang.NewKeyword("end-line"), int(397))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var v3 any = lang.NewList(args[0:]...) - _ = v3 - tmp4 := lang.Apply(lang.CreatePersistentTreeMap, []any{v3}) - return tmp4 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // sorted-map-by - { - tmp0 := lang.NewSymbol("sorted-map-by").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("comparator"), lang.NewSymbol("&"), lang.NewSymbol("keyvals"))), lang.NewKeyword("doc"), "keyval => key val\n Returns a new sorted map with supplied mappings, using the supplied\n comparator. If any keys are equal, they are handled as if by\n repeated uses of assoc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(406), lang.NewKeyword("end-line"), int(406))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var v4 any = lang.NewList(args[1:]...) - _ = v4 - tmp5 := lang.Apply(nil, []any{v3, v4}) - return tmp5 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // sorted-set - { - tmp0 := lang.NewSymbol("sorted-set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keys"))), lang.NewKeyword("doc"), "Returns a new sorted set with supplied keys. Any equal keys are\n handled as if by repeated uses of conj.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(416), lang.NewKeyword("end-line"), int(416))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var v3 any = lang.NewList(args[0:]...) - _ = v3 - tmp4 := lang.Apply(lang.CreatePersistentTreeSet, []any{v3}) - return tmp4 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // sorted-set-by - { - tmp0 := lang.NewSymbol("sorted-set-by").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("comparator"), lang.NewSymbol("&"), lang.NewSymbol("keys"))), lang.NewKeyword("doc"), "Returns a new sorted set with supplied keys, using the supplied\n comparator. Any equal keys are handled as if by repeated uses of\n conj.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(424), lang.NewKeyword("end-line"), int(424))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var v4 any = lang.NewList(args[1:]...) - _ = v4 - tmp5 := lang.Apply(lang.CreatePersistentTreeSetWithComparator, []any{v3, v4}) - return tmp5 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // sorted? - { - tmp0 := lang.NewSymbol("sorted?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements Sorted", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6235), lang.NewKeyword("end-line"), int(6235))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.Apply(tmp6, []any{nil, v3}) - return tmp7 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // special-symbol? - { - tmp0 := lang.NewSymbol("special-symbol?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns true if s names a special form", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4992), lang.NewKeyword("end-line"), int(4992))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("contains?")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7, ok := lang.FieldOrMethod(runtime4.Compiler, "specials") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", runtime4.Compiler, "specials"))) - } - var tmp8 any - switch reflect.TypeOf(tmp7).Kind() { - case reflect.Func: - tmp8 = lang.Apply(tmp7, nil) - default: - tmp8 = tmp7 - } - tmp9 := lang.Apply(tmp6, []any{tmp8, v3}) - return tmp9 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // spit - { - tmp0 := lang.NewSymbol("spit").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("content"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Opposite of slurp. Opens f with writer, writes content, then\n closes f. Options passed to glojure.java.io/writer.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6994), lang.NewKeyword("end-line"), int(6994))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - var tmp6 any - { // let - // let binding "w" - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("apply")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp9, []any{nil, v3, v5}) - var v11 any = tmp10 - _ = v11 - var tmp12 any - func() { - defer func() { - tmp13, ok := lang.FieldOrMethod(v11, "close") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v11, "close"))) - } - var tmp14 any - switch reflect.TypeOf(tmp13).Kind() { - case reflect.Func: - tmp14 = lang.Apply(tmp13, nil) - default: - tmp14 = tmp13 - } - _ = tmp14 - }() - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("str")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{v4}) - tmp19 := lang.Apply(lang.WriteWriter, []any{v11, tmp18}) - tmp12 = tmp19 - }() - tmp6 = tmp12 - } // end let - return tmp6 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // split-at - { - tmp0 := lang.NewSymbol("split-at").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a vector of [(take n coll) (drop n coll)]", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2983), lang.NewKeyword("end-line"), int(2983))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("take")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v3, v4}) - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("drop")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.Apply(tmp11, []any{v3, v4}) - tmp13 := lang.NewVector(tmp8, tmp12) - tmp14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2988), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2988), lang.NewKeyword("end-column"), int(33)) - tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp15 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // split-with - { - tmp0 := lang.NewSymbol("split-with").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a vector of [(take-while pred coll) (drop-while pred coll)]", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2990), lang.NewKeyword("end-line"), int(2990))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("take-while")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v3, v4}) - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("drop-while")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.Apply(tmp11, []any{v3, v4}) - tmp13 := lang.NewVector(tmp8, tmp12) - tmp14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2995), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2995), lang.NewKeyword("end-column"), int(51)) - tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp15 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // splitv-at - { - tmp0 := lang.NewSymbol("splitv-at").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a vector of [(into [] (take n) coll) (drop n coll)]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7256), lang.NewKeyword("end-line"), int(7256))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("into")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.NewVector() - tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7260), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(7260), lang.NewKeyword("end-column"), int(11)) - tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("take")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{v3}) - tmp15 := lang.Apply(tmp7, []any{tmp10, tmp14, v4}) - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("drop")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{v3, v4}) - tmp20 := lang.NewVector(tmp15, tmp19) - tmp21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7260), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(7260), lang.NewKeyword("end-column"), int(41)) - tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp22 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // spread - { - tmp0 := lang.NewSymbol("spread").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("arglist"))), lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(632), lang.NewKeyword("end-line"), int(632), lang.NewKeyword("private"), true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("nil?")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v3}) - if lang.IsTruthy(tmp8) { - } else { - var tmp9 any - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("nil?")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("next")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{v3}) - tmp17 := lang.Apply(tmp12, []any{tmp16}) - if lang.IsTruthy(tmp17) { - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("seq")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("first")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.Apply(tmp23, []any{v3}) - tmp25 := lang.Apply(tmp20, []any{tmp24}) - tmp9 = tmp25 - } else { - var tmp26 any - if lang.IsTruthy(lang.NewKeyword("else")) { - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("cons")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("first")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.Apply(tmp32, []any{v3}) - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("spread")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("next")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.Apply(tmp39, []any{v3}) - tmp41 := lang.Apply(tmp36, []any{tmp40}) - tmp42 := lang.Apply(tmp29, []any{tmp33, tmp41}) - tmp26 = tmp42 - } else { - } - tmp9 = tmp26 - } - tmp4 = tmp9 - } - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // str - { - tmp1 := reflect.TypeOf("") - tmp0 := lang.NewSymbol("str").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("ys"))), lang.NewKeyword("doc"), "With no args, returns the empty string. With one arg x, returns\n x.toString(). (str nil) returns the empty string. With more than\n one arg, returns the concatenation of the str values of the args.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(543), lang.NewKeyword("end-line"), int(543))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - return "" - case 1: - v4 := args[0] - _ = v4 - var tmp5 any - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("nil?")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(tmp8, []any{v4}) - if lang.IsTruthy(tmp9) { - tmp5 = "" - } else { - tmp10 := lang.Apply(lang.ToString, []any{v4}) - tmp5 = tmp10 - } - return tmp5 - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - var v5 any = lang.NewList(args[1:]...) - _ = v5 - var tmp6 lang.FnFunc - tmp6 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v7 := args[0] - _ = v7 - v8 := args[1] - _ = v8 - recur_loop_74: - var tmp9 any - if lang.IsTruthy(v8) { - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("str")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("first")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{v8}) - tmp18 := lang.Apply(tmp13, []any{tmp17}) - tmp19, _ := lang.FieldOrMethod(v7, "WriteString") - if reflect.TypeOf(tmp19).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("WriteString is not a function"))) - } - tmp20 := lang.Apply(tmp19, []any{tmp18}) - _ = tmp20 - var tmp10 any = v7 - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("next")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.Apply(tmp24, []any{v8}) - var tmp21 any = tmp25 - v7 = tmp10 - v8 = tmp21 - goto recur_loop_74 - } else { - tmp26, ok := lang.FieldOrMethod(v7, "String") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "String"))) - } - var tmp27 any - switch reflect.TypeOf(tmp26).Kind() { - case reflect.Func: - tmp27 = lang.Apply(tmp26, nil) - default: - tmp27 = tmp26 - } - tmp9 = tmp27 - } - return tmp9 - }) - tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(554), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(554), lang.NewKeyword("end-column"), int(127)) - tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("cons")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.Apply(tmp11, []any{v4, v5}) - tmp13 := lang.Apply(tmp8, []any{"unimplemented: new with non-constant class type", tmp12}) - return tmp13 - } - }) - tmp4 := reflect.TypeOf("") - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // stream-into! - { - tmp0 := lang.NewSymbol("stream-into!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("stream")), lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("xform"), lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Returns a new coll consisting of coll with all of the items of the\n stream conjoined. This is a terminal operation on the stream.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6810), lang.NewKeyword("end-line"), int(6810))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("instance?")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := reflect.TypeOf((*lang.IEditableCollection)(nil)).Elem() - tmp10 := lang.Apply(tmp8, []any{tmp9, v3}) - if lang.IsTruthy(tmp10) { - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("with-meta")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("persistent!")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("stream-reduce!")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("conj!")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("transient")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.Apply(tmp25, []any{v3}) - tmp27 := lang.Apply(tmp19, []any{tmp22, tmp26, v4}) - tmp28 := lang.Apply(tmp16, []any{tmp27}) - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("meta")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.Apply(tmp31, []any{v3}) - tmp33 := lang.Apply(tmp13, []any{tmp28, tmp32}) - tmp5 = tmp33 - } else { - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("stream-reduce!")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("conj")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.Apply(tmp36, []any{tmp39, v3, v4}) - tmp5 = tmp40 - } - return tmp5 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var tmp6 any - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("instance?")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := reflect.TypeOf((*lang.IEditableCollection)(nil)).Elem() - tmp11 := lang.Apply(tmp9, []any{tmp10, v3}) - if lang.IsTruthy(tmp11) { - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("with-meta")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("persistent!")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("stream-transduce!")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("conj!")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("transient")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.Apply(tmp26, []any{v3}) - tmp28 := lang.Apply(tmp20, []any{v4, tmp23, tmp27, v5}) - tmp29 := lang.Apply(tmp17, []any{tmp28}) - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("meta")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.Apply(tmp32, []any{v3}) - tmp34 := lang.Apply(tmp14, []any{tmp29, tmp33}) - tmp6 = tmp34 - } else { - tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp36 := tmp35.FindInternedVar(lang.NewSymbol("stream-transduce!")) - if tmp36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) - } - tmp37 := tmp36.Get() - tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp39 := tmp38.FindInternedVar(lang.NewSymbol("conj")) - if tmp39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) - } - tmp40 := tmp39.Get() - tmp41 := lang.Apply(tmp37, []any{v4, tmp40, v3, v5}) - tmp6 = tmp41 - } - return tmp6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // stream-reduce! - { - tmp0 := lang.NewSymbol("stream-reduce!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("s")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Works like reduce but takes a java.util.stream.BaseStream as its source.\n Honors 'reduced', is a terminal operation on the stream", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6784), lang.NewKeyword("end-line"), int(6784))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5, ok := lang.FieldOrMethod(v4, "iterator") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "iterator"))) - } - var tmp6 any - switch reflect.TypeOf(tmp5).Kind() { - case reflect.Func: - tmp6 = lang.Apply(tmp5, nil) - default: - tmp6 = tmp5 - } - tmp7 := lang.Apply(nil, []any{tmp6, v3}) - return tmp7 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6, ok := lang.FieldOrMethod(v5, "iterator") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "iterator"))) - } - var tmp7 any - switch reflect.TypeOf(tmp6).Kind() { - case reflect.Func: - tmp7 = lang.Apply(tmp6, nil) - default: - tmp7 = tmp6 - } - tmp8 := lang.Apply(nil, []any{tmp7, v3, v4}) - return tmp8 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // stream-seq! - { - tmp0 := lang.NewSymbol("stream-seq!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Takes a java.util.stream.BaseStream instance s and returns a seq of its\n contents. This is a terminal operation on the stream.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6793), lang.NewKeyword("end-line"), int(6793))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("iterator-seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7, ok := lang.FieldOrMethod(v3, "iterator") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "iterator"))) - } - var tmp8 any - switch reflect.TypeOf(tmp7).Kind() { - case reflect.Func: - tmp8 = lang.Apply(tmp7, nil) - default: - tmp8 = tmp7 - } - tmp9 := lang.Apply(tmp6, []any{tmp8}) - return tmp9 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // stream-transduce! - { - tmp0 := lang.NewSymbol("stream-transduce!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("f"), lang.NewSymbol("stream")), lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Works like transduce but takes a java.util.stream.BaseStream as its source.\n This is a terminal operation on the stream.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6800), lang.NewKeyword("end-line"), int(6800))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("stream-transduce!")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(v4, nil) - tmp10 := lang.Apply(tmp8, []any{v3, v4, tmp9, v5}) - return tmp10 - case 4: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - var tmp7 any - { // let - // let binding "f" - tmp8 := lang.Apply(v3, []any{v4}) - var v9 any = tmp8 - _ = v9 - // let binding "ret" - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("stream-reduce!")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{v9, v5, v6}) - var v14 any = tmp13 - _ = v14 - tmp15 := lang.Apply(v9, []any{v14}) - tmp7 = tmp15 - } // end let - return tmp7 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // string? - { - tmp0 := lang.NewSymbol("string?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a String", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(160), lang.NewKeyword("end-line"), int(164))).(*lang.Symbol) - var tmp2 lang.FnFunc - { // function string? - var v3 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("instance?")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{lang.Builtins["string"], v4}) - return tmp8 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(164), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(164), lang.NewKeyword("end-column"), int(58))).(lang.FnFunc) - v3 = tmp2 - _ = v3 - } - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // strip-ns - { - tmp0 := lang.NewSymbol("strip-ns").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(255), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(255), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("named"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("symbol?")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v3}) - if lang.IsTruthy(tmp8) { - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("symbol")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("name")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.Apply(tmp14, []any{v3}) - tmp16 := lang.Apply(tmp11, []any{nil, tmp15}) - tmp4 = tmp16 - } else { - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("keyword")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("name")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.Apply(tmp22, []any{v3}) - tmp24 := lang.Apply(tmp19, []any{nil, tmp23}) - tmp4 = tmp24 - } - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // struct - { - tmp0 := lang.NewSymbol("struct").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("&"), lang.NewSymbol("vals"))), lang.NewKeyword("doc"), "Returns a new structmap instance with the keys of the\n structure-basis. vals must be supplied for basis keys in order -\n where values are not supplied they will default to nil.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4061), lang.NewKeyword("end-line"), int(4061))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var v4 any = lang.NewList(args[1:]...) - _ = v4 - tmp5 := lang.Apply(lang.ConstructPersistentStructMap, []any{v3, v4}) - return tmp5 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // struct-map - { - tmp0 := lang.NewSymbol("struct-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("&"), lang.NewSymbol("inits"))), lang.NewKeyword("doc"), "Returns a new structmap instance with the keys of the\n structure-basis. keyvals may contain all, some or none of the basis\n keys - where values are not supplied they will default to nil.\n keyvals can also contain keys not in the basis.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4051), lang.NewKeyword("end-line"), int(4051))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var v4 any = lang.NewList(args[1:]...) - _ = v4 - tmp5 := lang.Apply(lang.CreatePersistentStructMap, []any{v3, v4}) - return tmp5 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // subs - { - tmp0 := lang.NewSymbol("subs").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("start")), lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("start"), lang.NewSymbol("end"))), lang.NewKeyword("doc"), "Returns the substring of s beginning at start inclusive, and ending\n at end (defaults to length of string), exclusive.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5005), lang.NewKeyword("end-line"), int(5005))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.Apply(lang.Builtins["slice"], []any{v3, v4}) - return tmp5 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6 := lang.Apply(lang.Builtins["slice"], []any{v3, v4, v5}) - return tmp6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // subseq - { - tmp0 := lang.NewSymbol("subseq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sc"), lang.NewSymbol("test"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("sc"), lang.NewSymbol("start-test"), lang.NewSymbol("start-key"), lang.NewSymbol("end-test"), lang.NewSymbol("end-key"))), lang.NewKeyword("doc"), "sc must be a sorted collection, test(s) one of <, <=, > or\n >=. Returns a seq of those entries with keys ek for\n which (test (.. sc comparator (compare ek key)) 0) is true", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5133), lang.NewKeyword("end-line"), int(5133))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var tmp6 any - { // let - // let binding "include" - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("mk-bound-fn")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp9, []any{v3, v4, v5}) - var v11 any = tmp10 - _ = v11 - var tmp12 any - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol(">")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol(">=")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{tmp15, tmp18})) - tmp20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5141), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5141), lang.NewKeyword("end-column"), int(17)) - tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp22 := lang.Apply(tmp21, []any{v4}) - if lang.IsTruthy(tmp22) { - var tmp23 any - { // let - // let binding "temp__0__auto__" - tmp24, _ := lang.FieldOrMethod(v3, "seqFrom") - if reflect.TypeOf(tmp24).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("seqFrom is not a function"))) - } - tmp25 := lang.Apply(tmp24, []any{v5, true}) - var v26 any = tmp25 - _ = v26 - var tmp27 any - if lang.IsTruthy(v26) { - var tmp28 any - { // let - // let binding "vec__68" - var v29 any = v26 - _ = v29 - // let binding "e" - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("nth")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.Apply(tmp32, []any{v29, int64(0), nil}) - var v34 any = tmp33 - _ = v34 - // let binding "s" - var v35 any = v29 - _ = v35 - var tmp36 any - tmp37 := lang.Apply(v11, []any{v34}) - if lang.IsTruthy(tmp37) { - tmp36 = v35 - } else { - tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp39 := tmp38.FindInternedVar(lang.NewSymbol("next")) - if tmp39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) - } - tmp40 := tmp39.Get() - tmp41 := lang.Apply(tmp40, []any{v35}) - tmp36 = tmp41 - } - tmp28 = tmp36 - } // end let - tmp27 = tmp28 - } else { - } - tmp23 = tmp27 - } // end let - tmp12 = tmp23 - } else { - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("take-while")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27, _ := lang.FieldOrMethod(v3, "seq") - if reflect.TypeOf(tmp27).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("seq is not a function"))) - } - tmp28 := lang.Apply(tmp27, []any{true}) - tmp29 := lang.Apply(tmp26, []any{v11, tmp28}) - tmp12 = tmp29 - } - tmp6 = tmp12 - } // end let - return tmp6 - case 5: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - v7 := args[4] - _ = v7 - var tmp8 any - { // let - // let binding "temp__0__auto__" - tmp9, _ := lang.FieldOrMethod(v3, "seqFrom") - if reflect.TypeOf(tmp9).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("seqFrom is not a function"))) - } - tmp10 := lang.Apply(tmp9, []any{v5, true}) - var v11 any = tmp10 - _ = v11 - var tmp12 any - if lang.IsTruthy(v11) { - var tmp13 any - { // let - // let binding "vec__71" - var v14 any = v11 - _ = v14 - // let binding "e" - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("nth")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{v14, int64(0), nil}) - var v19 any = tmp18 - _ = v19 - // let binding "s" - var v20 any = v14 - _ = v20 - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("take-while")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("mk-bound-fn")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.Apply(tmp26, []any{v3, v6, v7}) - var tmp28 any - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("mk-bound-fn")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.Apply(tmp31, []any{v3, v4, v5}) - tmp33 := lang.Apply(tmp32, []any{v19}) - if lang.IsTruthy(tmp33) { - tmp28 = v20 - } else { - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("next")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.Apply(tmp36, []any{v20}) - tmp28 = tmp37 - } - tmp38 := lang.Apply(tmp23, []any{tmp27, tmp28}) - tmp13 = tmp38 - } // end let - tmp12 = tmp13 - } else { - } - tmp8 = tmp12 - } // end let - return tmp8 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // subvec - { - tmp0 := lang.NewSymbol("subvec").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("v"), lang.NewSymbol("start")), lang.NewVector(lang.NewSymbol("v"), lang.NewSymbol("start"), lang.NewSymbol("end"))), lang.NewKeyword("doc"), "Returns a persistent vector of the items in vector from\n start (inclusive) to end (exclusive). If end is not supplied,\n defaults to (count vector). This operation is O(1) and very fast, as\n the resulting vector shares structure with the original and no\n trimming is done.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3819), lang.NewKeyword("end-line"), int(3819))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("subvec")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("count")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v3}) - tmp12 := lang.Apply(tmp7, []any{v3, v4, tmp11}) - return tmp12 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6, _ := lang.FieldOrMethod(runtime4.RT, "Subvec") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Subvec is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v3, v4, v5}) - return tmp7 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // supers - { - tmp0 := lang.NewSymbol("supers").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("class"))), lang.NewKeyword("doc"), "Returns the immediate and indirect superclasses and interfaces of c, if any", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5532), lang.NewKeyword("end-line"), int(5532))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "ret" - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("set")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("bases")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v3}) - tmp12 := lang.Apply(tmp7, []any{tmp11}) - var v13 any = tmp12 - _ = v13 - // let binding "cs" - var v14 any = v13 - _ = v14 - for { - var tmp15 any - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("seq")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{v14}) - if lang.IsTruthy(tmp19) { - var tmp20 any - { // let - // let binding "c" - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("first")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.Apply(tmp23, []any{v14}) - var v25 any = tmp24 - _ = v25 - // let binding "bs" - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("bases")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.Apply(tmp28, []any{v25}) - var v30 any = tmp29 - _ = v30 - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("into1")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.Apply(tmp34, []any{v13, v30}) - var tmp31 any = tmp35 - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("into1")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("disj")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.Apply(tmp42, []any{v14, v25}) - tmp44 := lang.Apply(tmp39, []any{tmp43, v30}) - var tmp36 any = tmp44 - v13 = tmp31 - v14 = tmp36 - continue - } // end let - tmp15 = tmp20 - } else { - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("not-empty")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.Apply(tmp23, []any{v13}) - tmp15 = tmp24 - } - tmp4 = tmp15 - break - } - } // end let - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // swap! - { - tmp0 := lang.NewSymbol("swap!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atom"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Atomically swaps the value of atom to be:\n (apply f current-value-of-atom args). Note that f may be called\n multiple times, and thus should be free of side effects. Returns\n the value that was swapped in.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2343), lang.NewKeyword("end-line"), int(2343))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - tmp6, _ := lang.FieldOrMethod(v3, "swap") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("swap is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // swap-vals! - { - tmp0 := lang.NewSymbol("swap-vals!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atom"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Atomically swaps the value of atom to be:\n (apply f current-value-of-atom args). Note that f may be called\n multiple times, and thus should be free of side effects.\n Returns [old new], the value of the atom before and after the swap.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2352), lang.NewKeyword("end-line"), int(2352))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - tmp6, _ := lang.FieldOrMethod(v3, "swapVals") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("swapVals is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // symbol - { - tmp1 := reflect.TypeOf((*lang.Symbol)(nil)) - tmp0 := lang.NewSymbol("symbol").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name"))), lang.NewKeyword("doc"), "Returns a Symbol with the given namespace and name. Arity-1 works\n on strings, keywords, and vars.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(584), lang.NewKeyword("end-line"), int(584))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v4 := args[0] - _ = v4 - var tmp5 any - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("symbol?")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(tmp8, []any{v4}) - if lang.IsTruthy(tmp9) { - tmp5 = v4 - } else { - var tmp10 any - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("instance?")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{lang.Builtins["string"], v4}) - if lang.IsTruthy(tmp14) { - tmp15 := lang.Apply(lang.NewSymbol, []any{v4}) - tmp10 = tmp15 - } else { - var tmp16 any - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("instance?")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := reflect.TypeOf((*lang.Var)(nil)) - tmp21 := lang.Apply(tmp19, []any{tmp20, v4}) - if lang.IsTruthy(tmp21) { - tmp22, ok := lang.FieldOrMethod(v4, "toSymbol") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "toSymbol"))) - } - var tmp23 any - switch reflect.TypeOf(tmp22).Kind() { - case reflect.Func: - tmp23 = lang.Apply(tmp22, nil) - default: - tmp23 = tmp22 - } - tmp16 = tmp23 - } else { - var tmp24 any - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("instance?")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() - tmp29 := lang.Apply(tmp27, []any{tmp28, v4}) - if lang.IsTruthy(tmp29) { - tmp30, ok := lang.FieldOrMethod(v4, "sym") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "sym"))) - } - var tmp31 any - switch reflect.TypeOf(tmp30).Kind() { - case reflect.Func: - tmp31 = lang.Apply(tmp30, nil) - default: - tmp31 = tmp30 - } - tmp24 = tmp31 - } else { - var tmp32 any - if lang.IsTruthy(lang.NewKeyword("else")) { - tmp33 := lang.Apply(lang.NewIllegalArgumentError, []any{"no conversion to symbol"}) - panic(tmp33) - } else { - } - tmp24 = tmp32 - } - tmp16 = tmp24 - } - tmp10 = tmp16 - } - tmp5 = tmp10 - } - return tmp5 - case 2: - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6 := lang.Apply(lang.InternSymbol, []any{v4, v5}) - return tmp6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp4 := reflect.TypeOf((*lang.Symbol)(nil)) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // symbol? - { - tmp0 := lang.NewSymbol("symbol?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a Symbol", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(557), lang.NewKeyword("end-line"), int(557))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := reflect.TypeOf((*lang.Symbol)(nil)) - tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) - return tmp8 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // sync - { - tmp0 := lang.NewSymbol("sync").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("flags-ignored-for-now"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "transaction-flags => TBD, pass nil for now\n\n Runs the exprs (in an implicit do) in a transaction that encompasses\n exprs and any nested calls. Starts a transaction if none is already\n running on this thread. Any uncaught exception will abort the\n transaction and flow out of sync. The exprs may be run more than\n once, but any effects on Refs will be atomic.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(2490), lang.NewKeyword("end-line"), int(2490))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("seq")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("concat")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("list")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("list")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.Apply(tmp19, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.LockingTransaction")}) - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("list")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("seq")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("concat")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("list")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.Apply(tmp32, []any{lang.NewSymbol("glojure.core/RunInTransaction")}) - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("list")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("seq")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("concat")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp44 := tmp43.FindInternedVar(lang.NewSymbol("list")) - if tmp44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) - } - tmp45 := tmp44.Get() - tmp46 := lang.Apply(tmp45, []any{lang.NewSymbol("glojure.core/fn")}) - tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp48 := tmp47.FindInternedVar(lang.NewSymbol("list")) - if tmp48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) - } - tmp49 := tmp48.Get() - tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp51 := tmp50.FindInternedVar(lang.NewSymbol("apply")) - if tmp51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) - } - tmp52 := tmp51.Get() - tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp54 := tmp53.FindInternedVar(lang.NewSymbol("vector")) - if tmp54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) - } - tmp55 := tmp54.Get() - tmp56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp57 := tmp56.FindInternedVar(lang.NewSymbol("seq")) - if tmp57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp57))) - } - tmp58 := tmp57.Get() - tmp59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp60 := tmp59.FindInternedVar(lang.NewSymbol("concat")) - if tmp60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp60))) - } - tmp61 := tmp60.Get() - tmp62 := lang.Apply(tmp61, nil) - tmp63 := lang.Apply(tmp58, []any{tmp62}) - tmp64 := lang.Apply(tmp52, []any{tmp55, tmp63}) - tmp65 := lang.Apply(tmp49, []any{tmp64}) - tmp66 := lang.Apply(tmp42, []any{tmp46, tmp65, v6}) - tmp67 := lang.Apply(tmp39, []any{tmp66}) - tmp68 := lang.Apply(tmp36, []any{tmp67}) - tmp69 := lang.Apply(tmp29, []any{tmp33, tmp68}) - tmp70 := lang.Apply(tmp26, []any{tmp69}) - tmp71 := lang.Apply(tmp23, []any{tmp70}) - tmp72 := lang.Apply(tmp12, []any{tmp16, tmp20, tmp71}) - tmp73 := lang.Apply(tmp9, []any{tmp72}) - return tmp73 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // system-newline - { - tmp0 := lang.NewSymbol("system-newline").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3695), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(3695), lang.NewKeyword("end-column"), int(40), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, "\n", true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // tagged-literal - { - tmp0 := lang.NewSymbol("tagged-literal").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag"), lang.NewSymbol("form"))), lang.NewKeyword("doc"), "Construct a data representation of a tagged literal from a\n tag symbol and a form.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7769), lang.NewKeyword("end-line"), int(7769))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.Apply(nil, []any{v3, v4}) - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // tagged-literal? - { - tmp0 := lang.NewSymbol("tagged-literal?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("value"))), lang.NewKeyword("doc"), "Return true if the value is the data representation of a tagged literal", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7763), lang.NewKeyword("end-line"), int(7763))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.Apply(tmp6, []any{nil, v3}) - return tmp7 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // take - { - tmp0 := lang.NewSymbol("take").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the first n items in coll, or all items if\n there are fewer than n. Returns a stateful transducer when\n no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2853), lang.NewKeyword("end-line"), int(2853))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v5 := args[0] - _ = v5 - var tmp6 any - { // let - // let binding "nv" - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("volatile!")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp9, []any{v3}) - var v11 any = tmp10 - _ = v11 - var tmp12 lang.FnFunc - tmp12 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp13 := lang.Apply(v5, nil) - return tmp13 - case 1: - v13 := args[0] - _ = v13 - tmp14 := lang.Apply(v5, []any{v13}) - return tmp14 - case 2: - v13 := args[0] - _ = v13 - v14 := args[1] - _ = v14 - var tmp15 any - { // let - // let binding "n" - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("deref")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{v11}) - var v20 any = tmp19 - _ = v20 - // let binding "nn" - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("dec")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24, ok := lang.FieldOrMethod(v11, "Deref") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v11, "Deref"))) - } - var tmp25 any - switch reflect.TypeOf(tmp24).Kind() { - case reflect.Func: - tmp25 = lang.Apply(tmp24, nil) - default: - tmp25 = tmp24 - } - tmp26 := lang.Apply(tmp23, []any{tmp25}) - tmp27, _ := lang.FieldOrMethod(v11, "reset") - if reflect.TypeOf(tmp27).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) - } - tmp28 := lang.Apply(tmp27, []any{tmp26}) - var v29 any = tmp28 - _ = v29 - // let binding "result" - var tmp30 any - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("pos?")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{v20}) - if lang.IsTruthy(tmp34) { - tmp35 := lang.Apply(v5, []any{v13, v14}) - tmp30 = tmp35 - } else { - tmp30 = v13 - } - var v36 any = tmp30 - _ = v36 - var tmp37 any - tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp39 := tmp38.FindInternedVar(lang.NewSymbol("not")) - if tmp39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) - } - tmp40 := tmp39.Get() - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("pos?")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.Apply(tmp43, []any{v29}) - tmp45 := lang.Apply(tmp40, []any{tmp44}) - if lang.IsTruthy(tmp45) { - tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp47 := tmp46.FindInternedVar(lang.NewSymbol("ensure-reduced")) - if tmp47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) - } - tmp48 := tmp47.Get() - tmp49 := lang.Apply(tmp48, []any{v36}) - tmp37 = tmp49 - } else { - tmp37 = v36 - } - tmp15 = tmp37 - } // end let - return tmp15 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2862), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(2873), lang.NewKeyword("end-column"), int(28)) - tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp6 = tmp14 - } // end let - return tmp6 - }) - tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2860), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2873), lang.NewKeyword("end-column"), int(30)) - tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp6 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 lang.FnFunc - tmp5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var tmp6 any - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("pos?")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp9, []any{v3}) - if lang.IsTruthy(tmp10) { - var tmp11 any - { // let - // let binding "temp__0__auto__" - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("seq")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.Apply(tmp14, []any{v4}) - var v16 any = tmp15 - _ = v16 - var tmp17 any - if lang.IsTruthy(v16) { - var tmp18 any - { // let - // let binding "s" - var v19 any = v16 - _ = v19 - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("cons")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("first")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.Apply(tmp25, []any{v19}) - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("take")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("dec")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.Apply(tmp32, []any{v3}) - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("rest")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.Apply(tmp36, []any{v19}) - tmp38 := lang.Apply(tmp29, []any{tmp33, tmp37}) - tmp39 := lang.Apply(tmp22, []any{tmp26, tmp38}) - tmp18 = tmp39 - } // end let - tmp17 = tmp18 - } else { - } - tmp11 = tmp17 - } // end let - tmp6 = tmp11 - } else { - } - return tmp6 - }) - tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) - return tmp6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // take-last - { - tmp0 := lang.NewSymbol("take-last").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a seq of the last n items in coll. Depending on the type\n of coll may be no better than linear time. For vectors, see also subvec.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2939), lang.NewKeyword("end-line"), int(2939))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - { // let - // let binding "s" - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("seq")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(tmp8, []any{v4}) - var v10 any = tmp9 - _ = v10 - // let binding "lead" - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("seq")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("drop")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{v3, v4}) - tmp18 := lang.Apply(tmp13, []any{tmp17}) - var v19 any = tmp18 - _ = v19 - for { - var tmp20 any - if lang.IsTruthy(v19) { - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("next")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.Apply(tmp24, []any{v10}) - var tmp21 any = tmp25 - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("next")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{v19}) - var tmp26 any = tmp30 - v10 = tmp21 - v19 = tmp26 - continue - } else { - tmp20 = v10 - } - tmp5 = tmp20 - break - } - } // end let - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // take-nth - { - tmp0 := lang.NewSymbol("take-nth").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy seq of every nth item in coll. Returns a stateful\n transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4287), lang.NewKeyword("end-line"), int(4287))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v5 := args[0] - _ = v5 - var tmp6 any - { // let - // let binding "iv" - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("volatile!")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp9, []any{int64(-1)}) - var v11 any = tmp10 - _ = v11 - var tmp12 lang.FnFunc - tmp12 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp13 := lang.Apply(v5, nil) - return tmp13 - case 1: - v13 := args[0] - _ = v13 - tmp14 := lang.Apply(v5, []any{v13}) - return tmp14 - case 2: - v13 := args[0] - _ = v13 - v14 := args[1] - _ = v14 - var tmp15 any - { // let - // let binding "i" - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("inc")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19, ok := lang.FieldOrMethod(v11, "Deref") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v11, "Deref"))) - } - var tmp20 any - switch reflect.TypeOf(tmp19).Kind() { - case reflect.Func: - tmp20 = lang.Apply(tmp19, nil) - default: - tmp20 = tmp19 - } - tmp21 := lang.Apply(tmp18, []any{tmp20}) - tmp22, _ := lang.FieldOrMethod(v11, "reset") - if reflect.TypeOf(tmp22).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) - } - tmp23 := lang.Apply(tmp22, []any{tmp21}) - var v24 any = tmp23 - _ = v24 - var tmp25 any - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("zero?")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("rem")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.Apply(tmp31, []any{v24, v3}) - tmp33 := lang.Apply(tmp28, []any{tmp32}) - if lang.IsTruthy(tmp33) { - tmp34 := lang.Apply(v5, []any{v13, v14}) - tmp25 = tmp34 - } else { - tmp25 = v13 - } - tmp15 = tmp25 - } // end let - return tmp15 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4295), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(4302), lang.NewKeyword("end-column"), int(28)) - tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp6 = tmp14 - } // end let - return tmp6 - }) - tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4293), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(4302), lang.NewKeyword("end-column"), int(30)) - tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp6 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 lang.FnFunc - tmp5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var tmp6 any - { // let - // let binding "temp__0__auto__" - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("seq")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp9, []any{v4}) - var v11 any = tmp10 - _ = v11 - var tmp12 any - if lang.IsTruthy(v11) { - var tmp13 any - { // let - // let binding "s" - var v14 any = v11 - _ = v14 - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("cons")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("first")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.Apply(tmp20, []any{v14}) - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("take-nth")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("drop")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.Apply(tmp27, []any{v3, v14}) - tmp29 := lang.Apply(tmp24, []any{v3, tmp28}) - tmp30 := lang.Apply(tmp17, []any{tmp21, tmp29}) - tmp13 = tmp30 - } // end let - tmp12 = tmp13 - } else { - } - tmp6 = tmp12 - } // end let - return tmp6 - }) - tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) - return tmp6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // take-while - { - tmp0 := lang.NewSymbol("take-while").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred")), lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of successive items from coll while\n (pred item) returns logical true. pred must be free of side-effects.\n Returns a transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2880), lang.NewKeyword("end-line"), int(2880))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v5 := args[0] - _ = v5 - var tmp6 lang.FnFunc - tmp6 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp7 := lang.Apply(v5, nil) - return tmp7 - case 1: - v7 := args[0] - _ = v7 - tmp8 := lang.Apply(v5, []any{v7}) - return tmp8 - case 2: - v7 := args[0] - _ = v7 - v8 := args[1] - _ = v8 - var tmp9 any - tmp10 := lang.Apply(v3, []any{v8}) - if lang.IsTruthy(tmp10) { - tmp11 := lang.Apply(v5, []any{v7, v8}) - tmp9 = tmp11 - } else { - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("reduced")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.Apply(tmp14, []any{v7}) - tmp9 = tmp15 - } - return tmp9 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2888), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(2894), lang.NewKeyword("end-column"), int(33)) - tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp8 - }) - tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2887), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2894), lang.NewKeyword("end-column"), int(34)) - tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp6 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 lang.FnFunc - tmp5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var tmp6 any - { // let - // let binding "temp__0__auto__" - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("seq")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp9, []any{v4}) - var v11 any = tmp10 - _ = v11 - var tmp12 any - if lang.IsTruthy(v11) { - var tmp13 any - { // let - // let binding "s" - var v14 any = v11 - _ = v14 - var tmp15 any - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("first")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{v14}) - tmp20 := lang.Apply(v3, []any{tmp19}) - if lang.IsTruthy(tmp20) { - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("cons")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("first")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.Apply(tmp26, []any{v14}) - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("take-while")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("rest")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{v14}) - tmp35 := lang.Apply(tmp30, []any{v3, tmp34}) - tmp36 := lang.Apply(tmp23, []any{tmp27, tmp35}) - tmp15 = tmp36 - } else { - } - tmp13 = tmp15 - } // end let - tmp12 = tmp13 - } else { - } - tmp6 = tmp12 - } // end let - return tmp6 - }) - tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) - return tmp6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // tapset - { - tmp0 := lang.NewSymbol("tapset").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7882), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(7882), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - tmp2 := lang.NewAtom(lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{}))) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // test - { - tmp0 := lang.NewSymbol("test").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("v"))), lang.NewKeyword("doc"), "test [v] finds fn at key :test in var metadata and calls it,\n presuming failure will throw exception", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4853), lang.NewKeyword("end-line"), int(4853))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "f" - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("meta")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v3}) - tmp9 := lang.Apply(lang.NewKeyword("test"), []any{tmp8}) - var v10 any = tmp9 - _ = v10 - var tmp11 any - if lang.IsTruthy(v10) { - tmp12 := lang.Apply(v10, nil) - _ = tmp12 - tmp11 = lang.NewKeyword("ok") - } else { - tmp11 = lang.NewKeyword("no-test") - } - tmp4 = tmp11 - } // end let - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // the-ns - { - tmp0 := lang.NewSymbol("the-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "If passed a namespace, returns it. Else, when passed a symbol,\n returns the namespace named by it, throwing an exception if not\n found.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4152), lang.NewKeyword("end-line"), int(4152))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("instance?")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := reflect.TypeOf((*lang.Namespace)(nil)) - tmp9 := lang.Apply(tmp7, []any{tmp8, v3}) - if lang.IsTruthy(tmp9) { - tmp4 = v3 - } else { - var tmp10 any - { // let - // let binding "or__0__auto__" - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("find-ns")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{v3}) - var v15 any = tmp14 - _ = v15 - var tmp16 any - if lang.IsTruthy(v15) { - tmp16 = v15 - } else { - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("str")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.Apply(tmp19, []any{"No namespace: ", v3, " found"}) - tmp21 := lang.Apply(lang.NewError, []any{tmp20}) - panic(tmp21) - } - tmp10 = tmp16 - } // end let - tmp4 = tmp10 - } - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // thread-bound? - { - tmp0 := lang.NewSymbol("thread-bound?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("vars"))), lang.NewKeyword("doc"), "Returns true if all of the vars provided as arguments have thread-local bindings.\n Implies that set!'ing the provided vars will succeed. Returns true if no vars are provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5499), lang.NewKeyword("end-line"), int(5499))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var v3 any = lang.NewList(args[0:]...) - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("every?")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - var tmp7 lang.FnFunc - tmp7 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v8 := args[0] - _ = v8 - tmp9, ok := lang.FieldOrMethod(v8, "getThreadBinding") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "getThreadBinding"))) - } - var tmp10 any - switch reflect.TypeOf(tmp9).Kind() { - case reflect.Func: - tmp10 = lang.Apply(tmp9, nil) - default: - tmp10 = tmp9 - } - return tmp10 - }) - tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5505), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5505), lang.NewKeyword("end-column"), int(78)) - tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp10 := lang.Apply(tmp6, []any{tmp9, v3}) - return tmp10 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // throw-if - { - tmp0 := lang.NewSymbol("throw-if").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("fmt"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Throws a CompilerException with a message if pred is true", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5832), lang.NewKeyword("end-line"), int(5832), lang.NewKeyword("private"), true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - var tmp6 any - if lang.IsTruthy(v3) { - var tmp7 any - { // let - // let binding "message" - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("apply")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("format")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp10, []any{tmp13, v4, v5}) - var v15 any = tmp14 - _ = v15 - // let binding "exception" - tmp16 := lang.Apply(lang.NewError, []any{v15}) - var v17 any = tmp16 - _ = v17 - // let binding "raw-trace" - tmp18, ok := lang.FieldOrMethod(v17, "getStackTrace") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v17, "getStackTrace"))) - } - var tmp19 any - switch reflect.TypeOf(tmp18).Kind() { - case reflect.Func: - tmp19 = lang.Apply(tmp18, nil) - default: - tmp19 = tmp18 - } - var v20 any = tmp19 - _ = v20 - // let binding "boring?" - var tmp21 lang.FnFunc - tmp21 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v22 := args[0] - _ = v22 - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("not=")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26, ok := lang.FieldOrMethod(v22, "getMethodName") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v22, "getMethodName"))) - } - var tmp27 any - switch reflect.TypeOf(tmp26).Kind() { - case reflect.Func: - tmp27 = lang.Apply(tmp26, nil) - default: - tmp27 = tmp26 - } - tmp28 := lang.Apply(tmp25, []any{tmp27, "doInvoke"}) - return tmp28 - }) - tmp22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5839), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(5839), lang.NewKeyword("end-column"), int(74)) - tmp23, err := lang.WithMeta(tmp21, tmp22.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v24 any = tmp23 - _ = v24 - // let binding "trace" - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("into-array")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("drop")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("drop-while")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{v24, v20}) - tmp35 := lang.Apply(tmp30, []any{int64(2), tmp34}) - tmp36 := lang.Apply(tmp27, []any{nil, tmp35}) - var v37 any = tmp36 - _ = v37 - tmp38, _ := lang.FieldOrMethod(v17, "setStackTrace") - if reflect.TypeOf(tmp38).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setStackTrace is not a function"))) - } - tmp39 := lang.Apply(tmp38, []any{v37}) - _ = tmp39 - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("*file*")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43, ok := lang.FieldOrMethod(nil, "Deref") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "Deref"))) - } - var tmp44 any - switch reflect.TypeOf(tmp43).Kind() { - case reflect.Func: - tmp44 = lang.Apply(tmp43, nil) - default: - tmp44 = tmp43 - } - tmp45, ok := lang.FieldOrMethod(nil, "Deref") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "Deref"))) - } - var tmp46 any - switch reflect.TypeOf(tmp45).Kind() { - case reflect.Func: - tmp46 = lang.Apply(tmp45, nil) - default: - tmp46 = tmp45 - } - tmp47 := lang.Apply(lang.NewCompilerError, []any{tmp42, tmp44, tmp46, v17}) - panic(tmp47) - } // end let - tmp6 = tmp7 - } else { - } - return tmp6 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // time - { - tmp0 := lang.NewSymbol("time").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"))), lang.NewKeyword("doc"), "Evaluates expr and prints the time it took. Returns the value of\n expr.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3885), lang.NewKeyword("end-line"), int(3885))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("seq")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("concat")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("list")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("glojure.core/let")}) - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("list")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("apply")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("vector")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("seq")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("concat")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{lang.NewSymbol("start__0__auto__")}) - tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp36 := tmp35.FindInternedVar(lang.NewSymbol("list")) - if tmp36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) - } - tmp37 := tmp36.Get() - tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp39 := tmp38.FindInternedVar(lang.NewSymbol("seq")) - if tmp39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) - } - tmp40 := tmp39.Get() - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("concat")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.Apply(tmp46, []any{lang.NewSymbol(".UnixNano")}) - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp52 := tmp51.FindInternedVar(lang.NewSymbol("seq")) - if tmp52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp52))) - } - tmp53 := tmp52.Get() - tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp55 := tmp54.FindInternedVar(lang.NewSymbol("concat")) - if tmp55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) - } - tmp56 := tmp55.Get() - tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp58 := tmp57.FindInternedVar(lang.NewSymbol("list")) - if tmp58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) - } - tmp59 := tmp58.Get() - tmp60 := lang.Apply(tmp59, []any{lang.NewSymbol("time.Now")}) - tmp61 := lang.Apply(tmp56, []any{tmp60}) - tmp62 := lang.Apply(tmp53, []any{tmp61}) - tmp63 := lang.Apply(tmp50, []any{tmp62}) - tmp64 := lang.Apply(tmp43, []any{tmp47, tmp63}) - tmp65 := lang.Apply(tmp40, []any{tmp64}) - tmp66 := lang.Apply(tmp37, []any{tmp65}) - tmp67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp68 := tmp67.FindInternedVar(lang.NewSymbol("list")) - if tmp68.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp68))) - } - tmp69 := tmp68.Get() - tmp70 := lang.Apply(tmp69, []any{lang.NewSymbol("ret__1__auto__")}) - tmp71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp72 := tmp71.FindInternedVar(lang.NewSymbol("list")) - if tmp72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp72))) - } - tmp73 := tmp72.Get() - tmp74 := lang.Apply(tmp73, []any{v5}) - tmp75 := lang.Apply(tmp30, []any{tmp34, tmp66, tmp70, tmp74}) - tmp76 := lang.Apply(tmp27, []any{tmp75}) - tmp77 := lang.Apply(tmp21, []any{tmp24, tmp76}) - tmp78 := lang.Apply(tmp18, []any{tmp77}) - tmp79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp80 := tmp79.FindInternedVar(lang.NewSymbol("list")) - if tmp80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp80))) - } - tmp81 := tmp80.Get() - tmp82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp83 := tmp82.FindInternedVar(lang.NewSymbol("seq")) - if tmp83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp83))) - } - tmp84 := tmp83.Get() - tmp85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp86 := tmp85.FindInternedVar(lang.NewSymbol("concat")) - if tmp86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp86))) - } - tmp87 := tmp86.Get() - tmp88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp89 := tmp88.FindInternedVar(lang.NewSymbol("list")) - if tmp89.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp89))) - } - tmp90 := tmp89.Get() - tmp91 := lang.Apply(tmp90, []any{lang.NewSymbol("glojure.core/prn")}) - tmp92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp93 := tmp92.FindInternedVar(lang.NewSymbol("list")) - if tmp93.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp93))) - } - tmp94 := tmp93.Get() - tmp95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp96 := tmp95.FindInternedVar(lang.NewSymbol("seq")) - if tmp96.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp96))) - } - tmp97 := tmp96.Get() - tmp98 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp99 := tmp98.FindInternedVar(lang.NewSymbol("concat")) - if tmp99.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp99))) - } - tmp100 := tmp99.Get() - tmp101 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp102 := tmp101.FindInternedVar(lang.NewSymbol("list")) - if tmp102.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp102))) - } - tmp103 := tmp102.Get() - tmp104 := lang.Apply(tmp103, []any{lang.NewSymbol("glojure.core/str")}) - tmp105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp106 := tmp105.FindInternedVar(lang.NewSymbol("list")) - if tmp106.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp106))) - } - tmp107 := tmp106.Get() - tmp108 := lang.Apply(tmp107, []any{"Elapsed time: "}) - tmp109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp110 := tmp109.FindInternedVar(lang.NewSymbol("list")) - if tmp110.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp110))) - } - tmp111 := tmp110.Get() - tmp112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp113 := tmp112.FindInternedVar(lang.NewSymbol("seq")) - if tmp113.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp113))) - } - tmp114 := tmp113.Get() - tmp115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp116 := tmp115.FindInternedVar(lang.NewSymbol("concat")) - if tmp116.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp116))) - } - tmp117 := tmp116.Get() - tmp118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp119 := tmp118.FindInternedVar(lang.NewSymbol("list")) - if tmp119.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp119))) - } - tmp120 := tmp119.Get() - tmp121 := lang.Apply(tmp120, []any{lang.NewSymbol("glojure.core//")}) - tmp122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp123 := tmp122.FindInternedVar(lang.NewSymbol("list")) - if tmp123.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp123))) - } - tmp124 := tmp123.Get() - tmp125 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp126 := tmp125.FindInternedVar(lang.NewSymbol("seq")) - if tmp126.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp126))) - } - tmp127 := tmp126.Get() - tmp128 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp129 := tmp128.FindInternedVar(lang.NewSymbol("concat")) - if tmp129.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp129))) - } - tmp130 := tmp129.Get() - tmp131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp132 := tmp131.FindInternedVar(lang.NewSymbol("list")) - if tmp132.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp132))) - } - tmp133 := tmp132.Get() - tmp134 := lang.Apply(tmp133, []any{lang.NewSymbol("glojure.core/double")}) - tmp135 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp136 := tmp135.FindInternedVar(lang.NewSymbol("list")) - if tmp136.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp136))) - } - tmp137 := tmp136.Get() - tmp138 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp139 := tmp138.FindInternedVar(lang.NewSymbol("seq")) - if tmp139.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp139))) - } - tmp140 := tmp139.Get() - tmp141 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp142 := tmp141.FindInternedVar(lang.NewSymbol("concat")) - if tmp142.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp142))) - } - tmp143 := tmp142.Get() - tmp144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp145 := tmp144.FindInternedVar(lang.NewSymbol("list")) - if tmp145.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp145))) - } - tmp146 := tmp145.Get() - tmp147 := lang.Apply(tmp146, []any{lang.NewSymbol("glojure.core/-")}) - tmp148 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp149 := tmp148.FindInternedVar(lang.NewSymbol("list")) - if tmp149.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp149))) - } - tmp150 := tmp149.Get() - tmp151 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp152 := tmp151.FindInternedVar(lang.NewSymbol("seq")) - if tmp152.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp152))) - } - tmp153 := tmp152.Get() - tmp154 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp155 := tmp154.FindInternedVar(lang.NewSymbol("concat")) - if tmp155.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp155))) - } - tmp156 := tmp155.Get() - tmp157 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp158 := tmp157.FindInternedVar(lang.NewSymbol("list")) - if tmp158.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp158))) - } - tmp159 := tmp158.Get() - tmp160 := lang.Apply(tmp159, []any{lang.NewSymbol(".UnixNano")}) - tmp161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp162 := tmp161.FindInternedVar(lang.NewSymbol("list")) - if tmp162.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp162))) - } - tmp163 := tmp162.Get() - tmp164 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp165 := tmp164.FindInternedVar(lang.NewSymbol("seq")) - if tmp165.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp165))) - } - tmp166 := tmp165.Get() - tmp167 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp168 := tmp167.FindInternedVar(lang.NewSymbol("concat")) - if tmp168.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp168))) - } - tmp169 := tmp168.Get() - tmp170 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp171 := tmp170.FindInternedVar(lang.NewSymbol("list")) - if tmp171.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp171))) - } - tmp172 := tmp171.Get() - tmp173 := lang.Apply(tmp172, []any{lang.NewSymbol("time.Now")}) - tmp174 := lang.Apply(tmp169, []any{tmp173}) - tmp175 := lang.Apply(tmp166, []any{tmp174}) - tmp176 := lang.Apply(tmp163, []any{tmp175}) - tmp177 := lang.Apply(tmp156, []any{tmp160, tmp176}) - tmp178 := lang.Apply(tmp153, []any{tmp177}) - tmp179 := lang.Apply(tmp150, []any{tmp178}) - tmp180 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp181 := tmp180.FindInternedVar(lang.NewSymbol("list")) - if tmp181.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp181))) - } - tmp182 := tmp181.Get() - tmp183 := lang.Apply(tmp182, []any{lang.NewSymbol("start__0__auto__")}) - tmp184 := lang.Apply(tmp143, []any{tmp147, tmp179, tmp183}) - tmp185 := lang.Apply(tmp140, []any{tmp184}) - tmp186 := lang.Apply(tmp137, []any{tmp185}) - tmp187 := lang.Apply(tmp130, []any{tmp134, tmp186}) - tmp188 := lang.Apply(tmp127, []any{tmp187}) - tmp189 := lang.Apply(tmp124, []any{tmp188}) - tmp190 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp191 := tmp190.FindInternedVar(lang.NewSymbol("list")) - if tmp191.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp191))) - } - tmp192 := tmp191.Get() - tmp193 := lang.Apply(tmp192, []any{nil}) - tmp194 := lang.Apply(tmp117, []any{tmp121, tmp189, tmp193}) - tmp195 := lang.Apply(tmp114, []any{tmp194}) - tmp196 := lang.Apply(tmp111, []any{tmp195}) - tmp197 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp198 := tmp197.FindInternedVar(lang.NewSymbol("list")) - if tmp198.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp198))) - } - tmp199 := tmp198.Get() - tmp200 := lang.Apply(tmp199, []any{" msecs"}) - tmp201 := lang.Apply(tmp100, []any{tmp104, tmp108, tmp196, tmp200}) - tmp202 := lang.Apply(tmp97, []any{tmp201}) - tmp203 := lang.Apply(tmp94, []any{tmp202}) - tmp204 := lang.Apply(tmp87, []any{tmp91, tmp203}) - tmp205 := lang.Apply(tmp84, []any{tmp204}) - tmp206 := lang.Apply(tmp81, []any{tmp205}) - tmp207 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp208 := tmp207.FindInternedVar(lang.NewSymbol("list")) - if tmp208.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp208))) - } - tmp209 := tmp208.Get() - tmp210 := lang.Apply(tmp209, []any{lang.NewSymbol("ret__1__auto__")}) - tmp211 := lang.Apply(tmp11, []any{tmp15, tmp78, tmp206, tmp210}) - tmp212 := lang.Apply(tmp8, []any{tmp211}) - return tmp212 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // to-array - { - tmp0 := lang.NewSymbol("to-array").WithMeta(lang.NewMap(lang.NewKeyword("tag"), "[Ljava.lang.Object;", lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns an array of Objects containing the contents of coll, which\n can be any Collection. Maps to java.util.Collection.toArray().", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(337), lang.NewKeyword("end-line"), int(337))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4, _ := lang.FieldOrMethod(runtime4.RT, "ToArray") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ToArray is not a function"))) - } - tmp5 := lang.Apply(tmp4, []any{v3}) - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), "[Ljava.lang.Object;")).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // to-array-2d - { - tmp0 := lang.NewSymbol("to-array-2d").WithMeta(lang.NewMap(lang.NewKeyword("tag"), "[[Ljava.lang.Object;", lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a (potentially-ragged) 2-dimensional array of Objects\n containing the contents of coll, which can be any Collection of any\n Collection.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4002), lang.NewKeyword("end-line"), int(4002))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "ret" - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("make-array")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := reflect.TypeOf((*reflect.Type)(nil)).Elem() - tmp9, _ := lang.FieldOrMethod(tmp8, "forName") - if reflect.TypeOf(tmp9).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("forName is not a function"))) - } - tmp10 := lang.Apply(tmp9, []any{"[Ljava.lang.Object;"}) - tmp11, _ := lang.FieldOrMethod(v3, "size") - if reflect.TypeOf(tmp11).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("size is not a function"))) - } - tmp12 := lang.Apply(tmp11, []any{}) - tmp13 := lang.Apply(tmp7, []any{tmp10, tmp12}) - var v14 any = tmp13 - _ = v14 - var tmp15 any - { // let - // let binding "i" - var v16 any = int64(0) - _ = v16 - // let binding "xs" - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.Apply(tmp19, []any{v3}) - var v21 any = tmp20 - _ = v21 - for { - var tmp22 any - if lang.IsTruthy(v21) { - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("aset")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("to-array")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("first")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.Apply(tmp31, []any{v21}) - tmp33 := lang.Apply(tmp28, []any{tmp32}) - tmp34 := lang.Apply(tmp25, []any{v14, v16, tmp33}) - _ = tmp34 - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("inc")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{v16}) - var tmp35 any = tmp39 - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("next")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.Apply(tmp43, []any{v21}) - var tmp40 any = tmp44 - v16 = tmp35 - v21 = tmp40 - continue - } else { - } - tmp15 = tmp22 - break - } - } // end let - _ = tmp15 - tmp4 = v14 - } // end let - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), "[[Ljava.lang.Object;")).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // trampoline - { - tmp0 := lang.NewSymbol("trampoline").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "trampoline can be used to convert algorithms requiring mutual\n recursion without stack consumption. Calls f with supplied args, if\n any. If f returns a fn, calls that fn with no arguments, and\n continues to repeat, until the return value is not a fn, then\n returns that non-fn value. Note that if you want to return a fn as a\n final value, you must wrap it in some data structure and unpack it\n after trampoline returns.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6293), lang.NewKeyword("end-line"), int(6293))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - recur_loop_1073: - var tmp4 any - { // let - // let binding "ret" - tmp5 := lang.Apply(v3, nil) - var v6 any = tmp5 - _ = v6 - var tmp7 any - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("fn?")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v6}) - if lang.IsTruthy(tmp11) { - var tmp12 any = v6 - v3 = tmp12 - goto recur_loop_1073 - } else { - tmp7 = v6 - } - tmp4 = tmp7 - } // end let - return tmp4 - default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var v4 any = lang.NewList(args[1:]...) - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("trampoline")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - var tmp8 lang.FnFunc - tmp8 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("apply")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.Apply(tmp11, []any{v3, v4}) - return tmp12 - }) - tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6309), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(6309), lang.NewKeyword("end-column"), int(32)) - tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp11 := lang.Apply(tmp7, []any{tmp10}) - return tmp11 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // transduce - { - tmp0 := lang.NewSymbol("transduce").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "reduce with a transformation of f (xf). If init is not\n supplied, (f) will be called to produce it. f should be a reducing\n step function that accepts both 1 and 2 arguments, if it accepts\n only 2 you can add the arity-1 with 'completing'. Returns the result\n of applying (the transformed) xf to init and the first item in coll,\n then applying xf to that result and the 2nd item, etc. If coll\n contains no items, returns init and f is not called. Note that\n certain transforms may inject or skip items.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6905), lang.NewKeyword("end-line"), int(6905))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("transduce")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(v4, nil) - tmp10 := lang.Apply(tmp8, []any{v3, v4, tmp9, v5}) - return tmp10 - case 4: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - var tmp7 any - { // let - // let binding "f" - tmp8 := lang.Apply(v3, []any{v4}) - var v9 any = tmp8 - _ = v9 - // let binding "ret" - var tmp10 any - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("instance?")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := reflect.TypeOf((*lang.IReduceInit)(nil)).Elem() - tmp15 := lang.Apply(tmp13, []any{tmp14, v6}) - if lang.IsTruthy(tmp15) { - tmp16, _ := lang.FieldOrMethod(v6, "ReduceInit") - if reflect.TypeOf(tmp16).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) - } - tmp17 := lang.Apply(tmp16, []any{v9, v5}) - tmp10 = tmp17 - } else { - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core.protocols")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("coll-reduce")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.Apply(tmp20, []any{v6, v9, v5}) - tmp10 = tmp21 - } - var v22 any = tmp10 - _ = v22 - tmp23 := lang.Apply(v9, []any{v22}) - tmp7 = tmp23 - } // end let - return tmp7 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // transient - { - tmp0 := lang.NewSymbol("transient").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a new, transient version of the collection, in constant time.\n\n Transients support a parallel set of 'changing' operations, with similar names\n followed by ! - assoc!, conj! etc. These do the same things as their persistent\n counterparts except the return values are themselves transient.\n\n Note in particular that transients are not designed to be bashed in-place. You\n must capture and use the return value in the next call. In this way, they support\n the same code structure as the functional persistent code they replace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3335), lang.NewKeyword("end-line"), int(3335))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4, ok := lang.FieldOrMethod(v3, "AsTransient") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "AsTransient"))) - } - var tmp5 any - switch reflect.TypeOf(tmp4).Kind() { - case reflect.Func: - tmp5 = lang.Apply(tmp4, nil) - default: - tmp5 = tmp4 - } - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // tree-seq - { - tmp0 := lang.NewSymbol("tree-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("branch?"), lang.NewSymbol("children"), lang.NewSymbol("root"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the nodes in a tree, via a depth-first walk.\n branch? must be a fn of one arg that returns true if passed a node\n that can have children (but may not). children must be a fn of one\n arg that returns a sequence of the children. Will only be called on\n nodes for which branch? returns true. Root is the root node of the\n tree.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4955), lang.NewKeyword("end-line"), int(4955))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var tmp6 any - { // let - // let binding "walk" - var tmp7 lang.FnFunc - { // function walk - var v8 lang.FnFunc - tmp7 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v9 := args[0] - _ = v9 - var tmp10 lang.FnFunc - tmp10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("cons")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - var tmp14 any - tmp15 := lang.Apply(v3, []any{v9}) - if lang.IsTruthy(tmp15) { - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("mapcat")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(v4, []any{v9}) - tmp20 := lang.Apply(tmp18, []any{v8, tmp19}) - tmp14 = tmp20 - } else { - } - tmp21 := lang.Apply(tmp13, []any{v9, tmp14}) - return tmp21 - }) - tmp11 := lang.Apply(lang.NewLazySeq, []any{tmp10}) - return tmp11 - }) - v8 = tmp7 - _ = v8 - } - tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4965), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(4969), lang.NewKeyword("end-column"), int(53)) - tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v10 any = tmp9 - _ = v10 - tmp11 := lang.Apply(v10, []any{v5}) - tmp6 = tmp11 - } // end let - return tmp6 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // true? - { - tmp1 := reflect.TypeOf(false) - tmp0 := lang.NewSymbol("true?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is the value true, false otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(511), lang.NewKeyword("end-line"), int(511))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5 := lang.Apply(lang.Identical, []any{v4, true}) - return tmp5 - }) - tmp4 := reflect.TypeOf(false) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // type - { - tmp0 := lang.NewSymbol("type").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns the :type metadata of x, or its Class if none", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3467), lang.NewKeyword("end-line"), int(3467))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "or__0__auto__" - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("get")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("meta")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v3}) - tmp12 := lang.Apply(tmp7, []any{tmp11, lang.NewKeyword("type")}) - var v13 any = tmp12 - _ = v13 - var tmp14 any - if lang.IsTruthy(v13) { - tmp14 = v13 - } else { - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("class")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{v3}) - tmp14 = tmp18 - } - tmp4 = tmp14 - } // end let - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // unchecked-add - { - var tmp1 lang.FnFunc - { // function unchecked-add__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("concat")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("list")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol(".")}) - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("seq")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("concat")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("list")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.Apply(tmp30, []any{lang.NewSymbol("glojure.core/UncheckedAdd")}) - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.Apply(tmp34, []any{v3}) - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{v4}) - tmp40 := lang.Apply(tmp27, []any{tmp31, tmp35, tmp39}) - tmp41 := lang.Apply(tmp24, []any{tmp40}) - tmp42 := lang.Apply(tmp21, []any{tmp41}) - tmp43 := lang.Apply(tmp10, []any{tmp14, tmp18, tmp42}) - tmp44 := lang.Apply(tmp7, []any{tmp43}) - return tmp44 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("unchecked-add").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the sum of x and y, both long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1203), lang.NewKeyword("end-line"), int(1203))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedAdd") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedAdd is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // unchecked-add-int - { - var tmp1 lang.FnFunc - { // function unchecked-add-int__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("concat")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("list")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol(".")}) - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("seq")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("concat")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("list")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.Apply(tmp30, []any{lang.NewSymbol("glojure.core/Unchecked_int_add")}) - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.Apply(tmp34, []any{v3}) - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{v4}) - tmp40 := lang.Apply(tmp27, []any{tmp31, tmp35, tmp39}) - tmp41 := lang.Apply(tmp24, []any{tmp40}) - tmp42 := lang.Apply(tmp21, []any{tmp41}) - tmp43 := lang.Apply(tmp10, []any{tmp14, tmp18, tmp42}) - tmp44 := lang.Apply(tmp7, []any{tmp43}) - return tmp44 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("unchecked-add-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the sum of x and y, both int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1196), lang.NewKeyword("end-line"), int(1196))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_add") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_add is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // unchecked-byte - { - var tmp1 lang.FnFunc - { // function unchecked-byte__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/UncheckedByteCast")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{v3}) - tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) - tmp36 := lang.Apply(tmp23, []any{tmp35}) - tmp37 := lang.Apply(tmp20, []any{tmp36}) - tmp38 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp37}) - tmp39 := lang.Apply(tmp6, []any{tmp38}) - return tmp39 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("unchecked-byte").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to byte. Subject to rounding or truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3517), lang.NewKeyword("end-line"), int(3517))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5 := lang.Apply(lang.UncheckedByteCast, []any{v4}) - return tmp5 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // unchecked-char - { - var tmp1 lang.FnFunc - { // function unchecked-char__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/UncheckedCharCast")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{v3}) - tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) - tmp36 := lang.Apply(tmp23, []any{tmp35}) - tmp37 := lang.Apply(tmp20, []any{tmp36}) - tmp38 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp37}) - tmp39 := lang.Apply(tmp6, []any{tmp38}) - return tmp39 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("unchecked-char").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to char. Subject to rounding or truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3529), lang.NewKeyword("end-line"), int(3529))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(runtime4.RT, "UncheckedCharCast") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedCharCast is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // unchecked-dec - { - var tmp1 lang.FnFunc - { // function unchecked-dec__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/UncheckedDec")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{v3}) - tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) - tmp36 := lang.Apply(tmp23, []any{tmp35}) - tmp37 := lang.Apply(tmp20, []any{tmp36}) - tmp38 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp37}) - tmp39 := lang.Apply(tmp6, []any{tmp38}) - return tmp39 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("unchecked-dec").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns a number one less than x, a long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1175), lang.NewKeyword("end-line"), int(1175))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedDec") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedDec is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // unchecked-dec-int - { - var tmp1 lang.FnFunc - { // function unchecked-dec-int__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/Unchecked_int_dec")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{v3}) - tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) - tmp36 := lang.Apply(tmp23, []any{tmp35}) - tmp37 := lang.Apply(tmp20, []any{tmp36}) - tmp38 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp37}) - tmp39 := lang.Apply(tmp6, []any{tmp38}) - return tmp39 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("unchecked-dec-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns a number one less than x, an int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1168), lang.NewKeyword("end-line"), int(1168))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_dec") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_dec is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // unchecked-divide-int - { - var tmp1 lang.FnFunc - { // function unchecked-divide-int__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("concat")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("list")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol(".")}) - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("seq")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("concat")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("list")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.Apply(tmp30, []any{lang.NewSymbol("glojure.core/UncheckedIntDivide")}) - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.Apply(tmp34, []any{v3}) - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{v4}) - tmp40 := lang.Apply(tmp27, []any{tmp31, tmp35, tmp39}) - tmp41 := lang.Apply(tmp24, []any{tmp40}) - tmp42 := lang.Apply(tmp21, []any{tmp41}) - tmp43 := lang.Apply(tmp10, []any{tmp14, tmp18, tmp42}) - tmp44 := lang.Apply(tmp7, []any{tmp43}) - return tmp44 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("unchecked-divide-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the division of x by y, both int.\n Note - uses a primitive operator subject to truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(26), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1238), lang.NewKeyword("end-line"), int(1238))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedIntDivide") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedIntDivide is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // unchecked-double - { - var tmp1 lang.FnFunc - { // function unchecked-double__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/UncheckedDoubleCast")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{v3}) - tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) - tmp36 := lang.Apply(tmp23, []any{tmp35}) - tmp37 := lang.Apply(tmp20, []any{tmp36}) - tmp38 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp37}) - tmp39 := lang.Apply(tmp6, []any{tmp38}) - return tmp39 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("unchecked-double").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to double. Subject to rounding.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3553), lang.NewKeyword("end-line"), int(3553))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5 := lang.Apply(lang.AsFloat64, []any{v4}) - return tmp5 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // unchecked-float - { - var tmp1 lang.FnFunc - { // function unchecked-float__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/UncheckedFloatCast")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{v3}) - tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) - tmp36 := lang.Apply(tmp23, []any{tmp35}) - tmp37 := lang.Apply(tmp20, []any{tmp36}) - tmp38 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp37}) - tmp39 := lang.Apply(tmp6, []any{tmp38}) - return tmp39 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("unchecked-float").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to float. Subject to rounding.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3547), lang.NewKeyword("end-line"), int(3547))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5 := lang.Apply(lang.UncheckedFloatCast, []any{v4}) - return tmp5 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // unchecked-inc - { - var tmp1 lang.FnFunc - { // function unchecked-inc__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/Unchecked_inc")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{v3}) - tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) - tmp36 := lang.Apply(tmp23, []any{tmp35}) - tmp37 := lang.Apply(tmp20, []any{tmp36}) - tmp38 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp37}) - tmp39 := lang.Apply(tmp6, []any{tmp38}) - return tmp39 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("unchecked-inc").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns a number one greater than x, a long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1161), lang.NewKeyword("end-line"), int(1161))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_inc") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_inc is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // unchecked-inc-int - { - var tmp1 lang.FnFunc - { // function unchecked-inc-int__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/Unchecked_int_inc")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{v3}) - tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) - tmp36 := lang.Apply(tmp23, []any{tmp35}) - tmp37 := lang.Apply(tmp20, []any{tmp36}) - tmp38 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp37}) - tmp39 := lang.Apply(tmp6, []any{tmp38}) - return tmp39 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("unchecked-inc-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns a number one greater than x, an int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1154), lang.NewKeyword("end-line"), int(1154))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_inc") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_inc is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // unchecked-int - { - var tmp1 lang.FnFunc - { // function unchecked-int__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/UncheckedIntCast")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{v3}) - tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) - tmp36 := lang.Apply(tmp23, []any{tmp35}) - tmp37 := lang.Apply(tmp20, []any{tmp36}) - tmp38 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp37}) - tmp39 := lang.Apply(tmp6, []any{tmp38}) - return tmp39 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("unchecked-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to int. Subject to rounding or truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3535), lang.NewKeyword("end-line"), int(3535))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5 := lang.Apply(lang.UncheckedIntCast, []any{v4}) - return tmp5 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // unchecked-long - { - var tmp1 lang.FnFunc - { // function unchecked-long__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/UncheckedLongCast")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{v3}) - tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) - tmp36 := lang.Apply(tmp23, []any{tmp35}) - tmp37 := lang.Apply(tmp20, []any{tmp36}) - tmp38 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp37}) - tmp39 := lang.Apply(tmp6, []any{tmp38}) - return tmp39 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("unchecked-long").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to long. Subject to rounding or truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3541), lang.NewKeyword("end-line"), int(3541))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5 := lang.Apply(lang.UncheckedLongCast, []any{v4}) - return tmp5 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // unchecked-multiply - { - var tmp1 lang.FnFunc - { // function unchecked-multiply__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("concat")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("list")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol(".")}) - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("seq")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("concat")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("list")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.Apply(tmp30, []any{lang.NewSymbol("glojure.core/Unchecked_multiply")}) - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.Apply(tmp34, []any{v3}) - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{v4}) - tmp40 := lang.Apply(tmp27, []any{tmp31, tmp35, tmp39}) - tmp41 := lang.Apply(tmp24, []any{tmp40}) - tmp42 := lang.Apply(tmp21, []any{tmp41}) - tmp43 := lang.Apply(tmp10, []any{tmp14, tmp18, tmp42}) - tmp44 := lang.Apply(tmp7, []any{tmp43}) - return tmp44 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("unchecked-multiply").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the product of x and y, both long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1231), lang.NewKeyword("end-line"), int(1231))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_multiply") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_multiply is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // unchecked-multiply-int - { - var tmp1 lang.FnFunc - { // function unchecked-multiply-int__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("concat")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("list")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol(".")}) - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("seq")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("concat")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("list")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.Apply(tmp30, []any{lang.NewSymbol("glojure.core/Unchecked_int_multiply")}) - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.Apply(tmp34, []any{v3}) - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{v4}) - tmp40 := lang.Apply(tmp27, []any{tmp31, tmp35, tmp39}) - tmp41 := lang.Apply(tmp24, []any{tmp40}) - tmp42 := lang.Apply(tmp21, []any{tmp41}) - tmp43 := lang.Apply(tmp10, []any{tmp14, tmp18, tmp42}) - tmp44 := lang.Apply(tmp7, []any{tmp43}) - return tmp44 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("unchecked-multiply-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the product of x and y, both int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1224), lang.NewKeyword("end-line"), int(1224))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_multiply") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_multiply is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // unchecked-negate - { - var tmp1 lang.FnFunc - { // function unchecked-negate__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/Unchecked_minus")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{v3}) - tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) - tmp36 := lang.Apply(tmp23, []any{tmp35}) - tmp37 := lang.Apply(tmp20, []any{tmp36}) - tmp38 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp37}) - tmp39 := lang.Apply(tmp6, []any{tmp38}) - return tmp39 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("unchecked-negate").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the negation of x, a long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1189), lang.NewKeyword("end-line"), int(1189))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_negate") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_negate is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // unchecked-negate-int - { - var tmp1 lang.FnFunc - { // function unchecked-negate-int__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/Unchecked_int_negate")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{v3}) - tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) - tmp36 := lang.Apply(tmp23, []any{tmp35}) - tmp37 := lang.Apply(tmp20, []any{tmp36}) - tmp38 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp37}) - tmp39 := lang.Apply(tmp6, []any{tmp38}) - return tmp39 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("unchecked-negate-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the negation of x, an int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(26), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1182), lang.NewKeyword("end-line"), int(1182))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_negate") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_negate is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // unchecked-remainder-int - { - var tmp1 lang.FnFunc - { // function unchecked-remainder-int__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("concat")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("list")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol(".")}) - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("seq")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("concat")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("list")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.Apply(tmp30, []any{lang.NewSymbol("glojure.core/Unchecked_int_remainder")}) - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.Apply(tmp34, []any{v3}) - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{v4}) - tmp40 := lang.Apply(tmp27, []any{tmp31, tmp35, tmp39}) - tmp41 := lang.Apply(tmp24, []any{tmp40}) - tmp42 := lang.Apply(tmp21, []any{tmp41}) - tmp43 := lang.Apply(tmp10, []any{tmp14, tmp18, tmp42}) - tmp44 := lang.Apply(tmp7, []any{tmp43}) - return tmp44 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("unchecked-remainder-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the remainder of division of x by y, both int.\n Note - uses a primitive operator subject to truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(29), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1245), lang.NewKeyword("end-line"), int(1245))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_remainder") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_remainder is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // unchecked-short - { - var tmp1 lang.FnFunc - { // function unchecked-short__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/UncheckedShortCast")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{v3}) - tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) - tmp36 := lang.Apply(tmp23, []any{tmp35}) - tmp37 := lang.Apply(tmp20, []any{tmp36}) - tmp38 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp37}) - tmp39 := lang.Apply(tmp6, []any{tmp38}) - return tmp39 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("unchecked-short").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to short. Subject to rounding or truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3523), lang.NewKeyword("end-line"), int(3523))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5 := lang.Apply(lang.UncheckedShortCast, []any{v4}) - return tmp5 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // unchecked-subtract - { - var tmp1 lang.FnFunc - { // function unchecked-subtract__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("concat")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("list")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol(".")}) - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("seq")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("concat")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("list")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.Apply(tmp30, []any{lang.NewSymbol("glojure.core/Unchecked_minus")}) - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.Apply(tmp34, []any{v3}) - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{v4}) - tmp40 := lang.Apply(tmp27, []any{tmp31, tmp35, tmp39}) - tmp41 := lang.Apply(tmp24, []any{tmp40}) - tmp42 := lang.Apply(tmp21, []any{tmp41}) - tmp43 := lang.Apply(tmp10, []any{tmp14, tmp18, tmp42}) - tmp44 := lang.Apply(tmp7, []any{tmp43}) - return tmp44 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("unchecked-subtract").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the difference of x and y, both long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1217), lang.NewKeyword("end-line"), int(1217))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_minus") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_minus is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // unchecked-subtract-int - { - var tmp1 lang.FnFunc - { // function unchecked-subtract-int__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("concat")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("list")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol(".")}) - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("seq")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("concat")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("list")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.Apply(tmp30, []any{lang.NewSymbol("glojure.core/Unchecked_int_subtract")}) - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.Apply(tmp34, []any{v3}) - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{v4}) - tmp40 := lang.Apply(tmp27, []any{tmp31, tmp35, tmp39}) - tmp41 := lang.Apply(tmp24, []any{tmp40}) - tmp42 := lang.Apply(tmp21, []any{tmp41}) - tmp43 := lang.Apply(tmp10, []any{tmp14, tmp18, tmp42}) - tmp44 := lang.Apply(tmp7, []any{tmp43}) - return tmp44 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("unchecked-subtract-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the difference of x and y, both int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1210), lang.NewKeyword("end-line"), int(1210))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_subtract") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_subtract is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // underive - { - tmp0 := lang.NewSymbol("underive").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag"), lang.NewSymbol("parent")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"), lang.NewSymbol("parent"))), lang.NewKeyword("doc"), "Removes a parent/child relationship between parent and\n tag. h must be a hierarchy obtained from make-hierarchy, if not\n supplied defaults to, and modifies, the global hierarchy.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5643), lang.NewKeyword("end-line"), int(5643))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("alter-var-root")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("global-hierarchy")) - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("underive")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.Apply(tmp7, []any{tmp8, tmp11, v3, v4}) - _ = tmp12 - return nil - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var tmp6 any - { // let - // let binding "parentMap" - tmp7 := lang.Apply(lang.NewKeyword("parents"), []any{v3}) - var v8 any = tmp7 - _ = v8 - // let binding "childsParents" - var tmp9 any - tmp10 := lang.Apply(v8, []any{v4}) - if lang.IsTruthy(tmp10) { - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("disj")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(v8, []any{v4}) - tmp15 := lang.Apply(tmp13, []any{tmp14, v5}) - tmp9 = tmp15 - } else { - tmp16 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) - tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5652), lang.NewKeyword("column"), int(36), lang.NewKeyword("end-line"), int(5652), lang.NewKeyword("end-column"), int(38)) - tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp9 = tmp18 - } - var v19 any = tmp9 - _ = v19 - // let binding "newParents" - var tmp20 any - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("not-empty")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.Apply(tmp23, []any{v19}) - if lang.IsTruthy(tmp24) { - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("assoc")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.Apply(tmp27, []any{v8, v4, v19}) - tmp20 = tmp28 - } else { - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("dissoc")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.Apply(tmp31, []any{v8, v4}) - tmp20 = tmp32 - } - var v33 any = tmp20 - _ = v33 - // let binding "deriv-seq" - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("flatten")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("map")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - var tmp40 lang.FnFunc - tmp40 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v41 := args[0] - _ = v41 - tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp43 := tmp42.FindInternedVar(lang.NewSymbol("cons")) - if tmp43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) - } - tmp44 := tmp43.Get() - tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp46 := tmp45.FindInternedVar(lang.NewSymbol("key")) - if tmp46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) - } - tmp47 := tmp46.Get() - tmp48 := lang.Apply(tmp47, []any{v41}) - tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp50 := tmp49.FindInternedVar(lang.NewSymbol("interpose")) - if tmp50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) - } - tmp51 := tmp50.Get() - tmp52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp53 := tmp52.FindInternedVar(lang.NewSymbol("key")) - if tmp53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp53))) - } - tmp54 := tmp53.Get() - tmp55 := lang.Apply(tmp54, []any{v41}) - tmp56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp57 := tmp56.FindInternedVar(lang.NewSymbol("val")) - if tmp57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp57))) - } - tmp58 := tmp57.Get() - tmp59 := lang.Apply(tmp58, []any{v41}) - tmp60 := lang.Apply(tmp51, []any{tmp55, tmp59}) - tmp61 := lang.Apply(tmp44, []any{tmp48, tmp60}) - return tmp61 - }) - tmp41 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5656), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(5656), lang.NewKeyword("end-column"), int(70)) - tmp42, err := lang.WithMeta(tmp40, tmp41.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp44 := tmp43.FindInternedVar(lang.NewSymbol("seq")) - if tmp44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) - } - tmp45 := tmp44.Get() - tmp46 := lang.Apply(tmp45, []any{v33}) - tmp47 := lang.Apply(tmp39, []any{tmp42, tmp46}) - tmp48 := lang.Apply(tmp36, []any{tmp47}) - var v49 any = tmp48 - _ = v49 - var tmp50 any - tmp51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp52 := tmp51.FindInternedVar(lang.NewSymbol("contains?")) - if tmp52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp52))) - } - tmp53 := tmp52.Get() - tmp54 := lang.Apply(v8, []any{v4}) - tmp55 := lang.Apply(tmp53, []any{tmp54, v5}) - if lang.IsTruthy(tmp55) { - tmp56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp57 := tmp56.FindInternedVar(lang.NewSymbol("reduce1")) - if tmp57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp57))) - } - tmp58 := tmp57.Get() - var tmp59 lang.FnFunc - tmp59 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v60 := args[0] - _ = v60 - v61 := args[1] - _ = v61 - tmp62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp63 := tmp62.FindInternedVar(lang.NewSymbol("apply")) - if tmp63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp63))) - } - tmp64 := tmp63.Get() - tmp65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp66 := tmp65.FindInternedVar(lang.NewSymbol("derive")) - if tmp66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp66))) - } - tmp67 := tmp66.Get() - tmp68 := lang.Apply(tmp64, []any{tmp67, v60, v61}) - return tmp68 - }) - tmp60 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5659), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5659), lang.NewKeyword("end-column"), int(31)) - tmp61, err := lang.WithMeta(tmp59, tmp60.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp63 := tmp62.FindInternedVar(lang.NewSymbol("make-hierarchy")) - if tmp63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp63))) - } - tmp64 := tmp63.Get() - tmp65 := lang.Apply(tmp64, nil) - tmp66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp67 := tmp66.FindInternedVar(lang.NewSymbol("partition")) - if tmp67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp67))) - } - tmp68 := tmp67.Get() - tmp69 := lang.Apply(tmp68, []any{int64(2), v49}) - tmp70 := lang.Apply(tmp58, []any{tmp61, tmp65, tmp69}) - tmp50 = tmp70 - } else { - tmp50 = v3 - } - tmp6 = tmp50 - } // end let - return tmp6 - default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // unquote - { - tmp0 := lang.NewSymbol("unquote").WithMeta(lang.NewMap()).(*lang.Symbol) - tmp1 := ns.Intern(tmp0) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // unquote-splicing - { - tmp0 := lang.NewSymbol("unquote-splicing").WithMeta(lang.NewMap()).(*lang.Symbol) - tmp1 := ns.Intern(tmp0) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // unreduced - { - tmp0 := lang.NewSymbol("unreduced").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "If x is reduced?, returns (deref x), else returns x", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2847), lang.NewKeyword("end-line"), int(2847))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("reduced?")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v3}) - if lang.IsTruthy(tmp8) { - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("deref")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.Apply(tmp11, []any{v3}) - tmp4 = tmp12 - } else { - tmp4 = v3 - } - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // unsigned-bit-shift-right - { - var tmp1 lang.FnFunc - { // function unsigned-bit-shift-right__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("seq")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("concat")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("list")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol(".")}) - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("list")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("list")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("seq")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("concat")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("list")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.Apply(tmp30, []any{lang.NewSymbol("glojure.core/UnsignedShiftRight")}) - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.Apply(tmp34, []any{v3}) - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{v4}) - tmp40 := lang.Apply(tmp27, []any{tmp31, tmp35, tmp39}) - tmp41 := lang.Apply(tmp24, []any{tmp40}) - tmp42 := lang.Apply(tmp21, []any{tmp41}) - tmp43 := lang.Apply(tmp10, []any{tmp14, tmp18, tmp42}) - tmp44 := lang.Apply(tmp7, []any{tmp43}) - return tmp44 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("unsigned-bit-shift-right").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Bitwise shift right, without sign-extension.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(30), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1373), lang.NewKeyword("end-line"), int(1373))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "UnsignedShiftRight") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("UnsignedShiftRight is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // update - { - tmp0 := lang.NewSymbol("update").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f"), lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("z")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("z"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "'Updates' a value in an associative structure, where k is a\n key and f is a function that will take the old value\n and any supplied args and return the new value, and returns a new\n structure. If the key does not exist, nil is passed as the old value.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6174), lang.NewKeyword("end-line"), int(6174))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("assoc")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("get")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.Apply(tmp11, []any{v3, v4}) - tmp13 := lang.Apply(v5, []any{tmp12}) - tmp14 := lang.Apply(tmp8, []any{v3, v4, tmp13}) - return tmp14 - case 4: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("assoc")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("get")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{v3, v4}) - tmp14 := lang.Apply(v5, []any{tmp13, v6}) - tmp15 := lang.Apply(tmp9, []any{v3, v4, tmp14}) - return tmp15 - case 5: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - v7 := args[4] - _ = v7 - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("assoc")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("get")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{v3, v4}) - tmp15 := lang.Apply(v5, []any{tmp14, v6, v7}) - tmp16 := lang.Apply(tmp10, []any{v3, v4, tmp15}) - return tmp16 - case 6: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - v7 := args[4] - _ = v7 - v8 := args[5] - _ = v8 - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("assoc")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("get")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.Apply(tmp14, []any{v3, v4}) - tmp16 := lang.Apply(v5, []any{tmp15, v6, v7, v8}) - tmp17 := lang.Apply(tmp11, []any{v3, v4, tmp16}) - return tmp17 - default: - if len(args) < 6 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - v7 := args[4] - _ = v7 - v8 := args[5] - _ = v8 - var v9 any = lang.NewList(args[6:]...) - _ = v9 - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("assoc")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("apply")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("get")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{v3, v4}) - tmp20 := lang.Apply(tmp15, []any{v5, tmp19, v6, v7, v8, v9}) - tmp21 := lang.Apply(tmp12, []any{v3, v4, tmp20}) - return tmp21 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // update-in - { - tmp0 := lang.NewSymbol("update-in").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("ks"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "'Updates' a value in a nested associative structure, where ks is a\n sequence of keys and f is a function that will take the old value\n and any supplied args and return the new value, and returns a new\n nested structure. If any levels do not exist, hash-maps will be\n created.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6158), lang.NewKeyword("end-line"), int(6158))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any - { // let - // let binding "up" - var tmp8 lang.FnFunc - { // function up - var v9 lang.FnFunc - tmp8 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v10 := args[0] - _ = v10 - v11 := args[1] - _ = v11 - v12 := args[2] - _ = v12 - v13 := args[3] - _ = v13 - var tmp14 any - { // let - // let binding "vec__141" - var v15 any = v11 - _ = v15 - // let binding "seq__142" - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("seq")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, []any{v15}) - var v20 any = tmp19 - _ = v20 - // let binding "first__143" - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("first")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.Apply(tmp23, []any{v20}) - var v25 any = tmp24 - _ = v25 - // let binding "seq__142" - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("next")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.Apply(tmp28, []any{v20}) - var v30 any = tmp29 - _ = v30 - // let binding "k" - var v31 any = v25 - _ = v31 - // let binding "ks" - var v32 any = v30 - _ = v32 - var tmp33 any - if lang.IsTruthy(v32) { - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("assoc")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("get")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.Apply(tmp39, []any{v10, v31}) - tmp41 := lang.Apply(v9, []any{tmp40, v32, v12, v13}) - tmp42 := lang.Apply(tmp36, []any{v10, v31, tmp41}) - tmp33 = tmp42 - } else { - tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp44 := tmp43.FindInternedVar(lang.NewSymbol("assoc")) - if tmp44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) - } - tmp45 := tmp44.Get() - tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp47 := tmp46.FindInternedVar(lang.NewSymbol("apply")) - if tmp47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) - } - tmp48 := tmp47.Get() - tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp50 := tmp49.FindInternedVar(lang.NewSymbol("get")) - if tmp50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) - } - tmp51 := tmp50.Get() - tmp52 := lang.Apply(tmp51, []any{v10, v31}) - tmp53 := lang.Apply(tmp48, []any{v12, tmp52, v13}) - tmp54 := lang.Apply(tmp45, []any{v10, v31, tmp53}) - tmp33 = tmp54 - } - tmp14 = tmp33 - } // end let - return tmp14 - }) - v9 = tmp8 - _ = v9 - } - tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6167), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(6171), lang.NewKeyword("end-column"), int(59)) - tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v11 any = tmp10 - _ = v11 - tmp12 := lang.Apply(v11, []any{v3, v4, v5, v6}) - tmp7 = tmp12 - } // end let - return tmp7 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // update-keys - { - tmp0 := lang.NewSymbol("update-keys").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("f"))), lang.NewKeyword("doc"), "m f => {(f k) v ...}\n\n Given a map m and a function f of 1-argument, returns a new map whose\n keys are the result of applying f to the keys of m, mapped to the\n corresponding values of m.\n f must return a unique key for each key of m, else the behavior is undefined.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7906), lang.NewKeyword("end-line"), int(7906))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - { // let - // let binding "ret" - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("persistent!")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("reduce-kv")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - var tmp12 lang.FnFunc - tmp12 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v13 := args[0] - _ = v13 - v14 := args[1] - _ = v14 - v15 := args[2] - _ = v15 - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("assoc!")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(v4, []any{v14}) - tmp20 := lang.Apply(tmp18, []any{v13, tmp19, v15}) - return tmp20 - }) - tmp13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7916), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7916), lang.NewKeyword("end-column"), int(59)) - tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("transient")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.NewMap() - tmp19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7917), lang.NewKeyword("column"), int(36), lang.NewKeyword("end-line"), int(7917), lang.NewKeyword("end-column"), int(37)) - tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp21 := lang.Apply(tmp17, []any{tmp20}) - tmp22 := lang.Apply(tmp11, []any{tmp14, tmp21, v3}) - tmp23 := lang.Apply(tmp8, []any{tmp22}) - var v24 any = tmp23 - _ = v24 - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("with-meta")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("meta")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.Apply(tmp30, []any{v3}) - tmp32 := lang.Apply(tmp27, []any{v24, tmp31}) - tmp5 = tmp32 - } // end let - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // update-vals - { - tmp0 := lang.NewSymbol("update-vals").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("f"))), lang.NewKeyword("doc"), "m f => {k (f v) ...}\n\n Given a map m and a function f of 1-argument, returns a new map where the keys of m\n are mapped to result of applying f to the corresponding values of m.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7890), lang.NewKeyword("end-line"), int(7890))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("with-meta")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("persistent!")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("reduce-kv")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - var tmp14 lang.FnFunc - tmp14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v15 := args[0] - _ = v15 - v16 := args[1] - _ = v16 - v17 := args[2] - _ = v17 - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("assoc!")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.Apply(v4, []any{v17}) - tmp22 := lang.Apply(tmp20, []any{v15, v16, tmp21}) - return tmp22 - }) - tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7899), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(7899), lang.NewKeyword("end-column"), int(51)) - tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var tmp17 any - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("instance?")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := reflect.TypeOf((*lang.IEditableCollection)(nil)).Elem() - tmp22 := lang.Apply(tmp20, []any{tmp21, v3}) - if lang.IsTruthy(tmp22) { - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("transient")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.Apply(tmp25, []any{v3}) - tmp17 = tmp26 - } else { - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("transient")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.NewMap() - tmp31 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7902), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(7902), lang.NewKeyword("end-column"), int(31)) - tmp32, err := lang.WithMeta(tmp30, tmp31.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp33 := lang.Apply(tmp29, []any{tmp32}) - tmp17 = tmp33 - } - tmp34 := lang.Apply(tmp13, []any{tmp16, tmp17, v3}) - tmp35 := lang.Apply(tmp10, []any{tmp34}) - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("meta")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.Apply(tmp38, []any{v3}) - tmp40 := lang.Apply(tmp7, []any{tmp35, tmp39}) - return tmp40 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // uri? - { - tmp0 := lang.NewSymbol("uri?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a java.net.URI", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7877), lang.NewKeyword("end-line"), int(7877))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := reflect.TypeOf((*url14.URL)(nil)).Elem() - tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) - return tmp8 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // use - { - tmp0 := lang.NewSymbol("use").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Like 'require, but also refers to each lib's namespace using\n glojure.core/refer. Use :use in the ns macro in preference to calling\n this directly.\n\n 'use accepts additional options in libspecs: :exclude, :only, :rename.\n The arguments and semantics for :exclude, :only, and :rename are the same\n as those documented for glojure.core/refer.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6079), lang.NewKeyword("end-line"), int(6079))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - var v3 any = lang.NewList(args[0:]...) - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("apply")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("load-libs")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp6, []any{tmp9, lang.NewKeyword("require"), lang.NewKeyword("use"), v3}) - return tmp10 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // uuid? - { - tmp0 := lang.NewSymbol("uuid?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a java.util.UUID", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6847), lang.NewKeyword("end-line"), int(6847))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := reflect.TypeOf([16]uint8{}) - tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) - return tmp8 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // val - { - tmp0 := lang.NewSymbol("val").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("e"))), lang.NewKeyword("doc"), "Returns the value in the map entry.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1570), lang.NewKeyword("end-line"), int(1570))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4, _ := lang.FieldOrMethod(v3, "GetValue") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("GetValue is not a function"))) - } - tmp5 := lang.Apply(tmp4, []any{}) - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // vals - { - tmp0 := lang.NewSymbol("vals").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"))), lang.NewKeyword("doc"), "Returns a sequence of the map's values, in the same order as (seq map).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1557), lang.NewKeyword("end-line"), int(1557))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.Apply(lang.Vals, []any{v3}) - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // var-get - { - tmp0 := lang.NewSymbol("var-get").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Gets the value in the var object", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4326), lang.NewKeyword("end-line"), int(4326))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4, _ := lang.FieldOrMethod(v3, "Get") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Get is not a function"))) - } - tmp5 := lang.Apply(tmp4, []any{}) - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // var-set - { - tmp0 := lang.NewSymbol("var-set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Sets the value in the var object to val. The var must be\n thread-locally bound.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4332), lang.NewKeyword("end-line"), int(4332))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5, _ := lang.FieldOrMethod(v3, "Set") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Set is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // var? - { - tmp0 := lang.NewSymbol("var?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("v"))), lang.NewKeyword("doc"), "Returns true if v is of type glojure.lang.Var", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4999), lang.NewKeyword("end-line"), int(4999))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := reflect.TypeOf((*lang.Var)(nil)) - tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) - return tmp8 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // vary-meta - { - tmp0 := lang.NewSymbol("vary-meta").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("obj"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Returns an object of the same type and value as obj, with\n (apply f (meta obj) args) as its metadata.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(668), lang.NewKeyword("end-line"), int(668))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("with-meta")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("apply")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("meta")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.Apply(tmp14, []any{v3}) - tmp16 := lang.Apply(tmp11, []any{v4, tmp15, v5}) - tmp17 := lang.Apply(tmp8, []any{v3, tmp16}) - return tmp17 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // vec - { - tmp0 := lang.NewSymbol("vec").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Creates a new vector containing the contents of coll. Java arrays\n will be aliased and should not be modified.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(366), lang.NewKeyword("end-line"), int(366))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("vector?")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.Apply(tmp7, []any{v3}) - if lang.IsTruthy(tmp8) { - var tmp9 any - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("instance?")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := reflect.TypeOf((*lang.IObj)(nil)).Elem() - tmp14 := lang.Apply(tmp12, []any{tmp13, v3}) - if lang.IsTruthy(tmp14) { - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("with-meta")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{v3, nil}) - tmp9 = tmp18 - } else { - tmp19 := lang.Apply(lang.CreateLazilyPersistentVector, []any{v3}) - tmp9 = tmp19 - } - tmp4 = tmp9 - } else { - tmp20 := lang.Apply(lang.CreateLazilyPersistentVector, []any{v3}) - tmp4 = tmp20 - } - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // vector - { - tmp0 := lang.NewSymbol("vector").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("a")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d"), lang.NewSymbol("e")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d"), lang.NewSymbol("e"), lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d"), lang.NewSymbol("e"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Creates a new vector containing the args.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(352), lang.NewKeyword("end-line"), int(352))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp3 := lang.NewVector() - tmp4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(356), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(356), lang.NewKeyword("end-column"), int(8)) - tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp5 - case 1: - v3 := args[0] - _ = v3 - tmp4 := lang.NewVector(v3) - tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(357), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(357), lang.NewKeyword("end-column"), int(10)) - tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp6 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.NewVector(v3, v4) - tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(358), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(358), lang.NewKeyword("end-column"), int(14)) - tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp7 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6 := lang.NewVector(v3, v4, v5) - tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(359), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(359), lang.NewKeyword("end-column"), int(18)) - tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp8 - case 4: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - tmp7 := lang.NewVector(v3, v4, v5, v6) - tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(360), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(360), lang.NewKeyword("end-column"), int(22)) - tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp9 - case 5: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - v7 := args[4] - _ = v7 - tmp8 := lang.NewVector(v3, v4, v5, v6, v7) - tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(361), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(361), lang.NewKeyword("end-column"), int(25)) - tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp10 - case 6: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - v7 := args[4] - _ = v7 - v8 := args[5] - _ = v8 - tmp9 := lang.NewVector(v3, v4, v5, v6, v7, v8) - tmp10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(362), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(362), lang.NewKeyword("end-column"), int(29)) - tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp11 - default: - if len(args) < 6 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - v7 := args[4] - _ = v7 - v8 := args[5] - _ = v8 - var v9 any = lang.NewList(args[6:]...) - _ = v9 - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("cons")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("cons")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("cons")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("cons")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("cons")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("cons")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.Apply(tmp27, []any{v8, v9}) - tmp29 := lang.Apply(tmp24, []any{v7, tmp28}) - tmp30 := lang.Apply(tmp21, []any{v6, tmp29}) - tmp31 := lang.Apply(tmp18, []any{v5, tmp30}) - tmp32 := lang.Apply(tmp15, []any{v4, tmp31}) - tmp33 := lang.Apply(tmp12, []any{v3, tmp32}) - tmp34 := lang.Apply(lang.CreateLazilyPersistentVector, []any{tmp33}) - return tmp34 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // vector? - { - tmp0 := lang.NewSymbol("vector?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x implements IPersistentVector", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(174), lang.NewKeyword("end-line"), int(178))).(*lang.Symbol) - var tmp2 lang.FnFunc - { // function vector? - var v3 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("instance?")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := reflect.TypeOf((*lang.IPersistentVector)(nil)).Elem() - tmp9 := lang.Apply(tmp7, []any{tmp8, v4}) - return tmp9 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(178), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(178), lang.NewKeyword("end-column"), int(106))).(lang.FnFunc) - v3 = tmp2 - _ = v3 - } - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // volatile! - { - tmp1 := reflect.TypeOf((*lang.Volatile)(nil)).Elem() - tmp0 := lang.NewSymbol("volatile!").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Creates and returns a Volatile with an initial value of val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2517), lang.NewKeyword("end-line"), int(2517))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5 := lang.Apply(lang.NewVolatile, []any{v4}) - return tmp5 - }) - tmp4 := reflect.TypeOf((*lang.Volatile)(nil)).Elem() - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // volatile? - { - tmp0 := lang.NewSymbol("volatile?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is a volatile.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2540), lang.NewKeyword("end-line"), int(2540))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("instance?")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := reflect.TypeOf((*lang.Volatile)(nil)).Elem() - tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) - return tmp8 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // vreset! - { - tmp0 := lang.NewSymbol("vreset!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("vol"), lang.NewSymbol("newval"))), lang.NewKeyword("doc"), "Sets the value of volatile to newval without regard for the\n current value. Returns newval.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2524), lang.NewKeyword("end-line"), int(2524))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5, _ := lang.FieldOrMethod(v3, "reset") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // vswap! - { - tmp0 := lang.NewSymbol("vswap!").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("vol"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Non-atomically swaps the value of the volatile as if:\n (apply f current-value-of-vol args). Returns the value that\n was swapped in.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(2531), lang.NewKeyword("end-line"), int(2531))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - var v7 any = lang.NewList(args[4:]...) - _ = v7 - var tmp8 any - { // let - // let binding "v" - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("with-meta")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.NewMap(lang.NewKeyword("tag"), lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Volatile")) - tmp13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2537), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(2537), lang.NewKeyword("end-column"), int(81)) - tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp15 := lang.Apply(tmp11, []any{v5, tmp14}) - var v16 any = tmp15 - _ = v16 - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("concat")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("list")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol(".reset")}) - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{v16}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.Apply(tmp42, []any{v6}) - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp48 := tmp47.FindInternedVar(lang.NewSymbol("seq")) - if tmp48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) - } - tmp49 := tmp48.Get() - tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp51 := tmp50.FindInternedVar(lang.NewSymbol("concat")) - if tmp51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) - } - tmp52 := tmp51.Get() - tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp54 := tmp53.FindInternedVar(lang.NewSymbol("list")) - if tmp54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) - } - tmp55 := tmp54.Get() - tmp56 := lang.Apply(tmp55, []any{lang.NewSymbol(".Deref")}) - tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp58 := tmp57.FindInternedVar(lang.NewSymbol("list")) - if tmp58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) - } - tmp59 := tmp58.Get() - tmp60 := lang.Apply(tmp59, []any{v16}) - tmp61 := lang.Apply(tmp52, []any{tmp56, tmp60}) - tmp62 := lang.Apply(tmp49, []any{tmp61}) - tmp63 := lang.Apply(tmp46, []any{tmp62}) - tmp64 := lang.Apply(tmp39, []any{tmp43, tmp63, v7}) - tmp65 := lang.Apply(tmp36, []any{tmp64}) - tmp66 := lang.Apply(tmp33, []any{tmp65}) - tmp67 := lang.Apply(tmp22, []any{tmp26, tmp30, tmp66}) - tmp68 := lang.Apply(tmp19, []any{tmp67}) - tmp8 = tmp68 - } // end let - return tmp8 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // when - { - tmp0 := lang.NewSymbol("when").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("test"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Evaluates test. If logical true, evaluates body in an implicit do.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(492), lang.NewKeyword("end-line"), int(492))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("list")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("cons")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol("do"), v6}) - tmp14 := lang.Apply(tmp9, []any{lang.NewSymbol("if"), v5, tmp13}) - return tmp14 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // when-first - { - tmp0 := lang.NewSymbol("when-first").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "bindings => x xs\n\n Roughly the same as (when (seq xs) (let [x (first xs)] body)) but xs is evaluated only once", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4622), lang.NewKeyword("end-line"), int(4622))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("vector?")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v5}) - if lang.IsTruthy(tmp11) { - } else { - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("str")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("first")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{v3}) - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("*ns*")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("meta")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.Apply(tmp24, []any{v3}) - tmp26 := lang.Apply(lang.NewKeyword("line"), []any{tmp25}) - tmp27 := lang.Apply(tmp14, []any{tmp18, " requires ", "a vector for its binding", " in ", tmp21, ":", tmp26}) - tmp28 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp27}) - panic(tmp28) - } - _ = tmp7 - var tmp29 any - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("=")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("count")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.Apply(tmp35, []any{v5}) - tmp37 := lang.Apply(tmp32, []any{int64(2), tmp36}) - if lang.IsTruthy(tmp37) { - } else { - tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp39 := tmp38.FindInternedVar(lang.NewSymbol("str")) - if tmp39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) - } - tmp40 := tmp39.Get() - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("first")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.Apply(tmp43, []any{v3}) - tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp46 := tmp45.FindInternedVar(lang.NewSymbol("*ns*")) - if tmp46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) - } - tmp47 := tmp46.Get() - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("meta")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v3}) - tmp52 := lang.Apply(lang.NewKeyword("line"), []any{tmp51}) - tmp53 := lang.Apply(tmp40, []any{tmp44, " requires ", "exactly 2 forms in binding vector", " in ", tmp47, ":", tmp52}) - tmp54 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp53}) - panic(tmp54) - } - _ = tmp29 - var tmp55 any - { // let - // let binding "vec__20" - var v56 any = v5 - _ = v56 - // let binding "x" - tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp58 := tmp57.FindInternedVar(lang.NewSymbol("nth")) - if tmp58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) - } - tmp59 := tmp58.Get() - tmp60 := lang.Apply(tmp59, []any{v56, int64(0), nil}) - var v61 any = tmp60 - _ = v61 - // let binding "xs" - tmp62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp63 := tmp62.FindInternedVar(lang.NewSymbol("nth")) - if tmp63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp63))) - } - tmp64 := tmp63.Get() - tmp65 := lang.Apply(tmp64, []any{v56, int64(1), nil}) - var v66 any = tmp65 - _ = v66 - tmp67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp68 := tmp67.FindInternedVar(lang.NewSymbol("seq")) - if tmp68.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp68))) - } - tmp69 := tmp68.Get() - tmp70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp71 := tmp70.FindInternedVar(lang.NewSymbol("concat")) - if tmp71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp71))) - } - tmp72 := tmp71.Get() - tmp73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp74 := tmp73.FindInternedVar(lang.NewSymbol("list")) - if tmp74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp74))) - } - tmp75 := tmp74.Get() - tmp76 := lang.Apply(tmp75, []any{lang.NewSymbol("glojure.core/when-let")}) - tmp77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp78 := tmp77.FindInternedVar(lang.NewSymbol("list")) - if tmp78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp78))) - } - tmp79 := tmp78.Get() - tmp80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp81 := tmp80.FindInternedVar(lang.NewSymbol("apply")) - if tmp81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp81))) - } - tmp82 := tmp81.Get() - tmp83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp84 := tmp83.FindInternedVar(lang.NewSymbol("vector")) - if tmp84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp84))) - } - tmp85 := tmp84.Get() - tmp86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp87 := tmp86.FindInternedVar(lang.NewSymbol("seq")) - if tmp87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp87))) - } - tmp88 := tmp87.Get() - tmp89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp90 := tmp89.FindInternedVar(lang.NewSymbol("concat")) - if tmp90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp90))) - } - tmp91 := tmp90.Get() - tmp92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp93 := tmp92.FindInternedVar(lang.NewSymbol("list")) - if tmp93.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp93))) - } - tmp94 := tmp93.Get() - tmp95 := lang.Apply(tmp94, []any{lang.NewSymbol("xs__0__auto__")}) - tmp96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp97 := tmp96.FindInternedVar(lang.NewSymbol("list")) - if tmp97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp97))) - } - tmp98 := tmp97.Get() - tmp99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp100 := tmp99.FindInternedVar(lang.NewSymbol("seq")) - if tmp100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp100))) - } - tmp101 := tmp100.Get() - tmp102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp103 := tmp102.FindInternedVar(lang.NewSymbol("concat")) - if tmp103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp103))) - } - tmp104 := tmp103.Get() - tmp105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp106 := tmp105.FindInternedVar(lang.NewSymbol("list")) - if tmp106.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp106))) - } - tmp107 := tmp106.Get() - tmp108 := lang.Apply(tmp107, []any{lang.NewSymbol("glojure.core/seq")}) - tmp109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp110 := tmp109.FindInternedVar(lang.NewSymbol("list")) - if tmp110.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp110))) - } - tmp111 := tmp110.Get() - tmp112 := lang.Apply(tmp111, []any{v66}) - tmp113 := lang.Apply(tmp104, []any{tmp108, tmp112}) - tmp114 := lang.Apply(tmp101, []any{tmp113}) - tmp115 := lang.Apply(tmp98, []any{tmp114}) - tmp116 := lang.Apply(tmp91, []any{tmp95, tmp115}) - tmp117 := lang.Apply(tmp88, []any{tmp116}) - tmp118 := lang.Apply(tmp82, []any{tmp85, tmp117}) - tmp119 := lang.Apply(tmp79, []any{tmp118}) - tmp120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp121 := tmp120.FindInternedVar(lang.NewSymbol("list")) - if tmp121.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp121))) - } - tmp122 := tmp121.Get() - tmp123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp124 := tmp123.FindInternedVar(lang.NewSymbol("seq")) - if tmp124.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp124))) - } - tmp125 := tmp124.Get() - tmp126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp127 := tmp126.FindInternedVar(lang.NewSymbol("concat")) - if tmp127.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp127))) - } - tmp128 := tmp127.Get() - tmp129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp130 := tmp129.FindInternedVar(lang.NewSymbol("list")) - if tmp130.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp130))) - } - tmp131 := tmp130.Get() - tmp132 := lang.Apply(tmp131, []any{lang.NewSymbol("glojure.core/let")}) - tmp133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp134 := tmp133.FindInternedVar(lang.NewSymbol("list")) - if tmp134.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp134))) - } - tmp135 := tmp134.Get() - tmp136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp137 := tmp136.FindInternedVar(lang.NewSymbol("apply")) - if tmp137.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp137))) - } - tmp138 := tmp137.Get() - tmp139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp140 := tmp139.FindInternedVar(lang.NewSymbol("vector")) - if tmp140.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp140))) - } - tmp141 := tmp140.Get() - tmp142 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp143 := tmp142.FindInternedVar(lang.NewSymbol("seq")) - if tmp143.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp143))) - } - tmp144 := tmp143.Get() - tmp145 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp146 := tmp145.FindInternedVar(lang.NewSymbol("concat")) - if tmp146.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp146))) - } - tmp147 := tmp146.Get() - tmp148 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp149 := tmp148.FindInternedVar(lang.NewSymbol("list")) - if tmp149.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp149))) - } - tmp150 := tmp149.Get() - tmp151 := lang.Apply(tmp150, []any{v61}) - tmp152 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp153 := tmp152.FindInternedVar(lang.NewSymbol("list")) - if tmp153.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp153))) - } - tmp154 := tmp153.Get() - tmp155 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp156 := tmp155.FindInternedVar(lang.NewSymbol("seq")) - if tmp156.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp156))) - } - tmp157 := tmp156.Get() - tmp158 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp159 := tmp158.FindInternedVar(lang.NewSymbol("concat")) - if tmp159.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp159))) - } - tmp160 := tmp159.Get() - tmp161 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp162 := tmp161.FindInternedVar(lang.NewSymbol("list")) - if tmp162.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp162))) - } - tmp163 := tmp162.Get() - tmp164 := lang.Apply(tmp163, []any{lang.NewSymbol("glojure.core/first")}) - tmp165 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp166 := tmp165.FindInternedVar(lang.NewSymbol("list")) - if tmp166.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp166))) - } - tmp167 := tmp166.Get() - tmp168 := lang.Apply(tmp167, []any{lang.NewSymbol("xs__0__auto__")}) - tmp169 := lang.Apply(tmp160, []any{tmp164, tmp168}) - tmp170 := lang.Apply(tmp157, []any{tmp169}) - tmp171 := lang.Apply(tmp154, []any{tmp170}) - tmp172 := lang.Apply(tmp147, []any{tmp151, tmp171}) - tmp173 := lang.Apply(tmp144, []any{tmp172}) - tmp174 := lang.Apply(tmp138, []any{tmp141, tmp173}) - tmp175 := lang.Apply(tmp135, []any{tmp174}) - tmp176 := lang.Apply(tmp128, []any{tmp132, tmp175, v6}) - tmp177 := lang.Apply(tmp125, []any{tmp176}) - tmp178 := lang.Apply(tmp122, []any{tmp177}) - tmp179 := lang.Apply(tmp72, []any{tmp76, tmp119, tmp178}) - tmp180 := lang.Apply(tmp69, []any{tmp179}) - tmp55 = tmp180 - } // end let - return tmp55 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // when-let - { - tmp0 := lang.NewSymbol("when-let").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "bindings => binding-form test\n\n When test is true, evaluates body with binding-form bound to the value of test", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1859), lang.NewKeyword("end-line"), int(1859))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("vector?")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v5}) - if lang.IsTruthy(tmp11) { - } else { - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("str")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("first")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{v3}) - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("*ns*")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("meta")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.Apply(tmp24, []any{v3}) - tmp26 := lang.Apply(lang.NewKeyword("line"), []any{tmp25}) - tmp27 := lang.Apply(tmp14, []any{tmp18, " requires ", "a vector for its binding", " in ", tmp21, ":", tmp26}) - tmp28 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp27}) - panic(tmp28) - } - _ = tmp7 - var tmp29 any - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("=")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("count")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.Apply(tmp35, []any{v5}) - tmp37 := lang.Apply(tmp32, []any{int64(2), tmp36}) - if lang.IsTruthy(tmp37) { - } else { - tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp39 := tmp38.FindInternedVar(lang.NewSymbol("str")) - if tmp39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) - } - tmp40 := tmp39.Get() - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("first")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.Apply(tmp43, []any{v3}) - tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp46 := tmp45.FindInternedVar(lang.NewSymbol("*ns*")) - if tmp46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) - } - tmp47 := tmp46.Get() - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("meta")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v3}) - tmp52 := lang.Apply(lang.NewKeyword("line"), []any{tmp51}) - tmp53 := lang.Apply(tmp40, []any{tmp44, " requires ", "exactly 2 forms in binding vector", " in ", tmp47, ":", tmp52}) - tmp54 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp53}) - panic(tmp54) - } - _ = tmp29 - var tmp55 any - { // let - // let binding "form" - tmp56 := lang.Apply(v5, []any{int64(0)}) - var v57 any = tmp56 - _ = v57 - // let binding "tst" - tmp58 := lang.Apply(v5, []any{int64(1)}) - var v59 any = tmp58 - _ = v59 - tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp61 := tmp60.FindInternedVar(lang.NewSymbol("seq")) - if tmp61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) - } - tmp62 := tmp61.Get() - tmp63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp64 := tmp63.FindInternedVar(lang.NewSymbol("concat")) - if tmp64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp64))) - } - tmp65 := tmp64.Get() - tmp66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp67 := tmp66.FindInternedVar(lang.NewSymbol("list")) - if tmp67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp67))) - } - tmp68 := tmp67.Get() - tmp69 := lang.Apply(tmp68, []any{lang.NewSymbol("glojure.core/let")}) - tmp70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp71 := tmp70.FindInternedVar(lang.NewSymbol("list")) - if tmp71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp71))) - } - tmp72 := tmp71.Get() - tmp73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp74 := tmp73.FindInternedVar(lang.NewSymbol("apply")) - if tmp74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp74))) - } - tmp75 := tmp74.Get() - tmp76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp77 := tmp76.FindInternedVar(lang.NewSymbol("vector")) - if tmp77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp77))) - } - tmp78 := tmp77.Get() - tmp79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp80 := tmp79.FindInternedVar(lang.NewSymbol("seq")) - if tmp80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp80))) - } - tmp81 := tmp80.Get() - tmp82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp83 := tmp82.FindInternedVar(lang.NewSymbol("concat")) - if tmp83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp83))) - } - tmp84 := tmp83.Get() - tmp85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp86 := tmp85.FindInternedVar(lang.NewSymbol("list")) - if tmp86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp86))) - } - tmp87 := tmp86.Get() - tmp88 := lang.Apply(tmp87, []any{lang.NewSymbol("temp__0__auto__")}) - tmp89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp90 := tmp89.FindInternedVar(lang.NewSymbol("list")) - if tmp90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp90))) - } - tmp91 := tmp90.Get() - tmp92 := lang.Apply(tmp91, []any{v59}) - tmp93 := lang.Apply(tmp84, []any{tmp88, tmp92}) - tmp94 := lang.Apply(tmp81, []any{tmp93}) - tmp95 := lang.Apply(tmp75, []any{tmp78, tmp94}) - tmp96 := lang.Apply(tmp72, []any{tmp95}) - tmp97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp98 := tmp97.FindInternedVar(lang.NewSymbol("list")) - if tmp98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp98))) - } - tmp99 := tmp98.Get() - tmp100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp101 := tmp100.FindInternedVar(lang.NewSymbol("seq")) - if tmp101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp101))) - } - tmp102 := tmp101.Get() - tmp103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp104 := tmp103.FindInternedVar(lang.NewSymbol("concat")) - if tmp104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp104))) - } - tmp105 := tmp104.Get() - tmp106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp107 := tmp106.FindInternedVar(lang.NewSymbol("list")) - if tmp107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp107))) - } - tmp108 := tmp107.Get() - tmp109 := lang.Apply(tmp108, []any{lang.NewSymbol("glojure.core/when")}) - tmp110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp111 := tmp110.FindInternedVar(lang.NewSymbol("list")) - if tmp111.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp111))) - } - tmp112 := tmp111.Get() - tmp113 := lang.Apply(tmp112, []any{lang.NewSymbol("temp__0__auto__")}) - tmp114 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp115 := tmp114.FindInternedVar(lang.NewSymbol("list")) - if tmp115.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp115))) - } - tmp116 := tmp115.Get() - tmp117 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp118 := tmp117.FindInternedVar(lang.NewSymbol("seq")) - if tmp118.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp118))) - } - tmp119 := tmp118.Get() - tmp120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp121 := tmp120.FindInternedVar(lang.NewSymbol("concat")) - if tmp121.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp121))) - } - tmp122 := tmp121.Get() - tmp123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp124 := tmp123.FindInternedVar(lang.NewSymbol("list")) - if tmp124.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp124))) - } - tmp125 := tmp124.Get() - tmp126 := lang.Apply(tmp125, []any{lang.NewSymbol("glojure.core/let")}) - tmp127 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp128 := tmp127.FindInternedVar(lang.NewSymbol("list")) - if tmp128.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp128))) - } - tmp129 := tmp128.Get() - tmp130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp131 := tmp130.FindInternedVar(lang.NewSymbol("apply")) - if tmp131.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp131))) - } - tmp132 := tmp131.Get() - tmp133 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp134 := tmp133.FindInternedVar(lang.NewSymbol("vector")) - if tmp134.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp134))) - } - tmp135 := tmp134.Get() - tmp136 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp137 := tmp136.FindInternedVar(lang.NewSymbol("seq")) - if tmp137.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp137))) - } - tmp138 := tmp137.Get() - tmp139 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp140 := tmp139.FindInternedVar(lang.NewSymbol("concat")) - if tmp140.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp140))) - } - tmp141 := tmp140.Get() - tmp142 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp143 := tmp142.FindInternedVar(lang.NewSymbol("list")) - if tmp143.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp143))) - } - tmp144 := tmp143.Get() - tmp145 := lang.Apply(tmp144, []any{v57}) - tmp146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp147 := tmp146.FindInternedVar(lang.NewSymbol("list")) - if tmp147.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp147))) - } - tmp148 := tmp147.Get() - tmp149 := lang.Apply(tmp148, []any{lang.NewSymbol("temp__0__auto__")}) - tmp150 := lang.Apply(tmp141, []any{tmp145, tmp149}) - tmp151 := lang.Apply(tmp138, []any{tmp150}) - tmp152 := lang.Apply(tmp132, []any{tmp135, tmp151}) - tmp153 := lang.Apply(tmp129, []any{tmp152}) - tmp154 := lang.Apply(tmp122, []any{tmp126, tmp153, v6}) - tmp155 := lang.Apply(tmp119, []any{tmp154}) - tmp156 := lang.Apply(tmp116, []any{tmp155}) - tmp157 := lang.Apply(tmp105, []any{tmp109, tmp113, tmp156}) - tmp158 := lang.Apply(tmp102, []any{tmp157}) - tmp159 := lang.Apply(tmp99, []any{tmp158}) - tmp160 := lang.Apply(tmp65, []any{tmp69, tmp96, tmp159}) - tmp161 := lang.Apply(tmp62, []any{tmp160}) - tmp55 = tmp161 - } // end let - return tmp55 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // when-not - { - tmp0 := lang.NewSymbol("when-not").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("test"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Evaluates test. If logical false, evaluates body in an implicit do.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(498), lang.NewKeyword("end-line"), int(498))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("list")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("cons")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol("do"), v6}) - tmp14 := lang.Apply(tmp9, []any{lang.NewSymbol("if"), v5, nil, tmp13}) - return tmp14 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // when-some - { - tmp0 := lang.NewSymbol("when-some").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "bindings => binding-form test\n\n When test is not nil, evaluates body with binding-form bound to the\n value of test", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1894), lang.NewKeyword("end-line"), int(1894))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("vector?")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v5}) - if lang.IsTruthy(tmp11) { - } else { - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("str")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("first")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{v3}) - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("*ns*")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("meta")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.Apply(tmp24, []any{v3}) - tmp26 := lang.Apply(lang.NewKeyword("line"), []any{tmp25}) - tmp27 := lang.Apply(tmp14, []any{tmp18, " requires ", "a vector for its binding", " in ", tmp21, ":", tmp26}) - tmp28 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp27}) - panic(tmp28) - } - _ = tmp7 - var tmp29 any - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("=")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("count")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.Apply(tmp35, []any{v5}) - tmp37 := lang.Apply(tmp32, []any{int64(2), tmp36}) - if lang.IsTruthy(tmp37) { - } else { - tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp39 := tmp38.FindInternedVar(lang.NewSymbol("str")) - if tmp39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) - } - tmp40 := tmp39.Get() - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("first")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.Apply(tmp43, []any{v3}) - tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp46 := tmp45.FindInternedVar(lang.NewSymbol("*ns*")) - if tmp46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) - } - tmp47 := tmp46.Get() - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("meta")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v3}) - tmp52 := lang.Apply(lang.NewKeyword("line"), []any{tmp51}) - tmp53 := lang.Apply(tmp40, []any{tmp44, " requires ", "exactly 2 forms in binding vector", " in ", tmp47, ":", tmp52}) - tmp54 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp53}) - panic(tmp54) - } - _ = tmp29 - var tmp55 any - { // let - // let binding "form" - tmp56 := lang.Apply(v5, []any{int64(0)}) - var v57 any = tmp56 - _ = v57 - // let binding "tst" - tmp58 := lang.Apply(v5, []any{int64(1)}) - var v59 any = tmp58 - _ = v59 - tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp61 := tmp60.FindInternedVar(lang.NewSymbol("seq")) - if tmp61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) - } - tmp62 := tmp61.Get() - tmp63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp64 := tmp63.FindInternedVar(lang.NewSymbol("concat")) - if tmp64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp64))) - } - tmp65 := tmp64.Get() - tmp66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp67 := tmp66.FindInternedVar(lang.NewSymbol("list")) - if tmp67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp67))) - } - tmp68 := tmp67.Get() - tmp69 := lang.Apply(tmp68, []any{lang.NewSymbol("glojure.core/let")}) - tmp70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp71 := tmp70.FindInternedVar(lang.NewSymbol("list")) - if tmp71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp71))) - } - tmp72 := tmp71.Get() - tmp73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp74 := tmp73.FindInternedVar(lang.NewSymbol("apply")) - if tmp74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp74))) - } - tmp75 := tmp74.Get() - tmp76 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp77 := tmp76.FindInternedVar(lang.NewSymbol("vector")) - if tmp77.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp77))) - } - tmp78 := tmp77.Get() - tmp79 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp80 := tmp79.FindInternedVar(lang.NewSymbol("seq")) - if tmp80.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp80))) - } - tmp81 := tmp80.Get() - tmp82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp83 := tmp82.FindInternedVar(lang.NewSymbol("concat")) - if tmp83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp83))) - } - tmp84 := tmp83.Get() - tmp85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp86 := tmp85.FindInternedVar(lang.NewSymbol("list")) - if tmp86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp86))) - } - tmp87 := tmp86.Get() - tmp88 := lang.Apply(tmp87, []any{lang.NewSymbol("temp__0__auto__")}) - tmp89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp90 := tmp89.FindInternedVar(lang.NewSymbol("list")) - if tmp90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp90))) - } - tmp91 := tmp90.Get() - tmp92 := lang.Apply(tmp91, []any{v59}) - tmp93 := lang.Apply(tmp84, []any{tmp88, tmp92}) - tmp94 := lang.Apply(tmp81, []any{tmp93}) - tmp95 := lang.Apply(tmp75, []any{tmp78, tmp94}) - tmp96 := lang.Apply(tmp72, []any{tmp95}) - tmp97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp98 := tmp97.FindInternedVar(lang.NewSymbol("list")) - if tmp98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp98))) - } - tmp99 := tmp98.Get() - tmp100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp101 := tmp100.FindInternedVar(lang.NewSymbol("seq")) - if tmp101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp101))) - } - tmp102 := tmp101.Get() - tmp103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp104 := tmp103.FindInternedVar(lang.NewSymbol("concat")) - if tmp104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp104))) - } - tmp105 := tmp104.Get() - tmp106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp107 := tmp106.FindInternedVar(lang.NewSymbol("list")) - if tmp107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp107))) - } - tmp108 := tmp107.Get() - tmp109 := lang.Apply(tmp108, []any{lang.NewSymbol("if")}) - tmp110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp111 := tmp110.FindInternedVar(lang.NewSymbol("list")) - if tmp111.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp111))) - } - tmp112 := tmp111.Get() - tmp113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp114 := tmp113.FindInternedVar(lang.NewSymbol("seq")) - if tmp114.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp114))) - } - tmp115 := tmp114.Get() - tmp116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp117 := tmp116.FindInternedVar(lang.NewSymbol("concat")) - if tmp117.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp117))) - } - tmp118 := tmp117.Get() - tmp119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp120 := tmp119.FindInternedVar(lang.NewSymbol("list")) - if tmp120.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp120))) - } - tmp121 := tmp120.Get() - tmp122 := lang.Apply(tmp121, []any{lang.NewSymbol("glojure.core/nil?")}) - tmp123 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp124 := tmp123.FindInternedVar(lang.NewSymbol("list")) - if tmp124.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp124))) - } - tmp125 := tmp124.Get() - tmp126 := lang.Apply(tmp125, []any{lang.NewSymbol("temp__0__auto__")}) - tmp127 := lang.Apply(tmp118, []any{tmp122, tmp126}) - tmp128 := lang.Apply(tmp115, []any{tmp127}) - tmp129 := lang.Apply(tmp112, []any{tmp128}) - tmp130 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp131 := tmp130.FindInternedVar(lang.NewSymbol("list")) - if tmp131.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp131))) - } - tmp132 := tmp131.Get() - tmp133 := lang.Apply(tmp132, []any{nil}) - tmp134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp135 := tmp134.FindInternedVar(lang.NewSymbol("list")) - if tmp135.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp135))) - } - tmp136 := tmp135.Get() - tmp137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp138 := tmp137.FindInternedVar(lang.NewSymbol("seq")) - if tmp138.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp138))) - } - tmp139 := tmp138.Get() - tmp140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp141 := tmp140.FindInternedVar(lang.NewSymbol("concat")) - if tmp141.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp141))) - } - tmp142 := tmp141.Get() - tmp143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp144 := tmp143.FindInternedVar(lang.NewSymbol("list")) - if tmp144.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp144))) - } - tmp145 := tmp144.Get() - tmp146 := lang.Apply(tmp145, []any{lang.NewSymbol("glojure.core/let")}) - tmp147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp148 := tmp147.FindInternedVar(lang.NewSymbol("list")) - if tmp148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp148))) - } - tmp149 := tmp148.Get() - tmp150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp151 := tmp150.FindInternedVar(lang.NewSymbol("apply")) - if tmp151.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp151))) - } - tmp152 := tmp151.Get() - tmp153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp154 := tmp153.FindInternedVar(lang.NewSymbol("vector")) - if tmp154.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp154))) - } - tmp155 := tmp154.Get() - tmp156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp157 := tmp156.FindInternedVar(lang.NewSymbol("seq")) - if tmp157.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp157))) - } - tmp158 := tmp157.Get() - tmp159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp160 := tmp159.FindInternedVar(lang.NewSymbol("concat")) - if tmp160.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp160))) - } - tmp161 := tmp160.Get() - tmp162 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp163 := tmp162.FindInternedVar(lang.NewSymbol("list")) - if tmp163.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp163))) - } - tmp164 := tmp163.Get() - tmp165 := lang.Apply(tmp164, []any{v57}) - tmp166 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp167 := tmp166.FindInternedVar(lang.NewSymbol("list")) - if tmp167.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp167))) - } - tmp168 := tmp167.Get() - tmp169 := lang.Apply(tmp168, []any{lang.NewSymbol("temp__0__auto__")}) - tmp170 := lang.Apply(tmp161, []any{tmp165, tmp169}) - tmp171 := lang.Apply(tmp158, []any{tmp170}) - tmp172 := lang.Apply(tmp152, []any{tmp155, tmp171}) - tmp173 := lang.Apply(tmp149, []any{tmp172}) - tmp174 := lang.Apply(tmp142, []any{tmp146, tmp173, v6}) - tmp175 := lang.Apply(tmp139, []any{tmp174}) - tmp176 := lang.Apply(tmp136, []any{tmp175}) - tmp177 := lang.Apply(tmp105, []any{tmp109, tmp129, tmp133, tmp176}) - tmp178 := lang.Apply(tmp102, []any{tmp177}) - tmp179 := lang.Apply(tmp99, []any{tmp178}) - tmp180 := lang.Apply(tmp65, []any{tmp69, tmp96, tmp179}) - tmp181 := lang.Apply(tmp62, []any{tmp180}) - tmp55 = tmp181 - } // end let - return tmp55 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // while - { - tmp0 := lang.NewSymbol("while").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("test"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Repeatedly executes body while test expression is true. Presumes\n some side-effect will cause test to become false/nil. Returns nil", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6327), lang.NewKeyword("end-line"), int(6327))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("seq")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("concat")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("list")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("glojure.core/loop")}) - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("list")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("apply")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("vector")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("seq")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("concat")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.Apply(tmp31, nil) - tmp33 := lang.Apply(tmp28, []any{tmp32}) - tmp34 := lang.Apply(tmp22, []any{tmp25, tmp33}) - tmp35 := lang.Apply(tmp19, []any{tmp34}) - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp40 := tmp39.FindInternedVar(lang.NewSymbol("seq")) - if tmp40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) - } - tmp41 := tmp40.Get() - tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp43 := tmp42.FindInternedVar(lang.NewSymbol("concat")) - if tmp43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) - } - tmp44 := tmp43.Get() - tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp46 := tmp45.FindInternedVar(lang.NewSymbol("list")) - if tmp46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) - } - tmp47 := tmp46.Get() - tmp48 := lang.Apply(tmp47, []any{lang.NewSymbol("glojure.core/when")}) - tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp50 := tmp49.FindInternedVar(lang.NewSymbol("list")) - if tmp50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) - } - tmp51 := tmp50.Get() - tmp52 := lang.Apply(tmp51, []any{v5}) - tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp54 := tmp53.FindInternedVar(lang.NewSymbol("list")) - if tmp54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) - } - tmp55 := tmp54.Get() - tmp56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp57 := tmp56.FindInternedVar(lang.NewSymbol("seq")) - if tmp57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp57))) - } - tmp58 := tmp57.Get() - tmp59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp60 := tmp59.FindInternedVar(lang.NewSymbol("concat")) - if tmp60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp60))) - } - tmp61 := tmp60.Get() - tmp62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp63 := tmp62.FindInternedVar(lang.NewSymbol("list")) - if tmp63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp63))) - } - tmp64 := tmp63.Get() - tmp65 := lang.Apply(tmp64, []any{lang.NewSymbol("recur")}) - tmp66 := lang.Apply(tmp61, []any{tmp65}) - tmp67 := lang.Apply(tmp58, []any{tmp66}) - tmp68 := lang.Apply(tmp55, []any{tmp67}) - tmp69 := lang.Apply(tmp44, []any{tmp48, tmp52, v6, tmp68}) - tmp70 := lang.Apply(tmp41, []any{tmp69}) - tmp71 := lang.Apply(tmp38, []any{tmp70}) - tmp72 := lang.Apply(tmp12, []any{tmp16, tmp35, tmp71}) - tmp73 := lang.Apply(tmp9, []any{tmp72}) - return tmp73 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // with-bindings - { - tmp0 := lang.NewSymbol("with-bindings").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("binding-map"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Takes a map of Var/value pairs. Installs for the given Vars the associated\n values as thread-local bindings. Then executes body. Pops the installed\n bindings after body was evaluated. Returns the value of body.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1984), lang.NewKeyword("end-line"), int(1984))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("seq")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("concat")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("list")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("glojure.core/with-bindings*")}) - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("list")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.Apply(tmp19, []any{v5}) - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("list")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("seq")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("concat")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("list")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.Apply(tmp32, []any{lang.NewSymbol("glojure.core/fn")}) - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("list")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("apply")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("vector")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp44 := tmp43.FindInternedVar(lang.NewSymbol("seq")) - if tmp44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) - } - tmp45 := tmp44.Get() - tmp46 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp47 := tmp46.FindInternedVar(lang.NewSymbol("concat")) - if tmp47.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp47))) - } - tmp48 := tmp47.Get() - tmp49 := lang.Apply(tmp48, nil) - tmp50 := lang.Apply(tmp45, []any{tmp49}) - tmp51 := lang.Apply(tmp39, []any{tmp42, tmp50}) - tmp52 := lang.Apply(tmp36, []any{tmp51}) - tmp53 := lang.Apply(tmp29, []any{tmp33, tmp52, v6}) - tmp54 := lang.Apply(tmp26, []any{tmp53}) - tmp55 := lang.Apply(tmp23, []any{tmp54}) - tmp56 := lang.Apply(tmp12, []any{tmp16, tmp20, tmp55}) - tmp57 := lang.Apply(tmp9, []any{tmp56}) - return tmp57 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // with-bindings* - { - tmp0 := lang.NewSymbol("with-bindings*").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("binding-map"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Takes a map of Var/value pairs. Installs for the given Vars the associated\n values as thread-local bindings. Then calls f with the supplied arguments.\n Pops the installed bindings after f returned. Returns whatever f returns.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1971), lang.NewKeyword("end-line"), int(1971))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("push-thread-bindings")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(tmp8, []any{v3}) - _ = tmp9 - var tmp10 any - func() { - defer func() { - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("pop-thread-bindings")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, nil) - _ = tmp14 - }() - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("apply")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{v4, v5}) - tmp10 = tmp18 - }() - return tmp10 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // with-in-str - { - tmp0 := lang.NewSymbol("with-in-str").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Evaluates body in a context in which *in* is bound to a fresh\n StringReader initialized with the string s.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4749), lang.NewKeyword("end-line"), int(4749))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("seq")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("concat")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("list")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("glojure.core/with-open")}) - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("list")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("apply")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("vector")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("seq")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("concat")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("list")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.Apply(tmp34, []any{lang.NewSymbol("s__0__auto__")}) - tmp36 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp37 := tmp36.FindInternedVar(lang.NewSymbol("list")) - if tmp37.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp37))) - } - tmp38 := tmp37.Get() - tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp40 := tmp39.FindInternedVar(lang.NewSymbol("seq")) - if tmp40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) - } - tmp41 := tmp40.Get() - tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp43 := tmp42.FindInternedVar(lang.NewSymbol("concat")) - if tmp43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) - } - tmp44 := tmp43.Get() - tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp46 := tmp45.FindInternedVar(lang.NewSymbol("list")) - if tmp46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) - } - tmp47 := tmp46.Get() - tmp48 := lang.Apply(tmp47, []any{lang.NewSymbol("glojure.core/->")}) - tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp50 := tmp49.FindInternedVar(lang.NewSymbol("list")) - if tmp50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) - } - tmp51 := tmp50.Get() - tmp52 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp53 := tmp52.FindInternedVar(lang.NewSymbol("seq")) - if tmp53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp53))) - } - tmp54 := tmp53.Get() - tmp55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp56 := tmp55.FindInternedVar(lang.NewSymbol("concat")) - if tmp56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp56))) - } - tmp57 := tmp56.Get() - tmp58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp59 := tmp58.FindInternedVar(lang.NewSymbol("list")) - if tmp59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp59))) - } - tmp60 := tmp59.Get() - tmp61 := lang.Apply(tmp60, []any{lang.NewSymbol("java.io.StringReader.")}) - tmp62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp63 := tmp62.FindInternedVar(lang.NewSymbol("list")) - if tmp63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp63))) - } - tmp64 := tmp63.Get() - tmp65 := lang.Apply(tmp64, []any{v5}) - tmp66 := lang.Apply(tmp57, []any{tmp61, tmp65}) - tmp67 := lang.Apply(tmp54, []any{tmp66}) - tmp68 := lang.Apply(tmp51, []any{tmp67}) - tmp69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp70 := tmp69.FindInternedVar(lang.NewSymbol("list")) - if tmp70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp70))) - } - tmp71 := tmp70.Get() - tmp72 := lang.Apply(tmp71, []any{lang.NewSymbol("glojure.lang.LineNumberingPushbackReader.")}) - tmp73 := lang.Apply(tmp44, []any{tmp48, tmp68, tmp72}) - tmp74 := lang.Apply(tmp41, []any{tmp73}) - tmp75 := lang.Apply(tmp38, []any{tmp74}) - tmp76 := lang.Apply(tmp31, []any{tmp35, tmp75}) - tmp77 := lang.Apply(tmp28, []any{tmp76}) - tmp78 := lang.Apply(tmp22, []any{tmp25, tmp77}) - tmp79 := lang.Apply(tmp19, []any{tmp78}) - tmp80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp81 := tmp80.FindInternedVar(lang.NewSymbol("list")) - if tmp81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp81))) - } - tmp82 := tmp81.Get() - tmp83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp84 := tmp83.FindInternedVar(lang.NewSymbol("seq")) - if tmp84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp84))) - } - tmp85 := tmp84.Get() - tmp86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp87 := tmp86.FindInternedVar(lang.NewSymbol("concat")) - if tmp87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp87))) - } - tmp88 := tmp87.Get() - tmp89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp90 := tmp89.FindInternedVar(lang.NewSymbol("list")) - if tmp90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp90))) - } - tmp91 := tmp90.Get() - tmp92 := lang.Apply(tmp91, []any{lang.NewSymbol("glojure.core/binding")}) - tmp93 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp94 := tmp93.FindInternedVar(lang.NewSymbol("list")) - if tmp94.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp94))) - } - tmp95 := tmp94.Get() - tmp96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp97 := tmp96.FindInternedVar(lang.NewSymbol("apply")) - if tmp97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp97))) - } - tmp98 := tmp97.Get() - tmp99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp100 := tmp99.FindInternedVar(lang.NewSymbol("vector")) - if tmp100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp100))) - } - tmp101 := tmp100.Get() - tmp102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp103 := tmp102.FindInternedVar(lang.NewSymbol("seq")) - if tmp103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp103))) - } - tmp104 := tmp103.Get() - tmp105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp106 := tmp105.FindInternedVar(lang.NewSymbol("concat")) - if tmp106.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp106))) - } - tmp107 := tmp106.Get() - tmp108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp109 := tmp108.FindInternedVar(lang.NewSymbol("list")) - if tmp109.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp109))) - } - tmp110 := tmp109.Get() - tmp111 := lang.Apply(tmp110, []any{lang.NewSymbol("glojure.core/*in*")}) - tmp112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp113 := tmp112.FindInternedVar(lang.NewSymbol("list")) - if tmp113.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp113))) - } - tmp114 := tmp113.Get() - tmp115 := lang.Apply(tmp114, []any{lang.NewSymbol("s__0__auto__")}) - tmp116 := lang.Apply(tmp107, []any{tmp111, tmp115}) - tmp117 := lang.Apply(tmp104, []any{tmp116}) - tmp118 := lang.Apply(tmp98, []any{tmp101, tmp117}) - tmp119 := lang.Apply(tmp95, []any{tmp118}) - tmp120 := lang.Apply(tmp88, []any{tmp92, tmp119, v6}) - tmp121 := lang.Apply(tmp85, []any{tmp120}) - tmp122 := lang.Apply(tmp82, []any{tmp121}) - tmp123 := lang.Apply(tmp12, []any{tmp16, tmp79, tmp122}) - tmp124 := lang.Apply(tmp9, []any{tmp123}) - return tmp124 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // with-loading-context - { - tmp0 := lang.NewSymbol("with-loading-context").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5734), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5734), lang.NewKeyword("end-column"), int(30), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("macro"), true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("seq")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("concat")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("list")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("seq")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("concat")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("list")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.Apply(tmp23, []any{lang.NewSymbol("glojure.core/fn")}) - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("list")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.Apply(tmp27, []any{lang.NewSymbol("loading__0__auto__")}) - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("list")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp33 := tmp32.FindInternedVar(lang.NewSymbol("apply")) - if tmp33.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp33))) - } - tmp34 := tmp33.Get() - tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp36 := tmp35.FindInternedVar(lang.NewSymbol("vector")) - if tmp36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) - } - tmp37 := tmp36.Get() - tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp39 := tmp38.FindInternedVar(lang.NewSymbol("seq")) - if tmp39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) - } - tmp40 := tmp39.Get() - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("concat")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.Apply(tmp43, nil) - tmp45 := lang.Apply(tmp40, []any{tmp44}) - tmp46 := lang.Apply(tmp34, []any{tmp37, tmp45}) - tmp47 := lang.Apply(tmp31, []any{tmp46}) - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp52 := tmp51.FindInternedVar(lang.NewSymbol("seq")) - if tmp52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp52))) - } - tmp53 := tmp52.Get() - tmp54 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp55 := tmp54.FindInternedVar(lang.NewSymbol("concat")) - if tmp55.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp55))) - } - tmp56 := tmp55.Get() - tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp58 := tmp57.FindInternedVar(lang.NewSymbol("list")) - if tmp58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) - } - tmp59 := tmp58.Get() - tmp60 := lang.Apply(tmp59, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.PushThreadBindings")}) - tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp62 := tmp61.FindInternedVar(lang.NewSymbol("list")) - if tmp62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) - } - tmp63 := tmp62.Get() - tmp64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp65 := tmp64.FindInternedVar(lang.NewSymbol("apply")) - if tmp65.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp65))) - } - tmp66 := tmp65.Get() - tmp67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp68 := tmp67.FindInternedVar(lang.NewSymbol("hash-map")) - if tmp68.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp68))) - } - tmp69 := tmp68.Get() - tmp70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp71 := tmp70.FindInternedVar(lang.NewSymbol("seq")) - if tmp71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp71))) - } - tmp72 := tmp71.Get() - tmp73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp74 := tmp73.FindInternedVar(lang.NewSymbol("concat")) - if tmp74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp74))) - } - tmp75 := tmp74.Get() - tmp76 := lang.Apply(tmp75, nil) - tmp77 := lang.Apply(tmp72, []any{tmp76}) - tmp78 := lang.Apply(tmp66, []any{tmp69, tmp77}) - tmp79 := lang.Apply(tmp63, []any{tmp78}) - tmp80 := lang.Apply(tmp56, []any{tmp60, tmp79}) - tmp81 := lang.Apply(tmp53, []any{tmp80}) - tmp82 := lang.Apply(tmp50, []any{tmp81}) - tmp83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp84 := tmp83.FindInternedVar(lang.NewSymbol("list")) - if tmp84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp84))) - } - tmp85 := tmp84.Get() - tmp86 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp87 := tmp86.FindInternedVar(lang.NewSymbol("seq")) - if tmp87.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp87))) - } - tmp88 := tmp87.Get() - tmp89 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp90 := tmp89.FindInternedVar(lang.NewSymbol("concat")) - if tmp90.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp90))) - } - tmp91 := tmp90.Get() - tmp92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp93 := tmp92.FindInternedVar(lang.NewSymbol("list")) - if tmp93.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp93))) - } - tmp94 := tmp93.Get() - tmp95 := lang.Apply(tmp94, []any{lang.NewSymbol("try")}) - tmp96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp97 := tmp96.FindInternedVar(lang.NewSymbol("list")) - if tmp97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp97))) - } - tmp98 := tmp97.Get() - tmp99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp100 := tmp99.FindInternedVar(lang.NewSymbol("seq")) - if tmp100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp100))) - } - tmp101 := tmp100.Get() - tmp102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp103 := tmp102.FindInternedVar(lang.NewSymbol("concat")) - if tmp103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp103))) - } - tmp104 := tmp103.Get() - tmp105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp106 := tmp105.FindInternedVar(lang.NewSymbol("list")) - if tmp106.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp106))) - } - tmp107 := tmp106.Get() - tmp108 := lang.Apply(tmp107, []any{lang.NewSymbol("finally")}) - tmp109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp110 := tmp109.FindInternedVar(lang.NewSymbol("list")) - if tmp110.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp110))) - } - tmp111 := tmp110.Get() - tmp112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp113 := tmp112.FindInternedVar(lang.NewSymbol("seq")) - if tmp113.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp113))) - } - tmp114 := tmp113.Get() - tmp115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp116 := tmp115.FindInternedVar(lang.NewSymbol("concat")) - if tmp116.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp116))) - } - tmp117 := tmp116.Get() - tmp118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp119 := tmp118.FindInternedVar(lang.NewSymbol("list")) - if tmp119.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp119))) - } - tmp120 := tmp119.Get() - tmp121 := lang.Apply(tmp120, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.PopThreadBindings")}) - tmp122 := lang.Apply(tmp117, []any{tmp121}) - tmp123 := lang.Apply(tmp114, []any{tmp122}) - tmp124 := lang.Apply(tmp111, []any{tmp123}) - tmp125 := lang.Apply(tmp104, []any{tmp108, tmp124}) - tmp126 := lang.Apply(tmp101, []any{tmp125}) - tmp127 := lang.Apply(tmp98, []any{tmp126}) - tmp128 := lang.Apply(tmp91, []any{tmp95, v5, tmp127}) - tmp129 := lang.Apply(tmp88, []any{tmp128}) - tmp130 := lang.Apply(tmp85, []any{tmp129}) - tmp131 := lang.Apply(tmp20, []any{tmp24, tmp28, tmp47, tmp82, tmp130}) - tmp132 := lang.Apply(tmp17, []any{tmp131}) - tmp133 := lang.Apply(tmp14, []any{tmp132}) - tmp134 := lang.Apply(tmp11, []any{tmp133}) - tmp135 := lang.Apply(tmp8, []any{tmp134}) - return tmp135 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // with-local-vars - { - tmp0 := lang.NewSymbol("with-local-vars").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name-vals-vec"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "varbinding=> symbol init-expr\n\n Executes the exprs in a context in which the symbols are bound to\n vars with per-thread bindings to the init-exprs. The symbols refer\n to the var objects themselves, and must be accessed with var-get and\n var-set", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4339), lang.NewKeyword("end-line"), int(4339))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("vector?")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v5}) - if lang.IsTruthy(tmp11) { - } else { - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("str")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("first")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{v3}) - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("*ns*")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("meta")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.Apply(tmp24, []any{v3}) - tmp26 := lang.Apply(lang.NewKeyword("line"), []any{tmp25}) - tmp27 := lang.Apply(tmp14, []any{tmp18, " requires ", "a vector for its binding", " in ", tmp21, ":", tmp26}) - tmp28 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp27}) - panic(tmp28) - } - _ = tmp7 - var tmp29 any - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("even?")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("count")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.Apply(tmp35, []any{v5}) - tmp37 := lang.Apply(tmp32, []any{tmp36}) - if lang.IsTruthy(tmp37) { - } else { - tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp39 := tmp38.FindInternedVar(lang.NewSymbol("str")) - if tmp39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) - } - tmp40 := tmp39.Get() - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("first")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.Apply(tmp43, []any{v3}) - tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp46 := tmp45.FindInternedVar(lang.NewSymbol("*ns*")) - if tmp46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) - } - tmp47 := tmp46.Get() - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("meta")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v3}) - tmp52 := lang.Apply(lang.NewKeyword("line"), []any{tmp51}) - tmp53 := lang.Apply(tmp40, []any{tmp44, " requires ", "an even number of forms in binding vector", " in ", tmp47, ":", tmp52}) - tmp54 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp53}) - panic(tmp54) - } - _ = tmp29 - tmp55 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp56 := tmp55.FindInternedVar(lang.NewSymbol("seq")) - if tmp56.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp56))) - } - tmp57 := tmp56.Get() - tmp58 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp59 := tmp58.FindInternedVar(lang.NewSymbol("concat")) - if tmp59.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp59))) - } - tmp60 := tmp59.Get() - tmp61 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp62 := tmp61.FindInternedVar(lang.NewSymbol("list")) - if tmp62.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp62))) - } - tmp63 := tmp62.Get() - tmp64 := lang.Apply(tmp63, []any{lang.NewSymbol("glojure.core/let")}) - tmp65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp66 := tmp65.FindInternedVar(lang.NewSymbol("list")) - if tmp66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp66))) - } - tmp67 := tmp66.Get() - tmp68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp69 := tmp68.FindInternedVar(lang.NewSymbol("apply")) - if tmp69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp69))) - } - tmp70 := tmp69.Get() - tmp71 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp72 := tmp71.FindInternedVar(lang.NewSymbol("vector")) - if tmp72.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp72))) - } - tmp73 := tmp72.Get() - tmp74 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp75 := tmp74.FindInternedVar(lang.NewSymbol("seq")) - if tmp75.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp75))) - } - tmp76 := tmp75.Get() - tmp77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp78 := tmp77.FindInternedVar(lang.NewSymbol("concat")) - if tmp78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp78))) - } - tmp79 := tmp78.Get() - tmp80 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp81 := tmp80.FindInternedVar(lang.NewSymbol("interleave")) - if tmp81.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp81))) - } - tmp82 := tmp81.Get() - tmp83 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp84 := tmp83.FindInternedVar(lang.NewSymbol("take-nth")) - if tmp84.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp84))) - } - tmp85 := tmp84.Get() - tmp86 := lang.Apply(tmp85, []any{int64(2), v5}) - tmp87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp88 := tmp87.FindInternedVar(lang.NewSymbol("repeat")) - if tmp88.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp88))) - } - tmp89 := tmp88.Get() - tmp90 := lang.Apply(tmp89, []any{lang.NewList(lang.NewSymbol(".."), lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.*Var"), lang.NewSymbol("create"), lang.NewSymbol("setDynamic"))}) - tmp91 := lang.Apply(tmp82, []any{tmp86, tmp90}) - tmp92 := lang.Apply(tmp79, []any{tmp91}) - tmp93 := lang.Apply(tmp76, []any{tmp92}) - tmp94 := lang.Apply(tmp70, []any{tmp73, tmp93}) - tmp95 := lang.Apply(tmp67, []any{tmp94}) - tmp96 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp97 := tmp96.FindInternedVar(lang.NewSymbol("list")) - if tmp97.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp97))) - } - tmp98 := tmp97.Get() - tmp99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp100 := tmp99.FindInternedVar(lang.NewSymbol("seq")) - if tmp100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp100))) - } - tmp101 := tmp100.Get() - tmp102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp103 := tmp102.FindInternedVar(lang.NewSymbol("concat")) - if tmp103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp103))) - } - tmp104 := tmp103.Get() - tmp105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp106 := tmp105.FindInternedVar(lang.NewSymbol("list")) - if tmp106.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp106))) - } - tmp107 := tmp106.Get() - tmp108 := lang.Apply(tmp107, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.PushThreadBindings")}) - tmp109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp110 := tmp109.FindInternedVar(lang.NewSymbol("list")) - if tmp110.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp110))) - } - tmp111 := tmp110.Get() - tmp112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp113 := tmp112.FindInternedVar(lang.NewSymbol("apply")) - if tmp113.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp113))) - } - tmp114 := tmp113.Get() - tmp115 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp116 := tmp115.FindInternedVar(lang.NewSymbol("hash-map")) - if tmp116.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp116))) - } - tmp117 := tmp116.Get() - tmp118 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp119 := tmp118.FindInternedVar(lang.NewSymbol("seq")) - if tmp119.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp119))) - } - tmp120 := tmp119.Get() - tmp121 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp122 := tmp121.FindInternedVar(lang.NewSymbol("concat")) - if tmp122.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp122))) - } - tmp123 := tmp122.Get() - tmp124 := lang.Apply(tmp123, nil) - tmp125 := lang.Apply(tmp120, []any{tmp124}) - tmp126 := lang.Apply(tmp114, []any{tmp117, tmp125}) - tmp127 := lang.Apply(tmp111, []any{tmp126}) - tmp128 := lang.Apply(tmp104, []any{tmp108, tmp127}) - tmp129 := lang.Apply(tmp101, []any{tmp128}) - tmp130 := lang.Apply(tmp98, []any{tmp129}) - tmp131 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp132 := tmp131.FindInternedVar(lang.NewSymbol("list")) - if tmp132.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp132))) - } - tmp133 := tmp132.Get() - tmp134 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp135 := tmp134.FindInternedVar(lang.NewSymbol("seq")) - if tmp135.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp135))) - } - tmp136 := tmp135.Get() - tmp137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp138 := tmp137.FindInternedVar(lang.NewSymbol("concat")) - if tmp138.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp138))) - } - tmp139 := tmp138.Get() - tmp140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp141 := tmp140.FindInternedVar(lang.NewSymbol("list")) - if tmp141.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp141))) - } - tmp142 := tmp141.Get() - tmp143 := lang.Apply(tmp142, []any{lang.NewSymbol("try")}) - tmp144 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp145 := tmp144.FindInternedVar(lang.NewSymbol("list")) - if tmp145.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp145))) - } - tmp146 := tmp145.Get() - tmp147 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp148 := tmp147.FindInternedVar(lang.NewSymbol("seq")) - if tmp148.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp148))) - } - tmp149 := tmp148.Get() - tmp150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp151 := tmp150.FindInternedVar(lang.NewSymbol("concat")) - if tmp151.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp151))) - } - tmp152 := tmp151.Get() - tmp153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp154 := tmp153.FindInternedVar(lang.NewSymbol("list")) - if tmp154.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp154))) - } - tmp155 := tmp154.Get() - tmp156 := lang.Apply(tmp155, []any{lang.NewSymbol("finally")}) - tmp157 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp158 := tmp157.FindInternedVar(lang.NewSymbol("list")) - if tmp158.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp158))) - } - tmp159 := tmp158.Get() - tmp160 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp161 := tmp160.FindInternedVar(lang.NewSymbol("seq")) - if tmp161.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp161))) - } - tmp162 := tmp161.Get() - tmp163 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp164 := tmp163.FindInternedVar(lang.NewSymbol("concat")) - if tmp164.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp164))) - } - tmp165 := tmp164.Get() - tmp166 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp167 := tmp166.FindInternedVar(lang.NewSymbol("list")) - if tmp167.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp167))) - } - tmp168 := tmp167.Get() - tmp169 := lang.Apply(tmp168, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.PopThreadBindings")}) - tmp170 := lang.Apply(tmp165, []any{tmp169}) - tmp171 := lang.Apply(tmp162, []any{tmp170}) - tmp172 := lang.Apply(tmp159, []any{tmp171}) - tmp173 := lang.Apply(tmp152, []any{tmp156, tmp172}) - tmp174 := lang.Apply(tmp149, []any{tmp173}) - tmp175 := lang.Apply(tmp146, []any{tmp174}) - tmp176 := lang.Apply(tmp139, []any{tmp143, v6, tmp175}) - tmp177 := lang.Apply(tmp136, []any{tmp176}) - tmp178 := lang.Apply(tmp133, []any{tmp177}) - tmp179 := lang.Apply(tmp60, []any{tmp64, tmp95, tmp130, tmp178}) - tmp180 := lang.Apply(tmp57, []any{tmp179}) - return tmp180 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // with-meta - { - tmp0 := lang.NewSymbol("with-meta").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("obj"), lang.NewSymbol("m"))), lang.NewKeyword("doc"), "Returns an object of the same type and value as obj, with\n map m as its metadata.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(211), lang.NewKeyword("end-line"), int(216))).(*lang.Symbol) - var tmp2 lang.FnFunc - { // function with-meta - var v3 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6, _ := lang.FieldOrMethod(v4, "WithMeta") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("WithMeta is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v5}) - return tmp7 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(216), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(217), lang.NewKeyword("end-column"), int(32))).(lang.FnFunc) - v3 = tmp2 - _ = v3 - } - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // with-open - { - tmp0 := lang.NewSymbol("with-open").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "bindings => [name init ...]\n\n Evaluates body in a try expression with names bound to the values\n of the inits, and a finally clause that calls (.close name) on each\n name in reverse order.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3832), lang.NewKeyword("end-line"), int(3832))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("vector?")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.Apply(tmp10, []any{v5}) - if lang.IsTruthy(tmp11) { - } else { - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("str")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp16 := tmp15.FindInternedVar(lang.NewSymbol("first")) - if tmp16.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp16))) - } - tmp17 := tmp16.Get() - tmp18 := lang.Apply(tmp17, []any{v3}) - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("*ns*")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("meta")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.Apply(tmp24, []any{v3}) - tmp26 := lang.Apply(lang.NewKeyword("line"), []any{tmp25}) - tmp27 := lang.Apply(tmp14, []any{tmp18, " requires ", "a vector for its binding", " in ", tmp21, ":", tmp26}) - tmp28 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp27}) - panic(tmp28) - } - _ = tmp7 - var tmp29 any - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("even?")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("count")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.Apply(tmp35, []any{v5}) - tmp37 := lang.Apply(tmp32, []any{tmp36}) - if lang.IsTruthy(tmp37) { - } else { - tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp39 := tmp38.FindInternedVar(lang.NewSymbol("str")) - if tmp39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) - } - tmp40 := tmp39.Get() - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("first")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.Apply(tmp43, []any{v3}) - tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp46 := tmp45.FindInternedVar(lang.NewSymbol("*ns*")) - if tmp46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) - } - tmp47 := tmp46.Get() - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("meta")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{v3}) - tmp52 := lang.Apply(lang.NewKeyword("line"), []any{tmp51}) - tmp53 := lang.Apply(tmp40, []any{tmp44, " requires ", "an even number of forms in binding vector", " in ", tmp47, ":", tmp52}) - tmp54 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp53}) - panic(tmp54) - } - _ = tmp29 - var tmp55 any - tmp56 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp57 := tmp56.FindInternedVar(lang.NewSymbol("=")) - if tmp57.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp57))) - } - tmp58 := tmp57.Get() - tmp59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp60 := tmp59.FindInternedVar(lang.NewSymbol("count")) - if tmp60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp60))) - } - tmp61 := tmp60.Get() - tmp62 := lang.Apply(tmp61, []any{v5}) - tmp63 := lang.Apply(tmp58, []any{tmp62, int64(0)}) - if lang.IsTruthy(tmp63) { - tmp64 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp65 := tmp64.FindInternedVar(lang.NewSymbol("seq")) - if tmp65.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp65))) - } - tmp66 := tmp65.Get() - tmp67 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp68 := tmp67.FindInternedVar(lang.NewSymbol("concat")) - if tmp68.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp68))) - } - tmp69 := tmp68.Get() - tmp70 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp71 := tmp70.FindInternedVar(lang.NewSymbol("list")) - if tmp71.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp71))) - } - tmp72 := tmp71.Get() - tmp73 := lang.Apply(tmp72, []any{lang.NewSymbol("do")}) - tmp74 := lang.Apply(tmp69, []any{tmp73, v6}) - tmp75 := lang.Apply(tmp66, []any{tmp74}) - tmp55 = tmp75 - } else { - var tmp76 any - tmp77 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp78 := tmp77.FindInternedVar(lang.NewSymbol("symbol?")) - if tmp78.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp78))) - } - tmp79 := tmp78.Get() - tmp80 := lang.Apply(v5, []any{int64(0)}) - tmp81 := lang.Apply(tmp79, []any{tmp80}) - if lang.IsTruthy(tmp81) { - tmp82 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp83 := tmp82.FindInternedVar(lang.NewSymbol("seq")) - if tmp83.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp83))) - } - tmp84 := tmp83.Get() - tmp85 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp86 := tmp85.FindInternedVar(lang.NewSymbol("concat")) - if tmp86.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp86))) - } - tmp87 := tmp86.Get() - tmp88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp89 := tmp88.FindInternedVar(lang.NewSymbol("list")) - if tmp89.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp89))) - } - tmp90 := tmp89.Get() - tmp91 := lang.Apply(tmp90, []any{lang.NewSymbol("glojure.core/let")}) - tmp92 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp93 := tmp92.FindInternedVar(lang.NewSymbol("list")) - if tmp93.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp93))) - } - tmp94 := tmp93.Get() - tmp95 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp96 := tmp95.FindInternedVar(lang.NewSymbol("subvec")) - if tmp96.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp96))) - } - tmp97 := tmp96.Get() - tmp98 := lang.Apply(tmp97, []any{v5, int64(0), int64(2)}) - tmp99 := lang.Apply(tmp94, []any{tmp98}) - tmp100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp101 := tmp100.FindInternedVar(lang.NewSymbol("list")) - if tmp101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp101))) - } - tmp102 := tmp101.Get() - tmp103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp104 := tmp103.FindInternedVar(lang.NewSymbol("seq")) - if tmp104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp104))) - } - tmp105 := tmp104.Get() - tmp106 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp107 := tmp106.FindInternedVar(lang.NewSymbol("concat")) - if tmp107.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp107))) - } - tmp108 := tmp107.Get() - tmp109 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp110 := tmp109.FindInternedVar(lang.NewSymbol("list")) - if tmp110.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp110))) - } - tmp111 := tmp110.Get() - tmp112 := lang.Apply(tmp111, []any{lang.NewSymbol("try")}) - tmp113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp114 := tmp113.FindInternedVar(lang.NewSymbol("list")) - if tmp114.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp114))) - } - tmp115 := tmp114.Get() - tmp116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp117 := tmp116.FindInternedVar(lang.NewSymbol("seq")) - if tmp117.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp117))) - } - tmp118 := tmp117.Get() - tmp119 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp120 := tmp119.FindInternedVar(lang.NewSymbol("concat")) - if tmp120.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp120))) - } - tmp121 := tmp120.Get() - tmp122 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp123 := tmp122.FindInternedVar(lang.NewSymbol("list")) - if tmp123.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp123))) - } - tmp124 := tmp123.Get() - tmp125 := lang.Apply(tmp124, []any{lang.NewSymbol("glojure.core/with-open")}) - tmp126 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp127 := tmp126.FindInternedVar(lang.NewSymbol("list")) - if tmp127.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp127))) - } - tmp128 := tmp127.Get() - tmp129 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp130 := tmp129.FindInternedVar(lang.NewSymbol("subvec")) - if tmp130.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp130))) - } - tmp131 := tmp130.Get() - tmp132 := lang.Apply(tmp131, []any{v5, int64(2)}) - tmp133 := lang.Apply(tmp128, []any{tmp132}) - tmp134 := lang.Apply(tmp121, []any{tmp125, tmp133, v6}) - tmp135 := lang.Apply(tmp118, []any{tmp134}) - tmp136 := lang.Apply(tmp115, []any{tmp135}) - tmp137 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp138 := tmp137.FindInternedVar(lang.NewSymbol("list")) - if tmp138.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp138))) - } - tmp139 := tmp138.Get() - tmp140 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp141 := tmp140.FindInternedVar(lang.NewSymbol("seq")) - if tmp141.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp141))) - } - tmp142 := tmp141.Get() - tmp143 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp144 := tmp143.FindInternedVar(lang.NewSymbol("concat")) - if tmp144.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp144))) - } - tmp145 := tmp144.Get() - tmp146 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp147 := tmp146.FindInternedVar(lang.NewSymbol("list")) - if tmp147.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp147))) - } - tmp148 := tmp147.Get() - tmp149 := lang.Apply(tmp148, []any{lang.NewSymbol("finally")}) - tmp150 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp151 := tmp150.FindInternedVar(lang.NewSymbol("list")) - if tmp151.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp151))) - } - tmp152 := tmp151.Get() - tmp153 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp154 := tmp153.FindInternedVar(lang.NewSymbol("seq")) - if tmp154.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp154))) - } - tmp155 := tmp154.Get() - tmp156 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp157 := tmp156.FindInternedVar(lang.NewSymbol("concat")) - if tmp157.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp157))) - } - tmp158 := tmp157.Get() - tmp159 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp160 := tmp159.FindInternedVar(lang.NewSymbol("list")) - if tmp160.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp160))) - } - tmp161 := tmp160.Get() - tmp162 := lang.Apply(tmp161, []any{lang.NewSymbol(".")}) - tmp163 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp164 := tmp163.FindInternedVar(lang.NewSymbol("list")) - if tmp164.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp164))) - } - tmp165 := tmp164.Get() - tmp166 := lang.Apply(v5, []any{int64(0)}) - tmp167 := lang.Apply(tmp165, []any{tmp166}) - tmp168 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp169 := tmp168.FindInternedVar(lang.NewSymbol("list")) - if tmp169.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp169))) - } - tmp170 := tmp169.Get() - tmp171 := lang.Apply(tmp170, []any{lang.NewSymbol("close")}) - tmp172 := lang.Apply(tmp158, []any{tmp162, tmp167, tmp171}) - tmp173 := lang.Apply(tmp155, []any{tmp172}) - tmp174 := lang.Apply(tmp152, []any{tmp173}) - tmp175 := lang.Apply(tmp145, []any{tmp149, tmp174}) - tmp176 := lang.Apply(tmp142, []any{tmp175}) - tmp177 := lang.Apply(tmp139, []any{tmp176}) - tmp178 := lang.Apply(tmp108, []any{tmp112, tmp136, tmp177}) - tmp179 := lang.Apply(tmp105, []any{tmp178}) - tmp180 := lang.Apply(tmp102, []any{tmp179}) - tmp181 := lang.Apply(tmp87, []any{tmp91, tmp99, tmp180}) - tmp182 := lang.Apply(tmp84, []any{tmp181}) - tmp76 = tmp182 - } else { - var tmp183 any - if lang.IsTruthy(lang.NewKeyword("else")) { - tmp184 := lang.Apply(lang.NewIllegalArgumentError, []any{"with-open only allows Symbols in bindings"}) - panic(tmp184) - } else { - } - tmp76 = tmp183 - } - tmp55 = tmp76 - } - return tmp55 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // with-out-str - { - tmp0 := lang.NewSymbol("with-out-str").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Evaluates exprs in a context in which *out* is bound to a fresh\n StringWriter. Returns the string created by any nested printing\n calls.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4738), lang.NewKeyword("end-line"), int(4738))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("seq")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("concat")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("list")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("glojure.core/let")}) - tmp16 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("list")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("apply")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("vector")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("seq")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("concat")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{lang.NewSymbol("s__0__auto__")}) - tmp35 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp36 := tmp35.FindInternedVar(lang.NewSymbol("list")) - if tmp36.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp36))) - } - tmp37 := tmp36.Get() - tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp39 := tmp38.FindInternedVar(lang.NewSymbol("seq")) - if tmp39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) - } - tmp40 := tmp39.Get() - tmp41 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp42 := tmp41.FindInternedVar(lang.NewSymbol("concat")) - if tmp42.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp42))) - } - tmp43 := tmp42.Get() - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.Apply(tmp46, []any{lang.NewSymbol("new")}) - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.Apply(tmp50, []any{lang.NewSymbol("strings.Builder")}) - tmp52 := lang.Apply(tmp43, []any{tmp47, tmp51}) - tmp53 := lang.Apply(tmp40, []any{tmp52}) - tmp54 := lang.Apply(tmp37, []any{tmp53}) - tmp55 := lang.Apply(tmp30, []any{tmp34, tmp54}) - tmp56 := lang.Apply(tmp27, []any{tmp55}) - tmp57 := lang.Apply(tmp21, []any{tmp24, tmp56}) - tmp58 := lang.Apply(tmp18, []any{tmp57}) - tmp59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp60 := tmp59.FindInternedVar(lang.NewSymbol("list")) - if tmp60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp60))) - } - tmp61 := tmp60.Get() - tmp62 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp63 := tmp62.FindInternedVar(lang.NewSymbol("seq")) - if tmp63.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp63))) - } - tmp64 := tmp63.Get() - tmp65 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp66 := tmp65.FindInternedVar(lang.NewSymbol("concat")) - if tmp66.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp66))) - } - tmp67 := tmp66.Get() - tmp68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp69 := tmp68.FindInternedVar(lang.NewSymbol("list")) - if tmp69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp69))) - } - tmp70 := tmp69.Get() - tmp71 := lang.Apply(tmp70, []any{lang.NewSymbol("glojure.core/binding")}) - tmp72 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp73 := tmp72.FindInternedVar(lang.NewSymbol("list")) - if tmp73.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp73))) - } - tmp74 := tmp73.Get() - tmp75 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp76 := tmp75.FindInternedVar(lang.NewSymbol("apply")) - if tmp76.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp76))) - } - tmp77 := tmp76.Get() - tmp78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp79 := tmp78.FindInternedVar(lang.NewSymbol("vector")) - if tmp79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp79))) - } - tmp80 := tmp79.Get() - tmp81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp82 := tmp81.FindInternedVar(lang.NewSymbol("seq")) - if tmp82.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp82))) - } - tmp83 := tmp82.Get() - tmp84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp85 := tmp84.FindInternedVar(lang.NewSymbol("concat")) - if tmp85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp85))) - } - tmp86 := tmp85.Get() - tmp87 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp88 := tmp87.FindInternedVar(lang.NewSymbol("list")) - if tmp88.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp88))) - } - tmp89 := tmp88.Get() - tmp90 := lang.Apply(tmp89, []any{lang.NewSymbol("glojure.core/*out*")}) - tmp91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp92 := tmp91.FindInternedVar(lang.NewSymbol("list")) - if tmp92.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp92))) - } - tmp93 := tmp92.Get() - tmp94 := lang.Apply(tmp93, []any{lang.NewSymbol("s__0__auto__")}) - tmp95 := lang.Apply(tmp86, []any{tmp90, tmp94}) - tmp96 := lang.Apply(tmp83, []any{tmp95}) - tmp97 := lang.Apply(tmp77, []any{tmp80, tmp96}) - tmp98 := lang.Apply(tmp74, []any{tmp97}) - tmp99 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp100 := tmp99.FindInternedVar(lang.NewSymbol("list")) - if tmp100.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp100))) - } - tmp101 := tmp100.Get() - tmp102 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp103 := tmp102.FindInternedVar(lang.NewSymbol("seq")) - if tmp103.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp103))) - } - tmp104 := tmp103.Get() - tmp105 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp106 := tmp105.FindInternedVar(lang.NewSymbol("concat")) - if tmp106.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp106))) - } - tmp107 := tmp106.Get() - tmp108 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp109 := tmp108.FindInternedVar(lang.NewSymbol("list")) - if tmp109.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp109))) - } - tmp110 := tmp109.Get() - tmp111 := lang.Apply(tmp110, []any{lang.NewSymbol("glojure.core/str")}) - tmp112 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp113 := tmp112.FindInternedVar(lang.NewSymbol("list")) - if tmp113.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp113))) - } - tmp114 := tmp113.Get() - tmp115 := lang.Apply(tmp114, []any{lang.NewSymbol("s__0__auto__")}) - tmp116 := lang.Apply(tmp107, []any{tmp111, tmp115}) - tmp117 := lang.Apply(tmp104, []any{tmp116}) - tmp118 := lang.Apply(tmp101, []any{tmp117}) - tmp119 := lang.Apply(tmp67, []any{tmp71, tmp98, v5, tmp118}) - tmp120 := lang.Apply(tmp64, []any{tmp119}) - tmp121 := lang.Apply(tmp61, []any{tmp120}) - tmp122 := lang.Apply(tmp11, []any{tmp15, tmp58, tmp121}) - tmp123 := lang.Apply(tmp8, []any{tmp122}) - return tmp123 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // with-precision - { - tmp0 := lang.NewSymbol("with-precision").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("precision"), lang.NewSymbol("&"), lang.NewSymbol("exprs"))), lang.NewKeyword("doc"), "Sets the precision and rounding mode to be used for BigDecimal operations.\n\n Usage: (with-precision 10 (/ 1M 3))\n or: (with-precision 10 :rounding HALF_DOWN (/ 1M 3))\n\n The rounding mode is one of CEILING, FLOOR, HALF_UP, HALF_DOWN,\n HALF_EVEN, UP, DOWN and UNNECESSARY; it defaults to HALF_UP.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5110), lang.NewKeyword("end-line"), int(5110))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any - { // let - // let binding "vec__65" - var tmp8 any - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("=")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp13 := tmp12.FindInternedVar(lang.NewSymbol("first")) - if tmp13.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp13))) - } - tmp14 := tmp13.Get() - tmp15 := lang.Apply(tmp14, []any{v6}) - tmp16 := lang.Apply(tmp11, []any{tmp15, lang.NewKeyword("rounding")}) - if lang.IsTruthy(tmp16) { - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("next")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("next")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.Apply(tmp22, []any{v6}) - tmp24 := lang.Apply(tmp19, []any{tmp23}) - tmp25 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("seq")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("concat")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("seq")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("concat")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("list")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.Apply(tmp42, []any{lang.NewSymbol(".")}) - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.Apply(tmp46, []any{lang.NewSymbol("java.math.RoundingMode")}) - tmp48 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp49 := tmp48.FindInternedVar(lang.NewSymbol("list")) - if tmp49.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp49))) - } - tmp50 := tmp49.Get() - tmp51 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp52 := tmp51.FindInternedVar(lang.NewSymbol("second")) - if tmp52.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp52))) - } - tmp53 := tmp52.Get() - tmp54 := lang.Apply(tmp53, []any{v6}) - tmp55 := lang.Apply(tmp50, []any{tmp54}) - tmp56 := lang.Apply(tmp39, []any{tmp43, tmp47, tmp55}) - tmp57 := lang.Apply(tmp36, []any{tmp56}) - tmp58 := lang.Apply(tmp33, []any{tmp57}) - tmp59 := lang.Apply(tmp30, []any{tmp58}) - tmp60 := lang.Apply(tmp27, []any{tmp59}) - tmp61 := lang.NewVector(tmp24, tmp60) - tmp62 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5121), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(5122), lang.NewKeyword("end-column"), int(69)) - tmp63, err := lang.WithMeta(tmp61, tmp62.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp8 = tmp63 - } else { - tmp64 := lang.NewVector(v6, nil) - tmp65 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5123), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(5123), lang.NewKeyword("end-column"), int(33)) - tmp66, err := lang.WithMeta(tmp64, tmp65.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp8 = tmp66 - } - var v67 any = tmp8 - _ = v67 - // let binding "body" - tmp68 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp69 := tmp68.FindInternedVar(lang.NewSymbol("nth")) - if tmp69.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp69))) - } - tmp70 := tmp69.Get() - tmp71 := lang.Apply(tmp70, []any{v67, int64(0), nil}) - var v72 any = tmp71 - _ = v72 - // let binding "rm" - tmp73 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp74 := tmp73.FindInternedVar(lang.NewSymbol("nth")) - if tmp74.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp74))) - } - tmp75 := tmp74.Get() - tmp76 := lang.Apply(tmp75, []any{v67, int64(1), nil}) - var v77 any = tmp76 - _ = v77 - tmp78 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp79 := tmp78.FindInternedVar(lang.NewSymbol("seq")) - if tmp79.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp79))) - } - tmp80 := tmp79.Get() - tmp81 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp82 := tmp81.FindInternedVar(lang.NewSymbol("concat")) - if tmp82.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp82))) - } - tmp83 := tmp82.Get() - tmp84 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp85 := tmp84.FindInternedVar(lang.NewSymbol("list")) - if tmp85.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp85))) - } - tmp86 := tmp85.Get() - tmp87 := lang.Apply(tmp86, []any{lang.NewSymbol("glojure.core/binding")}) - tmp88 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp89 := tmp88.FindInternedVar(lang.NewSymbol("list")) - if tmp89.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp89))) - } - tmp90 := tmp89.Get() - tmp91 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp92 := tmp91.FindInternedVar(lang.NewSymbol("apply")) - if tmp92.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp92))) - } - tmp93 := tmp92.Get() - tmp94 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp95 := tmp94.FindInternedVar(lang.NewSymbol("vector")) - if tmp95.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp95))) - } - tmp96 := tmp95.Get() - tmp97 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp98 := tmp97.FindInternedVar(lang.NewSymbol("seq")) - if tmp98.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp98))) - } - tmp99 := tmp98.Get() - tmp100 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp101 := tmp100.FindInternedVar(lang.NewSymbol("concat")) - if tmp101.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp101))) - } - tmp102 := tmp101.Get() - tmp103 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp104 := tmp103.FindInternedVar(lang.NewSymbol("list")) - if tmp104.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp104))) - } - tmp105 := tmp104.Get() - tmp106 := lang.Apply(tmp105, []any{lang.NewSymbol("glojure.core/*math-context*")}) - tmp107 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp108 := tmp107.FindInternedVar(lang.NewSymbol("list")) - if tmp108.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp108))) - } - tmp109 := tmp108.Get() - tmp110 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp111 := tmp110.FindInternedVar(lang.NewSymbol("seq")) - if tmp111.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp111))) - } - tmp112 := tmp111.Get() - tmp113 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp114 := tmp113.FindInternedVar(lang.NewSymbol("concat")) - if tmp114.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp114))) - } - tmp115 := tmp114.Get() - tmp116 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp117 := tmp116.FindInternedVar(lang.NewSymbol("list")) - if tmp117.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp117))) - } - tmp118 := tmp117.Get() - tmp119 := lang.Apply(tmp118, []any{lang.NewSymbol("java.math.MathContext.")}) - tmp120 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp121 := tmp120.FindInternedVar(lang.NewSymbol("list")) - if tmp121.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp121))) - } - tmp122 := tmp121.Get() - tmp123 := lang.Apply(tmp122, []any{v5}) - tmp124 := lang.Apply(tmp115, []any{tmp119, tmp123, v77}) - tmp125 := lang.Apply(tmp112, []any{tmp124}) - tmp126 := lang.Apply(tmp109, []any{tmp125}) - tmp127 := lang.Apply(tmp102, []any{tmp106, tmp126}) - tmp128 := lang.Apply(tmp99, []any{tmp127}) - tmp129 := lang.Apply(tmp93, []any{tmp96, tmp128}) - tmp130 := lang.Apply(tmp90, []any{tmp129}) - tmp131 := lang.Apply(tmp83, []any{tmp87, tmp130, v72}) - tmp132 := lang.Apply(tmp80, []any{tmp131}) - tmp7 = tmp132 - } // end let - return tmp7 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // with-redefs - { - tmp0 := lang.NewSymbol("with-redefs").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "binding => var-symbol temp-value-expr\n\n Temporarily redefines Vars while executing the body. The\n temp-value-exprs will be evaluated and each resulting value will\n replace in parallel the root value of its Var. After the body is\n executed, the root values of all the Vars will be set back to their\n old values. These temporary changes will be visible in all threads.\n Useful for mocking out functions during testing.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7544), lang.NewKeyword("end-line"), int(7544))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("seq")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("concat")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("list")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("glojure.core/with-redefs-fn")}) - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("list")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp21 := tmp20.FindInternedVar(lang.NewSymbol("zipmap")) - if tmp21.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp21))) - } - tmp22 := tmp21.Get() - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("map")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - var tmp26 lang.FnFunc - tmp26 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v27 := args[0] - _ = v27 - tmp28 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp29 := tmp28.FindInternedVar(lang.NewSymbol("list")) - if tmp29.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp29))) - } - tmp30 := tmp29.Get() - tmp31 := lang.Apply(tmp30, []any{lang.NewSymbol("var"), v27}) - return tmp31 - }) - tmp27 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7555), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(7555), lang.NewKeyword("end-column"), int(47)) - tmp28, err := lang.WithMeta(tmp26, tmp27.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp29 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp30 := tmp29.FindInternedVar(lang.NewSymbol("take-nth")) - if tmp30.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp30))) - } - tmp31 := tmp30.Get() - tmp32 := lang.Apply(tmp31, []any{int64(2), v5}) - tmp33 := lang.Apply(tmp25, []any{tmp28, tmp32}) - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("take-nth")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp38 := tmp37.FindInternedVar(lang.NewSymbol("next")) - if tmp38.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp38))) - } - tmp39 := tmp38.Get() - tmp40 := lang.Apply(tmp39, []any{v5}) - tmp41 := lang.Apply(tmp36, []any{int64(2), tmp40}) - tmp42 := lang.Apply(tmp22, []any{tmp33, tmp41}) - tmp43 := lang.Apply(tmp19, []any{tmp42}) - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("list")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp48 := tmp47.FindInternedVar(lang.NewSymbol("seq")) - if tmp48.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp48))) - } - tmp49 := tmp48.Get() - tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp51 := tmp50.FindInternedVar(lang.NewSymbol("concat")) - if tmp51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) - } - tmp52 := tmp51.Get() - tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp54 := tmp53.FindInternedVar(lang.NewSymbol("list")) - if tmp54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) - } - tmp55 := tmp54.Get() - tmp56 := lang.Apply(tmp55, []any{lang.NewSymbol("glojure.core/fn")}) - tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp58 := tmp57.FindInternedVar(lang.NewSymbol("list")) - if tmp58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) - } - tmp59 := tmp58.Get() - tmp60 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp61 := tmp60.FindInternedVar(lang.NewSymbol("apply")) - if tmp61.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp61))) - } - tmp62 := tmp61.Get() - tmp63 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp64 := tmp63.FindInternedVar(lang.NewSymbol("vector")) - if tmp64.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp64))) - } - tmp65 := tmp64.Get() - tmp66 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp67 := tmp66.FindInternedVar(lang.NewSymbol("seq")) - if tmp67.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp67))) - } - tmp68 := tmp67.Get() - tmp69 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp70 := tmp69.FindInternedVar(lang.NewSymbol("concat")) - if tmp70.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp70))) - } - tmp71 := tmp70.Get() - tmp72 := lang.Apply(tmp71, nil) - tmp73 := lang.Apply(tmp68, []any{tmp72}) - tmp74 := lang.Apply(tmp62, []any{tmp65, tmp73}) - tmp75 := lang.Apply(tmp59, []any{tmp74}) - tmp76 := lang.Apply(tmp52, []any{tmp56, tmp75, v6}) - tmp77 := lang.Apply(tmp49, []any{tmp76}) - tmp78 := lang.Apply(tmp46, []any{tmp77}) - tmp79 := lang.Apply(tmp12, []any{tmp16, tmp43, tmp78}) - tmp80 := lang.Apply(tmp9, []any{tmp79}) - return tmp80 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // with-redefs-fn - { - tmp0 := lang.NewSymbol("with-redefs-fn").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("binding-map"), lang.NewSymbol("func"))), lang.NewKeyword("doc"), "Temporarily redefines Vars during a call to func. Each val of\n binding-map will replace the root value of its key which must be\n a Var. After func is called with no args, the root values of all\n the Vars will be set back to their old values. These temporary\n changes will be visible in all threads. Useful for mocking out\n functions during testing.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7524), lang.NewKeyword("end-line"), int(7524))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - { // let - // let binding "root-bind" - var tmp6 lang.FnFunc - tmp6 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v7 := args[0] - _ = v7 - var tmp8 any - { // let - // let binding "seq_326" - tmp9 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp10 := tmp9.FindInternedVar(lang.NewSymbol("seq")) - if tmp10.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp10))) - } - tmp11 := tmp10.Get() - tmp12 := lang.Apply(tmp11, []any{v7}) - var v13 any = tmp12 - _ = v13 - // let binding "chunk_327" - var v14 any = nil - _ = v14 - // let binding "count_328" - var v15 any = int64(0) - _ = v15 - // let binding "i_329" - var v16 any = int64(0) - _ = v16 - for { - var tmp17 any - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("<")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.Apply(tmp20, []any{v16, v15}) - if lang.IsTruthy(tmp21) { - var tmp22 any - { // let - // let binding "vec__330" - tmp23, _ := lang.FieldOrMethod(v14, "nth") - if reflect.TypeOf(tmp23).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) - } - tmp24 := lang.Apply(tmp23, []any{v16}) - var v25 any = tmp24 - _ = v25 - // let binding "a-var" - tmp26 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp27 := tmp26.FindInternedVar(lang.NewSymbol("nth")) - if tmp27.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp27))) - } - tmp28 := tmp27.Get() - tmp29 := lang.Apply(tmp28, []any{v25, int64(0), nil}) - var v30 any = tmp29 - _ = v30 - // let binding "a-val" - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("nth")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{v25, int64(1), nil}) - var v35 any = tmp34 - _ = v35 - tmp36, _ := lang.FieldOrMethod(v30, "bindRoot") - if reflect.TypeOf(tmp36).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("bindRoot is not a function"))) - } - tmp37 := lang.Apply(tmp36, []any{v35}) - _ = tmp37 - var tmp38 any = v13 - var tmp39 any = v14 - var tmp40 any = v15 - tmp42 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp43 := tmp42.FindInternedVar(lang.NewSymbol("unchecked-inc")) - if tmp43.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp43))) - } - tmp44 := tmp43.Get() - tmp45 := lang.Apply(tmp44, []any{v16}) - var tmp41 any = tmp45 - v13 = tmp38 - v14 = tmp39 - v15 = tmp40 - v16 = tmp41 - continue - } // end let - tmp17 = tmp22 - } else { - var tmp23 any - { // let - // let binding "temp__0__auto__" - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("seq")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.Apply(tmp26, []any{v13}) - var v28 any = tmp27 - _ = v28 - var tmp29 any - if lang.IsTruthy(v28) { - var tmp30 any - { // let - // let binding "seq_326" - var v31 any = v28 - _ = v31 - var tmp32 any - tmp33 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp34 := tmp33.FindInternedVar(lang.NewSymbol("chunked-seq?")) - if tmp34.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp34))) - } - tmp35 := tmp34.Get() - tmp36 := lang.Apply(tmp35, []any{v31}) - if lang.IsTruthy(tmp36) { - var tmp37 any - { // let - // let binding "c__0__auto__" - tmp38 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp39 := tmp38.FindInternedVar(lang.NewSymbol("chunk-first")) - if tmp39.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp39))) - } - tmp40 := tmp39.Get() - tmp41 := lang.Apply(tmp40, []any{v31}) - var v42 any = tmp41 - _ = v42 - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("chunk-rest")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.Apply(tmp46, []any{v31}) - var tmp43 any = tmp47 - var tmp48 any = v42 - tmp50 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp51 := tmp50.FindInternedVar(lang.NewSymbol("int")) - if tmp51.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp51))) - } - tmp52 := tmp51.Get() - tmp53 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp54 := tmp53.FindInternedVar(lang.NewSymbol("count")) - if tmp54.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp54))) - } - tmp55 := tmp54.Get() - tmp56 := lang.Apply(tmp55, []any{v42}) - tmp57 := lang.Apply(tmp52, []any{tmp56}) - var tmp49 any = tmp57 - tmp59 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp60 := tmp59.FindInternedVar(lang.NewSymbol("int")) - if tmp60.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp60))) - } - tmp61 := tmp60.Get() - tmp62 := lang.Apply(tmp61, []any{int64(0)}) - var tmp58 any = tmp62 - v13 = tmp43 - v14 = tmp48 - v15 = tmp49 - v16 = tmp58 - continue - } // end let - tmp32 = tmp37 - } else { - var tmp38 any - { // let - // let binding "vec__333" - tmp39 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp40 := tmp39.FindInternedVar(lang.NewSymbol("first")) - if tmp40.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp40))) - } - tmp41 := tmp40.Get() - tmp42 := lang.Apply(tmp41, []any{v31}) - var v43 any = tmp42 - _ = v43 - // let binding "a-var" - tmp44 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp45 := tmp44.FindInternedVar(lang.NewSymbol("nth")) - if tmp45.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp45))) - } - tmp46 := tmp45.Get() - tmp47 := lang.Apply(tmp46, []any{v43, int64(0), nil}) - var v48 any = tmp47 - _ = v48 - // let binding "a-val" - tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp50 := tmp49.FindInternedVar(lang.NewSymbol("nth")) - if tmp50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) - } - tmp51 := tmp50.Get() - tmp52 := lang.Apply(tmp51, []any{v43, int64(1), nil}) - var v53 any = tmp52 - _ = v53 - tmp54, _ := lang.FieldOrMethod(v48, "bindRoot") - if reflect.TypeOf(tmp54).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("bindRoot is not a function"))) - } - tmp55 := lang.Apply(tmp54, []any{v53}) - _ = tmp55 - tmp57 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp58 := tmp57.FindInternedVar(lang.NewSymbol("next")) - if tmp58.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp58))) - } - tmp59 := tmp58.Get() - tmp60 := lang.Apply(tmp59, []any{v31}) - var tmp56 any = tmp60 - var tmp61 any = nil - var tmp62 any = int64(0) - var tmp63 any = int64(0) - v13 = tmp56 - v14 = tmp61 - v15 = tmp62 - v16 = tmp63 - continue - } // end let - tmp32 = tmp38 - } - tmp30 = tmp32 - } // end let - tmp29 = tmp30 - } else { - } - tmp23 = tmp29 - } // end let - tmp17 = tmp23 - } - tmp8 = tmp17 - break - } - } // end let - return tmp8 - }) - tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7533), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(7535), lang.NewKeyword("end-column"), int(93)) - tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v9 any = tmp8 - _ = v9 - // let binding "old-vals" - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("zipmap")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("keys")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{v3}) - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("map")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - var tmp20 lang.FnFunc - tmp20 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v21 := args[0] - _ = v21 - tmp22, ok := lang.FieldOrMethod(v21, "getRawRoot") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v21, "getRawRoot"))) - } - var tmp23 any - switch reflect.TypeOf(tmp22).Kind() { - case reflect.Func: - tmp23 = lang.Apply(tmp22, nil) - default: - tmp23 = tmp22 - } - return tmp23 - }) - tmp21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7537), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(7537), lang.NewKeyword("end-column"), int(92)) - tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp23 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp24 := tmp23.FindInternedVar(lang.NewSymbol("keys")) - if tmp24.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp24))) - } - tmp25 := tmp24.Get() - tmp26 := lang.Apply(tmp25, []any{v3}) - tmp27 := lang.Apply(tmp19, []any{tmp22, tmp26}) - tmp28 := lang.Apply(tmp12, []any{tmp16, tmp27}) - var v29 any = tmp28 - _ = v29 - var tmp30 any - func() { - defer func() { - tmp31 := lang.Apply(v9, []any{v29}) - _ = tmp31 - }() - tmp32 := lang.Apply(v9, []any{v3}) - _ = tmp32 - tmp33 := lang.Apply(v4, nil) - tmp30 = tmp33 - }() - tmp5 = tmp30 - } // end let - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // xml-seq - { - tmp0 := lang.NewSymbol("xml-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("root"))), lang.NewKeyword("doc"), "A tree seq on the xml elements as per xml/parse", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4982), lang.NewKeyword("end-line"), int(4982))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("tree-seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("complement")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("string?")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp9, []any{tmp12}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("comp")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("seq")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.Apply(tmp16, []any{tmp19, lang.NewKeyword("content")}) - tmp21 := lang.Apply(tmp6, []any{tmp13, tmp20, v3}) - return tmp21 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // zero? - { - var tmp1 lang.FnFunc - { // function zero?__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("seq")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("concat")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("list")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol(".")}) - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("list")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp18 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp19 := tmp18.FindInternedVar(lang.NewSymbol("list")) - if tmp19.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp19))) - } - tmp20 := tmp19.Get() - tmp21 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp22 := tmp21.FindInternedVar(lang.NewSymbol("seq")) - if tmp22.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp22))) - } - tmp23 := tmp22.Get() - tmp24 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp25 := tmp24.FindInternedVar(lang.NewSymbol("concat")) - if tmp25.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp25))) - } - tmp26 := tmp25.Get() - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("list")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/IsZero")}) - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("list")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.Apply(tmp33, []any{v3}) - tmp35 := lang.Apply(tmp26, []any{tmp30, tmp34}) - tmp36 := lang.Apply(tmp23, []any{tmp35}) - tmp37 := lang.Apply(tmp20, []any{tmp36}) - tmp38 := lang.Apply(tmp9, []any{tmp13, tmp17, tmp37}) - tmp39 := lang.Apply(tmp6, []any{tmp38}) - return tmp39 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := lang.NewSymbol("zero?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns true if num is zero, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(860), lang.NewKeyword("end-line"), int(860))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "IsZero") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("IsZero is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // zipmap - { - tmp0 := lang.NewSymbol("zipmap").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("keys"), lang.NewSymbol("vals"))), lang.NewKeyword("doc"), "Returns a map with the keys mapped to the corresponding vals.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6583), lang.NewKeyword("end-line"), int(6583))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - { // let - // let binding "map" - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("transient")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.NewMap() - tmp10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6588), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(6588), lang.NewKeyword("end-column"), int(28)) - tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp12 := lang.Apply(tmp8, []any{tmp11}) - var v13 any = tmp12 - _ = v13 - // let binding "ks" - tmp14 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("seq")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{v3}) - var v18 any = tmp17 - _ = v18 - // let binding "vs" - tmp19 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp20 := tmp19.FindInternedVar(lang.NewSymbol("seq")) - if tmp20.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp20))) - } - tmp21 := tmp20.Get() - tmp22 := lang.Apply(tmp21, []any{v4}) - var v23 any = tmp22 - _ = v23 - for { - var tmp24 any - var tmp25 any - { // let - // let binding "and__0__auto__" - var v26 any = v18 - _ = v26 - var tmp27 any - if lang.IsTruthy(v26) { - tmp27 = v23 - } else { - tmp27 = v26 - } - tmp25 = tmp27 - } // end let - if lang.IsTruthy(tmp25) { - tmp27 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp28 := tmp27.FindInternedVar(lang.NewSymbol("assoc!")) - if tmp28.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp28))) - } - tmp29 := tmp28.Get() - tmp30 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp31 := tmp30.FindInternedVar(lang.NewSymbol("first")) - if tmp31.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp31))) - } - tmp32 := tmp31.Get() - tmp33 := lang.Apply(tmp32, []any{v18}) - tmp34 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("first")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.Apply(tmp36, []any{v23}) - tmp38 := lang.Apply(tmp29, []any{v13, tmp33, tmp37}) - var tmp26 any = tmp38 - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("next")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.Apply(tmp42, []any{v18}) - var tmp39 any = tmp43 - tmp45 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp46 := tmp45.FindInternedVar(lang.NewSymbol("next")) - if tmp46.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp46))) - } - tmp47 := tmp46.Get() - tmp48 := lang.Apply(tmp47, []any{v23}) - var tmp44 any = tmp48 - v13 = tmp26 - v18 = tmp39 - v23 = tmp44 - continue - } else { - tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp50 := tmp49.FindInternedVar(lang.NewSymbol("persistent!")) - if tmp50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) - } - tmp51 := tmp50.Get() - tmp52 := lang.Apply(tmp51, []any{v13}) - tmp24 = tmp52 - } - tmp5 = tmp24 - break - } - } // end let - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } -} diff --git a/pkg/codegen/testdata/codegen/test/multifn.go b/pkg/codegen/testdata/codegen/test/multifn.go new file mode 100644 index 00000000..8d2dbcc9 --- /dev/null +++ b/pkg/codegen/testdata/codegen/test/multifn.go @@ -0,0 +1,161 @@ +// Code generated by glojure codegen. DO NOT EDIT. + +package generated + +import ( + fmt "fmt" + lang "github.com/glojurelang/glojure/pkg/lang" + reflect "reflect" +) + +func init() { + // reference fmt to avoid unused import error + _ = fmt.Printf + ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.multifn")) + _ = ns + // -main + { + tmp0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), "int64: 7 float64: 8.0 default: 3 4", lang.NewKeyword("file"), "codegen/test/multifn.glj", lang.NewKeyword("line"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(8), lang.NewKeyword("end-column"), int(68), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.multifn")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + tmp3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp4 := tmp3.FindInternedVar(lang.NewSymbol("str")) + if tmp4.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp4))) + } + tmp5 := tmp4.Get() + tmp6 := lang.FindNamespace(lang.NewSymbol("codegen.test.multifn")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("add")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.Apply(tmp8, []any{int64(3), int64(4)}) + tmp10 := lang.FindNamespace(lang.NewSymbol("codegen.test.multifn")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("add")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.Apply(tmp12, []any{float64(3.5), float64(4.5)}) + tmp14 := lang.FindNamespace(lang.NewSymbol("codegen.test.multifn")) + tmp15 := tmp14.FindInternedVar(lang.NewSymbol("add")) + if tmp15.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) + } + tmp16 := tmp15.Get() + tmp17 := lang.Apply(tmp16, []any{"3", "4"}) + tmp18 := lang.Apply(tmp5, []any{tmp9, " ", tmp13, " ", tmp17}) + return tmp18 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // add + { + tmp0 := lang.NewSymbol("add").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/multifn.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("doc"), "a multimethod for addition", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.multifn")))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp7 := tmp6.FindInternedVar(lang.NewSymbol("type")) + if tmp7.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) + } + tmp8 := tmp7.Get() + tmp9 := lang.Apply(tmp8, []any{v4}) + return tmp9 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/multifn.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(44), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(62))).(lang.FnFunc) + tmp2 := lang.NewMultiFn("add", tmp3, lang.NewKeyword("default"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")).FindInternedVar(lang.NewSymbol("global-hierarchy"))) + tmp4 := reflect.TypeOf(int64(0)) + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp9 := tmp8.FindInternedVar(lang.NewSymbol("str")) + if tmp9.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) + } + tmp10 := tmp9.Get() + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("+")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{v6, v7}) + tmp15 := lang.Apply(tmp10, []any{"int64: ", tmp14}) + return tmp15 + }) + tmp2.AddMethod(tmp4, tmp5) + tmp6 := reflect.TypeOf(float64(0)) + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp11 := tmp10.FindInternedVar(lang.NewSymbol("str")) + if tmp11.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) + } + tmp12 := tmp11.Get() + tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp14 := tmp13.FindInternedVar(lang.NewSymbol("+")) + if tmp14.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) + } + tmp15 := tmp14.Get() + tmp16 := lang.Apply(tmp15, []any{v8, v9}) + tmp17 := lang.Apply(tmp12, []any{"float64: ", tmp16}) + return tmp17 + }) + tmp2.AddMethod(tmp6, tmp7) + var tmp8 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v9 := args[0] + _ = v9 + v10 := args[1] + _ = v10 + tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) + tmp12 := tmp11.FindInternedVar(lang.NewSymbol("str")) + if tmp12.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) + } + tmp13 := tmp12.Get() + tmp14 := lang.Apply(tmp13, []any{"default: ", v9, " ", v10}) + return tmp14 + }) + tmp2.AddMethod(lang.NewKeyword("default"), tmp8) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } +} diff --git a/pkg/lang/multifn.go b/pkg/lang/multifn.go index 0892de54..2fc0a530 100644 --- a/pkg/lang/multifn.go +++ b/pkg/lang/multifn.go @@ -12,12 +12,12 @@ type MultiFn struct { name string dispatchFn IFn - defaultDispatchVal interface{} + defaultDispatchVal any hierarchy IRef methodTable IPersistentMap preferTable IPersistentMap methodCache IPersistentMap - cachedHierarchy interface{} + cachedHierarchy any mtx sync.RWMutex } @@ -28,7 +28,7 @@ var ( varIsA = InternVarName(NSCore.Name(), NewSymbol("isa?")) ) -func NewMultiFn(name string, dispatchFn IFn, defaultDispatchVal interface{}, hierarchy IRef) *MultiFn { +func NewMultiFn(name string, dispatchFn IFn, defaultDispatchVal any, hierarchy IRef) *MultiFn { return &MultiFn{ name: name, dispatchFn: dispatchFn, @@ -45,6 +45,38 @@ func (m *MultiFn) resetCache() { m.cachedHierarchy = m.hierarchy.Deref() } +func (m *MultiFn) GetMethodTable() IPersistentMap { + m.mtx.RLock() + defer m.mtx.RUnlock() + + return m.methodTable +} + +func (m *MultiFn) GetDispatchFn() IFn { + m.mtx.RLock() + defer m.mtx.RUnlock() + + return m.dispatchFn +} + +func (m *MultiFn) GetDefaultDispatchVal() any { + m.mtx.RLock() + defer m.mtx.RUnlock() + + return m.defaultDispatchVal +} + +func (m *MultiFn) GetHierarchy() IRef { + m.mtx.RLock() + defer m.mtx.RUnlock() + + return m.hierarchy +} + +func (m *MultiFn) GetName() string { + return m.name +} + func (m *MultiFn) PreferTable() IPersistentMap { m.mtx.RLock() defer m.mtx.RUnlock() @@ -52,7 +84,7 @@ func (m *MultiFn) PreferTable() IPersistentMap { return m.preferTable } -func (m *MultiFn) AddMethod(dispatchVal interface{}, method IFn) *MultiFn { +func (m *MultiFn) AddMethod(dispatchVal any, method IFn) *MultiFn { m.mtx.Lock() defer m.mtx.Unlock() @@ -62,7 +94,7 @@ func (m *MultiFn) AddMethod(dispatchVal interface{}, method IFn) *MultiFn { return m } -func (m *MultiFn) PreferMethod(dispatchValX, dispatchValY interface{}) *MultiFn { +func (m *MultiFn) PreferMethod(dispatchValX, dispatchValY any) *MultiFn { m.mtx.Lock() defer m.mtx.Unlock() @@ -77,7 +109,7 @@ func (m *MultiFn) PreferMethod(dispatchValX, dispatchValY interface{}) *MultiFn return m } -func (m *MultiFn) prefers(hierarchy, x, y interface{}) (res bool) { +func (m *MultiFn) prefers(hierarchy, x, y any) (res bool) { xprefs := m.preferTable.ValAt(x) if xprefs != nil && xprefs.(IPersistentSet).Contains(y) { return true @@ -114,15 +146,15 @@ func (m *MultiFn) prefers(hierarchy, x, y interface{}) (res bool) { return false } -func (m *MultiFn) Invoke(args ...interface{}) interface{} { +func (m *MultiFn) Invoke(args ...any) any { return m.getFn(m.dispatchFn.Invoke(args...)).Invoke(args...) } -func (m *MultiFn) ApplyTo(args ISeq) interface{} { +func (m *MultiFn) ApplyTo(args ISeq) any { return m.Invoke(seqToSlice(args)...) } -func (m *MultiFn) getMethod(dispatchVal interface{}) IFn { +func (m *MultiFn) getMethod(dispatchVal any) IFn { // TODO: cached hierarchy targetFn := m.methodCache.ValAt(dispatchVal) @@ -132,7 +164,7 @@ func (m *MultiFn) getMethod(dispatchVal interface{}) IFn { return m.findAndCacheBestMethod(dispatchVal) } -func (m *MultiFn) getFn(dispatchVal interface{}) IFn { +func (m *MultiFn) getFn(dispatchVal any) IFn { targetFn := m.getMethod(dispatchVal) if targetFn == nil { panic(fmt.Errorf("No method in multimethod '%s' for dispatch value: %v", m.name, ToString(dispatchVal))) @@ -140,7 +172,7 @@ func (m *MultiFn) getFn(dispatchVal interface{}) IFn { return targetFn } -func (m *MultiFn) findAndCacheBestMethod(dispatchVal interface{}) IFn { +func (m *MultiFn) findAndCacheBestMethod(dispatchVal any) IFn { m.mtx.RLock() mt := m.methodTable pt := m.preferTable @@ -161,13 +193,13 @@ func (m *MultiFn) findAndCacheBestMethod(dispatchVal interface{}) IFn { return bestMethod } -func (m *MultiFn) findBestMethod(dispatchVal interface{}) IFn { +func (m *MultiFn) findBestMethod(dispatchVal any) IFn { m.mtx.RLock() defer m.mtx.RUnlock() // TODO: cached hierarchy - var bestValue interface{} + var bestValue any var bestEntry IMapEntry for seq := Seq(m.methodTable); seq != nil; seq = seq.Next() { entry := seq.First().(IMapEntry) @@ -192,10 +224,10 @@ func (m *MultiFn) findBestMethod(dispatchVal interface{}) IFn { return bestValue.(IFn) } -func (m *MultiFn) isA(h, x, y interface{}) bool { +func (m *MultiFn) isA(h, x, y any) bool { return varIsA.Invoke(h, x, y).(bool) } -func (m *MultiFn) dominates(h, x, y interface{}) bool { +func (m *MultiFn) dominates(h, x, y any) bool { return m.prefers(m.hierarchy, x, y) || m.isA(h, x, y) } From 93e4bf8911ed920e34809a1296a694bd5bc9574f Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sat, 30 Aug 2025 19:19:44 -0700 Subject: [PATCH 46/67] Clean up vars, don't save gold output as go files Signed-off-by: James Hamlin --- pkg/codegen/codegen.go | 112 ++++++++--- pkg/codegen/codegen_test.go | 39 +++- .../load.go.out} | 11 +- .../load.go.out} | 11 +- .../load.go.out} | 11 +- .../{def_simple.go => def_simple/load.go.out} | 11 +- .../{fn_closure.go => fn_closure/load.go.out} | 93 +++++---- .../{fn_recur.go => fn_recur/load.go.out} | 75 ++++---- .../load.go.out} | 55 +++--- .../load.go.out} | 27 +-- .../test/{multifn.go => multifn/load.go.out} | 129 +++++-------- .../test/{ns_skip.go => ns_skip/load.go.out} | 11 +- .../load.go.out} | 11 +- .../codegen/test/{ref.go => ref/load.go.out} | 35 ++-- .../test/{the_var.go => the_var/load.go.out} | 11 +- .../load.go.out} | 11 +- .../load.go.out} | 121 ++++++------ .../{try_basic.go => try_basic/load.go.out} | 177 ++++++++---------- .../test/{values.go => values/load.go.out} | 39 ++-- .../{with_meta.go => with_meta/load.go.out} | 37 ++-- 20 files changed, 560 insertions(+), 467 deletions(-) rename pkg/codegen/testdata/codegen/test/{const_keyword.go => const_keyword/load.go.out} (74%) rename pkg/codegen/testdata/codegen/test/{const_number.go => const_number/load.go.out} (75%) rename pkg/codegen/testdata/codegen/test/{const_string.go => const_string/load.go.out} (75%) rename pkg/codegen/testdata/codegen/test/{def_simple.go => def_simple/load.go.out} (63%) rename pkg/codegen/testdata/codegen/test/{fn_closure.go => fn_closure/load.go.out} (72%) rename pkg/codegen/testdata/codegen/test/{fn_recur.go => fn_recur/load.go.out} (67%) rename pkg/codegen/testdata/codegen/test/{loop_simple.go => loop_simple/load.go.out} (65%) rename pkg/codegen/testdata/codegen/test/{maybe_class.go => maybe_class/load.go.out} (67%) rename pkg/codegen/testdata/codegen/test/{multifn.go => multifn/load.go.out} (50%) rename pkg/codegen/testdata/codegen/test/{ns_skip.go => ns_skip/load.go.out} (50%) rename pkg/codegen/testdata/codegen/test/{quote_simple.go => quote_simple/load.go.out} (82%) rename pkg/codegen/testdata/codegen/test/{ref.go => ref/load.go.out} (70%) rename pkg/codegen/testdata/codegen/test/{the_var.go => the_var/load.go.out} (88%) rename pkg/codegen/testdata/codegen/test/{throw_simple.go => throw_simple/load.go.out} (81%) rename pkg/codegen/testdata/codegen/test/{try_advanced.go => try_advanced/load.go.out} (69%) rename pkg/codegen/testdata/codegen/test/{try_basic.go => try_basic/load.go.out} (66%) rename pkg/codegen/testdata/codegen/test/{values.go => values/load.go.out} (70%) rename pkg/codegen/testdata/codegen/test/{with_meta.go => with_meta/load.go.out} (65%) diff --git a/pkg/codegen/codegen.go b/pkg/codegen/codegen.go index 089c4bf2..a3811592 100644 --- a/pkg/codegen/codegen.go +++ b/pkg/codegen/codegen.go @@ -47,6 +47,11 @@ type liftedValue struct { varName string } +type varInfo struct { + ns string + sym string +} + // Generator handles the conversion of AST nodes to Go code type Generator struct { originalWriter io.Writer @@ -54,7 +59,8 @@ type Generator struct { varScopes []varScope // stack of variable scopes recurStack []recurContext // stack of recur contexts for nested loops - imports map[string]string // set of imported packages with their aliases + imports map[string]string // set of imported packages with their aliases + varVariables map[varInfo]string // map of vars to their Go variable names // Fields for handling closures liftedValues map[liftedKey]*liftedValue // Dedupe by composite key @@ -80,6 +86,7 @@ func New(w io.Writer) *Generator { imports: make(map[string]string), liftedValues: make(map[liftedKey]*liftedValue), liftedCounter: 0, + varVariables: make(map[varInfo]string), } } @@ -138,7 +145,29 @@ func (g *Generator) Generate(ns *lang.Namespace) error { // Now construct the complete init function var initBuf bytes.Buffer - initBuf.WriteString("func init() {\n") + initBuf.WriteString(fmt.Sprintf("// LoadNS initializes the namespace %q\n", ns.Name().String())) + initBuf.WriteString("func LoadNS() {\n") + initBuf.WriteString(`checkDerefMacro := func (v *lang.Var) { + if v.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) + } +} +_ = checkDerefMacro +`) + + // initialize all the vars first + var varNames []string + var inverseVarMap = make(map[string]varInfo) + for vi, varName := range g.varVariables { + varNames = append(varNames, varName) + inverseVarMap[varName] = vi + } + sort.Strings(varNames) // Sort for deterministic output + for _, varName := range varNames { + vi := inverseVarMap[varName] + initBuf.WriteString(fmt.Sprintf("// var %s/%s\n", vi.ns, vi.sym)) + initBuf.WriteString(fmt.Sprintf("%s := lang.InternVarName(lang.NewSymbol(%q), lang.NewSymbol(%q))\n", varName, vi.ns, vi.sym)) + } // Generate lifted values at the beginning of init() if any if len(g.liftedValues) > 0 { @@ -180,8 +209,8 @@ func (g *Generator) Generate(ns *lang.Namespace) error { initBuf.WriteString("}\n") // Prepare the final source - sourceBytes := []byte(g.header()) // Package declaration and imports - sourceBytes = append(sourceBytes, initBuf.Bytes()...) // The complete init function + sourceBytes := []byte(g.header(mungeID(getLastNSPart(ns.Name().String())))) // File header with package and imports + sourceBytes = append(sourceBytes, initBuf.Bytes()...) // The complete init function // Format the generated code formatted, err := format.Source(sourceBytes) @@ -866,18 +895,10 @@ func (g *Generator) generateVarDeref(node *ast.Node) string { varNamespace := varNode.Var.Namespace() varSymbol := varNode.Var.Symbol() - // generate code to look up the var in the namespace - nsVar := g.allocateTempVar() - g.writef("%s := lang.FindNamespace(lang.NewSymbol(\"%s\"))\n", nsVar, varNamespace.Name()) - // look up the var in the namespace - varId := g.allocateTempVar() - g.writef("%s := %s.FindInternedVar(lang.NewSymbol(\"%s\"))\n", varId, nsVar, varSymbol.Name()) + // Look up the var variable + varId := g.allocateVarVariable(varNamespace.Name().String(), varSymbol.String()) - // if macro, panic with 'can't take value of macro: %v' - g.writef("if %s.IsMacro() {\n", varId) - g.writef(" panic(lang.NewIllegalArgumentError(fmt.Sprintf(\"can't take value of macro: %%v\", %s)))\n", varId) - g.writef("}\n") - // else, return Get() + g.writef("checkDerefMacro(%s)\n", varId) resultId := g.allocateTempVar() g.writef("%s := %s.Get()\n", resultId, varId) @@ -1416,13 +1437,13 @@ func (g *Generator) addImportWithAlias(pkg string) string { return alias } -func (g *Generator) header() string { - header := `// Code generated by glojure codegen. DO NOT EDIT. +func (g *Generator) header(pkgName string) string { + header := fmt.Sprintf(`// Code generated by glojure codegen. DO NOT EDIT. -package generated +package %s import ( -` +`, pkgName) // sort the imports by their package name for deterministic output keys := make([]string, 0, len(g.imports)) @@ -1456,7 +1477,7 @@ func (g *Generator) writeAssign(varName, rValue string) { } //////////////////////////////////////////////////////////////////////////////// -// Variable Scope Management +// Variable scope management and other helpers // PushVarScope creates a new variable scope func (g *Generator) pushVarScope() { @@ -1587,8 +1608,47 @@ func (g *Generator) allocateTempVar() string { return varName } +var ( + replacements = map[rune]string{ + '!': "_BANG_", + '?': "_QMARK_", + '-': "_", + '+': "_PLUS_", + '*': "_STAR_", + '/': "_SLASH_", + '=': "_EQ_", + '<': "_LT_", + '>': "_GT_", + '&': "_AMP_", + '%': "_PCT_", + '$': "_DOLLAR_", + '^': "_CARET_", + '~': "_TILDE_", + '.': "_DOT_", + ':': "_COLON_", + '@': "_AT_", + '#': "_HASH_", + } +) + func mungeID(name string) string { - return strings.ReplaceAll(name, "-", "__") + var sb strings.Builder + for _, ch := range name { + if repl, ok := replacements[ch]; ok { + sb.WriteString(repl) + } else if (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9') || ch == '_' { + sb.WriteRune(ch) + } else { + // Replace any other non-alphanumeric character with its Unicode code point + sb.WriteString(fmt.Sprintf("_U%04X_", ch)) + } + } + return sb.String() +} + +func getLastNSPart(ns string) string { + parts := strings.Split(ns, ".") + return parts[len(parts)-1] } func (g *Generator) pushRecurContext(loopID *lang.Symbol, bindings []string, useGoto bool) { @@ -1612,3 +1672,13 @@ func (g *Generator) currentRecurContext() *recurContext { } return &g.recurStack[len(g.recurStack)-1] } + +func (g *Generator) allocateVarVariable(ns, sym string) string { + varInfo := varInfo{ns: ns, sym: sym} + if v, ok := g.varVariables[varInfo]; ok { + return v + } + varName := mungeID(ns) + "_" + mungeID(sym) + g.varVariables[varInfo] = varName + return varName +} diff --git a/pkg/codegen/codegen_test.go b/pkg/codegen/codegen_test.go index 81ce8f86..5a7d6275 100644 --- a/pkg/codegen/codegen_test.go +++ b/pkg/codegen/codegen_test.go @@ -56,7 +56,11 @@ func TestCodegen(t *testing.T) { ns := lang.FindNamespace(lang.NewSymbol(nsName)) - generateAndTestNamespace(t, ns, strings.TrimSuffix(testFile, ".glj")+".go") + outputDir := strings.TrimSuffix(testFile, ".glj") + if err := os.MkdirAll(outputDir, 0755); err != nil { + t.Fatalf("failed to create output directory: %v", err) + } + generateAndTestNamespace(t, ns, filepath.Join(outputDir, "load.go.out")) }) } @@ -67,7 +71,10 @@ func TestCodegen(t *testing.T) { t.Fatal("glojure.core namespace not found") } - goldenFile := "testdata/codegen/test/core.go" + if err := os.MkdirAll("testdata/codegen/test/core", 0755); err != nil { + t.Fatalf("failed to create output directory: %v", err) + } + goldenFile := "testdata/codegen/test/core/load.go.out" generateAndTestNamespace(t, ns, goldenFile) }) } @@ -110,12 +117,28 @@ func generateAndTestNamespace(t *testing.T, ns *lang.Namespace, goldenFile strin generated, expected) } - // run go vet on the output file. print any errors from stderr - cmd := exec.Command("go", "vet", "-all", goldenFile) - var stderr bytes.Buffer - cmd.Stderr = &stderr - if err := cmd.Run(); err != nil { - t.Errorf("go vet failed for %s: %v\nStderr:\n%s", goldenFile, err, stderr.String()) + { + // Copy golden file to temp directory with .go extension for go vet + tempFile, err := ioutil.TempFile("", "codegen_test_*.go") + if err != nil { + t.Fatalf("failed to create temp file: %v", err) + } + defer os.Remove(tempFile.Name()) + + if _, err := tempFile.Write(expected); err != nil { + t.Fatalf("failed to write to temp file: %v", err) + } + if err := tempFile.Close(); err != nil { + t.Fatalf("failed to close temp file: %v", err) + } + + // run go vet on the temp file with .go extension + cmd := exec.Command("go", "vet", "-all", tempFile.Name()) + var stderr bytes.Buffer + cmd.Stderr = &stderr + if err := cmd.Run(); err != nil { + t.Errorf("go vet failed for %s: %v\nStderr:\n%s", goldenFile, err, stderr.String()) + } } // Check if namespace has -main function with expected output diff --git a/pkg/codegen/testdata/codegen/test/const_keyword.go b/pkg/codegen/testdata/codegen/test/const_keyword/load.go.out similarity index 74% rename from pkg/codegen/testdata/codegen/test/const_keyword.go rename to pkg/codegen/testdata/codegen/test/const_keyword/load.go.out index a98db605..b1fb1656 100644 --- a/pkg/codegen/testdata/codegen/test/const_keyword.go +++ b/pkg/codegen/testdata/codegen/test/const_keyword/load.go.out @@ -1,13 +1,20 @@ // Code generated by glojure codegen. DO NOT EDIT. -package generated +package const_keyword import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" ) -func init() { +// LoadNS initializes the namespace "codegen.test.const-keyword" +func LoadNS() { + checkDerefMacro := func(v *lang.Var) { + if v.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) + } + } + _ = checkDerefMacro // reference fmt to avoid unused import error _ = fmt.Printf ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.const-keyword")) diff --git a/pkg/codegen/testdata/codegen/test/const_number.go b/pkg/codegen/testdata/codegen/test/const_number/load.go.out similarity index 75% rename from pkg/codegen/testdata/codegen/test/const_number.go rename to pkg/codegen/testdata/codegen/test/const_number/load.go.out index b2735819..84b1ce59 100644 --- a/pkg/codegen/testdata/codegen/test/const_number.go +++ b/pkg/codegen/testdata/codegen/test/const_number/load.go.out @@ -1,13 +1,20 @@ // Code generated by glojure codegen. DO NOT EDIT. -package generated +package const_number import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" ) -func init() { +// LoadNS initializes the namespace "codegen.test.const-number" +func LoadNS() { + checkDerefMacro := func(v *lang.Var) { + if v.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) + } + } + _ = checkDerefMacro // reference fmt to avoid unused import error _ = fmt.Printf ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.const-number")) diff --git a/pkg/codegen/testdata/codegen/test/const_string.go b/pkg/codegen/testdata/codegen/test/const_string/load.go.out similarity index 75% rename from pkg/codegen/testdata/codegen/test/const_string.go rename to pkg/codegen/testdata/codegen/test/const_string/load.go.out index 9afa194d..60525b0b 100644 --- a/pkg/codegen/testdata/codegen/test/const_string.go +++ b/pkg/codegen/testdata/codegen/test/const_string/load.go.out @@ -1,13 +1,20 @@ // Code generated by glojure codegen. DO NOT EDIT. -package generated +package const_string import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" ) -func init() { +// LoadNS initializes the namespace "codegen.test.const-string" +func LoadNS() { + checkDerefMacro := func(v *lang.Var) { + if v.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) + } + } + _ = checkDerefMacro // reference fmt to avoid unused import error _ = fmt.Printf ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.const-string")) diff --git a/pkg/codegen/testdata/codegen/test/def_simple.go b/pkg/codegen/testdata/codegen/test/def_simple/load.go.out similarity index 63% rename from pkg/codegen/testdata/codegen/test/def_simple.go rename to pkg/codegen/testdata/codegen/test/def_simple/load.go.out index 34f08016..58433900 100644 --- a/pkg/codegen/testdata/codegen/test/def_simple.go +++ b/pkg/codegen/testdata/codegen/test/def_simple/load.go.out @@ -1,13 +1,20 @@ // Code generated by glojure codegen. DO NOT EDIT. -package generated +package def_simple import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" ) -func init() { +// LoadNS initializes the namespace "codegen.test.def-simple" +func LoadNS() { + checkDerefMacro := func(v *lang.Var) { + if v.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) + } + } + _ = checkDerefMacro // reference fmt to avoid unused import error _ = fmt.Printf ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.def-simple")) diff --git a/pkg/codegen/testdata/codegen/test/fn_closure.go b/pkg/codegen/testdata/codegen/test/fn_closure/load.go.out similarity index 72% rename from pkg/codegen/testdata/codegen/test/fn_closure.go rename to pkg/codegen/testdata/codegen/test/fn_closure/load.go.out index 8467de01..901d467e 100644 --- a/pkg/codegen/testdata/codegen/test/fn_closure.go +++ b/pkg/codegen/testdata/codegen/test/fn_closure/load.go.out @@ -1,13 +1,32 @@ // Code generated by glojure codegen. DO NOT EDIT. -package generated +package fn_closure import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" ) -func init() { +// LoadNS initializes the namespace "codegen.test.fn-closure" +func LoadNS() { + checkDerefMacro := func(v *lang.Var) { + if v.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) + } + } + _ = checkDerefMacro + // var codegen.test.fn-closure/closed + codegen_DOT_test_DOT_fn_closure_closed := lang.InternVarName(lang.NewSymbol("codegen.test.fn-closure"), lang.NewSymbol("closed")) + // var codegen.test.fn-closure/get-atom + codegen_DOT_test_DOT_fn_closure_get_atom := lang.InternVarName(lang.NewSymbol("codegen.test.fn-closure"), lang.NewSymbol("get-atom")) + // var codegen.test.fn-closure/inc-atom + codegen_DOT_test_DOT_fn_closure_inc_atom := lang.InternVarName(lang.NewSymbol("codegen.test.fn-closure"), lang.NewSymbol("inc-atom")) + // var glojure.core/deref + glojure_DOT_core_deref := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("deref")) + // var glojure.core/inc + glojure_DOT_core_inc := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("inc")) + // var glojure.core/swap! + glojure_DOT_core_swap_BANG_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("swap!")) // Closed-over values var closed0 any { @@ -31,35 +50,23 @@ func init() { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - tmp3 := lang.FindNamespace(lang.NewSymbol("codegen.test.fn-closure")) - tmp4 := tmp3.FindInternedVar(lang.NewSymbol("inc-atom")) - if tmp4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp4))) - } - tmp5 := tmp4.Get() + checkDerefMacro(codegen_DOT_test_DOT_fn_closure_inc_atom) + tmp3 := codegen_DOT_test_DOT_fn_closure_inc_atom.Get() + tmp4 := lang.Apply(tmp3, nil) + _ = tmp4 + checkDerefMacro(codegen_DOT_test_DOT_fn_closure_closed) + tmp5 := codegen_DOT_test_DOT_fn_closure_closed.Get() tmp6 := lang.Apply(tmp5, nil) - _ = tmp6 - tmp7 := lang.FindNamespace(lang.NewSymbol("codegen.test.fn-closure")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("closed")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp9, nil) - tmp11 := lang.FindNamespace(lang.NewSymbol("codegen.test.fn-closure")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("get-atom")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, nil) - tmp15 := lang.NewVector(tmp10, tmp14) - tmp16 := lang.NewMap(lang.NewKeyword("file"), "codegen/test/fn_closure.glj", lang.NewKeyword("line"), int(15), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(16), lang.NewKeyword("end-column"), int(14)) - tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + checkDerefMacro(codegen_DOT_test_DOT_fn_closure_get_atom) + tmp7 := codegen_DOT_test_DOT_fn_closure_get_atom.Get() + tmp8 := lang.Apply(tmp7, nil) + tmp9 := lang.NewVector(tmp6, tmp8) + tmp10 := lang.NewMap(lang.NewKeyword("file"), "codegen/test/fn_closure.glj", lang.NewKeyword("line"), int(15), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(16), lang.NewKeyword("end-column"), int(14)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) if err != nil { panic(err) } - return tmp17 + return tmp11 }) tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) @@ -121,14 +128,10 @@ func init() { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - tmp3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp4 := tmp3.FindInternedVar(lang.NewSymbol("deref")) - if tmp4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp4))) - } - tmp5 := tmp4.Get() - tmp6 := lang.Apply(tmp5, []any{closed1}) - return tmp6 + checkDerefMacro(glojure_DOT_core_deref) + tmp3 := glojure_DOT_core_deref.Get() + tmp4 := lang.Apply(tmp3, []any{closed1}) + return tmp4 }) tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) @@ -144,20 +147,12 @@ func init() { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - tmp3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp4 := tmp3.FindInternedVar(lang.NewSymbol("swap!")) - if tmp4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp4))) - } - tmp5 := tmp4.Get() - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("inc")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(tmp5, []any{closed1, tmp8}) - return tmp9 + checkDerefMacro(glojure_DOT_core_swap_BANG_) + tmp3 := glojure_DOT_core_swap_BANG_.Get() + checkDerefMacro(glojure_DOT_core_inc) + tmp4 := glojure_DOT_core_inc.Get() + tmp5 := lang.Apply(tmp3, []any{closed1, tmp4}) + return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) diff --git a/pkg/codegen/testdata/codegen/test/fn_recur.go b/pkg/codegen/testdata/codegen/test/fn_recur/load.go.out similarity index 67% rename from pkg/codegen/testdata/codegen/test/fn_recur.go rename to pkg/codegen/testdata/codegen/test/fn_recur/load.go.out index bf04077f..7b84e487 100644 --- a/pkg/codegen/testdata/codegen/test/fn_recur.go +++ b/pkg/codegen/testdata/codegen/test/fn_recur/load.go.out @@ -1,13 +1,28 @@ // Code generated by glojure codegen. DO NOT EDIT. -package generated +package fn_recur import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" ) -func init() { +// LoadNS initializes the namespace "codegen.test.fn-recur" +func LoadNS() { + checkDerefMacro := func(v *lang.Var) { + if v.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) + } + } + _ = checkDerefMacro + // var codegen.test.fn-recur/fib + codegen_DOT_test_DOT_fn_recur_fib := lang.InternVarName(lang.NewSymbol("codegen.test.fn-recur"), lang.NewSymbol("fib")) + // var glojure.core/= + glojure_DOT_core__EQ_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("=")) + // var glojure.core/+ + glojure_DOT_core__PLUS_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("+")) + // var glojure.core/inc + glojure_DOT_core_inc := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("inc")) // reference fmt to avoid unused import error _ = fmt.Printf ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.fn-recur")) @@ -20,14 +35,10 @@ func init() { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - tmp3 := lang.FindNamespace(lang.NewSymbol("codegen.test.fn-recur")) - tmp4 := tmp3.FindInternedVar(lang.NewSymbol("fib")) - if tmp4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp4))) - } - tmp5 := tmp4.Get() - tmp6 := lang.Apply(tmp5, []any{int64(10)}) - return tmp6 + checkDerefMacro(codegen_DOT_test_DOT_fn_recur_fib) + tmp3 := codegen_DOT_test_DOT_fn_recur_fib.Get() + tmp4 := lang.Apply(tmp3, []any{int64(10)}) + return tmp4 }) tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) @@ -63,36 +74,24 @@ func init() { _ = v9 recur_loop_1612: var tmp10 any - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("=")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{v9, v3}) - if lang.IsTruthy(tmp14) { + checkDerefMacro(glojure_DOT_core__EQ_) + tmp11 := glojure_DOT_core__EQ_.Get() + tmp12 := lang.Apply(tmp11, []any{v9, v3}) + if lang.IsTruthy(tmp12) { tmp10 = v7 } else { - var tmp15 any = v8 - tmp17 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp18 := tmp17.FindInternedVar(lang.NewSymbol("+")) - if tmp18.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp18))) - } - tmp19 := tmp18.Get() - tmp20 := lang.Apply(tmp19, []any{v7, v8}) - var tmp16 any = tmp20 - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("inc")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.Apply(tmp24, []any{v9}) - var tmp21 any = tmp25 - v7 = tmp15 - v8 = tmp16 - v9 = tmp21 + var tmp13 any = v8 + checkDerefMacro(glojure_DOT_core__PLUS_) + tmp15 := glojure_DOT_core__PLUS_.Get() + tmp16 := lang.Apply(tmp15, []any{v7, v8}) + var tmp14 any = tmp16 + checkDerefMacro(glojure_DOT_core_inc) + tmp18 := glojure_DOT_core_inc.Get() + tmp19 := lang.Apply(tmp18, []any{v9}) + var tmp17 any = tmp19 + v7 = tmp13 + v8 = tmp14 + v9 = tmp17 goto recur_loop_1612 } return tmp10 diff --git a/pkg/codegen/testdata/codegen/test/loop_simple.go b/pkg/codegen/testdata/codegen/test/loop_simple/load.go.out similarity index 65% rename from pkg/codegen/testdata/codegen/test/loop_simple.go rename to pkg/codegen/testdata/codegen/test/loop_simple/load.go.out index ae4aef2d..57dd724a 100644 --- a/pkg/codegen/testdata/codegen/test/loop_simple.go +++ b/pkg/codegen/testdata/codegen/test/loop_simple/load.go.out @@ -1,13 +1,26 @@ // Code generated by glojure codegen. DO NOT EDIT. -package generated +package loop_simple import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" ) -func init() { +// LoadNS initializes the namespace "codegen.test.loop-simple" +func LoadNS() { + checkDerefMacro := func(v *lang.Var) { + if v.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) + } + } + _ = checkDerefMacro + // var codegen.test.loop-simple/simple-loop + codegen_DOT_test_DOT_loop_simple_simple_loop := lang.InternVarName(lang.NewSymbol("codegen.test.loop-simple"), lang.NewSymbol("simple-loop")) + // var glojure.core/< + glojure_DOT_core__LT_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("<")) + // var glojure.core/inc + glojure_DOT_core_inc := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("inc")) // reference fmt to avoid unused import error _ = fmt.Printf ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.loop-simple")) @@ -20,14 +33,10 @@ func init() { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - tmp3 := lang.FindNamespace(lang.NewSymbol("codegen.test.loop-simple")) - tmp4 := tmp3.FindInternedVar(lang.NewSymbol("simple-loop")) - if tmp4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp4))) - } - tmp5 := tmp4.Get() - tmp6 := lang.Apply(tmp5, nil) - return tmp6 + checkDerefMacro(codegen_DOT_test_DOT_loop_simple_simple_loop) + tmp3 := codegen_DOT_test_DOT_loop_simple_simple_loop.Get() + tmp4 := lang.Apply(tmp3, nil) + return tmp4 }) tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) @@ -50,23 +59,15 @@ func init() { _ = v4 for { var tmp5 any - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("<")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(tmp8, []any{v4, int64(10)}) - if lang.IsTruthy(tmp9) { - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("inc")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{v4}) - var tmp10 any = tmp14 - v4 = tmp10 + checkDerefMacro(glojure_DOT_core__LT_) + tmp6 := glojure_DOT_core__LT_.Get() + tmp7 := lang.Apply(tmp6, []any{v4, int64(10)}) + if lang.IsTruthy(tmp7) { + checkDerefMacro(glojure_DOT_core_inc) + tmp9 := glojure_DOT_core_inc.Get() + tmp10 := lang.Apply(tmp9, []any{v4}) + var tmp8 any = tmp10 + v4 = tmp8 continue } else { tmp5 = v4 diff --git a/pkg/codegen/testdata/codegen/test/maybe_class.go b/pkg/codegen/testdata/codegen/test/maybe_class/load.go.out similarity index 67% rename from pkg/codegen/testdata/codegen/test/maybe_class.go rename to pkg/codegen/testdata/codegen/test/maybe_class/load.go.out index fedb603c..7c5e85b2 100644 --- a/pkg/codegen/testdata/codegen/test/maybe_class.go +++ b/pkg/codegen/testdata/codegen/test/maybe_class/load.go.out @@ -1,6 +1,6 @@ // Code generated by glojure codegen. DO NOT EDIT. -package generated +package maybe_class import ( fmt "fmt" @@ -8,7 +8,16 @@ import ( strings2 "strings" ) -func init() { +// LoadNS initializes the namespace "codegen.test.maybe-class" +func LoadNS() { + checkDerefMacro := func(v *lang.Var) { + if v.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) + } + } + _ = checkDerefMacro + // var glojure.core/vec + glojure_DOT_core_vec := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("vec")) // reference fmt to avoid unused import error _ = fmt.Printf ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.maybe-class")) @@ -21,15 +30,11 @@ func init() { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - tmp3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp4 := tmp3.FindInternedVar(lang.NewSymbol("vec")) - if tmp4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp4))) - } - tmp5 := tmp4.Get() - tmp6 := lang.Apply(strings2.Split, []any{"1,2,3", ","}) - tmp7 := lang.Apply(tmp5, []any{tmp6}) - return tmp7 + checkDerefMacro(glojure_DOT_core_vec) + tmp3 := glojure_DOT_core_vec.Get() + tmp4 := lang.Apply(strings2.Split, []any{"1,2,3", ","}) + tmp5 := lang.Apply(tmp3, []any{tmp4}) + return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) diff --git a/pkg/codegen/testdata/codegen/test/multifn.go b/pkg/codegen/testdata/codegen/test/multifn/load.go.out similarity index 50% rename from pkg/codegen/testdata/codegen/test/multifn.go rename to pkg/codegen/testdata/codegen/test/multifn/load.go.out index 8d2dbcc9..d019e5e2 100644 --- a/pkg/codegen/testdata/codegen/test/multifn.go +++ b/pkg/codegen/testdata/codegen/test/multifn/load.go.out @@ -1,6 +1,6 @@ // Code generated by glojure codegen. DO NOT EDIT. -package generated +package multifn import ( fmt "fmt" @@ -8,7 +8,22 @@ import ( reflect "reflect" ) -func init() { +// LoadNS initializes the namespace "codegen.test.multifn" +func LoadNS() { + checkDerefMacro := func(v *lang.Var) { + if v.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) + } + } + _ = checkDerefMacro + // var codegen.test.multifn/add + codegen_DOT_test_DOT_multifn_add := lang.InternVarName(lang.NewSymbol("codegen.test.multifn"), lang.NewSymbol("add")) + // var glojure.core/+ + glojure_DOT_core__PLUS_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("+")) + // var glojure.core/str + glojure_DOT_core_str := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("str")) + // var glojure.core/type + glojure_DOT_core_type := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("type")) // reference fmt to avoid unused import error _ = fmt.Printf ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.multifn")) @@ -21,35 +36,19 @@ func init() { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - tmp3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp4 := tmp3.FindInternedVar(lang.NewSymbol("str")) - if tmp4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp4))) - } - tmp5 := tmp4.Get() - tmp6 := lang.FindNamespace(lang.NewSymbol("codegen.test.multifn")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("add")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(tmp8, []any{int64(3), int64(4)}) - tmp10 := lang.FindNamespace(lang.NewSymbol("codegen.test.multifn")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("add")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.Apply(tmp12, []any{float64(3.5), float64(4.5)}) - tmp14 := lang.FindNamespace(lang.NewSymbol("codegen.test.multifn")) - tmp15 := tmp14.FindInternedVar(lang.NewSymbol("add")) - if tmp15.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp15))) - } - tmp16 := tmp15.Get() - tmp17 := lang.Apply(tmp16, []any{"3", "4"}) - tmp18 := lang.Apply(tmp5, []any{tmp9, " ", tmp13, " ", tmp17}) - return tmp18 + checkDerefMacro(glojure_DOT_core_str) + tmp3 := glojure_DOT_core_str.Get() + checkDerefMacro(codegen_DOT_test_DOT_multifn_add) + tmp4 := codegen_DOT_test_DOT_multifn_add.Get() + tmp5 := lang.Apply(tmp4, []any{int64(3), int64(4)}) + checkDerefMacro(codegen_DOT_test_DOT_multifn_add) + tmp6 := codegen_DOT_test_DOT_multifn_add.Get() + tmp7 := lang.Apply(tmp6, []any{float64(3.5), float64(4.5)}) + checkDerefMacro(codegen_DOT_test_DOT_multifn_add) + tmp8 := codegen_DOT_test_DOT_multifn_add.Get() + tmp9 := lang.Apply(tmp8, []any{"3", "4"}) + tmp10 := lang.Apply(tmp3, []any{tmp5, " ", tmp7, " ", tmp9}) + return tmp10 }) tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) @@ -69,14 +68,10 @@ func init() { _ = v4 v5 := args[1] _ = v5 - tmp6 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("type")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(tmp8, []any{v4}) - return tmp9 + checkDerefMacro(glojure_DOT_core_type) + tmp6 := glojure_DOT_core_type.Get() + tmp7 := lang.Apply(tmp6, []any{v4}) + return tmp7 }) tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/multifn.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(44), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(62))).(lang.FnFunc) tmp2 := lang.NewMultiFn("add", tmp3, lang.NewKeyword("default"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")).FindInternedVar(lang.NewSymbol("global-hierarchy"))) @@ -90,21 +85,13 @@ func init() { _ = v6 v7 := args[1] _ = v7 - tmp8 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("str")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("+")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{v6, v7}) - tmp15 := lang.Apply(tmp10, []any{"int64: ", tmp14}) - return tmp15 + checkDerefMacro(glojure_DOT_core_str) + tmp8 := glojure_DOT_core_str.Get() + checkDerefMacro(glojure_DOT_core__PLUS_) + tmp9 := glojure_DOT_core__PLUS_.Get() + tmp10 := lang.Apply(tmp9, []any{v6, v7}) + tmp11 := lang.Apply(tmp8, []any{"int64: ", tmp10}) + return tmp11 }) tmp2.AddMethod(tmp4, tmp5) tmp6 := reflect.TypeOf(float64(0)) @@ -117,21 +104,13 @@ func init() { _ = v8 v9 := args[1] _ = v9 - tmp10 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp11 := tmp10.FindInternedVar(lang.NewSymbol("str")) - if tmp11.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp11))) - } - tmp12 := tmp11.Get() - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("+")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.Apply(tmp15, []any{v8, v9}) - tmp17 := lang.Apply(tmp12, []any{"float64: ", tmp16}) - return tmp17 + checkDerefMacro(glojure_DOT_core_str) + tmp10 := glojure_DOT_core_str.Get() + checkDerefMacro(glojure_DOT_core__PLUS_) + tmp11 := glojure_DOT_core__PLUS_.Get() + tmp12 := lang.Apply(tmp11, []any{v8, v9}) + tmp13 := lang.Apply(tmp10, []any{"float64: ", tmp12}) + return tmp13 }) tmp2.AddMethod(tmp6, tmp7) var tmp8 lang.FnFunc @@ -143,14 +122,10 @@ func init() { _ = v9 v10 := args[1] _ = v10 - tmp11 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp12 := tmp11.FindInternedVar(lang.NewSymbol("str")) - if tmp12.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp12))) - } - tmp13 := tmp12.Get() - tmp14 := lang.Apply(tmp13, []any{"default: ", v9, " ", v10}) - return tmp14 + checkDerefMacro(glojure_DOT_core_str) + tmp11 := glojure_DOT_core_str.Get() + tmp12 := lang.Apply(tmp11, []any{"default: ", v9, " ", v10}) + return tmp12 }) tmp2.AddMethod(lang.NewKeyword("default"), tmp8) tmp1 := ns.InternWithValue(tmp0, tmp2, true) diff --git a/pkg/codegen/testdata/codegen/test/ns_skip.go b/pkg/codegen/testdata/codegen/test/ns_skip/load.go.out similarity index 50% rename from pkg/codegen/testdata/codegen/test/ns_skip.go rename to pkg/codegen/testdata/codegen/test/ns_skip/load.go.out index 64042a3f..a9050b8e 100644 --- a/pkg/codegen/testdata/codegen/test/ns_skip.go +++ b/pkg/codegen/testdata/codegen/test/ns_skip/load.go.out @@ -1,13 +1,20 @@ // Code generated by glojure codegen. DO NOT EDIT. -package generated +package ns_skip import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" ) -func init() { +// LoadNS initializes the namespace "codegen.test.ns-skip" +func LoadNS() { + checkDerefMacro := func(v *lang.Var) { + if v.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) + } + } + _ = checkDerefMacro // reference fmt to avoid unused import error _ = fmt.Printf ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.ns-skip")) diff --git a/pkg/codegen/testdata/codegen/test/quote_simple.go b/pkg/codegen/testdata/codegen/test/quote_simple/load.go.out similarity index 82% rename from pkg/codegen/testdata/codegen/test/quote_simple.go rename to pkg/codegen/testdata/codegen/test/quote_simple/load.go.out index dc973b58..4964834b 100644 --- a/pkg/codegen/testdata/codegen/test/quote_simple.go +++ b/pkg/codegen/testdata/codegen/test/quote_simple/load.go.out @@ -1,13 +1,20 @@ // Code generated by glojure codegen. DO NOT EDIT. -package generated +package quote_simple import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" ) -func init() { +// LoadNS initializes the namespace "codegen.test.quote-simple" +func LoadNS() { + checkDerefMacro := func(v *lang.Var) { + if v.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) + } + } + _ = checkDerefMacro // reference fmt to avoid unused import error _ = fmt.Printf ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.quote-simple")) diff --git a/pkg/codegen/testdata/codegen/test/ref.go b/pkg/codegen/testdata/codegen/test/ref/load.go.out similarity index 70% rename from pkg/codegen/testdata/codegen/test/ref.go rename to pkg/codegen/testdata/codegen/test/ref/load.go.out index f011bf0d..e15df75e 100644 --- a/pkg/codegen/testdata/codegen/test/ref.go +++ b/pkg/codegen/testdata/codegen/test/ref/load.go.out @@ -1,13 +1,24 @@ // Code generated by glojure codegen. DO NOT EDIT. -package generated +package ref import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" ) -func init() { +// LoadNS initializes the namespace "codegen.test.ref" +func LoadNS() { + checkDerefMacro := func(v *lang.Var) { + if v.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) + } + } + _ = checkDerefMacro + // var codegen.test.ref/test-ref + codegen_DOT_test_DOT_ref_test_ref := lang.InternVarName(lang.NewSymbol("codegen.test.ref"), lang.NewSymbol("test-ref")) + // var glojure.core/deref + glojure_DOT_core_deref := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("deref")) // reference fmt to avoid unused import error _ = fmt.Printf ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.ref")) @@ -20,20 +31,12 @@ func init() { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - tmp3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp4 := tmp3.FindInternedVar(lang.NewSymbol("deref")) - if tmp4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp4))) - } - tmp5 := tmp4.Get() - tmp6 := lang.FindNamespace(lang.NewSymbol("codegen.test.ref")) - tmp7 := tmp6.FindInternedVar(lang.NewSymbol("test-ref")) - if tmp7.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp7))) - } - tmp8 := tmp7.Get() - tmp9 := lang.Apply(tmp5, []any{tmp8}) - return tmp9 + checkDerefMacro(glojure_DOT_core_deref) + tmp3 := glojure_DOT_core_deref.Get() + checkDerefMacro(codegen_DOT_test_DOT_ref_test_ref) + tmp4 := codegen_DOT_test_DOT_ref_test_ref.Get() + tmp5 := lang.Apply(tmp3, []any{tmp4}) + return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) diff --git a/pkg/codegen/testdata/codegen/test/the_var.go b/pkg/codegen/testdata/codegen/test/the_var/load.go.out similarity index 88% rename from pkg/codegen/testdata/codegen/test/the_var.go rename to pkg/codegen/testdata/codegen/test/the_var/load.go.out index f2674402..95b8e674 100644 --- a/pkg/codegen/testdata/codegen/test/the_var.go +++ b/pkg/codegen/testdata/codegen/test/the_var/load.go.out @@ -1,6 +1,6 @@ // Code generated by glojure codegen. DO NOT EDIT. -package generated +package the_var import ( fmt "fmt" @@ -8,7 +8,14 @@ import ( reflect "reflect" ) -func init() { +// LoadNS initializes the namespace "codegen.test.the-var" +func LoadNS() { + checkDerefMacro := func(v *lang.Var) { + if v.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) + } + } + _ = checkDerefMacro // reference fmt to avoid unused import error _ = fmt.Printf ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.the-var")) diff --git a/pkg/codegen/testdata/codegen/test/throw_simple.go b/pkg/codegen/testdata/codegen/test/throw_simple/load.go.out similarity index 81% rename from pkg/codegen/testdata/codegen/test/throw_simple.go rename to pkg/codegen/testdata/codegen/test/throw_simple/load.go.out index 438ebc6c..b9ee93aa 100644 --- a/pkg/codegen/testdata/codegen/test/throw_simple.go +++ b/pkg/codegen/testdata/codegen/test/throw_simple/load.go.out @@ -1,13 +1,20 @@ // Code generated by glojure codegen. DO NOT EDIT. -package generated +package throw_simple import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" ) -func init() { +// LoadNS initializes the namespace "codegen.test.throw-simple" +func LoadNS() { + checkDerefMacro := func(v *lang.Var) { + if v.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) + } + } + _ = checkDerefMacro // reference fmt to avoid unused import error _ = fmt.Printf ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.throw-simple")) diff --git a/pkg/codegen/testdata/codegen/test/try_advanced.go b/pkg/codegen/testdata/codegen/test/try_advanced/load.go.out similarity index 69% rename from pkg/codegen/testdata/codegen/test/try_advanced.go rename to pkg/codegen/testdata/codegen/test/try_advanced/load.go.out index b2ef24a8..92af9d32 100644 --- a/pkg/codegen/testdata/codegen/test/try_advanced.go +++ b/pkg/codegen/testdata/codegen/test/try_advanced/load.go.out @@ -1,13 +1,30 @@ // Code generated by glojure codegen. DO NOT EDIT. -package generated +package try_advanced import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" ) -func init() { +// LoadNS initializes the namespace "codegen.test.try-advanced" +func LoadNS() { + checkDerefMacro := func(v *lang.Var) { + if v.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) + } + } + _ = checkDerefMacro + // var codegen.test.try-advanced/catch-binding-scope + codegen_DOT_test_DOT_try_advanced_catch_binding_scope := lang.InternVarName(lang.NewSymbol("codegen.test.try-advanced"), lang.NewSymbol("catch-binding-scope")) + // var codegen.test.try-advanced/catch-binding-scope-2 + codegen_DOT_test_DOT_try_advanced_catch_binding_scope_2 := lang.InternVarName(lang.NewSymbol("codegen.test.try-advanced"), lang.NewSymbol("catch-binding-scope-2")) + // var codegen.test.try-advanced/finally-with-return + codegen_DOT_test_DOT_try_advanced_finally_with_return := lang.InternVarName(lang.NewSymbol("codegen.test.try-advanced"), lang.NewSymbol("finally-with-return")) + // var codegen.test.try-advanced/try-custom-value + codegen_DOT_test_DOT_try_advanced_try_custom_value := lang.InternVarName(lang.NewSymbol("codegen.test.try-advanced"), lang.NewSymbol("try-custom-value")) + // var glojure.core/= + glojure_DOT_core__EQ_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("=")) // reference fmt to avoid unused import error _ = fmt.Printf ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-advanced")) @@ -21,85 +38,53 @@ func init() { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } var tmp3 any - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("=")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("codegen.test.try-advanced")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("try-custom-value")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp9, nil) - tmp11 := lang.Apply(tmp6, []any{tmp10, "custom error"}) - if lang.IsTruthy(tmp11) { + checkDerefMacro(glojure_DOT_core__EQ_) + tmp4 := glojure_DOT_core__EQ_.Get() + checkDerefMacro(codegen_DOT_test_DOT_try_advanced_try_custom_value) + tmp5 := codegen_DOT_test_DOT_try_advanced_try_custom_value.Get() + tmp6 := lang.Apply(tmp5, nil) + tmp7 := lang.Apply(tmp4, []any{tmp6, "custom error"}) + if lang.IsTruthy(tmp7) { } else { panic("try-custom-value failed") } _ = tmp3 - var tmp12 any - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("=")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.FindNamespace(lang.NewSymbol("codegen.test.try-advanced")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("catch-binding-scope")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, nil) - tmp20 := lang.Apply(tmp15, []any{tmp19, "test"}) - if lang.IsTruthy(tmp20) { + var tmp8 any + checkDerefMacro(glojure_DOT_core__EQ_) + tmp9 := glojure_DOT_core__EQ_.Get() + checkDerefMacro(codegen_DOT_test_DOT_try_advanced_catch_binding_scope) + tmp10 := codegen_DOT_test_DOT_try_advanced_catch_binding_scope.Get() + tmp11 := lang.Apply(tmp10, nil) + tmp12 := lang.Apply(tmp9, []any{tmp11, "test"}) + if lang.IsTruthy(tmp12) { } else { panic("catch-binding-scope failed") } - _ = tmp12 - var tmp21 any - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("=")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.FindNamespace(lang.NewSymbol("codegen.test.try-advanced")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("catch-binding-scope-2")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.Apply(tmp27, nil) - tmp29 := lang.Apply(tmp24, []any{tmp28, "outer"}) - if lang.IsTruthy(tmp29) { + _ = tmp8 + var tmp13 any + checkDerefMacro(glojure_DOT_core__EQ_) + tmp14 := glojure_DOT_core__EQ_.Get() + checkDerefMacro(codegen_DOT_test_DOT_try_advanced_catch_binding_scope_2) + tmp15 := codegen_DOT_test_DOT_try_advanced_catch_binding_scope_2.Get() + tmp16 := lang.Apply(tmp15, nil) + tmp17 := lang.Apply(tmp14, []any{tmp16, "outer"}) + if lang.IsTruthy(tmp17) { } else { panic("catch-binding-scope-2 failed") } - _ = tmp21 - var tmp30 any - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("=")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.FindNamespace(lang.NewSymbol("codegen.test.try-advanced")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("finally-with-return")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.Apply(tmp36, nil) - tmp38 := lang.Apply(tmp33, []any{tmp37, int64(42)}) - if lang.IsTruthy(tmp38) { + _ = tmp13 + var tmp18 any + checkDerefMacro(glojure_DOT_core__EQ_) + tmp19 := glojure_DOT_core__EQ_.Get() + checkDerefMacro(codegen_DOT_test_DOT_try_advanced_finally_with_return) + tmp20 := codegen_DOT_test_DOT_try_advanced_finally_with_return.Get() + tmp21 := lang.Apply(tmp20, nil) + tmp22 := lang.Apply(tmp19, []any{tmp21, int64(42)}) + if lang.IsTruthy(tmp22) { } else { panic("finally-with-return failed") } - _ = tmp30 + _ = tmp18 return "advanced tests passed" }) tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) diff --git a/pkg/codegen/testdata/codegen/test/try_basic.go b/pkg/codegen/testdata/codegen/test/try_basic/load.go.out similarity index 66% rename from pkg/codegen/testdata/codegen/test/try_basic.go rename to pkg/codegen/testdata/codegen/test/try_basic/load.go.out index be1f2f36..75a91de7 100644 --- a/pkg/codegen/testdata/codegen/test/try_basic.go +++ b/pkg/codegen/testdata/codegen/test/try_basic/load.go.out @@ -1,13 +1,34 @@ // Code generated by glojure codegen. DO NOT EDIT. -package generated +package try_basic import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" ) -func init() { +// LoadNS initializes the namespace "codegen.test.try-basic" +func LoadNS() { + checkDerefMacro := func(v *lang.Var) { + if v.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) + } + } + _ = checkDerefMacro + // var codegen.test.try-basic/basic-try + codegen_DOT_test_DOT_try_basic_basic_try := lang.InternVarName(lang.NewSymbol("codegen.test.try-basic"), lang.NewSymbol("basic-try")) + // var codegen.test.try-basic/nested-try + codegen_DOT_test_DOT_try_basic_nested_try := lang.InternVarName(lang.NewSymbol("codegen.test.try-basic"), lang.NewSymbol("nested-try")) + // var codegen.test.try-basic/try-catch-finally + codegen_DOT_test_DOT_try_basic_try_catch_finally := lang.InternVarName(lang.NewSymbol("codegen.test.try-basic"), lang.NewSymbol("try-catch-finally")) + // var codegen.test.try-basic/try-finally-only + codegen_DOT_test_DOT_try_basic_try_finally_only := lang.InternVarName(lang.NewSymbol("codegen.test.try-basic"), lang.NewSymbol("try-finally-only")) + // var codegen.test.try-basic/try-no-catch + codegen_DOT_test_DOT_try_basic_try_no_catch := lang.InternVarName(lang.NewSymbol("codegen.test.try-basic"), lang.NewSymbol("try-no-catch")) + // var codegen.test.try-basic/try-with-throw + codegen_DOT_test_DOT_try_basic_try_with_throw := lang.InternVarName(lang.NewSymbol("codegen.test.try-basic"), lang.NewSymbol("try-with-throw")) + // var glojure.core/= + glojure_DOT_core__EQ_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("=")) // reference fmt to avoid unused import error _ = fmt.Printf ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")) @@ -21,125 +42,77 @@ func init() { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } var tmp3 any - tmp4 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp5 := tmp4.FindInternedVar(lang.NewSymbol("=")) - if tmp5.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp5))) - } - tmp6 := tmp5.Get() - tmp7 := lang.FindNamespace(lang.NewSymbol("codegen.test.try-basic")) - tmp8 := tmp7.FindInternedVar(lang.NewSymbol("basic-try")) - if tmp8.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp8))) - } - tmp9 := tmp8.Get() - tmp10 := lang.Apply(tmp9, nil) - tmp11 := lang.Apply(tmp6, []any{tmp10, "success"}) - if lang.IsTruthy(tmp11) { + checkDerefMacro(glojure_DOT_core__EQ_) + tmp4 := glojure_DOT_core__EQ_.Get() + checkDerefMacro(codegen_DOT_test_DOT_try_basic_basic_try) + tmp5 := codegen_DOT_test_DOT_try_basic_basic_try.Get() + tmp6 := lang.Apply(tmp5, nil) + tmp7 := lang.Apply(tmp4, []any{tmp6, "success"}) + if lang.IsTruthy(tmp7) { } else { panic("basic-try failed") } _ = tmp3 - var tmp12 any - tmp13 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp14 := tmp13.FindInternedVar(lang.NewSymbol("=")) - if tmp14.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp14))) - } - tmp15 := tmp14.Get() - tmp16 := lang.FindNamespace(lang.NewSymbol("codegen.test.try-basic")) - tmp17 := tmp16.FindInternedVar(lang.NewSymbol("try-with-throw")) - if tmp17.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp17))) - } - tmp18 := tmp17.Get() - tmp19 := lang.Apply(tmp18, nil) - tmp20 := lang.Apply(tmp15, []any{tmp19, "caught exception"}) - if lang.IsTruthy(tmp20) { + var tmp8 any + checkDerefMacro(glojure_DOT_core__EQ_) + tmp9 := glojure_DOT_core__EQ_.Get() + checkDerefMacro(codegen_DOT_test_DOT_try_basic_try_with_throw) + tmp10 := codegen_DOT_test_DOT_try_basic_try_with_throw.Get() + tmp11 := lang.Apply(tmp10, nil) + tmp12 := lang.Apply(tmp9, []any{tmp11, "caught exception"}) + if lang.IsTruthy(tmp12) { } else { panic("try-with-throw failed") } - _ = tmp12 - var tmp21 any - tmp22 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp23 := tmp22.FindInternedVar(lang.NewSymbol("=")) - if tmp23.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp23))) - } - tmp24 := tmp23.Get() - tmp25 := lang.FindNamespace(lang.NewSymbol("codegen.test.try-basic")) - tmp26 := tmp25.FindInternedVar(lang.NewSymbol("try-no-catch")) - if tmp26.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp26))) - } - tmp27 := tmp26.Get() - tmp28 := lang.Apply(tmp27, nil) - tmp29 := lang.Apply(tmp24, []any{tmp28, "just body"}) - if lang.IsTruthy(tmp29) { + _ = tmp8 + var tmp13 any + checkDerefMacro(glojure_DOT_core__EQ_) + tmp14 := glojure_DOT_core__EQ_.Get() + checkDerefMacro(codegen_DOT_test_DOT_try_basic_try_no_catch) + tmp15 := codegen_DOT_test_DOT_try_basic_try_no_catch.Get() + tmp16 := lang.Apply(tmp15, nil) + tmp17 := lang.Apply(tmp14, []any{tmp16, "just body"}) + if lang.IsTruthy(tmp17) { } else { panic("try-no-catch failed") } - _ = tmp21 - var tmp30 any - tmp31 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp32 := tmp31.FindInternedVar(lang.NewSymbol("=")) - if tmp32.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp32))) - } - tmp33 := tmp32.Get() - tmp34 := lang.FindNamespace(lang.NewSymbol("codegen.test.try-basic")) - tmp35 := tmp34.FindInternedVar(lang.NewSymbol("try-finally-only")) - if tmp35.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp35))) - } - tmp36 := tmp35.Get() - tmp37 := lang.Apply(tmp36, nil) - tmp38 := lang.Apply(tmp33, []any{tmp37, "body"}) - if lang.IsTruthy(tmp38) { + _ = tmp13 + var tmp18 any + checkDerefMacro(glojure_DOT_core__EQ_) + tmp19 := glojure_DOT_core__EQ_.Get() + checkDerefMacro(codegen_DOT_test_DOT_try_basic_try_finally_only) + tmp20 := codegen_DOT_test_DOT_try_basic_try_finally_only.Get() + tmp21 := lang.Apply(tmp20, nil) + tmp22 := lang.Apply(tmp19, []any{tmp21, "body"}) + if lang.IsTruthy(tmp22) { } else { panic("try-finally-only failed") } - _ = tmp30 - var tmp39 any - tmp40 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp41 := tmp40.FindInternedVar(lang.NewSymbol("=")) - if tmp41.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp41))) - } - tmp42 := tmp41.Get() - tmp43 := lang.FindNamespace(lang.NewSymbol("codegen.test.try-basic")) - tmp44 := tmp43.FindInternedVar(lang.NewSymbol("try-catch-finally")) - if tmp44.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp44))) - } - tmp45 := tmp44.Get() - tmp46 := lang.Apply(tmp45, nil) - tmp47 := lang.Apply(tmp42, []any{tmp46, "caught"}) - if lang.IsTruthy(tmp47) { + _ = tmp18 + var tmp23 any + checkDerefMacro(glojure_DOT_core__EQ_) + tmp24 := glojure_DOT_core__EQ_.Get() + checkDerefMacro(codegen_DOT_test_DOT_try_basic_try_catch_finally) + tmp25 := codegen_DOT_test_DOT_try_basic_try_catch_finally.Get() + tmp26 := lang.Apply(tmp25, nil) + tmp27 := lang.Apply(tmp24, []any{tmp26, "caught"}) + if lang.IsTruthy(tmp27) { } else { panic("try-catch-finally failed") } - _ = tmp39 - var tmp48 any - tmp49 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp50 := tmp49.FindInternedVar(lang.NewSymbol("=")) - if tmp50.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp50))) - } - tmp51 := tmp50.Get() - tmp52 := lang.FindNamespace(lang.NewSymbol("codegen.test.try-basic")) - tmp53 := tmp52.FindInternedVar(lang.NewSymbol("nested-try")) - if tmp53.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp53))) - } - tmp54 := tmp53.Get() - tmp55 := lang.Apply(tmp54, nil) - tmp56 := lang.Apply(tmp51, []any{tmp55, "inner caught"}) - if lang.IsTruthy(tmp56) { + _ = tmp23 + var tmp28 any + checkDerefMacro(glojure_DOT_core__EQ_) + tmp29 := glojure_DOT_core__EQ_.Get() + checkDerefMacro(codegen_DOT_test_DOT_try_basic_nested_try) + tmp30 := codegen_DOT_test_DOT_try_basic_nested_try.Get() + tmp31 := lang.Apply(tmp30, nil) + tmp32 := lang.Apply(tmp29, []any{tmp31, "inner caught"}) + if lang.IsTruthy(tmp32) { } else { panic("nested-try failed") } - _ = tmp48 + _ = tmp28 return "all tests passed" }) tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) diff --git a/pkg/codegen/testdata/codegen/test/values.go b/pkg/codegen/testdata/codegen/test/values/load.go.out similarity index 70% rename from pkg/codegen/testdata/codegen/test/values.go rename to pkg/codegen/testdata/codegen/test/values/load.go.out index 62c35731..51356eac 100644 --- a/pkg/codegen/testdata/codegen/test/values.go +++ b/pkg/codegen/testdata/codegen/test/values/load.go.out @@ -1,6 +1,6 @@ // Code generated by glojure codegen. DO NOT EDIT. -package generated +package values import ( hex2 "encoding/hex" @@ -10,7 +10,18 @@ import ( reflect "reflect" ) -func init() { +// LoadNS initializes the namespace "codegen.test.values" +func LoadNS() { + checkDerefMacro := func(v *lang.Var) { + if v.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) + } + } + _ = checkDerefMacro + // var codegen.test.values/big-decimal + codegen_DOT_test_DOT_values_big_decimal := lang.InternVarName(lang.NewSymbol("codegen.test.values"), lang.NewSymbol("big-decimal")) + // var codegen.test.values/big-decimal-type + codegen_DOT_test_DOT_values_big_decimal_type := lang.InternVarName(lang.NewSymbol("codegen.test.values"), lang.NewSymbol("big-decimal-type")) // reference fmt to avoid unused import error _ = fmt.Printf ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.values")) @@ -32,25 +43,17 @@ func init() { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - tmp5 := lang.FindNamespace(lang.NewSymbol("codegen.test.values")) - tmp6 := tmp5.FindInternedVar(lang.NewSymbol("big-decimal")) - if tmp6.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp6))) - } - tmp7 := tmp6.Get() - tmp8 := lang.FindNamespace(lang.NewSymbol("codegen.test.values")) - tmp9 := tmp8.FindInternedVar(lang.NewSymbol("big-decimal-type")) - if tmp9.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp9))) - } - tmp10 := tmp9.Get() - tmp11 := lang.NewVector(tmp7, tmp10) - tmp12 := lang.NewMap(lang.NewKeyword("file"), "codegen/test/values.glj", lang.NewKeyword("line"), int(7), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(7), lang.NewKeyword("end-column"), int(32)) - tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + checkDerefMacro(codegen_DOT_test_DOT_values_big_decimal) + tmp5 := codegen_DOT_test_DOT_values_big_decimal.Get() + checkDerefMacro(codegen_DOT_test_DOT_values_big_decimal_type) + tmp6 := codegen_DOT_test_DOT_values_big_decimal_type.Get() + tmp7 := lang.NewVector(tmp5, tmp6) + tmp8 := lang.NewMap(lang.NewKeyword("file"), "codegen/test/values.glj", lang.NewKeyword("line"), int(7), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(7), lang.NewKeyword("end-column"), int(32)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) if err != nil { panic(err) } - return tmp13 + return tmp9 }) tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) tmp3 := ns.InternWithValue(tmp0, tmp4, true) diff --git a/pkg/codegen/testdata/codegen/test/with_meta.go b/pkg/codegen/testdata/codegen/test/with_meta/load.go.out similarity index 65% rename from pkg/codegen/testdata/codegen/test/with_meta.go rename to pkg/codegen/testdata/codegen/test/with_meta/load.go.out index 8ce869e8..2040dd36 100644 --- a/pkg/codegen/testdata/codegen/test/with_meta.go +++ b/pkg/codegen/testdata/codegen/test/with_meta/load.go.out @@ -1,13 +1,22 @@ // Code generated by glojure codegen. DO NOT EDIT. -package generated +package with_meta import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" ) -func init() { +// LoadNS initializes the namespace "codegen.test.with-meta" +func LoadNS() { + checkDerefMacro := func(v *lang.Var) { + if v.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) + } + } + _ = checkDerefMacro + // var glojure.core/meta + glojure_DOT_core_meta := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("meta")) // reference fmt to avoid unused import error _ = fmt.Printf ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.with-meta")) @@ -20,26 +29,22 @@ func init() { if len(args) != 0 { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } - tmp3 := lang.FindNamespace(lang.NewSymbol("glojure.core")) - tmp4 := tmp3.FindInternedVar(lang.NewSymbol("meta")) - if tmp4.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", tmp4))) - } - tmp5 := tmp4.Get() - tmp6 := lang.NewVector() - tmp7 := lang.NewMap(lang.NewKeyword("foo"), lang.NewKeyword("bar"), lang.NewKeyword("file"), "codegen/test/with_meta.glj", lang.NewKeyword("line"), int(4), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(4), lang.NewKeyword("end-column"), int(28)) - tmp8 := lang.NewMap(lang.NewKeyword("file"), "codegen/test/with_meta.glj", lang.NewKeyword("line"), int(4), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(4), lang.NewKeyword("end-column"), int(26)) - tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + checkDerefMacro(glojure_DOT_core_meta) + tmp3 := glojure_DOT_core_meta.Get() + tmp4 := lang.NewVector() + tmp5 := lang.NewMap(lang.NewKeyword("foo"), lang.NewKeyword("bar"), lang.NewKeyword("file"), "codegen/test/with_meta.glj", lang.NewKeyword("line"), int(4), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(4), lang.NewKeyword("end-column"), int(28)) + tmp6 := lang.NewMap(lang.NewKeyword("file"), "codegen/test/with_meta.glj", lang.NewKeyword("line"), int(4), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(4), lang.NewKeyword("end-column"), int(26)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp10, err := lang.WithMeta(tmp6, tmp9.(lang.IPersistentMap)) + tmp8, err := lang.WithMeta(tmp4, tmp7.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp11 := lang.Apply(tmp5, []any{tmp10}) - tmp12 := lang.Apply(lang.NewKeyword("foo"), []any{tmp11}) - return tmp12 + tmp9 := lang.Apply(tmp3, []any{tmp8}) + tmp10 := lang.Apply(lang.NewKeyword("foo"), []any{tmp9}) + return tmp10 }) tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) From 6791fcd3a2b1dfca3e09669476a20351dfbb39d3 Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sat, 30 Aug 2025 19:43:34 -0700 Subject: [PATCH 47/67] Create temp main to run codegen tests Signed-off-by: James Hamlin --- pkg/codegen/codegengotest/codegengo_test.go | 292 ++++++++++++++++---- 1 file changed, 239 insertions(+), 53 deletions(-) diff --git a/pkg/codegen/codegengotest/codegengo_test.go b/pkg/codegen/codegengotest/codegengo_test.go index 39fb6444..42ae0acd 100644 --- a/pkg/codegen/codegengotest/codegengo_test.go +++ b/pkg/codegen/codegengotest/codegengo_test.go @@ -1,15 +1,15 @@ package codegengotest import ( + "bytes" "fmt" "io/ioutil" "os" + "os/exec" "path/filepath" "strings" "testing" - _ "github.com/glojurelang/glojure/pkg/codegen/testdata/codegen/test" - _ "github.com/glojurelang/glojure/pkg/glj" "github.com/glojurelang/glojure/pkg/lang" ) @@ -20,31 +20,16 @@ func TestMain(m *testing.M) { } func TestGeneratedGo(t *testing.T) { - // Find all .glj files in testdata directory + // Find all .out files in testdata directory testdataDir := "../testdata" - var namespaces []string + var outFiles []string err := filepath.Walk(testdataDir, func(path string, info os.FileInfo, err error) error { if err != nil { return err } - if strings.HasSuffix(path, ".glj") { - // Read first line to get namespace - content, err := ioutil.ReadFile(path) - if err != nil { - return err - } - lines := strings.Split(string(content), "\n") - if len(lines) > 0 && strings.HasPrefix(lines[0], "(ns ") { - // Extract namespace name - nsLine := lines[0] - nsLine = strings.TrimPrefix(nsLine, "(ns ") - nsLine = strings.TrimSuffix(nsLine, ")") - parts := strings.Fields(nsLine) - if len(parts) > 0 { - namespaces = append(namespaces, parts[0]) - } - } + if strings.HasSuffix(path, "load.go.out") { + outFiles = append(outFiles, path) } return nil }) @@ -52,49 +37,250 @@ func TestGeneratedGo(t *testing.T) { t.Fatalf("Error walking testdata: %v", err) } - for _, nsName := range namespaces { - nsName := nsName // Capture range variable - t.Run(nsName, func(t *testing.T) { - ns := lang.FindNamespace(lang.NewSymbol(nsName)) - if ns == nil { - t.Fatalf("namespace %s not found", nsName) + for _, outFile := range outFiles { + outFile := outFile // Capture range variable + // Extract package name from path (e.g., "const_keyword" from "codegen/test/const_keyword/load.go.out") + dir := filepath.Dir(outFile) + pkgName := filepath.Base(dir) + + t.Run(pkgName, func(t *testing.T) { + // Read the corresponding .glj file to check for -main metadata + gljFile := strings.TrimSuffix(outFile, "/load.go.out") + ".glj" + nsName, hasMain := getNamespaceMetadata(t, gljFile) + + if !hasMain { + t.Skip("No -main function with expected metadata") } - mainVar := ns.FindInternedVar(lang.NewSymbol("-main")) - if mainVar == nil { - t.Skip() + // Create temp directory for the Go program + tempDir, err := ioutil.TempDir("", "codegengo_test_*") + if err != nil { + t.Fatalf("Failed to create temp dir: %v", err) } + defer os.RemoveAll(tempDir) - // Check if -main has :expected-output metadata - meta := mainVar.Meta() - if meta == nil { - t.Fatalf("metadata for %s/-main is nil", nsName) + // Create package directory in temp dir + pkgDir := filepath.Join(tempDir, pkgName) + if err := os.MkdirAll(pkgDir, 0755); err != nil { + t.Fatalf("Failed to create package dir: %v", err) } - expected := meta.ValAt(lang.NewKeyword("expected-output")) - expectedThrow := meta.ValAt(lang.NewKeyword("expected-throw")) - if lang.IsNil(expected) && lang.IsNil(expectedThrow) { - t.Fatalf("no :expected-output or :expected-throw metadata for %s/-main", nsName) + // Copy .out file to package dir as .go file + outContent, err := ioutil.ReadFile(outFile) + if err != nil { + t.Fatalf("Failed to read .out file: %v", err) } - if !lang.IsNil(expectedThrow) { - defer func() { - if r := recover(); r != nil { - if !lang.Equals(r, expectedThrow) { - t.Errorf("%s/-main threw %v, expected %v", nsName, r, expectedThrow) - } - } else { - t.Errorf("%s/-main did not throw, expected %v", nsName, expectedThrow) - } - }() + goFile := filepath.Join(pkgDir, "load.go") + if err := ioutil.WriteFile(goFile, outContent, 0644); err != nil { + t.Fatalf("Failed to write .go file: %v", err) } - // Run -main and check the result - result := mainVar.Invoke() - if !lang.Equals(result, expected) { - fmt.Printf("Result of %s/-main: %+v (%T)\n", nsName, result, result) - t.Errorf("%s/-main returned %v, expected %v", nsName, result, expected) + // Generate main.go + mainContent := generateMainFile(pkgName, nsName) + mainFile := filepath.Join(tempDir, "main.go") + if err := ioutil.WriteFile(mainFile, []byte(mainContent), 0644); err != nil { + t.Fatalf("Failed to write main.go: %v", err) + } + + // Get absolute path to project root (we're in pkg/codegen/codegengotest) + projectRoot, err := filepath.Abs("../../..") + if err != nil { + t.Fatalf("Failed to get project root: %v", err) + } + + // Create go.mod with absolute path replacement + goModContent := fmt.Sprintf(`module testprog + +go 1.21 + +require github.com/glojurelang/glojure v0.0.0 + +replace github.com/glojurelang/glojure => %s +`, projectRoot) + goModFile := filepath.Join(tempDir, "go.mod") + if err := ioutil.WriteFile(goModFile, []byte(goModContent), 0644); err != nil { + t.Fatalf("Failed to write go.mod: %v", err) + } + + // Copy go.sum from project root + goSumSrc := filepath.Join(projectRoot, "go.sum") + goSumContent, err := ioutil.ReadFile(goSumSrc) + if err != nil { + t.Fatalf("Failed to read go.sum: %v", err) + } + goSumDst := filepath.Join(tempDir, "go.sum") + if err := ioutil.WriteFile(goSumDst, goSumContent, 0644); err != nil { + t.Fatalf("Failed to write go.sum: %v", err) + } + + // Run go mod tidy to ensure all dependencies are resolved + cmd := exec.Command("go", "mod", "tidy") + cmd.Dir = tempDir + var tidyStderr bytes.Buffer + cmd.Stderr = &tidyStderr + if err := cmd.Run(); err != nil { + t.Fatalf("Failed to run go mod tidy: %v\nStderr: %s", err, tidyStderr.String()) + } + + // Build the program + cmd = exec.Command("go", "build", "-o", "testprog", ".") + cmd.Dir = tempDir + var buildStderr bytes.Buffer + cmd.Stderr = &buildStderr + if err := cmd.Run(); err != nil { + t.Fatalf("Failed to build program: %v\nStderr: %s", err, buildStderr.String()) + } + + // Run the program + cmd = exec.Command("./testprog") + cmd.Dir = tempDir + var stdout, stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + + err = cmd.Run() + + if err != nil { + // Program exited with non-zero status - test failed + t.Errorf("Test failed: %v\nStdout: %s\nStderr: %s", err, stdout.String(), stderr.String()) } }) } } + +// getNamespaceMetadata reads a .glj file and extracts namespace and checks for -main +func getNamespaceMetadata(t *testing.T, gljFile string) (nsName string, hasMain bool) { + t.Helper() + + content, err := ioutil.ReadFile(gljFile) + if err != nil { + t.Logf("Could not read .glj file %s: %v", gljFile, err) + return "", false + } + + lines := strings.Split(string(content), "\n") + for i, line := range lines { + line = strings.TrimSpace(line) + if strings.HasPrefix(line, "(ns ") { + // Extract namespace name + nsLine := strings.TrimPrefix(line, "(ns ") + nsLine = strings.TrimSuffix(nsLine, ")") + parts := strings.Fields(nsLine) + if len(parts) > 0 { + nsName = parts[0] + } + } + // Look for -main definition with metadata + // Check if current line has metadata with :expected- or next line has defn -main + if strings.Contains(line, ":expected-") { + // Check if this line or next line has -main + if strings.Contains(line, "-main") { + hasMain = true + } else if i+1 < len(lines) && strings.Contains(lines[i+1], "-main") { + hasMain = true + } + } + } + + // If we couldn't find it from the file, try loading the namespace to check + if nsName != "" && !hasMain { + ns := lang.FindNamespace(lang.NewSymbol(nsName)) + if ns != nil { + mainVar := ns.FindInternedVar(lang.NewSymbol("-main")) + if mainVar != nil { + meta := mainVar.Meta() + if meta != nil { + if out := meta.ValAt(lang.NewKeyword("expected-output")); out != nil { + hasMain = true + } + if throw := meta.ValAt(lang.NewKeyword("expected-throw")); throw != nil { + hasMain = true + } + } + } + } + } + + return nsName, hasMain +} + +// generateMainFile generates a main.go file that imports and calls LoadNS +func generateMainFile(pkgName, nsName string) string { + mainFunc := fmt.Sprintf(` +func main() { + %s.LoadNS() + + ns := lang.FindNamespace(lang.NewSymbol("%s")) + if ns == nil { + fmt.Println("ERROR: namespace not found") + os.Exit(1) + } + + mainVar := ns.FindInternedVar(lang.NewSymbol("-main")) + if mainVar == nil { + fmt.Println("ERROR: -main function not found") + os.Exit(1) + } + + // Get metadata for expected output/throw + meta := mainVar.Meta() + if meta == nil { + fmt.Println("ERROR: -main has no metadata") + os.Exit(1) + } + + expectedOutput := meta.ValAt(lang.NewKeyword("expected-output")) + expectedThrow := meta.ValAt(lang.NewKeyword("expected-throw")) + + if expectedOutput == nil && expectedThrow == nil { + fmt.Println("ERROR: -main has no :expected-output or :expected-throw metadata") + os.Exit(1) + } + + if expectedThrow != nil { + // Expect a panic/throw + defer func() { + if r := recover(); r != nil { + if lang.Equals(r, expectedThrow) { + fmt.Println("SUCCESS: Got expected throw") + os.Exit(0) + } else { + fmt.Printf("FAIL: Expected throw %%v, got %%v\n", expectedThrow, r) + os.Exit(1) + } + } else { + fmt.Printf("FAIL: Expected throw %%v, but no panic occurred\n", expectedThrow) + os.Exit(1) + } + }() + + // Run -main - should panic + mainVar.Invoke() + fmt.Printf("FAIL: Expected throw %%v, but no panic occurred\n", expectedThrow) + os.Exit(1) + } else { + // Expect normal return value + result := mainVar.Invoke() + if lang.Equals(result, expectedOutput) { + fmt.Println("SUCCESS: Got expected output") + os.Exit(0) + } else { + fmt.Printf("FAIL: Expected %%v, got %%v\n", expectedOutput, result) + os.Exit(1) + } + } +} +`, pkgName, nsName) + + return fmt.Sprintf(`package main + +import ( + "fmt" + "os" + + "testprog/%s" + "github.com/glojurelang/glojure/pkg/lang" +) +%s`, pkgName, mainFunc) +} From 74f6df21eee51caf1a6a85c9d0904e46a193aeed Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sat, 30 Aug 2025 19:49:38 -0700 Subject: [PATCH 48/67] Run codegen tests in parallel Signed-off-by: James Hamlin --- pkg/codegen/codegengotest/codegengo_test.go | 61 +++++++++++++-------- 1 file changed, 38 insertions(+), 23 deletions(-) diff --git a/pkg/codegen/codegengotest/codegengo_test.go b/pkg/codegen/codegengotest/codegengo_test.go index 42ae0acd..152f49eb 100644 --- a/pkg/codegen/codegengotest/codegengo_test.go +++ b/pkg/codegen/codegengotest/codegengo_test.go @@ -9,6 +9,7 @@ import ( "path/filepath" "strings" "testing" + "text/template" "github.com/glojurelang/glojure/pkg/lang" ) @@ -44,6 +45,8 @@ func TestGeneratedGo(t *testing.T) { pkgName := filepath.Base(dir) t.Run(pkgName, func(t *testing.T) { + t.Parallel() + // Read the corresponding .glj file to check for -main metadata gljFile := strings.TrimSuffix(outFile, "/load.go.out") + ".glj" nsName, hasMain := getNamespaceMetadata(t, gljFile) @@ -88,7 +91,7 @@ func TestGeneratedGo(t *testing.T) { if err != nil { t.Fatalf("Failed to get project root: %v", err) } - + // Create go.mod with absolute path replacement goModContent := fmt.Sprintf(`module testprog @@ -102,7 +105,7 @@ replace github.com/glojurelang/glojure => %s if err := ioutil.WriteFile(goModFile, []byte(goModContent), 0644); err != nil { t.Fatalf("Failed to write go.mod: %v", err) } - + // Copy go.sum from project root goSumSrc := filepath.Join(projectRoot, "go.sum") goSumContent, err := ioutil.ReadFile(goSumSrc) @@ -122,7 +125,7 @@ replace github.com/glojurelang/glojure => %s if err := cmd.Run(); err != nil { t.Fatalf("Failed to run go mod tidy: %v\nStderr: %s", err, tidyStderr.String()) } - + // Build the program cmd = exec.Command("go", "build", "-o", "testprog", ".") cmd.Dir = tempDir @@ -205,13 +208,21 @@ func getNamespaceMetadata(t *testing.T, gljFile string) (nsName string, hasMain return nsName, hasMain } -// generateMainFile generates a main.go file that imports and calls LoadNS -func generateMainFile(pkgName, nsName string) string { - mainFunc := fmt.Sprintf(` +var mainTemplate = template.Must(template.New("main").Parse(`package main + +import ( + "fmt" + "os" + + "testprog/{{.PkgName}}" + "github.com/glojurelang/glojure/pkg/lang" + _ "github.com/glojurelang/glojure/pkg/glj" +) + func main() { - %s.LoadNS() + {{.PkgName}}.LoadNS() - ns := lang.FindNamespace(lang.NewSymbol("%s")) + ns := lang.FindNamespace(lang.NewSymbol("{{.NsName}}")) if ns == nil { fmt.Println("ERROR: namespace not found") os.Exit(1) @@ -246,18 +257,18 @@ func main() { fmt.Println("SUCCESS: Got expected throw") os.Exit(0) } else { - fmt.Printf("FAIL: Expected throw %%v, got %%v\n", expectedThrow, r) + fmt.Printf("FAIL: Expected throw %v, got %v\n", expectedThrow, r) os.Exit(1) } } else { - fmt.Printf("FAIL: Expected throw %%v, but no panic occurred\n", expectedThrow) + fmt.Printf("FAIL: Expected throw %v, but no panic occurred\n", expectedThrow) os.Exit(1) } }() // Run -main - should panic mainVar.Invoke() - fmt.Printf("FAIL: Expected throw %%v, but no panic occurred\n", expectedThrow) + fmt.Printf("FAIL: Expected throw %v, but no panic occurred\n", expectedThrow) os.Exit(1) } else { // Expect normal return value @@ -266,21 +277,25 @@ func main() { fmt.Println("SUCCESS: Got expected output") os.Exit(0) } else { - fmt.Printf("FAIL: Expected %%v, got %%v\n", expectedOutput, result) + fmt.Printf("FAIL: Expected %v, got %v\n", expectedOutput, result) os.Exit(1) } } } -`, pkgName, nsName) - - return fmt.Sprintf(`package main +`)) -import ( - "fmt" - "os" - - "testprog/%s" - "github.com/glojurelang/glojure/pkg/lang" -) -%s`, pkgName, mainFunc) +// generateMainFile generates a main.go file that imports and calls LoadNS +func generateMainFile(pkgName, nsName string) string { + var buf bytes.Buffer + err := mainTemplate.Execute(&buf, struct { + PkgName string + NsName string + }{ + PkgName: pkgName, + NsName: nsName, + }) + if err != nil { + panic(fmt.Sprintf("Failed to generate main.go: %v", err)) + } + return buf.String() } From daaa0b8b77492dac73dc0fdadc2895c6e9b2e3c9 Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sat, 30 Aug 2025 20:36:25 -0700 Subject: [PATCH 49/67] AOT runs on glojure.core without error Signed-off-by: James Hamlin --- pkg/codegen/codegen.go | 120 +- .../testdata/codegen/test/core/load.go.out | 57396 ++++++++++++++++ pkg/gen/gljimports/gljimports_darwin_amd64.go | 1 + pkg/gen/gljimports/gljimports_darwin_arm64.go | 1 + pkg/gen/gljimports/gljimports_js_wasm.go | 1 + pkg/gen/gljimports/gljimports_linux_amd64.go | 1 + pkg/gen/gljimports/gljimports_linux_arm64.go | 1 + .../gljimports/gljimports_windows_amd64.go | 1 + pkg/gen/gljimports/gljimports_windows_arm.go | 1 + pkg/stdlib/glojure/go/io.glj | 10 +- 10 files changed, 57485 insertions(+), 48 deletions(-) create mode 100644 pkg/codegen/testdata/codegen/test/core/load.go.out diff --git a/pkg/codegen/codegen.go b/pkg/codegen/codegen.go index a3811592..90743a52 100644 --- a/pkg/codegen/codegen.go +++ b/pkg/codegen/codegen.go @@ -138,41 +138,19 @@ func (g *Generator) Generate(ns *lang.Namespace) error { return internedVars[i].name.String() < internedVars[j].name.String() }) for _, nv := range internedVars { + if isRuntimeOwnedVar(nv.vr) { + // Skip runtime-owned vars + continue + } if err := g.generateVar("ns", nv.name, nv.vr); err != nil { return fmt.Errorf("failed to generate code for var %s: %w", nv.name, err) } } - // Now construct the complete init function - var initBuf bytes.Buffer - initBuf.WriteString(fmt.Sprintf("// LoadNS initializes the namespace %q\n", ns.Name().String())) - initBuf.WriteString("func LoadNS() {\n") - initBuf.WriteString(`checkDerefMacro := func (v *lang.Var) { - if v.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) - } -} -_ = checkDerefMacro -`) - - // initialize all the vars first - var varNames []string - var inverseVarMap = make(map[string]varInfo) - for vi, varName := range g.varVariables { - varNames = append(varNames, varName) - inverseVarMap[varName] = vi - } - sort.Strings(varNames) // Sort for deterministic output - for _, varName := range varNames { - vi := inverseVarMap[varName] - initBuf.WriteString(fmt.Sprintf("// var %s/%s\n", vi.ns, vi.sym)) - initBuf.WriteString(fmt.Sprintf("%s := lang.InternVarName(lang.NewSymbol(%q), lang.NewSymbol(%q))\n", varName, vi.ns, vi.sym)) - } - + //////////////////////////////////////////////////////////////////////////////// + var liftedBuf bytes.Buffer // Generate lifted values at the beginning of init() if any if len(g.liftedValues) > 0 { - initBuf.WriteString(" // Closed-over values\n") - // Sort by variable name for deterministic output var sortedLifted []*liftedValue for _, lifted := range g.liftedValues { @@ -183,10 +161,7 @@ _ = checkDerefMacro }) // Generate code for each lifted value - // Use a temporary buffer to capture any initialization code - var liftedBuf bytes.Buffer g.w = &liftedBuf - for _, lifted := range sortedLifted { // Generate the value - this will write any needed initialization g.writef("var %s any\n", lifted.varName) @@ -198,8 +173,40 @@ _ = checkDerefMacro g.writef("}\n") g.popVarScope() } + } + + //////////////////////////////////////////////////////////////////////////////// - // Write the lifted values code to init + // Now construct the complete init function + var initBuf bytes.Buffer + initBuf.WriteString(`func checkDerefVar (v *lang.Var) any { + if v.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) + } + return v.Get() +} +`) + initBuf.WriteString(fmt.Sprintf("// LoadNS initializes the namespace %q\n", ns.Name().String())) + initBuf.WriteString("func LoadNS() {\n") + + // initialize all the vars first + var varNames []string + var inverseVarMap = make(map[string]varInfo) + for vi, varName := range g.varVariables { + varNames = append(varNames, varName) + inverseVarMap[varName] = vi + } + sort.Strings(varNames) // Sort for deterministic output + for _, varName := range varNames { + vi := inverseVarMap[varName] + initBuf.WriteString(fmt.Sprintf("// var %s/%s\n", vi.ns, vi.sym)) + initBuf.WriteString(fmt.Sprintf("%s := lang.InternVarName(lang.NewSymbol(%q), lang.NewSymbol(%q))\n", varName, vi.ns, vi.sym)) + } + + // Add lifted values if any + if liftedBuf.Len() > 0 { + initBuf.WriteString(strings.Repeat("/", 80)) + initBuf.WriteString("// Closed-over values\n") initBuf.Write(liftedBuf.Bytes()) initBuf.WriteString("\n") } @@ -230,8 +237,7 @@ _ = checkDerefMacro // generateVar generates Go code for a single Var func (g *Generator) generateVar(nsVariableName string, name *lang.Symbol, vr *lang.Var) error { if omittedVars[vr.String()] { - // Skip omitted vars - fmt.Printf("Skipping omitted var: %s\n", name.String()) + // Skip omitted vars like *in* and *out*, which are initialized by the runtime return nil } @@ -291,13 +297,7 @@ func (g *Generator) generateValue(value any) string { case *runtime.Fn: return g.generateFn(v) case lang.FnFunc: - // FnFunc is a simple function wrapper, we can't regenerate its exact implementation - // so we generate a placeholder that will panic if called - fnVar := g.allocateTempVar() - g.writef("%s := lang.NewFnFunc(func(args ...any) any {\n", fnVar) - g.writef(" panic(\"generated FnFunc not implemented\")\n") - g.writef("})\n") - return fnVar + return g.generateFnFunc(v) case lang.IPersistentMap: return g.generateMapValue(v) case lang.IPersistentVector: @@ -345,6 +345,10 @@ func (g *Generator) generateValue(value any) string { return fmt.Sprintf("lang.NewList(%s)", strings.Join(vals, ", ")) } + if fname, ok := getWellKnownFunctionName(v); ok { + return fname + } + panic(fmt.Sprintf("unsupported value type %T: %s", v, v)) } } @@ -667,6 +671,10 @@ func (g *Generator) generateMultiFn(mf *lang.MultiFn) string { return mfVar } +func (g *Generator) generateFnFunc(fn lang.FnFunc) string { + panic("cannot generate opaque go function values") +} + func (g *Generator) generateFn(fn *runtime.Fn) string { // Save and restore current environment prevEnv := g.currentFnEnv @@ -898,9 +906,8 @@ func (g *Generator) generateVarDeref(node *ast.Node) string { // Look up the var variable varId := g.allocateVarVariable(varNamespace.Name().String(), varSymbol.String()) - g.writef("checkDerefMacro(%s)\n", varId) resultId := g.allocateTempVar() - g.writef("%s := %s.Get()\n", resultId, varId) + g.writef("%s := checkDerefVar(%s)\n", resultId, varId) return resultId } @@ -1682,3 +1689,30 @@ func (g *Generator) allocateVarVariable(ns, sym string) string { g.varVariables[varInfo] = varName return varName } + +//////////////////////////////////////////////////////////////////////////////// + +var ( + runtimeOwnedVars = map[string]bool{ + "in-ns": true, + } + + wellKnownFunctions = map[uintptr]string{ + reflect.ValueOf(lang.NewList).Pointer(): "lang.NewList", + } +) + +func isRuntimeOwnedVar(v *lang.Var) bool { + // namespace must be glojure.core + if v.Namespace().Name().Name() != "glojure.core" { + return false + } + + return runtimeOwnedVars[v.Symbol().Name()] +} + +func getWellKnownFunctionName(fn any) (string, bool) { + ptr := reflect.ValueOf(fn).Pointer() + name, ok := wellKnownFunctions[ptr] + return name, ok +} diff --git a/pkg/codegen/testdata/codegen/test/core/load.go.out b/pkg/codegen/testdata/codegen/test/core/load.go.out new file mode 100644 index 00000000..787764fc --- /dev/null +++ b/pkg/codegen/testdata/codegen/test/core/load.go.out @@ -0,0 +1,57396 @@ +// Code generated by glojure codegen. DO NOT EDIT. + +package core + +import ( + errors8 "errors" + fmt "fmt" + lang "github.com/glojurelang/glojure/pkg/lang" + runtime7 "github.com/glojurelang/glojure/pkg/runtime" + uuid13 "github.com/google/uuid" + io3 "io" + math6 "math" + big9 "math/big" + rand16 "math/rand" + http17 "net/http" + url4 "net/url" + os5 "os" + reflect "reflect" + regexp15 "regexp" + runtime14 "runtime" + strconv12 "strconv" + strings11 "strings" + time10 "time" +) + +func checkDerefVar(v *lang.Var) any { + if v.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) + } + return v.Get() +} + +// LoadNS initializes the namespace "glojure.core" +func LoadNS() { + // var glojure.core.protocols/coll-reduce + glojure_DOT_core_DOT_protocols_coll_reduce := lang.InternVarName(lang.NewSymbol("glojure.core.protocols"), lang.NewSymbol("coll-reduce")) + // var glojure.core.protocols/interface-or-naive-reduce + glojure_DOT_core_DOT_protocols_interface_or_naive_reduce := lang.InternVarName(lang.NewSymbol("glojure.core.protocols"), lang.NewSymbol("interface-or-naive-reduce")) + // var glojure.core.protocols/kv-reduce + glojure_DOT_core_DOT_protocols_kv_reduce := lang.InternVarName(lang.NewSymbol("glojure.core.protocols"), lang.NewSymbol("kv-reduce")) + // var glojure.core.protocols/seq-reduce + glojure_DOT_core_DOT_protocols_seq_reduce := lang.InternVarName(lang.NewSymbol("glojure.core.protocols"), lang.NewSymbol("seq-reduce")) + // var glojure.core/StackTraceElement->vec + glojure_DOT_core_StackTraceElement__GT_vec := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("StackTraceElement->vec")) + // var glojure.core/Throwable->map + glojure_DOT_core_Throwable__GT_map := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("Throwable->map")) + // var glojure.core/- + glojure_DOT_core__ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("-")) + // var glojure.core/= + glojure_DOT_core__EQ_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("=")) + // var glojure.core/== + glojure_DOT_core__EQ__EQ_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("==")) + // var glojure.core/> + glojure_DOT_core__GT_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol(">")) + // var glojure.core/>= + glojure_DOT_core__GT__EQ_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol(">=")) + // var glojure.core/< + glojure_DOT_core__LT_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("<")) + // var glojure.core/<= + glojure_DOT_core__LT__EQ_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("<=")) + // var glojure.core/+ + glojure_DOT_core__PLUS_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("+")) + // var glojure.core/+' + glojure_DOT_core__PLUS__U0027_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("+'")) + // var glojure.core// + glojure_DOT_core__SLASH_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("/")) + // var glojure.core/* + glojure_DOT_core__STAR_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*")) + // var glojure.core/*' + glojure_DOT_core__STAR__U0027_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*'")) + // var glojure.core/*agent* + glojure_DOT_core__STAR_agent_STAR_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*agent*")) + // var glojure.core/*assert* + glojure_DOT_core__STAR_assert_STAR_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*assert*")) + // var glojure.core/*file* + glojure_DOT_core__STAR_file_STAR_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*file*")) + // var glojure.core/*flush-on-newline* + glojure_DOT_core__STAR_flush_on_newline_STAR_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*flush-on-newline*")) + // var glojure.core/*in* + glojure_DOT_core__STAR_in_STAR_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*in*")) + // var glojure.core/*loaded-libs* + glojure_DOT_core__STAR_loaded_libs_STAR_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*loaded-libs*")) + // var glojure.core/*loading-verbosely* + glojure_DOT_core__STAR_loading_verbosely_STAR_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*loading-verbosely*")) + // var glojure.core/*ns* + glojure_DOT_core__STAR_ns_STAR_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*ns*")) + // var glojure.core/*out* + glojure_DOT_core__STAR_out_STAR_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*out*")) + // var glojure.core/*pending-paths* + glojure_DOT_core__STAR_pending_paths_STAR_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*pending-paths*")) + // var glojure.core/*print-dup* + glojure_DOT_core__STAR_print_dup_STAR_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*print-dup*")) + // var glojure.core/*print-length* + glojure_DOT_core__STAR_print_length_STAR_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*print-length*")) + // var glojure.core/*print-level* + glojure_DOT_core__STAR_print_level_STAR_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*print-level*")) + // var glojure.core/*print-meta* + glojure_DOT_core__STAR_print_meta_STAR_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*print-meta*")) + // var glojure.core/*print-namespace-maps* + glojure_DOT_core__STAR_print_namespace_maps_STAR_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*print-namespace-maps*")) + // var glojure.core/*print-readably* + glojure_DOT_core__STAR_print_readably_STAR_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*print-readably*")) + // var glojure.core/*unchecked-math* + glojure_DOT_core__STAR_unchecked_math_STAR_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*unchecked-math*")) + // var glojure.core/*verbose-defrecords* + glojure_DOT_core__STAR_verbose_defrecords_STAR_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*verbose-defrecords*")) + // var glojure.core/-' + glojure_DOT_core___U0027_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("-'")) + // var glojure.core/agent + glojure_DOT_core_agent := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("agent")) + // var glojure.core/agent-error + glojure_DOT_core_agent_error := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("agent-error")) + // var glojure.core/aget + glojure_DOT_core_aget := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("aget")) + // var glojure.core/alength + glojure_DOT_core_alength := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("alength")) + // var glojure.core/alias + glojure_DOT_core_alias := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("alias")) + // var glojure.core/alter-var-root + glojure_DOT_core_alter_var_root := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("alter-var-root")) + // var glojure.core/ancestors + glojure_DOT_core_ancestors := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("ancestors")) + // var glojure.core/apply + glojure_DOT_core_apply := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("apply")) + // var glojure.core/aset + glojure_DOT_core_aset := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("aset")) + // var glojure.core/aset-boolean + glojure_DOT_core_aset_boolean := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("aset-boolean")) + // var glojure.core/aset-byte + glojure_DOT_core_aset_byte := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("aset-byte")) + // var glojure.core/aset-char + glojure_DOT_core_aset_char := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("aset-char")) + // var glojure.core/aset-double + glojure_DOT_core_aset_double := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("aset-double")) + // var glojure.core/aset-float + glojure_DOT_core_aset_float := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("aset-float")) + // var glojure.core/aset-int + glojure_DOT_core_aset_int := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("aset-int")) + // var glojure.core/aset-long + glojure_DOT_core_aset_long := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("aset-long")) + // var glojure.core/aset-short + glojure_DOT_core_aset_short := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("aset-short")) + // var glojure.core/assert-valid-fdecl + glojure_DOT_core_assert_valid_fdecl := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("assert-valid-fdecl")) + // var glojure.core/assoc + glojure_DOT_core_assoc := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("assoc")) + // var glojure.core/assoc! + glojure_DOT_core_assoc_BANG_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("assoc!")) + // var glojure.core/assoc-in + glojure_DOT_core_assoc_in := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("assoc-in")) + // var glojure.core/atom + glojure_DOT_core_atom := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("atom")) + // var glojure.core/await + glojure_DOT_core_await := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("await")) + // var glojure.core/bases + glojure_DOT_core_bases := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("bases")) + // var glojure.core/bigint + glojure_DOT_core_bigint := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("bigint")) + // var glojure.core/binding-conveyor-fn + glojure_DOT_core_binding_conveyor_fn := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("binding-conveyor-fn")) + // var glojure.core/bit-and + glojure_DOT_core_bit_and := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("bit-and")) + // var glojure.core/bit-and-not + glojure_DOT_core_bit_and_not := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("bit-and-not")) + // var glojure.core/bit-or + glojure_DOT_core_bit_or := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("bit-or")) + // var glojure.core/bit-shift-left + glojure_DOT_core_bit_shift_left := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("bit-shift-left")) + // var glojure.core/bit-shift-right + glojure_DOT_core_bit_shift_right := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("bit-shift-right")) + // var glojure.core/bit-xor + glojure_DOT_core_bit_xor := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("bit-xor")) + // var glojure.core/boolean + glojure_DOT_core_boolean := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("boolean")) + // var glojure.core/butlast + glojure_DOT_core_butlast := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("butlast")) + // var glojure.core/byte + glojure_DOT_core_byte := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("byte")) + // var glojure.core/case-map + glojure_DOT_core_case_map := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("case-map")) + // var glojure.core/cat + glojure_DOT_core_cat := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("cat")) + // var glojure.core/char + glojure_DOT_core_char := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("char")) + // var glojure.core/char-escape-string + glojure_DOT_core_char_escape_string := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("char-escape-string")) + // var glojure.core/char-name-string + glojure_DOT_core_char_name_string := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("char-name-string")) + // var glojure.core/check-cyclic-dependency + glojure_DOT_core_check_cyclic_dependency := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("check-cyclic-dependency")) + // var glojure.core/check-valid-options + glojure_DOT_core_check_valid_options := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("check-valid-options")) + // var glojure.core/chunk + glojure_DOT_core_chunk := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("chunk")) + // var glojure.core/chunk-append + glojure_DOT_core_chunk_append := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("chunk-append")) + // var glojure.core/chunk-buffer + glojure_DOT_core_chunk_buffer := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("chunk-buffer")) + // var glojure.core/chunk-cons + glojure_DOT_core_chunk_cons := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("chunk-cons")) + // var glojure.core/chunk-first + glojure_DOT_core_chunk_first := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("chunk-first")) + // var glojure.core/chunk-next + glojure_DOT_core_chunk_next := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("chunk-next")) + // var glojure.core/chunk-rest + glojure_DOT_core_chunk_rest := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("chunk-rest")) + // var glojure.core/chunked-seq? + glojure_DOT_core_chunked_seq_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("chunked-seq?")) + // var glojure.core/class + glojure_DOT_core_class := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("class")) + // var glojure.core/class? + glojure_DOT_core_class_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("class?")) + // var glojure.core/commute + glojure_DOT_core_commute := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("commute")) + // var glojure.core/comp + glojure_DOT_core_comp := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("comp")) + // var glojure.core/compare + glojure_DOT_core_compare := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("compare")) + // var glojure.core/compare-and-set! + glojure_DOT_core_compare_and_set_BANG_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("compare-and-set!")) + // var glojure.core/complement + glojure_DOT_core_complement := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("complement")) + // var glojure.core/completing + glojure_DOT_core_completing := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("completing")) + // var glojure.core/concat + glojure_DOT_core_concat := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("concat")) + // var glojure.core/conj + glojure_DOT_core_conj := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("conj")) + // var glojure.core/conj! + glojure_DOT_core_conj_BANG_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("conj!")) + // var glojure.core/cons + glojure_DOT_core_cons := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("cons")) + // var glojure.core/contains? + glojure_DOT_core_contains_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("contains?")) + // var glojure.core/count + glojure_DOT_core_count := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("count")) + // var glojure.core/counted? + glojure_DOT_core_counted_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("counted?")) + // var glojure.core/create-ns + glojure_DOT_core_create_ns := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("create-ns")) + // var glojure.core/create-struct + glojure_DOT_core_create_struct := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("create-struct")) + // var glojure.core/data-reader-urls + glojure_DOT_core_data_reader_urls := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("data-reader-urls")) + // var glojure.core/data-reader-var + glojure_DOT_core_data_reader_var := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("data-reader-var")) + // var glojure.core/dec + glojure_DOT_core_dec := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("dec")) + // var glojure.core/decimal? + glojure_DOT_core_decimal_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("decimal?")) + // var glojure.core/dedupe + glojure_DOT_core_dedupe := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("dedupe")) + // var glojure.core/deref + glojure_DOT_core_deref := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("deref")) + // var glojure.core/deref-as-map + glojure_DOT_core_deref_as_map := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("deref-as-map")) + // var glojure.core/deref-future + glojure_DOT_core_deref_future := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("deref-future")) + // var glojure.core/derive + glojure_DOT_core_derive := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("derive")) + // var glojure.core/descendants + glojure_DOT_core_descendants := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("descendants")) + // var glojure.core/destructure + glojure_DOT_core_destructure := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("destructure")) + // var glojure.core/disj + glojure_DOT_core_disj := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("disj")) + // var glojure.core/dissoc + glojure_DOT_core_dissoc := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("dissoc")) + // var glojure.core/distinct? + glojure_DOT_core_distinct_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("distinct?")) + // var glojure.core/doall + glojure_DOT_core_doall := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("doall")) + // var glojure.core/dorun + glojure_DOT_core_dorun := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("dorun")) + // var glojure.core/double + glojure_DOT_core_double := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("double")) + // var glojure.core/drop + glojure_DOT_core_drop := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("drop")) + // var glojure.core/drop-last + glojure_DOT_core_drop_last := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("drop-last")) + // var glojure.core/drop-while + glojure_DOT_core_drop_while := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("drop-while")) + // var glojure.core/elide-top-frames + glojure_DOT_core_elide_top_frames := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("elide-top-frames")) + // var glojure.core/emit-extend-protocol + glojure_DOT_core_emit_extend_protocol := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("emit-extend-protocol")) + // var glojure.core/emit-extend-type + glojure_DOT_core_emit_extend_type := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("emit-extend-type")) + // var glojure.core/emit-hinted-impl + glojure_DOT_core_emit_hinted_impl := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("emit-hinted-impl")) + // var glojure.core/empty? + glojure_DOT_core_empty_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("empty?")) + // var glojure.core/ensure-reduced + glojure_DOT_core_ensure_reduced := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("ensure-reduced")) + // var glojure.core/eval + glojure_DOT_core_eval := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("eval")) + // var glojure.core/even? + glojure_DOT_core_even_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("even?")) + // var glojure.core/every? + glojure_DOT_core_every_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("every?")) + // var glojure.core/ex-data + glojure_DOT_core_ex_data := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("ex-data")) + // var glojure.core/ex-info + glojure_DOT_core_ex_info := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("ex-info")) + // var glojure.core/ffirst + glojure_DOT_core_ffirst := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("ffirst")) + // var glojure.core/filter + glojure_DOT_core_filter := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("filter")) + // var glojure.core/filter-key + glojure_DOT_core_filter_key := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("filter-key")) + // var glojure.core/find + glojure_DOT_core_find := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("find")) + // var glojure.core/find-ns + glojure_DOT_core_find_ns := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("find-ns")) + // var glojure.core/first + glojure_DOT_core_first := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("first")) + // var glojure.core/fits-table? + glojure_DOT_core_fits_table_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("fits-table?")) + // var glojure.core/flatten + glojure_DOT_core_flatten := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("flatten")) + // var glojure.core/float + glojure_DOT_core_float := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("float")) + // var glojure.core/float? + glojure_DOT_core_float_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("float?")) + // var glojure.core/flush + glojure_DOT_core_flush := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("flush")) + // var glojure.core/fn? + glojure_DOT_core_fn_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("fn?")) + // var glojure.core/fnil + glojure_DOT_core_fnil := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("fnil")) + // var glojure.core/format + glojure_DOT_core_format := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("format")) + // var glojure.core/future-call + glojure_DOT_core_future_call := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("future-call")) + // var glojure.core/gensym + glojure_DOT_core_gensym := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("gensym")) + // var glojure.core/get + glojure_DOT_core_get := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("get")) + // var glojure.core/get-in + glojure_DOT_core_get_in := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("get-in")) + // var glojure.core/get-thread-bindings + glojure_DOT_core_get_thread_bindings := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("get-thread-bindings")) + // var glojure.core/global-hierarchy + glojure_DOT_core_global_hierarchy := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("global-hierarchy")) + // var glojure.core/halt-when + glojure_DOT_core_halt_when := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("halt-when")) + // var glojure.core/hash-map + glojure_DOT_core_hash_map := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("hash-map")) + // var glojure.core/hash-set + glojure_DOT_core_hash_set := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("hash-set")) + // var glojure.core/ident? + glojure_DOT_core_ident_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("ident?")) + // var glojure.core/identical? + glojure_DOT_core_identical_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("identical?")) + // var glojure.core/identity + glojure_DOT_core_identity := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("identity")) + // var glojure.core/inc + glojure_DOT_core_inc := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("inc")) + // var glojure.core/inc' + glojure_DOT_core_inc_U0027_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("inc'")) + // var glojure.core/instance? + glojure_DOT_core_instance_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("instance?")) + // var glojure.core/int + glojure_DOT_core_int := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("int")) + // var glojure.core/int? + glojure_DOT_core_int_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("int?")) + // var glojure.core/integer? + glojure_DOT_core_integer_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("integer?")) + // var glojure.core/interleave + glojure_DOT_core_interleave := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("interleave")) + // var glojure.core/intern + glojure_DOT_core_intern := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("intern")) + // var glojure.core/interpose + glojure_DOT_core_interpose := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("interpose")) + // var glojure.core/into + glojure_DOT_core_into := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("into")) + // var glojure.core/into1 + glojure_DOT_core_into1 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("into1")) + // var glojure.core/into-array + glojure_DOT_core_into_array := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("into-array")) + // var glojure.core/isa? + glojure_DOT_core_isa_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("isa?")) + // var glojure.core/iterate + glojure_DOT_core_iterate := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("iterate")) + // var glojure.core/iterator-seq + glojure_DOT_core_iterator_seq := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("iterator-seq")) + // var glojure.core/keep + glojure_DOT_core_keep := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("keep")) + // var glojure.core/key + glojure_DOT_core_key := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("key")) + // var glojure.core/keys + glojure_DOT_core_keys := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("keys")) + // var glojure.core/keyword + glojure_DOT_core_keyword := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("keyword")) + // var glojure.core/keyword? + glojure_DOT_core_keyword_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("keyword?")) + // var glojure.core/last + glojure_DOT_core_last := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("last")) + // var glojure.core/libspec? + glojure_DOT_core_libspec_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("libspec?")) + // var glojure.core/lift-ns + glojure_DOT_core_lift_ns := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("lift-ns")) + // var glojure.core/line-seq + glojure_DOT_core_line_seq := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("line-seq")) + // var glojure.core/list + glojure_DOT_core_list := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("list")) + // var glojure.core/list* + glojure_DOT_core_list_STAR_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("list*")) + // var glojure.core/load + glojure_DOT_core_load := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("load")) + // var glojure.core/load-all + glojure_DOT_core_load_all := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("load-all")) + // var glojure.core/load-data-reader-file + glojure_DOT_core_load_data_reader_file := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("load-data-reader-file")) + // var glojure.core/load-lib + glojure_DOT_core_load_lib := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("load-lib")) + // var glojure.core/load-libs + glojure_DOT_core_load_libs := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("load-libs")) + // var glojure.core/load-one + glojure_DOT_core_load_one := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("load-one")) + // var glojure.core/load-reader + glojure_DOT_core_load_reader := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("load-reader")) + // var glojure.core/long + glojure_DOT_core_long := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("long")) + // var glojure.core/macroexpand + glojure_DOT_core_macroexpand := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("macroexpand")) + // var glojure.core/macroexpand-1 + glojure_DOT_core_macroexpand_1 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("macroexpand-1")) + // var glojure.core/make-array + glojure_DOT_core_make_array := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("make-array")) + // var glojure.core/make-hierarchy + glojure_DOT_core_make_hierarchy := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("make-hierarchy")) + // var glojure.core/map + glojure_DOT_core_map := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("map")) + // var glojure.core/map? + glojure_DOT_core_map_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("map?")) + // var glojure.core/mapcat + glojure_DOT_core_mapcat := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("mapcat")) + // var glojure.core/max + glojure_DOT_core_max := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("max")) + // var glojure.core/max-mask-bits + glojure_DOT_core_max_mask_bits := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("max-mask-bits")) + // var glojure.core/max-switch-table-size + glojure_DOT_core_max_switch_table_size := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("max-switch-table-size")) + // var glojure.core/maybe-destructured + glojure_DOT_core_maybe_destructured := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("maybe-destructured")) + // var glojure.core/maybe-min-hash + glojure_DOT_core_maybe_min_hash := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("maybe-min-hash")) + // var glojure.core/merge + glojure_DOT_core_merge := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("merge")) + // var glojure.core/merge-hash-collisions + glojure_DOT_core_merge_hash_collisions := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("merge-hash-collisions")) + // var glojure.core/meta + glojure_DOT_core_meta := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("meta")) + // var glojure.core/min + glojure_DOT_core_min := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("min")) + // var glojure.core/mk-bound-fn + glojure_DOT_core_mk_bound_fn := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("mk-bound-fn")) + // var glojure.core/name + glojure_DOT_core_name := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("name")) + // var glojure.core/namespace + glojure_DOT_core_namespace := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("namespace")) + // var glojure.core/nary-inline + glojure_DOT_core_nary_inline := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("nary-inline")) + // var glojure.core/neg? + glojure_DOT_core_neg_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("neg?")) + // var glojure.core/newline + glojure_DOT_core_newline := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("newline")) + // var glojure.core/next + glojure_DOT_core_next := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("next")) + // var glojure.core/nil? + glojure_DOT_core_nil_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("nil?")) + // var glojure.core/nnext + glojure_DOT_core_nnext := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("nnext")) + // var glojure.core/normalize-slurp-opts + glojure_DOT_core_normalize_slurp_opts := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("normalize-slurp-opts")) + // var glojure.core/not + glojure_DOT_core_not := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("not")) + // var glojure.core/not= + glojure_DOT_core_not_EQ_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("not=")) + // var glojure.core/not-any? + glojure_DOT_core_not_any_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("not-any?")) + // var glojure.core/not-empty + glojure_DOT_core_not_empty := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("not-empty")) + // var glojure.core/ns-map + glojure_DOT_core_ns_map := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("ns-map")) + // var glojure.core/ns-name + glojure_DOT_core_ns_name := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("ns-name")) + // var glojure.core/ns-publics + glojure_DOT_core_ns_publics := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("ns-publics")) + // var glojure.core/ns-resolve + glojure_DOT_core_ns_resolve := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("ns-resolve")) + // var glojure.core/nth + glojure_DOT_core_nth := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("nth")) + // var glojure.core/nthrest + glojure_DOT_core_nthrest := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("nthrest")) + // var glojure.core/number? + glojure_DOT_core_number_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("number?")) + // var glojure.core/odd? + glojure_DOT_core_odd_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("odd?")) + // var glojure.core/parents + glojure_DOT_core_parents := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("parents")) + // var glojure.core/parse-impls + glojure_DOT_core_parse_impls := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("parse-impls")) + // var glojure.core/parsing-err + glojure_DOT_core_parsing_err := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("parsing-err")) + // var glojure.core/partial + glojure_DOT_core_partial := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("partial")) + // var glojure.core/partition + glojure_DOT_core_partition := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("partition")) + // var glojure.core/partition-all + glojure_DOT_core_partition_all := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("partition-all")) + // var glojure.core/partition-by + glojure_DOT_core_partition_by := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("partition-by")) + // var glojure.core/partitionv + glojure_DOT_core_partitionv := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("partitionv")) + // var glojure.core/partitionv-all + glojure_DOT_core_partitionv_all := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("partitionv-all")) + // var glojure.core/peek + glojure_DOT_core_peek := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("peek")) + // var glojure.core/persistent! + glojure_DOT_core_persistent_BANG_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("persistent!")) + // var glojure.core/pmap + glojure_DOT_core_pmap := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("pmap")) + // var glojure.core/pop + glojure_DOT_core_pop := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("pop")) + // var glojure.core/pop-thread-bindings + glojure_DOT_core_pop_thread_bindings := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("pop-thread-bindings")) + // var glojure.core/pos? + glojure_DOT_core_pos_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("pos?")) + // var glojure.core/pr + glojure_DOT_core_pr := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("pr")) + // var glojure.core/pr-on + glojure_DOT_core_pr_on := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("pr-on")) + // var glojure.core/pr-str + glojure_DOT_core_pr_str := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("pr-str")) + // var glojure.core/prep-hashes + glojure_DOT_core_prep_hashes := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("prep-hashes")) + // var glojure.core/prep-ints + glojure_DOT_core_prep_ints := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("prep-ints")) + // var glojure.core/prependss + glojure_DOT_core_prependss := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("prependss")) + // var glojure.core/preserving-reduced + glojure_DOT_core_preserving_reduced := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("preserving-reduced")) + // var glojure.core/print + glojure_DOT_core_print := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("print")) + // var glojure.core/print-ctor + glojure_DOT_core_print_ctor := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("print-ctor")) + // var glojure.core/print-dup + glojure_DOT_core_print_dup := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("print-dup")) + // var glojure.core/print-map + glojure_DOT_core_print_map := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("print-map")) + // var glojure.core/print-meta + glojure_DOT_core_print_meta := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("print-meta")) + // var glojure.core/print-method + glojure_DOT_core_print_method := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("print-method")) + // var glojure.core/print-object + glojure_DOT_core_print_object := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("print-object")) + // var glojure.core/print-prefix-map + glojure_DOT_core_print_prefix_map := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("print-prefix-map")) + // var glojure.core/print-sequential + glojure_DOT_core_print_sequential := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("print-sequential")) + // var glojure.core/print-simple + glojure_DOT_core_print_simple := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("print-simple")) + // var glojure.core/print-str + glojure_DOT_core_print_str := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("print-str")) + // var glojure.core/print-tagged-object + glojure_DOT_core_print_tagged_object := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("print-tagged-object")) + // var glojure.core/printf + glojure_DOT_core_printf := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("printf")) + // var glojure.core/println + glojure_DOT_core_println := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("println")) + // var glojure.core/prn + glojure_DOT_core_prn := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("prn")) + // var glojure.core/protocol? + glojure_DOT_core_protocol_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("protocol?")) + // var glojure.core/push-thread-bindings + glojure_DOT_core_push_thread_bindings := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("push-thread-bindings")) + // var glojure.core/qualified-ident? + glojure_DOT_core_qualified_ident_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("qualified-ident?")) + // var glojure.core/qualified-symbol? + glojure_DOT_core_qualified_symbol_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("qualified-symbol?")) + // var glojure.core/rand + glojure_DOT_core_rand := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("rand")) + // var glojure.core/rand-int + glojure_DOT_core_rand_int := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("rand-int")) + // var glojure.core/range + glojure_DOT_core_range := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("range")) + // var glojure.core/ratio? + glojure_DOT_core_ratio_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("ratio?")) + // var glojure.core/re-find + glojure_DOT_core_re_find := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("re-find")) + // var glojure.core/re-groups + glojure_DOT_core_re_groups := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("re-groups")) + // var glojure.core/re-matcher + glojure_DOT_core_re_matcher := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("re-matcher")) + // var glojure.core/read + glojure_DOT_core_read := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("read")) + // var glojure.core/read+string + glojure_DOT_core_read_PLUS_string := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("read+string")) + // var glojure.core/reduce + glojure_DOT_core_reduce := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("reduce")) + // var glojure.core/reduce1 + glojure_DOT_core_reduce1 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("reduce1")) + // var glojure.core/reduce-kv + glojure_DOT_core_reduce_kv := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("reduce-kv")) + // var glojure.core/reduced + glojure_DOT_core_reduced := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("reduced")) + // var glojure.core/reduced? + glojure_DOT_core_reduced_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("reduced?")) + // var glojure.core/reductions + glojure_DOT_core_reductions := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("reductions")) + // var glojure.core/ref + glojure_DOT_core_ref := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("ref")) + // var glojure.core/refer + glojure_DOT_core_refer := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("refer")) + // var glojure.core/release-pending-sends + glojure_DOT_core_release_pending_sends := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("release-pending-sends")) + // var glojure.core/rem + glojure_DOT_core_rem := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("rem")) + // var glojure.core/remove + glojure_DOT_core_remove := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("remove")) + // var glojure.core/remove-ns + glojure_DOT_core_remove_ns := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("remove-ns")) + // var glojure.core/repeat + glojure_DOT_core_repeat := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("repeat")) + // var glojure.core/repeatedly + glojure_DOT_core_repeatedly := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("repeatedly")) + // var glojure.core/require + glojure_DOT_core_require := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("require")) + // var glojure.core/resolve + glojure_DOT_core_resolve := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("resolve")) + // var glojure.core/rest + glojure_DOT_core_rest := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("rest")) + // var glojure.core/restart-agent + glojure_DOT_core_restart_agent := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("restart-agent")) + // var glojure.core/root-directory + glojure_DOT_core_root_directory := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("root-directory")) + // var glojure.core/root-resource + glojure_DOT_core_root_resource := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("root-resource")) + // var glojure.core/second + glojure_DOT_core_second := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("second")) + // var glojure.core/select-keys + glojure_DOT_core_select_keys := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("select-keys")) + // var glojure.core/send + glojure_DOT_core_send := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("send")) + // var glojure.core/send-off + glojure_DOT_core_send_off := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("send-off")) + // var glojure.core/send-via + glojure_DOT_core_send_via := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("send-via")) + // var glojure.core/seq + glojure_DOT_core_seq := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("seq")) + // var glojure.core/seq? + glojure_DOT_core_seq_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("seq?")) + // var glojure.core/seque + glojure_DOT_core_seque := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("seque")) + // var glojure.core/sequence + glojure_DOT_core_sequence := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("sequence")) + // var glojure.core/sequential? + glojure_DOT_core_sequential_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("sequential?")) + // var glojure.core/serialized-require + glojure_DOT_core_serialized_require := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("serialized-require")) + // var glojure.core/set + glojure_DOT_core_set := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("set")) + // var glojure.core/set? + glojure_DOT_core_set_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("set?")) + // var glojure.core/setup-reference + glojure_DOT_core_setup_reference := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("setup-reference")) + // var glojure.core/shift-mask + glojure_DOT_core_shift_mask := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("shift-mask")) + // var glojure.core/short + glojure_DOT_core_short := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("short")) + // var glojure.core/sigs + glojure_DOT_core_sigs := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("sigs")) + // var glojure.core/some + glojure_DOT_core_some := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("some")) + // var glojure.core/some? + glojure_DOT_core_some_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("some?")) + // var glojure.core/sort + glojure_DOT_core_sort := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("sort")) + // var glojure.core/sort-by + glojure_DOT_core_sort_by := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("sort-by")) + // var glojure.core/sorted-map + glojure_DOT_core_sorted_map := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("sorted-map")) + // var glojure.core/sorted-set + glojure_DOT_core_sorted_set := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("sorted-set")) + // var glojure.core/split-at + glojure_DOT_core_split_at := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("split-at")) + // var glojure.core/split-with + glojure_DOT_core_split_with := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("split-with")) + // var glojure.core/spread + glojure_DOT_core_spread := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("spread")) + // var glojure.core/str + glojure_DOT_core_str := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("str")) + // var glojure.core/stream-reduce! + glojure_DOT_core_stream_reduce_BANG_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("stream-reduce!")) + // var glojure.core/stream-transduce! + glojure_DOT_core_stream_transduce_BANG_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("stream-transduce!")) + // var glojure.core/string? + glojure_DOT_core_string_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("string?")) + // var glojure.core/strip-ns + glojure_DOT_core_strip_ns := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("strip-ns")) + // var glojure.core/struct + glojure_DOT_core_struct := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("struct")) + // var glojure.core/subs + glojure_DOT_core_subs := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("subs")) + // var glojure.core/subvec + glojure_DOT_core_subvec := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("subvec")) + // var glojure.core/supers + glojure_DOT_core_supers := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("supers")) + // var glojure.core/swap! + glojure_DOT_core_swap_BANG_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("swap!")) + // var glojure.core/symbol + glojure_DOT_core_symbol := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("symbol")) + // var glojure.core/symbol? + glojure_DOT_core_symbol_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("symbol?")) + // var glojure.core/system-newline + glojure_DOT_core_system_newline := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("system-newline")) + // var glojure.core/take + glojure_DOT_core_take := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("take")) + // var glojure.core/take-nth + glojure_DOT_core_take_nth := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("take-nth")) + // var glojure.core/take-while + glojure_DOT_core_take_while := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("take-while")) + // var glojure.core/tapset + glojure_DOT_core_tapset := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("tapset")) + // var glojure.core/the-ns + glojure_DOT_core_the_ns := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("the-ns")) + // var glojure.core/throw-if + glojure_DOT_core_throw_if := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("throw-if")) + // var glojure.core/to-array + glojure_DOT_core_to_array := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("to-array")) + // var glojure.core/trampoline + glojure_DOT_core_trampoline := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("trampoline")) + // var glojure.core/transduce + glojure_DOT_core_transduce := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("transduce")) + // var glojure.core/transient + glojure_DOT_core_transient := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("transient")) + // var glojure.core/tree-seq + glojure_DOT_core_tree_seq := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("tree-seq")) + // var glojure.core/unchecked-inc + glojure_DOT_core_unchecked_inc := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("unchecked-inc")) + // var glojure.core/underive + glojure_DOT_core_underive := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("underive")) + // var glojure.core/unreduced + glojure_DOT_core_unreduced := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("unreduced")) + // var glojure.core/update + glojure_DOT_core_update := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("update")) + // var glojure.core/val + glojure_DOT_core_val := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("val")) + // var glojure.core/vals + glojure_DOT_core_vals := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("vals")) + // var glojure.core/vary-meta + glojure_DOT_core_vary_meta := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("vary-meta")) + // var glojure.core/vec + glojure_DOT_core_vec := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("vec")) + // var glojure.core/vector + glojure_DOT_core_vector := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("vector")) + // var glojure.core/vector? + glojure_DOT_core_vector_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("vector?")) + // var glojure.core/volatile! + glojure_DOT_core_volatile_BANG_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("volatile!")) + // var glojure.core/vreset! + glojure_DOT_core_vreset_BANG_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("vreset!")) + // var glojure.core/with-bindings* + glojure_DOT_core_with_bindings_STAR_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("with-bindings*")) + // var glojure.core/with-meta + glojure_DOT_core_with_meta := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("with-meta")) + // var glojure.core/zero? + glojure_DOT_core_zero_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("zero?")) + // var glojure.core/zipmap + glojure_DOT_core_zipmap := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("zipmap")) + // var glojure.go.io/copy + glojure_DOT_go_DOT_io_copy := lang.InternVarName(lang.NewSymbol("glojure.go.io"), lang.NewSymbol("copy")) + // var glojure.go.io/make-input-stream + glojure_DOT_go_DOT_io_make_input_stream := lang.InternVarName(lang.NewSymbol("glojure.go.io"), lang.NewSymbol("make-input-stream")) + // var glojure.go.io/make-output-stream + glojure_DOT_go_DOT_io_make_output_stream := lang.InternVarName(lang.NewSymbol("glojure.go.io"), lang.NewSymbol("make-output-stream")) + // var glojure.go.io/make-writer + glojure_DOT_go_DOT_io_make_writer := lang.InternVarName(lang.NewSymbol("glojure.go.io"), lang.NewSymbol("make-writer")) + // var glojure.go.io/reader + glojure_DOT_go_DOT_io_reader := lang.InternVarName(lang.NewSymbol("glojure.go.io"), lang.NewSymbol("reader")) + // //////////////////////////////////////////////////////////////////////////////// Closed-over values + var closed0 any + { + closed0 = lang.NewSymbol("unchecked_multiply") + } + var closed1 any + { + closed1 = lang.NewSymbol("multiply") + } + var closed10 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + tmp3, _ := lang.FieldOrMethod(v1, "Reduce") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Reduce is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{v2}) + return tmp4 + case 3: + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + v3 := args[2] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v1, "ReduceInit") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + return tmp5 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + closed10 = tmp0 + } + var closed11 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + tmp3 := checkDerefVar(glojure_DOT_core_DOT_protocols_seq_reduce) + tmp4 := lang.Apply(tmp3, []any{v1, v2}) + return tmp4 + case 3: + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + v3 := args[2] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_DOT_protocols_seq_reduce) + tmp5 := lang.Apply(tmp4, []any{v1, v2, v3}) + return tmp5 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + closed11 = tmp0 + } + var closed12 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + tmp3 := checkDerefVar(glojure_DOT_core_DOT_protocols_seq_reduce) + tmp4 := lang.Apply(tmp3, []any{v1, v2}) + return tmp4 + case 3: + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + v3 := args[2] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_DOT_protocols_seq_reduce) + tmp5 := lang.Apply(tmp4, []any{v1, v2, v3}) + return tmp5 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + closed12 = tmp0 + } + var closed13 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + v3 := args[2] + _ = v3 + return v3 + }) + closed13 = tmp0 + } + var closed14 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + v3 := args[2] + _ = v3 + recur_loop_1275: + var tmp4 any + { // let + // let binding "temp__0__auto__" + tmp5 := checkDerefVar(glojure_DOT_core_seq) + tmp6 := lang.Apply(tmp5, []any{v1}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + if lang.IsTruthy(v7) { + var tmp9 any + { // let + // let binding "s" + var v10 any = v7 + _ = v10 + var tmp11 any + tmp12 := checkDerefVar(glojure_DOT_core_chunked_seq_QMARK_) + tmp13 := lang.Apply(tmp12, []any{v10}) + if lang.IsTruthy(tmp13) { + var tmp14 any + { // let + // let binding "ret" + tmp15 := checkDerefVar(glojure_DOT_core_chunk_first) + tmp16 := lang.Apply(tmp15, []any{v10}) + tmp17, _ := lang.FieldOrMethod(tmp16, "ReduceInit") + if reflect.TypeOf(tmp17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) + } + tmp18 := lang.Apply(tmp17, []any{v2, v3}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + tmp21 := checkDerefVar(glojure_DOT_core_reduced_QMARK_) + tmp22 := lang.Apply(tmp21, []any{v19}) + if lang.IsTruthy(tmp22) { + tmp23 := checkDerefVar(glojure_DOT_core_deref) + tmp24 := lang.Apply(tmp23, []any{v19}) + tmp20 = tmp24 + } else { + tmp26 := checkDerefVar(glojure_DOT_core_chunk_next) + tmp27 := lang.Apply(tmp26, []any{v10}) + var tmp25 any = tmp27 + var tmp28 any = v2 + var tmp29 any = v19 + v1 = tmp25 + v2 = tmp28 + v3 = tmp29 + goto recur_loop_1275 + } + tmp14 = tmp20 + } // end let + tmp11 = tmp14 + } else { + tmp15 := checkDerefVar(glojure_DOT_core_DOT_protocols_interface_or_naive_reduce) + tmp16 := lang.Apply(tmp15, []any{v10, v2, v3}) + tmp11 = tmp16 + } + tmp9 = tmp11 + } // end let + tmp8 = tmp9 + } else { + tmp8 = v3 + } + tmp4 = tmp8 + } // end let + return tmp4 + }) + closed14 = tmp0 + } + var closed15 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + v3 := args[2] + _ = v3 + var tmp4 any + { // let + // let binding "cls" + tmp5 := checkDerefVar(glojure_DOT_core_class) + tmp6 := lang.Apply(tmp5, []any{v1}) + var v7 any = tmp6 + _ = v7 + // let binding "s" + var v8 any = v1 + _ = v8 + // let binding "f" + var v9 any = v2 + _ = v9 + // let binding "val" + var v10 any = v3 + _ = v10 + for { + var tmp11 any + { // let + // let binding "temp__0__auto__" + tmp12 := checkDerefVar(glojure_DOT_core_seq) + tmp13 := lang.Apply(tmp12, []any{v8}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + var tmp16 any + { // let + // let binding "s" + var v17 any = v14 + _ = v17 + var tmp18 any + tmp19 := checkDerefVar(glojure_DOT_core_identical_QMARK_) + tmp20 := checkDerefVar(glojure_DOT_core_class) + tmp21 := lang.Apply(tmp20, []any{v17}) + tmp22 := lang.Apply(tmp19, []any{tmp21, v7}) + if lang.IsTruthy(tmp22) { + var tmp23 any + { // let + // let binding "ret" + tmp24 := checkDerefVar(glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v17}) + tmp26 := lang.Apply(v9, []any{v10, tmp25}) + var v27 any = tmp26 + _ = v27 + var tmp28 any + tmp29 := checkDerefVar(glojure_DOT_core_reduced_QMARK_) + tmp30 := lang.Apply(tmp29, []any{v27}) + if lang.IsTruthy(tmp30) { + tmp31 := checkDerefVar(glojure_DOT_core_deref) + tmp32 := lang.Apply(tmp31, []any{v27}) + tmp28 = tmp32 + } else { + var tmp33 any = v7 + tmp35 := checkDerefVar(glojure_DOT_core_next) + tmp36 := lang.Apply(tmp35, []any{v17}) + var tmp34 any = tmp36 + var tmp37 any = v9 + var tmp38 any = v27 + v7 = tmp33 + v8 = tmp34 + v9 = tmp37 + v10 = tmp38 + continue + } + tmp23 = tmp28 + } // end let + tmp18 = tmp23 + } else { + tmp24 := checkDerefVar(glojure_DOT_core_DOT_protocols_interface_or_naive_reduce) + tmp25 := lang.Apply(tmp24, []any{v17, v9, v10}) + tmp18 = tmp25 + } + tmp16 = tmp18 + } // end let + tmp15 = tmp16 + } else { + tmp15 = v10 + } + tmp11 = tmp15 + } // end let + tmp4 = tmp11 + break + } + } // end let + return tmp4 + }) + closed15 = tmp0 + } + var closed16 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v1 := args[0] + _ = v1 + return nil + }) + closed16 = tmp0 + } + var closed17 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + return v1 + }) + tmp0 = tmp0.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/go/io.glj", lang.NewKeyword("line"), int(188), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(188), lang.NewKeyword("end-column"), int(32))).(lang.FnFunc) + closed17 = tmp0 + } + var closed18 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + tmp3 := checkDerefVar(glojure_DOT_go_DOT_io_make_input_stream) + tmp4 := lang.Apply(tmp3, []any{v1, v2}) + return tmp4 + }) + tmp0 = tmp0.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/go/io.glj", lang.NewKeyword("line"), int(167), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(167), lang.NewKeyword("end-column"), int(56))).(lang.FnFunc) + closed18 = tmp0 + } + var closed19 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + tmp3 := checkDerefVar(glojure_DOT_go_DOT_io_make_writer) + tmp4 := checkDerefVar(glojure_DOT_go_DOT_io_make_output_stream) + tmp5 := lang.Apply(tmp4, []any{v1, v2}) + tmp6 := lang.Apply(tmp3, []any{tmp5, v2}) + return tmp6 + }) + tmp0 = tmp0.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/go/io.glj", lang.NewKeyword("line"), int(168), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(168), lang.NewKeyword("end-column"), int(76))).(lang.FnFunc) + closed19 = tmp0 + } + var closed2 any + { + closed2 = lang.NewSymbol("multiplyP") + } + var closed20 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + return v1 + }) + tmp0 = tmp0.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/go/io.glj", lang.NewKeyword("line"), int(187), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(187), lang.NewKeyword("end-column"), int(38))).(lang.FnFunc) + closed20 = tmp0 + } + var closed21 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + return v1 + }) + tmp0 = tmp0.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/go/io.glj", lang.NewKeyword("line"), int(226), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(226), lang.NewKeyword("end-column"), int(48))).(lang.FnFunc) + closed21 = tmp0 + } + var closed22 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + tmp3 := checkDerefVar(glojure_DOT_go_DOT_io_make_input_stream) + var tmp4 any + tmp5 := checkDerefVar(glojure_DOT_core__EQ_) + tmp6, ok := lang.FieldOrMethod(v1, "scheme") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v1, "scheme"))) + } + var tmp7 any + switch reflect.TypeOf(tmp6).Kind() { + case reflect.Func: + tmp7 = lang.Apply(tmp6, nil) + default: + tmp7 = tmp6 + } + tmp8 := lang.Apply(tmp5, []any{"file", tmp7}) + if lang.IsTruthy(tmp8) { + tmp9 := lang.Apply(nil, []any{v1}) + tmp4 = tmp9 + } else { + var tmp10 any + { // let + // let binding "req" + var tmp11 any + { // let + // let binding "res__0__auto__" + tmp12, ok := lang.FieldOrMethod(v1, "String") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v1, "String"))) + } + var tmp13 any + switch reflect.TypeOf(tmp12).Kind() { + case reflect.Func: + tmp13 = lang.Apply(tmp12, nil) + default: + tmp13 = tmp12 + } + tmp14 := lang.Apply(http17.NewRequest, []any{http17.MethodGet, tmp13, nil}) + var v15 any = tmp14 + _ = v15 + // let binding "vec__295" + var tmp16 any + tmp17 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp18 := lang.Apply(tmp17, []any{v15}) + if lang.IsTruthy(tmp18) { + tmp19 := checkDerefVar(glojure_DOT_core_pop) + tmp20 := lang.Apply(tmp19, []any{v15}) + tmp21 := checkDerefVar(glojure_DOT_core_last) + tmp22 := lang.Apply(tmp21, []any{v15}) + tmp23 := lang.NewVector(tmp20, tmp22) + tmp24 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(358), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(358), lang.NewKeyword("end-column"), int(14)) + tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp16 = tmp25 + } else { + tmp26 := lang.NewVector(nil, v15) + tmp27 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(358), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(358), lang.NewKeyword("end-column"), int(14)) + tmp28, err := lang.WithMeta(tmp26, tmp27.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp16 = tmp28 + } + var v29 any = tmp16 + _ = v29 + // let binding "vec__298" + tmp30 := checkDerefVar(glojure_DOT_core_nth) + tmp31 := lang.Apply(tmp30, []any{v29, int64(0), nil}) + var v32 any = tmp31 + _ = v32 + // let binding "seq__299" + tmp33 := checkDerefVar(glojure_DOT_core_seq) + tmp34 := lang.Apply(tmp33, []any{v32}) + var v35 any = tmp34 + _ = v35 + // let binding "first__300" + tmp36 := checkDerefVar(glojure_DOT_core_first) + tmp37 := lang.Apply(tmp36, []any{v35}) + var v38 any = tmp37 + _ = v38 + // let binding "seq__299" + tmp39 := checkDerefVar(glojure_DOT_core_next) + tmp40 := lang.Apply(tmp39, []any{v35}) + var v41 any = tmp40 + _ = v41 + // let binding "fst__1__auto__" + var v42 any = v38 + _ = v42 + // let binding "rst__2__auto__" + var v43 any = v41 + _ = v43 + // let binding "res__0__auto__" + var v44 any = v32 + _ = v44 + // let binding "err__3__auto__" + tmp45 := checkDerefVar(glojure_DOT_core_nth) + tmp46 := lang.Apply(tmp45, []any{v29, int64(1), nil}) + var v47 any = tmp46 + _ = v47 + // let binding "res__0__auto__" + var tmp48 any + tmp49 := checkDerefVar(glojure_DOT_core_not_empty) + tmp50 := lang.Apply(tmp49, []any{v43}) + if lang.IsTruthy(tmp50) { + tmp48 = v44 + } else { + tmp48 = v42 + } + var v51 any = tmp48 + _ = v51 + var tmp52 any + if lang.IsTruthy(v47) { + panic(v47) + } else { + } + _ = tmp52 + tmp11 = v51 + } // end let + var v12 any = tmp11 + _ = v12 + // let binding "res" + var tmp13 any + { // let + // let binding "res__0__auto__" + tmp14, _ := lang.FieldOrMethod(http17.DefaultClient, "Do") + if reflect.TypeOf(tmp14).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Do is not a function"))) + } + tmp15 := lang.Apply(tmp14, []any{v12}) + var v16 any = tmp15 + _ = v16 + // let binding "vec__301" + var tmp17 any + tmp18 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp19 := lang.Apply(tmp18, []any{v16}) + if lang.IsTruthy(tmp19) { + tmp20 := checkDerefVar(glojure_DOT_core_pop) + tmp21 := lang.Apply(tmp20, []any{v16}) + tmp22 := checkDerefVar(glojure_DOT_core_last) + tmp23 := lang.Apply(tmp22, []any{v16}) + tmp24 := lang.NewVector(tmp21, tmp23) + tmp25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(358), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(358), lang.NewKeyword("end-column"), int(14)) + tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp17 = tmp26 + } else { + tmp27 := lang.NewVector(nil, v16) + tmp28 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(358), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(358), lang.NewKeyword("end-column"), int(14)) + tmp29, err := lang.WithMeta(tmp27, tmp28.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp17 = tmp29 + } + var v30 any = tmp17 + _ = v30 + // let binding "vec__304" + tmp31 := checkDerefVar(glojure_DOT_core_nth) + tmp32 := lang.Apply(tmp31, []any{v30, int64(0), nil}) + var v33 any = tmp32 + _ = v33 + // let binding "seq__305" + tmp34 := checkDerefVar(glojure_DOT_core_seq) + tmp35 := lang.Apply(tmp34, []any{v33}) + var v36 any = tmp35 + _ = v36 + // let binding "first__306" + tmp37 := checkDerefVar(glojure_DOT_core_first) + tmp38 := lang.Apply(tmp37, []any{v36}) + var v39 any = tmp38 + _ = v39 + // let binding "seq__305" + tmp40 := checkDerefVar(glojure_DOT_core_next) + tmp41 := lang.Apply(tmp40, []any{v36}) + var v42 any = tmp41 + _ = v42 + // let binding "fst__1__auto__" + var v43 any = v39 + _ = v43 + // let binding "rst__2__auto__" + var v44 any = v42 + _ = v44 + // let binding "res__0__auto__" + var v45 any = v33 + _ = v45 + // let binding "err__3__auto__" + tmp46 := checkDerefVar(glojure_DOT_core_nth) + tmp47 := lang.Apply(tmp46, []any{v30, int64(1), nil}) + var v48 any = tmp47 + _ = v48 + // let binding "res__0__auto__" + var tmp49 any + tmp50 := checkDerefVar(glojure_DOT_core_not_empty) + tmp51 := lang.Apply(tmp50, []any{v44}) + if lang.IsTruthy(tmp51) { + tmp49 = v45 + } else { + tmp49 = v43 + } + var v52 any = tmp49 + _ = v52 + var tmp53 any + if lang.IsTruthy(v48) { + panic(v48) + } else { + } + _ = tmp53 + tmp13 = v52 + } // end let + var v14 any = tmp13 + _ = v14 + // let binding "status" + tmp15, ok := lang.FieldOrMethod(v14, "StatusCode") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v14, "StatusCode"))) + } + var tmp16 any + switch reflect.TypeOf(tmp15).Kind() { + case reflect.Func: + tmp16 = lang.Apply(tmp15, nil) + default: + tmp16 = tmp15 + } + var v17 any = tmp16 + _ = v17 + // let binding "body" + tmp18, ok := lang.FieldOrMethod(v14, "Body") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v14, "Body"))) + } + var tmp19 any + switch reflect.TypeOf(tmp18).Kind() { + case reflect.Func: + tmp19 = lang.Apply(tmp18, nil) + default: + tmp19 = tmp18 + } + var v20 any = tmp19 + _ = v20 + var tmp21 any + tmp22 := checkDerefVar(glojure_DOT_core_not_EQ_) + tmp23 := lang.Apply(tmp22, []any{int64(200), v17}) + if lang.IsTruthy(tmp23) { + tmp24, ok := lang.FieldOrMethod(v20, "Close") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v20, "Close"))) + } + var tmp25 any + switch reflect.TypeOf(tmp24).Kind() { + case reflect.Func: + tmp25 = lang.Apply(tmp24, nil) + default: + tmp25 = tmp24 + } + _ = tmp25 + tmp26 := lang.Apply(fmt.Errorf, []any{"http error: %s", v17}) + panic(tmp26) + } else { + } + _ = tmp21 + tmp10 = v20 + } // end let + tmp4 = tmp10 + } + tmp11 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp11 + }) + tmp0 = tmp0.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/go/io.glj", lang.NewKeyword("line"), int(232), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(244), lang.NewKeyword("end-column"), int(32))).(lang.FnFunc) + closed22 = tmp0 + } + var closed23 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + var tmp3 any + { // let + // let binding "vec__307" + tmp4 := lang.Apply(url4.ParseRequestURI, []any{v1}) + var v5 any = tmp4 + _ = v5 + // let binding "url" + tmp6 := checkDerefVar(glojure_DOT_core_nth) + tmp7 := lang.Apply(tmp6, []any{v5, int64(0), nil}) + var v8 any = tmp7 + _ = v8 + // let binding "err" + tmp9 := checkDerefVar(glojure_DOT_core_nth) + tmp10 := lang.Apply(tmp9, []any{v5, int64(1), nil}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + tmp13 := checkDerefVar(glojure_DOT_go_DOT_io_make_input_stream) + var tmp14 any + { // let + // let binding "res__0__auto__" + tmp15 := lang.Apply(os5.Open, []any{v1}) + var v16 any = tmp15 + _ = v16 + // let binding "vec__310" + var tmp17 any + tmp18 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp19 := lang.Apply(tmp18, []any{v16}) + if lang.IsTruthy(tmp19) { + tmp20 := checkDerefVar(glojure_DOT_core_pop) + tmp21 := lang.Apply(tmp20, []any{v16}) + tmp22 := checkDerefVar(glojure_DOT_core_last) + tmp23 := lang.Apply(tmp22, []any{v16}) + tmp24 := lang.NewVector(tmp21, tmp23) + tmp25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(358), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(358), lang.NewKeyword("end-column"), int(14)) + tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp17 = tmp26 + } else { + tmp27 := lang.NewVector(nil, v16) + tmp28 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(358), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(358), lang.NewKeyword("end-column"), int(14)) + tmp29, err := lang.WithMeta(tmp27, tmp28.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp17 = tmp29 + } + var v30 any = tmp17 + _ = v30 + // let binding "vec__313" + tmp31 := checkDerefVar(glojure_DOT_core_nth) + tmp32 := lang.Apply(tmp31, []any{v30, int64(0), nil}) + var v33 any = tmp32 + _ = v33 + // let binding "seq__314" + tmp34 := checkDerefVar(glojure_DOT_core_seq) + tmp35 := lang.Apply(tmp34, []any{v33}) + var v36 any = tmp35 + _ = v36 + // let binding "first__315" + tmp37 := checkDerefVar(glojure_DOT_core_first) + tmp38 := lang.Apply(tmp37, []any{v36}) + var v39 any = tmp38 + _ = v39 + // let binding "seq__314" + tmp40 := checkDerefVar(glojure_DOT_core_next) + tmp41 := lang.Apply(tmp40, []any{v36}) + var v42 any = tmp41 + _ = v42 + // let binding "fst__1__auto__" + var v43 any = v39 + _ = v43 + // let binding "rst__2__auto__" + var v44 any = v42 + _ = v44 + // let binding "res__0__auto__" + var v45 any = v33 + _ = v45 + // let binding "err__3__auto__" + tmp46 := checkDerefVar(glojure_DOT_core_nth) + tmp47 := lang.Apply(tmp46, []any{v30, int64(1), nil}) + var v48 any = tmp47 + _ = v48 + // let binding "res__0__auto__" + var tmp49 any + tmp50 := checkDerefVar(glojure_DOT_core_not_empty) + tmp51 := lang.Apply(tmp50, []any{v44}) + if lang.IsTruthy(tmp51) { + tmp49 = v45 + } else { + tmp49 = v43 + } + var v52 any = tmp49 + _ = v52 + var tmp53 any + if lang.IsTruthy(v48) { + panic(v48) + } else { + } + _ = tmp53 + tmp14 = v52 + } // end let + tmp15 := lang.Apply(tmp13, []any{tmp14, v2}) + tmp12 = tmp15 + } else { + tmp16 := checkDerefVar(glojure_DOT_go_DOT_io_make_input_stream) + tmp17 := lang.Apply(tmp16, []any{v8, v2}) + tmp12 = tmp17 + } + tmp3 = tmp12 + } // end let + return tmp3 + }) + tmp0 = tmp0.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/go/io.glj", lang.NewKeyword("line"), int(259), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(263), lang.NewKeyword("end-column"), int(60))).(lang.FnFunc) + closed23 = tmp0 + } + var closed24 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + tmp3 := checkDerefVar(glojure_DOT_core_str) + tmp4 := checkDerefVar(glojure_DOT_core_pr_str) + tmp5 := lang.Apply(tmp4, []any{v1}) + tmp6 := lang.Apply(tmp3, []any{"Cannot open <", tmp5, "> as an OutputStream."}) + tmp7 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp6}) + panic(tmp7) + }) + tmp0 = tmp0.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/go/io.glj", lang.NewKeyword("line"), int(172), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(174), lang.NewKeyword("end-column"), int(92))).(lang.FnFunc) + closed24 = tmp0 + } + var closed25 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + return v1 + }) + tmp0 = tmp0.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/go/io.glj", lang.NewKeyword("line"), int(227), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(227), lang.NewKeyword("end-column"), int(49))).(lang.FnFunc) + closed25 = tmp0 + } + var closed26 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(glojure_DOT_core__EQ_) + tmp5, ok := lang.FieldOrMethod(v1, "scheme") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v1, "scheme"))) + } + var tmp6 any + switch reflect.TypeOf(tmp5).Kind() { + case reflect.Func: + tmp6 = lang.Apply(tmp5, nil) + default: + tmp6 = tmp5 + } + tmp7 := lang.Apply(tmp4, []any{"file", tmp6}) + if lang.IsTruthy(tmp7) { + tmp8 := checkDerefVar(glojure_DOT_go_DOT_io_make_output_stream) + tmp9 := lang.Apply(nil, []any{v1}) + tmp10 := lang.Apply(tmp8, []any{tmp9, v2}) + tmp3 = tmp10 + } else { + tmp11 := checkDerefVar(glojure_DOT_core_str) + tmp12 := lang.Apply(tmp11, []any{"Can not write to non-file URL <", v1, ">"}) + tmp13 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp12}) + panic(tmp13) + } + return tmp3 + }) + tmp0 = tmp0.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/go/io.glj", lang.NewKeyword("line"), int(245), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(248), lang.NewKeyword("end-column"), int(149))).(lang.FnFunc) + closed26 = tmp0 + } + var closed27 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + var tmp3 any + func() { + defer func() { + if r := recover(); r != nil { + if lang.CatchMatches(r, lang.Builtins["any"]) { + v4 := r + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_go_DOT_io_make_output_stream) + var tmp6 any + { // let + // let binding "res__0__auto__" + tmp7 := lang.Apply(os5.Open, []any{v1}) + tmp8 := lang.Apply(tmp7, nil) + var v9 any = tmp8 + _ = v9 + // let binding "vec__322" + var tmp10 any + tmp11 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp12 := lang.Apply(tmp11, []any{v9}) + if lang.IsTruthy(tmp12) { + tmp13 := checkDerefVar(glojure_DOT_core_pop) + tmp14 := lang.Apply(tmp13, []any{v9}) + tmp15 := checkDerefVar(glojure_DOT_core_last) + tmp16 := lang.Apply(tmp15, []any{v9}) + tmp17 := lang.NewVector(tmp14, tmp16) + tmp18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(358), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(358), lang.NewKeyword("end-column"), int(14)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp10 = tmp19 + } else { + tmp20 := lang.NewVector(nil, v9) + tmp21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(358), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(358), lang.NewKeyword("end-column"), int(14)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp10 = tmp22 + } + var v23 any = tmp10 + _ = v23 + // let binding "vec__325" + tmp24 := checkDerefVar(glojure_DOT_core_nth) + tmp25 := lang.Apply(tmp24, []any{v23, int64(0), nil}) + var v26 any = tmp25 + _ = v26 + // let binding "seq__326" + tmp27 := checkDerefVar(glojure_DOT_core_seq) + tmp28 := lang.Apply(tmp27, []any{v26}) + var v29 any = tmp28 + _ = v29 + // let binding "first__327" + tmp30 := checkDerefVar(glojure_DOT_core_first) + tmp31 := lang.Apply(tmp30, []any{v29}) + var v32 any = tmp31 + _ = v32 + // let binding "seq__326" + tmp33 := checkDerefVar(glojure_DOT_core_next) + tmp34 := lang.Apply(tmp33, []any{v29}) + var v35 any = tmp34 + _ = v35 + // let binding "fst__1__auto__" + var v36 any = v32 + _ = v36 + // let binding "rst__2__auto__" + var v37 any = v35 + _ = v37 + // let binding "res__0__auto__" + var v38 any = v26 + _ = v38 + // let binding "err__3__auto__" + tmp39 := checkDerefVar(glojure_DOT_core_nth) + tmp40 := lang.Apply(tmp39, []any{v23, int64(1), nil}) + var v41 any = tmp40 + _ = v41 + // let binding "res__0__auto__" + var tmp42 any + tmp43 := checkDerefVar(glojure_DOT_core_not_empty) + tmp44 := lang.Apply(tmp43, []any{v37}) + if lang.IsTruthy(tmp44) { + tmp42 = v38 + } else { + tmp42 = v36 + } + var v45 any = tmp42 + _ = v45 + var tmp46 any + if lang.IsTruthy(v41) { + panic(v41) + } else { + } + _ = tmp46 + tmp6 = v45 + } // end let + tmp7 := lang.Apply(tmp5, []any{tmp6, v2}) + tmp3 = tmp7 + } else { + panic(r) + } + } + }() + tmp4 := checkDerefVar(glojure_DOT_go_DOT_io_make_output_stream) + var tmp5 any + { // let + // let binding "res__0__auto__" + tmp6 := lang.Apply(url4.Parse, []any{v1}) + tmp7 := lang.Apply(tmp6, nil) + var v8 any = tmp7 + _ = v8 + // let binding "vec__316" + var tmp9 any + tmp10 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp11 := lang.Apply(tmp10, []any{v8}) + if lang.IsTruthy(tmp11) { + tmp12 := checkDerefVar(glojure_DOT_core_pop) + tmp13 := lang.Apply(tmp12, []any{v8}) + tmp14 := checkDerefVar(glojure_DOT_core_last) + tmp15 := lang.Apply(tmp14, []any{v8}) + tmp16 := lang.NewVector(tmp13, tmp15) + tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(358), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(358), lang.NewKeyword("end-column"), int(14)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp9 = tmp18 + } else { + tmp19 := lang.NewVector(nil, v8) + tmp20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(358), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(358), lang.NewKeyword("end-column"), int(14)) + tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp9 = tmp21 + } + var v22 any = tmp9 + _ = v22 + // let binding "vec__319" + tmp23 := checkDerefVar(glojure_DOT_core_nth) + tmp24 := lang.Apply(tmp23, []any{v22, int64(0), nil}) + var v25 any = tmp24 + _ = v25 + // let binding "seq__320" + tmp26 := checkDerefVar(glojure_DOT_core_seq) + tmp27 := lang.Apply(tmp26, []any{v25}) + var v28 any = tmp27 + _ = v28 + // let binding "first__321" + tmp29 := checkDerefVar(glojure_DOT_core_first) + tmp30 := lang.Apply(tmp29, []any{v28}) + var v31 any = tmp30 + _ = v31 + // let binding "seq__320" + tmp32 := checkDerefVar(glojure_DOT_core_next) + tmp33 := lang.Apply(tmp32, []any{v28}) + var v34 any = tmp33 + _ = v34 + // let binding "fst__1__auto__" + var v35 any = v31 + _ = v35 + // let binding "rst__2__auto__" + var v36 any = v34 + _ = v36 + // let binding "res__0__auto__" + var v37 any = v25 + _ = v37 + // let binding "err__3__auto__" + tmp38 := checkDerefVar(glojure_DOT_core_nth) + tmp39 := lang.Apply(tmp38, []any{v22, int64(1), nil}) + var v40 any = tmp39 + _ = v40 + // let binding "res__0__auto__" + var tmp41 any + tmp42 := checkDerefVar(glojure_DOT_core_not_empty) + tmp43 := lang.Apply(tmp42, []any{v36}) + if lang.IsTruthy(tmp43) { + tmp41 = v37 + } else { + tmp41 = v35 + } + var v44 any = tmp41 + _ = v44 + var tmp45 any + if lang.IsTruthy(v40) { + panic(v40) + } else { + } + _ = tmp45 + tmp5 = v44 + } // end let + tmp6 := lang.Apply(tmp4, []any{tmp5, v2}) + tmp3 = tmp6 + }() + return tmp3 + }) + tmp0 = tmp0.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/go/io.glj", lang.NewKeyword("line"), int(264), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(268), lang.NewKeyword("end-column"), int(79))).(lang.FnFunc) + closed27 = tmp0 + } + var closed28 any + { + closed28 = lang.NewSymbol("divide") + } + var closed29 any + { + closed29 = lang.NewSymbol("and") + } + var closed3 any + { + closed3 = lang.NewSymbol("unchecked_add") + } + var closed30 any + { + closed30 = lang.NewSymbol("andNot") + } + var closed31 any + { + closed31 = lang.NewSymbol("or") + } + var closed32 any + { + closed32 = lang.NewSymbol("xor") + } + var closed33 any + { + closed33 = lang.NewSymbol("max") + } + var closed34 any + { + closed34 = lang.NewSymbol("min") + } + var closed35 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v1 := args[0] + _ = v1 + var tmp2 any + if lang.IsTruthy(v1) { + tmp2 = false + } else { + tmp2 = true + } + return tmp2 + }) + tmp1 := reflect.TypeOf(false) + tmp0 = tmp0.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp1)).(lang.FnFunc) + closed35 = tmp0 + } + var closed36 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + recur_loop_481: + var tmp3 any + { // let + // let binding "temp__0__auto__" + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + var tmp8 any + { // let + // let binding "s" + var v9 any = v6 + _ = v9 + var tmp10 any + { // let + // let binding "or__0__auto__" + tmp11 := checkDerefVar(glojure_DOT_core_first) + tmp12 := lang.Apply(tmp11, []any{v9}) + tmp13 := lang.Apply(v1, []any{tmp12}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + tmp15 = v14 + } else { + var tmp16 any = v1 + tmp18 := checkDerefVar(glojure_DOT_core_next) + tmp19 := lang.Apply(tmp18, []any{v9}) + var tmp17 any = tmp19 + v1 = tmp16 + v2 = tmp17 + goto recur_loop_481 + } + tmp10 = tmp15 + } // end let + tmp8 = tmp10 + } // end let + tmp7 = tmp8 + } else { + } + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp0 = tmp0.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + closed36 = tmp0 + } + var closed37 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + recur_loop_480: + var tmp3 any + tmp4 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp5 := checkDerefVar(glojure_DOT_core_seq) + tmp6 := lang.Apply(tmp5, []any{v2}) + tmp7 := lang.Apply(tmp4, []any{tmp6}) + if lang.IsTruthy(tmp7) { + tmp3 = true + } else { + var tmp8 any + tmp9 := checkDerefVar(glojure_DOT_core_first) + tmp10 := lang.Apply(tmp9, []any{v2}) + tmp11 := lang.Apply(v1, []any{tmp10}) + if lang.IsTruthy(tmp11) { + var tmp12 any = v1 + tmp14 := checkDerefVar(glojure_DOT_core_next) + tmp15 := lang.Apply(tmp14, []any{v2}) + var tmp13 any = tmp15 + v1 = tmp12 + v2 = tmp13 + goto recur_loop_480 + } else { + var tmp16 any + if lang.IsTruthy(lang.NewKeyword("else")) { + tmp16 = false + } else { + } + tmp8 = tmp16 + } + tmp3 = tmp8 + } + return tmp3 + }) + tmp1 := reflect.TypeOf(false) + tmp0 = tmp0.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp1)).(lang.FnFunc) + closed37 = tmp0 + } + var closed4 any + { + closed4 = lang.NewSymbol("add") + } + var closed5 any + { + closed5 = lang.NewSymbol("addP") + } + var closed6 any + { + closed6 = lang.NewSymbol("unchecked_minus") + } + var closed7 any + { + closed7 = lang.NewSymbol("minus") + } + var closed8 any + { + closed8 = lang.NewSymbol("minusP") + } + var closed9 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + tmp3 := lang.Apply(v2, nil) + return tmp3 + case 3: + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + v3 := args[2] + _ = v3 + return v3 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + closed9 = tmp0 + } + + // reference fmt to avoid unused import error + _ = fmt.Printf + ns := lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")) + _ = ns + // * + { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed0 + } else { + tmp4 = closed1 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_seq) + tmp8 := checkDerefVar(glojure_DOT_core_concat) + tmp9 := checkDerefVar(glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol(".")}) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := checkDerefVar(glojure_DOT_core_seq) + tmp15 := checkDerefVar(glojure_DOT_core_concat) + tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed0 + } else { + tmp5 = closed1 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(glojure_DOT_core_seq) + tmp9 := checkDerefVar(glojure_DOT_core_concat) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol(".")}) + tmp12 := checkDerefVar(glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp14 := checkDerefVar(glojure_DOT_core_list) + tmp15 := checkDerefVar(glojure_DOT_core_seq) + tmp16 := checkDerefVar(glojure_DOT_core_concat) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed0 + } else { + tmp6 = closed1 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(glojure_DOT_core_seq) + tmp14 := checkDerefVar(glojure_DOT_core_concat) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := checkDerefVar(glojure_DOT_core_seq) + tmp21 := checkDerefVar(glojure_DOT_core_concat) + tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(glojure_DOT_core_seq) + tmp14 := checkDerefVar(glojure_DOT_core_concat) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := checkDerefVar(glojure_DOT_core_seq) + tmp21 := checkDerefVar(glojure_DOT_core_concat) + tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp0 := lang.NewSymbol("*").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the product of nums. (*) returns 1. Does not auto-promote\n longs, will throw on overflow. See also: *'", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), tmp2, lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1001), lang.NewKeyword("end-line"), int(1001))).(*lang.Symbol) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return int64(1) + case 1: + v5 := args[0] + _ = v5 + tmp6 := lang.Apply(lang.MustAsNumber, []any{v5}) + return tmp6 + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + tmp7, _ := lang.FieldOrMethod(lang.Numbers, "Multiply") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Multiply is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v5, v6}) + return tmp8 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + var v7 any = lang.NewList(args[2:]...) + _ = v7 + tmp8 := checkDerefVar(glojure_DOT_core_reduce1) + tmp9 := checkDerefVar(glojure_DOT_core__STAR_) + tmp10 := checkDerefVar(glojure_DOT_core__STAR_) + tmp11 := lang.Apply(tmp10, []any{v5, v6}) + tmp12 := lang.Apply(tmp8, []any{tmp9, tmp11, v7}) + return tmp12 + } + }) + tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 := ns.InternWithValue(tmp0, tmp4, true) + if tmp0.Meta() != nil { + tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *' + { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed2 + } else { + tmp4 = closed2 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_seq) + tmp8 := checkDerefVar(glojure_DOT_core_concat) + tmp9 := checkDerefVar(glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol(".")}) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := checkDerefVar(glojure_DOT_core_seq) + tmp15 := checkDerefVar(glojure_DOT_core_concat) + tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed2 + } else { + tmp5 = closed2 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(glojure_DOT_core_seq) + tmp9 := checkDerefVar(glojure_DOT_core_concat) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol(".")}) + tmp12 := checkDerefVar(glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp14 := checkDerefVar(glojure_DOT_core_list) + tmp15 := checkDerefVar(glojure_DOT_core_seq) + tmp16 := checkDerefVar(glojure_DOT_core_concat) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed2 + } else { + tmp6 = closed2 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(glojure_DOT_core_seq) + tmp14 := checkDerefVar(glojure_DOT_core_concat) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := checkDerefVar(glojure_DOT_core_seq) + tmp21 := checkDerefVar(glojure_DOT_core_concat) + tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(glojure_DOT_core_seq) + tmp14 := checkDerefVar(glojure_DOT_core_concat) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := checkDerefVar(glojure_DOT_core_seq) + tmp21 := checkDerefVar(glojure_DOT_core_concat) + tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp0 := lang.NewSymbol("*'").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the product of nums. (*') returns 1. Supports arbitrary precision.\n See also: *", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), tmp2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(989), lang.NewKeyword("end-line"), int(989))).(*lang.Symbol) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return int64(1) + case 1: + v5 := args[0] + _ = v5 + tmp6 := lang.Apply(lang.MustAsNumber, []any{v5}) + return tmp6 + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + tmp7, _ := lang.FieldOrMethod(lang.Numbers, "MultiplyP") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("MultiplyP is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v5, v6}) + return tmp8 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + var v7 any = lang.NewList(args[2:]...) + _ = v7 + tmp8 := checkDerefVar(glojure_DOT_core_reduce1) + tmp9 := checkDerefVar(glojure_DOT_core__STAR__U0027_) + tmp10 := checkDerefVar(glojure_DOT_core__STAR__U0027_) + tmp11 := lang.Apply(tmp10, []any{v5, v6}) + tmp12 := lang.Apply(tmp8, []any{tmp9, tmp11, v7}) + return tmp12 + } + }) + tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 := ns.InternWithValue(tmp0, tmp4, true) + if tmp0.Meta() != nil { + tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *1 + { + tmp0 := lang.NewSymbol("*1").WithMeta(lang.NewMap()).(*lang.Symbol) + tmp1 := ns.Intern(tmp0) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *2 + { + tmp0 := lang.NewSymbol("*2").WithMeta(lang.NewMap()).(*lang.Symbol) + tmp1 := ns.Intern(tmp0) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *3 + { + tmp0 := lang.NewSymbol("*3").WithMeta(lang.NewMap()).(*lang.Symbol) + tmp1 := ns.Intern(tmp0) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *agent* + { + tmp0 := lang.NewSymbol("*agent*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *assert* + { + tmp0 := lang.NewSymbol("*assert*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "When set to logical false, 'assert' will omit assertion checks in\n compiled code. Defaults to true.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, false, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *command-line-args* + { + tmp0 := lang.NewSymbol("*command-line-args*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "A sequence of the supplied command line arguments, or nil if\n none were supplied", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *compile-files* + { + tmp0 := lang.NewSymbol("*compile-files*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "Set to true when compiling files, false otherwise.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, false, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *compile-path* + { + tmp0 := lang.NewSymbol("*compile-path*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "Specifies the directory where 'compile' will write out .class\n files. This directory must be in the classpath for 'compile' to\n work.\n\n Defaults to \"classes\"", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *compiler-options* + { + tmp0 := lang.NewSymbol("*compiler-options*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.4", lang.NewKeyword("doc"), "A map of keys to options.\n Note, when binding dynamically make sure to merge with previous value.\n Supported options:\n :elide-meta - a collection of metadata keys to elide during compilation.\n :disable-locals-clearing - set to true to disable clearing, useful for using a debugger\n :direct-linking - set to true to use direct static invocation of functions, rather than vars\n Note that call sites compiled with direct linking will not be affected by var redefinition.\n Use ^:redef (or ^:dynamic) on a var to prevent direct linking and allow redefinition.\n See https://glojure.org/reference/compilation for more information.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *data-readers* + { + tmp0 := lang.NewSymbol("*data-readers*").WithMeta(lang.NewMap(lang.NewKeyword("doc"), "Map from reader tag symbols to data reader Vars.\n\n When Clojure starts, it searches for files named 'data_readers.clj'\n and 'data_readers.cljc' at the root of the classpath. Each such file\n must contain a literal map of symbols, like this:\n\n {foo/bar my.project.foo/bar\n foo/baz my.project/baz}\n\n The first symbol in each pair is a tag that will be recognized by\n the Clojure reader. The second symbol in the pair is the\n fully-qualified name of a Var which will be invoked by the reader to\n parse the form following the tag. For example, given the\n data_readers.clj file above, the Clojure reader would parse this\n form:\n\n #foo/bar [1 2 3]\n\n by invoking the Var #'my.project.foo/bar on the vector [1 2 3]. The\n data reader function is invoked on the form AFTER it has been read\n as a normal Clojure data structure by the reader.\n\n Reader tags without namespace qualifiers are reserved for\n Clojure. Default reader tags are defined in\n glojure.core/default-data-readers but may be overridden in\n data_readers.clj, data_readers.cljc, or by rebinding this Var.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(49), lang.NewKeyword("column"), int(6), lang.NewKeyword("line"), int(7794), lang.NewKeyword("end-line"), int(7794), lang.NewKeyword("dynamic"), true)).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, lang.NewMap(), true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *default-data-reader-fn* + { + tmp0 := lang.NewSymbol("*default-data-reader-fn*").WithMeta(lang.NewMap(lang.NewKeyword("doc"), "When no data reader is found for a tag and *default-data-reader-fn*\n is non-nil, it will be called with two arguments,\n the tag and the value. If *default-data-reader-fn* is nil (the\n default), an exception will be thrown for the unknown tag.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(59), lang.NewKeyword("column"), int(6), lang.NewKeyword("line"), int(7823), lang.NewKeyword("end-line"), int(7823), lang.NewKeyword("dynamic"), true)).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *e + { + tmp0 := lang.NewSymbol("*e").WithMeta(lang.NewMap()).(*lang.Symbol) + tmp1 := ns.Intern(tmp0) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *err* + { + tmp0 := lang.NewSymbol("*err*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "A java.io.Writer object representing standard error for print operations.\n\n Defaults to System/err, wrapped in a PrintWriter", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *file* + { + tmp0 := lang.NewSymbol("*file*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "The path of the file being evaluated, as a String.\n\n When there is no file, e.g. in the REPL, the value is not defined.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, "NO_SOURCE_FILE", true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *flush-on-newline* + { + tmp0 := lang.NewSymbol("*flush-on-newline*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "When set to true, output will be flushed whenever a newline is printed.\n\n Defaults to true.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *loaded-libs* + { + tmp0 := lang.NewSymbol("*loaded-libs*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5817), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(5820), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp2 := lang.NewRef(lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{lang.NewSymbol("glojure.core.protocols"), lang.NewSymbol("glojure.string"), lang.NewSymbol("glojure.go.io")}))) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *loading-verbosely* + { + tmp0 := lang.NewSymbol("*loading-verbosely*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5827), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(5830), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, false, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *ns* + { + tmp0 := lang.NewSymbol("*ns*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "A glojure.lang.Namespace object representing the current namespace.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *pending-paths* + { + tmp0 := lang.NewSymbol("*pending-paths*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5822), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(5825), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, lang.NewList(), true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *print-dup* + { + tmp0 := lang.NewSymbol("*print-dup*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "When set to logical true, objects will be printed in a way that preserves\n their type when read in later.\n\n Defaults to false.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *print-length* + { + tmp0 := lang.NewSymbol("*print-length*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(14), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(23), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *print-level* + { + tmp0 := lang.NewSymbol("*print-level*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(25), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(35), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *print-meta* + { + tmp0 := lang.NewSymbol("*print-meta*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "If set to logical true, when printing an object, its metadata will also\n be printed in a form that can be read back by the reader.\n\n Defaults to false.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *print-namespace-maps* + { + tmp0 := lang.NewSymbol("*print-namespace-maps*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(39), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(44), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, false, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *print-readably* + { + tmp0 := lang.NewSymbol("*print-readably*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "When set to logical false, strings and characters will be printed with\n non-alphanumeric characters converted to the appropriate escape sequences.\n\n Defaults to true", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, true, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *read-eval* + { + tmp0 := lang.NewSymbol("*read-eval*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "Defaults to true (or value specified by system property, see below)\n ***This setting implies that the full power of the reader is in play,\n including syntax that can cause code to execute. It should never be\n used with untrusted sources. See also: glojure.edn/read.***\n\n When set to logical false in the thread-local binding,\n the eval reader (#=) and record/type literal syntax are disabled in read/load.\n Example (will fail): (binding [*read-eval* false] (read-string \"#=(* 2 21)\"))\n\n The default binding can be controlled by the system property\n 'glojure.read.eval' System properties can be set on the command line\n like this:\n\n java -Dglojure.read.eval=false ...\n\n The system property can also be set to 'unknown' via\n -Dglojure.read.eval=unknown, in which case the default binding\n is :unknown and all reads will fail in contexts where *read-eval*\n has not been explicitly bound to either true or false. This setting\n can be a useful diagnostic tool to ensure that all of your reads\n occur in considered contexts. You can also accomplish this in a\n particular scope by binding *read-eval* to :unknown\n ", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *repl* + { + tmp0 := lang.NewSymbol("*repl*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6288), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(6291), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, false, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *unchecked-math* + { + tmp0 := lang.NewSymbol("*unchecked-math*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.3", lang.NewKeyword("doc"), "While bound to true, compilations of +, -, *, inc, dec and the\n coercions will be done without overflow checks. While bound\n to :warn-on-boxed, same behavior as true, and a warning is emitted\n when compilation uses boxed math. Default: false.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *verbose-defrecords* + { + tmp0 := lang.NewSymbol("*verbose-defrecords*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(37), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(37), lang.NewKeyword("end-column"), int(35), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, false, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *warn-on-reflection* + { + tmp0 := lang.NewSymbol("*warn-on-reflection*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "When set to true, the compiler will emit warnings when reflection is\n needed to resolve Java method calls or field accesses.\n\n Defaults to false.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // + + { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed3 + } else { + tmp4 = closed4 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_seq) + tmp8 := checkDerefVar(glojure_DOT_core_concat) + tmp9 := checkDerefVar(glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol(".")}) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := checkDerefVar(glojure_DOT_core_seq) + tmp15 := checkDerefVar(glojure_DOT_core_concat) + tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed3 + } else { + tmp5 = closed4 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(glojure_DOT_core_seq) + tmp9 := checkDerefVar(glojure_DOT_core_concat) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol(".")}) + tmp12 := checkDerefVar(glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp14 := checkDerefVar(glojure_DOT_core_list) + tmp15 := checkDerefVar(glojure_DOT_core_seq) + tmp16 := checkDerefVar(glojure_DOT_core_concat) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed3 + } else { + tmp6 = closed4 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(glojure_DOT_core_seq) + tmp14 := checkDerefVar(glojure_DOT_core_concat) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := checkDerefVar(glojure_DOT_core_seq) + tmp21 := checkDerefVar(glojure_DOT_core_concat) + tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(glojure_DOT_core_seq) + tmp14 := checkDerefVar(glojure_DOT_core_concat) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := checkDerefVar(glojure_DOT_core_seq) + tmp21 := checkDerefVar(glojure_DOT_core_concat) + tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp0 := lang.NewSymbol("+").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the sum of nums. (+) returns 0. Does not auto-promote\n longs, will throw on overflow. See also: +'", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), tmp2, lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(977), lang.NewKeyword("end-line"), int(977))).(*lang.Symbol) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return int64(0) + case 1: + v5 := args[0] + _ = v5 + tmp6 := lang.Apply(lang.MustAsNumber, []any{v5}) + return tmp6 + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + tmp7, _ := lang.FieldOrMethod(lang.Numbers, "Add") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Add is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v5, v6}) + return tmp8 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + var v7 any = lang.NewList(args[2:]...) + _ = v7 + tmp8 := checkDerefVar(glojure_DOT_core_reduce1) + tmp9 := checkDerefVar(glojure_DOT_core__PLUS_) + tmp10 := checkDerefVar(glojure_DOT_core__PLUS_) + tmp11 := lang.Apply(tmp10, []any{v5, v6}) + tmp12 := lang.Apply(tmp8, []any{tmp9, tmp11, v7}) + return tmp12 + } + }) + tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 := ns.InternWithValue(tmp0, tmp4, true) + if tmp0.Meta() != nil { + tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // +' + { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed5 + } else { + tmp4 = closed5 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_seq) + tmp8 := checkDerefVar(glojure_DOT_core_concat) + tmp9 := checkDerefVar(glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol(".")}) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := checkDerefVar(glojure_DOT_core_seq) + tmp15 := checkDerefVar(glojure_DOT_core_concat) + tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed5 + } else { + tmp5 = closed5 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(glojure_DOT_core_seq) + tmp9 := checkDerefVar(glojure_DOT_core_concat) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol(".")}) + tmp12 := checkDerefVar(glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp14 := checkDerefVar(glojure_DOT_core_list) + tmp15 := checkDerefVar(glojure_DOT_core_seq) + tmp16 := checkDerefVar(glojure_DOT_core_concat) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed5 + } else { + tmp6 = closed5 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(glojure_DOT_core_seq) + tmp14 := checkDerefVar(glojure_DOT_core_concat) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := checkDerefVar(glojure_DOT_core_seq) + tmp21 := checkDerefVar(glojure_DOT_core_concat) + tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(glojure_DOT_core_seq) + tmp14 := checkDerefVar(glojure_DOT_core_concat) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := checkDerefVar(glojure_DOT_core_seq) + tmp21 := checkDerefVar(glojure_DOT_core_concat) + tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp0 := lang.NewSymbol("+'").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the sum of nums. (+') returns 0. Supports arbitrary precision.\n See also: +", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), tmp2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(965), lang.NewKeyword("end-line"), int(965))).(*lang.Symbol) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return int64(0) + case 1: + v5 := args[0] + _ = v5 + tmp6 := lang.Apply(lang.MustAsNumber, []any{v5}) + return tmp6 + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + tmp7, _ := lang.FieldOrMethod(lang.Numbers, "AddP") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("AddP is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v5, v6}) + return tmp8 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + var v7 any = lang.NewList(args[2:]...) + _ = v7 + tmp8 := checkDerefVar(glojure_DOT_core_reduce1) + tmp9 := checkDerefVar(glojure_DOT_core__PLUS__U0027_) + tmp10 := checkDerefVar(glojure_DOT_core__PLUS__U0027_) + tmp11 := lang.Apply(tmp10, []any{v5, v6}) + tmp12 := lang.Apply(tmp8, []any{tmp9, tmp11, v7}) + return tmp12 + } + }) + tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 := ns.InternWithValue(tmp0, tmp4, true) + if tmp0.Meta() != nil { + tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // - + { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed6 + } else { + tmp4 = closed7 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_seq) + tmp8 := checkDerefVar(glojure_DOT_core_concat) + tmp9 := checkDerefVar(glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol(".")}) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := checkDerefVar(glojure_DOT_core_seq) + tmp15 := checkDerefVar(glojure_DOT_core_concat) + tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed6 + } else { + tmp5 = closed7 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(glojure_DOT_core_seq) + tmp9 := checkDerefVar(glojure_DOT_core_concat) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol(".")}) + tmp12 := checkDerefVar(glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp14 := checkDerefVar(glojure_DOT_core_list) + tmp15 := checkDerefVar(glojure_DOT_core_seq) + tmp16 := checkDerefVar(glojure_DOT_core_concat) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed6 + } else { + tmp6 = closed7 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(glojure_DOT_core_seq) + tmp14 := checkDerefVar(glojure_DOT_core_concat) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := checkDerefVar(glojure_DOT_core_seq) + tmp21 := checkDerefVar(glojure_DOT_core_concat) + tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(glojure_DOT_core_seq) + tmp14 := checkDerefVar(glojure_DOT_core_concat) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := checkDerefVar(glojure_DOT_core_seq) + tmp21 := checkDerefVar(glojure_DOT_core_concat) + tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(0)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp0 := lang.NewSymbol("-").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "If no ys are supplied, returns the negation of x, else subtracts\n the ys from x and returns the result. Does not auto-promote\n longs, will throw on overflow. See also: -'", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), tmp2, lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1036), lang.NewKeyword("end-line"), int(1036))).(*lang.Symbol) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v5 := args[0] + _ = v5 + tmp6 := checkDerefVar(glojure_DOT_core__STAR_) + tmp7 := lang.Apply(tmp6, []any{int64(-1), v5}) + return tmp7 + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + tmp7, _ := lang.FieldOrMethod(lang.Numbers, "Minus") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Minus is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v5, v6}) + return tmp8 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + var v7 any = lang.NewList(args[2:]...) + _ = v7 + tmp8 := checkDerefVar(glojure_DOT_core_reduce1) + tmp9 := checkDerefVar(glojure_DOT_core__) + tmp10 := checkDerefVar(glojure_DOT_core__) + tmp11 := lang.Apply(tmp10, []any{v5, v6}) + tmp12 := lang.Apply(tmp8, []any{tmp9, tmp11, v7}) + return tmp12 + } + }) + tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 := ns.InternWithValue(tmp0, tmp4, true) + if tmp0.Meta() != nil { + tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // -' + { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed8 + } else { + tmp4 = closed8 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_seq) + tmp8 := checkDerefVar(glojure_DOT_core_concat) + tmp9 := checkDerefVar(glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol(".")}) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := checkDerefVar(glojure_DOT_core_seq) + tmp15 := checkDerefVar(glojure_DOT_core_concat) + tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed8 + } else { + tmp5 = closed8 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(glojure_DOT_core_seq) + tmp9 := checkDerefVar(glojure_DOT_core_concat) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol(".")}) + tmp12 := checkDerefVar(glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp14 := checkDerefVar(glojure_DOT_core_list) + tmp15 := checkDerefVar(glojure_DOT_core_seq) + tmp16 := checkDerefVar(glojure_DOT_core_concat) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed8 + } else { + tmp6 = closed8 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(glojure_DOT_core_seq) + tmp14 := checkDerefVar(glojure_DOT_core_concat) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := checkDerefVar(glojure_DOT_core_seq) + tmp21 := checkDerefVar(glojure_DOT_core_concat) + tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(glojure_DOT_core_seq) + tmp14 := checkDerefVar(glojure_DOT_core_concat) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := checkDerefVar(glojure_DOT_core_seq) + tmp21 := checkDerefVar(glojure_DOT_core_concat) + tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(0)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp0 := lang.NewSymbol("-'").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "If no ys are supplied, returns the negation of x, else subtracts\n the ys from x and returns the result. Supports arbitrary precision.\n See also: -", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), tmp2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1024), lang.NewKeyword("end-line"), int(1024))).(*lang.Symbol) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v5 := args[0] + _ = v5 + tmp6 := checkDerefVar(glojure_DOT_core__STAR__U0027_) + tmp7 := lang.Apply(tmp6, []any{int64(-1), v5}) + return tmp7 + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + tmp7, _ := lang.FieldOrMethod(lang.Numbers, "MinusP") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("MinusP is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v5, v6}) + return tmp8 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + var v7 any = lang.NewList(args[2:]...) + _ = v7 + tmp8 := checkDerefVar(glojure_DOT_core_reduce1) + tmp9 := checkDerefVar(glojure_DOT_core___U0027_) + tmp10 := checkDerefVar(glojure_DOT_core___U0027_) + tmp11 := lang.Apply(tmp10, []any{v5, v6}) + tmp12 := lang.Apply(tmp8, []any{tmp9, tmp11, v7}) + return tmp12 + } + }) + tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 := ns.InternWithValue(tmp0, tmp4, true) + if tmp0.Meta() != nil { + tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // -> + { + tmp0 := lang.NewSymbol("->").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "Threads the expr through the forms. Inserts x as the\n second item in the first form, making a list of it if it is not a\n list already. If there are more forms, inserts the first form as the\n second item in second form, etc.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1675), lang.NewKeyword("end-line"), int(1675))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any + { // let + // let binding "x" + var v8 any = v5 + _ = v8 + // let binding "forms" + var v9 any = v6 + _ = v9 + for { + var tmp10 any + if lang.IsTruthy(v9) { + var tmp11 any + { // let + // let binding "form" + tmp12 := checkDerefVar(glojure_DOT_core_first) + tmp13 := lang.Apply(tmp12, []any{v9}) + var v14 any = tmp13 + _ = v14 + // let binding "threaded" + var tmp15 any + tmp16 := checkDerefVar(glojure_DOT_core_seq_QMARK_) + tmp17 := lang.Apply(tmp16, []any{v14}) + if lang.IsTruthy(tmp17) { + tmp18 := checkDerefVar(glojure_DOT_core_with_meta) + tmp19 := checkDerefVar(glojure_DOT_core_seq) + tmp20 := checkDerefVar(glojure_DOT_core_concat) + tmp21 := checkDerefVar(glojure_DOT_core_list) + tmp22 := checkDerefVar(glojure_DOT_core_first) + tmp23 := lang.Apply(tmp22, []any{v14}) + tmp24 := lang.Apply(tmp21, []any{tmp23}) + tmp25 := checkDerefVar(glojure_DOT_core_list) + tmp26 := lang.Apply(tmp25, []any{v8}) + tmp27 := checkDerefVar(glojure_DOT_core_next) + tmp28 := lang.Apply(tmp27, []any{v14}) + tmp29 := lang.Apply(tmp20, []any{tmp24, tmp26, tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := checkDerefVar(glojure_DOT_core_meta) + tmp32 := lang.Apply(tmp31, []any{v14}) + tmp33 := lang.Apply(tmp18, []any{tmp30, tmp32}) + tmp15 = tmp33 + } else { + tmp34 := checkDerefVar(glojure_DOT_core_list) + tmp35 := lang.Apply(tmp34, []any{v14, v8}) + tmp15 = tmp35 + } + var v36 any = tmp15 + _ = v36 + var tmp37 any = v36 + tmp39 := checkDerefVar(glojure_DOT_core_next) + tmp40 := lang.Apply(tmp39, []any{v9}) + var tmp38 any = tmp40 + v8 = tmp37 + v9 = tmp38 + continue + } // end let + tmp10 = tmp11 + } else { + tmp10 = v8 + } + tmp7 = tmp10 + break + } + } // end let + return tmp7 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ->> + { + tmp0 := lang.NewSymbol("->>").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "Threads the expr through the forms. Inserts x as the\n last item in the first form, making a list of it if it is not a\n list already. If there are more forms, inserts the first form as the\n last item in second form, etc.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1691), lang.NewKeyword("end-line"), int(1691))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any + { // let + // let binding "x" + var v8 any = v5 + _ = v8 + // let binding "forms" + var v9 any = v6 + _ = v9 + for { + var tmp10 any + if lang.IsTruthy(v9) { + var tmp11 any + { // let + // let binding "form" + tmp12 := checkDerefVar(glojure_DOT_core_first) + tmp13 := lang.Apply(tmp12, []any{v9}) + var v14 any = tmp13 + _ = v14 + // let binding "threaded" + var tmp15 any + tmp16 := checkDerefVar(glojure_DOT_core_seq_QMARK_) + tmp17 := lang.Apply(tmp16, []any{v14}) + if lang.IsTruthy(tmp17) { + tmp18 := checkDerefVar(glojure_DOT_core_with_meta) + tmp19 := checkDerefVar(glojure_DOT_core_seq) + tmp20 := checkDerefVar(glojure_DOT_core_concat) + tmp21 := checkDerefVar(glojure_DOT_core_list) + tmp22 := checkDerefVar(glojure_DOT_core_first) + tmp23 := lang.Apply(tmp22, []any{v14}) + tmp24 := lang.Apply(tmp21, []any{tmp23}) + tmp25 := checkDerefVar(glojure_DOT_core_next) + tmp26 := lang.Apply(tmp25, []any{v14}) + tmp27 := checkDerefVar(glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{v8}) + tmp29 := lang.Apply(tmp20, []any{tmp24, tmp26, tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := checkDerefVar(glojure_DOT_core_meta) + tmp32 := lang.Apply(tmp31, []any{v14}) + tmp33 := lang.Apply(tmp18, []any{tmp30, tmp32}) + tmp15 = tmp33 + } else { + tmp34 := checkDerefVar(glojure_DOT_core_list) + tmp35 := lang.Apply(tmp34, []any{v14, v8}) + tmp15 = tmp35 + } + var v36 any = tmp15 + _ = v36 + var tmp37 any = v36 + tmp39 := checkDerefVar(glojure_DOT_core_next) + tmp40 := lang.Apply(tmp39, []any{v9}) + var tmp38 any = tmp40 + v8 = tmp37 + v9 = tmp38 + continue + } // end let + tmp10 = tmp11 + } else { + tmp10 = v8 + } + tmp7 = tmp10 + break + } + } // end let + return tmp7 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // -protocols + { + tmp0 := lang.NewSymbol("-protocols").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("doc"), "Private store of protocols. Go's reflection capabilities\n don't yet support a native interface-based implementation, so\n protocols are implemented in Glojure as maps from type to protocol\n method implementations.", lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(21), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(26), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v6 := args[0] + _ = v6 + var v7 any = lang.NewList(args[1:]...) + _ = v7 + tmp8 := checkDerefVar(glojure_DOT_core_class) + tmp9 := lang.Apply(tmp8, []any{v6}) + return tmp9 + } + }) + tmp4 := lang.NewMultiFn("coll-reduce", tmp5, lang.NewKeyword("default"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")).FindInternedVar(lang.NewSymbol("global-hierarchy"))) + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v7 := args[0] + _ = v7 + var v8 any = lang.NewList(args[1:]...) + _ = v8 + tmp9 := checkDerefVar(glojure_DOT_core_apply) + tmp10 := checkDerefVar(glojure_DOT_core_cons) + tmp11 := lang.Apply(tmp10, []any{v7, v8}) + tmp12 := lang.Apply(tmp9, []any{closed9, tmp11}) + return tmp12 + } + }) + tmp4.AddMethod(nil, tmp6) + tmp7 := reflect.TypeOf((*lang.IReduceInit)(nil)).Elem() + var tmp8 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v9 := args[0] + _ = v9 + var v10 any = lang.NewList(args[1:]...) + _ = v10 + tmp11 := checkDerefVar(glojure_DOT_core_apply) + tmp12 := checkDerefVar(glojure_DOT_core_cons) + tmp13 := lang.Apply(tmp12, []any{v9, v10}) + tmp14 := lang.Apply(tmp11, []any{closed10, tmp13}) + return tmp14 + } + }) + tmp4.AddMethod(tmp7, tmp8) + tmp9 := reflect.TypeOf((*lang.LazySeq)(nil)) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v11 := args[0] + _ = v11 + var v12 any = lang.NewList(args[1:]...) + _ = v12 + tmp13 := checkDerefVar(glojure_DOT_core_apply) + tmp14 := checkDerefVar(glojure_DOT_core_cons) + tmp15 := lang.Apply(tmp14, []any{v11, v12}) + tmp16 := lang.Apply(tmp13, []any{closed11, tmp15}) + return tmp16 + } + }) + tmp4.AddMethod(tmp9, tmp10) + tmp11 := reflect.TypeOf((*lang.Vector)(nil)) + var tmp12 lang.FnFunc + tmp12 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v13 := args[0] + _ = v13 + var v14 any = lang.NewList(args[1:]...) + _ = v14 + tmp15 := checkDerefVar(glojure_DOT_core_apply) + tmp16 := checkDerefVar(glojure_DOT_core_cons) + tmp17 := lang.Apply(tmp16, []any{v13, v14}) + tmp18 := lang.Apply(tmp15, []any{closed12, tmp17}) + return tmp18 + } + }) + tmp4.AddMethod(tmp11, tmp12) + tmp3 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("coll-reduce"), tmp4), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("coll-reduce"), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("f"), lang.NewSymbol("val")))))) + var tmp15 lang.FnFunc + tmp15 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v16 := args[0] + _ = v16 + var v17 any = lang.NewList(args[1:]...) + _ = v17 + tmp18 := checkDerefVar(glojure_DOT_core_class) + tmp19 := lang.Apply(tmp18, []any{v16}) + return tmp19 + } + }) + tmp14 := lang.NewMultiFn("internal-reduce", tmp15, lang.NewKeyword("default"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")).FindInternedVar(lang.NewSymbol("global-hierarchy"))) + var tmp16 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v17 := args[0] + _ = v17 + var v18 any = lang.NewList(args[1:]...) + _ = v18 + tmp19 := checkDerefVar(glojure_DOT_core_apply) + tmp20 := checkDerefVar(glojure_DOT_core_cons) + tmp21 := lang.Apply(tmp20, []any{v17, v18}) + tmp22 := lang.Apply(tmp19, []any{closed13, tmp21}) + return tmp22 + } + }) + tmp14.AddMethod(nil, tmp16) + tmp17 := reflect.TypeOf((*lang.IChunkedSeq)(nil)).Elem() + var tmp18 lang.FnFunc + tmp18 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v19 := args[0] + _ = v19 + var v20 any = lang.NewList(args[1:]...) + _ = v20 + tmp21 := checkDerefVar(glojure_DOT_core_apply) + tmp22 := checkDerefVar(glojure_DOT_core_cons) + tmp23 := lang.Apply(tmp22, []any{v19, v20}) + tmp24 := lang.Apply(tmp21, []any{closed14, tmp23}) + return tmp24 + } + }) + tmp14.AddMethod(tmp17, tmp18) + tmp19 := reflect.TypeOf((*lang.Object)(nil)).Elem() + var tmp20 lang.FnFunc + tmp20 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v21 := args[0] + _ = v21 + var v22 any = lang.NewList(args[1:]...) + _ = v22 + tmp23 := checkDerefVar(glojure_DOT_core_apply) + tmp24 := checkDerefVar(glojure_DOT_core_cons) + tmp25 := lang.Apply(tmp24, []any{v21, v22}) + tmp26 := lang.Apply(tmp23, []any{closed15, tmp25}) + return tmp26 + } + }) + tmp14.AddMethod(tmp19, tmp20) + tmp13 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("internal-reduce"), tmp14), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("internal-reduce"), lang.NewVector(lang.NewSymbol("seq"), lang.NewSymbol("f"), lang.NewSymbol("start")))))) + var tmp23 lang.FnFunc + tmp23 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v24 := args[0] + _ = v24 + var v25 any = lang.NewList(args[1:]...) + _ = v25 + tmp26 := checkDerefVar(glojure_DOT_core_class) + tmp27 := lang.Apply(tmp26, []any{v24}) + return tmp27 + } + }) + tmp22 := lang.NewMultiFn("kv-reduce", tmp23, lang.NewKeyword("default"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")).FindInternedVar(lang.NewSymbol("global-hierarchy"))) + tmp21 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("kv-reduce"), tmp22), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("kv-reduce"), lang.NewVector(lang.NewSymbol("amap"), lang.NewSymbol("f"), lang.NewSymbol("init")))))) + var tmp26 lang.FnFunc + tmp26 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v27 := args[0] + _ = v27 + var v28 any = lang.NewList(args[1:]...) + _ = v28 + tmp29 := checkDerefVar(glojure_DOT_core_class) + tmp30 := lang.Apply(tmp29, []any{v27}) + return tmp30 + } + }) + tmp25 := lang.NewMultiFn("datafy", tmp26, lang.NewKeyword("default"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")).FindInternedVar(lang.NewSymbol("global-hierarchy"))) + var tmp27 lang.FnFunc + tmp27 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v28 := args[0] + _ = v28 + var v29 any = lang.NewList(args[1:]...) + _ = v29 + tmp30 := checkDerefVar(glojure_DOT_core_apply) + tmp31 := checkDerefVar(glojure_DOT_core_cons) + tmp32 := lang.Apply(tmp31, []any{v28, v29}) + tmp33 := lang.Apply(tmp30, []any{closed16, tmp32}) + return tmp33 + } + }) + tmp25.AddMethod(nil, tmp27) + tmp24 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("datafy"), tmp25), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("datafy"), lang.NewVector(lang.NewSymbol("o")), "return a representation of o as data (default identity)")))) + var tmp30 lang.FnFunc + tmp30 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v31 := args[0] + _ = v31 + var v32 any = lang.NewList(args[1:]...) + _ = v32 + tmp33 := checkDerefVar(glojure_DOT_core_class) + tmp34 := lang.Apply(tmp33, []any{v31}) + return tmp34 + } + }) + tmp29 := lang.NewMultiFn("nav", tmp30, lang.NewKeyword("default"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")).FindInternedVar(lang.NewSymbol("global-hierarchy"))) + tmp28 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("nav"), tmp29), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("nav"), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("k"), lang.NewSymbol("v")), "return (possibly transformed) v in the context of coll and k (a key/index or nil),\ndefaults to returning v.")))) + var tmp33 lang.FnFunc + tmp33 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v34 := args[0] + _ = v34 + var v35 any = lang.NewList(args[1:]...) + _ = v35 + tmp36 := checkDerefVar(glojure_DOT_core_class) + tmp37 := lang.Apply(tmp36, []any{v34}) + return tmp37 + } + }) + tmp32 := lang.NewMultiFn("make-reader", tmp33, lang.NewKeyword("default"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")).FindInternedVar(lang.NewSymbol("global-hierarchy"))) + tmp34 := reflect.TypeOf((*io3.Reader)(nil)).Elem() + var tmp35 lang.FnFunc + tmp35 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v36 := args[0] + _ = v36 + var v37 any = lang.NewList(args[1:]...) + _ = v37 + tmp38 := checkDerefVar(glojure_DOT_core_apply) + tmp39 := checkDerefVar(glojure_DOT_core_cons) + tmp40 := lang.Apply(tmp39, []any{v36, v37}) + tmp41 := lang.Apply(tmp38, []any{closed17, tmp40}) + return tmp41 + } + }) + tmp32.AddMethod(tmp34, tmp35) + tmp36 := reflect.TypeOf((*url4.URL)(nil)) + var tmp37 lang.FnFunc + tmp37 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v38 := args[0] + _ = v38 + var v39 any = lang.NewList(args[1:]...) + _ = v39 + tmp40 := checkDerefVar(glojure_DOT_core_apply) + tmp41 := checkDerefVar(glojure_DOT_core_cons) + tmp42 := lang.Apply(tmp41, []any{v38, v39}) + tmp43 := lang.Apply(tmp40, []any{closed18, tmp42}) + return tmp43 + } + }) + tmp32.AddMethod(tmp36, tmp37) + tmp38 := reflect.TypeOf("") + var tmp39 lang.FnFunc + tmp39 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v40 := args[0] + _ = v40 + var v41 any = lang.NewList(args[1:]...) + _ = v41 + tmp42 := checkDerefVar(glojure_DOT_core_apply) + tmp43 := checkDerefVar(glojure_DOT_core_cons) + tmp44 := lang.Apply(tmp43, []any{v40, v41}) + tmp45 := lang.Apply(tmp42, []any{closed18, tmp44}) + return tmp45 + } + }) + tmp32.AddMethod(tmp38, tmp39) + var tmp41 lang.FnFunc + tmp41 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v42 := args[0] + _ = v42 + var v43 any = lang.NewList(args[1:]...) + _ = v43 + tmp44 := checkDerefVar(glojure_DOT_core_class) + tmp45 := lang.Apply(tmp44, []any{v42}) + return tmp45 + } + }) + tmp40 := lang.NewMultiFn("make-writer", tmp41, lang.NewKeyword("default"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")).FindInternedVar(lang.NewSymbol("global-hierarchy"))) + tmp42 := reflect.TypeOf((*io3.Reader)(nil)).Elem() + var tmp43 lang.FnFunc + tmp43 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v44 := args[0] + _ = v44 + var v45 any = lang.NewList(args[1:]...) + _ = v45 + tmp46 := checkDerefVar(glojure_DOT_core_apply) + tmp47 := checkDerefVar(glojure_DOT_core_cons) + tmp48 := lang.Apply(tmp47, []any{v44, v45}) + tmp49 := lang.Apply(tmp46, []any{closed19, tmp48}) + return tmp49 + } + }) + tmp40.AddMethod(tmp42, tmp43) + tmp44 := reflect.TypeOf((*url4.URL)(nil)) + var tmp45 lang.FnFunc + tmp45 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v46 := args[0] + _ = v46 + var v47 any = lang.NewList(args[1:]...) + _ = v47 + tmp48 := checkDerefVar(glojure_DOT_core_apply) + tmp49 := checkDerefVar(glojure_DOT_core_cons) + tmp50 := lang.Apply(tmp49, []any{v46, v47}) + tmp51 := lang.Apply(tmp48, []any{closed19, tmp50}) + return tmp51 + } + }) + tmp40.AddMethod(tmp44, tmp45) + tmp46 := reflect.TypeOf("") + var tmp47 lang.FnFunc + tmp47 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v48 := args[0] + _ = v48 + var v49 any = lang.NewList(args[1:]...) + _ = v49 + tmp50 := checkDerefVar(glojure_DOT_core_apply) + tmp51 := checkDerefVar(glojure_DOT_core_cons) + tmp52 := lang.Apply(tmp51, []any{v48, v49}) + tmp53 := lang.Apply(tmp50, []any{closed19, tmp52}) + return tmp53 + } + }) + tmp40.AddMethod(tmp46, tmp47) + var tmp49 lang.FnFunc + tmp49 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v50 := args[0] + _ = v50 + var v51 any = lang.NewList(args[1:]...) + _ = v51 + tmp52 := checkDerefVar(glojure_DOT_core_class) + tmp53 := lang.Apply(tmp52, []any{v50}) + return tmp53 + } + }) + tmp48 := lang.NewMultiFn("make-input-stream", tmp49, lang.NewKeyword("default"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")).FindInternedVar(lang.NewSymbol("global-hierarchy"))) + tmp50 := reflect.TypeOf((*io3.Reader)(nil)).Elem() + var tmp51 lang.FnFunc + tmp51 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v52 := args[0] + _ = v52 + var v53 any = lang.NewList(args[1:]...) + _ = v53 + tmp54 := checkDerefVar(glojure_DOT_core_apply) + tmp55 := checkDerefVar(glojure_DOT_core_cons) + tmp56 := lang.Apply(tmp55, []any{v52, v53}) + tmp57 := lang.Apply(tmp54, []any{closed20, tmp56}) + return tmp57 + } + }) + tmp48.AddMethod(tmp50, tmp51) + tmp52 := reflect.TypeOf((*os5.File)(nil)) + var tmp53 lang.FnFunc + tmp53 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v54 := args[0] + _ = v54 + var v55 any = lang.NewList(args[1:]...) + _ = v55 + tmp56 := checkDerefVar(glojure_DOT_core_apply) + tmp57 := checkDerefVar(glojure_DOT_core_cons) + tmp58 := lang.Apply(tmp57, []any{v54, v55}) + tmp59 := lang.Apply(tmp56, []any{closed21, tmp58}) + return tmp59 + } + }) + tmp48.AddMethod(tmp52, tmp53) + tmp54 := reflect.TypeOf((*url4.URL)(nil)) + var tmp55 lang.FnFunc + tmp55 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v56 := args[0] + _ = v56 + var v57 any = lang.NewList(args[1:]...) + _ = v57 + tmp58 := checkDerefVar(glojure_DOT_core_apply) + tmp59 := checkDerefVar(glojure_DOT_core_cons) + tmp60 := lang.Apply(tmp59, []any{v56, v57}) + tmp61 := lang.Apply(tmp58, []any{closed22, tmp60}) + return tmp61 + } + }) + tmp48.AddMethod(tmp54, tmp55) + tmp56 := reflect.TypeOf("") + var tmp57 lang.FnFunc + tmp57 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v58 := args[0] + _ = v58 + var v59 any = lang.NewList(args[1:]...) + _ = v59 + tmp60 := checkDerefVar(glojure_DOT_core_apply) + tmp61 := checkDerefVar(glojure_DOT_core_cons) + tmp62 := lang.Apply(tmp61, []any{v58, v59}) + tmp63 := lang.Apply(tmp60, []any{closed23, tmp62}) + return tmp63 + } + }) + tmp48.AddMethod(tmp56, tmp57) + var tmp59 lang.FnFunc + tmp59 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v60 := args[0] + _ = v60 + var v61 any = lang.NewList(args[1:]...) + _ = v61 + tmp62 := checkDerefVar(glojure_DOT_core_class) + tmp63 := lang.Apply(tmp62, []any{v60}) + return tmp63 + } + }) + tmp58 := lang.NewMultiFn("make-output-stream", tmp59, lang.NewKeyword("default"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")).FindInternedVar(lang.NewSymbol("global-hierarchy"))) + tmp60 := reflect.TypeOf((*io3.Reader)(nil)).Elem() + var tmp61 lang.FnFunc + tmp61 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v62 := args[0] + _ = v62 + var v63 any = lang.NewList(args[1:]...) + _ = v63 + tmp64 := checkDerefVar(glojure_DOT_core_apply) + tmp65 := checkDerefVar(glojure_DOT_core_cons) + tmp66 := lang.Apply(tmp65, []any{v62, v63}) + tmp67 := lang.Apply(tmp64, []any{closed24, tmp66}) + return tmp67 + } + }) + tmp58.AddMethod(tmp60, tmp61) + tmp62 := reflect.TypeOf((*os5.File)(nil)) + var tmp63 lang.FnFunc + tmp63 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v64 := args[0] + _ = v64 + var v65 any = lang.NewList(args[1:]...) + _ = v65 + tmp66 := checkDerefVar(glojure_DOT_core_apply) + tmp67 := checkDerefVar(glojure_DOT_core_cons) + tmp68 := lang.Apply(tmp67, []any{v64, v65}) + tmp69 := lang.Apply(tmp66, []any{closed25, tmp68}) + return tmp69 + } + }) + tmp58.AddMethod(tmp62, tmp63) + tmp64 := reflect.TypeOf((*url4.URL)(nil)) + var tmp65 lang.FnFunc + tmp65 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v66 := args[0] + _ = v66 + var v67 any = lang.NewList(args[1:]...) + _ = v67 + tmp68 := checkDerefVar(glojure_DOT_core_apply) + tmp69 := checkDerefVar(glojure_DOT_core_cons) + tmp70 := lang.Apply(tmp69, []any{v66, v67}) + tmp71 := lang.Apply(tmp68, []any{closed26, tmp70}) + return tmp71 + } + }) + tmp58.AddMethod(tmp64, tmp65) + tmp66 := reflect.TypeOf("") + var tmp67 lang.FnFunc + tmp67 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v68 := args[0] + _ = v68 + var v69 any = lang.NewList(args[1:]...) + _ = v69 + tmp70 := checkDerefVar(glojure_DOT_core_apply) + tmp71 := checkDerefVar(glojure_DOT_core_cons) + tmp72 := lang.Apply(tmp71, []any{v68, v69}) + tmp73 := lang.Apply(tmp70, []any{closed27, tmp72}) + return tmp73 + } + }) + tmp58.AddMethod(tmp66, tmp67) + tmp31 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("make-reader"), tmp32, lang.NewKeyword("make-writer"), tmp40, lang.NewKeyword("make-input-stream"), tmp48, lang.NewKeyword("make-output-stream"), tmp58), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("make-reader"), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("opts")), "Creates an io.Reader. See also IOFactory docs."), lang.NewList(lang.NewSymbol("make-writer"), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("opts")), "Creates an io.Reader. See also IOFactory docs."), lang.NewList(lang.NewSymbol("make-input-stream"), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("opts")), "Creates a BufferedInputStream. See also IOFactory docs."), lang.NewList(lang.NewSymbol("make-output-stream"), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("opts")), "Creates a BufferedOutputStream. See also IOFactory docs.")))) + tmp2 := lang.NewAtom(lang.NewMap(lang.NewSymbol("CollReduce"), tmp3, lang.NewSymbol("InternalReduce"), tmp13, lang.NewSymbol("IKVReduce"), tmp21, lang.NewSymbol("Datafiable"), tmp24, lang.NewSymbol("Navigable"), tmp28, lang.NewSymbol("IOFactory"), tmp31)) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // .. + { + tmp0 := lang.NewSymbol("..").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("form")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("form"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "form => fieldName-symbol or (instanceMethodName-symbol args*)\n\n Expands into a member access (.) of the first member on the first\n argument, followed by the next member on the result, etc. For\n instance:\n\n (.. System (getProperties) (get \"os.name\"))\n\n expands to:\n\n (. (. System (getProperties)) (get \"os.name\"))\n\n but is easier to write, read, and understand.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1657), lang.NewKeyword("end-line"), int(1657))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 4: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_seq) + tmp8 := checkDerefVar(glojure_DOT_core_concat) + tmp9 := checkDerefVar(glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol(".")}) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{v5}) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{v6}) + tmp15 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp14}) + tmp16 := lang.Apply(tmp7, []any{tmp15}) + return tmp16 + default: + if len(args) < 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + var v7 any = lang.NewList(args[4:]...) + _ = v7 + tmp8 := checkDerefVar(glojure_DOT_core_seq) + tmp9 := checkDerefVar(glojure_DOT_core_concat) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol("..")}) + tmp12 := checkDerefVar(glojure_DOT_core_list) + tmp13 := checkDerefVar(glojure_DOT_core_seq) + tmp14 := checkDerefVar(glojure_DOT_core_concat) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v5}) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v6}) + tmp21 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp12, []any{tmp22}) + tmp24 := lang.Apply(tmp9, []any{tmp11, tmp23, v7}) + tmp25 := lang.Apply(tmp8, []any{tmp24}) + return tmp25 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // / + { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed28 + } else { + tmp4 = closed28 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_seq) + tmp8 := checkDerefVar(glojure_DOT_core_concat) + tmp9 := checkDerefVar(glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol(".")}) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := checkDerefVar(glojure_DOT_core_seq) + tmp15 := checkDerefVar(glojure_DOT_core_concat) + tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed28 + } else { + tmp5 = closed28 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(glojure_DOT_core_seq) + tmp9 := checkDerefVar(glojure_DOT_core_concat) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol(".")}) + tmp12 := checkDerefVar(glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp14 := checkDerefVar(glojure_DOT_core_list) + tmp15 := checkDerefVar(glojure_DOT_core_seq) + tmp16 := checkDerefVar(glojure_DOT_core_concat) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed28 + } else { + tmp6 = closed28 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(glojure_DOT_core_seq) + tmp14 := checkDerefVar(glojure_DOT_core_concat) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := checkDerefVar(glojure_DOT_core_seq) + tmp21 := checkDerefVar(glojure_DOT_core_concat) + tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(glojure_DOT_core_seq) + tmp14 := checkDerefVar(glojure_DOT_core_concat) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := checkDerefVar(glojure_DOT_core_seq) + tmp21 := checkDerefVar(glojure_DOT_core_concat) + tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp0 := lang.NewSymbol("/").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "If no denominators are supplied, returns 1/numerator,\n else returns numerator divided by all of the denominators.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), tmp2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1013), lang.NewKeyword("end-line"), int(1013))).(*lang.Symbol) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v5 := args[0] + _ = v5 + tmp6 := checkDerefVar(glojure_DOT_core__SLASH_) + tmp7 := lang.Apply(tmp6, []any{int64(1), v5}) + return tmp7 + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + tmp7, _ := lang.FieldOrMethod(lang.Numbers, "Divide") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Divide is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v5, v6}) + return tmp8 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + var v7 any = lang.NewList(args[2:]...) + _ = v7 + tmp8 := checkDerefVar(glojure_DOT_core_reduce1) + tmp9 := checkDerefVar(glojure_DOT_core__SLASH_) + tmp10 := checkDerefVar(glojure_DOT_core__SLASH_) + tmp11 := lang.Apply(tmp10, []any{v5, v6}) + tmp12 := lang.Apply(tmp8, []any{tmp9, tmp11, v7}) + return tmp12 + } + }) + tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 := ns.InternWithValue(tmp0, tmp4, true) + if tmp0.Meta() != nil { + tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // < + { + var tmp1 lang.FnFunc + { // function <__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_seq) + tmp6 := checkDerefVar(glojure_DOT_core_concat) + tmp7 := checkDerefVar(glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{lang.NewSymbol(".")}) + tmp9 := checkDerefVar(glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := checkDerefVar(glojure_DOT_core_seq) + tmp13 := checkDerefVar(glojure_DOT_core_concat) + tmp14 := checkDerefVar(glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("glojure.core/Lt")}) + tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("<").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns non-nil if nums are in monotonically increasing order,\n otherwise false.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(893), lang.NewKeyword("end-line"), int(893))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + return true + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Lt") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Lt is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + recur_loop_150: + var tmp7 any + tmp8 := checkDerefVar(glojure_DOT_core__LT_) + tmp9 := lang.Apply(tmp8, []any{v4, v5}) + if lang.IsTruthy(tmp9) { + var tmp10 any + tmp11 := checkDerefVar(glojure_DOT_core_next) + tmp12 := lang.Apply(tmp11, []any{v6}) + if lang.IsTruthy(tmp12) { + var tmp13 any = v5 + tmp15 := checkDerefVar(glojure_DOT_core_first) + tmp16 := lang.Apply(tmp15, []any{v6}) + var tmp14 any = tmp16 + tmp18 := checkDerefVar(glojure_DOT_core_next) + tmp19 := lang.Apply(tmp18, []any{v6}) + var tmp17 any = tmp19 + v4 = tmp13 + v5 = tmp14 + v6 = tmp17 + goto recur_loop_150 + } else { + tmp20 := checkDerefVar(glojure_DOT_core__LT_) + tmp21 := checkDerefVar(glojure_DOT_core_first) + tmp22 := lang.Apply(tmp21, []any{v6}) + tmp23 := lang.Apply(tmp20, []any{v5, tmp22}) + tmp10 = tmp23 + } + tmp7 = tmp10 + } else { + tmp7 = false + } + return tmp7 + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // <= + { + var tmp1 lang.FnFunc + { // function <=__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_seq) + tmp6 := checkDerefVar(glojure_DOT_core_concat) + tmp7 := checkDerefVar(glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{lang.NewSymbol(".")}) + tmp9 := checkDerefVar(glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := checkDerefVar(glojure_DOT_core_seq) + tmp13 := checkDerefVar(glojure_DOT_core_concat) + tmp14 := checkDerefVar(glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("glojure.core/Lte")}) + tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("<=").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns non-nil if nums are in monotonically non-decreasing order,\n otherwise false.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1048), lang.NewKeyword("end-line"), int(1048))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + return true + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Lte") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Lte is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + recur_loop_194: + var tmp7 any + tmp8 := checkDerefVar(glojure_DOT_core__LT__EQ_) + tmp9 := lang.Apply(tmp8, []any{v4, v5}) + if lang.IsTruthy(tmp9) { + var tmp10 any + tmp11 := checkDerefVar(glojure_DOT_core_next) + tmp12 := lang.Apply(tmp11, []any{v6}) + if lang.IsTruthy(tmp12) { + var tmp13 any = v5 + tmp15 := checkDerefVar(glojure_DOT_core_first) + tmp16 := lang.Apply(tmp15, []any{v6}) + var tmp14 any = tmp16 + tmp18 := checkDerefVar(glojure_DOT_core_next) + tmp19 := lang.Apply(tmp18, []any{v6}) + var tmp17 any = tmp19 + v4 = tmp13 + v5 = tmp14 + v6 = tmp17 + goto recur_loop_194 + } else { + tmp20 := checkDerefVar(glojure_DOT_core__LT__EQ_) + tmp21 := checkDerefVar(glojure_DOT_core_first) + tmp22 := lang.Apply(tmp21, []any{v6}) + tmp23 := lang.Apply(tmp20, []any{v5, tmp22}) + tmp10 = tmp23 + } + tmp7 = tmp10 + } else { + tmp7 = false + } + return tmp7 + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // = + { + var tmp1 lang.FnFunc + { // function =__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_seq) + tmp6 := checkDerefVar(glojure_DOT_core_concat) + tmp7 := checkDerefVar(glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{lang.NewSymbol(".")}) + tmp9 := checkDerefVar(glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("glojure.lang.Util")}) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{lang.NewSymbol("glojure.core/equiv")}) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{v3}) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v4}) + tmp17 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp12, tmp14, tmp16}) + tmp18 := lang.Apply(tmp5, []any{tmp17}) + return tmp18 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("=").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Equality. Returns true if x equals y, false if not. Same as\n Java x.equals(y) except it also works for nil, and compares\n numbers and collections in a type-independent manner. Clojure's immutable data\n structures define equals() (and thus =) as a value, not an identity,\n comparison.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(776), lang.NewKeyword("end-line"), int(776))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + return true + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6 := lang.Apply(lang.Equiv, []any{v4, v5}) + return tmp6 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + recur_loop_126: + var tmp7 any + tmp8 := lang.Apply(lang.Equiv, []any{v4, v5}) + if lang.IsTruthy(tmp8) { + var tmp9 any + tmp10 := checkDerefVar(glojure_DOT_core_next) + tmp11 := lang.Apply(tmp10, []any{v6}) + if lang.IsTruthy(tmp11) { + var tmp12 any = v5 + tmp14 := checkDerefVar(glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v6}) + var tmp13 any = tmp15 + tmp17 := checkDerefVar(glojure_DOT_core_next) + tmp18 := lang.Apply(tmp17, []any{v6}) + var tmp16 any = tmp18 + v4 = tmp12 + v5 = tmp13 + v6 = tmp16 + goto recur_loop_126 + } else { + tmp19 := checkDerefVar(glojure_DOT_core_first) + tmp20 := lang.Apply(tmp19, []any{v6}) + tmp21 := lang.Apply(lang.Equiv, []any{v5, tmp20}) + tmp9 = tmp21 + } + tmp7 = tmp9 + } else { + tmp7 = false + } + return tmp7 + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // == + { + var tmp1 lang.FnFunc + { // function ==__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_seq) + tmp6 := checkDerefVar(glojure_DOT_core_concat) + tmp7 := checkDerefVar(glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{lang.NewSymbol(".")}) + tmp9 := checkDerefVar(glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := checkDerefVar(glojure_DOT_core_seq) + tmp13 := checkDerefVar(glojure_DOT_core_concat) + tmp14 := checkDerefVar(glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("glojure.core/Equiv")}) + tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("==").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns non-nil if nums all have the equivalent\n value (type-independent), otherwise false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1093), lang.NewKeyword("end-line"), int(1093))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + return true + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Equiv") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Equiv is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + recur_loop_206: + var tmp7 any + tmp8 := checkDerefVar(glojure_DOT_core__EQ__EQ_) + tmp9 := lang.Apply(tmp8, []any{v4, v5}) + if lang.IsTruthy(tmp9) { + var tmp10 any + tmp11 := checkDerefVar(glojure_DOT_core_next) + tmp12 := lang.Apply(tmp11, []any{v6}) + if lang.IsTruthy(tmp12) { + var tmp13 any = v5 + tmp15 := checkDerefVar(glojure_DOT_core_first) + tmp16 := lang.Apply(tmp15, []any{v6}) + var tmp14 any = tmp16 + tmp18 := checkDerefVar(glojure_DOT_core_next) + tmp19 := lang.Apply(tmp18, []any{v6}) + var tmp17 any = tmp19 + v4 = tmp13 + v5 = tmp14 + v6 = tmp17 + goto recur_loop_206 + } else { + tmp20 := checkDerefVar(glojure_DOT_core__EQ__EQ_) + tmp21 := checkDerefVar(glojure_DOT_core_first) + tmp22 := lang.Apply(tmp21, []any{v6}) + tmp23 := lang.Apply(tmp20, []any{v5, tmp22}) + tmp10 = tmp23 + } + tmp7 = tmp10 + } else { + tmp7 = false + } + return tmp7 + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // > + { + var tmp1 lang.FnFunc + { // function >__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_seq) + tmp6 := checkDerefVar(glojure_DOT_core_concat) + tmp7 := checkDerefVar(glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{lang.NewSymbol(".")}) + tmp9 := checkDerefVar(glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := checkDerefVar(glojure_DOT_core_seq) + tmp13 := checkDerefVar(glojure_DOT_core_concat) + tmp14 := checkDerefVar(glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("glojure.core/Gt")}) + tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol(">").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns non-nil if nums are in monotonically decreasing order,\n otherwise false.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1063), lang.NewKeyword("end-line"), int(1063))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + return true + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + recur_loop_198: + var tmp7 any + tmp8 := checkDerefVar(glojure_DOT_core__GT_) + tmp9 := lang.Apply(tmp8, []any{v4, v5}) + if lang.IsTruthy(tmp9) { + var tmp10 any + tmp11 := checkDerefVar(glojure_DOT_core_next) + tmp12 := lang.Apply(tmp11, []any{v6}) + if lang.IsTruthy(tmp12) { + var tmp13 any = v5 + tmp15 := checkDerefVar(glojure_DOT_core_first) + tmp16 := lang.Apply(tmp15, []any{v6}) + var tmp14 any = tmp16 + tmp18 := checkDerefVar(glojure_DOT_core_next) + tmp19 := lang.Apply(tmp18, []any{v6}) + var tmp17 any = tmp19 + v4 = tmp13 + v5 = tmp14 + v6 = tmp17 + goto recur_loop_198 + } else { + tmp20 := checkDerefVar(glojure_DOT_core__GT_) + tmp21 := checkDerefVar(glojure_DOT_core_first) + tmp22 := lang.Apply(tmp21, []any{v6}) + tmp23 := lang.Apply(tmp20, []any{v5, tmp22}) + tmp10 = tmp23 + } + tmp7 = tmp10 + } else { + tmp7 = false + } + return tmp7 + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // >0? + { + tmp0 := lang.NewSymbol(">0?").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(963), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(963), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(0)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // >1? + { + tmp0 := lang.NewSymbol(">1?").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(962), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(962), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // >= + { + var tmp1 lang.FnFunc + { // function >=__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_seq) + tmp6 := checkDerefVar(glojure_DOT_core_concat) + tmp7 := checkDerefVar(glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{lang.NewSymbol(".")}) + tmp9 := checkDerefVar(glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := checkDerefVar(glojure_DOT_core_seq) + tmp13 := checkDerefVar(glojure_DOT_core_concat) + tmp14 := checkDerefVar(glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("glojure.core/Gte")}) + tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol(">=").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns non-nil if nums are in monotonically non-increasing order,\n otherwise false.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1078), lang.NewKeyword("end-line"), int(1078))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + return true + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Gte") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gte is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + recur_loop_202: + var tmp7 any + tmp8 := checkDerefVar(glojure_DOT_core__GT__EQ_) + tmp9 := lang.Apply(tmp8, []any{v4, v5}) + if lang.IsTruthy(tmp9) { + var tmp10 any + tmp11 := checkDerefVar(glojure_DOT_core_next) + tmp12 := lang.Apply(tmp11, []any{v6}) + if lang.IsTruthy(tmp12) { + var tmp13 any = v5 + tmp15 := checkDerefVar(glojure_DOT_core_first) + tmp16 := lang.Apply(tmp15, []any{v6}) + var tmp14 any = tmp16 + tmp18 := checkDerefVar(glojure_DOT_core_next) + tmp19 := lang.Apply(tmp18, []any{v6}) + var tmp17 any = tmp19 + v4 = tmp13 + v5 = tmp14 + v6 = tmp17 + goto recur_loop_202 + } else { + tmp20 := checkDerefVar(glojure_DOT_core__GT__EQ_) + tmp21 := checkDerefVar(glojure_DOT_core_first) + tmp22 := lang.Apply(tmp21, []any{v6}) + tmp23 := lang.Apply(tmp20, []any{v5, tmp22}) + tmp10 = tmp23 + } + tmp7 = tmp10 + } else { + tmp7 = false + } + return tmp7 + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // NaN? + { + var tmp1 lang.FnFunc + { // function NaN?__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol("math.IsNaN")}) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{v3}) + tmp10 := lang.Apply(tmp5, []any{tmp7, tmp9}) + tmp11 := lang.Apply(tmp4, []any{tmp10}) + return tmp11 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("NaN?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns true if num is NaN, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1)})), lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7968), lang.NewKeyword("end-line"), int(7968))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5 := lang.Apply(math6.IsNaN, []any{v4}) + return tmp5 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // StackTraceElement->vec + { + tmp0 := lang.NewSymbol("StackTraceElement->vec").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"))), lang.NewKeyword("doc"), "Constructs a data representation for a StackTraceElement: [class method file line]", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(436), lang.NewKeyword("end-line"), int(436))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_symbol) + tmp5, ok := lang.FieldOrMethod(v3, "getClassName") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getClassName"))) + } + var tmp6 any + switch reflect.TypeOf(tmp5).Kind() { + case reflect.Func: + tmp6 = lang.Apply(tmp5, nil) + default: + tmp6 = tmp5 + } + tmp7 := lang.Apply(tmp4, []any{tmp6}) + tmp8 := checkDerefVar(glojure_DOT_core_symbol) + tmp9, ok := lang.FieldOrMethod(v3, "getMethodName") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getMethodName"))) + } + var tmp10 any + switch reflect.TypeOf(tmp9).Kind() { + case reflect.Func: + tmp10 = lang.Apply(tmp9, nil) + default: + tmp10 = tmp9 + } + tmp11 := lang.Apply(tmp8, []any{tmp10}) + tmp12, ok := lang.FieldOrMethod(v3, "getFileName") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getFileName"))) + } + var tmp13 any + switch reflect.TypeOf(tmp12).Kind() { + case reflect.Func: + tmp13 = lang.Apply(tmp12, nil) + default: + tmp13 = tmp12 + } + tmp14, ok := lang.FieldOrMethod(v3, "getLineNumber") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getLineNumber"))) + } + var tmp15 any + switch reflect.TypeOf(tmp14).Kind() { + case reflect.Func: + tmp15 = lang.Apply(tmp14, nil) + default: + tmp15 = tmp14 + } + tmp16 := lang.NewVector(tmp7, tmp11, tmp13, tmp15) + tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(440), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(440), lang.NewKeyword("end-column"), int(94)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp18 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // Throwable->map + { + tmp0 := lang.NewSymbol("Throwable->map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"))), lang.NewKeyword("doc"), "Constructs a data representation for a Throwable with keys:\n :cause - root cause message\n :phase - error phase\n :via - cause chain, with cause keys:\n :type - exception class symbol\n :message - exception message\n :data - ex-data\n :at - top stack element\n :trace - root cause stack elements", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(442), lang.NewKeyword("end-line"), int(442))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + { // let + // let binding "base" + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v6 := args[0] + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_merge) + tmp8 := checkDerefVar(glojure_DOT_core_symbol) + tmp9 := checkDerefVar(glojure_DOT_core_class) + tmp10 := lang.Apply(tmp9, []any{v6}) + tmp11, ok := lang.FieldOrMethod(tmp10, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp10, "Name"))) + } + var tmp12 any + switch reflect.TypeOf(tmp11).Kind() { + case reflect.Func: + tmp12 = lang.Apply(tmp11, nil) + default: + tmp12 = tmp11 + } + tmp13 := lang.Apply(tmp8, []any{tmp12}) + tmp14 := lang.NewMap(lang.NewKeyword("type"), tmp13) + tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(455), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(455), lang.NewKeyword("end-column"), int(56)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var tmp17 any + { // let + // let binding "temp__0__auto__" + tmp18, ok := lang.FieldOrMethod(v6, "getLocalizedMessage") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "getLocalizedMessage"))) + } + var tmp19 any + switch reflect.TypeOf(tmp18).Kind() { + case reflect.Func: + tmp19 = lang.Apply(tmp18, nil) + default: + tmp19 = tmp18 + } + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + var tmp22 any + { // let + // let binding "msg" + var v23 any = v20 + _ = v23 + tmp24 := lang.NewMap(lang.NewKeyword("message"), v23) + tmp25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(457), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(457), lang.NewKeyword("end-column"), int(33)) + tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp22 = tmp26 + } // end let + tmp21 = tmp22 + } else { + } + tmp17 = tmp21 + } // end let + var tmp18 any + { // let + // let binding "temp__0__auto__" + tmp19 := checkDerefVar(glojure_DOT_core_ex_data) + tmp20 := lang.Apply(tmp19, []any{v6}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + if lang.IsTruthy(v21) { + var tmp23 any + { // let + // let binding "ed" + var v24 any = v21 + _ = v24 + tmp25 := lang.NewMap(lang.NewKeyword("data"), v24) + tmp26 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(459), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(459), lang.NewKeyword("end-column"), int(29)) + tmp27, err := lang.WithMeta(tmp25, tmp26.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp23 = tmp27 + } // end let + tmp22 = tmp23 + } else { + } + tmp18 = tmp22 + } // end let + var tmp19 any + { // let + // let binding "st" + tmp20, ok := lang.FieldOrMethod(v6, "getStackTrace") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "getStackTrace"))) + } + var tmp21 any + switch reflect.TypeOf(tmp20).Kind() { + case reflect.Func: + tmp21 = lang.Apply(tmp20, nil) + default: + tmp21 = tmp20 + } + var v22 any = tmp21 + _ = v22 + var tmp23 any + tmp24 := checkDerefVar(glojure_DOT_core_pos_QMARK_) + tmp25 := checkDerefVar(glojure_DOT_core_alength) + tmp26 := lang.Apply(tmp25, []any{v22}) + tmp27 := lang.Apply(tmp24, []any{tmp26}) + if lang.IsTruthy(tmp27) { + tmp28 := checkDerefVar(glojure_DOT_core_StackTraceElement__GT_vec) + tmp29 := checkDerefVar(glojure_DOT_core_aget) + tmp30 := lang.Apply(tmp29, []any{v22, int64(0)}) + tmp31 := lang.Apply(tmp28, []any{tmp30}) + tmp32 := lang.NewMap(lang.NewKeyword("at"), tmp31) + tmp33 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(462), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(462), lang.NewKeyword("end-column"), int(63)) + tmp34, err := lang.WithMeta(tmp32, tmp33.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp23 = tmp34 + } else { + } + tmp19 = tmp23 + } // end let + tmp20 := lang.Apply(tmp7, []any{tmp16, tmp17, tmp18, tmp19}) + return tmp20 + }) + tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(454), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(462), lang.NewKeyword("end-column"), int(67)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v8 any = tmp7 + _ = v8 + // let binding "via" + var tmp9 any + { // let + // let binding "via" + tmp10 := lang.NewVector() + tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(463), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(463), lang.NewKeyword("end-column"), int(25)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v13 any = tmp12 + _ = v13 + // let binding "t" + var v14 any = v3 + _ = v14 + for { + var tmp15 any + if lang.IsTruthy(v14) { + tmp17 := checkDerefVar(glojure_DOT_core_conj) + tmp18 := lang.Apply(tmp17, []any{v13, v14}) + var tmp16 any = tmp18 + tmp20, ok := lang.FieldOrMethod(v14, "getCause") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v14, "getCause"))) + } + var tmp21 any + switch reflect.TypeOf(tmp20).Kind() { + case reflect.Func: + tmp21 = lang.Apply(tmp20, nil) + default: + tmp21 = tmp20 + } + var tmp19 any = tmp21 + v13 = tmp16 + v14 = tmp19 + continue + } else { + tmp15 = v13 + } + tmp9 = tmp15 + break + } + } // end let + var v10 any = tmp9 + _ = v10 + // let binding "root" + tmp11 := checkDerefVar(glojure_DOT_core_peek) + tmp12 := lang.Apply(tmp11, []any{v10}) + var v13 any = tmp12 + _ = v13 + tmp14 := checkDerefVar(glojure_DOT_core_merge) + tmp15 := checkDerefVar(glojure_DOT_core_vec) + tmp16 := checkDerefVar(glojure_DOT_core_map) + tmp17 := lang.Apply(tmp16, []any{v8, v10}) + tmp18 := lang.Apply(tmp15, []any{tmp17}) + tmp19 := checkDerefVar(glojure_DOT_core_vec) + tmp20 := checkDerefVar(glojure_DOT_core_map) + tmp21 := checkDerefVar(glojure_DOT_core_StackTraceElement__GT_vec) + var tmp22 any + { // let + // let binding "or__0__auto__" + var v23 any = v13 + _ = v23 + var tmp24 any + if lang.IsTruthy(v23) { + tmp24 = v23 + } else { + tmp24 = v3 + } + tmp22 = tmp24 + } // end let + tmp23, ok := lang.FieldOrMethod(tmp22, "getStackTrace") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp22, "getStackTrace"))) + } + var tmp24 any + switch reflect.TypeOf(tmp23).Kind() { + case reflect.Func: + tmp24 = lang.Apply(tmp23, nil) + default: + tmp24 = tmp23 + } + tmp25 := lang.Apply(tmp20, []any{tmp21, tmp24}) + tmp26 := lang.Apply(tmp19, []any{tmp25}) + tmp27 := lang.NewMap(lang.NewKeyword("via"), tmp18, lang.NewKeyword("trace"), tmp26) + tmp28 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(468), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(470), lang.NewKeyword("end-column"), int(111)) + tmp29, err := lang.WithMeta(tmp27, tmp28.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var tmp30 any + { // let + // let binding "temp__0__auto__" + tmp31, ok := lang.FieldOrMethod(v13, "getLocalizedMessage") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v13, "getLocalizedMessage"))) + } + var tmp32 any + switch reflect.TypeOf(tmp31).Kind() { + case reflect.Func: + tmp32 = lang.Apply(tmp31, nil) + default: + tmp32 = tmp31 + } + var v33 any = tmp32 + _ = v33 + var tmp34 any + if lang.IsTruthy(v33) { + var tmp35 any + { // let + // let binding "root-msg" + var v36 any = v33 + _ = v36 + tmp37 := lang.NewMap(lang.NewKeyword("cause"), v36) + tmp38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(472), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(472), lang.NewKeyword("end-column"), int(25)) + tmp39, err := lang.WithMeta(tmp37, tmp38.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp35 = tmp39 + } // end let + tmp34 = tmp35 + } else { + } + tmp30 = tmp34 + } // end let + var tmp31 any + { // let + // let binding "temp__0__auto__" + tmp32 := checkDerefVar(glojure_DOT_core_ex_data) + tmp33 := lang.Apply(tmp32, []any{v13}) + var v34 any = tmp33 + _ = v34 + var tmp35 any + if lang.IsTruthy(v34) { + var tmp36 any + { // let + // let binding "data" + var v37 any = v34 + _ = v37 + tmp38 := lang.NewMap(lang.NewKeyword("data"), v37) + tmp39 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(474), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(474), lang.NewKeyword("end-column"), int(20)) + tmp40, err := lang.WithMeta(tmp38, tmp39.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp36 = tmp40 + } // end let + tmp35 = tmp36 + } else { + } + tmp31 = tmp35 + } // end let + var tmp32 any + { // let + // let binding "temp__0__auto__" + tmp33 := checkDerefVar(glojure_DOT_core_ex_data) + tmp34 := lang.Apply(tmp33, []any{v3}) + tmp35 := lang.Apply(lang.NewKeyword("glojure.error/phase"), []any{tmp34}) + var v36 any = tmp35 + _ = v36 + var tmp37 any + if lang.IsTruthy(v36) { + var tmp38 any + { // let + // let binding "phase" + var v39 any = v36 + _ = v39 + tmp40 := lang.NewMap(lang.NewKeyword("phase"), v39) + tmp41 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(476), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(476), lang.NewKeyword("end-column"), int(22)) + tmp42, err := lang.WithMeta(tmp40, tmp41.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp38 = tmp42 + } // end let + tmp37 = tmp38 + } else { + } + tmp32 = tmp37 + } // end let + tmp33 := lang.Apply(tmp14, []any{tmp29, tmp30, tmp31, tmp32}) + tmp4 = tmp33 + } // end let + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // abs + { + var tmp1 lang.FnFunc + { // function abs__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Abs")}) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{v3}) + tmp10 := lang.Apply(tmp5, []any{tmp7, tmp9}) + tmp11 := lang.Apply(tmp4, []any{tmp10}) + return tmp11 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("abs").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the absolute value of a.\n If a is Long/MIN_VALUE => Long/MIN_VALUE\n If a is a double and zero => +0.0\n If a is a double and ##Inf or ##-Inf => ##Inf\n If a is a double and ##NaN => ##NaN", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1)})), lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1128), lang.NewKeyword("end-line"), int(1128))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5 := lang.Apply(lang.Abs, []any{v4}) + return tmp5 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // accessor + { + tmp0 := lang.NewSymbol("accessor").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("key"))), lang.NewKeyword("doc"), "Returns a fn that, given an instance of a structmap with the basis,\n returns the value at the key. The key must be in the basis. The\n returned function should be (slightly) more efficient than using\n get, but such use of accessors should be limited to known\n performance-critical areas.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4070), lang.NewKeyword("end-line"), int(4070))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(nil, "getAccessor") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getAccessor is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // aclone + { + var tmp1 lang.FnFunc + { // function aclone__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := checkDerefVar(glojure_DOT_core_seq) + tmp12 := checkDerefVar(glojure_DOT_core_concat) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/Aclone")}) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("aclone").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns a clone of the Java array. Works on arrays of known\n types.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3904), lang.NewKeyword("end-line"), int(3904))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5, _ := lang.FieldOrMethod(runtime7.RT, "Aclone") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Aclone is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // add-classpath + { + tmp0 := lang.NewSymbol("add-classpath").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("url"))), lang.NewKeyword("doc"), "DEPRECATED \n\n Adds the url (String or URL object) to the classpath per\n URLClassLoader.addURL", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("deprecated"), "1.1", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5176), lang.NewKeyword("end-line"), int(5176))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_println) + tmp5 := lang.Apply(tmp4, []any{"WARNING: add-classpath is deprecated"}) + _ = tmp5 + tmp6 := lang.Apply(nil, []any{v3}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // add-doc-and-meta + { + tmp0 := lang.NewSymbol("add-doc-and-meta").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("docstring"), lang.NewSymbol("meta"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(26), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6400), lang.NewKeyword("end-line"), int(6400), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 5 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := args[4] + _ = v7 + tmp8 := checkDerefVar(glojure_DOT_core_seq) + tmp9 := checkDerefVar(glojure_DOT_core_concat) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol("glojure.core/alter-meta!")}) + tmp12 := checkDerefVar(glojure_DOT_core_list) + tmp13 := checkDerefVar(glojure_DOT_core_seq) + tmp14 := checkDerefVar(glojure_DOT_core_concat) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("var")}) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v5}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{lang.NewSymbol("glojure.core/merge")}) + tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp25 := checkDerefVar(glojure_DOT_core_seq) + tmp26 := checkDerefVar(glojure_DOT_core_concat) + tmp27 := checkDerefVar(glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{lang.NewSymbol("glojure.core/assoc")}) + tmp29 := checkDerefVar(glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{v7}) + tmp31 := checkDerefVar(glojure_DOT_core_list) + tmp32 := lang.Apply(tmp31, []any{lang.NewKeyword("doc")}) + tmp33 := checkDerefVar(glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{v6}) + tmp35 := lang.Apply(tmp26, []any{tmp28, tmp30, tmp32, tmp34}) + tmp36 := lang.Apply(tmp25, []any{tmp35}) + tmp37 := lang.Apply(tmp24, []any{tmp36}) + tmp38 := lang.Apply(tmp9, []any{tmp11, tmp21, tmp23, tmp37}) + tmp39 := lang.Apply(tmp8, []any{tmp38}) + return tmp39 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // add-watch + { + tmp0 := lang.NewSymbol("add-watch").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("reference"), lang.NewSymbol("key"), lang.NewSymbol("fn"))), lang.NewKeyword("doc"), "Adds a watch function to an agent/atom/var/ref reference. The watch\n fn must be a fn of 4 args: a key, the reference, its old-state, its\n new-state. Whenever the reference's state might have been changed,\n any registered watches will have their functions called. The watch fn\n will be called synchronously, on the agent's thread if an agent,\n before any pending sends if agent or ref. Note that an atom's or\n ref's state may have changed again prior to the fn call, so use\n old/new-state rather than derefing the reference. Note also that watch\n fns may be called from multiple threads simultaneously. Var watchers\n are triggered only by root binding changes, not thread-local\n set!s. Keys must be unique per reference, and can be used to remove\n the watch with remove-watch, but are otherwise considered opaque by\n the watch mechanism.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2142), lang.NewKeyword("end-line"), int(2142))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6, _ := lang.FieldOrMethod(v3, "addWatch") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("addWatch is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // agent + { + tmp0 := lang.NewSymbol("agent").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("state"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Creates and returns an agent with an initial value of state and\n zero or more options (in any order):\n\n :meta metadata-map\n\n :validator validate-fn\n\n :error-handler handler-fn\n\n :error-mode mode-keyword\n\n If metadata-map is supplied, it will become the metadata on the\n agent. validate-fn must be nil or a side-effect-free fn of one\n argument, which will be passed the intended new state on any state\n change. If the new state is unacceptable, the validate-fn should\n return false or throw an exception. handler-fn is called if an\n action throws an exception or if validate-fn rejects a new state --\n see set-error-handler! for details. The mode-keyword may be either\n :continue (the default if an error-handler is given) or :fail (the\n default if no error-handler is given) -- see set-error-mode! for\n details.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2052), lang.NewKeyword("end-line"), int(2052))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any = lang.NewList(args[1:]...) + _ = v4 + var tmp5 any + { // let + // let binding "a" + var v6 any = "unimplemented: new with non-constant class type" + _ = v6 + // let binding "opts" + tmp7 := checkDerefVar(glojure_DOT_core_apply) + tmp8 := checkDerefVar(glojure_DOT_core_hash_map) + tmp9 := lang.Apply(tmp7, []any{tmp8, v4}) + var v10 any = tmp9 + _ = v10 + tmp11 := checkDerefVar(glojure_DOT_core_setup_reference) + tmp12 := lang.Apply(tmp11, []any{v6, v4}) + _ = tmp12 + var tmp13 any + tmp14 := lang.Apply(lang.NewKeyword("error-handler"), []any{v10}) + if lang.IsTruthy(tmp14) { + tmp15 := lang.Apply(lang.NewKeyword("error-handler"), []any{v10}) + tmp16, _ := lang.FieldOrMethod(v6, "setErrorHandler") + if reflect.TypeOf(tmp16).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorHandler is not a function"))) + } + tmp17 := lang.Apply(tmp16, []any{tmp15}) + tmp13 = tmp17 + } else { + } + _ = tmp13 + var tmp18 any + { // let + // let binding "or__0__auto__" + tmp19 := lang.Apply(lang.NewKeyword("error-mode"), []any{v10}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + tmp21 = v20 + } else { + var tmp22 any + tmp23 := lang.Apply(lang.NewKeyword("error-handler"), []any{v10}) + if lang.IsTruthy(tmp23) { + tmp22 = lang.NewKeyword("continue") + } else { + tmp22 = lang.NewKeyword("fail") + } + tmp21 = tmp22 + } + tmp18 = tmp21 + } // end let + tmp19, _ := lang.FieldOrMethod(v6, "setErrorMode") + if reflect.TypeOf(tmp19).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorMode is not a function"))) + } + tmp20 := lang.Apply(tmp19, []any{tmp18}) + _ = tmp20 + tmp5 = v6 + } // end let + return tmp5 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // agent-error + { + tmp0 := lang.NewSymbol("agent-error").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("doc"), "Returns the exception thrown during an asynchronous action of the\n agent if the agent is failed. Returns nil if the agent is not\n failed.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2167), lang.NewKeyword("end-line"), int(2167))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4, ok := lang.FieldOrMethod(v3, "getError") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getError"))) + } + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { + case reflect.Func: + tmp5 = lang.Apply(tmp4, nil) + default: + tmp5 = tmp4 + } + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // agent-errors + { + tmp0 := lang.NewSymbol("agent-errors").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("doc"), "DEPRECATED: Use 'agent-error' instead.\n Returns a sequence of the exceptions thrown during asynchronous\n actions of the agent.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("deprecated"), "1.2", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2234), lang.NewKeyword("end-line"), int(2234))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + { // let + // let binding "temp__0__auto__" + tmp5 := checkDerefVar(glojure_DOT_core_agent_error) + tmp6 := lang.Apply(tmp5, []any{v3}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + if lang.IsTruthy(v7) { + var tmp9 any + { // let + // let binding "e" + var v10 any = v7 + _ = v10 + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{v10}) + tmp9 = tmp12 + } // end let + tmp8 = tmp9 + } else { + } + tmp4 = tmp8 + } // end let + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // aget + { + var tmp1 lang.FnFunc + { // function aget__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_seq) + tmp6 := checkDerefVar(glojure_DOT_core_concat) + tmp7 := checkDerefVar(glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{lang.NewSymbol(".")}) + tmp9 := checkDerefVar(glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := checkDerefVar(glojure_DOT_core_seq) + tmp13 := checkDerefVar(glojure_DOT_core_concat) + tmp14 := checkDerefVar(glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("glojure.core/Aget")}) + tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp19 := checkDerefVar(glojure_DOT_core_seq) + tmp20 := checkDerefVar(glojure_DOT_core_concat) + tmp21 := checkDerefVar(glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("glojure.core/int")}) + tmp23 := checkDerefVar(glojure_DOT_core_list) + tmp24 := lang.Apply(tmp23, []any{v4}) + tmp25 := lang.Apply(tmp20, []any{tmp22, tmp24}) + tmp26 := lang.Apply(tmp19, []any{tmp25}) + tmp27 := lang.Apply(tmp18, []any{tmp26}) + tmp28 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp27}) + tmp29 := lang.Apply(tmp12, []any{tmp28}) + tmp30 := lang.Apply(tmp11, []any{tmp29}) + tmp31 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp30}) + tmp32 := lang.Apply(tmp5, []any{tmp31}) + return tmp32 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("aget").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("&"), lang.NewSymbol("idxs"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the value at the index/indices. Works on Java arrays of all\n types.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3911), lang.NewKeyword("end-line"), int(3911))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6 := lang.Apply(lang.Get, []any{v4, v5}) + return tmp6 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_apply) + tmp8 := checkDerefVar(glojure_DOT_core_aget) + tmp9 := checkDerefVar(glojure_DOT_core_aget) + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) + return tmp11 + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // alength + { + var tmp1 lang.FnFunc + { // function alength__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := checkDerefVar(glojure_DOT_core_seq) + tmp12 := checkDerefVar(glojure_DOT_core_concat) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/Alength")}) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("alength").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the length of the Java array. Works on arrays of all\n types.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3897), lang.NewKeyword("end-line"), int(3897))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5, _ := lang.FieldOrMethod(runtime7.RT, "Alength") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Alength is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // alias + { + tmp0 := lang.NewSymbol("alias").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("alias"), lang.NewSymbol("namespace-sym"))), lang.NewKeyword("doc"), "Add an alias in the current namespace to another\n namespace. Arguments are two symbols: the alias to be used, and\n the symbolic name of the target namespace. Use :as in the ns macro in preference\n to calling this directly.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4263), lang.NewKeyword("end-line"), int(4263))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) + tmp6 := checkDerefVar(glojure_DOT_core_the_ns) + tmp7 := lang.Apply(tmp6, []any{v4}) + tmp8, _ := lang.FieldOrMethod(tmp5, "AddAlias") + if reflect.TypeOf(tmp8).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("AddAlias is not a function"))) + } + tmp9 := lang.Apply(tmp8, []any{v3, tmp7}) + return tmp9 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // all-ns + { + tmp0 := lang.NewSymbol("all-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Returns a sequence of all namespaces.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4146), lang.NewKeyword("end-line"), int(4146))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + tmp3 := lang.Apply(nil, nil) + return tmp3 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // alter + { + tmp0 := lang.NewSymbol("alter").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("fun"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Must be called in a transaction. Sets the in-transaction-value of\n ref to:\n\n (apply fun in-transaction-value-of-ref args)\n\n and returns the in-transaction-value of ref.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2435), lang.NewKeyword("end-line"), int(2435))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6, _ := lang.FieldOrMethod(v3, "alter") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("alter is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // alter-meta! + { + tmp0 := lang.NewSymbol("alter-meta!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("iref"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Atomically sets the metadata for a namespace/var/ref/agent/atom to be:\n\n (apply f its-current-meta args)\n\n f must be free of side-effects", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2398), lang.NewKeyword("end-line"), int(2398))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6, _ := lang.FieldOrMethod(v3, "AlterMeta") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("AlterMeta is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // alter-var-root + { + tmp0 := lang.NewSymbol("alter-var-root").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("v"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Atomically alters the root binding of var v by applying f to its\n current value plus any args", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5484), lang.NewKeyword("end-line"), int(5484))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6, _ := lang.FieldOrMethod(v3, "alterRoot") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("alterRoot is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // amap + { + tmp0 := lang.NewSymbol("amap").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("idx"), lang.NewSymbol("ret"), lang.NewSymbol("expr"))), lang.NewKeyword("doc"), "Maps an expression across an array a, using an index named idx, and\n return value named ret, initialized to a clone of a, then setting \n each element of ret to the evaluation of expr, returning the new \n array ret.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5273), lang.NewKeyword("end-line"), int(5273))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 6 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := args[4] + _ = v7 + v8 := args[5] + _ = v8 + tmp9 := checkDerefVar(glojure_DOT_core_seq) + tmp10 := checkDerefVar(glojure_DOT_core_concat) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{lang.NewSymbol("glojure.core/let")}) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := checkDerefVar(glojure_DOT_core_apply) + tmp15 := checkDerefVar(glojure_DOT_core_vector) + tmp16 := checkDerefVar(glojure_DOT_core_seq) + tmp17 := checkDerefVar(glojure_DOT_core_concat) + tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{lang.NewSymbol("a__0__auto__")}) + tmp20 := checkDerefVar(glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{v5}) + tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{lang.NewSymbol("l__1__auto__")}) + tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp25 := checkDerefVar(glojure_DOT_core_seq) + tmp26 := checkDerefVar(glojure_DOT_core_concat) + tmp27 := checkDerefVar(glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{lang.NewSymbol("glojure.core/alength")}) + tmp29 := checkDerefVar(glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("a__0__auto__")}) + tmp31 := lang.Apply(tmp26, []any{tmp28, tmp30}) + tmp32 := lang.Apply(tmp25, []any{tmp31}) + tmp33 := lang.Apply(tmp24, []any{tmp32}) + tmp34 := checkDerefVar(glojure_DOT_core_list) + tmp35 := lang.Apply(tmp34, []any{v7}) + tmp36 := checkDerefVar(glojure_DOT_core_list) + tmp37 := checkDerefVar(glojure_DOT_core_seq) + tmp38 := checkDerefVar(glojure_DOT_core_concat) + tmp39 := checkDerefVar(glojure_DOT_core_list) + tmp40 := lang.Apply(tmp39, []any{lang.NewSymbol("glojure.core/aclone")}) + tmp41 := checkDerefVar(glojure_DOT_core_list) + tmp42 := lang.Apply(tmp41, []any{lang.NewSymbol("a__0__auto__")}) + tmp43 := lang.Apply(tmp38, []any{tmp40, tmp42}) + tmp44 := lang.Apply(tmp37, []any{tmp43}) + tmp45 := lang.Apply(tmp36, []any{tmp44}) + tmp46 := lang.Apply(tmp17, []any{tmp19, tmp21, tmp23, tmp33, tmp35, tmp45}) + tmp47 := lang.Apply(tmp16, []any{tmp46}) + tmp48 := lang.Apply(tmp14, []any{tmp15, tmp47}) + tmp49 := lang.Apply(tmp13, []any{tmp48}) + tmp50 := checkDerefVar(glojure_DOT_core_list) + tmp51 := checkDerefVar(glojure_DOT_core_seq) + tmp52 := checkDerefVar(glojure_DOT_core_concat) + tmp53 := checkDerefVar(glojure_DOT_core_list) + tmp54 := lang.Apply(tmp53, []any{lang.NewSymbol("glojure.core/loop")}) + tmp55 := checkDerefVar(glojure_DOT_core_list) + tmp56 := checkDerefVar(glojure_DOT_core_apply) + tmp57 := checkDerefVar(glojure_DOT_core_vector) + tmp58 := checkDerefVar(glojure_DOT_core_seq) + tmp59 := checkDerefVar(glojure_DOT_core_concat) + tmp60 := checkDerefVar(glojure_DOT_core_list) + tmp61 := lang.Apply(tmp60, []any{v6}) + tmp62 := checkDerefVar(glojure_DOT_core_list) + tmp63 := lang.Apply(tmp62, []any{int64(0)}) + tmp64 := lang.Apply(tmp59, []any{tmp61, tmp63}) + tmp65 := lang.Apply(tmp58, []any{tmp64}) + tmp66 := lang.Apply(tmp56, []any{tmp57, tmp65}) + tmp67 := lang.Apply(tmp55, []any{tmp66}) + tmp68 := checkDerefVar(glojure_DOT_core_list) + tmp69 := checkDerefVar(glojure_DOT_core_seq) + tmp70 := checkDerefVar(glojure_DOT_core_concat) + tmp71 := checkDerefVar(glojure_DOT_core_list) + tmp72 := lang.Apply(tmp71, []any{lang.NewSymbol("if")}) + tmp73 := checkDerefVar(glojure_DOT_core_list) + tmp74 := checkDerefVar(glojure_DOT_core_seq) + tmp75 := checkDerefVar(glojure_DOT_core_concat) + tmp76 := checkDerefVar(glojure_DOT_core_list) + tmp77 := lang.Apply(tmp76, []any{lang.NewSymbol("glojure.core/<")}) + tmp78 := checkDerefVar(glojure_DOT_core_list) + tmp79 := lang.Apply(tmp78, []any{v6}) + tmp80 := checkDerefVar(glojure_DOT_core_list) + tmp81 := lang.Apply(tmp80, []any{lang.NewSymbol("l__1__auto__")}) + tmp82 := lang.Apply(tmp75, []any{tmp77, tmp79, tmp81}) + tmp83 := lang.Apply(tmp74, []any{tmp82}) + tmp84 := lang.Apply(tmp73, []any{tmp83}) + tmp85 := checkDerefVar(glojure_DOT_core_list) + tmp86 := checkDerefVar(glojure_DOT_core_seq) + tmp87 := checkDerefVar(glojure_DOT_core_concat) + tmp88 := checkDerefVar(glojure_DOT_core_list) + tmp89 := lang.Apply(tmp88, []any{lang.NewSymbol("do")}) + tmp90 := checkDerefVar(glojure_DOT_core_list) + tmp91 := checkDerefVar(glojure_DOT_core_seq) + tmp92 := checkDerefVar(glojure_DOT_core_concat) + tmp93 := checkDerefVar(glojure_DOT_core_list) + tmp94 := lang.Apply(tmp93, []any{lang.NewSymbol("glojure.core/aset")}) + tmp95 := checkDerefVar(glojure_DOT_core_list) + tmp96 := lang.Apply(tmp95, []any{v7}) + tmp97 := checkDerefVar(glojure_DOT_core_list) + tmp98 := lang.Apply(tmp97, []any{v6}) + tmp99 := checkDerefVar(glojure_DOT_core_list) + tmp100 := lang.Apply(tmp99, []any{v8}) + tmp101 := lang.Apply(tmp92, []any{tmp94, tmp96, tmp98, tmp100}) + tmp102 := lang.Apply(tmp91, []any{tmp101}) + tmp103 := lang.Apply(tmp90, []any{tmp102}) + tmp104 := checkDerefVar(glojure_DOT_core_list) + tmp105 := checkDerefVar(glojure_DOT_core_seq) + tmp106 := checkDerefVar(glojure_DOT_core_concat) + tmp107 := checkDerefVar(glojure_DOT_core_list) + tmp108 := lang.Apply(tmp107, []any{lang.NewSymbol("recur")}) + tmp109 := checkDerefVar(glojure_DOT_core_list) + tmp110 := checkDerefVar(glojure_DOT_core_seq) + tmp111 := checkDerefVar(glojure_DOT_core_concat) + tmp112 := checkDerefVar(glojure_DOT_core_list) + tmp113 := lang.Apply(tmp112, []any{lang.NewSymbol("glojure.core/unchecked-inc")}) + tmp114 := checkDerefVar(glojure_DOT_core_list) + tmp115 := lang.Apply(tmp114, []any{v6}) + tmp116 := lang.Apply(tmp111, []any{tmp113, tmp115}) + tmp117 := lang.Apply(tmp110, []any{tmp116}) + tmp118 := lang.Apply(tmp109, []any{tmp117}) + tmp119 := lang.Apply(tmp106, []any{tmp108, tmp118}) + tmp120 := lang.Apply(tmp105, []any{tmp119}) + tmp121 := lang.Apply(tmp104, []any{tmp120}) + tmp122 := lang.Apply(tmp87, []any{tmp89, tmp103, tmp121}) + tmp123 := lang.Apply(tmp86, []any{tmp122}) + tmp124 := lang.Apply(tmp85, []any{tmp123}) + tmp125 := checkDerefVar(glojure_DOT_core_list) + tmp126 := lang.Apply(tmp125, []any{v7}) + tmp127 := lang.Apply(tmp70, []any{tmp72, tmp84, tmp124, tmp126}) + tmp128 := lang.Apply(tmp69, []any{tmp127}) + tmp129 := lang.Apply(tmp68, []any{tmp128}) + tmp130 := lang.Apply(tmp52, []any{tmp54, tmp67, tmp129}) + tmp131 := lang.Apply(tmp51, []any{tmp130}) + tmp132 := lang.Apply(tmp50, []any{tmp131}) + tmp133 := lang.Apply(tmp10, []any{tmp12, tmp49, tmp132}) + tmp134 := lang.Apply(tmp9, []any{tmp133}) + return tmp134 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ancestors + { + tmp0 := lang.NewSymbol("ancestors").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"))), lang.NewKeyword("doc"), "Returns the immediate and indirect parents of tag, either via a Java type\n inheritance relationship or a relationship established via derive. h\n must be a hierarchy obtained from make-hierarchy, if not supplied\n defaults to the global hierarchy", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5577), lang.NewKeyword("end-line"), int(5577))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_ancestors) + tmp5 := checkDerefVar(glojure_DOT_core_global_hierarchy) + tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) + return tmp6 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_not_empty) + var tmp6 any + { // let + // let binding "ta" + tmp7 := checkDerefVar(glojure_DOT_core_get) + tmp8 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) + tmp9 := lang.Apply(tmp7, []any{tmp8, v4}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + tmp12 := checkDerefVar(glojure_DOT_core_class_QMARK_) + tmp13 := lang.Apply(tmp12, []any{v4}) + if lang.IsTruthy(tmp13) { + var tmp14 any + { // let + // let binding "superclasses" + tmp15 := checkDerefVar(glojure_DOT_core_set) + tmp16 := checkDerefVar(glojure_DOT_core_supers) + tmp17 := lang.Apply(tmp16, []any{v4}) + tmp18 := lang.Apply(tmp15, []any{tmp17}) + var v19 any = tmp18 + _ = v19 + tmp20 := checkDerefVar(glojure_DOT_core_reduce1) + tmp21 := checkDerefVar(glojure_DOT_core_into1) + tmp22 := checkDerefVar(glojure_DOT_core_cons) + tmp23 := checkDerefVar(glojure_DOT_core_map) + var tmp24 lang.FnFunc + tmp24 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v25 := args[0] + _ = v25 + tmp26 := checkDerefVar(glojure_DOT_core_get) + tmp27 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) + tmp28 := lang.Apply(tmp26, []any{tmp27, v25}) + return tmp28 + }) + tmp25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5590), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(5590), lang.NewKeyword("end-column"), int(54)) + tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp27 := lang.Apply(tmp23, []any{tmp26, v19}) + tmp28 := lang.Apply(tmp22, []any{v10, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp21, v19, tmp28}) + tmp14 = tmp29 + } // end let + tmp11 = tmp14 + } else { + tmp11 = v10 + } + tmp6 = tmp11 + } // end let + tmp7 := lang.Apply(tmp5, []any{tmp6}) + return tmp7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // and + { + tmp0 := lang.NewSymbol("and").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("next"))), lang.NewKeyword("doc"), "Evaluates exprs one at a time, from left to right. If a form\n returns logical false (nil or false), and returns that value and\n doesn't evaluate any of the other expressions, otherwise it returns\n the value of the last expr. (and) returns true.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(835), lang.NewKeyword("end-line"), int(835))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + return true + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + return v5 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_seq) + tmp8 := checkDerefVar(glojure_DOT_core_concat) + tmp9 := checkDerefVar(glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("glojure.core/let")}) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := checkDerefVar(glojure_DOT_core_apply) + tmp13 := checkDerefVar(glojure_DOT_core_vector) + tmp14 := checkDerefVar(glojure_DOT_core_seq) + tmp15 := checkDerefVar(glojure_DOT_core_concat) + tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("and__0__auto__")}) + tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v5}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp12, []any{tmp13, tmp21}) + tmp23 := lang.Apply(tmp11, []any{tmp22}) + tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp25 := checkDerefVar(glojure_DOT_core_seq) + tmp26 := checkDerefVar(glojure_DOT_core_concat) + tmp27 := checkDerefVar(glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{lang.NewSymbol("if")}) + tmp29 := checkDerefVar(glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("and__0__auto__")}) + tmp31 := checkDerefVar(glojure_DOT_core_list) + tmp32 := checkDerefVar(glojure_DOT_core_seq) + tmp33 := checkDerefVar(glojure_DOT_core_concat) + tmp34 := checkDerefVar(glojure_DOT_core_list) + tmp35 := lang.Apply(tmp34, []any{lang.NewSymbol("glojure.core/and")}) + tmp36 := lang.Apply(tmp33, []any{tmp35, v6}) + tmp37 := lang.Apply(tmp32, []any{tmp36}) + tmp38 := lang.Apply(tmp31, []any{tmp37}) + tmp39 := checkDerefVar(glojure_DOT_core_list) + tmp40 := lang.Apply(tmp39, []any{lang.NewSymbol("and__0__auto__")}) + tmp41 := lang.Apply(tmp26, []any{tmp28, tmp30, tmp38, tmp40}) + tmp42 := lang.Apply(tmp25, []any{tmp41}) + tmp43 := lang.Apply(tmp24, []any{tmp42}) + tmp44 := lang.Apply(tmp8, []any{tmp10, tmp23, tmp43}) + tmp45 := lang.Apply(tmp7, []any{tmp44}) + return tmp45 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // any? + { + tmp1 := reflect.TypeOf(false) + tmp0 := lang.NewSymbol("any?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true given any argument.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(537), lang.NewKeyword("end-line"), int(537))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + return true + }) + tmp4 := reflect.TypeOf(false) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // apply + { + tmp0 := lang.NewSymbol("apply").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("z"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Applies fn f to the argument list formed by prepending intervening arguments to args.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(653), lang.NewKeyword("end-line"), int(653))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_seq) + tmp6 := lang.Apply(tmp5, []any{v4}) + tmp7 := lang.Apply(lang.Apply, []any{v3, tmp6}) + return tmp7 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6 := checkDerefVar(glojure_DOT_core_list_STAR_) + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + tmp8 := lang.Apply(lang.Apply, []any{v3, tmp7}) + return tmp8 + case 4: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_list_STAR_) + tmp8 := lang.Apply(tmp7, []any{v4, v5, v6}) + tmp9 := lang.Apply(lang.Apply, []any{v3, tmp8}) + return tmp9 + case 5: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := args[4] + _ = v7 + tmp8 := checkDerefVar(glojure_DOT_core_list_STAR_) + tmp9 := lang.Apply(tmp8, []any{v4, v5, v6, v7}) + tmp10 := lang.Apply(lang.Apply, []any{v3, tmp9}) + return tmp10 + default: + if len(args) < 5 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := args[4] + _ = v7 + var v8 any = lang.NewList(args[5:]...) + _ = v8 + tmp9 := checkDerefVar(glojure_DOT_core_cons) + tmp10 := checkDerefVar(glojure_DOT_core_cons) + tmp11 := checkDerefVar(glojure_DOT_core_cons) + tmp12 := checkDerefVar(glojure_DOT_core_cons) + tmp13 := checkDerefVar(glojure_DOT_core_spread) + tmp14 := lang.Apply(tmp13, []any{v8}) + tmp15 := lang.Apply(tmp12, []any{v7, tmp14}) + tmp16 := lang.Apply(tmp11, []any{v6, tmp15}) + tmp17 := lang.Apply(tmp10, []any{v5, tmp16}) + tmp18 := lang.Apply(tmp9, []any{v4, tmp17}) + tmp19 := lang.Apply(lang.Apply, []any{v3, tmp18}) + return tmp19 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // areduce + { + tmp0 := lang.NewSymbol("areduce").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("idx"), lang.NewSymbol("ret"), lang.NewSymbol("init"), lang.NewSymbol("expr"))), lang.NewKeyword("doc"), "Reduces an expression across an array a, using an index named idx,\n and return value named ret, initialized to init, setting ret to the \n evaluation of expr at each step, returning ret.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5289), lang.NewKeyword("end-line"), int(5289))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 7 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := args[4] + _ = v7 + v8 := args[5] + _ = v8 + v9 := args[6] + _ = v9 + tmp10 := checkDerefVar(glojure_DOT_core_seq) + tmp11 := checkDerefVar(glojure_DOT_core_concat) + tmp12 := checkDerefVar(glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol("glojure.core/let")}) + tmp14 := checkDerefVar(glojure_DOT_core_list) + tmp15 := checkDerefVar(glojure_DOT_core_apply) + tmp16 := checkDerefVar(glojure_DOT_core_vector) + tmp17 := checkDerefVar(glojure_DOT_core_seq) + tmp18 := checkDerefVar(glojure_DOT_core_concat) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{lang.NewSymbol("a__0__auto__")}) + tmp21 := checkDerefVar(glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v5}) + tmp23 := checkDerefVar(glojure_DOT_core_list) + tmp24 := lang.Apply(tmp23, []any{lang.NewSymbol("l__1__auto__")}) + tmp25 := checkDerefVar(glojure_DOT_core_list) + tmp26 := checkDerefVar(glojure_DOT_core_seq) + tmp27 := checkDerefVar(glojure_DOT_core_concat) + tmp28 := checkDerefVar(glojure_DOT_core_list) + tmp29 := lang.Apply(tmp28, []any{lang.NewSymbol("glojure.core/alength")}) + tmp30 := checkDerefVar(glojure_DOT_core_list) + tmp31 := lang.Apply(tmp30, []any{lang.NewSymbol("a__0__auto__")}) + tmp32 := lang.Apply(tmp27, []any{tmp29, tmp31}) + tmp33 := lang.Apply(tmp26, []any{tmp32}) + tmp34 := lang.Apply(tmp25, []any{tmp33}) + tmp35 := lang.Apply(tmp18, []any{tmp20, tmp22, tmp24, tmp34}) + tmp36 := lang.Apply(tmp17, []any{tmp35}) + tmp37 := lang.Apply(tmp15, []any{tmp16, tmp36}) + tmp38 := lang.Apply(tmp14, []any{tmp37}) + tmp39 := checkDerefVar(glojure_DOT_core_list) + tmp40 := checkDerefVar(glojure_DOT_core_seq) + tmp41 := checkDerefVar(glojure_DOT_core_concat) + tmp42 := checkDerefVar(glojure_DOT_core_list) + tmp43 := lang.Apply(tmp42, []any{lang.NewSymbol("glojure.core/loop")}) + tmp44 := checkDerefVar(glojure_DOT_core_list) + tmp45 := checkDerefVar(glojure_DOT_core_apply) + tmp46 := checkDerefVar(glojure_DOT_core_vector) + tmp47 := checkDerefVar(glojure_DOT_core_seq) + tmp48 := checkDerefVar(glojure_DOT_core_concat) + tmp49 := checkDerefVar(glojure_DOT_core_list) + tmp50 := lang.Apply(tmp49, []any{v6}) + tmp51 := checkDerefVar(glojure_DOT_core_list) + tmp52 := lang.Apply(tmp51, []any{int64(0)}) + tmp53 := checkDerefVar(glojure_DOT_core_list) + tmp54 := lang.Apply(tmp53, []any{v7}) + tmp55 := checkDerefVar(glojure_DOT_core_list) + tmp56 := lang.Apply(tmp55, []any{v8}) + tmp57 := lang.Apply(tmp48, []any{tmp50, tmp52, tmp54, tmp56}) + tmp58 := lang.Apply(tmp47, []any{tmp57}) + tmp59 := lang.Apply(tmp45, []any{tmp46, tmp58}) + tmp60 := lang.Apply(tmp44, []any{tmp59}) + tmp61 := checkDerefVar(glojure_DOT_core_list) + tmp62 := checkDerefVar(glojure_DOT_core_seq) + tmp63 := checkDerefVar(glojure_DOT_core_concat) + tmp64 := checkDerefVar(glojure_DOT_core_list) + tmp65 := lang.Apply(tmp64, []any{lang.NewSymbol("if")}) + tmp66 := checkDerefVar(glojure_DOT_core_list) + tmp67 := checkDerefVar(glojure_DOT_core_seq) + tmp68 := checkDerefVar(glojure_DOT_core_concat) + tmp69 := checkDerefVar(glojure_DOT_core_list) + tmp70 := lang.Apply(tmp69, []any{lang.NewSymbol("glojure.core/<")}) + tmp71 := checkDerefVar(glojure_DOT_core_list) + tmp72 := lang.Apply(tmp71, []any{v6}) + tmp73 := checkDerefVar(glojure_DOT_core_list) + tmp74 := lang.Apply(tmp73, []any{lang.NewSymbol("l__1__auto__")}) + tmp75 := lang.Apply(tmp68, []any{tmp70, tmp72, tmp74}) + tmp76 := lang.Apply(tmp67, []any{tmp75}) + tmp77 := lang.Apply(tmp66, []any{tmp76}) + tmp78 := checkDerefVar(glojure_DOT_core_list) + tmp79 := checkDerefVar(glojure_DOT_core_seq) + tmp80 := checkDerefVar(glojure_DOT_core_concat) + tmp81 := checkDerefVar(glojure_DOT_core_list) + tmp82 := lang.Apply(tmp81, []any{lang.NewSymbol("recur")}) + tmp83 := checkDerefVar(glojure_DOT_core_list) + tmp84 := checkDerefVar(glojure_DOT_core_seq) + tmp85 := checkDerefVar(glojure_DOT_core_concat) + tmp86 := checkDerefVar(glojure_DOT_core_list) + tmp87 := lang.Apply(tmp86, []any{lang.NewSymbol("glojure.core/unchecked-inc-int")}) + tmp88 := checkDerefVar(glojure_DOT_core_list) + tmp89 := lang.Apply(tmp88, []any{v6}) + tmp90 := lang.Apply(tmp85, []any{tmp87, tmp89}) + tmp91 := lang.Apply(tmp84, []any{tmp90}) + tmp92 := lang.Apply(tmp83, []any{tmp91}) + tmp93 := checkDerefVar(glojure_DOT_core_list) + tmp94 := lang.Apply(tmp93, []any{v9}) + tmp95 := lang.Apply(tmp80, []any{tmp82, tmp92, tmp94}) + tmp96 := lang.Apply(tmp79, []any{tmp95}) + tmp97 := lang.Apply(tmp78, []any{tmp96}) + tmp98 := checkDerefVar(glojure_DOT_core_list) + tmp99 := lang.Apply(tmp98, []any{v7}) + tmp100 := lang.Apply(tmp63, []any{tmp65, tmp77, tmp97, tmp99}) + tmp101 := lang.Apply(tmp62, []any{tmp100}) + tmp102 := lang.Apply(tmp61, []any{tmp101}) + tmp103 := lang.Apply(tmp41, []any{tmp43, tmp60, tmp102}) + tmp104 := lang.Apply(tmp40, []any{tmp103}) + tmp105 := lang.Apply(tmp39, []any{tmp104}) + tmp106 := lang.Apply(tmp11, []any{tmp13, tmp38, tmp105}) + tmp107 := lang.Apply(tmp10, []any{tmp106}) + return tmp107 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // array + { + tmp0 := lang.NewSymbol("array").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3457), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3458), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("items"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_into_array) + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // array-map + { + tmp0 := lang.NewSymbol("array-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keyvals"))), lang.NewKeyword("doc"), "Constructs an array-map. If any keys are equal, they are handled as\n if by repeated uses of assoc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4378), lang.NewKeyword("end-line"), int(4378))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp3, ok := lang.FieldOrMethod(nil, "EMPTY") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "EMPTY"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v3 any = lang.NewList(args[0:]...) + _ = v3 + var tmp4 any + { // let + // let binding "ary" + tmp5 := checkDerefVar(glojure_DOT_core_to_array) + tmp6 := lang.Apply(tmp5, []any{v3}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + tmp9 := checkDerefVar(glojure_DOT_core_odd_QMARK_) + tmp10 := checkDerefVar(glojure_DOT_core_alength) + tmp11 := lang.Apply(tmp10, []any{v7}) + tmp12 := lang.Apply(tmp9, []any{tmp11}) + if lang.IsTruthy(tmp12) { + tmp13 := checkDerefVar(glojure_DOT_core_str) + tmp14 := checkDerefVar(glojure_DOT_core_last) + tmp15 := lang.Apply(tmp14, []any{v3}) + tmp16 := lang.Apply(tmp13, []any{"No value supplied for key: ", tmp15}) + tmp17 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp16}) + panic(tmp17) + } else { + tmp18 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{v7}) + tmp8 = tmp18 + } + tmp4 = tmp8 + } // end let + return tmp4 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // as-> + { + tmp0 := lang.NewSymbol("as->").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "Binds name to expr, evaluates the first form in the lexical context\n of that binding, then binds name to that result, repeating for each\n successive form, returning the result of the last form.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7598), lang.NewKeyword("end-line"), int(7598))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + var v7 any = lang.NewList(args[4:]...) + _ = v7 + tmp8 := checkDerefVar(glojure_DOT_core_seq) + tmp9 := checkDerefVar(glojure_DOT_core_concat) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol("glojure.core/let")}) + tmp12 := checkDerefVar(glojure_DOT_core_list) + tmp13 := checkDerefVar(glojure_DOT_core_apply) + tmp14 := checkDerefVar(glojure_DOT_core_vector) + tmp15 := checkDerefVar(glojure_DOT_core_seq) + tmp16 := checkDerefVar(glojure_DOT_core_concat) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v6}) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v5}) + tmp21 := checkDerefVar(glojure_DOT_core_interleave) + tmp22 := checkDerefVar(glojure_DOT_core_repeat) + tmp23 := lang.Apply(tmp22, []any{v6}) + tmp24 := checkDerefVar(glojure_DOT_core_butlast) + tmp25 := lang.Apply(tmp24, []any{v7}) + tmp26 := lang.Apply(tmp21, []any{tmp23, tmp25}) + tmp27 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp26}) + tmp28 := lang.Apply(tmp15, []any{tmp27}) + tmp29 := lang.Apply(tmp13, []any{tmp14, tmp28}) + tmp30 := lang.Apply(tmp12, []any{tmp29}) + tmp31 := checkDerefVar(glojure_DOT_core_list) + var tmp32 any + tmp33 := checkDerefVar(glojure_DOT_core_empty_QMARK_) + tmp34 := lang.Apply(tmp33, []any{v7}) + if lang.IsTruthy(tmp34) { + tmp32 = v6 + } else { + tmp35 := checkDerefVar(glojure_DOT_core_last) + tmp36 := lang.Apply(tmp35, []any{v7}) + tmp32 = tmp36 + } + tmp37 := lang.Apply(tmp31, []any{tmp32}) + tmp38 := lang.Apply(tmp9, []any{tmp11, tmp30, tmp37}) + tmp39 := lang.Apply(tmp8, []any{tmp38}) + return tmp39 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // aset + { + var tmp1 lang.FnFunc + { // function aset__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6 := checkDerefVar(glojure_DOT_core_seq) + tmp7 := checkDerefVar(glojure_DOT_core_concat) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol(".")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + tmp12 := checkDerefVar(glojure_DOT_core_list) + tmp13 := checkDerefVar(glojure_DOT_core_seq) + tmp14 := checkDerefVar(glojure_DOT_core_concat) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("glojure.core/Aset")}) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := checkDerefVar(glojure_DOT_core_seq) + tmp21 := checkDerefVar(glojure_DOT_core_concat) + tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{lang.NewSymbol("glojure.core/int")}) + tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v4}) + tmp26 := lang.Apply(tmp21, []any{tmp23, tmp25}) + tmp27 := lang.Apply(tmp20, []any{tmp26}) + tmp28 := lang.Apply(tmp19, []any{tmp27}) + tmp29 := checkDerefVar(glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{v5}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp28, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp12, []any{tmp32}) + tmp34 := lang.Apply(tmp7, []any{tmp9, tmp11, tmp33}) + tmp35 := lang.Apply(tmp6, []any{tmp34}) + return tmp35 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("aset").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on Java arrays of\n reference types. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(3)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3922), lang.NewKeyword("end-line"), int(3922))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := args[2] + _ = v6 + tmp7 := lang.Apply(lang.SliceSet, []any{v4, v5, v6}) + _ = tmp7 + return v6 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := args[2] + _ = v6 + var v7 any = lang.NewList(args[3:]...) + _ = v7 + tmp8 := checkDerefVar(glojure_DOT_core_apply) + tmp9 := checkDerefVar(glojure_DOT_core_aset) + tmp10 := checkDerefVar(glojure_DOT_core_aget) + tmp11 := lang.Apply(tmp10, []any{v4, v5}) + tmp12 := lang.Apply(tmp8, []any{tmp9, tmp11, v6, v7}) + return tmp12 + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // aset-boolean + { + tmp0 := lang.NewSymbol("aset-boolean").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of boolean. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3956), lang.NewKeyword("end-line"), int(3958))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6 := checkDerefVar(glojure_DOT_core_boolean) + tmp7 := lang.Apply(tmp6, []any{v5}) + tmp8, _ := lang.FieldOrMethod(nil, "setBoolean") + if reflect.TypeOf(tmp8).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setBoolean is not a function"))) + } + tmp9 := lang.Apply(tmp8, []any{v3, v4, tmp7}) + _ = tmp9 + return v5 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_apply) + tmp8 := checkDerefVar(glojure_DOT_core_aset_boolean) + tmp9 := checkDerefVar(glojure_DOT_core_aget) + tmp10 := lang.Apply(tmp9, []any{v3, v4}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v5, v6}) + return tmp11 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // aset-byte + { + tmp0 := lang.NewSymbol("aset-byte").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of byte. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3976), lang.NewKeyword("end-line"), int(3978))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6 := checkDerefVar(glojure_DOT_core_byte) + tmp7 := lang.Apply(tmp6, []any{v5}) + tmp8, _ := lang.FieldOrMethod(nil, "setByte") + if reflect.TypeOf(tmp8).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setByte is not a function"))) + } + tmp9 := lang.Apply(tmp8, []any{v3, v4, tmp7}) + _ = tmp9 + return v5 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_apply) + tmp8 := checkDerefVar(glojure_DOT_core_aset_byte) + tmp9 := checkDerefVar(glojure_DOT_core_aget) + tmp10 := lang.Apply(tmp9, []any{v3, v4}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v5, v6}) + return tmp11 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // aset-char + { + tmp0 := lang.NewSymbol("aset-char").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of char. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3981), lang.NewKeyword("end-line"), int(3983))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6 := checkDerefVar(glojure_DOT_core_char) + tmp7 := lang.Apply(tmp6, []any{v5}) + tmp8, _ := lang.FieldOrMethod(nil, "setChar") + if reflect.TypeOf(tmp8).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setChar is not a function"))) + } + tmp9 := lang.Apply(tmp8, []any{v3, v4, tmp7}) + _ = tmp9 + return v5 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_apply) + tmp8 := checkDerefVar(glojure_DOT_core_aset_char) + tmp9 := checkDerefVar(glojure_DOT_core_aget) + tmp10 := lang.Apply(tmp9, []any{v3, v4}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v5, v6}) + return tmp11 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // aset-double + { + tmp0 := lang.NewSymbol("aset-double").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of double. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3966), lang.NewKeyword("end-line"), int(3968))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6 := checkDerefVar(glojure_DOT_core_double) + tmp7 := lang.Apply(tmp6, []any{v5}) + tmp8, _ := lang.FieldOrMethod(nil, "setDouble") + if reflect.TypeOf(tmp8).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setDouble is not a function"))) + } + tmp9 := lang.Apply(tmp8, []any{v3, v4, tmp7}) + _ = tmp9 + return v5 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_apply) + tmp8 := checkDerefVar(glojure_DOT_core_aset_double) + tmp9 := checkDerefVar(glojure_DOT_core_aget) + tmp10 := lang.Apply(tmp9, []any{v3, v4}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v5, v6}) + return tmp11 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // aset-float + { + tmp0 := lang.NewSymbol("aset-float").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of float. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3961), lang.NewKeyword("end-line"), int(3963))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6 := checkDerefVar(glojure_DOT_core_float) + tmp7 := lang.Apply(tmp6, []any{v5}) + tmp8, _ := lang.FieldOrMethod(nil, "setFloat") + if reflect.TypeOf(tmp8).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setFloat is not a function"))) + } + tmp9 := lang.Apply(tmp8, []any{v3, v4, tmp7}) + _ = tmp9 + return v5 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_apply) + tmp8 := checkDerefVar(glojure_DOT_core_aset_float) + tmp9 := checkDerefVar(glojure_DOT_core_aget) + tmp10 := lang.Apply(tmp9, []any{v3, v4}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v5, v6}) + return tmp11 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // aset-int + { + tmp0 := lang.NewSymbol("aset-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of int. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3946), lang.NewKeyword("end-line"), int(3948))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6 := checkDerefVar(glojure_DOT_core_int) + tmp7 := lang.Apply(tmp6, []any{v5}) + tmp8, _ := lang.FieldOrMethod(nil, "setInt") + if reflect.TypeOf(tmp8).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setInt is not a function"))) + } + tmp9 := lang.Apply(tmp8, []any{v3, v4, tmp7}) + _ = tmp9 + return v5 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_apply) + tmp8 := checkDerefVar(glojure_DOT_core_aset_int) + tmp9 := checkDerefVar(glojure_DOT_core_aget) + tmp10 := lang.Apply(tmp9, []any{v3, v4}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v5, v6}) + return tmp11 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // aset-long + { + tmp0 := lang.NewSymbol("aset-long").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of long. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3951), lang.NewKeyword("end-line"), int(3953))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6 := checkDerefVar(glojure_DOT_core_long) + tmp7 := lang.Apply(tmp6, []any{v5}) + tmp8, _ := lang.FieldOrMethod(nil, "setLong") + if reflect.TypeOf(tmp8).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setLong is not a function"))) + } + tmp9 := lang.Apply(tmp8, []any{v3, v4, tmp7}) + _ = tmp9 + return v5 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_apply) + tmp8 := checkDerefVar(glojure_DOT_core_aset_long) + tmp9 := checkDerefVar(glojure_DOT_core_aget) + tmp10 := lang.Apply(tmp9, []any{v3, v4}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v5, v6}) + return tmp11 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // aset-short + { + tmp0 := lang.NewSymbol("aset-short").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of short. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3971), lang.NewKeyword("end-line"), int(3973))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6 := checkDerefVar(glojure_DOT_core_short) + tmp7 := lang.Apply(tmp6, []any{v5}) + tmp8, _ := lang.FieldOrMethod(nil, "setShort") + if reflect.TypeOf(tmp8).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setShort is not a function"))) + } + tmp9 := lang.Apply(tmp8, []any{v3, v4, tmp7}) + _ = tmp9 + return v5 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_apply) + tmp8 := checkDerefVar(glojure_DOT_core_aset_short) + tmp9 := checkDerefVar(glojure_DOT_core_aget) + tmp10 := lang.Apply(tmp9, []any{v3, v4}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v5, v6}) + return tmp11 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // assert + { + tmp0 := lang.NewSymbol("assert").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("message"))), lang.NewKeyword("doc"), "Evaluates expression x and throws an AssertionError with optional\n message if x does not evaluate to logical true.\n\n Assertion checks are omitted from compiled code if '*assert*' is\n false.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4837), lang.NewKeyword("end-line"), int(4837))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(glojure_DOT_core__STAR_assert_STAR_) + if lang.IsTruthy(tmp7) { + tmp8 := checkDerefVar(glojure_DOT_core_seq) + tmp9 := checkDerefVar(glojure_DOT_core_concat) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol("glojure.core/when-not")}) + tmp12 := checkDerefVar(glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v5}) + tmp14 := checkDerefVar(glojure_DOT_core_list) + tmp15 := checkDerefVar(glojure_DOT_core_seq) + tmp16 := checkDerefVar(glojure_DOT_core_concat) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("throw")}) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := checkDerefVar(glojure_DOT_core_seq) + tmp21 := checkDerefVar(glojure_DOT_core_concat) + tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{lang.NewSymbol("new")}) + tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{lang.NewSymbol("glojure.core/AssertionError")}) + tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp27 := checkDerefVar(glojure_DOT_core_seq) + tmp28 := checkDerefVar(glojure_DOT_core_concat) + tmp29 := checkDerefVar(glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/str")}) + tmp31 := checkDerefVar(glojure_DOT_core_list) + tmp32 := lang.Apply(tmp31, []any{"Assert failed: "}) + tmp33 := checkDerefVar(glojure_DOT_core_list) + tmp34 := checkDerefVar(glojure_DOT_core_seq) + tmp35 := checkDerefVar(glojure_DOT_core_concat) + tmp36 := checkDerefVar(glojure_DOT_core_list) + tmp37 := lang.Apply(tmp36, []any{lang.NewSymbol("glojure.core/pr-str")}) + tmp38 := checkDerefVar(glojure_DOT_core_list) + tmp39 := checkDerefVar(glojure_DOT_core_seq) + tmp40 := checkDerefVar(glojure_DOT_core_concat) + tmp41 := checkDerefVar(glojure_DOT_core_list) + tmp42 := lang.Apply(tmp41, []any{lang.NewSymbol("quote")}) + tmp43 := checkDerefVar(glojure_DOT_core_list) + tmp44 := lang.Apply(tmp43, []any{v5}) + tmp45 := lang.Apply(tmp40, []any{tmp42, tmp44}) + tmp46 := lang.Apply(tmp39, []any{tmp45}) + tmp47 := lang.Apply(tmp38, []any{tmp46}) + tmp48 := lang.Apply(tmp35, []any{tmp37, tmp47}) + tmp49 := lang.Apply(tmp34, []any{tmp48}) + tmp50 := lang.Apply(tmp33, []any{tmp49}) + tmp51 := lang.Apply(tmp28, []any{tmp30, tmp32, tmp50}) + tmp52 := lang.Apply(tmp27, []any{tmp51}) + tmp53 := lang.Apply(tmp26, []any{tmp52}) + tmp54 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp53}) + tmp55 := lang.Apply(tmp20, []any{tmp54}) + tmp56 := lang.Apply(tmp19, []any{tmp55}) + tmp57 := lang.Apply(tmp16, []any{tmp18, tmp56}) + tmp58 := lang.Apply(tmp15, []any{tmp57}) + tmp59 := lang.Apply(tmp14, []any{tmp58}) + tmp60 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp59}) + tmp61 := lang.Apply(tmp8, []any{tmp60}) + tmp6 = tmp61 + } else { + } + return tmp6 + case 4: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + var tmp7 any + tmp8 := checkDerefVar(glojure_DOT_core__STAR_assert_STAR_) + if lang.IsTruthy(tmp8) { + tmp9 := checkDerefVar(glojure_DOT_core_seq) + tmp10 := checkDerefVar(glojure_DOT_core_concat) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{lang.NewSymbol("glojure.core/when-not")}) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{v5}) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := checkDerefVar(glojure_DOT_core_seq) + tmp17 := checkDerefVar(glojure_DOT_core_concat) + tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{lang.NewSymbol("throw")}) + tmp20 := checkDerefVar(glojure_DOT_core_list) + tmp21 := checkDerefVar(glojure_DOT_core_seq) + tmp22 := checkDerefVar(glojure_DOT_core_concat) + tmp23 := checkDerefVar(glojure_DOT_core_list) + tmp24 := lang.Apply(tmp23, []any{lang.NewSymbol("new")}) + tmp25 := checkDerefVar(glojure_DOT_core_list) + tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol("glojure.core/AssertionError")}) + tmp27 := checkDerefVar(glojure_DOT_core_list) + tmp28 := checkDerefVar(glojure_DOT_core_seq) + tmp29 := checkDerefVar(glojure_DOT_core_concat) + tmp30 := checkDerefVar(glojure_DOT_core_list) + tmp31 := lang.Apply(tmp30, []any{lang.NewSymbol("glojure.core/str")}) + tmp32 := checkDerefVar(glojure_DOT_core_list) + tmp33 := lang.Apply(tmp32, []any{"Assert failed: "}) + tmp34 := checkDerefVar(glojure_DOT_core_list) + tmp35 := lang.Apply(tmp34, []any{v6}) + tmp36 := checkDerefVar(glojure_DOT_core_list) + tmp37 := lang.Apply(tmp36, []any{"\n"}) + tmp38 := checkDerefVar(glojure_DOT_core_list) + tmp39 := checkDerefVar(glojure_DOT_core_seq) + tmp40 := checkDerefVar(glojure_DOT_core_concat) + tmp41 := checkDerefVar(glojure_DOT_core_list) + tmp42 := lang.Apply(tmp41, []any{lang.NewSymbol("glojure.core/pr-str")}) + tmp43 := checkDerefVar(glojure_DOT_core_list) + tmp44 := checkDerefVar(glojure_DOT_core_seq) + tmp45 := checkDerefVar(glojure_DOT_core_concat) + tmp46 := checkDerefVar(glojure_DOT_core_list) + tmp47 := lang.Apply(tmp46, []any{lang.NewSymbol("quote")}) + tmp48 := checkDerefVar(glojure_DOT_core_list) + tmp49 := lang.Apply(tmp48, []any{v5}) + tmp50 := lang.Apply(tmp45, []any{tmp47, tmp49}) + tmp51 := lang.Apply(tmp44, []any{tmp50}) + tmp52 := lang.Apply(tmp43, []any{tmp51}) + tmp53 := lang.Apply(tmp40, []any{tmp42, tmp52}) + tmp54 := lang.Apply(tmp39, []any{tmp53}) + tmp55 := lang.Apply(tmp38, []any{tmp54}) + tmp56 := lang.Apply(tmp29, []any{tmp31, tmp33, tmp35, tmp37, tmp55}) + tmp57 := lang.Apply(tmp28, []any{tmp56}) + tmp58 := lang.Apply(tmp27, []any{tmp57}) + tmp59 := lang.Apply(tmp22, []any{tmp24, tmp26, tmp58}) + tmp60 := lang.Apply(tmp21, []any{tmp59}) + tmp61 := lang.Apply(tmp20, []any{tmp60}) + tmp62 := lang.Apply(tmp17, []any{tmp19, tmp61}) + tmp63 := lang.Apply(tmp16, []any{tmp62}) + tmp64 := lang.Apply(tmp15, []any{tmp63}) + tmp65 := lang.Apply(tmp10, []any{tmp12, tmp14, tmp64}) + tmp66 := lang.Apply(tmp9, []any{tmp65}) + tmp7 = tmp66 + } else { + } + return tmp7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // assert-args + { + tmp0 := lang.NewSymbol("assert-args").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("pairs"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(38), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1830), lang.NewKeyword("end-line"), int(1830), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := checkDerefVar(glojure_DOT_core_seq) + tmp7 := checkDerefVar(glojure_DOT_core_concat) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("do")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := checkDerefVar(glojure_DOT_core_seq) + tmp12 := checkDerefVar(glojure_DOT_core_concat) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/when-not")}) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := checkDerefVar(glojure_DOT_core_first) + tmp17 := lang.Apply(tmp16, []any{v5}) + tmp18 := lang.Apply(tmp15, []any{tmp17}) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := checkDerefVar(glojure_DOT_core_seq) + tmp21 := checkDerefVar(glojure_DOT_core_concat) + tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{lang.NewSymbol("throw")}) + tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp25 := checkDerefVar(glojure_DOT_core_seq) + tmp26 := checkDerefVar(glojure_DOT_core_concat) + tmp27 := checkDerefVar(glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewIllegalArgumentError")}) + tmp29 := checkDerefVar(glojure_DOT_core_list) + tmp30 := checkDerefVar(glojure_DOT_core_seq) + tmp31 := checkDerefVar(glojure_DOT_core_concat) + tmp32 := checkDerefVar(glojure_DOT_core_list) + tmp33 := lang.Apply(tmp32, []any{lang.NewSymbol("glojure.core/str")}) + tmp34 := checkDerefVar(glojure_DOT_core_list) + tmp35 := checkDerefVar(glojure_DOT_core_seq) + tmp36 := checkDerefVar(glojure_DOT_core_concat) + tmp37 := checkDerefVar(glojure_DOT_core_list) + tmp38 := lang.Apply(tmp37, []any{lang.NewSymbol("glojure.core/first")}) + tmp39 := checkDerefVar(glojure_DOT_core_list) + tmp40 := lang.Apply(tmp39, []any{lang.NewSymbol("&form")}) + tmp41 := lang.Apply(tmp36, []any{tmp38, tmp40}) + tmp42 := lang.Apply(tmp35, []any{tmp41}) + tmp43 := lang.Apply(tmp34, []any{tmp42}) + tmp44 := checkDerefVar(glojure_DOT_core_list) + tmp45 := lang.Apply(tmp44, []any{" requires "}) + tmp46 := checkDerefVar(glojure_DOT_core_list) + tmp47 := checkDerefVar(glojure_DOT_core_second) + tmp48 := lang.Apply(tmp47, []any{v5}) + tmp49 := lang.Apply(tmp46, []any{tmp48}) + tmp50 := checkDerefVar(glojure_DOT_core_list) + tmp51 := lang.Apply(tmp50, []any{" in "}) + tmp52 := checkDerefVar(glojure_DOT_core_list) + tmp53 := lang.Apply(tmp52, []any{lang.NewSymbol("*ns*")}) + tmp54 := checkDerefVar(glojure_DOT_core_list) + tmp55 := lang.Apply(tmp54, []any{":"}) + tmp56 := checkDerefVar(glojure_DOT_core_list) + tmp57 := checkDerefVar(glojure_DOT_core_seq) + tmp58 := checkDerefVar(glojure_DOT_core_concat) + tmp59 := checkDerefVar(glojure_DOT_core_list) + tmp60 := lang.Apply(tmp59, []any{lang.NewKeyword("line")}) + tmp61 := checkDerefVar(glojure_DOT_core_list) + tmp62 := checkDerefVar(glojure_DOT_core_seq) + tmp63 := checkDerefVar(glojure_DOT_core_concat) + tmp64 := checkDerefVar(glojure_DOT_core_list) + tmp65 := lang.Apply(tmp64, []any{lang.NewSymbol("glojure.core/meta")}) + tmp66 := checkDerefVar(glojure_DOT_core_list) + tmp67 := lang.Apply(tmp66, []any{lang.NewSymbol("&form")}) + tmp68 := lang.Apply(tmp63, []any{tmp65, tmp67}) + tmp69 := lang.Apply(tmp62, []any{tmp68}) + tmp70 := lang.Apply(tmp61, []any{tmp69}) + tmp71 := lang.Apply(tmp58, []any{tmp60, tmp70}) + tmp72 := lang.Apply(tmp57, []any{tmp71}) + tmp73 := lang.Apply(tmp56, []any{tmp72}) + tmp74 := lang.Apply(tmp31, []any{tmp33, tmp43, tmp45, tmp49, tmp51, tmp53, tmp55, tmp73}) + tmp75 := lang.Apply(tmp30, []any{tmp74}) + tmp76 := lang.Apply(tmp29, []any{tmp75}) + tmp77 := lang.Apply(tmp26, []any{tmp28, tmp76}) + tmp78 := lang.Apply(tmp25, []any{tmp77}) + tmp79 := lang.Apply(tmp24, []any{tmp78}) + tmp80 := lang.Apply(tmp21, []any{tmp23, tmp79}) + tmp81 := lang.Apply(tmp20, []any{tmp80}) + tmp82 := lang.Apply(tmp19, []any{tmp81}) + tmp83 := lang.Apply(tmp12, []any{tmp14, tmp18, tmp82}) + tmp84 := lang.Apply(tmp11, []any{tmp83}) + tmp85 := lang.Apply(tmp10, []any{tmp84}) + tmp86 := checkDerefVar(glojure_DOT_core_list) + var tmp87 any + { // let + // let binding "more" + tmp88 := checkDerefVar(glojure_DOT_core_nnext) + tmp89 := lang.Apply(tmp88, []any{v5}) + var v90 any = tmp89 + _ = v90 + var tmp91 any + if lang.IsTruthy(v90) { + tmp92 := checkDerefVar(glojure_DOT_core_list_STAR_) + tmp93 := lang.Apply(tmp92, []any{lang.NewSymbol("glojure.core/assert-args"), v90}) + tmp91 = tmp93 + } else { + } + tmp87 = tmp91 + } // end let + tmp88 := lang.Apply(tmp86, []any{tmp87}) + tmp89 := lang.Apply(tmp7, []any{tmp9, tmp85, tmp88}) + tmp90 := lang.Apply(tmp6, []any{tmp89}) + return tmp90 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // assert-valid-fdecl + { + tmp0 := lang.NewSymbol("assert-valid-fdecl").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fdecl"))), lang.NewKeyword("doc"), "A good fdecl looks like (([a] ...) ([a b] ...)) near the end of defn.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(42), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(7502), lang.NewKeyword("end-line"), int(7502), lang.NewKeyword("private"), true, lang.NewKeyword("dynamic"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(glojure_DOT_core_empty_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + tmp7 := lang.Apply(lang.NewIllegalArgumentError, []any{"Parameter declaration missing"}) + panic(tmp7) + } else { + } + _ = tmp4 + var tmp8 any + { // let + // let binding "argdecls" + tmp9 := checkDerefVar(glojure_DOT_core_map) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v11 := args[0] + _ = v11 + var tmp12 any + tmp13 := checkDerefVar(glojure_DOT_core_seq_QMARK_) + tmp14 := lang.Apply(tmp13, []any{v11}) + if lang.IsTruthy(tmp14) { + tmp15 := checkDerefVar(glojure_DOT_core_first) + tmp16 := lang.Apply(tmp15, []any{v11}) + tmp12 = tmp16 + } else { + var tmp17 any + tmp18 := checkDerefVar(glojure_DOT_core_seq_QMARK_) + tmp19 := checkDerefVar(glojure_DOT_core_first) + tmp20 := lang.Apply(tmp19, []any{v3}) + tmp21 := lang.Apply(tmp18, []any{tmp20}) + if lang.IsTruthy(tmp21) { + tmp22 := checkDerefVar(glojure_DOT_core_str) + tmp23 := lang.Apply(tmp22, []any{"Invalid signature \"", v11, "\" should be a list"}) + tmp17 = tmp23 + } else { + tmp24 := checkDerefVar(glojure_DOT_core_str) + tmp25 := lang.Apply(tmp24, []any{"Parameter declaration \"", v11, "\" should be a vector"}) + tmp17 = tmp25 + } + tmp26 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp17}) + panic(tmp26) + } + return tmp12 + }) + tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7508), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7517), lang.NewKeyword("end-column"), int(59)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := lang.Apply(tmp9, []any{tmp12, v3}) + var v14 any = tmp13 + _ = v14 + // let binding "bad-args" + tmp15 := checkDerefVar(glojure_DOT_core_seq) + tmp16 := checkDerefVar(glojure_DOT_core_remove) + var tmp17 lang.FnFunc + tmp17 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v18 := args[0] + _ = v18 + tmp19 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp20 := lang.Apply(tmp19, []any{v18}) + return tmp20 + }) + tmp18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7519), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(7519), lang.NewKeyword("end-column"), int(42)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp20 := lang.Apply(tmp16, []any{tmp19, v14}) + tmp21 := lang.Apply(tmp15, []any{tmp20}) + var v22 any = tmp21 + _ = v22 + var tmp23 any + if lang.IsTruthy(v22) { + tmp24 := checkDerefVar(glojure_DOT_core_str) + tmp25 := checkDerefVar(glojure_DOT_core_first) + tmp26 := lang.Apply(tmp25, []any{v22}) + tmp27 := lang.Apply(tmp24, []any{"Parameter declaration \"", tmp26, "\" should be a vector"}) + tmp28 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp27}) + panic(tmp28) + } else { + } + tmp8 = tmp23 + } // end let + return tmp8 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // assoc + { + tmp0 := lang.NewSymbol("assoc").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"), lang.NewSymbol("val"), lang.NewSymbol("&"), lang.NewSymbol("kvs"))), lang.NewKeyword("doc"), "assoc[iate]. When applied to a map, returns a new map of the\n same (hashed/sorted) type, that contains the mapping of key(s) to\n val(s). When applied to a vector, returns a new vector that\n contains val at index. Note - index must be <= (count vector).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(181), lang.NewKeyword("end-line"), int(188))).(*lang.Symbol) + var tmp2 lang.FnFunc + { // function assoc + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := args[2] + _ = v6 + tmp7 := lang.Apply(lang.Assoc, []any{v4, v5, v6}) + return tmp7 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := args[2] + _ = v6 + var v7 any = lang.NewList(args[3:]...) + _ = v7 + recur_loop_24: + var tmp8 any + { // let + // let binding "ret" + tmp9 := lang.Apply(lang.Assoc, []any{v4, v5, v6}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + if lang.IsTruthy(v7) { + var tmp12 any + tmp13 := checkDerefVar(glojure_DOT_core_next) + tmp14 := lang.Apply(tmp13, []any{v7}) + if lang.IsTruthy(tmp14) { + var tmp15 any = v10 + tmp17 := checkDerefVar(glojure_DOT_core_first) + tmp18 := lang.Apply(tmp17, []any{v7}) + var tmp16 any = tmp18 + tmp20 := checkDerefVar(glojure_DOT_core_second) + tmp21 := lang.Apply(tmp20, []any{v7}) + var tmp19 any = tmp21 + tmp23 := checkDerefVar(glojure_DOT_core_nnext) + tmp24 := lang.Apply(tmp23, []any{v7}) + var tmp22 any = tmp24 + v4 = tmp15 + v5 = tmp16 + v6 = tmp19 + v7 = tmp22 + goto recur_loop_24 + } else { + tmp25 := lang.Apply(lang.NewIllegalArgumentError, []any{"assoc expects even number of arguments after map/vector, found odd number"}) + panic(tmp25) + } + tmp11 = tmp12 + } else { + tmp11 = v10 + } + tmp8 = tmp11 + } // end let + return tmp8 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(189), lang.NewKeyword("column"), int(2), lang.NewKeyword("end-line"), int(198), lang.NewKeyword("end-column"), int(15))).(lang.FnFunc) + v3 = tmp2 + _ = v3 + } + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // assoc! + { + tmp0 := lang.NewSymbol("assoc!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("key"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("key"), lang.NewSymbol("val"), lang.NewSymbol("&"), lang.NewSymbol("kvs"))), lang.NewKeyword("doc"), "When applied to a transient map, adds mapping of key(s) to\n val(s). When applied to a transient vector, sets the val at index.\n Note - index must be <= (count vector). Returns coll.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3369), lang.NewKeyword("end-line"), int(3369))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6, _ := lang.FieldOrMethod(v3, "Assoc") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Assoc is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + recur_loop_609: + var tmp7 any + { // let + // let binding "ret" + tmp8, _ := lang.FieldOrMethod(v3, "Assoc") + if reflect.TypeOf(tmp8).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Assoc is not a function"))) + } + tmp9 := lang.Apply(tmp8, []any{v4, v5}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + if lang.IsTruthy(v6) { + var tmp12 any = v10 + tmp14 := checkDerefVar(glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v6}) + var tmp13 any = tmp15 + tmp17 := checkDerefVar(glojure_DOT_core_second) + tmp18 := lang.Apply(tmp17, []any{v6}) + var tmp16 any = tmp18 + tmp20 := checkDerefVar(glojure_DOT_core_nnext) + tmp21 := lang.Apply(tmp20, []any{v6}) + var tmp19 any = tmp21 + v3 = tmp12 + v4 = tmp13 + v5 = tmp16 + v6 = tmp19 + goto recur_loop_609 + } else { + tmp11 = v10 + } + tmp7 = tmp11 + } // end let + return tmp7 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // assoc-in + { + tmp0 := lang.NewSymbol("assoc-in").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("&"), lang.NewSymbol("ks")), lang.NewSymbol("v"))), lang.NewKeyword("doc"), "Associates a value in a nested associative structure, where ks is a\n sequence of keys and v is the new value and returns a new nested structure.\n If any levels do not exist, hash-maps will be created.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6147), lang.NewKeyword("end-line"), int(6147))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var tmp6 any + { // let + // let binding "vec__138" + var v7 any = v4 + _ = v7 + // let binding "seq__139" + tmp8 := checkDerefVar(glojure_DOT_core_seq) + tmp9 := lang.Apply(tmp8, []any{v7}) + var v10 any = tmp9 + _ = v10 + // let binding "first__140" + tmp11 := checkDerefVar(glojure_DOT_core_first) + tmp12 := lang.Apply(tmp11, []any{v10}) + var v13 any = tmp12 + _ = v13 + // let binding "seq__139" + tmp14 := checkDerefVar(glojure_DOT_core_next) + tmp15 := lang.Apply(tmp14, []any{v10}) + var v16 any = tmp15 + _ = v16 + // let binding "k" + var v17 any = v13 + _ = v17 + // let binding "ks" + var v18 any = v16 + _ = v18 + var tmp19 any + if lang.IsTruthy(v18) { + tmp20 := checkDerefVar(glojure_DOT_core_assoc) + tmp21 := checkDerefVar(glojure_DOT_core_assoc_in) + tmp22 := checkDerefVar(glojure_DOT_core_get) + tmp23 := lang.Apply(tmp22, []any{v3, v17}) + tmp24 := lang.Apply(tmp21, []any{tmp23, v18, v5}) + tmp25 := lang.Apply(tmp20, []any{v3, v17, tmp24}) + tmp19 = tmp25 + } else { + tmp26 := checkDerefVar(glojure_DOT_core_assoc) + tmp27 := lang.Apply(tmp26, []any{v3, v17, v5}) + tmp19 = tmp27 + } + tmp6 = tmp19 + } // end let + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // associative? + { + tmp0 := lang.NewSymbol("associative?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements Associative", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6223), lang.NewKeyword("end-line"), int(6223))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp5 := lang.Apply(tmp4, []any{nil, v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // atom + { + tmp0 := lang.NewSymbol("atom").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Creates and returns an Atom with an initial value of x and zero or\n more options (in any order):\n\n :meta metadata-map\n\n :validator validate-fn\n\n If metadata-map is supplied, it will become the metadata on the\n atom. validate-fn must be nil or a side-effect-free fn of one\n argument, which will be passed the intended new state on any state\n change. If the new state is unacceptable, the validate-fn should\n return false or throw an exception.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2325), lang.NewKeyword("end-line"), int(2325))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.NewAtom, []any{v3}) + return tmp4 + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any = lang.NewList(args[1:]...) + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_setup_reference) + tmp6 := checkDerefVar(glojure_DOT_core_atom) + tmp7 := lang.Apply(tmp6, []any{v3}) + tmp8 := lang.Apply(tmp5, []any{tmp7, v4}) + return tmp8 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // await + { + tmp0 := lang.NewSymbol("await").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("agents"))), lang.NewKeyword("doc"), "Blocks the current thread (indefinitely!) until all actions\n dispatched thus far, from this thread or agent, to the agent(s) have\n occurred. Will block on failed agents. Will never return if\n a failed agent is restarted with :clear-actions true or shutdown-agents was called.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3267), lang.NewKeyword("end-line"), int(3267))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v3 any = lang.NewList(args[0:]...) + _ = v3 + var tmp4 any + tmp5 := lang.Apply(nil, nil) + if lang.IsTruthy(tmp5) { + panic("unimplemented: new with non-constant class type") + } else { + var tmp6 any + tmp7 := checkDerefVar(glojure_DOT_core__STAR_agent_STAR_) + if lang.IsTruthy(tmp7) { + tmp8 := lang.Apply(errors8.New, []any{"Can't await in agent action"}) + panic(tmp8) + } else { + } + _ = tmp6 + var tmp9 any + { // let + // let binding "latch" + var v10 any = "unimplemented: new with non-constant class type" + _ = v10 + // let binding "count-down" + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v12 := args[0] + _ = v12 + tmp13, _ := lang.FieldOrMethod(v10, "countDown") + if reflect.TypeOf(tmp13).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("countDown is not a function"))) + } + tmp14 := lang.Apply(tmp13, []any{}) + _ = tmp14 + return v12 + }) + tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3279), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(3279), lang.NewKeyword("end-column"), int(61)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v14 any = tmp13 + _ = v14 + var tmp15 any + { // let + // let binding "seq_1" + tmp16 := checkDerefVar(glojure_DOT_core_seq) + tmp17 := lang.Apply(tmp16, []any{v3}) + var v18 any = tmp17 + _ = v18 + // let binding "chunk_2" + var v19 any = nil + _ = v19 + // let binding "count_3" + var v20 any = int64(0) + _ = v20 + // let binding "i_4" + var v21 any = int64(0) + _ = v21 + for { + var tmp22 any + tmp23 := checkDerefVar(glojure_DOT_core__LT_) + tmp24 := lang.Apply(tmp23, []any{v21, v20}) + if lang.IsTruthy(tmp24) { + var tmp25 any + { // let + // let binding "agent" + tmp26, _ := lang.FieldOrMethod(v19, "nth") + if reflect.TypeOf(tmp26).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp27 := lang.Apply(tmp26, []any{v21}) + var v28 any = tmp27 + _ = v28 + tmp29 := checkDerefVar(glojure_DOT_core_send) + tmp30 := lang.Apply(tmp29, []any{v28, v14}) + _ = tmp30 + var tmp31 any = v18 + var tmp32 any = v19 + var tmp33 any = v20 + tmp35 := checkDerefVar(glojure_DOT_core_unchecked_inc) + tmp36 := lang.Apply(tmp35, []any{v21}) + var tmp34 any = tmp36 + v18 = tmp31 + v19 = tmp32 + v20 = tmp33 + v21 = tmp34 + continue + } // end let + tmp22 = tmp25 + } else { + var tmp26 any + { // let + // let binding "temp__0__auto__" + tmp27 := checkDerefVar(glojure_DOT_core_seq) + tmp28 := lang.Apply(tmp27, []any{v18}) + var v29 any = tmp28 + _ = v29 + var tmp30 any + if lang.IsTruthy(v29) { + var tmp31 any + { // let + // let binding "seq_1" + var v32 any = v29 + _ = v32 + var tmp33 any + tmp34 := checkDerefVar(glojure_DOT_core_chunked_seq_QMARK_) + tmp35 := lang.Apply(tmp34, []any{v32}) + if lang.IsTruthy(tmp35) { + var tmp36 any + { // let + // let binding "c__0__auto__" + tmp37 := checkDerefVar(glojure_DOT_core_chunk_first) + tmp38 := lang.Apply(tmp37, []any{v32}) + var v39 any = tmp38 + _ = v39 + tmp41 := checkDerefVar(glojure_DOT_core_chunk_rest) + tmp42 := lang.Apply(tmp41, []any{v32}) + var tmp40 any = tmp42 + var tmp43 any = v39 + tmp45 := checkDerefVar(glojure_DOT_core_int) + tmp46 := checkDerefVar(glojure_DOT_core_count) + tmp47 := lang.Apply(tmp46, []any{v39}) + tmp48 := lang.Apply(tmp45, []any{tmp47}) + var tmp44 any = tmp48 + tmp50 := checkDerefVar(glojure_DOT_core_int) + tmp51 := lang.Apply(tmp50, []any{int64(0)}) + var tmp49 any = tmp51 + v18 = tmp40 + v19 = tmp43 + v20 = tmp44 + v21 = tmp49 + continue + } // end let + tmp33 = tmp36 + } else { + var tmp37 any + { // let + // let binding "agent" + tmp38 := checkDerefVar(glojure_DOT_core_first) + tmp39 := lang.Apply(tmp38, []any{v32}) + var v40 any = tmp39 + _ = v40 + tmp41 := checkDerefVar(glojure_DOT_core_send) + tmp42 := lang.Apply(tmp41, []any{v40, v14}) + _ = tmp42 + tmp44 := checkDerefVar(glojure_DOT_core_next) + tmp45 := lang.Apply(tmp44, []any{v32}) + var tmp43 any = tmp45 + var tmp46 any = nil + var tmp47 any = int64(0) + var tmp48 any = int64(0) + v18 = tmp43 + v19 = tmp46 + v20 = tmp47 + v21 = tmp48 + continue + } // end let + tmp33 = tmp37 + } + tmp31 = tmp33 + } // end let + tmp30 = tmp31 + } else { + } + tmp26 = tmp30 + } // end let + tmp22 = tmp26 + } + tmp15 = tmp22 + break + } + } // end let + _ = tmp15 + tmp16, _ := lang.FieldOrMethod(v10, "await") + if reflect.TypeOf(tmp16).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) + } + tmp17 := lang.Apply(tmp16, []any{}) + tmp9 = tmp17 + } // end let + tmp4 = tmp9 + } + return tmp4 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // await-for + { + tmp0 := lang.NewSymbol("await-for").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("timeout-ms"), lang.NewSymbol("&"), lang.NewSymbol("agents"))), lang.NewKeyword("doc"), "Blocks the current thread until all actions dispatched thus\n far (from this thread or agent) to the agents have occurred, or the\n timeout (in milliseconds) has elapsed. Returns logical false if\n returning due to timeout, logical true otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3289), lang.NewKeyword("end-line"), int(3289))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any = lang.NewList(args[1:]...) + _ = v4 + var tmp5 any + tmp6 := lang.Apply(nil, nil) + if lang.IsTruthy(tmp6) { + panic("unimplemented: new with non-constant class type") + } else { + var tmp7 any + tmp8 := checkDerefVar(glojure_DOT_core__STAR_agent_STAR_) + if lang.IsTruthy(tmp8) { + tmp9 := lang.Apply(errors8.New, []any{"Can't await in agent action"}) + panic(tmp9) + } else { + } + _ = tmp7 + var tmp10 any + { // let + // let binding "latch" + var v11 any = "unimplemented: new with non-constant class type" + _ = v11 + // let binding "count-down" + var tmp12 lang.FnFunc + tmp12 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v13 := args[0] + _ = v13 + tmp14, _ := lang.FieldOrMethod(v11, "countDown") + if reflect.TypeOf(tmp14).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("countDown is not a function"))) + } + tmp15 := lang.Apply(tmp14, []any{}) + _ = tmp15 + return v13 + }) + tmp13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3301), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(3301), lang.NewKeyword("end-column"), int(62)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v15 any = tmp14 + _ = v15 + var tmp16 any + { // let + // let binding "seq_5" + tmp17 := checkDerefVar(glojure_DOT_core_seq) + tmp18 := lang.Apply(tmp17, []any{v4}) + var v19 any = tmp18 + _ = v19 + // let binding "chunk_6" + var v20 any = nil + _ = v20 + // let binding "count_7" + var v21 any = int64(0) + _ = v21 + // let binding "i_8" + var v22 any = int64(0) + _ = v22 + for { + var tmp23 any + tmp24 := checkDerefVar(glojure_DOT_core__LT_) + tmp25 := lang.Apply(tmp24, []any{v22, v21}) + if lang.IsTruthy(tmp25) { + var tmp26 any + { // let + // let binding "agent" + tmp27, _ := lang.FieldOrMethod(v20, "nth") + if reflect.TypeOf(tmp27).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp28 := lang.Apply(tmp27, []any{v22}) + var v29 any = tmp28 + _ = v29 + tmp30 := checkDerefVar(glojure_DOT_core_send) + tmp31 := lang.Apply(tmp30, []any{v29, v15}) + _ = tmp31 + var tmp32 any = v19 + var tmp33 any = v20 + var tmp34 any = v21 + tmp36 := checkDerefVar(glojure_DOT_core_unchecked_inc) + tmp37 := lang.Apply(tmp36, []any{v22}) + var tmp35 any = tmp37 + v19 = tmp32 + v20 = tmp33 + v21 = tmp34 + v22 = tmp35 + continue + } // end let + tmp23 = tmp26 + } else { + var tmp27 any + { // let + // let binding "temp__0__auto__" + tmp28 := checkDerefVar(glojure_DOT_core_seq) + tmp29 := lang.Apply(tmp28, []any{v19}) + var v30 any = tmp29 + _ = v30 + var tmp31 any + if lang.IsTruthy(v30) { + var tmp32 any + { // let + // let binding "seq_5" + var v33 any = v30 + _ = v33 + var tmp34 any + tmp35 := checkDerefVar(glojure_DOT_core_chunked_seq_QMARK_) + tmp36 := lang.Apply(tmp35, []any{v33}) + if lang.IsTruthy(tmp36) { + var tmp37 any + { // let + // let binding "c__0__auto__" + tmp38 := checkDerefVar(glojure_DOT_core_chunk_first) + tmp39 := lang.Apply(tmp38, []any{v33}) + var v40 any = tmp39 + _ = v40 + tmp42 := checkDerefVar(glojure_DOT_core_chunk_rest) + tmp43 := lang.Apply(tmp42, []any{v33}) + var tmp41 any = tmp43 + var tmp44 any = v40 + tmp46 := checkDerefVar(glojure_DOT_core_int) + tmp47 := checkDerefVar(glojure_DOT_core_count) + tmp48 := lang.Apply(tmp47, []any{v40}) + tmp49 := lang.Apply(tmp46, []any{tmp48}) + var tmp45 any = tmp49 + tmp51 := checkDerefVar(glojure_DOT_core_int) + tmp52 := lang.Apply(tmp51, []any{int64(0)}) + var tmp50 any = tmp52 + v19 = tmp41 + v20 = tmp44 + v21 = tmp45 + v22 = tmp50 + continue + } // end let + tmp34 = tmp37 + } else { + var tmp38 any + { // let + // let binding "agent" + tmp39 := checkDerefVar(glojure_DOT_core_first) + tmp40 := lang.Apply(tmp39, []any{v33}) + var v41 any = tmp40 + _ = v41 + tmp42 := checkDerefVar(glojure_DOT_core_send) + tmp43 := lang.Apply(tmp42, []any{v41, v15}) + _ = tmp43 + tmp45 := checkDerefVar(glojure_DOT_core_next) + tmp46 := lang.Apply(tmp45, []any{v33}) + var tmp44 any = tmp46 + var tmp47 any = nil + var tmp48 any = int64(0) + var tmp49 any = int64(0) + v19 = tmp44 + v20 = tmp47 + v21 = tmp48 + v22 = tmp49 + continue + } // end let + tmp34 = tmp38 + } + tmp32 = tmp34 + } // end let + tmp31 = tmp32 + } else { + } + tmp27 = tmp31 + } // end let + tmp23 = tmp27 + } + tmp16 = tmp23 + break + } + } // end let + _ = tmp16 + tmp17, ok := lang.FieldOrMethod(nil, "MILLISECONDS") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "MILLISECONDS"))) + } + var tmp18 any + switch reflect.TypeOf(tmp17).Kind() { + case reflect.Func: + tmp18 = lang.Apply(tmp17, nil) + default: + tmp18 = tmp17 + } + tmp19, _ := lang.FieldOrMethod(v11, "await") + if reflect.TypeOf(tmp19).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) + } + tmp20 := lang.Apply(tmp19, []any{v3, tmp18}) + tmp10 = tmp20 + } // end let + tmp5 = tmp10 + } + return tmp5 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // await1 + { + tmp0 := lang.NewSymbol("await1").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3284), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3284), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(glojure_DOT_core_pos_QMARK_) + tmp6, ok := lang.FieldOrMethod(v3, "getQueueCount") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getQueueCount"))) + } + var tmp7 any + switch reflect.TypeOf(tmp6).Kind() { + case reflect.Func: + tmp7 = lang.Apply(tmp6, nil) + default: + tmp7 = tmp6 + } + tmp8 := lang.Apply(tmp5, []any{tmp7}) + if lang.IsTruthy(tmp8) { + tmp9 := checkDerefVar(glojure_DOT_core_await) + tmp10 := lang.Apply(tmp9, []any{v3}) + tmp4 = tmp10 + } else { + } + _ = tmp4 + return v3 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bases + { + tmp0 := lang.NewSymbol("bases").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"))), lang.NewKeyword("doc"), "Returns the immediate superclass and direct interfaces of c, if any", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5522), lang.NewKeyword("end-line"), int(5522))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + if lang.IsTruthy(v3) { + var tmp5 any + { // let + // let binding "i" + tmp6 := checkDerefVar(glojure_DOT_core_seq) + tmp7 := lang.Apply(tmp6, []any{nil}) + var v8 any = tmp7 + _ = v8 + // let binding "s" + var v9 any = nil + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + tmp11 := checkDerefVar(glojure_DOT_core_cons) + tmp12 := lang.Apply(tmp11, []any{v9, v8}) + tmp10 = tmp12 + } else { + tmp10 = v8 + } + tmp5 = tmp10 + } // end let + tmp4 = tmp5 + } else { + } + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bigdec + { + tmp1 := reflect.TypeOf((*lang.BigDecimal)(nil)) + tmp0 := lang.NewSymbol("bigdec").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Coerce to BigDecimal", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3648), lang.NewKeyword("end-line"), int(3648))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(glojure_DOT_core_decimal_QMARK_) + tmp7 := lang.Apply(tmp6, []any{v4}) + if lang.IsTruthy(tmp7) { + tmp5 = v4 + } else { + var tmp8 any + tmp9 := checkDerefVar(glojure_DOT_core_float_QMARK_) + tmp10 := lang.Apply(tmp9, []any{v4}) + if lang.IsTruthy(tmp10) { + tmp11 := checkDerefVar(glojure_DOT_core_double) + tmp12 := lang.Apply(tmp11, []any{v4}) + tmp13 := lang.Apply(lang.NewBigDecimalFromFloat64, []any{tmp12}) + tmp8 = tmp13 + } else { + var tmp14 any + tmp15 := checkDerefVar(glojure_DOT_core_ratio_QMARK_) + tmp16 := lang.Apply(tmp15, []any{v4}) + if lang.IsTruthy(tmp16) { + tmp17 := checkDerefVar(glojure_DOT_core__SLASH_) + tmp18 := lang.Apply(lang.NewBigDecimalFromRatio, []any{v4}) + tmp19, ok := lang.FieldOrMethod(v4, "denominator") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "denominator"))) + } + var tmp20 any + switch reflect.TypeOf(tmp19).Kind() { + case reflect.Func: + tmp20 = lang.Apply(tmp19, nil) + default: + tmp20 = tmp19 + } + tmp21 := lang.Apply(tmp17, []any{tmp18, tmp20}) + tmp14 = tmp21 + } else { + var tmp22 any + tmp23 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp24 := reflect.TypeOf((*lang.BigInt)(nil)) + tmp25 := lang.Apply(tmp23, []any{tmp24, v4}) + if lang.IsTruthy(tmp25) { + tmp26, ok := lang.FieldOrMethod(v4, "toBigDecimal") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "toBigDecimal"))) + } + var tmp27 any + switch reflect.TypeOf(tmp26).Kind() { + case reflect.Func: + tmp27 = lang.Apply(tmp26, nil) + default: + tmp27 = tmp26 + } + tmp22 = tmp27 + } else { + var tmp28 any + tmp29 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp30 := reflect.TypeOf((*big9.Int)(nil)) + tmp31 := lang.Apply(tmp29, []any{tmp30, v4}) + if lang.IsTruthy(tmp31) { + tmp32 := lang.Apply(lang.NewBigDecimal, []any{v4}) + tmp28 = tmp32 + } else { + var tmp33 any + tmp34 := checkDerefVar(glojure_DOT_core_number_QMARK_) + tmp35 := lang.Apply(tmp34, []any{v4}) + if lang.IsTruthy(tmp35) { + tmp36 := checkDerefVar(glojure_DOT_core_long) + tmp37 := lang.Apply(tmp36, []any{v4}) + tmp38 := lang.Apply(lang.NewBigDecimalFromInt64, []any{tmp37}) + tmp33 = tmp38 + } else { + var tmp39 any + if lang.IsTruthy(lang.NewKeyword("else")) { + tmp40 := lang.Apply(lang.NewBigDecimal, []any{v4}) + tmp39 = tmp40 + } else { + } + tmp33 = tmp39 + } + tmp28 = tmp33 + } + tmp22 = tmp28 + } + tmp14 = tmp22 + } + tmp8 = tmp14 + } + tmp5 = tmp8 + } + return tmp5 + }) + tmp4 := reflect.TypeOf((*lang.BigDecimal)(nil)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bigint + { + tmp1 := reflect.TypeOf((*lang.BigInt)(nil)) + tmp0 := lang.NewSymbol("bigint").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Coerce to BigInt", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3620), lang.NewKeyword("end-line"), int(3620))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp7 := reflect.TypeOf((*lang.BigInt)(nil)) + tmp8 := lang.Apply(tmp6, []any{tmp7, v4}) + if lang.IsTruthy(tmp8) { + tmp5 = v4 + } else { + var tmp9 any + tmp10 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp11 := reflect.TypeOf((*big9.Int)(nil)) + tmp12 := lang.Apply(tmp10, []any{tmp11, v4}) + if lang.IsTruthy(tmp12) { + tmp13 := lang.Apply(lang.NewBigIntFromGoBigInt, []any{v4}) + tmp9 = tmp13 + } else { + var tmp14 any + tmp15 := checkDerefVar(glojure_DOT_core_decimal_QMARK_) + tmp16 := lang.Apply(tmp15, []any{v4}) + if lang.IsTruthy(tmp16) { + tmp17 := checkDerefVar(glojure_DOT_core_bigint) + tmp18, ok := lang.FieldOrMethod(v4, "toBigInteger") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "toBigInteger"))) + } + var tmp19 any + switch reflect.TypeOf(tmp18).Kind() { + case reflect.Func: + tmp19 = lang.Apply(tmp18, nil) + default: + tmp19 = tmp18 + } + tmp20 := lang.Apply(tmp17, []any{tmp19}) + tmp14 = tmp20 + } else { + var tmp21 any + tmp22 := checkDerefVar(glojure_DOT_core_float_QMARK_) + tmp23 := lang.Apply(tmp22, []any{v4}) + if lang.IsTruthy(tmp23) { + tmp24 := checkDerefVar(glojure_DOT_core_bigint) + tmp25 := checkDerefVar(glojure_DOT_core_double) + tmp26 := lang.Apply(tmp25, []any{v4}) + tmp27 := lang.Apply(lang.NewBigDecimalFromFloat64, []any{tmp26}) + tmp28 := lang.Apply(tmp24, []any{tmp27}) + tmp21 = tmp28 + } else { + var tmp29 any + tmp30 := checkDerefVar(glojure_DOT_core_ratio_QMARK_) + tmp31 := lang.Apply(tmp30, []any{v4}) + if lang.IsTruthy(tmp31) { + tmp32 := checkDerefVar(glojure_DOT_core_bigint) + tmp33, ok := lang.FieldOrMethod(v4, "bigIntegerValue") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "bigIntegerValue"))) + } + var tmp34 any + switch reflect.TypeOf(tmp33).Kind() { + case reflect.Func: + tmp34 = lang.Apply(tmp33, nil) + default: + tmp34 = tmp33 + } + tmp35 := lang.Apply(tmp32, []any{tmp34}) + tmp29 = tmp35 + } else { + var tmp36 any + tmp37 := checkDerefVar(glojure_DOT_core_number_QMARK_) + tmp38 := lang.Apply(tmp37, []any{v4}) + if lang.IsTruthy(tmp38) { + tmp39 := checkDerefVar(glojure_DOT_core_long) + tmp40 := lang.Apply(tmp39, []any{v4}) + tmp41 := lang.Apply(lang.NewBigIntFromInt64, []any{tmp40}) + tmp36 = tmp41 + } else { + var tmp42 any + if lang.IsTruthy(lang.NewKeyword("else")) { + tmp43 := checkDerefVar(glojure_DOT_core_bigint) + tmp44 := lang.Apply(lang.NewBigInt, []any{v4}) + tmp45 := lang.Apply(tmp43, []any{tmp44}) + tmp42 = tmp45 + } else { + } + tmp36 = tmp42 + } + tmp29 = tmp36 + } + tmp21 = tmp29 + } + tmp14 = tmp21 + } + tmp9 = tmp14 + } + tmp5 = tmp9 + } + return tmp5 + }) + tmp4 := reflect.TypeOf((*lang.BigInt)(nil)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // biginteger + { + tmp1 := reflect.TypeOf((*big9.Int)(nil)) + tmp0 := lang.NewSymbol("biginteger").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Coerce to BigInteger", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3634), lang.NewKeyword("end-line"), int(3634))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp7 := reflect.TypeOf((*big9.Int)(nil)) + tmp8 := lang.Apply(tmp6, []any{tmp7, v4}) + if lang.IsTruthy(tmp8) { + tmp5 = v4 + } else { + var tmp9 any + tmp10 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp11 := reflect.TypeOf((*lang.BigInt)(nil)) + tmp12 := lang.Apply(tmp10, []any{tmp11, v4}) + if lang.IsTruthy(tmp12) { + tmp13, ok := lang.FieldOrMethod(v4, "toBigInteger") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "toBigInteger"))) + } + var tmp14 any + switch reflect.TypeOf(tmp13).Kind() { + case reflect.Func: + tmp14 = lang.Apply(tmp13, nil) + default: + tmp14 = tmp13 + } + tmp9 = tmp14 + } else { + var tmp15 any + tmp16 := checkDerefVar(glojure_DOT_core_decimal_QMARK_) + tmp17 := lang.Apply(tmp16, []any{v4}) + if lang.IsTruthy(tmp17) { + tmp18, ok := lang.FieldOrMethod(v4, "toBigInteger") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "toBigInteger"))) + } + var tmp19 any + switch reflect.TypeOf(tmp18).Kind() { + case reflect.Func: + tmp19 = lang.Apply(tmp18, nil) + default: + tmp19 = tmp18 + } + tmp15 = tmp19 + } else { + var tmp20 any + tmp21 := checkDerefVar(glojure_DOT_core_float_QMARK_) + tmp22 := lang.Apply(tmp21, []any{v4}) + if lang.IsTruthy(tmp22) { + tmp23 := checkDerefVar(glojure_DOT_core_double) + tmp24 := lang.Apply(tmp23, []any{v4}) + tmp25 := lang.Apply(lang.NewBigDecimalFromFloat64, []any{tmp24}) + tmp26, ok := lang.FieldOrMethod(tmp25, "toBigInteger") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp25, "toBigInteger"))) + } + var tmp27 any + switch reflect.TypeOf(tmp26).Kind() { + case reflect.Func: + tmp27 = lang.Apply(tmp26, nil) + default: + tmp27 = tmp26 + } + tmp20 = tmp27 + } else { + var tmp28 any + tmp29 := checkDerefVar(glojure_DOT_core_ratio_QMARK_) + tmp30 := lang.Apply(tmp29, []any{v4}) + if lang.IsTruthy(tmp30) { + tmp31, ok := lang.FieldOrMethod(v4, "bigIntegerValue") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "bigIntegerValue"))) + } + var tmp32 any + switch reflect.TypeOf(tmp31).Kind() { + case reflect.Func: + tmp32 = lang.Apply(tmp31, nil) + default: + tmp32 = tmp31 + } + tmp28 = tmp32 + } else { + var tmp33 any + tmp34 := checkDerefVar(glojure_DOT_core_number_QMARK_) + tmp35 := lang.Apply(tmp34, []any{v4}) + if lang.IsTruthy(tmp35) { + tmp36 := checkDerefVar(glojure_DOT_core_long) + tmp37 := lang.Apply(tmp36, []any{v4}) + tmp38 := lang.Apply(big9.NewInt, []any{tmp37}) + tmp33 = tmp38 + } else { + var tmp39 any + if lang.IsTruthy(lang.NewKeyword("else")) { + tmp40 := lang.Apply(lang.NewBigInt, []any{v4}) + tmp39 = tmp40 + } else { + } + tmp33 = tmp39 + } + tmp28 = tmp33 + } + tmp20 = tmp28 + } + tmp15 = tmp20 + } + tmp9 = tmp15 + } + tmp5 = tmp9 + } + return tmp5 + }) + tmp4 := reflect.TypeOf((*big9.Int)(nil)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // binding + { + tmp0 := lang.NewSymbol("binding").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "binding => var-symbol init-expr\n\n Creates new bindings for the (already-existing) vars, with the\n supplied initial values, executes the exprs in an implicit do, then\n re-establishes the bindings that existed before. The new bindings\n are made in parallel (unlike let); all init-exprs are evaluated\n before the vars are bound to their new values.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1945), lang.NewKeyword("end-line"), int(1945))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any + tmp8 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp9 := lang.Apply(tmp8, []any{v5}) + if lang.IsTruthy(tmp9) { + } else { + tmp10 := checkDerefVar(glojure_DOT_core_str) + tmp11 := checkDerefVar(glojure_DOT_core_first) + tmp12 := lang.Apply(tmp11, []any{v3}) + tmp13 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) + tmp14 := checkDerefVar(glojure_DOT_core_meta) + tmp15 := lang.Apply(tmp14, []any{v3}) + tmp16 := lang.Apply(lang.NewKeyword("line"), []any{tmp15}) + tmp17 := lang.Apply(tmp10, []any{tmp12, " requires ", "a vector for its binding", " in ", tmp13, ":", tmp16}) + tmp18 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp17}) + panic(tmp18) + } + _ = tmp7 + var tmp19 any + tmp20 := checkDerefVar(glojure_DOT_core_even_QMARK_) + tmp21 := checkDerefVar(glojure_DOT_core_count) + tmp22 := lang.Apply(tmp21, []any{v5}) + tmp23 := lang.Apply(tmp20, []any{tmp22}) + if lang.IsTruthy(tmp23) { + } else { + tmp24 := checkDerefVar(glojure_DOT_core_str) + tmp25 := checkDerefVar(glojure_DOT_core_first) + tmp26 := lang.Apply(tmp25, []any{v3}) + tmp27 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) + tmp28 := checkDerefVar(glojure_DOT_core_meta) + tmp29 := lang.Apply(tmp28, []any{v3}) + tmp30 := lang.Apply(lang.NewKeyword("line"), []any{tmp29}) + tmp31 := lang.Apply(tmp24, []any{tmp26, " requires ", "an even number of forms in binding vector", " in ", tmp27, ":", tmp30}) + tmp32 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp31}) + panic(tmp32) + } + _ = tmp19 + var tmp33 any + { // let + // let binding "var-ize" + var tmp34 lang.FnFunc + tmp34 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v35 := args[0] + _ = v35 + var tmp36 any + { // let + // let binding "ret" + tmp37 := lang.NewVector() + tmp38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1959), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(1959), lang.NewKeyword("end-column"), int(31)) + tmp39, err := lang.WithMeta(tmp37, tmp38.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v40 any = tmp39 + _ = v40 + // let binding "vvs" + tmp41 := checkDerefVar(glojure_DOT_core_seq) + tmp42 := lang.Apply(tmp41, []any{v35}) + var v43 any = tmp42 + _ = v43 + for { + var tmp44 any + if lang.IsTruthy(v43) { + tmp46 := checkDerefVar(glojure_DOT_core_conj) + tmp47 := checkDerefVar(glojure_DOT_core_conj) + tmp48 := checkDerefVar(glojure_DOT_core_seq) + tmp49 := checkDerefVar(glojure_DOT_core_concat) + tmp50 := checkDerefVar(glojure_DOT_core_list) + tmp51 := lang.Apply(tmp50, []any{lang.NewSymbol("var")}) + tmp52 := checkDerefVar(glojure_DOT_core_list) + tmp53 := checkDerefVar(glojure_DOT_core_first) + tmp54 := lang.Apply(tmp53, []any{v43}) + tmp55 := lang.Apply(tmp52, []any{tmp54}) + tmp56 := lang.Apply(tmp49, []any{tmp51, tmp55}) + tmp57 := lang.Apply(tmp48, []any{tmp56}) + tmp58 := lang.Apply(tmp47, []any{v40, tmp57}) + tmp59 := checkDerefVar(glojure_DOT_core_second) + tmp60 := lang.Apply(tmp59, []any{v43}) + tmp61 := lang.Apply(tmp46, []any{tmp58, tmp60}) + var tmp45 any = tmp61 + tmp63 := checkDerefVar(glojure_DOT_core_next) + tmp64 := checkDerefVar(glojure_DOT_core_next) + tmp65 := lang.Apply(tmp64, []any{v43}) + tmp66 := lang.Apply(tmp63, []any{tmp65}) + var tmp62 any = tmp66 + v40 = tmp45 + v43 = tmp62 + continue + } else { + tmp67 := checkDerefVar(glojure_DOT_core_seq) + tmp68 := lang.Apply(tmp67, []any{v40}) + tmp44 = tmp68 + } + tmp36 = tmp44 + break + } + } // end let + return tmp36 + }) + tmp35 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1958), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(1963), lang.NewKeyword("end-column"), int(34)) + tmp36, err := lang.WithMeta(tmp34, tmp35.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v37 any = tmp36 + _ = v37 + tmp38 := checkDerefVar(glojure_DOT_core_seq) + tmp39 := checkDerefVar(glojure_DOT_core_concat) + tmp40 := checkDerefVar(glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{lang.NewSymbol("glojure.core/let")}) + tmp42 := checkDerefVar(glojure_DOT_core_list) + tmp43 := checkDerefVar(glojure_DOT_core_apply) + tmp44 := checkDerefVar(glojure_DOT_core_vector) + tmp45 := checkDerefVar(glojure_DOT_core_seq) + tmp46 := checkDerefVar(glojure_DOT_core_concat) + tmp47 := lang.Apply(tmp46, nil) + tmp48 := lang.Apply(tmp45, []any{tmp47}) + tmp49 := lang.Apply(tmp43, []any{tmp44, tmp48}) + tmp50 := lang.Apply(tmp42, []any{tmp49}) + tmp51 := checkDerefVar(glojure_DOT_core_list) + tmp52 := checkDerefVar(glojure_DOT_core_seq) + tmp53 := checkDerefVar(glojure_DOT_core_concat) + tmp54 := checkDerefVar(glojure_DOT_core_list) + tmp55 := lang.Apply(tmp54, []any{lang.NewSymbol("glojure.core/push-thread-bindings")}) + tmp56 := checkDerefVar(glojure_DOT_core_list) + tmp57 := checkDerefVar(glojure_DOT_core_seq) + tmp58 := checkDerefVar(glojure_DOT_core_concat) + tmp59 := checkDerefVar(glojure_DOT_core_list) + tmp60 := lang.Apply(tmp59, []any{lang.NewSymbol("glojure.core/hash-map")}) + tmp61 := lang.Apply(v37, []any{v5}) + tmp62 := lang.Apply(tmp58, []any{tmp60, tmp61}) + tmp63 := lang.Apply(tmp57, []any{tmp62}) + tmp64 := lang.Apply(tmp56, []any{tmp63}) + tmp65 := lang.Apply(tmp53, []any{tmp55, tmp64}) + tmp66 := lang.Apply(tmp52, []any{tmp65}) + tmp67 := lang.Apply(tmp51, []any{tmp66}) + tmp68 := checkDerefVar(glojure_DOT_core_list) + tmp69 := checkDerefVar(glojure_DOT_core_seq) + tmp70 := checkDerefVar(glojure_DOT_core_concat) + tmp71 := checkDerefVar(glojure_DOT_core_list) + tmp72 := lang.Apply(tmp71, []any{lang.NewSymbol("try")}) + tmp73 := checkDerefVar(glojure_DOT_core_list) + tmp74 := checkDerefVar(glojure_DOT_core_seq) + tmp75 := checkDerefVar(glojure_DOT_core_concat) + tmp76 := checkDerefVar(glojure_DOT_core_list) + tmp77 := lang.Apply(tmp76, []any{lang.NewSymbol("finally")}) + tmp78 := checkDerefVar(glojure_DOT_core_list) + tmp79 := checkDerefVar(glojure_DOT_core_seq) + tmp80 := checkDerefVar(glojure_DOT_core_concat) + tmp81 := checkDerefVar(glojure_DOT_core_list) + tmp82 := lang.Apply(tmp81, []any{lang.NewSymbol("glojure.core/pop-thread-bindings")}) + tmp83 := lang.Apply(tmp80, []any{tmp82}) + tmp84 := lang.Apply(tmp79, []any{tmp83}) + tmp85 := lang.Apply(tmp78, []any{tmp84}) + tmp86 := lang.Apply(tmp75, []any{tmp77, tmp85}) + tmp87 := lang.Apply(tmp74, []any{tmp86}) + tmp88 := lang.Apply(tmp73, []any{tmp87}) + tmp89 := lang.Apply(tmp70, []any{tmp72, v6, tmp88}) + tmp90 := lang.Apply(tmp69, []any{tmp89}) + tmp91 := lang.Apply(tmp68, []any{tmp90}) + tmp92 := lang.Apply(tmp39, []any{tmp41, tmp50, tmp67, tmp91}) + tmp93 := lang.Apply(tmp38, []any{tmp92}) + tmp33 = tmp93 + } // end let + return tmp33 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // binding-conveyor-fn + { + tmp0 := lang.NewSymbol("binding-conveyor-fn").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2020), lang.NewKeyword("end-line"), int(2020), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + { // let + // let binding "frame" + tmp5 := lang.Apply(lang.CloneThreadBindingFrame, nil) + var v6 any = tmp5 + _ = v6 + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp8 := lang.Apply(lang.ResetThreadBindingFrame, []any{v6}) + _ = tmp8 + tmp9 := lang.Apply(v3, nil) + return tmp9 + case 1: + v8 := args[0] + _ = v8 + tmp9 := lang.Apply(lang.ResetThreadBindingFrame, []any{v6}) + _ = tmp9 + tmp10 := lang.Apply(v3, []any{v8}) + return tmp10 + case 2: + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + tmp10 := lang.Apply(lang.ResetThreadBindingFrame, []any{v6}) + _ = tmp10 + tmp11 := lang.Apply(v3, []any{v8, v9}) + return tmp11 + case 3: + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + v10 := args[2] + _ = v10 + tmp11 := lang.Apply(lang.ResetThreadBindingFrame, []any{v6}) + _ = tmp11 + tmp12 := lang.Apply(v3, []any{v8, v9, v10}) + return tmp12 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + v10 := args[2] + _ = v10 + var v11 any = lang.NewList(args[3:]...) + _ = v11 + tmp12 := lang.Apply(lang.ResetThreadBindingFrame, []any{v6}) + _ = tmp12 + tmp13 := checkDerefVar(glojure_DOT_core_apply) + tmp14 := lang.Apply(tmp13, []any{v3, v8, v9, v10, v11}) + return tmp14 + } + }) + tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2025), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2040), lang.NewKeyword("end-column"), int(31)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp4 = tmp9 + } // end let + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bit-and + { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed29 + } else { + tmp4 = closed29 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_seq) + tmp8 := checkDerefVar(glojure_DOT_core_concat) + tmp9 := checkDerefVar(glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol(".")}) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := checkDerefVar(glojure_DOT_core_seq) + tmp15 := checkDerefVar(glojure_DOT_core_concat) + tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed29 + } else { + tmp5 = closed29 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(glojure_DOT_core_seq) + tmp9 := checkDerefVar(glojure_DOT_core_concat) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol(".")}) + tmp12 := checkDerefVar(glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp14 := checkDerefVar(glojure_DOT_core_list) + tmp15 := checkDerefVar(glojure_DOT_core_seq) + tmp16 := checkDerefVar(glojure_DOT_core_concat) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed29 + } else { + tmp6 = closed29 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(glojure_DOT_core_seq) + tmp14 := checkDerefVar(glojure_DOT_core_concat) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := checkDerefVar(glojure_DOT_core_seq) + tmp21 := checkDerefVar(glojure_DOT_core_concat) + tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(glojure_DOT_core_seq) + tmp14 := checkDerefVar(glojure_DOT_core_concat) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := checkDerefVar(glojure_DOT_core_seq) + tmp21 := checkDerefVar(glojure_DOT_core_concat) + tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp0 := lang.NewSymbol("bit-and").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Bitwise and", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), tmp2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1298), lang.NewKeyword("end-line"), int(1298))).(*lang.Symbol) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + tmp7, _ := lang.FieldOrMethod(lang.Numbers, "And") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("And is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v5, v6}) + return tmp8 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + var v7 any = lang.NewList(args[2:]...) + _ = v7 + tmp8 := checkDerefVar(glojure_DOT_core_reduce1) + tmp9 := checkDerefVar(glojure_DOT_core_bit_and) + tmp10 := checkDerefVar(glojure_DOT_core_bit_and) + tmp11 := lang.Apply(tmp10, []any{v5, v6}) + tmp12 := lang.Apply(tmp8, []any{tmp9, tmp11, v7}) + return tmp12 + } + }) + tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 := ns.InternWithValue(tmp0, tmp4, true) + if tmp0.Meta() != nil { + tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bit-and-not + { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed30 + } else { + tmp4 = closed30 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_seq) + tmp8 := checkDerefVar(glojure_DOT_core_concat) + tmp9 := checkDerefVar(glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol(".")}) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := checkDerefVar(glojure_DOT_core_seq) + tmp15 := checkDerefVar(glojure_DOT_core_concat) + tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed30 + } else { + tmp5 = closed30 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(glojure_DOT_core_seq) + tmp9 := checkDerefVar(glojure_DOT_core_concat) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol(".")}) + tmp12 := checkDerefVar(glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp14 := checkDerefVar(glojure_DOT_core_list) + tmp15 := checkDerefVar(glojure_DOT_core_seq) + tmp16 := checkDerefVar(glojure_DOT_core_concat) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed30 + } else { + tmp6 = closed30 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(glojure_DOT_core_seq) + tmp14 := checkDerefVar(glojure_DOT_core_concat) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := checkDerefVar(glojure_DOT_core_seq) + tmp21 := checkDerefVar(glojure_DOT_core_concat) + tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(glojure_DOT_core_seq) + tmp14 := checkDerefVar(glojure_DOT_core_concat) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := checkDerefVar(glojure_DOT_core_seq) + tmp21 := checkDerefVar(glojure_DOT_core_concat) + tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp0 := lang.NewSymbol("bit-and-not").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Bitwise and with complement", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), tmp2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1325), lang.NewKeyword("end-line"), int(1325))).(*lang.Symbol) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + tmp7, _ := lang.FieldOrMethod(lang.Numbers, "AndNot") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("AndNot is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v5, v6}) + return tmp8 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + var v7 any = lang.NewList(args[2:]...) + _ = v7 + tmp8 := checkDerefVar(glojure_DOT_core_reduce1) + tmp9 := checkDerefVar(glojure_DOT_core_bit_and_not) + tmp10 := checkDerefVar(glojure_DOT_core_bit_and_not) + tmp11 := lang.Apply(tmp10, []any{v5, v6}) + tmp12 := lang.Apply(tmp8, []any{tmp9, tmp11, v7}) + return tmp12 + } + }) + tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 := ns.InternWithValue(tmp0, tmp4, true) + if tmp0.Meta() != nil { + tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bit-clear + { + tmp0 := lang.NewSymbol("bit-clear").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Clear bit at index n", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1336), lang.NewKeyword("end-line"), int(1336))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "ClearBit") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ClearBit is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bit-flip + { + tmp0 := lang.NewSymbol("bit-flip").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Flip bit at index n", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1348), lang.NewKeyword("end-line"), int(1348))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "FlipBit") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("FlipBit is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bit-not + { + var tmp1 lang.FnFunc + { // function bit-not__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := checkDerefVar(glojure_DOT_core_seq) + tmp12 := checkDerefVar(glojure_DOT_core_concat) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/Not")}) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("bit-not").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Bitwise complement", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1291), lang.NewKeyword("end-line"), int(1291))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Not") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Not is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bit-or + { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed31 + } else { + tmp4 = closed31 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_seq) + tmp8 := checkDerefVar(glojure_DOT_core_concat) + tmp9 := checkDerefVar(glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol(".")}) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := checkDerefVar(glojure_DOT_core_seq) + tmp15 := checkDerefVar(glojure_DOT_core_concat) + tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed31 + } else { + tmp5 = closed31 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(glojure_DOT_core_seq) + tmp9 := checkDerefVar(glojure_DOT_core_concat) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol(".")}) + tmp12 := checkDerefVar(glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp14 := checkDerefVar(glojure_DOT_core_list) + tmp15 := checkDerefVar(glojure_DOT_core_seq) + tmp16 := checkDerefVar(glojure_DOT_core_concat) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed31 + } else { + tmp6 = closed31 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(glojure_DOT_core_seq) + tmp14 := checkDerefVar(glojure_DOT_core_concat) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := checkDerefVar(glojure_DOT_core_seq) + tmp21 := checkDerefVar(glojure_DOT_core_concat) + tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(glojure_DOT_core_seq) + tmp14 := checkDerefVar(glojure_DOT_core_concat) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := checkDerefVar(glojure_DOT_core_seq) + tmp21 := checkDerefVar(glojure_DOT_core_concat) + tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp0 := lang.NewSymbol("bit-or").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Bitwise or", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), tmp2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1307), lang.NewKeyword("end-line"), int(1307))).(*lang.Symbol) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + tmp7, _ := lang.FieldOrMethod(lang.Numbers, "Or") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Or is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v5, v6}) + return tmp8 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + var v7 any = lang.NewList(args[2:]...) + _ = v7 + tmp8 := checkDerefVar(glojure_DOT_core_reduce1) + tmp9 := checkDerefVar(glojure_DOT_core_bit_or) + tmp10 := checkDerefVar(glojure_DOT_core_bit_or) + tmp11 := lang.Apply(tmp10, []any{v5, v6}) + tmp12 := lang.Apply(tmp8, []any{tmp9, tmp11, v7}) + return tmp12 + } + }) + tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 := ns.InternWithValue(tmp0, tmp4, true) + if tmp0.Meta() != nil { + tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bit-set + { + tmp0 := lang.NewSymbol("bit-set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Set bit at index n", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1342), lang.NewKeyword("end-line"), int(1342))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "SetBit") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("SetBit is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bit-shift-left + { + var tmp1 lang.FnFunc + { // function bit-shift-left__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_seq) + tmp6 := checkDerefVar(glojure_DOT_core_concat) + tmp7 := checkDerefVar(glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{lang.NewSymbol(".")}) + tmp9 := checkDerefVar(glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := checkDerefVar(glojure_DOT_core_seq) + tmp13 := checkDerefVar(glojure_DOT_core_concat) + tmp14 := checkDerefVar(glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("glojure.core/ShiftLeft")}) + tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("bit-shift-left").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Bitwise shift left", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1361), lang.NewKeyword("end-line"), int(1361))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "ShiftLeft") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ShiftLeft is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bit-shift-right + { + var tmp1 lang.FnFunc + { // function bit-shift-right__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_seq) + tmp6 := checkDerefVar(glojure_DOT_core_concat) + tmp7 := checkDerefVar(glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{lang.NewSymbol(".")}) + tmp9 := checkDerefVar(glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := checkDerefVar(glojure_DOT_core_seq) + tmp13 := checkDerefVar(glojure_DOT_core_concat) + tmp14 := checkDerefVar(glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("glojure.core/ShiftRight")}) + tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("bit-shift-right").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Bitwise shift right", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1367), lang.NewKeyword("end-line"), int(1367))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "ShiftRight") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ShiftRight is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bit-test + { + tmp0 := lang.NewSymbol("bit-test").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Test bit at index n", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1354), lang.NewKeyword("end-line"), int(1354))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "TestBit") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("TestBit is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bit-xor + { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed32 + } else { + tmp4 = closed32 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_seq) + tmp8 := checkDerefVar(glojure_DOT_core_concat) + tmp9 := checkDerefVar(glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol(".")}) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := checkDerefVar(glojure_DOT_core_seq) + tmp15 := checkDerefVar(glojure_DOT_core_concat) + tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed32 + } else { + tmp5 = closed32 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(glojure_DOT_core_seq) + tmp9 := checkDerefVar(glojure_DOT_core_concat) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol(".")}) + tmp12 := checkDerefVar(glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp14 := checkDerefVar(glojure_DOT_core_list) + tmp15 := checkDerefVar(glojure_DOT_core_seq) + tmp16 := checkDerefVar(glojure_DOT_core_concat) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed32 + } else { + tmp6 = closed32 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(glojure_DOT_core_seq) + tmp14 := checkDerefVar(glojure_DOT_core_concat) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := checkDerefVar(glojure_DOT_core_seq) + tmp21 := checkDerefVar(glojure_DOT_core_concat) + tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(glojure_DOT_core_seq) + tmp14 := checkDerefVar(glojure_DOT_core_concat) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := checkDerefVar(glojure_DOT_core_seq) + tmp21 := checkDerefVar(glojure_DOT_core_concat) + tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp0 := lang.NewSymbol("bit-xor").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Bitwise exclusive or", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), tmp2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1316), lang.NewKeyword("end-line"), int(1316))).(*lang.Symbol) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + tmp7, _ := lang.FieldOrMethod(lang.Numbers, "Xor") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Xor is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v5, v6}) + return tmp8 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + var v7 any = lang.NewList(args[2:]...) + _ = v7 + tmp8 := checkDerefVar(glojure_DOT_core_reduce1) + tmp9 := checkDerefVar(glojure_DOT_core_bit_xor) + tmp10 := checkDerefVar(glojure_DOT_core_bit_xor) + tmp11 := lang.Apply(tmp10, []any{v5, v6}) + tmp12 := lang.Apply(tmp8, []any{tmp9, tmp11, v7}) + return tmp12 + } + }) + tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 := ns.InternWithValue(tmp0, tmp4, true) + if tmp0.Meta() != nil { + tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // boolean + { + var tmp1 lang.FnFunc + { // function boolean__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := checkDerefVar(glojure_DOT_core_seq) + tmp12 := checkDerefVar(glojure_DOT_core_concat) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/BooleanCast")}) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("boolean").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to boolean", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1601), lang.NewKeyword("end-line"), int(1601))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5, _ := lang.FieldOrMethod(runtime7.RT, "BooleanCast") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("BooleanCast is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // boolean-array + { + var tmp1 lang.FnFunc + { // function boolean-array__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol("glojure.core/BooleanArray")}) + tmp12 := checkDerefVar(glojure_DOT_core_list) + tmp13 := checkDerefVar(glojure_DOT_core_seq) + tmp14 := checkDerefVar(glojure_DOT_core_concat) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("glojure.core/args")}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + } + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("boolean-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Creates an array of booleans", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5309), lang.NewKeyword("end-line"), int(5309))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "BooleanArray") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("BooleanArray is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "BooleanArrayInit") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("BooleanArrayInit is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // boolean? + { + tmp0 := lang.NewSymbol("boolean?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a Boolean", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(518), lang.NewKeyword("end-line"), int(518))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp5 := lang.Apply(tmp4, []any{lang.Builtins["bool"], v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // booleans + { + var tmp1 lang.FnFunc + { // function booleans + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol("glojure.core/Booleans")}) + tmp12 := checkDerefVar(glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("booleans").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Casts to boolean[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5372), lang.NewKeyword("end-line"), int(5372))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Booleans") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Booleans is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bound-fn + { + tmp0 := lang.NewSymbol("bound-fn").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("fntail"))), lang.NewKeyword("doc"), "Returns a function defined by the given fntail, which will install the\n same bindings in effect as in the thread at the time bound-fn was called.\n This may be used to define a helper function which runs on a different\n thread, but needs the same bindings in place.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(2004), lang.NewKeyword("end-line"), int(2004))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := checkDerefVar(glojure_DOT_core_seq) + tmp7 := checkDerefVar(glojure_DOT_core_concat) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("glojure.core/bound-fn*")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := checkDerefVar(glojure_DOT_core_seq) + tmp12 := checkDerefVar(glojure_DOT_core_concat) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/fn")}) + tmp15 := lang.Apply(tmp12, []any{tmp14, v5}) + tmp16 := lang.Apply(tmp11, []any{tmp15}) + tmp17 := lang.Apply(tmp10, []any{tmp16}) + tmp18 := lang.Apply(tmp7, []any{tmp9, tmp17}) + tmp19 := lang.Apply(tmp6, []any{tmp18}) + return tmp19 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bound-fn* + { + tmp0 := lang.NewSymbol("bound-fn*").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Returns a function, which will install the same bindings in effect as in\n the thread at the time bound-fn* was called and then call f with any given\n arguments. This may be used to define a helper function which runs on a\n different thread, but needs the same bindings in place.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1992), lang.NewKeyword("end-line"), int(1992))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + { // let + // let binding "bindings" + tmp5 := checkDerefVar(glojure_DOT_core_get_thread_bindings) + tmp6 := lang.Apply(tmp5, nil) + var v7 any = tmp6 + _ = v7 + var tmp8 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v9 any = lang.NewList(args[0:]...) + _ = v9 + tmp10 := checkDerefVar(glojure_DOT_core_apply) + tmp11 := checkDerefVar(glojure_DOT_core_with_bindings_STAR_) + tmp12 := lang.Apply(tmp10, []any{tmp11, v7, v3, v9}) + return tmp12 + } + }) + tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2001), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2002), lang.NewKeyword("end-column"), int(45)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp4 = tmp10 + } // end let + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bound? + { + tmp0 := lang.NewSymbol("bound?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("vars"))), lang.NewKeyword("doc"), "Returns true if all of the vars provided as arguments have any bound value, root or thread-local.\n Implies that deref'ing the provided vars will succeed. Returns true if no vars are provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5491), lang.NewKeyword("end-line"), int(5491))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_every_QMARK_) + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v6 := args[0] + _ = v6 + tmp7, ok := lang.FieldOrMethod(v6, "isBound") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "isBound"))) + } + var tmp8 any + switch reflect.TypeOf(tmp7).Kind() { + case reflect.Func: + tmp8 = lang.Apply(tmp7, nil) + default: + tmp8 = tmp7 + } + return tmp8 + }) + tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5497), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5497), lang.NewKeyword("end-column"), int(69)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp8 := lang.Apply(tmp4, []any{tmp7, v3}) + return tmp8 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bounded-count + { + tmp0 := lang.NewSymbol("bounded-count").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "If coll is counted? returns its count, else will count at most the first n\n elements of coll using its seq", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7410), lang.NewKeyword("end-line"), int(7410))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(glojure_DOT_core_counted_QMARK_) + tmp7 := lang.Apply(tmp6, []any{v4}) + if lang.IsTruthy(tmp7) { + tmp8 := checkDerefVar(glojure_DOT_core_count) + tmp9 := lang.Apply(tmp8, []any{v4}) + tmp5 = tmp9 + } else { + var tmp10 any + { // let + // let binding "i" + var v11 any = int64(0) + _ = v11 + // let binding "s" + tmp12 := checkDerefVar(glojure_DOT_core_seq) + tmp13 := lang.Apply(tmp12, []any{v4}) + var v14 any = tmp13 + _ = v14 + for { + var tmp15 any + var tmp16 any + { // let + // let binding "and__0__auto__" + var v17 any = v14 + _ = v17 + var tmp18 any + if lang.IsTruthy(v17) { + tmp19 := checkDerefVar(glojure_DOT_core__LT_) + tmp20 := lang.Apply(tmp19, []any{v11, v3}) + tmp18 = tmp20 + } else { + tmp18 = v17 + } + tmp16 = tmp18 + } // end let + if lang.IsTruthy(tmp16) { + tmp18 := checkDerefVar(glojure_DOT_core_inc) + tmp19 := lang.Apply(tmp18, []any{v11}) + var tmp17 any = tmp19 + tmp21 := checkDerefVar(glojure_DOT_core_next) + tmp22 := lang.Apply(tmp21, []any{v14}) + var tmp20 any = tmp22 + v11 = tmp17 + v14 = tmp20 + continue + } else { + tmp15 = v11 + } + tmp10 = tmp15 + break + } + } // end let + tmp5 = tmp10 + } + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // butlast + { + tmp0 := lang.NewSymbol("butlast").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return a seq of all but the last item in coll, in linear time", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(272), lang.NewKeyword("end-line"), int(276))).(*lang.Symbol) + var tmp2 lang.FnFunc + { // function butlast + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + var tmp5 any + { // let + // let binding "ret" + tmp6 := lang.NewVector() + tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(277), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(277), lang.NewKeyword("end-column"), int(24)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v9 any = tmp8 + _ = v9 + // let binding "s" + var v10 any = v4 + _ = v10 + for { + var tmp11 any + tmp12 := checkDerefVar(glojure_DOT_core_next) + tmp13 := lang.Apply(tmp12, []any{v10}) + if lang.IsTruthy(tmp13) { + tmp15 := checkDerefVar(glojure_DOT_core_conj) + tmp16 := checkDerefVar(glojure_DOT_core_first) + tmp17 := lang.Apply(tmp16, []any{v10}) + tmp18 := lang.Apply(tmp15, []any{v9, tmp17}) + var tmp14 any = tmp18 + tmp20 := checkDerefVar(glojure_DOT_core_next) + tmp21 := lang.Apply(tmp20, []any{v10}) + var tmp19 any = tmp21 + v9 = tmp14 + v10 = tmp19 + continue + } else { + tmp22 := checkDerefVar(glojure_DOT_core_seq) + tmp23 := lang.Apply(tmp22, []any{v9}) + tmp11 = tmp23 + } + tmp5 = tmp11 + break + } + } // end let + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(276), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(280), lang.NewKeyword("end-column"), int(27))).(lang.FnFunc) + v3 = tmp2 + _ = v3 + } + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // byte + { + var tmp1 lang.FnFunc + { // function byte__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := checkDerefVar(glojure_DOT_core_seq) + tmp12 := checkDerefVar(glojure_DOT_core_concat) + tmp13 := checkDerefVar(glojure_DOT_core_list) + var tmp14 any + tmp15 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + if lang.IsTruthy(tmp15) { + tmp14 = lang.NewSymbol("uncheckedByteCast") + } else { + tmp14 = lang.NewSymbol("byteCast") + } + tmp16 := lang.Apply(tmp13, []any{tmp14}) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := lang.Apply(tmp12, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp11, []any{tmp19}) + tmp21 := lang.Apply(tmp10, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("byte").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to byte", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3505), lang.NewKeyword("end-line"), int(3505))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5 := lang.Apply(lang.ByteCast, []any{v4}) + return tmp5 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // byte-array + { + var tmp1 lang.FnFunc + { // function byte-array__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol("glojure.core/ByteArray")}) + tmp12 := checkDerefVar(glojure_DOT_core_list) + tmp13 := checkDerefVar(glojure_DOT_core_seq) + tmp14 := checkDerefVar(glojure_DOT_core_concat) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("glojure.core/args")}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + } + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("byte-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Creates an array of bytes", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5317), lang.NewKeyword("end-line"), int(5317))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "ByteArray") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ByteArray is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "ByteArrayInit") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ByteArrayInit is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bytes + { + var tmp1 lang.FnFunc + { // function bytes + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol("glojure.core/Bytes")}) + tmp12 := checkDerefVar(glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("bytes").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Casts to bytes[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5377), lang.NewKeyword("end-line"), int(5377))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Bytes") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Bytes is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bytes? + { + tmp0 := lang.NewSymbol("bytes?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a byte array", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5412), lang.NewKeyword("end-line"), int(5412))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + tmp4 = false + } else { + tmp7 := checkDerefVar(glojure_DOT_core__EQ_) + tmp8 := checkDerefVar(glojure_DOT_core_class) + tmp9 := lang.Apply(tmp8, []any{v3}) + tmp10, ok := lang.FieldOrMethod(tmp9, "getComponentType") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp9, "getComponentType"))) + } + var tmp11 any + switch reflect.TypeOf(tmp10).Kind() { + case reflect.Func: + tmp11 = lang.Apply(tmp10, nil) + default: + tmp11 = tmp10 + } + tmp12 := lang.Apply(tmp7, []any{tmp11, nil}) + tmp4 = tmp12 + } + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // case + { + tmp0 := lang.NewSymbol("case").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("e"), lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes an expression, and a set of clauses.\n\n Each clause can take the form of either:\n\n test-constant result-expr\n\n (test-constant1 ... test-constantN) result-expr\n\n The test-constants are not evaluated. They must be compile-time\n literals, and need not be quoted. If the expression is equal to a\n test-constant, the corresponding result-expr is returned. A single\n default expression can follow the clauses, and its value will be\n returned if no clause matches. If no default expression is provided\n and no clause matches, an IllegalArgumentException is thrown.\n\n Unlike cond and condp, case does a constant-time dispatch, the\n clauses are not considered sequentially. All manner of constant\n expressions are acceptable in case, including numbers, strings,\n symbols, keywords, and (Clojure) composites thereof. Note that since\n lists are used to group multiple constants that map to the same\n expression, a vector can be used to match a list if needed. The\n test-constants need not be all of the same type.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6712), lang.NewKeyword("end-line"), int(6712))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any + { // let + // let binding "ge" + tmp8 := checkDerefVar(glojure_DOT_core_with_meta) + tmp9 := checkDerefVar(glojure_DOT_core_gensym) + tmp10 := lang.Apply(tmp9, nil) + tmp11 := reflect.TypeOf((*lang.Object)(nil)).Elem() + tmp12 := lang.NewMap(lang.NewKeyword("tag"), tmp11) + tmp13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6738), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(6738), lang.NewKeyword("end-column"), int(84)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp15 := lang.Apply(tmp8, []any{tmp10, tmp14}) + var v16 any = tmp15 + _ = v16 + // let binding "default" + var tmp17 any + tmp18 := checkDerefVar(glojure_DOT_core_odd_QMARK_) + tmp19 := checkDerefVar(glojure_DOT_core_count) + tmp20 := lang.Apply(tmp19, []any{v6}) + tmp21 := lang.Apply(tmp18, []any{tmp20}) + if lang.IsTruthy(tmp21) { + tmp22 := checkDerefVar(glojure_DOT_core_last) + tmp23 := lang.Apply(tmp22, []any{v6}) + tmp17 = tmp23 + } else { + tmp24 := checkDerefVar(glojure_DOT_core_seq) + tmp25 := checkDerefVar(glojure_DOT_core_concat) + tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{lang.NewSymbol("throw")}) + tmp28 := checkDerefVar(glojure_DOT_core_list) + tmp29 := checkDerefVar(glojure_DOT_core_seq) + tmp30 := checkDerefVar(glojure_DOT_core_concat) + tmp31 := checkDerefVar(glojure_DOT_core_list) + tmp32 := lang.Apply(tmp31, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewIllegalArgumentError")}) + tmp33 := checkDerefVar(glojure_DOT_core_list) + tmp34 := checkDerefVar(glojure_DOT_core_seq) + tmp35 := checkDerefVar(glojure_DOT_core_concat) + tmp36 := checkDerefVar(glojure_DOT_core_list) + tmp37 := lang.Apply(tmp36, []any{lang.NewSymbol("glojure.core/str")}) + tmp38 := checkDerefVar(glojure_DOT_core_list) + tmp39 := lang.Apply(tmp38, []any{"No matching clause: "}) + tmp40 := checkDerefVar(glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{v16}) + tmp42 := lang.Apply(tmp35, []any{tmp37, tmp39, tmp41}) + tmp43 := lang.Apply(tmp34, []any{tmp42}) + tmp44 := lang.Apply(tmp33, []any{tmp43}) + tmp45 := lang.Apply(tmp30, []any{tmp32, tmp44}) + tmp46 := lang.Apply(tmp29, []any{tmp45}) + tmp47 := lang.Apply(tmp28, []any{tmp46}) + tmp48 := lang.Apply(tmp25, []any{tmp27, tmp47}) + tmp49 := lang.Apply(tmp24, []any{tmp48}) + tmp17 = tmp49 + } + var v50 any = tmp17 + _ = v50 + var tmp51 any + tmp52 := checkDerefVar(glojure_DOT_core__GT_) + tmp53 := checkDerefVar(glojure_DOT_core_count) + tmp54 := lang.Apply(tmp53, []any{v6}) + tmp55 := lang.Apply(tmp52, []any{int64(2), tmp54}) + if lang.IsTruthy(tmp55) { + tmp56 := checkDerefVar(glojure_DOT_core_seq) + tmp57 := checkDerefVar(glojure_DOT_core_concat) + tmp58 := checkDerefVar(glojure_DOT_core_list) + tmp59 := lang.Apply(tmp58, []any{lang.NewSymbol("glojure.core/let")}) + tmp60 := checkDerefVar(glojure_DOT_core_list) + tmp61 := checkDerefVar(glojure_DOT_core_apply) + tmp62 := checkDerefVar(glojure_DOT_core_vector) + tmp63 := checkDerefVar(glojure_DOT_core_seq) + tmp64 := checkDerefVar(glojure_DOT_core_concat) + tmp65 := checkDerefVar(glojure_DOT_core_list) + tmp66 := lang.Apply(tmp65, []any{v16}) + tmp67 := checkDerefVar(glojure_DOT_core_list) + tmp68 := lang.Apply(tmp67, []any{v5}) + tmp69 := lang.Apply(tmp64, []any{tmp66, tmp68}) + tmp70 := lang.Apply(tmp63, []any{tmp69}) + tmp71 := lang.Apply(tmp61, []any{tmp62, tmp70}) + tmp72 := lang.Apply(tmp60, []any{tmp71}) + tmp73 := checkDerefVar(glojure_DOT_core_list) + tmp74 := lang.Apply(tmp73, []any{v50}) + tmp75 := lang.Apply(tmp57, []any{tmp59, tmp72, tmp74}) + tmp76 := lang.Apply(tmp56, []any{tmp75}) + tmp51 = tmp76 + } else { + var tmp77 any + { // let + // let binding "pairs" + tmp78 := checkDerefVar(glojure_DOT_core_partition) + tmp79 := lang.Apply(tmp78, []any{int64(2), v6}) + var v80 any = tmp79 + _ = v80 + // let binding "assoc-test" + var tmp81 lang.FnFunc + { // function assoc-test + var v82 lang.FnFunc + tmp81 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v83 := args[0] + _ = v83 + v84 := args[1] + _ = v84 + v85 := args[2] + _ = v85 + var tmp86 any + tmp87 := checkDerefVar(glojure_DOT_core_contains_QMARK_) + tmp88 := lang.Apply(tmp87, []any{v83, v84}) + if lang.IsTruthy(tmp88) { + tmp89 := checkDerefVar(glojure_DOT_core_str) + tmp90 := lang.Apply(tmp89, []any{"Duplicate case test constant: ", v84}) + tmp91 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp90}) + panic(tmp91) + } else { + tmp92 := checkDerefVar(glojure_DOT_core_assoc) + tmp93 := lang.Apply(tmp92, []any{v83, v84, v85}) + tmp86 = tmp93 + } + return tmp86 + }) + v82 = tmp81 + _ = v82 + } + tmp82 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6745), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(6748), lang.NewKeyword("end-column"), int(48)) + tmp83, err := lang.WithMeta(tmp81, tmp82.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v84 any = tmp83 + _ = v84 + // let binding "pairs" + tmp85 := checkDerefVar(glojure_DOT_core_reduce1) + var tmp86 lang.FnFunc + tmp86 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v87 := args[0] + _ = v87 + v88 := args[1] + _ = v88 + var tmp89 any + { // let + // let binding "vec__177" + var v90 any = v88 + _ = v90 + // let binding "test" + tmp91 := checkDerefVar(glojure_DOT_core_nth) + tmp92 := lang.Apply(tmp91, []any{v90, int64(0), nil}) + var v93 any = tmp92 + _ = v93 + // let binding "expr" + tmp94 := checkDerefVar(glojure_DOT_core_nth) + tmp95 := lang.Apply(tmp94, []any{v90, int64(1), nil}) + var v96 any = tmp95 + _ = v96 + var tmp97 any + tmp98 := checkDerefVar(glojure_DOT_core_seq_QMARK_) + tmp99 := lang.Apply(tmp98, []any{v93}) + if lang.IsTruthy(tmp99) { + tmp100 := checkDerefVar(glojure_DOT_core_reduce1) + var tmp101 lang.FnFunc + tmp101 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v102 := args[0] + _ = v102 + v103 := args[1] + _ = v103 + tmp104 := lang.Apply(v84, []any{v102, v103, v96}) + return tmp104 + }) + tmp102 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6752), lang.NewKeyword("column"), int(37), lang.NewKeyword("end-line"), int(6752), lang.NewKeyword("end-column"), int(60)) + tmp103, err := lang.WithMeta(tmp101, tmp102.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp104 := lang.Apply(tmp100, []any{tmp103, v87, v93}) + tmp97 = tmp104 + } else { + tmp105 := lang.Apply(v84, []any{v87, v93, v96}) + tmp97 = tmp105 + } + tmp89 = tmp97 + } // end let + return tmp89 + }) + tmp87 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6750), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(6753), lang.NewKeyword("end-column"), int(53)) + tmp88, err := lang.WithMeta(tmp86, tmp87.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp89 := lang.NewMap() + tmp90 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6754), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(6754), lang.NewKeyword("end-column"), int(25)) + tmp91, err := lang.WithMeta(tmp89, tmp90.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp92 := lang.Apply(tmp85, []any{tmp88, tmp91, v80}) + var v93 any = tmp92 + _ = v93 + // let binding "tests" + tmp94 := checkDerefVar(glojure_DOT_core_keys) + tmp95 := lang.Apply(tmp94, []any{v93}) + var v96 any = tmp95 + _ = v96 + // let binding "thens" + tmp97 := checkDerefVar(glojure_DOT_core_vals) + tmp98 := lang.Apply(tmp97, []any{v93}) + var v99 any = tmp98 + _ = v99 + // let binding "mode" + var tmp100 any + tmp101 := checkDerefVar(glojure_DOT_core_every_QMARK_) + var tmp102 lang.FnFunc + tmp102 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v103 := args[0] + _ = v103 + var tmp104 any + { // let + // let binding "and__0__auto__" + tmp105 := checkDerefVar(glojure_DOT_core_integer_QMARK_) + tmp106 := lang.Apply(tmp105, []any{v103}) + var v107 any = tmp106 + _ = v107 + var tmp108 any + if lang.IsTruthy(v107) { + tmp109 := checkDerefVar(glojure_DOT_core__LT__EQ_) + tmp110 := lang.Apply(tmp109, []any{math6.MinInt, v103, math6.MaxInt}) + tmp108 = tmp110 + } else { + tmp108 = v107 + } + tmp104 = tmp108 + } // end let + return tmp104 + }) + tmp103 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6758), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(6758), lang.NewKeyword("end-column"), int(77)) + tmp104, err := lang.WithMeta(tmp102, tmp103.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp105 := lang.Apply(tmp101, []any{tmp104, v96}) + if lang.IsTruthy(tmp105) { + tmp100 = lang.NewKeyword("ints") + } else { + var tmp106 any + tmp107 := checkDerefVar(glojure_DOT_core_every_QMARK_) + tmp108 := checkDerefVar(glojure_DOT_core_keyword_QMARK_) + tmp109 := lang.Apply(tmp107, []any{tmp108, v96}) + if lang.IsTruthy(tmp109) { + tmp106 = lang.NewKeyword("identity") + } else { + var tmp110 any + if lang.IsTruthy(lang.NewKeyword("else")) { + tmp110 = lang.NewKeyword("hashes") + } else { + } + tmp106 = tmp110 + } + tmp100 = tmp106 + } + var v111 any = tmp100 + _ = v111 + var tmp112 any + { // let + // let binding "pred__180" + tmp113 := checkDerefVar(glojure_DOT_core__EQ_) + var v114 any = tmp113 + _ = v114 + // let binding "expr__181" + var v115 any = v111 + _ = v115 + var tmp116 any + tmp117 := lang.Apply(v114, []any{lang.NewKeyword("ints"), v115}) + if lang.IsTruthy(tmp117) { + var tmp118 any + { // let + // let binding "vec__182" + tmp119 := checkDerefVar(glojure_DOT_core_prep_ints) + tmp120 := lang.Apply(tmp119, []any{v96, v99}) + var v121 any = tmp120 + _ = v121 + // let binding "shift" + tmp122 := checkDerefVar(glojure_DOT_core_nth) + tmp123 := lang.Apply(tmp122, []any{v121, int64(0), nil}) + var v124 any = tmp123 + _ = v124 + // let binding "mask" + tmp125 := checkDerefVar(glojure_DOT_core_nth) + tmp126 := lang.Apply(tmp125, []any{v121, int64(1), nil}) + var v127 any = tmp126 + _ = v127 + // let binding "imap" + tmp128 := checkDerefVar(glojure_DOT_core_nth) + tmp129 := lang.Apply(tmp128, []any{v121, int64(2), nil}) + var v130 any = tmp129 + _ = v130 + // let binding "switch-type" + tmp131 := checkDerefVar(glojure_DOT_core_nth) + tmp132 := lang.Apply(tmp131, []any{v121, int64(3), nil}) + var v133 any = tmp132 + _ = v133 + tmp134 := checkDerefVar(glojure_DOT_core_seq) + tmp135 := checkDerefVar(glojure_DOT_core_concat) + tmp136 := checkDerefVar(glojure_DOT_core_list) + tmp137 := lang.Apply(tmp136, []any{lang.NewSymbol("glojure.core/let")}) + tmp138 := checkDerefVar(glojure_DOT_core_list) + tmp139 := checkDerefVar(glojure_DOT_core_apply) + tmp140 := checkDerefVar(glojure_DOT_core_vector) + tmp141 := checkDerefVar(glojure_DOT_core_seq) + tmp142 := checkDerefVar(glojure_DOT_core_concat) + tmp143 := checkDerefVar(glojure_DOT_core_list) + tmp144 := lang.Apply(tmp143, []any{v16}) + tmp145 := checkDerefVar(glojure_DOT_core_list) + tmp146 := lang.Apply(tmp145, []any{v5}) + tmp147 := lang.Apply(tmp142, []any{tmp144, tmp146}) + tmp148 := lang.Apply(tmp141, []any{tmp147}) + tmp149 := lang.Apply(tmp139, []any{tmp140, tmp148}) + tmp150 := lang.Apply(tmp138, []any{tmp149}) + tmp151 := checkDerefVar(glojure_DOT_core_list) + tmp152 := checkDerefVar(glojure_DOT_core_seq) + tmp153 := checkDerefVar(glojure_DOT_core_concat) + tmp154 := checkDerefVar(glojure_DOT_core_list) + tmp155 := lang.Apply(tmp154, []any{lang.NewSymbol("case*")}) + tmp156 := checkDerefVar(glojure_DOT_core_list) + tmp157 := lang.Apply(tmp156, []any{v16}) + tmp158 := checkDerefVar(glojure_DOT_core_list) + tmp159 := lang.Apply(tmp158, []any{v124}) + tmp160 := checkDerefVar(glojure_DOT_core_list) + tmp161 := lang.Apply(tmp160, []any{v127}) + tmp162 := checkDerefVar(glojure_DOT_core_list) + tmp163 := lang.Apply(tmp162, []any{v50}) + tmp164 := checkDerefVar(glojure_DOT_core_list) + tmp165 := lang.Apply(tmp164, []any{v130}) + tmp166 := checkDerefVar(glojure_DOT_core_list) + tmp167 := lang.Apply(tmp166, []any{v133}) + tmp168 := checkDerefVar(glojure_DOT_core_list) + tmp169 := lang.Apply(tmp168, []any{lang.NewKeyword("int")}) + tmp170 := lang.Apply(tmp153, []any{tmp155, tmp157, tmp159, tmp161, tmp163, tmp165, tmp167, tmp169}) + tmp171 := lang.Apply(tmp152, []any{tmp170}) + tmp172 := lang.Apply(tmp151, []any{tmp171}) + tmp173 := lang.Apply(tmp135, []any{tmp137, tmp150, tmp172}) + tmp174 := lang.Apply(tmp134, []any{tmp173}) + tmp118 = tmp174 + } // end let + tmp116 = tmp118 + } else { + var tmp119 any + tmp120 := lang.Apply(v114, []any{lang.NewKeyword("hashes"), v115}) + if lang.IsTruthy(tmp120) { + var tmp121 any + { // let + // let binding "vec__185" + tmp122 := checkDerefVar(glojure_DOT_core_prep_hashes) + tmp123 := lang.Apply(tmp122, []any{v16, v50, v96, v99}) + var v124 any = tmp123 + _ = v124 + // let binding "shift" + tmp125 := checkDerefVar(glojure_DOT_core_nth) + tmp126 := lang.Apply(tmp125, []any{v124, int64(0), nil}) + var v127 any = tmp126 + _ = v127 + // let binding "mask" + tmp128 := checkDerefVar(glojure_DOT_core_nth) + tmp129 := lang.Apply(tmp128, []any{v124, int64(1), nil}) + var v130 any = tmp129 + _ = v130 + // let binding "imap" + tmp131 := checkDerefVar(glojure_DOT_core_nth) + tmp132 := lang.Apply(tmp131, []any{v124, int64(2), nil}) + var v133 any = tmp132 + _ = v133 + // let binding "switch-type" + tmp134 := checkDerefVar(glojure_DOT_core_nth) + tmp135 := lang.Apply(tmp134, []any{v124, int64(3), nil}) + var v136 any = tmp135 + _ = v136 + // let binding "skip-check" + tmp137 := checkDerefVar(glojure_DOT_core_nth) + tmp138 := lang.Apply(tmp137, []any{v124, int64(4), nil}) + var v139 any = tmp138 + _ = v139 + tmp140 := checkDerefVar(glojure_DOT_core_seq) + tmp141 := checkDerefVar(glojure_DOT_core_concat) + tmp142 := checkDerefVar(glojure_DOT_core_list) + tmp143 := lang.Apply(tmp142, []any{lang.NewSymbol("glojure.core/let")}) + tmp144 := checkDerefVar(glojure_DOT_core_list) + tmp145 := checkDerefVar(glojure_DOT_core_apply) + tmp146 := checkDerefVar(glojure_DOT_core_vector) + tmp147 := checkDerefVar(glojure_DOT_core_seq) + tmp148 := checkDerefVar(glojure_DOT_core_concat) + tmp149 := checkDerefVar(glojure_DOT_core_list) + tmp150 := lang.Apply(tmp149, []any{v16}) + tmp151 := checkDerefVar(glojure_DOT_core_list) + tmp152 := lang.Apply(tmp151, []any{v5}) + tmp153 := lang.Apply(tmp148, []any{tmp150, tmp152}) + tmp154 := lang.Apply(tmp147, []any{tmp153}) + tmp155 := lang.Apply(tmp145, []any{tmp146, tmp154}) + tmp156 := lang.Apply(tmp144, []any{tmp155}) + tmp157 := checkDerefVar(glojure_DOT_core_list) + tmp158 := checkDerefVar(glojure_DOT_core_seq) + tmp159 := checkDerefVar(glojure_DOT_core_concat) + tmp160 := checkDerefVar(glojure_DOT_core_list) + tmp161 := lang.Apply(tmp160, []any{lang.NewSymbol("case*")}) + tmp162 := checkDerefVar(glojure_DOT_core_list) + tmp163 := lang.Apply(tmp162, []any{v16}) + tmp164 := checkDerefVar(glojure_DOT_core_list) + tmp165 := lang.Apply(tmp164, []any{v127}) + tmp166 := checkDerefVar(glojure_DOT_core_list) + tmp167 := lang.Apply(tmp166, []any{v130}) + tmp168 := checkDerefVar(glojure_DOT_core_list) + tmp169 := lang.Apply(tmp168, []any{v50}) + tmp170 := checkDerefVar(glojure_DOT_core_list) + tmp171 := lang.Apply(tmp170, []any{v133}) + tmp172 := checkDerefVar(glojure_DOT_core_list) + tmp173 := lang.Apply(tmp172, []any{v136}) + tmp174 := checkDerefVar(glojure_DOT_core_list) + tmp175 := lang.Apply(tmp174, []any{lang.NewKeyword("hash-equiv")}) + tmp176 := checkDerefVar(glojure_DOT_core_list) + tmp177 := lang.Apply(tmp176, []any{v139}) + tmp178 := lang.Apply(tmp159, []any{tmp161, tmp163, tmp165, tmp167, tmp169, tmp171, tmp173, tmp175, tmp177}) + tmp179 := lang.Apply(tmp158, []any{tmp178}) + tmp180 := lang.Apply(tmp157, []any{tmp179}) + tmp181 := lang.Apply(tmp141, []any{tmp143, tmp156, tmp180}) + tmp182 := lang.Apply(tmp140, []any{tmp181}) + tmp121 = tmp182 + } // end let + tmp119 = tmp121 + } else { + var tmp122 any + tmp123 := lang.Apply(v114, []any{lang.NewKeyword("identity"), v115}) + if lang.IsTruthy(tmp123) { + var tmp124 any + { // let + // let binding "vec__188" + tmp125 := checkDerefVar(glojure_DOT_core_prep_hashes) + tmp126 := lang.Apply(tmp125, []any{v16, v50, v96, v99}) + var v127 any = tmp126 + _ = v127 + // let binding "shift" + tmp128 := checkDerefVar(glojure_DOT_core_nth) + tmp129 := lang.Apply(tmp128, []any{v127, int64(0), nil}) + var v130 any = tmp129 + _ = v130 + // let binding "mask" + tmp131 := checkDerefVar(glojure_DOT_core_nth) + tmp132 := lang.Apply(tmp131, []any{v127, int64(1), nil}) + var v133 any = tmp132 + _ = v133 + // let binding "imap" + tmp134 := checkDerefVar(glojure_DOT_core_nth) + tmp135 := lang.Apply(tmp134, []any{v127, int64(2), nil}) + var v136 any = tmp135 + _ = v136 + // let binding "switch-type" + tmp137 := checkDerefVar(glojure_DOT_core_nth) + tmp138 := lang.Apply(tmp137, []any{v127, int64(3), nil}) + var v139 any = tmp138 + _ = v139 + // let binding "skip-check" + tmp140 := checkDerefVar(glojure_DOT_core_nth) + tmp141 := lang.Apply(tmp140, []any{v127, int64(4), nil}) + var v142 any = tmp141 + _ = v142 + tmp143 := checkDerefVar(glojure_DOT_core_seq) + tmp144 := checkDerefVar(glojure_DOT_core_concat) + tmp145 := checkDerefVar(glojure_DOT_core_list) + tmp146 := lang.Apply(tmp145, []any{lang.NewSymbol("glojure.core/let")}) + tmp147 := checkDerefVar(glojure_DOT_core_list) + tmp148 := checkDerefVar(glojure_DOT_core_apply) + tmp149 := checkDerefVar(glojure_DOT_core_vector) + tmp150 := checkDerefVar(glojure_DOT_core_seq) + tmp151 := checkDerefVar(glojure_DOT_core_concat) + tmp152 := checkDerefVar(glojure_DOT_core_list) + tmp153 := lang.Apply(tmp152, []any{v16}) + tmp154 := checkDerefVar(glojure_DOT_core_list) + tmp155 := lang.Apply(tmp154, []any{v5}) + tmp156 := lang.Apply(tmp151, []any{tmp153, tmp155}) + tmp157 := lang.Apply(tmp150, []any{tmp156}) + tmp158 := lang.Apply(tmp148, []any{tmp149, tmp157}) + tmp159 := lang.Apply(tmp147, []any{tmp158}) + tmp160 := checkDerefVar(glojure_DOT_core_list) + tmp161 := checkDerefVar(glojure_DOT_core_seq) + tmp162 := checkDerefVar(glojure_DOT_core_concat) + tmp163 := checkDerefVar(glojure_DOT_core_list) + tmp164 := lang.Apply(tmp163, []any{lang.NewSymbol("case*")}) + tmp165 := checkDerefVar(glojure_DOT_core_list) + tmp166 := lang.Apply(tmp165, []any{v16}) + tmp167 := checkDerefVar(glojure_DOT_core_list) + tmp168 := lang.Apply(tmp167, []any{v130}) + tmp169 := checkDerefVar(glojure_DOT_core_list) + tmp170 := lang.Apply(tmp169, []any{v133}) + tmp171 := checkDerefVar(glojure_DOT_core_list) + tmp172 := lang.Apply(tmp171, []any{v50}) + tmp173 := checkDerefVar(glojure_DOT_core_list) + tmp174 := lang.Apply(tmp173, []any{v136}) + tmp175 := checkDerefVar(glojure_DOT_core_list) + tmp176 := lang.Apply(tmp175, []any{v139}) + tmp177 := checkDerefVar(glojure_DOT_core_list) + tmp178 := lang.Apply(tmp177, []any{lang.NewKeyword("hash-identity")}) + tmp179 := checkDerefVar(glojure_DOT_core_list) + tmp180 := lang.Apply(tmp179, []any{v142}) + tmp181 := lang.Apply(tmp162, []any{tmp164, tmp166, tmp168, tmp170, tmp172, tmp174, tmp176, tmp178, tmp180}) + tmp182 := lang.Apply(tmp161, []any{tmp181}) + tmp183 := lang.Apply(tmp160, []any{tmp182}) + tmp184 := lang.Apply(tmp144, []any{tmp146, tmp159, tmp183}) + tmp185 := lang.Apply(tmp143, []any{tmp184}) + tmp124 = tmp185 + } // end let + tmp122 = tmp124 + } else { + tmp125 := checkDerefVar(glojure_DOT_core_str) + tmp126 := lang.Apply(tmp125, []any{"No matching clause: ", v115}) + tmp127 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp126}) + panic(tmp127) + } + tmp119 = tmp122 + } + tmp116 = tmp119 + } + tmp112 = tmp116 + } // end let + tmp77 = tmp112 + } // end let + tmp51 = tmp77 + } + tmp7 = tmp51 + } // end let + return tmp7 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // case-map + { + tmp0 := lang.NewSymbol("case-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("case-f"), lang.NewSymbol("test-f"), lang.NewSymbol("tests"), lang.NewSymbol("thens"))), lang.NewKeyword("doc"), "Transforms a sequence of test constants and a corresponding sequence of then\n expressions into a sorted map to be consumed by case*. The form of the map\n entries are {(case-f test) [(test-f test) then]}.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6614), lang.NewKeyword("end-line"), int(6614), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_into1) + tmp8 := checkDerefVar(glojure_DOT_core_sorted_map) + tmp9 := lang.Apply(tmp8, nil) + tmp10 := checkDerefVar(glojure_DOT_core_zipmap) + tmp11 := checkDerefVar(glojure_DOT_core_map) + tmp12 := lang.Apply(tmp11, []any{v3, v5}) + tmp13 := checkDerefVar(glojure_DOT_core_map) + tmp14 := checkDerefVar(glojure_DOT_core_vector) + tmp15 := checkDerefVar(glojure_DOT_core_map) + tmp16 := lang.Apply(tmp15, []any{v4, v5}) + tmp17 := lang.Apply(tmp13, []any{tmp14, tmp16, v6}) + tmp18 := lang.Apply(tmp10, []any{tmp12, tmp17}) + tmp19 := lang.Apply(tmp7, []any{tmp9, tmp18}) + return tmp19 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // cast + { + tmp0 := lang.NewSymbol("cast").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Throws a ClassCastException if x is not a c, else returns x.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(345), lang.NewKeyword("end-line"), int(345))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(v3, "cast") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("cast is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // cat + { + tmp0 := lang.NewSymbol("cat").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rf"))), lang.NewKeyword("doc"), "A transducer which concatenates the contents of each input, which must be a\n collection, into the reduction.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7645), lang.NewKeyword("end-line"), int(7645))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + { // let + // let binding "rrf" + tmp5 := checkDerefVar(glojure_DOT_core_preserving_reduced) + tmp6 := lang.Apply(tmp5, []any{v3}) + var v7 any = tmp6 + _ = v7 + var tmp8 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp9 := lang.Apply(v3, nil) + return tmp9 + case 1: + v9 := args[0] + _ = v9 + tmp10 := lang.Apply(v3, []any{v9}) + return tmp10 + case 2: + v9 := args[0] + _ = v9 + v10 := args[1] + _ = v10 + tmp11 := checkDerefVar(glojure_DOT_core_reduce) + tmp12 := lang.Apply(tmp11, []any{v7, v9, v10}) + return tmp12 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7651), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(7655), lang.NewKeyword("end-column"), int(36)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp4 = tmp10 + } // end let + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // char + { + var tmp1 lang.FnFunc + { // function char__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := checkDerefVar(glojure_DOT_core_seq) + tmp12 := checkDerefVar(glojure_DOT_core_concat) + tmp13 := checkDerefVar(glojure_DOT_core_list) + var tmp14 any + tmp15 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + if lang.IsTruthy(tmp15) { + tmp14 = lang.NewSymbol("uncheckedCharCast") + } else { + tmp14 = lang.NewSymbol("charCast") + } + tmp16 := lang.Apply(tmp13, []any{tmp14}) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := lang.Apply(tmp12, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp11, []any{tmp19}) + tmp21 := lang.Apply(tmp10, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("char").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to char", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3511), lang.NewKeyword("end-line"), int(3511))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5, _ := lang.FieldOrMethod(runtime7.RT, "CharCast") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("CharCast is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // char-array + { + var tmp1 lang.FnFunc + { // function char-array__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol("glojure.core/CharArray")}) + tmp12 := checkDerefVar(glojure_DOT_core_list) + tmp13 := checkDerefVar(glojure_DOT_core_seq) + tmp14 := checkDerefVar(glojure_DOT_core_concat) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("glojure.core/args")}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + } + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("char-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Creates an array of chars", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5325), lang.NewKeyword("end-line"), int(5325))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "CharArray") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("CharArray is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "CharArrayInit") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("CharArrayInit is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // char-escape-string + { + tmp1 := reflect.TypeOf("") + tmp0 := lang.NewSymbol("char-escape-string").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("doc"), "Returns escape string for char or nil if none", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(6), lang.NewKeyword("line"), int(214), lang.NewKeyword("end-line"), int(217))).(*lang.Symbol) + tmp2 := ns.InternWithValue(tmp0, lang.NewMap(lang.NewChar(10), "\\n", lang.NewChar(9), "\\t", lang.NewChar(13), "\\r", lang.NewChar(34), "\\\"", lang.NewChar(92), "\\\\", lang.NewChar(12), "\\f", lang.NewChar(8), "\\b"), true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // char-name-string + { + tmp1 := reflect.TypeOf("") + tmp0 := lang.NewSymbol("char-name-string").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("doc"), "Returns name string for char or nil if none", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(6), lang.NewKeyword("line"), int(335), lang.NewKeyword("end-line"), int(338))).(*lang.Symbol) + tmp2 := ns.InternWithValue(tmp0, lang.NewMap(lang.NewChar(10), "newline", lang.NewChar(9), "tab", lang.NewChar(32), "space", lang.NewChar(8), "backspace", lang.NewChar(12), "formfeed", lang.NewChar(13), "return"), true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // char? + { + tmp0 := lang.NewSymbol("char?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a Character", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(153), lang.NewKeyword("end-line"), int(157))).(*lang.Symbol) + var tmp2 lang.FnFunc + { // function char? + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp6 := reflect.TypeOf(int32(0)) + tmp7 := lang.Apply(tmp5, []any{tmp6, v4}) + return tmp7 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(157), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(157), lang.NewKeyword("end-column"), int(89))).(lang.FnFunc) + v3 = tmp2 + _ = v3 + } + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // chars + { + var tmp1 lang.FnFunc + { // function chars + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol("glojure.core/Chars")}) + tmp12 := checkDerefVar(glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("chars").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Casts to chars[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5382), lang.NewKeyword("end-line"), int(5382))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Chars") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Chars is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // check-cyclic-dependency + { + tmp0 := lang.NewSymbol("check-cyclic-dependency").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("path"))), lang.NewKeyword("doc"), "Detects and rejects non-trivial cyclic load dependencies. The\n exception message shows the dependency chain with the cycle\n highlighted. Ignores the trivial case of a file attempting to load\n itself because that can occur when a gen-class'd class loads its\n implementation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(30), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5974), lang.NewKeyword("end-line"), int(5974), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(glojure_DOT_core_some) + tmp6 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{v3})) + tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5981), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(5981), lang.NewKeyword("end-column"), int(21)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp9 := checkDerefVar(glojure_DOT_core_rest) + tmp10 := checkDerefVar(glojure_DOT_core__STAR_pending_paths_STAR_) + tmp11 := lang.Apply(tmp9, []any{tmp10}) + tmp12 := lang.Apply(tmp5, []any{tmp8, tmp11}) + if lang.IsTruthy(tmp12) { + var tmp13 any + { // let + // let binding "pending" + tmp14 := checkDerefVar(glojure_DOT_core_map) + var tmp15 lang.FnFunc + tmp15 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v16 := args[0] + _ = v16 + var tmp17 any + tmp18 := checkDerefVar(glojure_DOT_core__EQ_) + tmp19 := lang.Apply(tmp18, []any{v16, v3}) + if lang.IsTruthy(tmp19) { + tmp20 := checkDerefVar(glojure_DOT_core_str) + tmp21 := lang.Apply(tmp20, []any{"[ ", v16, " ]"}) + tmp17 = tmp21 + } else { + tmp17 = v16 + } + return tmp17 + }) + tmp16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5982), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(5982), lang.NewKeyword("end-column"), int(59)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp18 := checkDerefVar(glojure_DOT_core_cons) + tmp19 := checkDerefVar(glojure_DOT_core__STAR_pending_paths_STAR_) + tmp20 := lang.Apply(tmp18, []any{v3, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp17, tmp20}) + var v22 any = tmp21 + _ = v22 + // let binding "chain" + tmp23 := checkDerefVar(glojure_DOT_core_apply) + tmp24 := checkDerefVar(glojure_DOT_core_str) + tmp25 := checkDerefVar(glojure_DOT_core_interpose) + tmp26 := lang.Apply(tmp25, []any{"->", v22}) + tmp27 := lang.Apply(tmp23, []any{tmp24, tmp26}) + var v28 any = tmp27 + _ = v28 + tmp29 := checkDerefVar(glojure_DOT_core_throw_if) + tmp30 := lang.Apply(tmp29, []any{true, "Cyclic load dependency: %s", v28}) + tmp13 = tmp30 + } // end let + tmp4 = tmp13 + } else { + } + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // check-valid-options + { + tmp0 := lang.NewSymbol("check-valid-options").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("options"), lang.NewSymbol("&"), lang.NewSymbol("valid-keys"))), lang.NewKeyword("doc"), "Throws an exception if the given option map contains keys not listed\n as valid, else returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(35), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1709), lang.NewKeyword("end-line"), int(1709), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any = lang.NewList(args[1:]...) + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(glojure_DOT_core_seq) + tmp7 := checkDerefVar(glojure_DOT_core_apply) + tmp8 := checkDerefVar(glojure_DOT_core_disj) + tmp9 := checkDerefVar(glojure_DOT_core_apply) + tmp10 := checkDerefVar(glojure_DOT_core_hash_set) + tmp11 := checkDerefVar(glojure_DOT_core_keys) + tmp12 := lang.Apply(tmp11, []any{v3}) + tmp13 := lang.Apply(tmp9, []any{tmp10, tmp12}) + tmp14 := lang.Apply(tmp7, []any{tmp8, tmp13, v4}) + tmp15 := lang.Apply(tmp6, []any{tmp14}) + if lang.IsTruthy(tmp15) { + tmp16 := checkDerefVar(glojure_DOT_core_apply) + tmp17 := checkDerefVar(glojure_DOT_core_str) + tmp18 := checkDerefVar(glojure_DOT_core_first) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := checkDerefVar(glojure_DOT_core_map) + var tmp21 lang.FnFunc + tmp21 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v22 := args[0] + _ = v22 + tmp23 := checkDerefVar(glojure_DOT_core_str) + tmp24 := lang.Apply(tmp23, []any{", ", v22}) + return tmp24 + }) + tmp22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1718), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(1718), lang.NewKeyword("end-column"), int(28)) + tmp23, err := lang.WithMeta(tmp21, tmp22.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp24 := checkDerefVar(glojure_DOT_core_rest) + tmp25 := lang.Apply(tmp24, []any{v4}) + tmp26 := lang.Apply(tmp20, []any{tmp23, tmp25}) + tmp27 := lang.Apply(tmp16, []any{tmp17, "Only these options are valid: ", tmp19, tmp26}) + tmp28 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp27}) + panic(tmp28) + } else { + } + return tmp5 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // chunk + { + tmp0 := lang.NewSymbol("chunk").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(691), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(691), lang.NewKeyword("end-column"), int(41), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("b"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4, ok := lang.FieldOrMethod(v3, "chunk") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "chunk"))) + } + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { + case reflect.Func: + tmp5 = lang.Apply(tmp4, nil) + default: + tmp5 = tmp4 + } + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // chunk-append + { + tmp0 := lang.NewSymbol("chunk-append").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(688), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(688), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("b"), lang.NewSymbol("x"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(v3, "add") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // chunk-buffer + { + tmp0 := lang.NewSymbol("chunk-buffer").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(685), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(685), lang.NewKeyword("end-column"), int(53), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("capacity"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.NewChunkBuffer, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // chunk-cons + { + tmp0 := lang.NewSymbol("chunk-cons").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(703), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(703), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("chunk"), lang.NewSymbol("rest"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 any + tmp6 := lang.Apply(lang.Count, []any{v3}) + tmp7 := lang.Apply(lang.IsZero, []any{tmp6}) + if lang.IsTruthy(tmp7) { + tmp5 = v4 + } else { + tmp8 := lang.Apply(lang.NewChunkedCons, []any{v3, v4}) + tmp5 = tmp8 + } + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // chunk-first + { + tmp0 := lang.NewSymbol("chunk-first").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(694), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(694), lang.NewKeyword("end-column"), int(48), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4, ok := lang.FieldOrMethod(v3, "chunkedFirst") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "chunkedFirst"))) + } + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { + case reflect.Func: + tmp5 = lang.Apply(tmp4, nil) + default: + tmp5 = tmp4 + } + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // chunk-next + { + tmp0 := lang.NewSymbol("chunk-next").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(700), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(700), lang.NewKeyword("end-column"), int(71), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4, ok := lang.FieldOrMethod(v3, "chunkedNext") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "chunkedNext"))) + } + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { + case reflect.Func: + tmp5 = lang.Apply(tmp4, nil) + default: + tmp5 = tmp4 + } + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // chunk-rest + { + tmp0 := lang.NewSymbol("chunk-rest").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(697), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(697), lang.NewKeyword("end-column"), int(71), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4, ok := lang.FieldOrMethod(v3, "chunkedMore") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "chunkedMore"))) + } + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { + case reflect.Func: + tmp5 = lang.Apply(tmp4, nil) + default: + tmp5 = tmp4 + } + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // chunked-seq? + { + tmp0 := lang.NewSymbol("chunked-seq?").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(708), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(708), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp5 := reflect.TypeOf((*lang.IChunkedSeq)(nil)).Elem() + tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // class + { + tmp0 := lang.NewSymbol("class").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns the Class of x", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3461), lang.NewKeyword("end-line"), int(3461))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + tmp4 = v3 + } else { + tmp7 := lang.Apply(lang.TypeOf, []any{v3}) + tmp4 = tmp7 + } + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // class? + { + tmp0 := lang.NewSymbol("class?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is an instance of Class", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5465), lang.NewKeyword("end-line"), int(5465))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp5 := reflect.TypeOf((*reflect.Type)(nil)).Elem() + tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // clear-agent-errors + { + tmp0 := lang.NewSymbol("clear-agent-errors").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("doc"), "DEPRECATED: Use 'restart-agent' instead.\n Clears any exceptions thrown during asynchronous actions of the\n agent, allowing subsequent actions to occur.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("deprecated"), "1.2", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2244), lang.NewKeyword("end-line"), int(2244))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_restart_agent) + tmp5, ok := lang.FieldOrMethod(v3, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "Deref"))) + } + var tmp6 any + switch reflect.TypeOf(tmp5).Kind() { + case reflect.Func: + tmp6 = lang.Apply(tmp5, nil) + default: + tmp6 = tmp5 + } + tmp7 := lang.Apply(tmp4, []any{v3, tmp6}) + return tmp7 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // coll? + { + tmp0 := lang.NewSymbol("coll?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements IPersistentCollection", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6192), lang.NewKeyword("end-line"), int(6192))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp5 := reflect.TypeOf((*lang.IPersistentCollection)(nil)).Elem() + tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // comment + { + tmp0 := lang.NewSymbol("comment").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Ignores body, yields nil", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4733), lang.NewKeyword("end-line"), int(4733))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + return nil + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // commute + { + tmp0 := lang.NewSymbol("commute").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("fun"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Must be called in a transaction. Sets the in-transaction-value of\n ref to:\n\n (apply fun in-transaction-value-of-ref args)\n\n and returns the in-transaction-value of ref.\n\n At the commit point of the transaction, sets the value of ref to be:\n\n (apply fun most-recently-committed-value-of-ref args)\n\n Thus fun should be commutative, or, failing that, you must accept\n last-one-in-wins behavior. commute allows for more concurrency than\n ref-set.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2414), lang.NewKeyword("end-line"), int(2414))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6, _ := lang.FieldOrMethod(v3, "Commute") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Commute is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // comp + { + tmp0 := lang.NewSymbol("comp").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("g")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("g"), lang.NewSymbol("&"), lang.NewSymbol("fs"))), lang.NewKeyword("doc"), "Takes a set of functions and returns a fn that is the composition\n of those fns. The returned fn takes a variable number of args,\n applies the rightmost of fns to the args, the next\n fn (right-to-left) to the result, etc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2549), lang.NewKeyword("end-line"), int(2549))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp3 := checkDerefVar(glojure_DOT_core_identity) + return tmp3 + case 1: + v3 := args[0] + _ = v3 + return v3 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp6 := lang.Apply(v4, nil) + tmp7 := lang.Apply(v3, []any{tmp6}) + return tmp7 + case 1: + v6 := args[0] + _ = v6 + tmp7 := lang.Apply(v4, []any{v6}) + tmp8 := lang.Apply(v3, []any{tmp7}) + return tmp8 + case 2: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + tmp8 := lang.Apply(v4, []any{v6, v7}) + tmp9 := lang.Apply(v3, []any{tmp8}) + return tmp9 + case 3: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + tmp9 := lang.Apply(v4, []any{v6, v7, v8}) + tmp10 := lang.Apply(v3, []any{tmp9}) + return tmp10 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + var v9 any = lang.NewList(args[3:]...) + _ = v9 + tmp10 := checkDerefVar(glojure_DOT_core_apply) + tmp11 := lang.Apply(tmp10, []any{v4, v6, v7, v8, v9}) + tmp12 := lang.Apply(v3, []any{tmp11}) + return tmp12 + } + }) + tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2559), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2564), lang.NewKeyword("end-column"), int(49)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp7 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := checkDerefVar(glojure_DOT_core_reduce1) + tmp7 := checkDerefVar(glojure_DOT_core_comp) + tmp8 := checkDerefVar(glojure_DOT_core_list_STAR_) + tmp9 := lang.Apply(tmp8, []any{v3, v4, v5}) + tmp10 := lang.Apply(tmp6, []any{tmp7, tmp9}) + return tmp10 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // comparator + { + tmp0 := lang.NewSymbol("comparator").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"))), lang.NewKeyword("doc"), "Returns an implementation of java.util.Comparator based upon pred.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3077), lang.NewKeyword("end-line"), int(3077))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + var tmp7 any + tmp8 := lang.Apply(v3, []any{v5, v6}) + if lang.IsTruthy(tmp8) { + tmp7 = int64(-1) + } else { + var tmp9 any + tmp10 := lang.Apply(v3, []any{v6, v5}) + if lang.IsTruthy(tmp10) { + tmp9 = int64(1) + } else { + var tmp11 any + if lang.IsTruthy(lang.NewKeyword("else")) { + tmp11 = int64(0) + } else { + } + tmp9 = tmp11 + } + tmp7 = tmp9 + } + return tmp7 + }) + tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3082), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(3083), lang.NewKeyword("end-column"), int(48)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // compare + { + var tmp1 lang.FnFunc + { // function compare__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_seq) + tmp6 := checkDerefVar(glojure_DOT_core_concat) + tmp7 := checkDerefVar(glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{lang.NewSymbol(".")}) + tmp9 := checkDerefVar(glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("glojure.lang.Util")}) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{lang.NewSymbol("glojure.core/compare")}) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{v3}) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v4}) + tmp17 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp12, tmp14, tmp16}) + tmp18 := lang.Apply(tmp5, []any{tmp17}) + return tmp18 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("compare").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Comparator. Returns a negative number, zero, or a positive number\n when x is logically 'less than', 'equal to', or 'greater than'\n y. Same as Java x.compareTo(y) except it also works for nil, and\n compares numbers and collections in a type-independent manner. x\n must implement Comparable", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(824), lang.NewKeyword("end-line"), int(824))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6 := lang.Apply(lang.Compare, []any{v4, v5}) + return tmp6 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // compare-and-set! + { + tmp0 := lang.NewSymbol("compare-and-set!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atom"), lang.NewSymbol("oldval"), lang.NewSymbol("newval"))), lang.NewKeyword("doc"), "Atomically sets the value of atom to newval if and only if the\n current value of the atom is identical to oldval. Returns true if\n set happened, else false", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2360), lang.NewKeyword("end-line"), int(2360))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6, _ := lang.FieldOrMethod(v3, "compareAndSet") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("compareAndSet is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // compile + { + tmp0 := lang.NewSymbol("compile").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"))), lang.NewKeyword("doc"), "Compiles the namespace named by the symbol lib into a set of\n classfiles. The source for the lib must be in a proper\n classpath-relative directory. The output files will go into the\n directory specified by *compile-path*, and that directory too must\n be in the classpath.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6114), lang.NewKeyword("end-line"), int(6114))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + { // let + tmp5 := checkDerefVar(glojure_DOT_core_push_thread_bindings) + tmp6 := checkDerefVar(glojure_DOT_core_hash_map) + tmp7 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*compile-files*")) + tmp8 := lang.Apply(tmp6, []any{tmp7, true}) + tmp9 := lang.Apply(tmp5, []any{tmp8}) + _ = tmp9 + var tmp10 any + func() { + defer func() { + tmp11 := checkDerefVar(glojure_DOT_core_pop_thread_bindings) + tmp12 := lang.Apply(tmp11, nil) + _ = tmp12 + }() + tmp13 := checkDerefVar(glojure_DOT_core_load_one) + tmp14 := lang.Apply(tmp13, []any{v3, true, true}) + tmp10 = tmp14 + }() + tmp4 = tmp10 + } // end let + _ = tmp4 + return v3 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // complement + { + tmp0 := lang.NewSymbol("complement").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Takes a fn f and returns a fn that takes the same arguments as f,\n has the same effects, if any, and returns the opposite truth value.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1428), lang.NewKeyword("end-line"), int(1428))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp5 := checkDerefVar(glojure_DOT_core_not) + tmp6 := lang.Apply(v3, nil) + tmp7 := lang.Apply(tmp5, []any{tmp6}) + return tmp7 + case 1: + v5 := args[0] + _ = v5 + tmp6 := checkDerefVar(glojure_DOT_core_not) + tmp7 := lang.Apply(v3, []any{v5}) + tmp8 := lang.Apply(tmp6, []any{tmp7}) + return tmp8 + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_not) + tmp8 := lang.Apply(v3, []any{v5, v6}) + tmp9 := lang.Apply(tmp7, []any{tmp8}) + return tmp9 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + var v7 any = lang.NewList(args[2:]...) + _ = v7 + tmp8 := checkDerefVar(glojure_DOT_core_not) + tmp9 := checkDerefVar(glojure_DOT_core_apply) + tmp10 := lang.Apply(tmp9, []any{v3, v5, v6, v7}) + tmp11 := lang.Apply(tmp8, []any{tmp10}) + return tmp11 + } + }) + tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1434), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(1438), lang.NewKeyword("end-column"), int(40)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // completing + { + tmp0 := lang.NewSymbol("completing").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("cf"))), lang.NewKeyword("doc"), "Takes a reducing function f of 2 args and returns a fn suitable for\n transduce by adding an arity-1 signature that calls cf (default -\n identity) on the result argument.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6893), lang.NewKeyword("end-line"), int(6893))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_completing) + tmp5 := checkDerefVar(glojure_DOT_core_identity) + tmp6 := lang.Apply(tmp4, []any{v3, tmp5}) + return tmp6 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp6 := lang.Apply(v3, nil) + return tmp6 + case 1: + v6 := args[0] + _ = v6 + tmp7 := lang.Apply(v4, []any{v6}) + return tmp7 + case 2: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + tmp8 := lang.Apply(v3, []any{v6, v7}) + return tmp8 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6900), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(6903), lang.NewKeyword("end-column"), int(23)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // concat + { + tmp0 := lang.NewSymbol("concat").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("zs"))), lang.NewKeyword("doc"), "Returns a lazy seq representing the concatenation of the elements in the supplied colls.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(711), lang.NewKeyword("end-line"), int(711))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + return nil + }) + tmp4 := lang.Apply(lang.NewLazySeq, []any{tmp3}) + return tmp4 + case 1: + v3 := args[0] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + return v3 + }) + tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) + return tmp5 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var tmp6 any + { // let + // let binding "s" + tmp7 := checkDerefVar(glojure_DOT_core_seq) + tmp8 := lang.Apply(tmp7, []any{v3}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + var tmp11 any + tmp12 := checkDerefVar(glojure_DOT_core_chunked_seq_QMARK_) + tmp13 := lang.Apply(tmp12, []any{v9}) + if lang.IsTruthy(tmp13) { + tmp14 := checkDerefVar(glojure_DOT_core_chunk_cons) + tmp15 := checkDerefVar(glojure_DOT_core_chunk_first) + tmp16 := lang.Apply(tmp15, []any{v9}) + tmp17 := checkDerefVar(glojure_DOT_core_concat) + tmp18 := checkDerefVar(glojure_DOT_core_chunk_rest) + tmp19 := lang.Apply(tmp18, []any{v9}) + tmp20 := lang.Apply(tmp17, []any{tmp19, v4}) + tmp21 := lang.Apply(tmp14, []any{tmp16, tmp20}) + tmp11 = tmp21 + } else { + tmp22 := checkDerefVar(glojure_DOT_core_cons) + tmp23 := checkDerefVar(glojure_DOT_core_first) + tmp24 := lang.Apply(tmp23, []any{v9}) + tmp25 := checkDerefVar(glojure_DOT_core_concat) + tmp26 := checkDerefVar(glojure_DOT_core_rest) + tmp27 := lang.Apply(tmp26, []any{v9}) + tmp28 := lang.Apply(tmp25, []any{tmp27, v4}) + tmp29 := lang.Apply(tmp22, []any{tmp24, tmp28}) + tmp11 = tmp29 + } + tmp10 = tmp11 + } else { + tmp10 = v4 + } + tmp6 = tmp10 + } // end let + return tmp6 + }) + tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) + return tmp6 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + var tmp6 any + { // let + // let binding "cat" + var tmp7 lang.FnFunc + { // function cat + var v8 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v9 := args[0] + _ = v9 + v10 := args[1] + _ = v10 + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var tmp12 any + { // let + // let binding "xys" + tmp13 := checkDerefVar(glojure_DOT_core_seq) + tmp14 := lang.Apply(tmp13, []any{v9}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + if lang.IsTruthy(v15) { + var tmp17 any + tmp18 := checkDerefVar(glojure_DOT_core_chunked_seq_QMARK_) + tmp19 := lang.Apply(tmp18, []any{v15}) + if lang.IsTruthy(tmp19) { + tmp20 := checkDerefVar(glojure_DOT_core_chunk_cons) + tmp21 := checkDerefVar(glojure_DOT_core_chunk_first) + tmp22 := lang.Apply(tmp21, []any{v15}) + tmp23 := checkDerefVar(glojure_DOT_core_chunk_rest) + tmp24 := lang.Apply(tmp23, []any{v15}) + tmp25 := lang.Apply(v8, []any{tmp24, v10}) + tmp26 := lang.Apply(tmp20, []any{tmp22, tmp25}) + tmp17 = tmp26 + } else { + tmp27 := checkDerefVar(glojure_DOT_core_cons) + tmp28 := checkDerefVar(glojure_DOT_core_first) + tmp29 := lang.Apply(tmp28, []any{v15}) + tmp30 := checkDerefVar(glojure_DOT_core_rest) + tmp31 := lang.Apply(tmp30, []any{v15}) + tmp32 := lang.Apply(v8, []any{tmp31, v10}) + tmp33 := lang.Apply(tmp27, []any{tmp29, tmp32}) + tmp17 = tmp33 + } + tmp16 = tmp17 + } else { + var tmp34 any + if lang.IsTruthy(v10) { + tmp35 := checkDerefVar(glojure_DOT_core_first) + tmp36 := lang.Apply(tmp35, []any{v10}) + tmp37 := checkDerefVar(glojure_DOT_core_next) + tmp38 := lang.Apply(tmp37, []any{v10}) + tmp39 := lang.Apply(v8, []any{tmp36, tmp38}) + tmp34 = tmp39 + } else { + } + tmp16 = tmp34 + } + tmp12 = tmp16 + } // end let + return tmp12 + }) + tmp12 := lang.Apply(lang.NewLazySeq, []any{tmp11}) + return tmp12 + }) + v8 = tmp7 + _ = v8 + } + tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(726), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(735), lang.NewKeyword("end-column"), int(56)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v10 any = tmp9 + _ = v10 + tmp11 := checkDerefVar(glojure_DOT_core_concat) + tmp12 := lang.Apply(tmp11, []any{v3, v4}) + tmp13 := lang.Apply(v10, []any{tmp12, v5}) + tmp6 = tmp13 + } // end let + return tmp6 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // cond + { + tmp0 := lang.NewSymbol("cond").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes a set of test/expr pairs. It evaluates each test one at a\n time. If a test returns logical true, cond evaluates and returns\n the value of the corresponding expr and doesn't evaluate any of the\n other tests or exprs. (cond) returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(569), lang.NewKeyword("end-line"), int(569))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + var tmp6 any + if lang.IsTruthy(v5) { + tmp7 := checkDerefVar(glojure_DOT_core_list) + tmp8 := checkDerefVar(glojure_DOT_core_first) + tmp9 := lang.Apply(tmp8, []any{v5}) + var tmp10 any + tmp11 := checkDerefVar(glojure_DOT_core_next) + tmp12 := lang.Apply(tmp11, []any{v5}) + if lang.IsTruthy(tmp12) { + tmp13 := checkDerefVar(glojure_DOT_core_second) + tmp14 := lang.Apply(tmp13, []any{v5}) + tmp10 = tmp14 + } else { + tmp15 := lang.Apply(lang.NewIllegalArgumentError, []any{"cond requires an even number of forms"}) + panic(tmp15) + } + tmp16 := checkDerefVar(glojure_DOT_core_cons) + tmp17 := checkDerefVar(glojure_DOT_core_next) + tmp18 := checkDerefVar(glojure_DOT_core_next) + tmp19 := lang.Apply(tmp18, []any{v5}) + tmp20 := lang.Apply(tmp17, []any{tmp19}) + tmp21 := lang.Apply(tmp16, []any{lang.NewSymbol("glojure.core/cond"), tmp20}) + tmp22 := lang.Apply(tmp7, []any{lang.NewSymbol("if"), tmp9, tmp10, tmp21}) + tmp6 = tmp22 + } else { + } + return tmp6 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // cond-> + { + tmp0 := lang.NewSymbol("cond->").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes an expression and a set of test/form pairs. Threads expr (via ->)\n through each form for which the corresponding test\n expression is true. Note that, unlike cond branching, cond-> threading does\n not short circuit after the first true test expression.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7564), lang.NewKeyword("end-line"), int(7564))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any + { // let + // let binding "g" + tmp8 := checkDerefVar(glojure_DOT_core_gensym) + tmp9 := lang.Apply(tmp8, nil) + var v10 any = tmp9 + _ = v10 + // let binding "steps" + tmp11 := checkDerefVar(glojure_DOT_core_map) + var tmp12 lang.FnFunc + tmp12 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v13 := args[0] + _ = v13 + var tmp14 any + { // let + // let binding "vec__349" + var v15 any = v13 + _ = v15 + // let binding "test" + tmp16 := checkDerefVar(glojure_DOT_core_nth) + tmp17 := lang.Apply(tmp16, []any{v15, int64(0), nil}) + var v18 any = tmp17 + _ = v18 + // let binding "step" + tmp19 := checkDerefVar(glojure_DOT_core_nth) + tmp20 := lang.Apply(tmp19, []any{v15, int64(1), nil}) + var v21 any = tmp20 + _ = v21 + tmp22 := checkDerefVar(glojure_DOT_core_seq) + tmp23 := checkDerefVar(glojure_DOT_core_concat) + tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{lang.NewSymbol("if")}) + tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v18}) + tmp28 := checkDerefVar(glojure_DOT_core_list) + tmp29 := checkDerefVar(glojure_DOT_core_seq) + tmp30 := checkDerefVar(glojure_DOT_core_concat) + tmp31 := checkDerefVar(glojure_DOT_core_list) + tmp32 := lang.Apply(tmp31, []any{lang.NewSymbol("glojure.core/->")}) + tmp33 := checkDerefVar(glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{v10}) + tmp35 := checkDerefVar(glojure_DOT_core_list) + tmp36 := lang.Apply(tmp35, []any{v21}) + tmp37 := lang.Apply(tmp30, []any{tmp32, tmp34, tmp36}) + tmp38 := lang.Apply(tmp29, []any{tmp37}) + tmp39 := lang.Apply(tmp28, []any{tmp38}) + tmp40 := checkDerefVar(glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{v10}) + tmp42 := lang.Apply(tmp23, []any{tmp25, tmp27, tmp39, tmp41}) + tmp43 := lang.Apply(tmp22, []any{tmp42}) + tmp14 = tmp43 + } // end let + return tmp14 + }) + tmp13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7573), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7573), lang.NewKeyword("end-column"), int(66)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp15 := checkDerefVar(glojure_DOT_core_partition) + tmp16 := lang.Apply(tmp15, []any{int64(2), v6}) + tmp17 := lang.Apply(tmp11, []any{tmp14, tmp16}) + var v18 any = tmp17 + _ = v18 + tmp19 := checkDerefVar(glojure_DOT_core_seq) + tmp20 := checkDerefVar(glojure_DOT_core_concat) + tmp21 := checkDerefVar(glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("glojure.core/let")}) + tmp23 := checkDerefVar(glojure_DOT_core_list) + tmp24 := checkDerefVar(glojure_DOT_core_apply) + tmp25 := checkDerefVar(glojure_DOT_core_vector) + tmp26 := checkDerefVar(glojure_DOT_core_seq) + tmp27 := checkDerefVar(glojure_DOT_core_concat) + tmp28 := checkDerefVar(glojure_DOT_core_list) + tmp29 := lang.Apply(tmp28, []any{v10}) + tmp30 := checkDerefVar(glojure_DOT_core_list) + tmp31 := lang.Apply(tmp30, []any{v5}) + tmp32 := checkDerefVar(glojure_DOT_core_interleave) + tmp33 := checkDerefVar(glojure_DOT_core_repeat) + tmp34 := lang.Apply(tmp33, []any{v10}) + tmp35 := checkDerefVar(glojure_DOT_core_butlast) + tmp36 := lang.Apply(tmp35, []any{v18}) + tmp37 := lang.Apply(tmp32, []any{tmp34, tmp36}) + tmp38 := lang.Apply(tmp27, []any{tmp29, tmp31, tmp37}) + tmp39 := lang.Apply(tmp26, []any{tmp38}) + tmp40 := lang.Apply(tmp24, []any{tmp25, tmp39}) + tmp41 := lang.Apply(tmp23, []any{tmp40}) + tmp42 := checkDerefVar(glojure_DOT_core_list) + var tmp43 any + tmp44 := checkDerefVar(glojure_DOT_core_empty_QMARK_) + tmp45 := lang.Apply(tmp44, []any{v18}) + if lang.IsTruthy(tmp45) { + tmp43 = v10 + } else { + tmp46 := checkDerefVar(glojure_DOT_core_last) + tmp47 := lang.Apply(tmp46, []any{v18}) + tmp43 = tmp47 + } + tmp48 := lang.Apply(tmp42, []any{tmp43}) + tmp49 := lang.Apply(tmp20, []any{tmp22, tmp41, tmp48}) + tmp50 := lang.Apply(tmp19, []any{tmp49}) + tmp7 = tmp50 + } // end let + return tmp7 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // cond->> + { + tmp0 := lang.NewSymbol("cond->>").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes an expression and a set of test/form pairs. Threads expr (via ->>)\n through each form for which the corresponding test expression\n is true. Note that, unlike cond branching, cond->> threading does not short circuit\n after the first true test expression.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7581), lang.NewKeyword("end-line"), int(7581))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any + { // let + // let binding "g" + tmp8 := checkDerefVar(glojure_DOT_core_gensym) + tmp9 := lang.Apply(tmp8, nil) + var v10 any = tmp9 + _ = v10 + // let binding "steps" + tmp11 := checkDerefVar(glojure_DOT_core_map) + var tmp12 lang.FnFunc + tmp12 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v13 := args[0] + _ = v13 + var tmp14 any + { // let + // let binding "vec__353" + var v15 any = v13 + _ = v15 + // let binding "test" + tmp16 := checkDerefVar(glojure_DOT_core_nth) + tmp17 := lang.Apply(tmp16, []any{v15, int64(0), nil}) + var v18 any = tmp17 + _ = v18 + // let binding "step" + tmp19 := checkDerefVar(glojure_DOT_core_nth) + tmp20 := lang.Apply(tmp19, []any{v15, int64(1), nil}) + var v21 any = tmp20 + _ = v21 + tmp22 := checkDerefVar(glojure_DOT_core_seq) + tmp23 := checkDerefVar(glojure_DOT_core_concat) + tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{lang.NewSymbol("if")}) + tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v18}) + tmp28 := checkDerefVar(glojure_DOT_core_list) + tmp29 := checkDerefVar(glojure_DOT_core_seq) + tmp30 := checkDerefVar(glojure_DOT_core_concat) + tmp31 := checkDerefVar(glojure_DOT_core_list) + tmp32 := lang.Apply(tmp31, []any{lang.NewSymbol("glojure.core/->>")}) + tmp33 := checkDerefVar(glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{v10}) + tmp35 := checkDerefVar(glojure_DOT_core_list) + tmp36 := lang.Apply(tmp35, []any{v21}) + tmp37 := lang.Apply(tmp30, []any{tmp32, tmp34, tmp36}) + tmp38 := lang.Apply(tmp29, []any{tmp37}) + tmp39 := lang.Apply(tmp28, []any{tmp38}) + tmp40 := checkDerefVar(glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{v10}) + tmp42 := lang.Apply(tmp23, []any{tmp25, tmp27, tmp39, tmp41}) + tmp43 := lang.Apply(tmp22, []any{tmp42}) + tmp14 = tmp43 + } // end let + return tmp14 + }) + tmp13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7590), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7590), lang.NewKeyword("end-column"), int(67)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp15 := checkDerefVar(glojure_DOT_core_partition) + tmp16 := lang.Apply(tmp15, []any{int64(2), v6}) + tmp17 := lang.Apply(tmp11, []any{tmp14, tmp16}) + var v18 any = tmp17 + _ = v18 + tmp19 := checkDerefVar(glojure_DOT_core_seq) + tmp20 := checkDerefVar(glojure_DOT_core_concat) + tmp21 := checkDerefVar(glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("glojure.core/let")}) + tmp23 := checkDerefVar(glojure_DOT_core_list) + tmp24 := checkDerefVar(glojure_DOT_core_apply) + tmp25 := checkDerefVar(glojure_DOT_core_vector) + tmp26 := checkDerefVar(glojure_DOT_core_seq) + tmp27 := checkDerefVar(glojure_DOT_core_concat) + tmp28 := checkDerefVar(glojure_DOT_core_list) + tmp29 := lang.Apply(tmp28, []any{v10}) + tmp30 := checkDerefVar(glojure_DOT_core_list) + tmp31 := lang.Apply(tmp30, []any{v5}) + tmp32 := checkDerefVar(glojure_DOT_core_interleave) + tmp33 := checkDerefVar(glojure_DOT_core_repeat) + tmp34 := lang.Apply(tmp33, []any{v10}) + tmp35 := checkDerefVar(glojure_DOT_core_butlast) + tmp36 := lang.Apply(tmp35, []any{v18}) + tmp37 := lang.Apply(tmp32, []any{tmp34, tmp36}) + tmp38 := lang.Apply(tmp27, []any{tmp29, tmp31, tmp37}) + tmp39 := lang.Apply(tmp26, []any{tmp38}) + tmp40 := lang.Apply(tmp24, []any{tmp25, tmp39}) + tmp41 := lang.Apply(tmp23, []any{tmp40}) + tmp42 := checkDerefVar(glojure_DOT_core_list) + var tmp43 any + tmp44 := checkDerefVar(glojure_DOT_core_empty_QMARK_) + tmp45 := lang.Apply(tmp44, []any{v18}) + if lang.IsTruthy(tmp45) { + tmp43 = v10 + } else { + tmp46 := checkDerefVar(glojure_DOT_core_last) + tmp47 := lang.Apply(tmp46, []any{v18}) + tmp43 = tmp47 + } + tmp48 := lang.Apply(tmp42, []any{tmp43}) + tmp49 := lang.Apply(tmp20, []any{tmp22, tmp41, tmp48}) + tmp50 := lang.Apply(tmp19, []any{tmp49}) + tmp7 = tmp50 + } // end let + return tmp7 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // condp + { + tmp0 := lang.NewSymbol("condp").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes a binary predicate, an expression, and a set of clauses.\n Each clause can take the form of either:\n\n test-expr result-expr\n\n test-expr :>> result-fn\n\n Note :>> is an ordinary keyword.\n\n For each clause, (pred test-expr expr) is evaluated. If it returns\n logical true, the clause is a match. If a binary clause matches, the\n result-expr is returned, if a ternary clause matches, its result-fn,\n which must be a unary function, is called with the result of the\n predicate as its argument, the result of that call being the return\n value of condp. A single default expression can follow the clauses,\n and its value will be returned if no clause matches. If no default\n expression is provided and no clause matches, an\n IllegalArgumentException is thrown.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6353), lang.NewKeyword("end-line"), int(6353))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + var v7 any = lang.NewList(args[4:]...) + _ = v7 + var tmp8 any + { // let + // let binding "gpred" + tmp9 := checkDerefVar(glojure_DOT_core_gensym) + tmp10 := lang.Apply(tmp9, []any{"pred__"}) + var v11 any = tmp10 + _ = v11 + // let binding "gexpr" + tmp12 := checkDerefVar(glojure_DOT_core_gensym) + tmp13 := lang.Apply(tmp12, []any{"expr__"}) + var v14 any = tmp13 + _ = v14 + // let binding "emit" + var tmp15 lang.FnFunc + { // function emit + var v16 lang.FnFunc + tmp15 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v17 := args[0] + _ = v17 + v18 := args[1] + _ = v18 + v19 := args[2] + _ = v19 + var tmp20 any + { // let + // let binding "vec__144" + tmp21 := checkDerefVar(glojure_DOT_core_split_at) + var tmp22 any + tmp23 := checkDerefVar(glojure_DOT_core__EQ_) + tmp24 := checkDerefVar(glojure_DOT_core_second) + tmp25 := lang.Apply(tmp24, []any{v19}) + tmp26 := lang.Apply(tmp23, []any{lang.NewKeyword(">>"), tmp25}) + if lang.IsTruthy(tmp26) { + tmp22 = int64(3) + } else { + tmp22 = int64(2) + } + tmp27 := lang.Apply(tmp21, []any{tmp22, v19}) + var v28 any = tmp27 + _ = v28 + // let binding "vec__147" + tmp29 := checkDerefVar(glojure_DOT_core_nth) + tmp30 := lang.Apply(tmp29, []any{v28, int64(0), nil}) + var v31 any = tmp30 + _ = v31 + // let binding "a" + tmp32 := checkDerefVar(glojure_DOT_core_nth) + tmp33 := lang.Apply(tmp32, []any{v31, int64(0), nil}) + var v34 any = tmp33 + _ = v34 + // let binding "b" + tmp35 := checkDerefVar(glojure_DOT_core_nth) + tmp36 := lang.Apply(tmp35, []any{v31, int64(1), nil}) + var v37 any = tmp36 + _ = v37 + // let binding "c" + tmp38 := checkDerefVar(glojure_DOT_core_nth) + tmp39 := lang.Apply(tmp38, []any{v31, int64(2), nil}) + var v40 any = tmp39 + _ = v40 + // let binding "clause" + var v41 any = v31 + _ = v41 + // let binding "more" + tmp42 := checkDerefVar(glojure_DOT_core_nth) + tmp43 := lang.Apply(tmp42, []any{v28, int64(1), nil}) + var v44 any = tmp43 + _ = v44 + // let binding "n" + tmp45 := checkDerefVar(glojure_DOT_core_count) + tmp46 := lang.Apply(tmp45, []any{v41}) + var v47 any = tmp46 + _ = v47 + var tmp48 any + tmp49 := checkDerefVar(glojure_DOT_core__EQ_) + tmp50 := lang.Apply(tmp49, []any{int64(0), v47}) + if lang.IsTruthy(tmp50) { + tmp51 := checkDerefVar(glojure_DOT_core_seq) + tmp52 := checkDerefVar(glojure_DOT_core_concat) + tmp53 := checkDerefVar(glojure_DOT_core_list) + tmp54 := lang.Apply(tmp53, []any{lang.NewSymbol("throw")}) + tmp55 := checkDerefVar(glojure_DOT_core_list) + tmp56 := checkDerefVar(glojure_DOT_core_seq) + tmp57 := checkDerefVar(glojure_DOT_core_concat) + tmp58 := checkDerefVar(glojure_DOT_core_list) + tmp59 := lang.Apply(tmp58, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewIllegalArgumentError")}) + tmp60 := checkDerefVar(glojure_DOT_core_list) + tmp61 := checkDerefVar(glojure_DOT_core_seq) + tmp62 := checkDerefVar(glojure_DOT_core_concat) + tmp63 := checkDerefVar(glojure_DOT_core_list) + tmp64 := lang.Apply(tmp63, []any{lang.NewSymbol("glojure.core/str")}) + tmp65 := checkDerefVar(glojure_DOT_core_list) + tmp66 := lang.Apply(tmp65, []any{"No matching clause: "}) + tmp67 := checkDerefVar(glojure_DOT_core_list) + tmp68 := lang.Apply(tmp67, []any{v18}) + tmp69 := lang.Apply(tmp62, []any{tmp64, tmp66, tmp68}) + tmp70 := lang.Apply(tmp61, []any{tmp69}) + tmp71 := lang.Apply(tmp60, []any{tmp70}) + tmp72 := lang.Apply(tmp57, []any{tmp59, tmp71}) + tmp73 := lang.Apply(tmp56, []any{tmp72}) + tmp74 := lang.Apply(tmp55, []any{tmp73}) + tmp75 := lang.Apply(tmp52, []any{tmp54, tmp74}) + tmp76 := lang.Apply(tmp51, []any{tmp75}) + tmp48 = tmp76 + } else { + var tmp77 any + tmp78 := checkDerefVar(glojure_DOT_core__EQ_) + tmp79 := lang.Apply(tmp78, []any{int64(1), v47}) + if lang.IsTruthy(tmp79) { + tmp77 = v34 + } else { + var tmp80 any + tmp81 := checkDerefVar(glojure_DOT_core__EQ_) + tmp82 := lang.Apply(tmp81, []any{int64(2), v47}) + if lang.IsTruthy(tmp82) { + tmp83 := checkDerefVar(glojure_DOT_core_seq) + tmp84 := checkDerefVar(glojure_DOT_core_concat) + tmp85 := checkDerefVar(glojure_DOT_core_list) + tmp86 := lang.Apply(tmp85, []any{lang.NewSymbol("if")}) + tmp87 := checkDerefVar(glojure_DOT_core_list) + tmp88 := checkDerefVar(glojure_DOT_core_seq) + tmp89 := checkDerefVar(glojure_DOT_core_concat) + tmp90 := checkDerefVar(glojure_DOT_core_list) + tmp91 := lang.Apply(tmp90, []any{v17}) + tmp92 := checkDerefVar(glojure_DOT_core_list) + tmp93 := lang.Apply(tmp92, []any{v34}) + tmp94 := checkDerefVar(glojure_DOT_core_list) + tmp95 := lang.Apply(tmp94, []any{v18}) + tmp96 := lang.Apply(tmp89, []any{tmp91, tmp93, tmp95}) + tmp97 := lang.Apply(tmp88, []any{tmp96}) + tmp98 := lang.Apply(tmp87, []any{tmp97}) + tmp99 := checkDerefVar(glojure_DOT_core_list) + tmp100 := lang.Apply(tmp99, []any{v37}) + tmp101 := checkDerefVar(glojure_DOT_core_list) + tmp102 := lang.Apply(v16, []any{v17, v18, v44}) + tmp103 := lang.Apply(tmp101, []any{tmp102}) + tmp104 := lang.Apply(tmp84, []any{tmp86, tmp98, tmp100, tmp103}) + tmp105 := lang.Apply(tmp83, []any{tmp104}) + tmp80 = tmp105 + } else { + var tmp106 any + if lang.IsTruthy(lang.NewKeyword("else")) { + tmp107 := checkDerefVar(glojure_DOT_core_seq) + tmp108 := checkDerefVar(glojure_DOT_core_concat) + tmp109 := checkDerefVar(glojure_DOT_core_list) + tmp110 := lang.Apply(tmp109, []any{lang.NewSymbol("glojure.core/if-let")}) + tmp111 := checkDerefVar(glojure_DOT_core_list) + tmp112 := checkDerefVar(glojure_DOT_core_apply) + tmp113 := checkDerefVar(glojure_DOT_core_vector) + tmp114 := checkDerefVar(glojure_DOT_core_seq) + tmp115 := checkDerefVar(glojure_DOT_core_concat) + tmp116 := checkDerefVar(glojure_DOT_core_list) + tmp117 := lang.Apply(tmp116, []any{lang.NewSymbol("p__0__auto__")}) + tmp118 := checkDerefVar(glojure_DOT_core_list) + tmp119 := checkDerefVar(glojure_DOT_core_seq) + tmp120 := checkDerefVar(glojure_DOT_core_concat) + tmp121 := checkDerefVar(glojure_DOT_core_list) + tmp122 := lang.Apply(tmp121, []any{v17}) + tmp123 := checkDerefVar(glojure_DOT_core_list) + tmp124 := lang.Apply(tmp123, []any{v34}) + tmp125 := checkDerefVar(glojure_DOT_core_list) + tmp126 := lang.Apply(tmp125, []any{v18}) + tmp127 := lang.Apply(tmp120, []any{tmp122, tmp124, tmp126}) + tmp128 := lang.Apply(tmp119, []any{tmp127}) + tmp129 := lang.Apply(tmp118, []any{tmp128}) + tmp130 := lang.Apply(tmp115, []any{tmp117, tmp129}) + tmp131 := lang.Apply(tmp114, []any{tmp130}) + tmp132 := lang.Apply(tmp112, []any{tmp113, tmp131}) + tmp133 := lang.Apply(tmp111, []any{tmp132}) + tmp134 := checkDerefVar(glojure_DOT_core_list) + tmp135 := checkDerefVar(glojure_DOT_core_seq) + tmp136 := checkDerefVar(glojure_DOT_core_concat) + tmp137 := checkDerefVar(glojure_DOT_core_list) + tmp138 := lang.Apply(tmp137, []any{v40}) + tmp139 := checkDerefVar(glojure_DOT_core_list) + tmp140 := lang.Apply(tmp139, []any{lang.NewSymbol("p__0__auto__")}) + tmp141 := lang.Apply(tmp136, []any{tmp138, tmp140}) + tmp142 := lang.Apply(tmp135, []any{tmp141}) + tmp143 := lang.Apply(tmp134, []any{tmp142}) + tmp144 := checkDerefVar(glojure_DOT_core_list) + tmp145 := lang.Apply(v16, []any{v17, v18, v44}) + tmp146 := lang.Apply(tmp144, []any{tmp145}) + tmp147 := lang.Apply(tmp108, []any{tmp110, tmp133, tmp143, tmp146}) + tmp148 := lang.Apply(tmp107, []any{tmp147}) + tmp106 = tmp148 + } else { + } + tmp80 = tmp106 + } + tmp77 = tmp80 + } + tmp48 = tmp77 + } + tmp20 = tmp48 + } // end let + return tmp20 + }) + v16 = tmp15 + _ = v16 + } + tmp16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6377), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(6389), lang.NewKeyword("end-column"), int(53)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v18 any = tmp17 + _ = v18 + tmp19 := checkDerefVar(glojure_DOT_core_seq) + tmp20 := checkDerefVar(glojure_DOT_core_concat) + tmp21 := checkDerefVar(glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("glojure.core/let")}) + tmp23 := checkDerefVar(glojure_DOT_core_list) + tmp24 := checkDerefVar(glojure_DOT_core_apply) + tmp25 := checkDerefVar(glojure_DOT_core_vector) + tmp26 := checkDerefVar(glojure_DOT_core_seq) + tmp27 := checkDerefVar(glojure_DOT_core_concat) + tmp28 := checkDerefVar(glojure_DOT_core_list) + tmp29 := lang.Apply(tmp28, []any{v11}) + tmp30 := checkDerefVar(glojure_DOT_core_list) + tmp31 := lang.Apply(tmp30, []any{v5}) + tmp32 := checkDerefVar(glojure_DOT_core_list) + tmp33 := lang.Apply(tmp32, []any{v14}) + tmp34 := checkDerefVar(glojure_DOT_core_list) + tmp35 := lang.Apply(tmp34, []any{v6}) + tmp36 := lang.Apply(tmp27, []any{tmp29, tmp31, tmp33, tmp35}) + tmp37 := lang.Apply(tmp26, []any{tmp36}) + tmp38 := lang.Apply(tmp24, []any{tmp25, tmp37}) + tmp39 := lang.Apply(tmp23, []any{tmp38}) + tmp40 := checkDerefVar(glojure_DOT_core_list) + tmp41 := lang.Apply(v18, []any{v11, v14, v7}) + tmp42 := lang.Apply(tmp40, []any{tmp41}) + tmp43 := lang.Apply(tmp20, []any{tmp22, tmp39, tmp42}) + tmp44 := lang.Apply(tmp19, []any{tmp43}) + tmp8 = tmp44 + } // end let + return tmp8 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // conj + { + tmp0 := lang.NewSymbol("conj").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("xs"))), lang.NewKeyword("doc"), "conj[oin]. Returns a new collection with the xs\n 'added'. (conj nil item) returns (item).\n (conj coll) returns coll. (conj) returns [].\n The 'addition' may happen at different 'places' depending\n on the concrete type.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(73), lang.NewKeyword("end-line"), int(81))).(*lang.Symbol) + var tmp2 lang.FnFunc + { // function conj + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp4 := lang.NewVector() + tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(82), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(82), lang.NewKeyword("end-column"), int(14)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + case 1: + v4 := args[0] + _ = v4 + return v4 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6 := lang.Apply(lang.Conj, []any{v4, v5}) + return tmp6 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + recur_loop_10: + var tmp7 any + if lang.IsTruthy(v6) { + tmp9 := lang.Apply(lang.Conj, []any{v4, v5}) + var tmp8 any = tmp9 + tmp11 := checkDerefVar(glojure_DOT_core_first) + tmp12 := lang.Apply(tmp11, []any{v6}) + var tmp10 any = tmp12 + tmp14 := checkDerefVar(glojure_DOT_core_next) + tmp15 := lang.Apply(tmp14, []any{v6}) + var tmp13 any = tmp15 + v4 = tmp8 + v5 = tmp10 + v6 = tmp13 + goto recur_loop_10 + } else { + tmp16 := lang.Apply(lang.Conj, []any{v4, v5}) + tmp7 = tmp16 + } + return tmp7 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(81), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(88), lang.NewKeyword("end-column"), int(67))).(lang.FnFunc) + v3 = tmp2 + _ = v3 + } + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // conj! + { + tmp0 := lang.NewSymbol("conj!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Adds x to the transient collection, and return coll. The 'addition'\n may happen at different 'places' depending on the concrete type.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3359), lang.NewKeyword("end-line"), int(3359))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp3 := checkDerefVar(glojure_DOT_core_transient) + tmp4 := lang.NewVector() + tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3364), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(3364), lang.NewKeyword("end-column"), int(19)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp7 := lang.Apply(tmp3, []any{tmp6}) + return tmp7 + case 1: + v3 := args[0] + _ = v3 + return v3 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(v3, "Conj") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Conj is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // cons + { + tmp0 := lang.NewSymbol("cons").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("seq"))), lang.NewKeyword("doc"), "Returns a new seq where x is the first element and seq is\n the rest.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(21), lang.NewKeyword("end-line"), int(27))).(*lang.Symbol) + var tmp2 lang.FnFunc + { // function cons + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6 := lang.Apply(lang.NewCons, []any{v4, v5}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(27), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(27), lang.NewKeyword("end-column"), int(89))).(lang.FnFunc) + v3 = tmp2 + _ = v3 + } + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // constantly + { + tmp0 := lang.NewSymbol("constantly").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns a function that takes any number of arguments and returns x.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1440), lang.NewKeyword("end-line"), int(1440))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v5 any = lang.NewList(args[0:]...) + _ = v5 + return v3 + } + }) + tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1444), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(1444), lang.NewKeyword("end-column"), int(21)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // contains? + { + tmp0 := lang.NewSymbol("contains?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("key"))), lang.NewKeyword("doc"), "Returns true if key is present in the given collection, otherwise\n returns false. Note that for numerically indexed collections like\n vectors and Java arrays, this tests if the numeric key is within the\n range of indexes. 'contains?' operates constant or logarithmic time;\n it will not perform a linear search for a value. See also 'some'.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1479), lang.NewKeyword("end-line"), int(1479))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(runtime7.RT, "Contains") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Contains is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // count + { + var tmp1 lang.FnFunc + { // function count__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := checkDerefVar(glojure_DOT_core_seq) + tmp12 := checkDerefVar(glojure_DOT_core_concat) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/Count")}) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("count").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the number of items in the collection. (count nil) returns\n 0. Also works on strings, arrays, and Java Collections and Maps", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(867), lang.NewKeyword("end-line"), int(867))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5 := lang.Apply(lang.Count, []any{v4}) + return tmp5 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // counted? + { + tmp0 := lang.NewSymbol("counted?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements count in constant time", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6241), lang.NewKeyword("end-line"), int(6241))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp5 := reflect.TypeOf((*lang.Counted)(nil)).Elem() + tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // create-ns + { + tmp0 := lang.NewSymbol("create-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Create a new namespace named by the symbol if one doesn't already\n exist, returns it or the already-existing namespace of the same\n name.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4131), lang.NewKeyword("end-line"), int(4131))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(nil, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // create-struct + { + tmp0 := lang.NewSymbol("create-struct").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keys"))), lang.NewKeyword("doc"), "Returns a structure basis object.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4037), lang.NewKeyword("end-line"), int(4037))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := lang.Apply(lang.CreatePersistentStructMapSlotMap, []any{v3}) + return tmp4 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // cycle + { + tmp0 := lang.NewSymbol("cycle").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy (infinite!) sequence of repetitions of the items in coll.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2977), lang.NewKeyword("end-line"), int(2977))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := lang.Apply(tmp4, []any{v3}) + tmp6 := lang.Apply(lang.NewCycle, []any{tmp5}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // data-reader-urls + { + tmp0 := lang.NewSymbol("data-reader-urls").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7830), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7830), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + return lang.NewList() + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // data-reader-var + { + tmp0 := lang.NewSymbol("data-reader-var").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7832), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7832), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_intern) + tmp5 := checkDerefVar(glojure_DOT_core_create_ns) + tmp6 := checkDerefVar(glojure_DOT_core_symbol) + tmp7 := checkDerefVar(glojure_DOT_core_namespace) + tmp8 := lang.Apply(tmp7, []any{v3}) + tmp9 := lang.Apply(tmp6, []any{tmp8}) + tmp10 := lang.Apply(tmp5, []any{tmp9}) + tmp11 := checkDerefVar(glojure_DOT_core_symbol) + tmp12 := checkDerefVar(glojure_DOT_core_name) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(tmp11, []any{tmp13}) + tmp15 := lang.Apply(tmp4, []any{tmp10, tmp14}) + return tmp15 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // dec + { + var tmp1 lang.FnFunc + { // function dec__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := checkDerefVar(glojure_DOT_core_seq) + tmp12 := checkDerefVar(glojure_DOT_core_concat) + tmp13 := checkDerefVar(glojure_DOT_core_list) + var tmp14 any + tmp15 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + if lang.IsTruthy(tmp15) { + tmp14 = lang.NewSymbol("unchecked_dec") + } else { + tmp14 = lang.NewSymbol("dec") + } + tmp16 := lang.Apply(tmp13, []any{tmp14}) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := lang.Apply(tmp12, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp11, []any{tmp19}) + tmp21 := lang.Apply(tmp10, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("dec").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns a number one less than num. Does not auto-promote\n longs, will throw on overflow. See also: dec'", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1147), lang.NewKeyword("end-line"), int(1147))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Dec") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Dec is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // dec' + { + var tmp1 lang.FnFunc + { // function dec'__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := checkDerefVar(glojure_DOT_core_seq) + tmp12 := checkDerefVar(glojure_DOT_core_concat) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/DecP")}) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("dec'").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns a number one less than num. Supports arbitrary precision.\n See also: dec", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1140), lang.NewKeyword("end-line"), int(1140))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "DecP") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("DecP is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // decimal? + { + tmp0 := lang.NewSymbol("decimal?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is a BigDecimal", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3599), lang.NewKeyword("end-line"), int(3599))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp5 := reflect.TypeOf((*lang.BigDecimal)(nil)) + tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // declare + { + tmp0 := lang.NewSymbol("declare").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("names"))), lang.NewKeyword("doc"), "defs the supplied var names with no bindings, useful for making forward declarations.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(2768), lang.NewKeyword("end-line"), int(2768))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := checkDerefVar(glojure_DOT_core_seq) + tmp7 := checkDerefVar(glojure_DOT_core_concat) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("do")}) + tmp10 := checkDerefVar(glojure_DOT_core_map) + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v12 := args[0] + _ = v12 + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := checkDerefVar(glojure_DOT_core_vary_meta) + tmp15 := checkDerefVar(glojure_DOT_core_assoc) + tmp16 := lang.Apply(tmp14, []any{v12, tmp15, lang.NewKeyword("declared"), true}) + tmp17 := lang.Apply(tmp13, []any{lang.NewSymbol("def"), tmp16}) + return tmp17 + }) + tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2771), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(2771), lang.NewKeyword("end-column"), int(71)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp14 := lang.Apply(tmp10, []any{tmp13, v5}) + tmp15 := lang.Apply(tmp7, []any{tmp9, tmp14}) + tmp16 := lang.Apply(tmp6, []any{tmp15}) + return tmp16 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // dedupe + { + tmp0 := lang.NewSymbol("dedupe").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence removing consecutive duplicates in coll.\n Returns a transducer when no collection is provided.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7681), lang.NewKeyword("end-line"), int(7681))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + var tmp5 any + { // let + // let binding "pv" + tmp6 := checkDerefVar(glojure_DOT_core_volatile_BANG_) + tmp7 := lang.Apply(tmp6, []any{lang.NewKeyword("glojure.core/none")}) + var v8 any = tmp7 + _ = v8 + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp10 := lang.Apply(v4, nil) + return tmp10 + case 1: + v10 := args[0] + _ = v10 + tmp11 := lang.Apply(v4, []any{v10}) + return tmp11 + case 2: + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + var tmp12 any + { // let + // let binding "prior" + tmp13 := checkDerefVar(glojure_DOT_core_deref) + tmp14 := lang.Apply(tmp13, []any{v8}) + var v15 any = tmp14 + _ = v15 + tmp16 := checkDerefVar(glojure_DOT_core_vreset_BANG_) + tmp17 := lang.Apply(tmp16, []any{v8, v11}) + _ = tmp17 + var tmp18 any + tmp19 := checkDerefVar(glojure_DOT_core__EQ_) + tmp20 := lang.Apply(tmp19, []any{v15, v11}) + if lang.IsTruthy(tmp20) { + tmp18 = v10 + } else { + tmp21 := lang.Apply(v4, []any{v10, v11}) + tmp18 = tmp21 + } + tmp12 = tmp18 + } // end let + return tmp12 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7688), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7696), lang.NewKeyword("end-column"), int(37)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp5 = tmp11 + } // end let + return tmp5 + }) + tmp4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7686), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7696), lang.NewKeyword("end-column"), int(39)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 1: + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_sequence) + tmp5 := checkDerefVar(glojure_DOT_core_dedupe) + tmp6 := lang.Apply(tmp5, nil) + tmp7 := lang.Apply(tmp4, []any{tmp6, v3}) + return tmp7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // def-aset + { + tmp0 := lang.NewSymbol("def-aset").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("method"), lang.NewSymbol("coerce"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3935), lang.NewKeyword("end-line"), int(3936), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 5 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := args[4] + _ = v7 + tmp8 := checkDerefVar(glojure_DOT_core_seq) + tmp9 := checkDerefVar(glojure_DOT_core_concat) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol("glojure.core/defn")}) + tmp12 := checkDerefVar(glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v5}) + tmp14 := checkDerefVar(glojure_DOT_core_list) + tmp15 := checkDerefVar(glojure_DOT_core_apply) + tmp16 := checkDerefVar(glojure_DOT_core_hash_map) + tmp17 := checkDerefVar(glojure_DOT_core_seq) + tmp18 := checkDerefVar(glojure_DOT_core_concat) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{lang.NewKeyword("arglists")}) + tmp21 := checkDerefVar(glojure_DOT_core_list) + tmp22 := checkDerefVar(glojure_DOT_core_seq) + tmp23 := checkDerefVar(glojure_DOT_core_concat) + tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{lang.NewSymbol("quote")}) + tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp27 := checkDerefVar(glojure_DOT_core_seq) + tmp28 := checkDerefVar(glojure_DOT_core_concat) + tmp29 := checkDerefVar(glojure_DOT_core_list) + tmp30 := checkDerefVar(glojure_DOT_core_apply) + tmp31 := checkDerefVar(glojure_DOT_core_vector) + tmp32 := checkDerefVar(glojure_DOT_core_seq) + tmp33 := checkDerefVar(glojure_DOT_core_concat) + tmp34 := checkDerefVar(glojure_DOT_core_list) + tmp35 := lang.Apply(tmp34, []any{lang.NewSymbol("array")}) + tmp36 := checkDerefVar(glojure_DOT_core_list) + tmp37 := lang.Apply(tmp36, []any{lang.NewSymbol("idx")}) + tmp38 := checkDerefVar(glojure_DOT_core_list) + tmp39 := lang.Apply(tmp38, []any{lang.NewSymbol("val")}) + tmp40 := lang.Apply(tmp33, []any{tmp35, tmp37, tmp39}) + tmp41 := lang.Apply(tmp32, []any{tmp40}) + tmp42 := lang.Apply(tmp30, []any{tmp31, tmp41}) + tmp43 := lang.Apply(tmp29, []any{tmp42}) + tmp44 := checkDerefVar(glojure_DOT_core_list) + tmp45 := checkDerefVar(glojure_DOT_core_apply) + tmp46 := checkDerefVar(glojure_DOT_core_vector) + tmp47 := checkDerefVar(glojure_DOT_core_seq) + tmp48 := checkDerefVar(glojure_DOT_core_concat) + tmp49 := checkDerefVar(glojure_DOT_core_list) + tmp50 := lang.Apply(tmp49, []any{lang.NewSymbol("array")}) + tmp51 := checkDerefVar(glojure_DOT_core_list) + tmp52 := lang.Apply(tmp51, []any{lang.NewSymbol("idx")}) + tmp53 := checkDerefVar(glojure_DOT_core_list) + tmp54 := lang.Apply(tmp53, []any{lang.NewSymbol("idx2")}) + tmp55 := checkDerefVar(glojure_DOT_core_list) + tmp56 := lang.Apply(tmp55, []any{lang.NewSymbol("&")}) + tmp57 := checkDerefVar(glojure_DOT_core_list) + tmp58 := lang.Apply(tmp57, []any{lang.NewSymbol("idxv")}) + tmp59 := lang.Apply(tmp48, []any{tmp50, tmp52, tmp54, tmp56, tmp58}) + tmp60 := lang.Apply(tmp47, []any{tmp59}) + tmp61 := lang.Apply(tmp45, []any{tmp46, tmp60}) + tmp62 := lang.Apply(tmp44, []any{tmp61}) + tmp63 := lang.Apply(tmp28, []any{tmp43, tmp62}) + tmp64 := lang.Apply(tmp27, []any{tmp63}) + tmp65 := lang.Apply(tmp26, []any{tmp64}) + tmp66 := lang.Apply(tmp23, []any{tmp25, tmp65}) + tmp67 := lang.Apply(tmp22, []any{tmp66}) + tmp68 := lang.Apply(tmp21, []any{tmp67}) + tmp69 := lang.Apply(tmp18, []any{tmp20, tmp68}) + tmp70 := lang.Apply(tmp17, []any{tmp69}) + tmp71 := lang.Apply(tmp15, []any{tmp16, tmp70}) + tmp72 := lang.Apply(tmp14, []any{tmp71}) + tmp73 := checkDerefVar(glojure_DOT_core_list) + tmp74 := checkDerefVar(glojure_DOT_core_seq) + tmp75 := checkDerefVar(glojure_DOT_core_concat) + tmp76 := checkDerefVar(glojure_DOT_core_list) + tmp77 := checkDerefVar(glojure_DOT_core_apply) + tmp78 := checkDerefVar(glojure_DOT_core_vector) + tmp79 := checkDerefVar(glojure_DOT_core_seq) + tmp80 := checkDerefVar(glojure_DOT_core_concat) + tmp81 := checkDerefVar(glojure_DOT_core_list) + tmp82 := lang.Apply(tmp81, []any{lang.NewSymbol("array__0__auto__")}) + tmp83 := checkDerefVar(glojure_DOT_core_list) + tmp84 := lang.Apply(tmp83, []any{lang.NewSymbol("idx__1__auto__")}) + tmp85 := checkDerefVar(glojure_DOT_core_list) + tmp86 := lang.Apply(tmp85, []any{lang.NewSymbol("val__2__auto__")}) + tmp87 := lang.Apply(tmp80, []any{tmp82, tmp84, tmp86}) + tmp88 := lang.Apply(tmp79, []any{tmp87}) + tmp89 := lang.Apply(tmp77, []any{tmp78, tmp88}) + tmp90 := lang.Apply(tmp76, []any{tmp89}) + tmp91 := checkDerefVar(glojure_DOT_core_list) + tmp92 := checkDerefVar(glojure_DOT_core_seq) + tmp93 := checkDerefVar(glojure_DOT_core_concat) + tmp94 := checkDerefVar(glojure_DOT_core_list) + tmp95 := lang.Apply(tmp94, []any{lang.NewSymbol(".")}) + tmp96 := checkDerefVar(glojure_DOT_core_list) + tmp97 := lang.Apply(tmp96, []any{lang.NewSymbol("glojure.core/Array")}) + tmp98 := checkDerefVar(glojure_DOT_core_list) + tmp99 := checkDerefVar(glojure_DOT_core_seq) + tmp100 := checkDerefVar(glojure_DOT_core_concat) + tmp101 := checkDerefVar(glojure_DOT_core_list) + tmp102 := lang.Apply(tmp101, []any{v6}) + tmp103 := checkDerefVar(glojure_DOT_core_list) + tmp104 := lang.Apply(tmp103, []any{lang.NewSymbol("array__0__auto__")}) + tmp105 := checkDerefVar(glojure_DOT_core_list) + tmp106 := lang.Apply(tmp105, []any{lang.NewSymbol("idx__1__auto__")}) + tmp107 := checkDerefVar(glojure_DOT_core_list) + tmp108 := checkDerefVar(glojure_DOT_core_seq) + tmp109 := checkDerefVar(glojure_DOT_core_concat) + tmp110 := checkDerefVar(glojure_DOT_core_list) + tmp111 := lang.Apply(tmp110, []any{v7}) + tmp112 := checkDerefVar(glojure_DOT_core_list) + tmp113 := lang.Apply(tmp112, []any{lang.NewSymbol("val__2__auto__")}) + tmp114 := lang.Apply(tmp109, []any{tmp111, tmp113}) + tmp115 := lang.Apply(tmp108, []any{tmp114}) + tmp116 := lang.Apply(tmp107, []any{tmp115}) + tmp117 := lang.Apply(tmp100, []any{tmp102, tmp104, tmp106, tmp116}) + tmp118 := lang.Apply(tmp99, []any{tmp117}) + tmp119 := lang.Apply(tmp98, []any{tmp118}) + tmp120 := lang.Apply(tmp93, []any{tmp95, tmp97, tmp119}) + tmp121 := lang.Apply(tmp92, []any{tmp120}) + tmp122 := lang.Apply(tmp91, []any{tmp121}) + tmp123 := checkDerefVar(glojure_DOT_core_list) + tmp124 := lang.Apply(tmp123, []any{lang.NewSymbol("val__2__auto__")}) + tmp125 := lang.Apply(tmp75, []any{tmp90, tmp122, tmp124}) + tmp126 := lang.Apply(tmp74, []any{tmp125}) + tmp127 := lang.Apply(tmp73, []any{tmp126}) + tmp128 := checkDerefVar(glojure_DOT_core_list) + tmp129 := checkDerefVar(glojure_DOT_core_seq) + tmp130 := checkDerefVar(glojure_DOT_core_concat) + tmp131 := checkDerefVar(glojure_DOT_core_list) + tmp132 := checkDerefVar(glojure_DOT_core_apply) + tmp133 := checkDerefVar(glojure_DOT_core_vector) + tmp134 := checkDerefVar(glojure_DOT_core_seq) + tmp135 := checkDerefVar(glojure_DOT_core_concat) + tmp136 := checkDerefVar(glojure_DOT_core_list) + tmp137 := lang.Apply(tmp136, []any{lang.NewSymbol("array__0__auto__")}) + tmp138 := checkDerefVar(glojure_DOT_core_list) + tmp139 := lang.Apply(tmp138, []any{lang.NewSymbol("idx__1__auto__")}) + tmp140 := checkDerefVar(glojure_DOT_core_list) + tmp141 := lang.Apply(tmp140, []any{lang.NewSymbol("idx2__3__auto__")}) + tmp142 := checkDerefVar(glojure_DOT_core_list) + tmp143 := lang.Apply(tmp142, []any{lang.NewSymbol("&")}) + tmp144 := checkDerefVar(glojure_DOT_core_list) + tmp145 := lang.Apply(tmp144, []any{lang.NewSymbol("idxv__4__auto__")}) + tmp146 := lang.Apply(tmp135, []any{tmp137, tmp139, tmp141, tmp143, tmp145}) + tmp147 := lang.Apply(tmp134, []any{tmp146}) + tmp148 := lang.Apply(tmp132, []any{tmp133, tmp147}) + tmp149 := lang.Apply(tmp131, []any{tmp148}) + tmp150 := checkDerefVar(glojure_DOT_core_list) + tmp151 := checkDerefVar(glojure_DOT_core_seq) + tmp152 := checkDerefVar(glojure_DOT_core_concat) + tmp153 := checkDerefVar(glojure_DOT_core_list) + tmp154 := lang.Apply(tmp153, []any{lang.NewSymbol("glojure.core/apply")}) + tmp155 := checkDerefVar(glojure_DOT_core_list) + tmp156 := lang.Apply(tmp155, []any{v5}) + tmp157 := checkDerefVar(glojure_DOT_core_list) + tmp158 := checkDerefVar(glojure_DOT_core_seq) + tmp159 := checkDerefVar(glojure_DOT_core_concat) + tmp160 := checkDerefVar(glojure_DOT_core_list) + tmp161 := lang.Apply(tmp160, []any{lang.NewSymbol("glojure.core/aget")}) + tmp162 := checkDerefVar(glojure_DOT_core_list) + tmp163 := lang.Apply(tmp162, []any{lang.NewSymbol("array__0__auto__")}) + tmp164 := checkDerefVar(glojure_DOT_core_list) + tmp165 := lang.Apply(tmp164, []any{lang.NewSymbol("idx__1__auto__")}) + tmp166 := lang.Apply(tmp159, []any{tmp161, tmp163, tmp165}) + tmp167 := lang.Apply(tmp158, []any{tmp166}) + tmp168 := lang.Apply(tmp157, []any{tmp167}) + tmp169 := checkDerefVar(glojure_DOT_core_list) + tmp170 := lang.Apply(tmp169, []any{lang.NewSymbol("idx2__3__auto__")}) + tmp171 := checkDerefVar(glojure_DOT_core_list) + tmp172 := lang.Apply(tmp171, []any{lang.NewSymbol("idxv__4__auto__")}) + tmp173 := lang.Apply(tmp152, []any{tmp154, tmp156, tmp168, tmp170, tmp172}) + tmp174 := lang.Apply(tmp151, []any{tmp173}) + tmp175 := lang.Apply(tmp150, []any{tmp174}) + tmp176 := lang.Apply(tmp130, []any{tmp149, tmp175}) + tmp177 := lang.Apply(tmp129, []any{tmp176}) + tmp178 := lang.Apply(tmp128, []any{tmp177}) + tmp179 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp72, tmp127, tmp178}) + tmp180 := lang.Apply(tmp8, []any{tmp179}) + return tmp180 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // definline + { + tmp0 := lang.NewSymbol("definline").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("decl"))), lang.NewKeyword("doc"), "Experimental - like defmacro, except defines a named function whose\n body is the expansion, calls to which may be expanded inline as if\n it were a macro. Cannot be used with variadic (&) args.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5253), lang.NewKeyword("end-line"), int(5253))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any + { // let + // let binding "vec__80" + tmp8 := checkDerefVar(glojure_DOT_core_split_with) + tmp9 := checkDerefVar(glojure_DOT_core_comp) + tmp10 := checkDerefVar(glojure_DOT_core_not) + tmp11 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp12 := lang.Apply(tmp9, []any{tmp10, tmp11}) + tmp13 := lang.Apply(tmp8, []any{tmp12, v6}) + var v14 any = tmp13 + _ = v14 + // let binding "pre-args" + tmp15 := checkDerefVar(glojure_DOT_core_nth) + tmp16 := lang.Apply(tmp15, []any{v14, int64(0), nil}) + var v17 any = tmp16 + _ = v17 + // let binding "vec__83" + tmp18 := checkDerefVar(glojure_DOT_core_nth) + tmp19 := lang.Apply(tmp18, []any{v14, int64(1), nil}) + var v20 any = tmp19 + _ = v20 + // let binding "args" + tmp21 := checkDerefVar(glojure_DOT_core_nth) + tmp22 := lang.Apply(tmp21, []any{v20, int64(0), nil}) + var v23 any = tmp22 + _ = v23 + // let binding "expr" + tmp24 := checkDerefVar(glojure_DOT_core_nth) + tmp25 := lang.Apply(tmp24, []any{v20, int64(1), nil}) + var v26 any = tmp25 + _ = v26 + tmp27 := checkDerefVar(glojure_DOT_core_seq) + tmp28 := checkDerefVar(glojure_DOT_core_concat) + tmp29 := checkDerefVar(glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("do")}) + tmp31 := checkDerefVar(glojure_DOT_core_list) + tmp32 := checkDerefVar(glojure_DOT_core_seq) + tmp33 := checkDerefVar(glojure_DOT_core_concat) + tmp34 := checkDerefVar(glojure_DOT_core_list) + tmp35 := lang.Apply(tmp34, []any{lang.NewSymbol("glojure.core/defn")}) + tmp36 := checkDerefVar(glojure_DOT_core_list) + tmp37 := lang.Apply(tmp36, []any{v5}) + tmp38 := checkDerefVar(glojure_DOT_core_list) + tmp39 := lang.Apply(tmp38, []any{v23}) + tmp40 := checkDerefVar(glojure_DOT_core_list) + tmp41 := checkDerefVar(glojure_DOT_core_apply) + tmp42 := checkDerefVar(glojure_DOT_core_eval) + tmp43 := checkDerefVar(glojure_DOT_core_list) + tmp44 := lang.Apply(tmp43, []any{lang.NewSymbol("glojure.core/fn"), v23, v26}) + tmp45 := lang.Apply(tmp42, []any{tmp44}) + tmp46 := lang.Apply(tmp41, []any{tmp45, v23}) + tmp47 := lang.Apply(tmp40, []any{tmp46}) + tmp48 := lang.Apply(tmp33, []any{tmp35, tmp37, v17, tmp39, tmp47}) + tmp49 := lang.Apply(tmp32, []any{tmp48}) + tmp50 := lang.Apply(tmp31, []any{tmp49}) + tmp51 := checkDerefVar(glojure_DOT_core_list) + tmp52 := checkDerefVar(glojure_DOT_core_seq) + tmp53 := checkDerefVar(glojure_DOT_core_concat) + tmp54 := checkDerefVar(glojure_DOT_core_list) + tmp55 := lang.Apply(tmp54, []any{lang.NewSymbol("glojure.core/alter-meta!")}) + tmp56 := checkDerefVar(glojure_DOT_core_list) + tmp57 := checkDerefVar(glojure_DOT_core_seq) + tmp58 := checkDerefVar(glojure_DOT_core_concat) + tmp59 := checkDerefVar(glojure_DOT_core_list) + tmp60 := lang.Apply(tmp59, []any{lang.NewSymbol("var")}) + tmp61 := checkDerefVar(glojure_DOT_core_list) + tmp62 := lang.Apply(tmp61, []any{v5}) + tmp63 := lang.Apply(tmp58, []any{tmp60, tmp62}) + tmp64 := lang.Apply(tmp57, []any{tmp63}) + tmp65 := lang.Apply(tmp56, []any{tmp64}) + tmp66 := checkDerefVar(glojure_DOT_core_list) + tmp67 := lang.Apply(tmp66, []any{lang.NewSymbol("glojure.core/assoc")}) + tmp68 := checkDerefVar(glojure_DOT_core_list) + tmp69 := lang.Apply(tmp68, []any{lang.NewKeyword("inline")}) + tmp70 := checkDerefVar(glojure_DOT_core_list) + tmp71 := checkDerefVar(glojure_DOT_core_seq) + tmp72 := checkDerefVar(glojure_DOT_core_concat) + tmp73 := checkDerefVar(glojure_DOT_core_list) + tmp74 := lang.Apply(tmp73, []any{lang.NewSymbol("glojure.core/fn")}) + tmp75 := checkDerefVar(glojure_DOT_core_list) + tmp76 := lang.Apply(tmp75, []any{v5}) + tmp77 := checkDerefVar(glojure_DOT_core_list) + tmp78 := lang.Apply(tmp77, []any{v23}) + tmp79 := checkDerefVar(glojure_DOT_core_list) + tmp80 := lang.Apply(tmp79, []any{v26}) + tmp81 := lang.Apply(tmp72, []any{tmp74, tmp76, tmp78, tmp80}) + tmp82 := lang.Apply(tmp71, []any{tmp81}) + tmp83 := lang.Apply(tmp70, []any{tmp82}) + tmp84 := lang.Apply(tmp53, []any{tmp55, tmp65, tmp67, tmp69, tmp83}) + tmp85 := lang.Apply(tmp52, []any{tmp84}) + tmp86 := lang.Apply(tmp51, []any{tmp85}) + tmp87 := checkDerefVar(glojure_DOT_core_list) + tmp88 := checkDerefVar(glojure_DOT_core_seq) + tmp89 := checkDerefVar(glojure_DOT_core_concat) + tmp90 := checkDerefVar(glojure_DOT_core_list) + tmp91 := lang.Apply(tmp90, []any{lang.NewSymbol("var")}) + tmp92 := checkDerefVar(glojure_DOT_core_list) + tmp93 := lang.Apply(tmp92, []any{v5}) + tmp94 := lang.Apply(tmp89, []any{tmp91, tmp93}) + tmp95 := lang.Apply(tmp88, []any{tmp94}) + tmp96 := lang.Apply(tmp87, []any{tmp95}) + tmp97 := lang.Apply(tmp28, []any{tmp30, tmp50, tmp86, tmp96}) + tmp98 := lang.Apply(tmp27, []any{tmp97}) + tmp7 = tmp98 + } // end let + return tmp7 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // defmacro + { + tmp0 := lang.NewSymbol("defmacro").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("doc-string?"), lang.NewSymbol("attr-map?"), lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("body")), lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("doc-string?"), lang.NewSymbol("attr-map?"), lang.NewList(lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("body")), lang.NewSymbol("+"), lang.NewSymbol("attr-map?"))), lang.NewKeyword("doc"), "Like defn, but the resulting function name is declared as a\n macro and will be used as a macro by the compiler when it is\n called.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(445), lang.NewKeyword("end-line"), int(451))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any + { // let + // let binding "prefix" + var tmp8 any + { // let + // let binding "p" + tmp9 := checkDerefVar(glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{v5}) + var v11 any = tmp10 + _ = v11 + // let binding "args" + var v12 any = v6 + _ = v12 + for { + var tmp13 any + { // let + // let binding "f" + tmp14 := checkDerefVar(glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v12}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + tmp18 := checkDerefVar(glojure_DOT_core_string_QMARK_) + tmp19 := lang.Apply(tmp18, []any{v16}) + if lang.IsTruthy(tmp19) { + tmp21 := checkDerefVar(glojure_DOT_core_cons) + tmp22 := lang.Apply(tmp21, []any{v16, v11}) + var tmp20 any = tmp22 + tmp24 := checkDerefVar(glojure_DOT_core_next) + tmp25 := lang.Apply(tmp24, []any{v12}) + var tmp23 any = tmp25 + v11 = tmp20 + v12 = tmp23 + continue + } else { + var tmp26 any + tmp27 := checkDerefVar(glojure_DOT_core_map_QMARK_) + tmp28 := lang.Apply(tmp27, []any{v16}) + if lang.IsTruthy(tmp28) { + tmp30 := checkDerefVar(glojure_DOT_core_cons) + tmp31 := lang.Apply(tmp30, []any{v16, v11}) + var tmp29 any = tmp31 + tmp33 := checkDerefVar(glojure_DOT_core_next) + tmp34 := lang.Apply(tmp33, []any{v12}) + var tmp32 any = tmp34 + v11 = tmp29 + v12 = tmp32 + continue + } else { + tmp26 = v11 + } + tmp17 = tmp26 + } + tmp13 = tmp17 + } // end let + tmp8 = tmp13 + break + } + } // end let + var v9 any = tmp8 + _ = v9 + // let binding "fdecl" + var tmp10 any + { // let + // let binding "fd" + var v11 any = v6 + _ = v11 + for { + var tmp12 any + tmp13 := checkDerefVar(glojure_DOT_core_string_QMARK_) + tmp14 := checkDerefVar(glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v11}) + tmp16 := lang.Apply(tmp13, []any{tmp15}) + if lang.IsTruthy(tmp16) { + tmp18 := checkDerefVar(glojure_DOT_core_next) + tmp19 := lang.Apply(tmp18, []any{v11}) + var tmp17 any = tmp19 + v11 = tmp17 + continue + } else { + var tmp20 any + tmp21 := checkDerefVar(glojure_DOT_core_map_QMARK_) + tmp22 := checkDerefVar(glojure_DOT_core_first) + tmp23 := lang.Apply(tmp22, []any{v11}) + tmp24 := lang.Apply(tmp21, []any{tmp23}) + if lang.IsTruthy(tmp24) { + tmp26 := checkDerefVar(glojure_DOT_core_next) + tmp27 := lang.Apply(tmp26, []any{v11}) + var tmp25 any = tmp27 + v11 = tmp25 + continue + } else { + tmp20 = v11 + } + tmp12 = tmp20 + } + tmp10 = tmp12 + break + } + } // end let + var v11 any = tmp10 + _ = v11 + // let binding "fdecl" + var tmp12 any + tmp13 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp14 := checkDerefVar(glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v11}) + tmp16 := lang.Apply(tmp13, []any{tmp15}) + if lang.IsTruthy(tmp16) { + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v11}) + tmp12 = tmp18 + } else { + tmp12 = v11 + } + var v19 any = tmp12 + _ = v19 + // let binding "add-implicit-args" + var tmp20 lang.FnFunc + tmp20 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v21 := args[0] + _ = v21 + var tmp22 any + { // let + // let binding "args" + tmp23 := checkDerefVar(glojure_DOT_core_first) + tmp24 := lang.Apply(tmp23, []any{v21}) + var v25 any = tmp24 + _ = v25 + tmp26 := checkDerefVar(glojure_DOT_core_cons) + tmp27 := checkDerefVar(glojure_DOT_core_vec) + tmp28 := checkDerefVar(glojure_DOT_core_cons) + tmp29 := checkDerefVar(glojure_DOT_core_cons) + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("&env"), v25}) + tmp31 := lang.Apply(tmp28, []any{lang.NewSymbol("&form"), tmp30}) + tmp32 := lang.Apply(tmp27, []any{tmp31}) + tmp33 := checkDerefVar(glojure_DOT_core_next) + tmp34 := lang.Apply(tmp33, []any{v21}) + tmp35 := lang.Apply(tmp26, []any{tmp32, tmp34}) + tmp22 = tmp35 + } // end let + return tmp22 + }) + tmp21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(469), lang.NewKeyword("column"), int(38), lang.NewKeyword("end-line"), int(471), lang.NewKeyword("end-column"), int(87)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v23 any = tmp22 + _ = v23 + // let binding "add-args" + var tmp24 lang.FnFunc + tmp24 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v25 := args[0] + _ = v25 + v26 := args[1] + _ = v26 + recur_loop_61: + var tmp27 any + tmp28 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp29 := lang.Apply(tmp28, []any{v26}) + if lang.IsTruthy(tmp29) { + tmp27 = v25 + } else { + var tmp30 any + { // let + // let binding "d" + tmp31 := checkDerefVar(glojure_DOT_core_first) + tmp32 := lang.Apply(tmp31, []any{v26}) + var v33 any = tmp32 + _ = v33 + var tmp34 any + tmp35 := checkDerefVar(glojure_DOT_core_map_QMARK_) + tmp36 := lang.Apply(tmp35, []any{v33}) + if lang.IsTruthy(tmp36) { + tmp37 := checkDerefVar(glojure_DOT_core_conj) + tmp38 := lang.Apply(tmp37, []any{v25, v33}) + tmp34 = tmp38 + } else { + tmp40 := checkDerefVar(glojure_DOT_core_conj) + tmp41 := lang.Apply(v23, []any{v33}) + tmp42 := lang.Apply(tmp40, []any{v25, tmp41}) + var tmp39 any = tmp42 + tmp44 := checkDerefVar(glojure_DOT_core_next) + tmp45 := lang.Apply(tmp44, []any{v26}) + var tmp43 any = tmp45 + v25 = tmp39 + v26 = tmp43 + goto recur_loop_61 + } + tmp30 = tmp34 + } // end let + tmp27 = tmp30 + } + return tmp27 + }) + tmp25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(472), lang.NewKeyword("column"), int(29), lang.NewKeyword("end-line"), int(478), lang.NewKeyword("end-column"), int(90)) + tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v27 any = tmp26 + _ = v27 + // let binding "fdecl" + tmp28 := checkDerefVar(glojure_DOT_core_seq) + tmp29 := lang.NewVector() + tmp30 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(479), lang.NewKeyword("column"), int(41), lang.NewKeyword("end-line"), int(479), lang.NewKeyword("end-column"), int(42)) + tmp31, err := lang.WithMeta(tmp29, tmp30.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp32 := lang.Apply(v27, []any{tmp31, v19}) + tmp33 := lang.Apply(tmp28, []any{tmp32}) + var v34 any = tmp33 + _ = v34 + // let binding "decl" + var tmp35 any + { // let + // let binding "p" + var v36 any = v9 + _ = v36 + // let binding "d" + var v37 any = v34 + _ = v37 + for { + var tmp38 any + if lang.IsTruthy(v36) { + tmp40 := checkDerefVar(glojure_DOT_core_next) + tmp41 := lang.Apply(tmp40, []any{v36}) + var tmp39 any = tmp41 + tmp43 := checkDerefVar(glojure_DOT_core_cons) + tmp44 := checkDerefVar(glojure_DOT_core_first) + tmp45 := lang.Apply(tmp44, []any{v36}) + tmp46 := lang.Apply(tmp43, []any{tmp45, v37}) + var tmp42 any = tmp46 + v36 = tmp39 + v37 = tmp42 + continue + } else { + tmp38 = v37 + } + tmp35 = tmp38 + break + } + } // end let + var v36 any = tmp35 + _ = v36 + tmp37 := checkDerefVar(glojure_DOT_core_list) + tmp38 := checkDerefVar(glojure_DOT_core_cons) + tmp39 := lang.Apply(tmp38, []any{lang.NewSymbol("glojure.core/defn"), v36}) + tmp40 := checkDerefVar(glojure_DOT_core_list) + tmp41 := checkDerefVar(glojure_DOT_core_list) + tmp42 := lang.Apply(tmp41, []any{lang.NewSymbol("var"), v5}) + tmp43 := lang.Apply(tmp40, []any{lang.NewSymbol("."), tmp42, lang.NewList(lang.NewSymbol("SetMacro"))}) + tmp44 := checkDerefVar(glojure_DOT_core_list) + tmp45 := lang.Apply(tmp44, []any{lang.NewSymbol("var"), v5}) + tmp46 := lang.Apply(tmp37, []any{lang.NewSymbol("do"), tmp39, tmp43, tmp45}) + tmp7 = tmp46 + } // end let + return tmp7 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(451), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(487), lang.NewKeyword("end-column"), int(40))).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // defmethod + { + tmp0 := lang.NewSymbol("defmethod").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"), lang.NewSymbol("dispatch-val"), lang.NewSymbol("&"), lang.NewSymbol("fn-tail"))), lang.NewKeyword("doc"), "Creates and installs a new method of multimethod associated with dispatch-value. ", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1781), lang.NewKeyword("end-line"), int(1781))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + var v7 any = lang.NewList(args[4:]...) + _ = v7 + tmp8 := checkDerefVar(glojure_DOT_core_seq) + tmp9 := checkDerefVar(glojure_DOT_core_concat) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol(".")}) + tmp12 := checkDerefVar(glojure_DOT_core_list) + tmp13 := checkDerefVar(glojure_DOT_core_with_meta) + tmp14 := lang.NewMap(lang.NewKeyword("tag"), lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.*MultiFn")) + tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1785), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(1785), lang.NewKeyword("end-column"), int(82)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp17 := lang.Apply(tmp13, []any{v5, tmp16}) + tmp18 := lang.Apply(tmp12, []any{tmp17}) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{lang.NewSymbol("glojure.core/AddMethod")}) + tmp21 := checkDerefVar(glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v6}) + tmp23 := checkDerefVar(glojure_DOT_core_list) + tmp24 := checkDerefVar(glojure_DOT_core_seq) + tmp25 := checkDerefVar(glojure_DOT_core_concat) + tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{lang.NewSymbol("glojure.core/fn")}) + tmp28 := lang.Apply(tmp25, []any{tmp27, v7}) + tmp29 := lang.Apply(tmp24, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp29}) + tmp31 := lang.Apply(tmp9, []any{tmp11, tmp18, tmp20, tmp22, tmp30}) + tmp32 := lang.Apply(tmp8, []any{tmp31}) + return tmp32 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // defmulti + { + tmp0 := lang.NewSymbol("defmulti").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("docstring?"), lang.NewSymbol("attr-map?"), lang.NewSymbol("dispatch-fn"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Creates a new multimethod with the associated dispatch function.\n The docstring and attr-map are optional.\n\n Options are key-value pairs and may be one of:\n\n :default\n\n The default dispatch value, defaults to :default\n\n :hierarchy\n\n The value used for hierarchical dispatch (e.g. ::square is-a ::shape)\n\n Hierarchies are type-like relationships that do not depend upon type\n inheritance. By default Clojure's multimethods dispatch off of a\n global hierarchy map. However, a hierarchy relationship can be\n created with the derive function used to augment the root ancestor\n created with make-hierarchy.\n\n Multimethods expect the value of the hierarchy option to be supplied as\n a reference type e.g. a var (i.e. via the Var-quote dispatch macro #'\n or the var special form).", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1723), lang.NewKeyword("end-line"), int(1723))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any + { // let + // let binding "docstring" + var tmp8 any + tmp9 := checkDerefVar(glojure_DOT_core_string_QMARK_) + tmp10 := checkDerefVar(glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v6}) + tmp12 := lang.Apply(tmp9, []any{tmp11}) + if lang.IsTruthy(tmp12) { + tmp13 := checkDerefVar(glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v6}) + tmp8 = tmp14 + } else { + } + var v15 any = tmp8 + _ = v15 + // let binding "options" + var tmp16 any + tmp17 := checkDerefVar(glojure_DOT_core_string_QMARK_) + tmp18 := checkDerefVar(glojure_DOT_core_first) + tmp19 := lang.Apply(tmp18, []any{v6}) + tmp20 := lang.Apply(tmp17, []any{tmp19}) + if lang.IsTruthy(tmp20) { + tmp21 := checkDerefVar(glojure_DOT_core_next) + tmp22 := lang.Apply(tmp21, []any{v6}) + tmp16 = tmp22 + } else { + tmp16 = v6 + } + var v23 any = tmp16 + _ = v23 + // let binding "m" + var tmp24 any + tmp25 := checkDerefVar(glojure_DOT_core_map_QMARK_) + tmp26 := checkDerefVar(glojure_DOT_core_first) + tmp27 := lang.Apply(tmp26, []any{v23}) + tmp28 := lang.Apply(tmp25, []any{tmp27}) + if lang.IsTruthy(tmp28) { + tmp29 := checkDerefVar(glojure_DOT_core_first) + tmp30 := lang.Apply(tmp29, []any{v23}) + tmp24 = tmp30 + } else { + tmp31 := lang.NewMap() + tmp32 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1757), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(1757), lang.NewKeyword("end-column"), int(24)) + tmp33, err := lang.WithMeta(tmp31, tmp32.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp24 = tmp33 + } + var v34 any = tmp24 + _ = v34 + // let binding "options" + var tmp35 any + tmp36 := checkDerefVar(glojure_DOT_core_map_QMARK_) + tmp37 := checkDerefVar(glojure_DOT_core_first) + tmp38 := lang.Apply(tmp37, []any{v23}) + tmp39 := lang.Apply(tmp36, []any{tmp38}) + if lang.IsTruthy(tmp39) { + tmp40 := checkDerefVar(glojure_DOT_core_next) + tmp41 := lang.Apply(tmp40, []any{v23}) + tmp35 = tmp41 + } else { + tmp35 = v23 + } + var v42 any = tmp35 + _ = v42 + // let binding "dispatch-fn" + tmp43 := checkDerefVar(glojure_DOT_core_first) + tmp44 := lang.Apply(tmp43, []any{v42}) + var v45 any = tmp44 + _ = v45 + // let binding "options" + tmp46 := checkDerefVar(glojure_DOT_core_next) + tmp47 := lang.Apply(tmp46, []any{v42}) + var v48 any = tmp47 + _ = v48 + // let binding "m" + var tmp49 any + if lang.IsTruthy(v15) { + tmp50 := checkDerefVar(glojure_DOT_core_assoc) + tmp51 := lang.Apply(tmp50, []any{v34, lang.NewKeyword("doc"), v15}) + tmp49 = tmp51 + } else { + tmp49 = v34 + } + var v52 any = tmp49 + _ = v52 + // let binding "m" + var tmp53 any + tmp54 := checkDerefVar(glojure_DOT_core_meta) + tmp55 := lang.Apply(tmp54, []any{v5}) + if lang.IsTruthy(tmp55) { + tmp56 := checkDerefVar(glojure_DOT_core_conj) + tmp57 := checkDerefVar(glojure_DOT_core_meta) + tmp58 := lang.Apply(tmp57, []any{v5}) + tmp59 := lang.Apply(tmp56, []any{tmp58, v52}) + tmp53 = tmp59 + } else { + tmp53 = v52 + } + var v60 any = tmp53 + _ = v60 + // let binding "mm-name" + tmp61 := checkDerefVar(glojure_DOT_core_with_meta) + tmp62 := lang.Apply(tmp61, []any{v5, v60}) + var v63 any = tmp62 + _ = v63 + var tmp64 any + tmp65 := checkDerefVar(glojure_DOT_core__EQ_) + tmp66 := checkDerefVar(glojure_DOT_core_count) + tmp67 := lang.Apply(tmp66, []any{v48}) + tmp68 := lang.Apply(tmp65, []any{tmp67, int64(1)}) + if lang.IsTruthy(tmp68) { + tmp69 := lang.Apply(lang.NewError, []any{"The syntax for defmulti has changed. Example: (defmulti name dispatch-fn :default dispatch-value)"}) + panic(tmp69) + } else { + } + _ = tmp64 + var tmp70 any + { // let + // let binding "options" + tmp71 := checkDerefVar(glojure_DOT_core_apply) + tmp72 := checkDerefVar(glojure_DOT_core_hash_map) + tmp73 := lang.Apply(tmp71, []any{tmp72, v48}) + var v74 any = tmp73 + _ = v74 + // let binding "default" + tmp75 := checkDerefVar(glojure_DOT_core_get) + tmp76 := lang.Apply(tmp75, []any{v74, lang.NewKeyword("default"), lang.NewKeyword("default")}) + var v77 any = tmp76 + _ = v77 + // let binding "hierarchy" + tmp78 := checkDerefVar(glojure_DOT_core_get) + tmp79 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("global-hierarchy")) + tmp80 := lang.Apply(tmp78, []any{v74, lang.NewKeyword("hierarchy"), tmp79}) + var v81 any = tmp80 + _ = v81 + tmp82 := checkDerefVar(glojure_DOT_core_check_valid_options) + tmp83 := lang.Apply(tmp82, []any{v74, lang.NewKeyword("default"), lang.NewKeyword("hierarchy")}) + _ = tmp83 + tmp84 := checkDerefVar(glojure_DOT_core_seq) + tmp85 := checkDerefVar(glojure_DOT_core_concat) + tmp86 := checkDerefVar(glojure_DOT_core_list) + tmp87 := lang.Apply(tmp86, []any{lang.NewSymbol("glojure.core/let")}) + tmp88 := checkDerefVar(glojure_DOT_core_list) + tmp89 := checkDerefVar(glojure_DOT_core_apply) + tmp90 := checkDerefVar(glojure_DOT_core_vector) + tmp91 := checkDerefVar(glojure_DOT_core_seq) + tmp92 := checkDerefVar(glojure_DOT_core_concat) + tmp93 := checkDerefVar(glojure_DOT_core_list) + tmp94 := lang.Apply(tmp93, []any{lang.NewSymbol("v__0__auto__")}) + tmp95 := checkDerefVar(glojure_DOT_core_list) + tmp96 := checkDerefVar(glojure_DOT_core_seq) + tmp97 := checkDerefVar(glojure_DOT_core_concat) + tmp98 := checkDerefVar(glojure_DOT_core_list) + tmp99 := lang.Apply(tmp98, []any{lang.NewSymbol("def")}) + tmp100 := checkDerefVar(glojure_DOT_core_list) + tmp101 := lang.Apply(tmp100, []any{v63}) + tmp102 := lang.Apply(tmp97, []any{tmp99, tmp101}) + tmp103 := lang.Apply(tmp96, []any{tmp102}) + tmp104 := lang.Apply(tmp95, []any{tmp103}) + tmp105 := lang.Apply(tmp92, []any{tmp94, tmp104}) + tmp106 := lang.Apply(tmp91, []any{tmp105}) + tmp107 := lang.Apply(tmp89, []any{tmp90, tmp106}) + tmp108 := lang.Apply(tmp88, []any{tmp107}) + tmp109 := checkDerefVar(glojure_DOT_core_list) + tmp110 := checkDerefVar(glojure_DOT_core_seq) + tmp111 := checkDerefVar(glojure_DOT_core_concat) + tmp112 := checkDerefVar(glojure_DOT_core_list) + tmp113 := lang.Apply(tmp112, []any{lang.NewSymbol("glojure.core/when-not")}) + tmp114 := checkDerefVar(glojure_DOT_core_list) + tmp115 := checkDerefVar(glojure_DOT_core_seq) + tmp116 := checkDerefVar(glojure_DOT_core_concat) + tmp117 := checkDerefVar(glojure_DOT_core_list) + tmp118 := lang.Apply(tmp117, []any{lang.NewSymbol("glojure.core/and")}) + tmp119 := checkDerefVar(glojure_DOT_core_list) + tmp120 := checkDerefVar(glojure_DOT_core_seq) + tmp121 := checkDerefVar(glojure_DOT_core_concat) + tmp122 := checkDerefVar(glojure_DOT_core_list) + tmp123 := lang.Apply(tmp122, []any{lang.NewSymbol(".HasRoot")}) + tmp124 := checkDerefVar(glojure_DOT_core_list) + tmp125 := lang.Apply(tmp124, []any{lang.NewSymbol("v__0__auto__")}) + tmp126 := lang.Apply(tmp121, []any{tmp123, tmp125}) + tmp127 := lang.Apply(tmp120, []any{tmp126}) + tmp128 := lang.Apply(tmp119, []any{tmp127}) + tmp129 := checkDerefVar(glojure_DOT_core_list) + tmp130 := checkDerefVar(glojure_DOT_core_seq) + tmp131 := checkDerefVar(glojure_DOT_core_concat) + tmp132 := checkDerefVar(glojure_DOT_core_list) + tmp133 := lang.Apply(tmp132, []any{lang.NewSymbol("glojure.core/instance?")}) + tmp134 := checkDerefVar(glojure_DOT_core_list) + tmp135 := lang.Apply(tmp134, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.*MultiFn")}) + tmp136 := checkDerefVar(glojure_DOT_core_list) + tmp137 := checkDerefVar(glojure_DOT_core_seq) + tmp138 := checkDerefVar(glojure_DOT_core_concat) + tmp139 := checkDerefVar(glojure_DOT_core_list) + tmp140 := lang.Apply(tmp139, []any{lang.NewSymbol("glojure.core/deref")}) + tmp141 := checkDerefVar(glojure_DOT_core_list) + tmp142 := lang.Apply(tmp141, []any{lang.NewSymbol("v__0__auto__")}) + tmp143 := lang.Apply(tmp138, []any{tmp140, tmp142}) + tmp144 := lang.Apply(tmp137, []any{tmp143}) + tmp145 := lang.Apply(tmp136, []any{tmp144}) + tmp146 := lang.Apply(tmp131, []any{tmp133, tmp135, tmp145}) + tmp147 := lang.Apply(tmp130, []any{tmp146}) + tmp148 := lang.Apply(tmp129, []any{tmp147}) + tmp149 := lang.Apply(tmp116, []any{tmp118, tmp128, tmp148}) + tmp150 := lang.Apply(tmp115, []any{tmp149}) + tmp151 := lang.Apply(tmp114, []any{tmp150}) + tmp152 := checkDerefVar(glojure_DOT_core_list) + tmp153 := checkDerefVar(glojure_DOT_core_seq) + tmp154 := checkDerefVar(glojure_DOT_core_concat) + tmp155 := checkDerefVar(glojure_DOT_core_list) + tmp156 := lang.Apply(tmp155, []any{lang.NewSymbol("def")}) + tmp157 := checkDerefVar(glojure_DOT_core_list) + tmp158 := lang.Apply(tmp157, []any{v63}) + tmp159 := checkDerefVar(glojure_DOT_core_list) + tmp160 := checkDerefVar(glojure_DOT_core_seq) + tmp161 := checkDerefVar(glojure_DOT_core_concat) + tmp162 := checkDerefVar(glojure_DOT_core_list) + tmp163 := lang.Apply(tmp162, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewMultiFn")}) + tmp164 := checkDerefVar(glojure_DOT_core_list) + tmp165 := checkDerefVar(glojure_DOT_core_name) + tmp166 := lang.Apply(tmp165, []any{v63}) + tmp167 := lang.Apply(tmp164, []any{tmp166}) + tmp168 := checkDerefVar(glojure_DOT_core_list) + tmp169 := lang.Apply(tmp168, []any{v45}) + tmp170 := checkDerefVar(glojure_DOT_core_list) + tmp171 := lang.Apply(tmp170, []any{v77}) + tmp172 := checkDerefVar(glojure_DOT_core_list) + tmp173 := lang.Apply(tmp172, []any{v81}) + tmp174 := lang.Apply(tmp161, []any{tmp163, tmp167, tmp169, tmp171, tmp173}) + tmp175 := lang.Apply(tmp160, []any{tmp174}) + tmp176 := lang.Apply(tmp159, []any{tmp175}) + tmp177 := lang.Apply(tmp154, []any{tmp156, tmp158, tmp176}) + tmp178 := lang.Apply(tmp153, []any{tmp177}) + tmp179 := lang.Apply(tmp152, []any{tmp178}) + tmp180 := lang.Apply(tmp111, []any{tmp113, tmp151, tmp179}) + tmp181 := lang.Apply(tmp110, []any{tmp180}) + tmp182 := lang.Apply(tmp109, []any{tmp181}) + tmp183 := lang.Apply(tmp85, []any{tmp87, tmp108, tmp182}) + tmp184 := lang.Apply(tmp84, []any{tmp183}) + tmp70 = tmp184 + } // end let + tmp7 = tmp70 + } // end let + return tmp7 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // defn + { + tmp0 := lang.NewSymbol("defn").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("doc-string?"), lang.NewSymbol("attr-map?"), lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("prepost-map?"), lang.NewSymbol("body")), lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("doc-string?"), lang.NewSymbol("attr-map?"), lang.NewList(lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("prepost-map?"), lang.NewSymbol("body")), lang.NewSymbol("+"), lang.NewSymbol("attr-map?"))), lang.NewKeyword("doc"), "Same as (def name (fn [params* ] exprs*)) or (def\n name (fn ([params* ] exprs*)+)) with any doc-string or attrs added\n to the var metadata. prepost-map defines a map with optional keys\n :pre and :post that contain collections of pre or post conditions.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(284), lang.NewKeyword("end-line"), int(291))).(*lang.Symbol) + var tmp2 lang.FnFunc + { // function defn + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := args[2] + _ = v6 + var v7 any = lang.NewList(args[3:]...) + _ = v7 + var tmp8 any + tmp9 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp10 := reflect.TypeOf((*lang.Symbol)(nil)) + tmp11 := lang.Apply(tmp9, []any{tmp10, v6}) + if lang.IsTruthy(tmp11) { + } else { + tmp12 := lang.Apply(lang.NewIllegalArgumentError, []any{"First argument to defn must be a symbol"}) + panic(tmp12) + } + _ = tmp8 + var tmp13 any + { // let + // let binding "m" + var tmp14 any + tmp15 := checkDerefVar(glojure_DOT_core_string_QMARK_) + tmp16 := checkDerefVar(glojure_DOT_core_first) + tmp17 := lang.Apply(tmp16, []any{v7}) + tmp18 := lang.Apply(tmp15, []any{tmp17}) + if lang.IsTruthy(tmp18) { + tmp19 := checkDerefVar(glojure_DOT_core_first) + tmp20 := lang.Apply(tmp19, []any{v7}) + tmp21 := lang.NewMap(lang.NewKeyword("doc"), tmp20) + tmp22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(297), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(297), lang.NewKeyword("end-column"), int(38)) + tmp23, err := lang.WithMeta(tmp21, tmp22.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp14 = tmp23 + } else { + tmp24 := lang.NewMap() + tmp25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(298), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(298), lang.NewKeyword("end-column"), int(20)) + tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp14 = tmp26 + } + var v27 any = tmp14 + _ = v27 + // let binding "fdecl" + var tmp28 any + tmp29 := checkDerefVar(glojure_DOT_core_string_QMARK_) + tmp30 := checkDerefVar(glojure_DOT_core_first) + tmp31 := lang.Apply(tmp30, []any{v7}) + tmp32 := lang.Apply(tmp29, []any{tmp31}) + if lang.IsTruthy(tmp32) { + tmp33 := checkDerefVar(glojure_DOT_core_next) + tmp34 := lang.Apply(tmp33, []any{v7}) + tmp28 = tmp34 + } else { + tmp28 = v7 + } + var v35 any = tmp28 + _ = v35 + // let binding "m" + var tmp36 any + tmp37 := checkDerefVar(glojure_DOT_core_map_QMARK_) + tmp38 := checkDerefVar(glojure_DOT_core_first) + tmp39 := lang.Apply(tmp38, []any{v35}) + tmp40 := lang.Apply(tmp37, []any{tmp39}) + if lang.IsTruthy(tmp40) { + tmp41 := checkDerefVar(glojure_DOT_core_conj) + tmp42 := checkDerefVar(glojure_DOT_core_first) + tmp43 := lang.Apply(tmp42, []any{v35}) + tmp44 := lang.Apply(tmp41, []any{v27, tmp43}) + tmp36 = tmp44 + } else { + tmp36 = v27 + } + var v45 any = tmp36 + _ = v45 + // let binding "fdecl" + var tmp46 any + tmp47 := checkDerefVar(glojure_DOT_core_map_QMARK_) + tmp48 := checkDerefVar(glojure_DOT_core_first) + tmp49 := lang.Apply(tmp48, []any{v35}) + tmp50 := lang.Apply(tmp47, []any{tmp49}) + if lang.IsTruthy(tmp50) { + tmp51 := checkDerefVar(glojure_DOT_core_next) + tmp52 := lang.Apply(tmp51, []any{v35}) + tmp46 = tmp52 + } else { + tmp46 = v35 + } + var v53 any = tmp46 + _ = v53 + // let binding "fdecl" + var tmp54 any + tmp55 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp56 := checkDerefVar(glojure_DOT_core_first) + tmp57 := lang.Apply(tmp56, []any{v53}) + tmp58 := lang.Apply(tmp55, []any{tmp57}) + if lang.IsTruthy(tmp58) { + tmp59 := checkDerefVar(glojure_DOT_core_list) + tmp60 := lang.Apply(tmp59, []any{v53}) + tmp54 = tmp60 + } else { + tmp54 = v53 + } + var v61 any = tmp54 + _ = v61 + // let binding "m" + var tmp62 any + tmp63 := checkDerefVar(glojure_DOT_core_map_QMARK_) + tmp64 := checkDerefVar(glojure_DOT_core_last) + tmp65 := lang.Apply(tmp64, []any{v61}) + tmp66 := lang.Apply(tmp63, []any{tmp65}) + if lang.IsTruthy(tmp66) { + tmp67 := checkDerefVar(glojure_DOT_core_conj) + tmp68 := checkDerefVar(glojure_DOT_core_last) + tmp69 := lang.Apply(tmp68, []any{v61}) + tmp70 := lang.Apply(tmp67, []any{v45, tmp69}) + tmp62 = tmp70 + } else { + tmp62 = v45 + } + var v71 any = tmp62 + _ = v71 + // let binding "fdecl" + var tmp72 any + tmp73 := checkDerefVar(glojure_DOT_core_map_QMARK_) + tmp74 := checkDerefVar(glojure_DOT_core_last) + tmp75 := lang.Apply(tmp74, []any{v61}) + tmp76 := lang.Apply(tmp73, []any{tmp75}) + if lang.IsTruthy(tmp76) { + tmp77 := checkDerefVar(glojure_DOT_core_butlast) + tmp78 := lang.Apply(tmp77, []any{v61}) + tmp72 = tmp78 + } else { + tmp72 = v61 + } + var v79 any = tmp72 + _ = v79 + // let binding "m" + tmp80 := checkDerefVar(glojure_DOT_core_conj) + tmp81 := checkDerefVar(glojure_DOT_core_list) + tmp82 := checkDerefVar(glojure_DOT_core_sigs) + tmp83 := lang.Apply(tmp82, []any{v79}) + tmp84 := lang.Apply(tmp81, []any{lang.NewSymbol("quote"), tmp83}) + tmp85 := lang.NewMap(lang.NewKeyword("arglists"), tmp84) + tmp86 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(317), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(317), lang.NewKeyword("end-column"), int(60)) + tmp87, err := lang.WithMeta(tmp85, tmp86.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp88 := lang.Apply(tmp80, []any{tmp87, v71}) + var v89 any = tmp88 + _ = v89 + // let binding "m" + var tmp90 any + { // let + // let binding "inline" + tmp91 := lang.Apply(lang.NewKeyword("inline"), []any{v89}) + var v92 any = tmp91 + _ = v92 + // let binding "ifn" + tmp93 := checkDerefVar(glojure_DOT_core_first) + tmp94 := lang.Apply(tmp93, []any{v92}) + var v95 any = tmp94 + _ = v95 + // let binding "iname" + tmp96 := checkDerefVar(glojure_DOT_core_second) + tmp97 := lang.Apply(tmp96, []any{v92}) + var v98 any = tmp97 + _ = v98 + var tmp99 any + var tmp100 any + tmp101 := lang.Apply(lang.Equiv, []any{lang.NewSymbol("fn"), v95}) + if lang.IsTruthy(tmp101) { + var tmp102 any + tmp103 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp104 := reflect.TypeOf((*lang.Symbol)(nil)) + tmp105 := lang.Apply(tmp103, []any{tmp104, v98}) + if lang.IsTruthy(tmp105) { + tmp102 = false + } else { + tmp102 = true + } + tmp100 = tmp102 + } else { + } + if lang.IsTruthy(tmp100) { + tmp106 := checkDerefVar(glojure_DOT_core_assoc) + tmp107 := checkDerefVar(glojure_DOT_core_cons) + tmp108 := checkDerefVar(glojure_DOT_core_cons) + tmp109, ok := lang.FieldOrMethod(v6, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "Name"))) + } + var tmp110 any + switch reflect.TypeOf(tmp109).Kind() { + case reflect.Func: + tmp110 = lang.Apply(tmp109, nil) + default: + tmp110 = tmp109 + } + tmp111 := lang.Apply(lang.ConcatStrings, []any{tmp110, "__inliner"}) + tmp112 := lang.Apply(lang.NewSymbol, []any{tmp111}) + tmp113 := checkDerefVar(glojure_DOT_core_next) + tmp114 := lang.Apply(tmp113, []any{v92}) + tmp115 := lang.Apply(tmp108, []any{tmp112, tmp114}) + tmp116 := lang.Apply(tmp107, []any{v95, tmp115}) + tmp117 := lang.Apply(tmp106, []any{v89, lang.NewKeyword("inline"), tmp116}) + tmp99 = tmp117 + } else { + tmp99 = v89 + } + tmp90 = tmp99 + } // end let + var v91 any = tmp90 + _ = v91 + // let binding "m" + tmp92 := checkDerefVar(glojure_DOT_core_conj) + var tmp93 any + tmp94 := checkDerefVar(glojure_DOT_core_meta) + tmp95 := lang.Apply(tmp94, []any{v6}) + if lang.IsTruthy(tmp95) { + tmp96 := checkDerefVar(glojure_DOT_core_meta) + tmp97 := lang.Apply(tmp96, []any{v6}) + tmp93 = tmp97 + } else { + tmp98 := lang.NewMap() + tmp99 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(328), lang.NewKeyword("column"), int(51), lang.NewKeyword("end-line"), int(328), lang.NewKeyword("end-column"), int(52)) + tmp100, err := lang.WithMeta(tmp98, tmp99.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp93 = tmp100 + } + tmp101 := lang.Apply(tmp92, []any{tmp93, v91}) + var v102 any = tmp101 + _ = v102 + tmp103 := checkDerefVar(glojure_DOT_core_list) + tmp104 := checkDerefVar(glojure_DOT_core_with_meta) + tmp105 := lang.Apply(tmp104, []any{v6, v102}) + tmp106 := checkDerefVar(glojure_DOT_core_with_meta) + tmp107 := checkDerefVar(glojure_DOT_core_cons) + tmp108 := lang.Apply(tmp107, []any{lang.NewSymbol("glojure.core/fn"), v79}) + tmp109 := lang.Apply(lang.NewKeyword("tag"), []any{v102}) + tmp110 := lang.NewMap(lang.NewKeyword("rettag"), tmp109) + tmp111 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(333), lang.NewKeyword("column"), int(37), lang.NewKeyword("end-line"), int(333), lang.NewKeyword("end-column"), int(54)) + tmp112, err := lang.WithMeta(tmp110, tmp111.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp113 := lang.Apply(tmp106, []any{tmp108, tmp112}) + tmp114 := lang.Apply(tmp103, []any{lang.NewSymbol("def"), tmp105, tmp113}) + tmp13 = tmp114 + } // end let + return tmp13 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(291), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(333), lang.NewKeyword("end-column"), int(58))).(lang.FnFunc) + v3 = tmp2 + _ = v3 + } + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // defn- + { + tmp0 := lang.NewSymbol("defn-").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("decls"))), lang.NewKeyword("doc"), "same as defn, yielding non-public def", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4949), lang.NewKeyword("end-line"), int(4949))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_list_STAR_) + tmp8 := checkDerefVar(glojure_DOT_core_with_meta) + tmp9 := checkDerefVar(glojure_DOT_core_assoc) + tmp10 := checkDerefVar(glojure_DOT_core_meta) + tmp11 := lang.Apply(tmp10, []any{v5}) + tmp12 := lang.Apply(tmp9, []any{tmp11, lang.NewKeyword("private"), true}) + tmp13 := lang.Apply(tmp8, []any{v5, tmp12}) + tmp14 := lang.Apply(tmp7, []any{lang.NewSymbol("glojure.core/defn"), tmp13, v6}) + return tmp14 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // defonce + { + tmp0 := lang.NewSymbol("defonce").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("expr"))), lang.NewKeyword("doc"), "defs name to have the root value of the expr iff the named var has no root value,\n else expr is unevaluated", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5806), lang.NewKeyword("end-line"), int(5806))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_seq) + tmp8 := checkDerefVar(glojure_DOT_core_concat) + tmp9 := checkDerefVar(glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("glojure.core/let")}) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := checkDerefVar(glojure_DOT_core_apply) + tmp13 := checkDerefVar(glojure_DOT_core_vector) + tmp14 := checkDerefVar(glojure_DOT_core_seq) + tmp15 := checkDerefVar(glojure_DOT_core_concat) + tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("v__0__auto__")}) + tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp19 := checkDerefVar(glojure_DOT_core_seq) + tmp20 := checkDerefVar(glojure_DOT_core_concat) + tmp21 := checkDerefVar(glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("def")}) + tmp23 := checkDerefVar(glojure_DOT_core_list) + tmp24 := lang.Apply(tmp23, []any{v5}) + tmp25 := lang.Apply(tmp20, []any{tmp22, tmp24}) + tmp26 := lang.Apply(tmp19, []any{tmp25}) + tmp27 := lang.Apply(tmp18, []any{tmp26}) + tmp28 := lang.Apply(tmp15, []any{tmp17, tmp27}) + tmp29 := lang.Apply(tmp14, []any{tmp28}) + tmp30 := lang.Apply(tmp12, []any{tmp13, tmp29}) + tmp31 := lang.Apply(tmp11, []any{tmp30}) + tmp32 := checkDerefVar(glojure_DOT_core_list) + tmp33 := checkDerefVar(glojure_DOT_core_seq) + tmp34 := checkDerefVar(glojure_DOT_core_concat) + tmp35 := checkDerefVar(glojure_DOT_core_list) + tmp36 := lang.Apply(tmp35, []any{lang.NewSymbol("glojure.core/when-not")}) + tmp37 := checkDerefVar(glojure_DOT_core_list) + tmp38 := checkDerefVar(glojure_DOT_core_seq) + tmp39 := checkDerefVar(glojure_DOT_core_concat) + tmp40 := checkDerefVar(glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{lang.NewSymbol(".HasRoot")}) + tmp42 := checkDerefVar(glojure_DOT_core_list) + tmp43 := lang.Apply(tmp42, []any{lang.NewSymbol("v__0__auto__")}) + tmp44 := lang.Apply(tmp39, []any{tmp41, tmp43}) + tmp45 := lang.Apply(tmp38, []any{tmp44}) + tmp46 := lang.Apply(tmp37, []any{tmp45}) + tmp47 := checkDerefVar(glojure_DOT_core_list) + tmp48 := checkDerefVar(glojure_DOT_core_seq) + tmp49 := checkDerefVar(glojure_DOT_core_concat) + tmp50 := checkDerefVar(glojure_DOT_core_list) + tmp51 := lang.Apply(tmp50, []any{lang.NewSymbol("def")}) + tmp52 := checkDerefVar(glojure_DOT_core_list) + tmp53 := lang.Apply(tmp52, []any{v5}) + tmp54 := checkDerefVar(glojure_DOT_core_list) + tmp55 := lang.Apply(tmp54, []any{v6}) + tmp56 := lang.Apply(tmp49, []any{tmp51, tmp53, tmp55}) + tmp57 := lang.Apply(tmp48, []any{tmp56}) + tmp58 := lang.Apply(tmp47, []any{tmp57}) + tmp59 := lang.Apply(tmp34, []any{tmp36, tmp46, tmp58}) + tmp60 := lang.Apply(tmp33, []any{tmp59}) + tmp61 := lang.Apply(tmp32, []any{tmp60}) + tmp62 := lang.Apply(tmp8, []any{tmp10, tmp31, tmp61}) + tmp63 := lang.Apply(tmp7, []any{tmp62}) + return tmp63 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // defprotocol + { + tmp0 := lang.NewSymbol("defprotocol").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("opts+sigs"))), lang.NewKeyword("doc"), "A protocol is a named set of named methods and their signatures:\n (defprotocol AProtocolName\n\n ;optional doc string\n \"A doc string for AProtocol abstraction\"\n\n ;options\n :extend-via-metadata true\n\n ;method signatures\n (bar [this a b] \"bar docs\")\n (baz [this a] [this a b] [this a b c] \"baz docs\"))\n\n No implementations are provided. Docs can be specified for the\n protocol overall and for each method. The above yields a set of\n polymorphic functions and a protocol object. All are\n namespace-qualified by the ns enclosing the definition The resulting\n functions dispatch on the type of their first argument, which is\n required and corresponds to the implicit target object ('this' in \n Java parlance). defprotocol is dynamic, has no special compile-time \n effect, and defines no new types or classes. Implementations of \n the protocol methods can be provided using extend.\n\n When :extend-via-metadata is true, values can extend protocols by\n adding metadata where keys are fully-qualified protocol function\n symbols and values are function implementations. Protocol\n implementations are checked first for direct definitions (defrecord,\n deftype, reify), then metadata definitions, then external\n extensions (extend, extend-type, extend-protocol)\n\n defprotocol will automatically generate a corresponding interface,\n with the same name as the protocol, i.e. given a protocol:\n my.ns/Protocol, an interface: my.ns.Protocol. The interface will\n have methods corresponding to the protocol functions, and the\n protocol will automatically work with instances of the interface.\n\n Note that you should not use this interface with deftype or\n reify, as they support the protocol directly:\n\n (defprotocol P \n (foo [this]) \n (bar-me [this] [this y]))\n\n (deftype Foo [a b c] \n P\n (foo [this] a)\n (bar-me [this] b)\n (bar-me [this y] (+ c y)))\n \n (bar-me (Foo. 1 2 3) 42)\n => 45\n\n (foo \n (let [x 42]\n (reify P \n (foo [this] 17)\n (bar-me [this] x)\n (bar-me [this y] x))))\n => 17", lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(28), lang.NewKeyword("end-line"), int(28))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any + { // let + // let binding "doc" + var tmp8 any + tmp9 := checkDerefVar(glojure_DOT_core_string_QMARK_) + tmp10 := checkDerefVar(glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v6}) + tmp12 := lang.Apply(tmp9, []any{tmp11}) + if lang.IsTruthy(tmp12) { + tmp13 := checkDerefVar(glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v6}) + tmp8 = tmp14 + } else { + } + var v15 any = tmp8 + _ = v15 + // let binding "opts+sigs" + var tmp16 any + if lang.IsTruthy(v15) { + tmp17 := checkDerefVar(glojure_DOT_core_rest) + tmp18 := lang.Apply(tmp17, []any{v6}) + tmp16 = tmp18 + } else { + tmp16 = v6 + } + var v19 any = tmp16 + _ = v19 + // let binding "opts" + tmp20 := checkDerefVar(glojure_DOT_core_take_while) + var tmp21 lang.FnFunc + tmp21 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v22 := args[0] + _ = v22 + tmp23 := checkDerefVar(glojure_DOT_core_not) + tmp24 := checkDerefVar(glojure_DOT_core_seq_QMARK_) + tmp25 := lang.Apply(tmp24, []any{v22}) + tmp26 := lang.Apply(tmp23, []any{tmp25}) + return tmp26 + }) + tmp22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(92), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(92), lang.NewKeyword("end-column"), int(40)) + tmp23, err := lang.WithMeta(tmp21, tmp22.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp24 := lang.Apply(tmp20, []any{tmp23, v19}) + var v25 any = tmp24 + _ = v25 + // let binding "sigs" + tmp26 := checkDerefVar(glojure_DOT_core_drop_while) + var tmp27 lang.FnFunc + tmp27 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v28 := args[0] + _ = v28 + tmp29 := checkDerefVar(glojure_DOT_core_not) + tmp30 := checkDerefVar(glojure_DOT_core_seq_QMARK_) + tmp31 := lang.Apply(tmp30, []any{v28}) + tmp32 := lang.Apply(tmp29, []any{tmp31}) + return tmp32 + }) + tmp28 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(93), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(93), lang.NewKeyword("end-column"), int(40)) + tmp29, err := lang.WithMeta(tmp27, tmp28.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp30 := lang.Apply(tmp26, []any{tmp29, v19}) + var v31 any = tmp30 + _ = v31 + // let binding "opts" + var tmp32 any + tmp33 := checkDerefVar(glojure_DOT_core__EQ_) + tmp34 := lang.Apply(tmp33, []any{v31, v25}) + if lang.IsTruthy(tmp34) { + } else { + tmp32 = v25 + } + var v35 any = tmp32 + _ = v35 + tmp36 := checkDerefVar(glojure_DOT_core_seq) + tmp37 := checkDerefVar(glojure_DOT_core_concat) + tmp38 := checkDerefVar(glojure_DOT_core_list) + tmp39 := lang.Apply(tmp38, []any{lang.NewSymbol("do")}) + tmp40 := checkDerefVar(glojure_DOT_core_list) + tmp41 := checkDerefVar(glojure_DOT_core_seq) + tmp42 := checkDerefVar(glojure_DOT_core_concat) + tmp43 := checkDerefVar(glojure_DOT_core_list) + tmp44 := lang.Apply(tmp43, []any{lang.NewSymbol("def")}) + tmp45 := checkDerefVar(glojure_DOT_core_list) + tmp46 := lang.Apply(tmp45, []any{v5}) + tmp47 := checkDerefVar(glojure_DOT_core_list) + tmp48 := checkDerefVar(glojure_DOT_core_seq) + tmp49 := checkDerefVar(glojure_DOT_core_concat) + tmp50 := checkDerefVar(glojure_DOT_core_list) + tmp51 := lang.Apply(tmp50, []any{lang.NewSymbol("glojure.core/atom")}) + tmp52 := checkDerefVar(glojure_DOT_core_list) + tmp53 := checkDerefVar(glojure_DOT_core_apply) + tmp54 := checkDerefVar(glojure_DOT_core_hash_map) + tmp55 := checkDerefVar(glojure_DOT_core_seq) + tmp56 := checkDerefVar(glojure_DOT_core_concat) + tmp57 := checkDerefVar(glojure_DOT_core_list) + tmp58 := lang.Apply(tmp57, []any{lang.NewKeyword("on-interface")}) + tmp59 := checkDerefVar(glojure_DOT_core_list) + tmp60 := lang.Apply(tmp59, []any{true}) + tmp61 := checkDerefVar(glojure_DOT_core_list) + tmp62 := lang.Apply(tmp61, []any{lang.NewKeyword("sigs")}) + tmp63 := checkDerefVar(glojure_DOT_core_list) + tmp64 := checkDerefVar(glojure_DOT_core_seq) + tmp65 := checkDerefVar(glojure_DOT_core_concat) + tmp66 := checkDerefVar(glojure_DOT_core_list) + tmp67 := lang.Apply(tmp66, []any{lang.NewSymbol("quote")}) + tmp68 := checkDerefVar(glojure_DOT_core_list) + tmp69 := lang.Apply(tmp68, []any{v31}) + tmp70 := lang.Apply(tmp65, []any{tmp67, tmp69}) + tmp71 := lang.Apply(tmp64, []any{tmp70}) + tmp72 := lang.Apply(tmp63, []any{tmp71}) + tmp73 := checkDerefVar(glojure_DOT_core_list) + tmp74 := lang.Apply(tmp73, []any{lang.NewKeyword("multis")}) + tmp75 := checkDerefVar(glojure_DOT_core_list) + tmp76 := checkDerefVar(glojure_DOT_core_apply) + tmp77 := checkDerefVar(glojure_DOT_core_hash_map) + tmp78 := checkDerefVar(glojure_DOT_core_seq) + tmp79 := checkDerefVar(glojure_DOT_core_concat) + tmp80 := lang.Apply(tmp79, nil) + tmp81 := lang.Apply(tmp78, []any{tmp80}) + tmp82 := lang.Apply(tmp76, []any{tmp77, tmp81}) + tmp83 := lang.Apply(tmp75, []any{tmp82}) + tmp84 := lang.Apply(tmp56, []any{tmp58, tmp60, tmp62, tmp72, tmp74, tmp83}) + tmp85 := lang.Apply(tmp55, []any{tmp84}) + tmp86 := lang.Apply(tmp53, []any{tmp54, tmp85}) + tmp87 := lang.Apply(tmp52, []any{tmp86}) + tmp88 := lang.Apply(tmp49, []any{tmp51, tmp87}) + tmp89 := lang.Apply(tmp48, []any{tmp88}) + tmp90 := lang.Apply(tmp47, []any{tmp89}) + tmp91 := lang.Apply(tmp42, []any{tmp44, tmp46, tmp90}) + tmp92 := lang.Apply(tmp41, []any{tmp91}) + tmp93 := lang.Apply(tmp40, []any{tmp92}) + tmp94 := checkDerefVar(glojure_DOT_core_list) + tmp95 := checkDerefVar(glojure_DOT_core_seq) + tmp96 := checkDerefVar(glojure_DOT_core_concat) + tmp97 := checkDerefVar(glojure_DOT_core_list) + tmp98 := lang.Apply(tmp97, []any{lang.NewSymbol("glojure.core/swap!")}) + tmp99 := checkDerefVar(glojure_DOT_core_list) + tmp100 := lang.Apply(tmp99, []any{lang.NewSymbol("glojure.core/-protocols")}) + tmp101 := checkDerefVar(glojure_DOT_core_list) + tmp102 := lang.Apply(tmp101, []any{lang.NewSymbol("glojure.core/assoc")}) + tmp103 := checkDerefVar(glojure_DOT_core_list) + tmp104 := checkDerefVar(glojure_DOT_core_seq) + tmp105 := checkDerefVar(glojure_DOT_core_concat) + tmp106 := checkDerefVar(glojure_DOT_core_list) + tmp107 := lang.Apply(tmp106, []any{lang.NewSymbol("quote")}) + tmp108 := checkDerefVar(glojure_DOT_core_list) + tmp109 := lang.Apply(tmp108, []any{v5}) + tmp110 := lang.Apply(tmp105, []any{tmp107, tmp109}) + tmp111 := lang.Apply(tmp104, []any{tmp110}) + tmp112 := lang.Apply(tmp103, []any{tmp111}) + tmp113 := checkDerefVar(glojure_DOT_core_list) + tmp114 := lang.Apply(tmp113, []any{v5}) + tmp115 := lang.Apply(tmp96, []any{tmp98, tmp100, tmp102, tmp112, tmp114}) + tmp116 := lang.Apply(tmp95, []any{tmp115}) + tmp117 := lang.Apply(tmp94, []any{tmp116}) + tmp118 := checkDerefVar(glojure_DOT_core_map) + var tmp119 lang.FnFunc + tmp119 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v120 := args[0] + _ = v120 + tmp121 := checkDerefVar(glojure_DOT_core_seq) + tmp122 := checkDerefVar(glojure_DOT_core_concat) + tmp123 := checkDerefVar(glojure_DOT_core_list) + tmp124 := lang.Apply(tmp123, []any{lang.NewSymbol("do")}) + tmp125 := checkDerefVar(glojure_DOT_core_list) + tmp126 := checkDerefVar(glojure_DOT_core_seq) + tmp127 := checkDerefVar(glojure_DOT_core_concat) + tmp128 := checkDerefVar(glojure_DOT_core_list) + tmp129 := lang.Apply(tmp128, []any{lang.NewSymbol("glojure.core/defmulti")}) + tmp130 := checkDerefVar(glojure_DOT_core_list) + tmp131 := checkDerefVar(glojure_DOT_core_first) + tmp132 := lang.Apply(tmp131, []any{v120}) + tmp133 := lang.Apply(tmp130, []any{tmp132}) + tmp134 := checkDerefVar(glojure_DOT_core_list) + tmp135 := checkDerefVar(glojure_DOT_core_seq) + tmp136 := checkDerefVar(glojure_DOT_core_concat) + tmp137 := checkDerefVar(glojure_DOT_core_list) + tmp138 := lang.Apply(tmp137, []any{lang.NewSymbol("glojure.core/fn")}) + tmp139 := checkDerefVar(glojure_DOT_core_list) + tmp140 := checkDerefVar(glojure_DOT_core_apply) + tmp141 := checkDerefVar(glojure_DOT_core_vector) + tmp142 := checkDerefVar(glojure_DOT_core_seq) + tmp143 := checkDerefVar(glojure_DOT_core_concat) + tmp144 := checkDerefVar(glojure_DOT_core_list) + tmp145 := lang.Apply(tmp144, []any{lang.NewSymbol("this")}) + tmp146 := checkDerefVar(glojure_DOT_core_list) + tmp147 := lang.Apply(tmp146, []any{lang.NewSymbol("&")}) + tmp148 := checkDerefVar(glojure_DOT_core_list) + tmp149 := lang.Apply(tmp148, []any{lang.NewSymbol("args")}) + tmp150 := lang.Apply(tmp143, []any{tmp145, tmp147, tmp149}) + tmp151 := lang.Apply(tmp142, []any{tmp150}) + tmp152 := lang.Apply(tmp140, []any{tmp141, tmp151}) + tmp153 := lang.Apply(tmp139, []any{tmp152}) + tmp154 := checkDerefVar(glojure_DOT_core_list) + tmp155 := checkDerefVar(glojure_DOT_core_seq) + tmp156 := checkDerefVar(glojure_DOT_core_concat) + tmp157 := checkDerefVar(glojure_DOT_core_list) + tmp158 := lang.Apply(tmp157, []any{lang.NewSymbol("glojure.core/class")}) + tmp159 := checkDerefVar(glojure_DOT_core_list) + tmp160 := lang.Apply(tmp159, []any{lang.NewSymbol("this")}) + tmp161 := lang.Apply(tmp156, []any{tmp158, tmp160}) + tmp162 := lang.Apply(tmp155, []any{tmp161}) + tmp163 := lang.Apply(tmp154, []any{tmp162}) + tmp164 := lang.Apply(tmp136, []any{tmp138, tmp153, tmp163}) + tmp165 := lang.Apply(tmp135, []any{tmp164}) + tmp166 := lang.Apply(tmp134, []any{tmp165}) + tmp167 := lang.Apply(tmp127, []any{tmp129, tmp133, tmp166}) + tmp168 := lang.Apply(tmp126, []any{tmp167}) + tmp169 := lang.Apply(tmp125, []any{tmp168}) + tmp170 := checkDerefVar(glojure_DOT_core_list) + tmp171 := checkDerefVar(glojure_DOT_core_seq) + tmp172 := checkDerefVar(glojure_DOT_core_concat) + tmp173 := checkDerefVar(glojure_DOT_core_list) + tmp174 := lang.Apply(tmp173, []any{lang.NewSymbol("glojure.core/swap!")}) + tmp175 := checkDerefVar(glojure_DOT_core_list) + tmp176 := lang.Apply(tmp175, []any{v5}) + tmp177 := checkDerefVar(glojure_DOT_core_list) + tmp178 := lang.Apply(tmp177, []any{lang.NewSymbol("glojure.core/assoc-in")}) + tmp179 := checkDerefVar(glojure_DOT_core_list) + tmp180 := checkDerefVar(glojure_DOT_core_apply) + tmp181 := checkDerefVar(glojure_DOT_core_vector) + tmp182 := checkDerefVar(glojure_DOT_core_seq) + tmp183 := checkDerefVar(glojure_DOT_core_concat) + tmp184 := checkDerefVar(glojure_DOT_core_list) + tmp185 := lang.Apply(tmp184, []any{lang.NewKeyword("multis")}) + tmp186 := checkDerefVar(glojure_DOT_core_list) + tmp187 := checkDerefVar(glojure_DOT_core_seq) + tmp188 := checkDerefVar(glojure_DOT_core_concat) + tmp189 := checkDerefVar(glojure_DOT_core_list) + tmp190 := lang.Apply(tmp189, []any{lang.NewSymbol("glojure.core/keyword")}) + tmp191 := checkDerefVar(glojure_DOT_core_list) + tmp192 := checkDerefVar(glojure_DOT_core_seq) + tmp193 := checkDerefVar(glojure_DOT_core_concat) + tmp194 := checkDerefVar(glojure_DOT_core_list) + tmp195 := lang.Apply(tmp194, []any{lang.NewSymbol("quote")}) + tmp196 := checkDerefVar(glojure_DOT_core_list) + tmp197 := checkDerefVar(glojure_DOT_core_first) + tmp198 := lang.Apply(tmp197, []any{v120}) + tmp199 := lang.Apply(tmp196, []any{tmp198}) + tmp200 := lang.Apply(tmp193, []any{tmp195, tmp199}) + tmp201 := lang.Apply(tmp192, []any{tmp200}) + tmp202 := lang.Apply(tmp191, []any{tmp201}) + tmp203 := lang.Apply(tmp188, []any{tmp190, tmp202}) + tmp204 := lang.Apply(tmp187, []any{tmp203}) + tmp205 := lang.Apply(tmp186, []any{tmp204}) + tmp206 := lang.Apply(tmp183, []any{tmp185, tmp205}) + tmp207 := lang.Apply(tmp182, []any{tmp206}) + tmp208 := lang.Apply(tmp180, []any{tmp181, tmp207}) + tmp209 := lang.Apply(tmp179, []any{tmp208}) + tmp210 := checkDerefVar(glojure_DOT_core_list) + tmp211 := checkDerefVar(glojure_DOT_core_first) + tmp212 := lang.Apply(tmp211, []any{v120}) + tmp213 := lang.Apply(tmp210, []any{tmp212}) + tmp214 := lang.Apply(tmp172, []any{tmp174, tmp176, tmp178, tmp209, tmp213}) + tmp215 := lang.Apply(tmp171, []any{tmp214}) + tmp216 := lang.Apply(tmp170, []any{tmp215}) + tmp217 := lang.Apply(tmp122, []any{tmp124, tmp169, tmp216}) + tmp218 := lang.Apply(tmp121, []any{tmp217}) + return tmp218 + }) + tmp120 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(102), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(104), lang.NewKeyword("end-column"), int(90)) + tmp121, err := lang.WithMeta(tmp119, tmp120.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp122 := lang.Apply(tmp118, []any{tmp121, v31}) + tmp123 := checkDerefVar(glojure_DOT_core_list) + tmp124 := checkDerefVar(glojure_DOT_core_seq) + tmp125 := checkDerefVar(glojure_DOT_core_concat) + tmp126 := checkDerefVar(glojure_DOT_core_list) + tmp127 := lang.Apply(tmp126, []any{lang.NewSymbol("var")}) + tmp128 := checkDerefVar(glojure_DOT_core_list) + tmp129 := lang.Apply(tmp128, []any{v5}) + tmp130 := lang.Apply(tmp125, []any{tmp127, tmp129}) + tmp131 := lang.Apply(tmp124, []any{tmp130}) + tmp132 := lang.Apply(tmp123, []any{tmp131}) + tmp133 := lang.Apply(tmp37, []any{tmp39, tmp93, tmp117, tmp122, tmp132}) + tmp134 := lang.Apply(tmp36, []any{tmp133}) + tmp7 = tmp134 + } // end let + return tmp7 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // defstruct + { + tmp0 := lang.NewSymbol("defstruct").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("keys"))), lang.NewKeyword("doc"), "Same as (def name (create-struct keys...))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4044), lang.NewKeyword("end-line"), int(4044))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_seq) + tmp8 := checkDerefVar(glojure_DOT_core_concat) + tmp9 := checkDerefVar(glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("def")}) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{v5}) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := checkDerefVar(glojure_DOT_core_seq) + tmp15 := checkDerefVar(glojure_DOT_core_concat) + tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("glojure.core/create-struct")}) + tmp18 := lang.Apply(tmp15, []any{tmp17, v6}) + tmp19 := lang.Apply(tmp14, []any{tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp19}) + tmp21 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp20}) + tmp22 := lang.Apply(tmp7, []any{tmp21}) + return tmp22 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // delay + { + tmp0 := lang.NewSymbol("delay").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Takes a body of expressions and yields a Delay object that will\n invoke the body only the first time it is forced (with force or deref/@), and\n will cache the result and return it on all subsequent force\n calls. See also - realized?", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(739), lang.NewKeyword("end-line"), int(739))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := checkDerefVar(glojure_DOT_core_list_STAR_) + tmp8 := lang.NewVector() + tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(746), lang.NewKeyword("column"), int(62), lang.NewKeyword("end-line"), int(746), lang.NewKeyword("end-column"), int(63)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp11 := lang.Apply(tmp7, []any{lang.NewSymbol("fn*"), tmp10, v5}) + tmp12 := lang.Apply(tmp6, []any{lang.NewSymbol("new"), lang.NewSymbol("glojure.lang.Delay"), tmp11}) + return tmp12 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // delay? + { + tmp0 := lang.NewSymbol("delay?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "returns true if x is a Delay created with delay", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(748), lang.NewKeyword("end-line"), int(748))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp5 := lang.Apply(tmp4, []any{nil, v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // deliver + { + tmp0 := lang.NewSymbol("deliver").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("promise"), lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Delivers the supplied value to the promise, releasing any pending\n derefs. A subsequent call to deliver on a promise will have no effect.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7109), lang.NewKeyword("end-line"), int(7109))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(v3, []any{v4}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // denominator + { + tmp1 := reflect.TypeOf((*big9.Int)(nil)) + tmp0 := lang.NewSymbol("denominator").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("r"))), lang.NewKeyword("doc"), "Returns the denominator part of a Ratio.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3591), lang.NewKeyword("end-line"), int(3591))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5, ok := lang.FieldOrMethod(v4, "denominator") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "denominator"))) + } + var tmp6 any + switch reflect.TypeOf(tmp5).Kind() { + case reflect.Func: + tmp6 = lang.Apply(tmp5, nil) + default: + tmp6 = tmp5 + } + return tmp6 + }) + tmp4 := reflect.TypeOf((*big9.Int)(nil)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // deref + { + tmp0 := lang.NewSymbol("deref").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref")), lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("timeout-ms"), lang.NewSymbol("timeout-val"))), lang.NewKeyword("doc"), "Also reader macro: @ref/@agent/@var/@atom/@delay/@future/@promise. Within a transaction,\n returns the in-transaction-value of ref, else returns the\n most-recently-committed value of ref. When applied to a var, agent\n or atom, returns its current state. When applied to a delay, forces\n it if not already forced. When applied to a future, will block if\n computation not complete. When applied to a promise, will block\n until a value is delivered. The variant taking a timeout can be\n used for blocking references (futures and promises), and will return\n timeout-val if the timeout (in milliseconds) is reached before a\n value is available. See also - realized?.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2304), lang.NewKeyword("end-line"), int(2304))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp6 := reflect.TypeOf((*lang.IDeref)(nil)).Elem() + tmp7 := lang.Apply(tmp5, []any{tmp6, v3}) + if lang.IsTruthy(tmp7) { + tmp8, ok := lang.FieldOrMethod(v3, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "Deref"))) + } + var tmp9 any + switch reflect.TypeOf(tmp8).Kind() { + case reflect.Func: + tmp9 = lang.Apply(tmp8, nil) + default: + tmp9 = tmp8 + } + tmp4 = tmp9 + } else { + tmp10 := checkDerefVar(glojure_DOT_core_deref_future) + tmp11 := lang.Apply(tmp10, []any{v3}) + tmp4 = tmp11 + } + return tmp4 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp8 := reflect.TypeOf((*lang.IBlockingDeref)(nil)).Elem() + tmp9 := lang.Apply(tmp7, []any{tmp8, v3}) + if lang.IsTruthy(tmp9) { + tmp10, _ := lang.FieldOrMethod(v3, "DerefWithTimeout") + if reflect.TypeOf(tmp10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("DerefWithTimeout is not a function"))) + } + tmp11 := lang.Apply(tmp10, []any{v4, v5}) + tmp6 = tmp11 + } else { + tmp12 := checkDerefVar(glojure_DOT_core_deref_future) + tmp13 := lang.Apply(tmp12, []any{v3, v4, v5}) + tmp6 = tmp13 + } + return tmp6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // deref-as-map + { + tmp0 := lang.NewSymbol("deref-as-map").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(408), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(408), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + { // let + // let binding "pending" + var tmp5 any + { // let + // let binding "and__0__auto__" + tmp6 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp7 := reflect.TypeOf((*lang.IPending)(nil)).Elem() + tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + tmp11 := checkDerefVar(glojure_DOT_core_not) + tmp12, ok := lang.FieldOrMethod(v3, "isRealized") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "isRealized"))) + } + var tmp13 any + switch reflect.TypeOf(tmp12).Kind() { + case reflect.Func: + tmp13 = lang.Apply(tmp12, nil) + default: + tmp13 = tmp12 + } + tmp14 := lang.Apply(tmp11, []any{tmp13}) + tmp10 = tmp14 + } else { + tmp10 = v9 + } + tmp5 = tmp10 + } // end let + var v6 any = tmp5 + _ = v6 + // let binding "vec__250" + var tmp7 any + if lang.IsTruthy(v6) { + } else { + var tmp8 any + func() { + defer func() { + if r := recover(); r != nil { + if lang.CatchMatches(r, lang.Throwable) { + v9 := r + _ = v9 + tmp10 := lang.NewVector(true, v9) + tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(415), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(415), lang.NewKeyword("end-column"), int(25)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp8 = tmp12 + } else { + panic(r) + } + } + }() + tmp9 := checkDerefVar(glojure_DOT_core_deref) + tmp10 := lang.Apply(tmp9, []any{v3}) + tmp11 := lang.NewVector(false, tmp10) + tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(413), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(413), lang.NewKeyword("end-column"), int(32)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp8 = tmp13 + }() + tmp7 = tmp8 + } + var v14 any = tmp7 + _ = v14 + // let binding "ex" + tmp15 := checkDerefVar(glojure_DOT_core_nth) + tmp16 := lang.Apply(tmp15, []any{v14, int64(0), nil}) + var v17 any = tmp16 + _ = v17 + // let binding "val" + tmp18 := checkDerefVar(glojure_DOT_core_nth) + tmp19 := lang.Apply(tmp18, []any{v14, int64(1), nil}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + var tmp22 any + { // let + // let binding "or__0__auto__" + var v23 any = v17 + _ = v23 + var tmp24 any + if lang.IsTruthy(v23) { + tmp24 = v23 + } else { + var tmp25 any + { // let + // let binding "and__0__auto__" + tmp26 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp27 := reflect.TypeOf((*lang.Agent)(nil)) + tmp28 := lang.Apply(tmp26, []any{tmp27, v3}) + var v29 any = tmp28 + _ = v29 + var tmp30 any + if lang.IsTruthy(v29) { + tmp31 := checkDerefVar(glojure_DOT_core_agent_error) + tmp32 := lang.Apply(tmp31, []any{v3}) + tmp30 = tmp32 + } else { + tmp30 = v29 + } + tmp25 = tmp30 + } // end let + tmp24 = tmp25 + } + tmp22 = tmp24 + } // end let + if lang.IsTruthy(tmp22) { + tmp21 = lang.NewKeyword("failed") + } else { + var tmp23 any + if lang.IsTruthy(v6) { + tmp23 = lang.NewKeyword("pending") + } else { + var tmp24 any + if lang.IsTruthy(lang.NewKeyword("else")) { + tmp24 = lang.NewKeyword("ready") + } else { + } + tmp23 = tmp24 + } + tmp21 = tmp23 + } + tmp25 := lang.NewMap(lang.NewKeyword("status"), tmp21, lang.NewKeyword("val"), v20) + tmp26 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(416), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(429), lang.NewKeyword("end-column"), int(14)) + tmp27, err := lang.WithMeta(tmp25, tmp26.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp4 = tmp27 + } // end let + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // deref-future + { + tmp0 := lang.NewSymbol("deref-future").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2296), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(2296), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fut")), lang.NewVector(lang.NewSymbol("fut"), lang.NewSymbol("timeout-ms"), lang.NewSymbol("timeout-val"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + tmp4, ok := lang.FieldOrMethod(v3, "Get") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "Get"))) + } + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { + case reflect.Func: + tmp5 = lang.Apply(tmp4, nil) + default: + tmp5 = tmp4 + } + return tmp5 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var tmp6 any + func() { + defer func() { + if r := recover(); r != nil { + tmp7 := reflect.TypeOf((*lang.TimeoutError)(nil)).Elem() + if lang.CatchMatches(r, tmp7) { + v8 := r + _ = v8 + tmp6 = v5 + } else { + panic(r) + } + } + }() + tmp8, _ := lang.FieldOrMethod(v3, "Get") + if reflect.TypeOf(tmp8).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Get is not a function"))) + } + tmp9 := lang.Apply(tmp8, []any{v4, time10.Millisecond}) + tmp6 = tmp9 + }() + return tmp6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // derive + { + tmp0 := lang.NewSymbol("derive").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag"), lang.NewSymbol("parent")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"), lang.NewSymbol("parent"))), lang.NewKeyword("doc"), "Establishes a parent/child relationship between parent and\n tag. Parent must be a namespace-qualified symbol or keyword and\n child can be either a namespace-qualified symbol or keyword or a\n class. h must be a hierarchy obtained from make-hierarchy, if not\n supplied defaults to, and modifies, the global hierarchy.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5605), lang.NewKeyword("end-line"), int(5605))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_alter_var_root) + tmp6 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("global-hierarchy")) + tmp7 := checkDerefVar(glojure_DOT_core_derive) + tmp8 := lang.Apply(tmp5, []any{tmp6, tmp7, v3, v4}) + _ = tmp8 + return nil + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var tmp6 any + { // let + // let binding "tp" + tmp7 := lang.Apply(lang.NewKeyword("parents"), []any{v3}) + var v8 any = tmp7 + _ = v8 + // let binding "td" + tmp9 := lang.Apply(lang.NewKeyword("descendants"), []any{v3}) + var v10 any = tmp9 + _ = v10 + // let binding "ta" + tmp11 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) + var v12 any = tmp11 + _ = v12 + // let binding "tf" + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 5 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v14 := args[0] + _ = v14 + v15 := args[1] + _ = v15 + v16 := args[2] + _ = v16 + v17 := args[3] + _ = v17 + v18 := args[4] + _ = v18 + tmp19 := checkDerefVar(glojure_DOT_core_reduce1) + var tmp20 lang.FnFunc + tmp20 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v21 := args[0] + _ = v21 + v22 := args[1] + _ = v22 + tmp23 := checkDerefVar(glojure_DOT_core_assoc) + tmp24 := checkDerefVar(glojure_DOT_core_reduce1) + tmp25 := checkDerefVar(glojure_DOT_core_conj) + tmp26 := checkDerefVar(glojure_DOT_core_get) + tmp27 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp28 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5628), lang.NewKeyword("column"), int(61), lang.NewKeyword("end-line"), int(5628), lang.NewKeyword("end-column"), int(63)) + tmp29, err := lang.WithMeta(tmp27, tmp28.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp30 := lang.Apply(tmp26, []any{v18, v22, tmp29}) + tmp31 := checkDerefVar(glojure_DOT_core_cons) + tmp32 := lang.Apply(v18, []any{v17}) + tmp33 := lang.Apply(tmp31, []any{v17, tmp32}) + tmp34 := lang.Apply(tmp24, []any{tmp25, tmp30, tmp33}) + tmp35 := lang.Apply(tmp23, []any{v21, v22, tmp34}) + return tmp35 + }) + tmp21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5626), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(5628), lang.NewKeyword("end-column"), int(98)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp23 := checkDerefVar(glojure_DOT_core_cons) + tmp24 := lang.Apply(v16, []any{v15}) + tmp25 := lang.Apply(tmp23, []any{v15, tmp24}) + tmp26 := lang.Apply(tmp19, []any{tmp22, v14, tmp25}) + return tmp26 + }) + tmp14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5625), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(5629), lang.NewKeyword("end-column"), int(56)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v16 any = tmp15 + _ = v16 + var tmp17 any + { // let + // let binding "or__0__auto__" + var tmp18 any + tmp19 := checkDerefVar(glojure_DOT_core_contains_QMARK_) + tmp20 := lang.Apply(v8, []any{v4}) + tmp21 := lang.Apply(tmp19, []any{tmp20, v5}) + if lang.IsTruthy(tmp21) { + } else { + var tmp22 any + tmp23 := checkDerefVar(glojure_DOT_core_contains_QMARK_) + tmp24 := lang.Apply(v12, []any{v4}) + tmp25 := lang.Apply(tmp23, []any{tmp24, v5}) + if lang.IsTruthy(tmp25) { + tmp26 := checkDerefVar(glojure_DOT_core_print_str) + tmp27 := lang.Apply(tmp26, []any{v4, "already has", v5, "as ancestor"}) + tmp28 := lang.Apply(lang.NewError, []any{tmp27}) + panic(tmp28) + } else { + } + _ = tmp22 + var tmp29 any + tmp30 := checkDerefVar(glojure_DOT_core_contains_QMARK_) + tmp31 := lang.Apply(v12, []any{v5}) + tmp32 := lang.Apply(tmp30, []any{tmp31, v4}) + if lang.IsTruthy(tmp32) { + tmp33 := checkDerefVar(glojure_DOT_core_print_str) + tmp34 := lang.Apply(tmp33, []any{"Cyclic derivation:", v5, "has", v4, "as ancestor"}) + tmp35 := lang.Apply(lang.NewError, []any{tmp34}) + panic(tmp35) + } else { + } + _ = tmp29 + tmp36 := checkDerefVar(glojure_DOT_core_assoc) + tmp37 := lang.Apply(lang.NewKeyword("parents"), []any{v3}) + tmp38 := checkDerefVar(glojure_DOT_core_conj) + tmp39 := checkDerefVar(glojure_DOT_core_get) + tmp40 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp41 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5636), lang.NewKeyword("column"), int(61), lang.NewKeyword("end-line"), int(5636), lang.NewKeyword("end-column"), int(63)) + tmp42, err := lang.WithMeta(tmp40, tmp41.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp43 := lang.Apply(tmp39, []any{v8, v4, tmp42}) + tmp44 := lang.Apply(tmp38, []any{tmp43, v5}) + tmp45 := lang.Apply(tmp36, []any{tmp37, v4, tmp44}) + tmp46 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) + tmp47 := lang.Apply(v16, []any{tmp46, v4, v10, v5, v12}) + tmp48 := lang.Apply(lang.NewKeyword("descendants"), []any{v3}) + tmp49 := lang.Apply(v16, []any{tmp48, v5, v12, v4, v10}) + tmp50 := lang.NewMap(lang.NewKeyword("parents"), tmp45, lang.NewKeyword("ancestors"), tmp47, lang.NewKeyword("descendants"), tmp49) + tmp51 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5636), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(5638), lang.NewKeyword("end-column"), int(61)) + tmp52, err := lang.WithMeta(tmp50, tmp51.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp18 = tmp52 + } + var v53 any = tmp18 + _ = v53 + var tmp54 any + if lang.IsTruthy(v53) { + tmp54 = v53 + } else { + tmp54 = v3 + } + tmp17 = tmp54 + } // end let + tmp6 = tmp17 + } // end let + return tmp6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // descendants + { + tmp0 := lang.NewSymbol("descendants").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"))), lang.NewKeyword("doc"), "Returns the immediate and indirect children of tag, through a\n relationship established via derive. h must be a hierarchy obtained\n from make-hierarchy, if not supplied defaults to the global\n hierarchy. Note: does not work on Java type inheritance\n relationships.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5593), lang.NewKeyword("end-line"), int(5593))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_descendants) + tmp5 := checkDerefVar(glojure_DOT_core_global_hierarchy) + tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) + return tmp6 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(glojure_DOT_core_class_QMARK_) + tmp7 := lang.Apply(tmp6, []any{v4}) + if lang.IsTruthy(tmp7) { + tmp8 := lang.Apply(lang.NewUnsupportedOperationError, []any{"Can't get descendants of classes"}) + panic(tmp8) + } else { + tmp9 := checkDerefVar(glojure_DOT_core_not_empty) + tmp10 := checkDerefVar(glojure_DOT_core_get) + tmp11 := lang.Apply(lang.NewKeyword("descendants"), []any{v3}) + tmp12 := lang.Apply(tmp10, []any{tmp11, v4}) + tmp13 := lang.Apply(tmp9, []any{tmp12}) + tmp5 = tmp13 + } + return tmp5 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // destructure + { + tmp0 := lang.NewSymbol("destructure").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4400), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(4400), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + { // let + // let binding "bents" + tmp5 := checkDerefVar(glojure_DOT_core_partition) + tmp6 := lang.Apply(tmp5, []any{int64(2), v3}) + var v7 any = tmp6 + _ = v7 + // let binding "pb" + var tmp8 lang.FnFunc + { // function pb + var v9 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + v12 := args[2] + _ = v12 + var tmp13 any + { // let + // let binding "pvec" + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v15 := args[0] + _ = v15 + v16 := args[1] + _ = v16 + v17 := args[2] + _ = v17 + var tmp18 any + { // let + // let binding "gvec" + tmp19 := checkDerefVar(glojure_DOT_core_gensym) + tmp20 := lang.Apply(tmp19, []any{"vec__"}) + var v21 any = tmp20 + _ = v21 + // let binding "gseq" + tmp22 := checkDerefVar(glojure_DOT_core_gensym) + tmp23 := lang.Apply(tmp22, []any{"seq__"}) + var v24 any = tmp23 + _ = v24 + // let binding "gfirst" + tmp25 := checkDerefVar(glojure_DOT_core_gensym) + tmp26 := lang.Apply(tmp25, []any{"first__"}) + var v27 any = tmp26 + _ = v27 + // let binding "has-rest" + tmp28 := checkDerefVar(glojure_DOT_core_some) + tmp29 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{lang.NewSymbol("&")})) + tmp30 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4408), lang.NewKeyword("column"), int(43), lang.NewKeyword("end-line"), int(4408), lang.NewKeyword("end-column"), int(47)) + tmp31, err := lang.WithMeta(tmp29, tmp30.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp32 := lang.Apply(tmp28, []any{tmp31, v16}) + var v33 any = tmp32 + _ = v33 + var tmp34 any + { // let + // let binding "ret" + var tmp35 any + { // let + // let binding "ret" + tmp36 := checkDerefVar(glojure_DOT_core_conj) + tmp37 := lang.Apply(tmp36, []any{v15, v21, v17}) + var v38 any = tmp37 + _ = v38 + var tmp39 any + if lang.IsTruthy(v33) { + tmp40 := checkDerefVar(glojure_DOT_core_conj) + tmp41 := checkDerefVar(glojure_DOT_core_list) + tmp42 := lang.Apply(tmp41, []any{lang.NewSymbol("glojure.core/seq"), v21}) + tmp43 := lang.Apply(tmp40, []any{v38, v24, tmp42}) + tmp39 = tmp43 + } else { + tmp39 = v38 + } + tmp35 = tmp39 + } // end let + var v36 any = tmp35 + _ = v36 + // let binding "n" + var v37 any = int64(0) + _ = v37 + // let binding "bs" + var v38 any = v16 + _ = v38 + // let binding "seen-rest?" + var v39 any = false + _ = v39 + for { + var tmp40 any + tmp41 := checkDerefVar(glojure_DOT_core_seq) + tmp42 := lang.Apply(tmp41, []any{v38}) + if lang.IsTruthy(tmp42) { + var tmp43 any + { // let + // let binding "firstb" + tmp44 := checkDerefVar(glojure_DOT_core_first) + tmp45 := lang.Apply(tmp44, []any{v38}) + var v46 any = tmp45 + _ = v46 + var tmp47 any + tmp48 := checkDerefVar(glojure_DOT_core__EQ_) + tmp49 := lang.Apply(tmp48, []any{v46, lang.NewSymbol("&")}) + if lang.IsTruthy(tmp49) { + tmp51 := checkDerefVar(glojure_DOT_core_second) + tmp52 := lang.Apply(tmp51, []any{v38}) + tmp53 := lang.Apply(v9, []any{v36, tmp52, v24}) + var tmp50 any = tmp53 + var tmp54 any = v37 + tmp56 := checkDerefVar(glojure_DOT_core_nnext) + tmp57 := lang.Apply(tmp56, []any{v38}) + var tmp55 any = tmp57 + var tmp58 any = true + v36 = tmp50 + v37 = tmp54 + v38 = tmp55 + v39 = tmp58 + continue + } else { + var tmp59 any + tmp60 := checkDerefVar(glojure_DOT_core__EQ_) + tmp61 := lang.Apply(tmp60, []any{v46, lang.NewKeyword("as")}) + if lang.IsTruthy(tmp61) { + tmp62 := checkDerefVar(glojure_DOT_core_second) + tmp63 := lang.Apply(tmp62, []any{v38}) + tmp64 := lang.Apply(v9, []any{v36, tmp63, v21}) + tmp59 = tmp64 + } else { + var tmp65 any + if lang.IsTruthy(lang.NewKeyword("else")) { + var tmp66 any + if lang.IsTruthy(v39) { + tmp67 := lang.Apply(errors8.New, []any{"Unsupported binding form, only :as can follow & parameter"}) + panic(tmp67) + } else { + var tmp69 any + if lang.IsTruthy(v33) { + tmp70 := checkDerefVar(glojure_DOT_core_conj) + tmp71 := checkDerefVar(glojure_DOT_core_seq) + tmp72 := checkDerefVar(glojure_DOT_core_concat) + tmp73 := checkDerefVar(glojure_DOT_core_list) + tmp74 := lang.Apply(tmp73, []any{lang.NewSymbol("glojure.core/first")}) + tmp75 := checkDerefVar(glojure_DOT_core_list) + tmp76 := lang.Apply(tmp75, []any{v24}) + tmp77 := lang.Apply(tmp72, []any{tmp74, tmp76}) + tmp78 := lang.Apply(tmp71, []any{tmp77}) + tmp79 := checkDerefVar(glojure_DOT_core_seq) + tmp80 := checkDerefVar(glojure_DOT_core_concat) + tmp81 := checkDerefVar(glojure_DOT_core_list) + tmp82 := lang.Apply(tmp81, []any{lang.NewSymbol("glojure.core/next")}) + tmp83 := checkDerefVar(glojure_DOT_core_list) + tmp84 := lang.Apply(tmp83, []any{v24}) + tmp85 := lang.Apply(tmp80, []any{tmp82, tmp84}) + tmp86 := lang.Apply(tmp79, []any{tmp85}) + tmp87 := lang.Apply(tmp70, []any{v36, v27, tmp78, v24, tmp86}) + tmp69 = tmp87 + } else { + tmp69 = v36 + } + var tmp88 any + if lang.IsTruthy(v33) { + tmp88 = v27 + } else { + tmp89 := checkDerefVar(glojure_DOT_core_list) + tmp90 := lang.Apply(tmp89, []any{lang.NewSymbol("glojure.core/nth"), v21, v37, nil}) + tmp88 = tmp90 + } + tmp91 := lang.Apply(v9, []any{tmp69, v46, tmp88}) + var tmp68 any = tmp91 + tmp93 := checkDerefVar(glojure_DOT_core_inc) + tmp94 := lang.Apply(tmp93, []any{v37}) + var tmp92 any = tmp94 + tmp96 := checkDerefVar(glojure_DOT_core_next) + tmp97 := lang.Apply(tmp96, []any{v38}) + var tmp95 any = tmp97 + var tmp98 any = v39 + v36 = tmp68 + v37 = tmp92 + v38 = tmp95 + v39 = tmp98 + continue + } + tmp65 = tmp66 + } else { + } + tmp59 = tmp65 + } + tmp47 = tmp59 + } + tmp43 = tmp47 + } // end let + tmp40 = tmp43 + } else { + tmp40 = v36 + } + tmp34 = tmp40 + break + } + } // end let + tmp18 = tmp34 + } // end let + return tmp18 + }) + tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4404), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(4438), lang.NewKeyword("end-column"), int(34)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v17 any = tmp16 + _ = v17 + // let binding "pmap" + var tmp18 lang.FnFunc + tmp18 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v19 := args[0] + _ = v19 + v20 := args[1] + _ = v20 + v21 := args[2] + _ = v21 + var tmp22 any + { // let + // let binding "gmap" + tmp23 := checkDerefVar(glojure_DOT_core_gensym) + tmp24 := lang.Apply(tmp23, []any{"map__"}) + var v25 any = tmp24 + _ = v25 + // let binding "gmapseq" + tmp26 := checkDerefVar(glojure_DOT_core_with_meta) + tmp27 := lang.NewMap(lang.NewKeyword("tag"), lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.ISeq")) + tmp28 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4442), lang.NewKeyword("column"), int(52), lang.NewKeyword("end-line"), int(4442), lang.NewKeyword("end-column"), int(103)) + tmp29, err := lang.WithMeta(tmp27, tmp28.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp30 := lang.Apply(tmp26, []any{v25, tmp29}) + var v31 any = tmp30 + _ = v31 + // let binding "defaults" + tmp32 := lang.Apply(lang.NewKeyword("or"), []any{v20}) + var v33 any = tmp32 + _ = v33 + var tmp34 any + { // let + // let binding "ret" + var tmp35 lang.FnFunc + tmp35 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v36 := args[0] + _ = v36 + var tmp37 any + tmp38 := lang.Apply(lang.NewKeyword("as"), []any{v20}) + if lang.IsTruthy(tmp38) { + tmp39 := checkDerefVar(glojure_DOT_core_conj) + tmp40 := lang.Apply(lang.NewKeyword("as"), []any{v20}) + tmp41 := lang.Apply(tmp39, []any{v36, tmp40, v25}) + tmp37 = tmp41 + } else { + tmp37 = v36 + } + return tmp37 + }) + tmp36 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4450), lang.NewKeyword("column"), int(40), lang.NewKeyword("end-line"), int(4453), lang.NewKeyword("end-column"), int(48)) + tmp37, err := lang.WithMeta(tmp35, tmp36.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp38 := checkDerefVar(glojure_DOT_core_conj) + tmp39 := checkDerefVar(glojure_DOT_core_conj) + tmp40 := checkDerefVar(glojure_DOT_core_conj) + tmp41 := checkDerefVar(glojure_DOT_core_conj) + tmp42 := lang.Apply(tmp41, []any{v19, v25}) + tmp43 := lang.Apply(tmp40, []any{tmp42, v21}) + tmp44 := lang.Apply(tmp39, []any{tmp43, v25}) + tmp45 := checkDerefVar(glojure_DOT_core_seq) + tmp46 := checkDerefVar(glojure_DOT_core_concat) + tmp47 := checkDerefVar(glojure_DOT_core_list) + tmp48 := lang.Apply(tmp47, []any{lang.NewSymbol("if")}) + tmp49 := checkDerefVar(glojure_DOT_core_list) + tmp50 := checkDerefVar(glojure_DOT_core_seq) + tmp51 := checkDerefVar(glojure_DOT_core_concat) + tmp52 := checkDerefVar(glojure_DOT_core_list) + tmp53 := lang.Apply(tmp52, []any{lang.NewSymbol("glojure.core/seq?")}) + tmp54 := checkDerefVar(glojure_DOT_core_list) + tmp55 := lang.Apply(tmp54, []any{v25}) + tmp56 := lang.Apply(tmp51, []any{tmp53, tmp55}) + tmp57 := lang.Apply(tmp50, []any{tmp56}) + tmp58 := lang.Apply(tmp49, []any{tmp57}) + tmp59 := checkDerefVar(glojure_DOT_core_list) + tmp60 := checkDerefVar(glojure_DOT_core_seq) + tmp61 := checkDerefVar(glojure_DOT_core_concat) + tmp62 := checkDerefVar(glojure_DOT_core_list) + tmp63 := lang.Apply(tmp62, []any{lang.NewSymbol("if")}) + tmp64 := checkDerefVar(glojure_DOT_core_list) + tmp65 := checkDerefVar(glojure_DOT_core_seq) + tmp66 := checkDerefVar(glojure_DOT_core_concat) + tmp67 := checkDerefVar(glojure_DOT_core_list) + tmp68 := lang.Apply(tmp67, []any{lang.NewSymbol("glojure.core/next")}) + tmp69 := checkDerefVar(glojure_DOT_core_list) + tmp70 := lang.Apply(tmp69, []any{v31}) + tmp71 := lang.Apply(tmp66, []any{tmp68, tmp70}) + tmp72 := lang.Apply(tmp65, []any{tmp71}) + tmp73 := lang.Apply(tmp64, []any{tmp72}) + tmp74 := checkDerefVar(glojure_DOT_core_list) + tmp75 := checkDerefVar(glojure_DOT_core_seq) + tmp76 := checkDerefVar(glojure_DOT_core_concat) + tmp77 := checkDerefVar(glojure_DOT_core_list) + tmp78 := lang.Apply(tmp77, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewPersistentArrayMapAsIfByAssoc")}) + tmp79 := checkDerefVar(glojure_DOT_core_list) + tmp80 := checkDerefVar(glojure_DOT_core_seq) + tmp81 := checkDerefVar(glojure_DOT_core_concat) + tmp82 := checkDerefVar(glojure_DOT_core_list) + tmp83 := lang.Apply(tmp82, []any{lang.NewSymbol("glojure.core/to-array")}) + tmp84 := checkDerefVar(glojure_DOT_core_list) + tmp85 := lang.Apply(tmp84, []any{v31}) + tmp86 := lang.Apply(tmp81, []any{tmp83, tmp85}) + tmp87 := lang.Apply(tmp80, []any{tmp86}) + tmp88 := lang.Apply(tmp79, []any{tmp87}) + tmp89 := lang.Apply(tmp76, []any{tmp78, tmp88}) + tmp90 := lang.Apply(tmp75, []any{tmp89}) + tmp91 := lang.Apply(tmp74, []any{tmp90}) + tmp92 := checkDerefVar(glojure_DOT_core_list) + tmp93 := checkDerefVar(glojure_DOT_core_seq) + tmp94 := checkDerefVar(glojure_DOT_core_concat) + tmp95 := checkDerefVar(glojure_DOT_core_list) + tmp96 := lang.Apply(tmp95, []any{lang.NewSymbol("if")}) + tmp97 := checkDerefVar(glojure_DOT_core_list) + tmp98 := checkDerefVar(glojure_DOT_core_seq) + tmp99 := checkDerefVar(glojure_DOT_core_concat) + tmp100 := checkDerefVar(glojure_DOT_core_list) + tmp101 := lang.Apply(tmp100, []any{lang.NewSymbol("glojure.core/seq")}) + tmp102 := checkDerefVar(glojure_DOT_core_list) + tmp103 := lang.Apply(tmp102, []any{v31}) + tmp104 := lang.Apply(tmp99, []any{tmp101, tmp103}) + tmp105 := lang.Apply(tmp98, []any{tmp104}) + tmp106 := lang.Apply(tmp97, []any{tmp105}) + tmp107 := checkDerefVar(glojure_DOT_core_list) + tmp108 := checkDerefVar(glojure_DOT_core_seq) + tmp109 := checkDerefVar(glojure_DOT_core_concat) + tmp110 := checkDerefVar(glojure_DOT_core_list) + tmp111 := lang.Apply(tmp110, []any{lang.NewSymbol("glojure.core/first")}) + tmp112 := checkDerefVar(glojure_DOT_core_list) + tmp113 := lang.Apply(tmp112, []any{v31}) + tmp114 := lang.Apply(tmp109, []any{tmp111, tmp113}) + tmp115 := lang.Apply(tmp108, []any{tmp114}) + tmp116 := lang.Apply(tmp107, []any{tmp115}) + tmp117 := checkDerefVar(glojure_DOT_core_list) + tmp118 := lang.Apply(tmp117, []any{lang.NewSymbol("glojure.lang.PersistentArrayMap/EMPTY")}) + tmp119 := lang.Apply(tmp94, []any{tmp96, tmp106, tmp116, tmp118}) + tmp120 := lang.Apply(tmp93, []any{tmp119}) + tmp121 := lang.Apply(tmp92, []any{tmp120}) + tmp122 := lang.Apply(tmp61, []any{tmp63, tmp73, tmp91, tmp121}) + tmp123 := lang.Apply(tmp60, []any{tmp122}) + tmp124 := lang.Apply(tmp59, []any{tmp123}) + tmp125 := checkDerefVar(glojure_DOT_core_list) + tmp126 := lang.Apply(tmp125, []any{v25}) + tmp127 := lang.Apply(tmp46, []any{tmp48, tmp58, tmp124, tmp126}) + tmp128 := lang.Apply(tmp45, []any{tmp127}) + tmp129 := lang.Apply(tmp38, []any{tmp44, tmp128}) + tmp130 := lang.Apply(tmp37, []any{tmp129}) + var v131 any = tmp130 + _ = v131 + // let binding "bes" + var tmp132 any + { // let + // let binding "transforms" + tmp133 := checkDerefVar(glojure_DOT_core_reduce1) + var tmp134 lang.FnFunc + tmp134 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v135 := args[0] + _ = v135 + v136 := args[1] + _ = v136 + var tmp137 any + tmp138 := checkDerefVar(glojure_DOT_core_keyword_QMARK_) + tmp139 := lang.Apply(tmp138, []any{v136}) + if lang.IsTruthy(tmp139) { + var tmp140 any + { // let + // let binding "mkns" + tmp141 := checkDerefVar(glojure_DOT_core_namespace) + tmp142 := lang.Apply(tmp141, []any{v136}) + var v143 any = tmp142 + _ = v143 + // let binding "mkn" + tmp144 := checkDerefVar(glojure_DOT_core_name) + tmp145 := lang.Apply(tmp144, []any{v136}) + var v146 any = tmp145 + _ = v146 + var tmp147 any + tmp148 := checkDerefVar(glojure_DOT_core__EQ_) + tmp149 := lang.Apply(tmp148, []any{v146, "keys"}) + if lang.IsTruthy(tmp149) { + tmp150 := checkDerefVar(glojure_DOT_core_assoc) + var tmp151 lang.FnFunc + tmp151 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v152 := args[0] + _ = v152 + tmp153 := checkDerefVar(glojure_DOT_core_keyword) + var tmp154 any + { // let + // let binding "or__0__auto__" + var v155 any = v143 + _ = v155 + var tmp156 any + if lang.IsTruthy(v155) { + tmp156 = v155 + } else { + tmp157 := checkDerefVar(glojure_DOT_core_namespace) + tmp158 := lang.Apply(tmp157, []any{v152}) + tmp156 = tmp158 + } + tmp154 = tmp156 + } // end let + tmp155 := checkDerefVar(glojure_DOT_core_name) + tmp156 := lang.Apply(tmp155, []any{v152}) + tmp157 := lang.Apply(tmp153, []any{tmp154, tmp156}) + return tmp157 + }) + tmp152 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4460), lang.NewKeyword("column"), int(93), lang.NewKeyword("end-line"), int(4460), lang.NewKeyword("end-column"), int(135)) + tmp153, err := lang.WithMeta(tmp151, tmp152.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp154 := lang.Apply(tmp150, []any{v135, v136, tmp153}) + tmp147 = tmp154 + } else { + var tmp155 any + tmp156 := checkDerefVar(glojure_DOT_core__EQ_) + tmp157 := lang.Apply(tmp156, []any{v146, "syms"}) + if lang.IsTruthy(tmp157) { + tmp158 := checkDerefVar(glojure_DOT_core_assoc) + var tmp159 lang.FnFunc + tmp159 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v160 := args[0] + _ = v160 + tmp161 := checkDerefVar(glojure_DOT_core_list) + tmp162 := checkDerefVar(glojure_DOT_core_symbol) + var tmp163 any + { // let + // let binding "or__0__auto__" + var v164 any = v143 + _ = v164 + var tmp165 any + if lang.IsTruthy(v164) { + tmp165 = v164 + } else { + tmp166 := checkDerefVar(glojure_DOT_core_namespace) + tmp167 := lang.Apply(tmp166, []any{v160}) + tmp165 = tmp167 + } + tmp163 = tmp165 + } // end let + tmp164 := checkDerefVar(glojure_DOT_core_name) + tmp165 := lang.Apply(tmp164, []any{v160}) + tmp166 := lang.Apply(tmp162, []any{tmp163, tmp165}) + tmp167 := lang.Apply(tmp161, []any{lang.NewSymbol("quote"), tmp166}) + return tmp167 + }) + tmp160 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4461), lang.NewKeyword("column"), int(93), lang.NewKeyword("end-line"), int(4461), lang.NewKeyword("end-column"), int(148)) + tmp161, err := lang.WithMeta(tmp159, tmp160.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp162 := lang.Apply(tmp158, []any{v135, v136, tmp161}) + tmp155 = tmp162 + } else { + var tmp163 any + tmp164 := checkDerefVar(glojure_DOT_core__EQ_) + tmp165 := lang.Apply(tmp164, []any{v146, "strs"}) + if lang.IsTruthy(tmp165) { + tmp166 := checkDerefVar(glojure_DOT_core_assoc) + tmp167 := checkDerefVar(glojure_DOT_core_str) + tmp168 := lang.Apply(tmp166, []any{v135, v136, tmp167}) + tmp163 = tmp168 + } else { + var tmp169 any + if lang.IsTruthy(lang.NewKeyword("else")) { + tmp169 = v135 + } else { + } + tmp163 = tmp169 + } + tmp155 = tmp163 + } + tmp147 = tmp155 + } + tmp140 = tmp147 + } // end let + tmp137 = tmp140 + } else { + tmp137 = v135 + } + return tmp137 + }) + tmp135 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4456), lang.NewKeyword("column"), int(45), lang.NewKeyword("end-line"), int(4464), lang.NewKeyword("end-column"), int(60)) + tmp136, err := lang.WithMeta(tmp134, tmp135.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp137 := lang.NewMap() + tmp138 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4465), lang.NewKeyword("column"), int(45), lang.NewKeyword("end-line"), int(4465), lang.NewKeyword("end-column"), int(46)) + tmp139, err := lang.WithMeta(tmp137, tmp138.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp140 := checkDerefVar(glojure_DOT_core_keys) + tmp141 := lang.Apply(tmp140, []any{v20}) + tmp142 := lang.Apply(tmp133, []any{tmp136, tmp139, tmp141}) + var v143 any = tmp142 + _ = v143 + tmp144 := checkDerefVar(glojure_DOT_core_reduce1) + var tmp145 lang.FnFunc + tmp145 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v146 := args[0] + _ = v146 + v147 := args[1] + _ = v147 + tmp148 := checkDerefVar(glojure_DOT_core_reduce1) + var tmp149 lang.FnFunc + tmp149 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v150 := args[0] + _ = v150 + v151 := args[1] + _ = v151 + tmp152 := checkDerefVar(glojure_DOT_core_assoc) + tmp153 := checkDerefVar(glojure_DOT_core_val) + tmp154 := lang.Apply(tmp153, []any{v147}) + tmp155 := lang.Apply(tmp154, []any{v151}) + tmp156 := lang.Apply(tmp152, []any{v150, v151, tmp155}) + return tmp156 + }) + tmp150 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4469), lang.NewKeyword("column"), int(52), lang.NewKeyword("end-line"), int(4469), lang.NewKeyword("end-column"), int(82)) + tmp151, err := lang.WithMeta(tmp149, tmp150.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp152 := checkDerefVar(glojure_DOT_core_dissoc) + tmp153 := checkDerefVar(glojure_DOT_core_key) + tmp154 := lang.Apply(tmp153, []any{v147}) + tmp155 := lang.Apply(tmp152, []any{v146, tmp154}) + tmp156 := checkDerefVar(glojure_DOT_core_key) + tmp157 := lang.Apply(tmp156, []any{v147}) + tmp158 := lang.Apply(tmp157, []any{v146}) + tmp159 := lang.Apply(tmp148, []any{tmp151, tmp155, tmp158}) + return tmp159 + }) + tmp146 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4468), lang.NewKeyword("column"), int(41), lang.NewKeyword("end-line"), int(4471), lang.NewKeyword("end-column"), int(70)) + tmp147, err := lang.WithMeta(tmp145, tmp146.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp148 := checkDerefVar(glojure_DOT_core_dissoc) + tmp149 := lang.Apply(tmp148, []any{v20, lang.NewKeyword("as"), lang.NewKeyword("or")}) + tmp150 := lang.Apply(tmp144, []any{tmp147, tmp149, v143}) + tmp132 = tmp150 + } // end let + var v133 any = tmp132 + _ = v133 + for { + var tmp134 any + tmp135 := checkDerefVar(glojure_DOT_core_seq) + tmp136 := lang.Apply(tmp135, []any{v133}) + if lang.IsTruthy(tmp136) { + var tmp137 any + { // let + // let binding "bb" + tmp138 := checkDerefVar(glojure_DOT_core_key) + tmp139 := checkDerefVar(glojure_DOT_core_first) + tmp140 := lang.Apply(tmp139, []any{v133}) + tmp141 := lang.Apply(tmp138, []any{tmp140}) + var v142 any = tmp141 + _ = v142 + // let binding "bk" + tmp143 := checkDerefVar(glojure_DOT_core_val) + tmp144 := checkDerefVar(glojure_DOT_core_first) + tmp145 := lang.Apply(tmp144, []any{v133}) + tmp146 := lang.Apply(tmp143, []any{tmp145}) + var v147 any = tmp146 + _ = v147 + // let binding "local" + var tmp148 any + tmp149 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp150 := reflect.TypeOf((*lang.Named)(nil)).Elem() + tmp151 := lang.Apply(tmp149, []any{tmp150, v142}) + if lang.IsTruthy(tmp151) { + tmp152 := checkDerefVar(glojure_DOT_core_with_meta) + tmp153 := checkDerefVar(glojure_DOT_core_symbol) + tmp154 := checkDerefVar(glojure_DOT_core_name) + tmp155 := lang.Apply(tmp154, []any{v142}) + tmp156 := lang.Apply(tmp153, []any{nil, tmp155}) + tmp157 := checkDerefVar(glojure_DOT_core_meta) + tmp158 := lang.Apply(tmp157, []any{v142}) + tmp159 := lang.Apply(tmp152, []any{tmp156, tmp158}) + tmp148 = tmp159 + } else { + tmp148 = v142 + } + var v160 any = tmp148 + _ = v160 + // let binding "bv" + var tmp161 any + tmp162 := checkDerefVar(glojure_DOT_core_contains_QMARK_) + tmp163 := lang.Apply(tmp162, []any{v33, v160}) + if lang.IsTruthy(tmp163) { + tmp164 := checkDerefVar(glojure_DOT_core_list) + tmp165 := lang.Apply(v33, []any{v160}) + tmp166 := lang.Apply(tmp164, []any{lang.NewSymbol("glojure.core/get"), v25, v147, tmp165}) + tmp161 = tmp166 + } else { + tmp167 := checkDerefVar(glojure_DOT_core_list) + tmp168 := lang.Apply(tmp167, []any{lang.NewSymbol("glojure.core/get"), v25, v147}) + tmp161 = tmp168 + } + var v169 any = tmp161 + _ = v169 + var tmp171 any + tmp172 := checkDerefVar(glojure_DOT_core_ident_QMARK_) + tmp173 := lang.Apply(tmp172, []any{v142}) + if lang.IsTruthy(tmp173) { + tmp174 := checkDerefVar(glojure_DOT_core_conj) + tmp175 := lang.Apply(tmp174, []any{v131, v160, v169}) + tmp171 = tmp175 + } else { + tmp176 := lang.Apply(v9, []any{v131, v142, v169}) + tmp171 = tmp176 + } + var tmp170 any = tmp171 + tmp178 := checkDerefVar(glojure_DOT_core_next) + tmp179 := lang.Apply(tmp178, []any{v133}) + var tmp177 any = tmp179 + v131 = tmp170 + v133 = tmp177 + continue + } // end let + tmp134 = tmp137 + } else { + tmp134 = v131 + } + tmp34 = tmp134 + break + } + } // end let + tmp22 = tmp34 + } // end let + return tmp22 + }) + tmp19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4440), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(4485), lang.NewKeyword("end-column"), int(34)) + tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v21 any = tmp20 + _ = v21 + var tmp22 any + tmp23 := checkDerefVar(glojure_DOT_core_symbol_QMARK_) + tmp24 := lang.Apply(tmp23, []any{v11}) + if lang.IsTruthy(tmp24) { + tmp25 := checkDerefVar(glojure_DOT_core_conj) + tmp26 := checkDerefVar(glojure_DOT_core_conj) + tmp27 := lang.Apply(tmp26, []any{v10, v11}) + tmp28 := lang.Apply(tmp25, []any{tmp27, v12}) + tmp22 = tmp28 + } else { + var tmp29 any + tmp30 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp31 := lang.Apply(tmp30, []any{v11}) + if lang.IsTruthy(tmp31) { + tmp32 := lang.Apply(v17, []any{v10, v11, v12}) + tmp29 = tmp32 + } else { + var tmp33 any + tmp34 := checkDerefVar(glojure_DOT_core_map_QMARK_) + tmp35 := lang.Apply(tmp34, []any{v11}) + if lang.IsTruthy(tmp35) { + tmp36 := lang.Apply(v21, []any{v10, v11, v12}) + tmp33 = tmp36 + } else { + var tmp37 any + if lang.IsTruthy(lang.NewKeyword("else")) { + tmp38 := checkDerefVar(glojure_DOT_core_str) + tmp39 := lang.Apply(tmp38, []any{"Unsupported binding form: ", v11}) + tmp40 := lang.Apply(errors8.New, []any{tmp39}) + panic(tmp40) + } else { + } + tmp33 = tmp37 + } + tmp29 = tmp33 + } + tmp22 = tmp29 + } + tmp13 = tmp22 + } // end let + return tmp13 + }) + v9 = tmp8 + _ = v9 + } + tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4402), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(4490), lang.NewKeyword("end-column"), int(82)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v11 any = tmp10 + _ = v11 + // let binding "process-entry" + var tmp12 lang.FnFunc + tmp12 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v13 := args[0] + _ = v13 + v14 := args[1] + _ = v14 + tmp15 := checkDerefVar(glojure_DOT_core_first) + tmp16 := lang.Apply(tmp15, []any{v14}) + tmp17 := checkDerefVar(glojure_DOT_core_second) + tmp18 := lang.Apply(tmp17, []any{v14}) + tmp19 := lang.Apply(v11, []any{v13, tmp16, tmp18}) + return tmp19 + }) + tmp13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4491), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(4491), lang.NewKeyword("end-column"), int(66)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v15 any = tmp14 + _ = v15 + var tmp16 any + tmp17 := checkDerefVar(glojure_DOT_core_every_QMARK_) + tmp18 := checkDerefVar(glojure_DOT_core_symbol_QMARK_) + tmp19 := checkDerefVar(glojure_DOT_core_map) + tmp20 := checkDerefVar(glojure_DOT_core_first) + tmp21 := lang.Apply(tmp19, []any{tmp20, v7}) + tmp22 := lang.Apply(tmp17, []any{tmp18, tmp21}) + if lang.IsTruthy(tmp22) { + tmp16 = v3 + } else { + tmp23 := checkDerefVar(glojure_DOT_core_reduce1) + tmp24 := lang.NewVector() + tmp25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4494), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(4494), lang.NewKeyword("end-column"), int(31)) + tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp27 := lang.Apply(tmp23, []any{v15, tmp26, v7}) + tmp16 = tmp27 + } + tmp4 = tmp16 + } // end let + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // disj + { + tmp0 := lang.NewSymbol("disj").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("set")), lang.NewVector(lang.NewSymbol("set"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("set"), lang.NewSymbol("key"), lang.NewSymbol("&"), lang.NewSymbol("ks"))), lang.NewKeyword("doc"), "disj[oin]. Returns a new set of the same (hashed/sorted) type, that\n does not contain key(s).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1514), lang.NewKeyword("end-line"), int(1514))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + return v3 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 any + if lang.IsTruthy(v3) { + tmp6, _ := lang.FieldOrMethod(v3, "Disjoin") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Disjoin is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4}) + tmp5 = tmp7 + } else { + } + return tmp5 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + recur_loop_304: + var tmp6 any + if lang.IsTruthy(v3) { + var tmp7 any + { // let + // let binding "ret" + tmp8 := checkDerefVar(glojure_DOT_core_disj) + tmp9 := lang.Apply(tmp8, []any{v3, v4}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + if lang.IsTruthy(v5) { + var tmp12 any = v10 + tmp14 := checkDerefVar(glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v5}) + var tmp13 any = tmp15 + tmp17 := checkDerefVar(glojure_DOT_core_next) + tmp18 := lang.Apply(tmp17, []any{v5}) + var tmp16 any = tmp18 + v3 = tmp12 + v4 = tmp13 + v5 = tmp16 + goto recur_loop_304 + } else { + tmp11 = v10 + } + tmp7 = tmp11 + } // end let + tmp6 = tmp7 + } else { + } + return tmp6 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // disj! + { + tmp0 := lang.NewSymbol("disj!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("set")), lang.NewVector(lang.NewSymbol("set"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("set"), lang.NewSymbol("key"), lang.NewSymbol("&"), lang.NewSymbol("ks"))), lang.NewKeyword("doc"), "disj[oin]. Returns a transient set of the same (hashed/sorted) type, that\n does not contain key(s).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3401), lang.NewKeyword("end-line"), int(3401))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + return v3 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(v3, "Disjoin") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Disjoin is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + recur_loop_615: + var tmp6 any + { // let + // let binding "ret" + tmp7, _ := lang.FieldOrMethod(v3, "Disjoin") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Disjoin is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v4}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v5) { + var tmp11 any = v9 + tmp13 := checkDerefVar(glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v5}) + var tmp12 any = tmp14 + tmp16 := checkDerefVar(glojure_DOT_core_next) + tmp17 := lang.Apply(tmp16, []any{v5}) + var tmp15 any = tmp17 + v3 = tmp11 + v4 = tmp12 + v5 = tmp15 + goto recur_loop_615 + } else { + tmp10 = v9 + } + tmp6 = tmp10 + } // end let + return tmp6 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // dissoc + { + tmp0 := lang.NewSymbol("dissoc").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map")), lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"), lang.NewSymbol("&"), lang.NewSymbol("ks"))), lang.NewKeyword("doc"), "dissoc[iate]. Returns a new map of the same (hashed/sorted) type,\n that does not contain a mapping for key(s).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1500), lang.NewKeyword("end-line"), int(1500))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + return v3 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(runtime7.RT, "Dissoc") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Dissoc is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + recur_loop_301: + var tmp6 any + { // let + // let binding "ret" + tmp7 := checkDerefVar(glojure_DOT_core_dissoc) + tmp8 := lang.Apply(tmp7, []any{v3, v4}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v5) { + var tmp11 any = v9 + tmp13 := checkDerefVar(glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v5}) + var tmp12 any = tmp14 + tmp16 := checkDerefVar(glojure_DOT_core_next) + tmp17 := lang.Apply(tmp16, []any{v5}) + var tmp15 any = tmp17 + v3 = tmp11 + v4 = tmp12 + v5 = tmp15 + goto recur_loop_301 + } else { + tmp10 = v9 + } + tmp6 = tmp10 + } // end let + return tmp6 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // dissoc! + { + tmp0 := lang.NewSymbol("dissoc!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"), lang.NewSymbol("&"), lang.NewSymbol("ks"))), lang.NewKeyword("doc"), "Returns a transient map that doesn't contain a mapping for key(s).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3382), lang.NewKeyword("end-line"), int(3382))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(v3, "without") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("without is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + recur_loop_611: + var tmp6 any + { // let + // let binding "ret" + tmp7, _ := lang.FieldOrMethod(v3, "without") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("without is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v4}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v5) { + var tmp11 any = v9 + tmp13 := checkDerefVar(glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v5}) + var tmp12 any = tmp14 + tmp16 := checkDerefVar(glojure_DOT_core_next) + tmp17 := lang.Apply(tmp16, []any{v5}) + var tmp15 any = tmp17 + v3 = tmp11 + v4 = tmp12 + v5 = tmp15 + goto recur_loop_611 + } else { + tmp10 = v9 + } + tmp6 = tmp10 + } // end let + return tmp6 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // distinct + { + tmp0 := lang.NewSymbol("distinct").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the elements of coll with duplicates removed.\n Returns a stateful transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5053), lang.NewKeyword("end-line"), int(5053))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + var tmp5 any + { // let + // let binding "seen" + tmp6 := checkDerefVar(glojure_DOT_core_volatile_BANG_) + tmp7 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5060), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(5060), lang.NewKeyword("end-column"), int(30)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp10 := lang.Apply(tmp6, []any{tmp9}) + var v11 any = tmp10 + _ = v11 + var tmp12 lang.FnFunc + tmp12 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp13 := lang.Apply(v4, nil) + return tmp13 + case 1: + v13 := args[0] + _ = v13 + tmp14 := lang.Apply(v4, []any{v13}) + return tmp14 + case 2: + v13 := args[0] + _ = v13 + v14 := args[1] + _ = v14 + var tmp15 any + tmp16 := checkDerefVar(glojure_DOT_core_contains_QMARK_) + tmp17 := checkDerefVar(glojure_DOT_core_deref) + tmp18 := lang.Apply(tmp17, []any{v11}) + tmp19 := lang.Apply(tmp16, []any{tmp18, v14}) + if lang.IsTruthy(tmp19) { + tmp15 = v13 + } else { + tmp20 := checkDerefVar(glojure_DOT_core_conj) + tmp21, ok := lang.FieldOrMethod(v11, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v11, "Deref"))) + } + var tmp22 any + switch reflect.TypeOf(tmp21).Kind() { + case reflect.Func: + tmp22 = lang.Apply(tmp21, nil) + default: + tmp22 = tmp21 + } + tmp23 := lang.Apply(tmp20, []any{tmp22, v14}) + tmp24, _ := lang.FieldOrMethod(v11, "reset") + if reflect.TypeOf(tmp24).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) + } + tmp25 := lang.Apply(tmp24, []any{tmp23}) + _ = tmp25 + tmp26 := lang.Apply(v4, []any{v13, v14}) + tmp15 = tmp26 + } + return tmp15 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5061), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(5068), lang.NewKeyword("end-column"), int(37)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp5 = tmp14 + } // end let + return tmp5 + }) + tmp4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5059), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(5068), lang.NewKeyword("end-column"), int(39)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 1: + v3 := args[0] + _ = v3 + var tmp4 any + { // let + // let binding "step" + var tmp5 lang.FnFunc + { // function step + var v6 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + recur_loop_877: + var tmp13 any + { // let + // let binding "vec__62" + var v14 any = v11 + _ = v14 + // let binding "f" + tmp15 := checkDerefVar(glojure_DOT_core_nth) + tmp16 := lang.Apply(tmp15, []any{v14, int64(0), nil}) + var v17 any = tmp16 + _ = v17 + // let binding "xs" + var v18 any = v14 + _ = v18 + var tmp19 any + { // let + // let binding "temp__0__auto__" + tmp20 := checkDerefVar(glojure_DOT_core_seq) + tmp21 := lang.Apply(tmp20, []any{v18}) + var v22 any = tmp21 + _ = v22 + var tmp23 any + if lang.IsTruthy(v22) { + var tmp24 any + { // let + // let binding "s" + var v25 any = v22 + _ = v25 + var tmp26 any + tmp27 := checkDerefVar(glojure_DOT_core_contains_QMARK_) + tmp28 := lang.Apply(tmp27, []any{v12, v17}) + if lang.IsTruthy(tmp28) { + tmp30 := checkDerefVar(glojure_DOT_core_rest) + tmp31 := lang.Apply(tmp30, []any{v25}) + var tmp29 any = tmp31 + var tmp32 any = v12 + v11 = tmp29 + v12 = tmp32 + goto recur_loop_877 + } else { + tmp33 := checkDerefVar(glojure_DOT_core_cons) + tmp34 := checkDerefVar(glojure_DOT_core_rest) + tmp35 := lang.Apply(tmp34, []any{v25}) + tmp36 := checkDerefVar(glojure_DOT_core_conj) + tmp37 := lang.Apply(tmp36, []any{v12, v17}) + tmp38 := lang.Apply(v6, []any{tmp35, tmp37}) + tmp39 := lang.Apply(tmp33, []any{v17, tmp38}) + tmp26 = tmp39 + } + tmp24 = tmp26 + } // end let + tmp23 = tmp24 + } else { + } + tmp19 = tmp23 + } // end let + tmp13 = tmp19 + } // end let + return tmp13 + }) + tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5072), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(5076), lang.NewKeyword("end-column"), int(66)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := lang.Apply(tmp12, []any{v7, v8}) + return tmp13 + }) + tmp10 := lang.Apply(lang.NewLazySeq, []any{tmp9}) + return tmp10 + }) + v6 = tmp5 + _ = v6 + } + tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5070), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(5077), lang.NewKeyword("end-column"), int(29)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v8 any = tmp7 + _ = v8 + tmp9 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5078), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(5078), lang.NewKeyword("end-column"), int(19)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp12 := lang.Apply(v8, []any{v3, tmp11}) + tmp4 = tmp12 + } // end let + return tmp4 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // distinct? + { + tmp1 := reflect.TypeOf(false) + tmp0 := lang.NewSymbol("distinct?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Returns true if no two of the arguments are =", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5664), lang.NewKeyword("end-line"), int(5664))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + return true + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6 := checkDerefVar(glojure_DOT_core_not) + tmp7 := checkDerefVar(glojure_DOT_core__EQ_) + tmp8 := lang.Apply(tmp7, []any{v4, v5}) + tmp9 := lang.Apply(tmp6, []any{tmp8}) + return tmp9 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + var tmp7 any + tmp8 := checkDerefVar(glojure_DOT_core_not_EQ_) + tmp9 := lang.Apply(tmp8, []any{v4, v5}) + if lang.IsTruthy(tmp9) { + var tmp10 any + { // let + // let binding "s" + tmp11 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{v4, v5})) + tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5673), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(5673), lang.NewKeyword("end-column"), int(20)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v14 any = tmp13 + _ = v14 + // let binding "G__99" + var v15 any = v6 + _ = v15 + // let binding "vec__100" + var v16 any = v15 + _ = v16 + // let binding "seq__101" + tmp17 := checkDerefVar(glojure_DOT_core_seq) + tmp18 := lang.Apply(tmp17, []any{v16}) + var v19 any = tmp18 + _ = v19 + // let binding "first__102" + tmp20 := checkDerefVar(glojure_DOT_core_first) + tmp21 := lang.Apply(tmp20, []any{v19}) + var v22 any = tmp21 + _ = v22 + // let binding "seq__101" + tmp23 := checkDerefVar(glojure_DOT_core_next) + tmp24 := lang.Apply(tmp23, []any{v19}) + var v25 any = tmp24 + _ = v25 + // let binding "x" + var v26 any = v22 + _ = v26 + // let binding "etc" + var v27 any = v25 + _ = v27 + // let binding "xs" + var v28 any = v16 + _ = v28 + var tmp29 any + { // let + // let binding "s" + var v30 any = v14 + _ = v30 + // let binding "G__99" + var v31 any = v15 + _ = v31 + for { + var tmp32 any + { // let + // let binding "s" + var v33 any = v30 + _ = v33 + // let binding "vec__103" + var v34 any = v31 + _ = v34 + // let binding "seq__104" + tmp35 := checkDerefVar(glojure_DOT_core_seq) + tmp36 := lang.Apply(tmp35, []any{v34}) + var v37 any = tmp36 + _ = v37 + // let binding "first__105" + tmp38 := checkDerefVar(glojure_DOT_core_first) + tmp39 := lang.Apply(tmp38, []any{v37}) + var v40 any = tmp39 + _ = v40 + // let binding "seq__104" + tmp41 := checkDerefVar(glojure_DOT_core_next) + tmp42 := lang.Apply(tmp41, []any{v37}) + var v43 any = tmp42 + _ = v43 + // let binding "x" + var v44 any = v40 + _ = v44 + // let binding "etc" + var v45 any = v43 + _ = v45 + // let binding "xs" + var v46 any = v34 + _ = v46 + var tmp47 any + if lang.IsTruthy(v46) { + var tmp48 any + tmp49 := checkDerefVar(glojure_DOT_core_contains_QMARK_) + tmp50 := lang.Apply(tmp49, []any{v33, v44}) + if lang.IsTruthy(tmp50) { + tmp48 = false + } else { + tmp52 := checkDerefVar(glojure_DOT_core_conj) + tmp53 := lang.Apply(tmp52, []any{v33, v44}) + var tmp51 any = tmp53 + var tmp54 any = v45 + v30 = tmp51 + v31 = tmp54 + continue + } + tmp47 = tmp48 + } else { + tmp47 = true + } + tmp32 = tmp47 + } // end let + tmp29 = tmp32 + break + } + } // end let + tmp10 = tmp29 + } // end let + tmp7 = tmp10 + } else { + tmp7 = false + } + return tmp7 + } + }) + tmp4 := reflect.TypeOf(false) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // doall + { + tmp0 := lang.NewSymbol("doall").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "When lazy sequences are produced via functions that have side\n effects, any effects other than those needed to produce the first\n element in the seq do not occur until the seq is consumed. doall can\n be used to force any effects. Walks through the successive nexts of\n the seq, retains the head and returns it, thus causing the entire\n seq to reside in memory at one time.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3131), lang.NewKeyword("end-line"), int(3131))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_dorun) + tmp5 := lang.Apply(tmp4, []any{v3}) + _ = tmp5 + return v3 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_dorun) + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + _ = tmp6 + return v4 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // dorun + { + tmp0 := lang.NewSymbol("dorun").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "When lazy sequences are produced via functions that have side\n effects, any effects other than those needed to produce the first\n element in the seq do not occur until the seq is consumed. dorun can\n be used to force any effects. Walks through the successive nexts of\n the seq, does not retain the head and returns nil.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3116), lang.NewKeyword("end-line"), int(3116))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + recur_loop_579: + var tmp4 any + { // let + // let binding "temp__0__auto__" + tmp5 := checkDerefVar(glojure_DOT_core_seq) + tmp6 := lang.Apply(tmp5, []any{v3}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + if lang.IsTruthy(v7) { + var tmp9 any + { // let + // let binding "s" + var v10 any = v7 + _ = v10 + tmp12 := checkDerefVar(glojure_DOT_core_next) + tmp13 := lang.Apply(tmp12, []any{v10}) + var tmp11 any = tmp13 + v3 = tmp11 + goto recur_loop_579 + } // end let + tmp8 = tmp9 + } else { + } + tmp4 = tmp8 + } // end let + return tmp4 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + recur_loop_580: + var tmp5 any + var tmp6 any + { // let + // let binding "and__0__auto__" + tmp7 := checkDerefVar(glojure_DOT_core_seq) + tmp8 := lang.Apply(tmp7, []any{v4}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + tmp11 := checkDerefVar(glojure_DOT_core_pos_QMARK_) + tmp12 := lang.Apply(tmp11, []any{v3}) + tmp10 = tmp12 + } else { + tmp10 = v9 + } + tmp6 = tmp10 + } // end let + if lang.IsTruthy(tmp6) { + tmp8 := checkDerefVar(glojure_DOT_core_dec) + tmp9 := lang.Apply(tmp8, []any{v3}) + var tmp7 any = tmp9 + tmp11 := checkDerefVar(glojure_DOT_core_next) + tmp12 := lang.Apply(tmp11, []any{v4}) + var tmp10 any = tmp12 + v3 = tmp7 + v4 = tmp10 + goto recur_loop_580 + } else { + } + return tmp5 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // doseq + { + tmp0 := lang.NewSymbol("doseq").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("seq-exprs"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Repeatedly executes body (presumably for side-effects) with\n bindings and filtering as provided by \"for\". Does not retain\n the head of the sequence. Returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3209), lang.NewKeyword("end-line"), int(3209))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any + tmp8 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp9 := lang.Apply(tmp8, []any{v5}) + if lang.IsTruthy(tmp9) { + } else { + tmp10 := checkDerefVar(glojure_DOT_core_str) + tmp11 := checkDerefVar(glojure_DOT_core_first) + tmp12 := lang.Apply(tmp11, []any{v3}) + tmp13 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) + tmp14 := checkDerefVar(glojure_DOT_core_meta) + tmp15 := lang.Apply(tmp14, []any{v3}) + tmp16 := lang.Apply(lang.NewKeyword("line"), []any{tmp15}) + tmp17 := lang.Apply(tmp10, []any{tmp12, " requires ", "a vector for its binding", " in ", tmp13, ":", tmp16}) + tmp18 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp17}) + panic(tmp18) + } + _ = tmp7 + var tmp19 any + tmp20 := checkDerefVar(glojure_DOT_core_even_QMARK_) + tmp21 := checkDerefVar(glojure_DOT_core_count) + tmp22 := lang.Apply(tmp21, []any{v5}) + tmp23 := lang.Apply(tmp20, []any{tmp22}) + if lang.IsTruthy(tmp23) { + } else { + tmp24 := checkDerefVar(glojure_DOT_core_str) + tmp25 := checkDerefVar(glojure_DOT_core_first) + tmp26 := lang.Apply(tmp25, []any{v3}) + tmp27 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) + tmp28 := checkDerefVar(glojure_DOT_core_meta) + tmp29 := lang.Apply(tmp28, []any{v3}) + tmp30 := lang.Apply(lang.NewKeyword("line"), []any{tmp29}) + tmp31 := lang.Apply(tmp24, []any{tmp26, " requires ", "an even number of forms in binding vector", " in ", tmp27, ":", tmp30}) + tmp32 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp31}) + panic(tmp32) + } + _ = tmp19 + var tmp33 any + { // let + // let binding "step" + var tmp34 lang.FnFunc + { // function step + var v35 lang.FnFunc + tmp34 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v36 := args[0] + _ = v36 + v37 := args[1] + _ = v37 + var tmp38 any + tmp39 := checkDerefVar(glojure_DOT_core_not) + tmp40 := lang.Apply(tmp39, []any{v37}) + if lang.IsTruthy(tmp40) { + tmp41 := checkDerefVar(glojure_DOT_core_seq) + tmp42 := checkDerefVar(glojure_DOT_core_concat) + tmp43 := checkDerefVar(glojure_DOT_core_list) + tmp44 := lang.Apply(tmp43, []any{lang.NewSymbol("do")}) + tmp45 := lang.Apply(tmp42, []any{tmp44, v6}) + tmp46 := lang.Apply(tmp41, []any{tmp45}) + tmp47 := lang.NewVector(true, tmp46) + tmp48 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3220), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(3220), lang.NewKeyword("end-column"), int(36)) + tmp49, err := lang.WithMeta(tmp47, tmp48.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp38 = tmp49 + } else { + var tmp50 any + { // let + // let binding "k" + tmp51 := checkDerefVar(glojure_DOT_core_first) + tmp52 := lang.Apply(tmp51, []any{v37}) + var v53 any = tmp52 + _ = v53 + // let binding "v" + tmp54 := checkDerefVar(glojure_DOT_core_second) + tmp55 := lang.Apply(tmp54, []any{v37}) + var v56 any = tmp55 + _ = v56 + var tmp57 any + tmp58 := checkDerefVar(glojure_DOT_core_keyword_QMARK_) + tmp59 := lang.Apply(tmp58, []any{v53}) + if lang.IsTruthy(tmp59) { + var tmp60 any + { // let + // let binding "steppair" + tmp61 := checkDerefVar(glojure_DOT_core_nnext) + tmp62 := lang.Apply(tmp61, []any{v37}) + tmp63 := lang.Apply(v35, []any{v36, tmp62}) + var v64 any = tmp63 + _ = v64 + // let binding "needrec" + tmp65 := lang.Apply(v64, []any{int64(0)}) + var v66 any = tmp65 + _ = v66 + // let binding "subform" + tmp67 := lang.Apply(v64, []any{int64(1)}) + var v68 any = tmp67 + _ = v68 + var tmp69 any + tmp70 := checkDerefVar(glojure_DOT_core__EQ_) + tmp71 := lang.Apply(tmp70, []any{v53, lang.NewKeyword("let")}) + if lang.IsTruthy(tmp71) { + tmp72 := checkDerefVar(glojure_DOT_core_seq) + tmp73 := checkDerefVar(glojure_DOT_core_concat) + tmp74 := checkDerefVar(glojure_DOT_core_list) + tmp75 := lang.Apply(tmp74, []any{lang.NewSymbol("glojure.core/let")}) + tmp76 := checkDerefVar(glojure_DOT_core_list) + tmp77 := lang.Apply(tmp76, []any{v56}) + tmp78 := checkDerefVar(glojure_DOT_core_list) + tmp79 := lang.Apply(tmp78, []any{v68}) + tmp80 := lang.Apply(tmp73, []any{tmp75, tmp77, tmp79}) + tmp81 := lang.Apply(tmp72, []any{tmp80}) + tmp82 := lang.NewVector(v66, tmp81) + tmp83 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3228), lang.NewKeyword("column"), int(37), lang.NewKeyword("end-line"), int(3228), lang.NewKeyword("end-column"), int(64)) + tmp84, err := lang.WithMeta(tmp82, tmp83.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp69 = tmp84 + } else { + var tmp85 any + tmp86 := checkDerefVar(glojure_DOT_core__EQ_) + tmp87 := lang.Apply(tmp86, []any{v53, lang.NewKeyword("while")}) + if lang.IsTruthy(tmp87) { + tmp88 := checkDerefVar(glojure_DOT_core_seq) + tmp89 := checkDerefVar(glojure_DOT_core_concat) + tmp90 := checkDerefVar(glojure_DOT_core_list) + tmp91 := lang.Apply(tmp90, []any{lang.NewSymbol("glojure.core/when")}) + tmp92 := checkDerefVar(glojure_DOT_core_list) + tmp93 := lang.Apply(tmp92, []any{v56}) + tmp94 := checkDerefVar(glojure_DOT_core_list) + tmp95 := lang.Apply(tmp94, []any{v68}) + var tmp96 any + if lang.IsTruthy(v66) { + tmp97 := lang.NewVector(v36) + tmp98 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3231), lang.NewKeyword("column"), int(65), lang.NewKeyword("end-line"), int(3231), lang.NewKeyword("end-column"), int(73)) + tmp99, err := lang.WithMeta(tmp97, tmp98.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp96 = tmp99 + } else { + } + tmp100 := lang.Apply(tmp89, []any{tmp91, tmp93, tmp95, tmp96}) + tmp101 := lang.Apply(tmp88, []any{tmp100}) + tmp102 := lang.NewVector(false, tmp101) + tmp103 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3229), lang.NewKeyword("column"), int(39), lang.NewKeyword("end-line"), int(3231), lang.NewKeyword("end-column"), int(76)) + tmp104, err := lang.WithMeta(tmp102, tmp103.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp85 = tmp104 + } else { + var tmp105 any + tmp106 := checkDerefVar(glojure_DOT_core__EQ_) + tmp107 := lang.Apply(tmp106, []any{v53, lang.NewKeyword("when")}) + if lang.IsTruthy(tmp107) { + tmp108 := checkDerefVar(glojure_DOT_core_seq) + tmp109 := checkDerefVar(glojure_DOT_core_concat) + tmp110 := checkDerefVar(glojure_DOT_core_list) + tmp111 := lang.Apply(tmp110, []any{lang.NewSymbol("if")}) + tmp112 := checkDerefVar(glojure_DOT_core_list) + tmp113 := lang.Apply(tmp112, []any{v56}) + tmp114 := checkDerefVar(glojure_DOT_core_list) + tmp115 := checkDerefVar(glojure_DOT_core_seq) + tmp116 := checkDerefVar(glojure_DOT_core_concat) + tmp117 := checkDerefVar(glojure_DOT_core_list) + tmp118 := lang.Apply(tmp117, []any{lang.NewSymbol("do")}) + tmp119 := checkDerefVar(glojure_DOT_core_list) + tmp120 := lang.Apply(tmp119, []any{v68}) + var tmp121 any + if lang.IsTruthy(v66) { + tmp122 := lang.NewVector(v36) + tmp123 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3235), lang.NewKeyword("column"), int(66), lang.NewKeyword("end-line"), int(3235), lang.NewKeyword("end-column"), int(74)) + tmp124, err := lang.WithMeta(tmp122, tmp123.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp121 = tmp124 + } else { + } + tmp125 := lang.Apply(tmp116, []any{tmp118, tmp120, tmp121}) + tmp126 := lang.Apply(tmp115, []any{tmp125}) + tmp127 := lang.Apply(tmp114, []any{tmp126}) + tmp128 := checkDerefVar(glojure_DOT_core_list) + tmp129 := lang.Apply(tmp128, []any{v36}) + tmp130 := lang.Apply(tmp109, []any{tmp111, tmp113, tmp127, tmp129}) + tmp131 := lang.Apply(tmp108, []any{tmp130}) + tmp132 := lang.NewVector(false, tmp131) + tmp133 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3232), lang.NewKeyword("column"), int(38), lang.NewKeyword("end-line"), int(3236), lang.NewKeyword("end-column"), int(57)) + tmp134, err := lang.WithMeta(tmp132, tmp133.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp105 = tmp134 + } else { + } + tmp85 = tmp105 + } + tmp69 = tmp85 + } + tmp60 = tmp69 + } // end let + tmp57 = tmp60 + } else { + var tmp61 any + { // let + // let binding "seq-" + tmp62 := checkDerefVar(glojure_DOT_core_gensym) + tmp63 := lang.Apply(tmp62, []any{"seq_"}) + var v64 any = tmp63 + _ = v64 + // let binding "chunk-" + tmp65 := checkDerefVar(glojure_DOT_core_with_meta) + tmp66 := checkDerefVar(glojure_DOT_core_gensym) + tmp67 := lang.Apply(tmp66, []any{"chunk_"}) + tmp68 := lang.NewMap(lang.NewKeyword("tag"), lang.NewSymbol("glojure.lang.IChunk")) + tmp69 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3239), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(3239), lang.NewKeyword("end-column"), int(72)) + tmp70, err := lang.WithMeta(tmp68, tmp69.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp71 := lang.Apply(tmp65, []any{tmp67, tmp70}) + var v72 any = tmp71 + _ = v72 + // let binding "count-" + tmp73 := checkDerefVar(glojure_DOT_core_gensym) + tmp74 := lang.Apply(tmp73, []any{"count_"}) + var v75 any = tmp74 + _ = v75 + // let binding "i-" + tmp76 := checkDerefVar(glojure_DOT_core_gensym) + tmp77 := lang.Apply(tmp76, []any{"i_"}) + var v78 any = tmp77 + _ = v78 + // let binding "recform" + tmp79 := checkDerefVar(glojure_DOT_core_seq) + tmp80 := checkDerefVar(glojure_DOT_core_concat) + tmp81 := checkDerefVar(glojure_DOT_core_list) + tmp82 := lang.Apply(tmp81, []any{lang.NewSymbol("recur")}) + tmp83 := checkDerefVar(glojure_DOT_core_list) + tmp84 := checkDerefVar(glojure_DOT_core_seq) + tmp85 := checkDerefVar(glojure_DOT_core_concat) + tmp86 := checkDerefVar(glojure_DOT_core_list) + tmp87 := lang.Apply(tmp86, []any{lang.NewSymbol("glojure.core/next")}) + tmp88 := checkDerefVar(glojure_DOT_core_list) + tmp89 := lang.Apply(tmp88, []any{v64}) + tmp90 := lang.Apply(tmp85, []any{tmp87, tmp89}) + tmp91 := lang.Apply(tmp84, []any{tmp90}) + tmp92 := lang.Apply(tmp83, []any{tmp91}) + tmp93 := checkDerefVar(glojure_DOT_core_list) + tmp94 := lang.Apply(tmp93, []any{nil}) + tmp95 := checkDerefVar(glojure_DOT_core_list) + tmp96 := lang.Apply(tmp95, []any{int64(0)}) + tmp97 := checkDerefVar(glojure_DOT_core_list) + tmp98 := lang.Apply(tmp97, []any{int64(0)}) + tmp99 := lang.Apply(tmp80, []any{tmp82, tmp92, tmp94, tmp96, tmp98}) + tmp100 := lang.Apply(tmp79, []any{tmp99}) + var v101 any = tmp100 + _ = v101 + // let binding "steppair" + tmp102 := checkDerefVar(glojure_DOT_core_nnext) + tmp103 := lang.Apply(tmp102, []any{v37}) + tmp104 := lang.Apply(v35, []any{v101, tmp103}) + var v105 any = tmp104 + _ = v105 + // let binding "needrec" + tmp106 := lang.Apply(v105, []any{int64(0)}) + var v107 any = tmp106 + _ = v107 + // let binding "subform" + tmp108 := lang.Apply(v105, []any{int64(1)}) + var v109 any = tmp108 + _ = v109 + // let binding "recform-chunk" + tmp110 := checkDerefVar(glojure_DOT_core_seq) + tmp111 := checkDerefVar(glojure_DOT_core_concat) + tmp112 := checkDerefVar(glojure_DOT_core_list) + tmp113 := lang.Apply(tmp112, []any{lang.NewSymbol("recur")}) + tmp114 := checkDerefVar(glojure_DOT_core_list) + tmp115 := lang.Apply(tmp114, []any{v64}) + tmp116 := checkDerefVar(glojure_DOT_core_list) + tmp117 := lang.Apply(tmp116, []any{v72}) + tmp118 := checkDerefVar(glojure_DOT_core_list) + tmp119 := lang.Apply(tmp118, []any{v75}) + tmp120 := checkDerefVar(glojure_DOT_core_list) + tmp121 := checkDerefVar(glojure_DOT_core_seq) + tmp122 := checkDerefVar(glojure_DOT_core_concat) + tmp123 := checkDerefVar(glojure_DOT_core_list) + tmp124 := lang.Apply(tmp123, []any{lang.NewSymbol("glojure.core/unchecked-inc")}) + tmp125 := checkDerefVar(glojure_DOT_core_list) + tmp126 := lang.Apply(tmp125, []any{v78}) + tmp127 := lang.Apply(tmp122, []any{tmp124, tmp126}) + tmp128 := lang.Apply(tmp121, []any{tmp127}) + tmp129 := lang.Apply(tmp120, []any{tmp128}) + tmp130 := lang.Apply(tmp111, []any{tmp113, tmp115, tmp117, tmp119, tmp129}) + tmp131 := lang.Apply(tmp110, []any{tmp130}) + var v132 any = tmp131 + _ = v132 + // let binding "steppair-chunk" + tmp133 := checkDerefVar(glojure_DOT_core_nnext) + tmp134 := lang.Apply(tmp133, []any{v37}) + tmp135 := lang.Apply(v35, []any{v132, tmp134}) + var v136 any = tmp135 + _ = v136 + // let binding "subform-chunk" + tmp137 := lang.Apply(v136, []any{int64(1)}) + var v138 any = tmp137 + _ = v138 + tmp139 := checkDerefVar(glojure_DOT_core_seq) + tmp140 := checkDerefVar(glojure_DOT_core_concat) + tmp141 := checkDerefVar(glojure_DOT_core_list) + tmp142 := lang.Apply(tmp141, []any{lang.NewSymbol("glojure.core/loop")}) + tmp143 := checkDerefVar(glojure_DOT_core_list) + tmp144 := checkDerefVar(glojure_DOT_core_apply) + tmp145 := checkDerefVar(glojure_DOT_core_vector) + tmp146 := checkDerefVar(glojure_DOT_core_seq) + tmp147 := checkDerefVar(glojure_DOT_core_concat) + tmp148 := checkDerefVar(glojure_DOT_core_list) + tmp149 := lang.Apply(tmp148, []any{v64}) + tmp150 := checkDerefVar(glojure_DOT_core_list) + tmp151 := checkDerefVar(glojure_DOT_core_seq) + tmp152 := checkDerefVar(glojure_DOT_core_concat) + tmp153 := checkDerefVar(glojure_DOT_core_list) + tmp154 := lang.Apply(tmp153, []any{lang.NewSymbol("glojure.core/seq")}) + tmp155 := checkDerefVar(glojure_DOT_core_list) + tmp156 := lang.Apply(tmp155, []any{v56}) + tmp157 := lang.Apply(tmp152, []any{tmp154, tmp156}) + tmp158 := lang.Apply(tmp151, []any{tmp157}) + tmp159 := lang.Apply(tmp150, []any{tmp158}) + tmp160 := checkDerefVar(glojure_DOT_core_list) + tmp161 := lang.Apply(tmp160, []any{v72}) + tmp162 := checkDerefVar(glojure_DOT_core_list) + tmp163 := lang.Apply(tmp162, []any{nil}) + tmp164 := checkDerefVar(glojure_DOT_core_list) + tmp165 := lang.Apply(tmp164, []any{v75}) + tmp166 := checkDerefVar(glojure_DOT_core_list) + tmp167 := lang.Apply(tmp166, []any{int64(0)}) + tmp168 := checkDerefVar(glojure_DOT_core_list) + tmp169 := lang.Apply(tmp168, []any{v78}) + tmp170 := checkDerefVar(glojure_DOT_core_list) + tmp171 := lang.Apply(tmp170, []any{int64(0)}) + tmp172 := lang.Apply(tmp147, []any{tmp149, tmp159, tmp161, tmp163, tmp165, tmp167, tmp169, tmp171}) + tmp173 := lang.Apply(tmp146, []any{tmp172}) + tmp174 := lang.Apply(tmp144, []any{tmp145, tmp173}) + tmp175 := lang.Apply(tmp143, []any{tmp174}) + tmp176 := checkDerefVar(glojure_DOT_core_list) + tmp177 := checkDerefVar(glojure_DOT_core_seq) + tmp178 := checkDerefVar(glojure_DOT_core_concat) + tmp179 := checkDerefVar(glojure_DOT_core_list) + tmp180 := lang.Apply(tmp179, []any{lang.NewSymbol("if")}) + tmp181 := checkDerefVar(glojure_DOT_core_list) + tmp182 := checkDerefVar(glojure_DOT_core_seq) + tmp183 := checkDerefVar(glojure_DOT_core_concat) + tmp184 := checkDerefVar(glojure_DOT_core_list) + tmp185 := lang.Apply(tmp184, []any{lang.NewSymbol("glojure.core/<")}) + tmp186 := checkDerefVar(glojure_DOT_core_list) + tmp187 := lang.Apply(tmp186, []any{v78}) + tmp188 := checkDerefVar(glojure_DOT_core_list) + tmp189 := lang.Apply(tmp188, []any{v75}) + tmp190 := lang.Apply(tmp183, []any{tmp185, tmp187, tmp189}) + tmp191 := lang.Apply(tmp182, []any{tmp190}) + tmp192 := lang.Apply(tmp181, []any{tmp191}) + tmp193 := checkDerefVar(glojure_DOT_core_list) + tmp194 := checkDerefVar(glojure_DOT_core_seq) + tmp195 := checkDerefVar(glojure_DOT_core_concat) + tmp196 := checkDerefVar(glojure_DOT_core_list) + tmp197 := lang.Apply(tmp196, []any{lang.NewSymbol("glojure.core/let")}) + tmp198 := checkDerefVar(glojure_DOT_core_list) + tmp199 := checkDerefVar(glojure_DOT_core_apply) + tmp200 := checkDerefVar(glojure_DOT_core_vector) + tmp201 := checkDerefVar(glojure_DOT_core_seq) + tmp202 := checkDerefVar(glojure_DOT_core_concat) + tmp203 := checkDerefVar(glojure_DOT_core_list) + tmp204 := lang.Apply(tmp203, []any{v53}) + tmp205 := checkDerefVar(glojure_DOT_core_list) + tmp206 := checkDerefVar(glojure_DOT_core_seq) + tmp207 := checkDerefVar(glojure_DOT_core_concat) + tmp208 := checkDerefVar(glojure_DOT_core_list) + tmp209 := lang.Apply(tmp208, []any{lang.NewSymbol(".nth")}) + tmp210 := checkDerefVar(glojure_DOT_core_list) + tmp211 := lang.Apply(tmp210, []any{v72}) + tmp212 := checkDerefVar(glojure_DOT_core_list) + tmp213 := lang.Apply(tmp212, []any{v78}) + tmp214 := lang.Apply(tmp207, []any{tmp209, tmp211, tmp213}) + tmp215 := lang.Apply(tmp206, []any{tmp214}) + tmp216 := lang.Apply(tmp205, []any{tmp215}) + tmp217 := lang.Apply(tmp202, []any{tmp204, tmp216}) + tmp218 := lang.Apply(tmp201, []any{tmp217}) + tmp219 := lang.Apply(tmp199, []any{tmp200, tmp218}) + tmp220 := lang.Apply(tmp198, []any{tmp219}) + tmp221 := checkDerefVar(glojure_DOT_core_list) + tmp222 := lang.Apply(tmp221, []any{v138}) + var tmp223 any + if lang.IsTruthy(v107) { + tmp224 := lang.NewVector(v132) + tmp225 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3256), lang.NewKeyword("column"), int(48), lang.NewKeyword("end-line"), int(3256), lang.NewKeyword("end-column"), int(62)) + tmp226, err := lang.WithMeta(tmp224, tmp225.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp223 = tmp226 + } else { + } + tmp227 := lang.Apply(tmp195, []any{tmp197, tmp220, tmp222, tmp223}) + tmp228 := lang.Apply(tmp194, []any{tmp227}) + tmp229 := lang.Apply(tmp193, []any{tmp228}) + tmp230 := checkDerefVar(glojure_DOT_core_list) + tmp231 := checkDerefVar(glojure_DOT_core_seq) + tmp232 := checkDerefVar(glojure_DOT_core_concat) + tmp233 := checkDerefVar(glojure_DOT_core_list) + tmp234 := lang.Apply(tmp233, []any{lang.NewSymbol("glojure.core/when-let")}) + tmp235 := checkDerefVar(glojure_DOT_core_list) + tmp236 := checkDerefVar(glojure_DOT_core_apply) + tmp237 := checkDerefVar(glojure_DOT_core_vector) + tmp238 := checkDerefVar(glojure_DOT_core_seq) + tmp239 := checkDerefVar(glojure_DOT_core_concat) + tmp240 := checkDerefVar(glojure_DOT_core_list) + tmp241 := lang.Apply(tmp240, []any{v64}) + tmp242 := checkDerefVar(glojure_DOT_core_list) + tmp243 := checkDerefVar(glojure_DOT_core_seq) + tmp244 := checkDerefVar(glojure_DOT_core_concat) + tmp245 := checkDerefVar(glojure_DOT_core_list) + tmp246 := lang.Apply(tmp245, []any{lang.NewSymbol("glojure.core/seq")}) + tmp247 := checkDerefVar(glojure_DOT_core_list) + tmp248 := lang.Apply(tmp247, []any{v64}) + tmp249 := lang.Apply(tmp244, []any{tmp246, tmp248}) + tmp250 := lang.Apply(tmp243, []any{tmp249}) + tmp251 := lang.Apply(tmp242, []any{tmp250}) + tmp252 := lang.Apply(tmp239, []any{tmp241, tmp251}) + tmp253 := lang.Apply(tmp238, []any{tmp252}) + tmp254 := lang.Apply(tmp236, []any{tmp237, tmp253}) + tmp255 := lang.Apply(tmp235, []any{tmp254}) + tmp256 := checkDerefVar(glojure_DOT_core_list) + tmp257 := checkDerefVar(glojure_DOT_core_seq) + tmp258 := checkDerefVar(glojure_DOT_core_concat) + tmp259 := checkDerefVar(glojure_DOT_core_list) + tmp260 := lang.Apply(tmp259, []any{lang.NewSymbol("if")}) + tmp261 := checkDerefVar(glojure_DOT_core_list) + tmp262 := checkDerefVar(glojure_DOT_core_seq) + tmp263 := checkDerefVar(glojure_DOT_core_concat) + tmp264 := checkDerefVar(glojure_DOT_core_list) + tmp265 := lang.Apply(tmp264, []any{lang.NewSymbol("glojure.core/chunked-seq?")}) + tmp266 := checkDerefVar(glojure_DOT_core_list) + tmp267 := lang.Apply(tmp266, []any{v64}) + tmp268 := lang.Apply(tmp263, []any{tmp265, tmp267}) + tmp269 := lang.Apply(tmp262, []any{tmp268}) + tmp270 := lang.Apply(tmp261, []any{tmp269}) + tmp271 := checkDerefVar(glojure_DOT_core_list) + tmp272 := checkDerefVar(glojure_DOT_core_seq) + tmp273 := checkDerefVar(glojure_DOT_core_concat) + tmp274 := checkDerefVar(glojure_DOT_core_list) + tmp275 := lang.Apply(tmp274, []any{lang.NewSymbol("glojure.core/let")}) + tmp276 := checkDerefVar(glojure_DOT_core_list) + tmp277 := checkDerefVar(glojure_DOT_core_apply) + tmp278 := checkDerefVar(glojure_DOT_core_vector) + tmp279 := checkDerefVar(glojure_DOT_core_seq) + tmp280 := checkDerefVar(glojure_DOT_core_concat) + tmp281 := checkDerefVar(glojure_DOT_core_list) + tmp282 := lang.Apply(tmp281, []any{lang.NewSymbol("c__0__auto__")}) + tmp283 := checkDerefVar(glojure_DOT_core_list) + tmp284 := checkDerefVar(glojure_DOT_core_seq) + tmp285 := checkDerefVar(glojure_DOT_core_concat) + tmp286 := checkDerefVar(glojure_DOT_core_list) + tmp287 := lang.Apply(tmp286, []any{lang.NewSymbol("glojure.core/chunk-first")}) + tmp288 := checkDerefVar(glojure_DOT_core_list) + tmp289 := lang.Apply(tmp288, []any{v64}) + tmp290 := lang.Apply(tmp285, []any{tmp287, tmp289}) + tmp291 := lang.Apply(tmp284, []any{tmp290}) + tmp292 := lang.Apply(tmp283, []any{tmp291}) + tmp293 := lang.Apply(tmp280, []any{tmp282, tmp292}) + tmp294 := lang.Apply(tmp279, []any{tmp293}) + tmp295 := lang.Apply(tmp277, []any{tmp278, tmp294}) + tmp296 := lang.Apply(tmp276, []any{tmp295}) + tmp297 := checkDerefVar(glojure_DOT_core_list) + tmp298 := checkDerefVar(glojure_DOT_core_seq) + tmp299 := checkDerefVar(glojure_DOT_core_concat) + tmp300 := checkDerefVar(glojure_DOT_core_list) + tmp301 := lang.Apply(tmp300, []any{lang.NewSymbol("recur")}) + tmp302 := checkDerefVar(glojure_DOT_core_list) + tmp303 := checkDerefVar(glojure_DOT_core_seq) + tmp304 := checkDerefVar(glojure_DOT_core_concat) + tmp305 := checkDerefVar(glojure_DOT_core_list) + tmp306 := lang.Apply(tmp305, []any{lang.NewSymbol("glojure.core/chunk-rest")}) + tmp307 := checkDerefVar(glojure_DOT_core_list) + tmp308 := lang.Apply(tmp307, []any{v64}) + tmp309 := lang.Apply(tmp304, []any{tmp306, tmp308}) + tmp310 := lang.Apply(tmp303, []any{tmp309}) + tmp311 := lang.Apply(tmp302, []any{tmp310}) + tmp312 := checkDerefVar(glojure_DOT_core_list) + tmp313 := lang.Apply(tmp312, []any{lang.NewSymbol("c__0__auto__")}) + tmp314 := checkDerefVar(glojure_DOT_core_list) + tmp315 := checkDerefVar(glojure_DOT_core_seq) + tmp316 := checkDerefVar(glojure_DOT_core_concat) + tmp317 := checkDerefVar(glojure_DOT_core_list) + tmp318 := lang.Apply(tmp317, []any{lang.NewSymbol("glojure.core/int")}) + tmp319 := checkDerefVar(glojure_DOT_core_list) + tmp320 := checkDerefVar(glojure_DOT_core_seq) + tmp321 := checkDerefVar(glojure_DOT_core_concat) + tmp322 := checkDerefVar(glojure_DOT_core_list) + tmp323 := lang.Apply(tmp322, []any{lang.NewSymbol("glojure.core/count")}) + tmp324 := checkDerefVar(glojure_DOT_core_list) + tmp325 := lang.Apply(tmp324, []any{lang.NewSymbol("c__0__auto__")}) + tmp326 := lang.Apply(tmp321, []any{tmp323, tmp325}) + tmp327 := lang.Apply(tmp320, []any{tmp326}) + tmp328 := lang.Apply(tmp319, []any{tmp327}) + tmp329 := lang.Apply(tmp316, []any{tmp318, tmp328}) + tmp330 := lang.Apply(tmp315, []any{tmp329}) + tmp331 := lang.Apply(tmp314, []any{tmp330}) + tmp332 := checkDerefVar(glojure_DOT_core_list) + tmp333 := checkDerefVar(glojure_DOT_core_seq) + tmp334 := checkDerefVar(glojure_DOT_core_concat) + tmp335 := checkDerefVar(glojure_DOT_core_list) + tmp336 := lang.Apply(tmp335, []any{lang.NewSymbol("glojure.core/int")}) + tmp337 := checkDerefVar(glojure_DOT_core_list) + tmp338 := lang.Apply(tmp337, []any{int64(0)}) + tmp339 := lang.Apply(tmp334, []any{tmp336, tmp338}) + tmp340 := lang.Apply(tmp333, []any{tmp339}) + tmp341 := lang.Apply(tmp332, []any{tmp340}) + tmp342 := lang.Apply(tmp299, []any{tmp301, tmp311, tmp313, tmp331, tmp341}) + tmp343 := lang.Apply(tmp298, []any{tmp342}) + tmp344 := lang.Apply(tmp297, []any{tmp343}) + tmp345 := lang.Apply(tmp273, []any{tmp275, tmp296, tmp344}) + tmp346 := lang.Apply(tmp272, []any{tmp345}) + tmp347 := lang.Apply(tmp271, []any{tmp346}) + tmp348 := checkDerefVar(glojure_DOT_core_list) + tmp349 := checkDerefVar(glojure_DOT_core_seq) + tmp350 := checkDerefVar(glojure_DOT_core_concat) + tmp351 := checkDerefVar(glojure_DOT_core_list) + tmp352 := lang.Apply(tmp351, []any{lang.NewSymbol("glojure.core/let")}) + tmp353 := checkDerefVar(glojure_DOT_core_list) + tmp354 := checkDerefVar(glojure_DOT_core_apply) + tmp355 := checkDerefVar(glojure_DOT_core_vector) + tmp356 := checkDerefVar(glojure_DOT_core_seq) + tmp357 := checkDerefVar(glojure_DOT_core_concat) + tmp358 := checkDerefVar(glojure_DOT_core_list) + tmp359 := lang.Apply(tmp358, []any{v53}) + tmp360 := checkDerefVar(glojure_DOT_core_list) + tmp361 := checkDerefVar(glojure_DOT_core_seq) + tmp362 := checkDerefVar(glojure_DOT_core_concat) + tmp363 := checkDerefVar(glojure_DOT_core_list) + tmp364 := lang.Apply(tmp363, []any{lang.NewSymbol("glojure.core/first")}) + tmp365 := checkDerefVar(glojure_DOT_core_list) + tmp366 := lang.Apply(tmp365, []any{v64}) + tmp367 := lang.Apply(tmp362, []any{tmp364, tmp366}) + tmp368 := lang.Apply(tmp361, []any{tmp367}) + tmp369 := lang.Apply(tmp360, []any{tmp368}) + tmp370 := lang.Apply(tmp357, []any{tmp359, tmp369}) + tmp371 := lang.Apply(tmp356, []any{tmp370}) + tmp372 := lang.Apply(tmp354, []any{tmp355, tmp371}) + tmp373 := lang.Apply(tmp353, []any{tmp372}) + tmp374 := checkDerefVar(glojure_DOT_core_list) + tmp375 := lang.Apply(tmp374, []any{v109}) + var tmp376 any + if lang.IsTruthy(v107) { + tmp377 := lang.NewVector(v101) + tmp378 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3264), lang.NewKeyword("column"), int(52), lang.NewKeyword("end-line"), int(3264), lang.NewKeyword("end-column"), int(60)) + tmp379, err := lang.WithMeta(tmp377, tmp378.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp376 = tmp379 + } else { + } + tmp380 := lang.Apply(tmp350, []any{tmp352, tmp373, tmp375, tmp376}) + tmp381 := lang.Apply(tmp349, []any{tmp380}) + tmp382 := lang.Apply(tmp348, []any{tmp381}) + tmp383 := lang.Apply(tmp258, []any{tmp260, tmp270, tmp347, tmp382}) + tmp384 := lang.Apply(tmp257, []any{tmp383}) + tmp385 := lang.Apply(tmp256, []any{tmp384}) + tmp386 := lang.Apply(tmp232, []any{tmp234, tmp255, tmp385}) + tmp387 := lang.Apply(tmp231, []any{tmp386}) + tmp388 := lang.Apply(tmp230, []any{tmp387}) + tmp389 := lang.Apply(tmp178, []any{tmp180, tmp192, tmp229, tmp388}) + tmp390 := lang.Apply(tmp177, []any{tmp389}) + tmp391 := lang.Apply(tmp176, []any{tmp390}) + tmp392 := lang.Apply(tmp140, []any{tmp142, tmp175, tmp391}) + tmp393 := lang.Apply(tmp139, []any{tmp392}) + tmp394 := lang.NewVector(true, tmp393) + tmp395 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3250), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(3264), lang.NewKeyword("end-column"), int(67)) + tmp396, err := lang.WithMeta(tmp394, tmp395.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp61 = tmp396 + } // end let + tmp57 = tmp61 + } + tmp50 = tmp57 + } // end let + tmp38 = tmp50 + } + return tmp38 + }) + v35 = tmp34 + _ = v35 + } + tmp35 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3218), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(3264), lang.NewKeyword("end-column"), int(72)) + tmp36, err := lang.WithMeta(tmp34, tmp35.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v37 any = tmp36 + _ = v37 + tmp38 := checkDerefVar(glojure_DOT_core_nth) + tmp39 := checkDerefVar(glojure_DOT_core_seq) + tmp40 := lang.Apply(tmp39, []any{v5}) + tmp41 := lang.Apply(v37, []any{nil, tmp40}) + tmp42 := lang.Apply(tmp38, []any{tmp41, int64(1)}) + tmp33 = tmp42 + } // end let + return tmp33 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // dosync + { + tmp0 := lang.NewSymbol("dosync").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("exprs"))), lang.NewKeyword("doc"), "Runs the exprs (in an implicit do) in a transaction that encompasses\n exprs and any nested calls. Starts a transaction if none is already\n running on this thread. Any uncaught exception will abort the\n transaction and flow out of dosync. The exprs may be run more than\n once, but any effects on Refs will be atomic.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5100), lang.NewKeyword("end-line"), int(5100))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := checkDerefVar(glojure_DOT_core_seq) + tmp7 := checkDerefVar(glojure_DOT_core_concat) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("glojure.core/sync")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{nil}) + tmp12 := lang.Apply(tmp7, []any{tmp9, tmp11, v5}) + tmp13 := lang.Apply(tmp6, []any{tmp12}) + return tmp13 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // dotimes + { + tmp0 := lang.NewSymbol("dotimes").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "bindings => name n\n\n Repeatedly executes body (presumably for side-effects) with name\n bound to integers from 0 through n-1.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3306), lang.NewKeyword("end-line"), int(3306))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any + tmp8 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp9 := lang.Apply(tmp8, []any{v5}) + if lang.IsTruthy(tmp9) { + } else { + tmp10 := checkDerefVar(glojure_DOT_core_str) + tmp11 := checkDerefVar(glojure_DOT_core_first) + tmp12 := lang.Apply(tmp11, []any{v3}) + tmp13 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) + tmp14 := checkDerefVar(glojure_DOT_core_meta) + tmp15 := lang.Apply(tmp14, []any{v3}) + tmp16 := lang.Apply(lang.NewKeyword("line"), []any{tmp15}) + tmp17 := lang.Apply(tmp10, []any{tmp12, " requires ", "a vector for its binding", " in ", tmp13, ":", tmp16}) + tmp18 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp17}) + panic(tmp18) + } + _ = tmp7 + var tmp19 any + tmp20 := checkDerefVar(glojure_DOT_core__EQ_) + tmp21 := checkDerefVar(glojure_DOT_core_count) + tmp22 := lang.Apply(tmp21, []any{v5}) + tmp23 := lang.Apply(tmp20, []any{int64(2), tmp22}) + if lang.IsTruthy(tmp23) { + } else { + tmp24 := checkDerefVar(glojure_DOT_core_str) + tmp25 := checkDerefVar(glojure_DOT_core_first) + tmp26 := lang.Apply(tmp25, []any{v3}) + tmp27 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) + tmp28 := checkDerefVar(glojure_DOT_core_meta) + tmp29 := lang.Apply(tmp28, []any{v3}) + tmp30 := lang.Apply(lang.NewKeyword("line"), []any{tmp29}) + tmp31 := lang.Apply(tmp24, []any{tmp26, " requires ", "exactly 2 forms in binding vector", " in ", tmp27, ":", tmp30}) + tmp32 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp31}) + panic(tmp32) + } + _ = tmp19 + var tmp33 any + { // let + // let binding "i" + tmp34 := checkDerefVar(glojure_DOT_core_first) + tmp35 := lang.Apply(tmp34, []any{v5}) + var v36 any = tmp35 + _ = v36 + // let binding "n" + tmp37 := checkDerefVar(glojure_DOT_core_second) + tmp38 := lang.Apply(tmp37, []any{v5}) + var v39 any = tmp38 + _ = v39 + tmp40 := checkDerefVar(glojure_DOT_core_seq) + tmp41 := checkDerefVar(glojure_DOT_core_concat) + tmp42 := checkDerefVar(glojure_DOT_core_list) + tmp43 := lang.Apply(tmp42, []any{lang.NewSymbol("glojure.core/let")}) + tmp44 := checkDerefVar(glojure_DOT_core_list) + tmp45 := checkDerefVar(glojure_DOT_core_apply) + tmp46 := checkDerefVar(glojure_DOT_core_vector) + tmp47 := checkDerefVar(glojure_DOT_core_seq) + tmp48 := checkDerefVar(glojure_DOT_core_concat) + tmp49 := checkDerefVar(glojure_DOT_core_list) + tmp50 := lang.Apply(tmp49, []any{lang.NewSymbol("n__0__auto__")}) + tmp51 := checkDerefVar(glojure_DOT_core_list) + tmp52 := checkDerefVar(glojure_DOT_core_seq) + tmp53 := checkDerefVar(glojure_DOT_core_concat) + tmp54 := checkDerefVar(glojure_DOT_core_list) + tmp55 := lang.Apply(tmp54, []any{lang.NewSymbol("glojure.core/long")}) + tmp56 := checkDerefVar(glojure_DOT_core_list) + tmp57 := lang.Apply(tmp56, []any{v39}) + tmp58 := lang.Apply(tmp53, []any{tmp55, tmp57}) + tmp59 := lang.Apply(tmp52, []any{tmp58}) + tmp60 := lang.Apply(tmp51, []any{tmp59}) + tmp61 := lang.Apply(tmp48, []any{tmp50, tmp60}) + tmp62 := lang.Apply(tmp47, []any{tmp61}) + tmp63 := lang.Apply(tmp45, []any{tmp46, tmp62}) + tmp64 := lang.Apply(tmp44, []any{tmp63}) + tmp65 := checkDerefVar(glojure_DOT_core_list) + tmp66 := checkDerefVar(glojure_DOT_core_seq) + tmp67 := checkDerefVar(glojure_DOT_core_concat) + tmp68 := checkDerefVar(glojure_DOT_core_list) + tmp69 := lang.Apply(tmp68, []any{lang.NewSymbol("glojure.core/loop")}) + tmp70 := checkDerefVar(glojure_DOT_core_list) + tmp71 := checkDerefVar(glojure_DOT_core_apply) + tmp72 := checkDerefVar(glojure_DOT_core_vector) + tmp73 := checkDerefVar(glojure_DOT_core_seq) + tmp74 := checkDerefVar(glojure_DOT_core_concat) + tmp75 := checkDerefVar(glojure_DOT_core_list) + tmp76 := lang.Apply(tmp75, []any{v36}) + tmp77 := checkDerefVar(glojure_DOT_core_list) + tmp78 := lang.Apply(tmp77, []any{int64(0)}) + tmp79 := lang.Apply(tmp74, []any{tmp76, tmp78}) + tmp80 := lang.Apply(tmp73, []any{tmp79}) + tmp81 := lang.Apply(tmp71, []any{tmp72, tmp80}) + tmp82 := lang.Apply(tmp70, []any{tmp81}) + tmp83 := checkDerefVar(glojure_DOT_core_list) + tmp84 := checkDerefVar(glojure_DOT_core_seq) + tmp85 := checkDerefVar(glojure_DOT_core_concat) + tmp86 := checkDerefVar(glojure_DOT_core_list) + tmp87 := lang.Apply(tmp86, []any{lang.NewSymbol("glojure.core/when")}) + tmp88 := checkDerefVar(glojure_DOT_core_list) + tmp89 := checkDerefVar(glojure_DOT_core_seq) + tmp90 := checkDerefVar(glojure_DOT_core_concat) + tmp91 := checkDerefVar(glojure_DOT_core_list) + tmp92 := lang.Apply(tmp91, []any{lang.NewSymbol("glojure.core/<")}) + tmp93 := checkDerefVar(glojure_DOT_core_list) + tmp94 := lang.Apply(tmp93, []any{v36}) + tmp95 := checkDerefVar(glojure_DOT_core_list) + tmp96 := lang.Apply(tmp95, []any{lang.NewSymbol("n__0__auto__")}) + tmp97 := lang.Apply(tmp90, []any{tmp92, tmp94, tmp96}) + tmp98 := lang.Apply(tmp89, []any{tmp97}) + tmp99 := lang.Apply(tmp88, []any{tmp98}) + tmp100 := checkDerefVar(glojure_DOT_core_list) + tmp101 := checkDerefVar(glojure_DOT_core_seq) + tmp102 := checkDerefVar(glojure_DOT_core_concat) + tmp103 := checkDerefVar(glojure_DOT_core_list) + tmp104 := lang.Apply(tmp103, []any{lang.NewSymbol("recur")}) + tmp105 := checkDerefVar(glojure_DOT_core_list) + tmp106 := checkDerefVar(glojure_DOT_core_seq) + tmp107 := checkDerefVar(glojure_DOT_core_concat) + tmp108 := checkDerefVar(glojure_DOT_core_list) + tmp109 := lang.Apply(tmp108, []any{lang.NewSymbol("glojure.core/unchecked-inc")}) + tmp110 := checkDerefVar(glojure_DOT_core_list) + tmp111 := lang.Apply(tmp110, []any{v36}) + tmp112 := lang.Apply(tmp107, []any{tmp109, tmp111}) + tmp113 := lang.Apply(tmp106, []any{tmp112}) + tmp114 := lang.Apply(tmp105, []any{tmp113}) + tmp115 := lang.Apply(tmp102, []any{tmp104, tmp114}) + tmp116 := lang.Apply(tmp101, []any{tmp115}) + tmp117 := lang.Apply(tmp100, []any{tmp116}) + tmp118 := lang.Apply(tmp85, []any{tmp87, tmp99, v6, tmp117}) + tmp119 := lang.Apply(tmp84, []any{tmp118}) + tmp120 := lang.Apply(tmp83, []any{tmp119}) + tmp121 := lang.Apply(tmp67, []any{tmp69, tmp82, tmp120}) + tmp122 := lang.Apply(tmp66, []any{tmp121}) + tmp123 := lang.Apply(tmp65, []any{tmp122}) + tmp124 := lang.Apply(tmp41, []any{tmp43, tmp64, tmp123}) + tmp125 := lang.Apply(tmp40, []any{tmp124}) + tmp33 = tmp125 + } // end let + return tmp33 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // doto + { + tmp0 := lang.NewSymbol("doto").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "Evaluates x then calls all of the methods and functions with the\n value of x supplied at the front of the given arguments. The forms\n are evaluated in order. Returns x.\n\n (doto (new java.util.HashMap) (.put \"a\" 1) (.put \"b\" 2))", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3853), lang.NewKeyword("end-line"), int(3853))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any + { // let + // let binding "gx" + tmp8 := checkDerefVar(glojure_DOT_core_gensym) + tmp9 := lang.Apply(tmp8, nil) + var v10 any = tmp9 + _ = v10 + tmp11 := checkDerefVar(glojure_DOT_core_seq) + tmp12 := checkDerefVar(glojure_DOT_core_concat) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/let")}) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := checkDerefVar(glojure_DOT_core_apply) + tmp17 := checkDerefVar(glojure_DOT_core_vector) + tmp18 := checkDerefVar(glojure_DOT_core_seq) + tmp19 := checkDerefVar(glojure_DOT_core_concat) + tmp20 := checkDerefVar(glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{v10}) + tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v5}) + tmp24 := lang.Apply(tmp19, []any{tmp21, tmp23}) + tmp25 := lang.Apply(tmp18, []any{tmp24}) + tmp26 := lang.Apply(tmp16, []any{tmp17, tmp25}) + tmp27 := lang.Apply(tmp15, []any{tmp26}) + tmp28 := checkDerefVar(glojure_DOT_core_map) + var tmp29 lang.FnFunc + tmp29 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v30 := args[0] + _ = v30 + tmp31 := checkDerefVar(glojure_DOT_core_with_meta) + var tmp32 any + tmp33 := checkDerefVar(glojure_DOT_core_seq_QMARK_) + tmp34 := lang.Apply(tmp33, []any{v30}) + if lang.IsTruthy(tmp34) { + tmp35 := checkDerefVar(glojure_DOT_core_seq) + tmp36 := checkDerefVar(glojure_DOT_core_concat) + tmp37 := checkDerefVar(glojure_DOT_core_list) + tmp38 := checkDerefVar(glojure_DOT_core_first) + tmp39 := lang.Apply(tmp38, []any{v30}) + tmp40 := lang.Apply(tmp37, []any{tmp39}) + tmp41 := checkDerefVar(glojure_DOT_core_list) + tmp42 := lang.Apply(tmp41, []any{v10}) + tmp43 := checkDerefVar(glojure_DOT_core_next) + tmp44 := lang.Apply(tmp43, []any{v30}) + tmp45 := lang.Apply(tmp36, []any{tmp40, tmp42, tmp44}) + tmp46 := lang.Apply(tmp35, []any{tmp45}) + tmp32 = tmp46 + } else { + tmp47 := checkDerefVar(glojure_DOT_core_seq) + tmp48 := checkDerefVar(glojure_DOT_core_concat) + tmp49 := checkDerefVar(glojure_DOT_core_list) + tmp50 := lang.Apply(tmp49, []any{v30}) + tmp51 := checkDerefVar(glojure_DOT_core_list) + tmp52 := lang.Apply(tmp51, []any{v10}) + tmp53 := lang.Apply(tmp48, []any{tmp50, tmp52}) + tmp54 := lang.Apply(tmp47, []any{tmp53}) + tmp32 = tmp54 + } + tmp55 := checkDerefVar(glojure_DOT_core_meta) + tmp56 := lang.Apply(tmp55, []any{v30}) + tmp57 := lang.Apply(tmp31, []any{tmp32, tmp56}) + return tmp57 + }) + tmp30 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3863), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(3868), lang.NewKeyword("end-column"), int(30)) + tmp31, err := lang.WithMeta(tmp29, tmp30.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp32 := lang.Apply(tmp28, []any{tmp31, v6}) + tmp33 := checkDerefVar(glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{v10}) + tmp35 := lang.Apply(tmp12, []any{tmp14, tmp27, tmp32, tmp34}) + tmp36 := lang.Apply(tmp11, []any{tmp35}) + tmp7 = tmp36 + } // end let + return tmp7 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // double + { + var tmp1 lang.FnFunc + { // function double__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := checkDerefVar(glojure_DOT_core_seq) + tmp12 := checkDerefVar(glojure_DOT_core_concat) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/DoubleCast")}) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("double").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to double", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3493), lang.NewKeyword("end-line"), int(3493))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5 := lang.Apply(lang.AsFloat64, []any{v4}) + return tmp5 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // double-array + { + var tmp1 lang.FnFunc + { // function double-array__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol("glojure.core/DoubleArray")}) + tmp12 := checkDerefVar(glojure_DOT_core_list) + tmp13 := checkDerefVar(glojure_DOT_core_seq) + tmp14 := checkDerefVar(glojure_DOT_core_concat) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("glojure.core/args")}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + } + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("double-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Creates an array of doubles", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5341), lang.NewKeyword("end-line"), int(5341))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "DoubleArray") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("DoubleArray is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "DoubleArrayInit") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("DoubleArrayInit is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // double? + { + tmp0 := lang.NewSymbol("double?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a Double", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1421), lang.NewKeyword("end-line"), int(1421))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp5 := lang.Apply(tmp4, []any{lang.Builtins["float64"], v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // doubles + { + var tmp1 lang.FnFunc + { // function doubles + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol("glojure.core/Doubles")}) + tmp12 := checkDerefVar(glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("doubles").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Casts to double[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5402), lang.NewKeyword("end-line"), int(5402))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Doubles") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Doubles is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // drop + { + tmp0 := lang.NewSymbol("drop").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a laziness-preserving sequence of all but the first n items in coll.\n Returns a stateful transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2901), lang.NewKeyword("end-line"), int(2901))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + var tmp6 any + { // let + // let binding "nv" + tmp7 := checkDerefVar(glojure_DOT_core_volatile_BANG_) + tmp8 := lang.Apply(tmp7, []any{v3}) + var v9 any = tmp8 + _ = v9 + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp11 := lang.Apply(v5, nil) + return tmp11 + case 1: + v11 := args[0] + _ = v11 + tmp12 := lang.Apply(v5, []any{v11}) + return tmp12 + case 2: + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + var tmp13 any + { // let + // let binding "n" + tmp14 := checkDerefVar(glojure_DOT_core_deref) + tmp15 := lang.Apply(tmp14, []any{v9}) + var v16 any = tmp15 + _ = v16 + tmp17 := checkDerefVar(glojure_DOT_core_dec) + tmp18, ok := lang.FieldOrMethod(v9, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v9, "Deref"))) + } + var tmp19 any + switch reflect.TypeOf(tmp18).Kind() { + case reflect.Func: + tmp19 = lang.Apply(tmp18, nil) + default: + tmp19 = tmp18 + } + tmp20 := lang.Apply(tmp17, []any{tmp19}) + tmp21, _ := lang.FieldOrMethod(v9, "reset") + if reflect.TypeOf(tmp21).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) + } + tmp22 := lang.Apply(tmp21, []any{tmp20}) + _ = tmp22 + var tmp23 any + tmp24 := checkDerefVar(glojure_DOT_core_pos_QMARK_) + tmp25 := lang.Apply(tmp24, []any{v16}) + if lang.IsTruthy(tmp25) { + tmp23 = v11 + } else { + tmp26 := lang.Apply(v5, []any{v11, v12}) + tmp23 = tmp26 + } + tmp13 = tmp23 + } // end let + return tmp13 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2909), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(2917), lang.NewKeyword("end-column"), int(39)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp6 = tmp12 + } // end let + return tmp6 + }) + tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2907), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2917), lang.NewKeyword("end-column"), int(41)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp7 := reflect.TypeOf((*lang.IDrop)(nil)).Elem() + tmp8 := lang.Apply(tmp6, []any{tmp7, v4}) + if lang.IsTruthy(tmp8) { + var tmp9 any + { // let + // let binding "or__0__auto__" + var tmp10 any + tmp11 := checkDerefVar(glojure_DOT_core_pos_QMARK_) + tmp12 := lang.Apply(tmp11, []any{v3}) + if lang.IsTruthy(tmp12) { + var tmp13 any + tmp14 := checkDerefVar(glojure_DOT_core_int_QMARK_) + tmp15 := lang.Apply(tmp14, []any{v3}) + if lang.IsTruthy(tmp15) { + tmp13 = v3 + } else { + tmp16 := lang.Apply(nil, []any{v3}) + tmp13 = tmp16 + } + tmp17, _ := lang.FieldOrMethod(v4, "drop") + if reflect.TypeOf(tmp17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("drop is not a function"))) + } + tmp18 := lang.Apply(tmp17, []any{tmp13}) + tmp10 = tmp18 + } else { + tmp19 := checkDerefVar(glojure_DOT_core_seq) + tmp20 := lang.Apply(tmp19, []any{v4}) + tmp10 = tmp20 + } + var v21 any = tmp10 + _ = v21 + var tmp22 any + if lang.IsTruthy(v21) { + tmp22 = v21 + } else { + tmp22 = lang.NewList() + } + tmp9 = tmp22 + } // end let + tmp5 = tmp9 + } else { + var tmp10 any + { // let + // let binding "step" + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v12 := args[0] + _ = v12 + v13 := args[1] + _ = v13 + recur_loop_539: + var tmp14 any + { // let + // let binding "s" + tmp15 := checkDerefVar(glojure_DOT_core_seq) + tmp16 := lang.Apply(tmp15, []any{v13}) + var v17 any = tmp16 + _ = v17 + var tmp18 any + var tmp19 any + { // let + // let binding "and__0__auto__" + tmp20 := checkDerefVar(glojure_DOT_core_pos_QMARK_) + tmp21 := lang.Apply(tmp20, []any{v12}) + var v22 any = tmp21 + _ = v22 + var tmp23 any + if lang.IsTruthy(v22) { + tmp23 = v17 + } else { + tmp23 = v22 + } + tmp19 = tmp23 + } // end let + if lang.IsTruthy(tmp19) { + tmp21 := checkDerefVar(glojure_DOT_core_dec) + tmp22 := lang.Apply(tmp21, []any{v12}) + var tmp20 any = tmp22 + tmp24 := checkDerefVar(glojure_DOT_core_rest) + tmp25 := lang.Apply(tmp24, []any{v17}) + var tmp23 any = tmp25 + v12 = tmp20 + v13 = tmp23 + goto recur_loop_539 + } else { + tmp18 = v17 + } + tmp14 = tmp18 + } // end let + return tmp14 + }) + tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2925), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(2929), lang.NewKeyword("end-column"), int(28)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v14 any = tmp13 + _ = v14 + var tmp15 lang.FnFunc + tmp15 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + tmp16 := lang.Apply(v14, []any{v3, v4}) + return tmp16 + }) + tmp16 := lang.Apply(lang.NewLazySeq, []any{tmp15}) + tmp10 = tmp16 + } // end let + tmp5 = tmp10 + } + return tmp5 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // drop-last + { + tmp0 := lang.NewSymbol("drop-last").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return a lazy sequence of all but the last n (default 1) items in coll", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2932), lang.NewKeyword("end-line"), int(2932))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_drop_last) + tmp5 := lang.Apply(tmp4, []any{int64(1), v3}) + return tmp5 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_map) + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + return v7 + }) + tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2937), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(2937), lang.NewKeyword("end-column"), int(29)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp9 := checkDerefVar(glojure_DOT_core_drop) + tmp10 := lang.Apply(tmp9, []any{v3, v4}) + tmp11 := lang.Apply(tmp5, []any{tmp8, v4, tmp10}) + return tmp11 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // drop-while + { + tmp0 := lang.NewSymbol("drop-while").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred")), lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the items in coll starting from the\n first item for which (pred item) returns logical false. Returns a\n stateful transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2950), lang.NewKeyword("end-line"), int(2950))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + var tmp6 any + { // let + // let binding "dv" + tmp7 := checkDerefVar(glojure_DOT_core_volatile_BANG_) + tmp8 := lang.Apply(tmp7, []any{true}) + var v9 any = tmp8 + _ = v9 + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp11 := lang.Apply(v5, nil) + return tmp11 + case 1: + v11 := args[0] + _ = v11 + tmp12 := lang.Apply(v5, []any{v11}) + return tmp12 + case 2: + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + var tmp13 any + { // let + // let binding "drop?" + tmp14 := checkDerefVar(glojure_DOT_core_deref) + tmp15 := lang.Apply(tmp14, []any{v9}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + var tmp18 any + { // let + // let binding "and__0__auto__" + var v19 any = v16 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + tmp21 := lang.Apply(v3, []any{v12}) + tmp20 = tmp21 + } else { + tmp20 = v19 + } + tmp18 = tmp20 + } // end let + if lang.IsTruthy(tmp18) { + tmp17 = v11 + } else { + tmp19 := checkDerefVar(glojure_DOT_core_vreset_BANG_) + tmp20 := lang.Apply(tmp19, []any{v9, nil}) + _ = tmp20 + tmp21 := lang.Apply(v5, []any{v11, v12}) + tmp17 = tmp21 + } + tmp13 = tmp17 + } // end let + return tmp13 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2959), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(2968), lang.NewKeyword("end-column"), int(42)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp6 = tmp12 + } // end let + return tmp6 + }) + tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2957), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2968), lang.NewKeyword("end-column"), int(44)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 any + { // let + // let binding "step" + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + recur_loop_552: + var tmp9 any + { // let + // let binding "s" + tmp10 := checkDerefVar(glojure_DOT_core_seq) + tmp11 := lang.Apply(tmp10, []any{v8}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + var tmp14 any + { // let + // let binding "and__0__auto__" + var v15 any = v12 + _ = v15 + var tmp16 any + if lang.IsTruthy(v15) { + tmp17 := checkDerefVar(glojure_DOT_core_first) + tmp18 := lang.Apply(tmp17, []any{v12}) + tmp19 := lang.Apply(v7, []any{tmp18}) + tmp16 = tmp19 + } else { + tmp16 = v15 + } + tmp14 = tmp16 + } // end let + if lang.IsTruthy(tmp14) { + var tmp15 any = v7 + tmp17 := checkDerefVar(glojure_DOT_core_rest) + tmp18 := lang.Apply(tmp17, []any{v12}) + var tmp16 any = tmp18 + v7 = tmp15 + v8 = tmp16 + goto recur_loop_552 + } else { + tmp13 = v12 + } + tmp9 = tmp13 + } // end let + return tmp9 + }) + tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2970), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(2974), lang.NewKeyword("end-column"), int(26)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v9 any = tmp8 + _ = v9 + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + tmp11 := lang.Apply(v9, []any{v3, v4}) + return tmp11 + }) + tmp11 := lang.Apply(lang.NewLazySeq, []any{tmp10}) + tmp5 = tmp11 + } // end let + return tmp5 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // elide-top-frames + { + tmp0 := lang.NewSymbol("elide-top-frames").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4794), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(4794), lang.NewKeyword("end-column"), int(32), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ex"), lang.NewSymbol("class-name"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 any + { // let + // let binding "tr" + tmp6, ok := lang.FieldOrMethod(v3, "getStackTrace") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getStackTrace"))) + } + var tmp7 any + switch reflect.TypeOf(tmp6).Kind() { + case reflect.Func: + tmp7 = lang.Apply(tmp6, nil) + default: + tmp7 = tmp6 + } + var v8 any = tmp7 + _ = v8 + var tmp9 any + { // let + // let binding "G__54" + var v10 any = v3 + _ = v10 + var tmp11 any + if lang.IsTruthy(v8) { + tmp12 := checkDerefVar(glojure_DOT_core_into_array) + tmp13 := checkDerefVar(glojure_DOT_core_drop_while) + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v15 := args[0] + _ = v15 + tmp16 := checkDerefVar(glojure_DOT_core__EQ_) + tmp17, ok := lang.FieldOrMethod(v15, "getClassName") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v15, "getClassName"))) + } + var tmp18 any + switch reflect.TypeOf(tmp17).Kind() { + case reflect.Func: + tmp18 = lang.Apply(tmp17, nil) + default: + tmp18 = tmp17 + } + tmp19 := lang.Apply(tmp16, []any{v4, tmp18}) + return tmp19 + }) + tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4801), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(4801), lang.NewKeyword("end-column"), int(77)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp17 := lang.Apply(tmp13, []any{tmp16, v8}) + tmp18 := lang.Apply(tmp12, []any{nil, tmp17}) + tmp11 = tmp18 + } else { + } + tmp19, _ := lang.FieldOrMethod(v10, "setStackTrace") + if reflect.TypeOf(tmp19).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setStackTrace is not a function"))) + } + tmp20 := lang.Apply(tmp19, []any{tmp11}) + _ = tmp20 + tmp9 = v10 + } // end let + tmp5 = tmp9 + } // end let + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // emit-extend-protocol + { + tmp0 := lang.NewSymbol("emit-extend-protocol").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(205), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(205), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("p"), lang.NewSymbol("specs"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 any + { // let + // let binding "impls" + tmp6 := checkDerefVar(glojure_DOT_core_parse_impls) + tmp7 := lang.Apply(tmp6, []any{v4}) + var v8 any = tmp7 + _ = v8 + tmp9 := checkDerefVar(glojure_DOT_core_seq) + tmp10 := checkDerefVar(glojure_DOT_core_concat) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{lang.NewSymbol("do")}) + tmp13 := checkDerefVar(glojure_DOT_core_map) + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v15 := args[0] + _ = v15 + var tmp16 any + { // let + // let binding "vec__292" + var v17 any = v15 + _ = v17 + // let binding "t" + tmp18 := checkDerefVar(glojure_DOT_core_nth) + tmp19 := lang.Apply(tmp18, []any{v17, int64(0), nil}) + var v20 any = tmp19 + _ = v20 + // let binding "fs" + tmp21 := checkDerefVar(glojure_DOT_core_nth) + tmp22 := lang.Apply(tmp21, []any{v17, int64(1), nil}) + var v23 any = tmp22 + _ = v23 + tmp24 := checkDerefVar(glojure_DOT_core_seq) + tmp25 := checkDerefVar(glojure_DOT_core_concat) + tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{lang.NewSymbol("glojure.core/extend-type")}) + tmp28 := checkDerefVar(glojure_DOT_core_list) + tmp29 := lang.Apply(tmp28, []any{v20}) + tmp30 := checkDerefVar(glojure_DOT_core_list) + tmp31 := lang.Apply(tmp30, []any{v3}) + tmp32 := lang.Apply(tmp25, []any{tmp27, tmp29, tmp31, v23}) + tmp33 := lang.Apply(tmp24, []any{tmp32}) + tmp16 = tmp33 + } // end let + return tmp16 + }) + tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(208), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(209), lang.NewKeyword("end-column"), int(42)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp17 := lang.Apply(tmp13, []any{tmp16, v8}) + tmp18 := lang.Apply(tmp10, []any{tmp12, tmp17}) + tmp19 := lang.Apply(tmp9, []any{tmp18}) + tmp5 = tmp19 + } // end let + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // emit-extend-type + { + tmp0 := lang.NewSymbol("emit-extend-type").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(175), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(175), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"), lang.NewSymbol("specs"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 any + { // let + // let binding "impls" + tmp6 := checkDerefVar(glojure_DOT_core_parse_impls) + tmp7 := lang.Apply(tmp6, []any{v4}) + var v8 any = tmp7 + _ = v8 + tmp9 := checkDerefVar(glojure_DOT_core_seq) + tmp10 := checkDerefVar(glojure_DOT_core_concat) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{lang.NewSymbol("glojure.core/extend")}) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{v3}) + tmp15 := checkDerefVar(glojure_DOT_core_mapcat) + tmp16 := checkDerefVar(glojure_DOT_core_partial) + tmp17 := checkDerefVar(glojure_DOT_core_emit_hinted_impl) + tmp18 := lang.Apply(tmp16, []any{tmp17, v3}) + tmp19 := lang.Apply(tmp15, []any{tmp18, v8}) + tmp20 := lang.Apply(tmp10, []any{tmp12, tmp14, tmp19}) + tmp21 := lang.Apply(tmp9, []any{tmp20}) + tmp5 = tmp21 + } // end let + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // emit-hinted-impl + { + tmp0 := lang.NewSymbol("emit-hinted-impl").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(163), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(163), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"), lang.NewVector(lang.NewSymbol("p"), lang.NewSymbol("fs")))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 any + { // let + // let binding "vec__281" + var v6 any = v4 + _ = v6 + // let binding "p" + tmp7 := checkDerefVar(glojure_DOT_core_nth) + tmp8 := lang.Apply(tmp7, []any{v6, int64(0), nil}) + var v9 any = tmp8 + _ = v9 + // let binding "fs" + tmp10 := checkDerefVar(glojure_DOT_core_nth) + tmp11 := lang.Apply(tmp10, []any{v6, int64(1), nil}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + { // let + // let binding "hint" + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v15 := args[0] + _ = v15 + var tmp16 any + { // let + // let binding "specs" + var tmp17 any + tmp18 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp19 := checkDerefVar(glojure_DOT_core_first) + tmp20 := lang.Apply(tmp19, []any{v15}) + tmp21 := lang.Apply(tmp18, []any{tmp20}) + if lang.IsTruthy(tmp21) { + tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v15}) + tmp17 = tmp23 + } else { + tmp17 = v15 + } + var v24 any = tmp17 + _ = v24 + tmp25 := checkDerefVar(glojure_DOT_core_map) + var tmp26 lang.FnFunc + tmp26 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v27 := args[0] + _ = v27 + var tmp28 any + { // let + // let binding "vec__285" + var v29 any = v27 + _ = v29 + // let binding "seq__286" + tmp30 := checkDerefVar(glojure_DOT_core_seq) + tmp31 := lang.Apply(tmp30, []any{v29}) + var v32 any = tmp31 + _ = v32 + // let binding "first__287" + tmp33 := checkDerefVar(glojure_DOT_core_first) + tmp34 := lang.Apply(tmp33, []any{v32}) + var v35 any = tmp34 + _ = v35 + // let binding "seq__286" + tmp36 := checkDerefVar(glojure_DOT_core_next) + tmp37 := lang.Apply(tmp36, []any{v32}) + var v38 any = tmp37 + _ = v38 + // let binding "vec__288" + var v39 any = v35 + _ = v39 + // let binding "seq__289" + tmp40 := checkDerefVar(glojure_DOT_core_seq) + tmp41 := lang.Apply(tmp40, []any{v39}) + var v42 any = tmp41 + _ = v42 + // let binding "first__290" + tmp43 := checkDerefVar(glojure_DOT_core_first) + tmp44 := lang.Apply(tmp43, []any{v42}) + var v45 any = tmp44 + _ = v45 + // let binding "seq__289" + tmp46 := checkDerefVar(glojure_DOT_core_next) + tmp47 := lang.Apply(tmp46, []any{v42}) + var v48 any = tmp47 + _ = v48 + // let binding "target" + var v49 any = v45 + _ = v49 + // let binding "args" + var v50 any = v48 + _ = v50 + // let binding "body" + var v51 any = v38 + _ = v51 + tmp52 := checkDerefVar(glojure_DOT_core_cons) + tmp53 := checkDerefVar(glojure_DOT_core_apply) + tmp54 := checkDerefVar(glojure_DOT_core_vector) + tmp55 := checkDerefVar(glojure_DOT_core_vary_meta) + tmp56 := checkDerefVar(glojure_DOT_core_assoc) + tmp57 := lang.Apply(tmp55, []any{v49, tmp56, lang.NewKeyword("tag"), v3}) + tmp58 := lang.Apply(tmp53, []any{tmp54, tmp57, v50}) + tmp59 := lang.Apply(tmp52, []any{tmp58, v51}) + tmp28 = tmp59 + } // end let + return tmp28 + }) + tmp27 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(168), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(170), lang.NewKeyword("end-column"), int(36)) + tmp28, err := lang.WithMeta(tmp26, tmp27.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp29 := lang.Apply(tmp25, []any{tmp28, v24}) + tmp16 = tmp29 + } // end let + return tmp16 + }) + tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(164), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(171), lang.NewKeyword("end-column"), int(30)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v17 any = tmp16 + _ = v17 + tmp18 := checkDerefVar(glojure_DOT_core_zipmap) + tmp19 := checkDerefVar(glojure_DOT_core_map) + var tmp20 lang.FnFunc + tmp20 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v21 := args[0] + _ = v21 + tmp22 := checkDerefVar(glojure_DOT_core_keyword) + tmp23 := checkDerefVar(glojure_DOT_core_name) + tmp24 := checkDerefVar(glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v21}) + tmp26 := lang.Apply(tmp23, []any{tmp25}) + tmp27 := lang.Apply(tmp22, []any{tmp26}) + return tmp27 + }) + tmp21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(172), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(172), lang.NewKeyword("end-column"), int(46)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp23 := lang.Apply(tmp19, []any{tmp22, v12}) + tmp24 := checkDerefVar(glojure_DOT_core_map) + var tmp25 lang.FnFunc + tmp25 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v26 := args[0] + _ = v26 + tmp27 := checkDerefVar(glojure_DOT_core_cons) + tmp28 := checkDerefVar(glojure_DOT_core_drop) + tmp29 := lang.Apply(tmp28, []any{int64(1), v26}) + tmp30 := lang.Apply(v17, []any{tmp29}) + tmp31 := lang.Apply(tmp27, []any{lang.NewSymbol("glojure.core/fn"), tmp30}) + return tmp31 + }) + tmp26 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(173), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(173), lang.NewKeyword("end-column"), int(49)) + tmp27, err := lang.WithMeta(tmp25, tmp26.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp28 := lang.Apply(tmp24, []any{tmp27, v12}) + tmp29 := lang.Apply(tmp18, []any{tmp23, tmp28}) + tmp30 := lang.NewVector(v9, tmp29) + tmp31 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(172), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(173), lang.NewKeyword("end-column"), int(55)) + tmp32, err := lang.WithMeta(tmp30, tmp31.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 = tmp32 + } // end let + tmp5 = tmp13 + } // end let + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // empty + { + tmp0 := lang.NewSymbol("empty").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns an empty collection of the same category as coll, or nil", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5265), lang.NewKeyword("end-line"), int(5265))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp6 := reflect.TypeOf((*lang.IPersistentCollection)(nil)).Elem() + tmp7 := lang.Apply(tmp5, []any{tmp6, v3}) + if lang.IsTruthy(tmp7) { + tmp8, ok := lang.FieldOrMethod(v3, "empty") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "empty"))) + } + var tmp9 any + switch reflect.TypeOf(tmp8).Kind() { + case reflect.Func: + tmp9 = lang.Apply(tmp8, nil) + default: + tmp9 = tmp8 + } + tmp4 = tmp9 + } else { + } + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // empty? + { + tmp0 := lang.NewSymbol("empty?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll has no items. To check the emptiness of a seq,\n please use the idiom (seq x) rather than (not (empty? x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6247), lang.NewKeyword("end-line"), int(6247))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(glojure_DOT_core_counted_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + tmp7 := checkDerefVar(glojure_DOT_core_zero_QMARK_) + tmp8 := checkDerefVar(glojure_DOT_core_count) + tmp9 := lang.Apply(tmp8, []any{v3}) + tmp10 := lang.Apply(tmp7, []any{tmp9}) + tmp4 = tmp10 + } else { + tmp11 := checkDerefVar(glojure_DOT_core_not) + tmp12 := checkDerefVar(glojure_DOT_core_seq) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(tmp11, []any{tmp13}) + tmp4 = tmp14 + } + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ensure + { + tmp0 := lang.NewSymbol("ensure").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref"))), lang.NewKeyword("doc"), "Must be called in a transaction. Protects the ref from modification\n by other transactions. Returns the in-transaction-value of\n ref. Allows for more concurrency than (ref-set ref @ref)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2480), lang.NewKeyword("end-line"), int(2480))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v3, "touch") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("touch is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{}) + _ = tmp5 + tmp6, _ := lang.FieldOrMethod(v3, "deref") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("deref is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{}) + return tmp7 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ensure-reduced + { + tmp0 := lang.NewSymbol("ensure-reduced").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "If x is already reduced?, returns it, else returns (reduced x)", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2841), lang.NewKeyword("end-line"), int(2841))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(glojure_DOT_core_reduced_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + tmp4 = v3 + } else { + tmp7 := checkDerefVar(glojure_DOT_core_reduced) + tmp8 := lang.Apply(tmp7, []any{v3}) + tmp4 = tmp8 + } + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // enumeration-seq + { + tmp0 := lang.NewSymbol("enumeration-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("e"))), lang.NewKeyword("doc"), "Returns a seq on a java.util.Enumeration", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5710), lang.NewKeyword("end-line"), int(5710))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(nil, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // error-handler + { + tmp0 := lang.NewSymbol("error-handler").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("doc"), "Returns the error-handler of agent a, or nil if there is none.\n See set-error-handler!", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2202), lang.NewKeyword("end-line"), int(2202))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4, ok := lang.FieldOrMethod(v3, "getErrorHandler") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getErrorHandler"))) + } + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { + case reflect.Func: + tmp5 = lang.Apply(tmp4, nil) + default: + tmp5 = tmp4 + } + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // error-mode + { + tmp0 := lang.NewSymbol("error-mode").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("doc"), "Returns the error-mode of agent a. See set-error-mode!", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2227), lang.NewKeyword("end-line"), int(2227))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4, ok := lang.FieldOrMethod(v3, "getErrorMode") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getErrorMode"))) + } + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { + case reflect.Func: + tmp5 = lang.Apply(tmp4, nil) + default: + tmp5 = tmp4 + } + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // eval + { + tmp0 := lang.NewSymbol("eval").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("form"))), lang.NewKeyword("doc"), "Evaluates the form data structure (not text!) and returns the result.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3203), lang.NewKeyword("end-line"), int(3203))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(runtime7.Compiler, "Eval") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Eval is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // even? + { + tmp0 := lang.NewSymbol("even?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is even, throws an exception if n is not an integer", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1381), lang.NewKeyword("end-line"), int(1381))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(glojure_DOT_core_integer_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + tmp7 := checkDerefVar(glojure_DOT_core_zero_QMARK_) + tmp8 := checkDerefVar(glojure_DOT_core_bit_and) + tmp9 := lang.Apply(lang.UncheckedLongCast, []any{v3}) + tmp10 := lang.Apply(tmp8, []any{tmp9, int64(1)}) + tmp11 := lang.Apply(tmp7, []any{tmp10}) + tmp4 = tmp11 + } else { + tmp12 := checkDerefVar(glojure_DOT_core_str) + tmp13 := lang.Apply(tmp12, []any{"Argument must be an integer: ", v3}) + tmp14 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp13}) + panic(tmp14) + } + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // every-pred + { + tmp0 := lang.NewSymbol("every-pred").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("p")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2"), lang.NewSymbol("p3")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2"), lang.NewSymbol("p3"), lang.NewSymbol("&"), lang.NewSymbol("ps"))), lang.NewKeyword("doc"), "Takes a set of predicates and returns a function f that returns true if all of its\n composing predicates return a logical true value against all of its arguments, else it returns\n false. Note that f is short-circuiting in that it will stop execution on the first\n argument that triggers a logical false result against the original predicates.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7422), lang.NewKeyword("end-line"), int(7422))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + var tmp4 lang.FnFunc + { // function ep1 + var v5 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return true + case 1: + v6 := args[0] + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_boolean) + tmp8 := lang.Apply(v3, []any{v6}) + tmp9 := lang.Apply(tmp7, []any{tmp8}) + return tmp9 + case 2: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + tmp8 := checkDerefVar(glojure_DOT_core_boolean) + var tmp9 any + { // let + // let binding "and__0__auto__" + tmp10 := lang.Apply(v3, []any{v6}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + tmp13 := lang.Apply(v3, []any{v7}) + tmp12 = tmp13 + } else { + tmp12 = v11 + } + tmp9 = tmp12 + } // end let + tmp10 := lang.Apply(tmp8, []any{tmp9}) + return tmp10 + case 3: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + tmp9 := checkDerefVar(glojure_DOT_core_boolean) + var tmp10 any + { // let + // let binding "and__0__auto__" + tmp11 := lang.Apply(v3, []any{v6}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + var tmp14 any + { // let + // let binding "and__0__auto__" + tmp15 := lang.Apply(v3, []any{v7}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + if lang.IsTruthy(v16) { + tmp18 := lang.Apply(v3, []any{v8}) + tmp17 = tmp18 + } else { + tmp17 = v16 + } + tmp14 = tmp17 + } // end let + tmp13 = tmp14 + } else { + tmp13 = v12 + } + tmp10 = tmp13 + } // end let + tmp11 := lang.Apply(tmp9, []any{tmp10}) + return tmp11 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + var v9 any = lang.NewList(args[3:]...) + _ = v9 + tmp10 := checkDerefVar(glojure_DOT_core_boolean) + var tmp11 any + { // let + // let binding "and__0__auto__" + tmp12 := lang.Apply(v5, []any{v6, v7, v8}) + var v13 any = tmp12 + _ = v13 + var tmp14 any + if lang.IsTruthy(v13) { + tmp15 := checkDerefVar(glojure_DOT_core_every_QMARK_) + tmp16 := lang.Apply(tmp15, []any{v3, v9}) + tmp14 = tmp16 + } else { + tmp14 = v13 + } + tmp11 = tmp14 + } // end let + tmp12 := lang.Apply(tmp10, []any{tmp11}) + return tmp12 + } + }) + v5 = tmp4 + _ = v5 + } + tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7429), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7435), lang.NewKeyword("end-column"), int(56)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 lang.FnFunc + { // function ep2 + var v6 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return true + case 1: + v7 := args[0] + _ = v7 + tmp8 := checkDerefVar(glojure_DOT_core_boolean) + var tmp9 any + { // let + // let binding "and__0__auto__" + tmp10 := lang.Apply(v3, []any{v7}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + tmp13 := lang.Apply(v4, []any{v7}) + tmp12 = tmp13 + } else { + tmp12 = v11 + } + tmp9 = tmp12 + } // end let + tmp10 := lang.Apply(tmp8, []any{tmp9}) + return tmp10 + case 2: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + tmp9 := checkDerefVar(glojure_DOT_core_boolean) + var tmp10 any + { // let + // let binding "and__0__auto__" + tmp11 := lang.Apply(v3, []any{v7}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + var tmp14 any + { // let + // let binding "and__0__auto__" + tmp15 := lang.Apply(v3, []any{v8}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + if lang.IsTruthy(v16) { + var tmp18 any + { // let + // let binding "and__0__auto__" + tmp19 := lang.Apply(v4, []any{v7}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + tmp22 := lang.Apply(v4, []any{v8}) + tmp21 = tmp22 + } else { + tmp21 = v20 + } + tmp18 = tmp21 + } // end let + tmp17 = tmp18 + } else { + tmp17 = v16 + } + tmp14 = tmp17 + } // end let + tmp13 = tmp14 + } else { + tmp13 = v12 + } + tmp10 = tmp13 + } // end let + tmp11 := lang.Apply(tmp9, []any{tmp10}) + return tmp11 + case 3: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + tmp10 := checkDerefVar(glojure_DOT_core_boolean) + var tmp11 any + { // let + // let binding "and__0__auto__" + tmp12 := lang.Apply(v3, []any{v7}) + var v13 any = tmp12 + _ = v13 + var tmp14 any + if lang.IsTruthy(v13) { + var tmp15 any + { // let + // let binding "and__0__auto__" + tmp16 := lang.Apply(v3, []any{v8}) + var v17 any = tmp16 + _ = v17 + var tmp18 any + if lang.IsTruthy(v17) { + var tmp19 any + { // let + // let binding "and__0__auto__" + tmp20 := lang.Apply(v3, []any{v9}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + if lang.IsTruthy(v21) { + var tmp23 any + { // let + // let binding "and__0__auto__" + tmp24 := lang.Apply(v4, []any{v7}) + var v25 any = tmp24 + _ = v25 + var tmp26 any + if lang.IsTruthy(v25) { + var tmp27 any + { // let + // let binding "and__0__auto__" + tmp28 := lang.Apply(v4, []any{v8}) + var v29 any = tmp28 + _ = v29 + var tmp30 any + if lang.IsTruthy(v29) { + tmp31 := lang.Apply(v4, []any{v9}) + tmp30 = tmp31 + } else { + tmp30 = v29 + } + tmp27 = tmp30 + } // end let + tmp26 = tmp27 + } else { + tmp26 = v25 + } + tmp23 = tmp26 + } // end let + tmp22 = tmp23 + } else { + tmp22 = v21 + } + tmp19 = tmp22 + } // end let + tmp18 = tmp19 + } else { + tmp18 = v17 + } + tmp15 = tmp18 + } // end let + tmp14 = tmp15 + } else { + tmp14 = v13 + } + tmp11 = tmp14 + } // end let + tmp12 := lang.Apply(tmp10, []any{tmp11}) + return tmp12 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + var v10 any = lang.NewList(args[3:]...) + _ = v10 + tmp11 := checkDerefVar(glojure_DOT_core_boolean) + var tmp12 any + { // let + // let binding "and__0__auto__" + tmp13 := lang.Apply(v6, []any{v7, v8, v9}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + tmp16 := checkDerefVar(glojure_DOT_core_every_QMARK_) + var tmp17 lang.FnFunc + tmp17 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v18 := args[0] + _ = v18 + var tmp19 any + { // let + // let binding "and__0__auto__" + tmp20 := lang.Apply(v3, []any{v18}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + if lang.IsTruthy(v21) { + tmp23 := lang.Apply(v4, []any{v18}) + tmp22 = tmp23 + } else { + tmp22 = v21 + } + tmp19 = tmp22 + } // end let + return tmp19 + }) + tmp18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7443), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(7443), lang.NewKeyword("end-column"), int(65)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp20 := lang.Apply(tmp16, []any{tmp19, v10}) + tmp15 = tmp20 + } else { + tmp15 = v14 + } + tmp12 = tmp15 + } // end let + tmp13 := lang.Apply(tmp11, []any{tmp12}) + return tmp13 + } + }) + v6 = tmp5 + _ = v6 + } + tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7437), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7443), lang.NewKeyword("end-column"), int(75)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp7 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var tmp6 lang.FnFunc + { // function ep3 + var v7 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return true + case 1: + v8 := args[0] + _ = v8 + tmp9 := checkDerefVar(glojure_DOT_core_boolean) + var tmp10 any + { // let + // let binding "and__0__auto__" + tmp11 := lang.Apply(v3, []any{v8}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + var tmp14 any + { // let + // let binding "and__0__auto__" + tmp15 := lang.Apply(v4, []any{v8}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + if lang.IsTruthy(v16) { + tmp18 := lang.Apply(v5, []any{v8}) + tmp17 = tmp18 + } else { + tmp17 = v16 + } + tmp14 = tmp17 + } // end let + tmp13 = tmp14 + } else { + tmp13 = v12 + } + tmp10 = tmp13 + } // end let + tmp11 := lang.Apply(tmp9, []any{tmp10}) + return tmp11 + case 2: + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + tmp10 := checkDerefVar(glojure_DOT_core_boolean) + var tmp11 any + { // let + // let binding "and__0__auto__" + tmp12 := lang.Apply(v3, []any{v8}) + var v13 any = tmp12 + _ = v13 + var tmp14 any + if lang.IsTruthy(v13) { + var tmp15 any + { // let + // let binding "and__0__auto__" + tmp16 := lang.Apply(v3, []any{v9}) + var v17 any = tmp16 + _ = v17 + var tmp18 any + if lang.IsTruthy(v17) { + var tmp19 any + { // let + // let binding "and__0__auto__" + tmp20 := lang.Apply(v4, []any{v8}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + if lang.IsTruthy(v21) { + var tmp23 any + { // let + // let binding "and__0__auto__" + tmp24 := lang.Apply(v4, []any{v9}) + var v25 any = tmp24 + _ = v25 + var tmp26 any + if lang.IsTruthy(v25) { + var tmp27 any + { // let + // let binding "and__0__auto__" + tmp28 := lang.Apply(v5, []any{v8}) + var v29 any = tmp28 + _ = v29 + var tmp30 any + if lang.IsTruthy(v29) { + tmp31 := lang.Apply(v5, []any{v9}) + tmp30 = tmp31 + } else { + tmp30 = v29 + } + tmp27 = tmp30 + } // end let + tmp26 = tmp27 + } else { + tmp26 = v25 + } + tmp23 = tmp26 + } // end let + tmp22 = tmp23 + } else { + tmp22 = v21 + } + tmp19 = tmp22 + } // end let + tmp18 = tmp19 + } else { + tmp18 = v17 + } + tmp15 = tmp18 + } // end let + tmp14 = tmp15 + } else { + tmp14 = v13 + } + tmp11 = tmp14 + } // end let + tmp12 := lang.Apply(tmp10, []any{tmp11}) + return tmp12 + case 3: + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + v10 := args[2] + _ = v10 + tmp11 := checkDerefVar(glojure_DOT_core_boolean) + var tmp12 any + { // let + // let binding "and__0__auto__" + tmp13 := lang.Apply(v3, []any{v8}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + var tmp16 any + { // let + // let binding "and__0__auto__" + tmp17 := lang.Apply(v3, []any{v9}) + var v18 any = tmp17 + _ = v18 + var tmp19 any + if lang.IsTruthy(v18) { + var tmp20 any + { // let + // let binding "and__0__auto__" + tmp21 := lang.Apply(v3, []any{v10}) + var v22 any = tmp21 + _ = v22 + var tmp23 any + if lang.IsTruthy(v22) { + var tmp24 any + { // let + // let binding "and__0__auto__" + tmp25 := lang.Apply(v4, []any{v8}) + var v26 any = tmp25 + _ = v26 + var tmp27 any + if lang.IsTruthy(v26) { + var tmp28 any + { // let + // let binding "and__0__auto__" + tmp29 := lang.Apply(v4, []any{v9}) + var v30 any = tmp29 + _ = v30 + var tmp31 any + if lang.IsTruthy(v30) { + var tmp32 any + { // let + // let binding "and__0__auto__" + tmp33 := lang.Apply(v4, []any{v10}) + var v34 any = tmp33 + _ = v34 + var tmp35 any + if lang.IsTruthy(v34) { + var tmp36 any + { // let + // let binding "and__0__auto__" + tmp37 := lang.Apply(v5, []any{v8}) + var v38 any = tmp37 + _ = v38 + var tmp39 any + if lang.IsTruthy(v38) { + var tmp40 any + { // let + // let binding "and__0__auto__" + tmp41 := lang.Apply(v5, []any{v9}) + var v42 any = tmp41 + _ = v42 + var tmp43 any + if lang.IsTruthy(v42) { + tmp44 := lang.Apply(v5, []any{v10}) + tmp43 = tmp44 + } else { + tmp43 = v42 + } + tmp40 = tmp43 + } // end let + tmp39 = tmp40 + } else { + tmp39 = v38 + } + tmp36 = tmp39 + } // end let + tmp35 = tmp36 + } else { + tmp35 = v34 + } + tmp32 = tmp35 + } // end let + tmp31 = tmp32 + } else { + tmp31 = v30 + } + tmp28 = tmp31 + } // end let + tmp27 = tmp28 + } else { + tmp27 = v26 + } + tmp24 = tmp27 + } // end let + tmp23 = tmp24 + } else { + tmp23 = v22 + } + tmp20 = tmp23 + } // end let + tmp19 = tmp20 + } else { + tmp19 = v18 + } + tmp16 = tmp19 + } // end let + tmp15 = tmp16 + } else { + tmp15 = v14 + } + tmp12 = tmp15 + } // end let + tmp13 := lang.Apply(tmp11, []any{tmp12}) + return tmp13 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + v10 := args[2] + _ = v10 + var v11 any = lang.NewList(args[3:]...) + _ = v11 + tmp12 := checkDerefVar(glojure_DOT_core_boolean) + var tmp13 any + { // let + // let binding "and__0__auto__" + tmp14 := lang.Apply(v7, []any{v8, v9, v10}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + if lang.IsTruthy(v15) { + tmp17 := checkDerefVar(glojure_DOT_core_every_QMARK_) + var tmp18 lang.FnFunc + tmp18 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v19 := args[0] + _ = v19 + var tmp20 any + { // let + // let binding "and__0__auto__" + tmp21 := lang.Apply(v3, []any{v19}) + var v22 any = tmp21 + _ = v22 + var tmp23 any + if lang.IsTruthy(v22) { + var tmp24 any + { // let + // let binding "and__0__auto__" + tmp25 := lang.Apply(v4, []any{v19}) + var v26 any = tmp25 + _ = v26 + var tmp27 any + if lang.IsTruthy(v26) { + tmp28 := lang.Apply(v5, []any{v19}) + tmp27 = tmp28 + } else { + tmp27 = v26 + } + tmp24 = tmp27 + } // end let + tmp23 = tmp24 + } else { + tmp23 = v22 + } + tmp20 = tmp23 + } // end let + return tmp20 + }) + tmp19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7451), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(7451), lang.NewKeyword("end-column"), int(72)) + tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp21 := lang.Apply(tmp17, []any{tmp20, v11}) + tmp16 = tmp21 + } else { + tmp16 = v15 + } + tmp13 = tmp16 + } // end let + tmp14 := lang.Apply(tmp12, []any{tmp13}) + return tmp14 + } + }) + v7 = tmp6 + _ = v7 + } + tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7445), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7451), lang.NewKeyword("end-column"), int(82)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp8 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any + { // let + // let binding "ps" + tmp8 := checkDerefVar(glojure_DOT_core_list_STAR_) + tmp9 := lang.Apply(tmp8, []any{v3, v4, v5, v6}) + var v10 any = tmp9 + _ = v10 + var tmp11 lang.FnFunc + { // function epn + var v12 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return true + case 1: + v13 := args[0] + _ = v13 + tmp14 := checkDerefVar(glojure_DOT_core_every_QMARK_) + var tmp15 lang.FnFunc + tmp15 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v16 := args[0] + _ = v16 + tmp17 := lang.Apply(v16, []any{v13}) + return tmp17 + }) + tmp16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7456), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(7456), lang.NewKeyword("end-column"), int(28)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp18 := lang.Apply(tmp14, []any{tmp17, v10}) + return tmp18 + case 2: + v13 := args[0] + _ = v13 + v14 := args[1] + _ = v14 + tmp15 := checkDerefVar(glojure_DOT_core_every_QMARK_) + var tmp16 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v17 := args[0] + _ = v17 + var tmp18 any + { // let + // let binding "and__0__auto__" + tmp19 := lang.Apply(v17, []any{v13}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + tmp22 := lang.Apply(v17, []any{v14}) + tmp21 = tmp22 + } else { + tmp21 = v20 + } + tmp18 = tmp21 + } // end let + return tmp18 + }) + tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7457), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7457), lang.NewKeyword("end-column"), int(42)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp19 := lang.Apply(tmp15, []any{tmp18, v10}) + return tmp19 + case 3: + v13 := args[0] + _ = v13 + v14 := args[1] + _ = v14 + v15 := args[2] + _ = v15 + tmp16 := checkDerefVar(glojure_DOT_core_every_QMARK_) + var tmp17 lang.FnFunc + tmp17 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v18 := args[0] + _ = v18 + var tmp19 any + { // let + // let binding "and__0__auto__" + tmp20 := lang.Apply(v18, []any{v13}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + if lang.IsTruthy(v21) { + var tmp23 any + { // let + // let binding "and__0__auto__" + tmp24 := lang.Apply(v18, []any{v14}) + var v25 any = tmp24 + _ = v25 + var tmp26 any + if lang.IsTruthy(v25) { + tmp27 := lang.Apply(v18, []any{v15}) + tmp26 = tmp27 + } else { + tmp26 = v25 + } + tmp23 = tmp26 + } // end let + tmp22 = tmp23 + } else { + tmp22 = v21 + } + tmp19 = tmp22 + } // end let + return tmp19 + }) + tmp18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7458), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(7458), lang.NewKeyword("end-column"), int(50)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp20 := lang.Apply(tmp16, []any{tmp19, v10}) + return tmp20 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v13 := args[0] + _ = v13 + v14 := args[1] + _ = v14 + v15 := args[2] + _ = v15 + var v16 any = lang.NewList(args[3:]...) + _ = v16 + tmp17 := checkDerefVar(glojure_DOT_core_boolean) + var tmp18 any + { // let + // let binding "and__0__auto__" + tmp19 := lang.Apply(v12, []any{v13, v14, v15}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + tmp22 := checkDerefVar(glojure_DOT_core_every_QMARK_) + var tmp23 lang.FnFunc + tmp23 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v24 := args[0] + _ = v24 + tmp25 := checkDerefVar(glojure_DOT_core_every_QMARK_) + tmp26 := lang.Apply(tmp25, []any{v24, v16}) + return tmp26 + }) + tmp24 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7460), lang.NewKeyword("column"), int(48), lang.NewKeyword("end-line"), int(7460), lang.NewKeyword("end-column"), int(63)) + tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp26 := lang.Apply(tmp22, []any{tmp25, v10}) + tmp21 = tmp26 + } else { + tmp21 = v20 + } + tmp18 = tmp21 + } // end let + tmp19 := lang.Apply(tmp17, []any{tmp18}) + return tmp19 + } + }) + v12 = tmp11 + _ = v12 + } + tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7454), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7460), lang.NewKeyword("end-column"), int(71)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp7 = tmp13 + } // end let + return tmp7 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // every? + { + tmp1 := reflect.TypeOf(false) + tmp0 := lang.NewSymbol("every?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if (pred x) is logical true for every x in coll, else\n false.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2664), lang.NewKeyword("end-line"), int(2664))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + recur_loop_480: + var tmp6 any + tmp7 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp8 := checkDerefVar(glojure_DOT_core_seq) + tmp9 := lang.Apply(tmp8, []any{v5}) + tmp10 := lang.Apply(tmp7, []any{tmp9}) + if lang.IsTruthy(tmp10) { + tmp6 = true + } else { + var tmp11 any + tmp12 := checkDerefVar(glojure_DOT_core_first) + tmp13 := lang.Apply(tmp12, []any{v5}) + tmp14 := lang.Apply(v4, []any{tmp13}) + if lang.IsTruthy(tmp14) { + var tmp15 any = v4 + tmp17 := checkDerefVar(glojure_DOT_core_next) + tmp18 := lang.Apply(tmp17, []any{v5}) + var tmp16 any = tmp18 + v4 = tmp15 + v5 = tmp16 + goto recur_loop_480 + } else { + var tmp19 any + if lang.IsTruthy(lang.NewKeyword("else")) { + tmp19 = false + } else { + } + tmp11 = tmp19 + } + tmp6 = tmp11 + } + return tmp6 + }) + tmp4 := reflect.TypeOf(false) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ex-cause + { + tmp0 := lang.NewSymbol("ex-cause").WithMeta(lang.NewMap(lang.NewKeyword("tag"), nil, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ex"))), lang.NewKeyword("doc"), "Returns the cause of ex if ex is a Throwable.\n Otherwise returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4828), lang.NewKeyword("end-line"), int(4828))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp6 := lang.Apply(tmp5, []any{lang.Throwable, v3}) + if lang.IsTruthy(tmp6) { + tmp7, ok := lang.FieldOrMethod(v3, "getCause") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getCause"))) + } + var tmp8 any + switch reflect.TypeOf(tmp7).Kind() { + case reflect.Func: + tmp8 = lang.Apply(tmp7, nil) + default: + tmp8 = tmp7 + } + tmp4 = tmp8 + } else { + } + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ex-data + { + tmp0 := lang.NewSymbol("ex-data").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ex"))), lang.NewKeyword("doc"), "Returns exception data (a map) if ex is an IExceptionInfo.\n Otherwise returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4812), lang.NewKeyword("end-line"), int(4812))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp6 := lang.Apply(tmp5, []any{nil, v3}) + if lang.IsTruthy(tmp6) { + tmp7, ok := lang.FieldOrMethod(v3, "getData") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getData"))) + } + var tmp8 any + switch reflect.TypeOf(tmp7).Kind() { + case reflect.Func: + tmp8 = lang.Apply(tmp7, nil) + default: + tmp8 = tmp7 + } + tmp4 = tmp8 + } else { + } + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ex-info + { + tmp0 := lang.NewSymbol("ex-info").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("msg"), lang.NewSymbol("map")), lang.NewVector(lang.NewSymbol("msg"), lang.NewSymbol("map"), lang.NewSymbol("cause"))), lang.NewKeyword("doc"), "Create an instance of ExceptionInfo, a RuntimeException subclass\n that carries a map of additional data.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4803), lang.NewKeyword("end-line"), int(4803))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_elide_top_frames) + tmp6 := lang.Apply(nil, []any{v3, v4}) + tmp7 := lang.Apply(tmp5, []any{tmp6, "glojure.core$ex_info"}) + return tmp7 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6 := checkDerefVar(glojure_DOT_core_elide_top_frames) + tmp7 := lang.Apply(nil, []any{v3, v4, v5}) + tmp8 := lang.Apply(tmp6, []any{tmp7, "glojure.core$ex_info"}) + return tmp8 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ex-message + { + tmp0 := lang.NewSymbol("ex-message").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ex"))), lang.NewKeyword("doc"), "Returns the message attached to ex if ex is a Throwable.\n Otherwise returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4820), lang.NewKeyword("end-line"), int(4820))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp6 := lang.Apply(tmp5, []any{lang.Throwable, v3}) + if lang.IsTruthy(tmp6) { + tmp7, ok := lang.FieldOrMethod(v3, "getMessage") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getMessage"))) + } + var tmp8 any + switch reflect.TypeOf(tmp7).Kind() { + case reflect.Func: + tmp8 = lang.Apply(tmp7, nil) + default: + tmp8 = tmp7 + } + tmp4 = tmp8 + } else { + } + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // extend + { + tmp0 := lang.NewSymbol("extend").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atype"), lang.NewSymbol("&"), lang.NewSymbol("proto+mmaps"))), lang.NewKeyword("doc"), "Implementations of protocol methods can be provided using the extend construct:\n\n (extend AType\n AProtocol\n {:foo an-existing-fn\n :bar (fn [a b] ...)\n :baz (fn ([a]...) ([a b] ...)...)}\n BProtocol \n {...} \n ...)\n \n extend takes a type/class (or interface, see below), and one or more\n protocol + method map pairs. It will extend the polymorphism of the\n protocol's methods to call the supplied methods when an AType is\n provided as the first argument. \n\n Method maps are maps of the keyword-ized method names to ordinary\n fns. This facilitates easy reuse of existing fns and fn maps, for\n code reuse/mixins without derivation or composition. You can extend\n an interface to a protocol. This is primarily to facilitate interop\n with the host (e.g. Java) but opens the door to incidental multiple\n inheritance of implementation since a class can inherit from more\n than one interface, both of which extend the protocol. It is TBD how\n to specify which impl to use. You can extend a protocol on nil.\n\n If you are supplying the definitions explicitly (i.e. not reusing\n exsting functions or mixin maps), you may find it more convenient to\n use the extend-type or extend-protocol macros.\n\n Note that multiple independent extend clauses can exist for the same\n type, not all protocols need be defined in a single extend call.\n\n See also:\n extends?, satisfies?, extenders", lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(116), lang.NewKeyword("end-line"), int(116))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any = lang.NewList(args[1:]...) + _ = v4 + var tmp5 any + { // let + // let binding "seq_262" + tmp6 := checkDerefVar(glojure_DOT_core_seq) + tmp7 := checkDerefVar(glojure_DOT_core_partition) + tmp8 := lang.Apply(tmp7, []any{int64(2), v4}) + tmp9 := lang.Apply(tmp6, []any{tmp8}) + var v10 any = tmp9 + _ = v10 + // let binding "chunk_263" + var v11 any = nil + _ = v11 + // let binding "count_264" + var v12 any = int64(0) + _ = v12 + // let binding "i_265" + var v13 any = int64(0) + _ = v13 + for { + var tmp14 any + tmp15 := checkDerefVar(glojure_DOT_core__LT_) + tmp16 := lang.Apply(tmp15, []any{v13, v12}) + if lang.IsTruthy(tmp16) { + var tmp17 any + { // let + // let binding "vec__266" + tmp18, _ := lang.FieldOrMethod(v11, "nth") + if reflect.TypeOf(tmp18).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp19 := lang.Apply(tmp18, []any{v13}) + var v20 any = tmp19 + _ = v20 + // let binding "proto" + tmp21 := checkDerefVar(glojure_DOT_core_nth) + tmp22 := lang.Apply(tmp21, []any{v20, int64(0), nil}) + var v23 any = tmp22 + _ = v23 + // let binding "mmap" + tmp24 := checkDerefVar(glojure_DOT_core_nth) + tmp25 := lang.Apply(tmp24, []any{v20, int64(1), nil}) + var v26 any = tmp25 + _ = v26 + var tmp27 any + tmp28 := checkDerefVar(glojure_DOT_core_protocol_QMARK_) + tmp29 := lang.Apply(tmp28, []any{v23}) + if lang.IsTruthy(tmp29) { + } else { + tmp30 := checkDerefVar(glojure_DOT_core_str) + tmp31 := lang.Apply(tmp30, []any{v23, " is not a protocol"}) + tmp32 := lang.Apply(errors8.New, []any{tmp31}) + panic(tmp32) + } + _ = tmp27 + tmp33 := checkDerefVar(glojure_DOT_core_reduce1) + var tmp34 lang.FnFunc + tmp34 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v35 := args[0] + _ = v35 + v36 := args[1] + _ = v36 + var tmp37 any + { // let + // let binding "vec__270" + var v38 any = v36 + _ = v38 + // let binding "k" + tmp39 := checkDerefVar(glojure_DOT_core_nth) + tmp40 := lang.Apply(tmp39, []any{v38, int64(0), nil}) + var v41 any = tmp40 + _ = v41 + // let binding "v" + tmp42 := checkDerefVar(glojure_DOT_core_nth) + tmp43 := lang.Apply(tmp42, []any{v38, int64(1), nil}) + var v44 any = tmp43 + _ = v44 + tmp45 := checkDerefVar(glojure_DOT_core_get_in) + tmp46 := checkDerefVar(glojure_DOT_core_deref) + tmp47 := lang.Apply(tmp46, []any{v23}) + tmp48 := lang.NewVector(lang.NewKeyword("multis"), v41) + tmp49 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(158), lang.NewKeyword("column"), int(33), lang.NewKeyword("end-line"), int(158), lang.NewKeyword("end-column"), int(43)) + tmp50, err := lang.WithMeta(tmp48, tmp49.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp51 := lang.Apply(tmp45, []any{tmp47, tmp50}) + var tmp52 lang.FnFunc + tmp52 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v53 := args[0] + _ = v53 + var v54 any = lang.NewList(args[1:]...) + _ = v54 + tmp55 := checkDerefVar(glojure_DOT_core_apply) + tmp56 := checkDerefVar(glojure_DOT_core_cons) + tmp57 := lang.Apply(tmp56, []any{v53, v54}) + tmp58 := lang.Apply(tmp55, []any{v44, tmp57}) + return tmp58 + } + }) + tmp53, _ := lang.FieldOrMethod(tmp51, "AddMethod") + if reflect.TypeOf(tmp53).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("AddMethod is not a function"))) + } + tmp54 := lang.Apply(tmp53, []any{v3, tmp52}) + tmp37 = tmp54 + } // end let + return tmp37 + }) + tmp35 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(156), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(160), lang.NewKeyword("end-column"), int(45)) + tmp36, err := lang.WithMeta(tmp34, tmp35.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp37 := lang.Apply(tmp33, []any{tmp36, nil, v26}) + _ = tmp37 + var tmp38 any = v10 + var tmp39 any = v11 + var tmp40 any = v12 + tmp42 := checkDerefVar(glojure_DOT_core_unchecked_inc) + tmp43 := lang.Apply(tmp42, []any{v13}) + var tmp41 any = tmp43 + v10 = tmp38 + v11 = tmp39 + v12 = tmp40 + v13 = tmp41 + continue + } // end let + tmp14 = tmp17 + } else { + var tmp18 any + { // let + // let binding "temp__0__auto__" + tmp19 := checkDerefVar(glojure_DOT_core_seq) + tmp20 := lang.Apply(tmp19, []any{v10}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + if lang.IsTruthy(v21) { + var tmp23 any + { // let + // let binding "seq_262" + var v24 any = v21 + _ = v24 + var tmp25 any + tmp26 := checkDerefVar(glojure_DOT_core_chunked_seq_QMARK_) + tmp27 := lang.Apply(tmp26, []any{v24}) + if lang.IsTruthy(tmp27) { + var tmp28 any + { // let + // let binding "c__0__auto__" + tmp29 := checkDerefVar(glojure_DOT_core_chunk_first) + tmp30 := lang.Apply(tmp29, []any{v24}) + var v31 any = tmp30 + _ = v31 + tmp33 := checkDerefVar(glojure_DOT_core_chunk_rest) + tmp34 := lang.Apply(tmp33, []any{v24}) + var tmp32 any = tmp34 + var tmp35 any = v31 + tmp37 := checkDerefVar(glojure_DOT_core_int) + tmp38 := checkDerefVar(glojure_DOT_core_count) + tmp39 := lang.Apply(tmp38, []any{v31}) + tmp40 := lang.Apply(tmp37, []any{tmp39}) + var tmp36 any = tmp40 + tmp42 := checkDerefVar(glojure_DOT_core_int) + tmp43 := lang.Apply(tmp42, []any{int64(0)}) + var tmp41 any = tmp43 + v10 = tmp32 + v11 = tmp35 + v12 = tmp36 + v13 = tmp41 + continue + } // end let + tmp25 = tmp28 + } else { + var tmp29 any + { // let + // let binding "vec__273" + tmp30 := checkDerefVar(glojure_DOT_core_first) + tmp31 := lang.Apply(tmp30, []any{v24}) + var v32 any = tmp31 + _ = v32 + // let binding "proto" + tmp33 := checkDerefVar(glojure_DOT_core_nth) + tmp34 := lang.Apply(tmp33, []any{v32, int64(0), nil}) + var v35 any = tmp34 + _ = v35 + // let binding "mmap" + tmp36 := checkDerefVar(glojure_DOT_core_nth) + tmp37 := lang.Apply(tmp36, []any{v32, int64(1), nil}) + var v38 any = tmp37 + _ = v38 + var tmp39 any + tmp40 := checkDerefVar(glojure_DOT_core_protocol_QMARK_) + tmp41 := lang.Apply(tmp40, []any{v35}) + if lang.IsTruthy(tmp41) { + } else { + tmp42 := checkDerefVar(glojure_DOT_core_str) + tmp43 := lang.Apply(tmp42, []any{v35, " is not a protocol"}) + tmp44 := lang.Apply(errors8.New, []any{tmp43}) + panic(tmp44) + } + _ = tmp39 + tmp45 := checkDerefVar(glojure_DOT_core_reduce1) + var tmp46 lang.FnFunc + tmp46 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v47 := args[0] + _ = v47 + v48 := args[1] + _ = v48 + var tmp49 any + { // let + // let binding "vec__277" + var v50 any = v48 + _ = v50 + // let binding "k" + tmp51 := checkDerefVar(glojure_DOT_core_nth) + tmp52 := lang.Apply(tmp51, []any{v50, int64(0), nil}) + var v53 any = tmp52 + _ = v53 + // let binding "v" + tmp54 := checkDerefVar(glojure_DOT_core_nth) + tmp55 := lang.Apply(tmp54, []any{v50, int64(1), nil}) + var v56 any = tmp55 + _ = v56 + tmp57 := checkDerefVar(glojure_DOT_core_get_in) + tmp58 := checkDerefVar(glojure_DOT_core_deref) + tmp59 := lang.Apply(tmp58, []any{v35}) + tmp60 := lang.NewVector(lang.NewKeyword("multis"), v53) + tmp61 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(158), lang.NewKeyword("column"), int(33), lang.NewKeyword("end-line"), int(158), lang.NewKeyword("end-column"), int(43)) + tmp62, err := lang.WithMeta(tmp60, tmp61.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp63 := lang.Apply(tmp57, []any{tmp59, tmp62}) + var tmp64 lang.FnFunc + tmp64 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v65 := args[0] + _ = v65 + var v66 any = lang.NewList(args[1:]...) + _ = v66 + tmp67 := checkDerefVar(glojure_DOT_core_apply) + tmp68 := checkDerefVar(glojure_DOT_core_cons) + tmp69 := lang.Apply(tmp68, []any{v65, v66}) + tmp70 := lang.Apply(tmp67, []any{v56, tmp69}) + return tmp70 + } + }) + tmp65, _ := lang.FieldOrMethod(tmp63, "AddMethod") + if reflect.TypeOf(tmp65).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("AddMethod is not a function"))) + } + tmp66 := lang.Apply(tmp65, []any{v3, tmp64}) + tmp49 = tmp66 + } // end let + return tmp49 + }) + tmp47 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(156), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(160), lang.NewKeyword("end-column"), int(45)) + tmp48, err := lang.WithMeta(tmp46, tmp47.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp49 := lang.Apply(tmp45, []any{tmp48, nil, v38}) + _ = tmp49 + tmp51 := checkDerefVar(glojure_DOT_core_next) + tmp52 := lang.Apply(tmp51, []any{v24}) + var tmp50 any = tmp52 + var tmp53 any = nil + var tmp54 any = int64(0) + var tmp55 any = int64(0) + v10 = tmp50 + v11 = tmp53 + v12 = tmp54 + v13 = tmp55 + continue + } // end let + tmp25 = tmp29 + } + tmp23 = tmp25 + } // end let + tmp22 = tmp23 + } else { + } + tmp18 = tmp22 + } // end let + tmp14 = tmp18 + } + tmp5 = tmp14 + break + } + } // end let + return tmp5 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // extend-protocol + { + tmp0 := lang.NewSymbol("extend-protocol").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("p"), lang.NewSymbol("&"), lang.NewSymbol("specs"))), lang.NewKeyword("doc"), "Useful when you want to provide several implementations of the same\n protocol all at once. Takes a single protocol and the implementation\n of that protocol for one or more types.\n\n (extend-protocol Protocol\n AType\n (foo [x] ...)\n (bar [x y] ...)\n BType\n (foo [x] ...)\n (bar [x y] ...)\n AClass\n (foo [x] ...)\n (bar [x y] ...)\n nil\n (foo [x] ...)\n (bar [x y] ...))\n\n expands into:\n\n (do\n (clojure.core/extend-type AType Protocol \n (foo [x] ...) \n (bar [x y] ...))\n (clojure.core/extend-type BType Protocol \n (foo [x] ...) \n (bar [x y] ...))\n (clojure.core/extend-type AClass Protocol \n (foo [x] ...) \n (bar [x y] ...))\n (clojure.core/extend-type nil Protocol \n (foo [x] ...) \n (bar [x y] ...)))", lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(212), lang.NewKeyword("end-line"), int(212))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_emit_extend_protocol) + tmp8 := lang.Apply(tmp7, []any{v5, v6}) + return tmp8 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // extend-type + { + tmp0 := lang.NewSymbol("extend-type").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("t"), lang.NewSymbol("&"), lang.NewSymbol("specs"))), lang.NewKeyword("doc"), "A macro that expands into an extend call. Useful when you are\n supplying the definitions explicitly inline, extend-type\n automatically creates the maps required by extend. Propagates the\n class as a type hint on the first argument of all fns.\n\n (extend-type MyType \n Countable\n (cnt [c] ...)\n Foo\n (bar [x y] ...)\n (baz ([x] ...) ([x y & zs] ...)))\n\n expands into:\n\n (extend MyType\n Countable\n {:cnt (fn [c] ...)}\n Foo\n {:baz (fn ([x] ...) ([x y & zs] ...))\n :bar (fn [x y] ...)})", lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(180), lang.NewKeyword("end-line"), int(180))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_emit_extend_type) + tmp8 := lang.Apply(tmp7, []any{v5, v6}) + return tmp8 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // false? + { + tmp1 := reflect.TypeOf(false) + tmp0 := lang.NewSymbol("false?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is the value false, false otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(504), lang.NewKeyword("end-line"), int(504))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5 := lang.Apply(lang.Identical, []any{v4, false}) + return tmp5 + }) + tmp4 := reflect.TypeOf(false) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ffirst + { + tmp0 := lang.NewSymbol("ffirst").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Same as (first (first x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(98), lang.NewKeyword("end-line"), int(102))).(*lang.Symbol) + var tmp2 lang.FnFunc + { // function ffirst + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_first) + tmp6 := checkDerefVar(glojure_DOT_core_first) + tmp7 := lang.Apply(tmp6, []any{v4}) + tmp8 := lang.Apply(tmp5, []any{tmp7}) + return tmp8 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(102), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(102), lang.NewKeyword("end-column"), int(50))).(lang.FnFunc) + v3 = tmp2 + _ = v3 + } + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // file-seq + { + tmp0 := lang.NewSymbol("file-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("dir"))), lang.NewKeyword("doc"), "A tree seq on java.io.Files", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4972), lang.NewKeyword("end-line"), int(4972))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_tree_seq) + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v6 := args[0] + _ = v6 + tmp7, _ := lang.FieldOrMethod(v6, "isDirectory") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("isDirectory is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{}) + return tmp8 + }) + tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4978), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(4978), lang.NewKeyword("end-column"), int(47)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var tmp8 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v9 := args[0] + _ = v9 + tmp10 := checkDerefVar(glojure_DOT_core_seq) + tmp11, _ := lang.FieldOrMethod(v9, "listFiles") + if reflect.TypeOf(tmp11).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("listFiles is not a function"))) + } + tmp12 := lang.Apply(tmp11, []any{}) + tmp13 := lang.Apply(tmp10, []any{tmp12}) + return tmp13 + }) + tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4979), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(4979), lang.NewKeyword("end-column"), int(51)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp11 := lang.Apply(tmp4, []any{tmp7, tmp10, v3}) + return tmp11 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // filter + { + tmp0 := lang.NewSymbol("filter").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred")), lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the items in coll for which\n (pred item) returns logical true. pred must be free of side-effects.\n Returns a transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2785), lang.NewKeyword("end-line"), int(2785))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp7 := lang.Apply(v5, nil) + return tmp7 + case 1: + v7 := args[0] + _ = v7 + tmp8 := lang.Apply(v5, []any{v7}) + return tmp8 + case 2: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + var tmp9 any + tmp10 := lang.Apply(v3, []any{v8}) + if lang.IsTruthy(tmp10) { + tmp11 := lang.Apply(v5, []any{v7, v8}) + tmp9 = tmp11 + } else { + tmp9 = v7 + } + return tmp9 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2793), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(2799), lang.NewKeyword("end-column"), int(22)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp8 + }) + tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2792), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2799), lang.NewKeyword("end-column"), int(23)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var tmp6 any + { // let + // let binding "temp__0__auto__" + tmp7 := checkDerefVar(glojure_DOT_core_seq) + tmp8 := lang.Apply(tmp7, []any{v4}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + var tmp11 any + { // let + // let binding "s" + var v12 any = v9 + _ = v12 + var tmp13 any + tmp14 := checkDerefVar(glojure_DOT_core_chunked_seq_QMARK_) + tmp15 := lang.Apply(tmp14, []any{v12}) + if lang.IsTruthy(tmp15) { + var tmp16 any + { // let + // let binding "c" + tmp17 := checkDerefVar(glojure_DOT_core_chunk_first) + tmp18 := lang.Apply(tmp17, []any{v12}) + var v19 any = tmp18 + _ = v19 + // let binding "size" + tmp20 := checkDerefVar(glojure_DOT_core_count) + tmp21 := lang.Apply(tmp20, []any{v19}) + var v22 any = tmp21 + _ = v22 + // let binding "b" + tmp23 := checkDerefVar(glojure_DOT_core_chunk_buffer) + tmp24 := lang.Apply(tmp23, []any{v22}) + var v25 any = tmp24 + _ = v25 + var tmp26 any + { // let + // let binding "n__0__auto__" + tmp27 := lang.Apply(lang.LongCast, []any{v22}) + var v28 any = tmp27 + _ = v28 + var tmp29 any + { // let + // let binding "i" + var v30 any = int64(0) + _ = v30 + for { + var tmp31 any + tmp32 := checkDerefVar(glojure_DOT_core__LT_) + tmp33 := lang.Apply(tmp32, []any{v30, v28}) + if lang.IsTruthy(tmp33) { + var tmp34 any + { // let + // let binding "v" + tmp35, _ := lang.FieldOrMethod(v19, "nth") + if reflect.TypeOf(tmp35).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp36 := lang.Apply(tmp35, []any{v30}) + var v37 any = tmp36 + _ = v37 + var tmp38 any + tmp39 := lang.Apply(v3, []any{v37}) + if lang.IsTruthy(tmp39) { + tmp40 := checkDerefVar(glojure_DOT_core_chunk_append) + tmp41 := lang.Apply(tmp40, []any{v25, v37}) + tmp38 = tmp41 + } else { + } + tmp34 = tmp38 + } // end let + _ = tmp34 + tmp36 := checkDerefVar(glojure_DOT_core_unchecked_inc) + tmp37 := lang.Apply(tmp36, []any{v30}) + var tmp35 any = tmp37 + v30 = tmp35 + continue + } else { + } + tmp29 = tmp31 + break + } + } // end let + tmp26 = tmp29 + } // end let + _ = tmp26 + tmp27 := checkDerefVar(glojure_DOT_core_chunk_cons) + tmp28 := checkDerefVar(glojure_DOT_core_chunk) + tmp29 := lang.Apply(tmp28, []any{v25}) + tmp30 := checkDerefVar(glojure_DOT_core_filter) + tmp31 := checkDerefVar(glojure_DOT_core_chunk_rest) + tmp32 := lang.Apply(tmp31, []any{v12}) + tmp33 := lang.Apply(tmp30, []any{v3, tmp32}) + tmp34 := lang.Apply(tmp27, []any{tmp29, tmp33}) + tmp16 = tmp34 + } // end let + tmp13 = tmp16 + } else { + var tmp17 any + { // let + // let binding "f" + tmp18 := checkDerefVar(glojure_DOT_core_first) + tmp19 := lang.Apply(tmp18, []any{v12}) + var v20 any = tmp19 + _ = v20 + // let binding "r" + tmp21 := checkDerefVar(glojure_DOT_core_rest) + tmp22 := lang.Apply(tmp21, []any{v12}) + var v23 any = tmp22 + _ = v23 + var tmp24 any + tmp25 := lang.Apply(v3, []any{v20}) + if lang.IsTruthy(tmp25) { + tmp26 := checkDerefVar(glojure_DOT_core_cons) + tmp27 := checkDerefVar(glojure_DOT_core_filter) + tmp28 := lang.Apply(tmp27, []any{v3, v23}) + tmp29 := lang.Apply(tmp26, []any{v20, tmp28}) + tmp24 = tmp29 + } else { + tmp30 := checkDerefVar(glojure_DOT_core_filter) + tmp31 := lang.Apply(tmp30, []any{v3, v23}) + tmp24 = tmp31 + } + tmp17 = tmp24 + } // end let + tmp13 = tmp17 + } + tmp11 = tmp13 + } // end let + tmp10 = tmp11 + } else { + } + tmp6 = tmp10 + } // end let + return tmp6 + }) + tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) + return tmp6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // filter-key + { + tmp0 := lang.NewSymbol("filter-key").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("keyfn"), lang.NewSymbol("pred"), lang.NewSymbol("amap"))), lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4115), lang.NewKeyword("end-line"), int(4117), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var tmp6 any + { // let + // let binding "ret" + tmp7 := lang.NewMap() + tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4118), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(4118), lang.NewKeyword("end-column"), int(17)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v10 any = tmp9 + _ = v10 + // let binding "es" + tmp11 := checkDerefVar(glojure_DOT_core_seq) + tmp12 := lang.Apply(tmp11, []any{v5}) + var v13 any = tmp12 + _ = v13 + for { + var tmp14 any + if lang.IsTruthy(v13) { + var tmp15 any + tmp16 := checkDerefVar(glojure_DOT_core_first) + tmp17 := lang.Apply(tmp16, []any{v13}) + tmp18 := lang.Apply(v3, []any{tmp17}) + tmp19 := lang.Apply(v4, []any{tmp18}) + if lang.IsTruthy(tmp19) { + tmp21 := checkDerefVar(glojure_DOT_core_assoc) + tmp22 := checkDerefVar(glojure_DOT_core_key) + tmp23 := checkDerefVar(glojure_DOT_core_first) + tmp24 := lang.Apply(tmp23, []any{v13}) + tmp25 := lang.Apply(tmp22, []any{tmp24}) + tmp26 := checkDerefVar(glojure_DOT_core_val) + tmp27 := checkDerefVar(glojure_DOT_core_first) + tmp28 := lang.Apply(tmp27, []any{v13}) + tmp29 := lang.Apply(tmp26, []any{tmp28}) + tmp30 := lang.Apply(tmp21, []any{v10, tmp25, tmp29}) + var tmp20 any = tmp30 + tmp32 := checkDerefVar(glojure_DOT_core_next) + tmp33 := lang.Apply(tmp32, []any{v13}) + var tmp31 any = tmp33 + v10 = tmp20 + v13 = tmp31 + continue + } else { + var tmp34 any = v10 + tmp36 := checkDerefVar(glojure_DOT_core_next) + tmp37 := lang.Apply(tmp36, []any{v13}) + var tmp35 any = tmp37 + v10 = tmp34 + v13 = tmp35 + continue + } + tmp14 = tmp15 + } else { + tmp14 = v10 + } + tmp6 = tmp14 + break + } + } // end let + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // filterv + { + tmp0 := lang.NewSymbol("filterv").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a vector of the items in coll for which\n (pred item) returns logical true. pred must be free of side-effects.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6961), lang.NewKeyword("end-line"), int(6961))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_persistent_BANG_) + tmp6 := checkDerefVar(glojure_DOT_core_reduce) + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + var tmp10 any + tmp11 := lang.Apply(v3, []any{v9}) + if lang.IsTruthy(tmp11) { + tmp12 := checkDerefVar(glojure_DOT_core_conj_BANG_) + tmp13 := lang.Apply(tmp12, []any{v8, v9}) + tmp10 = tmp13 + } else { + tmp10 = v8 + } + return tmp10 + }) + tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6967), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(6967), lang.NewKeyword("end-column"), int(52)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp10 := checkDerefVar(glojure_DOT_core_transient) + tmp11 := lang.NewVector() + tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6968), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(6968), lang.NewKeyword("end-column"), int(27)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp14 := lang.Apply(tmp10, []any{tmp13}) + tmp15 := lang.Apply(tmp6, []any{tmp9, tmp14, v4}) + tmp16 := lang.Apply(tmp5, []any{tmp15}) + return tmp16 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // find + { + tmp0 := lang.NewSymbol("find").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"))), lang.NewKeyword("doc"), "Returns the map entry for key, or nil if key not present.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1530), lang.NewKeyword("end-line"), int(1530))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(runtime7.RT, "Find") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Find is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // find-keyword + { + tmp1 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() + tmp0 := lang.NewSymbol("find-keyword").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name"))), lang.NewKeyword("doc"), "Returns a Keyword with the given namespace and name if one already\n exists. This function will not intern a new keyword. If the keyword\n has not already been interned, it will return nil. Do not use :\n in the keyword strings, it will be added automatically.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(618), lang.NewKeyword("end-line"), int(618))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(glojure_DOT_core_keyword_QMARK_) + tmp7 := lang.Apply(tmp6, []any{v4}) + if lang.IsTruthy(tmp7) { + tmp5 = v4 + } else { + var tmp8 any + tmp9 := checkDerefVar(glojure_DOT_core_symbol_QMARK_) + tmp10 := lang.Apply(tmp9, []any{v4}) + if lang.IsTruthy(tmp10) { + tmp11 := lang.Apply(nil, []any{v4}) + tmp8 = tmp11 + } else { + var tmp12 any + tmp13 := checkDerefVar(glojure_DOT_core_string_QMARK_) + tmp14 := lang.Apply(tmp13, []any{v4}) + if lang.IsTruthy(tmp14) { + tmp15 := lang.Apply(nil, []any{v4}) + tmp12 = tmp15 + } else { + } + tmp8 = tmp12 + } + tmp5 = tmp8 + } + return tmp5 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6 := lang.Apply(nil, []any{v4, v5}) + return tmp6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp4 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // find-ns + { + tmp0 := lang.NewSymbol("find-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Returns the namespace named by the symbol or nil if it doesn't exist.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4125), lang.NewKeyword("end-line"), int(4125))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.FindNamespace, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // find-var + { + tmp0 := lang.NewSymbol("find-var").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Returns the global var named by the namespace-qualified symbol, or\n nil if no var with that name.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2013), lang.NewKeyword("end-line"), int(2013))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(runtime7.RT, "FindVar") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("FindVar is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // first + { + tmp0 := lang.NewSymbol("first").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns the first item in the collection. Calls seq on its\n argument. If coll is nil, returns nil.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(47), lang.NewKeyword("end-line"), int(52))).(*lang.Symbol) + var tmp2 lang.FnFunc + { // function first + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5 := lang.Apply(lang.First, []any{v4}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(52), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(52), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + v3 = tmp2 + _ = v3 + } + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // fits-table? + { + tmp0 := lang.NewSymbol("fits-table?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ints"))), lang.NewKeyword("doc"), "Returns true if the collection of ints can fit within the\n max-table-switch-size, false otherwise.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6625), lang.NewKeyword("end-line"), int(6625), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core__LT_) + tmp5 := checkDerefVar(glojure_DOT_core__) + tmp6 := checkDerefVar(glojure_DOT_core_apply) + tmp7 := checkDerefVar(glojure_DOT_core_max) + tmp8 := checkDerefVar(glojure_DOT_core_seq) + tmp9 := lang.Apply(tmp8, []any{v3}) + tmp10 := lang.Apply(tmp6, []any{tmp7, tmp9}) + tmp11 := checkDerefVar(glojure_DOT_core_apply) + tmp12 := checkDerefVar(glojure_DOT_core_min) + tmp13 := checkDerefVar(glojure_DOT_core_seq) + tmp14 := lang.Apply(tmp13, []any{v3}) + tmp15 := lang.Apply(tmp11, []any{tmp12, tmp14}) + tmp16 := lang.Apply(tmp5, []any{tmp10, tmp15}) + tmp17 := checkDerefVar(glojure_DOT_core_max_switch_table_size) + tmp18 := lang.Apply(tmp4, []any{tmp16, tmp17}) + return tmp18 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // flatten + { + tmp0 := lang.NewSymbol("flatten").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Takes any nested combination of sequential things (lists, vectors,\n etc.) and returns their contents as a single, flat lazy sequence.\n (flatten nil) returns an empty sequence.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7118), lang.NewKeyword("end-line"), int(7118))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_filter) + tmp5 := checkDerefVar(glojure_DOT_core_complement) + tmp6 := checkDerefVar(glojure_DOT_core_sequential_QMARK_) + tmp7 := lang.Apply(tmp5, []any{tmp6}) + tmp8 := checkDerefVar(glojure_DOT_core_rest) + tmp9 := checkDerefVar(glojure_DOT_core_tree_seq) + tmp10 := checkDerefVar(glojure_DOT_core_sequential_QMARK_) + tmp11 := checkDerefVar(glojure_DOT_core_seq) + tmp12 := lang.Apply(tmp9, []any{tmp10, tmp11, v3}) + tmp13 := lang.Apply(tmp8, []any{tmp12}) + tmp14 := lang.Apply(tmp4, []any{tmp7, tmp13}) + return tmp14 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // float + { + var tmp1 lang.FnFunc + { // function float__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := checkDerefVar(glojure_DOT_core_seq) + tmp12 := checkDerefVar(glojure_DOT_core_concat) + tmp13 := checkDerefVar(glojure_DOT_core_list) + var tmp14 any + tmp15 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + if lang.IsTruthy(tmp15) { + tmp14 = lang.NewSymbol("uncheckedFloatCast") + } else { + tmp14 = lang.NewSymbol("floatCast") + } + tmp16 := lang.Apply(tmp13, []any{tmp14}) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := lang.Apply(tmp12, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp11, []any{tmp19}) + tmp21 := lang.Apply(tmp10, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("float").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to float", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3487), lang.NewKeyword("end-line"), int(3487))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5 := lang.Apply(lang.FloatCast, []any{v4}) + return tmp5 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // float-array + { + var tmp1 lang.FnFunc + { // function float-array__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol("glojure.core/FloatArray")}) + tmp12 := checkDerefVar(glojure_DOT_core_list) + tmp13 := checkDerefVar(glojure_DOT_core_seq) + tmp14 := checkDerefVar(glojure_DOT_core_concat) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("glojure.core/args")}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + } + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("float-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Creates an array of floats", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5301), lang.NewKeyword("end-line"), int(5301))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "FloatArray") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("FloatArray is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "FloatArrayInit") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("FloatArrayInit is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // float? + { + tmp0 := lang.NewSymbol("float?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is a floating point number", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3605), lang.NewKeyword("end-line"), int(3605))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + { // let + // let binding "or__0__auto__" + tmp5 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp6 := lang.Apply(tmp5, []any{lang.Builtins["float64"], v3}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + if lang.IsTruthy(v7) { + tmp8 = v7 + } else { + tmp9 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp10 := lang.Apply(tmp9, []any{lang.Builtins["float32"], v3}) + tmp8 = tmp10 + } + tmp4 = tmp8 + } // end let + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // floats + { + var tmp1 lang.FnFunc + { // function floats + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol("glojure.core/Floats")}) + tmp12 := checkDerefVar(glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("floats").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Casts to float[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5392), lang.NewKeyword("end-line"), int(5392))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Floats") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Floats is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // flush + { + tmp0 := lang.NewSymbol("flush").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Flushes the output stream that is the current value of\n *out*", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3706), lang.NewKeyword("end-line"), int(3706))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + tmp3 := checkDerefVar(glojure_DOT_core__STAR_out_STAR_) + tmp4, _ := lang.FieldOrMethod(tmp3, "Sync") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Sync is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{}) + _ = tmp5 + return nil + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // fn + { + tmp0 := lang.NewSymbol("fn").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("sigs"))), lang.NewKeyword("doc"), "params => positional-params*, or positional-params* & rest-param\n positional-param => binding-form\n rest-param => binding-form\n binding-form => name, or destructuring-form\n\n Defines a function.\n\n See https://glojure.org/reference/special_forms#fn for more information", lang.NewKeyword("forms"), lang.NewVector(lang.NewList(lang.NewSymbol("fn"), lang.NewSymbol("name?"), lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("exprs*")), lang.NewList(lang.NewSymbol("fn"), lang.NewSymbol("name?"), lang.NewList(lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("exprs*")), lang.NewSymbol("+"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4533), lang.NewKeyword("end-line"), int(4533), lang.NewKeyword("special-form"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + var tmp6 any + { // let + // let binding "name" + var tmp7 any + tmp8 := checkDerefVar(glojure_DOT_core_symbol_QMARK_) + tmp9 := checkDerefVar(glojure_DOT_core_first) + tmp10 := lang.Apply(tmp9, []any{v5}) + tmp11 := lang.Apply(tmp8, []any{tmp10}) + if lang.IsTruthy(tmp11) { + tmp12 := checkDerefVar(glojure_DOT_core_first) + tmp13 := lang.Apply(tmp12, []any{v5}) + tmp7 = tmp13 + } else { + } + var v14 any = tmp7 + _ = v14 + // let binding "sigs" + var tmp15 any + if lang.IsTruthy(v14) { + tmp16 := checkDerefVar(glojure_DOT_core_next) + tmp17 := lang.Apply(tmp16, []any{v5}) + tmp15 = tmp17 + } else { + tmp15 = v5 + } + var v18 any = tmp15 + _ = v18 + // let binding "sigs" + var tmp19 any + tmp20 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp21 := checkDerefVar(glojure_DOT_core_first) + tmp22 := lang.Apply(tmp21, []any{v18}) + tmp23 := lang.Apply(tmp20, []any{tmp22}) + if lang.IsTruthy(tmp23) { + tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v18}) + tmp19 = tmp25 + } else { + var tmp26 any + tmp27 := checkDerefVar(glojure_DOT_core_seq_QMARK_) + tmp28 := checkDerefVar(glojure_DOT_core_first) + tmp29 := lang.Apply(tmp28, []any{v18}) + tmp30 := lang.Apply(tmp27, []any{tmp29}) + if lang.IsTruthy(tmp30) { + tmp26 = v18 + } else { + var tmp31 any + tmp32 := checkDerefVar(glojure_DOT_core_seq) + tmp33 := lang.Apply(tmp32, []any{v18}) + if lang.IsTruthy(tmp33) { + tmp34 := checkDerefVar(glojure_DOT_core_str) + tmp35 := checkDerefVar(glojure_DOT_core_first) + tmp36 := lang.Apply(tmp35, []any{v18}) + tmp37 := lang.Apply(tmp34, []any{"Parameter declaration ", tmp36, " should be a vector"}) + tmp31 = tmp37 + } else { + tmp38 := checkDerefVar(glojure_DOT_core_str) + tmp39 := lang.Apply(tmp38, []any{"Parameter declaration missing"}) + tmp31 = tmp39 + } + tmp40 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp31}) + panic(tmp40) + } + tmp19 = tmp26 + } + var v41 any = tmp19 + _ = v41 + // let binding "psig" + var tmp42 lang.FnFunc + tmp42 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v43 := args[0] + _ = v43 + var tmp44 any + tmp45 := checkDerefVar(glojure_DOT_core_not) + tmp46 := checkDerefVar(glojure_DOT_core_seq_QMARK_) + tmp47 := lang.Apply(tmp46, []any{v43}) + tmp48 := lang.Apply(tmp45, []any{tmp47}) + if lang.IsTruthy(tmp48) { + tmp49 := checkDerefVar(glojure_DOT_core_str) + tmp50 := lang.Apply(tmp49, []any{"Invalid signature ", v43, " should be a list"}) + tmp51 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp50}) + panic(tmp51) + } else { + } + _ = tmp44 + var tmp52 any + { // let + // let binding "vec__13" + var v53 any = v43 + _ = v53 + // let binding "seq__14" + tmp54 := checkDerefVar(glojure_DOT_core_seq) + tmp55 := lang.Apply(tmp54, []any{v53}) + var v56 any = tmp55 + _ = v56 + // let binding "first__15" + tmp57 := checkDerefVar(glojure_DOT_core_first) + tmp58 := lang.Apply(tmp57, []any{v56}) + var v59 any = tmp58 + _ = v59 + // let binding "seq__14" + tmp60 := checkDerefVar(glojure_DOT_core_next) + tmp61 := lang.Apply(tmp60, []any{v56}) + var v62 any = tmp61 + _ = v62 + // let binding "params" + var v63 any = v59 + _ = v63 + // let binding "body" + var v64 any = v62 + _ = v64 + // let binding "_" + var tmp65 any + tmp66 := checkDerefVar(glojure_DOT_core_not) + tmp67 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp68 := lang.Apply(tmp67, []any{v63}) + tmp69 := lang.Apply(tmp66, []any{tmp68}) + if lang.IsTruthy(tmp69) { + var tmp70 any + tmp71 := checkDerefVar(glojure_DOT_core_seq_QMARK_) + tmp72 := checkDerefVar(glojure_DOT_core_first) + tmp73 := lang.Apply(tmp72, []any{v41}) + tmp74 := lang.Apply(tmp71, []any{tmp73}) + if lang.IsTruthy(tmp74) { + tmp75 := checkDerefVar(glojure_DOT_core_str) + tmp76 := lang.Apply(tmp75, []any{"Parameter declaration ", v63, " should be a vector"}) + tmp70 = tmp76 + } else { + tmp77 := checkDerefVar(glojure_DOT_core_str) + tmp78 := lang.Apply(tmp77, []any{"Invalid signature ", v43, " should be a list"}) + tmp70 = tmp78 + } + tmp79 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp70}) + panic(tmp79) + } else { + } + var v80 any = tmp65 + _ = v80 + // let binding "conds" + var tmp81 any + var tmp82 any + { // let + // let binding "and__0__auto__" + tmp83 := checkDerefVar(glojure_DOT_core_next) + tmp84 := lang.Apply(tmp83, []any{v64}) + var v85 any = tmp84 + _ = v85 + var tmp86 any + if lang.IsTruthy(v85) { + tmp87 := checkDerefVar(glojure_DOT_core_map_QMARK_) + tmp88 := checkDerefVar(glojure_DOT_core_first) + tmp89 := lang.Apply(tmp88, []any{v64}) + tmp90 := lang.Apply(tmp87, []any{tmp89}) + tmp86 = tmp90 + } else { + tmp86 = v85 + } + tmp82 = tmp86 + } // end let + if lang.IsTruthy(tmp82) { + tmp83 := checkDerefVar(glojure_DOT_core_first) + tmp84 := lang.Apply(tmp83, []any{v64}) + tmp81 = tmp84 + } else { + } + var v85 any = tmp81 + _ = v85 + // let binding "body" + var tmp86 any + if lang.IsTruthy(v85) { + tmp87 := checkDerefVar(glojure_DOT_core_next) + tmp88 := lang.Apply(tmp87, []any{v64}) + tmp86 = tmp88 + } else { + tmp86 = v64 + } + var v89 any = tmp86 + _ = v89 + // let binding "conds" + var tmp90 any + { // let + // let binding "or__0__auto__" + var v91 any = v85 + _ = v91 + var tmp92 any + if lang.IsTruthy(v91) { + tmp92 = v91 + } else { + tmp93 := checkDerefVar(glojure_DOT_core_meta) + tmp94 := lang.Apply(tmp93, []any{v63}) + tmp92 = tmp94 + } + tmp90 = tmp92 + } // end let + var v91 any = tmp90 + _ = v91 + // let binding "pre" + tmp92 := lang.Apply(lang.NewKeyword("pre"), []any{v91}) + var v93 any = tmp92 + _ = v93 + // let binding "post" + tmp94 := lang.Apply(lang.NewKeyword("post"), []any{v91}) + var v95 any = tmp94 + _ = v95 + // let binding "body" + var tmp96 any + if lang.IsTruthy(v95) { + tmp97 := checkDerefVar(glojure_DOT_core_seq) + tmp98 := checkDerefVar(glojure_DOT_core_concat) + tmp99 := checkDerefVar(glojure_DOT_core_list) + tmp100 := checkDerefVar(glojure_DOT_core_seq) + tmp101 := checkDerefVar(glojure_DOT_core_concat) + tmp102 := checkDerefVar(glojure_DOT_core_list) + tmp103 := lang.Apply(tmp102, []any{lang.NewSymbol("glojure.core/let")}) + tmp104 := checkDerefVar(glojure_DOT_core_list) + tmp105 := checkDerefVar(glojure_DOT_core_apply) + tmp106 := checkDerefVar(glojure_DOT_core_vector) + tmp107 := checkDerefVar(glojure_DOT_core_seq) + tmp108 := checkDerefVar(glojure_DOT_core_concat) + tmp109 := checkDerefVar(glojure_DOT_core_list) + tmp110 := lang.Apply(tmp109, []any{lang.NewSymbol("%")}) + tmp111 := checkDerefVar(glojure_DOT_core_list) + var tmp112 any + tmp113 := checkDerefVar(glojure_DOT_core__LT_) + tmp114 := checkDerefVar(glojure_DOT_core_count) + tmp115 := lang.Apply(tmp114, []any{v89}) + tmp116 := lang.Apply(tmp113, []any{int64(1), tmp115}) + if lang.IsTruthy(tmp116) { + tmp117 := checkDerefVar(glojure_DOT_core_seq) + tmp118 := checkDerefVar(glojure_DOT_core_concat) + tmp119 := checkDerefVar(glojure_DOT_core_list) + tmp120 := lang.Apply(tmp119, []any{lang.NewSymbol("do")}) + tmp121 := lang.Apply(tmp118, []any{tmp120, v89}) + tmp122 := lang.Apply(tmp117, []any{tmp121}) + tmp112 = tmp122 + } else { + tmp123 := checkDerefVar(glojure_DOT_core_first) + tmp124 := lang.Apply(tmp123, []any{v89}) + tmp112 = tmp124 + } + tmp125 := lang.Apply(tmp111, []any{tmp112}) + tmp126 := lang.Apply(tmp108, []any{tmp110, tmp125}) + tmp127 := lang.Apply(tmp107, []any{tmp126}) + tmp128 := lang.Apply(tmp105, []any{tmp106, tmp127}) + tmp129 := lang.Apply(tmp104, []any{tmp128}) + tmp130 := checkDerefVar(glojure_DOT_core_map) + var tmp131 lang.FnFunc + tmp131 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v132 := args[0] + _ = v132 + tmp133 := checkDerefVar(glojure_DOT_core_seq) + tmp134 := checkDerefVar(glojure_DOT_core_concat) + tmp135 := checkDerefVar(glojure_DOT_core_list) + tmp136 := lang.Apply(tmp135, []any{lang.NewSymbol("glojure.core/assert")}) + tmp137 := checkDerefVar(glojure_DOT_core_list) + tmp138 := lang.Apply(tmp137, []any{v132}) + tmp139 := lang.Apply(tmp134, []any{tmp136, tmp138}) + tmp140 := lang.Apply(tmp133, []any{tmp139}) + return tmp140 + }) + tmp132 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4582), lang.NewKeyword("column"), int(41), lang.NewKeyword("end-line"), int(4582), lang.NewKeyword("end-column"), int(62)) + tmp133, err := lang.WithMeta(tmp131, tmp132.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp134 := lang.Apply(tmp130, []any{tmp133, v95}) + tmp135 := checkDerefVar(glojure_DOT_core_list) + tmp136 := lang.Apply(tmp135, []any{lang.NewSymbol("%")}) + tmp137 := lang.Apply(tmp101, []any{tmp103, tmp129, tmp134, tmp136}) + tmp138 := lang.Apply(tmp100, []any{tmp137}) + tmp139 := lang.Apply(tmp99, []any{tmp138}) + tmp140 := lang.Apply(tmp98, []any{tmp139}) + tmp141 := lang.Apply(tmp97, []any{tmp140}) + tmp96 = tmp141 + } else { + tmp96 = v89 + } + var v142 any = tmp96 + _ = v142 + // let binding "body" + var tmp143 any + if lang.IsTruthy(v93) { + tmp144 := checkDerefVar(glojure_DOT_core_concat) + tmp145 := checkDerefVar(glojure_DOT_core_map) + var tmp146 lang.FnFunc + tmp146 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v147 := args[0] + _ = v147 + tmp148 := checkDerefVar(glojure_DOT_core_seq) + tmp149 := checkDerefVar(glojure_DOT_core_concat) + tmp150 := checkDerefVar(glojure_DOT_core_list) + tmp151 := lang.Apply(tmp150, []any{lang.NewSymbol("glojure.core/assert")}) + tmp152 := checkDerefVar(glojure_DOT_core_list) + tmp153 := lang.Apply(tmp152, []any{v147}) + tmp154 := lang.Apply(tmp149, []any{tmp151, tmp153}) + tmp155 := lang.Apply(tmp148, []any{tmp154}) + return tmp155 + }) + tmp147 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4586), lang.NewKeyword("column"), int(44), lang.NewKeyword("end-line"), int(4586), lang.NewKeyword("end-column"), int(65)) + tmp148, err := lang.WithMeta(tmp146, tmp147.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp149 := lang.Apply(tmp145, []any{tmp148, v93}) + tmp150 := lang.Apply(tmp144, []any{tmp149, v142}) + tmp143 = tmp150 + } else { + tmp143 = v142 + } + var v151 any = tmp143 + _ = v151 + tmp152 := checkDerefVar(glojure_DOT_core_maybe_destructured) + tmp153 := lang.Apply(tmp152, []any{v63, v151}) + tmp52 = tmp153 + } // end let + return tmp52 + }) + tmp43 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4558), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(4589), lang.NewKeyword("end-column"), int(53)) + tmp44, err := lang.WithMeta(tmp42, tmp43.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v45 any = tmp44 + _ = v45 + // let binding "new-sigs" + tmp46 := checkDerefVar(glojure_DOT_core_map) + tmp47 := lang.Apply(tmp46, []any{v45, v41}) + var v48 any = tmp47 + _ = v48 + tmp49 := checkDerefVar(glojure_DOT_core_with_meta) + var tmp50 any + if lang.IsTruthy(v14) { + tmp51 := checkDerefVar(glojure_DOT_core_list_STAR_) + tmp52 := lang.Apply(tmp51, []any{lang.NewSymbol("fn*"), v14, v48}) + tmp50 = tmp52 + } else { + tmp53 := checkDerefVar(glojure_DOT_core_cons) + tmp54 := lang.Apply(tmp53, []any{lang.NewSymbol("fn*"), v48}) + tmp50 = tmp54 + } + tmp55 := checkDerefVar(glojure_DOT_core_meta) + tmp56 := lang.Apply(tmp55, []any{v3}) + tmp57 := lang.Apply(tmp49, []any{tmp50, tmp56}) + tmp6 = tmp57 + } // end let + return tmp6 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // fn? + { + tmp0 := lang.NewSymbol("fn?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements Fn, i.e. is an object created via fn.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6216), lang.NewKeyword("end-line"), int(6216))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp5 := reflect.TypeOf((*runtime7.Fn)(nil)) + tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // fnext + { + tmp0 := lang.NewSymbol("fnext").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Same as (first (next x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(112), lang.NewKeyword("end-line"), int(116))).(*lang.Symbol) + var tmp2 lang.FnFunc + { // function fnext + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_first) + tmp6 := checkDerefVar(glojure_DOT_core_next) + tmp7 := lang.Apply(tmp6, []any{v4}) + tmp8 := lang.Apply(tmp5, []any{tmp7}) + return tmp8 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(116), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(116), lang.NewKeyword("end-column"), int(47))).(lang.FnFunc) + v3 = tmp2 + _ = v3 + } + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // fnil + { + tmp0 := lang.NewSymbol("fnil").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("z"))), lang.NewKeyword("doc"), "Takes a function f, and returns a function that calls f, replacing\n a nil first argument to f with the supplied value x. Higher arity\n versions can replace arguments in the second and third\n positions (y, z). Note that the function f can take any number of\n arguments, not just the one(s) being nil-patched.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6558), lang.NewKeyword("end-line"), int(6558))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v6 := args[0] + _ = v6 + var tmp7 any + tmp8 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp9 := lang.Apply(tmp8, []any{v6}) + if lang.IsTruthy(tmp9) { + tmp7 = v4 + } else { + tmp7 = v6 + } + tmp10 := lang.Apply(v3, []any{tmp7}) + return tmp10 + case 2: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + var tmp8 any + tmp9 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp10 := lang.Apply(tmp9, []any{v6}) + if lang.IsTruthy(tmp10) { + tmp8 = v4 + } else { + tmp8 = v6 + } + tmp11 := lang.Apply(v3, []any{tmp8, v7}) + return tmp11 + case 3: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + var tmp9 any + tmp10 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp11 := lang.Apply(tmp10, []any{v6}) + if lang.IsTruthy(tmp11) { + tmp9 = v4 + } else { + tmp9 = v6 + } + tmp12 := lang.Apply(v3, []any{tmp9, v7, v8}) + return tmp12 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + var v9 any = lang.NewList(args[3:]...) + _ = v9 + tmp10 := checkDerefVar(glojure_DOT_core_apply) + var tmp11 any + tmp12 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp13 := lang.Apply(tmp12, []any{v6}) + if lang.IsTruthy(tmp13) { + tmp11 = v4 + } else { + tmp11 = v6 + } + tmp14 := lang.Apply(tmp10, []any{v3, tmp11, v7, v8, v9}) + return tmp14 + } + }) + tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6567), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(6571), lang.NewKeyword("end-column"), int(55)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp7 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + var tmp9 any + tmp10 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp11 := lang.Apply(tmp10, []any{v7}) + if lang.IsTruthy(tmp11) { + tmp9 = v4 + } else { + tmp9 = v7 + } + var tmp12 any + tmp13 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp14 := lang.Apply(tmp13, []any{v8}) + if lang.IsTruthy(tmp14) { + tmp12 = v5 + } else { + tmp12 = v8 + } + tmp15 := lang.Apply(v3, []any{tmp9, tmp12}) + return tmp15 + case 3: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + var tmp10 any + tmp11 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp12 := lang.Apply(tmp11, []any{v7}) + if lang.IsTruthy(tmp12) { + tmp10 = v4 + } else { + tmp10 = v7 + } + var tmp13 any + tmp14 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp15 := lang.Apply(tmp14, []any{v8}) + if lang.IsTruthy(tmp15) { + tmp13 = v5 + } else { + tmp13 = v8 + } + tmp16 := lang.Apply(v3, []any{tmp10, tmp13, v9}) + return tmp16 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + var v10 any = lang.NewList(args[3:]...) + _ = v10 + tmp11 := checkDerefVar(glojure_DOT_core_apply) + var tmp12 any + tmp13 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp14 := lang.Apply(tmp13, []any{v7}) + if lang.IsTruthy(tmp14) { + tmp12 = v4 + } else { + tmp12 = v7 + } + var tmp15 any + tmp16 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp17 := lang.Apply(tmp16, []any{v8}) + if lang.IsTruthy(tmp17) { + tmp15 = v5 + } else { + tmp15 = v8 + } + tmp18 := lang.Apply(tmp11, []any{v3, tmp12, tmp15, v9, v10}) + return tmp18 + } + }) + tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6573), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(6576), lang.NewKeyword("end-column"), int(71)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp8 + case 4: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + var tmp10 any + tmp11 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp12 := lang.Apply(tmp11, []any{v8}) + if lang.IsTruthy(tmp12) { + tmp10 = v4 + } else { + tmp10 = v8 + } + var tmp13 any + tmp14 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp15 := lang.Apply(tmp14, []any{v9}) + if lang.IsTruthy(tmp15) { + tmp13 = v5 + } else { + tmp13 = v9 + } + tmp16 := lang.Apply(v3, []any{tmp10, tmp13}) + return tmp16 + case 3: + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + v10 := args[2] + _ = v10 + var tmp11 any + tmp12 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp13 := lang.Apply(tmp12, []any{v8}) + if lang.IsTruthy(tmp13) { + tmp11 = v4 + } else { + tmp11 = v8 + } + var tmp14 any + tmp15 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp16 := lang.Apply(tmp15, []any{v9}) + if lang.IsTruthy(tmp16) { + tmp14 = v5 + } else { + tmp14 = v9 + } + var tmp17 any + tmp18 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp19 := lang.Apply(tmp18, []any{v10}) + if lang.IsTruthy(tmp19) { + tmp17 = v6 + } else { + tmp17 = v10 + } + tmp20 := lang.Apply(v3, []any{tmp11, tmp14, tmp17}) + return tmp20 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + v10 := args[2] + _ = v10 + var v11 any = lang.NewList(args[3:]...) + _ = v11 + tmp12 := checkDerefVar(glojure_DOT_core_apply) + var tmp13 any + tmp14 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp15 := lang.Apply(tmp14, []any{v8}) + if lang.IsTruthy(tmp15) { + tmp13 = v4 + } else { + tmp13 = v8 + } + var tmp16 any + tmp17 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp18 := lang.Apply(tmp17, []any{v9}) + if lang.IsTruthy(tmp18) { + tmp16 = v5 + } else { + tmp16 = v9 + } + var tmp19 any + tmp20 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp21 := lang.Apply(tmp20, []any{v10}) + if lang.IsTruthy(tmp21) { + tmp19 = v6 + } else { + tmp19 = v10 + } + tmp22 := lang.Apply(tmp12, []any{v3, tmp13, tmp16, tmp19, v11}) + return tmp22 + } + }) + tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6578), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(6581), lang.NewKeyword("end-column"), int(87)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp9 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // for + { + tmp0 := lang.NewSymbol("for").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("seq-exprs"), lang.NewSymbol("body-expr"))), lang.NewKeyword("doc"), "List comprehension. Takes a vector of one or more\n binding-form/collection-expr pairs, each followed by zero or more\n modifiers, and yields a lazy sequence of evaluations of expr.\n Collections are iterated in a nested fashion, rightmost fastest,\n and nested coll-exprs can refer to bindings created in prior\n binding-forms. Supported modifiers are: :let [binding-form expr ...],\n :while test, :when test.\n\n (take 100 (for [x (range 100000000) y (range 1000000) :while (< y x)] [x y]))", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4646), lang.NewKeyword("end-line"), int(4646))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + var tmp7 any + tmp8 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp9 := lang.Apply(tmp8, []any{v5}) + if lang.IsTruthy(tmp9) { + } else { + tmp10 := checkDerefVar(glojure_DOT_core_str) + tmp11 := checkDerefVar(glojure_DOT_core_first) + tmp12 := lang.Apply(tmp11, []any{v3}) + tmp13 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) + tmp14 := checkDerefVar(glojure_DOT_core_meta) + tmp15 := lang.Apply(tmp14, []any{v3}) + tmp16 := lang.Apply(lang.NewKeyword("line"), []any{tmp15}) + tmp17 := lang.Apply(tmp10, []any{tmp12, " requires ", "a vector for its binding", " in ", tmp13, ":", tmp16}) + tmp18 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp17}) + panic(tmp18) + } + _ = tmp7 + var tmp19 any + tmp20 := checkDerefVar(glojure_DOT_core_even_QMARK_) + tmp21 := checkDerefVar(glojure_DOT_core_count) + tmp22 := lang.Apply(tmp21, []any{v5}) + tmp23 := lang.Apply(tmp20, []any{tmp22}) + if lang.IsTruthy(tmp23) { + } else { + tmp24 := checkDerefVar(glojure_DOT_core_str) + tmp25 := checkDerefVar(glojure_DOT_core_first) + tmp26 := lang.Apply(tmp25, []any{v3}) + tmp27 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) + tmp28 := checkDerefVar(glojure_DOT_core_meta) + tmp29 := lang.Apply(tmp28, []any{v3}) + tmp30 := lang.Apply(lang.NewKeyword("line"), []any{tmp29}) + tmp31 := lang.Apply(tmp24, []any{tmp26, " requires ", "an even number of forms in binding vector", " in ", tmp27, ":", tmp30}) + tmp32 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp31}) + panic(tmp32) + } + _ = tmp19 + var tmp33 any + { // let + // let binding "to-groups" + var tmp34 lang.FnFunc + tmp34 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v35 := args[0] + _ = v35 + tmp36 := checkDerefVar(glojure_DOT_core_reduce1) + var tmp37 lang.FnFunc + tmp37 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v38 := args[0] + _ = v38 + v39 := args[1] + _ = v39 + var tmp40 any + { // let + // let binding "vec__24" + var v41 any = v39 + _ = v41 + // let binding "k" + tmp42 := checkDerefVar(glojure_DOT_core_nth) + tmp43 := lang.Apply(tmp42, []any{v41, int64(0), nil}) + var v44 any = tmp43 + _ = v44 + // let binding "v" + tmp45 := checkDerefVar(glojure_DOT_core_nth) + tmp46 := lang.Apply(tmp45, []any{v41, int64(1), nil}) + var v47 any = tmp46 + _ = v47 + var tmp48 any + tmp49 := checkDerefVar(glojure_DOT_core_keyword_QMARK_) + tmp50 := lang.Apply(tmp49, []any{v44}) + if lang.IsTruthy(tmp50) { + tmp51 := checkDerefVar(glojure_DOT_core_conj) + tmp52 := checkDerefVar(glojure_DOT_core_pop) + tmp53 := lang.Apply(tmp52, []any{v38}) + tmp54 := checkDerefVar(glojure_DOT_core_conj) + tmp55 := checkDerefVar(glojure_DOT_core_peek) + tmp56 := lang.Apply(tmp55, []any{v38}) + tmp57 := lang.NewVector(v44, v47) + tmp58 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4664), lang.NewKeyword("column"), int(72), lang.NewKeyword("end-line"), int(4664), lang.NewKeyword("end-column"), int(76)) + tmp59, err := lang.WithMeta(tmp57, tmp58.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp60 := lang.Apply(tmp54, []any{tmp56, tmp59}) + tmp61 := lang.Apply(tmp51, []any{tmp53, tmp60}) + tmp48 = tmp61 + } else { + tmp62 := checkDerefVar(glojure_DOT_core_conj) + tmp63 := lang.NewVector(v44, v47) + tmp64 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4665), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(4665), lang.NewKeyword("end-column"), int(50)) + tmp65, err := lang.WithMeta(tmp63, tmp64.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp66 := lang.Apply(tmp62, []any{v38, tmp65}) + tmp48 = tmp66 + } + tmp40 = tmp48 + } // end let + return tmp40 + }) + tmp38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4662), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(4665), lang.NewKeyword("end-column"), int(53)) + tmp39, err := lang.WithMeta(tmp37, tmp38.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp40 := lang.NewVector() + tmp41 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4666), lang.NewKeyword("column"), int(29), lang.NewKeyword("end-line"), int(4666), lang.NewKeyword("end-column"), int(30)) + tmp42, err := lang.WithMeta(tmp40, tmp41.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp43 := checkDerefVar(glojure_DOT_core_partition) + tmp44 := lang.Apply(tmp43, []any{int64(2), v35}) + tmp45 := lang.Apply(tmp36, []any{tmp39, tmp42, tmp44}) + return tmp45 + }) + tmp35 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4661), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(4666), lang.NewKeyword("end-column"), int(56)) + tmp36, err := lang.WithMeta(tmp34, tmp35.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v37 any = tmp36 + _ = v37 + // let binding "err" + var tmp38 lang.FnFunc + tmp38 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v39 any = lang.NewList(args[0:]...) + _ = v39 + tmp40 := checkDerefVar(glojure_DOT_core_apply) + tmp41 := checkDerefVar(glojure_DOT_core_str) + tmp42 := lang.Apply(tmp40, []any{tmp41, v39}) + tmp43 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp42}) + panic(tmp43) + } + }) + tmp39 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4667), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(4667), lang.NewKeyword("end-column"), int(125)) + tmp40, err := lang.WithMeta(tmp38, tmp39.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v41 any = tmp40 + _ = v41 + // let binding "emit-bind" + var tmp42 lang.FnFunc + { // function emit-bind + var v43 lang.FnFunc + tmp42 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v44 := args[0] + _ = v44 + var tmp45 any + { // let + // let binding "vec__28" + var v46 any = v44 + _ = v46 + // let binding "seq__29" + tmp47 := checkDerefVar(glojure_DOT_core_seq) + tmp48 := lang.Apply(tmp47, []any{v46}) + var v49 any = tmp48 + _ = v49 + // let binding "first__30" + tmp50 := checkDerefVar(glojure_DOT_core_first) + tmp51 := lang.Apply(tmp50, []any{v49}) + var v52 any = tmp51 + _ = v52 + // let binding "seq__29" + tmp53 := checkDerefVar(glojure_DOT_core_next) + tmp54 := lang.Apply(tmp53, []any{v49}) + var v55 any = tmp54 + _ = v55 + // let binding "vec__31" + var v56 any = v52 + _ = v56 + // let binding "seq__32" + tmp57 := checkDerefVar(glojure_DOT_core_seq) + tmp58 := lang.Apply(tmp57, []any{v56}) + var v59 any = tmp58 + _ = v59 + // let binding "first__33" + tmp60 := checkDerefVar(glojure_DOT_core_first) + tmp61 := lang.Apply(tmp60, []any{v59}) + var v62 any = tmp61 + _ = v62 + // let binding "seq__32" + tmp63 := checkDerefVar(glojure_DOT_core_next) + tmp64 := lang.Apply(tmp63, []any{v59}) + var v65 any = tmp64 + _ = v65 + // let binding "bind" + var v66 any = v62 + _ = v66 + // let binding "first__33" + tmp67 := checkDerefVar(glojure_DOT_core_first) + tmp68 := lang.Apply(tmp67, []any{v65}) + var v69 any = tmp68 + _ = v69 + // let binding "seq__32" + tmp70 := checkDerefVar(glojure_DOT_core_next) + tmp71 := lang.Apply(tmp70, []any{v65}) + var v72 any = tmp71 + _ = v72 + // let binding "expr" + var v73 any = v69 + _ = v73 + // let binding "mod-pairs" + var v74 any = v72 + _ = v74 + // let binding "vec__34" + var v75 any = v55 + _ = v75 + // let binding "vec__37" + tmp76 := checkDerefVar(glojure_DOT_core_nth) + tmp77 := lang.Apply(tmp76, []any{v75, int64(0), nil}) + var v78 any = tmp77 + _ = v78 + // let binding "_" + tmp79 := checkDerefVar(glojure_DOT_core_nth) + tmp80 := lang.Apply(tmp79, []any{v78, int64(0), nil}) + var v81 any = tmp80 + _ = v81 + // let binding "next-expr" + tmp82 := checkDerefVar(glojure_DOT_core_nth) + tmp83 := lang.Apply(tmp82, []any{v78, int64(1), nil}) + var v84 any = tmp83 + _ = v84 + // let binding "next-groups" + var v85 any = v75 + _ = v85 + var tmp86 any + { // let + // let binding "giter" + tmp87 := checkDerefVar(glojure_DOT_core_gensym) + tmp88 := lang.Apply(tmp87, []any{"iter__"}) + var v89 any = tmp88 + _ = v89 + // let binding "gxs" + tmp90 := checkDerefVar(glojure_DOT_core_gensym) + tmp91 := lang.Apply(tmp90, []any{"s__"}) + var v92 any = tmp91 + _ = v92 + // let binding "do-mod" + var tmp93 lang.FnFunc + { // function do-mod + var v94 lang.FnFunc + tmp93 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v95 := args[0] + _ = v95 + var tmp96 any + { // let + // let binding "vec__41" + var v97 any = v95 + _ = v97 + // let binding "seq__42" + tmp98 := checkDerefVar(glojure_DOT_core_seq) + tmp99 := lang.Apply(tmp98, []any{v97}) + var v100 any = tmp99 + _ = v100 + // let binding "first__43" + tmp101 := checkDerefVar(glojure_DOT_core_first) + tmp102 := lang.Apply(tmp101, []any{v100}) + var v103 any = tmp102 + _ = v103 + // let binding "seq__42" + tmp104 := checkDerefVar(glojure_DOT_core_next) + tmp105 := lang.Apply(tmp104, []any{v100}) + var v106 any = tmp105 + _ = v106 + // let binding "vec__44" + var v107 any = v103 + _ = v107 + // let binding "k" + tmp108 := checkDerefVar(glojure_DOT_core_nth) + tmp109 := lang.Apply(tmp108, []any{v107, int64(0), nil}) + var v110 any = tmp109 + _ = v110 + // let binding "v" + tmp111 := checkDerefVar(glojure_DOT_core_nth) + tmp112 := lang.Apply(tmp111, []any{v107, int64(1), nil}) + var v113 any = tmp112 + _ = v113 + // let binding "pair" + var v114 any = v107 + _ = v114 + // let binding "etc" + var v115 any = v106 + _ = v115 + var tmp116 any + tmp117 := checkDerefVar(glojure_DOT_core__EQ_) + tmp118 := lang.Apply(tmp117, []any{v110, lang.NewKeyword("let")}) + if lang.IsTruthy(tmp118) { + tmp119 := checkDerefVar(glojure_DOT_core_seq) + tmp120 := checkDerefVar(glojure_DOT_core_concat) + tmp121 := checkDerefVar(glojure_DOT_core_list) + tmp122 := lang.Apply(tmp121, []any{lang.NewSymbol("glojure.core/let")}) + tmp123 := checkDerefVar(glojure_DOT_core_list) + tmp124 := lang.Apply(tmp123, []any{v113}) + tmp125 := checkDerefVar(glojure_DOT_core_list) + tmp126 := lang.Apply(v94, []any{v115}) + tmp127 := lang.Apply(tmp125, []any{tmp126}) + tmp128 := lang.Apply(tmp120, []any{tmp122, tmp124, tmp127}) + tmp129 := lang.Apply(tmp119, []any{tmp128}) + tmp116 = tmp129 + } else { + var tmp130 any + tmp131 := checkDerefVar(glojure_DOT_core__EQ_) + tmp132 := lang.Apply(tmp131, []any{v110, lang.NewKeyword("while")}) + if lang.IsTruthy(tmp132) { + tmp133 := checkDerefVar(glojure_DOT_core_seq) + tmp134 := checkDerefVar(glojure_DOT_core_concat) + tmp135 := checkDerefVar(glojure_DOT_core_list) + tmp136 := lang.Apply(tmp135, []any{lang.NewSymbol("glojure.core/when")}) + tmp137 := checkDerefVar(glojure_DOT_core_list) + tmp138 := lang.Apply(tmp137, []any{v113}) + tmp139 := checkDerefVar(glojure_DOT_core_list) + tmp140 := lang.Apply(v94, []any{v115}) + tmp141 := lang.Apply(tmp139, []any{tmp140}) + tmp142 := lang.Apply(tmp134, []any{tmp136, tmp138, tmp141}) + tmp143 := lang.Apply(tmp133, []any{tmp142}) + tmp130 = tmp143 + } else { + var tmp144 any + tmp145 := checkDerefVar(glojure_DOT_core__EQ_) + tmp146 := lang.Apply(tmp145, []any{v110, lang.NewKeyword("when")}) + if lang.IsTruthy(tmp146) { + tmp147 := checkDerefVar(glojure_DOT_core_seq) + tmp148 := checkDerefVar(glojure_DOT_core_concat) + tmp149 := checkDerefVar(glojure_DOT_core_list) + tmp150 := lang.Apply(tmp149, []any{lang.NewSymbol("if")}) + tmp151 := checkDerefVar(glojure_DOT_core_list) + tmp152 := lang.Apply(tmp151, []any{v113}) + tmp153 := checkDerefVar(glojure_DOT_core_list) + tmp154 := lang.Apply(v94, []any{v115}) + tmp155 := lang.Apply(tmp153, []any{tmp154}) + tmp156 := checkDerefVar(glojure_DOT_core_list) + tmp157 := checkDerefVar(glojure_DOT_core_seq) + tmp158 := checkDerefVar(glojure_DOT_core_concat) + tmp159 := checkDerefVar(glojure_DOT_core_list) + tmp160 := lang.Apply(tmp159, []any{lang.NewSymbol("recur")}) + tmp161 := checkDerefVar(glojure_DOT_core_list) + tmp162 := checkDerefVar(glojure_DOT_core_seq) + tmp163 := checkDerefVar(glojure_DOT_core_concat) + tmp164 := checkDerefVar(glojure_DOT_core_list) + tmp165 := lang.Apply(tmp164, []any{lang.NewSymbol("glojure.core/rest")}) + tmp166 := checkDerefVar(glojure_DOT_core_list) + tmp167 := lang.Apply(tmp166, []any{v92}) + tmp168 := lang.Apply(tmp163, []any{tmp165, tmp167}) + tmp169 := lang.Apply(tmp162, []any{tmp168}) + tmp170 := lang.Apply(tmp161, []any{tmp169}) + tmp171 := lang.Apply(tmp158, []any{tmp160, tmp170}) + tmp172 := lang.Apply(tmp157, []any{tmp171}) + tmp173 := lang.Apply(tmp156, []any{tmp172}) + tmp174 := lang.Apply(tmp148, []any{tmp150, tmp152, tmp155, tmp173}) + tmp175 := lang.Apply(tmp147, []any{tmp174}) + tmp144 = tmp175 + } else { + var tmp176 any + tmp177 := checkDerefVar(glojure_DOT_core_keyword_QMARK_) + tmp178 := lang.Apply(tmp177, []any{v110}) + if lang.IsTruthy(tmp178) { + tmp179 := lang.Apply(v41, []any{"Invalid 'for' keyword ", v110}) + tmp176 = tmp179 + } else { + var tmp180 any + if lang.IsTruthy(v85) { + tmp181 := checkDerefVar(glojure_DOT_core_seq) + tmp182 := checkDerefVar(glojure_DOT_core_concat) + tmp183 := checkDerefVar(glojure_DOT_core_list) + tmp184 := lang.Apply(tmp183, []any{lang.NewSymbol("glojure.core/let")}) + tmp185 := checkDerefVar(glojure_DOT_core_list) + tmp186 := checkDerefVar(glojure_DOT_core_apply) + tmp187 := checkDerefVar(glojure_DOT_core_vector) + tmp188 := checkDerefVar(glojure_DOT_core_seq) + tmp189 := checkDerefVar(glojure_DOT_core_concat) + tmp190 := checkDerefVar(glojure_DOT_core_list) + tmp191 := lang.Apply(tmp190, []any{lang.NewSymbol("iterys__0__auto__")}) + tmp192 := checkDerefVar(glojure_DOT_core_list) + tmp193 := lang.Apply(v43, []any{v85}) + tmp194 := lang.Apply(tmp192, []any{tmp193}) + tmp195 := checkDerefVar(glojure_DOT_core_list) + tmp196 := lang.Apply(tmp195, []any{lang.NewSymbol("fs__1__auto__")}) + tmp197 := checkDerefVar(glojure_DOT_core_list) + tmp198 := checkDerefVar(glojure_DOT_core_seq) + tmp199 := checkDerefVar(glojure_DOT_core_concat) + tmp200 := checkDerefVar(glojure_DOT_core_list) + tmp201 := lang.Apply(tmp200, []any{lang.NewSymbol("glojure.core/seq")}) + tmp202 := checkDerefVar(glojure_DOT_core_list) + tmp203 := checkDerefVar(glojure_DOT_core_seq) + tmp204 := checkDerefVar(glojure_DOT_core_concat) + tmp205 := checkDerefVar(glojure_DOT_core_list) + tmp206 := lang.Apply(tmp205, []any{lang.NewSymbol("iterys__0__auto__")}) + tmp207 := checkDerefVar(glojure_DOT_core_list) + tmp208 := lang.Apply(tmp207, []any{v84}) + tmp209 := lang.Apply(tmp204, []any{tmp206, tmp208}) + tmp210 := lang.Apply(tmp203, []any{tmp209}) + tmp211 := lang.Apply(tmp202, []any{tmp210}) + tmp212 := lang.Apply(tmp199, []any{tmp201, tmp211}) + tmp213 := lang.Apply(tmp198, []any{tmp212}) + tmp214 := lang.Apply(tmp197, []any{tmp213}) + tmp215 := lang.Apply(tmp189, []any{tmp191, tmp194, tmp196, tmp214}) + tmp216 := lang.Apply(tmp188, []any{tmp215}) + tmp217 := lang.Apply(tmp186, []any{tmp187, tmp216}) + tmp218 := lang.Apply(tmp185, []any{tmp217}) + tmp219 := checkDerefVar(glojure_DOT_core_list) + tmp220 := checkDerefVar(glojure_DOT_core_seq) + tmp221 := checkDerefVar(glojure_DOT_core_concat) + tmp222 := checkDerefVar(glojure_DOT_core_list) + tmp223 := lang.Apply(tmp222, []any{lang.NewSymbol("if")}) + tmp224 := checkDerefVar(glojure_DOT_core_list) + tmp225 := lang.Apply(tmp224, []any{lang.NewSymbol("fs__1__auto__")}) + tmp226 := checkDerefVar(glojure_DOT_core_list) + tmp227 := checkDerefVar(glojure_DOT_core_seq) + tmp228 := checkDerefVar(glojure_DOT_core_concat) + tmp229 := checkDerefVar(glojure_DOT_core_list) + tmp230 := lang.Apply(tmp229, []any{lang.NewSymbol("glojure.core/concat")}) + tmp231 := checkDerefVar(glojure_DOT_core_list) + tmp232 := lang.Apply(tmp231, []any{lang.NewSymbol("fs__1__auto__")}) + tmp233 := checkDerefVar(glojure_DOT_core_list) + tmp234 := checkDerefVar(glojure_DOT_core_seq) + tmp235 := checkDerefVar(glojure_DOT_core_concat) + tmp236 := checkDerefVar(glojure_DOT_core_list) + tmp237 := lang.Apply(tmp236, []any{v89}) + tmp238 := checkDerefVar(glojure_DOT_core_list) + tmp239 := checkDerefVar(glojure_DOT_core_seq) + tmp240 := checkDerefVar(glojure_DOT_core_concat) + tmp241 := checkDerefVar(glojure_DOT_core_list) + tmp242 := lang.Apply(tmp241, []any{lang.NewSymbol("glojure.core/rest")}) + tmp243 := checkDerefVar(glojure_DOT_core_list) + tmp244 := lang.Apply(tmp243, []any{v92}) + tmp245 := lang.Apply(tmp240, []any{tmp242, tmp244}) + tmp246 := lang.Apply(tmp239, []any{tmp245}) + tmp247 := lang.Apply(tmp238, []any{tmp246}) + tmp248 := lang.Apply(tmp235, []any{tmp237, tmp247}) + tmp249 := lang.Apply(tmp234, []any{tmp248}) + tmp250 := lang.Apply(tmp233, []any{tmp249}) + tmp251 := lang.Apply(tmp228, []any{tmp230, tmp232, tmp250}) + tmp252 := lang.Apply(tmp227, []any{tmp251}) + tmp253 := lang.Apply(tmp226, []any{tmp252}) + tmp254 := checkDerefVar(glojure_DOT_core_list) + tmp255 := checkDerefVar(glojure_DOT_core_seq) + tmp256 := checkDerefVar(glojure_DOT_core_concat) + tmp257 := checkDerefVar(glojure_DOT_core_list) + tmp258 := lang.Apply(tmp257, []any{lang.NewSymbol("recur")}) + tmp259 := checkDerefVar(glojure_DOT_core_list) + tmp260 := checkDerefVar(glojure_DOT_core_seq) + tmp261 := checkDerefVar(glojure_DOT_core_concat) + tmp262 := checkDerefVar(glojure_DOT_core_list) + tmp263 := lang.Apply(tmp262, []any{lang.NewSymbol("glojure.core/rest")}) + tmp264 := checkDerefVar(glojure_DOT_core_list) + tmp265 := lang.Apply(tmp264, []any{v92}) + tmp266 := lang.Apply(tmp261, []any{tmp263, tmp265}) + tmp267 := lang.Apply(tmp260, []any{tmp266}) + tmp268 := lang.Apply(tmp259, []any{tmp267}) + tmp269 := lang.Apply(tmp256, []any{tmp258, tmp268}) + tmp270 := lang.Apply(tmp255, []any{tmp269}) + tmp271 := lang.Apply(tmp254, []any{tmp270}) + tmp272 := lang.Apply(tmp221, []any{tmp223, tmp225, tmp253, tmp271}) + tmp273 := lang.Apply(tmp220, []any{tmp272}) + tmp274 := lang.Apply(tmp219, []any{tmp273}) + tmp275 := lang.Apply(tmp182, []any{tmp184, tmp218, tmp274}) + tmp276 := lang.Apply(tmp181, []any{tmp275}) + tmp180 = tmp276 + } else { + var tmp277 any + if lang.IsTruthy(lang.NewKeyword("else")) { + tmp278 := checkDerefVar(glojure_DOT_core_seq) + tmp279 := checkDerefVar(glojure_DOT_core_concat) + tmp280 := checkDerefVar(glojure_DOT_core_list) + tmp281 := lang.Apply(tmp280, []any{lang.NewSymbol("glojure.core/cons")}) + tmp282 := checkDerefVar(glojure_DOT_core_list) + tmp283 := lang.Apply(tmp282, []any{v6}) + tmp284 := checkDerefVar(glojure_DOT_core_list) + tmp285 := checkDerefVar(glojure_DOT_core_seq) + tmp286 := checkDerefVar(glojure_DOT_core_concat) + tmp287 := checkDerefVar(glojure_DOT_core_list) + tmp288 := lang.Apply(tmp287, []any{v89}) + tmp289 := checkDerefVar(glojure_DOT_core_list) + tmp290 := checkDerefVar(glojure_DOT_core_seq) + tmp291 := checkDerefVar(glojure_DOT_core_concat) + tmp292 := checkDerefVar(glojure_DOT_core_list) + tmp293 := lang.Apply(tmp292, []any{lang.NewSymbol("glojure.core/rest")}) + tmp294 := checkDerefVar(glojure_DOT_core_list) + tmp295 := lang.Apply(tmp294, []any{v92}) + tmp296 := lang.Apply(tmp291, []any{tmp293, tmp295}) + tmp297 := lang.Apply(tmp290, []any{tmp296}) + tmp298 := lang.Apply(tmp289, []any{tmp297}) + tmp299 := lang.Apply(tmp286, []any{tmp288, tmp298}) + tmp300 := lang.Apply(tmp285, []any{tmp299}) + tmp301 := lang.Apply(tmp284, []any{tmp300}) + tmp302 := lang.Apply(tmp279, []any{tmp281, tmp283, tmp301}) + tmp303 := lang.Apply(tmp278, []any{tmp302}) + tmp277 = tmp303 + } else { + } + tmp180 = tmp277 + } + tmp176 = tmp180 + } + tmp144 = tmp176 + } + tmp130 = tmp144 + } + tmp116 = tmp130 + } + tmp96 = tmp116 + } // end let + return tmp96 + }) + v94 = tmp93 + _ = v94 + } + tmp94 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4672), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(4687), lang.NewKeyword("end-column"), int(73)) + tmp95, err := lang.WithMeta(tmp93, tmp94.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v96 any = tmp95 + _ = v96 + var tmp97 any + if lang.IsTruthy(v85) { + tmp98 := checkDerefVar(glojure_DOT_core_seq) + tmp99 := checkDerefVar(glojure_DOT_core_concat) + tmp100 := checkDerefVar(glojure_DOT_core_list) + tmp101 := lang.Apply(tmp100, []any{lang.NewSymbol("glojure.core/fn")}) + tmp102 := checkDerefVar(glojure_DOT_core_list) + tmp103 := lang.Apply(tmp102, []any{v89}) + tmp104 := checkDerefVar(glojure_DOT_core_list) + tmp105 := checkDerefVar(glojure_DOT_core_apply) + tmp106 := checkDerefVar(glojure_DOT_core_vector) + tmp107 := checkDerefVar(glojure_DOT_core_seq) + tmp108 := checkDerefVar(glojure_DOT_core_concat) + tmp109 := checkDerefVar(glojure_DOT_core_list) + tmp110 := lang.Apply(tmp109, []any{v92}) + tmp111 := lang.Apply(tmp108, []any{tmp110}) + tmp112 := lang.Apply(tmp107, []any{tmp111}) + tmp113 := lang.Apply(tmp105, []any{tmp106, tmp112}) + tmp114 := lang.Apply(tmp104, []any{tmp113}) + tmp115 := checkDerefVar(glojure_DOT_core_list) + tmp116 := checkDerefVar(glojure_DOT_core_seq) + tmp117 := checkDerefVar(glojure_DOT_core_concat) + tmp118 := checkDerefVar(glojure_DOT_core_list) + tmp119 := lang.Apply(tmp118, []any{lang.NewSymbol("glojure.core/lazy-seq")}) + tmp120 := checkDerefVar(glojure_DOT_core_list) + tmp121 := checkDerefVar(glojure_DOT_core_seq) + tmp122 := checkDerefVar(glojure_DOT_core_concat) + tmp123 := checkDerefVar(glojure_DOT_core_list) + tmp124 := lang.Apply(tmp123, []any{lang.NewSymbol("glojure.core/loop")}) + tmp125 := checkDerefVar(glojure_DOT_core_list) + tmp126 := checkDerefVar(glojure_DOT_core_apply) + tmp127 := checkDerefVar(glojure_DOT_core_vector) + tmp128 := checkDerefVar(glojure_DOT_core_seq) + tmp129 := checkDerefVar(glojure_DOT_core_concat) + tmp130 := checkDerefVar(glojure_DOT_core_list) + tmp131 := lang.Apply(tmp130, []any{v92}) + tmp132 := checkDerefVar(glojure_DOT_core_list) + tmp133 := lang.Apply(tmp132, []any{v92}) + tmp134 := lang.Apply(tmp129, []any{tmp131, tmp133}) + tmp135 := lang.Apply(tmp128, []any{tmp134}) + tmp136 := lang.Apply(tmp126, []any{tmp127, tmp135}) + tmp137 := lang.Apply(tmp125, []any{tmp136}) + tmp138 := checkDerefVar(glojure_DOT_core_list) + tmp139 := checkDerefVar(glojure_DOT_core_seq) + tmp140 := checkDerefVar(glojure_DOT_core_concat) + tmp141 := checkDerefVar(glojure_DOT_core_list) + tmp142 := lang.Apply(tmp141, []any{lang.NewSymbol("glojure.core/when-first")}) + tmp143 := checkDerefVar(glojure_DOT_core_list) + tmp144 := checkDerefVar(glojure_DOT_core_apply) + tmp145 := checkDerefVar(glojure_DOT_core_vector) + tmp146 := checkDerefVar(glojure_DOT_core_seq) + tmp147 := checkDerefVar(glojure_DOT_core_concat) + tmp148 := checkDerefVar(glojure_DOT_core_list) + tmp149 := lang.Apply(tmp148, []any{v66}) + tmp150 := checkDerefVar(glojure_DOT_core_list) + tmp151 := lang.Apply(tmp150, []any{v92}) + tmp152 := lang.Apply(tmp147, []any{tmp149, tmp151}) + tmp153 := lang.Apply(tmp146, []any{tmp152}) + tmp154 := lang.Apply(tmp144, []any{tmp145, tmp153}) + tmp155 := lang.Apply(tmp143, []any{tmp154}) + tmp156 := checkDerefVar(glojure_DOT_core_list) + tmp157 := lang.Apply(v96, []any{v74}) + tmp158 := lang.Apply(tmp156, []any{tmp157}) + tmp159 := lang.Apply(tmp140, []any{tmp142, tmp155, tmp158}) + tmp160 := lang.Apply(tmp139, []any{tmp159}) + tmp161 := lang.Apply(tmp138, []any{tmp160}) + tmp162 := lang.Apply(tmp122, []any{tmp124, tmp137, tmp161}) + tmp163 := lang.Apply(tmp121, []any{tmp162}) + tmp164 := lang.Apply(tmp120, []any{tmp163}) + tmp165 := lang.Apply(tmp117, []any{tmp119, tmp164}) + tmp166 := lang.Apply(tmp116, []any{tmp165}) + tmp167 := lang.Apply(tmp115, []any{tmp166}) + tmp168 := lang.Apply(tmp99, []any{tmp101, tmp103, tmp114, tmp167}) + tmp169 := lang.Apply(tmp98, []any{tmp168}) + tmp97 = tmp169 + } else { + var tmp170 any + { // let + // let binding "gi" + tmp171 := checkDerefVar(glojure_DOT_core_gensym) + tmp172 := lang.Apply(tmp171, []any{"i__"}) + var v173 any = tmp172 + _ = v173 + // let binding "gb" + tmp174 := checkDerefVar(glojure_DOT_core_gensym) + tmp175 := lang.Apply(tmp174, []any{"b__"}) + var v176 any = tmp175 + _ = v176 + // let binding "do-cmod" + var tmp177 lang.FnFunc + { // function do-cmod + var v178 lang.FnFunc + tmp177 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v179 := args[0] + _ = v179 + var tmp180 any + { // let + // let binding "vec__48" + var v181 any = v179 + _ = v181 + // let binding "seq__49" + tmp182 := checkDerefVar(glojure_DOT_core_seq) + tmp183 := lang.Apply(tmp182, []any{v181}) + var v184 any = tmp183 + _ = v184 + // let binding "first__50" + tmp185 := checkDerefVar(glojure_DOT_core_first) + tmp186 := lang.Apply(tmp185, []any{v184}) + var v187 any = tmp186 + _ = v187 + // let binding "seq__49" + tmp188 := checkDerefVar(glojure_DOT_core_next) + tmp189 := lang.Apply(tmp188, []any{v184}) + var v190 any = tmp189 + _ = v190 + // let binding "vec__51" + var v191 any = v187 + _ = v191 + // let binding "k" + tmp192 := checkDerefVar(glojure_DOT_core_nth) + tmp193 := lang.Apply(tmp192, []any{v191, int64(0), nil}) + var v194 any = tmp193 + _ = v194 + // let binding "v" + tmp195 := checkDerefVar(glojure_DOT_core_nth) + tmp196 := lang.Apply(tmp195, []any{v191, int64(1), nil}) + var v197 any = tmp196 + _ = v197 + // let binding "pair" + var v198 any = v191 + _ = v198 + // let binding "etc" + var v199 any = v190 + _ = v199 + var tmp200 any + tmp201 := checkDerefVar(glojure_DOT_core__EQ_) + tmp202 := lang.Apply(tmp201, []any{v194, lang.NewKeyword("let")}) + if lang.IsTruthy(tmp202) { + tmp203 := checkDerefVar(glojure_DOT_core_seq) + tmp204 := checkDerefVar(glojure_DOT_core_concat) + tmp205 := checkDerefVar(glojure_DOT_core_list) + tmp206 := lang.Apply(tmp205, []any{lang.NewSymbol("glojure.core/let")}) + tmp207 := checkDerefVar(glojure_DOT_core_list) + tmp208 := lang.Apply(tmp207, []any{v197}) + tmp209 := checkDerefVar(glojure_DOT_core_list) + tmp210 := lang.Apply(v178, []any{v199}) + tmp211 := lang.Apply(tmp209, []any{tmp210}) + tmp212 := lang.Apply(tmp204, []any{tmp206, tmp208, tmp211}) + tmp213 := lang.Apply(tmp203, []any{tmp212}) + tmp200 = tmp213 + } else { + var tmp214 any + tmp215 := checkDerefVar(glojure_DOT_core__EQ_) + tmp216 := lang.Apply(tmp215, []any{v194, lang.NewKeyword("while")}) + if lang.IsTruthy(tmp216) { + tmp217 := checkDerefVar(glojure_DOT_core_seq) + tmp218 := checkDerefVar(glojure_DOT_core_concat) + tmp219 := checkDerefVar(glojure_DOT_core_list) + tmp220 := lang.Apply(tmp219, []any{lang.NewSymbol("glojure.core/when")}) + tmp221 := checkDerefVar(glojure_DOT_core_list) + tmp222 := lang.Apply(tmp221, []any{v197}) + tmp223 := checkDerefVar(glojure_DOT_core_list) + tmp224 := lang.Apply(v178, []any{v199}) + tmp225 := lang.Apply(tmp223, []any{tmp224}) + tmp226 := lang.Apply(tmp218, []any{tmp220, tmp222, tmp225}) + tmp227 := lang.Apply(tmp217, []any{tmp226}) + tmp214 = tmp227 + } else { + var tmp228 any + tmp229 := checkDerefVar(glojure_DOT_core__EQ_) + tmp230 := lang.Apply(tmp229, []any{v194, lang.NewKeyword("when")}) + if lang.IsTruthy(tmp230) { + tmp231 := checkDerefVar(glojure_DOT_core_seq) + tmp232 := checkDerefVar(glojure_DOT_core_concat) + tmp233 := checkDerefVar(glojure_DOT_core_list) + tmp234 := lang.Apply(tmp233, []any{lang.NewSymbol("if")}) + tmp235 := checkDerefVar(glojure_DOT_core_list) + tmp236 := lang.Apply(tmp235, []any{v197}) + tmp237 := checkDerefVar(glojure_DOT_core_list) + tmp238 := lang.Apply(v178, []any{v199}) + tmp239 := lang.Apply(tmp237, []any{tmp238}) + tmp240 := checkDerefVar(glojure_DOT_core_list) + tmp241 := checkDerefVar(glojure_DOT_core_seq) + tmp242 := checkDerefVar(glojure_DOT_core_concat) + tmp243 := checkDerefVar(glojure_DOT_core_list) + tmp244 := lang.Apply(tmp243, []any{lang.NewSymbol("recur")}) + tmp245 := checkDerefVar(glojure_DOT_core_list) + tmp246 := checkDerefVar(glojure_DOT_core_seq) + tmp247 := checkDerefVar(glojure_DOT_core_concat) + tmp248 := checkDerefVar(glojure_DOT_core_list) + tmp249 := lang.Apply(tmp248, []any{lang.NewSymbol("glojure.core/unchecked-inc")}) + tmp250 := checkDerefVar(glojure_DOT_core_list) + tmp251 := lang.Apply(tmp250, []any{v173}) + tmp252 := lang.Apply(tmp247, []any{tmp249, tmp251}) + tmp253 := lang.Apply(tmp246, []any{tmp252}) + tmp254 := lang.Apply(tmp245, []any{tmp253}) + tmp255 := lang.Apply(tmp242, []any{tmp244, tmp254}) + tmp256 := lang.Apply(tmp241, []any{tmp255}) + tmp257 := lang.Apply(tmp240, []any{tmp256}) + tmp258 := lang.Apply(tmp232, []any{tmp234, tmp236, tmp239, tmp257}) + tmp259 := lang.Apply(tmp231, []any{tmp258}) + tmp228 = tmp259 + } else { + var tmp260 any + tmp261 := checkDerefVar(glojure_DOT_core_keyword_QMARK_) + tmp262 := lang.Apply(tmp261, []any{v194}) + if lang.IsTruthy(tmp262) { + tmp263 := lang.Apply(v41, []any{"Invalid 'for' keyword ", v194}) + tmp260 = tmp263 + } else { + var tmp264 any + if lang.IsTruthy(lang.NewKeyword("else")) { + tmp265 := checkDerefVar(glojure_DOT_core_seq) + tmp266 := checkDerefVar(glojure_DOT_core_concat) + tmp267 := checkDerefVar(glojure_DOT_core_list) + tmp268 := lang.Apply(tmp267, []any{lang.NewSymbol("do")}) + tmp269 := checkDerefVar(glojure_DOT_core_list) + tmp270 := checkDerefVar(glojure_DOT_core_seq) + tmp271 := checkDerefVar(glojure_DOT_core_concat) + tmp272 := checkDerefVar(glojure_DOT_core_list) + tmp273 := lang.Apply(tmp272, []any{lang.NewSymbol("glojure.core/chunk-append")}) + tmp274 := checkDerefVar(glojure_DOT_core_list) + tmp275 := lang.Apply(tmp274, []any{v176}) + tmp276 := checkDerefVar(glojure_DOT_core_list) + tmp277 := lang.Apply(tmp276, []any{v6}) + tmp278 := lang.Apply(tmp271, []any{tmp273, tmp275, tmp277}) + tmp279 := lang.Apply(tmp270, []any{tmp278}) + tmp280 := lang.Apply(tmp269, []any{tmp279}) + tmp281 := checkDerefVar(glojure_DOT_core_list) + tmp282 := checkDerefVar(glojure_DOT_core_seq) + tmp283 := checkDerefVar(glojure_DOT_core_concat) + tmp284 := checkDerefVar(glojure_DOT_core_list) + tmp285 := lang.Apply(tmp284, []any{lang.NewSymbol("recur")}) + tmp286 := checkDerefVar(glojure_DOT_core_list) + tmp287 := checkDerefVar(glojure_DOT_core_seq) + tmp288 := checkDerefVar(glojure_DOT_core_concat) + tmp289 := checkDerefVar(glojure_DOT_core_list) + tmp290 := lang.Apply(tmp289, []any{lang.NewSymbol("glojure.core/unchecked-inc")}) + tmp291 := checkDerefVar(glojure_DOT_core_list) + tmp292 := lang.Apply(tmp291, []any{v173}) + tmp293 := lang.Apply(tmp288, []any{tmp290, tmp292}) + tmp294 := lang.Apply(tmp287, []any{tmp293}) + tmp295 := lang.Apply(tmp286, []any{tmp294}) + tmp296 := lang.Apply(tmp283, []any{tmp285, tmp295}) + tmp297 := lang.Apply(tmp282, []any{tmp296}) + tmp298 := lang.Apply(tmp281, []any{tmp297}) + tmp299 := lang.Apply(tmp266, []any{tmp268, tmp280, tmp298}) + tmp300 := lang.Apply(tmp265, []any{tmp299}) + tmp264 = tmp300 + } else { + } + tmp260 = tmp264 + } + tmp228 = tmp260 + } + tmp214 = tmp228 + } + tmp200 = tmp214 + } + tmp180 = tmp200 + } // end let + return tmp180 + }) + v178 = tmp177 + _ = v178 + } + tmp178 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4698), lang.NewKeyword("column"), int(39), lang.NewKeyword("end-line"), int(4710), lang.NewKeyword("end-column"), int(79)) + tmp179, err := lang.WithMeta(tmp177, tmp178.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v180 any = tmp179 + _ = v180 + tmp181 := checkDerefVar(glojure_DOT_core_seq) + tmp182 := checkDerefVar(glojure_DOT_core_concat) + tmp183 := checkDerefVar(glojure_DOT_core_list) + tmp184 := lang.Apply(tmp183, []any{lang.NewSymbol("glojure.core/fn")}) + tmp185 := checkDerefVar(glojure_DOT_core_list) + tmp186 := lang.Apply(tmp185, []any{v89}) + tmp187 := checkDerefVar(glojure_DOT_core_list) + tmp188 := checkDerefVar(glojure_DOT_core_apply) + tmp189 := checkDerefVar(glojure_DOT_core_vector) + tmp190 := checkDerefVar(glojure_DOT_core_seq) + tmp191 := checkDerefVar(glojure_DOT_core_concat) + tmp192 := checkDerefVar(glojure_DOT_core_list) + tmp193 := lang.Apply(tmp192, []any{v92}) + tmp194 := lang.Apply(tmp191, []any{tmp193}) + tmp195 := lang.Apply(tmp190, []any{tmp194}) + tmp196 := lang.Apply(tmp188, []any{tmp189, tmp195}) + tmp197 := lang.Apply(tmp187, []any{tmp196}) + tmp198 := checkDerefVar(glojure_DOT_core_list) + tmp199 := checkDerefVar(glojure_DOT_core_seq) + tmp200 := checkDerefVar(glojure_DOT_core_concat) + tmp201 := checkDerefVar(glojure_DOT_core_list) + tmp202 := lang.Apply(tmp201, []any{lang.NewSymbol("glojure.core/lazy-seq")}) + tmp203 := checkDerefVar(glojure_DOT_core_list) + tmp204 := checkDerefVar(glojure_DOT_core_seq) + tmp205 := checkDerefVar(glojure_DOT_core_concat) + tmp206 := checkDerefVar(glojure_DOT_core_list) + tmp207 := lang.Apply(tmp206, []any{lang.NewSymbol("glojure.core/loop")}) + tmp208 := checkDerefVar(glojure_DOT_core_list) + tmp209 := checkDerefVar(glojure_DOT_core_apply) + tmp210 := checkDerefVar(glojure_DOT_core_vector) + tmp211 := checkDerefVar(glojure_DOT_core_seq) + tmp212 := checkDerefVar(glojure_DOT_core_concat) + tmp213 := checkDerefVar(glojure_DOT_core_list) + tmp214 := lang.Apply(tmp213, []any{v92}) + tmp215 := checkDerefVar(glojure_DOT_core_list) + tmp216 := lang.Apply(tmp215, []any{v92}) + tmp217 := lang.Apply(tmp212, []any{tmp214, tmp216}) + tmp218 := lang.Apply(tmp211, []any{tmp217}) + tmp219 := lang.Apply(tmp209, []any{tmp210, tmp218}) + tmp220 := lang.Apply(tmp208, []any{tmp219}) + tmp221 := checkDerefVar(glojure_DOT_core_list) + tmp222 := checkDerefVar(glojure_DOT_core_seq) + tmp223 := checkDerefVar(glojure_DOT_core_concat) + tmp224 := checkDerefVar(glojure_DOT_core_list) + tmp225 := lang.Apply(tmp224, []any{lang.NewSymbol("glojure.core/when-let")}) + tmp226 := checkDerefVar(glojure_DOT_core_list) + tmp227 := checkDerefVar(glojure_DOT_core_apply) + tmp228 := checkDerefVar(glojure_DOT_core_vector) + tmp229 := checkDerefVar(glojure_DOT_core_seq) + tmp230 := checkDerefVar(glojure_DOT_core_concat) + tmp231 := checkDerefVar(glojure_DOT_core_list) + tmp232 := lang.Apply(tmp231, []any{v92}) + tmp233 := checkDerefVar(glojure_DOT_core_list) + tmp234 := checkDerefVar(glojure_DOT_core_seq) + tmp235 := checkDerefVar(glojure_DOT_core_concat) + tmp236 := checkDerefVar(glojure_DOT_core_list) + tmp237 := lang.Apply(tmp236, []any{lang.NewSymbol("glojure.core/seq")}) + tmp238 := checkDerefVar(glojure_DOT_core_list) + tmp239 := lang.Apply(tmp238, []any{v92}) + tmp240 := lang.Apply(tmp235, []any{tmp237, tmp239}) + tmp241 := lang.Apply(tmp234, []any{tmp240}) + tmp242 := lang.Apply(tmp233, []any{tmp241}) + tmp243 := lang.Apply(tmp230, []any{tmp232, tmp242}) + tmp244 := lang.Apply(tmp229, []any{tmp243}) + tmp245 := lang.Apply(tmp227, []any{tmp228, tmp244}) + tmp246 := lang.Apply(tmp226, []any{tmp245}) + tmp247 := checkDerefVar(glojure_DOT_core_list) + tmp248 := checkDerefVar(glojure_DOT_core_seq) + tmp249 := checkDerefVar(glojure_DOT_core_concat) + tmp250 := checkDerefVar(glojure_DOT_core_list) + tmp251 := lang.Apply(tmp250, []any{lang.NewSymbol("if")}) + tmp252 := checkDerefVar(glojure_DOT_core_list) + tmp253 := checkDerefVar(glojure_DOT_core_seq) + tmp254 := checkDerefVar(glojure_DOT_core_concat) + tmp255 := checkDerefVar(glojure_DOT_core_list) + tmp256 := lang.Apply(tmp255, []any{lang.NewSymbol("glojure.core/chunked-seq?")}) + tmp257 := checkDerefVar(glojure_DOT_core_list) + tmp258 := lang.Apply(tmp257, []any{v92}) + tmp259 := lang.Apply(tmp254, []any{tmp256, tmp258}) + tmp260 := lang.Apply(tmp253, []any{tmp259}) + tmp261 := lang.Apply(tmp252, []any{tmp260}) + tmp262 := checkDerefVar(glojure_DOT_core_list) + tmp263 := checkDerefVar(glojure_DOT_core_seq) + tmp264 := checkDerefVar(glojure_DOT_core_concat) + tmp265 := checkDerefVar(glojure_DOT_core_list) + tmp266 := lang.Apply(tmp265, []any{lang.NewSymbol("glojure.core/let")}) + tmp267 := checkDerefVar(glojure_DOT_core_list) + tmp268 := checkDerefVar(glojure_DOT_core_apply) + tmp269 := checkDerefVar(glojure_DOT_core_vector) + tmp270 := checkDerefVar(glojure_DOT_core_seq) + tmp271 := checkDerefVar(glojure_DOT_core_concat) + tmp272 := checkDerefVar(glojure_DOT_core_list) + tmp273 := lang.Apply(tmp272, []any{lang.NewSymbol("c__0__auto__")}) + tmp274 := checkDerefVar(glojure_DOT_core_list) + tmp275 := checkDerefVar(glojure_DOT_core_seq) + tmp276 := checkDerefVar(glojure_DOT_core_concat) + tmp277 := checkDerefVar(glojure_DOT_core_list) + tmp278 := lang.Apply(tmp277, []any{lang.NewSymbol("glojure.core/chunk-first")}) + tmp279 := checkDerefVar(glojure_DOT_core_list) + tmp280 := lang.Apply(tmp279, []any{v92}) + tmp281 := lang.Apply(tmp276, []any{tmp278, tmp280}) + tmp282 := lang.Apply(tmp275, []any{tmp281}) + tmp283 := lang.Apply(tmp274, []any{tmp282}) + tmp284 := checkDerefVar(glojure_DOT_core_list) + tmp285 := lang.Apply(tmp284, []any{lang.NewSymbol("size__1__auto__")}) + tmp286 := checkDerefVar(glojure_DOT_core_list) + tmp287 := checkDerefVar(glojure_DOT_core_seq) + tmp288 := checkDerefVar(glojure_DOT_core_concat) + tmp289 := checkDerefVar(glojure_DOT_core_list) + tmp290 := lang.Apply(tmp289, []any{lang.NewSymbol("glojure.core/int")}) + tmp291 := checkDerefVar(glojure_DOT_core_list) + tmp292 := checkDerefVar(glojure_DOT_core_seq) + tmp293 := checkDerefVar(glojure_DOT_core_concat) + tmp294 := checkDerefVar(glojure_DOT_core_list) + tmp295 := lang.Apply(tmp294, []any{lang.NewSymbol("glojure.core/count")}) + tmp296 := checkDerefVar(glojure_DOT_core_list) + tmp297 := lang.Apply(tmp296, []any{lang.NewSymbol("c__0__auto__")}) + tmp298 := lang.Apply(tmp293, []any{tmp295, tmp297}) + tmp299 := lang.Apply(tmp292, []any{tmp298}) + tmp300 := lang.Apply(tmp291, []any{tmp299}) + tmp301 := lang.Apply(tmp288, []any{tmp290, tmp300}) + tmp302 := lang.Apply(tmp287, []any{tmp301}) + tmp303 := lang.Apply(tmp286, []any{tmp302}) + tmp304 := checkDerefVar(glojure_DOT_core_list) + tmp305 := lang.Apply(tmp304, []any{v176}) + tmp306 := checkDerefVar(glojure_DOT_core_list) + tmp307 := checkDerefVar(glojure_DOT_core_seq) + tmp308 := checkDerefVar(glojure_DOT_core_concat) + tmp309 := checkDerefVar(glojure_DOT_core_list) + tmp310 := lang.Apply(tmp309, []any{lang.NewSymbol("glojure.core/chunk-buffer")}) + tmp311 := checkDerefVar(glojure_DOT_core_list) + tmp312 := lang.Apply(tmp311, []any{lang.NewSymbol("size__1__auto__")}) + tmp313 := lang.Apply(tmp308, []any{tmp310, tmp312}) + tmp314 := lang.Apply(tmp307, []any{tmp313}) + tmp315 := lang.Apply(tmp306, []any{tmp314}) + tmp316 := lang.Apply(tmp271, []any{tmp273, tmp283, tmp285, tmp303, tmp305, tmp315}) + tmp317 := lang.Apply(tmp270, []any{tmp316}) + tmp318 := lang.Apply(tmp268, []any{tmp269, tmp317}) + tmp319 := lang.Apply(tmp267, []any{tmp318}) + tmp320 := checkDerefVar(glojure_DOT_core_list) + tmp321 := checkDerefVar(glojure_DOT_core_seq) + tmp322 := checkDerefVar(glojure_DOT_core_concat) + tmp323 := checkDerefVar(glojure_DOT_core_list) + tmp324 := lang.Apply(tmp323, []any{lang.NewSymbol("if")}) + tmp325 := checkDerefVar(glojure_DOT_core_list) + tmp326 := checkDerefVar(glojure_DOT_core_seq) + tmp327 := checkDerefVar(glojure_DOT_core_concat) + tmp328 := checkDerefVar(glojure_DOT_core_list) + tmp329 := lang.Apply(tmp328, []any{lang.NewSymbol("glojure.core/loop")}) + tmp330 := checkDerefVar(glojure_DOT_core_list) + tmp331 := checkDerefVar(glojure_DOT_core_apply) + tmp332 := checkDerefVar(glojure_DOT_core_vector) + tmp333 := checkDerefVar(glojure_DOT_core_seq) + tmp334 := checkDerefVar(glojure_DOT_core_concat) + tmp335 := checkDerefVar(glojure_DOT_core_list) + tmp336 := lang.Apply(tmp335, []any{v173}) + tmp337 := checkDerefVar(glojure_DOT_core_list) + tmp338 := checkDerefVar(glojure_DOT_core_seq) + tmp339 := checkDerefVar(glojure_DOT_core_concat) + tmp340 := checkDerefVar(glojure_DOT_core_list) + tmp341 := lang.Apply(tmp340, []any{lang.NewSymbol("glojure.core/int")}) + tmp342 := checkDerefVar(glojure_DOT_core_list) + tmp343 := lang.Apply(tmp342, []any{int64(0)}) + tmp344 := lang.Apply(tmp339, []any{tmp341, tmp343}) + tmp345 := lang.Apply(tmp338, []any{tmp344}) + tmp346 := lang.Apply(tmp337, []any{tmp345}) + tmp347 := lang.Apply(tmp334, []any{tmp336, tmp346}) + tmp348 := lang.Apply(tmp333, []any{tmp347}) + tmp349 := lang.Apply(tmp331, []any{tmp332, tmp348}) + tmp350 := lang.Apply(tmp330, []any{tmp349}) + tmp351 := checkDerefVar(glojure_DOT_core_list) + tmp352 := checkDerefVar(glojure_DOT_core_seq) + tmp353 := checkDerefVar(glojure_DOT_core_concat) + tmp354 := checkDerefVar(glojure_DOT_core_list) + tmp355 := lang.Apply(tmp354, []any{lang.NewSymbol("if")}) + tmp356 := checkDerefVar(glojure_DOT_core_list) + tmp357 := checkDerefVar(glojure_DOT_core_seq) + tmp358 := checkDerefVar(glojure_DOT_core_concat) + tmp359 := checkDerefVar(glojure_DOT_core_list) + tmp360 := lang.Apply(tmp359, []any{lang.NewSymbol("glojure.core/<")}) + tmp361 := checkDerefVar(glojure_DOT_core_list) + tmp362 := lang.Apply(tmp361, []any{v173}) + tmp363 := checkDerefVar(glojure_DOT_core_list) + tmp364 := lang.Apply(tmp363, []any{lang.NewSymbol("size__1__auto__")}) + tmp365 := lang.Apply(tmp358, []any{tmp360, tmp362, tmp364}) + tmp366 := lang.Apply(tmp357, []any{tmp365}) + tmp367 := lang.Apply(tmp356, []any{tmp366}) + tmp368 := checkDerefVar(glojure_DOT_core_list) + tmp369 := checkDerefVar(glojure_DOT_core_seq) + tmp370 := checkDerefVar(glojure_DOT_core_concat) + tmp371 := checkDerefVar(glojure_DOT_core_list) + tmp372 := lang.Apply(tmp371, []any{lang.NewSymbol("glojure.core/let")}) + tmp373 := checkDerefVar(glojure_DOT_core_list) + tmp374 := checkDerefVar(glojure_DOT_core_apply) + tmp375 := checkDerefVar(glojure_DOT_core_vector) + tmp376 := checkDerefVar(glojure_DOT_core_seq) + tmp377 := checkDerefVar(glojure_DOT_core_concat) + tmp378 := checkDerefVar(glojure_DOT_core_list) + tmp379 := lang.Apply(tmp378, []any{v66}) + tmp380 := checkDerefVar(glojure_DOT_core_list) + tmp381 := checkDerefVar(glojure_DOT_core_seq) + tmp382 := checkDerefVar(glojure_DOT_core_concat) + tmp383 := checkDerefVar(glojure_DOT_core_list) + tmp384 := lang.Apply(tmp383, []any{lang.NewSymbol(".nth")}) + tmp385 := checkDerefVar(glojure_DOT_core_list) + tmp386 := lang.Apply(tmp385, []any{lang.NewSymbol("c__0__auto__")}) + tmp387 := checkDerefVar(glojure_DOT_core_list) + tmp388 := lang.Apply(tmp387, []any{v173}) + tmp389 := lang.Apply(tmp382, []any{tmp384, tmp386, tmp388}) + tmp390 := lang.Apply(tmp381, []any{tmp389}) + tmp391 := lang.Apply(tmp380, []any{tmp390}) + tmp392 := lang.Apply(tmp377, []any{tmp379, tmp391}) + tmp393 := lang.Apply(tmp376, []any{tmp392}) + tmp394 := lang.Apply(tmp374, []any{tmp375, tmp393}) + tmp395 := lang.Apply(tmp373, []any{tmp394}) + tmp396 := checkDerefVar(glojure_DOT_core_list) + tmp397 := lang.Apply(v180, []any{v74}) + tmp398 := lang.Apply(tmp396, []any{tmp397}) + tmp399 := lang.Apply(tmp370, []any{tmp372, tmp395, tmp398}) + tmp400 := lang.Apply(tmp369, []any{tmp399}) + tmp401 := lang.Apply(tmp368, []any{tmp400}) + tmp402 := checkDerefVar(glojure_DOT_core_list) + tmp403 := lang.Apply(tmp402, []any{true}) + tmp404 := lang.Apply(tmp353, []any{tmp355, tmp367, tmp401, tmp403}) + tmp405 := lang.Apply(tmp352, []any{tmp404}) + tmp406 := lang.Apply(tmp351, []any{tmp405}) + tmp407 := lang.Apply(tmp327, []any{tmp329, tmp350, tmp406}) + tmp408 := lang.Apply(tmp326, []any{tmp407}) + tmp409 := lang.Apply(tmp325, []any{tmp408}) + tmp410 := checkDerefVar(glojure_DOT_core_list) + tmp411 := checkDerefVar(glojure_DOT_core_seq) + tmp412 := checkDerefVar(glojure_DOT_core_concat) + tmp413 := checkDerefVar(glojure_DOT_core_list) + tmp414 := lang.Apply(tmp413, []any{lang.NewSymbol("glojure.core/chunk-cons")}) + tmp415 := checkDerefVar(glojure_DOT_core_list) + tmp416 := checkDerefVar(glojure_DOT_core_seq) + tmp417 := checkDerefVar(glojure_DOT_core_concat) + tmp418 := checkDerefVar(glojure_DOT_core_list) + tmp419 := lang.Apply(tmp418, []any{lang.NewSymbol("glojure.core/chunk")}) + tmp420 := checkDerefVar(glojure_DOT_core_list) + tmp421 := lang.Apply(tmp420, []any{v176}) + tmp422 := lang.Apply(tmp417, []any{tmp419, tmp421}) + tmp423 := lang.Apply(tmp416, []any{tmp422}) + tmp424 := lang.Apply(tmp415, []any{tmp423}) + tmp425 := checkDerefVar(glojure_DOT_core_list) + tmp426 := checkDerefVar(glojure_DOT_core_seq) + tmp427 := checkDerefVar(glojure_DOT_core_concat) + tmp428 := checkDerefVar(glojure_DOT_core_list) + tmp429 := lang.Apply(tmp428, []any{v89}) + tmp430 := checkDerefVar(glojure_DOT_core_list) + tmp431 := checkDerefVar(glojure_DOT_core_seq) + tmp432 := checkDerefVar(glojure_DOT_core_concat) + tmp433 := checkDerefVar(glojure_DOT_core_list) + tmp434 := lang.Apply(tmp433, []any{lang.NewSymbol("glojure.core/chunk-rest")}) + tmp435 := checkDerefVar(glojure_DOT_core_list) + tmp436 := lang.Apply(tmp435, []any{v92}) + tmp437 := lang.Apply(tmp432, []any{tmp434, tmp436}) + tmp438 := lang.Apply(tmp431, []any{tmp437}) + tmp439 := lang.Apply(tmp430, []any{tmp438}) + tmp440 := lang.Apply(tmp427, []any{tmp429, tmp439}) + tmp441 := lang.Apply(tmp426, []any{tmp440}) + tmp442 := lang.Apply(tmp425, []any{tmp441}) + tmp443 := lang.Apply(tmp412, []any{tmp414, tmp424, tmp442}) + tmp444 := lang.Apply(tmp411, []any{tmp443}) + tmp445 := lang.Apply(tmp410, []any{tmp444}) + tmp446 := checkDerefVar(glojure_DOT_core_list) + tmp447 := checkDerefVar(glojure_DOT_core_seq) + tmp448 := checkDerefVar(glojure_DOT_core_concat) + tmp449 := checkDerefVar(glojure_DOT_core_list) + tmp450 := lang.Apply(tmp449, []any{lang.NewSymbol("glojure.core/chunk-cons")}) + tmp451 := checkDerefVar(glojure_DOT_core_list) + tmp452 := checkDerefVar(glojure_DOT_core_seq) + tmp453 := checkDerefVar(glojure_DOT_core_concat) + tmp454 := checkDerefVar(glojure_DOT_core_list) + tmp455 := lang.Apply(tmp454, []any{lang.NewSymbol("glojure.core/chunk")}) + tmp456 := checkDerefVar(glojure_DOT_core_list) + tmp457 := lang.Apply(tmp456, []any{v176}) + tmp458 := lang.Apply(tmp453, []any{tmp455, tmp457}) + tmp459 := lang.Apply(tmp452, []any{tmp458}) + tmp460 := lang.Apply(tmp451, []any{tmp459}) + tmp461 := checkDerefVar(glojure_DOT_core_list) + tmp462 := lang.Apply(tmp461, []any{nil}) + tmp463 := lang.Apply(tmp448, []any{tmp450, tmp460, tmp462}) + tmp464 := lang.Apply(tmp447, []any{tmp463}) + tmp465 := lang.Apply(tmp446, []any{tmp464}) + tmp466 := lang.Apply(tmp322, []any{tmp324, tmp409, tmp445, tmp465}) + tmp467 := lang.Apply(tmp321, []any{tmp466}) + tmp468 := lang.Apply(tmp320, []any{tmp467}) + tmp469 := lang.Apply(tmp264, []any{tmp266, tmp319, tmp468}) + tmp470 := lang.Apply(tmp263, []any{tmp469}) + tmp471 := lang.Apply(tmp262, []any{tmp470}) + tmp472 := checkDerefVar(glojure_DOT_core_list) + tmp473 := checkDerefVar(glojure_DOT_core_seq) + tmp474 := checkDerefVar(glojure_DOT_core_concat) + tmp475 := checkDerefVar(glojure_DOT_core_list) + tmp476 := lang.Apply(tmp475, []any{lang.NewSymbol("glojure.core/let")}) + tmp477 := checkDerefVar(glojure_DOT_core_list) + tmp478 := checkDerefVar(glojure_DOT_core_apply) + tmp479 := checkDerefVar(glojure_DOT_core_vector) + tmp480 := checkDerefVar(glojure_DOT_core_seq) + tmp481 := checkDerefVar(glojure_DOT_core_concat) + tmp482 := checkDerefVar(glojure_DOT_core_list) + tmp483 := lang.Apply(tmp482, []any{v66}) + tmp484 := checkDerefVar(glojure_DOT_core_list) + tmp485 := checkDerefVar(glojure_DOT_core_seq) + tmp486 := checkDerefVar(glojure_DOT_core_concat) + tmp487 := checkDerefVar(glojure_DOT_core_list) + tmp488 := lang.Apply(tmp487, []any{lang.NewSymbol("glojure.core/first")}) + tmp489 := checkDerefVar(glojure_DOT_core_list) + tmp490 := lang.Apply(tmp489, []any{v92}) + tmp491 := lang.Apply(tmp486, []any{tmp488, tmp490}) + tmp492 := lang.Apply(tmp485, []any{tmp491}) + tmp493 := lang.Apply(tmp484, []any{tmp492}) + tmp494 := lang.Apply(tmp481, []any{tmp483, tmp493}) + tmp495 := lang.Apply(tmp480, []any{tmp494}) + tmp496 := lang.Apply(tmp478, []any{tmp479, tmp495}) + tmp497 := lang.Apply(tmp477, []any{tmp496}) + tmp498 := checkDerefVar(glojure_DOT_core_list) + tmp499 := lang.Apply(v96, []any{v74}) + tmp500 := lang.Apply(tmp498, []any{tmp499}) + tmp501 := lang.Apply(tmp474, []any{tmp476, tmp497, tmp500}) + tmp502 := lang.Apply(tmp473, []any{tmp501}) + tmp503 := lang.Apply(tmp472, []any{tmp502}) + tmp504 := lang.Apply(tmp249, []any{tmp251, tmp261, tmp471, tmp503}) + tmp505 := lang.Apply(tmp248, []any{tmp504}) + tmp506 := lang.Apply(tmp247, []any{tmp505}) + tmp507 := lang.Apply(tmp223, []any{tmp225, tmp246, tmp506}) + tmp508 := lang.Apply(tmp222, []any{tmp507}) + tmp509 := lang.Apply(tmp221, []any{tmp508}) + tmp510 := lang.Apply(tmp205, []any{tmp207, tmp220, tmp509}) + tmp511 := lang.Apply(tmp204, []any{tmp510}) + tmp512 := lang.Apply(tmp203, []any{tmp511}) + tmp513 := lang.Apply(tmp200, []any{tmp202, tmp512}) + tmp514 := lang.Apply(tmp199, []any{tmp513}) + tmp515 := lang.Apply(tmp198, []any{tmp514}) + tmp516 := lang.Apply(tmp182, []any{tmp184, tmp186, tmp197, tmp515}) + tmp517 := lang.Apply(tmp181, []any{tmp516}) + tmp170 = tmp517 + } // end let + tmp97 = tmp170 + } + tmp86 = tmp97 + } // end let + tmp45 = tmp86 + } // end let + return tmp45 + }) + v43 = tmp42 + _ = v43 + } + tmp43 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4668), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(4729), lang.NewKeyword("end-column"), int(68)) + tmp44, err := lang.WithMeta(tmp42, tmp43.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v45 any = tmp44 + _ = v45 + tmp46 := checkDerefVar(glojure_DOT_core_seq) + tmp47 := checkDerefVar(glojure_DOT_core_concat) + tmp48 := checkDerefVar(glojure_DOT_core_list) + tmp49 := lang.Apply(tmp48, []any{lang.NewSymbol("glojure.core/let")}) + tmp50 := checkDerefVar(glojure_DOT_core_list) + tmp51 := checkDerefVar(glojure_DOT_core_apply) + tmp52 := checkDerefVar(glojure_DOT_core_vector) + tmp53 := checkDerefVar(glojure_DOT_core_seq) + tmp54 := checkDerefVar(glojure_DOT_core_concat) + tmp55 := checkDerefVar(glojure_DOT_core_list) + tmp56 := lang.Apply(tmp55, []any{lang.NewSymbol("iter__0__auto__")}) + tmp57 := checkDerefVar(glojure_DOT_core_list) + tmp58 := lang.Apply(v37, []any{v5}) + tmp59 := lang.Apply(v45, []any{tmp58}) + tmp60 := lang.Apply(tmp57, []any{tmp59}) + tmp61 := lang.Apply(tmp54, []any{tmp56, tmp60}) + tmp62 := lang.Apply(tmp53, []any{tmp61}) + tmp63 := lang.Apply(tmp51, []any{tmp52, tmp62}) + tmp64 := lang.Apply(tmp50, []any{tmp63}) + tmp65 := checkDerefVar(glojure_DOT_core_list) + tmp66 := checkDerefVar(glojure_DOT_core_seq) + tmp67 := checkDerefVar(glojure_DOT_core_concat) + tmp68 := checkDerefVar(glojure_DOT_core_list) + tmp69 := lang.Apply(tmp68, []any{lang.NewSymbol("iter__0__auto__")}) + tmp70 := checkDerefVar(glojure_DOT_core_list) + tmp71 := checkDerefVar(glojure_DOT_core_second) + tmp72 := lang.Apply(tmp71, []any{v5}) + tmp73 := lang.Apply(tmp70, []any{tmp72}) + tmp74 := lang.Apply(tmp67, []any{tmp69, tmp73}) + tmp75 := lang.Apply(tmp66, []any{tmp74}) + tmp76 := lang.Apply(tmp65, []any{tmp75}) + tmp77 := lang.Apply(tmp47, []any{tmp49, tmp64, tmp76}) + tmp78 := lang.Apply(tmp46, []any{tmp77}) + tmp33 = tmp78 + } // end let + return tmp33 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // force + { + tmp0 := lang.NewSymbol("force").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "If x is a Delay, returns the (possibly cached) value of its expression, else returns x", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(754), lang.NewKeyword("end-line"), int(754))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(nil, "force") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("force is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // format + { + tmp0 := lang.NewSymbol("format").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fmt"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Formats a string using java.lang.String.format, see java.util.Formatter for format\n string syntax", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5717), lang.NewKeyword("end-line"), int(5717))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any = lang.NewList(args[1:]...) + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_apply) + tmp6 := lang.Apply(tmp5, []any{fmt.Sprintf, v3, v4}) + return tmp6 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // frequencies + { + tmp0 := lang.NewSymbol("frequencies").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a map from distinct items in coll to the number of times\n they appear.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7185), lang.NewKeyword("end-line"), int(7185))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_persistent_BANG_) + tmp5 := checkDerefVar(glojure_DOT_core_reduce) + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + tmp9 := checkDerefVar(glojure_DOT_core_assoc_BANG_) + tmp10 := checkDerefVar(glojure_DOT_core_inc) + tmp11 := checkDerefVar(glojure_DOT_core_get) + tmp12 := lang.Apply(tmp11, []any{v7, v8, int64(0)}) + tmp13 := lang.Apply(tmp10, []any{tmp12}) + tmp14 := lang.Apply(tmp9, []any{v7, v8, tmp13}) + return tmp14 + }) + tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7192), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(7193), lang.NewKeyword("end-column"), int(54)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp9 := checkDerefVar(glojure_DOT_core_transient) + tmp10 := lang.NewMap() + tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7194), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(7194), lang.NewKeyword("end-column"), int(24)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := lang.Apply(tmp9, []any{tmp12}) + tmp14 := lang.Apply(tmp5, []any{tmp8, tmp13, v3}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // future + { + tmp0 := lang.NewSymbol("future").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Takes a body of expressions and yields a future object that will\n invoke the body in another thread, and will cache the result and\n return it on all subsequent calls to deref/@. If the computation has\n not yet finished, calls to deref/@ will block, unless the variant of\n deref with timeout is used. See also - realized?.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7009), lang.NewKeyword("end-line"), int(7009))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := checkDerefVar(glojure_DOT_core_seq) + tmp7 := checkDerefVar(glojure_DOT_core_concat) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("glojure.core/future-call")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := checkDerefVar(glojure_DOT_core_seq) + tmp12 := checkDerefVar(glojure_DOT_core_concat) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("fn*")}) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := checkDerefVar(glojure_DOT_core_apply) + tmp17 := checkDerefVar(glojure_DOT_core_vector) + tmp18 := checkDerefVar(glojure_DOT_core_seq) + tmp19 := checkDerefVar(glojure_DOT_core_concat) + tmp20 := lang.Apply(tmp19, nil) + tmp21 := lang.Apply(tmp18, []any{tmp20}) + tmp22 := lang.Apply(tmp16, []any{tmp17, tmp21}) + tmp23 := lang.Apply(tmp15, []any{tmp22}) + tmp24 := lang.Apply(tmp12, []any{tmp14, tmp23, v5}) + tmp25 := lang.Apply(tmp11, []any{tmp24}) + tmp26 := lang.Apply(tmp10, []any{tmp25}) + tmp27 := lang.Apply(tmp7, []any{tmp9, tmp26}) + tmp28 := lang.Apply(tmp6, []any{tmp27}) + return tmp28 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // future-call + { + tmp0 := lang.NewSymbol("future-call").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Takes a function of no args and yields a future object that will\n invoke the function in another thread, and will cache the result and\n return it on all subsequent calls to deref/@. If the computation has\n not yet finished, calls to deref/@ will block, unless the variant\n of deref with timeout is used. See also - realized?.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7003), lang.NewKeyword("end-line"), int(7003))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + { // let + // let binding "f" + tmp5 := checkDerefVar(glojure_DOT_core_binding_conveyor_fn) + tmp6 := lang.Apply(tmp5, []any{v3}) + var v7 any = tmp6 + _ = v7 + // let binding "fut" + tmp8 := lang.Apply(lang.AgentSubmit, []any{v7}) + var v9 any = tmp8 + _ = v9 + tmp4 = v9 + } // end let + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // future-cancel + { + tmp0 := lang.NewSymbol("future-cancel").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Cancels the future, if possible.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7019), lang.NewKeyword("end-line"), int(7019))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v3, "cancel") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("cancel is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{true}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // future-cancelled? + { + tmp0 := lang.NewSymbol("future-cancelled?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Returns true if future f is cancelled", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7025), lang.NewKeyword("end-line"), int(7025))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4, ok := lang.FieldOrMethod(v3, "isCancelled") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "isCancelled"))) + } + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { + case reflect.Func: + tmp5 = lang.Apply(tmp4, nil) + default: + tmp5 = tmp4 + } + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // future-done? + { + tmp0 := lang.NewSymbol("future-done?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Returns true if future f is done", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6538), lang.NewKeyword("end-line"), int(6538))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4, ok := lang.FieldOrMethod(v3, "isDone") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "isDone"))) + } + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { + case reflect.Func: + tmp5 = lang.Apply(tmp4, nil) + default: + tmp5 = tmp4 + } + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // future? + { + tmp0 := lang.NewSymbol("future?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is a future", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6532), lang.NewKeyword("end-line"), int(6532))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp5 := lang.Apply(tmp4, []any{nil, v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // gen-class + { + tmp0 := lang.NewSymbol("gen-class").WithMeta(lang.NewMap()).(*lang.Symbol) + tmp1 := ns.Intern(tmp0) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // gensym + { + tmp0 := lang.NewSymbol("gensym").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("prefix-string"))), lang.NewKeyword("doc"), "Returns a new symbol with a unique name. If a prefix string is\n supplied, the name is prefix# where # is some unique number. If\n prefix is not supplied, the prefix is 'G__'.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(599), lang.NewKeyword("end-line"), int(599))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp3 := checkDerefVar(glojure_DOT_core_gensym) + tmp4 := lang.Apply(tmp3, []any{"G__"}) + return tmp4 + case 1: + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_str) + tmp5 := checkDerefVar(glojure_DOT_core_str) + tmp6, _ := lang.FieldOrMethod(runtime7.RT, "NextID") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("NextID is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{}) + tmp8 := lang.Apply(tmp5, []any{tmp7}) + tmp9 := lang.Apply(tmp4, []any{v3, tmp8}) + tmp10 := lang.Apply(lang.NewSymbol, []any{tmp9}) + return tmp10 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // get + { + var tmp1 lang.FnFunc + { // function get__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := checkDerefVar(glojure_DOT_core_seq) + tmp7 := checkDerefVar(glojure_DOT_core_concat) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol(".")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + tmp12 := checkDerefVar(glojure_DOT_core_list) + tmp13 := checkDerefVar(glojure_DOT_core_seq) + tmp14 := checkDerefVar(glojure_DOT_core_concat) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("glojure.core/Get")}) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v4}) + tmp21 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp20, v5}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp12, []any{tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp9, tmp11, tmp23}) + tmp25 := lang.Apply(tmp6, []any{tmp24}) + return tmp25 + } + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("get").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"), lang.NewSymbol("not-found"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the value mapped to key, not-found or nil if key not present\n in associative collection, set, string, array, or ILookup instance.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2), int64(3)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1489), lang.NewKeyword("end-line"), int(1489))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6 := lang.Apply(lang.Get, []any{v4, v5}) + return tmp6 + case 3: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := args[2] + _ = v6 + tmp7 := lang.Apply(lang.GetDefault, []any{v4, v5, v6}) + return tmp7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // get-in + { + tmp0 := lang.NewSymbol("get-in").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("ks")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("ks"), lang.NewSymbol("not-found"))), lang.NewKeyword("doc"), "Returns the value in a nested associative structure,\n where ks is a sequence of keys. Returns nil if the key\n is not present, or the not-found value if supplied.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6128), lang.NewKeyword("end-line"), int(6128))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_reduce1) + tmp6 := checkDerefVar(glojure_DOT_core_get) + tmp7 := lang.Apply(tmp5, []any{tmp6, v3, v4}) + return tmp7 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var tmp6 any + { // let + // let binding "sentinel" + tmp7 := lang.Apply(reflect.StructOf, []any{nil}) + tmp8 := lang.Apply(reflect.New, []any{tmp7}) + tmp9, ok := lang.FieldOrMethod(tmp8, "Interface") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp8, "Interface"))) + } + var tmp10 any + switch reflect.TypeOf(tmp9).Kind() { + case reflect.Func: + tmp10 = lang.Apply(tmp9, nil) + default: + tmp10 = tmp9 + } + var v11 any = tmp10 + _ = v11 + // let binding "m" + var v12 any = v3 + _ = v12 + // let binding "ks" + tmp13 := checkDerefVar(glojure_DOT_core_seq) + tmp14 := lang.Apply(tmp13, []any{v4}) + var v15 any = tmp14 + _ = v15 + for { + var tmp16 any + if lang.IsTruthy(v15) { + var tmp17 any + { // let + // let binding "m" + tmp18 := checkDerefVar(glojure_DOT_core_get) + tmp19 := checkDerefVar(glojure_DOT_core_first) + tmp20 := lang.Apply(tmp19, []any{v15}) + tmp21 := lang.Apply(tmp18, []any{v12, tmp20, v11}) + var v22 any = tmp21 + _ = v22 + var tmp23 any + tmp24 := checkDerefVar(glojure_DOT_core_identical_QMARK_) + tmp25 := lang.Apply(tmp24, []any{v11, v22}) + if lang.IsTruthy(tmp25) { + tmp23 = v5 + } else { + var tmp26 any = v11 + var tmp27 any = v22 + tmp29 := checkDerefVar(glojure_DOT_core_next) + tmp30 := lang.Apply(tmp29, []any{v15}) + var tmp28 any = tmp30 + v11 = tmp26 + v12 = tmp27 + v15 = tmp28 + continue + } + tmp17 = tmp23 + } // end let + tmp16 = tmp17 + } else { + tmp16 = v12 + } + tmp6 = tmp16 + break + } + } // end let + return tmp6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // get-method + { + tmp0 := lang.NewSymbol("get-method").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"), lang.NewSymbol("dispatch-val"))), lang.NewKeyword("doc"), "Given a multimethod and a dispatch value, returns the dispatch fn\n that would apply to that value, or nil if none apply and no default", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1815), lang.NewKeyword("end-line"), int(1815))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(v3, "getMethod") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getMethod is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // get-thread-bindings + { + tmp0 := lang.NewSymbol("get-thread-bindings").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Get a map with the Var/value pairs which is currently in effect for the\n current thread.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1937), lang.NewKeyword("end-line"), int(1937))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + tmp3 := lang.Apply(nil, nil) + return tmp3 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // get-validator + { + tmp0 := lang.NewSymbol("get-validator").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("iref"))), lang.NewKeyword("doc"), "Gets the validator-fn for a var/ref/agent/atom.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2392), lang.NewKeyword("end-line"), int(2392))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v3, "getValidator") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getValidator is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // global-hierarchy + { + tmp0 := lang.NewSymbol("global-hierarchy").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5513), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(5514), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, lang.NewMap(lang.NewKeyword("parents"), lang.NewMap(), lang.NewKeyword("descendants"), lang.NewMap(), lang.NewKeyword("ancestors"), lang.NewMap()), true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // group-by + { + tmp0 := lang.NewSymbol("group-by").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a map of the elements of coll keyed by the result of\n f on each element. The value at each key will be a vector of the\n corresponding elements, in the order they appeared in coll.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7128), lang.NewKeyword("end-line"), int(7128))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_persistent_BANG_) + tmp6 := checkDerefVar(glojure_DOT_core_reduce) + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + var tmp10 any + { // let + // let binding "k" + tmp11 := lang.Apply(v3, []any{v9}) + var v12 any = tmp11 + _ = v12 + tmp13 := checkDerefVar(glojure_DOT_core_assoc_BANG_) + tmp14 := checkDerefVar(glojure_DOT_core_conj) + tmp15 := checkDerefVar(glojure_DOT_core_get) + tmp16 := lang.NewVector() + tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7139), lang.NewKeyword("column"), int(40), lang.NewKeyword("end-line"), int(7139), lang.NewKeyword("end-column"), int(41)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp19 := lang.Apply(tmp15, []any{v8, v12, tmp18}) + tmp20 := lang.Apply(tmp14, []any{tmp19, v9}) + tmp21 := lang.Apply(tmp13, []any{v8, v12, tmp20}) + tmp10 = tmp21 + } // end let + return tmp10 + }) + tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7137), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(7139), lang.NewKeyword("end-column"), int(48)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp10 := checkDerefVar(glojure_DOT_core_transient) + tmp11 := lang.NewMap() + tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7140), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(7140), lang.NewKeyword("end-column"), int(17)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp14 := lang.Apply(tmp10, []any{tmp13}) + tmp15 := lang.Apply(tmp6, []any{tmp9, tmp14, v4}) + tmp16 := lang.Apply(tmp5, []any{tmp15}) + return tmp16 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // halt-when + { + tmp0 := lang.NewSymbol("halt-when").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred")), lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("retf"))), lang.NewKeyword("doc"), "Returns a transducer that ends transduction when pred returns true\n for an input. When retf is supplied it must be a fn of 2 arguments -\n it will be passed the (completed) result so far and the input that\n triggered the predicate, and its return value (if it does not throw\n an exception) will be the return value of the transducer. If retf\n is not supplied, the input that triggered the predicate will be\n returned. If the predicate never returns true the transduction is\n unaffected.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7657), lang.NewKeyword("end-line"), int(7657))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_halt_when) + tmp5 := lang.Apply(tmp4, []any{v3, nil}) + return tmp5 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v6 := args[0] + _ = v6 + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp8 := lang.Apply(v6, nil) + return tmp8 + case 1: + v8 := args[0] + _ = v8 + var tmp9 any + var tmp10 any + { // let + // let binding "and__0__auto__" + tmp11 := checkDerefVar(glojure_DOT_core_map_QMARK_) + tmp12 := lang.Apply(tmp11, []any{v8}) + var v13 any = tmp12 + _ = v13 + var tmp14 any + if lang.IsTruthy(v13) { + tmp15 := checkDerefVar(glojure_DOT_core_contains_QMARK_) + tmp16 := lang.Apply(tmp15, []any{v8, lang.NewKeyword("glojure.core/halt")}) + tmp14 = tmp16 + } else { + tmp14 = v13 + } + tmp10 = tmp14 + } // end let + if lang.IsTruthy(tmp10) { + tmp11 := lang.Apply(lang.NewKeyword("glojure.core/halt"), []any{v8}) + tmp9 = tmp11 + } else { + tmp12 := lang.Apply(v6, []any{v8}) + tmp9 = tmp12 + } + return tmp9 + case 2: + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + var tmp10 any + tmp11 := lang.Apply(v3, []any{v9}) + if lang.IsTruthy(tmp11) { + tmp12 := checkDerefVar(glojure_DOT_core_reduced) + var tmp13 any + if lang.IsTruthy(v4) { + tmp14 := lang.Apply(v6, []any{v8}) + tmp15 := lang.Apply(v4, []any{tmp14, v9}) + tmp13 = tmp15 + } else { + tmp13 = v9 + } + tmp16 := lang.NewMap(lang.NewKeyword("glojure.core/halt"), tmp13) + tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7678), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(7678), lang.NewKeyword("end-column"), int(72)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp19 := lang.Apply(tmp12, []any{tmp18}) + tmp10 = tmp19 + } else { + tmp20 := lang.Apply(v6, []any{v8, v9}) + tmp10 = tmp20 + } + return tmp10 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7670), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7679), lang.NewKeyword("end-column"), int(34)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp9 + }) + tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7669), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7679), lang.NewKeyword("end-column"), int(35)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // hash + { + tmp0 := lang.NewSymbol("hash").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns the hash code of its argument. Note this is the hash code\n consistent with =, and thus is different than .hashCode for Integer,\n Short, Byte and Clojure collections.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5189), lang.NewKeyword("end-line"), int(5189))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.HashEq, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // hash-map + { + tmp0 := lang.NewSymbol("hash-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keyvals"))), lang.NewKeyword("doc"), "keyval => key val\n Returns a new hash map with supplied mappings. If any keys are\n equal, they are handled as if by repeated uses of assoc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(378), lang.NewKeyword("end-line"), int(378))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp3 := lang.NewMap() + tmp4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(384), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(384), lang.NewKeyword("end-column"), int(8)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := lang.Apply(lang.CreatePersistentHashMap, []any{v3}) + return tmp4 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // hash-ordered-coll + { + tmp0 := lang.NewSymbol("hash-ordered-coll").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns the hash code, consistent with =, for an external ordered\n collection implementing Iterable.\n See http://glojure.org/data_structures#hash for full algorithms.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5210), lang.NewKeyword("end-line"), int(5210))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(nil, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // hash-set + { + tmp0 := lang.NewSymbol("hash-set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keys"))), lang.NewKeyword("doc"), "Returns a new hash set with supplied keys. Any equal keys are\n handled as if by repeated uses of conj.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(388), lang.NewKeyword("end-line"), int(388))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp3 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(393), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(393), lang.NewKeyword("end-column"), int(9)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := lang.Apply(nil, []any{v3}) + return tmp4 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // hash-unordered-coll + { + tmp0 := lang.NewSymbol("hash-unordered-coll").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns the hash code, consistent with =, for an external unordered\n collection implementing Iterable. For maps, the iterator should\n return map entries whose hash is computed as\n (hash-ordered-coll [k v]).\n See http://glojure.org/data_structures#hash for full algorithms.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5219), lang.NewKeyword("end-line"), int(5219))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(nil, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ident? + { + tmp0 := lang.NewSymbol("ident?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a symbol or keyword", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1608), lang.NewKeyword("end-line"), int(1608))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + { // let + // let binding "or__0__auto__" + tmp5 := checkDerefVar(glojure_DOT_core_keyword_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + if lang.IsTruthy(v7) { + tmp8 = v7 + } else { + tmp9 := checkDerefVar(glojure_DOT_core_symbol_QMARK_) + tmp10 := lang.Apply(tmp9, []any{v3}) + tmp8 = tmp10 + } + tmp4 = tmp8 + } // end let + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // identical? + { + var tmp1 lang.FnFunc + { // function identical?__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_seq) + tmp6 := checkDerefVar(glojure_DOT_core_concat) + tmp7 := checkDerefVar(glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{lang.NewSymbol(".")}) + tmp9 := checkDerefVar(glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("glojure.lang.Util")}) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{lang.NewSymbol("glojure.core/identical")}) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{v3}) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v4}) + tmp17 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp12, tmp14, tmp16}) + tmp18 := lang.Apply(tmp5, []any{tmp17}) + return tmp18 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("identical?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Tests if 2 arguments are the same object", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(768), lang.NewKeyword("end-line"), int(768))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6 := lang.Apply(lang.Identical, []any{v4, v5}) + return tmp6 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // identity + { + tmp0 := lang.NewSymbol("identity").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns its argument.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1446), lang.NewKeyword("end-line"), int(1446))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + return v3 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // if-let + { + tmp0 := lang.NewSymbol("if-let").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("then")), lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("then"), lang.NewSymbol("else"), lang.NewSymbol("&"), lang.NewSymbol("oldform"))), lang.NewKeyword("doc"), "bindings => binding-form test\n\n If test is true, evaluates then with binding-form bound to the value of \n test, if not, yields else", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1839), lang.NewKeyword("end-line"), int(1839))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 4: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_seq) + tmp8 := checkDerefVar(glojure_DOT_core_concat) + tmp9 := checkDerefVar(glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("glojure.core/if-let")}) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{v5}) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{v6}) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{nil}) + tmp17 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp14, tmp16}) + tmp18 := lang.Apply(tmp7, []any{tmp17}) + return tmp18 + default: + if len(args) < 5 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := args[4] + _ = v7 + var v8 any = lang.NewList(args[5:]...) + _ = v8 + var tmp9 any + tmp10 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp11 := lang.Apply(tmp10, []any{v5}) + if lang.IsTruthy(tmp11) { + } else { + tmp12 := checkDerefVar(glojure_DOT_core_str) + tmp13 := checkDerefVar(glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v3}) + tmp15 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) + tmp16 := checkDerefVar(glojure_DOT_core_meta) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := lang.Apply(lang.NewKeyword("line"), []any{tmp17}) + tmp19 := lang.Apply(tmp12, []any{tmp14, " requires ", "a vector for its binding", " in ", tmp15, ":", tmp18}) + tmp20 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp19}) + panic(tmp20) + } + _ = tmp9 + var tmp21 any + tmp22 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp23 := lang.Apply(tmp22, []any{v8}) + if lang.IsTruthy(tmp23) { + } else { + tmp24 := checkDerefVar(glojure_DOT_core_str) + tmp25 := checkDerefVar(glojure_DOT_core_first) + tmp26 := lang.Apply(tmp25, []any{v3}) + tmp27 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) + tmp28 := checkDerefVar(glojure_DOT_core_meta) + tmp29 := lang.Apply(tmp28, []any{v3}) + tmp30 := lang.Apply(lang.NewKeyword("line"), []any{tmp29}) + tmp31 := lang.Apply(tmp24, []any{tmp26, " requires ", "1 or 2 forms after binding vector", " in ", tmp27, ":", tmp30}) + tmp32 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp31}) + panic(tmp32) + } + _ = tmp21 + var tmp33 any + tmp34 := checkDerefVar(glojure_DOT_core__EQ_) + tmp35 := checkDerefVar(glojure_DOT_core_count) + tmp36 := lang.Apply(tmp35, []any{v5}) + tmp37 := lang.Apply(tmp34, []any{int64(2), tmp36}) + if lang.IsTruthy(tmp37) { + } else { + tmp38 := checkDerefVar(glojure_DOT_core_str) + tmp39 := checkDerefVar(glojure_DOT_core_first) + tmp40 := lang.Apply(tmp39, []any{v3}) + tmp41 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) + tmp42 := checkDerefVar(glojure_DOT_core_meta) + tmp43 := lang.Apply(tmp42, []any{v3}) + tmp44 := lang.Apply(lang.NewKeyword("line"), []any{tmp43}) + tmp45 := lang.Apply(tmp38, []any{tmp40, " requires ", "exactly 2 forms in binding vector", " in ", tmp41, ":", tmp44}) + tmp46 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp45}) + panic(tmp46) + } + _ = tmp33 + var tmp47 any + { // let + // let binding "form" + tmp48 := lang.Apply(v5, []any{int64(0)}) + var v49 any = tmp48 + _ = v49 + // let binding "tst" + tmp50 := lang.Apply(v5, []any{int64(1)}) + var v51 any = tmp50 + _ = v51 + tmp52 := checkDerefVar(glojure_DOT_core_seq) + tmp53 := checkDerefVar(glojure_DOT_core_concat) + tmp54 := checkDerefVar(glojure_DOT_core_list) + tmp55 := lang.Apply(tmp54, []any{lang.NewSymbol("glojure.core/let")}) + tmp56 := checkDerefVar(glojure_DOT_core_list) + tmp57 := checkDerefVar(glojure_DOT_core_apply) + tmp58 := checkDerefVar(glojure_DOT_core_vector) + tmp59 := checkDerefVar(glojure_DOT_core_seq) + tmp60 := checkDerefVar(glojure_DOT_core_concat) + tmp61 := checkDerefVar(glojure_DOT_core_list) + tmp62 := lang.Apply(tmp61, []any{lang.NewSymbol("temp__0__auto__")}) + tmp63 := checkDerefVar(glojure_DOT_core_list) + tmp64 := lang.Apply(tmp63, []any{v51}) + tmp65 := lang.Apply(tmp60, []any{tmp62, tmp64}) + tmp66 := lang.Apply(tmp59, []any{tmp65}) + tmp67 := lang.Apply(tmp57, []any{tmp58, tmp66}) + tmp68 := lang.Apply(tmp56, []any{tmp67}) + tmp69 := checkDerefVar(glojure_DOT_core_list) + tmp70 := checkDerefVar(glojure_DOT_core_seq) + tmp71 := checkDerefVar(glojure_DOT_core_concat) + tmp72 := checkDerefVar(glojure_DOT_core_list) + tmp73 := lang.Apply(tmp72, []any{lang.NewSymbol("if")}) + tmp74 := checkDerefVar(glojure_DOT_core_list) + tmp75 := lang.Apply(tmp74, []any{lang.NewSymbol("temp__0__auto__")}) + tmp76 := checkDerefVar(glojure_DOT_core_list) + tmp77 := checkDerefVar(glojure_DOT_core_seq) + tmp78 := checkDerefVar(glojure_DOT_core_concat) + tmp79 := checkDerefVar(glojure_DOT_core_list) + tmp80 := lang.Apply(tmp79, []any{lang.NewSymbol("glojure.core/let")}) + tmp81 := checkDerefVar(glojure_DOT_core_list) + tmp82 := checkDerefVar(glojure_DOT_core_apply) + tmp83 := checkDerefVar(glojure_DOT_core_vector) + tmp84 := checkDerefVar(glojure_DOT_core_seq) + tmp85 := checkDerefVar(glojure_DOT_core_concat) + tmp86 := checkDerefVar(glojure_DOT_core_list) + tmp87 := lang.Apply(tmp86, []any{v49}) + tmp88 := checkDerefVar(glojure_DOT_core_list) + tmp89 := lang.Apply(tmp88, []any{lang.NewSymbol("temp__0__auto__")}) + tmp90 := lang.Apply(tmp85, []any{tmp87, tmp89}) + tmp91 := lang.Apply(tmp84, []any{tmp90}) + tmp92 := lang.Apply(tmp82, []any{tmp83, tmp91}) + tmp93 := lang.Apply(tmp81, []any{tmp92}) + tmp94 := checkDerefVar(glojure_DOT_core_list) + tmp95 := lang.Apply(tmp94, []any{v6}) + tmp96 := lang.Apply(tmp78, []any{tmp80, tmp93, tmp95}) + tmp97 := lang.Apply(tmp77, []any{tmp96}) + tmp98 := lang.Apply(tmp76, []any{tmp97}) + tmp99 := checkDerefVar(glojure_DOT_core_list) + tmp100 := lang.Apply(tmp99, []any{v7}) + tmp101 := lang.Apply(tmp71, []any{tmp73, tmp75, tmp98, tmp100}) + tmp102 := lang.Apply(tmp70, []any{tmp101}) + tmp103 := lang.Apply(tmp69, []any{tmp102}) + tmp104 := lang.Apply(tmp53, []any{tmp55, tmp68, tmp103}) + tmp105 := lang.Apply(tmp52, []any{tmp104}) + tmp47 = tmp105 + } // end let + return tmp47 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // if-not + { + tmp0 := lang.NewSymbol("if-not").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("test"), lang.NewSymbol("then")), lang.NewVector(lang.NewSymbol("test"), lang.NewSymbol("then"), lang.NewSymbol("else"))), lang.NewKeyword("doc"), "Evaluates test. If logical false, evaluates and returns then expr, \n otherwise else expr, if supplied, else nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(760), lang.NewKeyword("end-line"), int(760))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 4: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_seq) + tmp8 := checkDerefVar(glojure_DOT_core_concat) + tmp9 := checkDerefVar(glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("glojure.core/if-not")}) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{v5}) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{v6}) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{nil}) + tmp17 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp14, tmp16}) + tmp18 := lang.Apply(tmp7, []any{tmp17}) + return tmp18 + case 5: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := args[4] + _ = v7 + tmp8 := checkDerefVar(glojure_DOT_core_seq) + tmp9 := checkDerefVar(glojure_DOT_core_concat) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol("if")}) + tmp12 := checkDerefVar(glojure_DOT_core_list) + tmp13 := checkDerefVar(glojure_DOT_core_seq) + tmp14 := checkDerefVar(glojure_DOT_core_concat) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("glojure.core/not")}) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v5}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v6}) + tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v7}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp21, tmp23, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + return tmp27 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // if-some + { + tmp0 := lang.NewSymbol("if-some").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("then")), lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("then"), lang.NewSymbol("else"), lang.NewSymbol("&"), lang.NewSymbol("oldform"))), lang.NewKeyword("doc"), "bindings => binding-form test\n\n If test is not nil, evaluates then with binding-form bound to the\n value of test, if not, yields else", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1874), lang.NewKeyword("end-line"), int(1874))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 4: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_seq) + tmp8 := checkDerefVar(glojure_DOT_core_concat) + tmp9 := checkDerefVar(glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("glojure.core/if-some")}) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{v5}) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{v6}) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{nil}) + tmp17 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp14, tmp16}) + tmp18 := lang.Apply(tmp7, []any{tmp17}) + return tmp18 + default: + if len(args) < 5 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := args[4] + _ = v7 + var v8 any = lang.NewList(args[5:]...) + _ = v8 + var tmp9 any + tmp10 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp11 := lang.Apply(tmp10, []any{v5}) + if lang.IsTruthy(tmp11) { + } else { + tmp12 := checkDerefVar(glojure_DOT_core_str) + tmp13 := checkDerefVar(glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v3}) + tmp15 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) + tmp16 := checkDerefVar(glojure_DOT_core_meta) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := lang.Apply(lang.NewKeyword("line"), []any{tmp17}) + tmp19 := lang.Apply(tmp12, []any{tmp14, " requires ", "a vector for its binding", " in ", tmp15, ":", tmp18}) + tmp20 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp19}) + panic(tmp20) + } + _ = tmp9 + var tmp21 any + tmp22 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp23 := lang.Apply(tmp22, []any{v8}) + if lang.IsTruthy(tmp23) { + } else { + tmp24 := checkDerefVar(glojure_DOT_core_str) + tmp25 := checkDerefVar(glojure_DOT_core_first) + tmp26 := lang.Apply(tmp25, []any{v3}) + tmp27 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) + tmp28 := checkDerefVar(glojure_DOT_core_meta) + tmp29 := lang.Apply(tmp28, []any{v3}) + tmp30 := lang.Apply(lang.NewKeyword("line"), []any{tmp29}) + tmp31 := lang.Apply(tmp24, []any{tmp26, " requires ", "1 or 2 forms after binding vector", " in ", tmp27, ":", tmp30}) + tmp32 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp31}) + panic(tmp32) + } + _ = tmp21 + var tmp33 any + tmp34 := checkDerefVar(glojure_DOT_core__EQ_) + tmp35 := checkDerefVar(glojure_DOT_core_count) + tmp36 := lang.Apply(tmp35, []any{v5}) + tmp37 := lang.Apply(tmp34, []any{int64(2), tmp36}) + if lang.IsTruthy(tmp37) { + } else { + tmp38 := checkDerefVar(glojure_DOT_core_str) + tmp39 := checkDerefVar(glojure_DOT_core_first) + tmp40 := lang.Apply(tmp39, []any{v3}) + tmp41 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) + tmp42 := checkDerefVar(glojure_DOT_core_meta) + tmp43 := lang.Apply(tmp42, []any{v3}) + tmp44 := lang.Apply(lang.NewKeyword("line"), []any{tmp43}) + tmp45 := lang.Apply(tmp38, []any{tmp40, " requires ", "exactly 2 forms in binding vector", " in ", tmp41, ":", tmp44}) + tmp46 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp45}) + panic(tmp46) + } + _ = tmp33 + var tmp47 any + { // let + // let binding "form" + tmp48 := lang.Apply(v5, []any{int64(0)}) + var v49 any = tmp48 + _ = v49 + // let binding "tst" + tmp50 := lang.Apply(v5, []any{int64(1)}) + var v51 any = tmp50 + _ = v51 + tmp52 := checkDerefVar(glojure_DOT_core_seq) + tmp53 := checkDerefVar(glojure_DOT_core_concat) + tmp54 := checkDerefVar(glojure_DOT_core_list) + tmp55 := lang.Apply(tmp54, []any{lang.NewSymbol("glojure.core/let")}) + tmp56 := checkDerefVar(glojure_DOT_core_list) + tmp57 := checkDerefVar(glojure_DOT_core_apply) + tmp58 := checkDerefVar(glojure_DOT_core_vector) + tmp59 := checkDerefVar(glojure_DOT_core_seq) + tmp60 := checkDerefVar(glojure_DOT_core_concat) + tmp61 := checkDerefVar(glojure_DOT_core_list) + tmp62 := lang.Apply(tmp61, []any{lang.NewSymbol("temp__0__auto__")}) + tmp63 := checkDerefVar(glojure_DOT_core_list) + tmp64 := lang.Apply(tmp63, []any{v51}) + tmp65 := lang.Apply(tmp60, []any{tmp62, tmp64}) + tmp66 := lang.Apply(tmp59, []any{tmp65}) + tmp67 := lang.Apply(tmp57, []any{tmp58, tmp66}) + tmp68 := lang.Apply(tmp56, []any{tmp67}) + tmp69 := checkDerefVar(glojure_DOT_core_list) + tmp70 := checkDerefVar(glojure_DOT_core_seq) + tmp71 := checkDerefVar(glojure_DOT_core_concat) + tmp72 := checkDerefVar(glojure_DOT_core_list) + tmp73 := lang.Apply(tmp72, []any{lang.NewSymbol("if")}) + tmp74 := checkDerefVar(glojure_DOT_core_list) + tmp75 := checkDerefVar(glojure_DOT_core_seq) + tmp76 := checkDerefVar(glojure_DOT_core_concat) + tmp77 := checkDerefVar(glojure_DOT_core_list) + tmp78 := lang.Apply(tmp77, []any{lang.NewSymbol("glojure.core/nil?")}) + tmp79 := checkDerefVar(glojure_DOT_core_list) + tmp80 := lang.Apply(tmp79, []any{lang.NewSymbol("temp__0__auto__")}) + tmp81 := lang.Apply(tmp76, []any{tmp78, tmp80}) + tmp82 := lang.Apply(tmp75, []any{tmp81}) + tmp83 := lang.Apply(tmp74, []any{tmp82}) + tmp84 := checkDerefVar(glojure_DOT_core_list) + tmp85 := lang.Apply(tmp84, []any{v7}) + tmp86 := checkDerefVar(glojure_DOT_core_list) + tmp87 := checkDerefVar(glojure_DOT_core_seq) + tmp88 := checkDerefVar(glojure_DOT_core_concat) + tmp89 := checkDerefVar(glojure_DOT_core_list) + tmp90 := lang.Apply(tmp89, []any{lang.NewSymbol("glojure.core/let")}) + tmp91 := checkDerefVar(glojure_DOT_core_list) + tmp92 := checkDerefVar(glojure_DOT_core_apply) + tmp93 := checkDerefVar(glojure_DOT_core_vector) + tmp94 := checkDerefVar(glojure_DOT_core_seq) + tmp95 := checkDerefVar(glojure_DOT_core_concat) + tmp96 := checkDerefVar(glojure_DOT_core_list) + tmp97 := lang.Apply(tmp96, []any{v49}) + tmp98 := checkDerefVar(glojure_DOT_core_list) + tmp99 := lang.Apply(tmp98, []any{lang.NewSymbol("temp__0__auto__")}) + tmp100 := lang.Apply(tmp95, []any{tmp97, tmp99}) + tmp101 := lang.Apply(tmp94, []any{tmp100}) + tmp102 := lang.Apply(tmp92, []any{tmp93, tmp101}) + tmp103 := lang.Apply(tmp91, []any{tmp102}) + tmp104 := checkDerefVar(glojure_DOT_core_list) + tmp105 := lang.Apply(tmp104, []any{v6}) + tmp106 := lang.Apply(tmp88, []any{tmp90, tmp103, tmp105}) + tmp107 := lang.Apply(tmp87, []any{tmp106}) + tmp108 := lang.Apply(tmp86, []any{tmp107}) + tmp109 := lang.Apply(tmp71, []any{tmp73, tmp83, tmp85, tmp108}) + tmp110 := lang.Apply(tmp70, []any{tmp109}) + tmp111 := lang.Apply(tmp69, []any{tmp110}) + tmp112 := lang.Apply(tmp53, []any{tmp55, tmp68, tmp111}) + tmp113 := lang.Apply(tmp52, []any{tmp112}) + tmp47 = tmp113 + } // end let + return tmp47 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ifn? + { + tmp0 := lang.NewSymbol("ifn?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements IFn. Note that many data structures\n (e.g. sets and maps) implement IFn", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6209), lang.NewKeyword("end-line"), int(6209))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp5 := lang.Apply(tmp4, []any{nil, v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // import + { + tmp0 := lang.NewSymbol("import").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("import-symbols-or-lists"))), lang.NewKeyword("doc"), "import-list => (package-symbol class-name-symbols*)\n\n For each name in class-name-symbols, adds a mapping from name to the\n class named by package.name to the current namespace. Use :import in the ns\n macro in preference to calling this directly.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3426), lang.NewKeyword("end-line"), int(3426))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + var tmp6 any + { // let + // let binding "specs" + tmp7 := checkDerefVar(glojure_DOT_core_map) + var tmp8 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v9 := args[0] + _ = v9 + var tmp10 any + var tmp11 any + { // let + // let binding "and__0__auto__" + tmp12 := checkDerefVar(glojure_DOT_core_seq_QMARK_) + tmp13 := lang.Apply(tmp12, []any{v9}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + tmp16 := checkDerefVar(glojure_DOT_core__EQ_) + tmp17 := checkDerefVar(glojure_DOT_core_first) + tmp18 := lang.Apply(tmp17, []any{v9}) + tmp19 := lang.Apply(tmp16, []any{lang.NewSymbol("quote"), tmp18}) + tmp15 = tmp19 + } else { + tmp15 = v14 + } + tmp11 = tmp15 + } // end let + if lang.IsTruthy(tmp11) { + tmp12 := checkDerefVar(glojure_DOT_core_second) + tmp13 := lang.Apply(tmp12, []any{v9}) + tmp10 = tmp13 + } else { + tmp10 = v9 + } + return tmp10 + }) + tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3434), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(3434), lang.NewKeyword("end-column"), int(73)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp11 := lang.Apply(tmp7, []any{tmp10, v5}) + var v12 any = tmp11 + _ = v12 + tmp13 := checkDerefVar(glojure_DOT_core_seq) + tmp14 := checkDerefVar(glojure_DOT_core_concat) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("do")}) + tmp17 := checkDerefVar(glojure_DOT_core_map) + var tmp18 lang.FnFunc + tmp18 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v19 := args[0] + _ = v19 + tmp20 := checkDerefVar(glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Import"), v19}) + return tmp21 + }) + tmp19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3436), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(3436), lang.NewKeyword("end-column"), int(73)) + tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp21 := checkDerefVar(glojure_DOT_core_reduce1) + var tmp22 lang.FnFunc + tmp22 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v23 := args[0] + _ = v23 + v24 := args[1] + _ = v24 + var tmp25 any + tmp26 := checkDerefVar(glojure_DOT_core_symbol_QMARK_) + tmp27 := lang.Apply(tmp26, []any{v24}) + if lang.IsTruthy(tmp27) { + tmp28 := checkDerefVar(glojure_DOT_core_conj) + tmp29 := checkDerefVar(glojure_DOT_core_name) + tmp30 := lang.Apply(tmp29, []any{v24}) + tmp31 := lang.Apply(tmp28, []any{v23, tmp30}) + tmp25 = tmp31 + } else { + var tmp32 any + { // let + // let binding "p" + tmp33 := checkDerefVar(glojure_DOT_core_first) + tmp34 := lang.Apply(tmp33, []any{v24}) + var v35 any = tmp34 + _ = v35 + // let binding "cs" + tmp36 := checkDerefVar(glojure_DOT_core_rest) + tmp37 := lang.Apply(tmp36, []any{v24}) + var v38 any = tmp37 + _ = v38 + tmp39 := checkDerefVar(glojure_DOT_core_into1) + tmp40 := checkDerefVar(glojure_DOT_core_map) + var tmp41 lang.FnFunc + tmp41 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v42 := args[0] + _ = v42 + tmp43 := checkDerefVar(glojure_DOT_core_str) + tmp44 := lang.Apply(tmp43, []any{v35, ".", v42}) + return tmp44 + }) + tmp42 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3441), lang.NewKeyword("column"), int(45), lang.NewKeyword("end-line"), int(3441), lang.NewKeyword("end-column"), int(58)) + tmp43, err := lang.WithMeta(tmp41, tmp42.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp44 := lang.Apply(tmp40, []any{tmp43, v38}) + tmp45 := lang.Apply(tmp39, []any{v23, tmp44}) + tmp32 = tmp45 + } // end let + tmp25 = tmp32 + } + return tmp25 + }) + tmp23 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3437), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(3441), lang.NewKeyword("end-column"), int(66)) + tmp24, err := lang.WithMeta(tmp22, tmp23.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp25 := lang.NewVector() + tmp26 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3442), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(3442), lang.NewKeyword("end-column"), int(26)) + tmp27, err := lang.WithMeta(tmp25, tmp26.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp28 := lang.Apply(tmp21, []any{tmp24, tmp27, v12}) + tmp29 := lang.Apply(tmp17, []any{tmp20, tmp28}) + tmp30 := lang.Apply(tmp14, []any{tmp16, tmp29}) + tmp31 := lang.Apply(tmp13, []any{tmp30}) + tmp6 = tmp31 + } // end let + return tmp6 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // inc + { + var tmp1 lang.FnFunc + { // function inc__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := checkDerefVar(glojure_DOT_core_seq) + tmp12 := checkDerefVar(glojure_DOT_core_concat) + tmp13 := checkDerefVar(glojure_DOT_core_list) + var tmp14 any + tmp15 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + if lang.IsTruthy(tmp15) { + tmp14 = lang.NewSymbol("unchecked_inc") + } else { + tmp14 = lang.NewSymbol("inc") + } + tmp16 := lang.Apply(tmp13, []any{tmp14}) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := lang.Apply(tmp12, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp11, []any{tmp19}) + tmp21 := lang.Apply(tmp10, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("inc").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns a number one greater than num. Does not auto-promote\n longs, will throw on overflow. See also: inc'", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(915), lang.NewKeyword("end-line"), int(915))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Inc") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Inc is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // inc' + { + var tmp1 lang.FnFunc + { // function inc'__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := checkDerefVar(glojure_DOT_core_seq) + tmp12 := checkDerefVar(glojure_DOT_core_concat) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/IncP")}) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("inc'").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns a number one greater than num. Supports arbitrary precision.\n See also: inc", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(908), lang.NewKeyword("end-line"), int(908))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "IncP") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("IncP is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // indexed? + { + tmp0 := lang.NewSymbol("indexed?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return true if coll implements Indexed, indicating efficient lookup by index", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6263), lang.NewKeyword("end-line"), int(6263))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp5 := lang.Apply(tmp4, []any{nil, v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // infinite? + { + var tmp1 lang.FnFunc + { // function infinite?__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol("Double/isInfinite")}) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{v3}) + tmp10 := lang.Apply(tmp5, []any{tmp7, tmp9}) + tmp11 := lang.Apply(tmp4, []any{tmp10}) + return tmp11 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("infinite?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns true if num is negative or positive infinity, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1)})), lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7977), lang.NewKeyword("end-line"), int(7977))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5 := lang.Apply(nil, []any{v4}) + return tmp5 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // inst-ms + { + tmp0 := lang.NewSymbol("inst-ms").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("inst"))), lang.NewKeyword("doc"), "Return the number of milliseconds since January 1, 1970, 00:00:00 GMT", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6831), lang.NewKeyword("end-line"), int(6831))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(nil, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // inst? + { + tmp0 := lang.NewSymbol("inst?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x satisfies Inst", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6837), lang.NewKeyword("end-line"), int(6837))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + return nil + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // instance? + { + tmp0 := lang.NewSymbol("instance?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Evaluates x and tests if it is an instance of the type\n t. Returns true or false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(139), lang.NewKeyword("end-line"), int(143))).(*lang.Symbol) + var tmp2 lang.FnFunc + { // function instance? + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6 := lang.Apply(lang.HasType, []any{v4, v5}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(143), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(143), lang.NewKeyword("end-column"), int(85))).(lang.FnFunc) + v3 = tmp2 + _ = v3 + } + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // int + { + var tmp1 lang.FnFunc + { // function int__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := checkDerefVar(glojure_DOT_core_seq) + tmp12 := checkDerefVar(glojure_DOT_core_concat) + tmp13 := checkDerefVar(glojure_DOT_core_list) + var tmp14 any + tmp15 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + if lang.IsTruthy(tmp15) { + tmp14 = lang.NewSymbol("uncheckedIntCast") + } else { + tmp14 = lang.NewSymbol("intCast") + } + tmp16 := lang.Apply(tmp13, []any{tmp14}) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := lang.Apply(tmp12, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp11, []any{tmp19}) + tmp21 := lang.Apply(tmp10, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to int", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(875), lang.NewKeyword("end-line"), int(875))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5, _ := lang.FieldOrMethod(runtime7.RT, "IntCast") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("IntCast is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // int-array + { + var tmp1 lang.FnFunc + { // function int-array__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol("glojure.core/IntArray")}) + tmp12 := checkDerefVar(glojure_DOT_core_list) + tmp13 := checkDerefVar(glojure_DOT_core_seq) + tmp14 := checkDerefVar(glojure_DOT_core_concat) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("glojure.core/args")}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + } + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("int-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Creates an array of ints", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5356), lang.NewKeyword("end-line"), int(5356))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "IntArray") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("IntArray is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "IntArrayInit") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("IntArrayInit is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // int? + { + tmp0 := lang.NewSymbol("int?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a fixed precision integer", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1395), lang.NewKeyword("end-line"), int(1395))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + { // let + // let binding "or__0__auto__" + tmp5 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp6 := lang.Apply(tmp5, []any{lang.Builtins["int64"], v3}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + if lang.IsTruthy(v7) { + tmp8 = v7 + } else { + var tmp9 any + { // let + // let binding "or__0__auto__" + tmp10 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp11 := lang.Apply(tmp10, []any{nil, v3}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + tmp13 = v12 + } else { + var tmp14 any + { // let + // let binding "or__0__auto__" + tmp15 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp16 := lang.Apply(tmp15, []any{nil, v3}) + var v17 any = tmp16 + _ = v17 + var tmp18 any + if lang.IsTruthy(v17) { + tmp18 = v17 + } else { + tmp19 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp20 := lang.Apply(tmp19, []any{nil, v3}) + tmp18 = tmp20 + } + tmp14 = tmp18 + } // end let + tmp13 = tmp14 + } + tmp9 = tmp13 + } // end let + tmp8 = tmp9 + } + tmp4 = tmp8 + } // end let + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // integer? + { + tmp0 := lang.NewSymbol("integer?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is an integer", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1379), lang.NewKeyword("end-line"), int(1379))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.IsInteger, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // interleave + { + tmp0 := lang.NewSymbol("interleave").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("c1")), lang.NewVector(lang.NewSymbol("c1"), lang.NewSymbol("c2")), lang.NewVector(lang.NewSymbol("c1"), lang.NewSymbol("c2"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Returns a lazy seq of the first item in each coll, then the second etc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4308), lang.NewKeyword("end-line"), int(4308))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return lang.NewList() + case 1: + v3 := args[0] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + return v3 + }) + tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) + return tmp5 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var tmp6 any + { // let + // let binding "s1" + tmp7 := checkDerefVar(glojure_DOT_core_seq) + tmp8 := lang.Apply(tmp7, []any{v3}) + var v9 any = tmp8 + _ = v9 + // let binding "s2" + tmp10 := checkDerefVar(glojure_DOT_core_seq) + tmp11 := lang.Apply(tmp10, []any{v4}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + var tmp14 any + { // let + // let binding "and__0__auto__" + var v15 any = v9 + _ = v15 + var tmp16 any + if lang.IsTruthy(v15) { + tmp16 = v12 + } else { + tmp16 = v15 + } + tmp14 = tmp16 + } // end let + if lang.IsTruthy(tmp14) { + tmp15 := checkDerefVar(glojure_DOT_core_cons) + tmp16 := checkDerefVar(glojure_DOT_core_first) + tmp17 := lang.Apply(tmp16, []any{v9}) + tmp18 := checkDerefVar(glojure_DOT_core_cons) + tmp19 := checkDerefVar(glojure_DOT_core_first) + tmp20 := lang.Apply(tmp19, []any{v12}) + tmp21 := checkDerefVar(glojure_DOT_core_interleave) + tmp22 := checkDerefVar(glojure_DOT_core_rest) + tmp23 := lang.Apply(tmp22, []any{v9}) + tmp24 := checkDerefVar(glojure_DOT_core_rest) + tmp25 := lang.Apply(tmp24, []any{v12}) + tmp26 := lang.Apply(tmp21, []any{tmp23, tmp25}) + tmp27 := lang.Apply(tmp18, []any{tmp20, tmp26}) + tmp28 := lang.Apply(tmp15, []any{tmp17, tmp27}) + tmp13 = tmp28 + } else { + } + tmp6 = tmp13 + } // end let + return tmp6 + }) + tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) + return tmp6 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var tmp7 any + { // let + // let binding "ss" + tmp8 := checkDerefVar(glojure_DOT_core_map) + tmp9 := checkDerefVar(glojure_DOT_core_seq) + tmp10 := checkDerefVar(glojure_DOT_core_conj) + tmp11 := lang.Apply(tmp10, []any{v5, v4, v3}) + tmp12 := lang.Apply(tmp8, []any{tmp9, tmp11}) + var v13 any = tmp12 + _ = v13 + var tmp14 any + tmp15 := checkDerefVar(glojure_DOT_core_every_QMARK_) + tmp16 := checkDerefVar(glojure_DOT_core_identity) + tmp17 := lang.Apply(tmp15, []any{tmp16, v13}) + if lang.IsTruthy(tmp17) { + tmp18 := checkDerefVar(glojure_DOT_core_concat) + tmp19 := checkDerefVar(glojure_DOT_core_map) + tmp20 := checkDerefVar(glojure_DOT_core_first) + tmp21 := lang.Apply(tmp19, []any{tmp20, v13}) + tmp22 := checkDerefVar(glojure_DOT_core_apply) + tmp23 := checkDerefVar(glojure_DOT_core_interleave) + tmp24 := checkDerefVar(glojure_DOT_core_map) + tmp25 := checkDerefVar(glojure_DOT_core_rest) + tmp26 := lang.Apply(tmp24, []any{tmp25, v13}) + tmp27 := lang.Apply(tmp22, []any{tmp23, tmp26}) + tmp28 := lang.Apply(tmp18, []any{tmp21, tmp27}) + tmp14 = tmp28 + } else { + } + tmp7 = tmp14 + } // end let + return tmp7 + }) + tmp7 := lang.Apply(lang.NewLazySeq, []any{tmp6}) + return tmp7 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // intern + { + tmp0 := lang.NewSymbol("intern").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name"), lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Finds or creates a var named by the symbol name in the namespace\n ns (which can be a symbol or a namespace), setting its root binding\n to val if supplied. The namespace must exist. The var will adopt any\n metadata from the name symbol. Returns the var.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6311), lang.NewKeyword("end-line"), int(6311))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 any + { // let + // let binding "v" + tmp6 := checkDerefVar(glojure_DOT_core_the_ns) + tmp7 := lang.Apply(tmp6, []any{v3}) + tmp8 := lang.Apply(nil, []any{tmp7, v4}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + tmp11 := checkDerefVar(glojure_DOT_core_meta) + tmp12 := lang.Apply(tmp11, []any{v4}) + if lang.IsTruthy(tmp12) { + tmp13 := checkDerefVar(glojure_DOT_core_meta) + tmp14 := lang.Apply(tmp13, []any{v4}) + tmp15, _ := lang.FieldOrMethod(v9, "setMeta") + if reflect.TypeOf(tmp15).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMeta is not a function"))) + } + tmp16 := lang.Apply(tmp15, []any{tmp14}) + tmp10 = tmp16 + } else { + } + _ = tmp10 + tmp5 = v9 + } // end let + return tmp5 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var tmp6 any + { // let + // let binding "v" + tmp7 := checkDerefVar(glojure_DOT_core_the_ns) + tmp8 := lang.Apply(tmp7, []any{v3}) + tmp9 := lang.Apply(nil, []any{tmp8, v4, v5}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + tmp12 := checkDerefVar(glojure_DOT_core_meta) + tmp13 := lang.Apply(tmp12, []any{v4}) + if lang.IsTruthy(tmp13) { + tmp14 := checkDerefVar(glojure_DOT_core_meta) + tmp15 := lang.Apply(tmp14, []any{v4}) + tmp16, _ := lang.FieldOrMethod(v10, "setMeta") + if reflect.TypeOf(tmp16).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMeta is not a function"))) + } + tmp17 := lang.Apply(tmp16, []any{tmp15}) + tmp11 = tmp17 + } else { + } + _ = tmp11 + tmp6 = v10 + } // end let + return tmp6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // interpose + { + tmp0 := lang.NewSymbol("interpose").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sep")), lang.NewVector(lang.NewSymbol("sep"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy seq of the elements of coll separated by sep.\n Returns a stateful transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5230), lang.NewKeyword("end-line"), int(5230))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + var tmp6 any + { // let + // let binding "started" + tmp7 := checkDerefVar(glojure_DOT_core_volatile_BANG_) + tmp8 := lang.Apply(tmp7, []any{false}) + var v9 any = tmp8 + _ = v9 + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp11 := lang.Apply(v5, nil) + return tmp11 + case 1: + v11 := args[0] + _ = v11 + tmp12 := lang.Apply(v5, []any{v11}) + return tmp12 + case 2: + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + var tmp13 any + tmp14 := checkDerefVar(glojure_DOT_core_deref) + tmp15 := lang.Apply(tmp14, []any{v9}) + if lang.IsTruthy(tmp15) { + var tmp16 any + { // let + // let binding "sepr" + tmp17 := lang.Apply(v5, []any{v11, v3}) + var v18 any = tmp17 + _ = v18 + var tmp19 any + tmp20 := checkDerefVar(glojure_DOT_core_reduced_QMARK_) + tmp21 := lang.Apply(tmp20, []any{v18}) + if lang.IsTruthy(tmp21) { + tmp19 = v18 + } else { + tmp22 := lang.Apply(v5, []any{v18, v12}) + tmp19 = tmp22 + } + tmp16 = tmp19 + } // end let + tmp13 = tmp16 + } else { + tmp17 := checkDerefVar(glojure_DOT_core_vreset_BANG_) + tmp18 := lang.Apply(tmp17, []any{v9, true}) + _ = tmp18 + tmp19 := lang.Apply(v5, []any{v11, v12}) + tmp13 = tmp19 + } + return tmp13 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5238), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(5249), lang.NewKeyword("end-column"), int(35)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp6 = tmp12 + } // end let + return tmp6 + }) + tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5236), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(5249), lang.NewKeyword("end-column"), int(37)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_drop) + tmp6 := checkDerefVar(glojure_DOT_core_interleave) + tmp7 := checkDerefVar(glojure_DOT_core_repeat) + tmp8 := lang.Apply(tmp7, []any{v3}) + tmp9 := lang.Apply(tmp6, []any{tmp8, v4}) + tmp10 := lang.Apply(tmp5, []any{int64(1), tmp9}) + return tmp10 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // into + { + tmp0 := lang.NewSymbol("into").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("to")), lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("from")), lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("xform"), lang.NewSymbol("from"))), lang.NewKeyword("doc"), "Returns a new coll consisting of to with all of the items of\n from conjoined. A transducer may be supplied.\n (into x) returns x. (into) returns [].", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6922), lang.NewKeyword("end-line"), int(6922))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp3 := lang.NewVector() + tmp4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6928), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(6928), lang.NewKeyword("end-column"), int(8)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 1: + v3 := args[0] + _ = v3 + return v3 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp7 := reflect.TypeOf((*lang.IEditableCollection)(nil)).Elem() + tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) + if lang.IsTruthy(tmp8) { + tmp9 := checkDerefVar(glojure_DOT_core_with_meta) + tmp10 := checkDerefVar(glojure_DOT_core_persistent_BANG_) + tmp11 := checkDerefVar(glojure_DOT_core_reduce) + tmp12 := checkDerefVar(glojure_DOT_core_conj_BANG_) + tmp13 := checkDerefVar(glojure_DOT_core_transient) + tmp14 := lang.Apply(tmp13, []any{v3}) + tmp15 := lang.Apply(tmp11, []any{tmp12, tmp14, v4}) + tmp16 := lang.Apply(tmp10, []any{tmp15}) + tmp17 := checkDerefVar(glojure_DOT_core_meta) + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := lang.Apply(tmp9, []any{tmp16, tmp18}) + tmp5 = tmp19 + } else { + tmp20 := checkDerefVar(glojure_DOT_core_reduce) + tmp21 := checkDerefVar(glojure_DOT_core_conj) + tmp22 := lang.Apply(tmp20, []any{tmp21, v3, v4}) + tmp5 = tmp22 + } + return tmp5 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp8 := reflect.TypeOf((*lang.IEditableCollection)(nil)).Elem() + tmp9 := lang.Apply(tmp7, []any{tmp8, v3}) + if lang.IsTruthy(tmp9) { + var tmp10 any + { // let + // let binding "tm" + tmp11 := checkDerefVar(glojure_DOT_core_meta) + tmp12 := lang.Apply(tmp11, []any{v3}) + var v13 any = tmp12 + _ = v13 + // let binding "rf" + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v15 := args[0] + _ = v15 + tmp16 := checkDerefVar(glojure_DOT_core_with_meta) + tmp17 := checkDerefVar(glojure_DOT_core_persistent_BANG_) + tmp18 := lang.Apply(tmp17, []any{v15}) + tmp19 := lang.Apply(tmp16, []any{tmp18, v13}) + return tmp19 + case 2: + v15 := args[0] + _ = v15 + v16 := args[1] + _ = v16 + tmp17 := checkDerefVar(glojure_DOT_core_conj_BANG_) + tmp18 := lang.Apply(tmp17, []any{v15, v16}) + return tmp18 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6937), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(6939), lang.NewKeyword("end-column"), int(44)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v17 any = tmp16 + _ = v17 + tmp18 := checkDerefVar(glojure_DOT_core_transduce) + tmp19 := checkDerefVar(glojure_DOT_core_transient) + tmp20 := lang.Apply(tmp19, []any{v3}) + tmp21 := lang.Apply(tmp18, []any{v4, v17, tmp20, v5}) + tmp10 = tmp21 + } // end let + tmp6 = tmp10 + } else { + tmp11 := checkDerefVar(glojure_DOT_core_transduce) + tmp12 := checkDerefVar(glojure_DOT_core_conj) + tmp13 := lang.Apply(tmp11, []any{v4, tmp12, v3, v5}) + tmp6 = tmp13 + } + return tmp6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // into-array + { + tmp0 := lang.NewSymbol("into-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("aseq")), lang.NewVector(lang.NewSymbol("type"), lang.NewSymbol("aseq"))), lang.NewKeyword("doc"), "Returns an array with components set to the values in aseq. The array's\n component type is type if provided, or the type of the first value in\n aseq if present, or Object. All values in aseq must be compatible with\n the component type. Class objects for the primitive types can be obtained\n using, e.g., Integer/TYPE.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3444), lang.NewKeyword("end-line"), int(3444))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := lang.Apply(tmp4, []any{v3}) + tmp6 := lang.Apply(nil, []any{tmp5}) + return tmp6 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_seq) + tmp6 := lang.Apply(tmp5, []any{v4}) + tmp7 := lang.Apply(nil, []any{v3, tmp6}) + return tmp7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // into1 + { + tmp0 := lang.NewSymbol("into1").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("from"))), lang.NewKeyword("doc"), "Returns a new coll consisting of to-coll with all of the items of\n from-coll conjoined.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3416), lang.NewKeyword("end-line"), int(3416), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp7 := reflect.TypeOf((*lang.IEditableCollection)(nil)).Elem() + tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) + if lang.IsTruthy(tmp8) { + tmp9 := checkDerefVar(glojure_DOT_core_persistent_BANG_) + tmp10 := checkDerefVar(glojure_DOT_core_reduce1) + tmp11 := checkDerefVar(glojure_DOT_core_conj_BANG_) + tmp12 := checkDerefVar(glojure_DOT_core_transient) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(tmp10, []any{tmp11, tmp13, v4}) + tmp15 := lang.Apply(tmp9, []any{tmp14}) + tmp5 = tmp15 + } else { + tmp16 := checkDerefVar(glojure_DOT_core_reduce1) + tmp17 := checkDerefVar(glojure_DOT_core_conj) + tmp18 := lang.Apply(tmp16, []any{tmp17, v3, v4}) + tmp5 = tmp18 + } + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ints + { + var tmp1 lang.FnFunc + { // function ints + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol("glojure.core/Ints")}) + tmp12 := checkDerefVar(glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("ints").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Casts to int[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5397), lang.NewKeyword("end-line"), int(5397))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Ints") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Ints is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // io! + { + tmp0 := lang.NewSymbol("io!").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "If an io! block occurs in a transaction, throws an\n IllegalStateException, else runs body in an implicit do. If the\n first expression in body is a literal string, will use that as the\n exception message.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(2504), lang.NewKeyword("end-line"), int(2504))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + var tmp6 any + { // let + // let binding "message" + var tmp7 any + tmp8 := checkDerefVar(glojure_DOT_core_string_QMARK_) + tmp9 := checkDerefVar(glojure_DOT_core_first) + tmp10 := lang.Apply(tmp9, []any{v5}) + tmp11 := lang.Apply(tmp8, []any{tmp10}) + if lang.IsTruthy(tmp11) { + tmp12 := checkDerefVar(glojure_DOT_core_first) + tmp13 := lang.Apply(tmp12, []any{v5}) + tmp7 = tmp13 + } else { + } + var v14 any = tmp7 + _ = v14 + // let binding "body" + var tmp15 any + if lang.IsTruthy(v14) { + tmp16 := checkDerefVar(glojure_DOT_core_next) + tmp17 := lang.Apply(tmp16, []any{v5}) + tmp15 = tmp17 + } else { + tmp15 = v5 + } + var v18 any = tmp15 + _ = v18 + tmp19 := checkDerefVar(glojure_DOT_core_seq) + tmp20 := checkDerefVar(glojure_DOT_core_concat) + tmp21 := checkDerefVar(glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("if")}) + tmp23 := checkDerefVar(glojure_DOT_core_list) + tmp24 := checkDerefVar(glojure_DOT_core_seq) + tmp25 := checkDerefVar(glojure_DOT_core_concat) + tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{lang.NewSymbol("glojure.lang.LockingTransaction/isRunning")}) + tmp28 := lang.Apply(tmp25, []any{tmp27}) + tmp29 := lang.Apply(tmp24, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp29}) + tmp31 := checkDerefVar(glojure_DOT_core_list) + tmp32 := checkDerefVar(glojure_DOT_core_seq) + tmp33 := checkDerefVar(glojure_DOT_core_concat) + tmp34 := checkDerefVar(glojure_DOT_core_list) + tmp35 := lang.Apply(tmp34, []any{lang.NewSymbol("throw")}) + tmp36 := checkDerefVar(glojure_DOT_core_list) + tmp37 := checkDerefVar(glojure_DOT_core_seq) + tmp38 := checkDerefVar(glojure_DOT_core_concat) + tmp39 := checkDerefVar(glojure_DOT_core_list) + tmp40 := lang.Apply(tmp39, []any{lang.NewSymbol("new")}) + tmp41 := checkDerefVar(glojure_DOT_core_list) + tmp42 := lang.Apply(tmp41, []any{lang.NewSymbol("glojure.core/IllegalStateException")}) + tmp43 := checkDerefVar(glojure_DOT_core_list) + var tmp44 any + { // let + // let binding "or__0__auto__" + var v45 any = v14 + _ = v45 + var tmp46 any + if lang.IsTruthy(v45) { + tmp46 = v45 + } else { + tmp46 = "I/O in transaction" + } + tmp44 = tmp46 + } // end let + tmp45 := lang.Apply(tmp43, []any{tmp44}) + tmp46 := lang.Apply(tmp38, []any{tmp40, tmp42, tmp45}) + tmp47 := lang.Apply(tmp37, []any{tmp46}) + tmp48 := lang.Apply(tmp36, []any{tmp47}) + tmp49 := lang.Apply(tmp33, []any{tmp35, tmp48}) + tmp50 := lang.Apply(tmp32, []any{tmp49}) + tmp51 := lang.Apply(tmp31, []any{tmp50}) + tmp52 := checkDerefVar(glojure_DOT_core_list) + tmp53 := checkDerefVar(glojure_DOT_core_seq) + tmp54 := checkDerefVar(glojure_DOT_core_concat) + tmp55 := checkDerefVar(glojure_DOT_core_list) + tmp56 := lang.Apply(tmp55, []any{lang.NewSymbol("do")}) + tmp57 := lang.Apply(tmp54, []any{tmp56, v18}) + tmp58 := lang.Apply(tmp53, []any{tmp57}) + tmp59 := lang.Apply(tmp52, []any{tmp58}) + tmp60 := lang.Apply(tmp20, []any{tmp22, tmp30, tmp51, tmp59}) + tmp61 := lang.Apply(tmp19, []any{tmp60}) + tmp6 = tmp61 + } // end let + return tmp6 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // isa? + { + tmp0 := lang.NewSymbol("isa?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("child"), lang.NewSymbol("parent")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("child"), lang.NewSymbol("parent"))), lang.NewKeyword("doc"), "Returns true if (= child parent), or child is directly or indirectly derived from\n parent, either via a Java type inheritance relationship or a\n relationship established via derive. h must be a hierarchy obtained\n from make-hierarchy, if not supplied defaults to the global\n hierarchy", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5543), lang.NewKeyword("end-line"), int(5543))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_isa_QMARK_) + tmp6 := checkDerefVar(glojure_DOT_core_global_hierarchy) + tmp7 := lang.Apply(tmp5, []any{tmp6, v3, v4}) + return tmp7 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var tmp6 any + { // let + // let binding "or__0__auto__" + tmp7 := checkDerefVar(glojure_DOT_core__EQ_) + tmp8 := lang.Apply(tmp7, []any{v4, v5}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + tmp10 = v9 + } else { + var tmp11 any + { // let + // let binding "or__0__auto__" + var tmp12 any + { // let + // let binding "and__0__auto__" + tmp13 := checkDerefVar(glojure_DOT_core_class_QMARK_) + tmp14 := lang.Apply(tmp13, []any{v5}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + if lang.IsTruthy(v15) { + var tmp17 any + { // let + // let binding "and__0__auto__" + tmp18 := checkDerefVar(glojure_DOT_core_class_QMARK_) + tmp19 := lang.Apply(tmp18, []any{v4}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + tmp22, _ := lang.FieldOrMethod(v4, "AssignableTo") + if reflect.TypeOf(tmp22).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("AssignableTo is not a function"))) + } + tmp23 := lang.Apply(tmp22, []any{v5}) + tmp21 = tmp23 + } else { + tmp21 = v20 + } + tmp17 = tmp21 + } // end let + tmp16 = tmp17 + } else { + tmp16 = v15 + } + tmp12 = tmp16 + } // end let + var v13 any = tmp12 + _ = v13 + var tmp14 any + if lang.IsTruthy(v13) { + tmp14 = v13 + } else { + var tmp15 any + { // let + // let binding "or__0__auto__" + tmp16 := checkDerefVar(glojure_DOT_core_contains_QMARK_) + tmp17 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) + tmp18 := lang.Apply(tmp17, []any{v4}) + tmp19 := lang.Apply(tmp16, []any{tmp18, v5}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + tmp21 = v20 + } else { + var tmp22 any + { // let + // let binding "or__0__auto__" + var tmp23 any + { // let + // let binding "and__0__auto__" + tmp24 := checkDerefVar(glojure_DOT_core_class_QMARK_) + tmp25 := lang.Apply(tmp24, []any{v4}) + var v26 any = tmp25 + _ = v26 + var tmp27 any + if lang.IsTruthy(v26) { + tmp28 := checkDerefVar(glojure_DOT_core_some) + var tmp29 lang.FnFunc + tmp29 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v30 := args[0] + _ = v30 + tmp31 := checkDerefVar(glojure_DOT_core_contains_QMARK_) + tmp32 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) + tmp33 := lang.Apply(tmp32, []any{v30}) + tmp34 := lang.Apply(tmp31, []any{tmp33, v5}) + return tmp34 + }) + tmp30 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5556), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(5556), lang.NewKeyword("end-column"), int(71)) + tmp31, err := lang.WithMeta(tmp29, tmp30.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp32 := checkDerefVar(glojure_DOT_core_supers) + tmp33 := lang.Apply(tmp32, []any{v4}) + tmp34 := lang.Apply(tmp28, []any{tmp31, tmp33}) + tmp27 = tmp34 + } else { + tmp27 = v26 + } + tmp23 = tmp27 + } // end let + var v24 any = tmp23 + _ = v24 + var tmp25 any + if lang.IsTruthy(v24) { + tmp25 = v24 + } else { + var tmp26 any + { // let + // let binding "and__0__auto__" + tmp27 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp28 := lang.Apply(tmp27, []any{v5}) + var v29 any = tmp28 + _ = v29 + var tmp30 any + if lang.IsTruthy(v29) { + var tmp31 any + { // let + // let binding "and__0__auto__" + tmp32 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp33 := lang.Apply(tmp32, []any{v4}) + var v34 any = tmp33 + _ = v34 + var tmp35 any + if lang.IsTruthy(v34) { + var tmp36 any + { // let + // let binding "and__0__auto__" + tmp37 := checkDerefVar(glojure_DOT_core__EQ_) + tmp38 := checkDerefVar(glojure_DOT_core_count) + tmp39 := lang.Apply(tmp38, []any{v5}) + tmp40 := checkDerefVar(glojure_DOT_core_count) + tmp41 := lang.Apply(tmp40, []any{v4}) + tmp42 := lang.Apply(tmp37, []any{tmp39, tmp41}) + var v43 any = tmp42 + _ = v43 + var tmp44 any + if lang.IsTruthy(v43) { + var tmp45 any + { // let + // let binding "ret" + var v46 any = true + _ = v46 + // let binding "i" + var v47 any = int64(0) + _ = v47 + for { + var tmp48 any + var tmp49 any + { // let + // let binding "or__0__auto__" + tmp50 := checkDerefVar(glojure_DOT_core_not) + tmp51 := lang.Apply(tmp50, []any{v46}) + var v52 any = tmp51 + _ = v52 + var tmp53 any + if lang.IsTruthy(v52) { + tmp53 = v52 + } else { + tmp54 := checkDerefVar(glojure_DOT_core__EQ_) + tmp55 := checkDerefVar(glojure_DOT_core_count) + tmp56 := lang.Apply(tmp55, []any{v5}) + tmp57 := lang.Apply(tmp54, []any{v47, tmp56}) + tmp53 = tmp57 + } + tmp49 = tmp53 + } // end let + if lang.IsTruthy(tmp49) { + tmp48 = v46 + } else { + tmp51 := checkDerefVar(glojure_DOT_core_isa_QMARK_) + tmp52 := lang.Apply(v4, []any{v47}) + tmp53 := lang.Apply(v5, []any{v47}) + tmp54 := lang.Apply(tmp51, []any{v3, tmp52, tmp53}) + var tmp50 any = tmp54 + tmp56 := checkDerefVar(glojure_DOT_core_inc) + tmp57 := lang.Apply(tmp56, []any{v47}) + var tmp55 any = tmp57 + v46 = tmp50 + v47 = tmp55 + continue + } + tmp45 = tmp48 + break + } + } // end let + tmp44 = tmp45 + } else { + tmp44 = v43 + } + tmp36 = tmp44 + } // end let + tmp35 = tmp36 + } else { + tmp35 = v34 + } + tmp31 = tmp35 + } // end let + tmp30 = tmp31 + } else { + tmp30 = v29 + } + tmp26 = tmp30 + } // end let + tmp25 = tmp26 + } + tmp22 = tmp25 + } // end let + tmp21 = tmp22 + } + tmp15 = tmp21 + } // end let + tmp14 = tmp15 + } + tmp11 = tmp14 + } // end let + tmp10 = tmp11 + } + tmp6 = tmp10 + } // end let + return tmp6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // iterate + { + tmp0 := lang.NewSymbol("iterate").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns a lazy (infinite!) sequence of x, (f x), (f (f x)) etc.\n f must be free of side-effects", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3011), lang.NewKeyword("end-line"), int(3011))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(nil, []any{v3, v4}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // iteration + { + tmp0 := lang.NewSymbol("iteration").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("step"), lang.NewSymbol("&"), lang.NewMap(lang.NewKeyword("keys"), lang.NewVector(lang.NewSymbol("somef"), lang.NewSymbol("vf"), lang.NewSymbol("kf"), lang.NewSymbol("initk")), lang.NewKeyword("or"), lang.NewMap(lang.NewSymbol("vf"), lang.NewSymbol("identity"), lang.NewSymbol("kf"), lang.NewSymbol("identity"), lang.NewSymbol("somef"), lang.NewSymbol("some?"), lang.NewSymbol("initk"), nil)))), lang.NewKeyword("doc"), "Creates a seqable/reducible via repeated calls to step,\n a function of some (continuation token) 'k'. The first call to step\n will be passed initk, returning 'ret'. Iff (somef ret) is true,\n (vf ret) will be included in the iteration, else iteration will\n terminate and vf/kf will not be called. If (kf ret) is non-nil it\n will be passed to the next step call, else iteration will terminate.\n\n This can be used e.g. to consume APIs that return paginated or batched data.\n\n step - (possibly impure) fn of 'k' -> 'ret'\n\n :somef - fn of 'ret' -> logical true/false, default 'some?'\n :vf - fn of 'ret' -> 'v', a value produced by the iteration, default 'identity'\n :kf - fn of 'ret' -> 'next-k' or nil (signaling 'do not continue'), default 'identity'\n :initk - the first value passed to step, default 'nil'\n\n It is presumed that step with non-initk is unreproducible/non-idempotent.\n If step with initk is unreproducible it is on the consumer to not consume twice.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7716), lang.NewKeyword("end-line"), int(7716))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any = lang.NewList(args[1:]...) + _ = v4 + var tmp5 any + { // let + // let binding "map__357" + var v6 any = v4 + _ = v6 + // let binding "map__357" + var tmp7 any + tmp8 := checkDerefVar(glojure_DOT_core_seq_QMARK_) + tmp9 := lang.Apply(tmp8, []any{v6}) + if lang.IsTruthy(tmp9) { + var tmp10 any + tmp11 := checkDerefVar(glojure_DOT_core_next) + tmp12 := lang.Apply(tmp11, []any{v6}) + if lang.IsTruthy(tmp12) { + tmp13 := checkDerefVar(glojure_DOT_core_to_array) + tmp14 := lang.Apply(tmp13, []any{v6}) + tmp15 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{tmp14}) + tmp10 = tmp15 + } else { + var tmp16 any + tmp17 := checkDerefVar(glojure_DOT_core_seq) + tmp18 := lang.Apply(tmp17, []any{v6}) + if lang.IsTruthy(tmp18) { + tmp19 := checkDerefVar(glojure_DOT_core_first) + tmp20 := lang.Apply(tmp19, []any{v6}) + tmp16 = tmp20 + } else { + } + tmp10 = tmp16 + } + tmp7 = tmp10 + } else { + tmp7 = v6 + } + var v21 any = tmp7 + _ = v21 + // let binding "somef" + tmp22 := checkDerefVar(glojure_DOT_core_get) + tmp23 := checkDerefVar(glojure_DOT_core_some_QMARK_) + tmp24 := lang.Apply(tmp22, []any{v21, lang.NewKeyword("somef"), tmp23}) + var v25 any = tmp24 + _ = v25 + // let binding "vf" + tmp26 := checkDerefVar(glojure_DOT_core_get) + tmp27 := checkDerefVar(glojure_DOT_core_identity) + tmp28 := lang.Apply(tmp26, []any{v21, lang.NewKeyword("vf"), tmp27}) + var v29 any = tmp28 + _ = v29 + // let binding "kf" + tmp30 := checkDerefVar(glojure_DOT_core_get) + tmp31 := checkDerefVar(glojure_DOT_core_identity) + tmp32 := lang.Apply(tmp30, []any{v21, lang.NewKeyword("kf"), tmp31}) + var v33 any = tmp32 + _ = v33 + // let binding "initk" + tmp34 := checkDerefVar(glojure_DOT_core_get) + tmp35 := lang.Apply(tmp34, []any{v21, lang.NewKeyword("initk"), nil}) + var v36 any = tmp35 + _ = v36 + tmp37 := checkDerefVar(glojure_DOT_core_seq) + tmp38 := lang.NewVector(nil) + tmp39 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7743), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(7743), lang.NewKeyword("end-column"), int(11)) + tmp40, err := lang.WithMeta(tmp38, tmp39.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var tmp41 lang.FnFunc + { // function next + var v42 lang.FnFunc + tmp41 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v43 := args[0] + _ = v43 + var tmp44 any + tmp45 := lang.Apply(v25, []any{v43}) + if lang.IsTruthy(tmp45) { + tmp46 := checkDerefVar(glojure_DOT_core_cons) + tmp47 := lang.Apply(v29, []any{v43}) + var tmp48 any + { // let + // let binding "temp__0__auto__" + tmp49 := lang.Apply(v33, []any{v43}) + var v50 any = tmp49 + _ = v50 + var tmp51 any + tmp52 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp53 := lang.Apply(tmp52, []any{v50}) + if lang.IsTruthy(tmp53) { + } else { + var tmp54 any + { // let + // let binding "k" + var v55 any = v50 + _ = v55 + var tmp56 lang.FnFunc + tmp56 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + tmp57 := lang.Apply(v3, []any{v55}) + tmp58 := lang.Apply(v42, []any{tmp57}) + return tmp58 + }) + tmp57 := lang.Apply(lang.NewLazySeq, []any{tmp56}) + tmp54 = tmp57 + } // end let + tmp51 = tmp54 + } + tmp48 = tmp51 + } // end let + tmp49 := lang.Apply(tmp46, []any{tmp47, tmp48}) + tmp44 = tmp49 + } else { + } + return tmp44 + }) + v42 = tmp41 + _ = v42 + } + tmp42 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7744), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(7748), lang.NewKeyword("end-column"), int(51)) + tmp43, err := lang.WithMeta(tmp41, tmp42.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp44 := lang.Apply(v3, []any{v36}) + tmp45 := lang.Apply(tmp43, []any{tmp44}) + tmp46 := lang.Apply(tmp37, []any{tmp40, tmp45}) + tmp47 := reflect.TypeOf((*lang.IReduceInit)(nil)).Elem() + tmp48 := checkDerefVar(glojure_DOT_core_reduce) + tmp49 := lang.NewVector(nil, nil, nil) + tmp50 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7751), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(7751), lang.NewKeyword("end-column"), int(22)) + tmp51, err := lang.WithMeta(tmp49, tmp50.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var tmp52 any + { // let + // let binding "acc" + var v53 any = nil + _ = v53 + // let binding "ret" + tmp54 := lang.Apply(v3, []any{v36}) + var v55 any = tmp54 + _ = v55 + for { + var tmp56 any + tmp57 := lang.Apply(v25, []any{v55}) + if lang.IsTruthy(tmp57) { + var tmp58 any + { // let + // let binding "acc" + tmp59 := lang.Apply(v29, []any{v55}) + tmp60 := lang.Apply(nil, []any{v53, tmp59}) + var v61 any = tmp60 + _ = v61 + var tmp62 any + tmp63 := checkDerefVar(glojure_DOT_core_reduced_QMARK_) + tmp64 := lang.Apply(tmp63, []any{v61}) + if lang.IsTruthy(tmp64) { + tmp65 := checkDerefVar(glojure_DOT_core_deref) + tmp66 := lang.Apply(tmp65, []any{v61}) + tmp62 = tmp66 + } else { + var tmp67 any + { // let + // let binding "temp__0__auto__" + tmp68 := lang.Apply(v33, []any{v55}) + var v69 any = tmp68 + _ = v69 + var tmp70 any + tmp71 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp72 := lang.Apply(tmp71, []any{v69}) + if lang.IsTruthy(tmp72) { + tmp70 = v61 + } else { + var tmp73 any + { // let + // let binding "k" + var v74 any = v69 + _ = v74 + var tmp75 any = v61 + tmp77 := lang.Apply(v3, []any{v74}) + var tmp76 any = tmp77 + v53 = tmp75 + v55 = tmp76 + continue + } // end let + tmp70 = tmp73 + } + tmp67 = tmp70 + } // end let + tmp62 = tmp67 + } + tmp58 = tmp62 + } // end let + tmp56 = tmp58 + } else { + tmp56 = v53 + } + tmp52 = tmp56 + break + } + } // end let + tmp53 := lang.Apply(tmp48, []any{tmp51, tmp52}) + tmp54 := lang.Apply(nil, []any{nil, tmp46, tmp47, tmp53}) + tmp5 = tmp54 + } // end let + return tmp5 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // iterator-seq + { + tmp0 := lang.NewSymbol("iterator-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("iter"))), lang.NewKeyword("doc"), "Returns a seq on a java.util.Iterator. Note that most collections\n providing iterators implement Iterable and thus support seq directly.\n Seqs cache values, thus iterator-seq should not be used on any\n iterator that repeatedly returns the same mutable object.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5700), lang.NewKeyword("end-line"), int(5700))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(nil, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // juxt + { + tmp0 := lang.NewSymbol("juxt").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("g")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("g"), lang.NewSymbol("h")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("g"), lang.NewSymbol("h"), lang.NewSymbol("&"), lang.NewSymbol("fs"))), lang.NewKeyword("doc"), "Takes a set of functions and returns a fn that is the juxtaposition\n of those fns. The returned fn takes a variable number of args, and\n returns a vector containing the result of applying each fn to the\n args (left-to-right).\n ((juxt a b c) x) => [(a x) (b x) (c x)]", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2568), lang.NewKeyword("end-line"), int(2568))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp5 := lang.Apply(v3, nil) + tmp6 := lang.NewVector(tmp5) + tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2578), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(2578), lang.NewKeyword("end-column"), int(16)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp8 + case 1: + v5 := args[0] + _ = v5 + tmp6 := lang.Apply(v3, []any{v5}) + tmp7 := lang.NewVector(tmp6) + tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2579), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(2579), lang.NewKeyword("end-column"), int(19)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp9 + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + tmp7 := lang.Apply(v3, []any{v5, v6}) + tmp8 := lang.NewVector(tmp7) + tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2580), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(2580), lang.NewKeyword("end-column"), int(23)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp10 + case 3: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := args[2] + _ = v7 + tmp8 := lang.Apply(v3, []any{v5, v6, v7}) + tmp9 := lang.NewVector(tmp8) + tmp10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2581), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(2581), lang.NewKeyword("end-column"), int(27)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp11 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := args[2] + _ = v7 + var v8 any = lang.NewList(args[3:]...) + _ = v8 + tmp9 := checkDerefVar(glojure_DOT_core_apply) + tmp10 := lang.Apply(tmp9, []any{v3, v5, v6, v7, v8}) + tmp11 := lang.NewVector(tmp10) + tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2582), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(2582), lang.NewKeyword("end-column"), int(45)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp13 + } + }) + tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2577), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2582), lang.NewKeyword("end-column"), int(47)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp6 := lang.Apply(v3, nil) + tmp7 := lang.Apply(v4, nil) + tmp8 := lang.NewVector(tmp6, tmp7) + tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2585), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(2585), lang.NewKeyword("end-column"), int(20)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp10 + case 1: + v6 := args[0] + _ = v6 + tmp7 := lang.Apply(v3, []any{v6}) + tmp8 := lang.Apply(v4, []any{v6}) + tmp9 := lang.NewVector(tmp7, tmp8) + tmp10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2586), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(2586), lang.NewKeyword("end-column"), int(25)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp11 + case 2: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + tmp8 := lang.Apply(v3, []any{v6, v7}) + tmp9 := lang.Apply(v4, []any{v6, v7}) + tmp10 := lang.NewVector(tmp8, tmp9) + tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2587), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(2587), lang.NewKeyword("end-column"), int(31)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp12 + case 3: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + tmp9 := lang.Apply(v3, []any{v6, v7, v8}) + tmp10 := lang.Apply(v4, []any{v6, v7, v8}) + tmp11 := lang.NewVector(tmp9, tmp10) + tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2588), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(2588), lang.NewKeyword("end-column"), int(37)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp13 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + var v9 any = lang.NewList(args[3:]...) + _ = v9 + tmp10 := checkDerefVar(glojure_DOT_core_apply) + tmp11 := lang.Apply(tmp10, []any{v3, v6, v7, v8, v9}) + tmp12 := checkDerefVar(glojure_DOT_core_apply) + tmp13 := lang.Apply(tmp12, []any{v4, v6, v7, v8, v9}) + tmp14 := lang.NewVector(tmp11, tmp13) + tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2589), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(2589), lang.NewKeyword("end-column"), int(66)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp16 + } + }) + tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2584), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2589), lang.NewKeyword("end-column"), int(68)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp7 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp7 := lang.Apply(v3, nil) + tmp8 := lang.Apply(v4, nil) + tmp9 := lang.Apply(v5, nil) + tmp10 := lang.NewVector(tmp7, tmp8, tmp9) + tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2592), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(2592), lang.NewKeyword("end-column"), int(24)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp12 + case 1: + v7 := args[0] + _ = v7 + tmp8 := lang.Apply(v3, []any{v7}) + tmp9 := lang.Apply(v4, []any{v7}) + tmp10 := lang.Apply(v5, []any{v7}) + tmp11 := lang.NewVector(tmp8, tmp9, tmp10) + tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2593), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(2593), lang.NewKeyword("end-column"), int(31)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp13 + case 2: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + tmp9 := lang.Apply(v3, []any{v7, v8}) + tmp10 := lang.Apply(v4, []any{v7, v8}) + tmp11 := lang.Apply(v5, []any{v7, v8}) + tmp12 := lang.NewVector(tmp9, tmp10, tmp11) + tmp13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2594), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(2594), lang.NewKeyword("end-column"), int(39)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp14 + case 3: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + tmp10 := lang.Apply(v3, []any{v7, v8, v9}) + tmp11 := lang.Apply(v4, []any{v7, v8, v9}) + tmp12 := lang.Apply(v5, []any{v7, v8, v9}) + tmp13 := lang.NewVector(tmp10, tmp11, tmp12) + tmp14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2595), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(2595), lang.NewKeyword("end-column"), int(47)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp15 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + var v10 any = lang.NewList(args[3:]...) + _ = v10 + tmp11 := checkDerefVar(glojure_DOT_core_apply) + tmp12 := lang.Apply(tmp11, []any{v3, v7, v8, v9, v10}) + tmp13 := checkDerefVar(glojure_DOT_core_apply) + tmp14 := lang.Apply(tmp13, []any{v4, v7, v8, v9, v10}) + tmp15 := checkDerefVar(glojure_DOT_core_apply) + tmp16 := lang.Apply(tmp15, []any{v5, v7, v8, v9, v10}) + tmp17 := lang.NewVector(tmp12, tmp14, tmp16) + tmp18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2596), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(2596), lang.NewKeyword("end-column"), int(87)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp19 + } + }) + tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2591), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2596), lang.NewKeyword("end-column"), int(89)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp8 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any + { // let + // let binding "fs" + tmp8 := checkDerefVar(glojure_DOT_core_list_STAR_) + tmp9 := lang.Apply(tmp8, []any{v3, v4, v5, v6}) + var v10 any = tmp9 + _ = v10 + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp12 := checkDerefVar(glojure_DOT_core_reduce1) + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v14 := args[0] + _ = v14 + v15 := args[1] + _ = v15 + tmp16 := checkDerefVar(glojure_DOT_core_conj) + tmp17 := lang.Apply(v15, nil) + tmp18 := lang.Apply(tmp16, []any{v14, tmp17}) + return tmp18 + }) + tmp14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2600), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(2600), lang.NewKeyword("end-column"), int(37)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp16 := lang.NewVector() + tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2600), lang.NewKeyword("column"), int(39), lang.NewKeyword("end-line"), int(2600), lang.NewKeyword("end-column"), int(40)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp19 := lang.Apply(tmp12, []any{tmp15, tmp18, v10}) + return tmp19 + case 1: + v12 := args[0] + _ = v12 + tmp13 := checkDerefVar(glojure_DOT_core_reduce1) + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v15 := args[0] + _ = v15 + v16 := args[1] + _ = v16 + tmp17 := checkDerefVar(glojure_DOT_core_conj) + tmp18 := lang.Apply(v16, []any{v12}) + tmp19 := lang.Apply(tmp17, []any{v15, tmp18}) + return tmp19 + }) + tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2601), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(2601), lang.NewKeyword("end-column"), int(40)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp17 := lang.NewVector() + tmp18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2601), lang.NewKeyword("column"), int(42), lang.NewKeyword("end-line"), int(2601), lang.NewKeyword("end-column"), int(43)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp20 := lang.Apply(tmp13, []any{tmp16, tmp19, v10}) + return tmp20 + case 2: + v12 := args[0] + _ = v12 + v13 := args[1] + _ = v13 + tmp14 := checkDerefVar(glojure_DOT_core_reduce1) + var tmp15 lang.FnFunc + tmp15 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v16 := args[0] + _ = v16 + v17 := args[1] + _ = v17 + tmp18 := checkDerefVar(glojure_DOT_core_conj) + tmp19 := lang.Apply(v17, []any{v12, v13}) + tmp20 := lang.Apply(tmp18, []any{v16, tmp19}) + return tmp20 + }) + tmp16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2602), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(2602), lang.NewKeyword("end-column"), int(44)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp18 := lang.NewVector() + tmp19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2602), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(2602), lang.NewKeyword("end-column"), int(47)) + tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp21 := lang.Apply(tmp14, []any{tmp17, tmp20, v10}) + return tmp21 + case 3: + v12 := args[0] + _ = v12 + v13 := args[1] + _ = v13 + v14 := args[2] + _ = v14 + tmp15 := checkDerefVar(glojure_DOT_core_reduce1) + var tmp16 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v17 := args[0] + _ = v17 + v18 := args[1] + _ = v18 + tmp19 := checkDerefVar(glojure_DOT_core_conj) + tmp20 := lang.Apply(v18, []any{v12, v13, v14}) + tmp21 := lang.Apply(tmp19, []any{v17, tmp20}) + return tmp21 + }) + tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2603), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(2603), lang.NewKeyword("end-column"), int(48)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp19 := lang.NewVector() + tmp20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2603), lang.NewKeyword("column"), int(50), lang.NewKeyword("end-line"), int(2603), lang.NewKeyword("end-column"), int(51)) + tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp22 := lang.Apply(tmp15, []any{tmp18, tmp21, v10}) + return tmp22 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v12 := args[0] + _ = v12 + v13 := args[1] + _ = v13 + v14 := args[2] + _ = v14 + var v15 any = lang.NewList(args[3:]...) + _ = v15 + tmp16 := checkDerefVar(glojure_DOT_core_reduce1) + var tmp17 lang.FnFunc + tmp17 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v18 := args[0] + _ = v18 + v19 := args[1] + _ = v19 + tmp20 := checkDerefVar(glojure_DOT_core_conj) + tmp21 := checkDerefVar(glojure_DOT_core_apply) + tmp22 := lang.Apply(tmp21, []any{v19, v12, v13, v14, v15}) + tmp23 := lang.Apply(tmp20, []any{v18, tmp22}) + return tmp23 + }) + tmp18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2604), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(2604), lang.NewKeyword("end-column"), int(66)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp20 := lang.NewVector() + tmp21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2604), lang.NewKeyword("column"), int(68), lang.NewKeyword("end-line"), int(2604), lang.NewKeyword("end-column"), int(69)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp23 := lang.Apply(tmp16, []any{tmp19, tmp22, v10}) + return tmp23 + } + }) + tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2599), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(2604), lang.NewKeyword("end-column"), int(75)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp7 = tmp13 + } // end let + return tmp7 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // keep + { + tmp0 := lang.NewSymbol("keep").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the non-nil results of (f item). Note,\n this means false return values will be included. f must be free of\n side-effects. Returns a transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7339), lang.NewKeyword("end-line"), int(7339))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp7 := lang.Apply(v5, nil) + return tmp7 + case 1: + v7 := args[0] + _ = v7 + tmp8 := lang.Apply(v5, []any{v7}) + return tmp8 + case 2: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + var tmp9 any + { // let + // let binding "v" + tmp10 := lang.Apply(v3, []any{v8}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + tmp13 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp14 := lang.Apply(tmp13, []any{v11}) + if lang.IsTruthy(tmp14) { + tmp12 = v7 + } else { + tmp15 := lang.Apply(v5, []any{v7, v11}) + tmp12 = tmp15 + } + tmp9 = tmp12 + } // end let + return tmp9 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7347), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7354), lang.NewKeyword("end-column"), int(31)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp8 + }) + tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7346), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7354), lang.NewKeyword("end-column"), int(32)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var tmp6 any + { // let + // let binding "temp__0__auto__" + tmp7 := checkDerefVar(glojure_DOT_core_seq) + tmp8 := lang.Apply(tmp7, []any{v4}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + var tmp11 any + { // let + // let binding "s" + var v12 any = v9 + _ = v12 + var tmp13 any + tmp14 := checkDerefVar(glojure_DOT_core_chunked_seq_QMARK_) + tmp15 := lang.Apply(tmp14, []any{v12}) + if lang.IsTruthy(tmp15) { + var tmp16 any + { // let + // let binding "c" + tmp17 := checkDerefVar(glojure_DOT_core_chunk_first) + tmp18 := lang.Apply(tmp17, []any{v12}) + var v19 any = tmp18 + _ = v19 + // let binding "size" + tmp20 := checkDerefVar(glojure_DOT_core_count) + tmp21 := lang.Apply(tmp20, []any{v19}) + var v22 any = tmp21 + _ = v22 + // let binding "b" + tmp23 := checkDerefVar(glojure_DOT_core_chunk_buffer) + tmp24 := lang.Apply(tmp23, []any{v22}) + var v25 any = tmp24 + _ = v25 + var tmp26 any + { // let + // let binding "n__0__auto__" + tmp27 := checkDerefVar(glojure_DOT_core_long) + tmp28 := lang.Apply(tmp27, []any{v22}) + var v29 any = tmp28 + _ = v29 + var tmp30 any + { // let + // let binding "i" + var v31 any = int64(0) + _ = v31 + for { + var tmp32 any + tmp33 := checkDerefVar(glojure_DOT_core__LT_) + tmp34 := lang.Apply(tmp33, []any{v31, v29}) + if lang.IsTruthy(tmp34) { + var tmp35 any + { // let + // let binding "x" + tmp36, _ := lang.FieldOrMethod(v19, "nth") + if reflect.TypeOf(tmp36).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp37 := lang.Apply(tmp36, []any{v31}) + tmp38 := lang.Apply(v3, []any{tmp37}) + var v39 any = tmp38 + _ = v39 + var tmp40 any + tmp41 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp42 := lang.Apply(tmp41, []any{v39}) + if lang.IsTruthy(tmp42) { + } else { + tmp43 := checkDerefVar(glojure_DOT_core_chunk_append) + tmp44 := lang.Apply(tmp43, []any{v25, v39}) + tmp40 = tmp44 + } + tmp35 = tmp40 + } // end let + _ = tmp35 + tmp37 := checkDerefVar(glojure_DOT_core_unchecked_inc) + tmp38 := lang.Apply(tmp37, []any{v31}) + var tmp36 any = tmp38 + v31 = tmp36 + continue + } else { + } + tmp30 = tmp32 + break + } + } // end let + tmp26 = tmp30 + } // end let + _ = tmp26 + tmp27 := checkDerefVar(glojure_DOT_core_chunk_cons) + tmp28 := checkDerefVar(glojure_DOT_core_chunk) + tmp29 := lang.Apply(tmp28, []any{v25}) + tmp30 := checkDerefVar(glojure_DOT_core_keep) + tmp31 := checkDerefVar(glojure_DOT_core_chunk_rest) + tmp32 := lang.Apply(tmp31, []any{v12}) + tmp33 := lang.Apply(tmp30, []any{v3, tmp32}) + tmp34 := lang.Apply(tmp27, []any{tmp29, tmp33}) + tmp16 = tmp34 + } // end let + tmp13 = tmp16 + } else { + var tmp17 any + { // let + // let binding "x" + tmp18 := checkDerefVar(glojure_DOT_core_first) + tmp19 := lang.Apply(tmp18, []any{v12}) + tmp20 := lang.Apply(v3, []any{tmp19}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + tmp23 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp24 := lang.Apply(tmp23, []any{v21}) + if lang.IsTruthy(tmp24) { + tmp25 := checkDerefVar(glojure_DOT_core_keep) + tmp26 := checkDerefVar(glojure_DOT_core_rest) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp25, []any{v3, tmp27}) + tmp22 = tmp28 + } else { + tmp29 := checkDerefVar(glojure_DOT_core_cons) + tmp30 := checkDerefVar(glojure_DOT_core_keep) + tmp31 := checkDerefVar(glojure_DOT_core_rest) + tmp32 := lang.Apply(tmp31, []any{v12}) + tmp33 := lang.Apply(tmp30, []any{v3, tmp32}) + tmp34 := lang.Apply(tmp29, []any{v21, tmp33}) + tmp22 = tmp34 + } + tmp17 = tmp22 + } // end let + tmp13 = tmp17 + } + tmp11 = tmp13 + } // end let + tmp10 = tmp11 + } else { + } + tmp6 = tmp10 + } // end let + return tmp6 + }) + tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) + return tmp6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // keep-indexed + { + tmp0 := lang.NewSymbol("keep-indexed").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the non-nil results of (f index item). Note,\n this means false return values will be included. f must be free of\n side-effects. Returns a stateful transducer when no collection is\n provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7372), lang.NewKeyword("end-line"), int(7372))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + var tmp6 any + { // let + // let binding "iv" + tmp7 := checkDerefVar(glojure_DOT_core_volatile_BANG_) + tmp8 := lang.Apply(tmp7, []any{int64(-1)}) + var v9 any = tmp8 + _ = v9 + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp11 := lang.Apply(v5, nil) + return tmp11 + case 1: + v11 := args[0] + _ = v11 + tmp12 := lang.Apply(v5, []any{v11}) + return tmp12 + case 2: + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + var tmp13 any + { // let + // let binding "i" + tmp14 := checkDerefVar(glojure_DOT_core_inc) + tmp15, ok := lang.FieldOrMethod(v9, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v9, "Deref"))) + } + var tmp16 any + switch reflect.TypeOf(tmp15).Kind() { + case reflect.Func: + tmp16 = lang.Apply(tmp15, nil) + default: + tmp16 = tmp15 + } + tmp17 := lang.Apply(tmp14, []any{tmp16}) + tmp18, _ := lang.FieldOrMethod(v9, "reset") + if reflect.TypeOf(tmp18).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) + } + tmp19 := lang.Apply(tmp18, []any{tmp17}) + var v20 any = tmp19 + _ = v20 + // let binding "v" + tmp21 := lang.Apply(v3, []any{v20, v12}) + var v22 any = tmp21 + _ = v22 + var tmp23 any + tmp24 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp25 := lang.Apply(tmp24, []any{v22}) + if lang.IsTruthy(tmp25) { + tmp23 = v11 + } else { + tmp26 := lang.Apply(v5, []any{v11, v22}) + tmp23 = tmp26 + } + tmp13 = tmp23 + } // end let + return tmp13 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7382), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7390), lang.NewKeyword("end-column"), int(33)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp6 = tmp12 + } // end let + return tmp6 + }) + tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7380), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7390), lang.NewKeyword("end-column"), int(35)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + return nil + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // key + { + tmp0 := lang.NewSymbol("key").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("e"))), lang.NewKeyword("doc"), "Returns the key of the map entry.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1563), lang.NewKeyword("end-line"), int(1563))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v3, "GetKey") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("GetKey is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // keys + { + tmp0 := lang.NewSymbol("keys").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"))), lang.NewKeyword("doc"), "Returns a sequence of the map's keys, in the same order as (seq map).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1551), lang.NewKeyword("end-line"), int(1551))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.Keys, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // keyword + { + tmp1 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() + tmp0 := lang.NewSymbol("keyword").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name"))), lang.NewKeyword("doc"), "Returns a Keyword with the given namespace and name. Do not use :\n in the keyword strings, it will be added automatically.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(609), lang.NewKeyword("end-line"), int(609))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(glojure_DOT_core_keyword_QMARK_) + tmp7 := lang.Apply(tmp6, []any{v4}) + if lang.IsTruthy(tmp7) { + tmp5 = v4 + } else { + var tmp8 any + tmp9 := checkDerefVar(glojure_DOT_core_symbol_QMARK_) + tmp10 := lang.Apply(tmp9, []any{v4}) + if lang.IsTruthy(tmp10) { + tmp11 := lang.Apply(lang.InternKeywordSymbol, []any{v4}) + tmp8 = tmp11 + } else { + var tmp12 any + tmp13 := checkDerefVar(glojure_DOT_core_string_QMARK_) + tmp14 := lang.Apply(tmp13, []any{v4}) + if lang.IsTruthy(tmp14) { + tmp15 := lang.Apply(lang.InternKeywordString, []any{v4}) + tmp12 = tmp15 + } else { + } + tmp8 = tmp12 + } + tmp5 = tmp8 + } + return tmp5 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6 := lang.Apply(lang.InternKeyword, []any{v4, v5}) + return tmp6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp4 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // keyword? + { + tmp0 := lang.NewSymbol("keyword?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a Keyword", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(563), lang.NewKeyword("end-line"), int(563))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp5 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() + tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // last + { + tmp0 := lang.NewSymbol("last").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return the last item in coll, in linear time", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(262), lang.NewKeyword("end-line"), int(266))).(*lang.Symbol) + var tmp2 lang.FnFunc + { // function last + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + recur_loop_32: + var tmp5 any + tmp6 := checkDerefVar(glojure_DOT_core_next) + tmp7 := lang.Apply(tmp6, []any{v4}) + if lang.IsTruthy(tmp7) { + tmp9 := checkDerefVar(glojure_DOT_core_next) + tmp10 := lang.Apply(tmp9, []any{v4}) + var tmp8 any = tmp10 + v4 = tmp8 + goto recur_loop_32 + } else { + tmp11 := checkDerefVar(glojure_DOT_core_first) + tmp12 := lang.Apply(tmp11, []any{v4}) + tmp5 = tmp12 + } + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(266), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(269), lang.NewKeyword("end-column"), int(21))).(lang.FnFunc) + v3 = tmp2 + _ = v3 + } + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // lazy-cat + { + tmp0 := lang.NewSymbol("lazy-cat").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Expands to code which yields a lazy sequence of the concatenation\n of the supplied colls. Each coll expr is not evaluated until it is\n needed. \n\n (lazy-cat xs ys zs) === (concat (lazy-seq xs) (lazy-seq ys) (lazy-seq zs))", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4636), lang.NewKeyword("end-line"), int(4636))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := checkDerefVar(glojure_DOT_core_seq) + tmp7 := checkDerefVar(glojure_DOT_core_concat) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("glojure.core/concat")}) + tmp10 := checkDerefVar(glojure_DOT_core_map) + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v12 := args[0] + _ = v12 + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/lazy-seq"), v12}) + return tmp14 + }) + tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4644), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(4644), lang.NewKeyword("end-column"), int(37)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp14 := lang.Apply(tmp10, []any{tmp13, v5}) + tmp15 := lang.Apply(tmp7, []any{tmp9, tmp14}) + tmp16 := lang.Apply(tmp6, []any{tmp15}) + return tmp16 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // lazy-seq + { + tmp0 := lang.NewSymbol("lazy-seq").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Takes a body of expressions that returns an ISeq or nil, and yields\n a Seqable object that will invoke the body only the first time seq\n is called, and will cache the result and return it on all subsequent\n seq calls. See also - realized?", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(676), lang.NewKeyword("end-line"), int(676))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := checkDerefVar(glojure_DOT_core_list_STAR_) + tmp8 := lang.NewVector() + tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(683), lang.NewKeyword("column"), int(101), lang.NewKeyword("end-line"), int(683), lang.NewKeyword("end-column"), int(102)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp11 := lang.Apply(tmp7, []any{lang.NewSymbol("fn*"), tmp10, v5}) + tmp12 := lang.Apply(tmp6, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewLazySeq"), tmp11}) + return tmp12 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // let + { + tmp0 := lang.NewSymbol("let").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "binding => binding-form init-expr\n binding-form => name, or destructuring-form\n destructuring-form => map-destructure-form, or seq-destructure-form\n\n Evaluates the exprs in a lexical context in which the symbols in\n the binding-forms are bound to their respective init-exprs or parts\n therein.\n\n See https://glojure.org/reference/special_forms#binding-forms for\n more information about destructuring.", lang.NewKeyword("forms"), lang.NewVector(lang.NewList(lang.NewSymbol("let"), lang.NewVector(lang.NewSymbol("bindings*")), lang.NewSymbol("exprs*"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4496), lang.NewKeyword("end-line"), int(4496), lang.NewKeyword("special-form"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any + tmp8 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp9 := lang.Apply(tmp8, []any{v5}) + if lang.IsTruthy(tmp9) { + } else { + tmp10 := checkDerefVar(glojure_DOT_core_str) + tmp11 := checkDerefVar(glojure_DOT_core_first) + tmp12 := lang.Apply(tmp11, []any{v3}) + tmp13 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) + tmp14 := checkDerefVar(glojure_DOT_core_meta) + tmp15 := lang.Apply(tmp14, []any{v3}) + tmp16 := lang.Apply(lang.NewKeyword("line"), []any{tmp15}) + tmp17 := lang.Apply(tmp10, []any{tmp12, " requires ", "a vector for its binding", " in ", tmp13, ":", tmp16}) + tmp18 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp17}) + panic(tmp18) + } + _ = tmp7 + var tmp19 any + tmp20 := checkDerefVar(glojure_DOT_core_even_QMARK_) + tmp21 := checkDerefVar(glojure_DOT_core_count) + tmp22 := lang.Apply(tmp21, []any{v5}) + tmp23 := lang.Apply(tmp20, []any{tmp22}) + if lang.IsTruthy(tmp23) { + } else { + tmp24 := checkDerefVar(glojure_DOT_core_str) + tmp25 := checkDerefVar(glojure_DOT_core_first) + tmp26 := lang.Apply(tmp25, []any{v3}) + tmp27 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) + tmp28 := checkDerefVar(glojure_DOT_core_meta) + tmp29 := lang.Apply(tmp28, []any{v3}) + tmp30 := lang.Apply(lang.NewKeyword("line"), []any{tmp29}) + tmp31 := lang.Apply(tmp24, []any{tmp26, " requires ", "an even number of forms in binding vector", " in ", tmp27, ":", tmp30}) + tmp32 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp31}) + panic(tmp32) + } + _ = tmp19 + tmp33 := checkDerefVar(glojure_DOT_core_seq) + tmp34 := checkDerefVar(glojure_DOT_core_concat) + tmp35 := checkDerefVar(glojure_DOT_core_list) + tmp36 := lang.Apply(tmp35, []any{lang.NewSymbol("let*")}) + tmp37 := checkDerefVar(glojure_DOT_core_list) + tmp38 := checkDerefVar(glojure_DOT_core_destructure) + tmp39 := lang.Apply(tmp38, []any{v5}) + tmp40 := lang.Apply(tmp37, []any{tmp39}) + tmp41 := lang.Apply(tmp34, []any{tmp36, tmp40, v6}) + tmp42 := lang.Apply(tmp33, []any{tmp41}) + return tmp42 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // letfn + { + tmp0 := lang.NewSymbol("letfn").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fnspecs"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "fnspec ==> (fname [params*] exprs) or (fname ([params*] exprs)+)\n\n Takes a vector of function specs and a body, and generates a set of\n bindings of functions to their names. All of the names are available\n in all of the definitions of the functions, as well as the body.", lang.NewKeyword("forms"), lang.NewVector(lang.NewList(lang.NewSymbol("letfn"), lang.NewVector(lang.NewSymbol("fnspecs*")), lang.NewSymbol("exprs*"))), lang.NewKeyword("url"), nil, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6545), lang.NewKeyword("end-line"), int(6545), lang.NewKeyword("special-form"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_seq) + tmp8 := checkDerefVar(glojure_DOT_core_concat) + tmp9 := checkDerefVar(glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("letfn*")}) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := checkDerefVar(glojure_DOT_core_vec) + tmp13 := checkDerefVar(glojure_DOT_core_interleave) + tmp14 := checkDerefVar(glojure_DOT_core_map) + tmp15 := checkDerefVar(glojure_DOT_core_first) + tmp16 := lang.Apply(tmp14, []any{tmp15, v5}) + tmp17 := checkDerefVar(glojure_DOT_core_map) + var tmp18 lang.FnFunc + tmp18 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v19 := args[0] + _ = v19 + tmp20 := checkDerefVar(glojure_DOT_core_cons) + tmp21 := lang.Apply(tmp20, []any{lang.NewSymbol("glojure.core/fn"), v19}) + return tmp21 + }) + tmp19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6555), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(6555), lang.NewKeyword("end-column"), int(47)) + tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp21 := lang.Apply(tmp17, []any{tmp20, v5}) + tmp22 := lang.Apply(tmp13, []any{tmp16, tmp21}) + tmp23 := lang.Apply(tmp12, []any{tmp22}) + tmp24 := lang.Apply(tmp11, []any{tmp23}) + tmp25 := lang.Apply(tmp8, []any{tmp10, tmp24, v6}) + tmp26 := lang.Apply(tmp7, []any{tmp25}) + return tmp26 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // libspec? + { + tmp0 := lang.NewSymbol("libspec?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is a libspec", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5848), lang.NewKeyword("end-line"), int(5848), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + { // let + // let binding "or__0__auto__" + tmp5 := checkDerefVar(glojure_DOT_core_symbol_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + if lang.IsTruthy(v7) { + tmp8 = v7 + } else { + var tmp9 any + { // let + // let binding "and__0__auto__" + tmp10 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp11 := lang.Apply(tmp10, []any{v3}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + var tmp14 any + { // let + // let binding "or__0__auto__" + tmp15 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp16 := checkDerefVar(glojure_DOT_core_second) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := lang.Apply(tmp15, []any{tmp17}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + tmp20 = v19 + } else { + tmp21 := checkDerefVar(glojure_DOT_core_keyword_QMARK_) + tmp22 := checkDerefVar(glojure_DOT_core_second) + tmp23 := lang.Apply(tmp22, []any{v3}) + tmp24 := lang.Apply(tmp21, []any{tmp23}) + tmp20 = tmp24 + } + tmp14 = tmp20 + } // end let + tmp13 = tmp14 + } else { + tmp13 = v12 + } + tmp9 = tmp13 + } // end let + tmp8 = tmp9 + } + tmp4 = tmp8 + } // end let + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // lift-ns + { + tmp0 := lang.NewSymbol("lift-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"))), lang.NewKeyword("doc"), "Returns [lifted-ns lifted-kvs] or nil if m can't be lifted.", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(261), lang.NewKeyword("end-line"), int(261), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(glojure_DOT_core__STAR_print_namespace_maps_STAR_) + if lang.IsTruthy(tmp5) { + var tmp6 any + { // let + // let binding "ns" + var v7 any = nil + _ = v7 + // let binding "G__221" + tmp8 := checkDerefVar(glojure_DOT_core_seq) + tmp9 := lang.Apply(tmp8, []any{v3}) + var v10 any = tmp9 + _ = v10 + // let binding "vec__222" + var v11 any = v10 + _ = v11 + // let binding "seq__223" + tmp12 := checkDerefVar(glojure_DOT_core_seq) + tmp13 := lang.Apply(tmp12, []any{v11}) + var v14 any = tmp13 + _ = v14 + // let binding "first__224" + tmp15 := checkDerefVar(glojure_DOT_core_first) + tmp16 := lang.Apply(tmp15, []any{v14}) + var v17 any = tmp16 + _ = v17 + // let binding "seq__223" + tmp18 := checkDerefVar(glojure_DOT_core_next) + tmp19 := lang.Apply(tmp18, []any{v14}) + var v20 any = tmp19 + _ = v20 + // let binding "vec__225" + var v21 any = v17 + _ = v21 + // let binding "k" + tmp22 := checkDerefVar(glojure_DOT_core_nth) + tmp23 := lang.Apply(tmp22, []any{v21, int64(0), nil}) + var v24 any = tmp23 + _ = v24 + // let binding "v" + tmp25 := checkDerefVar(glojure_DOT_core_nth) + tmp26 := lang.Apply(tmp25, []any{v21, int64(1), nil}) + var v27 any = tmp26 + _ = v27 + // let binding "entry" + var v28 any = v21 + _ = v28 + // let binding "entries" + var v29 any = v20 + _ = v29 + // let binding "kvs" + tmp30 := lang.NewVector() + tmp31 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(267), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(267), lang.NewKeyword("end-column"), int(17)) + tmp32, err := lang.WithMeta(tmp30, tmp31.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v33 any = tmp32 + _ = v33 + var tmp34 any + { // let + // let binding "ns" + var v35 any = v7 + _ = v35 + // let binding "G__221" + var v36 any = v10 + _ = v36 + // let binding "kvs" + var v37 any = v33 + _ = v37 + for { + var tmp38 any + { // let + // let binding "ns" + var v39 any = v35 + _ = v39 + // let binding "vec__228" + var v40 any = v36 + _ = v40 + // let binding "seq__229" + tmp41 := checkDerefVar(glojure_DOT_core_seq) + tmp42 := lang.Apply(tmp41, []any{v40}) + var v43 any = tmp42 + _ = v43 + // let binding "first__230" + tmp44 := checkDerefVar(glojure_DOT_core_first) + tmp45 := lang.Apply(tmp44, []any{v43}) + var v46 any = tmp45 + _ = v46 + // let binding "seq__229" + tmp47 := checkDerefVar(glojure_DOT_core_next) + tmp48 := lang.Apply(tmp47, []any{v43}) + var v49 any = tmp48 + _ = v49 + // let binding "vec__231" + var v50 any = v46 + _ = v50 + // let binding "k" + tmp51 := checkDerefVar(glojure_DOT_core_nth) + tmp52 := lang.Apply(tmp51, []any{v50, int64(0), nil}) + var v53 any = tmp52 + _ = v53 + // let binding "v" + tmp54 := checkDerefVar(glojure_DOT_core_nth) + tmp55 := lang.Apply(tmp54, []any{v50, int64(1), nil}) + var v56 any = tmp55 + _ = v56 + // let binding "entry" + var v57 any = v50 + _ = v57 + // let binding "entries" + var v58 any = v49 + _ = v58 + // let binding "kvs" + var v59 any = v37 + _ = v59 + var tmp60 any + if lang.IsTruthy(v57) { + var tmp61 any + tmp62 := checkDerefVar(glojure_DOT_core_qualified_ident_QMARK_) + tmp63 := lang.Apply(tmp62, []any{v53}) + if lang.IsTruthy(tmp63) { + var tmp64 any + if lang.IsTruthy(v39) { + var tmp65 any + tmp66 := checkDerefVar(glojure_DOT_core__EQ_) + tmp67 := checkDerefVar(glojure_DOT_core_namespace) + tmp68 := lang.Apply(tmp67, []any{v53}) + tmp69 := lang.Apply(tmp66, []any{v39, tmp68}) + if lang.IsTruthy(tmp69) { + var tmp70 any = v39 + var tmp71 any = v58 + tmp73 := checkDerefVar(glojure_DOT_core_conj) + tmp74 := checkDerefVar(glojure_DOT_core_strip_ns) + tmp75 := lang.Apply(tmp74, []any{v53}) + tmp76 := lang.NewVector(tmp75, v56) + tmp77 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(272), lang.NewKeyword("column"), int(43), lang.NewKeyword("end-line"), int(272), lang.NewKeyword("end-column"), int(58)) + tmp78, err := lang.WithMeta(tmp76, tmp77.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp79 := lang.Apply(tmp73, []any{v59, tmp78}) + var tmp72 any = tmp79 + v35 = tmp70 + v36 = tmp71 + v37 = tmp72 + continue + } else { + } + tmp64 = tmp65 + } else { + var tmp80 any + { // let + // let binding "temp__0__auto__" + tmp81 := checkDerefVar(glojure_DOT_core_namespace) + tmp82 := lang.Apply(tmp81, []any{v53}) + var v83 any = tmp82 + _ = v83 + var tmp84 any + if lang.IsTruthy(v83) { + var tmp85 any + { // let + // let binding "new-ns" + var v86 any = v83 + _ = v86 + var tmp87 any = v86 + var tmp88 any = v58 + tmp90 := checkDerefVar(glojure_DOT_core_conj) + tmp91 := checkDerefVar(glojure_DOT_core_strip_ns) + tmp92 := lang.Apply(tmp91, []any{v53}) + tmp93 := lang.NewVector(tmp92, v56) + tmp94 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(274), lang.NewKeyword("column"), int(47), lang.NewKeyword("end-line"), int(274), lang.NewKeyword("end-column"), int(62)) + tmp95, err := lang.WithMeta(tmp93, tmp94.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp96 := lang.Apply(tmp90, []any{v59, tmp95}) + var tmp89 any = tmp96 + v35 = tmp87 + v36 = tmp88 + v37 = tmp89 + continue + } // end let + tmp84 = tmp85 + } else { + } + tmp80 = tmp84 + } // end let + tmp64 = tmp80 + } + tmp61 = tmp64 + } else { + } + tmp60 = tmp61 + } else { + tmp81 := lang.NewVector(v39, v59) + tmp82 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(275), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(275), lang.NewKeyword("end-column"), int(16)) + tmp83, err := lang.WithMeta(tmp81, tmp82.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp60 = tmp83 + } + tmp38 = tmp60 + } // end let + tmp34 = tmp38 + break + } + } // end let + tmp6 = tmp34 + } // end let + tmp4 = tmp6 + } else { + } + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // line-seq + { + tmp0 := lang.NewSymbol("line-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rdr"))), lang.NewKeyword("doc"), "Returns the lines of text from rdr as a lazy sequence of strings.\n rdr must implement java.io.BufferedReader.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3068), lang.NewKeyword("end-line"), int(3068))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + { // let + // let binding "temp__0__auto__" + tmp5, ok := lang.FieldOrMethod(v3, "readLine") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "readLine"))) + } + var tmp6 any + switch reflect.TypeOf(tmp5).Kind() { + case reflect.Func: + tmp6 = lang.Apply(tmp5, nil) + default: + tmp6 = tmp5 + } + var v7 any = tmp6 + _ = v7 + var tmp8 any + if lang.IsTruthy(v7) { + var tmp9 any + { // let + // let binding "line" + var v10 any = v7 + _ = v10 + tmp11 := checkDerefVar(glojure_DOT_core_cons) + var tmp12 lang.FnFunc + tmp12 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + tmp13 := checkDerefVar(glojure_DOT_core_line_seq) + tmp14 := lang.Apply(tmp13, []any{v3}) + return tmp14 + }) + tmp13 := lang.Apply(lang.NewLazySeq, []any{tmp12}) + tmp14 := lang.Apply(tmp11, []any{v10, tmp13}) + tmp9 = tmp14 + } // end let + tmp8 = tmp9 + } else { + } + tmp4 = tmp8 + } // end let + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // list + { + tmp0 := lang.NewSymbol("list").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("items"))), lang.NewKeyword("doc"), "Creates a new list containing the items.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(15), lang.NewKeyword("end-line"), int(18))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, lang.NewList, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // list* + { + tmp0 := lang.NewSymbol("list*").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Creates a new seq containing the items prepended to the rest, the\n last of which will be treated as a sequence.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(641), lang.NewKeyword("end-line"), int(641))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_cons) + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6 := checkDerefVar(glojure_DOT_core_cons) + tmp7 := checkDerefVar(glojure_DOT_core_cons) + tmp8 := lang.Apply(tmp7, []any{v4, v5}) + tmp9 := lang.Apply(tmp6, []any{v3, tmp8}) + return tmp9 + case 4: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_cons) + tmp8 := checkDerefVar(glojure_DOT_core_cons) + tmp9 := checkDerefVar(glojure_DOT_core_cons) + tmp10 := lang.Apply(tmp9, []any{v5, v6}) + tmp11 := lang.Apply(tmp8, []any{v4, tmp10}) + tmp12 := lang.Apply(tmp7, []any{v3, tmp11}) + return tmp12 + default: + if len(args) < 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + var v7 any = lang.NewList(args[4:]...) + _ = v7 + tmp8 := checkDerefVar(glojure_DOT_core_cons) + tmp9 := checkDerefVar(glojure_DOT_core_cons) + tmp10 := checkDerefVar(glojure_DOT_core_cons) + tmp11 := checkDerefVar(glojure_DOT_core_cons) + tmp12 := checkDerefVar(glojure_DOT_core_spread) + tmp13 := lang.Apply(tmp12, []any{v7}) + tmp14 := lang.Apply(tmp11, []any{v6, tmp13}) + tmp15 := lang.Apply(tmp10, []any{v5, tmp14}) + tmp16 := lang.Apply(tmp9, []any{v4, tmp15}) + tmp17 := lang.Apply(tmp8, []any{v3, tmp16}) + return tmp17 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // list? + { + tmp0 := lang.NewSymbol("list?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements IPersistentList", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6198), lang.NewKeyword("end-line"), int(6198))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp5 := reflect.TypeOf((*lang.IPersistentList)(nil)).Elem() + tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // load + { + tmp0 := lang.NewSymbol("load").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("paths"))), lang.NewKeyword("doc"), "Loads Clojure code from resources in classpath. A path is interpreted as\n classpath-relative if it begins with a slash or relative to the root\n directory for the current namespace otherwise.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("redef"), true, lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6095), lang.NewKeyword("end-line"), int(6095))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v3 any = lang.NewList(args[0:]...) + _ = v3 + var tmp4 any + { // let + // let binding "seq_133" + tmp5 := checkDerefVar(glojure_DOT_core_seq) + tmp6 := lang.Apply(tmp5, []any{v3}) + var v7 any = tmp6 + _ = v7 + // let binding "chunk_134" + var v8 any = nil + _ = v8 + // let binding "count_135" + var v9 any = int64(0) + _ = v9 + // let binding "i_136" + var v10 any = int64(0) + _ = v10 + for { + var tmp11 any + tmp12 := checkDerefVar(glojure_DOT_core__LT_) + tmp13 := lang.Apply(tmp12, []any{v10, v9}) + if lang.IsTruthy(tmp13) { + var tmp14 any + { // let + // let binding "path" + tmp15, _ := lang.FieldOrMethod(v8, "nth") + if reflect.TypeOf(tmp15).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp16 := lang.Apply(tmp15, []any{v10}) + var v17 any = tmp16 + _ = v17 + var tmp18 any + { // let + // let binding "path" + var tmp19 any + tmp20 := lang.Apply(strings11.HasPrefix, []any{v17, "/"}) + if lang.IsTruthy(tmp20) { + tmp19 = v17 + } else { + tmp21 := checkDerefVar(glojure_DOT_core_str) + tmp22 := checkDerefVar(glojure_DOT_core_root_directory) + tmp23 := checkDerefVar(glojure_DOT_core_ns_name) + tmp24 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) + tmp25 := lang.Apply(tmp23, []any{tmp24}) + tmp26 := lang.Apply(tmp22, []any{tmp25}) + tmp27 := lang.Apply(tmp21, []any{tmp26, lang.NewChar(47), v17}) + tmp19 = tmp27 + } + var v28 any = tmp19 + _ = v28 + var tmp29 any + tmp30 := checkDerefVar(glojure_DOT_core__STAR_loading_verbosely_STAR_) + if lang.IsTruthy(tmp30) { + tmp31 := checkDerefVar(glojure_DOT_core_printf) + tmp32 := lang.Apply(tmp31, []any{"(glojure.core/load \"%s\")\n", v28}) + _ = tmp32 + tmp33 := checkDerefVar(glojure_DOT_core_flush) + tmp34 := lang.Apply(tmp33, nil) + tmp29 = tmp34 + } else { + } + _ = tmp29 + tmp35 := checkDerefVar(glojure_DOT_core_check_cyclic_dependency) + tmp36 := lang.Apply(tmp35, []any{v28}) + _ = tmp36 + var tmp37 any + tmp38 := checkDerefVar(glojure_DOT_core__EQ_) + tmp39 := checkDerefVar(glojure_DOT_core_first) + tmp40 := checkDerefVar(glojure_DOT_core__STAR_pending_paths_STAR_) + tmp41 := lang.Apply(tmp39, []any{tmp40}) + tmp42 := lang.Apply(tmp38, []any{v28, tmp41}) + if lang.IsTruthy(tmp42) { + } else { + var tmp43 any + { // let + tmp44 := checkDerefVar(glojure_DOT_core_push_thread_bindings) + tmp45 := checkDerefVar(glojure_DOT_core_hash_map) + tmp46 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*pending-paths*")) + tmp47 := checkDerefVar(glojure_DOT_core_conj) + tmp48 := checkDerefVar(glojure_DOT_core__STAR_pending_paths_STAR_) + tmp49 := lang.Apply(tmp47, []any{tmp48, v28}) + tmp50 := lang.Apply(tmp45, []any{tmp46, tmp49}) + tmp51 := lang.Apply(tmp44, []any{tmp50}) + _ = tmp51 + var tmp52 any + func() { + defer func() { + tmp53 := checkDerefVar(glojure_DOT_core_pop_thread_bindings) + tmp54 := lang.Apply(tmp53, nil) + _ = tmp54 + }() + tmp55 := lang.Apply(strings11.TrimPrefix, []any{v28, "/"}) + tmp56, _ := lang.FieldOrMethod(runtime7.RT, "Load") + if reflect.TypeOf(tmp56).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Load is not a function"))) + } + tmp57 := lang.Apply(tmp56, []any{tmp55}) + tmp52 = tmp57 + }() + tmp43 = tmp52 + } // end let + tmp37 = tmp43 + } + tmp18 = tmp37 + } // end let + _ = tmp18 + var tmp19 any = v7 + var tmp20 any = v8 + var tmp21 any = v9 + tmp23 := checkDerefVar(glojure_DOT_core_unchecked_inc) + tmp24 := lang.Apply(tmp23, []any{v10}) + var tmp22 any = tmp24 + v7 = tmp19 + v8 = tmp20 + v9 = tmp21 + v10 = tmp22 + continue + } // end let + tmp11 = tmp14 + } else { + var tmp15 any + { // let + // let binding "temp__0__auto__" + tmp16 := checkDerefVar(glojure_DOT_core_seq) + tmp17 := lang.Apply(tmp16, []any{v7}) + var v18 any = tmp17 + _ = v18 + var tmp19 any + if lang.IsTruthy(v18) { + var tmp20 any + { // let + // let binding "seq_133" + var v21 any = v18 + _ = v21 + var tmp22 any + tmp23 := checkDerefVar(glojure_DOT_core_chunked_seq_QMARK_) + tmp24 := lang.Apply(tmp23, []any{v21}) + if lang.IsTruthy(tmp24) { + var tmp25 any + { // let + // let binding "c__0__auto__" + tmp26 := checkDerefVar(glojure_DOT_core_chunk_first) + tmp27 := lang.Apply(tmp26, []any{v21}) + var v28 any = tmp27 + _ = v28 + tmp30 := checkDerefVar(glojure_DOT_core_chunk_rest) + tmp31 := lang.Apply(tmp30, []any{v21}) + var tmp29 any = tmp31 + var tmp32 any = v28 + tmp34 := checkDerefVar(glojure_DOT_core_int) + tmp35 := checkDerefVar(glojure_DOT_core_count) + tmp36 := lang.Apply(tmp35, []any{v28}) + tmp37 := lang.Apply(tmp34, []any{tmp36}) + var tmp33 any = tmp37 + tmp39 := checkDerefVar(glojure_DOT_core_int) + tmp40 := lang.Apply(tmp39, []any{int64(0)}) + var tmp38 any = tmp40 + v7 = tmp29 + v8 = tmp32 + v9 = tmp33 + v10 = tmp38 + continue + } // end let + tmp22 = tmp25 + } else { + var tmp26 any + { // let + // let binding "path" + tmp27 := checkDerefVar(glojure_DOT_core_first) + tmp28 := lang.Apply(tmp27, []any{v21}) + var v29 any = tmp28 + _ = v29 + var tmp30 any + { // let + // let binding "path" + var tmp31 any + tmp32 := lang.Apply(strings11.HasPrefix, []any{v29, "/"}) + if lang.IsTruthy(tmp32) { + tmp31 = v29 + } else { + tmp33 := checkDerefVar(glojure_DOT_core_str) + tmp34 := checkDerefVar(glojure_DOT_core_root_directory) + tmp35 := checkDerefVar(glojure_DOT_core_ns_name) + tmp36 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) + tmp37 := lang.Apply(tmp35, []any{tmp36}) + tmp38 := lang.Apply(tmp34, []any{tmp37}) + tmp39 := lang.Apply(tmp33, []any{tmp38, lang.NewChar(47), v29}) + tmp31 = tmp39 + } + var v40 any = tmp31 + _ = v40 + var tmp41 any + tmp42 := checkDerefVar(glojure_DOT_core__STAR_loading_verbosely_STAR_) + if lang.IsTruthy(tmp42) { + tmp43 := checkDerefVar(glojure_DOT_core_printf) + tmp44 := lang.Apply(tmp43, []any{"(glojure.core/load \"%s\")\n", v40}) + _ = tmp44 + tmp45 := checkDerefVar(glojure_DOT_core_flush) + tmp46 := lang.Apply(tmp45, nil) + tmp41 = tmp46 + } else { + } + _ = tmp41 + tmp47 := checkDerefVar(glojure_DOT_core_check_cyclic_dependency) + tmp48 := lang.Apply(tmp47, []any{v40}) + _ = tmp48 + var tmp49 any + tmp50 := checkDerefVar(glojure_DOT_core__EQ_) + tmp51 := checkDerefVar(glojure_DOT_core_first) + tmp52 := checkDerefVar(glojure_DOT_core__STAR_pending_paths_STAR_) + tmp53 := lang.Apply(tmp51, []any{tmp52}) + tmp54 := lang.Apply(tmp50, []any{v40, tmp53}) + if lang.IsTruthy(tmp54) { + } else { + var tmp55 any + { // let + tmp56 := checkDerefVar(glojure_DOT_core_push_thread_bindings) + tmp57 := checkDerefVar(glojure_DOT_core_hash_map) + tmp58 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*pending-paths*")) + tmp59 := checkDerefVar(glojure_DOT_core_conj) + tmp60 := checkDerefVar(glojure_DOT_core__STAR_pending_paths_STAR_) + tmp61 := lang.Apply(tmp59, []any{tmp60, v40}) + tmp62 := lang.Apply(tmp57, []any{tmp58, tmp61}) + tmp63 := lang.Apply(tmp56, []any{tmp62}) + _ = tmp63 + var tmp64 any + func() { + defer func() { + tmp65 := checkDerefVar(glojure_DOT_core_pop_thread_bindings) + tmp66 := lang.Apply(tmp65, nil) + _ = tmp66 + }() + tmp67 := lang.Apply(strings11.TrimPrefix, []any{v40, "/"}) + tmp68, _ := lang.FieldOrMethod(runtime7.RT, "Load") + if reflect.TypeOf(tmp68).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Load is not a function"))) + } + tmp69 := lang.Apply(tmp68, []any{tmp67}) + tmp64 = tmp69 + }() + tmp55 = tmp64 + } // end let + tmp49 = tmp55 + } + tmp30 = tmp49 + } // end let + _ = tmp30 + tmp32 := checkDerefVar(glojure_DOT_core_next) + tmp33 := lang.Apply(tmp32, []any{v21}) + var tmp31 any = tmp33 + var tmp34 any = nil + var tmp35 any = int64(0) + var tmp36 any = int64(0) + v7 = tmp31 + v8 = tmp34 + v9 = tmp35 + v10 = tmp36 + continue + } // end let + tmp22 = tmp26 + } + tmp20 = tmp22 + } // end let + tmp19 = tmp20 + } else { + } + tmp15 = tmp19 + } // end let + tmp11 = tmp15 + } + tmp4 = tmp11 + break + } + } // end let + return tmp4 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // load-all + { + tmp0 := lang.NewSymbol("load-all").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"), lang.NewSymbol("need-ns"), lang.NewSymbol("require"))), lang.NewKeyword("doc"), "Loads a lib given its name and forces a load of any libs it directly or\n indirectly loads. If need-ns, ensures that the associated namespace\n exists after loading. If require, records the load so any duplicate loads\n can be skipped.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5892), lang.NewKeyword("end-line"), int(5892), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + tmp7 := checkDerefVar(glojure_DOT_core_commute) + tmp8 := checkDerefVar(glojure_DOT_core__STAR_loaded_libs_STAR_) + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + tmp12 := checkDerefVar(glojure_DOT_core_reduce1) + tmp13 := checkDerefVar(glojure_DOT_core_conj) + tmp14 := lang.Apply(tmp12, []any{tmp13, v10, v11}) + return tmp14 + }) + tmp10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5899), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(5899), lang.NewKeyword("end-column"), int(47)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var tmp12 any + { // let + tmp13 := checkDerefVar(glojure_DOT_core_push_thread_bindings) + tmp14 := checkDerefVar(glojure_DOT_core_hash_map) + tmp15 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*loaded-libs*")) + tmp16 := checkDerefVar(glojure_DOT_core_ref) + tmp17 := checkDerefVar(glojure_DOT_core_sorted_set) + tmp18 := lang.Apply(tmp17, nil) + tmp19 := lang.Apply(tmp16, []any{tmp18}) + tmp20 := lang.Apply(tmp14, []any{tmp15, tmp19}) + tmp21 := lang.Apply(tmp13, []any{tmp20}) + _ = tmp21 + var tmp22 any + func() { + defer func() { + tmp23 := checkDerefVar(glojure_DOT_core_pop_thread_bindings) + tmp24 := lang.Apply(tmp23, nil) + _ = tmp24 + }() + tmp25 := checkDerefVar(glojure_DOT_core_load_one) + tmp26 := lang.Apply(tmp25, []any{v3, v4, v5}) + _ = tmp26 + tmp27 := checkDerefVar(glojure_DOT_core_deref) + tmp28 := checkDerefVar(glojure_DOT_core__STAR_loaded_libs_STAR_) + tmp29 := lang.Apply(tmp27, []any{tmp28}) + tmp22 = tmp29 + }() + tmp12 = tmp22 + } // end let + tmp13 := lang.Apply(tmp7, []any{tmp8, tmp11, tmp12}) + return tmp13 + }) + tmp7, _ := lang.FieldOrMethod(lang.LockingTransaction, "RunInTransaction") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("RunInTransaction is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{tmp6}) + return tmp8 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // load-data-reader-file + { + tmp0 := lang.NewSymbol("load-data-reader-file").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7836), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7836), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("mappings"), lang.NewSymbol("url"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 any + { // let + // let binding "rdr" + tmp6, ok := lang.FieldOrMethod(v4, "openStream") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "openStream"))) + } + var tmp7 any + switch reflect.TypeOf(tmp6).Kind() { + case reflect.Func: + tmp7 = lang.Apply(tmp6, nil) + default: + tmp7 = tmp6 + } + tmp8 := lang.Apply(nil, []any{tmp7, "UTF-8"}) + tmp9 := lang.Apply(nil, []any{tmp8}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + func() { + defer func() { + tmp12, ok := lang.FieldOrMethod(v10, "close") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v10, "close"))) + } + var tmp13 any + switch reflect.TypeOf(tmp12).Kind() { + case reflect.Func: + tmp13 = lang.Apply(tmp12, nil) + default: + tmp13 = tmp12 + } + _ = tmp13 + }() + var tmp14 any + { // let + tmp15 := checkDerefVar(glojure_DOT_core_push_thread_bindings) + tmp16 := checkDerefVar(glojure_DOT_core_hash_map) + tmp17 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*file*")) + tmp18, ok := lang.FieldOrMethod(v4, "getFile") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "getFile"))) + } + var tmp19 any + switch reflect.TypeOf(tmp18).Kind() { + case reflect.Func: + tmp19 = lang.Apply(tmp18, nil) + default: + tmp19 = tmp18 + } + tmp20 := lang.Apply(tmp16, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp15, []any{tmp20}) + _ = tmp21 + var tmp22 any + func() { + defer func() { + tmp23 := checkDerefVar(glojure_DOT_core_pop_thread_bindings) + tmp24 := lang.Apply(tmp23, nil) + _ = tmp24 + }() + var tmp25 any + { // let + // let binding "read-opts" + var tmp26 any + tmp27, ok := lang.FieldOrMethod(v4, "getPath") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "getPath"))) + } + var tmp28 any + switch reflect.TypeOf(tmp27).Kind() { + case reflect.Func: + tmp28 = lang.Apply(tmp27, nil) + default: + tmp28 = tmp27 + } + tmp29, _ := lang.FieldOrMethod(tmp28, "endsWith") + if reflect.TypeOf(tmp29).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("endsWith is not a function"))) + } + tmp30 := lang.Apply(tmp29, []any{"cljc"}) + if lang.IsTruthy(tmp30) { + tmp31 := lang.NewMap(lang.NewKeyword("eof"), nil, lang.NewKeyword("read-cond"), lang.NewKeyword("allow")) + tmp32 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7842), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7842), lang.NewKeyword("end-column"), int(52)) + tmp33, err := lang.WithMeta(tmp31, tmp32.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp26 = tmp33 + } else { + tmp34 := lang.NewMap(lang.NewKeyword("eof"), nil) + tmp35 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7843), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7843), lang.NewKeyword("end-column"), int(34)) + tmp36, err := lang.WithMeta(tmp34, tmp35.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp26 = tmp36 + } + var v37 any = tmp26 + _ = v37 + // let binding "new-mappings" + tmp38 := checkDerefVar(glojure_DOT_core_read) + tmp39 := lang.Apply(tmp38, []any{v37, v10}) + var v40 any = tmp39 + _ = v40 + var tmp41 any + tmp42 := checkDerefVar(glojure_DOT_core_not) + tmp43 := checkDerefVar(glojure_DOT_core_map_QMARK_) + tmp44 := lang.Apply(tmp43, []any{v40}) + tmp45 := lang.Apply(tmp42, []any{tmp44}) + if lang.IsTruthy(tmp45) { + tmp46 := checkDerefVar(glojure_DOT_core_ex_info) + tmp47 := checkDerefVar(glojure_DOT_core_str) + tmp48 := lang.Apply(tmp47, []any{"Not a valid data-reader map"}) + tmp49 := lang.NewMap(lang.NewKeyword("url"), v4) + tmp50 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7847), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(7847), lang.NewKeyword("end-column"), int(36)) + tmp51, err := lang.WithMeta(tmp49, tmp50.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp52 := lang.Apply(tmp46, []any{tmp48, tmp51}) + panic(tmp52) + } else { + } + _ = tmp41 + tmp53 := checkDerefVar(glojure_DOT_core_reduce) + var tmp54 lang.FnFunc + tmp54 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v55 := args[0] + _ = v55 + v56 := args[1] + _ = v56 + var tmp57 any + { // let + // let binding "vec__359" + var v58 any = v56 + _ = v58 + // let binding "k" + tmp59 := checkDerefVar(glojure_DOT_core_nth) + tmp60 := lang.Apply(tmp59, []any{v58, int64(0), nil}) + var v61 any = tmp60 + _ = v61 + // let binding "v" + tmp62 := checkDerefVar(glojure_DOT_core_nth) + tmp63 := lang.Apply(tmp62, []any{v58, int64(1), nil}) + var v64 any = tmp63 + _ = v64 + var tmp65 any + tmp66 := checkDerefVar(glojure_DOT_core_not) + tmp67 := checkDerefVar(glojure_DOT_core_symbol_QMARK_) + tmp68 := lang.Apply(tmp67, []any{v61}) + tmp69 := lang.Apply(tmp66, []any{tmp68}) + if lang.IsTruthy(tmp69) { + tmp70 := checkDerefVar(glojure_DOT_core_ex_info) + tmp71 := checkDerefVar(glojure_DOT_core_str) + tmp72 := lang.Apply(tmp71, []any{"Invalid form in data-reader file"}) + tmp73 := lang.NewMap(lang.NewKeyword("url"), v4, lang.NewKeyword("form"), v61) + tmp74 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7852), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(7853), lang.NewKeyword("end-column"), int(38)) + tmp75, err := lang.WithMeta(tmp73, tmp74.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp76 := lang.Apply(tmp70, []any{tmp72, tmp75}) + panic(tmp76) + } else { + } + _ = tmp65 + var tmp77 any + { // let + // let binding "v-var" + tmp78 := checkDerefVar(glojure_DOT_core_data_reader_var) + tmp79 := lang.Apply(tmp78, []any{v64}) + var v80 any = tmp79 + _ = v80 + var tmp81 any + var tmp82 any + { // let + // let binding "and__0__auto__" + tmp83 := checkDerefVar(glojure_DOT_core_contains_QMARK_) + tmp84 := lang.Apply(tmp83, []any{v3, v61}) + var v85 any = tmp84 + _ = v85 + var tmp86 any + if lang.IsTruthy(v85) { + tmp87 := checkDerefVar(glojure_DOT_core_not_EQ_) + tmp88 := lang.Apply(v3, []any{v61}) + tmp89 := lang.Apply(tmp87, []any{tmp88, v80}) + tmp86 = tmp89 + } else { + tmp86 = v85 + } + tmp82 = tmp86 + } // end let + if lang.IsTruthy(tmp82) { + tmp83 := checkDerefVar(glojure_DOT_core_ex_info) + tmp84 := lang.NewMap(lang.NewKeyword("url"), v4, lang.NewKeyword("conflict"), v61, lang.NewKeyword("mappings"), v55) + tmp85 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7858), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(7860), lang.NewKeyword("end-column"), int(44)) + tmp86, err := lang.WithMeta(tmp84, tmp85.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp87 := lang.Apply(tmp83, []any{"Conflicting data-reader mapping", tmp86}) + panic(tmp87) + } else { + } + _ = tmp81 + tmp88 := checkDerefVar(glojure_DOT_core_assoc) + tmp89 := lang.Apply(tmp88, []any{v55, v61, v80}) + tmp77 = tmp89 + } // end let + tmp57 = tmp77 + } // end let + return tmp57 + }) + tmp55 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7849), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(7861), lang.NewKeyword("end-column"), int(32)) + tmp56, err := lang.WithMeta(tmp54, tmp55.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp57 := lang.Apply(tmp53, []any{tmp56, v3, v40}) + tmp25 = tmp57 + } // end let + tmp22 = tmp25 + }() + tmp14 = tmp22 + } // end let + tmp11 = tmp14 + }() + tmp5 = tmp11 + } // end let + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // load-data-readers + { + tmp0 := lang.NewSymbol("load-data-readers").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7865), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7865), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + tmp3 := checkDerefVar(glojure_DOT_core_alter_var_root) + tmp4 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*data-readers*")) + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v6 := args[0] + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_reduce) + tmp8 := checkDerefVar(glojure_DOT_core_load_data_reader_file) + tmp9 := checkDerefVar(glojure_DOT_core_data_reader_urls) + tmp10 := lang.Apply(tmp9, nil) + tmp11 := lang.Apply(tmp7, []any{tmp8, v6, tmp10}) + return tmp11 + }) + tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7867), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(7869), lang.NewKeyword("end-column"), int(57)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp8 := lang.Apply(tmp3, []any{tmp4, tmp7}) + return tmp8 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // load-file + { + tmp0 := lang.NewSymbol("load-file").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // load-lib + { + tmp0 := lang.NewSymbol("load-lib").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("prefix"), lang.NewSymbol("lib"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Loads a lib with options", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5904), lang.NewKeyword("end-line"), int(5904), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := checkDerefVar(glojure_DOT_core_throw_if) + var tmp7 any + { // let + // let binding "and__0__auto__" + var v8 any = v3 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + tmp10 := checkDerefVar(glojure_DOT_core_pos_QMARK_) + tmp11 := checkDerefVar(glojure_DOT_core_name) + tmp12 := lang.Apply(tmp11, []any{v4}) + tmp13 := checkDerefVar(glojure_DOT_core_int) + tmp14 := lang.Apply(tmp13, []any{lang.NewChar(46)}) + tmp15 := lang.Apply(strings11.Index, []any{tmp12, tmp14}) + tmp16 := lang.Apply(tmp10, []any{tmp15}) + tmp9 = tmp16 + } else { + tmp9 = v8 + } + tmp7 = tmp9 + } // end let + tmp8 := checkDerefVar(glojure_DOT_core_name) + tmp9 := lang.Apply(tmp8, []any{v4}) + tmp10 := lang.Apply(tmp6, []any{tmp7, "Found lib name '%s' containing period with prefix '%s'. lib names inside prefix lists must not contain periods", tmp9, v3}) + _ = tmp10 + var tmp11 any + { // let + // let binding "lib" + var tmp12 any + if lang.IsTruthy(v3) { + tmp13 := checkDerefVar(glojure_DOT_core_symbol) + tmp14 := checkDerefVar(glojure_DOT_core_str) + tmp15 := lang.Apply(tmp14, []any{v3, lang.NewChar(46), v4}) + tmp16 := lang.Apply(tmp13, []any{tmp15}) + tmp12 = tmp16 + } else { + tmp12 = v4 + } + var v17 any = tmp12 + _ = v17 + // let binding "opts" + tmp18 := checkDerefVar(glojure_DOT_core_apply) + tmp19 := checkDerefVar(glojure_DOT_core_hash_map) + tmp20 := lang.Apply(tmp18, []any{tmp19, v5}) + var v21 any = tmp20 + _ = v21 + // let binding "map__110" + var v22 any = v21 + _ = v22 + // let binding "map__110" + var tmp23 any + tmp24 := checkDerefVar(glojure_DOT_core_seq_QMARK_) + tmp25 := lang.Apply(tmp24, []any{v22}) + if lang.IsTruthy(tmp25) { + var tmp26 any + tmp27 := checkDerefVar(glojure_DOT_core_next) + tmp28 := lang.Apply(tmp27, []any{v22}) + if lang.IsTruthy(tmp28) { + tmp29 := checkDerefVar(glojure_DOT_core_to_array) + tmp30 := lang.Apply(tmp29, []any{v22}) + tmp31 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{tmp30}) + tmp26 = tmp31 + } else { + var tmp32 any + tmp33 := checkDerefVar(glojure_DOT_core_seq) + tmp34 := lang.Apply(tmp33, []any{v22}) + if lang.IsTruthy(tmp34) { + tmp35 := checkDerefVar(glojure_DOT_core_first) + tmp36 := lang.Apply(tmp35, []any{v22}) + tmp32 = tmp36 + } else { + } + tmp26 = tmp32 + } + tmp23 = tmp26 + } else { + tmp23 = v22 + } + var v37 any = tmp23 + _ = v37 + // let binding "as" + tmp38 := checkDerefVar(glojure_DOT_core_get) + tmp39 := lang.Apply(tmp38, []any{v37, lang.NewKeyword("as")}) + var v40 any = tmp39 + _ = v40 + // let binding "reload" + tmp41 := checkDerefVar(glojure_DOT_core_get) + tmp42 := lang.Apply(tmp41, []any{v37, lang.NewKeyword("reload")}) + var v43 any = tmp42 + _ = v43 + // let binding "reload-all" + tmp44 := checkDerefVar(glojure_DOT_core_get) + tmp45 := lang.Apply(tmp44, []any{v37, lang.NewKeyword("reload-all")}) + var v46 any = tmp45 + _ = v46 + // let binding "require" + tmp47 := checkDerefVar(glojure_DOT_core_get) + tmp48 := lang.Apply(tmp47, []any{v37, lang.NewKeyword("require")}) + var v49 any = tmp48 + _ = v49 + // let binding "use" + tmp50 := checkDerefVar(glojure_DOT_core_get) + tmp51 := lang.Apply(tmp50, []any{v37, lang.NewKeyword("use")}) + var v52 any = tmp51 + _ = v52 + // let binding "verbose" + tmp53 := checkDerefVar(glojure_DOT_core_get) + tmp54 := lang.Apply(tmp53, []any{v37, lang.NewKeyword("verbose")}) + var v55 any = tmp54 + _ = v55 + // let binding "as-alias" + tmp56 := checkDerefVar(glojure_DOT_core_get) + tmp57 := lang.Apply(tmp56, []any{v37, lang.NewKeyword("as-alias")}) + var v58 any = tmp57 + _ = v58 + // let binding "loaded" + tmp59 := checkDerefVar(glojure_DOT_core_contains_QMARK_) + tmp60 := checkDerefVar(glojure_DOT_core_deref) + tmp61 := checkDerefVar(glojure_DOT_core__STAR_loaded_libs_STAR_) + tmp62 := lang.Apply(tmp60, []any{tmp61}) + tmp63 := lang.Apply(tmp59, []any{tmp62, v17}) + var v64 any = tmp63 + _ = v64 + // let binding "need-ns" + var tmp65 any + { // let + // let binding "or__0__auto__" + var v66 any = v40 + _ = v66 + var tmp67 any + if lang.IsTruthy(v66) { + tmp67 = v66 + } else { + tmp67 = v52 + } + tmp65 = tmp67 + } // end let + var v66 any = tmp65 + _ = v66 + // let binding "load" + var tmp67 any + if lang.IsTruthy(v46) { + tmp68 := checkDerefVar(glojure_DOT_core_load_all) + tmp67 = tmp68 + } else { + var tmp69 any + if lang.IsTruthy(v43) { + tmp70 := checkDerefVar(glojure_DOT_core_load_one) + tmp69 = tmp70 + } else { + var tmp71 any + tmp72 := checkDerefVar(glojure_DOT_core_not) + tmp73 := lang.Apply(tmp72, []any{v64}) + if lang.IsTruthy(tmp73) { + var tmp74 any + if lang.IsTruthy(v66) { + tmp75 := checkDerefVar(glojure_DOT_core_load_one) + tmp74 = tmp75 + } else { + var tmp76 any + if lang.IsTruthy(v58) { + var tmp77 lang.FnFunc + tmp77 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v78 := args[0] + _ = v78 + v79 := args[1] + _ = v79 + v80 := args[2] + _ = v80 + tmp81 := checkDerefVar(glojure_DOT_core_create_ns) + tmp82 := lang.Apply(tmp81, []any{v78}) + return tmp82 + }) + tmp78 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5918), lang.NewKeyword("column"), int(48), lang.NewKeyword("end-line"), int(5918), lang.NewKeyword("end-column"), int(88)) + tmp79, err := lang.WithMeta(tmp77, tmp78.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp76 = tmp79 + } else { + var tmp80 any + if lang.IsTruthy(lang.NewKeyword("else")) { + tmp81 := checkDerefVar(glojure_DOT_core_load_one) + tmp80 = tmp81 + } else { + } + tmp76 = tmp80 + } + tmp74 = tmp76 + } + tmp71 = tmp74 + } else { + } + tmp69 = tmp71 + } + tmp67 = tmp69 + } + var v82 any = tmp67 + _ = v82 + // let binding "filter-opts" + tmp83 := checkDerefVar(glojure_DOT_core_select_keys) + tmp84 := lang.Apply(tmp83, []any{v21, lang.NewList(lang.NewKeyword("exclude"), lang.NewKeyword("only"), lang.NewKeyword("rename"), lang.NewKeyword("refer"))}) + var v85 any = tmp84 + _ = v85 + // let binding "undefined-on-entry" + tmp86 := checkDerefVar(glojure_DOT_core_not) + tmp87 := checkDerefVar(glojure_DOT_core_find_ns) + tmp88 := lang.Apply(tmp87, []any{v17}) + tmp89 := lang.Apply(tmp86, []any{tmp88}) + var v90 any = tmp89 + _ = v90 + var tmp91 any + { // let + tmp92 := checkDerefVar(glojure_DOT_core_push_thread_bindings) + tmp93 := checkDerefVar(glojure_DOT_core_hash_map) + tmp94 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*loading-verbosely*")) + var tmp95 any + { // let + // let binding "or__0__auto__" + tmp96 := checkDerefVar(glojure_DOT_core__STAR_loading_verbosely_STAR_) + var v97 any = tmp96 + _ = v97 + var tmp98 any + if lang.IsTruthy(v97) { + tmp98 = v97 + } else { + tmp98 = v55 + } + tmp95 = tmp98 + } // end let + tmp96 := lang.Apply(tmp93, []any{tmp94, tmp95}) + tmp97 := lang.Apply(tmp92, []any{tmp96}) + _ = tmp97 + var tmp98 any + func() { + defer func() { + tmp99 := checkDerefVar(glojure_DOT_core_pop_thread_bindings) + tmp100 := lang.Apply(tmp99, nil) + _ = tmp100 + }() + var tmp101 any + if lang.IsTruthy(v82) { + var tmp102 any + func() { + defer func() { + if r := recover(); r != nil { + if lang.CatchMatches(r, lang.Builtins["any"]) { + v103 := r + _ = v103 + var tmp104 any + if lang.IsTruthy(v90) { + tmp105 := checkDerefVar(glojure_DOT_core_remove_ns) + tmp106 := lang.Apply(tmp105, []any{v17}) + tmp104 = tmp106 + } else { + } + _ = tmp104 + panic(v103) + } else { + panic(r) + } + } + }() + tmp103 := lang.Apply(v82, []any{v17, v66, v49}) + tmp102 = tmp103 + }() + tmp101 = tmp102 + } else { + tmp104 := checkDerefVar(glojure_DOT_core_throw_if) + var tmp105 any + { // let + // let binding "and__0__auto__" + var v106 any = v66 + _ = v106 + var tmp107 any + if lang.IsTruthy(v106) { + tmp108 := checkDerefVar(glojure_DOT_core_not) + tmp109 := checkDerefVar(glojure_DOT_core_find_ns) + tmp110 := lang.Apply(tmp109, []any{v17}) + tmp111 := lang.Apply(tmp108, []any{tmp110}) + tmp107 = tmp111 + } else { + tmp107 = v106 + } + tmp105 = tmp107 + } // end let + tmp106 := lang.Apply(tmp104, []any{tmp105, "namespace '%s' not found", v17}) + tmp101 = tmp106 + } + _ = tmp101 + var tmp107 any + var tmp108 any + { // let + // let binding "and__0__auto__" + var v109 any = v66 + _ = v109 + var tmp110 any + if lang.IsTruthy(v109) { + tmp111 := checkDerefVar(glojure_DOT_core__STAR_loading_verbosely_STAR_) + tmp110 = tmp111 + } else { + tmp110 = v109 + } + tmp108 = tmp110 + } // end let + if lang.IsTruthy(tmp108) { + tmp109 := checkDerefVar(glojure_DOT_core_printf) + tmp110 := checkDerefVar(glojure_DOT_core_ns_name) + tmp111 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) + tmp112 := lang.Apply(tmp110, []any{tmp111}) + tmp113 := lang.Apply(tmp109, []any{"(glojure.core/in-ns '%s)\n", tmp112}) + tmp107 = tmp113 + } else { + } + _ = tmp107 + var tmp114 any + if lang.IsTruthy(v40) { + var tmp115 any + tmp116 := checkDerefVar(glojure_DOT_core__STAR_loading_verbosely_STAR_) + if lang.IsTruthy(tmp116) { + tmp117 := checkDerefVar(glojure_DOT_core_printf) + tmp118 := lang.Apply(tmp117, []any{"(glojure.core/alias '%s '%s)\n", v40, v17}) + tmp115 = tmp118 + } else { + } + _ = tmp115 + tmp119 := checkDerefVar(glojure_DOT_core_alias) + tmp120 := lang.Apply(tmp119, []any{v40, v17}) + tmp114 = tmp120 + } else { + } + _ = tmp114 + var tmp121 any + if lang.IsTruthy(v58) { + var tmp122 any + tmp123 := checkDerefVar(glojure_DOT_core__STAR_loading_verbosely_STAR_) + if lang.IsTruthy(tmp123) { + tmp124 := checkDerefVar(glojure_DOT_core_printf) + tmp125 := lang.Apply(tmp124, []any{"(glojure.core/alias '%s '%s)\n", v58, v17}) + tmp122 = tmp125 + } else { + } + _ = tmp122 + tmp126 := checkDerefVar(glojure_DOT_core_alias) + tmp127 := lang.Apply(tmp126, []any{v58, v17}) + tmp121 = tmp127 + } else { + } + _ = tmp121 + var tmp128 any + var tmp129 any + { // let + // let binding "or__0__auto__" + var v130 any = v52 + _ = v130 + var tmp131 any + if lang.IsTruthy(v130) { + tmp131 = v130 + } else { + tmp132 := lang.Apply(lang.NewKeyword("refer"), []any{v85}) + tmp131 = tmp132 + } + tmp129 = tmp131 + } // end let + if lang.IsTruthy(tmp129) { + var tmp130 any + tmp131 := checkDerefVar(glojure_DOT_core__STAR_loading_verbosely_STAR_) + if lang.IsTruthy(tmp131) { + tmp132 := checkDerefVar(glojure_DOT_core_printf) + tmp133 := lang.Apply(tmp132, []any{"(glojure.core/refer '%s", v17}) + _ = tmp133 + var tmp134 any + { // let + // let binding "seq_111" + tmp135 := checkDerefVar(glojure_DOT_core_seq) + tmp136 := lang.Apply(tmp135, []any{v85}) + var v137 any = tmp136 + _ = v137 + // let binding "chunk_112" + var v138 any = nil + _ = v138 + // let binding "count_113" + var v139 any = int64(0) + _ = v139 + // let binding "i_114" + var v140 any = int64(0) + _ = v140 + for { + var tmp141 any + tmp142 := checkDerefVar(glojure_DOT_core__LT_) + tmp143 := lang.Apply(tmp142, []any{v140, v139}) + if lang.IsTruthy(tmp143) { + var tmp144 any + { // let + // let binding "opt" + tmp145, _ := lang.FieldOrMethod(v138, "nth") + if reflect.TypeOf(tmp145).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp146 := lang.Apply(tmp145, []any{v140}) + var v147 any = tmp146 + _ = v147 + tmp148 := checkDerefVar(glojure_DOT_core_printf) + tmp149 := checkDerefVar(glojure_DOT_core_key) + tmp150 := lang.Apply(tmp149, []any{v147}) + tmp151 := checkDerefVar(glojure_DOT_core_print_str) + tmp152 := checkDerefVar(glojure_DOT_core_val) + tmp153 := lang.Apply(tmp152, []any{v147}) + tmp154 := lang.Apply(tmp151, []any{tmp153}) + tmp155 := lang.Apply(tmp148, []any{" %s '%s", tmp150, tmp154}) + _ = tmp155 + var tmp156 any = v137 + var tmp157 any = v138 + var tmp158 any = v139 + tmp160 := checkDerefVar(glojure_DOT_core_unchecked_inc) + tmp161 := lang.Apply(tmp160, []any{v140}) + var tmp159 any = tmp161 + v137 = tmp156 + v138 = tmp157 + v139 = tmp158 + v140 = tmp159 + continue + } // end let + tmp141 = tmp144 + } else { + var tmp145 any + { // let + // let binding "temp__0__auto__" + tmp146 := checkDerefVar(glojure_DOT_core_seq) + tmp147 := lang.Apply(tmp146, []any{v137}) + var v148 any = tmp147 + _ = v148 + var tmp149 any + if lang.IsTruthy(v148) { + var tmp150 any + { // let + // let binding "seq_111" + var v151 any = v148 + _ = v151 + var tmp152 any + tmp153 := checkDerefVar(glojure_DOT_core_chunked_seq_QMARK_) + tmp154 := lang.Apply(tmp153, []any{v151}) + if lang.IsTruthy(tmp154) { + var tmp155 any + { // let + // let binding "c__0__auto__" + tmp156 := checkDerefVar(glojure_DOT_core_chunk_first) + tmp157 := lang.Apply(tmp156, []any{v151}) + var v158 any = tmp157 + _ = v158 + tmp160 := checkDerefVar(glojure_DOT_core_chunk_rest) + tmp161 := lang.Apply(tmp160, []any{v151}) + var tmp159 any = tmp161 + var tmp162 any = v158 + tmp164 := checkDerefVar(glojure_DOT_core_int) + tmp165 := checkDerefVar(glojure_DOT_core_count) + tmp166 := lang.Apply(tmp165, []any{v158}) + tmp167 := lang.Apply(tmp164, []any{tmp166}) + var tmp163 any = tmp167 + tmp169 := checkDerefVar(glojure_DOT_core_int) + tmp170 := lang.Apply(tmp169, []any{int64(0)}) + var tmp168 any = tmp170 + v137 = tmp159 + v138 = tmp162 + v139 = tmp163 + v140 = tmp168 + continue + } // end let + tmp152 = tmp155 + } else { + var tmp156 any + { // let + // let binding "opt" + tmp157 := checkDerefVar(glojure_DOT_core_first) + tmp158 := lang.Apply(tmp157, []any{v151}) + var v159 any = tmp158 + _ = v159 + tmp160 := checkDerefVar(glojure_DOT_core_printf) + tmp161 := checkDerefVar(glojure_DOT_core_key) + tmp162 := lang.Apply(tmp161, []any{v159}) + tmp163 := checkDerefVar(glojure_DOT_core_print_str) + tmp164 := checkDerefVar(glojure_DOT_core_val) + tmp165 := lang.Apply(tmp164, []any{v159}) + tmp166 := lang.Apply(tmp163, []any{tmp165}) + tmp167 := lang.Apply(tmp160, []any{" %s '%s", tmp162, tmp166}) + _ = tmp167 + tmp169 := checkDerefVar(glojure_DOT_core_next) + tmp170 := lang.Apply(tmp169, []any{v151}) + var tmp168 any = tmp170 + var tmp171 any = nil + var tmp172 any = int64(0) + var tmp173 any = int64(0) + v137 = tmp168 + v138 = tmp171 + v139 = tmp172 + v140 = tmp173 + continue + } // end let + tmp152 = tmp156 + } + tmp150 = tmp152 + } // end let + tmp149 = tmp150 + } else { + } + tmp145 = tmp149 + } // end let + tmp141 = tmp145 + } + tmp134 = tmp141 + break + } + } // end let + _ = tmp134 + tmp135 := checkDerefVar(glojure_DOT_core_printf) + tmp136 := lang.Apply(tmp135, []any{")\n"}) + tmp130 = tmp136 + } else { + } + _ = tmp130 + tmp137 := checkDerefVar(glojure_DOT_core_apply) + tmp138 := checkDerefVar(glojure_DOT_core_refer) + tmp139 := checkDerefVar(glojure_DOT_core_mapcat) + tmp140 := checkDerefVar(glojure_DOT_core_seq) + tmp141 := lang.Apply(tmp139, []any{tmp140, v85}) + tmp142 := lang.Apply(tmp137, []any{tmp138, v17, tmp141}) + tmp128 = tmp142 + } else { + } + tmp98 = tmp128 + }() + tmp91 = tmp98 + } // end let + tmp11 = tmp91 + } // end let + return tmp11 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // load-libs + { + tmp0 := lang.NewSymbol("load-libs").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Loads libs, interpreting libspecs, prefix lists, and flags for\n forwarding to load-lib", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5951), lang.NewKeyword("end-line"), int(5951), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v3 any = lang.NewList(args[0:]...) + _ = v3 + var tmp4 any + { // let + // let binding "flags" + tmp5 := checkDerefVar(glojure_DOT_core_filter) + tmp6 := checkDerefVar(glojure_DOT_core_keyword_QMARK_) + tmp7 := lang.Apply(tmp5, []any{tmp6, v3}) + var v8 any = tmp7 + _ = v8 + // let binding "opts" + tmp9 := checkDerefVar(glojure_DOT_core_interleave) + tmp10 := checkDerefVar(glojure_DOT_core_repeat) + tmp11 := lang.Apply(tmp10, []any{true}) + tmp12 := lang.Apply(tmp9, []any{v8, tmp11}) + var v13 any = tmp12 + _ = v13 + // let binding "args" + tmp14 := checkDerefVar(glojure_DOT_core_filter) + tmp15 := checkDerefVar(glojure_DOT_core_complement) + tmp16 := checkDerefVar(glojure_DOT_core_keyword_QMARK_) + tmp17 := lang.Apply(tmp15, []any{tmp16}) + tmp18 := lang.Apply(tmp14, []any{tmp17, v3}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + { // let + // let binding "supported" + tmp21 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{lang.NewKeyword("as"), lang.NewKeyword("reload"), lang.NewKeyword("reload-all"), lang.NewKeyword("require"), lang.NewKeyword("use"), lang.NewKeyword("verbose"), lang.NewKeyword("refer"), lang.NewKeyword("as-alias")})) + tmp22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5959), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(5959), lang.NewKeyword("end-column"), int(86)) + tmp23, err := lang.WithMeta(tmp21, tmp22.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v24 any = tmp23 + _ = v24 + // let binding "unsupported" + tmp25 := checkDerefVar(glojure_DOT_core_seq) + tmp26 := checkDerefVar(glojure_DOT_core_remove) + tmp27 := lang.Apply(tmp26, []any{v24, v8}) + tmp28 := lang.Apply(tmp25, []any{tmp27}) + var v29 any = tmp28 + _ = v29 + tmp30 := checkDerefVar(glojure_DOT_core_throw_if) + tmp31 := checkDerefVar(glojure_DOT_core_apply) + tmp32 := checkDerefVar(glojure_DOT_core_str) + tmp33 := checkDerefVar(glojure_DOT_core_interpose) + tmp34 := lang.Apply(tmp33, []any{lang.NewChar(44), v29}) + tmp35 := lang.Apply(tmp31, []any{tmp32, "Unsupported option(s) supplied: ", tmp34}) + tmp36 := lang.Apply(tmp30, []any{v29, tmp35}) + tmp20 = tmp36 + } // end let + _ = tmp20 + tmp21 := checkDerefVar(glojure_DOT_core_throw_if) + tmp22 := checkDerefVar(glojure_DOT_core_not) + tmp23 := checkDerefVar(glojure_DOT_core_seq) + tmp24 := lang.Apply(tmp23, []any{v19}) + tmp25 := lang.Apply(tmp22, []any{tmp24}) + tmp26 := lang.Apply(tmp21, []any{tmp25, "Nothing specified to load"}) + _ = tmp26 + var tmp27 any + { // let + // let binding "seq_115" + tmp28 := checkDerefVar(glojure_DOT_core_seq) + tmp29 := lang.Apply(tmp28, []any{v19}) + var v30 any = tmp29 + _ = v30 + // let binding "chunk_116" + var v31 any = nil + _ = v31 + // let binding "count_117" + var v32 any = int64(0) + _ = v32 + // let binding "i_118" + var v33 any = int64(0) + _ = v33 + for { + var tmp34 any + tmp35 := checkDerefVar(glojure_DOT_core__LT_) + tmp36 := lang.Apply(tmp35, []any{v33, v32}) + if lang.IsTruthy(tmp36) { + var tmp37 any + { // let + // let binding "arg" + tmp38, _ := lang.FieldOrMethod(v31, "nth") + if reflect.TypeOf(tmp38).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp39 := lang.Apply(tmp38, []any{v33}) + var v40 any = tmp39 + _ = v40 + var tmp41 any + tmp42 := checkDerefVar(glojure_DOT_core_libspec_QMARK_) + tmp43 := lang.Apply(tmp42, []any{v40}) + if lang.IsTruthy(tmp43) { + tmp44 := checkDerefVar(glojure_DOT_core_apply) + tmp45 := checkDerefVar(glojure_DOT_core_load_lib) + tmp46 := checkDerefVar(glojure_DOT_core_prependss) + tmp47 := lang.Apply(tmp46, []any{v40, v13}) + tmp48 := lang.Apply(tmp44, []any{tmp45, nil, tmp47}) + tmp41 = tmp48 + } else { + var tmp49 any + { // let + // let binding "vec__119" + var v50 any = v40 + _ = v50 + // let binding "seq__120" + tmp51 := checkDerefVar(glojure_DOT_core_seq) + tmp52 := lang.Apply(tmp51, []any{v50}) + var v53 any = tmp52 + _ = v53 + // let binding "first__121" + tmp54 := checkDerefVar(glojure_DOT_core_first) + tmp55 := lang.Apply(tmp54, []any{v53}) + var v56 any = tmp55 + _ = v56 + // let binding "seq__120" + tmp57 := checkDerefVar(glojure_DOT_core_next) + tmp58 := lang.Apply(tmp57, []any{v53}) + var v59 any = tmp58 + _ = v59 + // let binding "prefix" + var v60 any = v56 + _ = v60 + // let binding "args" + var v61 any = v59 + _ = v61 + tmp62 := checkDerefVar(glojure_DOT_core_throw_if) + tmp63 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp64 := lang.Apply(tmp63, []any{v60}) + tmp65 := lang.Apply(tmp62, []any{tmp64, "prefix cannot be nil"}) + _ = tmp65 + var tmp66 any + { // let + // let binding "seq_122" + tmp67 := checkDerefVar(glojure_DOT_core_seq) + tmp68 := lang.Apply(tmp67, []any{v61}) + var v69 any = tmp68 + _ = v69 + // let binding "chunk_123" + var v70 any = nil + _ = v70 + // let binding "count_124" + var v71 any = int64(0) + _ = v71 + // let binding "i_125" + var v72 any = int64(0) + _ = v72 + for { + var tmp73 any + tmp74 := checkDerefVar(glojure_DOT_core__LT_) + tmp75 := lang.Apply(tmp74, []any{v72, v71}) + if lang.IsTruthy(tmp75) { + var tmp76 any + { // let + // let binding "arg" + tmp77, _ := lang.FieldOrMethod(v70, "nth") + if reflect.TypeOf(tmp77).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp78 := lang.Apply(tmp77, []any{v72}) + var v79 any = tmp78 + _ = v79 + tmp80 := checkDerefVar(glojure_DOT_core_apply) + tmp81 := checkDerefVar(glojure_DOT_core_load_lib) + tmp82 := checkDerefVar(glojure_DOT_core_prependss) + tmp83 := lang.Apply(tmp82, []any{v79, v13}) + tmp84 := lang.Apply(tmp80, []any{tmp81, v60, tmp83}) + _ = tmp84 + var tmp85 any = v69 + var tmp86 any = v70 + var tmp87 any = v71 + tmp89 := checkDerefVar(glojure_DOT_core_unchecked_inc) + tmp90 := lang.Apply(tmp89, []any{v72}) + var tmp88 any = tmp90 + v69 = tmp85 + v70 = tmp86 + v71 = tmp87 + v72 = tmp88 + continue + } // end let + tmp73 = tmp76 + } else { + var tmp77 any + { // let + // let binding "temp__0__auto__" + tmp78 := checkDerefVar(glojure_DOT_core_seq) + tmp79 := lang.Apply(tmp78, []any{v69}) + var v80 any = tmp79 + _ = v80 + var tmp81 any + if lang.IsTruthy(v80) { + var tmp82 any + { // let + // let binding "seq_122" + var v83 any = v80 + _ = v83 + var tmp84 any + tmp85 := checkDerefVar(glojure_DOT_core_chunked_seq_QMARK_) + tmp86 := lang.Apply(tmp85, []any{v83}) + if lang.IsTruthy(tmp86) { + var tmp87 any + { // let + // let binding "c__0__auto__" + tmp88 := checkDerefVar(glojure_DOT_core_chunk_first) + tmp89 := lang.Apply(tmp88, []any{v83}) + var v90 any = tmp89 + _ = v90 + tmp92 := checkDerefVar(glojure_DOT_core_chunk_rest) + tmp93 := lang.Apply(tmp92, []any{v83}) + var tmp91 any = tmp93 + var tmp94 any = v90 + tmp96 := checkDerefVar(glojure_DOT_core_int) + tmp97 := checkDerefVar(glojure_DOT_core_count) + tmp98 := lang.Apply(tmp97, []any{v90}) + tmp99 := lang.Apply(tmp96, []any{tmp98}) + var tmp95 any = tmp99 + tmp101 := checkDerefVar(glojure_DOT_core_int) + tmp102 := lang.Apply(tmp101, []any{int64(0)}) + var tmp100 any = tmp102 + v69 = tmp91 + v70 = tmp94 + v71 = tmp95 + v72 = tmp100 + continue + } // end let + tmp84 = tmp87 + } else { + var tmp88 any + { // let + // let binding "arg" + tmp89 := checkDerefVar(glojure_DOT_core_first) + tmp90 := lang.Apply(tmp89, []any{v83}) + var v91 any = tmp90 + _ = v91 + tmp92 := checkDerefVar(glojure_DOT_core_apply) + tmp93 := checkDerefVar(glojure_DOT_core_load_lib) + tmp94 := checkDerefVar(glojure_DOT_core_prependss) + tmp95 := lang.Apply(tmp94, []any{v91, v13}) + tmp96 := lang.Apply(tmp92, []any{tmp93, v60, tmp95}) + _ = tmp96 + tmp98 := checkDerefVar(glojure_DOT_core_next) + tmp99 := lang.Apply(tmp98, []any{v83}) + var tmp97 any = tmp99 + var tmp100 any = nil + var tmp101 any = int64(0) + var tmp102 any = int64(0) + v69 = tmp97 + v70 = tmp100 + v71 = tmp101 + v72 = tmp102 + continue + } // end let + tmp84 = tmp88 + } + tmp82 = tmp84 + } // end let + tmp81 = tmp82 + } else { + } + tmp77 = tmp81 + } // end let + tmp73 = tmp77 + } + tmp66 = tmp73 + break + } + } // end let + tmp49 = tmp66 + } // end let + tmp41 = tmp49 + } + _ = tmp41 + var tmp50 any = v30 + var tmp51 any = v31 + var tmp52 any = v32 + tmp54 := checkDerefVar(glojure_DOT_core_unchecked_inc) + tmp55 := lang.Apply(tmp54, []any{v33}) + var tmp53 any = tmp55 + v30 = tmp50 + v31 = tmp51 + v32 = tmp52 + v33 = tmp53 + continue + } // end let + tmp34 = tmp37 + } else { + var tmp38 any + { // let + // let binding "temp__0__auto__" + tmp39 := checkDerefVar(glojure_DOT_core_seq) + tmp40 := lang.Apply(tmp39, []any{v30}) + var v41 any = tmp40 + _ = v41 + var tmp42 any + if lang.IsTruthy(v41) { + var tmp43 any + { // let + // let binding "seq_115" + var v44 any = v41 + _ = v44 + var tmp45 any + tmp46 := checkDerefVar(glojure_DOT_core_chunked_seq_QMARK_) + tmp47 := lang.Apply(tmp46, []any{v44}) + if lang.IsTruthy(tmp47) { + var tmp48 any + { // let + // let binding "c__0__auto__" + tmp49 := checkDerefVar(glojure_DOT_core_chunk_first) + tmp50 := lang.Apply(tmp49, []any{v44}) + var v51 any = tmp50 + _ = v51 + tmp53 := checkDerefVar(glojure_DOT_core_chunk_rest) + tmp54 := lang.Apply(tmp53, []any{v44}) + var tmp52 any = tmp54 + var tmp55 any = v51 + tmp57 := checkDerefVar(glojure_DOT_core_int) + tmp58 := checkDerefVar(glojure_DOT_core_count) + tmp59 := lang.Apply(tmp58, []any{v51}) + tmp60 := lang.Apply(tmp57, []any{tmp59}) + var tmp56 any = tmp60 + tmp62 := checkDerefVar(glojure_DOT_core_int) + tmp63 := lang.Apply(tmp62, []any{int64(0)}) + var tmp61 any = tmp63 + v30 = tmp52 + v31 = tmp55 + v32 = tmp56 + v33 = tmp61 + continue + } // end let + tmp45 = tmp48 + } else { + var tmp49 any + { // let + // let binding "arg" + tmp50 := checkDerefVar(glojure_DOT_core_first) + tmp51 := lang.Apply(tmp50, []any{v44}) + var v52 any = tmp51 + _ = v52 + var tmp53 any + tmp54 := checkDerefVar(glojure_DOT_core_libspec_QMARK_) + tmp55 := lang.Apply(tmp54, []any{v52}) + if lang.IsTruthy(tmp55) { + tmp56 := checkDerefVar(glojure_DOT_core_apply) + tmp57 := checkDerefVar(glojure_DOT_core_load_lib) + tmp58 := checkDerefVar(glojure_DOT_core_prependss) + tmp59 := lang.Apply(tmp58, []any{v52, v13}) + tmp60 := lang.Apply(tmp56, []any{tmp57, nil, tmp59}) + tmp53 = tmp60 + } else { + var tmp61 any + { // let + // let binding "vec__126" + var v62 any = v52 + _ = v62 + // let binding "seq__127" + tmp63 := checkDerefVar(glojure_DOT_core_seq) + tmp64 := lang.Apply(tmp63, []any{v62}) + var v65 any = tmp64 + _ = v65 + // let binding "first__128" + tmp66 := checkDerefVar(glojure_DOT_core_first) + tmp67 := lang.Apply(tmp66, []any{v65}) + var v68 any = tmp67 + _ = v68 + // let binding "seq__127" + tmp69 := checkDerefVar(glojure_DOT_core_next) + tmp70 := lang.Apply(tmp69, []any{v65}) + var v71 any = tmp70 + _ = v71 + // let binding "prefix" + var v72 any = v68 + _ = v72 + // let binding "args" + var v73 any = v71 + _ = v73 + tmp74 := checkDerefVar(glojure_DOT_core_throw_if) + tmp75 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp76 := lang.Apply(tmp75, []any{v72}) + tmp77 := lang.Apply(tmp74, []any{tmp76, "prefix cannot be nil"}) + _ = tmp77 + var tmp78 any + { // let + // let binding "seq_129" + tmp79 := checkDerefVar(glojure_DOT_core_seq) + tmp80 := lang.Apply(tmp79, []any{v73}) + var v81 any = tmp80 + _ = v81 + // let binding "chunk_130" + var v82 any = nil + _ = v82 + // let binding "count_131" + var v83 any = int64(0) + _ = v83 + // let binding "i_132" + var v84 any = int64(0) + _ = v84 + for { + var tmp85 any + tmp86 := checkDerefVar(glojure_DOT_core__LT_) + tmp87 := lang.Apply(tmp86, []any{v84, v83}) + if lang.IsTruthy(tmp87) { + var tmp88 any + { // let + // let binding "arg" + tmp89, _ := lang.FieldOrMethod(v82, "nth") + if reflect.TypeOf(tmp89).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp90 := lang.Apply(tmp89, []any{v84}) + var v91 any = tmp90 + _ = v91 + tmp92 := checkDerefVar(glojure_DOT_core_apply) + tmp93 := checkDerefVar(glojure_DOT_core_load_lib) + tmp94 := checkDerefVar(glojure_DOT_core_prependss) + tmp95 := lang.Apply(tmp94, []any{v91, v13}) + tmp96 := lang.Apply(tmp92, []any{tmp93, v72, tmp95}) + _ = tmp96 + var tmp97 any = v81 + var tmp98 any = v82 + var tmp99 any = v83 + tmp101 := checkDerefVar(glojure_DOT_core_unchecked_inc) + tmp102 := lang.Apply(tmp101, []any{v84}) + var tmp100 any = tmp102 + v81 = tmp97 + v82 = tmp98 + v83 = tmp99 + v84 = tmp100 + continue + } // end let + tmp85 = tmp88 + } else { + var tmp89 any + { // let + // let binding "temp__0__auto__" + tmp90 := checkDerefVar(glojure_DOT_core_seq) + tmp91 := lang.Apply(tmp90, []any{v81}) + var v92 any = tmp91 + _ = v92 + var tmp93 any + if lang.IsTruthy(v92) { + var tmp94 any + { // let + // let binding "seq_129" + var v95 any = v92 + _ = v95 + var tmp96 any + tmp97 := checkDerefVar(glojure_DOT_core_chunked_seq_QMARK_) + tmp98 := lang.Apply(tmp97, []any{v95}) + if lang.IsTruthy(tmp98) { + var tmp99 any + { // let + // let binding "c__0__auto__" + tmp100 := checkDerefVar(glojure_DOT_core_chunk_first) + tmp101 := lang.Apply(tmp100, []any{v95}) + var v102 any = tmp101 + _ = v102 + tmp104 := checkDerefVar(glojure_DOT_core_chunk_rest) + tmp105 := lang.Apply(tmp104, []any{v95}) + var tmp103 any = tmp105 + var tmp106 any = v102 + tmp108 := checkDerefVar(glojure_DOT_core_int) + tmp109 := checkDerefVar(glojure_DOT_core_count) + tmp110 := lang.Apply(tmp109, []any{v102}) + tmp111 := lang.Apply(tmp108, []any{tmp110}) + var tmp107 any = tmp111 + tmp113 := checkDerefVar(glojure_DOT_core_int) + tmp114 := lang.Apply(tmp113, []any{int64(0)}) + var tmp112 any = tmp114 + v81 = tmp103 + v82 = tmp106 + v83 = tmp107 + v84 = tmp112 + continue + } // end let + tmp96 = tmp99 + } else { + var tmp100 any + { // let + // let binding "arg" + tmp101 := checkDerefVar(glojure_DOT_core_first) + tmp102 := lang.Apply(tmp101, []any{v95}) + var v103 any = tmp102 + _ = v103 + tmp104 := checkDerefVar(glojure_DOT_core_apply) + tmp105 := checkDerefVar(glojure_DOT_core_load_lib) + tmp106 := checkDerefVar(glojure_DOT_core_prependss) + tmp107 := lang.Apply(tmp106, []any{v103, v13}) + tmp108 := lang.Apply(tmp104, []any{tmp105, v72, tmp107}) + _ = tmp108 + tmp110 := checkDerefVar(glojure_DOT_core_next) + tmp111 := lang.Apply(tmp110, []any{v95}) + var tmp109 any = tmp111 + var tmp112 any = nil + var tmp113 any = int64(0) + var tmp114 any = int64(0) + v81 = tmp109 + v82 = tmp112 + v83 = tmp113 + v84 = tmp114 + continue + } // end let + tmp96 = tmp100 + } + tmp94 = tmp96 + } // end let + tmp93 = tmp94 + } else { + } + tmp89 = tmp93 + } // end let + tmp85 = tmp89 + } + tmp78 = tmp85 + break + } + } // end let + tmp61 = tmp78 + } // end let + tmp53 = tmp61 + } + _ = tmp53 + tmp63 := checkDerefVar(glojure_DOT_core_next) + tmp64 := lang.Apply(tmp63, []any{v44}) + var tmp62 any = tmp64 + var tmp65 any = nil + var tmp66 any = int64(0) + var tmp67 any = int64(0) + v30 = tmp62 + v31 = tmp65 + v32 = tmp66 + v33 = tmp67 + continue + } // end let + tmp45 = tmp49 + } + tmp43 = tmp45 + } // end let + tmp42 = tmp43 + } else { + } + tmp38 = tmp42 + } // end let + tmp34 = tmp38 + } + tmp27 = tmp34 + break + } + } // end let + tmp4 = tmp27 + } // end let + return tmp4 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // load-one + { + tmp0 := lang.NewSymbol("load-one").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"), lang.NewSymbol("need-ns"), lang.NewSymbol("require"))), lang.NewKeyword("doc"), "Loads a lib given its name. If need-ns, ensures that the associated\n namespace exists after loading. If require, records the load so any\n duplicate loads can be skipped.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5879), lang.NewKeyword("end-line"), int(5879), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6 := checkDerefVar(glojure_DOT_core_load) + tmp7 := checkDerefVar(glojure_DOT_core_root_resource) + tmp8 := lang.Apply(tmp7, []any{v3}) + tmp9 := lang.Apply(tmp6, []any{tmp8}) + _ = tmp9 + tmp10 := checkDerefVar(glojure_DOT_core_throw_if) + var tmp11 any + { // let + // let binding "and__0__auto__" + var v12 any = v4 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + tmp14 := checkDerefVar(glojure_DOT_core_not) + tmp15 := checkDerefVar(glojure_DOT_core_find_ns) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp14, []any{tmp16}) + tmp13 = tmp17 + } else { + tmp13 = v12 + } + tmp11 = tmp13 + } // end let + tmp12 := checkDerefVar(glojure_DOT_core_root_resource) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(tmp10, []any{tmp11, "namespace '%s' not found after loading '%s'", v3, tmp13}) + _ = tmp14 + var tmp15 any + if lang.IsTruthy(v5) { + var tmp16 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + tmp17 := checkDerefVar(glojure_DOT_core_commute) + tmp18 := checkDerefVar(glojure_DOT_core__STAR_loaded_libs_STAR_) + tmp19 := checkDerefVar(glojure_DOT_core_conj) + tmp20 := lang.Apply(tmp17, []any{tmp18, tmp19, v3}) + return tmp20 + }) + tmp17, _ := lang.FieldOrMethod(lang.LockingTransaction, "RunInTransaction") + if reflect.TypeOf(tmp17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("RunInTransaction is not a function"))) + } + tmp18 := lang.Apply(tmp17, []any{tmp16}) + tmp15 = tmp18 + } else { + } + return tmp15 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // load-reader + { + tmp0 := lang.NewSymbol("load-reader").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rdr"))), lang.NewKeyword("doc"), "Sequentially read and evaluate the set of forms contained in the\n stream/file", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4081), lang.NewKeyword("end-line"), int(4081))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(runtime7.Compiler, "load") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("load is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // load-string + { + tmp0 := lang.NewSymbol("load-string").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Sequentially read and evaluate the set of forms contained in the\n string", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4088), lang.NewKeyword("end-line"), int(4088))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + { // let + // let binding "rdr" + tmp5 := lang.Apply(nil, []any{v3}) + tmp6 := lang.Apply(nil, []any{tmp5}) + var v7 any = tmp6 + _ = v7 + tmp8 := checkDerefVar(glojure_DOT_core_load_reader) + tmp9 := lang.Apply(tmp8, []any{v7}) + tmp4 = tmp9 + } // end let + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // loaded-libs + { + tmp0 := lang.NewSymbol("loaded-libs").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Returns a sorted set of symbols naming the currently loaded libs", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6090), lang.NewKeyword("end-line"), int(6090))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + tmp3 := checkDerefVar(glojure_DOT_core_deref) + tmp4 := checkDerefVar(glojure_DOT_core__STAR_loaded_libs_STAR_) + tmp5 := lang.Apply(tmp3, []any{tmp4}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // locking + { + tmp0 := lang.NewSymbol("locking").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Executes exprs in an implicit do, while holding the monitor of x.\n Will release the monitor of x in all circumstances.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1643), lang.NewKeyword("end-line"), int(1643))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_seq) + tmp8 := checkDerefVar(glojure_DOT_core_concat) + tmp9 := checkDerefVar(glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("glojure.core/let")}) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := checkDerefVar(glojure_DOT_core_apply) + tmp13 := checkDerefVar(glojure_DOT_core_vector) + tmp14 := checkDerefVar(glojure_DOT_core_seq) + tmp15 := checkDerefVar(glojure_DOT_core_concat) + tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("lockee__0__auto__")}) + tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v5}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp12, []any{tmp13, tmp21}) + tmp23 := lang.Apply(tmp11, []any{tmp22}) + tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp25 := checkDerefVar(glojure_DOT_core_seq) + tmp26 := checkDerefVar(glojure_DOT_core_concat) + tmp27 := checkDerefVar(glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{lang.NewSymbol("try")}) + tmp29 := checkDerefVar(glojure_DOT_core_list) + tmp30 := checkDerefVar(glojure_DOT_core_seq) + tmp31 := checkDerefVar(glojure_DOT_core_concat) + tmp32 := checkDerefVar(glojure_DOT_core_list) + tmp33 := lang.Apply(tmp32, []any{lang.NewSymbol("glojure.core/let")}) + tmp34 := checkDerefVar(glojure_DOT_core_list) + tmp35 := checkDerefVar(glojure_DOT_core_apply) + tmp36 := checkDerefVar(glojure_DOT_core_vector) + tmp37 := checkDerefVar(glojure_DOT_core_seq) + tmp38 := checkDerefVar(glojure_DOT_core_concat) + tmp39 := checkDerefVar(glojure_DOT_core_list) + tmp40 := lang.Apply(tmp39, []any{lang.NewSymbol("locklocal__1__auto__")}) + tmp41 := checkDerefVar(glojure_DOT_core_list) + tmp42 := lang.Apply(tmp41, []any{lang.NewSymbol("lockee__0__auto__")}) + tmp43 := lang.Apply(tmp38, []any{tmp40, tmp42}) + tmp44 := lang.Apply(tmp37, []any{tmp43}) + tmp45 := lang.Apply(tmp35, []any{tmp36, tmp44}) + tmp46 := lang.Apply(tmp34, []any{tmp45}) + tmp47 := checkDerefVar(glojure_DOT_core_list) + tmp48 := checkDerefVar(glojure_DOT_core_seq) + tmp49 := checkDerefVar(glojure_DOT_core_concat) + tmp50 := checkDerefVar(glojure_DOT_core_list) + tmp51 := lang.Apply(tmp50, []any{lang.NewSymbol("monitor-enter")}) + tmp52 := checkDerefVar(glojure_DOT_core_list) + tmp53 := lang.Apply(tmp52, []any{lang.NewSymbol("locklocal__1__auto__")}) + tmp54 := lang.Apply(tmp49, []any{tmp51, tmp53}) + tmp55 := lang.Apply(tmp48, []any{tmp54}) + tmp56 := lang.Apply(tmp47, []any{tmp55}) + tmp57 := checkDerefVar(glojure_DOT_core_list) + tmp58 := checkDerefVar(glojure_DOT_core_seq) + tmp59 := checkDerefVar(glojure_DOT_core_concat) + tmp60 := checkDerefVar(glojure_DOT_core_list) + tmp61 := lang.Apply(tmp60, []any{lang.NewSymbol("try")}) + tmp62 := checkDerefVar(glojure_DOT_core_list) + tmp63 := checkDerefVar(glojure_DOT_core_seq) + tmp64 := checkDerefVar(glojure_DOT_core_concat) + tmp65 := checkDerefVar(glojure_DOT_core_list) + tmp66 := lang.Apply(tmp65, []any{lang.NewSymbol("finally")}) + tmp67 := checkDerefVar(glojure_DOT_core_list) + tmp68 := checkDerefVar(glojure_DOT_core_seq) + tmp69 := checkDerefVar(glojure_DOT_core_concat) + tmp70 := checkDerefVar(glojure_DOT_core_list) + tmp71 := lang.Apply(tmp70, []any{lang.NewSymbol("monitor-exit")}) + tmp72 := checkDerefVar(glojure_DOT_core_list) + tmp73 := lang.Apply(tmp72, []any{lang.NewSymbol("locklocal__1__auto__")}) + tmp74 := lang.Apply(tmp69, []any{tmp71, tmp73}) + tmp75 := lang.Apply(tmp68, []any{tmp74}) + tmp76 := lang.Apply(tmp67, []any{tmp75}) + tmp77 := lang.Apply(tmp64, []any{tmp66, tmp76}) + tmp78 := lang.Apply(tmp63, []any{tmp77}) + tmp79 := lang.Apply(tmp62, []any{tmp78}) + tmp80 := lang.Apply(tmp59, []any{tmp61, v6, tmp79}) + tmp81 := lang.Apply(tmp58, []any{tmp80}) + tmp82 := lang.Apply(tmp57, []any{tmp81}) + tmp83 := lang.Apply(tmp31, []any{tmp33, tmp46, tmp56, tmp82}) + tmp84 := lang.Apply(tmp30, []any{tmp83}) + tmp85 := lang.Apply(tmp29, []any{tmp84}) + tmp86 := lang.Apply(tmp26, []any{tmp28, tmp85}) + tmp87 := lang.Apply(tmp25, []any{tmp86}) + tmp88 := lang.Apply(tmp24, []any{tmp87}) + tmp89 := lang.Apply(tmp8, []any{tmp10, tmp23, tmp88}) + tmp90 := lang.Apply(tmp7, []any{tmp89}) + return tmp90 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // long + { + var tmp1 lang.FnFunc + { // function long__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := checkDerefVar(glojure_DOT_core_seq) + tmp12 := checkDerefVar(glojure_DOT_core_concat) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/LongCast")}) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("long").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to long", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3481), lang.NewKeyword("end-line"), int(3481))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5 := lang.Apply(lang.LongCast, []any{v4}) + return tmp5 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // long-array + { + var tmp1 lang.FnFunc + { // function long-array__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol("glojure.core/LongArray")}) + tmp12 := checkDerefVar(glojure_DOT_core_list) + tmp13 := checkDerefVar(glojure_DOT_core_seq) + tmp14 := checkDerefVar(glojure_DOT_core_concat) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("glojure.core/args")}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + } + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("long-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Creates an array of longs", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5364), lang.NewKeyword("end-line"), int(5364))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "LongArray") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("LongArray is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "LongArrayInit") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("LongArrayInit is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // longs + { + var tmp1 lang.FnFunc + { // function longs + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol("glojure.core/Longs")}) + tmp12 := checkDerefVar(glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("longs").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Casts to long[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5407), lang.NewKeyword("end-line"), int(5407))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Longs") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Longs is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // loop + { + tmp0 := lang.NewSymbol("loop").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Evaluates the exprs in a lexical context in which the symbols in\n the binding-forms are bound to their respective init-exprs or parts\n therein. Acts as a recur target.", lang.NewKeyword("forms"), lang.NewVector(lang.NewList(lang.NewSymbol("loop"), lang.NewVector(lang.NewSymbol("bindings*")), lang.NewSymbol("exprs*"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4597), lang.NewKeyword("end-line"), int(4597), lang.NewKeyword("special-form"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any + tmp8 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp9 := lang.Apply(tmp8, []any{v5}) + if lang.IsTruthy(tmp9) { + } else { + tmp10 := checkDerefVar(glojure_DOT_core_str) + tmp11 := checkDerefVar(glojure_DOT_core_first) + tmp12 := lang.Apply(tmp11, []any{v3}) + tmp13 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) + tmp14 := checkDerefVar(glojure_DOT_core_meta) + tmp15 := lang.Apply(tmp14, []any{v3}) + tmp16 := lang.Apply(lang.NewKeyword("line"), []any{tmp15}) + tmp17 := lang.Apply(tmp10, []any{tmp12, " requires ", "a vector for its binding", " in ", tmp13, ":", tmp16}) + tmp18 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp17}) + panic(tmp18) + } + _ = tmp7 + var tmp19 any + tmp20 := checkDerefVar(glojure_DOT_core_even_QMARK_) + tmp21 := checkDerefVar(glojure_DOT_core_count) + tmp22 := lang.Apply(tmp21, []any{v5}) + tmp23 := lang.Apply(tmp20, []any{tmp22}) + if lang.IsTruthy(tmp23) { + } else { + tmp24 := checkDerefVar(glojure_DOT_core_str) + tmp25 := checkDerefVar(glojure_DOT_core_first) + tmp26 := lang.Apply(tmp25, []any{v3}) + tmp27 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) + tmp28 := checkDerefVar(glojure_DOT_core_meta) + tmp29 := lang.Apply(tmp28, []any{v3}) + tmp30 := lang.Apply(lang.NewKeyword("line"), []any{tmp29}) + tmp31 := lang.Apply(tmp24, []any{tmp26, " requires ", "an even number of forms in binding vector", " in ", tmp27, ":", tmp30}) + tmp32 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp31}) + panic(tmp32) + } + _ = tmp19 + var tmp33 any + { // let + // let binding "db" + tmp34 := checkDerefVar(glojure_DOT_core_destructure) + tmp35 := lang.Apply(tmp34, []any{v5}) + var v36 any = tmp35 + _ = v36 + var tmp37 any + tmp38 := checkDerefVar(glojure_DOT_core__EQ_) + tmp39 := lang.Apply(tmp38, []any{v36, v5}) + if lang.IsTruthy(tmp39) { + tmp40 := checkDerefVar(glojure_DOT_core_seq) + tmp41 := checkDerefVar(glojure_DOT_core_concat) + tmp42 := checkDerefVar(glojure_DOT_core_list) + tmp43 := lang.Apply(tmp42, []any{lang.NewSymbol("loop*")}) + tmp44 := checkDerefVar(glojure_DOT_core_list) + tmp45 := lang.Apply(tmp44, []any{v5}) + tmp46 := lang.Apply(tmp41, []any{tmp43, tmp45, v6}) + tmp47 := lang.Apply(tmp40, []any{tmp46}) + tmp37 = tmp47 + } else { + var tmp48 any + { // let + // let binding "vs" + tmp49 := checkDerefVar(glojure_DOT_core_take_nth) + tmp50 := checkDerefVar(glojure_DOT_core_drop) + tmp51 := lang.Apply(tmp50, []any{int64(1), v5}) + tmp52 := lang.Apply(tmp49, []any{int64(2), tmp51}) + var v53 any = tmp52 + _ = v53 + // let binding "bs" + tmp54 := checkDerefVar(glojure_DOT_core_take_nth) + tmp55 := lang.Apply(tmp54, []any{int64(2), v5}) + var v56 any = tmp55 + _ = v56 + // let binding "gs" + tmp57 := checkDerefVar(glojure_DOT_core_map) + var tmp58 lang.FnFunc + tmp58 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v59 := args[0] + _ = v59 + var tmp60 any + tmp61 := checkDerefVar(glojure_DOT_core_symbol_QMARK_) + tmp62 := lang.Apply(tmp61, []any{v59}) + if lang.IsTruthy(tmp62) { + tmp60 = v59 + } else { + tmp63 := checkDerefVar(glojure_DOT_core_gensym) + tmp64 := lang.Apply(tmp63, nil) + tmp60 = tmp64 + } + return tmp60 + }) + tmp59 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4611), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(4611), lang.NewKeyword("end-column"), int(58)) + tmp60, err := lang.WithMeta(tmp58, tmp59.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp61 := lang.Apply(tmp57, []any{tmp60, v56}) + var v62 any = tmp61 + _ = v62 + // let binding "bfs" + tmp63 := checkDerefVar(glojure_DOT_core_reduce1) + var tmp64 lang.FnFunc + tmp64 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v65 := args[0] + _ = v65 + v66 := args[1] + _ = v66 + var tmp67 any + { // let + // let binding "vec__17" + var v68 any = v66 + _ = v68 + // let binding "b" + tmp69 := checkDerefVar(glojure_DOT_core_nth) + tmp70 := lang.Apply(tmp69, []any{v68, int64(0), nil}) + var v71 any = tmp70 + _ = v71 + // let binding "v" + tmp72 := checkDerefVar(glojure_DOT_core_nth) + tmp73 := lang.Apply(tmp72, []any{v68, int64(1), nil}) + var v74 any = tmp73 + _ = v74 + // let binding "g" + tmp75 := checkDerefVar(glojure_DOT_core_nth) + tmp76 := lang.Apply(tmp75, []any{v68, int64(2), nil}) + var v77 any = tmp76 + _ = v77 + var tmp78 any + tmp79 := checkDerefVar(glojure_DOT_core_symbol_QMARK_) + tmp80 := lang.Apply(tmp79, []any{v71}) + if lang.IsTruthy(tmp80) { + tmp81 := checkDerefVar(glojure_DOT_core_conj) + tmp82 := lang.Apply(tmp81, []any{v65, v77, v74}) + tmp78 = tmp82 + } else { + tmp83 := checkDerefVar(glojure_DOT_core_conj) + tmp84 := lang.Apply(tmp83, []any{v65, v77, v74, v71, v77}) + tmp78 = tmp84 + } + tmp67 = tmp78 + } // end let + return tmp67 + }) + tmp65 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4612), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(4615), lang.NewKeyword("end-column"), int(50)) + tmp66, err := lang.WithMeta(tmp64, tmp65.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp67 := lang.NewVector() + tmp68 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4616), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(4616), lang.NewKeyword("end-column"), int(28)) + tmp69, err := lang.WithMeta(tmp67, tmp68.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp70 := checkDerefVar(glojure_DOT_core_map) + tmp71 := checkDerefVar(glojure_DOT_core_vector) + tmp72 := lang.Apply(tmp70, []any{tmp71, v56, v53, v62}) + tmp73 := lang.Apply(tmp63, []any{tmp66, tmp69, tmp72}) + var v74 any = tmp73 + _ = v74 + tmp75 := checkDerefVar(glojure_DOT_core_seq) + tmp76 := checkDerefVar(glojure_DOT_core_concat) + tmp77 := checkDerefVar(glojure_DOT_core_list) + tmp78 := lang.Apply(tmp77, []any{lang.NewSymbol("glojure.core/let")}) + tmp79 := checkDerefVar(glojure_DOT_core_list) + tmp80 := lang.Apply(tmp79, []any{v74}) + tmp81 := checkDerefVar(glojure_DOT_core_list) + tmp82 := checkDerefVar(glojure_DOT_core_seq) + tmp83 := checkDerefVar(glojure_DOT_core_concat) + tmp84 := checkDerefVar(glojure_DOT_core_list) + tmp85 := lang.Apply(tmp84, []any{lang.NewSymbol("loop*")}) + tmp86 := checkDerefVar(glojure_DOT_core_list) + tmp87 := checkDerefVar(glojure_DOT_core_vec) + tmp88 := checkDerefVar(glojure_DOT_core_interleave) + tmp89 := lang.Apply(tmp88, []any{v62, v62}) + tmp90 := lang.Apply(tmp87, []any{tmp89}) + tmp91 := lang.Apply(tmp86, []any{tmp90}) + tmp92 := checkDerefVar(glojure_DOT_core_list) + tmp93 := checkDerefVar(glojure_DOT_core_seq) + tmp94 := checkDerefVar(glojure_DOT_core_concat) + tmp95 := checkDerefVar(glojure_DOT_core_list) + tmp96 := lang.Apply(tmp95, []any{lang.NewSymbol("glojure.core/let")}) + tmp97 := checkDerefVar(glojure_DOT_core_list) + tmp98 := checkDerefVar(glojure_DOT_core_vec) + tmp99 := checkDerefVar(glojure_DOT_core_interleave) + tmp100 := lang.Apply(tmp99, []any{v56, v62}) + tmp101 := lang.Apply(tmp98, []any{tmp100}) + tmp102 := lang.Apply(tmp97, []any{tmp101}) + tmp103 := lang.Apply(tmp94, []any{tmp96, tmp102, v6}) + tmp104 := lang.Apply(tmp93, []any{tmp103}) + tmp105 := lang.Apply(tmp92, []any{tmp104}) + tmp106 := lang.Apply(tmp83, []any{tmp85, tmp91, tmp105}) + tmp107 := lang.Apply(tmp82, []any{tmp106}) + tmp108 := lang.Apply(tmp81, []any{tmp107}) + tmp109 := lang.Apply(tmp76, []any{tmp78, tmp80, tmp108}) + tmp110 := lang.Apply(tmp75, []any{tmp109}) + tmp48 = tmp110 + } // end let + tmp37 = tmp48 + } + tmp33 = tmp37 + } // end let + return tmp33 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // macroexpand + { + tmp0 := lang.NewSymbol("macroexpand").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("form"))), lang.NewKeyword("doc"), "Repeatedly calls macroexpand-1 on form until it no longer\n represents a macro form, then returns it. Note neither\n macroexpand-1 nor macroexpand expand macros in subforms.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4025), lang.NewKeyword("end-line"), int(4025))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + { // let + // let binding "ex" + tmp5 := checkDerefVar(glojure_DOT_core_macroexpand_1) + tmp6 := lang.Apply(tmp5, []any{v3}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + tmp9 := checkDerefVar(glojure_DOT_core_identical_QMARK_) + tmp10 := lang.Apply(tmp9, []any{v7, v3}) + if lang.IsTruthy(tmp10) { + tmp8 = v3 + } else { + tmp11 := checkDerefVar(glojure_DOT_core_macroexpand) + tmp12 := lang.Apply(tmp11, []any{v7}) + tmp8 = tmp12 + } + tmp4 = tmp8 + } // end let + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // macroexpand-1 + { + tmp0 := lang.NewSymbol("macroexpand-1").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("form"))), lang.NewKeyword("doc"), "If form represents a macro form, returns its expansion,\n else returns form.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4017), lang.NewKeyword("end-line"), int(4017))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(runtime7.Compiler, "macroexpand1") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("macroexpand1 is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // make-array + { + tmp0 := lang.NewSymbol("make-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("type"), lang.NewSymbol("len")), lang.NewVector(lang.NewSymbol("type"), lang.NewSymbol("dim"), lang.NewSymbol("&"), lang.NewSymbol("more-dims"))), lang.NewKeyword("doc"), "Creates and returns an array of instances of the specified class of\n the specified dimension(s). Note that a class object is required.\n Class objects can be obtained by using their imported or\n fully-qualified name. Class objects for the primitive types can be\n obtained using, e.g., Integer/TYPE.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3985), lang.NewKeyword("end-line"), int(3985))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_int) + tmp6 := lang.Apply(tmp5, []any{v4}) + tmp7, _ := lang.FieldOrMethod(nil, "newInstance") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("newInstance is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v3, tmp6}) + return tmp8 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + var tmp6 any + { // let + // let binding "dims" + tmp7 := checkDerefVar(glojure_DOT_core_cons) + tmp8 := lang.Apply(tmp7, []any{v4, v5}) + var v9 any = tmp8 + _ = v9 + // let binding "dimarray" + tmp10 := checkDerefVar(glojure_DOT_core_make_array) + tmp11, ok := lang.FieldOrMethod(nil, "TYPE") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "TYPE"))) + } + var tmp12 any + switch reflect.TypeOf(tmp11).Kind() { + case reflect.Func: + tmp12 = lang.Apply(tmp11, nil) + default: + tmp12 = tmp11 + } + tmp13 := checkDerefVar(glojure_DOT_core_count) + tmp14 := lang.Apply(tmp13, []any{v9}) + tmp15 := lang.Apply(tmp10, []any{tmp12, tmp14}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + { // let + // let binding "n__0__auto__" + tmp18 := checkDerefVar(glojure_DOT_core_long) + tmp19 := checkDerefVar(glojure_DOT_core_alength) + tmp20 := lang.Apply(tmp19, []any{v16}) + tmp21 := lang.Apply(tmp18, []any{tmp20}) + var v22 any = tmp21 + _ = v22 + var tmp23 any + { // let + // let binding "i" + var v24 any = int64(0) + _ = v24 + for { + var tmp25 any + tmp26 := checkDerefVar(glojure_DOT_core__LT_) + tmp27 := lang.Apply(tmp26, []any{v24, v22}) + if lang.IsTruthy(tmp27) { + tmp28 := checkDerefVar(glojure_DOT_core_aset_int) + tmp29 := checkDerefVar(glojure_DOT_core_nth) + tmp30 := lang.Apply(tmp29, []any{v9, v24}) + tmp31 := lang.Apply(tmp28, []any{v16, v24, tmp30}) + _ = tmp31 + tmp33 := checkDerefVar(glojure_DOT_core_unchecked_inc) + tmp34 := lang.Apply(tmp33, []any{v24}) + var tmp32 any = tmp34 + v24 = tmp32 + continue + } else { + } + tmp23 = tmp25 + break + } + } // end let + tmp17 = tmp23 + } // end let + _ = tmp17 + tmp18, _ := lang.FieldOrMethod(nil, "newInstance") + if reflect.TypeOf(tmp18).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("newInstance is not a function"))) + } + tmp19 := lang.Apply(tmp18, []any{v3, v16}) + tmp6 = tmp19 + } // end let + return tmp6 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // make-hierarchy + { + tmp0 := lang.NewSymbol("make-hierarchy").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Creates a hierarchy object for use with derive, isa? etc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5507), lang.NewKeyword("end-line"), int(5507))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + tmp3 := lang.NewMap() + tmp4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5511), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(5511), lang.NewKeyword("end-column"), int(17)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp6 := lang.NewMap() + tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5511), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(5511), lang.NewKeyword("end-column"), int(33)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp9 := lang.NewMap() + tmp10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5511), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(5511), lang.NewKeyword("end-column"), int(47)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp12 := lang.NewMap(lang.NewKeyword("parents"), tmp5, lang.NewKeyword("descendants"), tmp8, lang.NewKeyword("ancestors"), tmp11) + tmp13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5511), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(5511), lang.NewKeyword("end-column"), int(48)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp14 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // map + { + tmp0 := lang.NewSymbol("map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2"), lang.NewSymbol("c3")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2"), lang.NewSymbol("c3"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Returns a lazy sequence consisting of the result of applying f to\n the set of first items of each coll, followed by applying f to the\n set of second items in each coll, until any one of the colls is\n exhausted. Any remaining items in other colls are ignored. Function\n f should accept number-of-colls arguments. Returns a transducer when\n no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2719), lang.NewKeyword("end-line"), int(2719))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp7 := lang.Apply(v5, nil) + return tmp7 + case 1: + v7 := args[0] + _ = v7 + tmp8 := lang.Apply(v5, []any{v7}) + return tmp8 + case 2: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + tmp9 := lang.Apply(v3, []any{v8}) + tmp10 := lang.Apply(v5, []any{v7, tmp9}) + return tmp10 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + var v9 any = lang.NewList(args[2:]...) + _ = v9 + tmp10 := checkDerefVar(glojure_DOT_core_apply) + tmp11 := lang.Apply(tmp10, []any{v3, v8, v9}) + tmp12 := lang.Apply(v5, []any{v7, tmp11}) + return tmp12 + } + }) + tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2730), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(2736), lang.NewKeyword("end-column"), int(47)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp8 + }) + tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2729), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2736), lang.NewKeyword("end-column"), int(48)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var tmp6 any + { // let + // let binding "temp__0__auto__" + tmp7 := checkDerefVar(glojure_DOT_core_seq) + tmp8 := lang.Apply(tmp7, []any{v4}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + var tmp11 any + { // let + // let binding "s" + var v12 any = v9 + _ = v12 + var tmp13 any + tmp14 := checkDerefVar(glojure_DOT_core_chunked_seq_QMARK_) + tmp15 := lang.Apply(tmp14, []any{v12}) + if lang.IsTruthy(tmp15) { + var tmp16 any + { // let + // let binding "c" + tmp17 := checkDerefVar(glojure_DOT_core_chunk_first) + tmp18 := lang.Apply(tmp17, []any{v12}) + var v19 any = tmp18 + _ = v19 + // let binding "size" + tmp20 := checkDerefVar(glojure_DOT_core_int) + tmp21 := checkDerefVar(glojure_DOT_core_count) + tmp22 := lang.Apply(tmp21, []any{v19}) + tmp23 := lang.Apply(tmp20, []any{tmp22}) + var v24 any = tmp23 + _ = v24 + // let binding "b" + tmp25 := checkDerefVar(glojure_DOT_core_chunk_buffer) + tmp26 := lang.Apply(tmp25, []any{v24}) + var v27 any = tmp26 + _ = v27 + var tmp28 any + { // let + // let binding "n__0__auto__" + tmp29 := lang.Apply(lang.LongCast, []any{v24}) + var v30 any = tmp29 + _ = v30 + var tmp31 any + { // let + // let binding "i" + var v32 any = int64(0) + _ = v32 + for { + var tmp33 any + tmp34 := checkDerefVar(glojure_DOT_core__LT_) + tmp35 := lang.Apply(tmp34, []any{v32, v30}) + if lang.IsTruthy(tmp35) { + tmp36 := checkDerefVar(glojure_DOT_core_chunk_append) + tmp37, _ := lang.FieldOrMethod(v19, "nth") + if reflect.TypeOf(tmp37).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp38 := lang.Apply(tmp37, []any{v32}) + tmp39 := lang.Apply(v3, []any{tmp38}) + tmp40 := lang.Apply(tmp36, []any{v27, tmp39}) + _ = tmp40 + tmp42 := checkDerefVar(glojure_DOT_core_unchecked_inc) + tmp43 := lang.Apply(tmp42, []any{v32}) + var tmp41 any = tmp43 + v32 = tmp41 + continue + } else { + } + tmp31 = tmp33 + break + } + } // end let + tmp28 = tmp31 + } // end let + _ = tmp28 + tmp29 := checkDerefVar(glojure_DOT_core_chunk_cons) + tmp30 := checkDerefVar(glojure_DOT_core_chunk) + tmp31 := lang.Apply(tmp30, []any{v27}) + tmp32 := checkDerefVar(glojure_DOT_core_map) + tmp33 := checkDerefVar(glojure_DOT_core_chunk_rest) + tmp34 := lang.Apply(tmp33, []any{v12}) + tmp35 := lang.Apply(tmp32, []any{v3, tmp34}) + tmp36 := lang.Apply(tmp29, []any{tmp31, tmp35}) + tmp16 = tmp36 + } // end let + tmp13 = tmp16 + } else { + tmp17 := checkDerefVar(glojure_DOT_core_cons) + tmp18 := checkDerefVar(glojure_DOT_core_first) + tmp19 := lang.Apply(tmp18, []any{v12}) + tmp20 := lang.Apply(v3, []any{tmp19}) + tmp21 := checkDerefVar(glojure_DOT_core_map) + tmp22 := checkDerefVar(glojure_DOT_core_rest) + tmp23 := lang.Apply(tmp22, []any{v12}) + tmp24 := lang.Apply(tmp21, []any{v3, tmp23}) + tmp25 := lang.Apply(tmp17, []any{tmp20, tmp24}) + tmp13 = tmp25 + } + tmp11 = tmp13 + } // end let + tmp10 = tmp11 + } else { + } + tmp6 = tmp10 + } // end let + return tmp6 + }) + tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) + return tmp6 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var tmp7 any + { // let + // let binding "s1" + tmp8 := checkDerefVar(glojure_DOT_core_seq) + tmp9 := lang.Apply(tmp8, []any{v4}) + var v10 any = tmp9 + _ = v10 + // let binding "s2" + tmp11 := checkDerefVar(glojure_DOT_core_seq) + tmp12 := lang.Apply(tmp11, []any{v5}) + var v13 any = tmp12 + _ = v13 + var tmp14 any + var tmp15 any + { // let + // let binding "and__0__auto__" + var v16 any = v10 + _ = v16 + var tmp17 any + if lang.IsTruthy(v16) { + tmp17 = v13 + } else { + tmp17 = v16 + } + tmp15 = tmp17 + } // end let + if lang.IsTruthy(tmp15) { + tmp16 := checkDerefVar(glojure_DOT_core_cons) + tmp17 := checkDerefVar(glojure_DOT_core_first) + tmp18 := lang.Apply(tmp17, []any{v10}) + tmp19 := checkDerefVar(glojure_DOT_core_first) + tmp20 := lang.Apply(tmp19, []any{v13}) + tmp21 := lang.Apply(v3, []any{tmp18, tmp20}) + tmp22 := checkDerefVar(glojure_DOT_core_map) + tmp23 := checkDerefVar(glojure_DOT_core_rest) + tmp24 := lang.Apply(tmp23, []any{v10}) + tmp25 := checkDerefVar(glojure_DOT_core_rest) + tmp26 := lang.Apply(tmp25, []any{v13}) + tmp27 := lang.Apply(tmp22, []any{v3, tmp24, tmp26}) + tmp28 := lang.Apply(tmp16, []any{tmp21, tmp27}) + tmp14 = tmp28 + } else { + } + tmp7 = tmp14 + } // end let + return tmp7 + }) + tmp7 := lang.Apply(lang.NewLazySeq, []any{tmp6}) + return tmp7 + case 4: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var tmp8 any + { // let + // let binding "s1" + tmp9 := checkDerefVar(glojure_DOT_core_seq) + tmp10 := lang.Apply(tmp9, []any{v4}) + var v11 any = tmp10 + _ = v11 + // let binding "s2" + tmp12 := checkDerefVar(glojure_DOT_core_seq) + tmp13 := lang.Apply(tmp12, []any{v5}) + var v14 any = tmp13 + _ = v14 + // let binding "s3" + tmp15 := checkDerefVar(glojure_DOT_core_seq) + tmp16 := lang.Apply(tmp15, []any{v6}) + var v17 any = tmp16 + _ = v17 + var tmp18 any + var tmp19 any + { // let + // let binding "and__0__auto__" + var v20 any = v11 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + var tmp22 any + { // let + // let binding "and__0__auto__" + var v23 any = v14 + _ = v23 + var tmp24 any + if lang.IsTruthy(v23) { + tmp24 = v17 + } else { + tmp24 = v23 + } + tmp22 = tmp24 + } // end let + tmp21 = tmp22 + } else { + tmp21 = v20 + } + tmp19 = tmp21 + } // end let + if lang.IsTruthy(tmp19) { + tmp20 := checkDerefVar(glojure_DOT_core_cons) + tmp21 := checkDerefVar(glojure_DOT_core_first) + tmp22 := lang.Apply(tmp21, []any{v11}) + tmp23 := checkDerefVar(glojure_DOT_core_first) + tmp24 := lang.Apply(tmp23, []any{v14}) + tmp25 := checkDerefVar(glojure_DOT_core_first) + tmp26 := lang.Apply(tmp25, []any{v17}) + tmp27 := lang.Apply(v3, []any{tmp22, tmp24, tmp26}) + tmp28 := checkDerefVar(glojure_DOT_core_map) + tmp29 := checkDerefVar(glojure_DOT_core_rest) + tmp30 := lang.Apply(tmp29, []any{v11}) + tmp31 := checkDerefVar(glojure_DOT_core_rest) + tmp32 := lang.Apply(tmp31, []any{v14}) + tmp33 := checkDerefVar(glojure_DOT_core_rest) + tmp34 := lang.Apply(tmp33, []any{v17}) + tmp35 := lang.Apply(tmp28, []any{v3, tmp30, tmp32, tmp34}) + tmp36 := lang.Apply(tmp20, []any{tmp27, tmp35}) + tmp18 = tmp36 + } else { + } + tmp8 = tmp18 + } // end let + return tmp8 + }) + tmp8 := lang.Apply(lang.NewLazySeq, []any{tmp7}) + return tmp8 + default: + if len(args) < 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + var v7 any = lang.NewList(args[4:]...) + _ = v7 + var tmp8 any + { // let + // let binding "step" + var tmp9 lang.FnFunc + { // function step + var v10 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v11 := args[0] + _ = v11 + var tmp12 lang.FnFunc + tmp12 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var tmp13 any + { // let + // let binding "ss" + tmp14 := checkDerefVar(glojure_DOT_core_map) + tmp15 := checkDerefVar(glojure_DOT_core_seq) + tmp16 := lang.Apply(tmp14, []any{tmp15, v11}) + var v17 any = tmp16 + _ = v17 + var tmp18 any + tmp19 := checkDerefVar(glojure_DOT_core_every_QMARK_) + tmp20 := checkDerefVar(glojure_DOT_core_identity) + tmp21 := lang.Apply(tmp19, []any{tmp20, v17}) + if lang.IsTruthy(tmp21) { + tmp22 := checkDerefVar(glojure_DOT_core_cons) + tmp23 := checkDerefVar(glojure_DOT_core_map) + tmp24 := checkDerefVar(glojure_DOT_core_first) + tmp25 := lang.Apply(tmp23, []any{tmp24, v17}) + tmp26 := checkDerefVar(glojure_DOT_core_map) + tmp27 := checkDerefVar(glojure_DOT_core_rest) + tmp28 := lang.Apply(tmp26, []any{tmp27, v17}) + tmp29 := lang.Apply(v10, []any{tmp28}) + tmp30 := lang.Apply(tmp22, []any{tmp25, tmp29}) + tmp18 = tmp30 + } else { + } + tmp13 = tmp18 + } // end let + return tmp13 + }) + tmp13 := lang.Apply(lang.NewLazySeq, []any{tmp12}) + return tmp13 + }) + v10 = tmp9 + _ = v10 + } + tmp10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2761), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(2765), lang.NewKeyword("end-column"), int(68)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v12 any = tmp11 + _ = v12 + tmp13 := checkDerefVar(glojure_DOT_core_map) + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v15 := args[0] + _ = v15 + tmp16 := checkDerefVar(glojure_DOT_core_apply) + tmp17 := lang.Apply(tmp16, []any{v3, v15}) + return tmp17 + }) + tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2766), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(2766), lang.NewKeyword("end-column"), int(22)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp17 := checkDerefVar(glojure_DOT_core_conj) + tmp18 := lang.Apply(tmp17, []any{v7, v6, v5, v4}) + tmp19 := lang.Apply(v12, []any{tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp16, tmp19}) + tmp8 = tmp20 + } // end let + return tmp8 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // map-entry? + { + tmp0 := lang.NewSymbol("map-entry?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a map entry", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.8", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1473), lang.NewKeyword("end-line"), int(1473))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp5 := reflect.TypeOf((*lang.MapEntry)(nil)).Elem() + tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // map-indexed + { + tmp0 := lang.NewSymbol("map-indexed").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence consisting of the result of applying f to 0\n and the first item of coll, followed by applying f to 1 and the second\n item in coll, etc, until coll is exhausted. Thus function f should\n accept 2 arguments, index and item. Returns a stateful transducer when\n no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7309), lang.NewKeyword("end-line"), int(7309))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + var tmp6 any + { // let + // let binding "i" + tmp7 := checkDerefVar(glojure_DOT_core_volatile_BANG_) + tmp8 := lang.Apply(tmp7, []any{int64(-1)}) + var v9 any = tmp8 + _ = v9 + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp11 := lang.Apply(v5, nil) + return tmp11 + case 1: + v11 := args[0] + _ = v11 + tmp12 := lang.Apply(v5, []any{v11}) + return tmp12 + case 2: + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(glojure_DOT_core_inc) + tmp14, ok := lang.FieldOrMethod(v9, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v9, "Deref"))) + } + var tmp15 any + switch reflect.TypeOf(tmp14).Kind() { + case reflect.Func: + tmp15 = lang.Apply(tmp14, nil) + default: + tmp15 = tmp14 + } + tmp16 := lang.Apply(tmp13, []any{tmp15}) + tmp17, _ := lang.FieldOrMethod(v9, "reset") + if reflect.TypeOf(tmp17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) + } + tmp18 := lang.Apply(tmp17, []any{tmp16}) + tmp19 := lang.Apply(v3, []any{tmp18, v12}) + tmp20 := lang.Apply(v5, []any{v11, tmp19}) + return tmp20 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7320), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7324), lang.NewKeyword("end-column"), int(48)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp6 = tmp12 + } // end let + return tmp6 + }) + tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7318), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7324), lang.NewKeyword("end-column"), int(50)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + return nil + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // map? + { + tmp0 := lang.NewSymbol("map?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x implements IPersistentMap", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(167), lang.NewKeyword("end-line"), int(171))).(*lang.Symbol) + var tmp2 lang.FnFunc + { // function map? + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp6 := reflect.TypeOf((*lang.IPersistentMap)(nil)).Elem() + tmp7 := lang.Apply(tmp5, []any{tmp6, v4}) + return tmp7 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(171), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(171), lang.NewKeyword("end-column"), int(97))).(lang.FnFunc) + v3 = tmp2 + _ = v3 + } + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // mapcat + { + tmp0 := lang.NewSymbol("mapcat").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Returns the result of applying concat to the result of applying map\n to f and colls. Thus function f should return a collection. Returns\n a transducer when no collections are provided", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2775), lang.NewKeyword("end-line"), int(2775))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_comp) + tmp5 := checkDerefVar(glojure_DOT_core_map) + tmp6 := lang.Apply(tmp5, []any{v3}) + tmp7 := checkDerefVar(glojure_DOT_core_cat) + tmp8 := lang.Apply(tmp4, []any{tmp6, tmp7}) + return tmp8 + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any = lang.NewList(args[1:]...) + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_apply) + tmp6 := checkDerefVar(glojure_DOT_core_concat) + tmp7 := checkDerefVar(glojure_DOT_core_apply) + tmp8 := checkDerefVar(glojure_DOT_core_map) + tmp9 := lang.Apply(tmp7, []any{tmp8, v3, v4}) + tmp10 := lang.Apply(tmp5, []any{tmp6, tmp9}) + return tmp10 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // mapv + { + tmp0 := lang.NewSymbol("mapv").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2"), lang.NewSymbol("c3")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2"), lang.NewSymbol("c3"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Returns a vector consisting of the result of applying f to the\n set of first items of each coll, followed by applying f to the set\n of second items in each coll, until any one of the colls is\n exhausted. Any remaining items in other colls are ignored. Function\n f should accept number-of-colls arguments.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6943), lang.NewKeyword("end-line"), int(6943))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_persistent_BANG_) + tmp6 := checkDerefVar(glojure_DOT_core_reduce) + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + tmp10 := checkDerefVar(glojure_DOT_core_conj_BANG_) + tmp11 := lang.Apply(v3, []any{v9}) + tmp12 := lang.Apply(tmp10, []any{v8, tmp11}) + return tmp12 + }) + tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6952), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(6952), lang.NewKeyword("end-column"), int(43)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp10 := checkDerefVar(glojure_DOT_core_transient) + tmp11 := lang.NewVector() + tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6952), lang.NewKeyword("column"), int(56), lang.NewKeyword("end-line"), int(6952), lang.NewKeyword("end-column"), int(57)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp14 := lang.Apply(tmp10, []any{tmp13}) + tmp15 := lang.Apply(tmp6, []any{tmp9, tmp14, v4}) + tmp16 := lang.Apply(tmp5, []any{tmp15}) + return tmp16 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6 := checkDerefVar(glojure_DOT_core_into) + tmp7 := lang.NewVector() + tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6955), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(6955), lang.NewKeyword("end-column"), int(13)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp10 := checkDerefVar(glojure_DOT_core_map) + tmp11 := lang.Apply(tmp10, []any{v3, v4, v5}) + tmp12 := lang.Apply(tmp6, []any{tmp9, tmp11}) + return tmp12 + case 4: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_into) + tmp8 := lang.NewVector() + tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6957), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(6957), lang.NewKeyword("end-column"), int(13)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp11 := checkDerefVar(glojure_DOT_core_map) + tmp12 := lang.Apply(tmp11, []any{v3, v4, v5, v6}) + tmp13 := lang.Apply(tmp7, []any{tmp10, tmp12}) + return tmp13 + default: + if len(args) < 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + var v7 any = lang.NewList(args[4:]...) + _ = v7 + tmp8 := checkDerefVar(glojure_DOT_core_into) + tmp9 := lang.NewVector() + tmp10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6959), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(6959), lang.NewKeyword("end-column"), int(13)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp12 := checkDerefVar(glojure_DOT_core_apply) + tmp13 := checkDerefVar(glojure_DOT_core_map) + tmp14 := lang.Apply(tmp12, []any{tmp13, v3, v4, v5, v6, v7}) + tmp15 := lang.Apply(tmp8, []any{tmp11, tmp14}) + return tmp15 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // max + { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed33 + } else { + tmp4 = closed33 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_seq) + tmp8 := checkDerefVar(glojure_DOT_core_concat) + tmp9 := checkDerefVar(glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol(".")}) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := checkDerefVar(glojure_DOT_core_seq) + tmp15 := checkDerefVar(glojure_DOT_core_concat) + tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed33 + } else { + tmp5 = closed33 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(glojure_DOT_core_seq) + tmp9 := checkDerefVar(glojure_DOT_core_concat) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol(".")}) + tmp12 := checkDerefVar(glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp14 := checkDerefVar(glojure_DOT_core_list) + tmp15 := checkDerefVar(glojure_DOT_core_seq) + tmp16 := checkDerefVar(glojure_DOT_core_concat) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed33 + } else { + tmp6 = closed33 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(glojure_DOT_core_seq) + tmp14 := checkDerefVar(glojure_DOT_core_concat) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := checkDerefVar(glojure_DOT_core_seq) + tmp21 := checkDerefVar(glojure_DOT_core_concat) + tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(glojure_DOT_core_seq) + tmp14 := checkDerefVar(glojure_DOT_core_concat) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := checkDerefVar(glojure_DOT_core_seq) + tmp21 := checkDerefVar(glojure_DOT_core_concat) + tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp0 := lang.NewSymbol("max").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the greatest of the nums.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), tmp2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1108), lang.NewKeyword("end-line"), int(1108))).(*lang.Symbol) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v5 := args[0] + _ = v5 + return v5 + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + tmp7, _ := lang.FieldOrMethod(lang.Numbers, "Max") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Max is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v5, v6}) + return tmp8 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + var v7 any = lang.NewList(args[2:]...) + _ = v7 + tmp8 := checkDerefVar(glojure_DOT_core_reduce1) + tmp9 := checkDerefVar(glojure_DOT_core_max) + tmp10 := checkDerefVar(glojure_DOT_core_max) + tmp11 := lang.Apply(tmp10, []any{v5, v6}) + tmp12 := lang.Apply(tmp8, []any{tmp9, tmp11, v7}) + return tmp12 + } + }) + tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 := ns.InternWithValue(tmp0, tmp4, true) + if tmp0.Meta() != nil { + tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // max-key + { + tmp0 := lang.NewSymbol("max-key").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Returns the x for which (k x), a number, is greatest.\n\n If there are multiple such xs, the last one is returned.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5013), lang.NewKeyword("end-line"), int(5013))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + return v4 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(glojure_DOT_core__GT_) + tmp8 := lang.Apply(v3, []any{v4}) + tmp9 := lang.Apply(v3, []any{v5}) + tmp10 := lang.Apply(tmp7, []any{tmp8, tmp9}) + if lang.IsTruthy(tmp10) { + tmp6 = v4 + } else { + tmp6 = v5 + } + return tmp6 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any + { // let + // let binding "kx" + tmp8 := lang.Apply(v3, []any{v4}) + var v9 any = tmp8 + _ = v9 + // let binding "ky" + tmp10 := lang.Apply(v3, []any{v5}) + var v11 any = tmp10 + _ = v11 + // let binding "vec__55" + var tmp12 any + tmp13 := checkDerefVar(glojure_DOT_core__GT_) + tmp14 := lang.Apply(tmp13, []any{v9, v11}) + if lang.IsTruthy(tmp14) { + tmp15 := lang.NewVector(v4, v9) + tmp16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5023), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(5023), lang.NewKeyword("end-column"), int(36)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp12 = tmp17 + } else { + tmp18 := lang.NewVector(v5, v11) + tmp19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5023), lang.NewKeyword("column"), int(38), lang.NewKeyword("end-line"), int(5023), lang.NewKeyword("end-column"), int(43)) + tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp12 = tmp20 + } + var v21 any = tmp12 + _ = v21 + // let binding "v" + tmp22 := checkDerefVar(glojure_DOT_core_nth) + tmp23 := lang.Apply(tmp22, []any{v21, int64(0), nil}) + var v24 any = tmp23 + _ = v24 + // let binding "kv" + tmp25 := checkDerefVar(glojure_DOT_core_nth) + tmp26 := lang.Apply(tmp25, []any{v21, int64(1), nil}) + var v27 any = tmp26 + _ = v27 + var tmp28 any + { // let + // let binding "v" + var v29 any = v24 + _ = v29 + // let binding "kv" + var v30 any = v27 + _ = v30 + // let binding "more" + var v31 any = v6 + _ = v31 + for { + var tmp32 any + if lang.IsTruthy(v31) { + var tmp33 any + { // let + // let binding "w" + tmp34 := checkDerefVar(glojure_DOT_core_first) + tmp35 := lang.Apply(tmp34, []any{v31}) + var v36 any = tmp35 + _ = v36 + // let binding "kw" + tmp37 := lang.Apply(v3, []any{v36}) + var v38 any = tmp37 + _ = v38 + var tmp39 any + tmp40 := checkDerefVar(glojure_DOT_core__GT__EQ_) + tmp41 := lang.Apply(tmp40, []any{v38, v30}) + if lang.IsTruthy(tmp41) { + var tmp42 any = v36 + var tmp43 any = v38 + tmp45 := checkDerefVar(glojure_DOT_core_next) + tmp46 := lang.Apply(tmp45, []any{v31}) + var tmp44 any = tmp46 + v29 = tmp42 + v30 = tmp43 + v31 = tmp44 + continue + } else { + var tmp47 any = v29 + var tmp48 any = v30 + tmp50 := checkDerefVar(glojure_DOT_core_next) + tmp51 := lang.Apply(tmp50, []any{v31}) + var tmp49 any = tmp51 + v29 = tmp47 + v30 = tmp48 + v31 = tmp49 + continue + } + tmp33 = tmp39 + } // end let + tmp32 = tmp33 + } else { + tmp32 = v29 + } + tmp28 = tmp32 + break + } + } // end let + tmp7 = tmp28 + } // end let + return tmp7 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // max-mask-bits + { + tmp0 := lang.NewSymbol("max-mask-bits").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6601), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(6601), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, int64(13), true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // max-switch-table-size + { + tmp0 := lang.NewSymbol("max-switch-table-size").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6602), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(6602), lang.NewKeyword("end-column"), int(36), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, int64(8192), true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // maybe-destructured + { + tmp0 := lang.NewSymbol("maybe-destructured").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4514), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(4515), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("params"), lang.NewSymbol("body"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(glojure_DOT_core_every_QMARK_) + tmp7 := checkDerefVar(glojure_DOT_core_symbol_QMARK_) + tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) + if lang.IsTruthy(tmp8) { + tmp9 := checkDerefVar(glojure_DOT_core_cons) + tmp10 := lang.Apply(tmp9, []any{v3, v4}) + tmp5 = tmp10 + } else { + var tmp11 any + { // let + // let binding "params" + var v12 any = v3 + _ = v12 + // let binding "new-params" + tmp13 := checkDerefVar(glojure_DOT_core_with_meta) + tmp14 := lang.NewVector() + tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4520), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(4520), lang.NewKeyword("end-column"), int(35)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp17 := checkDerefVar(glojure_DOT_core_meta) + tmp18 := lang.Apply(tmp17, []any{v12}) + tmp19 := lang.Apply(tmp13, []any{tmp16, tmp18}) + var v20 any = tmp19 + _ = v20 + // let binding "lets" + tmp21 := lang.NewVector() + tmp22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4521), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(4521), lang.NewKeyword("end-column"), int(18)) + tmp23, err := lang.WithMeta(tmp21, tmp22.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v24 any = tmp23 + _ = v24 + for { + var tmp25 any + if lang.IsTruthy(v12) { + var tmp26 any + tmp27 := checkDerefVar(glojure_DOT_core_symbol_QMARK_) + tmp28 := checkDerefVar(glojure_DOT_core_first) + tmp29 := lang.Apply(tmp28, []any{v12}) + tmp30 := lang.Apply(tmp27, []any{tmp29}) + if lang.IsTruthy(tmp30) { + tmp32 := checkDerefVar(glojure_DOT_core_next) + tmp33 := lang.Apply(tmp32, []any{v12}) + var tmp31 any = tmp33 + tmp35 := checkDerefVar(glojure_DOT_core_conj) + tmp36 := checkDerefVar(glojure_DOT_core_first) + tmp37 := lang.Apply(tmp36, []any{v12}) + tmp38 := lang.Apply(tmp35, []any{v20, tmp37}) + var tmp34 any = tmp38 + var tmp39 any = v24 + v12 = tmp31 + v20 = tmp34 + v24 = tmp39 + continue + } else { + var tmp40 any + { // let + // let binding "gparam" + tmp41 := checkDerefVar(glojure_DOT_core_gensym) + tmp42 := lang.Apply(tmp41, []any{"p__"}) + var v43 any = tmp42 + _ = v43 + tmp45 := checkDerefVar(glojure_DOT_core_next) + tmp46 := lang.Apply(tmp45, []any{v12}) + var tmp44 any = tmp46 + tmp48 := checkDerefVar(glojure_DOT_core_conj) + tmp49 := lang.Apply(tmp48, []any{v20, v43}) + var tmp47 any = tmp49 + tmp51 := checkDerefVar(glojure_DOT_core_conj) + tmp52 := checkDerefVar(glojure_DOT_core_conj) + tmp53 := checkDerefVar(glojure_DOT_core_first) + tmp54 := lang.Apply(tmp53, []any{v12}) + tmp55 := lang.Apply(tmp52, []any{v24, tmp54}) + tmp56 := lang.Apply(tmp51, []any{tmp55, v43}) + var tmp50 any = tmp56 + v12 = tmp44 + v20 = tmp47 + v24 = tmp50 + continue + } // end let + tmp26 = tmp40 + } + tmp25 = tmp26 + } else { + tmp41 := checkDerefVar(glojure_DOT_core_seq) + tmp42 := checkDerefVar(glojure_DOT_core_concat) + tmp43 := checkDerefVar(glojure_DOT_core_list) + tmp44 := lang.Apply(tmp43, []any{v20}) + tmp45 := checkDerefVar(glojure_DOT_core_list) + tmp46 := checkDerefVar(glojure_DOT_core_seq) + tmp47 := checkDerefVar(glojure_DOT_core_concat) + tmp48 := checkDerefVar(glojure_DOT_core_list) + tmp49 := lang.Apply(tmp48, []any{lang.NewSymbol("glojure.core/let")}) + tmp50 := checkDerefVar(glojure_DOT_core_list) + tmp51 := lang.Apply(tmp50, []any{v24}) + tmp52 := lang.Apply(tmp47, []any{tmp49, tmp51, v4}) + tmp53 := lang.Apply(tmp46, []any{tmp52}) + tmp54 := lang.Apply(tmp45, []any{tmp53}) + tmp55 := lang.Apply(tmp42, []any{tmp44, tmp54}) + tmp56 := lang.Apply(tmp41, []any{tmp55}) + tmp25 = tmp56 + } + tmp11 = tmp25 + break + } + } // end let + tmp5 = tmp11 + } + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // maybe-min-hash + { + tmp0 := lang.NewSymbol("maybe-min-hash").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("hashes"))), lang.NewKeyword("doc"), "takes a collection of hashes and returns [shift mask] or nil if none found", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6604), lang.NewKeyword("end-line"), int(6604), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_first) + tmp5 := checkDerefVar(glojure_DOT_core_filter) + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v7 := args[0] + _ = v7 + var tmp8 any + { // let + // let binding "vec__151" + var v9 any = v7 + _ = v9 + // let binding "s" + tmp10 := checkDerefVar(glojure_DOT_core_nth) + tmp11 := lang.Apply(tmp10, []any{v9, int64(0), nil}) + var v12 any = tmp11 + _ = v12 + // let binding "m" + tmp13 := checkDerefVar(glojure_DOT_core_nth) + tmp14 := lang.Apply(tmp13, []any{v9, int64(1), nil}) + var v15 any = tmp14 + _ = v15 + tmp16 := checkDerefVar(glojure_DOT_core_apply) + tmp17 := checkDerefVar(glojure_DOT_core_distinct_QMARK_) + tmp18 := checkDerefVar(glojure_DOT_core_map) + var tmp19 lang.FnFunc + tmp19 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v20 := args[0] + _ = v20 + tmp21 := checkDerefVar(glojure_DOT_core_shift_mask) + tmp22 := lang.Apply(tmp21, []any{v12, v15, v20}) + return tmp22 + }) + tmp20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6609), lang.NewKeyword("column"), int(37), lang.NewKeyword("end-line"), int(6609), lang.NewKeyword("end-column"), int(55)) + tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp22 := lang.Apply(tmp18, []any{tmp21, v3}) + tmp23 := lang.Apply(tmp16, []any{tmp17, tmp22}) + tmp8 = tmp23 + } // end let + return tmp8 + }) + tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6608), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(6609), lang.NewKeyword("end-column"), int(65)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var tmp9 any + { // let + // let binding "iter__0__auto__" + var tmp10 lang.FnFunc + { // function iter__154 + var v11 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v12 := args[0] + _ = v12 + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var tmp14 any + { // let + // let binding "s__155" + var v15 any = v12 + _ = v15 + for { + var tmp16 any + { // let + // let binding "temp__0__auto__" + tmp17 := checkDerefVar(glojure_DOT_core_seq) + tmp18 := lang.Apply(tmp17, []any{v15}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + var tmp21 any + { // let + // let binding "xs__0__auto__" + var v22 any = v19 + _ = v22 + var tmp23 any + { // let + // let binding "mask" + tmp24 := checkDerefVar(glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v22}) + var v26 any = tmp25 + _ = v26 + var tmp27 any + { // let + // let binding "iterys__0__auto__" + var tmp28 lang.FnFunc + { // function iter__156 + var v29 lang.FnFunc + tmp28 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v30 := args[0] + _ = v30 + var tmp31 lang.FnFunc + tmp31 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var tmp32 any + { // let + // let binding "s__157" + var v33 any = v30 + _ = v33 + for { + var tmp34 any + { // let + // let binding "temp__0__auto__" + tmp35 := checkDerefVar(glojure_DOT_core_seq) + tmp36 := lang.Apply(tmp35, []any{v33}) + var v37 any = tmp36 + _ = v37 + var tmp38 any + if lang.IsTruthy(v37) { + var tmp39 any + { // let + // let binding "s__157" + var v40 any = v37 + _ = v40 + var tmp41 any + tmp42 := checkDerefVar(glojure_DOT_core_chunked_seq_QMARK_) + tmp43 := lang.Apply(tmp42, []any{v40}) + if lang.IsTruthy(tmp43) { + var tmp44 any + { // let + // let binding "c__0__auto__" + tmp45 := checkDerefVar(glojure_DOT_core_chunk_first) + tmp46 := lang.Apply(tmp45, []any{v40}) + var v47 any = tmp46 + _ = v47 + // let binding "size__1__auto__" + tmp48 := checkDerefVar(glojure_DOT_core_int) + tmp49 := checkDerefVar(glojure_DOT_core_count) + tmp50 := lang.Apply(tmp49, []any{v47}) + tmp51 := lang.Apply(tmp48, []any{tmp50}) + var v52 any = tmp51 + _ = v52 + // let binding "b__159" + tmp53 := checkDerefVar(glojure_DOT_core_chunk_buffer) + tmp54 := lang.Apply(tmp53, []any{v52}) + var v55 any = tmp54 + _ = v55 + var tmp56 any + var tmp57 any + { // let + // let binding "i__158" + tmp58 := checkDerefVar(glojure_DOT_core_int) + tmp59 := lang.Apply(tmp58, []any{int64(0)}) + var v60 any = tmp59 + _ = v60 + for { + var tmp61 any + tmp62 := checkDerefVar(glojure_DOT_core__LT_) + tmp63 := lang.Apply(tmp62, []any{v60, v52}) + if lang.IsTruthy(tmp63) { + var tmp64 any + { // let + // let binding "shift" + tmp65, _ := lang.FieldOrMethod(v47, "nth") + if reflect.TypeOf(tmp65).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp66 := lang.Apply(tmp65, []any{v60}) + var v67 any = tmp66 + _ = v67 + tmp68 := checkDerefVar(glojure_DOT_core_chunk_append) + tmp69 := lang.NewVector(v67, v26) + tmp70 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6612), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(6612), lang.NewKeyword("end-column"), int(26)) + tmp71, err := lang.WithMeta(tmp69, tmp70.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp72 := lang.Apply(tmp68, []any{v55, tmp71}) + _ = tmp72 + tmp74 := checkDerefVar(glojure_DOT_core_unchecked_inc) + tmp75 := lang.Apply(tmp74, []any{v60}) + var tmp73 any = tmp75 + v60 = tmp73 + continue + } // end let + tmp61 = tmp64 + } else { + tmp61 = true + } + tmp57 = tmp61 + break + } + } // end let + if lang.IsTruthy(tmp57) { + tmp58 := checkDerefVar(glojure_DOT_core_chunk_cons) + tmp59 := checkDerefVar(glojure_DOT_core_chunk) + tmp60 := lang.Apply(tmp59, []any{v55}) + tmp61 := checkDerefVar(glojure_DOT_core_chunk_rest) + tmp62 := lang.Apply(tmp61, []any{v40}) + tmp63 := lang.Apply(v29, []any{tmp62}) + tmp64 := lang.Apply(tmp58, []any{tmp60, tmp63}) + tmp56 = tmp64 + } else { + tmp65 := checkDerefVar(glojure_DOT_core_chunk_cons) + tmp66 := checkDerefVar(glojure_DOT_core_chunk) + tmp67 := lang.Apply(tmp66, []any{v55}) + tmp68 := lang.Apply(tmp65, []any{tmp67, nil}) + tmp56 = tmp68 + } + tmp44 = tmp56 + } // end let + tmp41 = tmp44 + } else { + var tmp45 any + { // let + // let binding "shift" + tmp46 := checkDerefVar(glojure_DOT_core_first) + tmp47 := lang.Apply(tmp46, []any{v40}) + var v48 any = tmp47 + _ = v48 + tmp49 := checkDerefVar(glojure_DOT_core_cons) + tmp50 := lang.NewVector(v48, v26) + tmp51 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6612), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(6612), lang.NewKeyword("end-column"), int(26)) + tmp52, err := lang.WithMeta(tmp50, tmp51.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp53 := checkDerefVar(glojure_DOT_core_rest) + tmp54 := lang.Apply(tmp53, []any{v40}) + tmp55 := lang.Apply(v29, []any{tmp54}) + tmp56 := lang.Apply(tmp49, []any{tmp52, tmp55}) + tmp45 = tmp56 + } // end let + tmp41 = tmp45 + } + tmp39 = tmp41 + } // end let + tmp38 = tmp39 + } else { + } + tmp34 = tmp38 + } // end let + tmp32 = tmp34 + break + } + } // end let + return tmp32 + }) + tmp32 := lang.Apply(lang.NewLazySeq, []any{tmp31}) + return tmp32 + }) + v29 = tmp28 + _ = v29 + } + var v29 any = tmp28 + _ = v29 + // let binding "fs__1__auto__" + tmp30 := checkDerefVar(glojure_DOT_core_seq) + tmp31 := checkDerefVar(glojure_DOT_core_range) + tmp32 := lang.Apply(tmp31, []any{int64(0), int64(31)}) + tmp33 := lang.Apply(v29, []any{tmp32}) + tmp34 := lang.Apply(tmp30, []any{tmp33}) + var v35 any = tmp34 + _ = v35 + var tmp36 any + if lang.IsTruthy(v35) { + tmp37 := checkDerefVar(glojure_DOT_core_concat) + tmp38 := checkDerefVar(glojure_DOT_core_rest) + tmp39 := lang.Apply(tmp38, []any{v15}) + tmp40 := lang.Apply(v11, []any{tmp39}) + tmp41 := lang.Apply(tmp37, []any{v35, tmp40}) + tmp36 = tmp41 + } else { + tmp43 := checkDerefVar(glojure_DOT_core_rest) + tmp44 := lang.Apply(tmp43, []any{v15}) + var tmp42 any = tmp44 + v15 = tmp42 + continue + } + tmp27 = tmp36 + } // end let + tmp23 = tmp27 + } // end let + tmp21 = tmp23 + } // end let + tmp20 = tmp21 + } else { + } + tmp16 = tmp20 + } // end let + tmp14 = tmp16 + break + } + } // end let + return tmp14 + }) + tmp14 := lang.Apply(lang.NewLazySeq, []any{tmp13}) + return tmp14 + }) + v11 = tmp10 + _ = v11 + } + var v11 any = tmp10 + _ = v11 + tmp12 := checkDerefVar(glojure_DOT_core_map) + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v14 := args[0] + _ = v14 + tmp15 := checkDerefVar(glojure_DOT_core_dec) + tmp16 := checkDerefVar(glojure_DOT_core_bit_shift_left) + tmp17 := lang.Apply(tmp16, []any{int64(1), v14}) + tmp18 := lang.Apply(tmp15, []any{tmp17}) + return tmp18 + }) + tmp14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6610), lang.NewKeyword("column"), int(29), lang.NewKeyword("end-line"), int(6610), lang.NewKeyword("end-column"), int(55)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp16 := checkDerefVar(glojure_DOT_core_range) + tmp17 := checkDerefVar(glojure_DOT_core_inc) + tmp18 := checkDerefVar(glojure_DOT_core_max_mask_bits) + tmp19 := lang.Apply(tmp17, []any{tmp18}) + tmp20 := lang.Apply(tmp16, []any{int64(1), tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp15, tmp20}) + tmp22 := lang.Apply(v11, []any{tmp21}) + tmp9 = tmp22 + } // end let + tmp10 := lang.Apply(tmp5, []any{tmp8, tmp9}) + tmp11 := lang.Apply(tmp4, []any{tmp10}) + return tmp11 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // memfn + { + tmp0 := lang.NewSymbol("memfn").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Expands into code that creates a fn that expects to be passed an\n object and any args and calls the named instance method on the\n object passing the args. Use when you want to treat a Java method as\n a first-class fn. name may be type-hinted with the method receiver's\n type in order to avoid reflective calls.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3872), lang.NewKeyword("end-line"), int(3872))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any + { // let + // let binding "t" + tmp8 := checkDerefVar(glojure_DOT_core_with_meta) + tmp9 := checkDerefVar(glojure_DOT_core_gensym) + tmp10 := lang.Apply(tmp9, []any{"target"}) + tmp11 := checkDerefVar(glojure_DOT_core_meta) + tmp12 := lang.Apply(tmp11, []any{v5}) + tmp13 := lang.Apply(tmp8, []any{tmp10, tmp12}) + var v14 any = tmp13 + _ = v14 + tmp15 := checkDerefVar(glojure_DOT_core_seq) + tmp16 := checkDerefVar(glojure_DOT_core_concat) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("glojure.core/fn")}) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := checkDerefVar(glojure_DOT_core_apply) + tmp21 := checkDerefVar(glojure_DOT_core_vector) + tmp22 := checkDerefVar(glojure_DOT_core_seq) + tmp23 := checkDerefVar(glojure_DOT_core_concat) + tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v14}) + tmp26 := lang.Apply(tmp23, []any{tmp25, v6}) + tmp27 := lang.Apply(tmp22, []any{tmp26}) + tmp28 := lang.Apply(tmp20, []any{tmp21, tmp27}) + tmp29 := lang.Apply(tmp19, []any{tmp28}) + tmp30 := checkDerefVar(glojure_DOT_core_list) + tmp31 := checkDerefVar(glojure_DOT_core_seq) + tmp32 := checkDerefVar(glojure_DOT_core_concat) + tmp33 := checkDerefVar(glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{lang.NewSymbol(".")}) + tmp35 := checkDerefVar(glojure_DOT_core_list) + tmp36 := lang.Apply(tmp35, []any{v14}) + tmp37 := checkDerefVar(glojure_DOT_core_list) + tmp38 := checkDerefVar(glojure_DOT_core_seq) + tmp39 := checkDerefVar(glojure_DOT_core_concat) + tmp40 := checkDerefVar(glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{v5}) + tmp42 := lang.Apply(tmp39, []any{tmp41, v6}) + tmp43 := lang.Apply(tmp38, []any{tmp42}) + tmp44 := lang.Apply(tmp37, []any{tmp43}) + tmp45 := lang.Apply(tmp32, []any{tmp34, tmp36, tmp44}) + tmp46 := lang.Apply(tmp31, []any{tmp45}) + tmp47 := lang.Apply(tmp30, []any{tmp46}) + tmp48 := lang.Apply(tmp16, []any{tmp18, tmp29, tmp47}) + tmp49 := lang.Apply(tmp15, []any{tmp48}) + tmp7 = tmp49 + } // end let + return tmp7 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // memoize + { + tmp0 := lang.NewSymbol("memoize").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Returns a memoized version of a referentially transparent function. The\n memoized version of the function keeps a cache of the mapping from arguments\n to results and, when calls with the same arguments are repeated often, has\n higher performance at the expense of higher memory use.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6337), lang.NewKeyword("end-line"), int(6337))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + { // let + // let binding "mem" + tmp5 := checkDerefVar(glojure_DOT_core_atom) + tmp6 := lang.NewMap() + tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6345), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(6345), lang.NewKeyword("end-column"), int(20)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp9 := lang.Apply(tmp5, []any{tmp8}) + var v10 any = tmp9 + _ = v10 + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v12 any = lang.NewList(args[0:]...) + _ = v12 + var tmp13 any + { // let + // let binding "temp__0__auto__" + tmp14 := checkDerefVar(glojure_DOT_core_find) + tmp15 := checkDerefVar(glojure_DOT_core_deref) + tmp16 := lang.Apply(tmp15, []any{v10}) + tmp17 := lang.Apply(tmp14, []any{tmp16, v12}) + var v18 any = tmp17 + _ = v18 + var tmp19 any + if lang.IsTruthy(v18) { + var tmp20 any + { // let + // let binding "e" + var v21 any = v18 + _ = v21 + tmp22 := checkDerefVar(glojure_DOT_core_val) + tmp23 := lang.Apply(tmp22, []any{v21}) + tmp20 = tmp23 + } // end let + tmp19 = tmp20 + } else { + var tmp21 any + { // let + // let binding "ret" + tmp22 := checkDerefVar(glojure_DOT_core_apply) + tmp23 := lang.Apply(tmp22, []any{v3, v12}) + var v24 any = tmp23 + _ = v24 + tmp25 := checkDerefVar(glojure_DOT_core_swap_BANG_) + tmp26 := checkDerefVar(glojure_DOT_core_assoc) + tmp27 := lang.Apply(tmp25, []any{v10, tmp26, v12, v24}) + _ = tmp27 + tmp21 = v24 + } // end let + tmp19 = tmp21 + } + tmp13 = tmp19 + } // end let + return tmp13 + } + }) + tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6346), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(6351), lang.NewKeyword("end-column"), int(16)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp4 = tmp13 + } // end let + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // merge + { + tmp0 := lang.NewSymbol("merge").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("maps"))), lang.NewKeyword("doc"), "Returns a map that consists of the rest of the maps conj-ed onto\n the first. If a key occurs in more than one map, the mapping from\n the latter (left-to-right) will be the mapping in the result.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3040), lang.NewKeyword("end-line"), int(3040))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v3 any = lang.NewList(args[0:]...) + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(glojure_DOT_core_some) + tmp6 := checkDerefVar(glojure_DOT_core_identity) + tmp7 := lang.Apply(tmp5, []any{tmp6, v3}) + if lang.IsTruthy(tmp7) { + tmp8 := checkDerefVar(glojure_DOT_core_reduce1) + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + tmp12 := checkDerefVar(glojure_DOT_core_conj) + var tmp13 any + { // let + // let binding "or__0__auto__" + var v14 any = v10 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + tmp15 = v14 + } else { + tmp16 := lang.NewMap() + tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3048), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(3048), lang.NewKeyword("end-column"), int(29)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp15 = tmp18 + } + tmp13 = tmp15 + } // end let + tmp14 := lang.Apply(tmp12, []any{tmp13, v11}) + return tmp14 + }) + tmp10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3048), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(3048), lang.NewKeyword("end-column"), int(34)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp12 := lang.Apply(tmp8, []any{tmp11, v3}) + tmp4 = tmp12 + } else { + } + return tmp4 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // merge-hash-collisions + { + tmp0 := lang.NewSymbol("merge-hash-collisions").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr-sym"), lang.NewSymbol("default"), lang.NewSymbol("tests"), lang.NewSymbol("thens"))), lang.NewKeyword("doc"), "Takes a case expression, default expression, and a sequence of test constants\n and a corresponding sequence of then expressions. Returns a tuple of\n [tests thens skip-check-set] where no tests have the same hash. Each set of\n input test constants with the same hash is replaced with a single test\n constant (the case int), and their respective thens are combined into:\n (condp = expr\n test-1 then-1\n ...\n test-n then-n\n default).\n The skip-check is a set of case ints for which post-switch equivalence\n checking must not be done (the cases holding the above condp thens).", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6647), lang.NewKeyword("end-line"), int(6647), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + var tmp7 any + { // let + // let binding "buckets" + var tmp8 any + { // let + // let binding "m" + tmp9 := lang.NewMap() + tmp10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6661), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(6661), lang.NewKeyword("end-column"), int(27)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v12 any = tmp11 + _ = v12 + // let binding "ks" + var v13 any = v5 + _ = v13 + // let binding "vs" + var v14 any = v6 + _ = v14 + for { + var tmp15 any + var tmp16 any + { // let + // let binding "and__0__auto__" + var v17 any = v13 + _ = v17 + var tmp18 any + if lang.IsTruthy(v17) { + tmp18 = v14 + } else { + tmp18 = v17 + } + tmp16 = tmp18 + } // end let + if lang.IsTruthy(tmp16) { + tmp18 := checkDerefVar(glojure_DOT_core_update) + tmp19 := checkDerefVar(glojure_DOT_core_first) + tmp20 := lang.Apply(tmp19, []any{v13}) + tmp21 := lang.Apply(lang.Hash, []any{tmp20}) + tmp22 := checkDerefVar(glojure_DOT_core_fnil) + tmp23 := checkDerefVar(glojure_DOT_core_conj) + tmp24 := lang.NewVector() + tmp25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6664), lang.NewKeyword("column"), int(102), lang.NewKeyword("end-line"), int(6664), lang.NewKeyword("end-column"), int(103)) + tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp27 := lang.Apply(tmp22, []any{tmp23, tmp26}) + tmp28 := checkDerefVar(glojure_DOT_core_first) + tmp29 := lang.Apply(tmp28, []any{v13}) + tmp30 := checkDerefVar(glojure_DOT_core_first) + tmp31 := lang.Apply(tmp30, []any{v14}) + tmp32 := lang.NewVector(tmp29, tmp31) + tmp33 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6664), lang.NewKeyword("column"), int(106), lang.NewKeyword("end-line"), int(6664), lang.NewKeyword("end-column"), int(128)) + tmp34, err := lang.WithMeta(tmp32, tmp33.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp35 := lang.Apply(tmp18, []any{v12, tmp21, tmp27, tmp34}) + var tmp17 any = tmp35 + tmp37 := checkDerefVar(glojure_DOT_core_next) + tmp38 := lang.Apply(tmp37, []any{v13}) + var tmp36 any = tmp38 + tmp40 := checkDerefVar(glojure_DOT_core_next) + tmp41 := lang.Apply(tmp40, []any{v14}) + var tmp39 any = tmp41 + v12 = tmp17 + v13 = tmp36 + v14 = tmp39 + continue + } else { + tmp15 = v12 + } + tmp8 = tmp15 + break + } + } // end let + var v9 any = tmp8 + _ = v9 + // let binding "assoc-multi" + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + v13 := args[2] + _ = v13 + var tmp14 any + { // let + // let binding "testexprs" + tmp15 := checkDerefVar(glojure_DOT_core_mapcat) + var tmp16 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v17 := args[0] + _ = v17 + tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp19 := checkDerefVar(glojure_DOT_core_first) + tmp20 := lang.Apply(tmp19, []any{v17}) + tmp21 := lang.Apply(tmp18, []any{lang.NewSymbol("quote"), tmp20}) + tmp22 := checkDerefVar(glojure_DOT_core_second) + tmp23 := lang.Apply(tmp22, []any{v17}) + tmp24 := lang.NewVector(tmp21, tmp23) + tmp25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6668), lang.NewKeyword("column"), int(56), lang.NewKeyword("end-line"), int(6668), lang.NewKeyword("end-column"), int(93)) + tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp26 + }) + tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6668), lang.NewKeyword("column"), int(47), lang.NewKeyword("end-line"), int(6668), lang.NewKeyword("end-column"), int(94)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp19 := lang.Apply(tmp15, []any{tmp18, v13}) + var v20 any = tmp19 + _ = v20 + // let binding "expr" + tmp21 := checkDerefVar(glojure_DOT_core_seq) + tmp22 := checkDerefVar(glojure_DOT_core_concat) + tmp23 := checkDerefVar(glojure_DOT_core_list) + tmp24 := lang.Apply(tmp23, []any{lang.NewSymbol("glojure.core/condp")}) + tmp25 := checkDerefVar(glojure_DOT_core_list) + tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol("glojure.core/=")}) + tmp27 := checkDerefVar(glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{v3}) + tmp29 := checkDerefVar(glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{v4}) + tmp31 := lang.Apply(tmp22, []any{tmp24, tmp26, tmp28, v20, tmp30}) + tmp32 := lang.Apply(tmp21, []any{tmp31}) + var v33 any = tmp32 + _ = v33 + tmp34 := checkDerefVar(glojure_DOT_core_assoc) + tmp35 := lang.Apply(tmp34, []any{v11, v12, v33}) + tmp14 = tmp35 + } // end let + return tmp14 + }) + tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6667), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(6670), lang.NewKeyword("end-column"), int(42)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v13 any = tmp12 + _ = v13 + // let binding "hmap" + tmp14 := checkDerefVar(glojure_DOT_core_reduce1) + var tmp15 lang.FnFunc + tmp15 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v16 := args[0] + _ = v16 + v17 := args[1] + _ = v17 + var tmp18 any + { // let + // let binding "vec__164" + var v19 any = v17 + _ = v19 + // let binding "h" + tmp20 := checkDerefVar(glojure_DOT_core_nth) + tmp21 := lang.Apply(tmp20, []any{v19, int64(0), nil}) + var v22 any = tmp21 + _ = v22 + // let binding "bucket" + tmp23 := checkDerefVar(glojure_DOT_core_nth) + tmp24 := lang.Apply(tmp23, []any{v19, int64(1), nil}) + var v25 any = tmp24 + _ = v25 + var tmp26 any + tmp27 := checkDerefVar(glojure_DOT_core__EQ__EQ_) + tmp28 := checkDerefVar(glojure_DOT_core_count) + tmp29 := lang.Apply(tmp28, []any{v25}) + tmp30 := lang.Apply(tmp27, []any{int64(1), tmp29}) + if lang.IsTruthy(tmp30) { + tmp31 := checkDerefVar(glojure_DOT_core_assoc) + tmp32 := checkDerefVar(glojure_DOT_core_ffirst) + tmp33 := lang.Apply(tmp32, []any{v25}) + tmp34 := checkDerefVar(glojure_DOT_core_second) + tmp35 := checkDerefVar(glojure_DOT_core_first) + tmp36 := lang.Apply(tmp35, []any{v25}) + tmp37 := lang.Apply(tmp34, []any{tmp36}) + tmp38 := lang.Apply(tmp31, []any{v16, tmp33, tmp37}) + tmp26 = tmp38 + } else { + tmp39 := lang.Apply(v13, []any{v16, v22, v25}) + tmp26 = tmp39 + } + tmp18 = tmp26 + } // end let + return tmp18 + }) + tmp16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6672), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(6675), lang.NewKeyword("end-column"), int(45)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp18 := lang.NewMap() + tmp19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6676), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(6676), lang.NewKeyword("end-column"), int(17)) + tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp21 := lang.Apply(tmp14, []any{tmp17, tmp20, v9}) + var v22 any = tmp21 + _ = v22 + // let binding "skip-check" + tmp23 := checkDerefVar(glojure_DOT_core_into1) + tmp24 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6680), lang.NewKeyword("column"), int(29), lang.NewKeyword("end-line"), int(6680), lang.NewKeyword("end-column"), int(31)) + tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp27 := checkDerefVar(glojure_DOT_core_map) + tmp28 := checkDerefVar(glojure_DOT_core_first) + tmp29 := checkDerefVar(glojure_DOT_core_filter) + var tmp30 lang.FnFunc + tmp30 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v31 := args[0] + _ = v31 + tmp32 := checkDerefVar(glojure_DOT_core__LT_) + tmp33 := checkDerefVar(glojure_DOT_core_count) + tmp34 := checkDerefVar(glojure_DOT_core_second) + tmp35 := lang.Apply(tmp34, []any{v31}) + tmp36 := lang.Apply(tmp33, []any{tmp35}) + tmp37 := lang.Apply(tmp32, []any{int64(1), tmp36}) + return tmp37 + }) + tmp31 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6678), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(6678), lang.NewKeyword("end-column"), int(54)) + tmp32, err := lang.WithMeta(tmp30, tmp31.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp33 := lang.Apply(tmp29, []any{tmp32, v9}) + tmp34 := lang.Apply(tmp27, []any{tmp28, tmp33}) + tmp35 := lang.Apply(tmp23, []any{tmp26, tmp34}) + var v36 any = tmp35 + _ = v36 + tmp37 := checkDerefVar(glojure_DOT_core_keys) + tmp38 := lang.Apply(tmp37, []any{v22}) + tmp39 := checkDerefVar(glojure_DOT_core_vals) + tmp40 := lang.Apply(tmp39, []any{v22}) + tmp41 := lang.NewVector(tmp38, tmp40, v36) + tmp42 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6681), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(6681), lang.NewKeyword("end-column"), int(40)) + tmp43, err := lang.WithMeta(tmp41, tmp42.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp7 = tmp43 + } // end let + return tmp7 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // merge-with + { + tmp0 := lang.NewSymbol("merge-with").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("maps"))), lang.NewKeyword("doc"), "Returns a map that consists of the rest of the maps conj-ed onto\n the first. If a key occurs in more than one map, the mapping(s)\n from the latter (left-to-right) will be combined with the mapping in\n the result by calling (f val-in-result val-in-latter).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3050), lang.NewKeyword("end-line"), int(3050))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any = lang.NewList(args[1:]...) + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(glojure_DOT_core_some) + tmp7 := checkDerefVar(glojure_DOT_core_identity) + tmp8 := lang.Apply(tmp6, []any{tmp7, v4}) + if lang.IsTruthy(tmp8) { + var tmp9 any + { // let + // let binding "merge-entry" + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + var tmp13 any + { // let + // let binding "k" + tmp14 := checkDerefVar(glojure_DOT_core_key) + tmp15 := lang.Apply(tmp14, []any{v12}) + var v16 any = tmp15 + _ = v16 + // let binding "v" + tmp17 := checkDerefVar(glojure_DOT_core_val) + tmp18 := lang.Apply(tmp17, []any{v12}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + tmp21 := checkDerefVar(glojure_DOT_core_contains_QMARK_) + tmp22 := lang.Apply(tmp21, []any{v11, v16}) + if lang.IsTruthy(tmp22) { + tmp23 := checkDerefVar(glojure_DOT_core_assoc) + tmp24 := checkDerefVar(glojure_DOT_core_get) + tmp25 := lang.Apply(tmp24, []any{v11, v16}) + tmp26 := lang.Apply(v3, []any{tmp25, v19}) + tmp27 := lang.Apply(tmp23, []any{v11, v16, tmp26}) + tmp20 = tmp27 + } else { + tmp28 := checkDerefVar(glojure_DOT_core_assoc) + tmp29 := lang.Apply(tmp28, []any{v11, v16, v19}) + tmp20 = tmp29 + } + tmp13 = tmp20 + } // end let + return tmp13 + }) + tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3059), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(3063), lang.NewKeyword("end-column"), int(23)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v13 any = tmp12 + _ = v13 + // let binding "merge2" + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v15 := args[0] + _ = v15 + v16 := args[1] + _ = v16 + tmp17 := checkDerefVar(glojure_DOT_core_reduce1) + var tmp18 any + { // let + // let binding "or__0__auto__" + var v19 any = v15 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + tmp20 = v19 + } else { + tmp21 := lang.NewMap() + tmp22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3065), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(3065), lang.NewKeyword("end-column"), int(35)) + tmp23, err := lang.WithMeta(tmp21, tmp22.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp20 = tmp23 + } + tmp18 = tmp20 + } // end let + tmp19 := checkDerefVar(glojure_DOT_core_seq) + tmp20 := lang.Apply(tmp19, []any{v16}) + tmp21 := lang.Apply(tmp17, []any{v13, tmp18, tmp20}) + return tmp21 + }) + tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3064), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(3065), lang.NewKeyword("end-column"), int(47)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v17 any = tmp16 + _ = v17 + tmp18 := checkDerefVar(glojure_DOT_core_reduce1) + tmp19 := lang.Apply(tmp18, []any{v17, v4}) + tmp9 = tmp19 + } // end let + tmp5 = tmp9 + } else { + } + return tmp5 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // meta + { + tmp0 := lang.NewSymbol("meta").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("obj"))), lang.NewKeyword("doc"), "Returns the metadata of obj, returns nil if there is no metadata.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(202), lang.NewKeyword("end-line"), int(206))).(*lang.Symbol) + var tmp2 lang.FnFunc + { // function meta + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp7 := reflect.TypeOf((*lang.IMeta)(nil)).Elem() + tmp8 := lang.Apply(tmp6, []any{tmp7, v4}) + if lang.IsTruthy(tmp8) { + tmp9, ok := lang.FieldOrMethod(v4, "Meta") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "Meta"))) + } + var tmp10 any + switch reflect.TypeOf(tmp9).Kind() { + case reflect.Func: + tmp10 = lang.Apply(tmp9, nil) + default: + tmp10 = tmp9 + } + tmp5 = tmp10 + } else { + } + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(206), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(208), lang.NewKeyword("end-column"), int(21))).(lang.FnFunc) + v3 = tmp2 + _ = v3 + } + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // methods + { + tmp0 := lang.NewSymbol("methods").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"))), lang.NewKeyword("doc"), "Given a multimethod, returns a map of dispatch values -> dispatch fns", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1809), lang.NewKeyword("end-line"), int(1809))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4, ok := lang.FieldOrMethod(v3, "getMethodTable") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getMethodTable"))) + } + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { + case reflect.Func: + tmp5 = lang.Apply(tmp4, nil) + default: + tmp5 = tmp4 + } + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // min + { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed34 + } else { + tmp4 = closed34 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_seq) + tmp8 := checkDerefVar(glojure_DOT_core_concat) + tmp9 := checkDerefVar(glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol(".")}) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := checkDerefVar(glojure_DOT_core_seq) + tmp15 := checkDerefVar(glojure_DOT_core_concat) + tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed34 + } else { + tmp5 = closed34 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(glojure_DOT_core_seq) + tmp9 := checkDerefVar(glojure_DOT_core_concat) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol(".")}) + tmp12 := checkDerefVar(glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp14 := checkDerefVar(glojure_DOT_core_list) + tmp15 := checkDerefVar(glojure_DOT_core_seq) + tmp16 := checkDerefVar(glojure_DOT_core_concat) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed34 + } else { + tmp6 = closed34 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(glojure_DOT_core_seq) + tmp14 := checkDerefVar(glojure_DOT_core_concat) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := checkDerefVar(glojure_DOT_core_seq) + tmp21 := checkDerefVar(glojure_DOT_core_concat) + tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(glojure_DOT_core_seq) + tmp14 := checkDerefVar(glojure_DOT_core_concat) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := checkDerefVar(glojure_DOT_core_seq) + tmp21 := checkDerefVar(glojure_DOT_core_concat) + tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp0 := lang.NewSymbol("min").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the least of the nums.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), tmp2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1118), lang.NewKeyword("end-line"), int(1118))).(*lang.Symbol) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v5 := args[0] + _ = v5 + return v5 + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + tmp7, _ := lang.FieldOrMethod(lang.Numbers, "Min") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Min is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v5, v6}) + return tmp8 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + var v7 any = lang.NewList(args[2:]...) + _ = v7 + tmp8 := checkDerefVar(glojure_DOT_core_reduce1) + tmp9 := checkDerefVar(glojure_DOT_core_min) + tmp10 := checkDerefVar(glojure_DOT_core_min) + tmp11 := lang.Apply(tmp10, []any{v5, v6}) + tmp12 := lang.Apply(tmp8, []any{tmp9, tmp11, v7}) + return tmp12 + } + }) + tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 := ns.InternWithValue(tmp0, tmp4, true) + if tmp0.Meta() != nil { + tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // min-key + { + tmp0 := lang.NewSymbol("min-key").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Returns the x for which (k x), a number, is least.\n\n If there are multiple such xs, the last one is returned.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5033), lang.NewKeyword("end-line"), int(5033))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + return v4 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(glojure_DOT_core__LT_) + tmp8 := lang.Apply(v3, []any{v4}) + tmp9 := lang.Apply(v3, []any{v5}) + tmp10 := lang.Apply(tmp7, []any{tmp8, tmp9}) + if lang.IsTruthy(tmp10) { + tmp6 = v4 + } else { + tmp6 = v5 + } + return tmp6 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any + { // let + // let binding "kx" + tmp8 := lang.Apply(v3, []any{v4}) + var v9 any = tmp8 + _ = v9 + // let binding "ky" + tmp10 := lang.Apply(v3, []any{v5}) + var v11 any = tmp10 + _ = v11 + // let binding "vec__58" + var tmp12 any + tmp13 := checkDerefVar(glojure_DOT_core__LT_) + tmp14 := lang.Apply(tmp13, []any{v9, v11}) + if lang.IsTruthy(tmp14) { + tmp15 := lang.NewVector(v4, v9) + tmp16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5043), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(5043), lang.NewKeyword("end-column"), int(36)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp12 = tmp17 + } else { + tmp18 := lang.NewVector(v5, v11) + tmp19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5043), lang.NewKeyword("column"), int(38), lang.NewKeyword("end-line"), int(5043), lang.NewKeyword("end-column"), int(43)) + tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp12 = tmp20 + } + var v21 any = tmp12 + _ = v21 + // let binding "v" + tmp22 := checkDerefVar(glojure_DOT_core_nth) + tmp23 := lang.Apply(tmp22, []any{v21, int64(0), nil}) + var v24 any = tmp23 + _ = v24 + // let binding "kv" + tmp25 := checkDerefVar(glojure_DOT_core_nth) + tmp26 := lang.Apply(tmp25, []any{v21, int64(1), nil}) + var v27 any = tmp26 + _ = v27 + var tmp28 any + { // let + // let binding "v" + var v29 any = v24 + _ = v29 + // let binding "kv" + var v30 any = v27 + _ = v30 + // let binding "more" + var v31 any = v6 + _ = v31 + for { + var tmp32 any + if lang.IsTruthy(v31) { + var tmp33 any + { // let + // let binding "w" + tmp34 := checkDerefVar(glojure_DOT_core_first) + tmp35 := lang.Apply(tmp34, []any{v31}) + var v36 any = tmp35 + _ = v36 + // let binding "kw" + tmp37 := lang.Apply(v3, []any{v36}) + var v38 any = tmp37 + _ = v38 + var tmp39 any + tmp40 := checkDerefVar(glojure_DOT_core__LT__EQ_) + tmp41 := lang.Apply(tmp40, []any{v38, v30}) + if lang.IsTruthy(tmp41) { + var tmp42 any = v36 + var tmp43 any = v38 + tmp45 := checkDerefVar(glojure_DOT_core_next) + tmp46 := lang.Apply(tmp45, []any{v31}) + var tmp44 any = tmp46 + v29 = tmp42 + v30 = tmp43 + v31 = tmp44 + continue + } else { + var tmp47 any = v29 + var tmp48 any = v30 + tmp50 := checkDerefVar(glojure_DOT_core_next) + tmp51 := lang.Apply(tmp50, []any{v31}) + var tmp49 any = tmp51 + v29 = tmp47 + v30 = tmp48 + v31 = tmp49 + continue + } + tmp33 = tmp39 + } // end let + tmp32 = tmp33 + } else { + tmp32 = v29 + } + tmp28 = tmp32 + break + } + } // end let + tmp7 = tmp28 + } // end let + return tmp7 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // mix-collection-hash + { + tmp0 := lang.NewSymbol("mix-collection-hash").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("hash-basis"), lang.NewSymbol("count"))), lang.NewKeyword("doc"), "Mix final collection hash for ordered or unordered collections.\n hash-basis is the combined collection hash, count is the number\n of elements included in the basis. Note this is the hash code\n consistent with =, different from .hashCode.\n See http://glojure.org/data_structures#hash for full algorithms.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5199), lang.NewKeyword("end-line"), int(5199))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(nil, []any{v3, v4}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // mk-bound-fn + { + tmp0 := lang.NewSymbol("mk-bound-fn").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5127), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(5127), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sc"), lang.NewSymbol("test"), lang.NewSymbol("key"))), lang.NewKeyword("private"), true, lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v7 := args[0] + _ = v7 + tmp8, ok := lang.FieldOrMethod(v3, "comparator") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "comparator"))) + } + var tmp9 any + switch reflect.TypeOf(tmp8).Kind() { + case reflect.Func: + tmp9 = lang.Apply(tmp8, nil) + default: + tmp9 = tmp8 + } + tmp10, _ := lang.FieldOrMethod(v3, "entryKey") + if reflect.TypeOf(tmp10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("entryKey is not a function"))) + } + tmp11 := lang.Apply(tmp10, []any{v7}) + tmp12, _ := lang.FieldOrMethod(tmp9, "compare") + if reflect.TypeOf(tmp12).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("compare is not a function"))) + } + tmp13 := lang.Apply(tmp12, []any{tmp11, v5}) + tmp14 := lang.Apply(v4, []any{tmp13, int64(0)}) + return tmp14 + }) + tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5130), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(5131), lang.NewKeyword("end-column"), int(64)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp8 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // mod + { + tmp0 := lang.NewSymbol("mod").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"), lang.NewSymbol("div"))), lang.NewKeyword("doc"), "Modulus of num and div. Truncates toward negative infinity.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3567), lang.NewKeyword("end-line"), int(3567))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 any + { // let + // let binding "m" + tmp6 := checkDerefVar(glojure_DOT_core_rem) + tmp7 := lang.Apply(tmp6, []any{v3, v4}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + var tmp10 any + { // let + // let binding "or__0__auto__" + tmp11 := checkDerefVar(glojure_DOT_core_zero_QMARK_) + tmp12 := lang.Apply(tmp11, []any{v8}) + var v13 any = tmp12 + _ = v13 + var tmp14 any + if lang.IsTruthy(v13) { + tmp14 = v13 + } else { + tmp15 := checkDerefVar(glojure_DOT_core__EQ_) + tmp16 := checkDerefVar(glojure_DOT_core_pos_QMARK_) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(glojure_DOT_core_pos_QMARK_) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp14 = tmp20 + } + tmp10 = tmp14 + } // end let + if lang.IsTruthy(tmp10) { + tmp9 = v8 + } else { + tmp11 := checkDerefVar(glojure_DOT_core__PLUS_) + tmp12 := lang.Apply(tmp11, []any{v8, v4}) + tmp9 = tmp12 + } + tmp5 = tmp9 + } // end let + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // name + { + tmp1 := reflect.TypeOf("") + tmp0 := lang.NewSymbol("name").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns the name String of a string, symbol or keyword.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1585), lang.NewKeyword("end-line"), int(1585))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(glojure_DOT_core_string_QMARK_) + tmp7 := lang.Apply(tmp6, []any{v4}) + if lang.IsTruthy(tmp7) { + tmp5 = v4 + } else { + tmp8, _ := lang.FieldOrMethod(v4, "Name") + if reflect.TypeOf(tmp8).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Name is not a function"))) + } + tmp9 := lang.Apply(tmp8, []any{}) + tmp5 = tmp9 + } + return tmp5 + }) + tmp4 := reflect.TypeOf("") + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // namespace + { + tmp1 := reflect.TypeOf("") + tmp0 := lang.NewSymbol("namespace").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns the namespace String of a symbol or keyword, or nil if not present.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1593), lang.NewKeyword("end-line"), int(1593))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5, _ := lang.FieldOrMethod(v4, "Namespace") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Namespace is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{}) + return tmp6 + }) + tmp4 := reflect.TypeOf("") + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // nary-inline + { + tmp0 := lang.NewSymbol("nary-inline").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(948), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(948), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("op")), lang.NewVector(lang.NewSymbol("op"), lang.NewSymbol("unchecked-op"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_nary_inline) + tmp5 := lang.Apply(tmp4, []any{v3, v3}) + return tmp5 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v6 := args[0] + _ = v6 + var tmp7 any + { // let + // let binding "op" + var tmp8 any + tmp9 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + if lang.IsTruthy(tmp9) { + tmp8 = v4 + } else { + tmp8 = v3 + } + var v10 any = tmp8 + _ = v10 + tmp11 := checkDerefVar(glojure_DOT_core_seq) + tmp12 := checkDerefVar(glojure_DOT_core_concat) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol(".")}) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := checkDerefVar(glojure_DOT_core_seq) + tmp19 := checkDerefVar(glojure_DOT_core_concat) + tmp20 := checkDerefVar(glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{v10}) + tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v6}) + tmp24 := lang.Apply(tmp19, []any{tmp21, tmp23}) + tmp25 := lang.Apply(tmp18, []any{tmp24}) + tmp26 := lang.Apply(tmp17, []any{tmp25}) + tmp27 := lang.Apply(tmp12, []any{tmp14, tmp16, tmp26}) + tmp28 := lang.Apply(tmp11, []any{tmp27}) + tmp7 = tmp28 + } // end let + return tmp7 + case 2: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + var tmp8 any + { // let + // let binding "op" + var tmp9 any + tmp10 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + if lang.IsTruthy(tmp10) { + tmp9 = v4 + } else { + tmp9 = v3 + } + var v11 any = tmp9 + _ = v11 + tmp12 := checkDerefVar(glojure_DOT_core_seq) + tmp13 := checkDerefVar(glojure_DOT_core_concat) + tmp14 := checkDerefVar(glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol(".")}) + tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp19 := checkDerefVar(glojure_DOT_core_seq) + tmp20 := checkDerefVar(glojure_DOT_core_concat) + tmp21 := checkDerefVar(glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v11}) + tmp23 := checkDerefVar(glojure_DOT_core_list) + tmp24 := lang.Apply(tmp23, []any{v6}) + tmp25 := checkDerefVar(glojure_DOT_core_list) + tmp26 := lang.Apply(tmp25, []any{v7}) + tmp27 := lang.Apply(tmp20, []any{tmp22, tmp24, tmp26}) + tmp28 := lang.Apply(tmp19, []any{tmp27}) + tmp29 := lang.Apply(tmp18, []any{tmp28}) + tmp30 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp29}) + tmp31 := lang.Apply(tmp12, []any{tmp30}) + tmp8 = tmp31 + } // end let + return tmp8 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + var v8 any = lang.NewList(args[2:]...) + _ = v8 + var tmp9 any + { // let + // let binding "op" + var tmp10 any + tmp11 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + if lang.IsTruthy(tmp11) { + tmp10 = v4 + } else { + tmp10 = v3 + } + var v12 any = tmp10 + _ = v12 + tmp13 := checkDerefVar(glojure_DOT_core_reduce1) + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v15 := args[0] + _ = v15 + v16 := args[1] + _ = v16 + tmp17 := checkDerefVar(glojure_DOT_core_seq) + tmp18 := checkDerefVar(glojure_DOT_core_concat) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{lang.NewSymbol(".")}) + tmp21 := checkDerefVar(glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp23 := checkDerefVar(glojure_DOT_core_list) + tmp24 := checkDerefVar(glojure_DOT_core_seq) + tmp25 := checkDerefVar(glojure_DOT_core_concat) + tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := checkDerefVar(glojure_DOT_core_list) + tmp29 := lang.Apply(tmp28, []any{v15}) + tmp30 := checkDerefVar(glojure_DOT_core_list) + tmp31 := lang.Apply(tmp30, []any{v16}) + tmp32 := lang.Apply(tmp25, []any{tmp27, tmp29, tmp31}) + tmp33 := lang.Apply(tmp24, []any{tmp32}) + tmp34 := lang.Apply(tmp23, []any{tmp33}) + tmp35 := lang.Apply(tmp18, []any{tmp20, tmp22, tmp34}) + tmp36 := lang.Apply(tmp17, []any{tmp35}) + return tmp36 + }) + tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp17 := checkDerefVar(glojure_DOT_core_seq) + tmp18 := checkDerefVar(glojure_DOT_core_concat) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{lang.NewSymbol(".")}) + tmp21 := checkDerefVar(glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp23 := checkDerefVar(glojure_DOT_core_list) + tmp24 := checkDerefVar(glojure_DOT_core_seq) + tmp25 := checkDerefVar(glojure_DOT_core_concat) + tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := checkDerefVar(glojure_DOT_core_list) + tmp29 := lang.Apply(tmp28, []any{v6}) + tmp30 := checkDerefVar(glojure_DOT_core_list) + tmp31 := lang.Apply(tmp30, []any{v7}) + tmp32 := lang.Apply(tmp25, []any{tmp27, tmp29, tmp31}) + tmp33 := lang.Apply(tmp24, []any{tmp32}) + tmp34 := lang.Apply(tmp23, []any{tmp33}) + tmp35 := lang.Apply(tmp18, []any{tmp20, tmp22, tmp34}) + tmp36 := lang.Apply(tmp17, []any{tmp35}) + tmp37 := lang.Apply(tmp13, []any{tmp16, tmp36, v8}) + tmp9 = tmp37 + } // end let + return tmp9 + } + }) + tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // nat-int? + { + tmp0 := lang.NewSymbol("nat-int?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a non-negative fixed precision integer", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1415), lang.NewKeyword("end-line"), int(1415))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + { // let + // let binding "and__0__auto__" + tmp5 := checkDerefVar(glojure_DOT_core_int_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + if lang.IsTruthy(v7) { + tmp9 := checkDerefVar(glojure_DOT_core_not) + tmp10 := checkDerefVar(glojure_DOT_core_neg_QMARK_) + tmp11 := lang.Apply(tmp10, []any{v3}) + tmp12 := lang.Apply(tmp9, []any{tmp11}) + tmp8 = tmp12 + } else { + tmp8 = v7 + } + tmp4 = tmp8 + } // end let + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // neg-int? + { + tmp0 := lang.NewSymbol("neg-int?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a negative fixed precision integer", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1409), lang.NewKeyword("end-line"), int(1409))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + { // let + // let binding "and__0__auto__" + tmp5 := checkDerefVar(glojure_DOT_core_int_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + if lang.IsTruthy(v7) { + tmp9 := checkDerefVar(glojure_DOT_core_neg_QMARK_) + tmp10 := lang.Apply(tmp9, []any{v3}) + tmp8 = tmp10 + } else { + tmp8 = v7 + } + tmp4 = tmp8 + } // end let + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // neg? + { + var tmp1 lang.FnFunc + { // function neg?__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := checkDerefVar(glojure_DOT_core_seq) + tmp12 := checkDerefVar(glojure_DOT_core_concat) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/IsNeg")}) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("neg?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns true if num is less than zero, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1259), lang.NewKeyword("end-line"), int(1259))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "IsNeg") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("IsNeg is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // newline + { + tmp0 := lang.NewSymbol("newline").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Writes a platform-specific newline to *out*", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3698), lang.NewKeyword("end-line"), int(3698))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + tmp3 := checkDerefVar(glojure_DOT_core__STAR_out_STAR_) + tmp4 := checkDerefVar(glojure_DOT_core_system_newline) + tmp5 := lang.Apply(lang.AppendWriter, []any{tmp3, tmp4}) + _ = tmp5 + return nil + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // next + { + tmp1 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() + tmp0 := lang.NewSymbol("next").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a seq of the items after the first. Calls seq on its\n argument. If there are no more items, returns nil.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(55), lang.NewKeyword("end-line"), int(61))).(*lang.Symbol) + var tmp3 lang.FnFunc + { // function next + var v4 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + tmp6 := lang.Apply(lang.Next, []any{v5}) + return tmp6 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(61), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(61), lang.NewKeyword("end-column"), int(77))).(lang.FnFunc) + v4 = tmp3 + _ = v4 + } + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // nfirst + { + tmp0 := lang.NewSymbol("nfirst").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Same as (next (first x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(105), lang.NewKeyword("end-line"), int(109))).(*lang.Symbol) + var tmp2 lang.FnFunc + { // function nfirst + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_next) + tmp6 := checkDerefVar(glojure_DOT_core_first) + tmp7 := lang.Apply(tmp6, []any{v4}) + tmp8 := lang.Apply(tmp5, []any{tmp7}) + return tmp8 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(109), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(109), lang.NewKeyword("end-column"), int(49))).(lang.FnFunc) + v3 = tmp2 + _ = v3 + } + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // nil? + { + tmp1 := reflect.TypeOf(false) + var tmp2 lang.FnFunc + { // function nil?__inliner + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_list) + tmp6 := lang.Apply(tmp5, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Identical"), v4, nil}) + return tmp6 + }) + v3 = tmp2 + _ = v3 + } + tmp0 := lang.NewSymbol("nil?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp2, lang.NewKeyword("doc"), "Returns true if x is nil, false otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(435), lang.NewKeyword("end-line"), int(435))).(*lang.Symbol) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + tmp6 := lang.Apply(lang.IsNil, []any{v5}) + return tmp6 + }) + tmp5 := reflect.TypeOf(false) + tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp5)).(lang.FnFunc) + tmp3 := ns.InternWithValue(tmp0, tmp4, true) + if tmp0.Meta() != nil { + tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // nnext + { + tmp0 := lang.NewSymbol("nnext").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Same as (next (next x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(119), lang.NewKeyword("end-line"), int(123))).(*lang.Symbol) + var tmp2 lang.FnFunc + { // function nnext + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_next) + tmp6 := checkDerefVar(glojure_DOT_core_next) + tmp7 := lang.Apply(tmp6, []any{v4}) + tmp8 := lang.Apply(tmp5, []any{tmp7}) + return tmp8 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(123), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(123), lang.NewKeyword("end-column"), int(46))).(lang.FnFunc) + v3 = tmp2 + _ = v3 + } + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // normalize-slurp-opts + { + tmp0 := lang.NewSymbol("normalize-slurp-opts").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6974), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(6974), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("opts"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(glojure_DOT_core_string_QMARK_) + tmp6 := checkDerefVar(glojure_DOT_core_first) + tmp7 := lang.Apply(tmp6, []any{v3}) + tmp8 := lang.Apply(tmp5, []any{tmp7}) + if lang.IsTruthy(tmp8) { + tmp9 := checkDerefVar(glojure_DOT_core_println) + tmp10 := lang.Apply(tmp9, []any{"WARNING: (slurp f enc) is deprecated, use (slurp f :encoding enc)."}) + _ = tmp10 + tmp11 := checkDerefVar(glojure_DOT_core_first) + tmp12 := lang.Apply(tmp11, []any{v3}) + tmp13 := lang.NewVector(lang.NewKeyword("encoding"), tmp12) + tmp14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6979), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(6979), lang.NewKeyword("end-column"), int(30)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp4 = tmp15 + } else { + tmp4 = v3 + } + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // not + { + tmp1 := reflect.TypeOf(false) + tmp0 := lang.NewSymbol("not").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is logical false, false otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(523), lang.NewKeyword("end-line"), int(523))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + var tmp5 any + if lang.IsTruthy(v4) { + tmp5 = false + } else { + tmp5 = true + } + return tmp5 + }) + tmp4 := reflect.TypeOf(false) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // not-any? + { + tmp1 := reflect.TypeOf(false) + tmp0 := lang.NewSymbol("not-any?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns false if (pred x) is logical true for any x in coll,\n else true.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(2696), lang.NewKeyword("end-line"), int(2701))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp4 := lang.Apply(closed36, nil) + tmp5 := lang.Apply(closed35, []any{tmp4}) + return tmp5 + case 1: + v4 := args[0] + _ = v4 + tmp5 := lang.Apply(closed36, []any{v4}) + tmp6 := lang.Apply(closed35, []any{tmp5}) + return tmp6 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6 := lang.Apply(closed36, []any{v4, v5}) + tmp7 := lang.Apply(closed35, []any{tmp6}) + return tmp7 + case 3: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := args[2] + _ = v6 + tmp7 := lang.Apply(closed36, []any{v4, v5, v6}) + tmp8 := lang.Apply(closed35, []any{tmp7}) + return tmp8 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := args[2] + _ = v6 + var v7 any = lang.NewList(args[3:]...) + _ = v7 + tmp8 := checkDerefVar(glojure_DOT_core_apply) + tmp9 := lang.Apply(tmp8, []any{closed36, v4, v5, v6, v7}) + tmp10 := lang.Apply(closed35, []any{tmp9}) + return tmp10 + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2559), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2564), lang.NewKeyword("end-column"), int(49))).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // not-empty + { + tmp0 := lang.NewSymbol("not-empty").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "If coll is empty, returns nil, else coll", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5516), lang.NewKeyword("end-line"), int(5516))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(glojure_DOT_core_seq) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + tmp4 = v3 + } else { + } + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // not-every? + { + tmp1 := reflect.TypeOf(false) + tmp0 := lang.NewSymbol("not-every?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns false if (pred x) is logical true for every x in\n coll, else true.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(2677), lang.NewKeyword("end-line"), int(2682))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp4 := lang.Apply(closed37, nil) + tmp5 := lang.Apply(closed35, []any{tmp4}) + return tmp5 + case 1: + v4 := args[0] + _ = v4 + tmp5 := lang.Apply(closed37, []any{v4}) + tmp6 := lang.Apply(closed35, []any{tmp5}) + return tmp6 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6 := lang.Apply(closed37, []any{v4, v5}) + tmp7 := lang.Apply(closed35, []any{tmp6}) + return tmp7 + case 3: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := args[2] + _ = v6 + tmp7 := lang.Apply(closed37, []any{v4, v5, v6}) + tmp8 := lang.Apply(closed35, []any{tmp7}) + return tmp8 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := args[2] + _ = v6 + var v7 any = lang.NewList(args[3:]...) + _ = v7 + tmp8 := checkDerefVar(glojure_DOT_core_apply) + tmp9 := lang.Apply(tmp8, []any{closed37, v4, v5, v6, v7}) + tmp10 := lang.Apply(closed35, []any{tmp9}) + return tmp10 + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2559), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2564), lang.NewKeyword("end-column"), int(49))).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // not= + { + tmp1 := reflect.TypeOf(false) + tmp0 := lang.NewSymbol("not=").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Same as (not (= obj1 obj2))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(812), lang.NewKeyword("end-line"), int(812))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + return false + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6 := checkDerefVar(glojure_DOT_core_not) + tmp7 := checkDerefVar(glojure_DOT_core__EQ_) + tmp8 := lang.Apply(tmp7, []any{v4, v5}) + tmp9 := lang.Apply(tmp6, []any{tmp8}) + return tmp9 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_not) + tmp8 := checkDerefVar(glojure_DOT_core_apply) + tmp9 := checkDerefVar(glojure_DOT_core__EQ_) + tmp10 := lang.Apply(tmp8, []any{tmp9, v4, v5, v6}) + tmp11 := lang.Apply(tmp7, []any{tmp10}) + return tmp11 + } + }) + tmp4 := reflect.TypeOf(false) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ns + { + tmp0 := lang.NewSymbol("ns").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("docstring?"), lang.NewSymbol("attr-map?"), lang.NewSymbol("references*"))), lang.NewKeyword("doc"), "Sets *ns* to the namespace named by name (unevaluated), creating it\n if needed. references can be zero or more of: (:refer-glojure ...)\n (:require ...) (:use ...) (:import ...) (:load ...) (:gen-class)\n with the syntax of refer-glojure/require/use/import/load/gen-class\n respectively, except the arguments are unevaluated and need not be\n quoted. (:gen-class ...), when supplied, defaults to :name\n corresponding to the ns name, :main true, :impl-ns same as ns, and\n :init-impl-ns true. All options of gen-class are\n supported. The :gen-class directive is ignored when not\n compiling. If :gen-class is not supplied, when compiled only an\n nsname__init.class will be generated. If :refer-glojure is not used, a\n default (refer 'glojure.core) is used. Use of ns is preferred to\n individual calls to in-ns/require/use/import:\n\n (ns foo.bar\n (:refer-glojure :exclude [ancestors printf])\n (:require (glojure.contrib sql combinatorics))\n (:use (my.lib this that))\n (:import (java.util Date Timer Random)\n (java.sql Connection Statement)))", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5742), lang.NewKeyword("end-line"), int(5742))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any + { // let + // let binding "process-reference" + var tmp8 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v9 := args[0] + _ = v9 + var tmp10 any + { // let + // let binding "vec__107" + var v11 any = v9 + _ = v11 + // let binding "seq__108" + tmp12 := checkDerefVar(glojure_DOT_core_seq) + tmp13 := lang.Apply(tmp12, []any{v11}) + var v14 any = tmp13 + _ = v14 + // let binding "first__109" + tmp15 := checkDerefVar(glojure_DOT_core_first) + tmp16 := lang.Apply(tmp15, []any{v14}) + var v17 any = tmp16 + _ = v17 + // let binding "seq__108" + tmp18 := checkDerefVar(glojure_DOT_core_next) + tmp19 := lang.Apply(tmp18, []any{v14}) + var v20 any = tmp19 + _ = v20 + // let binding "kname" + var v21 any = v17 + _ = v21 + // let binding "args" + var v22 any = v20 + _ = v22 + tmp23 := checkDerefVar(glojure_DOT_core_seq) + tmp24 := checkDerefVar(glojure_DOT_core_concat) + tmp25 := checkDerefVar(glojure_DOT_core_list) + tmp26 := checkDerefVar(glojure_DOT_core_symbol) + tmp27 := checkDerefVar(glojure_DOT_core_name) + tmp28 := lang.Apply(tmp27, []any{v21}) + tmp29 := lang.Apply(tmp26, []any{"glojure.core", tmp28}) + tmp30 := lang.Apply(tmp25, []any{tmp29}) + tmp31 := checkDerefVar(glojure_DOT_core_map) + var tmp32 lang.FnFunc + tmp32 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v33 := args[0] + _ = v33 + tmp34 := checkDerefVar(glojure_DOT_core_list) + tmp35 := lang.Apply(tmp34, []any{lang.NewSymbol("quote"), v33}) + return tmp35 + }) + tmp33 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5769), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(5769), lang.NewKeyword("end-column"), int(36)) + tmp34, err := lang.WithMeta(tmp32, tmp33.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp35 := lang.Apply(tmp31, []any{tmp34, v22}) + tmp36 := lang.Apply(tmp24, []any{tmp30, tmp35}) + tmp37 := lang.Apply(tmp23, []any{tmp36}) + tmp10 = tmp37 + } // end let + return tmp10 + }) + tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5767), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(5769), lang.NewKeyword("end-column"), int(44)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v11 any = tmp10 + _ = v11 + // let binding "docstring" + var tmp12 any + tmp13 := checkDerefVar(glojure_DOT_core_string_QMARK_) + tmp14 := checkDerefVar(glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v6}) + tmp16 := lang.Apply(tmp13, []any{tmp15}) + if lang.IsTruthy(tmp16) { + tmp17 := checkDerefVar(glojure_DOT_core_first) + tmp18 := lang.Apply(tmp17, []any{v6}) + tmp12 = tmp18 + } else { + } + var v19 any = tmp12 + _ = v19 + // let binding "references" + var tmp20 any + if lang.IsTruthy(v19) { + tmp21 := checkDerefVar(glojure_DOT_core_next) + tmp22 := lang.Apply(tmp21, []any{v6}) + tmp20 = tmp22 + } else { + tmp20 = v6 + } + var v23 any = tmp20 + _ = v23 + // let binding "name" + var tmp24 any + if lang.IsTruthy(v19) { + tmp25 := checkDerefVar(glojure_DOT_core_vary_meta) + tmp26 := checkDerefVar(glojure_DOT_core_assoc) + tmp27 := lang.Apply(tmp25, []any{v5, tmp26, lang.NewKeyword("doc"), v19}) + tmp24 = tmp27 + } else { + tmp24 = v5 + } + var v28 any = tmp24 + _ = v28 + // let binding "metadata" + var tmp29 any + tmp30 := checkDerefVar(glojure_DOT_core_map_QMARK_) + tmp31 := checkDerefVar(glojure_DOT_core_first) + tmp32 := lang.Apply(tmp31, []any{v23}) + tmp33 := lang.Apply(tmp30, []any{tmp32}) + if lang.IsTruthy(tmp33) { + tmp34 := checkDerefVar(glojure_DOT_core_first) + tmp35 := lang.Apply(tmp34, []any{v23}) + tmp29 = tmp35 + } else { + } + var v36 any = tmp29 + _ = v36 + // let binding "references" + var tmp37 any + if lang.IsTruthy(v36) { + tmp38 := checkDerefVar(glojure_DOT_core_next) + tmp39 := lang.Apply(tmp38, []any{v23}) + tmp37 = tmp39 + } else { + tmp37 = v23 + } + var v40 any = tmp37 + _ = v40 + // let binding "name" + var tmp41 any + if lang.IsTruthy(v36) { + tmp42 := checkDerefVar(glojure_DOT_core_vary_meta) + tmp43 := checkDerefVar(glojure_DOT_core_merge) + tmp44 := lang.Apply(tmp42, []any{v28, tmp43, v36}) + tmp41 = tmp44 + } else { + tmp41 = v28 + } + var v45 any = tmp41 + _ = v45 + // let binding "gen-class-clause" + tmp46 := checkDerefVar(glojure_DOT_core_first) + tmp47 := checkDerefVar(glojure_DOT_core_filter) + var tmp48 lang.FnFunc + tmp48 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v49 := args[0] + _ = v49 + tmp50 := checkDerefVar(glojure_DOT_core__EQ_) + tmp51 := checkDerefVar(glojure_DOT_core_first) + tmp52 := lang.Apply(tmp51, []any{v49}) + tmp53 := lang.Apply(tmp50, []any{lang.NewKeyword("gen-class"), tmp52}) + return tmp53 + }) + tmp49 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5780), lang.NewKeyword("column"), int(41), lang.NewKeyword("end-line"), int(5780), lang.NewKeyword("end-column"), int(65)) + tmp50, err := lang.WithMeta(tmp48, tmp49.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp51 := lang.Apply(tmp47, []any{tmp50, v40}) + tmp52 := lang.Apply(tmp46, []any{tmp51}) + var v53 any = tmp52 + _ = v53 + // let binding "gen-class-call" + var tmp54 any + if lang.IsTruthy(v53) { + tmp55 := checkDerefVar(glojure_DOT_core_list_STAR_) + tmp56 := checkDerefVar(glojure_DOT_core_str) + tmp57 := lang.Apply(tmp56, []any{v45}) + tmp58, _ := lang.FieldOrMethod(tmp57, "replace") + if reflect.TypeOf(tmp58).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("replace is not a function"))) + } + tmp59 := lang.Apply(tmp58, []any{lang.NewChar(45), lang.NewChar(95)}) + tmp60 := checkDerefVar(glojure_DOT_core_next) + tmp61 := lang.Apply(tmp60, []any{v53}) + tmp62 := lang.Apply(tmp55, []any{lang.NewSymbol("glojure.core/gen-class"), lang.NewKeyword("name"), tmp59, lang.NewKeyword("impl-ns"), v45, lang.NewKeyword("main"), true, tmp61}) + tmp54 = tmp62 + } else { + } + var v63 any = tmp54 + _ = v63 + // let binding "references" + tmp64 := checkDerefVar(glojure_DOT_core_remove) + var tmp65 lang.FnFunc + tmp65 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v66 := args[0] + _ = v66 + tmp67 := checkDerefVar(glojure_DOT_core__EQ_) + tmp68 := checkDerefVar(glojure_DOT_core_first) + tmp69 := lang.Apply(tmp68, []any{v66}) + tmp70 := lang.Apply(tmp67, []any{lang.NewKeyword("gen-class"), tmp69}) + return tmp70 + }) + tmp66 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5784), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(5784), lang.NewKeyword("end-column"), int(52)) + tmp67, err := lang.WithMeta(tmp65, tmp66.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp68 := lang.Apply(tmp64, []any{tmp67, v40}) + var v69 any = tmp68 + _ = v69 + // let binding "name-metadata" + tmp70 := checkDerefVar(glojure_DOT_core_meta) + tmp71 := lang.Apply(tmp70, []any{v45}) + var v72 any = tmp71 + _ = v72 + tmp73 := checkDerefVar(glojure_DOT_core_seq) + tmp74 := checkDerefVar(glojure_DOT_core_concat) + tmp75 := checkDerefVar(glojure_DOT_core_list) + tmp76 := lang.Apply(tmp75, []any{lang.NewSymbol("do")}) + tmp77 := checkDerefVar(glojure_DOT_core_list) + tmp78 := checkDerefVar(glojure_DOT_core_seq) + tmp79 := checkDerefVar(glojure_DOT_core_concat) + tmp80 := checkDerefVar(glojure_DOT_core_list) + tmp81 := lang.Apply(tmp80, []any{lang.NewSymbol("glojure.core/in-ns")}) + tmp82 := checkDerefVar(glojure_DOT_core_list) + tmp83 := checkDerefVar(glojure_DOT_core_seq) + tmp84 := checkDerefVar(glojure_DOT_core_concat) + tmp85 := checkDerefVar(glojure_DOT_core_list) + tmp86 := lang.Apply(tmp85, []any{lang.NewSymbol("quote")}) + tmp87 := checkDerefVar(glojure_DOT_core_list) + tmp88 := lang.Apply(tmp87, []any{v45}) + tmp89 := lang.Apply(tmp84, []any{tmp86, tmp88}) + tmp90 := lang.Apply(tmp83, []any{tmp89}) + tmp91 := lang.Apply(tmp82, []any{tmp90}) + tmp92 := lang.Apply(tmp79, []any{tmp81, tmp91}) + tmp93 := lang.Apply(tmp78, []any{tmp92}) + tmp94 := lang.Apply(tmp77, []any{tmp93}) + var tmp95 any + if lang.IsTruthy(v72) { + tmp96 := checkDerefVar(glojure_DOT_core_seq) + tmp97 := checkDerefVar(glojure_DOT_core_concat) + tmp98 := checkDerefVar(glojure_DOT_core_list) + tmp99 := checkDerefVar(glojure_DOT_core_seq) + tmp100 := checkDerefVar(glojure_DOT_core_concat) + tmp101 := checkDerefVar(glojure_DOT_core_list) + tmp102 := lang.Apply(tmp101, []any{lang.NewSymbol(".ResetMeta")}) + tmp103 := checkDerefVar(glojure_DOT_core_list) + tmp104 := checkDerefVar(glojure_DOT_core_seq) + tmp105 := checkDerefVar(glojure_DOT_core_concat) + tmp106 := checkDerefVar(glojure_DOT_core_list) + tmp107 := lang.Apply(tmp106, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.FindNamespace")}) + tmp108 := checkDerefVar(glojure_DOT_core_list) + tmp109 := checkDerefVar(glojure_DOT_core_seq) + tmp110 := checkDerefVar(glojure_DOT_core_concat) + tmp111 := checkDerefVar(glojure_DOT_core_list) + tmp112 := lang.Apply(tmp111, []any{lang.NewSymbol("quote")}) + tmp113 := checkDerefVar(glojure_DOT_core_list) + tmp114 := lang.Apply(tmp113, []any{v45}) + tmp115 := lang.Apply(tmp110, []any{tmp112, tmp114}) + tmp116 := lang.Apply(tmp109, []any{tmp115}) + tmp117 := lang.Apply(tmp108, []any{tmp116}) + tmp118 := lang.Apply(tmp105, []any{tmp107, tmp117}) + tmp119 := lang.Apply(tmp104, []any{tmp118}) + tmp120 := lang.Apply(tmp103, []any{tmp119}) + tmp121 := checkDerefVar(glojure_DOT_core_list) + tmp122 := lang.Apply(tmp121, []any{v72}) + tmp123 := lang.Apply(tmp100, []any{tmp102, tmp120, tmp122}) + tmp124 := lang.Apply(tmp99, []any{tmp123}) + tmp125 := lang.Apply(tmp98, []any{tmp124}) + tmp126 := lang.Apply(tmp97, []any{tmp125}) + tmp127 := lang.Apply(tmp96, []any{tmp126}) + tmp95 = tmp127 + } else { + } + tmp128 := checkDerefVar(glojure_DOT_core_list) + tmp129 := checkDerefVar(glojure_DOT_core_seq) + tmp130 := checkDerefVar(glojure_DOT_core_concat) + tmp131 := checkDerefVar(glojure_DOT_core_list) + tmp132 := lang.Apply(tmp131, []any{lang.NewSymbol("glojure.core/with-loading-context")}) + var tmp133 any + if lang.IsTruthy(v63) { + tmp134 := checkDerefVar(glojure_DOT_core_list) + tmp135 := lang.Apply(tmp134, []any{v63}) + tmp133 = tmp135 + } else { + } + var tmp136 any + var tmp137 any + { // let + // let binding "and__0__auto__" + tmp138 := checkDerefVar(glojure_DOT_core_not_EQ_) + tmp139 := lang.Apply(tmp138, []any{v45, lang.NewSymbol("glojure.core")}) + var v140 any = tmp139 + _ = v140 + var tmp141 any + if lang.IsTruthy(v140) { + tmp142 := checkDerefVar(glojure_DOT_core_not_any_QMARK_) + var tmp143 lang.FnFunc + tmp143 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v144 := args[0] + _ = v144 + tmp145 := checkDerefVar(glojure_DOT_core__EQ_) + tmp146 := checkDerefVar(glojure_DOT_core_first) + tmp147 := lang.Apply(tmp146, []any{v144}) + tmp148 := lang.Apply(tmp145, []any{lang.NewKeyword("refer-glojure"), tmp147}) + return tmp148 + }) + tmp144 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5793), lang.NewKeyword("column"), int(58), lang.NewKeyword("end-line"), int(5793), lang.NewKeyword("end-column"), int(86)) + tmp145, err := lang.WithMeta(tmp143, tmp144.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp146 := lang.Apply(tmp142, []any{tmp145, v69}) + tmp141 = tmp146 + } else { + tmp141 = v140 + } + tmp137 = tmp141 + } // end let + if lang.IsTruthy(tmp137) { + tmp138 := checkDerefVar(glojure_DOT_core_seq) + tmp139 := checkDerefVar(glojure_DOT_core_concat) + tmp140 := checkDerefVar(glojure_DOT_core_list) + tmp141 := checkDerefVar(glojure_DOT_core_seq) + tmp142 := checkDerefVar(glojure_DOT_core_concat) + tmp143 := checkDerefVar(glojure_DOT_core_list) + tmp144 := lang.Apply(tmp143, []any{lang.NewSymbol("glojure.core/refer")}) + tmp145 := checkDerefVar(glojure_DOT_core_list) + tmp146 := checkDerefVar(glojure_DOT_core_seq) + tmp147 := checkDerefVar(glojure_DOT_core_concat) + tmp148 := checkDerefVar(glojure_DOT_core_list) + tmp149 := lang.Apply(tmp148, []any{lang.NewSymbol("quote")}) + tmp150 := checkDerefVar(glojure_DOT_core_list) + tmp151 := lang.Apply(tmp150, []any{lang.NewSymbol("glojure.core")}) + tmp152 := lang.Apply(tmp147, []any{tmp149, tmp151}) + tmp153 := lang.Apply(tmp146, []any{tmp152}) + tmp154 := lang.Apply(tmp145, []any{tmp153}) + tmp155 := lang.Apply(tmp142, []any{tmp144, tmp154}) + tmp156 := lang.Apply(tmp141, []any{tmp155}) + tmp157 := lang.Apply(tmp140, []any{tmp156}) + tmp158 := lang.Apply(tmp139, []any{tmp157}) + tmp159 := lang.Apply(tmp138, []any{tmp158}) + tmp136 = tmp159 + } else { + } + tmp160 := checkDerefVar(glojure_DOT_core_map) + tmp161 := lang.Apply(tmp160, []any{v11, v69}) + tmp162 := lang.Apply(tmp130, []any{tmp132, tmp133, tmp136, tmp161}) + tmp163 := lang.Apply(tmp129, []any{tmp162}) + tmp164 := lang.Apply(tmp128, []any{tmp163}) + tmp165 := checkDerefVar(glojure_DOT_core_list) + tmp166 := checkDerefVar(glojure_DOT_core_seq) + tmp167 := checkDerefVar(glojure_DOT_core_concat) + tmp168 := checkDerefVar(glojure_DOT_core_list) + tmp169 := lang.Apply(tmp168, []any{lang.NewSymbol("if")}) + tmp170 := checkDerefVar(glojure_DOT_core_list) + tmp171 := checkDerefVar(glojure_DOT_core_seq) + tmp172 := checkDerefVar(glojure_DOT_core_concat) + tmp173 := checkDerefVar(glojure_DOT_core_list) + tmp174 := lang.Apply(tmp173, []any{lang.NewSymbol(".Equals")}) + tmp175 := checkDerefVar(glojure_DOT_core_list) + tmp176 := checkDerefVar(glojure_DOT_core_seq) + tmp177 := checkDerefVar(glojure_DOT_core_concat) + tmp178 := checkDerefVar(glojure_DOT_core_list) + tmp179 := lang.Apply(tmp178, []any{lang.NewSymbol("quote")}) + tmp180 := checkDerefVar(glojure_DOT_core_list) + tmp181 := lang.Apply(tmp180, []any{v45}) + tmp182 := lang.Apply(tmp177, []any{tmp179, tmp181}) + tmp183 := lang.Apply(tmp176, []any{tmp182}) + tmp184 := lang.Apply(tmp175, []any{tmp183}) + tmp185 := checkDerefVar(glojure_DOT_core_list) + tmp186 := checkDerefVar(glojure_DOT_core_seq) + tmp187 := checkDerefVar(glojure_DOT_core_concat) + tmp188 := checkDerefVar(glojure_DOT_core_list) + tmp189 := lang.Apply(tmp188, []any{lang.NewSymbol("quote")}) + tmp190 := checkDerefVar(glojure_DOT_core_list) + tmp191 := lang.Apply(tmp190, []any{lang.NewSymbol("glojure.core")}) + tmp192 := lang.Apply(tmp187, []any{tmp189, tmp191}) + tmp193 := lang.Apply(tmp186, []any{tmp192}) + tmp194 := lang.Apply(tmp185, []any{tmp193}) + tmp195 := lang.Apply(tmp172, []any{tmp174, tmp184, tmp194}) + tmp196 := lang.Apply(tmp171, []any{tmp195}) + tmp197 := lang.Apply(tmp170, []any{tmp196}) + tmp198 := checkDerefVar(glojure_DOT_core_list) + tmp199 := lang.Apply(tmp198, []any{nil}) + tmp200 := checkDerefVar(glojure_DOT_core_list) + tmp201 := checkDerefVar(glojure_DOT_core_seq) + tmp202 := checkDerefVar(glojure_DOT_core_concat) + tmp203 := checkDerefVar(glojure_DOT_core_list) + tmp204 := lang.Apply(tmp203, []any{lang.NewSymbol("do")}) + tmp205 := checkDerefVar(glojure_DOT_core_list) + tmp206 := checkDerefVar(glojure_DOT_core_seq) + tmp207 := checkDerefVar(glojure_DOT_core_concat) + tmp208 := checkDerefVar(glojure_DOT_core_list) + tmp209 := lang.Apply(tmp208, []any{lang.NewSymbol("glojure.core/dosync")}) + tmp210 := checkDerefVar(glojure_DOT_core_list) + tmp211 := checkDerefVar(glojure_DOT_core_seq) + tmp212 := checkDerefVar(glojure_DOT_core_concat) + tmp213 := checkDerefVar(glojure_DOT_core_list) + tmp214 := lang.Apply(tmp213, []any{lang.NewSymbol("glojure.core/commute")}) + tmp215 := checkDerefVar(glojure_DOT_core_list) + tmp216 := checkDerefVar(glojure_DOT_core_seq) + tmp217 := checkDerefVar(glojure_DOT_core_concat) + tmp218 := checkDerefVar(glojure_DOT_core_list) + tmp219 := lang.Apply(tmp218, []any{lang.NewSymbol("glojure.core/deref")}) + tmp220 := checkDerefVar(glojure_DOT_core_list) + tmp221 := checkDerefVar(glojure_DOT_core_seq) + tmp222 := checkDerefVar(glojure_DOT_core_concat) + tmp223 := checkDerefVar(glojure_DOT_core_list) + tmp224 := lang.Apply(tmp223, []any{lang.NewSymbol("var")}) + tmp225 := checkDerefVar(glojure_DOT_core_list) + tmp226 := lang.Apply(tmp225, []any{lang.NewSymbol("glojure.core/*loaded-libs*")}) + tmp227 := lang.Apply(tmp222, []any{tmp224, tmp226}) + tmp228 := lang.Apply(tmp221, []any{tmp227}) + tmp229 := lang.Apply(tmp220, []any{tmp228}) + tmp230 := lang.Apply(tmp217, []any{tmp219, tmp229}) + tmp231 := lang.Apply(tmp216, []any{tmp230}) + tmp232 := lang.Apply(tmp215, []any{tmp231}) + tmp233 := checkDerefVar(glojure_DOT_core_list) + tmp234 := lang.Apply(tmp233, []any{lang.NewSymbol("glojure.core/conj")}) + tmp235 := checkDerefVar(glojure_DOT_core_list) + tmp236 := checkDerefVar(glojure_DOT_core_seq) + tmp237 := checkDerefVar(glojure_DOT_core_concat) + tmp238 := checkDerefVar(glojure_DOT_core_list) + tmp239 := lang.Apply(tmp238, []any{lang.NewSymbol("quote")}) + tmp240 := checkDerefVar(glojure_DOT_core_list) + tmp241 := lang.Apply(tmp240, []any{v45}) + tmp242 := lang.Apply(tmp237, []any{tmp239, tmp241}) + tmp243 := lang.Apply(tmp236, []any{tmp242}) + tmp244 := lang.Apply(tmp235, []any{tmp243}) + tmp245 := lang.Apply(tmp212, []any{tmp214, tmp232, tmp234, tmp244}) + tmp246 := lang.Apply(tmp211, []any{tmp245}) + tmp247 := lang.Apply(tmp210, []any{tmp246}) + tmp248 := lang.Apply(tmp207, []any{tmp209, tmp247}) + tmp249 := lang.Apply(tmp206, []any{tmp248}) + tmp250 := lang.Apply(tmp205, []any{tmp249}) + tmp251 := checkDerefVar(glojure_DOT_core_list) + tmp252 := lang.Apply(tmp251, []any{nil}) + tmp253 := lang.Apply(tmp202, []any{tmp204, tmp250, tmp252}) + tmp254 := lang.Apply(tmp201, []any{tmp253}) + tmp255 := lang.Apply(tmp200, []any{tmp254}) + tmp256 := lang.Apply(tmp167, []any{tmp169, tmp197, tmp199, tmp255}) + tmp257 := lang.Apply(tmp166, []any{tmp256}) + tmp258 := lang.Apply(tmp165, []any{tmp257}) + tmp259 := lang.Apply(tmp74, []any{tmp76, tmp94, tmp95, tmp164, tmp258}) + tmp260 := lang.Apply(tmp73, []any{tmp259}) + tmp7 = tmp260 + } // end let + return tmp7 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ns-aliases + { + tmp0 := lang.NewSymbol("ns-aliases").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of the aliases for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4273), lang.NewKeyword("end-line"), int(4273))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_the_ns) + tmp5 := lang.Apply(tmp4, []any{v3}) + tmp6, ok := lang.FieldOrMethod(tmp5, "getAliases") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp5, "getAliases"))) + } + var tmp7 any + switch reflect.TypeOf(tmp6).Kind() { + case reflect.Func: + tmp7 = lang.Apply(tmp6, nil) + default: + tmp7 = tmp6 + } + return tmp7 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ns-imports + { + tmp0 := lang.NewSymbol("ns-imports").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of the import mappings for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4199), lang.NewKeyword("end-line"), int(4199))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_filter_key) + tmp5 := checkDerefVar(glojure_DOT_core_val) + tmp6 := checkDerefVar(glojure_DOT_core_partial) + tmp7 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp8 := reflect.TypeOf((*reflect.Type)(nil)).Elem() + tmp9 := lang.Apply(tmp6, []any{tmp7, tmp8}) + tmp10 := checkDerefVar(glojure_DOT_core_ns_map) + tmp11 := lang.Apply(tmp10, []any{v3}) + tmp12 := lang.Apply(tmp4, []any{tmp5, tmp9, tmp11}) + return tmp12 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ns-interns + { + tmp0 := lang.NewSymbol("ns-interns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of the intern mappings for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4206), lang.NewKeyword("end-line"), int(4206))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + { // let + // let binding "ns" + tmp5 := checkDerefVar(glojure_DOT_core_the_ns) + tmp6 := lang.Apply(tmp5, []any{v3}) + var v7 any = tmp6 + _ = v7 + tmp8 := checkDerefVar(glojure_DOT_core_filter_key) + tmp9 := checkDerefVar(glojure_DOT_core_val) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v11 := args[0] + _ = v11 + var tmp12 any + { // let + // let binding "and__0__auto__" + tmp13 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp14 := reflect.TypeOf((*lang.Var)(nil)) + tmp15 := lang.Apply(tmp13, []any{tmp14, v11}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + if lang.IsTruthy(v16) { + tmp18 := checkDerefVar(glojure_DOT_core__EQ_) + tmp19, ok := lang.FieldOrMethod(v11, "Namespace") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v11, "Namespace"))) + } + var tmp20 any + switch reflect.TypeOf(tmp19).Kind() { + case reflect.Func: + tmp20 = lang.Apply(tmp19, nil) + default: + tmp20 = tmp19 + } + tmp21 := lang.Apply(tmp18, []any{v7, tmp20}) + tmp17 = tmp21 + } else { + tmp17 = v16 + } + tmp12 = tmp17 + } // end let + return tmp12 + }) + tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4212), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(4213), lang.NewKeyword("end-column"), int(56)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(glojure_DOT_core_ns_map) + tmp14 := lang.Apply(tmp13, []any{v7}) + tmp15 := lang.Apply(tmp8, []any{tmp9, tmp12, tmp14}) + tmp4 = tmp15 + } // end let + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ns-map + { + tmp0 := lang.NewSymbol("ns-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of all the mappings for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4170), lang.NewKeyword("end-line"), int(4170))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_the_ns) + tmp5 := lang.Apply(tmp4, []any{v3}) + tmp6, ok := lang.FieldOrMethod(tmp5, "Mappings") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp5, "Mappings"))) + } + var tmp7 any + switch reflect.TypeOf(tmp6).Kind() { + case reflect.Func: + tmp7 = lang.Apply(tmp6, nil) + default: + tmp7 = tmp6 + } + return tmp7 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ns-name + { + tmp0 := lang.NewSymbol("ns-name").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns the name of the namespace, a symbol.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4163), lang.NewKeyword("end-line"), int(4163))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_the_ns) + tmp5 := lang.Apply(tmp4, []any{v3}) + tmp6, ok := lang.FieldOrMethod(tmp5, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp5, "Name"))) + } + var tmp7 any + switch reflect.TypeOf(tmp6).Kind() { + case reflect.Func: + tmp7 = lang.Apply(tmp6, nil) + default: + tmp7 = tmp6 + } + return tmp7 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ns-publics + { + tmp0 := lang.NewSymbol("ns-publics").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of the public intern mappings for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4188), lang.NewKeyword("end-line"), int(4188))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + { // let + // let binding "ns" + tmp5 := checkDerefVar(glojure_DOT_core_the_ns) + tmp6 := lang.Apply(tmp5, []any{v3}) + var v7 any = tmp6 + _ = v7 + tmp8 := checkDerefVar(glojure_DOT_core_filter_key) + tmp9 := checkDerefVar(glojure_DOT_core_val) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v11 := args[0] + _ = v11 + var tmp12 any + { // let + // let binding "and__0__auto__" + tmp13 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp14 := reflect.TypeOf((*lang.Var)(nil)) + tmp15 := lang.Apply(tmp13, []any{tmp14, v11}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + if lang.IsTruthy(v16) { + var tmp18 any + { // let + // let binding "and__0__auto__" + tmp19 := checkDerefVar(glojure_DOT_core__EQ_) + tmp20, ok := lang.FieldOrMethod(v11, "Namespace") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v11, "Namespace"))) + } + var tmp21 any + switch reflect.TypeOf(tmp20).Kind() { + case reflect.Func: + tmp21 = lang.Apply(tmp20, nil) + default: + tmp21 = tmp20 + } + tmp22 := lang.Apply(tmp19, []any{v7, tmp21}) + var v23 any = tmp22 + _ = v23 + var tmp24 any + if lang.IsTruthy(v23) { + tmp25, ok := lang.FieldOrMethod(v11, "IsPublic") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v11, "IsPublic"))) + } + var tmp26 any + switch reflect.TypeOf(tmp25).Kind() { + case reflect.Func: + tmp26 = lang.Apply(tmp25, nil) + default: + tmp26 = tmp25 + } + tmp24 = tmp26 + } else { + tmp24 = v23 + } + tmp18 = tmp24 + } // end let + tmp17 = tmp18 + } else { + tmp17 = v16 + } + tmp12 = tmp17 + } // end let + return tmp12 + }) + tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4194), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(4196), lang.NewKeyword("end-column"), int(48)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(glojure_DOT_core_ns_map) + tmp14 := lang.Apply(tmp13, []any{v7}) + tmp15 := lang.Apply(tmp8, []any{tmp9, tmp12, tmp14}) + tmp4 = tmp15 + } // end let + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ns-refers + { + tmp0 := lang.NewSymbol("ns-refers").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of the refer mappings for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4253), lang.NewKeyword("end-line"), int(4253))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + { // let + // let binding "ns" + tmp5 := checkDerefVar(glojure_DOT_core_the_ns) + tmp6 := lang.Apply(tmp5, []any{v3}) + var v7 any = tmp6 + _ = v7 + tmp8 := checkDerefVar(glojure_DOT_core_filter_key) + tmp9 := checkDerefVar(glojure_DOT_core_val) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v11 := args[0] + _ = v11 + var tmp12 any + { // let + // let binding "and__0__auto__" + tmp13 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp14 := reflect.TypeOf((*lang.Var)(nil)) + tmp15 := lang.Apply(tmp13, []any{tmp14, v11}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + if lang.IsTruthy(v16) { + tmp18 := checkDerefVar(glojure_DOT_core_not_EQ_) + tmp19, ok := lang.FieldOrMethod(v11, "Namespace") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v11, "Namespace"))) + } + var tmp20 any + switch reflect.TypeOf(tmp19).Kind() { + case reflect.Func: + tmp20 = lang.Apply(tmp19, nil) + default: + tmp20 = tmp19 + } + tmp21 := lang.Apply(tmp18, []any{v7, tmp20}) + tmp17 = tmp21 + } else { + tmp17 = v16 + } + tmp12 = tmp17 + } // end let + return tmp12 + }) + tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4259), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(4260), lang.NewKeyword("end-column"), int(59)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(glojure_DOT_core_ns_map) + tmp14 := lang.Apply(tmp13, []any{v7}) + tmp15 := lang.Apply(tmp8, []any{tmp9, tmp12, tmp14}) + tmp4 = tmp15 + } // end let + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ns-resolve + { + tmp0 := lang.NewSymbol("ns-resolve").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("sym")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("env"), lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Returns the var or Class to which a symbol will be resolved in the\n namespace (unless found in the environment), else nil. Note that\n if the symbol is fully qualified, the var/Class to which it resolves\n need not be present in the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4358), lang.NewKeyword("end-line"), int(4358))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_ns_resolve) + tmp6 := lang.Apply(tmp5, []any{v3, nil, v4}) + return tmp6 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(glojure_DOT_core_contains_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v4, v5}) + if lang.IsTruthy(tmp8) { + } else { + tmp9 := checkDerefVar(glojure_DOT_core_the_ns) + tmp10 := lang.Apply(tmp9, []any{v3}) + tmp11, _ := lang.FieldOrMethod(runtime7.Compiler, "maybeResolveIn") + if reflect.TypeOf(tmp11).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("maybeResolveIn is not a function"))) + } + tmp12 := lang.Apply(tmp11, []any{tmp10, v5}) + tmp6 = tmp12 + } + return tmp6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ns-unalias + { + tmp0 := lang.NewSymbol("ns-unalias").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Removes the alias for the symbol from the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4280), lang.NewKeyword("end-line"), int(4280))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_the_ns) + tmp6 := lang.Apply(tmp5, []any{v3}) + tmp7, _ := lang.FieldOrMethod(tmp6, "removeAlias") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("removeAlias is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v4}) + return tmp8 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ns-unmap + { + tmp0 := lang.NewSymbol("ns-unmap").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Removes the mappings for the symbol from the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4177), lang.NewKeyword("end-line"), int(4177))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_the_ns) + tmp6 := lang.Apply(tmp5, []any{v3}) + tmp7, _ := lang.FieldOrMethod(tmp6, "unmap") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unmap is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v4}) + return tmp8 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // nth + { + var tmp1 lang.FnFunc + { // function nth__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := checkDerefVar(glojure_DOT_core_seq) + tmp7 := checkDerefVar(glojure_DOT_core_concat) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol(".")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + tmp12 := checkDerefVar(glojure_DOT_core_list) + tmp13 := checkDerefVar(glojure_DOT_core_seq) + tmp14 := checkDerefVar(glojure_DOT_core_concat) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("glojure.core/Nth")}) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := checkDerefVar(glojure_DOT_core_seq) + tmp19 := checkDerefVar(glojure_DOT_core_concat) + tmp20 := checkDerefVar(glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{lang.NewSymbol("glojure.core/unquote")}) + tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{lang.NewSymbol("glojure.core/c")}) + tmp24 := lang.Apply(tmp19, []any{tmp21, tmp23}) + tmp25 := lang.Apply(tmp18, []any{tmp24}) + tmp26 := lang.Apply(tmp17, []any{tmp25}) + tmp27 := checkDerefVar(glojure_DOT_core_list) + tmp28 := checkDerefVar(glojure_DOT_core_seq) + tmp29 := checkDerefVar(glojure_DOT_core_concat) + tmp30 := checkDerefVar(glojure_DOT_core_list) + tmp31 := lang.Apply(tmp30, []any{lang.NewSymbol("glojure.core/unquote")}) + tmp32 := checkDerefVar(glojure_DOT_core_list) + tmp33 := lang.Apply(tmp32, []any{lang.NewSymbol("glojure.core/i")}) + tmp34 := lang.Apply(tmp29, []any{tmp31, tmp33}) + tmp35 := lang.Apply(tmp28, []any{tmp34}) + tmp36 := lang.Apply(tmp27, []any{tmp35}) + tmp37 := checkDerefVar(glojure_DOT_core_list) + tmp38 := checkDerefVar(glojure_DOT_core_seq) + tmp39 := checkDerefVar(glojure_DOT_core_concat) + tmp40 := checkDerefVar(glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) + tmp42 := checkDerefVar(glojure_DOT_core_list) + tmp43 := lang.Apply(tmp42, []any{lang.NewSymbol("glojure.core/nf")}) + tmp44 := lang.Apply(tmp39, []any{tmp41, tmp43}) + tmp45 := lang.Apply(tmp38, []any{tmp44}) + tmp46 := lang.Apply(tmp37, []any{tmp45}) + tmp47 := lang.Apply(tmp14, []any{tmp16, tmp26, tmp36, tmp46}) + tmp48 := lang.Apply(tmp13, []any{tmp47}) + tmp49 := lang.Apply(tmp12, []any{tmp48}) + tmp50 := lang.Apply(tmp7, []any{tmp9, tmp11, tmp49}) + tmp51 := lang.Apply(tmp6, []any{tmp50}) + return tmp51 + } + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("nth").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("index")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("index"), lang.NewSymbol("not-found"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the value at the index. get returns nil if index out of\n bounds, nth throws an exception unless not-found is supplied. nth\n also works for strings, Java arrays, regex Matchers and Lists, and,\n in O(n) time, for sequences.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2), int64(3)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(882), lang.NewKeyword("end-line"), int(882))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(runtime7.RT, "Nth") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Nth is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + case 3: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := args[2] + _ = v6 + tmp7, _ := lang.FieldOrMethod(runtime7.RT, "NthDefault") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("NthDefault is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v4, v5, v6}) + return tmp8 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // nthnext + { + tmp0 := lang.NewSymbol("nthnext").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns the nth next of coll, (seq coll) when n is 0.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3147), lang.NewKeyword("end-line"), int(3147))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp7 := reflect.TypeOf((*lang.IDrop)(nil)).Elem() + tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) + if lang.IsTruthy(tmp8) { + var tmp9 any + tmp10 := checkDerefVar(glojure_DOT_core_pos_QMARK_) + tmp11 := lang.Apply(tmp10, []any{v4}) + if lang.IsTruthy(tmp11) { + var tmp12 any + tmp13 := checkDerefVar(glojure_DOT_core_int_QMARK_) + tmp14 := lang.Apply(tmp13, []any{v4}) + if lang.IsTruthy(tmp14) { + tmp12 = v4 + } else { + tmp15 := lang.Apply(nil, []any{v4}) + tmp12 = tmp15 + } + tmp16, _ := lang.FieldOrMethod(v3, "drop") + if reflect.TypeOf(tmp16).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("drop is not a function"))) + } + tmp17 := lang.Apply(tmp16, []any{tmp12}) + tmp9 = tmp17 + } else { + tmp18 := checkDerefVar(glojure_DOT_core_seq) + tmp19 := lang.Apply(tmp18, []any{v3}) + tmp9 = tmp19 + } + tmp5 = tmp9 + } else { + var tmp20 any + { // let + // let binding "n" + var v21 any = v4 + _ = v21 + // let binding "xs" + tmp22 := checkDerefVar(glojure_DOT_core_seq) + tmp23 := lang.Apply(tmp22, []any{v3}) + var v24 any = tmp23 + _ = v24 + for { + var tmp25 any + var tmp26 any + { // let + // let binding "and__0__auto__" + var v27 any = v24 + _ = v27 + var tmp28 any + if lang.IsTruthy(v27) { + tmp29 := checkDerefVar(glojure_DOT_core_pos_QMARK_) + tmp30 := lang.Apply(tmp29, []any{v21}) + tmp28 = tmp30 + } else { + tmp28 = v27 + } + tmp26 = tmp28 + } // end let + if lang.IsTruthy(tmp26) { + tmp28 := checkDerefVar(glojure_DOT_core_dec) + tmp29 := lang.Apply(tmp28, []any{v21}) + var tmp27 any = tmp29 + tmp31 := checkDerefVar(glojure_DOT_core_next) + tmp32 := lang.Apply(tmp31, []any{v24}) + var tmp30 any = tmp32 + v21 = tmp27 + v24 = tmp30 + continue + } else { + tmp25 = v24 + } + tmp20 = tmp25 + break + } + } // end let + tmp5 = tmp20 + } + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // nthrest + { + tmp0 := lang.NewSymbol("nthrest").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns the nth rest of coll, coll when n is 0.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3161), lang.NewKeyword("end-line"), int(3161))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(glojure_DOT_core_pos_QMARK_) + tmp7 := lang.Apply(tmp6, []any{v4}) + if lang.IsTruthy(tmp7) { + var tmp8 any + { // let + // let binding "or__0__auto__" + var tmp9 any + tmp10 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp11 := reflect.TypeOf((*lang.IDrop)(nil)).Elem() + tmp12 := lang.Apply(tmp10, []any{tmp11, v3}) + if lang.IsTruthy(tmp12) { + var tmp13 any + tmp14 := checkDerefVar(glojure_DOT_core_int_QMARK_) + tmp15 := lang.Apply(tmp14, []any{v4}) + if lang.IsTruthy(tmp15) { + tmp13 = v4 + } else { + tmp16 := lang.Apply(nil, []any{v4}) + tmp13 = tmp16 + } + tmp17, _ := lang.FieldOrMethod(v3, "drop") + if reflect.TypeOf(tmp17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("drop is not a function"))) + } + tmp18 := lang.Apply(tmp17, []any{tmp13}) + tmp9 = tmp18 + } else { + var tmp19 any + { // let + // let binding "n" + var v20 any = v4 + _ = v20 + // let binding "xs" + var v21 any = v3 + _ = v21 + for { + var tmp22 any + { // let + // let binding "temp__0__auto__" + var tmp23 any + { // let + // let binding "and__0__auto__" + tmp24 := checkDerefVar(glojure_DOT_core_pos_QMARK_) + tmp25 := lang.Apply(tmp24, []any{v20}) + var v26 any = tmp25 + _ = v26 + var tmp27 any + if lang.IsTruthy(v26) { + tmp28 := checkDerefVar(glojure_DOT_core_seq) + tmp29 := lang.Apply(tmp28, []any{v21}) + tmp27 = tmp29 + } else { + tmp27 = v26 + } + tmp23 = tmp27 + } // end let + var v24 any = tmp23 + _ = v24 + var tmp25 any + if lang.IsTruthy(v24) { + var tmp26 any + { // let + // let binding "xs" + var v27 any = v24 + _ = v27 + tmp29 := checkDerefVar(glojure_DOT_core_dec) + tmp30 := lang.Apply(tmp29, []any{v20}) + var tmp28 any = tmp30 + tmp32 := checkDerefVar(glojure_DOT_core_rest) + tmp33 := lang.Apply(tmp32, []any{v27}) + var tmp31 any = tmp33 + v20 = tmp28 + v21 = tmp31 + continue + } // end let + tmp25 = tmp26 + } else { + tmp27 := checkDerefVar(glojure_DOT_core_seq) + tmp28 := lang.Apply(tmp27, []any{v21}) + tmp25 = tmp28 + } + tmp22 = tmp25 + } // end let + tmp19 = tmp22 + break + } + } // end let + tmp9 = tmp19 + } + var v20 any = tmp9 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + tmp21 = v20 + } else { + tmp21 = lang.NewList() + } + tmp8 = tmp21 + } // end let + tmp5 = tmp8 + } else { + tmp5 = v3 + } + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // num + { + var tmp1 lang.FnFunc + { // function num__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := checkDerefVar(glojure_DOT_core_seq) + tmp12 := checkDerefVar(glojure_DOT_core_concat) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/Num")}) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("num").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to Number", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3474), lang.NewKeyword("end-line"), int(3474))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Num") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Num is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // number? + { + tmp0 := lang.NewSymbol("number?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is a Number", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3560), lang.NewKeyword("end-line"), int(3560))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.IsNumber, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // numerator + { + tmp1 := reflect.TypeOf((*big9.Int)(nil)) + tmp0 := lang.NewSymbol("numerator").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("r"))), lang.NewKeyword("doc"), "Returns the numerator part of a Ratio.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3583), lang.NewKeyword("end-line"), int(3583))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5, ok := lang.FieldOrMethod(v4, "numerator") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "numerator"))) + } + var tmp6 any + switch reflect.TypeOf(tmp5).Kind() { + case reflect.Func: + tmp6 = lang.Apply(tmp5, nil) + default: + tmp6 = tmp5 + } + return tmp6 + }) + tmp4 := reflect.TypeOf((*big9.Int)(nil)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // object-array + { + var tmp1 lang.FnFunc + { // function object-array__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol("glojure.core/Object_array")}) + tmp12 := checkDerefVar(glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("object-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Creates an array of objects", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1)})), lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5349), lang.NewKeyword("end-line"), int(5349))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5, _ := lang.FieldOrMethod(runtime7.RT, "Object_array") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Object_array is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // odd? + { + tmp0 := lang.NewSymbol("odd?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is odd, throws an exception if n is not an integer", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1389), lang.NewKeyword("end-line"), int(1389))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_not) + tmp5 := checkDerefVar(glojure_DOT_core_even_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + tmp7 := lang.Apply(tmp4, []any{tmp6}) + return tmp7 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // or + { + tmp0 := lang.NewSymbol("or").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("next"))), lang.NewKeyword("doc"), "Evaluates exprs one at a time, from left to right. If a form\n returns a logical true value, or returns that value and doesn't\n evaluate any of the other expressions, otherwise it returns the\n value of the last expression. (or) returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(847), lang.NewKeyword("end-line"), int(847))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + return nil + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + return v5 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_seq) + tmp8 := checkDerefVar(glojure_DOT_core_concat) + tmp9 := checkDerefVar(glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("glojure.core/let")}) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := checkDerefVar(glojure_DOT_core_apply) + tmp13 := checkDerefVar(glojure_DOT_core_vector) + tmp14 := checkDerefVar(glojure_DOT_core_seq) + tmp15 := checkDerefVar(glojure_DOT_core_concat) + tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("or__0__auto__")}) + tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v5}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp12, []any{tmp13, tmp21}) + tmp23 := lang.Apply(tmp11, []any{tmp22}) + tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp25 := checkDerefVar(glojure_DOT_core_seq) + tmp26 := checkDerefVar(glojure_DOT_core_concat) + tmp27 := checkDerefVar(glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{lang.NewSymbol("if")}) + tmp29 := checkDerefVar(glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("or__0__auto__")}) + tmp31 := checkDerefVar(glojure_DOT_core_list) + tmp32 := lang.Apply(tmp31, []any{lang.NewSymbol("or__0__auto__")}) + tmp33 := checkDerefVar(glojure_DOT_core_list) + tmp34 := checkDerefVar(glojure_DOT_core_seq) + tmp35 := checkDerefVar(glojure_DOT_core_concat) + tmp36 := checkDerefVar(glojure_DOT_core_list) + tmp37 := lang.Apply(tmp36, []any{lang.NewSymbol("glojure.core/or")}) + tmp38 := lang.Apply(tmp35, []any{tmp37, v6}) + tmp39 := lang.Apply(tmp34, []any{tmp38}) + tmp40 := lang.Apply(tmp33, []any{tmp39}) + tmp41 := lang.Apply(tmp26, []any{tmp28, tmp30, tmp32, tmp40}) + tmp42 := lang.Apply(tmp25, []any{tmp41}) + tmp43 := lang.Apply(tmp24, []any{tmp42}) + tmp44 := lang.Apply(tmp8, []any{tmp10, tmp23, tmp43}) + tmp45 := lang.Apply(tmp7, []any{tmp44}) + return tmp45 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // parents + { + tmp0 := lang.NewSymbol("parents").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"))), lang.NewKeyword("doc"), "Returns the immediate parents of tag, either via a Java type\n inheritance relationship or a relationship established via derive. h\n must be a hierarchy obtained from make-hierarchy, if not supplied\n defaults to the global hierarchy", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5564), lang.NewKeyword("end-line"), int(5564))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_parents) + tmp5 := checkDerefVar(glojure_DOT_core_global_hierarchy) + tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) + return tmp6 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_not_empty) + var tmp6 any + { // let + // let binding "tp" + tmp7 := checkDerefVar(glojure_DOT_core_get) + tmp8 := lang.Apply(lang.NewKeyword("parents"), []any{v3}) + tmp9 := lang.Apply(tmp7, []any{tmp8, v4}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + tmp12 := checkDerefVar(glojure_DOT_core_class_QMARK_) + tmp13 := lang.Apply(tmp12, []any{v4}) + if lang.IsTruthy(tmp13) { + tmp14 := checkDerefVar(glojure_DOT_core_into1) + tmp15 := checkDerefVar(glojure_DOT_core_set) + tmp16 := checkDerefVar(glojure_DOT_core_bases) + tmp17 := lang.Apply(tmp16, []any{v4}) + tmp18 := lang.Apply(tmp15, []any{tmp17}) + tmp19 := lang.Apply(tmp14, []any{tmp18, v10}) + tmp11 = tmp19 + } else { + tmp11 = v10 + } + tmp6 = tmp11 + } // end let + tmp7 := lang.Apply(tmp5, []any{tmp6}) + return tmp7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // parse-boolean + { + tmp0 := lang.NewSymbol("parse-boolean").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse strings \"true\" or \"false\" and return a boolean, or nil if invalid", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7957), lang.NewKeyword("end-line"), int(7957))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(glojure_DOT_core_string_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + var tmp7 any + { // let + // let binding "G__365" + var v8 any = v3 + _ = v8 + } // end let + tmp4 = tmp7 + } else { + tmp8 := checkDerefVar(glojure_DOT_core_parsing_err) + tmp9 := lang.Apply(tmp8, []any{v3}) + tmp10 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp9}) + panic(tmp10) + } + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // parse-double + { + tmp0 := lang.NewSymbol("parse-double").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse string with floating point components and return a Double value,\n or nil if parse fails.\n\n Grammar: https://docs.oracle.com/javase/8/docs/api/java/lang/Double.html#valueOf-java.lang.String-", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7935), lang.NewKeyword("end-line"), int(7935))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(glojure_DOT_core_string_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + var tmp7 any + { // let + // let binding "result__3649__auto__" + tmp8 := lang.Apply(strconv12.ParseFloat, []any{v3, int64(64)}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + tmp11 := lang.Apply(v9, []any{int64(1)}) + if lang.IsTruthy(tmp11) { + } else { + tmp12 := lang.Apply(v9, []any{int64(0)}) + tmp10 = tmp12 + } + tmp7 = tmp10 + } // end let + tmp4 = tmp7 + } else { + tmp8 := checkDerefVar(glojure_DOT_core_parsing_err) + tmp9 := lang.Apply(tmp8, []any{v3}) + tmp10 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp9}) + panic(tmp10) + } + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // parse-impls + { + tmp0 := lang.NewSymbol("parse-impls").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(13), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(13), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("specs"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + { // let + // let binding "ret" + tmp5 := lang.NewMap() + tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(14), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(14), lang.NewKeyword("end-column"), int(15)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v8 any = tmp7 + _ = v8 + // let binding "s" + var v9 any = v3 + _ = v9 + for { + var tmp10 any + tmp11 := checkDerefVar(glojure_DOT_core_seq) + tmp12 := lang.Apply(tmp11, []any{v9}) + if lang.IsTruthy(tmp12) { + tmp14 := checkDerefVar(glojure_DOT_core_assoc) + tmp15 := checkDerefVar(glojure_DOT_core_first) + tmp16 := lang.Apply(tmp15, []any{v9}) + tmp17 := checkDerefVar(glojure_DOT_core_take_while) + tmp18 := checkDerefVar(glojure_DOT_core_seq_QMARK_) + tmp19 := checkDerefVar(glojure_DOT_core_next) + tmp20 := lang.Apply(tmp19, []any{v9}) + tmp21 := lang.Apply(tmp17, []any{tmp18, tmp20}) + tmp22 := lang.Apply(tmp14, []any{v8, tmp16, tmp21}) + var tmp13 any = tmp22 + tmp24 := checkDerefVar(glojure_DOT_core_drop_while) + tmp25 := checkDerefVar(glojure_DOT_core_seq_QMARK_) + tmp26 := checkDerefVar(glojure_DOT_core_next) + tmp27 := lang.Apply(tmp26, []any{v9}) + tmp28 := lang.Apply(tmp24, []any{tmp25, tmp27}) + var tmp23 any = tmp28 + v8 = tmp13 + v9 = tmp23 + continue + } else { + tmp10 = v8 + } + tmp4 = tmp10 + break + } + } // end let + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // parse-long + { + tmp0 := lang.NewSymbol("parse-long").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse string of decimal digits with optional leading -/+ and return a\n Long value, or nil if parse fails", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7926), lang.NewKeyword("end-line"), int(7926))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(glojure_DOT_core_string_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + var tmp7 any + { // let + // let binding "result__3648__auto__" + tmp8 := lang.Apply(strconv12.ParseInt, []any{v3, int64(10), int64(64)}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + tmp11 := lang.Apply(v9, []any{int64(1)}) + if lang.IsTruthy(tmp11) { + } else { + tmp12 := lang.Apply(v9, []any{int64(0)}) + tmp10 = tmp12 + } + tmp7 = tmp10 + } // end let + tmp4 = tmp7 + } else { + tmp8 := checkDerefVar(glojure_DOT_core_parsing_err) + tmp9 := lang.Apply(tmp8, []any{v3}) + tmp10 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp9}) + panic(tmp10) + } + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // parse-uuid + { + tmp0 := lang.NewSymbol("parse-uuid").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse a string representing a UUID and return a java.util.UUID instance,\n or nil if parse fails.\n\n Grammar: https://docs.oracle.com/javase/8/docs/api/java/util/UUID.html#toString--", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7946), lang.NewKeyword("end-line"), int(7946))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + func() { + defer func() { + if r := recover(); r != nil { + tmp5 := reflect.TypeOf((*lang.IllegalArgumentError)(nil)) + if lang.CatchMatches(r, tmp5) { + v6 := r + _ = v6 + } else { + panic(r) + } + } + }() + var tmp6 any + { // let + // let binding "vec__362" + tmp7 := lang.Apply(uuid13.Parse, []any{v3}) + var v8 any = tmp7 + _ = v8 + // let binding "uuid" + tmp9 := checkDerefVar(glojure_DOT_core_nth) + tmp10 := lang.Apply(tmp9, []any{v8, int64(0), nil}) + var v11 any = tmp10 + _ = v11 + // let binding "err" + tmp12 := checkDerefVar(glojure_DOT_core_nth) + tmp13 := lang.Apply(tmp12, []any{v8, int64(1), nil}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + tmp16 := checkDerefVar(glojure_DOT_core_str) + tmp17 := lang.Apply(tmp16, []any{"Error parsing UUID: ", v14}) + tmp18 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp17}) + panic(tmp18) + } else { + tmp15 = v11 + } + tmp6 = tmp15 + } // end let + tmp4 = tmp6 + }() + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // parsing-err + { + tmp0 := lang.NewSymbol("parsing-err").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Construct message for parsing for non-string parsing error", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(7921), lang.NewKeyword("end-line"), int(7921), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_str) + var tmp5 any + tmp6 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp7 := lang.Apply(tmp6, []any{v3}) + if lang.IsTruthy(tmp7) { + tmp5 = "nil" + } else { + tmp8 := checkDerefVar(glojure_DOT_core_class) + tmp9 := lang.Apply(tmp8, []any{v3}) + tmp10, ok := lang.FieldOrMethod(tmp9, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp9, "Name"))) + } + var tmp11 any + switch reflect.TypeOf(tmp10).Kind() { + case reflect.Func: + tmp11 = lang.Apply(tmp10, nil) + default: + tmp11 = tmp10 + } + tmp5 = tmp11 + } + tmp12 := lang.Apply(tmp4, []any{"Expected string, got ", tmp5}) + return tmp12 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // partial + { + tmp0 := lang.NewSymbol("partial").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("arg1")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("arg1"), lang.NewSymbol("arg2")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("arg1"), lang.NewSymbol("arg2"), lang.NewSymbol("arg3")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("arg1"), lang.NewSymbol("arg2"), lang.NewSymbol("arg3"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Takes a function f and fewer than the normal arguments to f, and\n returns a fn that takes a variable number of additional args. When\n called, the returned function calls f with args + additional args.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2606), lang.NewKeyword("end-line"), int(2606))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + return v3 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp6 := lang.Apply(v3, []any{v4}) + return tmp6 + case 1: + v6 := args[0] + _ = v6 + tmp7 := lang.Apply(v3, []any{v4, v6}) + return tmp7 + case 2: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + tmp8 := lang.Apply(v3, []any{v4, v6, v7}) + return tmp8 + case 3: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + tmp9 := lang.Apply(v3, []any{v4, v6, v7, v8}) + return tmp9 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + var v9 any = lang.NewList(args[3:]...) + _ = v9 + tmp10 := checkDerefVar(glojure_DOT_core_apply) + tmp11 := lang.Apply(tmp10, []any{v3, v4, v6, v7, v8, v9}) + return tmp11 + } + }) + tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2614), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(2619), lang.NewKeyword("end-column"), int(48)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp7 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp7 := lang.Apply(v3, []any{v4, v5}) + return tmp7 + case 1: + v7 := args[0] + _ = v7 + tmp8 := lang.Apply(v3, []any{v4, v5, v7}) + return tmp8 + case 2: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + tmp9 := lang.Apply(v3, []any{v4, v5, v7, v8}) + return tmp9 + case 3: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + tmp10 := lang.Apply(v3, []any{v4, v5, v7, v8, v9}) + return tmp10 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + var v10 any = lang.NewList(args[3:]...) + _ = v10 + tmp11 := checkDerefVar(glojure_DOT_core_apply) + tmp12 := lang.Apply(tmp11, []any{v3, v4, v5, v7, v8, v9, v10}) + return tmp12 + } + }) + tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2621), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(2626), lang.NewKeyword("end-column"), int(53)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp8 + case 4: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp8 := lang.Apply(v3, []any{v4, v5, v6}) + return tmp8 + case 1: + v8 := args[0] + _ = v8 + tmp9 := lang.Apply(v3, []any{v4, v5, v6, v8}) + return tmp9 + case 2: + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + tmp10 := lang.Apply(v3, []any{v4, v5, v6, v8, v9}) + return tmp10 + case 3: + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + v10 := args[2] + _ = v10 + tmp11 := lang.Apply(v3, []any{v4, v5, v6, v8, v9, v10}) + return tmp11 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + v10 := args[2] + _ = v10 + var v11 any = lang.NewList(args[3:]...) + _ = v11 + tmp12 := checkDerefVar(glojure_DOT_core_apply) + tmp13 := lang.Apply(tmp12, []any{v3, v4, v5, v6, v8, v9, v10, v11}) + return tmp13 + } + }) + tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2628), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(2633), lang.NewKeyword("end-column"), int(58)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp9 + default: + if len(args) < 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + var v7 any = lang.NewList(args[4:]...) + _ = v7 + var tmp8 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v9 any = lang.NewList(args[0:]...) + _ = v9 + tmp10 := checkDerefVar(glojure_DOT_core_apply) + tmp11 := checkDerefVar(glojure_DOT_core_concat) + tmp12 := lang.Apply(tmp11, []any{v7, v9}) + tmp13 := lang.Apply(tmp10, []any{v3, v4, v5, v6, tmp12}) + return tmp13 + } + }) + tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2635), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(2635), lang.NewKeyword("end-column"), int(60)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp10 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // partition + { + tmp0 := lang.NewSymbol("partition").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("pad"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of lists of n items each, at offsets step\n apart. If step is not supplied, defaults to n, i.e. the partitions\n do not overlap. If a pad collection is supplied, use its elements as\n necessary to complete last partition upto n items. In case there are\n not enough padding elements, return a partition with less than n items.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3177), lang.NewKeyword("end-line"), int(3177))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_partition) + tmp6 := lang.Apply(tmp5, []any{v3, v3, v4}) + return tmp6 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var tmp7 any + { // let + // let binding "temp__0__auto__" + tmp8 := checkDerefVar(glojure_DOT_core_seq) + tmp9 := lang.Apply(tmp8, []any{v5}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + if lang.IsTruthy(v10) { + var tmp12 any + { // let + // let binding "s" + var v13 any = v10 + _ = v13 + var tmp14 any + { // let + // let binding "p" + tmp15 := checkDerefVar(glojure_DOT_core_doall) + tmp16 := checkDerefVar(glojure_DOT_core_take) + tmp17 := lang.Apply(tmp16, []any{v3, v13}) + tmp18 := lang.Apply(tmp15, []any{tmp17}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + tmp21 := checkDerefVar(glojure_DOT_core__EQ_) + tmp22 := checkDerefVar(glojure_DOT_core_count) + tmp23 := lang.Apply(tmp22, []any{v19}) + tmp24 := lang.Apply(tmp21, []any{v3, tmp23}) + if lang.IsTruthy(tmp24) { + tmp25 := checkDerefVar(glojure_DOT_core_cons) + tmp26 := checkDerefVar(glojure_DOT_core_partition) + tmp27 := checkDerefVar(glojure_DOT_core_nthrest) + tmp28 := lang.Apply(tmp27, []any{v13, v4}) + tmp29 := lang.Apply(tmp26, []any{v3, v4, tmp28}) + tmp30 := lang.Apply(tmp25, []any{v19, tmp29}) + tmp20 = tmp30 + } else { + } + tmp14 = tmp20 + } // end let + tmp12 = tmp14 + } // end let + tmp11 = tmp12 + } else { + } + tmp7 = tmp11 + } // end let + return tmp7 + }) + tmp7 := lang.Apply(lang.NewLazySeq, []any{tmp6}) + return tmp7 + case 4: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var tmp8 any + { // let + // let binding "temp__0__auto__" + tmp9 := checkDerefVar(glojure_DOT_core_seq) + tmp10 := lang.Apply(tmp9, []any{v6}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + var tmp13 any + { // let + // let binding "s" + var v14 any = v11 + _ = v14 + var tmp15 any + { // let + // let binding "p" + tmp16 := checkDerefVar(glojure_DOT_core_doall) + tmp17 := checkDerefVar(glojure_DOT_core_take) + tmp18 := lang.Apply(tmp17, []any{v3, v14}) + tmp19 := lang.Apply(tmp16, []any{tmp18}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + tmp22 := checkDerefVar(glojure_DOT_core__EQ_) + tmp23 := checkDerefVar(glojure_DOT_core_count) + tmp24 := lang.Apply(tmp23, []any{v20}) + tmp25 := lang.Apply(tmp22, []any{v3, tmp24}) + if lang.IsTruthy(tmp25) { + tmp26 := checkDerefVar(glojure_DOT_core_cons) + tmp27 := checkDerefVar(glojure_DOT_core_partition) + tmp28 := checkDerefVar(glojure_DOT_core_nthrest) + tmp29 := lang.Apply(tmp28, []any{v14, v4}) + tmp30 := lang.Apply(tmp27, []any{v3, v4, v5, tmp29}) + tmp31 := lang.Apply(tmp26, []any{v20, tmp30}) + tmp21 = tmp31 + } else { + tmp32 := checkDerefVar(glojure_DOT_core_list) + tmp33 := checkDerefVar(glojure_DOT_core_take) + tmp34 := checkDerefVar(glojure_DOT_core_concat) + tmp35 := lang.Apply(tmp34, []any{v20, v5}) + tmp36 := lang.Apply(tmp33, []any{v3, tmp35}) + tmp37 := lang.Apply(tmp32, []any{tmp36}) + tmp21 = tmp37 + } + tmp15 = tmp21 + } // end let + tmp13 = tmp15 + } // end let + tmp12 = tmp13 + } else { + } + tmp8 = tmp12 + } // end let + return tmp8 + }) + tmp8 := lang.Apply(lang.NewLazySeq, []any{tmp7}) + return tmp8 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // partition-all + { + tmp0 := lang.NewSymbol("partition-all").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of lists like partition, but may include\n partitions with fewer than n items at the end. Returns a stateful\n transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7222), lang.NewKeyword("end-line"), int(7222))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + var tmp6 any + { // let + // let binding "a" + tmp7 := checkDerefVar(glojure_DOT_core_to_array) + tmp8 := lang.Apply(tmp7, []any{v3}) + tmp9 := lang.Apply(lang.NewArrayList, []any{tmp8}) + var v10 any = tmp9 + _ = v10 + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp12 := lang.Apply(v5, nil) + return tmp12 + case 1: + v12 := args[0] + _ = v12 + var tmp13 any + { // let + // let binding "result" + var tmp14 any + tmp15, ok := lang.FieldOrMethod(v10, "isEmpty") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v10, "isEmpty"))) + } + var tmp16 any + switch reflect.TypeOf(tmp15).Kind() { + case reflect.Func: + tmp16 = lang.Apply(tmp15, nil) + default: + tmp16 = tmp15 + } + if lang.IsTruthy(tmp16) { + tmp14 = v12 + } else { + var tmp17 any + { // let + // let binding "v" + tmp18 := checkDerefVar(glojure_DOT_core_vec) + tmp19, ok := lang.FieldOrMethod(v10, "toArray") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v10, "toArray"))) + } + var tmp20 any + switch reflect.TypeOf(tmp19).Kind() { + case reflect.Func: + tmp20 = lang.Apply(tmp19, nil) + default: + tmp20 = tmp19 + } + tmp21 := lang.Apply(tmp18, []any{tmp20}) + var v22 any = tmp21 + _ = v22 + tmp23, ok := lang.FieldOrMethod(v10, "clear") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v10, "clear"))) + } + var tmp24 any + switch reflect.TypeOf(tmp23).Kind() { + case reflect.Func: + tmp24 = lang.Apply(tmp23, nil) + default: + tmp24 = tmp23 + } + _ = tmp24 + tmp25 := checkDerefVar(glojure_DOT_core_unreduced) + tmp26 := lang.Apply(v5, []any{v12, v22}) + tmp27 := lang.Apply(tmp25, []any{tmp26}) + tmp17 = tmp27 + } // end let + tmp14 = tmp17 + } + var v18 any = tmp14 + _ = v18 + tmp19 := lang.Apply(v5, []any{v18}) + tmp13 = tmp19 + } // end let + return tmp13 + case 2: + v12 := args[0] + _ = v12 + v13 := args[1] + _ = v13 + tmp14, _ := lang.FieldOrMethod(v10, "add") + if reflect.TypeOf(tmp14).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) + } + tmp15 := lang.Apply(tmp14, []any{v13}) + _ = tmp15 + var tmp16 any + tmp17 := checkDerefVar(glojure_DOT_core__EQ_) + tmp18, ok := lang.FieldOrMethod(v10, "size") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v10, "size"))) + } + var tmp19 any + switch reflect.TypeOf(tmp18).Kind() { + case reflect.Func: + tmp19 = lang.Apply(tmp18, nil) + default: + tmp19 = tmp18 + } + tmp20 := lang.Apply(tmp17, []any{v3, tmp19}) + if lang.IsTruthy(tmp20) { + var tmp21 any + { // let + // let binding "v" + tmp22 := checkDerefVar(glojure_DOT_core_vec) + tmp23, ok := lang.FieldOrMethod(v10, "toArray") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v10, "toArray"))) + } + var tmp24 any + switch reflect.TypeOf(tmp23).Kind() { + case reflect.Func: + tmp24 = lang.Apply(tmp23, nil) + default: + tmp24 = tmp23 + } + tmp25 := lang.Apply(tmp22, []any{tmp24}) + var v26 any = tmp25 + _ = v26 + tmp27, ok := lang.FieldOrMethod(v10, "clear") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v10, "clear"))) + } + var tmp28 any + switch reflect.TypeOf(tmp27).Kind() { + case reflect.Func: + tmp28 = lang.Apply(tmp27, nil) + default: + tmp28 = tmp27 + } + _ = tmp28 + tmp29 := lang.Apply(v5, []any{v12, v26}) + tmp21 = tmp29 + } // end let + tmp16 = tmp21 + } else { + tmp16 = v12 + } + return tmp16 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7231), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7247), lang.NewKeyword("end-column"), int(23)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp6 = tmp13 + } // end let + return tmp6 + }) + tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7229), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7247), lang.NewKeyword("end-column"), int(25)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_partition_all) + tmp6 := lang.Apply(tmp5, []any{v3, v3, v4}) + return tmp6 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var tmp7 any + { // let + // let binding "temp__0__auto__" + tmp8 := checkDerefVar(glojure_DOT_core_seq) + tmp9 := lang.Apply(tmp8, []any{v5}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + if lang.IsTruthy(v10) { + var tmp12 any + { // let + // let binding "s" + var v13 any = v10 + _ = v13 + var tmp14 any + { // let + // let binding "seg" + tmp15 := checkDerefVar(glojure_DOT_core_doall) + tmp16 := checkDerefVar(glojure_DOT_core_take) + tmp17 := lang.Apply(tmp16, []any{v3, v13}) + tmp18 := lang.Apply(tmp15, []any{tmp17}) + var v19 any = tmp18 + _ = v19 + tmp20 := checkDerefVar(glojure_DOT_core_cons) + tmp21 := checkDerefVar(glojure_DOT_core_partition_all) + tmp22 := checkDerefVar(glojure_DOT_core_nthrest) + tmp23 := lang.Apply(tmp22, []any{v13, v4}) + tmp24 := lang.Apply(tmp21, []any{v3, v4, tmp23}) + tmp25 := lang.Apply(tmp20, []any{v19, tmp24}) + tmp14 = tmp25 + } // end let + tmp12 = tmp14 + } // end let + tmp11 = tmp12 + } else { + } + tmp7 = tmp11 + } // end let + return tmp7 + }) + tmp7 := lang.Apply(lang.NewLazySeq, []any{tmp6}) + return tmp7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // partition-by + { + tmp0 := lang.NewSymbol("partition-by").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Applies f to each value in coll, splitting it each time f returns a\n new value. Returns a lazy seq of partitions. Returns a stateful\n transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7142), lang.NewKeyword("end-line"), int(7142))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + var tmp6 any + { // let + // let binding "a" + var v7 any = "unimplemented: new with non-constant class type" + _ = v7 + // let binding "pv" + tmp8 := checkDerefVar(glojure_DOT_core_volatile_BANG_) + tmp9 := lang.Apply(tmp8, []any{lang.NewKeyword("glojure.core/none")}) + var v10 any = tmp9 + _ = v10 + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp12 := lang.Apply(v5, nil) + return tmp12 + case 1: + v12 := args[0] + _ = v12 + var tmp13 any + { // let + // let binding "result" + var tmp14 any + tmp15, ok := lang.FieldOrMethod(v7, "isEmpty") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "isEmpty"))) + } + var tmp16 any + switch reflect.TypeOf(tmp15).Kind() { + case reflect.Func: + tmp16 = lang.Apply(tmp15, nil) + default: + tmp16 = tmp15 + } + if lang.IsTruthy(tmp16) { + tmp14 = v12 + } else { + var tmp17 any + { // let + // let binding "v" + tmp18 := checkDerefVar(glojure_DOT_core_vec) + tmp19, ok := lang.FieldOrMethod(v7, "toArray") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "toArray"))) + } + var tmp20 any + switch reflect.TypeOf(tmp19).Kind() { + case reflect.Func: + tmp20 = lang.Apply(tmp19, nil) + default: + tmp20 = tmp19 + } + tmp21 := lang.Apply(tmp18, []any{tmp20}) + var v22 any = tmp21 + _ = v22 + tmp23, ok := lang.FieldOrMethod(v7, "clear") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "clear"))) + } + var tmp24 any + switch reflect.TypeOf(tmp23).Kind() { + case reflect.Func: + tmp24 = lang.Apply(tmp23, nil) + default: + tmp24 = tmp23 + } + _ = tmp24 + tmp25 := checkDerefVar(glojure_DOT_core_unreduced) + tmp26 := lang.Apply(v5, []any{v12, v22}) + tmp27 := lang.Apply(tmp25, []any{tmp26}) + tmp17 = tmp27 + } // end let + tmp14 = tmp17 + } + var v18 any = tmp14 + _ = v18 + tmp19 := lang.Apply(v5, []any{v18}) + tmp13 = tmp19 + } // end let + return tmp13 + case 2: + v12 := args[0] + _ = v12 + v13 := args[1] + _ = v13 + var tmp14 any + { // let + // let binding "pval" + tmp15 := checkDerefVar(glojure_DOT_core_deref) + tmp16 := lang.Apply(tmp15, []any{v10}) + var v17 any = tmp16 + _ = v17 + // let binding "val" + tmp18 := lang.Apply(v3, []any{v13}) + var v19 any = tmp18 + _ = v19 + tmp20 := checkDerefVar(glojure_DOT_core_vreset_BANG_) + tmp21 := lang.Apply(tmp20, []any{v10, v19}) + _ = tmp21 + var tmp22 any + var tmp23 any + { // let + // let binding "or__0__auto__" + tmp24 := checkDerefVar(glojure_DOT_core_identical_QMARK_) + tmp25 := lang.Apply(tmp24, []any{v17, lang.NewKeyword("glojure.core/none")}) + var v26 any = tmp25 + _ = v26 + var tmp27 any + if lang.IsTruthy(v26) { + tmp27 = v26 + } else { + tmp28 := checkDerefVar(glojure_DOT_core__EQ_) + tmp29 := lang.Apply(tmp28, []any{v19, v17}) + tmp27 = tmp29 + } + tmp23 = tmp27 + } // end let + if lang.IsTruthy(tmp23) { + tmp24, _ := lang.FieldOrMethod(v7, "add") + if reflect.TypeOf(tmp24).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) + } + tmp25 := lang.Apply(tmp24, []any{v13}) + _ = tmp25 + tmp22 = v12 + } else { + var tmp26 any + { // let + // let binding "v" + tmp27 := checkDerefVar(glojure_DOT_core_vec) + tmp28, ok := lang.FieldOrMethod(v7, "toArray") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "toArray"))) + } + var tmp29 any + switch reflect.TypeOf(tmp28).Kind() { + case reflect.Func: + tmp29 = lang.Apply(tmp28, nil) + default: + tmp29 = tmp28 + } + tmp30 := lang.Apply(tmp27, []any{tmp29}) + var v31 any = tmp30 + _ = v31 + tmp32, ok := lang.FieldOrMethod(v7, "clear") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "clear"))) + } + var tmp33 any + switch reflect.TypeOf(tmp32).Kind() { + case reflect.Func: + tmp33 = lang.Apply(tmp32, nil) + default: + tmp33 = tmp32 + } + _ = tmp33 + var tmp34 any + { // let + // let binding "ret" + tmp35 := lang.Apply(v5, []any{v12, v31}) + var v36 any = tmp35 + _ = v36 + var tmp37 any + tmp38 := checkDerefVar(glojure_DOT_core_reduced_QMARK_) + tmp39 := lang.Apply(tmp38, []any{v36}) + if lang.IsTruthy(tmp39) { + } else { + tmp40, _ := lang.FieldOrMethod(v7, "add") + if reflect.TypeOf(tmp40).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) + } + tmp41 := lang.Apply(tmp40, []any{v13}) + tmp37 = tmp41 + } + _ = tmp37 + tmp34 = v36 + } // end let + tmp26 = tmp34 + } // end let + tmp22 = tmp26 + } + tmp14 = tmp22 + } // end let + return tmp14 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7152), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(7176), lang.NewKeyword("end-column"), int(28)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp6 = tmp13 + } // end let + return tmp6 + }) + tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7149), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(7176), lang.NewKeyword("end-column"), int(30)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var tmp6 any + { // let + // let binding "temp__0__auto__" + tmp7 := checkDerefVar(glojure_DOT_core_seq) + tmp8 := lang.Apply(tmp7, []any{v4}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + var tmp11 any + { // let + // let binding "s" + var v12 any = v9 + _ = v12 + var tmp13 any + { // let + // let binding "fst" + tmp14 := checkDerefVar(glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v12}) + var v16 any = tmp15 + _ = v16 + // let binding "fv" + tmp17 := lang.Apply(v3, []any{v16}) + var v18 any = tmp17 + _ = v18 + // let binding "run" + tmp19 := checkDerefVar(glojure_DOT_core_cons) + tmp20 := checkDerefVar(glojure_DOT_core_take_while) + var tmp21 lang.FnFunc + tmp21 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v22 := args[0] + _ = v22 + tmp23 := checkDerefVar(glojure_DOT_core__EQ_) + tmp24 := lang.Apply(v3, []any{v22}) + tmp25 := lang.Apply(tmp23, []any{v18, tmp24}) + return tmp25 + }) + tmp22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7182), lang.NewKeyword("column"), int(41), lang.NewKeyword("end-line"), int(7182), lang.NewKeyword("end-column"), int(53)) + tmp23, err := lang.WithMeta(tmp21, tmp22.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp24 := checkDerefVar(glojure_DOT_core_next) + tmp25 := lang.Apply(tmp24, []any{v12}) + tmp26 := lang.Apply(tmp20, []any{tmp23, tmp25}) + tmp27 := lang.Apply(tmp19, []any{v16, tmp26}) + var v28 any = tmp27 + _ = v28 + tmp29 := checkDerefVar(glojure_DOT_core_cons) + tmp30 := checkDerefVar(glojure_DOT_core_partition_by) + var tmp31 lang.FnFunc + tmp31 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + tmp32 := checkDerefVar(glojure_DOT_core_drop) + tmp33 := checkDerefVar(glojure_DOT_core_count) + tmp34 := lang.Apply(tmp33, []any{v28}) + tmp35 := lang.Apply(tmp32, []any{tmp34, v12}) + return tmp35 + }) + tmp32 := lang.Apply(lang.NewLazySeq, []any{tmp31}) + tmp33 := lang.Apply(tmp30, []any{v3, tmp32}) + tmp34 := lang.Apply(tmp29, []any{v28, tmp33}) + tmp13 = tmp34 + } // end let + tmp11 = tmp13 + } // end let + tmp10 = tmp11 + } else { + } + tmp6 = tmp10 + } // end let + return tmp6 + }) + tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) + return tmp6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // partitionv + { + tmp0 := lang.NewSymbol("partitionv").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("pad"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of vectors of n items each, at offsets step\n apart. If step is not supplied, defaults to n, i.e. the partitions\n do not overlap. If a pad collection is supplied, use its elements as\n necessary to complete last partition upto n items. In case there are\n not enough padding elements, return a partition with less than n items.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7262), lang.NewKeyword("end-line"), int(7262))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_partitionv) + tmp6 := lang.Apply(tmp5, []any{v3, v3, v4}) + return tmp6 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var tmp7 any + { // let + // let binding "temp__0__auto__" + tmp8 := checkDerefVar(glojure_DOT_core_seq) + tmp9 := lang.Apply(tmp8, []any{v5}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + if lang.IsTruthy(v10) { + var tmp12 any + { // let + // let binding "s" + var v13 any = v10 + _ = v13 + var tmp14 any + { // let + // let binding "p" + tmp15 := checkDerefVar(glojure_DOT_core_into) + tmp16 := lang.NewVector() + tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7274), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(7274), lang.NewKeyword("end-column"), int(23)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp19 := checkDerefVar(glojure_DOT_core_take) + tmp20 := lang.Apply(tmp19, []any{v3}) + tmp21 := lang.Apply(tmp15, []any{tmp18, tmp20, v13}) + var v22 any = tmp21 + _ = v22 + var tmp23 any + tmp24 := checkDerefVar(glojure_DOT_core__EQ_) + tmp25 := checkDerefVar(glojure_DOT_core_count) + tmp26 := lang.Apply(tmp25, []any{v22}) + tmp27 := lang.Apply(tmp24, []any{v3, tmp26}) + if lang.IsTruthy(tmp27) { + tmp28 := checkDerefVar(glojure_DOT_core_cons) + tmp29 := checkDerefVar(glojure_DOT_core_partitionv) + tmp30 := checkDerefVar(glojure_DOT_core_nthrest) + tmp31 := lang.Apply(tmp30, []any{v13, v4}) + tmp32 := lang.Apply(tmp29, []any{v3, v4, tmp31}) + tmp33 := lang.Apply(tmp28, []any{v22, tmp32}) + tmp23 = tmp33 + } else { + } + tmp14 = tmp23 + } // end let + tmp12 = tmp14 + } // end let + tmp11 = tmp12 + } else { + } + tmp7 = tmp11 + } // end let + return tmp7 + }) + tmp7 := lang.Apply(lang.NewLazySeq, []any{tmp6}) + return tmp7 + case 4: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var tmp8 any + { // let + // let binding "temp__0__auto__" + tmp9 := checkDerefVar(glojure_DOT_core_seq) + tmp10 := lang.Apply(tmp9, []any{v6}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + var tmp13 any + { // let + // let binding "s" + var v14 any = v11 + _ = v14 + var tmp15 any + { // let + // let binding "p" + tmp16 := checkDerefVar(glojure_DOT_core_into) + tmp17 := lang.NewVector() + tmp18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7280), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(7280), lang.NewKeyword("end-column"), int(23)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp20 := checkDerefVar(glojure_DOT_core_take) + tmp21 := lang.Apply(tmp20, []any{v3}) + tmp22 := lang.Apply(tmp16, []any{tmp19, tmp21, v14}) + var v23 any = tmp22 + _ = v23 + var tmp24 any + tmp25 := checkDerefVar(glojure_DOT_core__EQ_) + tmp26 := checkDerefVar(glojure_DOT_core_count) + tmp27 := lang.Apply(tmp26, []any{v23}) + tmp28 := lang.Apply(tmp25, []any{v3, tmp27}) + if lang.IsTruthy(tmp28) { + tmp29 := checkDerefVar(glojure_DOT_core_cons) + tmp30 := checkDerefVar(glojure_DOT_core_partitionv) + tmp31 := checkDerefVar(glojure_DOT_core_nthrest) + tmp32 := lang.Apply(tmp31, []any{v14, v4}) + tmp33 := lang.Apply(tmp30, []any{v3, v4, v5, tmp32}) + tmp34 := lang.Apply(tmp29, []any{v23, tmp33}) + tmp24 = tmp34 + } else { + tmp35 := checkDerefVar(glojure_DOT_core_list) + tmp36 := checkDerefVar(glojure_DOT_core_into) + tmp37 := lang.NewVector() + tmp38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7283), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(7283), lang.NewKeyword("end-column"), int(25)) + tmp39, err := lang.WithMeta(tmp37, tmp38.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp40 := checkDerefVar(glojure_DOT_core_take) + tmp41 := lang.Apply(tmp40, []any{v3}) + tmp42 := checkDerefVar(glojure_DOT_core_concat) + tmp43 := lang.Apply(tmp42, []any{v23, v5}) + tmp44 := lang.Apply(tmp36, []any{tmp39, tmp41, tmp43}) + tmp45 := lang.Apply(tmp35, []any{tmp44}) + tmp24 = tmp45 + } + tmp15 = tmp24 + } // end let + tmp13 = tmp15 + } // end let + tmp12 = tmp13 + } else { + } + tmp8 = tmp12 + } // end let + return tmp8 + }) + tmp8 := lang.Apply(lang.NewLazySeq, []any{tmp7}) + return tmp8 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // partitionv-all + { + tmp0 := lang.NewSymbol("partitionv-all").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of vector partitions, but may include\n partitions with fewer than n items at the end.\n Returns a stateful transducer when no collection is provided.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7285), lang.NewKeyword("end-line"), int(7285))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_partition_all) + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_partitionv_all) + tmp6 := lang.Apply(tmp5, []any{v3, v3, v4}) + return tmp6 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var tmp7 any + { // let + // let binding "temp__0__auto__" + tmp8 := checkDerefVar(glojure_DOT_core_seq) + tmp9 := lang.Apply(tmp8, []any{v5}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + if lang.IsTruthy(v10) { + var tmp12 any + { // let + // let binding "s" + var v13 any = v10 + _ = v13 + var tmp14 any + { // let + // let binding "seg" + tmp15 := checkDerefVar(glojure_DOT_core_into) + tmp16 := lang.NewVector() + tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7297), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(7297), lang.NewKeyword("end-column"), int(25)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp19 := checkDerefVar(glojure_DOT_core_take) + tmp20 := lang.Apply(tmp19, []any{v3}) + tmp21 := lang.Apply(tmp15, []any{tmp18, tmp20, v5}) + var v22 any = tmp21 + _ = v22 + tmp23 := checkDerefVar(glojure_DOT_core_cons) + tmp24 := checkDerefVar(glojure_DOT_core_partitionv_all) + tmp25 := checkDerefVar(glojure_DOT_core_drop) + tmp26 := lang.Apply(tmp25, []any{v4, v13}) + tmp27 := lang.Apply(tmp24, []any{v3, v4, tmp26}) + tmp28 := lang.Apply(tmp23, []any{v22, tmp27}) + tmp14 = tmp28 + } // end let + tmp12 = tmp14 + } // end let + tmp11 = tmp12 + } else { + } + tmp7 = tmp11 + } // end let + return tmp7 + }) + tmp7 := lang.Apply(lang.NewLazySeq, []any{tmp6}) + return tmp7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // pcalls + { + tmp0 := lang.NewSymbol("pcalls").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("fns"))), lang.NewKeyword("doc"), "Executes the no-arg fns in parallel, returning a lazy sequence of\n their values", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7056), lang.NewKeyword("end-line"), int(7056))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_pmap) + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v6 := args[0] + _ = v6 + tmp7 := lang.Apply(v6, nil) + return tmp7 + }) + tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7061), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(7061), lang.NewKeyword("end-column"), int(20)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp8 := lang.Apply(tmp4, []any{tmp7, v3}) + return tmp8 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // peek + { + tmp0 := lang.NewSymbol("peek").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "For a list or queue, same as first, for a vector, same as, but much\n more efficient than, last. If the collection is empty, returns nil.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1455), lang.NewKeyword("end-line"), int(1455))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(runtime7.RT, "Peek") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Peek is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // persistent! + { + tmp0 := lang.NewSymbol("persistent!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a new, persistent version of the transient collection, in\n constant time. The transient collection cannot be used after this\n call, any such use will throw an exception.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3350), lang.NewKeyword("end-line"), int(3350))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4, ok := lang.FieldOrMethod(v3, "Persistent") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "Persistent"))) + } + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { + case reflect.Func: + tmp5 = lang.Apply(tmp4, nil) + default: + tmp5 = tmp4 + } + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // pmap + { + tmp0 := lang.NewSymbol("pmap").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Like map, except f is applied in parallel. Semi-lazy in that the\n parallel computation stays ahead of the consumption, but doesn't\n realize the entire result unless required. Only useful for\n computationally intensive functions where the time of f dominates\n the coordination overhead.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7031), lang.NewKeyword("end-line"), int(7031))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 any + { // let + // let binding "n" + tmp6 := checkDerefVar(glojure_DOT_core__PLUS_) + tmp7 := lang.Apply(runtime14.NumCPU, nil) + tmp8 := lang.Apply(tmp6, []any{int64(2), tmp7}) + var v9 any = tmp8 + _ = v9 + // let binding "rets" + tmp10 := checkDerefVar(glojure_DOT_core_map) + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v12 := args[0] + _ = v12 + tmp13 := checkDerefVar(glojure_DOT_core_future_call) + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + tmp15 := lang.Apply(v3, []any{v12}) + return tmp15 + }) + tmp15 := lang.Apply(tmp13, []any{tmp14}) + return tmp15 + }) + tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7041), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7041), lang.NewKeyword("end-column"), int(34)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp14 := lang.Apply(tmp10, []any{tmp13, v4}) + var v15 any = tmp14 + _ = v15 + // let binding "step" + var tmp16 lang.FnFunc + { // function step + var v17 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v18 := args[0] + _ = v18 + v19 := args[1] + _ = v19 + var tmp20 any + { // let + // let binding "vec__335" + var v21 any = v18 + _ = v21 + // let binding "seq__336" + tmp22 := checkDerefVar(glojure_DOT_core_seq) + tmp23 := lang.Apply(tmp22, []any{v21}) + var v24 any = tmp23 + _ = v24 + // let binding "first__337" + tmp25 := checkDerefVar(glojure_DOT_core_first) + tmp26 := lang.Apply(tmp25, []any{v24}) + var v27 any = tmp26 + _ = v27 + // let binding "seq__336" + tmp28 := checkDerefVar(glojure_DOT_core_next) + tmp29 := lang.Apply(tmp28, []any{v24}) + var v30 any = tmp29 + _ = v30 + // let binding "x" + var v31 any = v27 + _ = v31 + // let binding "xs" + var v32 any = v30 + _ = v32 + // let binding "vs" + var v33 any = v21 + _ = v33 + var tmp34 lang.FnFunc + tmp34 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var tmp35 any + { // let + // let binding "temp__0__auto__" + tmp36 := checkDerefVar(glojure_DOT_core_seq) + tmp37 := lang.Apply(tmp36, []any{v19}) + var v38 any = tmp37 + _ = v38 + var tmp39 any + if lang.IsTruthy(v38) { + var tmp40 any + { // let + // let binding "s" + var v41 any = v38 + _ = v41 + tmp42 := checkDerefVar(glojure_DOT_core_cons) + tmp43 := checkDerefVar(glojure_DOT_core_deref) + tmp44 := lang.Apply(tmp43, []any{v31}) + tmp45 := checkDerefVar(glojure_DOT_core_rest) + tmp46 := lang.Apply(tmp45, []any{v41}) + tmp47 := lang.Apply(v17, []any{v32, tmp46}) + tmp48 := lang.Apply(tmp42, []any{tmp44, tmp47}) + tmp40 = tmp48 + } // end let + tmp39 = tmp40 + } else { + tmp41 := checkDerefVar(glojure_DOT_core_map) + tmp42 := checkDerefVar(glojure_DOT_core_deref) + tmp43 := lang.Apply(tmp41, []any{tmp42, v33}) + tmp39 = tmp43 + } + tmp35 = tmp39 + } // end let + return tmp35 + }) + tmp35 := lang.Apply(lang.NewLazySeq, []any{tmp34}) + tmp20 = tmp35 + } // end let + return tmp20 + }) + v17 = tmp16 + _ = v17 + } + tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7042), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(7046), lang.NewKeyword("end-column"), int(36)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v19 any = tmp18 + _ = v19 + tmp20 := checkDerefVar(glojure_DOT_core_drop) + tmp21 := lang.Apply(tmp20, []any{v9, v15}) + tmp22 := lang.Apply(v19, []any{v15, tmp21}) + tmp5 = tmp22 + } // end let + return tmp5 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + var tmp6 any + { // let + // let binding "step" + var tmp7 lang.FnFunc + { // function step + var v8 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v9 := args[0] + _ = v9 + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var tmp11 any + { // let + // let binding "ss" + tmp12 := checkDerefVar(glojure_DOT_core_map) + tmp13 := checkDerefVar(glojure_DOT_core_seq) + tmp14 := lang.Apply(tmp12, []any{tmp13, v9}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + tmp17 := checkDerefVar(glojure_DOT_core_every_QMARK_) + tmp18 := checkDerefVar(glojure_DOT_core_identity) + tmp19 := lang.Apply(tmp17, []any{tmp18, v15}) + if lang.IsTruthy(tmp19) { + tmp20 := checkDerefVar(glojure_DOT_core_cons) + tmp21 := checkDerefVar(glojure_DOT_core_map) + tmp22 := checkDerefVar(glojure_DOT_core_first) + tmp23 := lang.Apply(tmp21, []any{tmp22, v15}) + tmp24 := checkDerefVar(glojure_DOT_core_map) + tmp25 := checkDerefVar(glojure_DOT_core_rest) + tmp26 := lang.Apply(tmp24, []any{tmp25, v15}) + tmp27 := lang.Apply(v8, []any{tmp26}) + tmp28 := lang.Apply(tmp20, []any{tmp23, tmp27}) + tmp16 = tmp28 + } else { + } + tmp11 = tmp16 + } // end let + return tmp11 + }) + tmp11 := lang.Apply(lang.NewLazySeq, []any{tmp10}) + return tmp11 + }) + v8 = tmp7 + _ = v8 + } + tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7049), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(7053), lang.NewKeyword("end-column"), int(67)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v10 any = tmp9 + _ = v10 + tmp11 := checkDerefVar(glojure_DOT_core_pmap) + var tmp12 lang.FnFunc + tmp12 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v13 := args[0] + _ = v13 + tmp14 := checkDerefVar(glojure_DOT_core_apply) + tmp15 := lang.Apply(tmp14, []any{v3, v13}) + return tmp15 + }) + tmp13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7054), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(7054), lang.NewKeyword("end-column"), int(23)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp15 := checkDerefVar(glojure_DOT_core_cons) + tmp16 := lang.Apply(tmp15, []any{v4, v5}) + tmp17 := lang.Apply(v10, []any{tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp14, tmp17}) + tmp6 = tmp18 + } // end let + return tmp6 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // pop + { + tmp0 := lang.NewSymbol("pop").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "For a list or queue, returns a new list/queue without the first\n item, for a vector, returns a new vector without the last item. If\n the collection is empty, throws an exception. Note - not the same\n as next/butlast.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1462), lang.NewKeyword("end-line"), int(1462))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(runtime7.RT, "Pop") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Pop is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // pop! + { + tmp0 := lang.NewSymbol("pop!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Removes the last item from a transient vector. If\n the collection is empty, throws an exception. Returns coll", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3393), lang.NewKeyword("end-line"), int(3393))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4, ok := lang.FieldOrMethod(v3, "pop") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "pop"))) + } + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { + case reflect.Func: + tmp5 = lang.Apply(tmp4, nil) + default: + tmp5 = tmp4 + } + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // pop-thread-bindings + { + tmp0 := lang.NewSymbol("pop-thread-bindings").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Pop one set of bindings pushed with push-binding before. It is an error to\n pop bindings without pushing before.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1929), lang.NewKeyword("end-line"), int(1929))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + tmp3 := lang.Apply(lang.PopThreadBindings, nil) + return tmp3 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // pos-int? + { + tmp0 := lang.NewSymbol("pos-int?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a positive fixed precision integer", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1403), lang.NewKeyword("end-line"), int(1403))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + { // let + // let binding "and__0__auto__" + tmp5 := checkDerefVar(glojure_DOT_core_int_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + if lang.IsTruthy(v7) { + tmp9 := checkDerefVar(glojure_DOT_core_pos_QMARK_) + tmp10 := lang.Apply(tmp9, []any{v3}) + tmp8 = tmp10 + } else { + tmp8 = v7 + } + tmp4 = tmp8 + } // end let + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // pos? + { + var tmp1 lang.FnFunc + { // function pos?__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := checkDerefVar(glojure_DOT_core_seq) + tmp12 := checkDerefVar(glojure_DOT_core_concat) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/IsPos")}) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("pos?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns true if num is greater than zero, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1252), lang.NewKeyword("end-line"), int(1252))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "IsPos") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("IsPos is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // pr + { + tmp0 := lang.NewSymbol("pr").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Prints the object(s) to the output stream that is the current value\n of *out*. Prints the object(s), separated by spaces if there is\n more than one. By default, pr and prn print in a way that objects\n can be read by the reader", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3678), lang.NewKeyword("end-line"), int(3678), lang.NewKeyword("dynamic"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return nil + case 1: + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_pr_on) + tmp5 := checkDerefVar(glojure_DOT_core__STAR_out_STAR_) + tmp6 := lang.Apply(tmp4, []any{v3, tmp5}) + return tmp6 + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any = lang.NewList(args[1:]...) + _ = v4 + recur_loop_671: + tmp5 := checkDerefVar(glojure_DOT_core_pr) + tmp6 := lang.Apply(tmp5, []any{v3}) + _ = tmp6 + tmp7 := checkDerefVar(glojure_DOT_core__STAR_out_STAR_) + tmp8 := lang.Apply(lang.AppendWriter, []any{tmp7, lang.NewChar(32)}) + _ = tmp8 + var tmp9 any + { // let + // let binding "temp__0__auto__" + tmp10 := checkDerefVar(glojure_DOT_core_next) + tmp11 := lang.Apply(tmp10, []any{v4}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + var tmp14 any + { // let + // let binding "nmore" + var v15 any = v12 + _ = v15 + tmp17 := checkDerefVar(glojure_DOT_core_first) + tmp18 := lang.Apply(tmp17, []any{v4}) + var tmp16 any = tmp18 + var tmp19 any = v15 + v3 = tmp16 + v4 = tmp19 + goto recur_loop_671 + } // end let + tmp13 = tmp14 + } else { + tmp15 := checkDerefVar(glojure_DOT_core_apply) + tmp16 := checkDerefVar(glojure_DOT_core_pr) + tmp17 := lang.Apply(tmp15, []any{tmp16, v4}) + tmp13 = tmp17 + } + tmp9 = tmp13 + } // end let + return tmp9 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // pr-on + { + tmp0 := lang.NewSymbol("pr-on").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("w"))), lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3669), lang.NewKeyword("end-line"), int(3669), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(glojure_DOT_core__STAR_print_dup_STAR_) + if lang.IsTruthy(tmp6) { + tmp7 := checkDerefVar(glojure_DOT_core_print_dup) + tmp8 := lang.Apply(tmp7, []any{v3, v4}) + tmp5 = tmp8 + } else { + tmp9 := checkDerefVar(glojure_DOT_core_print_method) + tmp10 := lang.Apply(tmp9, []any{v3, v4}) + tmp5 = tmp10 + } + _ = tmp5 + return nil + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // pr-str + { + tmp1 := reflect.TypeOf("") + tmp0 := lang.NewSymbol("pr-str").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("xs"))), lang.NewKeyword("doc"), "pr to a string, returning it", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4758), lang.NewKeyword("end-line"), int(4758))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v4 any = lang.NewList(args[0:]...) + _ = v4 + var tmp5 any + { // let + // let binding "s__0__auto__" + var v6 any = "unimplemented: new with non-constant class type" + _ = v6 + var tmp7 any + { // let + tmp8 := checkDerefVar(glojure_DOT_core_push_thread_bindings) + tmp9 := checkDerefVar(glojure_DOT_core_hash_map) + tmp10 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*out*")) + tmp11 := lang.Apply(tmp9, []any{tmp10, v6}) + tmp12 := lang.Apply(tmp8, []any{tmp11}) + _ = tmp12 + var tmp13 any + func() { + defer func() { + tmp14 := checkDerefVar(glojure_DOT_core_pop_thread_bindings) + tmp15 := lang.Apply(tmp14, nil) + _ = tmp15 + }() + tmp16 := checkDerefVar(glojure_DOT_core_apply) + tmp17 := checkDerefVar(glojure_DOT_core_pr) + tmp18 := lang.Apply(tmp16, []any{tmp17, v4}) + _ = tmp18 + tmp19 := checkDerefVar(glojure_DOT_core_str) + tmp20 := lang.Apply(tmp19, []any{v6}) + tmp13 = tmp20 + }() + tmp7 = tmp13 + } // end let + tmp5 = tmp7 + } // end let + return tmp5 + } + }) + tmp4 := reflect.TypeOf("") + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // prefer-method + { + tmp0 := lang.NewSymbol("prefer-method").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"), lang.NewSymbol("dispatch-val-x"), lang.NewSymbol("dispatch-val-y"))), lang.NewKeyword("doc"), "Causes the multimethod to prefer matches of dispatch-val-x over dispatch-val-y \n when there is a conflict", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1801), lang.NewKeyword("end-line"), int(1801))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6, _ := lang.FieldOrMethod(v3, "PreferMethod") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("PreferMethod is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // prefers + { + tmp0 := lang.NewSymbol("prefers").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"))), lang.NewKeyword("doc"), "Given a multimethod, returns a map of preferred value -> set of other values", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1822), lang.NewKeyword("end-line"), int(1822))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4, ok := lang.FieldOrMethod(v3, "getPreferTable") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getPreferTable"))) + } + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { + case reflect.Func: + tmp5 = lang.Apply(tmp4, nil) + default: + tmp5 = tmp4 + } + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // prep-hashes + { + tmp0 := lang.NewSymbol("prep-hashes").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr-sym"), lang.NewSymbol("default"), lang.NewSymbol("tests"), lang.NewSymbol("thens"))), lang.NewKeyword("doc"), "Takes a sequence of test constants and a corresponding sequence of then\n expressions. Returns a tuple of [shift mask case-map switch-type skip-check]\n where case-map is a map of int case values to [test then] tuples, switch-type\n is either :sparse or :compact, and skip-check is a set of case ints for which\n post-switch equivalence checking must not be done (occurs with hash\n collisions).", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6683), lang.NewKeyword("end-line"), int(6683), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + var tmp7 any + { // let + // let binding "hashcode" + var tmp8 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v9 := args[0] + _ = v9 + tmp10 := lang.Apply(lang.Hash, []any{v9}) + return tmp10 + }) + tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6691), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(6691), lang.NewKeyword("end-column"), int(66)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v11 any = tmp10 + _ = v11 + // let binding "hashes" + tmp12 := checkDerefVar(glojure_DOT_core_into1) + tmp13 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6692), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(6692), lang.NewKeyword("end-column"), int(25)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp16 := checkDerefVar(glojure_DOT_core_map) + tmp17 := lang.Apply(tmp16, []any{v11, v5}) + tmp18 := lang.Apply(tmp12, []any{tmp15, tmp17}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + tmp21 := checkDerefVar(glojure_DOT_core__EQ__EQ_) + tmp22 := checkDerefVar(glojure_DOT_core_count) + tmp23 := lang.Apply(tmp22, []any{v5}) + tmp24 := checkDerefVar(glojure_DOT_core_count) + tmp25 := lang.Apply(tmp24, []any{v19}) + tmp26 := lang.Apply(tmp21, []any{tmp23, tmp25}) + if lang.IsTruthy(tmp26) { + var tmp27 any + tmp28 := checkDerefVar(glojure_DOT_core_fits_table_QMARK_) + tmp29 := lang.Apply(tmp28, []any{v19}) + if lang.IsTruthy(tmp29) { + tmp30 := checkDerefVar(glojure_DOT_core_case_map) + tmp31 := checkDerefVar(glojure_DOT_core_identity) + tmp32 := lang.Apply(tmp30, []any{v11, tmp31, v5, v6}) + tmp33 := lang.NewVector(int64(0), int64(0), tmp32, lang.NewKeyword("compact")) + tmp34 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6696), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(6696), lang.NewKeyword("end-column"), int(63)) + tmp35, err := lang.WithMeta(tmp33, tmp34.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp27 = tmp35 + } else { + var tmp36 any + { // let + // let binding "vec__167" + var tmp37 any + { // let + // let binding "or__0__auto__" + tmp38 := checkDerefVar(glojure_DOT_core_maybe_min_hash) + tmp39 := lang.Apply(tmp38, []any{v19}) + var v40 any = tmp39 + _ = v40 + var tmp41 any + if lang.IsTruthy(v40) { + tmp41 = v40 + } else { + tmp42 := lang.NewVector(int64(0), int64(0)) + tmp43 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6697), lang.NewKeyword("column"), int(56), lang.NewKeyword("end-line"), int(6697), lang.NewKeyword("end-column"), int(60)) + tmp44, err := lang.WithMeta(tmp42, tmp43.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp41 = tmp44 + } + tmp37 = tmp41 + } // end let + var v38 any = tmp37 + _ = v38 + // let binding "shift" + tmp39 := checkDerefVar(glojure_DOT_core_nth) + tmp40 := lang.Apply(tmp39, []any{v38, int64(0), nil}) + var v41 any = tmp40 + _ = v41 + // let binding "mask" + tmp42 := checkDerefVar(glojure_DOT_core_nth) + tmp43 := lang.Apply(tmp42, []any{v38, int64(1), nil}) + var v44 any = tmp43 + _ = v44 + var tmp45 any + tmp46 := checkDerefVar(glojure_DOT_core_zero_QMARK_) + tmp47 := lang.Apply(tmp46, []any{v44}) + if lang.IsTruthy(tmp47) { + tmp48 := checkDerefVar(glojure_DOT_core_case_map) + tmp49 := checkDerefVar(glojure_DOT_core_identity) + tmp50 := lang.Apply(tmp48, []any{v11, tmp49, v5, v6}) + tmp51 := lang.NewVector(int64(0), int64(0), tmp50, lang.NewKeyword("sparse")) + tmp52 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6700), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(6700), lang.NewKeyword("end-column"), int(66)) + tmp53, err := lang.WithMeta(tmp51, tmp52.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp45 = tmp53 + } else { + tmp54 := checkDerefVar(glojure_DOT_core_case_map) + var tmp55 lang.FnFunc + tmp55 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v56 := args[0] + _ = v56 + tmp57 := checkDerefVar(glojure_DOT_core_shift_mask) + tmp58 := lang.Apply(v11, []any{v56}) + tmp59 := lang.Apply(tmp57, []any{v41, v44, tmp58}) + return tmp59 + }) + tmp56 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6702), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(6702), lang.NewKeyword("end-column"), int(71)) + tmp57, err := lang.WithMeta(tmp55, tmp56.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp58 := checkDerefVar(glojure_DOT_core_identity) + tmp59 := lang.Apply(tmp54, []any{tmp57, tmp58, v5, v6}) + tmp60 := lang.NewVector(v41, v44, tmp59, lang.NewKeyword("compact")) + tmp61 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6702), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(6702), lang.NewKeyword("end-column"), int(103)) + tmp62, err := lang.WithMeta(tmp60, tmp61.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp45 = tmp62 + } + tmp36 = tmp45 + } // end let + tmp27 = tmp36 + } + tmp20 = tmp27 + } else { + var tmp37 any + { // let + // let binding "vec__170" + tmp38 := checkDerefVar(glojure_DOT_core_merge_hash_collisions) + tmp39 := lang.Apply(tmp38, []any{v3, v4, v5, v6}) + var v40 any = tmp39 + _ = v40 + // let binding "tests" + tmp41 := checkDerefVar(glojure_DOT_core_nth) + tmp42 := lang.Apply(tmp41, []any{v40, int64(0), nil}) + var v43 any = tmp42 + _ = v43 + // let binding "thens" + tmp44 := checkDerefVar(glojure_DOT_core_nth) + tmp45 := lang.Apply(tmp44, []any{v40, int64(1), nil}) + var v46 any = tmp45 + _ = v46 + // let binding "skip-check" + tmp47 := checkDerefVar(glojure_DOT_core_nth) + tmp48 := lang.Apply(tmp47, []any{v40, int64(2), nil}) + var v49 any = tmp48 + _ = v49 + // let binding "vec__173" + tmp50 := checkDerefVar(glojure_DOT_core_prep_hashes) + tmp51 := lang.Apply(tmp50, []any{v3, v4, v43, v46}) + var v52 any = tmp51 + _ = v52 + // let binding "shift" + tmp53 := checkDerefVar(glojure_DOT_core_nth) + tmp54 := lang.Apply(tmp53, []any{v52, int64(0), nil}) + var v55 any = tmp54 + _ = v55 + // let binding "mask" + tmp56 := checkDerefVar(glojure_DOT_core_nth) + tmp57 := lang.Apply(tmp56, []any{v52, int64(1), nil}) + var v58 any = tmp57 + _ = v58 + // let binding "case-map" + tmp59 := checkDerefVar(glojure_DOT_core_nth) + tmp60 := lang.Apply(tmp59, []any{v52, int64(2), nil}) + var v61 any = tmp60 + _ = v61 + // let binding "switch-type" + tmp62 := checkDerefVar(glojure_DOT_core_nth) + tmp63 := lang.Apply(tmp62, []any{v52, int64(3), nil}) + var v64 any = tmp63 + _ = v64 + // let binding "skip-check" + var tmp65 any + tmp66 := checkDerefVar(glojure_DOT_core_zero_QMARK_) + tmp67 := lang.Apply(tmp66, []any{v58}) + if lang.IsTruthy(tmp67) { + tmp65 = v49 + } else { + tmp68 := checkDerefVar(glojure_DOT_core_into1) + tmp69 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp70 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6708), lang.NewKeyword("column"), int(33), lang.NewKeyword("end-line"), int(6708), lang.NewKeyword("end-column"), int(35)) + tmp71, err := lang.WithMeta(tmp69, tmp70.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp72 := checkDerefVar(glojure_DOT_core_map) + var tmp73 lang.FnFunc + tmp73 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v74 := args[0] + _ = v74 + tmp75 := checkDerefVar(glojure_DOT_core_shift_mask) + tmp76 := lang.Apply(tmp75, []any{v55, v58, v74}) + return tmp76 + }) + tmp74 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6708), lang.NewKeyword("column"), int(42), lang.NewKeyword("end-line"), int(6708), lang.NewKeyword("end-column"), int(67)) + tmp75, err := lang.WithMeta(tmp73, tmp74.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp76 := lang.Apply(tmp72, []any{tmp75, v49}) + tmp77 := lang.Apply(tmp68, []any{tmp71, tmp76}) + tmp65 = tmp77 + } + var v78 any = tmp65 + _ = v78 + tmp79 := lang.NewVector(v55, v58, v61, v64, v78) + tmp80 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6709), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(6709), lang.NewKeyword("end-column"), int(52)) + tmp81, err := lang.WithMeta(tmp79, tmp80.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp37 = tmp81 + } // end let + tmp20 = tmp37 + } + tmp7 = tmp20 + } // end let + return tmp7 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // prep-ints + { + tmp0 := lang.NewSymbol("prep-ints").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tests"), lang.NewSymbol("thens"))), lang.NewKeyword("doc"), "Takes a sequence of int-sized test constants and a corresponding sequence of\n then expressions. Returns a tuple of [shift mask case-map switch-type] where\n case-map is a map of int case values to [test then] tuples, and switch-type\n is either :sparse or :compact.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6631), lang.NewKeyword("end-line"), int(6631), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(glojure_DOT_core_fits_table_QMARK_) + tmp7 := lang.Apply(tmp6, []any{v3}) + if lang.IsTruthy(tmp7) { + tmp8 := checkDerefVar(glojure_DOT_core_case_map) + tmp9 := checkDerefVar(glojure_DOT_core_int) + tmp10 := checkDerefVar(glojure_DOT_core_int) + tmp11 := lang.Apply(tmp8, []any{tmp9, tmp10, v3, v4}) + tmp12 := lang.NewVector(int64(0), int64(0), tmp11, lang.NewKeyword("compact")) + tmp13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6639), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(6639), lang.NewKeyword("end-column"), int(49)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp5 = tmp14 + } else { + var tmp15 any + { // let + // let binding "vec__160" + var tmp16 any + { // let + // let binding "or__0__auto__" + tmp17 := checkDerefVar(glojure_DOT_core_maybe_min_hash) + tmp18 := checkDerefVar(glojure_DOT_core_map) + tmp19 := checkDerefVar(glojure_DOT_core_int) + tmp20 := lang.Apply(tmp18, []any{tmp19, v3}) + tmp21 := lang.Apply(tmp17, []any{tmp20}) + var v22 any = tmp21 + _ = v22 + var tmp23 any + if lang.IsTruthy(v22) { + tmp23 = v22 + } else { + tmp24 := lang.NewVector(int64(0), int64(0)) + tmp25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6640), lang.NewKeyword("column"), int(61), lang.NewKeyword("end-line"), int(6640), lang.NewKeyword("end-column"), int(65)) + tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp23 = tmp26 + } + tmp16 = tmp23 + } // end let + var v17 any = tmp16 + _ = v17 + // let binding "shift" + tmp18 := checkDerefVar(glojure_DOT_core_nth) + tmp19 := lang.Apply(tmp18, []any{v17, int64(0), nil}) + var v20 any = tmp19 + _ = v20 + // let binding "mask" + tmp21 := checkDerefVar(glojure_DOT_core_nth) + tmp22 := lang.Apply(tmp21, []any{v17, int64(1), nil}) + var v23 any = tmp22 + _ = v23 + var tmp24 any + tmp25 := checkDerefVar(glojure_DOT_core_zero_QMARK_) + tmp26 := lang.Apply(tmp25, []any{v23}) + if lang.IsTruthy(tmp26) { + tmp27 := checkDerefVar(glojure_DOT_core_case_map) + tmp28 := checkDerefVar(glojure_DOT_core_int) + tmp29 := checkDerefVar(glojure_DOT_core_int) + tmp30 := lang.Apply(tmp27, []any{tmp28, tmp29, v3, v4}) + tmp31 := lang.NewVector(int64(0), int64(0), tmp30, lang.NewKeyword("sparse")) + tmp32 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6643), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(6643), lang.NewKeyword("end-column"), int(52)) + tmp33, err := lang.WithMeta(tmp31, tmp32.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp24 = tmp33 + } else { + tmp34 := checkDerefVar(glojure_DOT_core_case_map) + var tmp35 lang.FnFunc + tmp35 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v36 := args[0] + _ = v36 + tmp37 := checkDerefVar(glojure_DOT_core_shift_mask) + tmp38 := checkDerefVar(glojure_DOT_core_int) + tmp39 := lang.Apply(tmp38, []any{v36}) + tmp40 := lang.Apply(tmp37, []any{v20, v23, tmp39}) + return tmp40 + }) + tmp36 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6645), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(6645), lang.NewKeyword("end-column"), int(62)) + tmp37, err := lang.WithMeta(tmp35, tmp36.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp38 := checkDerefVar(glojure_DOT_core_int) + tmp39 := lang.Apply(tmp34, []any{tmp37, tmp38, v3, v4}) + tmp40 := lang.NewVector(v20, v23, tmp39, lang.NewKeyword("compact")) + tmp41 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6645), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(6645), lang.NewKeyword("end-column"), int(89)) + tmp42, err := lang.WithMeta(tmp40, tmp41.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp24 = tmp42 + } + tmp15 = tmp24 + } // end let + tmp5 = tmp15 + } + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // prependss + { + tmp0 := lang.NewSymbol("prependss").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Prepends a symbol or a seq to coll", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5857), lang.NewKeyword("end-line"), int(5857), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(glojure_DOT_core_symbol_QMARK_) + tmp7 := lang.Apply(tmp6, []any{v3}) + if lang.IsTruthy(tmp7) { + tmp8 := checkDerefVar(glojure_DOT_core_cons) + tmp9 := lang.Apply(tmp8, []any{v3, v4}) + tmp5 = tmp9 + } else { + tmp10 := checkDerefVar(glojure_DOT_core_concat) + tmp11 := lang.Apply(tmp10, []any{v3, v4}) + tmp5 = tmp11 + } + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // preserving-reduced + { + tmp0 := lang.NewSymbol("preserving-reduced").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7638), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(7638), lang.NewKeyword("end-column"), int(34), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rf"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + var tmp7 any + { // let + // let binding "ret" + tmp8 := lang.Apply(v3, []any{v5, v6}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + tmp11 := checkDerefVar(glojure_DOT_core_reduced_QMARK_) + tmp12 := lang.Apply(tmp11, []any{v9}) + if lang.IsTruthy(tmp12) { + tmp13 := checkDerefVar(glojure_DOT_core_reduced) + tmp14 := lang.Apply(tmp13, []any{v9}) + tmp10 = tmp14 + } else { + tmp10 = v9 + } + tmp7 = tmp10 + } // end let + return tmp7 + }) + tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7640), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(7643), lang.NewKeyword("end-column"), int(12)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print + { + tmp0 := lang.NewSymbol("print").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Prints the object(s) to the output stream that is the current value\n of *out*. print and println produce output for human consumption.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3725), lang.NewKeyword("end-line"), int(3725))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v3 any = lang.NewList(args[0:]...) + _ = v3 + var tmp4 any + { // let + tmp5 := checkDerefVar(glojure_DOT_core_push_thread_bindings) + tmp6 := checkDerefVar(glojure_DOT_core_hash_map) + tmp7 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*print-readably*")) + tmp8 := lang.Apply(tmp6, []any{tmp7, nil}) + tmp9 := lang.Apply(tmp5, []any{tmp8}) + _ = tmp9 + var tmp10 any + func() { + defer func() { + tmp11 := checkDerefVar(glojure_DOT_core_pop_thread_bindings) + tmp12 := lang.Apply(tmp11, nil) + _ = tmp12 + }() + tmp13 := checkDerefVar(glojure_DOT_core_apply) + tmp14 := checkDerefVar(glojure_DOT_core_pr) + tmp15 := lang.Apply(tmp13, []any{tmp14, v3}) + tmp10 = tmp15 + }() + tmp4 = tmp10 + } // end let + return tmp4 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print-ctor + { + tmp0 := lang.NewSymbol("print-ctor").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(95), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(95), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("print-args"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6 := lang.Apply(lang.WriteWriter, []any{v5, "#=("}) + _ = tmp6 + tmp7 := checkDerefVar(glojure_DOT_core_class) + tmp8 := lang.Apply(tmp7, []any{v3}) + tmp9, ok := lang.FieldOrMethod(tmp8, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp8, "Name"))) + } + var tmp10 any + switch reflect.TypeOf(tmp9).Kind() { + case reflect.Func: + tmp10 = lang.Apply(tmp9, nil) + default: + tmp10 = tmp9 + } + tmp11 := lang.Apply(lang.WriteWriter, []any{v5, tmp10}) + _ = tmp11 + tmp12 := lang.Apply(lang.WriteWriter, []any{v5, ". "}) + _ = tmp12 + tmp13 := lang.Apply(v4, []any{v3, v5}) + _ = tmp13 + tmp14 := lang.Apply(lang.WriteWriter, []any{v5, ")"}) + return tmp14 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print-dup + { + tmp0 := lang.NewSymbol("print-dup").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3667), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(3667), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6 := checkDerefVar(glojure_DOT_core_class) + tmp7 := lang.Apply(tmp6, []any{v4}) + return tmp7 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3667), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(3667), lang.NewKeyword("end-column"), int(45))).(lang.FnFunc) + tmp2 := lang.NewMultiFn("print-dup", tmp3, lang.NewKeyword("default"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")).FindInternedVar(lang.NewSymbol("global-hierarchy"))) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_print_method) + tmp8 := lang.Apply(tmp7, []any{v5, v6}) + return tmp8 + }) + tmp2.AddMethod(nil, tmp4) + tmp5 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + tmp9 := checkDerefVar(glojure_DOT_core_print_method) + tmp10 := lang.Apply(tmp9, []any{v7, v8}) + return tmp10 + }) + tmp2.AddMethod(tmp5, tmp6) + tmp7 := reflect.TypeOf((*lang.IPersistentList)(nil)).Elem() + var tmp8 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v9 := args[0] + _ = v9 + v10 := args[1] + _ = v10 + tmp11 := checkDerefVar(glojure_DOT_core_print_method) + tmp12 := lang.Apply(tmp11, []any{v9, v10}) + return tmp12 + }) + tmp2.AddMethod(tmp7, tmp8) + tmp9 := reflect.TypeOf((*lang.Symbol)(nil)) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(glojure_DOT_core_print_method) + tmp14 := lang.Apply(tmp13, []any{v11, v12}) + return tmp14 + }) + tmp2.AddMethod(tmp9, tmp10) + tmp11 := reflect.TypeOf((*lang.IRecord)(nil)).Elem() + var tmp12 lang.FnFunc + tmp12 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v13 := args[0] + _ = v13 + v14 := args[1] + _ = v14 + tmp15 := checkDerefVar(glojure_DOT_core_print_meta) + tmp16 := lang.Apply(tmp15, []any{v13, v14}) + _ = tmp16 + tmp17 := lang.Apply(lang.WriteWriter, []any{v14, "#"}) + _ = tmp17 + tmp18 := checkDerefVar(glojure_DOT_core_class) + tmp19 := lang.Apply(tmp18, []any{v13}) + tmp20, ok := lang.FieldOrMethod(tmp19, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp19, "Name"))) + } + var tmp21 any + switch reflect.TypeOf(tmp20).Kind() { + case reflect.Func: + tmp21 = lang.Apply(tmp20, nil) + default: + tmp21 = tmp20 + } + tmp22 := lang.Apply(lang.WriteWriter, []any{v14, tmp21}) + _ = tmp22 + var tmp23 any + tmp24 := checkDerefVar(glojure_DOT_core__STAR_verbose_defrecords_STAR_) + if lang.IsTruthy(tmp24) { + tmp25 := checkDerefVar(glojure_DOT_core_print_map) + tmp26 := checkDerefVar(glojure_DOT_core_print_dup) + tmp27 := lang.Apply(tmp25, []any{v13, tmp26, v14}) + tmp23 = tmp27 + } else { + tmp28 := checkDerefVar(glojure_DOT_core_print_sequential) + tmp29 := checkDerefVar(glojure_DOT_core_pr_on) + tmp30 := checkDerefVar(glojure_DOT_core_vals) + tmp31 := lang.Apply(tmp30, []any{v13}) + tmp32 := lang.Apply(tmp28, []any{"[", tmp29, ", ", "]", tmp31, v14}) + tmp23 = tmp32 + } + return tmp23 + }) + tmp2.AddMethod(tmp11, tmp12) + tmp13 := reflect.TypeOf((*lang.Set)(nil)) + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v15 := args[0] + _ = v15 + v16 := args[1] + _ = v16 + tmp17 := checkDerefVar(glojure_DOT_core_print_method) + tmp18 := lang.Apply(tmp17, []any{v15, v16}) + return tmp18 + }) + tmp2.AddMethod(tmp13, tmp14) + tmp15 := reflect.TypeOf((*lang.PersistentHashMap)(nil)) + var tmp16 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v17 := args[0] + _ = v17 + v18 := args[1] + _ = v18 + tmp19 := checkDerefVar(glojure_DOT_core_print_method) + tmp20 := lang.Apply(tmp19, []any{v17, v18}) + return tmp20 + }) + tmp2.AddMethod(tmp15, tmp16) + tmp17 := reflect.TypeOf(int64(0)) + var tmp18 lang.FnFunc + tmp18 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v19 := args[0] + _ = v19 + v20 := args[1] + _ = v20 + tmp21 := checkDerefVar(glojure_DOT_core_print_method) + tmp22 := lang.Apply(tmp21, []any{v19, v20}) + return tmp22 + }) + tmp2.AddMethod(tmp17, tmp18) + tmp19 := reflect.TypeOf((*lang.Vector)(nil)) + var tmp20 lang.FnFunc + tmp20 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v21 := args[0] + _ = v21 + v22 := args[1] + _ = v22 + tmp23 := checkDerefVar(glojure_DOT_core_print_method) + tmp24 := lang.Apply(tmp23, []any{v21, v22}) + return tmp24 + }) + tmp2.AddMethod(tmp19, tmp20) + tmp21 := reflect.TypeOf(float64(0)) + var tmp22 lang.FnFunc + tmp22 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v23 := args[0] + _ = v23 + v24 := args[1] + _ = v24 + tmp25 := checkDerefVar(glojure_DOT_core_print_method) + tmp26 := lang.Apply(tmp25, []any{v23, v24}) + return tmp26 + }) + tmp2.AddMethod(tmp21, tmp22) + tmp23 := reflect.TypeOf("") + var tmp24 lang.FnFunc + tmp24 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v25 := args[0] + _ = v25 + v26 := args[1] + _ = v26 + tmp27 := checkDerefVar(glojure_DOT_core_print_method) + tmp28 := lang.Apply(tmp27, []any{v25, v26}) + return tmp28 + }) + tmp2.AddMethod(tmp23, tmp24) + tmp25 := reflect.TypeOf((*lang.IPersistentCollection)(nil)).Elem() + var tmp26 lang.FnFunc + tmp26 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v27 := args[0] + _ = v27 + v28 := args[1] + _ = v28 + tmp29 := checkDerefVar(glojure_DOT_core_print_meta) + tmp30 := lang.Apply(tmp29, []any{v27, v28}) + _ = tmp30 + tmp31 := lang.Apply(lang.WriteWriter, []any{v28, "#=("}) + _ = tmp31 + tmp32 := checkDerefVar(glojure_DOT_core_class) + tmp33 := lang.Apply(tmp32, []any{v27}) + tmp34, ok := lang.FieldOrMethod(tmp33, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp33, "Name"))) + } + var tmp35 any + switch reflect.TypeOf(tmp34).Kind() { + case reflect.Func: + tmp35 = lang.Apply(tmp34, nil) + default: + tmp35 = tmp34 + } + tmp36 := lang.Apply(lang.WriteWriter, []any{v28, tmp35}) + _ = tmp36 + tmp37 := lang.Apply(lang.WriteWriter, []any{v28, "/create "}) + _ = tmp37 + tmp38 := checkDerefVar(glojure_DOT_core_print_sequential) + tmp39 := checkDerefVar(glojure_DOT_core_print_dup) + tmp40 := lang.Apply(tmp38, []any{"[", tmp39, " ", "]", v27, v28}) + _ = tmp40 + tmp41 := lang.Apply(lang.WriteWriter, []any{v28, ")"}) + return tmp41 + }) + tmp2.AddMethod(tmp25, tmp26) + tmp27 := reflect.TypeOf(int32(0)) + var tmp28 lang.FnFunc + tmp28 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v29 := args[0] + _ = v29 + v30 := args[1] + _ = v30 + tmp31 := checkDerefVar(glojure_DOT_core_print_method) + tmp32 := lang.Apply(tmp31, []any{v29, v30}) + return tmp32 + }) + tmp2.AddMethod(tmp27, tmp28) + tmp29 := reflect.TypeOf((*lang.IPersistentMap)(nil)).Elem() + var tmp30 lang.FnFunc + tmp30 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v31 := args[0] + _ = v31 + v32 := args[1] + _ = v32 + tmp33 := checkDerefVar(glojure_DOT_core_print_meta) + tmp34 := lang.Apply(tmp33, []any{v31, v32}) + _ = tmp34 + tmp35 := lang.Apply(lang.WriteWriter, []any{v32, "#=("}) + _ = tmp35 + tmp36 := checkDerefVar(glojure_DOT_core_class) + tmp37 := lang.Apply(tmp36, []any{v31}) + tmp38, ok := lang.FieldOrMethod(tmp37, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp37, "Name"))) + } + var tmp39 any + switch reflect.TypeOf(tmp38).Kind() { + case reflect.Func: + tmp39 = lang.Apply(tmp38, nil) + default: + tmp39 = tmp38 + } + tmp40 := lang.Apply(lang.WriteWriter, []any{v32, tmp39}) + _ = tmp40 + tmp41 := lang.Apply(lang.WriteWriter, []any{v32, "/create "}) + _ = tmp41 + tmp42 := checkDerefVar(glojure_DOT_core_print_map) + tmp43 := checkDerefVar(glojure_DOT_core_print_dup) + tmp44 := lang.Apply(tmp42, []any{v31, tmp43, v32}) + _ = tmp44 + tmp45 := lang.Apply(lang.WriteWriter, []any{v32, ")"}) + return tmp45 + }) + tmp2.AddMethod(tmp29, tmp30) + tmp31 := reflect.TypeOf((*lang.Namespace)(nil)) + var tmp32 lang.FnFunc + tmp32 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v33 := args[0] + _ = v33 + v34 := args[1] + _ = v34 + tmp35 := lang.Apply(lang.WriteWriter, []any{v34, "#=(find-ns "}) + _ = tmp35 + tmp36 := checkDerefVar(glojure_DOT_core_print_dup) + tmp37, ok := lang.FieldOrMethod(v33, "name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v33, "name"))) + } + var tmp38 any + switch reflect.TypeOf(tmp37).Kind() { + case reflect.Func: + tmp38 = lang.Apply(tmp37, nil) + default: + tmp38 = tmp37 + } + tmp39 := lang.Apply(tmp36, []any{tmp38, v34}) + _ = tmp39 + tmp40 := lang.Apply(lang.WriteWriter, []any{v34, ")"}) + return tmp40 + }) + tmp2.AddMethod(tmp31, tmp32) + tmp33 := reflect.TypeOf(false) + var tmp34 lang.FnFunc + tmp34 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v35 := args[0] + _ = v35 + v36 := args[1] + _ = v36 + tmp37 := checkDerefVar(glojure_DOT_core_print_method) + tmp38 := lang.Apply(tmp37, []any{v35, v36}) + return tmp38 + }) + tmp2.AddMethod(tmp33, tmp34) + tmp35 := reflect.TypeOf((*regexp15.Regexp)(nil)) + var tmp36 lang.FnFunc + tmp36 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v37 := args[0] + _ = v37 + v38 := args[1] + _ = v38 + tmp39 := checkDerefVar(glojure_DOT_core_print_method) + tmp40 := lang.Apply(tmp39, []any{v37, v38}) + return tmp40 + }) + tmp2.AddMethod(tmp35, tmp36) + tmp37 := reflect.TypeOf((*lang.Ratio)(nil)) + var tmp38 lang.FnFunc + tmp38 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v39 := args[0] + _ = v39 + v40 := args[1] + _ = v40 + tmp41 := checkDerefVar(glojure_DOT_core_print_method) + tmp42 := lang.Apply(tmp41, []any{v39, v40}) + return tmp42 + }) + tmp2.AddMethod(tmp37, tmp38) + tmp39 := reflect.TypeOf((*lang.Var)(nil)) + var tmp40 lang.FnFunc + tmp40 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v41 := args[0] + _ = v41 + v42 := args[1] + _ = v42 + tmp43 := checkDerefVar(glojure_DOT_core_str) + tmp44, ok := lang.FieldOrMethod(v41, "Namespace") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v41, "Namespace"))) + } + var tmp45 any + switch reflect.TypeOf(tmp44).Kind() { + case reflect.Func: + tmp45 = lang.Apply(tmp44, nil) + default: + tmp45 = tmp44 + } + tmp46, ok := lang.FieldOrMethod(tmp45, "name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp45, "name"))) + } + var tmp47 any + switch reflect.TypeOf(tmp46).Kind() { + case reflect.Func: + tmp47 = lang.Apply(tmp46, nil) + default: + tmp47 = tmp46 + } + tmp48, ok := lang.FieldOrMethod(v41, "sym") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v41, "sym"))) + } + var tmp49 any + switch reflect.TypeOf(tmp48).Kind() { + case reflect.Func: + tmp49 = lang.Apply(tmp48, nil) + default: + tmp49 = tmp48 + } + tmp50 := lang.Apply(tmp43, []any{"#=(var ", tmp47, "/", tmp49, ")"}) + tmp51 := lang.Apply(lang.WriteWriter, []any{v42, tmp50}) + return tmp51 + }) + tmp2.AddMethod(tmp39, tmp40) + tmp41 := reflect.TypeOf((*lang.BigDecimal)(nil)) + var tmp42 lang.FnFunc + tmp42 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v43 := args[0] + _ = v43 + v44 := args[1] + _ = v44 + tmp45 := checkDerefVar(glojure_DOT_core_print_method) + tmp46 := lang.Apply(tmp45, []any{v43, v44}) + return tmp46 + }) + tmp2.AddMethod(tmp41, tmp42) + tmp43 := reflect.TypeOf((*lang.BigInt)(nil)) + var tmp44 lang.FnFunc + tmp44 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v45 := args[0] + _ = v45 + v46 := args[1] + _ = v46 + tmp47 := checkDerefVar(glojure_DOT_core_print_method) + tmp48 := lang.Apply(tmp47, []any{v45, v46}) + return tmp48 + }) + tmp2.AddMethod(tmp43, tmp44) + tmp45 := reflect.TypeOf((*runtime7.Fn)(nil)) + var tmp46 lang.FnFunc + tmp46 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v47 := args[0] + _ = v47 + v48 := args[1] + _ = v48 + tmp49 := checkDerefVar(glojure_DOT_core_print_ctor) + var tmp50 lang.FnFunc + tmp50 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v51 := args[0] + _ = v51 + v52 := args[1] + _ = v52 + return nil + }) + tmp51 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(167), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(167), lang.NewKeyword("end-column"), int(26)) + tmp52, err := lang.WithMeta(tmp50, tmp51.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp53 := lang.Apply(tmp49, []any{v47, tmp52, v48}) + return tmp53 + }) + tmp2.AddMethod(tmp45, tmp46) + tmp47 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() + var tmp48 lang.FnFunc + tmp48 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v49 := args[0] + _ = v49 + v50 := args[1] + _ = v50 + tmp51 := checkDerefVar(glojure_DOT_core_print_method) + tmp52 := lang.Apply(tmp51, []any{v49, v50}) + return tmp52 + }) + tmp2.AddMethod(tmp47, tmp48) + tmp49 := reflect.TypeOf((*lang.IPersistentCollection)(nil)).Elem() + tmp50 := reflect.TypeOf((*runtime7.Fn)(nil)) + tmp2.PreferMethod(tmp49, tmp50) + tmp51 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() + tmp52 := reflect.TypeOf((*lang.IPersistentCollection)(nil)).Elem() + tmp2.PreferMethod(tmp51, tmp52) + tmp53 := reflect.TypeOf((*lang.IRecord)(nil)).Elem() + tmp54 := reflect.TypeOf((*lang.IPersistentMap)(nil)).Elem() + tmp2.PreferMethod(tmp53, tmp54) + tmp55 := reflect.TypeOf((*lang.IRecord)(nil)).Elem() + tmp56 := reflect.TypeOf((*lang.IPersistentCollection)(nil)).Elem() + tmp2.PreferMethod(tmp55, tmp56) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print-initialized + { + tmp0 := lang.NewSymbol("print-initialized").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(520), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(520), lang.NewKeyword("end-column"), int(39), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, true, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print-map + { + tmp0 := lang.NewSymbol("print-map").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(252), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(252), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("print-one"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6 := checkDerefVar(glojure_DOT_core_print_prefix_map) + tmp7 := lang.Apply(tmp6, []any{nil, v3, v4, v5}) + return tmp7 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print-meta + { + tmp0 := lang.NewSymbol("print-meta").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(70), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(70), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 any + { // let + // let binding "temp__0__auto__" + tmp6 := checkDerefVar(glojure_DOT_core_meta) + tmp7 := lang.Apply(tmp6, []any{v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + var tmp10 any + { // let + // let binding "m" + var v11 any = v8 + _ = v11 + var tmp12 any + var tmp13 any + { // let + // let binding "and__0__auto__" + tmp14 := checkDerefVar(glojure_DOT_core_pos_QMARK_) + tmp15 := checkDerefVar(glojure_DOT_core_count) + tmp16 := lang.Apply(tmp15, []any{v11}) + tmp17 := lang.Apply(tmp14, []any{tmp16}) + var v18 any = tmp17 + _ = v18 + var tmp19 any + if lang.IsTruthy(v18) { + var tmp20 any + { // let + // let binding "or__0__auto__" + tmp21 := checkDerefVar(glojure_DOT_core__STAR_print_dup_STAR_) + var v22 any = tmp21 + _ = v22 + var tmp23 any + if lang.IsTruthy(v22) { + tmp23 = v22 + } else { + var tmp24 any + { // let + // let binding "and__0__auto__" + tmp25 := checkDerefVar(glojure_DOT_core__STAR_print_meta_STAR_) + var v26 any = tmp25 + _ = v26 + var tmp27 any + if lang.IsTruthy(v26) { + tmp28 := checkDerefVar(glojure_DOT_core__STAR_print_readably_STAR_) + tmp27 = tmp28 + } else { + tmp27 = v26 + } + tmp24 = tmp27 + } // end let + tmp23 = tmp24 + } + tmp20 = tmp23 + } // end let + tmp19 = tmp20 + } else { + tmp19 = v18 + } + tmp13 = tmp19 + } // end let + if lang.IsTruthy(tmp13) { + tmp14 := lang.Apply(lang.WriteWriter, []any{v4, "^"}) + _ = tmp14 + var tmp15 any + var tmp16 any + { // let + // let binding "and__0__auto__" + tmp17 := checkDerefVar(glojure_DOT_core__EQ_) + tmp18 := checkDerefVar(glojure_DOT_core_count) + tmp19 := lang.Apply(tmp18, []any{v11}) + tmp20 := lang.Apply(tmp17, []any{tmp19, int64(1)}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + if lang.IsTruthy(v21) { + tmp23 := lang.Apply(lang.NewKeyword("tag"), []any{v11}) + tmp22 = tmp23 + } else { + tmp22 = v21 + } + tmp16 = tmp22 + } // end let + if lang.IsTruthy(tmp16) { + tmp17 := checkDerefVar(glojure_DOT_core_pr_on) + tmp18 := lang.Apply(lang.NewKeyword("tag"), []any{v11}) + tmp19 := lang.Apply(tmp17, []any{tmp18, v4}) + tmp15 = tmp19 + } else { + tmp20 := checkDerefVar(glojure_DOT_core_pr_on) + tmp21 := lang.Apply(tmp20, []any{v11, v4}) + tmp15 = tmp21 + } + _ = tmp15 + tmp22 := lang.Apply(lang.WriteWriter, []any{v4, " "}) + tmp12 = tmp22 + } else { + } + tmp10 = tmp12 + } // end let + tmp9 = tmp10 + } else { + } + tmp5 = tmp9 + } // end let + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print-method + { + tmp0 := lang.NewSymbol("print-method").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3664), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(3664), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var tmp6 any + { // let + // let binding "t" + tmp7 := checkDerefVar(glojure_DOT_core_get) + tmp8 := checkDerefVar(glojure_DOT_core_meta) + tmp9 := lang.Apply(tmp8, []any{v4}) + tmp10 := lang.Apply(tmp7, []any{tmp9, lang.NewKeyword("type")}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + tmp13 := checkDerefVar(glojure_DOT_core_keyword_QMARK_) + tmp14 := lang.Apply(tmp13, []any{v11}) + if lang.IsTruthy(tmp14) { + tmp12 = v11 + } else { + tmp15 := checkDerefVar(glojure_DOT_core_class) + tmp16 := lang.Apply(tmp15, []any{v4}) + tmp12 = tmp16 + } + tmp6 = tmp12 + } // end let + return tmp6 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3664), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(3666), lang.NewKeyword("end-column"), int(58))).(lang.FnFunc) + tmp2 := lang.NewMultiFn("print-method", tmp3, lang.NewKeyword("default"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")).FindInternedVar(lang.NewSymbol("global-hierarchy"))) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + tmp7 := lang.Apply(lang.WriteWriter, []any{v6, "nil"}) + return tmp7 + }) + tmp2.AddMethod(nil, tmp4) + tmp5 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + tmp9 := checkDerefVar(glojure_DOT_core_str) + tmp10 := lang.Apply(tmp9, []any{v7}) + tmp11 := lang.Apply(lang.WriteWriter, []any{v8, tmp10}) + return tmp11 + }) + tmp2.AddMethod(tmp5, tmp6) + tmp7 := reflect.TypeOf(uint32(0)) + var tmp8 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v9 := args[0] + _ = v9 + v10 := args[1] + _ = v10 + tmp11 := checkDerefVar(glojure_DOT_core_str) + tmp12 := lang.Apply(tmp11, []any{v9}) + tmp13, _ := lang.FieldOrMethod(v10, "write") + if reflect.TypeOf(tmp13).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + } + tmp14 := lang.Apply(tmp13, []any{tmp12}) + return tmp14 + }) + tmp2.AddMethod(tmp7, tmp8) + tmp9 := reflect.TypeOf((*lang.Symbol)(nil)) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(glojure_DOT_core_print_simple) + tmp14 := lang.Apply(tmp13, []any{v11, v12}) + return tmp14 + }) + tmp2.AddMethod(tmp9, tmp10) + tmp11 := reflect.TypeOf((*lang.IRecord)(nil)).Elem() + var tmp12 lang.FnFunc + tmp12 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v13 := args[0] + _ = v13 + v14 := args[1] + _ = v14 + tmp15 := checkDerefVar(glojure_DOT_core_print_meta) + tmp16 := lang.Apply(tmp15, []any{v13, v14}) + _ = tmp16 + tmp17 := lang.Apply(lang.WriteWriter, []any{v14, "#"}) + _ = tmp17 + tmp18 := checkDerefVar(glojure_DOT_core_class) + tmp19 := lang.Apply(tmp18, []any{v13}) + tmp20, ok := lang.FieldOrMethod(tmp19, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp19, "Name"))) + } + var tmp21 any + switch reflect.TypeOf(tmp20).Kind() { + case reflect.Func: + tmp21 = lang.Apply(tmp20, nil) + default: + tmp21 = tmp20 + } + tmp22 := lang.Apply(lang.WriteWriter, []any{v14, tmp21}) + _ = tmp22 + tmp23 := checkDerefVar(glojure_DOT_core_print_map) + tmp24 := checkDerefVar(glojure_DOT_core_pr_on) + tmp25 := lang.Apply(tmp23, []any{v13, tmp24, v14}) + return tmp25 + }) + tmp2.AddMethod(tmp11, tmp12) + tmp13 := reflect.TypeOf(uint(0)) + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v15 := args[0] + _ = v15 + v16 := args[1] + _ = v16 + tmp17 := checkDerefVar(glojure_DOT_core_str) + tmp18 := lang.Apply(tmp17, []any{v15}) + tmp19, _ := lang.FieldOrMethod(v16, "write") + if reflect.TypeOf(tmp19).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + } + tmp20 := lang.Apply(tmp19, []any{tmp18}) + return tmp20 + }) + tmp2.AddMethod(tmp13, tmp14) + tmp15 := reflect.TypeOf(int64(0)) + var tmp16 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v17 := args[0] + _ = v17 + v18 := args[1] + _ = v18 + tmp19 := checkDerefVar(glojure_DOT_core_str) + tmp20 := lang.Apply(tmp19, []any{v17}) + tmp21, _ := lang.FieldOrMethod(v18, "write") + if reflect.TypeOf(tmp21).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + } + tmp22 := lang.Apply(tmp21, []any{tmp20}) + return tmp22 + }) + tmp2.AddMethod(tmp15, tmp16) + var tmp17 lang.FnFunc + tmp17 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v18 := args[0] + _ = v18 + v19 := args[1] + _ = v19 + var tmp20 any + tmp21 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp22 := reflect.TypeOf((*lang.IObj)(nil)).Elem() + tmp23 := lang.Apply(tmp21, []any{tmp22, v18}) + if lang.IsTruthy(tmp23) { + tmp24 := checkDerefVar(glojure_DOT_core_print_method) + tmp25 := checkDerefVar(glojure_DOT_core_vary_meta) + var tmp26 lang.FnFunc + tmp26 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v27 := args[0] + _ = v27 + tmp28 := checkDerefVar(glojure_DOT_core_dissoc) + tmp29 := lang.Apply(tmp28, []any{v27, lang.NewKeyword("type")}) + return tmp29 + }) + tmp27 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(87), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(87), lang.NewKeyword("end-column"), int(48)) + tmp28, err := lang.WithMeta(tmp26, tmp27.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp29 := lang.Apply(tmp25, []any{v18, tmp28}) + tmp30 := lang.Apply(tmp24, []any{tmp29, v19}) + tmp20 = tmp30 + } else { + tmp31 := checkDerefVar(glojure_DOT_core_print_simple) + tmp32 := lang.Apply(tmp31, []any{v18, v19}) + tmp20 = tmp32 + } + return tmp20 + }) + tmp2.AddMethod(lang.NewKeyword("default"), tmp17) + tmp18 := reflect.TypeOf(float64(0)) + var tmp19 lang.FnFunc + tmp19 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v20 := args[0] + _ = v20 + v21 := args[1] + _ = v21 + var tmp22 any + tmp23 := checkDerefVar(glojure_DOT_core__EQ_) + tmp24 := lang.Apply(math6.Inf, []any{int64(1)}) + tmp25 := lang.Apply(tmp23, []any{tmp24, v20}) + if lang.IsTruthy(tmp25) { + tmp26 := lang.Apply(lang.WriteWriter, []any{v21, "##Inf"}) + tmp22 = tmp26 + } else { + var tmp27 any + tmp28 := checkDerefVar(glojure_DOT_core__EQ_) + tmp29 := lang.Apply(math6.Inf, []any{int64(-1)}) + tmp30 := lang.Apply(tmp28, []any{tmp29, v20}) + if lang.IsTruthy(tmp30) { + tmp31 := lang.Apply(lang.WriteWriter, []any{v21, "##-Inf"}) + tmp27 = tmp31 + } else { + var tmp32 any + tmp33 := lang.Apply(math6.IsNaN, []any{v20}) + if lang.IsTruthy(tmp33) { + tmp34 := lang.Apply(lang.WriteWriter, []any{v21, "##NaN"}) + tmp32 = tmp34 + } else { + var tmp35 any + if lang.IsTruthy(lang.NewKeyword("else")) { + tmp36 := checkDerefVar(glojure_DOT_core_str) + tmp37 := lang.Apply(tmp36, []any{v20}) + tmp38 := lang.Apply(lang.WriteWriter, []any{v21, tmp37}) + tmp35 = tmp38 + } else { + } + tmp32 = tmp35 + } + tmp27 = tmp32 + } + tmp22 = tmp27 + } + return tmp22 + }) + tmp2.AddMethod(tmp18, tmp19) + tmp20 := reflect.TypeOf("") + var tmp21 lang.FnFunc + tmp21 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v22 := args[0] + _ = v22 + v23 := args[1] + _ = v23 + var tmp24 any + var tmp25 any + { // let + // let binding "or__0__auto__" + tmp26 := checkDerefVar(glojure_DOT_core__STAR_print_dup_STAR_) + var v27 any = tmp26 + _ = v27 + var tmp28 any + if lang.IsTruthy(v27) { + tmp28 = v27 + } else { + tmp29 := checkDerefVar(glojure_DOT_core__STAR_print_readably_STAR_) + tmp28 = tmp29 + } + tmp25 = tmp28 + } // end let + if lang.IsTruthy(tmp25) { + tmp26 := lang.Apply(lang.AppendWriter, []any{v23, lang.NewChar(34)}) + _ = tmp26 + var tmp27 any + { // let + // let binding "n__0__auto__" + tmp28 := checkDerefVar(glojure_DOT_core_long) + tmp29 := checkDerefVar(glojure_DOT_core_count) + tmp30 := lang.Apply(tmp29, []any{v22}) + tmp31 := lang.Apply(tmp28, []any{tmp30}) + var v32 any = tmp31 + _ = v32 + var tmp33 any + { // let + // let binding "n" + var v34 any = int64(0) + _ = v34 + for { + var tmp35 any + tmp36 := checkDerefVar(glojure_DOT_core__LT_) + tmp37 := lang.Apply(tmp36, []any{v34, v32}) + if lang.IsTruthy(tmp37) { + var tmp38 any + { // let + // let binding "c" + tmp39 := lang.Apply(lang.CharAt, []any{v22, v34}) + var v40 any = tmp39 + _ = v40 + // let binding "e" + tmp41 := checkDerefVar(glojure_DOT_core_char_escape_string) + tmp42 := lang.Apply(tmp41, []any{v40}) + var v43 any = tmp42 + _ = v43 + var tmp44 any + if lang.IsTruthy(v43) { + tmp45 := lang.Apply(lang.WriteWriter, []any{v23, v43}) + tmp44 = tmp45 + } else { + tmp46 := lang.Apply(lang.AppendWriter, []any{v23, v40}) + tmp44 = tmp46 + } + tmp38 = tmp44 + } // end let + _ = tmp38 + tmp40 := checkDerefVar(glojure_DOT_core_unchecked_inc) + tmp41 := lang.Apply(tmp40, []any{v34}) + var tmp39 any = tmp41 + v34 = tmp39 + continue + } else { + } + tmp33 = tmp35 + break + } + } // end let + tmp27 = tmp33 + } // end let + _ = tmp27 + tmp28 := lang.Apply(lang.AppendWriter, []any{v23, lang.NewChar(34)}) + tmp24 = tmp28 + } else { + tmp29 := lang.Apply(lang.WriteWriter, []any{v23, v22}) + tmp24 = tmp29 + } + _ = tmp24 + return nil + }) + tmp2.AddMethod(tmp20, tmp21) + tmp22 := reflect.TypeOf(int32(0)) + var tmp23 lang.FnFunc + tmp23 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v24 := args[0] + _ = v24 + v25 := args[1] + _ = v25 + var tmp26 any + var tmp27 any + { // let + // let binding "or__0__auto__" + tmp28 := checkDerefVar(glojure_DOT_core__STAR_print_dup_STAR_) + var v29 any = tmp28 + _ = v29 + var tmp30 any + if lang.IsTruthy(v29) { + tmp30 = v29 + } else { + tmp31 := checkDerefVar(glojure_DOT_core__STAR_print_readably_STAR_) + tmp30 = tmp31 + } + tmp27 = tmp30 + } // end let + if lang.IsTruthy(tmp27) { + tmp28 := lang.Apply(lang.AppendWriter, []any{v25, lang.NewChar(92)}) + _ = tmp28 + var tmp29 any + { // let + // let binding "n" + tmp30 := checkDerefVar(glojure_DOT_core_char_name_string) + tmp31 := lang.Apply(tmp30, []any{v24}) + var v32 any = tmp31 + _ = v32 + var tmp33 any + if lang.IsTruthy(v32) { + tmp34 := lang.Apply(lang.WriteWriter, []any{v25, v32}) + tmp33 = tmp34 + } else { + tmp35 := lang.Apply(lang.AppendWriter, []any{v25, v24}) + tmp33 = tmp35 + } + tmp29 = tmp33 + } // end let + tmp26 = tmp29 + } else { + tmp30 := lang.Apply(lang.AppendWriter, []any{v25, v24}) + tmp26 = tmp30 + } + _ = tmp26 + return nil + }) + tmp2.AddMethod(tmp22, tmp23) + tmp24 := reflect.TypeOf((*lang.IPersistentMap)(nil)).Elem() + var tmp25 lang.FnFunc + tmp25 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v26 := args[0] + _ = v26 + v27 := args[1] + _ = v27 + tmp28 := checkDerefVar(glojure_DOT_core_print_meta) + tmp29 := lang.Apply(tmp28, []any{v26, v27}) + _ = tmp29 + var tmp30 any + { // let + // let binding "vec__234" + tmp31 := checkDerefVar(glojure_DOT_core_lift_ns) + tmp32 := lang.Apply(tmp31, []any{v26}) + var v33 any = tmp32 + _ = v33 + // let binding "ns" + tmp34 := checkDerefVar(glojure_DOT_core_nth) + tmp35 := lang.Apply(tmp34, []any{v33, int64(0), nil}) + var v36 any = tmp35 + _ = v36 + // let binding "lift-kvs" + tmp37 := checkDerefVar(glojure_DOT_core_nth) + tmp38 := lang.Apply(tmp37, []any{v33, int64(1), nil}) + var v39 any = tmp38 + _ = v39 + var tmp40 any + if lang.IsTruthy(v36) { + tmp41 := checkDerefVar(glojure_DOT_core_print_prefix_map) + tmp42 := checkDerefVar(glojure_DOT_core_str) + tmp43 := lang.Apply(tmp42, []any{"#:", v36}) + tmp44 := checkDerefVar(glojure_DOT_core_pr_on) + tmp45 := lang.Apply(tmp41, []any{tmp43, v39, tmp44, v27}) + tmp40 = tmp45 + } else { + tmp46 := checkDerefVar(glojure_DOT_core_print_map) + tmp47 := checkDerefVar(glojure_DOT_core_pr_on) + tmp48 := lang.Apply(tmp46, []any{v26, tmp47, v27}) + tmp40 = tmp48 + } + tmp30 = tmp40 + } // end let + return tmp30 + }) + tmp2.AddMethod(tmp24, tmp25) + tmp26 := reflect.TypeOf((*lang.IPersistentVector)(nil)).Elem() + var tmp27 lang.FnFunc + tmp27 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v28 := args[0] + _ = v28 + v29 := args[1] + _ = v29 + tmp30 := checkDerefVar(glojure_DOT_core_print_meta) + tmp31 := lang.Apply(tmp30, []any{v28, v29}) + _ = tmp31 + tmp32 := checkDerefVar(glojure_DOT_core_print_sequential) + tmp33 := checkDerefVar(glojure_DOT_core_pr_on) + tmp34 := lang.Apply(tmp32, []any{"[", tmp33, " ", "]", v28, v29}) + return tmp34 + }) + tmp2.AddMethod(tmp26, tmp27) + tmp28 := reflect.TypeOf((*lang.IPersistentSet)(nil)).Elem() + var tmp29 lang.FnFunc + tmp29 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v30 := args[0] + _ = v30 + v31 := args[1] + _ = v31 + tmp32 := checkDerefVar(glojure_DOT_core_print_meta) + tmp33 := lang.Apply(tmp32, []any{v30, v31}) + _ = tmp33 + tmp34 := checkDerefVar(glojure_DOT_core_print_sequential) + tmp35 := checkDerefVar(glojure_DOT_core_pr_on) + tmp36 := checkDerefVar(glojure_DOT_core_seq) + tmp37 := lang.Apply(tmp36, []any{v30}) + tmp38 := lang.Apply(tmp34, []any{"#{", tmp35, " ", "}", tmp37, v31}) + return tmp38 + }) + tmp2.AddMethod(tmp28, tmp29) + tmp30 := reflect.TypeOf(uint8(0)) + var tmp31 lang.FnFunc + tmp31 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v32 := args[0] + _ = v32 + v33 := args[1] + _ = v33 + tmp34 := checkDerefVar(glojure_DOT_core_str) + tmp35 := lang.Apply(tmp34, []any{v32}) + tmp36, _ := lang.FieldOrMethod(v33, "write") + if reflect.TypeOf(tmp36).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + } + tmp37 := lang.Apply(tmp36, []any{tmp35}) + return tmp37 + }) + tmp2.AddMethod(tmp30, tmp31) + tmp32 := reflect.TypeOf((*lang.IDeref)(nil)).Elem() + var tmp33 lang.FnFunc + tmp33 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v34 := args[0] + _ = v34 + v35 := args[1] + _ = v35 + tmp36 := checkDerefVar(glojure_DOT_core_print_tagged_object) + tmp37 := checkDerefVar(glojure_DOT_core_deref_as_map) + tmp38 := lang.Apply(tmp37, []any{v34}) + tmp39 := lang.Apply(tmp36, []any{v34, tmp38, v35}) + return tmp39 + }) + tmp2.AddMethod(tmp32, tmp33) + tmp34 := reflect.TypeOf(false) + var tmp35 lang.FnFunc + tmp35 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v36 := args[0] + _ = v36 + v37 := args[1] + _ = v37 + tmp38 := checkDerefVar(glojure_DOT_core_str) + tmp39 := lang.Apply(tmp38, []any{v36}) + tmp40 := lang.Apply(lang.WriteWriter, []any{v37, tmp39}) + return tmp40 + }) + tmp2.AddMethod(tmp34, tmp35) + tmp36 := reflect.TypeOf((*lang.Object)(nil)).Elem() + var tmp37 lang.FnFunc + tmp37 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v38 := args[0] + _ = v38 + v39 := args[1] + _ = v39 + tmp40 := checkDerefVar(glojure_DOT_core_print_object) + tmp41 := lang.Apply(tmp40, []any{v38, v39}) + return tmp41 + }) + tmp2.AddMethod(tmp36, tmp37) + tmp38 := reflect.TypeOf(int(0)) + var tmp39 lang.FnFunc + tmp39 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v40 := args[0] + _ = v40 + v41 := args[1] + _ = v41 + tmp42 := checkDerefVar(glojure_DOT_core_str) + tmp43 := lang.Apply(tmp42, []any{v40}) + tmp44, _ := lang.FieldOrMethod(v41, "write") + if reflect.TypeOf(tmp44).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + } + tmp45 := lang.Apply(tmp44, []any{tmp43}) + return tmp45 + }) + tmp2.AddMethod(tmp38, tmp39) + tmp40 := reflect.TypeOf((*regexp15.Regexp)(nil)) + var tmp41 lang.FnFunc + tmp41 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v42 := args[0] + _ = v42 + v43 := args[1] + _ = v43 + tmp44 := lang.Apply(lang.WriteWriter, []any{v43, "#\""}) + _ = tmp44 + var tmp45 any + { // let + // let binding "G__240" + tmp46 := checkDerefVar(glojure_DOT_core_seq) + tmp47, ok := lang.FieldOrMethod(v42, "String") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v42, "String"))) + } + var tmp48 any + switch reflect.TypeOf(tmp47).Kind() { + case reflect.Func: + tmp48 = lang.Apply(tmp47, nil) + default: + tmp48 = tmp47 + } + tmp49 := lang.Apply(tmp46, []any{tmp48}) + var v50 any = tmp49 + _ = v50 + // let binding "vec__241" + var v51 any = v50 + _ = v51 + // let binding "seq__242" + tmp52 := checkDerefVar(glojure_DOT_core_seq) + tmp53 := lang.Apply(tmp52, []any{v51}) + var v54 any = tmp53 + _ = v54 + // let binding "first__243" + tmp55 := checkDerefVar(glojure_DOT_core_first) + tmp56 := lang.Apply(tmp55, []any{v54}) + var v57 any = tmp56 + _ = v57 + // let binding "seq__242" + tmp58 := checkDerefVar(glojure_DOT_core_next) + tmp59 := lang.Apply(tmp58, []any{v54}) + var v60 any = tmp59 + _ = v60 + // let binding "c" + var v61 any = v57 + _ = v61 + // let binding "r" + var v62 any = v60 + _ = v62 + // let binding "s" + var v63 any = v51 + _ = v63 + // let binding "qmode" + var v64 any = false + _ = v64 + var tmp65 any + { // let + // let binding "G__240" + var v66 any = v50 + _ = v66 + // let binding "qmode" + var v67 any = v64 + _ = v67 + for { + var tmp68 any + { // let + // let binding "vec__244" + var v69 any = v66 + _ = v69 + // let binding "seq__245" + tmp70 := checkDerefVar(glojure_DOT_core_seq) + tmp71 := lang.Apply(tmp70, []any{v69}) + var v72 any = tmp71 + _ = v72 + // let binding "first__246" + tmp73 := checkDerefVar(glojure_DOT_core_first) + tmp74 := lang.Apply(tmp73, []any{v72}) + var v75 any = tmp74 + _ = v75 + // let binding "seq__245" + tmp76 := checkDerefVar(glojure_DOT_core_next) + tmp77 := lang.Apply(tmp76, []any{v72}) + var v78 any = tmp77 + _ = v78 + // let binding "c" + var v79 any = v75 + _ = v79 + // let binding "r" + var v80 any = v78 + _ = v80 + // let binding "s" + var v81 any = v69 + _ = v81 + // let binding "qmode" + var v82 any = v67 + _ = v82 + var tmp83 any + if lang.IsTruthy(v81) { + var tmp84 any + tmp85 := checkDerefVar(glojure_DOT_core__EQ_) + tmp86 := lang.Apply(tmp85, []any{v79, lang.NewChar(92)}) + if lang.IsTruthy(tmp86) { + var tmp87 any + { // let + // let binding "vec__247" + var v88 any = v80 + _ = v88 + // let binding "seq__248" + tmp89 := checkDerefVar(glojure_DOT_core_seq) + tmp90 := lang.Apply(tmp89, []any{v88}) + var v91 any = tmp90 + _ = v91 + // let binding "first__249" + tmp92 := checkDerefVar(glojure_DOT_core_first) + tmp93 := lang.Apply(tmp92, []any{v91}) + var v94 any = tmp93 + _ = v94 + // let binding "seq__248" + tmp95 := checkDerefVar(glojure_DOT_core_next) + tmp96 := lang.Apply(tmp95, []any{v91}) + var v97 any = tmp96 + _ = v97 + // let binding "c2" + var v98 any = v94 + _ = v98 + // let binding "r2" + var v99 any = v97 + _ = v99 + tmp100 := lang.Apply(lang.AppendWriter, []any{v43, lang.NewChar(92)}) + _ = tmp100 + tmp101 := lang.Apply(lang.AppendWriter, []any{v43, v98}) + _ = tmp101 + var tmp102 any + if lang.IsTruthy(v82) { + var tmp103 any = v99 + tmp105 := checkDerefVar(glojure_DOT_core_not_EQ_) + tmp106 := lang.Apply(tmp105, []any{v98, lang.NewChar(69)}) + var tmp104 any = tmp106 + v66 = tmp103 + v67 = tmp104 + continue + } else { + var tmp107 any = v99 + tmp109 := checkDerefVar(glojure_DOT_core__EQ_) + tmp110 := lang.Apply(tmp109, []any{v98, lang.NewChar(81)}) + var tmp108 any = tmp110 + v66 = tmp107 + v67 = tmp108 + continue + } + tmp87 = tmp102 + } // end let + tmp84 = tmp87 + } else { + var tmp88 any + tmp89 := checkDerefVar(glojure_DOT_core__EQ_) + tmp90 := lang.Apply(tmp89, []any{v79, lang.NewChar(34)}) + if lang.IsTruthy(tmp90) { + var tmp91 any + if lang.IsTruthy(v82) { + tmp92 := lang.Apply(lang.WriteWriter, []any{v43, "\\E\\\"\\Q"}) + tmp91 = tmp92 + } else { + tmp93 := lang.Apply(lang.WriteWriter, []any{v43, "\\\""}) + tmp91 = tmp93 + } + _ = tmp91 + var tmp94 any = v80 + var tmp95 any = v82 + v66 = tmp94 + v67 = tmp95 + continue + } else { + var tmp96 any + if lang.IsTruthy(lang.NewKeyword("else")) { + tmp97 := lang.Apply(lang.AppendWriter, []any{v43, v79}) + _ = tmp97 + var tmp98 any = v80 + var tmp99 any = v82 + v66 = tmp98 + v67 = tmp99 + continue + } else { + } + tmp88 = tmp96 + } + tmp84 = tmp88 + } + tmp83 = tmp84 + } else { + } + tmp68 = tmp83 + } // end let + tmp65 = tmp68 + break + } + } // end let + tmp45 = tmp65 + } // end let + _ = tmp45 + tmp46 := lang.Apply(lang.AppendWriter, []any{v43, lang.NewChar(34)}) + return tmp46 + }) + tmp2.AddMethod(tmp40, tmp41) + tmp42 := reflect.TypeOf(int32(0)) + var tmp43 lang.FnFunc + tmp43 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v44 := args[0] + _ = v44 + v45 := args[1] + _ = v45 + tmp46 := checkDerefVar(glojure_DOT_core_str) + tmp47 := lang.Apply(tmp46, []any{v44}) + tmp48, _ := lang.FieldOrMethod(v45, "write") + if reflect.TypeOf(tmp48).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + } + tmp49 := lang.Apply(tmp48, []any{tmp47}) + return tmp49 + }) + tmp2.AddMethod(tmp42, tmp43) + tmp44 := reflect.TypeOf((*lang.Ratio)(nil)) + var tmp45 lang.FnFunc + tmp45 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v46 := args[0] + _ = v46 + v47 := args[1] + _ = v47 + tmp48 := checkDerefVar(glojure_DOT_core_str) + tmp49 := lang.Apply(tmp48, []any{v46}) + tmp50, _ := lang.FieldOrMethod(v47, "write") + if reflect.TypeOf(tmp50).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + } + tmp51 := lang.Apply(tmp50, []any{tmp49}) + return tmp51 + }) + tmp2.AddMethod(tmp44, tmp45) + tmp46 := reflect.TypeOf(float32(0)) + var tmp47 lang.FnFunc + tmp47 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v48 := args[0] + _ = v48 + v49 := args[1] + _ = v49 + var tmp50 any + tmp51 := checkDerefVar(glojure_DOT_core__EQ_) + tmp52 := lang.Apply(math6.Inf, []any{int64(1)}) + tmp53 := lang.Apply(lang.Builtins["float32"], []any{tmp52}) + tmp54 := lang.Apply(tmp51, []any{tmp53, v48}) + if lang.IsTruthy(tmp54) { + tmp55 := lang.Apply(lang.WriteWriter, []any{v49, "##Inf"}) + tmp50 = tmp55 + } else { + var tmp56 any + tmp57 := checkDerefVar(glojure_DOT_core__EQ_) + tmp58 := lang.Apply(math6.Inf, []any{int64(-1)}) + tmp59 := lang.Apply(lang.Builtins["float32"], []any{tmp58}) + tmp60 := lang.Apply(tmp57, []any{tmp59, v48}) + if lang.IsTruthy(tmp60) { + tmp61 := lang.Apply(lang.WriteWriter, []any{v49, "##-Inf"}) + tmp56 = tmp61 + } else { + var tmp62 any + tmp63 := lang.Apply(math6.IsNaN, []any{v48}) + if lang.IsTruthy(tmp63) { + tmp64 := lang.Apply(lang.WriteWriter, []any{v49, "##NaN"}) + tmp62 = tmp64 + } else { + var tmp65 any + if lang.IsTruthy(lang.NewKeyword("else")) { + tmp66 := checkDerefVar(glojure_DOT_core_str) + tmp67 := lang.Apply(tmp66, []any{v48}) + tmp68 := lang.Apply(lang.WriteWriter, []any{v49, tmp67}) + tmp65 = tmp68 + } else { + } + tmp62 = tmp65 + } + tmp56 = tmp62 + } + tmp50 = tmp56 + } + return tmp50 + }) + tmp2.AddMethod(tmp46, tmp47) + tmp48 := reflect.TypeOf(int16(0)) + var tmp49 lang.FnFunc + tmp49 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v50 := args[0] + _ = v50 + v51 := args[1] + _ = v51 + tmp52 := checkDerefVar(glojure_DOT_core_str) + tmp53 := lang.Apply(tmp52, []any{v50}) + tmp54, _ := lang.FieldOrMethod(v51, "write") + if reflect.TypeOf(tmp54).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + } + tmp55 := lang.Apply(tmp54, []any{tmp53}) + return tmp55 + }) + tmp2.AddMethod(tmp48, tmp49) + tmp50 := reflect.TypeOf((*lang.Var)(nil)) + var tmp51 lang.FnFunc + tmp51 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v52 := args[0] + _ = v52 + v53 := args[1] + _ = v53 + tmp54 := checkDerefVar(glojure_DOT_core_print_simple) + tmp55 := lang.Apply(tmp54, []any{v52, v53}) + return tmp55 + }) + tmp2.AddMethod(tmp50, tmp51) + tmp52 := reflect.TypeOf(int8(0)) + var tmp53 lang.FnFunc + tmp53 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v54 := args[0] + _ = v54 + v55 := args[1] + _ = v55 + tmp56 := checkDerefVar(glojure_DOT_core_str) + tmp57 := lang.Apply(tmp56, []any{v54}) + tmp58, _ := lang.FieldOrMethod(v55, "write") + if reflect.TypeOf(tmp58).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + } + tmp59 := lang.Apply(tmp58, []any{tmp57}) + return tmp59 + }) + tmp2.AddMethod(tmp52, tmp53) + tmp54 := reflect.TypeOf(uint16(0)) + var tmp55 lang.FnFunc + tmp55 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v56 := args[0] + _ = v56 + v57 := args[1] + _ = v57 + tmp58 := checkDerefVar(glojure_DOT_core_str) + tmp59 := lang.Apply(tmp58, []any{v56}) + tmp60, _ := lang.FieldOrMethod(v57, "write") + if reflect.TypeOf(tmp60).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + } + tmp61 := lang.Apply(tmp60, []any{tmp59}) + return tmp61 + }) + tmp2.AddMethod(tmp54, tmp55) + tmp56 := reflect.TypeOf(uint64(0)) + var tmp57 lang.FnFunc + tmp57 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v58 := args[0] + _ = v58 + v59 := args[1] + _ = v59 + tmp60 := checkDerefVar(glojure_DOT_core_str) + tmp61 := lang.Apply(tmp60, []any{v58}) + tmp62, _ := lang.FieldOrMethod(v59, "write") + if reflect.TypeOf(tmp62).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + } + tmp63 := lang.Apply(tmp62, []any{tmp61}) + return tmp63 + }) + tmp2.AddMethod(tmp56, tmp57) + tmp58 := reflect.TypeOf((*lang.BigDecimal)(nil)) + var tmp59 lang.FnFunc + tmp59 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v60 := args[0] + _ = v60 + v61 := args[1] + _ = v61 + tmp62 := checkDerefVar(glojure_DOT_core_str) + tmp63 := lang.Apply(tmp62, []any{v60}) + tmp64 := lang.Apply(lang.WriteWriter, []any{v61, tmp63}) + _ = tmp64 + tmp65 := lang.Apply(lang.WriteWriter, []any{v61, "M"}) + return tmp65 + }) + tmp2.AddMethod(tmp58, tmp59) + tmp60 := reflect.TypeOf((*lang.BigInt)(nil)) + var tmp61 lang.FnFunc + tmp61 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v62 := args[0] + _ = v62 + v63 := args[1] + _ = v63 + tmp64 := checkDerefVar(glojure_DOT_core_str) + tmp65 := lang.Apply(tmp64, []any{v62}) + tmp66 := lang.Apply(lang.WriteWriter, []any{v63, tmp65}) + _ = tmp66 + tmp67 := lang.Apply(lang.WriteWriter, []any{v63, "N"}) + return tmp67 + }) + tmp2.AddMethod(tmp60, tmp61) + tmp62 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() + var tmp63 lang.FnFunc + tmp63 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v64 := args[0] + _ = v64 + v65 := args[1] + _ = v65 + tmp66 := checkDerefVar(glojure_DOT_core_print_meta) + tmp67 := lang.Apply(tmp66, []any{v64, v65}) + _ = tmp67 + tmp68 := checkDerefVar(glojure_DOT_core_print_sequential) + tmp69 := checkDerefVar(glojure_DOT_core_pr_on) + tmp70 := lang.Apply(tmp68, []any{"(", tmp69, " ", ")", v64, v65}) + return tmp70 + }) + tmp2.AddMethod(tmp62, tmp63) + tmp64 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() + tmp65 := reflect.TypeOf((*lang.IPersistentCollection)(nil)).Elem() + tmp2.PreferMethod(tmp64, tmp65) + tmp66 := reflect.TypeOf((*lang.IRecord)(nil)).Elem() + tmp67 := reflect.TypeOf((*lang.IPersistentMap)(nil)).Elem() + tmp2.PreferMethod(tmp66, tmp67) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print-object + { + tmp0 := lang.NewSymbol("print-object").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(115), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(115), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_print_tagged_object) + tmp6 := checkDerefVar(glojure_DOT_core_str) + tmp7 := lang.Apply(tmp6, []any{v3}) + tmp8 := lang.Apply(tmp5, []any{v3, tmp7, v4}) + return tmp8 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print-prefix-map + { + tmp0 := lang.NewSymbol("print-prefix-map").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(243), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(243), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("prefix"), lang.NewSymbol("kvs"), lang.NewSymbol("print-one"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_print_sequential) + tmp8 := checkDerefVar(glojure_DOT_core_str) + tmp9 := lang.Apply(tmp8, []any{v3, "{"}) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + var tmp13 any + { // let + // let binding "vec__212" + var v14 any = v11 + _ = v14 + // let binding "k" + tmp15 := checkDerefVar(glojure_DOT_core_nth) + tmp16 := lang.Apply(tmp15, []any{v14, int64(0), nil}) + var v17 any = tmp16 + _ = v17 + // let binding "v" + tmp18 := checkDerefVar(glojure_DOT_core_nth) + tmp19 := lang.Apply(tmp18, []any{v14, int64(1), nil}) + var v20 any = tmp19 + _ = v20 + tmp21 := lang.Apply(v5, []any{v17, v12}) + _ = tmp21 + tmp22 := lang.Apply(lang.AppendWriter, []any{v12, lang.NewChar(32)}) + _ = tmp22 + tmp23 := lang.Apply(v5, []any{v20, v12}) + tmp13 = tmp23 + } // end let + return tmp13 + }) + tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(246), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(247), lang.NewKeyword("end-column"), int(107)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := lang.Apply(tmp7, []any{tmp9, tmp12, ", ", "}", v4, v6}) + return tmp13 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print-sequential + { + tmp0 := lang.NewSymbol("print-sequential").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(46), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(46), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("begin"), lang.NewSymbol("print-one"), lang.NewSymbol("sep"), lang.NewSymbol("end"), lang.NewSymbol("sequence"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 6 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := args[4] + _ = v7 + v8 := args[5] + _ = v8 + var tmp9 any + { // let + tmp10 := checkDerefVar(glojure_DOT_core_push_thread_bindings) + tmp11 := checkDerefVar(glojure_DOT_core_hash_map) + tmp12 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*print-level*")) + var tmp13 any + { // let + // let binding "and__0__auto__" + tmp14 := checkDerefVar(glojure_DOT_core_not) + tmp15 := checkDerefVar(glojure_DOT_core__STAR_print_dup_STAR_) + tmp16 := lang.Apply(tmp14, []any{tmp15}) + var v17 any = tmp16 + _ = v17 + var tmp18 any + if lang.IsTruthy(v17) { + var tmp19 any + { // let + // let binding "and__0__auto__" + tmp20 := checkDerefVar(glojure_DOT_core__STAR_print_level_STAR_) + var v21 any = tmp20 + _ = v21 + var tmp22 any + if lang.IsTruthy(v21) { + tmp23 := checkDerefVar(glojure_DOT_core_dec) + tmp24 := checkDerefVar(glojure_DOT_core__STAR_print_level_STAR_) + tmp25 := lang.Apply(tmp23, []any{tmp24}) + tmp22 = tmp25 + } else { + tmp22 = v21 + } + tmp19 = tmp22 + } // end let + tmp18 = tmp19 + } else { + tmp18 = v17 + } + tmp13 = tmp18 + } // end let + tmp14 := lang.Apply(tmp11, []any{tmp12, tmp13}) + tmp15 := lang.Apply(tmp10, []any{tmp14}) + _ = tmp15 + var tmp16 any + func() { + defer func() { + tmp17 := checkDerefVar(glojure_DOT_core_pop_thread_bindings) + tmp18 := lang.Apply(tmp17, nil) + _ = tmp18 + }() + var tmp19 any + var tmp20 any + { // let + // let binding "and__0__auto__" + tmp21 := checkDerefVar(glojure_DOT_core__STAR_print_level_STAR_) + var v22 any = tmp21 + _ = v22 + var tmp23 any + if lang.IsTruthy(v22) { + tmp24 := checkDerefVar(glojure_DOT_core_neg_QMARK_) + tmp25 := checkDerefVar(glojure_DOT_core__STAR_print_level_STAR_) + tmp26 := lang.Apply(tmp24, []any{tmp25}) + tmp23 = tmp26 + } else { + tmp23 = v22 + } + tmp20 = tmp23 + } // end let + if lang.IsTruthy(tmp20) { + tmp21 := lang.Apply(lang.WriteWriter, []any{v8, "#"}) + tmp19 = tmp21 + } else { + tmp22 := lang.Apply(lang.WriteWriter, []any{v8, v3}) + _ = tmp22 + var tmp23 any + { // let + // let binding "temp__0__auto__" + tmp24 := checkDerefVar(glojure_DOT_core_seq) + tmp25 := lang.Apply(tmp24, []any{v7}) + var v26 any = tmp25 + _ = v26 + var tmp27 any + if lang.IsTruthy(v26) { + var tmp28 any + { // let + // let binding "xs" + var v29 any = v26 + _ = v29 + var tmp30 any + var tmp31 any + { // let + // let binding "and__0__auto__" + tmp32 := checkDerefVar(glojure_DOT_core_not) + tmp33 := checkDerefVar(glojure_DOT_core__STAR_print_dup_STAR_) + tmp34 := lang.Apply(tmp32, []any{tmp33}) + var v35 any = tmp34 + _ = v35 + var tmp36 any + if lang.IsTruthy(v35) { + tmp37 := checkDerefVar(glojure_DOT_core__STAR_print_length_STAR_) + tmp36 = tmp37 + } else { + tmp36 = v35 + } + tmp31 = tmp36 + } // end let + if lang.IsTruthy(tmp31) { + var tmp32 any + { // let + // let binding "G__194" + var v33 any = v29 + _ = v33 + // let binding "vec__195" + var v34 any = v33 + _ = v34 + // let binding "seq__196" + tmp35 := checkDerefVar(glojure_DOT_core_seq) + tmp36 := lang.Apply(tmp35, []any{v34}) + var v37 any = tmp36 + _ = v37 + // let binding "first__197" + tmp38 := checkDerefVar(glojure_DOT_core_first) + tmp39 := lang.Apply(tmp38, []any{v37}) + var v40 any = tmp39 + _ = v40 + // let binding "seq__196" + tmp41 := checkDerefVar(glojure_DOT_core_next) + tmp42 := lang.Apply(tmp41, []any{v37}) + var v43 any = tmp42 + _ = v43 + // let binding "x" + var v44 any = v40 + _ = v44 + // let binding "xs" + var v45 any = v43 + _ = v45 + // let binding "print-length" + tmp46 := checkDerefVar(glojure_DOT_core__STAR_print_length_STAR_) + var v47 any = tmp46 + _ = v47 + var tmp48 any + { // let + // let binding "G__194" + var v49 any = v33 + _ = v49 + // let binding "print-length" + var v50 any = v47 + _ = v50 + for { + var tmp51 any + { // let + // let binding "vec__198" + var v52 any = v49 + _ = v52 + // let binding "seq__199" + tmp53 := checkDerefVar(glojure_DOT_core_seq) + tmp54 := lang.Apply(tmp53, []any{v52}) + var v55 any = tmp54 + _ = v55 + // let binding "first__200" + tmp56 := checkDerefVar(glojure_DOT_core_first) + tmp57 := lang.Apply(tmp56, []any{v55}) + var v58 any = tmp57 + _ = v58 + // let binding "seq__199" + tmp59 := checkDerefVar(glojure_DOT_core_next) + tmp60 := lang.Apply(tmp59, []any{v55}) + var v61 any = tmp60 + _ = v61 + // let binding "x" + var v62 any = v58 + _ = v62 + // let binding "xs" + var v63 any = v61 + _ = v63 + // let binding "print-length" + var v64 any = v50 + _ = v64 + var tmp65 any + tmp66 := checkDerefVar(glojure_DOT_core_zero_QMARK_) + tmp67 := lang.Apply(tmp66, []any{v64}) + if lang.IsTruthy(tmp67) { + tmp68 := lang.Apply(lang.WriteWriter, []any{v8, "..."}) + tmp65 = tmp68 + } else { + tmp69 := lang.Apply(v4, []any{v62, v8}) + _ = tmp69 + var tmp70 any + if lang.IsTruthy(v63) { + tmp71 := lang.Apply(lang.WriteWriter, []any{v8, v5}) + _ = tmp71 + var tmp72 any = v63 + tmp74 := checkDerefVar(glojure_DOT_core_dec) + tmp75 := lang.Apply(tmp74, []any{v64}) + var tmp73 any = tmp75 + v49 = tmp72 + v50 = tmp73 + continue + } else { + } + tmp65 = tmp70 + } + tmp51 = tmp65 + } // end let + tmp48 = tmp51 + break + } + } // end let + tmp32 = tmp48 + } // end let + tmp30 = tmp32 + } else { + var tmp33 any + { // let + // let binding "G__204" + var v34 any = v29 + _ = v34 + // let binding "vec__205" + var v35 any = v34 + _ = v35 + // let binding "seq__206" + tmp36 := checkDerefVar(glojure_DOT_core_seq) + tmp37 := lang.Apply(tmp36, []any{v35}) + var v38 any = tmp37 + _ = v38 + // let binding "first__207" + tmp39 := checkDerefVar(glojure_DOT_core_first) + tmp40 := lang.Apply(tmp39, []any{v38}) + var v41 any = tmp40 + _ = v41 + // let binding "seq__206" + tmp42 := checkDerefVar(glojure_DOT_core_next) + tmp43 := lang.Apply(tmp42, []any{v38}) + var v44 any = tmp43 + _ = v44 + // let binding "x" + var v45 any = v41 + _ = v45 + // let binding "xs" + var v46 any = v44 + _ = v46 + var tmp47 any + { // let + // let binding "G__204" + var v48 any = v34 + _ = v48 + for { + var tmp49 any + { // let + // let binding "vec__208" + var v50 any = v48 + _ = v50 + // let binding "seq__209" + tmp51 := checkDerefVar(glojure_DOT_core_seq) + tmp52 := lang.Apply(tmp51, []any{v50}) + var v53 any = tmp52 + _ = v53 + // let binding "first__210" + tmp54 := checkDerefVar(glojure_DOT_core_first) + tmp55 := lang.Apply(tmp54, []any{v53}) + var v56 any = tmp55 + _ = v56 + // let binding "seq__209" + tmp57 := checkDerefVar(glojure_DOT_core_next) + tmp58 := lang.Apply(tmp57, []any{v53}) + var v59 any = tmp58 + _ = v59 + // let binding "x" + var v60 any = v56 + _ = v60 + // let binding "xs" + var v61 any = v59 + _ = v61 + tmp62 := lang.Apply(v4, []any{v60, v8}) + _ = tmp62 + var tmp63 any + if lang.IsTruthy(v61) { + tmp64 := lang.Apply(lang.WriteWriter, []any{v8, v5}) + _ = tmp64 + var tmp65 any = v61 + v48 = tmp65 + continue + } else { + } + tmp49 = tmp63 + } // end let + tmp47 = tmp49 + break + } + } // end let + tmp33 = tmp47 + } // end let + tmp30 = tmp33 + } + tmp28 = tmp30 + } // end let + tmp27 = tmp28 + } else { + } + tmp23 = tmp27 + } // end let + _ = tmp23 + tmp24 := lang.Apply(lang.WriteWriter, []any{v8, v6}) + tmp19 = tmp24 + } + tmp16 = tmp19 + }() + tmp9 = tmp16 + } // end let + return tmp9 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print-simple + { + tmp0 := lang.NewSymbol("print-simple").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(81), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(81), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_print_meta) + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + _ = tmp6 + tmp7 := checkDerefVar(glojure_DOT_core_str) + tmp8 := lang.Apply(tmp7, []any{v3}) + tmp9 := lang.Apply(lang.WriteWriter, []any{v4, tmp8}) + return tmp9 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print-str + { + tmp1 := reflect.TypeOf("") + tmp0 := lang.NewSymbol("print-str").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("xs"))), lang.NewKeyword("doc"), "print to a string, returning it", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4776), lang.NewKeyword("end-line"), int(4776))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v4 any = lang.NewList(args[0:]...) + _ = v4 + var tmp5 any + { // let + // let binding "s__0__auto__" + var v6 any = "unimplemented: new with non-constant class type" + _ = v6 + var tmp7 any + { // let + tmp8 := checkDerefVar(glojure_DOT_core_push_thread_bindings) + tmp9 := checkDerefVar(glojure_DOT_core_hash_map) + tmp10 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*out*")) + tmp11 := lang.Apply(tmp9, []any{tmp10, v6}) + tmp12 := lang.Apply(tmp8, []any{tmp11}) + _ = tmp12 + var tmp13 any + func() { + defer func() { + tmp14 := checkDerefVar(glojure_DOT_core_pop_thread_bindings) + tmp15 := lang.Apply(tmp14, nil) + _ = tmp15 + }() + tmp16 := checkDerefVar(glojure_DOT_core_apply) + tmp17 := checkDerefVar(glojure_DOT_core_print) + tmp18 := lang.Apply(tmp16, []any{tmp17, v4}) + _ = tmp18 + tmp19 := checkDerefVar(glojure_DOT_core_str) + tmp20 := lang.Apply(tmp19, []any{v6}) + tmp13 = tmp20 + }() + tmp7 = tmp13 + } // end let + tmp5 = tmp7 + } // end let + return tmp5 + } + }) + tmp4 := reflect.TypeOf("") + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print-tagged-object + { + tmp0 := lang.NewSymbol("print-tagged-object").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(102), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(102), lang.NewKeyword("end-column"), int(26), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("rep"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp8 := reflect.TypeOf((*lang.IMeta)(nil)).Elem() + tmp9 := lang.Apply(tmp7, []any{tmp8, v3}) + if lang.IsTruthy(tmp9) { + tmp10 := checkDerefVar(glojure_DOT_core_print_meta) + tmp11 := lang.Apply(tmp10, []any{v3, v5}) + tmp6 = tmp11 + } else { + } + _ = tmp6 + tmp12 := lang.Apply(lang.WriteWriter, []any{v5, "#object["}) + _ = tmp12 + var tmp13 any + { // let + // let binding "c" + tmp14 := checkDerefVar(glojure_DOT_core_class) + tmp15 := lang.Apply(tmp14, []any{v3}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + if lang.IsTruthy(false) { + tmp18 := checkDerefVar(glojure_DOT_core_print_method) + tmp19, ok := lang.FieldOrMethod(v16, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v16, "Name"))) + } + var tmp20 any + switch reflect.TypeOf(tmp19).Kind() { + case reflect.Func: + tmp20 = lang.Apply(tmp19, nil) + default: + tmp20 = tmp19 + } + tmp21 := lang.Apply(tmp18, []any{tmp20, v5}) + tmp17 = tmp21 + } else { + tmp22, ok := lang.FieldOrMethod(v16, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v16, "Name"))) + } + var tmp23 any + switch reflect.TypeOf(tmp22).Kind() { + case reflect.Func: + tmp23 = lang.Apply(tmp22, nil) + default: + tmp23 = tmp22 + } + tmp24 := lang.Apply(lang.WriteWriter, []any{v5, tmp23}) + tmp17 = tmp24 + } + tmp13 = tmp17 + } // end let + _ = tmp13 + tmp14 := lang.Apply(lang.WriteWriter, []any{v5, " "}) + _ = tmp14 + tmp15 := checkDerefVar(glojure_DOT_core_format) + tmp16 := lang.Apply(lang.IdentityHash, []any{v3}) + tmp17 := lang.Apply(tmp15, []any{"0x%x ", tmp16}) + tmp18 := lang.Apply(lang.WriteWriter, []any{v5, tmp17}) + _ = tmp18 + tmp19 := checkDerefVar(glojure_DOT_core_print_method) + tmp20 := lang.Apply(tmp19, []any{v4, v5}) + _ = tmp20 + tmp21 := lang.Apply(lang.WriteWriter, []any{v5, "]"}) + return tmp21 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print-throwable + { + tmp0 := lang.NewSymbol("print-throwable").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(478), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(478), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(lang.WriteWriter, []any{v4, "#error {\n :cause "}) + _ = tmp5 + var tmp6 any + { // let + // let binding "map__253" + tmp7 := checkDerefVar(glojure_DOT_core_Throwable__GT_map) + tmp8 := lang.Apply(tmp7, []any{v3}) + var v9 any = tmp8 + _ = v9 + // let binding "map__253" + var tmp10 any + tmp11 := checkDerefVar(glojure_DOT_core_seq_QMARK_) + tmp12 := lang.Apply(tmp11, []any{v9}) + if lang.IsTruthy(tmp12) { + var tmp13 any + tmp14 := checkDerefVar(glojure_DOT_core_next) + tmp15 := lang.Apply(tmp14, []any{v9}) + if lang.IsTruthy(tmp15) { + tmp16 := checkDerefVar(glojure_DOT_core_to_array) + tmp17 := lang.Apply(tmp16, []any{v9}) + tmp18 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{tmp17}) + tmp13 = tmp18 + } else { + var tmp19 any + tmp20 := checkDerefVar(glojure_DOT_core_seq) + tmp21 := lang.Apply(tmp20, []any{v9}) + if lang.IsTruthy(tmp21) { + tmp22 := checkDerefVar(glojure_DOT_core_first) + tmp23 := lang.Apply(tmp22, []any{v9}) + tmp19 = tmp23 + } else { + } + tmp13 = tmp19 + } + tmp10 = tmp13 + } else { + tmp10 = v9 + } + var v24 any = tmp10 + _ = v24 + // let binding "cause" + tmp25 := checkDerefVar(glojure_DOT_core_get) + tmp26 := lang.Apply(tmp25, []any{v24, lang.NewKeyword("cause")}) + var v27 any = tmp26 + _ = v27 + // let binding "data" + tmp28 := checkDerefVar(glojure_DOT_core_get) + tmp29 := lang.Apply(tmp28, []any{v24, lang.NewKeyword("data")}) + var v30 any = tmp29 + _ = v30 + // let binding "via" + tmp31 := checkDerefVar(glojure_DOT_core_get) + tmp32 := lang.Apply(tmp31, []any{v24, lang.NewKeyword("via")}) + var v33 any = tmp32 + _ = v33 + // let binding "trace" + tmp34 := checkDerefVar(glojure_DOT_core_get) + tmp35 := lang.Apply(tmp34, []any{v24, lang.NewKeyword("trace")}) + var v36 any = tmp35 + _ = v36 + // let binding "print-via" + var tmp37 lang.FnFunc + tmp37 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v38 := args[0] + _ = v38 + tmp39 := lang.Apply(lang.WriteWriter, []any{v4, "{:type "}) + _ = tmp39 + tmp40 := checkDerefVar(glojure_DOT_core_print_method) + tmp41 := lang.Apply(lang.NewKeyword("type"), []any{v38}) + tmp42 := lang.Apply(tmp40, []any{tmp41, v4}) + _ = tmp42 + tmp43 := lang.Apply(lang.WriteWriter, []any{v4, "\n :message "}) + _ = tmp43 + tmp44 := checkDerefVar(glojure_DOT_core_print_method) + tmp45 := lang.Apply(lang.NewKeyword("message"), []any{v38}) + tmp46 := lang.Apply(tmp44, []any{tmp45, v4}) + _ = tmp46 + var tmp47 any + { // let + // let binding "temp__0__auto__" + tmp48 := lang.Apply(lang.NewKeyword("data"), []any{v38}) + var v49 any = tmp48 + _ = v49 + var tmp50 any + if lang.IsTruthy(v49) { + var tmp51 any + { // let + // let binding "data" + var v52 any = v49 + _ = v52 + tmp53 := lang.Apply(lang.WriteWriter, []any{v4, "\n :data "}) + _ = tmp53 + tmp54 := checkDerefVar(glojure_DOT_core_print_method) + tmp55 := lang.Apply(tmp54, []any{v52, v4}) + tmp51 = tmp55 + } // end let + tmp50 = tmp51 + } else { + } + tmp47 = tmp50 + } // end let + _ = tmp47 + var tmp48 any + { // let + // let binding "temp__0__auto__" + tmp49 := lang.Apply(lang.NewKeyword("at"), []any{v38}) + var v50 any = tmp49 + _ = v50 + var tmp51 any + if lang.IsTruthy(v50) { + var tmp52 any + { // let + // let binding "at" + var v53 any = v50 + _ = v53 + tmp54 := lang.Apply(lang.WriteWriter, []any{v4, "\n :at "}) + _ = tmp54 + tmp55 := checkDerefVar(glojure_DOT_core_print_method) + tmp56 := lang.Apply(lang.NewKeyword("at"), []any{v38}) + tmp57 := lang.Apply(tmp55, []any{tmp56, v4}) + tmp52 = tmp57 + } // end let + tmp51 = tmp52 + } else { + } + tmp48 = tmp51 + } // end let + _ = tmp48 + tmp49 := lang.Apply(lang.WriteWriter, []any{v4, "}"}) + return tmp49 + }) + tmp38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(481), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(491), lang.NewKeyword("end-column"), int(73)) + tmp39, err := lang.WithMeta(tmp37, tmp38.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v40 any = tmp39 + _ = v40 + tmp41 := checkDerefVar(glojure_DOT_core_print_method) + tmp42 := lang.Apply(tmp41, []any{v27, v4}) + _ = tmp42 + var tmp43 any + if lang.IsTruthy(v30) { + tmp44 := lang.Apply(lang.WriteWriter, []any{v4, "\n :data "}) + _ = tmp44 + tmp45 := checkDerefVar(glojure_DOT_core_print_method) + tmp46 := lang.Apply(tmp45, []any{v30, v4}) + tmp43 = tmp46 + } else { + } + _ = tmp43 + var tmp47 any + if lang.IsTruthy(v33) { + tmp48 := lang.Apply(lang.WriteWriter, []any{v4, "\n :via\n ["}) + _ = tmp48 + var tmp49 any + { // let + // let binding "temp__0__auto__" + tmp50 := checkDerefVar(glojure_DOT_core_first) + tmp51 := lang.Apply(tmp50, []any{v33}) + var v52 any = tmp51 + _ = v52 + var tmp53 any + if lang.IsTruthy(v52) { + var tmp54 any + { // let + // let binding "fv" + var v55 any = v52 + _ = v55 + tmp56 := lang.Apply(v40, []any{v55}) + _ = tmp56 + var tmp57 any + { // let + // let binding "seq_254" + tmp58 := checkDerefVar(glojure_DOT_core_seq) + tmp59 := checkDerefVar(glojure_DOT_core_rest) + tmp60 := lang.Apply(tmp59, []any{v33}) + tmp61 := lang.Apply(tmp58, []any{tmp60}) + var v62 any = tmp61 + _ = v62 + // let binding "chunk_255" + var v63 any = nil + _ = v63 + // let binding "count_256" + var v64 any = int64(0) + _ = v64 + // let binding "i_257" + var v65 any = int64(0) + _ = v65 + for { + var tmp66 any + tmp67 := checkDerefVar(glojure_DOT_core__LT_) + tmp68 := lang.Apply(tmp67, []any{v65, v64}) + if lang.IsTruthy(tmp68) { + var tmp69 any + { // let + // let binding "v" + tmp70, _ := lang.FieldOrMethod(v63, "nth") + if reflect.TypeOf(tmp70).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp71 := lang.Apply(tmp70, []any{v65}) + var v72 any = tmp71 + _ = v72 + tmp73 := lang.Apply(lang.WriteWriter, []any{v4, "\n "}) + _ = tmp73 + tmp74 := lang.Apply(v40, []any{v72}) + _ = tmp74 + var tmp75 any = v62 + var tmp76 any = v63 + var tmp77 any = v64 + tmp79 := checkDerefVar(glojure_DOT_core_unchecked_inc) + tmp80 := lang.Apply(tmp79, []any{v65}) + var tmp78 any = tmp80 + v62 = tmp75 + v63 = tmp76 + v64 = tmp77 + v65 = tmp78 + continue + } // end let + tmp66 = tmp69 + } else { + var tmp70 any + { // let + // let binding "temp__0__auto__" + tmp71 := checkDerefVar(glojure_DOT_core_seq) + tmp72 := lang.Apply(tmp71, []any{v62}) + var v73 any = tmp72 + _ = v73 + var tmp74 any + if lang.IsTruthy(v73) { + var tmp75 any + { // let + // let binding "seq_254" + var v76 any = v73 + _ = v76 + var tmp77 any + tmp78 := checkDerefVar(glojure_DOT_core_chunked_seq_QMARK_) + tmp79 := lang.Apply(tmp78, []any{v76}) + if lang.IsTruthy(tmp79) { + var tmp80 any + { // let + // let binding "c__0__auto__" + tmp81 := checkDerefVar(glojure_DOT_core_chunk_first) + tmp82 := lang.Apply(tmp81, []any{v76}) + var v83 any = tmp82 + _ = v83 + tmp85 := checkDerefVar(glojure_DOT_core_chunk_rest) + tmp86 := lang.Apply(tmp85, []any{v76}) + var tmp84 any = tmp86 + var tmp87 any = v83 + tmp89 := checkDerefVar(glojure_DOT_core_int) + tmp90 := checkDerefVar(glojure_DOT_core_count) + tmp91 := lang.Apply(tmp90, []any{v83}) + tmp92 := lang.Apply(tmp89, []any{tmp91}) + var tmp88 any = tmp92 + tmp94 := checkDerefVar(glojure_DOT_core_int) + tmp95 := lang.Apply(tmp94, []any{int64(0)}) + var tmp93 any = tmp95 + v62 = tmp84 + v63 = tmp87 + v64 = tmp88 + v65 = tmp93 + continue + } // end let + tmp77 = tmp80 + } else { + var tmp81 any + { // let + // let binding "v" + tmp82 := checkDerefVar(glojure_DOT_core_first) + tmp83 := lang.Apply(tmp82, []any{v76}) + var v84 any = tmp83 + _ = v84 + tmp85 := lang.Apply(lang.WriteWriter, []any{v4, "\n "}) + _ = tmp85 + tmp86 := lang.Apply(v40, []any{v84}) + _ = tmp86 + tmp88 := checkDerefVar(glojure_DOT_core_next) + tmp89 := lang.Apply(tmp88, []any{v76}) + var tmp87 any = tmp89 + var tmp90 any = nil + var tmp91 any = int64(0) + var tmp92 any = int64(0) + v62 = tmp87 + v63 = tmp90 + v64 = tmp91 + v65 = tmp92 + continue + } // end let + tmp77 = tmp81 + } + tmp75 = tmp77 + } // end let + tmp74 = tmp75 + } else { + } + tmp70 = tmp74 + } // end let + tmp66 = tmp70 + } + tmp57 = tmp66 + break + } + } // end let + tmp54 = tmp57 + } // end let + tmp53 = tmp54 + } else { + } + tmp49 = tmp53 + } // end let + _ = tmp49 + tmp50 := lang.Apply(lang.WriteWriter, []any{v4, "]"}) + tmp47 = tmp50 + } else { + } + _ = tmp47 + var tmp51 any + if lang.IsTruthy(v36) { + tmp52 := lang.Apply(lang.WriteWriter, []any{v4, "\n :trace\n ["}) + _ = tmp52 + var tmp53 any + { // let + // let binding "temp__0__auto__" + tmp54 := checkDerefVar(glojure_DOT_core_first) + tmp55 := lang.Apply(tmp54, []any{v36}) + var v56 any = tmp55 + _ = v56 + var tmp57 any + if lang.IsTruthy(v56) { + var tmp58 any + { // let + // let binding "ft" + var v59 any = v56 + _ = v59 + tmp60 := checkDerefVar(glojure_DOT_core_print_method) + tmp61 := lang.Apply(tmp60, []any{v59, v4}) + _ = tmp61 + var tmp62 any + { // let + // let binding "seq_258" + tmp63 := checkDerefVar(glojure_DOT_core_seq) + tmp64 := checkDerefVar(glojure_DOT_core_rest) + tmp65 := lang.Apply(tmp64, []any{v36}) + tmp66 := lang.Apply(tmp63, []any{tmp65}) + var v67 any = tmp66 + _ = v67 + // let binding "chunk_259" + var v68 any = nil + _ = v68 + // let binding "count_260" + var v69 any = int64(0) + _ = v69 + // let binding "i_261" + var v70 any = int64(0) + _ = v70 + for { + var tmp71 any + tmp72 := checkDerefVar(glojure_DOT_core__LT_) + tmp73 := lang.Apply(tmp72, []any{v70, v69}) + if lang.IsTruthy(tmp73) { + var tmp74 any + { // let + // let binding "t" + tmp75, _ := lang.FieldOrMethod(v68, "nth") + if reflect.TypeOf(tmp75).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp76 := lang.Apply(tmp75, []any{v70}) + var v77 any = tmp76 + _ = v77 + tmp78 := lang.Apply(lang.WriteWriter, []any{v4, "\n "}) + _ = tmp78 + tmp79 := checkDerefVar(glojure_DOT_core_print_method) + tmp80 := lang.Apply(tmp79, []any{v77, v4}) + _ = tmp80 + var tmp81 any = v67 + var tmp82 any = v68 + var tmp83 any = v69 + tmp85 := checkDerefVar(glojure_DOT_core_unchecked_inc) + tmp86 := lang.Apply(tmp85, []any{v70}) + var tmp84 any = tmp86 + v67 = tmp81 + v68 = tmp82 + v69 = tmp83 + v70 = tmp84 + continue + } // end let + tmp71 = tmp74 + } else { + var tmp75 any + { // let + // let binding "temp__0__auto__" + tmp76 := checkDerefVar(glojure_DOT_core_seq) + tmp77 := lang.Apply(tmp76, []any{v67}) + var v78 any = tmp77 + _ = v78 + var tmp79 any + if lang.IsTruthy(v78) { + var tmp80 any + { // let + // let binding "seq_258" + var v81 any = v78 + _ = v81 + var tmp82 any + tmp83 := checkDerefVar(glojure_DOT_core_chunked_seq_QMARK_) + tmp84 := lang.Apply(tmp83, []any{v81}) + if lang.IsTruthy(tmp84) { + var tmp85 any + { // let + // let binding "c__0__auto__" + tmp86 := checkDerefVar(glojure_DOT_core_chunk_first) + tmp87 := lang.Apply(tmp86, []any{v81}) + var v88 any = tmp87 + _ = v88 + tmp90 := checkDerefVar(glojure_DOT_core_chunk_rest) + tmp91 := lang.Apply(tmp90, []any{v81}) + var tmp89 any = tmp91 + var tmp92 any = v88 + tmp94 := checkDerefVar(glojure_DOT_core_int) + tmp95 := checkDerefVar(glojure_DOT_core_count) + tmp96 := lang.Apply(tmp95, []any{v88}) + tmp97 := lang.Apply(tmp94, []any{tmp96}) + var tmp93 any = tmp97 + tmp99 := checkDerefVar(glojure_DOT_core_int) + tmp100 := lang.Apply(tmp99, []any{int64(0)}) + var tmp98 any = tmp100 + v67 = tmp89 + v68 = tmp92 + v69 = tmp93 + v70 = tmp98 + continue + } // end let + tmp82 = tmp85 + } else { + var tmp86 any + { // let + // let binding "t" + tmp87 := checkDerefVar(glojure_DOT_core_first) + tmp88 := lang.Apply(tmp87, []any{v81}) + var v89 any = tmp88 + _ = v89 + tmp90 := lang.Apply(lang.WriteWriter, []any{v4, "\n "}) + _ = tmp90 + tmp91 := checkDerefVar(glojure_DOT_core_print_method) + tmp92 := lang.Apply(tmp91, []any{v89, v4}) + _ = tmp92 + tmp94 := checkDerefVar(glojure_DOT_core_next) + tmp95 := lang.Apply(tmp94, []any{v81}) + var tmp93 any = tmp95 + var tmp96 any = nil + var tmp97 any = int64(0) + var tmp98 any = int64(0) + v67 = tmp93 + v68 = tmp96 + v69 = tmp97 + v70 = tmp98 + continue + } // end let + tmp82 = tmp86 + } + tmp80 = tmp82 + } // end let + tmp79 = tmp80 + } else { + } + tmp75 = tmp79 + } // end let + tmp71 = tmp75 + } + tmp62 = tmp71 + break + } + } // end let + tmp58 = tmp62 + } // end let + tmp57 = tmp58 + } else { + } + tmp53 = tmp57 + } // end let + _ = tmp53 + tmp54 := lang.Apply(lang.WriteWriter, []any{v4, "]"}) + tmp51 = tmp54 + } else { + } + tmp6 = tmp51 + } // end let + _ = tmp6 + tmp7 := lang.Apply(lang.WriteWriter, []any{v4, "}"}) + return tmp7 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // printf + { + tmp0 := lang.NewSymbol("printf").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fmt"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Prints formatted output, as per format", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5725), lang.NewKeyword("end-line"), int(5725))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any = lang.NewList(args[1:]...) + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_print) + tmp6 := checkDerefVar(glojure_DOT_core_apply) + tmp7 := checkDerefVar(glojure_DOT_core_format) + tmp8 := lang.Apply(tmp6, []any{tmp7, v3, v4}) + tmp9 := lang.Apply(tmp5, []any{tmp8}) + return tmp9 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // println + { + tmp0 := lang.NewSymbol("println").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Same as print followed by (newline)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3734), lang.NewKeyword("end-line"), int(3734))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v3 any = lang.NewList(args[0:]...) + _ = v3 + var tmp4 any + { // let + tmp5 := checkDerefVar(glojure_DOT_core_push_thread_bindings) + tmp6 := checkDerefVar(glojure_DOT_core_hash_map) + tmp7 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*print-readably*")) + tmp8 := lang.Apply(tmp6, []any{tmp7, nil}) + tmp9 := lang.Apply(tmp5, []any{tmp8}) + _ = tmp9 + var tmp10 any + func() { + defer func() { + tmp11 := checkDerefVar(glojure_DOT_core_pop_thread_bindings) + tmp12 := lang.Apply(tmp11, nil) + _ = tmp12 + }() + tmp13 := checkDerefVar(glojure_DOT_core_apply) + tmp14 := checkDerefVar(glojure_DOT_core_prn) + tmp15 := lang.Apply(tmp13, []any{tmp14, v3}) + tmp10 = tmp15 + }() + tmp4 = tmp10 + } // end let + return tmp4 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // println-str + { + tmp1 := reflect.TypeOf("") + tmp0 := lang.NewSymbol("println-str").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("xs"))), lang.NewKeyword("doc"), "println to a string, returning it", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4785), lang.NewKeyword("end-line"), int(4785))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v4 any = lang.NewList(args[0:]...) + _ = v4 + var tmp5 any + { // let + // let binding "s__0__auto__" + var v6 any = "unimplemented: new with non-constant class type" + _ = v6 + var tmp7 any + { // let + tmp8 := checkDerefVar(glojure_DOT_core_push_thread_bindings) + tmp9 := checkDerefVar(glojure_DOT_core_hash_map) + tmp10 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*out*")) + tmp11 := lang.Apply(tmp9, []any{tmp10, v6}) + tmp12 := lang.Apply(tmp8, []any{tmp11}) + _ = tmp12 + var tmp13 any + func() { + defer func() { + tmp14 := checkDerefVar(glojure_DOT_core_pop_thread_bindings) + tmp15 := lang.Apply(tmp14, nil) + _ = tmp15 + }() + tmp16 := checkDerefVar(glojure_DOT_core_apply) + tmp17 := checkDerefVar(glojure_DOT_core_println) + tmp18 := lang.Apply(tmp16, []any{tmp17, v4}) + _ = tmp18 + tmp19 := checkDerefVar(glojure_DOT_core_str) + tmp20 := lang.Apply(tmp19, []any{v6}) + tmp13 = tmp20 + }() + tmp7 = tmp13 + } // end let + tmp5 = tmp7 + } // end let + return tmp5 + } + }) + tmp4 := reflect.TypeOf("") + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // prn + { + tmp0 := lang.NewSymbol("prn").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Same as pr followed by (newline). Observes *flush-on-newline*", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3715), lang.NewKeyword("end-line"), int(3715))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_apply) + tmp5 := checkDerefVar(glojure_DOT_core_pr) + tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) + _ = tmp6 + tmp7 := checkDerefVar(glojure_DOT_core_newline) + tmp8 := lang.Apply(tmp7, nil) + _ = tmp8 + var tmp9 any + tmp10 := checkDerefVar(glojure_DOT_core__STAR_flush_on_newline_STAR_) + if lang.IsTruthy(tmp10) { + tmp11 := checkDerefVar(glojure_DOT_core_flush) + tmp12 := lang.Apply(tmp11, nil) + tmp9 = tmp12 + } else { + } + return tmp9 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // prn-str + { + tmp1 := reflect.TypeOf("") + tmp0 := lang.NewSymbol("prn-str").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("xs"))), lang.NewKeyword("doc"), "prn to a string, returning it", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4767), lang.NewKeyword("end-line"), int(4767))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v4 any = lang.NewList(args[0:]...) + _ = v4 + var tmp5 any + { // let + // let binding "s__0__auto__" + var v6 any = "unimplemented: new with non-constant class type" + _ = v6 + var tmp7 any + { // let + tmp8 := checkDerefVar(glojure_DOT_core_push_thread_bindings) + tmp9 := checkDerefVar(glojure_DOT_core_hash_map) + tmp10 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*out*")) + tmp11 := lang.Apply(tmp9, []any{tmp10, v6}) + tmp12 := lang.Apply(tmp8, []any{tmp11}) + _ = tmp12 + var tmp13 any + func() { + defer func() { + tmp14 := checkDerefVar(glojure_DOT_core_pop_thread_bindings) + tmp15 := lang.Apply(tmp14, nil) + _ = tmp15 + }() + tmp16 := checkDerefVar(glojure_DOT_core_apply) + tmp17 := checkDerefVar(glojure_DOT_core_prn) + tmp18 := lang.Apply(tmp16, []any{tmp17, v4}) + _ = tmp18 + tmp19 := checkDerefVar(glojure_DOT_core_str) + tmp20 := lang.Apply(tmp19, []any{v6}) + tmp13 = tmp20 + }() + tmp7 = tmp13 + } // end let + tmp5 = tmp7 + } // end let + return tmp5 + } + }) + tmp4 := reflect.TypeOf("") + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // promise + { + tmp0 := lang.NewSymbol("promise").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Returns a promise object that can be read with deref/@, and set,\n once only, with deliver. Calls to deref/@ prior to delivery will\n block, unless the variant of deref with timeout is used. All\n subsequent derefs will return the same delivered value without\n blocking. See also - realized?.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7078), lang.NewKeyword("end-line"), int(7078))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var tmp3 any + { // let + // let binding "d" + tmp4 := lang.Apply(nil, []any{int64(1)}) + var v5 any = tmp4 + _ = v5 + // let binding "v" + tmp6 := checkDerefVar(glojure_DOT_core_atom) + tmp7 := lang.Apply(tmp6, []any{v5}) + var v8 any = tmp7 + _ = v8 + tmp9 := reflect.TypeOf((*lang.IDeref)(nil)).Elem() + tmp10 := checkDerefVar(glojure_DOT_core_deref) + tmp11 := lang.NewVector(nil) + tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7091), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(7091), lang.NewKeyword("end-column"), int(17)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp14, ok := lang.FieldOrMethod(v5, "await") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "await"))) + } + var tmp15 any + switch reflect.TypeOf(tmp14).Kind() { + case reflect.Func: + tmp15 = lang.Apply(tmp14, nil) + default: + tmp15 = tmp14 + } + tmp16 := checkDerefVar(glojure_DOT_core_deref) + tmp17 := lang.Apply(tmp16, []any{v8}) + tmp18 := lang.Apply(tmp10, []any{tmp13, tmp15, tmp17}) + tmp19 := reflect.TypeOf((*lang.IBlockingDeref)(nil)).Elem() + tmp20 := checkDerefVar(glojure_DOT_core_deref) + tmp21 := lang.NewVector(nil, nil, nil) + tmp22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7094), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(7094), lang.NewKeyword("end-column"), int(34)) + tmp23, err := lang.WithMeta(tmp21, tmp22.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var tmp24 any + tmp25, _ := lang.FieldOrMethod(v5, "await") + if reflect.TypeOf(tmp25).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) + } + tmp26 := lang.Apply(tmp25, []any{nil, time10.Millisecond}) + if lang.IsTruthy(tmp26) { + tmp27 := checkDerefVar(glojure_DOT_core_deref) + tmp28 := lang.Apply(tmp27, []any{v8}) + tmp24 = tmp28 + } else { + } + tmp29 := lang.Apply(tmp20, []any{tmp23, tmp24}) + tmp30 := reflect.TypeOf((*lang.IPending)(nil)).Elem() + tmp31 := lang.NewVector(nil) + tmp32 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7099), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(7099), lang.NewKeyword("end-column"), int(24)) + tmp33, err := lang.WithMeta(tmp31, tmp32.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp34 := checkDerefVar(glojure_DOT_core_zero_QMARK_) + tmp35, ok := lang.FieldOrMethod(v5, "getCount") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "getCount"))) + } + var tmp36 any + switch reflect.TypeOf(tmp35).Kind() { + case reflect.Func: + tmp36 = lang.Apply(tmp35, nil) + default: + tmp36 = tmp35 + } + tmp37 := lang.Apply(tmp34, []any{tmp36}) + tmp38 := lang.Apply(nil, []any{tmp33, tmp37}) + tmp39 := lang.NewVector(nil, nil) + tmp40 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7103), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(7103), lang.NewKeyword("end-column"), int(14)) + tmp41, err := lang.WithMeta(tmp39, tmp40.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var tmp42 any + var tmp43 any + { // let + // let binding "and__0__auto__" + tmp44 := checkDerefVar(glojure_DOT_core_pos_QMARK_) + tmp45, ok := lang.FieldOrMethod(v5, "getCount") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "getCount"))) + } + var tmp46 any + switch reflect.TypeOf(tmp45).Kind() { + case reflect.Func: + tmp46 = lang.Apply(tmp45, nil) + default: + tmp46 = tmp45 + } + tmp47 := lang.Apply(tmp44, []any{tmp46}) + var v48 any = tmp47 + _ = v48 + var tmp49 any + if lang.IsTruthy(v48) { + tmp50 := checkDerefVar(glojure_DOT_core_compare_and_set_BANG_) + tmp51 := lang.Apply(tmp50, []any{v8, v5, nil}) + tmp49 = tmp51 + } else { + tmp49 = v48 + } + tmp43 = tmp49 + } // end let + if lang.IsTruthy(tmp43) { + tmp44, ok := lang.FieldOrMethod(v5, "countDown") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "countDown"))) + } + var tmp45 any + switch reflect.TypeOf(tmp44).Kind() { + case reflect.Func: + tmp45 = lang.Apply(tmp44, nil) + default: + tmp45 = tmp44 + } + _ = tmp45 + } else { + } + tmp46 := lang.Apply(nil, []any{tmp41, tmp42}) + tmp47 := lang.Apply(nil, []any{tmp9, tmp18, tmp19, tmp29, tmp30, tmp38, nil, tmp46}) + tmp3 = tmp47 + } // end let + return tmp3 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // protocol? + { + tmp0 := lang.NewSymbol("protocol?").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(110), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(110), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("maybe-p"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp6 := reflect.TypeOf((*lang.IAtom)(nil)).Elem() + tmp7 := lang.Apply(tmp5, []any{tmp6, v3}) + if lang.IsTruthy(tmp7) { + tmp8 := checkDerefVar(glojure_DOT_core_boolean) + tmp9 := checkDerefVar(glojure_DOT_core_deref) + tmp10 := lang.Apply(tmp9, []any{v3}) + tmp11 := lang.Apply(lang.NewKeyword("on-interface"), []any{tmp10}) + tmp12 := lang.Apply(tmp8, []any{tmp11}) + tmp4 = tmp12 + } else { + tmp4 = false + } + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // push-thread-bindings + { + tmp0 := lang.NewSymbol("push-thread-bindings").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"))), lang.NewKeyword("doc"), "WARNING: This is a low-level function. Prefer high-level macros like\n binding where ever possible.\n\n Takes a map of Var/value pairs. Binds each Var to the associated value for\n the current thread. Each call *MUST* be accompanied by a matching call to\n pop-thread-bindings wrapped in a try-finally!\n \n (push-thread-bindings bindings)\n (try\n ...\n (finally\n (pop-thread-bindings)))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(26), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1911), lang.NewKeyword("end-line"), int(1911))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.PushThreadBindings, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // pvalues + { + tmp0 := lang.NewSymbol("pvalues").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("exprs"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the values of the exprs, which are\n evaluated in parallel", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7063), lang.NewKeyword("end-line"), int(7063))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := checkDerefVar(glojure_DOT_core_seq) + tmp7 := checkDerefVar(glojure_DOT_core_concat) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("glojure.core/pcalls")}) + tmp10 := checkDerefVar(glojure_DOT_core_map) + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v12 := args[0] + _ = v12 + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := lang.NewVector() + tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7069), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(7069), lang.NewKeyword("end-column"), int(31)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp17 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/fn"), tmp16, v12}) + return tmp17 + }) + tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7069), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(7069), lang.NewKeyword("end-column"), int(34)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp14 := lang.Apply(tmp10, []any{tmp13, v5}) + tmp15 := lang.Apply(tmp7, []any{tmp9, tmp14}) + tmp16 := lang.Apply(tmp6, []any{tmp15}) + return tmp16 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // qualified-ident? + { + tmp0 := lang.NewSymbol("qualified-ident?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a symbol or keyword with a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1618), lang.NewKeyword("end-line"), int(1618))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_boolean) + var tmp5 any + { // let + // let binding "and__0__auto__" + tmp6 := checkDerefVar(glojure_DOT_core_ident_QMARK_) + tmp7 := lang.Apply(tmp6, []any{v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + var tmp10 any + { // let + // let binding "and__0__auto__" + tmp11 := checkDerefVar(glojure_DOT_core_namespace) + tmp12 := lang.Apply(tmp11, []any{v3}) + var v13 any = tmp12 + _ = v13 + var tmp14 any + if lang.IsTruthy(v13) { + tmp14 = true + } else { + tmp14 = v13 + } + tmp10 = tmp14 + } // end let + tmp9 = tmp10 + } else { + tmp9 = v8 + } + tmp5 = tmp9 + } // end let + tmp6 := lang.Apply(tmp4, []any{tmp5}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // qualified-keyword? + { + tmp0 := lang.NewSymbol("qualified-keyword?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a keyword with a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1638), lang.NewKeyword("end-line"), int(1638))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_boolean) + var tmp5 any + { // let + // let binding "and__0__auto__" + tmp6 := checkDerefVar(glojure_DOT_core_keyword_QMARK_) + tmp7 := lang.Apply(tmp6, []any{v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + var tmp10 any + { // let + // let binding "and__0__auto__" + tmp11 := checkDerefVar(glojure_DOT_core_namespace) + tmp12 := lang.Apply(tmp11, []any{v3}) + var v13 any = tmp12 + _ = v13 + var tmp14 any + if lang.IsTruthy(v13) { + tmp14 = true + } else { + tmp14 = v13 + } + tmp10 = tmp14 + } // end let + tmp9 = tmp10 + } else { + tmp9 = v8 + } + tmp5 = tmp9 + } // end let + tmp6 := lang.Apply(tmp4, []any{tmp5}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // qualified-symbol? + { + tmp0 := lang.NewSymbol("qualified-symbol?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a symbol with a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1628), lang.NewKeyword("end-line"), int(1628))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_boolean) + var tmp5 any + { // let + // let binding "and__0__auto__" + tmp6 := checkDerefVar(glojure_DOT_core_symbol_QMARK_) + tmp7 := lang.Apply(tmp6, []any{v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + var tmp10 any + { // let + // let binding "and__0__auto__" + tmp11 := checkDerefVar(glojure_DOT_core_namespace) + tmp12 := lang.Apply(tmp11, []any{v3}) + var v13 any = tmp12 + _ = v13 + var tmp14 any + if lang.IsTruthy(v13) { + tmp14 = true + } else { + tmp14 = v13 + } + tmp10 = tmp14 + } // end let + tmp9 = tmp10 + } else { + tmp9 = v8 + } + tmp5 = tmp9 + } // end let + tmp6 := lang.Apply(tmp4, []any{tmp5}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // quot + { + var tmp1 lang.FnFunc + { // function quot__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_seq) + tmp6 := checkDerefVar(glojure_DOT_core_concat) + tmp7 := checkDerefVar(glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{lang.NewSymbol(".")}) + tmp9 := checkDerefVar(glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := checkDerefVar(glojure_DOT_core_seq) + tmp13 := checkDerefVar(glojure_DOT_core_concat) + tmp14 := checkDerefVar(glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("glojure.core/Quotient")}) + tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("quot").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"), lang.NewSymbol("div"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "quot[ient] of dividing numerator by denominator.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1266), lang.NewKeyword("end-line"), int(1266))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Quotient") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Quotient is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // rand + { + tmp0 := lang.NewSymbol("rand").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns a random floating point number between 0 (inclusive) and\n n (default 1) (exclusive).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4935), lang.NewKeyword("end-line"), int(4935))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp3 := lang.Apply(rand16.Float64, nil) + return tmp3 + case 1: + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core__STAR_) + tmp5 := checkDerefVar(glojure_DOT_core_rand) + tmp6 := lang.Apply(tmp5, nil) + tmp7 := lang.Apply(tmp4, []any{v3, tmp6}) + return tmp7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // rand-int + { + tmp0 := lang.NewSymbol("rand-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns a random integer between 0 (inclusive) and n (exclusive).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4943), lang.NewKeyword("end-line"), int(4943))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_int) + tmp5 := checkDerefVar(glojure_DOT_core_rand) + tmp6 := lang.Apply(tmp5, []any{v3}) + tmp7 := lang.Apply(tmp4, []any{tmp6}) + return tmp7 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // rand-nth + { + tmp0 := lang.NewSymbol("rand-nth").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return a random element of the (sequential) collection. Will have\n the same performance characteristics as nth for the given\n collection.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7213), lang.NewKeyword("end-line"), int(7213))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_nth) + tmp5 := checkDerefVar(glojure_DOT_core_rand_int) + tmp6 := checkDerefVar(glojure_DOT_core_count) + tmp7 := lang.Apply(tmp6, []any{v3}) + tmp8 := lang.Apply(tmp5, []any{tmp7}) + tmp9 := lang.Apply(tmp4, []any{v3, tmp8}) + return tmp9 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // random-sample + { + tmp0 := lang.NewSymbol("random-sample").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("prob")), lang.NewVector(lang.NewSymbol("prob"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns items from coll with random probability of prob (0.0 -\n 1.0). Returns a transducer when no collection is provided.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7699), lang.NewKeyword("end-line"), int(7699))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_filter) + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v6 := args[0] + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core__LT_) + tmp8 := checkDerefVar(glojure_DOT_core_rand) + tmp9 := lang.Apply(tmp8, nil) + tmp10 := lang.Apply(tmp7, []any{tmp9, v3}) + return tmp10 + }) + tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7704), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(7704), lang.NewKeyword("end-column"), int(37)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp8 := lang.Apply(tmp4, []any{tmp7}) + return tmp8 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_filter) + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v7 := args[0] + _ = v7 + tmp8 := checkDerefVar(glojure_DOT_core__LT_) + tmp9 := checkDerefVar(glojure_DOT_core_rand) + tmp10 := lang.Apply(tmp9, nil) + tmp11 := lang.Apply(tmp8, []any{tmp10, v3}) + return tmp11 + }) + tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7706), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(7706), lang.NewKeyword("end-column"), int(37)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp9 := lang.Apply(tmp5, []any{tmp8, v4}) + return tmp9 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // random-uuid + { + tmp0 := lang.NewSymbol("random-uuid").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Returns a pseudo-randomly generated java.util.UUID instance (i.e. type 4).\n\n See: https://docs.oracle.com/javase/8/docs/api/java/util/UUID.html#randomUUID--", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6852), lang.NewKeyword("end-line"), int(6852))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + tmp3 := lang.Apply(uuid13.NewV7, nil) + return tmp3 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // range + { + tmp0 := lang.NewSymbol("range").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("end")), lang.NewVector(lang.NewSymbol("start"), lang.NewSymbol("end")), lang.NewVector(lang.NewSymbol("start"), lang.NewSymbol("end"), lang.NewSymbol("step"))), lang.NewKeyword("doc"), "Returns a lazy seq of nums from start (inclusive) to end\n (exclusive), by step, where start defaults to 0, step to 1, and end to\n infinity. When step is equal to 0, returns an infinite sequence of\n start. When start is equal to end, returns empty list.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3018), lang.NewKeyword("end-line"), int(3018))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp3 := checkDerefVar(glojure_DOT_core_iterate) + tmp4 := checkDerefVar(glojure_DOT_core_inc_U0027_) + tmp5 := lang.Apply(tmp3, []any{tmp4, int64(0)}) + return tmp5 + case 1: + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(glojure_DOT_core_int_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + tmp7 := lang.Apply(lang.NewLongRange, []any{int64(0), v3, int64(1)}) + tmp4 = tmp7 + } else { + tmp8 := lang.Apply(lang.NewRange, []any{int64(0), v3, int64(1)}) + tmp4 = tmp8 + } + return tmp4 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 any + var tmp6 any + { // let + // let binding "and__0__auto__" + tmp7 := checkDerefVar(glojure_DOT_core_int_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v3}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + tmp11 := checkDerefVar(glojure_DOT_core_int_QMARK_) + tmp12 := lang.Apply(tmp11, []any{v4}) + tmp10 = tmp12 + } else { + tmp10 = v9 + } + tmp6 = tmp10 + } // end let + if lang.IsTruthy(tmp6) { + tmp7 := lang.Apply(lang.NewLongRange, []any{v3, v4, int64(1)}) + tmp5 = tmp7 + } else { + tmp8 := lang.Apply(lang.NewRange, []any{v3, v4, int64(1)}) + tmp5 = tmp8 + } + return tmp5 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var tmp6 any + var tmp7 any + { // let + // let binding "and__0__auto__" + tmp8 := checkDerefVar(glojure_DOT_core_int_QMARK_) + tmp9 := lang.Apply(tmp8, []any{v3}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + if lang.IsTruthy(v10) { + var tmp12 any + { // let + // let binding "and__0__auto__" + tmp13 := checkDerefVar(glojure_DOT_core_int_QMARK_) + tmp14 := lang.Apply(tmp13, []any{v4}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + if lang.IsTruthy(v15) { + tmp17 := checkDerefVar(glojure_DOT_core_int_QMARK_) + tmp18 := lang.Apply(tmp17, []any{v5}) + tmp16 = tmp18 + } else { + tmp16 = v15 + } + tmp12 = tmp16 + } // end let + tmp11 = tmp12 + } else { + tmp11 = v10 + } + tmp7 = tmp11 + } // end let + if lang.IsTruthy(tmp7) { + tmp8 := lang.Apply(lang.NewLongRange, []any{v3, v4, v5}) + tmp6 = tmp8 + } else { + tmp9 := lang.Apply(lang.NewRange, []any{v3, v4, v5}) + tmp6 = tmp9 + } + return tmp6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ratio? + { + tmp0 := lang.NewSymbol("ratio?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is a Ratio", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3577), lang.NewKeyword("end-line"), int(3577))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp5 := reflect.TypeOf((*lang.Ratio)(nil)) + tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // rational? + { + tmp0 := lang.NewSymbol("rational?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is a rational number", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3613), lang.NewKeyword("end-line"), int(3613))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + { // let + // let binding "or__0__auto__" + tmp5 := checkDerefVar(glojure_DOT_core_integer_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + if lang.IsTruthy(v7) { + tmp8 = v7 + } else { + var tmp9 any + { // let + // let binding "or__0__auto__" + tmp10 := checkDerefVar(glojure_DOT_core_ratio_QMARK_) + tmp11 := lang.Apply(tmp10, []any{v3}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + tmp13 = v12 + } else { + tmp14 := checkDerefVar(glojure_DOT_core_decimal_QMARK_) + tmp15 := lang.Apply(tmp14, []any{v3}) + tmp13 = tmp15 + } + tmp9 = tmp13 + } // end let + tmp8 = tmp9 + } + tmp4 = tmp8 + } // end let + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // rationalize + { + tmp0 := lang.NewSymbol("rationalize").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("doc"), "returns the rational value of num", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1282), lang.NewKeyword("end-line"), int(1282))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Rationalize") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Rationalize is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // re-find + { + tmp0 := lang.NewSymbol("re-find").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m")), lang.NewVector(lang.NewSymbol("re"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns the next regex match, if any, of string to pattern, using\n java.util.regex.Matcher.find(). Uses re-groups to return the\n groups.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4922), lang.NewKeyword("end-line"), int(4922))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + var tmp4 any + tmp5, _ := lang.FieldOrMethod(v3, "find") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("find is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{}) + if lang.IsTruthy(tmp6) { + tmp7 := checkDerefVar(glojure_DOT_core_re_groups) + tmp8 := lang.Apply(tmp7, []any{v3}) + tmp4 = tmp8 + } else { + } + return tmp4 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 any + { // let + // let binding "m" + tmp6 := checkDerefVar(glojure_DOT_core_re_matcher) + tmp7 := lang.Apply(tmp6, []any{v3, v4}) + var v8 any = tmp7 + _ = v8 + tmp9 := checkDerefVar(glojure_DOT_core_re_find) + tmp10 := lang.Apply(tmp9, []any{v8}) + tmp5 = tmp10 + } // end let + return tmp5 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // re-groups + { + tmp0 := lang.NewSymbol("re-groups").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"))), lang.NewKeyword("doc"), "Returns the groups from the most recent match/find. If there are no\n nested groups, returns a string of the entire match. If there are\n nested groups, returns a vector of the groups, the first element\n being the entire match.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4882), lang.NewKeyword("end-line"), int(4882))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + { // let + // let binding "gc" + tmp5, _ := lang.FieldOrMethod(v3, "groupCount") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("groupCount is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + tmp9 := checkDerefVar(glojure_DOT_core_zero_QMARK_) + tmp10 := lang.Apply(tmp9, []any{v7}) + if lang.IsTruthy(tmp10) { + tmp11, _ := lang.FieldOrMethod(v3, "group") + if reflect.TypeOf(tmp11).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("group is not a function"))) + } + tmp12 := lang.Apply(tmp11, []any{}) + tmp8 = tmp12 + } else { + var tmp13 any + { // let + // let binding "ret" + tmp14 := lang.NewVector() + tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4893), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(4893), lang.NewKeyword("end-column"), int(21)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v17 any = tmp16 + _ = v17 + // let binding "c" + var v18 any = int64(0) + _ = v18 + for { + var tmp19 any + tmp20 := checkDerefVar(glojure_DOT_core__LT__EQ_) + tmp21 := lang.Apply(tmp20, []any{v18, v7}) + if lang.IsTruthy(tmp21) { + tmp23 := checkDerefVar(glojure_DOT_core_conj) + tmp24, _ := lang.FieldOrMethod(v3, "groupInt") + if reflect.TypeOf(tmp24).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("groupInt is not a function"))) + } + tmp25 := lang.Apply(tmp24, []any{v18}) + tmp26 := lang.Apply(tmp23, []any{v17, tmp25}) + var tmp22 any = tmp26 + tmp28 := checkDerefVar(glojure_DOT_core_inc) + tmp29 := lang.Apply(tmp28, []any{v18}) + var tmp27 any = tmp29 + v17 = tmp22 + v18 = tmp27 + continue + } else { + tmp19 = v17 + } + tmp13 = tmp19 + break + } + } // end let + tmp8 = tmp13 + } + tmp4 = tmp8 + } // end let + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // re-matcher + { + tmp1 := reflect.TypeOf((*lang.RegexpMatcher)(nil)) + tmp0 := lang.NewSymbol("re-matcher").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("re"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns an instance of java.util.regex.Matcher, for use, e.g. in\n re-find.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4873), lang.NewKeyword("end-line"), int(4873))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6 := lang.Apply(lang.NewRegexpMatcher, []any{v4, v5}) + return tmp6 + }) + tmp4 := reflect.TypeOf((*lang.RegexpMatcher)(nil)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // re-matches + { + tmp0 := lang.NewSymbol("re-matches").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("re"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns the match, if any, of string to pattern, using\n java.util.regex.Matcher.matches(). Uses re-groups to return the\n groups.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4910), lang.NewKeyword("end-line"), int(4910))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 any + { // let + // let binding "m" + tmp6 := checkDerefVar(glojure_DOT_core_re_matcher) + tmp7 := lang.Apply(tmp6, []any{v3, v4}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + tmp10, _ := lang.FieldOrMethod(v8, "matches") + if reflect.TypeOf(tmp10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("matches is not a function"))) + } + tmp11 := lang.Apply(tmp10, []any{}) + if lang.IsTruthy(tmp11) { + tmp12 := checkDerefVar(glojure_DOT_core_re_groups) + tmp13 := lang.Apply(tmp12, []any{v8}) + tmp9 = tmp13 + } else { + } + tmp5 = tmp9 + } // end let + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // re-pattern + { + tmp1 := reflect.TypeOf((*regexp15.Regexp)(nil)) + tmp0 := lang.NewSymbol("re-pattern").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns an instance of java.util.regex.Pattern, for use, e.g. in\n re-matcher.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4863), lang.NewKeyword("end-line"), int(4863))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp7 := reflect.TypeOf((*regexp15.Regexp)(nil)) + tmp8 := lang.Apply(tmp6, []any{tmp7, v4}) + if lang.IsTruthy(tmp8) { + tmp5 = v4 + } else { + tmp9 := lang.Apply(regexp15.MustCompile, []any{v4}) + tmp5 = tmp9 + } + return tmp5 + }) + tmp4 := reflect.TypeOf((*regexp15.Regexp)(nil)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // re-seq + { + tmp0 := lang.NewSymbol("re-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("re"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns a lazy sequence of successive matches of pattern in string,\n using java.util.regex.Matcher.find(), each such match processed with\n re-groups.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4898), lang.NewKeyword("end-line"), int(4898))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 any + { // let + // let binding "m" + tmp6 := checkDerefVar(glojure_DOT_core_re_matcher) + tmp7 := lang.Apply(tmp6, []any{v3, v4}) + var v8 any = tmp7 + _ = v8 + var tmp9 lang.FnFunc + { // function step + var v10 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var tmp11 any + tmp12, _ := lang.FieldOrMethod(v8, "find") + if reflect.TypeOf(tmp12).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("find is not a function"))) + } + tmp13 := lang.Apply(tmp12, []any{}) + if lang.IsTruthy(tmp13) { + tmp14 := checkDerefVar(glojure_DOT_core_cons) + tmp15 := checkDerefVar(glojure_DOT_core_re_groups) + tmp16 := lang.Apply(tmp15, []any{v8}) + var tmp17 lang.FnFunc + tmp17 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + tmp18 := lang.Apply(v10, nil) + return tmp18 + }) + tmp18 := lang.Apply(lang.NewLazySeq, []any{tmp17}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp11 = tmp19 + } else { + } + return tmp11 + }) + v10 = tmp9 + _ = v10 + } + tmp10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4906), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(4908), lang.NewKeyword("end-column"), int(49)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp12 := lang.Apply(tmp11, nil) + tmp5 = tmp12 + } // end let + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // read + { + tmp0 := lang.NewSymbol("read").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("stream")), lang.NewVector(lang.NewSymbol("stream"), lang.NewSymbol("eof-error?"), lang.NewSymbol("eof-value")), lang.NewVector(lang.NewSymbol("stream"), lang.NewSymbol("eof-error?"), lang.NewSymbol("eof-value"), lang.NewSymbol("recursive?")), lang.NewVector(lang.NewSymbol("opts"), lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Reads the next object from stream, which must be an instance of\n java.io.PushbackReader or some derivee. stream defaults to the\n current value of *in*.\n\n Opts is a persistent map with valid keys:\n :read-cond - :allow to process reader conditionals, or\n :preserve to keep all branches\n :features - persistent set of feature keywords for reader conditionals\n :eof - on eof, return value unless :eofthrow, then throw.\n if not specified, will throw\n\n Note that read can execute code (controlled by *read-eval*),\n and as such should be used only with trusted sources.\n\n For data structure interop use glojure.edn/read", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3742), lang.NewKeyword("end-line"), int(3742))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp3 := checkDerefVar(glojure_DOT_core_read) + tmp4 := checkDerefVar(glojure_DOT_core__STAR_in_STAR_) + tmp5 := lang.Apply(tmp3, []any{tmp4}) + return tmp5 + case 1: + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_read) + tmp5 := lang.Apply(tmp4, []any{v3, true, nil}) + return tmp5 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6 := checkDerefVar(glojure_DOT_core_read) + tmp7 := lang.Apply(tmp6, []any{v3, v4, v5, false}) + return tmp7 + case 4: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_boolean) + tmp8 := lang.Apply(tmp7, []any{v4}) + tmp9, _ := lang.FieldOrMethod(nil, "read") + if reflect.TypeOf(tmp9).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("read is not a function"))) + } + tmp10 := lang.Apply(tmp9, []any{v3, tmp8, v5, v6}) + return tmp10 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(nil, "read") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("read is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4, v3}) + return tmp6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // read+string + { + tmp0 := lang.NewSymbol("read+string").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("stream")), lang.NewVector(lang.NewSymbol("stream"), lang.NewSymbol("eof-error?"), lang.NewSymbol("eof-value")), lang.NewVector(lang.NewSymbol("stream"), lang.NewSymbol("eof-error?"), lang.NewSymbol("eof-value"), lang.NewSymbol("recursive?")), lang.NewVector(lang.NewSymbol("opts"), lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Like read, and taking the same args. stream must be a LineNumberingPushbackReader.\n Returns a vector containing the object read and the (whitespace-trimmed) string read.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3771), lang.NewKeyword("end-line"), int(3771))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp3 := checkDerefVar(glojure_DOT_core_read_PLUS_string) + tmp4 := checkDerefVar(glojure_DOT_core__STAR_in_STAR_) + tmp5 := lang.Apply(tmp3, []any{tmp4}) + return tmp5 + case 1: + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_read_PLUS_string) + tmp5 := lang.Apply(tmp4, []any{v3, true, nil}) + return tmp5 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6 := checkDerefVar(glojure_DOT_core_read_PLUS_string) + tmp7 := lang.Apply(tmp6, []any{v3, v4, v5, false}) + return tmp7 + case 4: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + var tmp7 any + func() { + defer func() { + if r := recover(); r != nil { + if lang.CatchMatches(r, lang.Throwable) { + v8 := r + _ = v8 + tmp9, ok := lang.FieldOrMethod(v3, "getString") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getString"))) + } + var tmp10 any + switch reflect.TypeOf(tmp9).Kind() { + case reflect.Func: + tmp10 = lang.Apply(tmp9, nil) + default: + tmp10 = tmp9 + } + _ = tmp10 + panic(v8) + } else { + panic(r) + } + } + }() + tmp8, ok := lang.FieldOrMethod(v3, "captureString") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "captureString"))) + } + var tmp9 any + switch reflect.TypeOf(tmp8).Kind() { + case reflect.Func: + tmp9 = lang.Apply(tmp8, nil) + default: + tmp9 = tmp8 + } + _ = tmp9 + var tmp10 any + { // let + // let binding "o" + tmp11 := checkDerefVar(glojure_DOT_core_read) + tmp12 := lang.Apply(tmp11, []any{v3, v4, v5, v6}) + var v13 any = tmp12 + _ = v13 + // let binding "s" + tmp14, ok := lang.FieldOrMethod(v3, "getString") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getString"))) + } + var tmp15 any + switch reflect.TypeOf(tmp14).Kind() { + case reflect.Func: + tmp15 = lang.Apply(tmp14, nil) + default: + tmp15 = tmp14 + } + tmp16, ok := lang.FieldOrMethod(tmp15, "trim") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp15, "trim"))) + } + var tmp17 any + switch reflect.TypeOf(tmp16).Kind() { + case reflect.Func: + tmp17 = lang.Apply(tmp16, nil) + default: + tmp17 = tmp16 + } + var v18 any = tmp17 + _ = v18 + tmp19 := lang.NewVector(v13, v18) + tmp20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3783), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(3783), lang.NewKeyword("end-column"), int(12)) + tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp10 = tmp21 + } // end let + tmp7 = tmp10 + }() + return tmp7 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 any + func() { + defer func() { + if r := recover(); r != nil { + if lang.CatchMatches(r, lang.Throwable) { + v6 := r + _ = v6 + tmp7, ok := lang.FieldOrMethod(v4, "getString") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "getString"))) + } + var tmp8 any + switch reflect.TypeOf(tmp7).Kind() { + case reflect.Func: + tmp8 = lang.Apply(tmp7, nil) + default: + tmp8 = tmp7 + } + _ = tmp8 + panic(v6) + } else { + panic(r) + } + } + }() + tmp6, ok := lang.FieldOrMethod(v4, "captureString") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "captureString"))) + } + var tmp7 any + switch reflect.TypeOf(tmp6).Kind() { + case reflect.Func: + tmp7 = lang.Apply(tmp6, nil) + default: + tmp7 = tmp6 + } + _ = tmp7 + var tmp8 any + { // let + // let binding "o" + tmp9 := checkDerefVar(glojure_DOT_core_read) + tmp10 := lang.Apply(tmp9, []any{v3, v4}) + var v11 any = tmp10 + _ = v11 + // let binding "s" + tmp12, ok := lang.FieldOrMethod(v4, "getString") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "getString"))) + } + var tmp13 any + switch reflect.TypeOf(tmp12).Kind() { + case reflect.Func: + tmp13 = lang.Apply(tmp12, nil) + default: + tmp13 = tmp12 + } + tmp14, ok := lang.FieldOrMethod(tmp13, "trim") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp13, "trim"))) + } + var tmp15 any + switch reflect.TypeOf(tmp14).Kind() { + case reflect.Func: + tmp15 = lang.Apply(tmp14, nil) + default: + tmp15 = tmp14 + } + var v16 any = tmp15 + _ = v16 + tmp17 := lang.NewVector(v11, v16) + tmp18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3792), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(3792), lang.NewKeyword("end-column"), int(12)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp8 = tmp19 + } // end let + tmp5 = tmp8 + }() + return tmp5 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // read-line + { + tmp0 := lang.NewSymbol("read-line").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Reads the next line from stream that is the current value of *in* .", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3797), lang.NewKeyword("end-line"), int(3797))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var tmp3 any + tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp5 := checkDerefVar(glojure_DOT_core__STAR_in_STAR_) + tmp6 := lang.Apply(tmp4, []any{nil, tmp5}) + if lang.IsTruthy(tmp6) { + tmp7 := checkDerefVar(glojure_DOT_core__STAR_in_STAR_) + tmp8, ok := lang.FieldOrMethod(tmp7, "readLine") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp7, "readLine"))) + } + var tmp9 any + switch reflect.TypeOf(tmp8).Kind() { + case reflect.Func: + tmp9 = lang.Apply(tmp8, nil) + default: + tmp9 = tmp8 + } + tmp3 = tmp9 + } else { + tmp10 := checkDerefVar(glojure_DOT_core__STAR_in_STAR_) + tmp11, ok := lang.FieldOrMethod(tmp10, "readLine") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp10, "readLine"))) + } + var tmp12 any + switch reflect.TypeOf(tmp11).Kind() { + case reflect.Func: + tmp12 = lang.Apply(tmp11, nil) + default: + tmp12 = tmp11 + } + tmp3 = tmp12 + } + return tmp3 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // read-string + { + tmp0 := lang.NewSymbol("read-string").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s")), lang.NewVector(lang.NewSymbol("opts"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Reads one object from the string s. Optionally include reader\n options, as specified in read.\n\n Note that read-string can execute code (controlled by *read-eval*),\n and as such should be used only with trusted sources.\n\n For data structure interop use glojure.edn/read-string", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3806), lang.NewKeyword("end-line"), int(3806))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(runtime7.RTReadString, []any{v3}) + return tmp4 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(runtime7.RTReadString, []any{v4, v3}) + return tmp5 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reader-conditional + { + tmp0 := lang.NewSymbol("reader-conditional").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("form"), lang.NewSymbol("splicing?"))), lang.NewKeyword("doc"), "Construct a data representation of a reader conditional.\n If true, splicing? indicates read-cond-splicing.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7782), lang.NewKeyword("end-line"), int(7782))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(nil, []any{v3, v4}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reader-conditional? + { + tmp0 := lang.NewSymbol("reader-conditional?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("value"))), lang.NewKeyword("doc"), "Return true if the value is the data representation of a reader conditional", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7776), lang.NewKeyword("end-line"), int(7776))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp5 := lang.Apply(tmp4, []any{nil, v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // realized? + { + tmp0 := lang.NewSymbol("realized?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if a value has been produced for a promise, delay, future or lazy sequence.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7559), lang.NewKeyword("end-line"), int(7559))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4, ok := lang.FieldOrMethod(v3, "isRealized") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "isRealized"))) + } + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { + case reflect.Func: + tmp5 = lang.Apply(tmp4, nil) + default: + tmp5 = tmp4 + } + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reduce + { + tmp0 := lang.NewSymbol("reduce").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("val"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "f should be a function of 2 arguments. If val is not supplied,\n returns the result of applying f to the first 2 items in coll, then\n applying f to that result and the 3rd item, etc. If coll contains no\n items, f must accept no arguments as well, and reduce returns the\n result of calling f with no arguments. If coll has only 1 item, it\n is returned and f is not called. If val is supplied, returns the\n result of applying f to val and the first item in coll, then\n applying f to that result and the 2nd item, etc. If coll contains no\n items, returns val and f is not called.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6860), lang.NewKeyword("end-line"), int(6860))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp7 := reflect.TypeOf((*lang.IReduce)(nil)).Elem() + tmp8 := lang.Apply(tmp6, []any{tmp7, v4}) + if lang.IsTruthy(tmp8) { + tmp9, _ := lang.FieldOrMethod(v4, "Reduce") + if reflect.TypeOf(tmp9).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Reduce is not a function"))) + } + tmp10 := lang.Apply(tmp9, []any{v3}) + tmp5 = tmp10 + } else { + tmp11 := checkDerefVar(glojure_DOT_core_DOT_protocols_coll_reduce) + tmp12 := lang.Apply(tmp11, []any{v4, v3}) + tmp5 = tmp12 + } + return tmp5 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp8 := reflect.TypeOf((*lang.IReduceInit)(nil)).Elem() + tmp9 := lang.Apply(tmp7, []any{tmp8, v5}) + if lang.IsTruthy(tmp9) { + tmp10, _ := lang.FieldOrMethod(v5, "ReduceInit") + if reflect.TypeOf(tmp10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) + } + tmp11 := lang.Apply(tmp10, []any{v3, v4}) + tmp6 = tmp11 + } else { + tmp12 := checkDerefVar(glojure_DOT_core_DOT_protocols_coll_reduce) + tmp13 := lang.Apply(tmp12, []any{v5, v3, v4}) + tmp6 = tmp13 + } + return tmp6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reduce-kv + { + tmp0 := lang.NewSymbol("reduce-kv").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Reduces an associative collection. f should be a function of 3\n arguments. Returns the result of applying f to init, the first key\n and the first value in coll, then applying f to that result and the\n 2nd key and value, etc. If coll contains no entries, returns init\n and f is not called. Note that reduce-kv is supported on vectors,\n where the keys will be the ordinals.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6882), lang.NewKeyword("end-line"), int(6882))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6 := checkDerefVar(glojure_DOT_core_DOT_protocols_kv_reduce) + tmp7 := lang.Apply(tmp6, []any{v5, v3, v4}) + return tmp7 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reduce1 + { + tmp0 := lang.NewSymbol("reduce1").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(923), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(924), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("val"), lang.NewSymbol("coll"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 any + { // let + // let binding "s" + tmp6 := checkDerefVar(glojure_DOT_core_seq) + tmp7 := lang.Apply(tmp6, []any{v4}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + tmp10 := checkDerefVar(glojure_DOT_core_reduce1) + tmp11 := checkDerefVar(glojure_DOT_core_first) + tmp12 := lang.Apply(tmp11, []any{v8}) + tmp13 := checkDerefVar(glojure_DOT_core_next) + tmp14 := lang.Apply(tmp13, []any{v8}) + tmp15 := lang.Apply(tmp10, []any{v3, tmp12, tmp14}) + tmp9 = tmp15 + } else { + tmp16 := lang.Apply(v3, nil) + tmp9 = tmp16 + } + tmp5 = tmp9 + } // end let + return tmp5 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + recur_loop_156: + var tmp6 any + { // let + // let binding "s" + tmp7 := checkDerefVar(glojure_DOT_core_seq) + tmp8 := lang.Apply(tmp7, []any{v5}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + var tmp11 any + tmp12 := checkDerefVar(glojure_DOT_core_chunked_seq_QMARK_) + tmp13 := lang.Apply(tmp12, []any{v9}) + if lang.IsTruthy(tmp13) { + var tmp14 any = v3 + tmp16 := checkDerefVar(glojure_DOT_core_chunk_first) + tmp17 := lang.Apply(tmp16, []any{v9}) + tmp18, _ := lang.FieldOrMethod(tmp17, "ReduceInit") + if reflect.TypeOf(tmp18).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) + } + tmp19 := lang.Apply(tmp18, []any{v3, v4}) + var tmp15 any = tmp19 + tmp21 := checkDerefVar(glojure_DOT_core_chunk_next) + tmp22 := lang.Apply(tmp21, []any{v9}) + var tmp20 any = tmp22 + v3 = tmp14 + v4 = tmp15 + v5 = tmp20 + goto recur_loop_156 + } else { + var tmp23 any = v3 + tmp25 := checkDerefVar(glojure_DOT_core_first) + tmp26 := lang.Apply(tmp25, []any{v9}) + tmp27 := lang.Apply(v3, []any{v4, tmp26}) + var tmp24 any = tmp27 + tmp29 := checkDerefVar(glojure_DOT_core_next) + tmp30 := lang.Apply(tmp29, []any{v9}) + var tmp28 any = tmp30 + v3 = tmp23 + v4 = tmp24 + v5 = tmp28 + goto recur_loop_156 + } + tmp10 = tmp11 + } else { + tmp10 = v4 + } + tmp6 = tmp10 + } // end let + return tmp6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reduced + { + tmp0 := lang.NewSymbol("reduced").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Wraps x in a way such that a reduce will terminate with the value x", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2828), lang.NewKeyword("end-line"), int(2828))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.NewReduced, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reduced? + { + var tmp1 lang.FnFunc + { // function reduced?__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.IsReduced")}) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{v3}) + tmp10 := lang.Apply(tmp5, []any{tmp7, tmp9}) + tmp11 := lang.Apply(tmp4, []any{tmp10}) + return tmp11 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("reduced?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns true if x is the result of a call to reduced", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1)})), lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2834), lang.NewKeyword("end-line"), int(2834))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5 := lang.Apply(lang.IsReduced, []any{v4}) + return tmp5 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reductions + { + tmp0 := lang.NewSymbol("reductions").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy seq of the intermediate values of the reduction (as\n per reduce) of coll by f, starting with init.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7196), lang.NewKeyword("end-line"), int(7196))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var tmp6 any + { // let + // let binding "temp__0__auto__" + tmp7 := checkDerefVar(glojure_DOT_core_seq) + tmp8 := lang.Apply(tmp7, []any{v4}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + var tmp11 any + { // let + // let binding "s" + var v12 any = v9 + _ = v12 + tmp13 := checkDerefVar(glojure_DOT_core_reductions) + tmp14 := checkDerefVar(glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v12}) + tmp16 := checkDerefVar(glojure_DOT_core_rest) + tmp17 := lang.Apply(tmp16, []any{v12}) + tmp18 := lang.Apply(tmp13, []any{v3, tmp15, tmp17}) + tmp11 = tmp18 + } // end let + tmp10 = tmp11 + } else { + tmp12 := checkDerefVar(glojure_DOT_core_list) + tmp13 := lang.Apply(v3, nil) + tmp14 := lang.Apply(tmp12, []any{tmp13}) + tmp10 = tmp14 + } + tmp6 = tmp10 + } // end let + return tmp6 + }) + tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) + return tmp6 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(glojure_DOT_core_reduced_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v4}) + if lang.IsTruthy(tmp8) { + tmp9 := checkDerefVar(glojure_DOT_core_list) + tmp10 := checkDerefVar(glojure_DOT_core_deref) + tmp11 := lang.Apply(tmp10, []any{v4}) + tmp12 := lang.Apply(tmp9, []any{tmp11}) + tmp6 = tmp12 + } else { + tmp13 := checkDerefVar(glojure_DOT_core_cons) + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var tmp15 any + { // let + // let binding "temp__0__auto__" + tmp16 := checkDerefVar(glojure_DOT_core_seq) + tmp17 := lang.Apply(tmp16, []any{v5}) + var v18 any = tmp17 + _ = v18 + var tmp19 any + if lang.IsTruthy(v18) { + var tmp20 any + { // let + // let binding "s" + var v21 any = v18 + _ = v21 + tmp22 := checkDerefVar(glojure_DOT_core_reductions) + tmp23 := checkDerefVar(glojure_DOT_core_first) + tmp24 := lang.Apply(tmp23, []any{v21}) + tmp25 := lang.Apply(v3, []any{v4, tmp24}) + tmp26 := checkDerefVar(glojure_DOT_core_rest) + tmp27 := lang.Apply(tmp26, []any{v21}) + tmp28 := lang.Apply(tmp22, []any{v3, tmp25, tmp27}) + tmp20 = tmp28 + } // end let + tmp19 = tmp20 + } else { + } + tmp15 = tmp19 + } // end let + return tmp15 + }) + tmp15 := lang.Apply(lang.NewLazySeq, []any{tmp14}) + tmp16 := lang.Apply(tmp13, []any{v4, tmp15}) + tmp6 = tmp16 + } + return tmp6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ref + { + tmp0 := lang.NewSymbol("ref").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Creates and returns a Ref with an initial value of x and zero or\n more options (in any order):\n\n :meta metadata-map\n\n :validator validate-fn\n\n :min-history (default 0)\n :max-history (default 10)\n\n If metadata-map is supplied, it will become the metadata on the\n ref. validate-fn must be nil or a side-effect-free fn of one\n argument, which will be passed the intended new state on any state\n change. If the new state is unacceptable, the validate-fn should\n return false or throw an exception. validate-fn will be called on\n transaction commit, when all refs have their final values.\n\n Normally refs accumulate history dynamically as needed to deal with\n read demands. If you know in advance you will need history you can\n set :min-history to ensure it will be available when first needed (instead\n of after a read fault). History is limited, and the limit can be set\n with :max-history.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2260), lang.NewKeyword("end-line"), int(2260))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.NewRef, []any{v3}) + return tmp4 + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any = lang.NewList(args[1:]...) + _ = v4 + var tmp5 any + { // let + // let binding "r" + tmp6 := checkDerefVar(glojure_DOT_core_setup_reference) + tmp7 := checkDerefVar(glojure_DOT_core_ref) + tmp8 := lang.Apply(tmp7, []any{v3}) + tmp9 := lang.Apply(tmp6, []any{tmp8, v4}) + var v10 any = tmp9 + _ = v10 + // let binding "opts" + tmp11 := checkDerefVar(glojure_DOT_core_apply) + tmp12 := checkDerefVar(glojure_DOT_core_hash_map) + tmp13 := lang.Apply(tmp11, []any{tmp12, v4}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + tmp16 := lang.Apply(lang.NewKeyword("max-history"), []any{v14}) + if lang.IsTruthy(tmp16) { + tmp17 := lang.Apply(lang.NewKeyword("max-history"), []any{v14}) + tmp18, _ := lang.FieldOrMethod(v10, "setMaxHistory") + if reflect.TypeOf(tmp18).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMaxHistory is not a function"))) + } + tmp19 := lang.Apply(tmp18, []any{tmp17}) + tmp15 = tmp19 + } else { + } + _ = tmp15 + var tmp20 any + tmp21 := lang.Apply(lang.NewKeyword("min-history"), []any{v14}) + if lang.IsTruthy(tmp21) { + tmp22 := lang.Apply(lang.NewKeyword("min-history"), []any{v14}) + tmp23, _ := lang.FieldOrMethod(v10, "setMinHistory") + if reflect.TypeOf(tmp23).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMinHistory is not a function"))) + } + tmp24 := lang.Apply(tmp23, []any{tmp22}) + tmp20 = tmp24 + } else { + } + _ = tmp20 + tmp5 = v10 + } // end let + return tmp5 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ref-history-count + { + tmp0 := lang.NewSymbol("ref-history-count").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref"))), lang.NewKeyword("doc"), "Returns the history count of a ref", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2455), lang.NewKeyword("end-line"), int(2455))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4, ok := lang.FieldOrMethod(v3, "getHistoryCount") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getHistoryCount"))) + } + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { + case reflect.Func: + tmp5 = lang.Apply(tmp4, nil) + default: + tmp5 = tmp4 + } + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ref-max-history + { + tmp0 := lang.NewSymbol("ref-max-history").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref")), lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Gets the max-history of a ref, or sets it and returns the ref", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2471), lang.NewKeyword("end-line"), int(2471))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + tmp4, ok := lang.FieldOrMethod(v3, "getMaxHistory") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getMaxHistory"))) + } + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { + case reflect.Func: + tmp5 = lang.Apply(tmp4, nil) + default: + tmp5 = tmp4 + } + return tmp5 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(v3, "setMaxHistory") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMaxHistory is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ref-min-history + { + tmp0 := lang.NewSymbol("ref-min-history").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref")), lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Gets the min-history of a ref, or sets it and returns the ref", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2462), lang.NewKeyword("end-line"), int(2462))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + tmp4, ok := lang.FieldOrMethod(v3, "getMinHistory") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getMinHistory"))) + } + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { + case reflect.Func: + tmp5 = lang.Apply(tmp4, nil) + default: + tmp5 = tmp4 + } + return tmp5 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(v3, "setMinHistory") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMinHistory is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ref-set + { + tmp0 := lang.NewSymbol("ref-set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Must be called in a transaction. Sets the value of ref.\n Returns val.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2447), lang.NewKeyword("end-line"), int(2447))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(v3, "set") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("set is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // refer + { + tmp0 := lang.NewSymbol("refer").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns-sym"), lang.NewSymbol("&"), lang.NewSymbol("filters"))), lang.NewKeyword("doc"), "refers to all public vars of ns, subject to filters.\n filters can include at most one each of:\n\n :exclude list-of-symbols\n :only list-of-symbols\n :rename map-of-fromsymbol-tosymbol\n\n For each public interned var in the namespace named by the symbol,\n adds a mapping from the name of the var to the var to the current\n namespace. Throws an exception if name is already mapped to\n something else in the current namespace. Filters can be used to\n select a subset, via inclusion or exclusion, or to provide a mapping\n to a symbol different from the var's name, in order to prevent\n clashes. Use :use in the ns macro in preference to calling this directly.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4216), lang.NewKeyword("end-line"), int(4216))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any = lang.NewList(args[1:]...) + _ = v4 + var tmp5 any + { // let + // let binding "ns" + var tmp6 any + { // let + // let binding "or__0__auto__" + tmp7 := checkDerefVar(glojure_DOT_core_find_ns) + tmp8 := lang.Apply(tmp7, []any{v3}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + tmp10 = v9 + } else { + tmp11 := checkDerefVar(glojure_DOT_core_str) + tmp12 := lang.Apply(tmp11, []any{"No namespace: ", v3}) + tmp13 := lang.Apply(errors8.New, []any{tmp12}) + panic(tmp13) + } + tmp6 = tmp10 + } // end let + var v7 any = tmp6 + _ = v7 + // let binding "fs" + tmp8 := checkDerefVar(glojure_DOT_core_apply) + tmp9 := checkDerefVar(glojure_DOT_core_hash_map) + tmp10 := lang.Apply(tmp8, []any{tmp9, v4}) + var v11 any = tmp10 + _ = v11 + // let binding "nspublics" + tmp12 := checkDerefVar(glojure_DOT_core_ns_publics) + tmp13 := lang.Apply(tmp12, []any{v7}) + var v14 any = tmp13 + _ = v14 + // let binding "rename" + var tmp15 any + { // let + // let binding "or__0__auto__" + tmp16 := lang.Apply(lang.NewKeyword("rename"), []any{v11}) + var v17 any = tmp16 + _ = v17 + var tmp18 any + if lang.IsTruthy(v17) { + tmp18 = v17 + } else { + tmp19 := lang.NewMap() + tmp20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4236), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(4236), lang.NewKeyword("end-column"), int(36)) + tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp18 = tmp21 + } + tmp15 = tmp18 + } // end let + var v16 any = tmp15 + _ = v16 + // let binding "exclude" + tmp17 := checkDerefVar(glojure_DOT_core_set) + tmp18 := lang.Apply(lang.NewKeyword("exclude"), []any{v11}) + tmp19 := lang.Apply(tmp17, []any{tmp18}) + var v20 any = tmp19 + _ = v20 + // let binding "to-do" + var tmp21 any + tmp22 := checkDerefVar(glojure_DOT_core__EQ_) + tmp23 := lang.Apply(lang.NewKeyword("refer"), []any{v11}) + tmp24 := lang.Apply(tmp22, []any{lang.NewKeyword("all"), tmp23}) + if lang.IsTruthy(tmp24) { + tmp25 := checkDerefVar(glojure_DOT_core_keys) + tmp26 := lang.Apply(tmp25, []any{v14}) + tmp21 = tmp26 + } else { + var tmp27 any + { // let + // let binding "or__0__auto__" + tmp28 := lang.Apply(lang.NewKeyword("refer"), []any{v11}) + var v29 any = tmp28 + _ = v29 + var tmp30 any + if lang.IsTruthy(v29) { + tmp30 = v29 + } else { + var tmp31 any + { // let + // let binding "or__0__auto__" + tmp32 := lang.Apply(lang.NewKeyword("only"), []any{v11}) + var v33 any = tmp32 + _ = v33 + var tmp34 any + if lang.IsTruthy(v33) { + tmp34 = v33 + } else { + tmp35 := checkDerefVar(glojure_DOT_core_keys) + tmp36 := lang.Apply(tmp35, []any{v14}) + tmp34 = tmp36 + } + tmp31 = tmp34 + } // end let + tmp30 = tmp31 + } + tmp27 = tmp30 + } // end let + tmp21 = tmp27 + } + var v28 any = tmp21 + _ = v28 + var tmp29 any + var tmp30 any + { // let + // let binding "and__0__auto__" + var v31 any = v28 + _ = v31 + var tmp32 any + if lang.IsTruthy(v31) { + tmp33 := checkDerefVar(glojure_DOT_core_not) + tmp34 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp35 := reflect.TypeOf((*lang.Sequential)(nil)).Elem() + tmp36 := lang.Apply(tmp34, []any{tmp35, v28}) + tmp37 := lang.Apply(tmp33, []any{tmp36}) + tmp32 = tmp37 + } else { + tmp32 = v31 + } + tmp30 = tmp32 + } // end let + if lang.IsTruthy(tmp30) { + tmp31 := lang.Apply(errors8.New, []any{":only/:refer value must be a sequential collection of symbols"}) + panic(tmp31) + } else { + } + _ = tmp29 + var tmp32 any + { // let + // let binding "seq_9" + tmp33 := checkDerefVar(glojure_DOT_core_seq) + tmp34 := lang.Apply(tmp33, []any{v28}) + var v35 any = tmp34 + _ = v35 + // let binding "chunk_10" + var v36 any = nil + _ = v36 + // let binding "count_11" + var v37 any = int64(0) + _ = v37 + // let binding "i_12" + var v38 any = int64(0) + _ = v38 + for { + var tmp39 any + tmp40 := checkDerefVar(glojure_DOT_core__LT_) + tmp41 := lang.Apply(tmp40, []any{v38, v37}) + if lang.IsTruthy(tmp41) { + var tmp42 any + { // let + // let binding "sym" + tmp43, _ := lang.FieldOrMethod(v36, "nth") + if reflect.TypeOf(tmp43).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp44 := lang.Apply(tmp43, []any{v38}) + var v45 any = tmp44 + _ = v45 + var tmp46 any + tmp47 := lang.Apply(v20, []any{v45}) + if lang.IsTruthy(tmp47) { + } else { + var tmp48 any + { // let + // let binding "v" + tmp49 := lang.Apply(v14, []any{v45}) + var v50 any = tmp49 + _ = v50 + var tmp51 any + if lang.IsTruthy(v50) { + } else { + panic("unimplemented: new with non-constant class type") + } + _ = tmp51 + tmp52 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) + var tmp53 any + { // let + // let binding "or__0__auto__" + tmp54 := lang.Apply(v16, []any{v45}) + var v55 any = tmp54 + _ = v55 + var tmp56 any + if lang.IsTruthy(v55) { + tmp56 = v55 + } else { + tmp56 = v45 + } + tmp53 = tmp56 + } // end let + tmp54, _ := lang.FieldOrMethod(tmp52, "Refer") + if reflect.TypeOf(tmp54).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Refer is not a function"))) + } + tmp55 := lang.Apply(tmp54, []any{tmp53, v50}) + tmp48 = tmp55 + } // end let + tmp46 = tmp48 + } + _ = tmp46 + var tmp49 any = v35 + var tmp50 any = v36 + var tmp51 any = v37 + tmp53 := checkDerefVar(glojure_DOT_core_unchecked_inc) + tmp54 := lang.Apply(tmp53, []any{v38}) + var tmp52 any = tmp54 + v35 = tmp49 + v36 = tmp50 + v37 = tmp51 + v38 = tmp52 + continue + } // end let + tmp39 = tmp42 + } else { + var tmp43 any + { // let + // let binding "temp__0__auto__" + tmp44 := checkDerefVar(glojure_DOT_core_seq) + tmp45 := lang.Apply(tmp44, []any{v35}) + var v46 any = tmp45 + _ = v46 + var tmp47 any + if lang.IsTruthy(v46) { + var tmp48 any + { // let + // let binding "seq_9" + var v49 any = v46 + _ = v49 + var tmp50 any + tmp51 := checkDerefVar(glojure_DOT_core_chunked_seq_QMARK_) + tmp52 := lang.Apply(tmp51, []any{v49}) + if lang.IsTruthy(tmp52) { + var tmp53 any + { // let + // let binding "c__0__auto__" + tmp54 := checkDerefVar(glojure_DOT_core_chunk_first) + tmp55 := lang.Apply(tmp54, []any{v49}) + var v56 any = tmp55 + _ = v56 + tmp58 := checkDerefVar(glojure_DOT_core_chunk_rest) + tmp59 := lang.Apply(tmp58, []any{v49}) + var tmp57 any = tmp59 + var tmp60 any = v56 + tmp62 := checkDerefVar(glojure_DOT_core_int) + tmp63 := checkDerefVar(glojure_DOT_core_count) + tmp64 := lang.Apply(tmp63, []any{v56}) + tmp65 := lang.Apply(tmp62, []any{tmp64}) + var tmp61 any = tmp65 + tmp67 := checkDerefVar(glojure_DOT_core_int) + tmp68 := lang.Apply(tmp67, []any{int64(0)}) + var tmp66 any = tmp68 + v35 = tmp57 + v36 = tmp60 + v37 = tmp61 + v38 = tmp66 + continue + } // end let + tmp50 = tmp53 + } else { + var tmp54 any + { // let + // let binding "sym" + tmp55 := checkDerefVar(glojure_DOT_core_first) + tmp56 := lang.Apply(tmp55, []any{v49}) + var v57 any = tmp56 + _ = v57 + var tmp58 any + tmp59 := lang.Apply(v20, []any{v57}) + if lang.IsTruthy(tmp59) { + } else { + var tmp60 any + { // let + // let binding "v" + tmp61 := lang.Apply(v14, []any{v57}) + var v62 any = tmp61 + _ = v62 + var tmp63 any + if lang.IsTruthy(v62) { + } else { + panic("unimplemented: new with non-constant class type") + } + _ = tmp63 + tmp64 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) + var tmp65 any + { // let + // let binding "or__0__auto__" + tmp66 := lang.Apply(v16, []any{v57}) + var v67 any = tmp66 + _ = v67 + var tmp68 any + if lang.IsTruthy(v67) { + tmp68 = v67 + } else { + tmp68 = v57 + } + tmp65 = tmp68 + } // end let + tmp66, _ := lang.FieldOrMethod(tmp64, "Refer") + if reflect.TypeOf(tmp66).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Refer is not a function"))) + } + tmp67 := lang.Apply(tmp66, []any{tmp65, v62}) + tmp60 = tmp67 + } // end let + tmp58 = tmp60 + } + _ = tmp58 + tmp62 := checkDerefVar(glojure_DOT_core_next) + tmp63 := lang.Apply(tmp62, []any{v49}) + var tmp61 any = tmp63 + var tmp64 any = nil + var tmp65 any = int64(0) + var tmp66 any = int64(0) + v35 = tmp61 + v36 = tmp64 + v37 = tmp65 + v38 = tmp66 + continue + } // end let + tmp50 = tmp54 + } + tmp48 = tmp50 + } // end let + tmp47 = tmp48 + } else { + } + tmp43 = tmp47 + } // end let + tmp39 = tmp43 + } + tmp32 = tmp39 + break + } + } // end let + tmp5 = tmp32 + } // end let + return tmp5 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // refer-glojure + { + tmp0 := lang.NewSymbol("refer-glojure").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("filters"))), lang.NewKeyword("doc"), "Same as (refer 'glojure.core )", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5800), lang.NewKeyword("end-line"), int(5800))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := checkDerefVar(glojure_DOT_core_seq) + tmp7 := checkDerefVar(glojure_DOT_core_concat) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("glojure.core/refer")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := checkDerefVar(glojure_DOT_core_seq) + tmp12 := checkDerefVar(glojure_DOT_core_concat) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("quote")}) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("glojure.core")}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp7, []any{tmp9, tmp19, v5}) + tmp21 := lang.Apply(tmp6, []any{tmp20}) + return tmp21 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // release-pending-sends + { + tmp0 := lang.NewSymbol("release-pending-sends").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Normally, actions sent directly or indirectly during another action\n are held until the action completes (changes the agent's\n state). This function can be used to dispatch any pending sent\n actions immediately. This has no impact on actions sent during a\n transaction, which are still held until commit. If no action is\n occurring, does nothing. Returns the number of actions dispatched.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2131), lang.NewKeyword("end-line"), int(2131))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + tmp3 := lang.Apply(nil, nil) + return tmp3 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // rem + { + var tmp1 lang.FnFunc + { // function rem__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_seq) + tmp6 := checkDerefVar(glojure_DOT_core_concat) + tmp7 := checkDerefVar(glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{lang.NewSymbol(".")}) + tmp9 := checkDerefVar(glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := checkDerefVar(glojure_DOT_core_seq) + tmp13 := checkDerefVar(glojure_DOT_core_concat) + tmp14 := checkDerefVar(glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("glojure.core/Remainder")}) + tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("rem").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"), lang.NewSymbol("div"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "remainder of dividing numerator by denominator.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1274), lang.NewKeyword("end-line"), int(1274))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Remainder") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Remainder is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // remove + { + tmp0 := lang.NewSymbol("remove").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred")), lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the items in coll for which\n (pred item) returns logical false. pred must be free of side-effects.\n Returns a transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2818), lang.NewKeyword("end-line"), int(2818))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_filter) + tmp5 := checkDerefVar(glojure_DOT_core_complement) + tmp6 := lang.Apply(tmp5, []any{v3}) + tmp7 := lang.Apply(tmp4, []any{tmp6}) + return tmp7 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_filter) + tmp6 := checkDerefVar(glojure_DOT_core_complement) + tmp7 := lang.Apply(tmp6, []any{v3}) + tmp8 := lang.Apply(tmp5, []any{tmp7, v4}) + return tmp8 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // remove-all-methods + { + tmp0 := lang.NewSymbol("remove-all-methods").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"))), lang.NewKeyword("doc"), "Removes all of the methods of multimethod.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1787), lang.NewKeyword("end-line"), int(1787))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4, ok := lang.FieldOrMethod(v3, "reset") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "reset"))) + } + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { + case reflect.Func: + tmp5 = lang.Apply(tmp4, nil) + default: + tmp5 = tmp4 + } + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // remove-method + { + tmp0 := lang.NewSymbol("remove-method").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"), lang.NewSymbol("dispatch-val"))), lang.NewKeyword("doc"), "Removes the method of multimethod associated with dispatch-value.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1794), lang.NewKeyword("end-line"), int(1794))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(v3, "removeMethod") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("removeMethod is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // remove-ns + { + tmp0 := lang.NewSymbol("remove-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Removes the namespace named by the symbol. Use with caution.\n Cannot be used to remove the glojure namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4139), lang.NewKeyword("end-line"), int(4139))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.RemoveNamespace, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // remove-tap + { + tmp0 := lang.NewSymbol("remove-tap").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Remove f from the tap set.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7883), lang.NewKeyword("end-line"), int(7883))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_swap_BANG_) + tmp5 := checkDerefVar(glojure_DOT_core_tapset) + tmp6 := checkDerefVar(glojure_DOT_core_disj) + tmp7 := lang.Apply(tmp4, []any{tmp5, tmp6, v3}) + _ = tmp7 + return nil + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // remove-watch + { + tmp0 := lang.NewSymbol("remove-watch").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("reference"), lang.NewSymbol("key"))), lang.NewKeyword("doc"), "Removes a watch (set by add-watch) from a reference", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2160), lang.NewKeyword("end-line"), int(2160))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(v3, "removeWatch") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("removeWatch is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // repeat + { + tmp0 := lang.NewSymbol("repeat").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns a lazy (infinite!, or length n if supplied) sequence of xs.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2997), lang.NewKeyword("end-line"), int(2997))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.NewRepeat, []any{v3}) + return tmp4 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(lang.NewRepeatN, []any{v3, v4}) + return tmp5 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // repeatedly + { + tmp0 := lang.NewSymbol("repeatedly").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Takes a function of no args, presumably with side effects, and\n returns an infinite (or length n if supplied) lazy sequence of calls\n to it", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5167), lang.NewKeyword("end-line"), int(5167))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + tmp5 := checkDerefVar(glojure_DOT_core_cons) + tmp6 := lang.Apply(v3, nil) + tmp7 := checkDerefVar(glojure_DOT_core_repeatedly) + tmp8 := lang.Apply(tmp7, []any{v3}) + tmp9 := lang.Apply(tmp5, []any{tmp6, tmp8}) + return tmp9 + }) + tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) + return tmp5 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_take) + tmp6 := checkDerefVar(glojure_DOT_core_repeatedly) + tmp7 := lang.Apply(tmp6, []any{v4}) + tmp8 := lang.Apply(tmp5, []any{v3, tmp7}) + return tmp8 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // replace + { + tmp0 := lang.NewSymbol("replace").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("smap")), lang.NewVector(lang.NewSymbol("smap"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Given a map of replacement pairs and a vector/collection, returns a\n vector/seq with any elements = a key in smap replaced with the\n corresponding val in smap. Returns a transducer when no collection\n is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5082), lang.NewKeyword("end-line"), int(5082))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_map) + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v6 := args[0] + _ = v6 + var tmp7 any + { // let + // let binding "temp__0__auto__" + tmp8 := checkDerefVar(glojure_DOT_core_find) + tmp9 := lang.Apply(tmp8, []any{v3, v6}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + if lang.IsTruthy(v10) { + var tmp12 any + { // let + // let binding "e" + var v13 any = v10 + _ = v13 + tmp14 := checkDerefVar(glojure_DOT_core_val) + tmp15 := lang.Apply(tmp14, []any{v13}) + tmp12 = tmp15 + } // end let + tmp11 = tmp12 + } else { + tmp11 = v6 + } + tmp7 = tmp11 + } // end let + return tmp7 + }) + tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5090), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5090), lang.NewKeyword("end-column"), int(47)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp8 := lang.Apply(tmp4, []any{tmp7}) + return tmp8 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp7 := lang.Apply(tmp6, []any{v4}) + if lang.IsTruthy(tmp7) { + tmp8 := checkDerefVar(glojure_DOT_core_reduce1) + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + var tmp12 any + { // let + // let binding "temp__0__auto__" + tmp13 := checkDerefVar(glojure_DOT_core_find) + tmp14 := checkDerefVar(glojure_DOT_core_nth) + tmp15 := lang.Apply(tmp14, []any{v10, v11}) + tmp16 := lang.Apply(tmp13, []any{v3, tmp15}) + var v17 any = tmp16 + _ = v17 + var tmp18 any + if lang.IsTruthy(v17) { + var tmp19 any + { // let + // let binding "e" + var v20 any = v17 + _ = v20 + tmp21 := checkDerefVar(glojure_DOT_core_assoc) + tmp22 := checkDerefVar(glojure_DOT_core_val) + tmp23 := lang.Apply(tmp22, []any{v20}) + tmp24 := lang.Apply(tmp21, []any{v10, v11, tmp23}) + tmp19 = tmp24 + } // end let + tmp18 = tmp19 + } else { + tmp18 = v10 + } + tmp12 = tmp18 + } // end let + return tmp12 + }) + tmp10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5093), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(5096), lang.NewKeyword("end-column"), int(23)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp12 := checkDerefVar(glojure_DOT_core_range) + tmp13 := checkDerefVar(glojure_DOT_core_count) + tmp14 := lang.Apply(tmp13, []any{v4}) + tmp15 := lang.Apply(tmp12, []any{tmp14}) + tmp16 := lang.Apply(tmp8, []any{tmp11, v4, tmp15}) + tmp5 = tmp16 + } else { + tmp17 := checkDerefVar(glojure_DOT_core_map) + var tmp18 lang.FnFunc + tmp18 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v19 := args[0] + _ = v19 + var tmp20 any + { // let + // let binding "temp__0__auto__" + tmp21 := checkDerefVar(glojure_DOT_core_find) + tmp22 := lang.Apply(tmp21, []any{v3, v19}) + var v23 any = tmp22 + _ = v23 + var tmp24 any + if lang.IsTruthy(v23) { + var tmp25 any + { // let + // let binding "e" + var v26 any = v23 + _ = v26 + tmp27 := checkDerefVar(glojure_DOT_core_val) + tmp28 := lang.Apply(tmp27, []any{v26}) + tmp25 = tmp28 + } // end let + tmp24 = tmp25 + } else { + tmp24 = v19 + } + tmp20 = tmp24 + } // end let + return tmp20 + }) + tmp19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5098), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(5098), lang.NewKeyword("end-column"), int(49)) + tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp21 := lang.Apply(tmp17, []any{tmp20, v4}) + tmp5 = tmp21 + } + return tmp5 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // replicate + { + tmp0 := lang.NewSymbol("replicate").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "DEPRECATED: Use 'repeat' instead.\n Returns a lazy seq of n xs.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("deprecated"), "1.3", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3004), lang.NewKeyword("end-line"), int(3004))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_take) + tmp6 := checkDerefVar(glojure_DOT_core_repeat) + tmp7 := lang.Apply(tmp6, []any{v4}) + tmp8 := lang.Apply(tmp5, []any{v3, tmp7}) + return tmp8 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // require + { + tmp0 := lang.NewSymbol("require").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Loads libs, skipping any that are already loaded. Each argument is\n either a libspec that identifies a lib, a prefix list that identifies\n multiple libs whose names share a common prefix, or a flag that modifies\n how all the identified libs are loaded. Use :require in the ns macro\n in preference to calling this directly.\n\n Libs\n\n A 'lib' is a named set of resources in classpath whose contents define a\n library of Clojure code. Lib names are symbols and each lib is associated\n with a Clojure namespace and a Java package that share its name. A lib's\n name also locates its root directory within classpath using Java's\n package name to classpath-relative path mapping. All resources in a lib\n should be contained in the directory structure under its root directory.\n All definitions a lib makes should be in its associated namespace.\n\n 'require loads a lib by loading its root resource. The root resource path\n is derived from the lib name in the following manner:\n Consider a lib named by the symbol 'x.y.z; it has the root directory\n /x/y/, and its root resource is /x/y/z.clj, or\n /x/y/z.cljc if /x/y/z.clj does not exist. The\n root resource should contain code to create the lib's\n namespace (usually by using the ns macro) and load any additional\n lib resources.\n\n Libspecs\n\n A libspec is a lib name or a vector containing a lib name followed by\n options expressed as sequential keywords and arguments.\n\n Recognized options:\n :as takes a symbol as its argument and makes that symbol an alias to the\n lib's namespace in the current namespace.\n :as-alias takes a symbol as its argument and aliases like :as, however\n the lib will not be loaded. If the lib has not been loaded, a new\n empty namespace will be created (as with create-ns).\n :refer takes a list of symbols to refer from the namespace or the :all\n keyword to bring in all public vars.\n\n Prefix Lists\n\n It's common for Clojure code to depend on several libs whose names have\n the same prefix. When specifying libs, prefix lists can be used to reduce\n repetition. A prefix list contains the shared prefix followed by libspecs\n with the shared prefix removed from the lib names. After removing the\n prefix, the names that remain must not contain any periods.\n\n Flags\n\n A flag is a keyword.\n Recognized flags: :reload, :reload-all, :verbose\n :reload forces loading of all the identified libs even if they are\n already loaded (has no effect on libspecs using :as-alias)\n :reload-all implies :reload and also forces loading of all libs that the\n identified libs directly or indirectly load via require or use\n (has no effect on libspecs using :as-alias)\n :verbose triggers printing information about each load, alias, and refer\n\n Example:\n\n The following would load the libraries glojure.zip and glojure.set\n abbreviated as 's'.\n\n (require '(glojure zip [set :as s]))", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5989), lang.NewKeyword("end-line"), int(5989))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_apply) + tmp5 := checkDerefVar(glojure_DOT_core_load_libs) + tmp6 := lang.Apply(tmp4, []any{tmp5, lang.NewKeyword("require"), v3}) + return tmp6 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // requiring-resolve + { + tmp0 := lang.NewSymbol("requiring-resolve").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Resolves namespace-qualified sym per 'resolve'. If initial resolve\nfails, attempts to require sym's namespace and retries.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6068), lang.NewKeyword("end-line"), int(6068))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(glojure_DOT_core_qualified_symbol_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + var tmp7 any + { // let + // let binding "or__0__auto__" + tmp8 := checkDerefVar(glojure_DOT_core_resolve) + tmp9 := lang.Apply(tmp8, []any{v3}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + if lang.IsTruthy(v10) { + tmp11 = v10 + } else { + tmp12 := checkDerefVar(glojure_DOT_core_serialized_require) + tmp13 := checkDerefVar(glojure_DOT_core_symbol) + tmp14 := checkDerefVar(glojure_DOT_core_namespace) + tmp15 := lang.Apply(tmp14, []any{v3}) + tmp16 := lang.Apply(tmp13, []any{tmp15}) + tmp17 := lang.Apply(tmp12, []any{tmp16}) + _ = tmp17 + tmp18 := checkDerefVar(glojure_DOT_core_resolve) + tmp19 := lang.Apply(tmp18, []any{v3}) + tmp11 = tmp19 + } + tmp7 = tmp11 + } // end let + tmp4 = tmp7 + } else { + tmp8 := checkDerefVar(glojure_DOT_core_str) + tmp9 := lang.Apply(tmp8, []any{"Not a qualified symbol: ", v3}) + tmp10 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp9}) + panic(tmp10) + } + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reset! + { + tmp0 := lang.NewSymbol("reset!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atom"), lang.NewSymbol("newval"))), lang.NewKeyword("doc"), "Sets the value of atom to newval without regard for the\n current value. Returns newval.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2368), lang.NewKeyword("end-line"), int(2368))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(v3, "reset") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reset-meta! + { + tmp0 := lang.NewSymbol("reset-meta!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("iref"), lang.NewSymbol("metadata-map"))), lang.NewKeyword("doc"), "Atomically resets the metadata for a namespace/var/ref/agent/atom", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2408), lang.NewKeyword("end-line"), int(2408))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(v3, "ResetMeta") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ResetMeta is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reset-vals! + { + tmp0 := lang.NewSymbol("reset-vals!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atom"), lang.NewSymbol("newval"))), lang.NewKeyword("doc"), "Sets the value of atom to newval. Returns [old new], the value of the\n atom before and after the reset.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2375), lang.NewKeyword("end-line"), int(2375))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(v3, "resetVals") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("resetVals is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // resolve + { + tmp0 := lang.NewSymbol("resolve").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym")), lang.NewVector(lang.NewSymbol("env"), lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "same as (ns-resolve *ns* symbol) or (ns-resolve *ns* &env symbol)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4371), lang.NewKeyword("end-line"), int(4371))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_ns_resolve) + tmp5 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) + tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) + return tmp6 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_ns_resolve) + tmp6 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) + tmp7 := lang.Apply(tmp5, []any{tmp6, v3, v4}) + return tmp7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // rest + { + tmp1 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() + tmp0 := lang.NewSymbol("rest").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a possibly empty seq of the items after the first. Calls seq on its\n argument.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(64), lang.NewKeyword("end-line"), int(70))).(*lang.Symbol) + var tmp3 lang.FnFunc + { // function rest + var v4 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + tmp6 := lang.Apply(lang.Rest, []any{v5}) + return tmp6 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(70), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(70), lang.NewKeyword("end-column"), int(77))).(lang.FnFunc) + v4 = tmp3 + _ = v4 + } + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // restart-agent + { + tmp0 := lang.NewSymbol("restart-agent").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("new-state"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "When an agent is failed, changes the agent state to new-state and\n then un-fails the agent so that sends are allowed again. If\n a :clear-actions true option is given, any actions queued on the\n agent that were being held while it was failed will be discarded,\n otherwise those held actions will proceed. The new-state must pass\n the validator if any, or restart will throw an exception and the\n agent will remain failed with its old state and error. Watchers, if\n any, will NOT be notified of the new state. Throws an exception if\n the agent is not failed.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2175), lang.NewKeyword("end-line"), int(2175))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + var tmp6 any + { // let + // let binding "opts" + tmp7 := checkDerefVar(glojure_DOT_core_apply) + tmp8 := checkDerefVar(glojure_DOT_core_hash_map) + tmp9 := lang.Apply(tmp7, []any{tmp8, v5}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + tmp12 := lang.Apply(lang.NewKeyword("clear-actions"), []any{v10}) + if lang.IsTruthy(tmp12) { + tmp11 = true + } else { + tmp11 = false + } + tmp13, _ := lang.FieldOrMethod(v3, "restart") + if reflect.TypeOf(tmp13).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("restart is not a function"))) + } + tmp14 := lang.Apply(tmp13, []any{v4, tmp11}) + tmp6 = tmp14 + } // end let + return tmp6 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // resultset-seq + { + tmp0 := lang.NewSymbol("resultset-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rs"))), lang.NewKeyword("doc"), "Creates and returns a lazy sequence of structmaps corresponding to\n the rows in the java.sql.ResultSet rs", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5681), lang.NewKeyword("end-line"), int(5681))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + { // let + // let binding "rsmeta" + tmp5, _ := lang.FieldOrMethod(v3, "getMetaData") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getMetaData is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{}) + var v7 any = tmp6 + _ = v7 + // let binding "idxs" + tmp8 := checkDerefVar(glojure_DOT_core_range) + tmp9 := checkDerefVar(glojure_DOT_core_inc) + tmp10, _ := lang.FieldOrMethod(v7, "getColumnCount") + if reflect.TypeOf(tmp10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getColumnCount is not a function"))) + } + tmp11 := lang.Apply(tmp10, []any{}) + tmp12 := lang.Apply(tmp9, []any{tmp11}) + tmp13 := lang.Apply(tmp8, []any{int64(1), tmp12}) + var v14 any = tmp13 + _ = v14 + // let binding "keys" + tmp15 := checkDerefVar(glojure_DOT_core_map) + tmp16 := checkDerefVar(glojure_DOT_core_comp) + tmp17 := checkDerefVar(glojure_DOT_core_keyword) + var tmp18 lang.FnFunc + tmp18 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v19 := args[0] + _ = v19 + tmp20, ok := lang.FieldOrMethod(v19, "toLowerCase") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v19, "toLowerCase"))) + } + var tmp21 any + switch reflect.TypeOf(tmp20).Kind() { + case reflect.Func: + tmp21 = lang.Apply(tmp20, nil) + default: + tmp21 = tmp20 + } + return tmp21 + }) + tmp19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5688), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(5688), lang.NewKeyword("end-column"), int(62)) + tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp21 := lang.Apply(tmp16, []any{tmp17, tmp20}) + tmp22 := checkDerefVar(glojure_DOT_core_map) + var tmp23 lang.FnFunc + tmp23 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v24 := args[0] + _ = v24 + tmp25, _ := lang.FieldOrMethod(v7, "getColumnLabel") + if reflect.TypeOf(tmp25).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getColumnLabel is not a function"))) + } + tmp26 := lang.Apply(tmp25, []any{v24}) + return tmp26 + }) + tmp24 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5689), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(5689), lang.NewKeyword("end-column"), int(63)) + tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp26 := lang.Apply(tmp22, []any{tmp25, v14}) + tmp27 := lang.Apply(tmp15, []any{tmp21, tmp26}) + var v28 any = tmp27 + _ = v28 + // let binding "check-keys" + var tmp29 any + { // let + // let binding "or__0__auto__" + tmp30 := checkDerefVar(glojure_DOT_core_apply) + tmp31 := checkDerefVar(glojure_DOT_core_distinct_QMARK_) + tmp32 := lang.Apply(tmp30, []any{tmp31, v28}) + var v33 any = tmp32 + _ = v33 + var tmp34 any + if lang.IsTruthy(v33) { + tmp34 = v33 + } else { + tmp35 := lang.Apply(lang.NewError, []any{"ResultSet must have unique column labels"}) + panic(tmp35) + } + tmp29 = tmp34 + } // end let + var v30 any = tmp29 + _ = v30 + // let binding "row-struct" + tmp31 := checkDerefVar(glojure_DOT_core_apply) + tmp32 := checkDerefVar(glojure_DOT_core_create_struct) + tmp33 := lang.Apply(tmp31, []any{tmp32, v28}) + var v34 any = tmp33 + _ = v34 + // let binding "row-values" + var tmp35 lang.FnFunc + tmp35 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + tmp36 := checkDerefVar(glojure_DOT_core_map) + var tmp37 lang.FnFunc + tmp37 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v38 := args[0] + _ = v38 + tmp39, _ := lang.FieldOrMethod(v3, "getObject") + if reflect.TypeOf(tmp39).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getObject is not a function"))) + } + tmp40 := lang.Apply(tmp39, []any{v38}) + return tmp40 + }) + tmp38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5694), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(5694), lang.NewKeyword("end-column"), int(71)) + tmp39, err := lang.WithMeta(tmp37, tmp38.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp40 := lang.Apply(tmp36, []any{tmp39, v14}) + return tmp40 + }) + tmp36 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5694), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(5694), lang.NewKeyword("end-column"), int(78)) + tmp37, err := lang.WithMeta(tmp35, tmp36.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v38 any = tmp37 + _ = v38 + // let binding "rows" + var tmp39 lang.FnFunc + { // function thisfn + var v40 lang.FnFunc + tmp39 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var tmp41 any + tmp42, _ := lang.FieldOrMethod(v3, "next") + if reflect.TypeOf(tmp42).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("next is not a function"))) + } + tmp43 := lang.Apply(tmp42, []any{}) + if lang.IsTruthy(tmp43) { + tmp44 := checkDerefVar(glojure_DOT_core_cons) + tmp45 := checkDerefVar(glojure_DOT_core_apply) + tmp46 := checkDerefVar(glojure_DOT_core_struct) + tmp47 := lang.Apply(v38, nil) + tmp48 := lang.Apply(tmp45, []any{tmp46, v34, tmp47}) + var tmp49 lang.FnFunc + tmp49 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + tmp50 := lang.Apply(v40, nil) + return tmp50 + }) + tmp50 := lang.Apply(lang.NewLazySeq, []any{tmp49}) + tmp51 := lang.Apply(tmp44, []any{tmp48, tmp50}) + tmp41 = tmp51 + } else { + } + return tmp41 + }) + v40 = tmp39 + _ = v40 + } + tmp40 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5695), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(5697), lang.NewKeyword("end-column"), int(86)) + tmp41, err := lang.WithMeta(tmp39, tmp40.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v42 any = tmp41 + _ = v42 + tmp43 := lang.Apply(v42, nil) + tmp4 = tmp43 + } // end let + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reverse + { + tmp0 := lang.NewSymbol("reverse").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a seq of the items in coll in reverse order. Not lazy.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(940), lang.NewKeyword("end-line"), int(940))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_reduce1) + tmp5 := checkDerefVar(glojure_DOT_core_conj) + tmp6 := lang.Apply(tmp4, []any{tmp5, lang.NewList(), v3}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reversible? + { + tmp0 := lang.NewSymbol("reversible?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements Reversible", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6257), lang.NewKeyword("end-line"), int(6257))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp5 := lang.Apply(tmp4, []any{nil, v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // root-directory + { + tmp0 := lang.NewSymbol("root-directory").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"))), lang.NewKeyword("doc"), "Returns the root resource path for a lib", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5871), lang.NewKeyword("end-line"), int(5871), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + { // let + // let binding "d" + tmp5 := checkDerefVar(glojure_DOT_core_root_resource) + tmp6 := lang.Apply(tmp5, []any{v3}) + var v7 any = tmp6 + _ = v7 + tmp8 := checkDerefVar(glojure_DOT_core_subs) + tmp9 := lang.Apply(strings11.LastIndex, []any{v7, "/"}) + tmp10 := lang.Apply(tmp8, []any{v7, int64(0), tmp9}) + tmp4 = tmp10 + } // end let + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // root-resource + { + tmp1 := reflect.TypeOf("") + tmp0 := lang.NewSymbol("root-resource").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"))), lang.NewKeyword("doc"), "Returns the root directory path for a lib", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5864), lang.NewKeyword("end-line"), int(5864), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_str) + tmp6 := checkDerefVar(glojure_DOT_core_name) + tmp7 := lang.Apply(tmp6, []any{v4}) + tmp8 := lang.Apply(strings11.ReplaceAll, []any{tmp7, "-", "_"}) + tmp9 := lang.Apply(strings11.ReplaceAll, []any{tmp8, ".", "/"}) + tmp10 := lang.Apply(tmp5, []any{lang.NewChar(47), tmp9}) + return tmp10 + }) + tmp4 := reflect.TypeOf("") + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // rseq + { + tmp0 := lang.NewSymbol("rseq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rev"))), lang.NewKeyword("doc"), "Returns, in constant time, a seq of the items in rev (which\n can be a vector or sorted-map), in reverse order. If rev is empty returns nil", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1577), lang.NewKeyword("end-line"), int(1577))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v3, "rseq") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("rseq is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // rsubseq + { + tmp0 := lang.NewSymbol("rsubseq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sc"), lang.NewSymbol("test"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("sc"), lang.NewSymbol("start-test"), lang.NewSymbol("start-key"), lang.NewSymbol("end-test"), lang.NewSymbol("end-key"))), lang.NewKeyword("doc"), "sc must be a sorted collection, test(s) one of <, <=, > or\n >=. Returns a reverse seq of those entries with keys ek for\n which (test (.. sc comparator (compare ek key)) 0) is true", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5150), lang.NewKeyword("end-line"), int(5150))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var tmp6 any + { // let + // let binding "include" + tmp7 := checkDerefVar(glojure_DOT_core_mk_bound_fn) + tmp8 := lang.Apply(tmp7, []any{v3, v4, v5}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + tmp11 := checkDerefVar(glojure_DOT_core__LT_) + tmp12 := checkDerefVar(glojure_DOT_core__LT__EQ_) + tmp13 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{tmp11, tmp12})) + tmp14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5158), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5158), lang.NewKeyword("end-column"), int(17)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp16 := lang.Apply(tmp15, []any{v4}) + if lang.IsTruthy(tmp16) { + var tmp17 any + { // let + // let binding "temp__0__auto__" + tmp18, _ := lang.FieldOrMethod(v3, "seqFrom") + if reflect.TypeOf(tmp18).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("seqFrom is not a function"))) + } + tmp19 := lang.Apply(tmp18, []any{v5, false}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + var tmp22 any + { // let + // let binding "vec__74" + var v23 any = v20 + _ = v23 + // let binding "e" + tmp24 := checkDerefVar(glojure_DOT_core_nth) + tmp25 := lang.Apply(tmp24, []any{v23, int64(0), nil}) + var v26 any = tmp25 + _ = v26 + // let binding "s" + var v27 any = v23 + _ = v27 + var tmp28 any + tmp29 := lang.Apply(v9, []any{v26}) + if lang.IsTruthy(tmp29) { + tmp28 = v27 + } else { + tmp30 := checkDerefVar(glojure_DOT_core_next) + tmp31 := lang.Apply(tmp30, []any{v27}) + tmp28 = tmp31 + } + tmp22 = tmp28 + } // end let + tmp21 = tmp22 + } else { + } + tmp17 = tmp21 + } // end let + tmp10 = tmp17 + } else { + tmp18 := checkDerefVar(glojure_DOT_core_take_while) + tmp19, _ := lang.FieldOrMethod(v3, "seq") + if reflect.TypeOf(tmp19).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("seq is not a function"))) + } + tmp20 := lang.Apply(tmp19, []any{false}) + tmp21 := lang.Apply(tmp18, []any{v9, tmp20}) + tmp10 = tmp21 + } + tmp6 = tmp10 + } // end let + return tmp6 + case 5: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := args[4] + _ = v7 + var tmp8 any + { // let + // let binding "temp__0__auto__" + tmp9, _ := lang.FieldOrMethod(v3, "seqFrom") + if reflect.TypeOf(tmp9).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("seqFrom is not a function"))) + } + tmp10 := lang.Apply(tmp9, []any{v7, false}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + var tmp13 any + { // let + // let binding "vec__77" + var v14 any = v11 + _ = v14 + // let binding "e" + tmp15 := checkDerefVar(glojure_DOT_core_nth) + tmp16 := lang.Apply(tmp15, []any{v14, int64(0), nil}) + var v17 any = tmp16 + _ = v17 + // let binding "s" + var v18 any = v14 + _ = v18 + tmp19 := checkDerefVar(glojure_DOT_core_take_while) + tmp20 := checkDerefVar(glojure_DOT_core_mk_bound_fn) + tmp21 := lang.Apply(tmp20, []any{v3, v4, v5}) + var tmp22 any + tmp23 := checkDerefVar(glojure_DOT_core_mk_bound_fn) + tmp24 := lang.Apply(tmp23, []any{v3, v6, v7}) + tmp25 := lang.Apply(tmp24, []any{v17}) + if lang.IsTruthy(tmp25) { + tmp22 = v18 + } else { + tmp26 := checkDerefVar(glojure_DOT_core_next) + tmp27 := lang.Apply(tmp26, []any{v18}) + tmp22 = tmp27 + } + tmp28 := lang.Apply(tmp19, []any{tmp21, tmp22}) + tmp13 = tmp28 + } // end let + tmp12 = tmp13 + } else { + } + tmp8 = tmp12 + } // end let + return tmp8 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // run! + { + tmp0 := lang.NewSymbol("run!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("proc"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Runs the supplied procedure (via reduce), for purposes of side\n effects, on successive items in the collection. Returns nil", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7708), lang.NewKeyword("end-line"), int(7708))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_reduce) + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + tmp9 := lang.Apply(v3, []any{v8}) + return tmp9 + }) + tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7713), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(7713), lang.NewKeyword("end-column"), int(20)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp9 := lang.Apply(tmp5, []any{tmp8, nil, v4}) + _ = tmp9 + return nil + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // second + { + tmp0 := lang.NewSymbol("second").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Same as (first (next x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(91), lang.NewKeyword("end-line"), int(95))).(*lang.Symbol) + var tmp2 lang.FnFunc + { // function second + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_first) + tmp6 := checkDerefVar(glojure_DOT_core_next) + tmp7 := lang.Apply(tmp6, []any{v4}) + tmp8 := lang.Apply(tmp5, []any{tmp7}) + return tmp8 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(95), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(95), lang.NewKeyword("end-column"), int(49))).(lang.FnFunc) + v3 = tmp2 + _ = v3 + } + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // select-keys + { + tmp0 := lang.NewSymbol("select-keys").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("keyseq"))), lang.NewKeyword("doc"), "Returns a map containing only those entries in map whose key is in keys", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1536), lang.NewKeyword("end-line"), int(1536))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 any + { // let + // let binding "ret" + tmp6 := lang.NewMap() + tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1541), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(1541), lang.NewKeyword("end-column"), int(17)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v9 any = tmp8 + _ = v9 + // let binding "keys" + tmp10 := checkDerefVar(glojure_DOT_core_seq) + tmp11 := lang.Apply(tmp10, []any{v4}) + var v12 any = tmp11 + _ = v12 + for { + var tmp13 any + if lang.IsTruthy(v12) { + var tmp14 any + { // let + // let binding "entry" + tmp15 := checkDerefVar(glojure_DOT_core_first) + tmp16 := lang.Apply(tmp15, []any{v12}) + tmp17, _ := lang.FieldOrMethod(runtime7.RT, "Find") + if reflect.TypeOf(tmp17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Find is not a function"))) + } + tmp18 := lang.Apply(tmp17, []any{v3, tmp16}) + var v19 any = tmp18 + _ = v19 + var tmp21 any + if lang.IsTruthy(v19) { + tmp22 := checkDerefVar(glojure_DOT_core_conj) + tmp23 := lang.Apply(tmp22, []any{v9, v19}) + tmp21 = tmp23 + } else { + tmp21 = v9 + } + var tmp20 any = tmp21 + tmp25 := checkDerefVar(glojure_DOT_core_next) + tmp26 := lang.Apply(tmp25, []any{v12}) + var tmp24 any = tmp26 + v9 = tmp20 + v12 = tmp24 + continue + } // end let + tmp13 = tmp14 + } else { + tmp15 := checkDerefVar(glojure_DOT_core_with_meta) + tmp16 := checkDerefVar(glojure_DOT_core_meta) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := lang.Apply(tmp15, []any{v9, tmp17}) + tmp13 = tmp18 + } + tmp5 = tmp13 + break + } + } // end let + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // send + { + tmp0 := lang.NewSymbol("send").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Dispatch an action to an agent. Returns the agent immediately.\n Subsequently, in a thread from a thread pool, the state of the agent\n will be set to the value of:\n\n (apply action-fn state-of-agent args)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2109), lang.NewKeyword("end-line"), int(2109))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := checkDerefVar(glojure_DOT_core_apply) + tmp7 := checkDerefVar(glojure_DOT_core_send_via) + tmp8 := lang.Apply(tmp6, []any{tmp7, nil, v3, v4, v5}) + return tmp8 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // send-off + { + tmp0 := lang.NewSymbol("send-off").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Dispatch a potentially blocking action to an agent. Returns the\n agent immediately. Subsequently, in a separate thread, the state of\n the agent will be set to the value of:\n\n (apply action-fn state-of-agent args)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2120), lang.NewKeyword("end-line"), int(2120))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := checkDerefVar(glojure_DOT_core_apply) + tmp7 := checkDerefVar(glojure_DOT_core_send_via) + tmp8 := lang.Apply(tmp6, []any{tmp7, nil, v3, v4, v5}) + return tmp8 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // send-via + { + tmp0 := lang.NewSymbol("send-via").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("executor"), lang.NewSymbol("a"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Dispatch an action to an agent. Returns the agent immediately.\n Subsequently, in a thread supplied by executor, the state of the agent\n will be set to the value of:\n\n (apply action-fn state-of-agent args)", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2099), lang.NewKeyword("end-line"), int(2099))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any + { // let + tmp8 := checkDerefVar(glojure_DOT_core_push_thread_bindings) + tmp9 := checkDerefVar(glojure_DOT_core_hash_map) + tmp10 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*agent*")) + tmp11 := lang.Apply(tmp9, []any{tmp10, v4}) + tmp12 := lang.Apply(tmp8, []any{tmp11}) + _ = tmp12 + var tmp13 any + func() { + defer func() { + tmp14 := checkDerefVar(glojure_DOT_core_pop_thread_bindings) + tmp15 := lang.Apply(tmp14, nil) + _ = tmp15 + }() + tmp16 := checkDerefVar(glojure_DOT_core_binding_conveyor_fn) + tmp17 := lang.Apply(tmp16, []any{v5}) + tmp13 = tmp17 + }() + tmp7 = tmp13 + } // end let + tmp8, _ := lang.FieldOrMethod(v4, "dispatch") + if reflect.TypeOf(tmp8).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("dispatch is not a function"))) + } + tmp9 := lang.Apply(tmp8, []any{tmp7, v6, v3}) + return tmp9 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // seq + { + tmp1 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() + tmp0 := lang.NewSymbol("seq").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a seq on the collection. If the collection is\n empty, returns nil. (seq nil) returns nil. seq also works on\n Strings, native Java arrays (of reference types) and any objects\n that implement Iterable. Note that seqs cache values, thus seq\n should not be used on any Iterable whose iterator repeatedly\n returns the same mutable object.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(4), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(126), lang.NewKeyword("end-line"), int(136))).(*lang.Symbol) + var tmp3 lang.FnFunc + { // function seq + var v4 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + tmp6 := lang.Apply(lang.Seq, []any{v5}) + return tmp6 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(136), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(136), lang.NewKeyword("end-column"), int(126))).(lang.FnFunc) + v4 = tmp3 + _ = v4 + } + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // seq-to-map-for-destructuring + { + tmp0 := lang.NewSymbol("seq-to-map-for-destructuring").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Builds a map from a seq as described in\n https://glojure.org/reference/special_forms#keyword-arguments", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(34), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4390), lang.NewKeyword("end-line"), int(4390))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(glojure_DOT_core_next) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + tmp7 := checkDerefVar(glojure_DOT_core_to_array) + tmp8 := lang.Apply(tmp7, []any{v3}) + tmp9 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{tmp8}) + tmp4 = tmp9 + } else { + var tmp10 any + tmp11 := checkDerefVar(glojure_DOT_core_seq) + tmp12 := lang.Apply(tmp11, []any{v3}) + if lang.IsTruthy(tmp12) { + tmp13 := checkDerefVar(glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v3}) + tmp10 = tmp14 + } else { + } + tmp4 = tmp10 + } + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // seq? + { + tmp0 := lang.NewSymbol("seq?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x implements ISeq", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(146), lang.NewKeyword("end-line"), int(150))).(*lang.Symbol) + var tmp2 lang.FnFunc + { // function seq? + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp6 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() + tmp7 := lang.Apply(tmp5, []any{tmp6, v4}) + return tmp7 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(150), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(150), lang.NewKeyword("end-column"), int(87))).(lang.FnFunc) + v3 = tmp2 + _ = v3 + } + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // seqable? + { + tmp0 := lang.NewSymbol("seqable?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if the seq function is supported for x", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6204), lang.NewKeyword("end-line"), int(6204))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(nil, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // seque + { + tmp0 := lang.NewSymbol("seque").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s")), lang.NewVector(lang.NewSymbol("n-or-q"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Creates a queued seq on another (presumably lazy) seq s. The queued\n seq will produce a concrete seq in the background, and can get up to\n n items ahead of the consumer. n-or-q can be an integer n buffer\n size, or an instance of java.util.concurrent BlockingQueue. Note\n that reading from a seque can block if the reader gets ahead of the\n producer.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5419), lang.NewKeyword("end-line"), int(5419))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seque) + tmp5 := lang.Apply(tmp4, []any{int64(100), v3}) + return tmp5 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 any + { // let + // let binding "q" + var tmp6 any + tmp7 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp8 := lang.Apply(tmp7, []any{nil, v3}) + if lang.IsTruthy(tmp8) { + tmp6 = v3 + } else { + tmp9 := checkDerefVar(glojure_DOT_core_int) + tmp10 := lang.Apply(tmp9, []any{v3}) + tmp11 := lang.Apply(nil, []any{tmp10}) + tmp6 = tmp11 + } + var v12 any = tmp6 + _ = v12 + // let binding "NIL" + tmp13 := lang.Apply(reflect.StructOf, []any{nil}) + tmp14 := lang.Apply(reflect.New, []any{tmp13}) + tmp15, ok := lang.FieldOrMethod(tmp14, "Interface") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp14, "Interface"))) + } + var tmp16 any + switch reflect.TypeOf(tmp15).Kind() { + case reflect.Func: + tmp16 = lang.Apply(tmp15, nil) + default: + tmp16 = tmp15 + } + var v17 any = tmp16 + _ = v17 + // let binding "agt" + tmp18 := checkDerefVar(glojure_DOT_core_agent) + var tmp19 lang.FnFunc + tmp19 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + return v4 + }) + tmp20 := lang.Apply(lang.NewLazySeq, []any{tmp19}) + tmp21 := lang.Apply(tmp18, []any{tmp20}) + var v22 any = tmp21 + _ = v22 + // let binding "log-error" + var tmp23 lang.FnFunc + tmp23 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v24 := args[0] + _ = v24 + v25 := args[1] + _ = v25 + var tmp26 any + tmp27, _ := lang.FieldOrMethod(v24, "offer") + if reflect.TypeOf(tmp27).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("offer is not a function"))) + } + tmp28 := lang.Apply(tmp27, []any{v24}) + if lang.IsTruthy(tmp28) { + panic(v25) + } else { + tmp26 = v25 + } + return tmp26 + }) + tmp24 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5435), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(5438), lang.NewKeyword("end-column"), int(26)) + tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v26 any = tmp25 + _ = v26 + // let binding "fill" + var tmp27 lang.FnFunc + tmp27 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v28 := args[0] + _ = v28 + var tmp29 any + if lang.IsTruthy(v28) { + var tmp30 any + tmp31 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp32 := lang.Apply(tmp31, []any{nil, v28}) + if lang.IsTruthy(tmp32) { + tmp33 := lang.Apply(v26, []any{v12, v28}) + tmp30 = tmp33 + } else { + var tmp34 any + func() { + defer func() { + if r := recover(); r != nil { + if lang.CatchMatches(r, lang.Builtins["any"]) { + v35 := r + _ = v35 + tmp36 := lang.Apply(v26, []any{v12, v35}) + tmp34 = tmp36 + } else { + panic(r) + } + } + }() + var tmp35 any + { // let + // let binding "G__89" + tmp36 := checkDerefVar(glojure_DOT_core_seq) + tmp37 := lang.Apply(tmp36, []any{v28}) + var v38 any = tmp37 + _ = v38 + // let binding "vec__90" + var v39 any = v38 + _ = v39 + // let binding "seq__91" + tmp40 := checkDerefVar(glojure_DOT_core_seq) + tmp41 := lang.Apply(tmp40, []any{v39}) + var v42 any = tmp41 + _ = v42 + // let binding "first__92" + tmp43 := checkDerefVar(glojure_DOT_core_first) + tmp44 := lang.Apply(tmp43, []any{v42}) + var v45 any = tmp44 + _ = v45 + // let binding "seq__91" + tmp46 := checkDerefVar(glojure_DOT_core_next) + tmp47 := lang.Apply(tmp46, []any{v42}) + var v48 any = tmp47 + _ = v48 + // let binding "x" + var v49 any = v45 + _ = v49 + // let binding "xs" + var v50 any = v48 + _ = v50 + // let binding "s" + var v51 any = v39 + _ = v51 + var tmp52 any + { // let + // let binding "G__89" + var v53 any = v38 + _ = v53 + for { + var tmp54 any + { // let + // let binding "vec__93" + var v55 any = v53 + _ = v55 + // let binding "seq__94" + tmp56 := checkDerefVar(glojure_DOT_core_seq) + tmp57 := lang.Apply(tmp56, []any{v55}) + var v58 any = tmp57 + _ = v58 + // let binding "first__95" + tmp59 := checkDerefVar(glojure_DOT_core_first) + tmp60 := lang.Apply(tmp59, []any{v58}) + var v61 any = tmp60 + _ = v61 + // let binding "seq__94" + tmp62 := checkDerefVar(glojure_DOT_core_next) + tmp63 := lang.Apply(tmp62, []any{v58}) + var v64 any = tmp63 + _ = v64 + // let binding "x" + var v65 any = v61 + _ = v65 + // let binding "xs" + var v66 any = v64 + _ = v66 + // let binding "s" + var v67 any = v55 + _ = v67 + var tmp68 any + if lang.IsTruthy(v67) { + var tmp69 any + var tmp70 any + tmp71 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp72 := lang.Apply(tmp71, []any{v65}) + if lang.IsTruthy(tmp72) { + tmp70 = v17 + } else { + tmp70 = v65 + } + tmp73, _ := lang.FieldOrMethod(v12, "offer") + if reflect.TypeOf(tmp73).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("offer is not a function"))) + } + tmp74 := lang.Apply(tmp73, []any{tmp70}) + if lang.IsTruthy(tmp74) { + var tmp75 any = v66 + v53 = tmp75 + continue + } else { + tmp69 = v67 + } + tmp68 = tmp69 + } else { + var tmp76 any + tmp77, _ := lang.FieldOrMethod(v12, "offer") + if reflect.TypeOf(tmp77).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("offer is not a function"))) + } + tmp78 := lang.Apply(tmp77, []any{v12}) + if lang.IsTruthy(tmp78) { + } else { + tmp76 = lang.NewList() + } + tmp68 = tmp76 + } + tmp54 = tmp68 + } // end let + tmp52 = tmp54 + break + } + } // end let + tmp35 = tmp52 + } // end let + tmp34 = tmp35 + }() + tmp30 = tmp34 + } + tmp29 = tmp30 + } else { + } + return tmp29 + }) + tmp28 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5439), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(5452), lang.NewKeyword("end-column"), int(44)) + tmp29, err := lang.WithMeta(tmp27, tmp28.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v30 any = tmp29 + _ = v30 + // let binding "drain" + var tmp31 lang.FnFunc + { // function drain + var v32 lang.FnFunc + tmp31 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var tmp33 lang.FnFunc + tmp33 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var tmp34 any + { // let + // let binding "x" + tmp35, ok := lang.FieldOrMethod(v12, "take") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v12, "take"))) + } + var tmp36 any + switch reflect.TypeOf(tmp35).Kind() { + case reflect.Func: + tmp36 = lang.Apply(tmp35, nil) + default: + tmp36 = tmp35 + } + var v37 any = tmp36 + _ = v37 + var tmp38 any + tmp39 := checkDerefVar(glojure_DOT_core_identical_QMARK_) + tmp40 := lang.Apply(tmp39, []any{v37, v12}) + if lang.IsTruthy(tmp40) { + tmp41 := checkDerefVar(glojure_DOT_core_deref) + tmp42 := lang.Apply(tmp41, []any{v22}) + _ = tmp42 + } else { + tmp43 := checkDerefVar(glojure_DOT_core_send_off) + tmp44 := lang.Apply(tmp43, []any{v22, v30}) + _ = tmp44 + tmp45 := checkDerefVar(glojure_DOT_core_release_pending_sends) + tmp46 := lang.Apply(tmp45, nil) + _ = tmp46 + tmp47 := checkDerefVar(glojure_DOT_core_cons) + var tmp48 any + tmp49 := checkDerefVar(glojure_DOT_core_identical_QMARK_) + tmp50 := lang.Apply(tmp49, []any{v37, v17}) + if lang.IsTruthy(tmp50) { + } else { + tmp48 = v37 + } + tmp51 := lang.Apply(v32, nil) + tmp52 := lang.Apply(tmp47, []any{tmp48, tmp51}) + tmp38 = tmp52 + } + tmp34 = tmp38 + } // end let + return tmp34 + }) + tmp34 := lang.Apply(lang.NewLazySeq, []any{tmp33}) + return tmp34 + }) + v32 = tmp31 + _ = v32 + } + tmp32 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5453), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(5461), lang.NewKeyword("end-column"), int(73)) + tmp33, err := lang.WithMeta(tmp31, tmp32.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v34 any = tmp33 + _ = v34 + tmp35 := checkDerefVar(glojure_DOT_core_send_off) + tmp36 := lang.Apply(tmp35, []any{v22, v30}) + _ = tmp36 + tmp37 := lang.Apply(v34, nil) + tmp5 = tmp37 + } // end let + return tmp5 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // sequence + { + tmp0 := lang.NewSymbol("sequence").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("coll"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Coerces coll to a (possibly empty) sequence, if it is not already\n one. Will not force a lazy seq. (sequence nil) yields (), When a\n transducer is supplied, returns a lazy sequence of applications of\n the transform to the items in coll(s), i.e. to the set of first\n items of each coll, followed by the set of second\n items in each coll, until any one of the colls is exhausted. Any\n remaining items in other colls are ignored. The transform should accept\n number-of-colls arguments", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2639), lang.NewKeyword("end-line"), int(2639))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(glojure_DOT_core_seq_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + tmp4 = v3 + } else { + var tmp7 any + { // let + // let binding "or__0__auto__" + tmp8 := checkDerefVar(glojure_DOT_core_seq) + tmp9 := lang.Apply(tmp8, []any{v3}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + if lang.IsTruthy(v10) { + tmp11 = v10 + } else { + tmp11 = lang.NewList() + } + tmp7 = tmp11 + } // end let + tmp4 = tmp7 + } + return tmp4 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 any + { // let + // let binding "or__0__auto__" + tmp6 := lang.Apply(nil, []any{v4}) + tmp7 := lang.Apply(nil, []any{v3, tmp6}) + tmp8 := lang.Apply(nil, []any{tmp7}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + tmp10 = v9 + } else { + tmp10 = lang.NewList() + } + tmp5 = tmp10 + } // end let + return tmp5 + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + var tmp6 any + { // let + // let binding "or__0__auto__" + tmp7 := checkDerefVar(glojure_DOT_core_map) + var tmp8 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v9 := args[0] + _ = v9 + tmp10 := lang.Apply(nil, []any{v9}) + return tmp10 + }) + tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2661), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(2661), lang.NewKeyword("end-column"), int(41)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp11 := checkDerefVar(glojure_DOT_core_cons) + tmp12 := lang.Apply(tmp11, []any{v4, v5}) + tmp13 := lang.Apply(tmp7, []any{tmp10, tmp12}) + tmp14 := lang.Apply(nil, []any{v3, tmp13}) + tmp15 := lang.Apply(nil, []any{tmp14}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + if lang.IsTruthy(v16) { + tmp17 = v16 + } else { + tmp17 = lang.NewList() + } + tmp6 = tmp17 + } // end let + return tmp6 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // sequential? + { + tmp0 := lang.NewSymbol("sequential?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements Sequential", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6229), lang.NewKeyword("end-line"), int(6229))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp5 := reflect.TypeOf((*lang.Sequential)(nil)).Elem() + tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // serialized-require + { + tmp0 := lang.NewSymbol("serialized-require").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Like 'require', but serializes loading.\n Interim function preferred over 'require' for known asynchronous loads.\n Future changes may make these equivalent.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6059), lang.NewKeyword("end-line"), int(6059), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v3 any = lang.NewList(args[0:]...) + _ = v3 + var tmp4 any + { // let + // let binding "lockee__0__auto__" + var v5 any = nil + _ = v5 + var tmp6 any + func() { + var tmp7 any + { // let + // let binding "locklocal__1__auto__" + var v8 any = v5 + _ = v8 + tmp9 := lang.Apply(nil, []any{v8}) + _ = tmp9 + var tmp10 any + func() { + defer func() { + tmp11 := lang.Apply(nil, []any{v8}) + _ = tmp11 + }() + tmp12 := checkDerefVar(glojure_DOT_core_apply) + tmp13 := checkDerefVar(glojure_DOT_core_require) + tmp14 := lang.Apply(tmp12, []any{tmp13, v3}) + tmp10 = tmp14 + }() + tmp7 = tmp10 + } // end let + tmp6 = tmp7 + }() + tmp4 = tmp6 + } // end let + return tmp4 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // set + { + tmp0 := lang.NewSymbol("set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a set of the distinct elements of coll.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4104), lang.NewKeyword("end-line"), int(4104))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(glojure_DOT_core_set_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + tmp7 := checkDerefVar(glojure_DOT_core_with_meta) + tmp8 := lang.Apply(tmp7, []any{v3, nil}) + tmp4 = tmp8 + } else { + var tmp9 any + tmp10 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp11 := reflect.TypeOf((*lang.IReduceInit)(nil)).Elem() + tmp12 := lang.Apply(tmp10, []any{tmp11, v3}) + if lang.IsTruthy(tmp12) { + tmp13 := checkDerefVar(glojure_DOT_core_persistent_BANG_) + tmp14 := checkDerefVar(glojure_DOT_core_conj_BANG_) + tmp15 := checkDerefVar(glojure_DOT_core_transient) + tmp16 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4112), lang.NewKeyword("column"), int(108), lang.NewKeyword("end-line"), int(4112), lang.NewKeyword("end-column"), int(110)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp19 := lang.Apply(tmp15, []any{tmp18}) + tmp20, _ := lang.FieldOrMethod(v3, "ReduceInit") + if reflect.TypeOf(tmp20).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) + } + tmp21 := lang.Apply(tmp20, []any{tmp14, tmp19}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp9 = tmp22 + } else { + tmp23 := checkDerefVar(glojure_DOT_core_persistent_BANG_) + tmp24 := checkDerefVar(glojure_DOT_core_reduce1) + tmp25 := checkDerefVar(glojure_DOT_core_conj_BANG_) + tmp26 := checkDerefVar(glojure_DOT_core_transient) + tmp27 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp28 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4113), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(4113), lang.NewKeyword("end-column"), int(48)) + tmp29, err := lang.WithMeta(tmp27, tmp28.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp30 := lang.Apply(tmp26, []any{tmp29}) + tmp31 := lang.Apply(tmp24, []any{tmp25, tmp30, v3}) + tmp32 := lang.Apply(tmp23, []any{tmp31}) + tmp9 = tmp32 + } + tmp4 = tmp9 + } + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // set-agent-send-executor! + { + tmp0 := lang.NewSymbol("set-agent-send-executor!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("executor"))), lang.NewKeyword("doc"), "Sets the ExecutorService to be used by send", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(30), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2087), lang.NewKeyword("end-line"), int(2087))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + return nil + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // set-agent-send-off-executor! + { + tmp0 := lang.NewSymbol("set-agent-send-off-executor!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("executor"))), lang.NewKeyword("doc"), "Sets the ExecutorService to be used by send-off", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(34), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2093), lang.NewKeyword("end-line"), int(2093))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + return nil + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // set-error-handler! + { + tmp0 := lang.NewSymbol("set-error-handler!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("handler-fn"))), lang.NewKeyword("doc"), "Sets the error-handler of agent a to handler-fn. If an action\n being run by the agent throws an exception or doesn't pass the\n validator fn, handler-fn will be called with two arguments: the\n agent and the exception.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2192), lang.NewKeyword("end-line"), int(2192))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(v3, "setErrorHandler") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorHandler is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // set-error-mode! + { + tmp0 := lang.NewSymbol("set-error-mode!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("mode-keyword"))), lang.NewKeyword("doc"), "Sets the error-mode of agent a to mode-keyword, which must be\n either :fail or :continue. If an action being run by the agent\n throws an exception or doesn't pass the validator fn, an\n error-handler may be called (see set-error-handler!), after which,\n if the mode is :continue, the agent will continue as if neither the\n action that caused the error nor the error itself ever happened.\n \n If the mode is :fail, the agent will become failed and will stop\n accepting new 'send' and 'send-off' actions, and any previously\n queued actions will be held until a 'restart-agent'. Deref will\n still work, returning the state of the agent before the error.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2210), lang.NewKeyword("end-line"), int(2210))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(v3, "setErrorMode") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorMode is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // set-validator! + { + tmp0 := lang.NewSymbol("set-validator!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("iref"), lang.NewSymbol("validator-fn"))), lang.NewKeyword("doc"), "Sets the validator-fn for a var/ref/agent/atom. validator-fn must be nil or a\n side-effect-free fn of one argument, which will be passed the intended\n new state on any state change. If the new state is unacceptable, the\n validator-fn should return false or throw an exception. If the current state (root\n value if var) is not acceptable to the new validator, an exception\n will be thrown and the validator will not be changed.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2381), lang.NewKeyword("end-line"), int(2381))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(v3, "setValidator") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setValidator is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // set? + { + tmp0 := lang.NewSymbol("set?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements IPersistentSet", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4098), lang.NewKeyword("end-line"), int(4098))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp5 := reflect.TypeOf((*lang.IPersistentSet)(nil)).Elem() + tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // setup-reference + { + tmp0 := lang.NewSymbol("setup-reference").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2043), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(2044), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("r"), lang.NewSymbol("options"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 any + { // let + // let binding "opts" + tmp6 := checkDerefVar(glojure_DOT_core_apply) + tmp7 := checkDerefVar(glojure_DOT_core_hash_map) + tmp8 := lang.Apply(tmp6, []any{tmp7, v4}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + tmp11 := lang.Apply(lang.NewKeyword("meta"), []any{v9}) + if lang.IsTruthy(tmp11) { + tmp12 := lang.Apply(lang.NewKeyword("meta"), []any{v9}) + tmp13, _ := lang.FieldOrMethod(v3, "ResetMeta") + if reflect.TypeOf(tmp13).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ResetMeta is not a function"))) + } + tmp14 := lang.Apply(tmp13, []any{tmp12}) + tmp10 = tmp14 + } else { + } + _ = tmp10 + var tmp15 any + tmp16 := lang.Apply(lang.NewKeyword("validator"), []any{v9}) + if lang.IsTruthy(tmp16) { + tmp17 := lang.Apply(lang.NewKeyword("validator"), []any{v9}) + tmp18, _ := lang.FieldOrMethod(v3, "setValidator") + if reflect.TypeOf(tmp18).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setValidator is not a function"))) + } + tmp19 := lang.Apply(tmp18, []any{tmp17}) + tmp15 = tmp19 + } else { + } + _ = tmp15 + tmp5 = v3 + } // end let + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // shift-mask + { + tmp0 := lang.NewSymbol("shift-mask").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6598), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(6598), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("shift"), lang.NewSymbol("mask"), lang.NewSymbol("x"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6 := checkDerefVar(glojure_DOT_core_bit_and) + tmp7 := checkDerefVar(glojure_DOT_core_bit_shift_right) + tmp8 := lang.Apply(tmp7, []any{v5, v3}) + tmp9 := lang.Apply(tmp6, []any{tmp8, v4}) + return tmp9 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // short + { + var tmp1 lang.FnFunc + { // function short__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := checkDerefVar(glojure_DOT_core_seq) + tmp12 := checkDerefVar(glojure_DOT_core_concat) + tmp13 := checkDerefVar(glojure_DOT_core_list) + var tmp14 any + tmp15 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + if lang.IsTruthy(tmp15) { + tmp14 = lang.NewSymbol("uncheckedShortCast") + } else { + tmp14 = lang.NewSymbol("shortCast") + } + tmp16 := lang.Apply(tmp13, []any{tmp14}) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := lang.Apply(tmp12, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp11, []any{tmp19}) + tmp21 := lang.Apply(tmp10, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("short").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to short", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3499), lang.NewKeyword("end-line"), int(3499))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5 := lang.Apply(lang.ShortCast, []any{v4}) + return tmp5 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // short-array + { + var tmp1 lang.FnFunc + { // function short-array__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol("glojure.core/ShortArray")}) + tmp12 := checkDerefVar(glojure_DOT_core_list) + tmp13 := checkDerefVar(glojure_DOT_core_seq) + tmp14 := checkDerefVar(glojure_DOT_core_concat) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("glojure.core/args")}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + } + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("short-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Creates an array of shorts", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5333), lang.NewKeyword("end-line"), int(5333))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "ShortArray") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ShortArray is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "ShortArrayInit") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ShortArrayInit is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // shorts + { + var tmp1 lang.FnFunc + { // function shorts + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol("glojure.core/Shorts")}) + tmp12 := checkDerefVar(glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("shorts").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Casts to shorts[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5387), lang.NewKeyword("end-line"), int(5387))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Shorts") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Shorts is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // shuffle + { + tmp0 := lang.NewSymbol("shuffle").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return a random permutation of coll", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7300), lang.NewKeyword("end-line"), int(7300))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + { // let + // let binding "al" + tmp5 := checkDerefVar(glojure_DOT_core_to_array) + tmp6 := lang.Apply(tmp5, []any{v3}) + tmp7 := lang.Apply(lang.NewArrayList, []any{tmp6}) + var v8 any = tmp7 + _ = v8 + tmp9 := lang.Apply(nil, []any{v8}) + _ = tmp9 + tmp10, ok := lang.FieldOrMethod(v8, "toArray") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "toArray"))) + } + var tmp11 any + switch reflect.TypeOf(tmp10).Kind() { + case reflect.Func: + tmp11 = lang.Apply(tmp10, nil) + default: + tmp11 = tmp10 + } + tmp12 := lang.Apply(nil, []any{tmp11}) + tmp4 = tmp12 + } // end let + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // shutdown-agents + { + tmp0 := lang.NewSymbol("shutdown-agents").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Initiates a shutdown of the thread pools that back the agent\n system. Running actions will complete, but no new actions will be\n accepted", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2252), lang.NewKeyword("end-line"), int(2252))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + tmp3 := lang.Apply(lang.ShutdownAgents, nil) + return tmp3 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // sigs + { + tmp0 := lang.NewSymbol("sigs").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(223), lang.NewKeyword("column"), int(2), lang.NewKeyword("end-line"), int(224), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_assert_valid_fdecl) + tmp5 := lang.Apply(tmp4, []any{v3}) + _ = tmp5 + var tmp6 any + { // let + // let binding "asig" + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v8 := args[0] + _ = v8 + var tmp9 any + { // let + // let binding "arglist" + tmp10 := checkDerefVar(glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v8}) + var v12 any = tmp11 + _ = v12 + // let binding "arglist" + var tmp13 any + tmp14 := checkDerefVar(glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v12}) + tmp16 := lang.Apply(lang.Equals, []any{lang.NewSymbol("&form"), tmp15}) + if lang.IsTruthy(tmp16) { + tmp17 := lang.Apply(lang.Count, []any{v12}) + tmp18 := lang.Apply(lang.Subvec, []any{v12, int64(2), tmp17}) + tmp13 = tmp18 + } else { + tmp13 = v12 + } + var v19 any = tmp13 + _ = v19 + // let binding "body" + tmp20 := checkDerefVar(glojure_DOT_core_next) + tmp21 := lang.Apply(tmp20, []any{v8}) + var v22 any = tmp21 + _ = v22 + var tmp23 any + tmp24 := checkDerefVar(glojure_DOT_core_map_QMARK_) + tmp25 := checkDerefVar(glojure_DOT_core_first) + tmp26 := lang.Apply(tmp25, []any{v22}) + tmp27 := lang.Apply(tmp24, []any{tmp26}) + if lang.IsTruthy(tmp27) { + var tmp28 any + tmp29 := checkDerefVar(glojure_DOT_core_next) + tmp30 := lang.Apply(tmp29, []any{v22}) + if lang.IsTruthy(tmp30) { + tmp31 := checkDerefVar(glojure_DOT_core_with_meta) + tmp32 := checkDerefVar(glojure_DOT_core_conj) + var tmp33 any + tmp34 := checkDerefVar(glojure_DOT_core_meta) + tmp35 := lang.Apply(tmp34, []any{v19}) + if lang.IsTruthy(tmp35) { + tmp36 := checkDerefVar(glojure_DOT_core_meta) + tmp37 := lang.Apply(tmp36, []any{v19}) + tmp33 = tmp37 + } else { + tmp38 := lang.NewMap() + tmp39 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(237), lang.NewKeyword("column"), int(77), lang.NewKeyword("end-line"), int(237), lang.NewKeyword("end-column"), int(78)) + tmp40, err := lang.WithMeta(tmp38, tmp39.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp33 = tmp40 + } + tmp41 := checkDerefVar(glojure_DOT_core_first) + tmp42 := lang.Apply(tmp41, []any{v22}) + tmp43 := lang.Apply(tmp32, []any{tmp33, tmp42}) + tmp44 := lang.Apply(tmp31, []any{v19, tmp43}) + tmp28 = tmp44 + } else { + tmp28 = v19 + } + tmp23 = tmp28 + } else { + tmp23 = v19 + } + tmp9 = tmp23 + } // end let + return tmp9 + }) + tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(228), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(239), lang.NewKeyword("end-column"), int(25)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v10 any = tmp9 + _ = v10 + // let binding "resolve-tag" + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v12 := args[0] + _ = v12 + var tmp13 any + { // let + // let binding "m" + tmp14 := checkDerefVar(glojure_DOT_core_meta) + tmp15 := lang.Apply(tmp14, []any{v12}) + var v16 any = tmp15 + _ = v16 + // let binding "tag" + tmp17 := lang.Apply(lang.NewKeyword("tag"), []any{v16}) + var v18 any = tmp17 + _ = v18 + var tmp19 any + tmp20 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp21 := reflect.TypeOf((*lang.Symbol)(nil)) + tmp22 := lang.Apply(tmp20, []any{tmp21, v18}) + if lang.IsTruthy(tmp22) { + var tmp23 any + tmp24, ok := lang.FieldOrMethod(v18, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v18, "Name"))) + } + var tmp25 any + switch reflect.TypeOf(tmp24).Kind() { + case reflect.Func: + tmp25 = lang.Apply(tmp24, nil) + default: + tmp25 = tmp24 + } + tmp26 := lang.Apply(strings11.Index, []any{tmp25, "."}) + tmp27 := lang.Apply(lang.Equiv, []any{tmp26, int64(-1)}) + if lang.IsTruthy(tmp27) { + var tmp28 any + tmp29 := lang.Apply(lang.Equals, []any{nil, nil}) + if lang.IsTruthy(tmp29) { + var tmp30 any + { // let + // let binding "c" + var v31 any = nil + _ = v31 + var tmp32 any + if lang.IsTruthy(v31) { + tmp33 := checkDerefVar(glojure_DOT_core_with_meta) + tmp34 := checkDerefVar(glojure_DOT_core_assoc) + tmp35, ok := lang.FieldOrMethod(v31, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v31, "Name"))) + } + var tmp36 any + switch reflect.TypeOf(tmp35).Kind() { + case reflect.Func: + tmp36 = lang.Apply(tmp35, nil) + default: + tmp36 = tmp35 + } + tmp37 := lang.Apply(lang.NewSymbol, []any{tmp36}) + tmp38 := lang.Apply(tmp34, []any{v16, lang.NewKeyword("tag"), tmp37}) + tmp39 := lang.Apply(tmp33, []any{v12, tmp38}) + tmp32 = tmp39 + } else { + tmp32 = v12 + } + tmp30 = tmp32 + } // end let + tmp28 = tmp30 + } else { + tmp28 = v12 + } + tmp23 = tmp28 + } else { + tmp23 = v12 + } + tmp19 = tmp23 + } else { + tmp19 = v12 + } + tmp13 = tmp19 + } // end let + return tmp13 + }) + tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(240), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(252), lang.NewKeyword("end-column"), int(37)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v14 any = tmp13 + _ = v14 + var tmp15 any + tmp16 := checkDerefVar(glojure_DOT_core_seq_QMARK_) + tmp17 := checkDerefVar(glojure_DOT_core_first) + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := lang.Apply(tmp16, []any{tmp18}) + if lang.IsTruthy(tmp19) { + var tmp20 any + { // let + // let binding "ret" + tmp21 := lang.NewVector() + tmp22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(254), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(254), lang.NewKeyword("end-column"), int(20)) + tmp23, err := lang.WithMeta(tmp21, tmp22.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v24 any = tmp23 + _ = v24 + // let binding "fdecls" + var v25 any = v3 + _ = v25 + for { + var tmp26 any + if lang.IsTruthy(v25) { + tmp28 := checkDerefVar(glojure_DOT_core_conj) + tmp29 := checkDerefVar(glojure_DOT_core_first) + tmp30 := lang.Apply(tmp29, []any{v25}) + tmp31 := lang.Apply(v10, []any{tmp30}) + tmp32 := lang.Apply(v14, []any{tmp31}) + tmp33 := lang.Apply(tmp28, []any{v24, tmp32}) + var tmp27 any = tmp33 + tmp35 := checkDerefVar(glojure_DOT_core_next) + tmp36 := lang.Apply(tmp35, []any{v25}) + var tmp34 any = tmp36 + v24 = tmp27 + v25 = tmp34 + continue + } else { + tmp37 := checkDerefVar(glojure_DOT_core_seq) + tmp38 := lang.Apply(tmp37, []any{v24}) + tmp26 = tmp38 + } + tmp20 = tmp26 + break + } + } // end let + tmp15 = tmp20 + } else { + tmp21 := checkDerefVar(glojure_DOT_core_list) + tmp22 := lang.Apply(v10, []any{v3}) + tmp23 := lang.Apply(v14, []any{tmp22}) + tmp24 := lang.Apply(tmp21, []any{tmp23}) + tmp15 = tmp24 + } + tmp6 = tmp15 + } // end let + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(225), lang.NewKeyword("column"), int(2), lang.NewKeyword("end-line"), int(258), lang.NewKeyword("end-column"), int(43))).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // simple-ident? + { + tmp0 := lang.NewSymbol("simple-ident?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a symbol or keyword without a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1613), lang.NewKeyword("end-line"), int(1613))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + { // let + // let binding "and__0__auto__" + tmp5 := checkDerefVar(glojure_DOT_core_ident_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + if lang.IsTruthy(v7) { + tmp9 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp10 := checkDerefVar(glojure_DOT_core_namespace) + tmp11 := lang.Apply(tmp10, []any{v3}) + tmp12 := lang.Apply(tmp9, []any{tmp11}) + tmp8 = tmp12 + } else { + tmp8 = v7 + } + tmp4 = tmp8 + } // end let + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // simple-keyword? + { + tmp0 := lang.NewSymbol("simple-keyword?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a keyword without a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1633), lang.NewKeyword("end-line"), int(1633))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + { // let + // let binding "and__0__auto__" + tmp5 := checkDerefVar(glojure_DOT_core_keyword_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + if lang.IsTruthy(v7) { + tmp9 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp10 := checkDerefVar(glojure_DOT_core_namespace) + tmp11 := lang.Apply(tmp10, []any{v3}) + tmp12 := lang.Apply(tmp9, []any{tmp11}) + tmp8 = tmp12 + } else { + tmp8 = v7 + } + tmp4 = tmp8 + } // end let + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // simple-symbol? + { + tmp0 := lang.NewSymbol("simple-symbol?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a symbol without a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1623), lang.NewKeyword("end-line"), int(1623))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + { // let + // let binding "and__0__auto__" + tmp5 := checkDerefVar(glojure_DOT_core_symbol_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + if lang.IsTruthy(v7) { + tmp9 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp10 := checkDerefVar(glojure_DOT_core_namespace) + tmp11 := lang.Apply(tmp10, []any{v3}) + tmp12 := lang.Apply(tmp9, []any{tmp11}) + tmp8 = tmp12 + } else { + tmp8 = v7 + } + tmp4 = tmp8 + } // end let + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // slurp + { + tmp1 := reflect.TypeOf("") + tmp0 := lang.NewSymbol("slurp").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("opts"))), lang.NewKeyword("doc"), "Opens a reader on f and reads all its contents, returning a string.\n See glojure.java.io/reader for a complete list of supported arguments.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6982), lang.NewKeyword("end-line"), int(6982))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + var v5 any = lang.NewList(args[1:]...) + _ = v5 + var tmp6 any + { // let + // let binding "opts" + tmp7 := checkDerefVar(glojure_DOT_core_normalize_slurp_opts) + tmp8 := lang.Apply(tmp7, []any{v5}) + var v9 any = tmp8 + _ = v9 + // let binding "sw" + var v10 any = "unimplemented: new with non-constant class type" + _ = v10 + var tmp11 any + { // let + // let binding "r" + tmp12 := checkDerefVar(glojure_DOT_core_apply) + tmp13 := checkDerefVar(glojure_DOT_go_DOT_io_reader) + tmp14 := lang.Apply(tmp12, []any{tmp13, v4, v9}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + func() { + defer func() { + tmp17, ok := lang.FieldOrMethod(v15, "close") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v15, "close"))) + } + var tmp18 any + switch reflect.TypeOf(tmp17).Kind() { + case reflect.Func: + tmp18 = lang.Apply(tmp17, nil) + default: + tmp18 = tmp17 + } + _ = tmp18 + }() + tmp19 := checkDerefVar(glojure_DOT_go_DOT_io_copy) + tmp20 := lang.Apply(tmp19, []any{v15, v10}) + _ = tmp20 + tmp21 := lang.Apply(lang.ToString, []any{v10}) + tmp16 = tmp21 + }() + tmp11 = tmp16 + } // end let + tmp6 = tmp11 + } // end let + return tmp6 + } + }) + tmp4 := reflect.TypeOf("") + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // some + { + tmp0 := lang.NewSymbol("some").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns the first logical true value of (pred x) for any x in coll,\n else nil. One common idiom is to use a set as pred, for example\n this will return :fred if :fred is in the sequence, otherwise nil:\n (some #{:fred} coll)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2684), lang.NewKeyword("end-line"), int(2684))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + recur_loop_481: + var tmp5 any + { // let + // let binding "temp__0__auto__" + tmp6 := checkDerefVar(glojure_DOT_core_seq) + tmp7 := lang.Apply(tmp6, []any{v4}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + var tmp10 any + { // let + // let binding "s" + var v11 any = v8 + _ = v11 + var tmp12 any + { // let + // let binding "or__0__auto__" + tmp13 := checkDerefVar(glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v11}) + tmp15 := lang.Apply(v3, []any{tmp14}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + if lang.IsTruthy(v16) { + tmp17 = v16 + } else { + var tmp18 any = v3 + tmp20 := checkDerefVar(glojure_DOT_core_next) + tmp21 := lang.Apply(tmp20, []any{v11}) + var tmp19 any = tmp21 + v3 = tmp18 + v4 = tmp19 + goto recur_loop_481 + } + tmp12 = tmp17 + } // end let + tmp10 = tmp12 + } // end let + tmp9 = tmp10 + } else { + } + tmp5 = tmp9 + } // end let + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // some-> + { + tmp0 := lang.NewSymbol("some->").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "When expr is not nil, threads it into the first form (via ->),\n and when that result is not nil, through the next etc", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7610), lang.NewKeyword("end-line"), int(7610))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any + { // let + // let binding "g" + tmp8 := checkDerefVar(glojure_DOT_core_gensym) + tmp9 := lang.Apply(tmp8, nil) + var v10 any = tmp9 + _ = v10 + // let binding "steps" + tmp11 := checkDerefVar(glojure_DOT_core_map) + var tmp12 lang.FnFunc + tmp12 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v13 := args[0] + _ = v13 + tmp14 := checkDerefVar(glojure_DOT_core_seq) + tmp15 := checkDerefVar(glojure_DOT_core_concat) + tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("if")}) + tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp19 := checkDerefVar(glojure_DOT_core_seq) + tmp20 := checkDerefVar(glojure_DOT_core_concat) + tmp21 := checkDerefVar(glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("glojure.core/nil?")}) + tmp23 := checkDerefVar(glojure_DOT_core_list) + tmp24 := lang.Apply(tmp23, []any{v10}) + tmp25 := lang.Apply(tmp20, []any{tmp22, tmp24}) + tmp26 := lang.Apply(tmp19, []any{tmp25}) + tmp27 := lang.Apply(tmp18, []any{tmp26}) + tmp28 := checkDerefVar(glojure_DOT_core_list) + tmp29 := lang.Apply(tmp28, []any{nil}) + tmp30 := checkDerefVar(glojure_DOT_core_list) + tmp31 := checkDerefVar(glojure_DOT_core_seq) + tmp32 := checkDerefVar(glojure_DOT_core_concat) + tmp33 := checkDerefVar(glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{lang.NewSymbol("glojure.core/->")}) + tmp35 := checkDerefVar(glojure_DOT_core_list) + tmp36 := lang.Apply(tmp35, []any{v10}) + tmp37 := checkDerefVar(glojure_DOT_core_list) + tmp38 := lang.Apply(tmp37, []any{v13}) + tmp39 := lang.Apply(tmp32, []any{tmp34, tmp36, tmp38}) + tmp40 := lang.Apply(tmp31, []any{tmp39}) + tmp41 := lang.Apply(tmp30, []any{tmp40}) + tmp42 := lang.Apply(tmp15, []any{tmp17, tmp27, tmp29, tmp41}) + tmp43 := lang.Apply(tmp14, []any{tmp42}) + return tmp43 + }) + tmp13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7616), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7616), lang.NewKeyword("end-column"), int(64)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp15 := lang.Apply(tmp11, []any{tmp14, v6}) + var v16 any = tmp15 + _ = v16 + tmp17 := checkDerefVar(glojure_DOT_core_seq) + tmp18 := checkDerefVar(glojure_DOT_core_concat) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{lang.NewSymbol("glojure.core/let")}) + tmp21 := checkDerefVar(glojure_DOT_core_list) + tmp22 := checkDerefVar(glojure_DOT_core_apply) + tmp23 := checkDerefVar(glojure_DOT_core_vector) + tmp24 := checkDerefVar(glojure_DOT_core_seq) + tmp25 := checkDerefVar(glojure_DOT_core_concat) + tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v10}) + tmp28 := checkDerefVar(glojure_DOT_core_list) + tmp29 := lang.Apply(tmp28, []any{v5}) + tmp30 := checkDerefVar(glojure_DOT_core_interleave) + tmp31 := checkDerefVar(glojure_DOT_core_repeat) + tmp32 := lang.Apply(tmp31, []any{v10}) + tmp33 := checkDerefVar(glojure_DOT_core_butlast) + tmp34 := lang.Apply(tmp33, []any{v16}) + tmp35 := lang.Apply(tmp30, []any{tmp32, tmp34}) + tmp36 := lang.Apply(tmp25, []any{tmp27, tmp29, tmp35}) + tmp37 := lang.Apply(tmp24, []any{tmp36}) + tmp38 := lang.Apply(tmp22, []any{tmp23, tmp37}) + tmp39 := lang.Apply(tmp21, []any{tmp38}) + tmp40 := checkDerefVar(glojure_DOT_core_list) + var tmp41 any + tmp42 := checkDerefVar(glojure_DOT_core_empty_QMARK_) + tmp43 := lang.Apply(tmp42, []any{v16}) + if lang.IsTruthy(tmp43) { + tmp41 = v10 + } else { + tmp44 := checkDerefVar(glojure_DOT_core_last) + tmp45 := lang.Apply(tmp44, []any{v16}) + tmp41 = tmp45 + } + tmp46 := lang.Apply(tmp40, []any{tmp41}) + tmp47 := lang.Apply(tmp18, []any{tmp20, tmp39, tmp46}) + tmp48 := lang.Apply(tmp17, []any{tmp47}) + tmp7 = tmp48 + } // end let + return tmp7 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // some->> + { + tmp0 := lang.NewSymbol("some->>").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "When expr is not nil, threads it into the first form (via ->>),\n and when that result is not nil, through the next etc", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7624), lang.NewKeyword("end-line"), int(7624))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any + { // let + // let binding "g" + tmp8 := checkDerefVar(glojure_DOT_core_gensym) + tmp9 := lang.Apply(tmp8, nil) + var v10 any = tmp9 + _ = v10 + // let binding "steps" + tmp11 := checkDerefVar(glojure_DOT_core_map) + var tmp12 lang.FnFunc + tmp12 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v13 := args[0] + _ = v13 + tmp14 := checkDerefVar(glojure_DOT_core_seq) + tmp15 := checkDerefVar(glojure_DOT_core_concat) + tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("if")}) + tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp19 := checkDerefVar(glojure_DOT_core_seq) + tmp20 := checkDerefVar(glojure_DOT_core_concat) + tmp21 := checkDerefVar(glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("glojure.core/nil?")}) + tmp23 := checkDerefVar(glojure_DOT_core_list) + tmp24 := lang.Apply(tmp23, []any{v10}) + tmp25 := lang.Apply(tmp20, []any{tmp22, tmp24}) + tmp26 := lang.Apply(tmp19, []any{tmp25}) + tmp27 := lang.Apply(tmp18, []any{tmp26}) + tmp28 := checkDerefVar(glojure_DOT_core_list) + tmp29 := lang.Apply(tmp28, []any{nil}) + tmp30 := checkDerefVar(glojure_DOT_core_list) + tmp31 := checkDerefVar(glojure_DOT_core_seq) + tmp32 := checkDerefVar(glojure_DOT_core_concat) + tmp33 := checkDerefVar(glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{lang.NewSymbol("glojure.core/->>")}) + tmp35 := checkDerefVar(glojure_DOT_core_list) + tmp36 := lang.Apply(tmp35, []any{v10}) + tmp37 := checkDerefVar(glojure_DOT_core_list) + tmp38 := lang.Apply(tmp37, []any{v13}) + tmp39 := lang.Apply(tmp32, []any{tmp34, tmp36, tmp38}) + tmp40 := lang.Apply(tmp31, []any{tmp39}) + tmp41 := lang.Apply(tmp30, []any{tmp40}) + tmp42 := lang.Apply(tmp15, []any{tmp17, tmp27, tmp29, tmp41}) + tmp43 := lang.Apply(tmp14, []any{tmp42}) + return tmp43 + }) + tmp13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7630), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7630), lang.NewKeyword("end-column"), int(65)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp15 := lang.Apply(tmp11, []any{tmp14, v6}) + var v16 any = tmp15 + _ = v16 + tmp17 := checkDerefVar(glojure_DOT_core_seq) + tmp18 := checkDerefVar(glojure_DOT_core_concat) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{lang.NewSymbol("glojure.core/let")}) + tmp21 := checkDerefVar(glojure_DOT_core_list) + tmp22 := checkDerefVar(glojure_DOT_core_apply) + tmp23 := checkDerefVar(glojure_DOT_core_vector) + tmp24 := checkDerefVar(glojure_DOT_core_seq) + tmp25 := checkDerefVar(glojure_DOT_core_concat) + tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v10}) + tmp28 := checkDerefVar(glojure_DOT_core_list) + tmp29 := lang.Apply(tmp28, []any{v5}) + tmp30 := checkDerefVar(glojure_DOT_core_interleave) + tmp31 := checkDerefVar(glojure_DOT_core_repeat) + tmp32 := lang.Apply(tmp31, []any{v10}) + tmp33 := checkDerefVar(glojure_DOT_core_butlast) + tmp34 := lang.Apply(tmp33, []any{v16}) + tmp35 := lang.Apply(tmp30, []any{tmp32, tmp34}) + tmp36 := lang.Apply(tmp25, []any{tmp27, tmp29, tmp35}) + tmp37 := lang.Apply(tmp24, []any{tmp36}) + tmp38 := lang.Apply(tmp22, []any{tmp23, tmp37}) + tmp39 := lang.Apply(tmp21, []any{tmp38}) + tmp40 := checkDerefVar(glojure_DOT_core_list) + var tmp41 any + tmp42 := checkDerefVar(glojure_DOT_core_empty_QMARK_) + tmp43 := lang.Apply(tmp42, []any{v16}) + if lang.IsTruthy(tmp43) { + tmp41 = v10 + } else { + tmp44 := checkDerefVar(glojure_DOT_core_last) + tmp45 := lang.Apply(tmp44, []any{v16}) + tmp41 = tmp45 + } + tmp46 := lang.Apply(tmp40, []any{tmp41}) + tmp47 := lang.Apply(tmp18, []any{tmp20, tmp39, tmp46}) + tmp48 := lang.Apply(tmp17, []any{tmp47}) + tmp7 = tmp48 + } // end let + return tmp7 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // some-fn + { + tmp0 := lang.NewSymbol("some-fn").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("p")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2"), lang.NewSymbol("p3")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2"), lang.NewSymbol("p3"), lang.NewSymbol("&"), lang.NewSymbol("ps"))), lang.NewKeyword("doc"), "Takes a set of predicates and returns a function f that returns the first logical true value\n returned by one of its composing predicates against any of its arguments, else it returns\n logical false. Note that f is short-circuiting in that it will stop execution on the first\n argument that triggers a logical true result against the original predicates.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7462), lang.NewKeyword("end-line"), int(7462))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + var tmp4 lang.FnFunc + { // function sp1 + var v5 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return nil + case 1: + v6 := args[0] + _ = v6 + tmp7 := lang.Apply(v3, []any{v6}) + return tmp7 + case 2: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + var tmp8 any + { // let + // let binding "or__0__auto__" + tmp9 := lang.Apply(v3, []any{v6}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + if lang.IsTruthy(v10) { + tmp11 = v10 + } else { + tmp12 := lang.Apply(v3, []any{v7}) + tmp11 = tmp12 + } + tmp8 = tmp11 + } // end let + return tmp8 + case 3: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + var tmp9 any + { // let + // let binding "or__0__auto__" + tmp10 := lang.Apply(v3, []any{v6}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + tmp12 = v11 + } else { + var tmp13 any + { // let + // let binding "or__0__auto__" + tmp14 := lang.Apply(v3, []any{v7}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + if lang.IsTruthy(v15) { + tmp16 = v15 + } else { + tmp17 := lang.Apply(v3, []any{v8}) + tmp16 = tmp17 + } + tmp13 = tmp16 + } // end let + tmp12 = tmp13 + } + tmp9 = tmp12 + } // end let + return tmp9 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + var v9 any = lang.NewList(args[3:]...) + _ = v9 + var tmp10 any + { // let + // let binding "or__0__auto__" + tmp11 := lang.Apply(v5, []any{v6, v7, v8}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + tmp13 = v12 + } else { + tmp14 := checkDerefVar(glojure_DOT_core_some) + tmp15 := lang.Apply(tmp14, []any{v3, v9}) + tmp13 = tmp15 + } + tmp10 = tmp13 + } // end let + return tmp10 + } + }) + v5 = tmp4 + _ = v5 + } + tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7469), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7475), lang.NewKeyword("end-column"), int(43)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 lang.FnFunc + { // function sp2 + var v6 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return nil + case 1: + v7 := args[0] + _ = v7 + var tmp8 any + { // let + // let binding "or__0__auto__" + tmp9 := lang.Apply(v3, []any{v7}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + if lang.IsTruthy(v10) { + tmp11 = v10 + } else { + tmp12 := lang.Apply(v4, []any{v7}) + tmp11 = tmp12 + } + tmp8 = tmp11 + } // end let + return tmp8 + case 2: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + var tmp9 any + { // let + // let binding "or__0__auto__" + tmp10 := lang.Apply(v3, []any{v7}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + tmp12 = v11 + } else { + var tmp13 any + { // let + // let binding "or__0__auto__" + tmp14 := lang.Apply(v3, []any{v8}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + if lang.IsTruthy(v15) { + tmp16 = v15 + } else { + var tmp17 any + { // let + // let binding "or__0__auto__" + tmp18 := lang.Apply(v4, []any{v7}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + tmp20 = v19 + } else { + tmp21 := lang.Apply(v4, []any{v8}) + tmp20 = tmp21 + } + tmp17 = tmp20 + } // end let + tmp16 = tmp17 + } + tmp13 = tmp16 + } // end let + tmp12 = tmp13 + } + tmp9 = tmp12 + } // end let + return tmp9 + case 3: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + var tmp10 any + { // let + // let binding "or__0__auto__" + tmp11 := lang.Apply(v3, []any{v7}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + tmp13 = v12 + } else { + var tmp14 any + { // let + // let binding "or__0__auto__" + tmp15 := lang.Apply(v3, []any{v8}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + if lang.IsTruthy(v16) { + tmp17 = v16 + } else { + var tmp18 any + { // let + // let binding "or__0__auto__" + tmp19 := lang.Apply(v3, []any{v9}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + tmp21 = v20 + } else { + var tmp22 any + { // let + // let binding "or__0__auto__" + tmp23 := lang.Apply(v4, []any{v7}) + var v24 any = tmp23 + _ = v24 + var tmp25 any + if lang.IsTruthy(v24) { + tmp25 = v24 + } else { + var tmp26 any + { // let + // let binding "or__0__auto__" + tmp27 := lang.Apply(v4, []any{v8}) + var v28 any = tmp27 + _ = v28 + var tmp29 any + if lang.IsTruthy(v28) { + tmp29 = v28 + } else { + tmp30 := lang.Apply(v4, []any{v9}) + tmp29 = tmp30 + } + tmp26 = tmp29 + } // end let + tmp25 = tmp26 + } + tmp22 = tmp25 + } // end let + tmp21 = tmp22 + } + tmp18 = tmp21 + } // end let + tmp17 = tmp18 + } + tmp14 = tmp17 + } // end let + tmp13 = tmp14 + } + tmp10 = tmp13 + } // end let + return tmp10 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + var v10 any = lang.NewList(args[3:]...) + _ = v10 + var tmp11 any + { // let + // let binding "or__0__auto__" + tmp12 := lang.Apply(v6, []any{v7, v8, v9}) + var v13 any = tmp12 + _ = v13 + var tmp14 any + if lang.IsTruthy(v13) { + tmp14 = v13 + } else { + tmp15 := checkDerefVar(glojure_DOT_core_some) + var tmp16 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v17 := args[0] + _ = v17 + var tmp18 any + { // let + // let binding "or__0__auto__" + tmp19 := lang.Apply(v3, []any{v17}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + tmp21 = v20 + } else { + tmp22 := lang.Apply(v4, []any{v17}) + tmp21 = tmp22 + } + tmp18 = tmp21 + } // end let + return tmp18 + }) + tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7483), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(7483), lang.NewKeyword("end-column"), int(52)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp19 := lang.Apply(tmp15, []any{tmp18, v10}) + tmp14 = tmp19 + } + tmp11 = tmp14 + } // end let + return tmp11 + } + }) + v6 = tmp5 + _ = v6 + } + tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7477), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7483), lang.NewKeyword("end-column"), int(61)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp7 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var tmp6 lang.FnFunc + { // function sp3 + var v7 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return nil + case 1: + v8 := args[0] + _ = v8 + var tmp9 any + { // let + // let binding "or__0__auto__" + tmp10 := lang.Apply(v3, []any{v8}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + tmp12 = v11 + } else { + var tmp13 any + { // let + // let binding "or__0__auto__" + tmp14 := lang.Apply(v4, []any{v8}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + if lang.IsTruthy(v15) { + tmp16 = v15 + } else { + tmp17 := lang.Apply(v5, []any{v8}) + tmp16 = tmp17 + } + tmp13 = tmp16 + } // end let + tmp12 = tmp13 + } + tmp9 = tmp12 + } // end let + return tmp9 + case 2: + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + var tmp10 any + { // let + // let binding "or__0__auto__" + tmp11 := lang.Apply(v3, []any{v8}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + tmp13 = v12 + } else { + var tmp14 any + { // let + // let binding "or__0__auto__" + tmp15 := lang.Apply(v3, []any{v9}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + if lang.IsTruthy(v16) { + tmp17 = v16 + } else { + var tmp18 any + { // let + // let binding "or__0__auto__" + tmp19 := lang.Apply(v4, []any{v8}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + tmp21 = v20 + } else { + var tmp22 any + { // let + // let binding "or__0__auto__" + tmp23 := lang.Apply(v4, []any{v9}) + var v24 any = tmp23 + _ = v24 + var tmp25 any + if lang.IsTruthy(v24) { + tmp25 = v24 + } else { + var tmp26 any + { // let + // let binding "or__0__auto__" + tmp27 := lang.Apply(v5, []any{v8}) + var v28 any = tmp27 + _ = v28 + var tmp29 any + if lang.IsTruthy(v28) { + tmp29 = v28 + } else { + tmp30 := lang.Apply(v5, []any{v9}) + tmp29 = tmp30 + } + tmp26 = tmp29 + } // end let + tmp25 = tmp26 + } + tmp22 = tmp25 + } // end let + tmp21 = tmp22 + } + tmp18 = tmp21 + } // end let + tmp17 = tmp18 + } + tmp14 = tmp17 + } // end let + tmp13 = tmp14 + } + tmp10 = tmp13 + } // end let + return tmp10 + case 3: + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + v10 := args[2] + _ = v10 + var tmp11 any + { // let + // let binding "or__0__auto__" + tmp12 := lang.Apply(v3, []any{v8}) + var v13 any = tmp12 + _ = v13 + var tmp14 any + if lang.IsTruthy(v13) { + tmp14 = v13 + } else { + var tmp15 any + { // let + // let binding "or__0__auto__" + tmp16 := lang.Apply(v3, []any{v9}) + var v17 any = tmp16 + _ = v17 + var tmp18 any + if lang.IsTruthy(v17) { + tmp18 = v17 + } else { + var tmp19 any + { // let + // let binding "or__0__auto__" + tmp20 := lang.Apply(v3, []any{v10}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + if lang.IsTruthy(v21) { + tmp22 = v21 + } else { + var tmp23 any + { // let + // let binding "or__0__auto__" + tmp24 := lang.Apply(v4, []any{v8}) + var v25 any = tmp24 + _ = v25 + var tmp26 any + if lang.IsTruthy(v25) { + tmp26 = v25 + } else { + var tmp27 any + { // let + // let binding "or__0__auto__" + tmp28 := lang.Apply(v4, []any{v9}) + var v29 any = tmp28 + _ = v29 + var tmp30 any + if lang.IsTruthy(v29) { + tmp30 = v29 + } else { + var tmp31 any + { // let + // let binding "or__0__auto__" + tmp32 := lang.Apply(v4, []any{v10}) + var v33 any = tmp32 + _ = v33 + var tmp34 any + if lang.IsTruthy(v33) { + tmp34 = v33 + } else { + var tmp35 any + { // let + // let binding "or__0__auto__" + tmp36 := lang.Apply(v5, []any{v8}) + var v37 any = tmp36 + _ = v37 + var tmp38 any + if lang.IsTruthy(v37) { + tmp38 = v37 + } else { + var tmp39 any + { // let + // let binding "or__0__auto__" + tmp40 := lang.Apply(v5, []any{v9}) + var v41 any = tmp40 + _ = v41 + var tmp42 any + if lang.IsTruthy(v41) { + tmp42 = v41 + } else { + tmp43 := lang.Apply(v5, []any{v10}) + tmp42 = tmp43 + } + tmp39 = tmp42 + } // end let + tmp38 = tmp39 + } + tmp35 = tmp38 + } // end let + tmp34 = tmp35 + } + tmp31 = tmp34 + } // end let + tmp30 = tmp31 + } + tmp27 = tmp30 + } // end let + tmp26 = tmp27 + } + tmp23 = tmp26 + } // end let + tmp22 = tmp23 + } + tmp19 = tmp22 + } // end let + tmp18 = tmp19 + } + tmp15 = tmp18 + } // end let + tmp14 = tmp15 + } + tmp11 = tmp14 + } // end let + return tmp11 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + v10 := args[2] + _ = v10 + var v11 any = lang.NewList(args[3:]...) + _ = v11 + var tmp12 any + { // let + // let binding "or__0__auto__" + tmp13 := lang.Apply(v7, []any{v8, v9, v10}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + tmp15 = v14 + } else { + tmp16 := checkDerefVar(glojure_DOT_core_some) + var tmp17 lang.FnFunc + tmp17 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v18 := args[0] + _ = v18 + var tmp19 any + { // let + // let binding "or__0__auto__" + tmp20 := lang.Apply(v3, []any{v18}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + if lang.IsTruthy(v21) { + tmp22 = v21 + } else { + var tmp23 any + { // let + // let binding "or__0__auto__" + tmp24 := lang.Apply(v4, []any{v18}) + var v25 any = tmp24 + _ = v25 + var tmp26 any + if lang.IsTruthy(v25) { + tmp26 = v25 + } else { + tmp27 := lang.Apply(v5, []any{v18}) + tmp26 = tmp27 + } + tmp23 = tmp26 + } // end let + tmp22 = tmp23 + } + tmp19 = tmp22 + } // end let + return tmp19 + }) + tmp18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7491), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(7491), lang.NewKeyword("end-column"), int(59)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp20 := lang.Apply(tmp16, []any{tmp19, v11}) + tmp15 = tmp20 + } + tmp12 = tmp15 + } // end let + return tmp12 + } + }) + v7 = tmp6 + _ = v7 + } + tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7485), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7491), lang.NewKeyword("end-column"), int(68)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp8 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any + { // let + // let binding "ps" + tmp8 := checkDerefVar(glojure_DOT_core_list_STAR_) + tmp9 := lang.Apply(tmp8, []any{v3, v4, v5, v6}) + var v10 any = tmp9 + _ = v10 + var tmp11 lang.FnFunc + { // function spn + var v12 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return nil + case 1: + v13 := args[0] + _ = v13 + tmp14 := checkDerefVar(glojure_DOT_core_some) + var tmp15 lang.FnFunc + tmp15 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v16 := args[0] + _ = v16 + tmp17 := lang.Apply(v16, []any{v13}) + return tmp17 + }) + tmp16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7496), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(7496), lang.NewKeyword("end-column"), int(26)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp18 := lang.Apply(tmp14, []any{tmp17, v10}) + return tmp18 + case 2: + v13 := args[0] + _ = v13 + v14 := args[1] + _ = v14 + tmp15 := checkDerefVar(glojure_DOT_core_some) + var tmp16 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v17 := args[0] + _ = v17 + var tmp18 any + { // let + // let binding "or__0__auto__" + tmp19 := lang.Apply(v17, []any{v13}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + tmp21 = v20 + } else { + tmp22 := lang.Apply(v17, []any{v14}) + tmp21 = tmp22 + } + tmp18 = tmp21 + } // end let + return tmp18 + }) + tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7497), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(7497), lang.NewKeyword("end-column"), int(39)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp19 := lang.Apply(tmp15, []any{tmp18, v10}) + return tmp19 + case 3: + v13 := args[0] + _ = v13 + v14 := args[1] + _ = v14 + v15 := args[2] + _ = v15 + tmp16 := checkDerefVar(glojure_DOT_core_some) + var tmp17 lang.FnFunc + tmp17 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v18 := args[0] + _ = v18 + var tmp19 any + { // let + // let binding "or__0__auto__" + tmp20 := lang.Apply(v18, []any{v13}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + if lang.IsTruthy(v21) { + tmp22 = v21 + } else { + var tmp23 any + { // let + // let binding "or__0__auto__" + tmp24 := lang.Apply(v18, []any{v14}) + var v25 any = tmp24 + _ = v25 + var tmp26 any + if lang.IsTruthy(v25) { + tmp26 = v25 + } else { + tmp27 := lang.Apply(v18, []any{v15}) + tmp26 = tmp27 + } + tmp23 = tmp26 + } // end let + tmp22 = tmp23 + } + tmp19 = tmp22 + } // end let + return tmp19 + }) + tmp18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7498), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7498), lang.NewKeyword("end-column"), int(47)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp20 := lang.Apply(tmp16, []any{tmp19, v10}) + return tmp20 + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v13 := args[0] + _ = v13 + v14 := args[1] + _ = v14 + v15 := args[2] + _ = v15 + var v16 any = lang.NewList(args[3:]...) + _ = v16 + var tmp17 any + { // let + // let binding "or__0__auto__" + tmp18 := lang.Apply(v12, []any{v13, v14, v15}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + tmp20 = v19 + } else { + tmp21 := checkDerefVar(glojure_DOT_core_some) + var tmp22 lang.FnFunc + tmp22 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v23 := args[0] + _ = v23 + tmp24 := checkDerefVar(glojure_DOT_core_some) + tmp25 := lang.Apply(tmp24, []any{v23, v16}) + return tmp25 + }) + tmp23 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7500), lang.NewKeyword("column"), int(36), lang.NewKeyword("end-line"), int(7500), lang.NewKeyword("end-column"), int(49)) + tmp24, err := lang.WithMeta(tmp22, tmp23.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp25 := lang.Apply(tmp21, []any{tmp24, v10}) + tmp20 = tmp25 + } + tmp17 = tmp20 + } // end let + return tmp17 + } + }) + v12 = tmp11 + _ = v12 + } + tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7494), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7500), lang.NewKeyword("end-column"), int(56)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp7 = tmp13 + } // end let + return tmp7 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // some? + { + tmp1 := reflect.TypeOf(false) + tmp0 := lang.NewSymbol("some?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is not nil, false otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(530), lang.NewKeyword("end-line"), int(530))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_not) + tmp6 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp7 := lang.Apply(tmp6, []any{v4}) + tmp8 := lang.Apply(tmp5, []any{tmp7}) + return tmp8 + }) + tmp4 := reflect.TypeOf(false) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // sort + { + tmp0 := lang.NewSymbol("sort").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("comp"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a sorted sequence of the items in coll. If no comparator is\n supplied, uses compare. comparator must implement\n java.util.Comparator. Guaranteed to be stable: equal elements will\n not be reordered. If coll is a Java array, it will be modified. To\n avoid this, sort a copy of the array.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3085), lang.NewKeyword("end-line"), int(3085))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_sort) + tmp5 := checkDerefVar(glojure_DOT_core_compare) + tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) + return tmp6 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(glojure_DOT_core_seq) + tmp7 := lang.Apply(tmp6, []any{v4}) + if lang.IsTruthy(tmp7) { + var tmp8 any + { // let + // let binding "a" + tmp9 := checkDerefVar(glojure_DOT_core_to_array) + tmp10 := lang.Apply(tmp9, []any{v4}) + var v11 any = tmp10 + _ = v11 + tmp12 := lang.Apply(lang.SortSlice, []any{v11, v3}) + _ = tmp12 + tmp13 := checkDerefVar(glojure_DOT_core_with_meta) + tmp14 := checkDerefVar(glojure_DOT_core_seq) + tmp15 := lang.Apply(tmp14, []any{v11}) + tmp16 := checkDerefVar(glojure_DOT_core_meta) + tmp17 := lang.Apply(tmp16, []any{v4}) + tmp18 := lang.Apply(tmp13, []any{tmp15, tmp17}) + tmp8 = tmp18 + } // end let + tmp5 = tmp8 + } else { + tmp5 = lang.NewList() + } + return tmp5 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // sort-by + { + tmp0 := lang.NewSymbol("sort-by").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("keyfn"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("keyfn"), lang.NewSymbol("comp"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a sorted sequence of the items in coll, where the sort\n order is determined by comparing (keyfn item). If no comparator is\n supplied, uses compare. comparator must implement\n java.util.Comparator. Guaranteed to be stable: equal elements will\n not be reordered. If coll is a Java array, it will be modified. To\n avoid this, sort a copy of the array.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3102), lang.NewKeyword("end-line"), int(3102))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_sort_by) + tmp6 := checkDerefVar(glojure_DOT_core_compare) + tmp7 := lang.Apply(tmp5, []any{v3, tmp6, v4}) + return tmp7 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6 := checkDerefVar(glojure_DOT_core_sort) + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + tmp10 := lang.Apply(v3, []any{v8}) + tmp11 := lang.Apply(v3, []any{v9}) + tmp12 := lang.Apply(v4, []any{tmp10, tmp11}) + return tmp12 + }) + tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3114), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(3114), lang.NewKeyword("end-column"), int(46)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp10 := lang.Apply(tmp6, []any{tmp9, v5}) + return tmp10 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // sorted-map + { + tmp0 := lang.NewSymbol("sorted-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keyvals"))), lang.NewKeyword("doc"), "keyval => key val\n Returns a new sorted map with supplied mappings. If any keys are\n equal, they are handled as if by repeated uses of assoc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(397), lang.NewKeyword("end-line"), int(397))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := lang.Apply(lang.CreatePersistentTreeMap, []any{v3}) + return tmp4 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // sorted-map-by + { + tmp0 := lang.NewSymbol("sorted-map-by").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("comparator"), lang.NewSymbol("&"), lang.NewSymbol("keyvals"))), lang.NewKeyword("doc"), "keyval => key val\n Returns a new sorted map with supplied mappings, using the supplied\n comparator. If any keys are equal, they are handled as if by\n repeated uses of assoc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(406), lang.NewKeyword("end-line"), int(406))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any = lang.NewList(args[1:]...) + _ = v4 + tmp5 := lang.Apply(nil, []any{v3, v4}) + return tmp5 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // sorted-set + { + tmp0 := lang.NewSymbol("sorted-set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keys"))), lang.NewKeyword("doc"), "Returns a new sorted set with supplied keys. Any equal keys are\n handled as if by repeated uses of conj.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(416), lang.NewKeyword("end-line"), int(416))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := lang.Apply(lang.CreatePersistentTreeSet, []any{v3}) + return tmp4 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // sorted-set-by + { + tmp0 := lang.NewSymbol("sorted-set-by").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("comparator"), lang.NewSymbol("&"), lang.NewSymbol("keys"))), lang.NewKeyword("doc"), "Returns a new sorted set with supplied keys, using the supplied\n comparator. Any equal keys are handled as if by repeated uses of\n conj.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(424), lang.NewKeyword("end-line"), int(424))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any = lang.NewList(args[1:]...) + _ = v4 + tmp5 := lang.Apply(lang.CreatePersistentTreeSetWithComparator, []any{v3, v4}) + return tmp5 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // sorted? + { + tmp0 := lang.NewSymbol("sorted?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements Sorted", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6235), lang.NewKeyword("end-line"), int(6235))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp5 := lang.Apply(tmp4, []any{nil, v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // special-symbol? + { + tmp0 := lang.NewSymbol("special-symbol?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns true if s names a special form", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4992), lang.NewKeyword("end-line"), int(4992))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_contains_QMARK_) + tmp5, ok := lang.FieldOrMethod(runtime7.Compiler, "specials") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", runtime7.Compiler, "specials"))) + } + var tmp6 any + switch reflect.TypeOf(tmp5).Kind() { + case reflect.Func: + tmp6 = lang.Apply(tmp5, nil) + default: + tmp6 = tmp5 + } + tmp7 := lang.Apply(tmp4, []any{tmp6, v3}) + return tmp7 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // spit + { + tmp0 := lang.NewSymbol("spit").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("content"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Opposite of slurp. Opens f with writer, writes content, then\n closes f. Options passed to glojure.java.io/writer.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6994), lang.NewKeyword("end-line"), int(6994))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + var tmp6 any + { // let + // let binding "w" + tmp7 := checkDerefVar(glojure_DOT_core_apply) + tmp8 := lang.Apply(tmp7, []any{nil, v3, v5}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + func() { + defer func() { + tmp11, ok := lang.FieldOrMethod(v9, "close") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v9, "close"))) + } + var tmp12 any + switch reflect.TypeOf(tmp11).Kind() { + case reflect.Func: + tmp12 = lang.Apply(tmp11, nil) + default: + tmp12 = tmp11 + } + _ = tmp12 + }() + tmp13 := checkDerefVar(glojure_DOT_core_str) + tmp14 := lang.Apply(tmp13, []any{v4}) + tmp15 := lang.Apply(lang.WriteWriter, []any{v9, tmp14}) + tmp10 = tmp15 + }() + tmp6 = tmp10 + } // end let + return tmp6 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // split-at + { + tmp0 := lang.NewSymbol("split-at").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a vector of [(take n coll) (drop n coll)]", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2983), lang.NewKeyword("end-line"), int(2983))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_take) + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + tmp7 := checkDerefVar(glojure_DOT_core_drop) + tmp8 := lang.Apply(tmp7, []any{v3, v4}) + tmp9 := lang.NewVector(tmp6, tmp8) + tmp10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2988), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2988), lang.NewKeyword("end-column"), int(33)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp11 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // split-with + { + tmp0 := lang.NewSymbol("split-with").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a vector of [(take-while pred coll) (drop-while pred coll)]", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2990), lang.NewKeyword("end-line"), int(2990))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_take_while) + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + tmp7 := checkDerefVar(glojure_DOT_core_drop_while) + tmp8 := lang.Apply(tmp7, []any{v3, v4}) + tmp9 := lang.NewVector(tmp6, tmp8) + tmp10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2995), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2995), lang.NewKeyword("end-column"), int(51)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp11 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // splitv-at + { + tmp0 := lang.NewSymbol("splitv-at").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a vector of [(into [] (take n) coll) (drop n coll)]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7256), lang.NewKeyword("end-line"), int(7256))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_into) + tmp6 := lang.NewVector() + tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7260), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(7260), lang.NewKeyword("end-column"), int(11)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp9 := checkDerefVar(glojure_DOT_core_take) + tmp10 := lang.Apply(tmp9, []any{v3}) + tmp11 := lang.Apply(tmp5, []any{tmp8, tmp10, v4}) + tmp12 := checkDerefVar(glojure_DOT_core_drop) + tmp13 := lang.Apply(tmp12, []any{v3, v4}) + tmp14 := lang.NewVector(tmp11, tmp13) + tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7260), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(7260), lang.NewKeyword("end-column"), int(41)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp16 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // spread + { + tmp0 := lang.NewSymbol("spread").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("arglist"))), lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(632), lang.NewKeyword("end-line"), int(632), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + } else { + var tmp7 any + tmp8 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp9 := checkDerefVar(glojure_DOT_core_next) + tmp10 := lang.Apply(tmp9, []any{v3}) + tmp11 := lang.Apply(tmp8, []any{tmp10}) + if lang.IsTruthy(tmp11) { + tmp12 := checkDerefVar(glojure_DOT_core_seq) + tmp13 := checkDerefVar(glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v3}) + tmp15 := lang.Apply(tmp12, []any{tmp14}) + tmp7 = tmp15 + } else { + var tmp16 any + if lang.IsTruthy(lang.NewKeyword("else")) { + tmp17 := checkDerefVar(glojure_DOT_core_cons) + tmp18 := checkDerefVar(glojure_DOT_core_first) + tmp19 := lang.Apply(tmp18, []any{v3}) + tmp20 := checkDerefVar(glojure_DOT_core_spread) + tmp21 := checkDerefVar(glojure_DOT_core_next) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp20, []any{tmp22}) + tmp24 := lang.Apply(tmp17, []any{tmp19, tmp23}) + tmp16 = tmp24 + } else { + } + tmp7 = tmp16 + } + tmp4 = tmp7 + } + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // str + { + tmp1 := reflect.TypeOf("") + tmp0 := lang.NewSymbol("str").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("ys"))), lang.NewKeyword("doc"), "With no args, returns the empty string. With one arg x, returns\n x.toString(). (str nil) returns the empty string. With more than\n one arg, returns the concatenation of the str values of the args.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(543), lang.NewKeyword("end-line"), int(543))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return "" + case 1: + v4 := args[0] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp7 := lang.Apply(tmp6, []any{v4}) + if lang.IsTruthy(tmp7) { + tmp5 = "" + } else { + tmp8 := lang.Apply(lang.ToString, []any{v4}) + tmp5 = tmp8 + } + return tmp5 + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + var v5 any = lang.NewList(args[1:]...) + _ = v5 + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + recur_loop_74: + var tmp9 any + if lang.IsTruthy(v8) { + tmp11 := checkDerefVar(glojure_DOT_core_str) + tmp12 := checkDerefVar(glojure_DOT_core_first) + tmp13 := lang.Apply(tmp12, []any{v8}) + tmp14 := lang.Apply(tmp11, []any{tmp13}) + tmp15, _ := lang.FieldOrMethod(v7, "WriteString") + if reflect.TypeOf(tmp15).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("WriteString is not a function"))) + } + tmp16 := lang.Apply(tmp15, []any{tmp14}) + _ = tmp16 + var tmp10 any = v7 + tmp18 := checkDerefVar(glojure_DOT_core_next) + tmp19 := lang.Apply(tmp18, []any{v8}) + var tmp17 any = tmp19 + v7 = tmp10 + v8 = tmp17 + goto recur_loop_74 + } else { + tmp20, ok := lang.FieldOrMethod(v7, "String") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "String"))) + } + var tmp21 any + switch reflect.TypeOf(tmp20).Kind() { + case reflect.Func: + tmp21 = lang.Apply(tmp20, nil) + default: + tmp21 = tmp20 + } + tmp9 = tmp21 + } + return tmp9 + }) + tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(554), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(554), lang.NewKeyword("end-column"), int(127)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp9 := checkDerefVar(glojure_DOT_core_cons) + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + tmp11 := lang.Apply(tmp8, []any{"unimplemented: new with non-constant class type", tmp10}) + return tmp11 + } + }) + tmp4 := reflect.TypeOf("") + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // stream-into! + { + tmp0 := lang.NewSymbol("stream-into!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("stream")), lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("xform"), lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Returns a new coll consisting of coll with all of the items of the\n stream conjoined. This is a terminal operation on the stream.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6810), lang.NewKeyword("end-line"), int(6810))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp7 := reflect.TypeOf((*lang.IEditableCollection)(nil)).Elem() + tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) + if lang.IsTruthy(tmp8) { + tmp9 := checkDerefVar(glojure_DOT_core_with_meta) + tmp10 := checkDerefVar(glojure_DOT_core_persistent_BANG_) + tmp11 := checkDerefVar(glojure_DOT_core_stream_reduce_BANG_) + tmp12 := checkDerefVar(glojure_DOT_core_conj_BANG_) + tmp13 := checkDerefVar(glojure_DOT_core_transient) + tmp14 := lang.Apply(tmp13, []any{v3}) + tmp15 := lang.Apply(tmp11, []any{tmp12, tmp14, v4}) + tmp16 := lang.Apply(tmp10, []any{tmp15}) + tmp17 := checkDerefVar(glojure_DOT_core_meta) + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := lang.Apply(tmp9, []any{tmp16, tmp18}) + tmp5 = tmp19 + } else { + tmp20 := checkDerefVar(glojure_DOT_core_stream_reduce_BANG_) + tmp21 := checkDerefVar(glojure_DOT_core_conj) + tmp22 := lang.Apply(tmp20, []any{tmp21, v3, v4}) + tmp5 = tmp22 + } + return tmp5 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp8 := reflect.TypeOf((*lang.IEditableCollection)(nil)).Elem() + tmp9 := lang.Apply(tmp7, []any{tmp8, v3}) + if lang.IsTruthy(tmp9) { + tmp10 := checkDerefVar(glojure_DOT_core_with_meta) + tmp11 := checkDerefVar(glojure_DOT_core_persistent_BANG_) + tmp12 := checkDerefVar(glojure_DOT_core_stream_transduce_BANG_) + tmp13 := checkDerefVar(glojure_DOT_core_conj_BANG_) + tmp14 := checkDerefVar(glojure_DOT_core_transient) + tmp15 := lang.Apply(tmp14, []any{v3}) + tmp16 := lang.Apply(tmp12, []any{v4, tmp13, tmp15, v5}) + tmp17 := lang.Apply(tmp11, []any{tmp16}) + tmp18 := checkDerefVar(glojure_DOT_core_meta) + tmp19 := lang.Apply(tmp18, []any{v3}) + tmp20 := lang.Apply(tmp10, []any{tmp17, tmp19}) + tmp6 = tmp20 + } else { + tmp21 := checkDerefVar(glojure_DOT_core_stream_transduce_BANG_) + tmp22 := checkDerefVar(glojure_DOT_core_conj) + tmp23 := lang.Apply(tmp21, []any{v4, tmp22, v3, v5}) + tmp6 = tmp23 + } + return tmp6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // stream-reduce! + { + tmp0 := lang.NewSymbol("stream-reduce!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("s")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Works like reduce but takes a java.util.stream.BaseStream as its source.\n Honors 'reduced', is a terminal operation on the stream", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6784), lang.NewKeyword("end-line"), int(6784))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, ok := lang.FieldOrMethod(v4, "iterator") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "iterator"))) + } + var tmp6 any + switch reflect.TypeOf(tmp5).Kind() { + case reflect.Func: + tmp6 = lang.Apply(tmp5, nil) + default: + tmp6 = tmp5 + } + tmp7 := lang.Apply(nil, []any{tmp6, v3}) + return tmp7 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6, ok := lang.FieldOrMethod(v5, "iterator") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "iterator"))) + } + var tmp7 any + switch reflect.TypeOf(tmp6).Kind() { + case reflect.Func: + tmp7 = lang.Apply(tmp6, nil) + default: + tmp7 = tmp6 + } + tmp8 := lang.Apply(nil, []any{tmp7, v3, v4}) + return tmp8 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // stream-seq! + { + tmp0 := lang.NewSymbol("stream-seq!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Takes a java.util.stream.BaseStream instance s and returns a seq of its\n contents. This is a terminal operation on the stream.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6793), lang.NewKeyword("end-line"), int(6793))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_iterator_seq) + tmp5, ok := lang.FieldOrMethod(v3, "iterator") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "iterator"))) + } + var tmp6 any + switch reflect.TypeOf(tmp5).Kind() { + case reflect.Func: + tmp6 = lang.Apply(tmp5, nil) + default: + tmp6 = tmp5 + } + tmp7 := lang.Apply(tmp4, []any{tmp6}) + return tmp7 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // stream-transduce! + { + tmp0 := lang.NewSymbol("stream-transduce!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("f"), lang.NewSymbol("stream")), lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Works like transduce but takes a java.util.stream.BaseStream as its source.\n This is a terminal operation on the stream.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6800), lang.NewKeyword("end-line"), int(6800))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6 := checkDerefVar(glojure_DOT_core_stream_transduce_BANG_) + tmp7 := lang.Apply(v4, nil) + tmp8 := lang.Apply(tmp6, []any{v3, v4, tmp7, v5}) + return tmp8 + case 4: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + var tmp7 any + { // let + // let binding "f" + tmp8 := lang.Apply(v3, []any{v4}) + var v9 any = tmp8 + _ = v9 + // let binding "ret" + tmp10 := checkDerefVar(glojure_DOT_core_stream_reduce_BANG_) + tmp11 := lang.Apply(tmp10, []any{v9, v5, v6}) + var v12 any = tmp11 + _ = v12 + tmp13 := lang.Apply(v9, []any{v12}) + tmp7 = tmp13 + } // end let + return tmp7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // string? + { + tmp0 := lang.NewSymbol("string?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a String", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(160), lang.NewKeyword("end-line"), int(164))).(*lang.Symbol) + var tmp2 lang.FnFunc + { // function string? + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp6 := lang.Apply(tmp5, []any{lang.Builtins["string"], v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(164), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(164), lang.NewKeyword("end-column"), int(58))).(lang.FnFunc) + v3 = tmp2 + _ = v3 + } + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // strip-ns + { + tmp0 := lang.NewSymbol("strip-ns").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(255), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(255), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("named"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(glojure_DOT_core_symbol_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + tmp7 := checkDerefVar(glojure_DOT_core_symbol) + tmp8 := checkDerefVar(glojure_DOT_core_name) + tmp9 := lang.Apply(tmp8, []any{v3}) + tmp10 := lang.Apply(tmp7, []any{nil, tmp9}) + tmp4 = tmp10 + } else { + tmp11 := checkDerefVar(glojure_DOT_core_keyword) + tmp12 := checkDerefVar(glojure_DOT_core_name) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(tmp11, []any{nil, tmp13}) + tmp4 = tmp14 + } + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // struct + { + tmp0 := lang.NewSymbol("struct").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("&"), lang.NewSymbol("vals"))), lang.NewKeyword("doc"), "Returns a new structmap instance with the keys of the\n structure-basis. vals must be supplied for basis keys in order -\n where values are not supplied they will default to nil.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4061), lang.NewKeyword("end-line"), int(4061))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any = lang.NewList(args[1:]...) + _ = v4 + tmp5 := lang.Apply(lang.ConstructPersistentStructMap, []any{v3, v4}) + return tmp5 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // struct-map + { + tmp0 := lang.NewSymbol("struct-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("&"), lang.NewSymbol("inits"))), lang.NewKeyword("doc"), "Returns a new structmap instance with the keys of the\n structure-basis. keyvals may contain all, some or none of the basis\n keys - where values are not supplied they will default to nil.\n keyvals can also contain keys not in the basis.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4051), lang.NewKeyword("end-line"), int(4051))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any = lang.NewList(args[1:]...) + _ = v4 + tmp5 := lang.Apply(lang.CreatePersistentStructMap, []any{v3, v4}) + return tmp5 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // subs + { + tmp0 := lang.NewSymbol("subs").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("start")), lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("start"), lang.NewSymbol("end"))), lang.NewKeyword("doc"), "Returns the substring of s beginning at start inclusive, and ending\n at end (defaults to length of string), exclusive.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5005), lang.NewKeyword("end-line"), int(5005))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(lang.Builtins["slice"], []any{v3, v4}) + return tmp5 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6 := lang.Apply(lang.Builtins["slice"], []any{v3, v4, v5}) + return tmp6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // subseq + { + tmp0 := lang.NewSymbol("subseq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sc"), lang.NewSymbol("test"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("sc"), lang.NewSymbol("start-test"), lang.NewSymbol("start-key"), lang.NewSymbol("end-test"), lang.NewSymbol("end-key"))), lang.NewKeyword("doc"), "sc must be a sorted collection, test(s) one of <, <=, > or\n >=. Returns a seq of those entries with keys ek for\n which (test (.. sc comparator (compare ek key)) 0) is true", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5133), lang.NewKeyword("end-line"), int(5133))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var tmp6 any + { // let + // let binding "include" + tmp7 := checkDerefVar(glojure_DOT_core_mk_bound_fn) + tmp8 := lang.Apply(tmp7, []any{v3, v4, v5}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + tmp11 := checkDerefVar(glojure_DOT_core__GT_) + tmp12 := checkDerefVar(glojure_DOT_core__GT__EQ_) + tmp13 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{tmp11, tmp12})) + tmp14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5141), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5141), lang.NewKeyword("end-column"), int(17)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp16 := lang.Apply(tmp15, []any{v4}) + if lang.IsTruthy(tmp16) { + var tmp17 any + { // let + // let binding "temp__0__auto__" + tmp18, _ := lang.FieldOrMethod(v3, "seqFrom") + if reflect.TypeOf(tmp18).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("seqFrom is not a function"))) + } + tmp19 := lang.Apply(tmp18, []any{v5, true}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + var tmp22 any + { // let + // let binding "vec__68" + var v23 any = v20 + _ = v23 + // let binding "e" + tmp24 := checkDerefVar(glojure_DOT_core_nth) + tmp25 := lang.Apply(tmp24, []any{v23, int64(0), nil}) + var v26 any = tmp25 + _ = v26 + // let binding "s" + var v27 any = v23 + _ = v27 + var tmp28 any + tmp29 := lang.Apply(v9, []any{v26}) + if lang.IsTruthy(tmp29) { + tmp28 = v27 + } else { + tmp30 := checkDerefVar(glojure_DOT_core_next) + tmp31 := lang.Apply(tmp30, []any{v27}) + tmp28 = tmp31 + } + tmp22 = tmp28 + } // end let + tmp21 = tmp22 + } else { + } + tmp17 = tmp21 + } // end let + tmp10 = tmp17 + } else { + tmp18 := checkDerefVar(glojure_DOT_core_take_while) + tmp19, _ := lang.FieldOrMethod(v3, "seq") + if reflect.TypeOf(tmp19).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("seq is not a function"))) + } + tmp20 := lang.Apply(tmp19, []any{true}) + tmp21 := lang.Apply(tmp18, []any{v9, tmp20}) + tmp10 = tmp21 + } + tmp6 = tmp10 + } // end let + return tmp6 + case 5: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := args[4] + _ = v7 + var tmp8 any + { // let + // let binding "temp__0__auto__" + tmp9, _ := lang.FieldOrMethod(v3, "seqFrom") + if reflect.TypeOf(tmp9).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("seqFrom is not a function"))) + } + tmp10 := lang.Apply(tmp9, []any{v5, true}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + var tmp13 any + { // let + // let binding "vec__71" + var v14 any = v11 + _ = v14 + // let binding "e" + tmp15 := checkDerefVar(glojure_DOT_core_nth) + tmp16 := lang.Apply(tmp15, []any{v14, int64(0), nil}) + var v17 any = tmp16 + _ = v17 + // let binding "s" + var v18 any = v14 + _ = v18 + tmp19 := checkDerefVar(glojure_DOT_core_take_while) + tmp20 := checkDerefVar(glojure_DOT_core_mk_bound_fn) + tmp21 := lang.Apply(tmp20, []any{v3, v6, v7}) + var tmp22 any + tmp23 := checkDerefVar(glojure_DOT_core_mk_bound_fn) + tmp24 := lang.Apply(tmp23, []any{v3, v4, v5}) + tmp25 := lang.Apply(tmp24, []any{v17}) + if lang.IsTruthy(tmp25) { + tmp22 = v18 + } else { + tmp26 := checkDerefVar(glojure_DOT_core_next) + tmp27 := lang.Apply(tmp26, []any{v18}) + tmp22 = tmp27 + } + tmp28 := lang.Apply(tmp19, []any{tmp21, tmp22}) + tmp13 = tmp28 + } // end let + tmp12 = tmp13 + } else { + } + tmp8 = tmp12 + } // end let + return tmp8 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // subvec + { + tmp0 := lang.NewSymbol("subvec").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("v"), lang.NewSymbol("start")), lang.NewVector(lang.NewSymbol("v"), lang.NewSymbol("start"), lang.NewSymbol("end"))), lang.NewKeyword("doc"), "Returns a persistent vector of the items in vector from\n start (inclusive) to end (exclusive). If end is not supplied,\n defaults to (count vector). This operation is O(1) and very fast, as\n the resulting vector shares structure with the original and no\n trimming is done.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3819), lang.NewKeyword("end-line"), int(3819))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_subvec) + tmp6 := checkDerefVar(glojure_DOT_core_count) + tmp7 := lang.Apply(tmp6, []any{v3}) + tmp8 := lang.Apply(tmp5, []any{v3, v4, tmp7}) + return tmp8 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6, _ := lang.FieldOrMethod(runtime7.RT, "Subvec") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Subvec is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v3, v4, v5}) + return tmp7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // supers + { + tmp0 := lang.NewSymbol("supers").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("class"))), lang.NewKeyword("doc"), "Returns the immediate and indirect superclasses and interfaces of c, if any", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5532), lang.NewKeyword("end-line"), int(5532))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + { // let + // let binding "ret" + tmp5 := checkDerefVar(glojure_DOT_core_set) + tmp6 := checkDerefVar(glojure_DOT_core_bases) + tmp7 := lang.Apply(tmp6, []any{v3}) + tmp8 := lang.Apply(tmp5, []any{tmp7}) + var v9 any = tmp8 + _ = v9 + // let binding "cs" + var v10 any = v9 + _ = v10 + for { + var tmp11 any + tmp12 := checkDerefVar(glojure_DOT_core_seq) + tmp13 := lang.Apply(tmp12, []any{v10}) + if lang.IsTruthy(tmp13) { + var tmp14 any + { // let + // let binding "c" + tmp15 := checkDerefVar(glojure_DOT_core_first) + tmp16 := lang.Apply(tmp15, []any{v10}) + var v17 any = tmp16 + _ = v17 + // let binding "bs" + tmp18 := checkDerefVar(glojure_DOT_core_bases) + tmp19 := lang.Apply(tmp18, []any{v17}) + var v20 any = tmp19 + _ = v20 + tmp22 := checkDerefVar(glojure_DOT_core_into1) + tmp23 := lang.Apply(tmp22, []any{v9, v20}) + var tmp21 any = tmp23 + tmp25 := checkDerefVar(glojure_DOT_core_into1) + tmp26 := checkDerefVar(glojure_DOT_core_disj) + tmp27 := lang.Apply(tmp26, []any{v10, v17}) + tmp28 := lang.Apply(tmp25, []any{tmp27, v20}) + var tmp24 any = tmp28 + v9 = tmp21 + v10 = tmp24 + continue + } // end let + tmp11 = tmp14 + } else { + tmp15 := checkDerefVar(glojure_DOT_core_not_empty) + tmp16 := lang.Apply(tmp15, []any{v9}) + tmp11 = tmp16 + } + tmp4 = tmp11 + break + } + } // end let + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // swap! + { + tmp0 := lang.NewSymbol("swap!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atom"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Atomically swaps the value of atom to be:\n (apply f current-value-of-atom args). Note that f may be called\n multiple times, and thus should be free of side effects. Returns\n the value that was swapped in.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2343), lang.NewKeyword("end-line"), int(2343))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6, _ := lang.FieldOrMethod(v3, "swap") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("swap is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // swap-vals! + { + tmp0 := lang.NewSymbol("swap-vals!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atom"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Atomically swaps the value of atom to be:\n (apply f current-value-of-atom args). Note that f may be called\n multiple times, and thus should be free of side effects.\n Returns [old new], the value of the atom before and after the swap.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2352), lang.NewKeyword("end-line"), int(2352))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6, _ := lang.FieldOrMethod(v3, "swapVals") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("swapVals is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // symbol + { + tmp1 := reflect.TypeOf((*lang.Symbol)(nil)) + tmp0 := lang.NewSymbol("symbol").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name"))), lang.NewKeyword("doc"), "Returns a Symbol with the given namespace and name. Arity-1 works\n on strings, keywords, and vars.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(584), lang.NewKeyword("end-line"), int(584))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(glojure_DOT_core_symbol_QMARK_) + tmp7 := lang.Apply(tmp6, []any{v4}) + if lang.IsTruthy(tmp7) { + tmp5 = v4 + } else { + var tmp8 any + tmp9 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp10 := lang.Apply(tmp9, []any{lang.Builtins["string"], v4}) + if lang.IsTruthy(tmp10) { + tmp11 := lang.Apply(lang.NewSymbol, []any{v4}) + tmp8 = tmp11 + } else { + var tmp12 any + tmp13 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp14 := reflect.TypeOf((*lang.Var)(nil)) + tmp15 := lang.Apply(tmp13, []any{tmp14, v4}) + if lang.IsTruthy(tmp15) { + tmp16, ok := lang.FieldOrMethod(v4, "toSymbol") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "toSymbol"))) + } + var tmp17 any + switch reflect.TypeOf(tmp16).Kind() { + case reflect.Func: + tmp17 = lang.Apply(tmp16, nil) + default: + tmp17 = tmp16 + } + tmp12 = tmp17 + } else { + var tmp18 any + tmp19 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp20 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() + tmp21 := lang.Apply(tmp19, []any{tmp20, v4}) + if lang.IsTruthy(tmp21) { + tmp22, ok := lang.FieldOrMethod(v4, "sym") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "sym"))) + } + var tmp23 any + switch reflect.TypeOf(tmp22).Kind() { + case reflect.Func: + tmp23 = lang.Apply(tmp22, nil) + default: + tmp23 = tmp22 + } + tmp18 = tmp23 + } else { + var tmp24 any + if lang.IsTruthy(lang.NewKeyword("else")) { + tmp25 := lang.Apply(lang.NewIllegalArgumentError, []any{"no conversion to symbol"}) + panic(tmp25) + } else { + } + tmp18 = tmp24 + } + tmp12 = tmp18 + } + tmp8 = tmp12 + } + tmp5 = tmp8 + } + return tmp5 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6 := lang.Apply(lang.InternSymbol, []any{v4, v5}) + return tmp6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp4 := reflect.TypeOf((*lang.Symbol)(nil)) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // symbol? + { + tmp0 := lang.NewSymbol("symbol?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a Symbol", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(557), lang.NewKeyword("end-line"), int(557))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp5 := reflect.TypeOf((*lang.Symbol)(nil)) + tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // sync + { + tmp0 := lang.NewSymbol("sync").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("flags-ignored-for-now"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "transaction-flags => TBD, pass nil for now\n\n Runs the exprs (in an implicit do) in a transaction that encompasses\n exprs and any nested calls. Starts a transaction if none is already\n running on this thread. Any uncaught exception will abort the\n transaction and flow out of sync. The exprs may be run more than\n once, but any effects on Refs will be atomic.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(2490), lang.NewKeyword("end-line"), int(2490))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_seq) + tmp8 := checkDerefVar(glojure_DOT_core_concat) + tmp9 := checkDerefVar(glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol(".")}) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.LockingTransaction")}) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := checkDerefVar(glojure_DOT_core_seq) + tmp15 := checkDerefVar(glojure_DOT_core_concat) + tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("glojure.core/RunInTransaction")}) + tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp19 := checkDerefVar(glojure_DOT_core_seq) + tmp20 := checkDerefVar(glojure_DOT_core_concat) + tmp21 := checkDerefVar(glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("glojure.core/fn")}) + tmp23 := checkDerefVar(glojure_DOT_core_list) + tmp24 := checkDerefVar(glojure_DOT_core_apply) + tmp25 := checkDerefVar(glojure_DOT_core_vector) + tmp26 := checkDerefVar(glojure_DOT_core_seq) + tmp27 := checkDerefVar(glojure_DOT_core_concat) + tmp28 := lang.Apply(tmp27, nil) + tmp29 := lang.Apply(tmp26, []any{tmp28}) + tmp30 := lang.Apply(tmp24, []any{tmp25, tmp29}) + tmp31 := lang.Apply(tmp23, []any{tmp30}) + tmp32 := lang.Apply(tmp20, []any{tmp22, tmp31, v6}) + tmp33 := lang.Apply(tmp19, []any{tmp32}) + tmp34 := lang.Apply(tmp18, []any{tmp33}) + tmp35 := lang.Apply(tmp15, []any{tmp17, tmp34}) + tmp36 := lang.Apply(tmp14, []any{tmp35}) + tmp37 := lang.Apply(tmp13, []any{tmp36}) + tmp38 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp37}) + tmp39 := lang.Apply(tmp7, []any{tmp38}) + return tmp39 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // system-newline + { + tmp0 := lang.NewSymbol("system-newline").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3695), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(3695), lang.NewKeyword("end-column"), int(40), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, "\n", true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // tagged-literal + { + tmp0 := lang.NewSymbol("tagged-literal").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag"), lang.NewSymbol("form"))), lang.NewKeyword("doc"), "Construct a data representation of a tagged literal from a\n tag symbol and a form.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7769), lang.NewKeyword("end-line"), int(7769))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(nil, []any{v3, v4}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // tagged-literal? + { + tmp0 := lang.NewSymbol("tagged-literal?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("value"))), lang.NewKeyword("doc"), "Return true if the value is the data representation of a tagged literal", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7763), lang.NewKeyword("end-line"), int(7763))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp5 := lang.Apply(tmp4, []any{nil, v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // take + { + tmp0 := lang.NewSymbol("take").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the first n items in coll, or all items if\n there are fewer than n. Returns a stateful transducer when\n no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2853), lang.NewKeyword("end-line"), int(2853))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + var tmp6 any + { // let + // let binding "nv" + tmp7 := checkDerefVar(glojure_DOT_core_volatile_BANG_) + tmp8 := lang.Apply(tmp7, []any{v3}) + var v9 any = tmp8 + _ = v9 + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp11 := lang.Apply(v5, nil) + return tmp11 + case 1: + v11 := args[0] + _ = v11 + tmp12 := lang.Apply(v5, []any{v11}) + return tmp12 + case 2: + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + var tmp13 any + { // let + // let binding "n" + tmp14 := checkDerefVar(glojure_DOT_core_deref) + tmp15 := lang.Apply(tmp14, []any{v9}) + var v16 any = tmp15 + _ = v16 + // let binding "nn" + tmp17 := checkDerefVar(glojure_DOT_core_dec) + tmp18, ok := lang.FieldOrMethod(v9, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v9, "Deref"))) + } + var tmp19 any + switch reflect.TypeOf(tmp18).Kind() { + case reflect.Func: + tmp19 = lang.Apply(tmp18, nil) + default: + tmp19 = tmp18 + } + tmp20 := lang.Apply(tmp17, []any{tmp19}) + tmp21, _ := lang.FieldOrMethod(v9, "reset") + if reflect.TypeOf(tmp21).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) + } + tmp22 := lang.Apply(tmp21, []any{tmp20}) + var v23 any = tmp22 + _ = v23 + // let binding "result" + var tmp24 any + tmp25 := checkDerefVar(glojure_DOT_core_pos_QMARK_) + tmp26 := lang.Apply(tmp25, []any{v16}) + if lang.IsTruthy(tmp26) { + tmp27 := lang.Apply(v5, []any{v11, v12}) + tmp24 = tmp27 + } else { + tmp24 = v11 + } + var v28 any = tmp24 + _ = v28 + var tmp29 any + tmp30 := checkDerefVar(glojure_DOT_core_not) + tmp31 := checkDerefVar(glojure_DOT_core_pos_QMARK_) + tmp32 := lang.Apply(tmp31, []any{v23}) + tmp33 := lang.Apply(tmp30, []any{tmp32}) + if lang.IsTruthy(tmp33) { + tmp34 := checkDerefVar(glojure_DOT_core_ensure_reduced) + tmp35 := lang.Apply(tmp34, []any{v28}) + tmp29 = tmp35 + } else { + tmp29 = v28 + } + tmp13 = tmp29 + } // end let + return tmp13 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2862), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(2873), lang.NewKeyword("end-column"), int(28)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp6 = tmp12 + } // end let + return tmp6 + }) + tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2860), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2873), lang.NewKeyword("end-column"), int(30)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var tmp6 any + tmp7 := checkDerefVar(glojure_DOT_core_pos_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v3}) + if lang.IsTruthy(tmp8) { + var tmp9 any + { // let + // let binding "temp__0__auto__" + tmp10 := checkDerefVar(glojure_DOT_core_seq) + tmp11 := lang.Apply(tmp10, []any{v4}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + var tmp14 any + { // let + // let binding "s" + var v15 any = v12 + _ = v15 + tmp16 := checkDerefVar(glojure_DOT_core_cons) + tmp17 := checkDerefVar(glojure_DOT_core_first) + tmp18 := lang.Apply(tmp17, []any{v15}) + tmp19 := checkDerefVar(glojure_DOT_core_take) + tmp20 := checkDerefVar(glojure_DOT_core_dec) + tmp21 := lang.Apply(tmp20, []any{v3}) + tmp22 := checkDerefVar(glojure_DOT_core_rest) + tmp23 := lang.Apply(tmp22, []any{v15}) + tmp24 := lang.Apply(tmp19, []any{tmp21, tmp23}) + tmp25 := lang.Apply(tmp16, []any{tmp18, tmp24}) + tmp14 = tmp25 + } // end let + tmp13 = tmp14 + } else { + } + tmp9 = tmp13 + } // end let + tmp6 = tmp9 + } else { + } + return tmp6 + }) + tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) + return tmp6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // take-last + { + tmp0 := lang.NewSymbol("take-last").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a seq of the last n items in coll. Depending on the type\n of coll may be no better than linear time. For vectors, see also subvec.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2939), lang.NewKeyword("end-line"), int(2939))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 any + { // let + // let binding "s" + tmp6 := checkDerefVar(glojure_DOT_core_seq) + tmp7 := lang.Apply(tmp6, []any{v4}) + var v8 any = tmp7 + _ = v8 + // let binding "lead" + tmp9 := checkDerefVar(glojure_DOT_core_seq) + tmp10 := checkDerefVar(glojure_DOT_core_drop) + tmp11 := lang.Apply(tmp10, []any{v3, v4}) + tmp12 := lang.Apply(tmp9, []any{tmp11}) + var v13 any = tmp12 + _ = v13 + for { + var tmp14 any + if lang.IsTruthy(v13) { + tmp16 := checkDerefVar(glojure_DOT_core_next) + tmp17 := lang.Apply(tmp16, []any{v8}) + var tmp15 any = tmp17 + tmp19 := checkDerefVar(glojure_DOT_core_next) + tmp20 := lang.Apply(tmp19, []any{v13}) + var tmp18 any = tmp20 + v8 = tmp15 + v13 = tmp18 + continue + } else { + tmp14 = v8 + } + tmp5 = tmp14 + break + } + } // end let + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // take-nth + { + tmp0 := lang.NewSymbol("take-nth").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy seq of every nth item in coll. Returns a stateful\n transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4287), lang.NewKeyword("end-line"), int(4287))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + var tmp6 any + { // let + // let binding "iv" + tmp7 := checkDerefVar(glojure_DOT_core_volatile_BANG_) + tmp8 := lang.Apply(tmp7, []any{int64(-1)}) + var v9 any = tmp8 + _ = v9 + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp11 := lang.Apply(v5, nil) + return tmp11 + case 1: + v11 := args[0] + _ = v11 + tmp12 := lang.Apply(v5, []any{v11}) + return tmp12 + case 2: + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + var tmp13 any + { // let + // let binding "i" + tmp14 := checkDerefVar(glojure_DOT_core_inc) + tmp15, ok := lang.FieldOrMethod(v9, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v9, "Deref"))) + } + var tmp16 any + switch reflect.TypeOf(tmp15).Kind() { + case reflect.Func: + tmp16 = lang.Apply(tmp15, nil) + default: + tmp16 = tmp15 + } + tmp17 := lang.Apply(tmp14, []any{tmp16}) + tmp18, _ := lang.FieldOrMethod(v9, "reset") + if reflect.TypeOf(tmp18).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) + } + tmp19 := lang.Apply(tmp18, []any{tmp17}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + tmp22 := checkDerefVar(glojure_DOT_core_zero_QMARK_) + tmp23 := checkDerefVar(glojure_DOT_core_rem) + tmp24 := lang.Apply(tmp23, []any{v20, v3}) + tmp25 := lang.Apply(tmp22, []any{tmp24}) + if lang.IsTruthy(tmp25) { + tmp26 := lang.Apply(v5, []any{v11, v12}) + tmp21 = tmp26 + } else { + tmp21 = v11 + } + tmp13 = tmp21 + } // end let + return tmp13 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4295), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(4302), lang.NewKeyword("end-column"), int(28)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp6 = tmp12 + } // end let + return tmp6 + }) + tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4293), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(4302), lang.NewKeyword("end-column"), int(30)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var tmp6 any + { // let + // let binding "temp__0__auto__" + tmp7 := checkDerefVar(glojure_DOT_core_seq) + tmp8 := lang.Apply(tmp7, []any{v4}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + var tmp11 any + { // let + // let binding "s" + var v12 any = v9 + _ = v12 + tmp13 := checkDerefVar(glojure_DOT_core_cons) + tmp14 := checkDerefVar(glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v12}) + tmp16 := checkDerefVar(glojure_DOT_core_take_nth) + tmp17 := checkDerefVar(glojure_DOT_core_drop) + tmp18 := lang.Apply(tmp17, []any{v3, v12}) + tmp19 := lang.Apply(tmp16, []any{v3, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp19}) + tmp11 = tmp20 + } // end let + tmp10 = tmp11 + } else { + } + tmp6 = tmp10 + } // end let + return tmp6 + }) + tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) + return tmp6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // take-while + { + tmp0 := lang.NewSymbol("take-while").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred")), lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of successive items from coll while\n (pred item) returns logical true. pred must be free of side-effects.\n Returns a transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2880), lang.NewKeyword("end-line"), int(2880))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v5 := args[0] + _ = v5 + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp7 := lang.Apply(v5, nil) + return tmp7 + case 1: + v7 := args[0] + _ = v7 + tmp8 := lang.Apply(v5, []any{v7}) + return tmp8 + case 2: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + var tmp9 any + tmp10 := lang.Apply(v3, []any{v8}) + if lang.IsTruthy(tmp10) { + tmp11 := lang.Apply(v5, []any{v7, v8}) + tmp9 = tmp11 + } else { + tmp12 := checkDerefVar(glojure_DOT_core_reduced) + tmp13 := lang.Apply(tmp12, []any{v7}) + tmp9 = tmp13 + } + return tmp9 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2888), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(2894), lang.NewKeyword("end-column"), int(33)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp8 + }) + tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2887), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2894), lang.NewKeyword("end-column"), int(34)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var tmp6 any + { // let + // let binding "temp__0__auto__" + tmp7 := checkDerefVar(glojure_DOT_core_seq) + tmp8 := lang.Apply(tmp7, []any{v4}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + var tmp11 any + { // let + // let binding "s" + var v12 any = v9 + _ = v12 + var tmp13 any + tmp14 := checkDerefVar(glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v12}) + tmp16 := lang.Apply(v3, []any{tmp15}) + if lang.IsTruthy(tmp16) { + tmp17 := checkDerefVar(glojure_DOT_core_cons) + tmp18 := checkDerefVar(glojure_DOT_core_first) + tmp19 := lang.Apply(tmp18, []any{v12}) + tmp20 := checkDerefVar(glojure_DOT_core_take_while) + tmp21 := checkDerefVar(glojure_DOT_core_rest) + tmp22 := lang.Apply(tmp21, []any{v12}) + tmp23 := lang.Apply(tmp20, []any{v3, tmp22}) + tmp24 := lang.Apply(tmp17, []any{tmp19, tmp23}) + tmp13 = tmp24 + } else { + } + tmp11 = tmp13 + } // end let + tmp10 = tmp11 + } else { + } + tmp6 = tmp10 + } // end let + return tmp6 + }) + tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) + return tmp6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // tapset + { + tmp0 := lang.NewSymbol("tapset").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7882), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(7882), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp2 := lang.NewAtom(lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{}))) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // test + { + tmp0 := lang.NewSymbol("test").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("v"))), lang.NewKeyword("doc"), "test [v] finds fn at key :test in var metadata and calls it,\n presuming failure will throw exception", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4853), lang.NewKeyword("end-line"), int(4853))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + { // let + // let binding "f" + tmp5 := checkDerefVar(glojure_DOT_core_meta) + tmp6 := lang.Apply(tmp5, []any{v3}) + tmp7 := lang.Apply(lang.NewKeyword("test"), []any{tmp6}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + tmp10 := lang.Apply(v8, nil) + _ = tmp10 + tmp9 = lang.NewKeyword("ok") + } else { + tmp9 = lang.NewKeyword("no-test") + } + tmp4 = tmp9 + } // end let + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // the-ns + { + tmp0 := lang.NewSymbol("the-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "If passed a namespace, returns it. Else, when passed a symbol,\n returns the namespace named by it, throwing an exception if not\n found.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4152), lang.NewKeyword("end-line"), int(4152))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp6 := reflect.TypeOf((*lang.Namespace)(nil)) + tmp7 := lang.Apply(tmp5, []any{tmp6, v3}) + if lang.IsTruthy(tmp7) { + tmp4 = v3 + } else { + var tmp8 any + { // let + // let binding "or__0__auto__" + tmp9 := checkDerefVar(glojure_DOT_core_find_ns) + tmp10 := lang.Apply(tmp9, []any{v3}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + tmp12 = v11 + } else { + tmp13 := checkDerefVar(glojure_DOT_core_str) + tmp14 := lang.Apply(tmp13, []any{"No namespace: ", v3, " found"}) + tmp15 := lang.Apply(lang.NewError, []any{tmp14}) + panic(tmp15) + } + tmp8 = tmp12 + } // end let + tmp4 = tmp8 + } + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // thread-bound? + { + tmp0 := lang.NewSymbol("thread-bound?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("vars"))), lang.NewKeyword("doc"), "Returns true if all of the vars provided as arguments have thread-local bindings.\n Implies that set!'ing the provided vars will succeed. Returns true if no vars are provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5499), lang.NewKeyword("end-line"), int(5499))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_every_QMARK_) + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v6 := args[0] + _ = v6 + tmp7, ok := lang.FieldOrMethod(v6, "getThreadBinding") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "getThreadBinding"))) + } + var tmp8 any + switch reflect.TypeOf(tmp7).Kind() { + case reflect.Func: + tmp8 = lang.Apply(tmp7, nil) + default: + tmp8 = tmp7 + } + return tmp8 + }) + tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5505), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5505), lang.NewKeyword("end-column"), int(78)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp8 := lang.Apply(tmp4, []any{tmp7, v3}) + return tmp8 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // throw-if + { + tmp0 := lang.NewSymbol("throw-if").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("fmt"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Throws a CompilerException with a message if pred is true", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5832), lang.NewKeyword("end-line"), int(5832), lang.NewKeyword("private"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + var tmp6 any + if lang.IsTruthy(v3) { + var tmp7 any + { // let + // let binding "message" + tmp8 := checkDerefVar(glojure_DOT_core_apply) + tmp9 := checkDerefVar(glojure_DOT_core_format) + tmp10 := lang.Apply(tmp8, []any{tmp9, v4, v5}) + var v11 any = tmp10 + _ = v11 + // let binding "exception" + tmp12 := lang.Apply(lang.NewError, []any{v11}) + var v13 any = tmp12 + _ = v13 + // let binding "raw-trace" + tmp14, ok := lang.FieldOrMethod(v13, "getStackTrace") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v13, "getStackTrace"))) + } + var tmp15 any + switch reflect.TypeOf(tmp14).Kind() { + case reflect.Func: + tmp15 = lang.Apply(tmp14, nil) + default: + tmp15 = tmp14 + } + var v16 any = tmp15 + _ = v16 + // let binding "boring?" + var tmp17 lang.FnFunc + tmp17 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v18 := args[0] + _ = v18 + tmp19 := checkDerefVar(glojure_DOT_core_not_EQ_) + tmp20, ok := lang.FieldOrMethod(v18, "getMethodName") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v18, "getMethodName"))) + } + var tmp21 any + switch reflect.TypeOf(tmp20).Kind() { + case reflect.Func: + tmp21 = lang.Apply(tmp20, nil) + default: + tmp21 = tmp20 + } + tmp22 := lang.Apply(tmp19, []any{tmp21, "doInvoke"}) + return tmp22 + }) + tmp18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5839), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(5839), lang.NewKeyword("end-column"), int(74)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v20 any = tmp19 + _ = v20 + // let binding "trace" + tmp21 := checkDerefVar(glojure_DOT_core_into_array) + tmp22 := checkDerefVar(glojure_DOT_core_drop) + tmp23 := checkDerefVar(glojure_DOT_core_drop_while) + tmp24 := lang.Apply(tmp23, []any{v20, v16}) + tmp25 := lang.Apply(tmp22, []any{int64(2), tmp24}) + tmp26 := lang.Apply(tmp21, []any{nil, tmp25}) + var v27 any = tmp26 + _ = v27 + tmp28, _ := lang.FieldOrMethod(v13, "setStackTrace") + if reflect.TypeOf(tmp28).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setStackTrace is not a function"))) + } + tmp29 := lang.Apply(tmp28, []any{v27}) + _ = tmp29 + tmp30 := checkDerefVar(glojure_DOT_core__STAR_file_STAR_) + tmp31, ok := lang.FieldOrMethod(nil, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "Deref"))) + } + var tmp32 any + switch reflect.TypeOf(tmp31).Kind() { + case reflect.Func: + tmp32 = lang.Apply(tmp31, nil) + default: + tmp32 = tmp31 + } + tmp33, ok := lang.FieldOrMethod(nil, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "Deref"))) + } + var tmp34 any + switch reflect.TypeOf(tmp33).Kind() { + case reflect.Func: + tmp34 = lang.Apply(tmp33, nil) + default: + tmp34 = tmp33 + } + tmp35 := lang.Apply(lang.NewCompilerError, []any{tmp30, tmp32, tmp34, v13}) + panic(tmp35) + } // end let + tmp6 = tmp7 + } else { + } + return tmp6 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // time + { + tmp0 := lang.NewSymbol("time").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"))), lang.NewKeyword("doc"), "Evaluates expr and prints the time it took. Returns the value of\n expr.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3885), lang.NewKeyword("end-line"), int(3885))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6 := checkDerefVar(glojure_DOT_core_seq) + tmp7 := checkDerefVar(glojure_DOT_core_concat) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("glojure.core/let")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := checkDerefVar(glojure_DOT_core_apply) + tmp12 := checkDerefVar(glojure_DOT_core_vector) + tmp13 := checkDerefVar(glojure_DOT_core_seq) + tmp14 := checkDerefVar(glojure_DOT_core_concat) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("start__0__auto__")}) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := checkDerefVar(glojure_DOT_core_seq) + tmp19 := checkDerefVar(glojure_DOT_core_concat) + tmp20 := checkDerefVar(glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{lang.NewSymbol(".UnixNano")}) + tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp23 := checkDerefVar(glojure_DOT_core_seq) + tmp24 := checkDerefVar(glojure_DOT_core_concat) + tmp25 := checkDerefVar(glojure_DOT_core_list) + tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol("time.Now")}) + tmp27 := lang.Apply(tmp24, []any{tmp26}) + tmp28 := lang.Apply(tmp23, []any{tmp27}) + tmp29 := lang.Apply(tmp22, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp21, tmp29}) + tmp31 := lang.Apply(tmp18, []any{tmp30}) + tmp32 := lang.Apply(tmp17, []any{tmp31}) + tmp33 := checkDerefVar(glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{lang.NewSymbol("ret__1__auto__")}) + tmp35 := checkDerefVar(glojure_DOT_core_list) + tmp36 := lang.Apply(tmp35, []any{v5}) + tmp37 := lang.Apply(tmp14, []any{tmp16, tmp32, tmp34, tmp36}) + tmp38 := lang.Apply(tmp13, []any{tmp37}) + tmp39 := lang.Apply(tmp11, []any{tmp12, tmp38}) + tmp40 := lang.Apply(tmp10, []any{tmp39}) + tmp41 := checkDerefVar(glojure_DOT_core_list) + tmp42 := checkDerefVar(glojure_DOT_core_seq) + tmp43 := checkDerefVar(glojure_DOT_core_concat) + tmp44 := checkDerefVar(glojure_DOT_core_list) + tmp45 := lang.Apply(tmp44, []any{lang.NewSymbol("glojure.core/prn")}) + tmp46 := checkDerefVar(glojure_DOT_core_list) + tmp47 := checkDerefVar(glojure_DOT_core_seq) + tmp48 := checkDerefVar(glojure_DOT_core_concat) + tmp49 := checkDerefVar(glojure_DOT_core_list) + tmp50 := lang.Apply(tmp49, []any{lang.NewSymbol("glojure.core/str")}) + tmp51 := checkDerefVar(glojure_DOT_core_list) + tmp52 := lang.Apply(tmp51, []any{"Elapsed time: "}) + tmp53 := checkDerefVar(glojure_DOT_core_list) + tmp54 := checkDerefVar(glojure_DOT_core_seq) + tmp55 := checkDerefVar(glojure_DOT_core_concat) + tmp56 := checkDerefVar(glojure_DOT_core_list) + tmp57 := lang.Apply(tmp56, []any{lang.NewSymbol("glojure.core//")}) + tmp58 := checkDerefVar(glojure_DOT_core_list) + tmp59 := checkDerefVar(glojure_DOT_core_seq) + tmp60 := checkDerefVar(glojure_DOT_core_concat) + tmp61 := checkDerefVar(glojure_DOT_core_list) + tmp62 := lang.Apply(tmp61, []any{lang.NewSymbol("glojure.core/double")}) + tmp63 := checkDerefVar(glojure_DOT_core_list) + tmp64 := checkDerefVar(glojure_DOT_core_seq) + tmp65 := checkDerefVar(glojure_DOT_core_concat) + tmp66 := checkDerefVar(glojure_DOT_core_list) + tmp67 := lang.Apply(tmp66, []any{lang.NewSymbol("glojure.core/-")}) + tmp68 := checkDerefVar(glojure_DOT_core_list) + tmp69 := checkDerefVar(glojure_DOT_core_seq) + tmp70 := checkDerefVar(glojure_DOT_core_concat) + tmp71 := checkDerefVar(glojure_DOT_core_list) + tmp72 := lang.Apply(tmp71, []any{lang.NewSymbol(".UnixNano")}) + tmp73 := checkDerefVar(glojure_DOT_core_list) + tmp74 := checkDerefVar(glojure_DOT_core_seq) + tmp75 := checkDerefVar(glojure_DOT_core_concat) + tmp76 := checkDerefVar(glojure_DOT_core_list) + tmp77 := lang.Apply(tmp76, []any{lang.NewSymbol("time.Now")}) + tmp78 := lang.Apply(tmp75, []any{tmp77}) + tmp79 := lang.Apply(tmp74, []any{tmp78}) + tmp80 := lang.Apply(tmp73, []any{tmp79}) + tmp81 := lang.Apply(tmp70, []any{tmp72, tmp80}) + tmp82 := lang.Apply(tmp69, []any{tmp81}) + tmp83 := lang.Apply(tmp68, []any{tmp82}) + tmp84 := checkDerefVar(glojure_DOT_core_list) + tmp85 := lang.Apply(tmp84, []any{lang.NewSymbol("start__0__auto__")}) + tmp86 := lang.Apply(tmp65, []any{tmp67, tmp83, tmp85}) + tmp87 := lang.Apply(tmp64, []any{tmp86}) + tmp88 := lang.Apply(tmp63, []any{tmp87}) + tmp89 := lang.Apply(tmp60, []any{tmp62, tmp88}) + tmp90 := lang.Apply(tmp59, []any{tmp89}) + tmp91 := lang.Apply(tmp58, []any{tmp90}) + tmp92 := checkDerefVar(glojure_DOT_core_list) + tmp93 := lang.Apply(tmp92, []any{float64(1e+06)}) + tmp94 := lang.Apply(tmp55, []any{tmp57, tmp91, tmp93}) + tmp95 := lang.Apply(tmp54, []any{tmp94}) + tmp96 := lang.Apply(tmp53, []any{tmp95}) + tmp97 := checkDerefVar(glojure_DOT_core_list) + tmp98 := lang.Apply(tmp97, []any{" msecs"}) + tmp99 := lang.Apply(tmp48, []any{tmp50, tmp52, tmp96, tmp98}) + tmp100 := lang.Apply(tmp47, []any{tmp99}) + tmp101 := lang.Apply(tmp46, []any{tmp100}) + tmp102 := lang.Apply(tmp43, []any{tmp45, tmp101}) + tmp103 := lang.Apply(tmp42, []any{tmp102}) + tmp104 := lang.Apply(tmp41, []any{tmp103}) + tmp105 := checkDerefVar(glojure_DOT_core_list) + tmp106 := lang.Apply(tmp105, []any{lang.NewSymbol("ret__1__auto__")}) + tmp107 := lang.Apply(tmp7, []any{tmp9, tmp40, tmp104, tmp106}) + tmp108 := lang.Apply(tmp6, []any{tmp107}) + return tmp108 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // to-array + { + tmp0 := lang.NewSymbol("to-array").WithMeta(lang.NewMap(lang.NewKeyword("tag"), "[Ljava.lang.Object;", lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns an array of Objects containing the contents of coll, which\n can be any Collection. Maps to java.util.Collection.toArray().", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(337), lang.NewKeyword("end-line"), int(337))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(runtime7.RT, "ToArray") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ToArray is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), "[Ljava.lang.Object;")).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // to-array-2d + { + tmp0 := lang.NewSymbol("to-array-2d").WithMeta(lang.NewMap(lang.NewKeyword("tag"), "[[Ljava.lang.Object;", lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a (potentially-ragged) 2-dimensional array of Objects\n containing the contents of coll, which can be any Collection of any\n Collection.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4002), lang.NewKeyword("end-line"), int(4002))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + { // let + // let binding "ret" + tmp5 := checkDerefVar(glojure_DOT_core_make_array) + tmp6 := reflect.TypeOf((*reflect.Type)(nil)).Elem() + tmp7, _ := lang.FieldOrMethod(tmp6, "forName") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("forName is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{"[Ljava.lang.Object;"}) + tmp9, _ := lang.FieldOrMethod(v3, "size") + if reflect.TypeOf(tmp9).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("size is not a function"))) + } + tmp10 := lang.Apply(tmp9, []any{}) + tmp11 := lang.Apply(tmp5, []any{tmp8, tmp10}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + { // let + // let binding "i" + var v14 any = int64(0) + _ = v14 + // let binding "xs" + tmp15 := checkDerefVar(glojure_DOT_core_seq) + tmp16 := lang.Apply(tmp15, []any{v3}) + var v17 any = tmp16 + _ = v17 + for { + var tmp18 any + if lang.IsTruthy(v17) { + tmp19 := checkDerefVar(glojure_DOT_core_aset) + tmp20 := checkDerefVar(glojure_DOT_core_to_array) + tmp21 := checkDerefVar(glojure_DOT_core_first) + tmp22 := lang.Apply(tmp21, []any{v17}) + tmp23 := lang.Apply(tmp20, []any{tmp22}) + tmp24 := lang.Apply(tmp19, []any{v12, v14, tmp23}) + _ = tmp24 + tmp26 := checkDerefVar(glojure_DOT_core_inc) + tmp27 := lang.Apply(tmp26, []any{v14}) + var tmp25 any = tmp27 + tmp29 := checkDerefVar(glojure_DOT_core_next) + tmp30 := lang.Apply(tmp29, []any{v17}) + var tmp28 any = tmp30 + v14 = tmp25 + v17 = tmp28 + continue + } else { + } + tmp13 = tmp18 + break + } + } // end let + _ = tmp13 + tmp4 = v12 + } // end let + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), "[[Ljava.lang.Object;")).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // trampoline + { + tmp0 := lang.NewSymbol("trampoline").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "trampoline can be used to convert algorithms requiring mutual\n recursion without stack consumption. Calls f with supplied args, if\n any. If f returns a fn, calls that fn with no arguments, and\n continues to repeat, until the return value is not a fn, then\n returns that non-fn value. Note that if you want to return a fn as a\n final value, you must wrap it in some data structure and unpack it\n after trampoline returns.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6293), lang.NewKeyword("end-line"), int(6293))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + recur_loop_1073: + var tmp4 any + { // let + // let binding "ret" + tmp5 := lang.Apply(v3, nil) + var v6 any = tmp5 + _ = v6 + var tmp7 any + tmp8 := checkDerefVar(glojure_DOT_core_fn_QMARK_) + tmp9 := lang.Apply(tmp8, []any{v6}) + if lang.IsTruthy(tmp9) { + var tmp10 any = v6 + v3 = tmp10 + goto recur_loop_1073 + } else { + tmp7 = v6 + } + tmp4 = tmp7 + } // end let + return tmp4 + default: + if len(args) < 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var v4 any = lang.NewList(args[1:]...) + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_trampoline) + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + tmp7 := checkDerefVar(glojure_DOT_core_apply) + tmp8 := lang.Apply(tmp7, []any{v3, v4}) + return tmp8 + }) + tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6309), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(6309), lang.NewKeyword("end-column"), int(32)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp9 := lang.Apply(tmp5, []any{tmp8}) + return tmp9 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // transduce + { + tmp0 := lang.NewSymbol("transduce").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "reduce with a transformation of f (xf). If init is not\n supplied, (f) will be called to produce it. f should be a reducing\n step function that accepts both 1 and 2 arguments, if it accepts\n only 2 you can add the arity-1 with 'completing'. Returns the result\n of applying (the transformed) xf to init and the first item in coll,\n then applying xf to that result and the 2nd item, etc. If coll\n contains no items, returns init and f is not called. Note that\n certain transforms may inject or skip items.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6905), lang.NewKeyword("end-line"), int(6905))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6 := checkDerefVar(glojure_DOT_core_transduce) + tmp7 := lang.Apply(v4, nil) + tmp8 := lang.Apply(tmp6, []any{v3, v4, tmp7, v5}) + return tmp8 + case 4: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + var tmp7 any + { // let + // let binding "f" + tmp8 := lang.Apply(v3, []any{v4}) + var v9 any = tmp8 + _ = v9 + // let binding "ret" + var tmp10 any + tmp11 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp12 := reflect.TypeOf((*lang.IReduceInit)(nil)).Elem() + tmp13 := lang.Apply(tmp11, []any{tmp12, v6}) + if lang.IsTruthy(tmp13) { + tmp14, _ := lang.FieldOrMethod(v6, "ReduceInit") + if reflect.TypeOf(tmp14).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) + } + tmp15 := lang.Apply(tmp14, []any{v9, v5}) + tmp10 = tmp15 + } else { + tmp16 := checkDerefVar(glojure_DOT_core_DOT_protocols_coll_reduce) + tmp17 := lang.Apply(tmp16, []any{v6, v9, v5}) + tmp10 = tmp17 + } + var v18 any = tmp10 + _ = v18 + tmp19 := lang.Apply(v9, []any{v18}) + tmp7 = tmp19 + } // end let + return tmp7 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // transient + { + tmp0 := lang.NewSymbol("transient").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a new, transient version of the collection, in constant time.\n\n Transients support a parallel set of 'changing' operations, with similar names\n followed by ! - assoc!, conj! etc. These do the same things as their persistent\n counterparts except the return values are themselves transient.\n\n Note in particular that transients are not designed to be bashed in-place. You\n must capture and use the return value in the next call. In this way, they support\n the same code structure as the functional persistent code they replace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3335), lang.NewKeyword("end-line"), int(3335))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4, ok := lang.FieldOrMethod(v3, "AsTransient") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "AsTransient"))) + } + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { + case reflect.Func: + tmp5 = lang.Apply(tmp4, nil) + default: + tmp5 = tmp4 + } + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // tree-seq + { + tmp0 := lang.NewSymbol("tree-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("branch?"), lang.NewSymbol("children"), lang.NewSymbol("root"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the nodes in a tree, via a depth-first walk.\n branch? must be a fn of one arg that returns true if passed a node\n that can have children (but may not). children must be a fn of one\n arg that returns a sequence of the children. Will only be called on\n nodes for which branch? returns true. Root is the root node of the\n tree.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4955), lang.NewKeyword("end-line"), int(4955))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var tmp6 any + { // let + // let binding "walk" + var tmp7 lang.FnFunc + { // function walk + var v8 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v9 := args[0] + _ = v9 + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + tmp11 := checkDerefVar(glojure_DOT_core_cons) + var tmp12 any + tmp13 := lang.Apply(v3, []any{v9}) + if lang.IsTruthy(tmp13) { + tmp14 := checkDerefVar(glojure_DOT_core_mapcat) + tmp15 := lang.Apply(v4, []any{v9}) + tmp16 := lang.Apply(tmp14, []any{v8, tmp15}) + tmp12 = tmp16 + } else { + } + tmp17 := lang.Apply(tmp11, []any{v9, tmp12}) + return tmp17 + }) + tmp11 := lang.Apply(lang.NewLazySeq, []any{tmp10}) + return tmp11 + }) + v8 = tmp7 + _ = v8 + } + tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4965), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(4969), lang.NewKeyword("end-column"), int(53)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v10 any = tmp9 + _ = v10 + tmp11 := lang.Apply(v10, []any{v5}) + tmp6 = tmp11 + } // end let + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // true? + { + tmp1 := reflect.TypeOf(false) + tmp0 := lang.NewSymbol("true?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is the value true, false otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(511), lang.NewKeyword("end-line"), int(511))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5 := lang.Apply(lang.Identical, []any{v4, true}) + return tmp5 + }) + tmp4 := reflect.TypeOf(false) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // type + { + tmp0 := lang.NewSymbol("type").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns the :type metadata of x, or its Class if none", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3467), lang.NewKeyword("end-line"), int(3467))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + { // let + // let binding "or__0__auto__" + tmp5 := checkDerefVar(glojure_DOT_core_get) + tmp6 := checkDerefVar(glojure_DOT_core_meta) + tmp7 := lang.Apply(tmp6, []any{v3}) + tmp8 := lang.Apply(tmp5, []any{tmp7, lang.NewKeyword("type")}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + tmp10 = v9 + } else { + tmp11 := checkDerefVar(glojure_DOT_core_class) + tmp12 := lang.Apply(tmp11, []any{v3}) + tmp10 = tmp12 + } + tmp4 = tmp10 + } // end let + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-add + { + var tmp1 lang.FnFunc + { // function unchecked-add__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_seq) + tmp6 := checkDerefVar(glojure_DOT_core_concat) + tmp7 := checkDerefVar(glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{lang.NewSymbol(".")}) + tmp9 := checkDerefVar(glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := checkDerefVar(glojure_DOT_core_seq) + tmp13 := checkDerefVar(glojure_DOT_core_concat) + tmp14 := checkDerefVar(glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("glojure.core/UncheckedAdd")}) + tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("unchecked-add").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the sum of x and y, both long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1203), lang.NewKeyword("end-line"), int(1203))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedAdd") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedAdd is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-add-int + { + var tmp1 lang.FnFunc + { // function unchecked-add-int__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_seq) + tmp6 := checkDerefVar(glojure_DOT_core_concat) + tmp7 := checkDerefVar(glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{lang.NewSymbol(".")}) + tmp9 := checkDerefVar(glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := checkDerefVar(glojure_DOT_core_seq) + tmp13 := checkDerefVar(glojure_DOT_core_concat) + tmp14 := checkDerefVar(glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("glojure.core/Unchecked_int_add")}) + tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("unchecked-add-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the sum of x and y, both int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1196), lang.NewKeyword("end-line"), int(1196))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_add") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_add is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-byte + { + var tmp1 lang.FnFunc + { // function unchecked-byte__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := checkDerefVar(glojure_DOT_core_seq) + tmp12 := checkDerefVar(glojure_DOT_core_concat) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/UncheckedByteCast")}) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("unchecked-byte").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to byte. Subject to rounding or truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3517), lang.NewKeyword("end-line"), int(3517))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5 := lang.Apply(lang.UncheckedByteCast, []any{v4}) + return tmp5 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-char + { + var tmp1 lang.FnFunc + { // function unchecked-char__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := checkDerefVar(glojure_DOT_core_seq) + tmp12 := checkDerefVar(glojure_DOT_core_concat) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/UncheckedCharCast")}) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("unchecked-char").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to char. Subject to rounding or truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3529), lang.NewKeyword("end-line"), int(3529))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5, _ := lang.FieldOrMethod(runtime7.RT, "UncheckedCharCast") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedCharCast is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-dec + { + var tmp1 lang.FnFunc + { // function unchecked-dec__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := checkDerefVar(glojure_DOT_core_seq) + tmp12 := checkDerefVar(glojure_DOT_core_concat) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/UncheckedDec")}) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("unchecked-dec").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns a number one less than x, a long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1175), lang.NewKeyword("end-line"), int(1175))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedDec") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedDec is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-dec-int + { + var tmp1 lang.FnFunc + { // function unchecked-dec-int__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := checkDerefVar(glojure_DOT_core_seq) + tmp12 := checkDerefVar(glojure_DOT_core_concat) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/Unchecked_int_dec")}) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("unchecked-dec-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns a number one less than x, an int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1168), lang.NewKeyword("end-line"), int(1168))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_dec") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_dec is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-divide-int + { + var tmp1 lang.FnFunc + { // function unchecked-divide-int__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_seq) + tmp6 := checkDerefVar(glojure_DOT_core_concat) + tmp7 := checkDerefVar(glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{lang.NewSymbol(".")}) + tmp9 := checkDerefVar(glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := checkDerefVar(glojure_DOT_core_seq) + tmp13 := checkDerefVar(glojure_DOT_core_concat) + tmp14 := checkDerefVar(glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("glojure.core/UncheckedIntDivide")}) + tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("unchecked-divide-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the division of x by y, both int.\n Note - uses a primitive operator subject to truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(26), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1238), lang.NewKeyword("end-line"), int(1238))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedIntDivide") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedIntDivide is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-double + { + var tmp1 lang.FnFunc + { // function unchecked-double__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := checkDerefVar(glojure_DOT_core_seq) + tmp12 := checkDerefVar(glojure_DOT_core_concat) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/UncheckedDoubleCast")}) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("unchecked-double").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to double. Subject to rounding.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3553), lang.NewKeyword("end-line"), int(3553))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5 := lang.Apply(lang.AsFloat64, []any{v4}) + return tmp5 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-float + { + var tmp1 lang.FnFunc + { // function unchecked-float__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := checkDerefVar(glojure_DOT_core_seq) + tmp12 := checkDerefVar(glojure_DOT_core_concat) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/UncheckedFloatCast")}) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("unchecked-float").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to float. Subject to rounding.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3547), lang.NewKeyword("end-line"), int(3547))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5 := lang.Apply(lang.UncheckedFloatCast, []any{v4}) + return tmp5 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-inc + { + var tmp1 lang.FnFunc + { // function unchecked-inc__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := checkDerefVar(glojure_DOT_core_seq) + tmp12 := checkDerefVar(glojure_DOT_core_concat) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/Unchecked_inc")}) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("unchecked-inc").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns a number one greater than x, a long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1161), lang.NewKeyword("end-line"), int(1161))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_inc") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_inc is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-inc-int + { + var tmp1 lang.FnFunc + { // function unchecked-inc-int__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := checkDerefVar(glojure_DOT_core_seq) + tmp12 := checkDerefVar(glojure_DOT_core_concat) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/Unchecked_int_inc")}) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("unchecked-inc-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns a number one greater than x, an int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1154), lang.NewKeyword("end-line"), int(1154))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_inc") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_inc is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-int + { + var tmp1 lang.FnFunc + { // function unchecked-int__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := checkDerefVar(glojure_DOT_core_seq) + tmp12 := checkDerefVar(glojure_DOT_core_concat) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/UncheckedIntCast")}) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("unchecked-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to int. Subject to rounding or truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3535), lang.NewKeyword("end-line"), int(3535))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5 := lang.Apply(lang.UncheckedIntCast, []any{v4}) + return tmp5 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-long + { + var tmp1 lang.FnFunc + { // function unchecked-long__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := checkDerefVar(glojure_DOT_core_seq) + tmp12 := checkDerefVar(glojure_DOT_core_concat) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/UncheckedLongCast")}) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("unchecked-long").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to long. Subject to rounding or truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3541), lang.NewKeyword("end-line"), int(3541))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5 := lang.Apply(lang.UncheckedLongCast, []any{v4}) + return tmp5 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-multiply + { + var tmp1 lang.FnFunc + { // function unchecked-multiply__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_seq) + tmp6 := checkDerefVar(glojure_DOT_core_concat) + tmp7 := checkDerefVar(glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{lang.NewSymbol(".")}) + tmp9 := checkDerefVar(glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := checkDerefVar(glojure_DOT_core_seq) + tmp13 := checkDerefVar(glojure_DOT_core_concat) + tmp14 := checkDerefVar(glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("glojure.core/Unchecked_multiply")}) + tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("unchecked-multiply").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the product of x and y, both long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1231), lang.NewKeyword("end-line"), int(1231))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_multiply") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_multiply is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-multiply-int + { + var tmp1 lang.FnFunc + { // function unchecked-multiply-int__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_seq) + tmp6 := checkDerefVar(glojure_DOT_core_concat) + tmp7 := checkDerefVar(glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{lang.NewSymbol(".")}) + tmp9 := checkDerefVar(glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := checkDerefVar(glojure_DOT_core_seq) + tmp13 := checkDerefVar(glojure_DOT_core_concat) + tmp14 := checkDerefVar(glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("glojure.core/Unchecked_int_multiply")}) + tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("unchecked-multiply-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the product of x and y, both int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1224), lang.NewKeyword("end-line"), int(1224))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_multiply") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_multiply is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-negate + { + var tmp1 lang.FnFunc + { // function unchecked-negate__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := checkDerefVar(glojure_DOT_core_seq) + tmp12 := checkDerefVar(glojure_DOT_core_concat) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/Unchecked_minus")}) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("unchecked-negate").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the negation of x, a long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1189), lang.NewKeyword("end-line"), int(1189))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_negate") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_negate is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-negate-int + { + var tmp1 lang.FnFunc + { // function unchecked-negate-int__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := checkDerefVar(glojure_DOT_core_seq) + tmp12 := checkDerefVar(glojure_DOT_core_concat) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/Unchecked_int_negate")}) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("unchecked-negate-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the negation of x, an int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(26), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1182), lang.NewKeyword("end-line"), int(1182))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_negate") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_negate is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-remainder-int + { + var tmp1 lang.FnFunc + { // function unchecked-remainder-int__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_seq) + tmp6 := checkDerefVar(glojure_DOT_core_concat) + tmp7 := checkDerefVar(glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{lang.NewSymbol(".")}) + tmp9 := checkDerefVar(glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := checkDerefVar(glojure_DOT_core_seq) + tmp13 := checkDerefVar(glojure_DOT_core_concat) + tmp14 := checkDerefVar(glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("glojure.core/Unchecked_int_remainder")}) + tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("unchecked-remainder-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the remainder of division of x by y, both int.\n Note - uses a primitive operator subject to truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(29), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1245), lang.NewKeyword("end-line"), int(1245))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_remainder") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_remainder is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-short + { + var tmp1 lang.FnFunc + { // function unchecked-short__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := checkDerefVar(glojure_DOT_core_seq) + tmp12 := checkDerefVar(glojure_DOT_core_concat) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/UncheckedShortCast")}) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("unchecked-short").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to short. Subject to rounding or truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3523), lang.NewKeyword("end-line"), int(3523))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5 := lang.Apply(lang.UncheckedShortCast, []any{v4}) + return tmp5 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-subtract + { + var tmp1 lang.FnFunc + { // function unchecked-subtract__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_seq) + tmp6 := checkDerefVar(glojure_DOT_core_concat) + tmp7 := checkDerefVar(glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{lang.NewSymbol(".")}) + tmp9 := checkDerefVar(glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := checkDerefVar(glojure_DOT_core_seq) + tmp13 := checkDerefVar(glojure_DOT_core_concat) + tmp14 := checkDerefVar(glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("glojure.core/Unchecked_minus")}) + tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("unchecked-subtract").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the difference of x and y, both long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1217), lang.NewKeyword("end-line"), int(1217))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_minus") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_minus is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-subtract-int + { + var tmp1 lang.FnFunc + { // function unchecked-subtract-int__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_seq) + tmp6 := checkDerefVar(glojure_DOT_core_concat) + tmp7 := checkDerefVar(glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{lang.NewSymbol(".")}) + tmp9 := checkDerefVar(glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := checkDerefVar(glojure_DOT_core_seq) + tmp13 := checkDerefVar(glojure_DOT_core_concat) + tmp14 := checkDerefVar(glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("glojure.core/Unchecked_int_subtract")}) + tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("unchecked-subtract-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the difference of x and y, both int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1210), lang.NewKeyword("end-line"), int(1210))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_subtract") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_subtract is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // underive + { + tmp0 := lang.NewSymbol("underive").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag"), lang.NewSymbol("parent")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"), lang.NewSymbol("parent"))), lang.NewKeyword("doc"), "Removes a parent/child relationship between parent and\n tag. h must be a hierarchy obtained from make-hierarchy, if not\n supplied defaults to, and modifies, the global hierarchy.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5643), lang.NewKeyword("end-line"), int(5643))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_alter_var_root) + tmp6 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("global-hierarchy")) + tmp7 := checkDerefVar(glojure_DOT_core_underive) + tmp8 := lang.Apply(tmp5, []any{tmp6, tmp7, v3, v4}) + _ = tmp8 + return nil + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var tmp6 any + { // let + // let binding "parentMap" + tmp7 := lang.Apply(lang.NewKeyword("parents"), []any{v3}) + var v8 any = tmp7 + _ = v8 + // let binding "childsParents" + var tmp9 any + tmp10 := lang.Apply(v8, []any{v4}) + if lang.IsTruthy(tmp10) { + tmp11 := checkDerefVar(glojure_DOT_core_disj) + tmp12 := lang.Apply(v8, []any{v4}) + tmp13 := lang.Apply(tmp11, []any{tmp12, v5}) + tmp9 = tmp13 + } else { + tmp14 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5652), lang.NewKeyword("column"), int(36), lang.NewKeyword("end-line"), int(5652), lang.NewKeyword("end-column"), int(38)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp9 = tmp16 + } + var v17 any = tmp9 + _ = v17 + // let binding "newParents" + var tmp18 any + tmp19 := checkDerefVar(glojure_DOT_core_not_empty) + tmp20 := lang.Apply(tmp19, []any{v17}) + if lang.IsTruthy(tmp20) { + tmp21 := checkDerefVar(glojure_DOT_core_assoc) + tmp22 := lang.Apply(tmp21, []any{v8, v4, v17}) + tmp18 = tmp22 + } else { + tmp23 := checkDerefVar(glojure_DOT_core_dissoc) + tmp24 := lang.Apply(tmp23, []any{v8, v4}) + tmp18 = tmp24 + } + var v25 any = tmp18 + _ = v25 + // let binding "deriv-seq" + tmp26 := checkDerefVar(glojure_DOT_core_flatten) + tmp27 := checkDerefVar(glojure_DOT_core_map) + var tmp28 lang.FnFunc + tmp28 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v29 := args[0] + _ = v29 + tmp30 := checkDerefVar(glojure_DOT_core_cons) + tmp31 := checkDerefVar(glojure_DOT_core_key) + tmp32 := lang.Apply(tmp31, []any{v29}) + tmp33 := checkDerefVar(glojure_DOT_core_interpose) + tmp34 := checkDerefVar(glojure_DOT_core_key) + tmp35 := lang.Apply(tmp34, []any{v29}) + tmp36 := checkDerefVar(glojure_DOT_core_val) + tmp37 := lang.Apply(tmp36, []any{v29}) + tmp38 := lang.Apply(tmp33, []any{tmp35, tmp37}) + tmp39 := lang.Apply(tmp30, []any{tmp32, tmp38}) + return tmp39 + }) + tmp29 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5656), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(5656), lang.NewKeyword("end-column"), int(70)) + tmp30, err := lang.WithMeta(tmp28, tmp29.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp31 := checkDerefVar(glojure_DOT_core_seq) + tmp32 := lang.Apply(tmp31, []any{v25}) + tmp33 := lang.Apply(tmp27, []any{tmp30, tmp32}) + tmp34 := lang.Apply(tmp26, []any{tmp33}) + var v35 any = tmp34 + _ = v35 + var tmp36 any + tmp37 := checkDerefVar(glojure_DOT_core_contains_QMARK_) + tmp38 := lang.Apply(v8, []any{v4}) + tmp39 := lang.Apply(tmp37, []any{tmp38, v5}) + if lang.IsTruthy(tmp39) { + tmp40 := checkDerefVar(glojure_DOT_core_reduce1) + var tmp41 lang.FnFunc + tmp41 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v42 := args[0] + _ = v42 + v43 := args[1] + _ = v43 + tmp44 := checkDerefVar(glojure_DOT_core_apply) + tmp45 := checkDerefVar(glojure_DOT_core_derive) + tmp46 := lang.Apply(tmp44, []any{tmp45, v42, v43}) + return tmp46 + }) + tmp42 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5659), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5659), lang.NewKeyword("end-column"), int(31)) + tmp43, err := lang.WithMeta(tmp41, tmp42.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp44 := checkDerefVar(glojure_DOT_core_make_hierarchy) + tmp45 := lang.Apply(tmp44, nil) + tmp46 := checkDerefVar(glojure_DOT_core_partition) + tmp47 := lang.Apply(tmp46, []any{int64(2), v35}) + tmp48 := lang.Apply(tmp40, []any{tmp43, tmp45, tmp47}) + tmp36 = tmp48 + } else { + tmp36 = v3 + } + tmp6 = tmp36 + } // end let + return tmp6 + default: + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unquote + { + tmp0 := lang.NewSymbol("unquote").WithMeta(lang.NewMap()).(*lang.Symbol) + tmp1 := ns.Intern(tmp0) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unquote-splicing + { + tmp0 := lang.NewSymbol("unquote-splicing").WithMeta(lang.NewMap()).(*lang.Symbol) + tmp1 := ns.Intern(tmp0) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unreduced + { + tmp0 := lang.NewSymbol("unreduced").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "If x is reduced?, returns (deref x), else returns x", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2847), lang.NewKeyword("end-line"), int(2847))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(glojure_DOT_core_reduced_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + tmp7 := checkDerefVar(glojure_DOT_core_deref) + tmp8 := lang.Apply(tmp7, []any{v3}) + tmp4 = tmp8 + } else { + tmp4 = v3 + } + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unsigned-bit-shift-right + { + var tmp1 lang.FnFunc + { // function unsigned-bit-shift-right__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_seq) + tmp6 := checkDerefVar(glojure_DOT_core_concat) + tmp7 := checkDerefVar(glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{lang.NewSymbol(".")}) + tmp9 := checkDerefVar(glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := checkDerefVar(glojure_DOT_core_seq) + tmp13 := checkDerefVar(glojure_DOT_core_concat) + tmp14 := checkDerefVar(glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("glojure.core/UnsignedShiftRight")}) + tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("unsigned-bit-shift-right").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Bitwise shift right, without sign-extension.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(30), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1373), lang.NewKeyword("end-line"), int(1373))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "UnsignedShiftRight") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("UnsignedShiftRight is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // update + { + tmp0 := lang.NewSymbol("update").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f"), lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("z")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("z"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "'Updates' a value in an associative structure, where k is a\n key and f is a function that will take the old value\n and any supplied args and return the new value, and returns a new\n structure. If the key does not exist, nil is passed as the old value.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6174), lang.NewKeyword("end-line"), int(6174))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6 := checkDerefVar(glojure_DOT_core_assoc) + tmp7 := checkDerefVar(glojure_DOT_core_get) + tmp8 := lang.Apply(tmp7, []any{v3, v4}) + tmp9 := lang.Apply(v5, []any{tmp8}) + tmp10 := lang.Apply(tmp6, []any{v3, v4, tmp9}) + return tmp10 + case 4: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_assoc) + tmp8 := checkDerefVar(glojure_DOT_core_get) + tmp9 := lang.Apply(tmp8, []any{v3, v4}) + tmp10 := lang.Apply(v5, []any{tmp9, v6}) + tmp11 := lang.Apply(tmp7, []any{v3, v4, tmp10}) + return tmp11 + case 5: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := args[4] + _ = v7 + tmp8 := checkDerefVar(glojure_DOT_core_assoc) + tmp9 := checkDerefVar(glojure_DOT_core_get) + tmp10 := lang.Apply(tmp9, []any{v3, v4}) + tmp11 := lang.Apply(v5, []any{tmp10, v6, v7}) + tmp12 := lang.Apply(tmp8, []any{v3, v4, tmp11}) + return tmp12 + case 6: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := args[4] + _ = v7 + v8 := args[5] + _ = v8 + tmp9 := checkDerefVar(glojure_DOT_core_assoc) + tmp10 := checkDerefVar(glojure_DOT_core_get) + tmp11 := lang.Apply(tmp10, []any{v3, v4}) + tmp12 := lang.Apply(v5, []any{tmp11, v6, v7, v8}) + tmp13 := lang.Apply(tmp9, []any{v3, v4, tmp12}) + return tmp13 + default: + if len(args) < 6 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := args[4] + _ = v7 + v8 := args[5] + _ = v8 + var v9 any = lang.NewList(args[6:]...) + _ = v9 + tmp10 := checkDerefVar(glojure_DOT_core_assoc) + tmp11 := checkDerefVar(glojure_DOT_core_apply) + tmp12 := checkDerefVar(glojure_DOT_core_get) + tmp13 := lang.Apply(tmp12, []any{v3, v4}) + tmp14 := lang.Apply(tmp11, []any{v5, tmp13, v6, v7, v8, v9}) + tmp15 := lang.Apply(tmp10, []any{v3, v4, tmp14}) + return tmp15 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // update-in + { + tmp0 := lang.NewSymbol("update-in").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("ks"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "'Updates' a value in a nested associative structure, where ks is a\n sequence of keys and f is a function that will take the old value\n and any supplied args and return the new value, and returns a new\n nested structure. If any levels do not exist, hash-maps will be\n created.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6158), lang.NewKeyword("end-line"), int(6158))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any + { // let + // let binding "up" + var tmp8 lang.FnFunc + { // function up + var v9 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + v12 := args[2] + _ = v12 + v13 := args[3] + _ = v13 + var tmp14 any + { // let + // let binding "vec__141" + var v15 any = v11 + _ = v15 + // let binding "seq__142" + tmp16 := checkDerefVar(glojure_DOT_core_seq) + tmp17 := lang.Apply(tmp16, []any{v15}) + var v18 any = tmp17 + _ = v18 + // let binding "first__143" + tmp19 := checkDerefVar(glojure_DOT_core_first) + tmp20 := lang.Apply(tmp19, []any{v18}) + var v21 any = tmp20 + _ = v21 + // let binding "seq__142" + tmp22 := checkDerefVar(glojure_DOT_core_next) + tmp23 := lang.Apply(tmp22, []any{v18}) + var v24 any = tmp23 + _ = v24 + // let binding "k" + var v25 any = v21 + _ = v25 + // let binding "ks" + var v26 any = v24 + _ = v26 + var tmp27 any + if lang.IsTruthy(v26) { + tmp28 := checkDerefVar(glojure_DOT_core_assoc) + tmp29 := checkDerefVar(glojure_DOT_core_get) + tmp30 := lang.Apply(tmp29, []any{v10, v25}) + tmp31 := lang.Apply(v9, []any{tmp30, v26, v12, v13}) + tmp32 := lang.Apply(tmp28, []any{v10, v25, tmp31}) + tmp27 = tmp32 + } else { + tmp33 := checkDerefVar(glojure_DOT_core_assoc) + tmp34 := checkDerefVar(glojure_DOT_core_apply) + tmp35 := checkDerefVar(glojure_DOT_core_get) + tmp36 := lang.Apply(tmp35, []any{v10, v25}) + tmp37 := lang.Apply(tmp34, []any{v12, tmp36, v13}) + tmp38 := lang.Apply(tmp33, []any{v10, v25, tmp37}) + tmp27 = tmp38 + } + tmp14 = tmp27 + } // end let + return tmp14 + }) + v9 = tmp8 + _ = v9 + } + tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6167), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(6171), lang.NewKeyword("end-column"), int(59)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v11 any = tmp10 + _ = v11 + tmp12 := lang.Apply(v11, []any{v3, v4, v5, v6}) + tmp7 = tmp12 + } // end let + return tmp7 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // update-keys + { + tmp0 := lang.NewSymbol("update-keys").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("f"))), lang.NewKeyword("doc"), "m f => {(f k) v ...}\n\n Given a map m and a function f of 1-argument, returns a new map whose\n keys are the result of applying f to the keys of m, mapped to the\n corresponding values of m.\n f must return a unique key for each key of m, else the behavior is undefined.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7906), lang.NewKeyword("end-line"), int(7906))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 any + { // let + // let binding "ret" + tmp6 := checkDerefVar(glojure_DOT_core_persistent_BANG_) + tmp7 := checkDerefVar(glojure_DOT_core_reduce_kv) + var tmp8 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v9 := args[0] + _ = v9 + v10 := args[1] + _ = v10 + v11 := args[2] + _ = v11 + tmp12 := checkDerefVar(glojure_DOT_core_assoc_BANG_) + tmp13 := lang.Apply(v4, []any{v10}) + tmp14 := lang.Apply(tmp12, []any{v9, tmp13, v11}) + return tmp14 + }) + tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7916), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7916), lang.NewKeyword("end-column"), int(59)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp11 := checkDerefVar(glojure_DOT_core_transient) + tmp12 := lang.NewMap() + tmp13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7917), lang.NewKeyword("column"), int(36), lang.NewKeyword("end-line"), int(7917), lang.NewKeyword("end-column"), int(37)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp15 := lang.Apply(tmp11, []any{tmp14}) + tmp16 := lang.Apply(tmp7, []any{tmp10, tmp15, v3}) + tmp17 := lang.Apply(tmp6, []any{tmp16}) + var v18 any = tmp17 + _ = v18 + tmp19 := checkDerefVar(glojure_DOT_core_with_meta) + tmp20 := checkDerefVar(glojure_DOT_core_meta) + tmp21 := lang.Apply(tmp20, []any{v3}) + tmp22 := lang.Apply(tmp19, []any{v18, tmp21}) + tmp5 = tmp22 + } // end let + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // update-vals + { + tmp0 := lang.NewSymbol("update-vals").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("f"))), lang.NewKeyword("doc"), "m f => {k (f v) ...}\n\n Given a map m and a function f of 1-argument, returns a new map where the keys of m\n are mapped to result of applying f to the corresponding values of m.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7890), lang.NewKeyword("end-line"), int(7890))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_with_meta) + tmp6 := checkDerefVar(glojure_DOT_core_persistent_BANG_) + tmp7 := checkDerefVar(glojure_DOT_core_reduce_kv) + var tmp8 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v9 := args[0] + _ = v9 + v10 := args[1] + _ = v10 + v11 := args[2] + _ = v11 + tmp12 := checkDerefVar(glojure_DOT_core_assoc_BANG_) + tmp13 := lang.Apply(v4, []any{v11}) + tmp14 := lang.Apply(tmp12, []any{v9, v10, tmp13}) + return tmp14 + }) + tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7899), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(7899), lang.NewKeyword("end-column"), int(51)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var tmp11 any + tmp12 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp13 := reflect.TypeOf((*lang.IEditableCollection)(nil)).Elem() + tmp14 := lang.Apply(tmp12, []any{tmp13, v3}) + if lang.IsTruthy(tmp14) { + tmp15 := checkDerefVar(glojure_DOT_core_transient) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp11 = tmp16 + } else { + tmp17 := checkDerefVar(glojure_DOT_core_transient) + tmp18 := lang.NewMap() + tmp19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7902), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(7902), lang.NewKeyword("end-column"), int(31)) + tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp21 := lang.Apply(tmp17, []any{tmp20}) + tmp11 = tmp21 + } + tmp22 := lang.Apply(tmp7, []any{tmp10, tmp11, v3}) + tmp23 := lang.Apply(tmp6, []any{tmp22}) + tmp24 := checkDerefVar(glojure_DOT_core_meta) + tmp25 := lang.Apply(tmp24, []any{v3}) + tmp26 := lang.Apply(tmp5, []any{tmp23, tmp25}) + return tmp26 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // uri? + { + tmp0 := lang.NewSymbol("uri?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a java.net.URI", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7877), lang.NewKeyword("end-line"), int(7877))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp5 := reflect.TypeOf((*url4.URL)(nil)).Elem() + tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // use + { + tmp0 := lang.NewSymbol("use").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Like 'require, but also refers to each lib's namespace using\n glojure.core/refer. Use :use in the ns macro in preference to calling\n this directly.\n\n 'use accepts additional options in libspecs: :exclude, :only, :rename.\n The arguments and semantics for :exclude, :only, and :rename are the same\n as those documented for glojure.core/refer.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6079), lang.NewKeyword("end-line"), int(6079))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 0 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_apply) + tmp5 := checkDerefVar(glojure_DOT_core_load_libs) + tmp6 := lang.Apply(tmp4, []any{tmp5, lang.NewKeyword("require"), lang.NewKeyword("use"), v3}) + return tmp6 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // uuid? + { + tmp0 := lang.NewSymbol("uuid?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a java.util.UUID", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6847), lang.NewKeyword("end-line"), int(6847))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp5 := reflect.TypeOf([16]uint8{}) + tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // val + { + tmp0 := lang.NewSymbol("val").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("e"))), lang.NewKeyword("doc"), "Returns the value in the map entry.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1570), lang.NewKeyword("end-line"), int(1570))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v3, "GetValue") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("GetValue is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // vals + { + tmp0 := lang.NewSymbol("vals").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"))), lang.NewKeyword("doc"), "Returns a sequence of the map's values, in the same order as (seq map).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1557), lang.NewKeyword("end-line"), int(1557))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.Vals, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // var-get + { + tmp0 := lang.NewSymbol("var-get").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Gets the value in the var object", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4326), lang.NewKeyword("end-line"), int(4326))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v3, "Get") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Get is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // var-set + { + tmp0 := lang.NewSymbol("var-set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Sets the value in the var object to val. The var must be\n thread-locally bound.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4332), lang.NewKeyword("end-line"), int(4332))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(v3, "Set") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Set is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // var? + { + tmp0 := lang.NewSymbol("var?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("v"))), lang.NewKeyword("doc"), "Returns true if v is of type glojure.lang.Var", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4999), lang.NewKeyword("end-line"), int(4999))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp5 := reflect.TypeOf((*lang.Var)(nil)) + tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // vary-meta + { + tmp0 := lang.NewSymbol("vary-meta").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("obj"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Returns an object of the same type and value as obj, with\n (apply f (meta obj) args) as its metadata.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(668), lang.NewKeyword("end-line"), int(668))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := checkDerefVar(glojure_DOT_core_with_meta) + tmp7 := checkDerefVar(glojure_DOT_core_apply) + tmp8 := checkDerefVar(glojure_DOT_core_meta) + tmp9 := lang.Apply(tmp8, []any{v3}) + tmp10 := lang.Apply(tmp7, []any{v4, tmp9, v5}) + tmp11 := lang.Apply(tmp6, []any{v3, tmp10}) + return tmp11 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // vec + { + tmp0 := lang.NewSymbol("vec").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Creates a new vector containing the contents of coll. Java arrays\n will be aliased and should not be modified.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(366), lang.NewKeyword("end-line"), int(366))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + var tmp7 any + tmp8 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp9 := reflect.TypeOf((*lang.IObj)(nil)).Elem() + tmp10 := lang.Apply(tmp8, []any{tmp9, v3}) + if lang.IsTruthy(tmp10) { + tmp11 := checkDerefVar(glojure_DOT_core_with_meta) + tmp12 := lang.Apply(tmp11, []any{v3, nil}) + tmp7 = tmp12 + } else { + tmp13 := lang.Apply(lang.CreateLazilyPersistentVector, []any{v3}) + tmp7 = tmp13 + } + tmp4 = tmp7 + } else { + tmp14 := lang.Apply(lang.CreateLazilyPersistentVector, []any{v3}) + tmp4 = tmp14 + } + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // vector + { + tmp0 := lang.NewSymbol("vector").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("a")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d"), lang.NewSymbol("e")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d"), lang.NewSymbol("e"), lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d"), lang.NewSymbol("e"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Creates a new vector containing the args.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(352), lang.NewKeyword("end-line"), int(352))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp3 := lang.NewVector() + tmp4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(356), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(356), lang.NewKeyword("end-column"), int(8)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 1: + v3 := args[0] + _ = v3 + tmp4 := lang.NewVector(v3) + tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(357), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(357), lang.NewKeyword("end-column"), int(10)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.NewVector(v3, v4) + tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(358), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(358), lang.NewKeyword("end-column"), int(14)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp7 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6 := lang.NewVector(v3, v4, v5) + tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(359), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(359), lang.NewKeyword("end-column"), int(18)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp8 + case 4: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + tmp7 := lang.NewVector(v3, v4, v5, v6) + tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(360), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(360), lang.NewKeyword("end-column"), int(22)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp9 + case 5: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := args[4] + _ = v7 + tmp8 := lang.NewVector(v3, v4, v5, v6, v7) + tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(361), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(361), lang.NewKeyword("end-column"), int(25)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp10 + case 6: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := args[4] + _ = v7 + v8 := args[5] + _ = v8 + tmp9 := lang.NewVector(v3, v4, v5, v6, v7, v8) + tmp10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(362), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(362), lang.NewKeyword("end-column"), int(29)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp11 + default: + if len(args) < 6 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + v7 := args[4] + _ = v7 + v8 := args[5] + _ = v8 + var v9 any = lang.NewList(args[6:]...) + _ = v9 + tmp10 := checkDerefVar(glojure_DOT_core_cons) + tmp11 := checkDerefVar(glojure_DOT_core_cons) + tmp12 := checkDerefVar(glojure_DOT_core_cons) + tmp13 := checkDerefVar(glojure_DOT_core_cons) + tmp14 := checkDerefVar(glojure_DOT_core_cons) + tmp15 := checkDerefVar(glojure_DOT_core_cons) + tmp16 := lang.Apply(tmp15, []any{v8, v9}) + tmp17 := lang.Apply(tmp14, []any{v7, tmp16}) + tmp18 := lang.Apply(tmp13, []any{v6, tmp17}) + tmp19 := lang.Apply(tmp12, []any{v5, tmp18}) + tmp20 := lang.Apply(tmp11, []any{v4, tmp19}) + tmp21 := lang.Apply(tmp10, []any{v3, tmp20}) + tmp22 := lang.Apply(lang.CreateLazilyPersistentVector, []any{tmp21}) + return tmp22 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // vector? + { + tmp0 := lang.NewSymbol("vector?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x implements IPersistentVector", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(174), lang.NewKeyword("end-line"), int(178))).(*lang.Symbol) + var tmp2 lang.FnFunc + { // function vector? + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp6 := reflect.TypeOf((*lang.IPersistentVector)(nil)).Elem() + tmp7 := lang.Apply(tmp5, []any{tmp6, v4}) + return tmp7 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(178), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(178), lang.NewKeyword("end-column"), int(106))).(lang.FnFunc) + v3 = tmp2 + _ = v3 + } + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // volatile! + { + tmp1 := reflect.TypeOf((*lang.Volatile)(nil)).Elem() + tmp0 := lang.NewSymbol("volatile!").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Creates and returns a Volatile with an initial value of val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2517), lang.NewKeyword("end-line"), int(2517))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5 := lang.Apply(lang.NewVolatile, []any{v4}) + return tmp5 + }) + tmp4 := reflect.TypeOf((*lang.Volatile)(nil)).Elem() + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // volatile? + { + tmp0 := lang.NewSymbol("volatile?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is a volatile.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2540), lang.NewKeyword("end-line"), int(2540))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp5 := reflect.TypeOf((*lang.Volatile)(nil)).Elem() + tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // vreset! + { + tmp0 := lang.NewSymbol("vreset!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("vol"), lang.NewSymbol("newval"))), lang.NewKeyword("doc"), "Sets the value of volatile to newval without regard for the\n current value. Returns newval.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2524), lang.NewKeyword("end-line"), int(2524))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(v3, "reset") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // vswap! + { + tmp0 := lang.NewSymbol("vswap!").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("vol"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Non-atomically swaps the value of the volatile as if:\n (apply f current-value-of-vol args). Returns the value that\n was swapped in.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(2531), lang.NewKeyword("end-line"), int(2531))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 4 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + v6 := args[3] + _ = v6 + var v7 any = lang.NewList(args[4:]...) + _ = v7 + var tmp8 any + { // let + // let binding "v" + tmp9 := checkDerefVar(glojure_DOT_core_with_meta) + tmp10 := lang.NewMap(lang.NewKeyword("tag"), lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Volatile")) + tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2537), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(2537), lang.NewKeyword("end-column"), int(81)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := lang.Apply(tmp9, []any{v5, tmp12}) + var v14 any = tmp13 + _ = v14 + tmp15 := checkDerefVar(glojure_DOT_core_seq) + tmp16 := checkDerefVar(glojure_DOT_core_concat) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol(".reset")}) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v14}) + tmp21 := checkDerefVar(glojure_DOT_core_list) + tmp22 := checkDerefVar(glojure_DOT_core_seq) + tmp23 := checkDerefVar(glojure_DOT_core_concat) + tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v6}) + tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp27 := checkDerefVar(glojure_DOT_core_seq) + tmp28 := checkDerefVar(glojure_DOT_core_concat) + tmp29 := checkDerefVar(glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol(".Deref")}) + tmp31 := checkDerefVar(glojure_DOT_core_list) + tmp32 := lang.Apply(tmp31, []any{v14}) + tmp33 := lang.Apply(tmp28, []any{tmp30, tmp32}) + tmp34 := lang.Apply(tmp27, []any{tmp33}) + tmp35 := lang.Apply(tmp26, []any{tmp34}) + tmp36 := lang.Apply(tmp23, []any{tmp25, tmp35, v7}) + tmp37 := lang.Apply(tmp22, []any{tmp36}) + tmp38 := lang.Apply(tmp21, []any{tmp37}) + tmp39 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp38}) + tmp40 := lang.Apply(tmp15, []any{tmp39}) + tmp8 = tmp40 + } // end let + return tmp8 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // when + { + tmp0 := lang.NewSymbol("when").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("test"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Evaluates test. If logical true, evaluates body in an implicit do.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(492), lang.NewKeyword("end-line"), int(492))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_list) + tmp8 := checkDerefVar(glojure_DOT_core_cons) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("do"), v6}) + tmp10 := lang.Apply(tmp7, []any{lang.NewSymbol("if"), v5, tmp9}) + return tmp10 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // when-first + { + tmp0 := lang.NewSymbol("when-first").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "bindings => x xs\n\n Roughly the same as (when (seq xs) (let [x (first xs)] body)) but xs is evaluated only once", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4622), lang.NewKeyword("end-line"), int(4622))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any + tmp8 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp9 := lang.Apply(tmp8, []any{v5}) + if lang.IsTruthy(tmp9) { + } else { + tmp10 := checkDerefVar(glojure_DOT_core_str) + tmp11 := checkDerefVar(glojure_DOT_core_first) + tmp12 := lang.Apply(tmp11, []any{v3}) + tmp13 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) + tmp14 := checkDerefVar(glojure_DOT_core_meta) + tmp15 := lang.Apply(tmp14, []any{v3}) + tmp16 := lang.Apply(lang.NewKeyword("line"), []any{tmp15}) + tmp17 := lang.Apply(tmp10, []any{tmp12, " requires ", "a vector for its binding", " in ", tmp13, ":", tmp16}) + tmp18 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp17}) + panic(tmp18) + } + _ = tmp7 + var tmp19 any + tmp20 := checkDerefVar(glojure_DOT_core__EQ_) + tmp21 := checkDerefVar(glojure_DOT_core_count) + tmp22 := lang.Apply(tmp21, []any{v5}) + tmp23 := lang.Apply(tmp20, []any{int64(2), tmp22}) + if lang.IsTruthy(tmp23) { + } else { + tmp24 := checkDerefVar(glojure_DOT_core_str) + tmp25 := checkDerefVar(glojure_DOT_core_first) + tmp26 := lang.Apply(tmp25, []any{v3}) + tmp27 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) + tmp28 := checkDerefVar(glojure_DOT_core_meta) + tmp29 := lang.Apply(tmp28, []any{v3}) + tmp30 := lang.Apply(lang.NewKeyword("line"), []any{tmp29}) + tmp31 := lang.Apply(tmp24, []any{tmp26, " requires ", "exactly 2 forms in binding vector", " in ", tmp27, ":", tmp30}) + tmp32 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp31}) + panic(tmp32) + } + _ = tmp19 + var tmp33 any + { // let + // let binding "vec__20" + var v34 any = v5 + _ = v34 + // let binding "x" + tmp35 := checkDerefVar(glojure_DOT_core_nth) + tmp36 := lang.Apply(tmp35, []any{v34, int64(0), nil}) + var v37 any = tmp36 + _ = v37 + // let binding "xs" + tmp38 := checkDerefVar(glojure_DOT_core_nth) + tmp39 := lang.Apply(tmp38, []any{v34, int64(1), nil}) + var v40 any = tmp39 + _ = v40 + tmp41 := checkDerefVar(glojure_DOT_core_seq) + tmp42 := checkDerefVar(glojure_DOT_core_concat) + tmp43 := checkDerefVar(glojure_DOT_core_list) + tmp44 := lang.Apply(tmp43, []any{lang.NewSymbol("glojure.core/when-let")}) + tmp45 := checkDerefVar(glojure_DOT_core_list) + tmp46 := checkDerefVar(glojure_DOT_core_apply) + tmp47 := checkDerefVar(glojure_DOT_core_vector) + tmp48 := checkDerefVar(glojure_DOT_core_seq) + tmp49 := checkDerefVar(glojure_DOT_core_concat) + tmp50 := checkDerefVar(glojure_DOT_core_list) + tmp51 := lang.Apply(tmp50, []any{lang.NewSymbol("xs__0__auto__")}) + tmp52 := checkDerefVar(glojure_DOT_core_list) + tmp53 := checkDerefVar(glojure_DOT_core_seq) + tmp54 := checkDerefVar(glojure_DOT_core_concat) + tmp55 := checkDerefVar(glojure_DOT_core_list) + tmp56 := lang.Apply(tmp55, []any{lang.NewSymbol("glojure.core/seq")}) + tmp57 := checkDerefVar(glojure_DOT_core_list) + tmp58 := lang.Apply(tmp57, []any{v40}) + tmp59 := lang.Apply(tmp54, []any{tmp56, tmp58}) + tmp60 := lang.Apply(tmp53, []any{tmp59}) + tmp61 := lang.Apply(tmp52, []any{tmp60}) + tmp62 := lang.Apply(tmp49, []any{tmp51, tmp61}) + tmp63 := lang.Apply(tmp48, []any{tmp62}) + tmp64 := lang.Apply(tmp46, []any{tmp47, tmp63}) + tmp65 := lang.Apply(tmp45, []any{tmp64}) + tmp66 := checkDerefVar(glojure_DOT_core_list) + tmp67 := checkDerefVar(glojure_DOT_core_seq) + tmp68 := checkDerefVar(glojure_DOT_core_concat) + tmp69 := checkDerefVar(glojure_DOT_core_list) + tmp70 := lang.Apply(tmp69, []any{lang.NewSymbol("glojure.core/let")}) + tmp71 := checkDerefVar(glojure_DOT_core_list) + tmp72 := checkDerefVar(glojure_DOT_core_apply) + tmp73 := checkDerefVar(glojure_DOT_core_vector) + tmp74 := checkDerefVar(glojure_DOT_core_seq) + tmp75 := checkDerefVar(glojure_DOT_core_concat) + tmp76 := checkDerefVar(glojure_DOT_core_list) + tmp77 := lang.Apply(tmp76, []any{v37}) + tmp78 := checkDerefVar(glojure_DOT_core_list) + tmp79 := checkDerefVar(glojure_DOT_core_seq) + tmp80 := checkDerefVar(glojure_DOT_core_concat) + tmp81 := checkDerefVar(glojure_DOT_core_list) + tmp82 := lang.Apply(tmp81, []any{lang.NewSymbol("glojure.core/first")}) + tmp83 := checkDerefVar(glojure_DOT_core_list) + tmp84 := lang.Apply(tmp83, []any{lang.NewSymbol("xs__0__auto__")}) + tmp85 := lang.Apply(tmp80, []any{tmp82, tmp84}) + tmp86 := lang.Apply(tmp79, []any{tmp85}) + tmp87 := lang.Apply(tmp78, []any{tmp86}) + tmp88 := lang.Apply(tmp75, []any{tmp77, tmp87}) + tmp89 := lang.Apply(tmp74, []any{tmp88}) + tmp90 := lang.Apply(tmp72, []any{tmp73, tmp89}) + tmp91 := lang.Apply(tmp71, []any{tmp90}) + tmp92 := lang.Apply(tmp68, []any{tmp70, tmp91, v6}) + tmp93 := lang.Apply(tmp67, []any{tmp92}) + tmp94 := lang.Apply(tmp66, []any{tmp93}) + tmp95 := lang.Apply(tmp42, []any{tmp44, tmp65, tmp94}) + tmp96 := lang.Apply(tmp41, []any{tmp95}) + tmp33 = tmp96 + } // end let + return tmp33 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // when-let + { + tmp0 := lang.NewSymbol("when-let").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "bindings => binding-form test\n\n When test is true, evaluates body with binding-form bound to the value of test", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1859), lang.NewKeyword("end-line"), int(1859))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any + tmp8 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp9 := lang.Apply(tmp8, []any{v5}) + if lang.IsTruthy(tmp9) { + } else { + tmp10 := checkDerefVar(glojure_DOT_core_str) + tmp11 := checkDerefVar(glojure_DOT_core_first) + tmp12 := lang.Apply(tmp11, []any{v3}) + tmp13 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) + tmp14 := checkDerefVar(glojure_DOT_core_meta) + tmp15 := lang.Apply(tmp14, []any{v3}) + tmp16 := lang.Apply(lang.NewKeyword("line"), []any{tmp15}) + tmp17 := lang.Apply(tmp10, []any{tmp12, " requires ", "a vector for its binding", " in ", tmp13, ":", tmp16}) + tmp18 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp17}) + panic(tmp18) + } + _ = tmp7 + var tmp19 any + tmp20 := checkDerefVar(glojure_DOT_core__EQ_) + tmp21 := checkDerefVar(glojure_DOT_core_count) + tmp22 := lang.Apply(tmp21, []any{v5}) + tmp23 := lang.Apply(tmp20, []any{int64(2), tmp22}) + if lang.IsTruthy(tmp23) { + } else { + tmp24 := checkDerefVar(glojure_DOT_core_str) + tmp25 := checkDerefVar(glojure_DOT_core_first) + tmp26 := lang.Apply(tmp25, []any{v3}) + tmp27 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) + tmp28 := checkDerefVar(glojure_DOT_core_meta) + tmp29 := lang.Apply(tmp28, []any{v3}) + tmp30 := lang.Apply(lang.NewKeyword("line"), []any{tmp29}) + tmp31 := lang.Apply(tmp24, []any{tmp26, " requires ", "exactly 2 forms in binding vector", " in ", tmp27, ":", tmp30}) + tmp32 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp31}) + panic(tmp32) + } + _ = tmp19 + var tmp33 any + { // let + // let binding "form" + tmp34 := lang.Apply(v5, []any{int64(0)}) + var v35 any = tmp34 + _ = v35 + // let binding "tst" + tmp36 := lang.Apply(v5, []any{int64(1)}) + var v37 any = tmp36 + _ = v37 + tmp38 := checkDerefVar(glojure_DOT_core_seq) + tmp39 := checkDerefVar(glojure_DOT_core_concat) + tmp40 := checkDerefVar(glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{lang.NewSymbol("glojure.core/let")}) + tmp42 := checkDerefVar(glojure_DOT_core_list) + tmp43 := checkDerefVar(glojure_DOT_core_apply) + tmp44 := checkDerefVar(glojure_DOT_core_vector) + tmp45 := checkDerefVar(glojure_DOT_core_seq) + tmp46 := checkDerefVar(glojure_DOT_core_concat) + tmp47 := checkDerefVar(glojure_DOT_core_list) + tmp48 := lang.Apply(tmp47, []any{lang.NewSymbol("temp__0__auto__")}) + tmp49 := checkDerefVar(glojure_DOT_core_list) + tmp50 := lang.Apply(tmp49, []any{v37}) + tmp51 := lang.Apply(tmp46, []any{tmp48, tmp50}) + tmp52 := lang.Apply(tmp45, []any{tmp51}) + tmp53 := lang.Apply(tmp43, []any{tmp44, tmp52}) + tmp54 := lang.Apply(tmp42, []any{tmp53}) + tmp55 := checkDerefVar(glojure_DOT_core_list) + tmp56 := checkDerefVar(glojure_DOT_core_seq) + tmp57 := checkDerefVar(glojure_DOT_core_concat) + tmp58 := checkDerefVar(glojure_DOT_core_list) + tmp59 := lang.Apply(tmp58, []any{lang.NewSymbol("glojure.core/when")}) + tmp60 := checkDerefVar(glojure_DOT_core_list) + tmp61 := lang.Apply(tmp60, []any{lang.NewSymbol("temp__0__auto__")}) + tmp62 := checkDerefVar(glojure_DOT_core_list) + tmp63 := checkDerefVar(glojure_DOT_core_seq) + tmp64 := checkDerefVar(glojure_DOT_core_concat) + tmp65 := checkDerefVar(glojure_DOT_core_list) + tmp66 := lang.Apply(tmp65, []any{lang.NewSymbol("glojure.core/let")}) + tmp67 := checkDerefVar(glojure_DOT_core_list) + tmp68 := checkDerefVar(glojure_DOT_core_apply) + tmp69 := checkDerefVar(glojure_DOT_core_vector) + tmp70 := checkDerefVar(glojure_DOT_core_seq) + tmp71 := checkDerefVar(glojure_DOT_core_concat) + tmp72 := checkDerefVar(glojure_DOT_core_list) + tmp73 := lang.Apply(tmp72, []any{v35}) + tmp74 := checkDerefVar(glojure_DOT_core_list) + tmp75 := lang.Apply(tmp74, []any{lang.NewSymbol("temp__0__auto__")}) + tmp76 := lang.Apply(tmp71, []any{tmp73, tmp75}) + tmp77 := lang.Apply(tmp70, []any{tmp76}) + tmp78 := lang.Apply(tmp68, []any{tmp69, tmp77}) + tmp79 := lang.Apply(tmp67, []any{tmp78}) + tmp80 := lang.Apply(tmp64, []any{tmp66, tmp79, v6}) + tmp81 := lang.Apply(tmp63, []any{tmp80}) + tmp82 := lang.Apply(tmp62, []any{tmp81}) + tmp83 := lang.Apply(tmp57, []any{tmp59, tmp61, tmp82}) + tmp84 := lang.Apply(tmp56, []any{tmp83}) + tmp85 := lang.Apply(tmp55, []any{tmp84}) + tmp86 := lang.Apply(tmp39, []any{tmp41, tmp54, tmp85}) + tmp87 := lang.Apply(tmp38, []any{tmp86}) + tmp33 = tmp87 + } // end let + return tmp33 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // when-not + { + tmp0 := lang.NewSymbol("when-not").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("test"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Evaluates test. If logical false, evaluates body in an implicit do.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(498), lang.NewKeyword("end-line"), int(498))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_list) + tmp8 := checkDerefVar(glojure_DOT_core_cons) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("do"), v6}) + tmp10 := lang.Apply(tmp7, []any{lang.NewSymbol("if"), v5, nil, tmp9}) + return tmp10 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // when-some + { + tmp0 := lang.NewSymbol("when-some").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "bindings => binding-form test\n\n When test is not nil, evaluates body with binding-form bound to the\n value of test", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1894), lang.NewKeyword("end-line"), int(1894))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any + tmp8 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp9 := lang.Apply(tmp8, []any{v5}) + if lang.IsTruthy(tmp9) { + } else { + tmp10 := checkDerefVar(glojure_DOT_core_str) + tmp11 := checkDerefVar(glojure_DOT_core_first) + tmp12 := lang.Apply(tmp11, []any{v3}) + tmp13 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) + tmp14 := checkDerefVar(glojure_DOT_core_meta) + tmp15 := lang.Apply(tmp14, []any{v3}) + tmp16 := lang.Apply(lang.NewKeyword("line"), []any{tmp15}) + tmp17 := lang.Apply(tmp10, []any{tmp12, " requires ", "a vector for its binding", " in ", tmp13, ":", tmp16}) + tmp18 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp17}) + panic(tmp18) + } + _ = tmp7 + var tmp19 any + tmp20 := checkDerefVar(glojure_DOT_core__EQ_) + tmp21 := checkDerefVar(glojure_DOT_core_count) + tmp22 := lang.Apply(tmp21, []any{v5}) + tmp23 := lang.Apply(tmp20, []any{int64(2), tmp22}) + if lang.IsTruthy(tmp23) { + } else { + tmp24 := checkDerefVar(glojure_DOT_core_str) + tmp25 := checkDerefVar(glojure_DOT_core_first) + tmp26 := lang.Apply(tmp25, []any{v3}) + tmp27 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) + tmp28 := checkDerefVar(glojure_DOT_core_meta) + tmp29 := lang.Apply(tmp28, []any{v3}) + tmp30 := lang.Apply(lang.NewKeyword("line"), []any{tmp29}) + tmp31 := lang.Apply(tmp24, []any{tmp26, " requires ", "exactly 2 forms in binding vector", " in ", tmp27, ":", tmp30}) + tmp32 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp31}) + panic(tmp32) + } + _ = tmp19 + var tmp33 any + { // let + // let binding "form" + tmp34 := lang.Apply(v5, []any{int64(0)}) + var v35 any = tmp34 + _ = v35 + // let binding "tst" + tmp36 := lang.Apply(v5, []any{int64(1)}) + var v37 any = tmp36 + _ = v37 + tmp38 := checkDerefVar(glojure_DOT_core_seq) + tmp39 := checkDerefVar(glojure_DOT_core_concat) + tmp40 := checkDerefVar(glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{lang.NewSymbol("glojure.core/let")}) + tmp42 := checkDerefVar(glojure_DOT_core_list) + tmp43 := checkDerefVar(glojure_DOT_core_apply) + tmp44 := checkDerefVar(glojure_DOT_core_vector) + tmp45 := checkDerefVar(glojure_DOT_core_seq) + tmp46 := checkDerefVar(glojure_DOT_core_concat) + tmp47 := checkDerefVar(glojure_DOT_core_list) + tmp48 := lang.Apply(tmp47, []any{lang.NewSymbol("temp__0__auto__")}) + tmp49 := checkDerefVar(glojure_DOT_core_list) + tmp50 := lang.Apply(tmp49, []any{v37}) + tmp51 := lang.Apply(tmp46, []any{tmp48, tmp50}) + tmp52 := lang.Apply(tmp45, []any{tmp51}) + tmp53 := lang.Apply(tmp43, []any{tmp44, tmp52}) + tmp54 := lang.Apply(tmp42, []any{tmp53}) + tmp55 := checkDerefVar(glojure_DOT_core_list) + tmp56 := checkDerefVar(glojure_DOT_core_seq) + tmp57 := checkDerefVar(glojure_DOT_core_concat) + tmp58 := checkDerefVar(glojure_DOT_core_list) + tmp59 := lang.Apply(tmp58, []any{lang.NewSymbol("if")}) + tmp60 := checkDerefVar(glojure_DOT_core_list) + tmp61 := checkDerefVar(glojure_DOT_core_seq) + tmp62 := checkDerefVar(glojure_DOT_core_concat) + tmp63 := checkDerefVar(glojure_DOT_core_list) + tmp64 := lang.Apply(tmp63, []any{lang.NewSymbol("glojure.core/nil?")}) + tmp65 := checkDerefVar(glojure_DOT_core_list) + tmp66 := lang.Apply(tmp65, []any{lang.NewSymbol("temp__0__auto__")}) + tmp67 := lang.Apply(tmp62, []any{tmp64, tmp66}) + tmp68 := lang.Apply(tmp61, []any{tmp67}) + tmp69 := lang.Apply(tmp60, []any{tmp68}) + tmp70 := checkDerefVar(glojure_DOT_core_list) + tmp71 := lang.Apply(tmp70, []any{nil}) + tmp72 := checkDerefVar(glojure_DOT_core_list) + tmp73 := checkDerefVar(glojure_DOT_core_seq) + tmp74 := checkDerefVar(glojure_DOT_core_concat) + tmp75 := checkDerefVar(glojure_DOT_core_list) + tmp76 := lang.Apply(tmp75, []any{lang.NewSymbol("glojure.core/let")}) + tmp77 := checkDerefVar(glojure_DOT_core_list) + tmp78 := checkDerefVar(glojure_DOT_core_apply) + tmp79 := checkDerefVar(glojure_DOT_core_vector) + tmp80 := checkDerefVar(glojure_DOT_core_seq) + tmp81 := checkDerefVar(glojure_DOT_core_concat) + tmp82 := checkDerefVar(glojure_DOT_core_list) + tmp83 := lang.Apply(tmp82, []any{v35}) + tmp84 := checkDerefVar(glojure_DOT_core_list) + tmp85 := lang.Apply(tmp84, []any{lang.NewSymbol("temp__0__auto__")}) + tmp86 := lang.Apply(tmp81, []any{tmp83, tmp85}) + tmp87 := lang.Apply(tmp80, []any{tmp86}) + tmp88 := lang.Apply(tmp78, []any{tmp79, tmp87}) + tmp89 := lang.Apply(tmp77, []any{tmp88}) + tmp90 := lang.Apply(tmp74, []any{tmp76, tmp89, v6}) + tmp91 := lang.Apply(tmp73, []any{tmp90}) + tmp92 := lang.Apply(tmp72, []any{tmp91}) + tmp93 := lang.Apply(tmp57, []any{tmp59, tmp69, tmp71, tmp92}) + tmp94 := lang.Apply(tmp56, []any{tmp93}) + tmp95 := lang.Apply(tmp55, []any{tmp94}) + tmp96 := lang.Apply(tmp39, []any{tmp41, tmp54, tmp95}) + tmp97 := lang.Apply(tmp38, []any{tmp96}) + tmp33 = tmp97 + } // end let + return tmp33 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // while + { + tmp0 := lang.NewSymbol("while").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("test"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Repeatedly executes body while test expression is true. Presumes\n some side-effect will cause test to become false/nil. Returns nil", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6327), lang.NewKeyword("end-line"), int(6327))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_seq) + tmp8 := checkDerefVar(glojure_DOT_core_concat) + tmp9 := checkDerefVar(glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("glojure.core/loop")}) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := checkDerefVar(glojure_DOT_core_apply) + tmp13 := checkDerefVar(glojure_DOT_core_vector) + tmp14 := checkDerefVar(glojure_DOT_core_seq) + tmp15 := checkDerefVar(glojure_DOT_core_concat) + tmp16 := lang.Apply(tmp15, nil) + tmp17 := lang.Apply(tmp14, []any{tmp16}) + tmp18 := lang.Apply(tmp12, []any{tmp13, tmp17}) + tmp19 := lang.Apply(tmp11, []any{tmp18}) + tmp20 := checkDerefVar(glojure_DOT_core_list) + tmp21 := checkDerefVar(glojure_DOT_core_seq) + tmp22 := checkDerefVar(glojure_DOT_core_concat) + tmp23 := checkDerefVar(glojure_DOT_core_list) + tmp24 := lang.Apply(tmp23, []any{lang.NewSymbol("glojure.core/when")}) + tmp25 := checkDerefVar(glojure_DOT_core_list) + tmp26 := lang.Apply(tmp25, []any{v5}) + tmp27 := checkDerefVar(glojure_DOT_core_list) + tmp28 := checkDerefVar(glojure_DOT_core_seq) + tmp29 := checkDerefVar(glojure_DOT_core_concat) + tmp30 := checkDerefVar(glojure_DOT_core_list) + tmp31 := lang.Apply(tmp30, []any{lang.NewSymbol("recur")}) + tmp32 := lang.Apply(tmp29, []any{tmp31}) + tmp33 := lang.Apply(tmp28, []any{tmp32}) + tmp34 := lang.Apply(tmp27, []any{tmp33}) + tmp35 := lang.Apply(tmp22, []any{tmp24, tmp26, v6, tmp34}) + tmp36 := lang.Apply(tmp21, []any{tmp35}) + tmp37 := lang.Apply(tmp20, []any{tmp36}) + tmp38 := lang.Apply(tmp8, []any{tmp10, tmp19, tmp37}) + tmp39 := lang.Apply(tmp7, []any{tmp38}) + return tmp39 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // with-bindings + { + tmp0 := lang.NewSymbol("with-bindings").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("binding-map"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Takes a map of Var/value pairs. Installs for the given Vars the associated\n values as thread-local bindings. Then executes body. Pops the installed\n bindings after body was evaluated. Returns the value of body.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1984), lang.NewKeyword("end-line"), int(1984))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_seq) + tmp8 := checkDerefVar(glojure_DOT_core_concat) + tmp9 := checkDerefVar(glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("glojure.core/with-bindings*")}) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{v5}) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := checkDerefVar(glojure_DOT_core_seq) + tmp15 := checkDerefVar(glojure_DOT_core_concat) + tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("glojure.core/fn")}) + tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp19 := checkDerefVar(glojure_DOT_core_apply) + tmp20 := checkDerefVar(glojure_DOT_core_vector) + tmp21 := checkDerefVar(glojure_DOT_core_seq) + tmp22 := checkDerefVar(glojure_DOT_core_concat) + tmp23 := lang.Apply(tmp22, nil) + tmp24 := lang.Apply(tmp21, []any{tmp23}) + tmp25 := lang.Apply(tmp19, []any{tmp20, tmp24}) + tmp26 := lang.Apply(tmp18, []any{tmp25}) + tmp27 := lang.Apply(tmp15, []any{tmp17, tmp26, v6}) + tmp28 := lang.Apply(tmp14, []any{tmp27}) + tmp29 := lang.Apply(tmp13, []any{tmp28}) + tmp30 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp29}) + tmp31 := lang.Apply(tmp7, []any{tmp30}) + return tmp31 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // with-bindings* + { + tmp0 := lang.NewSymbol("with-bindings*").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("binding-map"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Takes a map of Var/value pairs. Installs for the given Vars the associated\n values as thread-local bindings. Then calls f with the supplied arguments.\n Pops the installed bindings after f returned. Returns whatever f returns.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1971), lang.NewKeyword("end-line"), int(1971))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := checkDerefVar(glojure_DOT_core_push_thread_bindings) + tmp7 := lang.Apply(tmp6, []any{v3}) + _ = tmp7 + var tmp8 any + func() { + defer func() { + tmp9 := checkDerefVar(glojure_DOT_core_pop_thread_bindings) + tmp10 := lang.Apply(tmp9, nil) + _ = tmp10 + }() + tmp11 := checkDerefVar(glojure_DOT_core_apply) + tmp12 := lang.Apply(tmp11, []any{v4, v5}) + tmp8 = tmp12 + }() + return tmp8 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // with-in-str + { + tmp0 := lang.NewSymbol("with-in-str").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Evaluates body in a context in which *in* is bound to a fresh\n StringReader initialized with the string s.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4749), lang.NewKeyword("end-line"), int(4749))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_seq) + tmp8 := checkDerefVar(glojure_DOT_core_concat) + tmp9 := checkDerefVar(glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("glojure.core/with-open")}) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := checkDerefVar(glojure_DOT_core_apply) + tmp13 := checkDerefVar(glojure_DOT_core_vector) + tmp14 := checkDerefVar(glojure_DOT_core_seq) + tmp15 := checkDerefVar(glojure_DOT_core_concat) + tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("s__0__auto__")}) + tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp19 := checkDerefVar(glojure_DOT_core_seq) + tmp20 := checkDerefVar(glojure_DOT_core_concat) + tmp21 := checkDerefVar(glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("glojure.core/->")}) + tmp23 := checkDerefVar(glojure_DOT_core_list) + tmp24 := checkDerefVar(glojure_DOT_core_seq) + tmp25 := checkDerefVar(glojure_DOT_core_concat) + tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{lang.NewSymbol("java.io.StringReader.")}) + tmp28 := checkDerefVar(glojure_DOT_core_list) + tmp29 := lang.Apply(tmp28, []any{v5}) + tmp30 := lang.Apply(tmp25, []any{tmp27, tmp29}) + tmp31 := lang.Apply(tmp24, []any{tmp30}) + tmp32 := lang.Apply(tmp23, []any{tmp31}) + tmp33 := checkDerefVar(glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{lang.NewSymbol("glojure.lang.LineNumberingPushbackReader.")}) + tmp35 := lang.Apply(tmp20, []any{tmp22, tmp32, tmp34}) + tmp36 := lang.Apply(tmp19, []any{tmp35}) + tmp37 := lang.Apply(tmp18, []any{tmp36}) + tmp38 := lang.Apply(tmp15, []any{tmp17, tmp37}) + tmp39 := lang.Apply(tmp14, []any{tmp38}) + tmp40 := lang.Apply(tmp12, []any{tmp13, tmp39}) + tmp41 := lang.Apply(tmp11, []any{tmp40}) + tmp42 := checkDerefVar(glojure_DOT_core_list) + tmp43 := checkDerefVar(glojure_DOT_core_seq) + tmp44 := checkDerefVar(glojure_DOT_core_concat) + tmp45 := checkDerefVar(glojure_DOT_core_list) + tmp46 := lang.Apply(tmp45, []any{lang.NewSymbol("glojure.core/binding")}) + tmp47 := checkDerefVar(glojure_DOT_core_list) + tmp48 := checkDerefVar(glojure_DOT_core_apply) + tmp49 := checkDerefVar(glojure_DOT_core_vector) + tmp50 := checkDerefVar(glojure_DOT_core_seq) + tmp51 := checkDerefVar(glojure_DOT_core_concat) + tmp52 := checkDerefVar(glojure_DOT_core_list) + tmp53 := lang.Apply(tmp52, []any{lang.NewSymbol("glojure.core/*in*")}) + tmp54 := checkDerefVar(glojure_DOT_core_list) + tmp55 := lang.Apply(tmp54, []any{lang.NewSymbol("s__0__auto__")}) + tmp56 := lang.Apply(tmp51, []any{tmp53, tmp55}) + tmp57 := lang.Apply(tmp50, []any{tmp56}) + tmp58 := lang.Apply(tmp48, []any{tmp49, tmp57}) + tmp59 := lang.Apply(tmp47, []any{tmp58}) + tmp60 := lang.Apply(tmp44, []any{tmp46, tmp59, v6}) + tmp61 := lang.Apply(tmp43, []any{tmp60}) + tmp62 := lang.Apply(tmp42, []any{tmp61}) + tmp63 := lang.Apply(tmp8, []any{tmp10, tmp41, tmp62}) + tmp64 := lang.Apply(tmp7, []any{tmp63}) + return tmp64 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // with-loading-context + { + tmp0 := lang.NewSymbol("with-loading-context").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5734), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5734), lang.NewKeyword("end-column"), int(30), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("macro"), true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := checkDerefVar(glojure_DOT_core_seq) + tmp7 := checkDerefVar(glojure_DOT_core_concat) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := checkDerefVar(glojure_DOT_core_seq) + tmp10 := checkDerefVar(glojure_DOT_core_concat) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{lang.NewSymbol("glojure.core/fn")}) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("loading__0__auto__")}) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := checkDerefVar(glojure_DOT_core_apply) + tmp17 := checkDerefVar(glojure_DOT_core_vector) + tmp18 := checkDerefVar(glojure_DOT_core_seq) + tmp19 := checkDerefVar(glojure_DOT_core_concat) + tmp20 := lang.Apply(tmp19, nil) + tmp21 := lang.Apply(tmp18, []any{tmp20}) + tmp22 := lang.Apply(tmp16, []any{tmp17, tmp21}) + tmp23 := lang.Apply(tmp15, []any{tmp22}) + tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp25 := checkDerefVar(glojure_DOT_core_seq) + tmp26 := checkDerefVar(glojure_DOT_core_concat) + tmp27 := checkDerefVar(glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.PushThreadBindings")}) + tmp29 := checkDerefVar(glojure_DOT_core_list) + tmp30 := checkDerefVar(glojure_DOT_core_apply) + tmp31 := checkDerefVar(glojure_DOT_core_hash_map) + tmp32 := checkDerefVar(glojure_DOT_core_seq) + tmp33 := checkDerefVar(glojure_DOT_core_concat) + tmp34 := lang.Apply(tmp33, nil) + tmp35 := lang.Apply(tmp32, []any{tmp34}) + tmp36 := lang.Apply(tmp30, []any{tmp31, tmp35}) + tmp37 := lang.Apply(tmp29, []any{tmp36}) + tmp38 := lang.Apply(tmp26, []any{tmp28, tmp37}) + tmp39 := lang.Apply(tmp25, []any{tmp38}) + tmp40 := lang.Apply(tmp24, []any{tmp39}) + tmp41 := checkDerefVar(glojure_DOT_core_list) + tmp42 := checkDerefVar(glojure_DOT_core_seq) + tmp43 := checkDerefVar(glojure_DOT_core_concat) + tmp44 := checkDerefVar(glojure_DOT_core_list) + tmp45 := lang.Apply(tmp44, []any{lang.NewSymbol("try")}) + tmp46 := checkDerefVar(glojure_DOT_core_list) + tmp47 := checkDerefVar(glojure_DOT_core_seq) + tmp48 := checkDerefVar(glojure_DOT_core_concat) + tmp49 := checkDerefVar(glojure_DOT_core_list) + tmp50 := lang.Apply(tmp49, []any{lang.NewSymbol("finally")}) + tmp51 := checkDerefVar(glojure_DOT_core_list) + tmp52 := checkDerefVar(glojure_DOT_core_seq) + tmp53 := checkDerefVar(glojure_DOT_core_concat) + tmp54 := checkDerefVar(glojure_DOT_core_list) + tmp55 := lang.Apply(tmp54, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.PopThreadBindings")}) + tmp56 := lang.Apply(tmp53, []any{tmp55}) + tmp57 := lang.Apply(tmp52, []any{tmp56}) + tmp58 := lang.Apply(tmp51, []any{tmp57}) + tmp59 := lang.Apply(tmp48, []any{tmp50, tmp58}) + tmp60 := lang.Apply(tmp47, []any{tmp59}) + tmp61 := lang.Apply(tmp46, []any{tmp60}) + tmp62 := lang.Apply(tmp43, []any{tmp45, v5, tmp61}) + tmp63 := lang.Apply(tmp42, []any{tmp62}) + tmp64 := lang.Apply(tmp41, []any{tmp63}) + tmp65 := lang.Apply(tmp10, []any{tmp12, tmp14, tmp23, tmp40, tmp64}) + tmp66 := lang.Apply(tmp9, []any{tmp65}) + tmp67 := lang.Apply(tmp8, []any{tmp66}) + tmp68 := lang.Apply(tmp7, []any{tmp67}) + tmp69 := lang.Apply(tmp6, []any{tmp68}) + return tmp69 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // with-local-vars + { + tmp0 := lang.NewSymbol("with-local-vars").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name-vals-vec"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "varbinding=> symbol init-expr\n\n Executes the exprs in a context in which the symbols are bound to\n vars with per-thread bindings to the init-exprs. The symbols refer\n to the var objects themselves, and must be accessed with var-get and\n var-set", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4339), lang.NewKeyword("end-line"), int(4339))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any + tmp8 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp9 := lang.Apply(tmp8, []any{v5}) + if lang.IsTruthy(tmp9) { + } else { + tmp10 := checkDerefVar(glojure_DOT_core_str) + tmp11 := checkDerefVar(glojure_DOT_core_first) + tmp12 := lang.Apply(tmp11, []any{v3}) + tmp13 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) + tmp14 := checkDerefVar(glojure_DOT_core_meta) + tmp15 := lang.Apply(tmp14, []any{v3}) + tmp16 := lang.Apply(lang.NewKeyword("line"), []any{tmp15}) + tmp17 := lang.Apply(tmp10, []any{tmp12, " requires ", "a vector for its binding", " in ", tmp13, ":", tmp16}) + tmp18 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp17}) + panic(tmp18) + } + _ = tmp7 + var tmp19 any + tmp20 := checkDerefVar(glojure_DOT_core_even_QMARK_) + tmp21 := checkDerefVar(glojure_DOT_core_count) + tmp22 := lang.Apply(tmp21, []any{v5}) + tmp23 := lang.Apply(tmp20, []any{tmp22}) + if lang.IsTruthy(tmp23) { + } else { + tmp24 := checkDerefVar(glojure_DOT_core_str) + tmp25 := checkDerefVar(glojure_DOT_core_first) + tmp26 := lang.Apply(tmp25, []any{v3}) + tmp27 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) + tmp28 := checkDerefVar(glojure_DOT_core_meta) + tmp29 := lang.Apply(tmp28, []any{v3}) + tmp30 := lang.Apply(lang.NewKeyword("line"), []any{tmp29}) + tmp31 := lang.Apply(tmp24, []any{tmp26, " requires ", "an even number of forms in binding vector", " in ", tmp27, ":", tmp30}) + tmp32 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp31}) + panic(tmp32) + } + _ = tmp19 + tmp33 := checkDerefVar(glojure_DOT_core_seq) + tmp34 := checkDerefVar(glojure_DOT_core_concat) + tmp35 := checkDerefVar(glojure_DOT_core_list) + tmp36 := lang.Apply(tmp35, []any{lang.NewSymbol("glojure.core/let")}) + tmp37 := checkDerefVar(glojure_DOT_core_list) + tmp38 := checkDerefVar(glojure_DOT_core_apply) + tmp39 := checkDerefVar(glojure_DOT_core_vector) + tmp40 := checkDerefVar(glojure_DOT_core_seq) + tmp41 := checkDerefVar(glojure_DOT_core_concat) + tmp42 := checkDerefVar(glojure_DOT_core_interleave) + tmp43 := checkDerefVar(glojure_DOT_core_take_nth) + tmp44 := lang.Apply(tmp43, []any{int64(2), v5}) + tmp45 := checkDerefVar(glojure_DOT_core_repeat) + tmp46 := lang.Apply(tmp45, []any{lang.NewList(lang.NewSymbol(".."), lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.*Var"), lang.NewSymbol("create"), lang.NewSymbol("setDynamic"))}) + tmp47 := lang.Apply(tmp42, []any{tmp44, tmp46}) + tmp48 := lang.Apply(tmp41, []any{tmp47}) + tmp49 := lang.Apply(tmp40, []any{tmp48}) + tmp50 := lang.Apply(tmp38, []any{tmp39, tmp49}) + tmp51 := lang.Apply(tmp37, []any{tmp50}) + tmp52 := checkDerefVar(glojure_DOT_core_list) + tmp53 := checkDerefVar(glojure_DOT_core_seq) + tmp54 := checkDerefVar(glojure_DOT_core_concat) + tmp55 := checkDerefVar(glojure_DOT_core_list) + tmp56 := lang.Apply(tmp55, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.PushThreadBindings")}) + tmp57 := checkDerefVar(glojure_DOT_core_list) + tmp58 := checkDerefVar(glojure_DOT_core_apply) + tmp59 := checkDerefVar(glojure_DOT_core_hash_map) + tmp60 := checkDerefVar(glojure_DOT_core_seq) + tmp61 := checkDerefVar(glojure_DOT_core_concat) + tmp62 := lang.Apply(tmp61, nil) + tmp63 := lang.Apply(tmp60, []any{tmp62}) + tmp64 := lang.Apply(tmp58, []any{tmp59, tmp63}) + tmp65 := lang.Apply(tmp57, []any{tmp64}) + tmp66 := lang.Apply(tmp54, []any{tmp56, tmp65}) + tmp67 := lang.Apply(tmp53, []any{tmp66}) + tmp68 := lang.Apply(tmp52, []any{tmp67}) + tmp69 := checkDerefVar(glojure_DOT_core_list) + tmp70 := checkDerefVar(glojure_DOT_core_seq) + tmp71 := checkDerefVar(glojure_DOT_core_concat) + tmp72 := checkDerefVar(glojure_DOT_core_list) + tmp73 := lang.Apply(tmp72, []any{lang.NewSymbol("try")}) + tmp74 := checkDerefVar(glojure_DOT_core_list) + tmp75 := checkDerefVar(glojure_DOT_core_seq) + tmp76 := checkDerefVar(glojure_DOT_core_concat) + tmp77 := checkDerefVar(glojure_DOT_core_list) + tmp78 := lang.Apply(tmp77, []any{lang.NewSymbol("finally")}) + tmp79 := checkDerefVar(glojure_DOT_core_list) + tmp80 := checkDerefVar(glojure_DOT_core_seq) + tmp81 := checkDerefVar(glojure_DOT_core_concat) + tmp82 := checkDerefVar(glojure_DOT_core_list) + tmp83 := lang.Apply(tmp82, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.PopThreadBindings")}) + tmp84 := lang.Apply(tmp81, []any{tmp83}) + tmp85 := lang.Apply(tmp80, []any{tmp84}) + tmp86 := lang.Apply(tmp79, []any{tmp85}) + tmp87 := lang.Apply(tmp76, []any{tmp78, tmp86}) + tmp88 := lang.Apply(tmp75, []any{tmp87}) + tmp89 := lang.Apply(tmp74, []any{tmp88}) + tmp90 := lang.Apply(tmp71, []any{tmp73, v6, tmp89}) + tmp91 := lang.Apply(tmp70, []any{tmp90}) + tmp92 := lang.Apply(tmp69, []any{tmp91}) + tmp93 := lang.Apply(tmp34, []any{tmp36, tmp51, tmp68, tmp92}) + tmp94 := lang.Apply(tmp33, []any{tmp93}) + return tmp94 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // with-meta + { + tmp0 := lang.NewSymbol("with-meta").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("obj"), lang.NewSymbol("m"))), lang.NewKeyword("doc"), "Returns an object of the same type and value as obj, with\n map m as its metadata.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(211), lang.NewKeyword("end-line"), int(216))).(*lang.Symbol) + var tmp2 lang.FnFunc + { // function with-meta + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(v4, "WithMeta") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("WithMeta is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v5}) + return tmp7 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(216), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(217), lang.NewKeyword("end-column"), int(32))).(lang.FnFunc) + v3 = tmp2 + _ = v3 + } + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // with-open + { + tmp0 := lang.NewSymbol("with-open").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "bindings => [name init ...]\n\n Evaluates body in a try expression with names bound to the values\n of the inits, and a finally clause that calls (.close name) on each\n name in reverse order.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3832), lang.NewKeyword("end-line"), int(3832))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any + tmp8 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp9 := lang.Apply(tmp8, []any{v5}) + if lang.IsTruthy(tmp9) { + } else { + tmp10 := checkDerefVar(glojure_DOT_core_str) + tmp11 := checkDerefVar(glojure_DOT_core_first) + tmp12 := lang.Apply(tmp11, []any{v3}) + tmp13 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) + tmp14 := checkDerefVar(glojure_DOT_core_meta) + tmp15 := lang.Apply(tmp14, []any{v3}) + tmp16 := lang.Apply(lang.NewKeyword("line"), []any{tmp15}) + tmp17 := lang.Apply(tmp10, []any{tmp12, " requires ", "a vector for its binding", " in ", tmp13, ":", tmp16}) + tmp18 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp17}) + panic(tmp18) + } + _ = tmp7 + var tmp19 any + tmp20 := checkDerefVar(glojure_DOT_core_even_QMARK_) + tmp21 := checkDerefVar(glojure_DOT_core_count) + tmp22 := lang.Apply(tmp21, []any{v5}) + tmp23 := lang.Apply(tmp20, []any{tmp22}) + if lang.IsTruthy(tmp23) { + } else { + tmp24 := checkDerefVar(glojure_DOT_core_str) + tmp25 := checkDerefVar(glojure_DOT_core_first) + tmp26 := lang.Apply(tmp25, []any{v3}) + tmp27 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) + tmp28 := checkDerefVar(glojure_DOT_core_meta) + tmp29 := lang.Apply(tmp28, []any{v3}) + tmp30 := lang.Apply(lang.NewKeyword("line"), []any{tmp29}) + tmp31 := lang.Apply(tmp24, []any{tmp26, " requires ", "an even number of forms in binding vector", " in ", tmp27, ":", tmp30}) + tmp32 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp31}) + panic(tmp32) + } + _ = tmp19 + var tmp33 any + tmp34 := checkDerefVar(glojure_DOT_core__EQ_) + tmp35 := checkDerefVar(glojure_DOT_core_count) + tmp36 := lang.Apply(tmp35, []any{v5}) + tmp37 := lang.Apply(tmp34, []any{tmp36, int64(0)}) + if lang.IsTruthy(tmp37) { + tmp38 := checkDerefVar(glojure_DOT_core_seq) + tmp39 := checkDerefVar(glojure_DOT_core_concat) + tmp40 := checkDerefVar(glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{lang.NewSymbol("do")}) + tmp42 := lang.Apply(tmp39, []any{tmp41, v6}) + tmp43 := lang.Apply(tmp38, []any{tmp42}) + tmp33 = tmp43 + } else { + var tmp44 any + tmp45 := checkDerefVar(glojure_DOT_core_symbol_QMARK_) + tmp46 := lang.Apply(v5, []any{int64(0)}) + tmp47 := lang.Apply(tmp45, []any{tmp46}) + if lang.IsTruthy(tmp47) { + tmp48 := checkDerefVar(glojure_DOT_core_seq) + tmp49 := checkDerefVar(glojure_DOT_core_concat) + tmp50 := checkDerefVar(glojure_DOT_core_list) + tmp51 := lang.Apply(tmp50, []any{lang.NewSymbol("glojure.core/let")}) + tmp52 := checkDerefVar(glojure_DOT_core_list) + tmp53 := checkDerefVar(glojure_DOT_core_subvec) + tmp54 := lang.Apply(tmp53, []any{v5, int64(0), int64(2)}) + tmp55 := lang.Apply(tmp52, []any{tmp54}) + tmp56 := checkDerefVar(glojure_DOT_core_list) + tmp57 := checkDerefVar(glojure_DOT_core_seq) + tmp58 := checkDerefVar(glojure_DOT_core_concat) + tmp59 := checkDerefVar(glojure_DOT_core_list) + tmp60 := lang.Apply(tmp59, []any{lang.NewSymbol("try")}) + tmp61 := checkDerefVar(glojure_DOT_core_list) + tmp62 := checkDerefVar(glojure_DOT_core_seq) + tmp63 := checkDerefVar(glojure_DOT_core_concat) + tmp64 := checkDerefVar(glojure_DOT_core_list) + tmp65 := lang.Apply(tmp64, []any{lang.NewSymbol("glojure.core/with-open")}) + tmp66 := checkDerefVar(glojure_DOT_core_list) + tmp67 := checkDerefVar(glojure_DOT_core_subvec) + tmp68 := lang.Apply(tmp67, []any{v5, int64(2)}) + tmp69 := lang.Apply(tmp66, []any{tmp68}) + tmp70 := lang.Apply(tmp63, []any{tmp65, tmp69, v6}) + tmp71 := lang.Apply(tmp62, []any{tmp70}) + tmp72 := lang.Apply(tmp61, []any{tmp71}) + tmp73 := checkDerefVar(glojure_DOT_core_list) + tmp74 := checkDerefVar(glojure_DOT_core_seq) + tmp75 := checkDerefVar(glojure_DOT_core_concat) + tmp76 := checkDerefVar(glojure_DOT_core_list) + tmp77 := lang.Apply(tmp76, []any{lang.NewSymbol("finally")}) + tmp78 := checkDerefVar(glojure_DOT_core_list) + tmp79 := checkDerefVar(glojure_DOT_core_seq) + tmp80 := checkDerefVar(glojure_DOT_core_concat) + tmp81 := checkDerefVar(glojure_DOT_core_list) + tmp82 := lang.Apply(tmp81, []any{lang.NewSymbol(".")}) + tmp83 := checkDerefVar(glojure_DOT_core_list) + tmp84 := lang.Apply(v5, []any{int64(0)}) + tmp85 := lang.Apply(tmp83, []any{tmp84}) + tmp86 := checkDerefVar(glojure_DOT_core_list) + tmp87 := lang.Apply(tmp86, []any{lang.NewSymbol("close")}) + tmp88 := lang.Apply(tmp80, []any{tmp82, tmp85, tmp87}) + tmp89 := lang.Apply(tmp79, []any{tmp88}) + tmp90 := lang.Apply(tmp78, []any{tmp89}) + tmp91 := lang.Apply(tmp75, []any{tmp77, tmp90}) + tmp92 := lang.Apply(tmp74, []any{tmp91}) + tmp93 := lang.Apply(tmp73, []any{tmp92}) + tmp94 := lang.Apply(tmp58, []any{tmp60, tmp72, tmp93}) + tmp95 := lang.Apply(tmp57, []any{tmp94}) + tmp96 := lang.Apply(tmp56, []any{tmp95}) + tmp97 := lang.Apply(tmp49, []any{tmp51, tmp55, tmp96}) + tmp98 := lang.Apply(tmp48, []any{tmp97}) + tmp44 = tmp98 + } else { + var tmp99 any + if lang.IsTruthy(lang.NewKeyword("else")) { + tmp100 := lang.Apply(lang.NewIllegalArgumentError, []any{"with-open only allows Symbols in bindings"}) + panic(tmp100) + } else { + } + tmp44 = tmp99 + } + tmp33 = tmp44 + } + return tmp33 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // with-out-str + { + tmp0 := lang.NewSymbol("with-out-str").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Evaluates exprs in a context in which *out* is bound to a fresh\n StringWriter. Returns the string created by any nested printing\n calls.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4738), lang.NewKeyword("end-line"), int(4738))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := checkDerefVar(glojure_DOT_core_seq) + tmp7 := checkDerefVar(glojure_DOT_core_concat) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("glojure.core/let")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := checkDerefVar(glojure_DOT_core_apply) + tmp12 := checkDerefVar(glojure_DOT_core_vector) + tmp13 := checkDerefVar(glojure_DOT_core_seq) + tmp14 := checkDerefVar(glojure_DOT_core_concat) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("s__0__auto__")}) + tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp18 := checkDerefVar(glojure_DOT_core_seq) + tmp19 := checkDerefVar(glojure_DOT_core_concat) + tmp20 := checkDerefVar(glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{lang.NewSymbol("new")}) + tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{lang.NewSymbol("strings.Builder")}) + tmp24 := lang.Apply(tmp19, []any{tmp21, tmp23}) + tmp25 := lang.Apply(tmp18, []any{tmp24}) + tmp26 := lang.Apply(tmp17, []any{tmp25}) + tmp27 := lang.Apply(tmp14, []any{tmp16, tmp26}) + tmp28 := lang.Apply(tmp13, []any{tmp27}) + tmp29 := lang.Apply(tmp11, []any{tmp12, tmp28}) + tmp30 := lang.Apply(tmp10, []any{tmp29}) + tmp31 := checkDerefVar(glojure_DOT_core_list) + tmp32 := checkDerefVar(glojure_DOT_core_seq) + tmp33 := checkDerefVar(glojure_DOT_core_concat) + tmp34 := checkDerefVar(glojure_DOT_core_list) + tmp35 := lang.Apply(tmp34, []any{lang.NewSymbol("glojure.core/binding")}) + tmp36 := checkDerefVar(glojure_DOT_core_list) + tmp37 := checkDerefVar(glojure_DOT_core_apply) + tmp38 := checkDerefVar(glojure_DOT_core_vector) + tmp39 := checkDerefVar(glojure_DOT_core_seq) + tmp40 := checkDerefVar(glojure_DOT_core_concat) + tmp41 := checkDerefVar(glojure_DOT_core_list) + tmp42 := lang.Apply(tmp41, []any{lang.NewSymbol("glojure.core/*out*")}) + tmp43 := checkDerefVar(glojure_DOT_core_list) + tmp44 := lang.Apply(tmp43, []any{lang.NewSymbol("s__0__auto__")}) + tmp45 := lang.Apply(tmp40, []any{tmp42, tmp44}) + tmp46 := lang.Apply(tmp39, []any{tmp45}) + tmp47 := lang.Apply(tmp37, []any{tmp38, tmp46}) + tmp48 := lang.Apply(tmp36, []any{tmp47}) + tmp49 := checkDerefVar(glojure_DOT_core_list) + tmp50 := checkDerefVar(glojure_DOT_core_seq) + tmp51 := checkDerefVar(glojure_DOT_core_concat) + tmp52 := checkDerefVar(glojure_DOT_core_list) + tmp53 := lang.Apply(tmp52, []any{lang.NewSymbol("glojure.core/str")}) + tmp54 := checkDerefVar(glojure_DOT_core_list) + tmp55 := lang.Apply(tmp54, []any{lang.NewSymbol("s__0__auto__")}) + tmp56 := lang.Apply(tmp51, []any{tmp53, tmp55}) + tmp57 := lang.Apply(tmp50, []any{tmp56}) + tmp58 := lang.Apply(tmp49, []any{tmp57}) + tmp59 := lang.Apply(tmp33, []any{tmp35, tmp48, v5, tmp58}) + tmp60 := lang.Apply(tmp32, []any{tmp59}) + tmp61 := lang.Apply(tmp31, []any{tmp60}) + tmp62 := lang.Apply(tmp7, []any{tmp9, tmp30, tmp61}) + tmp63 := lang.Apply(tmp6, []any{tmp62}) + return tmp63 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // with-precision + { + tmp0 := lang.NewSymbol("with-precision").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("precision"), lang.NewSymbol("&"), lang.NewSymbol("exprs"))), lang.NewKeyword("doc"), "Sets the precision and rounding mode to be used for BigDecimal operations.\n\n Usage: (with-precision 10 (/ 1M 3))\n or: (with-precision 10 :rounding HALF_DOWN (/ 1M 3))\n\n The rounding mode is one of CEILING, FLOOR, HALF_UP, HALF_DOWN,\n HALF_EVEN, UP, DOWN and UNNECESSARY; it defaults to HALF_UP.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5110), lang.NewKeyword("end-line"), int(5110))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any + { // let + // let binding "vec__65" + var tmp8 any + tmp9 := checkDerefVar(glojure_DOT_core__EQ_) + tmp10 := checkDerefVar(glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v6}) + tmp12 := lang.Apply(tmp9, []any{tmp11, lang.NewKeyword("rounding")}) + if lang.IsTruthy(tmp12) { + tmp13 := checkDerefVar(glojure_DOT_core_next) + tmp14 := checkDerefVar(glojure_DOT_core_next) + tmp15 := lang.Apply(tmp14, []any{v6}) + tmp16 := lang.Apply(tmp13, []any{tmp15}) + tmp17 := checkDerefVar(glojure_DOT_core_seq) + tmp18 := checkDerefVar(glojure_DOT_core_concat) + tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp20 := checkDerefVar(glojure_DOT_core_seq) + tmp21 := checkDerefVar(glojure_DOT_core_concat) + tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{lang.NewSymbol(".")}) + tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{lang.NewSymbol("java.math.RoundingMode")}) + tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp27 := checkDerefVar(glojure_DOT_core_second) + tmp28 := lang.Apply(tmp27, []any{v6}) + tmp29 := lang.Apply(tmp26, []any{tmp28}) + tmp30 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp29}) + tmp31 := lang.Apply(tmp20, []any{tmp30}) + tmp32 := lang.Apply(tmp19, []any{tmp31}) + tmp33 := lang.Apply(tmp18, []any{tmp32}) + tmp34 := lang.Apply(tmp17, []any{tmp33}) + tmp35 := lang.NewVector(tmp16, tmp34) + tmp36 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5121), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(5122), lang.NewKeyword("end-column"), int(69)) + tmp37, err := lang.WithMeta(tmp35, tmp36.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp8 = tmp37 + } else { + tmp38 := lang.NewVector(v6, nil) + tmp39 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5123), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(5123), lang.NewKeyword("end-column"), int(33)) + tmp40, err := lang.WithMeta(tmp38, tmp39.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp8 = tmp40 + } + var v41 any = tmp8 + _ = v41 + // let binding "body" + tmp42 := checkDerefVar(glojure_DOT_core_nth) + tmp43 := lang.Apply(tmp42, []any{v41, int64(0), nil}) + var v44 any = tmp43 + _ = v44 + // let binding "rm" + tmp45 := checkDerefVar(glojure_DOT_core_nth) + tmp46 := lang.Apply(tmp45, []any{v41, int64(1), nil}) + var v47 any = tmp46 + _ = v47 + tmp48 := checkDerefVar(glojure_DOT_core_seq) + tmp49 := checkDerefVar(glojure_DOT_core_concat) + tmp50 := checkDerefVar(glojure_DOT_core_list) + tmp51 := lang.Apply(tmp50, []any{lang.NewSymbol("glojure.core/binding")}) + tmp52 := checkDerefVar(glojure_DOT_core_list) + tmp53 := checkDerefVar(glojure_DOT_core_apply) + tmp54 := checkDerefVar(glojure_DOT_core_vector) + tmp55 := checkDerefVar(glojure_DOT_core_seq) + tmp56 := checkDerefVar(glojure_DOT_core_concat) + tmp57 := checkDerefVar(glojure_DOT_core_list) + tmp58 := lang.Apply(tmp57, []any{lang.NewSymbol("glojure.core/*math-context*")}) + tmp59 := checkDerefVar(glojure_DOT_core_list) + tmp60 := checkDerefVar(glojure_DOT_core_seq) + tmp61 := checkDerefVar(glojure_DOT_core_concat) + tmp62 := checkDerefVar(glojure_DOT_core_list) + tmp63 := lang.Apply(tmp62, []any{lang.NewSymbol("java.math.MathContext.")}) + tmp64 := checkDerefVar(glojure_DOT_core_list) + tmp65 := lang.Apply(tmp64, []any{v5}) + tmp66 := lang.Apply(tmp61, []any{tmp63, tmp65, v47}) + tmp67 := lang.Apply(tmp60, []any{tmp66}) + tmp68 := lang.Apply(tmp59, []any{tmp67}) + tmp69 := lang.Apply(tmp56, []any{tmp58, tmp68}) + tmp70 := lang.Apply(tmp55, []any{tmp69}) + tmp71 := lang.Apply(tmp53, []any{tmp54, tmp70}) + tmp72 := lang.Apply(tmp52, []any{tmp71}) + tmp73 := lang.Apply(tmp49, []any{tmp51, tmp72, v44}) + tmp74 := lang.Apply(tmp48, []any{tmp73}) + tmp7 = tmp74 + } // end let + return tmp7 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // with-redefs + { + tmp0 := lang.NewSymbol("with-redefs").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "binding => var-symbol temp-value-expr\n\n Temporarily redefines Vars while executing the body. The\n temp-value-exprs will be evaluated and each resulting value will\n replace in parallel the root value of its Var. After the body is\n executed, the root values of all the Vars will be set back to their\n old values. These temporary changes will be visible in all threads.\n Useful for mocking out functions during testing.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7544), lang.NewKeyword("end-line"), int(7544))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + if len(args) < 3 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := checkDerefVar(glojure_DOT_core_seq) + tmp8 := checkDerefVar(glojure_DOT_core_concat) + tmp9 := checkDerefVar(glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("glojure.core/with-redefs-fn")}) + tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp12 := checkDerefVar(glojure_DOT_core_zipmap) + tmp13 := checkDerefVar(glojure_DOT_core_map) + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v15 := args[0] + _ = v15 + tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("var"), v15}) + return tmp17 + }) + tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7555), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(7555), lang.NewKeyword("end-column"), int(47)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp17 := checkDerefVar(glojure_DOT_core_take_nth) + tmp18 := lang.Apply(tmp17, []any{int64(2), v5}) + tmp19 := lang.Apply(tmp13, []any{tmp16, tmp18}) + tmp20 := checkDerefVar(glojure_DOT_core_take_nth) + tmp21 := checkDerefVar(glojure_DOT_core_next) + tmp22 := lang.Apply(tmp21, []any{v5}) + tmp23 := lang.Apply(tmp20, []any{int64(2), tmp22}) + tmp24 := lang.Apply(tmp12, []any{tmp19, tmp23}) + tmp25 := lang.Apply(tmp11, []any{tmp24}) + tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp27 := checkDerefVar(glojure_DOT_core_seq) + tmp28 := checkDerefVar(glojure_DOT_core_concat) + tmp29 := checkDerefVar(glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/fn")}) + tmp31 := checkDerefVar(glojure_DOT_core_list) + tmp32 := checkDerefVar(glojure_DOT_core_apply) + tmp33 := checkDerefVar(glojure_DOT_core_vector) + tmp34 := checkDerefVar(glojure_DOT_core_seq) + tmp35 := checkDerefVar(glojure_DOT_core_concat) + tmp36 := lang.Apply(tmp35, nil) + tmp37 := lang.Apply(tmp34, []any{tmp36}) + tmp38 := lang.Apply(tmp32, []any{tmp33, tmp37}) + tmp39 := lang.Apply(tmp31, []any{tmp38}) + tmp40 := lang.Apply(tmp28, []any{tmp30, tmp39, v6}) + tmp41 := lang.Apply(tmp27, []any{tmp40}) + tmp42 := lang.Apply(tmp26, []any{tmp41}) + tmp43 := lang.Apply(tmp8, []any{tmp10, tmp25, tmp42}) + tmp44 := lang.Apply(tmp7, []any{tmp43}) + return tmp44 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // with-redefs-fn + { + tmp0 := lang.NewSymbol("with-redefs-fn").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("binding-map"), lang.NewSymbol("func"))), lang.NewKeyword("doc"), "Temporarily redefines Vars during a call to func. Each val of\n binding-map will replace the root value of its key which must be\n a Var. After func is called with no args, the root values of all\n the Vars will be set back to their old values. These temporary\n changes will be visible in all threads. Useful for mocking out\n functions during testing.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7524), lang.NewKeyword("end-line"), int(7524))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 any + { // let + // let binding "root-bind" + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v7 := args[0] + _ = v7 + var tmp8 any + { // let + // let binding "seq_338" + tmp9 := checkDerefVar(glojure_DOT_core_seq) + tmp10 := lang.Apply(tmp9, []any{v7}) + var v11 any = tmp10 + _ = v11 + // let binding "chunk_339" + var v12 any = nil + _ = v12 + // let binding "count_340" + var v13 any = int64(0) + _ = v13 + // let binding "i_341" + var v14 any = int64(0) + _ = v14 + for { + var tmp15 any + tmp16 := checkDerefVar(glojure_DOT_core__LT_) + tmp17 := lang.Apply(tmp16, []any{v14, v13}) + if lang.IsTruthy(tmp17) { + var tmp18 any + { // let + // let binding "vec__342" + tmp19, _ := lang.FieldOrMethod(v12, "nth") + if reflect.TypeOf(tmp19).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp20 := lang.Apply(tmp19, []any{v14}) + var v21 any = tmp20 + _ = v21 + // let binding "a-var" + tmp22 := checkDerefVar(glojure_DOT_core_nth) + tmp23 := lang.Apply(tmp22, []any{v21, int64(0), nil}) + var v24 any = tmp23 + _ = v24 + // let binding "a-val" + tmp25 := checkDerefVar(glojure_DOT_core_nth) + tmp26 := lang.Apply(tmp25, []any{v21, int64(1), nil}) + var v27 any = tmp26 + _ = v27 + tmp28, _ := lang.FieldOrMethod(v24, "bindRoot") + if reflect.TypeOf(tmp28).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("bindRoot is not a function"))) + } + tmp29 := lang.Apply(tmp28, []any{v27}) + _ = tmp29 + var tmp30 any = v11 + var tmp31 any = v12 + var tmp32 any = v13 + tmp34 := checkDerefVar(glojure_DOT_core_unchecked_inc) + tmp35 := lang.Apply(tmp34, []any{v14}) + var tmp33 any = tmp35 + v11 = tmp30 + v12 = tmp31 + v13 = tmp32 + v14 = tmp33 + continue + } // end let + tmp15 = tmp18 + } else { + var tmp19 any + { // let + // let binding "temp__0__auto__" + tmp20 := checkDerefVar(glojure_DOT_core_seq) + tmp21 := lang.Apply(tmp20, []any{v11}) + var v22 any = tmp21 + _ = v22 + var tmp23 any + if lang.IsTruthy(v22) { + var tmp24 any + { // let + // let binding "seq_338" + var v25 any = v22 + _ = v25 + var tmp26 any + tmp27 := checkDerefVar(glojure_DOT_core_chunked_seq_QMARK_) + tmp28 := lang.Apply(tmp27, []any{v25}) + if lang.IsTruthy(tmp28) { + var tmp29 any + { // let + // let binding "c__0__auto__" + tmp30 := checkDerefVar(glojure_DOT_core_chunk_first) + tmp31 := lang.Apply(tmp30, []any{v25}) + var v32 any = tmp31 + _ = v32 + tmp34 := checkDerefVar(glojure_DOT_core_chunk_rest) + tmp35 := lang.Apply(tmp34, []any{v25}) + var tmp33 any = tmp35 + var tmp36 any = v32 + tmp38 := checkDerefVar(glojure_DOT_core_int) + tmp39 := checkDerefVar(glojure_DOT_core_count) + tmp40 := lang.Apply(tmp39, []any{v32}) + tmp41 := lang.Apply(tmp38, []any{tmp40}) + var tmp37 any = tmp41 + tmp43 := checkDerefVar(glojure_DOT_core_int) + tmp44 := lang.Apply(tmp43, []any{int64(0)}) + var tmp42 any = tmp44 + v11 = tmp33 + v12 = tmp36 + v13 = tmp37 + v14 = tmp42 + continue + } // end let + tmp26 = tmp29 + } else { + var tmp30 any + { // let + // let binding "vec__345" + tmp31 := checkDerefVar(glojure_DOT_core_first) + tmp32 := lang.Apply(tmp31, []any{v25}) + var v33 any = tmp32 + _ = v33 + // let binding "a-var" + tmp34 := checkDerefVar(glojure_DOT_core_nth) + tmp35 := lang.Apply(tmp34, []any{v33, int64(0), nil}) + var v36 any = tmp35 + _ = v36 + // let binding "a-val" + tmp37 := checkDerefVar(glojure_DOT_core_nth) + tmp38 := lang.Apply(tmp37, []any{v33, int64(1), nil}) + var v39 any = tmp38 + _ = v39 + tmp40, _ := lang.FieldOrMethod(v36, "bindRoot") + if reflect.TypeOf(tmp40).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("bindRoot is not a function"))) + } + tmp41 := lang.Apply(tmp40, []any{v39}) + _ = tmp41 + tmp43 := checkDerefVar(glojure_DOT_core_next) + tmp44 := lang.Apply(tmp43, []any{v25}) + var tmp42 any = tmp44 + var tmp45 any = nil + var tmp46 any = int64(0) + var tmp47 any = int64(0) + v11 = tmp42 + v12 = tmp45 + v13 = tmp46 + v14 = tmp47 + continue + } // end let + tmp26 = tmp30 + } + tmp24 = tmp26 + } // end let + tmp23 = tmp24 + } else { + } + tmp19 = tmp23 + } // end let + tmp15 = tmp19 + } + tmp8 = tmp15 + break + } + } // end let + return tmp8 + }) + tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7533), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(7535), lang.NewKeyword("end-column"), int(93)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v9 any = tmp8 + _ = v9 + // let binding "old-vals" + tmp10 := checkDerefVar(glojure_DOT_core_zipmap) + tmp11 := checkDerefVar(glojure_DOT_core_keys) + tmp12 := lang.Apply(tmp11, []any{v3}) + tmp13 := checkDerefVar(glojure_DOT_core_map) + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v15 := args[0] + _ = v15 + tmp16, ok := lang.FieldOrMethod(v15, "getRawRoot") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v15, "getRawRoot"))) + } + var tmp17 any + switch reflect.TypeOf(tmp16).Kind() { + case reflect.Func: + tmp17 = lang.Apply(tmp16, nil) + default: + tmp17 = tmp16 + } + return tmp17 + }) + tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7537), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(7537), lang.NewKeyword("end-column"), int(92)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp17 := checkDerefVar(glojure_DOT_core_keys) + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := lang.Apply(tmp13, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp10, []any{tmp12, tmp19}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + func() { + defer func() { + tmp23 := lang.Apply(v9, []any{v21}) + _ = tmp23 + }() + tmp24 := lang.Apply(v9, []any{v3}) + _ = tmp24 + tmp25 := lang.Apply(v4, nil) + tmp22 = tmp25 + }() + tmp5 = tmp22 + } // end let + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // xml-seq + { + tmp0 := lang.NewSymbol("xml-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("root"))), lang.NewKeyword("doc"), "A tree seq on the xml elements as per xml/parse", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4982), lang.NewKeyword("end-line"), int(4982))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_tree_seq) + tmp5 := checkDerefVar(glojure_DOT_core_complement) + tmp6 := checkDerefVar(glojure_DOT_core_string_QMARK_) + tmp7 := lang.Apply(tmp5, []any{tmp6}) + tmp8 := checkDerefVar(glojure_DOT_core_comp) + tmp9 := checkDerefVar(glojure_DOT_core_seq) + tmp10 := lang.Apply(tmp8, []any{tmp9, lang.NewKeyword("content")}) + tmp11 := lang.Apply(tmp4, []any{tmp7, tmp10, v3}) + return tmp11 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // zero? + { + var tmp1 lang.FnFunc + { // function zero?__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) + tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) + tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp11 := checkDerefVar(glojure_DOT_core_seq) + tmp12 := checkDerefVar(glojure_DOT_core_concat) + tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/IsZero")}) + tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := lang.NewSymbol("zero?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns true if num is zero, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(860), lang.NewKeyword("end-line"), int(860))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 1 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v4 := args[0] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "IsZero") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("IsZero is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 := ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // zipmap + { + tmp0 := lang.NewSymbol("zipmap").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("keys"), lang.NewSymbol("vals"))), lang.NewKeyword("doc"), "Returns a map with the keys mapped to the corresponding vals.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6583), lang.NewKeyword("end-line"), int(6583))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + if len(args) != 2 { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 any + { // let + // let binding "map" + tmp6 := checkDerefVar(glojure_DOT_core_transient) + tmp7 := lang.NewMap() + tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6588), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(6588), lang.NewKeyword("end-column"), int(28)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp10 := lang.Apply(tmp6, []any{tmp9}) + var v11 any = tmp10 + _ = v11 + // let binding "ks" + tmp12 := checkDerefVar(glojure_DOT_core_seq) + tmp13 := lang.Apply(tmp12, []any{v3}) + var v14 any = tmp13 + _ = v14 + // let binding "vs" + tmp15 := checkDerefVar(glojure_DOT_core_seq) + tmp16 := lang.Apply(tmp15, []any{v4}) + var v17 any = tmp16 + _ = v17 + for { + var tmp18 any + var tmp19 any + { // let + // let binding "and__0__auto__" + var v20 any = v14 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + tmp21 = v17 + } else { + tmp21 = v20 + } + tmp19 = tmp21 + } // end let + if lang.IsTruthy(tmp19) { + tmp21 := checkDerefVar(glojure_DOT_core_assoc_BANG_) + tmp22 := checkDerefVar(glojure_DOT_core_first) + tmp23 := lang.Apply(tmp22, []any{v14}) + tmp24 := checkDerefVar(glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v17}) + tmp26 := lang.Apply(tmp21, []any{v11, tmp23, tmp25}) + var tmp20 any = tmp26 + tmp28 := checkDerefVar(glojure_DOT_core_next) + tmp29 := lang.Apply(tmp28, []any{v14}) + var tmp27 any = tmp29 + tmp31 := checkDerefVar(glojure_DOT_core_next) + tmp32 := lang.Apply(tmp31, []any{v17}) + var tmp30 any = tmp32 + v11 = tmp20 + v14 = tmp27 + v17 = tmp30 + continue + } else { + tmp33 := checkDerefVar(glojure_DOT_core_persistent_BANG_) + tmp34 := lang.Apply(tmp33, []any{v11}) + tmp18 = tmp34 + } + tmp5 = tmp18 + break + } + } // end let + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp1 := ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } +} diff --git a/pkg/gen/gljimports/gljimports_darwin_amd64.go b/pkg/gen/gljimports/gljimports_darwin_amd64.go index b12fcdb3..028fed4b 100644 --- a/pkg/gen/gljimports/gljimports_darwin_amd64.go +++ b/pkg/gen/gljimports/gljimports_darwin_amd64.go @@ -3487,6 +3487,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.CreateLazilyPersistentVector", github_com_glojurelang_glojure_pkg_lang.CreateLazilyPersistentVector) _register("github.com/glojurelang/glojure/pkg/lang.CreateOwningLazilyPersistentVector", github_com_glojurelang_glojure_pkg_lang.CreateOwningLazilyPersistentVector) _register("github.com/glojurelang/glojure/pkg/lang.CreatePersistentHashMap", github_com_glojurelang_glojure_pkg_lang.CreatePersistentHashMap) + _register("github.com/glojurelang/glojure/pkg/lang.CreatePersistentStructMap", github_com_glojurelang_glojure_pkg_lang.CreatePersistentStructMap) _register("github.com/glojurelang/glojure/pkg/lang.CreatePersistentStructMapSlotMap", github_com_glojurelang_glojure_pkg_lang.CreatePersistentStructMapSlotMap) _register("github.com/glojurelang/glojure/pkg/lang.CreatePersistentTreeMap", github_com_glojurelang_glojure_pkg_lang.CreatePersistentTreeMap) _register("github.com/glojurelang/glojure/pkg/lang.CreatePersistentTreeSet", github_com_glojurelang_glojure_pkg_lang.CreatePersistentTreeSet) diff --git a/pkg/gen/gljimports/gljimports_darwin_arm64.go b/pkg/gen/gljimports/gljimports_darwin_arm64.go index fb34abcc..0d4dbe5e 100644 --- a/pkg/gen/gljimports/gljimports_darwin_arm64.go +++ b/pkg/gen/gljimports/gljimports_darwin_arm64.go @@ -3487,6 +3487,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.CreateLazilyPersistentVector", github_com_glojurelang_glojure_pkg_lang.CreateLazilyPersistentVector) _register("github.com/glojurelang/glojure/pkg/lang.CreateOwningLazilyPersistentVector", github_com_glojurelang_glojure_pkg_lang.CreateOwningLazilyPersistentVector) _register("github.com/glojurelang/glojure/pkg/lang.CreatePersistentHashMap", github_com_glojurelang_glojure_pkg_lang.CreatePersistentHashMap) + _register("github.com/glojurelang/glojure/pkg/lang.CreatePersistentStructMap", github_com_glojurelang_glojure_pkg_lang.CreatePersistentStructMap) _register("github.com/glojurelang/glojure/pkg/lang.CreatePersistentStructMapSlotMap", github_com_glojurelang_glojure_pkg_lang.CreatePersistentStructMapSlotMap) _register("github.com/glojurelang/glojure/pkg/lang.CreatePersistentTreeMap", github_com_glojurelang_glojure_pkg_lang.CreatePersistentTreeMap) _register("github.com/glojurelang/glojure/pkg/lang.CreatePersistentTreeSet", github_com_glojurelang_glojure_pkg_lang.CreatePersistentTreeSet) diff --git a/pkg/gen/gljimports/gljimports_js_wasm.go b/pkg/gen/gljimports/gljimports_js_wasm.go index 36f7d195..93c25a71 100644 --- a/pkg/gen/gljimports/gljimports_js_wasm.go +++ b/pkg/gen/gljimports/gljimports_js_wasm.go @@ -3487,6 +3487,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.CreateLazilyPersistentVector", github_com_glojurelang_glojure_pkg_lang.CreateLazilyPersistentVector) _register("github.com/glojurelang/glojure/pkg/lang.CreateOwningLazilyPersistentVector", github_com_glojurelang_glojure_pkg_lang.CreateOwningLazilyPersistentVector) _register("github.com/glojurelang/glojure/pkg/lang.CreatePersistentHashMap", github_com_glojurelang_glojure_pkg_lang.CreatePersistentHashMap) + _register("github.com/glojurelang/glojure/pkg/lang.CreatePersistentStructMap", github_com_glojurelang_glojure_pkg_lang.CreatePersistentStructMap) _register("github.com/glojurelang/glojure/pkg/lang.CreatePersistentStructMapSlotMap", github_com_glojurelang_glojure_pkg_lang.CreatePersistentStructMapSlotMap) _register("github.com/glojurelang/glojure/pkg/lang.CreatePersistentTreeMap", github_com_glojurelang_glojure_pkg_lang.CreatePersistentTreeMap) _register("github.com/glojurelang/glojure/pkg/lang.CreatePersistentTreeSet", github_com_glojurelang_glojure_pkg_lang.CreatePersistentTreeSet) diff --git a/pkg/gen/gljimports/gljimports_linux_amd64.go b/pkg/gen/gljimports/gljimports_linux_amd64.go index 2739769a..8b83539b 100644 --- a/pkg/gen/gljimports/gljimports_linux_amd64.go +++ b/pkg/gen/gljimports/gljimports_linux_amd64.go @@ -3487,6 +3487,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.CreateLazilyPersistentVector", github_com_glojurelang_glojure_pkg_lang.CreateLazilyPersistentVector) _register("github.com/glojurelang/glojure/pkg/lang.CreateOwningLazilyPersistentVector", github_com_glojurelang_glojure_pkg_lang.CreateOwningLazilyPersistentVector) _register("github.com/glojurelang/glojure/pkg/lang.CreatePersistentHashMap", github_com_glojurelang_glojure_pkg_lang.CreatePersistentHashMap) + _register("github.com/glojurelang/glojure/pkg/lang.CreatePersistentStructMap", github_com_glojurelang_glojure_pkg_lang.CreatePersistentStructMap) _register("github.com/glojurelang/glojure/pkg/lang.CreatePersistentStructMapSlotMap", github_com_glojurelang_glojure_pkg_lang.CreatePersistentStructMapSlotMap) _register("github.com/glojurelang/glojure/pkg/lang.CreatePersistentTreeMap", github_com_glojurelang_glojure_pkg_lang.CreatePersistentTreeMap) _register("github.com/glojurelang/glojure/pkg/lang.CreatePersistentTreeSet", github_com_glojurelang_glojure_pkg_lang.CreatePersistentTreeSet) diff --git a/pkg/gen/gljimports/gljimports_linux_arm64.go b/pkg/gen/gljimports/gljimports_linux_arm64.go index af69388a..378fbbdb 100644 --- a/pkg/gen/gljimports/gljimports_linux_arm64.go +++ b/pkg/gen/gljimports/gljimports_linux_arm64.go @@ -3487,6 +3487,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.CreateLazilyPersistentVector", github_com_glojurelang_glojure_pkg_lang.CreateLazilyPersistentVector) _register("github.com/glojurelang/glojure/pkg/lang.CreateOwningLazilyPersistentVector", github_com_glojurelang_glojure_pkg_lang.CreateOwningLazilyPersistentVector) _register("github.com/glojurelang/glojure/pkg/lang.CreatePersistentHashMap", github_com_glojurelang_glojure_pkg_lang.CreatePersistentHashMap) + _register("github.com/glojurelang/glojure/pkg/lang.CreatePersistentStructMap", github_com_glojurelang_glojure_pkg_lang.CreatePersistentStructMap) _register("github.com/glojurelang/glojure/pkg/lang.CreatePersistentStructMapSlotMap", github_com_glojurelang_glojure_pkg_lang.CreatePersistentStructMapSlotMap) _register("github.com/glojurelang/glojure/pkg/lang.CreatePersistentTreeMap", github_com_glojurelang_glojure_pkg_lang.CreatePersistentTreeMap) _register("github.com/glojurelang/glojure/pkg/lang.CreatePersistentTreeSet", github_com_glojurelang_glojure_pkg_lang.CreatePersistentTreeSet) diff --git a/pkg/gen/gljimports/gljimports_windows_amd64.go b/pkg/gen/gljimports/gljimports_windows_amd64.go index 8fdc6c9c..0aae41a4 100644 --- a/pkg/gen/gljimports/gljimports_windows_amd64.go +++ b/pkg/gen/gljimports/gljimports_windows_amd64.go @@ -3487,6 +3487,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.CreateLazilyPersistentVector", github_com_glojurelang_glojure_pkg_lang.CreateLazilyPersistentVector) _register("github.com/glojurelang/glojure/pkg/lang.CreateOwningLazilyPersistentVector", github_com_glojurelang_glojure_pkg_lang.CreateOwningLazilyPersistentVector) _register("github.com/glojurelang/glojure/pkg/lang.CreatePersistentHashMap", github_com_glojurelang_glojure_pkg_lang.CreatePersistentHashMap) + _register("github.com/glojurelang/glojure/pkg/lang.CreatePersistentStructMap", github_com_glojurelang_glojure_pkg_lang.CreatePersistentStructMap) _register("github.com/glojurelang/glojure/pkg/lang.CreatePersistentStructMapSlotMap", github_com_glojurelang_glojure_pkg_lang.CreatePersistentStructMapSlotMap) _register("github.com/glojurelang/glojure/pkg/lang.CreatePersistentTreeMap", github_com_glojurelang_glojure_pkg_lang.CreatePersistentTreeMap) _register("github.com/glojurelang/glojure/pkg/lang.CreatePersistentTreeSet", github_com_glojurelang_glojure_pkg_lang.CreatePersistentTreeSet) diff --git a/pkg/gen/gljimports/gljimports_windows_arm.go b/pkg/gen/gljimports/gljimports_windows_arm.go index 7568dd2d..70f63c47 100644 --- a/pkg/gen/gljimports/gljimports_windows_arm.go +++ b/pkg/gen/gljimports/gljimports_windows_arm.go @@ -3487,6 +3487,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.CreateLazilyPersistentVector", github_com_glojurelang_glojure_pkg_lang.CreateLazilyPersistentVector) _register("github.com/glojurelang/glojure/pkg/lang.CreateOwningLazilyPersistentVector", github_com_glojurelang_glojure_pkg_lang.CreateOwningLazilyPersistentVector) _register("github.com/glojurelang/glojure/pkg/lang.CreatePersistentHashMap", github_com_glojurelang_glojure_pkg_lang.CreatePersistentHashMap) + _register("github.com/glojurelang/glojure/pkg/lang.CreatePersistentStructMap", github_com_glojurelang_glojure_pkg_lang.CreatePersistentStructMap) _register("github.com/glojurelang/glojure/pkg/lang.CreatePersistentStructMapSlotMap", github_com_glojurelang_glojure_pkg_lang.CreatePersistentStructMapSlotMap) _register("github.com/glojurelang/glojure/pkg/lang.CreatePersistentTreeMap", github_com_glojurelang_glojure_pkg_lang.CreatePersistentTreeMap) _register("github.com/glojurelang/glojure/pkg/lang.CreatePersistentTreeSet", github_com_glojurelang_glojure_pkg_lang.CreatePersistentTreeSet) diff --git a/pkg/stdlib/glojure/go/io.glj b/pkg/stdlib/glojure/go/io.glj index 1aa52ff4..c92258ef 100644 --- a/pkg/stdlib/glojure/go/io.glj +++ b/pkg/stdlib/glojure/go/io.glj @@ -232,7 +232,7 @@ :make-input-stream (fn [^net$url.*URL x opts] (make-input-stream (if (= "file" (.scheme x)) - (FileInputStream. (as-file x)) + (as-file x) (let [req (go-try! net$http.NewRequest net$http.MethodGet (.String x) nil) res (go-try! . net$http.DefaultClient Do req) status (.StatusCode res) @@ -245,7 +245,7 @@ :make-output-stream (fn [^net$url.*URL x opts] (if (= "file" (.scheme x)) (make-output-stream (as-file x) opts) - (throw (IllegalArgumentException. (str "Can not write to non-file URL <" x ">"))))))) + (throw (github.com$glojurelang$glojure$pkg$lang.NewIllegalArgumentError (str "Can not write to non-file URL <" x ">"))))))) ;; (extend URI ;; IOFactory @@ -263,9 +263,9 @@ (make-input-stream url opts)))) :make-output-stream (fn [^go/string x opts] (try - (make-output-stream (URL. x) opts) - (catch MalformedURLException err - (make-output-stream (File. x) opts)))))) + (make-output-stream (go-try! (net$url.Parse x)) opts) + (catch go/any err + (make-output-stream (go-try! (os.Open x)) opts)))))) ;; (extend Socket ;; IOFactory From 940d621da8cbd3cd147529b62a4cc687ccd23f44 Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sat, 30 Aug 2025 21:12:26 -0700 Subject: [PATCH 50/67] Preallocate symbols and keywords Signed-off-by: James Hamlin --- pkg/codegen/codegen.go | 155 +- .../codegen/test/const_keyword/load.go.out | 35 +- .../codegen/test/const_number/load.go.out | 33 +- .../codegen/test/const_string/load.go.out | 33 +- .../testdata/codegen/test/core/load.go.out | 26772 ++++++++-------- .../codegen/test/def_simple/load.go.out | 26 +- .../codegen/test/fn_closure/load.go.out | 122 +- .../codegen/test/fn_recur/load.go.out | 82 +- .../codegen/test/loop_simple/load.go.out | 68 +- .../codegen/test/maybe_class/load.go.out | 48 +- .../testdata/codegen/test/multifn/load.go.out | 109 +- .../testdata/codegen/test/ns_skip/load.go.out | 23 +- .../codegen/test/quote_simple/load.go.out | 41 +- .../testdata/codegen/test/ref/load.go.out | 55 +- .../testdata/codegen/test/the_var/load.go.out | 46 +- .../codegen/test/throw_simple/load.go.out | 41 +- .../codegen/test/try_advanced/load.go.out | 113 +- .../codegen/test/try_basic/load.go.out | 147 +- .../testdata/codegen/test/values/load.go.out | 57 +- .../codegen/test/with_meta/load.go.out | 56 +- 20 files changed, 13851 insertions(+), 14211 deletions(-) diff --git a/pkg/codegen/codegen.go b/pkg/codegen/codegen.go index 90743a52..3e5f9583 100644 --- a/pkg/codegen/codegen.go +++ b/pkg/codegen/codegen.go @@ -59,8 +59,10 @@ type Generator struct { varScopes []varScope // stack of variable scopes recurStack []recurContext // stack of recur contexts for nested loops - imports map[string]string // set of imported packages with their aliases - varVariables map[varInfo]string // map of vars to their Go variable names + imports map[string]string // set of imported packages with their aliases + varVariables map[varInfo]string // map of vars to their Go variable names + symbolVariables map[string]string // set of all generated symbols to minimize allocations + kwVariables map[string]string // set of all generated keywords to minimize allocations // Fields for handling closures liftedValues map[liftedKey]*liftedValue // Dedupe by composite key @@ -79,14 +81,16 @@ var ( // New creates a new code generator func New(w io.Writer) *Generator { return &Generator{ - originalWriter: w, - w: w, - varScopes: []varScope{{nextNum: 0, names: make(map[string]string)}}, - recurStack: []recurContext{}, - imports: make(map[string]string), - liftedValues: make(map[liftedKey]*liftedValue), - liftedCounter: 0, - varVariables: make(map[varInfo]string), + originalWriter: w, + w: w, + varScopes: []varScope{{nextNum: 0, names: make(map[string]string)}}, + recurStack: []recurContext{}, + imports: make(map[string]string), + varVariables: make(map[varInfo]string), + symbolVariables: make(map[string]string), + kwVariables: make(map[string]string), + liftedValues: make(map[liftedKey]*liftedValue), + liftedCounter: 0, } } @@ -102,7 +106,7 @@ func (g *Generator) Generate(ns *lang.Namespace) error { g.writef("// reference fmt to avoid unused import error\n") g.writef("_ = fmt.Printf\n") - g.writef(" ns := lang.FindOrCreateNamespace(lang.NewSymbol(%#v))\n", ns.Name().String()) + g.writef(" ns := lang.FindOrCreateNamespace(%s)\n", g.allocSymVar(ns.Name().String())) g.writef(" _ = ns\n") // 1. Iterate through ns.Mappings() @@ -185,11 +189,42 @@ func (g *Generator) Generate(ns *lang.Namespace) error { } return v.Get() } +`) + initBuf.WriteString(`func checkArity(args []any, expected int) { + if len(args) != expected { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} `) initBuf.WriteString(fmt.Sprintf("// LoadNS initializes the namespace %q\n", ns.Name().String())) initBuf.WriteString("func LoadNS() {\n") - // initialize all the vars first + ////////////////////////// + // Symbols + var symbolNames []string + for sym := range g.symbolVariables { + symbolNames = append(symbolNames, sym) + } + sort.Strings(symbolNames) // Sort for deterministic output + for _, sym := range symbolNames { + varName := g.symbolVariables[sym] + initBuf.WriteString(fmt.Sprintf("%s := lang.NewSymbol(%q)\n", varName, sym)) + } + + ////////////////////////// + // Keywords + var kwNames []string + for kw := range g.kwVariables { + kwNames = append(kwNames, kw) + } + sort.Strings(kwNames) // Sort for deterministic output + for _, kw := range kwNames { + varName := g.kwVariables[kw] + initBuf.WriteString(fmt.Sprintf("%s := lang.NewKeyword(%q)\n", varName, kw)) + } + + ////////////////////////// + // Vars initialization var varNames []string var inverseVarMap = make(map[string]varInfo) for vi, varName := range g.varVariables { @@ -200,7 +235,8 @@ func (g *Generator) Generate(ns *lang.Namespace) error { for _, varName := range varNames { vi := inverseVarMap[varName] initBuf.WriteString(fmt.Sprintf("// var %s/%s\n", vi.ns, vi.sym)) - initBuf.WriteString(fmt.Sprintf("%s := lang.InternVarName(lang.NewSymbol(%q), lang.NewSymbol(%q))\n", varName, vi.ns, vi.sym)) + // NB: the variables will already have been allocated + initBuf.WriteString(fmt.Sprintf("%s := lang.InternVarName(%s, %s)\n", varName, g.allocSymVar(vi.ns), g.allocSymVar(vi.sym))) } // Add lifted values if any @@ -251,10 +287,10 @@ func (g *Generator) generateVar(nsVariableName string, name *lang.Symbol, vr *la meta := vr.Meta() varSym := g.allocateTempVar() if lang.IsNil(meta) { - g.writef("%s := lang.NewSymbol(\"%s\")\n", varSym, name.String()) + g.writef("%s := %s\n", varSym, g.allocSymVar(name.String())) } else { metaVariable := g.generateValue(meta) - g.writef("%s := lang.NewSymbol(\"%s\").WithMeta(%s).(*lang.Symbol)\n", varSym, name.String(), metaVariable) + g.writef("%s := %s.WithMeta(%s).(*lang.Symbol)\n", varSym, g.allocSymVar(name.String()), metaVariable) } // check if the var has a value @@ -291,9 +327,9 @@ func (g *Generator) generateValue(value any) string { // Generate a reference to a Var ns := v.Namespace() sym := v.Symbol() - return fmt.Sprintf("lang.FindOrCreateNamespace(lang.NewSymbol(%#v)).FindInternedVar(lang.NewSymbol(%#v))", ns.Name().String(), sym.String()) + return fmt.Sprintf("lang.FindOrCreateNamespace(%s).FindInternedVar(%s)", g.allocSymVar(ns.Name().String()), g.allocSymVar(sym.String())) case *lang.Namespace: - return fmt.Sprintf("lang.FindOrCreateNamespace(lang.NewSymbol(%#v))", v.Name().String()) + return fmt.Sprintf("lang.FindOrCreateNamespace(%s)", g.allocSymVar(v.Name().String())) case *runtime.Fn: return g.generateFn(v) case lang.FnFunc: @@ -308,12 +344,12 @@ func (g *Generator) generateValue(value any) string { return g.generateMultiFn(v) case lang.Keyword: if ns := v.Namespace(); ns != "" { - return fmt.Sprintf("lang.NewKeyword(\"%s/%s\")", ns, v.Name()) + return g.allocKWVar(fmt.Sprintf("%s/%s", ns, v.Name())) } else { - return fmt.Sprintf("lang.NewKeyword(\"%s\")", v.Name()) + return g.allocKWVar(v.Name()) } case *lang.Symbol: - return fmt.Sprintf("lang.NewSymbol(\"%s\")", v.FullName()) + return g.allocSymVar(v.String()) case lang.Char: return fmt.Sprintf("lang.NewChar(%#v)", rune(v)) case string: @@ -720,9 +756,7 @@ func (g *Generator) generateFn(fn *runtime.Fn) string { g.writef("%s = lang.NewFnFunc(func(args ...any) any {\n", fnVar) // Check arity - g.writef(" if len(args) != %d {\n", methodNode.FixedArity) - g.writef(" panic(lang.NewIllegalArgumentError(\"wrong number of arguments (\" + fmt.Sprint(len(args)) + \")\"))\n") - g.writef(" }\n") + g.writef("checkArity(args, %d)\n", methodNode.FixedArity) // Generate method body g.generateFnMethod(methodNode, "args") @@ -750,14 +784,13 @@ func (g *Generator) generateFn(fn *runtime.Fn) string { if variadicMethod != nil { variadicMethodNode := variadicMethod.Sub.(*ast.FnMethodNode) g.writef(" default:\n") - g.writef(" if len(args) < %d {\n", variadicMethodNode.FixedArity) - g.writef(" panic(lang.NewIllegalArgumentError(\"wrong number of arguments (\" + fmt.Sprint(len(args)) + \")\"))\n") - g.writef(" }\n") + g.writef("checkArity(args, %d)\n", variadicMethodNode.FixedArity) g.generateFnMethod(variadicMethodNode, "args") } else { // No variadic method - error on any other arity g.writef(" default:\n") - g.writef(" panic(lang.NewIllegalArgumentError(\"wrong number of arguments (\" + fmt.Sprint(len(args)) + \")\"))\n") + g.writef(" checkArity(args, -1)\n") + g.writef(" panic(\"unreachable\")\n") } g.writef(" }\n") @@ -904,7 +937,7 @@ func (g *Generator) generateVarDeref(node *ast.Node) string { varSymbol := varNode.Var.Symbol() // Look up the var variable - varId := g.allocateVarVariable(varNamespace.Name().String(), varSymbol.String()) + varId := g.allocVarVar(varNamespace.Name().String(), varSymbol.String()) resultId := g.allocateTempVar() g.writef("%s := checkDerefVar(%s)\n", resultId, varId) @@ -1390,7 +1423,7 @@ func (g *Generator) generateTheVar(node *ast.Node) string { name := varSym.Symbol() resultId := g.allocateTempVar() - g.writef("%s := lang.InternVarName(lang.NewSymbol(\"%s\"), lang.NewSymbol(\"%s\"))\n", resultId, ns.Name(), name.Name()) + g.writef("%s := lang.InternVarName(%s, %s)\n", resultId, g.allocSymVar(ns.Name().Name()), g.allocSymVar(name.Name())) return resultId } @@ -1617,24 +1650,25 @@ func (g *Generator) allocateTempVar() string { var ( replacements = map[rune]string{ - '!': "_BANG_", - '?': "_QMARK_", - '-': "_", - '+': "_PLUS_", - '*': "_STAR_", - '/': "_SLASH_", - '=': "_EQ_", - '<': "_LT_", - '>': "_GT_", - '&': "_AMP_", - '%': "_PCT_", - '$': "_DOLLAR_", - '^': "_CARET_", - '~': "_TILDE_", - '.': "_DOT_", - ':': "_COLON_", - '@': "_AT_", - '#': "_HASH_", + '!': "_BANG_", + '?': "_QMARK_", + '-': "_DASH_", + '+': "_PLUS_", + '*': "_STAR_", + '/': "_SLASH_", + '=': "_EQ_", + '<': "_LT_", + '>': "_GT_", + '&': "_AMP_", + '%': "_PCT_", + '$': "_DOLLAR_", + '^': "_CARET_", + '~': "_TILDE_", + '.': "_DOT_", + ':': "_COLON_", + '@': "_AT_", + '#': "_HASH_", + '\'': "_TICK_", } ) @@ -1680,16 +1714,39 @@ func (g *Generator) currentRecurContext() *recurContext { return &g.recurStack[len(g.recurStack)-1] } -func (g *Generator) allocateVarVariable(ns, sym string) string { +func (g *Generator) allocVarVar(ns, sym string) string { varInfo := varInfo{ns: ns, sym: sym} if v, ok := g.varVariables[varInfo]; ok { return v } - varName := mungeID(ns) + "_" + mungeID(sym) + + // also allocate for ns and symbols + g.allocSymVar(ns) + g.allocSymVar(sym) + + varName := "var_" + mungeID(ns) + "_" + mungeID(sym) g.varVariables[varInfo] = varName return varName } +func (g *Generator) allocSymVar(sym string) string { + if v, ok := g.symbolVariables[sym]; ok { + return v + } + varName := "sym_" + mungeID(sym) + g.symbolVariables[sym] = varName + return varName +} + +func (g *Generator) allocKWVar(kw string) string { + if v, ok := g.kwVariables[kw]; ok { + return v + } + varName := "kw_" + mungeID(kw) + g.kwVariables[kw] = varName + return varName +} + //////////////////////////////////////////////////////////////////////////////// var ( diff --git a/pkg/codegen/testdata/codegen/test/const_keyword/load.go.out b/pkg/codegen/testdata/codegen/test/const_keyword/load.go.out index b1fb1656..b8a97d12 100644 --- a/pkg/codegen/testdata/codegen/test/const_keyword/load.go.out +++ b/pkg/codegen/testdata/codegen/test/const_keyword/load.go.out @@ -1,28 +1,43 @@ // Code generated by glojure codegen. DO NOT EDIT. -package const_keyword +package const_DASH_keyword import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" ) +func checkDerefVar(v *lang.Var) any { + if v.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) + } + return v.Get() +} +func checkArity(args []any, expected int) { + if len(args) != expected { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + // LoadNS initializes the namespace "codegen.test.const-keyword" func LoadNS() { - checkDerefMacro := func(v *lang.Var) { - if v.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) - } - } - _ = checkDerefMacro + sym_codegen_DOT_test_DOT_const_DASH_keyword := lang.NewSymbol("codegen.test.const-keyword") + sym_const_DASH_keyword := lang.NewSymbol("const-keyword") + kw_column := lang.NewKeyword("column") + kw_end_DASH_column := lang.NewKeyword("end-column") + kw_end_DASH_line := lang.NewKeyword("end-line") + kw_file := lang.NewKeyword("file") + kw_foo := lang.NewKeyword("foo") + kw_line := lang.NewKeyword("line") + kw_ns := lang.NewKeyword("ns") // reference fmt to avoid unused import error _ = fmt.Printf - ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.const-keyword")) + ns := lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_const_DASH_keyword) _ = ns // const-keyword { - tmp0 := lang.NewSymbol("const-keyword").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/const_keyword.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.const-keyword")))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, lang.NewKeyword("foo"), true) + tmp0 := sym_const_DASH_keyword.WithMeta(lang.NewMap(kw_file, "codegen/test/const_keyword.glj", kw_line, int(3), kw_column, int(6), kw_end_DASH_line, int(3), kw_end_DASH_column, int(18), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_const_DASH_keyword))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, kw_foo, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } diff --git a/pkg/codegen/testdata/codegen/test/const_number/load.go.out b/pkg/codegen/testdata/codegen/test/const_number/load.go.out index 84b1ce59..165ffbcb 100644 --- a/pkg/codegen/testdata/codegen/test/const_number/load.go.out +++ b/pkg/codegen/testdata/codegen/test/const_number/load.go.out @@ -1,27 +1,42 @@ // Code generated by glojure codegen. DO NOT EDIT. -package const_number +package const_DASH_number import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" ) +func checkDerefVar(v *lang.Var) any { + if v.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) + } + return v.Get() +} +func checkArity(args []any, expected int) { + if len(args) != expected { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + // LoadNS initializes the namespace "codegen.test.const-number" func LoadNS() { - checkDerefMacro := func(v *lang.Var) { - if v.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) - } - } - _ = checkDerefMacro + sym_codegen_DOT_test_DOT_const_DASH_number := lang.NewSymbol("codegen.test.const-number") + sym_const_DASH_number := lang.NewSymbol("const-number") + kw_column := lang.NewKeyword("column") + kw_doc := lang.NewKeyword("doc") + kw_end_DASH_column := lang.NewKeyword("end-column") + kw_end_DASH_line := lang.NewKeyword("end-line") + kw_file := lang.NewKeyword("file") + kw_line := lang.NewKeyword("line") + kw_ns := lang.NewKeyword("ns") // reference fmt to avoid unused import error _ = fmt.Printf - ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.const-number")) + ns := lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_const_DASH_number) _ = ns // const-number { - tmp0 := lang.NewSymbol("const-number").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/const_number.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("doc"), "A constant number.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.const-number")))).(*lang.Symbol) + tmp0 := sym_const_DASH_number.WithMeta(lang.NewMap(kw_file, "codegen/test/const_number.glj", kw_line, int(3), kw_column, int(6), kw_end_DASH_line, int(3), kw_end_DASH_column, int(17), kw_doc, "A constant number.", kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_const_DASH_number))).(*lang.Symbol) tmp1 := ns.InternWithValue(tmp0, int64(42), true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) diff --git a/pkg/codegen/testdata/codegen/test/const_string/load.go.out b/pkg/codegen/testdata/codegen/test/const_string/load.go.out index 60525b0b..5dad0fba 100644 --- a/pkg/codegen/testdata/codegen/test/const_string/load.go.out +++ b/pkg/codegen/testdata/codegen/test/const_string/load.go.out @@ -1,27 +1,42 @@ // Code generated by glojure codegen. DO NOT EDIT. -package const_string +package const_DASH_string import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" ) +func checkDerefVar(v *lang.Var) any { + if v.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) + } + return v.Get() +} +func checkArity(args []any, expected int) { + if len(args) != expected { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + // LoadNS initializes the namespace "codegen.test.const-string" func LoadNS() { - checkDerefMacro := func(v *lang.Var) { - if v.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) - } - } - _ = checkDerefMacro + sym_codegen_DOT_test_DOT_const_DASH_string := lang.NewSymbol("codegen.test.const-string") + sym_const_DASH_string := lang.NewSymbol("const-string") + kw_column := lang.NewKeyword("column") + kw_end_DASH_column := lang.NewKeyword("end-column") + kw_end_DASH_line := lang.NewKeyword("end-line") + kw_file := lang.NewKeyword("file") + kw_hello := lang.NewKeyword("hello") + kw_line := lang.NewKeyword("line") + kw_ns := lang.NewKeyword("ns") // reference fmt to avoid unused import error _ = fmt.Printf - ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.const-string")) + ns := lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_const_DASH_string) _ = ns // const-string { - tmp0 := lang.NewSymbol("const-string").WithMeta(lang.NewMap(lang.NewKeyword("hello"), true, lang.NewKeyword("file"), "codegen/test/const_string.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.const-string")))).(*lang.Symbol) + tmp0 := sym_const_DASH_string.WithMeta(lang.NewMap(kw_hello, true, kw_file, "codegen/test/const_string.glj", kw_line, int(3), kw_column, int(6), kw_end_DASH_line, int(3), kw_end_DASH_column, int(25), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_const_DASH_string))).(*lang.Symbol) tmp1 := ns.InternWithValue(tmp0, "Hello, World!", true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) diff --git a/pkg/codegen/testdata/codegen/test/core/load.go.out b/pkg/codegen/testdata/codegen/test/core/load.go.out index 787764fc..f176d890 100644 --- a/pkg/codegen/testdata/codegen/test/core/load.go.out +++ b/pkg/codegen/testdata/codegen/test/core/load.go.out @@ -29,765 +29,2130 @@ func checkDerefVar(v *lang.Var) any { } return v.Get() } +func checkArity(args []any, expected int) { + if len(args) != expected { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} // LoadNS initializes the namespace "glojure.core" func LoadNS() { + sym__PCT_ := lang.NewSymbol("%") + sym__AMP_ := lang.NewSymbol("&") + sym__AMP_env := lang.NewSymbol("&env") + sym__AMP_form := lang.NewSymbol("&form") + sym__STAR_ := lang.NewSymbol("*") + sym__STAR__TICK_ := lang.NewSymbol("*'") + sym__STAR_1 := lang.NewSymbol("*1") + sym__STAR_2 := lang.NewSymbol("*2") + sym__STAR_3 := lang.NewSymbol("*3") + sym__STAR_agent_STAR_ := lang.NewSymbol("*agent*") + sym__STAR_assert_STAR_ := lang.NewSymbol("*assert*") + sym__STAR_command_DASH_line_DASH_args_STAR_ := lang.NewSymbol("*command-line-args*") + sym__STAR_compile_DASH_files_STAR_ := lang.NewSymbol("*compile-files*") + sym__STAR_compile_DASH_path_STAR_ := lang.NewSymbol("*compile-path*") + sym__STAR_compiler_DASH_options_STAR_ := lang.NewSymbol("*compiler-options*") + sym__STAR_data_DASH_readers_STAR_ := lang.NewSymbol("*data-readers*") + sym__STAR_default_DASH_data_DASH_reader_DASH_fn_STAR_ := lang.NewSymbol("*default-data-reader-fn*") + sym__STAR_e := lang.NewSymbol("*e") + sym__STAR_err_STAR_ := lang.NewSymbol("*err*") + sym__STAR_file_STAR_ := lang.NewSymbol("*file*") + sym__STAR_flush_DASH_on_DASH_newline_STAR_ := lang.NewSymbol("*flush-on-newline*") + sym__STAR_in_STAR_ := lang.NewSymbol("*in*") + sym__STAR_loaded_DASH_libs_STAR_ := lang.NewSymbol("*loaded-libs*") + sym__STAR_loading_DASH_verbosely_STAR_ := lang.NewSymbol("*loading-verbosely*") + sym__STAR_ns_STAR_ := lang.NewSymbol("*ns*") + sym__STAR_out_STAR_ := lang.NewSymbol("*out*") + sym__STAR_pending_DASH_paths_STAR_ := lang.NewSymbol("*pending-paths*") + sym__STAR_print_DASH_dup_STAR_ := lang.NewSymbol("*print-dup*") + sym__STAR_print_DASH_length_STAR_ := lang.NewSymbol("*print-length*") + sym__STAR_print_DASH_level_STAR_ := lang.NewSymbol("*print-level*") + sym__STAR_print_DASH_meta_STAR_ := lang.NewSymbol("*print-meta*") + sym__STAR_print_DASH_namespace_DASH_maps_STAR_ := lang.NewSymbol("*print-namespace-maps*") + sym__STAR_print_DASH_readably_STAR_ := lang.NewSymbol("*print-readably*") + sym__STAR_read_DASH_eval_STAR_ := lang.NewSymbol("*read-eval*") + sym__STAR_repl_STAR_ := lang.NewSymbol("*repl*") + sym__STAR_unchecked_DASH_math_STAR_ := lang.NewSymbol("*unchecked-math*") + sym__STAR_verbose_DASH_defrecords_STAR_ := lang.NewSymbol("*verbose-defrecords*") + sym__STAR_warn_DASH_on_DASH_reflection_STAR_ := lang.NewSymbol("*warn-on-reflection*") + sym__PLUS_ := lang.NewSymbol("+") + sym__PLUS__TICK_ := lang.NewSymbol("+'") + sym__DASH_ := lang.NewSymbol("-") + sym__DASH__TICK_ := lang.NewSymbol("-'") + sym__DASH__GT_ := lang.NewSymbol("->") + sym__DASH__GT__GT_ := lang.NewSymbol("->>") + sym__DASH_protocols := lang.NewSymbol("-protocols") + sym__DOT_ := lang.NewSymbol(".") + sym__DOT__DOT_ := lang.NewSymbol("..") + sym__DOT_Deref := lang.NewSymbol(".Deref") + sym__DOT_Equals := lang.NewSymbol(".Equals") + sym__DOT_HasRoot := lang.NewSymbol(".HasRoot") + sym__DOT_ResetMeta := lang.NewSymbol(".ResetMeta") + sym__DOT_UnixNano := lang.NewSymbol(".UnixNano") + sym__DOT_nth := lang.NewSymbol(".nth") + sym__DOT_reset := lang.NewSymbol(".reset") + sym__SLASH_ := lang.NewSymbol("/") + sym__LT_ := lang.NewSymbol("<") + sym__LT__EQ_ := lang.NewSymbol("<=") + sym__EQ_ := lang.NewSymbol("=") + sym__EQ__EQ_ := lang.NewSymbol("==") + sym__GT_ := lang.NewSymbol(">") + sym__GT_0_QMARK_ := lang.NewSymbol(">0?") + sym__GT_1_QMARK_ := lang.NewSymbol(">1?") + sym__GT__EQ_ := lang.NewSymbol(">=") + sym_CollReduce := lang.NewSymbol("CollReduce") + sym_Datafiable := lang.NewSymbol("Datafiable") + sym_Double_SLASH_isInfinite := lang.NewSymbol("Double/isInfinite") + sym_IKVReduce := lang.NewSymbol("IKVReduce") + sym_IOFactory := lang.NewSymbol("IOFactory") + sym_InternalReduce := lang.NewSymbol("InternalReduce") + sym_NaN_QMARK_ := lang.NewSymbol("NaN?") + sym_Navigable := lang.NewSymbol("Navigable") + sym_SetMacro := lang.NewSymbol("SetMacro") + sym_StackTraceElement_DASH__GT_vec := lang.NewSymbol("StackTraceElement->vec") + sym_Throwable_DASH__GT_map := lang.NewSymbol("Throwable->map") + sym_a := lang.NewSymbol("a") + sym_a__0__auto__ := lang.NewSymbol("a__0__auto__") + sym_abs := lang.NewSymbol("abs") + sym_accessor := lang.NewSymbol("accessor") + sym_aclone := lang.NewSymbol("aclone") + sym_add := lang.NewSymbol("add") + sym_add_DASH_classpath := lang.NewSymbol("add-classpath") + sym_add_DASH_doc_DASH_and_DASH_meta := lang.NewSymbol("add-doc-and-meta") + sym_add_DASH_watch := lang.NewSymbol("add-watch") + sym_addP := lang.NewSymbol("addP") + sym_agent := lang.NewSymbol("agent") + sym_agent_DASH_error := lang.NewSymbol("agent-error") + sym_agent_DASH_errors := lang.NewSymbol("agent-errors") + sym_agents := lang.NewSymbol("agents") + sym_aget := lang.NewSymbol("aget") + sym_alength := lang.NewSymbol("alength") + sym_alias := lang.NewSymbol("alias") + sym_all_DASH_ns := lang.NewSymbol("all-ns") + sym_alter := lang.NewSymbol("alter") + sym_alter_DASH_meta_BANG_ := lang.NewSymbol("alter-meta!") + sym_alter_DASH_var_DASH_root := lang.NewSymbol("alter-var-root") + sym_amap := lang.NewSymbol("amap") + sym_ancestors := lang.NewSymbol("ancestors") + sym_and := lang.NewSymbol("and") + sym_andNot := lang.NewSymbol("andNot") + sym_and__0__auto__ := lang.NewSymbol("and__0__auto__") + sym_any_QMARK_ := lang.NewSymbol("any?") + sym_apply := lang.NewSymbol("apply") + sym_areduce := lang.NewSymbol("areduce") + sym_arg1 := lang.NewSymbol("arg1") + sym_arg2 := lang.NewSymbol("arg2") + sym_arg3 := lang.NewSymbol("arg3") + sym_arglist := lang.NewSymbol("arglist") + sym_args := lang.NewSymbol("args") + sym_array := lang.NewSymbol("array") + sym_array_DASH_map := lang.NewSymbol("array-map") + sym_array__0__auto__ := lang.NewSymbol("array__0__auto__") + sym_as_DASH__GT_ := lang.NewSymbol("as->") + sym_aseq := lang.NewSymbol("aseq") + sym_aset := lang.NewSymbol("aset") + sym_aset_DASH_boolean := lang.NewSymbol("aset-boolean") + sym_aset_DASH_byte := lang.NewSymbol("aset-byte") + sym_aset_DASH_char := lang.NewSymbol("aset-char") + sym_aset_DASH_double := lang.NewSymbol("aset-double") + sym_aset_DASH_float := lang.NewSymbol("aset-float") + sym_aset_DASH_int := lang.NewSymbol("aset-int") + sym_aset_DASH_long := lang.NewSymbol("aset-long") + sym_aset_DASH_short := lang.NewSymbol("aset-short") + sym_assert := lang.NewSymbol("assert") + sym_assert_DASH_args := lang.NewSymbol("assert-args") + sym_assert_DASH_valid_DASH_fdecl := lang.NewSymbol("assert-valid-fdecl") + sym_assoc := lang.NewSymbol("assoc") + sym_assoc_BANG_ := lang.NewSymbol("assoc!") + sym_assoc_DASH_in := lang.NewSymbol("assoc-in") + sym_associative_QMARK_ := lang.NewSymbol("associative?") + sym_atom := lang.NewSymbol("atom") + sym_attr_DASH_map_QMARK_ := lang.NewSymbol("attr-map?") + sym_atype := lang.NewSymbol("atype") + sym_await := lang.NewSymbol("await") + sym_await_DASH_for := lang.NewSymbol("await-for") + sym_await1 := lang.NewSymbol("await1") + sym_b := lang.NewSymbol("b") + sym_bases := lang.NewSymbol("bases") + sym_begin := lang.NewSymbol("begin") + sym_bigdec := lang.NewSymbol("bigdec") + sym_bigint := lang.NewSymbol("bigint") + sym_biginteger := lang.NewSymbol("biginteger") + sym_binding := lang.NewSymbol("binding") + sym_binding_DASH_conveyor_DASH_fn := lang.NewSymbol("binding-conveyor-fn") + sym_binding_DASH_map := lang.NewSymbol("binding-map") + sym_bindings := lang.NewSymbol("bindings") + sym_bindings_STAR_ := lang.NewSymbol("bindings*") + sym_bit_DASH_and := lang.NewSymbol("bit-and") + sym_bit_DASH_and_DASH_not := lang.NewSymbol("bit-and-not") + sym_bit_DASH_clear := lang.NewSymbol("bit-clear") + sym_bit_DASH_flip := lang.NewSymbol("bit-flip") + sym_bit_DASH_not := lang.NewSymbol("bit-not") + sym_bit_DASH_or := lang.NewSymbol("bit-or") + sym_bit_DASH_set := lang.NewSymbol("bit-set") + sym_bit_DASH_shift_DASH_left := lang.NewSymbol("bit-shift-left") + sym_bit_DASH_shift_DASH_right := lang.NewSymbol("bit-shift-right") + sym_bit_DASH_test := lang.NewSymbol("bit-test") + sym_bit_DASH_xor := lang.NewSymbol("bit-xor") + sym_body := lang.NewSymbol("body") + sym_body_DASH_expr := lang.NewSymbol("body-expr") + sym_boolean := lang.NewSymbol("boolean") + sym_boolean_DASH_array := lang.NewSymbol("boolean-array") + sym_boolean_QMARK_ := lang.NewSymbol("boolean?") + sym_booleans := lang.NewSymbol("booleans") + sym_bound_DASH_fn := lang.NewSymbol("bound-fn") + sym_bound_DASH_fn_STAR_ := lang.NewSymbol("bound-fn*") + sym_bound_QMARK_ := lang.NewSymbol("bound?") + sym_bounded_DASH_count := lang.NewSymbol("bounded-count") + sym_branch_QMARK_ := lang.NewSymbol("branch?") + sym_butlast := lang.NewSymbol("butlast") + sym_byte := lang.NewSymbol("byte") + sym_byte_DASH_array := lang.NewSymbol("byte-array") + sym_byteCast := lang.NewSymbol("byteCast") + sym_bytes := lang.NewSymbol("bytes") + sym_bytes_QMARK_ := lang.NewSymbol("bytes?") + sym_c := lang.NewSymbol("c") + sym_c1 := lang.NewSymbol("c1") + sym_c2 := lang.NewSymbol("c2") + sym_c3 := lang.NewSymbol("c3") + sym_c__0__auto__ := lang.NewSymbol("c__0__auto__") + sym_capacity := lang.NewSymbol("capacity") + sym_case := lang.NewSymbol("case") + sym_case_STAR_ := lang.NewSymbol("case*") + sym_case_DASH_f := lang.NewSymbol("case-f") + sym_case_DASH_map := lang.NewSymbol("case-map") + sym_cast := lang.NewSymbol("cast") + sym_cat := lang.NewSymbol("cat") + sym_cause := lang.NewSymbol("cause") + sym_cf := lang.NewSymbol("cf") + sym_char := lang.NewSymbol("char") + sym_char_DASH_array := lang.NewSymbol("char-array") + sym_char_DASH_escape_DASH_string := lang.NewSymbol("char-escape-string") + sym_char_DASH_name_DASH_string := lang.NewSymbol("char-name-string") + sym_char_QMARK_ := lang.NewSymbol("char?") + sym_charCast := lang.NewSymbol("charCast") + sym_chars := lang.NewSymbol("chars") + sym_check_DASH_cyclic_DASH_dependency := lang.NewSymbol("check-cyclic-dependency") + sym_check_DASH_valid_DASH_options := lang.NewSymbol("check-valid-options") + sym_child := lang.NewSymbol("child") + sym_children := lang.NewSymbol("children") + sym_chunk := lang.NewSymbol("chunk") + sym_chunk_DASH_append := lang.NewSymbol("chunk-append") + sym_chunk_DASH_buffer := lang.NewSymbol("chunk-buffer") + sym_chunk_DASH_cons := lang.NewSymbol("chunk-cons") + sym_chunk_DASH_first := lang.NewSymbol("chunk-first") + sym_chunk_DASH_next := lang.NewSymbol("chunk-next") + sym_chunk_DASH_rest := lang.NewSymbol("chunk-rest") + sym_chunked_DASH_seq_QMARK_ := lang.NewSymbol("chunked-seq?") + sym_class := lang.NewSymbol("class") + sym_class_DASH_name := lang.NewSymbol("class-name") + sym_class_QMARK_ := lang.NewSymbol("class?") + sym_clauses := lang.NewSymbol("clauses") + sym_clear_DASH_agent_DASH_errors := lang.NewSymbol("clear-agent-errors") + sym_close := lang.NewSymbol("close") + sym_codegen_DOT_test_DOT_const_DASH_keyword := lang.NewSymbol("codegen.test.const-keyword") + sym_codegen_DOT_test_DOT_const_DASH_number := lang.NewSymbol("codegen.test.const-number") + sym_codegen_DOT_test_DOT_const_DASH_string := lang.NewSymbol("codegen.test.const-string") + sym_codegen_DOT_test_DOT_def_DASH_simple := lang.NewSymbol("codegen.test.def-simple") + sym_codegen_DOT_test_DOT_fn_DASH_closure := lang.NewSymbol("codegen.test.fn-closure") + sym_codegen_DOT_test_DOT_fn_DASH_recur := lang.NewSymbol("codegen.test.fn-recur") + sym_codegen_DOT_test_DOT_loop_DASH_simple := lang.NewSymbol("codegen.test.loop-simple") + sym_codegen_DOT_test_DOT_maybe_DASH_class := lang.NewSymbol("codegen.test.maybe-class") + sym_codegen_DOT_test_DOT_multifn := lang.NewSymbol("codegen.test.multifn") + sym_codegen_DOT_test_DOT_ns_DASH_skip := lang.NewSymbol("codegen.test.ns-skip") + sym_codegen_DOT_test_DOT_quote_DASH_simple := lang.NewSymbol("codegen.test.quote-simple") + sym_codegen_DOT_test_DOT_ref := lang.NewSymbol("codegen.test.ref") + sym_codegen_DOT_test_DOT_the_DASH_var := lang.NewSymbol("codegen.test.the-var") + sym_codegen_DOT_test_DOT_throw_DASH_simple := lang.NewSymbol("codegen.test.throw-simple") + sym_codegen_DOT_test_DOT_try_DASH_advanced := lang.NewSymbol("codegen.test.try-advanced") + sym_codegen_DOT_test_DOT_try_DASH_basic := lang.NewSymbol("codegen.test.try-basic") + sym_codegen_DOT_test_DOT_values := lang.NewSymbol("codegen.test.values") + sym_codegen_DOT_test_DOT_with_DASH_meta := lang.NewSymbol("codegen.test.with-meta") + sym_coerce := lang.NewSymbol("coerce") + sym_coll := lang.NewSymbol("coll") + sym_coll_DASH_reduce := lang.NewSymbol("coll-reduce") + sym_coll_QMARK_ := lang.NewSymbol("coll?") + sym_colls := lang.NewSymbol("colls") + sym_comment := lang.NewSymbol("comment") + sym_commute := lang.NewSymbol("commute") + sym_comp := lang.NewSymbol("comp") + sym_comparator := lang.NewSymbol("comparator") + sym_compare := lang.NewSymbol("compare") + sym_compare_DASH_and_DASH_set_BANG_ := lang.NewSymbol("compare-and-set!") + sym_compile := lang.NewSymbol("compile") + sym_complement := lang.NewSymbol("complement") + sym_completing := lang.NewSymbol("completing") + sym_concat := lang.NewSymbol("concat") + sym_cond := lang.NewSymbol("cond") + sym_cond_DASH__GT_ := lang.NewSymbol("cond->") + sym_cond_DASH__GT__GT_ := lang.NewSymbol("cond->>") + sym_condp := lang.NewSymbol("condp") + sym_conj := lang.NewSymbol("conj") + sym_conj_BANG_ := lang.NewSymbol("conj!") + sym_cons := lang.NewSymbol("cons") + sym_constantly := lang.NewSymbol("constantly") + sym_contains_QMARK_ := lang.NewSymbol("contains?") + sym_content := lang.NewSymbol("content") + sym_copy := lang.NewSymbol("copy") + sym_count := lang.NewSymbol("count") + sym_counted_QMARK_ := lang.NewSymbol("counted?") + sym_create := lang.NewSymbol("create") + sym_create_DASH_ns := lang.NewSymbol("create-ns") + sym_create_DASH_struct := lang.NewSymbol("create-struct") + sym_cycle := lang.NewSymbol("cycle") + sym_d := lang.NewSymbol("d") + sym_data_DASH_reader_DASH_urls := lang.NewSymbol("data-reader-urls") + sym_data_DASH_reader_DASH_var := lang.NewSymbol("data-reader-var") + sym_datafy := lang.NewSymbol("datafy") + sym_dec := lang.NewSymbol("dec") + sym_dec_TICK_ := lang.NewSymbol("dec'") + sym_decimal_QMARK_ := lang.NewSymbol("decimal?") + sym_decl := lang.NewSymbol("decl") + sym_declare := lang.NewSymbol("declare") + sym_decls := lang.NewSymbol("decls") + sym_dedupe := lang.NewSymbol("dedupe") + sym_def := lang.NewSymbol("def") + sym_def_DASH_aset := lang.NewSymbol("def-aset") + sym_default := lang.NewSymbol("default") + sym_definline := lang.NewSymbol("definline") + sym_defmacro := lang.NewSymbol("defmacro") + sym_defmethod := lang.NewSymbol("defmethod") + sym_defmulti := lang.NewSymbol("defmulti") + sym_defn := lang.NewSymbol("defn") + sym_defn_DASH_ := lang.NewSymbol("defn-") + sym_defonce := lang.NewSymbol("defonce") + sym_defprotocol := lang.NewSymbol("defprotocol") + sym_defstruct := lang.NewSymbol("defstruct") + sym_delay := lang.NewSymbol("delay") + sym_delay_QMARK_ := lang.NewSymbol("delay?") + sym_deliver := lang.NewSymbol("deliver") + sym_denominator := lang.NewSymbol("denominator") + sym_deref := lang.NewSymbol("deref") + sym_deref_DASH_as_DASH_map := lang.NewSymbol("deref-as-map") + sym_deref_DASH_future := lang.NewSymbol("deref-future") + sym_derive := lang.NewSymbol("derive") + sym_descendants := lang.NewSymbol("descendants") + sym_destructure := lang.NewSymbol("destructure") + sym_dim := lang.NewSymbol("dim") + sym_dir := lang.NewSymbol("dir") + sym_disj := lang.NewSymbol("disj") + sym_disj_BANG_ := lang.NewSymbol("disj!") + sym_dispatch_DASH_fn := lang.NewSymbol("dispatch-fn") + sym_dispatch_DASH_val := lang.NewSymbol("dispatch-val") + sym_dispatch_DASH_val_DASH_x := lang.NewSymbol("dispatch-val-x") + sym_dispatch_DASH_val_DASH_y := lang.NewSymbol("dispatch-val-y") + sym_dissoc := lang.NewSymbol("dissoc") + sym_dissoc_BANG_ := lang.NewSymbol("dissoc!") + sym_distinct := lang.NewSymbol("distinct") + sym_distinct_QMARK_ := lang.NewSymbol("distinct?") + sym_div := lang.NewSymbol("div") + sym_divide := lang.NewSymbol("divide") + sym_do := lang.NewSymbol("do") + sym_doall := lang.NewSymbol("doall") + sym_doc_DASH_string_QMARK_ := lang.NewSymbol("doc-string?") + sym_docstring := lang.NewSymbol("docstring") + sym_docstring_QMARK_ := lang.NewSymbol("docstring?") + sym_dorun := lang.NewSymbol("dorun") + sym_doseq := lang.NewSymbol("doseq") + sym_dosync := lang.NewSymbol("dosync") + sym_dotimes := lang.NewSymbol("dotimes") + sym_doto := lang.NewSymbol("doto") + sym_double := lang.NewSymbol("double") + sym_double_DASH_array := lang.NewSymbol("double-array") + sym_double_QMARK_ := lang.NewSymbol("double?") + sym_doubles := lang.NewSymbol("doubles") + sym_drop := lang.NewSymbol("drop") + sym_drop_DASH_last := lang.NewSymbol("drop-last") + sym_drop_DASH_while := lang.NewSymbol("drop-while") + sym_e := lang.NewSymbol("e") + sym_elide_DASH_top_DASH_frames := lang.NewSymbol("elide-top-frames") + sym_else := lang.NewSymbol("else") + sym_emit_DASH_extend_DASH_protocol := lang.NewSymbol("emit-extend-protocol") + sym_emit_DASH_extend_DASH_type := lang.NewSymbol("emit-extend-type") + sym_emit_DASH_hinted_DASH_impl := lang.NewSymbol("emit-hinted-impl") + sym_empty := lang.NewSymbol("empty") + sym_empty_QMARK_ := lang.NewSymbol("empty?") + sym_end := lang.NewSymbol("end") + sym_end_DASH_key := lang.NewSymbol("end-key") + sym_end_DASH_test := lang.NewSymbol("end-test") + sym_ensure := lang.NewSymbol("ensure") + sym_ensure_DASH_reduced := lang.NewSymbol("ensure-reduced") + sym_enumeration_DASH_seq := lang.NewSymbol("enumeration-seq") + sym_env := lang.NewSymbol("env") + sym_eof_DASH_error_QMARK_ := lang.NewSymbol("eof-error?") + sym_eof_DASH_value := lang.NewSymbol("eof-value") + sym_error_DASH_handler := lang.NewSymbol("error-handler") + sym_error_DASH_mode := lang.NewSymbol("error-mode") + sym_eval := lang.NewSymbol("eval") + sym_even_QMARK_ := lang.NewSymbol("even?") + sym_every_DASH_pred := lang.NewSymbol("every-pred") + sym_every_QMARK_ := lang.NewSymbol("every?") + sym_ex := lang.NewSymbol("ex") + sym_ex_DASH_cause := lang.NewSymbol("ex-cause") + sym_ex_DASH_data := lang.NewSymbol("ex-data") + sym_ex_DASH_info := lang.NewSymbol("ex-info") + sym_ex_DASH_message := lang.NewSymbol("ex-message") + sym_executor := lang.NewSymbol("executor") + sym_expr := lang.NewSymbol("expr") + sym_expr_DASH_sym := lang.NewSymbol("expr-sym") + sym_exprs := lang.NewSymbol("exprs") + sym_exprs_STAR_ := lang.NewSymbol("exprs*") + sym_extend := lang.NewSymbol("extend") + sym_extend_DASH_protocol := lang.NewSymbol("extend-protocol") + sym_extend_DASH_type := lang.NewSymbol("extend-type") + sym_f := lang.NewSymbol("f") + sym_false_QMARK_ := lang.NewSymbol("false?") + sym_fdecl := lang.NewSymbol("fdecl") + sym_ffirst := lang.NewSymbol("ffirst") + sym_file_DASH_seq := lang.NewSymbol("file-seq") + sym_filter := lang.NewSymbol("filter") + sym_filter_DASH_key := lang.NewSymbol("filter-key") + sym_filters := lang.NewSymbol("filters") + sym_filterv := lang.NewSymbol("filterv") + sym_finally := lang.NewSymbol("finally") + sym_find := lang.NewSymbol("find") + sym_find_DASH_keyword := lang.NewSymbol("find-keyword") + sym_find_DASH_ns := lang.NewSymbol("find-ns") + sym_find_DASH_var := lang.NewSymbol("find-var") + sym_first := lang.NewSymbol("first") + sym_fits_DASH_table_QMARK_ := lang.NewSymbol("fits-table?") + sym_flags_DASH_ignored_DASH_for_DASH_now := lang.NewSymbol("flags-ignored-for-now") + sym_flatten := lang.NewSymbol("flatten") + sym_float := lang.NewSymbol("float") + sym_float_DASH_array := lang.NewSymbol("float-array") + sym_float_QMARK_ := lang.NewSymbol("float?") + sym_floatCast := lang.NewSymbol("floatCast") + sym_floats := lang.NewSymbol("floats") + sym_flush := lang.NewSymbol("flush") + sym_fmt := lang.NewSymbol("fmt") + sym_fn := lang.NewSymbol("fn") + sym_fn_STAR_ := lang.NewSymbol("fn*") + sym_fn_DASH_tail := lang.NewSymbol("fn-tail") + sym_fn_QMARK_ := lang.NewSymbol("fn?") + sym_fnext := lang.NewSymbol("fnext") + sym_fnil := lang.NewSymbol("fnil") + sym_fns := lang.NewSymbol("fns") + sym_fnspecs := lang.NewSymbol("fnspecs") + sym_fnspecs_STAR_ := lang.NewSymbol("fnspecs*") + sym_fntail := lang.NewSymbol("fntail") + sym_for := lang.NewSymbol("for") + sym_force := lang.NewSymbol("force") + sym_form := lang.NewSymbol("form") + sym_format := lang.NewSymbol("format") + sym_forms := lang.NewSymbol("forms") + sym_frequencies := lang.NewSymbol("frequencies") + sym_from := lang.NewSymbol("from") + sym_fs := lang.NewSymbol("fs") + sym_fs__1__auto__ := lang.NewSymbol("fs__1__auto__") + sym_fun := lang.NewSymbol("fun") + sym_func := lang.NewSymbol("func") + sym_fut := lang.NewSymbol("fut") + sym_future := lang.NewSymbol("future") + sym_future_DASH_call := lang.NewSymbol("future-call") + sym_future_DASH_cancel := lang.NewSymbol("future-cancel") + sym_future_DASH_cancelled_QMARK_ := lang.NewSymbol("future-cancelled?") + sym_future_DASH_done_QMARK_ := lang.NewSymbol("future-done?") + sym_future_QMARK_ := lang.NewSymbol("future?") + sym_g := lang.NewSymbol("g") + sym_gen_DASH_class := lang.NewSymbol("gen-class") + sym_gensym := lang.NewSymbol("gensym") + sym_get := lang.NewSymbol("get") + sym_get_DASH_in := lang.NewSymbol("get-in") + sym_get_DASH_method := lang.NewSymbol("get-method") + sym_get_DASH_thread_DASH_bindings := lang.NewSymbol("get-thread-bindings") + sym_get_DASH_validator := lang.NewSymbol("get-validator") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT__STAR_MultiFn := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.*MultiFn") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT__STAR_Var := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.*Var") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Abs := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Abs") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_FindNamespace := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.FindNamespace") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_ISeq := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.ISeq") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Identical := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Identical") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Import := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Import") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_IsReduced := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.IsReduced") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_LockingTransaction := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.LockingTransaction") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_NewIllegalArgumentError := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewIllegalArgumentError") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_NewLazySeq := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewLazySeq") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_NewMultiFn := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewMultiFn") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_NewPersistentArrayMapAsIfByAssoc := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewPersistentArrayMapAsIfByAssoc") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_PopThreadBindings := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.PopThreadBindings") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_PushThreadBindings := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.PushThreadBindings") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Volatile := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Volatile") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT := lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT") + sym_global_DASH_hierarchy := lang.NewSymbol("global-hierarchy") + sym_glojure_DOT_core := lang.NewSymbol("glojure.core") + sym_glojure_DOT_core_DOT_protocols := lang.NewSymbol("glojure.core.protocols") + sym_glojure_DOT_core_SLASH__STAR_in_STAR_ := lang.NewSymbol("glojure.core/*in*") + sym_glojure_DOT_core_SLASH__STAR_loaded_DASH_libs_STAR_ := lang.NewSymbol("glojure.core/*loaded-libs*") + sym_glojure_DOT_core_SLASH__STAR_math_DASH_context_STAR_ := lang.NewSymbol("glojure.core/*math-context*") + sym_glojure_DOT_core_SLASH__STAR_out_STAR_ := lang.NewSymbol("glojure.core/*out*") + sym_glojure_DOT_core_SLASH__DASH_ := lang.NewSymbol("glojure.core/-") + sym_glojure_DOT_core_SLASH__DASH__GT_ := lang.NewSymbol("glojure.core/->") + sym_glojure_DOT_core_SLASH__DASH__GT__GT_ := lang.NewSymbol("glojure.core/->>") + sym_glojure_DOT_core_SLASH__DASH_protocols := lang.NewSymbol("glojure.core/-protocols") + sym_glojure_DOT_core_SLASH__SLASH_ := lang.NewSymbol("glojure.core//") + sym_glojure_DOT_core_SLASH__LT_ := lang.NewSymbol("glojure.core/<") + sym_glojure_DOT_core_SLASH__EQ_ := lang.NewSymbol("glojure.core/=") + sym_glojure_DOT_core_SLASH_Aclone := lang.NewSymbol("glojure.core/Aclone") + sym_glojure_DOT_core_SLASH_AddMethod := lang.NewSymbol("glojure.core/AddMethod") + sym_glojure_DOT_core_SLASH_Aget := lang.NewSymbol("glojure.core/Aget") + sym_glojure_DOT_core_SLASH_Alength := lang.NewSymbol("glojure.core/Alength") + sym_glojure_DOT_core_SLASH_Array := lang.NewSymbol("glojure.core/Array") + sym_glojure_DOT_core_SLASH_Aset := lang.NewSymbol("glojure.core/Aset") + sym_glojure_DOT_core_SLASH_AssertionError := lang.NewSymbol("glojure.core/AssertionError") + sym_glojure_DOT_core_SLASH_BooleanArray := lang.NewSymbol("glojure.core/BooleanArray") + sym_glojure_DOT_core_SLASH_BooleanCast := lang.NewSymbol("glojure.core/BooleanCast") + sym_glojure_DOT_core_SLASH_Booleans := lang.NewSymbol("glojure.core/Booleans") + sym_glojure_DOT_core_SLASH_ByteArray := lang.NewSymbol("glojure.core/ByteArray") + sym_glojure_DOT_core_SLASH_Bytes := lang.NewSymbol("glojure.core/Bytes") + sym_glojure_DOT_core_SLASH_CharArray := lang.NewSymbol("glojure.core/CharArray") + sym_glojure_DOT_core_SLASH_Chars := lang.NewSymbol("glojure.core/Chars") + sym_glojure_DOT_core_SLASH_Count := lang.NewSymbol("glojure.core/Count") + sym_glojure_DOT_core_SLASH_DecP := lang.NewSymbol("glojure.core/DecP") + sym_glojure_DOT_core_SLASH_DoubleArray := lang.NewSymbol("glojure.core/DoubleArray") + sym_glojure_DOT_core_SLASH_DoubleCast := lang.NewSymbol("glojure.core/DoubleCast") + sym_glojure_DOT_core_SLASH_Doubles := lang.NewSymbol("glojure.core/Doubles") + sym_glojure_DOT_core_SLASH_Equiv := lang.NewSymbol("glojure.core/Equiv") + sym_glojure_DOT_core_SLASH_FloatArray := lang.NewSymbol("glojure.core/FloatArray") + sym_glojure_DOT_core_SLASH_Floats := lang.NewSymbol("glojure.core/Floats") + sym_glojure_DOT_core_SLASH_Get := lang.NewSymbol("glojure.core/Get") + sym_glojure_DOT_core_SLASH_Gt := lang.NewSymbol("glojure.core/Gt") + sym_glojure_DOT_core_SLASH_Gte := lang.NewSymbol("glojure.core/Gte") + sym_glojure_DOT_core_SLASH_IllegalStateException := lang.NewSymbol("glojure.core/IllegalStateException") + sym_glojure_DOT_core_SLASH_IncP := lang.NewSymbol("glojure.core/IncP") + sym_glojure_DOT_core_SLASH_IntArray := lang.NewSymbol("glojure.core/IntArray") + sym_glojure_DOT_core_SLASH_Ints := lang.NewSymbol("glojure.core/Ints") + sym_glojure_DOT_core_SLASH_IsNeg := lang.NewSymbol("glojure.core/IsNeg") + sym_glojure_DOT_core_SLASH_IsPos := lang.NewSymbol("glojure.core/IsPos") + sym_glojure_DOT_core_SLASH_IsZero := lang.NewSymbol("glojure.core/IsZero") + sym_glojure_DOT_core_SLASH_LongArray := lang.NewSymbol("glojure.core/LongArray") + sym_glojure_DOT_core_SLASH_LongCast := lang.NewSymbol("glojure.core/LongCast") + sym_glojure_DOT_core_SLASH_Longs := lang.NewSymbol("glojure.core/Longs") + sym_glojure_DOT_core_SLASH_Lt := lang.NewSymbol("glojure.core/Lt") + sym_glojure_DOT_core_SLASH_Lte := lang.NewSymbol("glojure.core/Lte") + sym_glojure_DOT_core_SLASH_Not := lang.NewSymbol("glojure.core/Not") + sym_glojure_DOT_core_SLASH_Nth := lang.NewSymbol("glojure.core/Nth") + sym_glojure_DOT_core_SLASH_Num := lang.NewSymbol("glojure.core/Num") + sym_glojure_DOT_core_SLASH_Object_array := lang.NewSymbol("glojure.core/Object_array") + sym_glojure_DOT_core_SLASH_Quotient := lang.NewSymbol("glojure.core/Quotient") + sym_glojure_DOT_core_SLASH_Remainder := lang.NewSymbol("glojure.core/Remainder") + sym_glojure_DOT_core_SLASH_RunInTransaction := lang.NewSymbol("glojure.core/RunInTransaction") + sym_glojure_DOT_core_SLASH_ShiftLeft := lang.NewSymbol("glojure.core/ShiftLeft") + sym_glojure_DOT_core_SLASH_ShiftRight := lang.NewSymbol("glojure.core/ShiftRight") + sym_glojure_DOT_core_SLASH_ShortArray := lang.NewSymbol("glojure.core/ShortArray") + sym_glojure_DOT_core_SLASH_Shorts := lang.NewSymbol("glojure.core/Shorts") + sym_glojure_DOT_core_SLASH_UncheckedAdd := lang.NewSymbol("glojure.core/UncheckedAdd") + sym_glojure_DOT_core_SLASH_UncheckedByteCast := lang.NewSymbol("glojure.core/UncheckedByteCast") + sym_glojure_DOT_core_SLASH_UncheckedCharCast := lang.NewSymbol("glojure.core/UncheckedCharCast") + sym_glojure_DOT_core_SLASH_UncheckedDec := lang.NewSymbol("glojure.core/UncheckedDec") + sym_glojure_DOT_core_SLASH_UncheckedDoubleCast := lang.NewSymbol("glojure.core/UncheckedDoubleCast") + sym_glojure_DOT_core_SLASH_UncheckedFloatCast := lang.NewSymbol("glojure.core/UncheckedFloatCast") + sym_glojure_DOT_core_SLASH_UncheckedIntCast := lang.NewSymbol("glojure.core/UncheckedIntCast") + sym_glojure_DOT_core_SLASH_UncheckedIntDivide := lang.NewSymbol("glojure.core/UncheckedIntDivide") + sym_glojure_DOT_core_SLASH_UncheckedLongCast := lang.NewSymbol("glojure.core/UncheckedLongCast") + sym_glojure_DOT_core_SLASH_UncheckedShortCast := lang.NewSymbol("glojure.core/UncheckedShortCast") + sym_glojure_DOT_core_SLASH_Unchecked_inc := lang.NewSymbol("glojure.core/Unchecked_inc") + sym_glojure_DOT_core_SLASH_Unchecked_int_add := lang.NewSymbol("glojure.core/Unchecked_int_add") + sym_glojure_DOT_core_SLASH_Unchecked_int_dec := lang.NewSymbol("glojure.core/Unchecked_int_dec") + sym_glojure_DOT_core_SLASH_Unchecked_int_inc := lang.NewSymbol("glojure.core/Unchecked_int_inc") + sym_glojure_DOT_core_SLASH_Unchecked_int_multiply := lang.NewSymbol("glojure.core/Unchecked_int_multiply") + sym_glojure_DOT_core_SLASH_Unchecked_int_negate := lang.NewSymbol("glojure.core/Unchecked_int_negate") + sym_glojure_DOT_core_SLASH_Unchecked_int_remainder := lang.NewSymbol("glojure.core/Unchecked_int_remainder") + sym_glojure_DOT_core_SLASH_Unchecked_int_subtract := lang.NewSymbol("glojure.core/Unchecked_int_subtract") + sym_glojure_DOT_core_SLASH_Unchecked_minus := lang.NewSymbol("glojure.core/Unchecked_minus") + sym_glojure_DOT_core_SLASH_Unchecked_multiply := lang.NewSymbol("glojure.core/Unchecked_multiply") + sym_glojure_DOT_core_SLASH_UnsignedShiftRight := lang.NewSymbol("glojure.core/UnsignedShiftRight") + sym_glojure_DOT_core_SLASH_aclone := lang.NewSymbol("glojure.core/aclone") + sym_glojure_DOT_core_SLASH_aget := lang.NewSymbol("glojure.core/aget") + sym_glojure_DOT_core_SLASH_alength := lang.NewSymbol("glojure.core/alength") + sym_glojure_DOT_core_SLASH_alter_DASH_meta_BANG_ := lang.NewSymbol("glojure.core/alter-meta!") + sym_glojure_DOT_core_SLASH_and := lang.NewSymbol("glojure.core/and") + sym_glojure_DOT_core_SLASH_apply := lang.NewSymbol("glojure.core/apply") + sym_glojure_DOT_core_SLASH_args := lang.NewSymbol("glojure.core/args") + sym_glojure_DOT_core_SLASH_aset := lang.NewSymbol("glojure.core/aset") + sym_glojure_DOT_core_SLASH_assert := lang.NewSymbol("glojure.core/assert") + sym_glojure_DOT_core_SLASH_assert_DASH_args := lang.NewSymbol("glojure.core/assert-args") + sym_glojure_DOT_core_SLASH_assoc := lang.NewSymbol("glojure.core/assoc") + sym_glojure_DOT_core_SLASH_assoc_DASH_in := lang.NewSymbol("glojure.core/assoc-in") + sym_glojure_DOT_core_SLASH_atom := lang.NewSymbol("glojure.core/atom") + sym_glojure_DOT_core_SLASH_binding := lang.NewSymbol("glojure.core/binding") + sym_glojure_DOT_core_SLASH_bound_DASH_fn_STAR_ := lang.NewSymbol("glojure.core/bound-fn*") + sym_glojure_DOT_core_SLASH_c := lang.NewSymbol("glojure.core/c") + sym_glojure_DOT_core_SLASH_chunk := lang.NewSymbol("glojure.core/chunk") + sym_glojure_DOT_core_SLASH_chunk_DASH_append := lang.NewSymbol("glojure.core/chunk-append") + sym_glojure_DOT_core_SLASH_chunk_DASH_buffer := lang.NewSymbol("glojure.core/chunk-buffer") + sym_glojure_DOT_core_SLASH_chunk_DASH_cons := lang.NewSymbol("glojure.core/chunk-cons") + sym_glojure_DOT_core_SLASH_chunk_DASH_first := lang.NewSymbol("glojure.core/chunk-first") + sym_glojure_DOT_core_SLASH_chunk_DASH_rest := lang.NewSymbol("glojure.core/chunk-rest") + sym_glojure_DOT_core_SLASH_chunked_DASH_seq_QMARK_ := lang.NewSymbol("glojure.core/chunked-seq?") + sym_glojure_DOT_core_SLASH_class := lang.NewSymbol("glojure.core/class") + sym_glojure_DOT_core_SLASH_commute := lang.NewSymbol("glojure.core/commute") + sym_glojure_DOT_core_SLASH_compare := lang.NewSymbol("glojure.core/compare") + sym_glojure_DOT_core_SLASH_concat := lang.NewSymbol("glojure.core/concat") + sym_glojure_DOT_core_SLASH_cond := lang.NewSymbol("glojure.core/cond") + sym_glojure_DOT_core_SLASH_condp := lang.NewSymbol("glojure.core/condp") + sym_glojure_DOT_core_SLASH_conj := lang.NewSymbol("glojure.core/conj") + sym_glojure_DOT_core_SLASH_cons := lang.NewSymbol("glojure.core/cons") + sym_glojure_DOT_core_SLASH_count := lang.NewSymbol("glojure.core/count") + sym_glojure_DOT_core_SLASH_create_DASH_struct := lang.NewSymbol("glojure.core/create-struct") + sym_glojure_DOT_core_SLASH_defmulti := lang.NewSymbol("glojure.core/defmulti") + sym_glojure_DOT_core_SLASH_defn := lang.NewSymbol("glojure.core/defn") + sym_glojure_DOT_core_SLASH_deref := lang.NewSymbol("glojure.core/deref") + sym_glojure_DOT_core_SLASH_dosync := lang.NewSymbol("glojure.core/dosync") + sym_glojure_DOT_core_SLASH_double := lang.NewSymbol("glojure.core/double") + sym_glojure_DOT_core_SLASH_equiv := lang.NewSymbol("glojure.core/equiv") + sym_glojure_DOT_core_SLASH_extend := lang.NewSymbol("glojure.core/extend") + sym_glojure_DOT_core_SLASH_extend_DASH_type := lang.NewSymbol("glojure.core/extend-type") + sym_glojure_DOT_core_SLASH_first := lang.NewSymbol("glojure.core/first") + sym_glojure_DOT_core_SLASH_fn := lang.NewSymbol("glojure.core/fn") + sym_glojure_DOT_core_SLASH_future_DASH_call := lang.NewSymbol("glojure.core/future-call") + sym_glojure_DOT_core_SLASH_gen_DASH_class := lang.NewSymbol("glojure.core/gen-class") + sym_glojure_DOT_core_SLASH_get := lang.NewSymbol("glojure.core/get") + sym_glojure_DOT_core_SLASH_hash_DASH_map := lang.NewSymbol("glojure.core/hash-map") + sym_glojure_DOT_core_SLASH_i := lang.NewSymbol("glojure.core/i") + sym_glojure_DOT_core_SLASH_identical := lang.NewSymbol("glojure.core/identical") + sym_glojure_DOT_core_SLASH_if_DASH_let := lang.NewSymbol("glojure.core/if-let") + sym_glojure_DOT_core_SLASH_if_DASH_not := lang.NewSymbol("glojure.core/if-not") + sym_glojure_DOT_core_SLASH_if_DASH_some := lang.NewSymbol("glojure.core/if-some") + sym_glojure_DOT_core_SLASH_in_DASH_ns := lang.NewSymbol("glojure.core/in-ns") + sym_glojure_DOT_core_SLASH_instance_QMARK_ := lang.NewSymbol("glojure.core/instance?") + sym_glojure_DOT_core_SLASH_int := lang.NewSymbol("glojure.core/int") + sym_glojure_DOT_core_SLASH_keyword := lang.NewSymbol("glojure.core/keyword") + sym_glojure_DOT_core_SLASH_lazy_DASH_seq := lang.NewSymbol("glojure.core/lazy-seq") + sym_glojure_DOT_core_SLASH_let := lang.NewSymbol("glojure.core/let") + sym_glojure_DOT_core_SLASH_long := lang.NewSymbol("glojure.core/long") + sym_glojure_DOT_core_SLASH_loop := lang.NewSymbol("glojure.core/loop") + sym_glojure_DOT_core_SLASH_merge := lang.NewSymbol("glojure.core/merge") + sym_glojure_DOT_core_SLASH_meta := lang.NewSymbol("glojure.core/meta") + sym_glojure_DOT_core_SLASH_next := lang.NewSymbol("glojure.core/next") + sym_glojure_DOT_core_SLASH_nf := lang.NewSymbol("glojure.core/nf") + sym_glojure_DOT_core_SLASH_nil_QMARK_ := lang.NewSymbol("glojure.core/nil?") + sym_glojure_DOT_core_SLASH_not := lang.NewSymbol("glojure.core/not") + sym_glojure_DOT_core_SLASH_nth := lang.NewSymbol("glojure.core/nth") + sym_glojure_DOT_core_SLASH_or := lang.NewSymbol("glojure.core/or") + sym_glojure_DOT_core_SLASH_pcalls := lang.NewSymbol("glojure.core/pcalls") + sym_glojure_DOT_core_SLASH_pop_DASH_thread_DASH_bindings := lang.NewSymbol("glojure.core/pop-thread-bindings") + sym_glojure_DOT_core_SLASH_pr_DASH_str := lang.NewSymbol("glojure.core/pr-str") + sym_glojure_DOT_core_SLASH_prn := lang.NewSymbol("glojure.core/prn") + sym_glojure_DOT_core_SLASH_push_DASH_thread_DASH_bindings := lang.NewSymbol("glojure.core/push-thread-bindings") + sym_glojure_DOT_core_SLASH_refer := lang.NewSymbol("glojure.core/refer") + sym_glojure_DOT_core_SLASH_rest := lang.NewSymbol("glojure.core/rest") + sym_glojure_DOT_core_SLASH_seq := lang.NewSymbol("glojure.core/seq") + sym_glojure_DOT_core_SLASH_seq_QMARK_ := lang.NewSymbol("glojure.core/seq?") + sym_glojure_DOT_core_SLASH_str := lang.NewSymbol("glojure.core/str") + sym_glojure_DOT_core_SLASH_swap_BANG_ := lang.NewSymbol("glojure.core/swap!") + sym_glojure_DOT_core_SLASH_sync := lang.NewSymbol("glojure.core/sync") + sym_glojure_DOT_core_SLASH_to_DASH_array := lang.NewSymbol("glojure.core/to-array") + sym_glojure_DOT_core_SLASH_unchecked_DASH_inc := lang.NewSymbol("glojure.core/unchecked-inc") + sym_glojure_DOT_core_SLASH_unchecked_DASH_inc_DASH_int := lang.NewSymbol("glojure.core/unchecked-inc-int") + sym_glojure_DOT_core_SLASH_unquote := lang.NewSymbol("glojure.core/unquote") + sym_glojure_DOT_core_SLASH_unquote_DASH_splicing := lang.NewSymbol("glojure.core/unquote-splicing") + sym_glojure_DOT_core_SLASH_when := lang.NewSymbol("glojure.core/when") + sym_glojure_DOT_core_SLASH_when_DASH_first := lang.NewSymbol("glojure.core/when-first") + sym_glojure_DOT_core_SLASH_when_DASH_let := lang.NewSymbol("glojure.core/when-let") + sym_glojure_DOT_core_SLASH_when_DASH_not := lang.NewSymbol("glojure.core/when-not") + sym_glojure_DOT_core_SLASH_with_DASH_bindings_STAR_ := lang.NewSymbol("glojure.core/with-bindings*") + sym_glojure_DOT_core_SLASH_with_DASH_loading_DASH_context := lang.NewSymbol("glojure.core/with-loading-context") + sym_glojure_DOT_core_SLASH_with_DASH_open := lang.NewSymbol("glojure.core/with-open") + sym_glojure_DOT_core_SLASH_with_DASH_redefs_DASH_fn := lang.NewSymbol("glojure.core/with-redefs-fn") + sym_glojure_DOT_go_DOT_io := lang.NewSymbol("glojure.go.io") + sym_glojure_DOT_lang_DOT_Delay := lang.NewSymbol("glojure.lang.Delay") + sym_glojure_DOT_lang_DOT_IChunk := lang.NewSymbol("glojure.lang.IChunk") + sym_glojure_DOT_lang_DOT_LineNumberingPushbackReader_DOT_ := lang.NewSymbol("glojure.lang.LineNumberingPushbackReader.") + sym_glojure_DOT_lang_DOT_LockingTransaction_SLASH_isRunning := lang.NewSymbol("glojure.lang.LockingTransaction/isRunning") + sym_glojure_DOT_lang_DOT_PersistentArrayMap_SLASH_EMPTY := lang.NewSymbol("glojure.lang.PersistentArrayMap/EMPTY") + sym_glojure_DOT_lang_DOT_Util := lang.NewSymbol("glojure.lang.Util") + sym_glojure_DOT_string := lang.NewSymbol("glojure.string") + sym_group_DASH_by := lang.NewSymbol("group-by") + sym_h := lang.NewSymbol("h") + sym_halt_DASH_when := lang.NewSymbol("halt-when") + sym_handler_DASH_fn := lang.NewSymbol("handler-fn") + sym_hash := lang.NewSymbol("hash") + sym_hash_DASH_basis := lang.NewSymbol("hash-basis") + sym_hash_DASH_map := lang.NewSymbol("hash-map") + sym_hash_DASH_ordered_DASH_coll := lang.NewSymbol("hash-ordered-coll") + sym_hash_DASH_set := lang.NewSymbol("hash-set") + sym_hash_DASH_unordered_DASH_coll := lang.NewSymbol("hash-unordered-coll") + sym_hashes := lang.NewSymbol("hashes") + sym_ident_QMARK_ := lang.NewSymbol("ident?") + sym_identical_QMARK_ := lang.NewSymbol("identical?") + sym_identity := lang.NewSymbol("identity") + sym_idx := lang.NewSymbol("idx") + sym_idx2 := lang.NewSymbol("idx2") + sym_idx2__3__auto__ := lang.NewSymbol("idx2__3__auto__") + sym_idx__1__auto__ := lang.NewSymbol("idx__1__auto__") + sym_idxs := lang.NewSymbol("idxs") + sym_idxv := lang.NewSymbol("idxv") + sym_idxv__4__auto__ := lang.NewSymbol("idxv__4__auto__") + sym_if := lang.NewSymbol("if") + sym_if_DASH_let := lang.NewSymbol("if-let") + sym_if_DASH_not := lang.NewSymbol("if-not") + sym_if_DASH_some := lang.NewSymbol("if-some") + sym_ifn_QMARK_ := lang.NewSymbol("ifn?") + sym_import := lang.NewSymbol("import") + sym_import_DASH_symbols_DASH_or_DASH_lists := lang.NewSymbol("import-symbols-or-lists") + sym_inc := lang.NewSymbol("inc") + sym_inc_TICK_ := lang.NewSymbol("inc'") + sym_index := lang.NewSymbol("index") + sym_indexed_QMARK_ := lang.NewSymbol("indexed?") + sym_infinite_QMARK_ := lang.NewSymbol("infinite?") + sym_init := lang.NewSymbol("init") + sym_init_DASH_val_DASH_or_DASH_seq := lang.NewSymbol("init-val-or-seq") + sym_initk := lang.NewSymbol("initk") + sym_inits := lang.NewSymbol("inits") + sym_inst := lang.NewSymbol("inst") + sym_inst_DASH_ms := lang.NewSymbol("inst-ms") + sym_inst_QMARK_ := lang.NewSymbol("inst?") + sym_instance_QMARK_ := lang.NewSymbol("instance?") + sym_int := lang.NewSymbol("int") + sym_int_DASH_array := lang.NewSymbol("int-array") + sym_int_QMARK_ := lang.NewSymbol("int?") + sym_intCast := lang.NewSymbol("intCast") + sym_integer_QMARK_ := lang.NewSymbol("integer?") + sym_interface_DASH_or_DASH_naive_DASH_reduce := lang.NewSymbol("interface-or-naive-reduce") + sym_interleave := lang.NewSymbol("interleave") + sym_intern := lang.NewSymbol("intern") + sym_internal_DASH_reduce := lang.NewSymbol("internal-reduce") + sym_interpose := lang.NewSymbol("interpose") + sym_into := lang.NewSymbol("into") + sym_into_DASH_array := lang.NewSymbol("into-array") + sym_into1 := lang.NewSymbol("into1") + sym_ints := lang.NewSymbol("ints") + sym_io_BANG_ := lang.NewSymbol("io!") + sym_iref := lang.NewSymbol("iref") + sym_isa_QMARK_ := lang.NewSymbol("isa?") + sym_items := lang.NewSymbol("items") + sym_iter := lang.NewSymbol("iter") + sym_iter__0__auto__ := lang.NewSymbol("iter__0__auto__") + sym_iterate := lang.NewSymbol("iterate") + sym_iteration := lang.NewSymbol("iteration") + sym_iterator_DASH_seq := lang.NewSymbol("iterator-seq") + sym_iterys__0__auto__ := lang.NewSymbol("iterys__0__auto__") + sym_java_DOT_io_DOT_StringReader_DOT_ := lang.NewSymbol("java.io.StringReader.") + sym_java_DOT_math_DOT_MathContext_DOT_ := lang.NewSymbol("java.math.MathContext.") + sym_java_DOT_math_DOT_RoundingMode := lang.NewSymbol("java.math.RoundingMode") + sym_juxt := lang.NewSymbol("juxt") + sym_k := lang.NewSymbol("k") + sym_keep := lang.NewSymbol("keep") + sym_keep_DASH_indexed := lang.NewSymbol("keep-indexed") + sym_key := lang.NewSymbol("key") + sym_keyfn := lang.NewSymbol("keyfn") + sym_keys := lang.NewSymbol("keys") + sym_keyseq := lang.NewSymbol("keyseq") + sym_keyvals := lang.NewSymbol("keyvals") + sym_keyword := lang.NewSymbol("keyword") + sym_keyword_QMARK_ := lang.NewSymbol("keyword?") + sym_kf := lang.NewSymbol("kf") + sym_ks := lang.NewSymbol("ks") + sym_kv_DASH_reduce := lang.NewSymbol("kv-reduce") + sym_kvs := lang.NewSymbol("kvs") + sym_l__1__auto__ := lang.NewSymbol("l__1__auto__") + sym_last := lang.NewSymbol("last") + sym_lazy_DASH_cat := lang.NewSymbol("lazy-cat") + sym_lazy_DASH_seq := lang.NewSymbol("lazy-seq") + sym_len := lang.NewSymbol("len") + sym_let := lang.NewSymbol("let") + sym_let_STAR_ := lang.NewSymbol("let*") + sym_letfn := lang.NewSymbol("letfn") + sym_letfn_STAR_ := lang.NewSymbol("letfn*") + sym_lib := lang.NewSymbol("lib") + sym_libspec_QMARK_ := lang.NewSymbol("libspec?") + sym_lift_DASH_ns := lang.NewSymbol("lift-ns") + sym_line_DASH_seq := lang.NewSymbol("line-seq") + sym_list := lang.NewSymbol("list") + sym_list_STAR_ := lang.NewSymbol("list*") + sym_list_QMARK_ := lang.NewSymbol("list?") + sym_load := lang.NewSymbol("load") + sym_load_DASH_all := lang.NewSymbol("load-all") + sym_load_DASH_data_DASH_reader_DASH_file := lang.NewSymbol("load-data-reader-file") + sym_load_DASH_data_DASH_readers := lang.NewSymbol("load-data-readers") + sym_load_DASH_file := lang.NewSymbol("load-file") + sym_load_DASH_lib := lang.NewSymbol("load-lib") + sym_load_DASH_libs := lang.NewSymbol("load-libs") + sym_load_DASH_one := lang.NewSymbol("load-one") + sym_load_DASH_reader := lang.NewSymbol("load-reader") + sym_load_DASH_string := lang.NewSymbol("load-string") + sym_loaded_DASH_libs := lang.NewSymbol("loaded-libs") + sym_loading__0__auto__ := lang.NewSymbol("loading__0__auto__") + sym_lockee__0__auto__ := lang.NewSymbol("lockee__0__auto__") + sym_locking := lang.NewSymbol("locking") + sym_locklocal__1__auto__ := lang.NewSymbol("locklocal__1__auto__") + sym_long := lang.NewSymbol("long") + sym_long_DASH_array := lang.NewSymbol("long-array") + sym_longs := lang.NewSymbol("longs") + sym_loop := lang.NewSymbol("loop") + sym_loop_STAR_ := lang.NewSymbol("loop*") + sym_m := lang.NewSymbol("m") + sym_macroexpand := lang.NewSymbol("macroexpand") + sym_macroexpand_DASH_1 := lang.NewSymbol("macroexpand-1") + sym_make_DASH_array := lang.NewSymbol("make-array") + sym_make_DASH_hierarchy := lang.NewSymbol("make-hierarchy") + sym_make_DASH_input_DASH_stream := lang.NewSymbol("make-input-stream") + sym_make_DASH_output_DASH_stream := lang.NewSymbol("make-output-stream") + sym_make_DASH_reader := lang.NewSymbol("make-reader") + sym_make_DASH_writer := lang.NewSymbol("make-writer") + sym_map := lang.NewSymbol("map") + sym_map_DASH_entry_QMARK_ := lang.NewSymbol("map-entry?") + sym_map_DASH_indexed := lang.NewSymbol("map-indexed") + sym_map_QMARK_ := lang.NewSymbol("map?") + sym_mapcat := lang.NewSymbol("mapcat") + sym_mappings := lang.NewSymbol("mappings") + sym_maps := lang.NewSymbol("maps") + sym_mapv := lang.NewSymbol("mapv") + sym_mask := lang.NewSymbol("mask") + sym_math_DOT_IsNaN := lang.NewSymbol("math.IsNaN") + sym_max := lang.NewSymbol("max") + sym_max_DASH_key := lang.NewSymbol("max-key") + sym_max_DASH_mask_DASH_bits := lang.NewSymbol("max-mask-bits") + sym_max_DASH_switch_DASH_table_DASH_size := lang.NewSymbol("max-switch-table-size") + sym_maybe_DASH_destructured := lang.NewSymbol("maybe-destructured") + sym_maybe_DASH_min_DASH_hash := lang.NewSymbol("maybe-min-hash") + sym_maybe_DASH_p := lang.NewSymbol("maybe-p") + sym_memfn := lang.NewSymbol("memfn") + sym_memoize := lang.NewSymbol("memoize") + sym_merge := lang.NewSymbol("merge") + sym_merge_DASH_hash_DASH_collisions := lang.NewSymbol("merge-hash-collisions") + sym_merge_DASH_with := lang.NewSymbol("merge-with") + sym_message := lang.NewSymbol("message") + sym_meta := lang.NewSymbol("meta") + sym_metadata_DASH_map := lang.NewSymbol("metadata-map") + sym_method := lang.NewSymbol("method") + sym_methods := lang.NewSymbol("methods") + sym_min := lang.NewSymbol("min") + sym_min_DASH_key := lang.NewSymbol("min-key") + sym_minus := lang.NewSymbol("minus") + sym_minusP := lang.NewSymbol("minusP") + sym_mix_DASH_collection_DASH_hash := lang.NewSymbol("mix-collection-hash") + sym_mk_DASH_bound_DASH_fn := lang.NewSymbol("mk-bound-fn") + sym_mod := lang.NewSymbol("mod") + sym_mode_DASH_keyword := lang.NewSymbol("mode-keyword") + sym_monitor_DASH_enter := lang.NewSymbol("monitor-enter") + sym_monitor_DASH_exit := lang.NewSymbol("monitor-exit") + sym_more := lang.NewSymbol("more") + sym_more_DASH_dims := lang.NewSymbol("more-dims") + sym_msg := lang.NewSymbol("msg") + sym_multifn := lang.NewSymbol("multifn") + sym_multiply := lang.NewSymbol("multiply") + sym_multiplyP := lang.NewSymbol("multiplyP") + sym_n := lang.NewSymbol("n") + sym_n_DASH_or_DASH_q := lang.NewSymbol("n-or-q") + sym_n__0__auto__ := lang.NewSymbol("n__0__auto__") + sym_name := lang.NewSymbol("name") + sym_name_DASH_vals_DASH_vec := lang.NewSymbol("name-vals-vec") + sym_name_QMARK_ := lang.NewSymbol("name?") + sym_named := lang.NewSymbol("named") + sym_names := lang.NewSymbol("names") + sym_namespace := lang.NewSymbol("namespace") + sym_namespace_DASH_sym := lang.NewSymbol("namespace-sym") + sym_nary_DASH_inline := lang.NewSymbol("nary-inline") + sym_nat_DASH_int_QMARK_ := lang.NewSymbol("nat-int?") + sym_nav := lang.NewSymbol("nav") + sym_need_DASH_ns := lang.NewSymbol("need-ns") + sym_neg_DASH_int_QMARK_ := lang.NewSymbol("neg-int?") + sym_neg_QMARK_ := lang.NewSymbol("neg?") + sym_new := lang.NewSymbol("new") + sym_new_DASH_state := lang.NewSymbol("new-state") + sym_newline := lang.NewSymbol("newline") + sym_newval := lang.NewSymbol("newval") + sym_next := lang.NewSymbol("next") + sym_nfirst := lang.NewSymbol("nfirst") + sym_nil_QMARK_ := lang.NewSymbol("nil?") + sym_nnext := lang.NewSymbol("nnext") + sym_normalize_DASH_slurp_DASH_opts := lang.NewSymbol("normalize-slurp-opts") + sym_not := lang.NewSymbol("not") + sym_not_DASH_any_QMARK_ := lang.NewSymbol("not-any?") + sym_not_DASH_empty := lang.NewSymbol("not-empty") + sym_not_DASH_every_QMARK_ := lang.NewSymbol("not-every?") + sym_not_DASH_found := lang.NewSymbol("not-found") + sym_not_EQ_ := lang.NewSymbol("not=") + sym_ns := lang.NewSymbol("ns") + sym_ns_DASH_aliases := lang.NewSymbol("ns-aliases") + sym_ns_DASH_imports := lang.NewSymbol("ns-imports") + sym_ns_DASH_interns := lang.NewSymbol("ns-interns") + sym_ns_DASH_map := lang.NewSymbol("ns-map") + sym_ns_DASH_name := lang.NewSymbol("ns-name") + sym_ns_DASH_publics := lang.NewSymbol("ns-publics") + sym_ns_DASH_refers := lang.NewSymbol("ns-refers") + sym_ns_DASH_resolve := lang.NewSymbol("ns-resolve") + sym_ns_DASH_sym := lang.NewSymbol("ns-sym") + sym_ns_DASH_unalias := lang.NewSymbol("ns-unalias") + sym_ns_DASH_unmap := lang.NewSymbol("ns-unmap") + sym_nth := lang.NewSymbol("nth") + sym_nthnext := lang.NewSymbol("nthnext") + sym_nthrest := lang.NewSymbol("nthrest") + sym_num := lang.NewSymbol("num") + sym_number_QMARK_ := lang.NewSymbol("number?") + sym_numerator := lang.NewSymbol("numerator") + sym_o := lang.NewSymbol("o") + sym_obj := lang.NewSymbol("obj") + sym_object_DASH_array := lang.NewSymbol("object-array") + sym_odd_QMARK_ := lang.NewSymbol("odd?") + sym_oldform := lang.NewSymbol("oldform") + sym_oldval := lang.NewSymbol("oldval") + sym_op := lang.NewSymbol("op") + sym_options := lang.NewSymbol("options") + sym_opts := lang.NewSymbol("opts") + sym_opts_PLUS_sigs := lang.NewSymbol("opts+sigs") + sym_or := lang.NewSymbol("or") + sym_or__0__auto__ := lang.NewSymbol("or__0__auto__") + sym_p := lang.NewSymbol("p") + sym_p1 := lang.NewSymbol("p1") + sym_p2 := lang.NewSymbol("p2") + sym_p3 := lang.NewSymbol("p3") + sym_p__0__auto__ := lang.NewSymbol("p__0__auto__") + sym_pad := lang.NewSymbol("pad") + sym_pairs := lang.NewSymbol("pairs") + sym_params := lang.NewSymbol("params") + sym_params_STAR_ := lang.NewSymbol("params*") + sym_parent := lang.NewSymbol("parent") + sym_parents := lang.NewSymbol("parents") + sym_parse_DASH_boolean := lang.NewSymbol("parse-boolean") + sym_parse_DASH_double := lang.NewSymbol("parse-double") + sym_parse_DASH_impls := lang.NewSymbol("parse-impls") + sym_parse_DASH_long := lang.NewSymbol("parse-long") + sym_parse_DASH_uuid := lang.NewSymbol("parse-uuid") + sym_parsing_DASH_err := lang.NewSymbol("parsing-err") + sym_partial := lang.NewSymbol("partial") + sym_partition := lang.NewSymbol("partition") + sym_partition_DASH_all := lang.NewSymbol("partition-all") + sym_partition_DASH_by := lang.NewSymbol("partition-by") + sym_partitionv := lang.NewSymbol("partitionv") + sym_partitionv_DASH_all := lang.NewSymbol("partitionv-all") + sym_path := lang.NewSymbol("path") + sym_paths := lang.NewSymbol("paths") + sym_pcalls := lang.NewSymbol("pcalls") + sym_peek := lang.NewSymbol("peek") + sym_persistent_BANG_ := lang.NewSymbol("persistent!") + sym_pmap := lang.NewSymbol("pmap") + sym_pop := lang.NewSymbol("pop") + sym_pop_BANG_ := lang.NewSymbol("pop!") + sym_pop_DASH_thread_DASH_bindings := lang.NewSymbol("pop-thread-bindings") + sym_pos_DASH_int_QMARK_ := lang.NewSymbol("pos-int?") + sym_pos_QMARK_ := lang.NewSymbol("pos?") + sym_pr := lang.NewSymbol("pr") + sym_pr_DASH_on := lang.NewSymbol("pr-on") + sym_pr_DASH_str := lang.NewSymbol("pr-str") + sym_precision := lang.NewSymbol("precision") + sym_pred := lang.NewSymbol("pred") + sym_prefer_DASH_method := lang.NewSymbol("prefer-method") + sym_prefers := lang.NewSymbol("prefers") + sym_prefix := lang.NewSymbol("prefix") + sym_prefix_DASH_string := lang.NewSymbol("prefix-string") + sym_prep_DASH_hashes := lang.NewSymbol("prep-hashes") + sym_prep_DASH_ints := lang.NewSymbol("prep-ints") + sym_prependss := lang.NewSymbol("prependss") + sym_prepost_DASH_map_QMARK_ := lang.NewSymbol("prepost-map?") + sym_preserving_DASH_reduced := lang.NewSymbol("preserving-reduced") + sym_print := lang.NewSymbol("print") + sym_print_DASH_args := lang.NewSymbol("print-args") + sym_print_DASH_ctor := lang.NewSymbol("print-ctor") + sym_print_DASH_dup := lang.NewSymbol("print-dup") + sym_print_DASH_initialized := lang.NewSymbol("print-initialized") + sym_print_DASH_map := lang.NewSymbol("print-map") + sym_print_DASH_meta := lang.NewSymbol("print-meta") + sym_print_DASH_method := lang.NewSymbol("print-method") + sym_print_DASH_object := lang.NewSymbol("print-object") + sym_print_DASH_one := lang.NewSymbol("print-one") + sym_print_DASH_prefix_DASH_map := lang.NewSymbol("print-prefix-map") + sym_print_DASH_sequential := lang.NewSymbol("print-sequential") + sym_print_DASH_simple := lang.NewSymbol("print-simple") + sym_print_DASH_str := lang.NewSymbol("print-str") + sym_print_DASH_tagged_DASH_object := lang.NewSymbol("print-tagged-object") + sym_print_DASH_throwable := lang.NewSymbol("print-throwable") + sym_printf := lang.NewSymbol("printf") + sym_println := lang.NewSymbol("println") + sym_println_DASH_str := lang.NewSymbol("println-str") + sym_prn := lang.NewSymbol("prn") + sym_prn_DASH_str := lang.NewSymbol("prn-str") + sym_prob := lang.NewSymbol("prob") + sym_proc := lang.NewSymbol("proc") + sym_promise := lang.NewSymbol("promise") + sym_proto_PLUS_mmaps := lang.NewSymbol("proto+mmaps") + sym_protocol_QMARK_ := lang.NewSymbol("protocol?") + sym_ps := lang.NewSymbol("ps") + sym_push_DASH_thread_DASH_bindings := lang.NewSymbol("push-thread-bindings") + sym_pvalues := lang.NewSymbol("pvalues") + sym_qualified_DASH_ident_QMARK_ := lang.NewSymbol("qualified-ident?") + sym_qualified_DASH_keyword_QMARK_ := lang.NewSymbol("qualified-keyword?") + sym_qualified_DASH_symbol_QMARK_ := lang.NewSymbol("qualified-symbol?") + sym_quot := lang.NewSymbol("quot") + sym_quote := lang.NewSymbol("quote") + sym_r := lang.NewSymbol("r") + sym_rand := lang.NewSymbol("rand") + sym_rand_DASH_int := lang.NewSymbol("rand-int") + sym_rand_DASH_nth := lang.NewSymbol("rand-nth") + sym_random_DASH_sample := lang.NewSymbol("random-sample") + sym_random_DASH_uuid := lang.NewSymbol("random-uuid") + sym_range := lang.NewSymbol("range") + sym_ratio_QMARK_ := lang.NewSymbol("ratio?") + sym_rational_QMARK_ := lang.NewSymbol("rational?") + sym_rationalize := lang.NewSymbol("rationalize") + sym_rdr := lang.NewSymbol("rdr") + sym_re := lang.NewSymbol("re") + sym_re_DASH_find := lang.NewSymbol("re-find") + sym_re_DASH_groups := lang.NewSymbol("re-groups") + sym_re_DASH_matcher := lang.NewSymbol("re-matcher") + sym_re_DASH_matches := lang.NewSymbol("re-matches") + sym_re_DASH_pattern := lang.NewSymbol("re-pattern") + sym_re_DASH_seq := lang.NewSymbol("re-seq") + sym_read := lang.NewSymbol("read") + sym_read_PLUS_string := lang.NewSymbol("read+string") + sym_read_DASH_line := lang.NewSymbol("read-line") + sym_read_DASH_string := lang.NewSymbol("read-string") + sym_reader := lang.NewSymbol("reader") + sym_reader_DASH_conditional := lang.NewSymbol("reader-conditional") + sym_reader_DASH_conditional_QMARK_ := lang.NewSymbol("reader-conditional?") + sym_realized_QMARK_ := lang.NewSymbol("realized?") + sym_recur := lang.NewSymbol("recur") + sym_recursive_QMARK_ := lang.NewSymbol("recursive?") + sym_reduce := lang.NewSymbol("reduce") + sym_reduce_DASH_kv := lang.NewSymbol("reduce-kv") + sym_reduce1 := lang.NewSymbol("reduce1") + sym_reduced := lang.NewSymbol("reduced") + sym_reduced_QMARK_ := lang.NewSymbol("reduced?") + sym_reductions := lang.NewSymbol("reductions") + sym_ref := lang.NewSymbol("ref") + sym_ref_DASH_history_DASH_count := lang.NewSymbol("ref-history-count") + sym_ref_DASH_max_DASH_history := lang.NewSymbol("ref-max-history") + sym_ref_DASH_min_DASH_history := lang.NewSymbol("ref-min-history") + sym_ref_DASH_set := lang.NewSymbol("ref-set") + sym_refer := lang.NewSymbol("refer") + sym_refer_DASH_glojure := lang.NewSymbol("refer-glojure") + sym_reference := lang.NewSymbol("reference") + sym_references_STAR_ := lang.NewSymbol("references*") + sym_release_DASH_pending_DASH_sends := lang.NewSymbol("release-pending-sends") + sym_rem := lang.NewSymbol("rem") + sym_remove := lang.NewSymbol("remove") + sym_remove_DASH_all_DASH_methods := lang.NewSymbol("remove-all-methods") + sym_remove_DASH_method := lang.NewSymbol("remove-method") + sym_remove_DASH_ns := lang.NewSymbol("remove-ns") + sym_remove_DASH_tap := lang.NewSymbol("remove-tap") + sym_remove_DASH_watch := lang.NewSymbol("remove-watch") + sym_rep := lang.NewSymbol("rep") + sym_repeat := lang.NewSymbol("repeat") + sym_repeatedly := lang.NewSymbol("repeatedly") + sym_replace := lang.NewSymbol("replace") + sym_replicate := lang.NewSymbol("replicate") + sym_require := lang.NewSymbol("require") + sym_requiring_DASH_resolve := lang.NewSymbol("requiring-resolve") + sym_reset_BANG_ := lang.NewSymbol("reset!") + sym_reset_DASH_meta_BANG_ := lang.NewSymbol("reset-meta!") + sym_reset_DASH_vals_BANG_ := lang.NewSymbol("reset-vals!") + sym_resolve := lang.NewSymbol("resolve") + sym_rest := lang.NewSymbol("rest") + sym_restart_DASH_agent := lang.NewSymbol("restart-agent") + sym_resultset_DASH_seq := lang.NewSymbol("resultset-seq") + sym_ret := lang.NewSymbol("ret") + sym_ret__1__auto__ := lang.NewSymbol("ret__1__auto__") + sym_retf := lang.NewSymbol("retf") + sym_rev := lang.NewSymbol("rev") + sym_reverse := lang.NewSymbol("reverse") + sym_reversible_QMARK_ := lang.NewSymbol("reversible?") + sym_rf := lang.NewSymbol("rf") + sym_root := lang.NewSymbol("root") + sym_root_DASH_directory := lang.NewSymbol("root-directory") + sym_root_DASH_resource := lang.NewSymbol("root-resource") + sym_rs := lang.NewSymbol("rs") + sym_rseq := lang.NewSymbol("rseq") + sym_rsubseq := lang.NewSymbol("rsubseq") + sym_run_BANG_ := lang.NewSymbol("run!") + sym_s := lang.NewSymbol("s") + sym_s__0__auto__ := lang.NewSymbol("s__0__auto__") + sym_sc := lang.NewSymbol("sc") + sym_second := lang.NewSymbol("second") + sym_select_DASH_keys := lang.NewSymbol("select-keys") + sym_send := lang.NewSymbol("send") + sym_send_DASH_off := lang.NewSymbol("send-off") + sym_send_DASH_via := lang.NewSymbol("send-via") + sym_sep := lang.NewSymbol("sep") + sym_seq := lang.NewSymbol("seq") + sym_seq_DASH_exprs := lang.NewSymbol("seq-exprs") + sym_seq_DASH_reduce := lang.NewSymbol("seq-reduce") + sym_seq_DASH_to_DASH_map_DASH_for_DASH_destructuring := lang.NewSymbol("seq-to-map-for-destructuring") + sym_seq_QMARK_ := lang.NewSymbol("seq?") + sym_seqable_QMARK_ := lang.NewSymbol("seqable?") + sym_seque := lang.NewSymbol("seque") + sym_sequence := lang.NewSymbol("sequence") + sym_sequential_QMARK_ := lang.NewSymbol("sequential?") + sym_serialized_DASH_require := lang.NewSymbol("serialized-require") + sym_set := lang.NewSymbol("set") + sym_set_DASH_agent_DASH_send_DASH_executor_BANG_ := lang.NewSymbol("set-agent-send-executor!") + sym_set_DASH_agent_DASH_send_DASH_off_DASH_executor_BANG_ := lang.NewSymbol("set-agent-send-off-executor!") + sym_set_DASH_error_DASH_handler_BANG_ := lang.NewSymbol("set-error-handler!") + sym_set_DASH_error_DASH_mode_BANG_ := lang.NewSymbol("set-error-mode!") + sym_set_DASH_validator_BANG_ := lang.NewSymbol("set-validator!") + sym_set_QMARK_ := lang.NewSymbol("set?") + sym_setDynamic := lang.NewSymbol("setDynamic") + sym_setup_DASH_reference := lang.NewSymbol("setup-reference") + sym_shift := lang.NewSymbol("shift") + sym_shift_DASH_mask := lang.NewSymbol("shift-mask") + sym_short := lang.NewSymbol("short") + sym_short_DASH_array := lang.NewSymbol("short-array") + sym_shortCast := lang.NewSymbol("shortCast") + sym_shorts := lang.NewSymbol("shorts") + sym_shuffle := lang.NewSymbol("shuffle") + sym_shutdown_DASH_agents := lang.NewSymbol("shutdown-agents") + sym_sigs := lang.NewSymbol("sigs") + sym_simple_DASH_ident_QMARK_ := lang.NewSymbol("simple-ident?") + sym_simple_DASH_keyword_QMARK_ := lang.NewSymbol("simple-keyword?") + sym_simple_DASH_symbol_QMARK_ := lang.NewSymbol("simple-symbol?") + sym_size := lang.NewSymbol("size") + sym_size_DASH_or_DASH_seq := lang.NewSymbol("size-or-seq") + sym_size__1__auto__ := lang.NewSymbol("size__1__auto__") + sym_slurp := lang.NewSymbol("slurp") + sym_smap := lang.NewSymbol("smap") + sym_some := lang.NewSymbol("some") + sym_some_DASH__GT_ := lang.NewSymbol("some->") + sym_some_DASH__GT__GT_ := lang.NewSymbol("some->>") + sym_some_DASH_fn := lang.NewSymbol("some-fn") + sym_some_QMARK_ := lang.NewSymbol("some?") + sym_somef := lang.NewSymbol("somef") + sym_sort := lang.NewSymbol("sort") + sym_sort_DASH_by := lang.NewSymbol("sort-by") + sym_sorted_DASH_map := lang.NewSymbol("sorted-map") + sym_sorted_DASH_map_DASH_by := lang.NewSymbol("sorted-map-by") + sym_sorted_DASH_set := lang.NewSymbol("sorted-set") + sym_sorted_DASH_set_DASH_by := lang.NewSymbol("sorted-set-by") + sym_sorted_QMARK_ := lang.NewSymbol("sorted?") + sym_special_DASH_symbol_QMARK_ := lang.NewSymbol("special-symbol?") + sym_specs := lang.NewSymbol("specs") + sym_spit := lang.NewSymbol("spit") + sym_splicing_QMARK_ := lang.NewSymbol("splicing?") + sym_split_DASH_at := lang.NewSymbol("split-at") + sym_split_DASH_with := lang.NewSymbol("split-with") + sym_splitv_DASH_at := lang.NewSymbol("splitv-at") + sym_spread := lang.NewSymbol("spread") + sym_start := lang.NewSymbol("start") + sym_start_DASH_key := lang.NewSymbol("start-key") + sym_start_DASH_test := lang.NewSymbol("start-test") + sym_start__0__auto__ := lang.NewSymbol("start__0__auto__") + sym_state := lang.NewSymbol("state") + sym_step := lang.NewSymbol("step") + sym_str := lang.NewSymbol("str") + sym_stream := lang.NewSymbol("stream") + sym_stream_DASH_into_BANG_ := lang.NewSymbol("stream-into!") + sym_stream_DASH_reduce_BANG_ := lang.NewSymbol("stream-reduce!") + sym_stream_DASH_seq_BANG_ := lang.NewSymbol("stream-seq!") + sym_stream_DASH_transduce_BANG_ := lang.NewSymbol("stream-transduce!") + sym_string_QMARK_ := lang.NewSymbol("string?") + sym_strings_DOT_Builder := lang.NewSymbol("strings.Builder") + sym_strip_DASH_ns := lang.NewSymbol("strip-ns") + sym_struct := lang.NewSymbol("struct") + sym_struct_DASH_map := lang.NewSymbol("struct-map") + sym_subs := lang.NewSymbol("subs") + sym_subseq := lang.NewSymbol("subseq") + sym_subvec := lang.NewSymbol("subvec") + sym_supers := lang.NewSymbol("supers") + sym_swap_BANG_ := lang.NewSymbol("swap!") + sym_swap_DASH_vals_BANG_ := lang.NewSymbol("swap-vals!") + sym_sym := lang.NewSymbol("sym") + sym_symbol := lang.NewSymbol("symbol") + sym_symbol_QMARK_ := lang.NewSymbol("symbol?") + sym_sync := lang.NewSymbol("sync") + sym_system_DASH_newline := lang.NewSymbol("system-newline") + sym_t := lang.NewSymbol("t") + sym_tag := lang.NewSymbol("tag") + sym_tagged_DASH_literal := lang.NewSymbol("tagged-literal") + sym_tagged_DASH_literal_QMARK_ := lang.NewSymbol("tagged-literal?") + sym_take := lang.NewSymbol("take") + sym_take_DASH_last := lang.NewSymbol("take-last") + sym_take_DASH_nth := lang.NewSymbol("take-nth") + sym_take_DASH_while := lang.NewSymbol("take-while") + sym_tapset := lang.NewSymbol("tapset") + sym_temp__0__auto__ := lang.NewSymbol("temp__0__auto__") + sym_test := lang.NewSymbol("test") + sym_test_DASH_f := lang.NewSymbol("test-f") + sym_tests := lang.NewSymbol("tests") + sym_the_DASH_ns := lang.NewSymbol("the-ns") + sym_then := lang.NewSymbol("then") + sym_thens := lang.NewSymbol("thens") + sym_this := lang.NewSymbol("this") + sym_thread_DASH_bound_QMARK_ := lang.NewSymbol("thread-bound?") + sym_throw := lang.NewSymbol("throw") + sym_throw_DASH_if := lang.NewSymbol("throw-if") + sym_time := lang.NewSymbol("time") + sym_time_DOT_Now := lang.NewSymbol("time.Now") + sym_timeout_DASH_ms := lang.NewSymbol("timeout-ms") + sym_timeout_DASH_val := lang.NewSymbol("timeout-val") + sym_to := lang.NewSymbol("to") + sym_to_DASH_array := lang.NewSymbol("to-array") + sym_to_DASH_array_DASH_2d := lang.NewSymbol("to-array-2d") + sym_trampoline := lang.NewSymbol("trampoline") + sym_transduce := lang.NewSymbol("transduce") + sym_transient := lang.NewSymbol("transient") + sym_tree_DASH_seq := lang.NewSymbol("tree-seq") + sym_true_QMARK_ := lang.NewSymbol("true?") + sym_try := lang.NewSymbol("try") + sym_type := lang.NewSymbol("type") + sym_unchecked_DASH_add := lang.NewSymbol("unchecked-add") + sym_unchecked_DASH_add_DASH_int := lang.NewSymbol("unchecked-add-int") + sym_unchecked_DASH_byte := lang.NewSymbol("unchecked-byte") + sym_unchecked_DASH_char := lang.NewSymbol("unchecked-char") + sym_unchecked_DASH_dec := lang.NewSymbol("unchecked-dec") + sym_unchecked_DASH_dec_DASH_int := lang.NewSymbol("unchecked-dec-int") + sym_unchecked_DASH_divide_DASH_int := lang.NewSymbol("unchecked-divide-int") + sym_unchecked_DASH_double := lang.NewSymbol("unchecked-double") + sym_unchecked_DASH_float := lang.NewSymbol("unchecked-float") + sym_unchecked_DASH_inc := lang.NewSymbol("unchecked-inc") + sym_unchecked_DASH_inc_DASH_int := lang.NewSymbol("unchecked-inc-int") + sym_unchecked_DASH_int := lang.NewSymbol("unchecked-int") + sym_unchecked_DASH_long := lang.NewSymbol("unchecked-long") + sym_unchecked_DASH_multiply := lang.NewSymbol("unchecked-multiply") + sym_unchecked_DASH_multiply_DASH_int := lang.NewSymbol("unchecked-multiply-int") + sym_unchecked_DASH_negate := lang.NewSymbol("unchecked-negate") + sym_unchecked_DASH_negate_DASH_int := lang.NewSymbol("unchecked-negate-int") + sym_unchecked_DASH_op := lang.NewSymbol("unchecked-op") + sym_unchecked_DASH_remainder_DASH_int := lang.NewSymbol("unchecked-remainder-int") + sym_unchecked_DASH_short := lang.NewSymbol("unchecked-short") + sym_unchecked_DASH_subtract := lang.NewSymbol("unchecked-subtract") + sym_unchecked_DASH_subtract_DASH_int := lang.NewSymbol("unchecked-subtract-int") + sym_uncheckedByteCast := lang.NewSymbol("uncheckedByteCast") + sym_uncheckedCharCast := lang.NewSymbol("uncheckedCharCast") + sym_uncheckedFloatCast := lang.NewSymbol("uncheckedFloatCast") + sym_uncheckedIntCast := lang.NewSymbol("uncheckedIntCast") + sym_uncheckedShortCast := lang.NewSymbol("uncheckedShortCast") + sym_unchecked_add := lang.NewSymbol("unchecked_add") + sym_unchecked_dec := lang.NewSymbol("unchecked_dec") + sym_unchecked_inc := lang.NewSymbol("unchecked_inc") + sym_unchecked_minus := lang.NewSymbol("unchecked_minus") + sym_unchecked_multiply := lang.NewSymbol("unchecked_multiply") + sym_underive := lang.NewSymbol("underive") + sym_unquote := lang.NewSymbol("unquote") + sym_unquote_DASH_splicing := lang.NewSymbol("unquote-splicing") + sym_unreduced := lang.NewSymbol("unreduced") + sym_unsigned_DASH_bit_DASH_shift_DASH_right := lang.NewSymbol("unsigned-bit-shift-right") + sym_update := lang.NewSymbol("update") + sym_update_DASH_in := lang.NewSymbol("update-in") + sym_update_DASH_keys := lang.NewSymbol("update-keys") + sym_update_DASH_vals := lang.NewSymbol("update-vals") + sym_uri_QMARK_ := lang.NewSymbol("uri?") + sym_url := lang.NewSymbol("url") + sym_use := lang.NewSymbol("use") + sym_uuid_QMARK_ := lang.NewSymbol("uuid?") + sym_v := lang.NewSymbol("v") + sym_v__0__auto__ := lang.NewSymbol("v__0__auto__") + sym_val := lang.NewSymbol("val") + sym_val__2__auto__ := lang.NewSymbol("val__2__auto__") + sym_valid_DASH_keys := lang.NewSymbol("valid-keys") + sym_validator_DASH_fn := lang.NewSymbol("validator-fn") + sym_vals := lang.NewSymbol("vals") + sym_value := lang.NewSymbol("value") + sym_var := lang.NewSymbol("var") + sym_var_DASH_get := lang.NewSymbol("var-get") + sym_var_DASH_set := lang.NewSymbol("var-set") + sym_var_QMARK_ := lang.NewSymbol("var?") + sym_vars := lang.NewSymbol("vars") + sym_vary_DASH_meta := lang.NewSymbol("vary-meta") + sym_vec := lang.NewSymbol("vec") + sym_vector := lang.NewSymbol("vector") + sym_vector_QMARK_ := lang.NewSymbol("vector?") + sym_vf := lang.NewSymbol("vf") + sym_vol := lang.NewSymbol("vol") + sym_volatile_BANG_ := lang.NewSymbol("volatile!") + sym_volatile_QMARK_ := lang.NewSymbol("volatile?") + sym_vreset_BANG_ := lang.NewSymbol("vreset!") + sym_vswap_BANG_ := lang.NewSymbol("vswap!") + sym_w := lang.NewSymbol("w") + sym_when := lang.NewSymbol("when") + sym_when_DASH_first := lang.NewSymbol("when-first") + sym_when_DASH_let := lang.NewSymbol("when-let") + sym_when_DASH_not := lang.NewSymbol("when-not") + sym_when_DASH_some := lang.NewSymbol("when-some") + sym_while := lang.NewSymbol("while") + sym_with_DASH_bindings := lang.NewSymbol("with-bindings") + sym_with_DASH_bindings_STAR_ := lang.NewSymbol("with-bindings*") + sym_with_DASH_in_DASH_str := lang.NewSymbol("with-in-str") + sym_with_DASH_loading_DASH_context := lang.NewSymbol("with-loading-context") + sym_with_DASH_local_DASH_vars := lang.NewSymbol("with-local-vars") + sym_with_DASH_meta := lang.NewSymbol("with-meta") + sym_with_DASH_open := lang.NewSymbol("with-open") + sym_with_DASH_out_DASH_str := lang.NewSymbol("with-out-str") + sym_with_DASH_precision := lang.NewSymbol("with-precision") + sym_with_DASH_redefs := lang.NewSymbol("with-redefs") + sym_with_DASH_redefs_DASH_fn := lang.NewSymbol("with-redefs-fn") + sym_x := lang.NewSymbol("x") + sym_xform := lang.NewSymbol("xform") + sym_xml_DASH_seq := lang.NewSymbol("xml-seq") + sym_xor := lang.NewSymbol("xor") + sym_xs := lang.NewSymbol("xs") + sym_xs__0__auto__ := lang.NewSymbol("xs__0__auto__") + sym_y := lang.NewSymbol("y") + sym_ys := lang.NewSymbol("ys") + sym_z := lang.NewSymbol("z") + sym_zero_QMARK_ := lang.NewSymbol("zero?") + sym_zipmap := lang.NewSymbol("zipmap") + sym_zs := lang.NewSymbol("zs") + kw__GT__GT_ := lang.NewKeyword(">>") + kw_added := lang.NewKeyword("added") + kw_all := lang.NewKeyword("all") + kw_allow := lang.NewKeyword("allow") + kw_ancestors := lang.NewKeyword("ancestors") + kw_arglists := lang.NewKeyword("arglists") + kw_as := lang.NewKeyword("as") + kw_as_DASH_alias := lang.NewKeyword("as-alias") + kw_at := lang.NewKeyword("at") + kw_cause := lang.NewKeyword("cause") + kw_clear_DASH_actions := lang.NewKeyword("clear-actions") + kw_coll_DASH_reduce := lang.NewKeyword("coll-reduce") + kw_column := lang.NewKeyword("column") + kw_compact := lang.NewKeyword("compact") + kw_conflict := lang.NewKeyword("conflict") + kw_content := lang.NewKeyword("content") + kw_continue := lang.NewKeyword("continue") + kw_data := lang.NewKeyword("data") + kw_datafy := lang.NewKeyword("datafy") + kw_declared := lang.NewKeyword("declared") + kw_default := lang.NewKeyword("default") + kw_deprecated := lang.NewKeyword("deprecated") + kw_descendants := lang.NewKeyword("descendants") + kw_doc := lang.NewKeyword("doc") + kw_dynamic := lang.NewKeyword("dynamic") + kw_else := lang.NewKeyword("else") + kw_encoding := lang.NewKeyword("encoding") + kw_end_DASH_column := lang.NewKeyword("end-column") + kw_end_DASH_line := lang.NewKeyword("end-line") + kw_eof := lang.NewKeyword("eof") + kw_error_DASH_handler := lang.NewKeyword("error-handler") + kw_error_DASH_mode := lang.NewKeyword("error-mode") + kw_exclude := lang.NewKeyword("exclude") + kw_fail := lang.NewKeyword("fail") + kw_failed := lang.NewKeyword("failed") + kw_file := lang.NewKeyword("file") + kw_form := lang.NewKeyword("form") + kw_forms := lang.NewKeyword("forms") + kw_gen_DASH_class := lang.NewKeyword("gen-class") + kw_glojure_DOT_core_SLASH_halt := lang.NewKeyword("glojure.core/halt") + kw_glojure_DOT_core_SLASH_none := lang.NewKeyword("glojure.core/none") + kw_glojure_DOT_error_SLASH_phase := lang.NewKeyword("glojure.error/phase") + kw_hash_DASH_equiv := lang.NewKeyword("hash-equiv") + kw_hash_DASH_identity := lang.NewKeyword("hash-identity") + kw_hashes := lang.NewKeyword("hashes") + kw_hierarchy := lang.NewKeyword("hierarchy") + kw_identity := lang.NewKeyword("identity") + kw_impl_DASH_ns := lang.NewKeyword("impl-ns") + kw_initk := lang.NewKeyword("initk") + kw_inline := lang.NewKeyword("inline") + kw_inline_DASH_arities := lang.NewKeyword("inline-arities") + kw_int := lang.NewKeyword("int") + kw_internal_DASH_reduce := lang.NewKeyword("internal-reduce") + kw_ints := lang.NewKeyword("ints") + kw_keys := lang.NewKeyword("keys") + kw_kf := lang.NewKeyword("kf") + kw_kv_DASH_reduce := lang.NewKeyword("kv-reduce") + kw_let := lang.NewKeyword("let") + kw_line := lang.NewKeyword("line") + kw_macro := lang.NewKeyword("macro") + kw_main := lang.NewKeyword("main") + kw_make_DASH_input_DASH_stream := lang.NewKeyword("make-input-stream") + kw_make_DASH_output_DASH_stream := lang.NewKeyword("make-output-stream") + kw_make_DASH_reader := lang.NewKeyword("make-reader") + kw_make_DASH_writer := lang.NewKeyword("make-writer") + kw_mappings := lang.NewKeyword("mappings") + kw_max_DASH_history := lang.NewKeyword("max-history") + kw_message := lang.NewKeyword("message") + kw_meta := lang.NewKeyword("meta") + kw_min_DASH_history := lang.NewKeyword("min-history") + kw_multis := lang.NewKeyword("multis") + kw_name := lang.NewKeyword("name") + kw_nav := lang.NewKeyword("nav") + kw_no_DASH_test := lang.NewKeyword("no-test") + kw_ns := lang.NewKeyword("ns") + kw_ok := lang.NewKeyword("ok") + kw_on_DASH_interface := lang.NewKeyword("on-interface") + kw_only := lang.NewKeyword("only") + kw_or := lang.NewKeyword("or") + kw_parents := lang.NewKeyword("parents") + kw_pending := lang.NewKeyword("pending") + kw_phase := lang.NewKeyword("phase") + kw_post := lang.NewKeyword("post") + kw_pre := lang.NewKeyword("pre") + kw_private := lang.NewKeyword("private") + kw_read_DASH_cond := lang.NewKeyword("read-cond") + kw_ready := lang.NewKeyword("ready") + kw_redef := lang.NewKeyword("redef") + kw_refer := lang.NewKeyword("refer") + kw_refer_DASH_glojure := lang.NewKeyword("refer-glojure") + kw_reload := lang.NewKeyword("reload") + kw_reload_DASH_all := lang.NewKeyword("reload-all") + kw_rename := lang.NewKeyword("rename") + kw_require := lang.NewKeyword("require") + kw_rettag := lang.NewKeyword("rettag") + kw_rounding := lang.NewKeyword("rounding") + kw_sigs := lang.NewKeyword("sigs") + kw_somef := lang.NewKeyword("somef") + kw_sparse := lang.NewKeyword("sparse") + kw_special_DASH_form := lang.NewKeyword("special-form") + kw_static := lang.NewKeyword("static") + kw_status := lang.NewKeyword("status") + kw_tag := lang.NewKeyword("tag") + kw_test := lang.NewKeyword("test") + kw_trace := lang.NewKeyword("trace") + kw_type := lang.NewKeyword("type") + kw_url := lang.NewKeyword("url") + kw_use := lang.NewKeyword("use") + kw_val := lang.NewKeyword("val") + kw_validator := lang.NewKeyword("validator") + kw_verbose := lang.NewKeyword("verbose") + kw_vf := lang.NewKeyword("vf") + kw_via := lang.NewKeyword("via") + kw_when := lang.NewKeyword("when") + kw_while := lang.NewKeyword("while") // var glojure.core.protocols/coll-reduce - glojure_DOT_core_DOT_protocols_coll_reduce := lang.InternVarName(lang.NewSymbol("glojure.core.protocols"), lang.NewSymbol("coll-reduce")) + var_glojure_DOT_core_DOT_protocols_coll_DASH_reduce := lang.InternVarName(sym_glojure_DOT_core_DOT_protocols, sym_coll_DASH_reduce) // var glojure.core.protocols/interface-or-naive-reduce - glojure_DOT_core_DOT_protocols_interface_or_naive_reduce := lang.InternVarName(lang.NewSymbol("glojure.core.protocols"), lang.NewSymbol("interface-or-naive-reduce")) + var_glojure_DOT_core_DOT_protocols_interface_DASH_or_DASH_naive_DASH_reduce := lang.InternVarName(sym_glojure_DOT_core_DOT_protocols, sym_interface_DASH_or_DASH_naive_DASH_reduce) // var glojure.core.protocols/kv-reduce - glojure_DOT_core_DOT_protocols_kv_reduce := lang.InternVarName(lang.NewSymbol("glojure.core.protocols"), lang.NewSymbol("kv-reduce")) + var_glojure_DOT_core_DOT_protocols_kv_DASH_reduce := lang.InternVarName(sym_glojure_DOT_core_DOT_protocols, sym_kv_DASH_reduce) // var glojure.core.protocols/seq-reduce - glojure_DOT_core_DOT_protocols_seq_reduce := lang.InternVarName(lang.NewSymbol("glojure.core.protocols"), lang.NewSymbol("seq-reduce")) + var_glojure_DOT_core_DOT_protocols_seq_DASH_reduce := lang.InternVarName(sym_glojure_DOT_core_DOT_protocols, sym_seq_DASH_reduce) // var glojure.core/StackTraceElement->vec - glojure_DOT_core_StackTraceElement__GT_vec := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("StackTraceElement->vec")) + var_glojure_DOT_core_StackTraceElement_DASH__GT_vec := lang.InternVarName(sym_glojure_DOT_core, sym_StackTraceElement_DASH__GT_vec) // var glojure.core/Throwable->map - glojure_DOT_core_Throwable__GT_map := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("Throwable->map")) + var_glojure_DOT_core_Throwable_DASH__GT_map := lang.InternVarName(sym_glojure_DOT_core, sym_Throwable_DASH__GT_map) // var glojure.core/- - glojure_DOT_core__ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("-")) + var_glojure_DOT_core__DASH_ := lang.InternVarName(sym_glojure_DOT_core, sym__DASH_) + // var glojure.core/-' + var_glojure_DOT_core__DASH__TICK_ := lang.InternVarName(sym_glojure_DOT_core, sym__DASH__TICK_) // var glojure.core/= - glojure_DOT_core__EQ_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("=")) + var_glojure_DOT_core__EQ_ := lang.InternVarName(sym_glojure_DOT_core, sym__EQ_) // var glojure.core/== - glojure_DOT_core__EQ__EQ_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("==")) + var_glojure_DOT_core__EQ__EQ_ := lang.InternVarName(sym_glojure_DOT_core, sym__EQ__EQ_) // var glojure.core/> - glojure_DOT_core__GT_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol(">")) + var_glojure_DOT_core__GT_ := lang.InternVarName(sym_glojure_DOT_core, sym__GT_) // var glojure.core/>= - glojure_DOT_core__GT__EQ_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol(">=")) + var_glojure_DOT_core__GT__EQ_ := lang.InternVarName(sym_glojure_DOT_core, sym__GT__EQ_) // var glojure.core/< - glojure_DOT_core__LT_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("<")) + var_glojure_DOT_core__LT_ := lang.InternVarName(sym_glojure_DOT_core, sym__LT_) // var glojure.core/<= - glojure_DOT_core__LT__EQ_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("<=")) + var_glojure_DOT_core__LT__EQ_ := lang.InternVarName(sym_glojure_DOT_core, sym__LT__EQ_) // var glojure.core/+ - glojure_DOT_core__PLUS_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("+")) + var_glojure_DOT_core__PLUS_ := lang.InternVarName(sym_glojure_DOT_core, sym__PLUS_) // var glojure.core/+' - glojure_DOT_core__PLUS__U0027_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("+'")) + var_glojure_DOT_core__PLUS__TICK_ := lang.InternVarName(sym_glojure_DOT_core, sym__PLUS__TICK_) // var glojure.core// - glojure_DOT_core__SLASH_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("/")) + var_glojure_DOT_core__SLASH_ := lang.InternVarName(sym_glojure_DOT_core, sym__SLASH_) // var glojure.core/* - glojure_DOT_core__STAR_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*")) + var_glojure_DOT_core__STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_) // var glojure.core/*' - glojure_DOT_core__STAR__U0027_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*'")) + var_glojure_DOT_core__STAR__TICK_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR__TICK_) // var glojure.core/*agent* - glojure_DOT_core__STAR_agent_STAR_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*agent*")) + var_glojure_DOT_core__STAR_agent_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_agent_STAR_) // var glojure.core/*assert* - glojure_DOT_core__STAR_assert_STAR_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*assert*")) + var_glojure_DOT_core__STAR_assert_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_assert_STAR_) // var glojure.core/*file* - glojure_DOT_core__STAR_file_STAR_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*file*")) + var_glojure_DOT_core__STAR_file_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_file_STAR_) // var glojure.core/*flush-on-newline* - glojure_DOT_core__STAR_flush_on_newline_STAR_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*flush-on-newline*")) + var_glojure_DOT_core__STAR_flush_DASH_on_DASH_newline_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_flush_DASH_on_DASH_newline_STAR_) // var glojure.core/*in* - glojure_DOT_core__STAR_in_STAR_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*in*")) + var_glojure_DOT_core__STAR_in_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_in_STAR_) // var glojure.core/*loaded-libs* - glojure_DOT_core__STAR_loaded_libs_STAR_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*loaded-libs*")) + var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_loaded_DASH_libs_STAR_) // var glojure.core/*loading-verbosely* - glojure_DOT_core__STAR_loading_verbosely_STAR_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*loading-verbosely*")) + var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_loading_DASH_verbosely_STAR_) // var glojure.core/*ns* - glojure_DOT_core__STAR_ns_STAR_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*ns*")) + var_glojure_DOT_core__STAR_ns_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_ns_STAR_) // var glojure.core/*out* - glojure_DOT_core__STAR_out_STAR_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*out*")) + var_glojure_DOT_core__STAR_out_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) // var glojure.core/*pending-paths* - glojure_DOT_core__STAR_pending_paths_STAR_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*pending-paths*")) + var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_pending_DASH_paths_STAR_) // var glojure.core/*print-dup* - glojure_DOT_core__STAR_print_dup_STAR_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*print-dup*")) + var_glojure_DOT_core__STAR_print_DASH_dup_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_print_DASH_dup_STAR_) // var glojure.core/*print-length* - glojure_DOT_core__STAR_print_length_STAR_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*print-length*")) + var_glojure_DOT_core__STAR_print_DASH_length_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_print_DASH_length_STAR_) // var glojure.core/*print-level* - glojure_DOT_core__STAR_print_level_STAR_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*print-level*")) + var_glojure_DOT_core__STAR_print_DASH_level_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_print_DASH_level_STAR_) // var glojure.core/*print-meta* - glojure_DOT_core__STAR_print_meta_STAR_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*print-meta*")) + var_glojure_DOT_core__STAR_print_DASH_meta_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_print_DASH_meta_STAR_) // var glojure.core/*print-namespace-maps* - glojure_DOT_core__STAR_print_namespace_maps_STAR_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*print-namespace-maps*")) + var_glojure_DOT_core__STAR_print_DASH_namespace_DASH_maps_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_print_DASH_namespace_DASH_maps_STAR_) // var glojure.core/*print-readably* - glojure_DOT_core__STAR_print_readably_STAR_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*print-readably*")) + var_glojure_DOT_core__STAR_print_DASH_readably_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_print_DASH_readably_STAR_) // var glojure.core/*unchecked-math* - glojure_DOT_core__STAR_unchecked_math_STAR_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*unchecked-math*")) + var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_unchecked_DASH_math_STAR_) // var glojure.core/*verbose-defrecords* - glojure_DOT_core__STAR_verbose_defrecords_STAR_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*verbose-defrecords*")) - // var glojure.core/-' - glojure_DOT_core___U0027_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("-'")) + var_glojure_DOT_core__STAR_verbose_DASH_defrecords_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_verbose_DASH_defrecords_STAR_) // var glojure.core/agent - glojure_DOT_core_agent := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("agent")) + var_glojure_DOT_core_agent := lang.InternVarName(sym_glojure_DOT_core, sym_agent) // var glojure.core/agent-error - glojure_DOT_core_agent_error := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("agent-error")) + var_glojure_DOT_core_agent_DASH_error := lang.InternVarName(sym_glojure_DOT_core, sym_agent_DASH_error) // var glojure.core/aget - glojure_DOT_core_aget := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("aget")) + var_glojure_DOT_core_aget := lang.InternVarName(sym_glojure_DOT_core, sym_aget) // var glojure.core/alength - glojure_DOT_core_alength := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("alength")) + var_glojure_DOT_core_alength := lang.InternVarName(sym_glojure_DOT_core, sym_alength) // var glojure.core/alias - glojure_DOT_core_alias := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("alias")) + var_glojure_DOT_core_alias := lang.InternVarName(sym_glojure_DOT_core, sym_alias) // var glojure.core/alter-var-root - glojure_DOT_core_alter_var_root := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("alter-var-root")) + var_glojure_DOT_core_alter_DASH_var_DASH_root := lang.InternVarName(sym_glojure_DOT_core, sym_alter_DASH_var_DASH_root) // var glojure.core/ancestors - glojure_DOT_core_ancestors := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("ancestors")) + var_glojure_DOT_core_ancestors := lang.InternVarName(sym_glojure_DOT_core, sym_ancestors) // var glojure.core/apply - glojure_DOT_core_apply := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("apply")) + var_glojure_DOT_core_apply := lang.InternVarName(sym_glojure_DOT_core, sym_apply) // var glojure.core/aset - glojure_DOT_core_aset := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("aset")) + var_glojure_DOT_core_aset := lang.InternVarName(sym_glojure_DOT_core, sym_aset) // var glojure.core/aset-boolean - glojure_DOT_core_aset_boolean := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("aset-boolean")) + var_glojure_DOT_core_aset_DASH_boolean := lang.InternVarName(sym_glojure_DOT_core, sym_aset_DASH_boolean) // var glojure.core/aset-byte - glojure_DOT_core_aset_byte := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("aset-byte")) + var_glojure_DOT_core_aset_DASH_byte := lang.InternVarName(sym_glojure_DOT_core, sym_aset_DASH_byte) // var glojure.core/aset-char - glojure_DOT_core_aset_char := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("aset-char")) + var_glojure_DOT_core_aset_DASH_char := lang.InternVarName(sym_glojure_DOT_core, sym_aset_DASH_char) // var glojure.core/aset-double - glojure_DOT_core_aset_double := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("aset-double")) + var_glojure_DOT_core_aset_DASH_double := lang.InternVarName(sym_glojure_DOT_core, sym_aset_DASH_double) // var glojure.core/aset-float - glojure_DOT_core_aset_float := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("aset-float")) + var_glojure_DOT_core_aset_DASH_float := lang.InternVarName(sym_glojure_DOT_core, sym_aset_DASH_float) // var glojure.core/aset-int - glojure_DOT_core_aset_int := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("aset-int")) + var_glojure_DOT_core_aset_DASH_int := lang.InternVarName(sym_glojure_DOT_core, sym_aset_DASH_int) // var glojure.core/aset-long - glojure_DOT_core_aset_long := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("aset-long")) + var_glojure_DOT_core_aset_DASH_long := lang.InternVarName(sym_glojure_DOT_core, sym_aset_DASH_long) // var glojure.core/aset-short - glojure_DOT_core_aset_short := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("aset-short")) + var_glojure_DOT_core_aset_DASH_short := lang.InternVarName(sym_glojure_DOT_core, sym_aset_DASH_short) // var glojure.core/assert-valid-fdecl - glojure_DOT_core_assert_valid_fdecl := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("assert-valid-fdecl")) + var_glojure_DOT_core_assert_DASH_valid_DASH_fdecl := lang.InternVarName(sym_glojure_DOT_core, sym_assert_DASH_valid_DASH_fdecl) // var glojure.core/assoc - glojure_DOT_core_assoc := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("assoc")) + var_glojure_DOT_core_assoc := lang.InternVarName(sym_glojure_DOT_core, sym_assoc) // var glojure.core/assoc! - glojure_DOT_core_assoc_BANG_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("assoc!")) + var_glojure_DOT_core_assoc_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_assoc_BANG_) // var glojure.core/assoc-in - glojure_DOT_core_assoc_in := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("assoc-in")) + var_glojure_DOT_core_assoc_DASH_in := lang.InternVarName(sym_glojure_DOT_core, sym_assoc_DASH_in) // var glojure.core/atom - glojure_DOT_core_atom := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("atom")) + var_glojure_DOT_core_atom := lang.InternVarName(sym_glojure_DOT_core, sym_atom) // var glojure.core/await - glojure_DOT_core_await := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("await")) + var_glojure_DOT_core_await := lang.InternVarName(sym_glojure_DOT_core, sym_await) // var glojure.core/bases - glojure_DOT_core_bases := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("bases")) + var_glojure_DOT_core_bases := lang.InternVarName(sym_glojure_DOT_core, sym_bases) // var glojure.core/bigint - glojure_DOT_core_bigint := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("bigint")) + var_glojure_DOT_core_bigint := lang.InternVarName(sym_glojure_DOT_core, sym_bigint) // var glojure.core/binding-conveyor-fn - glojure_DOT_core_binding_conveyor_fn := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("binding-conveyor-fn")) + var_glojure_DOT_core_binding_DASH_conveyor_DASH_fn := lang.InternVarName(sym_glojure_DOT_core, sym_binding_DASH_conveyor_DASH_fn) // var glojure.core/bit-and - glojure_DOT_core_bit_and := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("bit-and")) + var_glojure_DOT_core_bit_DASH_and := lang.InternVarName(sym_glojure_DOT_core, sym_bit_DASH_and) // var glojure.core/bit-and-not - glojure_DOT_core_bit_and_not := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("bit-and-not")) + var_glojure_DOT_core_bit_DASH_and_DASH_not := lang.InternVarName(sym_glojure_DOT_core, sym_bit_DASH_and_DASH_not) // var glojure.core/bit-or - glojure_DOT_core_bit_or := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("bit-or")) + var_glojure_DOT_core_bit_DASH_or := lang.InternVarName(sym_glojure_DOT_core, sym_bit_DASH_or) // var glojure.core/bit-shift-left - glojure_DOT_core_bit_shift_left := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("bit-shift-left")) + var_glojure_DOT_core_bit_DASH_shift_DASH_left := lang.InternVarName(sym_glojure_DOT_core, sym_bit_DASH_shift_DASH_left) // var glojure.core/bit-shift-right - glojure_DOT_core_bit_shift_right := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("bit-shift-right")) + var_glojure_DOT_core_bit_DASH_shift_DASH_right := lang.InternVarName(sym_glojure_DOT_core, sym_bit_DASH_shift_DASH_right) // var glojure.core/bit-xor - glojure_DOT_core_bit_xor := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("bit-xor")) + var_glojure_DOT_core_bit_DASH_xor := lang.InternVarName(sym_glojure_DOT_core, sym_bit_DASH_xor) // var glojure.core/boolean - glojure_DOT_core_boolean := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("boolean")) + var_glojure_DOT_core_boolean := lang.InternVarName(sym_glojure_DOT_core, sym_boolean) // var glojure.core/butlast - glojure_DOT_core_butlast := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("butlast")) + var_glojure_DOT_core_butlast := lang.InternVarName(sym_glojure_DOT_core, sym_butlast) // var glojure.core/byte - glojure_DOT_core_byte := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("byte")) + var_glojure_DOT_core_byte := lang.InternVarName(sym_glojure_DOT_core, sym_byte) // var glojure.core/case-map - glojure_DOT_core_case_map := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("case-map")) + var_glojure_DOT_core_case_DASH_map := lang.InternVarName(sym_glojure_DOT_core, sym_case_DASH_map) // var glojure.core/cat - glojure_DOT_core_cat := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("cat")) + var_glojure_DOT_core_cat := lang.InternVarName(sym_glojure_DOT_core, sym_cat) // var glojure.core/char - glojure_DOT_core_char := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("char")) + var_glojure_DOT_core_char := lang.InternVarName(sym_glojure_DOT_core, sym_char) // var glojure.core/char-escape-string - glojure_DOT_core_char_escape_string := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("char-escape-string")) + var_glojure_DOT_core_char_DASH_escape_DASH_string := lang.InternVarName(sym_glojure_DOT_core, sym_char_DASH_escape_DASH_string) // var glojure.core/char-name-string - glojure_DOT_core_char_name_string := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("char-name-string")) + var_glojure_DOT_core_char_DASH_name_DASH_string := lang.InternVarName(sym_glojure_DOT_core, sym_char_DASH_name_DASH_string) // var glojure.core/check-cyclic-dependency - glojure_DOT_core_check_cyclic_dependency := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("check-cyclic-dependency")) + var_glojure_DOT_core_check_DASH_cyclic_DASH_dependency := lang.InternVarName(sym_glojure_DOT_core, sym_check_DASH_cyclic_DASH_dependency) // var glojure.core/check-valid-options - glojure_DOT_core_check_valid_options := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("check-valid-options")) + var_glojure_DOT_core_check_DASH_valid_DASH_options := lang.InternVarName(sym_glojure_DOT_core, sym_check_DASH_valid_DASH_options) // var glojure.core/chunk - glojure_DOT_core_chunk := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("chunk")) + var_glojure_DOT_core_chunk := lang.InternVarName(sym_glojure_DOT_core, sym_chunk) // var glojure.core/chunk-append - glojure_DOT_core_chunk_append := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("chunk-append")) + var_glojure_DOT_core_chunk_DASH_append := lang.InternVarName(sym_glojure_DOT_core, sym_chunk_DASH_append) // var glojure.core/chunk-buffer - glojure_DOT_core_chunk_buffer := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("chunk-buffer")) + var_glojure_DOT_core_chunk_DASH_buffer := lang.InternVarName(sym_glojure_DOT_core, sym_chunk_DASH_buffer) // var glojure.core/chunk-cons - glojure_DOT_core_chunk_cons := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("chunk-cons")) + var_glojure_DOT_core_chunk_DASH_cons := lang.InternVarName(sym_glojure_DOT_core, sym_chunk_DASH_cons) // var glojure.core/chunk-first - glojure_DOT_core_chunk_first := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("chunk-first")) + var_glojure_DOT_core_chunk_DASH_first := lang.InternVarName(sym_glojure_DOT_core, sym_chunk_DASH_first) // var glojure.core/chunk-next - glojure_DOT_core_chunk_next := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("chunk-next")) + var_glojure_DOT_core_chunk_DASH_next := lang.InternVarName(sym_glojure_DOT_core, sym_chunk_DASH_next) // var glojure.core/chunk-rest - glojure_DOT_core_chunk_rest := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("chunk-rest")) + var_glojure_DOT_core_chunk_DASH_rest := lang.InternVarName(sym_glojure_DOT_core, sym_chunk_DASH_rest) // var glojure.core/chunked-seq? - glojure_DOT_core_chunked_seq_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("chunked-seq?")) + var_glojure_DOT_core_chunked_DASH_seq_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_chunked_DASH_seq_QMARK_) // var glojure.core/class - glojure_DOT_core_class := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("class")) + var_glojure_DOT_core_class := lang.InternVarName(sym_glojure_DOT_core, sym_class) // var glojure.core/class? - glojure_DOT_core_class_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("class?")) + var_glojure_DOT_core_class_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_class_QMARK_) // var glojure.core/commute - glojure_DOT_core_commute := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("commute")) + var_glojure_DOT_core_commute := lang.InternVarName(sym_glojure_DOT_core, sym_commute) // var glojure.core/comp - glojure_DOT_core_comp := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("comp")) + var_glojure_DOT_core_comp := lang.InternVarName(sym_glojure_DOT_core, sym_comp) // var glojure.core/compare - glojure_DOT_core_compare := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("compare")) + var_glojure_DOT_core_compare := lang.InternVarName(sym_glojure_DOT_core, sym_compare) // var glojure.core/compare-and-set! - glojure_DOT_core_compare_and_set_BANG_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("compare-and-set!")) + var_glojure_DOT_core_compare_DASH_and_DASH_set_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_compare_DASH_and_DASH_set_BANG_) // var glojure.core/complement - glojure_DOT_core_complement := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("complement")) + var_glojure_DOT_core_complement := lang.InternVarName(sym_glojure_DOT_core, sym_complement) // var glojure.core/completing - glojure_DOT_core_completing := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("completing")) + var_glojure_DOT_core_completing := lang.InternVarName(sym_glojure_DOT_core, sym_completing) // var glojure.core/concat - glojure_DOT_core_concat := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("concat")) + var_glojure_DOT_core_concat := lang.InternVarName(sym_glojure_DOT_core, sym_concat) // var glojure.core/conj - glojure_DOT_core_conj := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("conj")) + var_glojure_DOT_core_conj := lang.InternVarName(sym_glojure_DOT_core, sym_conj) // var glojure.core/conj! - glojure_DOT_core_conj_BANG_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("conj!")) + var_glojure_DOT_core_conj_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_conj_BANG_) // var glojure.core/cons - glojure_DOT_core_cons := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("cons")) + var_glojure_DOT_core_cons := lang.InternVarName(sym_glojure_DOT_core, sym_cons) // var glojure.core/contains? - glojure_DOT_core_contains_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("contains?")) + var_glojure_DOT_core_contains_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_contains_QMARK_) // var glojure.core/count - glojure_DOT_core_count := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("count")) + var_glojure_DOT_core_count := lang.InternVarName(sym_glojure_DOT_core, sym_count) // var glojure.core/counted? - glojure_DOT_core_counted_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("counted?")) + var_glojure_DOT_core_counted_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_counted_QMARK_) // var glojure.core/create-ns - glojure_DOT_core_create_ns := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("create-ns")) + var_glojure_DOT_core_create_DASH_ns := lang.InternVarName(sym_glojure_DOT_core, sym_create_DASH_ns) // var glojure.core/create-struct - glojure_DOT_core_create_struct := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("create-struct")) + var_glojure_DOT_core_create_DASH_struct := lang.InternVarName(sym_glojure_DOT_core, sym_create_DASH_struct) // var glojure.core/data-reader-urls - glojure_DOT_core_data_reader_urls := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("data-reader-urls")) + var_glojure_DOT_core_data_DASH_reader_DASH_urls := lang.InternVarName(sym_glojure_DOT_core, sym_data_DASH_reader_DASH_urls) // var glojure.core/data-reader-var - glojure_DOT_core_data_reader_var := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("data-reader-var")) + var_glojure_DOT_core_data_DASH_reader_DASH_var := lang.InternVarName(sym_glojure_DOT_core, sym_data_DASH_reader_DASH_var) // var glojure.core/dec - glojure_DOT_core_dec := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("dec")) + var_glojure_DOT_core_dec := lang.InternVarName(sym_glojure_DOT_core, sym_dec) // var glojure.core/decimal? - glojure_DOT_core_decimal_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("decimal?")) + var_glojure_DOT_core_decimal_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_decimal_QMARK_) // var glojure.core/dedupe - glojure_DOT_core_dedupe := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("dedupe")) + var_glojure_DOT_core_dedupe := lang.InternVarName(sym_glojure_DOT_core, sym_dedupe) // var glojure.core/deref - glojure_DOT_core_deref := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("deref")) + var_glojure_DOT_core_deref := lang.InternVarName(sym_glojure_DOT_core, sym_deref) // var glojure.core/deref-as-map - glojure_DOT_core_deref_as_map := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("deref-as-map")) + var_glojure_DOT_core_deref_DASH_as_DASH_map := lang.InternVarName(sym_glojure_DOT_core, sym_deref_DASH_as_DASH_map) // var glojure.core/deref-future - glojure_DOT_core_deref_future := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("deref-future")) + var_glojure_DOT_core_deref_DASH_future := lang.InternVarName(sym_glojure_DOT_core, sym_deref_DASH_future) // var glojure.core/derive - glojure_DOT_core_derive := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("derive")) + var_glojure_DOT_core_derive := lang.InternVarName(sym_glojure_DOT_core, sym_derive) // var glojure.core/descendants - glojure_DOT_core_descendants := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("descendants")) + var_glojure_DOT_core_descendants := lang.InternVarName(sym_glojure_DOT_core, sym_descendants) // var glojure.core/destructure - glojure_DOT_core_destructure := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("destructure")) + var_glojure_DOT_core_destructure := lang.InternVarName(sym_glojure_DOT_core, sym_destructure) // var glojure.core/disj - glojure_DOT_core_disj := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("disj")) + var_glojure_DOT_core_disj := lang.InternVarName(sym_glojure_DOT_core, sym_disj) // var glojure.core/dissoc - glojure_DOT_core_dissoc := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("dissoc")) + var_glojure_DOT_core_dissoc := lang.InternVarName(sym_glojure_DOT_core, sym_dissoc) // var glojure.core/distinct? - glojure_DOT_core_distinct_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("distinct?")) + var_glojure_DOT_core_distinct_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_distinct_QMARK_) // var glojure.core/doall - glojure_DOT_core_doall := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("doall")) + var_glojure_DOT_core_doall := lang.InternVarName(sym_glojure_DOT_core, sym_doall) // var glojure.core/dorun - glojure_DOT_core_dorun := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("dorun")) + var_glojure_DOT_core_dorun := lang.InternVarName(sym_glojure_DOT_core, sym_dorun) // var glojure.core/double - glojure_DOT_core_double := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("double")) + var_glojure_DOT_core_double := lang.InternVarName(sym_glojure_DOT_core, sym_double) // var glojure.core/drop - glojure_DOT_core_drop := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("drop")) + var_glojure_DOT_core_drop := lang.InternVarName(sym_glojure_DOT_core, sym_drop) // var glojure.core/drop-last - glojure_DOT_core_drop_last := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("drop-last")) + var_glojure_DOT_core_drop_DASH_last := lang.InternVarName(sym_glojure_DOT_core, sym_drop_DASH_last) // var glojure.core/drop-while - glojure_DOT_core_drop_while := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("drop-while")) + var_glojure_DOT_core_drop_DASH_while := lang.InternVarName(sym_glojure_DOT_core, sym_drop_DASH_while) // var glojure.core/elide-top-frames - glojure_DOT_core_elide_top_frames := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("elide-top-frames")) + var_glojure_DOT_core_elide_DASH_top_DASH_frames := lang.InternVarName(sym_glojure_DOT_core, sym_elide_DASH_top_DASH_frames) // var glojure.core/emit-extend-protocol - glojure_DOT_core_emit_extend_protocol := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("emit-extend-protocol")) + var_glojure_DOT_core_emit_DASH_extend_DASH_protocol := lang.InternVarName(sym_glojure_DOT_core, sym_emit_DASH_extend_DASH_protocol) // var glojure.core/emit-extend-type - glojure_DOT_core_emit_extend_type := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("emit-extend-type")) + var_glojure_DOT_core_emit_DASH_extend_DASH_type := lang.InternVarName(sym_glojure_DOT_core, sym_emit_DASH_extend_DASH_type) // var glojure.core/emit-hinted-impl - glojure_DOT_core_emit_hinted_impl := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("emit-hinted-impl")) + var_glojure_DOT_core_emit_DASH_hinted_DASH_impl := lang.InternVarName(sym_glojure_DOT_core, sym_emit_DASH_hinted_DASH_impl) // var glojure.core/empty? - glojure_DOT_core_empty_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("empty?")) + var_glojure_DOT_core_empty_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_empty_QMARK_) // var glojure.core/ensure-reduced - glojure_DOT_core_ensure_reduced := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("ensure-reduced")) + var_glojure_DOT_core_ensure_DASH_reduced := lang.InternVarName(sym_glojure_DOT_core, sym_ensure_DASH_reduced) // var glojure.core/eval - glojure_DOT_core_eval := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("eval")) + var_glojure_DOT_core_eval := lang.InternVarName(sym_glojure_DOT_core, sym_eval) // var glojure.core/even? - glojure_DOT_core_even_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("even?")) + var_glojure_DOT_core_even_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_even_QMARK_) // var glojure.core/every? - glojure_DOT_core_every_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("every?")) + var_glojure_DOT_core_every_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_every_QMARK_) // var glojure.core/ex-data - glojure_DOT_core_ex_data := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("ex-data")) + var_glojure_DOT_core_ex_DASH_data := lang.InternVarName(sym_glojure_DOT_core, sym_ex_DASH_data) // var glojure.core/ex-info - glojure_DOT_core_ex_info := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("ex-info")) + var_glojure_DOT_core_ex_DASH_info := lang.InternVarName(sym_glojure_DOT_core, sym_ex_DASH_info) // var glojure.core/ffirst - glojure_DOT_core_ffirst := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("ffirst")) + var_glojure_DOT_core_ffirst := lang.InternVarName(sym_glojure_DOT_core, sym_ffirst) // var glojure.core/filter - glojure_DOT_core_filter := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("filter")) + var_glojure_DOT_core_filter := lang.InternVarName(sym_glojure_DOT_core, sym_filter) // var glojure.core/filter-key - glojure_DOT_core_filter_key := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("filter-key")) + var_glojure_DOT_core_filter_DASH_key := lang.InternVarName(sym_glojure_DOT_core, sym_filter_DASH_key) // var glojure.core/find - glojure_DOT_core_find := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("find")) + var_glojure_DOT_core_find := lang.InternVarName(sym_glojure_DOT_core, sym_find) // var glojure.core/find-ns - glojure_DOT_core_find_ns := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("find-ns")) + var_glojure_DOT_core_find_DASH_ns := lang.InternVarName(sym_glojure_DOT_core, sym_find_DASH_ns) // var glojure.core/first - glojure_DOT_core_first := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("first")) + var_glojure_DOT_core_first := lang.InternVarName(sym_glojure_DOT_core, sym_first) // var glojure.core/fits-table? - glojure_DOT_core_fits_table_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("fits-table?")) + var_glojure_DOT_core_fits_DASH_table_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_fits_DASH_table_QMARK_) // var glojure.core/flatten - glojure_DOT_core_flatten := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("flatten")) + var_glojure_DOT_core_flatten := lang.InternVarName(sym_glojure_DOT_core, sym_flatten) // var glojure.core/float - glojure_DOT_core_float := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("float")) + var_glojure_DOT_core_float := lang.InternVarName(sym_glojure_DOT_core, sym_float) // var glojure.core/float? - glojure_DOT_core_float_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("float?")) + var_glojure_DOT_core_float_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_float_QMARK_) // var glojure.core/flush - glojure_DOT_core_flush := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("flush")) + var_glojure_DOT_core_flush := lang.InternVarName(sym_glojure_DOT_core, sym_flush) // var glojure.core/fn? - glojure_DOT_core_fn_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("fn?")) + var_glojure_DOT_core_fn_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_fn_QMARK_) // var glojure.core/fnil - glojure_DOT_core_fnil := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("fnil")) + var_glojure_DOT_core_fnil := lang.InternVarName(sym_glojure_DOT_core, sym_fnil) // var glojure.core/format - glojure_DOT_core_format := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("format")) + var_glojure_DOT_core_format := lang.InternVarName(sym_glojure_DOT_core, sym_format) // var glojure.core/future-call - glojure_DOT_core_future_call := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("future-call")) + var_glojure_DOT_core_future_DASH_call := lang.InternVarName(sym_glojure_DOT_core, sym_future_DASH_call) // var glojure.core/gensym - glojure_DOT_core_gensym := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("gensym")) + var_glojure_DOT_core_gensym := lang.InternVarName(sym_glojure_DOT_core, sym_gensym) // var glojure.core/get - glojure_DOT_core_get := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("get")) + var_glojure_DOT_core_get := lang.InternVarName(sym_glojure_DOT_core, sym_get) // var glojure.core/get-in - glojure_DOT_core_get_in := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("get-in")) + var_glojure_DOT_core_get_DASH_in := lang.InternVarName(sym_glojure_DOT_core, sym_get_DASH_in) // var glojure.core/get-thread-bindings - glojure_DOT_core_get_thread_bindings := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("get-thread-bindings")) + var_glojure_DOT_core_get_DASH_thread_DASH_bindings := lang.InternVarName(sym_glojure_DOT_core, sym_get_DASH_thread_DASH_bindings) // var glojure.core/global-hierarchy - glojure_DOT_core_global_hierarchy := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("global-hierarchy")) + var_glojure_DOT_core_global_DASH_hierarchy := lang.InternVarName(sym_glojure_DOT_core, sym_global_DASH_hierarchy) // var glojure.core/halt-when - glojure_DOT_core_halt_when := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("halt-when")) + var_glojure_DOT_core_halt_DASH_when := lang.InternVarName(sym_glojure_DOT_core, sym_halt_DASH_when) // var glojure.core/hash-map - glojure_DOT_core_hash_map := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("hash-map")) + var_glojure_DOT_core_hash_DASH_map := lang.InternVarName(sym_glojure_DOT_core, sym_hash_DASH_map) // var glojure.core/hash-set - glojure_DOT_core_hash_set := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("hash-set")) + var_glojure_DOT_core_hash_DASH_set := lang.InternVarName(sym_glojure_DOT_core, sym_hash_DASH_set) // var glojure.core/ident? - glojure_DOT_core_ident_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("ident?")) + var_glojure_DOT_core_ident_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_ident_QMARK_) // var glojure.core/identical? - glojure_DOT_core_identical_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("identical?")) + var_glojure_DOT_core_identical_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_identical_QMARK_) // var glojure.core/identity - glojure_DOT_core_identity := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("identity")) + var_glojure_DOT_core_identity := lang.InternVarName(sym_glojure_DOT_core, sym_identity) // var glojure.core/inc - glojure_DOT_core_inc := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("inc")) + var_glojure_DOT_core_inc := lang.InternVarName(sym_glojure_DOT_core, sym_inc) // var glojure.core/inc' - glojure_DOT_core_inc_U0027_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("inc'")) + var_glojure_DOT_core_inc_TICK_ := lang.InternVarName(sym_glojure_DOT_core, sym_inc_TICK_) // var glojure.core/instance? - glojure_DOT_core_instance_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("instance?")) + var_glojure_DOT_core_instance_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_instance_QMARK_) // var glojure.core/int - glojure_DOT_core_int := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("int")) + var_glojure_DOT_core_int := lang.InternVarName(sym_glojure_DOT_core, sym_int) // var glojure.core/int? - glojure_DOT_core_int_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("int?")) + var_glojure_DOT_core_int_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_int_QMARK_) // var glojure.core/integer? - glojure_DOT_core_integer_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("integer?")) + var_glojure_DOT_core_integer_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_integer_QMARK_) // var glojure.core/interleave - glojure_DOT_core_interleave := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("interleave")) + var_glojure_DOT_core_interleave := lang.InternVarName(sym_glojure_DOT_core, sym_interleave) // var glojure.core/intern - glojure_DOT_core_intern := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("intern")) + var_glojure_DOT_core_intern := lang.InternVarName(sym_glojure_DOT_core, sym_intern) // var glojure.core/interpose - glojure_DOT_core_interpose := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("interpose")) + var_glojure_DOT_core_interpose := lang.InternVarName(sym_glojure_DOT_core, sym_interpose) // var glojure.core/into - glojure_DOT_core_into := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("into")) + var_glojure_DOT_core_into := lang.InternVarName(sym_glojure_DOT_core, sym_into) // var glojure.core/into1 - glojure_DOT_core_into1 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("into1")) + var_glojure_DOT_core_into1 := lang.InternVarName(sym_glojure_DOT_core, sym_into1) // var glojure.core/into-array - glojure_DOT_core_into_array := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("into-array")) + var_glojure_DOT_core_into_DASH_array := lang.InternVarName(sym_glojure_DOT_core, sym_into_DASH_array) // var glojure.core/isa? - glojure_DOT_core_isa_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("isa?")) + var_glojure_DOT_core_isa_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_isa_QMARK_) // var glojure.core/iterate - glojure_DOT_core_iterate := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("iterate")) + var_glojure_DOT_core_iterate := lang.InternVarName(sym_glojure_DOT_core, sym_iterate) // var glojure.core/iterator-seq - glojure_DOT_core_iterator_seq := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("iterator-seq")) + var_glojure_DOT_core_iterator_DASH_seq := lang.InternVarName(sym_glojure_DOT_core, sym_iterator_DASH_seq) // var glojure.core/keep - glojure_DOT_core_keep := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("keep")) + var_glojure_DOT_core_keep := lang.InternVarName(sym_glojure_DOT_core, sym_keep) // var glojure.core/key - glojure_DOT_core_key := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("key")) + var_glojure_DOT_core_key := lang.InternVarName(sym_glojure_DOT_core, sym_key) // var glojure.core/keys - glojure_DOT_core_keys := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("keys")) + var_glojure_DOT_core_keys := lang.InternVarName(sym_glojure_DOT_core, sym_keys) // var glojure.core/keyword - glojure_DOT_core_keyword := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("keyword")) + var_glojure_DOT_core_keyword := lang.InternVarName(sym_glojure_DOT_core, sym_keyword) // var glojure.core/keyword? - glojure_DOT_core_keyword_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("keyword?")) + var_glojure_DOT_core_keyword_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_keyword_QMARK_) // var glojure.core/last - glojure_DOT_core_last := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("last")) + var_glojure_DOT_core_last := lang.InternVarName(sym_glojure_DOT_core, sym_last) // var glojure.core/libspec? - glojure_DOT_core_libspec_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("libspec?")) + var_glojure_DOT_core_libspec_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_libspec_QMARK_) // var glojure.core/lift-ns - glojure_DOT_core_lift_ns := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("lift-ns")) + var_glojure_DOT_core_lift_DASH_ns := lang.InternVarName(sym_glojure_DOT_core, sym_lift_DASH_ns) // var glojure.core/line-seq - glojure_DOT_core_line_seq := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("line-seq")) + var_glojure_DOT_core_line_DASH_seq := lang.InternVarName(sym_glojure_DOT_core, sym_line_DASH_seq) // var glojure.core/list - glojure_DOT_core_list := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("list")) + var_glojure_DOT_core_list := lang.InternVarName(sym_glojure_DOT_core, sym_list) // var glojure.core/list* - glojure_DOT_core_list_STAR_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("list*")) + var_glojure_DOT_core_list_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym_list_STAR_) // var glojure.core/load - glojure_DOT_core_load := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("load")) + var_glojure_DOT_core_load := lang.InternVarName(sym_glojure_DOT_core, sym_load) // var glojure.core/load-all - glojure_DOT_core_load_all := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("load-all")) + var_glojure_DOT_core_load_DASH_all := lang.InternVarName(sym_glojure_DOT_core, sym_load_DASH_all) // var glojure.core/load-data-reader-file - glojure_DOT_core_load_data_reader_file := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("load-data-reader-file")) + var_glojure_DOT_core_load_DASH_data_DASH_reader_DASH_file := lang.InternVarName(sym_glojure_DOT_core, sym_load_DASH_data_DASH_reader_DASH_file) // var glojure.core/load-lib - glojure_DOT_core_load_lib := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("load-lib")) + var_glojure_DOT_core_load_DASH_lib := lang.InternVarName(sym_glojure_DOT_core, sym_load_DASH_lib) // var glojure.core/load-libs - glojure_DOT_core_load_libs := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("load-libs")) + var_glojure_DOT_core_load_DASH_libs := lang.InternVarName(sym_glojure_DOT_core, sym_load_DASH_libs) // var glojure.core/load-one - glojure_DOT_core_load_one := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("load-one")) + var_glojure_DOT_core_load_DASH_one := lang.InternVarName(sym_glojure_DOT_core, sym_load_DASH_one) // var glojure.core/load-reader - glojure_DOT_core_load_reader := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("load-reader")) + var_glojure_DOT_core_load_DASH_reader := lang.InternVarName(sym_glojure_DOT_core, sym_load_DASH_reader) // var glojure.core/long - glojure_DOT_core_long := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("long")) + var_glojure_DOT_core_long := lang.InternVarName(sym_glojure_DOT_core, sym_long) // var glojure.core/macroexpand - glojure_DOT_core_macroexpand := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("macroexpand")) + var_glojure_DOT_core_macroexpand := lang.InternVarName(sym_glojure_DOT_core, sym_macroexpand) // var glojure.core/macroexpand-1 - glojure_DOT_core_macroexpand_1 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("macroexpand-1")) + var_glojure_DOT_core_macroexpand_DASH_1 := lang.InternVarName(sym_glojure_DOT_core, sym_macroexpand_DASH_1) // var glojure.core/make-array - glojure_DOT_core_make_array := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("make-array")) + var_glojure_DOT_core_make_DASH_array := lang.InternVarName(sym_glojure_DOT_core, sym_make_DASH_array) // var glojure.core/make-hierarchy - glojure_DOT_core_make_hierarchy := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("make-hierarchy")) + var_glojure_DOT_core_make_DASH_hierarchy := lang.InternVarName(sym_glojure_DOT_core, sym_make_DASH_hierarchy) // var glojure.core/map - glojure_DOT_core_map := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("map")) + var_glojure_DOT_core_map := lang.InternVarName(sym_glojure_DOT_core, sym_map) // var glojure.core/map? - glojure_DOT_core_map_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("map?")) + var_glojure_DOT_core_map_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_map_QMARK_) // var glojure.core/mapcat - glojure_DOT_core_mapcat := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("mapcat")) + var_glojure_DOT_core_mapcat := lang.InternVarName(sym_glojure_DOT_core, sym_mapcat) // var glojure.core/max - glojure_DOT_core_max := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("max")) + var_glojure_DOT_core_max := lang.InternVarName(sym_glojure_DOT_core, sym_max) // var glojure.core/max-mask-bits - glojure_DOT_core_max_mask_bits := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("max-mask-bits")) + var_glojure_DOT_core_max_DASH_mask_DASH_bits := lang.InternVarName(sym_glojure_DOT_core, sym_max_DASH_mask_DASH_bits) // var glojure.core/max-switch-table-size - glojure_DOT_core_max_switch_table_size := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("max-switch-table-size")) + var_glojure_DOT_core_max_DASH_switch_DASH_table_DASH_size := lang.InternVarName(sym_glojure_DOT_core, sym_max_DASH_switch_DASH_table_DASH_size) // var glojure.core/maybe-destructured - glojure_DOT_core_maybe_destructured := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("maybe-destructured")) + var_glojure_DOT_core_maybe_DASH_destructured := lang.InternVarName(sym_glojure_DOT_core, sym_maybe_DASH_destructured) // var glojure.core/maybe-min-hash - glojure_DOT_core_maybe_min_hash := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("maybe-min-hash")) + var_glojure_DOT_core_maybe_DASH_min_DASH_hash := lang.InternVarName(sym_glojure_DOT_core, sym_maybe_DASH_min_DASH_hash) // var glojure.core/merge - glojure_DOT_core_merge := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("merge")) + var_glojure_DOT_core_merge := lang.InternVarName(sym_glojure_DOT_core, sym_merge) // var glojure.core/merge-hash-collisions - glojure_DOT_core_merge_hash_collisions := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("merge-hash-collisions")) + var_glojure_DOT_core_merge_DASH_hash_DASH_collisions := lang.InternVarName(sym_glojure_DOT_core, sym_merge_DASH_hash_DASH_collisions) // var glojure.core/meta - glojure_DOT_core_meta := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("meta")) + var_glojure_DOT_core_meta := lang.InternVarName(sym_glojure_DOT_core, sym_meta) // var glojure.core/min - glojure_DOT_core_min := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("min")) + var_glojure_DOT_core_min := lang.InternVarName(sym_glojure_DOT_core, sym_min) // var glojure.core/mk-bound-fn - glojure_DOT_core_mk_bound_fn := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("mk-bound-fn")) + var_glojure_DOT_core_mk_DASH_bound_DASH_fn := lang.InternVarName(sym_glojure_DOT_core, sym_mk_DASH_bound_DASH_fn) // var glojure.core/name - glojure_DOT_core_name := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("name")) + var_glojure_DOT_core_name := lang.InternVarName(sym_glojure_DOT_core, sym_name) // var glojure.core/namespace - glojure_DOT_core_namespace := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("namespace")) + var_glojure_DOT_core_namespace := lang.InternVarName(sym_glojure_DOT_core, sym_namespace) // var glojure.core/nary-inline - glojure_DOT_core_nary_inline := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("nary-inline")) + var_glojure_DOT_core_nary_DASH_inline := lang.InternVarName(sym_glojure_DOT_core, sym_nary_DASH_inline) // var glojure.core/neg? - glojure_DOT_core_neg_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("neg?")) + var_glojure_DOT_core_neg_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_neg_QMARK_) // var glojure.core/newline - glojure_DOT_core_newline := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("newline")) + var_glojure_DOT_core_newline := lang.InternVarName(sym_glojure_DOT_core, sym_newline) // var glojure.core/next - glojure_DOT_core_next := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("next")) + var_glojure_DOT_core_next := lang.InternVarName(sym_glojure_DOT_core, sym_next) // var glojure.core/nil? - glojure_DOT_core_nil_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("nil?")) + var_glojure_DOT_core_nil_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_nil_QMARK_) // var glojure.core/nnext - glojure_DOT_core_nnext := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("nnext")) + var_glojure_DOT_core_nnext := lang.InternVarName(sym_glojure_DOT_core, sym_nnext) // var glojure.core/normalize-slurp-opts - glojure_DOT_core_normalize_slurp_opts := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("normalize-slurp-opts")) + var_glojure_DOT_core_normalize_DASH_slurp_DASH_opts := lang.InternVarName(sym_glojure_DOT_core, sym_normalize_DASH_slurp_DASH_opts) // var glojure.core/not - glojure_DOT_core_not := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("not")) - // var glojure.core/not= - glojure_DOT_core_not_EQ_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("not=")) + var_glojure_DOT_core_not := lang.InternVarName(sym_glojure_DOT_core, sym_not) // var glojure.core/not-any? - glojure_DOT_core_not_any_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("not-any?")) + var_glojure_DOT_core_not_DASH_any_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_not_DASH_any_QMARK_) // var glojure.core/not-empty - glojure_DOT_core_not_empty := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("not-empty")) + var_glojure_DOT_core_not_DASH_empty := lang.InternVarName(sym_glojure_DOT_core, sym_not_DASH_empty) + // var glojure.core/not= + var_glojure_DOT_core_not_EQ_ := lang.InternVarName(sym_glojure_DOT_core, sym_not_EQ_) // var glojure.core/ns-map - glojure_DOT_core_ns_map := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("ns-map")) + var_glojure_DOT_core_ns_DASH_map := lang.InternVarName(sym_glojure_DOT_core, sym_ns_DASH_map) // var glojure.core/ns-name - glojure_DOT_core_ns_name := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("ns-name")) + var_glojure_DOT_core_ns_DASH_name := lang.InternVarName(sym_glojure_DOT_core, sym_ns_DASH_name) // var glojure.core/ns-publics - glojure_DOT_core_ns_publics := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("ns-publics")) + var_glojure_DOT_core_ns_DASH_publics := lang.InternVarName(sym_glojure_DOT_core, sym_ns_DASH_publics) // var glojure.core/ns-resolve - glojure_DOT_core_ns_resolve := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("ns-resolve")) + var_glojure_DOT_core_ns_DASH_resolve := lang.InternVarName(sym_glojure_DOT_core, sym_ns_DASH_resolve) // var glojure.core/nth - glojure_DOT_core_nth := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("nth")) + var_glojure_DOT_core_nth := lang.InternVarName(sym_glojure_DOT_core, sym_nth) // var glojure.core/nthrest - glojure_DOT_core_nthrest := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("nthrest")) + var_glojure_DOT_core_nthrest := lang.InternVarName(sym_glojure_DOT_core, sym_nthrest) // var glojure.core/number? - glojure_DOT_core_number_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("number?")) + var_glojure_DOT_core_number_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_number_QMARK_) // var glojure.core/odd? - glojure_DOT_core_odd_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("odd?")) + var_glojure_DOT_core_odd_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_odd_QMARK_) // var glojure.core/parents - glojure_DOT_core_parents := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("parents")) + var_glojure_DOT_core_parents := lang.InternVarName(sym_glojure_DOT_core, sym_parents) // var glojure.core/parse-impls - glojure_DOT_core_parse_impls := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("parse-impls")) + var_glojure_DOT_core_parse_DASH_impls := lang.InternVarName(sym_glojure_DOT_core, sym_parse_DASH_impls) // var glojure.core/parsing-err - glojure_DOT_core_parsing_err := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("parsing-err")) + var_glojure_DOT_core_parsing_DASH_err := lang.InternVarName(sym_glojure_DOT_core, sym_parsing_DASH_err) // var glojure.core/partial - glojure_DOT_core_partial := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("partial")) + var_glojure_DOT_core_partial := lang.InternVarName(sym_glojure_DOT_core, sym_partial) // var glojure.core/partition - glojure_DOT_core_partition := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("partition")) + var_glojure_DOT_core_partition := lang.InternVarName(sym_glojure_DOT_core, sym_partition) // var glojure.core/partition-all - glojure_DOT_core_partition_all := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("partition-all")) + var_glojure_DOT_core_partition_DASH_all := lang.InternVarName(sym_glojure_DOT_core, sym_partition_DASH_all) // var glojure.core/partition-by - glojure_DOT_core_partition_by := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("partition-by")) + var_glojure_DOT_core_partition_DASH_by := lang.InternVarName(sym_glojure_DOT_core, sym_partition_DASH_by) // var glojure.core/partitionv - glojure_DOT_core_partitionv := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("partitionv")) + var_glojure_DOT_core_partitionv := lang.InternVarName(sym_glojure_DOT_core, sym_partitionv) // var glojure.core/partitionv-all - glojure_DOT_core_partitionv_all := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("partitionv-all")) + var_glojure_DOT_core_partitionv_DASH_all := lang.InternVarName(sym_glojure_DOT_core, sym_partitionv_DASH_all) // var glojure.core/peek - glojure_DOT_core_peek := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("peek")) + var_glojure_DOT_core_peek := lang.InternVarName(sym_glojure_DOT_core, sym_peek) // var glojure.core/persistent! - glojure_DOT_core_persistent_BANG_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("persistent!")) + var_glojure_DOT_core_persistent_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_persistent_BANG_) // var glojure.core/pmap - glojure_DOT_core_pmap := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("pmap")) + var_glojure_DOT_core_pmap := lang.InternVarName(sym_glojure_DOT_core, sym_pmap) // var glojure.core/pop - glojure_DOT_core_pop := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("pop")) + var_glojure_DOT_core_pop := lang.InternVarName(sym_glojure_DOT_core, sym_pop) // var glojure.core/pop-thread-bindings - glojure_DOT_core_pop_thread_bindings := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("pop-thread-bindings")) + var_glojure_DOT_core_pop_DASH_thread_DASH_bindings := lang.InternVarName(sym_glojure_DOT_core, sym_pop_DASH_thread_DASH_bindings) // var glojure.core/pos? - glojure_DOT_core_pos_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("pos?")) + var_glojure_DOT_core_pos_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_pos_QMARK_) // var glojure.core/pr - glojure_DOT_core_pr := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("pr")) + var_glojure_DOT_core_pr := lang.InternVarName(sym_glojure_DOT_core, sym_pr) // var glojure.core/pr-on - glojure_DOT_core_pr_on := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("pr-on")) + var_glojure_DOT_core_pr_DASH_on := lang.InternVarName(sym_glojure_DOT_core, sym_pr_DASH_on) // var glojure.core/pr-str - glojure_DOT_core_pr_str := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("pr-str")) + var_glojure_DOT_core_pr_DASH_str := lang.InternVarName(sym_glojure_DOT_core, sym_pr_DASH_str) // var glojure.core/prep-hashes - glojure_DOT_core_prep_hashes := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("prep-hashes")) + var_glojure_DOT_core_prep_DASH_hashes := lang.InternVarName(sym_glojure_DOT_core, sym_prep_DASH_hashes) // var glojure.core/prep-ints - glojure_DOT_core_prep_ints := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("prep-ints")) + var_glojure_DOT_core_prep_DASH_ints := lang.InternVarName(sym_glojure_DOT_core, sym_prep_DASH_ints) // var glojure.core/prependss - glojure_DOT_core_prependss := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("prependss")) + var_glojure_DOT_core_prependss := lang.InternVarName(sym_glojure_DOT_core, sym_prependss) // var glojure.core/preserving-reduced - glojure_DOT_core_preserving_reduced := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("preserving-reduced")) + var_glojure_DOT_core_preserving_DASH_reduced := lang.InternVarName(sym_glojure_DOT_core, sym_preserving_DASH_reduced) // var glojure.core/print - glojure_DOT_core_print := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("print")) + var_glojure_DOT_core_print := lang.InternVarName(sym_glojure_DOT_core, sym_print) // var glojure.core/print-ctor - glojure_DOT_core_print_ctor := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("print-ctor")) + var_glojure_DOT_core_print_DASH_ctor := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_ctor) // var glojure.core/print-dup - glojure_DOT_core_print_dup := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("print-dup")) + var_glojure_DOT_core_print_DASH_dup := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_dup) // var glojure.core/print-map - glojure_DOT_core_print_map := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("print-map")) + var_glojure_DOT_core_print_DASH_map := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_map) // var glojure.core/print-meta - glojure_DOT_core_print_meta := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("print-meta")) + var_glojure_DOT_core_print_DASH_meta := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_meta) // var glojure.core/print-method - glojure_DOT_core_print_method := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("print-method")) + var_glojure_DOT_core_print_DASH_method := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_method) // var glojure.core/print-object - glojure_DOT_core_print_object := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("print-object")) + var_glojure_DOT_core_print_DASH_object := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_object) // var glojure.core/print-prefix-map - glojure_DOT_core_print_prefix_map := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("print-prefix-map")) + var_glojure_DOT_core_print_DASH_prefix_DASH_map := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_prefix_DASH_map) // var glojure.core/print-sequential - glojure_DOT_core_print_sequential := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("print-sequential")) + var_glojure_DOT_core_print_DASH_sequential := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_sequential) // var glojure.core/print-simple - glojure_DOT_core_print_simple := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("print-simple")) + var_glojure_DOT_core_print_DASH_simple := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_simple) // var glojure.core/print-str - glojure_DOT_core_print_str := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("print-str")) + var_glojure_DOT_core_print_DASH_str := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_str) // var glojure.core/print-tagged-object - glojure_DOT_core_print_tagged_object := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("print-tagged-object")) + var_glojure_DOT_core_print_DASH_tagged_DASH_object := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_tagged_DASH_object) // var glojure.core/printf - glojure_DOT_core_printf := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("printf")) + var_glojure_DOT_core_printf := lang.InternVarName(sym_glojure_DOT_core, sym_printf) // var glojure.core/println - glojure_DOT_core_println := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("println")) + var_glojure_DOT_core_println := lang.InternVarName(sym_glojure_DOT_core, sym_println) // var glojure.core/prn - glojure_DOT_core_prn := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("prn")) + var_glojure_DOT_core_prn := lang.InternVarName(sym_glojure_DOT_core, sym_prn) // var glojure.core/protocol? - glojure_DOT_core_protocol_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("protocol?")) + var_glojure_DOT_core_protocol_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_protocol_QMARK_) // var glojure.core/push-thread-bindings - glojure_DOT_core_push_thread_bindings := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("push-thread-bindings")) + var_glojure_DOT_core_push_DASH_thread_DASH_bindings := lang.InternVarName(sym_glojure_DOT_core, sym_push_DASH_thread_DASH_bindings) // var glojure.core/qualified-ident? - glojure_DOT_core_qualified_ident_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("qualified-ident?")) + var_glojure_DOT_core_qualified_DASH_ident_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_qualified_DASH_ident_QMARK_) // var glojure.core/qualified-symbol? - glojure_DOT_core_qualified_symbol_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("qualified-symbol?")) + var_glojure_DOT_core_qualified_DASH_symbol_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_qualified_DASH_symbol_QMARK_) // var glojure.core/rand - glojure_DOT_core_rand := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("rand")) + var_glojure_DOT_core_rand := lang.InternVarName(sym_glojure_DOT_core, sym_rand) // var glojure.core/rand-int - glojure_DOT_core_rand_int := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("rand-int")) + var_glojure_DOT_core_rand_DASH_int := lang.InternVarName(sym_glojure_DOT_core, sym_rand_DASH_int) // var glojure.core/range - glojure_DOT_core_range := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("range")) + var_glojure_DOT_core_range := lang.InternVarName(sym_glojure_DOT_core, sym_range) // var glojure.core/ratio? - glojure_DOT_core_ratio_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("ratio?")) + var_glojure_DOT_core_ratio_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_ratio_QMARK_) // var glojure.core/re-find - glojure_DOT_core_re_find := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("re-find")) + var_glojure_DOT_core_re_DASH_find := lang.InternVarName(sym_glojure_DOT_core, sym_re_DASH_find) // var glojure.core/re-groups - glojure_DOT_core_re_groups := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("re-groups")) + var_glojure_DOT_core_re_DASH_groups := lang.InternVarName(sym_glojure_DOT_core, sym_re_DASH_groups) // var glojure.core/re-matcher - glojure_DOT_core_re_matcher := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("re-matcher")) + var_glojure_DOT_core_re_DASH_matcher := lang.InternVarName(sym_glojure_DOT_core, sym_re_DASH_matcher) // var glojure.core/read - glojure_DOT_core_read := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("read")) + var_glojure_DOT_core_read := lang.InternVarName(sym_glojure_DOT_core, sym_read) // var glojure.core/read+string - glojure_DOT_core_read_PLUS_string := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("read+string")) + var_glojure_DOT_core_read_PLUS_string := lang.InternVarName(sym_glojure_DOT_core, sym_read_PLUS_string) // var glojure.core/reduce - glojure_DOT_core_reduce := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("reduce")) + var_glojure_DOT_core_reduce := lang.InternVarName(sym_glojure_DOT_core, sym_reduce) // var glojure.core/reduce1 - glojure_DOT_core_reduce1 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("reduce1")) + var_glojure_DOT_core_reduce1 := lang.InternVarName(sym_glojure_DOT_core, sym_reduce1) // var glojure.core/reduce-kv - glojure_DOT_core_reduce_kv := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("reduce-kv")) + var_glojure_DOT_core_reduce_DASH_kv := lang.InternVarName(sym_glojure_DOT_core, sym_reduce_DASH_kv) // var glojure.core/reduced - glojure_DOT_core_reduced := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("reduced")) + var_glojure_DOT_core_reduced := lang.InternVarName(sym_glojure_DOT_core, sym_reduced) // var glojure.core/reduced? - glojure_DOT_core_reduced_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("reduced?")) + var_glojure_DOT_core_reduced_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_reduced_QMARK_) // var glojure.core/reductions - glojure_DOT_core_reductions := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("reductions")) + var_glojure_DOT_core_reductions := lang.InternVarName(sym_glojure_DOT_core, sym_reductions) // var glojure.core/ref - glojure_DOT_core_ref := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("ref")) + var_glojure_DOT_core_ref := lang.InternVarName(sym_glojure_DOT_core, sym_ref) // var glojure.core/refer - glojure_DOT_core_refer := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("refer")) + var_glojure_DOT_core_refer := lang.InternVarName(sym_glojure_DOT_core, sym_refer) // var glojure.core/release-pending-sends - glojure_DOT_core_release_pending_sends := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("release-pending-sends")) + var_glojure_DOT_core_release_DASH_pending_DASH_sends := lang.InternVarName(sym_glojure_DOT_core, sym_release_DASH_pending_DASH_sends) // var glojure.core/rem - glojure_DOT_core_rem := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("rem")) + var_glojure_DOT_core_rem := lang.InternVarName(sym_glojure_DOT_core, sym_rem) // var glojure.core/remove - glojure_DOT_core_remove := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("remove")) + var_glojure_DOT_core_remove := lang.InternVarName(sym_glojure_DOT_core, sym_remove) // var glojure.core/remove-ns - glojure_DOT_core_remove_ns := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("remove-ns")) + var_glojure_DOT_core_remove_DASH_ns := lang.InternVarName(sym_glojure_DOT_core, sym_remove_DASH_ns) // var glojure.core/repeat - glojure_DOT_core_repeat := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("repeat")) + var_glojure_DOT_core_repeat := lang.InternVarName(sym_glojure_DOT_core, sym_repeat) // var glojure.core/repeatedly - glojure_DOT_core_repeatedly := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("repeatedly")) + var_glojure_DOT_core_repeatedly := lang.InternVarName(sym_glojure_DOT_core, sym_repeatedly) // var glojure.core/require - glojure_DOT_core_require := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("require")) + var_glojure_DOT_core_require := lang.InternVarName(sym_glojure_DOT_core, sym_require) // var glojure.core/resolve - glojure_DOT_core_resolve := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("resolve")) + var_glojure_DOT_core_resolve := lang.InternVarName(sym_glojure_DOT_core, sym_resolve) // var glojure.core/rest - glojure_DOT_core_rest := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("rest")) + var_glojure_DOT_core_rest := lang.InternVarName(sym_glojure_DOT_core, sym_rest) // var glojure.core/restart-agent - glojure_DOT_core_restart_agent := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("restart-agent")) + var_glojure_DOT_core_restart_DASH_agent := lang.InternVarName(sym_glojure_DOT_core, sym_restart_DASH_agent) // var glojure.core/root-directory - glojure_DOT_core_root_directory := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("root-directory")) + var_glojure_DOT_core_root_DASH_directory := lang.InternVarName(sym_glojure_DOT_core, sym_root_DASH_directory) // var glojure.core/root-resource - glojure_DOT_core_root_resource := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("root-resource")) + var_glojure_DOT_core_root_DASH_resource := lang.InternVarName(sym_glojure_DOT_core, sym_root_DASH_resource) // var glojure.core/second - glojure_DOT_core_second := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("second")) + var_glojure_DOT_core_second := lang.InternVarName(sym_glojure_DOT_core, sym_second) // var glojure.core/select-keys - glojure_DOT_core_select_keys := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("select-keys")) + var_glojure_DOT_core_select_DASH_keys := lang.InternVarName(sym_glojure_DOT_core, sym_select_DASH_keys) // var glojure.core/send - glojure_DOT_core_send := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("send")) + var_glojure_DOT_core_send := lang.InternVarName(sym_glojure_DOT_core, sym_send) // var glojure.core/send-off - glojure_DOT_core_send_off := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("send-off")) + var_glojure_DOT_core_send_DASH_off := lang.InternVarName(sym_glojure_DOT_core, sym_send_DASH_off) // var glojure.core/send-via - glojure_DOT_core_send_via := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("send-via")) + var_glojure_DOT_core_send_DASH_via := lang.InternVarName(sym_glojure_DOT_core, sym_send_DASH_via) // var glojure.core/seq - glojure_DOT_core_seq := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("seq")) + var_glojure_DOT_core_seq := lang.InternVarName(sym_glojure_DOT_core, sym_seq) // var glojure.core/seq? - glojure_DOT_core_seq_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("seq?")) + var_glojure_DOT_core_seq_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_seq_QMARK_) // var glojure.core/seque - glojure_DOT_core_seque := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("seque")) + var_glojure_DOT_core_seque := lang.InternVarName(sym_glojure_DOT_core, sym_seque) // var glojure.core/sequence - glojure_DOT_core_sequence := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("sequence")) + var_glojure_DOT_core_sequence := lang.InternVarName(sym_glojure_DOT_core, sym_sequence) // var glojure.core/sequential? - glojure_DOT_core_sequential_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("sequential?")) + var_glojure_DOT_core_sequential_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_sequential_QMARK_) // var glojure.core/serialized-require - glojure_DOT_core_serialized_require := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("serialized-require")) + var_glojure_DOT_core_serialized_DASH_require := lang.InternVarName(sym_glojure_DOT_core, sym_serialized_DASH_require) // var glojure.core/set - glojure_DOT_core_set := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("set")) + var_glojure_DOT_core_set := lang.InternVarName(sym_glojure_DOT_core, sym_set) // var glojure.core/set? - glojure_DOT_core_set_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("set?")) + var_glojure_DOT_core_set_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_set_QMARK_) // var glojure.core/setup-reference - glojure_DOT_core_setup_reference := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("setup-reference")) + var_glojure_DOT_core_setup_DASH_reference := lang.InternVarName(sym_glojure_DOT_core, sym_setup_DASH_reference) // var glojure.core/shift-mask - glojure_DOT_core_shift_mask := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("shift-mask")) + var_glojure_DOT_core_shift_DASH_mask := lang.InternVarName(sym_glojure_DOT_core, sym_shift_DASH_mask) // var glojure.core/short - glojure_DOT_core_short := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("short")) + var_glojure_DOT_core_short := lang.InternVarName(sym_glojure_DOT_core, sym_short) // var glojure.core/sigs - glojure_DOT_core_sigs := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("sigs")) + var_glojure_DOT_core_sigs := lang.InternVarName(sym_glojure_DOT_core, sym_sigs) // var glojure.core/some - glojure_DOT_core_some := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("some")) + var_glojure_DOT_core_some := lang.InternVarName(sym_glojure_DOT_core, sym_some) // var glojure.core/some? - glojure_DOT_core_some_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("some?")) + var_glojure_DOT_core_some_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_some_QMARK_) // var glojure.core/sort - glojure_DOT_core_sort := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("sort")) + var_glojure_DOT_core_sort := lang.InternVarName(sym_glojure_DOT_core, sym_sort) // var glojure.core/sort-by - glojure_DOT_core_sort_by := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("sort-by")) + var_glojure_DOT_core_sort_DASH_by := lang.InternVarName(sym_glojure_DOT_core, sym_sort_DASH_by) // var glojure.core/sorted-map - glojure_DOT_core_sorted_map := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("sorted-map")) + var_glojure_DOT_core_sorted_DASH_map := lang.InternVarName(sym_glojure_DOT_core, sym_sorted_DASH_map) // var glojure.core/sorted-set - glojure_DOT_core_sorted_set := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("sorted-set")) + var_glojure_DOT_core_sorted_DASH_set := lang.InternVarName(sym_glojure_DOT_core, sym_sorted_DASH_set) // var glojure.core/split-at - glojure_DOT_core_split_at := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("split-at")) + var_glojure_DOT_core_split_DASH_at := lang.InternVarName(sym_glojure_DOT_core, sym_split_DASH_at) // var glojure.core/split-with - glojure_DOT_core_split_with := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("split-with")) + var_glojure_DOT_core_split_DASH_with := lang.InternVarName(sym_glojure_DOT_core, sym_split_DASH_with) // var glojure.core/spread - glojure_DOT_core_spread := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("spread")) + var_glojure_DOT_core_spread := lang.InternVarName(sym_glojure_DOT_core, sym_spread) // var glojure.core/str - glojure_DOT_core_str := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("str")) + var_glojure_DOT_core_str := lang.InternVarName(sym_glojure_DOT_core, sym_str) // var glojure.core/stream-reduce! - glojure_DOT_core_stream_reduce_BANG_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("stream-reduce!")) + var_glojure_DOT_core_stream_DASH_reduce_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_stream_DASH_reduce_BANG_) // var glojure.core/stream-transduce! - glojure_DOT_core_stream_transduce_BANG_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("stream-transduce!")) + var_glojure_DOT_core_stream_DASH_transduce_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_stream_DASH_transduce_BANG_) // var glojure.core/string? - glojure_DOT_core_string_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("string?")) + var_glojure_DOT_core_string_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_string_QMARK_) // var glojure.core/strip-ns - glojure_DOT_core_strip_ns := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("strip-ns")) + var_glojure_DOT_core_strip_DASH_ns := lang.InternVarName(sym_glojure_DOT_core, sym_strip_DASH_ns) // var glojure.core/struct - glojure_DOT_core_struct := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("struct")) + var_glojure_DOT_core_struct := lang.InternVarName(sym_glojure_DOT_core, sym_struct) // var glojure.core/subs - glojure_DOT_core_subs := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("subs")) + var_glojure_DOT_core_subs := lang.InternVarName(sym_glojure_DOT_core, sym_subs) // var glojure.core/subvec - glojure_DOT_core_subvec := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("subvec")) + var_glojure_DOT_core_subvec := lang.InternVarName(sym_glojure_DOT_core, sym_subvec) // var glojure.core/supers - glojure_DOT_core_supers := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("supers")) + var_glojure_DOT_core_supers := lang.InternVarName(sym_glojure_DOT_core, sym_supers) // var glojure.core/swap! - glojure_DOT_core_swap_BANG_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("swap!")) + var_glojure_DOT_core_swap_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_swap_BANG_) // var glojure.core/symbol - glojure_DOT_core_symbol := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("symbol")) + var_glojure_DOT_core_symbol := lang.InternVarName(sym_glojure_DOT_core, sym_symbol) // var glojure.core/symbol? - glojure_DOT_core_symbol_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("symbol?")) + var_glojure_DOT_core_symbol_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_symbol_QMARK_) // var glojure.core/system-newline - glojure_DOT_core_system_newline := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("system-newline")) + var_glojure_DOT_core_system_DASH_newline := lang.InternVarName(sym_glojure_DOT_core, sym_system_DASH_newline) // var glojure.core/take - glojure_DOT_core_take := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("take")) + var_glojure_DOT_core_take := lang.InternVarName(sym_glojure_DOT_core, sym_take) // var glojure.core/take-nth - glojure_DOT_core_take_nth := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("take-nth")) + var_glojure_DOT_core_take_DASH_nth := lang.InternVarName(sym_glojure_DOT_core, sym_take_DASH_nth) // var glojure.core/take-while - glojure_DOT_core_take_while := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("take-while")) + var_glojure_DOT_core_take_DASH_while := lang.InternVarName(sym_glojure_DOT_core, sym_take_DASH_while) // var glojure.core/tapset - glojure_DOT_core_tapset := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("tapset")) + var_glojure_DOT_core_tapset := lang.InternVarName(sym_glojure_DOT_core, sym_tapset) // var glojure.core/the-ns - glojure_DOT_core_the_ns := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("the-ns")) + var_glojure_DOT_core_the_DASH_ns := lang.InternVarName(sym_glojure_DOT_core, sym_the_DASH_ns) // var glojure.core/throw-if - glojure_DOT_core_throw_if := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("throw-if")) + var_glojure_DOT_core_throw_DASH_if := lang.InternVarName(sym_glojure_DOT_core, sym_throw_DASH_if) // var glojure.core/to-array - glojure_DOT_core_to_array := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("to-array")) + var_glojure_DOT_core_to_DASH_array := lang.InternVarName(sym_glojure_DOT_core, sym_to_DASH_array) // var glojure.core/trampoline - glojure_DOT_core_trampoline := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("trampoline")) + var_glojure_DOT_core_trampoline := lang.InternVarName(sym_glojure_DOT_core, sym_trampoline) // var glojure.core/transduce - glojure_DOT_core_transduce := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("transduce")) + var_glojure_DOT_core_transduce := lang.InternVarName(sym_glojure_DOT_core, sym_transduce) // var glojure.core/transient - glojure_DOT_core_transient := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("transient")) + var_glojure_DOT_core_transient := lang.InternVarName(sym_glojure_DOT_core, sym_transient) // var glojure.core/tree-seq - glojure_DOT_core_tree_seq := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("tree-seq")) + var_glojure_DOT_core_tree_DASH_seq := lang.InternVarName(sym_glojure_DOT_core, sym_tree_DASH_seq) // var glojure.core/unchecked-inc - glojure_DOT_core_unchecked_inc := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("unchecked-inc")) + var_glojure_DOT_core_unchecked_DASH_inc := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_inc) // var glojure.core/underive - glojure_DOT_core_underive := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("underive")) + var_glojure_DOT_core_underive := lang.InternVarName(sym_glojure_DOT_core, sym_underive) // var glojure.core/unreduced - glojure_DOT_core_unreduced := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("unreduced")) + var_glojure_DOT_core_unreduced := lang.InternVarName(sym_glojure_DOT_core, sym_unreduced) // var glojure.core/update - glojure_DOT_core_update := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("update")) + var_glojure_DOT_core_update := lang.InternVarName(sym_glojure_DOT_core, sym_update) // var glojure.core/val - glojure_DOT_core_val := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("val")) + var_glojure_DOT_core_val := lang.InternVarName(sym_glojure_DOT_core, sym_val) // var glojure.core/vals - glojure_DOT_core_vals := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("vals")) + var_glojure_DOT_core_vals := lang.InternVarName(sym_glojure_DOT_core, sym_vals) // var glojure.core/vary-meta - glojure_DOT_core_vary_meta := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("vary-meta")) + var_glojure_DOT_core_vary_DASH_meta := lang.InternVarName(sym_glojure_DOT_core, sym_vary_DASH_meta) // var glojure.core/vec - glojure_DOT_core_vec := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("vec")) + var_glojure_DOT_core_vec := lang.InternVarName(sym_glojure_DOT_core, sym_vec) // var glojure.core/vector - glojure_DOT_core_vector := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("vector")) + var_glojure_DOT_core_vector := lang.InternVarName(sym_glojure_DOT_core, sym_vector) // var glojure.core/vector? - glojure_DOT_core_vector_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("vector?")) + var_glojure_DOT_core_vector_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_vector_QMARK_) // var glojure.core/volatile! - glojure_DOT_core_volatile_BANG_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("volatile!")) + var_glojure_DOT_core_volatile_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_volatile_BANG_) // var glojure.core/vreset! - glojure_DOT_core_vreset_BANG_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("vreset!")) + var_glojure_DOT_core_vreset_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_vreset_BANG_) // var glojure.core/with-bindings* - glojure_DOT_core_with_bindings_STAR_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("with-bindings*")) + var_glojure_DOT_core_with_DASH_bindings_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_bindings_STAR_) // var glojure.core/with-meta - glojure_DOT_core_with_meta := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("with-meta")) + var_glojure_DOT_core_with_DASH_meta := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_meta) // var glojure.core/zero? - glojure_DOT_core_zero_QMARK_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("zero?")) + var_glojure_DOT_core_zero_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_zero_QMARK_) // var glojure.core/zipmap - glojure_DOT_core_zipmap := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("zipmap")) + var_glojure_DOT_core_zipmap := lang.InternVarName(sym_glojure_DOT_core, sym_zipmap) // var glojure.go.io/copy - glojure_DOT_go_DOT_io_copy := lang.InternVarName(lang.NewSymbol("glojure.go.io"), lang.NewSymbol("copy")) + var_glojure_DOT_go_DOT_io_copy := lang.InternVarName(sym_glojure_DOT_go_DOT_io, sym_copy) // var glojure.go.io/make-input-stream - glojure_DOT_go_DOT_io_make_input_stream := lang.InternVarName(lang.NewSymbol("glojure.go.io"), lang.NewSymbol("make-input-stream")) + var_glojure_DOT_go_DOT_io_make_DASH_input_DASH_stream := lang.InternVarName(sym_glojure_DOT_go_DOT_io, sym_make_DASH_input_DASH_stream) // var glojure.go.io/make-output-stream - glojure_DOT_go_DOT_io_make_output_stream := lang.InternVarName(lang.NewSymbol("glojure.go.io"), lang.NewSymbol("make-output-stream")) + var_glojure_DOT_go_DOT_io_make_DASH_output_DASH_stream := lang.InternVarName(sym_glojure_DOT_go_DOT_io, sym_make_DASH_output_DASH_stream) // var glojure.go.io/make-writer - glojure_DOT_go_DOT_io_make_writer := lang.InternVarName(lang.NewSymbol("glojure.go.io"), lang.NewSymbol("make-writer")) + var_glojure_DOT_go_DOT_io_make_DASH_writer := lang.InternVarName(sym_glojure_DOT_go_DOT_io, sym_make_DASH_writer) // var glojure.go.io/reader - glojure_DOT_go_DOT_io_reader := lang.InternVarName(lang.NewSymbol("glojure.go.io"), lang.NewSymbol("reader")) + var_glojure_DOT_go_DOT_io_reader := lang.InternVarName(sym_glojure_DOT_go_DOT_io, sym_reader) // //////////////////////////////////////////////////////////////////////////////// Closed-over values var closed0 any { - closed0 = lang.NewSymbol("unchecked_multiply") + closed0 = sym_unchecked_multiply } var closed1 any { - closed1 = lang.NewSymbol("multiply") + closed1 = sym_multiply } var closed10 any { @@ -819,7 +2184,8 @@ func LoadNS() { tmp5 := lang.Apply(tmp4, []any{v2, v3}) return tmp5 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) closed10 = tmp0 @@ -834,7 +2200,7 @@ func LoadNS() { _ = v1 v2 := args[1] _ = v2 - tmp3 := checkDerefVar(glojure_DOT_core_DOT_protocols_seq_reduce) + tmp3 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_seq_DASH_reduce) tmp4 := lang.Apply(tmp3, []any{v1, v2}) return tmp4 case 3: @@ -844,11 +2210,12 @@ func LoadNS() { _ = v2 v3 := args[2] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_DOT_protocols_seq_reduce) + tmp4 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_seq_DASH_reduce) tmp5 := lang.Apply(tmp4, []any{v1, v2, v3}) return tmp5 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) closed11 = tmp0 @@ -863,7 +2230,7 @@ func LoadNS() { _ = v1 v2 := args[1] _ = v2 - tmp3 := checkDerefVar(glojure_DOT_core_DOT_protocols_seq_reduce) + tmp3 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_seq_DASH_reduce) tmp4 := lang.Apply(tmp3, []any{v1, v2}) return tmp4 case 3: @@ -873,11 +2240,12 @@ func LoadNS() { _ = v2 v3 := args[2] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_DOT_protocols_seq_reduce) + tmp4 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_seq_DASH_reduce) tmp5 := lang.Apply(tmp4, []any{v1, v2, v3}) return tmp5 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) closed12 = tmp0 @@ -886,9 +2254,7 @@ func LoadNS() { { var tmp0 lang.FnFunc tmp0 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v1 := args[0] _ = v1 v2 := args[1] @@ -903,9 +2269,7 @@ func LoadNS() { { var tmp0 lang.FnFunc tmp0 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v1 := args[0] _ = v1 v2 := args[1] @@ -916,7 +2280,7 @@ func LoadNS() { var tmp4 any { // let // let binding "temp__0__auto__" - tmp5 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) tmp6 := lang.Apply(tmp5, []any{v1}) var v7 any = tmp6 _ = v7 @@ -928,13 +2292,13 @@ func LoadNS() { var v10 any = v7 _ = v10 var tmp11 any - tmp12 := checkDerefVar(glojure_DOT_core_chunked_seq_QMARK_) + tmp12 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) tmp13 := lang.Apply(tmp12, []any{v10}) if lang.IsTruthy(tmp13) { var tmp14 any { // let // let binding "ret" - tmp15 := checkDerefVar(glojure_DOT_core_chunk_first) + tmp15 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) tmp16 := lang.Apply(tmp15, []any{v10}) tmp17, _ := lang.FieldOrMethod(tmp16, "ReduceInit") if reflect.TypeOf(tmp17).Kind() != reflect.Func { @@ -944,14 +2308,14 @@ func LoadNS() { var v19 any = tmp18 _ = v19 var tmp20 any - tmp21 := checkDerefVar(glojure_DOT_core_reduced_QMARK_) + tmp21 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) tmp22 := lang.Apply(tmp21, []any{v19}) if lang.IsTruthy(tmp22) { - tmp23 := checkDerefVar(glojure_DOT_core_deref) + tmp23 := checkDerefVar(var_glojure_DOT_core_deref) tmp24 := lang.Apply(tmp23, []any{v19}) tmp20 = tmp24 } else { - tmp26 := checkDerefVar(glojure_DOT_core_chunk_next) + tmp26 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_next) tmp27 := lang.Apply(tmp26, []any{v10}) var tmp25 any = tmp27 var tmp28 any = v2 @@ -965,7 +2329,7 @@ func LoadNS() { } // end let tmp11 = tmp14 } else { - tmp15 := checkDerefVar(glojure_DOT_core_DOT_protocols_interface_or_naive_reduce) + tmp15 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_interface_DASH_or_DASH_naive_DASH_reduce) tmp16 := lang.Apply(tmp15, []any{v10, v2, v3}) tmp11 = tmp16 } @@ -985,9 +2349,7 @@ func LoadNS() { { var tmp0 lang.FnFunc tmp0 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v1 := args[0] _ = v1 v2 := args[1] @@ -997,7 +2359,7 @@ func LoadNS() { var tmp4 any { // let // let binding "cls" - tmp5 := checkDerefVar(glojure_DOT_core_class) + tmp5 := checkDerefVar(var_glojure_DOT_core_class) tmp6 := lang.Apply(tmp5, []any{v1}) var v7 any = tmp6 _ = v7 @@ -1014,7 +2376,7 @@ func LoadNS() { var tmp11 any { // let // let binding "temp__0__auto__" - tmp12 := checkDerefVar(glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := lang.Apply(tmp12, []any{v8}) var v14 any = tmp13 _ = v14 @@ -1026,29 +2388,29 @@ func LoadNS() { var v17 any = v14 _ = v17 var tmp18 any - tmp19 := checkDerefVar(glojure_DOT_core_identical_QMARK_) - tmp20 := checkDerefVar(glojure_DOT_core_class) + tmp19 := checkDerefVar(var_glojure_DOT_core_identical_QMARK_) + tmp20 := checkDerefVar(var_glojure_DOT_core_class) tmp21 := lang.Apply(tmp20, []any{v17}) tmp22 := lang.Apply(tmp19, []any{tmp21, v7}) if lang.IsTruthy(tmp22) { var tmp23 any { // let // let binding "ret" - tmp24 := checkDerefVar(glojure_DOT_core_first) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) tmp25 := lang.Apply(tmp24, []any{v17}) tmp26 := lang.Apply(v9, []any{v10, tmp25}) var v27 any = tmp26 _ = v27 var tmp28 any - tmp29 := checkDerefVar(glojure_DOT_core_reduced_QMARK_) + tmp29 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) tmp30 := lang.Apply(tmp29, []any{v27}) if lang.IsTruthy(tmp30) { - tmp31 := checkDerefVar(glojure_DOT_core_deref) + tmp31 := checkDerefVar(var_glojure_DOT_core_deref) tmp32 := lang.Apply(tmp31, []any{v27}) tmp28 = tmp32 } else { var tmp33 any = v7 - tmp35 := checkDerefVar(glojure_DOT_core_next) + tmp35 := checkDerefVar(var_glojure_DOT_core_next) tmp36 := lang.Apply(tmp35, []any{v17}) var tmp34 any = tmp36 var tmp37 any = v9 @@ -1063,7 +2425,7 @@ func LoadNS() { } // end let tmp18 = tmp23 } else { - tmp24 := checkDerefVar(glojure_DOT_core_DOT_protocols_interface_or_naive_reduce) + tmp24 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_interface_DASH_or_DASH_naive_DASH_reduce) tmp25 := lang.Apply(tmp24, []any{v17, v9, v10}) tmp18 = tmp25 } @@ -1087,9 +2449,7 @@ func LoadNS() { { var tmp0 lang.FnFunc tmp0 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v1 := args[0] _ = v1 return nil @@ -1100,106 +2460,94 @@ func LoadNS() { { var tmp0 lang.FnFunc tmp0 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v1 := args[0] _ = v1 v2 := args[1] _ = v2 return v1 }) - tmp0 = tmp0.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/go/io.glj", lang.NewKeyword("line"), int(188), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(188), lang.NewKeyword("end-column"), int(32))).(lang.FnFunc) + tmp0 = tmp0.WithMeta(lang.NewMap(kw_file, "glojure/go/io.glj", kw_line, int(188), kw_column, int(18), kw_end_DASH_line, int(188), kw_end_DASH_column, int(32))).(lang.FnFunc) closed17 = tmp0 } var closed18 any { var tmp0 lang.FnFunc tmp0 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v1 := args[0] _ = v1 v2 := args[1] _ = v2 - tmp3 := checkDerefVar(glojure_DOT_go_DOT_io_make_input_stream) + tmp3 := checkDerefVar(var_glojure_DOT_go_DOT_io_make_DASH_input_DASH_stream) tmp4 := lang.Apply(tmp3, []any{v1, v2}) return tmp4 }) - tmp0 = tmp0.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/go/io.glj", lang.NewKeyword("line"), int(167), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(167), lang.NewKeyword("end-column"), int(56))).(lang.FnFunc) + tmp0 = tmp0.WithMeta(lang.NewMap(kw_file, "glojure/go/io.glj", kw_line, int(167), kw_column, int(17), kw_end_DASH_line, int(167), kw_end_DASH_column, int(56))).(lang.FnFunc) closed18 = tmp0 } var closed19 any { var tmp0 lang.FnFunc tmp0 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v1 := args[0] _ = v1 v2 := args[1] _ = v2 - tmp3 := checkDerefVar(glojure_DOT_go_DOT_io_make_writer) - tmp4 := checkDerefVar(glojure_DOT_go_DOT_io_make_output_stream) + tmp3 := checkDerefVar(var_glojure_DOT_go_DOT_io_make_DASH_writer) + tmp4 := checkDerefVar(var_glojure_DOT_go_DOT_io_make_DASH_output_DASH_stream) tmp5 := lang.Apply(tmp4, []any{v1, v2}) tmp6 := lang.Apply(tmp3, []any{tmp5, v2}) return tmp6 }) - tmp0 = tmp0.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/go/io.glj", lang.NewKeyword("line"), int(168), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(168), lang.NewKeyword("end-column"), int(76))).(lang.FnFunc) + tmp0 = tmp0.WithMeta(lang.NewMap(kw_file, "glojure/go/io.glj", kw_line, int(168), kw_column, int(17), kw_end_DASH_line, int(168), kw_end_DASH_column, int(76))).(lang.FnFunc) closed19 = tmp0 } var closed2 any { - closed2 = lang.NewSymbol("multiplyP") + closed2 = sym_multiplyP } var closed20 any { var tmp0 lang.FnFunc tmp0 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v1 := args[0] _ = v1 v2 := args[1] _ = v2 return v1 }) - tmp0 = tmp0.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/go/io.glj", lang.NewKeyword("line"), int(187), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(187), lang.NewKeyword("end-column"), int(38))).(lang.FnFunc) + tmp0 = tmp0.WithMeta(lang.NewMap(kw_file, "glojure/go/io.glj", kw_line, int(187), kw_column, int(24), kw_end_DASH_line, int(187), kw_end_DASH_column, int(38))).(lang.FnFunc) closed20 = tmp0 } var closed21 any { var tmp0 lang.FnFunc tmp0 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v1 := args[0] _ = v1 v2 := args[1] _ = v2 return v1 }) - tmp0 = tmp0.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/go/io.glj", lang.NewKeyword("line"), int(226), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(226), lang.NewKeyword("end-column"), int(48))).(lang.FnFunc) + tmp0 = tmp0.WithMeta(lang.NewMap(kw_file, "glojure/go/io.glj", kw_line, int(226), kw_column, int(24), kw_end_DASH_line, int(226), kw_end_DASH_column, int(48))).(lang.FnFunc) closed21 = tmp0 } var closed22 any { var tmp0 lang.FnFunc tmp0 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v1 := args[0] _ = v1 v2 := args[1] _ = v2 - tmp3 := checkDerefVar(glojure_DOT_go_DOT_io_make_input_stream) + tmp3 := checkDerefVar(var_glojure_DOT_go_DOT_io_make_DASH_input_DASH_stream) var tmp4 any - tmp5 := checkDerefVar(glojure_DOT_core__EQ_) + tmp5 := checkDerefVar(var_glojure_DOT_core__EQ_) tmp6, ok := lang.FieldOrMethod(v1, "scheme") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v1, "scheme"))) @@ -1238,15 +2586,15 @@ func LoadNS() { _ = v15 // let binding "vec__295" var tmp16 any - tmp17 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp17 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) tmp18 := lang.Apply(tmp17, []any{v15}) if lang.IsTruthy(tmp18) { - tmp19 := checkDerefVar(glojure_DOT_core_pop) + tmp19 := checkDerefVar(var_glojure_DOT_core_pop) tmp20 := lang.Apply(tmp19, []any{v15}) - tmp21 := checkDerefVar(glojure_DOT_core_last) + tmp21 := checkDerefVar(var_glojure_DOT_core_last) tmp22 := lang.Apply(tmp21, []any{v15}) tmp23 := lang.NewVector(tmp20, tmp22) - tmp24 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(358), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(358), lang.NewKeyword("end-column"), int(14)) + tmp24 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(358), kw_column, int(10), kw_end_DASH_line, int(358), kw_end_DASH_column, int(14)) tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) if err != nil { panic(err) @@ -1254,7 +2602,7 @@ func LoadNS() { tmp16 = tmp25 } else { tmp26 := lang.NewVector(nil, v15) - tmp27 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(358), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(358), lang.NewKeyword("end-column"), int(14)) + tmp27 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(358), kw_column, int(10), kw_end_DASH_line, int(358), kw_end_DASH_column, int(14)) tmp28, err := lang.WithMeta(tmp26, tmp27.(lang.IPersistentMap)) if err != nil { panic(err) @@ -1264,22 +2612,22 @@ func LoadNS() { var v29 any = tmp16 _ = v29 // let binding "vec__298" - tmp30 := checkDerefVar(glojure_DOT_core_nth) + tmp30 := checkDerefVar(var_glojure_DOT_core_nth) tmp31 := lang.Apply(tmp30, []any{v29, int64(0), nil}) var v32 any = tmp31 _ = v32 // let binding "seq__299" - tmp33 := checkDerefVar(glojure_DOT_core_seq) + tmp33 := checkDerefVar(var_glojure_DOT_core_seq) tmp34 := lang.Apply(tmp33, []any{v32}) var v35 any = tmp34 _ = v35 // let binding "first__300" - tmp36 := checkDerefVar(glojure_DOT_core_first) + tmp36 := checkDerefVar(var_glojure_DOT_core_first) tmp37 := lang.Apply(tmp36, []any{v35}) var v38 any = tmp37 _ = v38 // let binding "seq__299" - tmp39 := checkDerefVar(glojure_DOT_core_next) + tmp39 := checkDerefVar(var_glojure_DOT_core_next) tmp40 := lang.Apply(tmp39, []any{v35}) var v41 any = tmp40 _ = v41 @@ -1293,13 +2641,13 @@ func LoadNS() { var v44 any = v32 _ = v44 // let binding "err__3__auto__" - tmp45 := checkDerefVar(glojure_DOT_core_nth) + tmp45 := checkDerefVar(var_glojure_DOT_core_nth) tmp46 := lang.Apply(tmp45, []any{v29, int64(1), nil}) var v47 any = tmp46 _ = v47 // let binding "res__0__auto__" var tmp48 any - tmp49 := checkDerefVar(glojure_DOT_core_not_empty) + tmp49 := checkDerefVar(var_glojure_DOT_core_not_DASH_empty) tmp50 := lang.Apply(tmp49, []any{v43}) if lang.IsTruthy(tmp50) { tmp48 = v44 @@ -1331,15 +2679,15 @@ func LoadNS() { _ = v16 // let binding "vec__301" var tmp17 any - tmp18 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp18 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) tmp19 := lang.Apply(tmp18, []any{v16}) if lang.IsTruthy(tmp19) { - tmp20 := checkDerefVar(glojure_DOT_core_pop) + tmp20 := checkDerefVar(var_glojure_DOT_core_pop) tmp21 := lang.Apply(tmp20, []any{v16}) - tmp22 := checkDerefVar(glojure_DOT_core_last) + tmp22 := checkDerefVar(var_glojure_DOT_core_last) tmp23 := lang.Apply(tmp22, []any{v16}) tmp24 := lang.NewVector(tmp21, tmp23) - tmp25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(358), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(358), lang.NewKeyword("end-column"), int(14)) + tmp25 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(358), kw_column, int(10), kw_end_DASH_line, int(358), kw_end_DASH_column, int(14)) tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) if err != nil { panic(err) @@ -1347,7 +2695,7 @@ func LoadNS() { tmp17 = tmp26 } else { tmp27 := lang.NewVector(nil, v16) - tmp28 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(358), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(358), lang.NewKeyword("end-column"), int(14)) + tmp28 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(358), kw_column, int(10), kw_end_DASH_line, int(358), kw_end_DASH_column, int(14)) tmp29, err := lang.WithMeta(tmp27, tmp28.(lang.IPersistentMap)) if err != nil { panic(err) @@ -1357,22 +2705,22 @@ func LoadNS() { var v30 any = tmp17 _ = v30 // let binding "vec__304" - tmp31 := checkDerefVar(glojure_DOT_core_nth) + tmp31 := checkDerefVar(var_glojure_DOT_core_nth) tmp32 := lang.Apply(tmp31, []any{v30, int64(0), nil}) var v33 any = tmp32 _ = v33 // let binding "seq__305" - tmp34 := checkDerefVar(glojure_DOT_core_seq) + tmp34 := checkDerefVar(var_glojure_DOT_core_seq) tmp35 := lang.Apply(tmp34, []any{v33}) var v36 any = tmp35 _ = v36 // let binding "first__306" - tmp37 := checkDerefVar(glojure_DOT_core_first) + tmp37 := checkDerefVar(var_glojure_DOT_core_first) tmp38 := lang.Apply(tmp37, []any{v36}) var v39 any = tmp38 _ = v39 // let binding "seq__305" - tmp40 := checkDerefVar(glojure_DOT_core_next) + tmp40 := checkDerefVar(var_glojure_DOT_core_next) tmp41 := lang.Apply(tmp40, []any{v36}) var v42 any = tmp41 _ = v42 @@ -1386,13 +2734,13 @@ func LoadNS() { var v45 any = v33 _ = v45 // let binding "err__3__auto__" - tmp46 := checkDerefVar(glojure_DOT_core_nth) + tmp46 := checkDerefVar(var_glojure_DOT_core_nth) tmp47 := lang.Apply(tmp46, []any{v30, int64(1), nil}) var v48 any = tmp47 _ = v48 // let binding "res__0__auto__" var tmp49 any - tmp50 := checkDerefVar(glojure_DOT_core_not_empty) + tmp50 := checkDerefVar(var_glojure_DOT_core_not_DASH_empty) tmp51 := lang.Apply(tmp50, []any{v44}) if lang.IsTruthy(tmp51) { tmp49 = v45 @@ -1440,7 +2788,7 @@ func LoadNS() { var v20 any = tmp19 _ = v20 var tmp21 any - tmp22 := checkDerefVar(glojure_DOT_core_not_EQ_) + tmp22 := checkDerefVar(var_glojure_DOT_core_not_EQ_) tmp23 := lang.Apply(tmp22, []any{int64(200), v17}) if lang.IsTruthy(tmp23) { tmp24, ok := lang.FieldOrMethod(v20, "Close") @@ -1467,16 +2815,14 @@ func LoadNS() { tmp11 := lang.Apply(tmp3, []any{tmp4, v2}) return tmp11 }) - tmp0 = tmp0.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/go/io.glj", lang.NewKeyword("line"), int(232), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(244), lang.NewKeyword("end-column"), int(32))).(lang.FnFunc) + tmp0 = tmp0.WithMeta(lang.NewMap(kw_file, "glojure/go/io.glj", kw_line, int(232), kw_column, int(24), kw_end_DASH_line, int(244), kw_end_DASH_column, int(32))).(lang.FnFunc) closed22 = tmp0 } var closed23 any { var tmp0 lang.FnFunc tmp0 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v1 := args[0] _ = v1 v2 := args[1] @@ -1488,18 +2834,18 @@ func LoadNS() { var v5 any = tmp4 _ = v5 // let binding "url" - tmp6 := checkDerefVar(glojure_DOT_core_nth) + tmp6 := checkDerefVar(var_glojure_DOT_core_nth) tmp7 := lang.Apply(tmp6, []any{v5, int64(0), nil}) var v8 any = tmp7 _ = v8 // let binding "err" - tmp9 := checkDerefVar(glojure_DOT_core_nth) + tmp9 := checkDerefVar(var_glojure_DOT_core_nth) tmp10 := lang.Apply(tmp9, []any{v5, int64(1), nil}) var v11 any = tmp10 _ = v11 var tmp12 any if lang.IsTruthy(v11) { - tmp13 := checkDerefVar(glojure_DOT_go_DOT_io_make_input_stream) + tmp13 := checkDerefVar(var_glojure_DOT_go_DOT_io_make_DASH_input_DASH_stream) var tmp14 any { // let // let binding "res__0__auto__" @@ -1508,15 +2854,15 @@ func LoadNS() { _ = v16 // let binding "vec__310" var tmp17 any - tmp18 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp18 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) tmp19 := lang.Apply(tmp18, []any{v16}) if lang.IsTruthy(tmp19) { - tmp20 := checkDerefVar(glojure_DOT_core_pop) + tmp20 := checkDerefVar(var_glojure_DOT_core_pop) tmp21 := lang.Apply(tmp20, []any{v16}) - tmp22 := checkDerefVar(glojure_DOT_core_last) + tmp22 := checkDerefVar(var_glojure_DOT_core_last) tmp23 := lang.Apply(tmp22, []any{v16}) tmp24 := lang.NewVector(tmp21, tmp23) - tmp25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(358), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(358), lang.NewKeyword("end-column"), int(14)) + tmp25 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(358), kw_column, int(10), kw_end_DASH_line, int(358), kw_end_DASH_column, int(14)) tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) if err != nil { panic(err) @@ -1524,7 +2870,7 @@ func LoadNS() { tmp17 = tmp26 } else { tmp27 := lang.NewVector(nil, v16) - tmp28 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(358), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(358), lang.NewKeyword("end-column"), int(14)) + tmp28 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(358), kw_column, int(10), kw_end_DASH_line, int(358), kw_end_DASH_column, int(14)) tmp29, err := lang.WithMeta(tmp27, tmp28.(lang.IPersistentMap)) if err != nil { panic(err) @@ -1534,22 +2880,22 @@ func LoadNS() { var v30 any = tmp17 _ = v30 // let binding "vec__313" - tmp31 := checkDerefVar(glojure_DOT_core_nth) + tmp31 := checkDerefVar(var_glojure_DOT_core_nth) tmp32 := lang.Apply(tmp31, []any{v30, int64(0), nil}) var v33 any = tmp32 _ = v33 // let binding "seq__314" - tmp34 := checkDerefVar(glojure_DOT_core_seq) + tmp34 := checkDerefVar(var_glojure_DOT_core_seq) tmp35 := lang.Apply(tmp34, []any{v33}) var v36 any = tmp35 _ = v36 // let binding "first__315" - tmp37 := checkDerefVar(glojure_DOT_core_first) + tmp37 := checkDerefVar(var_glojure_DOT_core_first) tmp38 := lang.Apply(tmp37, []any{v36}) var v39 any = tmp38 _ = v39 // let binding "seq__314" - tmp40 := checkDerefVar(glojure_DOT_core_next) + tmp40 := checkDerefVar(var_glojure_DOT_core_next) tmp41 := lang.Apply(tmp40, []any{v36}) var v42 any = tmp41 _ = v42 @@ -1563,13 +2909,13 @@ func LoadNS() { var v45 any = v33 _ = v45 // let binding "err__3__auto__" - tmp46 := checkDerefVar(glojure_DOT_core_nth) + tmp46 := checkDerefVar(var_glojure_DOT_core_nth) tmp47 := lang.Apply(tmp46, []any{v30, int64(1), nil}) var v48 any = tmp47 _ = v48 // let binding "res__0__auto__" var tmp49 any - tmp50 := checkDerefVar(glojure_DOT_core_not_empty) + tmp50 := checkDerefVar(var_glojure_DOT_core_not_DASH_empty) tmp51 := lang.Apply(tmp50, []any{v44}) if lang.IsTruthy(tmp51) { tmp49 = v45 @@ -1589,7 +2935,7 @@ func LoadNS() { tmp15 := lang.Apply(tmp13, []any{tmp14, v2}) tmp12 = tmp15 } else { - tmp16 := checkDerefVar(glojure_DOT_go_DOT_io_make_input_stream) + tmp16 := checkDerefVar(var_glojure_DOT_go_DOT_io_make_DASH_input_DASH_stream) tmp17 := lang.Apply(tmp16, []any{v8, v2}) tmp12 = tmp17 } @@ -1597,59 +2943,53 @@ func LoadNS() { } // end let return tmp3 }) - tmp0 = tmp0.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/go/io.glj", lang.NewKeyword("line"), int(259), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(263), lang.NewKeyword("end-column"), int(60))).(lang.FnFunc) + tmp0 = tmp0.WithMeta(lang.NewMap(kw_file, "glojure/go/io.glj", kw_line, int(259), kw_column, int(24), kw_end_DASH_line, int(263), kw_end_DASH_column, int(60))).(lang.FnFunc) closed23 = tmp0 } var closed24 any { var tmp0 lang.FnFunc tmp0 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v1 := args[0] _ = v1 v2 := args[1] _ = v2 - tmp3 := checkDerefVar(glojure_DOT_core_str) - tmp4 := checkDerefVar(glojure_DOT_core_pr_str) + tmp3 := checkDerefVar(var_glojure_DOT_core_str) + tmp4 := checkDerefVar(var_glojure_DOT_core_pr_DASH_str) tmp5 := lang.Apply(tmp4, []any{v1}) tmp6 := lang.Apply(tmp3, []any{"Cannot open <", tmp5, "> as an OutputStream."}) tmp7 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp6}) panic(tmp7) }) - tmp0 = tmp0.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/go/io.glj", lang.NewKeyword("line"), int(172), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(174), lang.NewKeyword("end-column"), int(92))).(lang.FnFunc) + tmp0 = tmp0.WithMeta(lang.NewMap(kw_file, "glojure/go/io.glj", kw_line, int(172), kw_column, int(24), kw_end_DASH_line, int(174), kw_end_DASH_column, int(92))).(lang.FnFunc) closed24 = tmp0 } var closed25 any { var tmp0 lang.FnFunc tmp0 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v1 := args[0] _ = v1 v2 := args[1] _ = v2 return v1 }) - tmp0 = tmp0.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/go/io.glj", lang.NewKeyword("line"), int(227), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(227), lang.NewKeyword("end-column"), int(49))).(lang.FnFunc) + tmp0 = tmp0.WithMeta(lang.NewMap(kw_file, "glojure/go/io.glj", kw_line, int(227), kw_column, int(25), kw_end_DASH_line, int(227), kw_end_DASH_column, int(49))).(lang.FnFunc) closed25 = tmp0 } var closed26 any { var tmp0 lang.FnFunc tmp0 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v1 := args[0] _ = v1 v2 := args[1] _ = v2 var tmp3 any - tmp4 := checkDerefVar(glojure_DOT_core__EQ_) + tmp4 := checkDerefVar(var_glojure_DOT_core__EQ_) tmp5, ok := lang.FieldOrMethod(v1, "scheme") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v1, "scheme"))) @@ -1663,28 +3003,26 @@ func LoadNS() { } tmp7 := lang.Apply(tmp4, []any{"file", tmp6}) if lang.IsTruthy(tmp7) { - tmp8 := checkDerefVar(glojure_DOT_go_DOT_io_make_output_stream) + tmp8 := checkDerefVar(var_glojure_DOT_go_DOT_io_make_DASH_output_DASH_stream) tmp9 := lang.Apply(nil, []any{v1}) tmp10 := lang.Apply(tmp8, []any{tmp9, v2}) tmp3 = tmp10 } else { - tmp11 := checkDerefVar(glojure_DOT_core_str) + tmp11 := checkDerefVar(var_glojure_DOT_core_str) tmp12 := lang.Apply(tmp11, []any{"Can not write to non-file URL <", v1, ">"}) tmp13 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp12}) panic(tmp13) } return tmp3 }) - tmp0 = tmp0.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/go/io.glj", lang.NewKeyword("line"), int(245), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(248), lang.NewKeyword("end-column"), int(149))).(lang.FnFunc) + tmp0 = tmp0.WithMeta(lang.NewMap(kw_file, "glojure/go/io.glj", kw_line, int(245), kw_column, int(25), kw_end_DASH_line, int(248), kw_end_DASH_column, int(149))).(lang.FnFunc) closed26 = tmp0 } var closed27 any { var tmp0 lang.FnFunc tmp0 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v1 := args[0] _ = v1 v2 := args[1] @@ -1696,7 +3034,7 @@ func LoadNS() { if lang.CatchMatches(r, lang.Builtins["any"]) { v4 := r _ = v4 - tmp5 := checkDerefVar(glojure_DOT_go_DOT_io_make_output_stream) + tmp5 := checkDerefVar(var_glojure_DOT_go_DOT_io_make_DASH_output_DASH_stream) var tmp6 any { // let // let binding "res__0__auto__" @@ -1706,15 +3044,15 @@ func LoadNS() { _ = v9 // let binding "vec__322" var tmp10 any - tmp11 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp11 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) tmp12 := lang.Apply(tmp11, []any{v9}) if lang.IsTruthy(tmp12) { - tmp13 := checkDerefVar(glojure_DOT_core_pop) + tmp13 := checkDerefVar(var_glojure_DOT_core_pop) tmp14 := lang.Apply(tmp13, []any{v9}) - tmp15 := checkDerefVar(glojure_DOT_core_last) + tmp15 := checkDerefVar(var_glojure_DOT_core_last) tmp16 := lang.Apply(tmp15, []any{v9}) tmp17 := lang.NewVector(tmp14, tmp16) - tmp18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(358), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(358), lang.NewKeyword("end-column"), int(14)) + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(358), kw_column, int(10), kw_end_DASH_line, int(358), kw_end_DASH_column, int(14)) tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) if err != nil { panic(err) @@ -1722,7 +3060,7 @@ func LoadNS() { tmp10 = tmp19 } else { tmp20 := lang.NewVector(nil, v9) - tmp21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(358), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(358), lang.NewKeyword("end-column"), int(14)) + tmp21 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(358), kw_column, int(10), kw_end_DASH_line, int(358), kw_end_DASH_column, int(14)) tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) if err != nil { panic(err) @@ -1732,22 +3070,22 @@ func LoadNS() { var v23 any = tmp10 _ = v23 // let binding "vec__325" - tmp24 := checkDerefVar(glojure_DOT_core_nth) + tmp24 := checkDerefVar(var_glojure_DOT_core_nth) tmp25 := lang.Apply(tmp24, []any{v23, int64(0), nil}) var v26 any = tmp25 _ = v26 // let binding "seq__326" - tmp27 := checkDerefVar(glojure_DOT_core_seq) + tmp27 := checkDerefVar(var_glojure_DOT_core_seq) tmp28 := lang.Apply(tmp27, []any{v26}) var v29 any = tmp28 _ = v29 // let binding "first__327" - tmp30 := checkDerefVar(glojure_DOT_core_first) + tmp30 := checkDerefVar(var_glojure_DOT_core_first) tmp31 := lang.Apply(tmp30, []any{v29}) var v32 any = tmp31 _ = v32 // let binding "seq__326" - tmp33 := checkDerefVar(glojure_DOT_core_next) + tmp33 := checkDerefVar(var_glojure_DOT_core_next) tmp34 := lang.Apply(tmp33, []any{v29}) var v35 any = tmp34 _ = v35 @@ -1761,13 +3099,13 @@ func LoadNS() { var v38 any = v26 _ = v38 // let binding "err__3__auto__" - tmp39 := checkDerefVar(glojure_DOT_core_nth) + tmp39 := checkDerefVar(var_glojure_DOT_core_nth) tmp40 := lang.Apply(tmp39, []any{v23, int64(1), nil}) var v41 any = tmp40 _ = v41 // let binding "res__0__auto__" var tmp42 any - tmp43 := checkDerefVar(glojure_DOT_core_not_empty) + tmp43 := checkDerefVar(var_glojure_DOT_core_not_DASH_empty) tmp44 := lang.Apply(tmp43, []any{v37}) if lang.IsTruthy(tmp44) { tmp42 = v38 @@ -1791,7 +3129,7 @@ func LoadNS() { } } }() - tmp4 := checkDerefVar(glojure_DOT_go_DOT_io_make_output_stream) + tmp4 := checkDerefVar(var_glojure_DOT_go_DOT_io_make_DASH_output_DASH_stream) var tmp5 any { // let // let binding "res__0__auto__" @@ -1801,15 +3139,15 @@ func LoadNS() { _ = v8 // let binding "vec__316" var tmp9 any - tmp10 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp10 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) tmp11 := lang.Apply(tmp10, []any{v8}) if lang.IsTruthy(tmp11) { - tmp12 := checkDerefVar(glojure_DOT_core_pop) + tmp12 := checkDerefVar(var_glojure_DOT_core_pop) tmp13 := lang.Apply(tmp12, []any{v8}) - tmp14 := checkDerefVar(glojure_DOT_core_last) + tmp14 := checkDerefVar(var_glojure_DOT_core_last) tmp15 := lang.Apply(tmp14, []any{v8}) tmp16 := lang.NewVector(tmp13, tmp15) - tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(358), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(358), lang.NewKeyword("end-column"), int(14)) + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(358), kw_column, int(10), kw_end_DASH_line, int(358), kw_end_DASH_column, int(14)) tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) if err != nil { panic(err) @@ -1817,7 +3155,7 @@ func LoadNS() { tmp9 = tmp18 } else { tmp19 := lang.NewVector(nil, v8) - tmp20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(358), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(358), lang.NewKeyword("end-column"), int(14)) + tmp20 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(358), kw_column, int(10), kw_end_DASH_line, int(358), kw_end_DASH_column, int(14)) tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) if err != nil { panic(err) @@ -1827,22 +3165,22 @@ func LoadNS() { var v22 any = tmp9 _ = v22 // let binding "vec__319" - tmp23 := checkDerefVar(glojure_DOT_core_nth) + tmp23 := checkDerefVar(var_glojure_DOT_core_nth) tmp24 := lang.Apply(tmp23, []any{v22, int64(0), nil}) var v25 any = tmp24 _ = v25 // let binding "seq__320" - tmp26 := checkDerefVar(glojure_DOT_core_seq) + tmp26 := checkDerefVar(var_glojure_DOT_core_seq) tmp27 := lang.Apply(tmp26, []any{v25}) var v28 any = tmp27 _ = v28 // let binding "first__321" - tmp29 := checkDerefVar(glojure_DOT_core_first) + tmp29 := checkDerefVar(var_glojure_DOT_core_first) tmp30 := lang.Apply(tmp29, []any{v28}) var v31 any = tmp30 _ = v31 // let binding "seq__320" - tmp32 := checkDerefVar(glojure_DOT_core_next) + tmp32 := checkDerefVar(var_glojure_DOT_core_next) tmp33 := lang.Apply(tmp32, []any{v28}) var v34 any = tmp33 _ = v34 @@ -1856,13 +3194,13 @@ func LoadNS() { var v37 any = v25 _ = v37 // let binding "err__3__auto__" - tmp38 := checkDerefVar(glojure_DOT_core_nth) + tmp38 := checkDerefVar(var_glojure_DOT_core_nth) tmp39 := lang.Apply(tmp38, []any{v22, int64(1), nil}) var v40 any = tmp39 _ = v40 // let binding "res__0__auto__" var tmp41 any - tmp42 := checkDerefVar(glojure_DOT_core_not_empty) + tmp42 := checkDerefVar(var_glojure_DOT_core_not_DASH_empty) tmp43 := lang.Apply(tmp42, []any{v36}) if lang.IsTruthy(tmp43) { tmp41 = v37 @@ -1884,48 +3222,46 @@ func LoadNS() { }() return tmp3 }) - tmp0 = tmp0.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/go/io.glj", lang.NewKeyword("line"), int(264), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(268), lang.NewKeyword("end-column"), int(79))).(lang.FnFunc) + tmp0 = tmp0.WithMeta(lang.NewMap(kw_file, "glojure/go/io.glj", kw_line, int(264), kw_column, int(25), kw_end_DASH_line, int(268), kw_end_DASH_column, int(79))).(lang.FnFunc) closed27 = tmp0 } var closed28 any { - closed28 = lang.NewSymbol("divide") + closed28 = sym_divide } var closed29 any { - closed29 = lang.NewSymbol("and") + closed29 = sym_and } var closed3 any { - closed3 = lang.NewSymbol("unchecked_add") + closed3 = sym_unchecked_add } var closed30 any { - closed30 = lang.NewSymbol("andNot") + closed30 = sym_andNot } var closed31 any { - closed31 = lang.NewSymbol("or") + closed31 = sym_or } var closed32 any { - closed32 = lang.NewSymbol("xor") + closed32 = sym_xor } var closed33 any { - closed33 = lang.NewSymbol("max") + closed33 = sym_max } var closed34 any { - closed34 = lang.NewSymbol("min") + closed34 = sym_min } var closed35 any { var tmp0 lang.FnFunc tmp0 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v1 := args[0] _ = v1 var tmp2 any @@ -1937,16 +3273,14 @@ func LoadNS() { return tmp2 }) tmp1 := reflect.TypeOf(false) - tmp0 = tmp0.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp1)).(lang.FnFunc) + tmp0 = tmp0.WithMeta(lang.NewMap(kw_rettag, tmp1)).(lang.FnFunc) closed35 = tmp0 } var closed36 any { var tmp0 lang.FnFunc tmp0 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v1 := args[0] _ = v1 v2 := args[1] @@ -1955,7 +3289,7 @@ func LoadNS() { var tmp3 any { // let // let binding "temp__0__auto__" - tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) tmp5 := lang.Apply(tmp4, []any{v2}) var v6 any = tmp5 _ = v6 @@ -1969,7 +3303,7 @@ func LoadNS() { var tmp10 any { // let // let binding "or__0__auto__" - tmp11 := checkDerefVar(glojure_DOT_core_first) + tmp11 := checkDerefVar(var_glojure_DOT_core_first) tmp12 := lang.Apply(tmp11, []any{v9}) tmp13 := lang.Apply(v1, []any{tmp12}) var v14 any = tmp13 @@ -1979,7 +3313,7 @@ func LoadNS() { tmp15 = v14 } else { var tmp16 any = v1 - tmp18 := checkDerefVar(glojure_DOT_core_next) + tmp18 := checkDerefVar(var_glojure_DOT_core_next) tmp19 := lang.Apply(tmp18, []any{v9}) var tmp17 any = tmp19 v1 = tmp16 @@ -1997,36 +3331,34 @@ func LoadNS() { } // end let return tmp3 }) - tmp0 = tmp0.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp0 = tmp0.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) closed36 = tmp0 } var closed37 any { var tmp0 lang.FnFunc tmp0 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v1 := args[0] _ = v1 v2 := args[1] _ = v2 recur_loop_480: var tmp3 any - tmp4 := checkDerefVar(glojure_DOT_core_nil_QMARK_) - tmp5 := checkDerefVar(glojure_DOT_core_seq) + tmp4 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) tmp6 := lang.Apply(tmp5, []any{v2}) tmp7 := lang.Apply(tmp4, []any{tmp6}) if lang.IsTruthy(tmp7) { tmp3 = true } else { var tmp8 any - tmp9 := checkDerefVar(glojure_DOT_core_first) + tmp9 := checkDerefVar(var_glojure_DOT_core_first) tmp10 := lang.Apply(tmp9, []any{v2}) tmp11 := lang.Apply(v1, []any{tmp10}) if lang.IsTruthy(tmp11) { var tmp12 any = v1 - tmp14 := checkDerefVar(glojure_DOT_core_next) + tmp14 := checkDerefVar(var_glojure_DOT_core_next) tmp15 := lang.Apply(tmp14, []any{v2}) var tmp13 any = tmp15 v1 = tmp12 @@ -2034,7 +3366,7 @@ func LoadNS() { goto recur_loop_480 } else { var tmp16 any - if lang.IsTruthy(lang.NewKeyword("else")) { + if lang.IsTruthy(kw_else) { tmp16 = false } else { } @@ -2045,28 +3377,28 @@ func LoadNS() { return tmp3 }) tmp1 := reflect.TypeOf(false) - tmp0 = tmp0.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp1)).(lang.FnFunc) + tmp0 = tmp0.WithMeta(lang.NewMap(kw_rettag, tmp1)).(lang.FnFunc) closed37 = tmp0 } var closed4 any { - closed4 = lang.NewSymbol("add") + closed4 = sym_add } var closed5 any { - closed5 = lang.NewSymbol("addP") + closed5 = sym_addP } var closed6 any { - closed6 = lang.NewSymbol("unchecked_minus") + closed6 = sym_unchecked_minus } var closed7 any { - closed7 = lang.NewSymbol("minus") + closed7 = sym_minus } var closed8 any { - closed8 = lang.NewSymbol("minusP") + closed8 = sym_minusP } var closed9 any { @@ -2089,7 +3421,8 @@ func LoadNS() { _ = v3 return v3 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) closed9 = tmp0 @@ -2097,7 +3430,7 @@ func LoadNS() { // reference fmt to avoid unused import error _ = fmt.Printf - ns := lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")) + ns := lang.FindOrCreateNamespace(sym_glojure_DOT_core) _ = ns // * { @@ -2111,7 +3444,7 @@ func LoadNS() { { // let // let binding "op" var tmp4 any - tmp5 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp5) { tmp4 = closed0 } else { @@ -2119,18 +3452,18 @@ func LoadNS() { } var v6 any = tmp4 _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_seq) - tmp8 := checkDerefVar(glojure_DOT_core_concat) - tmp9 := checkDerefVar(glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol(".")}) - tmp11 := checkDerefVar(glojure_DOT_core_list) - tmp12 := lang.Apply(tmp11, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp13 := checkDerefVar(glojure_DOT_core_list) - tmp14 := checkDerefVar(glojure_DOT_core_seq) - tmp15 := checkDerefVar(glojure_DOT_core_concat) - tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v6}) - tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) tmp19 := lang.Apply(tmp18, []any{v2}) tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) tmp21 := lang.Apply(tmp14, []any{tmp20}) @@ -2149,7 +3482,7 @@ func LoadNS() { { // let // let binding "op" var tmp5 any - tmp6 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp6) { tmp5 = closed0 } else { @@ -2157,20 +3490,20 @@ func LoadNS() { } var v7 any = tmp5 _ = v7 - tmp8 := checkDerefVar(glojure_DOT_core_seq) - tmp9 := checkDerefVar(glojure_DOT_core_concat) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol(".")}) - tmp12 := checkDerefVar(glojure_DOT_core_list) - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp14 := checkDerefVar(glojure_DOT_core_list) - tmp15 := checkDerefVar(glojure_DOT_core_seq) - tmp16 := checkDerefVar(glojure_DOT_core_concat) - tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) tmp18 := lang.Apply(tmp17, []any{v7}) - tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) tmp20 := lang.Apply(tmp19, []any{v2}) - tmp21 := checkDerefVar(glojure_DOT_core_list) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) tmp22 := lang.Apply(tmp21, []any{v3}) tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) tmp24 := lang.Apply(tmp15, []any{tmp23}) @@ -2181,9 +3514,7 @@ func LoadNS() { } // end let return tmp4 default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -2194,7 +3525,7 @@ func LoadNS() { { // let // let binding "op" var tmp6 any - tmp7 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp7) { tmp6 = closed0 } else { @@ -2202,30 +3533,28 @@ func LoadNS() { } var v8 any = tmp6 _ = v8 - tmp9 := checkDerefVar(glojure_DOT_core_reduce1) + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) var tmp10 lang.FnFunc tmp10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v11 := args[0] _ = v11 v12 := args[1] _ = v12 - tmp13 := checkDerefVar(glojure_DOT_core_seq) - tmp14 := checkDerefVar(glojure_DOT_core_concat) - tmp15 := checkDerefVar(glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) - tmp17 := checkDerefVar(glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp19 := checkDerefVar(glojure_DOT_core_list) - tmp20 := checkDerefVar(glojure_DOT_core_seq) - tmp21 := checkDerefVar(glojure_DOT_core_concat) - tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) tmp23 := lang.Apply(tmp22, []any{v8}) - tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) tmp25 := lang.Apply(tmp24, []any{v11}) - tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) tmp27 := lang.Apply(tmp26, []any{v12}) tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) tmp29 := lang.Apply(tmp20, []any{tmp28}) @@ -2234,25 +3563,25 @@ func LoadNS() { tmp32 := lang.Apply(tmp13, []any{tmp31}) return tmp32 }) - tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp13 := checkDerefVar(glojure_DOT_core_seq) - tmp14 := checkDerefVar(glojure_DOT_core_concat) - tmp15 := checkDerefVar(glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) - tmp17 := checkDerefVar(glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp19 := checkDerefVar(glojure_DOT_core_list) - tmp20 := checkDerefVar(glojure_DOT_core_seq) - tmp21 := checkDerefVar(glojure_DOT_core_concat) - tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) tmp23 := lang.Apply(tmp22, []any{v8}) - tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) tmp25 := lang.Apply(tmp24, []any{v2}) - tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) tmp27 := lang.Apply(tmp26, []any{v3}) tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) tmp29 := lang.Apply(tmp20, []any{tmp28}) @@ -2265,12 +3594,10 @@ func LoadNS() { return tmp5 } }) - tmp1 = tmp1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") @@ -2280,8 +3607,8 @@ func LoadNS() { tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp0 := lang.NewSymbol("*").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the product of nums. (*) returns 1. Does not auto-promote\n longs, will throw on overflow. See also: *'", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), tmp2, lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1001), lang.NewKeyword("end-line"), int(1001))).(*lang.Symbol) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym__STAR_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns the product of nums. (*) returns 1. Does not auto-promote\n longs, will throw on overflow. See also: *'", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(7), kw_line, int(1001), kw_end_DASH_line, int(1001))).(*lang.Symbol) var tmp4 lang.FnFunc tmp4 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -2304,24 +3631,22 @@ func LoadNS() { tmp8 := lang.Apply(tmp7, []any{v5, v6}) return tmp8 default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v5 := args[0] _ = v5 v6 := args[1] _ = v6 var v7 any = lang.NewList(args[2:]...) _ = v7 - tmp8 := checkDerefVar(glojure_DOT_core_reduce1) - tmp9 := checkDerefVar(glojure_DOT_core__STAR_) - tmp10 := checkDerefVar(glojure_DOT_core__STAR_) + tmp8 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp9 := checkDerefVar(var_glojure_DOT_core__STAR_) + tmp10 := checkDerefVar(var_glojure_DOT_core__STAR_) tmp11 := lang.Apply(tmp10, []any{v5, v6}) tmp12 := lang.Apply(tmp8, []any{tmp9, tmp11, v7}) return tmp12 } }) - tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp4 = tmp4.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp3 := ns.InternWithValue(tmp0, tmp4, true) if tmp0.Meta() != nil { tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -2339,7 +3664,7 @@ func LoadNS() { { // let // let binding "op" var tmp4 any - tmp5 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp5) { tmp4 = closed2 } else { @@ -2347,18 +3672,18 @@ func LoadNS() { } var v6 any = tmp4 _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_seq) - tmp8 := checkDerefVar(glojure_DOT_core_concat) - tmp9 := checkDerefVar(glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol(".")}) - tmp11 := checkDerefVar(glojure_DOT_core_list) - tmp12 := lang.Apply(tmp11, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp13 := checkDerefVar(glojure_DOT_core_list) - tmp14 := checkDerefVar(glojure_DOT_core_seq) - tmp15 := checkDerefVar(glojure_DOT_core_concat) - tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v6}) - tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) tmp19 := lang.Apply(tmp18, []any{v2}) tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) tmp21 := lang.Apply(tmp14, []any{tmp20}) @@ -2377,7 +3702,7 @@ func LoadNS() { { // let // let binding "op" var tmp5 any - tmp6 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp6) { tmp5 = closed2 } else { @@ -2385,20 +3710,20 @@ func LoadNS() { } var v7 any = tmp5 _ = v7 - tmp8 := checkDerefVar(glojure_DOT_core_seq) - tmp9 := checkDerefVar(glojure_DOT_core_concat) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol(".")}) - tmp12 := checkDerefVar(glojure_DOT_core_list) - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp14 := checkDerefVar(glojure_DOT_core_list) - tmp15 := checkDerefVar(glojure_DOT_core_seq) - tmp16 := checkDerefVar(glojure_DOT_core_concat) - tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) tmp18 := lang.Apply(tmp17, []any{v7}) - tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) tmp20 := lang.Apply(tmp19, []any{v2}) - tmp21 := checkDerefVar(glojure_DOT_core_list) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) tmp22 := lang.Apply(tmp21, []any{v3}) tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) tmp24 := lang.Apply(tmp15, []any{tmp23}) @@ -2409,9 +3734,7 @@ func LoadNS() { } // end let return tmp4 default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -2422,7 +3745,7 @@ func LoadNS() { { // let // let binding "op" var tmp6 any - tmp7 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp7) { tmp6 = closed2 } else { @@ -2430,30 +3753,28 @@ func LoadNS() { } var v8 any = tmp6 _ = v8 - tmp9 := checkDerefVar(glojure_DOT_core_reduce1) + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) var tmp10 lang.FnFunc tmp10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v11 := args[0] _ = v11 v12 := args[1] _ = v12 - tmp13 := checkDerefVar(glojure_DOT_core_seq) - tmp14 := checkDerefVar(glojure_DOT_core_concat) - tmp15 := checkDerefVar(glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) - tmp17 := checkDerefVar(glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp19 := checkDerefVar(glojure_DOT_core_list) - tmp20 := checkDerefVar(glojure_DOT_core_seq) - tmp21 := checkDerefVar(glojure_DOT_core_concat) - tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) tmp23 := lang.Apply(tmp22, []any{v8}) - tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) tmp25 := lang.Apply(tmp24, []any{v11}) - tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) tmp27 := lang.Apply(tmp26, []any{v12}) tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) tmp29 := lang.Apply(tmp20, []any{tmp28}) @@ -2462,25 +3783,25 @@ func LoadNS() { tmp32 := lang.Apply(tmp13, []any{tmp31}) return tmp32 }) - tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp13 := checkDerefVar(glojure_DOT_core_seq) - tmp14 := checkDerefVar(glojure_DOT_core_concat) - tmp15 := checkDerefVar(glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) - tmp17 := checkDerefVar(glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp19 := checkDerefVar(glojure_DOT_core_list) - tmp20 := checkDerefVar(glojure_DOT_core_seq) - tmp21 := checkDerefVar(glojure_DOT_core_concat) - tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) tmp23 := lang.Apply(tmp22, []any{v8}) - tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) tmp25 := lang.Apply(tmp24, []any{v2}) - tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) tmp27 := lang.Apply(tmp26, []any{v3}) tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) tmp29 := lang.Apply(tmp20, []any{tmp28}) @@ -2493,12 +3814,10 @@ func LoadNS() { return tmp5 } }) - tmp1 = tmp1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") @@ -2508,8 +3827,8 @@ func LoadNS() { tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp0 := lang.NewSymbol("*'").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the product of nums. (*') returns 1. Supports arbitrary precision.\n See also: *", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), tmp2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(989), lang.NewKeyword("end-line"), int(989))).(*lang.Symbol) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym__STAR__TICK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns the product of nums. (*') returns 1. Supports arbitrary precision.\n See also: *", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(7), kw_line, int(989), kw_end_DASH_line, int(989))).(*lang.Symbol) var tmp4 lang.FnFunc tmp4 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -2532,24 +3851,22 @@ func LoadNS() { tmp8 := lang.Apply(tmp7, []any{v5, v6}) return tmp8 default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v5 := args[0] _ = v5 v6 := args[1] _ = v6 var v7 any = lang.NewList(args[2:]...) _ = v7 - tmp8 := checkDerefVar(glojure_DOT_core_reduce1) - tmp9 := checkDerefVar(glojure_DOT_core__STAR__U0027_) - tmp10 := checkDerefVar(glojure_DOT_core__STAR__U0027_) + tmp8 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp9 := checkDerefVar(var_glojure_DOT_core__STAR__TICK_) + tmp10 := checkDerefVar(var_glojure_DOT_core__STAR__TICK_) tmp11 := lang.Apply(tmp10, []any{v5, v6}) tmp12 := lang.Apply(tmp8, []any{tmp9, tmp11, v7}) return tmp12 } }) - tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp4 = tmp4.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp3 := ns.InternWithValue(tmp0, tmp4, true) if tmp0.Meta() != nil { tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -2557,7 +3874,7 @@ func LoadNS() { } // *1 { - tmp0 := lang.NewSymbol("*1").WithMeta(lang.NewMap()).(*lang.Symbol) + tmp0 := sym__STAR_1.WithMeta(lang.NewMap()).(*lang.Symbol) tmp1 := ns.Intern(tmp0) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -2565,7 +3882,7 @@ func LoadNS() { } // *2 { - tmp0 := lang.NewSymbol("*2").WithMeta(lang.NewMap()).(*lang.Symbol) + tmp0 := sym__STAR_2.WithMeta(lang.NewMap()).(*lang.Symbol) tmp1 := ns.Intern(tmp0) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -2573,7 +3890,7 @@ func LoadNS() { } // *3 { - tmp0 := lang.NewSymbol("*3").WithMeta(lang.NewMap()).(*lang.Symbol) + tmp0 := sym__STAR_3.WithMeta(lang.NewMap()).(*lang.Symbol) tmp1 := ns.Intern(tmp0) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -2581,7 +3898,7 @@ func LoadNS() { } // *agent* { - tmp0 := lang.NewSymbol("*agent*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym__STAR_agent_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) tmp1 := ns.InternWithValue(tmp0, nil, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -2589,7 +3906,7 @@ func LoadNS() { } // *assert* { - tmp0 := lang.NewSymbol("*assert*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "When set to logical false, 'assert' will omit assertion checks in\n compiled code. Defaults to true.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym__STAR_assert_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "When set to logical false, 'assert' will omit assertion checks in\n compiled code. Defaults to true.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) tmp1 := ns.InternWithValue(tmp0, false, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -2597,7 +3914,7 @@ func LoadNS() { } // *command-line-args* { - tmp0 := lang.NewSymbol("*command-line-args*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "A sequence of the supplied command line arguments, or nil if\n none were supplied", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym__STAR_command_DASH_line_DASH_args_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "A sequence of the supplied command line arguments, or nil if\n none were supplied", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) tmp1 := ns.InternWithValue(tmp0, nil, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -2605,7 +3922,7 @@ func LoadNS() { } // *compile-files* { - tmp0 := lang.NewSymbol("*compile-files*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "Set to true when compiling files, false otherwise.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym__STAR_compile_DASH_files_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "Set to true when compiling files, false otherwise.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) tmp1 := ns.InternWithValue(tmp0, false, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -2613,7 +3930,7 @@ func LoadNS() { } // *compile-path* { - tmp0 := lang.NewSymbol("*compile-path*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "Specifies the directory where 'compile' will write out .class\n files. This directory must be in the classpath for 'compile' to\n work.\n\n Defaults to \"classes\"", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym__STAR_compile_DASH_path_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "Specifies the directory where 'compile' will write out .class\n files. This directory must be in the classpath for 'compile' to\n work.\n\n Defaults to \"classes\"", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) tmp1 := ns.InternWithValue(tmp0, nil, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -2621,7 +3938,7 @@ func LoadNS() { } // *compiler-options* { - tmp0 := lang.NewSymbol("*compiler-options*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.4", lang.NewKeyword("doc"), "A map of keys to options.\n Note, when binding dynamically make sure to merge with previous value.\n Supported options:\n :elide-meta - a collection of metadata keys to elide during compilation.\n :disable-locals-clearing - set to true to disable clearing, useful for using a debugger\n :direct-linking - set to true to use direct static invocation of functions, rather than vars\n Note that call sites compiled with direct linking will not be affected by var redefinition.\n Use ^:redef (or ^:dynamic) on a var to prevent direct linking and allow redefinition.\n See https://glojure.org/reference/compilation for more information.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym__STAR_compiler_DASH_options_STAR_.WithMeta(lang.NewMap(kw_added, "1.4", kw_doc, "A map of keys to options.\n Note, when binding dynamically make sure to merge with previous value.\n Supported options:\n :elide-meta - a collection of metadata keys to elide during compilation.\n :disable-locals-clearing - set to true to disable clearing, useful for using a debugger\n :direct-linking - set to true to use direct static invocation of functions, rather than vars\n Note that call sites compiled with direct linking will not be affected by var redefinition.\n Use ^:redef (or ^:dynamic) on a var to prevent direct linking and allow redefinition.\n See https://glojure.org/reference/compilation for more information.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) tmp1 := ns.InternWithValue(tmp0, nil, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -2629,7 +3946,7 @@ func LoadNS() { } // *data-readers* { - tmp0 := lang.NewSymbol("*data-readers*").WithMeta(lang.NewMap(lang.NewKeyword("doc"), "Map from reader tag symbols to data reader Vars.\n\n When Clojure starts, it searches for files named 'data_readers.clj'\n and 'data_readers.cljc' at the root of the classpath. Each such file\n must contain a literal map of symbols, like this:\n\n {foo/bar my.project.foo/bar\n foo/baz my.project/baz}\n\n The first symbol in each pair is a tag that will be recognized by\n the Clojure reader. The second symbol in the pair is the\n fully-qualified name of a Var which will be invoked by the reader to\n parse the form following the tag. For example, given the\n data_readers.clj file above, the Clojure reader would parse this\n form:\n\n #foo/bar [1 2 3]\n\n by invoking the Var #'my.project.foo/bar on the vector [1 2 3]. The\n data reader function is invoked on the form AFTER it has been read\n as a normal Clojure data structure by the reader.\n\n Reader tags without namespace qualifiers are reserved for\n Clojure. Default reader tags are defined in\n glojure.core/default-data-readers but may be overridden in\n data_readers.clj, data_readers.cljc, or by rebinding this Var.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(49), lang.NewKeyword("column"), int(6), lang.NewKeyword("line"), int(7794), lang.NewKeyword("end-line"), int(7794), lang.NewKeyword("dynamic"), true)).(*lang.Symbol) + tmp0 := sym__STAR_data_DASH_readers_STAR_.WithMeta(lang.NewMap(kw_doc, "Map from reader tag symbols to data reader Vars.\n\n When Clojure starts, it searches for files named 'data_readers.clj'\n and 'data_readers.cljc' at the root of the classpath. Each such file\n must contain a literal map of symbols, like this:\n\n {foo/bar my.project.foo/bar\n foo/baz my.project/baz}\n\n The first symbol in each pair is a tag that will be recognized by\n the Clojure reader. The second symbol in the pair is the\n fully-qualified name of a Var which will be invoked by the reader to\n parse the form following the tag. For example, given the\n data_readers.clj file above, the Clojure reader would parse this\n form:\n\n #foo/bar [1 2 3]\n\n by invoking the Var #'my.project.foo/bar on the vector [1 2 3]. The\n data reader function is invoked on the form AFTER it has been read\n as a normal Clojure data structure by the reader.\n\n Reader tags without namespace qualifiers are reserved for\n Clojure. Default reader tags are defined in\n glojure.core/default-data-readers but may be overridden in\n data_readers.clj, data_readers.cljc, or by rebinding this Var.", kw_file, "glojure/core.glj", kw_added, "1.4", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(49), kw_column, int(6), kw_line, int(7794), kw_end_DASH_line, int(7794), kw_dynamic, true)).(*lang.Symbol) tmp1 := ns.InternWithValue(tmp0, lang.NewMap(), true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -2637,7 +3954,7 @@ func LoadNS() { } // *default-data-reader-fn* { - tmp0 := lang.NewSymbol("*default-data-reader-fn*").WithMeta(lang.NewMap(lang.NewKeyword("doc"), "When no data reader is found for a tag and *default-data-reader-fn*\n is non-nil, it will be called with two arguments,\n the tag and the value. If *default-data-reader-fn* is nil (the\n default), an exception will be thrown for the unknown tag.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(59), lang.NewKeyword("column"), int(6), lang.NewKeyword("line"), int(7823), lang.NewKeyword("end-line"), int(7823), lang.NewKeyword("dynamic"), true)).(*lang.Symbol) + tmp0 := sym__STAR_default_DASH_data_DASH_reader_DASH_fn_STAR_.WithMeta(lang.NewMap(kw_doc, "When no data reader is found for a tag and *default-data-reader-fn*\n is non-nil, it will be called with two arguments,\n the tag and the value. If *default-data-reader-fn* is nil (the\n default), an exception will be thrown for the unknown tag.", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(59), kw_column, int(6), kw_line, int(7823), kw_end_DASH_line, int(7823), kw_dynamic, true)).(*lang.Symbol) tmp1 := ns.InternWithValue(tmp0, nil, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -2645,7 +3962,7 @@ func LoadNS() { } // *e { - tmp0 := lang.NewSymbol("*e").WithMeta(lang.NewMap()).(*lang.Symbol) + tmp0 := sym__STAR_e.WithMeta(lang.NewMap()).(*lang.Symbol) tmp1 := ns.Intern(tmp0) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -2653,7 +3970,7 @@ func LoadNS() { } // *err* { - tmp0 := lang.NewSymbol("*err*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "A java.io.Writer object representing standard error for print operations.\n\n Defaults to System/err, wrapped in a PrintWriter", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym__STAR_err_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "A java.io.Writer object representing standard error for print operations.\n\n Defaults to System/err, wrapped in a PrintWriter", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) tmp1 := ns.InternWithValue(tmp0, nil, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -2661,7 +3978,7 @@ func LoadNS() { } // *file* { - tmp0 := lang.NewSymbol("*file*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "The path of the file being evaluated, as a String.\n\n When there is no file, e.g. in the REPL, the value is not defined.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym__STAR_file_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "The path of the file being evaluated, as a String.\n\n When there is no file, e.g. in the REPL, the value is not defined.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) tmp1 := ns.InternWithValue(tmp0, "NO_SOURCE_FILE", true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -2669,7 +3986,7 @@ func LoadNS() { } // *flush-on-newline* { - tmp0 := lang.NewSymbol("*flush-on-newline*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "When set to true, output will be flushed whenever a newline is printed.\n\n Defaults to true.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym__STAR_flush_DASH_on_DASH_newline_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "When set to true, output will be flushed whenever a newline is printed.\n\n Defaults to true.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) tmp1 := ns.InternWithValue(tmp0, nil, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -2677,8 +3994,8 @@ func LoadNS() { } // *loaded-libs* { - tmp0 := lang.NewSymbol("*loaded-libs*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5817), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(5820), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - tmp2 := lang.NewRef(lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{lang.NewSymbol("glojure.core.protocols"), lang.NewSymbol("glojure.string"), lang.NewSymbol("glojure.go.io")}))) + tmp0 := sym__STAR_loaded_DASH_libs_STAR_.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core.glj", kw_line, int(5817), kw_column, int(10), kw_end_DASH_line, int(5820), kw_end_DASH_column, int(15), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + tmp2 := lang.NewRef(lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{sym_glojure_DOT_core_DOT_protocols, sym_glojure_DOT_string, sym_glojure_DOT_go_DOT_io, sym_codegen_DOT_test_DOT_const_DASH_keyword, sym_codegen_DOT_test_DOT_const_DASH_number, sym_codegen_DOT_test_DOT_const_DASH_string, sym_codegen_DOT_test_DOT_def_DASH_simple, sym_codegen_DOT_test_DOT_fn_DASH_closure, sym_codegen_DOT_test_DOT_fn_DASH_recur, sym_codegen_DOT_test_DOT_loop_DASH_simple, sym_codegen_DOT_test_DOT_maybe_DASH_class, sym_codegen_DOT_test_DOT_multifn, sym_codegen_DOT_test_DOT_ns_DASH_skip, sym_codegen_DOT_test_DOT_quote_DASH_simple, sym_codegen_DOT_test_DOT_ref, sym_codegen_DOT_test_DOT_the_DASH_var, sym_codegen_DOT_test_DOT_throw_DASH_simple, sym_codegen_DOT_test_DOT_try_DASH_advanced, sym_codegen_DOT_test_DOT_try_DASH_basic, sym_codegen_DOT_test_DOT_values, sym_codegen_DOT_test_DOT_with_DASH_meta}))) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -2686,7 +4003,7 @@ func LoadNS() { } // *loading-verbosely* { - tmp0 := lang.NewSymbol("*loading-verbosely*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5827), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(5830), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym__STAR_loading_DASH_verbosely_STAR_.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core.glj", kw_line, int(5827), kw_column, int(10), kw_end_DASH_line, int(5830), kw_end_DASH_column, int(21), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) tmp1 := ns.InternWithValue(tmp0, false, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -2694,15 +4011,15 @@ func LoadNS() { } // *ns* { - tmp0 := lang.NewSymbol("*ns*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "A glojure.lang.Namespace object representing the current namespace.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), true) + tmp0 := sym__STAR_ns_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "A glojure.lang.Namespace object representing the current namespace.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, lang.FindOrCreateNamespace(sym_glojure_DOT_core), true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // *pending-paths* { - tmp0 := lang.NewSymbol("*pending-paths*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5822), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(5825), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym__STAR_pending_DASH_paths_STAR_.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core.glj", kw_line, int(5822), kw_column, int(10), kw_end_DASH_line, int(5825), kw_end_DASH_column, int(17), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) tmp1 := ns.InternWithValue(tmp0, lang.NewList(), true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -2710,7 +4027,7 @@ func LoadNS() { } // *print-dup* { - tmp0 := lang.NewSymbol("*print-dup*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "When set to logical true, objects will be printed in a way that preserves\n their type when read in later.\n\n Defaults to false.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym__STAR_print_DASH_dup_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "When set to logical true, objects will be printed in a way that preserves\n their type when read in later.\n\n Defaults to false.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) tmp1 := ns.InternWithValue(tmp0, nil, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -2718,7 +4035,7 @@ func LoadNS() { } // *print-length* { - tmp0 := lang.NewSymbol("*print-length*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(14), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(23), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym__STAR_print_DASH_length_STAR_.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core_print.glj", kw_line, int(14), kw_column, int(6), kw_end_DASH_line, int(23), kw_end_DASH_column, int(15), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) tmp1 := ns.InternWithValue(tmp0, nil, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -2726,7 +4043,7 @@ func LoadNS() { } // *print-level* { - tmp0 := lang.NewSymbol("*print-level*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(25), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(35), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym__STAR_print_DASH_level_STAR_.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core_print.glj", kw_line, int(25), kw_column, int(6), kw_end_DASH_line, int(35), kw_end_DASH_column, int(14), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) tmp1 := ns.InternWithValue(tmp0, nil, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -2734,7 +4051,7 @@ func LoadNS() { } // *print-meta* { - tmp0 := lang.NewSymbol("*print-meta*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "If set to logical true, when printing an object, its metadata will also\n be printed in a form that can be read back by the reader.\n\n Defaults to false.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym__STAR_print_DASH_meta_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "If set to logical true, when printing an object, its metadata will also\n be printed in a form that can be read back by the reader.\n\n Defaults to false.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) tmp1 := ns.InternWithValue(tmp0, nil, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -2742,7 +4059,7 @@ func LoadNS() { } // *print-namespace-maps* { - tmp0 := lang.NewSymbol("*print-namespace-maps*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(39), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(44), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym__STAR_print_DASH_namespace_DASH_maps_STAR_.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core_print.glj", kw_line, int(39), kw_column, int(6), kw_end_DASH_line, int(44), kw_end_DASH_column, int(23), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) tmp1 := ns.InternWithValue(tmp0, false, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -2750,7 +4067,7 @@ func LoadNS() { } // *print-readably* { - tmp0 := lang.NewSymbol("*print-readably*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "When set to logical false, strings and characters will be printed with\n non-alphanumeric characters converted to the appropriate escape sequences.\n\n Defaults to true", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym__STAR_print_DASH_readably_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "When set to logical false, strings and characters will be printed with\n non-alphanumeric characters converted to the appropriate escape sequences.\n\n Defaults to true", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) tmp1 := ns.InternWithValue(tmp0, true, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -2758,7 +4075,7 @@ func LoadNS() { } // *read-eval* { - tmp0 := lang.NewSymbol("*read-eval*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "Defaults to true (or value specified by system property, see below)\n ***This setting implies that the full power of the reader is in play,\n including syntax that can cause code to execute. It should never be\n used with untrusted sources. See also: glojure.edn/read.***\n\n When set to logical false in the thread-local binding,\n the eval reader (#=) and record/type literal syntax are disabled in read/load.\n Example (will fail): (binding [*read-eval* false] (read-string \"#=(* 2 21)\"))\n\n The default binding can be controlled by the system property\n 'glojure.read.eval' System properties can be set on the command line\n like this:\n\n java -Dglojure.read.eval=false ...\n\n The system property can also be set to 'unknown' via\n -Dglojure.read.eval=unknown, in which case the default binding\n is :unknown and all reads will fail in contexts where *read-eval*\n has not been explicitly bound to either true or false. This setting\n can be a useful diagnostic tool to ensure that all of your reads\n occur in considered contexts. You can also accomplish this in a\n particular scope by binding *read-eval* to :unknown\n ", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym__STAR_read_DASH_eval_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "Defaults to true (or value specified by system property, see below)\n ***This setting implies that the full power of the reader is in play,\n including syntax that can cause code to execute. It should never be\n used with untrusted sources. See also: glojure.edn/read.***\n\n When set to logical false in the thread-local binding,\n the eval reader (#=) and record/type literal syntax are disabled in read/load.\n Example (will fail): (binding [*read-eval* false] (read-string \"#=(* 2 21)\"))\n\n The default binding can be controlled by the system property\n 'glojure.read.eval' System properties can be set on the command line\n like this:\n\n java -Dglojure.read.eval=false ...\n\n The system property can also be set to 'unknown' via\n -Dglojure.read.eval=unknown, in which case the default binding\n is :unknown and all reads will fail in contexts where *read-eval*\n has not been explicitly bound to either true or false. This setting\n can be a useful diagnostic tool to ensure that all of your reads\n occur in considered contexts. You can also accomplish this in a\n particular scope by binding *read-eval* to :unknown\n ", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) tmp1 := ns.InternWithValue(tmp0, nil, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -2766,7 +4083,7 @@ func LoadNS() { } // *repl* { - tmp0 := lang.NewSymbol("*repl*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6288), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(6291), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym__STAR_repl_STAR_.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core.glj", kw_line, int(6288), kw_column, int(6), kw_end_DASH_line, int(6291), kw_end_DASH_column, int(8), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) tmp1 := ns.InternWithValue(tmp0, false, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -2774,7 +4091,7 @@ func LoadNS() { } // *unchecked-math* { - tmp0 := lang.NewSymbol("*unchecked-math*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.3", lang.NewKeyword("doc"), "While bound to true, compilations of +, -, *, inc, dec and the\n coercions will be done without overflow checks. While bound\n to :warn-on-boxed, same behavior as true, and a warning is emitted\n when compilation uses boxed math. Default: false.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym__STAR_unchecked_DASH_math_STAR_.WithMeta(lang.NewMap(kw_added, "1.3", kw_doc, "While bound to true, compilations of +, -, *, inc, dec and the\n coercions will be done without overflow checks. While bound\n to :warn-on-boxed, same behavior as true, and a warning is emitted\n when compilation uses boxed math. Default: false.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) tmp1 := ns.InternWithValue(tmp0, nil, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -2782,7 +4099,7 @@ func LoadNS() { } // *verbose-defrecords* { - tmp0 := lang.NewSymbol("*verbose-defrecords*").WithMeta(lang.NewMap(lang.NewKeyword("dynamic"), true, lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(37), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(37), lang.NewKeyword("end-column"), int(35), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym__STAR_verbose_DASH_defrecords_STAR_.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core_print.glj", kw_line, int(37), kw_column, int(6), kw_end_DASH_line, int(37), kw_end_DASH_column, int(35), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) tmp1 := ns.InternWithValue(tmp0, false, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -2790,7 +4107,7 @@ func LoadNS() { } // *warn-on-reflection* { - tmp0 := lang.NewSymbol("*warn-on-reflection*").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("doc"), "When set to true, the compiler will emit warnings when reflection is\n needed to resolve Java method calls or field accesses.\n\n Defaults to false.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym__STAR_warn_DASH_on_DASH_reflection_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "When set to true, the compiler will emit warnings when reflection is\n needed to resolve Java method calls or field accesses.\n\n Defaults to false.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) tmp1 := ns.InternWithValue(tmp0, nil, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -2808,7 +4125,7 @@ func LoadNS() { { // let // let binding "op" var tmp4 any - tmp5 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp5) { tmp4 = closed3 } else { @@ -2816,18 +4133,18 @@ func LoadNS() { } var v6 any = tmp4 _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_seq) - tmp8 := checkDerefVar(glojure_DOT_core_concat) - tmp9 := checkDerefVar(glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol(".")}) - tmp11 := checkDerefVar(glojure_DOT_core_list) - tmp12 := lang.Apply(tmp11, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp13 := checkDerefVar(glojure_DOT_core_list) - tmp14 := checkDerefVar(glojure_DOT_core_seq) - tmp15 := checkDerefVar(glojure_DOT_core_concat) - tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v6}) - tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) tmp19 := lang.Apply(tmp18, []any{v2}) tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) tmp21 := lang.Apply(tmp14, []any{tmp20}) @@ -2846,7 +4163,7 @@ func LoadNS() { { // let // let binding "op" var tmp5 any - tmp6 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp6) { tmp5 = closed3 } else { @@ -2854,20 +4171,20 @@ func LoadNS() { } var v7 any = tmp5 _ = v7 - tmp8 := checkDerefVar(glojure_DOT_core_seq) - tmp9 := checkDerefVar(glojure_DOT_core_concat) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol(".")}) - tmp12 := checkDerefVar(glojure_DOT_core_list) - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp14 := checkDerefVar(glojure_DOT_core_list) - tmp15 := checkDerefVar(glojure_DOT_core_seq) - tmp16 := checkDerefVar(glojure_DOT_core_concat) - tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) tmp18 := lang.Apply(tmp17, []any{v7}) - tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) tmp20 := lang.Apply(tmp19, []any{v2}) - tmp21 := checkDerefVar(glojure_DOT_core_list) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) tmp22 := lang.Apply(tmp21, []any{v3}) tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) tmp24 := lang.Apply(tmp15, []any{tmp23}) @@ -2878,9 +4195,7 @@ func LoadNS() { } // end let return tmp4 default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -2891,7 +4206,7 @@ func LoadNS() { { // let // let binding "op" var tmp6 any - tmp7 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp7) { tmp6 = closed3 } else { @@ -2899,30 +4214,28 @@ func LoadNS() { } var v8 any = tmp6 _ = v8 - tmp9 := checkDerefVar(glojure_DOT_core_reduce1) + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) var tmp10 lang.FnFunc tmp10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v11 := args[0] _ = v11 v12 := args[1] _ = v12 - tmp13 := checkDerefVar(glojure_DOT_core_seq) - tmp14 := checkDerefVar(glojure_DOT_core_concat) - tmp15 := checkDerefVar(glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) - tmp17 := checkDerefVar(glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp19 := checkDerefVar(glojure_DOT_core_list) - tmp20 := checkDerefVar(glojure_DOT_core_seq) - tmp21 := checkDerefVar(glojure_DOT_core_concat) - tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) tmp23 := lang.Apply(tmp22, []any{v8}) - tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) tmp25 := lang.Apply(tmp24, []any{v11}) - tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) tmp27 := lang.Apply(tmp26, []any{v12}) tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) tmp29 := lang.Apply(tmp20, []any{tmp28}) @@ -2931,25 +4244,25 @@ func LoadNS() { tmp32 := lang.Apply(tmp13, []any{tmp31}) return tmp32 }) - tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp13 := checkDerefVar(glojure_DOT_core_seq) - tmp14 := checkDerefVar(glojure_DOT_core_concat) - tmp15 := checkDerefVar(glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) - tmp17 := checkDerefVar(glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp19 := checkDerefVar(glojure_DOT_core_list) - tmp20 := checkDerefVar(glojure_DOT_core_seq) - tmp21 := checkDerefVar(glojure_DOT_core_concat) - tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) tmp23 := lang.Apply(tmp22, []any{v8}) - tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) tmp25 := lang.Apply(tmp24, []any{v2}) - tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) tmp27 := lang.Apply(tmp26, []any{v3}) tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) tmp29 := lang.Apply(tmp20, []any{tmp28}) @@ -2962,12 +4275,10 @@ func LoadNS() { return tmp5 } }) - tmp1 = tmp1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") @@ -2977,8 +4288,8 @@ func LoadNS() { tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp0 := lang.NewSymbol("+").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the sum of nums. (+) returns 0. Does not auto-promote\n longs, will throw on overflow. See also: +'", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), tmp2, lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(977), lang.NewKeyword("end-line"), int(977))).(*lang.Symbol) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym__PLUS_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns the sum of nums. (+) returns 0. Does not auto-promote\n longs, will throw on overflow. See also: +'", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(7), kw_line, int(977), kw_end_DASH_line, int(977))).(*lang.Symbol) var tmp4 lang.FnFunc tmp4 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -3001,24 +4312,22 @@ func LoadNS() { tmp8 := lang.Apply(tmp7, []any{v5, v6}) return tmp8 default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v5 := args[0] _ = v5 v6 := args[1] _ = v6 var v7 any = lang.NewList(args[2:]...) _ = v7 - tmp8 := checkDerefVar(glojure_DOT_core_reduce1) - tmp9 := checkDerefVar(glojure_DOT_core__PLUS_) - tmp10 := checkDerefVar(glojure_DOT_core__PLUS_) + tmp8 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp9 := checkDerefVar(var_glojure_DOT_core__PLUS_) + tmp10 := checkDerefVar(var_glojure_DOT_core__PLUS_) tmp11 := lang.Apply(tmp10, []any{v5, v6}) tmp12 := lang.Apply(tmp8, []any{tmp9, tmp11, v7}) return tmp12 } }) - tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp4 = tmp4.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp3 := ns.InternWithValue(tmp0, tmp4, true) if tmp0.Meta() != nil { tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -3036,7 +4345,7 @@ func LoadNS() { { // let // let binding "op" var tmp4 any - tmp5 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp5) { tmp4 = closed5 } else { @@ -3044,18 +4353,18 @@ func LoadNS() { } var v6 any = tmp4 _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_seq) - tmp8 := checkDerefVar(glojure_DOT_core_concat) - tmp9 := checkDerefVar(glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol(".")}) - tmp11 := checkDerefVar(glojure_DOT_core_list) - tmp12 := lang.Apply(tmp11, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp13 := checkDerefVar(glojure_DOT_core_list) - tmp14 := checkDerefVar(glojure_DOT_core_seq) - tmp15 := checkDerefVar(glojure_DOT_core_concat) - tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v6}) - tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) tmp19 := lang.Apply(tmp18, []any{v2}) tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) tmp21 := lang.Apply(tmp14, []any{tmp20}) @@ -3074,7 +4383,7 @@ func LoadNS() { { // let // let binding "op" var tmp5 any - tmp6 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp6) { tmp5 = closed5 } else { @@ -3082,20 +4391,20 @@ func LoadNS() { } var v7 any = tmp5 _ = v7 - tmp8 := checkDerefVar(glojure_DOT_core_seq) - tmp9 := checkDerefVar(glojure_DOT_core_concat) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol(".")}) - tmp12 := checkDerefVar(glojure_DOT_core_list) - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp14 := checkDerefVar(glojure_DOT_core_list) - tmp15 := checkDerefVar(glojure_DOT_core_seq) - tmp16 := checkDerefVar(glojure_DOT_core_concat) - tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) tmp18 := lang.Apply(tmp17, []any{v7}) - tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) tmp20 := lang.Apply(tmp19, []any{v2}) - tmp21 := checkDerefVar(glojure_DOT_core_list) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) tmp22 := lang.Apply(tmp21, []any{v3}) tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) tmp24 := lang.Apply(tmp15, []any{tmp23}) @@ -3106,9 +4415,7 @@ func LoadNS() { } // end let return tmp4 default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -3119,7 +4426,7 @@ func LoadNS() { { // let // let binding "op" var tmp6 any - tmp7 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp7) { tmp6 = closed5 } else { @@ -3127,30 +4434,28 @@ func LoadNS() { } var v8 any = tmp6 _ = v8 - tmp9 := checkDerefVar(glojure_DOT_core_reduce1) + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) var tmp10 lang.FnFunc tmp10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v11 := args[0] _ = v11 v12 := args[1] _ = v12 - tmp13 := checkDerefVar(glojure_DOT_core_seq) - tmp14 := checkDerefVar(glojure_DOT_core_concat) - tmp15 := checkDerefVar(glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) - tmp17 := checkDerefVar(glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp19 := checkDerefVar(glojure_DOT_core_list) - tmp20 := checkDerefVar(glojure_DOT_core_seq) - tmp21 := checkDerefVar(glojure_DOT_core_concat) - tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) tmp23 := lang.Apply(tmp22, []any{v8}) - tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) tmp25 := lang.Apply(tmp24, []any{v11}) - tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) tmp27 := lang.Apply(tmp26, []any{v12}) tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) tmp29 := lang.Apply(tmp20, []any{tmp28}) @@ -3159,25 +4464,25 @@ func LoadNS() { tmp32 := lang.Apply(tmp13, []any{tmp31}) return tmp32 }) - tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp13 := checkDerefVar(glojure_DOT_core_seq) - tmp14 := checkDerefVar(glojure_DOT_core_concat) - tmp15 := checkDerefVar(glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) - tmp17 := checkDerefVar(glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp19 := checkDerefVar(glojure_DOT_core_list) - tmp20 := checkDerefVar(glojure_DOT_core_seq) - tmp21 := checkDerefVar(glojure_DOT_core_concat) - tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) tmp23 := lang.Apply(tmp22, []any{v8}) - tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) tmp25 := lang.Apply(tmp24, []any{v2}) - tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) tmp27 := lang.Apply(tmp26, []any{v3}) tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) tmp29 := lang.Apply(tmp20, []any{tmp28}) @@ -3190,12 +4495,10 @@ func LoadNS() { return tmp5 } }) - tmp1 = tmp1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") @@ -3205,8 +4508,8 @@ func LoadNS() { tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp0 := lang.NewSymbol("+'").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the sum of nums. (+') returns 0. Supports arbitrary precision.\n See also: +", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), tmp2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(965), lang.NewKeyword("end-line"), int(965))).(*lang.Symbol) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym__PLUS__TICK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns the sum of nums. (+') returns 0. Supports arbitrary precision.\n See also: +", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(7), kw_line, int(965), kw_end_DASH_line, int(965))).(*lang.Symbol) var tmp4 lang.FnFunc tmp4 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -3229,24 +4532,22 @@ func LoadNS() { tmp8 := lang.Apply(tmp7, []any{v5, v6}) return tmp8 default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v5 := args[0] _ = v5 v6 := args[1] _ = v6 var v7 any = lang.NewList(args[2:]...) _ = v7 - tmp8 := checkDerefVar(glojure_DOT_core_reduce1) - tmp9 := checkDerefVar(glojure_DOT_core__PLUS__U0027_) - tmp10 := checkDerefVar(glojure_DOT_core__PLUS__U0027_) + tmp8 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp9 := checkDerefVar(var_glojure_DOT_core__PLUS__TICK_) + tmp10 := checkDerefVar(var_glojure_DOT_core__PLUS__TICK_) tmp11 := lang.Apply(tmp10, []any{v5, v6}) tmp12 := lang.Apply(tmp8, []any{tmp9, tmp11, v7}) return tmp12 } }) - tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp4 = tmp4.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp3 := ns.InternWithValue(tmp0, tmp4, true) if tmp0.Meta() != nil { tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -3264,7 +4565,7 @@ func LoadNS() { { // let // let binding "op" var tmp4 any - tmp5 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp5) { tmp4 = closed6 } else { @@ -3272,18 +4573,18 @@ func LoadNS() { } var v6 any = tmp4 _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_seq) - tmp8 := checkDerefVar(glojure_DOT_core_concat) - tmp9 := checkDerefVar(glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol(".")}) - tmp11 := checkDerefVar(glojure_DOT_core_list) - tmp12 := lang.Apply(tmp11, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp13 := checkDerefVar(glojure_DOT_core_list) - tmp14 := checkDerefVar(glojure_DOT_core_seq) - tmp15 := checkDerefVar(glojure_DOT_core_concat) - tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v6}) - tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) tmp19 := lang.Apply(tmp18, []any{v2}) tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) tmp21 := lang.Apply(tmp14, []any{tmp20}) @@ -3302,7 +4603,7 @@ func LoadNS() { { // let // let binding "op" var tmp5 any - tmp6 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp6) { tmp5 = closed6 } else { @@ -3310,20 +4611,20 @@ func LoadNS() { } var v7 any = tmp5 _ = v7 - tmp8 := checkDerefVar(glojure_DOT_core_seq) - tmp9 := checkDerefVar(glojure_DOT_core_concat) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol(".")}) - tmp12 := checkDerefVar(glojure_DOT_core_list) - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp14 := checkDerefVar(glojure_DOT_core_list) - tmp15 := checkDerefVar(glojure_DOT_core_seq) - tmp16 := checkDerefVar(glojure_DOT_core_concat) - tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) tmp18 := lang.Apply(tmp17, []any{v7}) - tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) tmp20 := lang.Apply(tmp19, []any{v2}) - tmp21 := checkDerefVar(glojure_DOT_core_list) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) tmp22 := lang.Apply(tmp21, []any{v3}) tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) tmp24 := lang.Apply(tmp15, []any{tmp23}) @@ -3334,9 +4635,7 @@ func LoadNS() { } // end let return tmp4 default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -3347,7 +4646,7 @@ func LoadNS() { { // let // let binding "op" var tmp6 any - tmp7 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp7) { tmp6 = closed6 } else { @@ -3355,30 +4654,28 @@ func LoadNS() { } var v8 any = tmp6 _ = v8 - tmp9 := checkDerefVar(glojure_DOT_core_reduce1) + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) var tmp10 lang.FnFunc tmp10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v11 := args[0] _ = v11 v12 := args[1] _ = v12 - tmp13 := checkDerefVar(glojure_DOT_core_seq) - tmp14 := checkDerefVar(glojure_DOT_core_concat) - tmp15 := checkDerefVar(glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) - tmp17 := checkDerefVar(glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp19 := checkDerefVar(glojure_DOT_core_list) - tmp20 := checkDerefVar(glojure_DOT_core_seq) - tmp21 := checkDerefVar(glojure_DOT_core_concat) - tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) tmp23 := lang.Apply(tmp22, []any{v8}) - tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) tmp25 := lang.Apply(tmp24, []any{v11}) - tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) tmp27 := lang.Apply(tmp26, []any{v12}) tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) tmp29 := lang.Apply(tmp20, []any{tmp28}) @@ -3387,25 +4684,25 @@ func LoadNS() { tmp32 := lang.Apply(tmp13, []any{tmp31}) return tmp32 }) - tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp13 := checkDerefVar(glojure_DOT_core_seq) - tmp14 := checkDerefVar(glojure_DOT_core_concat) - tmp15 := checkDerefVar(glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) - tmp17 := checkDerefVar(glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp19 := checkDerefVar(glojure_DOT_core_list) - tmp20 := checkDerefVar(glojure_DOT_core_seq) - tmp21 := checkDerefVar(glojure_DOT_core_concat) - tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) tmp23 := lang.Apply(tmp22, []any{v8}) - tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) tmp25 := lang.Apply(tmp24, []any{v2}) - tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) tmp27 := lang.Apply(tmp26, []any{v3}) tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) tmp29 := lang.Apply(tmp20, []any{tmp28}) @@ -3418,12 +4715,10 @@ func LoadNS() { return tmp5 } }) - tmp1 = tmp1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") @@ -3433,15 +4728,15 @@ func LoadNS() { tmp5 := lang.Apply(tmp4, []any{nil, int64(0)}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp0 := lang.NewSymbol("-").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "If no ys are supplied, returns the negation of x, else subtracts\n the ys from x and returns the result. Does not auto-promote\n longs, will throw on overflow. See also: -'", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), tmp2, lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1036), lang.NewKeyword("end-line"), int(1036))).(*lang.Symbol) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym__DASH_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "If no ys are supplied, returns the negation of x, else subtracts\n the ys from x and returns the result. Does not auto-promote\n longs, will throw on overflow. See also: -'", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(7), kw_line, int(1036), kw_end_DASH_line, int(1036))).(*lang.Symbol) var tmp4 lang.FnFunc tmp4 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v5 := args[0] _ = v5 - tmp6 := checkDerefVar(glojure_DOT_core__STAR_) + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_) tmp7 := lang.Apply(tmp6, []any{int64(-1), v5}) return tmp7 case 2: @@ -3456,24 +4751,22 @@ func LoadNS() { tmp8 := lang.Apply(tmp7, []any{v5, v6}) return tmp8 default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v5 := args[0] _ = v5 v6 := args[1] _ = v6 var v7 any = lang.NewList(args[2:]...) _ = v7 - tmp8 := checkDerefVar(glojure_DOT_core_reduce1) - tmp9 := checkDerefVar(glojure_DOT_core__) - tmp10 := checkDerefVar(glojure_DOT_core__) + tmp8 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp9 := checkDerefVar(var_glojure_DOT_core__DASH_) + tmp10 := checkDerefVar(var_glojure_DOT_core__DASH_) tmp11 := lang.Apply(tmp10, []any{v5, v6}) tmp12 := lang.Apply(tmp8, []any{tmp9, tmp11, v7}) return tmp12 } }) - tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp4 = tmp4.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp3 := ns.InternWithValue(tmp0, tmp4, true) if tmp0.Meta() != nil { tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -3491,7 +4784,7 @@ func LoadNS() { { // let // let binding "op" var tmp4 any - tmp5 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp5) { tmp4 = closed8 } else { @@ -3499,18 +4792,18 @@ func LoadNS() { } var v6 any = tmp4 _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_seq) - tmp8 := checkDerefVar(glojure_DOT_core_concat) - tmp9 := checkDerefVar(glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol(".")}) - tmp11 := checkDerefVar(glojure_DOT_core_list) - tmp12 := lang.Apply(tmp11, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp13 := checkDerefVar(glojure_DOT_core_list) - tmp14 := checkDerefVar(glojure_DOT_core_seq) - tmp15 := checkDerefVar(glojure_DOT_core_concat) - tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v6}) - tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) tmp19 := lang.Apply(tmp18, []any{v2}) tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) tmp21 := lang.Apply(tmp14, []any{tmp20}) @@ -3529,7 +4822,7 @@ func LoadNS() { { // let // let binding "op" var tmp5 any - tmp6 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp6) { tmp5 = closed8 } else { @@ -3537,20 +4830,20 @@ func LoadNS() { } var v7 any = tmp5 _ = v7 - tmp8 := checkDerefVar(glojure_DOT_core_seq) - tmp9 := checkDerefVar(glojure_DOT_core_concat) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol(".")}) - tmp12 := checkDerefVar(glojure_DOT_core_list) - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp14 := checkDerefVar(glojure_DOT_core_list) - tmp15 := checkDerefVar(glojure_DOT_core_seq) - tmp16 := checkDerefVar(glojure_DOT_core_concat) - tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) tmp18 := lang.Apply(tmp17, []any{v7}) - tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) tmp20 := lang.Apply(tmp19, []any{v2}) - tmp21 := checkDerefVar(glojure_DOT_core_list) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) tmp22 := lang.Apply(tmp21, []any{v3}) tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) tmp24 := lang.Apply(tmp15, []any{tmp23}) @@ -3561,9 +4854,7 @@ func LoadNS() { } // end let return tmp4 default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -3574,7 +4865,7 @@ func LoadNS() { { // let // let binding "op" var tmp6 any - tmp7 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp7) { tmp6 = closed8 } else { @@ -3582,30 +4873,28 @@ func LoadNS() { } var v8 any = tmp6 _ = v8 - tmp9 := checkDerefVar(glojure_DOT_core_reduce1) + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) var tmp10 lang.FnFunc tmp10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v11 := args[0] _ = v11 v12 := args[1] _ = v12 - tmp13 := checkDerefVar(glojure_DOT_core_seq) - tmp14 := checkDerefVar(glojure_DOT_core_concat) - tmp15 := checkDerefVar(glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) - tmp17 := checkDerefVar(glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp19 := checkDerefVar(glojure_DOT_core_list) - tmp20 := checkDerefVar(glojure_DOT_core_seq) - tmp21 := checkDerefVar(glojure_DOT_core_concat) - tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) tmp23 := lang.Apply(tmp22, []any{v8}) - tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) tmp25 := lang.Apply(tmp24, []any{v11}) - tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) tmp27 := lang.Apply(tmp26, []any{v12}) tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) tmp29 := lang.Apply(tmp20, []any{tmp28}) @@ -3614,25 +4903,25 @@ func LoadNS() { tmp32 := lang.Apply(tmp13, []any{tmp31}) return tmp32 }) - tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp13 := checkDerefVar(glojure_DOT_core_seq) - tmp14 := checkDerefVar(glojure_DOT_core_concat) - tmp15 := checkDerefVar(glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) - tmp17 := checkDerefVar(glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp19 := checkDerefVar(glojure_DOT_core_list) - tmp20 := checkDerefVar(glojure_DOT_core_seq) - tmp21 := checkDerefVar(glojure_DOT_core_concat) - tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) tmp23 := lang.Apply(tmp22, []any{v8}) - tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) tmp25 := lang.Apply(tmp24, []any{v2}) - tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) tmp27 := lang.Apply(tmp26, []any{v3}) tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) tmp29 := lang.Apply(tmp20, []any{tmp28}) @@ -3645,12 +4934,10 @@ func LoadNS() { return tmp5 } }) - tmp1 = tmp1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") @@ -3660,15 +4947,15 @@ func LoadNS() { tmp5 := lang.Apply(tmp4, []any{nil, int64(0)}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp0 := lang.NewSymbol("-'").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "If no ys are supplied, returns the negation of x, else subtracts\n the ys from x and returns the result. Supports arbitrary precision.\n See also: -", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), tmp2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1024), lang.NewKeyword("end-line"), int(1024))).(*lang.Symbol) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym__DASH__TICK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "If no ys are supplied, returns the negation of x, else subtracts\n the ys from x and returns the result. Supports arbitrary precision.\n See also: -", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(7), kw_line, int(1024), kw_end_DASH_line, int(1024))).(*lang.Symbol) var tmp4 lang.FnFunc tmp4 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v5 := args[0] _ = v5 - tmp6 := checkDerefVar(glojure_DOT_core__STAR__U0027_) + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR__TICK_) tmp7 := lang.Apply(tmp6, []any{int64(-1), v5}) return tmp7 case 2: @@ -3683,24 +4970,22 @@ func LoadNS() { tmp8 := lang.Apply(tmp7, []any{v5, v6}) return tmp8 default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v5 := args[0] _ = v5 v6 := args[1] _ = v6 var v7 any = lang.NewList(args[2:]...) _ = v7 - tmp8 := checkDerefVar(glojure_DOT_core_reduce1) - tmp9 := checkDerefVar(glojure_DOT_core___U0027_) - tmp10 := checkDerefVar(glojure_DOT_core___U0027_) + tmp8 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp9 := checkDerefVar(var_glojure_DOT_core__DASH__TICK_) + tmp10 := checkDerefVar(var_glojure_DOT_core__DASH__TICK_) tmp11 := lang.Apply(tmp10, []any{v5, v6}) tmp12 := lang.Apply(tmp8, []any{tmp9, tmp11, v7}) return tmp12 } }) - tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp4 = tmp4.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp3 := ns.InternWithValue(tmp0, tmp4, true) if tmp0.Meta() != nil { tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -3708,14 +4993,12 @@ func LoadNS() { } // -> { - tmp0 := lang.NewSymbol("->").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "Threads the expr through the forms. Inserts x as the\n second item in the first form, making a list of it if it is not a\n list already. If there are more forms, inserts the first form as the\n second item in second form, etc.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1675), lang.NewKeyword("end-line"), int(1675))).(*lang.Symbol) + tmp0 := sym__DASH__GT_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_x, sym__AMP_, sym_forms)), kw_doc, "Threads the expr through the forms. Inserts x as the\n second item in the first form, making a list of it if it is not a\n list already. If there are more forms, inserts the first form as the\n second item in second form, etc.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(11), kw_line, int(1675), kw_end_DASH_line, int(1675))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -3738,41 +5021,41 @@ func LoadNS() { var tmp11 any { // let // let binding "form" - tmp12 := checkDerefVar(glojure_DOT_core_first) + tmp12 := checkDerefVar(var_glojure_DOT_core_first) tmp13 := lang.Apply(tmp12, []any{v9}) var v14 any = tmp13 _ = v14 // let binding "threaded" var tmp15 any - tmp16 := checkDerefVar(glojure_DOT_core_seq_QMARK_) + tmp16 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) tmp17 := lang.Apply(tmp16, []any{v14}) if lang.IsTruthy(tmp17) { - tmp18 := checkDerefVar(glojure_DOT_core_with_meta) - tmp19 := checkDerefVar(glojure_DOT_core_seq) - tmp20 := checkDerefVar(glojure_DOT_core_concat) - tmp21 := checkDerefVar(glojure_DOT_core_list) - tmp22 := checkDerefVar(glojure_DOT_core_first) + tmp18 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp19 := checkDerefVar(var_glojure_DOT_core_seq) + tmp20 := checkDerefVar(var_glojure_DOT_core_concat) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := checkDerefVar(var_glojure_DOT_core_first) tmp23 := lang.Apply(tmp22, []any{v14}) tmp24 := lang.Apply(tmp21, []any{tmp23}) - tmp25 := checkDerefVar(glojure_DOT_core_list) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) tmp26 := lang.Apply(tmp25, []any{v8}) - tmp27 := checkDerefVar(glojure_DOT_core_next) + tmp27 := checkDerefVar(var_glojure_DOT_core_next) tmp28 := lang.Apply(tmp27, []any{v14}) tmp29 := lang.Apply(tmp20, []any{tmp24, tmp26, tmp28}) tmp30 := lang.Apply(tmp19, []any{tmp29}) - tmp31 := checkDerefVar(glojure_DOT_core_meta) + tmp31 := checkDerefVar(var_glojure_DOT_core_meta) tmp32 := lang.Apply(tmp31, []any{v14}) tmp33 := lang.Apply(tmp18, []any{tmp30, tmp32}) tmp15 = tmp33 } else { - tmp34 := checkDerefVar(glojure_DOT_core_list) + tmp34 := checkDerefVar(var_glojure_DOT_core_list) tmp35 := lang.Apply(tmp34, []any{v14, v8}) tmp15 = tmp35 } var v36 any = tmp15 _ = v36 var tmp37 any = v36 - tmp39 := checkDerefVar(glojure_DOT_core_next) + tmp39 := checkDerefVar(var_glojure_DOT_core_next) tmp40 := lang.Apply(tmp39, []any{v9}) var tmp38 any = tmp40 v8 = tmp37 @@ -3790,7 +5073,7 @@ func LoadNS() { return tmp7 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -3798,14 +5081,12 @@ func LoadNS() { } // ->> { - tmp0 := lang.NewSymbol("->>").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "Threads the expr through the forms. Inserts x as the\n last item in the first form, making a list of it if it is not a\n list already. If there are more forms, inserts the first form as the\n last item in second form, etc.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1691), lang.NewKeyword("end-line"), int(1691))).(*lang.Symbol) + tmp0 := sym__DASH__GT__GT_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_x, sym__AMP_, sym_forms)), kw_doc, "Threads the expr through the forms. Inserts x as the\n last item in the first form, making a list of it if it is not a\n list already. If there are more forms, inserts the first form as the\n last item in second form, etc.", kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(11), kw_line, int(1691), kw_end_DASH_line, int(1691))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -3828,41 +5109,41 @@ func LoadNS() { var tmp11 any { // let // let binding "form" - tmp12 := checkDerefVar(glojure_DOT_core_first) + tmp12 := checkDerefVar(var_glojure_DOT_core_first) tmp13 := lang.Apply(tmp12, []any{v9}) var v14 any = tmp13 _ = v14 // let binding "threaded" var tmp15 any - tmp16 := checkDerefVar(glojure_DOT_core_seq_QMARK_) + tmp16 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) tmp17 := lang.Apply(tmp16, []any{v14}) if lang.IsTruthy(tmp17) { - tmp18 := checkDerefVar(glojure_DOT_core_with_meta) - tmp19 := checkDerefVar(glojure_DOT_core_seq) - tmp20 := checkDerefVar(glojure_DOT_core_concat) - tmp21 := checkDerefVar(glojure_DOT_core_list) - tmp22 := checkDerefVar(glojure_DOT_core_first) + tmp18 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp19 := checkDerefVar(var_glojure_DOT_core_seq) + tmp20 := checkDerefVar(var_glojure_DOT_core_concat) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := checkDerefVar(var_glojure_DOT_core_first) tmp23 := lang.Apply(tmp22, []any{v14}) tmp24 := lang.Apply(tmp21, []any{tmp23}) - tmp25 := checkDerefVar(glojure_DOT_core_next) + tmp25 := checkDerefVar(var_glojure_DOT_core_next) tmp26 := lang.Apply(tmp25, []any{v14}) - tmp27 := checkDerefVar(glojure_DOT_core_list) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) tmp28 := lang.Apply(tmp27, []any{v8}) tmp29 := lang.Apply(tmp20, []any{tmp24, tmp26, tmp28}) tmp30 := lang.Apply(tmp19, []any{tmp29}) - tmp31 := checkDerefVar(glojure_DOT_core_meta) + tmp31 := checkDerefVar(var_glojure_DOT_core_meta) tmp32 := lang.Apply(tmp31, []any{v14}) tmp33 := lang.Apply(tmp18, []any{tmp30, tmp32}) tmp15 = tmp33 } else { - tmp34 := checkDerefVar(glojure_DOT_core_list) + tmp34 := checkDerefVar(var_glojure_DOT_core_list) tmp35 := lang.Apply(tmp34, []any{v14, v8}) tmp15 = tmp35 } var v36 any = tmp15 _ = v36 var tmp37 any = v36 - tmp39 := checkDerefVar(glojure_DOT_core_next) + tmp39 := checkDerefVar(var_glojure_DOT_core_next) tmp40 := lang.Apply(tmp39, []any{v9}) var tmp38 any = tmp40 v8 = tmp37 @@ -3880,7 +5161,7 @@ func LoadNS() { return tmp7 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -3888,37 +5169,33 @@ func LoadNS() { } // -protocols { - tmp0 := lang.NewSymbol("-protocols").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("doc"), "Private store of protocols. Go's reflection capabilities\n don't yet support a native interface-based implementation, so\n protocols are implemented in Glojure as maps from type to protocol\n method implementations.", lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(21), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(26), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym__DASH_protocols.WithMeta(lang.NewMap(kw_private, true, kw_doc, "Private store of protocols. Go's reflection capabilities\n don't yet support a native interface-based implementation, so\n protocols are implemented in Glojure as maps from type to protocol\n method implementations.", kw_file, "glojure/core_deftype.glj", kw_line, int(21), kw_column, int(3), kw_end_DASH_line, int(26), kw_end_DASH_column, int(12), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp5 lang.FnFunc tmp5 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v6 := args[0] _ = v6 var v7 any = lang.NewList(args[1:]...) _ = v7 - tmp8 := checkDerefVar(glojure_DOT_core_class) + tmp8 := checkDerefVar(var_glojure_DOT_core_class) tmp9 := lang.Apply(tmp8, []any{v6}) return tmp9 } }) - tmp4 := lang.NewMultiFn("coll-reduce", tmp5, lang.NewKeyword("default"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")).FindInternedVar(lang.NewSymbol("global-hierarchy"))) + tmp4 := lang.NewMultiFn("coll-reduce", tmp5, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) var tmp6 lang.FnFunc tmp6 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v7 := args[0] _ = v7 var v8 any = lang.NewList(args[1:]...) _ = v8 - tmp9 := checkDerefVar(glojure_DOT_core_apply) - tmp10 := checkDerefVar(glojure_DOT_core_cons) + tmp9 := checkDerefVar(var_glojure_DOT_core_apply) + tmp10 := checkDerefVar(var_glojure_DOT_core_cons) tmp11 := lang.Apply(tmp10, []any{v7, v8}) tmp12 := lang.Apply(tmp9, []any{closed9, tmp11}) return tmp12 @@ -3930,15 +5207,13 @@ func LoadNS() { tmp8 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v9 := args[0] _ = v9 var v10 any = lang.NewList(args[1:]...) _ = v10 - tmp11 := checkDerefVar(glojure_DOT_core_apply) - tmp12 := checkDerefVar(glojure_DOT_core_cons) + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + tmp12 := checkDerefVar(var_glojure_DOT_core_cons) tmp13 := lang.Apply(tmp12, []any{v9, v10}) tmp14 := lang.Apply(tmp11, []any{closed10, tmp13}) return tmp14 @@ -3950,15 +5225,13 @@ func LoadNS() { tmp10 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v11 := args[0] _ = v11 var v12 any = lang.NewList(args[1:]...) _ = v12 - tmp13 := checkDerefVar(glojure_DOT_core_apply) - tmp14 := checkDerefVar(glojure_DOT_core_cons) + tmp13 := checkDerefVar(var_glojure_DOT_core_apply) + tmp14 := checkDerefVar(var_glojure_DOT_core_cons) tmp15 := lang.Apply(tmp14, []any{v11, v12}) tmp16 := lang.Apply(tmp13, []any{closed11, tmp15}) return tmp16 @@ -3970,52 +5243,46 @@ func LoadNS() { tmp12 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v13 := args[0] _ = v13 var v14 any = lang.NewList(args[1:]...) _ = v14 - tmp15 := checkDerefVar(glojure_DOT_core_apply) - tmp16 := checkDerefVar(glojure_DOT_core_cons) + tmp15 := checkDerefVar(var_glojure_DOT_core_apply) + tmp16 := checkDerefVar(var_glojure_DOT_core_cons) tmp17 := lang.Apply(tmp16, []any{v13, v14}) tmp18 := lang.Apply(tmp15, []any{closed12, tmp17}) return tmp18 } }) tmp4.AddMethod(tmp11, tmp12) - tmp3 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("coll-reduce"), tmp4), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("coll-reduce"), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("f"), lang.NewSymbol("val")))))) + tmp3 := lang.NewAtom(lang.NewMap(kw_multis, lang.NewMap(kw_coll_DASH_reduce, tmp4), kw_on_DASH_interface, true, kw_sigs, lang.NewList(lang.NewList(sym_coll_DASH_reduce, lang.NewVector(sym_coll, sym_f), lang.NewVector(sym_coll, sym_f, sym_val))))) var tmp15 lang.FnFunc tmp15 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v16 := args[0] _ = v16 var v17 any = lang.NewList(args[1:]...) _ = v17 - tmp18 := checkDerefVar(glojure_DOT_core_class) + tmp18 := checkDerefVar(var_glojure_DOT_core_class) tmp19 := lang.Apply(tmp18, []any{v16}) return tmp19 } }) - tmp14 := lang.NewMultiFn("internal-reduce", tmp15, lang.NewKeyword("default"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")).FindInternedVar(lang.NewSymbol("global-hierarchy"))) + tmp14 := lang.NewMultiFn("internal-reduce", tmp15, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) var tmp16 lang.FnFunc tmp16 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v17 := args[0] _ = v17 var v18 any = lang.NewList(args[1:]...) _ = v18 - tmp19 := checkDerefVar(glojure_DOT_core_apply) - tmp20 := checkDerefVar(glojure_DOT_core_cons) + tmp19 := checkDerefVar(var_glojure_DOT_core_apply) + tmp20 := checkDerefVar(var_glojure_DOT_core_cons) tmp21 := lang.Apply(tmp20, []any{v17, v18}) tmp22 := lang.Apply(tmp19, []any{closed13, tmp21}) return tmp22 @@ -4027,15 +5294,13 @@ func LoadNS() { tmp18 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v19 := args[0] _ = v19 var v20 any = lang.NewList(args[1:]...) _ = v20 - tmp21 := checkDerefVar(glojure_DOT_core_apply) - tmp22 := checkDerefVar(glojure_DOT_core_cons) + tmp21 := checkDerefVar(var_glojure_DOT_core_apply) + tmp22 := checkDerefVar(var_glojure_DOT_core_cons) tmp23 := lang.Apply(tmp22, []any{v19, v20}) tmp24 := lang.Apply(tmp21, []any{closed14, tmp23}) return tmp24 @@ -4047,126 +5312,112 @@ func LoadNS() { tmp20 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v21 := args[0] _ = v21 var v22 any = lang.NewList(args[1:]...) _ = v22 - tmp23 := checkDerefVar(glojure_DOT_core_apply) - tmp24 := checkDerefVar(glojure_DOT_core_cons) + tmp23 := checkDerefVar(var_glojure_DOT_core_apply) + tmp24 := checkDerefVar(var_glojure_DOT_core_cons) tmp25 := lang.Apply(tmp24, []any{v21, v22}) tmp26 := lang.Apply(tmp23, []any{closed15, tmp25}) return tmp26 } }) tmp14.AddMethod(tmp19, tmp20) - tmp13 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("internal-reduce"), tmp14), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("internal-reduce"), lang.NewVector(lang.NewSymbol("seq"), lang.NewSymbol("f"), lang.NewSymbol("start")))))) + tmp13 := lang.NewAtom(lang.NewMap(kw_multis, lang.NewMap(kw_internal_DASH_reduce, tmp14), kw_on_DASH_interface, true, kw_sigs, lang.NewList(lang.NewList(sym_internal_DASH_reduce, lang.NewVector(sym_seq, sym_f, sym_start))))) var tmp23 lang.FnFunc tmp23 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v24 := args[0] _ = v24 var v25 any = lang.NewList(args[1:]...) _ = v25 - tmp26 := checkDerefVar(glojure_DOT_core_class) + tmp26 := checkDerefVar(var_glojure_DOT_core_class) tmp27 := lang.Apply(tmp26, []any{v24}) return tmp27 } }) - tmp22 := lang.NewMultiFn("kv-reduce", tmp23, lang.NewKeyword("default"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")).FindInternedVar(lang.NewSymbol("global-hierarchy"))) - tmp21 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("kv-reduce"), tmp22), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("kv-reduce"), lang.NewVector(lang.NewSymbol("amap"), lang.NewSymbol("f"), lang.NewSymbol("init")))))) + tmp22 := lang.NewMultiFn("kv-reduce", tmp23, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) + tmp21 := lang.NewAtom(lang.NewMap(kw_multis, lang.NewMap(kw_kv_DASH_reduce, tmp22), kw_on_DASH_interface, true, kw_sigs, lang.NewList(lang.NewList(sym_kv_DASH_reduce, lang.NewVector(sym_amap, sym_f, sym_init))))) var tmp26 lang.FnFunc tmp26 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v27 := args[0] _ = v27 var v28 any = lang.NewList(args[1:]...) _ = v28 - tmp29 := checkDerefVar(glojure_DOT_core_class) + tmp29 := checkDerefVar(var_glojure_DOT_core_class) tmp30 := lang.Apply(tmp29, []any{v27}) return tmp30 } }) - tmp25 := lang.NewMultiFn("datafy", tmp26, lang.NewKeyword("default"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")).FindInternedVar(lang.NewSymbol("global-hierarchy"))) + tmp25 := lang.NewMultiFn("datafy", tmp26, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) var tmp27 lang.FnFunc tmp27 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v28 := args[0] _ = v28 var v29 any = lang.NewList(args[1:]...) _ = v29 - tmp30 := checkDerefVar(glojure_DOT_core_apply) - tmp31 := checkDerefVar(glojure_DOT_core_cons) + tmp30 := checkDerefVar(var_glojure_DOT_core_apply) + tmp31 := checkDerefVar(var_glojure_DOT_core_cons) tmp32 := lang.Apply(tmp31, []any{v28, v29}) tmp33 := lang.Apply(tmp30, []any{closed16, tmp32}) return tmp33 } }) tmp25.AddMethod(nil, tmp27) - tmp24 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("datafy"), tmp25), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("datafy"), lang.NewVector(lang.NewSymbol("o")), "return a representation of o as data (default identity)")))) + tmp24 := lang.NewAtom(lang.NewMap(kw_multis, lang.NewMap(kw_datafy, tmp25), kw_on_DASH_interface, true, kw_sigs, lang.NewList(lang.NewList(sym_datafy, lang.NewVector(sym_o), "return a representation of o as data (default identity)")))) var tmp30 lang.FnFunc tmp30 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v31 := args[0] _ = v31 var v32 any = lang.NewList(args[1:]...) _ = v32 - tmp33 := checkDerefVar(glojure_DOT_core_class) + tmp33 := checkDerefVar(var_glojure_DOT_core_class) tmp34 := lang.Apply(tmp33, []any{v31}) return tmp34 } }) - tmp29 := lang.NewMultiFn("nav", tmp30, lang.NewKeyword("default"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")).FindInternedVar(lang.NewSymbol("global-hierarchy"))) - tmp28 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("nav"), tmp29), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("nav"), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("k"), lang.NewSymbol("v")), "return (possibly transformed) v in the context of coll and k (a key/index or nil),\ndefaults to returning v.")))) + tmp29 := lang.NewMultiFn("nav", tmp30, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) + tmp28 := lang.NewAtom(lang.NewMap(kw_multis, lang.NewMap(kw_nav, tmp29), kw_on_DASH_interface, true, kw_sigs, lang.NewList(lang.NewList(sym_nav, lang.NewVector(sym_coll, sym_k, sym_v), "return (possibly transformed) v in the context of coll and k (a key/index or nil),\ndefaults to returning v.")))) var tmp33 lang.FnFunc tmp33 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v34 := args[0] _ = v34 var v35 any = lang.NewList(args[1:]...) _ = v35 - tmp36 := checkDerefVar(glojure_DOT_core_class) + tmp36 := checkDerefVar(var_glojure_DOT_core_class) tmp37 := lang.Apply(tmp36, []any{v34}) return tmp37 } }) - tmp32 := lang.NewMultiFn("make-reader", tmp33, lang.NewKeyword("default"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")).FindInternedVar(lang.NewSymbol("global-hierarchy"))) + tmp32 := lang.NewMultiFn("make-reader", tmp33, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) tmp34 := reflect.TypeOf((*io3.Reader)(nil)).Elem() var tmp35 lang.FnFunc tmp35 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v36 := args[0] _ = v36 var v37 any = lang.NewList(args[1:]...) _ = v37 - tmp38 := checkDerefVar(glojure_DOT_core_apply) - tmp39 := checkDerefVar(glojure_DOT_core_cons) + tmp38 := checkDerefVar(var_glojure_DOT_core_apply) + tmp39 := checkDerefVar(var_glojure_DOT_core_cons) tmp40 := lang.Apply(tmp39, []any{v36, v37}) tmp41 := lang.Apply(tmp38, []any{closed17, tmp40}) return tmp41 @@ -4178,15 +5429,13 @@ func LoadNS() { tmp37 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v38 := args[0] _ = v38 var v39 any = lang.NewList(args[1:]...) _ = v39 - tmp40 := checkDerefVar(glojure_DOT_core_apply) - tmp41 := checkDerefVar(glojure_DOT_core_cons) + tmp40 := checkDerefVar(var_glojure_DOT_core_apply) + tmp41 := checkDerefVar(var_glojure_DOT_core_cons) tmp42 := lang.Apply(tmp41, []any{v38, v39}) tmp43 := lang.Apply(tmp40, []any{closed18, tmp42}) return tmp43 @@ -4198,15 +5447,13 @@ func LoadNS() { tmp39 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v40 := args[0] _ = v40 var v41 any = lang.NewList(args[1:]...) _ = v41 - tmp42 := checkDerefVar(glojure_DOT_core_apply) - tmp43 := checkDerefVar(glojure_DOT_core_cons) + tmp42 := checkDerefVar(var_glojure_DOT_core_apply) + tmp43 := checkDerefVar(var_glojure_DOT_core_cons) tmp44 := lang.Apply(tmp43, []any{v40, v41}) tmp45 := lang.Apply(tmp42, []any{closed18, tmp44}) return tmp45 @@ -4217,33 +5464,29 @@ func LoadNS() { tmp41 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v42 := args[0] _ = v42 var v43 any = lang.NewList(args[1:]...) _ = v43 - tmp44 := checkDerefVar(glojure_DOT_core_class) + tmp44 := checkDerefVar(var_glojure_DOT_core_class) tmp45 := lang.Apply(tmp44, []any{v42}) return tmp45 } }) - tmp40 := lang.NewMultiFn("make-writer", tmp41, lang.NewKeyword("default"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")).FindInternedVar(lang.NewSymbol("global-hierarchy"))) + tmp40 := lang.NewMultiFn("make-writer", tmp41, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) tmp42 := reflect.TypeOf((*io3.Reader)(nil)).Elem() var tmp43 lang.FnFunc tmp43 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v44 := args[0] _ = v44 var v45 any = lang.NewList(args[1:]...) _ = v45 - tmp46 := checkDerefVar(glojure_DOT_core_apply) - tmp47 := checkDerefVar(glojure_DOT_core_cons) + tmp46 := checkDerefVar(var_glojure_DOT_core_apply) + tmp47 := checkDerefVar(var_glojure_DOT_core_cons) tmp48 := lang.Apply(tmp47, []any{v44, v45}) tmp49 := lang.Apply(tmp46, []any{closed19, tmp48}) return tmp49 @@ -4255,15 +5498,13 @@ func LoadNS() { tmp45 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v46 := args[0] _ = v46 var v47 any = lang.NewList(args[1:]...) _ = v47 - tmp48 := checkDerefVar(glojure_DOT_core_apply) - tmp49 := checkDerefVar(glojure_DOT_core_cons) + tmp48 := checkDerefVar(var_glojure_DOT_core_apply) + tmp49 := checkDerefVar(var_glojure_DOT_core_cons) tmp50 := lang.Apply(tmp49, []any{v46, v47}) tmp51 := lang.Apply(tmp48, []any{closed19, tmp50}) return tmp51 @@ -4275,15 +5516,13 @@ func LoadNS() { tmp47 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v48 := args[0] _ = v48 var v49 any = lang.NewList(args[1:]...) _ = v49 - tmp50 := checkDerefVar(glojure_DOT_core_apply) - tmp51 := checkDerefVar(glojure_DOT_core_cons) + tmp50 := checkDerefVar(var_glojure_DOT_core_apply) + tmp51 := checkDerefVar(var_glojure_DOT_core_cons) tmp52 := lang.Apply(tmp51, []any{v48, v49}) tmp53 := lang.Apply(tmp50, []any{closed19, tmp52}) return tmp53 @@ -4294,33 +5533,29 @@ func LoadNS() { tmp49 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v50 := args[0] _ = v50 var v51 any = lang.NewList(args[1:]...) _ = v51 - tmp52 := checkDerefVar(glojure_DOT_core_class) + tmp52 := checkDerefVar(var_glojure_DOT_core_class) tmp53 := lang.Apply(tmp52, []any{v50}) return tmp53 } }) - tmp48 := lang.NewMultiFn("make-input-stream", tmp49, lang.NewKeyword("default"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")).FindInternedVar(lang.NewSymbol("global-hierarchy"))) + tmp48 := lang.NewMultiFn("make-input-stream", tmp49, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) tmp50 := reflect.TypeOf((*io3.Reader)(nil)).Elem() var tmp51 lang.FnFunc tmp51 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v52 := args[0] _ = v52 var v53 any = lang.NewList(args[1:]...) _ = v53 - tmp54 := checkDerefVar(glojure_DOT_core_apply) - tmp55 := checkDerefVar(glojure_DOT_core_cons) + tmp54 := checkDerefVar(var_glojure_DOT_core_apply) + tmp55 := checkDerefVar(var_glojure_DOT_core_cons) tmp56 := lang.Apply(tmp55, []any{v52, v53}) tmp57 := lang.Apply(tmp54, []any{closed20, tmp56}) return tmp57 @@ -4332,15 +5567,13 @@ func LoadNS() { tmp53 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v54 := args[0] _ = v54 var v55 any = lang.NewList(args[1:]...) _ = v55 - tmp56 := checkDerefVar(glojure_DOT_core_apply) - tmp57 := checkDerefVar(glojure_DOT_core_cons) + tmp56 := checkDerefVar(var_glojure_DOT_core_apply) + tmp57 := checkDerefVar(var_glojure_DOT_core_cons) tmp58 := lang.Apply(tmp57, []any{v54, v55}) tmp59 := lang.Apply(tmp56, []any{closed21, tmp58}) return tmp59 @@ -4352,15 +5585,13 @@ func LoadNS() { tmp55 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v56 := args[0] _ = v56 var v57 any = lang.NewList(args[1:]...) _ = v57 - tmp58 := checkDerefVar(glojure_DOT_core_apply) - tmp59 := checkDerefVar(glojure_DOT_core_cons) + tmp58 := checkDerefVar(var_glojure_DOT_core_apply) + tmp59 := checkDerefVar(var_glojure_DOT_core_cons) tmp60 := lang.Apply(tmp59, []any{v56, v57}) tmp61 := lang.Apply(tmp58, []any{closed22, tmp60}) return tmp61 @@ -4372,15 +5603,13 @@ func LoadNS() { tmp57 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v58 := args[0] _ = v58 var v59 any = lang.NewList(args[1:]...) _ = v59 - tmp60 := checkDerefVar(glojure_DOT_core_apply) - tmp61 := checkDerefVar(glojure_DOT_core_cons) + tmp60 := checkDerefVar(var_glojure_DOT_core_apply) + tmp61 := checkDerefVar(var_glojure_DOT_core_cons) tmp62 := lang.Apply(tmp61, []any{v58, v59}) tmp63 := lang.Apply(tmp60, []any{closed23, tmp62}) return tmp63 @@ -4391,33 +5620,29 @@ func LoadNS() { tmp59 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v60 := args[0] _ = v60 var v61 any = lang.NewList(args[1:]...) _ = v61 - tmp62 := checkDerefVar(glojure_DOT_core_class) + tmp62 := checkDerefVar(var_glojure_DOT_core_class) tmp63 := lang.Apply(tmp62, []any{v60}) return tmp63 } }) - tmp58 := lang.NewMultiFn("make-output-stream", tmp59, lang.NewKeyword("default"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")).FindInternedVar(lang.NewSymbol("global-hierarchy"))) + tmp58 := lang.NewMultiFn("make-output-stream", tmp59, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) tmp60 := reflect.TypeOf((*io3.Reader)(nil)).Elem() var tmp61 lang.FnFunc tmp61 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v62 := args[0] _ = v62 var v63 any = lang.NewList(args[1:]...) _ = v63 - tmp64 := checkDerefVar(glojure_DOT_core_apply) - tmp65 := checkDerefVar(glojure_DOT_core_cons) + tmp64 := checkDerefVar(var_glojure_DOT_core_apply) + tmp65 := checkDerefVar(var_glojure_DOT_core_cons) tmp66 := lang.Apply(tmp65, []any{v62, v63}) tmp67 := lang.Apply(tmp64, []any{closed24, tmp66}) return tmp67 @@ -4429,15 +5654,13 @@ func LoadNS() { tmp63 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v64 := args[0] _ = v64 var v65 any = lang.NewList(args[1:]...) _ = v65 - tmp66 := checkDerefVar(glojure_DOT_core_apply) - tmp67 := checkDerefVar(glojure_DOT_core_cons) + tmp66 := checkDerefVar(var_glojure_DOT_core_apply) + tmp67 := checkDerefVar(var_glojure_DOT_core_cons) tmp68 := lang.Apply(tmp67, []any{v64, v65}) tmp69 := lang.Apply(tmp66, []any{closed25, tmp68}) return tmp69 @@ -4449,15 +5672,13 @@ func LoadNS() { tmp65 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v66 := args[0] _ = v66 var v67 any = lang.NewList(args[1:]...) _ = v67 - tmp68 := checkDerefVar(glojure_DOT_core_apply) - tmp69 := checkDerefVar(glojure_DOT_core_cons) + tmp68 := checkDerefVar(var_glojure_DOT_core_apply) + tmp69 := checkDerefVar(var_glojure_DOT_core_cons) tmp70 := lang.Apply(tmp69, []any{v66, v67}) tmp71 := lang.Apply(tmp68, []any{closed26, tmp70}) return tmp71 @@ -4469,23 +5690,21 @@ func LoadNS() { tmp67 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v68 := args[0] _ = v68 var v69 any = lang.NewList(args[1:]...) _ = v69 - tmp70 := checkDerefVar(glojure_DOT_core_apply) - tmp71 := checkDerefVar(glojure_DOT_core_cons) + tmp70 := checkDerefVar(var_glojure_DOT_core_apply) + tmp71 := checkDerefVar(var_glojure_DOT_core_cons) tmp72 := lang.Apply(tmp71, []any{v68, v69}) tmp73 := lang.Apply(tmp70, []any{closed27, tmp72}) return tmp73 } }) tmp58.AddMethod(tmp66, tmp67) - tmp31 := lang.NewAtom(lang.NewMap(lang.NewKeyword("multis"), lang.NewMap(lang.NewKeyword("make-reader"), tmp32, lang.NewKeyword("make-writer"), tmp40, lang.NewKeyword("make-input-stream"), tmp48, lang.NewKeyword("make-output-stream"), tmp58), lang.NewKeyword("on-interface"), true, lang.NewKeyword("sigs"), lang.NewList(lang.NewList(lang.NewSymbol("make-reader"), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("opts")), "Creates an io.Reader. See also IOFactory docs."), lang.NewList(lang.NewSymbol("make-writer"), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("opts")), "Creates an io.Reader. See also IOFactory docs."), lang.NewList(lang.NewSymbol("make-input-stream"), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("opts")), "Creates a BufferedInputStream. See also IOFactory docs."), lang.NewList(lang.NewSymbol("make-output-stream"), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("opts")), "Creates a BufferedOutputStream. See also IOFactory docs.")))) - tmp2 := lang.NewAtom(lang.NewMap(lang.NewSymbol("CollReduce"), tmp3, lang.NewSymbol("InternalReduce"), tmp13, lang.NewSymbol("IKVReduce"), tmp21, lang.NewSymbol("Datafiable"), tmp24, lang.NewSymbol("Navigable"), tmp28, lang.NewSymbol("IOFactory"), tmp31)) + tmp31 := lang.NewAtom(lang.NewMap(kw_multis, lang.NewMap(kw_make_DASH_reader, tmp32, kw_make_DASH_writer, tmp40, kw_make_DASH_input_DASH_stream, tmp48, kw_make_DASH_output_DASH_stream, tmp58), kw_on_DASH_interface, true, kw_sigs, lang.NewList(lang.NewList(sym_make_DASH_reader, lang.NewVector(sym_x, sym_opts), "Creates an io.Reader. See also IOFactory docs."), lang.NewList(sym_make_DASH_writer, lang.NewVector(sym_x, sym_opts), "Creates an io.Reader. See also IOFactory docs."), lang.NewList(sym_make_DASH_input_DASH_stream, lang.NewVector(sym_x, sym_opts), "Creates a BufferedInputStream. See also IOFactory docs."), lang.NewList(sym_make_DASH_output_DASH_stream, lang.NewVector(sym_x, sym_opts), "Creates a BufferedOutputStream. See also IOFactory docs.")))) + tmp2 := lang.NewAtom(lang.NewMap(sym_CollReduce, tmp3, sym_InternalReduce, tmp13, sym_IKVReduce, tmp21, sym_Datafiable, tmp24, sym_Navigable, tmp28, sym_IOFactory, tmp31)) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -4493,7 +5712,7 @@ func LoadNS() { } // .. { - tmp0 := lang.NewSymbol("..").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("form")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("form"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "form => fieldName-symbol or (instanceMethodName-symbol args*)\n\n Expands into a member access (.) of the first member on the first\n argument, followed by the next member on the result, etc. For\n instance:\n\n (.. System (getProperties) (get \"os.name\"))\n\n expands to:\n\n (. (. System (getProperties)) (get \"os.name\"))\n\n but is easier to write, read, and understand.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1657), lang.NewKeyword("end-line"), int(1657))).(*lang.Symbol) + tmp0 := sym__DOT__DOT_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_form), lang.NewVector(sym_x, sym_form, sym__AMP_, sym_more)), kw_doc, "form => fieldName-symbol or (instanceMethodName-symbol args*)\n\n Expands into a member access (.) of the first member on the first\n argument, followed by the next member on the result, etc. For\n instance:\n\n (.. System (getProperties) (get \"os.name\"))\n\n expands to:\n\n (. (. System (getProperties)) (get \"os.name\"))\n\n but is easier to write, read, and understand.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(11), kw_line, int(1657), kw_end_DASH_line, int(1657))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -4506,21 +5725,19 @@ func LoadNS() { _ = v5 v6 := args[3] _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_seq) - tmp8 := checkDerefVar(glojure_DOT_core_concat) - tmp9 := checkDerefVar(glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol(".")}) - tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) tmp12 := lang.Apply(tmp11, []any{v5}) - tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) tmp14 := lang.Apply(tmp13, []any{v6}) tmp15 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp14}) tmp16 := lang.Apply(tmp7, []any{tmp15}) return tmp16 default: - if len(args) < 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 4) v3 := args[0] _ = v3 v4 := args[1] @@ -4531,18 +5748,18 @@ func LoadNS() { _ = v6 var v7 any = lang.NewList(args[4:]...) _ = v7 - tmp8 := checkDerefVar(glojure_DOT_core_seq) - tmp9 := checkDerefVar(glojure_DOT_core_concat) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol("..")}) - tmp12 := checkDerefVar(glojure_DOT_core_list) - tmp13 := checkDerefVar(glojure_DOT_core_seq) - tmp14 := checkDerefVar(glojure_DOT_core_concat) - tmp15 := checkDerefVar(glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) - tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) tmp18 := lang.Apply(tmp17, []any{v5}) - tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) tmp20 := lang.Apply(tmp19, []any{v6}) tmp21 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp20}) tmp22 := lang.Apply(tmp13, []any{tmp21}) @@ -4552,7 +5769,7 @@ func LoadNS() { return tmp25 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -4570,7 +5787,7 @@ func LoadNS() { { // let // let binding "op" var tmp4 any - tmp5 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp5) { tmp4 = closed28 } else { @@ -4578,18 +5795,18 @@ func LoadNS() { } var v6 any = tmp4 _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_seq) - tmp8 := checkDerefVar(glojure_DOT_core_concat) - tmp9 := checkDerefVar(glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol(".")}) - tmp11 := checkDerefVar(glojure_DOT_core_list) - tmp12 := lang.Apply(tmp11, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp13 := checkDerefVar(glojure_DOT_core_list) - tmp14 := checkDerefVar(glojure_DOT_core_seq) - tmp15 := checkDerefVar(glojure_DOT_core_concat) - tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v6}) - tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) tmp19 := lang.Apply(tmp18, []any{v2}) tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) tmp21 := lang.Apply(tmp14, []any{tmp20}) @@ -4608,7 +5825,7 @@ func LoadNS() { { // let // let binding "op" var tmp5 any - tmp6 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp6) { tmp5 = closed28 } else { @@ -4616,20 +5833,20 @@ func LoadNS() { } var v7 any = tmp5 _ = v7 - tmp8 := checkDerefVar(glojure_DOT_core_seq) - tmp9 := checkDerefVar(glojure_DOT_core_concat) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol(".")}) - tmp12 := checkDerefVar(glojure_DOT_core_list) - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp14 := checkDerefVar(glojure_DOT_core_list) - tmp15 := checkDerefVar(glojure_DOT_core_seq) - tmp16 := checkDerefVar(glojure_DOT_core_concat) - tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) tmp18 := lang.Apply(tmp17, []any{v7}) - tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) tmp20 := lang.Apply(tmp19, []any{v2}) - tmp21 := checkDerefVar(glojure_DOT_core_list) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) tmp22 := lang.Apply(tmp21, []any{v3}) tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) tmp24 := lang.Apply(tmp15, []any{tmp23}) @@ -4640,9 +5857,7 @@ func LoadNS() { } // end let return tmp4 default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -4653,7 +5868,7 @@ func LoadNS() { { // let // let binding "op" var tmp6 any - tmp7 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp7) { tmp6 = closed28 } else { @@ -4661,30 +5876,28 @@ func LoadNS() { } var v8 any = tmp6 _ = v8 - tmp9 := checkDerefVar(glojure_DOT_core_reduce1) + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) var tmp10 lang.FnFunc tmp10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v11 := args[0] _ = v11 v12 := args[1] _ = v12 - tmp13 := checkDerefVar(glojure_DOT_core_seq) - tmp14 := checkDerefVar(glojure_DOT_core_concat) - tmp15 := checkDerefVar(glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) - tmp17 := checkDerefVar(glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp19 := checkDerefVar(glojure_DOT_core_list) - tmp20 := checkDerefVar(glojure_DOT_core_seq) - tmp21 := checkDerefVar(glojure_DOT_core_concat) - tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) tmp23 := lang.Apply(tmp22, []any{v8}) - tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) tmp25 := lang.Apply(tmp24, []any{v11}) - tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) tmp27 := lang.Apply(tmp26, []any{v12}) tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) tmp29 := lang.Apply(tmp20, []any{tmp28}) @@ -4693,25 +5906,25 @@ func LoadNS() { tmp32 := lang.Apply(tmp13, []any{tmp31}) return tmp32 }) - tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp13 := checkDerefVar(glojure_DOT_core_seq) - tmp14 := checkDerefVar(glojure_DOT_core_concat) - tmp15 := checkDerefVar(glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) - tmp17 := checkDerefVar(glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp19 := checkDerefVar(glojure_DOT_core_list) - tmp20 := checkDerefVar(glojure_DOT_core_seq) - tmp21 := checkDerefVar(glojure_DOT_core_concat) - tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) tmp23 := lang.Apply(tmp22, []any{v8}) - tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) tmp25 := lang.Apply(tmp24, []any{v2}) - tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) tmp27 := lang.Apply(tmp26, []any{v3}) tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) tmp29 := lang.Apply(tmp20, []any{tmp28}) @@ -4724,12 +5937,10 @@ func LoadNS() { return tmp5 } }) - tmp1 = tmp1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") @@ -4739,15 +5950,15 @@ func LoadNS() { tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp0 := lang.NewSymbol("/").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "If no denominators are supplied, returns 1/numerator,\n else returns numerator divided by all of the denominators.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), tmp2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1013), lang.NewKeyword("end-line"), int(1013))).(*lang.Symbol) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym__SLASH_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "If no denominators are supplied, returns 1/numerator,\n else returns numerator divided by all of the denominators.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(7), kw_line, int(1013), kw_end_DASH_line, int(1013))).(*lang.Symbol) var tmp4 lang.FnFunc tmp4 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v5 := args[0] _ = v5 - tmp6 := checkDerefVar(glojure_DOT_core__SLASH_) + tmp6 := checkDerefVar(var_glojure_DOT_core__SLASH_) tmp7 := lang.Apply(tmp6, []any{int64(1), v5}) return tmp7 case 2: @@ -4762,24 +5973,22 @@ func LoadNS() { tmp8 := lang.Apply(tmp7, []any{v5, v6}) return tmp8 default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v5 := args[0] _ = v5 v6 := args[1] _ = v6 var v7 any = lang.NewList(args[2:]...) _ = v7 - tmp8 := checkDerefVar(glojure_DOT_core_reduce1) - tmp9 := checkDerefVar(glojure_DOT_core__SLASH_) - tmp10 := checkDerefVar(glojure_DOT_core__SLASH_) + tmp8 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp9 := checkDerefVar(var_glojure_DOT_core__SLASH_) + tmp10 := checkDerefVar(var_glojure_DOT_core__SLASH_) tmp11 := lang.Apply(tmp10, []any{v5, v6}) tmp12 := lang.Apply(tmp8, []any{tmp9, tmp11, v7}) return tmp12 } }) - tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp4 = tmp4.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp3 := ns.InternWithValue(tmp0, tmp4, true) if tmp0.Meta() != nil { tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -4791,27 +6000,25 @@ func LoadNS() { { // function <__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_seq) - tmp6 := checkDerefVar(glojure_DOT_core_concat) - tmp7 := checkDerefVar(glojure_DOT_core_list) - tmp8 := lang.Apply(tmp7, []any{lang.NewSymbol(".")}) - tmp9 := checkDerefVar(glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp11 := checkDerefVar(glojure_DOT_core_list) - tmp12 := checkDerefVar(glojure_DOT_core_seq) - tmp13 := checkDerefVar(glojure_DOT_core_concat) - tmp14 := checkDerefVar(glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("glojure.core/Lt")}) - tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Lt}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) - tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) tmp19 := lang.Apply(tmp18, []any{v4}) tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) tmp21 := lang.Apply(tmp12, []any{tmp20}) @@ -4823,7 +6030,7 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("<").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns non-nil if nums are in monotonically increasing order,\n otherwise false.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(893), lang.NewKeyword("end-line"), int(893))).(*lang.Symbol) + tmp0 := sym__LT_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns non-nil if nums are in monotonically increasing order,\n otherwise false.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(7), kw_line, int(893), kw_end_DASH_line, int(893))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -4843,9 +6050,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -4854,18 +6059,18 @@ func LoadNS() { _ = v6 recur_loop_150: var tmp7 any - tmp8 := checkDerefVar(glojure_DOT_core__LT_) + tmp8 := checkDerefVar(var_glojure_DOT_core__LT_) tmp9 := lang.Apply(tmp8, []any{v4, v5}) if lang.IsTruthy(tmp9) { var tmp10 any - tmp11 := checkDerefVar(glojure_DOT_core_next) + tmp11 := checkDerefVar(var_glojure_DOT_core_next) tmp12 := lang.Apply(tmp11, []any{v6}) if lang.IsTruthy(tmp12) { var tmp13 any = v5 - tmp15 := checkDerefVar(glojure_DOT_core_first) + tmp15 := checkDerefVar(var_glojure_DOT_core_first) tmp16 := lang.Apply(tmp15, []any{v6}) var tmp14 any = tmp16 - tmp18 := checkDerefVar(glojure_DOT_core_next) + tmp18 := checkDerefVar(var_glojure_DOT_core_next) tmp19 := lang.Apply(tmp18, []any{v6}) var tmp17 any = tmp19 v4 = tmp13 @@ -4873,8 +6078,8 @@ func LoadNS() { v6 = tmp17 goto recur_loop_150 } else { - tmp20 := checkDerefVar(glojure_DOT_core__LT_) - tmp21 := checkDerefVar(glojure_DOT_core_first) + tmp20 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp21 := checkDerefVar(var_glojure_DOT_core_first) tmp22 := lang.Apply(tmp21, []any{v6}) tmp23 := lang.Apply(tmp20, []any{v5, tmp22}) tmp10 = tmp23 @@ -4886,7 +6091,7 @@ func LoadNS() { return tmp7 } }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -4898,27 +6103,25 @@ func LoadNS() { { // function <=__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_seq) - tmp6 := checkDerefVar(glojure_DOT_core_concat) - tmp7 := checkDerefVar(glojure_DOT_core_list) - tmp8 := lang.Apply(tmp7, []any{lang.NewSymbol(".")}) - tmp9 := checkDerefVar(glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp11 := checkDerefVar(glojure_DOT_core_list) - tmp12 := checkDerefVar(glojure_DOT_core_seq) - tmp13 := checkDerefVar(glojure_DOT_core_concat) - tmp14 := checkDerefVar(glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("glojure.core/Lte")}) - tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Lte}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) - tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) tmp19 := lang.Apply(tmp18, []any{v4}) tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) tmp21 := lang.Apply(tmp12, []any{tmp20}) @@ -4930,7 +6133,7 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("<=").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns non-nil if nums are in monotonically non-decreasing order,\n otherwise false.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1048), lang.NewKeyword("end-line"), int(1048))).(*lang.Symbol) + tmp0 := sym__LT__EQ_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns non-nil if nums are in monotonically non-decreasing order,\n otherwise false.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(7), kw_line, int(1048), kw_end_DASH_line, int(1048))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -4950,9 +6153,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -4961,18 +6162,18 @@ func LoadNS() { _ = v6 recur_loop_194: var tmp7 any - tmp8 := checkDerefVar(glojure_DOT_core__LT__EQ_) + tmp8 := checkDerefVar(var_glojure_DOT_core__LT__EQ_) tmp9 := lang.Apply(tmp8, []any{v4, v5}) if lang.IsTruthy(tmp9) { var tmp10 any - tmp11 := checkDerefVar(glojure_DOT_core_next) + tmp11 := checkDerefVar(var_glojure_DOT_core_next) tmp12 := lang.Apply(tmp11, []any{v6}) if lang.IsTruthy(tmp12) { var tmp13 any = v5 - tmp15 := checkDerefVar(glojure_DOT_core_first) + tmp15 := checkDerefVar(var_glojure_DOT_core_first) tmp16 := lang.Apply(tmp15, []any{v6}) var tmp14 any = tmp16 - tmp18 := checkDerefVar(glojure_DOT_core_next) + tmp18 := checkDerefVar(var_glojure_DOT_core_next) tmp19 := lang.Apply(tmp18, []any{v6}) var tmp17 any = tmp19 v4 = tmp13 @@ -4980,8 +6181,8 @@ func LoadNS() { v6 = tmp17 goto recur_loop_194 } else { - tmp20 := checkDerefVar(glojure_DOT_core__LT__EQ_) - tmp21 := checkDerefVar(glojure_DOT_core_first) + tmp20 := checkDerefVar(var_glojure_DOT_core__LT__EQ_) + tmp21 := checkDerefVar(var_glojure_DOT_core_first) tmp22 := lang.Apply(tmp21, []any{v6}) tmp23 := lang.Apply(tmp20, []any{v5, tmp22}) tmp10 = tmp23 @@ -4993,7 +6194,7 @@ func LoadNS() { return tmp7 } }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -5005,24 +6206,22 @@ func LoadNS() { { // function =__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_seq) - tmp6 := checkDerefVar(glojure_DOT_core_concat) - tmp7 := checkDerefVar(glojure_DOT_core_list) - tmp8 := lang.Apply(tmp7, []any{lang.NewSymbol(".")}) - tmp9 := checkDerefVar(glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("glojure.lang.Util")}) - tmp11 := checkDerefVar(glojure_DOT_core_list) - tmp12 := lang.Apply(tmp11, []any{lang.NewSymbol("glojure.core/equiv")}) - tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_lang_DOT_Util}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_glojure_DOT_core_SLASH_equiv}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) tmp14 := lang.Apply(tmp13, []any{v3}) - tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v4}) tmp17 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp12, tmp14, tmp16}) tmp18 := lang.Apply(tmp5, []any{tmp17}) @@ -5031,7 +6230,7 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("=").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Equality. Returns true if x equals y, false if not. Same as\n Java x.equals(y) except it also works for nil, and compares\n numbers and collections in a type-independent manner. Clojure's immutable data\n structures define equals() (and thus =) as a value, not an identity,\n comparison.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(776), lang.NewKeyword("end-line"), int(776))).(*lang.Symbol) + tmp0 := sym__EQ_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Equality. Returns true if x equals y, false if not. Same as\n Java x.equals(y) except it also works for nil, and compares\n numbers and collections in a type-independent manner. Clojure's immutable data\n structures define equals() (and thus =) as a value, not an identity,\n comparison.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(7), kw_line, int(776), kw_end_DASH_line, int(776))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -5047,9 +6246,7 @@ func LoadNS() { tmp6 := lang.Apply(lang.Equiv, []any{v4, v5}) return tmp6 default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -5061,14 +6258,14 @@ func LoadNS() { tmp8 := lang.Apply(lang.Equiv, []any{v4, v5}) if lang.IsTruthy(tmp8) { var tmp9 any - tmp10 := checkDerefVar(glojure_DOT_core_next) + tmp10 := checkDerefVar(var_glojure_DOT_core_next) tmp11 := lang.Apply(tmp10, []any{v6}) if lang.IsTruthy(tmp11) { var tmp12 any = v5 - tmp14 := checkDerefVar(glojure_DOT_core_first) + tmp14 := checkDerefVar(var_glojure_DOT_core_first) tmp15 := lang.Apply(tmp14, []any{v6}) var tmp13 any = tmp15 - tmp17 := checkDerefVar(glojure_DOT_core_next) + tmp17 := checkDerefVar(var_glojure_DOT_core_next) tmp18 := lang.Apply(tmp17, []any{v6}) var tmp16 any = tmp18 v4 = tmp12 @@ -5076,7 +6273,7 @@ func LoadNS() { v6 = tmp16 goto recur_loop_126 } else { - tmp19 := checkDerefVar(glojure_DOT_core_first) + tmp19 := checkDerefVar(var_glojure_DOT_core_first) tmp20 := lang.Apply(tmp19, []any{v6}) tmp21 := lang.Apply(lang.Equiv, []any{v5, tmp20}) tmp9 = tmp21 @@ -5088,7 +6285,7 @@ func LoadNS() { return tmp7 } }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -5100,27 +6297,25 @@ func LoadNS() { { // function ==__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_seq) - tmp6 := checkDerefVar(glojure_DOT_core_concat) - tmp7 := checkDerefVar(glojure_DOT_core_list) - tmp8 := lang.Apply(tmp7, []any{lang.NewSymbol(".")}) - tmp9 := checkDerefVar(glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp11 := checkDerefVar(glojure_DOT_core_list) - tmp12 := checkDerefVar(glojure_DOT_core_seq) - tmp13 := checkDerefVar(glojure_DOT_core_concat) - tmp14 := checkDerefVar(glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("glojure.core/Equiv")}) - tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Equiv}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) - tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) tmp19 := lang.Apply(tmp18, []any{v4}) tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) tmp21 := lang.Apply(tmp12, []any{tmp20}) @@ -5132,7 +6327,7 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("==").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns non-nil if nums all have the equivalent\n value (type-independent), otherwise false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1093), lang.NewKeyword("end-line"), int(1093))).(*lang.Symbol) + tmp0 := sym__EQ__EQ_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns non-nil if nums all have the equivalent\n value (type-independent), otherwise false", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(7), kw_line, int(1093), kw_end_DASH_line, int(1093))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -5152,9 +6347,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -5163,18 +6356,18 @@ func LoadNS() { _ = v6 recur_loop_206: var tmp7 any - tmp8 := checkDerefVar(glojure_DOT_core__EQ__EQ_) + tmp8 := checkDerefVar(var_glojure_DOT_core__EQ__EQ_) tmp9 := lang.Apply(tmp8, []any{v4, v5}) if lang.IsTruthy(tmp9) { var tmp10 any - tmp11 := checkDerefVar(glojure_DOT_core_next) + tmp11 := checkDerefVar(var_glojure_DOT_core_next) tmp12 := lang.Apply(tmp11, []any{v6}) if lang.IsTruthy(tmp12) { var tmp13 any = v5 - tmp15 := checkDerefVar(glojure_DOT_core_first) + tmp15 := checkDerefVar(var_glojure_DOT_core_first) tmp16 := lang.Apply(tmp15, []any{v6}) var tmp14 any = tmp16 - tmp18 := checkDerefVar(glojure_DOT_core_next) + tmp18 := checkDerefVar(var_glojure_DOT_core_next) tmp19 := lang.Apply(tmp18, []any{v6}) var tmp17 any = tmp19 v4 = tmp13 @@ -5182,8 +6375,8 @@ func LoadNS() { v6 = tmp17 goto recur_loop_206 } else { - tmp20 := checkDerefVar(glojure_DOT_core__EQ__EQ_) - tmp21 := checkDerefVar(glojure_DOT_core_first) + tmp20 := checkDerefVar(var_glojure_DOT_core__EQ__EQ_) + tmp21 := checkDerefVar(var_glojure_DOT_core_first) tmp22 := lang.Apply(tmp21, []any{v6}) tmp23 := lang.Apply(tmp20, []any{v5, tmp22}) tmp10 = tmp23 @@ -5195,7 +6388,7 @@ func LoadNS() { return tmp7 } }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -5207,27 +6400,25 @@ func LoadNS() { { // function >__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_seq) - tmp6 := checkDerefVar(glojure_DOT_core_concat) - tmp7 := checkDerefVar(glojure_DOT_core_list) - tmp8 := lang.Apply(tmp7, []any{lang.NewSymbol(".")}) - tmp9 := checkDerefVar(glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp11 := checkDerefVar(glojure_DOT_core_list) - tmp12 := checkDerefVar(glojure_DOT_core_seq) - tmp13 := checkDerefVar(glojure_DOT_core_concat) - tmp14 := checkDerefVar(glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("glojure.core/Gt")}) - tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Gt}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) - tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) tmp19 := lang.Apply(tmp18, []any{v4}) tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) tmp21 := lang.Apply(tmp12, []any{tmp20}) @@ -5239,7 +6430,7 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol(">").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns non-nil if nums are in monotonically decreasing order,\n otherwise false.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1063), lang.NewKeyword("end-line"), int(1063))).(*lang.Symbol) + tmp0 := sym__GT_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns non-nil if nums are in monotonically decreasing order,\n otherwise false.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(7), kw_line, int(1063), kw_end_DASH_line, int(1063))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -5259,9 +6450,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -5270,18 +6459,18 @@ func LoadNS() { _ = v6 recur_loop_198: var tmp7 any - tmp8 := checkDerefVar(glojure_DOT_core__GT_) + tmp8 := checkDerefVar(var_glojure_DOT_core__GT_) tmp9 := lang.Apply(tmp8, []any{v4, v5}) if lang.IsTruthy(tmp9) { var tmp10 any - tmp11 := checkDerefVar(glojure_DOT_core_next) + tmp11 := checkDerefVar(var_glojure_DOT_core_next) tmp12 := lang.Apply(tmp11, []any{v6}) if lang.IsTruthy(tmp12) { var tmp13 any = v5 - tmp15 := checkDerefVar(glojure_DOT_core_first) + tmp15 := checkDerefVar(var_glojure_DOT_core_first) tmp16 := lang.Apply(tmp15, []any{v6}) var tmp14 any = tmp16 - tmp18 := checkDerefVar(glojure_DOT_core_next) + tmp18 := checkDerefVar(var_glojure_DOT_core_next) tmp19 := lang.Apply(tmp18, []any{v6}) var tmp17 any = tmp19 v4 = tmp13 @@ -5289,8 +6478,8 @@ func LoadNS() { v6 = tmp17 goto recur_loop_198 } else { - tmp20 := checkDerefVar(glojure_DOT_core__GT_) - tmp21 := checkDerefVar(glojure_DOT_core_first) + tmp20 := checkDerefVar(var_glojure_DOT_core__GT_) + tmp21 := checkDerefVar(var_glojure_DOT_core_first) tmp22 := lang.Apply(tmp21, []any{v6}) tmp23 := lang.Apply(tmp20, []any{v5, tmp22}) tmp10 = tmp23 @@ -5302,7 +6491,7 @@ func LoadNS() { return tmp7 } }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -5310,12 +6499,10 @@ func LoadNS() { } // >0? { - tmp0 := lang.NewSymbol(">0?").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(963), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(963), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym__GT_0_QMARK_.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(963), kw_column, int(7), kw_end_DASH_line, int(963), kw_end_DASH_column, int(19), kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") @@ -5325,7 +6512,7 @@ func LoadNS() { tmp5 := lang.Apply(tmp4, []any{nil, int64(0)}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -5333,12 +6520,10 @@ func LoadNS() { } // >1? { - tmp0 := lang.NewSymbol(">1?").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(962), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(962), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym__GT_1_QMARK_.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(962), kw_column, int(7), kw_end_DASH_line, int(962), kw_end_DASH_column, int(19), kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") @@ -5348,7 +6533,7 @@ func LoadNS() { tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -5360,27 +6545,25 @@ func LoadNS() { { // function >=__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_seq) - tmp6 := checkDerefVar(glojure_DOT_core_concat) - tmp7 := checkDerefVar(glojure_DOT_core_list) - tmp8 := lang.Apply(tmp7, []any{lang.NewSymbol(".")}) - tmp9 := checkDerefVar(glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp11 := checkDerefVar(glojure_DOT_core_list) - tmp12 := checkDerefVar(glojure_DOT_core_seq) - tmp13 := checkDerefVar(glojure_DOT_core_concat) - tmp14 := checkDerefVar(glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("glojure.core/Gte")}) - tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Gte}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) - tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) tmp19 := lang.Apply(tmp18, []any{v4}) tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) tmp21 := lang.Apply(tmp12, []any{tmp20}) @@ -5392,7 +6575,7 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol(">=").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns non-nil if nums are in monotonically non-increasing order,\n otherwise false.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1078), lang.NewKeyword("end-line"), int(1078))).(*lang.Symbol) + tmp0 := sym__GT__EQ_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns non-nil if nums are in monotonically non-increasing order,\n otherwise false.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(7), kw_line, int(1078), kw_end_DASH_line, int(1078))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -5412,9 +6595,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -5423,18 +6604,18 @@ func LoadNS() { _ = v6 recur_loop_202: var tmp7 any - tmp8 := checkDerefVar(glojure_DOT_core__GT__EQ_) + tmp8 := checkDerefVar(var_glojure_DOT_core__GT__EQ_) tmp9 := lang.Apply(tmp8, []any{v4, v5}) if lang.IsTruthy(tmp9) { var tmp10 any - tmp11 := checkDerefVar(glojure_DOT_core_next) + tmp11 := checkDerefVar(var_glojure_DOT_core_next) tmp12 := lang.Apply(tmp11, []any{v6}) if lang.IsTruthy(tmp12) { var tmp13 any = v5 - tmp15 := checkDerefVar(glojure_DOT_core_first) + tmp15 := checkDerefVar(var_glojure_DOT_core_first) tmp16 := lang.Apply(tmp15, []any{v6}) var tmp14 any = tmp16 - tmp18 := checkDerefVar(glojure_DOT_core_next) + tmp18 := checkDerefVar(var_glojure_DOT_core_next) tmp19 := lang.Apply(tmp18, []any{v6}) var tmp17 any = tmp19 v4 = tmp13 @@ -5442,8 +6623,8 @@ func LoadNS() { v6 = tmp17 goto recur_loop_202 } else { - tmp20 := checkDerefVar(glojure_DOT_core__GT__EQ_) - tmp21 := checkDerefVar(glojure_DOT_core_first) + tmp20 := checkDerefVar(var_glojure_DOT_core__GT__EQ_) + tmp21 := checkDerefVar(var_glojure_DOT_core_first) tmp22 := lang.Apply(tmp21, []any{v6}) tmp23 := lang.Apply(tmp20, []any{v5, tmp22}) tmp10 = tmp23 @@ -5455,7 +6636,7 @@ func LoadNS() { return tmp7 } }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -5467,16 +6648,14 @@ func LoadNS() { { // function NaN?__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) - tmp5 := checkDerefVar(glojure_DOT_core_concat) - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol("math.IsNaN")}) - tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym_math_DOT_IsNaN}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{v3}) tmp10 := lang.Apply(tmp5, []any{tmp7, tmp9}) tmp11 := lang.Apply(tmp4, []any{tmp10}) @@ -5485,18 +6664,16 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("NaN?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns true if num is NaN, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1)})), lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7968), lang.NewKeyword("end-line"), int(7968))).(*lang.Symbol) + tmp0 := sym_NaN_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_num)), kw_inline, tmp1, kw_doc, "Returns true if num is NaN, else false", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1)})), kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(7968), kw_end_DASH_line, int(7968))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 tmp5 := lang.Apply(math6.IsNaN, []any{v4}) return tmp5 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -5504,15 +6681,13 @@ func LoadNS() { } // StackTraceElement->vec { - tmp0 := lang.NewSymbol("StackTraceElement->vec").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"))), lang.NewKeyword("doc"), "Constructs a data representation for a StackTraceElement: [class method file line]", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(436), lang.NewKeyword("end-line"), int(436))).(*lang.Symbol) + tmp0 := sym_StackTraceElement_DASH__GT_vec.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_o)), kw_doc, "Constructs a data representation for a StackTraceElement: [class method file line]", kw_file, "glojure/core_print.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(28), kw_column, int(7), kw_line, int(436), kw_end_DASH_line, int(436))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_symbol) + tmp4 := checkDerefVar(var_glojure_DOT_core_symbol) tmp5, ok := lang.FieldOrMethod(v3, "getClassName") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getClassName"))) @@ -5525,7 +6700,7 @@ func LoadNS() { tmp6 = tmp5 } tmp7 := lang.Apply(tmp4, []any{tmp6}) - tmp8 := checkDerefVar(glojure_DOT_core_symbol) + tmp8 := checkDerefVar(var_glojure_DOT_core_symbol) tmp9, ok := lang.FieldOrMethod(v3, "getMethodName") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getMethodName"))) @@ -5561,14 +6736,14 @@ func LoadNS() { tmp15 = tmp14 } tmp16 := lang.NewVector(tmp7, tmp11, tmp13, tmp15) - tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(440), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(440), lang.NewKeyword("end-column"), int(94)) + tmp17 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(440), kw_column, int(3), kw_end_DASH_line, int(440), kw_end_DASH_column, int(94)) tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) if err != nil { panic(err) } return tmp18 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -5576,12 +6751,10 @@ func LoadNS() { } // Throwable->map { - tmp0 := lang.NewSymbol("Throwable->map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"))), lang.NewKeyword("doc"), "Constructs a data representation for a Throwable with keys:\n :cause - root cause message\n :phase - error phase\n :via - cause chain, with cause keys:\n :type - exception class symbol\n :message - exception message\n :data - ex-data\n :at - top stack element\n :trace - root cause stack elements", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(442), lang.NewKeyword("end-line"), int(442))).(*lang.Symbol) + tmp0 := sym_Throwable_DASH__GT_map.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_o)), kw_doc, "Constructs a data representation for a Throwable with keys:\n :cause - root cause message\n :phase - error phase\n :via - cause chain, with cause keys:\n :type - exception class symbol\n :message - exception message\n :data - ex-data\n :at - top stack element\n :trace - root cause stack elements", kw_file, "glojure/core_print.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(442), kw_end_DASH_line, int(442))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any @@ -5589,14 +6762,12 @@ func LoadNS() { // let binding "base" var tmp5 lang.FnFunc tmp5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v6 := args[0] _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_merge) - tmp8 := checkDerefVar(glojure_DOT_core_symbol) - tmp9 := checkDerefVar(glojure_DOT_core_class) + tmp7 := checkDerefVar(var_glojure_DOT_core_merge) + tmp8 := checkDerefVar(var_glojure_DOT_core_symbol) + tmp9 := checkDerefVar(var_glojure_DOT_core_class) tmp10 := lang.Apply(tmp9, []any{v6}) tmp11, ok := lang.FieldOrMethod(tmp10, "Name") if !ok { @@ -5610,8 +6781,8 @@ func LoadNS() { tmp12 = tmp11 } tmp13 := lang.Apply(tmp8, []any{tmp12}) - tmp14 := lang.NewMap(lang.NewKeyword("type"), tmp13) - tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(455), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(455), lang.NewKeyword("end-column"), int(56)) + tmp14 := lang.NewMap(kw_type, tmp13) + tmp15 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(455), kw_column, int(23), kw_end_DASH_line, int(455), kw_end_DASH_column, int(56)) tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) if err != nil { panic(err) @@ -5639,8 +6810,8 @@ func LoadNS() { // let binding "msg" var v23 any = v20 _ = v23 - tmp24 := lang.NewMap(lang.NewKeyword("message"), v23) - tmp25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(457), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(457), lang.NewKeyword("end-column"), int(33)) + tmp24 := lang.NewMap(kw_message, v23) + tmp25 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(457), kw_column, int(20), kw_end_DASH_line, int(457), kw_end_DASH_column, int(33)) tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) if err != nil { panic(err) @@ -5655,7 +6826,7 @@ func LoadNS() { var tmp18 any { // let // let binding "temp__0__auto__" - tmp19 := checkDerefVar(glojure_DOT_core_ex_data) + tmp19 := checkDerefVar(var_glojure_DOT_core_ex_DASH_data) tmp20 := lang.Apply(tmp19, []any{v6}) var v21 any = tmp20 _ = v21 @@ -5666,8 +6837,8 @@ func LoadNS() { // let binding "ed" var v24 any = v21 _ = v24 - tmp25 := lang.NewMap(lang.NewKeyword("data"), v24) - tmp26 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(459), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(459), lang.NewKeyword("end-column"), int(29)) + tmp25 := lang.NewMap(kw_data, v24) + tmp26 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(459), kw_column, int(20), kw_end_DASH_line, int(459), kw_end_DASH_column, int(29)) tmp27, err := lang.WithMeta(tmp25, tmp26.(lang.IPersistentMap)) if err != nil { panic(err) @@ -5696,17 +6867,17 @@ func LoadNS() { var v22 any = tmp21 _ = v22 var tmp23 any - tmp24 := checkDerefVar(glojure_DOT_core_pos_QMARK_) - tmp25 := checkDerefVar(glojure_DOT_core_alength) + tmp24 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp25 := checkDerefVar(var_glojure_DOT_core_alength) tmp26 := lang.Apply(tmp25, []any{v22}) tmp27 := lang.Apply(tmp24, []any{tmp26}) if lang.IsTruthy(tmp27) { - tmp28 := checkDerefVar(glojure_DOT_core_StackTraceElement__GT_vec) - tmp29 := checkDerefVar(glojure_DOT_core_aget) + tmp28 := checkDerefVar(var_glojure_DOT_core_StackTraceElement_DASH__GT_vec) + tmp29 := checkDerefVar(var_glojure_DOT_core_aget) tmp30 := lang.Apply(tmp29, []any{v22, int64(0)}) tmp31 := lang.Apply(tmp28, []any{tmp30}) - tmp32 := lang.NewMap(lang.NewKeyword("at"), tmp31) - tmp33 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(462), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(462), lang.NewKeyword("end-column"), int(63)) + tmp32 := lang.NewMap(kw_at, tmp31) + tmp33 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(462), kw_column, int(22), kw_end_DASH_line, int(462), kw_end_DASH_column, int(63)) tmp34, err := lang.WithMeta(tmp32, tmp33.(lang.IPersistentMap)) if err != nil { panic(err) @@ -5719,7 +6890,7 @@ func LoadNS() { tmp20 := lang.Apply(tmp7, []any{tmp16, tmp17, tmp18, tmp19}) return tmp20 }) - tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(454), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(462), lang.NewKeyword("end-column"), int(67)) + tmp6 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(454), kw_column, int(14), kw_end_DASH_line, int(462), kw_end_DASH_column, int(67)) tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) if err != nil { panic(err) @@ -5731,7 +6902,7 @@ func LoadNS() { { // let // let binding "via" tmp10 := lang.NewVector() - tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(463), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(463), lang.NewKeyword("end-column"), int(25)) + tmp11 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(463), kw_column, int(24), kw_end_DASH_line, int(463), kw_end_DASH_column, int(25)) tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) if err != nil { panic(err) @@ -5744,7 +6915,7 @@ func LoadNS() { for { var tmp15 any if lang.IsTruthy(v14) { - tmp17 := checkDerefVar(glojure_DOT_core_conj) + tmp17 := checkDerefVar(var_glojure_DOT_core_conj) tmp18 := lang.Apply(tmp17, []any{v13, v14}) var tmp16 any = tmp18 tmp20, ok := lang.FieldOrMethod(v14, "getCause") @@ -5772,18 +6943,18 @@ func LoadNS() { var v10 any = tmp9 _ = v10 // let binding "root" - tmp11 := checkDerefVar(glojure_DOT_core_peek) + tmp11 := checkDerefVar(var_glojure_DOT_core_peek) tmp12 := lang.Apply(tmp11, []any{v10}) var v13 any = tmp12 _ = v13 - tmp14 := checkDerefVar(glojure_DOT_core_merge) - tmp15 := checkDerefVar(glojure_DOT_core_vec) - tmp16 := checkDerefVar(glojure_DOT_core_map) + tmp14 := checkDerefVar(var_glojure_DOT_core_merge) + tmp15 := checkDerefVar(var_glojure_DOT_core_vec) + tmp16 := checkDerefVar(var_glojure_DOT_core_map) tmp17 := lang.Apply(tmp16, []any{v8, v10}) tmp18 := lang.Apply(tmp15, []any{tmp17}) - tmp19 := checkDerefVar(glojure_DOT_core_vec) - tmp20 := checkDerefVar(glojure_DOT_core_map) - tmp21 := checkDerefVar(glojure_DOT_core_StackTraceElement__GT_vec) + tmp19 := checkDerefVar(var_glojure_DOT_core_vec) + tmp20 := checkDerefVar(var_glojure_DOT_core_map) + tmp21 := checkDerefVar(var_glojure_DOT_core_StackTraceElement_DASH__GT_vec) var tmp22 any { // let // let binding "or__0__auto__" @@ -5810,8 +6981,8 @@ func LoadNS() { } tmp25 := lang.Apply(tmp20, []any{tmp21, tmp24}) tmp26 := lang.Apply(tmp19, []any{tmp25}) - tmp27 := lang.NewMap(lang.NewKeyword("via"), tmp18, lang.NewKeyword("trace"), tmp26) - tmp28 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(468), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(470), lang.NewKeyword("end-column"), int(111)) + tmp27 := lang.NewMap(kw_via, tmp18, kw_trace, tmp26) + tmp28 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(468), kw_column, int(12), kw_end_DASH_line, int(470), kw_end_DASH_column, int(111)) tmp29, err := lang.WithMeta(tmp27, tmp28.(lang.IPersistentMap)) if err != nil { panic(err) @@ -5839,8 +7010,8 @@ func LoadNS() { // let binding "root-msg" var v36 any = v33 _ = v36 - tmp37 := lang.NewMap(lang.NewKeyword("cause"), v36) - tmp38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(472), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(472), lang.NewKeyword("end-column"), int(25)) + tmp37 := lang.NewMap(kw_cause, v36) + tmp38 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(472), kw_column, int(9), kw_end_DASH_line, int(472), kw_end_DASH_column, int(25)) tmp39, err := lang.WithMeta(tmp37, tmp38.(lang.IPersistentMap)) if err != nil { panic(err) @@ -5855,7 +7026,7 @@ func LoadNS() { var tmp31 any { // let // let binding "temp__0__auto__" - tmp32 := checkDerefVar(glojure_DOT_core_ex_data) + tmp32 := checkDerefVar(var_glojure_DOT_core_ex_DASH_data) tmp33 := lang.Apply(tmp32, []any{v13}) var v34 any = tmp33 _ = v34 @@ -5866,8 +7037,8 @@ func LoadNS() { // let binding "data" var v37 any = v34 _ = v37 - tmp38 := lang.NewMap(lang.NewKeyword("data"), v37) - tmp39 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(474), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(474), lang.NewKeyword("end-column"), int(20)) + tmp38 := lang.NewMap(kw_data, v37) + tmp39 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(474), kw_column, int(9), kw_end_DASH_line, int(474), kw_end_DASH_column, int(20)) tmp40, err := lang.WithMeta(tmp38, tmp39.(lang.IPersistentMap)) if err != nil { panic(err) @@ -5882,9 +7053,9 @@ func LoadNS() { var tmp32 any { // let // let binding "temp__0__auto__" - tmp33 := checkDerefVar(glojure_DOT_core_ex_data) + tmp33 := checkDerefVar(var_glojure_DOT_core_ex_DASH_data) tmp34 := lang.Apply(tmp33, []any{v3}) - tmp35 := lang.Apply(lang.NewKeyword("glojure.error/phase"), []any{tmp34}) + tmp35 := lang.Apply(kw_glojure_DOT_error_SLASH_phase, []any{tmp34}) var v36 any = tmp35 _ = v36 var tmp37 any @@ -5894,8 +7065,8 @@ func LoadNS() { // let binding "phase" var v39 any = v36 _ = v39 - tmp40 := lang.NewMap(lang.NewKeyword("phase"), v39) - tmp41 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(476), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(476), lang.NewKeyword("end-column"), int(22)) + tmp40 := lang.NewMap(kw_phase, v39) + tmp41 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(476), kw_column, int(9), kw_end_DASH_line, int(476), kw_end_DASH_column, int(22)) tmp42, err := lang.WithMeta(tmp40, tmp41.(lang.IPersistentMap)) if err != nil { panic(err) @@ -5912,7 +7083,7 @@ func LoadNS() { } // end let return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -5924,16 +7095,14 @@ func LoadNS() { { // function abs__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) - tmp5 := checkDerefVar(glojure_DOT_core_concat) - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Abs")}) - tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Abs}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{v3}) tmp10 := lang.Apply(tmp5, []any{tmp7, tmp9}) tmp11 := lang.Apply(tmp4, []any{tmp10}) @@ -5942,18 +7111,16 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("abs").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the absolute value of a.\n If a is Long/MIN_VALUE => Long/MIN_VALUE\n If a is a double and zero => +0.0\n If a is a double and ##Inf or ##-Inf => ##Inf\n If a is a double and ##NaN => ##NaN", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1)})), lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1128), lang.NewKeyword("end-line"), int(1128))).(*lang.Symbol) + tmp0 := sym_abs.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a)), kw_inline, tmp1, kw_doc, "Returns the absolute value of a.\n If a is Long/MIN_VALUE => Long/MIN_VALUE\n If a is a double and zero => +0.0\n If a is a double and ##Inf or ##-Inf => ##Inf\n If a is a double and ##NaN => ##NaN", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1)})), kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(1128), kw_end_DASH_line, int(1128))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 tmp5 := lang.Apply(lang.Abs, []any{v4}) return tmp5 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -5961,12 +7128,10 @@ func LoadNS() { } // accessor { - tmp0 := lang.NewSymbol("accessor").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("key"))), lang.NewKeyword("doc"), "Returns a fn that, given an instance of a structmap with the basis,\n returns the value at the key. The key must be in the basis. The\n returned function should be (slightly) more efficient than using\n get, but such use of accessors should be limited to known\n performance-critical areas.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4070), lang.NewKeyword("end-line"), int(4070))).(*lang.Symbol) + tmp0 := sym_accessor.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s, sym_key)), kw_doc, "Returns a fn that, given an instance of a structmap with the basis,\n returns the value at the key. The key must be in the basis. The\n returned function should be (slightly) more efficient than using\n get, but such use of accessors should be limited to known\n performance-critical areas.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(4070), kw_end_DASH_line, int(4070))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -5978,7 +7143,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -5990,23 +7155,21 @@ func LoadNS() { { // function aclone__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) - tmp5 := checkDerefVar(glojure_DOT_core_concat) - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := checkDerefVar(glojure_DOT_core_seq) - tmp12 := checkDerefVar(glojure_DOT_core_concat) - tmp13 := checkDerefVar(glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/Aclone")}) - tmp15 := checkDerefVar(glojure_DOT_core_list) + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Aclone}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) tmp18 := lang.Apply(tmp11, []any{tmp17}) @@ -6018,12 +7181,10 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("aclone").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns a clone of the Java array. Works on arrays of known\n types.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3904), lang.NewKeyword("end-line"), int(3904))).(*lang.Symbol) + tmp0 := sym_aclone.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array)), kw_inline, tmp1, kw_doc, "Returns a clone of the Java array. Works on arrays of known\n types.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(3904), kw_end_DASH_line, int(3904))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 tmp5, _ := lang.FieldOrMethod(runtime7.RT, "Aclone") @@ -6033,7 +7194,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v4}) return tmp6 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -6041,21 +7202,19 @@ func LoadNS() { } // add-classpath { - tmp0 := lang.NewSymbol("add-classpath").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("url"))), lang.NewKeyword("doc"), "DEPRECATED \n\n Adds the url (String or URL object) to the classpath per\n URLClassLoader.addURL", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("deprecated"), "1.1", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5176), lang.NewKeyword("end-line"), int(5176))).(*lang.Symbol) + tmp0 := sym_add_DASH_classpath.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_url)), kw_doc, "DEPRECATED \n\n Adds the url (String or URL object) to the classpath per\n URLClassLoader.addURL", kw_file, "glojure/core.glj", kw_deprecated, "1.1", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(5176), kw_end_DASH_line, int(5176))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_println) + tmp4 := checkDerefVar(var_glojure_DOT_core_println) tmp5 := lang.Apply(tmp4, []any{"WARNING: add-classpath is deprecated"}) _ = tmp5 tmp6 := lang.Apply(nil, []any{v3}) return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -6063,12 +7222,10 @@ func LoadNS() { } // add-doc-and-meta { - tmp0 := lang.NewSymbol("add-doc-and-meta").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("docstring"), lang.NewSymbol("meta"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(26), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6400), lang.NewKeyword("end-line"), int(6400), lang.NewKeyword("private"), true)).(*lang.Symbol) + tmp0 := sym_add_DASH_doc_DASH_and_DASH_meta.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym_docstring, sym_meta)), kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(26), kw_column, int(11), kw_line, int(6400), kw_end_DASH_line, int(6400), kw_private, true)).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 5 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 5) v3 := args[0] _ = v3 v4 := args[1] @@ -6079,32 +7236,32 @@ func LoadNS() { _ = v6 v7 := args[4] _ = v7 - tmp8 := checkDerefVar(glojure_DOT_core_seq) - tmp9 := checkDerefVar(glojure_DOT_core_concat) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol("glojure.core/alter-meta!")}) - tmp12 := checkDerefVar(glojure_DOT_core_list) - tmp13 := checkDerefVar(glojure_DOT_core_seq) - tmp14 := checkDerefVar(glojure_DOT_core_concat) - tmp15 := checkDerefVar(glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("var")}) - tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_alter_DASH_meta_BANG_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_var}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) tmp18 := lang.Apply(tmp17, []any{v5}) tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) tmp20 := lang.Apply(tmp13, []any{tmp19}) tmp21 := lang.Apply(tmp12, []any{tmp20}) - tmp22 := checkDerefVar(glojure_DOT_core_list) - tmp23 := lang.Apply(tmp22, []any{lang.NewSymbol("glojure.core/merge")}) - tmp24 := checkDerefVar(glojure_DOT_core_list) - tmp25 := checkDerefVar(glojure_DOT_core_seq) - tmp26 := checkDerefVar(glojure_DOT_core_concat) - tmp27 := checkDerefVar(glojure_DOT_core_list) - tmp28 := lang.Apply(tmp27, []any{lang.NewSymbol("glojure.core/assoc")}) - tmp29 := checkDerefVar(glojure_DOT_core_list) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{sym_glojure_DOT_core_SLASH_merge}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := checkDerefVar(var_glojure_DOT_core_seq) + tmp26 := checkDerefVar(var_glojure_DOT_core_concat) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{sym_glojure_DOT_core_SLASH_assoc}) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) tmp30 := lang.Apply(tmp29, []any{v7}) - tmp31 := checkDerefVar(glojure_DOT_core_list) - tmp32 := lang.Apply(tmp31, []any{lang.NewKeyword("doc")}) - tmp33 := checkDerefVar(glojure_DOT_core_list) + tmp31 := checkDerefVar(var_glojure_DOT_core_list) + tmp32 := lang.Apply(tmp31, []any{kw_doc}) + tmp33 := checkDerefVar(var_glojure_DOT_core_list) tmp34 := lang.Apply(tmp33, []any{v6}) tmp35 := lang.Apply(tmp26, []any{tmp28, tmp30, tmp32, tmp34}) tmp36 := lang.Apply(tmp25, []any{tmp35}) @@ -6113,7 +7270,7 @@ func LoadNS() { tmp39 := lang.Apply(tmp8, []any{tmp38}) return tmp39 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -6121,12 +7278,10 @@ func LoadNS() { } // add-watch { - tmp0 := lang.NewSymbol("add-watch").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("reference"), lang.NewSymbol("key"), lang.NewSymbol("fn"))), lang.NewKeyword("doc"), "Adds a watch function to an agent/atom/var/ref reference. The watch\n fn must be a fn of 4 args: a key, the reference, its old-state, its\n new-state. Whenever the reference's state might have been changed,\n any registered watches will have their functions called. The watch fn\n will be called synchronously, on the agent's thread if an agent,\n before any pending sends if agent or ref. Note that an atom's or\n ref's state may have changed again prior to the fn call, so use\n old/new-state rather than derefing the reference. Note also that watch\n fns may be called from multiple threads simultaneously. Var watchers\n are triggered only by root binding changes, not thread-local\n set!s. Keys must be unique per reference, and can be used to remove\n the watch with remove-watch, but are otherwise considered opaque by\n the watch mechanism.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2142), lang.NewKeyword("end-line"), int(2142))).(*lang.Symbol) + tmp0 := sym_add_DASH_watch.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_reference, sym_key, sym_fn)), kw_doc, "Adds a watch function to an agent/atom/var/ref reference. The watch\n fn must be a fn of 4 args: a key, the reference, its old-state, its\n new-state. Whenever the reference's state might have been changed,\n any registered watches will have their functions called. The watch fn\n will be called synchronously, on the agent's thread if an agent,\n before any pending sends if agent or ref. Note that an atom's or\n ref's state may have changed again prior to the fn call, so use\n old/new-state rather than derefing the reference. Note also that watch\n fns may be called from multiple threads simultaneously. Var watchers\n are triggered only by root binding changes, not thread-local\n set!s. Keys must be unique per reference, and can be used to remove\n the watch with remove-watch, but are otherwise considered opaque by\n the watch mechanism.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(2142), kw_end_DASH_line, int(2142))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -6140,7 +7295,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -6148,14 +7303,12 @@ func LoadNS() { } // agent { - tmp0 := lang.NewSymbol("agent").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("state"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Creates and returns an agent with an initial value of state and\n zero or more options (in any order):\n\n :meta metadata-map\n\n :validator validate-fn\n\n :error-handler handler-fn\n\n :error-mode mode-keyword\n\n If metadata-map is supplied, it will become the metadata on the\n agent. validate-fn must be nil or a side-effect-free fn of one\n argument, which will be passed the intended new state on any state\n change. If the new state is unacceptable, the validate-fn should\n return false or throw an exception. handler-fn is called if an\n action throws an exception or if validate-fn rejects a new state --\n see set-error-handler! for details. The mode-keyword may be either\n :continue (the default if an error-handler is given) or :fail (the\n default if no error-handler is given) -- see set-error-mode! for\n details.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2052), lang.NewKeyword("end-line"), int(2052))).(*lang.Symbol) + tmp0 := sym_agent.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_state, sym__AMP_, sym_options)), kw_doc, "Creates and returns an agent with an initial value of state and\n zero or more options (in any order):\n\n :meta metadata-map\n\n :validator validate-fn\n\n :error-handler handler-fn\n\n :error-mode mode-keyword\n\n If metadata-map is supplied, it will become the metadata on the\n agent. validate-fn must be nil or a side-effect-free fn of one\n argument, which will be passed the intended new state on any state\n change. If the new state is unacceptable, the validate-fn should\n return false or throw an exception. handler-fn is called if an\n action throws an exception or if validate-fn rejects a new state --\n see set-error-handler! for details. The mode-keyword may be either\n :continue (the default if an error-handler is given) or :fail (the\n default if no error-handler is given) -- see set-error-mode! for\n details.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(2052), kw_end_DASH_line, int(2052))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var v4 any = lang.NewList(args[1:]...) @@ -6166,18 +7319,18 @@ func LoadNS() { var v6 any = "unimplemented: new with non-constant class type" _ = v6 // let binding "opts" - tmp7 := checkDerefVar(glojure_DOT_core_apply) - tmp8 := checkDerefVar(glojure_DOT_core_hash_map) + tmp7 := checkDerefVar(var_glojure_DOT_core_apply) + tmp8 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) tmp9 := lang.Apply(tmp7, []any{tmp8, v4}) var v10 any = tmp9 _ = v10 - tmp11 := checkDerefVar(glojure_DOT_core_setup_reference) + tmp11 := checkDerefVar(var_glojure_DOT_core_setup_DASH_reference) tmp12 := lang.Apply(tmp11, []any{v6, v4}) _ = tmp12 var tmp13 any - tmp14 := lang.Apply(lang.NewKeyword("error-handler"), []any{v10}) + tmp14 := lang.Apply(kw_error_DASH_handler, []any{v10}) if lang.IsTruthy(tmp14) { - tmp15 := lang.Apply(lang.NewKeyword("error-handler"), []any{v10}) + tmp15 := lang.Apply(kw_error_DASH_handler, []any{v10}) tmp16, _ := lang.FieldOrMethod(v6, "setErrorHandler") if reflect.TypeOf(tmp16).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorHandler is not a function"))) @@ -6190,7 +7343,7 @@ func LoadNS() { var tmp18 any { // let // let binding "or__0__auto__" - tmp19 := lang.Apply(lang.NewKeyword("error-mode"), []any{v10}) + tmp19 := lang.Apply(kw_error_DASH_mode, []any{v10}) var v20 any = tmp19 _ = v20 var tmp21 any @@ -6198,11 +7351,11 @@ func LoadNS() { tmp21 = v20 } else { var tmp22 any - tmp23 := lang.Apply(lang.NewKeyword("error-handler"), []any{v10}) + tmp23 := lang.Apply(kw_error_DASH_handler, []any{v10}) if lang.IsTruthy(tmp23) { - tmp22 = lang.NewKeyword("continue") + tmp22 = kw_continue } else { - tmp22 = lang.NewKeyword("fail") + tmp22 = kw_fail } tmp21 = tmp22 } @@ -6219,7 +7372,7 @@ func LoadNS() { return tmp5 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -6227,12 +7380,10 @@ func LoadNS() { } // agent-error { - tmp0 := lang.NewSymbol("agent-error").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("doc"), "Returns the exception thrown during an asynchronous action of the\n agent if the agent is failed. Returns nil if the agent is not\n failed.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2167), lang.NewKeyword("end-line"), int(2167))).(*lang.Symbol) + tmp0 := sym_agent_DASH_error.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a)), kw_doc, "Returns the exception thrown during an asynchronous action of the\n agent if the agent is failed. Returns nil if the agent is not\n failed.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(2167), kw_end_DASH_line, int(2167))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4, ok := lang.FieldOrMethod(v3, "getError") @@ -6248,7 +7399,7 @@ func LoadNS() { } return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -6256,18 +7407,16 @@ func LoadNS() { } // agent-errors { - tmp0 := lang.NewSymbol("agent-errors").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("doc"), "DEPRECATED: Use 'agent-error' instead.\n Returns a sequence of the exceptions thrown during asynchronous\n actions of the agent.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("deprecated"), "1.2", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2234), lang.NewKeyword("end-line"), int(2234))).(*lang.Symbol) + tmp0 := sym_agent_DASH_errors.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a)), kw_doc, "DEPRECATED: Use 'agent-error' instead.\n Returns a sequence of the exceptions thrown during asynchronous\n actions of the agent.", kw_file, "glojure/core.glj", kw_deprecated, "1.2", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(2234), kw_end_DASH_line, int(2234))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any { // let // let binding "temp__0__auto__" - tmp5 := checkDerefVar(glojure_DOT_core_agent_error) + tmp5 := checkDerefVar(var_glojure_DOT_core_agent_DASH_error) tmp6 := lang.Apply(tmp5, []any{v3}) var v7 any = tmp6 _ = v7 @@ -6278,7 +7427,7 @@ func LoadNS() { // let binding "e" var v10 any = v7 _ = v10 - tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) tmp12 := lang.Apply(tmp11, []any{v10}) tmp9 = tmp12 } // end let @@ -6289,7 +7438,7 @@ func LoadNS() { } // end let return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -6301,32 +7450,30 @@ func LoadNS() { { // function aget__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_seq) - tmp6 := checkDerefVar(glojure_DOT_core_concat) - tmp7 := checkDerefVar(glojure_DOT_core_list) - tmp8 := lang.Apply(tmp7, []any{lang.NewSymbol(".")}) - tmp9 := checkDerefVar(glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - tmp11 := checkDerefVar(glojure_DOT_core_list) - tmp12 := checkDerefVar(glojure_DOT_core_seq) - tmp13 := checkDerefVar(glojure_DOT_core_concat) - tmp14 := checkDerefVar(glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("glojure.core/Aget")}) - tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Aget}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) - tmp18 := checkDerefVar(glojure_DOT_core_list) - tmp19 := checkDerefVar(glojure_DOT_core_seq) - tmp20 := checkDerefVar(glojure_DOT_core_concat) - tmp21 := checkDerefVar(glojure_DOT_core_list) - tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("glojure.core/int")}) - tmp23 := checkDerefVar(glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := checkDerefVar(var_glojure_DOT_core_seq) + tmp20 := checkDerefVar(var_glojure_DOT_core_concat) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{sym_glojure_DOT_core_SLASH_int}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) tmp24 := lang.Apply(tmp23, []any{v4}) tmp25 := lang.Apply(tmp20, []any{tmp22, tmp24}) tmp26 := lang.Apply(tmp19, []any{tmp25}) @@ -6341,7 +7488,7 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("aget").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("&"), lang.NewSymbol("idxs"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the value at the index/indices. Works on Java arrays of all\n types.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3911), lang.NewKeyword("end-line"), int(3911))).(*lang.Symbol) + tmp0 := sym_aget.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx), lang.NewVector(sym_array, sym_idx, sym__AMP_, sym_idxs)), kw_inline, tmp1, kw_doc, "Returns the value at the index/indices. Works on Java arrays of all\n types.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3911), kw_end_DASH_line, int(3911))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -6353,24 +7500,22 @@ func LoadNS() { tmp6 := lang.Apply(lang.Get, []any{v4, v5}) return tmp6 default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v4 := args[0] _ = v4 v5 := args[1] _ = v5 var v6 any = lang.NewList(args[2:]...) _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_apply) - tmp8 := checkDerefVar(glojure_DOT_core_aget) - tmp9 := checkDerefVar(glojure_DOT_core_aget) + tmp7 := checkDerefVar(var_glojure_DOT_core_apply) + tmp8 := checkDerefVar(var_glojure_DOT_core_aget) + tmp9 := checkDerefVar(var_glojure_DOT_core_aget) tmp10 := lang.Apply(tmp9, []any{v4, v5}) tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) return tmp11 } }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -6382,23 +7527,21 @@ func LoadNS() { { // function alength__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) - tmp5 := checkDerefVar(glojure_DOT_core_concat) - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := checkDerefVar(glojure_DOT_core_seq) - tmp12 := checkDerefVar(glojure_DOT_core_concat) - tmp13 := checkDerefVar(glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/Alength")}) - tmp15 := checkDerefVar(glojure_DOT_core_list) + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Alength}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) tmp18 := lang.Apply(tmp11, []any{tmp17}) @@ -6410,12 +7553,10 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("alength").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the length of the Java array. Works on arrays of all\n types.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3897), lang.NewKeyword("end-line"), int(3897))).(*lang.Symbol) + tmp0 := sym_alength.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array)), kw_inline, tmp1, kw_doc, "Returns the length of the Java array. Works on arrays of all\n types.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(3897), kw_end_DASH_line, int(3897))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 tmp5, _ := lang.FieldOrMethod(runtime7.RT, "Alength") @@ -6425,7 +7566,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v4}) return tmp6 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -6433,18 +7574,16 @@ func LoadNS() { } // alias { - tmp0 := lang.NewSymbol("alias").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("alias"), lang.NewSymbol("namespace-sym"))), lang.NewKeyword("doc"), "Add an alias in the current namespace to another\n namespace. Arguments are two symbols: the alias to be used, and\n the symbolic name of the target namespace. Use :as in the ns macro in preference\n to calling this directly.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4263), lang.NewKeyword("end-line"), int(4263))).(*lang.Symbol) + tmp0 := sym_alias.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_alias, sym_namespace_DASH_sym)), kw_doc, "Add an alias in the current namespace to another\n namespace. Arguments are two symbols: the alias to be used, and\n the symbolic name of the target namespace. Use :as in the ns macro in preference\n to calling this directly.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(4263), kw_end_DASH_line, int(4263))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) - tmp6 := checkDerefVar(glojure_DOT_core_the_ns) + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp6 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) tmp7 := lang.Apply(tmp6, []any{v4}) tmp8, _ := lang.FieldOrMethod(tmp5, "AddAlias") if reflect.TypeOf(tmp8).Kind() != reflect.Func { @@ -6453,7 +7592,7 @@ func LoadNS() { tmp9 := lang.Apply(tmp8, []any{v3, tmp7}) return tmp9 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -6461,16 +7600,14 @@ func LoadNS() { } // all-ns { - tmp0 := lang.NewSymbol("all-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Returns a sequence of all namespaces.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4146), lang.NewKeyword("end-line"), int(4146))).(*lang.Symbol) + tmp0 := sym_all_DASH_ns.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Returns a sequence of all namespaces.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(4146), kw_end_DASH_line, int(4146))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) tmp3 := lang.Apply(nil, nil) return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -6478,14 +7615,12 @@ func LoadNS() { } // alter { - tmp0 := lang.NewSymbol("alter").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("fun"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Must be called in a transaction. Sets the in-transaction-value of\n ref to:\n\n (apply fun in-transaction-value-of-ref args)\n\n and returns the in-transaction-value of ref.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2435), lang.NewKeyword("end-line"), int(2435))).(*lang.Symbol) + tmp0 := sym_alter.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ref, sym_fun, sym__AMP_, sym_args)), kw_doc, "Must be called in a transaction. Sets the in-transaction-value of\n ref to:\n\n (apply fun in-transaction-value-of-ref args)\n\n and returns the in-transaction-value of ref.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(2435), kw_end_DASH_line, int(2435))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -6500,7 +7635,7 @@ func LoadNS() { return tmp7 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -6508,14 +7643,12 @@ func LoadNS() { } // alter-meta! { - tmp0 := lang.NewSymbol("alter-meta!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("iref"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Atomically sets the metadata for a namespace/var/ref/agent/atom to be:\n\n (apply f its-current-meta args)\n\n f must be free of side-effects", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2398), lang.NewKeyword("end-line"), int(2398))).(*lang.Symbol) + tmp0 := sym_alter_DASH_meta_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_iref, sym_f, sym__AMP_, sym_args)), kw_doc, "Atomically sets the metadata for a namespace/var/ref/agent/atom to be:\n\n (apply f its-current-meta args)\n\n f must be free of side-effects", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(2398), kw_end_DASH_line, int(2398))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -6530,7 +7663,7 @@ func LoadNS() { return tmp7 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -6538,14 +7671,12 @@ func LoadNS() { } // alter-var-root { - tmp0 := lang.NewSymbol("alter-var-root").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("v"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Atomically alters the root binding of var v by applying f to its\n current value plus any args", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5484), lang.NewKeyword("end-line"), int(5484))).(*lang.Symbol) + tmp0 := sym_alter_DASH_var_DASH_root.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_v, sym_f, sym__AMP_, sym_args)), kw_doc, "Atomically alters the root binding of var v by applying f to its\n current value plus any args", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(5484), kw_end_DASH_line, int(5484))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -6560,7 +7691,7 @@ func LoadNS() { return tmp7 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -6568,12 +7699,10 @@ func LoadNS() { } // amap { - tmp0 := lang.NewSymbol("amap").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("idx"), lang.NewSymbol("ret"), lang.NewSymbol("expr"))), lang.NewKeyword("doc"), "Maps an expression across an array a, using an index named idx, and\n return value named ret, initialized to a clone of a, then setting \n each element of ret to the evaluation of expr, returning the new \n array ret.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5273), lang.NewKeyword("end-line"), int(5273))).(*lang.Symbol) + tmp0 := sym_amap.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_a, sym_idx, sym_ret, sym_expr)), kw_doc, "Maps an expression across an array a, using an index named idx, and\n return value named ret, initialized to a clone of a, then setting \n each element of ret to the evaluation of expr, returning the new \n array ret.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(11), kw_line, int(5273), kw_end_DASH_line, int(5273))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 6 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 6) v3 := args[0] _ = v3 v4 := args[1] @@ -6586,40 +7715,40 @@ func LoadNS() { _ = v7 v8 := args[5] _ = v8 - tmp9 := checkDerefVar(glojure_DOT_core_seq) - tmp10 := checkDerefVar(glojure_DOT_core_concat) - tmp11 := checkDerefVar(glojure_DOT_core_list) - tmp12 := lang.Apply(tmp11, []any{lang.NewSymbol("glojure.core/let")}) - tmp13 := checkDerefVar(glojure_DOT_core_list) - tmp14 := checkDerefVar(glojure_DOT_core_apply) - tmp15 := checkDerefVar(glojure_DOT_core_vector) - tmp16 := checkDerefVar(glojure_DOT_core_seq) - tmp17 := checkDerefVar(glojure_DOT_core_concat) - tmp18 := checkDerefVar(glojure_DOT_core_list) - tmp19 := lang.Apply(tmp18, []any{lang.NewSymbol("a__0__auto__")}) - tmp20 := checkDerefVar(glojure_DOT_core_list) + tmp9 := checkDerefVar(var_glojure_DOT_core_seq) + tmp10 := checkDerefVar(var_glojure_DOT_core_concat) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_glojure_DOT_core_SLASH_let}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_apply) + tmp15 := checkDerefVar(var_glojure_DOT_core_vector) + tmp16 := checkDerefVar(var_glojure_DOT_core_seq) + tmp17 := checkDerefVar(var_glojure_DOT_core_concat) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{sym_a__0__auto__}) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) tmp21 := lang.Apply(tmp20, []any{v5}) - tmp22 := checkDerefVar(glojure_DOT_core_list) - tmp23 := lang.Apply(tmp22, []any{lang.NewSymbol("l__1__auto__")}) - tmp24 := checkDerefVar(glojure_DOT_core_list) - tmp25 := checkDerefVar(glojure_DOT_core_seq) - tmp26 := checkDerefVar(glojure_DOT_core_concat) - tmp27 := checkDerefVar(glojure_DOT_core_list) - tmp28 := lang.Apply(tmp27, []any{lang.NewSymbol("glojure.core/alength")}) - tmp29 := checkDerefVar(glojure_DOT_core_list) - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("a__0__auto__")}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{sym_l__1__auto__}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := checkDerefVar(var_glojure_DOT_core_seq) + tmp26 := checkDerefVar(var_glojure_DOT_core_concat) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{sym_glojure_DOT_core_SLASH_alength}) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{sym_a__0__auto__}) tmp31 := lang.Apply(tmp26, []any{tmp28, tmp30}) tmp32 := lang.Apply(tmp25, []any{tmp31}) tmp33 := lang.Apply(tmp24, []any{tmp32}) - tmp34 := checkDerefVar(glojure_DOT_core_list) + tmp34 := checkDerefVar(var_glojure_DOT_core_list) tmp35 := lang.Apply(tmp34, []any{v7}) - tmp36 := checkDerefVar(glojure_DOT_core_list) - tmp37 := checkDerefVar(glojure_DOT_core_seq) - tmp38 := checkDerefVar(glojure_DOT_core_concat) - tmp39 := checkDerefVar(glojure_DOT_core_list) - tmp40 := lang.Apply(tmp39, []any{lang.NewSymbol("glojure.core/aclone")}) - tmp41 := checkDerefVar(glojure_DOT_core_list) - tmp42 := lang.Apply(tmp41, []any{lang.NewSymbol("a__0__auto__")}) + tmp36 := checkDerefVar(var_glojure_DOT_core_list) + tmp37 := checkDerefVar(var_glojure_DOT_core_seq) + tmp38 := checkDerefVar(var_glojure_DOT_core_concat) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := lang.Apply(tmp39, []any{sym_glojure_DOT_core_SLASH_aclone}) + tmp41 := checkDerefVar(var_glojure_DOT_core_list) + tmp42 := lang.Apply(tmp41, []any{sym_a__0__auto__}) tmp43 := lang.Apply(tmp38, []any{tmp40, tmp42}) tmp44 := lang.Apply(tmp37, []any{tmp43}) tmp45 := lang.Apply(tmp36, []any{tmp44}) @@ -6627,71 +7756,71 @@ func LoadNS() { tmp47 := lang.Apply(tmp16, []any{tmp46}) tmp48 := lang.Apply(tmp14, []any{tmp15, tmp47}) tmp49 := lang.Apply(tmp13, []any{tmp48}) - tmp50 := checkDerefVar(glojure_DOT_core_list) - tmp51 := checkDerefVar(glojure_DOT_core_seq) - tmp52 := checkDerefVar(glojure_DOT_core_concat) - tmp53 := checkDerefVar(glojure_DOT_core_list) - tmp54 := lang.Apply(tmp53, []any{lang.NewSymbol("glojure.core/loop")}) - tmp55 := checkDerefVar(glojure_DOT_core_list) - tmp56 := checkDerefVar(glojure_DOT_core_apply) - tmp57 := checkDerefVar(glojure_DOT_core_vector) - tmp58 := checkDerefVar(glojure_DOT_core_seq) - tmp59 := checkDerefVar(glojure_DOT_core_concat) - tmp60 := checkDerefVar(glojure_DOT_core_list) + tmp50 := checkDerefVar(var_glojure_DOT_core_list) + tmp51 := checkDerefVar(var_glojure_DOT_core_seq) + tmp52 := checkDerefVar(var_glojure_DOT_core_concat) + tmp53 := checkDerefVar(var_glojure_DOT_core_list) + tmp54 := lang.Apply(tmp53, []any{sym_glojure_DOT_core_SLASH_loop}) + tmp55 := checkDerefVar(var_glojure_DOT_core_list) + tmp56 := checkDerefVar(var_glojure_DOT_core_apply) + tmp57 := checkDerefVar(var_glojure_DOT_core_vector) + tmp58 := checkDerefVar(var_glojure_DOT_core_seq) + tmp59 := checkDerefVar(var_glojure_DOT_core_concat) + tmp60 := checkDerefVar(var_glojure_DOT_core_list) tmp61 := lang.Apply(tmp60, []any{v6}) - tmp62 := checkDerefVar(glojure_DOT_core_list) + tmp62 := checkDerefVar(var_glojure_DOT_core_list) tmp63 := lang.Apply(tmp62, []any{int64(0)}) tmp64 := lang.Apply(tmp59, []any{tmp61, tmp63}) tmp65 := lang.Apply(tmp58, []any{tmp64}) tmp66 := lang.Apply(tmp56, []any{tmp57, tmp65}) tmp67 := lang.Apply(tmp55, []any{tmp66}) - tmp68 := checkDerefVar(glojure_DOT_core_list) - tmp69 := checkDerefVar(glojure_DOT_core_seq) - tmp70 := checkDerefVar(glojure_DOT_core_concat) - tmp71 := checkDerefVar(glojure_DOT_core_list) - tmp72 := lang.Apply(tmp71, []any{lang.NewSymbol("if")}) - tmp73 := checkDerefVar(glojure_DOT_core_list) - tmp74 := checkDerefVar(glojure_DOT_core_seq) - tmp75 := checkDerefVar(glojure_DOT_core_concat) - tmp76 := checkDerefVar(glojure_DOT_core_list) - tmp77 := lang.Apply(tmp76, []any{lang.NewSymbol("glojure.core/<")}) - tmp78 := checkDerefVar(glojure_DOT_core_list) + tmp68 := checkDerefVar(var_glojure_DOT_core_list) + tmp69 := checkDerefVar(var_glojure_DOT_core_seq) + tmp70 := checkDerefVar(var_glojure_DOT_core_concat) + tmp71 := checkDerefVar(var_glojure_DOT_core_list) + tmp72 := lang.Apply(tmp71, []any{sym_if}) + tmp73 := checkDerefVar(var_glojure_DOT_core_list) + tmp74 := checkDerefVar(var_glojure_DOT_core_seq) + tmp75 := checkDerefVar(var_glojure_DOT_core_concat) + tmp76 := checkDerefVar(var_glojure_DOT_core_list) + tmp77 := lang.Apply(tmp76, []any{sym_glojure_DOT_core_SLASH__LT_}) + tmp78 := checkDerefVar(var_glojure_DOT_core_list) tmp79 := lang.Apply(tmp78, []any{v6}) - tmp80 := checkDerefVar(glojure_DOT_core_list) - tmp81 := lang.Apply(tmp80, []any{lang.NewSymbol("l__1__auto__")}) + tmp80 := checkDerefVar(var_glojure_DOT_core_list) + tmp81 := lang.Apply(tmp80, []any{sym_l__1__auto__}) tmp82 := lang.Apply(tmp75, []any{tmp77, tmp79, tmp81}) tmp83 := lang.Apply(tmp74, []any{tmp82}) tmp84 := lang.Apply(tmp73, []any{tmp83}) - tmp85 := checkDerefVar(glojure_DOT_core_list) - tmp86 := checkDerefVar(glojure_DOT_core_seq) - tmp87 := checkDerefVar(glojure_DOT_core_concat) - tmp88 := checkDerefVar(glojure_DOT_core_list) - tmp89 := lang.Apply(tmp88, []any{lang.NewSymbol("do")}) - tmp90 := checkDerefVar(glojure_DOT_core_list) - tmp91 := checkDerefVar(glojure_DOT_core_seq) - tmp92 := checkDerefVar(glojure_DOT_core_concat) - tmp93 := checkDerefVar(glojure_DOT_core_list) - tmp94 := lang.Apply(tmp93, []any{lang.NewSymbol("glojure.core/aset")}) - tmp95 := checkDerefVar(glojure_DOT_core_list) + tmp85 := checkDerefVar(var_glojure_DOT_core_list) + tmp86 := checkDerefVar(var_glojure_DOT_core_seq) + tmp87 := checkDerefVar(var_glojure_DOT_core_concat) + tmp88 := checkDerefVar(var_glojure_DOT_core_list) + tmp89 := lang.Apply(tmp88, []any{sym_do}) + tmp90 := checkDerefVar(var_glojure_DOT_core_list) + tmp91 := checkDerefVar(var_glojure_DOT_core_seq) + tmp92 := checkDerefVar(var_glojure_DOT_core_concat) + tmp93 := checkDerefVar(var_glojure_DOT_core_list) + tmp94 := lang.Apply(tmp93, []any{sym_glojure_DOT_core_SLASH_aset}) + tmp95 := checkDerefVar(var_glojure_DOT_core_list) tmp96 := lang.Apply(tmp95, []any{v7}) - tmp97 := checkDerefVar(glojure_DOT_core_list) + tmp97 := checkDerefVar(var_glojure_DOT_core_list) tmp98 := lang.Apply(tmp97, []any{v6}) - tmp99 := checkDerefVar(glojure_DOT_core_list) + tmp99 := checkDerefVar(var_glojure_DOT_core_list) tmp100 := lang.Apply(tmp99, []any{v8}) tmp101 := lang.Apply(tmp92, []any{tmp94, tmp96, tmp98, tmp100}) tmp102 := lang.Apply(tmp91, []any{tmp101}) tmp103 := lang.Apply(tmp90, []any{tmp102}) - tmp104 := checkDerefVar(glojure_DOT_core_list) - tmp105 := checkDerefVar(glojure_DOT_core_seq) - tmp106 := checkDerefVar(glojure_DOT_core_concat) - tmp107 := checkDerefVar(glojure_DOT_core_list) - tmp108 := lang.Apply(tmp107, []any{lang.NewSymbol("recur")}) - tmp109 := checkDerefVar(glojure_DOT_core_list) - tmp110 := checkDerefVar(glojure_DOT_core_seq) - tmp111 := checkDerefVar(glojure_DOT_core_concat) - tmp112 := checkDerefVar(glojure_DOT_core_list) - tmp113 := lang.Apply(tmp112, []any{lang.NewSymbol("glojure.core/unchecked-inc")}) - tmp114 := checkDerefVar(glojure_DOT_core_list) + tmp104 := checkDerefVar(var_glojure_DOT_core_list) + tmp105 := checkDerefVar(var_glojure_DOT_core_seq) + tmp106 := checkDerefVar(var_glojure_DOT_core_concat) + tmp107 := checkDerefVar(var_glojure_DOT_core_list) + tmp108 := lang.Apply(tmp107, []any{sym_recur}) + tmp109 := checkDerefVar(var_glojure_DOT_core_list) + tmp110 := checkDerefVar(var_glojure_DOT_core_seq) + tmp111 := checkDerefVar(var_glojure_DOT_core_concat) + tmp112 := checkDerefVar(var_glojure_DOT_core_list) + tmp113 := lang.Apply(tmp112, []any{sym_glojure_DOT_core_SLASH_unchecked_DASH_inc}) + tmp114 := checkDerefVar(var_glojure_DOT_core_list) tmp115 := lang.Apply(tmp114, []any{v6}) tmp116 := lang.Apply(tmp111, []any{tmp113, tmp115}) tmp117 := lang.Apply(tmp110, []any{tmp116}) @@ -6702,7 +7831,7 @@ func LoadNS() { tmp122 := lang.Apply(tmp87, []any{tmp89, tmp103, tmp121}) tmp123 := lang.Apply(tmp86, []any{tmp122}) tmp124 := lang.Apply(tmp85, []any{tmp123}) - tmp125 := checkDerefVar(glojure_DOT_core_list) + tmp125 := checkDerefVar(var_glojure_DOT_core_list) tmp126 := lang.Apply(tmp125, []any{v7}) tmp127 := lang.Apply(tmp70, []any{tmp72, tmp84, tmp124, tmp126}) tmp128 := lang.Apply(tmp69, []any{tmp127}) @@ -6714,7 +7843,7 @@ func LoadNS() { tmp134 := lang.Apply(tmp9, []any{tmp133}) return tmp134 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -6722,15 +7851,15 @@ func LoadNS() { } // ancestors { - tmp0 := lang.NewSymbol("ancestors").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"))), lang.NewKeyword("doc"), "Returns the immediate and indirect parents of tag, either via a Java type\n inheritance relationship or a relationship established via derive. h\n must be a hierarchy obtained from make-hierarchy, if not supplied\n defaults to the global hierarchy", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5577), lang.NewKeyword("end-line"), int(5577))).(*lang.Symbol) + tmp0 := sym_ancestors.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_tag), lang.NewVector(sym_h, sym_tag)), kw_doc, "Returns the immediate and indirect parents of tag, either via a Java type\n inheritance relationship or a relationship established via derive. h\n must be a hierarchy obtained from make-hierarchy, if not supplied\n defaults to the global hierarchy", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(5577), kw_end_DASH_line, int(5577))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_ancestors) - tmp5 := checkDerefVar(glojure_DOT_core_global_hierarchy) + tmp4 := checkDerefVar(var_glojure_DOT_core_ancestors) + tmp5 := checkDerefVar(var_glojure_DOT_core_global_DASH_hierarchy) tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) return tmp6 case 2: @@ -6738,45 +7867,43 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_not_empty) + tmp5 := checkDerefVar(var_glojure_DOT_core_not_DASH_empty) var tmp6 any { // let // let binding "ta" - tmp7 := checkDerefVar(glojure_DOT_core_get) - tmp8 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) + tmp7 := checkDerefVar(var_glojure_DOT_core_get) + tmp8 := lang.Apply(kw_ancestors, []any{v3}) tmp9 := lang.Apply(tmp7, []any{tmp8, v4}) var v10 any = tmp9 _ = v10 var tmp11 any - tmp12 := checkDerefVar(glojure_DOT_core_class_QMARK_) + tmp12 := checkDerefVar(var_glojure_DOT_core_class_QMARK_) tmp13 := lang.Apply(tmp12, []any{v4}) if lang.IsTruthy(tmp13) { var tmp14 any { // let // let binding "superclasses" - tmp15 := checkDerefVar(glojure_DOT_core_set) - tmp16 := checkDerefVar(glojure_DOT_core_supers) + tmp15 := checkDerefVar(var_glojure_DOT_core_set) + tmp16 := checkDerefVar(var_glojure_DOT_core_supers) tmp17 := lang.Apply(tmp16, []any{v4}) tmp18 := lang.Apply(tmp15, []any{tmp17}) var v19 any = tmp18 _ = v19 - tmp20 := checkDerefVar(glojure_DOT_core_reduce1) - tmp21 := checkDerefVar(glojure_DOT_core_into1) - tmp22 := checkDerefVar(glojure_DOT_core_cons) - tmp23 := checkDerefVar(glojure_DOT_core_map) + tmp20 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp21 := checkDerefVar(var_glojure_DOT_core_into1) + tmp22 := checkDerefVar(var_glojure_DOT_core_cons) + tmp23 := checkDerefVar(var_glojure_DOT_core_map) var tmp24 lang.FnFunc tmp24 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v25 := args[0] _ = v25 - tmp26 := checkDerefVar(glojure_DOT_core_get) - tmp27 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) + tmp26 := checkDerefVar(var_glojure_DOT_core_get) + tmp27 := lang.Apply(kw_ancestors, []any{v3}) tmp28 := lang.Apply(tmp26, []any{tmp27, v25}) return tmp28 }) - tmp25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5590), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(5590), lang.NewKeyword("end-column"), int(54)) + tmp25 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5590), kw_column, int(32), kw_end_DASH_line, int(5590), kw_end_DASH_column, int(54)) tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) if err != nil { panic(err) @@ -6795,10 +7922,11 @@ func LoadNS() { tmp7 := lang.Apply(tmp5, []any{tmp6}) return tmp7 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -6806,7 +7934,7 @@ func LoadNS() { } // and { - tmp0 := lang.NewSymbol("and").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("next"))), lang.NewKeyword("doc"), "Evaluates exprs one at a time, from left to right. If a form\n returns logical false (nil or false), and returns that value and\n doesn't evaluate any of the other expressions, otherwise it returns\n the value of the last expr. (and) returns true.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(835), lang.NewKeyword("end-line"), int(835))).(*lang.Symbol) + tmp0 := sym_and.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_x), lang.NewVector(sym_x, sym__AMP_, sym_next)), kw_doc, "Evaluates exprs one at a time, from left to right. If a form\n returns logical false (nil or false), and returns that value and\n doesn't evaluate any of the other expressions, otherwise it returns\n the value of the last expr. (and) returns true.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(11), kw_line, int(835), kw_end_DASH_line, int(835))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -6825,9 +7953,7 @@ func LoadNS() { _ = v5 return v5 default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -6836,40 +7962,40 @@ func LoadNS() { _ = v5 var v6 any = lang.NewList(args[3:]...) _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_seq) - tmp8 := checkDerefVar(glojure_DOT_core_concat) - tmp9 := checkDerefVar(glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("glojure.core/let")}) - tmp11 := checkDerefVar(glojure_DOT_core_list) - tmp12 := checkDerefVar(glojure_DOT_core_apply) - tmp13 := checkDerefVar(glojure_DOT_core_vector) - tmp14 := checkDerefVar(glojure_DOT_core_seq) - tmp15 := checkDerefVar(glojure_DOT_core_concat) - tmp16 := checkDerefVar(glojure_DOT_core_list) - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("and__0__auto__")}) - tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_core_SLASH_let}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_apply) + tmp13 := checkDerefVar(var_glojure_DOT_core_vector) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{sym_and__0__auto__}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) tmp19 := lang.Apply(tmp18, []any{v5}) tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) tmp21 := lang.Apply(tmp14, []any{tmp20}) tmp22 := lang.Apply(tmp12, []any{tmp13, tmp21}) tmp23 := lang.Apply(tmp11, []any{tmp22}) - tmp24 := checkDerefVar(glojure_DOT_core_list) - tmp25 := checkDerefVar(glojure_DOT_core_seq) - tmp26 := checkDerefVar(glojure_DOT_core_concat) - tmp27 := checkDerefVar(glojure_DOT_core_list) - tmp28 := lang.Apply(tmp27, []any{lang.NewSymbol("if")}) - tmp29 := checkDerefVar(glojure_DOT_core_list) - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("and__0__auto__")}) - tmp31 := checkDerefVar(glojure_DOT_core_list) - tmp32 := checkDerefVar(glojure_DOT_core_seq) - tmp33 := checkDerefVar(glojure_DOT_core_concat) - tmp34 := checkDerefVar(glojure_DOT_core_list) - tmp35 := lang.Apply(tmp34, []any{lang.NewSymbol("glojure.core/and")}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := checkDerefVar(var_glojure_DOT_core_seq) + tmp26 := checkDerefVar(var_glojure_DOT_core_concat) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{sym_if}) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{sym_and__0__auto__}) + tmp31 := checkDerefVar(var_glojure_DOT_core_list) + tmp32 := checkDerefVar(var_glojure_DOT_core_seq) + tmp33 := checkDerefVar(var_glojure_DOT_core_concat) + tmp34 := checkDerefVar(var_glojure_DOT_core_list) + tmp35 := lang.Apply(tmp34, []any{sym_glojure_DOT_core_SLASH_and}) tmp36 := lang.Apply(tmp33, []any{tmp35, v6}) tmp37 := lang.Apply(tmp32, []any{tmp36}) tmp38 := lang.Apply(tmp31, []any{tmp37}) - tmp39 := checkDerefVar(glojure_DOT_core_list) - tmp40 := lang.Apply(tmp39, []any{lang.NewSymbol("and__0__auto__")}) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := lang.Apply(tmp39, []any{sym_and__0__auto__}) tmp41 := lang.Apply(tmp26, []any{tmp28, tmp30, tmp38, tmp40}) tmp42 := lang.Apply(tmp25, []any{tmp41}) tmp43 := lang.Apply(tmp24, []any{tmp42}) @@ -6878,7 +8004,7 @@ func LoadNS() { return tmp45 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -6887,18 +8013,16 @@ func LoadNS() { // any? { tmp1 := reflect.TypeOf(false) - tmp0 := lang.NewSymbol("any?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true given any argument.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(537), lang.NewKeyword("end-line"), int(537))).(*lang.Symbol) + tmp0 := sym_any_QMARK_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true given any argument.", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(537), kw_end_DASH_line, int(537))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 return true }) tmp4 := reflect.TypeOf(false) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -6906,7 +8030,7 @@ func LoadNS() { } // apply { - tmp0 := lang.NewSymbol("apply").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("z"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Applies fn f to the argument list formed by prepending intervening arguments to args.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(653), lang.NewKeyword("end-line"), int(653))).(*lang.Symbol) + tmp0 := sym_apply.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_args), lang.NewVector(sym_f, sym_x, sym_args), lang.NewVector(sym_f, sym_x, sym_y, sym_args), lang.NewVector(sym_f, sym_x, sym_y, sym_z, sym_args), lang.NewVector(sym_f, sym_a, sym_b, sym_c, sym_d, sym__AMP_, sym_args)), kw_doc, "Applies fn f to the argument list formed by prepending intervening arguments to args.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(653), kw_end_DASH_line, int(653))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -6915,7 +8039,7 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) tmp6 := lang.Apply(tmp5, []any{v4}) tmp7 := lang.Apply(lang.Apply, []any{v3, tmp6}) return tmp7 @@ -6926,7 +8050,7 @@ func LoadNS() { _ = v4 v5 := args[2] _ = v5 - tmp6 := checkDerefVar(glojure_DOT_core_list_STAR_) + tmp6 := checkDerefVar(var_glojure_DOT_core_list_STAR_) tmp7 := lang.Apply(tmp6, []any{v4, v5}) tmp8 := lang.Apply(lang.Apply, []any{v3, tmp7}) return tmp8 @@ -6939,7 +8063,7 @@ func LoadNS() { _ = v5 v6 := args[3] _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_list_STAR_) + tmp7 := checkDerefVar(var_glojure_DOT_core_list_STAR_) tmp8 := lang.Apply(tmp7, []any{v4, v5, v6}) tmp9 := lang.Apply(lang.Apply, []any{v3, tmp8}) return tmp9 @@ -6954,14 +8078,12 @@ func LoadNS() { _ = v6 v7 := args[4] _ = v7 - tmp8 := checkDerefVar(glojure_DOT_core_list_STAR_) + tmp8 := checkDerefVar(var_glojure_DOT_core_list_STAR_) tmp9 := lang.Apply(tmp8, []any{v4, v5, v6, v7}) tmp10 := lang.Apply(lang.Apply, []any{v3, tmp9}) return tmp10 default: - if len(args) < 5 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 5) v3 := args[0] _ = v3 v4 := args[1] @@ -6974,11 +8096,11 @@ func LoadNS() { _ = v7 var v8 any = lang.NewList(args[5:]...) _ = v8 - tmp9 := checkDerefVar(glojure_DOT_core_cons) - tmp10 := checkDerefVar(glojure_DOT_core_cons) - tmp11 := checkDerefVar(glojure_DOT_core_cons) - tmp12 := checkDerefVar(glojure_DOT_core_cons) - tmp13 := checkDerefVar(glojure_DOT_core_spread) + tmp9 := checkDerefVar(var_glojure_DOT_core_cons) + tmp10 := checkDerefVar(var_glojure_DOT_core_cons) + tmp11 := checkDerefVar(var_glojure_DOT_core_cons) + tmp12 := checkDerefVar(var_glojure_DOT_core_cons) + tmp13 := checkDerefVar(var_glojure_DOT_core_spread) tmp14 := lang.Apply(tmp13, []any{v8}) tmp15 := lang.Apply(tmp12, []any{v7, tmp14}) tmp16 := lang.Apply(tmp11, []any{v6, tmp15}) @@ -6988,7 +8110,7 @@ func LoadNS() { return tmp19 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -6996,12 +8118,10 @@ func LoadNS() { } // areduce { - tmp0 := lang.NewSymbol("areduce").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("idx"), lang.NewSymbol("ret"), lang.NewSymbol("init"), lang.NewSymbol("expr"))), lang.NewKeyword("doc"), "Reduces an expression across an array a, using an index named idx,\n and return value named ret, initialized to init, setting ret to the \n evaluation of expr at each step, returning ret.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5289), lang.NewKeyword("end-line"), int(5289))).(*lang.Symbol) + tmp0 := sym_areduce.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_a, sym_idx, sym_ret, sym_init, sym_expr)), kw_doc, "Reduces an expression across an array a, using an index named idx,\n and return value named ret, initialized to init, setting ret to the \n evaluation of expr at each step, returning ret.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(5289), kw_end_DASH_line, int(5289))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 7 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 7) v3 := args[0] _ = v3 v4 := args[1] @@ -7016,28 +8136,28 @@ func LoadNS() { _ = v8 v9 := args[6] _ = v9 - tmp10 := checkDerefVar(glojure_DOT_core_seq) - tmp11 := checkDerefVar(glojure_DOT_core_concat) - tmp12 := checkDerefVar(glojure_DOT_core_list) - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol("glojure.core/let")}) - tmp14 := checkDerefVar(glojure_DOT_core_list) - tmp15 := checkDerefVar(glojure_DOT_core_apply) - tmp16 := checkDerefVar(glojure_DOT_core_vector) - tmp17 := checkDerefVar(glojure_DOT_core_seq) - tmp18 := checkDerefVar(glojure_DOT_core_concat) - tmp19 := checkDerefVar(glojure_DOT_core_list) - tmp20 := lang.Apply(tmp19, []any{lang.NewSymbol("a__0__auto__")}) - tmp21 := checkDerefVar(glojure_DOT_core_list) + tmp10 := checkDerefVar(var_glojure_DOT_core_seq) + tmp11 := checkDerefVar(var_glojure_DOT_core_concat) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_glojure_DOT_core_SLASH_let}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_apply) + tmp16 := checkDerefVar(var_glojure_DOT_core_vector) + tmp17 := checkDerefVar(var_glojure_DOT_core_seq) + tmp18 := checkDerefVar(var_glojure_DOT_core_concat) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{sym_a__0__auto__}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) tmp22 := lang.Apply(tmp21, []any{v5}) - tmp23 := checkDerefVar(glojure_DOT_core_list) - tmp24 := lang.Apply(tmp23, []any{lang.NewSymbol("l__1__auto__")}) - tmp25 := checkDerefVar(glojure_DOT_core_list) - tmp26 := checkDerefVar(glojure_DOT_core_seq) - tmp27 := checkDerefVar(glojure_DOT_core_concat) - tmp28 := checkDerefVar(glojure_DOT_core_list) - tmp29 := lang.Apply(tmp28, []any{lang.NewSymbol("glojure.core/alength")}) - tmp30 := checkDerefVar(glojure_DOT_core_list) - tmp31 := lang.Apply(tmp30, []any{lang.NewSymbol("a__0__auto__")}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := lang.Apply(tmp23, []any{sym_l__1__auto__}) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := checkDerefVar(var_glojure_DOT_core_seq) + tmp27 := checkDerefVar(var_glojure_DOT_core_concat) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := lang.Apply(tmp28, []any{sym_glojure_DOT_core_SLASH_alength}) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := lang.Apply(tmp30, []any{sym_a__0__auto__}) tmp32 := lang.Apply(tmp27, []any{tmp29, tmp31}) tmp33 := lang.Apply(tmp26, []any{tmp32}) tmp34 := lang.Apply(tmp25, []any{tmp33}) @@ -7045,66 +8165,66 @@ func LoadNS() { tmp36 := lang.Apply(tmp17, []any{tmp35}) tmp37 := lang.Apply(tmp15, []any{tmp16, tmp36}) tmp38 := lang.Apply(tmp14, []any{tmp37}) - tmp39 := checkDerefVar(glojure_DOT_core_list) - tmp40 := checkDerefVar(glojure_DOT_core_seq) - tmp41 := checkDerefVar(glojure_DOT_core_concat) - tmp42 := checkDerefVar(glojure_DOT_core_list) - tmp43 := lang.Apply(tmp42, []any{lang.NewSymbol("glojure.core/loop")}) - tmp44 := checkDerefVar(glojure_DOT_core_list) - tmp45 := checkDerefVar(glojure_DOT_core_apply) - tmp46 := checkDerefVar(glojure_DOT_core_vector) - tmp47 := checkDerefVar(glojure_DOT_core_seq) - tmp48 := checkDerefVar(glojure_DOT_core_concat) - tmp49 := checkDerefVar(glojure_DOT_core_list) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := checkDerefVar(var_glojure_DOT_core_seq) + tmp41 := checkDerefVar(var_glojure_DOT_core_concat) + tmp42 := checkDerefVar(var_glojure_DOT_core_list) + tmp43 := lang.Apply(tmp42, []any{sym_glojure_DOT_core_SLASH_loop}) + tmp44 := checkDerefVar(var_glojure_DOT_core_list) + tmp45 := checkDerefVar(var_glojure_DOT_core_apply) + tmp46 := checkDerefVar(var_glojure_DOT_core_vector) + tmp47 := checkDerefVar(var_glojure_DOT_core_seq) + tmp48 := checkDerefVar(var_glojure_DOT_core_concat) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) tmp50 := lang.Apply(tmp49, []any{v6}) - tmp51 := checkDerefVar(glojure_DOT_core_list) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) tmp52 := lang.Apply(tmp51, []any{int64(0)}) - tmp53 := checkDerefVar(glojure_DOT_core_list) + tmp53 := checkDerefVar(var_glojure_DOT_core_list) tmp54 := lang.Apply(tmp53, []any{v7}) - tmp55 := checkDerefVar(glojure_DOT_core_list) + tmp55 := checkDerefVar(var_glojure_DOT_core_list) tmp56 := lang.Apply(tmp55, []any{v8}) tmp57 := lang.Apply(tmp48, []any{tmp50, tmp52, tmp54, tmp56}) tmp58 := lang.Apply(tmp47, []any{tmp57}) tmp59 := lang.Apply(tmp45, []any{tmp46, tmp58}) tmp60 := lang.Apply(tmp44, []any{tmp59}) - tmp61 := checkDerefVar(glojure_DOT_core_list) - tmp62 := checkDerefVar(glojure_DOT_core_seq) - tmp63 := checkDerefVar(glojure_DOT_core_concat) - tmp64 := checkDerefVar(glojure_DOT_core_list) - tmp65 := lang.Apply(tmp64, []any{lang.NewSymbol("if")}) - tmp66 := checkDerefVar(glojure_DOT_core_list) - tmp67 := checkDerefVar(glojure_DOT_core_seq) - tmp68 := checkDerefVar(glojure_DOT_core_concat) - tmp69 := checkDerefVar(glojure_DOT_core_list) - tmp70 := lang.Apply(tmp69, []any{lang.NewSymbol("glojure.core/<")}) - tmp71 := checkDerefVar(glojure_DOT_core_list) + tmp61 := checkDerefVar(var_glojure_DOT_core_list) + tmp62 := checkDerefVar(var_glojure_DOT_core_seq) + tmp63 := checkDerefVar(var_glojure_DOT_core_concat) + tmp64 := checkDerefVar(var_glojure_DOT_core_list) + tmp65 := lang.Apply(tmp64, []any{sym_if}) + tmp66 := checkDerefVar(var_glojure_DOT_core_list) + tmp67 := checkDerefVar(var_glojure_DOT_core_seq) + tmp68 := checkDerefVar(var_glojure_DOT_core_concat) + tmp69 := checkDerefVar(var_glojure_DOT_core_list) + tmp70 := lang.Apply(tmp69, []any{sym_glojure_DOT_core_SLASH__LT_}) + tmp71 := checkDerefVar(var_glojure_DOT_core_list) tmp72 := lang.Apply(tmp71, []any{v6}) - tmp73 := checkDerefVar(glojure_DOT_core_list) - tmp74 := lang.Apply(tmp73, []any{lang.NewSymbol("l__1__auto__")}) + tmp73 := checkDerefVar(var_glojure_DOT_core_list) + tmp74 := lang.Apply(tmp73, []any{sym_l__1__auto__}) tmp75 := lang.Apply(tmp68, []any{tmp70, tmp72, tmp74}) tmp76 := lang.Apply(tmp67, []any{tmp75}) tmp77 := lang.Apply(tmp66, []any{tmp76}) - tmp78 := checkDerefVar(glojure_DOT_core_list) - tmp79 := checkDerefVar(glojure_DOT_core_seq) - tmp80 := checkDerefVar(glojure_DOT_core_concat) - tmp81 := checkDerefVar(glojure_DOT_core_list) - tmp82 := lang.Apply(tmp81, []any{lang.NewSymbol("recur")}) - tmp83 := checkDerefVar(glojure_DOT_core_list) - tmp84 := checkDerefVar(glojure_DOT_core_seq) - tmp85 := checkDerefVar(glojure_DOT_core_concat) - tmp86 := checkDerefVar(glojure_DOT_core_list) - tmp87 := lang.Apply(tmp86, []any{lang.NewSymbol("glojure.core/unchecked-inc-int")}) - tmp88 := checkDerefVar(glojure_DOT_core_list) + tmp78 := checkDerefVar(var_glojure_DOT_core_list) + tmp79 := checkDerefVar(var_glojure_DOT_core_seq) + tmp80 := checkDerefVar(var_glojure_DOT_core_concat) + tmp81 := checkDerefVar(var_glojure_DOT_core_list) + tmp82 := lang.Apply(tmp81, []any{sym_recur}) + tmp83 := checkDerefVar(var_glojure_DOT_core_list) + tmp84 := checkDerefVar(var_glojure_DOT_core_seq) + tmp85 := checkDerefVar(var_glojure_DOT_core_concat) + tmp86 := checkDerefVar(var_glojure_DOT_core_list) + tmp87 := lang.Apply(tmp86, []any{sym_glojure_DOT_core_SLASH_unchecked_DASH_inc_DASH_int}) + tmp88 := checkDerefVar(var_glojure_DOT_core_list) tmp89 := lang.Apply(tmp88, []any{v6}) tmp90 := lang.Apply(tmp85, []any{tmp87, tmp89}) tmp91 := lang.Apply(tmp84, []any{tmp90}) tmp92 := lang.Apply(tmp83, []any{tmp91}) - tmp93 := checkDerefVar(glojure_DOT_core_list) + tmp93 := checkDerefVar(var_glojure_DOT_core_list) tmp94 := lang.Apply(tmp93, []any{v9}) tmp95 := lang.Apply(tmp80, []any{tmp82, tmp92, tmp94}) tmp96 := lang.Apply(tmp79, []any{tmp95}) tmp97 := lang.Apply(tmp78, []any{tmp96}) - tmp98 := checkDerefVar(glojure_DOT_core_list) + tmp98 := checkDerefVar(var_glojure_DOT_core_list) tmp99 := lang.Apply(tmp98, []any{v7}) tmp100 := lang.Apply(tmp63, []any{tmp65, tmp77, tmp97, tmp99}) tmp101 := lang.Apply(tmp62, []any{tmp100}) @@ -7116,7 +8236,7 @@ func LoadNS() { tmp107 := lang.Apply(tmp10, []any{tmp106}) return tmp107 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -7124,22 +8244,20 @@ func LoadNS() { } // array { - tmp0 := lang.NewSymbol("array").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3457), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3458), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("items"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym_array.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(3457), kw_column, int(7), kw_end_DASH_line, int(3458), kw_end_DASH_column, int(7), kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_items)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_into_array) + tmp4 := checkDerefVar(var_glojure_DOT_core_into_DASH_array) tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -7147,7 +8265,7 @@ func LoadNS() { } // array-map { - tmp0 := lang.NewSymbol("array-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keyvals"))), lang.NewKeyword("doc"), "Constructs an array-map. If any keys are equal, they are handled as\n if by repeated uses of assoc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4378), lang.NewKeyword("end-line"), int(4378))).(*lang.Symbol) + tmp0 := sym_array_DASH_map.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym__AMP_, sym_keyvals)), kw_doc, "Constructs an array-map. If any keys are equal, they are handled as\n if by repeated uses of assoc.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(4378), kw_end_DASH_line, int(4378))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -7165,26 +8283,24 @@ func LoadNS() { } return tmp4 default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 var tmp4 any { // let // let binding "ary" - tmp5 := checkDerefVar(glojure_DOT_core_to_array) + tmp5 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) tmp6 := lang.Apply(tmp5, []any{v3}) var v7 any = tmp6 _ = v7 var tmp8 any - tmp9 := checkDerefVar(glojure_DOT_core_odd_QMARK_) - tmp10 := checkDerefVar(glojure_DOT_core_alength) + tmp9 := checkDerefVar(var_glojure_DOT_core_odd_QMARK_) + tmp10 := checkDerefVar(var_glojure_DOT_core_alength) tmp11 := lang.Apply(tmp10, []any{v7}) tmp12 := lang.Apply(tmp9, []any{tmp11}) if lang.IsTruthy(tmp12) { - tmp13 := checkDerefVar(glojure_DOT_core_str) - tmp14 := checkDerefVar(glojure_DOT_core_last) + tmp13 := checkDerefVar(var_glojure_DOT_core_str) + tmp14 := checkDerefVar(var_glojure_DOT_core_last) tmp15 := lang.Apply(tmp14, []any{v3}) tmp16 := lang.Apply(tmp13, []any{"No value supplied for key: ", tmp15}) tmp17 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp16}) @@ -7198,7 +8314,7 @@ func LoadNS() { return tmp4 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -7206,14 +8322,12 @@ func LoadNS() { } // as-> { - tmp0 := lang.NewSymbol("as->").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "Binds name to expr, evaluates the first form in the lexical context\n of that binding, then binds name to that result, repeating for each\n successive form, returning the result of the last form.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7598), lang.NewKeyword("end-line"), int(7598))).(*lang.Symbol) + tmp0 := sym_as_DASH__GT_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_expr, sym_name, sym__AMP_, sym_forms)), kw_doc, "Binds name to expr, evaluates the first form in the lexical context\n of that binding, then binds name to that result, repeating for each\n successive form, returning the result of the last form.", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(11), kw_line, int(7598), kw_end_DASH_line, int(7598))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 4) v3 := args[0] _ = v3 v4 := args[1] @@ -7224,37 +8338,37 @@ func LoadNS() { _ = v6 var v7 any = lang.NewList(args[4:]...) _ = v7 - tmp8 := checkDerefVar(glojure_DOT_core_seq) - tmp9 := checkDerefVar(glojure_DOT_core_concat) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol("glojure.core/let")}) - tmp12 := checkDerefVar(glojure_DOT_core_list) - tmp13 := checkDerefVar(glojure_DOT_core_apply) - tmp14 := checkDerefVar(glojure_DOT_core_vector) - tmp15 := checkDerefVar(glojure_DOT_core_seq) - tmp16 := checkDerefVar(glojure_DOT_core_concat) - tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_let}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_apply) + tmp14 := checkDerefVar(var_glojure_DOT_core_vector) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) tmp18 := lang.Apply(tmp17, []any{v6}) - tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) tmp20 := lang.Apply(tmp19, []any{v5}) - tmp21 := checkDerefVar(glojure_DOT_core_interleave) - tmp22 := checkDerefVar(glojure_DOT_core_repeat) + tmp21 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp22 := checkDerefVar(var_glojure_DOT_core_repeat) tmp23 := lang.Apply(tmp22, []any{v6}) - tmp24 := checkDerefVar(glojure_DOT_core_butlast) + tmp24 := checkDerefVar(var_glojure_DOT_core_butlast) tmp25 := lang.Apply(tmp24, []any{v7}) tmp26 := lang.Apply(tmp21, []any{tmp23, tmp25}) tmp27 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp26}) tmp28 := lang.Apply(tmp15, []any{tmp27}) tmp29 := lang.Apply(tmp13, []any{tmp14, tmp28}) tmp30 := lang.Apply(tmp12, []any{tmp29}) - tmp31 := checkDerefVar(glojure_DOT_core_list) + tmp31 := checkDerefVar(var_glojure_DOT_core_list) var tmp32 any - tmp33 := checkDerefVar(glojure_DOT_core_empty_QMARK_) + tmp33 := checkDerefVar(var_glojure_DOT_core_empty_QMARK_) tmp34 := lang.Apply(tmp33, []any{v7}) if lang.IsTruthy(tmp34) { tmp32 = v6 } else { - tmp35 := checkDerefVar(glojure_DOT_core_last) + tmp35 := checkDerefVar(var_glojure_DOT_core_last) tmp36 := lang.Apply(tmp35, []any{v7}) tmp32 = tmp36 } @@ -7264,7 +8378,7 @@ func LoadNS() { return tmp39 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -7276,39 +8390,37 @@ func LoadNS() { { // function aset__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] _ = v4 v5 := args[2] _ = v5 - tmp6 := checkDerefVar(glojure_DOT_core_seq) - tmp7 := checkDerefVar(glojure_DOT_core_concat) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol(".")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - tmp12 := checkDerefVar(glojure_DOT_core_list) - tmp13 := checkDerefVar(glojure_DOT_core_seq) - tmp14 := checkDerefVar(glojure_DOT_core_concat) - tmp15 := checkDerefVar(glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("glojure.core/Aset")}) - tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym__DOT_}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_Aset}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) tmp18 := lang.Apply(tmp17, []any{v3}) - tmp19 := checkDerefVar(glojure_DOT_core_list) - tmp20 := checkDerefVar(glojure_DOT_core_seq) - tmp21 := checkDerefVar(glojure_DOT_core_concat) - tmp22 := checkDerefVar(glojure_DOT_core_list) - tmp23 := lang.Apply(tmp22, []any{lang.NewSymbol("glojure.core/int")}) - tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{sym_glojure_DOT_core_SLASH_int}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) tmp25 := lang.Apply(tmp24, []any{v4}) tmp26 := lang.Apply(tmp21, []any{tmp23, tmp25}) tmp27 := lang.Apply(tmp20, []any{tmp26}) tmp28 := lang.Apply(tmp19, []any{tmp27}) - tmp29 := checkDerefVar(glojure_DOT_core_list) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) tmp30 := lang.Apply(tmp29, []any{v5}) tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp28, tmp30}) tmp32 := lang.Apply(tmp13, []any{tmp31}) @@ -7320,7 +8432,7 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("aset").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on Java arrays of\n reference types. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(3)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3922), lang.NewKeyword("end-line"), int(3922))).(*lang.Symbol) + tmp0 := sym_aset.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx, sym_val), lang.NewVector(sym_array, sym_idx, sym_idx2, sym__AMP_, sym_idxv)), kw_inline, tmp1, kw_doc, "Sets the value at the index/indices. Works on Java arrays of\n reference types. Returns val.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(3)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3922), kw_end_DASH_line, int(3922))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -7335,9 +8447,7 @@ func LoadNS() { _ = tmp7 return v6 default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v4 := args[0] _ = v4 v5 := args[1] @@ -7346,15 +8456,15 @@ func LoadNS() { _ = v6 var v7 any = lang.NewList(args[3:]...) _ = v7 - tmp8 := checkDerefVar(glojure_DOT_core_apply) - tmp9 := checkDerefVar(glojure_DOT_core_aset) - tmp10 := checkDerefVar(glojure_DOT_core_aget) + tmp8 := checkDerefVar(var_glojure_DOT_core_apply) + tmp9 := checkDerefVar(var_glojure_DOT_core_aset) + tmp10 := checkDerefVar(var_glojure_DOT_core_aget) tmp11 := lang.Apply(tmp10, []any{v4, v5}) tmp12 := lang.Apply(tmp8, []any{tmp9, tmp11, v6, v7}) return tmp12 } }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -7362,7 +8472,7 @@ func LoadNS() { } // aset-boolean { - tmp0 := lang.NewSymbol("aset-boolean").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of boolean. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3956), lang.NewKeyword("end-line"), int(3958))).(*lang.Symbol) + tmp0 := sym_aset_DASH_boolean.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx, sym_val), lang.NewVector(sym_array, sym_idx, sym_idx2, sym__AMP_, sym_idxv)), kw_doc, "Sets the value at the index/indices. Works on arrays of boolean. Returns val.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(3), kw_line, int(3956), kw_end_DASH_line, int(3958))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -7373,7 +8483,7 @@ func LoadNS() { _ = v4 v5 := args[2] _ = v5 - tmp6 := checkDerefVar(glojure_DOT_core_boolean) + tmp6 := checkDerefVar(var_glojure_DOT_core_boolean) tmp7 := lang.Apply(tmp6, []any{v5}) tmp8, _ := lang.FieldOrMethod(nil, "setBoolean") if reflect.TypeOf(tmp8).Kind() != reflect.Func { @@ -7383,9 +8493,7 @@ func LoadNS() { _ = tmp9 return v5 default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -7394,15 +8502,15 @@ func LoadNS() { _ = v5 var v6 any = lang.NewList(args[3:]...) _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_apply) - tmp8 := checkDerefVar(glojure_DOT_core_aset_boolean) - tmp9 := checkDerefVar(glojure_DOT_core_aget) + tmp7 := checkDerefVar(var_glojure_DOT_core_apply) + tmp8 := checkDerefVar(var_glojure_DOT_core_aset_DASH_boolean) + tmp9 := checkDerefVar(var_glojure_DOT_core_aget) tmp10 := lang.Apply(tmp9, []any{v3, v4}) tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v5, v6}) return tmp11 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -7410,7 +8518,7 @@ func LoadNS() { } // aset-byte { - tmp0 := lang.NewSymbol("aset-byte").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of byte. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3976), lang.NewKeyword("end-line"), int(3978))).(*lang.Symbol) + tmp0 := sym_aset_DASH_byte.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx, sym_val), lang.NewVector(sym_array, sym_idx, sym_idx2, sym__AMP_, sym_idxv)), kw_doc, "Sets the value at the index/indices. Works on arrays of byte. Returns val.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(3), kw_line, int(3976), kw_end_DASH_line, int(3978))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -7421,7 +8529,7 @@ func LoadNS() { _ = v4 v5 := args[2] _ = v5 - tmp6 := checkDerefVar(glojure_DOT_core_byte) + tmp6 := checkDerefVar(var_glojure_DOT_core_byte) tmp7 := lang.Apply(tmp6, []any{v5}) tmp8, _ := lang.FieldOrMethod(nil, "setByte") if reflect.TypeOf(tmp8).Kind() != reflect.Func { @@ -7431,9 +8539,7 @@ func LoadNS() { _ = tmp9 return v5 default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -7442,15 +8548,15 @@ func LoadNS() { _ = v5 var v6 any = lang.NewList(args[3:]...) _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_apply) - tmp8 := checkDerefVar(glojure_DOT_core_aset_byte) - tmp9 := checkDerefVar(glojure_DOT_core_aget) + tmp7 := checkDerefVar(var_glojure_DOT_core_apply) + tmp8 := checkDerefVar(var_glojure_DOT_core_aset_DASH_byte) + tmp9 := checkDerefVar(var_glojure_DOT_core_aget) tmp10 := lang.Apply(tmp9, []any{v3, v4}) tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v5, v6}) return tmp11 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -7458,7 +8564,7 @@ func LoadNS() { } // aset-char { - tmp0 := lang.NewSymbol("aset-char").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of char. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3981), lang.NewKeyword("end-line"), int(3983))).(*lang.Symbol) + tmp0 := sym_aset_DASH_char.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx, sym_val), lang.NewVector(sym_array, sym_idx, sym_idx2, sym__AMP_, sym_idxv)), kw_doc, "Sets the value at the index/indices. Works on arrays of char. Returns val.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(3), kw_line, int(3981), kw_end_DASH_line, int(3983))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -7469,7 +8575,7 @@ func LoadNS() { _ = v4 v5 := args[2] _ = v5 - tmp6 := checkDerefVar(glojure_DOT_core_char) + tmp6 := checkDerefVar(var_glojure_DOT_core_char) tmp7 := lang.Apply(tmp6, []any{v5}) tmp8, _ := lang.FieldOrMethod(nil, "setChar") if reflect.TypeOf(tmp8).Kind() != reflect.Func { @@ -7479,9 +8585,7 @@ func LoadNS() { _ = tmp9 return v5 default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -7490,15 +8594,15 @@ func LoadNS() { _ = v5 var v6 any = lang.NewList(args[3:]...) _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_apply) - tmp8 := checkDerefVar(glojure_DOT_core_aset_char) - tmp9 := checkDerefVar(glojure_DOT_core_aget) + tmp7 := checkDerefVar(var_glojure_DOT_core_apply) + tmp8 := checkDerefVar(var_glojure_DOT_core_aset_DASH_char) + tmp9 := checkDerefVar(var_glojure_DOT_core_aget) tmp10 := lang.Apply(tmp9, []any{v3, v4}) tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v5, v6}) return tmp11 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -7506,7 +8610,7 @@ func LoadNS() { } // aset-double { - tmp0 := lang.NewSymbol("aset-double").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of double. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3966), lang.NewKeyword("end-line"), int(3968))).(*lang.Symbol) + tmp0 := sym_aset_DASH_double.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx, sym_val), lang.NewVector(sym_array, sym_idx, sym_idx2, sym__AMP_, sym_idxv)), kw_doc, "Sets the value at the index/indices. Works on arrays of double. Returns val.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(3), kw_line, int(3966), kw_end_DASH_line, int(3968))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -7517,7 +8621,7 @@ func LoadNS() { _ = v4 v5 := args[2] _ = v5 - tmp6 := checkDerefVar(glojure_DOT_core_double) + tmp6 := checkDerefVar(var_glojure_DOT_core_double) tmp7 := lang.Apply(tmp6, []any{v5}) tmp8, _ := lang.FieldOrMethod(nil, "setDouble") if reflect.TypeOf(tmp8).Kind() != reflect.Func { @@ -7527,9 +8631,7 @@ func LoadNS() { _ = tmp9 return v5 default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -7538,15 +8640,15 @@ func LoadNS() { _ = v5 var v6 any = lang.NewList(args[3:]...) _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_apply) - tmp8 := checkDerefVar(glojure_DOT_core_aset_double) - tmp9 := checkDerefVar(glojure_DOT_core_aget) + tmp7 := checkDerefVar(var_glojure_DOT_core_apply) + tmp8 := checkDerefVar(var_glojure_DOT_core_aset_DASH_double) + tmp9 := checkDerefVar(var_glojure_DOT_core_aget) tmp10 := lang.Apply(tmp9, []any{v3, v4}) tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v5, v6}) return tmp11 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -7554,7 +8656,7 @@ func LoadNS() { } // aset-float { - tmp0 := lang.NewSymbol("aset-float").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of float. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3961), lang.NewKeyword("end-line"), int(3963))).(*lang.Symbol) + tmp0 := sym_aset_DASH_float.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx, sym_val), lang.NewVector(sym_array, sym_idx, sym_idx2, sym__AMP_, sym_idxv)), kw_doc, "Sets the value at the index/indices. Works on arrays of float. Returns val.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(3), kw_line, int(3961), kw_end_DASH_line, int(3963))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -7565,7 +8667,7 @@ func LoadNS() { _ = v4 v5 := args[2] _ = v5 - tmp6 := checkDerefVar(glojure_DOT_core_float) + tmp6 := checkDerefVar(var_glojure_DOT_core_float) tmp7 := lang.Apply(tmp6, []any{v5}) tmp8, _ := lang.FieldOrMethod(nil, "setFloat") if reflect.TypeOf(tmp8).Kind() != reflect.Func { @@ -7575,9 +8677,7 @@ func LoadNS() { _ = tmp9 return v5 default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -7586,15 +8686,15 @@ func LoadNS() { _ = v5 var v6 any = lang.NewList(args[3:]...) _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_apply) - tmp8 := checkDerefVar(glojure_DOT_core_aset_float) - tmp9 := checkDerefVar(glojure_DOT_core_aget) + tmp7 := checkDerefVar(var_glojure_DOT_core_apply) + tmp8 := checkDerefVar(var_glojure_DOT_core_aset_DASH_float) + tmp9 := checkDerefVar(var_glojure_DOT_core_aget) tmp10 := lang.Apply(tmp9, []any{v3, v4}) tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v5, v6}) return tmp11 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -7602,7 +8702,7 @@ func LoadNS() { } // aset-int { - tmp0 := lang.NewSymbol("aset-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of int. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3946), lang.NewKeyword("end-line"), int(3948))).(*lang.Symbol) + tmp0 := sym_aset_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx, sym_val), lang.NewVector(sym_array, sym_idx, sym_idx2, sym__AMP_, sym_idxv)), kw_doc, "Sets the value at the index/indices. Works on arrays of int. Returns val.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(3), kw_line, int(3946), kw_end_DASH_line, int(3948))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -7613,7 +8713,7 @@ func LoadNS() { _ = v4 v5 := args[2] _ = v5 - tmp6 := checkDerefVar(glojure_DOT_core_int) + tmp6 := checkDerefVar(var_glojure_DOT_core_int) tmp7 := lang.Apply(tmp6, []any{v5}) tmp8, _ := lang.FieldOrMethod(nil, "setInt") if reflect.TypeOf(tmp8).Kind() != reflect.Func { @@ -7623,9 +8723,7 @@ func LoadNS() { _ = tmp9 return v5 default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -7634,15 +8732,15 @@ func LoadNS() { _ = v5 var v6 any = lang.NewList(args[3:]...) _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_apply) - tmp8 := checkDerefVar(glojure_DOT_core_aset_int) - tmp9 := checkDerefVar(glojure_DOT_core_aget) + tmp7 := checkDerefVar(var_glojure_DOT_core_apply) + tmp8 := checkDerefVar(var_glojure_DOT_core_aset_DASH_int) + tmp9 := checkDerefVar(var_glojure_DOT_core_aget) tmp10 := lang.Apply(tmp9, []any{v3, v4}) tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v5, v6}) return tmp11 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -7650,7 +8748,7 @@ func LoadNS() { } // aset-long { - tmp0 := lang.NewSymbol("aset-long").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of long. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3951), lang.NewKeyword("end-line"), int(3953))).(*lang.Symbol) + tmp0 := sym_aset_DASH_long.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx, sym_val), lang.NewVector(sym_array, sym_idx, sym_idx2, sym__AMP_, sym_idxv)), kw_doc, "Sets the value at the index/indices. Works on arrays of long. Returns val.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(3), kw_line, int(3951), kw_end_DASH_line, int(3953))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -7661,7 +8759,7 @@ func LoadNS() { _ = v4 v5 := args[2] _ = v5 - tmp6 := checkDerefVar(glojure_DOT_core_long) + tmp6 := checkDerefVar(var_glojure_DOT_core_long) tmp7 := lang.Apply(tmp6, []any{v5}) tmp8, _ := lang.FieldOrMethod(nil, "setLong") if reflect.TypeOf(tmp8).Kind() != reflect.Func { @@ -7671,9 +8769,7 @@ func LoadNS() { _ = tmp9 return v5 default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -7682,15 +8778,15 @@ func LoadNS() { _ = v5 var v6 any = lang.NewList(args[3:]...) _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_apply) - tmp8 := checkDerefVar(glojure_DOT_core_aset_long) - tmp9 := checkDerefVar(glojure_DOT_core_aget) + tmp7 := checkDerefVar(var_glojure_DOT_core_apply) + tmp8 := checkDerefVar(var_glojure_DOT_core_aset_DASH_long) + tmp9 := checkDerefVar(var_glojure_DOT_core_aget) tmp10 := lang.Apply(tmp9, []any{v3, v4}) tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v5, v6}) return tmp11 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -7698,7 +8794,7 @@ func LoadNS() { } // aset-short { - tmp0 := lang.NewSymbol("aset-short").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("array"), lang.NewSymbol("idx"), lang.NewSymbol("idx2"), lang.NewSymbol("&"), lang.NewSymbol("idxv"))), lang.NewKeyword("doc"), "Sets the value at the index/indices. Works on arrays of short. Returns val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3971), lang.NewKeyword("end-line"), int(3973))).(*lang.Symbol) + tmp0 := sym_aset_DASH_short.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx, sym_val), lang.NewVector(sym_array, sym_idx, sym_idx2, sym__AMP_, sym_idxv)), kw_doc, "Sets the value at the index/indices. Works on arrays of short. Returns val.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(3), kw_line, int(3971), kw_end_DASH_line, int(3973))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -7709,7 +8805,7 @@ func LoadNS() { _ = v4 v5 := args[2] _ = v5 - tmp6 := checkDerefVar(glojure_DOT_core_short) + tmp6 := checkDerefVar(var_glojure_DOT_core_short) tmp7 := lang.Apply(tmp6, []any{v5}) tmp8, _ := lang.FieldOrMethod(nil, "setShort") if reflect.TypeOf(tmp8).Kind() != reflect.Func { @@ -7719,9 +8815,7 @@ func LoadNS() { _ = tmp9 return v5 default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -7730,15 +8824,15 @@ func LoadNS() { _ = v5 var v6 any = lang.NewList(args[3:]...) _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_apply) - tmp8 := checkDerefVar(glojure_DOT_core_aset_short) - tmp9 := checkDerefVar(glojure_DOT_core_aget) + tmp7 := checkDerefVar(var_glojure_DOT_core_apply) + tmp8 := checkDerefVar(var_glojure_DOT_core_aset_DASH_short) + tmp9 := checkDerefVar(var_glojure_DOT_core_aget) tmp10 := lang.Apply(tmp9, []any{v3, v4}) tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v5, v6}) return tmp11 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -7746,7 +8840,7 @@ func LoadNS() { } // assert { - tmp0 := lang.NewSymbol("assert").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("message"))), lang.NewKeyword("doc"), "Evaluates expression x and throws an AssertionError with optional\n message if x does not evaluate to logical true.\n\n Assertion checks are omitted from compiled code if '*assert*' is\n false.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4837), lang.NewKeyword("end-line"), int(4837))).(*lang.Symbol) + tmp0 := sym_assert.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_message)), kw_doc, "Evaluates expression x and throws an AssertionError with optional\n message if x does not evaluate to logical true.\n\n Assertion checks are omitted from compiled code if '*assert*' is\n false.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(11), kw_line, int(4837), kw_end_DASH_line, int(4837))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -7758,44 +8852,44 @@ func LoadNS() { v5 := args[2] _ = v5 var tmp6 any - tmp7 := checkDerefVar(glojure_DOT_core__STAR_assert_STAR_) + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_assert_STAR_) if lang.IsTruthy(tmp7) { - tmp8 := checkDerefVar(glojure_DOT_core_seq) - tmp9 := checkDerefVar(glojure_DOT_core_concat) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol("glojure.core/when-not")}) - tmp12 := checkDerefVar(glojure_DOT_core_list) + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_when_DASH_not}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := lang.Apply(tmp12, []any{v5}) - tmp14 := checkDerefVar(glojure_DOT_core_list) - tmp15 := checkDerefVar(glojure_DOT_core_seq) - tmp16 := checkDerefVar(glojure_DOT_core_concat) - tmp17 := checkDerefVar(glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("throw")}) - tmp19 := checkDerefVar(glojure_DOT_core_list) - tmp20 := checkDerefVar(glojure_DOT_core_seq) - tmp21 := checkDerefVar(glojure_DOT_core_concat) - tmp22 := checkDerefVar(glojure_DOT_core_list) - tmp23 := lang.Apply(tmp22, []any{lang.NewSymbol("new")}) - tmp24 := checkDerefVar(glojure_DOT_core_list) - tmp25 := lang.Apply(tmp24, []any{lang.NewSymbol("glojure.core/AssertionError")}) - tmp26 := checkDerefVar(glojure_DOT_core_list) - tmp27 := checkDerefVar(glojure_DOT_core_seq) - tmp28 := checkDerefVar(glojure_DOT_core_concat) - tmp29 := checkDerefVar(glojure_DOT_core_list) - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/str")}) - tmp31 := checkDerefVar(glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_throw}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{sym_new}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{sym_glojure_DOT_core_SLASH_AssertionError}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := checkDerefVar(var_glojure_DOT_core_seq) + tmp28 := checkDerefVar(var_glojure_DOT_core_concat) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{sym_glojure_DOT_core_SLASH_str}) + tmp31 := checkDerefVar(var_glojure_DOT_core_list) tmp32 := lang.Apply(tmp31, []any{"Assert failed: "}) - tmp33 := checkDerefVar(glojure_DOT_core_list) - tmp34 := checkDerefVar(glojure_DOT_core_seq) - tmp35 := checkDerefVar(glojure_DOT_core_concat) - tmp36 := checkDerefVar(glojure_DOT_core_list) - tmp37 := lang.Apply(tmp36, []any{lang.NewSymbol("glojure.core/pr-str")}) - tmp38 := checkDerefVar(glojure_DOT_core_list) - tmp39 := checkDerefVar(glojure_DOT_core_seq) - tmp40 := checkDerefVar(glojure_DOT_core_concat) - tmp41 := checkDerefVar(glojure_DOT_core_list) - tmp42 := lang.Apply(tmp41, []any{lang.NewSymbol("quote")}) - tmp43 := checkDerefVar(glojure_DOT_core_list) + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := checkDerefVar(var_glojure_DOT_core_seq) + tmp35 := checkDerefVar(var_glojure_DOT_core_concat) + tmp36 := checkDerefVar(var_glojure_DOT_core_list) + tmp37 := lang.Apply(tmp36, []any{sym_glojure_DOT_core_SLASH_pr_DASH_str}) + tmp38 := checkDerefVar(var_glojure_DOT_core_list) + tmp39 := checkDerefVar(var_glojure_DOT_core_seq) + tmp40 := checkDerefVar(var_glojure_DOT_core_concat) + tmp41 := checkDerefVar(var_glojure_DOT_core_list) + tmp42 := lang.Apply(tmp41, []any{sym_quote}) + tmp43 := checkDerefVar(var_glojure_DOT_core_list) tmp44 := lang.Apply(tmp43, []any{v5}) tmp45 := lang.Apply(tmp40, []any{tmp42, tmp44}) tmp46 := lang.Apply(tmp39, []any{tmp45}) @@ -7828,48 +8922,48 @@ func LoadNS() { v6 := args[3] _ = v6 var tmp7 any - tmp8 := checkDerefVar(glojure_DOT_core__STAR_assert_STAR_) + tmp8 := checkDerefVar(var_glojure_DOT_core__STAR_assert_STAR_) if lang.IsTruthy(tmp8) { - tmp9 := checkDerefVar(glojure_DOT_core_seq) - tmp10 := checkDerefVar(glojure_DOT_core_concat) - tmp11 := checkDerefVar(glojure_DOT_core_list) - tmp12 := lang.Apply(tmp11, []any{lang.NewSymbol("glojure.core/when-not")}) - tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp9 := checkDerefVar(var_glojure_DOT_core_seq) + tmp10 := checkDerefVar(var_glojure_DOT_core_concat) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_glojure_DOT_core_SLASH_when_DASH_not}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) tmp14 := lang.Apply(tmp13, []any{v5}) - tmp15 := checkDerefVar(glojure_DOT_core_list) - tmp16 := checkDerefVar(glojure_DOT_core_seq) - tmp17 := checkDerefVar(glojure_DOT_core_concat) - tmp18 := checkDerefVar(glojure_DOT_core_list) - tmp19 := lang.Apply(tmp18, []any{lang.NewSymbol("throw")}) - tmp20 := checkDerefVar(glojure_DOT_core_list) - tmp21 := checkDerefVar(glojure_DOT_core_seq) - tmp22 := checkDerefVar(glojure_DOT_core_concat) - tmp23 := checkDerefVar(glojure_DOT_core_list) - tmp24 := lang.Apply(tmp23, []any{lang.NewSymbol("new")}) - tmp25 := checkDerefVar(glojure_DOT_core_list) - tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol("glojure.core/AssertionError")}) - tmp27 := checkDerefVar(glojure_DOT_core_list) - tmp28 := checkDerefVar(glojure_DOT_core_seq) - tmp29 := checkDerefVar(glojure_DOT_core_concat) - tmp30 := checkDerefVar(glojure_DOT_core_list) - tmp31 := lang.Apply(tmp30, []any{lang.NewSymbol("glojure.core/str")}) - tmp32 := checkDerefVar(glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := checkDerefVar(var_glojure_DOT_core_seq) + tmp17 := checkDerefVar(var_glojure_DOT_core_concat) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{sym_throw}) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := checkDerefVar(var_glojure_DOT_core_seq) + tmp22 := checkDerefVar(var_glojure_DOT_core_concat) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := lang.Apply(tmp23, []any{sym_new}) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := lang.Apply(tmp25, []any{sym_glojure_DOT_core_SLASH_AssertionError}) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := checkDerefVar(var_glojure_DOT_core_seq) + tmp29 := checkDerefVar(var_glojure_DOT_core_concat) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := lang.Apply(tmp30, []any{sym_glojure_DOT_core_SLASH_str}) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) tmp33 := lang.Apply(tmp32, []any{"Assert failed: "}) - tmp34 := checkDerefVar(glojure_DOT_core_list) + tmp34 := checkDerefVar(var_glojure_DOT_core_list) tmp35 := lang.Apply(tmp34, []any{v6}) - tmp36 := checkDerefVar(glojure_DOT_core_list) + tmp36 := checkDerefVar(var_glojure_DOT_core_list) tmp37 := lang.Apply(tmp36, []any{"\n"}) - tmp38 := checkDerefVar(glojure_DOT_core_list) - tmp39 := checkDerefVar(glojure_DOT_core_seq) - tmp40 := checkDerefVar(glojure_DOT_core_concat) - tmp41 := checkDerefVar(glojure_DOT_core_list) - tmp42 := lang.Apply(tmp41, []any{lang.NewSymbol("glojure.core/pr-str")}) - tmp43 := checkDerefVar(glojure_DOT_core_list) - tmp44 := checkDerefVar(glojure_DOT_core_seq) - tmp45 := checkDerefVar(glojure_DOT_core_concat) - tmp46 := checkDerefVar(glojure_DOT_core_list) - tmp47 := lang.Apply(tmp46, []any{lang.NewSymbol("quote")}) - tmp48 := checkDerefVar(glojure_DOT_core_list) + tmp38 := checkDerefVar(var_glojure_DOT_core_list) + tmp39 := checkDerefVar(var_glojure_DOT_core_seq) + tmp40 := checkDerefVar(var_glojure_DOT_core_concat) + tmp41 := checkDerefVar(var_glojure_DOT_core_list) + tmp42 := lang.Apply(tmp41, []any{sym_glojure_DOT_core_SLASH_pr_DASH_str}) + tmp43 := checkDerefVar(var_glojure_DOT_core_list) + tmp44 := checkDerefVar(var_glojure_DOT_core_seq) + tmp45 := checkDerefVar(var_glojure_DOT_core_concat) + tmp46 := checkDerefVar(var_glojure_DOT_core_list) + tmp47 := lang.Apply(tmp46, []any{sym_quote}) + tmp48 := checkDerefVar(var_glojure_DOT_core_list) tmp49 := lang.Apply(tmp48, []any{v5}) tmp50 := lang.Apply(tmp45, []any{tmp47, tmp49}) tmp51 := lang.Apply(tmp44, []any{tmp50}) @@ -7893,10 +8987,11 @@ func LoadNS() { } return tmp7 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -7904,82 +8999,80 @@ func LoadNS() { } // assert-args { - tmp0 := lang.NewSymbol("assert-args").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("pairs"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(38), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1830), lang.NewKeyword("end-line"), int(1830), lang.NewKeyword("private"), true)).(*lang.Symbol) + tmp0 := sym_assert_DASH_args.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_pairs)), kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(38), kw_column, int(11), kw_line, int(1830), kw_end_DASH_line, int(1830), kw_private, true)).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 var v5 any = lang.NewList(args[2:]...) _ = v5 - tmp6 := checkDerefVar(glojure_DOT_core_seq) - tmp7 := checkDerefVar(glojure_DOT_core_concat) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("do")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := checkDerefVar(glojure_DOT_core_seq) - tmp12 := checkDerefVar(glojure_DOT_core_concat) - tmp13 := checkDerefVar(glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/when-not")}) - tmp15 := checkDerefVar(glojure_DOT_core_list) - tmp16 := checkDerefVar(glojure_DOT_core_first) + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_do}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_when_DASH_not}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := checkDerefVar(var_glojure_DOT_core_first) tmp17 := lang.Apply(tmp16, []any{v5}) tmp18 := lang.Apply(tmp15, []any{tmp17}) - tmp19 := checkDerefVar(glojure_DOT_core_list) - tmp20 := checkDerefVar(glojure_DOT_core_seq) - tmp21 := checkDerefVar(glojure_DOT_core_concat) - tmp22 := checkDerefVar(glojure_DOT_core_list) - tmp23 := lang.Apply(tmp22, []any{lang.NewSymbol("throw")}) - tmp24 := checkDerefVar(glojure_DOT_core_list) - tmp25 := checkDerefVar(glojure_DOT_core_seq) - tmp26 := checkDerefVar(glojure_DOT_core_concat) - tmp27 := checkDerefVar(glojure_DOT_core_list) - tmp28 := lang.Apply(tmp27, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewIllegalArgumentError")}) - tmp29 := checkDerefVar(glojure_DOT_core_list) - tmp30 := checkDerefVar(glojure_DOT_core_seq) - tmp31 := checkDerefVar(glojure_DOT_core_concat) - tmp32 := checkDerefVar(glojure_DOT_core_list) - tmp33 := lang.Apply(tmp32, []any{lang.NewSymbol("glojure.core/str")}) - tmp34 := checkDerefVar(glojure_DOT_core_list) - tmp35 := checkDerefVar(glojure_DOT_core_seq) - tmp36 := checkDerefVar(glojure_DOT_core_concat) - tmp37 := checkDerefVar(glojure_DOT_core_list) - tmp38 := lang.Apply(tmp37, []any{lang.NewSymbol("glojure.core/first")}) - tmp39 := checkDerefVar(glojure_DOT_core_list) - tmp40 := lang.Apply(tmp39, []any{lang.NewSymbol("&form")}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{sym_throw}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := checkDerefVar(var_glojure_DOT_core_seq) + tmp26 := checkDerefVar(var_glojure_DOT_core_concat) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_NewIllegalArgumentError}) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := checkDerefVar(var_glojure_DOT_core_seq) + tmp31 := checkDerefVar(var_glojure_DOT_core_concat) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := lang.Apply(tmp32, []any{sym_glojure_DOT_core_SLASH_str}) + tmp34 := checkDerefVar(var_glojure_DOT_core_list) + tmp35 := checkDerefVar(var_glojure_DOT_core_seq) + tmp36 := checkDerefVar(var_glojure_DOT_core_concat) + tmp37 := checkDerefVar(var_glojure_DOT_core_list) + tmp38 := lang.Apply(tmp37, []any{sym_glojure_DOT_core_SLASH_first}) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := lang.Apply(tmp39, []any{sym__AMP_form}) tmp41 := lang.Apply(tmp36, []any{tmp38, tmp40}) tmp42 := lang.Apply(tmp35, []any{tmp41}) tmp43 := lang.Apply(tmp34, []any{tmp42}) - tmp44 := checkDerefVar(glojure_DOT_core_list) + tmp44 := checkDerefVar(var_glojure_DOT_core_list) tmp45 := lang.Apply(tmp44, []any{" requires "}) - tmp46 := checkDerefVar(glojure_DOT_core_list) - tmp47 := checkDerefVar(glojure_DOT_core_second) + tmp46 := checkDerefVar(var_glojure_DOT_core_list) + tmp47 := checkDerefVar(var_glojure_DOT_core_second) tmp48 := lang.Apply(tmp47, []any{v5}) tmp49 := lang.Apply(tmp46, []any{tmp48}) - tmp50 := checkDerefVar(glojure_DOT_core_list) + tmp50 := checkDerefVar(var_glojure_DOT_core_list) tmp51 := lang.Apply(tmp50, []any{" in "}) - tmp52 := checkDerefVar(glojure_DOT_core_list) - tmp53 := lang.Apply(tmp52, []any{lang.NewSymbol("*ns*")}) - tmp54 := checkDerefVar(glojure_DOT_core_list) + tmp52 := checkDerefVar(var_glojure_DOT_core_list) + tmp53 := lang.Apply(tmp52, []any{sym__STAR_ns_STAR_}) + tmp54 := checkDerefVar(var_glojure_DOT_core_list) tmp55 := lang.Apply(tmp54, []any{":"}) - tmp56 := checkDerefVar(glojure_DOT_core_list) - tmp57 := checkDerefVar(glojure_DOT_core_seq) - tmp58 := checkDerefVar(glojure_DOT_core_concat) - tmp59 := checkDerefVar(glojure_DOT_core_list) - tmp60 := lang.Apply(tmp59, []any{lang.NewKeyword("line")}) - tmp61 := checkDerefVar(glojure_DOT_core_list) - tmp62 := checkDerefVar(glojure_DOT_core_seq) - tmp63 := checkDerefVar(glojure_DOT_core_concat) - tmp64 := checkDerefVar(glojure_DOT_core_list) - tmp65 := lang.Apply(tmp64, []any{lang.NewSymbol("glojure.core/meta")}) - tmp66 := checkDerefVar(glojure_DOT_core_list) - tmp67 := lang.Apply(tmp66, []any{lang.NewSymbol("&form")}) + tmp56 := checkDerefVar(var_glojure_DOT_core_list) + tmp57 := checkDerefVar(var_glojure_DOT_core_seq) + tmp58 := checkDerefVar(var_glojure_DOT_core_concat) + tmp59 := checkDerefVar(var_glojure_DOT_core_list) + tmp60 := lang.Apply(tmp59, []any{kw_line}) + tmp61 := checkDerefVar(var_glojure_DOT_core_list) + tmp62 := checkDerefVar(var_glojure_DOT_core_seq) + tmp63 := checkDerefVar(var_glojure_DOT_core_concat) + tmp64 := checkDerefVar(var_glojure_DOT_core_list) + tmp65 := lang.Apply(tmp64, []any{sym_glojure_DOT_core_SLASH_meta}) + tmp66 := checkDerefVar(var_glojure_DOT_core_list) + tmp67 := lang.Apply(tmp66, []any{sym__AMP_form}) tmp68 := lang.Apply(tmp63, []any{tmp65, tmp67}) tmp69 := lang.Apply(tmp62, []any{tmp68}) tmp70 := lang.Apply(tmp61, []any{tmp69}) @@ -7998,18 +9091,18 @@ func LoadNS() { tmp83 := lang.Apply(tmp12, []any{tmp14, tmp18, tmp82}) tmp84 := lang.Apply(tmp11, []any{tmp83}) tmp85 := lang.Apply(tmp10, []any{tmp84}) - tmp86 := checkDerefVar(glojure_DOT_core_list) + tmp86 := checkDerefVar(var_glojure_DOT_core_list) var tmp87 any { // let // let binding "more" - tmp88 := checkDerefVar(glojure_DOT_core_nnext) + tmp88 := checkDerefVar(var_glojure_DOT_core_nnext) tmp89 := lang.Apply(tmp88, []any{v5}) var v90 any = tmp89 _ = v90 var tmp91 any if lang.IsTruthy(v90) { - tmp92 := checkDerefVar(glojure_DOT_core_list_STAR_) - tmp93 := lang.Apply(tmp92, []any{lang.NewSymbol("glojure.core/assert-args"), v90}) + tmp92 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp93 := lang.Apply(tmp92, []any{sym_glojure_DOT_core_SLASH_assert_DASH_args, v90}) tmp91 = tmp93 } else { } @@ -8021,7 +9114,7 @@ func LoadNS() { return tmp90 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -8029,16 +9122,14 @@ func LoadNS() { } // assert-valid-fdecl { - tmp0 := lang.NewSymbol("assert-valid-fdecl").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fdecl"))), lang.NewKeyword("doc"), "A good fdecl looks like (([a] ...) ([a b] ...)) near the end of defn.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(42), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(7502), lang.NewKeyword("end-line"), int(7502), lang.NewKeyword("private"), true, lang.NewKeyword("dynamic"), true)).(*lang.Symbol) + tmp0 := sym_assert_DASH_valid_DASH_fdecl.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_fdecl)), kw_doc, "A good fdecl looks like (([a] ...) ([a b] ...)) near the end of defn.", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(42), kw_column, int(8), kw_line, int(7502), kw_end_DASH_line, int(7502), kw_private, true, kw_dynamic, true)).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any - tmp5 := checkDerefVar(glojure_DOT_core_empty_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_empty_QMARK_) tmp6 := lang.Apply(tmp5, []any{v3}) if lang.IsTruthy(tmp6) { tmp7 := lang.Apply(lang.NewIllegalArgumentError, []any{"Parameter declaration missing"}) @@ -8049,33 +9140,31 @@ func LoadNS() { var tmp8 any { // let // let binding "argdecls" - tmp9 := checkDerefVar(glojure_DOT_core_map) + tmp9 := checkDerefVar(var_glojure_DOT_core_map) var tmp10 lang.FnFunc tmp10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v11 := args[0] _ = v11 var tmp12 any - tmp13 := checkDerefVar(glojure_DOT_core_seq_QMARK_) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) tmp14 := lang.Apply(tmp13, []any{v11}) if lang.IsTruthy(tmp14) { - tmp15 := checkDerefVar(glojure_DOT_core_first) + tmp15 := checkDerefVar(var_glojure_DOT_core_first) tmp16 := lang.Apply(tmp15, []any{v11}) tmp12 = tmp16 } else { var tmp17 any - tmp18 := checkDerefVar(glojure_DOT_core_seq_QMARK_) - tmp19 := checkDerefVar(glojure_DOT_core_first) + tmp18 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp19 := checkDerefVar(var_glojure_DOT_core_first) tmp20 := lang.Apply(tmp19, []any{v3}) tmp21 := lang.Apply(tmp18, []any{tmp20}) if lang.IsTruthy(tmp21) { - tmp22 := checkDerefVar(glojure_DOT_core_str) + tmp22 := checkDerefVar(var_glojure_DOT_core_str) tmp23 := lang.Apply(tmp22, []any{"Invalid signature \"", v11, "\" should be a list"}) tmp17 = tmp23 } else { - tmp24 := checkDerefVar(glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_str) tmp25 := lang.Apply(tmp24, []any{"Parameter declaration \"", v11, "\" should be a vector"}) tmp17 = tmp25 } @@ -8084,7 +9173,7 @@ func LoadNS() { } return tmp12 }) - tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7508), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7517), lang.NewKeyword("end-column"), int(59)) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7508), kw_column, int(20), kw_end_DASH_line, int(7517), kw_end_DASH_column, int(59)) tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) if err != nil { panic(err) @@ -8093,20 +9182,18 @@ func LoadNS() { var v14 any = tmp13 _ = v14 // let binding "bad-args" - tmp15 := checkDerefVar(glojure_DOT_core_seq) - tmp16 := checkDerefVar(glojure_DOT_core_remove) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_remove) var tmp17 lang.FnFunc tmp17 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v18 := args[0] _ = v18 - tmp19 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp19 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) tmp20 := lang.Apply(tmp19, []any{v18}) return tmp20 }) - tmp18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7519), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(7519), lang.NewKeyword("end-column"), int(42)) + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7519), kw_column, int(31), kw_end_DASH_line, int(7519), kw_end_DASH_column, int(42)) tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) if err != nil { panic(err) @@ -8117,8 +9204,8 @@ func LoadNS() { _ = v22 var tmp23 any if lang.IsTruthy(v22) { - tmp24 := checkDerefVar(glojure_DOT_core_str) - tmp25 := checkDerefVar(glojure_DOT_core_first) + tmp24 := checkDerefVar(var_glojure_DOT_core_str) + tmp25 := checkDerefVar(var_glojure_DOT_core_first) tmp26 := lang.Apply(tmp25, []any{v22}) tmp27 := lang.Apply(tmp24, []any{"Parameter declaration \"", tmp26, "\" should be a vector"}) tmp28 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp27}) @@ -8129,7 +9216,7 @@ func LoadNS() { } // end let return tmp8 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -8137,7 +9224,7 @@ func LoadNS() { } // assoc { - tmp0 := lang.NewSymbol("assoc").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"), lang.NewSymbol("val"), lang.NewSymbol("&"), lang.NewSymbol("kvs"))), lang.NewKeyword("doc"), "assoc[iate]. When applied to a map, returns a new map of the\n same (hashed/sorted) type, that contains the mapping of key(s) to\n val(s). When applied to a vector, returns a new vector that\n contains val at index. Note - index must be <= (count vector).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(181), lang.NewKeyword("end-line"), int(188))).(*lang.Symbol) + tmp0 := sym_assoc.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_map, sym_key, sym_val), lang.NewVector(sym_map, sym_key, sym_val, sym__AMP_, sym_kvs)), kw_doc, "assoc[iate]. When applied to a map, returns a new map of the\n same (hashed/sorted) type, that contains the mapping of key(s) to\n val(s). When applied to a vector, returns a new vector that\n contains val at index. Note - index must be <= (count vector).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(6), kw_column, int(2), kw_line, int(181), kw_end_DASH_line, int(188))).(*lang.Symbol) var tmp2 lang.FnFunc { // function assoc var v3 lang.FnFunc @@ -8153,9 +9240,7 @@ func LoadNS() { tmp7 := lang.Apply(lang.Assoc, []any{v4, v5, v6}) return tmp7 default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v4 := args[0] _ = v4 v5 := args[1] @@ -8174,17 +9259,17 @@ func LoadNS() { var tmp11 any if lang.IsTruthy(v7) { var tmp12 any - tmp13 := checkDerefVar(glojure_DOT_core_next) + tmp13 := checkDerefVar(var_glojure_DOT_core_next) tmp14 := lang.Apply(tmp13, []any{v7}) if lang.IsTruthy(tmp14) { var tmp15 any = v10 - tmp17 := checkDerefVar(glojure_DOT_core_first) + tmp17 := checkDerefVar(var_glojure_DOT_core_first) tmp18 := lang.Apply(tmp17, []any{v7}) var tmp16 any = tmp18 - tmp20 := checkDerefVar(glojure_DOT_core_second) + tmp20 := checkDerefVar(var_glojure_DOT_core_second) tmp21 := lang.Apply(tmp20, []any{v7}) var tmp19 any = tmp21 - tmp23 := checkDerefVar(glojure_DOT_core_nnext) + tmp23 := checkDerefVar(var_glojure_DOT_core_nnext) tmp24 := lang.Apply(tmp23, []any{v7}) var tmp22 any = tmp24 v4 = tmp15 @@ -8205,7 +9290,7 @@ func LoadNS() { return tmp8 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(189), lang.NewKeyword("column"), int(2), lang.NewKeyword("end-line"), int(198), lang.NewKeyword("end-column"), int(15))).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(189), kw_column, int(2), kw_end_DASH_line, int(198), kw_end_DASH_column, int(15))).(lang.FnFunc) v3 = tmp2 _ = v3 } @@ -8216,7 +9301,7 @@ func LoadNS() { } // assoc! { - tmp0 := lang.NewSymbol("assoc!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("key"), lang.NewSymbol("val")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("key"), lang.NewSymbol("val"), lang.NewSymbol("&"), lang.NewSymbol("kvs"))), lang.NewKeyword("doc"), "When applied to a transient map, adds mapping of key(s) to\n val(s). When applied to a transient vector, sets the val at index.\n Note - index must be <= (count vector). Returns coll.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3369), lang.NewKeyword("end-line"), int(3369))).(*lang.Symbol) + tmp0 := sym_assoc_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll, sym_key, sym_val), lang.NewVector(sym_coll, sym_key, sym_val, sym__AMP_, sym_kvs)), kw_doc, "When applied to a transient map, adds mapping of key(s) to\n val(s). When applied to a transient vector, sets the val at index.\n Note - index must be <= (count vector). Returns coll.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(3369), kw_end_DASH_line, int(3369))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -8234,9 +9319,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -8259,13 +9342,13 @@ func LoadNS() { var tmp11 any if lang.IsTruthy(v6) { var tmp12 any = v10 - tmp14 := checkDerefVar(glojure_DOT_core_first) + tmp14 := checkDerefVar(var_glojure_DOT_core_first) tmp15 := lang.Apply(tmp14, []any{v6}) var tmp13 any = tmp15 - tmp17 := checkDerefVar(glojure_DOT_core_second) + tmp17 := checkDerefVar(var_glojure_DOT_core_second) tmp18 := lang.Apply(tmp17, []any{v6}) var tmp16 any = tmp18 - tmp20 := checkDerefVar(glojure_DOT_core_nnext) + tmp20 := checkDerefVar(var_glojure_DOT_core_nnext) tmp21 := lang.Apply(tmp20, []any{v6}) var tmp19 any = tmp21 v3 = tmp12 @@ -8281,7 +9364,7 @@ func LoadNS() { return tmp7 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -8289,12 +9372,10 @@ func LoadNS() { } // assoc-in { - tmp0 := lang.NewSymbol("assoc-in").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("&"), lang.NewSymbol("ks")), lang.NewSymbol("v"))), lang.NewKeyword("doc"), "Associates a value in a nested associative structure, where ks is a\n sequence of keys and v is the new value and returns a new nested structure.\n If any levels do not exist, hash-maps will be created.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6147), lang.NewKeyword("end-line"), int(6147))).(*lang.Symbol) + tmp0 := sym_assoc_DASH_in.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m, lang.NewVector(sym_k, sym__AMP_, sym_ks), sym_v)), kw_doc, "Associates a value in a nested associative structure, where ks is a\n sequence of keys and v is the new value and returns a new nested structure.\n If any levels do not exist, hash-maps will be created.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(6147), kw_end_DASH_line, int(6147))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -8307,17 +9388,17 @@ func LoadNS() { var v7 any = v4 _ = v7 // let binding "seq__139" - tmp8 := checkDerefVar(glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) tmp9 := lang.Apply(tmp8, []any{v7}) var v10 any = tmp9 _ = v10 // let binding "first__140" - tmp11 := checkDerefVar(glojure_DOT_core_first) + tmp11 := checkDerefVar(var_glojure_DOT_core_first) tmp12 := lang.Apply(tmp11, []any{v10}) var v13 any = tmp12 _ = v13 // let binding "seq__139" - tmp14 := checkDerefVar(glojure_DOT_core_next) + tmp14 := checkDerefVar(var_glojure_DOT_core_next) tmp15 := lang.Apply(tmp14, []any{v10}) var v16 any = tmp15 _ = v16 @@ -8329,15 +9410,15 @@ func LoadNS() { _ = v18 var tmp19 any if lang.IsTruthy(v18) { - tmp20 := checkDerefVar(glojure_DOT_core_assoc) - tmp21 := checkDerefVar(glojure_DOT_core_assoc_in) - tmp22 := checkDerefVar(glojure_DOT_core_get) + tmp20 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp21 := checkDerefVar(var_glojure_DOT_core_assoc_DASH_in) + tmp22 := checkDerefVar(var_glojure_DOT_core_get) tmp23 := lang.Apply(tmp22, []any{v3, v17}) tmp24 := lang.Apply(tmp21, []any{tmp23, v18, v5}) tmp25 := lang.Apply(tmp20, []any{v3, v17, tmp24}) tmp19 = tmp25 } else { - tmp26 := checkDerefVar(glojure_DOT_core_assoc) + tmp26 := checkDerefVar(var_glojure_DOT_core_assoc) tmp27 := lang.Apply(tmp26, []any{v3, v17, v5}) tmp19 = tmp27 } @@ -8345,7 +9426,7 @@ func LoadNS() { } // end let return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -8353,19 +9434,17 @@ func LoadNS() { } // associative? { - tmp0 := lang.NewSymbol("associative?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements Associative", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6223), lang.NewKeyword("end-line"), int(6223))).(*lang.Symbol) + tmp0 := sym_associative_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns true if coll implements Associative", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(6223), kw_end_DASH_line, int(6223))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp5 := lang.Apply(tmp4, []any{nil, v3}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -8373,7 +9452,7 @@ func LoadNS() { } // atom { - tmp0 := lang.NewSymbol("atom").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Creates and returns an Atom with an initial value of x and zero or\n more options (in any order):\n\n :meta metadata-map\n\n :validator validate-fn\n\n If metadata-map is supplied, it will become the metadata on the\n atom. validate-fn must be nil or a side-effect-free fn of one\n argument, which will be passed the intended new state on any state\n change. If the new state is unacceptable, the validate-fn should\n return false or throw an exception.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2325), lang.NewKeyword("end-line"), int(2325))).(*lang.Symbol) + tmp0 := sym_atom.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym__AMP_, sym_options)), kw_doc, "Creates and returns an Atom with an initial value of x and zero or\n more options (in any order):\n\n :meta metadata-map\n\n :validator validate-fn\n\n If metadata-map is supplied, it will become the metadata on the\n atom. validate-fn must be nil or a side-effect-free fn of one\n argument, which will be passed the intended new state on any state\n change. If the new state is unacceptable, the validate-fn should\n return false or throw an exception.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(2325), kw_end_DASH_line, int(2325))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -8383,21 +9462,19 @@ func LoadNS() { tmp4 := lang.Apply(lang.NewAtom, []any{v3}) return tmp4 default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var v4 any = lang.NewList(args[1:]...) _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_setup_reference) - tmp6 := checkDerefVar(glojure_DOT_core_atom) + tmp5 := checkDerefVar(var_glojure_DOT_core_setup_DASH_reference) + tmp6 := checkDerefVar(var_glojure_DOT_core_atom) tmp7 := lang.Apply(tmp6, []any{v3}) tmp8 := lang.Apply(tmp5, []any{tmp7, v4}) return tmp8 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -8405,14 +9482,12 @@ func LoadNS() { } // await { - tmp0 := lang.NewSymbol("await").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("agents"))), lang.NewKeyword("doc"), "Blocks the current thread (indefinitely!) until all actions\n dispatched thus far, from this thread or agent, to the agent(s) have\n occurred. Will block on failed agents. Will never return if\n a failed agent is restarted with :clear-actions true or shutdown-agents was called.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3267), lang.NewKeyword("end-line"), int(3267))).(*lang.Symbol) + tmp0 := sym_await.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_agents)), kw_doc, "Blocks the current thread (indefinitely!) until all actions\n dispatched thus far, from this thread or agent, to the agent(s) have\n occurred. Will block on failed agents. Will never return if\n a failed agent is restarted with :clear-actions true or shutdown-agents was called.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3267), kw_end_DASH_line, int(3267))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 var tmp4 any @@ -8421,7 +9496,7 @@ func LoadNS() { panic("unimplemented: new with non-constant class type") } else { var tmp6 any - tmp7 := checkDerefVar(glojure_DOT_core__STAR_agent_STAR_) + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_agent_STAR_) if lang.IsTruthy(tmp7) { tmp8 := lang.Apply(errors8.New, []any{"Can't await in agent action"}) panic(tmp8) @@ -8436,9 +9511,7 @@ func LoadNS() { // let binding "count-down" var tmp11 lang.FnFunc tmp11 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v12 := args[0] _ = v12 tmp13, _ := lang.FieldOrMethod(v10, "countDown") @@ -8449,7 +9522,7 @@ func LoadNS() { _ = tmp14 return v12 }) - tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3279), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(3279), lang.NewKeyword("end-column"), int(61)) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3279), kw_column, int(22), kw_end_DASH_line, int(3279), kw_end_DASH_column, int(61)) tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) if err != nil { panic(err) @@ -8459,7 +9532,7 @@ func LoadNS() { var tmp15 any { // let // let binding "seq_1" - tmp16 := checkDerefVar(glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_seq) tmp17 := lang.Apply(tmp16, []any{v3}) var v18 any = tmp17 _ = v18 @@ -8474,7 +9547,7 @@ func LoadNS() { _ = v21 for { var tmp22 any - tmp23 := checkDerefVar(glojure_DOT_core__LT_) + tmp23 := checkDerefVar(var_glojure_DOT_core__LT_) tmp24 := lang.Apply(tmp23, []any{v21, v20}) if lang.IsTruthy(tmp24) { var tmp25 any @@ -8487,13 +9560,13 @@ func LoadNS() { tmp27 := lang.Apply(tmp26, []any{v21}) var v28 any = tmp27 _ = v28 - tmp29 := checkDerefVar(glojure_DOT_core_send) + tmp29 := checkDerefVar(var_glojure_DOT_core_send) tmp30 := lang.Apply(tmp29, []any{v28, v14}) _ = tmp30 var tmp31 any = v18 var tmp32 any = v19 var tmp33 any = v20 - tmp35 := checkDerefVar(glojure_DOT_core_unchecked_inc) + tmp35 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) tmp36 := lang.Apply(tmp35, []any{v21}) var tmp34 any = tmp36 v18 = tmp31 @@ -8507,7 +9580,7 @@ func LoadNS() { var tmp26 any { // let // let binding "temp__0__auto__" - tmp27 := checkDerefVar(glojure_DOT_core_seq) + tmp27 := checkDerefVar(var_glojure_DOT_core_seq) tmp28 := lang.Apply(tmp27, []any{v18}) var v29 any = tmp28 _ = v29 @@ -8519,26 +9592,26 @@ func LoadNS() { var v32 any = v29 _ = v32 var tmp33 any - tmp34 := checkDerefVar(glojure_DOT_core_chunked_seq_QMARK_) + tmp34 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) tmp35 := lang.Apply(tmp34, []any{v32}) if lang.IsTruthy(tmp35) { var tmp36 any { // let // let binding "c__0__auto__" - tmp37 := checkDerefVar(glojure_DOT_core_chunk_first) + tmp37 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) tmp38 := lang.Apply(tmp37, []any{v32}) var v39 any = tmp38 _ = v39 - tmp41 := checkDerefVar(glojure_DOT_core_chunk_rest) + tmp41 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) tmp42 := lang.Apply(tmp41, []any{v32}) var tmp40 any = tmp42 var tmp43 any = v39 - tmp45 := checkDerefVar(glojure_DOT_core_int) - tmp46 := checkDerefVar(glojure_DOT_core_count) + tmp45 := checkDerefVar(var_glojure_DOT_core_int) + tmp46 := checkDerefVar(var_glojure_DOT_core_count) tmp47 := lang.Apply(tmp46, []any{v39}) tmp48 := lang.Apply(tmp45, []any{tmp47}) var tmp44 any = tmp48 - tmp50 := checkDerefVar(glojure_DOT_core_int) + tmp50 := checkDerefVar(var_glojure_DOT_core_int) tmp51 := lang.Apply(tmp50, []any{int64(0)}) var tmp49 any = tmp51 v18 = tmp40 @@ -8552,14 +9625,14 @@ func LoadNS() { var tmp37 any { // let // let binding "agent" - tmp38 := checkDerefVar(glojure_DOT_core_first) + tmp38 := checkDerefVar(var_glojure_DOT_core_first) tmp39 := lang.Apply(tmp38, []any{v32}) var v40 any = tmp39 _ = v40 - tmp41 := checkDerefVar(glojure_DOT_core_send) + tmp41 := checkDerefVar(var_glojure_DOT_core_send) tmp42 := lang.Apply(tmp41, []any{v40, v14}) _ = tmp42 - tmp44 := checkDerefVar(glojure_DOT_core_next) + tmp44 := checkDerefVar(var_glojure_DOT_core_next) tmp45 := lang.Apply(tmp44, []any{v32}) var tmp43 any = tmp45 var tmp46 any = nil @@ -8599,7 +9672,7 @@ func LoadNS() { return tmp4 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -8607,14 +9680,12 @@ func LoadNS() { } // await-for { - tmp0 := lang.NewSymbol("await-for").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("timeout-ms"), lang.NewSymbol("&"), lang.NewSymbol("agents"))), lang.NewKeyword("doc"), "Blocks the current thread until all actions dispatched thus\n far (from this thread or agent) to the agents have occurred, or the\n timeout (in milliseconds) has elapsed. Returns logical false if\n returning due to timeout, logical true otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3289), lang.NewKeyword("end-line"), int(3289))).(*lang.Symbol) + tmp0 := sym_await_DASH_for.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_timeout_DASH_ms, sym__AMP_, sym_agents)), kw_doc, "Blocks the current thread until all actions dispatched thus\n far (from this thread or agent) to the agents have occurred, or the\n timeout (in milliseconds) has elapsed. Returns logical false if\n returning due to timeout, logical true otherwise.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(3289), kw_end_DASH_line, int(3289))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var v4 any = lang.NewList(args[1:]...) @@ -8625,7 +9696,7 @@ func LoadNS() { panic("unimplemented: new with non-constant class type") } else { var tmp7 any - tmp8 := checkDerefVar(glojure_DOT_core__STAR_agent_STAR_) + tmp8 := checkDerefVar(var_glojure_DOT_core__STAR_agent_STAR_) if lang.IsTruthy(tmp8) { tmp9 := lang.Apply(errors8.New, []any{"Can't await in agent action"}) panic(tmp9) @@ -8640,9 +9711,7 @@ func LoadNS() { // let binding "count-down" var tmp12 lang.FnFunc tmp12 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v13 := args[0] _ = v13 tmp14, _ := lang.FieldOrMethod(v11, "countDown") @@ -8653,7 +9722,7 @@ func LoadNS() { _ = tmp15 return v13 }) - tmp13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3301), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(3301), lang.NewKeyword("end-column"), int(62)) + tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3301), kw_column, int(23), kw_end_DASH_line, int(3301), kw_end_DASH_column, int(62)) tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) if err != nil { panic(err) @@ -8663,7 +9732,7 @@ func LoadNS() { var tmp16 any { // let // let binding "seq_5" - tmp17 := checkDerefVar(glojure_DOT_core_seq) + tmp17 := checkDerefVar(var_glojure_DOT_core_seq) tmp18 := lang.Apply(tmp17, []any{v4}) var v19 any = tmp18 _ = v19 @@ -8678,7 +9747,7 @@ func LoadNS() { _ = v22 for { var tmp23 any - tmp24 := checkDerefVar(glojure_DOT_core__LT_) + tmp24 := checkDerefVar(var_glojure_DOT_core__LT_) tmp25 := lang.Apply(tmp24, []any{v22, v21}) if lang.IsTruthy(tmp25) { var tmp26 any @@ -8691,13 +9760,13 @@ func LoadNS() { tmp28 := lang.Apply(tmp27, []any{v22}) var v29 any = tmp28 _ = v29 - tmp30 := checkDerefVar(glojure_DOT_core_send) + tmp30 := checkDerefVar(var_glojure_DOT_core_send) tmp31 := lang.Apply(tmp30, []any{v29, v15}) _ = tmp31 var tmp32 any = v19 var tmp33 any = v20 var tmp34 any = v21 - tmp36 := checkDerefVar(glojure_DOT_core_unchecked_inc) + tmp36 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) tmp37 := lang.Apply(tmp36, []any{v22}) var tmp35 any = tmp37 v19 = tmp32 @@ -8711,7 +9780,7 @@ func LoadNS() { var tmp27 any { // let // let binding "temp__0__auto__" - tmp28 := checkDerefVar(glojure_DOT_core_seq) + tmp28 := checkDerefVar(var_glojure_DOT_core_seq) tmp29 := lang.Apply(tmp28, []any{v19}) var v30 any = tmp29 _ = v30 @@ -8723,26 +9792,26 @@ func LoadNS() { var v33 any = v30 _ = v33 var tmp34 any - tmp35 := checkDerefVar(glojure_DOT_core_chunked_seq_QMARK_) + tmp35 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) tmp36 := lang.Apply(tmp35, []any{v33}) if lang.IsTruthy(tmp36) { var tmp37 any { // let // let binding "c__0__auto__" - tmp38 := checkDerefVar(glojure_DOT_core_chunk_first) + tmp38 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) tmp39 := lang.Apply(tmp38, []any{v33}) var v40 any = tmp39 _ = v40 - tmp42 := checkDerefVar(glojure_DOT_core_chunk_rest) + tmp42 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) tmp43 := lang.Apply(tmp42, []any{v33}) var tmp41 any = tmp43 var tmp44 any = v40 - tmp46 := checkDerefVar(glojure_DOT_core_int) - tmp47 := checkDerefVar(glojure_DOT_core_count) + tmp46 := checkDerefVar(var_glojure_DOT_core_int) + tmp47 := checkDerefVar(var_glojure_DOT_core_count) tmp48 := lang.Apply(tmp47, []any{v40}) tmp49 := lang.Apply(tmp46, []any{tmp48}) var tmp45 any = tmp49 - tmp51 := checkDerefVar(glojure_DOT_core_int) + tmp51 := checkDerefVar(var_glojure_DOT_core_int) tmp52 := lang.Apply(tmp51, []any{int64(0)}) var tmp50 any = tmp52 v19 = tmp41 @@ -8756,14 +9825,14 @@ func LoadNS() { var tmp38 any { // let // let binding "agent" - tmp39 := checkDerefVar(glojure_DOT_core_first) + tmp39 := checkDerefVar(var_glojure_DOT_core_first) tmp40 := lang.Apply(tmp39, []any{v33}) var v41 any = tmp40 _ = v41 - tmp42 := checkDerefVar(glojure_DOT_core_send) + tmp42 := checkDerefVar(var_glojure_DOT_core_send) tmp43 := lang.Apply(tmp42, []any{v41, v15}) _ = tmp43 - tmp45 := checkDerefVar(glojure_DOT_core_next) + tmp45 := checkDerefVar(var_glojure_DOT_core_next) tmp46 := lang.Apply(tmp45, []any{v33}) var tmp44 any = tmp46 var tmp47 any = nil @@ -8814,7 +9883,7 @@ func LoadNS() { return tmp5 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -8822,16 +9891,14 @@ func LoadNS() { } // await1 { - tmp0 := lang.NewSymbol("await1").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3284), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3284), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym_await1.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(3284), kw_column, int(7), kw_end_DASH_line, int(3284), kw_end_DASH_column, int(21), kw_arglists, lang.NewList(lang.NewVector(sym_a)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any - tmp5 := checkDerefVar(glojure_DOT_core_pos_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) tmp6, ok := lang.FieldOrMethod(v3, "getQueueCount") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getQueueCount"))) @@ -8845,7 +9912,7 @@ func LoadNS() { } tmp8 := lang.Apply(tmp5, []any{tmp7}) if lang.IsTruthy(tmp8) { - tmp9 := checkDerefVar(glojure_DOT_core_await) + tmp9 := checkDerefVar(var_glojure_DOT_core_await) tmp10 := lang.Apply(tmp9, []any{v3}) tmp4 = tmp10 } else { @@ -8853,7 +9920,7 @@ func LoadNS() { _ = tmp4 return v3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -8861,12 +9928,10 @@ func LoadNS() { } // bases { - tmp0 := lang.NewSymbol("bases").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"))), lang.NewKeyword("doc"), "Returns the immediate superclass and direct interfaces of c, if any", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5522), lang.NewKeyword("end-line"), int(5522))).(*lang.Symbol) + tmp0 := sym_bases.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_c)), kw_doc, "Returns the immediate superclass and direct interfaces of c, if any", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(5522), kw_end_DASH_line, int(5522))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any @@ -8874,7 +9939,7 @@ func LoadNS() { var tmp5 any { // let // let binding "i" - tmp6 := checkDerefVar(glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) tmp7 := lang.Apply(tmp6, []any{nil}) var v8 any = tmp7 _ = v8 @@ -8883,7 +9948,7 @@ func LoadNS() { _ = v9 var tmp10 any if lang.IsTruthy(v9) { - tmp11 := checkDerefVar(glojure_DOT_core_cons) + tmp11 := checkDerefVar(var_glojure_DOT_core_cons) tmp12 := lang.Apply(tmp11, []any{v9, v8}) tmp10 = tmp12 } else { @@ -8896,7 +9961,7 @@ func LoadNS() { } return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -8905,34 +9970,32 @@ func LoadNS() { // bigdec { tmp1 := reflect.TypeOf((*lang.BigDecimal)(nil)) - tmp0 := lang.NewSymbol("bigdec").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Coerce to BigDecimal", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3648), lang.NewKeyword("end-line"), int(3648))).(*lang.Symbol) + tmp0 := sym_bigdec.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Coerce to BigDecimal", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(3648), kw_end_DASH_line, int(3648))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 var tmp5 any - tmp6 := checkDerefVar(glojure_DOT_core_decimal_QMARK_) + tmp6 := checkDerefVar(var_glojure_DOT_core_decimal_QMARK_) tmp7 := lang.Apply(tmp6, []any{v4}) if lang.IsTruthy(tmp7) { tmp5 = v4 } else { var tmp8 any - tmp9 := checkDerefVar(glojure_DOT_core_float_QMARK_) + tmp9 := checkDerefVar(var_glojure_DOT_core_float_QMARK_) tmp10 := lang.Apply(tmp9, []any{v4}) if lang.IsTruthy(tmp10) { - tmp11 := checkDerefVar(glojure_DOT_core_double) + tmp11 := checkDerefVar(var_glojure_DOT_core_double) tmp12 := lang.Apply(tmp11, []any{v4}) tmp13 := lang.Apply(lang.NewBigDecimalFromFloat64, []any{tmp12}) tmp8 = tmp13 } else { var tmp14 any - tmp15 := checkDerefVar(glojure_DOT_core_ratio_QMARK_) + tmp15 := checkDerefVar(var_glojure_DOT_core_ratio_QMARK_) tmp16 := lang.Apply(tmp15, []any{v4}) if lang.IsTruthy(tmp16) { - tmp17 := checkDerefVar(glojure_DOT_core__SLASH_) + tmp17 := checkDerefVar(var_glojure_DOT_core__SLASH_) tmp18 := lang.Apply(lang.NewBigDecimalFromRatio, []any{v4}) tmp19, ok := lang.FieldOrMethod(v4, "denominator") if !ok { @@ -8949,7 +10012,7 @@ func LoadNS() { tmp14 = tmp21 } else { var tmp22 any - tmp23 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp23 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp24 := reflect.TypeOf((*lang.BigInt)(nil)) tmp25 := lang.Apply(tmp23, []any{tmp24, v4}) if lang.IsTruthy(tmp25) { @@ -8967,7 +10030,7 @@ func LoadNS() { tmp22 = tmp27 } else { var tmp28 any - tmp29 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp29 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp30 := reflect.TypeOf((*big9.Int)(nil)) tmp31 := lang.Apply(tmp29, []any{tmp30, v4}) if lang.IsTruthy(tmp31) { @@ -8975,16 +10038,16 @@ func LoadNS() { tmp28 = tmp32 } else { var tmp33 any - tmp34 := checkDerefVar(glojure_DOT_core_number_QMARK_) + tmp34 := checkDerefVar(var_glojure_DOT_core_number_QMARK_) tmp35 := lang.Apply(tmp34, []any{v4}) if lang.IsTruthy(tmp35) { - tmp36 := checkDerefVar(glojure_DOT_core_long) + tmp36 := checkDerefVar(var_glojure_DOT_core_long) tmp37 := lang.Apply(tmp36, []any{v4}) tmp38 := lang.Apply(lang.NewBigDecimalFromInt64, []any{tmp37}) tmp33 = tmp38 } else { var tmp39 any - if lang.IsTruthy(lang.NewKeyword("else")) { + if lang.IsTruthy(kw_else) { tmp40 := lang.Apply(lang.NewBigDecimal, []any{v4}) tmp39 = tmp40 } else { @@ -9004,7 +10067,7 @@ func LoadNS() { return tmp5 }) tmp4 := reflect.TypeOf((*lang.BigDecimal)(nil)) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -9013,23 +10076,21 @@ func LoadNS() { // bigint { tmp1 := reflect.TypeOf((*lang.BigInt)(nil)) - tmp0 := lang.NewSymbol("bigint").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Coerce to BigInt", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3620), lang.NewKeyword("end-line"), int(3620))).(*lang.Symbol) + tmp0 := sym_bigint.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Coerce to BigInt", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(3620), kw_end_DASH_line, int(3620))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 var tmp5 any - tmp6 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp6 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp7 := reflect.TypeOf((*lang.BigInt)(nil)) tmp8 := lang.Apply(tmp6, []any{tmp7, v4}) if lang.IsTruthy(tmp8) { tmp5 = v4 } else { var tmp9 any - tmp10 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp10 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp11 := reflect.TypeOf((*big9.Int)(nil)) tmp12 := lang.Apply(tmp10, []any{tmp11, v4}) if lang.IsTruthy(tmp12) { @@ -9037,10 +10098,10 @@ func LoadNS() { tmp9 = tmp13 } else { var tmp14 any - tmp15 := checkDerefVar(glojure_DOT_core_decimal_QMARK_) + tmp15 := checkDerefVar(var_glojure_DOT_core_decimal_QMARK_) tmp16 := lang.Apply(tmp15, []any{v4}) if lang.IsTruthy(tmp16) { - tmp17 := checkDerefVar(glojure_DOT_core_bigint) + tmp17 := checkDerefVar(var_glojure_DOT_core_bigint) tmp18, ok := lang.FieldOrMethod(v4, "toBigInteger") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "toBigInteger"))) @@ -9056,21 +10117,21 @@ func LoadNS() { tmp14 = tmp20 } else { var tmp21 any - tmp22 := checkDerefVar(glojure_DOT_core_float_QMARK_) + tmp22 := checkDerefVar(var_glojure_DOT_core_float_QMARK_) tmp23 := lang.Apply(tmp22, []any{v4}) if lang.IsTruthy(tmp23) { - tmp24 := checkDerefVar(glojure_DOT_core_bigint) - tmp25 := checkDerefVar(glojure_DOT_core_double) + tmp24 := checkDerefVar(var_glojure_DOT_core_bigint) + tmp25 := checkDerefVar(var_glojure_DOT_core_double) tmp26 := lang.Apply(tmp25, []any{v4}) tmp27 := lang.Apply(lang.NewBigDecimalFromFloat64, []any{tmp26}) tmp28 := lang.Apply(tmp24, []any{tmp27}) tmp21 = tmp28 } else { var tmp29 any - tmp30 := checkDerefVar(glojure_DOT_core_ratio_QMARK_) + tmp30 := checkDerefVar(var_glojure_DOT_core_ratio_QMARK_) tmp31 := lang.Apply(tmp30, []any{v4}) if lang.IsTruthy(tmp31) { - tmp32 := checkDerefVar(glojure_DOT_core_bigint) + tmp32 := checkDerefVar(var_glojure_DOT_core_bigint) tmp33, ok := lang.FieldOrMethod(v4, "bigIntegerValue") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "bigIntegerValue"))) @@ -9086,17 +10147,17 @@ func LoadNS() { tmp29 = tmp35 } else { var tmp36 any - tmp37 := checkDerefVar(glojure_DOT_core_number_QMARK_) + tmp37 := checkDerefVar(var_glojure_DOT_core_number_QMARK_) tmp38 := lang.Apply(tmp37, []any{v4}) if lang.IsTruthy(tmp38) { - tmp39 := checkDerefVar(glojure_DOT_core_long) + tmp39 := checkDerefVar(var_glojure_DOT_core_long) tmp40 := lang.Apply(tmp39, []any{v4}) tmp41 := lang.Apply(lang.NewBigIntFromInt64, []any{tmp40}) tmp36 = tmp41 } else { var tmp42 any - if lang.IsTruthy(lang.NewKeyword("else")) { - tmp43 := checkDerefVar(glojure_DOT_core_bigint) + if lang.IsTruthy(kw_else) { + tmp43 := checkDerefVar(var_glojure_DOT_core_bigint) tmp44 := lang.Apply(lang.NewBigInt, []any{v4}) tmp45 := lang.Apply(tmp43, []any{tmp44}) tmp42 = tmp45 @@ -9117,7 +10178,7 @@ func LoadNS() { return tmp5 }) tmp4 := reflect.TypeOf((*lang.BigInt)(nil)) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -9126,23 +10187,21 @@ func LoadNS() { // biginteger { tmp1 := reflect.TypeOf((*big9.Int)(nil)) - tmp0 := lang.NewSymbol("biginteger").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Coerce to BigInteger", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3634), lang.NewKeyword("end-line"), int(3634))).(*lang.Symbol) + tmp0 := sym_biginteger.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Coerce to BigInteger", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(3634), kw_end_DASH_line, int(3634))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 var tmp5 any - tmp6 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp6 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp7 := reflect.TypeOf((*big9.Int)(nil)) tmp8 := lang.Apply(tmp6, []any{tmp7, v4}) if lang.IsTruthy(tmp8) { tmp5 = v4 } else { var tmp9 any - tmp10 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp10 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp11 := reflect.TypeOf((*lang.BigInt)(nil)) tmp12 := lang.Apply(tmp10, []any{tmp11, v4}) if lang.IsTruthy(tmp12) { @@ -9160,7 +10219,7 @@ func LoadNS() { tmp9 = tmp14 } else { var tmp15 any - tmp16 := checkDerefVar(glojure_DOT_core_decimal_QMARK_) + tmp16 := checkDerefVar(var_glojure_DOT_core_decimal_QMARK_) tmp17 := lang.Apply(tmp16, []any{v4}) if lang.IsTruthy(tmp17) { tmp18, ok := lang.FieldOrMethod(v4, "toBigInteger") @@ -9177,10 +10236,10 @@ func LoadNS() { tmp15 = tmp19 } else { var tmp20 any - tmp21 := checkDerefVar(glojure_DOT_core_float_QMARK_) + tmp21 := checkDerefVar(var_glojure_DOT_core_float_QMARK_) tmp22 := lang.Apply(tmp21, []any{v4}) if lang.IsTruthy(tmp22) { - tmp23 := checkDerefVar(glojure_DOT_core_double) + tmp23 := checkDerefVar(var_glojure_DOT_core_double) tmp24 := lang.Apply(tmp23, []any{v4}) tmp25 := lang.Apply(lang.NewBigDecimalFromFloat64, []any{tmp24}) tmp26, ok := lang.FieldOrMethod(tmp25, "toBigInteger") @@ -9197,7 +10256,7 @@ func LoadNS() { tmp20 = tmp27 } else { var tmp28 any - tmp29 := checkDerefVar(glojure_DOT_core_ratio_QMARK_) + tmp29 := checkDerefVar(var_glojure_DOT_core_ratio_QMARK_) tmp30 := lang.Apply(tmp29, []any{v4}) if lang.IsTruthy(tmp30) { tmp31, ok := lang.FieldOrMethod(v4, "bigIntegerValue") @@ -9214,16 +10273,16 @@ func LoadNS() { tmp28 = tmp32 } else { var tmp33 any - tmp34 := checkDerefVar(glojure_DOT_core_number_QMARK_) + tmp34 := checkDerefVar(var_glojure_DOT_core_number_QMARK_) tmp35 := lang.Apply(tmp34, []any{v4}) if lang.IsTruthy(tmp35) { - tmp36 := checkDerefVar(glojure_DOT_core_long) + tmp36 := checkDerefVar(var_glojure_DOT_core_long) tmp37 := lang.Apply(tmp36, []any{v4}) tmp38 := lang.Apply(big9.NewInt, []any{tmp37}) tmp33 = tmp38 } else { var tmp39 any - if lang.IsTruthy(lang.NewKeyword("else")) { + if lang.IsTruthy(kw_else) { tmp40 := lang.Apply(lang.NewBigInt, []any{v4}) tmp39 = tmp40 } else { @@ -9243,7 +10302,7 @@ func LoadNS() { return tmp5 }) tmp4 := reflect.TypeOf((*big9.Int)(nil)) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -9251,14 +10310,12 @@ func LoadNS() { } // binding { - tmp0 := lang.NewSymbol("binding").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "binding => var-symbol init-expr\n\n Creates new bindings for the (already-existing) vars, with the\n supplied initial values, executes the exprs in an implicit do, then\n re-establishes the bindings that existed before. The new bindings\n are made in parallel (unlike let); all init-exprs are evaluated\n before the vars are bound to their new values.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1945), lang.NewKeyword("end-line"), int(1945))).(*lang.Symbol) + tmp0 := sym_binding.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "binding => var-symbol init-expr\n\n Creates new bindings for the (already-existing) vars, with the\n supplied initial values, executes the exprs in an implicit do, then\n re-establishes the bindings that existed before. The new bindings\n are made in parallel (unlike let); all init-exprs are evaluated\n before the vars are bound to their new values.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(1945), kw_end_DASH_line, int(1945))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -9268,36 +10325,36 @@ func LoadNS() { var v6 any = lang.NewList(args[3:]...) _ = v6 var tmp7 any - tmp8 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp8 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) tmp9 := lang.Apply(tmp8, []any{v5}) if lang.IsTruthy(tmp9) { } else { - tmp10 := checkDerefVar(glojure_DOT_core_str) - tmp11 := checkDerefVar(glojure_DOT_core_first) + tmp10 := checkDerefVar(var_glojure_DOT_core_str) + tmp11 := checkDerefVar(var_glojure_DOT_core_first) tmp12 := lang.Apply(tmp11, []any{v3}) - tmp13 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) - tmp14 := checkDerefVar(glojure_DOT_core_meta) + tmp13 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp14 := checkDerefVar(var_glojure_DOT_core_meta) tmp15 := lang.Apply(tmp14, []any{v3}) - tmp16 := lang.Apply(lang.NewKeyword("line"), []any{tmp15}) + tmp16 := lang.Apply(kw_line, []any{tmp15}) tmp17 := lang.Apply(tmp10, []any{tmp12, " requires ", "a vector for its binding", " in ", tmp13, ":", tmp16}) tmp18 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp17}) panic(tmp18) } _ = tmp7 var tmp19 any - tmp20 := checkDerefVar(glojure_DOT_core_even_QMARK_) - tmp21 := checkDerefVar(glojure_DOT_core_count) + tmp20 := checkDerefVar(var_glojure_DOT_core_even_QMARK_) + tmp21 := checkDerefVar(var_glojure_DOT_core_count) tmp22 := lang.Apply(tmp21, []any{v5}) tmp23 := lang.Apply(tmp20, []any{tmp22}) if lang.IsTruthy(tmp23) { } else { - tmp24 := checkDerefVar(glojure_DOT_core_str) - tmp25 := checkDerefVar(glojure_DOT_core_first) + tmp24 := checkDerefVar(var_glojure_DOT_core_str) + tmp25 := checkDerefVar(var_glojure_DOT_core_first) tmp26 := lang.Apply(tmp25, []any{v3}) - tmp27 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) - tmp28 := checkDerefVar(glojure_DOT_core_meta) + tmp27 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp28 := checkDerefVar(var_glojure_DOT_core_meta) tmp29 := lang.Apply(tmp28, []any{v3}) - tmp30 := lang.Apply(lang.NewKeyword("line"), []any{tmp29}) + tmp30 := lang.Apply(kw_line, []any{tmp29}) tmp31 := lang.Apply(tmp24, []any{tmp26, " requires ", "an even number of forms in binding vector", " in ", tmp27, ":", tmp30}) tmp32 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp31}) panic(tmp32) @@ -9308,16 +10365,14 @@ func LoadNS() { // let binding "var-ize" var tmp34 lang.FnFunc tmp34 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v35 := args[0] _ = v35 var tmp36 any { // let // let binding "ret" tmp37 := lang.NewVector() - tmp38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1959), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(1959), lang.NewKeyword("end-column"), int(31)) + tmp38 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(1959), kw_column, int(30), kw_end_DASH_line, int(1959), kw_end_DASH_column, int(31)) tmp39, err := lang.WithMeta(tmp37, tmp38.(lang.IPersistentMap)) if err != nil { panic(err) @@ -9325,32 +10380,32 @@ func LoadNS() { var v40 any = tmp39 _ = v40 // let binding "vvs" - tmp41 := checkDerefVar(glojure_DOT_core_seq) + tmp41 := checkDerefVar(var_glojure_DOT_core_seq) tmp42 := lang.Apply(tmp41, []any{v35}) var v43 any = tmp42 _ = v43 for { var tmp44 any if lang.IsTruthy(v43) { - tmp46 := checkDerefVar(glojure_DOT_core_conj) - tmp47 := checkDerefVar(glojure_DOT_core_conj) - tmp48 := checkDerefVar(glojure_DOT_core_seq) - tmp49 := checkDerefVar(glojure_DOT_core_concat) - tmp50 := checkDerefVar(glojure_DOT_core_list) - tmp51 := lang.Apply(tmp50, []any{lang.NewSymbol("var")}) - tmp52 := checkDerefVar(glojure_DOT_core_list) - tmp53 := checkDerefVar(glojure_DOT_core_first) + tmp46 := checkDerefVar(var_glojure_DOT_core_conj) + tmp47 := checkDerefVar(var_glojure_DOT_core_conj) + tmp48 := checkDerefVar(var_glojure_DOT_core_seq) + tmp49 := checkDerefVar(var_glojure_DOT_core_concat) + tmp50 := checkDerefVar(var_glojure_DOT_core_list) + tmp51 := lang.Apply(tmp50, []any{sym_var}) + tmp52 := checkDerefVar(var_glojure_DOT_core_list) + tmp53 := checkDerefVar(var_glojure_DOT_core_first) tmp54 := lang.Apply(tmp53, []any{v43}) tmp55 := lang.Apply(tmp52, []any{tmp54}) tmp56 := lang.Apply(tmp49, []any{tmp51, tmp55}) tmp57 := lang.Apply(tmp48, []any{tmp56}) tmp58 := lang.Apply(tmp47, []any{v40, tmp57}) - tmp59 := checkDerefVar(glojure_DOT_core_second) + tmp59 := checkDerefVar(var_glojure_DOT_core_second) tmp60 := lang.Apply(tmp59, []any{v43}) tmp61 := lang.Apply(tmp46, []any{tmp58, tmp60}) var tmp45 any = tmp61 - tmp63 := checkDerefVar(glojure_DOT_core_next) - tmp64 := checkDerefVar(glojure_DOT_core_next) + tmp63 := checkDerefVar(var_glojure_DOT_core_next) + tmp64 := checkDerefVar(var_glojure_DOT_core_next) tmp65 := lang.Apply(tmp64, []any{v43}) tmp66 := lang.Apply(tmp63, []any{tmp65}) var tmp62 any = tmp66 @@ -9358,7 +10413,7 @@ func LoadNS() { v43 = tmp62 continue } else { - tmp67 := checkDerefVar(glojure_DOT_core_seq) + tmp67 := checkDerefVar(var_glojure_DOT_core_seq) tmp68 := lang.Apply(tmp67, []any{v40}) tmp44 = tmp68 } @@ -9368,36 +10423,36 @@ func LoadNS() { } // end let return tmp36 }) - tmp35 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1958), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(1963), lang.NewKeyword("end-column"), int(34)) + tmp35 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(1958), kw_column, int(17), kw_end_DASH_line, int(1963), kw_end_DASH_column, int(34)) tmp36, err := lang.WithMeta(tmp34, tmp35.(lang.IPersistentMap)) if err != nil { panic(err) } var v37 any = tmp36 _ = v37 - tmp38 := checkDerefVar(glojure_DOT_core_seq) - tmp39 := checkDerefVar(glojure_DOT_core_concat) - tmp40 := checkDerefVar(glojure_DOT_core_list) - tmp41 := lang.Apply(tmp40, []any{lang.NewSymbol("glojure.core/let")}) - tmp42 := checkDerefVar(glojure_DOT_core_list) - tmp43 := checkDerefVar(glojure_DOT_core_apply) - tmp44 := checkDerefVar(glojure_DOT_core_vector) - tmp45 := checkDerefVar(glojure_DOT_core_seq) - tmp46 := checkDerefVar(glojure_DOT_core_concat) + tmp38 := checkDerefVar(var_glojure_DOT_core_seq) + tmp39 := checkDerefVar(var_glojure_DOT_core_concat) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{sym_glojure_DOT_core_SLASH_let}) + tmp42 := checkDerefVar(var_glojure_DOT_core_list) + tmp43 := checkDerefVar(var_glojure_DOT_core_apply) + tmp44 := checkDerefVar(var_glojure_DOT_core_vector) + tmp45 := checkDerefVar(var_glojure_DOT_core_seq) + tmp46 := checkDerefVar(var_glojure_DOT_core_concat) tmp47 := lang.Apply(tmp46, nil) tmp48 := lang.Apply(tmp45, []any{tmp47}) tmp49 := lang.Apply(tmp43, []any{tmp44, tmp48}) tmp50 := lang.Apply(tmp42, []any{tmp49}) - tmp51 := checkDerefVar(glojure_DOT_core_list) - tmp52 := checkDerefVar(glojure_DOT_core_seq) - tmp53 := checkDerefVar(glojure_DOT_core_concat) - tmp54 := checkDerefVar(glojure_DOT_core_list) - tmp55 := lang.Apply(tmp54, []any{lang.NewSymbol("glojure.core/push-thread-bindings")}) - tmp56 := checkDerefVar(glojure_DOT_core_list) - tmp57 := checkDerefVar(glojure_DOT_core_seq) - tmp58 := checkDerefVar(glojure_DOT_core_concat) - tmp59 := checkDerefVar(glojure_DOT_core_list) - tmp60 := lang.Apply(tmp59, []any{lang.NewSymbol("glojure.core/hash-map")}) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := checkDerefVar(var_glojure_DOT_core_seq) + tmp53 := checkDerefVar(var_glojure_DOT_core_concat) + tmp54 := checkDerefVar(var_glojure_DOT_core_list) + tmp55 := lang.Apply(tmp54, []any{sym_glojure_DOT_core_SLASH_push_DASH_thread_DASH_bindings}) + tmp56 := checkDerefVar(var_glojure_DOT_core_list) + tmp57 := checkDerefVar(var_glojure_DOT_core_seq) + tmp58 := checkDerefVar(var_glojure_DOT_core_concat) + tmp59 := checkDerefVar(var_glojure_DOT_core_list) + tmp60 := lang.Apply(tmp59, []any{sym_glojure_DOT_core_SLASH_hash_DASH_map}) tmp61 := lang.Apply(v37, []any{v5}) tmp62 := lang.Apply(tmp58, []any{tmp60, tmp61}) tmp63 := lang.Apply(tmp57, []any{tmp62}) @@ -9405,21 +10460,21 @@ func LoadNS() { tmp65 := lang.Apply(tmp53, []any{tmp55, tmp64}) tmp66 := lang.Apply(tmp52, []any{tmp65}) tmp67 := lang.Apply(tmp51, []any{tmp66}) - tmp68 := checkDerefVar(glojure_DOT_core_list) - tmp69 := checkDerefVar(glojure_DOT_core_seq) - tmp70 := checkDerefVar(glojure_DOT_core_concat) - tmp71 := checkDerefVar(glojure_DOT_core_list) - tmp72 := lang.Apply(tmp71, []any{lang.NewSymbol("try")}) - tmp73 := checkDerefVar(glojure_DOT_core_list) - tmp74 := checkDerefVar(glojure_DOT_core_seq) - tmp75 := checkDerefVar(glojure_DOT_core_concat) - tmp76 := checkDerefVar(glojure_DOT_core_list) - tmp77 := lang.Apply(tmp76, []any{lang.NewSymbol("finally")}) - tmp78 := checkDerefVar(glojure_DOT_core_list) - tmp79 := checkDerefVar(glojure_DOT_core_seq) - tmp80 := checkDerefVar(glojure_DOT_core_concat) - tmp81 := checkDerefVar(glojure_DOT_core_list) - tmp82 := lang.Apply(tmp81, []any{lang.NewSymbol("glojure.core/pop-thread-bindings")}) + tmp68 := checkDerefVar(var_glojure_DOT_core_list) + tmp69 := checkDerefVar(var_glojure_DOT_core_seq) + tmp70 := checkDerefVar(var_glojure_DOT_core_concat) + tmp71 := checkDerefVar(var_glojure_DOT_core_list) + tmp72 := lang.Apply(tmp71, []any{sym_try}) + tmp73 := checkDerefVar(var_glojure_DOT_core_list) + tmp74 := checkDerefVar(var_glojure_DOT_core_seq) + tmp75 := checkDerefVar(var_glojure_DOT_core_concat) + tmp76 := checkDerefVar(var_glojure_DOT_core_list) + tmp77 := lang.Apply(tmp76, []any{sym_finally}) + tmp78 := checkDerefVar(var_glojure_DOT_core_list) + tmp79 := checkDerefVar(var_glojure_DOT_core_seq) + tmp80 := checkDerefVar(var_glojure_DOT_core_concat) + tmp81 := checkDerefVar(var_glojure_DOT_core_list) + tmp82 := lang.Apply(tmp81, []any{sym_glojure_DOT_core_SLASH_pop_DASH_thread_DASH_bindings}) tmp83 := lang.Apply(tmp80, []any{tmp82}) tmp84 := lang.Apply(tmp79, []any{tmp83}) tmp85 := lang.Apply(tmp78, []any{tmp84}) @@ -9436,7 +10491,7 @@ func LoadNS() { return tmp33 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -9444,12 +10499,10 @@ func LoadNS() { } // binding-conveyor-fn { - tmp0 := lang.NewSymbol("binding-conveyor-fn").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2020), lang.NewKeyword("end-line"), int(2020), lang.NewKeyword("private"), true)).(*lang.Symbol) + tmp0 := sym_binding_DASH_conveyor_DASH_fn.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f)), kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(25), kw_column, int(7), kw_line, int(2020), kw_end_DASH_line, int(2020), kw_private, true)).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any @@ -9494,9 +10547,7 @@ func LoadNS() { tmp12 := lang.Apply(v3, []any{v8, v9, v10}) return tmp12 default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v8 := args[0] _ = v8 v9 := args[1] @@ -9507,12 +10558,12 @@ func LoadNS() { _ = v11 tmp12 := lang.Apply(lang.ResetThreadBindingFrame, []any{v6}) _ = tmp12 - tmp13 := checkDerefVar(glojure_DOT_core_apply) + tmp13 := checkDerefVar(var_glojure_DOT_core_apply) tmp14 := lang.Apply(tmp13, []any{v3, v8, v9, v10, v11}) return tmp14 } }) - tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2025), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2040), lang.NewKeyword("end-column"), int(31)) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2025), kw_column, int(5), kw_end_DASH_line, int(2040), kw_end_DASH_column, int(31)) tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) if err != nil { panic(err) @@ -9521,7 +10572,7 @@ func LoadNS() { } // end let return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -9539,7 +10590,7 @@ func LoadNS() { { // let // let binding "op" var tmp4 any - tmp5 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp5) { tmp4 = closed29 } else { @@ -9547,18 +10598,18 @@ func LoadNS() { } var v6 any = tmp4 _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_seq) - tmp8 := checkDerefVar(glojure_DOT_core_concat) - tmp9 := checkDerefVar(glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol(".")}) - tmp11 := checkDerefVar(glojure_DOT_core_list) - tmp12 := lang.Apply(tmp11, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp13 := checkDerefVar(glojure_DOT_core_list) - tmp14 := checkDerefVar(glojure_DOT_core_seq) - tmp15 := checkDerefVar(glojure_DOT_core_concat) - tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v6}) - tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) tmp19 := lang.Apply(tmp18, []any{v2}) tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) tmp21 := lang.Apply(tmp14, []any{tmp20}) @@ -9577,7 +10628,7 @@ func LoadNS() { { // let // let binding "op" var tmp5 any - tmp6 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp6) { tmp5 = closed29 } else { @@ -9585,20 +10636,20 @@ func LoadNS() { } var v7 any = tmp5 _ = v7 - tmp8 := checkDerefVar(glojure_DOT_core_seq) - tmp9 := checkDerefVar(glojure_DOT_core_concat) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol(".")}) - tmp12 := checkDerefVar(glojure_DOT_core_list) - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp14 := checkDerefVar(glojure_DOT_core_list) - tmp15 := checkDerefVar(glojure_DOT_core_seq) - tmp16 := checkDerefVar(glojure_DOT_core_concat) - tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) tmp18 := lang.Apply(tmp17, []any{v7}) - tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) tmp20 := lang.Apply(tmp19, []any{v2}) - tmp21 := checkDerefVar(glojure_DOT_core_list) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) tmp22 := lang.Apply(tmp21, []any{v3}) tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) tmp24 := lang.Apply(tmp15, []any{tmp23}) @@ -9609,9 +10660,7 @@ func LoadNS() { } // end let return tmp4 default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -9622,7 +10671,7 @@ func LoadNS() { { // let // let binding "op" var tmp6 any - tmp7 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp7) { tmp6 = closed29 } else { @@ -9630,30 +10679,28 @@ func LoadNS() { } var v8 any = tmp6 _ = v8 - tmp9 := checkDerefVar(glojure_DOT_core_reduce1) + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) var tmp10 lang.FnFunc tmp10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v11 := args[0] _ = v11 v12 := args[1] _ = v12 - tmp13 := checkDerefVar(glojure_DOT_core_seq) - tmp14 := checkDerefVar(glojure_DOT_core_concat) - tmp15 := checkDerefVar(glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) - tmp17 := checkDerefVar(glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp19 := checkDerefVar(glojure_DOT_core_list) - tmp20 := checkDerefVar(glojure_DOT_core_seq) - tmp21 := checkDerefVar(glojure_DOT_core_concat) - tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) tmp23 := lang.Apply(tmp22, []any{v8}) - tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) tmp25 := lang.Apply(tmp24, []any{v11}) - tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) tmp27 := lang.Apply(tmp26, []any{v12}) tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) tmp29 := lang.Apply(tmp20, []any{tmp28}) @@ -9662,25 +10709,25 @@ func LoadNS() { tmp32 := lang.Apply(tmp13, []any{tmp31}) return tmp32 }) - tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp13 := checkDerefVar(glojure_DOT_core_seq) - tmp14 := checkDerefVar(glojure_DOT_core_concat) - tmp15 := checkDerefVar(glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) - tmp17 := checkDerefVar(glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp19 := checkDerefVar(glojure_DOT_core_list) - tmp20 := checkDerefVar(glojure_DOT_core_seq) - tmp21 := checkDerefVar(glojure_DOT_core_concat) - tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) tmp23 := lang.Apply(tmp22, []any{v8}) - tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) tmp25 := lang.Apply(tmp24, []any{v2}) - tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) tmp27 := lang.Apply(tmp26, []any{v3}) tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) tmp29 := lang.Apply(tmp20, []any{tmp28}) @@ -9693,12 +10740,10 @@ func LoadNS() { return tmp5 } }) - tmp1 = tmp1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") @@ -9708,8 +10753,8 @@ func LoadNS() { tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp0 := lang.NewSymbol("bit-and").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Bitwise and", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), tmp2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1298), lang.NewKeyword("end-line"), int(1298))).(*lang.Symbol) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym_bit_DASH_and.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Bitwise and", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(1298), kw_end_DASH_line, int(1298))).(*lang.Symbol) var tmp4 lang.FnFunc tmp4 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -9725,24 +10770,22 @@ func LoadNS() { tmp8 := lang.Apply(tmp7, []any{v5, v6}) return tmp8 default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v5 := args[0] _ = v5 v6 := args[1] _ = v6 var v7 any = lang.NewList(args[2:]...) _ = v7 - tmp8 := checkDerefVar(glojure_DOT_core_reduce1) - tmp9 := checkDerefVar(glojure_DOT_core_bit_and) - tmp10 := checkDerefVar(glojure_DOT_core_bit_and) + tmp8 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp9 := checkDerefVar(var_glojure_DOT_core_bit_DASH_and) + tmp10 := checkDerefVar(var_glojure_DOT_core_bit_DASH_and) tmp11 := lang.Apply(tmp10, []any{v5, v6}) tmp12 := lang.Apply(tmp8, []any{tmp9, tmp11, v7}) return tmp12 } }) - tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp4 = tmp4.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp3 := ns.InternWithValue(tmp0, tmp4, true) if tmp0.Meta() != nil { tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -9760,7 +10803,7 @@ func LoadNS() { { // let // let binding "op" var tmp4 any - tmp5 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp5) { tmp4 = closed30 } else { @@ -9768,18 +10811,18 @@ func LoadNS() { } var v6 any = tmp4 _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_seq) - tmp8 := checkDerefVar(glojure_DOT_core_concat) - tmp9 := checkDerefVar(glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol(".")}) - tmp11 := checkDerefVar(glojure_DOT_core_list) - tmp12 := lang.Apply(tmp11, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp13 := checkDerefVar(glojure_DOT_core_list) - tmp14 := checkDerefVar(glojure_DOT_core_seq) - tmp15 := checkDerefVar(glojure_DOT_core_concat) - tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v6}) - tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) tmp19 := lang.Apply(tmp18, []any{v2}) tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) tmp21 := lang.Apply(tmp14, []any{tmp20}) @@ -9798,7 +10841,7 @@ func LoadNS() { { // let // let binding "op" var tmp5 any - tmp6 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp6) { tmp5 = closed30 } else { @@ -9806,20 +10849,20 @@ func LoadNS() { } var v7 any = tmp5 _ = v7 - tmp8 := checkDerefVar(glojure_DOT_core_seq) - tmp9 := checkDerefVar(glojure_DOT_core_concat) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol(".")}) - tmp12 := checkDerefVar(glojure_DOT_core_list) - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp14 := checkDerefVar(glojure_DOT_core_list) - tmp15 := checkDerefVar(glojure_DOT_core_seq) - tmp16 := checkDerefVar(glojure_DOT_core_concat) - tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) tmp18 := lang.Apply(tmp17, []any{v7}) - tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) tmp20 := lang.Apply(tmp19, []any{v2}) - tmp21 := checkDerefVar(glojure_DOT_core_list) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) tmp22 := lang.Apply(tmp21, []any{v3}) tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) tmp24 := lang.Apply(tmp15, []any{tmp23}) @@ -9830,9 +10873,7 @@ func LoadNS() { } // end let return tmp4 default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -9843,7 +10884,7 @@ func LoadNS() { { // let // let binding "op" var tmp6 any - tmp7 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp7) { tmp6 = closed30 } else { @@ -9851,30 +10892,28 @@ func LoadNS() { } var v8 any = tmp6 _ = v8 - tmp9 := checkDerefVar(glojure_DOT_core_reduce1) + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) var tmp10 lang.FnFunc tmp10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v11 := args[0] _ = v11 v12 := args[1] _ = v12 - tmp13 := checkDerefVar(glojure_DOT_core_seq) - tmp14 := checkDerefVar(glojure_DOT_core_concat) - tmp15 := checkDerefVar(glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) - tmp17 := checkDerefVar(glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp19 := checkDerefVar(glojure_DOT_core_list) - tmp20 := checkDerefVar(glojure_DOT_core_seq) - tmp21 := checkDerefVar(glojure_DOT_core_concat) - tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) tmp23 := lang.Apply(tmp22, []any{v8}) - tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) tmp25 := lang.Apply(tmp24, []any{v11}) - tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) tmp27 := lang.Apply(tmp26, []any{v12}) tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) tmp29 := lang.Apply(tmp20, []any{tmp28}) @@ -9883,25 +10922,25 @@ func LoadNS() { tmp32 := lang.Apply(tmp13, []any{tmp31}) return tmp32 }) - tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp13 := checkDerefVar(glojure_DOT_core_seq) - tmp14 := checkDerefVar(glojure_DOT_core_concat) - tmp15 := checkDerefVar(glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) - tmp17 := checkDerefVar(glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp19 := checkDerefVar(glojure_DOT_core_list) - tmp20 := checkDerefVar(glojure_DOT_core_seq) - tmp21 := checkDerefVar(glojure_DOT_core_concat) - tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) tmp23 := lang.Apply(tmp22, []any{v8}) - tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) tmp25 := lang.Apply(tmp24, []any{v2}) - tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) tmp27 := lang.Apply(tmp26, []any{v3}) tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) tmp29 := lang.Apply(tmp20, []any{tmp28}) @@ -9914,12 +10953,10 @@ func LoadNS() { return tmp5 } }) - tmp1 = tmp1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") @@ -9929,8 +10966,8 @@ func LoadNS() { tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp0 := lang.NewSymbol("bit-and-not").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Bitwise and with complement", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), tmp2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1325), lang.NewKeyword("end-line"), int(1325))).(*lang.Symbol) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym_bit_DASH_and_DASH_not.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Bitwise and with complement", kw_static, true, kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(1325), kw_end_DASH_line, int(1325))).(*lang.Symbol) var tmp4 lang.FnFunc tmp4 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -9946,24 +10983,22 @@ func LoadNS() { tmp8 := lang.Apply(tmp7, []any{v5, v6}) return tmp8 default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v5 := args[0] _ = v5 v6 := args[1] _ = v6 var v7 any = lang.NewList(args[2:]...) _ = v7 - tmp8 := checkDerefVar(glojure_DOT_core_reduce1) - tmp9 := checkDerefVar(glojure_DOT_core_bit_and_not) - tmp10 := checkDerefVar(glojure_DOT_core_bit_and_not) + tmp8 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp9 := checkDerefVar(var_glojure_DOT_core_bit_DASH_and_DASH_not) + tmp10 := checkDerefVar(var_glojure_DOT_core_bit_DASH_and_DASH_not) tmp11 := lang.Apply(tmp10, []any{v5, v6}) tmp12 := lang.Apply(tmp8, []any{tmp9, tmp11, v7}) return tmp12 } }) - tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp4 = tmp4.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp3 := ns.InternWithValue(tmp0, tmp4, true) if tmp0.Meta() != nil { tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -9971,12 +11006,10 @@ func LoadNS() { } // bit-clear { - tmp0 := lang.NewSymbol("bit-clear").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Clear bit at index n", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1336), lang.NewKeyword("end-line"), int(1336))).(*lang.Symbol) + tmp0 := sym_bit_DASH_clear.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_n)), kw_doc, "Clear bit at index n", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(1336), kw_end_DASH_line, int(1336))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -9988,7 +11021,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -9996,12 +11029,10 @@ func LoadNS() { } // bit-flip { - tmp0 := lang.NewSymbol("bit-flip").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Flip bit at index n", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1348), lang.NewKeyword("end-line"), int(1348))).(*lang.Symbol) + tmp0 := sym_bit_DASH_flip.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_n)), kw_doc, "Flip bit at index n", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(1348), kw_end_DASH_line, int(1348))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -10013,7 +11044,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -10025,23 +11056,21 @@ func LoadNS() { { // function bit-not__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) - tmp5 := checkDerefVar(glojure_DOT_core_concat) - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := checkDerefVar(glojure_DOT_core_seq) - tmp12 := checkDerefVar(glojure_DOT_core_concat) - tmp13 := checkDerefVar(glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/Not")}) - tmp15 := checkDerefVar(glojure_DOT_core_list) + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Not}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) tmp18 := lang.Apply(tmp11, []any{tmp17}) @@ -10053,12 +11082,10 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("bit-not").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Bitwise complement", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1291), lang.NewKeyword("end-line"), int(1291))).(*lang.Symbol) + tmp0 := sym_bit_DASH_not.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Bitwise complement", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(1291), kw_end_DASH_line, int(1291))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Not") @@ -10068,7 +11095,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v4}) return tmp6 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -10086,7 +11113,7 @@ func LoadNS() { { // let // let binding "op" var tmp4 any - tmp5 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp5) { tmp4 = closed31 } else { @@ -10094,18 +11121,18 @@ func LoadNS() { } var v6 any = tmp4 _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_seq) - tmp8 := checkDerefVar(glojure_DOT_core_concat) - tmp9 := checkDerefVar(glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol(".")}) - tmp11 := checkDerefVar(glojure_DOT_core_list) - tmp12 := lang.Apply(tmp11, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp13 := checkDerefVar(glojure_DOT_core_list) - tmp14 := checkDerefVar(glojure_DOT_core_seq) - tmp15 := checkDerefVar(glojure_DOT_core_concat) - tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v6}) - tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) tmp19 := lang.Apply(tmp18, []any{v2}) tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) tmp21 := lang.Apply(tmp14, []any{tmp20}) @@ -10124,7 +11151,7 @@ func LoadNS() { { // let // let binding "op" var tmp5 any - tmp6 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp6) { tmp5 = closed31 } else { @@ -10132,20 +11159,20 @@ func LoadNS() { } var v7 any = tmp5 _ = v7 - tmp8 := checkDerefVar(glojure_DOT_core_seq) - tmp9 := checkDerefVar(glojure_DOT_core_concat) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol(".")}) - tmp12 := checkDerefVar(glojure_DOT_core_list) - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp14 := checkDerefVar(glojure_DOT_core_list) - tmp15 := checkDerefVar(glojure_DOT_core_seq) - tmp16 := checkDerefVar(glojure_DOT_core_concat) - tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) tmp18 := lang.Apply(tmp17, []any{v7}) - tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) tmp20 := lang.Apply(tmp19, []any{v2}) - tmp21 := checkDerefVar(glojure_DOT_core_list) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) tmp22 := lang.Apply(tmp21, []any{v3}) tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) tmp24 := lang.Apply(tmp15, []any{tmp23}) @@ -10156,9 +11183,7 @@ func LoadNS() { } // end let return tmp4 default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -10169,7 +11194,7 @@ func LoadNS() { { // let // let binding "op" var tmp6 any - tmp7 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp7) { tmp6 = closed31 } else { @@ -10177,30 +11202,28 @@ func LoadNS() { } var v8 any = tmp6 _ = v8 - tmp9 := checkDerefVar(glojure_DOT_core_reduce1) + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) var tmp10 lang.FnFunc tmp10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v11 := args[0] _ = v11 v12 := args[1] _ = v12 - tmp13 := checkDerefVar(glojure_DOT_core_seq) - tmp14 := checkDerefVar(glojure_DOT_core_concat) - tmp15 := checkDerefVar(glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) - tmp17 := checkDerefVar(glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp19 := checkDerefVar(glojure_DOT_core_list) - tmp20 := checkDerefVar(glojure_DOT_core_seq) - tmp21 := checkDerefVar(glojure_DOT_core_concat) - tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) tmp23 := lang.Apply(tmp22, []any{v8}) - tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) tmp25 := lang.Apply(tmp24, []any{v11}) - tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) tmp27 := lang.Apply(tmp26, []any{v12}) tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) tmp29 := lang.Apply(tmp20, []any{tmp28}) @@ -10209,25 +11232,25 @@ func LoadNS() { tmp32 := lang.Apply(tmp13, []any{tmp31}) return tmp32 }) - tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp13 := checkDerefVar(glojure_DOT_core_seq) - tmp14 := checkDerefVar(glojure_DOT_core_concat) - tmp15 := checkDerefVar(glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) - tmp17 := checkDerefVar(glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp19 := checkDerefVar(glojure_DOT_core_list) - tmp20 := checkDerefVar(glojure_DOT_core_seq) - tmp21 := checkDerefVar(glojure_DOT_core_concat) - tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) tmp23 := lang.Apply(tmp22, []any{v8}) - tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) tmp25 := lang.Apply(tmp24, []any{v2}) - tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) tmp27 := lang.Apply(tmp26, []any{v3}) tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) tmp29 := lang.Apply(tmp20, []any{tmp28}) @@ -10240,12 +11263,10 @@ func LoadNS() { return tmp5 } }) - tmp1 = tmp1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") @@ -10255,8 +11276,8 @@ func LoadNS() { tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp0 := lang.NewSymbol("bit-or").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Bitwise or", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), tmp2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1307), lang.NewKeyword("end-line"), int(1307))).(*lang.Symbol) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym_bit_DASH_or.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Bitwise or", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(1307), kw_end_DASH_line, int(1307))).(*lang.Symbol) var tmp4 lang.FnFunc tmp4 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -10272,24 +11293,22 @@ func LoadNS() { tmp8 := lang.Apply(tmp7, []any{v5, v6}) return tmp8 default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v5 := args[0] _ = v5 v6 := args[1] _ = v6 var v7 any = lang.NewList(args[2:]...) _ = v7 - tmp8 := checkDerefVar(glojure_DOT_core_reduce1) - tmp9 := checkDerefVar(glojure_DOT_core_bit_or) - tmp10 := checkDerefVar(glojure_DOT_core_bit_or) + tmp8 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp9 := checkDerefVar(var_glojure_DOT_core_bit_DASH_or) + tmp10 := checkDerefVar(var_glojure_DOT_core_bit_DASH_or) tmp11 := lang.Apply(tmp10, []any{v5, v6}) tmp12 := lang.Apply(tmp8, []any{tmp9, tmp11, v7}) return tmp12 } }) - tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp4 = tmp4.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp3 := ns.InternWithValue(tmp0, tmp4, true) if tmp0.Meta() != nil { tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -10297,12 +11316,10 @@ func LoadNS() { } // bit-set { - tmp0 := lang.NewSymbol("bit-set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Set bit at index n", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1342), lang.NewKeyword("end-line"), int(1342))).(*lang.Symbol) + tmp0 := sym_bit_DASH_set.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_n)), kw_doc, "Set bit at index n", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(1342), kw_end_DASH_line, int(1342))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -10314,7 +11331,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -10326,27 +11343,25 @@ func LoadNS() { { // function bit-shift-left__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_seq) - tmp6 := checkDerefVar(glojure_DOT_core_concat) - tmp7 := checkDerefVar(glojure_DOT_core_list) - tmp8 := lang.Apply(tmp7, []any{lang.NewSymbol(".")}) - tmp9 := checkDerefVar(glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp11 := checkDerefVar(glojure_DOT_core_list) - tmp12 := checkDerefVar(glojure_DOT_core_seq) - tmp13 := checkDerefVar(glojure_DOT_core_concat) - tmp14 := checkDerefVar(glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("glojure.core/ShiftLeft")}) - tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_ShiftLeft}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) - tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) tmp19 := lang.Apply(tmp18, []any{v4}) tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) tmp21 := lang.Apply(tmp12, []any{tmp20}) @@ -10358,12 +11373,10 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("bit-shift-left").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Bitwise shift left", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1361), lang.NewKeyword("end-line"), int(1361))).(*lang.Symbol) + tmp0 := sym_bit_DASH_shift_DASH_left.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_n)), kw_inline, tmp1, kw_doc, "Bitwise shift left", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(1361), kw_end_DASH_line, int(1361))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -10375,7 +11388,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -10387,27 +11400,25 @@ func LoadNS() { { // function bit-shift-right__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_seq) - tmp6 := checkDerefVar(glojure_DOT_core_concat) - tmp7 := checkDerefVar(glojure_DOT_core_list) - tmp8 := lang.Apply(tmp7, []any{lang.NewSymbol(".")}) - tmp9 := checkDerefVar(glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp11 := checkDerefVar(glojure_DOT_core_list) - tmp12 := checkDerefVar(glojure_DOT_core_seq) - tmp13 := checkDerefVar(glojure_DOT_core_concat) - tmp14 := checkDerefVar(glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("glojure.core/ShiftRight")}) - tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_ShiftRight}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) - tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) tmp19 := lang.Apply(tmp18, []any{v4}) tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) tmp21 := lang.Apply(tmp12, []any{tmp20}) @@ -10419,12 +11430,10 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("bit-shift-right").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Bitwise shift right", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1367), lang.NewKeyword("end-line"), int(1367))).(*lang.Symbol) + tmp0 := sym_bit_DASH_shift_DASH_right.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_n)), kw_inline, tmp1, kw_doc, "Bitwise shift right", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(1367), kw_end_DASH_line, int(1367))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -10436,7 +11445,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -10444,12 +11453,10 @@ func LoadNS() { } // bit-test { - tmp0 := lang.NewSymbol("bit-test").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Test bit at index n", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1354), lang.NewKeyword("end-line"), int(1354))).(*lang.Symbol) + tmp0 := sym_bit_DASH_test.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_n)), kw_doc, "Test bit at index n", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(1354), kw_end_DASH_line, int(1354))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -10461,7 +11468,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -10479,7 +11486,7 @@ func LoadNS() { { // let // let binding "op" var tmp4 any - tmp5 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp5) { tmp4 = closed32 } else { @@ -10487,18 +11494,18 @@ func LoadNS() { } var v6 any = tmp4 _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_seq) - tmp8 := checkDerefVar(glojure_DOT_core_concat) - tmp9 := checkDerefVar(glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol(".")}) - tmp11 := checkDerefVar(glojure_DOT_core_list) - tmp12 := lang.Apply(tmp11, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp13 := checkDerefVar(glojure_DOT_core_list) - tmp14 := checkDerefVar(glojure_DOT_core_seq) - tmp15 := checkDerefVar(glojure_DOT_core_concat) - tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v6}) - tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) tmp19 := lang.Apply(tmp18, []any{v2}) tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) tmp21 := lang.Apply(tmp14, []any{tmp20}) @@ -10517,7 +11524,7 @@ func LoadNS() { { // let // let binding "op" var tmp5 any - tmp6 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp6) { tmp5 = closed32 } else { @@ -10525,20 +11532,20 @@ func LoadNS() { } var v7 any = tmp5 _ = v7 - tmp8 := checkDerefVar(glojure_DOT_core_seq) - tmp9 := checkDerefVar(glojure_DOT_core_concat) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol(".")}) - tmp12 := checkDerefVar(glojure_DOT_core_list) - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp14 := checkDerefVar(glojure_DOT_core_list) - tmp15 := checkDerefVar(glojure_DOT_core_seq) - tmp16 := checkDerefVar(glojure_DOT_core_concat) - tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) tmp18 := lang.Apply(tmp17, []any{v7}) - tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) tmp20 := lang.Apply(tmp19, []any{v2}) - tmp21 := checkDerefVar(glojure_DOT_core_list) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) tmp22 := lang.Apply(tmp21, []any{v3}) tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) tmp24 := lang.Apply(tmp15, []any{tmp23}) @@ -10549,9 +11556,7 @@ func LoadNS() { } // end let return tmp4 default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -10562,7 +11567,7 @@ func LoadNS() { { // let // let binding "op" var tmp6 any - tmp7 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp7) { tmp6 = closed32 } else { @@ -10570,30 +11575,28 @@ func LoadNS() { } var v8 any = tmp6 _ = v8 - tmp9 := checkDerefVar(glojure_DOT_core_reduce1) + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) var tmp10 lang.FnFunc tmp10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v11 := args[0] _ = v11 v12 := args[1] _ = v12 - tmp13 := checkDerefVar(glojure_DOT_core_seq) - tmp14 := checkDerefVar(glojure_DOT_core_concat) - tmp15 := checkDerefVar(glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) - tmp17 := checkDerefVar(glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp19 := checkDerefVar(glojure_DOT_core_list) - tmp20 := checkDerefVar(glojure_DOT_core_seq) - tmp21 := checkDerefVar(glojure_DOT_core_concat) - tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) tmp23 := lang.Apply(tmp22, []any{v8}) - tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) tmp25 := lang.Apply(tmp24, []any{v11}) - tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) tmp27 := lang.Apply(tmp26, []any{v12}) tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) tmp29 := lang.Apply(tmp20, []any{tmp28}) @@ -10602,25 +11605,25 @@ func LoadNS() { tmp32 := lang.Apply(tmp13, []any{tmp31}) return tmp32 }) - tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp13 := checkDerefVar(glojure_DOT_core_seq) - tmp14 := checkDerefVar(glojure_DOT_core_concat) - tmp15 := checkDerefVar(glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) - tmp17 := checkDerefVar(glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp19 := checkDerefVar(glojure_DOT_core_list) - tmp20 := checkDerefVar(glojure_DOT_core_seq) - tmp21 := checkDerefVar(glojure_DOT_core_concat) - tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) tmp23 := lang.Apply(tmp22, []any{v8}) - tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) tmp25 := lang.Apply(tmp24, []any{v2}) - tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) tmp27 := lang.Apply(tmp26, []any{v3}) tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) tmp29 := lang.Apply(tmp20, []any{tmp28}) @@ -10633,12 +11636,10 @@ func LoadNS() { return tmp5 } }) - tmp1 = tmp1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") @@ -10648,8 +11649,8 @@ func LoadNS() { tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp0 := lang.NewSymbol("bit-xor").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Bitwise exclusive or", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), tmp2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1316), lang.NewKeyword("end-line"), int(1316))).(*lang.Symbol) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym_bit_DASH_xor.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Bitwise exclusive or", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(1316), kw_end_DASH_line, int(1316))).(*lang.Symbol) var tmp4 lang.FnFunc tmp4 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -10665,24 +11666,22 @@ func LoadNS() { tmp8 := lang.Apply(tmp7, []any{v5, v6}) return tmp8 default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v5 := args[0] _ = v5 v6 := args[1] _ = v6 var v7 any = lang.NewList(args[2:]...) _ = v7 - tmp8 := checkDerefVar(glojure_DOT_core_reduce1) - tmp9 := checkDerefVar(glojure_DOT_core_bit_xor) - tmp10 := checkDerefVar(glojure_DOT_core_bit_xor) + tmp8 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp9 := checkDerefVar(var_glojure_DOT_core_bit_DASH_xor) + tmp10 := checkDerefVar(var_glojure_DOT_core_bit_DASH_xor) tmp11 := lang.Apply(tmp10, []any{v5, v6}) tmp12 := lang.Apply(tmp8, []any{tmp9, tmp11, v7}) return tmp12 } }) - tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp4 = tmp4.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp3 := ns.InternWithValue(tmp0, tmp4, true) if tmp0.Meta() != nil { tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -10694,23 +11693,21 @@ func LoadNS() { { // function boolean__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) - tmp5 := checkDerefVar(glojure_DOT_core_concat) - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := checkDerefVar(glojure_DOT_core_seq) - tmp12 := checkDerefVar(glojure_DOT_core_concat) - tmp13 := checkDerefVar(glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/BooleanCast")}) - tmp15 := checkDerefVar(glojure_DOT_core_list) + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_BooleanCast}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) tmp18 := lang.Apply(tmp11, []any{tmp17}) @@ -10722,12 +11719,10 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("boolean").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to boolean", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1601), lang.NewKeyword("end-line"), int(1601))).(*lang.Symbol) + tmp0 := sym_boolean.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to boolean", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(1601), kw_end_DASH_line, int(1601))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 tmp5, _ := lang.FieldOrMethod(runtime7.RT, "BooleanCast") @@ -10737,7 +11732,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v4}) return tmp6 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -10751,26 +11746,24 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) - tmp5 := checkDerefVar(glojure_DOT_core_concat) - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol("glojure.core/BooleanArray")}) - tmp12 := checkDerefVar(glojure_DOT_core_list) - tmp13 := checkDerefVar(glojure_DOT_core_seq) - tmp14 := checkDerefVar(glojure_DOT_core_concat) - tmp15 := checkDerefVar(glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) - tmp17 := checkDerefVar(glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("glojure.core/args")}) + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_BooleanArray}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_unquote_DASH_splicing}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_glojure_DOT_core_SLASH_args}) tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) tmp20 := lang.Apply(tmp13, []any{tmp19}) tmp21 := lang.Apply(tmp12, []any{tmp20}) @@ -10782,7 +11775,7 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("boolean-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Creates an array of booleans", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5309), lang.NewKeyword("end-line"), int(5309))).(*lang.Symbol) + tmp0 := sym_boolean_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_size_DASH_or_DASH_seq), lang.NewVector(sym_size, sym_init_DASH_val_DASH_or_DASH_seq)), kw_inline, tmp1, kw_doc, "Creates an array of booleans", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(5309), kw_end_DASH_line, int(5309))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -10807,10 +11800,11 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -10818,19 +11812,17 @@ func LoadNS() { } // boolean? { - tmp0 := lang.NewSymbol("boolean?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a Boolean", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(518), lang.NewKeyword("end-line"), int(518))).(*lang.Symbol) + tmp0 := sym_boolean_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a Boolean", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(518), kw_end_DASH_line, int(518))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp5 := lang.Apply(tmp4, []any{lang.Builtins["bool"], v3}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -10842,20 +11834,18 @@ func LoadNS() { { // function booleans var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) - tmp5 := checkDerefVar(glojure_DOT_core_concat) - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol("glojure.core/Booleans")}) - tmp12 := checkDerefVar(glojure_DOT_core_list) + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Booleans}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := lang.Apply(tmp12, []any{v3}) tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) tmp15 := lang.Apply(tmp4, []any{tmp14}) @@ -10864,12 +11854,10 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("booleans").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Casts to boolean[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5372), lang.NewKeyword("end-line"), int(5372))).(*lang.Symbol) + tmp0 := sym_booleans.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xs)), kw_inline, tmp1, kw_doc, "Casts to boolean[]", kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(12), kw_line, int(5372), kw_end_DASH_line, int(5372))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Booleans") @@ -10879,7 +11867,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v4}) return tmp6 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -10887,29 +11875,27 @@ func LoadNS() { } // bound-fn { - tmp0 := lang.NewSymbol("bound-fn").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("fntail"))), lang.NewKeyword("doc"), "Returns a function defined by the given fntail, which will install the\n same bindings in effect as in the thread at the time bound-fn was called.\n This may be used to define a helper function which runs on a different\n thread, but needs the same bindings in place.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(2004), lang.NewKeyword("end-line"), int(2004))).(*lang.Symbol) + tmp0 := sym_bound_DASH_fn.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_fntail)), kw_doc, "Returns a function defined by the given fntail, which will install the\n same bindings in effect as in the thread at the time bound-fn was called.\n This may be used to define a helper function which runs on a different\n thread, but needs the same bindings in place.", kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(11), kw_line, int(2004), kw_end_DASH_line, int(2004))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 var v5 any = lang.NewList(args[2:]...) _ = v5 - tmp6 := checkDerefVar(glojure_DOT_core_seq) - tmp7 := checkDerefVar(glojure_DOT_core_concat) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("glojure.core/bound-fn*")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := checkDerefVar(glojure_DOT_core_seq) - tmp12 := checkDerefVar(glojure_DOT_core_concat) - tmp13 := checkDerefVar(glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/fn")}) + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_bound_DASH_fn_STAR_}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_fn}) tmp15 := lang.Apply(tmp12, []any{tmp14, v5}) tmp16 := lang.Apply(tmp11, []any{tmp15}) tmp17 := lang.Apply(tmp10, []any{tmp16}) @@ -10918,7 +11904,7 @@ func LoadNS() { return tmp19 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -10926,18 +11912,16 @@ func LoadNS() { } // bound-fn* { - tmp0 := lang.NewSymbol("bound-fn*").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Returns a function, which will install the same bindings in effect as in\n the thread at the time bound-fn* was called and then call f with any given\n arguments. This may be used to define a helper function which runs on a\n different thread, but needs the same bindings in place.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1992), lang.NewKeyword("end-line"), int(1992))).(*lang.Symbol) + tmp0 := sym_bound_DASH_fn_STAR_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f)), kw_doc, "Returns a function, which will install the same bindings in effect as in\n the thread at the time bound-fn* was called and then call f with any given\n arguments. This may be used to define a helper function which runs on a\n different thread, but needs the same bindings in place.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(1992), kw_end_DASH_line, int(1992))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any { // let // let binding "bindings" - tmp5 := checkDerefVar(glojure_DOT_core_get_thread_bindings) + tmp5 := checkDerefVar(var_glojure_DOT_core_get_DASH_thread_DASH_bindings) tmp6 := lang.Apply(tmp5, nil) var v7 any = tmp6 _ = v7 @@ -10945,18 +11929,16 @@ func LoadNS() { tmp8 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var v9 any = lang.NewList(args[0:]...) _ = v9 - tmp10 := checkDerefVar(glojure_DOT_core_apply) - tmp11 := checkDerefVar(glojure_DOT_core_with_bindings_STAR_) + tmp10 := checkDerefVar(var_glojure_DOT_core_apply) + tmp11 := checkDerefVar(var_glojure_DOT_core_with_DASH_bindings_STAR_) tmp12 := lang.Apply(tmp10, []any{tmp11, v7, v3, v9}) return tmp12 } }) - tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2001), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2002), lang.NewKeyword("end-column"), int(45)) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2001), kw_column, int(5), kw_end_DASH_line, int(2002), kw_end_DASH_column, int(45)) tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) if err != nil { panic(err) @@ -10965,7 +11947,7 @@ func LoadNS() { } // end let return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -10973,22 +11955,18 @@ func LoadNS() { } // bound? { - tmp0 := lang.NewSymbol("bound?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("vars"))), lang.NewKeyword("doc"), "Returns true if all of the vars provided as arguments have any bound value, root or thread-local.\n Implies that deref'ing the provided vars will succeed. Returns true if no vars are provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5491), lang.NewKeyword("end-line"), int(5491))).(*lang.Symbol) + tmp0 := sym_bound_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_vars)), kw_doc, "Returns true if all of the vars provided as arguments have any bound value, root or thread-local.\n Implies that deref'ing the provided vars will succeed. Returns true if no vars are provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(5491), kw_end_DASH_line, int(5491))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_every_QMARK_) + tmp4 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) var tmp5 lang.FnFunc tmp5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v6 := args[0] _ = v6 tmp7, ok := lang.FieldOrMethod(v6, "isBound") @@ -11004,7 +11982,7 @@ func LoadNS() { } return tmp8 }) - tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5497), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5497), lang.NewKeyword("end-column"), int(69)) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5497), kw_column, int(11), kw_end_DASH_line, int(5497), kw_end_DASH_column, int(69)) tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) if err != nil { panic(err) @@ -11013,7 +11991,7 @@ func LoadNS() { return tmp8 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -11021,21 +11999,19 @@ func LoadNS() { } // bounded-count { - tmp0 := lang.NewSymbol("bounded-count").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "If coll is counted? returns its count, else will count at most the first n\n elements of coll using its seq", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7410), lang.NewKeyword("end-line"), int(7410))).(*lang.Symbol) + tmp0 := sym_bounded_DASH_count.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n, sym_coll)), kw_doc, "If coll is counted? returns its count, else will count at most the first n\n elements of coll using its seq", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(7410), kw_end_DASH_line, int(7410))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 var tmp5 any - tmp6 := checkDerefVar(glojure_DOT_core_counted_QMARK_) + tmp6 := checkDerefVar(var_glojure_DOT_core_counted_QMARK_) tmp7 := lang.Apply(tmp6, []any{v4}) if lang.IsTruthy(tmp7) { - tmp8 := checkDerefVar(glojure_DOT_core_count) + tmp8 := checkDerefVar(var_glojure_DOT_core_count) tmp9 := lang.Apply(tmp8, []any{v4}) tmp5 = tmp9 } else { @@ -11045,7 +12021,7 @@ func LoadNS() { var v11 any = int64(0) _ = v11 // let binding "s" - tmp12 := checkDerefVar(glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := lang.Apply(tmp12, []any{v4}) var v14 any = tmp13 _ = v14 @@ -11058,7 +12034,7 @@ func LoadNS() { _ = v17 var tmp18 any if lang.IsTruthy(v17) { - tmp19 := checkDerefVar(glojure_DOT_core__LT_) + tmp19 := checkDerefVar(var_glojure_DOT_core__LT_) tmp20 := lang.Apply(tmp19, []any{v11, v3}) tmp18 = tmp20 } else { @@ -11067,10 +12043,10 @@ func LoadNS() { tmp16 = tmp18 } // end let if lang.IsTruthy(tmp16) { - tmp18 := checkDerefVar(glojure_DOT_core_inc) + tmp18 := checkDerefVar(var_glojure_DOT_core_inc) tmp19 := lang.Apply(tmp18, []any{v11}) var tmp17 any = tmp19 - tmp21 := checkDerefVar(glojure_DOT_core_next) + tmp21 := checkDerefVar(var_glojure_DOT_core_next) tmp22 := lang.Apply(tmp21, []any{v14}) var tmp20 any = tmp22 v11 = tmp17 @@ -11087,7 +12063,7 @@ func LoadNS() { } return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -11095,21 +12071,19 @@ func LoadNS() { } // butlast { - tmp0 := lang.NewSymbol("butlast").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return a seq of all but the last item in coll, in linear time", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(272), lang.NewKeyword("end-line"), int(276))).(*lang.Symbol) + tmp0 := sym_butlast.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Return a seq of all but the last item in coll, in linear time", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(2), kw_line, int(272), kw_end_DASH_line, int(276))).(*lang.Symbol) var tmp2 lang.FnFunc { // function butlast var v3 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 var tmp5 any { // let // let binding "ret" tmp6 := lang.NewVector() - tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(277), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(277), lang.NewKeyword("end-column"), int(24)) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(277), kw_column, int(23), kw_end_DASH_line, int(277), kw_end_DASH_column, int(24)) tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) if err != nil { panic(err) @@ -11121,22 +12095,22 @@ func LoadNS() { _ = v10 for { var tmp11 any - tmp12 := checkDerefVar(glojure_DOT_core_next) + tmp12 := checkDerefVar(var_glojure_DOT_core_next) tmp13 := lang.Apply(tmp12, []any{v10}) if lang.IsTruthy(tmp13) { - tmp15 := checkDerefVar(glojure_DOT_core_conj) - tmp16 := checkDerefVar(glojure_DOT_core_first) + tmp15 := checkDerefVar(var_glojure_DOT_core_conj) + tmp16 := checkDerefVar(var_glojure_DOT_core_first) tmp17 := lang.Apply(tmp16, []any{v10}) tmp18 := lang.Apply(tmp15, []any{v9, tmp17}) var tmp14 any = tmp18 - tmp20 := checkDerefVar(glojure_DOT_core_next) + tmp20 := checkDerefVar(var_glojure_DOT_core_next) tmp21 := lang.Apply(tmp20, []any{v10}) var tmp19 any = tmp21 v9 = tmp14 v10 = tmp19 continue } else { - tmp22 := checkDerefVar(glojure_DOT_core_seq) + tmp22 := checkDerefVar(var_glojure_DOT_core_seq) tmp23 := lang.Apply(tmp22, []any{v9}) tmp11 = tmp23 } @@ -11146,7 +12120,7 @@ func LoadNS() { } // end let return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(276), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(280), lang.NewKeyword("end-column"), int(27))).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(276), kw_column, int(10), kw_end_DASH_line, int(280), kw_end_DASH_column, int(27))).(lang.FnFunc) v3 = tmp2 _ = v3 } @@ -11161,30 +12135,28 @@ func LoadNS() { { // function byte__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) - tmp5 := checkDerefVar(glojure_DOT_core_concat) - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := checkDerefVar(glojure_DOT_core_seq) - tmp12 := checkDerefVar(glojure_DOT_core_concat) - tmp13 := checkDerefVar(glojure_DOT_core_list) + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) var tmp14 any - tmp15 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + tmp15 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp15) { - tmp14 = lang.NewSymbol("uncheckedByteCast") + tmp14 = sym_uncheckedByteCast } else { - tmp14 = lang.NewSymbol("byteCast") + tmp14 = sym_byteCast } tmp16 := lang.Apply(tmp13, []any{tmp14}) - tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) tmp18 := lang.Apply(tmp17, []any{v3}) tmp19 := lang.Apply(tmp12, []any{tmp16, tmp18}) tmp20 := lang.Apply(tmp11, []any{tmp19}) @@ -11196,18 +12168,16 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("byte").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to byte", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3505), lang.NewKeyword("end-line"), int(3505))).(*lang.Symbol) + tmp0 := sym_byte.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to byte", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3505), kw_end_DASH_line, int(3505))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 tmp5 := lang.Apply(lang.ByteCast, []any{v4}) return tmp5 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -11221,26 +12191,24 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) - tmp5 := checkDerefVar(glojure_DOT_core_concat) - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol("glojure.core/ByteArray")}) - tmp12 := checkDerefVar(glojure_DOT_core_list) - tmp13 := checkDerefVar(glojure_DOT_core_seq) - tmp14 := checkDerefVar(glojure_DOT_core_concat) - tmp15 := checkDerefVar(glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) - tmp17 := checkDerefVar(glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("glojure.core/args")}) + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_ByteArray}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_unquote_DASH_splicing}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_glojure_DOT_core_SLASH_args}) tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) tmp20 := lang.Apply(tmp13, []any{tmp19}) tmp21 := lang.Apply(tmp12, []any{tmp20}) @@ -11252,7 +12220,7 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("byte-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Creates an array of bytes", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5317), lang.NewKeyword("end-line"), int(5317))).(*lang.Symbol) + tmp0 := sym_byte_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_size_DASH_or_DASH_seq), lang.NewVector(sym_size, sym_init_DASH_val_DASH_or_DASH_seq)), kw_inline, tmp1, kw_doc, "Creates an array of bytes", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(5317), kw_end_DASH_line, int(5317))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -11277,10 +12245,11 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -11292,20 +12261,18 @@ func LoadNS() { { // function bytes var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) - tmp5 := checkDerefVar(glojure_DOT_core_concat) - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol("glojure.core/Bytes")}) - tmp12 := checkDerefVar(glojure_DOT_core_list) + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Bytes}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := lang.Apply(tmp12, []any{v3}) tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) tmp15 := lang.Apply(tmp4, []any{tmp14}) @@ -11314,12 +12281,10 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("bytes").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Casts to bytes[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5377), lang.NewKeyword("end-line"), int(5377))).(*lang.Symbol) + tmp0 := sym_bytes.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xs)), kw_inline, tmp1, kw_doc, "Casts to bytes[]", kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(12), kw_line, int(5377), kw_end_DASH_line, int(5377))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Bytes") @@ -11329,7 +12294,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v4}) return tmp6 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -11337,22 +12302,20 @@ func LoadNS() { } // bytes? { - tmp0 := lang.NewSymbol("bytes?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a byte array", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5412), lang.NewKeyword("end-line"), int(5412))).(*lang.Symbol) + tmp0 := sym_bytes_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a byte array", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(5412), kw_end_DASH_line, int(5412))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any - tmp5 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) tmp6 := lang.Apply(tmp5, []any{v3}) if lang.IsTruthy(tmp6) { tmp4 = false } else { - tmp7 := checkDerefVar(glojure_DOT_core__EQ_) - tmp8 := checkDerefVar(glojure_DOT_core_class) + tmp7 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp8 := checkDerefVar(var_glojure_DOT_core_class) tmp9 := lang.Apply(tmp8, []any{v3}) tmp10, ok := lang.FieldOrMethod(tmp9, "getComponentType") if !ok { @@ -11370,7 +12333,7 @@ func LoadNS() { } return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -11378,14 +12341,12 @@ func LoadNS() { } // case { - tmp0 := lang.NewSymbol("case").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("e"), lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes an expression, and a set of clauses.\n\n Each clause can take the form of either:\n\n test-constant result-expr\n\n (test-constant1 ... test-constantN) result-expr\n\n The test-constants are not evaluated. They must be compile-time\n literals, and need not be quoted. If the expression is equal to a\n test-constant, the corresponding result-expr is returned. A single\n default expression can follow the clauses, and its value will be\n returned if no clause matches. If no default expression is provided\n and no clause matches, an IllegalArgumentException is thrown.\n\n Unlike cond and condp, case does a constant-time dispatch, the\n clauses are not considered sequentially. All manner of constant\n expressions are acceptable in case, including numbers, strings,\n symbols, keywords, and (Clojure) composites thereof. Note that since\n lists are used to group multiple constants that map to the same\n expression, a vector can be used to match a list if needed. The\n test-constants need not be all of the same type.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6712), lang.NewKeyword("end-line"), int(6712))).(*lang.Symbol) + tmp0 := sym_case.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_e, sym__AMP_, sym_clauses)), kw_doc, "Takes an expression, and a set of clauses.\n\n Each clause can take the form of either:\n\n test-constant result-expr\n\n (test-constant1 ... test-constantN) result-expr\n\n The test-constants are not evaluated. They must be compile-time\n literals, and need not be quoted. If the expression is equal to a\n test-constant, the corresponding result-expr is returned. A single\n default expression can follow the clauses, and its value will be\n returned if no clause matches. If no default expression is provided\n and no clause matches, an IllegalArgumentException is thrown.\n\n Unlike cond and condp, case does a constant-time dispatch, the\n clauses are not considered sequentially. All manner of constant\n expressions are acceptable in case, including numbers, strings,\n symbols, keywords, and (Clojure) composites thereof. Note that since\n lists are used to group multiple constants that map to the same\n expression, a vector can be used to match a list if needed. The\n test-constants need not be all of the same type.", kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(11), kw_line, int(6712), kw_end_DASH_line, int(6712))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -11397,12 +12358,12 @@ func LoadNS() { var tmp7 any { // let // let binding "ge" - tmp8 := checkDerefVar(glojure_DOT_core_with_meta) - tmp9 := checkDerefVar(glojure_DOT_core_gensym) + tmp8 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp9 := checkDerefVar(var_glojure_DOT_core_gensym) tmp10 := lang.Apply(tmp9, nil) tmp11 := reflect.TypeOf((*lang.Object)(nil)).Elem() - tmp12 := lang.NewMap(lang.NewKeyword("tag"), tmp11) - tmp13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6738), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(6738), lang.NewKeyword("end-column"), int(84)) + tmp12 := lang.NewMap(kw_tag, tmp11) + tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6738), kw_column, int(32), kw_end_DASH_line, int(6738), kw_end_DASH_column, int(84)) tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) if err != nil { panic(err) @@ -11412,32 +12373,32 @@ func LoadNS() { _ = v16 // let binding "default" var tmp17 any - tmp18 := checkDerefVar(glojure_DOT_core_odd_QMARK_) - tmp19 := checkDerefVar(glojure_DOT_core_count) + tmp18 := checkDerefVar(var_glojure_DOT_core_odd_QMARK_) + tmp19 := checkDerefVar(var_glojure_DOT_core_count) tmp20 := lang.Apply(tmp19, []any{v6}) tmp21 := lang.Apply(tmp18, []any{tmp20}) if lang.IsTruthy(tmp21) { - tmp22 := checkDerefVar(glojure_DOT_core_last) + tmp22 := checkDerefVar(var_glojure_DOT_core_last) tmp23 := lang.Apply(tmp22, []any{v6}) tmp17 = tmp23 } else { - tmp24 := checkDerefVar(glojure_DOT_core_seq) - tmp25 := checkDerefVar(glojure_DOT_core_concat) - tmp26 := checkDerefVar(glojure_DOT_core_list) - tmp27 := lang.Apply(tmp26, []any{lang.NewSymbol("throw")}) - tmp28 := checkDerefVar(glojure_DOT_core_list) - tmp29 := checkDerefVar(glojure_DOT_core_seq) - tmp30 := checkDerefVar(glojure_DOT_core_concat) - tmp31 := checkDerefVar(glojure_DOT_core_list) - tmp32 := lang.Apply(tmp31, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewIllegalArgumentError")}) - tmp33 := checkDerefVar(glojure_DOT_core_list) - tmp34 := checkDerefVar(glojure_DOT_core_seq) - tmp35 := checkDerefVar(glojure_DOT_core_concat) - tmp36 := checkDerefVar(glojure_DOT_core_list) - tmp37 := lang.Apply(tmp36, []any{lang.NewSymbol("glojure.core/str")}) - tmp38 := checkDerefVar(glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_seq) + tmp25 := checkDerefVar(var_glojure_DOT_core_concat) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{sym_throw}) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := checkDerefVar(var_glojure_DOT_core_seq) + tmp30 := checkDerefVar(var_glojure_DOT_core_concat) + tmp31 := checkDerefVar(var_glojure_DOT_core_list) + tmp32 := lang.Apply(tmp31, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_NewIllegalArgumentError}) + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := checkDerefVar(var_glojure_DOT_core_seq) + tmp35 := checkDerefVar(var_glojure_DOT_core_concat) + tmp36 := checkDerefVar(var_glojure_DOT_core_list) + tmp37 := lang.Apply(tmp36, []any{sym_glojure_DOT_core_SLASH_str}) + tmp38 := checkDerefVar(var_glojure_DOT_core_list) tmp39 := lang.Apply(tmp38, []any{"No matching clause: "}) - tmp40 := checkDerefVar(glojure_DOT_core_list) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) tmp41 := lang.Apply(tmp40, []any{v16}) tmp42 := lang.Apply(tmp35, []any{tmp37, tmp39, tmp41}) tmp43 := lang.Apply(tmp34, []any{tmp42}) @@ -11452,29 +12413,29 @@ func LoadNS() { var v50 any = tmp17 _ = v50 var tmp51 any - tmp52 := checkDerefVar(glojure_DOT_core__GT_) - tmp53 := checkDerefVar(glojure_DOT_core_count) + tmp52 := checkDerefVar(var_glojure_DOT_core__GT_) + tmp53 := checkDerefVar(var_glojure_DOT_core_count) tmp54 := lang.Apply(tmp53, []any{v6}) tmp55 := lang.Apply(tmp52, []any{int64(2), tmp54}) if lang.IsTruthy(tmp55) { - tmp56 := checkDerefVar(glojure_DOT_core_seq) - tmp57 := checkDerefVar(glojure_DOT_core_concat) - tmp58 := checkDerefVar(glojure_DOT_core_list) - tmp59 := lang.Apply(tmp58, []any{lang.NewSymbol("glojure.core/let")}) - tmp60 := checkDerefVar(glojure_DOT_core_list) - tmp61 := checkDerefVar(glojure_DOT_core_apply) - tmp62 := checkDerefVar(glojure_DOT_core_vector) - tmp63 := checkDerefVar(glojure_DOT_core_seq) - tmp64 := checkDerefVar(glojure_DOT_core_concat) - tmp65 := checkDerefVar(glojure_DOT_core_list) + tmp56 := checkDerefVar(var_glojure_DOT_core_seq) + tmp57 := checkDerefVar(var_glojure_DOT_core_concat) + tmp58 := checkDerefVar(var_glojure_DOT_core_list) + tmp59 := lang.Apply(tmp58, []any{sym_glojure_DOT_core_SLASH_let}) + tmp60 := checkDerefVar(var_glojure_DOT_core_list) + tmp61 := checkDerefVar(var_glojure_DOT_core_apply) + tmp62 := checkDerefVar(var_glojure_DOT_core_vector) + tmp63 := checkDerefVar(var_glojure_DOT_core_seq) + tmp64 := checkDerefVar(var_glojure_DOT_core_concat) + tmp65 := checkDerefVar(var_glojure_DOT_core_list) tmp66 := lang.Apply(tmp65, []any{v16}) - tmp67 := checkDerefVar(glojure_DOT_core_list) + tmp67 := checkDerefVar(var_glojure_DOT_core_list) tmp68 := lang.Apply(tmp67, []any{v5}) tmp69 := lang.Apply(tmp64, []any{tmp66, tmp68}) tmp70 := lang.Apply(tmp63, []any{tmp69}) tmp71 := lang.Apply(tmp61, []any{tmp62, tmp70}) tmp72 := lang.Apply(tmp60, []any{tmp71}) - tmp73 := checkDerefVar(glojure_DOT_core_list) + tmp73 := checkDerefVar(var_glojure_DOT_core_list) tmp74 := lang.Apply(tmp73, []any{v50}) tmp75 := lang.Apply(tmp57, []any{tmp59, tmp72, tmp74}) tmp76 := lang.Apply(tmp56, []any{tmp75}) @@ -11483,7 +12444,7 @@ func LoadNS() { var tmp77 any { // let // let binding "pairs" - tmp78 := checkDerefVar(glojure_DOT_core_partition) + tmp78 := checkDerefVar(var_glojure_DOT_core_partition) tmp79 := lang.Apply(tmp78, []any{int64(2), v6}) var v80 any = tmp79 _ = v80 @@ -11492,9 +12453,7 @@ func LoadNS() { { // function assoc-test var v82 lang.FnFunc tmp81 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v83 := args[0] _ = v83 v84 := args[1] @@ -11502,15 +12461,15 @@ func LoadNS() { v85 := args[2] _ = v85 var tmp86 any - tmp87 := checkDerefVar(glojure_DOT_core_contains_QMARK_) + tmp87 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) tmp88 := lang.Apply(tmp87, []any{v83, v84}) if lang.IsTruthy(tmp88) { - tmp89 := checkDerefVar(glojure_DOT_core_str) + tmp89 := checkDerefVar(var_glojure_DOT_core_str) tmp90 := lang.Apply(tmp89, []any{"Duplicate case test constant: ", v84}) tmp91 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp90}) panic(tmp91) } else { - tmp92 := checkDerefVar(glojure_DOT_core_assoc) + tmp92 := checkDerefVar(var_glojure_DOT_core_assoc) tmp93 := lang.Apply(tmp92, []any{v83, v84, v85}) tmp86 = tmp93 } @@ -11519,7 +12478,7 @@ func LoadNS() { v82 = tmp81 _ = v82 } - tmp82 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6745), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(6748), lang.NewKeyword("end-column"), int(48)) + tmp82 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6745), kw_column, int(24), kw_end_DASH_line, int(6748), kw_end_DASH_column, int(48)) tmp83, err := lang.WithMeta(tmp81, tmp82.(lang.IPersistentMap)) if err != nil { panic(err) @@ -11527,12 +12486,10 @@ func LoadNS() { var v84 any = tmp83 _ = v84 // let binding "pairs" - tmp85 := checkDerefVar(glojure_DOT_core_reduce1) + tmp85 := checkDerefVar(var_glojure_DOT_core_reduce1) var tmp86 lang.FnFunc tmp86 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v87 := args[0] _ = v87 v88 := args[1] @@ -11543,25 +12500,23 @@ func LoadNS() { var v90 any = v88 _ = v90 // let binding "test" - tmp91 := checkDerefVar(glojure_DOT_core_nth) + tmp91 := checkDerefVar(var_glojure_DOT_core_nth) tmp92 := lang.Apply(tmp91, []any{v90, int64(0), nil}) var v93 any = tmp92 _ = v93 // let binding "expr" - tmp94 := checkDerefVar(glojure_DOT_core_nth) + tmp94 := checkDerefVar(var_glojure_DOT_core_nth) tmp95 := lang.Apply(tmp94, []any{v90, int64(1), nil}) var v96 any = tmp95 _ = v96 var tmp97 any - tmp98 := checkDerefVar(glojure_DOT_core_seq_QMARK_) + tmp98 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) tmp99 := lang.Apply(tmp98, []any{v93}) if lang.IsTruthy(tmp99) { - tmp100 := checkDerefVar(glojure_DOT_core_reduce1) + tmp100 := checkDerefVar(var_glojure_DOT_core_reduce1) var tmp101 lang.FnFunc tmp101 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v102 := args[0] _ = v102 v103 := args[1] @@ -11569,7 +12524,7 @@ func LoadNS() { tmp104 := lang.Apply(v84, []any{v102, v103, v96}) return tmp104 }) - tmp102 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6752), lang.NewKeyword("column"), int(37), lang.NewKeyword("end-line"), int(6752), lang.NewKeyword("end-column"), int(60)) + tmp102 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6752), kw_column, int(37), kw_end_DASH_line, int(6752), kw_end_DASH_column, int(60)) tmp103, err := lang.WithMeta(tmp101, tmp102.(lang.IPersistentMap)) if err != nil { panic(err) @@ -11584,13 +12539,13 @@ func LoadNS() { } // end let return tmp89 }) - tmp87 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6750), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(6753), lang.NewKeyword("end-column"), int(53)) + tmp87 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6750), kw_column, int(24), kw_end_DASH_line, int(6753), kw_end_DASH_column, int(53)) tmp88, err := lang.WithMeta(tmp86, tmp87.(lang.IPersistentMap)) if err != nil { panic(err) } tmp89 := lang.NewMap() - tmp90 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6754), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(6754), lang.NewKeyword("end-column"), int(25)) + tmp90 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6754), kw_column, int(24), kw_end_DASH_line, int(6754), kw_end_DASH_column, int(25)) tmp91, err := lang.WithMeta(tmp89, tmp90.(lang.IPersistentMap)) if err != nil { panic(err) @@ -11599,35 +12554,33 @@ func LoadNS() { var v93 any = tmp92 _ = v93 // let binding "tests" - tmp94 := checkDerefVar(glojure_DOT_core_keys) + tmp94 := checkDerefVar(var_glojure_DOT_core_keys) tmp95 := lang.Apply(tmp94, []any{v93}) var v96 any = tmp95 _ = v96 // let binding "thens" - tmp97 := checkDerefVar(glojure_DOT_core_vals) + tmp97 := checkDerefVar(var_glojure_DOT_core_vals) tmp98 := lang.Apply(tmp97, []any{v93}) var v99 any = tmp98 _ = v99 // let binding "mode" var tmp100 any - tmp101 := checkDerefVar(glojure_DOT_core_every_QMARK_) + tmp101 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) var tmp102 lang.FnFunc tmp102 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v103 := args[0] _ = v103 var tmp104 any { // let // let binding "and__0__auto__" - tmp105 := checkDerefVar(glojure_DOT_core_integer_QMARK_) + tmp105 := checkDerefVar(var_glojure_DOT_core_integer_QMARK_) tmp106 := lang.Apply(tmp105, []any{v103}) var v107 any = tmp106 _ = v107 var tmp108 any if lang.IsTruthy(v107) { - tmp109 := checkDerefVar(glojure_DOT_core__LT__EQ_) + tmp109 := checkDerefVar(var_glojure_DOT_core__LT__EQ_) tmp110 := lang.Apply(tmp109, []any{math6.MinInt, v103, math6.MaxInt}) tmp108 = tmp110 } else { @@ -11637,25 +12590,25 @@ func LoadNS() { } // end let return tmp104 }) - tmp103 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6758), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(6758), lang.NewKeyword("end-column"), int(77)) + tmp103 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6758), kw_column, int(28), kw_end_DASH_line, int(6758), kw_end_DASH_column, int(77)) tmp104, err := lang.WithMeta(tmp102, tmp103.(lang.IPersistentMap)) if err != nil { panic(err) } tmp105 := lang.Apply(tmp101, []any{tmp104, v96}) if lang.IsTruthy(tmp105) { - tmp100 = lang.NewKeyword("ints") + tmp100 = kw_ints } else { var tmp106 any - tmp107 := checkDerefVar(glojure_DOT_core_every_QMARK_) - tmp108 := checkDerefVar(glojure_DOT_core_keyword_QMARK_) + tmp107 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + tmp108 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) tmp109 := lang.Apply(tmp107, []any{tmp108, v96}) if lang.IsTruthy(tmp109) { - tmp106 = lang.NewKeyword("identity") + tmp106 = kw_identity } else { var tmp110 any - if lang.IsTruthy(lang.NewKeyword("else")) { - tmp110 = lang.NewKeyword("hashes") + if lang.IsTruthy(kw_else) { + tmp110 = kw_hashes } else { } tmp106 = tmp110 @@ -11667,78 +12620,78 @@ func LoadNS() { var tmp112 any { // let // let binding "pred__180" - tmp113 := checkDerefVar(glojure_DOT_core__EQ_) + tmp113 := checkDerefVar(var_glojure_DOT_core__EQ_) var v114 any = tmp113 _ = v114 // let binding "expr__181" var v115 any = v111 _ = v115 var tmp116 any - tmp117 := lang.Apply(v114, []any{lang.NewKeyword("ints"), v115}) + tmp117 := lang.Apply(v114, []any{kw_ints, v115}) if lang.IsTruthy(tmp117) { var tmp118 any { // let // let binding "vec__182" - tmp119 := checkDerefVar(glojure_DOT_core_prep_ints) + tmp119 := checkDerefVar(var_glojure_DOT_core_prep_DASH_ints) tmp120 := lang.Apply(tmp119, []any{v96, v99}) var v121 any = tmp120 _ = v121 // let binding "shift" - tmp122 := checkDerefVar(glojure_DOT_core_nth) + tmp122 := checkDerefVar(var_glojure_DOT_core_nth) tmp123 := lang.Apply(tmp122, []any{v121, int64(0), nil}) var v124 any = tmp123 _ = v124 // let binding "mask" - tmp125 := checkDerefVar(glojure_DOT_core_nth) + tmp125 := checkDerefVar(var_glojure_DOT_core_nth) tmp126 := lang.Apply(tmp125, []any{v121, int64(1), nil}) var v127 any = tmp126 _ = v127 // let binding "imap" - tmp128 := checkDerefVar(glojure_DOT_core_nth) + tmp128 := checkDerefVar(var_glojure_DOT_core_nth) tmp129 := lang.Apply(tmp128, []any{v121, int64(2), nil}) var v130 any = tmp129 _ = v130 // let binding "switch-type" - tmp131 := checkDerefVar(glojure_DOT_core_nth) + tmp131 := checkDerefVar(var_glojure_DOT_core_nth) tmp132 := lang.Apply(tmp131, []any{v121, int64(3), nil}) var v133 any = tmp132 _ = v133 - tmp134 := checkDerefVar(glojure_DOT_core_seq) - tmp135 := checkDerefVar(glojure_DOT_core_concat) - tmp136 := checkDerefVar(glojure_DOT_core_list) - tmp137 := lang.Apply(tmp136, []any{lang.NewSymbol("glojure.core/let")}) - tmp138 := checkDerefVar(glojure_DOT_core_list) - tmp139 := checkDerefVar(glojure_DOT_core_apply) - tmp140 := checkDerefVar(glojure_DOT_core_vector) - tmp141 := checkDerefVar(glojure_DOT_core_seq) - tmp142 := checkDerefVar(glojure_DOT_core_concat) - tmp143 := checkDerefVar(glojure_DOT_core_list) + tmp134 := checkDerefVar(var_glojure_DOT_core_seq) + tmp135 := checkDerefVar(var_glojure_DOT_core_concat) + tmp136 := checkDerefVar(var_glojure_DOT_core_list) + tmp137 := lang.Apply(tmp136, []any{sym_glojure_DOT_core_SLASH_let}) + tmp138 := checkDerefVar(var_glojure_DOT_core_list) + tmp139 := checkDerefVar(var_glojure_DOT_core_apply) + tmp140 := checkDerefVar(var_glojure_DOT_core_vector) + tmp141 := checkDerefVar(var_glojure_DOT_core_seq) + tmp142 := checkDerefVar(var_glojure_DOT_core_concat) + tmp143 := checkDerefVar(var_glojure_DOT_core_list) tmp144 := lang.Apply(tmp143, []any{v16}) - tmp145 := checkDerefVar(glojure_DOT_core_list) + tmp145 := checkDerefVar(var_glojure_DOT_core_list) tmp146 := lang.Apply(tmp145, []any{v5}) tmp147 := lang.Apply(tmp142, []any{tmp144, tmp146}) tmp148 := lang.Apply(tmp141, []any{tmp147}) tmp149 := lang.Apply(tmp139, []any{tmp140, tmp148}) tmp150 := lang.Apply(tmp138, []any{tmp149}) - tmp151 := checkDerefVar(glojure_DOT_core_list) - tmp152 := checkDerefVar(glojure_DOT_core_seq) - tmp153 := checkDerefVar(glojure_DOT_core_concat) - tmp154 := checkDerefVar(glojure_DOT_core_list) - tmp155 := lang.Apply(tmp154, []any{lang.NewSymbol("case*")}) - tmp156 := checkDerefVar(glojure_DOT_core_list) + tmp151 := checkDerefVar(var_glojure_DOT_core_list) + tmp152 := checkDerefVar(var_glojure_DOT_core_seq) + tmp153 := checkDerefVar(var_glojure_DOT_core_concat) + tmp154 := checkDerefVar(var_glojure_DOT_core_list) + tmp155 := lang.Apply(tmp154, []any{sym_case_STAR_}) + tmp156 := checkDerefVar(var_glojure_DOT_core_list) tmp157 := lang.Apply(tmp156, []any{v16}) - tmp158 := checkDerefVar(glojure_DOT_core_list) + tmp158 := checkDerefVar(var_glojure_DOT_core_list) tmp159 := lang.Apply(tmp158, []any{v124}) - tmp160 := checkDerefVar(glojure_DOT_core_list) + tmp160 := checkDerefVar(var_glojure_DOT_core_list) tmp161 := lang.Apply(tmp160, []any{v127}) - tmp162 := checkDerefVar(glojure_DOT_core_list) + tmp162 := checkDerefVar(var_glojure_DOT_core_list) tmp163 := lang.Apply(tmp162, []any{v50}) - tmp164 := checkDerefVar(glojure_DOT_core_list) + tmp164 := checkDerefVar(var_glojure_DOT_core_list) tmp165 := lang.Apply(tmp164, []any{v130}) - tmp166 := checkDerefVar(glojure_DOT_core_list) + tmp166 := checkDerefVar(var_glojure_DOT_core_list) tmp167 := lang.Apply(tmp166, []any{v133}) - tmp168 := checkDerefVar(glojure_DOT_core_list) - tmp169 := lang.Apply(tmp168, []any{lang.NewKeyword("int")}) + tmp168 := checkDerefVar(var_glojure_DOT_core_list) + tmp169 := lang.Apply(tmp168, []any{kw_int}) tmp170 := lang.Apply(tmp153, []any{tmp155, tmp157, tmp159, tmp161, tmp163, tmp165, tmp167, tmp169}) tmp171 := lang.Apply(tmp152, []any{tmp170}) tmp172 := lang.Apply(tmp151, []any{tmp171}) @@ -11749,77 +12702,77 @@ func LoadNS() { tmp116 = tmp118 } else { var tmp119 any - tmp120 := lang.Apply(v114, []any{lang.NewKeyword("hashes"), v115}) + tmp120 := lang.Apply(v114, []any{kw_hashes, v115}) if lang.IsTruthy(tmp120) { var tmp121 any { // let // let binding "vec__185" - tmp122 := checkDerefVar(glojure_DOT_core_prep_hashes) + tmp122 := checkDerefVar(var_glojure_DOT_core_prep_DASH_hashes) tmp123 := lang.Apply(tmp122, []any{v16, v50, v96, v99}) var v124 any = tmp123 _ = v124 // let binding "shift" - tmp125 := checkDerefVar(glojure_DOT_core_nth) + tmp125 := checkDerefVar(var_glojure_DOT_core_nth) tmp126 := lang.Apply(tmp125, []any{v124, int64(0), nil}) var v127 any = tmp126 _ = v127 // let binding "mask" - tmp128 := checkDerefVar(glojure_DOT_core_nth) + tmp128 := checkDerefVar(var_glojure_DOT_core_nth) tmp129 := lang.Apply(tmp128, []any{v124, int64(1), nil}) var v130 any = tmp129 _ = v130 // let binding "imap" - tmp131 := checkDerefVar(glojure_DOT_core_nth) + tmp131 := checkDerefVar(var_glojure_DOT_core_nth) tmp132 := lang.Apply(tmp131, []any{v124, int64(2), nil}) var v133 any = tmp132 _ = v133 // let binding "switch-type" - tmp134 := checkDerefVar(glojure_DOT_core_nth) + tmp134 := checkDerefVar(var_glojure_DOT_core_nth) tmp135 := lang.Apply(tmp134, []any{v124, int64(3), nil}) var v136 any = tmp135 _ = v136 // let binding "skip-check" - tmp137 := checkDerefVar(glojure_DOT_core_nth) + tmp137 := checkDerefVar(var_glojure_DOT_core_nth) tmp138 := lang.Apply(tmp137, []any{v124, int64(4), nil}) var v139 any = tmp138 _ = v139 - tmp140 := checkDerefVar(glojure_DOT_core_seq) - tmp141 := checkDerefVar(glojure_DOT_core_concat) - tmp142 := checkDerefVar(glojure_DOT_core_list) - tmp143 := lang.Apply(tmp142, []any{lang.NewSymbol("glojure.core/let")}) - tmp144 := checkDerefVar(glojure_DOT_core_list) - tmp145 := checkDerefVar(glojure_DOT_core_apply) - tmp146 := checkDerefVar(glojure_DOT_core_vector) - tmp147 := checkDerefVar(glojure_DOT_core_seq) - tmp148 := checkDerefVar(glojure_DOT_core_concat) - tmp149 := checkDerefVar(glojure_DOT_core_list) + tmp140 := checkDerefVar(var_glojure_DOT_core_seq) + tmp141 := checkDerefVar(var_glojure_DOT_core_concat) + tmp142 := checkDerefVar(var_glojure_DOT_core_list) + tmp143 := lang.Apply(tmp142, []any{sym_glojure_DOT_core_SLASH_let}) + tmp144 := checkDerefVar(var_glojure_DOT_core_list) + tmp145 := checkDerefVar(var_glojure_DOT_core_apply) + tmp146 := checkDerefVar(var_glojure_DOT_core_vector) + tmp147 := checkDerefVar(var_glojure_DOT_core_seq) + tmp148 := checkDerefVar(var_glojure_DOT_core_concat) + tmp149 := checkDerefVar(var_glojure_DOT_core_list) tmp150 := lang.Apply(tmp149, []any{v16}) - tmp151 := checkDerefVar(glojure_DOT_core_list) + tmp151 := checkDerefVar(var_glojure_DOT_core_list) tmp152 := lang.Apply(tmp151, []any{v5}) tmp153 := lang.Apply(tmp148, []any{tmp150, tmp152}) tmp154 := lang.Apply(tmp147, []any{tmp153}) tmp155 := lang.Apply(tmp145, []any{tmp146, tmp154}) tmp156 := lang.Apply(tmp144, []any{tmp155}) - tmp157 := checkDerefVar(glojure_DOT_core_list) - tmp158 := checkDerefVar(glojure_DOT_core_seq) - tmp159 := checkDerefVar(glojure_DOT_core_concat) - tmp160 := checkDerefVar(glojure_DOT_core_list) - tmp161 := lang.Apply(tmp160, []any{lang.NewSymbol("case*")}) - tmp162 := checkDerefVar(glojure_DOT_core_list) + tmp157 := checkDerefVar(var_glojure_DOT_core_list) + tmp158 := checkDerefVar(var_glojure_DOT_core_seq) + tmp159 := checkDerefVar(var_glojure_DOT_core_concat) + tmp160 := checkDerefVar(var_glojure_DOT_core_list) + tmp161 := lang.Apply(tmp160, []any{sym_case_STAR_}) + tmp162 := checkDerefVar(var_glojure_DOT_core_list) tmp163 := lang.Apply(tmp162, []any{v16}) - tmp164 := checkDerefVar(glojure_DOT_core_list) + tmp164 := checkDerefVar(var_glojure_DOT_core_list) tmp165 := lang.Apply(tmp164, []any{v127}) - tmp166 := checkDerefVar(glojure_DOT_core_list) + tmp166 := checkDerefVar(var_glojure_DOT_core_list) tmp167 := lang.Apply(tmp166, []any{v130}) - tmp168 := checkDerefVar(glojure_DOT_core_list) + tmp168 := checkDerefVar(var_glojure_DOT_core_list) tmp169 := lang.Apply(tmp168, []any{v50}) - tmp170 := checkDerefVar(glojure_DOT_core_list) + tmp170 := checkDerefVar(var_glojure_DOT_core_list) tmp171 := lang.Apply(tmp170, []any{v133}) - tmp172 := checkDerefVar(glojure_DOT_core_list) + tmp172 := checkDerefVar(var_glojure_DOT_core_list) tmp173 := lang.Apply(tmp172, []any{v136}) - tmp174 := checkDerefVar(glojure_DOT_core_list) - tmp175 := lang.Apply(tmp174, []any{lang.NewKeyword("hash-equiv")}) - tmp176 := checkDerefVar(glojure_DOT_core_list) + tmp174 := checkDerefVar(var_glojure_DOT_core_list) + tmp175 := lang.Apply(tmp174, []any{kw_hash_DASH_equiv}) + tmp176 := checkDerefVar(var_glojure_DOT_core_list) tmp177 := lang.Apply(tmp176, []any{v139}) tmp178 := lang.Apply(tmp159, []any{tmp161, tmp163, tmp165, tmp167, tmp169, tmp171, tmp173, tmp175, tmp177}) tmp179 := lang.Apply(tmp158, []any{tmp178}) @@ -11831,77 +12784,77 @@ func LoadNS() { tmp119 = tmp121 } else { var tmp122 any - tmp123 := lang.Apply(v114, []any{lang.NewKeyword("identity"), v115}) + tmp123 := lang.Apply(v114, []any{kw_identity, v115}) if lang.IsTruthy(tmp123) { var tmp124 any { // let // let binding "vec__188" - tmp125 := checkDerefVar(glojure_DOT_core_prep_hashes) + tmp125 := checkDerefVar(var_glojure_DOT_core_prep_DASH_hashes) tmp126 := lang.Apply(tmp125, []any{v16, v50, v96, v99}) var v127 any = tmp126 _ = v127 // let binding "shift" - tmp128 := checkDerefVar(glojure_DOT_core_nth) + tmp128 := checkDerefVar(var_glojure_DOT_core_nth) tmp129 := lang.Apply(tmp128, []any{v127, int64(0), nil}) var v130 any = tmp129 _ = v130 // let binding "mask" - tmp131 := checkDerefVar(glojure_DOT_core_nth) + tmp131 := checkDerefVar(var_glojure_DOT_core_nth) tmp132 := lang.Apply(tmp131, []any{v127, int64(1), nil}) var v133 any = tmp132 _ = v133 // let binding "imap" - tmp134 := checkDerefVar(glojure_DOT_core_nth) + tmp134 := checkDerefVar(var_glojure_DOT_core_nth) tmp135 := lang.Apply(tmp134, []any{v127, int64(2), nil}) var v136 any = tmp135 _ = v136 // let binding "switch-type" - tmp137 := checkDerefVar(glojure_DOT_core_nth) + tmp137 := checkDerefVar(var_glojure_DOT_core_nth) tmp138 := lang.Apply(tmp137, []any{v127, int64(3), nil}) var v139 any = tmp138 _ = v139 // let binding "skip-check" - tmp140 := checkDerefVar(glojure_DOT_core_nth) + tmp140 := checkDerefVar(var_glojure_DOT_core_nth) tmp141 := lang.Apply(tmp140, []any{v127, int64(4), nil}) var v142 any = tmp141 _ = v142 - tmp143 := checkDerefVar(glojure_DOT_core_seq) - tmp144 := checkDerefVar(glojure_DOT_core_concat) - tmp145 := checkDerefVar(glojure_DOT_core_list) - tmp146 := lang.Apply(tmp145, []any{lang.NewSymbol("glojure.core/let")}) - tmp147 := checkDerefVar(glojure_DOT_core_list) - tmp148 := checkDerefVar(glojure_DOT_core_apply) - tmp149 := checkDerefVar(glojure_DOT_core_vector) - tmp150 := checkDerefVar(glojure_DOT_core_seq) - tmp151 := checkDerefVar(glojure_DOT_core_concat) - tmp152 := checkDerefVar(glojure_DOT_core_list) + tmp143 := checkDerefVar(var_glojure_DOT_core_seq) + tmp144 := checkDerefVar(var_glojure_DOT_core_concat) + tmp145 := checkDerefVar(var_glojure_DOT_core_list) + tmp146 := lang.Apply(tmp145, []any{sym_glojure_DOT_core_SLASH_let}) + tmp147 := checkDerefVar(var_glojure_DOT_core_list) + tmp148 := checkDerefVar(var_glojure_DOT_core_apply) + tmp149 := checkDerefVar(var_glojure_DOT_core_vector) + tmp150 := checkDerefVar(var_glojure_DOT_core_seq) + tmp151 := checkDerefVar(var_glojure_DOT_core_concat) + tmp152 := checkDerefVar(var_glojure_DOT_core_list) tmp153 := lang.Apply(tmp152, []any{v16}) - tmp154 := checkDerefVar(glojure_DOT_core_list) + tmp154 := checkDerefVar(var_glojure_DOT_core_list) tmp155 := lang.Apply(tmp154, []any{v5}) tmp156 := lang.Apply(tmp151, []any{tmp153, tmp155}) tmp157 := lang.Apply(tmp150, []any{tmp156}) tmp158 := lang.Apply(tmp148, []any{tmp149, tmp157}) tmp159 := lang.Apply(tmp147, []any{tmp158}) - tmp160 := checkDerefVar(glojure_DOT_core_list) - tmp161 := checkDerefVar(glojure_DOT_core_seq) - tmp162 := checkDerefVar(glojure_DOT_core_concat) - tmp163 := checkDerefVar(glojure_DOT_core_list) - tmp164 := lang.Apply(tmp163, []any{lang.NewSymbol("case*")}) - tmp165 := checkDerefVar(glojure_DOT_core_list) + tmp160 := checkDerefVar(var_glojure_DOT_core_list) + tmp161 := checkDerefVar(var_glojure_DOT_core_seq) + tmp162 := checkDerefVar(var_glojure_DOT_core_concat) + tmp163 := checkDerefVar(var_glojure_DOT_core_list) + tmp164 := lang.Apply(tmp163, []any{sym_case_STAR_}) + tmp165 := checkDerefVar(var_glojure_DOT_core_list) tmp166 := lang.Apply(tmp165, []any{v16}) - tmp167 := checkDerefVar(glojure_DOT_core_list) + tmp167 := checkDerefVar(var_glojure_DOT_core_list) tmp168 := lang.Apply(tmp167, []any{v130}) - tmp169 := checkDerefVar(glojure_DOT_core_list) + tmp169 := checkDerefVar(var_glojure_DOT_core_list) tmp170 := lang.Apply(tmp169, []any{v133}) - tmp171 := checkDerefVar(glojure_DOT_core_list) + tmp171 := checkDerefVar(var_glojure_DOT_core_list) tmp172 := lang.Apply(tmp171, []any{v50}) - tmp173 := checkDerefVar(glojure_DOT_core_list) + tmp173 := checkDerefVar(var_glojure_DOT_core_list) tmp174 := lang.Apply(tmp173, []any{v136}) - tmp175 := checkDerefVar(glojure_DOT_core_list) + tmp175 := checkDerefVar(var_glojure_DOT_core_list) tmp176 := lang.Apply(tmp175, []any{v139}) - tmp177 := checkDerefVar(glojure_DOT_core_list) - tmp178 := lang.Apply(tmp177, []any{lang.NewKeyword("hash-identity")}) - tmp179 := checkDerefVar(glojure_DOT_core_list) + tmp177 := checkDerefVar(var_glojure_DOT_core_list) + tmp178 := lang.Apply(tmp177, []any{kw_hash_DASH_identity}) + tmp179 := checkDerefVar(var_glojure_DOT_core_list) tmp180 := lang.Apply(tmp179, []any{v142}) tmp181 := lang.Apply(tmp162, []any{tmp164, tmp166, tmp168, tmp170, tmp172, tmp174, tmp176, tmp178, tmp180}) tmp182 := lang.Apply(tmp161, []any{tmp181}) @@ -11912,7 +12865,7 @@ func LoadNS() { } // end let tmp122 = tmp124 } else { - tmp125 := checkDerefVar(glojure_DOT_core_str) + tmp125 := checkDerefVar(var_glojure_DOT_core_str) tmp126 := lang.Apply(tmp125, []any{"No matching clause: ", v115}) tmp127 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp126}) panic(tmp127) @@ -11932,7 +12885,7 @@ func LoadNS() { return tmp7 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -11940,12 +12893,10 @@ func LoadNS() { } // case-map { - tmp0 := lang.NewSymbol("case-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("case-f"), lang.NewSymbol("test-f"), lang.NewSymbol("tests"), lang.NewSymbol("thens"))), lang.NewKeyword("doc"), "Transforms a sequence of test constants and a corresponding sequence of then\n expressions into a sorted map to be consumed by case*. The form of the map\n entries are {(case-f test) [(test-f test) then]}.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6614), lang.NewKeyword("end-line"), int(6614), lang.NewKeyword("private"), true)).(*lang.Symbol) + tmp0 := sym_case_DASH_map.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_case_DASH_f, sym_test_DASH_f, sym_tests, sym_thens)), kw_doc, "Transforms a sequence of test constants and a corresponding sequence of then\n expressions into a sorted map to be consumed by case*. The form of the map\n entries are {(case-f test) [(test-f test) then]}.", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(8), kw_line, int(6614), kw_end_DASH_line, int(6614), kw_private, true)).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 4) v3 := args[0] _ = v3 v4 := args[1] @@ -11954,22 +12905,22 @@ func LoadNS() { _ = v5 v6 := args[3] _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_into1) - tmp8 := checkDerefVar(glojure_DOT_core_sorted_map) + tmp7 := checkDerefVar(var_glojure_DOT_core_into1) + tmp8 := checkDerefVar(var_glojure_DOT_core_sorted_DASH_map) tmp9 := lang.Apply(tmp8, nil) - tmp10 := checkDerefVar(glojure_DOT_core_zipmap) - tmp11 := checkDerefVar(glojure_DOT_core_map) + tmp10 := checkDerefVar(var_glojure_DOT_core_zipmap) + tmp11 := checkDerefVar(var_glojure_DOT_core_map) tmp12 := lang.Apply(tmp11, []any{v3, v5}) - tmp13 := checkDerefVar(glojure_DOT_core_map) - tmp14 := checkDerefVar(glojure_DOT_core_vector) - tmp15 := checkDerefVar(glojure_DOT_core_map) + tmp13 := checkDerefVar(var_glojure_DOT_core_map) + tmp14 := checkDerefVar(var_glojure_DOT_core_vector) + tmp15 := checkDerefVar(var_glojure_DOT_core_map) tmp16 := lang.Apply(tmp15, []any{v4, v5}) tmp17 := lang.Apply(tmp13, []any{tmp14, tmp16, v6}) tmp18 := lang.Apply(tmp10, []any{tmp12, tmp17}) tmp19 := lang.Apply(tmp7, []any{tmp9, tmp18}) return tmp19 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -11977,12 +12928,10 @@ func LoadNS() { } // cast { - tmp0 := lang.NewSymbol("cast").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Throws a ClassCastException if x is not a c, else returns x.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(345), lang.NewKeyword("end-line"), int(345))).(*lang.Symbol) + tmp0 := sym_cast.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_c, sym_x)), kw_doc, "Throws a ClassCastException if x is not a c, else returns x.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(345), kw_end_DASH_line, int(345))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -11994,7 +12943,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v4}) return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -12002,18 +12951,16 @@ func LoadNS() { } // cat { - tmp0 := lang.NewSymbol("cat").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rf"))), lang.NewKeyword("doc"), "A transducer which concatenates the contents of each input, which must be a\n collection, into the reduction.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7645), lang.NewKeyword("end-line"), int(7645))).(*lang.Symbol) + tmp0 := sym_cat.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_rf)), kw_doc, "A transducer which concatenates the contents of each input, which must be a\n collection, into the reduction.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(7645), kw_end_DASH_line, int(7645))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any { // let // let binding "rrf" - tmp5 := checkDerefVar(glojure_DOT_core_preserving_reduced) + tmp5 := checkDerefVar(var_glojure_DOT_core_preserving_DASH_reduced) tmp6 := lang.Apply(tmp5, []any{v3}) var v7 any = tmp6 _ = v7 @@ -12033,14 +12980,15 @@ func LoadNS() { _ = v9 v10 := args[1] _ = v10 - tmp11 := checkDerefVar(glojure_DOT_core_reduce) + tmp11 := checkDerefVar(var_glojure_DOT_core_reduce) tmp12 := lang.Apply(tmp11, []any{v7, v9, v10}) return tmp12 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7651), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(7655), lang.NewKeyword("end-column"), int(36)) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7651), kw_column, int(5), kw_end_DASH_line, int(7655), kw_end_DASH_column, int(36)) tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) if err != nil { panic(err) @@ -12049,7 +12997,7 @@ func LoadNS() { } // end let return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -12061,30 +13009,28 @@ func LoadNS() { { // function char__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) - tmp5 := checkDerefVar(glojure_DOT_core_concat) - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := checkDerefVar(glojure_DOT_core_seq) - tmp12 := checkDerefVar(glojure_DOT_core_concat) - tmp13 := checkDerefVar(glojure_DOT_core_list) + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) var tmp14 any - tmp15 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + tmp15 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp15) { - tmp14 = lang.NewSymbol("uncheckedCharCast") + tmp14 = sym_uncheckedCharCast } else { - tmp14 = lang.NewSymbol("charCast") + tmp14 = sym_charCast } tmp16 := lang.Apply(tmp13, []any{tmp14}) - tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) tmp18 := lang.Apply(tmp17, []any{v3}) tmp19 := lang.Apply(tmp12, []any{tmp16, tmp18}) tmp20 := lang.Apply(tmp11, []any{tmp19}) @@ -12096,12 +13042,10 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("char").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to char", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3511), lang.NewKeyword("end-line"), int(3511))).(*lang.Symbol) + tmp0 := sym_char.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to char", kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3511), kw_end_DASH_line, int(3511))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 tmp5, _ := lang.FieldOrMethod(runtime7.RT, "CharCast") @@ -12111,7 +13055,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v4}) return tmp6 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -12125,26 +13069,24 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) - tmp5 := checkDerefVar(glojure_DOT_core_concat) - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol("glojure.core/CharArray")}) - tmp12 := checkDerefVar(glojure_DOT_core_list) - tmp13 := checkDerefVar(glojure_DOT_core_seq) - tmp14 := checkDerefVar(glojure_DOT_core_concat) - tmp15 := checkDerefVar(glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) - tmp17 := checkDerefVar(glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("glojure.core/args")}) + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_CharArray}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_unquote_DASH_splicing}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_glojure_DOT_core_SLASH_args}) tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) tmp20 := lang.Apply(tmp13, []any{tmp19}) tmp21 := lang.Apply(tmp12, []any{tmp20}) @@ -12156,7 +13098,7 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("char-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Creates an array of chars", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5325), lang.NewKeyword("end-line"), int(5325))).(*lang.Symbol) + tmp0 := sym_char_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_size_DASH_or_DASH_seq), lang.NewVector(sym_size, sym_init_DASH_val_DASH_or_DASH_seq)), kw_inline, tmp1, kw_doc, "Creates an array of chars", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(5325), kw_end_DASH_line, int(5325))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -12181,10 +13123,11 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -12193,7 +13136,7 @@ func LoadNS() { // char-escape-string { tmp1 := reflect.TypeOf("") - tmp0 := lang.NewSymbol("char-escape-string").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("doc"), "Returns escape string for char or nil if none", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(6), lang.NewKeyword("line"), int(214), lang.NewKeyword("end-line"), int(217))).(*lang.Symbol) + tmp0 := sym_char_DASH_escape_DASH_string.WithMeta(lang.NewMap(kw_tag, tmp1, kw_doc, "Returns escape string for char or nil if none", kw_file, "glojure/core_print.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(6), kw_line, int(214), kw_end_DASH_line, int(217))).(*lang.Symbol) tmp2 := ns.InternWithValue(tmp0, lang.NewMap(lang.NewChar(10), "\\n", lang.NewChar(9), "\\t", lang.NewChar(13), "\\r", lang.NewChar(34), "\\\"", lang.NewChar(92), "\\\\", lang.NewChar(12), "\\f", lang.NewChar(8), "\\b"), true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -12202,7 +13145,7 @@ func LoadNS() { // char-name-string { tmp1 := reflect.TypeOf("") - tmp0 := lang.NewSymbol("char-name-string").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("doc"), "Returns name string for char or nil if none", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(6), lang.NewKeyword("line"), int(335), lang.NewKeyword("end-line"), int(338))).(*lang.Symbol) + tmp0 := sym_char_DASH_name_DASH_string.WithMeta(lang.NewMap(kw_tag, tmp1, kw_doc, "Returns name string for char or nil if none", kw_file, "glojure/core_print.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(6), kw_line, int(335), kw_end_DASH_line, int(338))).(*lang.Symbol) tmp2 := ns.InternWithValue(tmp0, lang.NewMap(lang.NewChar(10), "newline", lang.NewChar(9), "tab", lang.NewChar(32), "space", lang.NewChar(8), "backspace", lang.NewChar(12), "formfeed", lang.NewChar(13), "return"), true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -12210,22 +13153,20 @@ func LoadNS() { } // char? { - tmp0 := lang.NewSymbol("char?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a Character", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(153), lang.NewKeyword("end-line"), int(157))).(*lang.Symbol) + tmp0 := sym_char_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a Character", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(6), kw_column, int(2), kw_line, int(153), kw_end_DASH_line, int(157))).(*lang.Symbol) var tmp2 lang.FnFunc { // function char? var v3 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp6 := reflect.TypeOf(int32(0)) tmp7 := lang.Apply(tmp5, []any{tmp6, v4}) return tmp7 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(157), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(157), lang.NewKeyword("end-column"), int(89))).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(157), kw_column, int(8), kw_end_DASH_line, int(157), kw_end_DASH_column, int(89))).(lang.FnFunc) v3 = tmp2 _ = v3 } @@ -12240,20 +13181,18 @@ func LoadNS() { { // function chars var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) - tmp5 := checkDerefVar(glojure_DOT_core_concat) - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol("glojure.core/Chars")}) - tmp12 := checkDerefVar(glojure_DOT_core_list) + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Chars}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := lang.Apply(tmp12, []any{v3}) tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) tmp15 := lang.Apply(tmp4, []any{tmp14}) @@ -12262,12 +13201,10 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("chars").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Casts to chars[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5382), lang.NewKeyword("end-line"), int(5382))).(*lang.Symbol) + tmp0 := sym_chars.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xs)), kw_inline, tmp1, kw_doc, "Casts to chars[]", kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(12), kw_line, int(5382), kw_end_DASH_line, int(5382))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Chars") @@ -12277,7 +13214,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v4}) return tmp6 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -12285,43 +13222,39 @@ func LoadNS() { } // check-cyclic-dependency { - tmp0 := lang.NewSymbol("check-cyclic-dependency").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("path"))), lang.NewKeyword("doc"), "Detects and rejects non-trivial cyclic load dependencies. The\n exception message shows the dependency chain with the cycle\n highlighted. Ignores the trivial case of a file attempting to load\n itself because that can occur when a gen-class'd class loads its\n implementation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(30), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5974), lang.NewKeyword("end-line"), int(5974), lang.NewKeyword("private"), true)).(*lang.Symbol) + tmp0 := sym_check_DASH_cyclic_DASH_dependency.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_path)), kw_doc, "Detects and rejects non-trivial cyclic load dependencies. The\n exception message shows the dependency chain with the cycle\n highlighted. Ignores the trivial case of a file attempting to load\n itself because that can occur when a gen-class'd class loads its\n implementation.", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(30), kw_column, int(8), kw_line, int(5974), kw_end_DASH_line, int(5974), kw_private, true)).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any - tmp5 := checkDerefVar(glojure_DOT_core_some) + tmp5 := checkDerefVar(var_glojure_DOT_core_some) tmp6 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{v3})) - tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5981), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(5981), lang.NewKeyword("end-column"), int(21)) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5981), kw_column, int(15), kw_end_DASH_line, int(5981), kw_end_DASH_column, int(21)) tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp9 := checkDerefVar(glojure_DOT_core_rest) - tmp10 := checkDerefVar(glojure_DOT_core__STAR_pending_paths_STAR_) + tmp9 := checkDerefVar(var_glojure_DOT_core_rest) + tmp10 := checkDerefVar(var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_) tmp11 := lang.Apply(tmp9, []any{tmp10}) tmp12 := lang.Apply(tmp5, []any{tmp8, tmp11}) if lang.IsTruthy(tmp12) { var tmp13 any { // let // let binding "pending" - tmp14 := checkDerefVar(glojure_DOT_core_map) + tmp14 := checkDerefVar(var_glojure_DOT_core_map) var tmp15 lang.FnFunc tmp15 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v16 := args[0] _ = v16 var tmp17 any - tmp18 := checkDerefVar(glojure_DOT_core__EQ_) + tmp18 := checkDerefVar(var_glojure_DOT_core__EQ_) tmp19 := lang.Apply(tmp18, []any{v16, v3}) if lang.IsTruthy(tmp19) { - tmp20 := checkDerefVar(glojure_DOT_core_str) + tmp20 := checkDerefVar(var_glojure_DOT_core_str) tmp21 := lang.Apply(tmp20, []any{"[ ", v16, " ]"}) tmp17 = tmp21 } else { @@ -12329,26 +13262,26 @@ func LoadNS() { } return tmp17 }) - tmp16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5982), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(5982), lang.NewKeyword("end-column"), int(59)) + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5982), kw_column, int(24), kw_end_DASH_line, int(5982), kw_end_DASH_column, int(59)) tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp18 := checkDerefVar(glojure_DOT_core_cons) - tmp19 := checkDerefVar(glojure_DOT_core__STAR_pending_paths_STAR_) + tmp18 := checkDerefVar(var_glojure_DOT_core_cons) + tmp19 := checkDerefVar(var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_) tmp20 := lang.Apply(tmp18, []any{v3, tmp19}) tmp21 := lang.Apply(tmp14, []any{tmp17, tmp20}) var v22 any = tmp21 _ = v22 // let binding "chain" - tmp23 := checkDerefVar(glojure_DOT_core_apply) - tmp24 := checkDerefVar(glojure_DOT_core_str) - tmp25 := checkDerefVar(glojure_DOT_core_interpose) + tmp23 := checkDerefVar(var_glojure_DOT_core_apply) + tmp24 := checkDerefVar(var_glojure_DOT_core_str) + tmp25 := checkDerefVar(var_glojure_DOT_core_interpose) tmp26 := lang.Apply(tmp25, []any{"->", v22}) tmp27 := lang.Apply(tmp23, []any{tmp24, tmp26}) var v28 any = tmp27 _ = v28 - tmp29 := checkDerefVar(glojure_DOT_core_throw_if) + tmp29 := checkDerefVar(var_glojure_DOT_core_throw_DASH_if) tmp30 := lang.Apply(tmp29, []any{true, "Cyclic load dependency: %s", v28}) tmp13 = tmp30 } // end let @@ -12357,7 +13290,7 @@ func LoadNS() { } return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -12365,52 +13298,48 @@ func LoadNS() { } // check-valid-options { - tmp0 := lang.NewSymbol("check-valid-options").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("options"), lang.NewSymbol("&"), lang.NewSymbol("valid-keys"))), lang.NewKeyword("doc"), "Throws an exception if the given option map contains keys not listed\n as valid, else returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(35), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1709), lang.NewKeyword("end-line"), int(1709), lang.NewKeyword("private"), true)).(*lang.Symbol) + tmp0 := sym_check_DASH_valid_DASH_options.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_options, sym__AMP_, sym_valid_DASH_keys)), kw_doc, "Throws an exception if the given option map contains keys not listed\n as valid, else returns nil.", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(35), kw_column, int(7), kw_line, int(1709), kw_end_DASH_line, int(1709), kw_private, true)).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var v4 any = lang.NewList(args[1:]...) _ = v4 var tmp5 any - tmp6 := checkDerefVar(glojure_DOT_core_seq) - tmp7 := checkDerefVar(glojure_DOT_core_apply) - tmp8 := checkDerefVar(glojure_DOT_core_disj) - tmp9 := checkDerefVar(glojure_DOT_core_apply) - tmp10 := checkDerefVar(glojure_DOT_core_hash_set) - tmp11 := checkDerefVar(glojure_DOT_core_keys) + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_apply) + tmp8 := checkDerefVar(var_glojure_DOT_core_disj) + tmp9 := checkDerefVar(var_glojure_DOT_core_apply) + tmp10 := checkDerefVar(var_glojure_DOT_core_hash_DASH_set) + tmp11 := checkDerefVar(var_glojure_DOT_core_keys) tmp12 := lang.Apply(tmp11, []any{v3}) tmp13 := lang.Apply(tmp9, []any{tmp10, tmp12}) tmp14 := lang.Apply(tmp7, []any{tmp8, tmp13, v4}) tmp15 := lang.Apply(tmp6, []any{tmp14}) if lang.IsTruthy(tmp15) { - tmp16 := checkDerefVar(glojure_DOT_core_apply) - tmp17 := checkDerefVar(glojure_DOT_core_str) - tmp18 := checkDerefVar(glojure_DOT_core_first) + tmp16 := checkDerefVar(var_glojure_DOT_core_apply) + tmp17 := checkDerefVar(var_glojure_DOT_core_str) + tmp18 := checkDerefVar(var_glojure_DOT_core_first) tmp19 := lang.Apply(tmp18, []any{v4}) - tmp20 := checkDerefVar(glojure_DOT_core_map) + tmp20 := checkDerefVar(var_glojure_DOT_core_map) var tmp21 lang.FnFunc tmp21 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v22 := args[0] _ = v22 - tmp23 := checkDerefVar(glojure_DOT_core_str) + tmp23 := checkDerefVar(var_glojure_DOT_core_str) tmp24 := lang.Apply(tmp23, []any{", ", v22}) return tmp24 }) - tmp22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1718), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(1718), lang.NewKeyword("end-column"), int(28)) + tmp22 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(1718), kw_column, int(16), kw_end_DASH_line, int(1718), kw_end_DASH_column, int(28)) tmp23, err := lang.WithMeta(tmp21, tmp22.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp24 := checkDerefVar(glojure_DOT_core_rest) + tmp24 := checkDerefVar(var_glojure_DOT_core_rest) tmp25 := lang.Apply(tmp24, []any{v4}) tmp26 := lang.Apply(tmp20, []any{tmp23, tmp25}) tmp27 := lang.Apply(tmp16, []any{tmp17, "Only these options are valid: ", tmp19, tmp26}) @@ -12421,7 +13350,7 @@ func LoadNS() { return tmp5 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -12429,12 +13358,10 @@ func LoadNS() { } // chunk { - tmp0 := lang.NewSymbol("chunk").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(691), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(691), lang.NewKeyword("end-column"), int(41), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("b"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym_chunk.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(691), kw_column, int(7), kw_end_DASH_line, int(691), kw_end_DASH_column, int(41), kw_arglists, lang.NewList(lang.NewVector(sym_b)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4, ok := lang.FieldOrMethod(v3, "chunk") @@ -12450,7 +13377,7 @@ func LoadNS() { } return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -12458,12 +13385,10 @@ func LoadNS() { } // chunk-append { - tmp0 := lang.NewSymbol("chunk-append").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(688), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(688), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("b"), lang.NewSymbol("x"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym_chunk_DASH_append.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(688), kw_column, int(7), kw_end_DASH_line, int(688), kw_end_DASH_column, int(27), kw_arglists, lang.NewList(lang.NewVector(sym_b, sym_x)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -12475,7 +13400,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v4}) return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -12483,18 +13408,16 @@ func LoadNS() { } // chunk-buffer { - tmp0 := lang.NewSymbol("chunk-buffer").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(685), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(685), lang.NewKeyword("end-column"), int(53), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("capacity"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym_chunk_DASH_buffer.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(685), kw_column, int(7), kw_end_DASH_line, int(685), kw_end_DASH_column, int(53), kw_arglists, lang.NewList(lang.NewVector(sym_capacity)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4 := lang.Apply(lang.NewChunkBuffer, []any{v3}) return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -12502,12 +13425,10 @@ func LoadNS() { } // chunk-cons { - tmp0 := lang.NewSymbol("chunk-cons").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(703), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(703), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("chunk"), lang.NewSymbol("rest"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym_chunk_DASH_cons.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(703), kw_column, int(7), kw_end_DASH_line, int(703), kw_end_DASH_column, int(25), kw_arglists, lang.NewList(lang.NewVector(sym_chunk, sym_rest)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -12523,7 +13444,7 @@ func LoadNS() { } return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -12531,12 +13452,10 @@ func LoadNS() { } // chunk-first { - tmp0 := lang.NewSymbol("chunk-first").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(694), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(694), lang.NewKeyword("end-column"), int(48), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym_chunk_DASH_first.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(694), kw_column, int(7), kw_end_DASH_line, int(694), kw_end_DASH_column, int(48), kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4, ok := lang.FieldOrMethod(v3, "chunkedFirst") @@ -12552,7 +13471,7 @@ func LoadNS() { } return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -12560,12 +13479,10 @@ func LoadNS() { } // chunk-next { - tmp0 := lang.NewSymbol("chunk-next").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(700), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(700), lang.NewKeyword("end-column"), int(71), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym_chunk_DASH_next.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(700), kw_column, int(7), kw_end_DASH_line, int(700), kw_end_DASH_column, int(71), kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4, ok := lang.FieldOrMethod(v3, "chunkedNext") @@ -12581,7 +13498,7 @@ func LoadNS() { } return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -12589,12 +13506,10 @@ func LoadNS() { } // chunk-rest { - tmp0 := lang.NewSymbol("chunk-rest").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(697), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(697), lang.NewKeyword("end-column"), int(71), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym_chunk_DASH_rest.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(697), kw_column, int(7), kw_end_DASH_line, int(697), kw_end_DASH_column, int(71), kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4, ok := lang.FieldOrMethod(v3, "chunkedMore") @@ -12610,7 +13525,7 @@ func LoadNS() { } return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -12618,20 +13533,18 @@ func LoadNS() { } // chunked-seq? { - tmp0 := lang.NewSymbol("chunked-seq?").WithMeta(lang.NewMap(lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(708), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(708), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym_chunked_DASH_seq_QMARK_.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(708), kw_column, int(7), kw_end_DASH_line, int(708), kw_end_DASH_column, int(27), kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp5 := reflect.TypeOf((*lang.IChunkedSeq)(nil)).Elem() tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -12639,16 +13552,14 @@ func LoadNS() { } // class { - tmp0 := lang.NewSymbol("class").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns the Class of x", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3461), lang.NewKeyword("end-line"), int(3461))).(*lang.Symbol) + tmp0 := sym_class.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns the Class of x", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3461), kw_end_DASH_line, int(3461))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any - tmp5 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) tmp6 := lang.Apply(tmp5, []any{v3}) if lang.IsTruthy(tmp6) { tmp4 = v3 @@ -12658,7 +13569,7 @@ func LoadNS() { } return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -12666,20 +13577,18 @@ func LoadNS() { } // class? { - tmp0 := lang.NewSymbol("class?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is an instance of Class", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5465), lang.NewKeyword("end-line"), int(5465))).(*lang.Symbol) + tmp0 := sym_class_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x is an instance of Class", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(5465), kw_end_DASH_line, int(5465))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp5 := reflect.TypeOf((*reflect.Type)(nil)).Elem() tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -12687,15 +13596,13 @@ func LoadNS() { } // clear-agent-errors { - tmp0 := lang.NewSymbol("clear-agent-errors").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("doc"), "DEPRECATED: Use 'restart-agent' instead.\n Clears any exceptions thrown during asynchronous actions of the\n agent, allowing subsequent actions to occur.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("deprecated"), "1.2", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2244), lang.NewKeyword("end-line"), int(2244))).(*lang.Symbol) + tmp0 := sym_clear_DASH_agent_DASH_errors.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a)), kw_doc, "DEPRECATED: Use 'restart-agent' instead.\n Clears any exceptions thrown during asynchronous actions of the\n agent, allowing subsequent actions to occur.", kw_file, "glojure/core.glj", kw_deprecated, "1.2", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(24), kw_column, int(7), kw_line, int(2244), kw_end_DASH_line, int(2244))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_restart_agent) + tmp4 := checkDerefVar(var_glojure_DOT_core_restart_DASH_agent) tmp5, ok := lang.FieldOrMethod(v3, "Deref") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "Deref"))) @@ -12710,7 +13617,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp4, []any{v3, tmp6}) return tmp7 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -12718,20 +13625,18 @@ func LoadNS() { } // coll? { - tmp0 := lang.NewSymbol("coll?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements IPersistentCollection", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6192), lang.NewKeyword("end-line"), int(6192))).(*lang.Symbol) + tmp0 := sym_coll_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x implements IPersistentCollection", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(6192), kw_end_DASH_line, int(6192))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp5 := reflect.TypeOf((*lang.IPersistentCollection)(nil)).Elem() tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -12739,14 +13644,12 @@ func LoadNS() { } // comment { - tmp0 := lang.NewSymbol("comment").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Ignores body, yields nil", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4733), lang.NewKeyword("end-line"), int(4733))).(*lang.Symbol) + tmp0 := sym_comment.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_body)), kw_doc, "Ignores body, yields nil", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(4733), kw_end_DASH_line, int(4733))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -12756,7 +13659,7 @@ func LoadNS() { return nil } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -12764,14 +13667,12 @@ func LoadNS() { } // commute { - tmp0 := lang.NewSymbol("commute").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("fun"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Must be called in a transaction. Sets the in-transaction-value of\n ref to:\n\n (apply fun in-transaction-value-of-ref args)\n\n and returns the in-transaction-value of ref.\n\n At the commit point of the transaction, sets the value of ref to be:\n\n (apply fun most-recently-committed-value-of-ref args)\n\n Thus fun should be commutative, or, failing that, you must accept\n last-one-in-wins behavior. commute allows for more concurrency than\n ref-set.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2414), lang.NewKeyword("end-line"), int(2414))).(*lang.Symbol) + tmp0 := sym_commute.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ref, sym_fun, sym__AMP_, sym_args)), kw_doc, "Must be called in a transaction. Sets the in-transaction-value of\n ref to:\n\n (apply fun in-transaction-value-of-ref args)\n\n and returns the in-transaction-value of ref.\n\n At the commit point of the transaction, sets the value of ref to be:\n\n (apply fun most-recently-committed-value-of-ref args)\n\n Thus fun should be commutative, or, failing that, you must accept\n last-one-in-wins behavior. commute allows for more concurrency than\n ref-set.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(2414), kw_end_DASH_line, int(2414))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -12786,7 +13687,7 @@ func LoadNS() { return tmp7 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -12794,12 +13695,12 @@ func LoadNS() { } // comp { - tmp0 := lang.NewSymbol("comp").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("g")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("g"), lang.NewSymbol("&"), lang.NewSymbol("fs"))), lang.NewKeyword("doc"), "Takes a set of functions and returns a fn that is the composition\n of those fns. The returned fn takes a variable number of args,\n applies the rightmost of fns to the args, the next\n fn (right-to-left) to the result, etc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2549), lang.NewKeyword("end-line"), int(2549))).(*lang.Symbol) + tmp0 := sym_comp.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_f), lang.NewVector(sym_f, sym_g), lang.NewVector(sym_f, sym_g, sym__AMP_, sym_fs)), kw_doc, "Takes a set of functions and returns a fn that is the composition\n of those fns. The returned fn takes a variable number of args,\n applies the rightmost of fns to the args, the next\n fn (right-to-left) to the result, etc.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(2549), kw_end_DASH_line, int(2549))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - tmp3 := checkDerefVar(glojure_DOT_core_identity) + tmp3 := checkDerefVar(var_glojure_DOT_core_identity) return tmp3 case 1: v3 := args[0] @@ -12842,9 +13743,7 @@ func LoadNS() { tmp10 := lang.Apply(v3, []any{tmp9}) return tmp10 default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v6 := args[0] _ = v6 v7 := args[1] @@ -12853,37 +13752,35 @@ func LoadNS() { _ = v8 var v9 any = lang.NewList(args[3:]...) _ = v9 - tmp10 := checkDerefVar(glojure_DOT_core_apply) + tmp10 := checkDerefVar(var_glojure_DOT_core_apply) tmp11 := lang.Apply(tmp10, []any{v4, v6, v7, v8, v9}) tmp12 := lang.Apply(v3, []any{tmp11}) return tmp12 } }) - tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2559), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2564), lang.NewKeyword("end-column"), int(49)) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2559), kw_column, int(6), kw_end_DASH_line, int(2564), kw_end_DASH_column, int(49)) tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) if err != nil { panic(err) } return tmp7 default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 var v5 any = lang.NewList(args[2:]...) _ = v5 - tmp6 := checkDerefVar(glojure_DOT_core_reduce1) - tmp7 := checkDerefVar(glojure_DOT_core_comp) - tmp8 := checkDerefVar(glojure_DOT_core_list_STAR_) + tmp6 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp7 := checkDerefVar(var_glojure_DOT_core_comp) + tmp8 := checkDerefVar(var_glojure_DOT_core_list_STAR_) tmp9 := lang.Apply(tmp8, []any{v3, v4, v5}) tmp10 := lang.Apply(tmp6, []any{tmp7, tmp9}) return tmp10 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -12891,19 +13788,15 @@ func LoadNS() { } // comparator { - tmp0 := lang.NewSymbol("comparator").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"))), lang.NewKeyword("doc"), "Returns an implementation of java.util.Comparator based upon pred.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3077), lang.NewKeyword("end-line"), int(3077))).(*lang.Symbol) + tmp0 := sym_comparator.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred)), kw_doc, "Returns an implementation of java.util.Comparator based upon pred.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(3077), kw_end_DASH_line, int(3077))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 lang.FnFunc tmp4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v5 := args[0] _ = v5 v6 := args[1] @@ -12919,7 +13812,7 @@ func LoadNS() { tmp9 = int64(1) } else { var tmp11 any - if lang.IsTruthy(lang.NewKeyword("else")) { + if lang.IsTruthy(kw_else) { tmp11 = int64(0) } else { } @@ -12929,14 +13822,14 @@ func LoadNS() { } return tmp7 }) - tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3082), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(3083), lang.NewKeyword("end-column"), int(48)) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3082), kw_column, int(5), kw_end_DASH_line, int(3083), kw_end_DASH_column, int(48)) tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) if err != nil { panic(err) } return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -12948,24 +13841,22 @@ func LoadNS() { { // function compare__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_seq) - tmp6 := checkDerefVar(glojure_DOT_core_concat) - tmp7 := checkDerefVar(glojure_DOT_core_list) - tmp8 := lang.Apply(tmp7, []any{lang.NewSymbol(".")}) - tmp9 := checkDerefVar(glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("glojure.lang.Util")}) - tmp11 := checkDerefVar(glojure_DOT_core_list) - tmp12 := lang.Apply(tmp11, []any{lang.NewSymbol("glojure.core/compare")}) - tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_lang_DOT_Util}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_glojure_DOT_core_SLASH_compare}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) tmp14 := lang.Apply(tmp13, []any{v3}) - tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v4}) tmp17 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp12, tmp14, tmp16}) tmp18 := lang.Apply(tmp5, []any{tmp17}) @@ -12974,12 +13865,10 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("compare").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Comparator. Returns a negative number, zero, or a positive number\n when x is logically 'less than', 'equal to', or 'greater than'\n y. Same as Java x.compareTo(y) except it also works for nil, and\n compares numbers and collections in a type-independent manner. x\n must implement Comparable", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(824), lang.NewKeyword("end-line"), int(824))).(*lang.Symbol) + tmp0 := sym_compare.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Comparator. Returns a negative number, zero, or a positive number\n when x is logically 'less than', 'equal to', or 'greater than'\n y. Same as Java x.compareTo(y) except it also works for nil, and\n compares numbers and collections in a type-independent manner. x\n must implement Comparable", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(824), kw_end_DASH_line, int(824))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -12987,7 +13876,7 @@ func LoadNS() { tmp6 := lang.Apply(lang.Compare, []any{v4, v5}) return tmp6 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -12995,12 +13884,10 @@ func LoadNS() { } // compare-and-set! { - tmp0 := lang.NewSymbol("compare-and-set!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atom"), lang.NewSymbol("oldval"), lang.NewSymbol("newval"))), lang.NewKeyword("doc"), "Atomically sets the value of atom to newval if and only if the\n current value of the atom is identical to oldval. Returns true if\n set happened, else false", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2360), lang.NewKeyword("end-line"), int(2360))).(*lang.Symbol) + tmp0 := sym_compare_DASH_and_DASH_set_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_atom, sym_oldval, sym_newval)), kw_doc, "Atomically sets the value of atom to newval if and only if the\n current value of the atom is identical to oldval. Returns true if\n set happened, else false", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(22), kw_column, int(7), kw_line, int(2360), kw_end_DASH_line, int(2360))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -13014,7 +13901,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -13022,30 +13909,28 @@ func LoadNS() { } // compile { - tmp0 := lang.NewSymbol("compile").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"))), lang.NewKeyword("doc"), "Compiles the namespace named by the symbol lib into a set of\n classfiles. The source for the lib must be in a proper\n classpath-relative directory. The output files will go into the\n directory specified by *compile-path*, and that directory too must\n be in the classpath.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6114), lang.NewKeyword("end-line"), int(6114))).(*lang.Symbol) + tmp0 := sym_compile.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_lib)), kw_doc, "Compiles the namespace named by the symbol lib into a set of\n classfiles. The source for the lib must be in a proper\n classpath-relative directory. The output files will go into the\n directory specified by *compile-path*, and that directory too must\n be in the classpath.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(6114), kw_end_DASH_line, int(6114))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any { // let - tmp5 := checkDerefVar(glojure_DOT_core_push_thread_bindings) - tmp6 := checkDerefVar(glojure_DOT_core_hash_map) - tmp7 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*compile-files*")) + tmp5 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp6 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp7 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_compile_DASH_files_STAR_) tmp8 := lang.Apply(tmp6, []any{tmp7, true}) tmp9 := lang.Apply(tmp5, []any{tmp8}) _ = tmp9 var tmp10 any func() { defer func() { - tmp11 := checkDerefVar(glojure_DOT_core_pop_thread_bindings) + tmp11 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) tmp12 := lang.Apply(tmp11, nil) _ = tmp12 }() - tmp13 := checkDerefVar(glojure_DOT_core_load_one) + tmp13 := checkDerefVar(var_glojure_DOT_core_load_DASH_one) tmp14 := lang.Apply(tmp13, []any{v3, true, true}) tmp10 = tmp14 }() @@ -13054,7 +13939,7 @@ func LoadNS() { _ = tmp4 return v3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -13062,26 +13947,24 @@ func LoadNS() { } // complement { - tmp0 := lang.NewSymbol("complement").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Takes a fn f and returns a fn that takes the same arguments as f,\n has the same effects, if any, and returns the opposite truth value.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1428), lang.NewKeyword("end-line"), int(1428))).(*lang.Symbol) + tmp0 := sym_complement.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f)), kw_doc, "Takes a fn f and returns a fn that takes the same arguments as f,\n has the same effects, if any, and returns the opposite truth value.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(1428), kw_end_DASH_line, int(1428))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 lang.FnFunc tmp4 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - tmp5 := checkDerefVar(glojure_DOT_core_not) + tmp5 := checkDerefVar(var_glojure_DOT_core_not) tmp6 := lang.Apply(v3, nil) tmp7 := lang.Apply(tmp5, []any{tmp6}) return tmp7 case 1: v5 := args[0] _ = v5 - tmp6 := checkDerefVar(glojure_DOT_core_not) + tmp6 := checkDerefVar(var_glojure_DOT_core_not) tmp7 := lang.Apply(v3, []any{v5}) tmp8 := lang.Apply(tmp6, []any{tmp7}) return tmp8 @@ -13090,35 +13973,33 @@ func LoadNS() { _ = v5 v6 := args[1] _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_not) + tmp7 := checkDerefVar(var_glojure_DOT_core_not) tmp8 := lang.Apply(v3, []any{v5, v6}) tmp9 := lang.Apply(tmp7, []any{tmp8}) return tmp9 default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v5 := args[0] _ = v5 v6 := args[1] _ = v6 var v7 any = lang.NewList(args[2:]...) _ = v7 - tmp8 := checkDerefVar(glojure_DOT_core_not) - tmp9 := checkDerefVar(glojure_DOT_core_apply) + tmp8 := checkDerefVar(var_glojure_DOT_core_not) + tmp9 := checkDerefVar(var_glojure_DOT_core_apply) tmp10 := lang.Apply(tmp9, []any{v3, v5, v6, v7}) tmp11 := lang.Apply(tmp8, []any{tmp10}) return tmp11 } }) - tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1434), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(1438), lang.NewKeyword("end-column"), int(40)) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(1434), kw_column, int(3), kw_end_DASH_line, int(1438), kw_end_DASH_column, int(40)) tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) if err != nil { panic(err) } return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -13126,15 +14007,15 @@ func LoadNS() { } // completing { - tmp0 := lang.NewSymbol("completing").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("cf"))), lang.NewKeyword("doc"), "Takes a reducing function f of 2 args and returns a fn suitable for\n transduce by adding an arity-1 signature that calls cf (default -\n identity) on the result argument.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6893), lang.NewKeyword("end-line"), int(6893))).(*lang.Symbol) + tmp0 := sym_completing.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_cf)), kw_doc, "Takes a reducing function f of 2 args and returns a fn suitable for\n transduce by adding an arity-1 signature that calls cf (default -\n identity) on the result argument.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(6893), kw_end_DASH_line, int(6893))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_completing) - tmp5 := checkDerefVar(glojure_DOT_core_identity) + tmp4 := checkDerefVar(var_glojure_DOT_core_completing) + tmp5 := checkDerefVar(var_glojure_DOT_core_identity) tmp6 := lang.Apply(tmp4, []any{v3, tmp5}) return tmp6 case 2: @@ -13161,20 +14042,22 @@ func LoadNS() { tmp8 := lang.Apply(v3, []any{v6, v7}) return tmp8 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6900), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(6903), lang.NewKeyword("end-column"), int(23)) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6900), kw_column, int(6), kw_end_DASH_line, int(6903), kw_end_DASH_column, int(23)) tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) if err != nil { panic(err) } return tmp7 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -13182,16 +14065,14 @@ func LoadNS() { } // concat { - tmp0 := lang.NewSymbol("concat").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("zs"))), lang.NewKeyword("doc"), "Returns a lazy seq representing the concatenation of the elements in the supplied colls.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(711), lang.NewKeyword("end-line"), int(711))).(*lang.Symbol) + tmp0 := sym_concat.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_zs)), kw_doc, "Returns a lazy seq representing the concatenation of the elements in the supplied colls.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(711), kw_end_DASH_line, int(711))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) return nil }) tmp4 := lang.Apply(lang.NewLazySeq, []any{tmp3}) @@ -13201,9 +14082,7 @@ func LoadNS() { _ = v3 var tmp4 lang.FnFunc tmp4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) return v3 }) tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) @@ -13215,37 +14094,35 @@ func LoadNS() { _ = v4 var tmp5 lang.FnFunc tmp5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var tmp6 any { // let // let binding "s" - tmp7 := checkDerefVar(glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) tmp8 := lang.Apply(tmp7, []any{v3}) var v9 any = tmp8 _ = v9 var tmp10 any if lang.IsTruthy(v9) { var tmp11 any - tmp12 := checkDerefVar(glojure_DOT_core_chunked_seq_QMARK_) + tmp12 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) tmp13 := lang.Apply(tmp12, []any{v9}) if lang.IsTruthy(tmp13) { - tmp14 := checkDerefVar(glojure_DOT_core_chunk_cons) - tmp15 := checkDerefVar(glojure_DOT_core_chunk_first) + tmp14 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_cons) + tmp15 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) tmp16 := lang.Apply(tmp15, []any{v9}) - tmp17 := checkDerefVar(glojure_DOT_core_concat) - tmp18 := checkDerefVar(glojure_DOT_core_chunk_rest) + tmp17 := checkDerefVar(var_glojure_DOT_core_concat) + tmp18 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) tmp19 := lang.Apply(tmp18, []any{v9}) tmp20 := lang.Apply(tmp17, []any{tmp19, v4}) tmp21 := lang.Apply(tmp14, []any{tmp16, tmp20}) tmp11 = tmp21 } else { - tmp22 := checkDerefVar(glojure_DOT_core_cons) - tmp23 := checkDerefVar(glojure_DOT_core_first) + tmp22 := checkDerefVar(var_glojure_DOT_core_cons) + tmp23 := checkDerefVar(var_glojure_DOT_core_first) tmp24 := lang.Apply(tmp23, []any{v9}) - tmp25 := checkDerefVar(glojure_DOT_core_concat) - tmp26 := checkDerefVar(glojure_DOT_core_rest) + tmp25 := checkDerefVar(var_glojure_DOT_core_concat) + tmp26 := checkDerefVar(var_glojure_DOT_core_rest) tmp27 := lang.Apply(tmp26, []any{v9}) tmp28 := lang.Apply(tmp25, []any{tmp27, v4}) tmp29 := lang.Apply(tmp22, []any{tmp24, tmp28}) @@ -13262,9 +14139,7 @@ func LoadNS() { tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) return tmp6 default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -13278,44 +14153,40 @@ func LoadNS() { { // function cat var v8 lang.FnFunc tmp7 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v9 := args[0] _ = v9 v10 := args[1] _ = v10 var tmp11 lang.FnFunc tmp11 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var tmp12 any { // let // let binding "xys" - tmp13 := checkDerefVar(glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) tmp14 := lang.Apply(tmp13, []any{v9}) var v15 any = tmp14 _ = v15 var tmp16 any if lang.IsTruthy(v15) { var tmp17 any - tmp18 := checkDerefVar(glojure_DOT_core_chunked_seq_QMARK_) + tmp18 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) tmp19 := lang.Apply(tmp18, []any{v15}) if lang.IsTruthy(tmp19) { - tmp20 := checkDerefVar(glojure_DOT_core_chunk_cons) - tmp21 := checkDerefVar(glojure_DOT_core_chunk_first) + tmp20 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_cons) + tmp21 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) tmp22 := lang.Apply(tmp21, []any{v15}) - tmp23 := checkDerefVar(glojure_DOT_core_chunk_rest) + tmp23 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) tmp24 := lang.Apply(tmp23, []any{v15}) tmp25 := lang.Apply(v8, []any{tmp24, v10}) tmp26 := lang.Apply(tmp20, []any{tmp22, tmp25}) tmp17 = tmp26 } else { - tmp27 := checkDerefVar(glojure_DOT_core_cons) - tmp28 := checkDerefVar(glojure_DOT_core_first) + tmp27 := checkDerefVar(var_glojure_DOT_core_cons) + tmp28 := checkDerefVar(var_glojure_DOT_core_first) tmp29 := lang.Apply(tmp28, []any{v15}) - tmp30 := checkDerefVar(glojure_DOT_core_rest) + tmp30 := checkDerefVar(var_glojure_DOT_core_rest) tmp31 := lang.Apply(tmp30, []any{v15}) tmp32 := lang.Apply(v8, []any{tmp31, v10}) tmp33 := lang.Apply(tmp27, []any{tmp29, tmp32}) @@ -13325,9 +14196,9 @@ func LoadNS() { } else { var tmp34 any if lang.IsTruthy(v10) { - tmp35 := checkDerefVar(glojure_DOT_core_first) + tmp35 := checkDerefVar(var_glojure_DOT_core_first) tmp36 := lang.Apply(tmp35, []any{v10}) - tmp37 := checkDerefVar(glojure_DOT_core_next) + tmp37 := checkDerefVar(var_glojure_DOT_core_next) tmp38 := lang.Apply(tmp37, []any{v10}) tmp39 := lang.Apply(v8, []any{tmp36, tmp38}) tmp34 = tmp39 @@ -13345,14 +14216,14 @@ func LoadNS() { v8 = tmp7 _ = v8 } - tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(726), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(735), lang.NewKeyword("end-column"), int(56)) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(726), kw_column, int(16), kw_end_DASH_line, int(735), kw_end_DASH_column, int(56)) tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) if err != nil { panic(err) } var v10 any = tmp9 _ = v10 - tmp11 := checkDerefVar(glojure_DOT_core_concat) + tmp11 := checkDerefVar(var_glojure_DOT_core_concat) tmp12 := lang.Apply(tmp11, []any{v3, v4}) tmp13 := lang.Apply(v10, []any{tmp12, v5}) tmp6 = tmp13 @@ -13360,7 +14231,7 @@ func LoadNS() { return tmp6 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -13368,14 +14239,12 @@ func LoadNS() { } // cond { - tmp0 := lang.NewSymbol("cond").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes a set of test/expr pairs. It evaluates each test one at a\n time. If a test returns logical true, cond evaluates and returns\n the value of the corresponding expr and doesn't evaluate any of the\n other tests or exprs. (cond) returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(569), lang.NewKeyword("end-line"), int(569))).(*lang.Symbol) + tmp0 := sym_cond.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_clauses)), kw_doc, "Takes a set of test/expr pairs. It evaluates each test one at a\n time. If a test returns logical true, cond evaluates and returns\n the value of the corresponding expr and doesn't evaluate any of the\n other tests or exprs. (cond) returns nil.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(11), kw_line, int(569), kw_end_DASH_line, int(569))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -13384,34 +14253,34 @@ func LoadNS() { _ = v5 var tmp6 any if lang.IsTruthy(v5) { - tmp7 := checkDerefVar(glojure_DOT_core_list) - tmp8 := checkDerefVar(glojure_DOT_core_first) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := checkDerefVar(var_glojure_DOT_core_first) tmp9 := lang.Apply(tmp8, []any{v5}) var tmp10 any - tmp11 := checkDerefVar(glojure_DOT_core_next) + tmp11 := checkDerefVar(var_glojure_DOT_core_next) tmp12 := lang.Apply(tmp11, []any{v5}) if lang.IsTruthy(tmp12) { - tmp13 := checkDerefVar(glojure_DOT_core_second) + tmp13 := checkDerefVar(var_glojure_DOT_core_second) tmp14 := lang.Apply(tmp13, []any{v5}) tmp10 = tmp14 } else { tmp15 := lang.Apply(lang.NewIllegalArgumentError, []any{"cond requires an even number of forms"}) panic(tmp15) } - tmp16 := checkDerefVar(glojure_DOT_core_cons) - tmp17 := checkDerefVar(glojure_DOT_core_next) - tmp18 := checkDerefVar(glojure_DOT_core_next) + tmp16 := checkDerefVar(var_glojure_DOT_core_cons) + tmp17 := checkDerefVar(var_glojure_DOT_core_next) + tmp18 := checkDerefVar(var_glojure_DOT_core_next) tmp19 := lang.Apply(tmp18, []any{v5}) tmp20 := lang.Apply(tmp17, []any{tmp19}) - tmp21 := lang.Apply(tmp16, []any{lang.NewSymbol("glojure.core/cond"), tmp20}) - tmp22 := lang.Apply(tmp7, []any{lang.NewSymbol("if"), tmp9, tmp10, tmp21}) + tmp21 := lang.Apply(tmp16, []any{sym_glojure_DOT_core_SLASH_cond, tmp20}) + tmp22 := lang.Apply(tmp7, []any{sym_if, tmp9, tmp10, tmp21}) tmp6 = tmp22 } else { } return tmp6 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -13419,14 +14288,12 @@ func LoadNS() { } // cond-> { - tmp0 := lang.NewSymbol("cond->").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes an expression and a set of test/form pairs. Threads expr (via ->)\n through each form for which the corresponding test\n expression is true. Note that, unlike cond branching, cond-> threading does\n not short circuit after the first true test expression.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7564), lang.NewKeyword("end-line"), int(7564))).(*lang.Symbol) + tmp0 := sym_cond_DASH__GT_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_expr, sym__AMP_, sym_clauses)), kw_doc, "Takes an expression and a set of test/form pairs. Threads expr (via ->)\n through each form for which the corresponding test\n expression is true. Note that, unlike cond branching, cond-> threading does\n not short circuit after the first true test expression.", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(11), kw_line, int(7564), kw_end_DASH_line, int(7564))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -13438,17 +14305,15 @@ func LoadNS() { var tmp7 any { // let // let binding "g" - tmp8 := checkDerefVar(glojure_DOT_core_gensym) + tmp8 := checkDerefVar(var_glojure_DOT_core_gensym) tmp9 := lang.Apply(tmp8, nil) var v10 any = tmp9 _ = v10 // let binding "steps" - tmp11 := checkDerefVar(glojure_DOT_core_map) + tmp11 := checkDerefVar(var_glojure_DOT_core_map) var tmp12 lang.FnFunc tmp12 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v13 := args[0] _ = v13 var tmp14 any @@ -13457,34 +14322,34 @@ func LoadNS() { var v15 any = v13 _ = v15 // let binding "test" - tmp16 := checkDerefVar(glojure_DOT_core_nth) + tmp16 := checkDerefVar(var_glojure_DOT_core_nth) tmp17 := lang.Apply(tmp16, []any{v15, int64(0), nil}) var v18 any = tmp17 _ = v18 // let binding "step" - tmp19 := checkDerefVar(glojure_DOT_core_nth) + tmp19 := checkDerefVar(var_glojure_DOT_core_nth) tmp20 := lang.Apply(tmp19, []any{v15, int64(1), nil}) var v21 any = tmp20 _ = v21 - tmp22 := checkDerefVar(glojure_DOT_core_seq) - tmp23 := checkDerefVar(glojure_DOT_core_concat) - tmp24 := checkDerefVar(glojure_DOT_core_list) - tmp25 := lang.Apply(tmp24, []any{lang.NewSymbol("if")}) - tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp22 := checkDerefVar(var_glojure_DOT_core_seq) + tmp23 := checkDerefVar(var_glojure_DOT_core_concat) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{sym_if}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) tmp27 := lang.Apply(tmp26, []any{v18}) - tmp28 := checkDerefVar(glojure_DOT_core_list) - tmp29 := checkDerefVar(glojure_DOT_core_seq) - tmp30 := checkDerefVar(glojure_DOT_core_concat) - tmp31 := checkDerefVar(glojure_DOT_core_list) - tmp32 := lang.Apply(tmp31, []any{lang.NewSymbol("glojure.core/->")}) - tmp33 := checkDerefVar(glojure_DOT_core_list) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := checkDerefVar(var_glojure_DOT_core_seq) + tmp30 := checkDerefVar(var_glojure_DOT_core_concat) + tmp31 := checkDerefVar(var_glojure_DOT_core_list) + tmp32 := lang.Apply(tmp31, []any{sym_glojure_DOT_core_SLASH__DASH__GT_}) + tmp33 := checkDerefVar(var_glojure_DOT_core_list) tmp34 := lang.Apply(tmp33, []any{v10}) - tmp35 := checkDerefVar(glojure_DOT_core_list) + tmp35 := checkDerefVar(var_glojure_DOT_core_list) tmp36 := lang.Apply(tmp35, []any{v21}) tmp37 := lang.Apply(tmp30, []any{tmp32, tmp34, tmp36}) tmp38 := lang.Apply(tmp29, []any{tmp37}) tmp39 := lang.Apply(tmp28, []any{tmp38}) - tmp40 := checkDerefVar(glojure_DOT_core_list) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) tmp41 := lang.Apply(tmp40, []any{v10}) tmp42 := lang.Apply(tmp23, []any{tmp25, tmp27, tmp39, tmp41}) tmp43 := lang.Apply(tmp22, []any{tmp42}) @@ -13492,47 +14357,47 @@ func LoadNS() { } // end let return tmp14 }) - tmp13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7573), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7573), lang.NewKeyword("end-column"), int(66)) + tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7573), kw_column, int(20), kw_end_DASH_line, int(7573), kw_end_DASH_column, int(66)) tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp15 := checkDerefVar(glojure_DOT_core_partition) + tmp15 := checkDerefVar(var_glojure_DOT_core_partition) tmp16 := lang.Apply(tmp15, []any{int64(2), v6}) tmp17 := lang.Apply(tmp11, []any{tmp14, tmp16}) var v18 any = tmp17 _ = v18 - tmp19 := checkDerefVar(glojure_DOT_core_seq) - tmp20 := checkDerefVar(glojure_DOT_core_concat) - tmp21 := checkDerefVar(glojure_DOT_core_list) - tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("glojure.core/let")}) - tmp23 := checkDerefVar(glojure_DOT_core_list) - tmp24 := checkDerefVar(glojure_DOT_core_apply) - tmp25 := checkDerefVar(glojure_DOT_core_vector) - tmp26 := checkDerefVar(glojure_DOT_core_seq) - tmp27 := checkDerefVar(glojure_DOT_core_concat) - tmp28 := checkDerefVar(glojure_DOT_core_list) + tmp19 := checkDerefVar(var_glojure_DOT_core_seq) + tmp20 := checkDerefVar(var_glojure_DOT_core_concat) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{sym_glojure_DOT_core_SLASH_let}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_apply) + tmp25 := checkDerefVar(var_glojure_DOT_core_vector) + tmp26 := checkDerefVar(var_glojure_DOT_core_seq) + tmp27 := checkDerefVar(var_glojure_DOT_core_concat) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) tmp29 := lang.Apply(tmp28, []any{v10}) - tmp30 := checkDerefVar(glojure_DOT_core_list) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) tmp31 := lang.Apply(tmp30, []any{v5}) - tmp32 := checkDerefVar(glojure_DOT_core_interleave) - tmp33 := checkDerefVar(glojure_DOT_core_repeat) + tmp32 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp33 := checkDerefVar(var_glojure_DOT_core_repeat) tmp34 := lang.Apply(tmp33, []any{v10}) - tmp35 := checkDerefVar(glojure_DOT_core_butlast) + tmp35 := checkDerefVar(var_glojure_DOT_core_butlast) tmp36 := lang.Apply(tmp35, []any{v18}) tmp37 := lang.Apply(tmp32, []any{tmp34, tmp36}) tmp38 := lang.Apply(tmp27, []any{tmp29, tmp31, tmp37}) tmp39 := lang.Apply(tmp26, []any{tmp38}) tmp40 := lang.Apply(tmp24, []any{tmp25, tmp39}) tmp41 := lang.Apply(tmp23, []any{tmp40}) - tmp42 := checkDerefVar(glojure_DOT_core_list) + tmp42 := checkDerefVar(var_glojure_DOT_core_list) var tmp43 any - tmp44 := checkDerefVar(glojure_DOT_core_empty_QMARK_) + tmp44 := checkDerefVar(var_glojure_DOT_core_empty_QMARK_) tmp45 := lang.Apply(tmp44, []any{v18}) if lang.IsTruthy(tmp45) { tmp43 = v10 } else { - tmp46 := checkDerefVar(glojure_DOT_core_last) + tmp46 := checkDerefVar(var_glojure_DOT_core_last) tmp47 := lang.Apply(tmp46, []any{v18}) tmp43 = tmp47 } @@ -13544,7 +14409,7 @@ func LoadNS() { return tmp7 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -13552,14 +14417,12 @@ func LoadNS() { } // cond->> { - tmp0 := lang.NewSymbol("cond->>").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes an expression and a set of test/form pairs. Threads expr (via ->>)\n through each form for which the corresponding test expression\n is true. Note that, unlike cond branching, cond->> threading does not short circuit\n after the first true test expression.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7581), lang.NewKeyword("end-line"), int(7581))).(*lang.Symbol) + tmp0 := sym_cond_DASH__GT__GT_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_expr, sym__AMP_, sym_clauses)), kw_doc, "Takes an expression and a set of test/form pairs. Threads expr (via ->>)\n through each form for which the corresponding test expression\n is true. Note that, unlike cond branching, cond->> threading does not short circuit\n after the first true test expression.", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(7581), kw_end_DASH_line, int(7581))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -13571,17 +14434,15 @@ func LoadNS() { var tmp7 any { // let // let binding "g" - tmp8 := checkDerefVar(glojure_DOT_core_gensym) + tmp8 := checkDerefVar(var_glojure_DOT_core_gensym) tmp9 := lang.Apply(tmp8, nil) var v10 any = tmp9 _ = v10 // let binding "steps" - tmp11 := checkDerefVar(glojure_DOT_core_map) + tmp11 := checkDerefVar(var_glojure_DOT_core_map) var tmp12 lang.FnFunc tmp12 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v13 := args[0] _ = v13 var tmp14 any @@ -13590,34 +14451,34 @@ func LoadNS() { var v15 any = v13 _ = v15 // let binding "test" - tmp16 := checkDerefVar(glojure_DOT_core_nth) + tmp16 := checkDerefVar(var_glojure_DOT_core_nth) tmp17 := lang.Apply(tmp16, []any{v15, int64(0), nil}) var v18 any = tmp17 _ = v18 // let binding "step" - tmp19 := checkDerefVar(glojure_DOT_core_nth) + tmp19 := checkDerefVar(var_glojure_DOT_core_nth) tmp20 := lang.Apply(tmp19, []any{v15, int64(1), nil}) var v21 any = tmp20 _ = v21 - tmp22 := checkDerefVar(glojure_DOT_core_seq) - tmp23 := checkDerefVar(glojure_DOT_core_concat) - tmp24 := checkDerefVar(glojure_DOT_core_list) - tmp25 := lang.Apply(tmp24, []any{lang.NewSymbol("if")}) - tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp22 := checkDerefVar(var_glojure_DOT_core_seq) + tmp23 := checkDerefVar(var_glojure_DOT_core_concat) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{sym_if}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) tmp27 := lang.Apply(tmp26, []any{v18}) - tmp28 := checkDerefVar(glojure_DOT_core_list) - tmp29 := checkDerefVar(glojure_DOT_core_seq) - tmp30 := checkDerefVar(glojure_DOT_core_concat) - tmp31 := checkDerefVar(glojure_DOT_core_list) - tmp32 := lang.Apply(tmp31, []any{lang.NewSymbol("glojure.core/->>")}) - tmp33 := checkDerefVar(glojure_DOT_core_list) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := checkDerefVar(var_glojure_DOT_core_seq) + tmp30 := checkDerefVar(var_glojure_DOT_core_concat) + tmp31 := checkDerefVar(var_glojure_DOT_core_list) + tmp32 := lang.Apply(tmp31, []any{sym_glojure_DOT_core_SLASH__DASH__GT__GT_}) + tmp33 := checkDerefVar(var_glojure_DOT_core_list) tmp34 := lang.Apply(tmp33, []any{v10}) - tmp35 := checkDerefVar(glojure_DOT_core_list) + tmp35 := checkDerefVar(var_glojure_DOT_core_list) tmp36 := lang.Apply(tmp35, []any{v21}) tmp37 := lang.Apply(tmp30, []any{tmp32, tmp34, tmp36}) tmp38 := lang.Apply(tmp29, []any{tmp37}) tmp39 := lang.Apply(tmp28, []any{tmp38}) - tmp40 := checkDerefVar(glojure_DOT_core_list) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) tmp41 := lang.Apply(tmp40, []any{v10}) tmp42 := lang.Apply(tmp23, []any{tmp25, tmp27, tmp39, tmp41}) tmp43 := lang.Apply(tmp22, []any{tmp42}) @@ -13625,47 +14486,47 @@ func LoadNS() { } // end let return tmp14 }) - tmp13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7590), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7590), lang.NewKeyword("end-column"), int(67)) + tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7590), kw_column, int(20), kw_end_DASH_line, int(7590), kw_end_DASH_column, int(67)) tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp15 := checkDerefVar(glojure_DOT_core_partition) + tmp15 := checkDerefVar(var_glojure_DOT_core_partition) tmp16 := lang.Apply(tmp15, []any{int64(2), v6}) tmp17 := lang.Apply(tmp11, []any{tmp14, tmp16}) var v18 any = tmp17 _ = v18 - tmp19 := checkDerefVar(glojure_DOT_core_seq) - tmp20 := checkDerefVar(glojure_DOT_core_concat) - tmp21 := checkDerefVar(glojure_DOT_core_list) - tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("glojure.core/let")}) - tmp23 := checkDerefVar(glojure_DOT_core_list) - tmp24 := checkDerefVar(glojure_DOT_core_apply) - tmp25 := checkDerefVar(glojure_DOT_core_vector) - tmp26 := checkDerefVar(glojure_DOT_core_seq) - tmp27 := checkDerefVar(glojure_DOT_core_concat) - tmp28 := checkDerefVar(glojure_DOT_core_list) + tmp19 := checkDerefVar(var_glojure_DOT_core_seq) + tmp20 := checkDerefVar(var_glojure_DOT_core_concat) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{sym_glojure_DOT_core_SLASH_let}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_apply) + tmp25 := checkDerefVar(var_glojure_DOT_core_vector) + tmp26 := checkDerefVar(var_glojure_DOT_core_seq) + tmp27 := checkDerefVar(var_glojure_DOT_core_concat) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) tmp29 := lang.Apply(tmp28, []any{v10}) - tmp30 := checkDerefVar(glojure_DOT_core_list) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) tmp31 := lang.Apply(tmp30, []any{v5}) - tmp32 := checkDerefVar(glojure_DOT_core_interleave) - tmp33 := checkDerefVar(glojure_DOT_core_repeat) + tmp32 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp33 := checkDerefVar(var_glojure_DOT_core_repeat) tmp34 := lang.Apply(tmp33, []any{v10}) - tmp35 := checkDerefVar(glojure_DOT_core_butlast) + tmp35 := checkDerefVar(var_glojure_DOT_core_butlast) tmp36 := lang.Apply(tmp35, []any{v18}) tmp37 := lang.Apply(tmp32, []any{tmp34, tmp36}) tmp38 := lang.Apply(tmp27, []any{tmp29, tmp31, tmp37}) tmp39 := lang.Apply(tmp26, []any{tmp38}) tmp40 := lang.Apply(tmp24, []any{tmp25, tmp39}) tmp41 := lang.Apply(tmp23, []any{tmp40}) - tmp42 := checkDerefVar(glojure_DOT_core_list) + tmp42 := checkDerefVar(var_glojure_DOT_core_list) var tmp43 any - tmp44 := checkDerefVar(glojure_DOT_core_empty_QMARK_) + tmp44 := checkDerefVar(var_glojure_DOT_core_empty_QMARK_) tmp45 := lang.Apply(tmp44, []any{v18}) if lang.IsTruthy(tmp45) { tmp43 = v10 } else { - tmp46 := checkDerefVar(glojure_DOT_core_last) + tmp46 := checkDerefVar(var_glojure_DOT_core_last) tmp47 := lang.Apply(tmp46, []any{v18}) tmp43 = tmp47 } @@ -13677,7 +14538,7 @@ func LoadNS() { return tmp7 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -13685,14 +14546,12 @@ func LoadNS() { } // condp { - tmp0 := lang.NewSymbol("condp").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("clauses"))), lang.NewKeyword("doc"), "Takes a binary predicate, an expression, and a set of clauses.\n Each clause can take the form of either:\n\n test-expr result-expr\n\n test-expr :>> result-fn\n\n Note :>> is an ordinary keyword.\n\n For each clause, (pred test-expr expr) is evaluated. If it returns\n logical true, the clause is a match. If a binary clause matches, the\n result-expr is returned, if a ternary clause matches, its result-fn,\n which must be a unary function, is called with the result of the\n predicate as its argument, the result of that call being the return\n value of condp. A single default expression can follow the clauses,\n and its value will be returned if no clause matches. If no default\n expression is provided and no clause matches, an\n IllegalArgumentException is thrown.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6353), lang.NewKeyword("end-line"), int(6353))).(*lang.Symbol) + tmp0 := sym_condp.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_pred, sym_expr, sym__AMP_, sym_clauses)), kw_doc, "Takes a binary predicate, an expression, and a set of clauses.\n Each clause can take the form of either:\n\n test-expr result-expr\n\n test-expr :>> result-fn\n\n Note :>> is an ordinary keyword.\n\n For each clause, (pred test-expr expr) is evaluated. If it returns\n logical true, the clause is a match. If a binary clause matches, the\n result-expr is returned, if a ternary clause matches, its result-fn,\n which must be a unary function, is called with the result of the\n predicate as its argument, the result of that call being the return\n value of condp. A single default expression can follow the clauses,\n and its value will be returned if no clause matches. If no default\n expression is provided and no clause matches, an\n IllegalArgumentException is thrown.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(11), kw_line, int(6353), kw_end_DASH_line, int(6353))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 4) v3 := args[0] _ = v3 v4 := args[1] @@ -13706,12 +14565,12 @@ func LoadNS() { var tmp8 any { // let // let binding "gpred" - tmp9 := checkDerefVar(glojure_DOT_core_gensym) + tmp9 := checkDerefVar(var_glojure_DOT_core_gensym) tmp10 := lang.Apply(tmp9, []any{"pred__"}) var v11 any = tmp10 _ = v11 // let binding "gexpr" - tmp12 := checkDerefVar(glojure_DOT_core_gensym) + tmp12 := checkDerefVar(var_glojure_DOT_core_gensym) tmp13 := lang.Apply(tmp12, []any{"expr__"}) var v14 any = tmp13 _ = v14 @@ -13720,9 +14579,7 @@ func LoadNS() { { // function emit var v16 lang.FnFunc tmp15 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v17 := args[0] _ = v17 v18 := args[1] @@ -13732,12 +14589,12 @@ func LoadNS() { var tmp20 any { // let // let binding "vec__144" - tmp21 := checkDerefVar(glojure_DOT_core_split_at) + tmp21 := checkDerefVar(var_glojure_DOT_core_split_DASH_at) var tmp22 any - tmp23 := checkDerefVar(glojure_DOT_core__EQ_) - tmp24 := checkDerefVar(glojure_DOT_core_second) + tmp23 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp24 := checkDerefVar(var_glojure_DOT_core_second) tmp25 := lang.Apply(tmp24, []any{v19}) - tmp26 := lang.Apply(tmp23, []any{lang.NewKeyword(">>"), tmp25}) + tmp26 := lang.Apply(tmp23, []any{kw__GT__GT_, tmp25}) if lang.IsTruthy(tmp26) { tmp22 = int64(3) } else { @@ -13747,22 +14604,22 @@ func LoadNS() { var v28 any = tmp27 _ = v28 // let binding "vec__147" - tmp29 := checkDerefVar(glojure_DOT_core_nth) + tmp29 := checkDerefVar(var_glojure_DOT_core_nth) tmp30 := lang.Apply(tmp29, []any{v28, int64(0), nil}) var v31 any = tmp30 _ = v31 // let binding "a" - tmp32 := checkDerefVar(glojure_DOT_core_nth) + tmp32 := checkDerefVar(var_glojure_DOT_core_nth) tmp33 := lang.Apply(tmp32, []any{v31, int64(0), nil}) var v34 any = tmp33 _ = v34 // let binding "b" - tmp35 := checkDerefVar(glojure_DOT_core_nth) + tmp35 := checkDerefVar(var_glojure_DOT_core_nth) tmp36 := lang.Apply(tmp35, []any{v31, int64(1), nil}) var v37 any = tmp36 _ = v37 // let binding "c" - tmp38 := checkDerefVar(glojure_DOT_core_nth) + tmp38 := checkDerefVar(var_glojure_DOT_core_nth) tmp39 := lang.Apply(tmp38, []any{v31, int64(2), nil}) var v40 any = tmp39 _ = v40 @@ -13770,36 +14627,36 @@ func LoadNS() { var v41 any = v31 _ = v41 // let binding "more" - tmp42 := checkDerefVar(glojure_DOT_core_nth) + tmp42 := checkDerefVar(var_glojure_DOT_core_nth) tmp43 := lang.Apply(tmp42, []any{v28, int64(1), nil}) var v44 any = tmp43 _ = v44 // let binding "n" - tmp45 := checkDerefVar(glojure_DOT_core_count) + tmp45 := checkDerefVar(var_glojure_DOT_core_count) tmp46 := lang.Apply(tmp45, []any{v41}) var v47 any = tmp46 _ = v47 var tmp48 any - tmp49 := checkDerefVar(glojure_DOT_core__EQ_) + tmp49 := checkDerefVar(var_glojure_DOT_core__EQ_) tmp50 := lang.Apply(tmp49, []any{int64(0), v47}) if lang.IsTruthy(tmp50) { - tmp51 := checkDerefVar(glojure_DOT_core_seq) - tmp52 := checkDerefVar(glojure_DOT_core_concat) - tmp53 := checkDerefVar(glojure_DOT_core_list) - tmp54 := lang.Apply(tmp53, []any{lang.NewSymbol("throw")}) - tmp55 := checkDerefVar(glojure_DOT_core_list) - tmp56 := checkDerefVar(glojure_DOT_core_seq) - tmp57 := checkDerefVar(glojure_DOT_core_concat) - tmp58 := checkDerefVar(glojure_DOT_core_list) - tmp59 := lang.Apply(tmp58, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewIllegalArgumentError")}) - tmp60 := checkDerefVar(glojure_DOT_core_list) - tmp61 := checkDerefVar(glojure_DOT_core_seq) - tmp62 := checkDerefVar(glojure_DOT_core_concat) - tmp63 := checkDerefVar(glojure_DOT_core_list) - tmp64 := lang.Apply(tmp63, []any{lang.NewSymbol("glojure.core/str")}) - tmp65 := checkDerefVar(glojure_DOT_core_list) + tmp51 := checkDerefVar(var_glojure_DOT_core_seq) + tmp52 := checkDerefVar(var_glojure_DOT_core_concat) + tmp53 := checkDerefVar(var_glojure_DOT_core_list) + tmp54 := lang.Apply(tmp53, []any{sym_throw}) + tmp55 := checkDerefVar(var_glojure_DOT_core_list) + tmp56 := checkDerefVar(var_glojure_DOT_core_seq) + tmp57 := checkDerefVar(var_glojure_DOT_core_concat) + tmp58 := checkDerefVar(var_glojure_DOT_core_list) + tmp59 := lang.Apply(tmp58, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_NewIllegalArgumentError}) + tmp60 := checkDerefVar(var_glojure_DOT_core_list) + tmp61 := checkDerefVar(var_glojure_DOT_core_seq) + tmp62 := checkDerefVar(var_glojure_DOT_core_concat) + tmp63 := checkDerefVar(var_glojure_DOT_core_list) + tmp64 := lang.Apply(tmp63, []any{sym_glojure_DOT_core_SLASH_str}) + tmp65 := checkDerefVar(var_glojure_DOT_core_list) tmp66 := lang.Apply(tmp65, []any{"No matching clause: "}) - tmp67 := checkDerefVar(glojure_DOT_core_list) + tmp67 := checkDerefVar(var_glojure_DOT_core_list) tmp68 := lang.Apply(tmp67, []any{v18}) tmp69 := lang.Apply(tmp62, []any{tmp64, tmp66, tmp68}) tmp70 := lang.Apply(tmp61, []any{tmp69}) @@ -13812,34 +14669,34 @@ func LoadNS() { tmp48 = tmp76 } else { var tmp77 any - tmp78 := checkDerefVar(glojure_DOT_core__EQ_) + tmp78 := checkDerefVar(var_glojure_DOT_core__EQ_) tmp79 := lang.Apply(tmp78, []any{int64(1), v47}) if lang.IsTruthy(tmp79) { tmp77 = v34 } else { var tmp80 any - tmp81 := checkDerefVar(glojure_DOT_core__EQ_) + tmp81 := checkDerefVar(var_glojure_DOT_core__EQ_) tmp82 := lang.Apply(tmp81, []any{int64(2), v47}) if lang.IsTruthy(tmp82) { - tmp83 := checkDerefVar(glojure_DOT_core_seq) - tmp84 := checkDerefVar(glojure_DOT_core_concat) - tmp85 := checkDerefVar(glojure_DOT_core_list) - tmp86 := lang.Apply(tmp85, []any{lang.NewSymbol("if")}) - tmp87 := checkDerefVar(glojure_DOT_core_list) - tmp88 := checkDerefVar(glojure_DOT_core_seq) - tmp89 := checkDerefVar(glojure_DOT_core_concat) - tmp90 := checkDerefVar(glojure_DOT_core_list) + tmp83 := checkDerefVar(var_glojure_DOT_core_seq) + tmp84 := checkDerefVar(var_glojure_DOT_core_concat) + tmp85 := checkDerefVar(var_glojure_DOT_core_list) + tmp86 := lang.Apply(tmp85, []any{sym_if}) + tmp87 := checkDerefVar(var_glojure_DOT_core_list) + tmp88 := checkDerefVar(var_glojure_DOT_core_seq) + tmp89 := checkDerefVar(var_glojure_DOT_core_concat) + tmp90 := checkDerefVar(var_glojure_DOT_core_list) tmp91 := lang.Apply(tmp90, []any{v17}) - tmp92 := checkDerefVar(glojure_DOT_core_list) + tmp92 := checkDerefVar(var_glojure_DOT_core_list) tmp93 := lang.Apply(tmp92, []any{v34}) - tmp94 := checkDerefVar(glojure_DOT_core_list) + tmp94 := checkDerefVar(var_glojure_DOT_core_list) tmp95 := lang.Apply(tmp94, []any{v18}) tmp96 := lang.Apply(tmp89, []any{tmp91, tmp93, tmp95}) tmp97 := lang.Apply(tmp88, []any{tmp96}) tmp98 := lang.Apply(tmp87, []any{tmp97}) - tmp99 := checkDerefVar(glojure_DOT_core_list) + tmp99 := checkDerefVar(var_glojure_DOT_core_list) tmp100 := lang.Apply(tmp99, []any{v37}) - tmp101 := checkDerefVar(glojure_DOT_core_list) + tmp101 := checkDerefVar(var_glojure_DOT_core_list) tmp102 := lang.Apply(v16, []any{v17, v18, v44}) tmp103 := lang.Apply(tmp101, []any{tmp102}) tmp104 := lang.Apply(tmp84, []any{tmp86, tmp98, tmp100, tmp103}) @@ -13847,26 +14704,26 @@ func LoadNS() { tmp80 = tmp105 } else { var tmp106 any - if lang.IsTruthy(lang.NewKeyword("else")) { - tmp107 := checkDerefVar(glojure_DOT_core_seq) - tmp108 := checkDerefVar(glojure_DOT_core_concat) - tmp109 := checkDerefVar(glojure_DOT_core_list) - tmp110 := lang.Apply(tmp109, []any{lang.NewSymbol("glojure.core/if-let")}) - tmp111 := checkDerefVar(glojure_DOT_core_list) - tmp112 := checkDerefVar(glojure_DOT_core_apply) - tmp113 := checkDerefVar(glojure_DOT_core_vector) - tmp114 := checkDerefVar(glojure_DOT_core_seq) - tmp115 := checkDerefVar(glojure_DOT_core_concat) - tmp116 := checkDerefVar(glojure_DOT_core_list) - tmp117 := lang.Apply(tmp116, []any{lang.NewSymbol("p__0__auto__")}) - tmp118 := checkDerefVar(glojure_DOT_core_list) - tmp119 := checkDerefVar(glojure_DOT_core_seq) - tmp120 := checkDerefVar(glojure_DOT_core_concat) - tmp121 := checkDerefVar(glojure_DOT_core_list) + if lang.IsTruthy(kw_else) { + tmp107 := checkDerefVar(var_glojure_DOT_core_seq) + tmp108 := checkDerefVar(var_glojure_DOT_core_concat) + tmp109 := checkDerefVar(var_glojure_DOT_core_list) + tmp110 := lang.Apply(tmp109, []any{sym_glojure_DOT_core_SLASH_if_DASH_let}) + tmp111 := checkDerefVar(var_glojure_DOT_core_list) + tmp112 := checkDerefVar(var_glojure_DOT_core_apply) + tmp113 := checkDerefVar(var_glojure_DOT_core_vector) + tmp114 := checkDerefVar(var_glojure_DOT_core_seq) + tmp115 := checkDerefVar(var_glojure_DOT_core_concat) + tmp116 := checkDerefVar(var_glojure_DOT_core_list) + tmp117 := lang.Apply(tmp116, []any{sym_p__0__auto__}) + tmp118 := checkDerefVar(var_glojure_DOT_core_list) + tmp119 := checkDerefVar(var_glojure_DOT_core_seq) + tmp120 := checkDerefVar(var_glojure_DOT_core_concat) + tmp121 := checkDerefVar(var_glojure_DOT_core_list) tmp122 := lang.Apply(tmp121, []any{v17}) - tmp123 := checkDerefVar(glojure_DOT_core_list) + tmp123 := checkDerefVar(var_glojure_DOT_core_list) tmp124 := lang.Apply(tmp123, []any{v34}) - tmp125 := checkDerefVar(glojure_DOT_core_list) + tmp125 := checkDerefVar(var_glojure_DOT_core_list) tmp126 := lang.Apply(tmp125, []any{v18}) tmp127 := lang.Apply(tmp120, []any{tmp122, tmp124, tmp126}) tmp128 := lang.Apply(tmp119, []any{tmp127}) @@ -13875,17 +14732,17 @@ func LoadNS() { tmp131 := lang.Apply(tmp114, []any{tmp130}) tmp132 := lang.Apply(tmp112, []any{tmp113, tmp131}) tmp133 := lang.Apply(tmp111, []any{tmp132}) - tmp134 := checkDerefVar(glojure_DOT_core_list) - tmp135 := checkDerefVar(glojure_DOT_core_seq) - tmp136 := checkDerefVar(glojure_DOT_core_concat) - tmp137 := checkDerefVar(glojure_DOT_core_list) + tmp134 := checkDerefVar(var_glojure_DOT_core_list) + tmp135 := checkDerefVar(var_glojure_DOT_core_seq) + tmp136 := checkDerefVar(var_glojure_DOT_core_concat) + tmp137 := checkDerefVar(var_glojure_DOT_core_list) tmp138 := lang.Apply(tmp137, []any{v40}) - tmp139 := checkDerefVar(glojure_DOT_core_list) - tmp140 := lang.Apply(tmp139, []any{lang.NewSymbol("p__0__auto__")}) + tmp139 := checkDerefVar(var_glojure_DOT_core_list) + tmp140 := lang.Apply(tmp139, []any{sym_p__0__auto__}) tmp141 := lang.Apply(tmp136, []any{tmp138, tmp140}) tmp142 := lang.Apply(tmp135, []any{tmp141}) tmp143 := lang.Apply(tmp134, []any{tmp142}) - tmp144 := checkDerefVar(glojure_DOT_core_list) + tmp144 := checkDerefVar(var_glojure_DOT_core_list) tmp145 := lang.Apply(v16, []any{v17, v18, v44}) tmp146 := lang.Apply(tmp144, []any{tmp145}) tmp147 := lang.Apply(tmp108, []any{tmp110, tmp133, tmp143, tmp146}) @@ -13906,35 +14763,35 @@ func LoadNS() { v16 = tmp15 _ = v16 } - tmp16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6377), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(6389), lang.NewKeyword("end-column"), int(53)) + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6377), kw_column, int(14), kw_end_DASH_line, int(6389), kw_end_DASH_column, int(53)) tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) if err != nil { panic(err) } var v18 any = tmp17 _ = v18 - tmp19 := checkDerefVar(glojure_DOT_core_seq) - tmp20 := checkDerefVar(glojure_DOT_core_concat) - tmp21 := checkDerefVar(glojure_DOT_core_list) - tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("glojure.core/let")}) - tmp23 := checkDerefVar(glojure_DOT_core_list) - tmp24 := checkDerefVar(glojure_DOT_core_apply) - tmp25 := checkDerefVar(glojure_DOT_core_vector) - tmp26 := checkDerefVar(glojure_DOT_core_seq) - tmp27 := checkDerefVar(glojure_DOT_core_concat) - tmp28 := checkDerefVar(glojure_DOT_core_list) + tmp19 := checkDerefVar(var_glojure_DOT_core_seq) + tmp20 := checkDerefVar(var_glojure_DOT_core_concat) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{sym_glojure_DOT_core_SLASH_let}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_apply) + tmp25 := checkDerefVar(var_glojure_DOT_core_vector) + tmp26 := checkDerefVar(var_glojure_DOT_core_seq) + tmp27 := checkDerefVar(var_glojure_DOT_core_concat) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) tmp29 := lang.Apply(tmp28, []any{v11}) - tmp30 := checkDerefVar(glojure_DOT_core_list) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) tmp31 := lang.Apply(tmp30, []any{v5}) - tmp32 := checkDerefVar(glojure_DOT_core_list) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) tmp33 := lang.Apply(tmp32, []any{v14}) - tmp34 := checkDerefVar(glojure_DOT_core_list) + tmp34 := checkDerefVar(var_glojure_DOT_core_list) tmp35 := lang.Apply(tmp34, []any{v6}) tmp36 := lang.Apply(tmp27, []any{tmp29, tmp31, tmp33, tmp35}) tmp37 := lang.Apply(tmp26, []any{tmp36}) tmp38 := lang.Apply(tmp24, []any{tmp25, tmp37}) tmp39 := lang.Apply(tmp23, []any{tmp38}) - tmp40 := checkDerefVar(glojure_DOT_core_list) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) tmp41 := lang.Apply(v18, []any{v11, v14, v7}) tmp42 := lang.Apply(tmp40, []any{tmp41}) tmp43 := lang.Apply(tmp20, []any{tmp22, tmp39, tmp42}) @@ -13944,7 +14801,7 @@ func LoadNS() { return tmp8 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -13952,7 +14809,7 @@ func LoadNS() { } // conj { - tmp0 := lang.NewSymbol("conj").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("xs"))), lang.NewKeyword("doc"), "conj[oin]. Returns a new collection with the xs\n 'added'. (conj nil item) returns (item).\n (conj coll) returns coll. (conj) returns [].\n The 'addition' may happen at different 'places' depending\n on the concrete type.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(73), lang.NewKeyword("end-line"), int(81))).(*lang.Symbol) + tmp0 := sym_conj.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_coll), lang.NewVector(sym_coll, sym_x), lang.NewVector(sym_coll, sym_x, sym__AMP_, sym_xs)), kw_doc, "conj[oin]. Returns a new collection with the xs\n 'added'. (conj nil item) returns (item).\n (conj coll) returns coll. (conj) returns [].\n The 'addition' may happen at different 'places' depending\n on the concrete type.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(5), kw_column, int(2), kw_line, int(73), kw_end_DASH_line, int(81))).(*lang.Symbol) var tmp2 lang.FnFunc { // function conj var v3 lang.FnFunc @@ -13960,7 +14817,7 @@ func LoadNS() { switch len(args) { case 0: tmp4 := lang.NewVector() - tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(82), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(82), lang.NewKeyword("end-column"), int(14)) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(82), kw_column, int(13), kw_end_DASH_line, int(82), kw_end_DASH_column, int(14)) tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) if err != nil { panic(err) @@ -13978,9 +14835,7 @@ func LoadNS() { tmp6 := lang.Apply(lang.Conj, []any{v4, v5}) return tmp6 default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -13992,10 +14847,10 @@ func LoadNS() { if lang.IsTruthy(v6) { tmp9 := lang.Apply(lang.Conj, []any{v4, v5}) var tmp8 any = tmp9 - tmp11 := checkDerefVar(glojure_DOT_core_first) + tmp11 := checkDerefVar(var_glojure_DOT_core_first) tmp12 := lang.Apply(tmp11, []any{v6}) var tmp10 any = tmp12 - tmp14 := checkDerefVar(glojure_DOT_core_next) + tmp14 := checkDerefVar(var_glojure_DOT_core_next) tmp15 := lang.Apply(tmp14, []any{v6}) var tmp13 any = tmp15 v4 = tmp8 @@ -14009,7 +14864,7 @@ func LoadNS() { return tmp7 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(81), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(88), lang.NewKeyword("end-column"), int(67))).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(81), kw_column, int(7), kw_end_DASH_line, int(88), kw_end_DASH_column, int(67))).(lang.FnFunc) v3 = tmp2 _ = v3 } @@ -14020,14 +14875,14 @@ func LoadNS() { } // conj! { - tmp0 := lang.NewSymbol("conj!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Adds x to the transient collection, and return coll. The 'addition'\n may happen at different 'places' depending on the concrete type.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3359), lang.NewKeyword("end-line"), int(3359))).(*lang.Symbol) + tmp0 := sym_conj_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_coll), lang.NewVector(sym_coll, sym_x)), kw_doc, "Adds x to the transient collection, and return coll. The 'addition'\n may happen at different 'places' depending on the concrete type.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3359), kw_end_DASH_line, int(3359))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - tmp3 := checkDerefVar(glojure_DOT_core_transient) + tmp3 := checkDerefVar(var_glojure_DOT_core_transient) tmp4 := lang.NewVector() - tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3364), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(3364), lang.NewKeyword("end-column"), int(19)) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3364), kw_column, int(18), kw_end_DASH_line, int(3364), kw_end_DASH_column, int(19)) tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) if err != nil { panic(err) @@ -14050,10 +14905,11 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v4}) return tmp6 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -14061,14 +14917,12 @@ func LoadNS() { } // cons { - tmp0 := lang.NewSymbol("cons").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("seq"))), lang.NewKeyword("doc"), "Returns a new seq where x is the first element and seq is\n the rest.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(21), lang.NewKeyword("end-line"), int(27))).(*lang.Symbol) + tmp0 := sym_cons.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_seq)), kw_doc, "Returns a new seq where x is the first element and seq is\n the rest.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(5), kw_column, int(2), kw_line, int(21), kw_end_DASH_line, int(27))).(*lang.Symbol) var tmp2 lang.FnFunc { // function cons var v3 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -14076,7 +14930,7 @@ func LoadNS() { tmp6 := lang.Apply(lang.NewCons, []any{v4, v5}) return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(27), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(27), lang.NewKeyword("end-column"), int(89))).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(27), kw_column, int(7), kw_end_DASH_line, int(27), kw_end_DASH_column, int(89))).(lang.FnFunc) v3 = tmp2 _ = v3 } @@ -14087,34 +14941,30 @@ func LoadNS() { } // constantly { - tmp0 := lang.NewSymbol("constantly").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns a function that takes any number of arguments and returns x.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1440), lang.NewKeyword("end-line"), int(1440))).(*lang.Symbol) + tmp0 := sym_constantly.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns a function that takes any number of arguments and returns x.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(1440), kw_end_DASH_line, int(1440))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 lang.FnFunc tmp4 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var v5 any = lang.NewList(args[0:]...) _ = v5 return v3 } }) - tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1444), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(1444), lang.NewKeyword("end-column"), int(21)) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(1444), kw_column, int(7), kw_end_DASH_line, int(1444), kw_end_DASH_column, int(21)) tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) if err != nil { panic(err) } return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -14122,12 +14972,10 @@ func LoadNS() { } // contains? { - tmp0 := lang.NewSymbol("contains?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("key"))), lang.NewKeyword("doc"), "Returns true if key is present in the given collection, otherwise\n returns false. Note that for numerically indexed collections like\n vectors and Java arrays, this tests if the numeric key is within the\n range of indexes. 'contains?' operates constant or logarithmic time;\n it will not perform a linear search for a value. See also 'some'.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1479), lang.NewKeyword("end-line"), int(1479))).(*lang.Symbol) + tmp0 := sym_contains_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll, sym_key)), kw_doc, "Returns true if key is present in the given collection, otherwise\n returns false. Note that for numerically indexed collections like\n vectors and Java arrays, this tests if the numeric key is within the\n range of indexes. 'contains?' operates constant or logarithmic time;\n it will not perform a linear search for a value. See also 'some'.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(1479), kw_end_DASH_line, int(1479))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -14139,7 +14987,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -14151,23 +14999,21 @@ func LoadNS() { { // function count__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) - tmp5 := checkDerefVar(glojure_DOT_core_concat) - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := checkDerefVar(glojure_DOT_core_seq) - tmp12 := checkDerefVar(glojure_DOT_core_concat) - tmp13 := checkDerefVar(glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/Count")}) - tmp15 := checkDerefVar(glojure_DOT_core_list) + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Count}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) tmp18 := lang.Apply(tmp11, []any{tmp17}) @@ -14179,18 +15025,16 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("count").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the number of items in the collection. (count nil) returns\n 0. Also works on strings, arrays, and Java Collections and Maps", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(867), lang.NewKeyword("end-line"), int(867))).(*lang.Symbol) + tmp0 := sym_count.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_inline, tmp1, kw_doc, "Returns the number of items in the collection. (count nil) returns\n 0. Also works on strings, arrays, and Java Collections and Maps", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(867), kw_end_DASH_line, int(867))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 tmp5 := lang.Apply(lang.Count, []any{v4}) return tmp5 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -14198,20 +15042,18 @@ func LoadNS() { } // counted? { - tmp0 := lang.NewSymbol("counted?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements count in constant time", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6241), lang.NewKeyword("end-line"), int(6241))).(*lang.Symbol) + tmp0 := sym_counted_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns true if coll implements count in constant time", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(6241), kw_end_DASH_line, int(6241))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp5 := reflect.TypeOf((*lang.Counted)(nil)).Elem() tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -14219,18 +15061,16 @@ func LoadNS() { } // create-ns { - tmp0 := lang.NewSymbol("create-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Create a new namespace named by the symbol if one doesn't already\n exist, returns it or the already-existing namespace of the same\n name.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4131), lang.NewKeyword("end-line"), int(4131))).(*lang.Symbol) + tmp0 := sym_create_DASH_ns.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_sym)), kw_doc, "Create a new namespace named by the symbol if one doesn't already\n exist, returns it or the already-existing namespace of the same\n name.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(4131), kw_end_DASH_line, int(4131))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4 := lang.Apply(nil, []any{v3}) return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -14238,21 +15078,19 @@ func LoadNS() { } // create-struct { - tmp0 := lang.NewSymbol("create-struct").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keys"))), lang.NewKeyword("doc"), "Returns a structure basis object.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4037), lang.NewKeyword("end-line"), int(4037))).(*lang.Symbol) + tmp0 := sym_create_DASH_struct.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_keys)), kw_doc, "Returns a structure basis object.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(4037), kw_end_DASH_line, int(4037))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 tmp4 := lang.Apply(lang.CreatePersistentStructMapSlotMap, []any{v3}) return tmp4 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -14260,20 +15098,18 @@ func LoadNS() { } // cycle { - tmp0 := lang.NewSymbol("cycle").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy (infinite!) sequence of repetitions of the items in coll.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2977), lang.NewKeyword("end-line"), int(2977))).(*lang.Symbol) + tmp0 := sym_cycle.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a lazy (infinite!) sequence of repetitions of the items in coll.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(2977), kw_end_DASH_line, int(2977))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) tmp5 := lang.Apply(tmp4, []any{v3}) tmp6 := lang.Apply(lang.NewCycle, []any{tmp5}) return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -14281,15 +15117,13 @@ func LoadNS() { } // data-reader-urls { - tmp0 := lang.NewSymbol("data-reader-urls").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7830), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7830), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym_data_DASH_reader_DASH_urls.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7830), kw_column, int(8), kw_end_DASH_line, int(7830), kw_end_DASH_column, int(23), kw_private, true, kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) return lang.NewList() }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -14297,29 +15131,27 @@ func LoadNS() { } // data-reader-var { - tmp0 := lang.NewSymbol("data-reader-var").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7832), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7832), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym_data_DASH_reader_DASH_var.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7832), kw_column, int(8), kw_end_DASH_line, int(7832), kw_end_DASH_column, int(22), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_sym)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_intern) - tmp5 := checkDerefVar(glojure_DOT_core_create_ns) - tmp6 := checkDerefVar(glojure_DOT_core_symbol) - tmp7 := checkDerefVar(glojure_DOT_core_namespace) + tmp4 := checkDerefVar(var_glojure_DOT_core_intern) + tmp5 := checkDerefVar(var_glojure_DOT_core_create_DASH_ns) + tmp6 := checkDerefVar(var_glojure_DOT_core_symbol) + tmp7 := checkDerefVar(var_glojure_DOT_core_namespace) tmp8 := lang.Apply(tmp7, []any{v3}) tmp9 := lang.Apply(tmp6, []any{tmp8}) tmp10 := lang.Apply(tmp5, []any{tmp9}) - tmp11 := checkDerefVar(glojure_DOT_core_symbol) - tmp12 := checkDerefVar(glojure_DOT_core_name) + tmp11 := checkDerefVar(var_glojure_DOT_core_symbol) + tmp12 := checkDerefVar(var_glojure_DOT_core_name) tmp13 := lang.Apply(tmp12, []any{v3}) tmp14 := lang.Apply(tmp11, []any{tmp13}) tmp15 := lang.Apply(tmp4, []any{tmp10, tmp14}) return tmp15 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -14331,30 +15163,28 @@ func LoadNS() { { // function dec__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) - tmp5 := checkDerefVar(glojure_DOT_core_concat) - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := checkDerefVar(glojure_DOT_core_seq) - tmp12 := checkDerefVar(glojure_DOT_core_concat) - tmp13 := checkDerefVar(glojure_DOT_core_list) + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) var tmp14 any - tmp15 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + tmp15 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp15) { - tmp14 = lang.NewSymbol("unchecked_dec") + tmp14 = sym_unchecked_dec } else { - tmp14 = lang.NewSymbol("dec") + tmp14 = sym_dec } tmp16 := lang.Apply(tmp13, []any{tmp14}) - tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) tmp18 := lang.Apply(tmp17, []any{v3}) tmp19 := lang.Apply(tmp12, []any{tmp16, tmp18}) tmp20 := lang.Apply(tmp11, []any{tmp19}) @@ -14366,12 +15196,10 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("dec").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns a number one less than num. Does not auto-promote\n longs, will throw on overflow. See also: dec'", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1147), lang.NewKeyword("end-line"), int(1147))).(*lang.Symbol) + tmp0 := sym_dec.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns a number one less than num. Does not auto-promote\n longs, will throw on overflow. See also: dec'", kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(1147), kw_end_DASH_line, int(1147))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Dec") @@ -14381,7 +15209,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v4}) return tmp6 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -14393,23 +15221,21 @@ func LoadNS() { { // function dec'__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) - tmp5 := checkDerefVar(glojure_DOT_core_concat) - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := checkDerefVar(glojure_DOT_core_seq) - tmp12 := checkDerefVar(glojure_DOT_core_concat) - tmp13 := checkDerefVar(glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/DecP")}) - tmp15 := checkDerefVar(glojure_DOT_core_list) + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_DecP}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) tmp18 := lang.Apply(tmp11, []any{tmp17}) @@ -14421,12 +15247,10 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("dec'").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns a number one less than num. Supports arbitrary precision.\n See also: dec", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1140), lang.NewKeyword("end-line"), int(1140))).(*lang.Symbol) + tmp0 := sym_dec_TICK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns a number one less than num. Supports arbitrary precision.\n See also: dec", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1140), kw_end_DASH_line, int(1140))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 tmp5, _ := lang.FieldOrMethod(lang.Numbers, "DecP") @@ -14436,7 +15260,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v4}) return tmp6 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -14444,20 +15268,18 @@ func LoadNS() { } // decimal? { - tmp0 := lang.NewSymbol("decimal?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is a BigDecimal", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3599), lang.NewKeyword("end-line"), int(3599))).(*lang.Symbol) + tmp0 := sym_decimal_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_doc, "Returns true if n is a BigDecimal", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(3599), kw_end_DASH_line, int(3599))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp5 := reflect.TypeOf((*lang.BigDecimal)(nil)) tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -14465,40 +15287,36 @@ func LoadNS() { } // declare { - tmp0 := lang.NewSymbol("declare").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("names"))), lang.NewKeyword("doc"), "defs the supplied var names with no bindings, useful for making forward declarations.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(2768), lang.NewKeyword("end-line"), int(2768))).(*lang.Symbol) + tmp0 := sym_declare.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_names)), kw_doc, "defs the supplied var names with no bindings, useful for making forward declarations.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(2768), kw_end_DASH_line, int(2768))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 var v5 any = lang.NewList(args[2:]...) _ = v5 - tmp6 := checkDerefVar(glojure_DOT_core_seq) - tmp7 := checkDerefVar(glojure_DOT_core_concat) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("do")}) - tmp10 := checkDerefVar(glojure_DOT_core_map) + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_do}) + tmp10 := checkDerefVar(var_glojure_DOT_core_map) var tmp11 lang.FnFunc tmp11 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v12 := args[0] _ = v12 - tmp13 := checkDerefVar(glojure_DOT_core_list) - tmp14 := checkDerefVar(glojure_DOT_core_vary_meta) - tmp15 := checkDerefVar(glojure_DOT_core_assoc) - tmp16 := lang.Apply(tmp14, []any{v12, tmp15, lang.NewKeyword("declared"), true}) - tmp17 := lang.Apply(tmp13, []any{lang.NewSymbol("def"), tmp16}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_vary_DASH_meta) + tmp15 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp16 := lang.Apply(tmp14, []any{v12, tmp15, kw_declared, true}) + tmp17 := lang.Apply(tmp13, []any{sym_def, tmp16}) return tmp17 }) - tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2771), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(2771), lang.NewKeyword("end-column"), int(71)) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2771), kw_column, int(25), kw_end_DASH_line, int(2771), kw_end_DASH_column, int(71)) tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) if err != nil { panic(err) @@ -14509,7 +15327,7 @@ func LoadNS() { return tmp16 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -14517,23 +15335,21 @@ func LoadNS() { } // dedupe { - tmp0 := lang.NewSymbol("dedupe").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence removing consecutive duplicates in coll.\n Returns a transducer when no collection is provided.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7681), lang.NewKeyword("end-line"), int(7681))).(*lang.Symbol) + tmp0 := sym_dedupe.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_coll)), kw_doc, "Returns a lazy sequence removing consecutive duplicates in coll.\n Returns a transducer when no collection is provided.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(7681), kw_end_DASH_line, int(7681))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 var tmp5 any { // let // let binding "pv" - tmp6 := checkDerefVar(glojure_DOT_core_volatile_BANG_) - tmp7 := lang.Apply(tmp6, []any{lang.NewKeyword("glojure.core/none")}) + tmp6 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) + tmp7 := lang.Apply(tmp6, []any{kw_glojure_DOT_core_SLASH_none}) var v8 any = tmp7 _ = v8 var tmp9 lang.FnFunc @@ -14555,15 +15371,15 @@ func LoadNS() { var tmp12 any { // let // let binding "prior" - tmp13 := checkDerefVar(glojure_DOT_core_deref) + tmp13 := checkDerefVar(var_glojure_DOT_core_deref) tmp14 := lang.Apply(tmp13, []any{v8}) var v15 any = tmp14 _ = v15 - tmp16 := checkDerefVar(glojure_DOT_core_vreset_BANG_) + tmp16 := checkDerefVar(var_glojure_DOT_core_vreset_BANG_) tmp17 := lang.Apply(tmp16, []any{v8, v11}) _ = tmp17 var tmp18 any - tmp19 := checkDerefVar(glojure_DOT_core__EQ_) + tmp19 := checkDerefVar(var_glojure_DOT_core__EQ_) tmp20 := lang.Apply(tmp19, []any{v15, v11}) if lang.IsTruthy(tmp20) { tmp18 = v10 @@ -14575,10 +15391,11 @@ func LoadNS() { } // end let return tmp12 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7688), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7696), lang.NewKeyword("end-column"), int(37)) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7688), kw_column, int(8), kw_end_DASH_line, int(7696), kw_end_DASH_column, int(37)) tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) if err != nil { panic(err) @@ -14587,7 +15404,7 @@ func LoadNS() { } // end let return tmp5 }) - tmp4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7686), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7696), lang.NewKeyword("end-column"), int(39)) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7686), kw_column, int(4), kw_end_DASH_line, int(7696), kw_end_DASH_column, int(39)) tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) if err != nil { panic(err) @@ -14596,16 +15413,17 @@ func LoadNS() { case 1: v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_sequence) - tmp5 := checkDerefVar(glojure_DOT_core_dedupe) + tmp4 := checkDerefVar(var_glojure_DOT_core_sequence) + tmp5 := checkDerefVar(var_glojure_DOT_core_dedupe) tmp6 := lang.Apply(tmp5, nil) tmp7 := lang.Apply(tmp4, []any{tmp6, v3}) return tmp7 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -14613,12 +15431,10 @@ func LoadNS() { } // def-aset { - tmp0 := lang.NewSymbol("def-aset").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("method"), lang.NewSymbol("coerce"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(3), lang.NewKeyword("line"), int(3935), lang.NewKeyword("end-line"), int(3936), lang.NewKeyword("private"), true)).(*lang.Symbol) + tmp0 := sym_def_DASH_aset.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym_method, sym_coerce)), kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(3), kw_line, int(3935), kw_end_DASH_line, int(3936), kw_private, true)).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 5 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 5) v3 := args[0] _ = v3 v4 := args[1] @@ -14629,57 +15445,57 @@ func LoadNS() { _ = v6 v7 := args[4] _ = v7 - tmp8 := checkDerefVar(glojure_DOT_core_seq) - tmp9 := checkDerefVar(glojure_DOT_core_concat) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol("glojure.core/defn")}) - tmp12 := checkDerefVar(glojure_DOT_core_list) + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_defn}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := lang.Apply(tmp12, []any{v5}) - tmp14 := checkDerefVar(glojure_DOT_core_list) - tmp15 := checkDerefVar(glojure_DOT_core_apply) - tmp16 := checkDerefVar(glojure_DOT_core_hash_map) - tmp17 := checkDerefVar(glojure_DOT_core_seq) - tmp18 := checkDerefVar(glojure_DOT_core_concat) - tmp19 := checkDerefVar(glojure_DOT_core_list) - tmp20 := lang.Apply(tmp19, []any{lang.NewKeyword("arglists")}) - tmp21 := checkDerefVar(glojure_DOT_core_list) - tmp22 := checkDerefVar(glojure_DOT_core_seq) - tmp23 := checkDerefVar(glojure_DOT_core_concat) - tmp24 := checkDerefVar(glojure_DOT_core_list) - tmp25 := lang.Apply(tmp24, []any{lang.NewSymbol("quote")}) - tmp26 := checkDerefVar(glojure_DOT_core_list) - tmp27 := checkDerefVar(glojure_DOT_core_seq) - tmp28 := checkDerefVar(glojure_DOT_core_concat) - tmp29 := checkDerefVar(glojure_DOT_core_list) - tmp30 := checkDerefVar(glojure_DOT_core_apply) - tmp31 := checkDerefVar(glojure_DOT_core_vector) - tmp32 := checkDerefVar(glojure_DOT_core_seq) - tmp33 := checkDerefVar(glojure_DOT_core_concat) - tmp34 := checkDerefVar(glojure_DOT_core_list) - tmp35 := lang.Apply(tmp34, []any{lang.NewSymbol("array")}) - tmp36 := checkDerefVar(glojure_DOT_core_list) - tmp37 := lang.Apply(tmp36, []any{lang.NewSymbol("idx")}) - tmp38 := checkDerefVar(glojure_DOT_core_list) - tmp39 := lang.Apply(tmp38, []any{lang.NewSymbol("val")}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_apply) + tmp16 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp17 := checkDerefVar(var_glojure_DOT_core_seq) + tmp18 := checkDerefVar(var_glojure_DOT_core_concat) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{kw_arglists}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := checkDerefVar(var_glojure_DOT_core_seq) + tmp23 := checkDerefVar(var_glojure_DOT_core_concat) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{sym_quote}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := checkDerefVar(var_glojure_DOT_core_seq) + tmp28 := checkDerefVar(var_glojure_DOT_core_concat) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := checkDerefVar(var_glojure_DOT_core_apply) + tmp31 := checkDerefVar(var_glojure_DOT_core_vector) + tmp32 := checkDerefVar(var_glojure_DOT_core_seq) + tmp33 := checkDerefVar(var_glojure_DOT_core_concat) + tmp34 := checkDerefVar(var_glojure_DOT_core_list) + tmp35 := lang.Apply(tmp34, []any{sym_array}) + tmp36 := checkDerefVar(var_glojure_DOT_core_list) + tmp37 := lang.Apply(tmp36, []any{sym_idx}) + tmp38 := checkDerefVar(var_glojure_DOT_core_list) + tmp39 := lang.Apply(tmp38, []any{sym_val}) tmp40 := lang.Apply(tmp33, []any{tmp35, tmp37, tmp39}) tmp41 := lang.Apply(tmp32, []any{tmp40}) tmp42 := lang.Apply(tmp30, []any{tmp31, tmp41}) tmp43 := lang.Apply(tmp29, []any{tmp42}) - tmp44 := checkDerefVar(glojure_DOT_core_list) - tmp45 := checkDerefVar(glojure_DOT_core_apply) - tmp46 := checkDerefVar(glojure_DOT_core_vector) - tmp47 := checkDerefVar(glojure_DOT_core_seq) - tmp48 := checkDerefVar(glojure_DOT_core_concat) - tmp49 := checkDerefVar(glojure_DOT_core_list) - tmp50 := lang.Apply(tmp49, []any{lang.NewSymbol("array")}) - tmp51 := checkDerefVar(glojure_DOT_core_list) - tmp52 := lang.Apply(tmp51, []any{lang.NewSymbol("idx")}) - tmp53 := checkDerefVar(glojure_DOT_core_list) - tmp54 := lang.Apply(tmp53, []any{lang.NewSymbol("idx2")}) - tmp55 := checkDerefVar(glojure_DOT_core_list) - tmp56 := lang.Apply(tmp55, []any{lang.NewSymbol("&")}) - tmp57 := checkDerefVar(glojure_DOT_core_list) - tmp58 := lang.Apply(tmp57, []any{lang.NewSymbol("idxv")}) + tmp44 := checkDerefVar(var_glojure_DOT_core_list) + tmp45 := checkDerefVar(var_glojure_DOT_core_apply) + tmp46 := checkDerefVar(var_glojure_DOT_core_vector) + tmp47 := checkDerefVar(var_glojure_DOT_core_seq) + tmp48 := checkDerefVar(var_glojure_DOT_core_concat) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) + tmp50 := lang.Apply(tmp49, []any{sym_array}) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := lang.Apply(tmp51, []any{sym_idx}) + tmp53 := checkDerefVar(var_glojure_DOT_core_list) + tmp54 := lang.Apply(tmp53, []any{sym_idx2}) + tmp55 := checkDerefVar(var_glojure_DOT_core_list) + tmp56 := lang.Apply(tmp55, []any{sym__AMP_}) + tmp57 := checkDerefVar(var_glojure_DOT_core_list) + tmp58 := lang.Apply(tmp57, []any{sym_idxv}) tmp59 := lang.Apply(tmp48, []any{tmp50, tmp52, tmp54, tmp56, tmp58}) tmp60 := lang.Apply(tmp47, []any{tmp59}) tmp61 := lang.Apply(tmp45, []any{tmp46, tmp60}) @@ -14694,47 +15510,47 @@ func LoadNS() { tmp70 := lang.Apply(tmp17, []any{tmp69}) tmp71 := lang.Apply(tmp15, []any{tmp16, tmp70}) tmp72 := lang.Apply(tmp14, []any{tmp71}) - tmp73 := checkDerefVar(glojure_DOT_core_list) - tmp74 := checkDerefVar(glojure_DOT_core_seq) - tmp75 := checkDerefVar(glojure_DOT_core_concat) - tmp76 := checkDerefVar(glojure_DOT_core_list) - tmp77 := checkDerefVar(glojure_DOT_core_apply) - tmp78 := checkDerefVar(glojure_DOT_core_vector) - tmp79 := checkDerefVar(glojure_DOT_core_seq) - tmp80 := checkDerefVar(glojure_DOT_core_concat) - tmp81 := checkDerefVar(glojure_DOT_core_list) - tmp82 := lang.Apply(tmp81, []any{lang.NewSymbol("array__0__auto__")}) - tmp83 := checkDerefVar(glojure_DOT_core_list) - tmp84 := lang.Apply(tmp83, []any{lang.NewSymbol("idx__1__auto__")}) - tmp85 := checkDerefVar(glojure_DOT_core_list) - tmp86 := lang.Apply(tmp85, []any{lang.NewSymbol("val__2__auto__")}) + tmp73 := checkDerefVar(var_glojure_DOT_core_list) + tmp74 := checkDerefVar(var_glojure_DOT_core_seq) + tmp75 := checkDerefVar(var_glojure_DOT_core_concat) + tmp76 := checkDerefVar(var_glojure_DOT_core_list) + tmp77 := checkDerefVar(var_glojure_DOT_core_apply) + tmp78 := checkDerefVar(var_glojure_DOT_core_vector) + tmp79 := checkDerefVar(var_glojure_DOT_core_seq) + tmp80 := checkDerefVar(var_glojure_DOT_core_concat) + tmp81 := checkDerefVar(var_glojure_DOT_core_list) + tmp82 := lang.Apply(tmp81, []any{sym_array__0__auto__}) + tmp83 := checkDerefVar(var_glojure_DOT_core_list) + tmp84 := lang.Apply(tmp83, []any{sym_idx__1__auto__}) + tmp85 := checkDerefVar(var_glojure_DOT_core_list) + tmp86 := lang.Apply(tmp85, []any{sym_val__2__auto__}) tmp87 := lang.Apply(tmp80, []any{tmp82, tmp84, tmp86}) tmp88 := lang.Apply(tmp79, []any{tmp87}) tmp89 := lang.Apply(tmp77, []any{tmp78, tmp88}) tmp90 := lang.Apply(tmp76, []any{tmp89}) - tmp91 := checkDerefVar(glojure_DOT_core_list) - tmp92 := checkDerefVar(glojure_DOT_core_seq) - tmp93 := checkDerefVar(glojure_DOT_core_concat) - tmp94 := checkDerefVar(glojure_DOT_core_list) - tmp95 := lang.Apply(tmp94, []any{lang.NewSymbol(".")}) - tmp96 := checkDerefVar(glojure_DOT_core_list) - tmp97 := lang.Apply(tmp96, []any{lang.NewSymbol("glojure.core/Array")}) - tmp98 := checkDerefVar(glojure_DOT_core_list) - tmp99 := checkDerefVar(glojure_DOT_core_seq) - tmp100 := checkDerefVar(glojure_DOT_core_concat) - tmp101 := checkDerefVar(glojure_DOT_core_list) + tmp91 := checkDerefVar(var_glojure_DOT_core_list) + tmp92 := checkDerefVar(var_glojure_DOT_core_seq) + tmp93 := checkDerefVar(var_glojure_DOT_core_concat) + tmp94 := checkDerefVar(var_glojure_DOT_core_list) + tmp95 := lang.Apply(tmp94, []any{sym__DOT_}) + tmp96 := checkDerefVar(var_glojure_DOT_core_list) + tmp97 := lang.Apply(tmp96, []any{sym_glojure_DOT_core_SLASH_Array}) + tmp98 := checkDerefVar(var_glojure_DOT_core_list) + tmp99 := checkDerefVar(var_glojure_DOT_core_seq) + tmp100 := checkDerefVar(var_glojure_DOT_core_concat) + tmp101 := checkDerefVar(var_glojure_DOT_core_list) tmp102 := lang.Apply(tmp101, []any{v6}) - tmp103 := checkDerefVar(glojure_DOT_core_list) - tmp104 := lang.Apply(tmp103, []any{lang.NewSymbol("array__0__auto__")}) - tmp105 := checkDerefVar(glojure_DOT_core_list) - tmp106 := lang.Apply(tmp105, []any{lang.NewSymbol("idx__1__auto__")}) - tmp107 := checkDerefVar(glojure_DOT_core_list) - tmp108 := checkDerefVar(glojure_DOT_core_seq) - tmp109 := checkDerefVar(glojure_DOT_core_concat) - tmp110 := checkDerefVar(glojure_DOT_core_list) + tmp103 := checkDerefVar(var_glojure_DOT_core_list) + tmp104 := lang.Apply(tmp103, []any{sym_array__0__auto__}) + tmp105 := checkDerefVar(var_glojure_DOT_core_list) + tmp106 := lang.Apply(tmp105, []any{sym_idx__1__auto__}) + tmp107 := checkDerefVar(var_glojure_DOT_core_list) + tmp108 := checkDerefVar(var_glojure_DOT_core_seq) + tmp109 := checkDerefVar(var_glojure_DOT_core_concat) + tmp110 := checkDerefVar(var_glojure_DOT_core_list) tmp111 := lang.Apply(tmp110, []any{v7}) - tmp112 := checkDerefVar(glojure_DOT_core_list) - tmp113 := lang.Apply(tmp112, []any{lang.NewSymbol("val__2__auto__")}) + tmp112 := checkDerefVar(var_glojure_DOT_core_list) + tmp113 := lang.Apply(tmp112, []any{sym_val__2__auto__}) tmp114 := lang.Apply(tmp109, []any{tmp111, tmp113}) tmp115 := lang.Apply(tmp108, []any{tmp114}) tmp116 := lang.Apply(tmp107, []any{tmp115}) @@ -14744,56 +15560,56 @@ func LoadNS() { tmp120 := lang.Apply(tmp93, []any{tmp95, tmp97, tmp119}) tmp121 := lang.Apply(tmp92, []any{tmp120}) tmp122 := lang.Apply(tmp91, []any{tmp121}) - tmp123 := checkDerefVar(glojure_DOT_core_list) - tmp124 := lang.Apply(tmp123, []any{lang.NewSymbol("val__2__auto__")}) + tmp123 := checkDerefVar(var_glojure_DOT_core_list) + tmp124 := lang.Apply(tmp123, []any{sym_val__2__auto__}) tmp125 := lang.Apply(tmp75, []any{tmp90, tmp122, tmp124}) tmp126 := lang.Apply(tmp74, []any{tmp125}) tmp127 := lang.Apply(tmp73, []any{tmp126}) - tmp128 := checkDerefVar(glojure_DOT_core_list) - tmp129 := checkDerefVar(glojure_DOT_core_seq) - tmp130 := checkDerefVar(glojure_DOT_core_concat) - tmp131 := checkDerefVar(glojure_DOT_core_list) - tmp132 := checkDerefVar(glojure_DOT_core_apply) - tmp133 := checkDerefVar(glojure_DOT_core_vector) - tmp134 := checkDerefVar(glojure_DOT_core_seq) - tmp135 := checkDerefVar(glojure_DOT_core_concat) - tmp136 := checkDerefVar(glojure_DOT_core_list) - tmp137 := lang.Apply(tmp136, []any{lang.NewSymbol("array__0__auto__")}) - tmp138 := checkDerefVar(glojure_DOT_core_list) - tmp139 := lang.Apply(tmp138, []any{lang.NewSymbol("idx__1__auto__")}) - tmp140 := checkDerefVar(glojure_DOT_core_list) - tmp141 := lang.Apply(tmp140, []any{lang.NewSymbol("idx2__3__auto__")}) - tmp142 := checkDerefVar(glojure_DOT_core_list) - tmp143 := lang.Apply(tmp142, []any{lang.NewSymbol("&")}) - tmp144 := checkDerefVar(glojure_DOT_core_list) - tmp145 := lang.Apply(tmp144, []any{lang.NewSymbol("idxv__4__auto__")}) + tmp128 := checkDerefVar(var_glojure_DOT_core_list) + tmp129 := checkDerefVar(var_glojure_DOT_core_seq) + tmp130 := checkDerefVar(var_glojure_DOT_core_concat) + tmp131 := checkDerefVar(var_glojure_DOT_core_list) + tmp132 := checkDerefVar(var_glojure_DOT_core_apply) + tmp133 := checkDerefVar(var_glojure_DOT_core_vector) + tmp134 := checkDerefVar(var_glojure_DOT_core_seq) + tmp135 := checkDerefVar(var_glojure_DOT_core_concat) + tmp136 := checkDerefVar(var_glojure_DOT_core_list) + tmp137 := lang.Apply(tmp136, []any{sym_array__0__auto__}) + tmp138 := checkDerefVar(var_glojure_DOT_core_list) + tmp139 := lang.Apply(tmp138, []any{sym_idx__1__auto__}) + tmp140 := checkDerefVar(var_glojure_DOT_core_list) + tmp141 := lang.Apply(tmp140, []any{sym_idx2__3__auto__}) + tmp142 := checkDerefVar(var_glojure_DOT_core_list) + tmp143 := lang.Apply(tmp142, []any{sym__AMP_}) + tmp144 := checkDerefVar(var_glojure_DOT_core_list) + tmp145 := lang.Apply(tmp144, []any{sym_idxv__4__auto__}) tmp146 := lang.Apply(tmp135, []any{tmp137, tmp139, tmp141, tmp143, tmp145}) tmp147 := lang.Apply(tmp134, []any{tmp146}) tmp148 := lang.Apply(tmp132, []any{tmp133, tmp147}) tmp149 := lang.Apply(tmp131, []any{tmp148}) - tmp150 := checkDerefVar(glojure_DOT_core_list) - tmp151 := checkDerefVar(glojure_DOT_core_seq) - tmp152 := checkDerefVar(glojure_DOT_core_concat) - tmp153 := checkDerefVar(glojure_DOT_core_list) - tmp154 := lang.Apply(tmp153, []any{lang.NewSymbol("glojure.core/apply")}) - tmp155 := checkDerefVar(glojure_DOT_core_list) + tmp150 := checkDerefVar(var_glojure_DOT_core_list) + tmp151 := checkDerefVar(var_glojure_DOT_core_seq) + tmp152 := checkDerefVar(var_glojure_DOT_core_concat) + tmp153 := checkDerefVar(var_glojure_DOT_core_list) + tmp154 := lang.Apply(tmp153, []any{sym_glojure_DOT_core_SLASH_apply}) + tmp155 := checkDerefVar(var_glojure_DOT_core_list) tmp156 := lang.Apply(tmp155, []any{v5}) - tmp157 := checkDerefVar(glojure_DOT_core_list) - tmp158 := checkDerefVar(glojure_DOT_core_seq) - tmp159 := checkDerefVar(glojure_DOT_core_concat) - tmp160 := checkDerefVar(glojure_DOT_core_list) - tmp161 := lang.Apply(tmp160, []any{lang.NewSymbol("glojure.core/aget")}) - tmp162 := checkDerefVar(glojure_DOT_core_list) - tmp163 := lang.Apply(tmp162, []any{lang.NewSymbol("array__0__auto__")}) - tmp164 := checkDerefVar(glojure_DOT_core_list) - tmp165 := lang.Apply(tmp164, []any{lang.NewSymbol("idx__1__auto__")}) + tmp157 := checkDerefVar(var_glojure_DOT_core_list) + tmp158 := checkDerefVar(var_glojure_DOT_core_seq) + tmp159 := checkDerefVar(var_glojure_DOT_core_concat) + tmp160 := checkDerefVar(var_glojure_DOT_core_list) + tmp161 := lang.Apply(tmp160, []any{sym_glojure_DOT_core_SLASH_aget}) + tmp162 := checkDerefVar(var_glojure_DOT_core_list) + tmp163 := lang.Apply(tmp162, []any{sym_array__0__auto__}) + tmp164 := checkDerefVar(var_glojure_DOT_core_list) + tmp165 := lang.Apply(tmp164, []any{sym_idx__1__auto__}) tmp166 := lang.Apply(tmp159, []any{tmp161, tmp163, tmp165}) tmp167 := lang.Apply(tmp158, []any{tmp166}) tmp168 := lang.Apply(tmp157, []any{tmp167}) - tmp169 := checkDerefVar(glojure_DOT_core_list) - tmp170 := lang.Apply(tmp169, []any{lang.NewSymbol("idx2__3__auto__")}) - tmp171 := checkDerefVar(glojure_DOT_core_list) - tmp172 := lang.Apply(tmp171, []any{lang.NewSymbol("idxv__4__auto__")}) + tmp169 := checkDerefVar(var_glojure_DOT_core_list) + tmp170 := lang.Apply(tmp169, []any{sym_idx2__3__auto__}) + tmp171 := checkDerefVar(var_glojure_DOT_core_list) + tmp172 := lang.Apply(tmp171, []any{sym_idxv__4__auto__}) tmp173 := lang.Apply(tmp152, []any{tmp154, tmp156, tmp168, tmp170, tmp172}) tmp174 := lang.Apply(tmp151, []any{tmp173}) tmp175 := lang.Apply(tmp150, []any{tmp174}) @@ -14804,7 +15620,7 @@ func LoadNS() { tmp180 := lang.Apply(tmp8, []any{tmp179}) return tmp180 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -14812,14 +15628,12 @@ func LoadNS() { } // definline { - tmp0 := lang.NewSymbol("definline").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("decl"))), lang.NewKeyword("doc"), "Experimental - like defmacro, except defines a named function whose\n body is the expansion, calls to which may be expanded inline as if\n it were a macro. Cannot be used with variadic (&) args.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5253), lang.NewKeyword("end-line"), int(5253))).(*lang.Symbol) + tmp0 := sym_definline.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym__AMP_, sym_decl)), kw_doc, "Experimental - like defmacro, except defines a named function whose\n body is the expansion, calls to which may be expanded inline as if\n it were a macro. Cannot be used with variadic (&) args.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(11), kw_line, int(5253), kw_end_DASH_line, int(5253))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -14831,87 +15645,87 @@ func LoadNS() { var tmp7 any { // let // let binding "vec__80" - tmp8 := checkDerefVar(glojure_DOT_core_split_with) - tmp9 := checkDerefVar(glojure_DOT_core_comp) - tmp10 := checkDerefVar(glojure_DOT_core_not) - tmp11 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp8 := checkDerefVar(var_glojure_DOT_core_split_DASH_with) + tmp9 := checkDerefVar(var_glojure_DOT_core_comp) + tmp10 := checkDerefVar(var_glojure_DOT_core_not) + tmp11 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) tmp12 := lang.Apply(tmp9, []any{tmp10, tmp11}) tmp13 := lang.Apply(tmp8, []any{tmp12, v6}) var v14 any = tmp13 _ = v14 // let binding "pre-args" - tmp15 := checkDerefVar(glojure_DOT_core_nth) + tmp15 := checkDerefVar(var_glojure_DOT_core_nth) tmp16 := lang.Apply(tmp15, []any{v14, int64(0), nil}) var v17 any = tmp16 _ = v17 // let binding "vec__83" - tmp18 := checkDerefVar(glojure_DOT_core_nth) + tmp18 := checkDerefVar(var_glojure_DOT_core_nth) tmp19 := lang.Apply(tmp18, []any{v14, int64(1), nil}) var v20 any = tmp19 _ = v20 // let binding "args" - tmp21 := checkDerefVar(glojure_DOT_core_nth) + tmp21 := checkDerefVar(var_glojure_DOT_core_nth) tmp22 := lang.Apply(tmp21, []any{v20, int64(0), nil}) var v23 any = tmp22 _ = v23 // let binding "expr" - tmp24 := checkDerefVar(glojure_DOT_core_nth) + tmp24 := checkDerefVar(var_glojure_DOT_core_nth) tmp25 := lang.Apply(tmp24, []any{v20, int64(1), nil}) var v26 any = tmp25 _ = v26 - tmp27 := checkDerefVar(glojure_DOT_core_seq) - tmp28 := checkDerefVar(glojure_DOT_core_concat) - tmp29 := checkDerefVar(glojure_DOT_core_list) - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("do")}) - tmp31 := checkDerefVar(glojure_DOT_core_list) - tmp32 := checkDerefVar(glojure_DOT_core_seq) - tmp33 := checkDerefVar(glojure_DOT_core_concat) - tmp34 := checkDerefVar(glojure_DOT_core_list) - tmp35 := lang.Apply(tmp34, []any{lang.NewSymbol("glojure.core/defn")}) - tmp36 := checkDerefVar(glojure_DOT_core_list) + tmp27 := checkDerefVar(var_glojure_DOT_core_seq) + tmp28 := checkDerefVar(var_glojure_DOT_core_concat) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{sym_do}) + tmp31 := checkDerefVar(var_glojure_DOT_core_list) + tmp32 := checkDerefVar(var_glojure_DOT_core_seq) + tmp33 := checkDerefVar(var_glojure_DOT_core_concat) + tmp34 := checkDerefVar(var_glojure_DOT_core_list) + tmp35 := lang.Apply(tmp34, []any{sym_glojure_DOT_core_SLASH_defn}) + tmp36 := checkDerefVar(var_glojure_DOT_core_list) tmp37 := lang.Apply(tmp36, []any{v5}) - tmp38 := checkDerefVar(glojure_DOT_core_list) + tmp38 := checkDerefVar(var_glojure_DOT_core_list) tmp39 := lang.Apply(tmp38, []any{v23}) - tmp40 := checkDerefVar(glojure_DOT_core_list) - tmp41 := checkDerefVar(glojure_DOT_core_apply) - tmp42 := checkDerefVar(glojure_DOT_core_eval) - tmp43 := checkDerefVar(glojure_DOT_core_list) - tmp44 := lang.Apply(tmp43, []any{lang.NewSymbol("glojure.core/fn"), v23, v26}) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := checkDerefVar(var_glojure_DOT_core_apply) + tmp42 := checkDerefVar(var_glojure_DOT_core_eval) + tmp43 := checkDerefVar(var_glojure_DOT_core_list) + tmp44 := lang.Apply(tmp43, []any{sym_glojure_DOT_core_SLASH_fn, v23, v26}) tmp45 := lang.Apply(tmp42, []any{tmp44}) tmp46 := lang.Apply(tmp41, []any{tmp45, v23}) tmp47 := lang.Apply(tmp40, []any{tmp46}) tmp48 := lang.Apply(tmp33, []any{tmp35, tmp37, v17, tmp39, tmp47}) tmp49 := lang.Apply(tmp32, []any{tmp48}) tmp50 := lang.Apply(tmp31, []any{tmp49}) - tmp51 := checkDerefVar(glojure_DOT_core_list) - tmp52 := checkDerefVar(glojure_DOT_core_seq) - tmp53 := checkDerefVar(glojure_DOT_core_concat) - tmp54 := checkDerefVar(glojure_DOT_core_list) - tmp55 := lang.Apply(tmp54, []any{lang.NewSymbol("glojure.core/alter-meta!")}) - tmp56 := checkDerefVar(glojure_DOT_core_list) - tmp57 := checkDerefVar(glojure_DOT_core_seq) - tmp58 := checkDerefVar(glojure_DOT_core_concat) - tmp59 := checkDerefVar(glojure_DOT_core_list) - tmp60 := lang.Apply(tmp59, []any{lang.NewSymbol("var")}) - tmp61 := checkDerefVar(glojure_DOT_core_list) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := checkDerefVar(var_glojure_DOT_core_seq) + tmp53 := checkDerefVar(var_glojure_DOT_core_concat) + tmp54 := checkDerefVar(var_glojure_DOT_core_list) + tmp55 := lang.Apply(tmp54, []any{sym_glojure_DOT_core_SLASH_alter_DASH_meta_BANG_}) + tmp56 := checkDerefVar(var_glojure_DOT_core_list) + tmp57 := checkDerefVar(var_glojure_DOT_core_seq) + tmp58 := checkDerefVar(var_glojure_DOT_core_concat) + tmp59 := checkDerefVar(var_glojure_DOT_core_list) + tmp60 := lang.Apply(tmp59, []any{sym_var}) + tmp61 := checkDerefVar(var_glojure_DOT_core_list) tmp62 := lang.Apply(tmp61, []any{v5}) tmp63 := lang.Apply(tmp58, []any{tmp60, tmp62}) tmp64 := lang.Apply(tmp57, []any{tmp63}) tmp65 := lang.Apply(tmp56, []any{tmp64}) - tmp66 := checkDerefVar(glojure_DOT_core_list) - tmp67 := lang.Apply(tmp66, []any{lang.NewSymbol("glojure.core/assoc")}) - tmp68 := checkDerefVar(glojure_DOT_core_list) - tmp69 := lang.Apply(tmp68, []any{lang.NewKeyword("inline")}) - tmp70 := checkDerefVar(glojure_DOT_core_list) - tmp71 := checkDerefVar(glojure_DOT_core_seq) - tmp72 := checkDerefVar(glojure_DOT_core_concat) - tmp73 := checkDerefVar(glojure_DOT_core_list) - tmp74 := lang.Apply(tmp73, []any{lang.NewSymbol("glojure.core/fn")}) - tmp75 := checkDerefVar(glojure_DOT_core_list) + tmp66 := checkDerefVar(var_glojure_DOT_core_list) + tmp67 := lang.Apply(tmp66, []any{sym_glojure_DOT_core_SLASH_assoc}) + tmp68 := checkDerefVar(var_glojure_DOT_core_list) + tmp69 := lang.Apply(tmp68, []any{kw_inline}) + tmp70 := checkDerefVar(var_glojure_DOT_core_list) + tmp71 := checkDerefVar(var_glojure_DOT_core_seq) + tmp72 := checkDerefVar(var_glojure_DOT_core_concat) + tmp73 := checkDerefVar(var_glojure_DOT_core_list) + tmp74 := lang.Apply(tmp73, []any{sym_glojure_DOT_core_SLASH_fn}) + tmp75 := checkDerefVar(var_glojure_DOT_core_list) tmp76 := lang.Apply(tmp75, []any{v5}) - tmp77 := checkDerefVar(glojure_DOT_core_list) + tmp77 := checkDerefVar(var_glojure_DOT_core_list) tmp78 := lang.Apply(tmp77, []any{v23}) - tmp79 := checkDerefVar(glojure_DOT_core_list) + tmp79 := checkDerefVar(var_glojure_DOT_core_list) tmp80 := lang.Apply(tmp79, []any{v26}) tmp81 := lang.Apply(tmp72, []any{tmp74, tmp76, tmp78, tmp80}) tmp82 := lang.Apply(tmp71, []any{tmp81}) @@ -14919,12 +15733,12 @@ func LoadNS() { tmp84 := lang.Apply(tmp53, []any{tmp55, tmp65, tmp67, tmp69, tmp83}) tmp85 := lang.Apply(tmp52, []any{tmp84}) tmp86 := lang.Apply(tmp51, []any{tmp85}) - tmp87 := checkDerefVar(glojure_DOT_core_list) - tmp88 := checkDerefVar(glojure_DOT_core_seq) - tmp89 := checkDerefVar(glojure_DOT_core_concat) - tmp90 := checkDerefVar(glojure_DOT_core_list) - tmp91 := lang.Apply(tmp90, []any{lang.NewSymbol("var")}) - tmp92 := checkDerefVar(glojure_DOT_core_list) + tmp87 := checkDerefVar(var_glojure_DOT_core_list) + tmp88 := checkDerefVar(var_glojure_DOT_core_seq) + tmp89 := checkDerefVar(var_glojure_DOT_core_concat) + tmp90 := checkDerefVar(var_glojure_DOT_core_list) + tmp91 := lang.Apply(tmp90, []any{sym_var}) + tmp92 := checkDerefVar(var_glojure_DOT_core_list) tmp93 := lang.Apply(tmp92, []any{v5}) tmp94 := lang.Apply(tmp89, []any{tmp91, tmp93}) tmp95 := lang.Apply(tmp88, []any{tmp94}) @@ -14936,7 +15750,7 @@ func LoadNS() { return tmp7 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -14944,14 +15758,12 @@ func LoadNS() { } // defmacro { - tmp0 := lang.NewSymbol("defmacro").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("doc-string?"), lang.NewSymbol("attr-map?"), lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("body")), lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("doc-string?"), lang.NewSymbol("attr-map?"), lang.NewList(lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("body")), lang.NewSymbol("+"), lang.NewSymbol("attr-map?"))), lang.NewKeyword("doc"), "Like defn, but the resulting function name is declared as a\n macro and will be used as a macro by the compiler when it is\n called.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(445), lang.NewKeyword("end-line"), int(451))).(*lang.Symbol) + tmp0 := sym_defmacro.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym_doc_DASH_string_QMARK_, sym_attr_DASH_map_QMARK_, lang.NewVector(sym_params_STAR_), sym_body), lang.NewVector(sym_name, sym_doc_DASH_string_QMARK_, sym_attr_DASH_map_QMARK_, lang.NewList(lang.NewVector(sym_params_STAR_), sym_body), sym__PLUS_, sym_attr_DASH_map_QMARK_)), kw_doc, "Like defn, but the resulting function name is declared as a\n macro and will be used as a macro by the compiler when it is\n called.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(2), kw_line, int(445), kw_end_DASH_line, int(451))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -14966,7 +15778,7 @@ func LoadNS() { var tmp8 any { // let // let binding "p" - tmp9 := checkDerefVar(glojure_DOT_core_list) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) tmp10 := lang.Apply(tmp9, []any{v5}) var v11 any = tmp10 _ = v11 @@ -14977,18 +15789,18 @@ func LoadNS() { var tmp13 any { // let // let binding "f" - tmp14 := checkDerefVar(glojure_DOT_core_first) + tmp14 := checkDerefVar(var_glojure_DOT_core_first) tmp15 := lang.Apply(tmp14, []any{v12}) var v16 any = tmp15 _ = v16 var tmp17 any - tmp18 := checkDerefVar(glojure_DOT_core_string_QMARK_) + tmp18 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) tmp19 := lang.Apply(tmp18, []any{v16}) if lang.IsTruthy(tmp19) { - tmp21 := checkDerefVar(glojure_DOT_core_cons) + tmp21 := checkDerefVar(var_glojure_DOT_core_cons) tmp22 := lang.Apply(tmp21, []any{v16, v11}) var tmp20 any = tmp22 - tmp24 := checkDerefVar(glojure_DOT_core_next) + tmp24 := checkDerefVar(var_glojure_DOT_core_next) tmp25 := lang.Apply(tmp24, []any{v12}) var tmp23 any = tmp25 v11 = tmp20 @@ -14996,13 +15808,13 @@ func LoadNS() { continue } else { var tmp26 any - tmp27 := checkDerefVar(glojure_DOT_core_map_QMARK_) + tmp27 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) tmp28 := lang.Apply(tmp27, []any{v16}) if lang.IsTruthy(tmp28) { - tmp30 := checkDerefVar(glojure_DOT_core_cons) + tmp30 := checkDerefVar(var_glojure_DOT_core_cons) tmp31 := lang.Apply(tmp30, []any{v16, v11}) var tmp29 any = tmp31 - tmp33 := checkDerefVar(glojure_DOT_core_next) + tmp33 := checkDerefVar(var_glojure_DOT_core_next) tmp34 := lang.Apply(tmp33, []any{v12}) var tmp32 any = tmp34 v11 = tmp29 @@ -15029,24 +15841,24 @@ func LoadNS() { _ = v11 for { var tmp12 any - tmp13 := checkDerefVar(glojure_DOT_core_string_QMARK_) - tmp14 := checkDerefVar(glojure_DOT_core_first) + tmp13 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp14 := checkDerefVar(var_glojure_DOT_core_first) tmp15 := lang.Apply(tmp14, []any{v11}) tmp16 := lang.Apply(tmp13, []any{tmp15}) if lang.IsTruthy(tmp16) { - tmp18 := checkDerefVar(glojure_DOT_core_next) + tmp18 := checkDerefVar(var_glojure_DOT_core_next) tmp19 := lang.Apply(tmp18, []any{v11}) var tmp17 any = tmp19 v11 = tmp17 continue } else { var tmp20 any - tmp21 := checkDerefVar(glojure_DOT_core_map_QMARK_) - tmp22 := checkDerefVar(glojure_DOT_core_first) + tmp21 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp22 := checkDerefVar(var_glojure_DOT_core_first) tmp23 := lang.Apply(tmp22, []any{v11}) tmp24 := lang.Apply(tmp21, []any{tmp23}) if lang.IsTruthy(tmp24) { - tmp26 := checkDerefVar(glojure_DOT_core_next) + tmp26 := checkDerefVar(var_glojure_DOT_core_next) tmp27 := lang.Apply(tmp26, []any{v11}) var tmp25 any = tmp27 v11 = tmp25 @@ -15064,12 +15876,12 @@ func LoadNS() { _ = v11 // let binding "fdecl" var tmp12 any - tmp13 := checkDerefVar(glojure_DOT_core_vector_QMARK_) - tmp14 := checkDerefVar(glojure_DOT_core_first) + tmp13 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp14 := checkDerefVar(var_glojure_DOT_core_first) tmp15 := lang.Apply(tmp14, []any{v11}) tmp16 := lang.Apply(tmp13, []any{tmp15}) if lang.IsTruthy(tmp16) { - tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) tmp18 := lang.Apply(tmp17, []any{v11}) tmp12 = tmp18 } else { @@ -15080,33 +15892,31 @@ func LoadNS() { // let binding "add-implicit-args" var tmp20 lang.FnFunc tmp20 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v21 := args[0] _ = v21 var tmp22 any { // let // let binding "args" - tmp23 := checkDerefVar(glojure_DOT_core_first) + tmp23 := checkDerefVar(var_glojure_DOT_core_first) tmp24 := lang.Apply(tmp23, []any{v21}) var v25 any = tmp24 _ = v25 - tmp26 := checkDerefVar(glojure_DOT_core_cons) - tmp27 := checkDerefVar(glojure_DOT_core_vec) - tmp28 := checkDerefVar(glojure_DOT_core_cons) - tmp29 := checkDerefVar(glojure_DOT_core_cons) - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("&env"), v25}) - tmp31 := lang.Apply(tmp28, []any{lang.NewSymbol("&form"), tmp30}) + tmp26 := checkDerefVar(var_glojure_DOT_core_cons) + tmp27 := checkDerefVar(var_glojure_DOT_core_vec) + tmp28 := checkDerefVar(var_glojure_DOT_core_cons) + tmp29 := checkDerefVar(var_glojure_DOT_core_cons) + tmp30 := lang.Apply(tmp29, []any{sym__AMP_env, v25}) + tmp31 := lang.Apply(tmp28, []any{sym__AMP_form, tmp30}) tmp32 := lang.Apply(tmp27, []any{tmp31}) - tmp33 := checkDerefVar(glojure_DOT_core_next) + tmp33 := checkDerefVar(var_glojure_DOT_core_next) tmp34 := lang.Apply(tmp33, []any{v21}) tmp35 := lang.Apply(tmp26, []any{tmp32, tmp34}) tmp22 = tmp35 } // end let return tmp22 }) - tmp21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(469), lang.NewKeyword("column"), int(38), lang.NewKeyword("end-line"), int(471), lang.NewKeyword("end-column"), int(87)) + tmp21 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(469), kw_column, int(38), kw_end_DASH_line, int(471), kw_end_DASH_column, int(87)) tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) if err != nil { panic(err) @@ -15116,16 +15926,14 @@ func LoadNS() { // let binding "add-args" var tmp24 lang.FnFunc tmp24 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v25 := args[0] _ = v25 v26 := args[1] _ = v26 recur_loop_61: var tmp27 any - tmp28 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp28 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) tmp29 := lang.Apply(tmp28, []any{v26}) if lang.IsTruthy(tmp29) { tmp27 = v25 @@ -15133,23 +15941,23 @@ func LoadNS() { var tmp30 any { // let // let binding "d" - tmp31 := checkDerefVar(glojure_DOT_core_first) + tmp31 := checkDerefVar(var_glojure_DOT_core_first) tmp32 := lang.Apply(tmp31, []any{v26}) var v33 any = tmp32 _ = v33 var tmp34 any - tmp35 := checkDerefVar(glojure_DOT_core_map_QMARK_) + tmp35 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) tmp36 := lang.Apply(tmp35, []any{v33}) if lang.IsTruthy(tmp36) { - tmp37 := checkDerefVar(glojure_DOT_core_conj) + tmp37 := checkDerefVar(var_glojure_DOT_core_conj) tmp38 := lang.Apply(tmp37, []any{v25, v33}) tmp34 = tmp38 } else { - tmp40 := checkDerefVar(glojure_DOT_core_conj) + tmp40 := checkDerefVar(var_glojure_DOT_core_conj) tmp41 := lang.Apply(v23, []any{v33}) tmp42 := lang.Apply(tmp40, []any{v25, tmp41}) var tmp39 any = tmp42 - tmp44 := checkDerefVar(glojure_DOT_core_next) + tmp44 := checkDerefVar(var_glojure_DOT_core_next) tmp45 := lang.Apply(tmp44, []any{v26}) var tmp43 any = tmp45 v25 = tmp39 @@ -15162,7 +15970,7 @@ func LoadNS() { } return tmp27 }) - tmp25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(472), lang.NewKeyword("column"), int(29), lang.NewKeyword("end-line"), int(478), lang.NewKeyword("end-column"), int(90)) + tmp25 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(472), kw_column, int(29), kw_end_DASH_line, int(478), kw_end_DASH_column, int(90)) tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) if err != nil { panic(err) @@ -15170,9 +15978,9 @@ func LoadNS() { var v27 any = tmp26 _ = v27 // let binding "fdecl" - tmp28 := checkDerefVar(glojure_DOT_core_seq) + tmp28 := checkDerefVar(var_glojure_DOT_core_seq) tmp29 := lang.NewVector() - tmp30 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(479), lang.NewKeyword("column"), int(41), lang.NewKeyword("end-line"), int(479), lang.NewKeyword("end-column"), int(42)) + tmp30 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(479), kw_column, int(41), kw_end_DASH_line, int(479), kw_end_DASH_column, int(42)) tmp31, err := lang.WithMeta(tmp29, tmp30.(lang.IPersistentMap)) if err != nil { panic(err) @@ -15193,11 +16001,11 @@ func LoadNS() { for { var tmp38 any if lang.IsTruthy(v36) { - tmp40 := checkDerefVar(glojure_DOT_core_next) + tmp40 := checkDerefVar(var_glojure_DOT_core_next) tmp41 := lang.Apply(tmp40, []any{v36}) var tmp39 any = tmp41 - tmp43 := checkDerefVar(glojure_DOT_core_cons) - tmp44 := checkDerefVar(glojure_DOT_core_first) + tmp43 := checkDerefVar(var_glojure_DOT_core_cons) + tmp44 := checkDerefVar(var_glojure_DOT_core_first) tmp45 := lang.Apply(tmp44, []any{v36}) tmp46 := lang.Apply(tmp43, []any{tmp45, v37}) var tmp42 any = tmp46 @@ -15213,22 +16021,22 @@ func LoadNS() { } // end let var v36 any = tmp35 _ = v36 - tmp37 := checkDerefVar(glojure_DOT_core_list) - tmp38 := checkDerefVar(glojure_DOT_core_cons) - tmp39 := lang.Apply(tmp38, []any{lang.NewSymbol("glojure.core/defn"), v36}) - tmp40 := checkDerefVar(glojure_DOT_core_list) - tmp41 := checkDerefVar(glojure_DOT_core_list) - tmp42 := lang.Apply(tmp41, []any{lang.NewSymbol("var"), v5}) - tmp43 := lang.Apply(tmp40, []any{lang.NewSymbol("."), tmp42, lang.NewList(lang.NewSymbol("SetMacro"))}) - tmp44 := checkDerefVar(glojure_DOT_core_list) - tmp45 := lang.Apply(tmp44, []any{lang.NewSymbol("var"), v5}) - tmp46 := lang.Apply(tmp37, []any{lang.NewSymbol("do"), tmp39, tmp43, tmp45}) + tmp37 := checkDerefVar(var_glojure_DOT_core_list) + tmp38 := checkDerefVar(var_glojure_DOT_core_cons) + tmp39 := lang.Apply(tmp38, []any{sym_glojure_DOT_core_SLASH_defn, v36}) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := checkDerefVar(var_glojure_DOT_core_list) + tmp42 := lang.Apply(tmp41, []any{sym_var, v5}) + tmp43 := lang.Apply(tmp40, []any{sym__DOT_, tmp42, lang.NewList(sym_SetMacro)}) + tmp44 := checkDerefVar(var_glojure_DOT_core_list) + tmp45 := lang.Apply(tmp44, []any{sym_var, v5}) + tmp46 := lang.Apply(tmp37, []any{sym_do, tmp39, tmp43, tmp45}) tmp7 = tmp46 } // end let return tmp7 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(451), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(487), lang.NewKeyword("end-column"), int(40))).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(451), kw_column, int(11), kw_end_DASH_line, int(487), kw_end_DASH_column, int(40))).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -15236,14 +16044,12 @@ func LoadNS() { } // defmethod { - tmp0 := lang.NewSymbol("defmethod").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"), lang.NewSymbol("dispatch-val"), lang.NewSymbol("&"), lang.NewSymbol("fn-tail"))), lang.NewKeyword("doc"), "Creates and installs a new method of multimethod associated with dispatch-value. ", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1781), lang.NewKeyword("end-line"), int(1781))).(*lang.Symbol) + tmp0 := sym_defmethod.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_multifn, sym_dispatch_DASH_val, sym__AMP_, sym_fn_DASH_tail)), kw_doc, "Creates and installs a new method of multimethod associated with dispatch-value. ", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(11), kw_line, int(1781), kw_end_DASH_line, int(1781))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 4) v3 := args[0] _ = v3 v4 := args[1] @@ -15254,29 +16060,29 @@ func LoadNS() { _ = v6 var v7 any = lang.NewList(args[4:]...) _ = v7 - tmp8 := checkDerefVar(glojure_DOT_core_seq) - tmp9 := checkDerefVar(glojure_DOT_core_concat) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol(".")}) - tmp12 := checkDerefVar(glojure_DOT_core_list) - tmp13 := checkDerefVar(glojure_DOT_core_with_meta) - tmp14 := lang.NewMap(lang.NewKeyword("tag"), lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.*MultiFn")) - tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1785), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(1785), lang.NewKeyword("end-column"), int(82)) + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp14 := lang.NewMap(kw_tag, sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT__STAR_MultiFn) + tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(1785), kw_column, int(27), kw_end_DASH_line, int(1785), kw_end_DASH_column, int(82)) tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) if err != nil { panic(err) } tmp17 := lang.Apply(tmp13, []any{v5, tmp16}) tmp18 := lang.Apply(tmp12, []any{tmp17}) - tmp19 := checkDerefVar(glojure_DOT_core_list) - tmp20 := lang.Apply(tmp19, []any{lang.NewSymbol("glojure.core/AddMethod")}) - tmp21 := checkDerefVar(glojure_DOT_core_list) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{sym_glojure_DOT_core_SLASH_AddMethod}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) tmp22 := lang.Apply(tmp21, []any{v6}) - tmp23 := checkDerefVar(glojure_DOT_core_list) - tmp24 := checkDerefVar(glojure_DOT_core_seq) - tmp25 := checkDerefVar(glojure_DOT_core_concat) - tmp26 := checkDerefVar(glojure_DOT_core_list) - tmp27 := lang.Apply(tmp26, []any{lang.NewSymbol("glojure.core/fn")}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_seq) + tmp25 := checkDerefVar(var_glojure_DOT_core_concat) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{sym_glojure_DOT_core_SLASH_fn}) tmp28 := lang.Apply(tmp25, []any{tmp27, v7}) tmp29 := lang.Apply(tmp24, []any{tmp28}) tmp30 := lang.Apply(tmp23, []any{tmp29}) @@ -15285,7 +16091,7 @@ func LoadNS() { return tmp32 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -15293,14 +16099,12 @@ func LoadNS() { } // defmulti { - tmp0 := lang.NewSymbol("defmulti").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("docstring?"), lang.NewSymbol("attr-map?"), lang.NewSymbol("dispatch-fn"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Creates a new multimethod with the associated dispatch function.\n The docstring and attr-map are optional.\n\n Options are key-value pairs and may be one of:\n\n :default\n\n The default dispatch value, defaults to :default\n\n :hierarchy\n\n The value used for hierarchical dispatch (e.g. ::square is-a ::shape)\n\n Hierarchies are type-like relationships that do not depend upon type\n inheritance. By default Clojure's multimethods dispatch off of a\n global hierarchy map. However, a hierarchy relationship can be\n created with the derive function used to augment the root ancestor\n created with make-hierarchy.\n\n Multimethods expect the value of the hierarchy option to be supplied as\n a reference type e.g. a var (i.e. via the Var-quote dispatch macro #'\n or the var special form).", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1723), lang.NewKeyword("end-line"), int(1723))).(*lang.Symbol) + tmp0 := sym_defmulti.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym_docstring_QMARK_, sym_attr_DASH_map_QMARK_, sym_dispatch_DASH_fn, sym__AMP_, sym_options)), kw_doc, "Creates a new multimethod with the associated dispatch function.\n The docstring and attr-map are optional.\n\n Options are key-value pairs and may be one of:\n\n :default\n\n The default dispatch value, defaults to :default\n\n :hierarchy\n\n The value used for hierarchical dispatch (e.g. ::square is-a ::shape)\n\n Hierarchies are type-like relationships that do not depend upon type\n inheritance. By default Clojure's multimethods dispatch off of a\n global hierarchy map. However, a hierarchy relationship can be\n created with the derive function used to augment the root ancestor\n created with make-hierarchy.\n\n Multimethods expect the value of the hierarchy option to be supplied as\n a reference type e.g. a var (i.e. via the Var-quote dispatch macro #'\n or the var special form).", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(11), kw_line, int(1723), kw_end_DASH_line, int(1723))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -15313,12 +16117,12 @@ func LoadNS() { { // let // let binding "docstring" var tmp8 any - tmp9 := checkDerefVar(glojure_DOT_core_string_QMARK_) - tmp10 := checkDerefVar(glojure_DOT_core_first) + tmp9 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp10 := checkDerefVar(var_glojure_DOT_core_first) tmp11 := lang.Apply(tmp10, []any{v6}) tmp12 := lang.Apply(tmp9, []any{tmp11}) if lang.IsTruthy(tmp12) { - tmp13 := checkDerefVar(glojure_DOT_core_first) + tmp13 := checkDerefVar(var_glojure_DOT_core_first) tmp14 := lang.Apply(tmp13, []any{v6}) tmp8 = tmp14 } else { @@ -15327,12 +16131,12 @@ func LoadNS() { _ = v15 // let binding "options" var tmp16 any - tmp17 := checkDerefVar(glojure_DOT_core_string_QMARK_) - tmp18 := checkDerefVar(glojure_DOT_core_first) + tmp17 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp18 := checkDerefVar(var_glojure_DOT_core_first) tmp19 := lang.Apply(tmp18, []any{v6}) tmp20 := lang.Apply(tmp17, []any{tmp19}) if lang.IsTruthy(tmp20) { - tmp21 := checkDerefVar(glojure_DOT_core_next) + tmp21 := checkDerefVar(var_glojure_DOT_core_next) tmp22 := lang.Apply(tmp21, []any{v6}) tmp16 = tmp22 } else { @@ -15342,17 +16146,17 @@ func LoadNS() { _ = v23 // let binding "m" var tmp24 any - tmp25 := checkDerefVar(glojure_DOT_core_map_QMARK_) - tmp26 := checkDerefVar(glojure_DOT_core_first) + tmp25 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp26 := checkDerefVar(var_glojure_DOT_core_first) tmp27 := lang.Apply(tmp26, []any{v23}) tmp28 := lang.Apply(tmp25, []any{tmp27}) if lang.IsTruthy(tmp28) { - tmp29 := checkDerefVar(glojure_DOT_core_first) + tmp29 := checkDerefVar(var_glojure_DOT_core_first) tmp30 := lang.Apply(tmp29, []any{v23}) tmp24 = tmp30 } else { tmp31 := lang.NewMap() - tmp32 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1757), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(1757), lang.NewKeyword("end-column"), int(24)) + tmp32 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(1757), kw_column, int(23), kw_end_DASH_line, int(1757), kw_end_DASH_column, int(24)) tmp33, err := lang.WithMeta(tmp31, tmp32.(lang.IPersistentMap)) if err != nil { panic(err) @@ -15363,12 +16167,12 @@ func LoadNS() { _ = v34 // let binding "options" var tmp35 any - tmp36 := checkDerefVar(glojure_DOT_core_map_QMARK_) - tmp37 := checkDerefVar(glojure_DOT_core_first) + tmp36 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp37 := checkDerefVar(var_glojure_DOT_core_first) tmp38 := lang.Apply(tmp37, []any{v23}) tmp39 := lang.Apply(tmp36, []any{tmp38}) if lang.IsTruthy(tmp39) { - tmp40 := checkDerefVar(glojure_DOT_core_next) + tmp40 := checkDerefVar(var_glojure_DOT_core_next) tmp41 := lang.Apply(tmp40, []any{v23}) tmp35 = tmp41 } else { @@ -15377,20 +16181,20 @@ func LoadNS() { var v42 any = tmp35 _ = v42 // let binding "dispatch-fn" - tmp43 := checkDerefVar(glojure_DOT_core_first) + tmp43 := checkDerefVar(var_glojure_DOT_core_first) tmp44 := lang.Apply(tmp43, []any{v42}) var v45 any = tmp44 _ = v45 // let binding "options" - tmp46 := checkDerefVar(glojure_DOT_core_next) + tmp46 := checkDerefVar(var_glojure_DOT_core_next) tmp47 := lang.Apply(tmp46, []any{v42}) var v48 any = tmp47 _ = v48 // let binding "m" var tmp49 any if lang.IsTruthy(v15) { - tmp50 := checkDerefVar(glojure_DOT_core_assoc) - tmp51 := lang.Apply(tmp50, []any{v34, lang.NewKeyword("doc"), v15}) + tmp50 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp51 := lang.Apply(tmp50, []any{v34, kw_doc, v15}) tmp49 = tmp51 } else { tmp49 = v34 @@ -15399,11 +16203,11 @@ func LoadNS() { _ = v52 // let binding "m" var tmp53 any - tmp54 := checkDerefVar(glojure_DOT_core_meta) + tmp54 := checkDerefVar(var_glojure_DOT_core_meta) tmp55 := lang.Apply(tmp54, []any{v5}) if lang.IsTruthy(tmp55) { - tmp56 := checkDerefVar(glojure_DOT_core_conj) - tmp57 := checkDerefVar(glojure_DOT_core_meta) + tmp56 := checkDerefVar(var_glojure_DOT_core_conj) + tmp57 := checkDerefVar(var_glojure_DOT_core_meta) tmp58 := lang.Apply(tmp57, []any{v5}) tmp59 := lang.Apply(tmp56, []any{tmp58, v52}) tmp53 = tmp59 @@ -15413,13 +16217,13 @@ func LoadNS() { var v60 any = tmp53 _ = v60 // let binding "mm-name" - tmp61 := checkDerefVar(glojure_DOT_core_with_meta) + tmp61 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) tmp62 := lang.Apply(tmp61, []any{v5, v60}) var v63 any = tmp62 _ = v63 var tmp64 any - tmp65 := checkDerefVar(glojure_DOT_core__EQ_) - tmp66 := checkDerefVar(glojure_DOT_core_count) + tmp65 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp66 := checkDerefVar(var_glojure_DOT_core_count) tmp67 := lang.Apply(tmp66, []any{v48}) tmp68 := lang.Apply(tmp65, []any{tmp67, int64(1)}) if lang.IsTruthy(tmp68) { @@ -15431,42 +16235,42 @@ func LoadNS() { var tmp70 any { // let // let binding "options" - tmp71 := checkDerefVar(glojure_DOT_core_apply) - tmp72 := checkDerefVar(glojure_DOT_core_hash_map) + tmp71 := checkDerefVar(var_glojure_DOT_core_apply) + tmp72 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) tmp73 := lang.Apply(tmp71, []any{tmp72, v48}) var v74 any = tmp73 _ = v74 // let binding "default" - tmp75 := checkDerefVar(glojure_DOT_core_get) - tmp76 := lang.Apply(tmp75, []any{v74, lang.NewKeyword("default"), lang.NewKeyword("default")}) + tmp75 := checkDerefVar(var_glojure_DOT_core_get) + tmp76 := lang.Apply(tmp75, []any{v74, kw_default, kw_default}) var v77 any = tmp76 _ = v77 // let binding "hierarchy" - tmp78 := checkDerefVar(glojure_DOT_core_get) - tmp79 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("global-hierarchy")) - tmp80 := lang.Apply(tmp78, []any{v74, lang.NewKeyword("hierarchy"), tmp79}) + tmp78 := checkDerefVar(var_glojure_DOT_core_get) + tmp79 := lang.InternVarName(sym_glojure_DOT_core, sym_global_DASH_hierarchy) + tmp80 := lang.Apply(tmp78, []any{v74, kw_hierarchy, tmp79}) var v81 any = tmp80 _ = v81 - tmp82 := checkDerefVar(glojure_DOT_core_check_valid_options) - tmp83 := lang.Apply(tmp82, []any{v74, lang.NewKeyword("default"), lang.NewKeyword("hierarchy")}) + tmp82 := checkDerefVar(var_glojure_DOT_core_check_DASH_valid_DASH_options) + tmp83 := lang.Apply(tmp82, []any{v74, kw_default, kw_hierarchy}) _ = tmp83 - tmp84 := checkDerefVar(glojure_DOT_core_seq) - tmp85 := checkDerefVar(glojure_DOT_core_concat) - tmp86 := checkDerefVar(glojure_DOT_core_list) - tmp87 := lang.Apply(tmp86, []any{lang.NewSymbol("glojure.core/let")}) - tmp88 := checkDerefVar(glojure_DOT_core_list) - tmp89 := checkDerefVar(glojure_DOT_core_apply) - tmp90 := checkDerefVar(glojure_DOT_core_vector) - tmp91 := checkDerefVar(glojure_DOT_core_seq) - tmp92 := checkDerefVar(glojure_DOT_core_concat) - tmp93 := checkDerefVar(glojure_DOT_core_list) - tmp94 := lang.Apply(tmp93, []any{lang.NewSymbol("v__0__auto__")}) - tmp95 := checkDerefVar(glojure_DOT_core_list) - tmp96 := checkDerefVar(glojure_DOT_core_seq) - tmp97 := checkDerefVar(glojure_DOT_core_concat) - tmp98 := checkDerefVar(glojure_DOT_core_list) - tmp99 := lang.Apply(tmp98, []any{lang.NewSymbol("def")}) - tmp100 := checkDerefVar(glojure_DOT_core_list) + tmp84 := checkDerefVar(var_glojure_DOT_core_seq) + tmp85 := checkDerefVar(var_glojure_DOT_core_concat) + tmp86 := checkDerefVar(var_glojure_DOT_core_list) + tmp87 := lang.Apply(tmp86, []any{sym_glojure_DOT_core_SLASH_let}) + tmp88 := checkDerefVar(var_glojure_DOT_core_list) + tmp89 := checkDerefVar(var_glojure_DOT_core_apply) + tmp90 := checkDerefVar(var_glojure_DOT_core_vector) + tmp91 := checkDerefVar(var_glojure_DOT_core_seq) + tmp92 := checkDerefVar(var_glojure_DOT_core_concat) + tmp93 := checkDerefVar(var_glojure_DOT_core_list) + tmp94 := lang.Apply(tmp93, []any{sym_v__0__auto__}) + tmp95 := checkDerefVar(var_glojure_DOT_core_list) + tmp96 := checkDerefVar(var_glojure_DOT_core_seq) + tmp97 := checkDerefVar(var_glojure_DOT_core_concat) + tmp98 := checkDerefVar(var_glojure_DOT_core_list) + tmp99 := lang.Apply(tmp98, []any{sym_def}) + tmp100 := checkDerefVar(var_glojure_DOT_core_list) tmp101 := lang.Apply(tmp100, []any{v63}) tmp102 := lang.Apply(tmp97, []any{tmp99, tmp101}) tmp103 := lang.Apply(tmp96, []any{tmp102}) @@ -15475,40 +16279,40 @@ func LoadNS() { tmp106 := lang.Apply(tmp91, []any{tmp105}) tmp107 := lang.Apply(tmp89, []any{tmp90, tmp106}) tmp108 := lang.Apply(tmp88, []any{tmp107}) - tmp109 := checkDerefVar(glojure_DOT_core_list) - tmp110 := checkDerefVar(glojure_DOT_core_seq) - tmp111 := checkDerefVar(glojure_DOT_core_concat) - tmp112 := checkDerefVar(glojure_DOT_core_list) - tmp113 := lang.Apply(tmp112, []any{lang.NewSymbol("glojure.core/when-not")}) - tmp114 := checkDerefVar(glojure_DOT_core_list) - tmp115 := checkDerefVar(glojure_DOT_core_seq) - tmp116 := checkDerefVar(glojure_DOT_core_concat) - tmp117 := checkDerefVar(glojure_DOT_core_list) - tmp118 := lang.Apply(tmp117, []any{lang.NewSymbol("glojure.core/and")}) - tmp119 := checkDerefVar(glojure_DOT_core_list) - tmp120 := checkDerefVar(glojure_DOT_core_seq) - tmp121 := checkDerefVar(glojure_DOT_core_concat) - tmp122 := checkDerefVar(glojure_DOT_core_list) - tmp123 := lang.Apply(tmp122, []any{lang.NewSymbol(".HasRoot")}) - tmp124 := checkDerefVar(glojure_DOT_core_list) - tmp125 := lang.Apply(tmp124, []any{lang.NewSymbol("v__0__auto__")}) + tmp109 := checkDerefVar(var_glojure_DOT_core_list) + tmp110 := checkDerefVar(var_glojure_DOT_core_seq) + tmp111 := checkDerefVar(var_glojure_DOT_core_concat) + tmp112 := checkDerefVar(var_glojure_DOT_core_list) + tmp113 := lang.Apply(tmp112, []any{sym_glojure_DOT_core_SLASH_when_DASH_not}) + tmp114 := checkDerefVar(var_glojure_DOT_core_list) + tmp115 := checkDerefVar(var_glojure_DOT_core_seq) + tmp116 := checkDerefVar(var_glojure_DOT_core_concat) + tmp117 := checkDerefVar(var_glojure_DOT_core_list) + tmp118 := lang.Apply(tmp117, []any{sym_glojure_DOT_core_SLASH_and}) + tmp119 := checkDerefVar(var_glojure_DOT_core_list) + tmp120 := checkDerefVar(var_glojure_DOT_core_seq) + tmp121 := checkDerefVar(var_glojure_DOT_core_concat) + tmp122 := checkDerefVar(var_glojure_DOT_core_list) + tmp123 := lang.Apply(tmp122, []any{sym__DOT_HasRoot}) + tmp124 := checkDerefVar(var_glojure_DOT_core_list) + tmp125 := lang.Apply(tmp124, []any{sym_v__0__auto__}) tmp126 := lang.Apply(tmp121, []any{tmp123, tmp125}) tmp127 := lang.Apply(tmp120, []any{tmp126}) tmp128 := lang.Apply(tmp119, []any{tmp127}) - tmp129 := checkDerefVar(glojure_DOT_core_list) - tmp130 := checkDerefVar(glojure_DOT_core_seq) - tmp131 := checkDerefVar(glojure_DOT_core_concat) - tmp132 := checkDerefVar(glojure_DOT_core_list) - tmp133 := lang.Apply(tmp132, []any{lang.NewSymbol("glojure.core/instance?")}) - tmp134 := checkDerefVar(glojure_DOT_core_list) - tmp135 := lang.Apply(tmp134, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.*MultiFn")}) - tmp136 := checkDerefVar(glojure_DOT_core_list) - tmp137 := checkDerefVar(glojure_DOT_core_seq) - tmp138 := checkDerefVar(glojure_DOT_core_concat) - tmp139 := checkDerefVar(glojure_DOT_core_list) - tmp140 := lang.Apply(tmp139, []any{lang.NewSymbol("glojure.core/deref")}) - tmp141 := checkDerefVar(glojure_DOT_core_list) - tmp142 := lang.Apply(tmp141, []any{lang.NewSymbol("v__0__auto__")}) + tmp129 := checkDerefVar(var_glojure_DOT_core_list) + tmp130 := checkDerefVar(var_glojure_DOT_core_seq) + tmp131 := checkDerefVar(var_glojure_DOT_core_concat) + tmp132 := checkDerefVar(var_glojure_DOT_core_list) + tmp133 := lang.Apply(tmp132, []any{sym_glojure_DOT_core_SLASH_instance_QMARK_}) + tmp134 := checkDerefVar(var_glojure_DOT_core_list) + tmp135 := lang.Apply(tmp134, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT__STAR_MultiFn}) + tmp136 := checkDerefVar(var_glojure_DOT_core_list) + tmp137 := checkDerefVar(var_glojure_DOT_core_seq) + tmp138 := checkDerefVar(var_glojure_DOT_core_concat) + tmp139 := checkDerefVar(var_glojure_DOT_core_list) + tmp140 := lang.Apply(tmp139, []any{sym_glojure_DOT_core_SLASH_deref}) + tmp141 := checkDerefVar(var_glojure_DOT_core_list) + tmp142 := lang.Apply(tmp141, []any{sym_v__0__auto__}) tmp143 := lang.Apply(tmp138, []any{tmp140, tmp142}) tmp144 := lang.Apply(tmp137, []any{tmp143}) tmp145 := lang.Apply(tmp136, []any{tmp144}) @@ -15518,27 +16322,27 @@ func LoadNS() { tmp149 := lang.Apply(tmp116, []any{tmp118, tmp128, tmp148}) tmp150 := lang.Apply(tmp115, []any{tmp149}) tmp151 := lang.Apply(tmp114, []any{tmp150}) - tmp152 := checkDerefVar(glojure_DOT_core_list) - tmp153 := checkDerefVar(glojure_DOT_core_seq) - tmp154 := checkDerefVar(glojure_DOT_core_concat) - tmp155 := checkDerefVar(glojure_DOT_core_list) - tmp156 := lang.Apply(tmp155, []any{lang.NewSymbol("def")}) - tmp157 := checkDerefVar(glojure_DOT_core_list) + tmp152 := checkDerefVar(var_glojure_DOT_core_list) + tmp153 := checkDerefVar(var_glojure_DOT_core_seq) + tmp154 := checkDerefVar(var_glojure_DOT_core_concat) + tmp155 := checkDerefVar(var_glojure_DOT_core_list) + tmp156 := lang.Apply(tmp155, []any{sym_def}) + tmp157 := checkDerefVar(var_glojure_DOT_core_list) tmp158 := lang.Apply(tmp157, []any{v63}) - tmp159 := checkDerefVar(glojure_DOT_core_list) - tmp160 := checkDerefVar(glojure_DOT_core_seq) - tmp161 := checkDerefVar(glojure_DOT_core_concat) - tmp162 := checkDerefVar(glojure_DOT_core_list) - tmp163 := lang.Apply(tmp162, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewMultiFn")}) - tmp164 := checkDerefVar(glojure_DOT_core_list) - tmp165 := checkDerefVar(glojure_DOT_core_name) + tmp159 := checkDerefVar(var_glojure_DOT_core_list) + tmp160 := checkDerefVar(var_glojure_DOT_core_seq) + tmp161 := checkDerefVar(var_glojure_DOT_core_concat) + tmp162 := checkDerefVar(var_glojure_DOT_core_list) + tmp163 := lang.Apply(tmp162, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_NewMultiFn}) + tmp164 := checkDerefVar(var_glojure_DOT_core_list) + tmp165 := checkDerefVar(var_glojure_DOT_core_name) tmp166 := lang.Apply(tmp165, []any{v63}) tmp167 := lang.Apply(tmp164, []any{tmp166}) - tmp168 := checkDerefVar(glojure_DOT_core_list) + tmp168 := checkDerefVar(var_glojure_DOT_core_list) tmp169 := lang.Apply(tmp168, []any{v45}) - tmp170 := checkDerefVar(glojure_DOT_core_list) + tmp170 := checkDerefVar(var_glojure_DOT_core_list) tmp171 := lang.Apply(tmp170, []any{v77}) - tmp172 := checkDerefVar(glojure_DOT_core_list) + tmp172 := checkDerefVar(var_glojure_DOT_core_list) tmp173 := lang.Apply(tmp172, []any{v81}) tmp174 := lang.Apply(tmp161, []any{tmp163, tmp167, tmp169, tmp171, tmp173}) tmp175 := lang.Apply(tmp160, []any{tmp174}) @@ -15558,7 +16362,7 @@ func LoadNS() { return tmp7 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -15566,16 +16370,14 @@ func LoadNS() { } // defn { - tmp0 := lang.NewSymbol("defn").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("doc-string?"), lang.NewSymbol("attr-map?"), lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("prepost-map?"), lang.NewSymbol("body")), lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("doc-string?"), lang.NewSymbol("attr-map?"), lang.NewList(lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("prepost-map?"), lang.NewSymbol("body")), lang.NewSymbol("+"), lang.NewSymbol("attr-map?"))), lang.NewKeyword("doc"), "Same as (def name (fn [params* ] exprs*)) or (def\n name (fn ([params* ] exprs*)+)) with any doc-string or attrs added\n to the var metadata. prepost-map defines a map with optional keys\n :pre and :post that contain collections of pre or post conditions.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(284), lang.NewKeyword("end-line"), int(291))).(*lang.Symbol) + tmp0 := sym_defn.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym_doc_DASH_string_QMARK_, sym_attr_DASH_map_QMARK_, lang.NewVector(sym_params_STAR_), sym_prepost_DASH_map_QMARK_, sym_body), lang.NewVector(sym_name, sym_doc_DASH_string_QMARK_, sym_attr_DASH_map_QMARK_, lang.NewList(lang.NewVector(sym_params_STAR_), sym_prepost_DASH_map_QMARK_, sym_body), sym__PLUS_, sym_attr_DASH_map_QMARK_)), kw_doc, "Same as (def name (fn [params* ] exprs*)) or (def\n name (fn ([params* ] exprs*)+)) with any doc-string or attrs added\n to the var metadata. prepost-map defines a map with optional keys\n :pre and :post that contain collections of pre or post conditions.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(5), kw_column, int(2), kw_line, int(284), kw_end_DASH_line, int(291))).(*lang.Symbol) var tmp2 lang.FnFunc { // function defn var v3 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v4 := args[0] _ = v4 v5 := args[1] @@ -15585,7 +16387,7 @@ func LoadNS() { var v7 any = lang.NewList(args[3:]...) _ = v7 var tmp8 any - tmp9 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp9 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp10 := reflect.TypeOf((*lang.Symbol)(nil)) tmp11 := lang.Apply(tmp9, []any{tmp10, v6}) if lang.IsTruthy(tmp11) { @@ -15598,15 +16400,15 @@ func LoadNS() { { // let // let binding "m" var tmp14 any - tmp15 := checkDerefVar(glojure_DOT_core_string_QMARK_) - tmp16 := checkDerefVar(glojure_DOT_core_first) + tmp15 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp16 := checkDerefVar(var_glojure_DOT_core_first) tmp17 := lang.Apply(tmp16, []any{v7}) tmp18 := lang.Apply(tmp15, []any{tmp17}) if lang.IsTruthy(tmp18) { - tmp19 := checkDerefVar(glojure_DOT_core_first) + tmp19 := checkDerefVar(var_glojure_DOT_core_first) tmp20 := lang.Apply(tmp19, []any{v7}) - tmp21 := lang.NewMap(lang.NewKeyword("doc"), tmp20) - tmp22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(297), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(297), lang.NewKeyword("end-column"), int(38)) + tmp21 := lang.NewMap(kw_doc, tmp20) + tmp22 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(297), kw_column, int(19), kw_end_DASH_line, int(297), kw_end_DASH_column, int(38)) tmp23, err := lang.WithMeta(tmp21, tmp22.(lang.IPersistentMap)) if err != nil { panic(err) @@ -15614,7 +16416,7 @@ func LoadNS() { tmp14 = tmp23 } else { tmp24 := lang.NewMap() - tmp25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(298), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(298), lang.NewKeyword("end-column"), int(20)) + tmp25 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(298), kw_column, int(19), kw_end_DASH_line, int(298), kw_end_DASH_column, int(20)) tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) if err != nil { panic(err) @@ -15625,12 +16427,12 @@ func LoadNS() { _ = v27 // let binding "fdecl" var tmp28 any - tmp29 := checkDerefVar(glojure_DOT_core_string_QMARK_) - tmp30 := checkDerefVar(glojure_DOT_core_first) + tmp29 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp30 := checkDerefVar(var_glojure_DOT_core_first) tmp31 := lang.Apply(tmp30, []any{v7}) tmp32 := lang.Apply(tmp29, []any{tmp31}) if lang.IsTruthy(tmp32) { - tmp33 := checkDerefVar(glojure_DOT_core_next) + tmp33 := checkDerefVar(var_glojure_DOT_core_next) tmp34 := lang.Apply(tmp33, []any{v7}) tmp28 = tmp34 } else { @@ -15640,13 +16442,13 @@ func LoadNS() { _ = v35 // let binding "m" var tmp36 any - tmp37 := checkDerefVar(glojure_DOT_core_map_QMARK_) - tmp38 := checkDerefVar(glojure_DOT_core_first) + tmp37 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp38 := checkDerefVar(var_glojure_DOT_core_first) tmp39 := lang.Apply(tmp38, []any{v35}) tmp40 := lang.Apply(tmp37, []any{tmp39}) if lang.IsTruthy(tmp40) { - tmp41 := checkDerefVar(glojure_DOT_core_conj) - tmp42 := checkDerefVar(glojure_DOT_core_first) + tmp41 := checkDerefVar(var_glojure_DOT_core_conj) + tmp42 := checkDerefVar(var_glojure_DOT_core_first) tmp43 := lang.Apply(tmp42, []any{v35}) tmp44 := lang.Apply(tmp41, []any{v27, tmp43}) tmp36 = tmp44 @@ -15657,12 +16459,12 @@ func LoadNS() { _ = v45 // let binding "fdecl" var tmp46 any - tmp47 := checkDerefVar(glojure_DOT_core_map_QMARK_) - tmp48 := checkDerefVar(glojure_DOT_core_first) + tmp47 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp48 := checkDerefVar(var_glojure_DOT_core_first) tmp49 := lang.Apply(tmp48, []any{v35}) tmp50 := lang.Apply(tmp47, []any{tmp49}) if lang.IsTruthy(tmp50) { - tmp51 := checkDerefVar(glojure_DOT_core_next) + tmp51 := checkDerefVar(var_glojure_DOT_core_next) tmp52 := lang.Apply(tmp51, []any{v35}) tmp46 = tmp52 } else { @@ -15672,12 +16474,12 @@ func LoadNS() { _ = v53 // let binding "fdecl" var tmp54 any - tmp55 := checkDerefVar(glojure_DOT_core_vector_QMARK_) - tmp56 := checkDerefVar(glojure_DOT_core_first) + tmp55 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp56 := checkDerefVar(var_glojure_DOT_core_first) tmp57 := lang.Apply(tmp56, []any{v53}) tmp58 := lang.Apply(tmp55, []any{tmp57}) if lang.IsTruthy(tmp58) { - tmp59 := checkDerefVar(glojure_DOT_core_list) + tmp59 := checkDerefVar(var_glojure_DOT_core_list) tmp60 := lang.Apply(tmp59, []any{v53}) tmp54 = tmp60 } else { @@ -15687,13 +16489,13 @@ func LoadNS() { _ = v61 // let binding "m" var tmp62 any - tmp63 := checkDerefVar(glojure_DOT_core_map_QMARK_) - tmp64 := checkDerefVar(glojure_DOT_core_last) + tmp63 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp64 := checkDerefVar(var_glojure_DOT_core_last) tmp65 := lang.Apply(tmp64, []any{v61}) tmp66 := lang.Apply(tmp63, []any{tmp65}) if lang.IsTruthy(tmp66) { - tmp67 := checkDerefVar(glojure_DOT_core_conj) - tmp68 := checkDerefVar(glojure_DOT_core_last) + tmp67 := checkDerefVar(var_glojure_DOT_core_conj) + tmp68 := checkDerefVar(var_glojure_DOT_core_last) tmp69 := lang.Apply(tmp68, []any{v61}) tmp70 := lang.Apply(tmp67, []any{v45, tmp69}) tmp62 = tmp70 @@ -15704,12 +16506,12 @@ func LoadNS() { _ = v71 // let binding "fdecl" var tmp72 any - tmp73 := checkDerefVar(glojure_DOT_core_map_QMARK_) - tmp74 := checkDerefVar(glojure_DOT_core_last) + tmp73 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp74 := checkDerefVar(var_glojure_DOT_core_last) tmp75 := lang.Apply(tmp74, []any{v61}) tmp76 := lang.Apply(tmp73, []any{tmp75}) if lang.IsTruthy(tmp76) { - tmp77 := checkDerefVar(glojure_DOT_core_butlast) + tmp77 := checkDerefVar(var_glojure_DOT_core_butlast) tmp78 := lang.Apply(tmp77, []any{v61}) tmp72 = tmp78 } else { @@ -15718,13 +16520,13 @@ func LoadNS() { var v79 any = tmp72 _ = v79 // let binding "m" - tmp80 := checkDerefVar(glojure_DOT_core_conj) - tmp81 := checkDerefVar(glojure_DOT_core_list) - tmp82 := checkDerefVar(glojure_DOT_core_sigs) + tmp80 := checkDerefVar(var_glojure_DOT_core_conj) + tmp81 := checkDerefVar(var_glojure_DOT_core_list) + tmp82 := checkDerefVar(var_glojure_DOT_core_sigs) tmp83 := lang.Apply(tmp82, []any{v79}) - tmp84 := lang.Apply(tmp81, []any{lang.NewSymbol("quote"), tmp83}) - tmp85 := lang.NewMap(lang.NewKeyword("arglists"), tmp84) - tmp86 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(317), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(317), lang.NewKeyword("end-column"), int(60)) + tmp84 := lang.Apply(tmp81, []any{sym_quote, tmp83}) + tmp85 := lang.NewMap(kw_arglists, tmp84) + tmp86 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(317), kw_column, int(23), kw_end_DASH_line, int(317), kw_end_DASH_column, int(60)) tmp87, err := lang.WithMeta(tmp85, tmp86.(lang.IPersistentMap)) if err != nil { panic(err) @@ -15736,25 +16538,25 @@ func LoadNS() { var tmp90 any { // let // let binding "inline" - tmp91 := lang.Apply(lang.NewKeyword("inline"), []any{v89}) + tmp91 := lang.Apply(kw_inline, []any{v89}) var v92 any = tmp91 _ = v92 // let binding "ifn" - tmp93 := checkDerefVar(glojure_DOT_core_first) + tmp93 := checkDerefVar(var_glojure_DOT_core_first) tmp94 := lang.Apply(tmp93, []any{v92}) var v95 any = tmp94 _ = v95 // let binding "iname" - tmp96 := checkDerefVar(glojure_DOT_core_second) + tmp96 := checkDerefVar(var_glojure_DOT_core_second) tmp97 := lang.Apply(tmp96, []any{v92}) var v98 any = tmp97 _ = v98 var tmp99 any var tmp100 any - tmp101 := lang.Apply(lang.Equiv, []any{lang.NewSymbol("fn"), v95}) + tmp101 := lang.Apply(lang.Equiv, []any{sym_fn, v95}) if lang.IsTruthy(tmp101) { var tmp102 any - tmp103 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp103 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp104 := reflect.TypeOf((*lang.Symbol)(nil)) tmp105 := lang.Apply(tmp103, []any{tmp104, v98}) if lang.IsTruthy(tmp105) { @@ -15766,9 +16568,9 @@ func LoadNS() { } else { } if lang.IsTruthy(tmp100) { - tmp106 := checkDerefVar(glojure_DOT_core_assoc) - tmp107 := checkDerefVar(glojure_DOT_core_cons) - tmp108 := checkDerefVar(glojure_DOT_core_cons) + tmp106 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp107 := checkDerefVar(var_glojure_DOT_core_cons) + tmp108 := checkDerefVar(var_glojure_DOT_core_cons) tmp109, ok := lang.FieldOrMethod(v6, "Name") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "Name"))) @@ -15782,11 +16584,11 @@ func LoadNS() { } tmp111 := lang.Apply(lang.ConcatStrings, []any{tmp110, "__inliner"}) tmp112 := lang.Apply(lang.NewSymbol, []any{tmp111}) - tmp113 := checkDerefVar(glojure_DOT_core_next) + tmp113 := checkDerefVar(var_glojure_DOT_core_next) tmp114 := lang.Apply(tmp113, []any{v92}) tmp115 := lang.Apply(tmp108, []any{tmp112, tmp114}) tmp116 := lang.Apply(tmp107, []any{v95, tmp115}) - tmp117 := lang.Apply(tmp106, []any{v89, lang.NewKeyword("inline"), tmp116}) + tmp117 := lang.Apply(tmp106, []any{v89, kw_inline, tmp116}) tmp99 = tmp117 } else { tmp99 = v89 @@ -15796,17 +16598,17 @@ func LoadNS() { var v91 any = tmp90 _ = v91 // let binding "m" - tmp92 := checkDerefVar(glojure_DOT_core_conj) + tmp92 := checkDerefVar(var_glojure_DOT_core_conj) var tmp93 any - tmp94 := checkDerefVar(glojure_DOT_core_meta) + tmp94 := checkDerefVar(var_glojure_DOT_core_meta) tmp95 := lang.Apply(tmp94, []any{v6}) if lang.IsTruthy(tmp95) { - tmp96 := checkDerefVar(glojure_DOT_core_meta) + tmp96 := checkDerefVar(var_glojure_DOT_core_meta) tmp97 := lang.Apply(tmp96, []any{v6}) tmp93 = tmp97 } else { tmp98 := lang.NewMap() - tmp99 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(328), lang.NewKeyword("column"), int(51), lang.NewKeyword("end-line"), int(328), lang.NewKeyword("end-column"), int(52)) + tmp99 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(328), kw_column, int(51), kw_end_DASH_line, int(328), kw_end_DASH_column, int(52)) tmp100, err := lang.WithMeta(tmp98, tmp99.(lang.IPersistentMap)) if err != nil { panic(err) @@ -15816,27 +16618,27 @@ func LoadNS() { tmp101 := lang.Apply(tmp92, []any{tmp93, v91}) var v102 any = tmp101 _ = v102 - tmp103 := checkDerefVar(glojure_DOT_core_list) - tmp104 := checkDerefVar(glojure_DOT_core_with_meta) + tmp103 := checkDerefVar(var_glojure_DOT_core_list) + tmp104 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) tmp105 := lang.Apply(tmp104, []any{v6, v102}) - tmp106 := checkDerefVar(glojure_DOT_core_with_meta) - tmp107 := checkDerefVar(glojure_DOT_core_cons) - tmp108 := lang.Apply(tmp107, []any{lang.NewSymbol("glojure.core/fn"), v79}) - tmp109 := lang.Apply(lang.NewKeyword("tag"), []any{v102}) - tmp110 := lang.NewMap(lang.NewKeyword("rettag"), tmp109) - tmp111 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(333), lang.NewKeyword("column"), int(37), lang.NewKeyword("end-line"), int(333), lang.NewKeyword("end-column"), int(54)) + tmp106 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp107 := checkDerefVar(var_glojure_DOT_core_cons) + tmp108 := lang.Apply(tmp107, []any{sym_glojure_DOT_core_SLASH_fn, v79}) + tmp109 := lang.Apply(kw_tag, []any{v102}) + tmp110 := lang.NewMap(kw_rettag, tmp109) + tmp111 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(333), kw_column, int(37), kw_end_DASH_line, int(333), kw_end_DASH_column, int(54)) tmp112, err := lang.WithMeta(tmp110, tmp111.(lang.IPersistentMap)) if err != nil { panic(err) } tmp113 := lang.Apply(tmp106, []any{tmp108, tmp112}) - tmp114 := lang.Apply(tmp103, []any{lang.NewSymbol("def"), tmp105, tmp113}) + tmp114 := lang.Apply(tmp103, []any{sym_def, tmp105, tmp113}) tmp13 = tmp114 } // end let return tmp13 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(291), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(333), lang.NewKeyword("end-column"), int(58))).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(291), kw_column, int(7), kw_end_DASH_line, int(333), kw_end_DASH_column, int(58))).(lang.FnFunc) v3 = tmp2 _ = v3 } @@ -15847,14 +16649,12 @@ func LoadNS() { } // defn- { - tmp0 := lang.NewSymbol("defn-").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("decls"))), lang.NewKeyword("doc"), "same as defn, yielding non-public def", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4949), lang.NewKeyword("end-line"), int(4949))).(*lang.Symbol) + tmp0 := sym_defn_DASH_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym__AMP_, sym_decls)), kw_doc, "same as defn, yielding non-public def", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(11), kw_line, int(4949), kw_end_DASH_line, int(4949))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -15863,18 +16663,18 @@ func LoadNS() { _ = v5 var v6 any = lang.NewList(args[3:]...) _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_list_STAR_) - tmp8 := checkDerefVar(glojure_DOT_core_with_meta) - tmp9 := checkDerefVar(glojure_DOT_core_assoc) - tmp10 := checkDerefVar(glojure_DOT_core_meta) + tmp7 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp8 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp9 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp10 := checkDerefVar(var_glojure_DOT_core_meta) tmp11 := lang.Apply(tmp10, []any{v5}) - tmp12 := lang.Apply(tmp9, []any{tmp11, lang.NewKeyword("private"), true}) + tmp12 := lang.Apply(tmp9, []any{tmp11, kw_private, true}) tmp13 := lang.Apply(tmp8, []any{v5, tmp12}) - tmp14 := lang.Apply(tmp7, []any{lang.NewSymbol("glojure.core/defn"), tmp13, v6}) + tmp14 := lang.Apply(tmp7, []any{sym_glojure_DOT_core_SLASH_defn, tmp13, v6}) return tmp14 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -15882,12 +16682,10 @@ func LoadNS() { } // defonce { - tmp0 := lang.NewSymbol("defonce").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("expr"))), lang.NewKeyword("doc"), "defs name to have the root value of the expr iff the named var has no root value,\n else expr is unevaluated", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5806), lang.NewKeyword("end-line"), int(5806))).(*lang.Symbol) + tmp0 := sym_defonce.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym_expr)), kw_doc, "defs name to have the root value of the expr iff the named var has no root value,\n else expr is unevaluated", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(5806), kw_end_DASH_line, int(5806))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 4) v3 := args[0] _ = v3 v4 := args[1] @@ -15896,23 +16694,23 @@ func LoadNS() { _ = v5 v6 := args[3] _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_seq) - tmp8 := checkDerefVar(glojure_DOT_core_concat) - tmp9 := checkDerefVar(glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("glojure.core/let")}) - tmp11 := checkDerefVar(glojure_DOT_core_list) - tmp12 := checkDerefVar(glojure_DOT_core_apply) - tmp13 := checkDerefVar(glojure_DOT_core_vector) - tmp14 := checkDerefVar(glojure_DOT_core_seq) - tmp15 := checkDerefVar(glojure_DOT_core_concat) - tmp16 := checkDerefVar(glojure_DOT_core_list) - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("v__0__auto__")}) - tmp18 := checkDerefVar(glojure_DOT_core_list) - tmp19 := checkDerefVar(glojure_DOT_core_seq) - tmp20 := checkDerefVar(glojure_DOT_core_concat) - tmp21 := checkDerefVar(glojure_DOT_core_list) - tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("def")}) - tmp23 := checkDerefVar(glojure_DOT_core_list) + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_core_SLASH_let}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_apply) + tmp13 := checkDerefVar(var_glojure_DOT_core_vector) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{sym_v__0__auto__}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := checkDerefVar(var_glojure_DOT_core_seq) + tmp20 := checkDerefVar(var_glojure_DOT_core_concat) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{sym_def}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) tmp24 := lang.Apply(tmp23, []any{v5}) tmp25 := lang.Apply(tmp20, []any{tmp22, tmp24}) tmp26 := lang.Apply(tmp19, []any{tmp25}) @@ -15921,29 +16719,29 @@ func LoadNS() { tmp29 := lang.Apply(tmp14, []any{tmp28}) tmp30 := lang.Apply(tmp12, []any{tmp13, tmp29}) tmp31 := lang.Apply(tmp11, []any{tmp30}) - tmp32 := checkDerefVar(glojure_DOT_core_list) - tmp33 := checkDerefVar(glojure_DOT_core_seq) - tmp34 := checkDerefVar(glojure_DOT_core_concat) - tmp35 := checkDerefVar(glojure_DOT_core_list) - tmp36 := lang.Apply(tmp35, []any{lang.NewSymbol("glojure.core/when-not")}) - tmp37 := checkDerefVar(glojure_DOT_core_list) - tmp38 := checkDerefVar(glojure_DOT_core_seq) - tmp39 := checkDerefVar(glojure_DOT_core_concat) - tmp40 := checkDerefVar(glojure_DOT_core_list) - tmp41 := lang.Apply(tmp40, []any{lang.NewSymbol(".HasRoot")}) - tmp42 := checkDerefVar(glojure_DOT_core_list) - tmp43 := lang.Apply(tmp42, []any{lang.NewSymbol("v__0__auto__")}) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := checkDerefVar(var_glojure_DOT_core_seq) + tmp34 := checkDerefVar(var_glojure_DOT_core_concat) + tmp35 := checkDerefVar(var_glojure_DOT_core_list) + tmp36 := lang.Apply(tmp35, []any{sym_glojure_DOT_core_SLASH_when_DASH_not}) + tmp37 := checkDerefVar(var_glojure_DOT_core_list) + tmp38 := checkDerefVar(var_glojure_DOT_core_seq) + tmp39 := checkDerefVar(var_glojure_DOT_core_concat) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{sym__DOT_HasRoot}) + tmp42 := checkDerefVar(var_glojure_DOT_core_list) + tmp43 := lang.Apply(tmp42, []any{sym_v__0__auto__}) tmp44 := lang.Apply(tmp39, []any{tmp41, tmp43}) tmp45 := lang.Apply(tmp38, []any{tmp44}) tmp46 := lang.Apply(tmp37, []any{tmp45}) - tmp47 := checkDerefVar(glojure_DOT_core_list) - tmp48 := checkDerefVar(glojure_DOT_core_seq) - tmp49 := checkDerefVar(glojure_DOT_core_concat) - tmp50 := checkDerefVar(glojure_DOT_core_list) - tmp51 := lang.Apply(tmp50, []any{lang.NewSymbol("def")}) - tmp52 := checkDerefVar(glojure_DOT_core_list) + tmp47 := checkDerefVar(var_glojure_DOT_core_list) + tmp48 := checkDerefVar(var_glojure_DOT_core_seq) + tmp49 := checkDerefVar(var_glojure_DOT_core_concat) + tmp50 := checkDerefVar(var_glojure_DOT_core_list) + tmp51 := lang.Apply(tmp50, []any{sym_def}) + tmp52 := checkDerefVar(var_glojure_DOT_core_list) tmp53 := lang.Apply(tmp52, []any{v5}) - tmp54 := checkDerefVar(glojure_DOT_core_list) + tmp54 := checkDerefVar(var_glojure_DOT_core_list) tmp55 := lang.Apply(tmp54, []any{v6}) tmp56 := lang.Apply(tmp49, []any{tmp51, tmp53, tmp55}) tmp57 := lang.Apply(tmp48, []any{tmp56}) @@ -15955,7 +16753,7 @@ func LoadNS() { tmp63 := lang.Apply(tmp7, []any{tmp62}) return tmp63 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -15963,14 +16761,12 @@ func LoadNS() { } // defprotocol { - tmp0 := lang.NewSymbol("defprotocol").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("opts+sigs"))), lang.NewKeyword("doc"), "A protocol is a named set of named methods and their signatures:\n (defprotocol AProtocolName\n\n ;optional doc string\n \"A doc string for AProtocol abstraction\"\n\n ;options\n :extend-via-metadata true\n\n ;method signatures\n (bar [this a b] \"bar docs\")\n (baz [this a] [this a b] [this a b c] \"baz docs\"))\n\n No implementations are provided. Docs can be specified for the\n protocol overall and for each method. The above yields a set of\n polymorphic functions and a protocol object. All are\n namespace-qualified by the ns enclosing the definition The resulting\n functions dispatch on the type of their first argument, which is\n required and corresponds to the implicit target object ('this' in \n Java parlance). defprotocol is dynamic, has no special compile-time \n effect, and defines no new types or classes. Implementations of \n the protocol methods can be provided using extend.\n\n When :extend-via-metadata is true, values can extend protocols by\n adding metadata where keys are fully-qualified protocol function\n symbols and values are function implementations. Protocol\n implementations are checked first for direct definitions (defrecord,\n deftype, reify), then metadata definitions, then external\n extensions (extend, extend-type, extend-protocol)\n\n defprotocol will automatically generate a corresponding interface,\n with the same name as the protocol, i.e. given a protocol:\n my.ns/Protocol, an interface: my.ns.Protocol. The interface will\n have methods corresponding to the protocol functions, and the\n protocol will automatically work with instances of the interface.\n\n Note that you should not use this interface with deftype or\n reify, as they support the protocol directly:\n\n (defprotocol P \n (foo [this]) \n (bar-me [this] [this y]))\n\n (deftype Foo [a b c] \n P\n (foo [this] a)\n (bar-me [this] b)\n (bar-me [this y] (+ c y)))\n \n (bar-me (Foo. 1 2 3) 42)\n => 45\n\n (foo \n (let [x 42]\n (reify P \n (foo [this] 17)\n (bar-me [this] x)\n (bar-me [this y] x))))\n => 17", lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(28), lang.NewKeyword("end-line"), int(28))).(*lang.Symbol) + tmp0 := sym_defprotocol.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym__AMP_, sym_opts_PLUS_sigs)), kw_doc, "A protocol is a named set of named methods and their signatures:\n (defprotocol AProtocolName\n\n ;optional doc string\n \"A doc string for AProtocol abstraction\"\n\n ;options\n :extend-via-metadata true\n\n ;method signatures\n (bar [this a b] \"bar docs\")\n (baz [this a] [this a b] [this a b c] \"baz docs\"))\n\n No implementations are provided. Docs can be specified for the\n protocol overall and for each method. The above yields a set of\n polymorphic functions and a protocol object. All are\n namespace-qualified by the ns enclosing the definition The resulting\n functions dispatch on the type of their first argument, which is\n required and corresponds to the implicit target object ('this' in \n Java parlance). defprotocol is dynamic, has no special compile-time \n effect, and defines no new types or classes. Implementations of \n the protocol methods can be provided using extend.\n\n When :extend-via-metadata is true, values can extend protocols by\n adding metadata where keys are fully-qualified protocol function\n symbols and values are function implementations. Protocol\n implementations are checked first for direct definitions (defrecord,\n deftype, reify), then metadata definitions, then external\n extensions (extend, extend-type, extend-protocol)\n\n defprotocol will automatically generate a corresponding interface,\n with the same name as the protocol, i.e. given a protocol:\n my.ns/Protocol, an interface: my.ns.Protocol. The interface will\n have methods corresponding to the protocol functions, and the\n protocol will automatically work with instances of the interface.\n\n Note that you should not use this interface with deftype or\n reify, as they support the protocol directly:\n\n (defprotocol P \n (foo [this]) \n (bar-me [this] [this y]))\n\n (deftype Foo [a b c] \n P\n (foo [this] a)\n (bar-me [this] b)\n (bar-me [this y] (+ c y)))\n \n (bar-me (Foo. 1 2 3) 42)\n => 45\n\n (foo \n (let [x 42]\n (reify P \n (foo [this] 17)\n (bar-me [this] x)\n (bar-me [this y] x))))\n => 17", kw_file, "glojure/core_deftype.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(11), kw_line, int(28), kw_end_DASH_line, int(28))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -15983,12 +16779,12 @@ func LoadNS() { { // let // let binding "doc" var tmp8 any - tmp9 := checkDerefVar(glojure_DOT_core_string_QMARK_) - tmp10 := checkDerefVar(glojure_DOT_core_first) + tmp9 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp10 := checkDerefVar(var_glojure_DOT_core_first) tmp11 := lang.Apply(tmp10, []any{v6}) tmp12 := lang.Apply(tmp9, []any{tmp11}) if lang.IsTruthy(tmp12) { - tmp13 := checkDerefVar(glojure_DOT_core_first) + tmp13 := checkDerefVar(var_glojure_DOT_core_first) tmp14 := lang.Apply(tmp13, []any{v6}) tmp8 = tmp14 } else { @@ -15998,7 +16794,7 @@ func LoadNS() { // let binding "opts+sigs" var tmp16 any if lang.IsTruthy(v15) { - tmp17 := checkDerefVar(glojure_DOT_core_rest) + tmp17 := checkDerefVar(var_glojure_DOT_core_rest) tmp18 := lang.Apply(tmp17, []any{v6}) tmp16 = tmp18 } else { @@ -16007,21 +16803,19 @@ func LoadNS() { var v19 any = tmp16 _ = v19 // let binding "opts" - tmp20 := checkDerefVar(glojure_DOT_core_take_while) + tmp20 := checkDerefVar(var_glojure_DOT_core_take_DASH_while) var tmp21 lang.FnFunc tmp21 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v22 := args[0] _ = v22 - tmp23 := checkDerefVar(glojure_DOT_core_not) - tmp24 := checkDerefVar(glojure_DOT_core_seq_QMARK_) + tmp23 := checkDerefVar(var_glojure_DOT_core_not) + tmp24 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) tmp25 := lang.Apply(tmp24, []any{v22}) tmp26 := lang.Apply(tmp23, []any{tmp25}) return tmp26 }) - tmp22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(92), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(92), lang.NewKeyword("end-column"), int(40)) + tmp22 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(92), kw_column, int(26), kw_end_DASH_line, int(92), kw_end_DASH_column, int(40)) tmp23, err := lang.WithMeta(tmp21, tmp22.(lang.IPersistentMap)) if err != nil { panic(err) @@ -16030,21 +16824,19 @@ func LoadNS() { var v25 any = tmp24 _ = v25 // let binding "sigs" - tmp26 := checkDerefVar(glojure_DOT_core_drop_while) + tmp26 := checkDerefVar(var_glojure_DOT_core_drop_DASH_while) var tmp27 lang.FnFunc tmp27 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v28 := args[0] _ = v28 - tmp29 := checkDerefVar(glojure_DOT_core_not) - tmp30 := checkDerefVar(glojure_DOT_core_seq_QMARK_) + tmp29 := checkDerefVar(var_glojure_DOT_core_not) + tmp30 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) tmp31 := lang.Apply(tmp30, []any{v28}) tmp32 := lang.Apply(tmp29, []any{tmp31}) return tmp32 }) - tmp28 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(93), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(93), lang.NewKeyword("end-column"), int(40)) + tmp28 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(93), kw_column, int(26), kw_end_DASH_line, int(93), kw_end_DASH_column, int(40)) tmp29, err := lang.WithMeta(tmp27, tmp28.(lang.IPersistentMap)) if err != nil { panic(err) @@ -16054,7 +16846,7 @@ func LoadNS() { _ = v31 // let binding "opts" var tmp32 any - tmp33 := checkDerefVar(glojure_DOT_core__EQ_) + tmp33 := checkDerefVar(var_glojure_DOT_core__EQ_) tmp34 := lang.Apply(tmp33, []any{v31, v25}) if lang.IsTruthy(tmp34) { } else { @@ -16062,50 +16854,50 @@ func LoadNS() { } var v35 any = tmp32 _ = v35 - tmp36 := checkDerefVar(glojure_DOT_core_seq) - tmp37 := checkDerefVar(glojure_DOT_core_concat) - tmp38 := checkDerefVar(glojure_DOT_core_list) - tmp39 := lang.Apply(tmp38, []any{lang.NewSymbol("do")}) - tmp40 := checkDerefVar(glojure_DOT_core_list) - tmp41 := checkDerefVar(glojure_DOT_core_seq) - tmp42 := checkDerefVar(glojure_DOT_core_concat) - tmp43 := checkDerefVar(glojure_DOT_core_list) - tmp44 := lang.Apply(tmp43, []any{lang.NewSymbol("def")}) - tmp45 := checkDerefVar(glojure_DOT_core_list) + tmp36 := checkDerefVar(var_glojure_DOT_core_seq) + tmp37 := checkDerefVar(var_glojure_DOT_core_concat) + tmp38 := checkDerefVar(var_glojure_DOT_core_list) + tmp39 := lang.Apply(tmp38, []any{sym_do}) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := checkDerefVar(var_glojure_DOT_core_seq) + tmp42 := checkDerefVar(var_glojure_DOT_core_concat) + tmp43 := checkDerefVar(var_glojure_DOT_core_list) + tmp44 := lang.Apply(tmp43, []any{sym_def}) + tmp45 := checkDerefVar(var_glojure_DOT_core_list) tmp46 := lang.Apply(tmp45, []any{v5}) - tmp47 := checkDerefVar(glojure_DOT_core_list) - tmp48 := checkDerefVar(glojure_DOT_core_seq) - tmp49 := checkDerefVar(glojure_DOT_core_concat) - tmp50 := checkDerefVar(glojure_DOT_core_list) - tmp51 := lang.Apply(tmp50, []any{lang.NewSymbol("glojure.core/atom")}) - tmp52 := checkDerefVar(glojure_DOT_core_list) - tmp53 := checkDerefVar(glojure_DOT_core_apply) - tmp54 := checkDerefVar(glojure_DOT_core_hash_map) - tmp55 := checkDerefVar(glojure_DOT_core_seq) - tmp56 := checkDerefVar(glojure_DOT_core_concat) - tmp57 := checkDerefVar(glojure_DOT_core_list) - tmp58 := lang.Apply(tmp57, []any{lang.NewKeyword("on-interface")}) - tmp59 := checkDerefVar(glojure_DOT_core_list) + tmp47 := checkDerefVar(var_glojure_DOT_core_list) + tmp48 := checkDerefVar(var_glojure_DOT_core_seq) + tmp49 := checkDerefVar(var_glojure_DOT_core_concat) + tmp50 := checkDerefVar(var_glojure_DOT_core_list) + tmp51 := lang.Apply(tmp50, []any{sym_glojure_DOT_core_SLASH_atom}) + tmp52 := checkDerefVar(var_glojure_DOT_core_list) + tmp53 := checkDerefVar(var_glojure_DOT_core_apply) + tmp54 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp55 := checkDerefVar(var_glojure_DOT_core_seq) + tmp56 := checkDerefVar(var_glojure_DOT_core_concat) + tmp57 := checkDerefVar(var_glojure_DOT_core_list) + tmp58 := lang.Apply(tmp57, []any{kw_on_DASH_interface}) + tmp59 := checkDerefVar(var_glojure_DOT_core_list) tmp60 := lang.Apply(tmp59, []any{true}) - tmp61 := checkDerefVar(glojure_DOT_core_list) - tmp62 := lang.Apply(tmp61, []any{lang.NewKeyword("sigs")}) - tmp63 := checkDerefVar(glojure_DOT_core_list) - tmp64 := checkDerefVar(glojure_DOT_core_seq) - tmp65 := checkDerefVar(glojure_DOT_core_concat) - tmp66 := checkDerefVar(glojure_DOT_core_list) - tmp67 := lang.Apply(tmp66, []any{lang.NewSymbol("quote")}) - tmp68 := checkDerefVar(glojure_DOT_core_list) + tmp61 := checkDerefVar(var_glojure_DOT_core_list) + tmp62 := lang.Apply(tmp61, []any{kw_sigs}) + tmp63 := checkDerefVar(var_glojure_DOT_core_list) + tmp64 := checkDerefVar(var_glojure_DOT_core_seq) + tmp65 := checkDerefVar(var_glojure_DOT_core_concat) + tmp66 := checkDerefVar(var_glojure_DOT_core_list) + tmp67 := lang.Apply(tmp66, []any{sym_quote}) + tmp68 := checkDerefVar(var_glojure_DOT_core_list) tmp69 := lang.Apply(tmp68, []any{v31}) tmp70 := lang.Apply(tmp65, []any{tmp67, tmp69}) tmp71 := lang.Apply(tmp64, []any{tmp70}) tmp72 := lang.Apply(tmp63, []any{tmp71}) - tmp73 := checkDerefVar(glojure_DOT_core_list) - tmp74 := lang.Apply(tmp73, []any{lang.NewKeyword("multis")}) - tmp75 := checkDerefVar(glojure_DOT_core_list) - tmp76 := checkDerefVar(glojure_DOT_core_apply) - tmp77 := checkDerefVar(glojure_DOT_core_hash_map) - tmp78 := checkDerefVar(glojure_DOT_core_seq) - tmp79 := checkDerefVar(glojure_DOT_core_concat) + tmp73 := checkDerefVar(var_glojure_DOT_core_list) + tmp74 := lang.Apply(tmp73, []any{kw_multis}) + tmp75 := checkDerefVar(var_glojure_DOT_core_list) + tmp76 := checkDerefVar(var_glojure_DOT_core_apply) + tmp77 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp78 := checkDerefVar(var_glojure_DOT_core_seq) + tmp79 := checkDerefVar(var_glojure_DOT_core_concat) tmp80 := lang.Apply(tmp79, nil) tmp81 := lang.Apply(tmp78, []any{tmp80}) tmp82 := lang.Apply(tmp76, []any{tmp77, tmp81}) @@ -16120,78 +16912,76 @@ func LoadNS() { tmp91 := lang.Apply(tmp42, []any{tmp44, tmp46, tmp90}) tmp92 := lang.Apply(tmp41, []any{tmp91}) tmp93 := lang.Apply(tmp40, []any{tmp92}) - tmp94 := checkDerefVar(glojure_DOT_core_list) - tmp95 := checkDerefVar(glojure_DOT_core_seq) - tmp96 := checkDerefVar(glojure_DOT_core_concat) - tmp97 := checkDerefVar(glojure_DOT_core_list) - tmp98 := lang.Apply(tmp97, []any{lang.NewSymbol("glojure.core/swap!")}) - tmp99 := checkDerefVar(glojure_DOT_core_list) - tmp100 := lang.Apply(tmp99, []any{lang.NewSymbol("glojure.core/-protocols")}) - tmp101 := checkDerefVar(glojure_DOT_core_list) - tmp102 := lang.Apply(tmp101, []any{lang.NewSymbol("glojure.core/assoc")}) - tmp103 := checkDerefVar(glojure_DOT_core_list) - tmp104 := checkDerefVar(glojure_DOT_core_seq) - tmp105 := checkDerefVar(glojure_DOT_core_concat) - tmp106 := checkDerefVar(glojure_DOT_core_list) - tmp107 := lang.Apply(tmp106, []any{lang.NewSymbol("quote")}) - tmp108 := checkDerefVar(glojure_DOT_core_list) + tmp94 := checkDerefVar(var_glojure_DOT_core_list) + tmp95 := checkDerefVar(var_glojure_DOT_core_seq) + tmp96 := checkDerefVar(var_glojure_DOT_core_concat) + tmp97 := checkDerefVar(var_glojure_DOT_core_list) + tmp98 := lang.Apply(tmp97, []any{sym_glojure_DOT_core_SLASH_swap_BANG_}) + tmp99 := checkDerefVar(var_glojure_DOT_core_list) + tmp100 := lang.Apply(tmp99, []any{sym_glojure_DOT_core_SLASH__DASH_protocols}) + tmp101 := checkDerefVar(var_glojure_DOT_core_list) + tmp102 := lang.Apply(tmp101, []any{sym_glojure_DOT_core_SLASH_assoc}) + tmp103 := checkDerefVar(var_glojure_DOT_core_list) + tmp104 := checkDerefVar(var_glojure_DOT_core_seq) + tmp105 := checkDerefVar(var_glojure_DOT_core_concat) + tmp106 := checkDerefVar(var_glojure_DOT_core_list) + tmp107 := lang.Apply(tmp106, []any{sym_quote}) + tmp108 := checkDerefVar(var_glojure_DOT_core_list) tmp109 := lang.Apply(tmp108, []any{v5}) tmp110 := lang.Apply(tmp105, []any{tmp107, tmp109}) tmp111 := lang.Apply(tmp104, []any{tmp110}) tmp112 := lang.Apply(tmp103, []any{tmp111}) - tmp113 := checkDerefVar(glojure_DOT_core_list) + tmp113 := checkDerefVar(var_glojure_DOT_core_list) tmp114 := lang.Apply(tmp113, []any{v5}) tmp115 := lang.Apply(tmp96, []any{tmp98, tmp100, tmp102, tmp112, tmp114}) tmp116 := lang.Apply(tmp95, []any{tmp115}) tmp117 := lang.Apply(tmp94, []any{tmp116}) - tmp118 := checkDerefVar(glojure_DOT_core_map) + tmp118 := checkDerefVar(var_glojure_DOT_core_map) var tmp119 lang.FnFunc tmp119 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v120 := args[0] _ = v120 - tmp121 := checkDerefVar(glojure_DOT_core_seq) - tmp122 := checkDerefVar(glojure_DOT_core_concat) - tmp123 := checkDerefVar(glojure_DOT_core_list) - tmp124 := lang.Apply(tmp123, []any{lang.NewSymbol("do")}) - tmp125 := checkDerefVar(glojure_DOT_core_list) - tmp126 := checkDerefVar(glojure_DOT_core_seq) - tmp127 := checkDerefVar(glojure_DOT_core_concat) - tmp128 := checkDerefVar(glojure_DOT_core_list) - tmp129 := lang.Apply(tmp128, []any{lang.NewSymbol("glojure.core/defmulti")}) - tmp130 := checkDerefVar(glojure_DOT_core_list) - tmp131 := checkDerefVar(glojure_DOT_core_first) + tmp121 := checkDerefVar(var_glojure_DOT_core_seq) + tmp122 := checkDerefVar(var_glojure_DOT_core_concat) + tmp123 := checkDerefVar(var_glojure_DOT_core_list) + tmp124 := lang.Apply(tmp123, []any{sym_do}) + tmp125 := checkDerefVar(var_glojure_DOT_core_list) + tmp126 := checkDerefVar(var_glojure_DOT_core_seq) + tmp127 := checkDerefVar(var_glojure_DOT_core_concat) + tmp128 := checkDerefVar(var_glojure_DOT_core_list) + tmp129 := lang.Apply(tmp128, []any{sym_glojure_DOT_core_SLASH_defmulti}) + tmp130 := checkDerefVar(var_glojure_DOT_core_list) + tmp131 := checkDerefVar(var_glojure_DOT_core_first) tmp132 := lang.Apply(tmp131, []any{v120}) tmp133 := lang.Apply(tmp130, []any{tmp132}) - tmp134 := checkDerefVar(glojure_DOT_core_list) - tmp135 := checkDerefVar(glojure_DOT_core_seq) - tmp136 := checkDerefVar(glojure_DOT_core_concat) - tmp137 := checkDerefVar(glojure_DOT_core_list) - tmp138 := lang.Apply(tmp137, []any{lang.NewSymbol("glojure.core/fn")}) - tmp139 := checkDerefVar(glojure_DOT_core_list) - tmp140 := checkDerefVar(glojure_DOT_core_apply) - tmp141 := checkDerefVar(glojure_DOT_core_vector) - tmp142 := checkDerefVar(glojure_DOT_core_seq) - tmp143 := checkDerefVar(glojure_DOT_core_concat) - tmp144 := checkDerefVar(glojure_DOT_core_list) - tmp145 := lang.Apply(tmp144, []any{lang.NewSymbol("this")}) - tmp146 := checkDerefVar(glojure_DOT_core_list) - tmp147 := lang.Apply(tmp146, []any{lang.NewSymbol("&")}) - tmp148 := checkDerefVar(glojure_DOT_core_list) - tmp149 := lang.Apply(tmp148, []any{lang.NewSymbol("args")}) + tmp134 := checkDerefVar(var_glojure_DOT_core_list) + tmp135 := checkDerefVar(var_glojure_DOT_core_seq) + tmp136 := checkDerefVar(var_glojure_DOT_core_concat) + tmp137 := checkDerefVar(var_glojure_DOT_core_list) + tmp138 := lang.Apply(tmp137, []any{sym_glojure_DOT_core_SLASH_fn}) + tmp139 := checkDerefVar(var_glojure_DOT_core_list) + tmp140 := checkDerefVar(var_glojure_DOT_core_apply) + tmp141 := checkDerefVar(var_glojure_DOT_core_vector) + tmp142 := checkDerefVar(var_glojure_DOT_core_seq) + tmp143 := checkDerefVar(var_glojure_DOT_core_concat) + tmp144 := checkDerefVar(var_glojure_DOT_core_list) + tmp145 := lang.Apply(tmp144, []any{sym_this}) + tmp146 := checkDerefVar(var_glojure_DOT_core_list) + tmp147 := lang.Apply(tmp146, []any{sym__AMP_}) + tmp148 := checkDerefVar(var_glojure_DOT_core_list) + tmp149 := lang.Apply(tmp148, []any{sym_args}) tmp150 := lang.Apply(tmp143, []any{tmp145, tmp147, tmp149}) tmp151 := lang.Apply(tmp142, []any{tmp150}) tmp152 := lang.Apply(tmp140, []any{tmp141, tmp151}) tmp153 := lang.Apply(tmp139, []any{tmp152}) - tmp154 := checkDerefVar(glojure_DOT_core_list) - tmp155 := checkDerefVar(glojure_DOT_core_seq) - tmp156 := checkDerefVar(glojure_DOT_core_concat) - tmp157 := checkDerefVar(glojure_DOT_core_list) - tmp158 := lang.Apply(tmp157, []any{lang.NewSymbol("glojure.core/class")}) - tmp159 := checkDerefVar(glojure_DOT_core_list) - tmp160 := lang.Apply(tmp159, []any{lang.NewSymbol("this")}) + tmp154 := checkDerefVar(var_glojure_DOT_core_list) + tmp155 := checkDerefVar(var_glojure_DOT_core_seq) + tmp156 := checkDerefVar(var_glojure_DOT_core_concat) + tmp157 := checkDerefVar(var_glojure_DOT_core_list) + tmp158 := lang.Apply(tmp157, []any{sym_glojure_DOT_core_SLASH_class}) + tmp159 := checkDerefVar(var_glojure_DOT_core_list) + tmp160 := lang.Apply(tmp159, []any{sym_this}) tmp161 := lang.Apply(tmp156, []any{tmp158, tmp160}) tmp162 := lang.Apply(tmp155, []any{tmp161}) tmp163 := lang.Apply(tmp154, []any{tmp162}) @@ -16201,34 +16991,34 @@ func LoadNS() { tmp167 := lang.Apply(tmp127, []any{tmp129, tmp133, tmp166}) tmp168 := lang.Apply(tmp126, []any{tmp167}) tmp169 := lang.Apply(tmp125, []any{tmp168}) - tmp170 := checkDerefVar(glojure_DOT_core_list) - tmp171 := checkDerefVar(glojure_DOT_core_seq) - tmp172 := checkDerefVar(glojure_DOT_core_concat) - tmp173 := checkDerefVar(glojure_DOT_core_list) - tmp174 := lang.Apply(tmp173, []any{lang.NewSymbol("glojure.core/swap!")}) - tmp175 := checkDerefVar(glojure_DOT_core_list) + tmp170 := checkDerefVar(var_glojure_DOT_core_list) + tmp171 := checkDerefVar(var_glojure_DOT_core_seq) + tmp172 := checkDerefVar(var_glojure_DOT_core_concat) + tmp173 := checkDerefVar(var_glojure_DOT_core_list) + tmp174 := lang.Apply(tmp173, []any{sym_glojure_DOT_core_SLASH_swap_BANG_}) + tmp175 := checkDerefVar(var_glojure_DOT_core_list) tmp176 := lang.Apply(tmp175, []any{v5}) - tmp177 := checkDerefVar(glojure_DOT_core_list) - tmp178 := lang.Apply(tmp177, []any{lang.NewSymbol("glojure.core/assoc-in")}) - tmp179 := checkDerefVar(glojure_DOT_core_list) - tmp180 := checkDerefVar(glojure_DOT_core_apply) - tmp181 := checkDerefVar(glojure_DOT_core_vector) - tmp182 := checkDerefVar(glojure_DOT_core_seq) - tmp183 := checkDerefVar(glojure_DOT_core_concat) - tmp184 := checkDerefVar(glojure_DOT_core_list) - tmp185 := lang.Apply(tmp184, []any{lang.NewKeyword("multis")}) - tmp186 := checkDerefVar(glojure_DOT_core_list) - tmp187 := checkDerefVar(glojure_DOT_core_seq) - tmp188 := checkDerefVar(glojure_DOT_core_concat) - tmp189 := checkDerefVar(glojure_DOT_core_list) - tmp190 := lang.Apply(tmp189, []any{lang.NewSymbol("glojure.core/keyword")}) - tmp191 := checkDerefVar(glojure_DOT_core_list) - tmp192 := checkDerefVar(glojure_DOT_core_seq) - tmp193 := checkDerefVar(glojure_DOT_core_concat) - tmp194 := checkDerefVar(glojure_DOT_core_list) - tmp195 := lang.Apply(tmp194, []any{lang.NewSymbol("quote")}) - tmp196 := checkDerefVar(glojure_DOT_core_list) - tmp197 := checkDerefVar(glojure_DOT_core_first) + tmp177 := checkDerefVar(var_glojure_DOT_core_list) + tmp178 := lang.Apply(tmp177, []any{sym_glojure_DOT_core_SLASH_assoc_DASH_in}) + tmp179 := checkDerefVar(var_glojure_DOT_core_list) + tmp180 := checkDerefVar(var_glojure_DOT_core_apply) + tmp181 := checkDerefVar(var_glojure_DOT_core_vector) + tmp182 := checkDerefVar(var_glojure_DOT_core_seq) + tmp183 := checkDerefVar(var_glojure_DOT_core_concat) + tmp184 := checkDerefVar(var_glojure_DOT_core_list) + tmp185 := lang.Apply(tmp184, []any{kw_multis}) + tmp186 := checkDerefVar(var_glojure_DOT_core_list) + tmp187 := checkDerefVar(var_glojure_DOT_core_seq) + tmp188 := checkDerefVar(var_glojure_DOT_core_concat) + tmp189 := checkDerefVar(var_glojure_DOT_core_list) + tmp190 := lang.Apply(tmp189, []any{sym_glojure_DOT_core_SLASH_keyword}) + tmp191 := checkDerefVar(var_glojure_DOT_core_list) + tmp192 := checkDerefVar(var_glojure_DOT_core_seq) + tmp193 := checkDerefVar(var_glojure_DOT_core_concat) + tmp194 := checkDerefVar(var_glojure_DOT_core_list) + tmp195 := lang.Apply(tmp194, []any{sym_quote}) + tmp196 := checkDerefVar(var_glojure_DOT_core_list) + tmp197 := checkDerefVar(var_glojure_DOT_core_first) tmp198 := lang.Apply(tmp197, []any{v120}) tmp199 := lang.Apply(tmp196, []any{tmp198}) tmp200 := lang.Apply(tmp193, []any{tmp195, tmp199}) @@ -16241,8 +17031,8 @@ func LoadNS() { tmp207 := lang.Apply(tmp182, []any{tmp206}) tmp208 := lang.Apply(tmp180, []any{tmp181, tmp207}) tmp209 := lang.Apply(tmp179, []any{tmp208}) - tmp210 := checkDerefVar(glojure_DOT_core_list) - tmp211 := checkDerefVar(glojure_DOT_core_first) + tmp210 := checkDerefVar(var_glojure_DOT_core_list) + tmp211 := checkDerefVar(var_glojure_DOT_core_first) tmp212 := lang.Apply(tmp211, []any{v120}) tmp213 := lang.Apply(tmp210, []any{tmp212}) tmp214 := lang.Apply(tmp172, []any{tmp174, tmp176, tmp178, tmp209, tmp213}) @@ -16252,18 +17042,18 @@ func LoadNS() { tmp218 := lang.Apply(tmp121, []any{tmp217}) return tmp218 }) - tmp120 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(102), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(104), lang.NewKeyword("end-column"), int(90)) + tmp120 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(102), kw_column, int(13), kw_end_DASH_line, int(104), kw_end_DASH_column, int(90)) tmp121, err := lang.WithMeta(tmp119, tmp120.(lang.IPersistentMap)) if err != nil { panic(err) } tmp122 := lang.Apply(tmp118, []any{tmp121, v31}) - tmp123 := checkDerefVar(glojure_DOT_core_list) - tmp124 := checkDerefVar(glojure_DOT_core_seq) - tmp125 := checkDerefVar(glojure_DOT_core_concat) - tmp126 := checkDerefVar(glojure_DOT_core_list) - tmp127 := lang.Apply(tmp126, []any{lang.NewSymbol("var")}) - tmp128 := checkDerefVar(glojure_DOT_core_list) + tmp123 := checkDerefVar(var_glojure_DOT_core_list) + tmp124 := checkDerefVar(var_glojure_DOT_core_seq) + tmp125 := checkDerefVar(var_glojure_DOT_core_concat) + tmp126 := checkDerefVar(var_glojure_DOT_core_list) + tmp127 := lang.Apply(tmp126, []any{sym_var}) + tmp128 := checkDerefVar(var_glojure_DOT_core_list) tmp129 := lang.Apply(tmp128, []any{v5}) tmp130 := lang.Apply(tmp125, []any{tmp127, tmp129}) tmp131 := lang.Apply(tmp124, []any{tmp130}) @@ -16275,7 +17065,7 @@ func LoadNS() { return tmp7 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -16283,14 +17073,12 @@ func LoadNS() { } // defstruct { - tmp0 := lang.NewSymbol("defstruct").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("keys"))), lang.NewKeyword("doc"), "Same as (def name (create-struct keys...))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4044), lang.NewKeyword("end-line"), int(4044))).(*lang.Symbol) + tmp0 := sym_defstruct.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym__AMP_, sym_keys)), kw_doc, "Same as (def name (create-struct keys...))", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(11), kw_line, int(4044), kw_end_DASH_line, int(4044))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -16299,17 +17087,17 @@ func LoadNS() { _ = v5 var v6 any = lang.NewList(args[3:]...) _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_seq) - tmp8 := checkDerefVar(glojure_DOT_core_concat) - tmp9 := checkDerefVar(glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("def")}) - tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_def}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) tmp12 := lang.Apply(tmp11, []any{v5}) - tmp13 := checkDerefVar(glojure_DOT_core_list) - tmp14 := checkDerefVar(glojure_DOT_core_seq) - tmp15 := checkDerefVar(glojure_DOT_core_concat) - tmp16 := checkDerefVar(glojure_DOT_core_list) - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("glojure.core/create-struct")}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{sym_glojure_DOT_core_SLASH_create_DASH_struct}) tmp18 := lang.Apply(tmp15, []any{tmp17, v6}) tmp19 := lang.Apply(tmp14, []any{tmp18}) tmp20 := lang.Apply(tmp13, []any{tmp19}) @@ -16318,7 +17106,7 @@ func LoadNS() { return tmp22 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -16326,34 +17114,32 @@ func LoadNS() { } // delay { - tmp0 := lang.NewSymbol("delay").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Takes a body of expressions and yields a Delay object that will\n invoke the body only the first time it is forced (with force or deref/@), and\n will cache the result and return it on all subsequent force\n calls. See also - realized?", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(739), lang.NewKeyword("end-line"), int(739))).(*lang.Symbol) + tmp0 := sym_delay.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_body)), kw_doc, "Takes a body of expressions and yields a Delay object that will\n invoke the body only the first time it is forced (with force or deref/@), and\n will cache the result and return it on all subsequent force\n calls. See also - realized?", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(11), kw_line, int(739), kw_end_DASH_line, int(739))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 var v5 any = lang.NewList(args[2:]...) _ = v5 - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := checkDerefVar(glojure_DOT_core_list_STAR_) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := checkDerefVar(var_glojure_DOT_core_list_STAR_) tmp8 := lang.NewVector() - tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(746), lang.NewKeyword("column"), int(62), lang.NewKeyword("end-line"), int(746), lang.NewKeyword("end-column"), int(63)) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(746), kw_column, int(62), kw_end_DASH_line, int(746), kw_end_DASH_column, int(63)) tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp11 := lang.Apply(tmp7, []any{lang.NewSymbol("fn*"), tmp10, v5}) - tmp12 := lang.Apply(tmp6, []any{lang.NewSymbol("new"), lang.NewSymbol("glojure.lang.Delay"), tmp11}) + tmp11 := lang.Apply(tmp7, []any{sym_fn_STAR_, tmp10, v5}) + tmp12 := lang.Apply(tmp6, []any{sym_new, sym_glojure_DOT_lang_DOT_Delay, tmp11}) return tmp12 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -16361,19 +17147,17 @@ func LoadNS() { } // delay? { - tmp0 := lang.NewSymbol("delay?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "returns true if x is a Delay created with delay", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(748), lang.NewKeyword("end-line"), int(748))).(*lang.Symbol) + tmp0 := sym_delay_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "returns true if x is a Delay created with delay", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(748), kw_end_DASH_line, int(748))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp5 := lang.Apply(tmp4, []any{nil, v3}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -16381,12 +17165,10 @@ func LoadNS() { } // deliver { - tmp0 := lang.NewSymbol("deliver").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("promise"), lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Delivers the supplied value to the promise, releasing any pending\n derefs. A subsequent call to deliver on a promise will have no effect.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7109), lang.NewKeyword("end-line"), int(7109))).(*lang.Symbol) + tmp0 := sym_deliver.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_promise, sym_val)), kw_doc, "Delivers the supplied value to the promise, releasing any pending\n derefs. A subsequent call to deliver on a promise will have no effect.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(7109), kw_end_DASH_line, int(7109))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -16394,7 +17176,7 @@ func LoadNS() { tmp5 := lang.Apply(v3, []any{v4}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -16403,12 +17185,10 @@ func LoadNS() { // denominator { tmp1 := reflect.TypeOf((*big9.Int)(nil)) - tmp0 := lang.NewSymbol("denominator").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("r"))), lang.NewKeyword("doc"), "Returns the denominator part of a Ratio.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3591), lang.NewKeyword("end-line"), int(3591))).(*lang.Symbol) + tmp0 := sym_denominator.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_r)), kw_doc, "Returns the denominator part of a Ratio.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(3591), kw_end_DASH_line, int(3591))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 tmp5, ok := lang.FieldOrMethod(v4, "denominator") @@ -16425,7 +17205,7 @@ func LoadNS() { return tmp6 }) tmp4 := reflect.TypeOf((*big9.Int)(nil)) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -16433,7 +17213,7 @@ func LoadNS() { } // deref { - tmp0 := lang.NewSymbol("deref").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref")), lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("timeout-ms"), lang.NewSymbol("timeout-val"))), lang.NewKeyword("doc"), "Also reader macro: @ref/@agent/@var/@atom/@delay/@future/@promise. Within a transaction,\n returns the in-transaction-value of ref, else returns the\n most-recently-committed value of ref. When applied to a var, agent\n or atom, returns its current state. When applied to a delay, forces\n it if not already forced. When applied to a future, will block if\n computation not complete. When applied to a promise, will block\n until a value is delivered. The variant taking a timeout can be\n used for blocking references (futures and promises), and will return\n timeout-val if the timeout (in milliseconds) is reached before a\n value is available. See also - realized?.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2304), lang.NewKeyword("end-line"), int(2304))).(*lang.Symbol) + tmp0 := sym_deref.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ref), lang.NewVector(sym_ref, sym_timeout_DASH_ms, sym_timeout_DASH_val)), kw_doc, "Also reader macro: @ref/@agent/@var/@atom/@delay/@future/@promise. Within a transaction,\n returns the in-transaction-value of ref, else returns the\n most-recently-committed value of ref. When applied to a var, agent\n or atom, returns its current state. When applied to a delay, forces\n it if not already forced. When applied to a future, will block if\n computation not complete. When applied to a promise, will block\n until a value is delivered. The variant taking a timeout can be\n used for blocking references (futures and promises), and will return\n timeout-val if the timeout (in milliseconds) is reached before a\n value is available. See also - realized?.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(2304), kw_end_DASH_line, int(2304))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -16441,7 +17221,7 @@ func LoadNS() { v3 := args[0] _ = v3 var tmp4 any - tmp5 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp6 := reflect.TypeOf((*lang.IDeref)(nil)).Elem() tmp7 := lang.Apply(tmp5, []any{tmp6, v3}) if lang.IsTruthy(tmp7) { @@ -16458,7 +17238,7 @@ func LoadNS() { } tmp4 = tmp9 } else { - tmp10 := checkDerefVar(glojure_DOT_core_deref_future) + tmp10 := checkDerefVar(var_glojure_DOT_core_deref_DASH_future) tmp11 := lang.Apply(tmp10, []any{v3}) tmp4 = tmp11 } @@ -16471,7 +17251,7 @@ func LoadNS() { v5 := args[2] _ = v5 var tmp6 any - tmp7 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp7 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp8 := reflect.TypeOf((*lang.IBlockingDeref)(nil)).Elem() tmp9 := lang.Apply(tmp7, []any{tmp8, v3}) if lang.IsTruthy(tmp9) { @@ -16482,16 +17262,17 @@ func LoadNS() { tmp11 := lang.Apply(tmp10, []any{v4, v5}) tmp6 = tmp11 } else { - tmp12 := checkDerefVar(glojure_DOT_core_deref_future) + tmp12 := checkDerefVar(var_glojure_DOT_core_deref_DASH_future) tmp13 := lang.Apply(tmp12, []any{v3, v4, v5}) tmp6 = tmp13 } return tmp6 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -16499,12 +17280,10 @@ func LoadNS() { } // deref-as-map { - tmp0 := lang.NewSymbol("deref-as-map").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(408), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(408), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym_deref_DASH_as_DASH_map.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(408), kw_column, int(8), kw_end_DASH_line, int(408), kw_end_DASH_column, int(19), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_o)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any @@ -16513,14 +17292,14 @@ func LoadNS() { var tmp5 any { // let // let binding "and__0__auto__" - tmp6 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp6 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp7 := reflect.TypeOf((*lang.IPending)(nil)).Elem() tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) var v9 any = tmp8 _ = v9 var tmp10 any if lang.IsTruthy(v9) { - tmp11 := checkDerefVar(glojure_DOT_core_not) + tmp11 := checkDerefVar(var_glojure_DOT_core_not) tmp12, ok := lang.FieldOrMethod(v3, "isRealized") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "isRealized"))) @@ -16553,7 +17332,7 @@ func LoadNS() { v9 := r _ = v9 tmp10 := lang.NewVector(true, v9) - tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(415), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(415), lang.NewKeyword("end-column"), int(25)) + tmp11 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(415), kw_column, int(18), kw_end_DASH_line, int(415), kw_end_DASH_column, int(25)) tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) if err != nil { panic(err) @@ -16564,10 +17343,10 @@ func LoadNS() { } } }() - tmp9 := checkDerefVar(glojure_DOT_core_deref) + tmp9 := checkDerefVar(var_glojure_DOT_core_deref) tmp10 := lang.Apply(tmp9, []any{v3}) tmp11 := lang.NewVector(false, tmp10) - tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(413), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(413), lang.NewKeyword("end-column"), int(32)) + tmp12 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(413), kw_column, int(16), kw_end_DASH_line, int(413), kw_end_DASH_column, int(32)) tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) if err != nil { panic(err) @@ -16579,12 +17358,12 @@ func LoadNS() { var v14 any = tmp7 _ = v14 // let binding "ex" - tmp15 := checkDerefVar(glojure_DOT_core_nth) + tmp15 := checkDerefVar(var_glojure_DOT_core_nth) tmp16 := lang.Apply(tmp15, []any{v14, int64(0), nil}) var v17 any = tmp16 _ = v17 // let binding "val" - tmp18 := checkDerefVar(glojure_DOT_core_nth) + tmp18 := checkDerefVar(var_glojure_DOT_core_nth) tmp19 := lang.Apply(tmp18, []any{v14, int64(1), nil}) var v20 any = tmp19 _ = v20 @@ -16601,14 +17380,14 @@ func LoadNS() { var tmp25 any { // let // let binding "and__0__auto__" - tmp26 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp26 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp27 := reflect.TypeOf((*lang.Agent)(nil)) tmp28 := lang.Apply(tmp26, []any{tmp27, v3}) var v29 any = tmp28 _ = v29 var tmp30 any if lang.IsTruthy(v29) { - tmp31 := checkDerefVar(glojure_DOT_core_agent_error) + tmp31 := checkDerefVar(var_glojure_DOT_core_agent_DASH_error) tmp32 := lang.Apply(tmp31, []any{v3}) tmp30 = tmp32 } else { @@ -16621,23 +17400,23 @@ func LoadNS() { tmp22 = tmp24 } // end let if lang.IsTruthy(tmp22) { - tmp21 = lang.NewKeyword("failed") + tmp21 = kw_failed } else { var tmp23 any if lang.IsTruthy(v6) { - tmp23 = lang.NewKeyword("pending") + tmp23 = kw_pending } else { var tmp24 any - if lang.IsTruthy(lang.NewKeyword("else")) { - tmp24 = lang.NewKeyword("ready") + if lang.IsTruthy(kw_else) { + tmp24 = kw_ready } else { } tmp23 = tmp24 } tmp21 = tmp23 } - tmp25 := lang.NewMap(lang.NewKeyword("status"), tmp21, lang.NewKeyword("val"), v20) - tmp26 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(416), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(429), lang.NewKeyword("end-column"), int(14)) + tmp25 := lang.NewMap(kw_status, tmp21, kw_val, v20) + tmp26 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(416), kw_column, int(5), kw_end_DASH_line, int(429), kw_end_DASH_column, int(14)) tmp27, err := lang.WithMeta(tmp25, tmp26.(lang.IPersistentMap)) if err != nil { panic(err) @@ -16646,7 +17425,7 @@ func LoadNS() { } // end let return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -16654,7 +17433,7 @@ func LoadNS() { } // deref-future { - tmp0 := lang.NewSymbol("deref-future").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2296), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(2296), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fut")), lang.NewVector(lang.NewSymbol("fut"), lang.NewSymbol("timeout-ms"), lang.NewSymbol("timeout-val"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym_deref_DASH_future.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(2296), kw_column, int(7), kw_end_DASH_line, int(2296), kw_end_DASH_column, int(28), kw_arglists, lang.NewList(lang.NewVector(sym_fut), lang.NewVector(sym_fut, sym_timeout_DASH_ms, sym_timeout_DASH_val)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -16703,10 +17482,11 @@ func LoadNS() { }() return tmp6 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -16714,7 +17494,7 @@ func LoadNS() { } // derive { - tmp0 := lang.NewSymbol("derive").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag"), lang.NewSymbol("parent")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"), lang.NewSymbol("parent"))), lang.NewKeyword("doc"), "Establishes a parent/child relationship between parent and\n tag. Parent must be a namespace-qualified symbol or keyword and\n child can be either a namespace-qualified symbol or keyword or a\n class. h must be a hierarchy obtained from make-hierarchy, if not\n supplied defaults to, and modifies, the global hierarchy.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5605), lang.NewKeyword("end-line"), int(5605))).(*lang.Symbol) + tmp0 := sym_derive.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_tag, sym_parent), lang.NewVector(sym_h, sym_tag, sym_parent)), kw_doc, "Establishes a parent/child relationship between parent and\n tag. Parent must be a namespace-qualified symbol or keyword and\n child can be either a namespace-qualified symbol or keyword or a\n class. h must be a hierarchy obtained from make-hierarchy, if not\n supplied defaults to, and modifies, the global hierarchy.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(5605), kw_end_DASH_line, int(5605))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -16723,9 +17503,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_alter_var_root) - tmp6 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("global-hierarchy")) - tmp7 := checkDerefVar(glojure_DOT_core_derive) + tmp5 := checkDerefVar(var_glojure_DOT_core_alter_DASH_var_DASH_root) + tmp6 := lang.InternVarName(sym_glojure_DOT_core, sym_global_DASH_hierarchy) + tmp7 := checkDerefVar(var_glojure_DOT_core_derive) tmp8 := lang.Apply(tmp5, []any{tmp6, tmp7, v3, v4}) _ = tmp8 return nil @@ -16739,23 +17519,21 @@ func LoadNS() { var tmp6 any { // let // let binding "tp" - tmp7 := lang.Apply(lang.NewKeyword("parents"), []any{v3}) + tmp7 := lang.Apply(kw_parents, []any{v3}) var v8 any = tmp7 _ = v8 // let binding "td" - tmp9 := lang.Apply(lang.NewKeyword("descendants"), []any{v3}) + tmp9 := lang.Apply(kw_descendants, []any{v3}) var v10 any = tmp9 _ = v10 // let binding "ta" - tmp11 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) + tmp11 := lang.Apply(kw_ancestors, []any{v3}) var v12 any = tmp11 _ = v12 // let binding "tf" var tmp13 lang.FnFunc tmp13 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 5 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 5) v14 := args[0] _ = v14 v15 := args[1] @@ -16766,46 +17544,44 @@ func LoadNS() { _ = v17 v18 := args[4] _ = v18 - tmp19 := checkDerefVar(glojure_DOT_core_reduce1) + tmp19 := checkDerefVar(var_glojure_DOT_core_reduce1) var tmp20 lang.FnFunc tmp20 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v21 := args[0] _ = v21 v22 := args[1] _ = v22 - tmp23 := checkDerefVar(glojure_DOT_core_assoc) - tmp24 := checkDerefVar(glojure_DOT_core_reduce1) - tmp25 := checkDerefVar(glojure_DOT_core_conj) - tmp26 := checkDerefVar(glojure_DOT_core_get) + tmp23 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp24 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp25 := checkDerefVar(var_glojure_DOT_core_conj) + tmp26 := checkDerefVar(var_glojure_DOT_core_get) tmp27 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) - tmp28 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5628), lang.NewKeyword("column"), int(61), lang.NewKeyword("end-line"), int(5628), lang.NewKeyword("end-column"), int(63)) + tmp28 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5628), kw_column, int(61), kw_end_DASH_line, int(5628), kw_end_DASH_column, int(63)) tmp29, err := lang.WithMeta(tmp27, tmp28.(lang.IPersistentMap)) if err != nil { panic(err) } tmp30 := lang.Apply(tmp26, []any{v18, v22, tmp29}) - tmp31 := checkDerefVar(glojure_DOT_core_cons) + tmp31 := checkDerefVar(var_glojure_DOT_core_cons) tmp32 := lang.Apply(v18, []any{v17}) tmp33 := lang.Apply(tmp31, []any{v17, tmp32}) tmp34 := lang.Apply(tmp24, []any{tmp25, tmp30, tmp33}) tmp35 := lang.Apply(tmp23, []any{v21, v22, tmp34}) return tmp35 }) - tmp21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5626), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(5628), lang.NewKeyword("end-column"), int(98)) + tmp21 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5626), kw_column, int(24), kw_end_DASH_line, int(5628), kw_end_DASH_column, int(98)) tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp23 := checkDerefVar(glojure_DOT_core_cons) + tmp23 := checkDerefVar(var_glojure_DOT_core_cons) tmp24 := lang.Apply(v16, []any{v15}) tmp25 := lang.Apply(tmp23, []any{v15, tmp24}) tmp26 := lang.Apply(tmp19, []any{tmp22, v14, tmp25}) return tmp26 }) - tmp14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5625), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(5629), lang.NewKeyword("end-column"), int(56)) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5625), kw_column, int(13), kw_end_DASH_line, int(5629), kw_end_DASH_column, int(56)) tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) if err != nil { panic(err) @@ -16816,17 +17592,17 @@ func LoadNS() { { // let // let binding "or__0__auto__" var tmp18 any - tmp19 := checkDerefVar(glojure_DOT_core_contains_QMARK_) + tmp19 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) tmp20 := lang.Apply(v8, []any{v4}) tmp21 := lang.Apply(tmp19, []any{tmp20, v5}) if lang.IsTruthy(tmp21) { } else { var tmp22 any - tmp23 := checkDerefVar(glojure_DOT_core_contains_QMARK_) + tmp23 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) tmp24 := lang.Apply(v12, []any{v4}) tmp25 := lang.Apply(tmp23, []any{tmp24, v5}) if lang.IsTruthy(tmp25) { - tmp26 := checkDerefVar(glojure_DOT_core_print_str) + tmp26 := checkDerefVar(var_glojure_DOT_core_print_DASH_str) tmp27 := lang.Apply(tmp26, []any{v4, "already has", v5, "as ancestor"}) tmp28 := lang.Apply(lang.NewError, []any{tmp27}) panic(tmp28) @@ -16834,23 +17610,23 @@ func LoadNS() { } _ = tmp22 var tmp29 any - tmp30 := checkDerefVar(glojure_DOT_core_contains_QMARK_) + tmp30 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) tmp31 := lang.Apply(v12, []any{v5}) tmp32 := lang.Apply(tmp30, []any{tmp31, v4}) if lang.IsTruthy(tmp32) { - tmp33 := checkDerefVar(glojure_DOT_core_print_str) + tmp33 := checkDerefVar(var_glojure_DOT_core_print_DASH_str) tmp34 := lang.Apply(tmp33, []any{"Cyclic derivation:", v5, "has", v4, "as ancestor"}) tmp35 := lang.Apply(lang.NewError, []any{tmp34}) panic(tmp35) } else { } _ = tmp29 - tmp36 := checkDerefVar(glojure_DOT_core_assoc) - tmp37 := lang.Apply(lang.NewKeyword("parents"), []any{v3}) - tmp38 := checkDerefVar(glojure_DOT_core_conj) - tmp39 := checkDerefVar(glojure_DOT_core_get) + tmp36 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp37 := lang.Apply(kw_parents, []any{v3}) + tmp38 := checkDerefVar(var_glojure_DOT_core_conj) + tmp39 := checkDerefVar(var_glojure_DOT_core_get) tmp40 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) - tmp41 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5636), lang.NewKeyword("column"), int(61), lang.NewKeyword("end-line"), int(5636), lang.NewKeyword("end-column"), int(63)) + tmp41 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5636), kw_column, int(61), kw_end_DASH_line, int(5636), kw_end_DASH_column, int(63)) tmp42, err := lang.WithMeta(tmp40, tmp41.(lang.IPersistentMap)) if err != nil { panic(err) @@ -16858,12 +17634,12 @@ func LoadNS() { tmp43 := lang.Apply(tmp39, []any{v8, v4, tmp42}) tmp44 := lang.Apply(tmp38, []any{tmp43, v5}) tmp45 := lang.Apply(tmp36, []any{tmp37, v4, tmp44}) - tmp46 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) + tmp46 := lang.Apply(kw_ancestors, []any{v3}) tmp47 := lang.Apply(v16, []any{tmp46, v4, v10, v5, v12}) - tmp48 := lang.Apply(lang.NewKeyword("descendants"), []any{v3}) + tmp48 := lang.Apply(kw_descendants, []any{v3}) tmp49 := lang.Apply(v16, []any{tmp48, v5, v12, v4, v10}) - tmp50 := lang.NewMap(lang.NewKeyword("parents"), tmp45, lang.NewKeyword("ancestors"), tmp47, lang.NewKeyword("descendants"), tmp49) - tmp51 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5636), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(5638), lang.NewKeyword("end-column"), int(61)) + tmp50 := lang.NewMap(kw_parents, tmp45, kw_ancestors, tmp47, kw_descendants, tmp49) + tmp51 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5636), kw_column, int(9), kw_end_DASH_line, int(5638), kw_end_DASH_column, int(61)) tmp52, err := lang.WithMeta(tmp50, tmp51.(lang.IPersistentMap)) if err != nil { panic(err) @@ -16884,10 +17660,11 @@ func LoadNS() { } // end let return tmp6 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -16895,15 +17672,15 @@ func LoadNS() { } // descendants { - tmp0 := lang.NewSymbol("descendants").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"))), lang.NewKeyword("doc"), "Returns the immediate and indirect children of tag, through a\n relationship established via derive. h must be a hierarchy obtained\n from make-hierarchy, if not supplied defaults to the global\n hierarchy. Note: does not work on Java type inheritance\n relationships.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5593), lang.NewKeyword("end-line"), int(5593))).(*lang.Symbol) + tmp0 := sym_descendants.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_tag), lang.NewVector(sym_h, sym_tag)), kw_doc, "Returns the immediate and indirect children of tag, through a\n relationship established via derive. h must be a hierarchy obtained\n from make-hierarchy, if not supplied defaults to the global\n hierarchy. Note: does not work on Java type inheritance\n relationships.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(5593), kw_end_DASH_line, int(5593))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_descendants) - tmp5 := checkDerefVar(glojure_DOT_core_global_hierarchy) + tmp4 := checkDerefVar(var_glojure_DOT_core_descendants) + tmp5 := checkDerefVar(var_glojure_DOT_core_global_DASH_hierarchy) tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) return tmp6 case 2: @@ -16912,25 +17689,26 @@ func LoadNS() { v4 := args[1] _ = v4 var tmp5 any - tmp6 := checkDerefVar(glojure_DOT_core_class_QMARK_) + tmp6 := checkDerefVar(var_glojure_DOT_core_class_QMARK_) tmp7 := lang.Apply(tmp6, []any{v4}) if lang.IsTruthy(tmp7) { tmp8 := lang.Apply(lang.NewUnsupportedOperationError, []any{"Can't get descendants of classes"}) panic(tmp8) } else { - tmp9 := checkDerefVar(glojure_DOT_core_not_empty) - tmp10 := checkDerefVar(glojure_DOT_core_get) - tmp11 := lang.Apply(lang.NewKeyword("descendants"), []any{v3}) + tmp9 := checkDerefVar(var_glojure_DOT_core_not_DASH_empty) + tmp10 := checkDerefVar(var_glojure_DOT_core_get) + tmp11 := lang.Apply(kw_descendants, []any{v3}) tmp12 := lang.Apply(tmp10, []any{tmp11, v4}) tmp13 := lang.Apply(tmp9, []any{tmp12}) tmp5 = tmp13 } return tmp5 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -16938,18 +17716,16 @@ func LoadNS() { } // destructure { - tmp0 := lang.NewSymbol("destructure").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4400), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(4400), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym_destructure.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4400), kw_column, int(7), kw_end_DASH_line, int(4400), kw_end_DASH_column, int(17), kw_arglists, lang.NewList(lang.NewVector(sym_bindings)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any { // let // let binding "bents" - tmp5 := checkDerefVar(glojure_DOT_core_partition) + tmp5 := checkDerefVar(var_glojure_DOT_core_partition) tmp6 := lang.Apply(tmp5, []any{int64(2), v3}) var v7 any = tmp6 _ = v7 @@ -16958,9 +17734,7 @@ func LoadNS() { { // function pb var v9 lang.FnFunc tmp8 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v10 := args[0] _ = v10 v11 := args[1] @@ -16972,9 +17746,7 @@ func LoadNS() { // let binding "pvec" var tmp14 lang.FnFunc tmp14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v15 := args[0] _ = v15 v16 := args[1] @@ -16984,24 +17756,24 @@ func LoadNS() { var tmp18 any { // let // let binding "gvec" - tmp19 := checkDerefVar(glojure_DOT_core_gensym) + tmp19 := checkDerefVar(var_glojure_DOT_core_gensym) tmp20 := lang.Apply(tmp19, []any{"vec__"}) var v21 any = tmp20 _ = v21 // let binding "gseq" - tmp22 := checkDerefVar(glojure_DOT_core_gensym) + tmp22 := checkDerefVar(var_glojure_DOT_core_gensym) tmp23 := lang.Apply(tmp22, []any{"seq__"}) var v24 any = tmp23 _ = v24 // let binding "gfirst" - tmp25 := checkDerefVar(glojure_DOT_core_gensym) + tmp25 := checkDerefVar(var_glojure_DOT_core_gensym) tmp26 := lang.Apply(tmp25, []any{"first__"}) var v27 any = tmp26 _ = v27 // let binding "has-rest" - tmp28 := checkDerefVar(glojure_DOT_core_some) - tmp29 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{lang.NewSymbol("&")})) - tmp30 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4408), lang.NewKeyword("column"), int(43), lang.NewKeyword("end-line"), int(4408), lang.NewKeyword("end-column"), int(47)) + tmp28 := checkDerefVar(var_glojure_DOT_core_some) + tmp29 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{sym__AMP_})) + tmp30 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4408), kw_column, int(43), kw_end_DASH_line, int(4408), kw_end_DASH_column, int(47)) tmp31, err := lang.WithMeta(tmp29, tmp30.(lang.IPersistentMap)) if err != nil { panic(err) @@ -17015,15 +17787,15 @@ func LoadNS() { var tmp35 any { // let // let binding "ret" - tmp36 := checkDerefVar(glojure_DOT_core_conj) + tmp36 := checkDerefVar(var_glojure_DOT_core_conj) tmp37 := lang.Apply(tmp36, []any{v15, v21, v17}) var v38 any = tmp37 _ = v38 var tmp39 any if lang.IsTruthy(v33) { - tmp40 := checkDerefVar(glojure_DOT_core_conj) - tmp41 := checkDerefVar(glojure_DOT_core_list) - tmp42 := lang.Apply(tmp41, []any{lang.NewSymbol("glojure.core/seq"), v21}) + tmp40 := checkDerefVar(var_glojure_DOT_core_conj) + tmp41 := checkDerefVar(var_glojure_DOT_core_list) + tmp42 := lang.Apply(tmp41, []any{sym_glojure_DOT_core_SLASH_seq, v21}) tmp43 := lang.Apply(tmp40, []any{v38, v24, tmp42}) tmp39 = tmp43 } else { @@ -17044,26 +17816,26 @@ func LoadNS() { _ = v39 for { var tmp40 any - tmp41 := checkDerefVar(glojure_DOT_core_seq) + tmp41 := checkDerefVar(var_glojure_DOT_core_seq) tmp42 := lang.Apply(tmp41, []any{v38}) if lang.IsTruthy(tmp42) { var tmp43 any { // let // let binding "firstb" - tmp44 := checkDerefVar(glojure_DOT_core_first) + tmp44 := checkDerefVar(var_glojure_DOT_core_first) tmp45 := lang.Apply(tmp44, []any{v38}) var v46 any = tmp45 _ = v46 var tmp47 any - tmp48 := checkDerefVar(glojure_DOT_core__EQ_) - tmp49 := lang.Apply(tmp48, []any{v46, lang.NewSymbol("&")}) + tmp48 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp49 := lang.Apply(tmp48, []any{v46, sym__AMP_}) if lang.IsTruthy(tmp49) { - tmp51 := checkDerefVar(glojure_DOT_core_second) + tmp51 := checkDerefVar(var_glojure_DOT_core_second) tmp52 := lang.Apply(tmp51, []any{v38}) tmp53 := lang.Apply(v9, []any{v36, tmp52, v24}) var tmp50 any = tmp53 var tmp54 any = v37 - tmp56 := checkDerefVar(glojure_DOT_core_nnext) + tmp56 := checkDerefVar(var_glojure_DOT_core_nnext) tmp57 := lang.Apply(tmp56, []any{v38}) var tmp55 any = tmp57 var tmp58 any = true @@ -17074,16 +17846,16 @@ func LoadNS() { continue } else { var tmp59 any - tmp60 := checkDerefVar(glojure_DOT_core__EQ_) - tmp61 := lang.Apply(tmp60, []any{v46, lang.NewKeyword("as")}) + tmp60 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp61 := lang.Apply(tmp60, []any{v46, kw_as}) if lang.IsTruthy(tmp61) { - tmp62 := checkDerefVar(glojure_DOT_core_second) + tmp62 := checkDerefVar(var_glojure_DOT_core_second) tmp63 := lang.Apply(tmp62, []any{v38}) tmp64 := lang.Apply(v9, []any{v36, tmp63, v21}) tmp59 = tmp64 } else { var tmp65 any - if lang.IsTruthy(lang.NewKeyword("else")) { + if lang.IsTruthy(kw_else) { var tmp66 any if lang.IsTruthy(v39) { tmp67 := lang.Apply(errors8.New, []any{"Unsupported binding form, only :as can follow & parameter"}) @@ -17091,20 +17863,20 @@ func LoadNS() { } else { var tmp69 any if lang.IsTruthy(v33) { - tmp70 := checkDerefVar(glojure_DOT_core_conj) - tmp71 := checkDerefVar(glojure_DOT_core_seq) - tmp72 := checkDerefVar(glojure_DOT_core_concat) - tmp73 := checkDerefVar(glojure_DOT_core_list) - tmp74 := lang.Apply(tmp73, []any{lang.NewSymbol("glojure.core/first")}) - tmp75 := checkDerefVar(glojure_DOT_core_list) + tmp70 := checkDerefVar(var_glojure_DOT_core_conj) + tmp71 := checkDerefVar(var_glojure_DOT_core_seq) + tmp72 := checkDerefVar(var_glojure_DOT_core_concat) + tmp73 := checkDerefVar(var_glojure_DOT_core_list) + tmp74 := lang.Apply(tmp73, []any{sym_glojure_DOT_core_SLASH_first}) + tmp75 := checkDerefVar(var_glojure_DOT_core_list) tmp76 := lang.Apply(tmp75, []any{v24}) tmp77 := lang.Apply(tmp72, []any{tmp74, tmp76}) tmp78 := lang.Apply(tmp71, []any{tmp77}) - tmp79 := checkDerefVar(glojure_DOT_core_seq) - tmp80 := checkDerefVar(glojure_DOT_core_concat) - tmp81 := checkDerefVar(glojure_DOT_core_list) - tmp82 := lang.Apply(tmp81, []any{lang.NewSymbol("glojure.core/next")}) - tmp83 := checkDerefVar(glojure_DOT_core_list) + tmp79 := checkDerefVar(var_glojure_DOT_core_seq) + tmp80 := checkDerefVar(var_glojure_DOT_core_concat) + tmp81 := checkDerefVar(var_glojure_DOT_core_list) + tmp82 := lang.Apply(tmp81, []any{sym_glojure_DOT_core_SLASH_next}) + tmp83 := checkDerefVar(var_glojure_DOT_core_list) tmp84 := lang.Apply(tmp83, []any{v24}) tmp85 := lang.Apply(tmp80, []any{tmp82, tmp84}) tmp86 := lang.Apply(tmp79, []any{tmp85}) @@ -17117,16 +17889,16 @@ func LoadNS() { if lang.IsTruthy(v33) { tmp88 = v27 } else { - tmp89 := checkDerefVar(glojure_DOT_core_list) - tmp90 := lang.Apply(tmp89, []any{lang.NewSymbol("glojure.core/nth"), v21, v37, nil}) + tmp89 := checkDerefVar(var_glojure_DOT_core_list) + tmp90 := lang.Apply(tmp89, []any{sym_glojure_DOT_core_SLASH_nth, v21, v37, nil}) tmp88 = tmp90 } tmp91 := lang.Apply(v9, []any{tmp69, v46, tmp88}) var tmp68 any = tmp91 - tmp93 := checkDerefVar(glojure_DOT_core_inc) + tmp93 := checkDerefVar(var_glojure_DOT_core_inc) tmp94 := lang.Apply(tmp93, []any{v37}) var tmp92 any = tmp94 - tmp96 := checkDerefVar(glojure_DOT_core_next) + tmp96 := checkDerefVar(var_glojure_DOT_core_next) tmp97 := lang.Apply(tmp96, []any{v38}) var tmp95 any = tmp97 var tmp98 any = v39 @@ -17157,7 +17929,7 @@ func LoadNS() { } // end let return tmp18 }) - tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4404), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(4438), lang.NewKeyword("end-column"), int(34)) + tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4404), kw_column, int(20), kw_end_DASH_line, int(4438), kw_end_DASH_column, int(34)) tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) if err != nil { panic(err) @@ -17167,9 +17939,7 @@ func LoadNS() { // let binding "pmap" var tmp18 lang.FnFunc tmp18 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v19 := args[0] _ = v19 v20 := args[1] @@ -17179,14 +17949,14 @@ func LoadNS() { var tmp22 any { // let // let binding "gmap" - tmp23 := checkDerefVar(glojure_DOT_core_gensym) + tmp23 := checkDerefVar(var_glojure_DOT_core_gensym) tmp24 := lang.Apply(tmp23, []any{"map__"}) var v25 any = tmp24 _ = v25 // let binding "gmapseq" - tmp26 := checkDerefVar(glojure_DOT_core_with_meta) - tmp27 := lang.NewMap(lang.NewKeyword("tag"), lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.ISeq")) - tmp28 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4442), lang.NewKeyword("column"), int(52), lang.NewKeyword("end-line"), int(4442), lang.NewKeyword("end-column"), int(103)) + tmp26 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp27 := lang.NewMap(kw_tag, sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_ISeq) + tmp28 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4442), kw_column, int(52), kw_end_DASH_line, int(4442), kw_end_DASH_column, int(103)) tmp29, err := lang.WithMeta(tmp27, tmp28.(lang.IPersistentMap)) if err != nil { panic(err) @@ -17195,7 +17965,7 @@ func LoadNS() { var v31 any = tmp30 _ = v31 // let binding "defaults" - tmp32 := lang.Apply(lang.NewKeyword("or"), []any{v20}) + tmp32 := lang.Apply(kw_or, []any{v20}) var v33 any = tmp32 _ = v33 var tmp34 any @@ -17203,16 +17973,14 @@ func LoadNS() { // let binding "ret" var tmp35 lang.FnFunc tmp35 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v36 := args[0] _ = v36 var tmp37 any - tmp38 := lang.Apply(lang.NewKeyword("as"), []any{v20}) + tmp38 := lang.Apply(kw_as, []any{v20}) if lang.IsTruthy(tmp38) { - tmp39 := checkDerefVar(glojure_DOT_core_conj) - tmp40 := lang.Apply(lang.NewKeyword("as"), []any{v20}) + tmp39 := checkDerefVar(var_glojure_DOT_core_conj) + tmp40 := lang.Apply(kw_as, []any{v20}) tmp41 := lang.Apply(tmp39, []any{v36, tmp40, v25}) tmp37 = tmp41 } else { @@ -17220,58 +17988,58 @@ func LoadNS() { } return tmp37 }) - tmp36 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4450), lang.NewKeyword("column"), int(40), lang.NewKeyword("end-line"), int(4453), lang.NewKeyword("end-column"), int(48)) + tmp36 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4450), kw_column, int(40), kw_end_DASH_line, int(4453), kw_end_DASH_column, int(48)) tmp37, err := lang.WithMeta(tmp35, tmp36.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp38 := checkDerefVar(glojure_DOT_core_conj) - tmp39 := checkDerefVar(glojure_DOT_core_conj) - tmp40 := checkDerefVar(glojure_DOT_core_conj) - tmp41 := checkDerefVar(glojure_DOT_core_conj) + tmp38 := checkDerefVar(var_glojure_DOT_core_conj) + tmp39 := checkDerefVar(var_glojure_DOT_core_conj) + tmp40 := checkDerefVar(var_glojure_DOT_core_conj) + tmp41 := checkDerefVar(var_glojure_DOT_core_conj) tmp42 := lang.Apply(tmp41, []any{v19, v25}) tmp43 := lang.Apply(tmp40, []any{tmp42, v21}) tmp44 := lang.Apply(tmp39, []any{tmp43, v25}) - tmp45 := checkDerefVar(glojure_DOT_core_seq) - tmp46 := checkDerefVar(glojure_DOT_core_concat) - tmp47 := checkDerefVar(glojure_DOT_core_list) - tmp48 := lang.Apply(tmp47, []any{lang.NewSymbol("if")}) - tmp49 := checkDerefVar(glojure_DOT_core_list) - tmp50 := checkDerefVar(glojure_DOT_core_seq) - tmp51 := checkDerefVar(glojure_DOT_core_concat) - tmp52 := checkDerefVar(glojure_DOT_core_list) - tmp53 := lang.Apply(tmp52, []any{lang.NewSymbol("glojure.core/seq?")}) - tmp54 := checkDerefVar(glojure_DOT_core_list) + tmp45 := checkDerefVar(var_glojure_DOT_core_seq) + tmp46 := checkDerefVar(var_glojure_DOT_core_concat) + tmp47 := checkDerefVar(var_glojure_DOT_core_list) + tmp48 := lang.Apply(tmp47, []any{sym_if}) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) + tmp50 := checkDerefVar(var_glojure_DOT_core_seq) + tmp51 := checkDerefVar(var_glojure_DOT_core_concat) + tmp52 := checkDerefVar(var_glojure_DOT_core_list) + tmp53 := lang.Apply(tmp52, []any{sym_glojure_DOT_core_SLASH_seq_QMARK_}) + tmp54 := checkDerefVar(var_glojure_DOT_core_list) tmp55 := lang.Apply(tmp54, []any{v25}) tmp56 := lang.Apply(tmp51, []any{tmp53, tmp55}) tmp57 := lang.Apply(tmp50, []any{tmp56}) tmp58 := lang.Apply(tmp49, []any{tmp57}) - tmp59 := checkDerefVar(glojure_DOT_core_list) - tmp60 := checkDerefVar(glojure_DOT_core_seq) - tmp61 := checkDerefVar(glojure_DOT_core_concat) - tmp62 := checkDerefVar(glojure_DOT_core_list) - tmp63 := lang.Apply(tmp62, []any{lang.NewSymbol("if")}) - tmp64 := checkDerefVar(glojure_DOT_core_list) - tmp65 := checkDerefVar(glojure_DOT_core_seq) - tmp66 := checkDerefVar(glojure_DOT_core_concat) - tmp67 := checkDerefVar(glojure_DOT_core_list) - tmp68 := lang.Apply(tmp67, []any{lang.NewSymbol("glojure.core/next")}) - tmp69 := checkDerefVar(glojure_DOT_core_list) + tmp59 := checkDerefVar(var_glojure_DOT_core_list) + tmp60 := checkDerefVar(var_glojure_DOT_core_seq) + tmp61 := checkDerefVar(var_glojure_DOT_core_concat) + tmp62 := checkDerefVar(var_glojure_DOT_core_list) + tmp63 := lang.Apply(tmp62, []any{sym_if}) + tmp64 := checkDerefVar(var_glojure_DOT_core_list) + tmp65 := checkDerefVar(var_glojure_DOT_core_seq) + tmp66 := checkDerefVar(var_glojure_DOT_core_concat) + tmp67 := checkDerefVar(var_glojure_DOT_core_list) + tmp68 := lang.Apply(tmp67, []any{sym_glojure_DOT_core_SLASH_next}) + tmp69 := checkDerefVar(var_glojure_DOT_core_list) tmp70 := lang.Apply(tmp69, []any{v31}) tmp71 := lang.Apply(tmp66, []any{tmp68, tmp70}) tmp72 := lang.Apply(tmp65, []any{tmp71}) tmp73 := lang.Apply(tmp64, []any{tmp72}) - tmp74 := checkDerefVar(glojure_DOT_core_list) - tmp75 := checkDerefVar(glojure_DOT_core_seq) - tmp76 := checkDerefVar(glojure_DOT_core_concat) - tmp77 := checkDerefVar(glojure_DOT_core_list) - tmp78 := lang.Apply(tmp77, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewPersistentArrayMapAsIfByAssoc")}) - tmp79 := checkDerefVar(glojure_DOT_core_list) - tmp80 := checkDerefVar(glojure_DOT_core_seq) - tmp81 := checkDerefVar(glojure_DOT_core_concat) - tmp82 := checkDerefVar(glojure_DOT_core_list) - tmp83 := lang.Apply(tmp82, []any{lang.NewSymbol("glojure.core/to-array")}) - tmp84 := checkDerefVar(glojure_DOT_core_list) + tmp74 := checkDerefVar(var_glojure_DOT_core_list) + tmp75 := checkDerefVar(var_glojure_DOT_core_seq) + tmp76 := checkDerefVar(var_glojure_DOT_core_concat) + tmp77 := checkDerefVar(var_glojure_DOT_core_list) + tmp78 := lang.Apply(tmp77, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_NewPersistentArrayMapAsIfByAssoc}) + tmp79 := checkDerefVar(var_glojure_DOT_core_list) + tmp80 := checkDerefVar(var_glojure_DOT_core_seq) + tmp81 := checkDerefVar(var_glojure_DOT_core_concat) + tmp82 := checkDerefVar(var_glojure_DOT_core_list) + tmp83 := lang.Apply(tmp82, []any{sym_glojure_DOT_core_SLASH_to_DASH_array}) + tmp84 := checkDerefVar(var_glojure_DOT_core_list) tmp85 := lang.Apply(tmp84, []any{v31}) tmp86 := lang.Apply(tmp81, []any{tmp83, tmp85}) tmp87 := lang.Apply(tmp80, []any{tmp86}) @@ -17279,40 +18047,40 @@ func LoadNS() { tmp89 := lang.Apply(tmp76, []any{tmp78, tmp88}) tmp90 := lang.Apply(tmp75, []any{tmp89}) tmp91 := lang.Apply(tmp74, []any{tmp90}) - tmp92 := checkDerefVar(glojure_DOT_core_list) - tmp93 := checkDerefVar(glojure_DOT_core_seq) - tmp94 := checkDerefVar(glojure_DOT_core_concat) - tmp95 := checkDerefVar(glojure_DOT_core_list) - tmp96 := lang.Apply(tmp95, []any{lang.NewSymbol("if")}) - tmp97 := checkDerefVar(glojure_DOT_core_list) - tmp98 := checkDerefVar(glojure_DOT_core_seq) - tmp99 := checkDerefVar(glojure_DOT_core_concat) - tmp100 := checkDerefVar(glojure_DOT_core_list) - tmp101 := lang.Apply(tmp100, []any{lang.NewSymbol("glojure.core/seq")}) - tmp102 := checkDerefVar(glojure_DOT_core_list) + tmp92 := checkDerefVar(var_glojure_DOT_core_list) + tmp93 := checkDerefVar(var_glojure_DOT_core_seq) + tmp94 := checkDerefVar(var_glojure_DOT_core_concat) + tmp95 := checkDerefVar(var_glojure_DOT_core_list) + tmp96 := lang.Apply(tmp95, []any{sym_if}) + tmp97 := checkDerefVar(var_glojure_DOT_core_list) + tmp98 := checkDerefVar(var_glojure_DOT_core_seq) + tmp99 := checkDerefVar(var_glojure_DOT_core_concat) + tmp100 := checkDerefVar(var_glojure_DOT_core_list) + tmp101 := lang.Apply(tmp100, []any{sym_glojure_DOT_core_SLASH_seq}) + tmp102 := checkDerefVar(var_glojure_DOT_core_list) tmp103 := lang.Apply(tmp102, []any{v31}) tmp104 := lang.Apply(tmp99, []any{tmp101, tmp103}) tmp105 := lang.Apply(tmp98, []any{tmp104}) tmp106 := lang.Apply(tmp97, []any{tmp105}) - tmp107 := checkDerefVar(glojure_DOT_core_list) - tmp108 := checkDerefVar(glojure_DOT_core_seq) - tmp109 := checkDerefVar(glojure_DOT_core_concat) - tmp110 := checkDerefVar(glojure_DOT_core_list) - tmp111 := lang.Apply(tmp110, []any{lang.NewSymbol("glojure.core/first")}) - tmp112 := checkDerefVar(glojure_DOT_core_list) + tmp107 := checkDerefVar(var_glojure_DOT_core_list) + tmp108 := checkDerefVar(var_glojure_DOT_core_seq) + tmp109 := checkDerefVar(var_glojure_DOT_core_concat) + tmp110 := checkDerefVar(var_glojure_DOT_core_list) + tmp111 := lang.Apply(tmp110, []any{sym_glojure_DOT_core_SLASH_first}) + tmp112 := checkDerefVar(var_glojure_DOT_core_list) tmp113 := lang.Apply(tmp112, []any{v31}) tmp114 := lang.Apply(tmp109, []any{tmp111, tmp113}) tmp115 := lang.Apply(tmp108, []any{tmp114}) tmp116 := lang.Apply(tmp107, []any{tmp115}) - tmp117 := checkDerefVar(glojure_DOT_core_list) - tmp118 := lang.Apply(tmp117, []any{lang.NewSymbol("glojure.lang.PersistentArrayMap/EMPTY")}) + tmp117 := checkDerefVar(var_glojure_DOT_core_list) + tmp118 := lang.Apply(tmp117, []any{sym_glojure_DOT_lang_DOT_PersistentArrayMap_SLASH_EMPTY}) tmp119 := lang.Apply(tmp94, []any{tmp96, tmp106, tmp116, tmp118}) tmp120 := lang.Apply(tmp93, []any{tmp119}) tmp121 := lang.Apply(tmp92, []any{tmp120}) tmp122 := lang.Apply(tmp61, []any{tmp63, tmp73, tmp91, tmp121}) tmp123 := lang.Apply(tmp60, []any{tmp122}) tmp124 := lang.Apply(tmp59, []any{tmp123}) - tmp125 := checkDerefVar(glojure_DOT_core_list) + tmp125 := checkDerefVar(var_glojure_DOT_core_list) tmp126 := lang.Apply(tmp125, []any{v25}) tmp127 := lang.Apply(tmp46, []any{tmp48, tmp58, tmp124, tmp126}) tmp128 := lang.Apply(tmp45, []any{tmp127}) @@ -17324,45 +18092,41 @@ func LoadNS() { var tmp132 any { // let // let binding "transforms" - tmp133 := checkDerefVar(glojure_DOT_core_reduce1) + tmp133 := checkDerefVar(var_glojure_DOT_core_reduce1) var tmp134 lang.FnFunc tmp134 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v135 := args[0] _ = v135 v136 := args[1] _ = v136 var tmp137 any - tmp138 := checkDerefVar(glojure_DOT_core_keyword_QMARK_) + tmp138 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) tmp139 := lang.Apply(tmp138, []any{v136}) if lang.IsTruthy(tmp139) { var tmp140 any { // let // let binding "mkns" - tmp141 := checkDerefVar(glojure_DOT_core_namespace) + tmp141 := checkDerefVar(var_glojure_DOT_core_namespace) tmp142 := lang.Apply(tmp141, []any{v136}) var v143 any = tmp142 _ = v143 // let binding "mkn" - tmp144 := checkDerefVar(glojure_DOT_core_name) + tmp144 := checkDerefVar(var_glojure_DOT_core_name) tmp145 := lang.Apply(tmp144, []any{v136}) var v146 any = tmp145 _ = v146 var tmp147 any - tmp148 := checkDerefVar(glojure_DOT_core__EQ_) + tmp148 := checkDerefVar(var_glojure_DOT_core__EQ_) tmp149 := lang.Apply(tmp148, []any{v146, "keys"}) if lang.IsTruthy(tmp149) { - tmp150 := checkDerefVar(glojure_DOT_core_assoc) + tmp150 := checkDerefVar(var_glojure_DOT_core_assoc) var tmp151 lang.FnFunc tmp151 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v152 := args[0] _ = v152 - tmp153 := checkDerefVar(glojure_DOT_core_keyword) + tmp153 := checkDerefVar(var_glojure_DOT_core_keyword) var tmp154 any { // let // let binding "or__0__auto__" @@ -17372,18 +18136,18 @@ func LoadNS() { if lang.IsTruthy(v155) { tmp156 = v155 } else { - tmp157 := checkDerefVar(glojure_DOT_core_namespace) + tmp157 := checkDerefVar(var_glojure_DOT_core_namespace) tmp158 := lang.Apply(tmp157, []any{v152}) tmp156 = tmp158 } tmp154 = tmp156 } // end let - tmp155 := checkDerefVar(glojure_DOT_core_name) + tmp155 := checkDerefVar(var_glojure_DOT_core_name) tmp156 := lang.Apply(tmp155, []any{v152}) tmp157 := lang.Apply(tmp153, []any{tmp154, tmp156}) return tmp157 }) - tmp152 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4460), lang.NewKeyword("column"), int(93), lang.NewKeyword("end-line"), int(4460), lang.NewKeyword("end-column"), int(135)) + tmp152 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4460), kw_column, int(93), kw_end_DASH_line, int(4460), kw_end_DASH_column, int(135)) tmp153, err := lang.WithMeta(tmp151, tmp152.(lang.IPersistentMap)) if err != nil { panic(err) @@ -17392,19 +18156,17 @@ func LoadNS() { tmp147 = tmp154 } else { var tmp155 any - tmp156 := checkDerefVar(glojure_DOT_core__EQ_) + tmp156 := checkDerefVar(var_glojure_DOT_core__EQ_) tmp157 := lang.Apply(tmp156, []any{v146, "syms"}) if lang.IsTruthy(tmp157) { - tmp158 := checkDerefVar(glojure_DOT_core_assoc) + tmp158 := checkDerefVar(var_glojure_DOT_core_assoc) var tmp159 lang.FnFunc tmp159 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v160 := args[0] _ = v160 - tmp161 := checkDerefVar(glojure_DOT_core_list) - tmp162 := checkDerefVar(glojure_DOT_core_symbol) + tmp161 := checkDerefVar(var_glojure_DOT_core_list) + tmp162 := checkDerefVar(var_glojure_DOT_core_symbol) var tmp163 any { // let // let binding "or__0__auto__" @@ -17414,19 +18176,19 @@ func LoadNS() { if lang.IsTruthy(v164) { tmp165 = v164 } else { - tmp166 := checkDerefVar(glojure_DOT_core_namespace) + tmp166 := checkDerefVar(var_glojure_DOT_core_namespace) tmp167 := lang.Apply(tmp166, []any{v160}) tmp165 = tmp167 } tmp163 = tmp165 } // end let - tmp164 := checkDerefVar(glojure_DOT_core_name) + tmp164 := checkDerefVar(var_glojure_DOT_core_name) tmp165 := lang.Apply(tmp164, []any{v160}) tmp166 := lang.Apply(tmp162, []any{tmp163, tmp165}) - tmp167 := lang.Apply(tmp161, []any{lang.NewSymbol("quote"), tmp166}) + tmp167 := lang.Apply(tmp161, []any{sym_quote, tmp166}) return tmp167 }) - tmp160 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4461), lang.NewKeyword("column"), int(93), lang.NewKeyword("end-line"), int(4461), lang.NewKeyword("end-column"), int(148)) + tmp160 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4461), kw_column, int(93), kw_end_DASH_line, int(4461), kw_end_DASH_column, int(148)) tmp161, err := lang.WithMeta(tmp159, tmp160.(lang.IPersistentMap)) if err != nil { panic(err) @@ -17435,16 +18197,16 @@ func LoadNS() { tmp155 = tmp162 } else { var tmp163 any - tmp164 := checkDerefVar(glojure_DOT_core__EQ_) + tmp164 := checkDerefVar(var_glojure_DOT_core__EQ_) tmp165 := lang.Apply(tmp164, []any{v146, "strs"}) if lang.IsTruthy(tmp165) { - tmp166 := checkDerefVar(glojure_DOT_core_assoc) - tmp167 := checkDerefVar(glojure_DOT_core_str) + tmp166 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp167 := checkDerefVar(var_glojure_DOT_core_str) tmp168 := lang.Apply(tmp166, []any{v135, v136, tmp167}) tmp163 = tmp168 } else { var tmp169 any - if lang.IsTruthy(lang.NewKeyword("else")) { + if lang.IsTruthy(kw_else) { tmp169 = v135 } else { } @@ -17462,71 +18224,67 @@ func LoadNS() { } return tmp137 }) - tmp135 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4456), lang.NewKeyword("column"), int(45), lang.NewKeyword("end-line"), int(4464), lang.NewKeyword("end-column"), int(60)) + tmp135 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4456), kw_column, int(45), kw_end_DASH_line, int(4464), kw_end_DASH_column, int(60)) tmp136, err := lang.WithMeta(tmp134, tmp135.(lang.IPersistentMap)) if err != nil { panic(err) } tmp137 := lang.NewMap() - tmp138 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4465), lang.NewKeyword("column"), int(45), lang.NewKeyword("end-line"), int(4465), lang.NewKeyword("end-column"), int(46)) + tmp138 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4465), kw_column, int(45), kw_end_DASH_line, int(4465), kw_end_DASH_column, int(46)) tmp139, err := lang.WithMeta(tmp137, tmp138.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp140 := checkDerefVar(glojure_DOT_core_keys) + tmp140 := checkDerefVar(var_glojure_DOT_core_keys) tmp141 := lang.Apply(tmp140, []any{v20}) tmp142 := lang.Apply(tmp133, []any{tmp136, tmp139, tmp141}) var v143 any = tmp142 _ = v143 - tmp144 := checkDerefVar(glojure_DOT_core_reduce1) + tmp144 := checkDerefVar(var_glojure_DOT_core_reduce1) var tmp145 lang.FnFunc tmp145 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v146 := args[0] _ = v146 v147 := args[1] _ = v147 - tmp148 := checkDerefVar(glojure_DOT_core_reduce1) + tmp148 := checkDerefVar(var_glojure_DOT_core_reduce1) var tmp149 lang.FnFunc tmp149 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v150 := args[0] _ = v150 v151 := args[1] _ = v151 - tmp152 := checkDerefVar(glojure_DOT_core_assoc) - tmp153 := checkDerefVar(glojure_DOT_core_val) + tmp152 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp153 := checkDerefVar(var_glojure_DOT_core_val) tmp154 := lang.Apply(tmp153, []any{v147}) tmp155 := lang.Apply(tmp154, []any{v151}) tmp156 := lang.Apply(tmp152, []any{v150, v151, tmp155}) return tmp156 }) - tmp150 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4469), lang.NewKeyword("column"), int(52), lang.NewKeyword("end-line"), int(4469), lang.NewKeyword("end-column"), int(82)) + tmp150 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4469), kw_column, int(52), kw_end_DASH_line, int(4469), kw_end_DASH_column, int(82)) tmp151, err := lang.WithMeta(tmp149, tmp150.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp152 := checkDerefVar(glojure_DOT_core_dissoc) - tmp153 := checkDerefVar(glojure_DOT_core_key) + tmp152 := checkDerefVar(var_glojure_DOT_core_dissoc) + tmp153 := checkDerefVar(var_glojure_DOT_core_key) tmp154 := lang.Apply(tmp153, []any{v147}) tmp155 := lang.Apply(tmp152, []any{v146, tmp154}) - tmp156 := checkDerefVar(glojure_DOT_core_key) + tmp156 := checkDerefVar(var_glojure_DOT_core_key) tmp157 := lang.Apply(tmp156, []any{v147}) tmp158 := lang.Apply(tmp157, []any{v146}) tmp159 := lang.Apply(tmp148, []any{tmp151, tmp155, tmp158}) return tmp159 }) - tmp146 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4468), lang.NewKeyword("column"), int(41), lang.NewKeyword("end-line"), int(4471), lang.NewKeyword("end-column"), int(70)) + tmp146 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4468), kw_column, int(41), kw_end_DASH_line, int(4471), kw_end_DASH_column, int(70)) tmp147, err := lang.WithMeta(tmp145, tmp146.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp148 := checkDerefVar(glojure_DOT_core_dissoc) - tmp149 := lang.Apply(tmp148, []any{v20, lang.NewKeyword("as"), lang.NewKeyword("or")}) + tmp148 := checkDerefVar(var_glojure_DOT_core_dissoc) + tmp149 := lang.Apply(tmp148, []any{v20, kw_as, kw_or}) tmp150 := lang.Apply(tmp144, []any{tmp147, tmp149, v143}) tmp132 = tmp150 } // end let @@ -17534,37 +18292,37 @@ func LoadNS() { _ = v133 for { var tmp134 any - tmp135 := checkDerefVar(glojure_DOT_core_seq) + tmp135 := checkDerefVar(var_glojure_DOT_core_seq) tmp136 := lang.Apply(tmp135, []any{v133}) if lang.IsTruthy(tmp136) { var tmp137 any { // let // let binding "bb" - tmp138 := checkDerefVar(glojure_DOT_core_key) - tmp139 := checkDerefVar(glojure_DOT_core_first) + tmp138 := checkDerefVar(var_glojure_DOT_core_key) + tmp139 := checkDerefVar(var_glojure_DOT_core_first) tmp140 := lang.Apply(tmp139, []any{v133}) tmp141 := lang.Apply(tmp138, []any{tmp140}) var v142 any = tmp141 _ = v142 // let binding "bk" - tmp143 := checkDerefVar(glojure_DOT_core_val) - tmp144 := checkDerefVar(glojure_DOT_core_first) + tmp143 := checkDerefVar(var_glojure_DOT_core_val) + tmp144 := checkDerefVar(var_glojure_DOT_core_first) tmp145 := lang.Apply(tmp144, []any{v133}) tmp146 := lang.Apply(tmp143, []any{tmp145}) var v147 any = tmp146 _ = v147 // let binding "local" var tmp148 any - tmp149 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp149 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp150 := reflect.TypeOf((*lang.Named)(nil)).Elem() tmp151 := lang.Apply(tmp149, []any{tmp150, v142}) if lang.IsTruthy(tmp151) { - tmp152 := checkDerefVar(glojure_DOT_core_with_meta) - tmp153 := checkDerefVar(glojure_DOT_core_symbol) - tmp154 := checkDerefVar(glojure_DOT_core_name) + tmp152 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp153 := checkDerefVar(var_glojure_DOT_core_symbol) + tmp154 := checkDerefVar(var_glojure_DOT_core_name) tmp155 := lang.Apply(tmp154, []any{v142}) tmp156 := lang.Apply(tmp153, []any{nil, tmp155}) - tmp157 := checkDerefVar(glojure_DOT_core_meta) + tmp157 := checkDerefVar(var_glojure_DOT_core_meta) tmp158 := lang.Apply(tmp157, []any{v142}) tmp159 := lang.Apply(tmp152, []any{tmp156, tmp158}) tmp148 = tmp159 @@ -17575,25 +18333,25 @@ func LoadNS() { _ = v160 // let binding "bv" var tmp161 any - tmp162 := checkDerefVar(glojure_DOT_core_contains_QMARK_) + tmp162 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) tmp163 := lang.Apply(tmp162, []any{v33, v160}) if lang.IsTruthy(tmp163) { - tmp164 := checkDerefVar(glojure_DOT_core_list) + tmp164 := checkDerefVar(var_glojure_DOT_core_list) tmp165 := lang.Apply(v33, []any{v160}) - tmp166 := lang.Apply(tmp164, []any{lang.NewSymbol("glojure.core/get"), v25, v147, tmp165}) + tmp166 := lang.Apply(tmp164, []any{sym_glojure_DOT_core_SLASH_get, v25, v147, tmp165}) tmp161 = tmp166 } else { - tmp167 := checkDerefVar(glojure_DOT_core_list) - tmp168 := lang.Apply(tmp167, []any{lang.NewSymbol("glojure.core/get"), v25, v147}) + tmp167 := checkDerefVar(var_glojure_DOT_core_list) + tmp168 := lang.Apply(tmp167, []any{sym_glojure_DOT_core_SLASH_get, v25, v147}) tmp161 = tmp168 } var v169 any = tmp161 _ = v169 var tmp171 any - tmp172 := checkDerefVar(glojure_DOT_core_ident_QMARK_) + tmp172 := checkDerefVar(var_glojure_DOT_core_ident_QMARK_) tmp173 := lang.Apply(tmp172, []any{v142}) if lang.IsTruthy(tmp173) { - tmp174 := checkDerefVar(glojure_DOT_core_conj) + tmp174 := checkDerefVar(var_glojure_DOT_core_conj) tmp175 := lang.Apply(tmp174, []any{v131, v160, v169}) tmp171 = tmp175 } else { @@ -17601,7 +18359,7 @@ func LoadNS() { tmp171 = tmp176 } var tmp170 any = tmp171 - tmp178 := checkDerefVar(glojure_DOT_core_next) + tmp178 := checkDerefVar(var_glojure_DOT_core_next) tmp179 := lang.Apply(tmp178, []any{v133}) var tmp177 any = tmp179 v131 = tmp170 @@ -17620,7 +18378,7 @@ func LoadNS() { } // end let return tmp22 }) - tmp19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4440), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(4485), lang.NewKeyword("end-column"), int(34)) + tmp19 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4440), kw_column, int(20), kw_end_DASH_line, int(4485), kw_end_DASH_column, int(34)) tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) if err != nil { panic(err) @@ -17628,32 +18386,32 @@ func LoadNS() { var v21 any = tmp20 _ = v21 var tmp22 any - tmp23 := checkDerefVar(glojure_DOT_core_symbol_QMARK_) + tmp23 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) tmp24 := lang.Apply(tmp23, []any{v11}) if lang.IsTruthy(tmp24) { - tmp25 := checkDerefVar(glojure_DOT_core_conj) - tmp26 := checkDerefVar(glojure_DOT_core_conj) + tmp25 := checkDerefVar(var_glojure_DOT_core_conj) + tmp26 := checkDerefVar(var_glojure_DOT_core_conj) tmp27 := lang.Apply(tmp26, []any{v10, v11}) tmp28 := lang.Apply(tmp25, []any{tmp27, v12}) tmp22 = tmp28 } else { var tmp29 any - tmp30 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp30 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) tmp31 := lang.Apply(tmp30, []any{v11}) if lang.IsTruthy(tmp31) { tmp32 := lang.Apply(v17, []any{v10, v11, v12}) tmp29 = tmp32 } else { var tmp33 any - tmp34 := checkDerefVar(glojure_DOT_core_map_QMARK_) + tmp34 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) tmp35 := lang.Apply(tmp34, []any{v11}) if lang.IsTruthy(tmp35) { tmp36 := lang.Apply(v21, []any{v10, v11, v12}) tmp33 = tmp36 } else { var tmp37 any - if lang.IsTruthy(lang.NewKeyword("else")) { - tmp38 := checkDerefVar(glojure_DOT_core_str) + if lang.IsTruthy(kw_else) { + tmp38 := checkDerefVar(var_glojure_DOT_core_str) tmp39 := lang.Apply(tmp38, []any{"Unsupported binding form: ", v11}) tmp40 := lang.Apply(errors8.New, []any{tmp39}) panic(tmp40) @@ -17672,7 +18430,7 @@ func LoadNS() { v9 = tmp8 _ = v9 } - tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4402), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(4490), lang.NewKeyword("end-column"), int(82)) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4402), kw_column, int(12), kw_end_DASH_line, int(4490), kw_end_DASH_column, int(82)) tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) if err != nil { panic(err) @@ -17682,21 +18440,19 @@ func LoadNS() { // let binding "process-entry" var tmp12 lang.FnFunc tmp12 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v13 := args[0] _ = v13 v14 := args[1] _ = v14 - tmp15 := checkDerefVar(glojure_DOT_core_first) + tmp15 := checkDerefVar(var_glojure_DOT_core_first) tmp16 := lang.Apply(tmp15, []any{v14}) - tmp17 := checkDerefVar(glojure_DOT_core_second) + tmp17 := checkDerefVar(var_glojure_DOT_core_second) tmp18 := lang.Apply(tmp17, []any{v14}) tmp19 := lang.Apply(v11, []any{v13, tmp16, tmp18}) return tmp19 }) - tmp13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4491), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(4491), lang.NewKeyword("end-column"), int(66)) + tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4491), kw_column, int(23), kw_end_DASH_line, int(4491), kw_end_DASH_column, int(66)) tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) if err != nil { panic(err) @@ -17704,18 +18460,18 @@ func LoadNS() { var v15 any = tmp14 _ = v15 var tmp16 any - tmp17 := checkDerefVar(glojure_DOT_core_every_QMARK_) - tmp18 := checkDerefVar(glojure_DOT_core_symbol_QMARK_) - tmp19 := checkDerefVar(glojure_DOT_core_map) - tmp20 := checkDerefVar(glojure_DOT_core_first) + tmp17 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + tmp18 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp19 := checkDerefVar(var_glojure_DOT_core_map) + tmp20 := checkDerefVar(var_glojure_DOT_core_first) tmp21 := lang.Apply(tmp19, []any{tmp20, v7}) tmp22 := lang.Apply(tmp17, []any{tmp18, tmp21}) if lang.IsTruthy(tmp22) { tmp16 = v3 } else { - tmp23 := checkDerefVar(glojure_DOT_core_reduce1) + tmp23 := checkDerefVar(var_glojure_DOT_core_reduce1) tmp24 := lang.NewVector() - tmp25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4494), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(4494), lang.NewKeyword("end-column"), int(31)) + tmp25 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4494), kw_column, int(30), kw_end_DASH_line, int(4494), kw_end_DASH_column, int(31)) tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) if err != nil { panic(err) @@ -17727,7 +18483,7 @@ func LoadNS() { } // end let return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -17735,7 +18491,7 @@ func LoadNS() { } // disj { - tmp0 := lang.NewSymbol("disj").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("set")), lang.NewVector(lang.NewSymbol("set"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("set"), lang.NewSymbol("key"), lang.NewSymbol("&"), lang.NewSymbol("ks"))), lang.NewKeyword("doc"), "disj[oin]. Returns a new set of the same (hashed/sorted) type, that\n does not contain key(s).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1514), lang.NewKeyword("end-line"), int(1514))).(*lang.Symbol) + tmp0 := sym_disj.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_set), lang.NewVector(sym_set, sym_key), lang.NewVector(sym_set, sym_key, sym__AMP_, sym_ks)), kw_doc, "disj[oin]. Returns a new set of the same (hashed/sorted) type, that\n does not contain key(s).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1514), kw_end_DASH_line, int(1514))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -17760,9 +18516,7 @@ func LoadNS() { } return tmp5 default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -17775,17 +18529,17 @@ func LoadNS() { var tmp7 any { // let // let binding "ret" - tmp8 := checkDerefVar(glojure_DOT_core_disj) + tmp8 := checkDerefVar(var_glojure_DOT_core_disj) tmp9 := lang.Apply(tmp8, []any{v3, v4}) var v10 any = tmp9 _ = v10 var tmp11 any if lang.IsTruthy(v5) { var tmp12 any = v10 - tmp14 := checkDerefVar(glojure_DOT_core_first) + tmp14 := checkDerefVar(var_glojure_DOT_core_first) tmp15 := lang.Apply(tmp14, []any{v5}) var tmp13 any = tmp15 - tmp17 := checkDerefVar(glojure_DOT_core_next) + tmp17 := checkDerefVar(var_glojure_DOT_core_next) tmp18 := lang.Apply(tmp17, []any{v5}) var tmp16 any = tmp18 v3 = tmp12 @@ -17803,7 +18557,7 @@ func LoadNS() { return tmp6 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -17811,7 +18565,7 @@ func LoadNS() { } // disj! { - tmp0 := lang.NewSymbol("disj!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("set")), lang.NewVector(lang.NewSymbol("set"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("set"), lang.NewSymbol("key"), lang.NewSymbol("&"), lang.NewSymbol("ks"))), lang.NewKeyword("doc"), "disj[oin]. Returns a transient set of the same (hashed/sorted) type, that\n does not contain key(s).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3401), lang.NewKeyword("end-line"), int(3401))).(*lang.Symbol) + tmp0 := sym_disj_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_set), lang.NewVector(sym_set, sym_key), lang.NewVector(sym_set, sym_key, sym__AMP_, sym_ks)), kw_doc, "disj[oin]. Returns a transient set of the same (hashed/sorted) type, that\n does not contain key(s).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3401), kw_end_DASH_line, int(3401))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -17831,9 +18585,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v4}) return tmp6 default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -17854,10 +18606,10 @@ func LoadNS() { var tmp10 any if lang.IsTruthy(v5) { var tmp11 any = v9 - tmp13 := checkDerefVar(glojure_DOT_core_first) + tmp13 := checkDerefVar(var_glojure_DOT_core_first) tmp14 := lang.Apply(tmp13, []any{v5}) var tmp12 any = tmp14 - tmp16 := checkDerefVar(glojure_DOT_core_next) + tmp16 := checkDerefVar(var_glojure_DOT_core_next) tmp17 := lang.Apply(tmp16, []any{v5}) var tmp15 any = tmp17 v3 = tmp11 @@ -17872,7 +18624,7 @@ func LoadNS() { return tmp6 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -17880,7 +18632,7 @@ func LoadNS() { } // dissoc { - tmp0 := lang.NewSymbol("dissoc").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map")), lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"), lang.NewSymbol("&"), lang.NewSymbol("ks"))), lang.NewKeyword("doc"), "dissoc[iate]. Returns a new map of the same (hashed/sorted) type,\n that does not contain a mapping for key(s).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1500), lang.NewKeyword("end-line"), int(1500))).(*lang.Symbol) + tmp0 := sym_dissoc.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_map), lang.NewVector(sym_map, sym_key), lang.NewVector(sym_map, sym_key, sym__AMP_, sym_ks)), kw_doc, "dissoc[iate]. Returns a new map of the same (hashed/sorted) type,\n that does not contain a mapping for key(s).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(1500), kw_end_DASH_line, int(1500))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -17900,9 +18652,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -17913,17 +18663,17 @@ func LoadNS() { var tmp6 any { // let // let binding "ret" - tmp7 := checkDerefVar(glojure_DOT_core_dissoc) + tmp7 := checkDerefVar(var_glojure_DOT_core_dissoc) tmp8 := lang.Apply(tmp7, []any{v3, v4}) var v9 any = tmp8 _ = v9 var tmp10 any if lang.IsTruthy(v5) { var tmp11 any = v9 - tmp13 := checkDerefVar(glojure_DOT_core_first) + tmp13 := checkDerefVar(var_glojure_DOT_core_first) tmp14 := lang.Apply(tmp13, []any{v5}) var tmp12 any = tmp14 - tmp16 := checkDerefVar(glojure_DOT_core_next) + tmp16 := checkDerefVar(var_glojure_DOT_core_next) tmp17 := lang.Apply(tmp16, []any{v5}) var tmp15 any = tmp17 v3 = tmp11 @@ -17938,7 +18688,7 @@ func LoadNS() { return tmp6 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -17946,7 +18696,7 @@ func LoadNS() { } // dissoc! { - tmp0 := lang.NewSymbol("dissoc!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"), lang.NewSymbol("&"), lang.NewSymbol("ks"))), lang.NewKeyword("doc"), "Returns a transient map that doesn't contain a mapping for key(s).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3382), lang.NewKeyword("end-line"), int(3382))).(*lang.Symbol) + tmp0 := sym_dissoc_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_map, sym_key), lang.NewVector(sym_map, sym_key, sym__AMP_, sym_ks)), kw_doc, "Returns a transient map that doesn't contain a mapping for key(s).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(3382), kw_end_DASH_line, int(3382))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -17962,9 +18712,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v4}) return tmp6 default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -17985,10 +18733,10 @@ func LoadNS() { var tmp10 any if lang.IsTruthy(v5) { var tmp11 any = v9 - tmp13 := checkDerefVar(glojure_DOT_core_first) + tmp13 := checkDerefVar(var_glojure_DOT_core_first) tmp14 := lang.Apply(tmp13, []any{v5}) var tmp12 any = tmp14 - tmp16 := checkDerefVar(glojure_DOT_core_next) + tmp16 := checkDerefVar(var_glojure_DOT_core_next) tmp17 := lang.Apply(tmp16, []any{v5}) var tmp15 any = tmp17 v3 = tmp11 @@ -18003,7 +18751,7 @@ func LoadNS() { return tmp6 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -18011,24 +18759,22 @@ func LoadNS() { } // distinct { - tmp0 := lang.NewSymbol("distinct").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the elements of coll with duplicates removed.\n Returns a stateful transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5053), lang.NewKeyword("end-line"), int(5053))).(*lang.Symbol) + tmp0 := sym_distinct.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_coll)), kw_doc, "Returns a lazy sequence of the elements of coll with duplicates removed.\n Returns a stateful transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(5053), kw_end_DASH_line, int(5053))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 var tmp5 any { // let // let binding "seen" - tmp6 := checkDerefVar(glojure_DOT_core_volatile_BANG_) + tmp6 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) tmp7 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) - tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5060), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(5060), lang.NewKeyword("end-column"), int(30)) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5060), kw_column, int(28), kw_end_DASH_line, int(5060), kw_end_DASH_column, int(30)) tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) if err != nil { panic(err) @@ -18053,14 +18799,14 @@ func LoadNS() { v14 := args[1] _ = v14 var tmp15 any - tmp16 := checkDerefVar(glojure_DOT_core_contains_QMARK_) - tmp17 := checkDerefVar(glojure_DOT_core_deref) + tmp16 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp17 := checkDerefVar(var_glojure_DOT_core_deref) tmp18 := lang.Apply(tmp17, []any{v11}) tmp19 := lang.Apply(tmp16, []any{tmp18, v14}) if lang.IsTruthy(tmp19) { tmp15 = v13 } else { - tmp20 := checkDerefVar(glojure_DOT_core_conj) + tmp20 := checkDerefVar(var_glojure_DOT_core_conj) tmp21, ok := lang.FieldOrMethod(v11, "Deref") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v11, "Deref"))) @@ -18084,10 +18830,11 @@ func LoadNS() { } return tmp15 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5061), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(5068), lang.NewKeyword("end-column"), int(37)) + tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5061), kw_column, int(8), kw_end_DASH_line, int(5068), kw_end_DASH_column, int(37)) tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) if err != nil { panic(err) @@ -18096,7 +18843,7 @@ func LoadNS() { } // end let return tmp5 }) - tmp4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5059), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(5068), lang.NewKeyword("end-column"), int(39)) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5059), kw_column, int(4), kw_end_DASH_line, int(5068), kw_end_DASH_column, int(39)) tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) if err != nil { panic(err) @@ -18112,23 +18859,17 @@ func LoadNS() { { // function step var v6 lang.FnFunc tmp5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v7 := args[0] _ = v7 v8 := args[1] _ = v8 var tmp9 lang.FnFunc tmp9 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var tmp10 lang.FnFunc tmp10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v11 := args[0] _ = v11 v12 := args[1] @@ -18140,7 +18881,7 @@ func LoadNS() { var v14 any = v11 _ = v14 // let binding "f" - tmp15 := checkDerefVar(glojure_DOT_core_nth) + tmp15 := checkDerefVar(var_glojure_DOT_core_nth) tmp16 := lang.Apply(tmp15, []any{v14, int64(0), nil}) var v17 any = tmp16 _ = v17 @@ -18150,7 +18891,7 @@ func LoadNS() { var tmp19 any { // let // let binding "temp__0__auto__" - tmp20 := checkDerefVar(glojure_DOT_core_seq) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) tmp21 := lang.Apply(tmp20, []any{v18}) var v22 any = tmp21 _ = v22 @@ -18162,10 +18903,10 @@ func LoadNS() { var v25 any = v22 _ = v25 var tmp26 any - tmp27 := checkDerefVar(glojure_DOT_core_contains_QMARK_) + tmp27 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) tmp28 := lang.Apply(tmp27, []any{v12, v17}) if lang.IsTruthy(tmp28) { - tmp30 := checkDerefVar(glojure_DOT_core_rest) + tmp30 := checkDerefVar(var_glojure_DOT_core_rest) tmp31 := lang.Apply(tmp30, []any{v25}) var tmp29 any = tmp31 var tmp32 any = v12 @@ -18173,10 +18914,10 @@ func LoadNS() { v12 = tmp32 goto recur_loop_877 } else { - tmp33 := checkDerefVar(glojure_DOT_core_cons) - tmp34 := checkDerefVar(glojure_DOT_core_rest) + tmp33 := checkDerefVar(var_glojure_DOT_core_cons) + tmp34 := checkDerefVar(var_glojure_DOT_core_rest) tmp35 := lang.Apply(tmp34, []any{v25}) - tmp36 := checkDerefVar(glojure_DOT_core_conj) + tmp36 := checkDerefVar(var_glojure_DOT_core_conj) tmp37 := lang.Apply(tmp36, []any{v12, v17}) tmp38 := lang.Apply(v6, []any{tmp35, tmp37}) tmp39 := lang.Apply(tmp33, []any{v17, tmp38}) @@ -18193,7 +18934,7 @@ func LoadNS() { } // end let return tmp13 }) - tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5072), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(5076), lang.NewKeyword("end-column"), int(66)) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5072), kw_column, int(20), kw_end_DASH_line, int(5076), kw_end_DASH_column, int(66)) tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) if err != nil { panic(err) @@ -18207,7 +18948,7 @@ func LoadNS() { v6 = tmp5 _ = v6 } - tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5070), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(5077), lang.NewKeyword("end-column"), int(29)) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5070), kw_column, int(15), kw_end_DASH_line, int(5077), kw_end_DASH_column, int(29)) tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) if err != nil { panic(err) @@ -18215,7 +18956,7 @@ func LoadNS() { var v8 any = tmp7 _ = v8 tmp9 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) - tmp10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5078), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(5078), lang.NewKeyword("end-column"), int(19)) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5078), kw_column, int(17), kw_end_DASH_line, int(5078), kw_end_DASH_column, int(19)) tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) if err != nil { panic(err) @@ -18225,10 +18966,11 @@ func LoadNS() { } // end let return tmp4 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -18237,7 +18979,7 @@ func LoadNS() { // distinct? { tmp1 := reflect.TypeOf(false) - tmp0 := lang.NewSymbol("distinct?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Returns true if no two of the arguments are =", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5664), lang.NewKeyword("end-line"), int(5664))).(*lang.Symbol) + tmp0 := sym_distinct_QMARK_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_doc, "Returns true if no two of the arguments are =", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(5664), kw_end_DASH_line, int(5664))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -18250,15 +18992,13 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6 := checkDerefVar(glojure_DOT_core_not) - tmp7 := checkDerefVar(glojure_DOT_core__EQ_) + tmp6 := checkDerefVar(var_glojure_DOT_core_not) + tmp7 := checkDerefVar(var_glojure_DOT_core__EQ_) tmp8 := lang.Apply(tmp7, []any{v4, v5}) tmp9 := lang.Apply(tmp6, []any{tmp8}) return tmp9 default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -18266,14 +19006,14 @@ func LoadNS() { var v6 any = lang.NewList(args[2:]...) _ = v6 var tmp7 any - tmp8 := checkDerefVar(glojure_DOT_core_not_EQ_) + tmp8 := checkDerefVar(var_glojure_DOT_core_not_EQ_) tmp9 := lang.Apply(tmp8, []any{v4, v5}) if lang.IsTruthy(tmp9) { var tmp10 any { // let // let binding "s" tmp11 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{v4, v5})) - tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5673), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(5673), lang.NewKeyword("end-column"), int(20)) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5673), kw_column, int(15), kw_end_DASH_line, int(5673), kw_end_DASH_column, int(20)) tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) if err != nil { panic(err) @@ -18287,17 +19027,17 @@ func LoadNS() { var v16 any = v15 _ = v16 // let binding "seq__101" - tmp17 := checkDerefVar(glojure_DOT_core_seq) + tmp17 := checkDerefVar(var_glojure_DOT_core_seq) tmp18 := lang.Apply(tmp17, []any{v16}) var v19 any = tmp18 _ = v19 // let binding "first__102" - tmp20 := checkDerefVar(glojure_DOT_core_first) + tmp20 := checkDerefVar(var_glojure_DOT_core_first) tmp21 := lang.Apply(tmp20, []any{v19}) var v22 any = tmp21 _ = v22 // let binding "seq__101" - tmp23 := checkDerefVar(glojure_DOT_core_next) + tmp23 := checkDerefVar(var_glojure_DOT_core_next) tmp24 := lang.Apply(tmp23, []any{v19}) var v25 any = tmp24 _ = v25 @@ -18328,17 +19068,17 @@ func LoadNS() { var v34 any = v31 _ = v34 // let binding "seq__104" - tmp35 := checkDerefVar(glojure_DOT_core_seq) + tmp35 := checkDerefVar(var_glojure_DOT_core_seq) tmp36 := lang.Apply(tmp35, []any{v34}) var v37 any = tmp36 _ = v37 // let binding "first__105" - tmp38 := checkDerefVar(glojure_DOT_core_first) + tmp38 := checkDerefVar(var_glojure_DOT_core_first) tmp39 := lang.Apply(tmp38, []any{v37}) var v40 any = tmp39 _ = v40 // let binding "seq__104" - tmp41 := checkDerefVar(glojure_DOT_core_next) + tmp41 := checkDerefVar(var_glojure_DOT_core_next) tmp42 := lang.Apply(tmp41, []any{v37}) var v43 any = tmp42 _ = v43 @@ -18354,12 +19094,12 @@ func LoadNS() { var tmp47 any if lang.IsTruthy(v46) { var tmp48 any - tmp49 := checkDerefVar(glojure_DOT_core_contains_QMARK_) + tmp49 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) tmp50 := lang.Apply(tmp49, []any{v33, v44}) if lang.IsTruthy(tmp50) { tmp48 = false } else { - tmp52 := checkDerefVar(glojure_DOT_core_conj) + tmp52 := checkDerefVar(var_glojure_DOT_core_conj) tmp53 := lang.Apply(tmp52, []any{v33, v44}) var tmp51 any = tmp53 var tmp54 any = v45 @@ -18387,7 +19127,7 @@ func LoadNS() { } }) tmp4 := reflect.TypeOf(false) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -18395,14 +19135,14 @@ func LoadNS() { } // doall { - tmp0 := lang.NewSymbol("doall").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "When lazy sequences are produced via functions that have side\n effects, any effects other than those needed to produce the first\n element in the seq do not occur until the seq is consumed. doall can\n be used to force any effects. Walks through the successive nexts of\n the seq, retains the head and returns it, thus causing the entire\n seq to reside in memory at one time.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3131), lang.NewKeyword("end-line"), int(3131))).(*lang.Symbol) + tmp0 := sym_doall.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll), lang.NewVector(sym_n, sym_coll)), kw_doc, "When lazy sequences are produced via functions that have side\n effects, any effects other than those needed to produce the first\n element in the seq do not occur until the seq is consumed. doall can\n be used to force any effects. Walks through the successive nexts of\n the seq, retains the head and returns it, thus causing the entire\n seq to reside in memory at one time.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3131), kw_end_DASH_line, int(3131))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_dorun) + tmp4 := checkDerefVar(var_glojure_DOT_core_dorun) tmp5 := lang.Apply(tmp4, []any{v3}) _ = tmp5 return v3 @@ -18411,15 +19151,16 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_dorun) + tmp5 := checkDerefVar(var_glojure_DOT_core_dorun) tmp6 := lang.Apply(tmp5, []any{v3, v4}) _ = tmp6 return v4 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -18427,7 +19168,7 @@ func LoadNS() { } // dorun { - tmp0 := lang.NewSymbol("dorun").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "When lazy sequences are produced via functions that have side\n effects, any effects other than those needed to produce the first\n element in the seq do not occur until the seq is consumed. dorun can\n be used to force any effects. Walks through the successive nexts of\n the seq, does not retain the head and returns nil.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3116), lang.NewKeyword("end-line"), int(3116))).(*lang.Symbol) + tmp0 := sym_dorun.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll), lang.NewVector(sym_n, sym_coll)), kw_doc, "When lazy sequences are produced via functions that have side\n effects, any effects other than those needed to produce the first\n element in the seq do not occur until the seq is consumed. dorun can\n be used to force any effects. Walks through the successive nexts of\n the seq, does not retain the head and returns nil.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3116), kw_end_DASH_line, int(3116))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -18438,7 +19179,7 @@ func LoadNS() { var tmp4 any { // let // let binding "temp__0__auto__" - tmp5 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) tmp6 := lang.Apply(tmp5, []any{v3}) var v7 any = tmp6 _ = v7 @@ -18449,7 +19190,7 @@ func LoadNS() { // let binding "s" var v10 any = v7 _ = v10 - tmp12 := checkDerefVar(glojure_DOT_core_next) + tmp12 := checkDerefVar(var_glojure_DOT_core_next) tmp13 := lang.Apply(tmp12, []any{v10}) var tmp11 any = tmp13 v3 = tmp11 @@ -18471,13 +19212,13 @@ func LoadNS() { var tmp6 any { // let // let binding "and__0__auto__" - tmp7 := checkDerefVar(glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) tmp8 := lang.Apply(tmp7, []any{v4}) var v9 any = tmp8 _ = v9 var tmp10 any if lang.IsTruthy(v9) { - tmp11 := checkDerefVar(glojure_DOT_core_pos_QMARK_) + tmp11 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) tmp12 := lang.Apply(tmp11, []any{v3}) tmp10 = tmp12 } else { @@ -18486,10 +19227,10 @@ func LoadNS() { tmp6 = tmp10 } // end let if lang.IsTruthy(tmp6) { - tmp8 := checkDerefVar(glojure_DOT_core_dec) + tmp8 := checkDerefVar(var_glojure_DOT_core_dec) tmp9 := lang.Apply(tmp8, []any{v3}) var tmp7 any = tmp9 - tmp11 := checkDerefVar(glojure_DOT_core_next) + tmp11 := checkDerefVar(var_glojure_DOT_core_next) tmp12 := lang.Apply(tmp11, []any{v4}) var tmp10 any = tmp12 v3 = tmp7 @@ -18499,10 +19240,11 @@ func LoadNS() { } return tmp5 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -18510,14 +19252,12 @@ func LoadNS() { } // doseq { - tmp0 := lang.NewSymbol("doseq").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("seq-exprs"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Repeatedly executes body (presumably for side-effects) with\n bindings and filtering as provided by \"for\". Does not retain\n the head of the sequence. Returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3209), lang.NewKeyword("end-line"), int(3209))).(*lang.Symbol) + tmp0 := sym_doseq.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_seq_DASH_exprs, sym__AMP_, sym_body)), kw_doc, "Repeatedly executes body (presumably for side-effects) with\n bindings and filtering as provided by \"for\". Does not retain\n the head of the sequence. Returns nil.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(11), kw_line, int(3209), kw_end_DASH_line, int(3209))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -18527,36 +19267,36 @@ func LoadNS() { var v6 any = lang.NewList(args[3:]...) _ = v6 var tmp7 any - tmp8 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp8 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) tmp9 := lang.Apply(tmp8, []any{v5}) if lang.IsTruthy(tmp9) { } else { - tmp10 := checkDerefVar(glojure_DOT_core_str) - tmp11 := checkDerefVar(glojure_DOT_core_first) + tmp10 := checkDerefVar(var_glojure_DOT_core_str) + tmp11 := checkDerefVar(var_glojure_DOT_core_first) tmp12 := lang.Apply(tmp11, []any{v3}) - tmp13 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) - tmp14 := checkDerefVar(glojure_DOT_core_meta) + tmp13 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp14 := checkDerefVar(var_glojure_DOT_core_meta) tmp15 := lang.Apply(tmp14, []any{v3}) - tmp16 := lang.Apply(lang.NewKeyword("line"), []any{tmp15}) + tmp16 := lang.Apply(kw_line, []any{tmp15}) tmp17 := lang.Apply(tmp10, []any{tmp12, " requires ", "a vector for its binding", " in ", tmp13, ":", tmp16}) tmp18 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp17}) panic(tmp18) } _ = tmp7 var tmp19 any - tmp20 := checkDerefVar(glojure_DOT_core_even_QMARK_) - tmp21 := checkDerefVar(glojure_DOT_core_count) + tmp20 := checkDerefVar(var_glojure_DOT_core_even_QMARK_) + tmp21 := checkDerefVar(var_glojure_DOT_core_count) tmp22 := lang.Apply(tmp21, []any{v5}) tmp23 := lang.Apply(tmp20, []any{tmp22}) if lang.IsTruthy(tmp23) { } else { - tmp24 := checkDerefVar(glojure_DOT_core_str) - tmp25 := checkDerefVar(glojure_DOT_core_first) + tmp24 := checkDerefVar(var_glojure_DOT_core_str) + tmp25 := checkDerefVar(var_glojure_DOT_core_first) tmp26 := lang.Apply(tmp25, []any{v3}) - tmp27 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) - tmp28 := checkDerefVar(glojure_DOT_core_meta) + tmp27 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp28 := checkDerefVar(var_glojure_DOT_core_meta) tmp29 := lang.Apply(tmp28, []any{v3}) - tmp30 := lang.Apply(lang.NewKeyword("line"), []any{tmp29}) + tmp30 := lang.Apply(kw_line, []any{tmp29}) tmp31 := lang.Apply(tmp24, []any{tmp26, " requires ", "an even number of forms in binding vector", " in ", tmp27, ":", tmp30}) tmp32 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp31}) panic(tmp32) @@ -18569,25 +19309,23 @@ func LoadNS() { { // function step var v35 lang.FnFunc tmp34 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v36 := args[0] _ = v36 v37 := args[1] _ = v37 var tmp38 any - tmp39 := checkDerefVar(glojure_DOT_core_not) + tmp39 := checkDerefVar(var_glojure_DOT_core_not) tmp40 := lang.Apply(tmp39, []any{v37}) if lang.IsTruthy(tmp40) { - tmp41 := checkDerefVar(glojure_DOT_core_seq) - tmp42 := checkDerefVar(glojure_DOT_core_concat) - tmp43 := checkDerefVar(glojure_DOT_core_list) - tmp44 := lang.Apply(tmp43, []any{lang.NewSymbol("do")}) + tmp41 := checkDerefVar(var_glojure_DOT_core_seq) + tmp42 := checkDerefVar(var_glojure_DOT_core_concat) + tmp43 := checkDerefVar(var_glojure_DOT_core_list) + tmp44 := lang.Apply(tmp43, []any{sym_do}) tmp45 := lang.Apply(tmp42, []any{tmp44, v6}) tmp46 := lang.Apply(tmp41, []any{tmp45}) tmp47 := lang.NewVector(true, tmp46) - tmp48 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3220), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(3220), lang.NewKeyword("end-column"), int(36)) + tmp48 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3220), kw_column, int(18), kw_end_DASH_line, int(3220), kw_end_DASH_column, int(36)) tmp49, err := lang.WithMeta(tmp47, tmp48.(lang.IPersistentMap)) if err != nil { panic(err) @@ -18597,23 +19335,23 @@ func LoadNS() { var tmp50 any { // let // let binding "k" - tmp51 := checkDerefVar(glojure_DOT_core_first) + tmp51 := checkDerefVar(var_glojure_DOT_core_first) tmp52 := lang.Apply(tmp51, []any{v37}) var v53 any = tmp52 _ = v53 // let binding "v" - tmp54 := checkDerefVar(glojure_DOT_core_second) + tmp54 := checkDerefVar(var_glojure_DOT_core_second) tmp55 := lang.Apply(tmp54, []any{v37}) var v56 any = tmp55 _ = v56 var tmp57 any - tmp58 := checkDerefVar(glojure_DOT_core_keyword_QMARK_) + tmp58 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) tmp59 := lang.Apply(tmp58, []any{v53}) if lang.IsTruthy(tmp59) { var tmp60 any { // let // let binding "steppair" - tmp61 := checkDerefVar(glojure_DOT_core_nnext) + tmp61 := checkDerefVar(var_glojure_DOT_core_nnext) tmp62 := lang.Apply(tmp61, []any{v37}) tmp63 := lang.Apply(v35, []any{v36, tmp62}) var v64 any = tmp63 @@ -18627,21 +19365,21 @@ func LoadNS() { var v68 any = tmp67 _ = v68 var tmp69 any - tmp70 := checkDerefVar(glojure_DOT_core__EQ_) - tmp71 := lang.Apply(tmp70, []any{v53, lang.NewKeyword("let")}) + tmp70 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp71 := lang.Apply(tmp70, []any{v53, kw_let}) if lang.IsTruthy(tmp71) { - tmp72 := checkDerefVar(glojure_DOT_core_seq) - tmp73 := checkDerefVar(glojure_DOT_core_concat) - tmp74 := checkDerefVar(glojure_DOT_core_list) - tmp75 := lang.Apply(tmp74, []any{lang.NewSymbol("glojure.core/let")}) - tmp76 := checkDerefVar(glojure_DOT_core_list) + tmp72 := checkDerefVar(var_glojure_DOT_core_seq) + tmp73 := checkDerefVar(var_glojure_DOT_core_concat) + tmp74 := checkDerefVar(var_glojure_DOT_core_list) + tmp75 := lang.Apply(tmp74, []any{sym_glojure_DOT_core_SLASH_let}) + tmp76 := checkDerefVar(var_glojure_DOT_core_list) tmp77 := lang.Apply(tmp76, []any{v56}) - tmp78 := checkDerefVar(glojure_DOT_core_list) + tmp78 := checkDerefVar(var_glojure_DOT_core_list) tmp79 := lang.Apply(tmp78, []any{v68}) tmp80 := lang.Apply(tmp73, []any{tmp75, tmp77, tmp79}) tmp81 := lang.Apply(tmp72, []any{tmp80}) tmp82 := lang.NewVector(v66, tmp81) - tmp83 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3228), lang.NewKeyword("column"), int(37), lang.NewKeyword("end-line"), int(3228), lang.NewKeyword("end-column"), int(64)) + tmp83 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3228), kw_column, int(37), kw_end_DASH_line, int(3228), kw_end_DASH_column, int(64)) tmp84, err := lang.WithMeta(tmp82, tmp83.(lang.IPersistentMap)) if err != nil { panic(err) @@ -18649,21 +19387,21 @@ func LoadNS() { tmp69 = tmp84 } else { var tmp85 any - tmp86 := checkDerefVar(glojure_DOT_core__EQ_) - tmp87 := lang.Apply(tmp86, []any{v53, lang.NewKeyword("while")}) + tmp86 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp87 := lang.Apply(tmp86, []any{v53, kw_while}) if lang.IsTruthy(tmp87) { - tmp88 := checkDerefVar(glojure_DOT_core_seq) - tmp89 := checkDerefVar(glojure_DOT_core_concat) - tmp90 := checkDerefVar(glojure_DOT_core_list) - tmp91 := lang.Apply(tmp90, []any{lang.NewSymbol("glojure.core/when")}) - tmp92 := checkDerefVar(glojure_DOT_core_list) + tmp88 := checkDerefVar(var_glojure_DOT_core_seq) + tmp89 := checkDerefVar(var_glojure_DOT_core_concat) + tmp90 := checkDerefVar(var_glojure_DOT_core_list) + tmp91 := lang.Apply(tmp90, []any{sym_glojure_DOT_core_SLASH_when}) + tmp92 := checkDerefVar(var_glojure_DOT_core_list) tmp93 := lang.Apply(tmp92, []any{v56}) - tmp94 := checkDerefVar(glojure_DOT_core_list) + tmp94 := checkDerefVar(var_glojure_DOT_core_list) tmp95 := lang.Apply(tmp94, []any{v68}) var tmp96 any if lang.IsTruthy(v66) { tmp97 := lang.NewVector(v36) - tmp98 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3231), lang.NewKeyword("column"), int(65), lang.NewKeyword("end-line"), int(3231), lang.NewKeyword("end-column"), int(73)) + tmp98 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3231), kw_column, int(65), kw_end_DASH_line, int(3231), kw_end_DASH_column, int(73)) tmp99, err := lang.WithMeta(tmp97, tmp98.(lang.IPersistentMap)) if err != nil { panic(err) @@ -18674,7 +19412,7 @@ func LoadNS() { tmp100 := lang.Apply(tmp89, []any{tmp91, tmp93, tmp95, tmp96}) tmp101 := lang.Apply(tmp88, []any{tmp100}) tmp102 := lang.NewVector(false, tmp101) - tmp103 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3229), lang.NewKeyword("column"), int(39), lang.NewKeyword("end-line"), int(3231), lang.NewKeyword("end-column"), int(76)) + tmp103 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3229), kw_column, int(39), kw_end_DASH_line, int(3231), kw_end_DASH_column, int(76)) tmp104, err := lang.WithMeta(tmp102, tmp103.(lang.IPersistentMap)) if err != nil { panic(err) @@ -18682,26 +19420,26 @@ func LoadNS() { tmp85 = tmp104 } else { var tmp105 any - tmp106 := checkDerefVar(glojure_DOT_core__EQ_) - tmp107 := lang.Apply(tmp106, []any{v53, lang.NewKeyword("when")}) + tmp106 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp107 := lang.Apply(tmp106, []any{v53, kw_when}) if lang.IsTruthy(tmp107) { - tmp108 := checkDerefVar(glojure_DOT_core_seq) - tmp109 := checkDerefVar(glojure_DOT_core_concat) - tmp110 := checkDerefVar(glojure_DOT_core_list) - tmp111 := lang.Apply(tmp110, []any{lang.NewSymbol("if")}) - tmp112 := checkDerefVar(glojure_DOT_core_list) + tmp108 := checkDerefVar(var_glojure_DOT_core_seq) + tmp109 := checkDerefVar(var_glojure_DOT_core_concat) + tmp110 := checkDerefVar(var_glojure_DOT_core_list) + tmp111 := lang.Apply(tmp110, []any{sym_if}) + tmp112 := checkDerefVar(var_glojure_DOT_core_list) tmp113 := lang.Apply(tmp112, []any{v56}) - tmp114 := checkDerefVar(glojure_DOT_core_list) - tmp115 := checkDerefVar(glojure_DOT_core_seq) - tmp116 := checkDerefVar(glojure_DOT_core_concat) - tmp117 := checkDerefVar(glojure_DOT_core_list) - tmp118 := lang.Apply(tmp117, []any{lang.NewSymbol("do")}) - tmp119 := checkDerefVar(glojure_DOT_core_list) + tmp114 := checkDerefVar(var_glojure_DOT_core_list) + tmp115 := checkDerefVar(var_glojure_DOT_core_seq) + tmp116 := checkDerefVar(var_glojure_DOT_core_concat) + tmp117 := checkDerefVar(var_glojure_DOT_core_list) + tmp118 := lang.Apply(tmp117, []any{sym_do}) + tmp119 := checkDerefVar(var_glojure_DOT_core_list) tmp120 := lang.Apply(tmp119, []any{v68}) var tmp121 any if lang.IsTruthy(v66) { tmp122 := lang.NewVector(v36) - tmp123 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3235), lang.NewKeyword("column"), int(66), lang.NewKeyword("end-line"), int(3235), lang.NewKeyword("end-column"), int(74)) + tmp123 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3235), kw_column, int(66), kw_end_DASH_line, int(3235), kw_end_DASH_column, int(74)) tmp124, err := lang.WithMeta(tmp122, tmp123.(lang.IPersistentMap)) if err != nil { panic(err) @@ -18712,12 +19450,12 @@ func LoadNS() { tmp125 := lang.Apply(tmp116, []any{tmp118, tmp120, tmp121}) tmp126 := lang.Apply(tmp115, []any{tmp125}) tmp127 := lang.Apply(tmp114, []any{tmp126}) - tmp128 := checkDerefVar(glojure_DOT_core_list) + tmp128 := checkDerefVar(var_glojure_DOT_core_list) tmp129 := lang.Apply(tmp128, []any{v36}) tmp130 := lang.Apply(tmp109, []any{tmp111, tmp113, tmp127, tmp129}) tmp131 := lang.Apply(tmp108, []any{tmp130}) tmp132 := lang.NewVector(false, tmp131) - tmp133 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3232), lang.NewKeyword("column"), int(38), lang.NewKeyword("end-line"), int(3236), lang.NewKeyword("end-column"), int(57)) + tmp133 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3232), kw_column, int(38), kw_end_DASH_line, int(3236), kw_end_DASH_column, int(57)) tmp134, err := lang.WithMeta(tmp132, tmp133.(lang.IPersistentMap)) if err != nil { panic(err) @@ -18736,16 +19474,16 @@ func LoadNS() { var tmp61 any { // let // let binding "seq-" - tmp62 := checkDerefVar(glojure_DOT_core_gensym) + tmp62 := checkDerefVar(var_glojure_DOT_core_gensym) tmp63 := lang.Apply(tmp62, []any{"seq_"}) var v64 any = tmp63 _ = v64 // let binding "chunk-" - tmp65 := checkDerefVar(glojure_DOT_core_with_meta) - tmp66 := checkDerefVar(glojure_DOT_core_gensym) + tmp65 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp66 := checkDerefVar(var_glojure_DOT_core_gensym) tmp67 := lang.Apply(tmp66, []any{"chunk_"}) - tmp68 := lang.NewMap(lang.NewKeyword("tag"), lang.NewSymbol("glojure.lang.IChunk")) - tmp69 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3239), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(3239), lang.NewKeyword("end-column"), int(72)) + tmp68 := lang.NewMap(kw_tag, sym_glojure_DOT_lang_DOT_IChunk) + tmp69 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3239), kw_column, int(46), kw_end_DASH_line, int(3239), kw_end_DASH_column, int(72)) tmp70, err := lang.WithMeta(tmp68, tmp69.(lang.IPersistentMap)) if err != nil { panic(err) @@ -18754,42 +19492,42 @@ func LoadNS() { var v72 any = tmp71 _ = v72 // let binding "count-" - tmp73 := checkDerefVar(glojure_DOT_core_gensym) + tmp73 := checkDerefVar(var_glojure_DOT_core_gensym) tmp74 := lang.Apply(tmp73, []any{"count_"}) var v75 any = tmp74 _ = v75 // let binding "i-" - tmp76 := checkDerefVar(glojure_DOT_core_gensym) + tmp76 := checkDerefVar(var_glojure_DOT_core_gensym) tmp77 := lang.Apply(tmp76, []any{"i_"}) var v78 any = tmp77 _ = v78 // let binding "recform" - tmp79 := checkDerefVar(glojure_DOT_core_seq) - tmp80 := checkDerefVar(glojure_DOT_core_concat) - tmp81 := checkDerefVar(glojure_DOT_core_list) - tmp82 := lang.Apply(tmp81, []any{lang.NewSymbol("recur")}) - tmp83 := checkDerefVar(glojure_DOT_core_list) - tmp84 := checkDerefVar(glojure_DOT_core_seq) - tmp85 := checkDerefVar(glojure_DOT_core_concat) - tmp86 := checkDerefVar(glojure_DOT_core_list) - tmp87 := lang.Apply(tmp86, []any{lang.NewSymbol("glojure.core/next")}) - tmp88 := checkDerefVar(glojure_DOT_core_list) + tmp79 := checkDerefVar(var_glojure_DOT_core_seq) + tmp80 := checkDerefVar(var_glojure_DOT_core_concat) + tmp81 := checkDerefVar(var_glojure_DOT_core_list) + tmp82 := lang.Apply(tmp81, []any{sym_recur}) + tmp83 := checkDerefVar(var_glojure_DOT_core_list) + tmp84 := checkDerefVar(var_glojure_DOT_core_seq) + tmp85 := checkDerefVar(var_glojure_DOT_core_concat) + tmp86 := checkDerefVar(var_glojure_DOT_core_list) + tmp87 := lang.Apply(tmp86, []any{sym_glojure_DOT_core_SLASH_next}) + tmp88 := checkDerefVar(var_glojure_DOT_core_list) tmp89 := lang.Apply(tmp88, []any{v64}) tmp90 := lang.Apply(tmp85, []any{tmp87, tmp89}) tmp91 := lang.Apply(tmp84, []any{tmp90}) tmp92 := lang.Apply(tmp83, []any{tmp91}) - tmp93 := checkDerefVar(glojure_DOT_core_list) + tmp93 := checkDerefVar(var_glojure_DOT_core_list) tmp94 := lang.Apply(tmp93, []any{nil}) - tmp95 := checkDerefVar(glojure_DOT_core_list) + tmp95 := checkDerefVar(var_glojure_DOT_core_list) tmp96 := lang.Apply(tmp95, []any{int64(0)}) - tmp97 := checkDerefVar(glojure_DOT_core_list) + tmp97 := checkDerefVar(var_glojure_DOT_core_list) tmp98 := lang.Apply(tmp97, []any{int64(0)}) tmp99 := lang.Apply(tmp80, []any{tmp82, tmp92, tmp94, tmp96, tmp98}) tmp100 := lang.Apply(tmp79, []any{tmp99}) var v101 any = tmp100 _ = v101 // let binding "steppair" - tmp102 := checkDerefVar(glojure_DOT_core_nnext) + tmp102 := checkDerefVar(var_glojure_DOT_core_nnext) tmp103 := lang.Apply(tmp102, []any{v37}) tmp104 := lang.Apply(v35, []any{v101, tmp103}) var v105 any = tmp104 @@ -18803,22 +19541,22 @@ func LoadNS() { var v109 any = tmp108 _ = v109 // let binding "recform-chunk" - tmp110 := checkDerefVar(glojure_DOT_core_seq) - tmp111 := checkDerefVar(glojure_DOT_core_concat) - tmp112 := checkDerefVar(glojure_DOT_core_list) - tmp113 := lang.Apply(tmp112, []any{lang.NewSymbol("recur")}) - tmp114 := checkDerefVar(glojure_DOT_core_list) + tmp110 := checkDerefVar(var_glojure_DOT_core_seq) + tmp111 := checkDerefVar(var_glojure_DOT_core_concat) + tmp112 := checkDerefVar(var_glojure_DOT_core_list) + tmp113 := lang.Apply(tmp112, []any{sym_recur}) + tmp114 := checkDerefVar(var_glojure_DOT_core_list) tmp115 := lang.Apply(tmp114, []any{v64}) - tmp116 := checkDerefVar(glojure_DOT_core_list) + tmp116 := checkDerefVar(var_glojure_DOT_core_list) tmp117 := lang.Apply(tmp116, []any{v72}) - tmp118 := checkDerefVar(glojure_DOT_core_list) + tmp118 := checkDerefVar(var_glojure_DOT_core_list) tmp119 := lang.Apply(tmp118, []any{v75}) - tmp120 := checkDerefVar(glojure_DOT_core_list) - tmp121 := checkDerefVar(glojure_DOT_core_seq) - tmp122 := checkDerefVar(glojure_DOT_core_concat) - tmp123 := checkDerefVar(glojure_DOT_core_list) - tmp124 := lang.Apply(tmp123, []any{lang.NewSymbol("glojure.core/unchecked-inc")}) - tmp125 := checkDerefVar(glojure_DOT_core_list) + tmp120 := checkDerefVar(var_glojure_DOT_core_list) + tmp121 := checkDerefVar(var_glojure_DOT_core_seq) + tmp122 := checkDerefVar(var_glojure_DOT_core_concat) + tmp123 := checkDerefVar(var_glojure_DOT_core_list) + tmp124 := lang.Apply(tmp123, []any{sym_glojure_DOT_core_SLASH_unchecked_DASH_inc}) + tmp125 := checkDerefVar(var_glojure_DOT_core_list) tmp126 := lang.Apply(tmp125, []any{v78}) tmp127 := lang.Apply(tmp122, []any{tmp124, tmp126}) tmp128 := lang.Apply(tmp121, []any{tmp127}) @@ -18828,7 +19566,7 @@ func LoadNS() { var v132 any = tmp131 _ = v132 // let binding "steppair-chunk" - tmp133 := checkDerefVar(glojure_DOT_core_nnext) + tmp133 := checkDerefVar(var_glojure_DOT_core_nnext) tmp134 := lang.Apply(tmp133, []any{v37}) tmp135 := lang.Apply(v35, []any{v132, tmp134}) var v136 any = tmp135 @@ -18837,80 +19575,80 @@ func LoadNS() { tmp137 := lang.Apply(v136, []any{int64(1)}) var v138 any = tmp137 _ = v138 - tmp139 := checkDerefVar(glojure_DOT_core_seq) - tmp140 := checkDerefVar(glojure_DOT_core_concat) - tmp141 := checkDerefVar(glojure_DOT_core_list) - tmp142 := lang.Apply(tmp141, []any{lang.NewSymbol("glojure.core/loop")}) - tmp143 := checkDerefVar(glojure_DOT_core_list) - tmp144 := checkDerefVar(glojure_DOT_core_apply) - tmp145 := checkDerefVar(glojure_DOT_core_vector) - tmp146 := checkDerefVar(glojure_DOT_core_seq) - tmp147 := checkDerefVar(glojure_DOT_core_concat) - tmp148 := checkDerefVar(glojure_DOT_core_list) + tmp139 := checkDerefVar(var_glojure_DOT_core_seq) + tmp140 := checkDerefVar(var_glojure_DOT_core_concat) + tmp141 := checkDerefVar(var_glojure_DOT_core_list) + tmp142 := lang.Apply(tmp141, []any{sym_glojure_DOT_core_SLASH_loop}) + tmp143 := checkDerefVar(var_glojure_DOT_core_list) + tmp144 := checkDerefVar(var_glojure_DOT_core_apply) + tmp145 := checkDerefVar(var_glojure_DOT_core_vector) + tmp146 := checkDerefVar(var_glojure_DOT_core_seq) + tmp147 := checkDerefVar(var_glojure_DOT_core_concat) + tmp148 := checkDerefVar(var_glojure_DOT_core_list) tmp149 := lang.Apply(tmp148, []any{v64}) - tmp150 := checkDerefVar(glojure_DOT_core_list) - tmp151 := checkDerefVar(glojure_DOT_core_seq) - tmp152 := checkDerefVar(glojure_DOT_core_concat) - tmp153 := checkDerefVar(glojure_DOT_core_list) - tmp154 := lang.Apply(tmp153, []any{lang.NewSymbol("glojure.core/seq")}) - tmp155 := checkDerefVar(glojure_DOT_core_list) + tmp150 := checkDerefVar(var_glojure_DOT_core_list) + tmp151 := checkDerefVar(var_glojure_DOT_core_seq) + tmp152 := checkDerefVar(var_glojure_DOT_core_concat) + tmp153 := checkDerefVar(var_glojure_DOT_core_list) + tmp154 := lang.Apply(tmp153, []any{sym_glojure_DOT_core_SLASH_seq}) + tmp155 := checkDerefVar(var_glojure_DOT_core_list) tmp156 := lang.Apply(tmp155, []any{v56}) tmp157 := lang.Apply(tmp152, []any{tmp154, tmp156}) tmp158 := lang.Apply(tmp151, []any{tmp157}) tmp159 := lang.Apply(tmp150, []any{tmp158}) - tmp160 := checkDerefVar(glojure_DOT_core_list) + tmp160 := checkDerefVar(var_glojure_DOT_core_list) tmp161 := lang.Apply(tmp160, []any{v72}) - tmp162 := checkDerefVar(glojure_DOT_core_list) + tmp162 := checkDerefVar(var_glojure_DOT_core_list) tmp163 := lang.Apply(tmp162, []any{nil}) - tmp164 := checkDerefVar(glojure_DOT_core_list) + tmp164 := checkDerefVar(var_glojure_DOT_core_list) tmp165 := lang.Apply(tmp164, []any{v75}) - tmp166 := checkDerefVar(glojure_DOT_core_list) + tmp166 := checkDerefVar(var_glojure_DOT_core_list) tmp167 := lang.Apply(tmp166, []any{int64(0)}) - tmp168 := checkDerefVar(glojure_DOT_core_list) + tmp168 := checkDerefVar(var_glojure_DOT_core_list) tmp169 := lang.Apply(tmp168, []any{v78}) - tmp170 := checkDerefVar(glojure_DOT_core_list) + tmp170 := checkDerefVar(var_glojure_DOT_core_list) tmp171 := lang.Apply(tmp170, []any{int64(0)}) tmp172 := lang.Apply(tmp147, []any{tmp149, tmp159, tmp161, tmp163, tmp165, tmp167, tmp169, tmp171}) tmp173 := lang.Apply(tmp146, []any{tmp172}) tmp174 := lang.Apply(tmp144, []any{tmp145, tmp173}) tmp175 := lang.Apply(tmp143, []any{tmp174}) - tmp176 := checkDerefVar(glojure_DOT_core_list) - tmp177 := checkDerefVar(glojure_DOT_core_seq) - tmp178 := checkDerefVar(glojure_DOT_core_concat) - tmp179 := checkDerefVar(glojure_DOT_core_list) - tmp180 := lang.Apply(tmp179, []any{lang.NewSymbol("if")}) - tmp181 := checkDerefVar(glojure_DOT_core_list) - tmp182 := checkDerefVar(glojure_DOT_core_seq) - tmp183 := checkDerefVar(glojure_DOT_core_concat) - tmp184 := checkDerefVar(glojure_DOT_core_list) - tmp185 := lang.Apply(tmp184, []any{lang.NewSymbol("glojure.core/<")}) - tmp186 := checkDerefVar(glojure_DOT_core_list) + tmp176 := checkDerefVar(var_glojure_DOT_core_list) + tmp177 := checkDerefVar(var_glojure_DOT_core_seq) + tmp178 := checkDerefVar(var_glojure_DOT_core_concat) + tmp179 := checkDerefVar(var_glojure_DOT_core_list) + tmp180 := lang.Apply(tmp179, []any{sym_if}) + tmp181 := checkDerefVar(var_glojure_DOT_core_list) + tmp182 := checkDerefVar(var_glojure_DOT_core_seq) + tmp183 := checkDerefVar(var_glojure_DOT_core_concat) + tmp184 := checkDerefVar(var_glojure_DOT_core_list) + tmp185 := lang.Apply(tmp184, []any{sym_glojure_DOT_core_SLASH__LT_}) + tmp186 := checkDerefVar(var_glojure_DOT_core_list) tmp187 := lang.Apply(tmp186, []any{v78}) - tmp188 := checkDerefVar(glojure_DOT_core_list) + tmp188 := checkDerefVar(var_glojure_DOT_core_list) tmp189 := lang.Apply(tmp188, []any{v75}) tmp190 := lang.Apply(tmp183, []any{tmp185, tmp187, tmp189}) tmp191 := lang.Apply(tmp182, []any{tmp190}) tmp192 := lang.Apply(tmp181, []any{tmp191}) - tmp193 := checkDerefVar(glojure_DOT_core_list) - tmp194 := checkDerefVar(glojure_DOT_core_seq) - tmp195 := checkDerefVar(glojure_DOT_core_concat) - tmp196 := checkDerefVar(glojure_DOT_core_list) - tmp197 := lang.Apply(tmp196, []any{lang.NewSymbol("glojure.core/let")}) - tmp198 := checkDerefVar(glojure_DOT_core_list) - tmp199 := checkDerefVar(glojure_DOT_core_apply) - tmp200 := checkDerefVar(glojure_DOT_core_vector) - tmp201 := checkDerefVar(glojure_DOT_core_seq) - tmp202 := checkDerefVar(glojure_DOT_core_concat) - tmp203 := checkDerefVar(glojure_DOT_core_list) + tmp193 := checkDerefVar(var_glojure_DOT_core_list) + tmp194 := checkDerefVar(var_glojure_DOT_core_seq) + tmp195 := checkDerefVar(var_glojure_DOT_core_concat) + tmp196 := checkDerefVar(var_glojure_DOT_core_list) + tmp197 := lang.Apply(tmp196, []any{sym_glojure_DOT_core_SLASH_let}) + tmp198 := checkDerefVar(var_glojure_DOT_core_list) + tmp199 := checkDerefVar(var_glojure_DOT_core_apply) + tmp200 := checkDerefVar(var_glojure_DOT_core_vector) + tmp201 := checkDerefVar(var_glojure_DOT_core_seq) + tmp202 := checkDerefVar(var_glojure_DOT_core_concat) + tmp203 := checkDerefVar(var_glojure_DOT_core_list) tmp204 := lang.Apply(tmp203, []any{v53}) - tmp205 := checkDerefVar(glojure_DOT_core_list) - tmp206 := checkDerefVar(glojure_DOT_core_seq) - tmp207 := checkDerefVar(glojure_DOT_core_concat) - tmp208 := checkDerefVar(glojure_DOT_core_list) - tmp209 := lang.Apply(tmp208, []any{lang.NewSymbol(".nth")}) - tmp210 := checkDerefVar(glojure_DOT_core_list) + tmp205 := checkDerefVar(var_glojure_DOT_core_list) + tmp206 := checkDerefVar(var_glojure_DOT_core_seq) + tmp207 := checkDerefVar(var_glojure_DOT_core_concat) + tmp208 := checkDerefVar(var_glojure_DOT_core_list) + tmp209 := lang.Apply(tmp208, []any{sym__DOT_nth}) + tmp210 := checkDerefVar(var_glojure_DOT_core_list) tmp211 := lang.Apply(tmp210, []any{v72}) - tmp212 := checkDerefVar(glojure_DOT_core_list) + tmp212 := checkDerefVar(var_glojure_DOT_core_list) tmp213 := lang.Apply(tmp212, []any{v78}) tmp214 := lang.Apply(tmp207, []any{tmp209, tmp211, tmp213}) tmp215 := lang.Apply(tmp206, []any{tmp214}) @@ -18919,12 +19657,12 @@ func LoadNS() { tmp218 := lang.Apply(tmp201, []any{tmp217}) tmp219 := lang.Apply(tmp199, []any{tmp200, tmp218}) tmp220 := lang.Apply(tmp198, []any{tmp219}) - tmp221 := checkDerefVar(glojure_DOT_core_list) + tmp221 := checkDerefVar(var_glojure_DOT_core_list) tmp222 := lang.Apply(tmp221, []any{v138}) var tmp223 any if lang.IsTruthy(v107) { tmp224 := lang.NewVector(v132) - tmp225 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3256), lang.NewKeyword("column"), int(48), lang.NewKeyword("end-line"), int(3256), lang.NewKeyword("end-column"), int(62)) + tmp225 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3256), kw_column, int(48), kw_end_DASH_line, int(3256), kw_end_DASH_column, int(62)) tmp226, err := lang.WithMeta(tmp224, tmp225.(lang.IPersistentMap)) if err != nil { panic(err) @@ -18935,24 +19673,24 @@ func LoadNS() { tmp227 := lang.Apply(tmp195, []any{tmp197, tmp220, tmp222, tmp223}) tmp228 := lang.Apply(tmp194, []any{tmp227}) tmp229 := lang.Apply(tmp193, []any{tmp228}) - tmp230 := checkDerefVar(glojure_DOT_core_list) - tmp231 := checkDerefVar(glojure_DOT_core_seq) - tmp232 := checkDerefVar(glojure_DOT_core_concat) - tmp233 := checkDerefVar(glojure_DOT_core_list) - tmp234 := lang.Apply(tmp233, []any{lang.NewSymbol("glojure.core/when-let")}) - tmp235 := checkDerefVar(glojure_DOT_core_list) - tmp236 := checkDerefVar(glojure_DOT_core_apply) - tmp237 := checkDerefVar(glojure_DOT_core_vector) - tmp238 := checkDerefVar(glojure_DOT_core_seq) - tmp239 := checkDerefVar(glojure_DOT_core_concat) - tmp240 := checkDerefVar(glojure_DOT_core_list) + tmp230 := checkDerefVar(var_glojure_DOT_core_list) + tmp231 := checkDerefVar(var_glojure_DOT_core_seq) + tmp232 := checkDerefVar(var_glojure_DOT_core_concat) + tmp233 := checkDerefVar(var_glojure_DOT_core_list) + tmp234 := lang.Apply(tmp233, []any{sym_glojure_DOT_core_SLASH_when_DASH_let}) + tmp235 := checkDerefVar(var_glojure_DOT_core_list) + tmp236 := checkDerefVar(var_glojure_DOT_core_apply) + tmp237 := checkDerefVar(var_glojure_DOT_core_vector) + tmp238 := checkDerefVar(var_glojure_DOT_core_seq) + tmp239 := checkDerefVar(var_glojure_DOT_core_concat) + tmp240 := checkDerefVar(var_glojure_DOT_core_list) tmp241 := lang.Apply(tmp240, []any{v64}) - tmp242 := checkDerefVar(glojure_DOT_core_list) - tmp243 := checkDerefVar(glojure_DOT_core_seq) - tmp244 := checkDerefVar(glojure_DOT_core_concat) - tmp245 := checkDerefVar(glojure_DOT_core_list) - tmp246 := lang.Apply(tmp245, []any{lang.NewSymbol("glojure.core/seq")}) - tmp247 := checkDerefVar(glojure_DOT_core_list) + tmp242 := checkDerefVar(var_glojure_DOT_core_list) + tmp243 := checkDerefVar(var_glojure_DOT_core_seq) + tmp244 := checkDerefVar(var_glojure_DOT_core_concat) + tmp245 := checkDerefVar(var_glojure_DOT_core_list) + tmp246 := lang.Apply(tmp245, []any{sym_glojure_DOT_core_SLASH_seq}) + tmp247 := checkDerefVar(var_glojure_DOT_core_list) tmp248 := lang.Apply(tmp247, []any{v64}) tmp249 := lang.Apply(tmp244, []any{tmp246, tmp248}) tmp250 := lang.Apply(tmp243, []any{tmp249}) @@ -18961,39 +19699,39 @@ func LoadNS() { tmp253 := lang.Apply(tmp238, []any{tmp252}) tmp254 := lang.Apply(tmp236, []any{tmp237, tmp253}) tmp255 := lang.Apply(tmp235, []any{tmp254}) - tmp256 := checkDerefVar(glojure_DOT_core_list) - tmp257 := checkDerefVar(glojure_DOT_core_seq) - tmp258 := checkDerefVar(glojure_DOT_core_concat) - tmp259 := checkDerefVar(glojure_DOT_core_list) - tmp260 := lang.Apply(tmp259, []any{lang.NewSymbol("if")}) - tmp261 := checkDerefVar(glojure_DOT_core_list) - tmp262 := checkDerefVar(glojure_DOT_core_seq) - tmp263 := checkDerefVar(glojure_DOT_core_concat) - tmp264 := checkDerefVar(glojure_DOT_core_list) - tmp265 := lang.Apply(tmp264, []any{lang.NewSymbol("glojure.core/chunked-seq?")}) - tmp266 := checkDerefVar(glojure_DOT_core_list) + tmp256 := checkDerefVar(var_glojure_DOT_core_list) + tmp257 := checkDerefVar(var_glojure_DOT_core_seq) + tmp258 := checkDerefVar(var_glojure_DOT_core_concat) + tmp259 := checkDerefVar(var_glojure_DOT_core_list) + tmp260 := lang.Apply(tmp259, []any{sym_if}) + tmp261 := checkDerefVar(var_glojure_DOT_core_list) + tmp262 := checkDerefVar(var_glojure_DOT_core_seq) + tmp263 := checkDerefVar(var_glojure_DOT_core_concat) + tmp264 := checkDerefVar(var_glojure_DOT_core_list) + tmp265 := lang.Apply(tmp264, []any{sym_glojure_DOT_core_SLASH_chunked_DASH_seq_QMARK_}) + tmp266 := checkDerefVar(var_glojure_DOT_core_list) tmp267 := lang.Apply(tmp266, []any{v64}) tmp268 := lang.Apply(tmp263, []any{tmp265, tmp267}) tmp269 := lang.Apply(tmp262, []any{tmp268}) tmp270 := lang.Apply(tmp261, []any{tmp269}) - tmp271 := checkDerefVar(glojure_DOT_core_list) - tmp272 := checkDerefVar(glojure_DOT_core_seq) - tmp273 := checkDerefVar(glojure_DOT_core_concat) - tmp274 := checkDerefVar(glojure_DOT_core_list) - tmp275 := lang.Apply(tmp274, []any{lang.NewSymbol("glojure.core/let")}) - tmp276 := checkDerefVar(glojure_DOT_core_list) - tmp277 := checkDerefVar(glojure_DOT_core_apply) - tmp278 := checkDerefVar(glojure_DOT_core_vector) - tmp279 := checkDerefVar(glojure_DOT_core_seq) - tmp280 := checkDerefVar(glojure_DOT_core_concat) - tmp281 := checkDerefVar(glojure_DOT_core_list) - tmp282 := lang.Apply(tmp281, []any{lang.NewSymbol("c__0__auto__")}) - tmp283 := checkDerefVar(glojure_DOT_core_list) - tmp284 := checkDerefVar(glojure_DOT_core_seq) - tmp285 := checkDerefVar(glojure_DOT_core_concat) - tmp286 := checkDerefVar(glojure_DOT_core_list) - tmp287 := lang.Apply(tmp286, []any{lang.NewSymbol("glojure.core/chunk-first")}) - tmp288 := checkDerefVar(glojure_DOT_core_list) + tmp271 := checkDerefVar(var_glojure_DOT_core_list) + tmp272 := checkDerefVar(var_glojure_DOT_core_seq) + tmp273 := checkDerefVar(var_glojure_DOT_core_concat) + tmp274 := checkDerefVar(var_glojure_DOT_core_list) + tmp275 := lang.Apply(tmp274, []any{sym_glojure_DOT_core_SLASH_let}) + tmp276 := checkDerefVar(var_glojure_DOT_core_list) + tmp277 := checkDerefVar(var_glojure_DOT_core_apply) + tmp278 := checkDerefVar(var_glojure_DOT_core_vector) + tmp279 := checkDerefVar(var_glojure_DOT_core_seq) + tmp280 := checkDerefVar(var_glojure_DOT_core_concat) + tmp281 := checkDerefVar(var_glojure_DOT_core_list) + tmp282 := lang.Apply(tmp281, []any{sym_c__0__auto__}) + tmp283 := checkDerefVar(var_glojure_DOT_core_list) + tmp284 := checkDerefVar(var_glojure_DOT_core_seq) + tmp285 := checkDerefVar(var_glojure_DOT_core_concat) + tmp286 := checkDerefVar(var_glojure_DOT_core_list) + tmp287 := lang.Apply(tmp286, []any{sym_glojure_DOT_core_SLASH_chunk_DASH_first}) + tmp288 := checkDerefVar(var_glojure_DOT_core_list) tmp289 := lang.Apply(tmp288, []any{v64}) tmp290 := lang.Apply(tmp285, []any{tmp287, tmp289}) tmp291 := lang.Apply(tmp284, []any{tmp290}) @@ -19002,47 +19740,47 @@ func LoadNS() { tmp294 := lang.Apply(tmp279, []any{tmp293}) tmp295 := lang.Apply(tmp277, []any{tmp278, tmp294}) tmp296 := lang.Apply(tmp276, []any{tmp295}) - tmp297 := checkDerefVar(glojure_DOT_core_list) - tmp298 := checkDerefVar(glojure_DOT_core_seq) - tmp299 := checkDerefVar(glojure_DOT_core_concat) - tmp300 := checkDerefVar(glojure_DOT_core_list) - tmp301 := lang.Apply(tmp300, []any{lang.NewSymbol("recur")}) - tmp302 := checkDerefVar(glojure_DOT_core_list) - tmp303 := checkDerefVar(glojure_DOT_core_seq) - tmp304 := checkDerefVar(glojure_DOT_core_concat) - tmp305 := checkDerefVar(glojure_DOT_core_list) - tmp306 := lang.Apply(tmp305, []any{lang.NewSymbol("glojure.core/chunk-rest")}) - tmp307 := checkDerefVar(glojure_DOT_core_list) + tmp297 := checkDerefVar(var_glojure_DOT_core_list) + tmp298 := checkDerefVar(var_glojure_DOT_core_seq) + tmp299 := checkDerefVar(var_glojure_DOT_core_concat) + tmp300 := checkDerefVar(var_glojure_DOT_core_list) + tmp301 := lang.Apply(tmp300, []any{sym_recur}) + tmp302 := checkDerefVar(var_glojure_DOT_core_list) + tmp303 := checkDerefVar(var_glojure_DOT_core_seq) + tmp304 := checkDerefVar(var_glojure_DOT_core_concat) + tmp305 := checkDerefVar(var_glojure_DOT_core_list) + tmp306 := lang.Apply(tmp305, []any{sym_glojure_DOT_core_SLASH_chunk_DASH_rest}) + tmp307 := checkDerefVar(var_glojure_DOT_core_list) tmp308 := lang.Apply(tmp307, []any{v64}) tmp309 := lang.Apply(tmp304, []any{tmp306, tmp308}) tmp310 := lang.Apply(tmp303, []any{tmp309}) tmp311 := lang.Apply(tmp302, []any{tmp310}) - tmp312 := checkDerefVar(glojure_DOT_core_list) - tmp313 := lang.Apply(tmp312, []any{lang.NewSymbol("c__0__auto__")}) - tmp314 := checkDerefVar(glojure_DOT_core_list) - tmp315 := checkDerefVar(glojure_DOT_core_seq) - tmp316 := checkDerefVar(glojure_DOT_core_concat) - tmp317 := checkDerefVar(glojure_DOT_core_list) - tmp318 := lang.Apply(tmp317, []any{lang.NewSymbol("glojure.core/int")}) - tmp319 := checkDerefVar(glojure_DOT_core_list) - tmp320 := checkDerefVar(glojure_DOT_core_seq) - tmp321 := checkDerefVar(glojure_DOT_core_concat) - tmp322 := checkDerefVar(glojure_DOT_core_list) - tmp323 := lang.Apply(tmp322, []any{lang.NewSymbol("glojure.core/count")}) - tmp324 := checkDerefVar(glojure_DOT_core_list) - tmp325 := lang.Apply(tmp324, []any{lang.NewSymbol("c__0__auto__")}) + tmp312 := checkDerefVar(var_glojure_DOT_core_list) + tmp313 := lang.Apply(tmp312, []any{sym_c__0__auto__}) + tmp314 := checkDerefVar(var_glojure_DOT_core_list) + tmp315 := checkDerefVar(var_glojure_DOT_core_seq) + tmp316 := checkDerefVar(var_glojure_DOT_core_concat) + tmp317 := checkDerefVar(var_glojure_DOT_core_list) + tmp318 := lang.Apply(tmp317, []any{sym_glojure_DOT_core_SLASH_int}) + tmp319 := checkDerefVar(var_glojure_DOT_core_list) + tmp320 := checkDerefVar(var_glojure_DOT_core_seq) + tmp321 := checkDerefVar(var_glojure_DOT_core_concat) + tmp322 := checkDerefVar(var_glojure_DOT_core_list) + tmp323 := lang.Apply(tmp322, []any{sym_glojure_DOT_core_SLASH_count}) + tmp324 := checkDerefVar(var_glojure_DOT_core_list) + tmp325 := lang.Apply(tmp324, []any{sym_c__0__auto__}) tmp326 := lang.Apply(tmp321, []any{tmp323, tmp325}) tmp327 := lang.Apply(tmp320, []any{tmp326}) tmp328 := lang.Apply(tmp319, []any{tmp327}) tmp329 := lang.Apply(tmp316, []any{tmp318, tmp328}) tmp330 := lang.Apply(tmp315, []any{tmp329}) tmp331 := lang.Apply(tmp314, []any{tmp330}) - tmp332 := checkDerefVar(glojure_DOT_core_list) - tmp333 := checkDerefVar(glojure_DOT_core_seq) - tmp334 := checkDerefVar(glojure_DOT_core_concat) - tmp335 := checkDerefVar(glojure_DOT_core_list) - tmp336 := lang.Apply(tmp335, []any{lang.NewSymbol("glojure.core/int")}) - tmp337 := checkDerefVar(glojure_DOT_core_list) + tmp332 := checkDerefVar(var_glojure_DOT_core_list) + tmp333 := checkDerefVar(var_glojure_DOT_core_seq) + tmp334 := checkDerefVar(var_glojure_DOT_core_concat) + tmp335 := checkDerefVar(var_glojure_DOT_core_list) + tmp336 := lang.Apply(tmp335, []any{sym_glojure_DOT_core_SLASH_int}) + tmp337 := checkDerefVar(var_glojure_DOT_core_list) tmp338 := lang.Apply(tmp337, []any{int64(0)}) tmp339 := lang.Apply(tmp334, []any{tmp336, tmp338}) tmp340 := lang.Apply(tmp333, []any{tmp339}) @@ -19053,24 +19791,24 @@ func LoadNS() { tmp345 := lang.Apply(tmp273, []any{tmp275, tmp296, tmp344}) tmp346 := lang.Apply(tmp272, []any{tmp345}) tmp347 := lang.Apply(tmp271, []any{tmp346}) - tmp348 := checkDerefVar(glojure_DOT_core_list) - tmp349 := checkDerefVar(glojure_DOT_core_seq) - tmp350 := checkDerefVar(glojure_DOT_core_concat) - tmp351 := checkDerefVar(glojure_DOT_core_list) - tmp352 := lang.Apply(tmp351, []any{lang.NewSymbol("glojure.core/let")}) - tmp353 := checkDerefVar(glojure_DOT_core_list) - tmp354 := checkDerefVar(glojure_DOT_core_apply) - tmp355 := checkDerefVar(glojure_DOT_core_vector) - tmp356 := checkDerefVar(glojure_DOT_core_seq) - tmp357 := checkDerefVar(glojure_DOT_core_concat) - tmp358 := checkDerefVar(glojure_DOT_core_list) + tmp348 := checkDerefVar(var_glojure_DOT_core_list) + tmp349 := checkDerefVar(var_glojure_DOT_core_seq) + tmp350 := checkDerefVar(var_glojure_DOT_core_concat) + tmp351 := checkDerefVar(var_glojure_DOT_core_list) + tmp352 := lang.Apply(tmp351, []any{sym_glojure_DOT_core_SLASH_let}) + tmp353 := checkDerefVar(var_glojure_DOT_core_list) + tmp354 := checkDerefVar(var_glojure_DOT_core_apply) + tmp355 := checkDerefVar(var_glojure_DOT_core_vector) + tmp356 := checkDerefVar(var_glojure_DOT_core_seq) + tmp357 := checkDerefVar(var_glojure_DOT_core_concat) + tmp358 := checkDerefVar(var_glojure_DOT_core_list) tmp359 := lang.Apply(tmp358, []any{v53}) - tmp360 := checkDerefVar(glojure_DOT_core_list) - tmp361 := checkDerefVar(glojure_DOT_core_seq) - tmp362 := checkDerefVar(glojure_DOT_core_concat) - tmp363 := checkDerefVar(glojure_DOT_core_list) - tmp364 := lang.Apply(tmp363, []any{lang.NewSymbol("glojure.core/first")}) - tmp365 := checkDerefVar(glojure_DOT_core_list) + tmp360 := checkDerefVar(var_glojure_DOT_core_list) + tmp361 := checkDerefVar(var_glojure_DOT_core_seq) + tmp362 := checkDerefVar(var_glojure_DOT_core_concat) + tmp363 := checkDerefVar(var_glojure_DOT_core_list) + tmp364 := lang.Apply(tmp363, []any{sym_glojure_DOT_core_SLASH_first}) + tmp365 := checkDerefVar(var_glojure_DOT_core_list) tmp366 := lang.Apply(tmp365, []any{v64}) tmp367 := lang.Apply(tmp362, []any{tmp364, tmp366}) tmp368 := lang.Apply(tmp361, []any{tmp367}) @@ -19079,12 +19817,12 @@ func LoadNS() { tmp371 := lang.Apply(tmp356, []any{tmp370}) tmp372 := lang.Apply(tmp354, []any{tmp355, tmp371}) tmp373 := lang.Apply(tmp353, []any{tmp372}) - tmp374 := checkDerefVar(glojure_DOT_core_list) + tmp374 := checkDerefVar(var_glojure_DOT_core_list) tmp375 := lang.Apply(tmp374, []any{v109}) var tmp376 any if lang.IsTruthy(v107) { tmp377 := lang.NewVector(v101) - tmp378 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3264), lang.NewKeyword("column"), int(52), lang.NewKeyword("end-line"), int(3264), lang.NewKeyword("end-column"), int(60)) + tmp378 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3264), kw_column, int(52), kw_end_DASH_line, int(3264), kw_end_DASH_column, int(60)) tmp379, err := lang.WithMeta(tmp377, tmp378.(lang.IPersistentMap)) if err != nil { panic(err) @@ -19107,7 +19845,7 @@ func LoadNS() { tmp392 := lang.Apply(tmp140, []any{tmp142, tmp175, tmp391}) tmp393 := lang.Apply(tmp139, []any{tmp392}) tmp394 := lang.NewVector(true, tmp393) - tmp395 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3250), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(3264), lang.NewKeyword("end-column"), int(67)) + tmp395 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3250), kw_column, int(24), kw_end_DASH_line, int(3264), kw_end_DASH_column, int(67)) tmp396, err := lang.WithMeta(tmp394, tmp395.(lang.IPersistentMap)) if err != nil { panic(err) @@ -19125,15 +19863,15 @@ func LoadNS() { v35 = tmp34 _ = v35 } - tmp35 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3218), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(3264), lang.NewKeyword("end-column"), int(72)) + tmp35 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3218), kw_column, int(14), kw_end_DASH_line, int(3264), kw_end_DASH_column, int(72)) tmp36, err := lang.WithMeta(tmp34, tmp35.(lang.IPersistentMap)) if err != nil { panic(err) } var v37 any = tmp36 _ = v37 - tmp38 := checkDerefVar(glojure_DOT_core_nth) - tmp39 := checkDerefVar(glojure_DOT_core_seq) + tmp38 := checkDerefVar(var_glojure_DOT_core_nth) + tmp39 := checkDerefVar(var_glojure_DOT_core_seq) tmp40 := lang.Apply(tmp39, []any{v5}) tmp41 := lang.Apply(v37, []any{nil, tmp40}) tmp42 := lang.Apply(tmp38, []any{tmp41, int64(1)}) @@ -19142,7 +19880,7 @@ func LoadNS() { return tmp33 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -19150,32 +19888,30 @@ func LoadNS() { } // dosync { - tmp0 := lang.NewSymbol("dosync").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("exprs"))), lang.NewKeyword("doc"), "Runs the exprs (in an implicit do) in a transaction that encompasses\n exprs and any nested calls. Starts a transaction if none is already\n running on this thread. Any uncaught exception will abort the\n transaction and flow out of dosync. The exprs may be run more than\n once, but any effects on Refs will be atomic.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5100), lang.NewKeyword("end-line"), int(5100))).(*lang.Symbol) + tmp0 := sym_dosync.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_exprs)), kw_doc, "Runs the exprs (in an implicit do) in a transaction that encompasses\n exprs and any nested calls. Starts a transaction if none is already\n running on this thread. Any uncaught exception will abort the\n transaction and flow out of dosync. The exprs may be run more than\n once, but any effects on Refs will be atomic.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(11), kw_line, int(5100), kw_end_DASH_line, int(5100))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 var v5 any = lang.NewList(args[2:]...) _ = v5 - tmp6 := checkDerefVar(glojure_DOT_core_seq) - tmp7 := checkDerefVar(glojure_DOT_core_concat) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("glojure.core/sync")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_sync}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) tmp11 := lang.Apply(tmp10, []any{nil}) tmp12 := lang.Apply(tmp7, []any{tmp9, tmp11, v5}) tmp13 := lang.Apply(tmp6, []any{tmp12}) return tmp13 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -19183,14 +19919,12 @@ func LoadNS() { } // dotimes { - tmp0 := lang.NewSymbol("dotimes").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "bindings => name n\n\n Repeatedly executes body (presumably for side-effects) with name\n bound to integers from 0 through n-1.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3306), lang.NewKeyword("end-line"), int(3306))).(*lang.Symbol) + tmp0 := sym_dotimes.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "bindings => name n\n\n Repeatedly executes body (presumably for side-effects) with name\n bound to integers from 0 through n-1.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(3306), kw_end_DASH_line, int(3306))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -19200,36 +19934,36 @@ func LoadNS() { var v6 any = lang.NewList(args[3:]...) _ = v6 var tmp7 any - tmp8 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp8 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) tmp9 := lang.Apply(tmp8, []any{v5}) if lang.IsTruthy(tmp9) { } else { - tmp10 := checkDerefVar(glojure_DOT_core_str) - tmp11 := checkDerefVar(glojure_DOT_core_first) + tmp10 := checkDerefVar(var_glojure_DOT_core_str) + tmp11 := checkDerefVar(var_glojure_DOT_core_first) tmp12 := lang.Apply(tmp11, []any{v3}) - tmp13 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) - tmp14 := checkDerefVar(glojure_DOT_core_meta) + tmp13 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp14 := checkDerefVar(var_glojure_DOT_core_meta) tmp15 := lang.Apply(tmp14, []any{v3}) - tmp16 := lang.Apply(lang.NewKeyword("line"), []any{tmp15}) + tmp16 := lang.Apply(kw_line, []any{tmp15}) tmp17 := lang.Apply(tmp10, []any{tmp12, " requires ", "a vector for its binding", " in ", tmp13, ":", tmp16}) tmp18 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp17}) panic(tmp18) } _ = tmp7 var tmp19 any - tmp20 := checkDerefVar(glojure_DOT_core__EQ_) - tmp21 := checkDerefVar(glojure_DOT_core_count) + tmp20 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp21 := checkDerefVar(var_glojure_DOT_core_count) tmp22 := lang.Apply(tmp21, []any{v5}) tmp23 := lang.Apply(tmp20, []any{int64(2), tmp22}) if lang.IsTruthy(tmp23) { } else { - tmp24 := checkDerefVar(glojure_DOT_core_str) - tmp25 := checkDerefVar(glojure_DOT_core_first) + tmp24 := checkDerefVar(var_glojure_DOT_core_str) + tmp25 := checkDerefVar(var_glojure_DOT_core_first) tmp26 := lang.Apply(tmp25, []any{v3}) - tmp27 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) - tmp28 := checkDerefVar(glojure_DOT_core_meta) + tmp27 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp28 := checkDerefVar(var_glojure_DOT_core_meta) tmp29 := lang.Apply(tmp28, []any{v3}) - tmp30 := lang.Apply(lang.NewKeyword("line"), []any{tmp29}) + tmp30 := lang.Apply(kw_line, []any{tmp29}) tmp31 := lang.Apply(tmp24, []any{tmp26, " requires ", "exactly 2 forms in binding vector", " in ", tmp27, ":", tmp30}) tmp32 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp31}) panic(tmp32) @@ -19238,32 +19972,32 @@ func LoadNS() { var tmp33 any { // let // let binding "i" - tmp34 := checkDerefVar(glojure_DOT_core_first) + tmp34 := checkDerefVar(var_glojure_DOT_core_first) tmp35 := lang.Apply(tmp34, []any{v5}) var v36 any = tmp35 _ = v36 // let binding "n" - tmp37 := checkDerefVar(glojure_DOT_core_second) + tmp37 := checkDerefVar(var_glojure_DOT_core_second) tmp38 := lang.Apply(tmp37, []any{v5}) var v39 any = tmp38 _ = v39 - tmp40 := checkDerefVar(glojure_DOT_core_seq) - tmp41 := checkDerefVar(glojure_DOT_core_concat) - tmp42 := checkDerefVar(glojure_DOT_core_list) - tmp43 := lang.Apply(tmp42, []any{lang.NewSymbol("glojure.core/let")}) - tmp44 := checkDerefVar(glojure_DOT_core_list) - tmp45 := checkDerefVar(glojure_DOT_core_apply) - tmp46 := checkDerefVar(glojure_DOT_core_vector) - tmp47 := checkDerefVar(glojure_DOT_core_seq) - tmp48 := checkDerefVar(glojure_DOT_core_concat) - tmp49 := checkDerefVar(glojure_DOT_core_list) - tmp50 := lang.Apply(tmp49, []any{lang.NewSymbol("n__0__auto__")}) - tmp51 := checkDerefVar(glojure_DOT_core_list) - tmp52 := checkDerefVar(glojure_DOT_core_seq) - tmp53 := checkDerefVar(glojure_DOT_core_concat) - tmp54 := checkDerefVar(glojure_DOT_core_list) - tmp55 := lang.Apply(tmp54, []any{lang.NewSymbol("glojure.core/long")}) - tmp56 := checkDerefVar(glojure_DOT_core_list) + tmp40 := checkDerefVar(var_glojure_DOT_core_seq) + tmp41 := checkDerefVar(var_glojure_DOT_core_concat) + tmp42 := checkDerefVar(var_glojure_DOT_core_list) + tmp43 := lang.Apply(tmp42, []any{sym_glojure_DOT_core_SLASH_let}) + tmp44 := checkDerefVar(var_glojure_DOT_core_list) + tmp45 := checkDerefVar(var_glojure_DOT_core_apply) + tmp46 := checkDerefVar(var_glojure_DOT_core_vector) + tmp47 := checkDerefVar(var_glojure_DOT_core_seq) + tmp48 := checkDerefVar(var_glojure_DOT_core_concat) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) + tmp50 := lang.Apply(tmp49, []any{sym_n__0__auto__}) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := checkDerefVar(var_glojure_DOT_core_seq) + tmp53 := checkDerefVar(var_glojure_DOT_core_concat) + tmp54 := checkDerefVar(var_glojure_DOT_core_list) + tmp55 := lang.Apply(tmp54, []any{sym_glojure_DOT_core_SLASH_long}) + tmp56 := checkDerefVar(var_glojure_DOT_core_list) tmp57 := lang.Apply(tmp56, []any{v39}) tmp58 := lang.Apply(tmp53, []any{tmp55, tmp57}) tmp59 := lang.Apply(tmp52, []any{tmp58}) @@ -19272,52 +20006,52 @@ func LoadNS() { tmp62 := lang.Apply(tmp47, []any{tmp61}) tmp63 := lang.Apply(tmp45, []any{tmp46, tmp62}) tmp64 := lang.Apply(tmp44, []any{tmp63}) - tmp65 := checkDerefVar(glojure_DOT_core_list) - tmp66 := checkDerefVar(glojure_DOT_core_seq) - tmp67 := checkDerefVar(glojure_DOT_core_concat) - tmp68 := checkDerefVar(glojure_DOT_core_list) - tmp69 := lang.Apply(tmp68, []any{lang.NewSymbol("glojure.core/loop")}) - tmp70 := checkDerefVar(glojure_DOT_core_list) - tmp71 := checkDerefVar(glojure_DOT_core_apply) - tmp72 := checkDerefVar(glojure_DOT_core_vector) - tmp73 := checkDerefVar(glojure_DOT_core_seq) - tmp74 := checkDerefVar(glojure_DOT_core_concat) - tmp75 := checkDerefVar(glojure_DOT_core_list) + tmp65 := checkDerefVar(var_glojure_DOT_core_list) + tmp66 := checkDerefVar(var_glojure_DOT_core_seq) + tmp67 := checkDerefVar(var_glojure_DOT_core_concat) + tmp68 := checkDerefVar(var_glojure_DOT_core_list) + tmp69 := lang.Apply(tmp68, []any{sym_glojure_DOT_core_SLASH_loop}) + tmp70 := checkDerefVar(var_glojure_DOT_core_list) + tmp71 := checkDerefVar(var_glojure_DOT_core_apply) + tmp72 := checkDerefVar(var_glojure_DOT_core_vector) + tmp73 := checkDerefVar(var_glojure_DOT_core_seq) + tmp74 := checkDerefVar(var_glojure_DOT_core_concat) + tmp75 := checkDerefVar(var_glojure_DOT_core_list) tmp76 := lang.Apply(tmp75, []any{v36}) - tmp77 := checkDerefVar(glojure_DOT_core_list) + tmp77 := checkDerefVar(var_glojure_DOT_core_list) tmp78 := lang.Apply(tmp77, []any{int64(0)}) tmp79 := lang.Apply(tmp74, []any{tmp76, tmp78}) tmp80 := lang.Apply(tmp73, []any{tmp79}) tmp81 := lang.Apply(tmp71, []any{tmp72, tmp80}) tmp82 := lang.Apply(tmp70, []any{tmp81}) - tmp83 := checkDerefVar(glojure_DOT_core_list) - tmp84 := checkDerefVar(glojure_DOT_core_seq) - tmp85 := checkDerefVar(glojure_DOT_core_concat) - tmp86 := checkDerefVar(glojure_DOT_core_list) - tmp87 := lang.Apply(tmp86, []any{lang.NewSymbol("glojure.core/when")}) - tmp88 := checkDerefVar(glojure_DOT_core_list) - tmp89 := checkDerefVar(glojure_DOT_core_seq) - tmp90 := checkDerefVar(glojure_DOT_core_concat) - tmp91 := checkDerefVar(glojure_DOT_core_list) - tmp92 := lang.Apply(tmp91, []any{lang.NewSymbol("glojure.core/<")}) - tmp93 := checkDerefVar(glojure_DOT_core_list) + tmp83 := checkDerefVar(var_glojure_DOT_core_list) + tmp84 := checkDerefVar(var_glojure_DOT_core_seq) + tmp85 := checkDerefVar(var_glojure_DOT_core_concat) + tmp86 := checkDerefVar(var_glojure_DOT_core_list) + tmp87 := lang.Apply(tmp86, []any{sym_glojure_DOT_core_SLASH_when}) + tmp88 := checkDerefVar(var_glojure_DOT_core_list) + tmp89 := checkDerefVar(var_glojure_DOT_core_seq) + tmp90 := checkDerefVar(var_glojure_DOT_core_concat) + tmp91 := checkDerefVar(var_glojure_DOT_core_list) + tmp92 := lang.Apply(tmp91, []any{sym_glojure_DOT_core_SLASH__LT_}) + tmp93 := checkDerefVar(var_glojure_DOT_core_list) tmp94 := lang.Apply(tmp93, []any{v36}) - tmp95 := checkDerefVar(glojure_DOT_core_list) - tmp96 := lang.Apply(tmp95, []any{lang.NewSymbol("n__0__auto__")}) + tmp95 := checkDerefVar(var_glojure_DOT_core_list) + tmp96 := lang.Apply(tmp95, []any{sym_n__0__auto__}) tmp97 := lang.Apply(tmp90, []any{tmp92, tmp94, tmp96}) tmp98 := lang.Apply(tmp89, []any{tmp97}) tmp99 := lang.Apply(tmp88, []any{tmp98}) - tmp100 := checkDerefVar(glojure_DOT_core_list) - tmp101 := checkDerefVar(glojure_DOT_core_seq) - tmp102 := checkDerefVar(glojure_DOT_core_concat) - tmp103 := checkDerefVar(glojure_DOT_core_list) - tmp104 := lang.Apply(tmp103, []any{lang.NewSymbol("recur")}) - tmp105 := checkDerefVar(glojure_DOT_core_list) - tmp106 := checkDerefVar(glojure_DOT_core_seq) - tmp107 := checkDerefVar(glojure_DOT_core_concat) - tmp108 := checkDerefVar(glojure_DOT_core_list) - tmp109 := lang.Apply(tmp108, []any{lang.NewSymbol("glojure.core/unchecked-inc")}) - tmp110 := checkDerefVar(glojure_DOT_core_list) + tmp100 := checkDerefVar(var_glojure_DOT_core_list) + tmp101 := checkDerefVar(var_glojure_DOT_core_seq) + tmp102 := checkDerefVar(var_glojure_DOT_core_concat) + tmp103 := checkDerefVar(var_glojure_DOT_core_list) + tmp104 := lang.Apply(tmp103, []any{sym_recur}) + tmp105 := checkDerefVar(var_glojure_DOT_core_list) + tmp106 := checkDerefVar(var_glojure_DOT_core_seq) + tmp107 := checkDerefVar(var_glojure_DOT_core_concat) + tmp108 := checkDerefVar(var_glojure_DOT_core_list) + tmp109 := lang.Apply(tmp108, []any{sym_glojure_DOT_core_SLASH_unchecked_DASH_inc}) + tmp110 := checkDerefVar(var_glojure_DOT_core_list) tmp111 := lang.Apply(tmp110, []any{v36}) tmp112 := lang.Apply(tmp107, []any{tmp109, tmp111}) tmp113 := lang.Apply(tmp106, []any{tmp112}) @@ -19338,7 +20072,7 @@ func LoadNS() { return tmp33 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -19346,14 +20080,12 @@ func LoadNS() { } // doto { - tmp0 := lang.NewSymbol("doto").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "Evaluates x then calls all of the methods and functions with the\n value of x supplied at the front of the given arguments. The forms\n are evaluated in order. Returns x.\n\n (doto (new java.util.HashMap) (.put \"a\" 1) (.put \"b\" 2))", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3853), lang.NewKeyword("end-line"), int(3853))).(*lang.Symbol) + tmp0 := sym_doto.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_x, sym__AMP_, sym_forms)), kw_doc, "Evaluates x then calls all of the methods and functions with the\n value of x supplied at the front of the given arguments. The forms\n are evaluated in order. Returns x.\n\n (doto (new java.util.HashMap) (.put \"a\" 1) (.put \"b\" 2))", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(11), kw_line, int(3853), kw_end_DASH_line, int(3853))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -19365,76 +20097,74 @@ func LoadNS() { var tmp7 any { // let // let binding "gx" - tmp8 := checkDerefVar(glojure_DOT_core_gensym) + tmp8 := checkDerefVar(var_glojure_DOT_core_gensym) tmp9 := lang.Apply(tmp8, nil) var v10 any = tmp9 _ = v10 - tmp11 := checkDerefVar(glojure_DOT_core_seq) - tmp12 := checkDerefVar(glojure_DOT_core_concat) - tmp13 := checkDerefVar(glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/let")}) - tmp15 := checkDerefVar(glojure_DOT_core_list) - tmp16 := checkDerefVar(glojure_DOT_core_apply) - tmp17 := checkDerefVar(glojure_DOT_core_vector) - tmp18 := checkDerefVar(glojure_DOT_core_seq) - tmp19 := checkDerefVar(glojure_DOT_core_concat) - tmp20 := checkDerefVar(glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_let}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := checkDerefVar(var_glojure_DOT_core_apply) + tmp17 := checkDerefVar(var_glojure_DOT_core_vector) + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) tmp21 := lang.Apply(tmp20, []any{v10}) - tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) tmp23 := lang.Apply(tmp22, []any{v5}) tmp24 := lang.Apply(tmp19, []any{tmp21, tmp23}) tmp25 := lang.Apply(tmp18, []any{tmp24}) tmp26 := lang.Apply(tmp16, []any{tmp17, tmp25}) tmp27 := lang.Apply(tmp15, []any{tmp26}) - tmp28 := checkDerefVar(glojure_DOT_core_map) + tmp28 := checkDerefVar(var_glojure_DOT_core_map) var tmp29 lang.FnFunc tmp29 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v30 := args[0] _ = v30 - tmp31 := checkDerefVar(glojure_DOT_core_with_meta) + tmp31 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) var tmp32 any - tmp33 := checkDerefVar(glojure_DOT_core_seq_QMARK_) + tmp33 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) tmp34 := lang.Apply(tmp33, []any{v30}) if lang.IsTruthy(tmp34) { - tmp35 := checkDerefVar(glojure_DOT_core_seq) - tmp36 := checkDerefVar(glojure_DOT_core_concat) - tmp37 := checkDerefVar(glojure_DOT_core_list) - tmp38 := checkDerefVar(glojure_DOT_core_first) + tmp35 := checkDerefVar(var_glojure_DOT_core_seq) + tmp36 := checkDerefVar(var_glojure_DOT_core_concat) + tmp37 := checkDerefVar(var_glojure_DOT_core_list) + tmp38 := checkDerefVar(var_glojure_DOT_core_first) tmp39 := lang.Apply(tmp38, []any{v30}) tmp40 := lang.Apply(tmp37, []any{tmp39}) - tmp41 := checkDerefVar(glojure_DOT_core_list) + tmp41 := checkDerefVar(var_glojure_DOT_core_list) tmp42 := lang.Apply(tmp41, []any{v10}) - tmp43 := checkDerefVar(glojure_DOT_core_next) + tmp43 := checkDerefVar(var_glojure_DOT_core_next) tmp44 := lang.Apply(tmp43, []any{v30}) tmp45 := lang.Apply(tmp36, []any{tmp40, tmp42, tmp44}) tmp46 := lang.Apply(tmp35, []any{tmp45}) tmp32 = tmp46 } else { - tmp47 := checkDerefVar(glojure_DOT_core_seq) - tmp48 := checkDerefVar(glojure_DOT_core_concat) - tmp49 := checkDerefVar(glojure_DOT_core_list) + tmp47 := checkDerefVar(var_glojure_DOT_core_seq) + tmp48 := checkDerefVar(var_glojure_DOT_core_concat) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) tmp50 := lang.Apply(tmp49, []any{v30}) - tmp51 := checkDerefVar(glojure_DOT_core_list) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) tmp52 := lang.Apply(tmp51, []any{v10}) tmp53 := lang.Apply(tmp48, []any{tmp50, tmp52}) tmp54 := lang.Apply(tmp47, []any{tmp53}) tmp32 = tmp54 } - tmp55 := checkDerefVar(glojure_DOT_core_meta) + tmp55 := checkDerefVar(var_glojure_DOT_core_meta) tmp56 := lang.Apply(tmp55, []any{v30}) tmp57 := lang.Apply(tmp31, []any{tmp32, tmp56}) return tmp57 }) - tmp30 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3863), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(3868), lang.NewKeyword("end-column"), int(30)) + tmp30 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3863), kw_column, int(17), kw_end_DASH_line, int(3868), kw_end_DASH_column, int(30)) tmp31, err := lang.WithMeta(tmp29, tmp30.(lang.IPersistentMap)) if err != nil { panic(err) } tmp32 := lang.Apply(tmp28, []any{tmp31, v6}) - tmp33 := checkDerefVar(glojure_DOT_core_list) + tmp33 := checkDerefVar(var_glojure_DOT_core_list) tmp34 := lang.Apply(tmp33, []any{v10}) tmp35 := lang.Apply(tmp12, []any{tmp14, tmp27, tmp32, tmp34}) tmp36 := lang.Apply(tmp11, []any{tmp35}) @@ -19443,7 +20173,7 @@ func LoadNS() { return tmp7 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -19455,23 +20185,21 @@ func LoadNS() { { // function double__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) - tmp5 := checkDerefVar(glojure_DOT_core_concat) - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := checkDerefVar(glojure_DOT_core_seq) - tmp12 := checkDerefVar(glojure_DOT_core_concat) - tmp13 := checkDerefVar(glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/DoubleCast")}) - tmp15 := checkDerefVar(glojure_DOT_core_list) + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_DoubleCast}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) tmp18 := lang.Apply(tmp11, []any{tmp17}) @@ -19483,18 +20211,16 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("double").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to double", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3493), lang.NewKeyword("end-line"), int(3493))).(*lang.Symbol) + tmp0 := sym_double.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to double", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(3493), kw_end_DASH_line, int(3493))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 tmp5 := lang.Apply(lang.AsFloat64, []any{v4}) return tmp5 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -19508,26 +20234,24 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) - tmp5 := checkDerefVar(glojure_DOT_core_concat) - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol("glojure.core/DoubleArray")}) - tmp12 := checkDerefVar(glojure_DOT_core_list) - tmp13 := checkDerefVar(glojure_DOT_core_seq) - tmp14 := checkDerefVar(glojure_DOT_core_concat) - tmp15 := checkDerefVar(glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) - tmp17 := checkDerefVar(glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("glojure.core/args")}) + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_DoubleArray}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_unquote_DASH_splicing}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_glojure_DOT_core_SLASH_args}) tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) tmp20 := lang.Apply(tmp13, []any{tmp19}) tmp21 := lang.Apply(tmp12, []any{tmp20}) @@ -19539,7 +20263,7 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("double-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Creates an array of doubles", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5341), lang.NewKeyword("end-line"), int(5341))).(*lang.Symbol) + tmp0 := sym_double_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_size_DASH_or_DASH_seq), lang.NewVector(sym_size, sym_init_DASH_val_DASH_or_DASH_seq)), kw_inline, tmp1, kw_doc, "Creates an array of doubles", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(5341), kw_end_DASH_line, int(5341))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -19564,10 +20288,11 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -19575,19 +20300,17 @@ func LoadNS() { } // double? { - tmp0 := lang.NewSymbol("double?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a Double", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1421), lang.NewKeyword("end-line"), int(1421))).(*lang.Symbol) + tmp0 := sym_double_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a Double", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(1421), kw_end_DASH_line, int(1421))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp5 := lang.Apply(tmp4, []any{lang.Builtins["float64"], v3}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -19599,20 +20322,18 @@ func LoadNS() { { // function doubles var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) - tmp5 := checkDerefVar(glojure_DOT_core_concat) - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol("glojure.core/Doubles")}) - tmp12 := checkDerefVar(glojure_DOT_core_list) + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Doubles}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := lang.Apply(tmp12, []any{v3}) tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) tmp15 := lang.Apply(tmp4, []any{tmp14}) @@ -19621,12 +20342,10 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("doubles").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Casts to double[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5402), lang.NewKeyword("end-line"), int(5402))).(*lang.Symbol) + tmp0 := sym_doubles.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xs)), kw_inline, tmp1, kw_doc, "Casts to double[]", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(12), kw_line, int(5402), kw_end_DASH_line, int(5402))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Doubles") @@ -19636,7 +20355,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v4}) return tmp6 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -19644,7 +20363,7 @@ func LoadNS() { } // drop { - tmp0 := lang.NewSymbol("drop").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a laziness-preserving sequence of all but the first n items in coll.\n Returns a stateful transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2901), lang.NewKeyword("end-line"), int(2901))).(*lang.Symbol) + tmp0 := sym_drop.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n), lang.NewVector(sym_n, sym_coll)), kw_doc, "Returns a laziness-preserving sequence of all but the first n items in coll.\n Returns a stateful transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(2901), kw_end_DASH_line, int(2901))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -19653,15 +20372,13 @@ func LoadNS() { _ = v3 var tmp4 lang.FnFunc tmp4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v5 := args[0] _ = v5 var tmp6 any { // let // let binding "nv" - tmp7 := checkDerefVar(glojure_DOT_core_volatile_BANG_) + tmp7 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) tmp8 := lang.Apply(tmp7, []any{v3}) var v9 any = tmp8 _ = v9 @@ -19684,11 +20401,11 @@ func LoadNS() { var tmp13 any { // let // let binding "n" - tmp14 := checkDerefVar(glojure_DOT_core_deref) + tmp14 := checkDerefVar(var_glojure_DOT_core_deref) tmp15 := lang.Apply(tmp14, []any{v9}) var v16 any = tmp15 _ = v16 - tmp17 := checkDerefVar(glojure_DOT_core_dec) + tmp17 := checkDerefVar(var_glojure_DOT_core_dec) tmp18, ok := lang.FieldOrMethod(v9, "Deref") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v9, "Deref"))) @@ -19708,7 +20425,7 @@ func LoadNS() { tmp22 := lang.Apply(tmp21, []any{tmp20}) _ = tmp22 var tmp23 any - tmp24 := checkDerefVar(glojure_DOT_core_pos_QMARK_) + tmp24 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) tmp25 := lang.Apply(tmp24, []any{v16}) if lang.IsTruthy(tmp25) { tmp23 = v11 @@ -19720,10 +20437,11 @@ func LoadNS() { } // end let return tmp13 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2909), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(2917), lang.NewKeyword("end-column"), int(39)) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2909), kw_column, int(10), kw_end_DASH_line, int(2917), kw_end_DASH_column, int(39)) tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) if err != nil { panic(err) @@ -19732,7 +20450,7 @@ func LoadNS() { } // end let return tmp6 }) - tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2907), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2917), lang.NewKeyword("end-column"), int(41)) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2907), kw_column, int(6), kw_end_DASH_line, int(2917), kw_end_DASH_column, int(41)) tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) if err != nil { panic(err) @@ -19744,7 +20462,7 @@ func LoadNS() { v4 := args[1] _ = v4 var tmp5 any - tmp6 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp6 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp7 := reflect.TypeOf((*lang.IDrop)(nil)).Elem() tmp8 := lang.Apply(tmp6, []any{tmp7, v4}) if lang.IsTruthy(tmp8) { @@ -19752,11 +20470,11 @@ func LoadNS() { { // let // let binding "or__0__auto__" var tmp10 any - tmp11 := checkDerefVar(glojure_DOT_core_pos_QMARK_) + tmp11 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) tmp12 := lang.Apply(tmp11, []any{v3}) if lang.IsTruthy(tmp12) { var tmp13 any - tmp14 := checkDerefVar(glojure_DOT_core_int_QMARK_) + tmp14 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) tmp15 := lang.Apply(tmp14, []any{v3}) if lang.IsTruthy(tmp15) { tmp13 = v3 @@ -19771,7 +20489,7 @@ func LoadNS() { tmp18 := lang.Apply(tmp17, []any{tmp13}) tmp10 = tmp18 } else { - tmp19 := checkDerefVar(glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_seq) tmp20 := lang.Apply(tmp19, []any{v4}) tmp10 = tmp20 } @@ -19792,9 +20510,7 @@ func LoadNS() { // let binding "step" var tmp11 lang.FnFunc tmp11 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v12 := args[0] _ = v12 v13 := args[1] @@ -19803,7 +20519,7 @@ func LoadNS() { var tmp14 any { // let // let binding "s" - tmp15 := checkDerefVar(glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) tmp16 := lang.Apply(tmp15, []any{v13}) var v17 any = tmp16 _ = v17 @@ -19811,7 +20527,7 @@ func LoadNS() { var tmp19 any { // let // let binding "and__0__auto__" - tmp20 := checkDerefVar(glojure_DOT_core_pos_QMARK_) + tmp20 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) tmp21 := lang.Apply(tmp20, []any{v12}) var v22 any = tmp21 _ = v22 @@ -19824,10 +20540,10 @@ func LoadNS() { tmp19 = tmp23 } // end let if lang.IsTruthy(tmp19) { - tmp21 := checkDerefVar(glojure_DOT_core_dec) + tmp21 := checkDerefVar(var_glojure_DOT_core_dec) tmp22 := lang.Apply(tmp21, []any{v12}) var tmp20 any = tmp22 - tmp24 := checkDerefVar(glojure_DOT_core_rest) + tmp24 := checkDerefVar(var_glojure_DOT_core_rest) tmp25 := lang.Apply(tmp24, []any{v17}) var tmp23 any = tmp25 v12 = tmp20 @@ -19840,7 +20556,7 @@ func LoadNS() { } // end let return tmp14 }) - tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2925), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(2929), lang.NewKeyword("end-column"), int(28)) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2925), kw_column, int(19), kw_end_DASH_line, int(2929), kw_end_DASH_column, int(28)) tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) if err != nil { panic(err) @@ -19849,9 +20565,7 @@ func LoadNS() { _ = v14 var tmp15 lang.FnFunc tmp15 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) tmp16 := lang.Apply(v14, []any{v3, v4}) return tmp16 }) @@ -19862,10 +20576,11 @@ func LoadNS() { } return tmp5 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -19873,14 +20588,14 @@ func LoadNS() { } // drop-last { - tmp0 := lang.NewSymbol("drop-last").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return a lazy sequence of all but the last n (default 1) items in coll", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2932), lang.NewKeyword("end-line"), int(2932))).(*lang.Symbol) + tmp0 := sym_drop_DASH_last.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll), lang.NewVector(sym_n, sym_coll)), kw_doc, "Return a lazy sequence of all but the last n (default 1) items in coll", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(2932), kw_end_DASH_line, int(2932))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_drop_last) + tmp4 := checkDerefVar(var_glojure_DOT_core_drop_DASH_last) tmp5 := lang.Apply(tmp4, []any{int64(1), v3}) return tmp5 case 2: @@ -19888,32 +20603,31 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_map) + tmp5 := checkDerefVar(var_glojure_DOT_core_map) var tmp6 lang.FnFunc tmp6 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v7 := args[0] _ = v7 v8 := args[1] _ = v8 return v7 }) - tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2937), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(2937), lang.NewKeyword("end-column"), int(29)) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2937), kw_column, int(18), kw_end_DASH_line, int(2937), kw_end_DASH_column, int(29)) tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp9 := checkDerefVar(glojure_DOT_core_drop) + tmp9 := checkDerefVar(var_glojure_DOT_core_drop) tmp10 := lang.Apply(tmp9, []any{v3, v4}) tmp11 := lang.Apply(tmp5, []any{tmp8, v4, tmp10}) return tmp11 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -19921,7 +20635,7 @@ func LoadNS() { } // drop-while { - tmp0 := lang.NewSymbol("drop-while").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred")), lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the items in coll starting from the\n first item for which (pred item) returns logical false. Returns a\n stateful transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2950), lang.NewKeyword("end-line"), int(2950))).(*lang.Symbol) + tmp0 := sym_drop_DASH_while.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred), lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns a lazy sequence of the items in coll starting from the\n first item for which (pred item) returns logical false. Returns a\n stateful transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(2950), kw_end_DASH_line, int(2950))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -19930,15 +20644,13 @@ func LoadNS() { _ = v3 var tmp4 lang.FnFunc tmp4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v5 := args[0] _ = v5 var tmp6 any { // let // let binding "dv" - tmp7 := checkDerefVar(glojure_DOT_core_volatile_BANG_) + tmp7 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) tmp8 := lang.Apply(tmp7, []any{true}) var v9 any = tmp8 _ = v9 @@ -19961,7 +20673,7 @@ func LoadNS() { var tmp13 any { // let // let binding "drop?" - tmp14 := checkDerefVar(glojure_DOT_core_deref) + tmp14 := checkDerefVar(var_glojure_DOT_core_deref) tmp15 := lang.Apply(tmp14, []any{v9}) var v16 any = tmp15 _ = v16 @@ -19983,7 +20695,7 @@ func LoadNS() { if lang.IsTruthy(tmp18) { tmp17 = v11 } else { - tmp19 := checkDerefVar(glojure_DOT_core_vreset_BANG_) + tmp19 := checkDerefVar(var_glojure_DOT_core_vreset_BANG_) tmp20 := lang.Apply(tmp19, []any{v9, nil}) _ = tmp20 tmp21 := lang.Apply(v5, []any{v11, v12}) @@ -19993,10 +20705,11 @@ func LoadNS() { } // end let return tmp13 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2959), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(2968), lang.NewKeyword("end-column"), int(42)) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2959), kw_column, int(10), kw_end_DASH_line, int(2968), kw_end_DASH_column, int(42)) tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) if err != nil { panic(err) @@ -20005,7 +20718,7 @@ func LoadNS() { } // end let return tmp6 }) - tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2957), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2968), lang.NewKeyword("end-column"), int(44)) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2957), kw_column, int(6), kw_end_DASH_line, int(2968), kw_end_DASH_column, int(44)) tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) if err != nil { panic(err) @@ -20021,9 +20734,7 @@ func LoadNS() { // let binding "step" var tmp6 lang.FnFunc tmp6 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v7 := args[0] _ = v7 v8 := args[1] @@ -20032,7 +20743,7 @@ func LoadNS() { var tmp9 any { // let // let binding "s" - tmp10 := checkDerefVar(glojure_DOT_core_seq) + tmp10 := checkDerefVar(var_glojure_DOT_core_seq) tmp11 := lang.Apply(tmp10, []any{v8}) var v12 any = tmp11 _ = v12 @@ -20044,7 +20755,7 @@ func LoadNS() { _ = v15 var tmp16 any if lang.IsTruthy(v15) { - tmp17 := checkDerefVar(glojure_DOT_core_first) + tmp17 := checkDerefVar(var_glojure_DOT_core_first) tmp18 := lang.Apply(tmp17, []any{v12}) tmp19 := lang.Apply(v7, []any{tmp18}) tmp16 = tmp19 @@ -20055,7 +20766,7 @@ func LoadNS() { } // end let if lang.IsTruthy(tmp14) { var tmp15 any = v7 - tmp17 := checkDerefVar(glojure_DOT_core_rest) + tmp17 := checkDerefVar(var_glojure_DOT_core_rest) tmp18 := lang.Apply(tmp17, []any{v12}) var tmp16 any = tmp18 v7 = tmp15 @@ -20068,7 +20779,7 @@ func LoadNS() { } // end let return tmp9 }) - tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2970), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(2974), lang.NewKeyword("end-column"), int(26)) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2970), kw_column, int(17), kw_end_DASH_line, int(2974), kw_end_DASH_column, int(26)) tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) if err != nil { panic(err) @@ -20077,9 +20788,7 @@ func LoadNS() { _ = v9 var tmp10 lang.FnFunc tmp10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) tmp11 := lang.Apply(v9, []any{v3, v4}) return tmp11 }) @@ -20088,10 +20797,11 @@ func LoadNS() { } // end let return tmp5 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -20099,12 +20809,10 @@ func LoadNS() { } // elide-top-frames { - tmp0 := lang.NewSymbol("elide-top-frames").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4794), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(4794), lang.NewKeyword("end-column"), int(32), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ex"), lang.NewSymbol("class-name"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym_elide_DASH_top_DASH_frames.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(4794), kw_column, int(7), kw_end_DASH_line, int(4794), kw_end_DASH_column, int(32), kw_arglists, lang.NewList(lang.NewVector(sym_ex, sym_class_DASH_name)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -20132,16 +20840,14 @@ func LoadNS() { _ = v10 var tmp11 any if lang.IsTruthy(v8) { - tmp12 := checkDerefVar(glojure_DOT_core_into_array) - tmp13 := checkDerefVar(glojure_DOT_core_drop_while) + tmp12 := checkDerefVar(var_glojure_DOT_core_into_DASH_array) + tmp13 := checkDerefVar(var_glojure_DOT_core_drop_DASH_while) var tmp14 lang.FnFunc tmp14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v15 := args[0] _ = v15 - tmp16 := checkDerefVar(glojure_DOT_core__EQ_) + tmp16 := checkDerefVar(var_glojure_DOT_core__EQ_) tmp17, ok := lang.FieldOrMethod(v15, "getClassName") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v15, "getClassName"))) @@ -20156,7 +20862,7 @@ func LoadNS() { tmp19 := lang.Apply(tmp16, []any{v4, tmp18}) return tmp19 }) - tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4801), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(4801), lang.NewKeyword("end-column"), int(77)) + tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4801), kw_column, int(25), kw_end_DASH_line, int(4801), kw_end_DASH_column, int(77)) tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) if err != nil { panic(err) @@ -20178,7 +20884,7 @@ func LoadNS() { } // end let return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -20186,12 +20892,10 @@ func LoadNS() { } // emit-extend-protocol { - tmp0 := lang.NewSymbol("emit-extend-protocol").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(205), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(205), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("p"), lang.NewSymbol("specs"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym_emit_DASH_extend_DASH_protocol.WithMeta(lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(205), kw_column, int(8), kw_end_DASH_line, int(205), kw_end_DASH_column, int(27), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_p, sym_specs)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -20199,20 +20903,18 @@ func LoadNS() { var tmp5 any { // let // let binding "impls" - tmp6 := checkDerefVar(glojure_DOT_core_parse_impls) + tmp6 := checkDerefVar(var_glojure_DOT_core_parse_DASH_impls) tmp7 := lang.Apply(tmp6, []any{v4}) var v8 any = tmp7 _ = v8 - tmp9 := checkDerefVar(glojure_DOT_core_seq) - tmp10 := checkDerefVar(glojure_DOT_core_concat) - tmp11 := checkDerefVar(glojure_DOT_core_list) - tmp12 := lang.Apply(tmp11, []any{lang.NewSymbol("do")}) - tmp13 := checkDerefVar(glojure_DOT_core_map) + tmp9 := checkDerefVar(var_glojure_DOT_core_seq) + tmp10 := checkDerefVar(var_glojure_DOT_core_concat) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_do}) + tmp13 := checkDerefVar(var_glojure_DOT_core_map) var tmp14 lang.FnFunc tmp14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v15 := args[0] _ = v15 var tmp16 any @@ -20221,22 +20923,22 @@ func LoadNS() { var v17 any = v15 _ = v17 // let binding "t" - tmp18 := checkDerefVar(glojure_DOT_core_nth) + tmp18 := checkDerefVar(var_glojure_DOT_core_nth) tmp19 := lang.Apply(tmp18, []any{v17, int64(0), nil}) var v20 any = tmp19 _ = v20 // let binding "fs" - tmp21 := checkDerefVar(glojure_DOT_core_nth) + tmp21 := checkDerefVar(var_glojure_DOT_core_nth) tmp22 := lang.Apply(tmp21, []any{v17, int64(1), nil}) var v23 any = tmp22 _ = v23 - tmp24 := checkDerefVar(glojure_DOT_core_seq) - tmp25 := checkDerefVar(glojure_DOT_core_concat) - tmp26 := checkDerefVar(glojure_DOT_core_list) - tmp27 := lang.Apply(tmp26, []any{lang.NewSymbol("glojure.core/extend-type")}) - tmp28 := checkDerefVar(glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_seq) + tmp25 := checkDerefVar(var_glojure_DOT_core_concat) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{sym_glojure_DOT_core_SLASH_extend_DASH_type}) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) tmp29 := lang.Apply(tmp28, []any{v20}) - tmp30 := checkDerefVar(glojure_DOT_core_list) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) tmp31 := lang.Apply(tmp30, []any{v3}) tmp32 := lang.Apply(tmp25, []any{tmp27, tmp29, tmp31, v23}) tmp33 := lang.Apply(tmp24, []any{tmp32}) @@ -20244,7 +20946,7 @@ func LoadNS() { } // end let return tmp16 }) - tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(208), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(209), lang.NewKeyword("end-column"), int(42)) + tmp15 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(208), kw_column, int(15), kw_end_DASH_line, int(209), kw_end_DASH_column, int(42)) tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) if err != nil { panic(err) @@ -20256,7 +20958,7 @@ func LoadNS() { } // end let return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -20264,12 +20966,10 @@ func LoadNS() { } // emit-extend-type { - tmp0 := lang.NewSymbol("emit-extend-type").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(175), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(175), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"), lang.NewSymbol("specs"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym_emit_DASH_extend_DASH_type.WithMeta(lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(175), kw_column, int(8), kw_end_DASH_line, int(175), kw_end_DASH_column, int(23), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_c, sym_specs)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -20277,19 +20977,19 @@ func LoadNS() { var tmp5 any { // let // let binding "impls" - tmp6 := checkDerefVar(glojure_DOT_core_parse_impls) + tmp6 := checkDerefVar(var_glojure_DOT_core_parse_DASH_impls) tmp7 := lang.Apply(tmp6, []any{v4}) var v8 any = tmp7 _ = v8 - tmp9 := checkDerefVar(glojure_DOT_core_seq) - tmp10 := checkDerefVar(glojure_DOT_core_concat) - tmp11 := checkDerefVar(glojure_DOT_core_list) - tmp12 := lang.Apply(tmp11, []any{lang.NewSymbol("glojure.core/extend")}) - tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp9 := checkDerefVar(var_glojure_DOT_core_seq) + tmp10 := checkDerefVar(var_glojure_DOT_core_concat) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_glojure_DOT_core_SLASH_extend}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) tmp14 := lang.Apply(tmp13, []any{v3}) - tmp15 := checkDerefVar(glojure_DOT_core_mapcat) - tmp16 := checkDerefVar(glojure_DOT_core_partial) - tmp17 := checkDerefVar(glojure_DOT_core_emit_hinted_impl) + tmp15 := checkDerefVar(var_glojure_DOT_core_mapcat) + tmp16 := checkDerefVar(var_glojure_DOT_core_partial) + tmp17 := checkDerefVar(var_glojure_DOT_core_emit_DASH_hinted_DASH_impl) tmp18 := lang.Apply(tmp16, []any{tmp17, v3}) tmp19 := lang.Apply(tmp15, []any{tmp18, v8}) tmp20 := lang.Apply(tmp10, []any{tmp12, tmp14, tmp19}) @@ -20298,7 +20998,7 @@ func LoadNS() { } // end let return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -20306,12 +21006,10 @@ func LoadNS() { } // emit-hinted-impl { - tmp0 := lang.NewSymbol("emit-hinted-impl").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(163), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(163), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"), lang.NewVector(lang.NewSymbol("p"), lang.NewSymbol("fs")))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym_emit_DASH_hinted_DASH_impl.WithMeta(lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(163), kw_column, int(8), kw_end_DASH_line, int(163), kw_end_DASH_column, int(23), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_c, lang.NewVector(sym_p, sym_fs))), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -20322,12 +21020,12 @@ func LoadNS() { var v6 any = v4 _ = v6 // let binding "p" - tmp7 := checkDerefVar(glojure_DOT_core_nth) + tmp7 := checkDerefVar(var_glojure_DOT_core_nth) tmp8 := lang.Apply(tmp7, []any{v6, int64(0), nil}) var v9 any = tmp8 _ = v9 // let binding "fs" - tmp10 := checkDerefVar(glojure_DOT_core_nth) + tmp10 := checkDerefVar(var_glojure_DOT_core_nth) tmp11 := lang.Apply(tmp10, []any{v6, int64(1), nil}) var v12 any = tmp11 _ = v12 @@ -20336,21 +21034,19 @@ func LoadNS() { // let binding "hint" var tmp14 lang.FnFunc tmp14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v15 := args[0] _ = v15 var tmp16 any { // let // let binding "specs" var tmp17 any - tmp18 := checkDerefVar(glojure_DOT_core_vector_QMARK_) - tmp19 := checkDerefVar(glojure_DOT_core_first) + tmp18 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp19 := checkDerefVar(var_glojure_DOT_core_first) tmp20 := lang.Apply(tmp19, []any{v15}) tmp21 := lang.Apply(tmp18, []any{tmp20}) if lang.IsTruthy(tmp21) { - tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) tmp23 := lang.Apply(tmp22, []any{v15}) tmp17 = tmp23 } else { @@ -20358,12 +21054,10 @@ func LoadNS() { } var v24 any = tmp17 _ = v24 - tmp25 := checkDerefVar(glojure_DOT_core_map) + tmp25 := checkDerefVar(var_glojure_DOT_core_map) var tmp26 lang.FnFunc tmp26 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v27 := args[0] _ = v27 var tmp28 any @@ -20372,17 +21066,17 @@ func LoadNS() { var v29 any = v27 _ = v29 // let binding "seq__286" - tmp30 := checkDerefVar(glojure_DOT_core_seq) + tmp30 := checkDerefVar(var_glojure_DOT_core_seq) tmp31 := lang.Apply(tmp30, []any{v29}) var v32 any = tmp31 _ = v32 // let binding "first__287" - tmp33 := checkDerefVar(glojure_DOT_core_first) + tmp33 := checkDerefVar(var_glojure_DOT_core_first) tmp34 := lang.Apply(tmp33, []any{v32}) var v35 any = tmp34 _ = v35 // let binding "seq__286" - tmp36 := checkDerefVar(glojure_DOT_core_next) + tmp36 := checkDerefVar(var_glojure_DOT_core_next) tmp37 := lang.Apply(tmp36, []any{v32}) var v38 any = tmp37 _ = v38 @@ -20390,17 +21084,17 @@ func LoadNS() { var v39 any = v35 _ = v39 // let binding "seq__289" - tmp40 := checkDerefVar(glojure_DOT_core_seq) + tmp40 := checkDerefVar(var_glojure_DOT_core_seq) tmp41 := lang.Apply(tmp40, []any{v39}) var v42 any = tmp41 _ = v42 // let binding "first__290" - tmp43 := checkDerefVar(glojure_DOT_core_first) + tmp43 := checkDerefVar(var_glojure_DOT_core_first) tmp44 := lang.Apply(tmp43, []any{v42}) var v45 any = tmp44 _ = v45 // let binding "seq__289" - tmp46 := checkDerefVar(glojure_DOT_core_next) + tmp46 := checkDerefVar(var_glojure_DOT_core_next) tmp47 := lang.Apply(tmp46, []any{v42}) var v48 any = tmp47 _ = v48 @@ -20413,19 +21107,19 @@ func LoadNS() { // let binding "body" var v51 any = v38 _ = v51 - tmp52 := checkDerefVar(glojure_DOT_core_cons) - tmp53 := checkDerefVar(glojure_DOT_core_apply) - tmp54 := checkDerefVar(glojure_DOT_core_vector) - tmp55 := checkDerefVar(glojure_DOT_core_vary_meta) - tmp56 := checkDerefVar(glojure_DOT_core_assoc) - tmp57 := lang.Apply(tmp55, []any{v49, tmp56, lang.NewKeyword("tag"), v3}) + tmp52 := checkDerefVar(var_glojure_DOT_core_cons) + tmp53 := checkDerefVar(var_glojure_DOT_core_apply) + tmp54 := checkDerefVar(var_glojure_DOT_core_vector) + tmp55 := checkDerefVar(var_glojure_DOT_core_vary_DASH_meta) + tmp56 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp57 := lang.Apply(tmp55, []any{v49, tmp56, kw_tag, v3}) tmp58 := lang.Apply(tmp53, []any{tmp54, tmp57, v50}) tmp59 := lang.Apply(tmp52, []any{tmp58, v51}) tmp28 = tmp59 } // end let return tmp28 }) - tmp27 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(168), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(170), lang.NewKeyword("end-column"), int(36)) + tmp27 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(168), kw_column, int(23), kw_end_DASH_line, int(170), kw_end_DASH_column, int(36)) tmp28, err := lang.WithMeta(tmp26, tmp27.(lang.IPersistentMap)) if err != nil { panic(err) @@ -20435,52 +21129,48 @@ func LoadNS() { } // end let return tmp16 }) - tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(164), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(171), lang.NewKeyword("end-column"), int(30)) + tmp15 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(164), kw_column, int(14), kw_end_DASH_line, int(171), kw_end_DASH_column, int(30)) tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) if err != nil { panic(err) } var v17 any = tmp16 _ = v17 - tmp18 := checkDerefVar(glojure_DOT_core_zipmap) - tmp19 := checkDerefVar(glojure_DOT_core_map) + tmp18 := checkDerefVar(var_glojure_DOT_core_zipmap) + tmp19 := checkDerefVar(var_glojure_DOT_core_map) var tmp20 lang.FnFunc tmp20 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v21 := args[0] _ = v21 - tmp22 := checkDerefVar(glojure_DOT_core_keyword) - tmp23 := checkDerefVar(glojure_DOT_core_name) - tmp24 := checkDerefVar(glojure_DOT_core_first) + tmp22 := checkDerefVar(var_glojure_DOT_core_keyword) + tmp23 := checkDerefVar(var_glojure_DOT_core_name) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) tmp25 := lang.Apply(tmp24, []any{v21}) tmp26 := lang.Apply(tmp23, []any{tmp25}) tmp27 := lang.Apply(tmp22, []any{tmp26}) return tmp27 }) - tmp21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(172), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(172), lang.NewKeyword("end-column"), int(46)) + tmp21 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(172), kw_column, int(21), kw_end_DASH_line, int(172), kw_end_DASH_column, int(46)) tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) if err != nil { panic(err) } tmp23 := lang.Apply(tmp19, []any{tmp22, v12}) - tmp24 := checkDerefVar(glojure_DOT_core_map) + tmp24 := checkDerefVar(var_glojure_DOT_core_map) var tmp25 lang.FnFunc tmp25 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v26 := args[0] _ = v26 - tmp27 := checkDerefVar(glojure_DOT_core_cons) - tmp28 := checkDerefVar(glojure_DOT_core_drop) + tmp27 := checkDerefVar(var_glojure_DOT_core_cons) + tmp28 := checkDerefVar(var_glojure_DOT_core_drop) tmp29 := lang.Apply(tmp28, []any{int64(1), v26}) tmp30 := lang.Apply(v17, []any{tmp29}) - tmp31 := lang.Apply(tmp27, []any{lang.NewSymbol("glojure.core/fn"), tmp30}) + tmp31 := lang.Apply(tmp27, []any{sym_glojure_DOT_core_SLASH_fn, tmp30}) return tmp31 }) - tmp26 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(173), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(173), lang.NewKeyword("end-column"), int(49)) + tmp26 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(173), kw_column, int(21), kw_end_DASH_line, int(173), kw_end_DASH_column, int(49)) tmp27, err := lang.WithMeta(tmp25, tmp26.(lang.IPersistentMap)) if err != nil { panic(err) @@ -20488,7 +21178,7 @@ func LoadNS() { tmp28 := lang.Apply(tmp24, []any{tmp27, v12}) tmp29 := lang.Apply(tmp18, []any{tmp23, tmp28}) tmp30 := lang.NewVector(v9, tmp29) - tmp31 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(172), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(173), lang.NewKeyword("end-column"), int(55)) + tmp31 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(172), kw_column, int(5), kw_end_DASH_line, int(173), kw_end_DASH_column, int(55)) tmp32, err := lang.WithMeta(tmp30, tmp31.(lang.IPersistentMap)) if err != nil { panic(err) @@ -20499,7 +21189,7 @@ func LoadNS() { } // end let return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -20507,16 +21197,14 @@ func LoadNS() { } // empty { - tmp0 := lang.NewSymbol("empty").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns an empty collection of the same category as coll, or nil", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5265), lang.NewKeyword("end-line"), int(5265))).(*lang.Symbol) + tmp0 := sym_empty.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns an empty collection of the same category as coll, or nil", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(5265), kw_end_DASH_line, int(5265))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any - tmp5 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp6 := reflect.TypeOf((*lang.IPersistentCollection)(nil)).Elem() tmp7 := lang.Apply(tmp5, []any{tmp6, v3}) if lang.IsTruthy(tmp7) { @@ -20536,7 +21224,7 @@ func LoadNS() { } return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -20544,33 +21232,31 @@ func LoadNS() { } // empty? { - tmp0 := lang.NewSymbol("empty?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll has no items. To check the emptiness of a seq,\n please use the idiom (seq x) rather than (not (empty? x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6247), lang.NewKeyword("end-line"), int(6247))).(*lang.Symbol) + tmp0 := sym_empty_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns true if coll has no items. To check the emptiness of a seq,\n please use the idiom (seq x) rather than (not (empty? x))", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(6247), kw_end_DASH_line, int(6247))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any - tmp5 := checkDerefVar(glojure_DOT_core_counted_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_counted_QMARK_) tmp6 := lang.Apply(tmp5, []any{v3}) if lang.IsTruthy(tmp6) { - tmp7 := checkDerefVar(glojure_DOT_core_zero_QMARK_) - tmp8 := checkDerefVar(glojure_DOT_core_count) + tmp7 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) + tmp8 := checkDerefVar(var_glojure_DOT_core_count) tmp9 := lang.Apply(tmp8, []any{v3}) tmp10 := lang.Apply(tmp7, []any{tmp9}) tmp4 = tmp10 } else { - tmp11 := checkDerefVar(glojure_DOT_core_not) - tmp12 := checkDerefVar(glojure_DOT_core_seq) + tmp11 := checkDerefVar(var_glojure_DOT_core_not) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := lang.Apply(tmp12, []any{v3}) tmp14 := lang.Apply(tmp11, []any{tmp13}) tmp4 = tmp14 } return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -20578,12 +21264,10 @@ func LoadNS() { } // ensure { - tmp0 := lang.NewSymbol("ensure").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref"))), lang.NewKeyword("doc"), "Must be called in a transaction. Protects the ref from modification\n by other transactions. Returns the in-transaction-value of\n ref. Allows for more concurrency than (ref-set ref @ref)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2480), lang.NewKeyword("end-line"), int(2480))).(*lang.Symbol) + tmp0 := sym_ensure.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ref)), kw_doc, "Must be called in a transaction. Protects the ref from modification\n by other transactions. Returns the in-transaction-value of\n ref. Allows for more concurrency than (ref-set ref @ref)", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(2480), kw_end_DASH_line, int(2480))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4, _ := lang.FieldOrMethod(v3, "touch") @@ -20599,7 +21283,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{}) return tmp7 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -20607,27 +21291,25 @@ func LoadNS() { } // ensure-reduced { - tmp0 := lang.NewSymbol("ensure-reduced").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "If x is already reduced?, returns it, else returns (reduced x)", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2841), lang.NewKeyword("end-line"), int(2841))).(*lang.Symbol) + tmp0 := sym_ensure_DASH_reduced.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "If x is already reduced?, returns it, else returns (reduced x)", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(2841), kw_end_DASH_line, int(2841))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any - tmp5 := checkDerefVar(glojure_DOT_core_reduced_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) tmp6 := lang.Apply(tmp5, []any{v3}) if lang.IsTruthy(tmp6) { tmp4 = v3 } else { - tmp7 := checkDerefVar(glojure_DOT_core_reduced) + tmp7 := checkDerefVar(var_glojure_DOT_core_reduced) tmp8 := lang.Apply(tmp7, []any{v3}) tmp4 = tmp8 } return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -20635,18 +21317,16 @@ func LoadNS() { } // enumeration-seq { - tmp0 := lang.NewSymbol("enumeration-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("e"))), lang.NewKeyword("doc"), "Returns a seq on a java.util.Enumeration", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5710), lang.NewKeyword("end-line"), int(5710))).(*lang.Symbol) + tmp0 := sym_enumeration_DASH_seq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_e)), kw_doc, "Returns a seq on a java.util.Enumeration", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(5710), kw_end_DASH_line, int(5710))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4 := lang.Apply(nil, []any{v3}) return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -20654,12 +21334,10 @@ func LoadNS() { } // error-handler { - tmp0 := lang.NewSymbol("error-handler").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("doc"), "Returns the error-handler of agent a, or nil if there is none.\n See set-error-handler!", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2202), lang.NewKeyword("end-line"), int(2202))).(*lang.Symbol) + tmp0 := sym_error_DASH_handler.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a)), kw_doc, "Returns the error-handler of agent a, or nil if there is none.\n See set-error-handler!", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(2202), kw_end_DASH_line, int(2202))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4, ok := lang.FieldOrMethod(v3, "getErrorHandler") @@ -20675,7 +21353,7 @@ func LoadNS() { } return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -20683,12 +21361,10 @@ func LoadNS() { } // error-mode { - tmp0 := lang.NewSymbol("error-mode").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"))), lang.NewKeyword("doc"), "Returns the error-mode of agent a. See set-error-mode!", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2227), lang.NewKeyword("end-line"), int(2227))).(*lang.Symbol) + tmp0 := sym_error_DASH_mode.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a)), kw_doc, "Returns the error-mode of agent a. See set-error-mode!", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(2227), kw_end_DASH_line, int(2227))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4, ok := lang.FieldOrMethod(v3, "getErrorMode") @@ -20704,7 +21380,7 @@ func LoadNS() { } return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -20712,12 +21388,10 @@ func LoadNS() { } // eval { - tmp0 := lang.NewSymbol("eval").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("form"))), lang.NewKeyword("doc"), "Evaluates the form data structure (not text!) and returns the result.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3203), lang.NewKeyword("end-line"), int(3203))).(*lang.Symbol) + tmp0 := sym_eval.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_form)), kw_doc, "Evaluates the form data structure (not text!) and returns the result.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3203), kw_end_DASH_line, int(3203))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4, _ := lang.FieldOrMethod(runtime7.Compiler, "Eval") @@ -20727,7 +21401,7 @@ func LoadNS() { tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -20735,33 +21409,31 @@ func LoadNS() { } // even? { - tmp0 := lang.NewSymbol("even?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is even, throws an exception if n is not an integer", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1381), lang.NewKeyword("end-line"), int(1381))).(*lang.Symbol) + tmp0 := sym_even_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_doc, "Returns true if n is even, throws an exception if n is not an integer", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(1381), kw_end_DASH_line, int(1381))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any - tmp5 := checkDerefVar(glojure_DOT_core_integer_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_integer_QMARK_) tmp6 := lang.Apply(tmp5, []any{v3}) if lang.IsTruthy(tmp6) { - tmp7 := checkDerefVar(glojure_DOT_core_zero_QMARK_) - tmp8 := checkDerefVar(glojure_DOT_core_bit_and) + tmp7 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) + tmp8 := checkDerefVar(var_glojure_DOT_core_bit_DASH_and) tmp9 := lang.Apply(lang.UncheckedLongCast, []any{v3}) tmp10 := lang.Apply(tmp8, []any{tmp9, int64(1)}) tmp11 := lang.Apply(tmp7, []any{tmp10}) tmp4 = tmp11 } else { - tmp12 := checkDerefVar(glojure_DOT_core_str) + tmp12 := checkDerefVar(var_glojure_DOT_core_str) tmp13 := lang.Apply(tmp12, []any{"Argument must be an integer: ", v3}) tmp14 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp13}) panic(tmp14) } return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -20769,7 +21441,7 @@ func LoadNS() { } // every-pred { - tmp0 := lang.NewSymbol("every-pred").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("p")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2"), lang.NewSymbol("p3")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2"), lang.NewSymbol("p3"), lang.NewSymbol("&"), lang.NewSymbol("ps"))), lang.NewKeyword("doc"), "Takes a set of predicates and returns a function f that returns true if all of its\n composing predicates return a logical true value against all of its arguments, else it returns\n false. Note that f is short-circuiting in that it will stop execution on the first\n argument that triggers a logical false result against the original predicates.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7422), lang.NewKeyword("end-line"), int(7422))).(*lang.Symbol) + tmp0 := sym_every_DASH_pred.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_p), lang.NewVector(sym_p1, sym_p2), lang.NewVector(sym_p1, sym_p2, sym_p3), lang.NewVector(sym_p1, sym_p2, sym_p3, sym__AMP_, sym_ps)), kw_doc, "Takes a set of predicates and returns a function f that returns true if all of its\n composing predicates return a logical true value against all of its arguments, else it returns\n false. Note that f is short-circuiting in that it will stop execution on the first\n argument that triggers a logical false result against the original predicates.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(7422), kw_end_DASH_line, int(7422))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -20786,7 +21458,7 @@ func LoadNS() { case 1: v6 := args[0] _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_boolean) + tmp7 := checkDerefVar(var_glojure_DOT_core_boolean) tmp8 := lang.Apply(v3, []any{v6}) tmp9 := lang.Apply(tmp7, []any{tmp8}) return tmp9 @@ -20795,7 +21467,7 @@ func LoadNS() { _ = v6 v7 := args[1] _ = v7 - tmp8 := checkDerefVar(glojure_DOT_core_boolean) + tmp8 := checkDerefVar(var_glojure_DOT_core_boolean) var tmp9 any { // let // let binding "and__0__auto__" @@ -20820,7 +21492,7 @@ func LoadNS() { _ = v7 v8 := args[2] _ = v8 - tmp9 := checkDerefVar(glojure_DOT_core_boolean) + tmp9 := checkDerefVar(var_glojure_DOT_core_boolean) var tmp10 any { // let // let binding "and__0__auto__" @@ -20853,9 +21525,7 @@ func LoadNS() { tmp11 := lang.Apply(tmp9, []any{tmp10}) return tmp11 default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v6 := args[0] _ = v6 v7 := args[1] @@ -20864,7 +21534,7 @@ func LoadNS() { _ = v8 var v9 any = lang.NewList(args[3:]...) _ = v9 - tmp10 := checkDerefVar(glojure_DOT_core_boolean) + tmp10 := checkDerefVar(var_glojure_DOT_core_boolean) var tmp11 any { // let // let binding "and__0__auto__" @@ -20873,7 +21543,7 @@ func LoadNS() { _ = v13 var tmp14 any if lang.IsTruthy(v13) { - tmp15 := checkDerefVar(glojure_DOT_core_every_QMARK_) + tmp15 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) tmp16 := lang.Apply(tmp15, []any{v3, v9}) tmp14 = tmp16 } else { @@ -20888,7 +21558,7 @@ func LoadNS() { v5 = tmp4 _ = v5 } - tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7429), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7435), lang.NewKeyword("end-column"), int(56)) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7429), kw_column, int(6), kw_end_DASH_line, int(7435), kw_end_DASH_column, int(56)) tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) if err != nil { panic(err) @@ -20909,7 +21579,7 @@ func LoadNS() { case 1: v7 := args[0] _ = v7 - tmp8 := checkDerefVar(glojure_DOT_core_boolean) + tmp8 := checkDerefVar(var_glojure_DOT_core_boolean) var tmp9 any { // let // let binding "and__0__auto__" @@ -20932,7 +21602,7 @@ func LoadNS() { _ = v7 v8 := args[1] _ = v8 - tmp9 := checkDerefVar(glojure_DOT_core_boolean) + tmp9 := checkDerefVar(var_glojure_DOT_core_boolean) var tmp10 any { // let // let binding "and__0__auto__" @@ -20985,7 +21655,7 @@ func LoadNS() { _ = v8 v9 := args[2] _ = v9 - tmp10 := checkDerefVar(glojure_DOT_core_boolean) + tmp10 := checkDerefVar(var_glojure_DOT_core_boolean) var tmp11 any { // let // let binding "and__0__auto__" @@ -21060,9 +21730,7 @@ func LoadNS() { tmp12 := lang.Apply(tmp10, []any{tmp11}) return tmp12 default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v7 := args[0] _ = v7 v8 := args[1] @@ -21071,7 +21739,7 @@ func LoadNS() { _ = v9 var v10 any = lang.NewList(args[3:]...) _ = v10 - tmp11 := checkDerefVar(glojure_DOT_core_boolean) + tmp11 := checkDerefVar(var_glojure_DOT_core_boolean) var tmp12 any { // let // let binding "and__0__auto__" @@ -21080,12 +21748,10 @@ func LoadNS() { _ = v14 var tmp15 any if lang.IsTruthy(v14) { - tmp16 := checkDerefVar(glojure_DOT_core_every_QMARK_) + tmp16 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) var tmp17 lang.FnFunc tmp17 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v18 := args[0] _ = v18 var tmp19 any @@ -21105,7 +21771,7 @@ func LoadNS() { } // end let return tmp19 }) - tmp18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7443), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(7443), lang.NewKeyword("end-column"), int(65)) + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7443), kw_column, int(46), kw_end_DASH_line, int(7443), kw_end_DASH_column, int(65)) tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) if err != nil { panic(err) @@ -21124,7 +21790,7 @@ func LoadNS() { v6 = tmp5 _ = v6 } - tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7437), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7443), lang.NewKeyword("end-column"), int(75)) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7437), kw_column, int(6), kw_end_DASH_line, int(7443), kw_end_DASH_column, int(75)) tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) if err != nil { panic(err) @@ -21147,7 +21813,7 @@ func LoadNS() { case 1: v8 := args[0] _ = v8 - tmp9 := checkDerefVar(glojure_DOT_core_boolean) + tmp9 := checkDerefVar(var_glojure_DOT_core_boolean) var tmp10 any { // let // let binding "and__0__auto__" @@ -21184,7 +21850,7 @@ func LoadNS() { _ = v8 v9 := args[1] _ = v9 - tmp10 := checkDerefVar(glojure_DOT_core_boolean) + tmp10 := checkDerefVar(var_glojure_DOT_core_boolean) var tmp11 any { // let // let binding "and__0__auto__" @@ -21265,7 +21931,7 @@ func LoadNS() { _ = v9 v10 := args[2] _ = v10 - tmp11 := checkDerefVar(glojure_DOT_core_boolean) + tmp11 := checkDerefVar(var_glojure_DOT_core_boolean) var tmp12 any { // let // let binding "and__0__auto__" @@ -21382,9 +22048,7 @@ func LoadNS() { tmp13 := lang.Apply(tmp11, []any{tmp12}) return tmp13 default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v8 := args[0] _ = v8 v9 := args[1] @@ -21393,7 +22057,7 @@ func LoadNS() { _ = v10 var v11 any = lang.NewList(args[3:]...) _ = v11 - tmp12 := checkDerefVar(glojure_DOT_core_boolean) + tmp12 := checkDerefVar(var_glojure_DOT_core_boolean) var tmp13 any { // let // let binding "and__0__auto__" @@ -21402,12 +22066,10 @@ func LoadNS() { _ = v15 var tmp16 any if lang.IsTruthy(v15) { - tmp17 := checkDerefVar(glojure_DOT_core_every_QMARK_) + tmp17 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) var tmp18 lang.FnFunc tmp18 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v19 := args[0] _ = v19 var tmp20 any @@ -21441,7 +22103,7 @@ func LoadNS() { } // end let return tmp20 }) - tmp19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7451), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(7451), lang.NewKeyword("end-column"), int(72)) + tmp19 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7451), kw_column, int(46), kw_end_DASH_line, int(7451), kw_end_DASH_column, int(72)) tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) if err != nil { panic(err) @@ -21460,16 +22122,14 @@ func LoadNS() { v7 = tmp6 _ = v7 } - tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7445), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7451), lang.NewKeyword("end-column"), int(82)) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7445), kw_column, int(6), kw_end_DASH_line, int(7451), kw_end_DASH_column, int(82)) tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) if err != nil { panic(err) } return tmp8 default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -21481,7 +22141,7 @@ func LoadNS() { var tmp7 any { // let // let binding "ps" - tmp8 := checkDerefVar(glojure_DOT_core_list_STAR_) + tmp8 := checkDerefVar(var_glojure_DOT_core_list_STAR_) tmp9 := lang.Apply(tmp8, []any{v3, v4, v5, v6}) var v10 any = tmp9 _ = v10 @@ -21495,18 +22155,16 @@ func LoadNS() { case 1: v13 := args[0] _ = v13 - tmp14 := checkDerefVar(glojure_DOT_core_every_QMARK_) + tmp14 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) var tmp15 lang.FnFunc tmp15 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v16 := args[0] _ = v16 tmp17 := lang.Apply(v16, []any{v13}) return tmp17 }) - tmp16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7456), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(7456), lang.NewKeyword("end-column"), int(28)) + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7456), kw_column, int(23), kw_end_DASH_line, int(7456), kw_end_DASH_column, int(28)) tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) if err != nil { panic(err) @@ -21518,12 +22176,10 @@ func LoadNS() { _ = v13 v14 := args[1] _ = v14 - tmp15 := checkDerefVar(glojure_DOT_core_every_QMARK_) + tmp15 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) var tmp16 lang.FnFunc tmp16 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v17 := args[0] _ = v17 var tmp18 any @@ -21543,7 +22199,7 @@ func LoadNS() { } // end let return tmp18 }) - tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7457), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7457), lang.NewKeyword("end-column"), int(42)) + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7457), kw_column, int(25), kw_end_DASH_line, int(7457), kw_end_DASH_column, int(42)) tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) if err != nil { panic(err) @@ -21557,12 +22213,10 @@ func LoadNS() { _ = v14 v15 := args[2] _ = v15 - tmp16 := checkDerefVar(glojure_DOT_core_every_QMARK_) + tmp16 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) var tmp17 lang.FnFunc tmp17 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v18 := args[0] _ = v18 var tmp19 any @@ -21596,7 +22250,7 @@ func LoadNS() { } // end let return tmp19 }) - tmp18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7458), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(7458), lang.NewKeyword("end-column"), int(50)) + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7458), kw_column, int(27), kw_end_DASH_line, int(7458), kw_end_DASH_column, int(50)) tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) if err != nil { panic(err) @@ -21604,9 +22258,7 @@ func LoadNS() { tmp20 := lang.Apply(tmp16, []any{tmp19, v10}) return tmp20 default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v13 := args[0] _ = v13 v14 := args[1] @@ -21615,7 +22267,7 @@ func LoadNS() { _ = v15 var v16 any = lang.NewList(args[3:]...) _ = v16 - tmp17 := checkDerefVar(glojure_DOT_core_boolean) + tmp17 := checkDerefVar(var_glojure_DOT_core_boolean) var tmp18 any { // let // let binding "and__0__auto__" @@ -21624,19 +22276,17 @@ func LoadNS() { _ = v20 var tmp21 any if lang.IsTruthy(v20) { - tmp22 := checkDerefVar(glojure_DOT_core_every_QMARK_) + tmp22 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) var tmp23 lang.FnFunc tmp23 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v24 := args[0] _ = v24 - tmp25 := checkDerefVar(glojure_DOT_core_every_QMARK_) + tmp25 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) tmp26 := lang.Apply(tmp25, []any{v24, v16}) return tmp26 }) - tmp24 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7460), lang.NewKeyword("column"), int(48), lang.NewKeyword("end-line"), int(7460), lang.NewKeyword("end-column"), int(63)) + tmp24 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7460), kw_column, int(48), kw_end_DASH_line, int(7460), kw_end_DASH_column, int(63)) tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) if err != nil { panic(err) @@ -21655,7 +22305,7 @@ func LoadNS() { v12 = tmp11 _ = v12 } - tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7454), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7460), lang.NewKeyword("end-column"), int(71)) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7454), kw_column, int(8), kw_end_DASH_line, int(7460), kw_end_DASH_column, int(71)) tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) if err != nil { panic(err) @@ -21665,7 +22315,7 @@ func LoadNS() { return tmp7 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -21674,32 +22324,30 @@ func LoadNS() { // every? { tmp1 := reflect.TypeOf(false) - tmp0 := lang.NewSymbol("every?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if (pred x) is logical true for every x in coll, else\n false.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2664), lang.NewKeyword("end-line"), int(2664))).(*lang.Symbol) + tmp0 := sym_every_QMARK_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns true if (pred x) is logical true for every x in coll, else\n false.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(2664), kw_end_DASH_line, int(2664))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v4 := args[0] _ = v4 v5 := args[1] _ = v5 recur_loop_480: var tmp6 any - tmp7 := checkDerefVar(glojure_DOT_core_nil_QMARK_) - tmp8 := checkDerefVar(glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) tmp9 := lang.Apply(tmp8, []any{v5}) tmp10 := lang.Apply(tmp7, []any{tmp9}) if lang.IsTruthy(tmp10) { tmp6 = true } else { var tmp11 any - tmp12 := checkDerefVar(glojure_DOT_core_first) + tmp12 := checkDerefVar(var_glojure_DOT_core_first) tmp13 := lang.Apply(tmp12, []any{v5}) tmp14 := lang.Apply(v4, []any{tmp13}) if lang.IsTruthy(tmp14) { var tmp15 any = v4 - tmp17 := checkDerefVar(glojure_DOT_core_next) + tmp17 := checkDerefVar(var_glojure_DOT_core_next) tmp18 := lang.Apply(tmp17, []any{v5}) var tmp16 any = tmp18 v4 = tmp15 @@ -21707,7 +22355,7 @@ func LoadNS() { goto recur_loop_480 } else { var tmp19 any - if lang.IsTruthy(lang.NewKeyword("else")) { + if lang.IsTruthy(kw_else) { tmp19 = false } else { } @@ -21718,7 +22366,7 @@ func LoadNS() { return tmp6 }) tmp4 := reflect.TypeOf(false) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -21726,16 +22374,14 @@ func LoadNS() { } // ex-cause { - tmp0 := lang.NewSymbol("ex-cause").WithMeta(lang.NewMap(lang.NewKeyword("tag"), nil, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ex"))), lang.NewKeyword("doc"), "Returns the cause of ex if ex is a Throwable.\n Otherwise returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4828), lang.NewKeyword("end-line"), int(4828))).(*lang.Symbol) + tmp0 := sym_ex_DASH_cause.WithMeta(lang.NewMap(kw_tag, nil, kw_arglists, lang.NewList(lang.NewVector(sym_ex)), kw_doc, "Returns the cause of ex if ex is a Throwable.\n Otherwise returns nil.", kw_file, "glojure/core.glj", kw_added, "1.10", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(4828), kw_end_DASH_line, int(4828))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any - tmp5 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp6 := lang.Apply(tmp5, []any{lang.Throwable, v3}) if lang.IsTruthy(tmp6) { tmp7, ok := lang.FieldOrMethod(v3, "getCause") @@ -21754,7 +22400,7 @@ func LoadNS() { } return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -21762,16 +22408,14 @@ func LoadNS() { } // ex-data { - tmp0 := lang.NewSymbol("ex-data").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ex"))), lang.NewKeyword("doc"), "Returns exception data (a map) if ex is an IExceptionInfo.\n Otherwise returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4812), lang.NewKeyword("end-line"), int(4812))).(*lang.Symbol) + tmp0 := sym_ex_DASH_data.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ex)), kw_doc, "Returns exception data (a map) if ex is an IExceptionInfo.\n Otherwise returns nil.", kw_file, "glojure/core.glj", kw_added, "1.4", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4812), kw_end_DASH_line, int(4812))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any - tmp5 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp6 := lang.Apply(tmp5, []any{nil, v3}) if lang.IsTruthy(tmp6) { tmp7, ok := lang.FieldOrMethod(v3, "getData") @@ -21790,7 +22434,7 @@ func LoadNS() { } return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -21798,7 +22442,7 @@ func LoadNS() { } // ex-info { - tmp0 := lang.NewSymbol("ex-info").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("msg"), lang.NewSymbol("map")), lang.NewVector(lang.NewSymbol("msg"), lang.NewSymbol("map"), lang.NewSymbol("cause"))), lang.NewKeyword("doc"), "Create an instance of ExceptionInfo, a RuntimeException subclass\n that carries a map of additional data.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4803), lang.NewKeyword("end-line"), int(4803))).(*lang.Symbol) + tmp0 := sym_ex_DASH_info.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_msg, sym_map), lang.NewVector(sym_msg, sym_map, sym_cause)), kw_doc, "Create an instance of ExceptionInfo, a RuntimeException subclass\n that carries a map of additional data.", kw_file, "glojure/core.glj", kw_added, "1.4", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4803), kw_end_DASH_line, int(4803))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -21807,7 +22451,7 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_elide_top_frames) + tmp5 := checkDerefVar(var_glojure_DOT_core_elide_DASH_top_DASH_frames) tmp6 := lang.Apply(nil, []any{v3, v4}) tmp7 := lang.Apply(tmp5, []any{tmp6, "glojure.core$ex_info"}) return tmp7 @@ -21818,15 +22462,16 @@ func LoadNS() { _ = v4 v5 := args[2] _ = v5 - tmp6 := checkDerefVar(glojure_DOT_core_elide_top_frames) + tmp6 := checkDerefVar(var_glojure_DOT_core_elide_DASH_top_DASH_frames) tmp7 := lang.Apply(nil, []any{v3, v4, v5}) tmp8 := lang.Apply(tmp6, []any{tmp7, "glojure.core$ex_info"}) return tmp8 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -21834,16 +22479,14 @@ func LoadNS() { } // ex-message { - tmp0 := lang.NewSymbol("ex-message").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ex"))), lang.NewKeyword("doc"), "Returns the message attached to ex if ex is a Throwable.\n Otherwise returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4820), lang.NewKeyword("end-line"), int(4820))).(*lang.Symbol) + tmp0 := sym_ex_DASH_message.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ex)), kw_doc, "Returns the message attached to ex if ex is a Throwable.\n Otherwise returns nil.", kw_file, "glojure/core.glj", kw_added, "1.10", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4820), kw_end_DASH_line, int(4820))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any - tmp5 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp6 := lang.Apply(tmp5, []any{lang.Throwable, v3}) if lang.IsTruthy(tmp6) { tmp7, ok := lang.FieldOrMethod(v3, "getMessage") @@ -21862,7 +22505,7 @@ func LoadNS() { } return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -21870,14 +22513,12 @@ func LoadNS() { } // extend { - tmp0 := lang.NewSymbol("extend").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atype"), lang.NewSymbol("&"), lang.NewSymbol("proto+mmaps"))), lang.NewKeyword("doc"), "Implementations of protocol methods can be provided using the extend construct:\n\n (extend AType\n AProtocol\n {:foo an-existing-fn\n :bar (fn [a b] ...)\n :baz (fn ([a]...) ([a b] ...)...)}\n BProtocol \n {...} \n ...)\n \n extend takes a type/class (or interface, see below), and one or more\n protocol + method map pairs. It will extend the polymorphism of the\n protocol's methods to call the supplied methods when an AType is\n provided as the first argument. \n\n Method maps are maps of the keyword-ized method names to ordinary\n fns. This facilitates easy reuse of existing fns and fn maps, for\n code reuse/mixins without derivation or composition. You can extend\n an interface to a protocol. This is primarily to facilitate interop\n with the host (e.g. Java) but opens the door to incidental multiple\n inheritance of implementation since a class can inherit from more\n than one interface, both of which extend the protocol. It is TBD how\n to specify which impl to use. You can extend a protocol on nil.\n\n If you are supplying the definitions explicitly (i.e. not reusing\n exsting functions or mixin maps), you may find it more convenient to\n use the extend-type or extend-protocol macros.\n\n Note that multiple independent extend clauses can exist for the same\n type, not all protocols need be defined in a single extend call.\n\n See also:\n extends?, satisfies?, extenders", lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(116), lang.NewKeyword("end-line"), int(116))).(*lang.Symbol) + tmp0 := sym_extend.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_atype, sym__AMP_, sym_proto_PLUS_mmaps)), kw_doc, "Implementations of protocol methods can be provided using the extend construct:\n\n (extend AType\n AProtocol\n {:foo an-existing-fn\n :bar (fn [a b] ...)\n :baz (fn ([a]...) ([a b] ...)...)}\n BProtocol \n {...} \n ...)\n \n extend takes a type/class (or interface, see below), and one or more\n protocol + method map pairs. It will extend the polymorphism of the\n protocol's methods to call the supplied methods when an AType is\n provided as the first argument. \n\n Method maps are maps of the keyword-ized method names to ordinary\n fns. This facilitates easy reuse of existing fns and fn maps, for\n code reuse/mixins without derivation or composition. You can extend\n an interface to a protocol. This is primarily to facilitate interop\n with the host (e.g. Java) but opens the door to incidental multiple\n inheritance of implementation since a class can inherit from more\n than one interface, both of which extend the protocol. It is TBD how\n to specify which impl to use. You can extend a protocol on nil.\n\n If you are supplying the definitions explicitly (i.e. not reusing\n exsting functions or mixin maps), you may find it more convenient to\n use the extend-type or extend-protocol macros.\n\n Note that multiple independent extend clauses can exist for the same\n type, not all protocols need be defined in a single extend call.\n\n See also:\n extends?, satisfies?, extenders", kw_file, "glojure/core_deftype.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(116), kw_end_DASH_line, int(116))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var v4 any = lang.NewList(args[1:]...) @@ -21885,8 +22526,8 @@ func LoadNS() { var tmp5 any { // let // let binding "seq_262" - tmp6 := checkDerefVar(glojure_DOT_core_seq) - tmp7 := checkDerefVar(glojure_DOT_core_partition) + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_partition) tmp8 := lang.Apply(tmp7, []any{int64(2), v4}) tmp9 := lang.Apply(tmp6, []any{tmp8}) var v10 any = tmp9 @@ -21902,7 +22543,7 @@ func LoadNS() { _ = v13 for { var tmp14 any - tmp15 := checkDerefVar(glojure_DOT_core__LT_) + tmp15 := checkDerefVar(var_glojure_DOT_core__LT_) tmp16 := lang.Apply(tmp15, []any{v13, v12}) if lang.IsTruthy(tmp16) { var tmp17 any @@ -21916,32 +22557,30 @@ func LoadNS() { var v20 any = tmp19 _ = v20 // let binding "proto" - tmp21 := checkDerefVar(glojure_DOT_core_nth) + tmp21 := checkDerefVar(var_glojure_DOT_core_nth) tmp22 := lang.Apply(tmp21, []any{v20, int64(0), nil}) var v23 any = tmp22 _ = v23 // let binding "mmap" - tmp24 := checkDerefVar(glojure_DOT_core_nth) + tmp24 := checkDerefVar(var_glojure_DOT_core_nth) tmp25 := lang.Apply(tmp24, []any{v20, int64(1), nil}) var v26 any = tmp25 _ = v26 var tmp27 any - tmp28 := checkDerefVar(glojure_DOT_core_protocol_QMARK_) + tmp28 := checkDerefVar(var_glojure_DOT_core_protocol_QMARK_) tmp29 := lang.Apply(tmp28, []any{v23}) if lang.IsTruthy(tmp29) { } else { - tmp30 := checkDerefVar(glojure_DOT_core_str) + tmp30 := checkDerefVar(var_glojure_DOT_core_str) tmp31 := lang.Apply(tmp30, []any{v23, " is not a protocol"}) tmp32 := lang.Apply(errors8.New, []any{tmp31}) panic(tmp32) } _ = tmp27 - tmp33 := checkDerefVar(glojure_DOT_core_reduce1) + tmp33 := checkDerefVar(var_glojure_DOT_core_reduce1) var tmp34 lang.FnFunc tmp34 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v35 := args[0] _ = v35 v36 := args[1] @@ -21952,20 +22591,20 @@ func LoadNS() { var v38 any = v36 _ = v38 // let binding "k" - tmp39 := checkDerefVar(glojure_DOT_core_nth) + tmp39 := checkDerefVar(var_glojure_DOT_core_nth) tmp40 := lang.Apply(tmp39, []any{v38, int64(0), nil}) var v41 any = tmp40 _ = v41 // let binding "v" - tmp42 := checkDerefVar(glojure_DOT_core_nth) + tmp42 := checkDerefVar(var_glojure_DOT_core_nth) tmp43 := lang.Apply(tmp42, []any{v38, int64(1), nil}) var v44 any = tmp43 _ = v44 - tmp45 := checkDerefVar(glojure_DOT_core_get_in) - tmp46 := checkDerefVar(glojure_DOT_core_deref) + tmp45 := checkDerefVar(var_glojure_DOT_core_get_DASH_in) + tmp46 := checkDerefVar(var_glojure_DOT_core_deref) tmp47 := lang.Apply(tmp46, []any{v23}) - tmp48 := lang.NewVector(lang.NewKeyword("multis"), v41) - tmp49 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(158), lang.NewKeyword("column"), int(33), lang.NewKeyword("end-line"), int(158), lang.NewKeyword("end-column"), int(43)) + tmp48 := lang.NewVector(kw_multis, v41) + tmp49 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(158), kw_column, int(33), kw_end_DASH_line, int(158), kw_end_DASH_column, int(43)) tmp50, err := lang.WithMeta(tmp48, tmp49.(lang.IPersistentMap)) if err != nil { panic(err) @@ -21975,15 +22614,13 @@ func LoadNS() { tmp52 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v53 := args[0] _ = v53 var v54 any = lang.NewList(args[1:]...) _ = v54 - tmp55 := checkDerefVar(glojure_DOT_core_apply) - tmp56 := checkDerefVar(glojure_DOT_core_cons) + tmp55 := checkDerefVar(var_glojure_DOT_core_apply) + tmp56 := checkDerefVar(var_glojure_DOT_core_cons) tmp57 := lang.Apply(tmp56, []any{v53, v54}) tmp58 := lang.Apply(tmp55, []any{v44, tmp57}) return tmp58 @@ -21998,7 +22635,7 @@ func LoadNS() { } // end let return tmp37 }) - tmp35 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(156), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(160), lang.NewKeyword("end-column"), int(45)) + tmp35 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(156), kw_column, int(14), kw_end_DASH_line, int(160), kw_end_DASH_column, int(45)) tmp36, err := lang.WithMeta(tmp34, tmp35.(lang.IPersistentMap)) if err != nil { panic(err) @@ -22008,7 +22645,7 @@ func LoadNS() { var tmp38 any = v10 var tmp39 any = v11 var tmp40 any = v12 - tmp42 := checkDerefVar(glojure_DOT_core_unchecked_inc) + tmp42 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) tmp43 := lang.Apply(tmp42, []any{v13}) var tmp41 any = tmp43 v10 = tmp38 @@ -22022,7 +22659,7 @@ func LoadNS() { var tmp18 any { // let // let binding "temp__0__auto__" - tmp19 := checkDerefVar(glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_seq) tmp20 := lang.Apply(tmp19, []any{v10}) var v21 any = tmp20 _ = v21 @@ -22034,26 +22671,26 @@ func LoadNS() { var v24 any = v21 _ = v24 var tmp25 any - tmp26 := checkDerefVar(glojure_DOT_core_chunked_seq_QMARK_) + tmp26 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) tmp27 := lang.Apply(tmp26, []any{v24}) if lang.IsTruthy(tmp27) { var tmp28 any { // let // let binding "c__0__auto__" - tmp29 := checkDerefVar(glojure_DOT_core_chunk_first) + tmp29 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) tmp30 := lang.Apply(tmp29, []any{v24}) var v31 any = tmp30 _ = v31 - tmp33 := checkDerefVar(glojure_DOT_core_chunk_rest) + tmp33 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) tmp34 := lang.Apply(tmp33, []any{v24}) var tmp32 any = tmp34 var tmp35 any = v31 - tmp37 := checkDerefVar(glojure_DOT_core_int) - tmp38 := checkDerefVar(glojure_DOT_core_count) + tmp37 := checkDerefVar(var_glojure_DOT_core_int) + tmp38 := checkDerefVar(var_glojure_DOT_core_count) tmp39 := lang.Apply(tmp38, []any{v31}) tmp40 := lang.Apply(tmp37, []any{tmp39}) var tmp36 any = tmp40 - tmp42 := checkDerefVar(glojure_DOT_core_int) + tmp42 := checkDerefVar(var_glojure_DOT_core_int) tmp43 := lang.Apply(tmp42, []any{int64(0)}) var tmp41 any = tmp43 v10 = tmp32 @@ -22067,37 +22704,35 @@ func LoadNS() { var tmp29 any { // let // let binding "vec__273" - tmp30 := checkDerefVar(glojure_DOT_core_first) + tmp30 := checkDerefVar(var_glojure_DOT_core_first) tmp31 := lang.Apply(tmp30, []any{v24}) var v32 any = tmp31 _ = v32 // let binding "proto" - tmp33 := checkDerefVar(glojure_DOT_core_nth) + tmp33 := checkDerefVar(var_glojure_DOT_core_nth) tmp34 := lang.Apply(tmp33, []any{v32, int64(0), nil}) var v35 any = tmp34 _ = v35 // let binding "mmap" - tmp36 := checkDerefVar(glojure_DOT_core_nth) + tmp36 := checkDerefVar(var_glojure_DOT_core_nth) tmp37 := lang.Apply(tmp36, []any{v32, int64(1), nil}) var v38 any = tmp37 _ = v38 var tmp39 any - tmp40 := checkDerefVar(glojure_DOT_core_protocol_QMARK_) + tmp40 := checkDerefVar(var_glojure_DOT_core_protocol_QMARK_) tmp41 := lang.Apply(tmp40, []any{v35}) if lang.IsTruthy(tmp41) { } else { - tmp42 := checkDerefVar(glojure_DOT_core_str) + tmp42 := checkDerefVar(var_glojure_DOT_core_str) tmp43 := lang.Apply(tmp42, []any{v35, " is not a protocol"}) tmp44 := lang.Apply(errors8.New, []any{tmp43}) panic(tmp44) } _ = tmp39 - tmp45 := checkDerefVar(glojure_DOT_core_reduce1) + tmp45 := checkDerefVar(var_glojure_DOT_core_reduce1) var tmp46 lang.FnFunc tmp46 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v47 := args[0] _ = v47 v48 := args[1] @@ -22108,20 +22743,20 @@ func LoadNS() { var v50 any = v48 _ = v50 // let binding "k" - tmp51 := checkDerefVar(glojure_DOT_core_nth) + tmp51 := checkDerefVar(var_glojure_DOT_core_nth) tmp52 := lang.Apply(tmp51, []any{v50, int64(0), nil}) var v53 any = tmp52 _ = v53 // let binding "v" - tmp54 := checkDerefVar(glojure_DOT_core_nth) + tmp54 := checkDerefVar(var_glojure_DOT_core_nth) tmp55 := lang.Apply(tmp54, []any{v50, int64(1), nil}) var v56 any = tmp55 _ = v56 - tmp57 := checkDerefVar(glojure_DOT_core_get_in) - tmp58 := checkDerefVar(glojure_DOT_core_deref) + tmp57 := checkDerefVar(var_glojure_DOT_core_get_DASH_in) + tmp58 := checkDerefVar(var_glojure_DOT_core_deref) tmp59 := lang.Apply(tmp58, []any{v35}) - tmp60 := lang.NewVector(lang.NewKeyword("multis"), v53) - tmp61 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(158), lang.NewKeyword("column"), int(33), lang.NewKeyword("end-line"), int(158), lang.NewKeyword("end-column"), int(43)) + tmp60 := lang.NewVector(kw_multis, v53) + tmp61 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(158), kw_column, int(33), kw_end_DASH_line, int(158), kw_end_DASH_column, int(43)) tmp62, err := lang.WithMeta(tmp60, tmp61.(lang.IPersistentMap)) if err != nil { panic(err) @@ -22131,15 +22766,13 @@ func LoadNS() { tmp64 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v65 := args[0] _ = v65 var v66 any = lang.NewList(args[1:]...) _ = v66 - tmp67 := checkDerefVar(glojure_DOT_core_apply) - tmp68 := checkDerefVar(glojure_DOT_core_cons) + tmp67 := checkDerefVar(var_glojure_DOT_core_apply) + tmp68 := checkDerefVar(var_glojure_DOT_core_cons) tmp69 := lang.Apply(tmp68, []any{v65, v66}) tmp70 := lang.Apply(tmp67, []any{v56, tmp69}) return tmp70 @@ -22154,14 +22787,14 @@ func LoadNS() { } // end let return tmp49 }) - tmp47 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(156), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(160), lang.NewKeyword("end-column"), int(45)) + tmp47 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(156), kw_column, int(14), kw_end_DASH_line, int(160), kw_end_DASH_column, int(45)) tmp48, err := lang.WithMeta(tmp46, tmp47.(lang.IPersistentMap)) if err != nil { panic(err) } tmp49 := lang.Apply(tmp45, []any{tmp48, nil, v38}) _ = tmp49 - tmp51 := checkDerefVar(glojure_DOT_core_next) + tmp51 := checkDerefVar(var_glojure_DOT_core_next) tmp52 := lang.Apply(tmp51, []any{v24}) var tmp50 any = tmp52 var tmp53 any = nil @@ -22191,7 +22824,7 @@ func LoadNS() { return tmp5 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -22199,14 +22832,12 @@ func LoadNS() { } // extend-protocol { - tmp0 := lang.NewSymbol("extend-protocol").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("p"), lang.NewSymbol("&"), lang.NewSymbol("specs"))), lang.NewKeyword("doc"), "Useful when you want to provide several implementations of the same\n protocol all at once. Takes a single protocol and the implementation\n of that protocol for one or more types.\n\n (extend-protocol Protocol\n AType\n (foo [x] ...)\n (bar [x y] ...)\n BType\n (foo [x] ...)\n (bar [x y] ...)\n AClass\n (foo [x] ...)\n (bar [x y] ...)\n nil\n (foo [x] ...)\n (bar [x y] ...))\n\n expands into:\n\n (do\n (clojure.core/extend-type AType Protocol \n (foo [x] ...) \n (bar [x y] ...))\n (clojure.core/extend-type BType Protocol \n (foo [x] ...) \n (bar [x y] ...))\n (clojure.core/extend-type AClass Protocol \n (foo [x] ...) \n (bar [x y] ...))\n (clojure.core/extend-type nil Protocol \n (foo [x] ...) \n (bar [x y] ...)))", lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(212), lang.NewKeyword("end-line"), int(212))).(*lang.Symbol) + tmp0 := sym_extend_DASH_protocol.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_p, sym__AMP_, sym_specs)), kw_doc, "Useful when you want to provide several implementations of the same\n protocol all at once. Takes a single protocol and the implementation\n of that protocol for one or more types.\n\n (extend-protocol Protocol\n AType\n (foo [x] ...)\n (bar [x y] ...)\n BType\n (foo [x] ...)\n (bar [x y] ...)\n AClass\n (foo [x] ...)\n (bar [x y] ...)\n nil\n (foo [x] ...)\n (bar [x y] ...))\n\n expands into:\n\n (do\n (clojure.core/extend-type AType Protocol \n (foo [x] ...) \n (bar [x y] ...))\n (clojure.core/extend-type BType Protocol \n (foo [x] ...) \n (bar [x y] ...))\n (clojure.core/extend-type AClass Protocol \n (foo [x] ...) \n (bar [x y] ...))\n (clojure.core/extend-type nil Protocol \n (foo [x] ...) \n (bar [x y] ...)))", kw_file, "glojure/core_deftype.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(25), kw_column, int(11), kw_line, int(212), kw_end_DASH_line, int(212))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -22215,12 +22846,12 @@ func LoadNS() { _ = v5 var v6 any = lang.NewList(args[3:]...) _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_emit_extend_protocol) + tmp7 := checkDerefVar(var_glojure_DOT_core_emit_DASH_extend_DASH_protocol) tmp8 := lang.Apply(tmp7, []any{v5, v6}) return tmp8 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -22228,14 +22859,12 @@ func LoadNS() { } // extend-type { - tmp0 := lang.NewSymbol("extend-type").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("t"), lang.NewSymbol("&"), lang.NewSymbol("specs"))), lang.NewKeyword("doc"), "A macro that expands into an extend call. Useful when you are\n supplying the definitions explicitly inline, extend-type\n automatically creates the maps required by extend. Propagates the\n class as a type hint on the first argument of all fns.\n\n (extend-type MyType \n Countable\n (cnt [c] ...)\n Foo\n (bar [x y] ...)\n (baz ([x] ...) ([x y & zs] ...)))\n\n expands into:\n\n (extend MyType\n Countable\n {:cnt (fn [c] ...)}\n Foo\n {:baz (fn ([x] ...) ([x y & zs] ...))\n :bar (fn [x y] ...)})", lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(180), lang.NewKeyword("end-line"), int(180))).(*lang.Symbol) + tmp0 := sym_extend_DASH_type.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_t, sym__AMP_, sym_specs)), kw_doc, "A macro that expands into an extend call. Useful when you are\n supplying the definitions explicitly inline, extend-type\n automatically creates the maps required by extend. Propagates the\n class as a type hint on the first argument of all fns.\n\n (extend-type MyType \n Countable\n (cnt [c] ...)\n Foo\n (bar [x y] ...)\n (baz ([x] ...) ([x y & zs] ...)))\n\n expands into:\n\n (extend MyType\n Countable\n {:cnt (fn [c] ...)}\n Foo\n {:baz (fn ([x] ...) ([x y & zs] ...))\n :bar (fn [x y] ...)})", kw_file, "glojure/core_deftype.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(11), kw_line, int(180), kw_end_DASH_line, int(180))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -22244,12 +22873,12 @@ func LoadNS() { _ = v5 var v6 any = lang.NewList(args[3:]...) _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_emit_extend_type) + tmp7 := checkDerefVar(var_glojure_DOT_core_emit_DASH_extend_DASH_type) tmp8 := lang.Apply(tmp7, []any{v5, v6}) return tmp8 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -22258,19 +22887,17 @@ func LoadNS() { // false? { tmp1 := reflect.TypeOf(false) - tmp0 := lang.NewSymbol("false?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is the value false, false otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(504), lang.NewKeyword("end-line"), int(504))).(*lang.Symbol) + tmp0 := sym_false_QMARK_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x is the value false, false otherwise.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(504), kw_end_DASH_line, int(504))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 tmp5 := lang.Apply(lang.Identical, []any{v4, false}) return tmp5 }) tmp4 := reflect.TypeOf(false) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -22278,23 +22905,21 @@ func LoadNS() { } // ffirst { - tmp0 := lang.NewSymbol("ffirst").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Same as (first (first x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(98), lang.NewKeyword("end-line"), int(102))).(*lang.Symbol) + tmp0 := sym_ffirst.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Same as (first (first x))", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(2), kw_line, int(98), kw_end_DASH_line, int(102))).(*lang.Symbol) var tmp2 lang.FnFunc { // function ffirst var v3 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_first) - tmp6 := checkDerefVar(glojure_DOT_core_first) + tmp5 := checkDerefVar(var_glojure_DOT_core_first) + tmp6 := checkDerefVar(var_glojure_DOT_core_first) tmp7 := lang.Apply(tmp6, []any{v4}) tmp8 := lang.Apply(tmp5, []any{tmp7}) return tmp8 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(102), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(102), lang.NewKeyword("end-column"), int(50))).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(102), kw_column, int(9), kw_end_DASH_line, int(102), kw_end_DASH_column, int(50))).(lang.FnFunc) v3 = tmp2 _ = v3 } @@ -22305,20 +22930,16 @@ func LoadNS() { } // file-seq { - tmp0 := lang.NewSymbol("file-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("dir"))), lang.NewKeyword("doc"), "A tree seq on java.io.Files", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4972), lang.NewKeyword("end-line"), int(4972))).(*lang.Symbol) + tmp0 := sym_file_DASH_seq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_dir)), kw_doc, "A tree seq on java.io.Files", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(4972), kw_end_DASH_line, int(4972))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_tree_seq) + tmp4 := checkDerefVar(var_glojure_DOT_core_tree_DASH_seq) var tmp5 lang.FnFunc tmp5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v6 := args[0] _ = v6 tmp7, _ := lang.FieldOrMethod(v6, "isDirectory") @@ -22328,19 +22949,17 @@ func LoadNS() { tmp8 := lang.Apply(tmp7, []any{}) return tmp8 }) - tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4978), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(4978), lang.NewKeyword("end-column"), int(47)) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4978), kw_column, int(6), kw_end_DASH_line, int(4978), kw_end_DASH_column, int(47)) tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) if err != nil { panic(err) } var tmp8 lang.FnFunc tmp8 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v9 := args[0] _ = v9 - tmp10 := checkDerefVar(glojure_DOT_core_seq) + tmp10 := checkDerefVar(var_glojure_DOT_core_seq) tmp11, _ := lang.FieldOrMethod(v9, "listFiles") if reflect.TypeOf(tmp11).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("listFiles is not a function"))) @@ -22349,7 +22968,7 @@ func LoadNS() { tmp13 := lang.Apply(tmp10, []any{tmp12}) return tmp13 }) - tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4979), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(4979), lang.NewKeyword("end-column"), int(51)) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4979), kw_column, int(6), kw_end_DASH_line, int(4979), kw_end_DASH_column, int(51)) tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) if err != nil { panic(err) @@ -22357,7 +22976,7 @@ func LoadNS() { tmp11 := lang.Apply(tmp4, []any{tmp7, tmp10, v3}) return tmp11 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -22365,7 +22984,7 @@ func LoadNS() { } // filter { - tmp0 := lang.NewSymbol("filter").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred")), lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the items in coll for which\n (pred item) returns logical true. pred must be free of side-effects.\n Returns a transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2785), lang.NewKeyword("end-line"), int(2785))).(*lang.Symbol) + tmp0 := sym_filter.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred), lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns a lazy sequence of the items in coll for which\n (pred item) returns logical true. pred must be free of side-effects.\n Returns a transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(2785), kw_end_DASH_line, int(2785))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -22374,9 +22993,7 @@ func LoadNS() { _ = v3 var tmp4 lang.FnFunc tmp4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v5 := args[0] _ = v5 var tmp6 lang.FnFunc @@ -22405,17 +23022,18 @@ func LoadNS() { } return tmp9 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2793), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(2799), lang.NewKeyword("end-column"), int(22)) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2793), kw_column, int(7), kw_end_DASH_line, int(2799), kw_end_DASH_column, int(22)) tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) if err != nil { panic(err) } return tmp8 }) - tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2792), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2799), lang.NewKeyword("end-column"), int(23)) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2792), kw_column, int(5), kw_end_DASH_line, int(2799), kw_end_DASH_column, int(23)) tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) if err != nil { panic(err) @@ -22428,13 +23046,11 @@ func LoadNS() { _ = v4 var tmp5 lang.FnFunc tmp5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var tmp6 any { // let // let binding "temp__0__auto__" - tmp7 := checkDerefVar(glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) tmp8 := lang.Apply(tmp7, []any{v4}) var v9 any = tmp8 _ = v9 @@ -22446,23 +23062,23 @@ func LoadNS() { var v12 any = v9 _ = v12 var tmp13 any - tmp14 := checkDerefVar(glojure_DOT_core_chunked_seq_QMARK_) + tmp14 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) tmp15 := lang.Apply(tmp14, []any{v12}) if lang.IsTruthy(tmp15) { var tmp16 any { // let // let binding "c" - tmp17 := checkDerefVar(glojure_DOT_core_chunk_first) + tmp17 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) tmp18 := lang.Apply(tmp17, []any{v12}) var v19 any = tmp18 _ = v19 // let binding "size" - tmp20 := checkDerefVar(glojure_DOT_core_count) + tmp20 := checkDerefVar(var_glojure_DOT_core_count) tmp21 := lang.Apply(tmp20, []any{v19}) var v22 any = tmp21 _ = v22 // let binding "b" - tmp23 := checkDerefVar(glojure_DOT_core_chunk_buffer) + tmp23 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_buffer) tmp24 := lang.Apply(tmp23, []any{v22}) var v25 any = tmp24 _ = v25 @@ -22479,7 +23095,7 @@ func LoadNS() { _ = v30 for { var tmp31 any - tmp32 := checkDerefVar(glojure_DOT_core__LT_) + tmp32 := checkDerefVar(var_glojure_DOT_core__LT_) tmp33 := lang.Apply(tmp32, []any{v30, v28}) if lang.IsTruthy(tmp33) { var tmp34 any @@ -22495,7 +23111,7 @@ func LoadNS() { var tmp38 any tmp39 := lang.Apply(v3, []any{v37}) if lang.IsTruthy(tmp39) { - tmp40 := checkDerefVar(glojure_DOT_core_chunk_append) + tmp40 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_append) tmp41 := lang.Apply(tmp40, []any{v25, v37}) tmp38 = tmp41 } else { @@ -22503,7 +23119,7 @@ func LoadNS() { tmp34 = tmp38 } // end let _ = tmp34 - tmp36 := checkDerefVar(glojure_DOT_core_unchecked_inc) + tmp36 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) tmp37 := lang.Apply(tmp36, []any{v30}) var tmp35 any = tmp37 v30 = tmp35 @@ -22517,11 +23133,11 @@ func LoadNS() { tmp26 = tmp29 } // end let _ = tmp26 - tmp27 := checkDerefVar(glojure_DOT_core_chunk_cons) - tmp28 := checkDerefVar(glojure_DOT_core_chunk) + tmp27 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_cons) + tmp28 := checkDerefVar(var_glojure_DOT_core_chunk) tmp29 := lang.Apply(tmp28, []any{v25}) - tmp30 := checkDerefVar(glojure_DOT_core_filter) - tmp31 := checkDerefVar(glojure_DOT_core_chunk_rest) + tmp30 := checkDerefVar(var_glojure_DOT_core_filter) + tmp31 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) tmp32 := lang.Apply(tmp31, []any{v12}) tmp33 := lang.Apply(tmp30, []any{v3, tmp32}) tmp34 := lang.Apply(tmp27, []any{tmp29, tmp33}) @@ -22532,25 +23148,25 @@ func LoadNS() { var tmp17 any { // let // let binding "f" - tmp18 := checkDerefVar(glojure_DOT_core_first) + tmp18 := checkDerefVar(var_glojure_DOT_core_first) tmp19 := lang.Apply(tmp18, []any{v12}) var v20 any = tmp19 _ = v20 // let binding "r" - tmp21 := checkDerefVar(glojure_DOT_core_rest) + tmp21 := checkDerefVar(var_glojure_DOT_core_rest) tmp22 := lang.Apply(tmp21, []any{v12}) var v23 any = tmp22 _ = v23 var tmp24 any tmp25 := lang.Apply(v3, []any{v20}) if lang.IsTruthy(tmp25) { - tmp26 := checkDerefVar(glojure_DOT_core_cons) - tmp27 := checkDerefVar(glojure_DOT_core_filter) + tmp26 := checkDerefVar(var_glojure_DOT_core_cons) + tmp27 := checkDerefVar(var_glojure_DOT_core_filter) tmp28 := lang.Apply(tmp27, []any{v3, v23}) tmp29 := lang.Apply(tmp26, []any{v20, tmp28}) tmp24 = tmp29 } else { - tmp30 := checkDerefVar(glojure_DOT_core_filter) + tmp30 := checkDerefVar(var_glojure_DOT_core_filter) tmp31 := lang.Apply(tmp30, []any{v3, v23}) tmp24 = tmp31 } @@ -22570,10 +23186,11 @@ func LoadNS() { tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) return tmp6 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -22581,12 +23198,10 @@ func LoadNS() { } // filter-key { - tmp0 := lang.NewSymbol("filter-key").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("keyfn"), lang.NewSymbol("pred"), lang.NewSymbol("amap"))), lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4115), lang.NewKeyword("end-line"), int(4117), lang.NewKeyword("private"), true)).(*lang.Symbol) + tmp0 := sym_filter_DASH_key.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_keyfn, sym_pred, sym_amap)), kw_static, true, kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(4115), kw_end_DASH_line, int(4117), kw_private, true)).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -22597,7 +23212,7 @@ func LoadNS() { { // let // let binding "ret" tmp7 := lang.NewMap() - tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4118), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(4118), lang.NewKeyword("end-column"), int(17)) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4118), kw_column, int(16), kw_end_DASH_line, int(4118), kw_end_DASH_column, int(17)) tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) if err != nil { panic(err) @@ -22605,7 +23220,7 @@ func LoadNS() { var v10 any = tmp9 _ = v10 // let binding "es" - tmp11 := checkDerefVar(glojure_DOT_core_seq) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := lang.Apply(tmp11, []any{v5}) var v13 any = tmp12 _ = v13 @@ -22613,23 +23228,23 @@ func LoadNS() { var tmp14 any if lang.IsTruthy(v13) { var tmp15 any - tmp16 := checkDerefVar(glojure_DOT_core_first) + tmp16 := checkDerefVar(var_glojure_DOT_core_first) tmp17 := lang.Apply(tmp16, []any{v13}) tmp18 := lang.Apply(v3, []any{tmp17}) tmp19 := lang.Apply(v4, []any{tmp18}) if lang.IsTruthy(tmp19) { - tmp21 := checkDerefVar(glojure_DOT_core_assoc) - tmp22 := checkDerefVar(glojure_DOT_core_key) - tmp23 := checkDerefVar(glojure_DOT_core_first) + tmp21 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp22 := checkDerefVar(var_glojure_DOT_core_key) + tmp23 := checkDerefVar(var_glojure_DOT_core_first) tmp24 := lang.Apply(tmp23, []any{v13}) tmp25 := lang.Apply(tmp22, []any{tmp24}) - tmp26 := checkDerefVar(glojure_DOT_core_val) - tmp27 := checkDerefVar(glojure_DOT_core_first) + tmp26 := checkDerefVar(var_glojure_DOT_core_val) + tmp27 := checkDerefVar(var_glojure_DOT_core_first) tmp28 := lang.Apply(tmp27, []any{v13}) tmp29 := lang.Apply(tmp26, []any{tmp28}) tmp30 := lang.Apply(tmp21, []any{v10, tmp25, tmp29}) var tmp20 any = tmp30 - tmp32 := checkDerefVar(glojure_DOT_core_next) + tmp32 := checkDerefVar(var_glojure_DOT_core_next) tmp33 := lang.Apply(tmp32, []any{v13}) var tmp31 any = tmp33 v10 = tmp20 @@ -22637,7 +23252,7 @@ func LoadNS() { continue } else { var tmp34 any = v10 - tmp36 := checkDerefVar(glojure_DOT_core_next) + tmp36 := checkDerefVar(var_glojure_DOT_core_next) tmp37 := lang.Apply(tmp36, []any{v13}) var tmp35 any = tmp37 v10 = tmp34 @@ -22654,7 +23269,7 @@ func LoadNS() { } // end let return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -22662,23 +23277,19 @@ func LoadNS() { } // filterv { - tmp0 := lang.NewSymbol("filterv").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a vector of the items in coll for which\n (pred item) returns logical true. pred must be free of side-effects.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6961), lang.NewKeyword("end-line"), int(6961))).(*lang.Symbol) + tmp0 := sym_filterv.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns a vector of the items in coll for which\n (pred item) returns logical true. pred must be free of side-effects.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.4", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(6961), kw_end_DASH_line, int(6961))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_persistent_BANG_) - tmp6 := checkDerefVar(glojure_DOT_core_reduce) + tmp5 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp6 := checkDerefVar(var_glojure_DOT_core_reduce) var tmp7 lang.FnFunc tmp7 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v8 := args[0] _ = v8 v9 := args[1] @@ -22686,7 +23297,7 @@ func LoadNS() { var tmp10 any tmp11 := lang.Apply(v3, []any{v9}) if lang.IsTruthy(tmp11) { - tmp12 := checkDerefVar(glojure_DOT_core_conj_BANG_) + tmp12 := checkDerefVar(var_glojure_DOT_core_conj_BANG_) tmp13 := lang.Apply(tmp12, []any{v8, v9}) tmp10 = tmp13 } else { @@ -22694,14 +23305,14 @@ func LoadNS() { } return tmp10 }) - tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6967), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(6967), lang.NewKeyword("end-column"), int(52)) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6967), kw_column, int(15), kw_end_DASH_line, int(6967), kw_end_DASH_column, int(52)) tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp10 := checkDerefVar(glojure_DOT_core_transient) + tmp10 := checkDerefVar(var_glojure_DOT_core_transient) tmp11 := lang.NewVector() - tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6968), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(6968), lang.NewKeyword("end-column"), int(27)) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6968), kw_column, int(26), kw_end_DASH_line, int(6968), kw_end_DASH_column, int(27)) tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) if err != nil { panic(err) @@ -22711,7 +23322,7 @@ func LoadNS() { tmp16 := lang.Apply(tmp5, []any{tmp15}) return tmp16 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -22719,12 +23330,10 @@ func LoadNS() { } // find { - tmp0 := lang.NewSymbol("find").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"))), lang.NewKeyword("doc"), "Returns the map entry for key, or nil if key not present.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1530), lang.NewKeyword("end-line"), int(1530))).(*lang.Symbol) + tmp0 := sym_find.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_map, sym_key)), kw_doc, "Returns the map entry for key, or nil if key not present.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1530), kw_end_DASH_line, int(1530))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -22736,7 +23345,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -22745,7 +23354,7 @@ func LoadNS() { // find-keyword { tmp1 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() - tmp0 := lang.NewSymbol("find-keyword").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name"))), lang.NewKeyword("doc"), "Returns a Keyword with the given namespace and name if one already\n exists. This function will not intern a new keyword. If the keyword\n has not already been interned, it will return nil. Do not use :\n in the keyword strings, it will be added automatically.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(618), lang.NewKeyword("end-line"), int(618))).(*lang.Symbol) + tmp0 := sym_find_DASH_keyword.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_name), lang.NewVector(sym_ns, sym_name)), kw_doc, "Returns a Keyword with the given namespace and name if one already\n exists. This function will not intern a new keyword. If the keyword\n has not already been interned, it will return nil. Do not use :\n in the keyword strings, it will be added automatically.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(618), kw_end_DASH_line, int(618))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -22753,20 +23362,20 @@ func LoadNS() { v4 := args[0] _ = v4 var tmp5 any - tmp6 := checkDerefVar(glojure_DOT_core_keyword_QMARK_) + tmp6 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) tmp7 := lang.Apply(tmp6, []any{v4}) if lang.IsTruthy(tmp7) { tmp5 = v4 } else { var tmp8 any - tmp9 := checkDerefVar(glojure_DOT_core_symbol_QMARK_) + tmp9 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) tmp10 := lang.Apply(tmp9, []any{v4}) if lang.IsTruthy(tmp10) { tmp11 := lang.Apply(nil, []any{v4}) tmp8 = tmp11 } else { var tmp12 any - tmp13 := checkDerefVar(glojure_DOT_core_string_QMARK_) + tmp13 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) tmp14 := lang.Apply(tmp13, []any{v4}) if lang.IsTruthy(tmp14) { tmp15 := lang.Apply(nil, []any{v4}) @@ -22786,11 +23395,12 @@ func LoadNS() { tmp6 := lang.Apply(nil, []any{v4, v5}) return tmp6 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) tmp4 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -22798,18 +23408,16 @@ func LoadNS() { } // find-ns { - tmp0 := lang.NewSymbol("find-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Returns the namespace named by the symbol or nil if it doesn't exist.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4125), lang.NewKeyword("end-line"), int(4125))).(*lang.Symbol) + tmp0 := sym_find_DASH_ns.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_sym)), kw_doc, "Returns the namespace named by the symbol or nil if it doesn't exist.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4125), kw_end_DASH_line, int(4125))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4 := lang.Apply(lang.FindNamespace, []any{v3}) return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -22817,12 +23425,10 @@ func LoadNS() { } // find-var { - tmp0 := lang.NewSymbol("find-var").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Returns the global var named by the namespace-qualified symbol, or\n nil if no var with that name.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2013), lang.NewKeyword("end-line"), int(2013))).(*lang.Symbol) + tmp0 := sym_find_DASH_var.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_sym)), kw_doc, "Returns the global var named by the namespace-qualified symbol, or\n nil if no var with that name.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(2013), kw_end_DASH_line, int(2013))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4, _ := lang.FieldOrMethod(runtime7.RT, "FindVar") @@ -22832,7 +23438,7 @@ func LoadNS() { tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -22840,20 +23446,18 @@ func LoadNS() { } // first { - tmp0 := lang.NewSymbol("first").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns the first item in the collection. Calls seq on its\n argument. If coll is nil, returns nil.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(47), lang.NewKeyword("end-line"), int(52))).(*lang.Symbol) + tmp0 := sym_first.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns the first item in the collection. Calls seq on its\n argument. If coll is nil, returns nil.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(6), kw_column, int(2), kw_line, int(47), kw_end_DASH_line, int(52))).(*lang.Symbol) var tmp2 lang.FnFunc { // function first var v3 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 tmp5 := lang.Apply(lang.First, []any{v4}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(52), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(52), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(52), kw_column, int(8), kw_end_DASH_line, int(52), kw_end_DASH_column, int(86))).(lang.FnFunc) v3 = tmp2 _ = v3 } @@ -22864,32 +23468,30 @@ func LoadNS() { } // fits-table? { - tmp0 := lang.NewSymbol("fits-table?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ints"))), lang.NewKeyword("doc"), "Returns true if the collection of ints can fit within the\n max-table-switch-size, false otherwise.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6625), lang.NewKeyword("end-line"), int(6625), lang.NewKeyword("private"), true)).(*lang.Symbol) + tmp0 := sym_fits_DASH_table_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ints)), kw_doc, "Returns true if the collection of ints can fit within the\n max-table-switch-size, false otherwise.", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(8), kw_line, int(6625), kw_end_DASH_line, int(6625), kw_private, true)).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core__LT_) - tmp5 := checkDerefVar(glojure_DOT_core__) - tmp6 := checkDerefVar(glojure_DOT_core_apply) - tmp7 := checkDerefVar(glojure_DOT_core_max) - tmp8 := checkDerefVar(glojure_DOT_core_seq) + tmp4 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp5 := checkDerefVar(var_glojure_DOT_core__DASH_) + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_max) + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) tmp9 := lang.Apply(tmp8, []any{v3}) tmp10 := lang.Apply(tmp6, []any{tmp7, tmp9}) - tmp11 := checkDerefVar(glojure_DOT_core_apply) - tmp12 := checkDerefVar(glojure_DOT_core_min) - tmp13 := checkDerefVar(glojure_DOT_core_seq) + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + tmp12 := checkDerefVar(var_glojure_DOT_core_min) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) tmp14 := lang.Apply(tmp13, []any{v3}) tmp15 := lang.Apply(tmp11, []any{tmp12, tmp14}) tmp16 := lang.Apply(tmp5, []any{tmp10, tmp15}) - tmp17 := checkDerefVar(glojure_DOT_core_max_switch_table_size) + tmp17 := checkDerefVar(var_glojure_DOT_core_max_DASH_switch_DASH_table_DASH_size) tmp18 := lang.Apply(tmp4, []any{tmp16, tmp17}) return tmp18 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -22897,28 +23499,26 @@ func LoadNS() { } // flatten { - tmp0 := lang.NewSymbol("flatten").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Takes any nested combination of sequential things (lists, vectors,\n etc.) and returns their contents as a single, flat lazy sequence.\n (flatten nil) returns an empty sequence.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7118), lang.NewKeyword("end-line"), int(7118))).(*lang.Symbol) + tmp0 := sym_flatten.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Takes any nested combination of sequential things (lists, vectors,\n etc.) and returns their contents as a single, flat lazy sequence.\n (flatten nil) returns an empty sequence.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(7118), kw_end_DASH_line, int(7118))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_filter) - tmp5 := checkDerefVar(glojure_DOT_core_complement) - tmp6 := checkDerefVar(glojure_DOT_core_sequential_QMARK_) + tmp4 := checkDerefVar(var_glojure_DOT_core_filter) + tmp5 := checkDerefVar(var_glojure_DOT_core_complement) + tmp6 := checkDerefVar(var_glojure_DOT_core_sequential_QMARK_) tmp7 := lang.Apply(tmp5, []any{tmp6}) - tmp8 := checkDerefVar(glojure_DOT_core_rest) - tmp9 := checkDerefVar(glojure_DOT_core_tree_seq) - tmp10 := checkDerefVar(glojure_DOT_core_sequential_QMARK_) - tmp11 := checkDerefVar(glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_rest) + tmp9 := checkDerefVar(var_glojure_DOT_core_tree_DASH_seq) + tmp10 := checkDerefVar(var_glojure_DOT_core_sequential_QMARK_) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := lang.Apply(tmp9, []any{tmp10, tmp11, v3}) tmp13 := lang.Apply(tmp8, []any{tmp12}) tmp14 := lang.Apply(tmp4, []any{tmp7, tmp13}) return tmp14 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -22930,30 +23530,28 @@ func LoadNS() { { // function float__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) - tmp5 := checkDerefVar(glojure_DOT_core_concat) - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := checkDerefVar(glojure_DOT_core_seq) - tmp12 := checkDerefVar(glojure_DOT_core_concat) - tmp13 := checkDerefVar(glojure_DOT_core_list) + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) var tmp14 any - tmp15 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + tmp15 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp15) { - tmp14 = lang.NewSymbol("uncheckedFloatCast") + tmp14 = sym_uncheckedFloatCast } else { - tmp14 = lang.NewSymbol("floatCast") + tmp14 = sym_floatCast } tmp16 := lang.Apply(tmp13, []any{tmp14}) - tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) tmp18 := lang.Apply(tmp17, []any{v3}) tmp19 := lang.Apply(tmp12, []any{tmp16, tmp18}) tmp20 := lang.Apply(tmp11, []any{tmp19}) @@ -22965,18 +23563,16 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("float").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to float", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3487), lang.NewKeyword("end-line"), int(3487))).(*lang.Symbol) + tmp0 := sym_float.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to float", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3487), kw_end_DASH_line, int(3487))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 tmp5 := lang.Apply(lang.FloatCast, []any{v4}) return tmp5 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -22990,26 +23586,24 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) - tmp5 := checkDerefVar(glojure_DOT_core_concat) - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol("glojure.core/FloatArray")}) - tmp12 := checkDerefVar(glojure_DOT_core_list) - tmp13 := checkDerefVar(glojure_DOT_core_seq) - tmp14 := checkDerefVar(glojure_DOT_core_concat) - tmp15 := checkDerefVar(glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) - tmp17 := checkDerefVar(glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("glojure.core/args")}) + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_FloatArray}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_unquote_DASH_splicing}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_glojure_DOT_core_SLASH_args}) tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) tmp20 := lang.Apply(tmp13, []any{tmp19}) tmp21 := lang.Apply(tmp12, []any{tmp20}) @@ -23021,7 +23615,7 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("float-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Creates an array of floats", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5301), lang.NewKeyword("end-line"), int(5301))).(*lang.Symbol) + tmp0 := sym_float_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_size_DASH_or_DASH_seq), lang.NewVector(sym_size, sym_init_DASH_val_DASH_or_DASH_seq)), kw_inline, tmp1, kw_doc, "Creates an array of floats", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(5301), kw_end_DASH_line, int(5301))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -23046,10 +23640,11 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -23057,18 +23652,16 @@ func LoadNS() { } // float? { - tmp0 := lang.NewSymbol("float?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is a floating point number", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3605), lang.NewKeyword("end-line"), int(3605))).(*lang.Symbol) + tmp0 := sym_float_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_doc, "Returns true if n is a floating point number", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(3605), kw_end_DASH_line, int(3605))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any { // let // let binding "or__0__auto__" - tmp5 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp6 := lang.Apply(tmp5, []any{lang.Builtins["float64"], v3}) var v7 any = tmp6 _ = v7 @@ -23076,7 +23669,7 @@ func LoadNS() { if lang.IsTruthy(v7) { tmp8 = v7 } else { - tmp9 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp9 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp10 := lang.Apply(tmp9, []any{lang.Builtins["float32"], v3}) tmp8 = tmp10 } @@ -23084,7 +23677,7 @@ func LoadNS() { } // end let return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -23096,20 +23689,18 @@ func LoadNS() { { // function floats var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) - tmp5 := checkDerefVar(glojure_DOT_core_concat) - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol("glojure.core/Floats")}) - tmp12 := checkDerefVar(glojure_DOT_core_list) + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Floats}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := lang.Apply(tmp12, []any{v3}) tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) tmp15 := lang.Apply(tmp4, []any{tmp14}) @@ -23118,12 +23709,10 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("floats").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Casts to float[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5392), lang.NewKeyword("end-line"), int(5392))).(*lang.Symbol) + tmp0 := sym_floats.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xs)), kw_inline, tmp1, kw_doc, "Casts to float[]", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(12), kw_line, int(5392), kw_end_DASH_line, int(5392))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Floats") @@ -23133,7 +23722,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v4}) return tmp6 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -23141,13 +23730,11 @@ func LoadNS() { } // flush { - tmp0 := lang.NewSymbol("flush").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Flushes the output stream that is the current value of\n *out*", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3706), lang.NewKeyword("end-line"), int(3706))).(*lang.Symbol) + tmp0 := sym_flush.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Flushes the output stream that is the current value of\n *out*", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3706), kw_end_DASH_line, int(3706))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - tmp3 := checkDerefVar(glojure_DOT_core__STAR_out_STAR_) + checkArity(args, 0) + tmp3 := checkDerefVar(var_glojure_DOT_core__STAR_out_STAR_) tmp4, _ := lang.FieldOrMethod(tmp3, "Sync") if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Sync is not a function"))) @@ -23156,7 +23743,7 @@ func LoadNS() { _ = tmp5 return nil }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -23164,14 +23751,12 @@ func LoadNS() { } // fn { - tmp0 := lang.NewSymbol("fn").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("sigs"))), lang.NewKeyword("doc"), "params => positional-params*, or positional-params* & rest-param\n positional-param => binding-form\n rest-param => binding-form\n binding-form => name, or destructuring-form\n\n Defines a function.\n\n See https://glojure.org/reference/special_forms#fn for more information", lang.NewKeyword("forms"), lang.NewVector(lang.NewList(lang.NewSymbol("fn"), lang.NewSymbol("name?"), lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("exprs*")), lang.NewList(lang.NewSymbol("fn"), lang.NewSymbol("name?"), lang.NewList(lang.NewVector(lang.NewSymbol("params*")), lang.NewSymbol("exprs*")), lang.NewSymbol("+"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4533), lang.NewKeyword("end-line"), int(4533), lang.NewKeyword("special-form"), true)).(*lang.Symbol) + tmp0 := sym_fn.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_sigs)), kw_doc, "params => positional-params*, or positional-params* & rest-param\n positional-param => binding-form\n rest-param => binding-form\n binding-form => name, or destructuring-form\n\n Defines a function.\n\n See https://glojure.org/reference/special_forms#fn for more information", kw_forms, lang.NewVector(lang.NewList(sym_fn, sym_name_QMARK_, lang.NewVector(sym_params_STAR_), sym_exprs_STAR_), lang.NewList(sym_fn, sym_name_QMARK_, lang.NewList(lang.NewVector(sym_params_STAR_), sym_exprs_STAR_), sym__PLUS_)), kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(11), kw_line, int(4533), kw_end_DASH_line, int(4533), kw_special_DASH_form, true)).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -23182,12 +23767,12 @@ func LoadNS() { { // let // let binding "name" var tmp7 any - tmp8 := checkDerefVar(glojure_DOT_core_symbol_QMARK_) - tmp9 := checkDerefVar(glojure_DOT_core_first) + tmp8 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp9 := checkDerefVar(var_glojure_DOT_core_first) tmp10 := lang.Apply(tmp9, []any{v5}) tmp11 := lang.Apply(tmp8, []any{tmp10}) if lang.IsTruthy(tmp11) { - tmp12 := checkDerefVar(glojure_DOT_core_first) + tmp12 := checkDerefVar(var_glojure_DOT_core_first) tmp13 := lang.Apply(tmp12, []any{v5}) tmp7 = tmp13 } else { @@ -23197,7 +23782,7 @@ func LoadNS() { // let binding "sigs" var tmp15 any if lang.IsTruthy(v14) { - tmp16 := checkDerefVar(glojure_DOT_core_next) + tmp16 := checkDerefVar(var_glojure_DOT_core_next) tmp17 := lang.Apply(tmp16, []any{v5}) tmp15 = tmp17 } else { @@ -23207,34 +23792,34 @@ func LoadNS() { _ = v18 // let binding "sigs" var tmp19 any - tmp20 := checkDerefVar(glojure_DOT_core_vector_QMARK_) - tmp21 := checkDerefVar(glojure_DOT_core_first) + tmp20 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp21 := checkDerefVar(var_glojure_DOT_core_first) tmp22 := lang.Apply(tmp21, []any{v18}) tmp23 := lang.Apply(tmp20, []any{tmp22}) if lang.IsTruthy(tmp23) { - tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) tmp25 := lang.Apply(tmp24, []any{v18}) tmp19 = tmp25 } else { var tmp26 any - tmp27 := checkDerefVar(glojure_DOT_core_seq_QMARK_) - tmp28 := checkDerefVar(glojure_DOT_core_first) + tmp27 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp28 := checkDerefVar(var_glojure_DOT_core_first) tmp29 := lang.Apply(tmp28, []any{v18}) tmp30 := lang.Apply(tmp27, []any{tmp29}) if lang.IsTruthy(tmp30) { tmp26 = v18 } else { var tmp31 any - tmp32 := checkDerefVar(glojure_DOT_core_seq) + tmp32 := checkDerefVar(var_glojure_DOT_core_seq) tmp33 := lang.Apply(tmp32, []any{v18}) if lang.IsTruthy(tmp33) { - tmp34 := checkDerefVar(glojure_DOT_core_str) - tmp35 := checkDerefVar(glojure_DOT_core_first) + tmp34 := checkDerefVar(var_glojure_DOT_core_str) + tmp35 := checkDerefVar(var_glojure_DOT_core_first) tmp36 := lang.Apply(tmp35, []any{v18}) tmp37 := lang.Apply(tmp34, []any{"Parameter declaration ", tmp36, " should be a vector"}) tmp31 = tmp37 } else { - tmp38 := checkDerefVar(glojure_DOT_core_str) + tmp38 := checkDerefVar(var_glojure_DOT_core_str) tmp39 := lang.Apply(tmp38, []any{"Parameter declaration missing"}) tmp31 = tmp39 } @@ -23248,18 +23833,16 @@ func LoadNS() { // let binding "psig" var tmp42 lang.FnFunc tmp42 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v43 := args[0] _ = v43 var tmp44 any - tmp45 := checkDerefVar(glojure_DOT_core_not) - tmp46 := checkDerefVar(glojure_DOT_core_seq_QMARK_) + tmp45 := checkDerefVar(var_glojure_DOT_core_not) + tmp46 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) tmp47 := lang.Apply(tmp46, []any{v43}) tmp48 := lang.Apply(tmp45, []any{tmp47}) if lang.IsTruthy(tmp48) { - tmp49 := checkDerefVar(glojure_DOT_core_str) + tmp49 := checkDerefVar(var_glojure_DOT_core_str) tmp50 := lang.Apply(tmp49, []any{"Invalid signature ", v43, " should be a list"}) tmp51 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp50}) panic(tmp51) @@ -23272,17 +23855,17 @@ func LoadNS() { var v53 any = v43 _ = v53 // let binding "seq__14" - tmp54 := checkDerefVar(glojure_DOT_core_seq) + tmp54 := checkDerefVar(var_glojure_DOT_core_seq) tmp55 := lang.Apply(tmp54, []any{v53}) var v56 any = tmp55 _ = v56 // let binding "first__15" - tmp57 := checkDerefVar(glojure_DOT_core_first) + tmp57 := checkDerefVar(var_glojure_DOT_core_first) tmp58 := lang.Apply(tmp57, []any{v56}) var v59 any = tmp58 _ = v59 // let binding "seq__14" - tmp60 := checkDerefVar(glojure_DOT_core_next) + tmp60 := checkDerefVar(var_glojure_DOT_core_next) tmp61 := lang.Apply(tmp60, []any{v56}) var v62 any = tmp61 _ = v62 @@ -23294,22 +23877,22 @@ func LoadNS() { _ = v64 // let binding "_" var tmp65 any - tmp66 := checkDerefVar(glojure_DOT_core_not) - tmp67 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp66 := checkDerefVar(var_glojure_DOT_core_not) + tmp67 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) tmp68 := lang.Apply(tmp67, []any{v63}) tmp69 := lang.Apply(tmp66, []any{tmp68}) if lang.IsTruthy(tmp69) { var tmp70 any - tmp71 := checkDerefVar(glojure_DOT_core_seq_QMARK_) - tmp72 := checkDerefVar(glojure_DOT_core_first) + tmp71 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp72 := checkDerefVar(var_glojure_DOT_core_first) tmp73 := lang.Apply(tmp72, []any{v41}) tmp74 := lang.Apply(tmp71, []any{tmp73}) if lang.IsTruthy(tmp74) { - tmp75 := checkDerefVar(glojure_DOT_core_str) + tmp75 := checkDerefVar(var_glojure_DOT_core_str) tmp76 := lang.Apply(tmp75, []any{"Parameter declaration ", v63, " should be a vector"}) tmp70 = tmp76 } else { - tmp77 := checkDerefVar(glojure_DOT_core_str) + tmp77 := checkDerefVar(var_glojure_DOT_core_str) tmp78 := lang.Apply(tmp77, []any{"Invalid signature ", v43, " should be a list"}) tmp70 = tmp78 } @@ -23324,14 +23907,14 @@ func LoadNS() { var tmp82 any { // let // let binding "and__0__auto__" - tmp83 := checkDerefVar(glojure_DOT_core_next) + tmp83 := checkDerefVar(var_glojure_DOT_core_next) tmp84 := lang.Apply(tmp83, []any{v64}) var v85 any = tmp84 _ = v85 var tmp86 any if lang.IsTruthy(v85) { - tmp87 := checkDerefVar(glojure_DOT_core_map_QMARK_) - tmp88 := checkDerefVar(glojure_DOT_core_first) + tmp87 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp88 := checkDerefVar(var_glojure_DOT_core_first) tmp89 := lang.Apply(tmp88, []any{v64}) tmp90 := lang.Apply(tmp87, []any{tmp89}) tmp86 = tmp90 @@ -23341,7 +23924,7 @@ func LoadNS() { tmp82 = tmp86 } // end let if lang.IsTruthy(tmp82) { - tmp83 := checkDerefVar(glojure_DOT_core_first) + tmp83 := checkDerefVar(var_glojure_DOT_core_first) tmp84 := lang.Apply(tmp83, []any{v64}) tmp81 = tmp84 } else { @@ -23351,7 +23934,7 @@ func LoadNS() { // let binding "body" var tmp86 any if lang.IsTruthy(v85) { - tmp87 := checkDerefVar(glojure_DOT_core_next) + tmp87 := checkDerefVar(var_glojure_DOT_core_next) tmp88 := lang.Apply(tmp87, []any{v64}) tmp86 = tmp88 } else { @@ -23369,7 +23952,7 @@ func LoadNS() { if lang.IsTruthy(v91) { tmp92 = v91 } else { - tmp93 := checkDerefVar(glojure_DOT_core_meta) + tmp93 := checkDerefVar(var_glojure_DOT_core_meta) tmp94 := lang.Apply(tmp93, []any{v63}) tmp92 = tmp94 } @@ -23378,46 +23961,46 @@ func LoadNS() { var v91 any = tmp90 _ = v91 // let binding "pre" - tmp92 := lang.Apply(lang.NewKeyword("pre"), []any{v91}) + tmp92 := lang.Apply(kw_pre, []any{v91}) var v93 any = tmp92 _ = v93 // let binding "post" - tmp94 := lang.Apply(lang.NewKeyword("post"), []any{v91}) + tmp94 := lang.Apply(kw_post, []any{v91}) var v95 any = tmp94 _ = v95 // let binding "body" var tmp96 any if lang.IsTruthy(v95) { - tmp97 := checkDerefVar(glojure_DOT_core_seq) - tmp98 := checkDerefVar(glojure_DOT_core_concat) - tmp99 := checkDerefVar(glojure_DOT_core_list) - tmp100 := checkDerefVar(glojure_DOT_core_seq) - tmp101 := checkDerefVar(glojure_DOT_core_concat) - tmp102 := checkDerefVar(glojure_DOT_core_list) - tmp103 := lang.Apply(tmp102, []any{lang.NewSymbol("glojure.core/let")}) - tmp104 := checkDerefVar(glojure_DOT_core_list) - tmp105 := checkDerefVar(glojure_DOT_core_apply) - tmp106 := checkDerefVar(glojure_DOT_core_vector) - tmp107 := checkDerefVar(glojure_DOT_core_seq) - tmp108 := checkDerefVar(glojure_DOT_core_concat) - tmp109 := checkDerefVar(glojure_DOT_core_list) - tmp110 := lang.Apply(tmp109, []any{lang.NewSymbol("%")}) - tmp111 := checkDerefVar(glojure_DOT_core_list) + tmp97 := checkDerefVar(var_glojure_DOT_core_seq) + tmp98 := checkDerefVar(var_glojure_DOT_core_concat) + tmp99 := checkDerefVar(var_glojure_DOT_core_list) + tmp100 := checkDerefVar(var_glojure_DOT_core_seq) + tmp101 := checkDerefVar(var_glojure_DOT_core_concat) + tmp102 := checkDerefVar(var_glojure_DOT_core_list) + tmp103 := lang.Apply(tmp102, []any{sym_glojure_DOT_core_SLASH_let}) + tmp104 := checkDerefVar(var_glojure_DOT_core_list) + tmp105 := checkDerefVar(var_glojure_DOT_core_apply) + tmp106 := checkDerefVar(var_glojure_DOT_core_vector) + tmp107 := checkDerefVar(var_glojure_DOT_core_seq) + tmp108 := checkDerefVar(var_glojure_DOT_core_concat) + tmp109 := checkDerefVar(var_glojure_DOT_core_list) + tmp110 := lang.Apply(tmp109, []any{sym__PCT_}) + tmp111 := checkDerefVar(var_glojure_DOT_core_list) var tmp112 any - tmp113 := checkDerefVar(glojure_DOT_core__LT_) - tmp114 := checkDerefVar(glojure_DOT_core_count) + tmp113 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp114 := checkDerefVar(var_glojure_DOT_core_count) tmp115 := lang.Apply(tmp114, []any{v89}) tmp116 := lang.Apply(tmp113, []any{int64(1), tmp115}) if lang.IsTruthy(tmp116) { - tmp117 := checkDerefVar(glojure_DOT_core_seq) - tmp118 := checkDerefVar(glojure_DOT_core_concat) - tmp119 := checkDerefVar(glojure_DOT_core_list) - tmp120 := lang.Apply(tmp119, []any{lang.NewSymbol("do")}) + tmp117 := checkDerefVar(var_glojure_DOT_core_seq) + tmp118 := checkDerefVar(var_glojure_DOT_core_concat) + tmp119 := checkDerefVar(var_glojure_DOT_core_list) + tmp120 := lang.Apply(tmp119, []any{sym_do}) tmp121 := lang.Apply(tmp118, []any{tmp120, v89}) tmp122 := lang.Apply(tmp117, []any{tmp121}) tmp112 = tmp122 } else { - tmp123 := checkDerefVar(glojure_DOT_core_first) + tmp123 := checkDerefVar(var_glojure_DOT_core_first) tmp124 := lang.Apply(tmp123, []any{v89}) tmp112 = tmp124 } @@ -23426,32 +24009,30 @@ func LoadNS() { tmp127 := lang.Apply(tmp107, []any{tmp126}) tmp128 := lang.Apply(tmp105, []any{tmp106, tmp127}) tmp129 := lang.Apply(tmp104, []any{tmp128}) - tmp130 := checkDerefVar(glojure_DOT_core_map) + tmp130 := checkDerefVar(var_glojure_DOT_core_map) var tmp131 lang.FnFunc tmp131 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v132 := args[0] _ = v132 - tmp133 := checkDerefVar(glojure_DOT_core_seq) - tmp134 := checkDerefVar(glojure_DOT_core_concat) - tmp135 := checkDerefVar(glojure_DOT_core_list) - tmp136 := lang.Apply(tmp135, []any{lang.NewSymbol("glojure.core/assert")}) - tmp137 := checkDerefVar(glojure_DOT_core_list) + tmp133 := checkDerefVar(var_glojure_DOT_core_seq) + tmp134 := checkDerefVar(var_glojure_DOT_core_concat) + tmp135 := checkDerefVar(var_glojure_DOT_core_list) + tmp136 := lang.Apply(tmp135, []any{sym_glojure_DOT_core_SLASH_assert}) + tmp137 := checkDerefVar(var_glojure_DOT_core_list) tmp138 := lang.Apply(tmp137, []any{v132}) tmp139 := lang.Apply(tmp134, []any{tmp136, tmp138}) tmp140 := lang.Apply(tmp133, []any{tmp139}) return tmp140 }) - tmp132 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4582), lang.NewKeyword("column"), int(41), lang.NewKeyword("end-line"), int(4582), lang.NewKeyword("end-column"), int(62)) + tmp132 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4582), kw_column, int(41), kw_end_DASH_line, int(4582), kw_end_DASH_column, int(62)) tmp133, err := lang.WithMeta(tmp131, tmp132.(lang.IPersistentMap)) if err != nil { panic(err) } tmp134 := lang.Apply(tmp130, []any{tmp133, v95}) - tmp135 := checkDerefVar(glojure_DOT_core_list) - tmp136 := lang.Apply(tmp135, []any{lang.NewSymbol("%")}) + tmp135 := checkDerefVar(var_glojure_DOT_core_list) + tmp136 := lang.Apply(tmp135, []any{sym__PCT_}) tmp137 := lang.Apply(tmp101, []any{tmp103, tmp129, tmp134, tmp136}) tmp138 := lang.Apply(tmp100, []any{tmp137}) tmp139 := lang.Apply(tmp99, []any{tmp138}) @@ -23466,26 +24047,24 @@ func LoadNS() { // let binding "body" var tmp143 any if lang.IsTruthy(v93) { - tmp144 := checkDerefVar(glojure_DOT_core_concat) - tmp145 := checkDerefVar(glojure_DOT_core_map) + tmp144 := checkDerefVar(var_glojure_DOT_core_concat) + tmp145 := checkDerefVar(var_glojure_DOT_core_map) var tmp146 lang.FnFunc tmp146 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v147 := args[0] _ = v147 - tmp148 := checkDerefVar(glojure_DOT_core_seq) - tmp149 := checkDerefVar(glojure_DOT_core_concat) - tmp150 := checkDerefVar(glojure_DOT_core_list) - tmp151 := lang.Apply(tmp150, []any{lang.NewSymbol("glojure.core/assert")}) - tmp152 := checkDerefVar(glojure_DOT_core_list) + tmp148 := checkDerefVar(var_glojure_DOT_core_seq) + tmp149 := checkDerefVar(var_glojure_DOT_core_concat) + tmp150 := checkDerefVar(var_glojure_DOT_core_list) + tmp151 := lang.Apply(tmp150, []any{sym_glojure_DOT_core_SLASH_assert}) + tmp152 := checkDerefVar(var_glojure_DOT_core_list) tmp153 := lang.Apply(tmp152, []any{v147}) tmp154 := lang.Apply(tmp149, []any{tmp151, tmp153}) tmp155 := lang.Apply(tmp148, []any{tmp154}) return tmp155 }) - tmp147 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4586), lang.NewKeyword("column"), int(44), lang.NewKeyword("end-line"), int(4586), lang.NewKeyword("end-column"), int(65)) + tmp147 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4586), kw_column, int(44), kw_end_DASH_line, int(4586), kw_end_DASH_column, int(65)) tmp148, err := lang.WithMeta(tmp146, tmp147.(lang.IPersistentMap)) if err != nil { panic(err) @@ -23498,13 +24077,13 @@ func LoadNS() { } var v151 any = tmp143 _ = v151 - tmp152 := checkDerefVar(glojure_DOT_core_maybe_destructured) + tmp152 := checkDerefVar(var_glojure_DOT_core_maybe_DASH_destructured) tmp153 := lang.Apply(tmp152, []any{v63, v151}) tmp52 = tmp153 } // end let return tmp52 }) - tmp43 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4558), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(4589), lang.NewKeyword("end-column"), int(53)) + tmp43 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4558), kw_column, int(16), kw_end_DASH_line, int(4589), kw_end_DASH_column, int(53)) tmp44, err := lang.WithMeta(tmp42, tmp43.(lang.IPersistentMap)) if err != nil { panic(err) @@ -23512,22 +24091,22 @@ func LoadNS() { var v45 any = tmp44 _ = v45 // let binding "new-sigs" - tmp46 := checkDerefVar(glojure_DOT_core_map) + tmp46 := checkDerefVar(var_glojure_DOT_core_map) tmp47 := lang.Apply(tmp46, []any{v45, v41}) var v48 any = tmp47 _ = v48 - tmp49 := checkDerefVar(glojure_DOT_core_with_meta) + tmp49 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) var tmp50 any if lang.IsTruthy(v14) { - tmp51 := checkDerefVar(glojure_DOT_core_list_STAR_) - tmp52 := lang.Apply(tmp51, []any{lang.NewSymbol("fn*"), v14, v48}) + tmp51 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp52 := lang.Apply(tmp51, []any{sym_fn_STAR_, v14, v48}) tmp50 = tmp52 } else { - tmp53 := checkDerefVar(glojure_DOT_core_cons) - tmp54 := lang.Apply(tmp53, []any{lang.NewSymbol("fn*"), v48}) + tmp53 := checkDerefVar(var_glojure_DOT_core_cons) + tmp54 := lang.Apply(tmp53, []any{sym_fn_STAR_, v48}) tmp50 = tmp54 } - tmp55 := checkDerefVar(glojure_DOT_core_meta) + tmp55 := checkDerefVar(var_glojure_DOT_core_meta) tmp56 := lang.Apply(tmp55, []any{v3}) tmp57 := lang.Apply(tmp49, []any{tmp50, tmp56}) tmp6 = tmp57 @@ -23535,7 +24114,7 @@ func LoadNS() { return tmp6 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -23543,20 +24122,18 @@ func LoadNS() { } // fn? { - tmp0 := lang.NewSymbol("fn?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements Fn, i.e. is an object created via fn.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6216), lang.NewKeyword("end-line"), int(6216))).(*lang.Symbol) + tmp0 := sym_fn_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x implements Fn, i.e. is an object created via fn.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(6216), kw_end_DASH_line, int(6216))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp5 := reflect.TypeOf((*runtime7.Fn)(nil)) tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -23564,23 +24141,21 @@ func LoadNS() { } // fnext { - tmp0 := lang.NewSymbol("fnext").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Same as (first (next x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(112), lang.NewKeyword("end-line"), int(116))).(*lang.Symbol) + tmp0 := sym_fnext.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Same as (first (next x))", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(6), kw_column, int(2), kw_line, int(112), kw_end_DASH_line, int(116))).(*lang.Symbol) var tmp2 lang.FnFunc { // function fnext var v3 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_first) - tmp6 := checkDerefVar(glojure_DOT_core_next) + tmp5 := checkDerefVar(var_glojure_DOT_core_first) + tmp6 := checkDerefVar(var_glojure_DOT_core_next) tmp7 := lang.Apply(tmp6, []any{v4}) tmp8 := lang.Apply(tmp5, []any{tmp7}) return tmp8 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(116), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(116), lang.NewKeyword("end-column"), int(47))).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(116), kw_column, int(8), kw_end_DASH_line, int(116), kw_end_DASH_column, int(47))).(lang.FnFunc) v3 = tmp2 _ = v3 } @@ -23591,7 +24166,7 @@ func LoadNS() { } // fnil { - tmp0 := lang.NewSymbol("fnil").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("z"))), lang.NewKeyword("doc"), "Takes a function f, and returns a function that calls f, replacing\n a nil first argument to f with the supplied value x. Higher arity\n versions can replace arguments in the second and third\n positions (y, z). Note that the function f can take any number of\n arguments, not just the one(s) being nil-patched.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6558), lang.NewKeyword("end-line"), int(6558))).(*lang.Symbol) + tmp0 := sym_fnil.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_x), lang.NewVector(sym_f, sym_x, sym_y), lang.NewVector(sym_f, sym_x, sym_y, sym_z)), kw_doc, "Takes a function f, and returns a function that calls f, replacing\n a nil first argument to f with the supplied value x. Higher arity\n versions can replace arguments in the second and third\n positions (y, z). Note that the function f can take any number of\n arguments, not just the one(s) being nil-patched.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(6558), kw_end_DASH_line, int(6558))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -23607,7 +24182,7 @@ func LoadNS() { v6 := args[0] _ = v6 var tmp7 any - tmp8 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp8 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) tmp9 := lang.Apply(tmp8, []any{v6}) if lang.IsTruthy(tmp9) { tmp7 = v4 @@ -23622,7 +24197,7 @@ func LoadNS() { v7 := args[1] _ = v7 var tmp8 any - tmp9 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp9 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) tmp10 := lang.Apply(tmp9, []any{v6}) if lang.IsTruthy(tmp10) { tmp8 = v4 @@ -23639,7 +24214,7 @@ func LoadNS() { v8 := args[2] _ = v8 var tmp9 any - tmp10 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp10 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) tmp11 := lang.Apply(tmp10, []any{v6}) if lang.IsTruthy(tmp11) { tmp9 = v4 @@ -23649,9 +24224,7 @@ func LoadNS() { tmp12 := lang.Apply(v3, []any{tmp9, v7, v8}) return tmp12 default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v6 := args[0] _ = v6 v7 := args[1] @@ -23660,9 +24233,9 @@ func LoadNS() { _ = v8 var v9 any = lang.NewList(args[3:]...) _ = v9 - tmp10 := checkDerefVar(glojure_DOT_core_apply) + tmp10 := checkDerefVar(var_glojure_DOT_core_apply) var tmp11 any - tmp12 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp12 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) tmp13 := lang.Apply(tmp12, []any{v6}) if lang.IsTruthy(tmp13) { tmp11 = v4 @@ -23673,7 +24246,7 @@ func LoadNS() { return tmp14 } }) - tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6567), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(6571), lang.NewKeyword("end-column"), int(55)) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6567), kw_column, int(4), kw_end_DASH_line, int(6571), kw_end_DASH_column, int(55)) tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) if err != nil { panic(err) @@ -23695,7 +24268,7 @@ func LoadNS() { v8 := args[1] _ = v8 var tmp9 any - tmp10 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp10 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) tmp11 := lang.Apply(tmp10, []any{v7}) if lang.IsTruthy(tmp11) { tmp9 = v4 @@ -23703,7 +24276,7 @@ func LoadNS() { tmp9 = v7 } var tmp12 any - tmp13 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp13 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) tmp14 := lang.Apply(tmp13, []any{v8}) if lang.IsTruthy(tmp14) { tmp12 = v5 @@ -23720,7 +24293,7 @@ func LoadNS() { v9 := args[2] _ = v9 var tmp10 any - tmp11 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp11 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) tmp12 := lang.Apply(tmp11, []any{v7}) if lang.IsTruthy(tmp12) { tmp10 = v4 @@ -23728,7 +24301,7 @@ func LoadNS() { tmp10 = v7 } var tmp13 any - tmp14 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp14 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) tmp15 := lang.Apply(tmp14, []any{v8}) if lang.IsTruthy(tmp15) { tmp13 = v5 @@ -23738,9 +24311,7 @@ func LoadNS() { tmp16 := lang.Apply(v3, []any{tmp10, tmp13, v9}) return tmp16 default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v7 := args[0] _ = v7 v8 := args[1] @@ -23749,9 +24320,9 @@ func LoadNS() { _ = v9 var v10 any = lang.NewList(args[3:]...) _ = v10 - tmp11 := checkDerefVar(glojure_DOT_core_apply) + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) var tmp12 any - tmp13 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp13 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) tmp14 := lang.Apply(tmp13, []any{v7}) if lang.IsTruthy(tmp14) { tmp12 = v4 @@ -23759,7 +24330,7 @@ func LoadNS() { tmp12 = v7 } var tmp15 any - tmp16 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp16 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) tmp17 := lang.Apply(tmp16, []any{v8}) if lang.IsTruthy(tmp17) { tmp15 = v5 @@ -23770,7 +24341,7 @@ func LoadNS() { return tmp18 } }) - tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6573), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(6576), lang.NewKeyword("end-column"), int(71)) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6573), kw_column, int(4), kw_end_DASH_line, int(6576), kw_end_DASH_column, int(71)) tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) if err != nil { panic(err) @@ -23794,7 +24365,7 @@ func LoadNS() { v9 := args[1] _ = v9 var tmp10 any - tmp11 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp11 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) tmp12 := lang.Apply(tmp11, []any{v8}) if lang.IsTruthy(tmp12) { tmp10 = v4 @@ -23802,7 +24373,7 @@ func LoadNS() { tmp10 = v8 } var tmp13 any - tmp14 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp14 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) tmp15 := lang.Apply(tmp14, []any{v9}) if lang.IsTruthy(tmp15) { tmp13 = v5 @@ -23819,7 +24390,7 @@ func LoadNS() { v10 := args[2] _ = v10 var tmp11 any - tmp12 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp12 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) tmp13 := lang.Apply(tmp12, []any{v8}) if lang.IsTruthy(tmp13) { tmp11 = v4 @@ -23827,7 +24398,7 @@ func LoadNS() { tmp11 = v8 } var tmp14 any - tmp15 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp15 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) tmp16 := lang.Apply(tmp15, []any{v9}) if lang.IsTruthy(tmp16) { tmp14 = v5 @@ -23835,7 +24406,7 @@ func LoadNS() { tmp14 = v9 } var tmp17 any - tmp18 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp18 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) tmp19 := lang.Apply(tmp18, []any{v10}) if lang.IsTruthy(tmp19) { tmp17 = v6 @@ -23845,9 +24416,7 @@ func LoadNS() { tmp20 := lang.Apply(v3, []any{tmp11, tmp14, tmp17}) return tmp20 default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v8 := args[0] _ = v8 v9 := args[1] @@ -23856,9 +24425,9 @@ func LoadNS() { _ = v10 var v11 any = lang.NewList(args[3:]...) _ = v11 - tmp12 := checkDerefVar(glojure_DOT_core_apply) + tmp12 := checkDerefVar(var_glojure_DOT_core_apply) var tmp13 any - tmp14 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp14 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) tmp15 := lang.Apply(tmp14, []any{v8}) if lang.IsTruthy(tmp15) { tmp13 = v4 @@ -23866,7 +24435,7 @@ func LoadNS() { tmp13 = v8 } var tmp16 any - tmp17 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp17 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) tmp18 := lang.Apply(tmp17, []any{v9}) if lang.IsTruthy(tmp18) { tmp16 = v5 @@ -23874,7 +24443,7 @@ func LoadNS() { tmp16 = v9 } var tmp19 any - tmp20 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp20 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) tmp21 := lang.Apply(tmp20, []any{v10}) if lang.IsTruthy(tmp21) { tmp19 = v6 @@ -23885,17 +24454,18 @@ func LoadNS() { return tmp22 } }) - tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6578), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(6581), lang.NewKeyword("end-column"), int(87)) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6578), kw_column, int(4), kw_end_DASH_line, int(6581), kw_end_DASH_column, int(87)) tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) if err != nil { panic(err) } return tmp9 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -23903,12 +24473,10 @@ func LoadNS() { } // for { - tmp0 := lang.NewSymbol("for").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("seq-exprs"), lang.NewSymbol("body-expr"))), lang.NewKeyword("doc"), "List comprehension. Takes a vector of one or more\n binding-form/collection-expr pairs, each followed by zero or more\n modifiers, and yields a lazy sequence of evaluations of expr.\n Collections are iterated in a nested fashion, rightmost fastest,\n and nested coll-exprs can refer to bindings created in prior\n binding-forms. Supported modifiers are: :let [binding-form expr ...],\n :while test, :when test.\n\n (take 100 (for [x (range 100000000) y (range 1000000) :while (< y x)] [x y]))", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4646), lang.NewKeyword("end-line"), int(4646))).(*lang.Symbol) + tmp0 := sym_for.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_seq_DASH_exprs, sym_body_DASH_expr)), kw_doc, "List comprehension. Takes a vector of one or more\n binding-form/collection-expr pairs, each followed by zero or more\n modifiers, and yields a lazy sequence of evaluations of expr.\n Collections are iterated in a nested fashion, rightmost fastest,\n and nested coll-exprs can refer to bindings created in prior\n binding-forms. Supported modifiers are: :let [binding-form expr ...],\n :while test, :when test.\n\n (take 100 (for [x (range 100000000) y (range 1000000) :while (< y x)] [x y]))", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(11), kw_line, int(4646), kw_end_DASH_line, int(4646))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 4) v3 := args[0] _ = v3 v4 := args[1] @@ -23918,36 +24486,36 @@ func LoadNS() { v6 := args[3] _ = v6 var tmp7 any - tmp8 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp8 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) tmp9 := lang.Apply(tmp8, []any{v5}) if lang.IsTruthy(tmp9) { } else { - tmp10 := checkDerefVar(glojure_DOT_core_str) - tmp11 := checkDerefVar(glojure_DOT_core_first) + tmp10 := checkDerefVar(var_glojure_DOT_core_str) + tmp11 := checkDerefVar(var_glojure_DOT_core_first) tmp12 := lang.Apply(tmp11, []any{v3}) - tmp13 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) - tmp14 := checkDerefVar(glojure_DOT_core_meta) + tmp13 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp14 := checkDerefVar(var_glojure_DOT_core_meta) tmp15 := lang.Apply(tmp14, []any{v3}) - tmp16 := lang.Apply(lang.NewKeyword("line"), []any{tmp15}) + tmp16 := lang.Apply(kw_line, []any{tmp15}) tmp17 := lang.Apply(tmp10, []any{tmp12, " requires ", "a vector for its binding", " in ", tmp13, ":", tmp16}) tmp18 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp17}) panic(tmp18) } _ = tmp7 var tmp19 any - tmp20 := checkDerefVar(glojure_DOT_core_even_QMARK_) - tmp21 := checkDerefVar(glojure_DOT_core_count) + tmp20 := checkDerefVar(var_glojure_DOT_core_even_QMARK_) + tmp21 := checkDerefVar(var_glojure_DOT_core_count) tmp22 := lang.Apply(tmp21, []any{v5}) tmp23 := lang.Apply(tmp20, []any{tmp22}) if lang.IsTruthy(tmp23) { } else { - tmp24 := checkDerefVar(glojure_DOT_core_str) - tmp25 := checkDerefVar(glojure_DOT_core_first) + tmp24 := checkDerefVar(var_glojure_DOT_core_str) + tmp25 := checkDerefVar(var_glojure_DOT_core_first) tmp26 := lang.Apply(tmp25, []any{v3}) - tmp27 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) - tmp28 := checkDerefVar(glojure_DOT_core_meta) + tmp27 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp28 := checkDerefVar(var_glojure_DOT_core_meta) tmp29 := lang.Apply(tmp28, []any{v3}) - tmp30 := lang.Apply(lang.NewKeyword("line"), []any{tmp29}) + tmp30 := lang.Apply(kw_line, []any{tmp29}) tmp31 := lang.Apply(tmp24, []any{tmp26, " requires ", "an even number of forms in binding vector", " in ", tmp27, ":", tmp30}) tmp32 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp31}) panic(tmp32) @@ -23958,17 +24526,13 @@ func LoadNS() { // let binding "to-groups" var tmp34 lang.FnFunc tmp34 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v35 := args[0] _ = v35 - tmp36 := checkDerefVar(glojure_DOT_core_reduce1) + tmp36 := checkDerefVar(var_glojure_DOT_core_reduce1) var tmp37 lang.FnFunc tmp37 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v38 := args[0] _ = v38 v39 := args[1] @@ -23979,27 +24543,27 @@ func LoadNS() { var v41 any = v39 _ = v41 // let binding "k" - tmp42 := checkDerefVar(glojure_DOT_core_nth) + tmp42 := checkDerefVar(var_glojure_DOT_core_nth) tmp43 := lang.Apply(tmp42, []any{v41, int64(0), nil}) var v44 any = tmp43 _ = v44 // let binding "v" - tmp45 := checkDerefVar(glojure_DOT_core_nth) + tmp45 := checkDerefVar(var_glojure_DOT_core_nth) tmp46 := lang.Apply(tmp45, []any{v41, int64(1), nil}) var v47 any = tmp46 _ = v47 var tmp48 any - tmp49 := checkDerefVar(glojure_DOT_core_keyword_QMARK_) + tmp49 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) tmp50 := lang.Apply(tmp49, []any{v44}) if lang.IsTruthy(tmp50) { - tmp51 := checkDerefVar(glojure_DOT_core_conj) - tmp52 := checkDerefVar(glojure_DOT_core_pop) + tmp51 := checkDerefVar(var_glojure_DOT_core_conj) + tmp52 := checkDerefVar(var_glojure_DOT_core_pop) tmp53 := lang.Apply(tmp52, []any{v38}) - tmp54 := checkDerefVar(glojure_DOT_core_conj) - tmp55 := checkDerefVar(glojure_DOT_core_peek) + tmp54 := checkDerefVar(var_glojure_DOT_core_conj) + tmp55 := checkDerefVar(var_glojure_DOT_core_peek) tmp56 := lang.Apply(tmp55, []any{v38}) tmp57 := lang.NewVector(v44, v47) - tmp58 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4664), lang.NewKeyword("column"), int(72), lang.NewKeyword("end-line"), int(4664), lang.NewKeyword("end-column"), int(76)) + tmp58 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4664), kw_column, int(72), kw_end_DASH_line, int(4664), kw_end_DASH_column, int(76)) tmp59, err := lang.WithMeta(tmp57, tmp58.(lang.IPersistentMap)) if err != nil { panic(err) @@ -24008,9 +24572,9 @@ func LoadNS() { tmp61 := lang.Apply(tmp51, []any{tmp53, tmp60}) tmp48 = tmp61 } else { - tmp62 := checkDerefVar(glojure_DOT_core_conj) + tmp62 := checkDerefVar(var_glojure_DOT_core_conj) tmp63 := lang.NewVector(v44, v47) - tmp64 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4665), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(4665), lang.NewKeyword("end-column"), int(50)) + tmp64 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4665), kw_column, int(46), kw_end_DASH_line, int(4665), kw_end_DASH_column, int(50)) tmp65, err := lang.WithMeta(tmp63, tmp64.(lang.IPersistentMap)) if err != nil { panic(err) @@ -24022,23 +24586,23 @@ func LoadNS() { } // end let return tmp40 }) - tmp38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4662), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(4665), lang.NewKeyword("end-column"), int(53)) + tmp38 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4662), kw_column, int(30), kw_end_DASH_line, int(4665), kw_end_DASH_column, int(53)) tmp39, err := lang.WithMeta(tmp37, tmp38.(lang.IPersistentMap)) if err != nil { panic(err) } tmp40 := lang.NewVector() - tmp41 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4666), lang.NewKeyword("column"), int(29), lang.NewKeyword("end-line"), int(4666), lang.NewKeyword("end-column"), int(30)) + tmp41 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4666), kw_column, int(29), kw_end_DASH_line, int(4666), kw_end_DASH_column, int(30)) tmp42, err := lang.WithMeta(tmp40, tmp41.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp43 := checkDerefVar(glojure_DOT_core_partition) + tmp43 := checkDerefVar(var_glojure_DOT_core_partition) tmp44 := lang.Apply(tmp43, []any{int64(2), v35}) tmp45 := lang.Apply(tmp36, []any{tmp39, tmp42, tmp44}) return tmp45 }) - tmp35 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4661), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(4666), lang.NewKeyword("end-column"), int(56)) + tmp35 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4661), kw_column, int(19), kw_end_DASH_line, int(4666), kw_end_DASH_column, int(56)) tmp36, err := lang.WithMeta(tmp34, tmp35.(lang.IPersistentMap)) if err != nil { panic(err) @@ -24050,19 +24614,17 @@ func LoadNS() { tmp38 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var v39 any = lang.NewList(args[0:]...) _ = v39 - tmp40 := checkDerefVar(glojure_DOT_core_apply) - tmp41 := checkDerefVar(glojure_DOT_core_str) + tmp40 := checkDerefVar(var_glojure_DOT_core_apply) + tmp41 := checkDerefVar(var_glojure_DOT_core_str) tmp42 := lang.Apply(tmp40, []any{tmp41, v39}) tmp43 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp42}) panic(tmp43) } }) - tmp39 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4667), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(4667), lang.NewKeyword("end-column"), int(125)) + tmp39 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4667), kw_column, int(13), kw_end_DASH_line, int(4667), kw_end_DASH_column, int(125)) tmp40, err := lang.WithMeta(tmp38, tmp39.(lang.IPersistentMap)) if err != nil { panic(err) @@ -24074,9 +24636,7 @@ func LoadNS() { { // function emit-bind var v43 lang.FnFunc tmp42 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v44 := args[0] _ = v44 var tmp45 any @@ -24085,17 +24645,17 @@ func LoadNS() { var v46 any = v44 _ = v46 // let binding "seq__29" - tmp47 := checkDerefVar(glojure_DOT_core_seq) + tmp47 := checkDerefVar(var_glojure_DOT_core_seq) tmp48 := lang.Apply(tmp47, []any{v46}) var v49 any = tmp48 _ = v49 // let binding "first__30" - tmp50 := checkDerefVar(glojure_DOT_core_first) + tmp50 := checkDerefVar(var_glojure_DOT_core_first) tmp51 := lang.Apply(tmp50, []any{v49}) var v52 any = tmp51 _ = v52 // let binding "seq__29" - tmp53 := checkDerefVar(glojure_DOT_core_next) + tmp53 := checkDerefVar(var_glojure_DOT_core_next) tmp54 := lang.Apply(tmp53, []any{v49}) var v55 any = tmp54 _ = v55 @@ -24103,17 +24663,17 @@ func LoadNS() { var v56 any = v52 _ = v56 // let binding "seq__32" - tmp57 := checkDerefVar(glojure_DOT_core_seq) + tmp57 := checkDerefVar(var_glojure_DOT_core_seq) tmp58 := lang.Apply(tmp57, []any{v56}) var v59 any = tmp58 _ = v59 // let binding "first__33" - tmp60 := checkDerefVar(glojure_DOT_core_first) + tmp60 := checkDerefVar(var_glojure_DOT_core_first) tmp61 := lang.Apply(tmp60, []any{v59}) var v62 any = tmp61 _ = v62 // let binding "seq__32" - tmp63 := checkDerefVar(glojure_DOT_core_next) + tmp63 := checkDerefVar(var_glojure_DOT_core_next) tmp64 := lang.Apply(tmp63, []any{v59}) var v65 any = tmp64 _ = v65 @@ -24121,12 +24681,12 @@ func LoadNS() { var v66 any = v62 _ = v66 // let binding "first__33" - tmp67 := checkDerefVar(glojure_DOT_core_first) + tmp67 := checkDerefVar(var_glojure_DOT_core_first) tmp68 := lang.Apply(tmp67, []any{v65}) var v69 any = tmp68 _ = v69 // let binding "seq__32" - tmp70 := checkDerefVar(glojure_DOT_core_next) + tmp70 := checkDerefVar(var_glojure_DOT_core_next) tmp71 := lang.Apply(tmp70, []any{v65}) var v72 any = tmp71 _ = v72 @@ -24140,17 +24700,17 @@ func LoadNS() { var v75 any = v55 _ = v75 // let binding "vec__37" - tmp76 := checkDerefVar(glojure_DOT_core_nth) + tmp76 := checkDerefVar(var_glojure_DOT_core_nth) tmp77 := lang.Apply(tmp76, []any{v75, int64(0), nil}) var v78 any = tmp77 _ = v78 // let binding "_" - tmp79 := checkDerefVar(glojure_DOT_core_nth) + tmp79 := checkDerefVar(var_glojure_DOT_core_nth) tmp80 := lang.Apply(tmp79, []any{v78, int64(0), nil}) var v81 any = tmp80 _ = v81 // let binding "next-expr" - tmp82 := checkDerefVar(glojure_DOT_core_nth) + tmp82 := checkDerefVar(var_glojure_DOT_core_nth) tmp83 := lang.Apply(tmp82, []any{v78, int64(1), nil}) var v84 any = tmp83 _ = v84 @@ -24160,12 +24720,12 @@ func LoadNS() { var tmp86 any { // let // let binding "giter" - tmp87 := checkDerefVar(glojure_DOT_core_gensym) + tmp87 := checkDerefVar(var_glojure_DOT_core_gensym) tmp88 := lang.Apply(tmp87, []any{"iter__"}) var v89 any = tmp88 _ = v89 // let binding "gxs" - tmp90 := checkDerefVar(glojure_DOT_core_gensym) + tmp90 := checkDerefVar(var_glojure_DOT_core_gensym) tmp91 := lang.Apply(tmp90, []any{"s__"}) var v92 any = tmp91 _ = v92 @@ -24174,9 +24734,7 @@ func LoadNS() { { // function do-mod var v94 lang.FnFunc tmp93 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v95 := args[0] _ = v95 var tmp96 any @@ -24185,17 +24743,17 @@ func LoadNS() { var v97 any = v95 _ = v97 // let binding "seq__42" - tmp98 := checkDerefVar(glojure_DOT_core_seq) + tmp98 := checkDerefVar(var_glojure_DOT_core_seq) tmp99 := lang.Apply(tmp98, []any{v97}) var v100 any = tmp99 _ = v100 // let binding "first__43" - tmp101 := checkDerefVar(glojure_DOT_core_first) + tmp101 := checkDerefVar(var_glojure_DOT_core_first) tmp102 := lang.Apply(tmp101, []any{v100}) var v103 any = tmp102 _ = v103 // let binding "seq__42" - tmp104 := checkDerefVar(glojure_DOT_core_next) + tmp104 := checkDerefVar(var_glojure_DOT_core_next) tmp105 := lang.Apply(tmp104, []any{v100}) var v106 any = tmp105 _ = v106 @@ -24203,12 +24761,12 @@ func LoadNS() { var v107 any = v103 _ = v107 // let binding "k" - tmp108 := checkDerefVar(glojure_DOT_core_nth) + tmp108 := checkDerefVar(var_glojure_DOT_core_nth) tmp109 := lang.Apply(tmp108, []any{v107, int64(0), nil}) var v110 any = tmp109 _ = v110 // let binding "v" - tmp111 := checkDerefVar(glojure_DOT_core_nth) + tmp111 := checkDerefVar(var_glojure_DOT_core_nth) tmp112 := lang.Apply(tmp111, []any{v107, int64(1), nil}) var v113 any = tmp112 _ = v113 @@ -24219,16 +24777,16 @@ func LoadNS() { var v115 any = v106 _ = v115 var tmp116 any - tmp117 := checkDerefVar(glojure_DOT_core__EQ_) - tmp118 := lang.Apply(tmp117, []any{v110, lang.NewKeyword("let")}) + tmp117 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp118 := lang.Apply(tmp117, []any{v110, kw_let}) if lang.IsTruthy(tmp118) { - tmp119 := checkDerefVar(glojure_DOT_core_seq) - tmp120 := checkDerefVar(glojure_DOT_core_concat) - tmp121 := checkDerefVar(glojure_DOT_core_list) - tmp122 := lang.Apply(tmp121, []any{lang.NewSymbol("glojure.core/let")}) - tmp123 := checkDerefVar(glojure_DOT_core_list) + tmp119 := checkDerefVar(var_glojure_DOT_core_seq) + tmp120 := checkDerefVar(var_glojure_DOT_core_concat) + tmp121 := checkDerefVar(var_glojure_DOT_core_list) + tmp122 := lang.Apply(tmp121, []any{sym_glojure_DOT_core_SLASH_let}) + tmp123 := checkDerefVar(var_glojure_DOT_core_list) tmp124 := lang.Apply(tmp123, []any{v113}) - tmp125 := checkDerefVar(glojure_DOT_core_list) + tmp125 := checkDerefVar(var_glojure_DOT_core_list) tmp126 := lang.Apply(v94, []any{v115}) tmp127 := lang.Apply(tmp125, []any{tmp126}) tmp128 := lang.Apply(tmp120, []any{tmp122, tmp124, tmp127}) @@ -24236,16 +24794,16 @@ func LoadNS() { tmp116 = tmp129 } else { var tmp130 any - tmp131 := checkDerefVar(glojure_DOT_core__EQ_) - tmp132 := lang.Apply(tmp131, []any{v110, lang.NewKeyword("while")}) + tmp131 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp132 := lang.Apply(tmp131, []any{v110, kw_while}) if lang.IsTruthy(tmp132) { - tmp133 := checkDerefVar(glojure_DOT_core_seq) - tmp134 := checkDerefVar(glojure_DOT_core_concat) - tmp135 := checkDerefVar(glojure_DOT_core_list) - tmp136 := lang.Apply(tmp135, []any{lang.NewSymbol("glojure.core/when")}) - tmp137 := checkDerefVar(glojure_DOT_core_list) + tmp133 := checkDerefVar(var_glojure_DOT_core_seq) + tmp134 := checkDerefVar(var_glojure_DOT_core_concat) + tmp135 := checkDerefVar(var_glojure_DOT_core_list) + tmp136 := lang.Apply(tmp135, []any{sym_glojure_DOT_core_SLASH_when}) + tmp137 := checkDerefVar(var_glojure_DOT_core_list) tmp138 := lang.Apply(tmp137, []any{v113}) - tmp139 := checkDerefVar(glojure_DOT_core_list) + tmp139 := checkDerefVar(var_glojure_DOT_core_list) tmp140 := lang.Apply(v94, []any{v115}) tmp141 := lang.Apply(tmp139, []any{tmp140}) tmp142 := lang.Apply(tmp134, []any{tmp136, tmp138, tmp141}) @@ -24253,29 +24811,29 @@ func LoadNS() { tmp130 = tmp143 } else { var tmp144 any - tmp145 := checkDerefVar(glojure_DOT_core__EQ_) - tmp146 := lang.Apply(tmp145, []any{v110, lang.NewKeyword("when")}) + tmp145 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp146 := lang.Apply(tmp145, []any{v110, kw_when}) if lang.IsTruthy(tmp146) { - tmp147 := checkDerefVar(glojure_DOT_core_seq) - tmp148 := checkDerefVar(glojure_DOT_core_concat) - tmp149 := checkDerefVar(glojure_DOT_core_list) - tmp150 := lang.Apply(tmp149, []any{lang.NewSymbol("if")}) - tmp151 := checkDerefVar(glojure_DOT_core_list) + tmp147 := checkDerefVar(var_glojure_DOT_core_seq) + tmp148 := checkDerefVar(var_glojure_DOT_core_concat) + tmp149 := checkDerefVar(var_glojure_DOT_core_list) + tmp150 := lang.Apply(tmp149, []any{sym_if}) + tmp151 := checkDerefVar(var_glojure_DOT_core_list) tmp152 := lang.Apply(tmp151, []any{v113}) - tmp153 := checkDerefVar(glojure_DOT_core_list) + tmp153 := checkDerefVar(var_glojure_DOT_core_list) tmp154 := lang.Apply(v94, []any{v115}) tmp155 := lang.Apply(tmp153, []any{tmp154}) - tmp156 := checkDerefVar(glojure_DOT_core_list) - tmp157 := checkDerefVar(glojure_DOT_core_seq) - tmp158 := checkDerefVar(glojure_DOT_core_concat) - tmp159 := checkDerefVar(glojure_DOT_core_list) - tmp160 := lang.Apply(tmp159, []any{lang.NewSymbol("recur")}) - tmp161 := checkDerefVar(glojure_DOT_core_list) - tmp162 := checkDerefVar(glojure_DOT_core_seq) - tmp163 := checkDerefVar(glojure_DOT_core_concat) - tmp164 := checkDerefVar(glojure_DOT_core_list) - tmp165 := lang.Apply(tmp164, []any{lang.NewSymbol("glojure.core/rest")}) - tmp166 := checkDerefVar(glojure_DOT_core_list) + tmp156 := checkDerefVar(var_glojure_DOT_core_list) + tmp157 := checkDerefVar(var_glojure_DOT_core_seq) + tmp158 := checkDerefVar(var_glojure_DOT_core_concat) + tmp159 := checkDerefVar(var_glojure_DOT_core_list) + tmp160 := lang.Apply(tmp159, []any{sym_recur}) + tmp161 := checkDerefVar(var_glojure_DOT_core_list) + tmp162 := checkDerefVar(var_glojure_DOT_core_seq) + tmp163 := checkDerefVar(var_glojure_DOT_core_concat) + tmp164 := checkDerefVar(var_glojure_DOT_core_list) + tmp165 := lang.Apply(tmp164, []any{sym_glojure_DOT_core_SLASH_rest}) + tmp166 := checkDerefVar(var_glojure_DOT_core_list) tmp167 := lang.Apply(tmp166, []any{v92}) tmp168 := lang.Apply(tmp163, []any{tmp165, tmp167}) tmp169 := lang.Apply(tmp162, []any{tmp168}) @@ -24288,7 +24846,7 @@ func LoadNS() { tmp144 = tmp175 } else { var tmp176 any - tmp177 := checkDerefVar(glojure_DOT_core_keyword_QMARK_) + tmp177 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) tmp178 := lang.Apply(tmp177, []any{v110}) if lang.IsTruthy(tmp178) { tmp179 := lang.Apply(v41, []any{"Invalid 'for' keyword ", v110}) @@ -24296,33 +24854,33 @@ func LoadNS() { } else { var tmp180 any if lang.IsTruthy(v85) { - tmp181 := checkDerefVar(glojure_DOT_core_seq) - tmp182 := checkDerefVar(glojure_DOT_core_concat) - tmp183 := checkDerefVar(glojure_DOT_core_list) - tmp184 := lang.Apply(tmp183, []any{lang.NewSymbol("glojure.core/let")}) - tmp185 := checkDerefVar(glojure_DOT_core_list) - tmp186 := checkDerefVar(glojure_DOT_core_apply) - tmp187 := checkDerefVar(glojure_DOT_core_vector) - tmp188 := checkDerefVar(glojure_DOT_core_seq) - tmp189 := checkDerefVar(glojure_DOT_core_concat) - tmp190 := checkDerefVar(glojure_DOT_core_list) - tmp191 := lang.Apply(tmp190, []any{lang.NewSymbol("iterys__0__auto__")}) - tmp192 := checkDerefVar(glojure_DOT_core_list) + tmp181 := checkDerefVar(var_glojure_DOT_core_seq) + tmp182 := checkDerefVar(var_glojure_DOT_core_concat) + tmp183 := checkDerefVar(var_glojure_DOT_core_list) + tmp184 := lang.Apply(tmp183, []any{sym_glojure_DOT_core_SLASH_let}) + tmp185 := checkDerefVar(var_glojure_DOT_core_list) + tmp186 := checkDerefVar(var_glojure_DOT_core_apply) + tmp187 := checkDerefVar(var_glojure_DOT_core_vector) + tmp188 := checkDerefVar(var_glojure_DOT_core_seq) + tmp189 := checkDerefVar(var_glojure_DOT_core_concat) + tmp190 := checkDerefVar(var_glojure_DOT_core_list) + tmp191 := lang.Apply(tmp190, []any{sym_iterys__0__auto__}) + tmp192 := checkDerefVar(var_glojure_DOT_core_list) tmp193 := lang.Apply(v43, []any{v85}) tmp194 := lang.Apply(tmp192, []any{tmp193}) - tmp195 := checkDerefVar(glojure_DOT_core_list) - tmp196 := lang.Apply(tmp195, []any{lang.NewSymbol("fs__1__auto__")}) - tmp197 := checkDerefVar(glojure_DOT_core_list) - tmp198 := checkDerefVar(glojure_DOT_core_seq) - tmp199 := checkDerefVar(glojure_DOT_core_concat) - tmp200 := checkDerefVar(glojure_DOT_core_list) - tmp201 := lang.Apply(tmp200, []any{lang.NewSymbol("glojure.core/seq")}) - tmp202 := checkDerefVar(glojure_DOT_core_list) - tmp203 := checkDerefVar(glojure_DOT_core_seq) - tmp204 := checkDerefVar(glojure_DOT_core_concat) - tmp205 := checkDerefVar(glojure_DOT_core_list) - tmp206 := lang.Apply(tmp205, []any{lang.NewSymbol("iterys__0__auto__")}) - tmp207 := checkDerefVar(glojure_DOT_core_list) + tmp195 := checkDerefVar(var_glojure_DOT_core_list) + tmp196 := lang.Apply(tmp195, []any{sym_fs__1__auto__}) + tmp197 := checkDerefVar(var_glojure_DOT_core_list) + tmp198 := checkDerefVar(var_glojure_DOT_core_seq) + tmp199 := checkDerefVar(var_glojure_DOT_core_concat) + tmp200 := checkDerefVar(var_glojure_DOT_core_list) + tmp201 := lang.Apply(tmp200, []any{sym_glojure_DOT_core_SLASH_seq}) + tmp202 := checkDerefVar(var_glojure_DOT_core_list) + tmp203 := checkDerefVar(var_glojure_DOT_core_seq) + tmp204 := checkDerefVar(var_glojure_DOT_core_concat) + tmp205 := checkDerefVar(var_glojure_DOT_core_list) + tmp206 := lang.Apply(tmp205, []any{sym_iterys__0__auto__}) + tmp207 := checkDerefVar(var_glojure_DOT_core_list) tmp208 := lang.Apply(tmp207, []any{v84}) tmp209 := lang.Apply(tmp204, []any{tmp206, tmp208}) tmp210 := lang.Apply(tmp203, []any{tmp209}) @@ -24334,31 +24892,31 @@ func LoadNS() { tmp216 := lang.Apply(tmp188, []any{tmp215}) tmp217 := lang.Apply(tmp186, []any{tmp187, tmp216}) tmp218 := lang.Apply(tmp185, []any{tmp217}) - tmp219 := checkDerefVar(glojure_DOT_core_list) - tmp220 := checkDerefVar(glojure_DOT_core_seq) - tmp221 := checkDerefVar(glojure_DOT_core_concat) - tmp222 := checkDerefVar(glojure_DOT_core_list) - tmp223 := lang.Apply(tmp222, []any{lang.NewSymbol("if")}) - tmp224 := checkDerefVar(glojure_DOT_core_list) - tmp225 := lang.Apply(tmp224, []any{lang.NewSymbol("fs__1__auto__")}) - tmp226 := checkDerefVar(glojure_DOT_core_list) - tmp227 := checkDerefVar(glojure_DOT_core_seq) - tmp228 := checkDerefVar(glojure_DOT_core_concat) - tmp229 := checkDerefVar(glojure_DOT_core_list) - tmp230 := lang.Apply(tmp229, []any{lang.NewSymbol("glojure.core/concat")}) - tmp231 := checkDerefVar(glojure_DOT_core_list) - tmp232 := lang.Apply(tmp231, []any{lang.NewSymbol("fs__1__auto__")}) - tmp233 := checkDerefVar(glojure_DOT_core_list) - tmp234 := checkDerefVar(glojure_DOT_core_seq) - tmp235 := checkDerefVar(glojure_DOT_core_concat) - tmp236 := checkDerefVar(glojure_DOT_core_list) + tmp219 := checkDerefVar(var_glojure_DOT_core_list) + tmp220 := checkDerefVar(var_glojure_DOT_core_seq) + tmp221 := checkDerefVar(var_glojure_DOT_core_concat) + tmp222 := checkDerefVar(var_glojure_DOT_core_list) + tmp223 := lang.Apply(tmp222, []any{sym_if}) + tmp224 := checkDerefVar(var_glojure_DOT_core_list) + tmp225 := lang.Apply(tmp224, []any{sym_fs__1__auto__}) + tmp226 := checkDerefVar(var_glojure_DOT_core_list) + tmp227 := checkDerefVar(var_glojure_DOT_core_seq) + tmp228 := checkDerefVar(var_glojure_DOT_core_concat) + tmp229 := checkDerefVar(var_glojure_DOT_core_list) + tmp230 := lang.Apply(tmp229, []any{sym_glojure_DOT_core_SLASH_concat}) + tmp231 := checkDerefVar(var_glojure_DOT_core_list) + tmp232 := lang.Apply(tmp231, []any{sym_fs__1__auto__}) + tmp233 := checkDerefVar(var_glojure_DOT_core_list) + tmp234 := checkDerefVar(var_glojure_DOT_core_seq) + tmp235 := checkDerefVar(var_glojure_DOT_core_concat) + tmp236 := checkDerefVar(var_glojure_DOT_core_list) tmp237 := lang.Apply(tmp236, []any{v89}) - tmp238 := checkDerefVar(glojure_DOT_core_list) - tmp239 := checkDerefVar(glojure_DOT_core_seq) - tmp240 := checkDerefVar(glojure_DOT_core_concat) - tmp241 := checkDerefVar(glojure_DOT_core_list) - tmp242 := lang.Apply(tmp241, []any{lang.NewSymbol("glojure.core/rest")}) - tmp243 := checkDerefVar(glojure_DOT_core_list) + tmp238 := checkDerefVar(var_glojure_DOT_core_list) + tmp239 := checkDerefVar(var_glojure_DOT_core_seq) + tmp240 := checkDerefVar(var_glojure_DOT_core_concat) + tmp241 := checkDerefVar(var_glojure_DOT_core_list) + tmp242 := lang.Apply(tmp241, []any{sym_glojure_DOT_core_SLASH_rest}) + tmp243 := checkDerefVar(var_glojure_DOT_core_list) tmp244 := lang.Apply(tmp243, []any{v92}) tmp245 := lang.Apply(tmp240, []any{tmp242, tmp244}) tmp246 := lang.Apply(tmp239, []any{tmp245}) @@ -24369,17 +24927,17 @@ func LoadNS() { tmp251 := lang.Apply(tmp228, []any{tmp230, tmp232, tmp250}) tmp252 := lang.Apply(tmp227, []any{tmp251}) tmp253 := lang.Apply(tmp226, []any{tmp252}) - tmp254 := checkDerefVar(glojure_DOT_core_list) - tmp255 := checkDerefVar(glojure_DOT_core_seq) - tmp256 := checkDerefVar(glojure_DOT_core_concat) - tmp257 := checkDerefVar(glojure_DOT_core_list) - tmp258 := lang.Apply(tmp257, []any{lang.NewSymbol("recur")}) - tmp259 := checkDerefVar(glojure_DOT_core_list) - tmp260 := checkDerefVar(glojure_DOT_core_seq) - tmp261 := checkDerefVar(glojure_DOT_core_concat) - tmp262 := checkDerefVar(glojure_DOT_core_list) - tmp263 := lang.Apply(tmp262, []any{lang.NewSymbol("glojure.core/rest")}) - tmp264 := checkDerefVar(glojure_DOT_core_list) + tmp254 := checkDerefVar(var_glojure_DOT_core_list) + tmp255 := checkDerefVar(var_glojure_DOT_core_seq) + tmp256 := checkDerefVar(var_glojure_DOT_core_concat) + tmp257 := checkDerefVar(var_glojure_DOT_core_list) + tmp258 := lang.Apply(tmp257, []any{sym_recur}) + tmp259 := checkDerefVar(var_glojure_DOT_core_list) + tmp260 := checkDerefVar(var_glojure_DOT_core_seq) + tmp261 := checkDerefVar(var_glojure_DOT_core_concat) + tmp262 := checkDerefVar(var_glojure_DOT_core_list) + tmp263 := lang.Apply(tmp262, []any{sym_glojure_DOT_core_SLASH_rest}) + tmp264 := checkDerefVar(var_glojure_DOT_core_list) tmp265 := lang.Apply(tmp264, []any{v92}) tmp266 := lang.Apply(tmp261, []any{tmp263, tmp265}) tmp267 := lang.Apply(tmp260, []any{tmp266}) @@ -24395,24 +24953,24 @@ func LoadNS() { tmp180 = tmp276 } else { var tmp277 any - if lang.IsTruthy(lang.NewKeyword("else")) { - tmp278 := checkDerefVar(glojure_DOT_core_seq) - tmp279 := checkDerefVar(glojure_DOT_core_concat) - tmp280 := checkDerefVar(glojure_DOT_core_list) - tmp281 := lang.Apply(tmp280, []any{lang.NewSymbol("glojure.core/cons")}) - tmp282 := checkDerefVar(glojure_DOT_core_list) + if lang.IsTruthy(kw_else) { + tmp278 := checkDerefVar(var_glojure_DOT_core_seq) + tmp279 := checkDerefVar(var_glojure_DOT_core_concat) + tmp280 := checkDerefVar(var_glojure_DOT_core_list) + tmp281 := lang.Apply(tmp280, []any{sym_glojure_DOT_core_SLASH_cons}) + tmp282 := checkDerefVar(var_glojure_DOT_core_list) tmp283 := lang.Apply(tmp282, []any{v6}) - tmp284 := checkDerefVar(glojure_DOT_core_list) - tmp285 := checkDerefVar(glojure_DOT_core_seq) - tmp286 := checkDerefVar(glojure_DOT_core_concat) - tmp287 := checkDerefVar(glojure_DOT_core_list) + tmp284 := checkDerefVar(var_glojure_DOT_core_list) + tmp285 := checkDerefVar(var_glojure_DOT_core_seq) + tmp286 := checkDerefVar(var_glojure_DOT_core_concat) + tmp287 := checkDerefVar(var_glojure_DOT_core_list) tmp288 := lang.Apply(tmp287, []any{v89}) - tmp289 := checkDerefVar(glojure_DOT_core_list) - tmp290 := checkDerefVar(glojure_DOT_core_seq) - tmp291 := checkDerefVar(glojure_DOT_core_concat) - tmp292 := checkDerefVar(glojure_DOT_core_list) - tmp293 := lang.Apply(tmp292, []any{lang.NewSymbol("glojure.core/rest")}) - tmp294 := checkDerefVar(glojure_DOT_core_list) + tmp289 := checkDerefVar(var_glojure_DOT_core_list) + tmp290 := checkDerefVar(var_glojure_DOT_core_seq) + tmp291 := checkDerefVar(var_glojure_DOT_core_concat) + tmp292 := checkDerefVar(var_glojure_DOT_core_list) + tmp293 := lang.Apply(tmp292, []any{sym_glojure_DOT_core_SLASH_rest}) + tmp294 := checkDerefVar(var_glojure_DOT_core_list) tmp295 := lang.Apply(tmp294, []any{v92}) tmp296 := lang.Apply(tmp291, []any{tmp293, tmp295}) tmp297 := lang.Apply(tmp290, []any{tmp296}) @@ -24442,7 +25000,7 @@ func LoadNS() { v94 = tmp93 _ = v94 } - tmp94 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4672), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(4687), lang.NewKeyword("end-column"), int(73)) + tmp94 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4672), kw_column, int(34), kw_end_DASH_line, int(4687), kw_end_DASH_column, int(73)) tmp95, err := lang.WithMeta(tmp93, tmp94.(lang.IPersistentMap)) if err != nil { panic(err) @@ -24451,65 +25009,65 @@ func LoadNS() { _ = v96 var tmp97 any if lang.IsTruthy(v85) { - tmp98 := checkDerefVar(glojure_DOT_core_seq) - tmp99 := checkDerefVar(glojure_DOT_core_concat) - tmp100 := checkDerefVar(glojure_DOT_core_list) - tmp101 := lang.Apply(tmp100, []any{lang.NewSymbol("glojure.core/fn")}) - tmp102 := checkDerefVar(glojure_DOT_core_list) + tmp98 := checkDerefVar(var_glojure_DOT_core_seq) + tmp99 := checkDerefVar(var_glojure_DOT_core_concat) + tmp100 := checkDerefVar(var_glojure_DOT_core_list) + tmp101 := lang.Apply(tmp100, []any{sym_glojure_DOT_core_SLASH_fn}) + tmp102 := checkDerefVar(var_glojure_DOT_core_list) tmp103 := lang.Apply(tmp102, []any{v89}) - tmp104 := checkDerefVar(glojure_DOT_core_list) - tmp105 := checkDerefVar(glojure_DOT_core_apply) - tmp106 := checkDerefVar(glojure_DOT_core_vector) - tmp107 := checkDerefVar(glojure_DOT_core_seq) - tmp108 := checkDerefVar(glojure_DOT_core_concat) - tmp109 := checkDerefVar(glojure_DOT_core_list) + tmp104 := checkDerefVar(var_glojure_DOT_core_list) + tmp105 := checkDerefVar(var_glojure_DOT_core_apply) + tmp106 := checkDerefVar(var_glojure_DOT_core_vector) + tmp107 := checkDerefVar(var_glojure_DOT_core_seq) + tmp108 := checkDerefVar(var_glojure_DOT_core_concat) + tmp109 := checkDerefVar(var_glojure_DOT_core_list) tmp110 := lang.Apply(tmp109, []any{v92}) tmp111 := lang.Apply(tmp108, []any{tmp110}) tmp112 := lang.Apply(tmp107, []any{tmp111}) tmp113 := lang.Apply(tmp105, []any{tmp106, tmp112}) tmp114 := lang.Apply(tmp104, []any{tmp113}) - tmp115 := checkDerefVar(glojure_DOT_core_list) - tmp116 := checkDerefVar(glojure_DOT_core_seq) - tmp117 := checkDerefVar(glojure_DOT_core_concat) - tmp118 := checkDerefVar(glojure_DOT_core_list) - tmp119 := lang.Apply(tmp118, []any{lang.NewSymbol("glojure.core/lazy-seq")}) - tmp120 := checkDerefVar(glojure_DOT_core_list) - tmp121 := checkDerefVar(glojure_DOT_core_seq) - tmp122 := checkDerefVar(glojure_DOT_core_concat) - tmp123 := checkDerefVar(glojure_DOT_core_list) - tmp124 := lang.Apply(tmp123, []any{lang.NewSymbol("glojure.core/loop")}) - tmp125 := checkDerefVar(glojure_DOT_core_list) - tmp126 := checkDerefVar(glojure_DOT_core_apply) - tmp127 := checkDerefVar(glojure_DOT_core_vector) - tmp128 := checkDerefVar(glojure_DOT_core_seq) - tmp129 := checkDerefVar(glojure_DOT_core_concat) - tmp130 := checkDerefVar(glojure_DOT_core_list) + tmp115 := checkDerefVar(var_glojure_DOT_core_list) + tmp116 := checkDerefVar(var_glojure_DOT_core_seq) + tmp117 := checkDerefVar(var_glojure_DOT_core_concat) + tmp118 := checkDerefVar(var_glojure_DOT_core_list) + tmp119 := lang.Apply(tmp118, []any{sym_glojure_DOT_core_SLASH_lazy_DASH_seq}) + tmp120 := checkDerefVar(var_glojure_DOT_core_list) + tmp121 := checkDerefVar(var_glojure_DOT_core_seq) + tmp122 := checkDerefVar(var_glojure_DOT_core_concat) + tmp123 := checkDerefVar(var_glojure_DOT_core_list) + tmp124 := lang.Apply(tmp123, []any{sym_glojure_DOT_core_SLASH_loop}) + tmp125 := checkDerefVar(var_glojure_DOT_core_list) + tmp126 := checkDerefVar(var_glojure_DOT_core_apply) + tmp127 := checkDerefVar(var_glojure_DOT_core_vector) + tmp128 := checkDerefVar(var_glojure_DOT_core_seq) + tmp129 := checkDerefVar(var_glojure_DOT_core_concat) + tmp130 := checkDerefVar(var_glojure_DOT_core_list) tmp131 := lang.Apply(tmp130, []any{v92}) - tmp132 := checkDerefVar(glojure_DOT_core_list) + tmp132 := checkDerefVar(var_glojure_DOT_core_list) tmp133 := lang.Apply(tmp132, []any{v92}) tmp134 := lang.Apply(tmp129, []any{tmp131, tmp133}) tmp135 := lang.Apply(tmp128, []any{tmp134}) tmp136 := lang.Apply(tmp126, []any{tmp127, tmp135}) tmp137 := lang.Apply(tmp125, []any{tmp136}) - tmp138 := checkDerefVar(glojure_DOT_core_list) - tmp139 := checkDerefVar(glojure_DOT_core_seq) - tmp140 := checkDerefVar(glojure_DOT_core_concat) - tmp141 := checkDerefVar(glojure_DOT_core_list) - tmp142 := lang.Apply(tmp141, []any{lang.NewSymbol("glojure.core/when-first")}) - tmp143 := checkDerefVar(glojure_DOT_core_list) - tmp144 := checkDerefVar(glojure_DOT_core_apply) - tmp145 := checkDerefVar(glojure_DOT_core_vector) - tmp146 := checkDerefVar(glojure_DOT_core_seq) - tmp147 := checkDerefVar(glojure_DOT_core_concat) - tmp148 := checkDerefVar(glojure_DOT_core_list) + tmp138 := checkDerefVar(var_glojure_DOT_core_list) + tmp139 := checkDerefVar(var_glojure_DOT_core_seq) + tmp140 := checkDerefVar(var_glojure_DOT_core_concat) + tmp141 := checkDerefVar(var_glojure_DOT_core_list) + tmp142 := lang.Apply(tmp141, []any{sym_glojure_DOT_core_SLASH_when_DASH_first}) + tmp143 := checkDerefVar(var_glojure_DOT_core_list) + tmp144 := checkDerefVar(var_glojure_DOT_core_apply) + tmp145 := checkDerefVar(var_glojure_DOT_core_vector) + tmp146 := checkDerefVar(var_glojure_DOT_core_seq) + tmp147 := checkDerefVar(var_glojure_DOT_core_concat) + tmp148 := checkDerefVar(var_glojure_DOT_core_list) tmp149 := lang.Apply(tmp148, []any{v66}) - tmp150 := checkDerefVar(glojure_DOT_core_list) + tmp150 := checkDerefVar(var_glojure_DOT_core_list) tmp151 := lang.Apply(tmp150, []any{v92}) tmp152 := lang.Apply(tmp147, []any{tmp149, tmp151}) tmp153 := lang.Apply(tmp146, []any{tmp152}) tmp154 := lang.Apply(tmp144, []any{tmp145, tmp153}) tmp155 := lang.Apply(tmp143, []any{tmp154}) - tmp156 := checkDerefVar(glojure_DOT_core_list) + tmp156 := checkDerefVar(var_glojure_DOT_core_list) tmp157 := lang.Apply(v96, []any{v74}) tmp158 := lang.Apply(tmp156, []any{tmp157}) tmp159 := lang.Apply(tmp140, []any{tmp142, tmp155, tmp158}) @@ -24528,12 +25086,12 @@ func LoadNS() { var tmp170 any { // let // let binding "gi" - tmp171 := checkDerefVar(glojure_DOT_core_gensym) + tmp171 := checkDerefVar(var_glojure_DOT_core_gensym) tmp172 := lang.Apply(tmp171, []any{"i__"}) var v173 any = tmp172 _ = v173 // let binding "gb" - tmp174 := checkDerefVar(glojure_DOT_core_gensym) + tmp174 := checkDerefVar(var_glojure_DOT_core_gensym) tmp175 := lang.Apply(tmp174, []any{"b__"}) var v176 any = tmp175 _ = v176 @@ -24542,9 +25100,7 @@ func LoadNS() { { // function do-cmod var v178 lang.FnFunc tmp177 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v179 := args[0] _ = v179 var tmp180 any @@ -24553,17 +25109,17 @@ func LoadNS() { var v181 any = v179 _ = v181 // let binding "seq__49" - tmp182 := checkDerefVar(glojure_DOT_core_seq) + tmp182 := checkDerefVar(var_glojure_DOT_core_seq) tmp183 := lang.Apply(tmp182, []any{v181}) var v184 any = tmp183 _ = v184 // let binding "first__50" - tmp185 := checkDerefVar(glojure_DOT_core_first) + tmp185 := checkDerefVar(var_glojure_DOT_core_first) tmp186 := lang.Apply(tmp185, []any{v184}) var v187 any = tmp186 _ = v187 // let binding "seq__49" - tmp188 := checkDerefVar(glojure_DOT_core_next) + tmp188 := checkDerefVar(var_glojure_DOT_core_next) tmp189 := lang.Apply(tmp188, []any{v184}) var v190 any = tmp189 _ = v190 @@ -24571,12 +25127,12 @@ func LoadNS() { var v191 any = v187 _ = v191 // let binding "k" - tmp192 := checkDerefVar(glojure_DOT_core_nth) + tmp192 := checkDerefVar(var_glojure_DOT_core_nth) tmp193 := lang.Apply(tmp192, []any{v191, int64(0), nil}) var v194 any = tmp193 _ = v194 // let binding "v" - tmp195 := checkDerefVar(glojure_DOT_core_nth) + tmp195 := checkDerefVar(var_glojure_DOT_core_nth) tmp196 := lang.Apply(tmp195, []any{v191, int64(1), nil}) var v197 any = tmp196 _ = v197 @@ -24587,16 +25143,16 @@ func LoadNS() { var v199 any = v190 _ = v199 var tmp200 any - tmp201 := checkDerefVar(glojure_DOT_core__EQ_) - tmp202 := lang.Apply(tmp201, []any{v194, lang.NewKeyword("let")}) + tmp201 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp202 := lang.Apply(tmp201, []any{v194, kw_let}) if lang.IsTruthy(tmp202) { - tmp203 := checkDerefVar(glojure_DOT_core_seq) - tmp204 := checkDerefVar(glojure_DOT_core_concat) - tmp205 := checkDerefVar(glojure_DOT_core_list) - tmp206 := lang.Apply(tmp205, []any{lang.NewSymbol("glojure.core/let")}) - tmp207 := checkDerefVar(glojure_DOT_core_list) + tmp203 := checkDerefVar(var_glojure_DOT_core_seq) + tmp204 := checkDerefVar(var_glojure_DOT_core_concat) + tmp205 := checkDerefVar(var_glojure_DOT_core_list) + tmp206 := lang.Apply(tmp205, []any{sym_glojure_DOT_core_SLASH_let}) + tmp207 := checkDerefVar(var_glojure_DOT_core_list) tmp208 := lang.Apply(tmp207, []any{v197}) - tmp209 := checkDerefVar(glojure_DOT_core_list) + tmp209 := checkDerefVar(var_glojure_DOT_core_list) tmp210 := lang.Apply(v178, []any{v199}) tmp211 := lang.Apply(tmp209, []any{tmp210}) tmp212 := lang.Apply(tmp204, []any{tmp206, tmp208, tmp211}) @@ -24604,16 +25160,16 @@ func LoadNS() { tmp200 = tmp213 } else { var tmp214 any - tmp215 := checkDerefVar(glojure_DOT_core__EQ_) - tmp216 := lang.Apply(tmp215, []any{v194, lang.NewKeyword("while")}) + tmp215 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp216 := lang.Apply(tmp215, []any{v194, kw_while}) if lang.IsTruthy(tmp216) { - tmp217 := checkDerefVar(glojure_DOT_core_seq) - tmp218 := checkDerefVar(glojure_DOT_core_concat) - tmp219 := checkDerefVar(glojure_DOT_core_list) - tmp220 := lang.Apply(tmp219, []any{lang.NewSymbol("glojure.core/when")}) - tmp221 := checkDerefVar(glojure_DOT_core_list) + tmp217 := checkDerefVar(var_glojure_DOT_core_seq) + tmp218 := checkDerefVar(var_glojure_DOT_core_concat) + tmp219 := checkDerefVar(var_glojure_DOT_core_list) + tmp220 := lang.Apply(tmp219, []any{sym_glojure_DOT_core_SLASH_when}) + tmp221 := checkDerefVar(var_glojure_DOT_core_list) tmp222 := lang.Apply(tmp221, []any{v197}) - tmp223 := checkDerefVar(glojure_DOT_core_list) + tmp223 := checkDerefVar(var_glojure_DOT_core_list) tmp224 := lang.Apply(v178, []any{v199}) tmp225 := lang.Apply(tmp223, []any{tmp224}) tmp226 := lang.Apply(tmp218, []any{tmp220, tmp222, tmp225}) @@ -24621,29 +25177,29 @@ func LoadNS() { tmp214 = tmp227 } else { var tmp228 any - tmp229 := checkDerefVar(glojure_DOT_core__EQ_) - tmp230 := lang.Apply(tmp229, []any{v194, lang.NewKeyword("when")}) + tmp229 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp230 := lang.Apply(tmp229, []any{v194, kw_when}) if lang.IsTruthy(tmp230) { - tmp231 := checkDerefVar(glojure_DOT_core_seq) - tmp232 := checkDerefVar(glojure_DOT_core_concat) - tmp233 := checkDerefVar(glojure_DOT_core_list) - tmp234 := lang.Apply(tmp233, []any{lang.NewSymbol("if")}) - tmp235 := checkDerefVar(glojure_DOT_core_list) + tmp231 := checkDerefVar(var_glojure_DOT_core_seq) + tmp232 := checkDerefVar(var_glojure_DOT_core_concat) + tmp233 := checkDerefVar(var_glojure_DOT_core_list) + tmp234 := lang.Apply(tmp233, []any{sym_if}) + tmp235 := checkDerefVar(var_glojure_DOT_core_list) tmp236 := lang.Apply(tmp235, []any{v197}) - tmp237 := checkDerefVar(glojure_DOT_core_list) + tmp237 := checkDerefVar(var_glojure_DOT_core_list) tmp238 := lang.Apply(v178, []any{v199}) tmp239 := lang.Apply(tmp237, []any{tmp238}) - tmp240 := checkDerefVar(glojure_DOT_core_list) - tmp241 := checkDerefVar(glojure_DOT_core_seq) - tmp242 := checkDerefVar(glojure_DOT_core_concat) - tmp243 := checkDerefVar(glojure_DOT_core_list) - tmp244 := lang.Apply(tmp243, []any{lang.NewSymbol("recur")}) - tmp245 := checkDerefVar(glojure_DOT_core_list) - tmp246 := checkDerefVar(glojure_DOT_core_seq) - tmp247 := checkDerefVar(glojure_DOT_core_concat) - tmp248 := checkDerefVar(glojure_DOT_core_list) - tmp249 := lang.Apply(tmp248, []any{lang.NewSymbol("glojure.core/unchecked-inc")}) - tmp250 := checkDerefVar(glojure_DOT_core_list) + tmp240 := checkDerefVar(var_glojure_DOT_core_list) + tmp241 := checkDerefVar(var_glojure_DOT_core_seq) + tmp242 := checkDerefVar(var_glojure_DOT_core_concat) + tmp243 := checkDerefVar(var_glojure_DOT_core_list) + tmp244 := lang.Apply(tmp243, []any{sym_recur}) + tmp245 := checkDerefVar(var_glojure_DOT_core_list) + tmp246 := checkDerefVar(var_glojure_DOT_core_seq) + tmp247 := checkDerefVar(var_glojure_DOT_core_concat) + tmp248 := checkDerefVar(var_glojure_DOT_core_list) + tmp249 := lang.Apply(tmp248, []any{sym_glojure_DOT_core_SLASH_unchecked_DASH_inc}) + tmp250 := checkDerefVar(var_glojure_DOT_core_list) tmp251 := lang.Apply(tmp250, []any{v173}) tmp252 := lang.Apply(tmp247, []any{tmp249, tmp251}) tmp253 := lang.Apply(tmp246, []any{tmp252}) @@ -24656,41 +25212,41 @@ func LoadNS() { tmp228 = tmp259 } else { var tmp260 any - tmp261 := checkDerefVar(glojure_DOT_core_keyword_QMARK_) + tmp261 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) tmp262 := lang.Apply(tmp261, []any{v194}) if lang.IsTruthy(tmp262) { tmp263 := lang.Apply(v41, []any{"Invalid 'for' keyword ", v194}) tmp260 = tmp263 } else { var tmp264 any - if lang.IsTruthy(lang.NewKeyword("else")) { - tmp265 := checkDerefVar(glojure_DOT_core_seq) - tmp266 := checkDerefVar(glojure_DOT_core_concat) - tmp267 := checkDerefVar(glojure_DOT_core_list) - tmp268 := lang.Apply(tmp267, []any{lang.NewSymbol("do")}) - tmp269 := checkDerefVar(glojure_DOT_core_list) - tmp270 := checkDerefVar(glojure_DOT_core_seq) - tmp271 := checkDerefVar(glojure_DOT_core_concat) - tmp272 := checkDerefVar(glojure_DOT_core_list) - tmp273 := lang.Apply(tmp272, []any{lang.NewSymbol("glojure.core/chunk-append")}) - tmp274 := checkDerefVar(glojure_DOT_core_list) + if lang.IsTruthy(kw_else) { + tmp265 := checkDerefVar(var_glojure_DOT_core_seq) + tmp266 := checkDerefVar(var_glojure_DOT_core_concat) + tmp267 := checkDerefVar(var_glojure_DOT_core_list) + tmp268 := lang.Apply(tmp267, []any{sym_do}) + tmp269 := checkDerefVar(var_glojure_DOT_core_list) + tmp270 := checkDerefVar(var_glojure_DOT_core_seq) + tmp271 := checkDerefVar(var_glojure_DOT_core_concat) + tmp272 := checkDerefVar(var_glojure_DOT_core_list) + tmp273 := lang.Apply(tmp272, []any{sym_glojure_DOT_core_SLASH_chunk_DASH_append}) + tmp274 := checkDerefVar(var_glojure_DOT_core_list) tmp275 := lang.Apply(tmp274, []any{v176}) - tmp276 := checkDerefVar(glojure_DOT_core_list) + tmp276 := checkDerefVar(var_glojure_DOT_core_list) tmp277 := lang.Apply(tmp276, []any{v6}) tmp278 := lang.Apply(tmp271, []any{tmp273, tmp275, tmp277}) tmp279 := lang.Apply(tmp270, []any{tmp278}) tmp280 := lang.Apply(tmp269, []any{tmp279}) - tmp281 := checkDerefVar(glojure_DOT_core_list) - tmp282 := checkDerefVar(glojure_DOT_core_seq) - tmp283 := checkDerefVar(glojure_DOT_core_concat) - tmp284 := checkDerefVar(glojure_DOT_core_list) - tmp285 := lang.Apply(tmp284, []any{lang.NewSymbol("recur")}) - tmp286 := checkDerefVar(glojure_DOT_core_list) - tmp287 := checkDerefVar(glojure_DOT_core_seq) - tmp288 := checkDerefVar(glojure_DOT_core_concat) - tmp289 := checkDerefVar(glojure_DOT_core_list) - tmp290 := lang.Apply(tmp289, []any{lang.NewSymbol("glojure.core/unchecked-inc")}) - tmp291 := checkDerefVar(glojure_DOT_core_list) + tmp281 := checkDerefVar(var_glojure_DOT_core_list) + tmp282 := checkDerefVar(var_glojure_DOT_core_seq) + tmp283 := checkDerefVar(var_glojure_DOT_core_concat) + tmp284 := checkDerefVar(var_glojure_DOT_core_list) + tmp285 := lang.Apply(tmp284, []any{sym_recur}) + tmp286 := checkDerefVar(var_glojure_DOT_core_list) + tmp287 := checkDerefVar(var_glojure_DOT_core_seq) + tmp288 := checkDerefVar(var_glojure_DOT_core_concat) + tmp289 := checkDerefVar(var_glojure_DOT_core_list) + tmp290 := lang.Apply(tmp289, []any{sym_glojure_DOT_core_SLASH_unchecked_DASH_inc}) + tmp291 := checkDerefVar(var_glojure_DOT_core_list) tmp292 := lang.Apply(tmp291, []any{v173}) tmp293 := lang.Apply(tmp288, []any{tmp290, tmp292}) tmp294 := lang.Apply(tmp287, []any{tmp293}) @@ -24718,71 +25274,71 @@ func LoadNS() { v178 = tmp177 _ = v178 } - tmp178 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4698), lang.NewKeyword("column"), int(39), lang.NewKeyword("end-line"), int(4710), lang.NewKeyword("end-column"), int(79)) + tmp178 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4698), kw_column, int(39), kw_end_DASH_line, int(4710), kw_end_DASH_column, int(79)) tmp179, err := lang.WithMeta(tmp177, tmp178.(lang.IPersistentMap)) if err != nil { panic(err) } var v180 any = tmp179 _ = v180 - tmp181 := checkDerefVar(glojure_DOT_core_seq) - tmp182 := checkDerefVar(glojure_DOT_core_concat) - tmp183 := checkDerefVar(glojure_DOT_core_list) - tmp184 := lang.Apply(tmp183, []any{lang.NewSymbol("glojure.core/fn")}) - tmp185 := checkDerefVar(glojure_DOT_core_list) + tmp181 := checkDerefVar(var_glojure_DOT_core_seq) + tmp182 := checkDerefVar(var_glojure_DOT_core_concat) + tmp183 := checkDerefVar(var_glojure_DOT_core_list) + tmp184 := lang.Apply(tmp183, []any{sym_glojure_DOT_core_SLASH_fn}) + tmp185 := checkDerefVar(var_glojure_DOT_core_list) tmp186 := lang.Apply(tmp185, []any{v89}) - tmp187 := checkDerefVar(glojure_DOT_core_list) - tmp188 := checkDerefVar(glojure_DOT_core_apply) - tmp189 := checkDerefVar(glojure_DOT_core_vector) - tmp190 := checkDerefVar(glojure_DOT_core_seq) - tmp191 := checkDerefVar(glojure_DOT_core_concat) - tmp192 := checkDerefVar(glojure_DOT_core_list) + tmp187 := checkDerefVar(var_glojure_DOT_core_list) + tmp188 := checkDerefVar(var_glojure_DOT_core_apply) + tmp189 := checkDerefVar(var_glojure_DOT_core_vector) + tmp190 := checkDerefVar(var_glojure_DOT_core_seq) + tmp191 := checkDerefVar(var_glojure_DOT_core_concat) + tmp192 := checkDerefVar(var_glojure_DOT_core_list) tmp193 := lang.Apply(tmp192, []any{v92}) tmp194 := lang.Apply(tmp191, []any{tmp193}) tmp195 := lang.Apply(tmp190, []any{tmp194}) tmp196 := lang.Apply(tmp188, []any{tmp189, tmp195}) tmp197 := lang.Apply(tmp187, []any{tmp196}) - tmp198 := checkDerefVar(glojure_DOT_core_list) - tmp199 := checkDerefVar(glojure_DOT_core_seq) - tmp200 := checkDerefVar(glojure_DOT_core_concat) - tmp201 := checkDerefVar(glojure_DOT_core_list) - tmp202 := lang.Apply(tmp201, []any{lang.NewSymbol("glojure.core/lazy-seq")}) - tmp203 := checkDerefVar(glojure_DOT_core_list) - tmp204 := checkDerefVar(glojure_DOT_core_seq) - tmp205 := checkDerefVar(glojure_DOT_core_concat) - tmp206 := checkDerefVar(glojure_DOT_core_list) - tmp207 := lang.Apply(tmp206, []any{lang.NewSymbol("glojure.core/loop")}) - tmp208 := checkDerefVar(glojure_DOT_core_list) - tmp209 := checkDerefVar(glojure_DOT_core_apply) - tmp210 := checkDerefVar(glojure_DOT_core_vector) - tmp211 := checkDerefVar(glojure_DOT_core_seq) - tmp212 := checkDerefVar(glojure_DOT_core_concat) - tmp213 := checkDerefVar(glojure_DOT_core_list) + tmp198 := checkDerefVar(var_glojure_DOT_core_list) + tmp199 := checkDerefVar(var_glojure_DOT_core_seq) + tmp200 := checkDerefVar(var_glojure_DOT_core_concat) + tmp201 := checkDerefVar(var_glojure_DOT_core_list) + tmp202 := lang.Apply(tmp201, []any{sym_glojure_DOT_core_SLASH_lazy_DASH_seq}) + tmp203 := checkDerefVar(var_glojure_DOT_core_list) + tmp204 := checkDerefVar(var_glojure_DOT_core_seq) + tmp205 := checkDerefVar(var_glojure_DOT_core_concat) + tmp206 := checkDerefVar(var_glojure_DOT_core_list) + tmp207 := lang.Apply(tmp206, []any{sym_glojure_DOT_core_SLASH_loop}) + tmp208 := checkDerefVar(var_glojure_DOT_core_list) + tmp209 := checkDerefVar(var_glojure_DOT_core_apply) + tmp210 := checkDerefVar(var_glojure_DOT_core_vector) + tmp211 := checkDerefVar(var_glojure_DOT_core_seq) + tmp212 := checkDerefVar(var_glojure_DOT_core_concat) + tmp213 := checkDerefVar(var_glojure_DOT_core_list) tmp214 := lang.Apply(tmp213, []any{v92}) - tmp215 := checkDerefVar(glojure_DOT_core_list) + tmp215 := checkDerefVar(var_glojure_DOT_core_list) tmp216 := lang.Apply(tmp215, []any{v92}) tmp217 := lang.Apply(tmp212, []any{tmp214, tmp216}) tmp218 := lang.Apply(tmp211, []any{tmp217}) tmp219 := lang.Apply(tmp209, []any{tmp210, tmp218}) tmp220 := lang.Apply(tmp208, []any{tmp219}) - tmp221 := checkDerefVar(glojure_DOT_core_list) - tmp222 := checkDerefVar(glojure_DOT_core_seq) - tmp223 := checkDerefVar(glojure_DOT_core_concat) - tmp224 := checkDerefVar(glojure_DOT_core_list) - tmp225 := lang.Apply(tmp224, []any{lang.NewSymbol("glojure.core/when-let")}) - tmp226 := checkDerefVar(glojure_DOT_core_list) - tmp227 := checkDerefVar(glojure_DOT_core_apply) - tmp228 := checkDerefVar(glojure_DOT_core_vector) - tmp229 := checkDerefVar(glojure_DOT_core_seq) - tmp230 := checkDerefVar(glojure_DOT_core_concat) - tmp231 := checkDerefVar(glojure_DOT_core_list) + tmp221 := checkDerefVar(var_glojure_DOT_core_list) + tmp222 := checkDerefVar(var_glojure_DOT_core_seq) + tmp223 := checkDerefVar(var_glojure_DOT_core_concat) + tmp224 := checkDerefVar(var_glojure_DOT_core_list) + tmp225 := lang.Apply(tmp224, []any{sym_glojure_DOT_core_SLASH_when_DASH_let}) + tmp226 := checkDerefVar(var_glojure_DOT_core_list) + tmp227 := checkDerefVar(var_glojure_DOT_core_apply) + tmp228 := checkDerefVar(var_glojure_DOT_core_vector) + tmp229 := checkDerefVar(var_glojure_DOT_core_seq) + tmp230 := checkDerefVar(var_glojure_DOT_core_concat) + tmp231 := checkDerefVar(var_glojure_DOT_core_list) tmp232 := lang.Apply(tmp231, []any{v92}) - tmp233 := checkDerefVar(glojure_DOT_core_list) - tmp234 := checkDerefVar(glojure_DOT_core_seq) - tmp235 := checkDerefVar(glojure_DOT_core_concat) - tmp236 := checkDerefVar(glojure_DOT_core_list) - tmp237 := lang.Apply(tmp236, []any{lang.NewSymbol("glojure.core/seq")}) - tmp238 := checkDerefVar(glojure_DOT_core_list) + tmp233 := checkDerefVar(var_glojure_DOT_core_list) + tmp234 := checkDerefVar(var_glojure_DOT_core_seq) + tmp235 := checkDerefVar(var_glojure_DOT_core_concat) + tmp236 := checkDerefVar(var_glojure_DOT_core_list) + tmp237 := lang.Apply(tmp236, []any{sym_glojure_DOT_core_SLASH_seq}) + tmp238 := checkDerefVar(var_glojure_DOT_core_list) tmp239 := lang.Apply(tmp238, []any{v92}) tmp240 := lang.Apply(tmp235, []any{tmp237, tmp239}) tmp241 := lang.Apply(tmp234, []any{tmp240}) @@ -24791,72 +25347,72 @@ func LoadNS() { tmp244 := lang.Apply(tmp229, []any{tmp243}) tmp245 := lang.Apply(tmp227, []any{tmp228, tmp244}) tmp246 := lang.Apply(tmp226, []any{tmp245}) - tmp247 := checkDerefVar(glojure_DOT_core_list) - tmp248 := checkDerefVar(glojure_DOT_core_seq) - tmp249 := checkDerefVar(glojure_DOT_core_concat) - tmp250 := checkDerefVar(glojure_DOT_core_list) - tmp251 := lang.Apply(tmp250, []any{lang.NewSymbol("if")}) - tmp252 := checkDerefVar(glojure_DOT_core_list) - tmp253 := checkDerefVar(glojure_DOT_core_seq) - tmp254 := checkDerefVar(glojure_DOT_core_concat) - tmp255 := checkDerefVar(glojure_DOT_core_list) - tmp256 := lang.Apply(tmp255, []any{lang.NewSymbol("glojure.core/chunked-seq?")}) - tmp257 := checkDerefVar(glojure_DOT_core_list) + tmp247 := checkDerefVar(var_glojure_DOT_core_list) + tmp248 := checkDerefVar(var_glojure_DOT_core_seq) + tmp249 := checkDerefVar(var_glojure_DOT_core_concat) + tmp250 := checkDerefVar(var_glojure_DOT_core_list) + tmp251 := lang.Apply(tmp250, []any{sym_if}) + tmp252 := checkDerefVar(var_glojure_DOT_core_list) + tmp253 := checkDerefVar(var_glojure_DOT_core_seq) + tmp254 := checkDerefVar(var_glojure_DOT_core_concat) + tmp255 := checkDerefVar(var_glojure_DOT_core_list) + tmp256 := lang.Apply(tmp255, []any{sym_glojure_DOT_core_SLASH_chunked_DASH_seq_QMARK_}) + tmp257 := checkDerefVar(var_glojure_DOT_core_list) tmp258 := lang.Apply(tmp257, []any{v92}) tmp259 := lang.Apply(tmp254, []any{tmp256, tmp258}) tmp260 := lang.Apply(tmp253, []any{tmp259}) tmp261 := lang.Apply(tmp252, []any{tmp260}) - tmp262 := checkDerefVar(glojure_DOT_core_list) - tmp263 := checkDerefVar(glojure_DOT_core_seq) - tmp264 := checkDerefVar(glojure_DOT_core_concat) - tmp265 := checkDerefVar(glojure_DOT_core_list) - tmp266 := lang.Apply(tmp265, []any{lang.NewSymbol("glojure.core/let")}) - tmp267 := checkDerefVar(glojure_DOT_core_list) - tmp268 := checkDerefVar(glojure_DOT_core_apply) - tmp269 := checkDerefVar(glojure_DOT_core_vector) - tmp270 := checkDerefVar(glojure_DOT_core_seq) - tmp271 := checkDerefVar(glojure_DOT_core_concat) - tmp272 := checkDerefVar(glojure_DOT_core_list) - tmp273 := lang.Apply(tmp272, []any{lang.NewSymbol("c__0__auto__")}) - tmp274 := checkDerefVar(glojure_DOT_core_list) - tmp275 := checkDerefVar(glojure_DOT_core_seq) - tmp276 := checkDerefVar(glojure_DOT_core_concat) - tmp277 := checkDerefVar(glojure_DOT_core_list) - tmp278 := lang.Apply(tmp277, []any{lang.NewSymbol("glojure.core/chunk-first")}) - tmp279 := checkDerefVar(glojure_DOT_core_list) + tmp262 := checkDerefVar(var_glojure_DOT_core_list) + tmp263 := checkDerefVar(var_glojure_DOT_core_seq) + tmp264 := checkDerefVar(var_glojure_DOT_core_concat) + tmp265 := checkDerefVar(var_glojure_DOT_core_list) + tmp266 := lang.Apply(tmp265, []any{sym_glojure_DOT_core_SLASH_let}) + tmp267 := checkDerefVar(var_glojure_DOT_core_list) + tmp268 := checkDerefVar(var_glojure_DOT_core_apply) + tmp269 := checkDerefVar(var_glojure_DOT_core_vector) + tmp270 := checkDerefVar(var_glojure_DOT_core_seq) + tmp271 := checkDerefVar(var_glojure_DOT_core_concat) + tmp272 := checkDerefVar(var_glojure_DOT_core_list) + tmp273 := lang.Apply(tmp272, []any{sym_c__0__auto__}) + tmp274 := checkDerefVar(var_glojure_DOT_core_list) + tmp275 := checkDerefVar(var_glojure_DOT_core_seq) + tmp276 := checkDerefVar(var_glojure_DOT_core_concat) + tmp277 := checkDerefVar(var_glojure_DOT_core_list) + tmp278 := lang.Apply(tmp277, []any{sym_glojure_DOT_core_SLASH_chunk_DASH_first}) + tmp279 := checkDerefVar(var_glojure_DOT_core_list) tmp280 := lang.Apply(tmp279, []any{v92}) tmp281 := lang.Apply(tmp276, []any{tmp278, tmp280}) tmp282 := lang.Apply(tmp275, []any{tmp281}) tmp283 := lang.Apply(tmp274, []any{tmp282}) - tmp284 := checkDerefVar(glojure_DOT_core_list) - tmp285 := lang.Apply(tmp284, []any{lang.NewSymbol("size__1__auto__")}) - tmp286 := checkDerefVar(glojure_DOT_core_list) - tmp287 := checkDerefVar(glojure_DOT_core_seq) - tmp288 := checkDerefVar(glojure_DOT_core_concat) - tmp289 := checkDerefVar(glojure_DOT_core_list) - tmp290 := lang.Apply(tmp289, []any{lang.NewSymbol("glojure.core/int")}) - tmp291 := checkDerefVar(glojure_DOT_core_list) - tmp292 := checkDerefVar(glojure_DOT_core_seq) - tmp293 := checkDerefVar(glojure_DOT_core_concat) - tmp294 := checkDerefVar(glojure_DOT_core_list) - tmp295 := lang.Apply(tmp294, []any{lang.NewSymbol("glojure.core/count")}) - tmp296 := checkDerefVar(glojure_DOT_core_list) - tmp297 := lang.Apply(tmp296, []any{lang.NewSymbol("c__0__auto__")}) + tmp284 := checkDerefVar(var_glojure_DOT_core_list) + tmp285 := lang.Apply(tmp284, []any{sym_size__1__auto__}) + tmp286 := checkDerefVar(var_glojure_DOT_core_list) + tmp287 := checkDerefVar(var_glojure_DOT_core_seq) + tmp288 := checkDerefVar(var_glojure_DOT_core_concat) + tmp289 := checkDerefVar(var_glojure_DOT_core_list) + tmp290 := lang.Apply(tmp289, []any{sym_glojure_DOT_core_SLASH_int}) + tmp291 := checkDerefVar(var_glojure_DOT_core_list) + tmp292 := checkDerefVar(var_glojure_DOT_core_seq) + tmp293 := checkDerefVar(var_glojure_DOT_core_concat) + tmp294 := checkDerefVar(var_glojure_DOT_core_list) + tmp295 := lang.Apply(tmp294, []any{sym_glojure_DOT_core_SLASH_count}) + tmp296 := checkDerefVar(var_glojure_DOT_core_list) + tmp297 := lang.Apply(tmp296, []any{sym_c__0__auto__}) tmp298 := lang.Apply(tmp293, []any{tmp295, tmp297}) tmp299 := lang.Apply(tmp292, []any{tmp298}) tmp300 := lang.Apply(tmp291, []any{tmp299}) tmp301 := lang.Apply(tmp288, []any{tmp290, tmp300}) tmp302 := lang.Apply(tmp287, []any{tmp301}) tmp303 := lang.Apply(tmp286, []any{tmp302}) - tmp304 := checkDerefVar(glojure_DOT_core_list) + tmp304 := checkDerefVar(var_glojure_DOT_core_list) tmp305 := lang.Apply(tmp304, []any{v176}) - tmp306 := checkDerefVar(glojure_DOT_core_list) - tmp307 := checkDerefVar(glojure_DOT_core_seq) - tmp308 := checkDerefVar(glojure_DOT_core_concat) - tmp309 := checkDerefVar(glojure_DOT_core_list) - tmp310 := lang.Apply(tmp309, []any{lang.NewSymbol("glojure.core/chunk-buffer")}) - tmp311 := checkDerefVar(glojure_DOT_core_list) - tmp312 := lang.Apply(tmp311, []any{lang.NewSymbol("size__1__auto__")}) + tmp306 := checkDerefVar(var_glojure_DOT_core_list) + tmp307 := checkDerefVar(var_glojure_DOT_core_seq) + tmp308 := checkDerefVar(var_glojure_DOT_core_concat) + tmp309 := checkDerefVar(var_glojure_DOT_core_list) + tmp310 := lang.Apply(tmp309, []any{sym_glojure_DOT_core_SLASH_chunk_DASH_buffer}) + tmp311 := checkDerefVar(var_glojure_DOT_core_list) + tmp312 := lang.Apply(tmp311, []any{sym_size__1__auto__}) tmp313 := lang.Apply(tmp308, []any{tmp310, tmp312}) tmp314 := lang.Apply(tmp307, []any{tmp313}) tmp315 := lang.Apply(tmp306, []any{tmp314}) @@ -24864,29 +25420,29 @@ func LoadNS() { tmp317 := lang.Apply(tmp270, []any{tmp316}) tmp318 := lang.Apply(tmp268, []any{tmp269, tmp317}) tmp319 := lang.Apply(tmp267, []any{tmp318}) - tmp320 := checkDerefVar(glojure_DOT_core_list) - tmp321 := checkDerefVar(glojure_DOT_core_seq) - tmp322 := checkDerefVar(glojure_DOT_core_concat) - tmp323 := checkDerefVar(glojure_DOT_core_list) - tmp324 := lang.Apply(tmp323, []any{lang.NewSymbol("if")}) - tmp325 := checkDerefVar(glojure_DOT_core_list) - tmp326 := checkDerefVar(glojure_DOT_core_seq) - tmp327 := checkDerefVar(glojure_DOT_core_concat) - tmp328 := checkDerefVar(glojure_DOT_core_list) - tmp329 := lang.Apply(tmp328, []any{lang.NewSymbol("glojure.core/loop")}) - tmp330 := checkDerefVar(glojure_DOT_core_list) - tmp331 := checkDerefVar(glojure_DOT_core_apply) - tmp332 := checkDerefVar(glojure_DOT_core_vector) - tmp333 := checkDerefVar(glojure_DOT_core_seq) - tmp334 := checkDerefVar(glojure_DOT_core_concat) - tmp335 := checkDerefVar(glojure_DOT_core_list) + tmp320 := checkDerefVar(var_glojure_DOT_core_list) + tmp321 := checkDerefVar(var_glojure_DOT_core_seq) + tmp322 := checkDerefVar(var_glojure_DOT_core_concat) + tmp323 := checkDerefVar(var_glojure_DOT_core_list) + tmp324 := lang.Apply(tmp323, []any{sym_if}) + tmp325 := checkDerefVar(var_glojure_DOT_core_list) + tmp326 := checkDerefVar(var_glojure_DOT_core_seq) + tmp327 := checkDerefVar(var_glojure_DOT_core_concat) + tmp328 := checkDerefVar(var_glojure_DOT_core_list) + tmp329 := lang.Apply(tmp328, []any{sym_glojure_DOT_core_SLASH_loop}) + tmp330 := checkDerefVar(var_glojure_DOT_core_list) + tmp331 := checkDerefVar(var_glojure_DOT_core_apply) + tmp332 := checkDerefVar(var_glojure_DOT_core_vector) + tmp333 := checkDerefVar(var_glojure_DOT_core_seq) + tmp334 := checkDerefVar(var_glojure_DOT_core_concat) + tmp335 := checkDerefVar(var_glojure_DOT_core_list) tmp336 := lang.Apply(tmp335, []any{v173}) - tmp337 := checkDerefVar(glojure_DOT_core_list) - tmp338 := checkDerefVar(glojure_DOT_core_seq) - tmp339 := checkDerefVar(glojure_DOT_core_concat) - tmp340 := checkDerefVar(glojure_DOT_core_list) - tmp341 := lang.Apply(tmp340, []any{lang.NewSymbol("glojure.core/int")}) - tmp342 := checkDerefVar(glojure_DOT_core_list) + tmp337 := checkDerefVar(var_glojure_DOT_core_list) + tmp338 := checkDerefVar(var_glojure_DOT_core_seq) + tmp339 := checkDerefVar(var_glojure_DOT_core_concat) + tmp340 := checkDerefVar(var_glojure_DOT_core_list) + tmp341 := lang.Apply(tmp340, []any{sym_glojure_DOT_core_SLASH_int}) + tmp342 := checkDerefVar(var_glojure_DOT_core_list) tmp343 := lang.Apply(tmp342, []any{int64(0)}) tmp344 := lang.Apply(tmp339, []any{tmp341, tmp343}) tmp345 := lang.Apply(tmp338, []any{tmp344}) @@ -24895,43 +25451,43 @@ func LoadNS() { tmp348 := lang.Apply(tmp333, []any{tmp347}) tmp349 := lang.Apply(tmp331, []any{tmp332, tmp348}) tmp350 := lang.Apply(tmp330, []any{tmp349}) - tmp351 := checkDerefVar(glojure_DOT_core_list) - tmp352 := checkDerefVar(glojure_DOT_core_seq) - tmp353 := checkDerefVar(glojure_DOT_core_concat) - tmp354 := checkDerefVar(glojure_DOT_core_list) - tmp355 := lang.Apply(tmp354, []any{lang.NewSymbol("if")}) - tmp356 := checkDerefVar(glojure_DOT_core_list) - tmp357 := checkDerefVar(glojure_DOT_core_seq) - tmp358 := checkDerefVar(glojure_DOT_core_concat) - tmp359 := checkDerefVar(glojure_DOT_core_list) - tmp360 := lang.Apply(tmp359, []any{lang.NewSymbol("glojure.core/<")}) - tmp361 := checkDerefVar(glojure_DOT_core_list) + tmp351 := checkDerefVar(var_glojure_DOT_core_list) + tmp352 := checkDerefVar(var_glojure_DOT_core_seq) + tmp353 := checkDerefVar(var_glojure_DOT_core_concat) + tmp354 := checkDerefVar(var_glojure_DOT_core_list) + tmp355 := lang.Apply(tmp354, []any{sym_if}) + tmp356 := checkDerefVar(var_glojure_DOT_core_list) + tmp357 := checkDerefVar(var_glojure_DOT_core_seq) + tmp358 := checkDerefVar(var_glojure_DOT_core_concat) + tmp359 := checkDerefVar(var_glojure_DOT_core_list) + tmp360 := lang.Apply(tmp359, []any{sym_glojure_DOT_core_SLASH__LT_}) + tmp361 := checkDerefVar(var_glojure_DOT_core_list) tmp362 := lang.Apply(tmp361, []any{v173}) - tmp363 := checkDerefVar(glojure_DOT_core_list) - tmp364 := lang.Apply(tmp363, []any{lang.NewSymbol("size__1__auto__")}) + tmp363 := checkDerefVar(var_glojure_DOT_core_list) + tmp364 := lang.Apply(tmp363, []any{sym_size__1__auto__}) tmp365 := lang.Apply(tmp358, []any{tmp360, tmp362, tmp364}) tmp366 := lang.Apply(tmp357, []any{tmp365}) tmp367 := lang.Apply(tmp356, []any{tmp366}) - tmp368 := checkDerefVar(glojure_DOT_core_list) - tmp369 := checkDerefVar(glojure_DOT_core_seq) - tmp370 := checkDerefVar(glojure_DOT_core_concat) - tmp371 := checkDerefVar(glojure_DOT_core_list) - tmp372 := lang.Apply(tmp371, []any{lang.NewSymbol("glojure.core/let")}) - tmp373 := checkDerefVar(glojure_DOT_core_list) - tmp374 := checkDerefVar(glojure_DOT_core_apply) - tmp375 := checkDerefVar(glojure_DOT_core_vector) - tmp376 := checkDerefVar(glojure_DOT_core_seq) - tmp377 := checkDerefVar(glojure_DOT_core_concat) - tmp378 := checkDerefVar(glojure_DOT_core_list) + tmp368 := checkDerefVar(var_glojure_DOT_core_list) + tmp369 := checkDerefVar(var_glojure_DOT_core_seq) + tmp370 := checkDerefVar(var_glojure_DOT_core_concat) + tmp371 := checkDerefVar(var_glojure_DOT_core_list) + tmp372 := lang.Apply(tmp371, []any{sym_glojure_DOT_core_SLASH_let}) + tmp373 := checkDerefVar(var_glojure_DOT_core_list) + tmp374 := checkDerefVar(var_glojure_DOT_core_apply) + tmp375 := checkDerefVar(var_glojure_DOT_core_vector) + tmp376 := checkDerefVar(var_glojure_DOT_core_seq) + tmp377 := checkDerefVar(var_glojure_DOT_core_concat) + tmp378 := checkDerefVar(var_glojure_DOT_core_list) tmp379 := lang.Apply(tmp378, []any{v66}) - tmp380 := checkDerefVar(glojure_DOT_core_list) - tmp381 := checkDerefVar(glojure_DOT_core_seq) - tmp382 := checkDerefVar(glojure_DOT_core_concat) - tmp383 := checkDerefVar(glojure_DOT_core_list) - tmp384 := lang.Apply(tmp383, []any{lang.NewSymbol(".nth")}) - tmp385 := checkDerefVar(glojure_DOT_core_list) - tmp386 := lang.Apply(tmp385, []any{lang.NewSymbol("c__0__auto__")}) - tmp387 := checkDerefVar(glojure_DOT_core_list) + tmp380 := checkDerefVar(var_glojure_DOT_core_list) + tmp381 := checkDerefVar(var_glojure_DOT_core_seq) + tmp382 := checkDerefVar(var_glojure_DOT_core_concat) + tmp383 := checkDerefVar(var_glojure_DOT_core_list) + tmp384 := lang.Apply(tmp383, []any{sym__DOT_nth}) + tmp385 := checkDerefVar(var_glojure_DOT_core_list) + tmp386 := lang.Apply(tmp385, []any{sym_c__0__auto__}) + tmp387 := checkDerefVar(var_glojure_DOT_core_list) tmp388 := lang.Apply(tmp387, []any{v173}) tmp389 := lang.Apply(tmp382, []any{tmp384, tmp386, tmp388}) tmp390 := lang.Apply(tmp381, []any{tmp389}) @@ -24940,13 +25496,13 @@ func LoadNS() { tmp393 := lang.Apply(tmp376, []any{tmp392}) tmp394 := lang.Apply(tmp374, []any{tmp375, tmp393}) tmp395 := lang.Apply(tmp373, []any{tmp394}) - tmp396 := checkDerefVar(glojure_DOT_core_list) + tmp396 := checkDerefVar(var_glojure_DOT_core_list) tmp397 := lang.Apply(v180, []any{v74}) tmp398 := lang.Apply(tmp396, []any{tmp397}) tmp399 := lang.Apply(tmp370, []any{tmp372, tmp395, tmp398}) tmp400 := lang.Apply(tmp369, []any{tmp399}) tmp401 := lang.Apply(tmp368, []any{tmp400}) - tmp402 := checkDerefVar(glojure_DOT_core_list) + tmp402 := checkDerefVar(var_glojure_DOT_core_list) tmp403 := lang.Apply(tmp402, []any{true}) tmp404 := lang.Apply(tmp353, []any{tmp355, tmp367, tmp401, tmp403}) tmp405 := lang.Apply(tmp352, []any{tmp404}) @@ -24954,32 +25510,32 @@ func LoadNS() { tmp407 := lang.Apply(tmp327, []any{tmp329, tmp350, tmp406}) tmp408 := lang.Apply(tmp326, []any{tmp407}) tmp409 := lang.Apply(tmp325, []any{tmp408}) - tmp410 := checkDerefVar(glojure_DOT_core_list) - tmp411 := checkDerefVar(glojure_DOT_core_seq) - tmp412 := checkDerefVar(glojure_DOT_core_concat) - tmp413 := checkDerefVar(glojure_DOT_core_list) - tmp414 := lang.Apply(tmp413, []any{lang.NewSymbol("glojure.core/chunk-cons")}) - tmp415 := checkDerefVar(glojure_DOT_core_list) - tmp416 := checkDerefVar(glojure_DOT_core_seq) - tmp417 := checkDerefVar(glojure_DOT_core_concat) - tmp418 := checkDerefVar(glojure_DOT_core_list) - tmp419 := lang.Apply(tmp418, []any{lang.NewSymbol("glojure.core/chunk")}) - tmp420 := checkDerefVar(glojure_DOT_core_list) + tmp410 := checkDerefVar(var_glojure_DOT_core_list) + tmp411 := checkDerefVar(var_glojure_DOT_core_seq) + tmp412 := checkDerefVar(var_glojure_DOT_core_concat) + tmp413 := checkDerefVar(var_glojure_DOT_core_list) + tmp414 := lang.Apply(tmp413, []any{sym_glojure_DOT_core_SLASH_chunk_DASH_cons}) + tmp415 := checkDerefVar(var_glojure_DOT_core_list) + tmp416 := checkDerefVar(var_glojure_DOT_core_seq) + tmp417 := checkDerefVar(var_glojure_DOT_core_concat) + tmp418 := checkDerefVar(var_glojure_DOT_core_list) + tmp419 := lang.Apply(tmp418, []any{sym_glojure_DOT_core_SLASH_chunk}) + tmp420 := checkDerefVar(var_glojure_DOT_core_list) tmp421 := lang.Apply(tmp420, []any{v176}) tmp422 := lang.Apply(tmp417, []any{tmp419, tmp421}) tmp423 := lang.Apply(tmp416, []any{tmp422}) tmp424 := lang.Apply(tmp415, []any{tmp423}) - tmp425 := checkDerefVar(glojure_DOT_core_list) - tmp426 := checkDerefVar(glojure_DOT_core_seq) - tmp427 := checkDerefVar(glojure_DOT_core_concat) - tmp428 := checkDerefVar(glojure_DOT_core_list) + tmp425 := checkDerefVar(var_glojure_DOT_core_list) + tmp426 := checkDerefVar(var_glojure_DOT_core_seq) + tmp427 := checkDerefVar(var_glojure_DOT_core_concat) + tmp428 := checkDerefVar(var_glojure_DOT_core_list) tmp429 := lang.Apply(tmp428, []any{v89}) - tmp430 := checkDerefVar(glojure_DOT_core_list) - tmp431 := checkDerefVar(glojure_DOT_core_seq) - tmp432 := checkDerefVar(glojure_DOT_core_concat) - tmp433 := checkDerefVar(glojure_DOT_core_list) - tmp434 := lang.Apply(tmp433, []any{lang.NewSymbol("glojure.core/chunk-rest")}) - tmp435 := checkDerefVar(glojure_DOT_core_list) + tmp430 := checkDerefVar(var_glojure_DOT_core_list) + tmp431 := checkDerefVar(var_glojure_DOT_core_seq) + tmp432 := checkDerefVar(var_glojure_DOT_core_concat) + tmp433 := checkDerefVar(var_glojure_DOT_core_list) + tmp434 := lang.Apply(tmp433, []any{sym_glojure_DOT_core_SLASH_chunk_DASH_rest}) + tmp435 := checkDerefVar(var_glojure_DOT_core_list) tmp436 := lang.Apply(tmp435, []any{v92}) tmp437 := lang.Apply(tmp432, []any{tmp434, tmp436}) tmp438 := lang.Apply(tmp431, []any{tmp437}) @@ -24990,22 +25546,22 @@ func LoadNS() { tmp443 := lang.Apply(tmp412, []any{tmp414, tmp424, tmp442}) tmp444 := lang.Apply(tmp411, []any{tmp443}) tmp445 := lang.Apply(tmp410, []any{tmp444}) - tmp446 := checkDerefVar(glojure_DOT_core_list) - tmp447 := checkDerefVar(glojure_DOT_core_seq) - tmp448 := checkDerefVar(glojure_DOT_core_concat) - tmp449 := checkDerefVar(glojure_DOT_core_list) - tmp450 := lang.Apply(tmp449, []any{lang.NewSymbol("glojure.core/chunk-cons")}) - tmp451 := checkDerefVar(glojure_DOT_core_list) - tmp452 := checkDerefVar(glojure_DOT_core_seq) - tmp453 := checkDerefVar(glojure_DOT_core_concat) - tmp454 := checkDerefVar(glojure_DOT_core_list) - tmp455 := lang.Apply(tmp454, []any{lang.NewSymbol("glojure.core/chunk")}) - tmp456 := checkDerefVar(glojure_DOT_core_list) + tmp446 := checkDerefVar(var_glojure_DOT_core_list) + tmp447 := checkDerefVar(var_glojure_DOT_core_seq) + tmp448 := checkDerefVar(var_glojure_DOT_core_concat) + tmp449 := checkDerefVar(var_glojure_DOT_core_list) + tmp450 := lang.Apply(tmp449, []any{sym_glojure_DOT_core_SLASH_chunk_DASH_cons}) + tmp451 := checkDerefVar(var_glojure_DOT_core_list) + tmp452 := checkDerefVar(var_glojure_DOT_core_seq) + tmp453 := checkDerefVar(var_glojure_DOT_core_concat) + tmp454 := checkDerefVar(var_glojure_DOT_core_list) + tmp455 := lang.Apply(tmp454, []any{sym_glojure_DOT_core_SLASH_chunk}) + tmp456 := checkDerefVar(var_glojure_DOT_core_list) tmp457 := lang.Apply(tmp456, []any{v176}) tmp458 := lang.Apply(tmp453, []any{tmp455, tmp457}) tmp459 := lang.Apply(tmp452, []any{tmp458}) tmp460 := lang.Apply(tmp451, []any{tmp459}) - tmp461 := checkDerefVar(glojure_DOT_core_list) + tmp461 := checkDerefVar(var_glojure_DOT_core_list) tmp462 := lang.Apply(tmp461, []any{nil}) tmp463 := lang.Apply(tmp448, []any{tmp450, tmp460, tmp462}) tmp464 := lang.Apply(tmp447, []any{tmp463}) @@ -25016,24 +25572,24 @@ func LoadNS() { tmp469 := lang.Apply(tmp264, []any{tmp266, tmp319, tmp468}) tmp470 := lang.Apply(tmp263, []any{tmp469}) tmp471 := lang.Apply(tmp262, []any{tmp470}) - tmp472 := checkDerefVar(glojure_DOT_core_list) - tmp473 := checkDerefVar(glojure_DOT_core_seq) - tmp474 := checkDerefVar(glojure_DOT_core_concat) - tmp475 := checkDerefVar(glojure_DOT_core_list) - tmp476 := lang.Apply(tmp475, []any{lang.NewSymbol("glojure.core/let")}) - tmp477 := checkDerefVar(glojure_DOT_core_list) - tmp478 := checkDerefVar(glojure_DOT_core_apply) - tmp479 := checkDerefVar(glojure_DOT_core_vector) - tmp480 := checkDerefVar(glojure_DOT_core_seq) - tmp481 := checkDerefVar(glojure_DOT_core_concat) - tmp482 := checkDerefVar(glojure_DOT_core_list) + tmp472 := checkDerefVar(var_glojure_DOT_core_list) + tmp473 := checkDerefVar(var_glojure_DOT_core_seq) + tmp474 := checkDerefVar(var_glojure_DOT_core_concat) + tmp475 := checkDerefVar(var_glojure_DOT_core_list) + tmp476 := lang.Apply(tmp475, []any{sym_glojure_DOT_core_SLASH_let}) + tmp477 := checkDerefVar(var_glojure_DOT_core_list) + tmp478 := checkDerefVar(var_glojure_DOT_core_apply) + tmp479 := checkDerefVar(var_glojure_DOT_core_vector) + tmp480 := checkDerefVar(var_glojure_DOT_core_seq) + tmp481 := checkDerefVar(var_glojure_DOT_core_concat) + tmp482 := checkDerefVar(var_glojure_DOT_core_list) tmp483 := lang.Apply(tmp482, []any{v66}) - tmp484 := checkDerefVar(glojure_DOT_core_list) - tmp485 := checkDerefVar(glojure_DOT_core_seq) - tmp486 := checkDerefVar(glojure_DOT_core_concat) - tmp487 := checkDerefVar(glojure_DOT_core_list) - tmp488 := lang.Apply(tmp487, []any{lang.NewSymbol("glojure.core/first")}) - tmp489 := checkDerefVar(glojure_DOT_core_list) + tmp484 := checkDerefVar(var_glojure_DOT_core_list) + tmp485 := checkDerefVar(var_glojure_DOT_core_seq) + tmp486 := checkDerefVar(var_glojure_DOT_core_concat) + tmp487 := checkDerefVar(var_glojure_DOT_core_list) + tmp488 := lang.Apply(tmp487, []any{sym_glojure_DOT_core_SLASH_first}) + tmp489 := checkDerefVar(var_glojure_DOT_core_list) tmp490 := lang.Apply(tmp489, []any{v92}) tmp491 := lang.Apply(tmp486, []any{tmp488, tmp490}) tmp492 := lang.Apply(tmp485, []any{tmp491}) @@ -25042,7 +25598,7 @@ func LoadNS() { tmp495 := lang.Apply(tmp480, []any{tmp494}) tmp496 := lang.Apply(tmp478, []any{tmp479, tmp495}) tmp497 := lang.Apply(tmp477, []any{tmp496}) - tmp498 := checkDerefVar(glojure_DOT_core_list) + tmp498 := checkDerefVar(var_glojure_DOT_core_list) tmp499 := lang.Apply(v96, []any{v74}) tmp500 := lang.Apply(tmp498, []any{tmp499}) tmp501 := lang.Apply(tmp474, []any{tmp476, tmp497, tmp500}) @@ -25075,25 +25631,25 @@ func LoadNS() { v43 = tmp42 _ = v43 } - tmp43 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4668), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(4729), lang.NewKeyword("end-column"), int(68)) + tmp43 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4668), kw_column, int(19), kw_end_DASH_line, int(4729), kw_end_DASH_column, int(68)) tmp44, err := lang.WithMeta(tmp42, tmp43.(lang.IPersistentMap)) if err != nil { panic(err) } var v45 any = tmp44 _ = v45 - tmp46 := checkDerefVar(glojure_DOT_core_seq) - tmp47 := checkDerefVar(glojure_DOT_core_concat) - tmp48 := checkDerefVar(glojure_DOT_core_list) - tmp49 := lang.Apply(tmp48, []any{lang.NewSymbol("glojure.core/let")}) - tmp50 := checkDerefVar(glojure_DOT_core_list) - tmp51 := checkDerefVar(glojure_DOT_core_apply) - tmp52 := checkDerefVar(glojure_DOT_core_vector) - tmp53 := checkDerefVar(glojure_DOT_core_seq) - tmp54 := checkDerefVar(glojure_DOT_core_concat) - tmp55 := checkDerefVar(glojure_DOT_core_list) - tmp56 := lang.Apply(tmp55, []any{lang.NewSymbol("iter__0__auto__")}) - tmp57 := checkDerefVar(glojure_DOT_core_list) + tmp46 := checkDerefVar(var_glojure_DOT_core_seq) + tmp47 := checkDerefVar(var_glojure_DOT_core_concat) + tmp48 := checkDerefVar(var_glojure_DOT_core_list) + tmp49 := lang.Apply(tmp48, []any{sym_glojure_DOT_core_SLASH_let}) + tmp50 := checkDerefVar(var_glojure_DOT_core_list) + tmp51 := checkDerefVar(var_glojure_DOT_core_apply) + tmp52 := checkDerefVar(var_glojure_DOT_core_vector) + tmp53 := checkDerefVar(var_glojure_DOT_core_seq) + tmp54 := checkDerefVar(var_glojure_DOT_core_concat) + tmp55 := checkDerefVar(var_glojure_DOT_core_list) + tmp56 := lang.Apply(tmp55, []any{sym_iter__0__auto__}) + tmp57 := checkDerefVar(var_glojure_DOT_core_list) tmp58 := lang.Apply(v37, []any{v5}) tmp59 := lang.Apply(v45, []any{tmp58}) tmp60 := lang.Apply(tmp57, []any{tmp59}) @@ -25101,13 +25657,13 @@ func LoadNS() { tmp62 := lang.Apply(tmp53, []any{tmp61}) tmp63 := lang.Apply(tmp51, []any{tmp52, tmp62}) tmp64 := lang.Apply(tmp50, []any{tmp63}) - tmp65 := checkDerefVar(glojure_DOT_core_list) - tmp66 := checkDerefVar(glojure_DOT_core_seq) - tmp67 := checkDerefVar(glojure_DOT_core_concat) - tmp68 := checkDerefVar(glojure_DOT_core_list) - tmp69 := lang.Apply(tmp68, []any{lang.NewSymbol("iter__0__auto__")}) - tmp70 := checkDerefVar(glojure_DOT_core_list) - tmp71 := checkDerefVar(glojure_DOT_core_second) + tmp65 := checkDerefVar(var_glojure_DOT_core_list) + tmp66 := checkDerefVar(var_glojure_DOT_core_seq) + tmp67 := checkDerefVar(var_glojure_DOT_core_concat) + tmp68 := checkDerefVar(var_glojure_DOT_core_list) + tmp69 := lang.Apply(tmp68, []any{sym_iter__0__auto__}) + tmp70 := checkDerefVar(var_glojure_DOT_core_list) + tmp71 := checkDerefVar(var_glojure_DOT_core_second) tmp72 := lang.Apply(tmp71, []any{v5}) tmp73 := lang.Apply(tmp70, []any{tmp72}) tmp74 := lang.Apply(tmp67, []any{tmp69, tmp73}) @@ -25119,7 +25675,7 @@ func LoadNS() { } // end let return tmp33 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -25127,12 +25683,10 @@ func LoadNS() { } // force { - tmp0 := lang.NewSymbol("force").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "If x is a Delay, returns the (possibly cached) value of its expression, else returns x", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(754), lang.NewKeyword("end-line"), int(754))).(*lang.Symbol) + tmp0 := sym_force.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "If x is a Delay, returns the (possibly cached) value of its expression, else returns x", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(754), kw_end_DASH_line, int(754))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4, _ := lang.FieldOrMethod(nil, "force") @@ -25142,7 +25696,7 @@ func LoadNS() { tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -25150,24 +25704,22 @@ func LoadNS() { } // format { - tmp0 := lang.NewSymbol("format").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fmt"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Formats a string using java.lang.String.format, see java.util.Formatter for format\n string syntax", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5717), lang.NewKeyword("end-line"), int(5717))).(*lang.Symbol) + tmp0 := sym_format.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_fmt, sym__AMP_, sym_args)), kw_doc, "Formats a string using java.lang.String.format, see java.util.Formatter for format\n string syntax", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(5717), kw_end_DASH_line, int(5717))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var v4 any = lang.NewList(args[1:]...) _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_apply) + tmp5 := checkDerefVar(var_glojure_DOT_core_apply) tmp6 := lang.Apply(tmp5, []any{fmt.Sprintf, v3, v4}) return tmp6 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -25175,41 +25727,37 @@ func LoadNS() { } // frequencies { - tmp0 := lang.NewSymbol("frequencies").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a map from distinct items in coll to the number of times\n they appear.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7185), lang.NewKeyword("end-line"), int(7185))).(*lang.Symbol) + tmp0 := sym_frequencies.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a map from distinct items in coll to the number of times\n they appear.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(7185), kw_end_DASH_line, int(7185))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_persistent_BANG_) - tmp5 := checkDerefVar(glojure_DOT_core_reduce) + tmp4 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp5 := checkDerefVar(var_glojure_DOT_core_reduce) var tmp6 lang.FnFunc tmp6 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v7 := args[0] _ = v7 v8 := args[1] _ = v8 - tmp9 := checkDerefVar(glojure_DOT_core_assoc_BANG_) - tmp10 := checkDerefVar(glojure_DOT_core_inc) - tmp11 := checkDerefVar(glojure_DOT_core_get) + tmp9 := checkDerefVar(var_glojure_DOT_core_assoc_BANG_) + tmp10 := checkDerefVar(var_glojure_DOT_core_inc) + tmp11 := checkDerefVar(var_glojure_DOT_core_get) tmp12 := lang.Apply(tmp11, []any{v7, v8, int64(0)}) tmp13 := lang.Apply(tmp10, []any{tmp12}) tmp14 := lang.Apply(tmp9, []any{v7, v8, tmp13}) return tmp14 }) - tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7192), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(7193), lang.NewKeyword("end-column"), int(54)) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7192), kw_column, int(12), kw_end_DASH_line, int(7193), kw_end_DASH_column, int(54)) tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp9 := checkDerefVar(glojure_DOT_core_transient) + tmp9 := checkDerefVar(var_glojure_DOT_core_transient) tmp10 := lang.NewMap() - tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7194), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(7194), lang.NewKeyword("end-column"), int(24)) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7194), kw_column, int(23), kw_end_DASH_line, int(7194), kw_end_DASH_column, int(24)) tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) if err != nil { panic(err) @@ -25219,7 +25767,7 @@ func LoadNS() { tmp15 := lang.Apply(tmp4, []any{tmp14}) return tmp15 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -25227,34 +25775,32 @@ func LoadNS() { } // future { - tmp0 := lang.NewSymbol("future").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Takes a body of expressions and yields a future object that will\n invoke the body in another thread, and will cache the result and\n return it on all subsequent calls to deref/@. If the computation has\n not yet finished, calls to deref/@ will block, unless the variant of\n deref with timeout is used. See also - realized?.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7009), lang.NewKeyword("end-line"), int(7009))).(*lang.Symbol) + tmp0 := sym_future.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_body)), kw_doc, "Takes a body of expressions and yields a future object that will\n invoke the body in another thread, and will cache the result and\n return it on all subsequent calls to deref/@. If the computation has\n not yet finished, calls to deref/@ will block, unless the variant of\n deref with timeout is used. See also - realized?.", kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(11), kw_line, int(7009), kw_end_DASH_line, int(7009))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 var v5 any = lang.NewList(args[2:]...) _ = v5 - tmp6 := checkDerefVar(glojure_DOT_core_seq) - tmp7 := checkDerefVar(glojure_DOT_core_concat) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("glojure.core/future-call")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := checkDerefVar(glojure_DOT_core_seq) - tmp12 := checkDerefVar(glojure_DOT_core_concat) - tmp13 := checkDerefVar(glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("fn*")}) - tmp15 := checkDerefVar(glojure_DOT_core_list) - tmp16 := checkDerefVar(glojure_DOT_core_apply) - tmp17 := checkDerefVar(glojure_DOT_core_vector) - tmp18 := checkDerefVar(glojure_DOT_core_seq) - tmp19 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_future_DASH_call}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_fn_STAR_}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := checkDerefVar(var_glojure_DOT_core_apply) + tmp17 := checkDerefVar(var_glojure_DOT_core_vector) + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) tmp20 := lang.Apply(tmp19, nil) tmp21 := lang.Apply(tmp18, []any{tmp20}) tmp22 := lang.Apply(tmp16, []any{tmp17, tmp21}) @@ -25267,7 +25813,7 @@ func LoadNS() { return tmp28 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -25275,18 +25821,16 @@ func LoadNS() { } // future-call { - tmp0 := lang.NewSymbol("future-call").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Takes a function of no args and yields a future object that will\n invoke the function in another thread, and will cache the result and\n return it on all subsequent calls to deref/@. If the computation has\n not yet finished, calls to deref/@ will block, unless the variant\n of deref with timeout is used. See also - realized?.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7003), lang.NewKeyword("end-line"), int(7003))).(*lang.Symbol) + tmp0 := sym_future_DASH_call.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f)), kw_doc, "Takes a function of no args and yields a future object that will\n invoke the function in another thread, and will cache the result and\n return it on all subsequent calls to deref/@. If the computation has\n not yet finished, calls to deref/@ will block, unless the variant\n of deref with timeout is used. See also - realized?.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(7003), kw_end_DASH_line, int(7003))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any { // let // let binding "f" - tmp5 := checkDerefVar(glojure_DOT_core_binding_conveyor_fn) + tmp5 := checkDerefVar(var_glojure_DOT_core_binding_DASH_conveyor_DASH_fn) tmp6 := lang.Apply(tmp5, []any{v3}) var v7 any = tmp6 _ = v7 @@ -25298,7 +25842,7 @@ func LoadNS() { } // end let return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -25306,12 +25850,10 @@ func LoadNS() { } // future-cancel { - tmp0 := lang.NewSymbol("future-cancel").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Cancels the future, if possible.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7019), lang.NewKeyword("end-line"), int(7019))).(*lang.Symbol) + tmp0 := sym_future_DASH_cancel.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f)), kw_doc, "Cancels the future, if possible.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(7019), kw_end_DASH_line, int(7019))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4, _ := lang.FieldOrMethod(v3, "cancel") @@ -25321,7 +25863,7 @@ func LoadNS() { tmp5 := lang.Apply(tmp4, []any{true}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -25329,12 +25871,10 @@ func LoadNS() { } // future-cancelled? { - tmp0 := lang.NewSymbol("future-cancelled?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Returns true if future f is cancelled", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7025), lang.NewKeyword("end-line"), int(7025))).(*lang.Symbol) + tmp0 := sym_future_DASH_cancelled_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f)), kw_doc, "Returns true if future f is cancelled", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(7), kw_line, int(7025), kw_end_DASH_line, int(7025))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4, ok := lang.FieldOrMethod(v3, "isCancelled") @@ -25350,7 +25890,7 @@ func LoadNS() { } return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -25358,12 +25898,10 @@ func LoadNS() { } // future-done? { - tmp0 := lang.NewSymbol("future-done?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Returns true if future f is done", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6538), lang.NewKeyword("end-line"), int(6538))).(*lang.Symbol) + tmp0 := sym_future_DASH_done_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f)), kw_doc, "Returns true if future f is done", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(6538), kw_end_DASH_line, int(6538))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4, ok := lang.FieldOrMethod(v3, "isDone") @@ -25379,7 +25917,7 @@ func LoadNS() { } return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -25387,19 +25925,17 @@ func LoadNS() { } // future? { - tmp0 := lang.NewSymbol("future?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is a future", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6532), lang.NewKeyword("end-line"), int(6532))).(*lang.Symbol) + tmp0 := sym_future_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x is a future", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(6532), kw_end_DASH_line, int(6532))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp5 := lang.Apply(tmp4, []any{nil, v3}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -25407,7 +25943,7 @@ func LoadNS() { } // gen-class { - tmp0 := lang.NewSymbol("gen-class").WithMeta(lang.NewMap()).(*lang.Symbol) + tmp0 := sym_gen_DASH_class.WithMeta(lang.NewMap()).(*lang.Symbol) tmp1 := ns.Intern(tmp0) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -25415,19 +25951,19 @@ func LoadNS() { } // gensym { - tmp0 := lang.NewSymbol("gensym").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("prefix-string"))), lang.NewKeyword("doc"), "Returns a new symbol with a unique name. If a prefix string is\n supplied, the name is prefix# where # is some unique number. If\n prefix is not supplied, the prefix is 'G__'.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(599), lang.NewKeyword("end-line"), int(599))).(*lang.Symbol) + tmp0 := sym_gensym.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_prefix_DASH_string)), kw_doc, "Returns a new symbol with a unique name. If a prefix string is\n supplied, the name is prefix# where # is some unique number. If\n prefix is not supplied, the prefix is 'G__'.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(599), kw_end_DASH_line, int(599))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - tmp3 := checkDerefVar(glojure_DOT_core_gensym) + tmp3 := checkDerefVar(var_glojure_DOT_core_gensym) tmp4 := lang.Apply(tmp3, []any{"G__"}) return tmp4 case 1: v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_str) - tmp5 := checkDerefVar(glojure_DOT_core_str) + tmp4 := checkDerefVar(var_glojure_DOT_core_str) + tmp5 := checkDerefVar(var_glojure_DOT_core_str) tmp6, _ := lang.FieldOrMethod(runtime7.RT, "NextID") if reflect.TypeOf(tmp6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("NextID is not a function"))) @@ -25438,10 +25974,11 @@ func LoadNS() { tmp10 := lang.Apply(lang.NewSymbol, []any{tmp9}) return tmp10 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -25455,29 +25992,27 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 var v5 any = lang.NewList(args[2:]...) _ = v5 - tmp6 := checkDerefVar(glojure_DOT_core_seq) - tmp7 := checkDerefVar(glojure_DOT_core_concat) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol(".")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - tmp12 := checkDerefVar(glojure_DOT_core_list) - tmp13 := checkDerefVar(glojure_DOT_core_seq) - tmp14 := checkDerefVar(glojure_DOT_core_concat) - tmp15 := checkDerefVar(glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("glojure.core/Get")}) - tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym__DOT_}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_Get}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) tmp18 := lang.Apply(tmp17, []any{v3}) - tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) tmp20 := lang.Apply(tmp19, []any{v4}) tmp21 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp20, v5}) tmp22 := lang.Apply(tmp13, []any{tmp21}) @@ -25490,7 +26025,7 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("get").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("key"), lang.NewSymbol("not-found"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the value mapped to key, not-found or nil if key not present\n in associative collection, set, string, array, or ILookup instance.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2), int64(3)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1489), lang.NewKeyword("end-line"), int(1489))).(*lang.Symbol) + tmp0 := sym_get.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_map, sym_key), lang.NewVector(sym_map, sym_key, sym_not_DASH_found)), kw_inline, tmp1, kw_doc, "Returns the value mapped to key, not-found or nil if key not present\n in associative collection, set, string, array, or ILookup instance.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2), int64(3)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(1489), kw_end_DASH_line, int(1489))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -25511,10 +26046,11 @@ func LoadNS() { tmp7 := lang.Apply(lang.GetDefault, []any{v4, v5, v6}) return tmp7 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -25522,7 +26058,7 @@ func LoadNS() { } // get-in { - tmp0 := lang.NewSymbol("get-in").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("ks")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("ks"), lang.NewSymbol("not-found"))), lang.NewKeyword("doc"), "Returns the value in a nested associative structure,\n where ks is a sequence of keys. Returns nil if the key\n is not present, or the not-found value if supplied.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6128), lang.NewKeyword("end-line"), int(6128))).(*lang.Symbol) + tmp0 := sym_get_DASH_in.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m, sym_ks), lang.NewVector(sym_m, sym_ks, sym_not_DASH_found)), kw_doc, "Returns the value in a nested associative structure,\n where ks is a sequence of keys. Returns nil if the key\n is not present, or the not-found value if supplied.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(6128), kw_end_DASH_line, int(6128))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -25531,8 +26067,8 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_reduce1) - tmp6 := checkDerefVar(glojure_DOT_core_get) + tmp5 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp6 := checkDerefVar(var_glojure_DOT_core_get) tmp7 := lang.Apply(tmp5, []any{tmp6, v3, v4}) return tmp7 case 3: @@ -25564,7 +26100,7 @@ func LoadNS() { var v12 any = v3 _ = v12 // let binding "ks" - tmp13 := checkDerefVar(glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) tmp14 := lang.Apply(tmp13, []any{v4}) var v15 any = tmp14 _ = v15 @@ -25574,21 +26110,21 @@ func LoadNS() { var tmp17 any { // let // let binding "m" - tmp18 := checkDerefVar(glojure_DOT_core_get) - tmp19 := checkDerefVar(glojure_DOT_core_first) + tmp18 := checkDerefVar(var_glojure_DOT_core_get) + tmp19 := checkDerefVar(var_glojure_DOT_core_first) tmp20 := lang.Apply(tmp19, []any{v15}) tmp21 := lang.Apply(tmp18, []any{v12, tmp20, v11}) var v22 any = tmp21 _ = v22 var tmp23 any - tmp24 := checkDerefVar(glojure_DOT_core_identical_QMARK_) + tmp24 := checkDerefVar(var_glojure_DOT_core_identical_QMARK_) tmp25 := lang.Apply(tmp24, []any{v11, v22}) if lang.IsTruthy(tmp25) { tmp23 = v5 } else { var tmp26 any = v11 var tmp27 any = v22 - tmp29 := checkDerefVar(glojure_DOT_core_next) + tmp29 := checkDerefVar(var_glojure_DOT_core_next) tmp30 := lang.Apply(tmp29, []any{v15}) var tmp28 any = tmp30 v11 = tmp26 @@ -25608,10 +26144,11 @@ func LoadNS() { } // end let return tmp6 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -25619,12 +26156,10 @@ func LoadNS() { } // get-method { - tmp0 := lang.NewSymbol("get-method").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"), lang.NewSymbol("dispatch-val"))), lang.NewKeyword("doc"), "Given a multimethod and a dispatch value, returns the dispatch fn\n that would apply to that value, or nil if none apply and no default", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1815), lang.NewKeyword("end-line"), int(1815))).(*lang.Symbol) + tmp0 := sym_get_DASH_method.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_multifn, sym_dispatch_DASH_val)), kw_doc, "Given a multimethod and a dispatch value, returns the dispatch fn\n that would apply to that value, or nil if none apply and no default", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(1815), kw_end_DASH_line, int(1815))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -25636,7 +26171,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v4}) return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -25644,16 +26179,14 @@ func LoadNS() { } // get-thread-bindings { - tmp0 := lang.NewSymbol("get-thread-bindings").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Get a map with the Var/value pairs which is currently in effect for the\n current thread.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1937), lang.NewKeyword("end-line"), int(1937))).(*lang.Symbol) + tmp0 := sym_get_DASH_thread_DASH_bindings.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Get a map with the Var/value pairs which is currently in effect for the\n current thread.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(25), kw_column, int(7), kw_line, int(1937), kw_end_DASH_line, int(1937))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) tmp3 := lang.Apply(nil, nil) return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -25661,12 +26194,10 @@ func LoadNS() { } // get-validator { - tmp0 := lang.NewSymbol("get-validator").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("iref"))), lang.NewKeyword("doc"), "Gets the validator-fn for a var/ref/agent/atom.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2392), lang.NewKeyword("end-line"), int(2392))).(*lang.Symbol) + tmp0 := sym_get_DASH_validator.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_iref)), kw_doc, "Gets the validator-fn for a var/ref/agent/atom.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(2392), kw_end_DASH_line, int(2392))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4, _ := lang.FieldOrMethod(v3, "getValidator") @@ -25676,7 +26207,7 @@ func LoadNS() { tmp5 := lang.Apply(tmp4, []any{}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -25684,31 +26215,27 @@ func LoadNS() { } // global-hierarchy { - tmp0 := lang.NewSymbol("global-hierarchy").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5513), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(5514), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, lang.NewMap(lang.NewKeyword("parents"), lang.NewMap(), lang.NewKeyword("descendants"), lang.NewMap(), lang.NewKeyword("ancestors"), lang.NewMap()), true) + tmp0 := sym_global_DASH_hierarchy.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(5513), kw_column, int(6), kw_end_DASH_line, int(5514), kw_end_DASH_column, int(21), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + tmp1 := ns.InternWithValue(tmp0, lang.NewMap(kw_parents, lang.NewMap(), kw_descendants, lang.NewMap(), kw_ancestors, lang.NewMap()), true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // group-by { - tmp0 := lang.NewSymbol("group-by").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a map of the elements of coll keyed by the result of\n f on each element. The value at each key will be a vector of the\n corresponding elements, in the order they appeared in coll.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7128), lang.NewKeyword("end-line"), int(7128))).(*lang.Symbol) + tmp0 := sym_group_DASH_by.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_coll)), kw_doc, "Returns a map of the elements of coll keyed by the result of\n f on each element. The value at each key will be a vector of the\n corresponding elements, in the order they appeared in coll.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(7128), kw_end_DASH_line, int(7128))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_persistent_BANG_) - tmp6 := checkDerefVar(glojure_DOT_core_reduce) + tmp5 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp6 := checkDerefVar(var_glojure_DOT_core_reduce) var tmp7 lang.FnFunc tmp7 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v8 := args[0] _ = v8 v9 := args[1] @@ -25719,11 +26246,11 @@ func LoadNS() { tmp11 := lang.Apply(v3, []any{v9}) var v12 any = tmp11 _ = v12 - tmp13 := checkDerefVar(glojure_DOT_core_assoc_BANG_) - tmp14 := checkDerefVar(glojure_DOT_core_conj) - tmp15 := checkDerefVar(glojure_DOT_core_get) + tmp13 := checkDerefVar(var_glojure_DOT_core_assoc_BANG_) + tmp14 := checkDerefVar(var_glojure_DOT_core_conj) + tmp15 := checkDerefVar(var_glojure_DOT_core_get) tmp16 := lang.NewVector() - tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7139), lang.NewKeyword("column"), int(40), lang.NewKeyword("end-line"), int(7139), lang.NewKeyword("end-column"), int(41)) + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7139), kw_column, int(40), kw_end_DASH_line, int(7139), kw_end_DASH_column, int(41)) tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) if err != nil { panic(err) @@ -25735,14 +26262,14 @@ func LoadNS() { } // end let return tmp10 }) - tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7137), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(7139), lang.NewKeyword("end-column"), int(48)) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7137), kw_column, int(5), kw_end_DASH_line, int(7139), kw_end_DASH_column, int(48)) tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp10 := checkDerefVar(glojure_DOT_core_transient) + tmp10 := checkDerefVar(var_glojure_DOT_core_transient) tmp11 := lang.NewMap() - tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7140), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(7140), lang.NewKeyword("end-column"), int(17)) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7140), kw_column, int(16), kw_end_DASH_line, int(7140), kw_end_DASH_column, int(17)) tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) if err != nil { panic(err) @@ -25752,7 +26279,7 @@ func LoadNS() { tmp16 := lang.Apply(tmp5, []any{tmp15}) return tmp16 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -25760,14 +26287,14 @@ func LoadNS() { } // halt-when { - tmp0 := lang.NewSymbol("halt-when").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred")), lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("retf"))), lang.NewKeyword("doc"), "Returns a transducer that ends transduction when pred returns true\n for an input. When retf is supplied it must be a fn of 2 arguments -\n it will be passed the (completed) result so far and the input that\n triggered the predicate, and its return value (if it does not throw\n an exception) will be the return value of the transducer. If retf\n is not supplied, the input that triggered the predicate will be\n returned. If the predicate never returns true the transduction is\n unaffected.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7657), lang.NewKeyword("end-line"), int(7657))).(*lang.Symbol) + tmp0 := sym_halt_DASH_when.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred), lang.NewVector(sym_pred, sym_retf)), kw_doc, "Returns a transducer that ends transduction when pred returns true\n for an input. When retf is supplied it must be a fn of 2 arguments -\n it will be passed the (completed) result so far and the input that\n triggered the predicate, and its return value (if it does not throw\n an exception) will be the return value of the transducer. If retf\n is not supplied, the input that triggered the predicate will be\n returned. If the predicate never returns true the transduction is\n unaffected.", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(7657), kw_end_DASH_line, int(7657))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_halt_when) + tmp4 := checkDerefVar(var_glojure_DOT_core_halt_DASH_when) tmp5 := lang.Apply(tmp4, []any{v3, nil}) return tmp5 case 2: @@ -25777,9 +26304,7 @@ func LoadNS() { _ = v4 var tmp5 lang.FnFunc tmp5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v6 := args[0] _ = v6 var tmp7 lang.FnFunc @@ -25795,14 +26320,14 @@ func LoadNS() { var tmp10 any { // let // let binding "and__0__auto__" - tmp11 := checkDerefVar(glojure_DOT_core_map_QMARK_) + tmp11 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) tmp12 := lang.Apply(tmp11, []any{v8}) var v13 any = tmp12 _ = v13 var tmp14 any if lang.IsTruthy(v13) { - tmp15 := checkDerefVar(glojure_DOT_core_contains_QMARK_) - tmp16 := lang.Apply(tmp15, []any{v8, lang.NewKeyword("glojure.core/halt")}) + tmp15 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp16 := lang.Apply(tmp15, []any{v8, kw_glojure_DOT_core_SLASH_halt}) tmp14 = tmp16 } else { tmp14 = v13 @@ -25810,7 +26335,7 @@ func LoadNS() { tmp10 = tmp14 } // end let if lang.IsTruthy(tmp10) { - tmp11 := lang.Apply(lang.NewKeyword("glojure.core/halt"), []any{v8}) + tmp11 := lang.Apply(kw_glojure_DOT_core_SLASH_halt, []any{v8}) tmp9 = tmp11 } else { tmp12 := lang.Apply(v6, []any{v8}) @@ -25825,7 +26350,7 @@ func LoadNS() { var tmp10 any tmp11 := lang.Apply(v3, []any{v9}) if lang.IsTruthy(tmp11) { - tmp12 := checkDerefVar(glojure_DOT_core_reduced) + tmp12 := checkDerefVar(var_glojure_DOT_core_reduced) var tmp13 any if lang.IsTruthy(v4) { tmp14 := lang.Apply(v6, []any{v8}) @@ -25834,8 +26359,8 @@ func LoadNS() { } else { tmp13 = v9 } - tmp16 := lang.NewMap(lang.NewKeyword("glojure.core/halt"), tmp13) - tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7678), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(7678), lang.NewKeyword("end-column"), int(72)) + tmp16 := lang.NewMap(kw_glojure_DOT_core_SLASH_halt, tmp13) + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7678), kw_column, int(24), kw_end_DASH_line, int(7678), kw_end_DASH_column, int(72)) tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) if err != nil { panic(err) @@ -25848,27 +26373,29 @@ func LoadNS() { } return tmp10 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7670), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7679), lang.NewKeyword("end-column"), int(34)) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7670), kw_column, int(8), kw_end_DASH_line, int(7679), kw_end_DASH_column, int(34)) tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) if err != nil { panic(err) } return tmp9 }) - tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7669), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7679), lang.NewKeyword("end-column"), int(35)) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7669), kw_column, int(6), kw_end_DASH_line, int(7679), kw_end_DASH_column, int(35)) tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) if err != nil { panic(err) } return tmp7 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -25876,18 +26403,16 @@ func LoadNS() { } // hash { - tmp0 := lang.NewSymbol("hash").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns the hash code of its argument. Note this is the hash code\n consistent with =, and thus is different than .hashCode for Integer,\n Short, Byte and Clojure collections.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5189), lang.NewKeyword("end-line"), int(5189))).(*lang.Symbol) + tmp0 := sym_hash.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns the hash code of its argument. Note this is the hash code\n consistent with =, and thus is different than .hashCode for Integer,\n Short, Byte and Clojure collections.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(5189), kw_end_DASH_line, int(5189))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4 := lang.Apply(lang.HashEq, []any{v3}) return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -25895,29 +26420,27 @@ func LoadNS() { } // hash-map { - tmp0 := lang.NewSymbol("hash-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keyvals"))), lang.NewKeyword("doc"), "keyval => key val\n Returns a new hash map with supplied mappings. If any keys are\n equal, they are handled as if by repeated uses of assoc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(378), lang.NewKeyword("end-line"), int(378))).(*lang.Symbol) + tmp0 := sym_hash_DASH_map.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym__AMP_, sym_keyvals)), kw_doc, "keyval => key val\n Returns a new hash map with supplied mappings. If any keys are\n equal, they are handled as if by repeated uses of assoc.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(378), kw_end_DASH_line, int(378))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: tmp3 := lang.NewMap() - tmp4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(384), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(384), lang.NewKeyword("end-column"), int(8)) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(384), kw_column, int(7), kw_end_DASH_line, int(384), kw_end_DASH_column, int(8)) tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) if err != nil { panic(err) } return tmp5 default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 tmp4 := lang.Apply(lang.CreatePersistentHashMap, []any{v3}) return tmp4 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -25925,18 +26448,16 @@ func LoadNS() { } // hash-ordered-coll { - tmp0 := lang.NewSymbol("hash-ordered-coll").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns the hash code, consistent with =, for an external ordered\n collection implementing Iterable.\n See http://glojure.org/data_structures#hash for full algorithms.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5210), lang.NewKeyword("end-line"), int(5210))).(*lang.Symbol) + tmp0 := sym_hash_DASH_ordered_DASH_coll.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns the hash code, consistent with =, for an external ordered\n collection implementing Iterable.\n See http://glojure.org/data_structures#hash for full algorithms.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.6", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(7), kw_line, int(5210), kw_end_DASH_line, int(5210))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4 := lang.Apply(nil, []any{v3}) return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -25944,29 +26465,27 @@ func LoadNS() { } // hash-set { - tmp0 := lang.NewSymbol("hash-set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keys"))), lang.NewKeyword("doc"), "Returns a new hash set with supplied keys. Any equal keys are\n handled as if by repeated uses of conj.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(388), lang.NewKeyword("end-line"), int(388))).(*lang.Symbol) + tmp0 := sym_hash_DASH_set.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym__AMP_, sym_keys)), kw_doc, "Returns a new hash set with supplied keys. Any equal keys are\n handled as if by repeated uses of conj.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(388), kw_end_DASH_line, int(388))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: tmp3 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) - tmp4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(393), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(393), lang.NewKeyword("end-column"), int(9)) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(393), kw_column, int(7), kw_end_DASH_line, int(393), kw_end_DASH_column, int(9)) tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) if err != nil { panic(err) } return tmp5 default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 tmp4 := lang.Apply(nil, []any{v3}) return tmp4 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -25974,18 +26493,16 @@ func LoadNS() { } // hash-unordered-coll { - tmp0 := lang.NewSymbol("hash-unordered-coll").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns the hash code, consistent with =, for an external unordered\n collection implementing Iterable. For maps, the iterator should\n return map entries whose hash is computed as\n (hash-ordered-coll [k v]).\n See http://glojure.org/data_structures#hash for full algorithms.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5219), lang.NewKeyword("end-line"), int(5219))).(*lang.Symbol) + tmp0 := sym_hash_DASH_unordered_DASH_coll.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns the hash code, consistent with =, for an external unordered\n collection implementing Iterable. For maps, the iterator should\n return map entries whose hash is computed as\n (hash-ordered-coll [k v]).\n See http://glojure.org/data_structures#hash for full algorithms.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.6", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(25), kw_column, int(7), kw_line, int(5219), kw_end_DASH_line, int(5219))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4 := lang.Apply(nil, []any{v3}) return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -25993,18 +26510,16 @@ func LoadNS() { } // ident? { - tmp0 := lang.NewSymbol("ident?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a symbol or keyword", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1608), lang.NewKeyword("end-line"), int(1608))).(*lang.Symbol) + tmp0 := sym_ident_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a symbol or keyword", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(1608), kw_end_DASH_line, int(1608))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any { // let // let binding "or__0__auto__" - tmp5 := checkDerefVar(glojure_DOT_core_keyword_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) tmp6 := lang.Apply(tmp5, []any{v3}) var v7 any = tmp6 _ = v7 @@ -26012,7 +26527,7 @@ func LoadNS() { if lang.IsTruthy(v7) { tmp8 = v7 } else { - tmp9 := checkDerefVar(glojure_DOT_core_symbol_QMARK_) + tmp9 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) tmp10 := lang.Apply(tmp9, []any{v3}) tmp8 = tmp10 } @@ -26020,7 +26535,7 @@ func LoadNS() { } // end let return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -26032,24 +26547,22 @@ func LoadNS() { { // function identical?__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_seq) - tmp6 := checkDerefVar(glojure_DOT_core_concat) - tmp7 := checkDerefVar(glojure_DOT_core_list) - tmp8 := lang.Apply(tmp7, []any{lang.NewSymbol(".")}) - tmp9 := checkDerefVar(glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("glojure.lang.Util")}) - tmp11 := checkDerefVar(glojure_DOT_core_list) - tmp12 := lang.Apply(tmp11, []any{lang.NewSymbol("glojure.core/identical")}) - tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_lang_DOT_Util}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_glojure_DOT_core_SLASH_identical}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) tmp14 := lang.Apply(tmp13, []any{v3}) - tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v4}) tmp17 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp12, tmp14, tmp16}) tmp18 := lang.Apply(tmp5, []any{tmp17}) @@ -26058,12 +26571,10 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("identical?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Tests if 2 arguments are the same object", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(768), lang.NewKeyword("end-line"), int(768))).(*lang.Symbol) + tmp0 := sym_identical_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Tests if 2 arguments are the same object", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(768), kw_end_DASH_line, int(768))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -26071,7 +26582,7 @@ func LoadNS() { tmp6 := lang.Apply(lang.Identical, []any{v4, v5}) return tmp6 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -26079,17 +26590,15 @@ func LoadNS() { } // identity { - tmp0 := lang.NewSymbol("identity").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns its argument.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1446), lang.NewKeyword("end-line"), int(1446))).(*lang.Symbol) + tmp0 := sym_identity.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns its argument.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(1446), kw_end_DASH_line, int(1446))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 return v3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -26097,7 +26606,7 @@ func LoadNS() { } // if-let { - tmp0 := lang.NewSymbol("if-let").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("then")), lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("then"), lang.NewSymbol("else"), lang.NewSymbol("&"), lang.NewSymbol("oldform"))), lang.NewKeyword("doc"), "bindings => binding-form test\n\n If test is true, evaluates then with binding-form bound to the value of \n test, if not, yields else", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1839), lang.NewKeyword("end-line"), int(1839))).(*lang.Symbol) + tmp0 := sym_if_DASH_let.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym_then), lang.NewVector(sym_bindings, sym_then, sym_else, sym__AMP_, sym_oldform)), kw_doc, "bindings => binding-form test\n\n If test is true, evaluates then with binding-form bound to the value of \n test, if not, yields else", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(11), kw_line, int(1839), kw_end_DASH_line, int(1839))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -26110,23 +26619,21 @@ func LoadNS() { _ = v5 v6 := args[3] _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_seq) - tmp8 := checkDerefVar(glojure_DOT_core_concat) - tmp9 := checkDerefVar(glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("glojure.core/if-let")}) - tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_core_SLASH_if_DASH_let}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) tmp12 := lang.Apply(tmp11, []any{v5}) - tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) tmp14 := lang.Apply(tmp13, []any{v6}) - tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{nil}) tmp17 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp14, tmp16}) tmp18 := lang.Apply(tmp7, []any{tmp17}) return tmp18 default: - if len(args) < 5 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 5) v3 := args[0] _ = v3 v4 := args[1] @@ -26140,53 +26647,53 @@ func LoadNS() { var v8 any = lang.NewList(args[5:]...) _ = v8 var tmp9 any - tmp10 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp10 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) tmp11 := lang.Apply(tmp10, []any{v5}) if lang.IsTruthy(tmp11) { } else { - tmp12 := checkDerefVar(glojure_DOT_core_str) - tmp13 := checkDerefVar(glojure_DOT_core_first) + tmp12 := checkDerefVar(var_glojure_DOT_core_str) + tmp13 := checkDerefVar(var_glojure_DOT_core_first) tmp14 := lang.Apply(tmp13, []any{v3}) - tmp15 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) - tmp16 := checkDerefVar(glojure_DOT_core_meta) + tmp15 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp16 := checkDerefVar(var_glojure_DOT_core_meta) tmp17 := lang.Apply(tmp16, []any{v3}) - tmp18 := lang.Apply(lang.NewKeyword("line"), []any{tmp17}) + tmp18 := lang.Apply(kw_line, []any{tmp17}) tmp19 := lang.Apply(tmp12, []any{tmp14, " requires ", "a vector for its binding", " in ", tmp15, ":", tmp18}) tmp20 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp19}) panic(tmp20) } _ = tmp9 var tmp21 any - tmp22 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp22 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) tmp23 := lang.Apply(tmp22, []any{v8}) if lang.IsTruthy(tmp23) { } else { - tmp24 := checkDerefVar(glojure_DOT_core_str) - tmp25 := checkDerefVar(glojure_DOT_core_first) + tmp24 := checkDerefVar(var_glojure_DOT_core_str) + tmp25 := checkDerefVar(var_glojure_DOT_core_first) tmp26 := lang.Apply(tmp25, []any{v3}) - tmp27 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) - tmp28 := checkDerefVar(glojure_DOT_core_meta) + tmp27 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp28 := checkDerefVar(var_glojure_DOT_core_meta) tmp29 := lang.Apply(tmp28, []any{v3}) - tmp30 := lang.Apply(lang.NewKeyword("line"), []any{tmp29}) + tmp30 := lang.Apply(kw_line, []any{tmp29}) tmp31 := lang.Apply(tmp24, []any{tmp26, " requires ", "1 or 2 forms after binding vector", " in ", tmp27, ":", tmp30}) tmp32 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp31}) panic(tmp32) } _ = tmp21 var tmp33 any - tmp34 := checkDerefVar(glojure_DOT_core__EQ_) - tmp35 := checkDerefVar(glojure_DOT_core_count) + tmp34 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp35 := checkDerefVar(var_glojure_DOT_core_count) tmp36 := lang.Apply(tmp35, []any{v5}) tmp37 := lang.Apply(tmp34, []any{int64(2), tmp36}) if lang.IsTruthy(tmp37) { } else { - tmp38 := checkDerefVar(glojure_DOT_core_str) - tmp39 := checkDerefVar(glojure_DOT_core_first) + tmp38 := checkDerefVar(var_glojure_DOT_core_str) + tmp39 := checkDerefVar(var_glojure_DOT_core_first) tmp40 := lang.Apply(tmp39, []any{v3}) - tmp41 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) - tmp42 := checkDerefVar(glojure_DOT_core_meta) + tmp41 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp42 := checkDerefVar(var_glojure_DOT_core_meta) tmp43 := lang.Apply(tmp42, []any{v3}) - tmp44 := lang.Apply(lang.NewKeyword("line"), []any{tmp43}) + tmp44 := lang.Apply(kw_line, []any{tmp43}) tmp45 := lang.Apply(tmp38, []any{tmp40, " requires ", "exactly 2 forms in binding vector", " in ", tmp41, ":", tmp44}) tmp46 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp45}) panic(tmp46) @@ -26202,54 +26709,54 @@ func LoadNS() { tmp50 := lang.Apply(v5, []any{int64(1)}) var v51 any = tmp50 _ = v51 - tmp52 := checkDerefVar(glojure_DOT_core_seq) - tmp53 := checkDerefVar(glojure_DOT_core_concat) - tmp54 := checkDerefVar(glojure_DOT_core_list) - tmp55 := lang.Apply(tmp54, []any{lang.NewSymbol("glojure.core/let")}) - tmp56 := checkDerefVar(glojure_DOT_core_list) - tmp57 := checkDerefVar(glojure_DOT_core_apply) - tmp58 := checkDerefVar(glojure_DOT_core_vector) - tmp59 := checkDerefVar(glojure_DOT_core_seq) - tmp60 := checkDerefVar(glojure_DOT_core_concat) - tmp61 := checkDerefVar(glojure_DOT_core_list) - tmp62 := lang.Apply(tmp61, []any{lang.NewSymbol("temp__0__auto__")}) - tmp63 := checkDerefVar(glojure_DOT_core_list) + tmp52 := checkDerefVar(var_glojure_DOT_core_seq) + tmp53 := checkDerefVar(var_glojure_DOT_core_concat) + tmp54 := checkDerefVar(var_glojure_DOT_core_list) + tmp55 := lang.Apply(tmp54, []any{sym_glojure_DOT_core_SLASH_let}) + tmp56 := checkDerefVar(var_glojure_DOT_core_list) + tmp57 := checkDerefVar(var_glojure_DOT_core_apply) + tmp58 := checkDerefVar(var_glojure_DOT_core_vector) + tmp59 := checkDerefVar(var_glojure_DOT_core_seq) + tmp60 := checkDerefVar(var_glojure_DOT_core_concat) + tmp61 := checkDerefVar(var_glojure_DOT_core_list) + tmp62 := lang.Apply(tmp61, []any{sym_temp__0__auto__}) + tmp63 := checkDerefVar(var_glojure_DOT_core_list) tmp64 := lang.Apply(tmp63, []any{v51}) tmp65 := lang.Apply(tmp60, []any{tmp62, tmp64}) tmp66 := lang.Apply(tmp59, []any{tmp65}) tmp67 := lang.Apply(tmp57, []any{tmp58, tmp66}) tmp68 := lang.Apply(tmp56, []any{tmp67}) - tmp69 := checkDerefVar(glojure_DOT_core_list) - tmp70 := checkDerefVar(glojure_DOT_core_seq) - tmp71 := checkDerefVar(glojure_DOT_core_concat) - tmp72 := checkDerefVar(glojure_DOT_core_list) - tmp73 := lang.Apply(tmp72, []any{lang.NewSymbol("if")}) - tmp74 := checkDerefVar(glojure_DOT_core_list) - tmp75 := lang.Apply(tmp74, []any{lang.NewSymbol("temp__0__auto__")}) - tmp76 := checkDerefVar(glojure_DOT_core_list) - tmp77 := checkDerefVar(glojure_DOT_core_seq) - tmp78 := checkDerefVar(glojure_DOT_core_concat) - tmp79 := checkDerefVar(glojure_DOT_core_list) - tmp80 := lang.Apply(tmp79, []any{lang.NewSymbol("glojure.core/let")}) - tmp81 := checkDerefVar(glojure_DOT_core_list) - tmp82 := checkDerefVar(glojure_DOT_core_apply) - tmp83 := checkDerefVar(glojure_DOT_core_vector) - tmp84 := checkDerefVar(glojure_DOT_core_seq) - tmp85 := checkDerefVar(glojure_DOT_core_concat) - tmp86 := checkDerefVar(glojure_DOT_core_list) + tmp69 := checkDerefVar(var_glojure_DOT_core_list) + tmp70 := checkDerefVar(var_glojure_DOT_core_seq) + tmp71 := checkDerefVar(var_glojure_DOT_core_concat) + tmp72 := checkDerefVar(var_glojure_DOT_core_list) + tmp73 := lang.Apply(tmp72, []any{sym_if}) + tmp74 := checkDerefVar(var_glojure_DOT_core_list) + tmp75 := lang.Apply(tmp74, []any{sym_temp__0__auto__}) + tmp76 := checkDerefVar(var_glojure_DOT_core_list) + tmp77 := checkDerefVar(var_glojure_DOT_core_seq) + tmp78 := checkDerefVar(var_glojure_DOT_core_concat) + tmp79 := checkDerefVar(var_glojure_DOT_core_list) + tmp80 := lang.Apply(tmp79, []any{sym_glojure_DOT_core_SLASH_let}) + tmp81 := checkDerefVar(var_glojure_DOT_core_list) + tmp82 := checkDerefVar(var_glojure_DOT_core_apply) + tmp83 := checkDerefVar(var_glojure_DOT_core_vector) + tmp84 := checkDerefVar(var_glojure_DOT_core_seq) + tmp85 := checkDerefVar(var_glojure_DOT_core_concat) + tmp86 := checkDerefVar(var_glojure_DOT_core_list) tmp87 := lang.Apply(tmp86, []any{v49}) - tmp88 := checkDerefVar(glojure_DOT_core_list) - tmp89 := lang.Apply(tmp88, []any{lang.NewSymbol("temp__0__auto__")}) + tmp88 := checkDerefVar(var_glojure_DOT_core_list) + tmp89 := lang.Apply(tmp88, []any{sym_temp__0__auto__}) tmp90 := lang.Apply(tmp85, []any{tmp87, tmp89}) tmp91 := lang.Apply(tmp84, []any{tmp90}) tmp92 := lang.Apply(tmp82, []any{tmp83, tmp91}) tmp93 := lang.Apply(tmp81, []any{tmp92}) - tmp94 := checkDerefVar(glojure_DOT_core_list) + tmp94 := checkDerefVar(var_glojure_DOT_core_list) tmp95 := lang.Apply(tmp94, []any{v6}) tmp96 := lang.Apply(tmp78, []any{tmp80, tmp93, tmp95}) tmp97 := lang.Apply(tmp77, []any{tmp96}) tmp98 := lang.Apply(tmp76, []any{tmp97}) - tmp99 := checkDerefVar(glojure_DOT_core_list) + tmp99 := checkDerefVar(var_glojure_DOT_core_list) tmp100 := lang.Apply(tmp99, []any{v7}) tmp101 := lang.Apply(tmp71, []any{tmp73, tmp75, tmp98, tmp100}) tmp102 := lang.Apply(tmp70, []any{tmp101}) @@ -26261,7 +26768,7 @@ func LoadNS() { return tmp47 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -26269,7 +26776,7 @@ func LoadNS() { } // if-not { - tmp0 := lang.NewSymbol("if-not").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("test"), lang.NewSymbol("then")), lang.NewVector(lang.NewSymbol("test"), lang.NewSymbol("then"), lang.NewSymbol("else"))), lang.NewKeyword("doc"), "Evaluates test. If logical false, evaluates and returns then expr, \n otherwise else expr, if supplied, else nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(760), lang.NewKeyword("end-line"), int(760))).(*lang.Symbol) + tmp0 := sym_if_DASH_not.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_test, sym_then), lang.NewVector(sym_test, sym_then, sym_else)), kw_doc, "Evaluates test. If logical false, evaluates and returns then expr, \n otherwise else expr, if supplied, else nil.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(11), kw_line, int(760), kw_end_DASH_line, int(760))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -26282,15 +26789,15 @@ func LoadNS() { _ = v5 v6 := args[3] _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_seq) - tmp8 := checkDerefVar(glojure_DOT_core_concat) - tmp9 := checkDerefVar(glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("glojure.core/if-not")}) - tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_core_SLASH_if_DASH_not}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) tmp12 := lang.Apply(tmp11, []any{v5}) - tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) tmp14 := lang.Apply(tmp13, []any{v6}) - tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{nil}) tmp17 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp14, tmp16}) tmp18 := lang.Apply(tmp7, []any{tmp17}) @@ -26306,32 +26813,33 @@ func LoadNS() { _ = v6 v7 := args[4] _ = v7 - tmp8 := checkDerefVar(glojure_DOT_core_seq) - tmp9 := checkDerefVar(glojure_DOT_core_concat) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol("if")}) - tmp12 := checkDerefVar(glojure_DOT_core_list) - tmp13 := checkDerefVar(glojure_DOT_core_seq) - tmp14 := checkDerefVar(glojure_DOT_core_concat) - tmp15 := checkDerefVar(glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("glojure.core/not")}) - tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_if}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_not}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) tmp18 := lang.Apply(tmp17, []any{v5}) tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) tmp20 := lang.Apply(tmp13, []any{tmp19}) tmp21 := lang.Apply(tmp12, []any{tmp20}) - tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) tmp23 := lang.Apply(tmp22, []any{v6}) - tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) tmp25 := lang.Apply(tmp24, []any{v7}) tmp26 := lang.Apply(tmp9, []any{tmp11, tmp21, tmp23, tmp25}) tmp27 := lang.Apply(tmp8, []any{tmp26}) return tmp27 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -26339,7 +26847,7 @@ func LoadNS() { } // if-some { - tmp0 := lang.NewSymbol("if-some").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("then")), lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("then"), lang.NewSymbol("else"), lang.NewSymbol("&"), lang.NewSymbol("oldform"))), lang.NewKeyword("doc"), "bindings => binding-form test\n\n If test is not nil, evaluates then with binding-form bound to the\n value of test, if not, yields else", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1874), lang.NewKeyword("end-line"), int(1874))).(*lang.Symbol) + tmp0 := sym_if_DASH_some.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym_then), lang.NewVector(sym_bindings, sym_then, sym_else, sym__AMP_, sym_oldform)), kw_doc, "bindings => binding-form test\n\n If test is not nil, evaluates then with binding-form bound to the\n value of test, if not, yields else", kw_file, "glojure/core.glj", kw_added, "1.6", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(1874), kw_end_DASH_line, int(1874))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -26352,23 +26860,21 @@ func LoadNS() { _ = v5 v6 := args[3] _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_seq) - tmp8 := checkDerefVar(glojure_DOT_core_concat) - tmp9 := checkDerefVar(glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("glojure.core/if-some")}) - tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_core_SLASH_if_DASH_some}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) tmp12 := lang.Apply(tmp11, []any{v5}) - tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) tmp14 := lang.Apply(tmp13, []any{v6}) - tmp15 := checkDerefVar(glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{nil}) tmp17 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp14, tmp16}) tmp18 := lang.Apply(tmp7, []any{tmp17}) return tmp18 default: - if len(args) < 5 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 5) v3 := args[0] _ = v3 v4 := args[1] @@ -26382,53 +26888,53 @@ func LoadNS() { var v8 any = lang.NewList(args[5:]...) _ = v8 var tmp9 any - tmp10 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp10 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) tmp11 := lang.Apply(tmp10, []any{v5}) if lang.IsTruthy(tmp11) { } else { - tmp12 := checkDerefVar(glojure_DOT_core_str) - tmp13 := checkDerefVar(glojure_DOT_core_first) + tmp12 := checkDerefVar(var_glojure_DOT_core_str) + tmp13 := checkDerefVar(var_glojure_DOT_core_first) tmp14 := lang.Apply(tmp13, []any{v3}) - tmp15 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) - tmp16 := checkDerefVar(glojure_DOT_core_meta) + tmp15 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp16 := checkDerefVar(var_glojure_DOT_core_meta) tmp17 := lang.Apply(tmp16, []any{v3}) - tmp18 := lang.Apply(lang.NewKeyword("line"), []any{tmp17}) + tmp18 := lang.Apply(kw_line, []any{tmp17}) tmp19 := lang.Apply(tmp12, []any{tmp14, " requires ", "a vector for its binding", " in ", tmp15, ":", tmp18}) tmp20 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp19}) panic(tmp20) } _ = tmp9 var tmp21 any - tmp22 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp22 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) tmp23 := lang.Apply(tmp22, []any{v8}) if lang.IsTruthy(tmp23) { } else { - tmp24 := checkDerefVar(glojure_DOT_core_str) - tmp25 := checkDerefVar(glojure_DOT_core_first) + tmp24 := checkDerefVar(var_glojure_DOT_core_str) + tmp25 := checkDerefVar(var_glojure_DOT_core_first) tmp26 := lang.Apply(tmp25, []any{v3}) - tmp27 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) - tmp28 := checkDerefVar(glojure_DOT_core_meta) + tmp27 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp28 := checkDerefVar(var_glojure_DOT_core_meta) tmp29 := lang.Apply(tmp28, []any{v3}) - tmp30 := lang.Apply(lang.NewKeyword("line"), []any{tmp29}) + tmp30 := lang.Apply(kw_line, []any{tmp29}) tmp31 := lang.Apply(tmp24, []any{tmp26, " requires ", "1 or 2 forms after binding vector", " in ", tmp27, ":", tmp30}) tmp32 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp31}) panic(tmp32) } _ = tmp21 var tmp33 any - tmp34 := checkDerefVar(glojure_DOT_core__EQ_) - tmp35 := checkDerefVar(glojure_DOT_core_count) + tmp34 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp35 := checkDerefVar(var_glojure_DOT_core_count) tmp36 := lang.Apply(tmp35, []any{v5}) tmp37 := lang.Apply(tmp34, []any{int64(2), tmp36}) if lang.IsTruthy(tmp37) { } else { - tmp38 := checkDerefVar(glojure_DOT_core_str) - tmp39 := checkDerefVar(glojure_DOT_core_first) + tmp38 := checkDerefVar(var_glojure_DOT_core_str) + tmp39 := checkDerefVar(var_glojure_DOT_core_first) tmp40 := lang.Apply(tmp39, []any{v3}) - tmp41 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) - tmp42 := checkDerefVar(glojure_DOT_core_meta) + tmp41 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp42 := checkDerefVar(var_glojure_DOT_core_meta) tmp43 := lang.Apply(tmp42, []any{v3}) - tmp44 := lang.Apply(lang.NewKeyword("line"), []any{tmp43}) + tmp44 := lang.Apply(kw_line, []any{tmp43}) tmp45 := lang.Apply(tmp38, []any{tmp40, " requires ", "exactly 2 forms in binding vector", " in ", tmp41, ":", tmp44}) tmp46 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp45}) panic(tmp46) @@ -26444,59 +26950,59 @@ func LoadNS() { tmp50 := lang.Apply(v5, []any{int64(1)}) var v51 any = tmp50 _ = v51 - tmp52 := checkDerefVar(glojure_DOT_core_seq) - tmp53 := checkDerefVar(glojure_DOT_core_concat) - tmp54 := checkDerefVar(glojure_DOT_core_list) - tmp55 := lang.Apply(tmp54, []any{lang.NewSymbol("glojure.core/let")}) - tmp56 := checkDerefVar(glojure_DOT_core_list) - tmp57 := checkDerefVar(glojure_DOT_core_apply) - tmp58 := checkDerefVar(glojure_DOT_core_vector) - tmp59 := checkDerefVar(glojure_DOT_core_seq) - tmp60 := checkDerefVar(glojure_DOT_core_concat) - tmp61 := checkDerefVar(glojure_DOT_core_list) - tmp62 := lang.Apply(tmp61, []any{lang.NewSymbol("temp__0__auto__")}) - tmp63 := checkDerefVar(glojure_DOT_core_list) + tmp52 := checkDerefVar(var_glojure_DOT_core_seq) + tmp53 := checkDerefVar(var_glojure_DOT_core_concat) + tmp54 := checkDerefVar(var_glojure_DOT_core_list) + tmp55 := lang.Apply(tmp54, []any{sym_glojure_DOT_core_SLASH_let}) + tmp56 := checkDerefVar(var_glojure_DOT_core_list) + tmp57 := checkDerefVar(var_glojure_DOT_core_apply) + tmp58 := checkDerefVar(var_glojure_DOT_core_vector) + tmp59 := checkDerefVar(var_glojure_DOT_core_seq) + tmp60 := checkDerefVar(var_glojure_DOT_core_concat) + tmp61 := checkDerefVar(var_glojure_DOT_core_list) + tmp62 := lang.Apply(tmp61, []any{sym_temp__0__auto__}) + tmp63 := checkDerefVar(var_glojure_DOT_core_list) tmp64 := lang.Apply(tmp63, []any{v51}) tmp65 := lang.Apply(tmp60, []any{tmp62, tmp64}) tmp66 := lang.Apply(tmp59, []any{tmp65}) tmp67 := lang.Apply(tmp57, []any{tmp58, tmp66}) tmp68 := lang.Apply(tmp56, []any{tmp67}) - tmp69 := checkDerefVar(glojure_DOT_core_list) - tmp70 := checkDerefVar(glojure_DOT_core_seq) - tmp71 := checkDerefVar(glojure_DOT_core_concat) - tmp72 := checkDerefVar(glojure_DOT_core_list) - tmp73 := lang.Apply(tmp72, []any{lang.NewSymbol("if")}) - tmp74 := checkDerefVar(glojure_DOT_core_list) - tmp75 := checkDerefVar(glojure_DOT_core_seq) - tmp76 := checkDerefVar(glojure_DOT_core_concat) - tmp77 := checkDerefVar(glojure_DOT_core_list) - tmp78 := lang.Apply(tmp77, []any{lang.NewSymbol("glojure.core/nil?")}) - tmp79 := checkDerefVar(glojure_DOT_core_list) - tmp80 := lang.Apply(tmp79, []any{lang.NewSymbol("temp__0__auto__")}) + tmp69 := checkDerefVar(var_glojure_DOT_core_list) + tmp70 := checkDerefVar(var_glojure_DOT_core_seq) + tmp71 := checkDerefVar(var_glojure_DOT_core_concat) + tmp72 := checkDerefVar(var_glojure_DOT_core_list) + tmp73 := lang.Apply(tmp72, []any{sym_if}) + tmp74 := checkDerefVar(var_glojure_DOT_core_list) + tmp75 := checkDerefVar(var_glojure_DOT_core_seq) + tmp76 := checkDerefVar(var_glojure_DOT_core_concat) + tmp77 := checkDerefVar(var_glojure_DOT_core_list) + tmp78 := lang.Apply(tmp77, []any{sym_glojure_DOT_core_SLASH_nil_QMARK_}) + tmp79 := checkDerefVar(var_glojure_DOT_core_list) + tmp80 := lang.Apply(tmp79, []any{sym_temp__0__auto__}) tmp81 := lang.Apply(tmp76, []any{tmp78, tmp80}) tmp82 := lang.Apply(tmp75, []any{tmp81}) tmp83 := lang.Apply(tmp74, []any{tmp82}) - tmp84 := checkDerefVar(glojure_DOT_core_list) + tmp84 := checkDerefVar(var_glojure_DOT_core_list) tmp85 := lang.Apply(tmp84, []any{v7}) - tmp86 := checkDerefVar(glojure_DOT_core_list) - tmp87 := checkDerefVar(glojure_DOT_core_seq) - tmp88 := checkDerefVar(glojure_DOT_core_concat) - tmp89 := checkDerefVar(glojure_DOT_core_list) - tmp90 := lang.Apply(tmp89, []any{lang.NewSymbol("glojure.core/let")}) - tmp91 := checkDerefVar(glojure_DOT_core_list) - tmp92 := checkDerefVar(glojure_DOT_core_apply) - tmp93 := checkDerefVar(glojure_DOT_core_vector) - tmp94 := checkDerefVar(glojure_DOT_core_seq) - tmp95 := checkDerefVar(glojure_DOT_core_concat) - tmp96 := checkDerefVar(glojure_DOT_core_list) + tmp86 := checkDerefVar(var_glojure_DOT_core_list) + tmp87 := checkDerefVar(var_glojure_DOT_core_seq) + tmp88 := checkDerefVar(var_glojure_DOT_core_concat) + tmp89 := checkDerefVar(var_glojure_DOT_core_list) + tmp90 := lang.Apply(tmp89, []any{sym_glojure_DOT_core_SLASH_let}) + tmp91 := checkDerefVar(var_glojure_DOT_core_list) + tmp92 := checkDerefVar(var_glojure_DOT_core_apply) + tmp93 := checkDerefVar(var_glojure_DOT_core_vector) + tmp94 := checkDerefVar(var_glojure_DOT_core_seq) + tmp95 := checkDerefVar(var_glojure_DOT_core_concat) + tmp96 := checkDerefVar(var_glojure_DOT_core_list) tmp97 := lang.Apply(tmp96, []any{v49}) - tmp98 := checkDerefVar(glojure_DOT_core_list) - tmp99 := lang.Apply(tmp98, []any{lang.NewSymbol("temp__0__auto__")}) + tmp98 := checkDerefVar(var_glojure_DOT_core_list) + tmp99 := lang.Apply(tmp98, []any{sym_temp__0__auto__}) tmp100 := lang.Apply(tmp95, []any{tmp97, tmp99}) tmp101 := lang.Apply(tmp94, []any{tmp100}) tmp102 := lang.Apply(tmp92, []any{tmp93, tmp101}) tmp103 := lang.Apply(tmp91, []any{tmp102}) - tmp104 := checkDerefVar(glojure_DOT_core_list) + tmp104 := checkDerefVar(var_glojure_DOT_core_list) tmp105 := lang.Apply(tmp104, []any{v6}) tmp106 := lang.Apply(tmp88, []any{tmp90, tmp103, tmp105}) tmp107 := lang.Apply(tmp87, []any{tmp106}) @@ -26511,7 +27017,7 @@ func LoadNS() { return tmp47 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -26519,19 +27025,17 @@ func LoadNS() { } // ifn? { - tmp0 := lang.NewSymbol("ifn?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements IFn. Note that many data structures\n (e.g. sets and maps) implement IFn", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6209), lang.NewKeyword("end-line"), int(6209))).(*lang.Symbol) + tmp0 := sym_ifn_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x implements IFn. Note that many data structures\n (e.g. sets and maps) implement IFn", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(6209), kw_end_DASH_line, int(6209))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp5 := lang.Apply(tmp4, []any{nil, v3}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -26539,14 +27043,12 @@ func LoadNS() { } // import { - tmp0 := lang.NewSymbol("import").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("import-symbols-or-lists"))), lang.NewKeyword("doc"), "import-list => (package-symbol class-name-symbols*)\n\n For each name in class-name-symbols, adds a mapping from name to the\n class named by package.name to the current namespace. Use :import in the ns\n macro in preference to calling this directly.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3426), lang.NewKeyword("end-line"), int(3426))).(*lang.Symbol) + tmp0 := sym_import.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_import_DASH_symbols_DASH_or_DASH_lists)), kw_doc, "import-list => (package-symbol class-name-symbols*)\n\n For each name in class-name-symbols, adds a mapping from name to the\n class named by package.name to the current namespace. Use :import in the ns\n macro in preference to calling this directly.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(11), kw_line, int(3426), kw_end_DASH_line, int(3426))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -26556,28 +27058,26 @@ func LoadNS() { var tmp6 any { // let // let binding "specs" - tmp7 := checkDerefVar(glojure_DOT_core_map) + tmp7 := checkDerefVar(var_glojure_DOT_core_map) var tmp8 lang.FnFunc tmp8 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v9 := args[0] _ = v9 var tmp10 any var tmp11 any { // let // let binding "and__0__auto__" - tmp12 := checkDerefVar(glojure_DOT_core_seq_QMARK_) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) tmp13 := lang.Apply(tmp12, []any{v9}) var v14 any = tmp13 _ = v14 var tmp15 any if lang.IsTruthy(v14) { - tmp16 := checkDerefVar(glojure_DOT_core__EQ_) - tmp17 := checkDerefVar(glojure_DOT_core_first) + tmp16 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp17 := checkDerefVar(var_glojure_DOT_core_first) tmp18 := lang.Apply(tmp17, []any{v9}) - tmp19 := lang.Apply(tmp16, []any{lang.NewSymbol("quote"), tmp18}) + tmp19 := lang.Apply(tmp16, []any{sym_quote, tmp18}) tmp15 = tmp19 } else { tmp15 = v14 @@ -26585,7 +27085,7 @@ func LoadNS() { tmp11 = tmp15 } // end let if lang.IsTruthy(tmp11) { - tmp12 := checkDerefVar(glojure_DOT_core_second) + tmp12 := checkDerefVar(var_glojure_DOT_core_second) tmp13 := lang.Apply(tmp12, []any{v9}) tmp10 = tmp13 } else { @@ -26593,7 +27093,7 @@ func LoadNS() { } return tmp10 }) - tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3434), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(3434), lang.NewKeyword("end-column"), int(73)) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3434), kw_column, int(20), kw_end_DASH_line, int(3434), kw_end_DASH_column, int(73)) tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) if err != nil { panic(err) @@ -26601,43 +27101,39 @@ func LoadNS() { tmp11 := lang.Apply(tmp7, []any{tmp10, v5}) var v12 any = tmp11 _ = v12 - tmp13 := checkDerefVar(glojure_DOT_core_seq) - tmp14 := checkDerefVar(glojure_DOT_core_concat) - tmp15 := checkDerefVar(glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("do")}) - tmp17 := checkDerefVar(glojure_DOT_core_map) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_do}) + tmp17 := checkDerefVar(var_glojure_DOT_core_map) var tmp18 lang.FnFunc tmp18 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v19 := args[0] _ = v19 - tmp20 := checkDerefVar(glojure_DOT_core_list) - tmp21 := lang.Apply(tmp20, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Import"), v19}) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Import, v19}) return tmp21 }) - tmp19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3436), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(3436), lang.NewKeyword("end-column"), int(73)) + tmp19 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3436), kw_column, int(17), kw_end_DASH_line, int(3436), kw_end_DASH_column, int(73)) tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp21 := checkDerefVar(glojure_DOT_core_reduce1) + tmp21 := checkDerefVar(var_glojure_DOT_core_reduce1) var tmp22 lang.FnFunc tmp22 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v23 := args[0] _ = v23 v24 := args[1] _ = v24 var tmp25 any - tmp26 := checkDerefVar(glojure_DOT_core_symbol_QMARK_) + tmp26 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) tmp27 := lang.Apply(tmp26, []any{v24}) if lang.IsTruthy(tmp27) { - tmp28 := checkDerefVar(glojure_DOT_core_conj) - tmp29 := checkDerefVar(glojure_DOT_core_name) + tmp28 := checkDerefVar(var_glojure_DOT_core_conj) + tmp29 := checkDerefVar(var_glojure_DOT_core_name) tmp30 := lang.Apply(tmp29, []any{v24}) tmp31 := lang.Apply(tmp28, []any{v23, tmp30}) tmp25 = tmp31 @@ -26645,29 +27141,27 @@ func LoadNS() { var tmp32 any { // let // let binding "p" - tmp33 := checkDerefVar(glojure_DOT_core_first) + tmp33 := checkDerefVar(var_glojure_DOT_core_first) tmp34 := lang.Apply(tmp33, []any{v24}) var v35 any = tmp34 _ = v35 // let binding "cs" - tmp36 := checkDerefVar(glojure_DOT_core_rest) + tmp36 := checkDerefVar(var_glojure_DOT_core_rest) tmp37 := lang.Apply(tmp36, []any{v24}) var v38 any = tmp37 _ = v38 - tmp39 := checkDerefVar(glojure_DOT_core_into1) - tmp40 := checkDerefVar(glojure_DOT_core_map) + tmp39 := checkDerefVar(var_glojure_DOT_core_into1) + tmp40 := checkDerefVar(var_glojure_DOT_core_map) var tmp41 lang.FnFunc tmp41 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v42 := args[0] _ = v42 - tmp43 := checkDerefVar(glojure_DOT_core_str) + tmp43 := checkDerefVar(var_glojure_DOT_core_str) tmp44 := lang.Apply(tmp43, []any{v35, ".", v42}) return tmp44 }) - tmp42 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3441), lang.NewKeyword("column"), int(45), lang.NewKeyword("end-line"), int(3441), lang.NewKeyword("end-column"), int(58)) + tmp42 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3441), kw_column, int(45), kw_end_DASH_line, int(3441), kw_end_DASH_column, int(58)) tmp43, err := lang.WithMeta(tmp41, tmp42.(lang.IPersistentMap)) if err != nil { panic(err) @@ -26680,13 +27174,13 @@ func LoadNS() { } return tmp25 }) - tmp23 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3437), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(3441), lang.NewKeyword("end-column"), int(66)) + tmp23 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3437), kw_column, int(26), kw_end_DASH_line, int(3441), kw_end_DASH_column, int(66)) tmp24, err := lang.WithMeta(tmp22, tmp23.(lang.IPersistentMap)) if err != nil { panic(err) } tmp25 := lang.NewVector() - tmp26 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3442), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(3442), lang.NewKeyword("end-column"), int(26)) + tmp26 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3442), kw_column, int(25), kw_end_DASH_line, int(3442), kw_end_DASH_column, int(26)) tmp27, err := lang.WithMeta(tmp25, tmp26.(lang.IPersistentMap)) if err != nil { panic(err) @@ -26700,7 +27194,7 @@ func LoadNS() { return tmp6 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -26712,30 +27206,28 @@ func LoadNS() { { // function inc__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) - tmp5 := checkDerefVar(glojure_DOT_core_concat) - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := checkDerefVar(glojure_DOT_core_seq) - tmp12 := checkDerefVar(glojure_DOT_core_concat) - tmp13 := checkDerefVar(glojure_DOT_core_list) + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) var tmp14 any - tmp15 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + tmp15 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp15) { - tmp14 = lang.NewSymbol("unchecked_inc") + tmp14 = sym_unchecked_inc } else { - tmp14 = lang.NewSymbol("inc") + tmp14 = sym_inc } tmp16 := lang.Apply(tmp13, []any{tmp14}) - tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) tmp18 := lang.Apply(tmp17, []any{v3}) tmp19 := lang.Apply(tmp12, []any{tmp16, tmp18}) tmp20 := lang.Apply(tmp11, []any{tmp19}) @@ -26747,12 +27239,10 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("inc").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns a number one greater than num. Does not auto-promote\n longs, will throw on overflow. See also: inc'", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(915), lang.NewKeyword("end-line"), int(915))).(*lang.Symbol) + tmp0 := sym_inc.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns a number one greater than num. Does not auto-promote\n longs, will throw on overflow. See also: inc'", kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(915), kw_end_DASH_line, int(915))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Inc") @@ -26762,7 +27252,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v4}) return tmp6 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -26774,23 +27264,21 @@ func LoadNS() { { // function inc'__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) - tmp5 := checkDerefVar(glojure_DOT_core_concat) - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := checkDerefVar(glojure_DOT_core_seq) - tmp12 := checkDerefVar(glojure_DOT_core_concat) - tmp13 := checkDerefVar(glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/IncP")}) - tmp15 := checkDerefVar(glojure_DOT_core_list) + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_IncP}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) tmp18 := lang.Apply(tmp11, []any{tmp17}) @@ -26802,12 +27290,10 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("inc'").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns a number one greater than num. Supports arbitrary precision.\n See also: inc", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(908), lang.NewKeyword("end-line"), int(908))).(*lang.Symbol) + tmp0 := sym_inc_TICK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns a number one greater than num. Supports arbitrary precision.\n See also: inc", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(908), kw_end_DASH_line, int(908))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 tmp5, _ := lang.FieldOrMethod(lang.Numbers, "IncP") @@ -26817,7 +27303,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v4}) return tmp6 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -26825,19 +27311,17 @@ func LoadNS() { } // indexed? { - tmp0 := lang.NewSymbol("indexed?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return true if coll implements Indexed, indicating efficient lookup by index", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6263), lang.NewKeyword("end-line"), int(6263))).(*lang.Symbol) + tmp0 := sym_indexed_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Return true if coll implements Indexed, indicating efficient lookup by index", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(6263), kw_end_DASH_line, int(6263))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp5 := lang.Apply(tmp4, []any{nil, v3}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -26849,16 +27333,14 @@ func LoadNS() { { // function infinite?__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) - tmp5 := checkDerefVar(glojure_DOT_core_concat) - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol("Double/isInfinite")}) - tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym_Double_SLASH_isInfinite}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{v3}) tmp10 := lang.Apply(tmp5, []any{tmp7, tmp9}) tmp11 := lang.Apply(tmp4, []any{tmp10}) @@ -26867,18 +27349,16 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("infinite?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns true if num is negative or positive infinity, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1)})), lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7977), lang.NewKeyword("end-line"), int(7977))).(*lang.Symbol) + tmp0 := sym_infinite_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_num)), kw_inline, tmp1, kw_doc, "Returns true if num is negative or positive infinity, else false", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1)})), kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(7977), kw_end_DASH_line, int(7977))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 tmp5 := lang.Apply(nil, []any{v4}) return tmp5 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -26886,18 +27366,16 @@ func LoadNS() { } // inst-ms { - tmp0 := lang.NewSymbol("inst-ms").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("inst"))), lang.NewKeyword("doc"), "Return the number of milliseconds since January 1, 1970, 00:00:00 GMT", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6831), lang.NewKeyword("end-line"), int(6831))).(*lang.Symbol) + tmp0 := sym_inst_DASH_ms.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_inst)), kw_doc, "Return the number of milliseconds since January 1, 1970, 00:00:00 GMT", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(6831), kw_end_DASH_line, int(6831))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4 := lang.Apply(nil, []any{v3}) return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -26905,17 +27383,15 @@ func LoadNS() { } // inst? { - tmp0 := lang.NewSymbol("inst?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x satisfies Inst", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6837), lang.NewKeyword("end-line"), int(6837))).(*lang.Symbol) + tmp0 := sym_inst_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x satisfies Inst", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(6837), kw_end_DASH_line, int(6837))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 return nil }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -26923,14 +27399,12 @@ func LoadNS() { } // instance? { - tmp0 := lang.NewSymbol("instance?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("c"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Evaluates x and tests if it is an instance of the type\n t. Returns true or false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(139), lang.NewKeyword("end-line"), int(143))).(*lang.Symbol) + tmp0 := sym_instance_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_c, sym_x)), kw_doc, "Evaluates x and tests if it is an instance of the type\n t. Returns true or false", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(2), kw_line, int(139), kw_end_DASH_line, int(143))).(*lang.Symbol) var tmp2 lang.FnFunc { // function instance? var v3 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -26938,7 +27412,7 @@ func LoadNS() { tmp6 := lang.Apply(lang.HasType, []any{v4, v5}) return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(143), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(143), lang.NewKeyword("end-column"), int(85))).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(143), kw_column, int(12), kw_end_DASH_line, int(143), kw_end_DASH_column, int(85))).(lang.FnFunc) v3 = tmp2 _ = v3 } @@ -26953,30 +27427,28 @@ func LoadNS() { { // function int__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) - tmp5 := checkDerefVar(glojure_DOT_core_concat) - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := checkDerefVar(glojure_DOT_core_seq) - tmp12 := checkDerefVar(glojure_DOT_core_concat) - tmp13 := checkDerefVar(glojure_DOT_core_list) + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) var tmp14 any - tmp15 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + tmp15 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp15) { - tmp14 = lang.NewSymbol("uncheckedIntCast") + tmp14 = sym_uncheckedIntCast } else { - tmp14 = lang.NewSymbol("intCast") + tmp14 = sym_intCast } tmp16 := lang.Apply(tmp13, []any{tmp14}) - tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) tmp18 := lang.Apply(tmp17, []any{v3}) tmp19 := lang.Apply(tmp12, []any{tmp16, tmp18}) tmp20 := lang.Apply(tmp11, []any{tmp19}) @@ -26988,12 +27460,10 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to int", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(875), lang.NewKeyword("end-line"), int(875))).(*lang.Symbol) + tmp0 := sym_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to int", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(875), kw_end_DASH_line, int(875))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 tmp5, _ := lang.FieldOrMethod(runtime7.RT, "IntCast") @@ -27003,7 +27473,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v4}) return tmp6 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -27017,26 +27487,24 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) - tmp5 := checkDerefVar(glojure_DOT_core_concat) - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol("glojure.core/IntArray")}) - tmp12 := checkDerefVar(glojure_DOT_core_list) - tmp13 := checkDerefVar(glojure_DOT_core_seq) - tmp14 := checkDerefVar(glojure_DOT_core_concat) - tmp15 := checkDerefVar(glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) - tmp17 := checkDerefVar(glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("glojure.core/args")}) + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_IntArray}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_unquote_DASH_splicing}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_glojure_DOT_core_SLASH_args}) tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) tmp20 := lang.Apply(tmp13, []any{tmp19}) tmp21 := lang.Apply(tmp12, []any{tmp20}) @@ -27048,7 +27516,7 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("int-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Creates an array of ints", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5356), lang.NewKeyword("end-line"), int(5356))).(*lang.Symbol) + tmp0 := sym_int_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_size_DASH_or_DASH_seq), lang.NewVector(sym_size, sym_init_DASH_val_DASH_or_DASH_seq)), kw_inline, tmp1, kw_doc, "Creates an array of ints", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(5356), kw_end_DASH_line, int(5356))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -27073,10 +27541,11 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -27084,18 +27553,16 @@ func LoadNS() { } // int? { - tmp0 := lang.NewSymbol("int?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a fixed precision integer", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1395), lang.NewKeyword("end-line"), int(1395))).(*lang.Symbol) + tmp0 := sym_int_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a fixed precision integer", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1395), kw_end_DASH_line, int(1395))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any { // let // let binding "or__0__auto__" - tmp5 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp6 := lang.Apply(tmp5, []any{lang.Builtins["int64"], v3}) var v7 any = tmp6 _ = v7 @@ -27106,7 +27573,7 @@ func LoadNS() { var tmp9 any { // let // let binding "or__0__auto__" - tmp10 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp10 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp11 := lang.Apply(tmp10, []any{nil, v3}) var v12 any = tmp11 _ = v12 @@ -27117,7 +27584,7 @@ func LoadNS() { var tmp14 any { // let // let binding "or__0__auto__" - tmp15 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp15 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp16 := lang.Apply(tmp15, []any{nil, v3}) var v17 any = tmp16 _ = v17 @@ -27125,7 +27592,7 @@ func LoadNS() { if lang.IsTruthy(v17) { tmp18 = v17 } else { - tmp19 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp19 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp20 := lang.Apply(tmp19, []any{nil, v3}) tmp18 = tmp20 } @@ -27141,7 +27608,7 @@ func LoadNS() { } // end let return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -27149,18 +27616,16 @@ func LoadNS() { } // integer? { - tmp0 := lang.NewSymbol("integer?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is an integer", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1379), lang.NewKeyword("end-line"), int(1379))).(*lang.Symbol) + tmp0 := sym_integer_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_doc, "Returns true if n is an integer", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(1379), kw_end_DASH_line, int(1379))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4 := lang.Apply(lang.IsInteger, []any{v3}) return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -27168,7 +27633,7 @@ func LoadNS() { } // interleave { - tmp0 := lang.NewSymbol("interleave").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("c1")), lang.NewVector(lang.NewSymbol("c1"), lang.NewSymbol("c2")), lang.NewVector(lang.NewSymbol("c1"), lang.NewSymbol("c2"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Returns a lazy seq of the first item in each coll, then the second etc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4308), lang.NewKeyword("end-line"), int(4308))).(*lang.Symbol) + tmp0 := sym_interleave.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_c1), lang.NewVector(sym_c1, sym_c2), lang.NewVector(sym_c1, sym_c2, sym__AMP_, sym_colls)), kw_doc, "Returns a lazy seq of the first item in each coll, then the second etc.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4308), kw_end_DASH_line, int(4308))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -27179,9 +27644,7 @@ func LoadNS() { _ = v3 var tmp4 lang.FnFunc tmp4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) return v3 }) tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) @@ -27193,18 +27656,16 @@ func LoadNS() { _ = v4 var tmp5 lang.FnFunc tmp5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var tmp6 any { // let // let binding "s1" - tmp7 := checkDerefVar(glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) tmp8 := lang.Apply(tmp7, []any{v3}) var v9 any = tmp8 _ = v9 // let binding "s2" - tmp10 := checkDerefVar(glojure_DOT_core_seq) + tmp10 := checkDerefVar(var_glojure_DOT_core_seq) tmp11 := lang.Apply(tmp10, []any{v4}) var v12 any = tmp11 _ = v12 @@ -27223,16 +27684,16 @@ func LoadNS() { tmp14 = tmp16 } // end let if lang.IsTruthy(tmp14) { - tmp15 := checkDerefVar(glojure_DOT_core_cons) - tmp16 := checkDerefVar(glojure_DOT_core_first) + tmp15 := checkDerefVar(var_glojure_DOT_core_cons) + tmp16 := checkDerefVar(var_glojure_DOT_core_first) tmp17 := lang.Apply(tmp16, []any{v9}) - tmp18 := checkDerefVar(glojure_DOT_core_cons) - tmp19 := checkDerefVar(glojure_DOT_core_first) + tmp18 := checkDerefVar(var_glojure_DOT_core_cons) + tmp19 := checkDerefVar(var_glojure_DOT_core_first) tmp20 := lang.Apply(tmp19, []any{v12}) - tmp21 := checkDerefVar(glojure_DOT_core_interleave) - tmp22 := checkDerefVar(glojure_DOT_core_rest) + tmp21 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp22 := checkDerefVar(var_glojure_DOT_core_rest) tmp23 := lang.Apply(tmp22, []any{v9}) - tmp24 := checkDerefVar(glojure_DOT_core_rest) + tmp24 := checkDerefVar(var_glojure_DOT_core_rest) tmp25 := lang.Apply(tmp24, []any{v12}) tmp26 := lang.Apply(tmp21, []any{tmp23, tmp25}) tmp27 := lang.Apply(tmp18, []any{tmp20, tmp26}) @@ -27247,9 +27708,7 @@ func LoadNS() { tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) return tmp6 default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -27258,32 +27717,30 @@ func LoadNS() { _ = v5 var tmp6 lang.FnFunc tmp6 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var tmp7 any { // let // let binding "ss" - tmp8 := checkDerefVar(glojure_DOT_core_map) - tmp9 := checkDerefVar(glojure_DOT_core_seq) - tmp10 := checkDerefVar(glojure_DOT_core_conj) + tmp8 := checkDerefVar(var_glojure_DOT_core_map) + tmp9 := checkDerefVar(var_glojure_DOT_core_seq) + tmp10 := checkDerefVar(var_glojure_DOT_core_conj) tmp11 := lang.Apply(tmp10, []any{v5, v4, v3}) tmp12 := lang.Apply(tmp8, []any{tmp9, tmp11}) var v13 any = tmp12 _ = v13 var tmp14 any - tmp15 := checkDerefVar(glojure_DOT_core_every_QMARK_) - tmp16 := checkDerefVar(glojure_DOT_core_identity) + tmp15 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + tmp16 := checkDerefVar(var_glojure_DOT_core_identity) tmp17 := lang.Apply(tmp15, []any{tmp16, v13}) if lang.IsTruthy(tmp17) { - tmp18 := checkDerefVar(glojure_DOT_core_concat) - tmp19 := checkDerefVar(glojure_DOT_core_map) - tmp20 := checkDerefVar(glojure_DOT_core_first) + tmp18 := checkDerefVar(var_glojure_DOT_core_concat) + tmp19 := checkDerefVar(var_glojure_DOT_core_map) + tmp20 := checkDerefVar(var_glojure_DOT_core_first) tmp21 := lang.Apply(tmp19, []any{tmp20, v13}) - tmp22 := checkDerefVar(glojure_DOT_core_apply) - tmp23 := checkDerefVar(glojure_DOT_core_interleave) - tmp24 := checkDerefVar(glojure_DOT_core_map) - tmp25 := checkDerefVar(glojure_DOT_core_rest) + tmp22 := checkDerefVar(var_glojure_DOT_core_apply) + tmp23 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp24 := checkDerefVar(var_glojure_DOT_core_map) + tmp25 := checkDerefVar(var_glojure_DOT_core_rest) tmp26 := lang.Apply(tmp24, []any{tmp25, v13}) tmp27 := lang.Apply(tmp22, []any{tmp23, tmp26}) tmp28 := lang.Apply(tmp18, []any{tmp21, tmp27}) @@ -27298,7 +27755,7 @@ func LoadNS() { return tmp7 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -27306,7 +27763,7 @@ func LoadNS() { } // intern { - tmp0 := lang.NewSymbol("intern").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name"), lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Finds or creates a var named by the symbol name in the namespace\n ns (which can be a symbol or a namespace), setting its root binding\n to val if supplied. The namespace must exist. The var will adopt any\n metadata from the name symbol. Returns the var.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6311), lang.NewKeyword("end-line"), int(6311))).(*lang.Symbol) + tmp0 := sym_intern.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns, sym_name), lang.NewVector(sym_ns, sym_name, sym_val)), kw_doc, "Finds or creates a var named by the symbol name in the namespace\n ns (which can be a symbol or a namespace), setting its root binding\n to val if supplied. The namespace must exist. The var will adopt any\n metadata from the name symbol. Returns the var.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(6311), kw_end_DASH_line, int(6311))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -27318,16 +27775,16 @@ func LoadNS() { var tmp5 any { // let // let binding "v" - tmp6 := checkDerefVar(glojure_DOT_core_the_ns) + tmp6 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) tmp7 := lang.Apply(tmp6, []any{v3}) tmp8 := lang.Apply(nil, []any{tmp7, v4}) var v9 any = tmp8 _ = v9 var tmp10 any - tmp11 := checkDerefVar(glojure_DOT_core_meta) + tmp11 := checkDerefVar(var_glojure_DOT_core_meta) tmp12 := lang.Apply(tmp11, []any{v4}) if lang.IsTruthy(tmp12) { - tmp13 := checkDerefVar(glojure_DOT_core_meta) + tmp13 := checkDerefVar(var_glojure_DOT_core_meta) tmp14 := lang.Apply(tmp13, []any{v4}) tmp15, _ := lang.FieldOrMethod(v9, "setMeta") if reflect.TypeOf(tmp15).Kind() != reflect.Func { @@ -27351,16 +27808,16 @@ func LoadNS() { var tmp6 any { // let // let binding "v" - tmp7 := checkDerefVar(glojure_DOT_core_the_ns) + tmp7 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) tmp8 := lang.Apply(tmp7, []any{v3}) tmp9 := lang.Apply(nil, []any{tmp8, v4, v5}) var v10 any = tmp9 _ = v10 var tmp11 any - tmp12 := checkDerefVar(glojure_DOT_core_meta) + tmp12 := checkDerefVar(var_glojure_DOT_core_meta) tmp13 := lang.Apply(tmp12, []any{v4}) if lang.IsTruthy(tmp13) { - tmp14 := checkDerefVar(glojure_DOT_core_meta) + tmp14 := checkDerefVar(var_glojure_DOT_core_meta) tmp15 := lang.Apply(tmp14, []any{v4}) tmp16, _ := lang.FieldOrMethod(v10, "setMeta") if reflect.TypeOf(tmp16).Kind() != reflect.Func { @@ -27375,10 +27832,11 @@ func LoadNS() { } // end let return tmp6 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -27386,7 +27844,7 @@ func LoadNS() { } // interpose { - tmp0 := lang.NewSymbol("interpose").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sep")), lang.NewVector(lang.NewSymbol("sep"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy seq of the elements of coll separated by sep.\n Returns a stateful transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5230), lang.NewKeyword("end-line"), int(5230))).(*lang.Symbol) + tmp0 := sym_interpose.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_sep), lang.NewVector(sym_sep, sym_coll)), kw_doc, "Returns a lazy seq of the elements of coll separated by sep.\n Returns a stateful transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(5230), kw_end_DASH_line, int(5230))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -27395,15 +27853,13 @@ func LoadNS() { _ = v3 var tmp4 lang.FnFunc tmp4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v5 := args[0] _ = v5 var tmp6 any { // let // let binding "started" - tmp7 := checkDerefVar(glojure_DOT_core_volatile_BANG_) + tmp7 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) tmp8 := lang.Apply(tmp7, []any{false}) var v9 any = tmp8 _ = v9 @@ -27424,7 +27880,7 @@ func LoadNS() { v12 := args[1] _ = v12 var tmp13 any - tmp14 := checkDerefVar(glojure_DOT_core_deref) + tmp14 := checkDerefVar(var_glojure_DOT_core_deref) tmp15 := lang.Apply(tmp14, []any{v9}) if lang.IsTruthy(tmp15) { var tmp16 any @@ -27434,7 +27890,7 @@ func LoadNS() { var v18 any = tmp17 _ = v18 var tmp19 any - tmp20 := checkDerefVar(glojure_DOT_core_reduced_QMARK_) + tmp20 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) tmp21 := lang.Apply(tmp20, []any{v18}) if lang.IsTruthy(tmp21) { tmp19 = v18 @@ -27446,7 +27902,7 @@ func LoadNS() { } // end let tmp13 = tmp16 } else { - tmp17 := checkDerefVar(glojure_DOT_core_vreset_BANG_) + tmp17 := checkDerefVar(var_glojure_DOT_core_vreset_BANG_) tmp18 := lang.Apply(tmp17, []any{v9, true}) _ = tmp18 tmp19 := lang.Apply(v5, []any{v11, v12}) @@ -27454,10 +27910,11 @@ func LoadNS() { } return tmp13 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5238), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(5249), lang.NewKeyword("end-column"), int(35)) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5238), kw_column, int(8), kw_end_DASH_line, int(5249), kw_end_DASH_column, int(35)) tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) if err != nil { panic(err) @@ -27466,7 +27923,7 @@ func LoadNS() { } // end let return tmp6 }) - tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5236), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(5249), lang.NewKeyword("end-column"), int(37)) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5236), kw_column, int(4), kw_end_DASH_line, int(5249), kw_end_DASH_column, int(37)) tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) if err != nil { panic(err) @@ -27477,18 +27934,19 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_drop) - tmp6 := checkDerefVar(glojure_DOT_core_interleave) - tmp7 := checkDerefVar(glojure_DOT_core_repeat) + tmp5 := checkDerefVar(var_glojure_DOT_core_drop) + tmp6 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp7 := checkDerefVar(var_glojure_DOT_core_repeat) tmp8 := lang.Apply(tmp7, []any{v3}) tmp9 := lang.Apply(tmp6, []any{tmp8, v4}) tmp10 := lang.Apply(tmp5, []any{int64(1), tmp9}) return tmp10 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -27496,13 +27954,13 @@ func LoadNS() { } // into { - tmp0 := lang.NewSymbol("into").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("to")), lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("from")), lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("xform"), lang.NewSymbol("from"))), lang.NewKeyword("doc"), "Returns a new coll consisting of to with all of the items of\n from conjoined. A transducer may be supplied.\n (into x) returns x. (into) returns [].", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6922), lang.NewKeyword("end-line"), int(6922))).(*lang.Symbol) + tmp0 := sym_into.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_to), lang.NewVector(sym_to, sym_from), lang.NewVector(sym_to, sym_xform, sym_from)), kw_doc, "Returns a new coll consisting of to with all of the items of\n from conjoined. A transducer may be supplied.\n (into x) returns x. (into) returns [].", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(6922), kw_end_DASH_line, int(6922))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: tmp3 := lang.NewVector() - tmp4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6928), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(6928), lang.NewKeyword("end-column"), int(8)) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6928), kw_column, int(7), kw_end_DASH_line, int(6928), kw_end_DASH_column, int(8)) tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) if err != nil { panic(err) @@ -27518,25 +27976,25 @@ func LoadNS() { v4 := args[1] _ = v4 var tmp5 any - tmp6 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp6 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp7 := reflect.TypeOf((*lang.IEditableCollection)(nil)).Elem() tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) if lang.IsTruthy(tmp8) { - tmp9 := checkDerefVar(glojure_DOT_core_with_meta) - tmp10 := checkDerefVar(glojure_DOT_core_persistent_BANG_) - tmp11 := checkDerefVar(glojure_DOT_core_reduce) - tmp12 := checkDerefVar(glojure_DOT_core_conj_BANG_) - tmp13 := checkDerefVar(glojure_DOT_core_transient) + tmp9 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp10 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp11 := checkDerefVar(var_glojure_DOT_core_reduce) + tmp12 := checkDerefVar(var_glojure_DOT_core_conj_BANG_) + tmp13 := checkDerefVar(var_glojure_DOT_core_transient) tmp14 := lang.Apply(tmp13, []any{v3}) tmp15 := lang.Apply(tmp11, []any{tmp12, tmp14, v4}) tmp16 := lang.Apply(tmp10, []any{tmp15}) - tmp17 := checkDerefVar(glojure_DOT_core_meta) + tmp17 := checkDerefVar(var_glojure_DOT_core_meta) tmp18 := lang.Apply(tmp17, []any{v3}) tmp19 := lang.Apply(tmp9, []any{tmp16, tmp18}) tmp5 = tmp19 } else { - tmp20 := checkDerefVar(glojure_DOT_core_reduce) - tmp21 := checkDerefVar(glojure_DOT_core_conj) + tmp20 := checkDerefVar(var_glojure_DOT_core_reduce) + tmp21 := checkDerefVar(var_glojure_DOT_core_conj) tmp22 := lang.Apply(tmp20, []any{tmp21, v3, v4}) tmp5 = tmp22 } @@ -27549,14 +28007,14 @@ func LoadNS() { v5 := args[2] _ = v5 var tmp6 any - tmp7 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp7 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp8 := reflect.TypeOf((*lang.IEditableCollection)(nil)).Elem() tmp9 := lang.Apply(tmp7, []any{tmp8, v3}) if lang.IsTruthy(tmp9) { var tmp10 any { // let // let binding "tm" - tmp11 := checkDerefVar(glojure_DOT_core_meta) + tmp11 := checkDerefVar(var_glojure_DOT_core_meta) tmp12 := lang.Apply(tmp11, []any{v3}) var v13 any = tmp12 _ = v13 @@ -27567,8 +28025,8 @@ func LoadNS() { case 1: v15 := args[0] _ = v15 - tmp16 := checkDerefVar(glojure_DOT_core_with_meta) - tmp17 := checkDerefVar(glojure_DOT_core_persistent_BANG_) + tmp16 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp17 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) tmp18 := lang.Apply(tmp17, []any{v15}) tmp19 := lang.Apply(tmp16, []any{tmp18, v13}) return tmp19 @@ -27577,39 +28035,41 @@ func LoadNS() { _ = v15 v16 := args[1] _ = v16 - tmp17 := checkDerefVar(glojure_DOT_core_conj_BANG_) + tmp17 := checkDerefVar(var_glojure_DOT_core_conj_BANG_) tmp18 := lang.Apply(tmp17, []any{v15, v16}) return tmp18 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6937), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(6939), lang.NewKeyword("end-column"), int(44)) + tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6937), kw_column, int(17), kw_end_DASH_line, int(6939), kw_end_DASH_column, int(44)) tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) if err != nil { panic(err) } var v17 any = tmp16 _ = v17 - tmp18 := checkDerefVar(glojure_DOT_core_transduce) - tmp19 := checkDerefVar(glojure_DOT_core_transient) + tmp18 := checkDerefVar(var_glojure_DOT_core_transduce) + tmp19 := checkDerefVar(var_glojure_DOT_core_transient) tmp20 := lang.Apply(tmp19, []any{v3}) tmp21 := lang.Apply(tmp18, []any{v4, v17, tmp20, v5}) tmp10 = tmp21 } // end let tmp6 = tmp10 } else { - tmp11 := checkDerefVar(glojure_DOT_core_transduce) - tmp12 := checkDerefVar(glojure_DOT_core_conj) + tmp11 := checkDerefVar(var_glojure_DOT_core_transduce) + tmp12 := checkDerefVar(var_glojure_DOT_core_conj) tmp13 := lang.Apply(tmp11, []any{v4, tmp12, v3, v5}) tmp6 = tmp13 } return tmp6 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -27617,14 +28077,14 @@ func LoadNS() { } // into-array { - tmp0 := lang.NewSymbol("into-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("aseq")), lang.NewVector(lang.NewSymbol("type"), lang.NewSymbol("aseq"))), lang.NewKeyword("doc"), "Returns an array with components set to the values in aseq. The array's\n component type is type if provided, or the type of the first value in\n aseq if present, or Object. All values in aseq must be compatible with\n the component type. Class objects for the primitive types can be obtained\n using, e.g., Integer/TYPE.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3444), lang.NewKeyword("end-line"), int(3444))).(*lang.Symbol) + tmp0 := sym_into_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_aseq), lang.NewVector(sym_type, sym_aseq)), kw_doc, "Returns an array with components set to the values in aseq. The array's\n component type is type if provided, or the type of the first value in\n aseq if present, or Object. All values in aseq must be compatible with\n the component type. Class objects for the primitive types can be obtained\n using, e.g., Integer/TYPE.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(3444), kw_end_DASH_line, int(3444))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) tmp5 := lang.Apply(tmp4, []any{v3}) tmp6 := lang.Apply(nil, []any{tmp5}) return tmp6 @@ -27633,15 +28093,16 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) tmp6 := lang.Apply(tmp5, []any{v4}) tmp7 := lang.Apply(nil, []any{v3, tmp6}) return tmp7 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -27649,38 +28110,36 @@ func LoadNS() { } // into1 { - tmp0 := lang.NewSymbol("into1").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("from"))), lang.NewKeyword("doc"), "Returns a new coll consisting of to-coll with all of the items of\n from-coll conjoined.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3416), lang.NewKeyword("end-line"), int(3416), lang.NewKeyword("private"), true)).(*lang.Symbol) + tmp0 := sym_into1.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_to, sym_from)), kw_doc, "Returns a new coll consisting of to-coll with all of the items of\n from-coll conjoined.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(3416), kw_end_DASH_line, int(3416), kw_private, true)).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 var tmp5 any - tmp6 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp6 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp7 := reflect.TypeOf((*lang.IEditableCollection)(nil)).Elem() tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) if lang.IsTruthy(tmp8) { - tmp9 := checkDerefVar(glojure_DOT_core_persistent_BANG_) - tmp10 := checkDerefVar(glojure_DOT_core_reduce1) - tmp11 := checkDerefVar(glojure_DOT_core_conj_BANG_) - tmp12 := checkDerefVar(glojure_DOT_core_transient) + tmp9 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp10 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp11 := checkDerefVar(var_glojure_DOT_core_conj_BANG_) + tmp12 := checkDerefVar(var_glojure_DOT_core_transient) tmp13 := lang.Apply(tmp12, []any{v3}) tmp14 := lang.Apply(tmp10, []any{tmp11, tmp13, v4}) tmp15 := lang.Apply(tmp9, []any{tmp14}) tmp5 = tmp15 } else { - tmp16 := checkDerefVar(glojure_DOT_core_reduce1) - tmp17 := checkDerefVar(glojure_DOT_core_conj) + tmp16 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp17 := checkDerefVar(var_glojure_DOT_core_conj) tmp18 := lang.Apply(tmp16, []any{tmp17, v3, v4}) tmp5 = tmp18 } return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -27692,20 +28151,18 @@ func LoadNS() { { // function ints var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) - tmp5 := checkDerefVar(glojure_DOT_core_concat) - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol("glojure.core/Ints")}) - tmp12 := checkDerefVar(glojure_DOT_core_list) + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Ints}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := lang.Apply(tmp12, []any{v3}) tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) tmp15 := lang.Apply(tmp4, []any{tmp14}) @@ -27714,12 +28171,10 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("ints").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Casts to int[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5397), lang.NewKeyword("end-line"), int(5397))).(*lang.Symbol) + tmp0 := sym_ints.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xs)), kw_inline, tmp1, kw_doc, "Casts to int[]", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(12), kw_line, int(5397), kw_end_DASH_line, int(5397))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Ints") @@ -27729,7 +28184,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v4}) return tmp6 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -27737,14 +28192,12 @@ func LoadNS() { } // io! { - tmp0 := lang.NewSymbol("io!").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "If an io! block occurs in a transaction, throws an\n IllegalStateException, else runs body in an implicit do. If the\n first expression in body is a literal string, will use that as the\n exception message.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(2504), lang.NewKeyword("end-line"), int(2504))).(*lang.Symbol) + tmp0 := sym_io_BANG_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_body)), kw_doc, "If an io! block occurs in a transaction, throws an\n IllegalStateException, else runs body in an implicit do. If the\n first expression in body is a literal string, will use that as the\n exception message.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(11), kw_line, int(2504), kw_end_DASH_line, int(2504))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -27755,12 +28208,12 @@ func LoadNS() { { // let // let binding "message" var tmp7 any - tmp8 := checkDerefVar(glojure_DOT_core_string_QMARK_) - tmp9 := checkDerefVar(glojure_DOT_core_first) + tmp8 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp9 := checkDerefVar(var_glojure_DOT_core_first) tmp10 := lang.Apply(tmp9, []any{v5}) tmp11 := lang.Apply(tmp8, []any{tmp10}) if lang.IsTruthy(tmp11) { - tmp12 := checkDerefVar(glojure_DOT_core_first) + tmp12 := checkDerefVar(var_glojure_DOT_core_first) tmp13 := lang.Apply(tmp12, []any{v5}) tmp7 = tmp13 } else { @@ -27770,7 +28223,7 @@ func LoadNS() { // let binding "body" var tmp15 any if lang.IsTruthy(v14) { - tmp16 := checkDerefVar(glojure_DOT_core_next) + tmp16 := checkDerefVar(var_glojure_DOT_core_next) tmp17 := lang.Apply(tmp16, []any{v5}) tmp15 = tmp17 } else { @@ -27778,31 +28231,31 @@ func LoadNS() { } var v18 any = tmp15 _ = v18 - tmp19 := checkDerefVar(glojure_DOT_core_seq) - tmp20 := checkDerefVar(glojure_DOT_core_concat) - tmp21 := checkDerefVar(glojure_DOT_core_list) - tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("if")}) - tmp23 := checkDerefVar(glojure_DOT_core_list) - tmp24 := checkDerefVar(glojure_DOT_core_seq) - tmp25 := checkDerefVar(glojure_DOT_core_concat) - tmp26 := checkDerefVar(glojure_DOT_core_list) - tmp27 := lang.Apply(tmp26, []any{lang.NewSymbol("glojure.lang.LockingTransaction/isRunning")}) + tmp19 := checkDerefVar(var_glojure_DOT_core_seq) + tmp20 := checkDerefVar(var_glojure_DOT_core_concat) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{sym_if}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_seq) + tmp25 := checkDerefVar(var_glojure_DOT_core_concat) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{sym_glojure_DOT_lang_DOT_LockingTransaction_SLASH_isRunning}) tmp28 := lang.Apply(tmp25, []any{tmp27}) tmp29 := lang.Apply(tmp24, []any{tmp28}) tmp30 := lang.Apply(tmp23, []any{tmp29}) - tmp31 := checkDerefVar(glojure_DOT_core_list) - tmp32 := checkDerefVar(glojure_DOT_core_seq) - tmp33 := checkDerefVar(glojure_DOT_core_concat) - tmp34 := checkDerefVar(glojure_DOT_core_list) - tmp35 := lang.Apply(tmp34, []any{lang.NewSymbol("throw")}) - tmp36 := checkDerefVar(glojure_DOT_core_list) - tmp37 := checkDerefVar(glojure_DOT_core_seq) - tmp38 := checkDerefVar(glojure_DOT_core_concat) - tmp39 := checkDerefVar(glojure_DOT_core_list) - tmp40 := lang.Apply(tmp39, []any{lang.NewSymbol("new")}) - tmp41 := checkDerefVar(glojure_DOT_core_list) - tmp42 := lang.Apply(tmp41, []any{lang.NewSymbol("glojure.core/IllegalStateException")}) - tmp43 := checkDerefVar(glojure_DOT_core_list) + tmp31 := checkDerefVar(var_glojure_DOT_core_list) + tmp32 := checkDerefVar(var_glojure_DOT_core_seq) + tmp33 := checkDerefVar(var_glojure_DOT_core_concat) + tmp34 := checkDerefVar(var_glojure_DOT_core_list) + tmp35 := lang.Apply(tmp34, []any{sym_throw}) + tmp36 := checkDerefVar(var_glojure_DOT_core_list) + tmp37 := checkDerefVar(var_glojure_DOT_core_seq) + tmp38 := checkDerefVar(var_glojure_DOT_core_concat) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := lang.Apply(tmp39, []any{sym_new}) + tmp41 := checkDerefVar(var_glojure_DOT_core_list) + tmp42 := lang.Apply(tmp41, []any{sym_glojure_DOT_core_SLASH_IllegalStateException}) + tmp43 := checkDerefVar(var_glojure_DOT_core_list) var tmp44 any { // let // let binding "or__0__auto__" @@ -27823,11 +28276,11 @@ func LoadNS() { tmp49 := lang.Apply(tmp33, []any{tmp35, tmp48}) tmp50 := lang.Apply(tmp32, []any{tmp49}) tmp51 := lang.Apply(tmp31, []any{tmp50}) - tmp52 := checkDerefVar(glojure_DOT_core_list) - tmp53 := checkDerefVar(glojure_DOT_core_seq) - tmp54 := checkDerefVar(glojure_DOT_core_concat) - tmp55 := checkDerefVar(glojure_DOT_core_list) - tmp56 := lang.Apply(tmp55, []any{lang.NewSymbol("do")}) + tmp52 := checkDerefVar(var_glojure_DOT_core_list) + tmp53 := checkDerefVar(var_glojure_DOT_core_seq) + tmp54 := checkDerefVar(var_glojure_DOT_core_concat) + tmp55 := checkDerefVar(var_glojure_DOT_core_list) + tmp56 := lang.Apply(tmp55, []any{sym_do}) tmp57 := lang.Apply(tmp54, []any{tmp56, v18}) tmp58 := lang.Apply(tmp53, []any{tmp57}) tmp59 := lang.Apply(tmp52, []any{tmp58}) @@ -27838,7 +28291,7 @@ func LoadNS() { return tmp6 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -27846,7 +28299,7 @@ func LoadNS() { } // isa? { - tmp0 := lang.NewSymbol("isa?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("child"), lang.NewSymbol("parent")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("child"), lang.NewSymbol("parent"))), lang.NewKeyword("doc"), "Returns true if (= child parent), or child is directly or indirectly derived from\n parent, either via a Java type inheritance relationship or a\n relationship established via derive. h must be a hierarchy obtained\n from make-hierarchy, if not supplied defaults to the global\n hierarchy", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5543), lang.NewKeyword("end-line"), int(5543))).(*lang.Symbol) + tmp0 := sym_isa_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_child, sym_parent), lang.NewVector(sym_h, sym_child, sym_parent)), kw_doc, "Returns true if (= child parent), or child is directly or indirectly derived from\n parent, either via a Java type inheritance relationship or a\n relationship established via derive. h must be a hierarchy obtained\n from make-hierarchy, if not supplied defaults to the global\n hierarchy", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(5543), kw_end_DASH_line, int(5543))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -27855,8 +28308,8 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_isa_QMARK_) - tmp6 := checkDerefVar(glojure_DOT_core_global_hierarchy) + tmp5 := checkDerefVar(var_glojure_DOT_core_isa_QMARK_) + tmp6 := checkDerefVar(var_glojure_DOT_core_global_DASH_hierarchy) tmp7 := lang.Apply(tmp5, []any{tmp6, v3, v4}) return tmp7 case 3: @@ -27869,7 +28322,7 @@ func LoadNS() { var tmp6 any { // let // let binding "or__0__auto__" - tmp7 := checkDerefVar(glojure_DOT_core__EQ_) + tmp7 := checkDerefVar(var_glojure_DOT_core__EQ_) tmp8 := lang.Apply(tmp7, []any{v4, v5}) var v9 any = tmp8 _ = v9 @@ -27883,7 +28336,7 @@ func LoadNS() { var tmp12 any { // let // let binding "and__0__auto__" - tmp13 := checkDerefVar(glojure_DOT_core_class_QMARK_) + tmp13 := checkDerefVar(var_glojure_DOT_core_class_QMARK_) tmp14 := lang.Apply(tmp13, []any{v5}) var v15 any = tmp14 _ = v15 @@ -27892,7 +28345,7 @@ func LoadNS() { var tmp17 any { // let // let binding "and__0__auto__" - tmp18 := checkDerefVar(glojure_DOT_core_class_QMARK_) + tmp18 := checkDerefVar(var_glojure_DOT_core_class_QMARK_) tmp19 := lang.Apply(tmp18, []any{v4}) var v20 any = tmp19 _ = v20 @@ -27924,8 +28377,8 @@ func LoadNS() { var tmp15 any { // let // let binding "or__0__auto__" - tmp16 := checkDerefVar(glojure_DOT_core_contains_QMARK_) - tmp17 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) + tmp16 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp17 := lang.Apply(kw_ancestors, []any{v3}) tmp18 := lang.Apply(tmp17, []any{v4}) tmp19 := lang.Apply(tmp16, []any{tmp18, v5}) var v20 any = tmp19 @@ -27940,32 +28393,30 @@ func LoadNS() { var tmp23 any { // let // let binding "and__0__auto__" - tmp24 := checkDerefVar(glojure_DOT_core_class_QMARK_) + tmp24 := checkDerefVar(var_glojure_DOT_core_class_QMARK_) tmp25 := lang.Apply(tmp24, []any{v4}) var v26 any = tmp25 _ = v26 var tmp27 any if lang.IsTruthy(v26) { - tmp28 := checkDerefVar(glojure_DOT_core_some) + tmp28 := checkDerefVar(var_glojure_DOT_core_some) var tmp29 lang.FnFunc tmp29 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v30 := args[0] _ = v30 - tmp31 := checkDerefVar(glojure_DOT_core_contains_QMARK_) - tmp32 := lang.Apply(lang.NewKeyword("ancestors"), []any{v3}) + tmp31 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp32 := lang.Apply(kw_ancestors, []any{v3}) tmp33 := lang.Apply(tmp32, []any{v30}) tmp34 := lang.Apply(tmp31, []any{tmp33, v5}) return tmp34 }) - tmp30 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5556), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(5556), lang.NewKeyword("end-column"), int(71)) + tmp30 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5556), kw_column, int(34), kw_end_DASH_line, int(5556), kw_end_DASH_column, int(71)) tmp31, err := lang.WithMeta(tmp29, tmp30.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp32 := checkDerefVar(glojure_DOT_core_supers) + tmp32 := checkDerefVar(var_glojure_DOT_core_supers) tmp33 := lang.Apply(tmp32, []any{v4}) tmp34 := lang.Apply(tmp28, []any{tmp31, tmp33}) tmp27 = tmp34 @@ -27983,7 +28434,7 @@ func LoadNS() { var tmp26 any { // let // let binding "and__0__auto__" - tmp27 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp27 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) tmp28 := lang.Apply(tmp27, []any{v5}) var v29 any = tmp28 _ = v29 @@ -27992,7 +28443,7 @@ func LoadNS() { var tmp31 any { // let // let binding "and__0__auto__" - tmp32 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp32 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) tmp33 := lang.Apply(tmp32, []any{v4}) var v34 any = tmp33 _ = v34 @@ -28001,10 +28452,10 @@ func LoadNS() { var tmp36 any { // let // let binding "and__0__auto__" - tmp37 := checkDerefVar(glojure_DOT_core__EQ_) - tmp38 := checkDerefVar(glojure_DOT_core_count) + tmp37 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp38 := checkDerefVar(var_glojure_DOT_core_count) tmp39 := lang.Apply(tmp38, []any{v5}) - tmp40 := checkDerefVar(glojure_DOT_core_count) + tmp40 := checkDerefVar(var_glojure_DOT_core_count) tmp41 := lang.Apply(tmp40, []any{v4}) tmp42 := lang.Apply(tmp37, []any{tmp39, tmp41}) var v43 any = tmp42 @@ -28024,7 +28475,7 @@ func LoadNS() { var tmp49 any { // let // let binding "or__0__auto__" - tmp50 := checkDerefVar(glojure_DOT_core_not) + tmp50 := checkDerefVar(var_glojure_DOT_core_not) tmp51 := lang.Apply(tmp50, []any{v46}) var v52 any = tmp51 _ = v52 @@ -28032,8 +28483,8 @@ func LoadNS() { if lang.IsTruthy(v52) { tmp53 = v52 } else { - tmp54 := checkDerefVar(glojure_DOT_core__EQ_) - tmp55 := checkDerefVar(glojure_DOT_core_count) + tmp54 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp55 := checkDerefVar(var_glojure_DOT_core_count) tmp56 := lang.Apply(tmp55, []any{v5}) tmp57 := lang.Apply(tmp54, []any{v47, tmp56}) tmp53 = tmp57 @@ -28043,12 +28494,12 @@ func LoadNS() { if lang.IsTruthy(tmp49) { tmp48 = v46 } else { - tmp51 := checkDerefVar(glojure_DOT_core_isa_QMARK_) + tmp51 := checkDerefVar(var_glojure_DOT_core_isa_QMARK_) tmp52 := lang.Apply(v4, []any{v47}) tmp53 := lang.Apply(v5, []any{v47}) tmp54 := lang.Apply(tmp51, []any{v3, tmp52, tmp53}) var tmp50 any = tmp54 - tmp56 := checkDerefVar(glojure_DOT_core_inc) + tmp56 := checkDerefVar(var_glojure_DOT_core_inc) tmp57 := lang.Apply(tmp56, []any{v47}) var tmp55 any = tmp57 v46 = tmp50 @@ -28095,10 +28546,11 @@ func LoadNS() { } // end let return tmp6 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -28106,12 +28558,10 @@ func LoadNS() { } // iterate { - tmp0 := lang.NewSymbol("iterate").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns a lazy (infinite!) sequence of x, (f x), (f (f x)) etc.\n f must be free of side-effects", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3011), lang.NewKeyword("end-line"), int(3011))).(*lang.Symbol) + tmp0 := sym_iterate.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_x)), kw_doc, "Returns a lazy (infinite!) sequence of x, (f x), (f (f x)) etc.\n f must be free of side-effects", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(3011), kw_end_DASH_line, int(3011))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -28119,7 +28569,7 @@ func LoadNS() { tmp5 := lang.Apply(nil, []any{v3, v4}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -28127,14 +28577,12 @@ func LoadNS() { } // iteration { - tmp0 := lang.NewSymbol("iteration").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("step"), lang.NewSymbol("&"), lang.NewMap(lang.NewKeyword("keys"), lang.NewVector(lang.NewSymbol("somef"), lang.NewSymbol("vf"), lang.NewSymbol("kf"), lang.NewSymbol("initk")), lang.NewKeyword("or"), lang.NewMap(lang.NewSymbol("vf"), lang.NewSymbol("identity"), lang.NewSymbol("kf"), lang.NewSymbol("identity"), lang.NewSymbol("somef"), lang.NewSymbol("some?"), lang.NewSymbol("initk"), nil)))), lang.NewKeyword("doc"), "Creates a seqable/reducible via repeated calls to step,\n a function of some (continuation token) 'k'. The first call to step\n will be passed initk, returning 'ret'. Iff (somef ret) is true,\n (vf ret) will be included in the iteration, else iteration will\n terminate and vf/kf will not be called. If (kf ret) is non-nil it\n will be passed to the next step call, else iteration will terminate.\n\n This can be used e.g. to consume APIs that return paginated or batched data.\n\n step - (possibly impure) fn of 'k' -> 'ret'\n\n :somef - fn of 'ret' -> logical true/false, default 'some?'\n :vf - fn of 'ret' -> 'v', a value produced by the iteration, default 'identity'\n :kf - fn of 'ret' -> 'next-k' or nil (signaling 'do not continue'), default 'identity'\n :initk - the first value passed to step, default 'nil'\n\n It is presumed that step with non-initk is unreproducible/non-idempotent.\n If step with initk is unreproducible it is on the consumer to not consume twice.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7716), lang.NewKeyword("end-line"), int(7716))).(*lang.Symbol) + tmp0 := sym_iteration.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_step, sym__AMP_, lang.NewMap(kw_keys, lang.NewVector(sym_somef, sym_vf, sym_kf, sym_initk), kw_or, lang.NewMap(sym_vf, sym_identity, sym_kf, sym_identity, sym_somef, sym_some_QMARK_, sym_initk, nil)))), kw_doc, "Creates a seqable/reducible via repeated calls to step,\n a function of some (continuation token) 'k'. The first call to step\n will be passed initk, returning 'ret'. Iff (somef ret) is true,\n (vf ret) will be included in the iteration, else iteration will\n terminate and vf/kf will not be called. If (kf ret) is non-nil it\n will be passed to the next step call, else iteration will terminate.\n\n This can be used e.g. to consume APIs that return paginated or batched data.\n\n step - (possibly impure) fn of 'k' -> 'ret'\n\n :somef - fn of 'ret' -> logical true/false, default 'some?'\n :vf - fn of 'ret' -> 'v', a value produced by the iteration, default 'identity'\n :kf - fn of 'ret' -> 'next-k' or nil (signaling 'do not continue'), default 'identity'\n :initk - the first value passed to step, default 'nil'\n\n It is presumed that step with non-initk is unreproducible/non-idempotent.\n If step with initk is unreproducible it is on the consumer to not consume twice.", kw_file, "glojure/core.glj", kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(7716), kw_end_DASH_line, int(7716))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var v4 any = lang.NewList(args[1:]...) @@ -28146,23 +28594,23 @@ func LoadNS() { _ = v6 // let binding "map__357" var tmp7 any - tmp8 := checkDerefVar(glojure_DOT_core_seq_QMARK_) + tmp8 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) tmp9 := lang.Apply(tmp8, []any{v6}) if lang.IsTruthy(tmp9) { var tmp10 any - tmp11 := checkDerefVar(glojure_DOT_core_next) + tmp11 := checkDerefVar(var_glojure_DOT_core_next) tmp12 := lang.Apply(tmp11, []any{v6}) if lang.IsTruthy(tmp12) { - tmp13 := checkDerefVar(glojure_DOT_core_to_array) + tmp13 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) tmp14 := lang.Apply(tmp13, []any{v6}) tmp15 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{tmp14}) tmp10 = tmp15 } else { var tmp16 any - tmp17 := checkDerefVar(glojure_DOT_core_seq) + tmp17 := checkDerefVar(var_glojure_DOT_core_seq) tmp18 := lang.Apply(tmp17, []any{v6}) if lang.IsTruthy(tmp18) { - tmp19 := checkDerefVar(glojure_DOT_core_first) + tmp19 := checkDerefVar(var_glojure_DOT_core_first) tmp20 := lang.Apply(tmp19, []any{v6}) tmp16 = tmp20 } else { @@ -28176,31 +28624,31 @@ func LoadNS() { var v21 any = tmp7 _ = v21 // let binding "somef" - tmp22 := checkDerefVar(glojure_DOT_core_get) - tmp23 := checkDerefVar(glojure_DOT_core_some_QMARK_) - tmp24 := lang.Apply(tmp22, []any{v21, lang.NewKeyword("somef"), tmp23}) + tmp22 := checkDerefVar(var_glojure_DOT_core_get) + tmp23 := checkDerefVar(var_glojure_DOT_core_some_QMARK_) + tmp24 := lang.Apply(tmp22, []any{v21, kw_somef, tmp23}) var v25 any = tmp24 _ = v25 // let binding "vf" - tmp26 := checkDerefVar(glojure_DOT_core_get) - tmp27 := checkDerefVar(glojure_DOT_core_identity) - tmp28 := lang.Apply(tmp26, []any{v21, lang.NewKeyword("vf"), tmp27}) + tmp26 := checkDerefVar(var_glojure_DOT_core_get) + tmp27 := checkDerefVar(var_glojure_DOT_core_identity) + tmp28 := lang.Apply(tmp26, []any{v21, kw_vf, tmp27}) var v29 any = tmp28 _ = v29 // let binding "kf" - tmp30 := checkDerefVar(glojure_DOT_core_get) - tmp31 := checkDerefVar(glojure_DOT_core_identity) - tmp32 := lang.Apply(tmp30, []any{v21, lang.NewKeyword("kf"), tmp31}) + tmp30 := checkDerefVar(var_glojure_DOT_core_get) + tmp31 := checkDerefVar(var_glojure_DOT_core_identity) + tmp32 := lang.Apply(tmp30, []any{v21, kw_kf, tmp31}) var v33 any = tmp32 _ = v33 // let binding "initk" - tmp34 := checkDerefVar(glojure_DOT_core_get) - tmp35 := lang.Apply(tmp34, []any{v21, lang.NewKeyword("initk"), nil}) + tmp34 := checkDerefVar(var_glojure_DOT_core_get) + tmp35 := lang.Apply(tmp34, []any{v21, kw_initk, nil}) var v36 any = tmp35 _ = v36 - tmp37 := checkDerefVar(glojure_DOT_core_seq) + tmp37 := checkDerefVar(var_glojure_DOT_core_seq) tmp38 := lang.NewVector(nil) - tmp39 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7743), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(7743), lang.NewKeyword("end-column"), int(11)) + tmp39 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7743), kw_column, int(9), kw_end_DASH_line, int(7743), kw_end_DASH_column, int(11)) tmp40, err := lang.WithMeta(tmp38, tmp39.(lang.IPersistentMap)) if err != nil { panic(err) @@ -28209,15 +28657,13 @@ func LoadNS() { { // function next var v42 lang.FnFunc tmp41 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v43 := args[0] _ = v43 var tmp44 any tmp45 := lang.Apply(v25, []any{v43}) if lang.IsTruthy(tmp45) { - tmp46 := checkDerefVar(glojure_DOT_core_cons) + tmp46 := checkDerefVar(var_glojure_DOT_core_cons) tmp47 := lang.Apply(v29, []any{v43}) var tmp48 any { // let @@ -28226,7 +28672,7 @@ func LoadNS() { var v50 any = tmp49 _ = v50 var tmp51 any - tmp52 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp52 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) tmp53 := lang.Apply(tmp52, []any{v50}) if lang.IsTruthy(tmp53) { } else { @@ -28237,9 +28683,7 @@ func LoadNS() { _ = v55 var tmp56 lang.FnFunc tmp56 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) tmp57 := lang.Apply(v3, []any{v55}) tmp58 := lang.Apply(v42, []any{tmp57}) return tmp58 @@ -28260,7 +28704,7 @@ func LoadNS() { v42 = tmp41 _ = v42 } - tmp42 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7744), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(7748), lang.NewKeyword("end-column"), int(51)) + tmp42 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7744), kw_column, int(10), kw_end_DASH_line, int(7748), kw_end_DASH_column, int(51)) tmp43, err := lang.WithMeta(tmp41, tmp42.(lang.IPersistentMap)) if err != nil { panic(err) @@ -28269,9 +28713,9 @@ func LoadNS() { tmp45 := lang.Apply(tmp43, []any{tmp44}) tmp46 := lang.Apply(tmp37, []any{tmp40, tmp45}) tmp47 := reflect.TypeOf((*lang.IReduceInit)(nil)).Elem() - tmp48 := checkDerefVar(glojure_DOT_core_reduce) + tmp48 := checkDerefVar(var_glojure_DOT_core_reduce) tmp49 := lang.NewVector(nil, nil, nil) - tmp50 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7751), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(7751), lang.NewKeyword("end-column"), int(22)) + tmp50 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7751), kw_column, int(12), kw_end_DASH_line, int(7751), kw_end_DASH_column, int(22)) tmp51, err := lang.WithMeta(tmp49, tmp50.(lang.IPersistentMap)) if err != nil { panic(err) @@ -28297,10 +28741,10 @@ func LoadNS() { var v61 any = tmp60 _ = v61 var tmp62 any - tmp63 := checkDerefVar(glojure_DOT_core_reduced_QMARK_) + tmp63 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) tmp64 := lang.Apply(tmp63, []any{v61}) if lang.IsTruthy(tmp64) { - tmp65 := checkDerefVar(glojure_DOT_core_deref) + tmp65 := checkDerefVar(var_glojure_DOT_core_deref) tmp66 := lang.Apply(tmp65, []any{v61}) tmp62 = tmp66 } else { @@ -28311,7 +28755,7 @@ func LoadNS() { var v69 any = tmp68 _ = v69 var tmp70 any - tmp71 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp71 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) tmp72 := lang.Apply(tmp71, []any{v69}) if lang.IsTruthy(tmp72) { tmp70 = v61 @@ -28351,7 +28795,7 @@ func LoadNS() { return tmp5 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -28359,18 +28803,16 @@ func LoadNS() { } // iterator-seq { - tmp0 := lang.NewSymbol("iterator-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("iter"))), lang.NewKeyword("doc"), "Returns a seq on a java.util.Iterator. Note that most collections\n providing iterators implement Iterable and thus support seq directly.\n Seqs cache values, thus iterator-seq should not be used on any\n iterator that repeatedly returns the same mutable object.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5700), lang.NewKeyword("end-line"), int(5700))).(*lang.Symbol) + tmp0 := sym_iterator_DASH_seq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_iter)), kw_doc, "Returns a seq on a java.util.Iterator. Note that most collections\n providing iterators implement Iterable and thus support seq directly.\n Seqs cache values, thus iterator-seq should not be used on any\n iterator that repeatedly returns the same mutable object.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(5700), kw_end_DASH_line, int(5700))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4 := lang.Apply(nil, []any{v3}) return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -28378,7 +28820,7 @@ func LoadNS() { } // juxt { - tmp0 := lang.NewSymbol("juxt").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("g")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("g"), lang.NewSymbol("h")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("g"), lang.NewSymbol("h"), lang.NewSymbol("&"), lang.NewSymbol("fs"))), lang.NewKeyword("doc"), "Takes a set of functions and returns a fn that is the juxtaposition\n of those fns. The returned fn takes a variable number of args, and\n returns a vector containing the result of applying each fn to the\n args (left-to-right).\n ((juxt a b c) x) => [(a x) (b x) (c x)]", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2568), lang.NewKeyword("end-line"), int(2568))).(*lang.Symbol) + tmp0 := sym_juxt.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_g), lang.NewVector(sym_f, sym_g, sym_h), lang.NewVector(sym_f, sym_g, sym_h, sym__AMP_, sym_fs)), kw_doc, "Takes a set of functions and returns a fn that is the juxtaposition\n of those fns. The returned fn takes a variable number of args, and\n returns a vector containing the result of applying each fn to the\n args (left-to-right).\n ((juxt a b c) x) => [(a x) (b x) (c x)]", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(2568), kw_end_DASH_line, int(2568))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -28391,7 +28833,7 @@ func LoadNS() { case 0: tmp5 := lang.Apply(v3, nil) tmp6 := lang.NewVector(tmp5) - tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2578), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(2578), lang.NewKeyword("end-column"), int(16)) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2578), kw_column, int(12), kw_end_DASH_line, int(2578), kw_end_DASH_column, int(16)) tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) if err != nil { panic(err) @@ -28402,7 +28844,7 @@ func LoadNS() { _ = v5 tmp6 := lang.Apply(v3, []any{v5}) tmp7 := lang.NewVector(tmp6) - tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2579), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(2579), lang.NewKeyword("end-column"), int(19)) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2579), kw_column, int(13), kw_end_DASH_line, int(2579), kw_end_DASH_column, int(19)) tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) if err != nil { panic(err) @@ -28415,7 +28857,7 @@ func LoadNS() { _ = v6 tmp7 := lang.Apply(v3, []any{v5, v6}) tmp8 := lang.NewVector(tmp7) - tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2580), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(2580), lang.NewKeyword("end-column"), int(23)) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2580), kw_column, int(15), kw_end_DASH_line, int(2580), kw_end_DASH_column, int(23)) tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) if err != nil { panic(err) @@ -28430,16 +28872,14 @@ func LoadNS() { _ = v7 tmp8 := lang.Apply(v3, []any{v5, v6, v7}) tmp9 := lang.NewVector(tmp8) - tmp10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2581), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(2581), lang.NewKeyword("end-column"), int(27)) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2581), kw_column, int(17), kw_end_DASH_line, int(2581), kw_end_DASH_column, int(27)) tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) if err != nil { panic(err) } return tmp11 default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v5 := args[0] _ = v5 v6 := args[1] @@ -28448,10 +28888,10 @@ func LoadNS() { _ = v7 var v8 any = lang.NewList(args[3:]...) _ = v8 - tmp9 := checkDerefVar(glojure_DOT_core_apply) + tmp9 := checkDerefVar(var_glojure_DOT_core_apply) tmp10 := lang.Apply(tmp9, []any{v3, v5, v6, v7, v8}) tmp11 := lang.NewVector(tmp10) - tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2582), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(2582), lang.NewKeyword("end-column"), int(45)) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2582), kw_column, int(24), kw_end_DASH_line, int(2582), kw_end_DASH_column, int(45)) tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) if err != nil { panic(err) @@ -28459,7 +28899,7 @@ func LoadNS() { return tmp13 } }) - tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2577), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2582), lang.NewKeyword("end-column"), int(47)) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2577), kw_column, int(6), kw_end_DASH_line, int(2582), kw_end_DASH_column, int(47)) tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) if err != nil { panic(err) @@ -28477,7 +28917,7 @@ func LoadNS() { tmp6 := lang.Apply(v3, nil) tmp7 := lang.Apply(v4, nil) tmp8 := lang.NewVector(tmp6, tmp7) - tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2585), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(2585), lang.NewKeyword("end-column"), int(20)) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2585), kw_column, int(12), kw_end_DASH_line, int(2585), kw_end_DASH_column, int(20)) tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) if err != nil { panic(err) @@ -28489,7 +28929,7 @@ func LoadNS() { tmp7 := lang.Apply(v3, []any{v6}) tmp8 := lang.Apply(v4, []any{v6}) tmp9 := lang.NewVector(tmp7, tmp8) - tmp10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2586), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(2586), lang.NewKeyword("end-column"), int(25)) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2586), kw_column, int(13), kw_end_DASH_line, int(2586), kw_end_DASH_column, int(25)) tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) if err != nil { panic(err) @@ -28503,7 +28943,7 @@ func LoadNS() { tmp8 := lang.Apply(v3, []any{v6, v7}) tmp9 := lang.Apply(v4, []any{v6, v7}) tmp10 := lang.NewVector(tmp8, tmp9) - tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2587), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(2587), lang.NewKeyword("end-column"), int(31)) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2587), kw_column, int(15), kw_end_DASH_line, int(2587), kw_end_DASH_column, int(31)) tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) if err != nil { panic(err) @@ -28519,16 +28959,14 @@ func LoadNS() { tmp9 := lang.Apply(v3, []any{v6, v7, v8}) tmp10 := lang.Apply(v4, []any{v6, v7, v8}) tmp11 := lang.NewVector(tmp9, tmp10) - tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2588), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(2588), lang.NewKeyword("end-column"), int(37)) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2588), kw_column, int(17), kw_end_DASH_line, int(2588), kw_end_DASH_column, int(37)) tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) if err != nil { panic(err) } return tmp13 default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v6 := args[0] _ = v6 v7 := args[1] @@ -28537,12 +28975,12 @@ func LoadNS() { _ = v8 var v9 any = lang.NewList(args[3:]...) _ = v9 - tmp10 := checkDerefVar(glojure_DOT_core_apply) + tmp10 := checkDerefVar(var_glojure_DOT_core_apply) tmp11 := lang.Apply(tmp10, []any{v3, v6, v7, v8, v9}) - tmp12 := checkDerefVar(glojure_DOT_core_apply) + tmp12 := checkDerefVar(var_glojure_DOT_core_apply) tmp13 := lang.Apply(tmp12, []any{v4, v6, v7, v8, v9}) tmp14 := lang.NewVector(tmp11, tmp13) - tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2589), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(2589), lang.NewKeyword("end-column"), int(66)) + tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2589), kw_column, int(24), kw_end_DASH_line, int(2589), kw_end_DASH_column, int(66)) tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) if err != nil { panic(err) @@ -28550,7 +28988,7 @@ func LoadNS() { return tmp16 } }) - tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2584), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2589), lang.NewKeyword("end-column"), int(68)) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2584), kw_column, int(6), kw_end_DASH_line, int(2589), kw_end_DASH_column, int(68)) tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) if err != nil { panic(err) @@ -28571,7 +29009,7 @@ func LoadNS() { tmp8 := lang.Apply(v4, nil) tmp9 := lang.Apply(v5, nil) tmp10 := lang.NewVector(tmp7, tmp8, tmp9) - tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2592), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(2592), lang.NewKeyword("end-column"), int(24)) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2592), kw_column, int(12), kw_end_DASH_line, int(2592), kw_end_DASH_column, int(24)) tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) if err != nil { panic(err) @@ -28584,7 +29022,7 @@ func LoadNS() { tmp9 := lang.Apply(v4, []any{v7}) tmp10 := lang.Apply(v5, []any{v7}) tmp11 := lang.NewVector(tmp8, tmp9, tmp10) - tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2593), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(2593), lang.NewKeyword("end-column"), int(31)) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2593), kw_column, int(13), kw_end_DASH_line, int(2593), kw_end_DASH_column, int(31)) tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) if err != nil { panic(err) @@ -28599,7 +29037,7 @@ func LoadNS() { tmp10 := lang.Apply(v4, []any{v7, v8}) tmp11 := lang.Apply(v5, []any{v7, v8}) tmp12 := lang.NewVector(tmp9, tmp10, tmp11) - tmp13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2594), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(2594), lang.NewKeyword("end-column"), int(39)) + tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2594), kw_column, int(15), kw_end_DASH_line, int(2594), kw_end_DASH_column, int(39)) tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) if err != nil { panic(err) @@ -28616,16 +29054,14 @@ func LoadNS() { tmp11 := lang.Apply(v4, []any{v7, v8, v9}) tmp12 := lang.Apply(v5, []any{v7, v8, v9}) tmp13 := lang.NewVector(tmp10, tmp11, tmp12) - tmp14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2595), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(2595), lang.NewKeyword("end-column"), int(47)) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2595), kw_column, int(17), kw_end_DASH_line, int(2595), kw_end_DASH_column, int(47)) tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) if err != nil { panic(err) } return tmp15 default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v7 := args[0] _ = v7 v8 := args[1] @@ -28634,14 +29070,14 @@ func LoadNS() { _ = v9 var v10 any = lang.NewList(args[3:]...) _ = v10 - tmp11 := checkDerefVar(glojure_DOT_core_apply) + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) tmp12 := lang.Apply(tmp11, []any{v3, v7, v8, v9, v10}) - tmp13 := checkDerefVar(glojure_DOT_core_apply) + tmp13 := checkDerefVar(var_glojure_DOT_core_apply) tmp14 := lang.Apply(tmp13, []any{v4, v7, v8, v9, v10}) - tmp15 := checkDerefVar(glojure_DOT_core_apply) + tmp15 := checkDerefVar(var_glojure_DOT_core_apply) tmp16 := lang.Apply(tmp15, []any{v5, v7, v8, v9, v10}) tmp17 := lang.NewVector(tmp12, tmp14, tmp16) - tmp18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2596), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(2596), lang.NewKeyword("end-column"), int(87)) + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2596), kw_column, int(24), kw_end_DASH_line, int(2596), kw_end_DASH_column, int(87)) tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) if err != nil { panic(err) @@ -28649,16 +29085,14 @@ func LoadNS() { return tmp19 } }) - tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2591), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2596), lang.NewKeyword("end-column"), int(89)) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2591), kw_column, int(6), kw_end_DASH_line, int(2596), kw_end_DASH_column, int(89)) tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) if err != nil { panic(err) } return tmp8 default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -28670,7 +29104,7 @@ func LoadNS() { var tmp7 any { // let // let binding "fs" - tmp8 := checkDerefVar(glojure_DOT_core_list_STAR_) + tmp8 := checkDerefVar(var_glojure_DOT_core_list_STAR_) tmp9 := lang.Apply(tmp8, []any{v3, v4, v5, v6}) var v10 any = tmp9 _ = v10 @@ -28678,28 +29112,26 @@ func LoadNS() { tmp11 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - tmp12 := checkDerefVar(glojure_DOT_core_reduce1) + tmp12 := checkDerefVar(var_glojure_DOT_core_reduce1) var tmp13 lang.FnFunc tmp13 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v14 := args[0] _ = v14 v15 := args[1] _ = v15 - tmp16 := checkDerefVar(glojure_DOT_core_conj) + tmp16 := checkDerefVar(var_glojure_DOT_core_conj) tmp17 := lang.Apply(v15, nil) tmp18 := lang.Apply(tmp16, []any{v14, tmp17}) return tmp18 }) - tmp14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2600), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(2600), lang.NewKeyword("end-column"), int(37)) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2600), kw_column, int(23), kw_end_DASH_line, int(2600), kw_end_DASH_column, int(37)) tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) if err != nil { panic(err) } tmp16 := lang.NewVector() - tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2600), lang.NewKeyword("column"), int(39), lang.NewKeyword("end-line"), int(2600), lang.NewKeyword("end-column"), int(40)) + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2600), kw_column, int(39), kw_end_DASH_line, int(2600), kw_end_DASH_column, int(40)) tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) if err != nil { panic(err) @@ -28709,28 +29141,26 @@ func LoadNS() { case 1: v12 := args[0] _ = v12 - tmp13 := checkDerefVar(glojure_DOT_core_reduce1) + tmp13 := checkDerefVar(var_glojure_DOT_core_reduce1) var tmp14 lang.FnFunc tmp14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v15 := args[0] _ = v15 v16 := args[1] _ = v16 - tmp17 := checkDerefVar(glojure_DOT_core_conj) + tmp17 := checkDerefVar(var_glojure_DOT_core_conj) tmp18 := lang.Apply(v16, []any{v12}) tmp19 := lang.Apply(tmp17, []any{v15, tmp18}) return tmp19 }) - tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2601), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(2601), lang.NewKeyword("end-column"), int(40)) + tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2601), kw_column, int(24), kw_end_DASH_line, int(2601), kw_end_DASH_column, int(40)) tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) if err != nil { panic(err) } tmp17 := lang.NewVector() - tmp18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2601), lang.NewKeyword("column"), int(42), lang.NewKeyword("end-line"), int(2601), lang.NewKeyword("end-column"), int(43)) + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2601), kw_column, int(42), kw_end_DASH_line, int(2601), kw_end_DASH_column, int(43)) tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) if err != nil { panic(err) @@ -28742,28 +29172,26 @@ func LoadNS() { _ = v12 v13 := args[1] _ = v13 - tmp14 := checkDerefVar(glojure_DOT_core_reduce1) + tmp14 := checkDerefVar(var_glojure_DOT_core_reduce1) var tmp15 lang.FnFunc tmp15 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v16 := args[0] _ = v16 v17 := args[1] _ = v17 - tmp18 := checkDerefVar(glojure_DOT_core_conj) + tmp18 := checkDerefVar(var_glojure_DOT_core_conj) tmp19 := lang.Apply(v17, []any{v12, v13}) tmp20 := lang.Apply(tmp18, []any{v16, tmp19}) return tmp20 }) - tmp16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2602), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(2602), lang.NewKeyword("end-column"), int(44)) + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2602), kw_column, int(26), kw_end_DASH_line, int(2602), kw_end_DASH_column, int(44)) tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) if err != nil { panic(err) } tmp18 := lang.NewVector() - tmp19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2602), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(2602), lang.NewKeyword("end-column"), int(47)) + tmp19 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2602), kw_column, int(46), kw_end_DASH_line, int(2602), kw_end_DASH_column, int(47)) tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) if err != nil { panic(err) @@ -28777,28 +29205,26 @@ func LoadNS() { _ = v13 v14 := args[2] _ = v14 - tmp15 := checkDerefVar(glojure_DOT_core_reduce1) + tmp15 := checkDerefVar(var_glojure_DOT_core_reduce1) var tmp16 lang.FnFunc tmp16 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v17 := args[0] _ = v17 v18 := args[1] _ = v18 - tmp19 := checkDerefVar(glojure_DOT_core_conj) + tmp19 := checkDerefVar(var_glojure_DOT_core_conj) tmp20 := lang.Apply(v18, []any{v12, v13, v14}) tmp21 := lang.Apply(tmp19, []any{v17, tmp20}) return tmp21 }) - tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2603), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(2603), lang.NewKeyword("end-column"), int(48)) + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2603), kw_column, int(28), kw_end_DASH_line, int(2603), kw_end_DASH_column, int(48)) tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) if err != nil { panic(err) } tmp19 := lang.NewVector() - tmp20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2603), lang.NewKeyword("column"), int(50), lang.NewKeyword("end-line"), int(2603), lang.NewKeyword("end-column"), int(51)) + tmp20 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2603), kw_column, int(50), kw_end_DASH_line, int(2603), kw_end_DASH_column, int(51)) tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) if err != nil { panic(err) @@ -28806,9 +29232,7 @@ func LoadNS() { tmp22 := lang.Apply(tmp15, []any{tmp18, tmp21, v10}) return tmp22 default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v12 := args[0] _ = v12 v13 := args[1] @@ -28817,29 +29241,27 @@ func LoadNS() { _ = v14 var v15 any = lang.NewList(args[3:]...) _ = v15 - tmp16 := checkDerefVar(glojure_DOT_core_reduce1) + tmp16 := checkDerefVar(var_glojure_DOT_core_reduce1) var tmp17 lang.FnFunc tmp17 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v18 := args[0] _ = v18 v19 := args[1] _ = v19 - tmp20 := checkDerefVar(glojure_DOT_core_conj) - tmp21 := checkDerefVar(glojure_DOT_core_apply) + tmp20 := checkDerefVar(var_glojure_DOT_core_conj) + tmp21 := checkDerefVar(var_glojure_DOT_core_apply) tmp22 := lang.Apply(tmp21, []any{v19, v12, v13, v14, v15}) tmp23 := lang.Apply(tmp20, []any{v18, tmp22}) return tmp23 }) - tmp18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2604), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(2604), lang.NewKeyword("end-column"), int(66)) + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2604), kw_column, int(35), kw_end_DASH_line, int(2604), kw_end_DASH_column, int(66)) tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) if err != nil { panic(err) } tmp20 := lang.NewVector() - tmp21 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2604), lang.NewKeyword("column"), int(68), lang.NewKeyword("end-line"), int(2604), lang.NewKeyword("end-column"), int(69)) + tmp21 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2604), kw_column, int(68), kw_end_DASH_line, int(2604), kw_end_DASH_column, int(69)) tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) if err != nil { panic(err) @@ -28848,7 +29270,7 @@ func LoadNS() { return tmp23 } }) - tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2599), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(2604), lang.NewKeyword("end-column"), int(75)) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2599), kw_column, int(8), kw_end_DASH_line, int(2604), kw_end_DASH_column, int(75)) tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) if err != nil { panic(err) @@ -28858,7 +29280,7 @@ func LoadNS() { return tmp7 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -28866,7 +29288,7 @@ func LoadNS() { } // keep { - tmp0 := lang.NewSymbol("keep").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the non-nil results of (f item). Note,\n this means false return values will be included. f must be free of\n side-effects. Returns a transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7339), lang.NewKeyword("end-line"), int(7339))).(*lang.Symbol) + tmp0 := sym_keep.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_coll)), kw_doc, "Returns a lazy sequence of the non-nil results of (f item). Note,\n this means false return values will be included. f must be free of\n side-effects. Returns a transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(7339), kw_end_DASH_line, int(7339))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -28875,9 +29297,7 @@ func LoadNS() { _ = v3 var tmp4 lang.FnFunc tmp4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v5 := args[0] _ = v5 var tmp6 lang.FnFunc @@ -28903,7 +29323,7 @@ func LoadNS() { var v11 any = tmp10 _ = v11 var tmp12 any - tmp13 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp13 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) tmp14 := lang.Apply(tmp13, []any{v11}) if lang.IsTruthy(tmp14) { tmp12 = v7 @@ -28915,17 +29335,18 @@ func LoadNS() { } // end let return tmp9 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7347), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7354), lang.NewKeyword("end-column"), int(31)) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7347), kw_column, int(6), kw_end_DASH_line, int(7354), kw_end_DASH_column, int(31)) tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) if err != nil { panic(err) } return tmp8 }) - tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7346), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7354), lang.NewKeyword("end-column"), int(32)) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7346), kw_column, int(4), kw_end_DASH_line, int(7354), kw_end_DASH_column, int(32)) tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) if err != nil { panic(err) @@ -28938,13 +29359,11 @@ func LoadNS() { _ = v4 var tmp5 lang.FnFunc tmp5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var tmp6 any { // let // let binding "temp__0__auto__" - tmp7 := checkDerefVar(glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) tmp8 := lang.Apply(tmp7, []any{v4}) var v9 any = tmp8 _ = v9 @@ -28956,30 +29375,30 @@ func LoadNS() { var v12 any = v9 _ = v12 var tmp13 any - tmp14 := checkDerefVar(glojure_DOT_core_chunked_seq_QMARK_) + tmp14 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) tmp15 := lang.Apply(tmp14, []any{v12}) if lang.IsTruthy(tmp15) { var tmp16 any { // let // let binding "c" - tmp17 := checkDerefVar(glojure_DOT_core_chunk_first) + tmp17 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) tmp18 := lang.Apply(tmp17, []any{v12}) var v19 any = tmp18 _ = v19 // let binding "size" - tmp20 := checkDerefVar(glojure_DOT_core_count) + tmp20 := checkDerefVar(var_glojure_DOT_core_count) tmp21 := lang.Apply(tmp20, []any{v19}) var v22 any = tmp21 _ = v22 // let binding "b" - tmp23 := checkDerefVar(glojure_DOT_core_chunk_buffer) + tmp23 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_buffer) tmp24 := lang.Apply(tmp23, []any{v22}) var v25 any = tmp24 _ = v25 var tmp26 any { // let // let binding "n__0__auto__" - tmp27 := checkDerefVar(glojure_DOT_core_long) + tmp27 := checkDerefVar(var_glojure_DOT_core_long) tmp28 := lang.Apply(tmp27, []any{v22}) var v29 any = tmp28 _ = v29 @@ -28990,7 +29409,7 @@ func LoadNS() { _ = v31 for { var tmp32 any - tmp33 := checkDerefVar(glojure_DOT_core__LT_) + tmp33 := checkDerefVar(var_glojure_DOT_core__LT_) tmp34 := lang.Apply(tmp33, []any{v31, v29}) if lang.IsTruthy(tmp34) { var tmp35 any @@ -29005,18 +29424,18 @@ func LoadNS() { var v39 any = tmp38 _ = v39 var tmp40 any - tmp41 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp41 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) tmp42 := lang.Apply(tmp41, []any{v39}) if lang.IsTruthy(tmp42) { } else { - tmp43 := checkDerefVar(glojure_DOT_core_chunk_append) + tmp43 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_append) tmp44 := lang.Apply(tmp43, []any{v25, v39}) tmp40 = tmp44 } tmp35 = tmp40 } // end let _ = tmp35 - tmp37 := checkDerefVar(glojure_DOT_core_unchecked_inc) + tmp37 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) tmp38 := lang.Apply(tmp37, []any{v31}) var tmp36 any = tmp38 v31 = tmp36 @@ -29030,11 +29449,11 @@ func LoadNS() { tmp26 = tmp30 } // end let _ = tmp26 - tmp27 := checkDerefVar(glojure_DOT_core_chunk_cons) - tmp28 := checkDerefVar(glojure_DOT_core_chunk) + tmp27 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_cons) + tmp28 := checkDerefVar(var_glojure_DOT_core_chunk) tmp29 := lang.Apply(tmp28, []any{v25}) - tmp30 := checkDerefVar(glojure_DOT_core_keep) - tmp31 := checkDerefVar(glojure_DOT_core_chunk_rest) + tmp30 := checkDerefVar(var_glojure_DOT_core_keep) + tmp31 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) tmp32 := lang.Apply(tmp31, []any{v12}) tmp33 := lang.Apply(tmp30, []any{v3, tmp32}) tmp34 := lang.Apply(tmp27, []any{tmp29, tmp33}) @@ -29045,24 +29464,24 @@ func LoadNS() { var tmp17 any { // let // let binding "x" - tmp18 := checkDerefVar(glojure_DOT_core_first) + tmp18 := checkDerefVar(var_glojure_DOT_core_first) tmp19 := lang.Apply(tmp18, []any{v12}) tmp20 := lang.Apply(v3, []any{tmp19}) var v21 any = tmp20 _ = v21 var tmp22 any - tmp23 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp23 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) tmp24 := lang.Apply(tmp23, []any{v21}) if lang.IsTruthy(tmp24) { - tmp25 := checkDerefVar(glojure_DOT_core_keep) - tmp26 := checkDerefVar(glojure_DOT_core_rest) + tmp25 := checkDerefVar(var_glojure_DOT_core_keep) + tmp26 := checkDerefVar(var_glojure_DOT_core_rest) tmp27 := lang.Apply(tmp26, []any{v12}) tmp28 := lang.Apply(tmp25, []any{v3, tmp27}) tmp22 = tmp28 } else { - tmp29 := checkDerefVar(glojure_DOT_core_cons) - tmp30 := checkDerefVar(glojure_DOT_core_keep) - tmp31 := checkDerefVar(glojure_DOT_core_rest) + tmp29 := checkDerefVar(var_glojure_DOT_core_cons) + tmp30 := checkDerefVar(var_glojure_DOT_core_keep) + tmp31 := checkDerefVar(var_glojure_DOT_core_rest) tmp32 := lang.Apply(tmp31, []any{v12}) tmp33 := lang.Apply(tmp30, []any{v3, tmp32}) tmp34 := lang.Apply(tmp29, []any{v21, tmp33}) @@ -29084,10 +29503,11 @@ func LoadNS() { tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) return tmp6 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -29095,7 +29515,7 @@ func LoadNS() { } // keep-indexed { - tmp0 := lang.NewSymbol("keep-indexed").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the non-nil results of (f index item). Note,\n this means false return values will be included. f must be free of\n side-effects. Returns a stateful transducer when no collection is\n provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7372), lang.NewKeyword("end-line"), int(7372))).(*lang.Symbol) + tmp0 := sym_keep_DASH_indexed.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_coll)), kw_doc, "Returns a lazy sequence of the non-nil results of (f index item). Note,\n this means false return values will be included. f must be free of\n side-effects. Returns a stateful transducer when no collection is\n provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(7372), kw_end_DASH_line, int(7372))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -29104,15 +29524,13 @@ func LoadNS() { _ = v3 var tmp4 lang.FnFunc tmp4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v5 := args[0] _ = v5 var tmp6 any { // let // let binding "iv" - tmp7 := checkDerefVar(glojure_DOT_core_volatile_BANG_) + tmp7 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) tmp8 := lang.Apply(tmp7, []any{int64(-1)}) var v9 any = tmp8 _ = v9 @@ -29135,7 +29553,7 @@ func LoadNS() { var tmp13 any { // let // let binding "i" - tmp14 := checkDerefVar(glojure_DOT_core_inc) + tmp14 := checkDerefVar(var_glojure_DOT_core_inc) tmp15, ok := lang.FieldOrMethod(v9, "Deref") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v9, "Deref"))) @@ -29160,7 +29578,7 @@ func LoadNS() { var v22 any = tmp21 _ = v22 var tmp23 any - tmp24 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp24 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) tmp25 := lang.Apply(tmp24, []any{v22}) if lang.IsTruthy(tmp25) { tmp23 = v11 @@ -29172,10 +29590,11 @@ func LoadNS() { } // end let return tmp13 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7382), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7390), lang.NewKeyword("end-column"), int(33)) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7382), kw_column, int(8), kw_end_DASH_line, int(7390), kw_end_DASH_column, int(33)) tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) if err != nil { panic(err) @@ -29184,7 +29603,7 @@ func LoadNS() { } // end let return tmp6 }) - tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7380), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7390), lang.NewKeyword("end-column"), int(35)) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7380), kw_column, int(4), kw_end_DASH_line, int(7390), kw_end_DASH_column, int(35)) tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) if err != nil { panic(err) @@ -29197,10 +29616,11 @@ func LoadNS() { _ = v4 return nil default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -29208,12 +29628,10 @@ func LoadNS() { } // key { - tmp0 := lang.NewSymbol("key").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("e"))), lang.NewKeyword("doc"), "Returns the key of the map entry.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1563), lang.NewKeyword("end-line"), int(1563))).(*lang.Symbol) + tmp0 := sym_key.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_e)), kw_doc, "Returns the key of the map entry.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(1563), kw_end_DASH_line, int(1563))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4, _ := lang.FieldOrMethod(v3, "GetKey") @@ -29223,7 +29641,7 @@ func LoadNS() { tmp5 := lang.Apply(tmp4, []any{}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -29231,18 +29649,16 @@ func LoadNS() { } // keys { - tmp0 := lang.NewSymbol("keys").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"))), lang.NewKeyword("doc"), "Returns a sequence of the map's keys, in the same order as (seq map).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1551), lang.NewKeyword("end-line"), int(1551))).(*lang.Symbol) + tmp0 := sym_keys.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_map)), kw_doc, "Returns a sequence of the map's keys, in the same order as (seq map).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1551), kw_end_DASH_line, int(1551))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4 := lang.Apply(lang.Keys, []any{v3}) return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -29251,7 +29667,7 @@ func LoadNS() { // keyword { tmp1 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() - tmp0 := lang.NewSymbol("keyword").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name"))), lang.NewKeyword("doc"), "Returns a Keyword with the given namespace and name. Do not use :\n in the keyword strings, it will be added automatically.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(609), lang.NewKeyword("end-line"), int(609))).(*lang.Symbol) + tmp0 := sym_keyword.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_name), lang.NewVector(sym_ns, sym_name)), kw_doc, "Returns a Keyword with the given namespace and name. Do not use :\n in the keyword strings, it will be added automatically.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(609), kw_end_DASH_line, int(609))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -29259,20 +29675,20 @@ func LoadNS() { v4 := args[0] _ = v4 var tmp5 any - tmp6 := checkDerefVar(glojure_DOT_core_keyword_QMARK_) + tmp6 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) tmp7 := lang.Apply(tmp6, []any{v4}) if lang.IsTruthy(tmp7) { tmp5 = v4 } else { var tmp8 any - tmp9 := checkDerefVar(glojure_DOT_core_symbol_QMARK_) + tmp9 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) tmp10 := lang.Apply(tmp9, []any{v4}) if lang.IsTruthy(tmp10) { tmp11 := lang.Apply(lang.InternKeywordSymbol, []any{v4}) tmp8 = tmp11 } else { var tmp12 any - tmp13 := checkDerefVar(glojure_DOT_core_string_QMARK_) + tmp13 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) tmp14 := lang.Apply(tmp13, []any{v4}) if lang.IsTruthy(tmp14) { tmp15 := lang.Apply(lang.InternKeywordString, []any{v4}) @@ -29292,11 +29708,12 @@ func LoadNS() { tmp6 := lang.Apply(lang.InternKeyword, []any{v4, v5}) return tmp6 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) tmp4 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -29304,20 +29721,18 @@ func LoadNS() { } // keyword? { - tmp0 := lang.NewSymbol("keyword?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a Keyword", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(563), lang.NewKeyword("end-line"), int(563))).(*lang.Symbol) + tmp0 := sym_keyword_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a Keyword", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(563), kw_end_DASH_line, int(563))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp5 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -29325,34 +29740,32 @@ func LoadNS() { } // last { - tmp0 := lang.NewSymbol("last").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return the last item in coll, in linear time", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(262), lang.NewKeyword("end-line"), int(266))).(*lang.Symbol) + tmp0 := sym_last.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Return the last item in coll, in linear time", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(5), kw_column, int(2), kw_line, int(262), kw_end_DASH_line, int(266))).(*lang.Symbol) var tmp2 lang.FnFunc { // function last var v3 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 recur_loop_32: var tmp5 any - tmp6 := checkDerefVar(glojure_DOT_core_next) + tmp6 := checkDerefVar(var_glojure_DOT_core_next) tmp7 := lang.Apply(tmp6, []any{v4}) if lang.IsTruthy(tmp7) { - tmp9 := checkDerefVar(glojure_DOT_core_next) + tmp9 := checkDerefVar(var_glojure_DOT_core_next) tmp10 := lang.Apply(tmp9, []any{v4}) var tmp8 any = tmp10 v4 = tmp8 goto recur_loop_32 } else { - tmp11 := checkDerefVar(glojure_DOT_core_first) + tmp11 := checkDerefVar(var_glojure_DOT_core_first) tmp12 := lang.Apply(tmp11, []any{v4}) tmp5 = tmp12 } return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(266), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(269), lang.NewKeyword("end-column"), int(21))).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(266), kw_column, int(7), kw_end_DASH_line, int(269), kw_end_DASH_column, int(21))).(lang.FnFunc) v3 = tmp2 _ = v3 } @@ -29363,37 +29776,33 @@ func LoadNS() { } // lazy-cat { - tmp0 := lang.NewSymbol("lazy-cat").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Expands to code which yields a lazy sequence of the concatenation\n of the supplied colls. Each coll expr is not evaluated until it is\n needed. \n\n (lazy-cat xs ys zs) === (concat (lazy-seq xs) (lazy-seq ys) (lazy-seq zs))", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4636), lang.NewKeyword("end-line"), int(4636))).(*lang.Symbol) + tmp0 := sym_lazy_DASH_cat.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_colls)), kw_doc, "Expands to code which yields a lazy sequence of the concatenation\n of the supplied colls. Each coll expr is not evaluated until it is\n needed. \n\n (lazy-cat xs ys zs) === (concat (lazy-seq xs) (lazy-seq ys) (lazy-seq zs))", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(11), kw_line, int(4636), kw_end_DASH_line, int(4636))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 var v5 any = lang.NewList(args[2:]...) _ = v5 - tmp6 := checkDerefVar(glojure_DOT_core_seq) - tmp7 := checkDerefVar(glojure_DOT_core_concat) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("glojure.core/concat")}) - tmp10 := checkDerefVar(glojure_DOT_core_map) + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_concat}) + tmp10 := checkDerefVar(var_glojure_DOT_core_map) var tmp11 lang.FnFunc tmp11 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v12 := args[0] _ = v12 - tmp13 := checkDerefVar(glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/lazy-seq"), v12}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_lazy_DASH_seq, v12}) return tmp14 }) - tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4644), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(4644), lang.NewKeyword("end-column"), int(37)) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4644), kw_column, int(19), kw_end_DASH_line, int(4644), kw_end_DASH_column, int(37)) tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) if err != nil { panic(err) @@ -29404,7 +29813,7 @@ func LoadNS() { return tmp16 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -29412,34 +29821,32 @@ func LoadNS() { } // lazy-seq { - tmp0 := lang.NewSymbol("lazy-seq").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Takes a body of expressions that returns an ISeq or nil, and yields\n a Seqable object that will invoke the body only the first time seq\n is called, and will cache the result and return it on all subsequent\n seq calls. See also - realized?", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(676), lang.NewKeyword("end-line"), int(676))).(*lang.Symbol) + tmp0 := sym_lazy_DASH_seq.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_body)), kw_doc, "Takes a body of expressions that returns an ISeq or nil, and yields\n a Seqable object that will invoke the body only the first time seq\n is called, and will cache the result and return it on all subsequent\n seq calls. See also - realized?", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(11), kw_line, int(676), kw_end_DASH_line, int(676))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 var v5 any = lang.NewList(args[2:]...) _ = v5 - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := checkDerefVar(glojure_DOT_core_list_STAR_) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := checkDerefVar(var_glojure_DOT_core_list_STAR_) tmp8 := lang.NewVector() - tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(683), lang.NewKeyword("column"), int(101), lang.NewKeyword("end-line"), int(683), lang.NewKeyword("end-column"), int(102)) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(683), kw_column, int(101), kw_end_DASH_line, int(683), kw_end_DASH_column, int(102)) tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp11 := lang.Apply(tmp7, []any{lang.NewSymbol("fn*"), tmp10, v5}) - tmp12 := lang.Apply(tmp6, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewLazySeq"), tmp11}) + tmp11 := lang.Apply(tmp7, []any{sym_fn_STAR_, tmp10, v5}) + tmp12 := lang.Apply(tmp6, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_NewLazySeq, tmp11}) return tmp12 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -29447,14 +29854,12 @@ func LoadNS() { } // let { - tmp0 := lang.NewSymbol("let").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "binding => binding-form init-expr\n binding-form => name, or destructuring-form\n destructuring-form => map-destructure-form, or seq-destructure-form\n\n Evaluates the exprs in a lexical context in which the symbols in\n the binding-forms are bound to their respective init-exprs or parts\n therein.\n\n See https://glojure.org/reference/special_forms#binding-forms for\n more information about destructuring.", lang.NewKeyword("forms"), lang.NewVector(lang.NewList(lang.NewSymbol("let"), lang.NewVector(lang.NewSymbol("bindings*")), lang.NewSymbol("exprs*"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4496), lang.NewKeyword("end-line"), int(4496), lang.NewKeyword("special-form"), true)).(*lang.Symbol) + tmp0 := sym_let.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "binding => binding-form init-expr\n binding-form => name, or destructuring-form\n destructuring-form => map-destructure-form, or seq-destructure-form\n\n Evaluates the exprs in a lexical context in which the symbols in\n the binding-forms are bound to their respective init-exprs or parts\n therein.\n\n See https://glojure.org/reference/special_forms#binding-forms for\n more information about destructuring.", kw_forms, lang.NewVector(lang.NewList(sym_let, lang.NewVector(sym_bindings_STAR_), sym_exprs_STAR_)), kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(11), kw_line, int(4496), kw_end_DASH_line, int(4496), kw_special_DASH_form, true)).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -29464,47 +29869,47 @@ func LoadNS() { var v6 any = lang.NewList(args[3:]...) _ = v6 var tmp7 any - tmp8 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp8 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) tmp9 := lang.Apply(tmp8, []any{v5}) if lang.IsTruthy(tmp9) { } else { - tmp10 := checkDerefVar(glojure_DOT_core_str) - tmp11 := checkDerefVar(glojure_DOT_core_first) + tmp10 := checkDerefVar(var_glojure_DOT_core_str) + tmp11 := checkDerefVar(var_glojure_DOT_core_first) tmp12 := lang.Apply(tmp11, []any{v3}) - tmp13 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) - tmp14 := checkDerefVar(glojure_DOT_core_meta) + tmp13 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp14 := checkDerefVar(var_glojure_DOT_core_meta) tmp15 := lang.Apply(tmp14, []any{v3}) - tmp16 := lang.Apply(lang.NewKeyword("line"), []any{tmp15}) + tmp16 := lang.Apply(kw_line, []any{tmp15}) tmp17 := lang.Apply(tmp10, []any{tmp12, " requires ", "a vector for its binding", " in ", tmp13, ":", tmp16}) tmp18 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp17}) panic(tmp18) } _ = tmp7 var tmp19 any - tmp20 := checkDerefVar(glojure_DOT_core_even_QMARK_) - tmp21 := checkDerefVar(glojure_DOT_core_count) + tmp20 := checkDerefVar(var_glojure_DOT_core_even_QMARK_) + tmp21 := checkDerefVar(var_glojure_DOT_core_count) tmp22 := lang.Apply(tmp21, []any{v5}) tmp23 := lang.Apply(tmp20, []any{tmp22}) if lang.IsTruthy(tmp23) { } else { - tmp24 := checkDerefVar(glojure_DOT_core_str) - tmp25 := checkDerefVar(glojure_DOT_core_first) + tmp24 := checkDerefVar(var_glojure_DOT_core_str) + tmp25 := checkDerefVar(var_glojure_DOT_core_first) tmp26 := lang.Apply(tmp25, []any{v3}) - tmp27 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) - tmp28 := checkDerefVar(glojure_DOT_core_meta) + tmp27 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp28 := checkDerefVar(var_glojure_DOT_core_meta) tmp29 := lang.Apply(tmp28, []any{v3}) - tmp30 := lang.Apply(lang.NewKeyword("line"), []any{tmp29}) + tmp30 := lang.Apply(kw_line, []any{tmp29}) tmp31 := lang.Apply(tmp24, []any{tmp26, " requires ", "an even number of forms in binding vector", " in ", tmp27, ":", tmp30}) tmp32 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp31}) panic(tmp32) } _ = tmp19 - tmp33 := checkDerefVar(glojure_DOT_core_seq) - tmp34 := checkDerefVar(glojure_DOT_core_concat) - tmp35 := checkDerefVar(glojure_DOT_core_list) - tmp36 := lang.Apply(tmp35, []any{lang.NewSymbol("let*")}) - tmp37 := checkDerefVar(glojure_DOT_core_list) - tmp38 := checkDerefVar(glojure_DOT_core_destructure) + tmp33 := checkDerefVar(var_glojure_DOT_core_seq) + tmp34 := checkDerefVar(var_glojure_DOT_core_concat) + tmp35 := checkDerefVar(var_glojure_DOT_core_list) + tmp36 := lang.Apply(tmp35, []any{sym_let_STAR_}) + tmp37 := checkDerefVar(var_glojure_DOT_core_list) + tmp38 := checkDerefVar(var_glojure_DOT_core_destructure) tmp39 := lang.Apply(tmp38, []any{v5}) tmp40 := lang.Apply(tmp37, []any{tmp39}) tmp41 := lang.Apply(tmp34, []any{tmp36, tmp40, v6}) @@ -29512,7 +29917,7 @@ func LoadNS() { return tmp42 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -29520,14 +29925,12 @@ func LoadNS() { } // letfn { - tmp0 := lang.NewSymbol("letfn").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fnspecs"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "fnspec ==> (fname [params*] exprs) or (fname ([params*] exprs)+)\n\n Takes a vector of function specs and a body, and generates a set of\n bindings of functions to their names. All of the names are available\n in all of the definitions of the functions, as well as the body.", lang.NewKeyword("forms"), lang.NewVector(lang.NewList(lang.NewSymbol("letfn"), lang.NewVector(lang.NewSymbol("fnspecs*")), lang.NewSymbol("exprs*"))), lang.NewKeyword("url"), nil, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6545), lang.NewKeyword("end-line"), int(6545), lang.NewKeyword("special-form"), true)).(*lang.Symbol) + tmp0 := sym_letfn.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_fnspecs, sym__AMP_, sym_body)), kw_doc, "fnspec ==> (fname [params*] exprs) or (fname ([params*] exprs)+)\n\n Takes a vector of function specs and a body, and generates a set of\n bindings of functions to their names. All of the names are available\n in all of the definitions of the functions, as well as the body.", kw_forms, lang.NewVector(lang.NewList(sym_letfn, lang.NewVector(sym_fnspecs_STAR_), sym_exprs_STAR_)), kw_url, nil, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(11), kw_line, int(6545), kw_end_DASH_line, int(6545), kw_special_DASH_form, true)).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -29536,29 +29939,27 @@ func LoadNS() { _ = v5 var v6 any = lang.NewList(args[3:]...) _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_seq) - tmp8 := checkDerefVar(glojure_DOT_core_concat) - tmp9 := checkDerefVar(glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("letfn*")}) - tmp11 := checkDerefVar(glojure_DOT_core_list) - tmp12 := checkDerefVar(glojure_DOT_core_vec) - tmp13 := checkDerefVar(glojure_DOT_core_interleave) - tmp14 := checkDerefVar(glojure_DOT_core_map) - tmp15 := checkDerefVar(glojure_DOT_core_first) + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_letfn_STAR_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_vec) + tmp13 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp14 := checkDerefVar(var_glojure_DOT_core_map) + tmp15 := checkDerefVar(var_glojure_DOT_core_first) tmp16 := lang.Apply(tmp14, []any{tmp15, v5}) - tmp17 := checkDerefVar(glojure_DOT_core_map) + tmp17 := checkDerefVar(var_glojure_DOT_core_map) var tmp18 lang.FnFunc tmp18 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v19 := args[0] _ = v19 - tmp20 := checkDerefVar(glojure_DOT_core_cons) - tmp21 := lang.Apply(tmp20, []any{lang.NewSymbol("glojure.core/fn"), v19}) + tmp20 := checkDerefVar(var_glojure_DOT_core_cons) + tmp21 := lang.Apply(tmp20, []any{sym_glojure_DOT_core_SLASH_fn, v19}) return tmp21 }) - tmp19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6555), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(6555), lang.NewKeyword("end-column"), int(47)) + tmp19 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6555), kw_column, int(35), kw_end_DASH_line, int(6555), kw_end_DASH_column, int(47)) tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) if err != nil { panic(err) @@ -29572,7 +29973,7 @@ func LoadNS() { return tmp26 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -29580,18 +29981,16 @@ func LoadNS() { } // libspec? { - tmp0 := lang.NewSymbol("libspec?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is a libspec", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5848), lang.NewKeyword("end-line"), int(5848), lang.NewKeyword("private"), true)).(*lang.Symbol) + tmp0 := sym_libspec_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x is a libspec", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(8), kw_line, int(5848), kw_end_DASH_line, int(5848), kw_private, true)).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any { // let // let binding "or__0__auto__" - tmp5 := checkDerefVar(glojure_DOT_core_symbol_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) tmp6 := lang.Apply(tmp5, []any{v3}) var v7 any = tmp6 _ = v7 @@ -29602,7 +30001,7 @@ func LoadNS() { var tmp9 any { // let // let binding "and__0__auto__" - tmp10 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp10 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) tmp11 := lang.Apply(tmp10, []any{v3}) var v12 any = tmp11 _ = v12 @@ -29611,8 +30010,8 @@ func LoadNS() { var tmp14 any { // let // let binding "or__0__auto__" - tmp15 := checkDerefVar(glojure_DOT_core_nil_QMARK_) - tmp16 := checkDerefVar(glojure_DOT_core_second) + tmp15 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp16 := checkDerefVar(var_glojure_DOT_core_second) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := lang.Apply(tmp15, []any{tmp17}) var v19 any = tmp18 @@ -29621,8 +30020,8 @@ func LoadNS() { if lang.IsTruthy(v19) { tmp20 = v19 } else { - tmp21 := checkDerefVar(glojure_DOT_core_keyword_QMARK_) - tmp22 := checkDerefVar(glojure_DOT_core_second) + tmp21 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp22 := checkDerefVar(var_glojure_DOT_core_second) tmp23 := lang.Apply(tmp22, []any{v3}) tmp24 := lang.Apply(tmp21, []any{tmp23}) tmp20 = tmp24 @@ -29641,7 +30040,7 @@ func LoadNS() { } // end let return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -29649,16 +30048,14 @@ func LoadNS() { } // lift-ns { - tmp0 := lang.NewSymbol("lift-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"))), lang.NewKeyword("doc"), "Returns [lifted-ns lifted-kvs] or nil if m can't be lifted.", lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(261), lang.NewKeyword("end-line"), int(261), lang.NewKeyword("private"), true)).(*lang.Symbol) + tmp0 := sym_lift_DASH_ns.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m)), kw_doc, "Returns [lifted-ns lifted-kvs] or nil if m can't be lifted.", kw_file, "glojure/core_print.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(8), kw_line, int(261), kw_end_DASH_line, int(261), kw_private, true)).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any - tmp5 := checkDerefVar(glojure_DOT_core__STAR_print_namespace_maps_STAR_) + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_namespace_DASH_maps_STAR_) if lang.IsTruthy(tmp5) { var tmp6 any { // let @@ -29666,7 +30063,7 @@ func LoadNS() { var v7 any = nil _ = v7 // let binding "G__221" - tmp8 := checkDerefVar(glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) tmp9 := lang.Apply(tmp8, []any{v3}) var v10 any = tmp9 _ = v10 @@ -29674,17 +30071,17 @@ func LoadNS() { var v11 any = v10 _ = v11 // let binding "seq__223" - tmp12 := checkDerefVar(glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := lang.Apply(tmp12, []any{v11}) var v14 any = tmp13 _ = v14 // let binding "first__224" - tmp15 := checkDerefVar(glojure_DOT_core_first) + tmp15 := checkDerefVar(var_glojure_DOT_core_first) tmp16 := lang.Apply(tmp15, []any{v14}) var v17 any = tmp16 _ = v17 // let binding "seq__223" - tmp18 := checkDerefVar(glojure_DOT_core_next) + tmp18 := checkDerefVar(var_glojure_DOT_core_next) tmp19 := lang.Apply(tmp18, []any{v14}) var v20 any = tmp19 _ = v20 @@ -29692,12 +30089,12 @@ func LoadNS() { var v21 any = v17 _ = v21 // let binding "k" - tmp22 := checkDerefVar(glojure_DOT_core_nth) + tmp22 := checkDerefVar(var_glojure_DOT_core_nth) tmp23 := lang.Apply(tmp22, []any{v21, int64(0), nil}) var v24 any = tmp23 _ = v24 // let binding "v" - tmp25 := checkDerefVar(glojure_DOT_core_nth) + tmp25 := checkDerefVar(var_glojure_DOT_core_nth) tmp26 := lang.Apply(tmp25, []any{v21, int64(1), nil}) var v27 any = tmp26 _ = v27 @@ -29709,7 +30106,7 @@ func LoadNS() { _ = v29 // let binding "kvs" tmp30 := lang.NewVector() - tmp31 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(267), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(267), lang.NewKeyword("end-column"), int(17)) + tmp31 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(267), kw_column, int(16), kw_end_DASH_line, int(267), kw_end_DASH_column, int(17)) tmp32, err := lang.WithMeta(tmp30, tmp31.(lang.IPersistentMap)) if err != nil { panic(err) @@ -29737,17 +30134,17 @@ func LoadNS() { var v40 any = v36 _ = v40 // let binding "seq__229" - tmp41 := checkDerefVar(glojure_DOT_core_seq) + tmp41 := checkDerefVar(var_glojure_DOT_core_seq) tmp42 := lang.Apply(tmp41, []any{v40}) var v43 any = tmp42 _ = v43 // let binding "first__230" - tmp44 := checkDerefVar(glojure_DOT_core_first) + tmp44 := checkDerefVar(var_glojure_DOT_core_first) tmp45 := lang.Apply(tmp44, []any{v43}) var v46 any = tmp45 _ = v46 // let binding "seq__229" - tmp47 := checkDerefVar(glojure_DOT_core_next) + tmp47 := checkDerefVar(var_glojure_DOT_core_next) tmp48 := lang.Apply(tmp47, []any{v43}) var v49 any = tmp48 _ = v49 @@ -29755,12 +30152,12 @@ func LoadNS() { var v50 any = v46 _ = v50 // let binding "k" - tmp51 := checkDerefVar(glojure_DOT_core_nth) + tmp51 := checkDerefVar(var_glojure_DOT_core_nth) tmp52 := lang.Apply(tmp51, []any{v50, int64(0), nil}) var v53 any = tmp52 _ = v53 // let binding "v" - tmp54 := checkDerefVar(glojure_DOT_core_nth) + tmp54 := checkDerefVar(var_glojure_DOT_core_nth) tmp55 := lang.Apply(tmp54, []any{v50, int64(1), nil}) var v56 any = tmp55 _ = v56 @@ -29776,24 +30173,24 @@ func LoadNS() { var tmp60 any if lang.IsTruthy(v57) { var tmp61 any - tmp62 := checkDerefVar(glojure_DOT_core_qualified_ident_QMARK_) + tmp62 := checkDerefVar(var_glojure_DOT_core_qualified_DASH_ident_QMARK_) tmp63 := lang.Apply(tmp62, []any{v53}) if lang.IsTruthy(tmp63) { var tmp64 any if lang.IsTruthy(v39) { var tmp65 any - tmp66 := checkDerefVar(glojure_DOT_core__EQ_) - tmp67 := checkDerefVar(glojure_DOT_core_namespace) + tmp66 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp67 := checkDerefVar(var_glojure_DOT_core_namespace) tmp68 := lang.Apply(tmp67, []any{v53}) tmp69 := lang.Apply(tmp66, []any{v39, tmp68}) if lang.IsTruthy(tmp69) { var tmp70 any = v39 var tmp71 any = v58 - tmp73 := checkDerefVar(glojure_DOT_core_conj) - tmp74 := checkDerefVar(glojure_DOT_core_strip_ns) + tmp73 := checkDerefVar(var_glojure_DOT_core_conj) + tmp74 := checkDerefVar(var_glojure_DOT_core_strip_DASH_ns) tmp75 := lang.Apply(tmp74, []any{v53}) tmp76 := lang.NewVector(tmp75, v56) - tmp77 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(272), lang.NewKeyword("column"), int(43), lang.NewKeyword("end-line"), int(272), lang.NewKeyword("end-column"), int(58)) + tmp77 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(272), kw_column, int(43), kw_end_DASH_line, int(272), kw_end_DASH_column, int(58)) tmp78, err := lang.WithMeta(tmp76, tmp77.(lang.IPersistentMap)) if err != nil { panic(err) @@ -29811,7 +30208,7 @@ func LoadNS() { var tmp80 any { // let // let binding "temp__0__auto__" - tmp81 := checkDerefVar(glojure_DOT_core_namespace) + tmp81 := checkDerefVar(var_glojure_DOT_core_namespace) tmp82 := lang.Apply(tmp81, []any{v53}) var v83 any = tmp82 _ = v83 @@ -29824,11 +30221,11 @@ func LoadNS() { _ = v86 var tmp87 any = v86 var tmp88 any = v58 - tmp90 := checkDerefVar(glojure_DOT_core_conj) - tmp91 := checkDerefVar(glojure_DOT_core_strip_ns) + tmp90 := checkDerefVar(var_glojure_DOT_core_conj) + tmp91 := checkDerefVar(var_glojure_DOT_core_strip_DASH_ns) tmp92 := lang.Apply(tmp91, []any{v53}) tmp93 := lang.NewVector(tmp92, v56) - tmp94 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(274), lang.NewKeyword("column"), int(47), lang.NewKeyword("end-line"), int(274), lang.NewKeyword("end-column"), int(62)) + tmp94 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(274), kw_column, int(47), kw_end_DASH_line, int(274), kw_end_DASH_column, int(62)) tmp95, err := lang.WithMeta(tmp93, tmp94.(lang.IPersistentMap)) if err != nil { panic(err) @@ -29853,7 +30250,7 @@ func LoadNS() { tmp60 = tmp61 } else { tmp81 := lang.NewVector(v39, v59) - tmp82 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(275), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(275), lang.NewKeyword("end-column"), int(16)) + tmp82 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(275), kw_column, int(9), kw_end_DASH_line, int(275), kw_end_DASH_column, int(16)) tmp83, err := lang.WithMeta(tmp81, tmp82.(lang.IPersistentMap)) if err != nil { panic(err) @@ -29873,7 +30270,7 @@ func LoadNS() { } return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -29881,12 +30278,10 @@ func LoadNS() { } // line-seq { - tmp0 := lang.NewSymbol("line-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rdr"))), lang.NewKeyword("doc"), "Returns the lines of text from rdr as a lazy sequence of strings.\n rdr must implement java.io.BufferedReader.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3068), lang.NewKeyword("end-line"), int(3068))).(*lang.Symbol) + tmp0 := sym_line_DASH_seq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_rdr)), kw_doc, "Returns the lines of text from rdr as a lazy sequence of strings.\n rdr must implement java.io.BufferedReader.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(3068), kw_end_DASH_line, int(3068))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any @@ -29912,13 +30307,11 @@ func LoadNS() { // let binding "line" var v10 any = v7 _ = v10 - tmp11 := checkDerefVar(glojure_DOT_core_cons) + tmp11 := checkDerefVar(var_glojure_DOT_core_cons) var tmp12 lang.FnFunc tmp12 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - tmp13 := checkDerefVar(glojure_DOT_core_line_seq) + checkArity(args, 0) + tmp13 := checkDerefVar(var_glojure_DOT_core_line_DASH_seq) tmp14 := lang.Apply(tmp13, []any{v3}) return tmp14 }) @@ -29933,7 +30326,7 @@ func LoadNS() { } // end let return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -29941,7 +30334,7 @@ func LoadNS() { } // list { - tmp0 := lang.NewSymbol("list").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("items"))), lang.NewKeyword("doc"), "Creates a new list containing the items.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(15), lang.NewKeyword("end-line"), int(18))).(*lang.Symbol) + tmp0 := sym_list.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_items)), kw_doc, "Creates a new list containing the items.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(6), kw_column, int(2), kw_line, int(15), kw_end_DASH_line, int(18))).(*lang.Symbol) tmp1 := ns.InternWithValue(tmp0, lang.NewList, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -29949,14 +30342,14 @@ func LoadNS() { } // list* { - tmp0 := lang.NewSymbol("list*").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("args")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Creates a new seq containing the items prepended to the rest, the\n last of which will be treated as a sequence.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(641), lang.NewKeyword("end-line"), int(641))).(*lang.Symbol) + tmp0 := sym_list_STAR_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_args), lang.NewVector(sym_a, sym_args), lang.NewVector(sym_a, sym_b, sym_args), lang.NewVector(sym_a, sym_b, sym_c, sym_args), lang.NewVector(sym_a, sym_b, sym_c, sym_d, sym__AMP_, sym_more)), kw_doc, "Creates a new seq containing the items prepended to the rest, the\n last of which will be treated as a sequence.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(641), kw_end_DASH_line, int(641))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 case 2: @@ -29964,7 +30357,7 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_cons) + tmp5 := checkDerefVar(var_glojure_DOT_core_cons) tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 case 3: @@ -29974,8 +30367,8 @@ func LoadNS() { _ = v4 v5 := args[2] _ = v5 - tmp6 := checkDerefVar(glojure_DOT_core_cons) - tmp7 := checkDerefVar(glojure_DOT_core_cons) + tmp6 := checkDerefVar(var_glojure_DOT_core_cons) + tmp7 := checkDerefVar(var_glojure_DOT_core_cons) tmp8 := lang.Apply(tmp7, []any{v4, v5}) tmp9 := lang.Apply(tmp6, []any{v3, tmp8}) return tmp9 @@ -29988,17 +30381,15 @@ func LoadNS() { _ = v5 v6 := args[3] _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_cons) - tmp8 := checkDerefVar(glojure_DOT_core_cons) - tmp9 := checkDerefVar(glojure_DOT_core_cons) + tmp7 := checkDerefVar(var_glojure_DOT_core_cons) + tmp8 := checkDerefVar(var_glojure_DOT_core_cons) + tmp9 := checkDerefVar(var_glojure_DOT_core_cons) tmp10 := lang.Apply(tmp9, []any{v5, v6}) tmp11 := lang.Apply(tmp8, []any{v4, tmp10}) tmp12 := lang.Apply(tmp7, []any{v3, tmp11}) return tmp12 default: - if len(args) < 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 4) v3 := args[0] _ = v3 v4 := args[1] @@ -30009,11 +30400,11 @@ func LoadNS() { _ = v6 var v7 any = lang.NewList(args[4:]...) _ = v7 - tmp8 := checkDerefVar(glojure_DOT_core_cons) - tmp9 := checkDerefVar(glojure_DOT_core_cons) - tmp10 := checkDerefVar(glojure_DOT_core_cons) - tmp11 := checkDerefVar(glojure_DOT_core_cons) - tmp12 := checkDerefVar(glojure_DOT_core_spread) + tmp8 := checkDerefVar(var_glojure_DOT_core_cons) + tmp9 := checkDerefVar(var_glojure_DOT_core_cons) + tmp10 := checkDerefVar(var_glojure_DOT_core_cons) + tmp11 := checkDerefVar(var_glojure_DOT_core_cons) + tmp12 := checkDerefVar(var_glojure_DOT_core_spread) tmp13 := lang.Apply(tmp12, []any{v7}) tmp14 := lang.Apply(tmp11, []any{v6, tmp13}) tmp15 := lang.Apply(tmp10, []any{v5, tmp14}) @@ -30022,7 +30413,7 @@ func LoadNS() { return tmp17 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -30030,20 +30421,18 @@ func LoadNS() { } // list? { - tmp0 := lang.NewSymbol("list?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements IPersistentList", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6198), lang.NewKeyword("end-line"), int(6198))).(*lang.Symbol) + tmp0 := sym_list_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x implements IPersistentList", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(6198), kw_end_DASH_line, int(6198))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp5 := reflect.TypeOf((*lang.IPersistentList)(nil)).Elem() tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -30051,20 +30440,18 @@ func LoadNS() { } // load { - tmp0 := lang.NewSymbol("load").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("paths"))), lang.NewKeyword("doc"), "Loads Clojure code from resources in classpath. A path is interpreted as\n classpath-relative if it begins with a slash or relative to the root\n directory for the current namespace otherwise.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("redef"), true, lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6095), lang.NewKeyword("end-line"), int(6095))).(*lang.Symbol) + tmp0 := sym_load.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_paths)), kw_doc, "Loads Clojure code from resources in classpath. A path is interpreted as\n classpath-relative if it begins with a slash or relative to the root\n directory for the current namespace otherwise.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_redef, true, kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(6095), kw_end_DASH_line, int(6095))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 var tmp4 any { // let // let binding "seq_133" - tmp5 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) tmp6 := lang.Apply(tmp5, []any{v3}) var v7 any = tmp6 _ = v7 @@ -30079,7 +30466,7 @@ func LoadNS() { _ = v10 for { var tmp11 any - tmp12 := checkDerefVar(glojure_DOT_core__LT_) + tmp12 := checkDerefVar(var_glojure_DOT_core__LT_) tmp13 := lang.Apply(tmp12, []any{v10, v9}) if lang.IsTruthy(tmp13) { var tmp14 any @@ -30100,10 +30487,10 @@ func LoadNS() { if lang.IsTruthy(tmp20) { tmp19 = v17 } else { - tmp21 := checkDerefVar(glojure_DOT_core_str) - tmp22 := checkDerefVar(glojure_DOT_core_root_directory) - tmp23 := checkDerefVar(glojure_DOT_core_ns_name) - tmp24 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) + tmp21 := checkDerefVar(var_glojure_DOT_core_str) + tmp22 := checkDerefVar(var_glojure_DOT_core_root_DASH_directory) + tmp23 := checkDerefVar(var_glojure_DOT_core_ns_DASH_name) + tmp24 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) tmp25 := lang.Apply(tmp23, []any{tmp24}) tmp26 := lang.Apply(tmp22, []any{tmp25}) tmp27 := lang.Apply(tmp21, []any{tmp26, lang.NewChar(47), v17}) @@ -30112,35 +30499,35 @@ func LoadNS() { var v28 any = tmp19 _ = v28 var tmp29 any - tmp30 := checkDerefVar(glojure_DOT_core__STAR_loading_verbosely_STAR_) + tmp30 := checkDerefVar(var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_) if lang.IsTruthy(tmp30) { - tmp31 := checkDerefVar(glojure_DOT_core_printf) + tmp31 := checkDerefVar(var_glojure_DOT_core_printf) tmp32 := lang.Apply(tmp31, []any{"(glojure.core/load \"%s\")\n", v28}) _ = tmp32 - tmp33 := checkDerefVar(glojure_DOT_core_flush) + tmp33 := checkDerefVar(var_glojure_DOT_core_flush) tmp34 := lang.Apply(tmp33, nil) tmp29 = tmp34 } else { } _ = tmp29 - tmp35 := checkDerefVar(glojure_DOT_core_check_cyclic_dependency) + tmp35 := checkDerefVar(var_glojure_DOT_core_check_DASH_cyclic_DASH_dependency) tmp36 := lang.Apply(tmp35, []any{v28}) _ = tmp36 var tmp37 any - tmp38 := checkDerefVar(glojure_DOT_core__EQ_) - tmp39 := checkDerefVar(glojure_DOT_core_first) - tmp40 := checkDerefVar(glojure_DOT_core__STAR_pending_paths_STAR_) + tmp38 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp39 := checkDerefVar(var_glojure_DOT_core_first) + tmp40 := checkDerefVar(var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_) tmp41 := lang.Apply(tmp39, []any{tmp40}) tmp42 := lang.Apply(tmp38, []any{v28, tmp41}) if lang.IsTruthy(tmp42) { } else { var tmp43 any { // let - tmp44 := checkDerefVar(glojure_DOT_core_push_thread_bindings) - tmp45 := checkDerefVar(glojure_DOT_core_hash_map) - tmp46 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*pending-paths*")) - tmp47 := checkDerefVar(glojure_DOT_core_conj) - tmp48 := checkDerefVar(glojure_DOT_core__STAR_pending_paths_STAR_) + tmp44 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp45 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp46 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_pending_DASH_paths_STAR_) + tmp47 := checkDerefVar(var_glojure_DOT_core_conj) + tmp48 := checkDerefVar(var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_) tmp49 := lang.Apply(tmp47, []any{tmp48, v28}) tmp50 := lang.Apply(tmp45, []any{tmp46, tmp49}) tmp51 := lang.Apply(tmp44, []any{tmp50}) @@ -30148,7 +30535,7 @@ func LoadNS() { var tmp52 any func() { defer func() { - tmp53 := checkDerefVar(glojure_DOT_core_pop_thread_bindings) + tmp53 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) tmp54 := lang.Apply(tmp53, nil) _ = tmp54 }() @@ -30170,7 +30557,7 @@ func LoadNS() { var tmp19 any = v7 var tmp20 any = v8 var tmp21 any = v9 - tmp23 := checkDerefVar(glojure_DOT_core_unchecked_inc) + tmp23 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) tmp24 := lang.Apply(tmp23, []any{v10}) var tmp22 any = tmp24 v7 = tmp19 @@ -30184,7 +30571,7 @@ func LoadNS() { var tmp15 any { // let // let binding "temp__0__auto__" - tmp16 := checkDerefVar(glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_seq) tmp17 := lang.Apply(tmp16, []any{v7}) var v18 any = tmp17 _ = v18 @@ -30196,26 +30583,26 @@ func LoadNS() { var v21 any = v18 _ = v21 var tmp22 any - tmp23 := checkDerefVar(glojure_DOT_core_chunked_seq_QMARK_) + tmp23 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) tmp24 := lang.Apply(tmp23, []any{v21}) if lang.IsTruthy(tmp24) { var tmp25 any { // let // let binding "c__0__auto__" - tmp26 := checkDerefVar(glojure_DOT_core_chunk_first) + tmp26 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) tmp27 := lang.Apply(tmp26, []any{v21}) var v28 any = tmp27 _ = v28 - tmp30 := checkDerefVar(glojure_DOT_core_chunk_rest) + tmp30 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) tmp31 := lang.Apply(tmp30, []any{v21}) var tmp29 any = tmp31 var tmp32 any = v28 - tmp34 := checkDerefVar(glojure_DOT_core_int) - tmp35 := checkDerefVar(glojure_DOT_core_count) + tmp34 := checkDerefVar(var_glojure_DOT_core_int) + tmp35 := checkDerefVar(var_glojure_DOT_core_count) tmp36 := lang.Apply(tmp35, []any{v28}) tmp37 := lang.Apply(tmp34, []any{tmp36}) var tmp33 any = tmp37 - tmp39 := checkDerefVar(glojure_DOT_core_int) + tmp39 := checkDerefVar(var_glojure_DOT_core_int) tmp40 := lang.Apply(tmp39, []any{int64(0)}) var tmp38 any = tmp40 v7 = tmp29 @@ -30229,7 +30616,7 @@ func LoadNS() { var tmp26 any { // let // let binding "path" - tmp27 := checkDerefVar(glojure_DOT_core_first) + tmp27 := checkDerefVar(var_glojure_DOT_core_first) tmp28 := lang.Apply(tmp27, []any{v21}) var v29 any = tmp28 _ = v29 @@ -30241,10 +30628,10 @@ func LoadNS() { if lang.IsTruthy(tmp32) { tmp31 = v29 } else { - tmp33 := checkDerefVar(glojure_DOT_core_str) - tmp34 := checkDerefVar(glojure_DOT_core_root_directory) - tmp35 := checkDerefVar(glojure_DOT_core_ns_name) - tmp36 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) + tmp33 := checkDerefVar(var_glojure_DOT_core_str) + tmp34 := checkDerefVar(var_glojure_DOT_core_root_DASH_directory) + tmp35 := checkDerefVar(var_glojure_DOT_core_ns_DASH_name) + tmp36 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) tmp37 := lang.Apply(tmp35, []any{tmp36}) tmp38 := lang.Apply(tmp34, []any{tmp37}) tmp39 := lang.Apply(tmp33, []any{tmp38, lang.NewChar(47), v29}) @@ -30253,35 +30640,35 @@ func LoadNS() { var v40 any = tmp31 _ = v40 var tmp41 any - tmp42 := checkDerefVar(glojure_DOT_core__STAR_loading_verbosely_STAR_) + tmp42 := checkDerefVar(var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_) if lang.IsTruthy(tmp42) { - tmp43 := checkDerefVar(glojure_DOT_core_printf) + tmp43 := checkDerefVar(var_glojure_DOT_core_printf) tmp44 := lang.Apply(tmp43, []any{"(glojure.core/load \"%s\")\n", v40}) _ = tmp44 - tmp45 := checkDerefVar(glojure_DOT_core_flush) + tmp45 := checkDerefVar(var_glojure_DOT_core_flush) tmp46 := lang.Apply(tmp45, nil) tmp41 = tmp46 } else { } _ = tmp41 - tmp47 := checkDerefVar(glojure_DOT_core_check_cyclic_dependency) + tmp47 := checkDerefVar(var_glojure_DOT_core_check_DASH_cyclic_DASH_dependency) tmp48 := lang.Apply(tmp47, []any{v40}) _ = tmp48 var tmp49 any - tmp50 := checkDerefVar(glojure_DOT_core__EQ_) - tmp51 := checkDerefVar(glojure_DOT_core_first) - tmp52 := checkDerefVar(glojure_DOT_core__STAR_pending_paths_STAR_) + tmp50 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp51 := checkDerefVar(var_glojure_DOT_core_first) + tmp52 := checkDerefVar(var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_) tmp53 := lang.Apply(tmp51, []any{tmp52}) tmp54 := lang.Apply(tmp50, []any{v40, tmp53}) if lang.IsTruthy(tmp54) { } else { var tmp55 any { // let - tmp56 := checkDerefVar(glojure_DOT_core_push_thread_bindings) - tmp57 := checkDerefVar(glojure_DOT_core_hash_map) - tmp58 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*pending-paths*")) - tmp59 := checkDerefVar(glojure_DOT_core_conj) - tmp60 := checkDerefVar(glojure_DOT_core__STAR_pending_paths_STAR_) + tmp56 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp57 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp58 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_pending_DASH_paths_STAR_) + tmp59 := checkDerefVar(var_glojure_DOT_core_conj) + tmp60 := checkDerefVar(var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_) tmp61 := lang.Apply(tmp59, []any{tmp60, v40}) tmp62 := lang.Apply(tmp57, []any{tmp58, tmp61}) tmp63 := lang.Apply(tmp56, []any{tmp62}) @@ -30289,7 +30676,7 @@ func LoadNS() { var tmp64 any func() { defer func() { - tmp65 := checkDerefVar(glojure_DOT_core_pop_thread_bindings) + tmp65 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) tmp66 := lang.Apply(tmp65, nil) _ = tmp66 }() @@ -30308,7 +30695,7 @@ func LoadNS() { tmp30 = tmp49 } // end let _ = tmp30 - tmp32 := checkDerefVar(glojure_DOT_core_next) + tmp32 := checkDerefVar(var_glojure_DOT_core_next) tmp33 := lang.Apply(tmp32, []any{v21}) var tmp31 any = tmp33 var tmp34 any = nil @@ -30338,7 +30725,7 @@ func LoadNS() { return tmp4 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -30346,12 +30733,10 @@ func LoadNS() { } // load-all { - tmp0 := lang.NewSymbol("load-all").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"), lang.NewSymbol("need-ns"), lang.NewSymbol("require"))), lang.NewKeyword("doc"), "Loads a lib given its name and forces a load of any libs it directly or\n indirectly loads. If need-ns, ensures that the associated namespace\n exists after loading. If require, records the load so any duplicate loads\n can be skipped.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5892), lang.NewKeyword("end-line"), int(5892), lang.NewKeyword("private"), true)).(*lang.Symbol) + tmp0 := sym_load_DASH_all.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_lib, sym_need_DASH_ns, sym_require)), kw_doc, "Loads a lib given its name and forces a load of any libs it directly or\n indirectly loads. If need-ns, ensures that the associated namespace\n exists after loading. If require, records the load so any duplicate loads\n can be skipped.", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(8), kw_line, int(5892), kw_end_DASH_line, int(5892), kw_private, true)).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -30360,37 +30745,33 @@ func LoadNS() { _ = v5 var tmp6 lang.FnFunc tmp6 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - tmp7 := checkDerefVar(glojure_DOT_core_commute) - tmp8 := checkDerefVar(glojure_DOT_core__STAR_loaded_libs_STAR_) + checkArity(args, 0) + tmp7 := checkDerefVar(var_glojure_DOT_core_commute) + tmp8 := checkDerefVar(var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_) var tmp9 lang.FnFunc tmp9 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v10 := args[0] _ = v10 v11 := args[1] _ = v11 - tmp12 := checkDerefVar(glojure_DOT_core_reduce1) - tmp13 := checkDerefVar(glojure_DOT_core_conj) + tmp12 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp13 := checkDerefVar(var_glojure_DOT_core_conj) tmp14 := lang.Apply(tmp12, []any{tmp13, v10, v11}) return tmp14 }) - tmp10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5899), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(5899), lang.NewKeyword("end-column"), int(47)) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5899), kw_column, int(27), kw_end_DASH_line, int(5899), kw_end_DASH_column, int(47)) tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) if err != nil { panic(err) } var tmp12 any { // let - tmp13 := checkDerefVar(glojure_DOT_core_push_thread_bindings) - tmp14 := checkDerefVar(glojure_DOT_core_hash_map) - tmp15 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*loaded-libs*")) - tmp16 := checkDerefVar(glojure_DOT_core_ref) - tmp17 := checkDerefVar(glojure_DOT_core_sorted_set) + tmp13 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp14 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp15 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_loaded_DASH_libs_STAR_) + tmp16 := checkDerefVar(var_glojure_DOT_core_ref) + tmp17 := checkDerefVar(var_glojure_DOT_core_sorted_DASH_set) tmp18 := lang.Apply(tmp17, nil) tmp19 := lang.Apply(tmp16, []any{tmp18}) tmp20 := lang.Apply(tmp14, []any{tmp15, tmp19}) @@ -30399,15 +30780,15 @@ func LoadNS() { var tmp22 any func() { defer func() { - tmp23 := checkDerefVar(glojure_DOT_core_pop_thread_bindings) + tmp23 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) tmp24 := lang.Apply(tmp23, nil) _ = tmp24 }() - tmp25 := checkDerefVar(glojure_DOT_core_load_one) + tmp25 := checkDerefVar(var_glojure_DOT_core_load_DASH_one) tmp26 := lang.Apply(tmp25, []any{v3, v4, v5}) _ = tmp26 - tmp27 := checkDerefVar(glojure_DOT_core_deref) - tmp28 := checkDerefVar(glojure_DOT_core__STAR_loaded_libs_STAR_) + tmp27 := checkDerefVar(var_glojure_DOT_core_deref) + tmp28 := checkDerefVar(var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_) tmp29 := lang.Apply(tmp27, []any{tmp28}) tmp22 = tmp29 }() @@ -30423,7 +30804,7 @@ func LoadNS() { tmp8 := lang.Apply(tmp7, []any{tmp6}) return tmp8 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -30431,12 +30812,10 @@ func LoadNS() { } // load-data-reader-file { - tmp0 := lang.NewSymbol("load-data-reader-file").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7836), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7836), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("mappings"), lang.NewSymbol("url"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym_load_DASH_data_DASH_reader_DASH_file.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7836), kw_column, int(8), kw_end_DASH_line, int(7836), kw_end_DASH_column, int(28), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_mappings, sym_url)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -30477,9 +30856,9 @@ func LoadNS() { }() var tmp14 any { // let - tmp15 := checkDerefVar(glojure_DOT_core_push_thread_bindings) - tmp16 := checkDerefVar(glojure_DOT_core_hash_map) - tmp17 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*file*")) + tmp15 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp16 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp17 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_file_STAR_) tmp18, ok := lang.FieldOrMethod(v4, "getFile") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "getFile"))) @@ -30497,7 +30876,7 @@ func LoadNS() { var tmp22 any func() { defer func() { - tmp23 := checkDerefVar(glojure_DOT_core_pop_thread_bindings) + tmp23 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) tmp24 := lang.Apply(tmp23, nil) _ = tmp24 }() @@ -30522,16 +30901,16 @@ func LoadNS() { } tmp30 := lang.Apply(tmp29, []any{"cljc"}) if lang.IsTruthy(tmp30) { - tmp31 := lang.NewMap(lang.NewKeyword("eof"), nil, lang.NewKeyword("read-cond"), lang.NewKeyword("allow")) - tmp32 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7842), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7842), lang.NewKeyword("end-column"), int(52)) + tmp31 := lang.NewMap(kw_eof, nil, kw_read_DASH_cond, kw_allow) + tmp32 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7842), kw_column, int(25), kw_end_DASH_line, int(7842), kw_end_DASH_column, int(52)) tmp33, err := lang.WithMeta(tmp31, tmp32.(lang.IPersistentMap)) if err != nil { panic(err) } tmp26 = tmp33 } else { - tmp34 := lang.NewMap(lang.NewKeyword("eof"), nil) - tmp35 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7843), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7843), lang.NewKeyword("end-column"), int(34)) + tmp34 := lang.NewMap(kw_eof, nil) + tmp35 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7843), kw_column, int(25), kw_end_DASH_line, int(7843), kw_end_DASH_column, int(34)) tmp36, err := lang.WithMeta(tmp34, tmp35.(lang.IPersistentMap)) if err != nil { panic(err) @@ -30541,21 +30920,21 @@ func LoadNS() { var v37 any = tmp26 _ = v37 // let binding "new-mappings" - tmp38 := checkDerefVar(glojure_DOT_core_read) + tmp38 := checkDerefVar(var_glojure_DOT_core_read) tmp39 := lang.Apply(tmp38, []any{v37, v10}) var v40 any = tmp39 _ = v40 var tmp41 any - tmp42 := checkDerefVar(glojure_DOT_core_not) - tmp43 := checkDerefVar(glojure_DOT_core_map_QMARK_) + tmp42 := checkDerefVar(var_glojure_DOT_core_not) + tmp43 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) tmp44 := lang.Apply(tmp43, []any{v40}) tmp45 := lang.Apply(tmp42, []any{tmp44}) if lang.IsTruthy(tmp45) { - tmp46 := checkDerefVar(glojure_DOT_core_ex_info) - tmp47 := checkDerefVar(glojure_DOT_core_str) + tmp46 := checkDerefVar(var_glojure_DOT_core_ex_DASH_info) + tmp47 := checkDerefVar(var_glojure_DOT_core_str) tmp48 := lang.Apply(tmp47, []any{"Not a valid data-reader map"}) - tmp49 := lang.NewMap(lang.NewKeyword("url"), v4) - tmp50 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7847), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(7847), lang.NewKeyword("end-column"), int(36)) + tmp49 := lang.NewMap(kw_url, v4) + tmp50 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7847), kw_column, int(27), kw_end_DASH_line, int(7847), kw_end_DASH_column, int(36)) tmp51, err := lang.WithMeta(tmp49, tmp50.(lang.IPersistentMap)) if err != nil { panic(err) @@ -30565,12 +30944,10 @@ func LoadNS() { } else { } _ = tmp41 - tmp53 := checkDerefVar(glojure_DOT_core_reduce) + tmp53 := checkDerefVar(var_glojure_DOT_core_reduce) var tmp54 lang.FnFunc tmp54 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v55 := args[0] _ = v55 v56 := args[1] @@ -30581,26 +30958,26 @@ func LoadNS() { var v58 any = v56 _ = v58 // let binding "k" - tmp59 := checkDerefVar(glojure_DOT_core_nth) + tmp59 := checkDerefVar(var_glojure_DOT_core_nth) tmp60 := lang.Apply(tmp59, []any{v58, int64(0), nil}) var v61 any = tmp60 _ = v61 // let binding "v" - tmp62 := checkDerefVar(glojure_DOT_core_nth) + tmp62 := checkDerefVar(var_glojure_DOT_core_nth) tmp63 := lang.Apply(tmp62, []any{v58, int64(1), nil}) var v64 any = tmp63 _ = v64 var tmp65 any - tmp66 := checkDerefVar(glojure_DOT_core_not) - tmp67 := checkDerefVar(glojure_DOT_core_symbol_QMARK_) + tmp66 := checkDerefVar(var_glojure_DOT_core_not) + tmp67 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) tmp68 := lang.Apply(tmp67, []any{v61}) tmp69 := lang.Apply(tmp66, []any{tmp68}) if lang.IsTruthy(tmp69) { - tmp70 := checkDerefVar(glojure_DOT_core_ex_info) - tmp71 := checkDerefVar(glojure_DOT_core_str) + tmp70 := checkDerefVar(var_glojure_DOT_core_ex_DASH_info) + tmp71 := checkDerefVar(var_glojure_DOT_core_str) tmp72 := lang.Apply(tmp71, []any{"Invalid form in data-reader file"}) - tmp73 := lang.NewMap(lang.NewKeyword("url"), v4, lang.NewKeyword("form"), v61) - tmp74 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7852), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(7853), lang.NewKeyword("end-column"), int(38)) + tmp73 := lang.NewMap(kw_url, v4, kw_form, v61) + tmp74 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7852), kw_column, int(30), kw_end_DASH_line, int(7853), kw_end_DASH_column, int(38)) tmp75, err := lang.WithMeta(tmp73, tmp74.(lang.IPersistentMap)) if err != nil { panic(err) @@ -30613,7 +30990,7 @@ func LoadNS() { var tmp77 any { // let // let binding "v-var" - tmp78 := checkDerefVar(glojure_DOT_core_data_reader_var) + tmp78 := checkDerefVar(var_glojure_DOT_core_data_DASH_reader_DASH_var) tmp79 := lang.Apply(tmp78, []any{v64}) var v80 any = tmp79 _ = v80 @@ -30621,13 +30998,13 @@ func LoadNS() { var tmp82 any { // let // let binding "and__0__auto__" - tmp83 := checkDerefVar(glojure_DOT_core_contains_QMARK_) + tmp83 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) tmp84 := lang.Apply(tmp83, []any{v3, v61}) var v85 any = tmp84 _ = v85 var tmp86 any if lang.IsTruthy(v85) { - tmp87 := checkDerefVar(glojure_DOT_core_not_EQ_) + tmp87 := checkDerefVar(var_glojure_DOT_core_not_EQ_) tmp88 := lang.Apply(v3, []any{v61}) tmp89 := lang.Apply(tmp87, []any{tmp88, v80}) tmp86 = tmp89 @@ -30637,9 +31014,9 @@ func LoadNS() { tmp82 = tmp86 } // end let if lang.IsTruthy(tmp82) { - tmp83 := checkDerefVar(glojure_DOT_core_ex_info) - tmp84 := lang.NewMap(lang.NewKeyword("url"), v4, lang.NewKeyword("conflict"), v61, lang.NewKeyword("mappings"), v55) - tmp85 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7858), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(7860), lang.NewKeyword("end-column"), int(44)) + tmp83 := checkDerefVar(var_glojure_DOT_core_ex_DASH_info) + tmp84 := lang.NewMap(kw_url, v4, kw_conflict, v61, kw_mappings, v55) + tmp85 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7858), kw_column, int(32), kw_end_DASH_line, int(7860), kw_end_DASH_column, int(44)) tmp86, err := lang.WithMeta(tmp84, tmp85.(lang.IPersistentMap)) if err != nil { panic(err) @@ -30649,7 +31026,7 @@ func LoadNS() { } else { } _ = tmp81 - tmp88 := checkDerefVar(glojure_DOT_core_assoc) + tmp88 := checkDerefVar(var_glojure_DOT_core_assoc) tmp89 := lang.Apply(tmp88, []any{v55, v61, v80}) tmp77 = tmp89 } // end let @@ -30657,7 +31034,7 @@ func LoadNS() { } // end let return tmp57 }) - tmp55 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7849), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(7861), lang.NewKeyword("end-column"), int(32)) + tmp55 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7849), kw_column, int(10), kw_end_DASH_line, int(7861), kw_end_DASH_column, int(32)) tmp56, err := lang.WithMeta(tmp54, tmp55.(lang.IPersistentMap)) if err != nil { panic(err) @@ -30675,7 +31052,7 @@ func LoadNS() { } // end let return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -30683,29 +31060,25 @@ func LoadNS() { } // load-data-readers { - tmp0 := lang.NewSymbol("load-data-readers").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7865), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7865), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym_load_DASH_data_DASH_readers.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7865), kw_column, int(8), kw_end_DASH_line, int(7865), kw_end_DASH_column, int(24), kw_private, true, kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - tmp3 := checkDerefVar(glojure_DOT_core_alter_var_root) - tmp4 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*data-readers*")) + checkArity(args, 0) + tmp3 := checkDerefVar(var_glojure_DOT_core_alter_DASH_var_DASH_root) + tmp4 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_data_DASH_readers_STAR_) var tmp5 lang.FnFunc tmp5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v6 := args[0] _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_reduce) - tmp8 := checkDerefVar(glojure_DOT_core_load_data_reader_file) - tmp9 := checkDerefVar(glojure_DOT_core_data_reader_urls) + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce) + tmp8 := checkDerefVar(var_glojure_DOT_core_load_DASH_data_DASH_reader_DASH_file) + tmp9 := checkDerefVar(var_glojure_DOT_core_data_DASH_reader_DASH_urls) tmp10 := lang.Apply(tmp9, nil) tmp11 := lang.Apply(tmp7, []any{tmp8, v6, tmp10}) return tmp11 }) - tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7867), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(7869), lang.NewKeyword("end-column"), int(57)) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7867), kw_column, int(19), kw_end_DASH_line, int(7869), kw_end_DASH_column, int(57)) tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) if err != nil { panic(err) @@ -30713,7 +31086,7 @@ func LoadNS() { tmp8 := lang.Apply(tmp3, []any{tmp4, tmp7}) return tmp8 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -30721,7 +31094,7 @@ func LoadNS() { } // load-file { - tmp0 := lang.NewSymbol("load-file").WithMeta(lang.NewMap(lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym_load_DASH_file.WithMeta(lang.NewMap(kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) tmp1 := ns.InternWithValue(tmp0, nil, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -30729,21 +31102,19 @@ func LoadNS() { } // load-lib { - tmp0 := lang.NewSymbol("load-lib").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("prefix"), lang.NewSymbol("lib"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Loads a lib with options", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5904), lang.NewKeyword("end-line"), int(5904), lang.NewKeyword("private"), true)).(*lang.Symbol) + tmp0 := sym_load_DASH_lib.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_prefix, sym_lib, sym__AMP_, sym_options)), kw_doc, "Loads a lib with options", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(8), kw_line, int(5904), kw_end_DASH_line, int(5904), kw_private, true)).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 var v5 any = lang.NewList(args[2:]...) _ = v5 - tmp6 := checkDerefVar(glojure_DOT_core_throw_if) + tmp6 := checkDerefVar(var_glojure_DOT_core_throw_DASH_if) var tmp7 any { // let // let binding "and__0__auto__" @@ -30751,10 +31122,10 @@ func LoadNS() { _ = v8 var tmp9 any if lang.IsTruthy(v8) { - tmp10 := checkDerefVar(glojure_DOT_core_pos_QMARK_) - tmp11 := checkDerefVar(glojure_DOT_core_name) + tmp10 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp11 := checkDerefVar(var_glojure_DOT_core_name) tmp12 := lang.Apply(tmp11, []any{v4}) - tmp13 := checkDerefVar(glojure_DOT_core_int) + tmp13 := checkDerefVar(var_glojure_DOT_core_int) tmp14 := lang.Apply(tmp13, []any{lang.NewChar(46)}) tmp15 := lang.Apply(strings11.Index, []any{tmp12, tmp14}) tmp16 := lang.Apply(tmp10, []any{tmp15}) @@ -30764,7 +31135,7 @@ func LoadNS() { } tmp7 = tmp9 } // end let - tmp8 := checkDerefVar(glojure_DOT_core_name) + tmp8 := checkDerefVar(var_glojure_DOT_core_name) tmp9 := lang.Apply(tmp8, []any{v4}) tmp10 := lang.Apply(tmp6, []any{tmp7, "Found lib name '%s' containing period with prefix '%s'. lib names inside prefix lists must not contain periods", tmp9, v3}) _ = tmp10 @@ -30773,8 +31144,8 @@ func LoadNS() { // let binding "lib" var tmp12 any if lang.IsTruthy(v3) { - tmp13 := checkDerefVar(glojure_DOT_core_symbol) - tmp14 := checkDerefVar(glojure_DOT_core_str) + tmp13 := checkDerefVar(var_glojure_DOT_core_symbol) + tmp14 := checkDerefVar(var_glojure_DOT_core_str) tmp15 := lang.Apply(tmp14, []any{v3, lang.NewChar(46), v4}) tmp16 := lang.Apply(tmp13, []any{tmp15}) tmp12 = tmp16 @@ -30784,8 +31155,8 @@ func LoadNS() { var v17 any = tmp12 _ = v17 // let binding "opts" - tmp18 := checkDerefVar(glojure_DOT_core_apply) - tmp19 := checkDerefVar(glojure_DOT_core_hash_map) + tmp18 := checkDerefVar(var_glojure_DOT_core_apply) + tmp19 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) tmp20 := lang.Apply(tmp18, []any{tmp19, v5}) var v21 any = tmp20 _ = v21 @@ -30794,23 +31165,23 @@ func LoadNS() { _ = v22 // let binding "map__110" var tmp23 any - tmp24 := checkDerefVar(glojure_DOT_core_seq_QMARK_) + tmp24 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) tmp25 := lang.Apply(tmp24, []any{v22}) if lang.IsTruthy(tmp25) { var tmp26 any - tmp27 := checkDerefVar(glojure_DOT_core_next) + tmp27 := checkDerefVar(var_glojure_DOT_core_next) tmp28 := lang.Apply(tmp27, []any{v22}) if lang.IsTruthy(tmp28) { - tmp29 := checkDerefVar(glojure_DOT_core_to_array) + tmp29 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) tmp30 := lang.Apply(tmp29, []any{v22}) tmp31 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{tmp30}) tmp26 = tmp31 } else { var tmp32 any - tmp33 := checkDerefVar(glojure_DOT_core_seq) + tmp33 := checkDerefVar(var_glojure_DOT_core_seq) tmp34 := lang.Apply(tmp33, []any{v22}) if lang.IsTruthy(tmp34) { - tmp35 := checkDerefVar(glojure_DOT_core_first) + tmp35 := checkDerefVar(var_glojure_DOT_core_first) tmp36 := lang.Apply(tmp35, []any{v22}) tmp32 = tmp36 } else { @@ -30824,44 +31195,44 @@ func LoadNS() { var v37 any = tmp23 _ = v37 // let binding "as" - tmp38 := checkDerefVar(glojure_DOT_core_get) - tmp39 := lang.Apply(tmp38, []any{v37, lang.NewKeyword("as")}) + tmp38 := checkDerefVar(var_glojure_DOT_core_get) + tmp39 := lang.Apply(tmp38, []any{v37, kw_as}) var v40 any = tmp39 _ = v40 // let binding "reload" - tmp41 := checkDerefVar(glojure_DOT_core_get) - tmp42 := lang.Apply(tmp41, []any{v37, lang.NewKeyword("reload")}) + tmp41 := checkDerefVar(var_glojure_DOT_core_get) + tmp42 := lang.Apply(tmp41, []any{v37, kw_reload}) var v43 any = tmp42 _ = v43 // let binding "reload-all" - tmp44 := checkDerefVar(glojure_DOT_core_get) - tmp45 := lang.Apply(tmp44, []any{v37, lang.NewKeyword("reload-all")}) + tmp44 := checkDerefVar(var_glojure_DOT_core_get) + tmp45 := lang.Apply(tmp44, []any{v37, kw_reload_DASH_all}) var v46 any = tmp45 _ = v46 // let binding "require" - tmp47 := checkDerefVar(glojure_DOT_core_get) - tmp48 := lang.Apply(tmp47, []any{v37, lang.NewKeyword("require")}) + tmp47 := checkDerefVar(var_glojure_DOT_core_get) + tmp48 := lang.Apply(tmp47, []any{v37, kw_require}) var v49 any = tmp48 _ = v49 // let binding "use" - tmp50 := checkDerefVar(glojure_DOT_core_get) - tmp51 := lang.Apply(tmp50, []any{v37, lang.NewKeyword("use")}) + tmp50 := checkDerefVar(var_glojure_DOT_core_get) + tmp51 := lang.Apply(tmp50, []any{v37, kw_use}) var v52 any = tmp51 _ = v52 // let binding "verbose" - tmp53 := checkDerefVar(glojure_DOT_core_get) - tmp54 := lang.Apply(tmp53, []any{v37, lang.NewKeyword("verbose")}) + tmp53 := checkDerefVar(var_glojure_DOT_core_get) + tmp54 := lang.Apply(tmp53, []any{v37, kw_verbose}) var v55 any = tmp54 _ = v55 // let binding "as-alias" - tmp56 := checkDerefVar(glojure_DOT_core_get) - tmp57 := lang.Apply(tmp56, []any{v37, lang.NewKeyword("as-alias")}) + tmp56 := checkDerefVar(var_glojure_DOT_core_get) + tmp57 := lang.Apply(tmp56, []any{v37, kw_as_DASH_alias}) var v58 any = tmp57 _ = v58 // let binding "loaded" - tmp59 := checkDerefVar(glojure_DOT_core_contains_QMARK_) - tmp60 := checkDerefVar(glojure_DOT_core_deref) - tmp61 := checkDerefVar(glojure_DOT_core__STAR_loaded_libs_STAR_) + tmp59 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp60 := checkDerefVar(var_glojure_DOT_core_deref) + tmp61 := checkDerefVar(var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_) tmp62 := lang.Apply(tmp60, []any{tmp61}) tmp63 := lang.Apply(tmp59, []any{tmp62, v17}) var v64 any = tmp63 @@ -30885,41 +31256,39 @@ func LoadNS() { // let binding "load" var tmp67 any if lang.IsTruthy(v46) { - tmp68 := checkDerefVar(glojure_DOT_core_load_all) + tmp68 := checkDerefVar(var_glojure_DOT_core_load_DASH_all) tmp67 = tmp68 } else { var tmp69 any if lang.IsTruthy(v43) { - tmp70 := checkDerefVar(glojure_DOT_core_load_one) + tmp70 := checkDerefVar(var_glojure_DOT_core_load_DASH_one) tmp69 = tmp70 } else { var tmp71 any - tmp72 := checkDerefVar(glojure_DOT_core_not) + tmp72 := checkDerefVar(var_glojure_DOT_core_not) tmp73 := lang.Apply(tmp72, []any{v64}) if lang.IsTruthy(tmp73) { var tmp74 any if lang.IsTruthy(v66) { - tmp75 := checkDerefVar(glojure_DOT_core_load_one) + tmp75 := checkDerefVar(var_glojure_DOT_core_load_DASH_one) tmp74 = tmp75 } else { var tmp76 any if lang.IsTruthy(v58) { var tmp77 lang.FnFunc tmp77 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v78 := args[0] _ = v78 v79 := args[1] _ = v79 v80 := args[2] _ = v80 - tmp81 := checkDerefVar(glojure_DOT_core_create_ns) + tmp81 := checkDerefVar(var_glojure_DOT_core_create_DASH_ns) tmp82 := lang.Apply(tmp81, []any{v78}) return tmp82 }) - tmp78 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5918), lang.NewKeyword("column"), int(48), lang.NewKeyword("end-line"), int(5918), lang.NewKeyword("end-column"), int(88)) + tmp78 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5918), kw_column, int(48), kw_end_DASH_line, int(5918), kw_end_DASH_column, int(88)) tmp79, err := lang.WithMeta(tmp77, tmp78.(lang.IPersistentMap)) if err != nil { panic(err) @@ -30927,8 +31296,8 @@ func LoadNS() { tmp76 = tmp79 } else { var tmp80 any - if lang.IsTruthy(lang.NewKeyword("else")) { - tmp81 := checkDerefVar(glojure_DOT_core_load_one) + if lang.IsTruthy(kw_else) { + tmp81 := checkDerefVar(var_glojure_DOT_core_load_DASH_one) tmp80 = tmp81 } else { } @@ -30946,26 +31315,26 @@ func LoadNS() { var v82 any = tmp67 _ = v82 // let binding "filter-opts" - tmp83 := checkDerefVar(glojure_DOT_core_select_keys) - tmp84 := lang.Apply(tmp83, []any{v21, lang.NewList(lang.NewKeyword("exclude"), lang.NewKeyword("only"), lang.NewKeyword("rename"), lang.NewKeyword("refer"))}) + tmp83 := checkDerefVar(var_glojure_DOT_core_select_DASH_keys) + tmp84 := lang.Apply(tmp83, []any{v21, lang.NewList(kw_exclude, kw_only, kw_rename, kw_refer)}) var v85 any = tmp84 _ = v85 // let binding "undefined-on-entry" - tmp86 := checkDerefVar(glojure_DOT_core_not) - tmp87 := checkDerefVar(glojure_DOT_core_find_ns) + tmp86 := checkDerefVar(var_glojure_DOT_core_not) + tmp87 := checkDerefVar(var_glojure_DOT_core_find_DASH_ns) tmp88 := lang.Apply(tmp87, []any{v17}) tmp89 := lang.Apply(tmp86, []any{tmp88}) var v90 any = tmp89 _ = v90 var tmp91 any { // let - tmp92 := checkDerefVar(glojure_DOT_core_push_thread_bindings) - tmp93 := checkDerefVar(glojure_DOT_core_hash_map) - tmp94 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*loading-verbosely*")) + tmp92 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp93 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp94 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_loading_DASH_verbosely_STAR_) var tmp95 any { // let // let binding "or__0__auto__" - tmp96 := checkDerefVar(glojure_DOT_core__STAR_loading_verbosely_STAR_) + tmp96 := checkDerefVar(var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_) var v97 any = tmp96 _ = v97 var tmp98 any @@ -30982,7 +31351,7 @@ func LoadNS() { var tmp98 any func() { defer func() { - tmp99 := checkDerefVar(glojure_DOT_core_pop_thread_bindings) + tmp99 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) tmp100 := lang.Apply(tmp99, nil) _ = tmp100 }() @@ -30997,7 +31366,7 @@ func LoadNS() { _ = v103 var tmp104 any if lang.IsTruthy(v90) { - tmp105 := checkDerefVar(glojure_DOT_core_remove_ns) + tmp105 := checkDerefVar(var_glojure_DOT_core_remove_DASH_ns) tmp106 := lang.Apply(tmp105, []any{v17}) tmp104 = tmp106 } else { @@ -31014,7 +31383,7 @@ func LoadNS() { }() tmp101 = tmp102 } else { - tmp104 := checkDerefVar(glojure_DOT_core_throw_if) + tmp104 := checkDerefVar(var_glojure_DOT_core_throw_DASH_if) var tmp105 any { // let // let binding "and__0__auto__" @@ -31022,8 +31391,8 @@ func LoadNS() { _ = v106 var tmp107 any if lang.IsTruthy(v106) { - tmp108 := checkDerefVar(glojure_DOT_core_not) - tmp109 := checkDerefVar(glojure_DOT_core_find_ns) + tmp108 := checkDerefVar(var_glojure_DOT_core_not) + tmp109 := checkDerefVar(var_glojure_DOT_core_find_DASH_ns) tmp110 := lang.Apply(tmp109, []any{v17}) tmp111 := lang.Apply(tmp108, []any{tmp110}) tmp107 = tmp111 @@ -31044,7 +31413,7 @@ func LoadNS() { _ = v109 var tmp110 any if lang.IsTruthy(v109) { - tmp111 := checkDerefVar(glojure_DOT_core__STAR_loading_verbosely_STAR_) + tmp111 := checkDerefVar(var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_) tmp110 = tmp111 } else { tmp110 = v109 @@ -31052,9 +31421,9 @@ func LoadNS() { tmp108 = tmp110 } // end let if lang.IsTruthy(tmp108) { - tmp109 := checkDerefVar(glojure_DOT_core_printf) - tmp110 := checkDerefVar(glojure_DOT_core_ns_name) - tmp111 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) + tmp109 := checkDerefVar(var_glojure_DOT_core_printf) + tmp110 := checkDerefVar(var_glojure_DOT_core_ns_DASH_name) + tmp111 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) tmp112 := lang.Apply(tmp110, []any{tmp111}) tmp113 := lang.Apply(tmp109, []any{"(glojure.core/in-ns '%s)\n", tmp112}) tmp107 = tmp113 @@ -31064,15 +31433,15 @@ func LoadNS() { var tmp114 any if lang.IsTruthy(v40) { var tmp115 any - tmp116 := checkDerefVar(glojure_DOT_core__STAR_loading_verbosely_STAR_) + tmp116 := checkDerefVar(var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_) if lang.IsTruthy(tmp116) { - tmp117 := checkDerefVar(glojure_DOT_core_printf) + tmp117 := checkDerefVar(var_glojure_DOT_core_printf) tmp118 := lang.Apply(tmp117, []any{"(glojure.core/alias '%s '%s)\n", v40, v17}) tmp115 = tmp118 } else { } _ = tmp115 - tmp119 := checkDerefVar(glojure_DOT_core_alias) + tmp119 := checkDerefVar(var_glojure_DOT_core_alias) tmp120 := lang.Apply(tmp119, []any{v40, v17}) tmp114 = tmp120 } else { @@ -31081,15 +31450,15 @@ func LoadNS() { var tmp121 any if lang.IsTruthy(v58) { var tmp122 any - tmp123 := checkDerefVar(glojure_DOT_core__STAR_loading_verbosely_STAR_) + tmp123 := checkDerefVar(var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_) if lang.IsTruthy(tmp123) { - tmp124 := checkDerefVar(glojure_DOT_core_printf) + tmp124 := checkDerefVar(var_glojure_DOT_core_printf) tmp125 := lang.Apply(tmp124, []any{"(glojure.core/alias '%s '%s)\n", v58, v17}) tmp122 = tmp125 } else { } _ = tmp122 - tmp126 := checkDerefVar(glojure_DOT_core_alias) + tmp126 := checkDerefVar(var_glojure_DOT_core_alias) tmp127 := lang.Apply(tmp126, []any{v58, v17}) tmp121 = tmp127 } else { @@ -31105,22 +31474,22 @@ func LoadNS() { if lang.IsTruthy(v130) { tmp131 = v130 } else { - tmp132 := lang.Apply(lang.NewKeyword("refer"), []any{v85}) + tmp132 := lang.Apply(kw_refer, []any{v85}) tmp131 = tmp132 } tmp129 = tmp131 } // end let if lang.IsTruthy(tmp129) { var tmp130 any - tmp131 := checkDerefVar(glojure_DOT_core__STAR_loading_verbosely_STAR_) + tmp131 := checkDerefVar(var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_) if lang.IsTruthy(tmp131) { - tmp132 := checkDerefVar(glojure_DOT_core_printf) + tmp132 := checkDerefVar(var_glojure_DOT_core_printf) tmp133 := lang.Apply(tmp132, []any{"(glojure.core/refer '%s", v17}) _ = tmp133 var tmp134 any { // let // let binding "seq_111" - tmp135 := checkDerefVar(glojure_DOT_core_seq) + tmp135 := checkDerefVar(var_glojure_DOT_core_seq) tmp136 := lang.Apply(tmp135, []any{v85}) var v137 any = tmp136 _ = v137 @@ -31135,7 +31504,7 @@ func LoadNS() { _ = v140 for { var tmp141 any - tmp142 := checkDerefVar(glojure_DOT_core__LT_) + tmp142 := checkDerefVar(var_glojure_DOT_core__LT_) tmp143 := lang.Apply(tmp142, []any{v140, v139}) if lang.IsTruthy(tmp143) { var tmp144 any @@ -31148,11 +31517,11 @@ func LoadNS() { tmp146 := lang.Apply(tmp145, []any{v140}) var v147 any = tmp146 _ = v147 - tmp148 := checkDerefVar(glojure_DOT_core_printf) - tmp149 := checkDerefVar(glojure_DOT_core_key) + tmp148 := checkDerefVar(var_glojure_DOT_core_printf) + tmp149 := checkDerefVar(var_glojure_DOT_core_key) tmp150 := lang.Apply(tmp149, []any{v147}) - tmp151 := checkDerefVar(glojure_DOT_core_print_str) - tmp152 := checkDerefVar(glojure_DOT_core_val) + tmp151 := checkDerefVar(var_glojure_DOT_core_print_DASH_str) + tmp152 := checkDerefVar(var_glojure_DOT_core_val) tmp153 := lang.Apply(tmp152, []any{v147}) tmp154 := lang.Apply(tmp151, []any{tmp153}) tmp155 := lang.Apply(tmp148, []any{" %s '%s", tmp150, tmp154}) @@ -31160,7 +31529,7 @@ func LoadNS() { var tmp156 any = v137 var tmp157 any = v138 var tmp158 any = v139 - tmp160 := checkDerefVar(glojure_DOT_core_unchecked_inc) + tmp160 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) tmp161 := lang.Apply(tmp160, []any{v140}) var tmp159 any = tmp161 v137 = tmp156 @@ -31174,7 +31543,7 @@ func LoadNS() { var tmp145 any { // let // let binding "temp__0__auto__" - tmp146 := checkDerefVar(glojure_DOT_core_seq) + tmp146 := checkDerefVar(var_glojure_DOT_core_seq) tmp147 := lang.Apply(tmp146, []any{v137}) var v148 any = tmp147 _ = v148 @@ -31186,26 +31555,26 @@ func LoadNS() { var v151 any = v148 _ = v151 var tmp152 any - tmp153 := checkDerefVar(glojure_DOT_core_chunked_seq_QMARK_) + tmp153 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) tmp154 := lang.Apply(tmp153, []any{v151}) if lang.IsTruthy(tmp154) { var tmp155 any { // let // let binding "c__0__auto__" - tmp156 := checkDerefVar(glojure_DOT_core_chunk_first) + tmp156 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) tmp157 := lang.Apply(tmp156, []any{v151}) var v158 any = tmp157 _ = v158 - tmp160 := checkDerefVar(glojure_DOT_core_chunk_rest) + tmp160 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) tmp161 := lang.Apply(tmp160, []any{v151}) var tmp159 any = tmp161 var tmp162 any = v158 - tmp164 := checkDerefVar(glojure_DOT_core_int) - tmp165 := checkDerefVar(glojure_DOT_core_count) + tmp164 := checkDerefVar(var_glojure_DOT_core_int) + tmp165 := checkDerefVar(var_glojure_DOT_core_count) tmp166 := lang.Apply(tmp165, []any{v158}) tmp167 := lang.Apply(tmp164, []any{tmp166}) var tmp163 any = tmp167 - tmp169 := checkDerefVar(glojure_DOT_core_int) + tmp169 := checkDerefVar(var_glojure_DOT_core_int) tmp170 := lang.Apply(tmp169, []any{int64(0)}) var tmp168 any = tmp170 v137 = tmp159 @@ -31219,20 +31588,20 @@ func LoadNS() { var tmp156 any { // let // let binding "opt" - tmp157 := checkDerefVar(glojure_DOT_core_first) + tmp157 := checkDerefVar(var_glojure_DOT_core_first) tmp158 := lang.Apply(tmp157, []any{v151}) var v159 any = tmp158 _ = v159 - tmp160 := checkDerefVar(glojure_DOT_core_printf) - tmp161 := checkDerefVar(glojure_DOT_core_key) + tmp160 := checkDerefVar(var_glojure_DOT_core_printf) + tmp161 := checkDerefVar(var_glojure_DOT_core_key) tmp162 := lang.Apply(tmp161, []any{v159}) - tmp163 := checkDerefVar(glojure_DOT_core_print_str) - tmp164 := checkDerefVar(glojure_DOT_core_val) + tmp163 := checkDerefVar(var_glojure_DOT_core_print_DASH_str) + tmp164 := checkDerefVar(var_glojure_DOT_core_val) tmp165 := lang.Apply(tmp164, []any{v159}) tmp166 := lang.Apply(tmp163, []any{tmp165}) tmp167 := lang.Apply(tmp160, []any{" %s '%s", tmp162, tmp166}) _ = tmp167 - tmp169 := checkDerefVar(glojure_DOT_core_next) + tmp169 := checkDerefVar(var_glojure_DOT_core_next) tmp170 := lang.Apply(tmp169, []any{v151}) var tmp168 any = tmp170 var tmp171 any = nil @@ -31260,16 +31629,16 @@ func LoadNS() { } } // end let _ = tmp134 - tmp135 := checkDerefVar(glojure_DOT_core_printf) + tmp135 := checkDerefVar(var_glojure_DOT_core_printf) tmp136 := lang.Apply(tmp135, []any{")\n"}) tmp130 = tmp136 } else { } _ = tmp130 - tmp137 := checkDerefVar(glojure_DOT_core_apply) - tmp138 := checkDerefVar(glojure_DOT_core_refer) - tmp139 := checkDerefVar(glojure_DOT_core_mapcat) - tmp140 := checkDerefVar(glojure_DOT_core_seq) + tmp137 := checkDerefVar(var_glojure_DOT_core_apply) + tmp138 := checkDerefVar(var_glojure_DOT_core_refer) + tmp139 := checkDerefVar(var_glojure_DOT_core_mapcat) + tmp140 := checkDerefVar(var_glojure_DOT_core_seq) tmp141 := lang.Apply(tmp139, []any{tmp140, v85}) tmp142 := lang.Apply(tmp137, []any{tmp138, v17, tmp141}) tmp128 = tmp142 @@ -31284,7 +31653,7 @@ func LoadNS() { return tmp11 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -31292,35 +31661,33 @@ func LoadNS() { } // load-libs { - tmp0 := lang.NewSymbol("load-libs").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Loads libs, interpreting libspecs, prefix lists, and flags for\n forwarding to load-lib", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5951), lang.NewKeyword("end-line"), int(5951), lang.NewKeyword("private"), true)).(*lang.Symbol) + tmp0 := sym_load_DASH_libs.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_args)), kw_doc, "Loads libs, interpreting libspecs, prefix lists, and flags for\n forwarding to load-lib", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(8), kw_line, int(5951), kw_end_DASH_line, int(5951), kw_private, true)).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 var tmp4 any { // let // let binding "flags" - tmp5 := checkDerefVar(glojure_DOT_core_filter) - tmp6 := checkDerefVar(glojure_DOT_core_keyword_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_filter) + tmp6 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) tmp7 := lang.Apply(tmp5, []any{tmp6, v3}) var v8 any = tmp7 _ = v8 // let binding "opts" - tmp9 := checkDerefVar(glojure_DOT_core_interleave) - tmp10 := checkDerefVar(glojure_DOT_core_repeat) + tmp9 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp10 := checkDerefVar(var_glojure_DOT_core_repeat) tmp11 := lang.Apply(tmp10, []any{true}) tmp12 := lang.Apply(tmp9, []any{v8, tmp11}) var v13 any = tmp12 _ = v13 // let binding "args" - tmp14 := checkDerefVar(glojure_DOT_core_filter) - tmp15 := checkDerefVar(glojure_DOT_core_complement) - tmp16 := checkDerefVar(glojure_DOT_core_keyword_QMARK_) + tmp14 := checkDerefVar(var_glojure_DOT_core_filter) + tmp15 := checkDerefVar(var_glojure_DOT_core_complement) + tmp16 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) tmp17 := lang.Apply(tmp15, []any{tmp16}) tmp18 := lang.Apply(tmp14, []any{tmp17, v3}) var v19 any = tmp18 @@ -31328,8 +31695,8 @@ func LoadNS() { var tmp20 any { // let // let binding "supported" - tmp21 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{lang.NewKeyword("as"), lang.NewKeyword("reload"), lang.NewKeyword("reload-all"), lang.NewKeyword("require"), lang.NewKeyword("use"), lang.NewKeyword("verbose"), lang.NewKeyword("refer"), lang.NewKeyword("as-alias")})) - tmp22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5959), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(5959), lang.NewKeyword("end-column"), int(86)) + tmp21 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{kw_as, kw_reload, kw_reload_DASH_all, kw_require, kw_use, kw_verbose, kw_refer, kw_as_DASH_alias})) + tmp22 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5959), kw_column, int(21), kw_end_DASH_line, int(5959), kw_end_DASH_column, int(86)) tmp23, err := lang.WithMeta(tmp21, tmp22.(lang.IPersistentMap)) if err != nil { panic(err) @@ -31337,25 +31704,25 @@ func LoadNS() { var v24 any = tmp23 _ = v24 // let binding "unsupported" - tmp25 := checkDerefVar(glojure_DOT_core_seq) - tmp26 := checkDerefVar(glojure_DOT_core_remove) + tmp25 := checkDerefVar(var_glojure_DOT_core_seq) + tmp26 := checkDerefVar(var_glojure_DOT_core_remove) tmp27 := lang.Apply(tmp26, []any{v24, v8}) tmp28 := lang.Apply(tmp25, []any{tmp27}) var v29 any = tmp28 _ = v29 - tmp30 := checkDerefVar(glojure_DOT_core_throw_if) - tmp31 := checkDerefVar(glojure_DOT_core_apply) - tmp32 := checkDerefVar(glojure_DOT_core_str) - tmp33 := checkDerefVar(glojure_DOT_core_interpose) + tmp30 := checkDerefVar(var_glojure_DOT_core_throw_DASH_if) + tmp31 := checkDerefVar(var_glojure_DOT_core_apply) + tmp32 := checkDerefVar(var_glojure_DOT_core_str) + tmp33 := checkDerefVar(var_glojure_DOT_core_interpose) tmp34 := lang.Apply(tmp33, []any{lang.NewChar(44), v29}) tmp35 := lang.Apply(tmp31, []any{tmp32, "Unsupported option(s) supplied: ", tmp34}) tmp36 := lang.Apply(tmp30, []any{v29, tmp35}) tmp20 = tmp36 } // end let _ = tmp20 - tmp21 := checkDerefVar(glojure_DOT_core_throw_if) - tmp22 := checkDerefVar(glojure_DOT_core_not) - tmp23 := checkDerefVar(glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_throw_DASH_if) + tmp22 := checkDerefVar(var_glojure_DOT_core_not) + tmp23 := checkDerefVar(var_glojure_DOT_core_seq) tmp24 := lang.Apply(tmp23, []any{v19}) tmp25 := lang.Apply(tmp22, []any{tmp24}) tmp26 := lang.Apply(tmp21, []any{tmp25, "Nothing specified to load"}) @@ -31363,7 +31730,7 @@ func LoadNS() { var tmp27 any { // let // let binding "seq_115" - tmp28 := checkDerefVar(glojure_DOT_core_seq) + tmp28 := checkDerefVar(var_glojure_DOT_core_seq) tmp29 := lang.Apply(tmp28, []any{v19}) var v30 any = tmp29 _ = v30 @@ -31378,7 +31745,7 @@ func LoadNS() { _ = v33 for { var tmp34 any - tmp35 := checkDerefVar(glojure_DOT_core__LT_) + tmp35 := checkDerefVar(var_glojure_DOT_core__LT_) tmp36 := lang.Apply(tmp35, []any{v33, v32}) if lang.IsTruthy(tmp36) { var tmp37 any @@ -31392,12 +31759,12 @@ func LoadNS() { var v40 any = tmp39 _ = v40 var tmp41 any - tmp42 := checkDerefVar(glojure_DOT_core_libspec_QMARK_) + tmp42 := checkDerefVar(var_glojure_DOT_core_libspec_QMARK_) tmp43 := lang.Apply(tmp42, []any{v40}) if lang.IsTruthy(tmp43) { - tmp44 := checkDerefVar(glojure_DOT_core_apply) - tmp45 := checkDerefVar(glojure_DOT_core_load_lib) - tmp46 := checkDerefVar(glojure_DOT_core_prependss) + tmp44 := checkDerefVar(var_glojure_DOT_core_apply) + tmp45 := checkDerefVar(var_glojure_DOT_core_load_DASH_lib) + tmp46 := checkDerefVar(var_glojure_DOT_core_prependss) tmp47 := lang.Apply(tmp46, []any{v40, v13}) tmp48 := lang.Apply(tmp44, []any{tmp45, nil, tmp47}) tmp41 = tmp48 @@ -31408,17 +31775,17 @@ func LoadNS() { var v50 any = v40 _ = v50 // let binding "seq__120" - tmp51 := checkDerefVar(glojure_DOT_core_seq) + tmp51 := checkDerefVar(var_glojure_DOT_core_seq) tmp52 := lang.Apply(tmp51, []any{v50}) var v53 any = tmp52 _ = v53 // let binding "first__121" - tmp54 := checkDerefVar(glojure_DOT_core_first) + tmp54 := checkDerefVar(var_glojure_DOT_core_first) tmp55 := lang.Apply(tmp54, []any{v53}) var v56 any = tmp55 _ = v56 // let binding "seq__120" - tmp57 := checkDerefVar(glojure_DOT_core_next) + tmp57 := checkDerefVar(var_glojure_DOT_core_next) tmp58 := lang.Apply(tmp57, []any{v53}) var v59 any = tmp58 _ = v59 @@ -31428,15 +31795,15 @@ func LoadNS() { // let binding "args" var v61 any = v59 _ = v61 - tmp62 := checkDerefVar(glojure_DOT_core_throw_if) - tmp63 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp62 := checkDerefVar(var_glojure_DOT_core_throw_DASH_if) + tmp63 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) tmp64 := lang.Apply(tmp63, []any{v60}) tmp65 := lang.Apply(tmp62, []any{tmp64, "prefix cannot be nil"}) _ = tmp65 var tmp66 any { // let // let binding "seq_122" - tmp67 := checkDerefVar(glojure_DOT_core_seq) + tmp67 := checkDerefVar(var_glojure_DOT_core_seq) tmp68 := lang.Apply(tmp67, []any{v61}) var v69 any = tmp68 _ = v69 @@ -31451,7 +31818,7 @@ func LoadNS() { _ = v72 for { var tmp73 any - tmp74 := checkDerefVar(glojure_DOT_core__LT_) + tmp74 := checkDerefVar(var_glojure_DOT_core__LT_) tmp75 := lang.Apply(tmp74, []any{v72, v71}) if lang.IsTruthy(tmp75) { var tmp76 any @@ -31464,16 +31831,16 @@ func LoadNS() { tmp78 := lang.Apply(tmp77, []any{v72}) var v79 any = tmp78 _ = v79 - tmp80 := checkDerefVar(glojure_DOT_core_apply) - tmp81 := checkDerefVar(glojure_DOT_core_load_lib) - tmp82 := checkDerefVar(glojure_DOT_core_prependss) + tmp80 := checkDerefVar(var_glojure_DOT_core_apply) + tmp81 := checkDerefVar(var_glojure_DOT_core_load_DASH_lib) + tmp82 := checkDerefVar(var_glojure_DOT_core_prependss) tmp83 := lang.Apply(tmp82, []any{v79, v13}) tmp84 := lang.Apply(tmp80, []any{tmp81, v60, tmp83}) _ = tmp84 var tmp85 any = v69 var tmp86 any = v70 var tmp87 any = v71 - tmp89 := checkDerefVar(glojure_DOT_core_unchecked_inc) + tmp89 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) tmp90 := lang.Apply(tmp89, []any{v72}) var tmp88 any = tmp90 v69 = tmp85 @@ -31487,7 +31854,7 @@ func LoadNS() { var tmp77 any { // let // let binding "temp__0__auto__" - tmp78 := checkDerefVar(glojure_DOT_core_seq) + tmp78 := checkDerefVar(var_glojure_DOT_core_seq) tmp79 := lang.Apply(tmp78, []any{v69}) var v80 any = tmp79 _ = v80 @@ -31499,26 +31866,26 @@ func LoadNS() { var v83 any = v80 _ = v83 var tmp84 any - tmp85 := checkDerefVar(glojure_DOT_core_chunked_seq_QMARK_) + tmp85 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) tmp86 := lang.Apply(tmp85, []any{v83}) if lang.IsTruthy(tmp86) { var tmp87 any { // let // let binding "c__0__auto__" - tmp88 := checkDerefVar(glojure_DOT_core_chunk_first) + tmp88 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) tmp89 := lang.Apply(tmp88, []any{v83}) var v90 any = tmp89 _ = v90 - tmp92 := checkDerefVar(glojure_DOT_core_chunk_rest) + tmp92 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) tmp93 := lang.Apply(tmp92, []any{v83}) var tmp91 any = tmp93 var tmp94 any = v90 - tmp96 := checkDerefVar(glojure_DOT_core_int) - tmp97 := checkDerefVar(glojure_DOT_core_count) + tmp96 := checkDerefVar(var_glojure_DOT_core_int) + tmp97 := checkDerefVar(var_glojure_DOT_core_count) tmp98 := lang.Apply(tmp97, []any{v90}) tmp99 := lang.Apply(tmp96, []any{tmp98}) var tmp95 any = tmp99 - tmp101 := checkDerefVar(glojure_DOT_core_int) + tmp101 := checkDerefVar(var_glojure_DOT_core_int) tmp102 := lang.Apply(tmp101, []any{int64(0)}) var tmp100 any = tmp102 v69 = tmp91 @@ -31532,17 +31899,17 @@ func LoadNS() { var tmp88 any { // let // let binding "arg" - tmp89 := checkDerefVar(glojure_DOT_core_first) + tmp89 := checkDerefVar(var_glojure_DOT_core_first) tmp90 := lang.Apply(tmp89, []any{v83}) var v91 any = tmp90 _ = v91 - tmp92 := checkDerefVar(glojure_DOT_core_apply) - tmp93 := checkDerefVar(glojure_DOT_core_load_lib) - tmp94 := checkDerefVar(glojure_DOT_core_prependss) + tmp92 := checkDerefVar(var_glojure_DOT_core_apply) + tmp93 := checkDerefVar(var_glojure_DOT_core_load_DASH_lib) + tmp94 := checkDerefVar(var_glojure_DOT_core_prependss) tmp95 := lang.Apply(tmp94, []any{v91, v13}) tmp96 := lang.Apply(tmp92, []any{tmp93, v60, tmp95}) _ = tmp96 - tmp98 := checkDerefVar(glojure_DOT_core_next) + tmp98 := checkDerefVar(var_glojure_DOT_core_next) tmp99 := lang.Apply(tmp98, []any{v83}) var tmp97 any = tmp99 var tmp100 any = nil @@ -31577,7 +31944,7 @@ func LoadNS() { var tmp50 any = v30 var tmp51 any = v31 var tmp52 any = v32 - tmp54 := checkDerefVar(glojure_DOT_core_unchecked_inc) + tmp54 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) tmp55 := lang.Apply(tmp54, []any{v33}) var tmp53 any = tmp55 v30 = tmp50 @@ -31591,7 +31958,7 @@ func LoadNS() { var tmp38 any { // let // let binding "temp__0__auto__" - tmp39 := checkDerefVar(glojure_DOT_core_seq) + tmp39 := checkDerefVar(var_glojure_DOT_core_seq) tmp40 := lang.Apply(tmp39, []any{v30}) var v41 any = tmp40 _ = v41 @@ -31603,26 +31970,26 @@ func LoadNS() { var v44 any = v41 _ = v44 var tmp45 any - tmp46 := checkDerefVar(glojure_DOT_core_chunked_seq_QMARK_) + tmp46 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) tmp47 := lang.Apply(tmp46, []any{v44}) if lang.IsTruthy(tmp47) { var tmp48 any { // let // let binding "c__0__auto__" - tmp49 := checkDerefVar(glojure_DOT_core_chunk_first) + tmp49 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) tmp50 := lang.Apply(tmp49, []any{v44}) var v51 any = tmp50 _ = v51 - tmp53 := checkDerefVar(glojure_DOT_core_chunk_rest) + tmp53 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) tmp54 := lang.Apply(tmp53, []any{v44}) var tmp52 any = tmp54 var tmp55 any = v51 - tmp57 := checkDerefVar(glojure_DOT_core_int) - tmp58 := checkDerefVar(glojure_DOT_core_count) + tmp57 := checkDerefVar(var_glojure_DOT_core_int) + tmp58 := checkDerefVar(var_glojure_DOT_core_count) tmp59 := lang.Apply(tmp58, []any{v51}) tmp60 := lang.Apply(tmp57, []any{tmp59}) var tmp56 any = tmp60 - tmp62 := checkDerefVar(glojure_DOT_core_int) + tmp62 := checkDerefVar(var_glojure_DOT_core_int) tmp63 := lang.Apply(tmp62, []any{int64(0)}) var tmp61 any = tmp63 v30 = tmp52 @@ -31636,17 +32003,17 @@ func LoadNS() { var tmp49 any { // let // let binding "arg" - tmp50 := checkDerefVar(glojure_DOT_core_first) + tmp50 := checkDerefVar(var_glojure_DOT_core_first) tmp51 := lang.Apply(tmp50, []any{v44}) var v52 any = tmp51 _ = v52 var tmp53 any - tmp54 := checkDerefVar(glojure_DOT_core_libspec_QMARK_) + tmp54 := checkDerefVar(var_glojure_DOT_core_libspec_QMARK_) tmp55 := lang.Apply(tmp54, []any{v52}) if lang.IsTruthy(tmp55) { - tmp56 := checkDerefVar(glojure_DOT_core_apply) - tmp57 := checkDerefVar(glojure_DOT_core_load_lib) - tmp58 := checkDerefVar(glojure_DOT_core_prependss) + tmp56 := checkDerefVar(var_glojure_DOT_core_apply) + tmp57 := checkDerefVar(var_glojure_DOT_core_load_DASH_lib) + tmp58 := checkDerefVar(var_glojure_DOT_core_prependss) tmp59 := lang.Apply(tmp58, []any{v52, v13}) tmp60 := lang.Apply(tmp56, []any{tmp57, nil, tmp59}) tmp53 = tmp60 @@ -31657,17 +32024,17 @@ func LoadNS() { var v62 any = v52 _ = v62 // let binding "seq__127" - tmp63 := checkDerefVar(glojure_DOT_core_seq) + tmp63 := checkDerefVar(var_glojure_DOT_core_seq) tmp64 := lang.Apply(tmp63, []any{v62}) var v65 any = tmp64 _ = v65 // let binding "first__128" - tmp66 := checkDerefVar(glojure_DOT_core_first) + tmp66 := checkDerefVar(var_glojure_DOT_core_first) tmp67 := lang.Apply(tmp66, []any{v65}) var v68 any = tmp67 _ = v68 // let binding "seq__127" - tmp69 := checkDerefVar(glojure_DOT_core_next) + tmp69 := checkDerefVar(var_glojure_DOT_core_next) tmp70 := lang.Apply(tmp69, []any{v65}) var v71 any = tmp70 _ = v71 @@ -31677,15 +32044,15 @@ func LoadNS() { // let binding "args" var v73 any = v71 _ = v73 - tmp74 := checkDerefVar(glojure_DOT_core_throw_if) - tmp75 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp74 := checkDerefVar(var_glojure_DOT_core_throw_DASH_if) + tmp75 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) tmp76 := lang.Apply(tmp75, []any{v72}) tmp77 := lang.Apply(tmp74, []any{tmp76, "prefix cannot be nil"}) _ = tmp77 var tmp78 any { // let // let binding "seq_129" - tmp79 := checkDerefVar(glojure_DOT_core_seq) + tmp79 := checkDerefVar(var_glojure_DOT_core_seq) tmp80 := lang.Apply(tmp79, []any{v73}) var v81 any = tmp80 _ = v81 @@ -31700,7 +32067,7 @@ func LoadNS() { _ = v84 for { var tmp85 any - tmp86 := checkDerefVar(glojure_DOT_core__LT_) + tmp86 := checkDerefVar(var_glojure_DOT_core__LT_) tmp87 := lang.Apply(tmp86, []any{v84, v83}) if lang.IsTruthy(tmp87) { var tmp88 any @@ -31713,16 +32080,16 @@ func LoadNS() { tmp90 := lang.Apply(tmp89, []any{v84}) var v91 any = tmp90 _ = v91 - tmp92 := checkDerefVar(glojure_DOT_core_apply) - tmp93 := checkDerefVar(glojure_DOT_core_load_lib) - tmp94 := checkDerefVar(glojure_DOT_core_prependss) + tmp92 := checkDerefVar(var_glojure_DOT_core_apply) + tmp93 := checkDerefVar(var_glojure_DOT_core_load_DASH_lib) + tmp94 := checkDerefVar(var_glojure_DOT_core_prependss) tmp95 := lang.Apply(tmp94, []any{v91, v13}) tmp96 := lang.Apply(tmp92, []any{tmp93, v72, tmp95}) _ = tmp96 var tmp97 any = v81 var tmp98 any = v82 var tmp99 any = v83 - tmp101 := checkDerefVar(glojure_DOT_core_unchecked_inc) + tmp101 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) tmp102 := lang.Apply(tmp101, []any{v84}) var tmp100 any = tmp102 v81 = tmp97 @@ -31736,7 +32103,7 @@ func LoadNS() { var tmp89 any { // let // let binding "temp__0__auto__" - tmp90 := checkDerefVar(glojure_DOT_core_seq) + tmp90 := checkDerefVar(var_glojure_DOT_core_seq) tmp91 := lang.Apply(tmp90, []any{v81}) var v92 any = tmp91 _ = v92 @@ -31748,26 +32115,26 @@ func LoadNS() { var v95 any = v92 _ = v95 var tmp96 any - tmp97 := checkDerefVar(glojure_DOT_core_chunked_seq_QMARK_) + tmp97 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) tmp98 := lang.Apply(tmp97, []any{v95}) if lang.IsTruthy(tmp98) { var tmp99 any { // let // let binding "c__0__auto__" - tmp100 := checkDerefVar(glojure_DOT_core_chunk_first) + tmp100 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) tmp101 := lang.Apply(tmp100, []any{v95}) var v102 any = tmp101 _ = v102 - tmp104 := checkDerefVar(glojure_DOT_core_chunk_rest) + tmp104 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) tmp105 := lang.Apply(tmp104, []any{v95}) var tmp103 any = tmp105 var tmp106 any = v102 - tmp108 := checkDerefVar(glojure_DOT_core_int) - tmp109 := checkDerefVar(glojure_DOT_core_count) + tmp108 := checkDerefVar(var_glojure_DOT_core_int) + tmp109 := checkDerefVar(var_glojure_DOT_core_count) tmp110 := lang.Apply(tmp109, []any{v102}) tmp111 := lang.Apply(tmp108, []any{tmp110}) var tmp107 any = tmp111 - tmp113 := checkDerefVar(glojure_DOT_core_int) + tmp113 := checkDerefVar(var_glojure_DOT_core_int) tmp114 := lang.Apply(tmp113, []any{int64(0)}) var tmp112 any = tmp114 v81 = tmp103 @@ -31781,17 +32148,17 @@ func LoadNS() { var tmp100 any { // let // let binding "arg" - tmp101 := checkDerefVar(glojure_DOT_core_first) + tmp101 := checkDerefVar(var_glojure_DOT_core_first) tmp102 := lang.Apply(tmp101, []any{v95}) var v103 any = tmp102 _ = v103 - tmp104 := checkDerefVar(glojure_DOT_core_apply) - tmp105 := checkDerefVar(glojure_DOT_core_load_lib) - tmp106 := checkDerefVar(glojure_DOT_core_prependss) + tmp104 := checkDerefVar(var_glojure_DOT_core_apply) + tmp105 := checkDerefVar(var_glojure_DOT_core_load_DASH_lib) + tmp106 := checkDerefVar(var_glojure_DOT_core_prependss) tmp107 := lang.Apply(tmp106, []any{v103, v13}) tmp108 := lang.Apply(tmp104, []any{tmp105, v72, tmp107}) _ = tmp108 - tmp110 := checkDerefVar(glojure_DOT_core_next) + tmp110 := checkDerefVar(var_glojure_DOT_core_next) tmp111 := lang.Apply(tmp110, []any{v95}) var tmp109 any = tmp111 var tmp112 any = nil @@ -31823,7 +32190,7 @@ func LoadNS() { tmp53 = tmp61 } _ = tmp53 - tmp63 := checkDerefVar(glojure_DOT_core_next) + tmp63 := checkDerefVar(var_glojure_DOT_core_next) tmp64 := lang.Apply(tmp63, []any{v44}) var tmp62 any = tmp64 var tmp65 any = nil @@ -31855,7 +32222,7 @@ func LoadNS() { return tmp4 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -31863,24 +32230,22 @@ func LoadNS() { } // load-one { - tmp0 := lang.NewSymbol("load-one").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"), lang.NewSymbol("need-ns"), lang.NewSymbol("require"))), lang.NewKeyword("doc"), "Loads a lib given its name. If need-ns, ensures that the associated\n namespace exists after loading. If require, records the load so any\n duplicate loads can be skipped.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5879), lang.NewKeyword("end-line"), int(5879), lang.NewKeyword("private"), true)).(*lang.Symbol) + tmp0 := sym_load_DASH_one.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_lib, sym_need_DASH_ns, sym_require)), kw_doc, "Loads a lib given its name. If need-ns, ensures that the associated\n namespace exists after loading. If require, records the load so any\n duplicate loads can be skipped.", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(8), kw_line, int(5879), kw_end_DASH_line, int(5879), kw_private, true)).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] _ = v4 v5 := args[2] _ = v5 - tmp6 := checkDerefVar(glojure_DOT_core_load) - tmp7 := checkDerefVar(glojure_DOT_core_root_resource) + tmp6 := checkDerefVar(var_glojure_DOT_core_load) + tmp7 := checkDerefVar(var_glojure_DOT_core_root_DASH_resource) tmp8 := lang.Apply(tmp7, []any{v3}) tmp9 := lang.Apply(tmp6, []any{tmp8}) _ = tmp9 - tmp10 := checkDerefVar(glojure_DOT_core_throw_if) + tmp10 := checkDerefVar(var_glojure_DOT_core_throw_DASH_if) var tmp11 any { // let // let binding "and__0__auto__" @@ -31888,8 +32253,8 @@ func LoadNS() { _ = v12 var tmp13 any if lang.IsTruthy(v12) { - tmp14 := checkDerefVar(glojure_DOT_core_not) - tmp15 := checkDerefVar(glojure_DOT_core_find_ns) + tmp14 := checkDerefVar(var_glojure_DOT_core_not) + tmp15 := checkDerefVar(var_glojure_DOT_core_find_DASH_ns) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp14, []any{tmp16}) tmp13 = tmp17 @@ -31898,7 +32263,7 @@ func LoadNS() { } tmp11 = tmp13 } // end let - tmp12 := checkDerefVar(glojure_DOT_core_root_resource) + tmp12 := checkDerefVar(var_glojure_DOT_core_root_DASH_resource) tmp13 := lang.Apply(tmp12, []any{v3}) tmp14 := lang.Apply(tmp10, []any{tmp11, "namespace '%s' not found after loading '%s'", v3, tmp13}) _ = tmp14 @@ -31906,12 +32271,10 @@ func LoadNS() { if lang.IsTruthy(v5) { var tmp16 lang.FnFunc tmp16 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - tmp17 := checkDerefVar(glojure_DOT_core_commute) - tmp18 := checkDerefVar(glojure_DOT_core__STAR_loaded_libs_STAR_) - tmp19 := checkDerefVar(glojure_DOT_core_conj) + checkArity(args, 0) + tmp17 := checkDerefVar(var_glojure_DOT_core_commute) + tmp18 := checkDerefVar(var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_) + tmp19 := checkDerefVar(var_glojure_DOT_core_conj) tmp20 := lang.Apply(tmp17, []any{tmp18, tmp19, v3}) return tmp20 }) @@ -31925,7 +32288,7 @@ func LoadNS() { } return tmp15 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -31933,12 +32296,10 @@ func LoadNS() { } // load-reader { - tmp0 := lang.NewSymbol("load-reader").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rdr"))), lang.NewKeyword("doc"), "Sequentially read and evaluate the set of forms contained in the\n stream/file", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4081), lang.NewKeyword("end-line"), int(4081))).(*lang.Symbol) + tmp0 := sym_load_DASH_reader.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_rdr)), kw_doc, "Sequentially read and evaluate the set of forms contained in the\n stream/file", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(4081), kw_end_DASH_line, int(4081))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4, _ := lang.FieldOrMethod(runtime7.Compiler, "load") @@ -31948,7 +32309,7 @@ func LoadNS() { tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -31956,12 +32317,10 @@ func LoadNS() { } // load-string { - tmp0 := lang.NewSymbol("load-string").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Sequentially read and evaluate the set of forms contained in the\n string", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4088), lang.NewKeyword("end-line"), int(4088))).(*lang.Symbol) + tmp0 := sym_load_DASH_string.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_doc, "Sequentially read and evaluate the set of forms contained in the\n string", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(4088), kw_end_DASH_line, int(4088))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any @@ -31971,13 +32330,13 @@ func LoadNS() { tmp6 := lang.Apply(nil, []any{tmp5}) var v7 any = tmp6 _ = v7 - tmp8 := checkDerefVar(glojure_DOT_core_load_reader) + tmp8 := checkDerefVar(var_glojure_DOT_core_load_DASH_reader) tmp9 := lang.Apply(tmp8, []any{v7}) tmp4 = tmp9 } // end let return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -31985,18 +32344,16 @@ func LoadNS() { } // loaded-libs { - tmp0 := lang.NewSymbol("loaded-libs").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Returns a sorted set of symbols naming the currently loaded libs", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6090), lang.NewKeyword("end-line"), int(6090))).(*lang.Symbol) + tmp0 := sym_loaded_DASH_libs.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Returns a sorted set of symbols naming the currently loaded libs", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(6090), kw_end_DASH_line, int(6090))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - tmp3 := checkDerefVar(glojure_DOT_core_deref) - tmp4 := checkDerefVar(glojure_DOT_core__STAR_loaded_libs_STAR_) + checkArity(args, 0) + tmp3 := checkDerefVar(var_glojure_DOT_core_deref) + tmp4 := checkDerefVar(var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_) tmp5 := lang.Apply(tmp3, []any{tmp4}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -32004,14 +32361,12 @@ func LoadNS() { } // locking { - tmp0 := lang.NewSymbol("locking").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Executes exprs in an implicit do, while holding the monitor of x.\n Will release the monitor of x in all circumstances.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1643), lang.NewKeyword("end-line"), int(1643))).(*lang.Symbol) + tmp0 := sym_locking.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_x, sym__AMP_, sym_body)), kw_doc, "Executes exprs in an implicit do, while holding the monitor of x.\n Will release the monitor of x in all circumstances.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(1643), kw_end_DASH_line, int(1643))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -32020,73 +32375,73 @@ func LoadNS() { _ = v5 var v6 any = lang.NewList(args[3:]...) _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_seq) - tmp8 := checkDerefVar(glojure_DOT_core_concat) - tmp9 := checkDerefVar(glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("glojure.core/let")}) - tmp11 := checkDerefVar(glojure_DOT_core_list) - tmp12 := checkDerefVar(glojure_DOT_core_apply) - tmp13 := checkDerefVar(glojure_DOT_core_vector) - tmp14 := checkDerefVar(glojure_DOT_core_seq) - tmp15 := checkDerefVar(glojure_DOT_core_concat) - tmp16 := checkDerefVar(glojure_DOT_core_list) - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("lockee__0__auto__")}) - tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_core_SLASH_let}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_apply) + tmp13 := checkDerefVar(var_glojure_DOT_core_vector) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{sym_lockee__0__auto__}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) tmp19 := lang.Apply(tmp18, []any{v5}) tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) tmp21 := lang.Apply(tmp14, []any{tmp20}) tmp22 := lang.Apply(tmp12, []any{tmp13, tmp21}) tmp23 := lang.Apply(tmp11, []any{tmp22}) - tmp24 := checkDerefVar(glojure_DOT_core_list) - tmp25 := checkDerefVar(glojure_DOT_core_seq) - tmp26 := checkDerefVar(glojure_DOT_core_concat) - tmp27 := checkDerefVar(glojure_DOT_core_list) - tmp28 := lang.Apply(tmp27, []any{lang.NewSymbol("try")}) - tmp29 := checkDerefVar(glojure_DOT_core_list) - tmp30 := checkDerefVar(glojure_DOT_core_seq) - tmp31 := checkDerefVar(glojure_DOT_core_concat) - tmp32 := checkDerefVar(glojure_DOT_core_list) - tmp33 := lang.Apply(tmp32, []any{lang.NewSymbol("glojure.core/let")}) - tmp34 := checkDerefVar(glojure_DOT_core_list) - tmp35 := checkDerefVar(glojure_DOT_core_apply) - tmp36 := checkDerefVar(glojure_DOT_core_vector) - tmp37 := checkDerefVar(glojure_DOT_core_seq) - tmp38 := checkDerefVar(glojure_DOT_core_concat) - tmp39 := checkDerefVar(glojure_DOT_core_list) - tmp40 := lang.Apply(tmp39, []any{lang.NewSymbol("locklocal__1__auto__")}) - tmp41 := checkDerefVar(glojure_DOT_core_list) - tmp42 := lang.Apply(tmp41, []any{lang.NewSymbol("lockee__0__auto__")}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := checkDerefVar(var_glojure_DOT_core_seq) + tmp26 := checkDerefVar(var_glojure_DOT_core_concat) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{sym_try}) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := checkDerefVar(var_glojure_DOT_core_seq) + tmp31 := checkDerefVar(var_glojure_DOT_core_concat) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := lang.Apply(tmp32, []any{sym_glojure_DOT_core_SLASH_let}) + tmp34 := checkDerefVar(var_glojure_DOT_core_list) + tmp35 := checkDerefVar(var_glojure_DOT_core_apply) + tmp36 := checkDerefVar(var_glojure_DOT_core_vector) + tmp37 := checkDerefVar(var_glojure_DOT_core_seq) + tmp38 := checkDerefVar(var_glojure_DOT_core_concat) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := lang.Apply(tmp39, []any{sym_locklocal__1__auto__}) + tmp41 := checkDerefVar(var_glojure_DOT_core_list) + tmp42 := lang.Apply(tmp41, []any{sym_lockee__0__auto__}) tmp43 := lang.Apply(tmp38, []any{tmp40, tmp42}) tmp44 := lang.Apply(tmp37, []any{tmp43}) tmp45 := lang.Apply(tmp35, []any{tmp36, tmp44}) tmp46 := lang.Apply(tmp34, []any{tmp45}) - tmp47 := checkDerefVar(glojure_DOT_core_list) - tmp48 := checkDerefVar(glojure_DOT_core_seq) - tmp49 := checkDerefVar(glojure_DOT_core_concat) - tmp50 := checkDerefVar(glojure_DOT_core_list) - tmp51 := lang.Apply(tmp50, []any{lang.NewSymbol("monitor-enter")}) - tmp52 := checkDerefVar(glojure_DOT_core_list) - tmp53 := lang.Apply(tmp52, []any{lang.NewSymbol("locklocal__1__auto__")}) + tmp47 := checkDerefVar(var_glojure_DOT_core_list) + tmp48 := checkDerefVar(var_glojure_DOT_core_seq) + tmp49 := checkDerefVar(var_glojure_DOT_core_concat) + tmp50 := checkDerefVar(var_glojure_DOT_core_list) + tmp51 := lang.Apply(tmp50, []any{sym_monitor_DASH_enter}) + tmp52 := checkDerefVar(var_glojure_DOT_core_list) + tmp53 := lang.Apply(tmp52, []any{sym_locklocal__1__auto__}) tmp54 := lang.Apply(tmp49, []any{tmp51, tmp53}) tmp55 := lang.Apply(tmp48, []any{tmp54}) tmp56 := lang.Apply(tmp47, []any{tmp55}) - tmp57 := checkDerefVar(glojure_DOT_core_list) - tmp58 := checkDerefVar(glojure_DOT_core_seq) - tmp59 := checkDerefVar(glojure_DOT_core_concat) - tmp60 := checkDerefVar(glojure_DOT_core_list) - tmp61 := lang.Apply(tmp60, []any{lang.NewSymbol("try")}) - tmp62 := checkDerefVar(glojure_DOT_core_list) - tmp63 := checkDerefVar(glojure_DOT_core_seq) - tmp64 := checkDerefVar(glojure_DOT_core_concat) - tmp65 := checkDerefVar(glojure_DOT_core_list) - tmp66 := lang.Apply(tmp65, []any{lang.NewSymbol("finally")}) - tmp67 := checkDerefVar(glojure_DOT_core_list) - tmp68 := checkDerefVar(glojure_DOT_core_seq) - tmp69 := checkDerefVar(glojure_DOT_core_concat) - tmp70 := checkDerefVar(glojure_DOT_core_list) - tmp71 := lang.Apply(tmp70, []any{lang.NewSymbol("monitor-exit")}) - tmp72 := checkDerefVar(glojure_DOT_core_list) - tmp73 := lang.Apply(tmp72, []any{lang.NewSymbol("locklocal__1__auto__")}) + tmp57 := checkDerefVar(var_glojure_DOT_core_list) + tmp58 := checkDerefVar(var_glojure_DOT_core_seq) + tmp59 := checkDerefVar(var_glojure_DOT_core_concat) + tmp60 := checkDerefVar(var_glojure_DOT_core_list) + tmp61 := lang.Apply(tmp60, []any{sym_try}) + tmp62 := checkDerefVar(var_glojure_DOT_core_list) + tmp63 := checkDerefVar(var_glojure_DOT_core_seq) + tmp64 := checkDerefVar(var_glojure_DOT_core_concat) + tmp65 := checkDerefVar(var_glojure_DOT_core_list) + tmp66 := lang.Apply(tmp65, []any{sym_finally}) + tmp67 := checkDerefVar(var_glojure_DOT_core_list) + tmp68 := checkDerefVar(var_glojure_DOT_core_seq) + tmp69 := checkDerefVar(var_glojure_DOT_core_concat) + tmp70 := checkDerefVar(var_glojure_DOT_core_list) + tmp71 := lang.Apply(tmp70, []any{sym_monitor_DASH_exit}) + tmp72 := checkDerefVar(var_glojure_DOT_core_list) + tmp73 := lang.Apply(tmp72, []any{sym_locklocal__1__auto__}) tmp74 := lang.Apply(tmp69, []any{tmp71, tmp73}) tmp75 := lang.Apply(tmp68, []any{tmp74}) tmp76 := lang.Apply(tmp67, []any{tmp75}) @@ -32107,7 +32462,7 @@ func LoadNS() { return tmp90 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -32119,23 +32474,21 @@ func LoadNS() { { // function long__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) - tmp5 := checkDerefVar(glojure_DOT_core_concat) - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := checkDerefVar(glojure_DOT_core_seq) - tmp12 := checkDerefVar(glojure_DOT_core_concat) - tmp13 := checkDerefVar(glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/LongCast")}) - tmp15 := checkDerefVar(glojure_DOT_core_list) + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_LongCast}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) tmp18 := lang.Apply(tmp11, []any{tmp17}) @@ -32147,18 +32500,16 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("long").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to long", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3481), lang.NewKeyword("end-line"), int(3481))).(*lang.Symbol) + tmp0 := sym_long.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to long", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3481), kw_end_DASH_line, int(3481))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 tmp5 := lang.Apply(lang.LongCast, []any{v4}) return tmp5 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -32172,26 +32523,24 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) - tmp5 := checkDerefVar(glojure_DOT_core_concat) - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol("glojure.core/LongArray")}) - tmp12 := checkDerefVar(glojure_DOT_core_list) - tmp13 := checkDerefVar(glojure_DOT_core_seq) - tmp14 := checkDerefVar(glojure_DOT_core_concat) - tmp15 := checkDerefVar(glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) - tmp17 := checkDerefVar(glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("glojure.core/args")}) + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_LongArray}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_unquote_DASH_splicing}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_glojure_DOT_core_SLASH_args}) tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) tmp20 := lang.Apply(tmp13, []any{tmp19}) tmp21 := lang.Apply(tmp12, []any{tmp20}) @@ -32203,7 +32552,7 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("long-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Creates an array of longs", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5364), lang.NewKeyword("end-line"), int(5364))).(*lang.Symbol) + tmp0 := sym_long_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_size_DASH_or_DASH_seq), lang.NewVector(sym_size, sym_init_DASH_val_DASH_or_DASH_seq)), kw_inline, tmp1, kw_doc, "Creates an array of longs", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(5364), kw_end_DASH_line, int(5364))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -32228,10 +32577,11 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -32243,20 +32593,18 @@ func LoadNS() { { // function longs var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) - tmp5 := checkDerefVar(glojure_DOT_core_concat) - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol("glojure.core/Longs")}) - tmp12 := checkDerefVar(glojure_DOT_core_list) + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Longs}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := lang.Apply(tmp12, []any{v3}) tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) tmp15 := lang.Apply(tmp4, []any{tmp14}) @@ -32265,12 +32613,10 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("longs").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Casts to long[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5407), lang.NewKeyword("end-line"), int(5407))).(*lang.Symbol) + tmp0 := sym_longs.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xs)), kw_inline, tmp1, kw_doc, "Casts to long[]", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(12), kw_line, int(5407), kw_end_DASH_line, int(5407))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Longs") @@ -32280,7 +32626,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v4}) return tmp6 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -32288,14 +32634,12 @@ func LoadNS() { } // loop { - tmp0 := lang.NewSymbol("loop").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Evaluates the exprs in a lexical context in which the symbols in\n the binding-forms are bound to their respective init-exprs or parts\n therein. Acts as a recur target.", lang.NewKeyword("forms"), lang.NewVector(lang.NewList(lang.NewSymbol("loop"), lang.NewVector(lang.NewSymbol("bindings*")), lang.NewSymbol("exprs*"))), lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4597), lang.NewKeyword("end-line"), int(4597), lang.NewKeyword("special-form"), true)).(*lang.Symbol) + tmp0 := sym_loop.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "Evaluates the exprs in a lexical context in which the symbols in\n the binding-forms are bound to their respective init-exprs or parts\n therein. Acts as a recur target.", kw_forms, lang.NewVector(lang.NewList(sym_loop, lang.NewVector(sym_bindings_STAR_), sym_exprs_STAR_)), kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(11), kw_line, int(4597), kw_end_DASH_line, int(4597), kw_special_DASH_form, true)).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -32305,36 +32649,36 @@ func LoadNS() { var v6 any = lang.NewList(args[3:]...) _ = v6 var tmp7 any - tmp8 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp8 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) tmp9 := lang.Apply(tmp8, []any{v5}) if lang.IsTruthy(tmp9) { } else { - tmp10 := checkDerefVar(glojure_DOT_core_str) - tmp11 := checkDerefVar(glojure_DOT_core_first) + tmp10 := checkDerefVar(var_glojure_DOT_core_str) + tmp11 := checkDerefVar(var_glojure_DOT_core_first) tmp12 := lang.Apply(tmp11, []any{v3}) - tmp13 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) - tmp14 := checkDerefVar(glojure_DOT_core_meta) + tmp13 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp14 := checkDerefVar(var_glojure_DOT_core_meta) tmp15 := lang.Apply(tmp14, []any{v3}) - tmp16 := lang.Apply(lang.NewKeyword("line"), []any{tmp15}) + tmp16 := lang.Apply(kw_line, []any{tmp15}) tmp17 := lang.Apply(tmp10, []any{tmp12, " requires ", "a vector for its binding", " in ", tmp13, ":", tmp16}) tmp18 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp17}) panic(tmp18) } _ = tmp7 var tmp19 any - tmp20 := checkDerefVar(glojure_DOT_core_even_QMARK_) - tmp21 := checkDerefVar(glojure_DOT_core_count) + tmp20 := checkDerefVar(var_glojure_DOT_core_even_QMARK_) + tmp21 := checkDerefVar(var_glojure_DOT_core_count) tmp22 := lang.Apply(tmp21, []any{v5}) tmp23 := lang.Apply(tmp20, []any{tmp22}) if lang.IsTruthy(tmp23) { } else { - tmp24 := checkDerefVar(glojure_DOT_core_str) - tmp25 := checkDerefVar(glojure_DOT_core_first) + tmp24 := checkDerefVar(var_glojure_DOT_core_str) + tmp25 := checkDerefVar(var_glojure_DOT_core_first) tmp26 := lang.Apply(tmp25, []any{v3}) - tmp27 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) - tmp28 := checkDerefVar(glojure_DOT_core_meta) + tmp27 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp28 := checkDerefVar(var_glojure_DOT_core_meta) tmp29 := lang.Apply(tmp28, []any{v3}) - tmp30 := lang.Apply(lang.NewKeyword("line"), []any{tmp29}) + tmp30 := lang.Apply(kw_line, []any{tmp29}) tmp31 := lang.Apply(tmp24, []any{tmp26, " requires ", "an even number of forms in binding vector", " in ", tmp27, ":", tmp30}) tmp32 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp31}) panic(tmp32) @@ -32343,19 +32687,19 @@ func LoadNS() { var tmp33 any { // let // let binding "db" - tmp34 := checkDerefVar(glojure_DOT_core_destructure) + tmp34 := checkDerefVar(var_glojure_DOT_core_destructure) tmp35 := lang.Apply(tmp34, []any{v5}) var v36 any = tmp35 _ = v36 var tmp37 any - tmp38 := checkDerefVar(glojure_DOT_core__EQ_) + tmp38 := checkDerefVar(var_glojure_DOT_core__EQ_) tmp39 := lang.Apply(tmp38, []any{v36, v5}) if lang.IsTruthy(tmp39) { - tmp40 := checkDerefVar(glojure_DOT_core_seq) - tmp41 := checkDerefVar(glojure_DOT_core_concat) - tmp42 := checkDerefVar(glojure_DOT_core_list) - tmp43 := lang.Apply(tmp42, []any{lang.NewSymbol("loop*")}) - tmp44 := checkDerefVar(glojure_DOT_core_list) + tmp40 := checkDerefVar(var_glojure_DOT_core_seq) + tmp41 := checkDerefVar(var_glojure_DOT_core_concat) + tmp42 := checkDerefVar(var_glojure_DOT_core_list) + tmp43 := lang.Apply(tmp42, []any{sym_loop_STAR_}) + tmp44 := checkDerefVar(var_glojure_DOT_core_list) tmp45 := lang.Apply(tmp44, []any{v5}) tmp46 := lang.Apply(tmp41, []any{tmp43, tmp45, v6}) tmp47 := lang.Apply(tmp40, []any{tmp46}) @@ -32364,39 +32708,37 @@ func LoadNS() { var tmp48 any { // let // let binding "vs" - tmp49 := checkDerefVar(glojure_DOT_core_take_nth) - tmp50 := checkDerefVar(glojure_DOT_core_drop) + tmp49 := checkDerefVar(var_glojure_DOT_core_take_DASH_nth) + tmp50 := checkDerefVar(var_glojure_DOT_core_drop) tmp51 := lang.Apply(tmp50, []any{int64(1), v5}) tmp52 := lang.Apply(tmp49, []any{int64(2), tmp51}) var v53 any = tmp52 _ = v53 // let binding "bs" - tmp54 := checkDerefVar(glojure_DOT_core_take_nth) + tmp54 := checkDerefVar(var_glojure_DOT_core_take_DASH_nth) tmp55 := lang.Apply(tmp54, []any{int64(2), v5}) var v56 any = tmp55 _ = v56 // let binding "gs" - tmp57 := checkDerefVar(glojure_DOT_core_map) + tmp57 := checkDerefVar(var_glojure_DOT_core_map) var tmp58 lang.FnFunc tmp58 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v59 := args[0] _ = v59 var tmp60 any - tmp61 := checkDerefVar(glojure_DOT_core_symbol_QMARK_) + tmp61 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) tmp62 := lang.Apply(tmp61, []any{v59}) if lang.IsTruthy(tmp62) { tmp60 = v59 } else { - tmp63 := checkDerefVar(glojure_DOT_core_gensym) + tmp63 := checkDerefVar(var_glojure_DOT_core_gensym) tmp64 := lang.Apply(tmp63, nil) tmp60 = tmp64 } return tmp60 }) - tmp59 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4611), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(4611), lang.NewKeyword("end-column"), int(58)) + tmp59 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4611), kw_column, int(23), kw_end_DASH_line, int(4611), kw_end_DASH_column, int(58)) tmp60, err := lang.WithMeta(tmp58, tmp59.(lang.IPersistentMap)) if err != nil { panic(err) @@ -32405,12 +32747,10 @@ func LoadNS() { var v62 any = tmp61 _ = v62 // let binding "bfs" - tmp63 := checkDerefVar(glojure_DOT_core_reduce1) + tmp63 := checkDerefVar(var_glojure_DOT_core_reduce1) var tmp64 lang.FnFunc tmp64 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v65 := args[0] _ = v65 v66 := args[1] @@ -32421,29 +32761,29 @@ func LoadNS() { var v68 any = v66 _ = v68 // let binding "b" - tmp69 := checkDerefVar(glojure_DOT_core_nth) + tmp69 := checkDerefVar(var_glojure_DOT_core_nth) tmp70 := lang.Apply(tmp69, []any{v68, int64(0), nil}) var v71 any = tmp70 _ = v71 // let binding "v" - tmp72 := checkDerefVar(glojure_DOT_core_nth) + tmp72 := checkDerefVar(var_glojure_DOT_core_nth) tmp73 := lang.Apply(tmp72, []any{v68, int64(1), nil}) var v74 any = tmp73 _ = v74 // let binding "g" - tmp75 := checkDerefVar(glojure_DOT_core_nth) + tmp75 := checkDerefVar(var_glojure_DOT_core_nth) tmp76 := lang.Apply(tmp75, []any{v68, int64(2), nil}) var v77 any = tmp76 _ = v77 var tmp78 any - tmp79 := checkDerefVar(glojure_DOT_core_symbol_QMARK_) + tmp79 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) tmp80 := lang.Apply(tmp79, []any{v71}) if lang.IsTruthy(tmp80) { - tmp81 := checkDerefVar(glojure_DOT_core_conj) + tmp81 := checkDerefVar(var_glojure_DOT_core_conj) tmp82 := lang.Apply(tmp81, []any{v65, v77, v74}) tmp78 = tmp82 } else { - tmp83 := checkDerefVar(glojure_DOT_core_conj) + tmp83 := checkDerefVar(var_glojure_DOT_core_conj) tmp84 := lang.Apply(tmp83, []any{v65, v77, v74, v71, v77}) tmp78 = tmp84 } @@ -32451,48 +32791,48 @@ func LoadNS() { } // end let return tmp67 }) - tmp65 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4612), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(4615), lang.NewKeyword("end-column"), int(50)) + tmp65 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4612), kw_column, int(28), kw_end_DASH_line, int(4615), kw_end_DASH_column, int(50)) tmp66, err := lang.WithMeta(tmp64, tmp65.(lang.IPersistentMap)) if err != nil { panic(err) } tmp67 := lang.NewVector() - tmp68 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4616), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(4616), lang.NewKeyword("end-column"), int(28)) + tmp68 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4616), kw_column, int(27), kw_end_DASH_line, int(4616), kw_end_DASH_column, int(28)) tmp69, err := lang.WithMeta(tmp67, tmp68.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp70 := checkDerefVar(glojure_DOT_core_map) - tmp71 := checkDerefVar(glojure_DOT_core_vector) + tmp70 := checkDerefVar(var_glojure_DOT_core_map) + tmp71 := checkDerefVar(var_glojure_DOT_core_vector) tmp72 := lang.Apply(tmp70, []any{tmp71, v56, v53, v62}) tmp73 := lang.Apply(tmp63, []any{tmp66, tmp69, tmp72}) var v74 any = tmp73 _ = v74 - tmp75 := checkDerefVar(glojure_DOT_core_seq) - tmp76 := checkDerefVar(glojure_DOT_core_concat) - tmp77 := checkDerefVar(glojure_DOT_core_list) - tmp78 := lang.Apply(tmp77, []any{lang.NewSymbol("glojure.core/let")}) - tmp79 := checkDerefVar(glojure_DOT_core_list) + tmp75 := checkDerefVar(var_glojure_DOT_core_seq) + tmp76 := checkDerefVar(var_glojure_DOT_core_concat) + tmp77 := checkDerefVar(var_glojure_DOT_core_list) + tmp78 := lang.Apply(tmp77, []any{sym_glojure_DOT_core_SLASH_let}) + tmp79 := checkDerefVar(var_glojure_DOT_core_list) tmp80 := lang.Apply(tmp79, []any{v74}) - tmp81 := checkDerefVar(glojure_DOT_core_list) - tmp82 := checkDerefVar(glojure_DOT_core_seq) - tmp83 := checkDerefVar(glojure_DOT_core_concat) - tmp84 := checkDerefVar(glojure_DOT_core_list) - tmp85 := lang.Apply(tmp84, []any{lang.NewSymbol("loop*")}) - tmp86 := checkDerefVar(glojure_DOT_core_list) - tmp87 := checkDerefVar(glojure_DOT_core_vec) - tmp88 := checkDerefVar(glojure_DOT_core_interleave) + tmp81 := checkDerefVar(var_glojure_DOT_core_list) + tmp82 := checkDerefVar(var_glojure_DOT_core_seq) + tmp83 := checkDerefVar(var_glojure_DOT_core_concat) + tmp84 := checkDerefVar(var_glojure_DOT_core_list) + tmp85 := lang.Apply(tmp84, []any{sym_loop_STAR_}) + tmp86 := checkDerefVar(var_glojure_DOT_core_list) + tmp87 := checkDerefVar(var_glojure_DOT_core_vec) + tmp88 := checkDerefVar(var_glojure_DOT_core_interleave) tmp89 := lang.Apply(tmp88, []any{v62, v62}) tmp90 := lang.Apply(tmp87, []any{tmp89}) tmp91 := lang.Apply(tmp86, []any{tmp90}) - tmp92 := checkDerefVar(glojure_DOT_core_list) - tmp93 := checkDerefVar(glojure_DOT_core_seq) - tmp94 := checkDerefVar(glojure_DOT_core_concat) - tmp95 := checkDerefVar(glojure_DOT_core_list) - tmp96 := lang.Apply(tmp95, []any{lang.NewSymbol("glojure.core/let")}) - tmp97 := checkDerefVar(glojure_DOT_core_list) - tmp98 := checkDerefVar(glojure_DOT_core_vec) - tmp99 := checkDerefVar(glojure_DOT_core_interleave) + tmp92 := checkDerefVar(var_glojure_DOT_core_list) + tmp93 := checkDerefVar(var_glojure_DOT_core_seq) + tmp94 := checkDerefVar(var_glojure_DOT_core_concat) + tmp95 := checkDerefVar(var_glojure_DOT_core_list) + tmp96 := lang.Apply(tmp95, []any{sym_glojure_DOT_core_SLASH_let}) + tmp97 := checkDerefVar(var_glojure_DOT_core_list) + tmp98 := checkDerefVar(var_glojure_DOT_core_vec) + tmp99 := checkDerefVar(var_glojure_DOT_core_interleave) tmp100 := lang.Apply(tmp99, []any{v56, v62}) tmp101 := lang.Apply(tmp98, []any{tmp100}) tmp102 := lang.Apply(tmp97, []any{tmp101}) @@ -32513,7 +32853,7 @@ func LoadNS() { return tmp33 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -32521,28 +32861,26 @@ func LoadNS() { } // macroexpand { - tmp0 := lang.NewSymbol("macroexpand").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("form"))), lang.NewKeyword("doc"), "Repeatedly calls macroexpand-1 on form until it no longer\n represents a macro form, then returns it. Note neither\n macroexpand-1 nor macroexpand expand macros in subforms.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4025), lang.NewKeyword("end-line"), int(4025))).(*lang.Symbol) + tmp0 := sym_macroexpand.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_form)), kw_doc, "Repeatedly calls macroexpand-1 on form until it no longer\n represents a macro form, then returns it. Note neither\n macroexpand-1 nor macroexpand expand macros in subforms.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(4025), kw_end_DASH_line, int(4025))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any { // let // let binding "ex" - tmp5 := checkDerefVar(glojure_DOT_core_macroexpand_1) + tmp5 := checkDerefVar(var_glojure_DOT_core_macroexpand_DASH_1) tmp6 := lang.Apply(tmp5, []any{v3}) var v7 any = tmp6 _ = v7 var tmp8 any - tmp9 := checkDerefVar(glojure_DOT_core_identical_QMARK_) + tmp9 := checkDerefVar(var_glojure_DOT_core_identical_QMARK_) tmp10 := lang.Apply(tmp9, []any{v7, v3}) if lang.IsTruthy(tmp10) { tmp8 = v3 } else { - tmp11 := checkDerefVar(glojure_DOT_core_macroexpand) + tmp11 := checkDerefVar(var_glojure_DOT_core_macroexpand) tmp12 := lang.Apply(tmp11, []any{v7}) tmp8 = tmp12 } @@ -32550,7 +32888,7 @@ func LoadNS() { } // end let return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -32558,12 +32896,10 @@ func LoadNS() { } // macroexpand-1 { - tmp0 := lang.NewSymbol("macroexpand-1").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("form"))), lang.NewKeyword("doc"), "If form represents a macro form, returns its expansion,\n else returns form.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4017), lang.NewKeyword("end-line"), int(4017))).(*lang.Symbol) + tmp0 := sym_macroexpand_DASH_1.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_form)), kw_doc, "If form represents a macro form, returns its expansion,\n else returns form.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(4017), kw_end_DASH_line, int(4017))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4, _ := lang.FieldOrMethod(runtime7.Compiler, "macroexpand1") @@ -32573,7 +32909,7 @@ func LoadNS() { tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -32581,7 +32917,7 @@ func LoadNS() { } // make-array { - tmp0 := lang.NewSymbol("make-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("type"), lang.NewSymbol("len")), lang.NewVector(lang.NewSymbol("type"), lang.NewSymbol("dim"), lang.NewSymbol("&"), lang.NewSymbol("more-dims"))), lang.NewKeyword("doc"), "Creates and returns an array of instances of the specified class of\n the specified dimension(s). Note that a class object is required.\n Class objects can be obtained by using their imported or\n fully-qualified name. Class objects for the primitive types can be\n obtained using, e.g., Integer/TYPE.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3985), lang.NewKeyword("end-line"), int(3985))).(*lang.Symbol) + tmp0 := sym_make_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_type, sym_len), lang.NewVector(sym_type, sym_dim, sym__AMP_, sym_more_DASH_dims)), kw_doc, "Creates and returns an array of instances of the specified class of\n the specified dimension(s). Note that a class object is required.\n Class objects can be obtained by using their imported or\n fully-qualified name. Class objects for the primitive types can be\n obtained using, e.g., Integer/TYPE.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(3985), kw_end_DASH_line, int(3985))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -32590,7 +32926,7 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_int) + tmp5 := checkDerefVar(var_glojure_DOT_core_int) tmp6 := lang.Apply(tmp5, []any{v4}) tmp7, _ := lang.FieldOrMethod(nil, "newInstance") if reflect.TypeOf(tmp7).Kind() != reflect.Func { @@ -32599,9 +32935,7 @@ func LoadNS() { tmp8 := lang.Apply(tmp7, []any{v3, tmp6}) return tmp8 default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -32611,12 +32945,12 @@ func LoadNS() { var tmp6 any { // let // let binding "dims" - tmp7 := checkDerefVar(glojure_DOT_core_cons) + tmp7 := checkDerefVar(var_glojure_DOT_core_cons) tmp8 := lang.Apply(tmp7, []any{v4, v5}) var v9 any = tmp8 _ = v9 // let binding "dimarray" - tmp10 := checkDerefVar(glojure_DOT_core_make_array) + tmp10 := checkDerefVar(var_glojure_DOT_core_make_DASH_array) tmp11, ok := lang.FieldOrMethod(nil, "TYPE") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "TYPE"))) @@ -32628,7 +32962,7 @@ func LoadNS() { default: tmp12 = tmp11 } - tmp13 := checkDerefVar(glojure_DOT_core_count) + tmp13 := checkDerefVar(var_glojure_DOT_core_count) tmp14 := lang.Apply(tmp13, []any{v9}) tmp15 := lang.Apply(tmp10, []any{tmp12, tmp14}) var v16 any = tmp15 @@ -32636,8 +32970,8 @@ func LoadNS() { var tmp17 any { // let // let binding "n__0__auto__" - tmp18 := checkDerefVar(glojure_DOT_core_long) - tmp19 := checkDerefVar(glojure_DOT_core_alength) + tmp18 := checkDerefVar(var_glojure_DOT_core_long) + tmp19 := checkDerefVar(var_glojure_DOT_core_alength) tmp20 := lang.Apply(tmp19, []any{v16}) tmp21 := lang.Apply(tmp18, []any{tmp20}) var v22 any = tmp21 @@ -32649,15 +32983,15 @@ func LoadNS() { _ = v24 for { var tmp25 any - tmp26 := checkDerefVar(glojure_DOT_core__LT_) + tmp26 := checkDerefVar(var_glojure_DOT_core__LT_) tmp27 := lang.Apply(tmp26, []any{v24, v22}) if lang.IsTruthy(tmp27) { - tmp28 := checkDerefVar(glojure_DOT_core_aset_int) - tmp29 := checkDerefVar(glojure_DOT_core_nth) + tmp28 := checkDerefVar(var_glojure_DOT_core_aset_DASH_int) + tmp29 := checkDerefVar(var_glojure_DOT_core_nth) tmp30 := lang.Apply(tmp29, []any{v9, v24}) tmp31 := lang.Apply(tmp28, []any{v16, v24, tmp30}) _ = tmp31 - tmp33 := checkDerefVar(glojure_DOT_core_unchecked_inc) + tmp33 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) tmp34 := lang.Apply(tmp33, []any{v24}) var tmp32 any = tmp34 v24 = tmp32 @@ -32681,7 +33015,7 @@ func LoadNS() { return tmp6 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -32689,39 +33023,37 @@ func LoadNS() { } // make-hierarchy { - tmp0 := lang.NewSymbol("make-hierarchy").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Creates a hierarchy object for use with derive, isa? etc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5507), lang.NewKeyword("end-line"), int(5507))).(*lang.Symbol) + tmp0 := sym_make_DASH_hierarchy.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Creates a hierarchy object for use with derive, isa? etc.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(5507), kw_end_DASH_line, int(5507))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) tmp3 := lang.NewMap() - tmp4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5511), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(5511), lang.NewKeyword("end-column"), int(17)) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5511), kw_column, int(16), kw_end_DASH_line, int(5511), kw_end_DASH_column, int(17)) tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) if err != nil { panic(err) } tmp6 := lang.NewMap() - tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5511), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(5511), lang.NewKeyword("end-column"), int(33)) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5511), kw_column, int(32), kw_end_DASH_line, int(5511), kw_end_DASH_column, int(33)) tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) if err != nil { panic(err) } tmp9 := lang.NewMap() - tmp10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5511), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(5511), lang.NewKeyword("end-column"), int(47)) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5511), kw_column, int(46), kw_end_DASH_line, int(5511), kw_end_DASH_column, int(47)) tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp12 := lang.NewMap(lang.NewKeyword("parents"), tmp5, lang.NewKeyword("descendants"), tmp8, lang.NewKeyword("ancestors"), tmp11) - tmp13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5511), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(5511), lang.NewKeyword("end-column"), int(48)) + tmp12 := lang.NewMap(kw_parents, tmp5, kw_descendants, tmp8, kw_ancestors, tmp11) + tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5511), kw_column, int(6), kw_end_DASH_line, int(5511), kw_end_DASH_column, int(48)) tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) if err != nil { panic(err) } return tmp14 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -32729,7 +33061,7 @@ func LoadNS() { } // map { - tmp0 := lang.NewSymbol("map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2"), lang.NewSymbol("c3")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2"), lang.NewSymbol("c3"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Returns a lazy sequence consisting of the result of applying f to\n the set of first items of each coll, followed by applying f to the\n set of second items in each coll, until any one of the colls is\n exhausted. Any remaining items in other colls are ignored. Function\n f should accept number-of-colls arguments. Returns a transducer when\n no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2719), lang.NewKeyword("end-line"), int(2719))).(*lang.Symbol) + tmp0 := sym_map.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_coll), lang.NewVector(sym_f, sym_c1, sym_c2), lang.NewVector(sym_f, sym_c1, sym_c2, sym_c3), lang.NewVector(sym_f, sym_c1, sym_c2, sym_c3, sym__AMP_, sym_colls)), kw_doc, "Returns a lazy sequence consisting of the result of applying f to\n the set of first items of each coll, followed by applying f to the\n set of second items in each coll, until any one of the colls is\n exhausted. Any remaining items in other colls are ignored. Function\n f should accept number-of-colls arguments. Returns a transducer when\n no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(2719), kw_end_DASH_line, int(2719))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -32738,9 +33070,7 @@ func LoadNS() { _ = v3 var tmp4 lang.FnFunc tmp4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v5 := args[0] _ = v5 var tmp6 lang.FnFunc @@ -32763,29 +33093,27 @@ func LoadNS() { tmp10 := lang.Apply(v5, []any{v7, tmp9}) return tmp10 default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v7 := args[0] _ = v7 v8 := args[1] _ = v8 var v9 any = lang.NewList(args[2:]...) _ = v9 - tmp10 := checkDerefVar(glojure_DOT_core_apply) + tmp10 := checkDerefVar(var_glojure_DOT_core_apply) tmp11 := lang.Apply(tmp10, []any{v3, v8, v9}) tmp12 := lang.Apply(v5, []any{v7, tmp11}) return tmp12 } }) - tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2730), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(2736), lang.NewKeyword("end-column"), int(47)) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2730), kw_column, int(7), kw_end_DASH_line, int(2736), kw_end_DASH_column, int(47)) tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) if err != nil { panic(err) } return tmp8 }) - tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2729), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2736), lang.NewKeyword("end-column"), int(48)) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2729), kw_column, int(5), kw_end_DASH_line, int(2736), kw_end_DASH_column, int(48)) tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) if err != nil { panic(err) @@ -32798,13 +33126,11 @@ func LoadNS() { _ = v4 var tmp5 lang.FnFunc tmp5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var tmp6 any { // let // let binding "temp__0__auto__" - tmp7 := checkDerefVar(glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) tmp8 := lang.Apply(tmp7, []any{v4}) var v9 any = tmp8 _ = v9 @@ -32816,25 +33142,25 @@ func LoadNS() { var v12 any = v9 _ = v12 var tmp13 any - tmp14 := checkDerefVar(glojure_DOT_core_chunked_seq_QMARK_) + tmp14 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) tmp15 := lang.Apply(tmp14, []any{v12}) if lang.IsTruthy(tmp15) { var tmp16 any { // let // let binding "c" - tmp17 := checkDerefVar(glojure_DOT_core_chunk_first) + tmp17 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) tmp18 := lang.Apply(tmp17, []any{v12}) var v19 any = tmp18 _ = v19 // let binding "size" - tmp20 := checkDerefVar(glojure_DOT_core_int) - tmp21 := checkDerefVar(glojure_DOT_core_count) + tmp20 := checkDerefVar(var_glojure_DOT_core_int) + tmp21 := checkDerefVar(var_glojure_DOT_core_count) tmp22 := lang.Apply(tmp21, []any{v19}) tmp23 := lang.Apply(tmp20, []any{tmp22}) var v24 any = tmp23 _ = v24 // let binding "b" - tmp25 := checkDerefVar(glojure_DOT_core_chunk_buffer) + tmp25 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_buffer) tmp26 := lang.Apply(tmp25, []any{v24}) var v27 any = tmp26 _ = v27 @@ -32851,10 +33177,10 @@ func LoadNS() { _ = v32 for { var tmp33 any - tmp34 := checkDerefVar(glojure_DOT_core__LT_) + tmp34 := checkDerefVar(var_glojure_DOT_core__LT_) tmp35 := lang.Apply(tmp34, []any{v32, v30}) if lang.IsTruthy(tmp35) { - tmp36 := checkDerefVar(glojure_DOT_core_chunk_append) + tmp36 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_append) tmp37, _ := lang.FieldOrMethod(v19, "nth") if reflect.TypeOf(tmp37).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) @@ -32863,7 +33189,7 @@ func LoadNS() { tmp39 := lang.Apply(v3, []any{tmp38}) tmp40 := lang.Apply(tmp36, []any{v27, tmp39}) _ = tmp40 - tmp42 := checkDerefVar(glojure_DOT_core_unchecked_inc) + tmp42 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) tmp43 := lang.Apply(tmp42, []any{v32}) var tmp41 any = tmp43 v32 = tmp41 @@ -32877,11 +33203,11 @@ func LoadNS() { tmp28 = tmp31 } // end let _ = tmp28 - tmp29 := checkDerefVar(glojure_DOT_core_chunk_cons) - tmp30 := checkDerefVar(glojure_DOT_core_chunk) + tmp29 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_cons) + tmp30 := checkDerefVar(var_glojure_DOT_core_chunk) tmp31 := lang.Apply(tmp30, []any{v27}) - tmp32 := checkDerefVar(glojure_DOT_core_map) - tmp33 := checkDerefVar(glojure_DOT_core_chunk_rest) + tmp32 := checkDerefVar(var_glojure_DOT_core_map) + tmp33 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) tmp34 := lang.Apply(tmp33, []any{v12}) tmp35 := lang.Apply(tmp32, []any{v3, tmp34}) tmp36 := lang.Apply(tmp29, []any{tmp31, tmp35}) @@ -32889,12 +33215,12 @@ func LoadNS() { } // end let tmp13 = tmp16 } else { - tmp17 := checkDerefVar(glojure_DOT_core_cons) - tmp18 := checkDerefVar(glojure_DOT_core_first) + tmp17 := checkDerefVar(var_glojure_DOT_core_cons) + tmp18 := checkDerefVar(var_glojure_DOT_core_first) tmp19 := lang.Apply(tmp18, []any{v12}) tmp20 := lang.Apply(v3, []any{tmp19}) - tmp21 := checkDerefVar(glojure_DOT_core_map) - tmp22 := checkDerefVar(glojure_DOT_core_rest) + tmp21 := checkDerefVar(var_glojure_DOT_core_map) + tmp22 := checkDerefVar(var_glojure_DOT_core_rest) tmp23 := lang.Apply(tmp22, []any{v12}) tmp24 := lang.Apply(tmp21, []any{v3, tmp23}) tmp25 := lang.Apply(tmp17, []any{tmp20, tmp24}) @@ -32920,18 +33246,16 @@ func LoadNS() { _ = v5 var tmp6 lang.FnFunc tmp6 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var tmp7 any { // let // let binding "s1" - tmp8 := checkDerefVar(glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) tmp9 := lang.Apply(tmp8, []any{v4}) var v10 any = tmp9 _ = v10 // let binding "s2" - tmp11 := checkDerefVar(glojure_DOT_core_seq) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := lang.Apply(tmp11, []any{v5}) var v13 any = tmp12 _ = v13 @@ -32950,16 +33274,16 @@ func LoadNS() { tmp15 = tmp17 } // end let if lang.IsTruthy(tmp15) { - tmp16 := checkDerefVar(glojure_DOT_core_cons) - tmp17 := checkDerefVar(glojure_DOT_core_first) + tmp16 := checkDerefVar(var_glojure_DOT_core_cons) + tmp17 := checkDerefVar(var_glojure_DOT_core_first) tmp18 := lang.Apply(tmp17, []any{v10}) - tmp19 := checkDerefVar(glojure_DOT_core_first) + tmp19 := checkDerefVar(var_glojure_DOT_core_first) tmp20 := lang.Apply(tmp19, []any{v13}) tmp21 := lang.Apply(v3, []any{tmp18, tmp20}) - tmp22 := checkDerefVar(glojure_DOT_core_map) - tmp23 := checkDerefVar(glojure_DOT_core_rest) + tmp22 := checkDerefVar(var_glojure_DOT_core_map) + tmp23 := checkDerefVar(var_glojure_DOT_core_rest) tmp24 := lang.Apply(tmp23, []any{v10}) - tmp25 := checkDerefVar(glojure_DOT_core_rest) + tmp25 := checkDerefVar(var_glojure_DOT_core_rest) tmp26 := lang.Apply(tmp25, []any{v13}) tmp27 := lang.Apply(tmp22, []any{v3, tmp24, tmp26}) tmp28 := lang.Apply(tmp16, []any{tmp21, tmp27}) @@ -32983,23 +33307,21 @@ func LoadNS() { _ = v6 var tmp7 lang.FnFunc tmp7 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var tmp8 any { // let // let binding "s1" - tmp9 := checkDerefVar(glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_seq) tmp10 := lang.Apply(tmp9, []any{v4}) var v11 any = tmp10 _ = v11 // let binding "s2" - tmp12 := checkDerefVar(glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := lang.Apply(tmp12, []any{v5}) var v14 any = tmp13 _ = v14 // let binding "s3" - tmp15 := checkDerefVar(glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) tmp16 := lang.Apply(tmp15, []any{v6}) var v17 any = tmp16 _ = v17 @@ -33031,20 +33353,20 @@ func LoadNS() { tmp19 = tmp21 } // end let if lang.IsTruthy(tmp19) { - tmp20 := checkDerefVar(glojure_DOT_core_cons) - tmp21 := checkDerefVar(glojure_DOT_core_first) + tmp20 := checkDerefVar(var_glojure_DOT_core_cons) + tmp21 := checkDerefVar(var_glojure_DOT_core_first) tmp22 := lang.Apply(tmp21, []any{v11}) - tmp23 := checkDerefVar(glojure_DOT_core_first) + tmp23 := checkDerefVar(var_glojure_DOT_core_first) tmp24 := lang.Apply(tmp23, []any{v14}) - tmp25 := checkDerefVar(glojure_DOT_core_first) + tmp25 := checkDerefVar(var_glojure_DOT_core_first) tmp26 := lang.Apply(tmp25, []any{v17}) tmp27 := lang.Apply(v3, []any{tmp22, tmp24, tmp26}) - tmp28 := checkDerefVar(glojure_DOT_core_map) - tmp29 := checkDerefVar(glojure_DOT_core_rest) + tmp28 := checkDerefVar(var_glojure_DOT_core_map) + tmp29 := checkDerefVar(var_glojure_DOT_core_rest) tmp30 := lang.Apply(tmp29, []any{v11}) - tmp31 := checkDerefVar(glojure_DOT_core_rest) + tmp31 := checkDerefVar(var_glojure_DOT_core_rest) tmp32 := lang.Apply(tmp31, []any{v14}) - tmp33 := checkDerefVar(glojure_DOT_core_rest) + tmp33 := checkDerefVar(var_glojure_DOT_core_rest) tmp34 := lang.Apply(tmp33, []any{v17}) tmp35 := lang.Apply(tmp28, []any{v3, tmp30, tmp32, tmp34}) tmp36 := lang.Apply(tmp20, []any{tmp27, tmp35}) @@ -33058,9 +33380,7 @@ func LoadNS() { tmp8 := lang.Apply(lang.NewLazySeq, []any{tmp7}) return tmp8 default: - if len(args) < 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 4) v3 := args[0] _ = v3 v4 := args[1] @@ -33078,35 +33398,31 @@ func LoadNS() { { // function step var v10 lang.FnFunc tmp9 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v11 := args[0] _ = v11 var tmp12 lang.FnFunc tmp12 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var tmp13 any { // let // let binding "ss" - tmp14 := checkDerefVar(glojure_DOT_core_map) - tmp15 := checkDerefVar(glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_map) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) tmp16 := lang.Apply(tmp14, []any{tmp15, v11}) var v17 any = tmp16 _ = v17 var tmp18 any - tmp19 := checkDerefVar(glojure_DOT_core_every_QMARK_) - tmp20 := checkDerefVar(glojure_DOT_core_identity) + tmp19 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + tmp20 := checkDerefVar(var_glojure_DOT_core_identity) tmp21 := lang.Apply(tmp19, []any{tmp20, v17}) if lang.IsTruthy(tmp21) { - tmp22 := checkDerefVar(glojure_DOT_core_cons) - tmp23 := checkDerefVar(glojure_DOT_core_map) - tmp24 := checkDerefVar(glojure_DOT_core_first) + tmp22 := checkDerefVar(var_glojure_DOT_core_cons) + tmp23 := checkDerefVar(var_glojure_DOT_core_map) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) tmp25 := lang.Apply(tmp23, []any{tmp24, v17}) - tmp26 := checkDerefVar(glojure_DOT_core_map) - tmp27 := checkDerefVar(glojure_DOT_core_rest) + tmp26 := checkDerefVar(var_glojure_DOT_core_map) + tmp27 := checkDerefVar(var_glojure_DOT_core_rest) tmp28 := lang.Apply(tmp26, []any{tmp27, v17}) tmp29 := lang.Apply(v10, []any{tmp28}) tmp30 := lang.Apply(tmp22, []any{tmp25, tmp29}) @@ -33123,31 +33439,29 @@ func LoadNS() { v10 = tmp9 _ = v10 } - tmp10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2761), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(2765), lang.NewKeyword("end-column"), int(68)) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2761), kw_column, int(15), kw_end_DASH_line, int(2765), kw_end_DASH_column, int(68)) tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) if err != nil { panic(err) } var v12 any = tmp11 _ = v12 - tmp13 := checkDerefVar(glojure_DOT_core_map) + tmp13 := checkDerefVar(var_glojure_DOT_core_map) var tmp14 lang.FnFunc tmp14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v15 := args[0] _ = v15 - tmp16 := checkDerefVar(glojure_DOT_core_apply) + tmp16 := checkDerefVar(var_glojure_DOT_core_apply) tmp17 := lang.Apply(tmp16, []any{v3, v15}) return tmp17 }) - tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2766), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(2766), lang.NewKeyword("end-column"), int(22)) + tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2766), kw_column, int(11), kw_end_DASH_line, int(2766), kw_end_DASH_column, int(22)) tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp17 := checkDerefVar(glojure_DOT_core_conj) + tmp17 := checkDerefVar(var_glojure_DOT_core_conj) tmp18 := lang.Apply(tmp17, []any{v7, v6, v5, v4}) tmp19 := lang.Apply(v12, []any{tmp18}) tmp20 := lang.Apply(tmp13, []any{tmp16, tmp19}) @@ -33156,7 +33470,7 @@ func LoadNS() { return tmp8 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -33164,20 +33478,18 @@ func LoadNS() { } // map-entry? { - tmp0 := lang.NewSymbol("map-entry?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a map entry", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.8", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1473), lang.NewKeyword("end-line"), int(1473))).(*lang.Symbol) + tmp0 := sym_map_DASH_entry_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a map entry", kw_file, "glojure/core.glj", kw_added, "1.8", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(1473), kw_end_DASH_line, int(1473))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp5 := reflect.TypeOf((*lang.MapEntry)(nil)).Elem() tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -33185,7 +33497,7 @@ func LoadNS() { } // map-indexed { - tmp0 := lang.NewSymbol("map-indexed").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence consisting of the result of applying f to 0\n and the first item of coll, followed by applying f to 1 and the second\n item in coll, etc, until coll is exhausted. Thus function f should\n accept 2 arguments, index and item. Returns a stateful transducer when\n no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7309), lang.NewKeyword("end-line"), int(7309))).(*lang.Symbol) + tmp0 := sym_map_DASH_indexed.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_coll)), kw_doc, "Returns a lazy sequence consisting of the result of applying f to 0\n and the first item of coll, followed by applying f to 1 and the second\n item in coll, etc, until coll is exhausted. Thus function f should\n accept 2 arguments, index and item. Returns a stateful transducer when\n no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(7309), kw_end_DASH_line, int(7309))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -33194,15 +33506,13 @@ func LoadNS() { _ = v3 var tmp4 lang.FnFunc tmp4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v5 := args[0] _ = v5 var tmp6 any { // let // let binding "i" - tmp7 := checkDerefVar(glojure_DOT_core_volatile_BANG_) + tmp7 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) tmp8 := lang.Apply(tmp7, []any{int64(-1)}) var v9 any = tmp8 _ = v9 @@ -33222,7 +33532,7 @@ func LoadNS() { _ = v11 v12 := args[1] _ = v12 - tmp13 := checkDerefVar(glojure_DOT_core_inc) + tmp13 := checkDerefVar(var_glojure_DOT_core_inc) tmp14, ok := lang.FieldOrMethod(v9, "Deref") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v9, "Deref"))) @@ -33244,10 +33554,11 @@ func LoadNS() { tmp20 := lang.Apply(v5, []any{v11, tmp19}) return tmp20 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7320), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7324), lang.NewKeyword("end-column"), int(48)) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7320), kw_column, int(8), kw_end_DASH_line, int(7324), kw_end_DASH_column, int(48)) tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) if err != nil { panic(err) @@ -33256,7 +33567,7 @@ func LoadNS() { } // end let return tmp6 }) - tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7318), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7324), lang.NewKeyword("end-column"), int(50)) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7318), kw_column, int(4), kw_end_DASH_line, int(7324), kw_end_DASH_column, int(50)) tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) if err != nil { panic(err) @@ -33269,10 +33580,11 @@ func LoadNS() { _ = v4 return nil default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -33280,22 +33592,20 @@ func LoadNS() { } // map? { - tmp0 := lang.NewSymbol("map?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x implements IPersistentMap", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(167), lang.NewKeyword("end-line"), int(171))).(*lang.Symbol) + tmp0 := sym_map_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x implements IPersistentMap", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(5), kw_column, int(2), kw_line, int(167), kw_end_DASH_line, int(171))).(*lang.Symbol) var tmp2 lang.FnFunc { // function map? var v3 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp6 := reflect.TypeOf((*lang.IPersistentMap)(nil)).Elem() tmp7 := lang.Apply(tmp5, []any{tmp6, v4}) return tmp7 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(171), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(171), lang.NewKeyword("end-column"), int(97))).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(171), kw_column, int(7), kw_end_DASH_line, int(171), kw_end_DASH_column, int(97))).(lang.FnFunc) v3 = tmp2 _ = v3 } @@ -33306,37 +33616,35 @@ func LoadNS() { } // mapcat { - tmp0 := lang.NewSymbol("mapcat").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Returns the result of applying concat to the result of applying map\n to f and colls. Thus function f should return a collection. Returns\n a transducer when no collections are provided", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2775), lang.NewKeyword("end-line"), int(2775))).(*lang.Symbol) + tmp0 := sym_mapcat.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym__AMP_, sym_colls)), kw_doc, "Returns the result of applying concat to the result of applying map\n to f and colls. Thus function f should return a collection. Returns\n a transducer when no collections are provided", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(2775), kw_end_DASH_line, int(2775))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_comp) - tmp5 := checkDerefVar(glojure_DOT_core_map) + tmp4 := checkDerefVar(var_glojure_DOT_core_comp) + tmp5 := checkDerefVar(var_glojure_DOT_core_map) tmp6 := lang.Apply(tmp5, []any{v3}) - tmp7 := checkDerefVar(glojure_DOT_core_cat) + tmp7 := checkDerefVar(var_glojure_DOT_core_cat) tmp8 := lang.Apply(tmp4, []any{tmp6, tmp7}) return tmp8 default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var v4 any = lang.NewList(args[1:]...) _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_apply) - tmp6 := checkDerefVar(glojure_DOT_core_concat) - tmp7 := checkDerefVar(glojure_DOT_core_apply) - tmp8 := checkDerefVar(glojure_DOT_core_map) + tmp5 := checkDerefVar(var_glojure_DOT_core_apply) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_apply) + tmp8 := checkDerefVar(var_glojure_DOT_core_map) tmp9 := lang.Apply(tmp7, []any{tmp8, v3, v4}) tmp10 := lang.Apply(tmp5, []any{tmp6, tmp9}) return tmp10 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -33344,7 +33652,7 @@ func LoadNS() { } // mapv { - tmp0 := lang.NewSymbol("mapv").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2"), lang.NewSymbol("c3")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("c1"), lang.NewSymbol("c2"), lang.NewSymbol("c3"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Returns a vector consisting of the result of applying f to the\n set of first items of each coll, followed by applying f to the set\n of second items in each coll, until any one of the colls is\n exhausted. Any remaining items in other colls are ignored. Function\n f should accept number-of-colls arguments.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6943), lang.NewKeyword("end-line"), int(6943))).(*lang.Symbol) + tmp0 := sym_mapv.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_coll), lang.NewVector(sym_f, sym_c1, sym_c2), lang.NewVector(sym_f, sym_c1, sym_c2, sym_c3), lang.NewVector(sym_f, sym_c1, sym_c2, sym_c3, sym__AMP_, sym_colls)), kw_doc, "Returns a vector consisting of the result of applying f to the\n set of first items of each coll, followed by applying f to the set\n of second items in each coll, until any one of the colls is\n exhausted. Any remaining items in other colls are ignored. Function\n f should accept number-of-colls arguments.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.4", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(6943), kw_end_DASH_line, int(6943))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -33353,30 +33661,28 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_persistent_BANG_) - tmp6 := checkDerefVar(glojure_DOT_core_reduce) + tmp5 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp6 := checkDerefVar(var_glojure_DOT_core_reduce) var tmp7 lang.FnFunc tmp7 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v8 := args[0] _ = v8 v9 := args[1] _ = v9 - tmp10 := checkDerefVar(glojure_DOT_core_conj_BANG_) + tmp10 := checkDerefVar(var_glojure_DOT_core_conj_BANG_) tmp11 := lang.Apply(v3, []any{v9}) tmp12 := lang.Apply(tmp10, []any{v8, tmp11}) return tmp12 }) - tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6952), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(6952), lang.NewKeyword("end-column"), int(43)) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6952), kw_column, int(18), kw_end_DASH_line, int(6952), kw_end_DASH_column, int(43)) tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp10 := checkDerefVar(glojure_DOT_core_transient) + tmp10 := checkDerefVar(var_glojure_DOT_core_transient) tmp11 := lang.NewVector() - tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6952), lang.NewKeyword("column"), int(56), lang.NewKeyword("end-line"), int(6952), lang.NewKeyword("end-column"), int(57)) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6952), kw_column, int(56), kw_end_DASH_line, int(6952), kw_end_DASH_column, int(57)) tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) if err != nil { panic(err) @@ -33392,14 +33698,14 @@ func LoadNS() { _ = v4 v5 := args[2] _ = v5 - tmp6 := checkDerefVar(glojure_DOT_core_into) + tmp6 := checkDerefVar(var_glojure_DOT_core_into) tmp7 := lang.NewVector() - tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6955), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(6955), lang.NewKeyword("end-column"), int(13)) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6955), kw_column, int(12), kw_end_DASH_line, int(6955), kw_end_DASH_column, int(13)) tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp10 := checkDerefVar(glojure_DOT_core_map) + tmp10 := checkDerefVar(var_glojure_DOT_core_map) tmp11 := lang.Apply(tmp10, []any{v3, v4, v5}) tmp12 := lang.Apply(tmp6, []any{tmp9, tmp11}) return tmp12 @@ -33412,21 +33718,19 @@ func LoadNS() { _ = v5 v6 := args[3] _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_into) + tmp7 := checkDerefVar(var_glojure_DOT_core_into) tmp8 := lang.NewVector() - tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6957), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(6957), lang.NewKeyword("end-column"), int(13)) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6957), kw_column, int(12), kw_end_DASH_line, int(6957), kw_end_DASH_column, int(13)) tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp11 := checkDerefVar(glojure_DOT_core_map) + tmp11 := checkDerefVar(var_glojure_DOT_core_map) tmp12 := lang.Apply(tmp11, []any{v3, v4, v5, v6}) tmp13 := lang.Apply(tmp7, []any{tmp10, tmp12}) return tmp13 default: - if len(args) < 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 4) v3 := args[0] _ = v3 v4 := args[1] @@ -33437,21 +33741,21 @@ func LoadNS() { _ = v6 var v7 any = lang.NewList(args[4:]...) _ = v7 - tmp8 := checkDerefVar(glojure_DOT_core_into) + tmp8 := checkDerefVar(var_glojure_DOT_core_into) tmp9 := lang.NewVector() - tmp10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6959), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(6959), lang.NewKeyword("end-column"), int(13)) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6959), kw_column, int(12), kw_end_DASH_line, int(6959), kw_end_DASH_column, int(13)) tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp12 := checkDerefVar(glojure_DOT_core_apply) - tmp13 := checkDerefVar(glojure_DOT_core_map) + tmp12 := checkDerefVar(var_glojure_DOT_core_apply) + tmp13 := checkDerefVar(var_glojure_DOT_core_map) tmp14 := lang.Apply(tmp12, []any{tmp13, v3, v4, v5, v6, v7}) tmp15 := lang.Apply(tmp8, []any{tmp11, tmp14}) return tmp15 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -33469,7 +33773,7 @@ func LoadNS() { { // let // let binding "op" var tmp4 any - tmp5 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp5) { tmp4 = closed33 } else { @@ -33477,18 +33781,18 @@ func LoadNS() { } var v6 any = tmp4 _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_seq) - tmp8 := checkDerefVar(glojure_DOT_core_concat) - tmp9 := checkDerefVar(glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol(".")}) - tmp11 := checkDerefVar(glojure_DOT_core_list) - tmp12 := lang.Apply(tmp11, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp13 := checkDerefVar(glojure_DOT_core_list) - tmp14 := checkDerefVar(glojure_DOT_core_seq) - tmp15 := checkDerefVar(glojure_DOT_core_concat) - tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v6}) - tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) tmp19 := lang.Apply(tmp18, []any{v2}) tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) tmp21 := lang.Apply(tmp14, []any{tmp20}) @@ -33507,7 +33811,7 @@ func LoadNS() { { // let // let binding "op" var tmp5 any - tmp6 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp6) { tmp5 = closed33 } else { @@ -33515,20 +33819,20 @@ func LoadNS() { } var v7 any = tmp5 _ = v7 - tmp8 := checkDerefVar(glojure_DOT_core_seq) - tmp9 := checkDerefVar(glojure_DOT_core_concat) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol(".")}) - tmp12 := checkDerefVar(glojure_DOT_core_list) - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp14 := checkDerefVar(glojure_DOT_core_list) - tmp15 := checkDerefVar(glojure_DOT_core_seq) - tmp16 := checkDerefVar(glojure_DOT_core_concat) - tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) tmp18 := lang.Apply(tmp17, []any{v7}) - tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) tmp20 := lang.Apply(tmp19, []any{v2}) - tmp21 := checkDerefVar(glojure_DOT_core_list) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) tmp22 := lang.Apply(tmp21, []any{v3}) tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) tmp24 := lang.Apply(tmp15, []any{tmp23}) @@ -33539,9 +33843,7 @@ func LoadNS() { } // end let return tmp4 default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -33552,7 +33854,7 @@ func LoadNS() { { // let // let binding "op" var tmp6 any - tmp7 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp7) { tmp6 = closed33 } else { @@ -33560,30 +33862,28 @@ func LoadNS() { } var v8 any = tmp6 _ = v8 - tmp9 := checkDerefVar(glojure_DOT_core_reduce1) + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) var tmp10 lang.FnFunc tmp10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v11 := args[0] _ = v11 v12 := args[1] _ = v12 - tmp13 := checkDerefVar(glojure_DOT_core_seq) - tmp14 := checkDerefVar(glojure_DOT_core_concat) - tmp15 := checkDerefVar(glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) - tmp17 := checkDerefVar(glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp19 := checkDerefVar(glojure_DOT_core_list) - tmp20 := checkDerefVar(glojure_DOT_core_seq) - tmp21 := checkDerefVar(glojure_DOT_core_concat) - tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) tmp23 := lang.Apply(tmp22, []any{v8}) - tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) tmp25 := lang.Apply(tmp24, []any{v11}) - tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) tmp27 := lang.Apply(tmp26, []any{v12}) tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) tmp29 := lang.Apply(tmp20, []any{tmp28}) @@ -33592,25 +33892,25 @@ func LoadNS() { tmp32 := lang.Apply(tmp13, []any{tmp31}) return tmp32 }) - tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp13 := checkDerefVar(glojure_DOT_core_seq) - tmp14 := checkDerefVar(glojure_DOT_core_concat) - tmp15 := checkDerefVar(glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) - tmp17 := checkDerefVar(glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp19 := checkDerefVar(glojure_DOT_core_list) - tmp20 := checkDerefVar(glojure_DOT_core_seq) - tmp21 := checkDerefVar(glojure_DOT_core_concat) - tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) tmp23 := lang.Apply(tmp22, []any{v8}) - tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) tmp25 := lang.Apply(tmp24, []any{v2}) - tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) tmp27 := lang.Apply(tmp26, []any{v3}) tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) tmp29 := lang.Apply(tmp20, []any{tmp28}) @@ -33623,12 +33923,10 @@ func LoadNS() { return tmp5 } }) - tmp1 = tmp1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") @@ -33638,8 +33936,8 @@ func LoadNS() { tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp0 := lang.NewSymbol("max").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the greatest of the nums.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), tmp2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1108), lang.NewKeyword("end-line"), int(1108))).(*lang.Symbol) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym_max.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns the greatest of the nums.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(1108), kw_end_DASH_line, int(1108))).(*lang.Symbol) var tmp4 lang.FnFunc tmp4 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -33659,24 +33957,22 @@ func LoadNS() { tmp8 := lang.Apply(tmp7, []any{v5, v6}) return tmp8 default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v5 := args[0] _ = v5 v6 := args[1] _ = v6 var v7 any = lang.NewList(args[2:]...) _ = v7 - tmp8 := checkDerefVar(glojure_DOT_core_reduce1) - tmp9 := checkDerefVar(glojure_DOT_core_max) - tmp10 := checkDerefVar(glojure_DOT_core_max) + tmp8 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp9 := checkDerefVar(var_glojure_DOT_core_max) + tmp10 := checkDerefVar(var_glojure_DOT_core_max) tmp11 := lang.Apply(tmp10, []any{v5, v6}) tmp12 := lang.Apply(tmp8, []any{tmp9, tmp11, v7}) return tmp12 } }) - tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp4 = tmp4.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp3 := ns.InternWithValue(tmp0, tmp4, true) if tmp0.Meta() != nil { tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -33684,7 +33980,7 @@ func LoadNS() { } // max-key { - tmp0 := lang.NewSymbol("max-key").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Returns the x for which (k x), a number, is greatest.\n\n If there are multiple such xs, the last one is returned.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5013), lang.NewKeyword("end-line"), int(5013))).(*lang.Symbol) + tmp0 := sym_max_DASH_key.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_k, sym_x), lang.NewVector(sym_k, sym_x, sym_y), lang.NewVector(sym_k, sym_x, sym_y, sym__AMP_, sym_more)), kw_doc, "Returns the x for which (k x), a number, is greatest.\n\n If there are multiple such xs, the last one is returned.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(5013), kw_end_DASH_line, int(5013))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -33702,7 +33998,7 @@ func LoadNS() { v5 := args[2] _ = v5 var tmp6 any - tmp7 := checkDerefVar(glojure_DOT_core__GT_) + tmp7 := checkDerefVar(var_glojure_DOT_core__GT_) tmp8 := lang.Apply(v3, []any{v4}) tmp9 := lang.Apply(v3, []any{v5}) tmp10 := lang.Apply(tmp7, []any{tmp8, tmp9}) @@ -33713,9 +34009,7 @@ func LoadNS() { } return tmp6 default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -33736,11 +34030,11 @@ func LoadNS() { _ = v11 // let binding "vec__55" var tmp12 any - tmp13 := checkDerefVar(glojure_DOT_core__GT_) + tmp13 := checkDerefVar(var_glojure_DOT_core__GT_) tmp14 := lang.Apply(tmp13, []any{v9, v11}) if lang.IsTruthy(tmp14) { tmp15 := lang.NewVector(v4, v9) - tmp16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5023), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(5023), lang.NewKeyword("end-column"), int(36)) + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5023), kw_column, int(31), kw_end_DASH_line, int(5023), kw_end_DASH_column, int(36)) tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) if err != nil { panic(err) @@ -33748,7 +34042,7 @@ func LoadNS() { tmp12 = tmp17 } else { tmp18 := lang.NewVector(v5, v11) - tmp19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5023), lang.NewKeyword("column"), int(38), lang.NewKeyword("end-line"), int(5023), lang.NewKeyword("end-column"), int(43)) + tmp19 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5023), kw_column, int(38), kw_end_DASH_line, int(5023), kw_end_DASH_column, int(43)) tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) if err != nil { panic(err) @@ -33758,12 +34052,12 @@ func LoadNS() { var v21 any = tmp12 _ = v21 // let binding "v" - tmp22 := checkDerefVar(glojure_DOT_core_nth) + tmp22 := checkDerefVar(var_glojure_DOT_core_nth) tmp23 := lang.Apply(tmp22, []any{v21, int64(0), nil}) var v24 any = tmp23 _ = v24 // let binding "kv" - tmp25 := checkDerefVar(glojure_DOT_core_nth) + tmp25 := checkDerefVar(var_glojure_DOT_core_nth) tmp26 := lang.Apply(tmp25, []any{v21, int64(1), nil}) var v27 any = tmp26 _ = v27 @@ -33784,7 +34078,7 @@ func LoadNS() { var tmp33 any { // let // let binding "w" - tmp34 := checkDerefVar(glojure_DOT_core_first) + tmp34 := checkDerefVar(var_glojure_DOT_core_first) tmp35 := lang.Apply(tmp34, []any{v31}) var v36 any = tmp35 _ = v36 @@ -33793,12 +34087,12 @@ func LoadNS() { var v38 any = tmp37 _ = v38 var tmp39 any - tmp40 := checkDerefVar(glojure_DOT_core__GT__EQ_) + tmp40 := checkDerefVar(var_glojure_DOT_core__GT__EQ_) tmp41 := lang.Apply(tmp40, []any{v38, v30}) if lang.IsTruthy(tmp41) { var tmp42 any = v36 var tmp43 any = v38 - tmp45 := checkDerefVar(glojure_DOT_core_next) + tmp45 := checkDerefVar(var_glojure_DOT_core_next) tmp46 := lang.Apply(tmp45, []any{v31}) var tmp44 any = tmp46 v29 = tmp42 @@ -33808,7 +34102,7 @@ func LoadNS() { } else { var tmp47 any = v29 var tmp48 any = v30 - tmp50 := checkDerefVar(glojure_DOT_core_next) + tmp50 := checkDerefVar(var_glojure_DOT_core_next) tmp51 := lang.Apply(tmp50, []any{v31}) var tmp49 any = tmp51 v29 = tmp47 @@ -33831,7 +34125,7 @@ func LoadNS() { return tmp7 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -33839,7 +34133,7 @@ func LoadNS() { } // max-mask-bits { - tmp0 := lang.NewSymbol("max-mask-bits").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6601), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(6601), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym_max_DASH_mask_DASH_bits.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(6601), kw_column, int(6), kw_end_DASH_line, int(6601), kw_end_DASH_column, int(28), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) tmp1 := ns.InternWithValue(tmp0, int64(13), true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -33847,7 +34141,7 @@ func LoadNS() { } // max-switch-table-size { - tmp0 := lang.NewSymbol("max-switch-table-size").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6602), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(6602), lang.NewKeyword("end-column"), int(36), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym_max_DASH_switch_DASH_table_DASH_size.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(6602), kw_column, int(6), kw_end_DASH_line, int(6602), kw_end_DASH_column, int(36), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) tmp1 := ns.InternWithValue(tmp0, int64(8192), true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -33855,22 +34149,20 @@ func LoadNS() { } // maybe-destructured { - tmp0 := lang.NewSymbol("maybe-destructured").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4514), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(4515), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("params"), lang.NewSymbol("body"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym_maybe_DASH_destructured.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(4514), kw_column, int(7), kw_end_DASH_line, int(4515), kw_end_DASH_column, int(20), kw_arglists, lang.NewList(lang.NewVector(sym_params, sym_body)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 var tmp5 any - tmp6 := checkDerefVar(glojure_DOT_core_every_QMARK_) - tmp7 := checkDerefVar(glojure_DOT_core_symbol_QMARK_) + tmp6 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + tmp7 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) if lang.IsTruthy(tmp8) { - tmp9 := checkDerefVar(glojure_DOT_core_cons) + tmp9 := checkDerefVar(var_glojure_DOT_core_cons) tmp10 := lang.Apply(tmp9, []any{v3, v4}) tmp5 = tmp10 } else { @@ -33880,21 +34172,21 @@ func LoadNS() { var v12 any = v3 _ = v12 // let binding "new-params" - tmp13 := checkDerefVar(glojure_DOT_core_with_meta) + tmp13 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) tmp14 := lang.NewVector() - tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4520), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(4520), lang.NewKeyword("end-column"), int(35)) + tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4520), kw_column, int(34), kw_end_DASH_line, int(4520), kw_end_DASH_column, int(35)) tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp17 := checkDerefVar(glojure_DOT_core_meta) + tmp17 := checkDerefVar(var_glojure_DOT_core_meta) tmp18 := lang.Apply(tmp17, []any{v12}) tmp19 := lang.Apply(tmp13, []any{tmp16, tmp18}) var v20 any = tmp19 _ = v20 // let binding "lets" tmp21 := lang.NewVector() - tmp22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4521), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(4521), lang.NewKeyword("end-column"), int(18)) + tmp22 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4521), kw_column, int(17), kw_end_DASH_line, int(4521), kw_end_DASH_column, int(18)) tmp23, err := lang.WithMeta(tmp21, tmp22.(lang.IPersistentMap)) if err != nil { panic(err) @@ -33905,16 +34197,16 @@ func LoadNS() { var tmp25 any if lang.IsTruthy(v12) { var tmp26 any - tmp27 := checkDerefVar(glojure_DOT_core_symbol_QMARK_) - tmp28 := checkDerefVar(glojure_DOT_core_first) + tmp27 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp28 := checkDerefVar(var_glojure_DOT_core_first) tmp29 := lang.Apply(tmp28, []any{v12}) tmp30 := lang.Apply(tmp27, []any{tmp29}) if lang.IsTruthy(tmp30) { - tmp32 := checkDerefVar(glojure_DOT_core_next) + tmp32 := checkDerefVar(var_glojure_DOT_core_next) tmp33 := lang.Apply(tmp32, []any{v12}) var tmp31 any = tmp33 - tmp35 := checkDerefVar(glojure_DOT_core_conj) - tmp36 := checkDerefVar(glojure_DOT_core_first) + tmp35 := checkDerefVar(var_glojure_DOT_core_conj) + tmp36 := checkDerefVar(var_glojure_DOT_core_first) tmp37 := lang.Apply(tmp36, []any{v12}) tmp38 := lang.Apply(tmp35, []any{v20, tmp37}) var tmp34 any = tmp38 @@ -33927,19 +34219,19 @@ func LoadNS() { var tmp40 any { // let // let binding "gparam" - tmp41 := checkDerefVar(glojure_DOT_core_gensym) + tmp41 := checkDerefVar(var_glojure_DOT_core_gensym) tmp42 := lang.Apply(tmp41, []any{"p__"}) var v43 any = tmp42 _ = v43 - tmp45 := checkDerefVar(glojure_DOT_core_next) + tmp45 := checkDerefVar(var_glojure_DOT_core_next) tmp46 := lang.Apply(tmp45, []any{v12}) var tmp44 any = tmp46 - tmp48 := checkDerefVar(glojure_DOT_core_conj) + tmp48 := checkDerefVar(var_glojure_DOT_core_conj) tmp49 := lang.Apply(tmp48, []any{v20, v43}) var tmp47 any = tmp49 - tmp51 := checkDerefVar(glojure_DOT_core_conj) - tmp52 := checkDerefVar(glojure_DOT_core_conj) - tmp53 := checkDerefVar(glojure_DOT_core_first) + tmp51 := checkDerefVar(var_glojure_DOT_core_conj) + tmp52 := checkDerefVar(var_glojure_DOT_core_conj) + tmp53 := checkDerefVar(var_glojure_DOT_core_first) tmp54 := lang.Apply(tmp53, []any{v12}) tmp55 := lang.Apply(tmp52, []any{v24, tmp54}) tmp56 := lang.Apply(tmp51, []any{tmp55, v43}) @@ -33953,16 +34245,16 @@ func LoadNS() { } tmp25 = tmp26 } else { - tmp41 := checkDerefVar(glojure_DOT_core_seq) - tmp42 := checkDerefVar(glojure_DOT_core_concat) - tmp43 := checkDerefVar(glojure_DOT_core_list) + tmp41 := checkDerefVar(var_glojure_DOT_core_seq) + tmp42 := checkDerefVar(var_glojure_DOT_core_concat) + tmp43 := checkDerefVar(var_glojure_DOT_core_list) tmp44 := lang.Apply(tmp43, []any{v20}) - tmp45 := checkDerefVar(glojure_DOT_core_list) - tmp46 := checkDerefVar(glojure_DOT_core_seq) - tmp47 := checkDerefVar(glojure_DOT_core_concat) - tmp48 := checkDerefVar(glojure_DOT_core_list) - tmp49 := lang.Apply(tmp48, []any{lang.NewSymbol("glojure.core/let")}) - tmp50 := checkDerefVar(glojure_DOT_core_list) + tmp45 := checkDerefVar(var_glojure_DOT_core_list) + tmp46 := checkDerefVar(var_glojure_DOT_core_seq) + tmp47 := checkDerefVar(var_glojure_DOT_core_concat) + tmp48 := checkDerefVar(var_glojure_DOT_core_list) + tmp49 := lang.Apply(tmp48, []any{sym_glojure_DOT_core_SLASH_let}) + tmp50 := checkDerefVar(var_glojure_DOT_core_list) tmp51 := lang.Apply(tmp50, []any{v24}) tmp52 := lang.Apply(tmp47, []any{tmp49, tmp51, v4}) tmp53 := lang.Apply(tmp46, []any{tmp52}) @@ -33979,7 +34271,7 @@ func LoadNS() { } return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -33987,21 +34279,17 @@ func LoadNS() { } // maybe-min-hash { - tmp0 := lang.NewSymbol("maybe-min-hash").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("hashes"))), lang.NewKeyword("doc"), "takes a collection of hashes and returns [shift mask] or nil if none found", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6604), lang.NewKeyword("end-line"), int(6604), lang.NewKeyword("private"), true)).(*lang.Symbol) + tmp0 := sym_maybe_DASH_min_DASH_hash.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_hashes)), kw_doc, "takes a collection of hashes and returns [shift mask] or nil if none found", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(8), kw_line, int(6604), kw_end_DASH_line, int(6604), kw_private, true)).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_first) - tmp5 := checkDerefVar(glojure_DOT_core_filter) + tmp4 := checkDerefVar(var_glojure_DOT_core_first) + tmp5 := checkDerefVar(var_glojure_DOT_core_filter) var tmp6 lang.FnFunc tmp6 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v7 := args[0] _ = v7 var tmp8 any @@ -34010,30 +34298,28 @@ func LoadNS() { var v9 any = v7 _ = v9 // let binding "s" - tmp10 := checkDerefVar(glojure_DOT_core_nth) + tmp10 := checkDerefVar(var_glojure_DOT_core_nth) tmp11 := lang.Apply(tmp10, []any{v9, int64(0), nil}) var v12 any = tmp11 _ = v12 // let binding "m" - tmp13 := checkDerefVar(glojure_DOT_core_nth) + tmp13 := checkDerefVar(var_glojure_DOT_core_nth) tmp14 := lang.Apply(tmp13, []any{v9, int64(1), nil}) var v15 any = tmp14 _ = v15 - tmp16 := checkDerefVar(glojure_DOT_core_apply) - tmp17 := checkDerefVar(glojure_DOT_core_distinct_QMARK_) - tmp18 := checkDerefVar(glojure_DOT_core_map) + tmp16 := checkDerefVar(var_glojure_DOT_core_apply) + tmp17 := checkDerefVar(var_glojure_DOT_core_distinct_QMARK_) + tmp18 := checkDerefVar(var_glojure_DOT_core_map) var tmp19 lang.FnFunc tmp19 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v20 := args[0] _ = v20 - tmp21 := checkDerefVar(glojure_DOT_core_shift_mask) + tmp21 := checkDerefVar(var_glojure_DOT_core_shift_DASH_mask) tmp22 := lang.Apply(tmp21, []any{v12, v15, v20}) return tmp22 }) - tmp20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6609), lang.NewKeyword("column"), int(37), lang.NewKeyword("end-line"), int(6609), lang.NewKeyword("end-column"), int(55)) + tmp20 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6609), kw_column, int(37), kw_end_DASH_line, int(6609), kw_end_DASH_column, int(55)) tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) if err != nil { panic(err) @@ -34044,7 +34330,7 @@ func LoadNS() { } // end let return tmp8 }) - tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6608), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(6609), lang.NewKeyword("end-column"), int(65)) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6608), kw_column, int(13), kw_end_DASH_line, int(6609), kw_end_DASH_column, int(65)) tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) if err != nil { panic(err) @@ -34056,16 +34342,12 @@ func LoadNS() { { // function iter__154 var v11 lang.FnFunc tmp10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v12 := args[0] _ = v12 var tmp13 lang.FnFunc tmp13 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var tmp14 any { // let // let binding "s__155" @@ -34075,7 +34357,7 @@ func LoadNS() { var tmp16 any { // let // let binding "temp__0__auto__" - tmp17 := checkDerefVar(glojure_DOT_core_seq) + tmp17 := checkDerefVar(var_glojure_DOT_core_seq) tmp18 := lang.Apply(tmp17, []any{v15}) var v19 any = tmp18 _ = v19 @@ -34089,7 +34371,7 @@ func LoadNS() { var tmp23 any { // let // let binding "mask" - tmp24 := checkDerefVar(glojure_DOT_core_first) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) tmp25 := lang.Apply(tmp24, []any{v22}) var v26 any = tmp25 _ = v26 @@ -34100,16 +34382,12 @@ func LoadNS() { { // function iter__156 var v29 lang.FnFunc tmp28 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v30 := args[0] _ = v30 var tmp31 lang.FnFunc tmp31 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var tmp32 any { // let // let binding "s__157" @@ -34119,7 +34397,7 @@ func LoadNS() { var tmp34 any { // let // let binding "temp__0__auto__" - tmp35 := checkDerefVar(glojure_DOT_core_seq) + tmp35 := checkDerefVar(var_glojure_DOT_core_seq) tmp36 := lang.Apply(tmp35, []any{v33}) var v37 any = tmp36 _ = v37 @@ -34131,25 +34409,25 @@ func LoadNS() { var v40 any = v37 _ = v40 var tmp41 any - tmp42 := checkDerefVar(glojure_DOT_core_chunked_seq_QMARK_) + tmp42 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) tmp43 := lang.Apply(tmp42, []any{v40}) if lang.IsTruthy(tmp43) { var tmp44 any { // let // let binding "c__0__auto__" - tmp45 := checkDerefVar(glojure_DOT_core_chunk_first) + tmp45 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) tmp46 := lang.Apply(tmp45, []any{v40}) var v47 any = tmp46 _ = v47 // let binding "size__1__auto__" - tmp48 := checkDerefVar(glojure_DOT_core_int) - tmp49 := checkDerefVar(glojure_DOT_core_count) + tmp48 := checkDerefVar(var_glojure_DOT_core_int) + tmp49 := checkDerefVar(var_glojure_DOT_core_count) tmp50 := lang.Apply(tmp49, []any{v47}) tmp51 := lang.Apply(tmp48, []any{tmp50}) var v52 any = tmp51 _ = v52 // let binding "b__159" - tmp53 := checkDerefVar(glojure_DOT_core_chunk_buffer) + tmp53 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_buffer) tmp54 := lang.Apply(tmp53, []any{v52}) var v55 any = tmp54 _ = v55 @@ -34157,13 +34435,13 @@ func LoadNS() { var tmp57 any { // let // let binding "i__158" - tmp58 := checkDerefVar(glojure_DOT_core_int) + tmp58 := checkDerefVar(var_glojure_DOT_core_int) tmp59 := lang.Apply(tmp58, []any{int64(0)}) var v60 any = tmp59 _ = v60 for { var tmp61 any - tmp62 := checkDerefVar(glojure_DOT_core__LT_) + tmp62 := checkDerefVar(var_glojure_DOT_core__LT_) tmp63 := lang.Apply(tmp62, []any{v60, v52}) if lang.IsTruthy(tmp63) { var tmp64 any @@ -34176,16 +34454,16 @@ func LoadNS() { tmp66 := lang.Apply(tmp65, []any{v60}) var v67 any = tmp66 _ = v67 - tmp68 := checkDerefVar(glojure_DOT_core_chunk_append) + tmp68 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_append) tmp69 := lang.NewVector(v67, v26) - tmp70 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6612), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(6612), lang.NewKeyword("end-column"), int(26)) + tmp70 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6612), kw_column, int(15), kw_end_DASH_line, int(6612), kw_end_DASH_column, int(26)) tmp71, err := lang.WithMeta(tmp69, tmp70.(lang.IPersistentMap)) if err != nil { panic(err) } tmp72 := lang.Apply(tmp68, []any{v55, tmp71}) _ = tmp72 - tmp74 := checkDerefVar(glojure_DOT_core_unchecked_inc) + tmp74 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) tmp75 := lang.Apply(tmp74, []any{v60}) var tmp73 any = tmp75 v60 = tmp73 @@ -34200,17 +34478,17 @@ func LoadNS() { } } // end let if lang.IsTruthy(tmp57) { - tmp58 := checkDerefVar(glojure_DOT_core_chunk_cons) - tmp59 := checkDerefVar(glojure_DOT_core_chunk) + tmp58 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_cons) + tmp59 := checkDerefVar(var_glojure_DOT_core_chunk) tmp60 := lang.Apply(tmp59, []any{v55}) - tmp61 := checkDerefVar(glojure_DOT_core_chunk_rest) + tmp61 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) tmp62 := lang.Apply(tmp61, []any{v40}) tmp63 := lang.Apply(v29, []any{tmp62}) tmp64 := lang.Apply(tmp58, []any{tmp60, tmp63}) tmp56 = tmp64 } else { - tmp65 := checkDerefVar(glojure_DOT_core_chunk_cons) - tmp66 := checkDerefVar(glojure_DOT_core_chunk) + tmp65 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_cons) + tmp66 := checkDerefVar(var_glojure_DOT_core_chunk) tmp67 := lang.Apply(tmp66, []any{v55}) tmp68 := lang.Apply(tmp65, []any{tmp67, nil}) tmp56 = tmp68 @@ -34222,18 +34500,18 @@ func LoadNS() { var tmp45 any { // let // let binding "shift" - tmp46 := checkDerefVar(glojure_DOT_core_first) + tmp46 := checkDerefVar(var_glojure_DOT_core_first) tmp47 := lang.Apply(tmp46, []any{v40}) var v48 any = tmp47 _ = v48 - tmp49 := checkDerefVar(glojure_DOT_core_cons) + tmp49 := checkDerefVar(var_glojure_DOT_core_cons) tmp50 := lang.NewVector(v48, v26) - tmp51 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6612), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(6612), lang.NewKeyword("end-column"), int(26)) + tmp51 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6612), kw_column, int(15), kw_end_DASH_line, int(6612), kw_end_DASH_column, int(26)) tmp52, err := lang.WithMeta(tmp50, tmp51.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp53 := checkDerefVar(glojure_DOT_core_rest) + tmp53 := checkDerefVar(var_glojure_DOT_core_rest) tmp54 := lang.Apply(tmp53, []any{v40}) tmp55 := lang.Apply(v29, []any{tmp54}) tmp56 := lang.Apply(tmp49, []any{tmp52, tmp55}) @@ -34263,8 +34541,8 @@ func LoadNS() { var v29 any = tmp28 _ = v29 // let binding "fs__1__auto__" - tmp30 := checkDerefVar(glojure_DOT_core_seq) - tmp31 := checkDerefVar(glojure_DOT_core_range) + tmp30 := checkDerefVar(var_glojure_DOT_core_seq) + tmp31 := checkDerefVar(var_glojure_DOT_core_range) tmp32 := lang.Apply(tmp31, []any{int64(0), int64(31)}) tmp33 := lang.Apply(v29, []any{tmp32}) tmp34 := lang.Apply(tmp30, []any{tmp33}) @@ -34272,14 +34550,14 @@ func LoadNS() { _ = v35 var tmp36 any if lang.IsTruthy(v35) { - tmp37 := checkDerefVar(glojure_DOT_core_concat) - tmp38 := checkDerefVar(glojure_DOT_core_rest) + tmp37 := checkDerefVar(var_glojure_DOT_core_concat) + tmp38 := checkDerefVar(var_glojure_DOT_core_rest) tmp39 := lang.Apply(tmp38, []any{v15}) tmp40 := lang.Apply(v11, []any{tmp39}) tmp41 := lang.Apply(tmp37, []any{v35, tmp40}) tmp36 = tmp41 } else { - tmp43 := checkDerefVar(glojure_DOT_core_rest) + tmp43 := checkDerefVar(var_glojure_DOT_core_rest) tmp44 := lang.Apply(tmp43, []any{v15}) var tmp42 any = tmp44 v15 = tmp42 @@ -34310,28 +34588,26 @@ func LoadNS() { } var v11 any = tmp10 _ = v11 - tmp12 := checkDerefVar(glojure_DOT_core_map) + tmp12 := checkDerefVar(var_glojure_DOT_core_map) var tmp13 lang.FnFunc tmp13 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v14 := args[0] _ = v14 - tmp15 := checkDerefVar(glojure_DOT_core_dec) - tmp16 := checkDerefVar(glojure_DOT_core_bit_shift_left) + tmp15 := checkDerefVar(var_glojure_DOT_core_dec) + tmp16 := checkDerefVar(var_glojure_DOT_core_bit_DASH_shift_DASH_left) tmp17 := lang.Apply(tmp16, []any{int64(1), v14}) tmp18 := lang.Apply(tmp15, []any{tmp17}) return tmp18 }) - tmp14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6610), lang.NewKeyword("column"), int(29), lang.NewKeyword("end-line"), int(6610), lang.NewKeyword("end-column"), int(55)) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6610), kw_column, int(29), kw_end_DASH_line, int(6610), kw_end_DASH_column, int(55)) tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp16 := checkDerefVar(glojure_DOT_core_range) - tmp17 := checkDerefVar(glojure_DOT_core_inc) - tmp18 := checkDerefVar(glojure_DOT_core_max_mask_bits) + tmp16 := checkDerefVar(var_glojure_DOT_core_range) + tmp17 := checkDerefVar(var_glojure_DOT_core_inc) + tmp18 := checkDerefVar(var_glojure_DOT_core_max_DASH_mask_DASH_bits) tmp19 := lang.Apply(tmp17, []any{tmp18}) tmp20 := lang.Apply(tmp16, []any{int64(1), tmp19}) tmp21 := lang.Apply(tmp12, []any{tmp15, tmp20}) @@ -34342,7 +34618,7 @@ func LoadNS() { tmp11 := lang.Apply(tmp4, []any{tmp10}) return tmp11 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -34350,14 +34626,12 @@ func LoadNS() { } // memfn { - tmp0 := lang.NewSymbol("memfn").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Expands into code that creates a fn that expects to be passed an\n object and any args and calls the named instance method on the\n object passing the args. Use when you want to treat a Java method as\n a first-class fn. name may be type-hinted with the method receiver's\n type in order to avoid reflective calls.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3872), lang.NewKeyword("end-line"), int(3872))).(*lang.Symbol) + tmp0 := sym_memfn.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym__AMP_, sym_args)), kw_doc, "Expands into code that creates a fn that expects to be passed an\n object and any args and calls the named instance method on the\n object passing the args. Use when you want to treat a Java method as\n a first-class fn. name may be type-hinted with the method receiver's\n type in order to avoid reflective calls.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(11), kw_line, int(3872), kw_end_DASH_line, int(3872))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -34369,40 +34643,40 @@ func LoadNS() { var tmp7 any { // let // let binding "t" - tmp8 := checkDerefVar(glojure_DOT_core_with_meta) - tmp9 := checkDerefVar(glojure_DOT_core_gensym) + tmp8 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp9 := checkDerefVar(var_glojure_DOT_core_gensym) tmp10 := lang.Apply(tmp9, []any{"target"}) - tmp11 := checkDerefVar(glojure_DOT_core_meta) + tmp11 := checkDerefVar(var_glojure_DOT_core_meta) tmp12 := lang.Apply(tmp11, []any{v5}) tmp13 := lang.Apply(tmp8, []any{tmp10, tmp12}) var v14 any = tmp13 _ = v14 - tmp15 := checkDerefVar(glojure_DOT_core_seq) - tmp16 := checkDerefVar(glojure_DOT_core_concat) - tmp17 := checkDerefVar(glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("glojure.core/fn")}) - tmp19 := checkDerefVar(glojure_DOT_core_list) - tmp20 := checkDerefVar(glojure_DOT_core_apply) - tmp21 := checkDerefVar(glojure_DOT_core_vector) - tmp22 := checkDerefVar(glojure_DOT_core_seq) - tmp23 := checkDerefVar(glojure_DOT_core_concat) - tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_glojure_DOT_core_SLASH_fn}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_apply) + tmp21 := checkDerefVar(var_glojure_DOT_core_vector) + tmp22 := checkDerefVar(var_glojure_DOT_core_seq) + tmp23 := checkDerefVar(var_glojure_DOT_core_concat) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) tmp25 := lang.Apply(tmp24, []any{v14}) tmp26 := lang.Apply(tmp23, []any{tmp25, v6}) tmp27 := lang.Apply(tmp22, []any{tmp26}) tmp28 := lang.Apply(tmp20, []any{tmp21, tmp27}) tmp29 := lang.Apply(tmp19, []any{tmp28}) - tmp30 := checkDerefVar(glojure_DOT_core_list) - tmp31 := checkDerefVar(glojure_DOT_core_seq) - tmp32 := checkDerefVar(glojure_DOT_core_concat) - tmp33 := checkDerefVar(glojure_DOT_core_list) - tmp34 := lang.Apply(tmp33, []any{lang.NewSymbol(".")}) - tmp35 := checkDerefVar(glojure_DOT_core_list) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := checkDerefVar(var_glojure_DOT_core_seq) + tmp32 := checkDerefVar(var_glojure_DOT_core_concat) + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{sym__DOT_}) + tmp35 := checkDerefVar(var_glojure_DOT_core_list) tmp36 := lang.Apply(tmp35, []any{v14}) - tmp37 := checkDerefVar(glojure_DOT_core_list) - tmp38 := checkDerefVar(glojure_DOT_core_seq) - tmp39 := checkDerefVar(glojure_DOT_core_concat) - tmp40 := checkDerefVar(glojure_DOT_core_list) + tmp37 := checkDerefVar(var_glojure_DOT_core_list) + tmp38 := checkDerefVar(var_glojure_DOT_core_seq) + tmp39 := checkDerefVar(var_glojure_DOT_core_concat) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) tmp41 := lang.Apply(tmp40, []any{v5}) tmp42 := lang.Apply(tmp39, []any{tmp41, v6}) tmp43 := lang.Apply(tmp38, []any{tmp42}) @@ -34417,7 +34691,7 @@ func LoadNS() { return tmp7 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -34425,20 +34699,18 @@ func LoadNS() { } // memoize { - tmp0 := lang.NewSymbol("memoize").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Returns a memoized version of a referentially transparent function. The\n memoized version of the function keeps a cache of the mapping from arguments\n to results and, when calls with the same arguments are repeated often, has\n higher performance at the expense of higher memory use.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6337), lang.NewKeyword("end-line"), int(6337))).(*lang.Symbol) + tmp0 := sym_memoize.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f)), kw_doc, "Returns a memoized version of a referentially transparent function. The\n memoized version of the function keeps a cache of the mapping from arguments\n to results and, when calls with the same arguments are repeated often, has\n higher performance at the expense of higher memory use.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(6337), kw_end_DASH_line, int(6337))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any { // let // let binding "mem" - tmp5 := checkDerefVar(glojure_DOT_core_atom) + tmp5 := checkDerefVar(var_glojure_DOT_core_atom) tmp6 := lang.NewMap() - tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6345), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(6345), lang.NewKeyword("end-column"), int(20)) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6345), kw_column, int(19), kw_end_DASH_line, int(6345), kw_end_DASH_column, int(20)) tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) if err != nil { panic(err) @@ -34450,16 +34722,14 @@ func LoadNS() { tmp11 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var v12 any = lang.NewList(args[0:]...) _ = v12 var tmp13 any { // let // let binding "temp__0__auto__" - tmp14 := checkDerefVar(glojure_DOT_core_find) - tmp15 := checkDerefVar(glojure_DOT_core_deref) + tmp14 := checkDerefVar(var_glojure_DOT_core_find) + tmp15 := checkDerefVar(var_glojure_DOT_core_deref) tmp16 := lang.Apply(tmp15, []any{v10}) tmp17 := lang.Apply(tmp14, []any{tmp16, v12}) var v18 any = tmp17 @@ -34471,7 +34741,7 @@ func LoadNS() { // let binding "e" var v21 any = v18 _ = v21 - tmp22 := checkDerefVar(glojure_DOT_core_val) + tmp22 := checkDerefVar(var_glojure_DOT_core_val) tmp23 := lang.Apply(tmp22, []any{v21}) tmp20 = tmp23 } // end let @@ -34480,12 +34750,12 @@ func LoadNS() { var tmp21 any { // let // let binding "ret" - tmp22 := checkDerefVar(glojure_DOT_core_apply) + tmp22 := checkDerefVar(var_glojure_DOT_core_apply) tmp23 := lang.Apply(tmp22, []any{v3, v12}) var v24 any = tmp23 _ = v24 - tmp25 := checkDerefVar(glojure_DOT_core_swap_BANG_) - tmp26 := checkDerefVar(glojure_DOT_core_assoc) + tmp25 := checkDerefVar(var_glojure_DOT_core_swap_BANG_) + tmp26 := checkDerefVar(var_glojure_DOT_core_assoc) tmp27 := lang.Apply(tmp25, []any{v10, tmp26, v12, v24}) _ = tmp27 tmp21 = v24 @@ -34497,7 +34767,7 @@ func LoadNS() { return tmp13 } }) - tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6346), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(6351), lang.NewKeyword("end-column"), int(16)) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6346), kw_column, int(5), kw_end_DASH_line, int(6351), kw_end_DASH_column, int(16)) tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) if err != nil { panic(err) @@ -34506,7 +34776,7 @@ func LoadNS() { } // end let return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -34514,32 +34784,28 @@ func LoadNS() { } // merge { - tmp0 := lang.NewSymbol("merge").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("maps"))), lang.NewKeyword("doc"), "Returns a map that consists of the rest of the maps conj-ed onto\n the first. If a key occurs in more than one map, the mapping from\n the latter (left-to-right) will be the mapping in the result.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3040), lang.NewKeyword("end-line"), int(3040))).(*lang.Symbol) + tmp0 := sym_merge.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_maps)), kw_doc, "Returns a map that consists of the rest of the maps conj-ed onto\n the first. If a key occurs in more than one map, the mapping from\n the latter (left-to-right) will be the mapping in the result.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3040), kw_end_DASH_line, int(3040))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 var tmp4 any - tmp5 := checkDerefVar(glojure_DOT_core_some) - tmp6 := checkDerefVar(glojure_DOT_core_identity) + tmp5 := checkDerefVar(var_glojure_DOT_core_some) + tmp6 := checkDerefVar(var_glojure_DOT_core_identity) tmp7 := lang.Apply(tmp5, []any{tmp6, v3}) if lang.IsTruthy(tmp7) { - tmp8 := checkDerefVar(glojure_DOT_core_reduce1) + tmp8 := checkDerefVar(var_glojure_DOT_core_reduce1) var tmp9 lang.FnFunc tmp9 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v10 := args[0] _ = v10 v11 := args[1] _ = v11 - tmp12 := checkDerefVar(glojure_DOT_core_conj) + tmp12 := checkDerefVar(var_glojure_DOT_core_conj) var tmp13 any { // let // let binding "or__0__auto__" @@ -34550,7 +34816,7 @@ func LoadNS() { tmp15 = v14 } else { tmp16 := lang.NewMap() - tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3048), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(3048), lang.NewKeyword("end-column"), int(29)) + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3048), kw_column, int(28), kw_end_DASH_line, int(3048), kw_end_DASH_column, int(29)) tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) if err != nil { panic(err) @@ -34562,7 +34828,7 @@ func LoadNS() { tmp14 := lang.Apply(tmp12, []any{tmp13, v11}) return tmp14 }) - tmp10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3048), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(3048), lang.NewKeyword("end-column"), int(34)) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3048), kw_column, int(14), kw_end_DASH_line, int(3048), kw_end_DASH_column, int(34)) tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) if err != nil { panic(err) @@ -34574,7 +34840,7 @@ func LoadNS() { return tmp4 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -34582,12 +34848,10 @@ func LoadNS() { } // merge-hash-collisions { - tmp0 := lang.NewSymbol("merge-hash-collisions").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr-sym"), lang.NewSymbol("default"), lang.NewSymbol("tests"), lang.NewSymbol("thens"))), lang.NewKeyword("doc"), "Takes a case expression, default expression, and a sequence of test constants\n and a corresponding sequence of then expressions. Returns a tuple of\n [tests thens skip-check-set] where no tests have the same hash. Each set of\n input test constants with the same hash is replaced with a single test\n constant (the case int), and their respective thens are combined into:\n (condp = expr\n test-1 then-1\n ...\n test-n then-n\n default).\n The skip-check is a set of case ints for which post-switch equivalence\n checking must not be done (the cases holding the above condp thens).", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6647), lang.NewKeyword("end-line"), int(6647), lang.NewKeyword("private"), true)).(*lang.Symbol) + tmp0 := sym_merge_DASH_hash_DASH_collisions.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_expr_DASH_sym, sym_default, sym_tests, sym_thens)), kw_doc, "Takes a case expression, default expression, and a sequence of test constants\n and a corresponding sequence of then expressions. Returns a tuple of\n [tests thens skip-check-set] where no tests have the same hash. Each set of\n input test constants with the same hash is replaced with a single test\n constant (the case int), and their respective thens are combined into:\n (condp = expr\n test-1 then-1\n ...\n test-n then-n\n default).\n The skip-check is a set of case ints for which post-switch equivalence\n checking must not be done (the cases holding the above condp thens).", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(28), kw_column, int(8), kw_line, int(6647), kw_end_DASH_line, int(6647), kw_private, true)).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 4) v3 := args[0] _ = v3 v4 := args[1] @@ -34603,7 +34867,7 @@ func LoadNS() { { // let // let binding "m" tmp9 := lang.NewMap() - tmp10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6661), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(6661), lang.NewKeyword("end-column"), int(27)) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6661), kw_column, int(26), kw_end_DASH_line, int(6661), kw_end_DASH_column, int(27)) tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) if err != nil { panic(err) @@ -34632,35 +34896,35 @@ func LoadNS() { tmp16 = tmp18 } // end let if lang.IsTruthy(tmp16) { - tmp18 := checkDerefVar(glojure_DOT_core_update) - tmp19 := checkDerefVar(glojure_DOT_core_first) + tmp18 := checkDerefVar(var_glojure_DOT_core_update) + tmp19 := checkDerefVar(var_glojure_DOT_core_first) tmp20 := lang.Apply(tmp19, []any{v13}) tmp21 := lang.Apply(lang.Hash, []any{tmp20}) - tmp22 := checkDerefVar(glojure_DOT_core_fnil) - tmp23 := checkDerefVar(glojure_DOT_core_conj) + tmp22 := checkDerefVar(var_glojure_DOT_core_fnil) + tmp23 := checkDerefVar(var_glojure_DOT_core_conj) tmp24 := lang.NewVector() - tmp25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6664), lang.NewKeyword("column"), int(102), lang.NewKeyword("end-line"), int(6664), lang.NewKeyword("end-column"), int(103)) + tmp25 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6664), kw_column, int(102), kw_end_DASH_line, int(6664), kw_end_DASH_column, int(103)) tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) if err != nil { panic(err) } tmp27 := lang.Apply(tmp22, []any{tmp23, tmp26}) - tmp28 := checkDerefVar(glojure_DOT_core_first) + tmp28 := checkDerefVar(var_glojure_DOT_core_first) tmp29 := lang.Apply(tmp28, []any{v13}) - tmp30 := checkDerefVar(glojure_DOT_core_first) + tmp30 := checkDerefVar(var_glojure_DOT_core_first) tmp31 := lang.Apply(tmp30, []any{v14}) tmp32 := lang.NewVector(tmp29, tmp31) - tmp33 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6664), lang.NewKeyword("column"), int(106), lang.NewKeyword("end-line"), int(6664), lang.NewKeyword("end-column"), int(128)) + tmp33 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6664), kw_column, int(106), kw_end_DASH_line, int(6664), kw_end_DASH_column, int(128)) tmp34, err := lang.WithMeta(tmp32, tmp33.(lang.IPersistentMap)) if err != nil { panic(err) } tmp35 := lang.Apply(tmp18, []any{v12, tmp21, tmp27, tmp34}) var tmp17 any = tmp35 - tmp37 := checkDerefVar(glojure_DOT_core_next) + tmp37 := checkDerefVar(var_glojure_DOT_core_next) tmp38 := lang.Apply(tmp37, []any{v13}) var tmp36 any = tmp38 - tmp40 := checkDerefVar(glojure_DOT_core_next) + tmp40 := checkDerefVar(var_glojure_DOT_core_next) tmp41 := lang.Apply(tmp40, []any{v14}) var tmp39 any = tmp41 v12 = tmp17 @@ -34679,9 +34943,7 @@ func LoadNS() { // let binding "assoc-multi" var tmp10 lang.FnFunc tmp10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v11 := args[0] _ = v11 v12 := args[1] @@ -34691,29 +34953,27 @@ func LoadNS() { var tmp14 any { // let // let binding "testexprs" - tmp15 := checkDerefVar(glojure_DOT_core_mapcat) + tmp15 := checkDerefVar(var_glojure_DOT_core_mapcat) var tmp16 lang.FnFunc tmp16 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v17 := args[0] _ = v17 - tmp18 := checkDerefVar(glojure_DOT_core_list) - tmp19 := checkDerefVar(glojure_DOT_core_first) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := checkDerefVar(var_glojure_DOT_core_first) tmp20 := lang.Apply(tmp19, []any{v17}) - tmp21 := lang.Apply(tmp18, []any{lang.NewSymbol("quote"), tmp20}) - tmp22 := checkDerefVar(glojure_DOT_core_second) + tmp21 := lang.Apply(tmp18, []any{sym_quote, tmp20}) + tmp22 := checkDerefVar(var_glojure_DOT_core_second) tmp23 := lang.Apply(tmp22, []any{v17}) tmp24 := lang.NewVector(tmp21, tmp23) - tmp25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6668), lang.NewKeyword("column"), int(56), lang.NewKeyword("end-line"), int(6668), lang.NewKeyword("end-column"), int(93)) + tmp25 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6668), kw_column, int(56), kw_end_DASH_line, int(6668), kw_end_DASH_column, int(93)) tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) if err != nil { panic(err) } return tmp26 }) - tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6668), lang.NewKeyword("column"), int(47), lang.NewKeyword("end-line"), int(6668), lang.NewKeyword("end-column"), int(94)) + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6668), kw_column, int(47), kw_end_DASH_line, int(6668), kw_end_DASH_column, int(94)) tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) if err != nil { panic(err) @@ -34722,27 +34982,27 @@ func LoadNS() { var v20 any = tmp19 _ = v20 // let binding "expr" - tmp21 := checkDerefVar(glojure_DOT_core_seq) - tmp22 := checkDerefVar(glojure_DOT_core_concat) - tmp23 := checkDerefVar(glojure_DOT_core_list) - tmp24 := lang.Apply(tmp23, []any{lang.NewSymbol("glojure.core/condp")}) - tmp25 := checkDerefVar(glojure_DOT_core_list) - tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol("glojure.core/=")}) - tmp27 := checkDerefVar(glojure_DOT_core_list) + tmp21 := checkDerefVar(var_glojure_DOT_core_seq) + tmp22 := checkDerefVar(var_glojure_DOT_core_concat) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := lang.Apply(tmp23, []any{sym_glojure_DOT_core_SLASH_condp}) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := lang.Apply(tmp25, []any{sym_glojure_DOT_core_SLASH__EQ_}) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) tmp28 := lang.Apply(tmp27, []any{v3}) - tmp29 := checkDerefVar(glojure_DOT_core_list) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) tmp30 := lang.Apply(tmp29, []any{v4}) tmp31 := lang.Apply(tmp22, []any{tmp24, tmp26, tmp28, v20, tmp30}) tmp32 := lang.Apply(tmp21, []any{tmp31}) var v33 any = tmp32 _ = v33 - tmp34 := checkDerefVar(glojure_DOT_core_assoc) + tmp34 := checkDerefVar(var_glojure_DOT_core_assoc) tmp35 := lang.Apply(tmp34, []any{v11, v12, v33}) tmp14 = tmp35 } // end let return tmp14 }) - tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6667), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(6670), lang.NewKeyword("end-column"), int(42)) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6667), kw_column, int(21), kw_end_DASH_line, int(6670), kw_end_DASH_column, int(42)) tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) if err != nil { panic(err) @@ -34750,12 +35010,10 @@ func LoadNS() { var v13 any = tmp12 _ = v13 // let binding "hmap" - tmp14 := checkDerefVar(glojure_DOT_core_reduce1) + tmp14 := checkDerefVar(var_glojure_DOT_core_reduce1) var tmp15 lang.FnFunc tmp15 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v16 := args[0] _ = v16 v17 := args[1] @@ -34766,26 +35024,26 @@ func LoadNS() { var v19 any = v17 _ = v19 // let binding "h" - tmp20 := checkDerefVar(glojure_DOT_core_nth) + tmp20 := checkDerefVar(var_glojure_DOT_core_nth) tmp21 := lang.Apply(tmp20, []any{v19, int64(0), nil}) var v22 any = tmp21 _ = v22 // let binding "bucket" - tmp23 := checkDerefVar(glojure_DOT_core_nth) + tmp23 := checkDerefVar(var_glojure_DOT_core_nth) tmp24 := lang.Apply(tmp23, []any{v19, int64(1), nil}) var v25 any = tmp24 _ = v25 var tmp26 any - tmp27 := checkDerefVar(glojure_DOT_core__EQ__EQ_) - tmp28 := checkDerefVar(glojure_DOT_core_count) + tmp27 := checkDerefVar(var_glojure_DOT_core__EQ__EQ_) + tmp28 := checkDerefVar(var_glojure_DOT_core_count) tmp29 := lang.Apply(tmp28, []any{v25}) tmp30 := lang.Apply(tmp27, []any{int64(1), tmp29}) if lang.IsTruthy(tmp30) { - tmp31 := checkDerefVar(glojure_DOT_core_assoc) - tmp32 := checkDerefVar(glojure_DOT_core_ffirst) + tmp31 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp32 := checkDerefVar(var_glojure_DOT_core_ffirst) tmp33 := lang.Apply(tmp32, []any{v25}) - tmp34 := checkDerefVar(glojure_DOT_core_second) - tmp35 := checkDerefVar(glojure_DOT_core_first) + tmp34 := checkDerefVar(var_glojure_DOT_core_second) + tmp35 := checkDerefVar(var_glojure_DOT_core_first) tmp36 := lang.Apply(tmp35, []any{v25}) tmp37 := lang.Apply(tmp34, []any{tmp36}) tmp38 := lang.Apply(tmp31, []any{v16, tmp33, tmp37}) @@ -34798,13 +35056,13 @@ func LoadNS() { } // end let return tmp18 }) - tmp16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6672), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(6675), lang.NewKeyword("end-column"), int(45)) + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6672), kw_column, int(16), kw_end_DASH_line, int(6675), kw_end_DASH_column, int(45)) tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) if err != nil { panic(err) } tmp18 := lang.NewMap() - tmp19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6676), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(6676), lang.NewKeyword("end-column"), int(17)) + tmp19 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6676), kw_column, int(16), kw_end_DASH_line, int(6676), kw_end_DASH_column, int(17)) tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) if err != nil { panic(err) @@ -34813,32 +35071,30 @@ func LoadNS() { var v22 any = tmp21 _ = v22 // let binding "skip-check" - tmp23 := checkDerefVar(glojure_DOT_core_into1) + tmp23 := checkDerefVar(var_glojure_DOT_core_into1) tmp24 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) - tmp25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6680), lang.NewKeyword("column"), int(29), lang.NewKeyword("end-line"), int(6680), lang.NewKeyword("end-column"), int(31)) + tmp25 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6680), kw_column, int(29), kw_end_DASH_line, int(6680), kw_end_DASH_column, int(31)) tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp27 := checkDerefVar(glojure_DOT_core_map) - tmp28 := checkDerefVar(glojure_DOT_core_first) - tmp29 := checkDerefVar(glojure_DOT_core_filter) + tmp27 := checkDerefVar(var_glojure_DOT_core_map) + tmp28 := checkDerefVar(var_glojure_DOT_core_first) + tmp29 := checkDerefVar(var_glojure_DOT_core_filter) var tmp30 lang.FnFunc tmp30 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v31 := args[0] _ = v31 - tmp32 := checkDerefVar(glojure_DOT_core__LT_) - tmp33 := checkDerefVar(glojure_DOT_core_count) - tmp34 := checkDerefVar(glojure_DOT_core_second) + tmp32 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp33 := checkDerefVar(var_glojure_DOT_core_count) + tmp34 := checkDerefVar(var_glojure_DOT_core_second) tmp35 := lang.Apply(tmp34, []any{v31}) tmp36 := lang.Apply(tmp33, []any{tmp35}) tmp37 := lang.Apply(tmp32, []any{int64(1), tmp36}) return tmp37 }) - tmp31 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6678), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(6678), lang.NewKeyword("end-column"), int(54)) + tmp31 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6678), kw_column, int(30), kw_end_DASH_line, int(6678), kw_end_DASH_column, int(54)) tmp32, err := lang.WithMeta(tmp30, tmp31.(lang.IPersistentMap)) if err != nil { panic(err) @@ -34848,12 +35104,12 @@ func LoadNS() { tmp35 := lang.Apply(tmp23, []any{tmp26, tmp34}) var v36 any = tmp35 _ = v36 - tmp37 := checkDerefVar(glojure_DOT_core_keys) + tmp37 := checkDerefVar(var_glojure_DOT_core_keys) tmp38 := lang.Apply(tmp37, []any{v22}) - tmp39 := checkDerefVar(glojure_DOT_core_vals) + tmp39 := checkDerefVar(var_glojure_DOT_core_vals) tmp40 := lang.Apply(tmp39, []any{v22}) tmp41 := lang.NewVector(tmp38, tmp40, v36) - tmp42 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6681), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(6681), lang.NewKeyword("end-column"), int(40)) + tmp42 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6681), kw_column, int(5), kw_end_DASH_line, int(6681), kw_end_DASH_column, int(40)) tmp43, err := lang.WithMeta(tmp41, tmp42.(lang.IPersistentMap)) if err != nil { panic(err) @@ -34862,7 +35118,7 @@ func LoadNS() { } // end let return tmp7 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -34870,21 +35126,19 @@ func LoadNS() { } // merge-with { - tmp0 := lang.NewSymbol("merge-with").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("maps"))), lang.NewKeyword("doc"), "Returns a map that consists of the rest of the maps conj-ed onto\n the first. If a key occurs in more than one map, the mapping(s)\n from the latter (left-to-right) will be combined with the mapping in\n the result by calling (f val-in-result val-in-latter).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3050), lang.NewKeyword("end-line"), int(3050))).(*lang.Symbol) + tmp0 := sym_merge_DASH_with.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym__AMP_, sym_maps)), kw_doc, "Returns a map that consists of the rest of the maps conj-ed onto\n the first. If a key occurs in more than one map, the mapping(s)\n from the latter (left-to-right) will be combined with the mapping in\n the result by calling (f val-in-result val-in-latter).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(3050), kw_end_DASH_line, int(3050))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var v4 any = lang.NewList(args[1:]...) _ = v4 var tmp5 any - tmp6 := checkDerefVar(glojure_DOT_core_some) - tmp7 := checkDerefVar(glojure_DOT_core_identity) + tmp6 := checkDerefVar(var_glojure_DOT_core_some) + tmp7 := checkDerefVar(var_glojure_DOT_core_identity) tmp8 := lang.Apply(tmp6, []any{tmp7, v4}) if lang.IsTruthy(tmp8) { var tmp9 any @@ -34892,9 +35146,7 @@ func LoadNS() { // let binding "merge-entry" var tmp10 lang.FnFunc tmp10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v11 := args[0] _ = v11 v12 := args[1] @@ -34902,27 +35154,27 @@ func LoadNS() { var tmp13 any { // let // let binding "k" - tmp14 := checkDerefVar(glojure_DOT_core_key) + tmp14 := checkDerefVar(var_glojure_DOT_core_key) tmp15 := lang.Apply(tmp14, []any{v12}) var v16 any = tmp15 _ = v16 // let binding "v" - tmp17 := checkDerefVar(glojure_DOT_core_val) + tmp17 := checkDerefVar(var_glojure_DOT_core_val) tmp18 := lang.Apply(tmp17, []any{v12}) var v19 any = tmp18 _ = v19 var tmp20 any - tmp21 := checkDerefVar(glojure_DOT_core_contains_QMARK_) + tmp21 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) tmp22 := lang.Apply(tmp21, []any{v11, v16}) if lang.IsTruthy(tmp22) { - tmp23 := checkDerefVar(glojure_DOT_core_assoc) - tmp24 := checkDerefVar(glojure_DOT_core_get) + tmp23 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp24 := checkDerefVar(var_glojure_DOT_core_get) tmp25 := lang.Apply(tmp24, []any{v11, v16}) tmp26 := lang.Apply(v3, []any{tmp25, v19}) tmp27 := lang.Apply(tmp23, []any{v11, v16, tmp26}) tmp20 = tmp27 } else { - tmp28 := checkDerefVar(glojure_DOT_core_assoc) + tmp28 := checkDerefVar(var_glojure_DOT_core_assoc) tmp29 := lang.Apply(tmp28, []any{v11, v16, v19}) tmp20 = tmp29 } @@ -34930,7 +35182,7 @@ func LoadNS() { } // end let return tmp13 }) - tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3059), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(3063), lang.NewKeyword("end-column"), int(23)) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3059), kw_column, int(23), kw_end_DASH_line, int(3063), kw_end_DASH_column, int(23)) tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) if err != nil { panic(err) @@ -34940,14 +35192,12 @@ func LoadNS() { // let binding "merge2" var tmp14 lang.FnFunc tmp14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v15 := args[0] _ = v15 v16 := args[1] _ = v16 - tmp17 := checkDerefVar(glojure_DOT_core_reduce1) + tmp17 := checkDerefVar(var_glojure_DOT_core_reduce1) var tmp18 any { // let // let binding "or__0__auto__" @@ -34958,7 +35208,7 @@ func LoadNS() { tmp20 = v19 } else { tmp21 := lang.NewMap() - tmp22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3065), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(3065), lang.NewKeyword("end-column"), int(35)) + tmp22 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3065), kw_column, int(34), kw_end_DASH_line, int(3065), kw_end_DASH_column, int(35)) tmp23, err := lang.WithMeta(tmp21, tmp22.(lang.IPersistentMap)) if err != nil { panic(err) @@ -34967,19 +35217,19 @@ func LoadNS() { } tmp18 = tmp20 } // end let - tmp19 := checkDerefVar(glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_seq) tmp20 := lang.Apply(tmp19, []any{v16}) tmp21 := lang.Apply(tmp17, []any{v13, tmp18, tmp20}) return tmp21 }) - tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3064), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(3065), lang.NewKeyword("end-column"), int(47)) + tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3064), kw_column, int(18), kw_end_DASH_line, int(3065), kw_end_DASH_column, int(47)) tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) if err != nil { panic(err) } var v17 any = tmp16 _ = v17 - tmp18 := checkDerefVar(glojure_DOT_core_reduce1) + tmp18 := checkDerefVar(var_glojure_DOT_core_reduce1) tmp19 := lang.Apply(tmp18, []any{v17, v4}) tmp9 = tmp19 } // end let @@ -34989,7 +35239,7 @@ func LoadNS() { return tmp5 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -34997,18 +35247,16 @@ func LoadNS() { } // meta { - tmp0 := lang.NewSymbol("meta").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("obj"))), lang.NewKeyword("doc"), "Returns the metadata of obj, returns nil if there is no metadata.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(202), lang.NewKeyword("end-line"), int(206))).(*lang.Symbol) + tmp0 := sym_meta.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_obj)), kw_doc, "Returns the metadata of obj, returns nil if there is no metadata.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(5), kw_column, int(2), kw_line, int(202), kw_end_DASH_line, int(206))).(*lang.Symbol) var tmp2 lang.FnFunc { // function meta var v3 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 var tmp5 any - tmp6 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp6 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp7 := reflect.TypeOf((*lang.IMeta)(nil)).Elem() tmp8 := lang.Apply(tmp6, []any{tmp7, v4}) if lang.IsTruthy(tmp8) { @@ -35028,7 +35276,7 @@ func LoadNS() { } return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(206), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(208), lang.NewKeyword("end-column"), int(21))).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(206), kw_column, int(7), kw_end_DASH_line, int(208), kw_end_DASH_column, int(21))).(lang.FnFunc) v3 = tmp2 _ = v3 } @@ -35039,12 +35287,10 @@ func LoadNS() { } // methods { - tmp0 := lang.NewSymbol("methods").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"))), lang.NewKeyword("doc"), "Given a multimethod, returns a map of dispatch values -> dispatch fns", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1809), lang.NewKeyword("end-line"), int(1809))).(*lang.Symbol) + tmp0 := sym_methods.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_multifn)), kw_doc, "Given a multimethod, returns a map of dispatch values -> dispatch fns", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(1809), kw_end_DASH_line, int(1809))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4, ok := lang.FieldOrMethod(v3, "getMethodTable") @@ -35060,7 +35306,7 @@ func LoadNS() { } return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -35078,7 +35324,7 @@ func LoadNS() { { // let // let binding "op" var tmp4 any - tmp5 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp5) { tmp4 = closed34 } else { @@ -35086,18 +35332,18 @@ func LoadNS() { } var v6 any = tmp4 _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_seq) - tmp8 := checkDerefVar(glojure_DOT_core_concat) - tmp9 := checkDerefVar(glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol(".")}) - tmp11 := checkDerefVar(glojure_DOT_core_list) - tmp12 := lang.Apply(tmp11, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp13 := checkDerefVar(glojure_DOT_core_list) - tmp14 := checkDerefVar(glojure_DOT_core_seq) - tmp15 := checkDerefVar(glojure_DOT_core_concat) - tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v6}) - tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) tmp19 := lang.Apply(tmp18, []any{v2}) tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) tmp21 := lang.Apply(tmp14, []any{tmp20}) @@ -35116,7 +35362,7 @@ func LoadNS() { { // let // let binding "op" var tmp5 any - tmp6 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp6) { tmp5 = closed34 } else { @@ -35124,20 +35370,20 @@ func LoadNS() { } var v7 any = tmp5 _ = v7 - tmp8 := checkDerefVar(glojure_DOT_core_seq) - tmp9 := checkDerefVar(glojure_DOT_core_concat) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol(".")}) - tmp12 := checkDerefVar(glojure_DOT_core_list) - tmp13 := lang.Apply(tmp12, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp14 := checkDerefVar(glojure_DOT_core_list) - tmp15 := checkDerefVar(glojure_DOT_core_seq) - tmp16 := checkDerefVar(glojure_DOT_core_concat) - tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) tmp18 := lang.Apply(tmp17, []any{v7}) - tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) tmp20 := lang.Apply(tmp19, []any{v2}) - tmp21 := checkDerefVar(glojure_DOT_core_list) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) tmp22 := lang.Apply(tmp21, []any{v3}) tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) tmp24 := lang.Apply(tmp15, []any{tmp23}) @@ -35148,9 +35394,7 @@ func LoadNS() { } // end let return tmp4 default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -35161,7 +35405,7 @@ func LoadNS() { { // let // let binding "op" var tmp6 any - tmp7 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp7) { tmp6 = closed34 } else { @@ -35169,30 +35413,28 @@ func LoadNS() { } var v8 any = tmp6 _ = v8 - tmp9 := checkDerefVar(glojure_DOT_core_reduce1) + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) var tmp10 lang.FnFunc tmp10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v11 := args[0] _ = v11 v12 := args[1] _ = v12 - tmp13 := checkDerefVar(glojure_DOT_core_seq) - tmp14 := checkDerefVar(glojure_DOT_core_concat) - tmp15 := checkDerefVar(glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) - tmp17 := checkDerefVar(glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp19 := checkDerefVar(glojure_DOT_core_list) - tmp20 := checkDerefVar(glojure_DOT_core_seq) - tmp21 := checkDerefVar(glojure_DOT_core_concat) - tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) tmp23 := lang.Apply(tmp22, []any{v8}) - tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) tmp25 := lang.Apply(tmp24, []any{v11}) - tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) tmp27 := lang.Apply(tmp26, []any{v12}) tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) tmp29 := lang.Apply(tmp20, []any{tmp28}) @@ -35201,25 +35443,25 @@ func LoadNS() { tmp32 := lang.Apply(tmp13, []any{tmp31}) return tmp32 }) - tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp13 := checkDerefVar(glojure_DOT_core_seq) - tmp14 := checkDerefVar(glojure_DOT_core_concat) - tmp15 := checkDerefVar(glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol(".")}) - tmp17 := checkDerefVar(glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp19 := checkDerefVar(glojure_DOT_core_list) - tmp20 := checkDerefVar(glojure_DOT_core_seq) - tmp21 := checkDerefVar(glojure_DOT_core_concat) - tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) tmp23 := lang.Apply(tmp22, []any{v8}) - tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) tmp25 := lang.Apply(tmp24, []any{v2}) - tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) tmp27 := lang.Apply(tmp26, []any{v3}) tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) tmp29 := lang.Apply(tmp20, []any{tmp28}) @@ -35232,12 +35474,10 @@ func LoadNS() { return tmp5 } }) - tmp1 = tmp1.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86))).(lang.FnFunc) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") @@ -35247,8 +35487,8 @@ func LoadNS() { tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) - tmp0 := lang.NewSymbol("min").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the least of the nums.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), tmp2, lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1118), lang.NewKeyword("end-line"), int(1118))).(*lang.Symbol) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym_min.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns the least of the nums.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(1118), kw_end_DASH_line, int(1118))).(*lang.Symbol) var tmp4 lang.FnFunc tmp4 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -35268,24 +35508,22 @@ func LoadNS() { tmp8 := lang.Apply(tmp7, []any{v5, v6}) return tmp8 default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v5 := args[0] _ = v5 v6 := args[1] _ = v6 var v7 any = lang.NewList(args[2:]...) _ = v7 - tmp8 := checkDerefVar(glojure_DOT_core_reduce1) - tmp9 := checkDerefVar(glojure_DOT_core_min) - tmp10 := checkDerefVar(glojure_DOT_core_min) + tmp8 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp9 := checkDerefVar(var_glojure_DOT_core_min) + tmp10 := checkDerefVar(var_glojure_DOT_core_min) tmp11 := lang.Apply(tmp10, []any{v5, v6}) tmp12 := lang.Apply(tmp8, []any{tmp9, tmp11, v7}) return tmp12 } }) - tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp4 = tmp4.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp3 := ns.InternWithValue(tmp0, tmp4, true) if tmp0.Meta() != nil { tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -35293,7 +35531,7 @@ func LoadNS() { } // min-key { - tmp0 := lang.NewSymbol("min-key").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("k"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Returns the x for which (k x), a number, is least.\n\n If there are multiple such xs, the last one is returned.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5033), lang.NewKeyword("end-line"), int(5033))).(*lang.Symbol) + tmp0 := sym_min_DASH_key.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_k, sym_x), lang.NewVector(sym_k, sym_x, sym_y), lang.NewVector(sym_k, sym_x, sym_y, sym__AMP_, sym_more)), kw_doc, "Returns the x for which (k x), a number, is least.\n\n If there are multiple such xs, the last one is returned.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(5033), kw_end_DASH_line, int(5033))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -35311,7 +35549,7 @@ func LoadNS() { v5 := args[2] _ = v5 var tmp6 any - tmp7 := checkDerefVar(glojure_DOT_core__LT_) + tmp7 := checkDerefVar(var_glojure_DOT_core__LT_) tmp8 := lang.Apply(v3, []any{v4}) tmp9 := lang.Apply(v3, []any{v5}) tmp10 := lang.Apply(tmp7, []any{tmp8, tmp9}) @@ -35322,9 +35560,7 @@ func LoadNS() { } return tmp6 default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -35345,11 +35581,11 @@ func LoadNS() { _ = v11 // let binding "vec__58" var tmp12 any - tmp13 := checkDerefVar(glojure_DOT_core__LT_) + tmp13 := checkDerefVar(var_glojure_DOT_core__LT_) tmp14 := lang.Apply(tmp13, []any{v9, v11}) if lang.IsTruthy(tmp14) { tmp15 := lang.NewVector(v4, v9) - tmp16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5043), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(5043), lang.NewKeyword("end-column"), int(36)) + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5043), kw_column, int(31), kw_end_DASH_line, int(5043), kw_end_DASH_column, int(36)) tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) if err != nil { panic(err) @@ -35357,7 +35593,7 @@ func LoadNS() { tmp12 = tmp17 } else { tmp18 := lang.NewVector(v5, v11) - tmp19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5043), lang.NewKeyword("column"), int(38), lang.NewKeyword("end-line"), int(5043), lang.NewKeyword("end-column"), int(43)) + tmp19 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5043), kw_column, int(38), kw_end_DASH_line, int(5043), kw_end_DASH_column, int(43)) tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) if err != nil { panic(err) @@ -35367,12 +35603,12 @@ func LoadNS() { var v21 any = tmp12 _ = v21 // let binding "v" - tmp22 := checkDerefVar(glojure_DOT_core_nth) + tmp22 := checkDerefVar(var_glojure_DOT_core_nth) tmp23 := lang.Apply(tmp22, []any{v21, int64(0), nil}) var v24 any = tmp23 _ = v24 // let binding "kv" - tmp25 := checkDerefVar(glojure_DOT_core_nth) + tmp25 := checkDerefVar(var_glojure_DOT_core_nth) tmp26 := lang.Apply(tmp25, []any{v21, int64(1), nil}) var v27 any = tmp26 _ = v27 @@ -35393,7 +35629,7 @@ func LoadNS() { var tmp33 any { // let // let binding "w" - tmp34 := checkDerefVar(glojure_DOT_core_first) + tmp34 := checkDerefVar(var_glojure_DOT_core_first) tmp35 := lang.Apply(tmp34, []any{v31}) var v36 any = tmp35 _ = v36 @@ -35402,12 +35638,12 @@ func LoadNS() { var v38 any = tmp37 _ = v38 var tmp39 any - tmp40 := checkDerefVar(glojure_DOT_core__LT__EQ_) + tmp40 := checkDerefVar(var_glojure_DOT_core__LT__EQ_) tmp41 := lang.Apply(tmp40, []any{v38, v30}) if lang.IsTruthy(tmp41) { var tmp42 any = v36 var tmp43 any = v38 - tmp45 := checkDerefVar(glojure_DOT_core_next) + tmp45 := checkDerefVar(var_glojure_DOT_core_next) tmp46 := lang.Apply(tmp45, []any{v31}) var tmp44 any = tmp46 v29 = tmp42 @@ -35417,7 +35653,7 @@ func LoadNS() { } else { var tmp47 any = v29 var tmp48 any = v30 - tmp50 := checkDerefVar(glojure_DOT_core_next) + tmp50 := checkDerefVar(var_glojure_DOT_core_next) tmp51 := lang.Apply(tmp50, []any{v31}) var tmp49 any = tmp51 v29 = tmp47 @@ -35440,7 +35676,7 @@ func LoadNS() { return tmp7 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -35448,12 +35684,10 @@ func LoadNS() { } // mix-collection-hash { - tmp0 := lang.NewSymbol("mix-collection-hash").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("hash-basis"), lang.NewSymbol("count"))), lang.NewKeyword("doc"), "Mix final collection hash for ordered or unordered collections.\n hash-basis is the combined collection hash, count is the number\n of elements included in the basis. Note this is the hash code\n consistent with =, different from .hashCode.\n See http://glojure.org/data_structures#hash for full algorithms.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5199), lang.NewKeyword("end-line"), int(5199))).(*lang.Symbol) + tmp0 := sym_mix_DASH_collection_DASH_hash.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_hash_DASH_basis, sym_count)), kw_doc, "Mix final collection hash for ordered or unordered collections.\n hash-basis is the combined collection hash, count is the number\n of elements included in the basis. Note this is the hash code\n consistent with =, different from .hashCode.\n See http://glojure.org/data_structures#hash for full algorithms.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.6", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(25), kw_column, int(7), kw_line, int(5199), kw_end_DASH_line, int(5199))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -35461,7 +35695,7 @@ func LoadNS() { tmp5 := lang.Apply(nil, []any{v3, v4}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -35469,12 +35703,10 @@ func LoadNS() { } // mk-bound-fn { - tmp0 := lang.NewSymbol("mk-bound-fn").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5127), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(5127), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sc"), lang.NewSymbol("test"), lang.NewSymbol("key"))), lang.NewKeyword("private"), true, lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym_mk_DASH_bound_DASH_fn.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5127), kw_column, int(7), kw_end_DASH_line, int(5127), kw_end_DASH_column, int(17), kw_arglists, lang.NewList(lang.NewVector(sym_sc, sym_test, sym_key)), kw_private, true, kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -35483,9 +35715,7 @@ func LoadNS() { _ = v5 var tmp6 lang.FnFunc tmp6 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v7 := args[0] _ = v7 tmp8, ok := lang.FieldOrMethod(v3, "comparator") @@ -35512,14 +35742,14 @@ func LoadNS() { tmp14 := lang.Apply(v4, []any{tmp13, int64(0)}) return tmp14 }) - tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5130), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(5131), lang.NewKeyword("end-column"), int(64)) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5130), kw_column, int(3), kw_end_DASH_line, int(5131), kw_end_DASH_column, int(64)) tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) if err != nil { panic(err) } return tmp8 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -35527,12 +35757,10 @@ func LoadNS() { } // mod { - tmp0 := lang.NewSymbol("mod").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"), lang.NewSymbol("div"))), lang.NewKeyword("doc"), "Modulus of num and div. Truncates toward negative infinity.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3567), lang.NewKeyword("end-line"), int(3567))).(*lang.Symbol) + tmp0 := sym_mod.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_num, sym_div)), kw_doc, "Modulus of num and div. Truncates toward negative infinity.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(3567), kw_end_DASH_line, int(3567))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -35540,7 +35768,7 @@ func LoadNS() { var tmp5 any { // let // let binding "m" - tmp6 := checkDerefVar(glojure_DOT_core_rem) + tmp6 := checkDerefVar(var_glojure_DOT_core_rem) tmp7 := lang.Apply(tmp6, []any{v3, v4}) var v8 any = tmp7 _ = v8 @@ -35548,7 +35776,7 @@ func LoadNS() { var tmp10 any { // let // let binding "or__0__auto__" - tmp11 := checkDerefVar(glojure_DOT_core_zero_QMARK_) + tmp11 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) tmp12 := lang.Apply(tmp11, []any{v8}) var v13 any = tmp12 _ = v13 @@ -35556,10 +35784,10 @@ func LoadNS() { if lang.IsTruthy(v13) { tmp14 = v13 } else { - tmp15 := checkDerefVar(glojure_DOT_core__EQ_) - tmp16 := checkDerefVar(glojure_DOT_core_pos_QMARK_) + tmp15 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp16 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) tmp17 := lang.Apply(tmp16, []any{v3}) - tmp18 := checkDerefVar(glojure_DOT_core_pos_QMARK_) + tmp18 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) tmp19 := lang.Apply(tmp18, []any{v4}) tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) tmp14 = tmp20 @@ -35569,7 +35797,7 @@ func LoadNS() { if lang.IsTruthy(tmp10) { tmp9 = v8 } else { - tmp11 := checkDerefVar(glojure_DOT_core__PLUS_) + tmp11 := checkDerefVar(var_glojure_DOT_core__PLUS_) tmp12 := lang.Apply(tmp11, []any{v8, v4}) tmp9 = tmp12 } @@ -35577,7 +35805,7 @@ func LoadNS() { } // end let return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -35586,16 +35814,14 @@ func LoadNS() { // name { tmp1 := reflect.TypeOf("") - tmp0 := lang.NewSymbol("name").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns the name String of a string, symbol or keyword.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1585), lang.NewKeyword("end-line"), int(1585))).(*lang.Symbol) + tmp0 := sym_name.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns the name String of a string, symbol or keyword.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1585), kw_end_DASH_line, int(1585))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 var tmp5 any - tmp6 := checkDerefVar(glojure_DOT_core_string_QMARK_) + tmp6 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) tmp7 := lang.Apply(tmp6, []any{v4}) if lang.IsTruthy(tmp7) { tmp5 = v4 @@ -35610,7 +35836,7 @@ func LoadNS() { return tmp5 }) tmp4 := reflect.TypeOf("") - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -35619,12 +35845,10 @@ func LoadNS() { // namespace { tmp1 := reflect.TypeOf("") - tmp0 := lang.NewSymbol("namespace").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns the namespace String of a symbol or keyword, or nil if not present.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1593), lang.NewKeyword("end-line"), int(1593))).(*lang.Symbol) + tmp0 := sym_namespace.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns the namespace String of a symbol or keyword, or nil if not present.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(1593), kw_end_DASH_line, int(1593))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 tmp5, _ := lang.FieldOrMethod(v4, "Namespace") @@ -35635,7 +35859,7 @@ func LoadNS() { return tmp6 }) tmp4 := reflect.TypeOf("") - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -35643,14 +35867,14 @@ func LoadNS() { } // nary-inline { - tmp0 := lang.NewSymbol("nary-inline").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(948), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(948), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("op")), lang.NewVector(lang.NewSymbol("op"), lang.NewSymbol("unchecked-op"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym_nary_DASH_inline.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(948), kw_column, int(7), kw_end_DASH_line, int(948), kw_end_DASH_column, int(27), kw_arglists, lang.NewList(lang.NewVector(sym_op), lang.NewVector(sym_op, sym_unchecked_DASH_op)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_nary_inline) + tmp4 := checkDerefVar(var_glojure_DOT_core_nary_DASH_inline) tmp5 := lang.Apply(tmp4, []any{v3, v3}) return tmp5 case 2: @@ -35668,7 +35892,7 @@ func LoadNS() { { // let // let binding "op" var tmp8 any - tmp9 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + tmp9 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp9) { tmp8 = v4 } else { @@ -35676,18 +35900,18 @@ func LoadNS() { } var v10 any = tmp8 _ = v10 - tmp11 := checkDerefVar(glojure_DOT_core_seq) - tmp12 := checkDerefVar(glojure_DOT_core_concat) - tmp13 := checkDerefVar(glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol(".")}) - tmp15 := checkDerefVar(glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp17 := checkDerefVar(glojure_DOT_core_list) - tmp18 := checkDerefVar(glojure_DOT_core_seq) - tmp19 := checkDerefVar(glojure_DOT_core_concat) - tmp20 := checkDerefVar(glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym__DOT_}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) tmp21 := lang.Apply(tmp20, []any{v10}) - tmp22 := checkDerefVar(glojure_DOT_core_list) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) tmp23 := lang.Apply(tmp22, []any{v6}) tmp24 := lang.Apply(tmp19, []any{tmp21, tmp23}) tmp25 := lang.Apply(tmp18, []any{tmp24}) @@ -35706,7 +35930,7 @@ func LoadNS() { { // let // let binding "op" var tmp9 any - tmp10 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + tmp10 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp10) { tmp9 = v4 } else { @@ -35714,20 +35938,20 @@ func LoadNS() { } var v11 any = tmp9 _ = v11 - tmp12 := checkDerefVar(glojure_DOT_core_seq) - tmp13 := checkDerefVar(glojure_DOT_core_concat) - tmp14 := checkDerefVar(glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol(".")}) - tmp16 := checkDerefVar(glojure_DOT_core_list) - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp18 := checkDerefVar(glojure_DOT_core_list) - tmp19 := checkDerefVar(glojure_DOT_core_seq) - tmp20 := checkDerefVar(glojure_DOT_core_concat) - tmp21 := checkDerefVar(glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym__DOT_}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := checkDerefVar(var_glojure_DOT_core_seq) + tmp20 := checkDerefVar(var_glojure_DOT_core_concat) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) tmp22 := lang.Apply(tmp21, []any{v11}) - tmp23 := checkDerefVar(glojure_DOT_core_list) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) tmp24 := lang.Apply(tmp23, []any{v6}) - tmp25 := checkDerefVar(glojure_DOT_core_list) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) tmp26 := lang.Apply(tmp25, []any{v7}) tmp27 := lang.Apply(tmp20, []any{tmp22, tmp24, tmp26}) tmp28 := lang.Apply(tmp19, []any{tmp27}) @@ -35738,9 +35962,7 @@ func LoadNS() { } // end let return tmp8 default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v6 := args[0] _ = v6 v7 := args[1] @@ -35751,7 +35973,7 @@ func LoadNS() { { // let // let binding "op" var tmp10 any - tmp11 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + tmp11 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp11) { tmp10 = v4 } else { @@ -35759,30 +35981,28 @@ func LoadNS() { } var v12 any = tmp10 _ = v12 - tmp13 := checkDerefVar(glojure_DOT_core_reduce1) + tmp13 := checkDerefVar(var_glojure_DOT_core_reduce1) var tmp14 lang.FnFunc tmp14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v15 := args[0] _ = v15 v16 := args[1] _ = v16 - tmp17 := checkDerefVar(glojure_DOT_core_seq) - tmp18 := checkDerefVar(glojure_DOT_core_concat) - tmp19 := checkDerefVar(glojure_DOT_core_list) - tmp20 := lang.Apply(tmp19, []any{lang.NewSymbol(".")}) - tmp21 := checkDerefVar(glojure_DOT_core_list) - tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp23 := checkDerefVar(glojure_DOT_core_list) - tmp24 := checkDerefVar(glojure_DOT_core_seq) - tmp25 := checkDerefVar(glojure_DOT_core_concat) - tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp17 := checkDerefVar(var_glojure_DOT_core_seq) + tmp18 := checkDerefVar(var_glojure_DOT_core_concat) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{sym__DOT_}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_seq) + tmp25 := checkDerefVar(var_glojure_DOT_core_concat) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) tmp27 := lang.Apply(tmp26, []any{v12}) - tmp28 := checkDerefVar(glojure_DOT_core_list) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) tmp29 := lang.Apply(tmp28, []any{v15}) - tmp30 := checkDerefVar(glojure_DOT_core_list) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) tmp31 := lang.Apply(tmp30, []any{v16}) tmp32 := lang.Apply(tmp25, []any{tmp27, tmp29, tmp31}) tmp33 := lang.Apply(tmp24, []any{tmp32}) @@ -35791,25 +36011,25 @@ func LoadNS() { tmp36 := lang.Apply(tmp17, []any{tmp35}) return tmp36 }) - tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(959), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(959), lang.NewKeyword("end-column"), int(88)) + tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp17 := checkDerefVar(glojure_DOT_core_seq) - tmp18 := checkDerefVar(glojure_DOT_core_concat) - tmp19 := checkDerefVar(glojure_DOT_core_list) - tmp20 := lang.Apply(tmp19, []any{lang.NewSymbol(".")}) - tmp21 := checkDerefVar(glojure_DOT_core_list) - tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp23 := checkDerefVar(glojure_DOT_core_list) - tmp24 := checkDerefVar(glojure_DOT_core_seq) - tmp25 := checkDerefVar(glojure_DOT_core_concat) - tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp17 := checkDerefVar(var_glojure_DOT_core_seq) + tmp18 := checkDerefVar(var_glojure_DOT_core_concat) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{sym__DOT_}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_seq) + tmp25 := checkDerefVar(var_glojure_DOT_core_concat) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) tmp27 := lang.Apply(tmp26, []any{v12}) - tmp28 := checkDerefVar(glojure_DOT_core_list) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) tmp29 := lang.Apply(tmp28, []any{v6}) - tmp30 := checkDerefVar(glojure_DOT_core_list) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) tmp31 := lang.Apply(tmp30, []any{v7}) tmp32 := lang.Apply(tmp25, []any{tmp27, tmp29, tmp31}) tmp33 := lang.Apply(tmp24, []any{tmp32}) @@ -35822,17 +36042,18 @@ func LoadNS() { return tmp9 } }) - tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(951), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(960), lang.NewKeyword("end-column"), int(86)) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86)) tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) if err != nil { panic(err) } return tmp7 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -35840,25 +36061,23 @@ func LoadNS() { } // nat-int? { - tmp0 := lang.NewSymbol("nat-int?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a non-negative fixed precision integer", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1415), lang.NewKeyword("end-line"), int(1415))).(*lang.Symbol) + tmp0 := sym_nat_DASH_int_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a non-negative fixed precision integer", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(1415), kw_end_DASH_line, int(1415))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any { // let // let binding "and__0__auto__" - tmp5 := checkDerefVar(glojure_DOT_core_int_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) tmp6 := lang.Apply(tmp5, []any{v3}) var v7 any = tmp6 _ = v7 var tmp8 any if lang.IsTruthy(v7) { - tmp9 := checkDerefVar(glojure_DOT_core_not) - tmp10 := checkDerefVar(glojure_DOT_core_neg_QMARK_) + tmp9 := checkDerefVar(var_glojure_DOT_core_not) + tmp10 := checkDerefVar(var_glojure_DOT_core_neg_QMARK_) tmp11 := lang.Apply(tmp10, []any{v3}) tmp12 := lang.Apply(tmp9, []any{tmp11}) tmp8 = tmp12 @@ -35869,7 +36088,7 @@ func LoadNS() { } // end let return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -35877,24 +36096,22 @@ func LoadNS() { } // neg-int? { - tmp0 := lang.NewSymbol("neg-int?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a negative fixed precision integer", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1409), lang.NewKeyword("end-line"), int(1409))).(*lang.Symbol) + tmp0 := sym_neg_DASH_int_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a negative fixed precision integer", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(1409), kw_end_DASH_line, int(1409))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any { // let // let binding "and__0__auto__" - tmp5 := checkDerefVar(glojure_DOT_core_int_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) tmp6 := lang.Apply(tmp5, []any{v3}) var v7 any = tmp6 _ = v7 var tmp8 any if lang.IsTruthy(v7) { - tmp9 := checkDerefVar(glojure_DOT_core_neg_QMARK_) + tmp9 := checkDerefVar(var_glojure_DOT_core_neg_QMARK_) tmp10 := lang.Apply(tmp9, []any{v3}) tmp8 = tmp10 } else { @@ -35904,7 +36121,7 @@ func LoadNS() { } // end let return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -35916,23 +36133,21 @@ func LoadNS() { { // function neg?__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) - tmp5 := checkDerefVar(glojure_DOT_core_concat) - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := checkDerefVar(glojure_DOT_core_seq) - tmp12 := checkDerefVar(glojure_DOT_core_concat) - tmp13 := checkDerefVar(glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/IsNeg")}) - tmp15 := checkDerefVar(glojure_DOT_core_list) + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_IsNeg}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) tmp18 := lang.Apply(tmp11, []any{tmp17}) @@ -35944,12 +36159,10 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("neg?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns true if num is less than zero, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1259), lang.NewKeyword("end-line"), int(1259))).(*lang.Symbol) + tmp0 := sym_neg_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_num)), kw_inline, tmp1, kw_doc, "Returns true if num is less than zero, else false", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1259), kw_end_DASH_line, int(1259))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 tmp5, _ := lang.FieldOrMethod(lang.Numbers, "IsNeg") @@ -35959,7 +36172,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v4}) return tmp6 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -35967,19 +36180,17 @@ func LoadNS() { } // newline { - tmp0 := lang.NewSymbol("newline").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Writes a platform-specific newline to *out*", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3698), lang.NewKeyword("end-line"), int(3698))).(*lang.Symbol) + tmp0 := sym_newline.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Writes a platform-specific newline to *out*", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(3698), kw_end_DASH_line, int(3698))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - tmp3 := checkDerefVar(glojure_DOT_core__STAR_out_STAR_) - tmp4 := checkDerefVar(glojure_DOT_core_system_newline) + checkArity(args, 0) + tmp3 := checkDerefVar(var_glojure_DOT_core__STAR_out_STAR_) + tmp4 := checkDerefVar(var_glojure_DOT_core_system_DASH_newline) tmp5 := lang.Apply(lang.AppendWriter, []any{tmp3, tmp4}) _ = tmp5 return nil }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -35988,20 +36199,18 @@ func LoadNS() { // next { tmp1 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() - tmp0 := lang.NewSymbol("next").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a seq of the items after the first. Calls seq on its\n argument. If there are no more items, returns nil.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(55), lang.NewKeyword("end-line"), int(61))).(*lang.Symbol) + tmp0 := sym_next.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a seq of the items after the first. Calls seq on its\n argument. If there are no more items, returns nil.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(5), kw_column, int(2), kw_line, int(55), kw_end_DASH_line, int(61))).(*lang.Symbol) var tmp3 lang.FnFunc { // function next var v4 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v5 := args[0] _ = v5 tmp6 := lang.Apply(lang.Next, []any{v5}) return tmp6 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(61), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(61), lang.NewKeyword("end-column"), int(77))).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(61), kw_column, int(7), kw_end_DASH_line, int(61), kw_end_DASH_column, int(77))).(lang.FnFunc) v4 = tmp3 _ = v4 } @@ -36012,23 +36221,21 @@ func LoadNS() { } // nfirst { - tmp0 := lang.NewSymbol("nfirst").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Same as (next (first x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(105), lang.NewKeyword("end-line"), int(109))).(*lang.Symbol) + tmp0 := sym_nfirst.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Same as (next (first x))", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(2), kw_line, int(105), kw_end_DASH_line, int(109))).(*lang.Symbol) var tmp2 lang.FnFunc { // function nfirst var v3 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_next) - tmp6 := checkDerefVar(glojure_DOT_core_first) + tmp5 := checkDerefVar(var_glojure_DOT_core_next) + tmp6 := checkDerefVar(var_glojure_DOT_core_first) tmp7 := lang.Apply(tmp6, []any{v4}) tmp8 := lang.Apply(tmp5, []any{tmp7}) return tmp8 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(109), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(109), lang.NewKeyword("end-column"), int(49))).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(109), kw_column, int(9), kw_end_DASH_line, int(109), kw_end_DASH_column, int(49))).(lang.FnFunc) v3 = tmp2 _ = v3 } @@ -36044,31 +36251,27 @@ func LoadNS() { { // function nil?__inliner var v3 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_list) - tmp6 := lang.Apply(tmp5, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Identical"), v4, nil}) + tmp5 := checkDerefVar(var_glojure_DOT_core_list) + tmp6 := lang.Apply(tmp5, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Identical, v4, nil}) return tmp6 }) v3 = tmp2 _ = v3 } - tmp0 := lang.NewSymbol("nil?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp2, lang.NewKeyword("doc"), "Returns true if x is nil, false otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(435), lang.NewKeyword("end-line"), int(435))).(*lang.Symbol) + tmp0 := sym_nil_QMARK_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp2, kw_doc, "Returns true if x is nil, false otherwise.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(435), kw_end_DASH_line, int(435))).(*lang.Symbol) var tmp4 lang.FnFunc tmp4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v5 := args[0] _ = v5 tmp6 := lang.Apply(lang.IsNil, []any{v5}) return tmp6 }) tmp5 := reflect.TypeOf(false) - tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp5)).(lang.FnFunc) + tmp4 = tmp4.WithMeta(lang.NewMap(kw_rettag, tmp5)).(lang.FnFunc) tmp3 := ns.InternWithValue(tmp0, tmp4, true) if tmp0.Meta() != nil { tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -36076,23 +36279,21 @@ func LoadNS() { } // nnext { - tmp0 := lang.NewSymbol("nnext").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Same as (next (next x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(6), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(119), lang.NewKeyword("end-line"), int(123))).(*lang.Symbol) + tmp0 := sym_nnext.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Same as (next (next x))", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(6), kw_column, int(2), kw_line, int(119), kw_end_DASH_line, int(123))).(*lang.Symbol) var tmp2 lang.FnFunc { // function nnext var v3 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_next) - tmp6 := checkDerefVar(glojure_DOT_core_next) + tmp5 := checkDerefVar(var_glojure_DOT_core_next) + tmp6 := checkDerefVar(var_glojure_DOT_core_next) tmp7 := lang.Apply(tmp6, []any{v4}) tmp8 := lang.Apply(tmp5, []any{tmp7}) return tmp8 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(123), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(123), lang.NewKeyword("end-column"), int(46))).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(123), kw_column, int(8), kw_end_DASH_line, int(123), kw_end_DASH_column, int(46))).(lang.FnFunc) v3 = tmp2 _ = v3 } @@ -36103,27 +36304,25 @@ func LoadNS() { } // normalize-slurp-opts { - tmp0 := lang.NewSymbol("normalize-slurp-opts").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6974), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(6974), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("opts"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym_normalize_DASH_slurp_DASH_opts.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6974), kw_column, int(8), kw_end_DASH_line, int(6974), kw_end_DASH_column, int(27), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_opts)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any - tmp5 := checkDerefVar(glojure_DOT_core_string_QMARK_) - tmp6 := checkDerefVar(glojure_DOT_core_first) + tmp5 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp6 := checkDerefVar(var_glojure_DOT_core_first) tmp7 := lang.Apply(tmp6, []any{v3}) tmp8 := lang.Apply(tmp5, []any{tmp7}) if lang.IsTruthy(tmp8) { - tmp9 := checkDerefVar(glojure_DOT_core_println) + tmp9 := checkDerefVar(var_glojure_DOT_core_println) tmp10 := lang.Apply(tmp9, []any{"WARNING: (slurp f enc) is deprecated, use (slurp f :encoding enc)."}) _ = tmp10 - tmp11 := checkDerefVar(glojure_DOT_core_first) + tmp11 := checkDerefVar(var_glojure_DOT_core_first) tmp12 := lang.Apply(tmp11, []any{v3}) - tmp13 := lang.NewVector(lang.NewKeyword("encoding"), tmp12) - tmp14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6979), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(6979), lang.NewKeyword("end-column"), int(30)) + tmp13 := lang.NewVector(kw_encoding, tmp12) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6979), kw_column, int(7), kw_end_DASH_line, int(6979), kw_end_DASH_column, int(30)) tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) if err != nil { panic(err) @@ -36134,7 +36333,7 @@ func LoadNS() { } return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -36143,12 +36342,10 @@ func LoadNS() { // not { tmp1 := reflect.TypeOf(false) - tmp0 := lang.NewSymbol("not").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is logical false, false otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(523), lang.NewKeyword("end-line"), int(523))).(*lang.Symbol) + tmp0 := sym_not.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x is logical false, false otherwise.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(523), kw_end_DASH_line, int(523))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 var tmp5 any @@ -36160,7 +36357,7 @@ func LoadNS() { return tmp5 }) tmp4 := reflect.TypeOf(false) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -36169,7 +36366,7 @@ func LoadNS() { // not-any? { tmp1 := reflect.TypeOf(false) - tmp0 := lang.NewSymbol("not-any?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns false if (pred x) is logical true for any x in coll,\n else true.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(2696), lang.NewKeyword("end-line"), int(2701))).(*lang.Symbol) + tmp0 := sym_not_DASH_any_QMARK_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns false if (pred x) is logical true for any x in coll,\n else true.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(2), kw_line, int(2696), kw_end_DASH_line, int(2701))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -36202,9 +36399,7 @@ func LoadNS() { tmp8 := lang.Apply(closed35, []any{tmp7}) return tmp8 default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v4 := args[0] _ = v4 v5 := args[1] @@ -36213,13 +36408,13 @@ func LoadNS() { _ = v6 var v7 any = lang.NewList(args[3:]...) _ = v7 - tmp8 := checkDerefVar(glojure_DOT_core_apply) + tmp8 := checkDerefVar(var_glojure_DOT_core_apply) tmp9 := lang.Apply(tmp8, []any{closed36, v4, v5, v6, v7}) tmp10 := lang.Apply(closed35, []any{tmp9}) return tmp10 } }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2559), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2564), lang.NewKeyword("end-column"), int(49))).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2559), kw_column, int(6), kw_end_DASH_line, int(2564), kw_end_DASH_column, int(49))).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -36227,16 +36422,14 @@ func LoadNS() { } // not-empty { - tmp0 := lang.NewSymbol("not-empty").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "If coll is empty, returns nil, else coll", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5516), lang.NewKeyword("end-line"), int(5516))).(*lang.Symbol) + tmp0 := sym_not_DASH_empty.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "If coll is empty, returns nil, else coll", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(5516), kw_end_DASH_line, int(5516))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any - tmp5 := checkDerefVar(glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) tmp6 := lang.Apply(tmp5, []any{v3}) if lang.IsTruthy(tmp6) { tmp4 = v3 @@ -36244,7 +36437,7 @@ func LoadNS() { } return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -36253,7 +36446,7 @@ func LoadNS() { // not-every? { tmp1 := reflect.TypeOf(false) - tmp0 := lang.NewSymbol("not-every?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns false if (pred x) is logical true for every x in\n coll, else true.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(2677), lang.NewKeyword("end-line"), int(2682))).(*lang.Symbol) + tmp0 := sym_not_DASH_every_QMARK_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns false if (pred x) is logical true for every x in\n coll, else true.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(2), kw_line, int(2677), kw_end_DASH_line, int(2682))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -36286,9 +36479,7 @@ func LoadNS() { tmp8 := lang.Apply(closed35, []any{tmp7}) return tmp8 default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v4 := args[0] _ = v4 v5 := args[1] @@ -36297,13 +36488,13 @@ func LoadNS() { _ = v6 var v7 any = lang.NewList(args[3:]...) _ = v7 - tmp8 := checkDerefVar(glojure_DOT_core_apply) + tmp8 := checkDerefVar(var_glojure_DOT_core_apply) tmp9 := lang.Apply(tmp8, []any{closed37, v4, v5, v6, v7}) tmp10 := lang.Apply(closed35, []any{tmp9}) return tmp10 } }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2559), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2564), lang.NewKeyword("end-column"), int(49))).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2559), kw_column, int(6), kw_end_DASH_line, int(2564), kw_end_DASH_column, int(49))).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -36312,7 +36503,7 @@ func LoadNS() { // not= { tmp1 := reflect.TypeOf(false) - tmp0 := lang.NewSymbol("not=").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Same as (not (= obj1 obj2))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(812), lang.NewKeyword("end-line"), int(812))).(*lang.Symbol) + tmp0 := sym_not_EQ_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_doc, "Same as (not (= obj1 obj2))", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(812), kw_end_DASH_line, int(812))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -36325,31 +36516,29 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6 := checkDerefVar(glojure_DOT_core_not) - tmp7 := checkDerefVar(glojure_DOT_core__EQ_) + tmp6 := checkDerefVar(var_glojure_DOT_core_not) + tmp7 := checkDerefVar(var_glojure_DOT_core__EQ_) tmp8 := lang.Apply(tmp7, []any{v4, v5}) tmp9 := lang.Apply(tmp6, []any{tmp8}) return tmp9 default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v4 := args[0] _ = v4 v5 := args[1] _ = v5 var v6 any = lang.NewList(args[2:]...) _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_not) - tmp8 := checkDerefVar(glojure_DOT_core_apply) - tmp9 := checkDerefVar(glojure_DOT_core__EQ_) + tmp7 := checkDerefVar(var_glojure_DOT_core_not) + tmp8 := checkDerefVar(var_glojure_DOT_core_apply) + tmp9 := checkDerefVar(var_glojure_DOT_core__EQ_) tmp10 := lang.Apply(tmp8, []any{tmp9, v4, v5, v6}) tmp11 := lang.Apply(tmp7, []any{tmp10}) return tmp11 } }) tmp4 := reflect.TypeOf(false) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -36357,14 +36546,12 @@ func LoadNS() { } // ns { - tmp0 := lang.NewSymbol("ns").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name"), lang.NewSymbol("docstring?"), lang.NewSymbol("attr-map?"), lang.NewSymbol("references*"))), lang.NewKeyword("doc"), "Sets *ns* to the namespace named by name (unevaluated), creating it\n if needed. references can be zero or more of: (:refer-glojure ...)\n (:require ...) (:use ...) (:import ...) (:load ...) (:gen-class)\n with the syntax of refer-glojure/require/use/import/load/gen-class\n respectively, except the arguments are unevaluated and need not be\n quoted. (:gen-class ...), when supplied, defaults to :name\n corresponding to the ns name, :main true, :impl-ns same as ns, and\n :init-impl-ns true. All options of gen-class are\n supported. The :gen-class directive is ignored when not\n compiling. If :gen-class is not supplied, when compiled only an\n nsname__init.class will be generated. If :refer-glojure is not used, a\n default (refer 'glojure.core) is used. Use of ns is preferred to\n individual calls to in-ns/require/use/import:\n\n (ns foo.bar\n (:refer-glojure :exclude [ancestors printf])\n (:require (glojure.contrib sql combinatorics))\n (:use (my.lib this that))\n (:import (java.util Date Timer Random)\n (java.sql Connection Statement)))", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5742), lang.NewKeyword("end-line"), int(5742))).(*lang.Symbol) + tmp0 := sym_ns.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym_docstring_QMARK_, sym_attr_DASH_map_QMARK_, sym_references_STAR_)), kw_doc, "Sets *ns* to the namespace named by name (unevaluated), creating it\n if needed. references can be zero or more of: (:refer-glojure ...)\n (:require ...) (:use ...) (:import ...) (:load ...) (:gen-class)\n with the syntax of refer-glojure/require/use/import/load/gen-class\n respectively, except the arguments are unevaluated and need not be\n quoted. (:gen-class ...), when supplied, defaults to :name\n corresponding to the ns name, :main true, :impl-ns same as ns, and\n :init-impl-ns true. All options of gen-class are\n supported. The :gen-class directive is ignored when not\n compiling. If :gen-class is not supplied, when compiled only an\n nsname__init.class will be generated. If :refer-glojure is not used, a\n default (refer 'glojure.core) is used. Use of ns is preferred to\n individual calls to in-ns/require/use/import:\n\n (ns foo.bar\n (:refer-glojure :exclude [ancestors printf])\n (:require (glojure.contrib sql combinatorics))\n (:use (my.lib this that))\n (:import (java.util Date Timer Random)\n (java.sql Connection Statement)))", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(11), kw_line, int(5742), kw_end_DASH_line, int(5742))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -36378,9 +36565,7 @@ func LoadNS() { // let binding "process-reference" var tmp8 lang.FnFunc tmp8 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v9 := args[0] _ = v9 var tmp10 any @@ -36389,17 +36574,17 @@ func LoadNS() { var v11 any = v9 _ = v11 // let binding "seq__108" - tmp12 := checkDerefVar(glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := lang.Apply(tmp12, []any{v11}) var v14 any = tmp13 _ = v14 // let binding "first__109" - tmp15 := checkDerefVar(glojure_DOT_core_first) + tmp15 := checkDerefVar(var_glojure_DOT_core_first) tmp16 := lang.Apply(tmp15, []any{v14}) var v17 any = tmp16 _ = v17 // let binding "seq__108" - tmp18 := checkDerefVar(glojure_DOT_core_next) + tmp18 := checkDerefVar(var_glojure_DOT_core_next) tmp19 := lang.Apply(tmp18, []any{v14}) var v20 any = tmp19 _ = v20 @@ -36409,27 +36594,25 @@ func LoadNS() { // let binding "args" var v22 any = v20 _ = v22 - tmp23 := checkDerefVar(glojure_DOT_core_seq) - tmp24 := checkDerefVar(glojure_DOT_core_concat) - tmp25 := checkDerefVar(glojure_DOT_core_list) - tmp26 := checkDerefVar(glojure_DOT_core_symbol) - tmp27 := checkDerefVar(glojure_DOT_core_name) + tmp23 := checkDerefVar(var_glojure_DOT_core_seq) + tmp24 := checkDerefVar(var_glojure_DOT_core_concat) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := checkDerefVar(var_glojure_DOT_core_symbol) + tmp27 := checkDerefVar(var_glojure_DOT_core_name) tmp28 := lang.Apply(tmp27, []any{v21}) tmp29 := lang.Apply(tmp26, []any{"glojure.core", tmp28}) tmp30 := lang.Apply(tmp25, []any{tmp29}) - tmp31 := checkDerefVar(glojure_DOT_core_map) + tmp31 := checkDerefVar(var_glojure_DOT_core_map) var tmp32 lang.FnFunc tmp32 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v33 := args[0] _ = v33 - tmp34 := checkDerefVar(glojure_DOT_core_list) - tmp35 := lang.Apply(tmp34, []any{lang.NewSymbol("quote"), v33}) + tmp34 := checkDerefVar(var_glojure_DOT_core_list) + tmp35 := lang.Apply(tmp34, []any{sym_quote, v33}) return tmp35 }) - tmp33 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5769), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(5769), lang.NewKeyword("end-column"), int(36)) + tmp33 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5769), kw_column, int(21), kw_end_DASH_line, int(5769), kw_end_DASH_column, int(36)) tmp34, err := lang.WithMeta(tmp32, tmp33.(lang.IPersistentMap)) if err != nil { panic(err) @@ -36441,7 +36624,7 @@ func LoadNS() { } // end let return tmp10 }) - tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5767), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(5769), lang.NewKeyword("end-column"), int(44)) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5767), kw_column, int(9), kw_end_DASH_line, int(5769), kw_end_DASH_column, int(44)) tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) if err != nil { panic(err) @@ -36450,12 +36633,12 @@ func LoadNS() { _ = v11 // let binding "docstring" var tmp12 any - tmp13 := checkDerefVar(glojure_DOT_core_string_QMARK_) - tmp14 := checkDerefVar(glojure_DOT_core_first) + tmp13 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp14 := checkDerefVar(var_glojure_DOT_core_first) tmp15 := lang.Apply(tmp14, []any{v6}) tmp16 := lang.Apply(tmp13, []any{tmp15}) if lang.IsTruthy(tmp16) { - tmp17 := checkDerefVar(glojure_DOT_core_first) + tmp17 := checkDerefVar(var_glojure_DOT_core_first) tmp18 := lang.Apply(tmp17, []any{v6}) tmp12 = tmp18 } else { @@ -36465,7 +36648,7 @@ func LoadNS() { // let binding "references" var tmp20 any if lang.IsTruthy(v19) { - tmp21 := checkDerefVar(glojure_DOT_core_next) + tmp21 := checkDerefVar(var_glojure_DOT_core_next) tmp22 := lang.Apply(tmp21, []any{v6}) tmp20 = tmp22 } else { @@ -36476,9 +36659,9 @@ func LoadNS() { // let binding "name" var tmp24 any if lang.IsTruthy(v19) { - tmp25 := checkDerefVar(glojure_DOT_core_vary_meta) - tmp26 := checkDerefVar(glojure_DOT_core_assoc) - tmp27 := lang.Apply(tmp25, []any{v5, tmp26, lang.NewKeyword("doc"), v19}) + tmp25 := checkDerefVar(var_glojure_DOT_core_vary_DASH_meta) + tmp26 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp27 := lang.Apply(tmp25, []any{v5, tmp26, kw_doc, v19}) tmp24 = tmp27 } else { tmp24 = v5 @@ -36487,12 +36670,12 @@ func LoadNS() { _ = v28 // let binding "metadata" var tmp29 any - tmp30 := checkDerefVar(glojure_DOT_core_map_QMARK_) - tmp31 := checkDerefVar(glojure_DOT_core_first) + tmp30 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp31 := checkDerefVar(var_glojure_DOT_core_first) tmp32 := lang.Apply(tmp31, []any{v23}) tmp33 := lang.Apply(tmp30, []any{tmp32}) if lang.IsTruthy(tmp33) { - tmp34 := checkDerefVar(glojure_DOT_core_first) + tmp34 := checkDerefVar(var_glojure_DOT_core_first) tmp35 := lang.Apply(tmp34, []any{v23}) tmp29 = tmp35 } else { @@ -36502,7 +36685,7 @@ func LoadNS() { // let binding "references" var tmp37 any if lang.IsTruthy(v36) { - tmp38 := checkDerefVar(glojure_DOT_core_next) + tmp38 := checkDerefVar(var_glojure_DOT_core_next) tmp39 := lang.Apply(tmp38, []any{v23}) tmp37 = tmp39 } else { @@ -36513,8 +36696,8 @@ func LoadNS() { // let binding "name" var tmp41 any if lang.IsTruthy(v36) { - tmp42 := checkDerefVar(glojure_DOT_core_vary_meta) - tmp43 := checkDerefVar(glojure_DOT_core_merge) + tmp42 := checkDerefVar(var_glojure_DOT_core_vary_DASH_meta) + tmp43 := checkDerefVar(var_glojure_DOT_core_merge) tmp44 := lang.Apply(tmp42, []any{v28, tmp43, v36}) tmp41 = tmp44 } else { @@ -36523,22 +36706,20 @@ func LoadNS() { var v45 any = tmp41 _ = v45 // let binding "gen-class-clause" - tmp46 := checkDerefVar(glojure_DOT_core_first) - tmp47 := checkDerefVar(glojure_DOT_core_filter) + tmp46 := checkDerefVar(var_glojure_DOT_core_first) + tmp47 := checkDerefVar(var_glojure_DOT_core_filter) var tmp48 lang.FnFunc tmp48 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v49 := args[0] _ = v49 - tmp50 := checkDerefVar(glojure_DOT_core__EQ_) - tmp51 := checkDerefVar(glojure_DOT_core_first) + tmp50 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp51 := checkDerefVar(var_glojure_DOT_core_first) tmp52 := lang.Apply(tmp51, []any{v49}) - tmp53 := lang.Apply(tmp50, []any{lang.NewKeyword("gen-class"), tmp52}) + tmp53 := lang.Apply(tmp50, []any{kw_gen_DASH_class, tmp52}) return tmp53 }) - tmp49 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5780), lang.NewKeyword("column"), int(41), lang.NewKeyword("end-line"), int(5780), lang.NewKeyword("end-column"), int(65)) + tmp49 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5780), kw_column, int(41), kw_end_DASH_line, int(5780), kw_end_DASH_column, int(65)) tmp50, err := lang.WithMeta(tmp48, tmp49.(lang.IPersistentMap)) if err != nil { panic(err) @@ -36550,38 +36731,36 @@ func LoadNS() { // let binding "gen-class-call" var tmp54 any if lang.IsTruthy(v53) { - tmp55 := checkDerefVar(glojure_DOT_core_list_STAR_) - tmp56 := checkDerefVar(glojure_DOT_core_str) + tmp55 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp56 := checkDerefVar(var_glojure_DOT_core_str) tmp57 := lang.Apply(tmp56, []any{v45}) tmp58, _ := lang.FieldOrMethod(tmp57, "replace") if reflect.TypeOf(tmp58).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("replace is not a function"))) } tmp59 := lang.Apply(tmp58, []any{lang.NewChar(45), lang.NewChar(95)}) - tmp60 := checkDerefVar(glojure_DOT_core_next) + tmp60 := checkDerefVar(var_glojure_DOT_core_next) tmp61 := lang.Apply(tmp60, []any{v53}) - tmp62 := lang.Apply(tmp55, []any{lang.NewSymbol("glojure.core/gen-class"), lang.NewKeyword("name"), tmp59, lang.NewKeyword("impl-ns"), v45, lang.NewKeyword("main"), true, tmp61}) + tmp62 := lang.Apply(tmp55, []any{sym_glojure_DOT_core_SLASH_gen_DASH_class, kw_name, tmp59, kw_impl_DASH_ns, v45, kw_main, true, tmp61}) tmp54 = tmp62 } else { } var v63 any = tmp54 _ = v63 // let binding "references" - tmp64 := checkDerefVar(glojure_DOT_core_remove) + tmp64 := checkDerefVar(var_glojure_DOT_core_remove) var tmp65 lang.FnFunc tmp65 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v66 := args[0] _ = v66 - tmp67 := checkDerefVar(glojure_DOT_core__EQ_) - tmp68 := checkDerefVar(glojure_DOT_core_first) + tmp67 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp68 := checkDerefVar(var_glojure_DOT_core_first) tmp69 := lang.Apply(tmp68, []any{v66}) - tmp70 := lang.Apply(tmp67, []any{lang.NewKeyword("gen-class"), tmp69}) + tmp70 := lang.Apply(tmp67, []any{kw_gen_DASH_class, tmp69}) return tmp70 }) - tmp66 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5784), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(5784), lang.NewKeyword("end-column"), int(52)) + tmp66 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5784), kw_column, int(28), kw_end_DASH_line, int(5784), kw_end_DASH_column, int(52)) tmp67, err := lang.WithMeta(tmp65, tmp66.(lang.IPersistentMap)) if err != nil { panic(err) @@ -36590,25 +36769,25 @@ func LoadNS() { var v69 any = tmp68 _ = v69 // let binding "name-metadata" - tmp70 := checkDerefVar(glojure_DOT_core_meta) + tmp70 := checkDerefVar(var_glojure_DOT_core_meta) tmp71 := lang.Apply(tmp70, []any{v45}) var v72 any = tmp71 _ = v72 - tmp73 := checkDerefVar(glojure_DOT_core_seq) - tmp74 := checkDerefVar(glojure_DOT_core_concat) - tmp75 := checkDerefVar(glojure_DOT_core_list) - tmp76 := lang.Apply(tmp75, []any{lang.NewSymbol("do")}) - tmp77 := checkDerefVar(glojure_DOT_core_list) - tmp78 := checkDerefVar(glojure_DOT_core_seq) - tmp79 := checkDerefVar(glojure_DOT_core_concat) - tmp80 := checkDerefVar(glojure_DOT_core_list) - tmp81 := lang.Apply(tmp80, []any{lang.NewSymbol("glojure.core/in-ns")}) - tmp82 := checkDerefVar(glojure_DOT_core_list) - tmp83 := checkDerefVar(glojure_DOT_core_seq) - tmp84 := checkDerefVar(glojure_DOT_core_concat) - tmp85 := checkDerefVar(glojure_DOT_core_list) - tmp86 := lang.Apply(tmp85, []any{lang.NewSymbol("quote")}) - tmp87 := checkDerefVar(glojure_DOT_core_list) + tmp73 := checkDerefVar(var_glojure_DOT_core_seq) + tmp74 := checkDerefVar(var_glojure_DOT_core_concat) + tmp75 := checkDerefVar(var_glojure_DOT_core_list) + tmp76 := lang.Apply(tmp75, []any{sym_do}) + tmp77 := checkDerefVar(var_glojure_DOT_core_list) + tmp78 := checkDerefVar(var_glojure_DOT_core_seq) + tmp79 := checkDerefVar(var_glojure_DOT_core_concat) + tmp80 := checkDerefVar(var_glojure_DOT_core_list) + tmp81 := lang.Apply(tmp80, []any{sym_glojure_DOT_core_SLASH_in_DASH_ns}) + tmp82 := checkDerefVar(var_glojure_DOT_core_list) + tmp83 := checkDerefVar(var_glojure_DOT_core_seq) + tmp84 := checkDerefVar(var_glojure_DOT_core_concat) + tmp85 := checkDerefVar(var_glojure_DOT_core_list) + tmp86 := lang.Apply(tmp85, []any{sym_quote}) + tmp87 := checkDerefVar(var_glojure_DOT_core_list) tmp88 := lang.Apply(tmp87, []any{v45}) tmp89 := lang.Apply(tmp84, []any{tmp86, tmp88}) tmp90 := lang.Apply(tmp83, []any{tmp89}) @@ -36618,24 +36797,24 @@ func LoadNS() { tmp94 := lang.Apply(tmp77, []any{tmp93}) var tmp95 any if lang.IsTruthy(v72) { - tmp96 := checkDerefVar(glojure_DOT_core_seq) - tmp97 := checkDerefVar(glojure_DOT_core_concat) - tmp98 := checkDerefVar(glojure_DOT_core_list) - tmp99 := checkDerefVar(glojure_DOT_core_seq) - tmp100 := checkDerefVar(glojure_DOT_core_concat) - tmp101 := checkDerefVar(glojure_DOT_core_list) - tmp102 := lang.Apply(tmp101, []any{lang.NewSymbol(".ResetMeta")}) - tmp103 := checkDerefVar(glojure_DOT_core_list) - tmp104 := checkDerefVar(glojure_DOT_core_seq) - tmp105 := checkDerefVar(glojure_DOT_core_concat) - tmp106 := checkDerefVar(glojure_DOT_core_list) - tmp107 := lang.Apply(tmp106, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.FindNamespace")}) - tmp108 := checkDerefVar(glojure_DOT_core_list) - tmp109 := checkDerefVar(glojure_DOT_core_seq) - tmp110 := checkDerefVar(glojure_DOT_core_concat) - tmp111 := checkDerefVar(glojure_DOT_core_list) - tmp112 := lang.Apply(tmp111, []any{lang.NewSymbol("quote")}) - tmp113 := checkDerefVar(glojure_DOT_core_list) + tmp96 := checkDerefVar(var_glojure_DOT_core_seq) + tmp97 := checkDerefVar(var_glojure_DOT_core_concat) + tmp98 := checkDerefVar(var_glojure_DOT_core_list) + tmp99 := checkDerefVar(var_glojure_DOT_core_seq) + tmp100 := checkDerefVar(var_glojure_DOT_core_concat) + tmp101 := checkDerefVar(var_glojure_DOT_core_list) + tmp102 := lang.Apply(tmp101, []any{sym__DOT_ResetMeta}) + tmp103 := checkDerefVar(var_glojure_DOT_core_list) + tmp104 := checkDerefVar(var_glojure_DOT_core_seq) + tmp105 := checkDerefVar(var_glojure_DOT_core_concat) + tmp106 := checkDerefVar(var_glojure_DOT_core_list) + tmp107 := lang.Apply(tmp106, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_FindNamespace}) + tmp108 := checkDerefVar(var_glojure_DOT_core_list) + tmp109 := checkDerefVar(var_glojure_DOT_core_seq) + tmp110 := checkDerefVar(var_glojure_DOT_core_concat) + tmp111 := checkDerefVar(var_glojure_DOT_core_list) + tmp112 := lang.Apply(tmp111, []any{sym_quote}) + tmp113 := checkDerefVar(var_glojure_DOT_core_list) tmp114 := lang.Apply(tmp113, []any{v45}) tmp115 := lang.Apply(tmp110, []any{tmp112, tmp114}) tmp116 := lang.Apply(tmp109, []any{tmp115}) @@ -36643,7 +36822,7 @@ func LoadNS() { tmp118 := lang.Apply(tmp105, []any{tmp107, tmp117}) tmp119 := lang.Apply(tmp104, []any{tmp118}) tmp120 := lang.Apply(tmp103, []any{tmp119}) - tmp121 := checkDerefVar(glojure_DOT_core_list) + tmp121 := checkDerefVar(var_glojure_DOT_core_list) tmp122 := lang.Apply(tmp121, []any{v72}) tmp123 := lang.Apply(tmp100, []any{tmp102, tmp120, tmp122}) tmp124 := lang.Apply(tmp99, []any{tmp123}) @@ -36653,14 +36832,14 @@ func LoadNS() { tmp95 = tmp127 } else { } - tmp128 := checkDerefVar(glojure_DOT_core_list) - tmp129 := checkDerefVar(glojure_DOT_core_seq) - tmp130 := checkDerefVar(glojure_DOT_core_concat) - tmp131 := checkDerefVar(glojure_DOT_core_list) - tmp132 := lang.Apply(tmp131, []any{lang.NewSymbol("glojure.core/with-loading-context")}) + tmp128 := checkDerefVar(var_glojure_DOT_core_list) + tmp129 := checkDerefVar(var_glojure_DOT_core_seq) + tmp130 := checkDerefVar(var_glojure_DOT_core_concat) + tmp131 := checkDerefVar(var_glojure_DOT_core_list) + tmp132 := lang.Apply(tmp131, []any{sym_glojure_DOT_core_SLASH_with_DASH_loading_DASH_context}) var tmp133 any if lang.IsTruthy(v63) { - tmp134 := checkDerefVar(glojure_DOT_core_list) + tmp134 := checkDerefVar(var_glojure_DOT_core_list) tmp135 := lang.Apply(tmp134, []any{v63}) tmp133 = tmp135 } else { @@ -36669,27 +36848,25 @@ func LoadNS() { var tmp137 any { // let // let binding "and__0__auto__" - tmp138 := checkDerefVar(glojure_DOT_core_not_EQ_) - tmp139 := lang.Apply(tmp138, []any{v45, lang.NewSymbol("glojure.core")}) + tmp138 := checkDerefVar(var_glojure_DOT_core_not_EQ_) + tmp139 := lang.Apply(tmp138, []any{v45, sym_glojure_DOT_core}) var v140 any = tmp139 _ = v140 var tmp141 any if lang.IsTruthy(v140) { - tmp142 := checkDerefVar(glojure_DOT_core_not_any_QMARK_) + tmp142 := checkDerefVar(var_glojure_DOT_core_not_DASH_any_QMARK_) var tmp143 lang.FnFunc tmp143 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v144 := args[0] _ = v144 - tmp145 := checkDerefVar(glojure_DOT_core__EQ_) - tmp146 := checkDerefVar(glojure_DOT_core_first) + tmp145 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp146 := checkDerefVar(var_glojure_DOT_core_first) tmp147 := lang.Apply(tmp146, []any{v144}) - tmp148 := lang.Apply(tmp145, []any{lang.NewKeyword("refer-glojure"), tmp147}) + tmp148 := lang.Apply(tmp145, []any{kw_refer_DASH_glojure, tmp147}) return tmp148 }) - tmp144 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5793), lang.NewKeyword("column"), int(58), lang.NewKeyword("end-line"), int(5793), lang.NewKeyword("end-column"), int(86)) + tmp144 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5793), kw_column, int(58), kw_end_DASH_line, int(5793), kw_end_DASH_column, int(86)) tmp145, err := lang.WithMeta(tmp143, tmp144.(lang.IPersistentMap)) if err != nil { panic(err) @@ -36702,20 +36879,20 @@ func LoadNS() { tmp137 = tmp141 } // end let if lang.IsTruthy(tmp137) { - tmp138 := checkDerefVar(glojure_DOT_core_seq) - tmp139 := checkDerefVar(glojure_DOT_core_concat) - tmp140 := checkDerefVar(glojure_DOT_core_list) - tmp141 := checkDerefVar(glojure_DOT_core_seq) - tmp142 := checkDerefVar(glojure_DOT_core_concat) - tmp143 := checkDerefVar(glojure_DOT_core_list) - tmp144 := lang.Apply(tmp143, []any{lang.NewSymbol("glojure.core/refer")}) - tmp145 := checkDerefVar(glojure_DOT_core_list) - tmp146 := checkDerefVar(glojure_DOT_core_seq) - tmp147 := checkDerefVar(glojure_DOT_core_concat) - tmp148 := checkDerefVar(glojure_DOT_core_list) - tmp149 := lang.Apply(tmp148, []any{lang.NewSymbol("quote")}) - tmp150 := checkDerefVar(glojure_DOT_core_list) - tmp151 := lang.Apply(tmp150, []any{lang.NewSymbol("glojure.core")}) + tmp138 := checkDerefVar(var_glojure_DOT_core_seq) + tmp139 := checkDerefVar(var_glojure_DOT_core_concat) + tmp140 := checkDerefVar(var_glojure_DOT_core_list) + tmp141 := checkDerefVar(var_glojure_DOT_core_seq) + tmp142 := checkDerefVar(var_glojure_DOT_core_concat) + tmp143 := checkDerefVar(var_glojure_DOT_core_list) + tmp144 := lang.Apply(tmp143, []any{sym_glojure_DOT_core_SLASH_refer}) + tmp145 := checkDerefVar(var_glojure_DOT_core_list) + tmp146 := checkDerefVar(var_glojure_DOT_core_seq) + tmp147 := checkDerefVar(var_glojure_DOT_core_concat) + tmp148 := checkDerefVar(var_glojure_DOT_core_list) + tmp149 := lang.Apply(tmp148, []any{sym_quote}) + tmp150 := checkDerefVar(var_glojure_DOT_core_list) + tmp151 := lang.Apply(tmp150, []any{sym_glojure_DOT_core}) tmp152 := lang.Apply(tmp147, []any{tmp149, tmp151}) tmp153 := lang.Apply(tmp146, []any{tmp152}) tmp154 := lang.Apply(tmp145, []any{tmp153}) @@ -36727,87 +36904,87 @@ func LoadNS() { tmp136 = tmp159 } else { } - tmp160 := checkDerefVar(glojure_DOT_core_map) + tmp160 := checkDerefVar(var_glojure_DOT_core_map) tmp161 := lang.Apply(tmp160, []any{v11, v69}) tmp162 := lang.Apply(tmp130, []any{tmp132, tmp133, tmp136, tmp161}) tmp163 := lang.Apply(tmp129, []any{tmp162}) tmp164 := lang.Apply(tmp128, []any{tmp163}) - tmp165 := checkDerefVar(glojure_DOT_core_list) - tmp166 := checkDerefVar(glojure_DOT_core_seq) - tmp167 := checkDerefVar(glojure_DOT_core_concat) - tmp168 := checkDerefVar(glojure_DOT_core_list) - tmp169 := lang.Apply(tmp168, []any{lang.NewSymbol("if")}) - tmp170 := checkDerefVar(glojure_DOT_core_list) - tmp171 := checkDerefVar(glojure_DOT_core_seq) - tmp172 := checkDerefVar(glojure_DOT_core_concat) - tmp173 := checkDerefVar(glojure_DOT_core_list) - tmp174 := lang.Apply(tmp173, []any{lang.NewSymbol(".Equals")}) - tmp175 := checkDerefVar(glojure_DOT_core_list) - tmp176 := checkDerefVar(glojure_DOT_core_seq) - tmp177 := checkDerefVar(glojure_DOT_core_concat) - tmp178 := checkDerefVar(glojure_DOT_core_list) - tmp179 := lang.Apply(tmp178, []any{lang.NewSymbol("quote")}) - tmp180 := checkDerefVar(glojure_DOT_core_list) + tmp165 := checkDerefVar(var_glojure_DOT_core_list) + tmp166 := checkDerefVar(var_glojure_DOT_core_seq) + tmp167 := checkDerefVar(var_glojure_DOT_core_concat) + tmp168 := checkDerefVar(var_glojure_DOT_core_list) + tmp169 := lang.Apply(tmp168, []any{sym_if}) + tmp170 := checkDerefVar(var_glojure_DOT_core_list) + tmp171 := checkDerefVar(var_glojure_DOT_core_seq) + tmp172 := checkDerefVar(var_glojure_DOT_core_concat) + tmp173 := checkDerefVar(var_glojure_DOT_core_list) + tmp174 := lang.Apply(tmp173, []any{sym__DOT_Equals}) + tmp175 := checkDerefVar(var_glojure_DOT_core_list) + tmp176 := checkDerefVar(var_glojure_DOT_core_seq) + tmp177 := checkDerefVar(var_glojure_DOT_core_concat) + tmp178 := checkDerefVar(var_glojure_DOT_core_list) + tmp179 := lang.Apply(tmp178, []any{sym_quote}) + tmp180 := checkDerefVar(var_glojure_DOT_core_list) tmp181 := lang.Apply(tmp180, []any{v45}) tmp182 := lang.Apply(tmp177, []any{tmp179, tmp181}) tmp183 := lang.Apply(tmp176, []any{tmp182}) tmp184 := lang.Apply(tmp175, []any{tmp183}) - tmp185 := checkDerefVar(glojure_DOT_core_list) - tmp186 := checkDerefVar(glojure_DOT_core_seq) - tmp187 := checkDerefVar(glojure_DOT_core_concat) - tmp188 := checkDerefVar(glojure_DOT_core_list) - tmp189 := lang.Apply(tmp188, []any{lang.NewSymbol("quote")}) - tmp190 := checkDerefVar(glojure_DOT_core_list) - tmp191 := lang.Apply(tmp190, []any{lang.NewSymbol("glojure.core")}) + tmp185 := checkDerefVar(var_glojure_DOT_core_list) + tmp186 := checkDerefVar(var_glojure_DOT_core_seq) + tmp187 := checkDerefVar(var_glojure_DOT_core_concat) + tmp188 := checkDerefVar(var_glojure_DOT_core_list) + tmp189 := lang.Apply(tmp188, []any{sym_quote}) + tmp190 := checkDerefVar(var_glojure_DOT_core_list) + tmp191 := lang.Apply(tmp190, []any{sym_glojure_DOT_core}) tmp192 := lang.Apply(tmp187, []any{tmp189, tmp191}) tmp193 := lang.Apply(tmp186, []any{tmp192}) tmp194 := lang.Apply(tmp185, []any{tmp193}) tmp195 := lang.Apply(tmp172, []any{tmp174, tmp184, tmp194}) tmp196 := lang.Apply(tmp171, []any{tmp195}) tmp197 := lang.Apply(tmp170, []any{tmp196}) - tmp198 := checkDerefVar(glojure_DOT_core_list) + tmp198 := checkDerefVar(var_glojure_DOT_core_list) tmp199 := lang.Apply(tmp198, []any{nil}) - tmp200 := checkDerefVar(glojure_DOT_core_list) - tmp201 := checkDerefVar(glojure_DOT_core_seq) - tmp202 := checkDerefVar(glojure_DOT_core_concat) - tmp203 := checkDerefVar(glojure_DOT_core_list) - tmp204 := lang.Apply(tmp203, []any{lang.NewSymbol("do")}) - tmp205 := checkDerefVar(glojure_DOT_core_list) - tmp206 := checkDerefVar(glojure_DOT_core_seq) - tmp207 := checkDerefVar(glojure_DOT_core_concat) - tmp208 := checkDerefVar(glojure_DOT_core_list) - tmp209 := lang.Apply(tmp208, []any{lang.NewSymbol("glojure.core/dosync")}) - tmp210 := checkDerefVar(glojure_DOT_core_list) - tmp211 := checkDerefVar(glojure_DOT_core_seq) - tmp212 := checkDerefVar(glojure_DOT_core_concat) - tmp213 := checkDerefVar(glojure_DOT_core_list) - tmp214 := lang.Apply(tmp213, []any{lang.NewSymbol("glojure.core/commute")}) - tmp215 := checkDerefVar(glojure_DOT_core_list) - tmp216 := checkDerefVar(glojure_DOT_core_seq) - tmp217 := checkDerefVar(glojure_DOT_core_concat) - tmp218 := checkDerefVar(glojure_DOT_core_list) - tmp219 := lang.Apply(tmp218, []any{lang.NewSymbol("glojure.core/deref")}) - tmp220 := checkDerefVar(glojure_DOT_core_list) - tmp221 := checkDerefVar(glojure_DOT_core_seq) - tmp222 := checkDerefVar(glojure_DOT_core_concat) - tmp223 := checkDerefVar(glojure_DOT_core_list) - tmp224 := lang.Apply(tmp223, []any{lang.NewSymbol("var")}) - tmp225 := checkDerefVar(glojure_DOT_core_list) - tmp226 := lang.Apply(tmp225, []any{lang.NewSymbol("glojure.core/*loaded-libs*")}) + tmp200 := checkDerefVar(var_glojure_DOT_core_list) + tmp201 := checkDerefVar(var_glojure_DOT_core_seq) + tmp202 := checkDerefVar(var_glojure_DOT_core_concat) + tmp203 := checkDerefVar(var_glojure_DOT_core_list) + tmp204 := lang.Apply(tmp203, []any{sym_do}) + tmp205 := checkDerefVar(var_glojure_DOT_core_list) + tmp206 := checkDerefVar(var_glojure_DOT_core_seq) + tmp207 := checkDerefVar(var_glojure_DOT_core_concat) + tmp208 := checkDerefVar(var_glojure_DOT_core_list) + tmp209 := lang.Apply(tmp208, []any{sym_glojure_DOT_core_SLASH_dosync}) + tmp210 := checkDerefVar(var_glojure_DOT_core_list) + tmp211 := checkDerefVar(var_glojure_DOT_core_seq) + tmp212 := checkDerefVar(var_glojure_DOT_core_concat) + tmp213 := checkDerefVar(var_glojure_DOT_core_list) + tmp214 := lang.Apply(tmp213, []any{sym_glojure_DOT_core_SLASH_commute}) + tmp215 := checkDerefVar(var_glojure_DOT_core_list) + tmp216 := checkDerefVar(var_glojure_DOT_core_seq) + tmp217 := checkDerefVar(var_glojure_DOT_core_concat) + tmp218 := checkDerefVar(var_glojure_DOT_core_list) + tmp219 := lang.Apply(tmp218, []any{sym_glojure_DOT_core_SLASH_deref}) + tmp220 := checkDerefVar(var_glojure_DOT_core_list) + tmp221 := checkDerefVar(var_glojure_DOT_core_seq) + tmp222 := checkDerefVar(var_glojure_DOT_core_concat) + tmp223 := checkDerefVar(var_glojure_DOT_core_list) + tmp224 := lang.Apply(tmp223, []any{sym_var}) + tmp225 := checkDerefVar(var_glojure_DOT_core_list) + tmp226 := lang.Apply(tmp225, []any{sym_glojure_DOT_core_SLASH__STAR_loaded_DASH_libs_STAR_}) tmp227 := lang.Apply(tmp222, []any{tmp224, tmp226}) tmp228 := lang.Apply(tmp221, []any{tmp227}) tmp229 := lang.Apply(tmp220, []any{tmp228}) tmp230 := lang.Apply(tmp217, []any{tmp219, tmp229}) tmp231 := lang.Apply(tmp216, []any{tmp230}) tmp232 := lang.Apply(tmp215, []any{tmp231}) - tmp233 := checkDerefVar(glojure_DOT_core_list) - tmp234 := lang.Apply(tmp233, []any{lang.NewSymbol("glojure.core/conj")}) - tmp235 := checkDerefVar(glojure_DOT_core_list) - tmp236 := checkDerefVar(glojure_DOT_core_seq) - tmp237 := checkDerefVar(glojure_DOT_core_concat) - tmp238 := checkDerefVar(glojure_DOT_core_list) - tmp239 := lang.Apply(tmp238, []any{lang.NewSymbol("quote")}) - tmp240 := checkDerefVar(glojure_DOT_core_list) + tmp233 := checkDerefVar(var_glojure_DOT_core_list) + tmp234 := lang.Apply(tmp233, []any{sym_glojure_DOT_core_SLASH_conj}) + tmp235 := checkDerefVar(var_glojure_DOT_core_list) + tmp236 := checkDerefVar(var_glojure_DOT_core_seq) + tmp237 := checkDerefVar(var_glojure_DOT_core_concat) + tmp238 := checkDerefVar(var_glojure_DOT_core_list) + tmp239 := lang.Apply(tmp238, []any{sym_quote}) + tmp240 := checkDerefVar(var_glojure_DOT_core_list) tmp241 := lang.Apply(tmp240, []any{v45}) tmp242 := lang.Apply(tmp237, []any{tmp239, tmp241}) tmp243 := lang.Apply(tmp236, []any{tmp242}) @@ -36818,7 +36995,7 @@ func LoadNS() { tmp248 := lang.Apply(tmp207, []any{tmp209, tmp247}) tmp249 := lang.Apply(tmp206, []any{tmp248}) tmp250 := lang.Apply(tmp205, []any{tmp249}) - tmp251 := checkDerefVar(glojure_DOT_core_list) + tmp251 := checkDerefVar(var_glojure_DOT_core_list) tmp252 := lang.Apply(tmp251, []any{nil}) tmp253 := lang.Apply(tmp202, []any{tmp204, tmp250, tmp252}) tmp254 := lang.Apply(tmp201, []any{tmp253}) @@ -36833,7 +37010,7 @@ func LoadNS() { return tmp7 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -36841,15 +37018,13 @@ func LoadNS() { } // ns-aliases { - tmp0 := lang.NewSymbol("ns-aliases").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of the aliases for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4273), lang.NewKeyword("end-line"), int(4273))).(*lang.Symbol) + tmp0 := sym_ns_DASH_aliases.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns)), kw_doc, "Returns a map of the aliases for the namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4273), kw_end_DASH_line, int(4273))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_the_ns) + tmp4 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) tmp5 := lang.Apply(tmp4, []any{v3}) tmp6, ok := lang.FieldOrMethod(tmp5, "getAliases") if !ok { @@ -36864,7 +37039,7 @@ func LoadNS() { } return tmp7 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -36872,26 +37047,24 @@ func LoadNS() { } // ns-imports { - tmp0 := lang.NewSymbol("ns-imports").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of the import mappings for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4199), lang.NewKeyword("end-line"), int(4199))).(*lang.Symbol) + tmp0 := sym_ns_DASH_imports.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns)), kw_doc, "Returns a map of the import mappings for the namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4199), kw_end_DASH_line, int(4199))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_filter_key) - tmp5 := checkDerefVar(glojure_DOT_core_val) - tmp6 := checkDerefVar(glojure_DOT_core_partial) - tmp7 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp4 := checkDerefVar(var_glojure_DOT_core_filter_DASH_key) + tmp5 := checkDerefVar(var_glojure_DOT_core_val) + tmp6 := checkDerefVar(var_glojure_DOT_core_partial) + tmp7 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp8 := reflect.TypeOf((*reflect.Type)(nil)).Elem() tmp9 := lang.Apply(tmp6, []any{tmp7, tmp8}) - tmp10 := checkDerefVar(glojure_DOT_core_ns_map) + tmp10 := checkDerefVar(var_glojure_DOT_core_ns_DASH_map) tmp11 := lang.Apply(tmp10, []any{v3}) tmp12 := lang.Apply(tmp4, []any{tmp5, tmp9, tmp11}) return tmp12 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -36899,41 +37072,37 @@ func LoadNS() { } // ns-interns { - tmp0 := lang.NewSymbol("ns-interns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of the intern mappings for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4206), lang.NewKeyword("end-line"), int(4206))).(*lang.Symbol) + tmp0 := sym_ns_DASH_interns.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns)), kw_doc, "Returns a map of the intern mappings for the namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4206), kw_end_DASH_line, int(4206))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any { // let // let binding "ns" - tmp5 := checkDerefVar(glojure_DOT_core_the_ns) + tmp5 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) tmp6 := lang.Apply(tmp5, []any{v3}) var v7 any = tmp6 _ = v7 - tmp8 := checkDerefVar(glojure_DOT_core_filter_key) - tmp9 := checkDerefVar(glojure_DOT_core_val) + tmp8 := checkDerefVar(var_glojure_DOT_core_filter_DASH_key) + tmp9 := checkDerefVar(var_glojure_DOT_core_val) var tmp10 lang.FnFunc tmp10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v11 := args[0] _ = v11 var tmp12 any { // let // let binding "and__0__auto__" - tmp13 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp13 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp14 := reflect.TypeOf((*lang.Var)(nil)) tmp15 := lang.Apply(tmp13, []any{tmp14, v11}) var v16 any = tmp15 _ = v16 var tmp17 any if lang.IsTruthy(v16) { - tmp18 := checkDerefVar(glojure_DOT_core__EQ_) + tmp18 := checkDerefVar(var_glojure_DOT_core__EQ_) tmp19, ok := lang.FieldOrMethod(v11, "Namespace") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v11, "Namespace"))) @@ -36954,19 +37123,19 @@ func LoadNS() { } // end let return tmp12 }) - tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4212), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(4213), lang.NewKeyword("end-column"), int(56)) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4212), kw_column, int(21), kw_end_DASH_line, int(4213), kw_end_DASH_column, int(56)) tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp13 := checkDerefVar(glojure_DOT_core_ns_map) + tmp13 := checkDerefVar(var_glojure_DOT_core_ns_DASH_map) tmp14 := lang.Apply(tmp13, []any{v7}) tmp15 := lang.Apply(tmp8, []any{tmp9, tmp12, tmp14}) tmp4 = tmp15 } // end let return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -36974,15 +37143,13 @@ func LoadNS() { } // ns-map { - tmp0 := lang.NewSymbol("ns-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of all the mappings for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4170), lang.NewKeyword("end-line"), int(4170))).(*lang.Symbol) + tmp0 := sym_ns_DASH_map.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns)), kw_doc, "Returns a map of all the mappings for the namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(4170), kw_end_DASH_line, int(4170))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_the_ns) + tmp4 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) tmp5 := lang.Apply(tmp4, []any{v3}) tmp6, ok := lang.FieldOrMethod(tmp5, "Mappings") if !ok { @@ -36997,7 +37164,7 @@ func LoadNS() { } return tmp7 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -37005,15 +37172,13 @@ func LoadNS() { } // ns-name { - tmp0 := lang.NewSymbol("ns-name").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns the name of the namespace, a symbol.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4163), lang.NewKeyword("end-line"), int(4163))).(*lang.Symbol) + tmp0 := sym_ns_DASH_name.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns)), kw_doc, "Returns the name of the namespace, a symbol.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4163), kw_end_DASH_line, int(4163))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_the_ns) + tmp4 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) tmp5 := lang.Apply(tmp4, []any{v3}) tmp6, ok := lang.FieldOrMethod(tmp5, "Name") if !ok { @@ -37028,7 +37193,7 @@ func LoadNS() { } return tmp7 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -37036,34 +37201,30 @@ func LoadNS() { } // ns-publics { - tmp0 := lang.NewSymbol("ns-publics").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of the public intern mappings for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4188), lang.NewKeyword("end-line"), int(4188))).(*lang.Symbol) + tmp0 := sym_ns_DASH_publics.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns)), kw_doc, "Returns a map of the public intern mappings for the namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4188), kw_end_DASH_line, int(4188))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any { // let // let binding "ns" - tmp5 := checkDerefVar(glojure_DOT_core_the_ns) + tmp5 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) tmp6 := lang.Apply(tmp5, []any{v3}) var v7 any = tmp6 _ = v7 - tmp8 := checkDerefVar(glojure_DOT_core_filter_key) - tmp9 := checkDerefVar(glojure_DOT_core_val) + tmp8 := checkDerefVar(var_glojure_DOT_core_filter_DASH_key) + tmp9 := checkDerefVar(var_glojure_DOT_core_val) var tmp10 lang.FnFunc tmp10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v11 := args[0] _ = v11 var tmp12 any { // let // let binding "and__0__auto__" - tmp13 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp13 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp14 := reflect.TypeOf((*lang.Var)(nil)) tmp15 := lang.Apply(tmp13, []any{tmp14, v11}) var v16 any = tmp15 @@ -37073,7 +37234,7 @@ func LoadNS() { var tmp18 any { // let // let binding "and__0__auto__" - tmp19 := checkDerefVar(glojure_DOT_core__EQ_) + tmp19 := checkDerefVar(var_glojure_DOT_core__EQ_) tmp20, ok := lang.FieldOrMethod(v11, "Namespace") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v11, "Namespace"))) @@ -37115,19 +37276,19 @@ func LoadNS() { } // end let return tmp12 }) - tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4194), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(4196), lang.NewKeyword("end-column"), int(48)) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4194), kw_column, int(21), kw_end_DASH_line, int(4196), kw_end_DASH_column, int(48)) tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp13 := checkDerefVar(glojure_DOT_core_ns_map) + tmp13 := checkDerefVar(var_glojure_DOT_core_ns_DASH_map) tmp14 := lang.Apply(tmp13, []any{v7}) tmp15 := lang.Apply(tmp8, []any{tmp9, tmp12, tmp14}) tmp4 = tmp15 } // end let return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -37135,41 +37296,37 @@ func LoadNS() { } // ns-refers { - tmp0 := lang.NewSymbol("ns-refers").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"))), lang.NewKeyword("doc"), "Returns a map of the refer mappings for the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4253), lang.NewKeyword("end-line"), int(4253))).(*lang.Symbol) + tmp0 := sym_ns_DASH_refers.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns)), kw_doc, "Returns a map of the refer mappings for the namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(4253), kw_end_DASH_line, int(4253))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any { // let // let binding "ns" - tmp5 := checkDerefVar(glojure_DOT_core_the_ns) + tmp5 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) tmp6 := lang.Apply(tmp5, []any{v3}) var v7 any = tmp6 _ = v7 - tmp8 := checkDerefVar(glojure_DOT_core_filter_key) - tmp9 := checkDerefVar(glojure_DOT_core_val) + tmp8 := checkDerefVar(var_glojure_DOT_core_filter_DASH_key) + tmp9 := checkDerefVar(var_glojure_DOT_core_val) var tmp10 lang.FnFunc tmp10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v11 := args[0] _ = v11 var tmp12 any { // let // let binding "and__0__auto__" - tmp13 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp13 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp14 := reflect.TypeOf((*lang.Var)(nil)) tmp15 := lang.Apply(tmp13, []any{tmp14, v11}) var v16 any = tmp15 _ = v16 var tmp17 any if lang.IsTruthy(v16) { - tmp18 := checkDerefVar(glojure_DOT_core_not_EQ_) + tmp18 := checkDerefVar(var_glojure_DOT_core_not_EQ_) tmp19, ok := lang.FieldOrMethod(v11, "Namespace") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v11, "Namespace"))) @@ -37190,19 +37347,19 @@ func LoadNS() { } // end let return tmp12 }) - tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4259), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(4260), lang.NewKeyword("end-column"), int(59)) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4259), kw_column, int(21), kw_end_DASH_line, int(4260), kw_end_DASH_column, int(59)) tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp13 := checkDerefVar(glojure_DOT_core_ns_map) + tmp13 := checkDerefVar(var_glojure_DOT_core_ns_DASH_map) tmp14 := lang.Apply(tmp13, []any{v7}) tmp15 := lang.Apply(tmp8, []any{tmp9, tmp12, tmp14}) tmp4 = tmp15 } // end let return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -37210,7 +37367,7 @@ func LoadNS() { } // ns-resolve { - tmp0 := lang.NewSymbol("ns-resolve").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("sym")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("env"), lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Returns the var or Class to which a symbol will be resolved in the\n namespace (unless found in the environment), else nil. Note that\n if the symbol is fully qualified, the var/Class to which it resolves\n need not be present in the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4358), lang.NewKeyword("end-line"), int(4358))).(*lang.Symbol) + tmp0 := sym_ns_DASH_resolve.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns, sym_sym), lang.NewVector(sym_ns, sym_env, sym_sym)), kw_doc, "Returns the var or Class to which a symbol will be resolved in the\n namespace (unless found in the environment), else nil. Note that\n if the symbol is fully qualified, the var/Class to which it resolves\n need not be present in the namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4358), kw_end_DASH_line, int(4358))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -37219,7 +37376,7 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_ns_resolve) + tmp5 := checkDerefVar(var_glojure_DOT_core_ns_DASH_resolve) tmp6 := lang.Apply(tmp5, []any{v3, nil, v4}) return tmp6 case 3: @@ -37230,11 +37387,11 @@ func LoadNS() { v5 := args[2] _ = v5 var tmp6 any - tmp7 := checkDerefVar(glojure_DOT_core_contains_QMARK_) + tmp7 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) tmp8 := lang.Apply(tmp7, []any{v4, v5}) if lang.IsTruthy(tmp8) { } else { - tmp9 := checkDerefVar(glojure_DOT_core_the_ns) + tmp9 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) tmp10 := lang.Apply(tmp9, []any{v3}) tmp11, _ := lang.FieldOrMethod(runtime7.Compiler, "maybeResolveIn") if reflect.TypeOf(tmp11).Kind() != reflect.Func { @@ -37245,10 +37402,11 @@ func LoadNS() { } return tmp6 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -37256,17 +37414,15 @@ func LoadNS() { } // ns-unalias { - tmp0 := lang.NewSymbol("ns-unalias").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Removes the alias for the symbol from the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4280), lang.NewKeyword("end-line"), int(4280))).(*lang.Symbol) + tmp0 := sym_ns_DASH_unalias.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns, sym_sym)), kw_doc, "Removes the alias for the symbol from the namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4280), kw_end_DASH_line, int(4280))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_the_ns) + tmp5 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) tmp6 := lang.Apply(tmp5, []any{v3}) tmp7, _ := lang.FieldOrMethod(tmp6, "removeAlias") if reflect.TypeOf(tmp7).Kind() != reflect.Func { @@ -37275,7 +37431,7 @@ func LoadNS() { tmp8 := lang.Apply(tmp7, []any{v4}) return tmp8 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -37283,17 +37439,15 @@ func LoadNS() { } // ns-unmap { - tmp0 := lang.NewSymbol("ns-unmap").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Removes the mappings for the symbol from the namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4177), lang.NewKeyword("end-line"), int(4177))).(*lang.Symbol) + tmp0 := sym_ns_DASH_unmap.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns, sym_sym)), kw_doc, "Removes the mappings for the symbol from the namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(4177), kw_end_DASH_line, int(4177))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_the_ns) + tmp5 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) tmp6 := lang.Apply(tmp5, []any{v3}) tmp7, _ := lang.FieldOrMethod(tmp6, "unmap") if reflect.TypeOf(tmp7).Kind() != reflect.Func { @@ -37302,7 +37456,7 @@ func LoadNS() { tmp8 := lang.Apply(tmp7, []any{v4}) return tmp8 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -37316,53 +37470,51 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 var v5 any = lang.NewList(args[2:]...) _ = v5 - tmp6 := checkDerefVar(glojure_DOT_core_seq) - tmp7 := checkDerefVar(glojure_DOT_core_concat) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol(".")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - tmp12 := checkDerefVar(glojure_DOT_core_list) - tmp13 := checkDerefVar(glojure_DOT_core_seq) - tmp14 := checkDerefVar(glojure_DOT_core_concat) - tmp15 := checkDerefVar(glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("glojure.core/Nth")}) - tmp17 := checkDerefVar(glojure_DOT_core_list) - tmp18 := checkDerefVar(glojure_DOT_core_seq) - tmp19 := checkDerefVar(glojure_DOT_core_concat) - tmp20 := checkDerefVar(glojure_DOT_core_list) - tmp21 := lang.Apply(tmp20, []any{lang.NewSymbol("glojure.core/unquote")}) - tmp22 := checkDerefVar(glojure_DOT_core_list) - tmp23 := lang.Apply(tmp22, []any{lang.NewSymbol("glojure.core/c")}) + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym__DOT_}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_Nth}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{sym_glojure_DOT_core_SLASH_unquote}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{sym_glojure_DOT_core_SLASH_c}) tmp24 := lang.Apply(tmp19, []any{tmp21, tmp23}) tmp25 := lang.Apply(tmp18, []any{tmp24}) tmp26 := lang.Apply(tmp17, []any{tmp25}) - tmp27 := checkDerefVar(glojure_DOT_core_list) - tmp28 := checkDerefVar(glojure_DOT_core_seq) - tmp29 := checkDerefVar(glojure_DOT_core_concat) - tmp30 := checkDerefVar(glojure_DOT_core_list) - tmp31 := lang.Apply(tmp30, []any{lang.NewSymbol("glojure.core/unquote")}) - tmp32 := checkDerefVar(glojure_DOT_core_list) - tmp33 := lang.Apply(tmp32, []any{lang.NewSymbol("glojure.core/i")}) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := checkDerefVar(var_glojure_DOT_core_seq) + tmp29 := checkDerefVar(var_glojure_DOT_core_concat) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := lang.Apply(tmp30, []any{sym_glojure_DOT_core_SLASH_unquote}) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := lang.Apply(tmp32, []any{sym_glojure_DOT_core_SLASH_i}) tmp34 := lang.Apply(tmp29, []any{tmp31, tmp33}) tmp35 := lang.Apply(tmp28, []any{tmp34}) tmp36 := lang.Apply(tmp27, []any{tmp35}) - tmp37 := checkDerefVar(glojure_DOT_core_list) - tmp38 := checkDerefVar(glojure_DOT_core_seq) - tmp39 := checkDerefVar(glojure_DOT_core_concat) - tmp40 := checkDerefVar(glojure_DOT_core_list) - tmp41 := lang.Apply(tmp40, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) - tmp42 := checkDerefVar(glojure_DOT_core_list) - tmp43 := lang.Apply(tmp42, []any{lang.NewSymbol("glojure.core/nf")}) + tmp37 := checkDerefVar(var_glojure_DOT_core_list) + tmp38 := checkDerefVar(var_glojure_DOT_core_seq) + tmp39 := checkDerefVar(var_glojure_DOT_core_concat) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{sym_glojure_DOT_core_SLASH_unquote_DASH_splicing}) + tmp42 := checkDerefVar(var_glojure_DOT_core_list) + tmp43 := lang.Apply(tmp42, []any{sym_glojure_DOT_core_SLASH_nf}) tmp44 := lang.Apply(tmp39, []any{tmp41, tmp43}) tmp45 := lang.Apply(tmp38, []any{tmp44}) tmp46 := lang.Apply(tmp37, []any{tmp45}) @@ -37377,7 +37529,7 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("nth").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("index")), lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("index"), lang.NewSymbol("not-found"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the value at the index. get returns nil if index out of\n bounds, nth throws an exception unless not-found is supplied. nth\n also works for strings, Java arrays, regex Matchers and Lists, and,\n in O(n) time, for sequences.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2), int64(3)})), lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(882), lang.NewKeyword("end-line"), int(882))).(*lang.Symbol) + tmp0 := sym_nth.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll, sym_index), lang.NewVector(sym_coll, sym_index, sym_not_DASH_found)), kw_inline, tmp1, kw_doc, "Returns the value at the index. get returns nil if index out of\n bounds, nth throws an exception unless not-found is supplied. nth\n also works for strings, Java arrays, regex Matchers and Lists, and,\n in O(n) time, for sequences.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2), int64(3)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(882), kw_end_DASH_line, int(882))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -37406,10 +37558,11 @@ func LoadNS() { tmp8 := lang.Apply(tmp7, []any{v4, v5, v6}) return tmp8 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -37417,27 +37570,25 @@ func LoadNS() { } // nthnext { - tmp0 := lang.NewSymbol("nthnext").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns the nth next of coll, (seq coll) when n is 0.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3147), lang.NewKeyword("end-line"), int(3147))).(*lang.Symbol) + tmp0 := sym_nthnext.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll, sym_n)), kw_doc, "Returns the nth next of coll, (seq coll) when n is 0.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(3147), kw_end_DASH_line, int(3147))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 var tmp5 any - tmp6 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp6 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp7 := reflect.TypeOf((*lang.IDrop)(nil)).Elem() tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) if lang.IsTruthy(tmp8) { var tmp9 any - tmp10 := checkDerefVar(glojure_DOT_core_pos_QMARK_) + tmp10 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) tmp11 := lang.Apply(tmp10, []any{v4}) if lang.IsTruthy(tmp11) { var tmp12 any - tmp13 := checkDerefVar(glojure_DOT_core_int_QMARK_) + tmp13 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) tmp14 := lang.Apply(tmp13, []any{v4}) if lang.IsTruthy(tmp14) { tmp12 = v4 @@ -37452,7 +37603,7 @@ func LoadNS() { tmp17 := lang.Apply(tmp16, []any{tmp12}) tmp9 = tmp17 } else { - tmp18 := checkDerefVar(glojure_DOT_core_seq) + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) tmp19 := lang.Apply(tmp18, []any{v3}) tmp9 = tmp19 } @@ -37464,7 +37615,7 @@ func LoadNS() { var v21 any = v4 _ = v21 // let binding "xs" - tmp22 := checkDerefVar(glojure_DOT_core_seq) + tmp22 := checkDerefVar(var_glojure_DOT_core_seq) tmp23 := lang.Apply(tmp22, []any{v3}) var v24 any = tmp23 _ = v24 @@ -37477,7 +37628,7 @@ func LoadNS() { _ = v27 var tmp28 any if lang.IsTruthy(v27) { - tmp29 := checkDerefVar(glojure_DOT_core_pos_QMARK_) + tmp29 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) tmp30 := lang.Apply(tmp29, []any{v21}) tmp28 = tmp30 } else { @@ -37486,10 +37637,10 @@ func LoadNS() { tmp26 = tmp28 } // end let if lang.IsTruthy(tmp26) { - tmp28 := checkDerefVar(glojure_DOT_core_dec) + tmp28 := checkDerefVar(var_glojure_DOT_core_dec) tmp29 := lang.Apply(tmp28, []any{v21}) var tmp27 any = tmp29 - tmp31 := checkDerefVar(glojure_DOT_core_next) + tmp31 := checkDerefVar(var_glojure_DOT_core_next) tmp32 := lang.Apply(tmp31, []any{v24}) var tmp30 any = tmp32 v21 = tmp27 @@ -37506,7 +37657,7 @@ func LoadNS() { } return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -37514,30 +37665,28 @@ func LoadNS() { } // nthrest { - tmp0 := lang.NewSymbol("nthrest").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns the nth rest of coll, coll when n is 0.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3161), lang.NewKeyword("end-line"), int(3161))).(*lang.Symbol) + tmp0 := sym_nthrest.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll, sym_n)), kw_doc, "Returns the nth rest of coll, coll when n is 0.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(3161), kw_end_DASH_line, int(3161))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 var tmp5 any - tmp6 := checkDerefVar(glojure_DOT_core_pos_QMARK_) + tmp6 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) tmp7 := lang.Apply(tmp6, []any{v4}) if lang.IsTruthy(tmp7) { var tmp8 any { // let // let binding "or__0__auto__" var tmp9 any - tmp10 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp10 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp11 := reflect.TypeOf((*lang.IDrop)(nil)).Elem() tmp12 := lang.Apply(tmp10, []any{tmp11, v3}) if lang.IsTruthy(tmp12) { var tmp13 any - tmp14 := checkDerefVar(glojure_DOT_core_int_QMARK_) + tmp14 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) tmp15 := lang.Apply(tmp14, []any{v4}) if lang.IsTruthy(tmp15) { tmp13 = v4 @@ -37567,13 +37716,13 @@ func LoadNS() { var tmp23 any { // let // let binding "and__0__auto__" - tmp24 := checkDerefVar(glojure_DOT_core_pos_QMARK_) + tmp24 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) tmp25 := lang.Apply(tmp24, []any{v20}) var v26 any = tmp25 _ = v26 var tmp27 any if lang.IsTruthy(v26) { - tmp28 := checkDerefVar(glojure_DOT_core_seq) + tmp28 := checkDerefVar(var_glojure_DOT_core_seq) tmp29 := lang.Apply(tmp28, []any{v21}) tmp27 = tmp29 } else { @@ -37590,10 +37739,10 @@ func LoadNS() { // let binding "xs" var v27 any = v24 _ = v27 - tmp29 := checkDerefVar(glojure_DOT_core_dec) + tmp29 := checkDerefVar(var_glojure_DOT_core_dec) tmp30 := lang.Apply(tmp29, []any{v20}) var tmp28 any = tmp30 - tmp32 := checkDerefVar(glojure_DOT_core_rest) + tmp32 := checkDerefVar(var_glojure_DOT_core_rest) tmp33 := lang.Apply(tmp32, []any{v27}) var tmp31 any = tmp33 v20 = tmp28 @@ -37602,7 +37751,7 @@ func LoadNS() { } // end let tmp25 = tmp26 } else { - tmp27 := checkDerefVar(glojure_DOT_core_seq) + tmp27 := checkDerefVar(var_glojure_DOT_core_seq) tmp28 := lang.Apply(tmp27, []any{v21}) tmp25 = tmp28 } @@ -37630,7 +37779,7 @@ func LoadNS() { } return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -37642,23 +37791,21 @@ func LoadNS() { { // function num__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) - tmp5 := checkDerefVar(glojure_DOT_core_concat) - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := checkDerefVar(glojure_DOT_core_seq) - tmp12 := checkDerefVar(glojure_DOT_core_concat) - tmp13 := checkDerefVar(glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/Num")}) - tmp15 := checkDerefVar(glojure_DOT_core_list) + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Num}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) tmp18 := lang.Apply(tmp11, []any{tmp17}) @@ -37670,12 +37817,10 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("num").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to Number", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3474), lang.NewKeyword("end-line"), int(3474))).(*lang.Symbol) + tmp0 := sym_num.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to Number", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(3474), kw_end_DASH_line, int(3474))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Num") @@ -37685,7 +37830,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v4}) return tmp6 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -37693,18 +37838,16 @@ func LoadNS() { } // number? { - tmp0 := lang.NewSymbol("number?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is a Number", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3560), lang.NewKeyword("end-line"), int(3560))).(*lang.Symbol) + tmp0 := sym_number_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x is a Number", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(3560), kw_end_DASH_line, int(3560))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4 := lang.Apply(lang.IsNumber, []any{v3}) return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -37713,12 +37856,10 @@ func LoadNS() { // numerator { tmp1 := reflect.TypeOf((*big9.Int)(nil)) - tmp0 := lang.NewSymbol("numerator").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("r"))), lang.NewKeyword("doc"), "Returns the numerator part of a Ratio.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3583), lang.NewKeyword("end-line"), int(3583))).(*lang.Symbol) + tmp0 := sym_numerator.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_r)), kw_doc, "Returns the numerator part of a Ratio.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(3583), kw_end_DASH_line, int(3583))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 tmp5, ok := lang.FieldOrMethod(v4, "numerator") @@ -37735,7 +37876,7 @@ func LoadNS() { return tmp6 }) tmp4 := reflect.TypeOf((*big9.Int)(nil)) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -37747,20 +37888,18 @@ func LoadNS() { { // function object-array__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) - tmp5 := checkDerefVar(glojure_DOT_core_concat) - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol("glojure.core/Object_array")}) - tmp12 := checkDerefVar(glojure_DOT_core_list) + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Object_array}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := lang.Apply(tmp12, []any{v3}) tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) tmp15 := lang.Apply(tmp4, []any{tmp14}) @@ -37769,12 +37908,10 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("object-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Creates an array of objects", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1)})), lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5349), lang.NewKeyword("end-line"), int(5349))).(*lang.Symbol) + tmp0 := sym_object_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_size_DASH_or_DASH_seq)), kw_inline, tmp1, kw_doc, "Creates an array of objects", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1)})), kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(5349), kw_end_DASH_line, int(5349))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 tmp5, _ := lang.FieldOrMethod(runtime7.RT, "Object_array") @@ -37784,7 +37921,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v4}) return tmp6 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -37792,21 +37929,19 @@ func LoadNS() { } // odd? { - tmp0 := lang.NewSymbol("odd?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is odd, throws an exception if n is not an integer", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1389), lang.NewKeyword("end-line"), int(1389))).(*lang.Symbol) + tmp0 := sym_odd_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_doc, "Returns true if n is odd, throws an exception if n is not an integer", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1389), kw_end_DASH_line, int(1389))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_not) - tmp5 := checkDerefVar(glojure_DOT_core_even_QMARK_) + tmp4 := checkDerefVar(var_glojure_DOT_core_not) + tmp5 := checkDerefVar(var_glojure_DOT_core_even_QMARK_) tmp6 := lang.Apply(tmp5, []any{v3}) tmp7 := lang.Apply(tmp4, []any{tmp6}) return tmp7 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -37814,7 +37949,7 @@ func LoadNS() { } // or { - tmp0 := lang.NewSymbol("or").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("next"))), lang.NewKeyword("doc"), "Evaluates exprs one at a time, from left to right. If a form\n returns a logical true value, or returns that value and doesn't\n evaluate any of the other expressions, otherwise it returns the\n value of the last expression. (or) returns nil.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(847), lang.NewKeyword("end-line"), int(847))).(*lang.Symbol) + tmp0 := sym_or.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_x), lang.NewVector(sym_x, sym__AMP_, sym_next)), kw_doc, "Evaluates exprs one at a time, from left to right. If a form\n returns a logical true value, or returns that value and doesn't\n evaluate any of the other expressions, otherwise it returns the\n value of the last expression. (or) returns nil.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(11), kw_line, int(847), kw_end_DASH_line, int(847))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -37833,9 +37968,7 @@ func LoadNS() { _ = v5 return v5 default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -37844,37 +37977,37 @@ func LoadNS() { _ = v5 var v6 any = lang.NewList(args[3:]...) _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_seq) - tmp8 := checkDerefVar(glojure_DOT_core_concat) - tmp9 := checkDerefVar(glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("glojure.core/let")}) - tmp11 := checkDerefVar(glojure_DOT_core_list) - tmp12 := checkDerefVar(glojure_DOT_core_apply) - tmp13 := checkDerefVar(glojure_DOT_core_vector) - tmp14 := checkDerefVar(glojure_DOT_core_seq) - tmp15 := checkDerefVar(glojure_DOT_core_concat) - tmp16 := checkDerefVar(glojure_DOT_core_list) - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("or__0__auto__")}) - tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_core_SLASH_let}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_apply) + tmp13 := checkDerefVar(var_glojure_DOT_core_vector) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{sym_or__0__auto__}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) tmp19 := lang.Apply(tmp18, []any{v5}) tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) tmp21 := lang.Apply(tmp14, []any{tmp20}) tmp22 := lang.Apply(tmp12, []any{tmp13, tmp21}) tmp23 := lang.Apply(tmp11, []any{tmp22}) - tmp24 := checkDerefVar(glojure_DOT_core_list) - tmp25 := checkDerefVar(glojure_DOT_core_seq) - tmp26 := checkDerefVar(glojure_DOT_core_concat) - tmp27 := checkDerefVar(glojure_DOT_core_list) - tmp28 := lang.Apply(tmp27, []any{lang.NewSymbol("if")}) - tmp29 := checkDerefVar(glojure_DOT_core_list) - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("or__0__auto__")}) - tmp31 := checkDerefVar(glojure_DOT_core_list) - tmp32 := lang.Apply(tmp31, []any{lang.NewSymbol("or__0__auto__")}) - tmp33 := checkDerefVar(glojure_DOT_core_list) - tmp34 := checkDerefVar(glojure_DOT_core_seq) - tmp35 := checkDerefVar(glojure_DOT_core_concat) - tmp36 := checkDerefVar(glojure_DOT_core_list) - tmp37 := lang.Apply(tmp36, []any{lang.NewSymbol("glojure.core/or")}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := checkDerefVar(var_glojure_DOT_core_seq) + tmp26 := checkDerefVar(var_glojure_DOT_core_concat) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{sym_if}) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{sym_or__0__auto__}) + tmp31 := checkDerefVar(var_glojure_DOT_core_list) + tmp32 := lang.Apply(tmp31, []any{sym_or__0__auto__}) + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := checkDerefVar(var_glojure_DOT_core_seq) + tmp35 := checkDerefVar(var_glojure_DOT_core_concat) + tmp36 := checkDerefVar(var_glojure_DOT_core_list) + tmp37 := lang.Apply(tmp36, []any{sym_glojure_DOT_core_SLASH_or}) tmp38 := lang.Apply(tmp35, []any{tmp37, v6}) tmp39 := lang.Apply(tmp34, []any{tmp38}) tmp40 := lang.Apply(tmp33, []any{tmp39}) @@ -37886,7 +38019,7 @@ func LoadNS() { return tmp45 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -37894,15 +38027,15 @@ func LoadNS() { } // parents { - tmp0 := lang.NewSymbol("parents").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"))), lang.NewKeyword("doc"), "Returns the immediate parents of tag, either via a Java type\n inheritance relationship or a relationship established via derive. h\n must be a hierarchy obtained from make-hierarchy, if not supplied\n defaults to the global hierarchy", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5564), lang.NewKeyword("end-line"), int(5564))).(*lang.Symbol) + tmp0 := sym_parents.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_tag), lang.NewVector(sym_h, sym_tag)), kw_doc, "Returns the immediate parents of tag, either via a Java type\n inheritance relationship or a relationship established via derive. h\n must be a hierarchy obtained from make-hierarchy, if not supplied\n defaults to the global hierarchy", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(5564), kw_end_DASH_line, int(5564))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_parents) - tmp5 := checkDerefVar(glojure_DOT_core_global_hierarchy) + tmp4 := checkDerefVar(var_glojure_DOT_core_parents) + tmp5 := checkDerefVar(var_glojure_DOT_core_global_DASH_hierarchy) tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) return tmp6 case 2: @@ -37910,22 +38043,22 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_not_empty) + tmp5 := checkDerefVar(var_glojure_DOT_core_not_DASH_empty) var tmp6 any { // let // let binding "tp" - tmp7 := checkDerefVar(glojure_DOT_core_get) - tmp8 := lang.Apply(lang.NewKeyword("parents"), []any{v3}) + tmp7 := checkDerefVar(var_glojure_DOT_core_get) + tmp8 := lang.Apply(kw_parents, []any{v3}) tmp9 := lang.Apply(tmp7, []any{tmp8, v4}) var v10 any = tmp9 _ = v10 var tmp11 any - tmp12 := checkDerefVar(glojure_DOT_core_class_QMARK_) + tmp12 := checkDerefVar(var_glojure_DOT_core_class_QMARK_) tmp13 := lang.Apply(tmp12, []any{v4}) if lang.IsTruthy(tmp13) { - tmp14 := checkDerefVar(glojure_DOT_core_into1) - tmp15 := checkDerefVar(glojure_DOT_core_set) - tmp16 := checkDerefVar(glojure_DOT_core_bases) + tmp14 := checkDerefVar(var_glojure_DOT_core_into1) + tmp15 := checkDerefVar(var_glojure_DOT_core_set) + tmp16 := checkDerefVar(var_glojure_DOT_core_bases) tmp17 := lang.Apply(tmp16, []any{v4}) tmp18 := lang.Apply(tmp15, []any{tmp17}) tmp19 := lang.Apply(tmp14, []any{tmp18, v10}) @@ -37938,10 +38071,11 @@ func LoadNS() { tmp7 := lang.Apply(tmp5, []any{tmp6}) return tmp7 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -37949,16 +38083,14 @@ func LoadNS() { } // parse-boolean { - tmp0 := lang.NewSymbol("parse-boolean").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse strings \"true\" or \"false\" and return a boolean, or nil if invalid", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7957), lang.NewKeyword("end-line"), int(7957))).(*lang.Symbol) + tmp0 := sym_parse_DASH_boolean.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_doc, "Parse strings \"true\" or \"false\" and return a boolean, or nil if invalid", kw_file, "glojure/core.glj", kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(7957), kw_end_DASH_line, int(7957))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any - tmp5 := checkDerefVar(glojure_DOT_core_string_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) tmp6 := lang.Apply(tmp5, []any{v3}) if lang.IsTruthy(tmp6) { var tmp7 any @@ -37969,14 +38101,14 @@ func LoadNS() { } // end let tmp4 = tmp7 } else { - tmp8 := checkDerefVar(glojure_DOT_core_parsing_err) + tmp8 := checkDerefVar(var_glojure_DOT_core_parsing_DASH_err) tmp9 := lang.Apply(tmp8, []any{v3}) tmp10 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp9}) panic(tmp10) } return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -37984,16 +38116,14 @@ func LoadNS() { } // parse-double { - tmp0 := lang.NewSymbol("parse-double").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse string with floating point components and return a Double value,\n or nil if parse fails.\n\n Grammar: https://docs.oracle.com/javase/8/docs/api/java/lang/Double.html#valueOf-java.lang.String-", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7935), lang.NewKeyword("end-line"), int(7935))).(*lang.Symbol) + tmp0 := sym_parse_DASH_double.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_doc, "Parse string with floating point components and return a Double value,\n or nil if parse fails.\n\n Grammar: https://docs.oracle.com/javase/8/docs/api/java/lang/Double.html#valueOf-java.lang.String-", kw_file, "glojure/core.glj", kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(7935), kw_end_DASH_line, int(7935))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any - tmp5 := checkDerefVar(glojure_DOT_core_string_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) tmp6 := lang.Apply(tmp5, []any{v3}) if lang.IsTruthy(tmp6) { var tmp7 any @@ -38013,14 +38143,14 @@ func LoadNS() { } // end let tmp4 = tmp7 } else { - tmp8 := checkDerefVar(glojure_DOT_core_parsing_err) + tmp8 := checkDerefVar(var_glojure_DOT_core_parsing_DASH_err) tmp9 := lang.Apply(tmp8, []any{v3}) tmp10 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp9}) panic(tmp10) } return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -38028,19 +38158,17 @@ func LoadNS() { } // parse-impls { - tmp0 := lang.NewSymbol("parse-impls").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(13), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(13), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("specs"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym_parse_DASH_impls.WithMeta(lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(13), kw_column, int(8), kw_end_DASH_line, int(13), kw_end_DASH_column, int(18), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_specs)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any { // let // let binding "ret" tmp5 := lang.NewMap() - tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(14), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(14), lang.NewKeyword("end-column"), int(15)) + tmp6 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(14), kw_column, int(14), kw_end_DASH_line, int(14), kw_end_DASH_column, int(15)) tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) if err != nil { panic(err) @@ -38052,22 +38180,22 @@ func LoadNS() { _ = v9 for { var tmp10 any - tmp11 := checkDerefVar(glojure_DOT_core_seq) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := lang.Apply(tmp11, []any{v9}) if lang.IsTruthy(tmp12) { - tmp14 := checkDerefVar(glojure_DOT_core_assoc) - tmp15 := checkDerefVar(glojure_DOT_core_first) + tmp14 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp15 := checkDerefVar(var_glojure_DOT_core_first) tmp16 := lang.Apply(tmp15, []any{v9}) - tmp17 := checkDerefVar(glojure_DOT_core_take_while) - tmp18 := checkDerefVar(glojure_DOT_core_seq_QMARK_) - tmp19 := checkDerefVar(glojure_DOT_core_next) + tmp17 := checkDerefVar(var_glojure_DOT_core_take_DASH_while) + tmp18 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp19 := checkDerefVar(var_glojure_DOT_core_next) tmp20 := lang.Apply(tmp19, []any{v9}) tmp21 := lang.Apply(tmp17, []any{tmp18, tmp20}) tmp22 := lang.Apply(tmp14, []any{v8, tmp16, tmp21}) var tmp13 any = tmp22 - tmp24 := checkDerefVar(glojure_DOT_core_drop_while) - tmp25 := checkDerefVar(glojure_DOT_core_seq_QMARK_) - tmp26 := checkDerefVar(glojure_DOT_core_next) + tmp24 := checkDerefVar(var_glojure_DOT_core_drop_DASH_while) + tmp25 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp26 := checkDerefVar(var_glojure_DOT_core_next) tmp27 := lang.Apply(tmp26, []any{v9}) tmp28 := lang.Apply(tmp24, []any{tmp25, tmp27}) var tmp23 any = tmp28 @@ -38083,7 +38211,7 @@ func LoadNS() { } // end let return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -38091,16 +38219,14 @@ func LoadNS() { } // parse-long { - tmp0 := lang.NewSymbol("parse-long").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse string of decimal digits with optional leading -/+ and return a\n Long value, or nil if parse fails", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7926), lang.NewKeyword("end-line"), int(7926))).(*lang.Symbol) + tmp0 := sym_parse_DASH_long.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_doc, "Parse string of decimal digits with optional leading -/+ and return a\n Long value, or nil if parse fails", kw_file, "glojure/core.glj", kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(7926), kw_end_DASH_line, int(7926))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any - tmp5 := checkDerefVar(glojure_DOT_core_string_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) tmp6 := lang.Apply(tmp5, []any{v3}) if lang.IsTruthy(tmp6) { var tmp7 any @@ -38120,14 +38246,14 @@ func LoadNS() { } // end let tmp4 = tmp7 } else { - tmp8 := checkDerefVar(glojure_DOT_core_parsing_err) + tmp8 := checkDerefVar(var_glojure_DOT_core_parsing_DASH_err) tmp9 := lang.Apply(tmp8, []any{v3}) tmp10 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp9}) panic(tmp10) } return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -38135,12 +38261,10 @@ func LoadNS() { } // parse-uuid { - tmp0 := lang.NewSymbol("parse-uuid").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Parse a string representing a UUID and return a java.util.UUID instance,\n or nil if parse fails.\n\n Grammar: https://docs.oracle.com/javase/8/docs/api/java/util/UUID.html#toString--", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7946), lang.NewKeyword("end-line"), int(7946))).(*lang.Symbol) + tmp0 := sym_parse_DASH_uuid.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_doc, "Parse a string representing a UUID and return a java.util.UUID instance,\n or nil if parse fails.\n\n Grammar: https://docs.oracle.com/javase/8/docs/api/java/util/UUID.html#toString--", kw_file, "glojure/core.glj", kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(7946), kw_end_DASH_line, int(7946))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any @@ -38163,18 +38287,18 @@ func LoadNS() { var v8 any = tmp7 _ = v8 // let binding "uuid" - tmp9 := checkDerefVar(glojure_DOT_core_nth) + tmp9 := checkDerefVar(var_glojure_DOT_core_nth) tmp10 := lang.Apply(tmp9, []any{v8, int64(0), nil}) var v11 any = tmp10 _ = v11 // let binding "err" - tmp12 := checkDerefVar(glojure_DOT_core_nth) + tmp12 := checkDerefVar(var_glojure_DOT_core_nth) tmp13 := lang.Apply(tmp12, []any{v8, int64(1), nil}) var v14 any = tmp13 _ = v14 var tmp15 any if lang.IsTruthy(v14) { - tmp16 := checkDerefVar(glojure_DOT_core_str) + tmp16 := checkDerefVar(var_glojure_DOT_core_str) tmp17 := lang.Apply(tmp16, []any{"Error parsing UUID: ", v14}) tmp18 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp17}) panic(tmp18) @@ -38187,7 +38311,7 @@ func LoadNS() { }() return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -38195,22 +38319,20 @@ func LoadNS() { } // parsing-err { - tmp0 := lang.NewSymbol("parsing-err").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Construct message for parsing for non-string parsing error", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(7921), lang.NewKeyword("end-line"), int(7921), lang.NewKeyword("private"), true)).(*lang.Symbol) + tmp0 := sym_parsing_DASH_err.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_val)), kw_doc, "Construct message for parsing for non-string parsing error", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(8), kw_line, int(7921), kw_end_DASH_line, int(7921), kw_private, true)).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_str) + tmp4 := checkDerefVar(var_glojure_DOT_core_str) var tmp5 any - tmp6 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp6 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) tmp7 := lang.Apply(tmp6, []any{v3}) if lang.IsTruthy(tmp7) { tmp5 = "nil" } else { - tmp8 := checkDerefVar(glojure_DOT_core_class) + tmp8 := checkDerefVar(var_glojure_DOT_core_class) tmp9 := lang.Apply(tmp8, []any{v3}) tmp10, ok := lang.FieldOrMethod(tmp9, "Name") if !ok { @@ -38228,7 +38350,7 @@ func LoadNS() { tmp12 := lang.Apply(tmp4, []any{"Expected string, got ", tmp5}) return tmp12 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -38236,7 +38358,7 @@ func LoadNS() { } // partial { - tmp0 := lang.NewSymbol("partial").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("arg1")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("arg1"), lang.NewSymbol("arg2")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("arg1"), lang.NewSymbol("arg2"), lang.NewSymbol("arg3")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("arg1"), lang.NewSymbol("arg2"), lang.NewSymbol("arg3"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Takes a function f and fewer than the normal arguments to f, and\n returns a fn that takes a variable number of additional args. When\n called, the returned function calls f with args + additional args.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2606), lang.NewKeyword("end-line"), int(2606))).(*lang.Symbol) + tmp0 := sym_partial.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_arg1), lang.NewVector(sym_f, sym_arg1, sym_arg2), lang.NewVector(sym_f, sym_arg1, sym_arg2, sym_arg3), lang.NewVector(sym_f, sym_arg1, sym_arg2, sym_arg3, sym__AMP_, sym_more)), kw_doc, "Takes a function f and fewer than the normal arguments to f, and\n returns a fn that takes a variable number of additional args. When\n called, the returned function calls f with args + additional args.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(2606), kw_end_DASH_line, int(2606))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -38277,9 +38399,7 @@ func LoadNS() { tmp9 := lang.Apply(v3, []any{v4, v6, v7, v8}) return tmp9 default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v6 := args[0] _ = v6 v7 := args[1] @@ -38288,12 +38408,12 @@ func LoadNS() { _ = v8 var v9 any = lang.NewList(args[3:]...) _ = v9 - tmp10 := checkDerefVar(glojure_DOT_core_apply) + tmp10 := checkDerefVar(var_glojure_DOT_core_apply) tmp11 := lang.Apply(tmp10, []any{v3, v4, v6, v7, v8, v9}) return tmp11 } }) - tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2614), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(2619), lang.NewKeyword("end-column"), int(48)) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2614), kw_column, int(4), kw_end_DASH_line, int(2619), kw_end_DASH_column, int(48)) tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) if err != nil { panic(err) @@ -38334,9 +38454,7 @@ func LoadNS() { tmp10 := lang.Apply(v3, []any{v4, v5, v7, v8, v9}) return tmp10 default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v7 := args[0] _ = v7 v8 := args[1] @@ -38345,12 +38463,12 @@ func LoadNS() { _ = v9 var v10 any = lang.NewList(args[3:]...) _ = v10 - tmp11 := checkDerefVar(glojure_DOT_core_apply) + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) tmp12 := lang.Apply(tmp11, []any{v3, v4, v5, v7, v8, v9, v10}) return tmp12 } }) - tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2621), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(2626), lang.NewKeyword("end-column"), int(53)) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2621), kw_column, int(4), kw_end_DASH_line, int(2626), kw_end_DASH_column, int(53)) tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) if err != nil { panic(err) @@ -38393,9 +38511,7 @@ func LoadNS() { tmp11 := lang.Apply(v3, []any{v4, v5, v6, v8, v9, v10}) return tmp11 default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v8 := args[0] _ = v8 v9 := args[1] @@ -38404,21 +38520,19 @@ func LoadNS() { _ = v10 var v11 any = lang.NewList(args[3:]...) _ = v11 - tmp12 := checkDerefVar(glojure_DOT_core_apply) + tmp12 := checkDerefVar(var_glojure_DOT_core_apply) tmp13 := lang.Apply(tmp12, []any{v3, v4, v5, v6, v8, v9, v10, v11}) return tmp13 } }) - tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2628), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(2633), lang.NewKeyword("end-column"), int(58)) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2628), kw_column, int(4), kw_end_DASH_line, int(2633), kw_end_DASH_column, int(58)) tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) if err != nil { panic(err) } return tmp9 default: - if len(args) < 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 4) v3 := args[0] _ = v3 v4 := args[1] @@ -38433,19 +38547,17 @@ func LoadNS() { tmp8 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var v9 any = lang.NewList(args[0:]...) _ = v9 - tmp10 := checkDerefVar(glojure_DOT_core_apply) - tmp11 := checkDerefVar(glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_apply) + tmp11 := checkDerefVar(var_glojure_DOT_core_concat) tmp12 := lang.Apply(tmp11, []any{v7, v9}) tmp13 := lang.Apply(tmp10, []any{v3, v4, v5, v6, tmp12}) return tmp13 } }) - tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2635), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(2635), lang.NewKeyword("end-column"), int(60)) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2635), kw_column, int(4), kw_end_DASH_line, int(2635), kw_end_DASH_column, int(60)) tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) if err != nil { panic(err) @@ -38453,7 +38565,7 @@ func LoadNS() { return tmp10 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -38461,7 +38573,7 @@ func LoadNS() { } // partition { - tmp0 := lang.NewSymbol("partition").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("pad"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of lists of n items each, at offsets step\n apart. If step is not supplied, defaults to n, i.e. the partitions\n do not overlap. If a pad collection is supplied, use its elements as\n necessary to complete last partition upto n items. In case there are\n not enough padding elements, return a partition with less than n items.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3177), lang.NewKeyword("end-line"), int(3177))).(*lang.Symbol) + tmp0 := sym_partition.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n, sym_coll), lang.NewVector(sym_n, sym_step, sym_coll), lang.NewVector(sym_n, sym_step, sym_pad, sym_coll)), kw_doc, "Returns a lazy sequence of lists of n items each, at offsets step\n apart. If step is not supplied, defaults to n, i.e. the partitions\n do not overlap. If a pad collection is supplied, use its elements as\n necessary to complete last partition upto n items. In case there are\n not enough padding elements, return a partition with less than n items.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(3177), kw_end_DASH_line, int(3177))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -38470,7 +38582,7 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_partition) + tmp5 := checkDerefVar(var_glojure_DOT_core_partition) tmp6 := lang.Apply(tmp5, []any{v3, v3, v4}) return tmp6 case 3: @@ -38482,13 +38594,11 @@ func LoadNS() { _ = v5 var tmp6 lang.FnFunc tmp6 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var tmp7 any { // let // let binding "temp__0__auto__" - tmp8 := checkDerefVar(glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) tmp9 := lang.Apply(tmp8, []any{v5}) var v10 any = tmp9 _ = v10 @@ -38502,21 +38612,21 @@ func LoadNS() { var tmp14 any { // let // let binding "p" - tmp15 := checkDerefVar(glojure_DOT_core_doall) - tmp16 := checkDerefVar(glojure_DOT_core_take) + tmp15 := checkDerefVar(var_glojure_DOT_core_doall) + tmp16 := checkDerefVar(var_glojure_DOT_core_take) tmp17 := lang.Apply(tmp16, []any{v3, v13}) tmp18 := lang.Apply(tmp15, []any{tmp17}) var v19 any = tmp18 _ = v19 var tmp20 any - tmp21 := checkDerefVar(glojure_DOT_core__EQ_) - tmp22 := checkDerefVar(glojure_DOT_core_count) + tmp21 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp22 := checkDerefVar(var_glojure_DOT_core_count) tmp23 := lang.Apply(tmp22, []any{v19}) tmp24 := lang.Apply(tmp21, []any{v3, tmp23}) if lang.IsTruthy(tmp24) { - tmp25 := checkDerefVar(glojure_DOT_core_cons) - tmp26 := checkDerefVar(glojure_DOT_core_partition) - tmp27 := checkDerefVar(glojure_DOT_core_nthrest) + tmp25 := checkDerefVar(var_glojure_DOT_core_cons) + tmp26 := checkDerefVar(var_glojure_DOT_core_partition) + tmp27 := checkDerefVar(var_glojure_DOT_core_nthrest) tmp28 := lang.Apply(tmp27, []any{v13, v4}) tmp29 := lang.Apply(tmp26, []any{v3, v4, tmp28}) tmp30 := lang.Apply(tmp25, []any{v19, tmp29}) @@ -38547,13 +38657,11 @@ func LoadNS() { _ = v6 var tmp7 lang.FnFunc tmp7 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var tmp8 any { // let // let binding "temp__0__auto__" - tmp9 := checkDerefVar(glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_seq) tmp10 := lang.Apply(tmp9, []any{v6}) var v11 any = tmp10 _ = v11 @@ -38567,29 +38675,29 @@ func LoadNS() { var tmp15 any { // let // let binding "p" - tmp16 := checkDerefVar(glojure_DOT_core_doall) - tmp17 := checkDerefVar(glojure_DOT_core_take) + tmp16 := checkDerefVar(var_glojure_DOT_core_doall) + tmp17 := checkDerefVar(var_glojure_DOT_core_take) tmp18 := lang.Apply(tmp17, []any{v3, v14}) tmp19 := lang.Apply(tmp16, []any{tmp18}) var v20 any = tmp19 _ = v20 var tmp21 any - tmp22 := checkDerefVar(glojure_DOT_core__EQ_) - tmp23 := checkDerefVar(glojure_DOT_core_count) + tmp22 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp23 := checkDerefVar(var_glojure_DOT_core_count) tmp24 := lang.Apply(tmp23, []any{v20}) tmp25 := lang.Apply(tmp22, []any{v3, tmp24}) if lang.IsTruthy(tmp25) { - tmp26 := checkDerefVar(glojure_DOT_core_cons) - tmp27 := checkDerefVar(glojure_DOT_core_partition) - tmp28 := checkDerefVar(glojure_DOT_core_nthrest) + tmp26 := checkDerefVar(var_glojure_DOT_core_cons) + tmp27 := checkDerefVar(var_glojure_DOT_core_partition) + tmp28 := checkDerefVar(var_glojure_DOT_core_nthrest) tmp29 := lang.Apply(tmp28, []any{v14, v4}) tmp30 := lang.Apply(tmp27, []any{v3, v4, v5, tmp29}) tmp31 := lang.Apply(tmp26, []any{v20, tmp30}) tmp21 = tmp31 } else { - tmp32 := checkDerefVar(glojure_DOT_core_list) - tmp33 := checkDerefVar(glojure_DOT_core_take) - tmp34 := checkDerefVar(glojure_DOT_core_concat) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := checkDerefVar(var_glojure_DOT_core_take) + tmp34 := checkDerefVar(var_glojure_DOT_core_concat) tmp35 := lang.Apply(tmp34, []any{v20, v5}) tmp36 := lang.Apply(tmp33, []any{v3, tmp35}) tmp37 := lang.Apply(tmp32, []any{tmp36}) @@ -38609,10 +38717,11 @@ func LoadNS() { tmp8 := lang.Apply(lang.NewLazySeq, []any{tmp7}) return tmp8 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -38620,7 +38729,7 @@ func LoadNS() { } // partition-all { - tmp0 := lang.NewSymbol("partition-all").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of lists like partition, but may include\n partitions with fewer than n items at the end. Returns a stateful\n transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7222), lang.NewKeyword("end-line"), int(7222))).(*lang.Symbol) + tmp0 := sym_partition_DASH_all.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n), lang.NewVector(sym_n, sym_coll), lang.NewVector(sym_n, sym_step, sym_coll)), kw_doc, "Returns a lazy sequence of lists like partition, but may include\n partitions with fewer than n items at the end. Returns a stateful\n transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(7222), kw_end_DASH_line, int(7222))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -38629,15 +38738,13 @@ func LoadNS() { _ = v3 var tmp4 lang.FnFunc tmp4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v5 := args[0] _ = v5 var tmp6 any { // let // let binding "a" - tmp7 := checkDerefVar(glojure_DOT_core_to_array) + tmp7 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) tmp8 := lang.Apply(tmp7, []any{v3}) tmp9 := lang.Apply(lang.NewArrayList, []any{tmp8}) var v10 any = tmp9 @@ -38672,7 +38779,7 @@ func LoadNS() { var tmp17 any { // let // let binding "v" - tmp18 := checkDerefVar(glojure_DOT_core_vec) + tmp18 := checkDerefVar(var_glojure_DOT_core_vec) tmp19, ok := lang.FieldOrMethod(v10, "toArray") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v10, "toArray"))) @@ -38699,7 +38806,7 @@ func LoadNS() { tmp24 = tmp23 } _ = tmp24 - tmp25 := checkDerefVar(glojure_DOT_core_unreduced) + tmp25 := checkDerefVar(var_glojure_DOT_core_unreduced) tmp26 := lang.Apply(v5, []any{v12, v22}) tmp27 := lang.Apply(tmp25, []any{tmp26}) tmp17 = tmp27 @@ -38724,7 +38831,7 @@ func LoadNS() { tmp15 := lang.Apply(tmp14, []any{v13}) _ = tmp15 var tmp16 any - tmp17 := checkDerefVar(glojure_DOT_core__EQ_) + tmp17 := checkDerefVar(var_glojure_DOT_core__EQ_) tmp18, ok := lang.FieldOrMethod(v10, "size") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v10, "size"))) @@ -38741,7 +38848,7 @@ func LoadNS() { var tmp21 any { // let // let binding "v" - tmp22 := checkDerefVar(glojure_DOT_core_vec) + tmp22 := checkDerefVar(var_glojure_DOT_core_vec) tmp23, ok := lang.FieldOrMethod(v10, "toArray") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v10, "toArray"))) @@ -38777,10 +38884,11 @@ func LoadNS() { } return tmp16 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7231), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7247), lang.NewKeyword("end-column"), int(23)) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7231), kw_column, int(8), kw_end_DASH_line, int(7247), kw_end_DASH_column, int(23)) tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) if err != nil { panic(err) @@ -38789,7 +38897,7 @@ func LoadNS() { } // end let return tmp6 }) - tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7229), lang.NewKeyword("column"), int(4), lang.NewKeyword("end-line"), int(7247), lang.NewKeyword("end-column"), int(25)) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7229), kw_column, int(4), kw_end_DASH_line, int(7247), kw_end_DASH_column, int(25)) tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) if err != nil { panic(err) @@ -38800,7 +38908,7 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_partition_all) + tmp5 := checkDerefVar(var_glojure_DOT_core_partition_DASH_all) tmp6 := lang.Apply(tmp5, []any{v3, v3, v4}) return tmp6 case 3: @@ -38812,13 +38920,11 @@ func LoadNS() { _ = v5 var tmp6 lang.FnFunc tmp6 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var tmp7 any { // let // let binding "temp__0__auto__" - tmp8 := checkDerefVar(glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) tmp9 := lang.Apply(tmp8, []any{v5}) var v10 any = tmp9 _ = v10 @@ -38832,15 +38938,15 @@ func LoadNS() { var tmp14 any { // let // let binding "seg" - tmp15 := checkDerefVar(glojure_DOT_core_doall) - tmp16 := checkDerefVar(glojure_DOT_core_take) + tmp15 := checkDerefVar(var_glojure_DOT_core_doall) + tmp16 := checkDerefVar(var_glojure_DOT_core_take) tmp17 := lang.Apply(tmp16, []any{v3, v13}) tmp18 := lang.Apply(tmp15, []any{tmp17}) var v19 any = tmp18 _ = v19 - tmp20 := checkDerefVar(glojure_DOT_core_cons) - tmp21 := checkDerefVar(glojure_DOT_core_partition_all) - tmp22 := checkDerefVar(glojure_DOT_core_nthrest) + tmp20 := checkDerefVar(var_glojure_DOT_core_cons) + tmp21 := checkDerefVar(var_glojure_DOT_core_partition_DASH_all) + tmp22 := checkDerefVar(var_glojure_DOT_core_nthrest) tmp23 := lang.Apply(tmp22, []any{v13, v4}) tmp24 := lang.Apply(tmp21, []any{v3, v4, tmp23}) tmp25 := lang.Apply(tmp20, []any{v19, tmp24}) @@ -38858,10 +38964,11 @@ func LoadNS() { tmp7 := lang.Apply(lang.NewLazySeq, []any{tmp6}) return tmp7 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -38869,7 +38976,7 @@ func LoadNS() { } // partition-by { - tmp0 := lang.NewSymbol("partition-by").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Applies f to each value in coll, splitting it each time f returns a\n new value. Returns a lazy seq of partitions. Returns a stateful\n transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7142), lang.NewKeyword("end-line"), int(7142))).(*lang.Symbol) + tmp0 := sym_partition_DASH_by.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_coll)), kw_doc, "Applies f to each value in coll, splitting it each time f returns a\n new value. Returns a lazy seq of partitions. Returns a stateful\n transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(7142), kw_end_DASH_line, int(7142))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -38878,9 +38985,7 @@ func LoadNS() { _ = v3 var tmp4 lang.FnFunc tmp4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v5 := args[0] _ = v5 var tmp6 any @@ -38889,8 +38994,8 @@ func LoadNS() { var v7 any = "unimplemented: new with non-constant class type" _ = v7 // let binding "pv" - tmp8 := checkDerefVar(glojure_DOT_core_volatile_BANG_) - tmp9 := lang.Apply(tmp8, []any{lang.NewKeyword("glojure.core/none")}) + tmp8 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) + tmp9 := lang.Apply(tmp8, []any{kw_glojure_DOT_core_SLASH_none}) var v10 any = tmp9 _ = v10 var tmp11 lang.FnFunc @@ -38923,7 +39028,7 @@ func LoadNS() { var tmp17 any { // let // let binding "v" - tmp18 := checkDerefVar(glojure_DOT_core_vec) + tmp18 := checkDerefVar(var_glojure_DOT_core_vec) tmp19, ok := lang.FieldOrMethod(v7, "toArray") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "toArray"))) @@ -38950,7 +39055,7 @@ func LoadNS() { tmp24 = tmp23 } _ = tmp24 - tmp25 := checkDerefVar(glojure_DOT_core_unreduced) + tmp25 := checkDerefVar(var_glojure_DOT_core_unreduced) tmp26 := lang.Apply(v5, []any{v12, v22}) tmp27 := lang.Apply(tmp25, []any{tmp26}) tmp17 = tmp27 @@ -38971,7 +39076,7 @@ func LoadNS() { var tmp14 any { // let // let binding "pval" - tmp15 := checkDerefVar(glojure_DOT_core_deref) + tmp15 := checkDerefVar(var_glojure_DOT_core_deref) tmp16 := lang.Apply(tmp15, []any{v10}) var v17 any = tmp16 _ = v17 @@ -38979,22 +39084,22 @@ func LoadNS() { tmp18 := lang.Apply(v3, []any{v13}) var v19 any = tmp18 _ = v19 - tmp20 := checkDerefVar(glojure_DOT_core_vreset_BANG_) + tmp20 := checkDerefVar(var_glojure_DOT_core_vreset_BANG_) tmp21 := lang.Apply(tmp20, []any{v10, v19}) _ = tmp21 var tmp22 any var tmp23 any { // let // let binding "or__0__auto__" - tmp24 := checkDerefVar(glojure_DOT_core_identical_QMARK_) - tmp25 := lang.Apply(tmp24, []any{v17, lang.NewKeyword("glojure.core/none")}) + tmp24 := checkDerefVar(var_glojure_DOT_core_identical_QMARK_) + tmp25 := lang.Apply(tmp24, []any{v17, kw_glojure_DOT_core_SLASH_none}) var v26 any = tmp25 _ = v26 var tmp27 any if lang.IsTruthy(v26) { tmp27 = v26 } else { - tmp28 := checkDerefVar(glojure_DOT_core__EQ_) + tmp28 := checkDerefVar(var_glojure_DOT_core__EQ_) tmp29 := lang.Apply(tmp28, []any{v19, v17}) tmp27 = tmp29 } @@ -39012,7 +39117,7 @@ func LoadNS() { var tmp26 any { // let // let binding "v" - tmp27 := checkDerefVar(glojure_DOT_core_vec) + tmp27 := checkDerefVar(var_glojure_DOT_core_vec) tmp28, ok := lang.FieldOrMethod(v7, "toArray") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "toArray"))) @@ -39046,7 +39151,7 @@ func LoadNS() { var v36 any = tmp35 _ = v36 var tmp37 any - tmp38 := checkDerefVar(glojure_DOT_core_reduced_QMARK_) + tmp38 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) tmp39 := lang.Apply(tmp38, []any{v36}) if lang.IsTruthy(tmp39) { } else { @@ -39068,10 +39173,11 @@ func LoadNS() { } // end let return tmp14 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7152), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(7176), lang.NewKeyword("end-column"), int(28)) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7152), kw_column, int(7), kw_end_DASH_line, int(7176), kw_end_DASH_column, int(28)) tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) if err != nil { panic(err) @@ -39080,7 +39186,7 @@ func LoadNS() { } // end let return tmp6 }) - tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7149), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(7176), lang.NewKeyword("end-column"), int(30)) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7149), kw_column, int(3), kw_end_DASH_line, int(7176), kw_end_DASH_column, int(30)) tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) if err != nil { panic(err) @@ -39093,13 +39199,11 @@ func LoadNS() { _ = v4 var tmp5 lang.FnFunc tmp5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var tmp6 any { // let // let binding "temp__0__auto__" - tmp7 := checkDerefVar(glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) tmp8 := lang.Apply(tmp7, []any{v4}) var v9 any = tmp8 _ = v9 @@ -39113,7 +39217,7 @@ func LoadNS() { var tmp13 any { // let // let binding "fst" - tmp14 := checkDerefVar(glojure_DOT_core_first) + tmp14 := checkDerefVar(var_glojure_DOT_core_first) tmp15 := lang.Apply(tmp14, []any{v12}) var v16 any = tmp15 _ = v16 @@ -39122,40 +39226,36 @@ func LoadNS() { var v18 any = tmp17 _ = v18 // let binding "run" - tmp19 := checkDerefVar(glojure_DOT_core_cons) - tmp20 := checkDerefVar(glojure_DOT_core_take_while) + tmp19 := checkDerefVar(var_glojure_DOT_core_cons) + tmp20 := checkDerefVar(var_glojure_DOT_core_take_DASH_while) var tmp21 lang.FnFunc tmp21 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v22 := args[0] _ = v22 - tmp23 := checkDerefVar(glojure_DOT_core__EQ_) + tmp23 := checkDerefVar(var_glojure_DOT_core__EQ_) tmp24 := lang.Apply(v3, []any{v22}) tmp25 := lang.Apply(tmp23, []any{v18, tmp24}) return tmp25 }) - tmp22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7182), lang.NewKeyword("column"), int(41), lang.NewKeyword("end-line"), int(7182), lang.NewKeyword("end-column"), int(53)) + tmp22 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7182), kw_column, int(41), kw_end_DASH_line, int(7182), kw_end_DASH_column, int(53)) tmp23, err := lang.WithMeta(tmp21, tmp22.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp24 := checkDerefVar(glojure_DOT_core_next) + tmp24 := checkDerefVar(var_glojure_DOT_core_next) tmp25 := lang.Apply(tmp24, []any{v12}) tmp26 := lang.Apply(tmp20, []any{tmp23, tmp25}) tmp27 := lang.Apply(tmp19, []any{v16, tmp26}) var v28 any = tmp27 _ = v28 - tmp29 := checkDerefVar(glojure_DOT_core_cons) - tmp30 := checkDerefVar(glojure_DOT_core_partition_by) + tmp29 := checkDerefVar(var_glojure_DOT_core_cons) + tmp30 := checkDerefVar(var_glojure_DOT_core_partition_DASH_by) var tmp31 lang.FnFunc tmp31 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - tmp32 := checkDerefVar(glojure_DOT_core_drop) - tmp33 := checkDerefVar(glojure_DOT_core_count) + checkArity(args, 0) + tmp32 := checkDerefVar(var_glojure_DOT_core_drop) + tmp33 := checkDerefVar(var_glojure_DOT_core_count) tmp34 := lang.Apply(tmp33, []any{v28}) tmp35 := lang.Apply(tmp32, []any{tmp34, v12}) return tmp35 @@ -39177,10 +39277,11 @@ func LoadNS() { tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) return tmp6 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -39188,7 +39289,7 @@ func LoadNS() { } // partitionv { - tmp0 := lang.NewSymbol("partitionv").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("pad"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of vectors of n items each, at offsets step\n apart. If step is not supplied, defaults to n, i.e. the partitions\n do not overlap. If a pad collection is supplied, use its elements as\n necessary to complete last partition upto n items. In case there are\n not enough padding elements, return a partition with less than n items.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7262), lang.NewKeyword("end-line"), int(7262))).(*lang.Symbol) + tmp0 := sym_partitionv.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n, sym_coll), lang.NewVector(sym_n, sym_step, sym_coll), lang.NewVector(sym_n, sym_step, sym_pad, sym_coll)), kw_doc, "Returns a lazy sequence of vectors of n items each, at offsets step\n apart. If step is not supplied, defaults to n, i.e. the partitions\n do not overlap. If a pad collection is supplied, use its elements as\n necessary to complete last partition upto n items. In case there are\n not enough padding elements, return a partition with less than n items.", kw_file, "glojure/core.glj", kw_added, "1.12", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(7262), kw_end_DASH_line, int(7262))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -39197,7 +39298,7 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_partitionv) + tmp5 := checkDerefVar(var_glojure_DOT_core_partitionv) tmp6 := lang.Apply(tmp5, []any{v3, v3, v4}) return tmp6 case 3: @@ -39209,13 +39310,11 @@ func LoadNS() { _ = v5 var tmp6 lang.FnFunc tmp6 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var tmp7 any { // let // let binding "temp__0__auto__" - tmp8 := checkDerefVar(glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) tmp9 := lang.Apply(tmp8, []any{v5}) var v10 any = tmp9 _ = v10 @@ -39229,27 +39328,27 @@ func LoadNS() { var tmp14 any { // let // let binding "p" - tmp15 := checkDerefVar(glojure_DOT_core_into) + tmp15 := checkDerefVar(var_glojure_DOT_core_into) tmp16 := lang.NewVector() - tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7274), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(7274), lang.NewKeyword("end-column"), int(23)) + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7274), kw_column, int(22), kw_end_DASH_line, int(7274), kw_end_DASH_column, int(23)) tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp19 := checkDerefVar(glojure_DOT_core_take) + tmp19 := checkDerefVar(var_glojure_DOT_core_take) tmp20 := lang.Apply(tmp19, []any{v3}) tmp21 := lang.Apply(tmp15, []any{tmp18, tmp20, v13}) var v22 any = tmp21 _ = v22 var tmp23 any - tmp24 := checkDerefVar(glojure_DOT_core__EQ_) - tmp25 := checkDerefVar(glojure_DOT_core_count) + tmp24 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp25 := checkDerefVar(var_glojure_DOT_core_count) tmp26 := lang.Apply(tmp25, []any{v22}) tmp27 := lang.Apply(tmp24, []any{v3, tmp26}) if lang.IsTruthy(tmp27) { - tmp28 := checkDerefVar(glojure_DOT_core_cons) - tmp29 := checkDerefVar(glojure_DOT_core_partitionv) - tmp30 := checkDerefVar(glojure_DOT_core_nthrest) + tmp28 := checkDerefVar(var_glojure_DOT_core_cons) + tmp29 := checkDerefVar(var_glojure_DOT_core_partitionv) + tmp30 := checkDerefVar(var_glojure_DOT_core_nthrest) tmp31 := lang.Apply(tmp30, []any{v13, v4}) tmp32 := lang.Apply(tmp29, []any{v3, v4, tmp31}) tmp33 := lang.Apply(tmp28, []any{v22, tmp32}) @@ -39280,13 +39379,11 @@ func LoadNS() { _ = v6 var tmp7 lang.FnFunc tmp7 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var tmp8 any { // let // let binding "temp__0__auto__" - tmp9 := checkDerefVar(glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_seq) tmp10 := lang.Apply(tmp9, []any{v6}) var v11 any = tmp10 _ = v11 @@ -39300,43 +39397,43 @@ func LoadNS() { var tmp15 any { // let // let binding "p" - tmp16 := checkDerefVar(glojure_DOT_core_into) + tmp16 := checkDerefVar(var_glojure_DOT_core_into) tmp17 := lang.NewVector() - tmp18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7280), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(7280), lang.NewKeyword("end-column"), int(23)) + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7280), kw_column, int(22), kw_end_DASH_line, int(7280), kw_end_DASH_column, int(23)) tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp20 := checkDerefVar(glojure_DOT_core_take) + tmp20 := checkDerefVar(var_glojure_DOT_core_take) tmp21 := lang.Apply(tmp20, []any{v3}) tmp22 := lang.Apply(tmp16, []any{tmp19, tmp21, v14}) var v23 any = tmp22 _ = v23 var tmp24 any - tmp25 := checkDerefVar(glojure_DOT_core__EQ_) - tmp26 := checkDerefVar(glojure_DOT_core_count) + tmp25 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp26 := checkDerefVar(var_glojure_DOT_core_count) tmp27 := lang.Apply(tmp26, []any{v23}) tmp28 := lang.Apply(tmp25, []any{v3, tmp27}) if lang.IsTruthy(tmp28) { - tmp29 := checkDerefVar(glojure_DOT_core_cons) - tmp30 := checkDerefVar(glojure_DOT_core_partitionv) - tmp31 := checkDerefVar(glojure_DOT_core_nthrest) + tmp29 := checkDerefVar(var_glojure_DOT_core_cons) + tmp30 := checkDerefVar(var_glojure_DOT_core_partitionv) + tmp31 := checkDerefVar(var_glojure_DOT_core_nthrest) tmp32 := lang.Apply(tmp31, []any{v14, v4}) tmp33 := lang.Apply(tmp30, []any{v3, v4, v5, tmp32}) tmp34 := lang.Apply(tmp29, []any{v23, tmp33}) tmp24 = tmp34 } else { - tmp35 := checkDerefVar(glojure_DOT_core_list) - tmp36 := checkDerefVar(glojure_DOT_core_into) + tmp35 := checkDerefVar(var_glojure_DOT_core_list) + tmp36 := checkDerefVar(var_glojure_DOT_core_into) tmp37 := lang.NewVector() - tmp38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7283), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(7283), lang.NewKeyword("end-column"), int(25)) + tmp38 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7283), kw_column, int(24), kw_end_DASH_line, int(7283), kw_end_DASH_column, int(25)) tmp39, err := lang.WithMeta(tmp37, tmp38.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp40 := checkDerefVar(glojure_DOT_core_take) + tmp40 := checkDerefVar(var_glojure_DOT_core_take) tmp41 := lang.Apply(tmp40, []any{v3}) - tmp42 := checkDerefVar(glojure_DOT_core_concat) + tmp42 := checkDerefVar(var_glojure_DOT_core_concat) tmp43 := lang.Apply(tmp42, []any{v23, v5}) tmp44 := lang.Apply(tmp36, []any{tmp39, tmp41, tmp43}) tmp45 := lang.Apply(tmp35, []any{tmp44}) @@ -39356,10 +39453,11 @@ func LoadNS() { tmp8 := lang.Apply(lang.NewLazySeq, []any{tmp7}) return tmp8 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -39367,14 +39465,14 @@ func LoadNS() { } // partitionv-all { - tmp0 := lang.NewSymbol("partitionv-all").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("step"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of vector partitions, but may include\n partitions with fewer than n items at the end.\n Returns a stateful transducer when no collection is provided.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7285), lang.NewKeyword("end-line"), int(7285))).(*lang.Symbol) + tmp0 := sym_partitionv_DASH_all.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n), lang.NewVector(sym_n, sym_coll), lang.NewVector(sym_n, sym_step, sym_coll)), kw_doc, "Returns a lazy sequence of vector partitions, but may include\n partitions with fewer than n items at the end.\n Returns a stateful transducer when no collection is provided.", kw_file, "glojure/core.glj", kw_added, "1.12", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(7285), kw_end_DASH_line, int(7285))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_partition_all) + tmp4 := checkDerefVar(var_glojure_DOT_core_partition_DASH_all) tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 case 2: @@ -39382,7 +39480,7 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_partitionv_all) + tmp5 := checkDerefVar(var_glojure_DOT_core_partitionv_DASH_all) tmp6 := lang.Apply(tmp5, []any{v3, v3, v4}) return tmp6 case 3: @@ -39394,13 +39492,11 @@ func LoadNS() { _ = v5 var tmp6 lang.FnFunc tmp6 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var tmp7 any { // let // let binding "temp__0__auto__" - tmp8 := checkDerefVar(glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) tmp9 := lang.Apply(tmp8, []any{v5}) var v10 any = tmp9 _ = v10 @@ -39414,21 +39510,21 @@ func LoadNS() { var tmp14 any { // let // let binding "seg" - tmp15 := checkDerefVar(glojure_DOT_core_into) + tmp15 := checkDerefVar(var_glojure_DOT_core_into) tmp16 := lang.NewVector() - tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7297), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(7297), lang.NewKeyword("end-column"), int(25)) + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7297), kw_column, int(24), kw_end_DASH_line, int(7297), kw_end_DASH_column, int(25)) tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp19 := checkDerefVar(glojure_DOT_core_take) + tmp19 := checkDerefVar(var_glojure_DOT_core_take) tmp20 := lang.Apply(tmp19, []any{v3}) tmp21 := lang.Apply(tmp15, []any{tmp18, tmp20, v5}) var v22 any = tmp21 _ = v22 - tmp23 := checkDerefVar(glojure_DOT_core_cons) - tmp24 := checkDerefVar(glojure_DOT_core_partitionv_all) - tmp25 := checkDerefVar(glojure_DOT_core_drop) + tmp23 := checkDerefVar(var_glojure_DOT_core_cons) + tmp24 := checkDerefVar(var_glojure_DOT_core_partitionv_DASH_all) + tmp25 := checkDerefVar(var_glojure_DOT_core_drop) tmp26 := lang.Apply(tmp25, []any{v4, v13}) tmp27 := lang.Apply(tmp24, []any{v3, v4, tmp26}) tmp28 := lang.Apply(tmp23, []any{v22, tmp27}) @@ -39446,10 +39542,11 @@ func LoadNS() { tmp7 := lang.Apply(lang.NewLazySeq, []any{tmp6}) return tmp7 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -39457,28 +39554,24 @@ func LoadNS() { } // pcalls { - tmp0 := lang.NewSymbol("pcalls").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("fns"))), lang.NewKeyword("doc"), "Executes the no-arg fns in parallel, returning a lazy sequence of\n their values", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7056), lang.NewKeyword("end-line"), int(7056))).(*lang.Symbol) + tmp0 := sym_pcalls.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_fns)), kw_doc, "Executes the no-arg fns in parallel, returning a lazy sequence of\n their values", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(7056), kw_end_DASH_line, int(7056))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_pmap) + tmp4 := checkDerefVar(var_glojure_DOT_core_pmap) var tmp5 lang.FnFunc tmp5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v6 := args[0] _ = v6 tmp7 := lang.Apply(v6, nil) return tmp7 }) - tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7061), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(7061), lang.NewKeyword("end-column"), int(20)) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7061), kw_column, int(17), kw_end_DASH_line, int(7061), kw_end_DASH_column, int(20)) tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) if err != nil { panic(err) @@ -39487,7 +39580,7 @@ func LoadNS() { return tmp8 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -39495,12 +39588,10 @@ func LoadNS() { } // peek { - tmp0 := lang.NewSymbol("peek").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "For a list or queue, same as first, for a vector, same as, but much\n more efficient than, last. If the collection is empty, returns nil.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1455), lang.NewKeyword("end-line"), int(1455))).(*lang.Symbol) + tmp0 := sym_peek.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "For a list or queue, same as first, for a vector, same as, but much\n more efficient than, last. If the collection is empty, returns nil.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1455), kw_end_DASH_line, int(1455))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4, _ := lang.FieldOrMethod(runtime7.RT, "Peek") @@ -39510,7 +39601,7 @@ func LoadNS() { tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -39518,12 +39609,10 @@ func LoadNS() { } // persistent! { - tmp0 := lang.NewSymbol("persistent!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a new, persistent version of the transient collection, in\n constant time. The transient collection cannot be used after this\n call, any such use will throw an exception.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3350), lang.NewKeyword("end-line"), int(3350))).(*lang.Symbol) + tmp0 := sym_persistent_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a new, persistent version of the transient collection, in\n constant time. The transient collection cannot be used after this\n call, any such use will throw an exception.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(3350), kw_end_DASH_line, int(3350))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4, ok := lang.FieldOrMethod(v3, "Persistent") @@ -39539,7 +39628,7 @@ func LoadNS() { } return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -39547,7 +39636,7 @@ func LoadNS() { } // pmap { - tmp0 := lang.NewSymbol("pmap").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Like map, except f is applied in parallel. Semi-lazy in that the\n parallel computation stays ahead of the consumption, but doesn't\n realize the entire result unless required. Only useful for\n computationally intensive functions where the time of f dominates\n the coordination overhead.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7031), lang.NewKeyword("end-line"), int(7031))).(*lang.Symbol) + tmp0 := sym_pmap.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_coll), lang.NewVector(sym_f, sym_coll, sym__AMP_, sym_colls)), kw_doc, "Like map, except f is applied in parallel. Semi-lazy in that the\n parallel computation stays ahead of the consumption, but doesn't\n realize the entire result unless required. Only useful for\n computationally intensive functions where the time of f dominates\n the coordination overhead.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(7031), kw_end_DASH_line, int(7031))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -39559,33 +39648,29 @@ func LoadNS() { var tmp5 any { // let // let binding "n" - tmp6 := checkDerefVar(glojure_DOT_core__PLUS_) + tmp6 := checkDerefVar(var_glojure_DOT_core__PLUS_) tmp7 := lang.Apply(runtime14.NumCPU, nil) tmp8 := lang.Apply(tmp6, []any{int64(2), tmp7}) var v9 any = tmp8 _ = v9 // let binding "rets" - tmp10 := checkDerefVar(glojure_DOT_core_map) + tmp10 := checkDerefVar(var_glojure_DOT_core_map) var tmp11 lang.FnFunc tmp11 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v12 := args[0] _ = v12 - tmp13 := checkDerefVar(glojure_DOT_core_future_call) + tmp13 := checkDerefVar(var_glojure_DOT_core_future_DASH_call) var tmp14 lang.FnFunc tmp14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) tmp15 := lang.Apply(v3, []any{v12}) return tmp15 }) tmp15 := lang.Apply(tmp13, []any{tmp14}) return tmp15 }) - tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7041), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7041), lang.NewKeyword("end-column"), int(34)) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7041), kw_column, int(20), kw_end_DASH_line, int(7041), kw_end_DASH_column, int(34)) tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) if err != nil { panic(err) @@ -39598,9 +39683,7 @@ func LoadNS() { { // function step var v17 lang.FnFunc tmp16 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v18 := args[0] _ = v18 v19 := args[1] @@ -39611,17 +39694,17 @@ func LoadNS() { var v21 any = v18 _ = v21 // let binding "seq__336" - tmp22 := checkDerefVar(glojure_DOT_core_seq) + tmp22 := checkDerefVar(var_glojure_DOT_core_seq) tmp23 := lang.Apply(tmp22, []any{v21}) var v24 any = tmp23 _ = v24 // let binding "first__337" - tmp25 := checkDerefVar(glojure_DOT_core_first) + tmp25 := checkDerefVar(var_glojure_DOT_core_first) tmp26 := lang.Apply(tmp25, []any{v24}) var v27 any = tmp26 _ = v27 // let binding "seq__336" - tmp28 := checkDerefVar(glojure_DOT_core_next) + tmp28 := checkDerefVar(var_glojure_DOT_core_next) tmp29 := lang.Apply(tmp28, []any{v24}) var v30 any = tmp29 _ = v30 @@ -39636,13 +39719,11 @@ func LoadNS() { _ = v33 var tmp34 lang.FnFunc tmp34 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var tmp35 any { // let // let binding "temp__0__auto__" - tmp36 := checkDerefVar(glojure_DOT_core_seq) + tmp36 := checkDerefVar(var_glojure_DOT_core_seq) tmp37 := lang.Apply(tmp36, []any{v19}) var v38 any = tmp37 _ = v38 @@ -39653,10 +39734,10 @@ func LoadNS() { // let binding "s" var v41 any = v38 _ = v41 - tmp42 := checkDerefVar(glojure_DOT_core_cons) - tmp43 := checkDerefVar(glojure_DOT_core_deref) + tmp42 := checkDerefVar(var_glojure_DOT_core_cons) + tmp43 := checkDerefVar(var_glojure_DOT_core_deref) tmp44 := lang.Apply(tmp43, []any{v31}) - tmp45 := checkDerefVar(glojure_DOT_core_rest) + tmp45 := checkDerefVar(var_glojure_DOT_core_rest) tmp46 := lang.Apply(tmp45, []any{v41}) tmp47 := lang.Apply(v17, []any{v32, tmp46}) tmp48 := lang.Apply(tmp42, []any{tmp44, tmp47}) @@ -39664,8 +39745,8 @@ func LoadNS() { } // end let tmp39 = tmp40 } else { - tmp41 := checkDerefVar(glojure_DOT_core_map) - tmp42 := checkDerefVar(glojure_DOT_core_deref) + tmp41 := checkDerefVar(var_glojure_DOT_core_map) + tmp42 := checkDerefVar(var_glojure_DOT_core_deref) tmp43 := lang.Apply(tmp41, []any{tmp42, v33}) tmp39 = tmp43 } @@ -39681,23 +39762,21 @@ func LoadNS() { v17 = tmp16 _ = v17 } - tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7042), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(7046), lang.NewKeyword("end-column"), int(36)) + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7042), kw_column, int(15), kw_end_DASH_line, int(7046), kw_end_DASH_column, int(36)) tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) if err != nil { panic(err) } var v19 any = tmp18 _ = v19 - tmp20 := checkDerefVar(glojure_DOT_core_drop) + tmp20 := checkDerefVar(var_glojure_DOT_core_drop) tmp21 := lang.Apply(tmp20, []any{v9, v15}) tmp22 := lang.Apply(v19, []any{v15, tmp21}) tmp5 = tmp22 } // end let return tmp5 default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -39711,35 +39790,31 @@ func LoadNS() { { // function step var v8 lang.FnFunc tmp7 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v9 := args[0] _ = v9 var tmp10 lang.FnFunc tmp10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var tmp11 any { // let // let binding "ss" - tmp12 := checkDerefVar(glojure_DOT_core_map) - tmp13 := checkDerefVar(glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_map) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) tmp14 := lang.Apply(tmp12, []any{tmp13, v9}) var v15 any = tmp14 _ = v15 var tmp16 any - tmp17 := checkDerefVar(glojure_DOT_core_every_QMARK_) - tmp18 := checkDerefVar(glojure_DOT_core_identity) + tmp17 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + tmp18 := checkDerefVar(var_glojure_DOT_core_identity) tmp19 := lang.Apply(tmp17, []any{tmp18, v15}) if lang.IsTruthy(tmp19) { - tmp20 := checkDerefVar(glojure_DOT_core_cons) - tmp21 := checkDerefVar(glojure_DOT_core_map) - tmp22 := checkDerefVar(glojure_DOT_core_first) + tmp20 := checkDerefVar(var_glojure_DOT_core_cons) + tmp21 := checkDerefVar(var_glojure_DOT_core_map) + tmp22 := checkDerefVar(var_glojure_DOT_core_first) tmp23 := lang.Apply(tmp21, []any{tmp22, v15}) - tmp24 := checkDerefVar(glojure_DOT_core_map) - tmp25 := checkDerefVar(glojure_DOT_core_rest) + tmp24 := checkDerefVar(var_glojure_DOT_core_map) + tmp25 := checkDerefVar(var_glojure_DOT_core_rest) tmp26 := lang.Apply(tmp24, []any{tmp25, v15}) tmp27 := lang.Apply(v8, []any{tmp26}) tmp28 := lang.Apply(tmp20, []any{tmp23, tmp27}) @@ -39756,31 +39831,29 @@ func LoadNS() { v8 = tmp7 _ = v8 } - tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7049), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(7053), lang.NewKeyword("end-column"), int(67)) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7049), kw_column, int(15), kw_end_DASH_line, int(7053), kw_end_DASH_column, int(67)) tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) if err != nil { panic(err) } var v10 any = tmp9 _ = v10 - tmp11 := checkDerefVar(glojure_DOT_core_pmap) + tmp11 := checkDerefVar(var_glojure_DOT_core_pmap) var tmp12 lang.FnFunc tmp12 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v13 := args[0] _ = v13 - tmp14 := checkDerefVar(glojure_DOT_core_apply) + tmp14 := checkDerefVar(var_glojure_DOT_core_apply) tmp15 := lang.Apply(tmp14, []any{v3, v13}) return tmp15 }) - tmp13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7054), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(7054), lang.NewKeyword("end-column"), int(23)) + tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7054), kw_column, int(12), kw_end_DASH_line, int(7054), kw_end_DASH_column, int(23)) tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp15 := checkDerefVar(glojure_DOT_core_cons) + tmp15 := checkDerefVar(var_glojure_DOT_core_cons) tmp16 := lang.Apply(tmp15, []any{v4, v5}) tmp17 := lang.Apply(v10, []any{tmp16}) tmp18 := lang.Apply(tmp11, []any{tmp14, tmp17}) @@ -39789,7 +39862,7 @@ func LoadNS() { return tmp6 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -39797,12 +39870,10 @@ func LoadNS() { } // pop { - tmp0 := lang.NewSymbol("pop").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "For a list or queue, returns a new list/queue without the first\n item, for a vector, returns a new vector without the last item. If\n the collection is empty, throws an exception. Note - not the same\n as next/butlast.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1462), lang.NewKeyword("end-line"), int(1462))).(*lang.Symbol) + tmp0 := sym_pop.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "For a list or queue, returns a new list/queue without the first\n item, for a vector, returns a new vector without the last item. If\n the collection is empty, throws an exception. Note - not the same\n as next/butlast.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(1462), kw_end_DASH_line, int(1462))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4, _ := lang.FieldOrMethod(runtime7.RT, "Pop") @@ -39812,7 +39883,7 @@ func LoadNS() { tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -39820,12 +39891,10 @@ func LoadNS() { } // pop! { - tmp0 := lang.NewSymbol("pop!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Removes the last item from a transient vector. If\n the collection is empty, throws an exception. Returns coll", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3393), lang.NewKeyword("end-line"), int(3393))).(*lang.Symbol) + tmp0 := sym_pop_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Removes the last item from a transient vector. If\n the collection is empty, throws an exception. Returns coll", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3393), kw_end_DASH_line, int(3393))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4, ok := lang.FieldOrMethod(v3, "pop") @@ -39841,7 +39910,7 @@ func LoadNS() { } return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -39849,16 +39918,14 @@ func LoadNS() { } // pop-thread-bindings { - tmp0 := lang.NewSymbol("pop-thread-bindings").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Pop one set of bindings pushed with push-binding before. It is an error to\n pop bindings without pushing before.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1929), lang.NewKeyword("end-line"), int(1929))).(*lang.Symbol) + tmp0 := sym_pop_DASH_thread_DASH_bindings.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Pop one set of bindings pushed with push-binding before. It is an error to\n pop bindings without pushing before.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(25), kw_column, int(7), kw_line, int(1929), kw_end_DASH_line, int(1929))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) tmp3 := lang.Apply(lang.PopThreadBindings, nil) return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -39866,24 +39933,22 @@ func LoadNS() { } // pos-int? { - tmp0 := lang.NewSymbol("pos-int?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a positive fixed precision integer", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1403), lang.NewKeyword("end-line"), int(1403))).(*lang.Symbol) + tmp0 := sym_pos_DASH_int_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a positive fixed precision integer", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(1403), kw_end_DASH_line, int(1403))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any { // let // let binding "and__0__auto__" - tmp5 := checkDerefVar(glojure_DOT_core_int_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) tmp6 := lang.Apply(tmp5, []any{v3}) var v7 any = tmp6 _ = v7 var tmp8 any if lang.IsTruthy(v7) { - tmp9 := checkDerefVar(glojure_DOT_core_pos_QMARK_) + tmp9 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) tmp10 := lang.Apply(tmp9, []any{v3}) tmp8 = tmp10 } else { @@ -39893,7 +39958,7 @@ func LoadNS() { } // end let return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -39905,23 +39970,21 @@ func LoadNS() { { // function pos?__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) - tmp5 := checkDerefVar(glojure_DOT_core_concat) - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := checkDerefVar(glojure_DOT_core_seq) - tmp12 := checkDerefVar(glojure_DOT_core_concat) - tmp13 := checkDerefVar(glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/IsPos")}) - tmp15 := checkDerefVar(glojure_DOT_core_list) + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_IsPos}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) tmp18 := lang.Apply(tmp11, []any{tmp17}) @@ -39933,12 +39996,10 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("pos?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns true if num is greater than zero, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1252), lang.NewKeyword("end-line"), int(1252))).(*lang.Symbol) + tmp0 := sym_pos_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_num)), kw_inline, tmp1, kw_doc, "Returns true if num is greater than zero, else false", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1252), kw_end_DASH_line, int(1252))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 tmp5, _ := lang.FieldOrMethod(lang.Numbers, "IsPos") @@ -39948,7 +40009,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v4}) return tmp6 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -39956,7 +40017,7 @@ func LoadNS() { } // pr { - tmp0 := lang.NewSymbol("pr").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Prints the object(s) to the output stream that is the current value\n of *out*. Prints the object(s), separated by spaces if there is\n more than one. By default, pr and prn print in a way that objects\n can be read by the reader", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3678), lang.NewKeyword("end-line"), int(3678), lang.NewKeyword("dynamic"), true)).(*lang.Symbol) + tmp0 := sym_pr.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_x), lang.NewVector(sym_x, sym__AMP_, sym_more)), kw_doc, "Prints the object(s) to the output stream that is the current value\n of *out*. Prints the object(s), separated by spaces if there is\n more than one. By default, pr and prn print in a way that objects\n can be read by the reader", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(7), kw_line, int(3678), kw_end_DASH_line, int(3678), kw_dynamic, true)).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -39965,29 +40026,27 @@ func LoadNS() { case 1: v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_pr_on) - tmp5 := checkDerefVar(glojure_DOT_core__STAR_out_STAR_) + tmp4 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_out_STAR_) tmp6 := lang.Apply(tmp4, []any{v3, tmp5}) return tmp6 default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var v4 any = lang.NewList(args[1:]...) _ = v4 recur_loop_671: - tmp5 := checkDerefVar(glojure_DOT_core_pr) + tmp5 := checkDerefVar(var_glojure_DOT_core_pr) tmp6 := lang.Apply(tmp5, []any{v3}) _ = tmp6 - tmp7 := checkDerefVar(glojure_DOT_core__STAR_out_STAR_) + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_out_STAR_) tmp8 := lang.Apply(lang.AppendWriter, []any{tmp7, lang.NewChar(32)}) _ = tmp8 var tmp9 any { // let // let binding "temp__0__auto__" - tmp10 := checkDerefVar(glojure_DOT_core_next) + tmp10 := checkDerefVar(var_glojure_DOT_core_next) tmp11 := lang.Apply(tmp10, []any{v4}) var v12 any = tmp11 _ = v12 @@ -39998,7 +40057,7 @@ func LoadNS() { // let binding "nmore" var v15 any = v12 _ = v15 - tmp17 := checkDerefVar(glojure_DOT_core_first) + tmp17 := checkDerefVar(var_glojure_DOT_core_first) tmp18 := lang.Apply(tmp17, []any{v4}) var tmp16 any = tmp18 var tmp19 any = v15 @@ -40008,8 +40067,8 @@ func LoadNS() { } // end let tmp13 = tmp14 } else { - tmp15 := checkDerefVar(glojure_DOT_core_apply) - tmp16 := checkDerefVar(glojure_DOT_core_pr) + tmp15 := checkDerefVar(var_glojure_DOT_core_apply) + tmp16 := checkDerefVar(var_glojure_DOT_core_pr) tmp17 := lang.Apply(tmp15, []any{tmp16, v4}) tmp13 = tmp17 } @@ -40018,7 +40077,7 @@ func LoadNS() { return tmp9 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -40026,31 +40085,29 @@ func LoadNS() { } // pr-on { - tmp0 := lang.NewSymbol("pr-on").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("w"))), lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3669), lang.NewKeyword("end-line"), int(3669), lang.NewKeyword("private"), true)).(*lang.Symbol) + tmp0 := sym_pr_DASH_on.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_w)), kw_static, true, kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3669), kw_end_DASH_line, int(3669), kw_private, true)).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 var tmp5 any - tmp6 := checkDerefVar(glojure_DOT_core__STAR_print_dup_STAR_) + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_dup_STAR_) if lang.IsTruthy(tmp6) { - tmp7 := checkDerefVar(glojure_DOT_core_print_dup) + tmp7 := checkDerefVar(var_glojure_DOT_core_print_DASH_dup) tmp8 := lang.Apply(tmp7, []any{v3, v4}) tmp5 = tmp8 } else { - tmp9 := checkDerefVar(glojure_DOT_core_print_method) + tmp9 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) tmp10 := lang.Apply(tmp9, []any{v3, v4}) tmp5 = tmp10 } _ = tmp5 return nil }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -40059,14 +40116,12 @@ func LoadNS() { // pr-str { tmp1 := reflect.TypeOf("") - tmp0 := lang.NewSymbol("pr-str").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("xs"))), lang.NewKeyword("doc"), "pr to a string, returning it", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4758), lang.NewKeyword("end-line"), int(4758))).(*lang.Symbol) + tmp0 := sym_pr_DASH_str.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_xs)), kw_doc, "pr to a string, returning it", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(4758), kw_end_DASH_line, int(4758))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var v4 any = lang.NewList(args[0:]...) _ = v4 var tmp5 any @@ -40076,24 +40131,24 @@ func LoadNS() { _ = v6 var tmp7 any { // let - tmp8 := checkDerefVar(glojure_DOT_core_push_thread_bindings) - tmp9 := checkDerefVar(glojure_DOT_core_hash_map) - tmp10 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*out*")) + tmp8 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp9 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp10 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) tmp11 := lang.Apply(tmp9, []any{tmp10, v6}) tmp12 := lang.Apply(tmp8, []any{tmp11}) _ = tmp12 var tmp13 any func() { defer func() { - tmp14 := checkDerefVar(glojure_DOT_core_pop_thread_bindings) + tmp14 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) tmp15 := lang.Apply(tmp14, nil) _ = tmp15 }() - tmp16 := checkDerefVar(glojure_DOT_core_apply) - tmp17 := checkDerefVar(glojure_DOT_core_pr) + tmp16 := checkDerefVar(var_glojure_DOT_core_apply) + tmp17 := checkDerefVar(var_glojure_DOT_core_pr) tmp18 := lang.Apply(tmp16, []any{tmp17, v4}) _ = tmp18 - tmp19 := checkDerefVar(glojure_DOT_core_str) + tmp19 := checkDerefVar(var_glojure_DOT_core_str) tmp20 := lang.Apply(tmp19, []any{v6}) tmp13 = tmp20 }() @@ -40105,7 +40160,7 @@ func LoadNS() { } }) tmp4 := reflect.TypeOf("") - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -40113,12 +40168,10 @@ func LoadNS() { } // prefer-method { - tmp0 := lang.NewSymbol("prefer-method").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"), lang.NewSymbol("dispatch-val-x"), lang.NewSymbol("dispatch-val-y"))), lang.NewKeyword("doc"), "Causes the multimethod to prefer matches of dispatch-val-x over dispatch-val-y \n when there is a conflict", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1801), lang.NewKeyword("end-line"), int(1801))).(*lang.Symbol) + tmp0 := sym_prefer_DASH_method.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_multifn, sym_dispatch_DASH_val_DASH_x, sym_dispatch_DASH_val_DASH_y)), kw_doc, "Causes the multimethod to prefer matches of dispatch-val-x over dispatch-val-y \n when there is a conflict", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(1801), kw_end_DASH_line, int(1801))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -40132,7 +40185,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -40140,12 +40193,10 @@ func LoadNS() { } // prefers { - tmp0 := lang.NewSymbol("prefers").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"))), lang.NewKeyword("doc"), "Given a multimethod, returns a map of preferred value -> set of other values", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1822), lang.NewKeyword("end-line"), int(1822))).(*lang.Symbol) + tmp0 := sym_prefers.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_multifn)), kw_doc, "Given a multimethod, returns a map of preferred value -> set of other values", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(1822), kw_end_DASH_line, int(1822))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4, ok := lang.FieldOrMethod(v3, "getPreferTable") @@ -40161,7 +40212,7 @@ func LoadNS() { } return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -40169,12 +40220,10 @@ func LoadNS() { } // prep-hashes { - tmp0 := lang.NewSymbol("prep-hashes").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr-sym"), lang.NewSymbol("default"), lang.NewSymbol("tests"), lang.NewSymbol("thens"))), lang.NewKeyword("doc"), "Takes a sequence of test constants and a corresponding sequence of then\n expressions. Returns a tuple of [shift mask case-map switch-type skip-check]\n where case-map is a map of int case values to [test then] tuples, switch-type\n is either :sparse or :compact, and skip-check is a set of case ints for which\n post-switch equivalence checking must not be done (occurs with hash\n collisions).", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6683), lang.NewKeyword("end-line"), int(6683), lang.NewKeyword("private"), true)).(*lang.Symbol) + tmp0 := sym_prep_DASH_hashes.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_expr_DASH_sym, sym_default, sym_tests, sym_thens)), kw_doc, "Takes a sequence of test constants and a corresponding sequence of then\n expressions. Returns a tuple of [shift mask case-map switch-type skip-check]\n where case-map is a map of int case values to [test then] tuples, switch-type\n is either :sparse or :compact, and skip-check is a set of case ints for which\n post-switch equivalence checking must not be done (occurs with hash\n collisions).", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(8), kw_line, int(6683), kw_end_DASH_line, int(6683), kw_private, true)).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 4) v3 := args[0] _ = v3 v4 := args[1] @@ -40188,15 +40237,13 @@ func LoadNS() { // let binding "hashcode" var tmp8 lang.FnFunc tmp8 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v9 := args[0] _ = v9 tmp10 := lang.Apply(lang.Hash, []any{v9}) return tmp10 }) - tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6691), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(6691), lang.NewKeyword("end-column"), int(66)) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6691), kw_column, int(18), kw_end_DASH_line, int(6691), kw_end_DASH_column, int(66)) tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) if err != nil { panic(err) @@ -40204,35 +40251,35 @@ func LoadNS() { var v11 any = tmp10 _ = v11 // let binding "hashes" - tmp12 := checkDerefVar(glojure_DOT_core_into1) + tmp12 := checkDerefVar(var_glojure_DOT_core_into1) tmp13 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) - tmp14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6692), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(6692), lang.NewKeyword("end-column"), int(25)) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6692), kw_column, int(23), kw_end_DASH_line, int(6692), kw_end_DASH_column, int(25)) tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp16 := checkDerefVar(glojure_DOT_core_map) + tmp16 := checkDerefVar(var_glojure_DOT_core_map) tmp17 := lang.Apply(tmp16, []any{v11, v5}) tmp18 := lang.Apply(tmp12, []any{tmp15, tmp17}) var v19 any = tmp18 _ = v19 var tmp20 any - tmp21 := checkDerefVar(glojure_DOT_core__EQ__EQ_) - tmp22 := checkDerefVar(glojure_DOT_core_count) + tmp21 := checkDerefVar(var_glojure_DOT_core__EQ__EQ_) + tmp22 := checkDerefVar(var_glojure_DOT_core_count) tmp23 := lang.Apply(tmp22, []any{v5}) - tmp24 := checkDerefVar(glojure_DOT_core_count) + tmp24 := checkDerefVar(var_glojure_DOT_core_count) tmp25 := lang.Apply(tmp24, []any{v19}) tmp26 := lang.Apply(tmp21, []any{tmp23, tmp25}) if lang.IsTruthy(tmp26) { var tmp27 any - tmp28 := checkDerefVar(glojure_DOT_core_fits_table_QMARK_) + tmp28 := checkDerefVar(var_glojure_DOT_core_fits_DASH_table_QMARK_) tmp29 := lang.Apply(tmp28, []any{v19}) if lang.IsTruthy(tmp29) { - tmp30 := checkDerefVar(glojure_DOT_core_case_map) - tmp31 := checkDerefVar(glojure_DOT_core_identity) + tmp30 := checkDerefVar(var_glojure_DOT_core_case_DASH_map) + tmp31 := checkDerefVar(var_glojure_DOT_core_identity) tmp32 := lang.Apply(tmp30, []any{v11, tmp31, v5, v6}) - tmp33 := lang.NewVector(int64(0), int64(0), tmp32, lang.NewKeyword("compact")) - tmp34 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6696), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(6696), lang.NewKeyword("end-column"), int(63)) + tmp33 := lang.NewVector(int64(0), int64(0), tmp32, kw_compact) + tmp34 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6696), kw_column, int(9), kw_end_DASH_line, int(6696), kw_end_DASH_column, int(63)) tmp35, err := lang.WithMeta(tmp33, tmp34.(lang.IPersistentMap)) if err != nil { panic(err) @@ -40245,7 +40292,7 @@ func LoadNS() { var tmp37 any { // let // let binding "or__0__auto__" - tmp38 := checkDerefVar(glojure_DOT_core_maybe_min_hash) + tmp38 := checkDerefVar(var_glojure_DOT_core_maybe_DASH_min_DASH_hash) tmp39 := lang.Apply(tmp38, []any{v19}) var v40 any = tmp39 _ = v40 @@ -40254,7 +40301,7 @@ func LoadNS() { tmp41 = v40 } else { tmp42 := lang.NewVector(int64(0), int64(0)) - tmp43 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6697), lang.NewKeyword("column"), int(56), lang.NewKeyword("end-line"), int(6697), lang.NewKeyword("end-column"), int(60)) + tmp43 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6697), kw_column, int(56), kw_end_DASH_line, int(6697), kw_end_DASH_column, int(60)) tmp44, err := lang.WithMeta(tmp42, tmp43.(lang.IPersistentMap)) if err != nil { panic(err) @@ -40266,52 +40313,50 @@ func LoadNS() { var v38 any = tmp37 _ = v38 // let binding "shift" - tmp39 := checkDerefVar(glojure_DOT_core_nth) + tmp39 := checkDerefVar(var_glojure_DOT_core_nth) tmp40 := lang.Apply(tmp39, []any{v38, int64(0), nil}) var v41 any = tmp40 _ = v41 // let binding "mask" - tmp42 := checkDerefVar(glojure_DOT_core_nth) + tmp42 := checkDerefVar(var_glojure_DOT_core_nth) tmp43 := lang.Apply(tmp42, []any{v38, int64(1), nil}) var v44 any = tmp43 _ = v44 var tmp45 any - tmp46 := checkDerefVar(glojure_DOT_core_zero_QMARK_) + tmp46 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) tmp47 := lang.Apply(tmp46, []any{v44}) if lang.IsTruthy(tmp47) { - tmp48 := checkDerefVar(glojure_DOT_core_case_map) - tmp49 := checkDerefVar(glojure_DOT_core_identity) + tmp48 := checkDerefVar(var_glojure_DOT_core_case_DASH_map) + tmp49 := checkDerefVar(var_glojure_DOT_core_identity) tmp50 := lang.Apply(tmp48, []any{v11, tmp49, v5, v6}) - tmp51 := lang.NewVector(int64(0), int64(0), tmp50, lang.NewKeyword("sparse")) - tmp52 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6700), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(6700), lang.NewKeyword("end-column"), int(66)) + tmp51 := lang.NewVector(int64(0), int64(0), tmp50, kw_sparse) + tmp52 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6700), kw_column, int(13), kw_end_DASH_line, int(6700), kw_end_DASH_column, int(66)) tmp53, err := lang.WithMeta(tmp51, tmp52.(lang.IPersistentMap)) if err != nil { panic(err) } tmp45 = tmp53 } else { - tmp54 := checkDerefVar(glojure_DOT_core_case_map) + tmp54 := checkDerefVar(var_glojure_DOT_core_case_DASH_map) var tmp55 lang.FnFunc tmp55 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v56 := args[0] _ = v56 - tmp57 := checkDerefVar(glojure_DOT_core_shift_mask) + tmp57 := checkDerefVar(var_glojure_DOT_core_shift_DASH_mask) tmp58 := lang.Apply(v11, []any{v56}) tmp59 := lang.Apply(tmp57, []any{v41, v44, tmp58}) return tmp59 }) - tmp56 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6702), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(6702), lang.NewKeyword("end-column"), int(71)) + tmp56 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6702), kw_column, int(35), kw_end_DASH_line, int(6702), kw_end_DASH_column, int(71)) tmp57, err := lang.WithMeta(tmp55, tmp56.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp58 := checkDerefVar(glojure_DOT_core_identity) + tmp58 := checkDerefVar(var_glojure_DOT_core_identity) tmp59 := lang.Apply(tmp54, []any{tmp57, tmp58, v5, v6}) - tmp60 := lang.NewVector(v41, v44, tmp59, lang.NewKeyword("compact")) - tmp61 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6702), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(6702), lang.NewKeyword("end-column"), int(103)) + tmp60 := lang.NewVector(v41, v44, tmp59, kw_compact) + tmp61 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6702), kw_column, int(13), kw_end_DASH_line, int(6702), kw_end_DASH_column, int(103)) tmp62, err := lang.WithMeta(tmp60, tmp61.(lang.IPersistentMap)) if err != nil { panic(err) @@ -40327,77 +40372,75 @@ func LoadNS() { var tmp37 any { // let // let binding "vec__170" - tmp38 := checkDerefVar(glojure_DOT_core_merge_hash_collisions) + tmp38 := checkDerefVar(var_glojure_DOT_core_merge_DASH_hash_DASH_collisions) tmp39 := lang.Apply(tmp38, []any{v3, v4, v5, v6}) var v40 any = tmp39 _ = v40 // let binding "tests" - tmp41 := checkDerefVar(glojure_DOT_core_nth) + tmp41 := checkDerefVar(var_glojure_DOT_core_nth) tmp42 := lang.Apply(tmp41, []any{v40, int64(0), nil}) var v43 any = tmp42 _ = v43 // let binding "thens" - tmp44 := checkDerefVar(glojure_DOT_core_nth) + tmp44 := checkDerefVar(var_glojure_DOT_core_nth) tmp45 := lang.Apply(tmp44, []any{v40, int64(1), nil}) var v46 any = tmp45 _ = v46 // let binding "skip-check" - tmp47 := checkDerefVar(glojure_DOT_core_nth) + tmp47 := checkDerefVar(var_glojure_DOT_core_nth) tmp48 := lang.Apply(tmp47, []any{v40, int64(2), nil}) var v49 any = tmp48 _ = v49 // let binding "vec__173" - tmp50 := checkDerefVar(glojure_DOT_core_prep_hashes) + tmp50 := checkDerefVar(var_glojure_DOT_core_prep_DASH_hashes) tmp51 := lang.Apply(tmp50, []any{v3, v4, v43, v46}) var v52 any = tmp51 _ = v52 // let binding "shift" - tmp53 := checkDerefVar(glojure_DOT_core_nth) + tmp53 := checkDerefVar(var_glojure_DOT_core_nth) tmp54 := lang.Apply(tmp53, []any{v52, int64(0), nil}) var v55 any = tmp54 _ = v55 // let binding "mask" - tmp56 := checkDerefVar(glojure_DOT_core_nth) + tmp56 := checkDerefVar(var_glojure_DOT_core_nth) tmp57 := lang.Apply(tmp56, []any{v52, int64(1), nil}) var v58 any = tmp57 _ = v58 // let binding "case-map" - tmp59 := checkDerefVar(glojure_DOT_core_nth) + tmp59 := checkDerefVar(var_glojure_DOT_core_nth) tmp60 := lang.Apply(tmp59, []any{v52, int64(2), nil}) var v61 any = tmp60 _ = v61 // let binding "switch-type" - tmp62 := checkDerefVar(glojure_DOT_core_nth) + tmp62 := checkDerefVar(var_glojure_DOT_core_nth) tmp63 := lang.Apply(tmp62, []any{v52, int64(3), nil}) var v64 any = tmp63 _ = v64 // let binding "skip-check" var tmp65 any - tmp66 := checkDerefVar(glojure_DOT_core_zero_QMARK_) + tmp66 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) tmp67 := lang.Apply(tmp66, []any{v58}) if lang.IsTruthy(tmp67) { tmp65 = v49 } else { - tmp68 := checkDerefVar(glojure_DOT_core_into1) + tmp68 := checkDerefVar(var_glojure_DOT_core_into1) tmp69 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) - tmp70 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6708), lang.NewKeyword("column"), int(33), lang.NewKeyword("end-line"), int(6708), lang.NewKeyword("end-column"), int(35)) + tmp70 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6708), kw_column, int(33), kw_end_DASH_line, int(6708), kw_end_DASH_column, int(35)) tmp71, err := lang.WithMeta(tmp69, tmp70.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp72 := checkDerefVar(glojure_DOT_core_map) + tmp72 := checkDerefVar(var_glojure_DOT_core_map) var tmp73 lang.FnFunc tmp73 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v74 := args[0] _ = v74 - tmp75 := checkDerefVar(glojure_DOT_core_shift_mask) + tmp75 := checkDerefVar(var_glojure_DOT_core_shift_DASH_mask) tmp76 := lang.Apply(tmp75, []any{v55, v58, v74}) return tmp76 }) - tmp74 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6708), lang.NewKeyword("column"), int(42), lang.NewKeyword("end-line"), int(6708), lang.NewKeyword("end-column"), int(67)) + tmp74 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6708), kw_column, int(42), kw_end_DASH_line, int(6708), kw_end_DASH_column, int(67)) tmp75, err := lang.WithMeta(tmp73, tmp74.(lang.IPersistentMap)) if err != nil { panic(err) @@ -40409,7 +40452,7 @@ func LoadNS() { var v78 any = tmp65 _ = v78 tmp79 := lang.NewVector(v55, v58, v61, v64, v78) - tmp80 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6709), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(6709), lang.NewKeyword("end-column"), int(52)) + tmp80 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6709), kw_column, int(9), kw_end_DASH_line, int(6709), kw_end_DASH_column, int(52)) tmp81, err := lang.WithMeta(tmp79, tmp80.(lang.IPersistentMap)) if err != nil { panic(err) @@ -40422,7 +40465,7 @@ func LoadNS() { } // end let return tmp7 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -40430,26 +40473,24 @@ func LoadNS() { } // prep-ints { - tmp0 := lang.NewSymbol("prep-ints").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tests"), lang.NewSymbol("thens"))), lang.NewKeyword("doc"), "Takes a sequence of int-sized test constants and a corresponding sequence of\n then expressions. Returns a tuple of [shift mask case-map switch-type] where\n case-map is a map of int case values to [test then] tuples, and switch-type\n is either :sparse or :compact.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6631), lang.NewKeyword("end-line"), int(6631), lang.NewKeyword("private"), true)).(*lang.Symbol) + tmp0 := sym_prep_DASH_ints.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_tests, sym_thens)), kw_doc, "Takes a sequence of int-sized test constants and a corresponding sequence of\n then expressions. Returns a tuple of [shift mask case-map switch-type] where\n case-map is a map of int case values to [test then] tuples, and switch-type\n is either :sparse or :compact.", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(8), kw_line, int(6631), kw_end_DASH_line, int(6631), kw_private, true)).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 var tmp5 any - tmp6 := checkDerefVar(glojure_DOT_core_fits_table_QMARK_) + tmp6 := checkDerefVar(var_glojure_DOT_core_fits_DASH_table_QMARK_) tmp7 := lang.Apply(tmp6, []any{v3}) if lang.IsTruthy(tmp7) { - tmp8 := checkDerefVar(glojure_DOT_core_case_map) - tmp9 := checkDerefVar(glojure_DOT_core_int) - tmp10 := checkDerefVar(glojure_DOT_core_int) + tmp8 := checkDerefVar(var_glojure_DOT_core_case_DASH_map) + tmp9 := checkDerefVar(var_glojure_DOT_core_int) + tmp10 := checkDerefVar(var_glojure_DOT_core_int) tmp11 := lang.Apply(tmp8, []any{tmp9, tmp10, v3, v4}) - tmp12 := lang.NewVector(int64(0), int64(0), tmp11, lang.NewKeyword("compact")) - tmp13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6639), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(6639), lang.NewKeyword("end-column"), int(49)) + tmp12 := lang.NewVector(int64(0), int64(0), tmp11, kw_compact) + tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6639), kw_column, int(5), kw_end_DASH_line, int(6639), kw_end_DASH_column, int(49)) tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) if err != nil { panic(err) @@ -40462,9 +40503,9 @@ func LoadNS() { var tmp16 any { // let // let binding "or__0__auto__" - tmp17 := checkDerefVar(glojure_DOT_core_maybe_min_hash) - tmp18 := checkDerefVar(glojure_DOT_core_map) - tmp19 := checkDerefVar(glojure_DOT_core_int) + tmp17 := checkDerefVar(var_glojure_DOT_core_maybe_DASH_min_DASH_hash) + tmp18 := checkDerefVar(var_glojure_DOT_core_map) + tmp19 := checkDerefVar(var_glojure_DOT_core_int) tmp20 := lang.Apply(tmp18, []any{tmp19, v3}) tmp21 := lang.Apply(tmp17, []any{tmp20}) var v22 any = tmp21 @@ -40474,7 +40515,7 @@ func LoadNS() { tmp23 = v22 } else { tmp24 := lang.NewVector(int64(0), int64(0)) - tmp25 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6640), lang.NewKeyword("column"), int(61), lang.NewKeyword("end-line"), int(6640), lang.NewKeyword("end-column"), int(65)) + tmp25 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6640), kw_column, int(61), kw_end_DASH_line, int(6640), kw_end_DASH_column, int(65)) tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) if err != nil { panic(err) @@ -40486,54 +40527,52 @@ func LoadNS() { var v17 any = tmp16 _ = v17 // let binding "shift" - tmp18 := checkDerefVar(glojure_DOT_core_nth) + tmp18 := checkDerefVar(var_glojure_DOT_core_nth) tmp19 := lang.Apply(tmp18, []any{v17, int64(0), nil}) var v20 any = tmp19 _ = v20 // let binding "mask" - tmp21 := checkDerefVar(glojure_DOT_core_nth) + tmp21 := checkDerefVar(var_glojure_DOT_core_nth) tmp22 := lang.Apply(tmp21, []any{v17, int64(1), nil}) var v23 any = tmp22 _ = v23 var tmp24 any - tmp25 := checkDerefVar(glojure_DOT_core_zero_QMARK_) + tmp25 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) tmp26 := lang.Apply(tmp25, []any{v23}) if lang.IsTruthy(tmp26) { - tmp27 := checkDerefVar(glojure_DOT_core_case_map) - tmp28 := checkDerefVar(glojure_DOT_core_int) - tmp29 := checkDerefVar(glojure_DOT_core_int) + tmp27 := checkDerefVar(var_glojure_DOT_core_case_DASH_map) + tmp28 := checkDerefVar(var_glojure_DOT_core_int) + tmp29 := checkDerefVar(var_glojure_DOT_core_int) tmp30 := lang.Apply(tmp27, []any{tmp28, tmp29, v3, v4}) - tmp31 := lang.NewVector(int64(0), int64(0), tmp30, lang.NewKeyword("sparse")) - tmp32 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6643), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(6643), lang.NewKeyword("end-column"), int(52)) + tmp31 := lang.NewVector(int64(0), int64(0), tmp30, kw_sparse) + tmp32 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6643), kw_column, int(9), kw_end_DASH_line, int(6643), kw_end_DASH_column, int(52)) tmp33, err := lang.WithMeta(tmp31, tmp32.(lang.IPersistentMap)) if err != nil { panic(err) } tmp24 = tmp33 } else { - tmp34 := checkDerefVar(glojure_DOT_core_case_map) + tmp34 := checkDerefVar(var_glojure_DOT_core_case_DASH_map) var tmp35 lang.FnFunc tmp35 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v36 := args[0] _ = v36 - tmp37 := checkDerefVar(glojure_DOT_core_shift_mask) - tmp38 := checkDerefVar(glojure_DOT_core_int) + tmp37 := checkDerefVar(var_glojure_DOT_core_shift_DASH_mask) + tmp38 := checkDerefVar(var_glojure_DOT_core_int) tmp39 := lang.Apply(tmp38, []any{v36}) tmp40 := lang.Apply(tmp37, []any{v20, v23, tmp39}) return tmp40 }) - tmp36 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6645), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(6645), lang.NewKeyword("end-column"), int(62)) + tmp36 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6645), kw_column, int(31), kw_end_DASH_line, int(6645), kw_end_DASH_column, int(62)) tmp37, err := lang.WithMeta(tmp35, tmp36.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp38 := checkDerefVar(glojure_DOT_core_int) + tmp38 := checkDerefVar(var_glojure_DOT_core_int) tmp39 := lang.Apply(tmp34, []any{tmp37, tmp38, v3, v4}) - tmp40 := lang.NewVector(v20, v23, tmp39, lang.NewKeyword("compact")) - tmp41 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6645), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(6645), lang.NewKeyword("end-column"), int(89)) + tmp40 := lang.NewVector(v20, v23, tmp39, kw_compact) + tmp41 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6645), kw_column, int(9), kw_end_DASH_line, int(6645), kw_end_DASH_column, int(89)) tmp42, err := lang.WithMeta(tmp40, tmp41.(lang.IPersistentMap)) if err != nil { panic(err) @@ -40546,7 +40585,7 @@ func LoadNS() { } return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -40554,31 +40593,29 @@ func LoadNS() { } // prependss { - tmp0 := lang.NewSymbol("prependss").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Prepends a symbol or a seq to coll", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5857), lang.NewKeyword("end-line"), int(5857), lang.NewKeyword("private"), true)).(*lang.Symbol) + tmp0 := sym_prependss.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_coll)), kw_doc, "Prepends a symbol or a seq to coll", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(8), kw_line, int(5857), kw_end_DASH_line, int(5857), kw_private, true)).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 var tmp5 any - tmp6 := checkDerefVar(glojure_DOT_core_symbol_QMARK_) + tmp6 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) tmp7 := lang.Apply(tmp6, []any{v3}) if lang.IsTruthy(tmp7) { - tmp8 := checkDerefVar(glojure_DOT_core_cons) + tmp8 := checkDerefVar(var_glojure_DOT_core_cons) tmp9 := lang.Apply(tmp8, []any{v3, v4}) tmp5 = tmp9 } else { - tmp10 := checkDerefVar(glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_concat) tmp11 := lang.Apply(tmp10, []any{v3, v4}) tmp5 = tmp11 } return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -40586,19 +40623,15 @@ func LoadNS() { } // preserving-reduced { - tmp0 := lang.NewSymbol("preserving-reduced").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7638), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(7638), lang.NewKeyword("end-column"), int(34), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rf"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym_preserving_DASH_reduced.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(7638), kw_column, int(7), kw_end_DASH_line, int(7638), kw_end_DASH_column, int(34), kw_arglists, lang.NewList(lang.NewVector(sym_rf)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 lang.FnFunc tmp4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v5 := args[0] _ = v5 v6 := args[1] @@ -40610,10 +40643,10 @@ func LoadNS() { var v9 any = tmp8 _ = v9 var tmp10 any - tmp11 := checkDerefVar(glojure_DOT_core_reduced_QMARK_) + tmp11 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) tmp12 := lang.Apply(tmp11, []any{v9}) if lang.IsTruthy(tmp12) { - tmp13 := checkDerefVar(glojure_DOT_core_reduced) + tmp13 := checkDerefVar(var_glojure_DOT_core_reduced) tmp14 := lang.Apply(tmp13, []any{v9}) tmp10 = tmp14 } else { @@ -40623,14 +40656,14 @@ func LoadNS() { } // end let return tmp7 }) - tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7640), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(7643), lang.NewKeyword("end-column"), int(12)) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7640), kw_column, int(3), kw_end_DASH_line, int(7643), kw_end_DASH_column, int(12)) tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) if err != nil { panic(err) } return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -40638,33 +40671,31 @@ func LoadNS() { } // print { - tmp0 := lang.NewSymbol("print").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Prints the object(s) to the output stream that is the current value\n of *out*. print and println produce output for human consumption.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3725), lang.NewKeyword("end-line"), int(3725))).(*lang.Symbol) + tmp0 := sym_print.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_more)), kw_doc, "Prints the object(s) to the output stream that is the current value\n of *out*. print and println produce output for human consumption.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3725), kw_end_DASH_line, int(3725))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 var tmp4 any { // let - tmp5 := checkDerefVar(glojure_DOT_core_push_thread_bindings) - tmp6 := checkDerefVar(glojure_DOT_core_hash_map) - tmp7 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*print-readably*")) + tmp5 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp6 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp7 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_print_DASH_readably_STAR_) tmp8 := lang.Apply(tmp6, []any{tmp7, nil}) tmp9 := lang.Apply(tmp5, []any{tmp8}) _ = tmp9 var tmp10 any func() { defer func() { - tmp11 := checkDerefVar(glojure_DOT_core_pop_thread_bindings) + tmp11 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) tmp12 := lang.Apply(tmp11, nil) _ = tmp12 }() - tmp13 := checkDerefVar(glojure_DOT_core_apply) - tmp14 := checkDerefVar(glojure_DOT_core_pr) + tmp13 := checkDerefVar(var_glojure_DOT_core_apply) + tmp14 := checkDerefVar(var_glojure_DOT_core_pr) tmp15 := lang.Apply(tmp13, []any{tmp14, v3}) tmp10 = tmp15 }() @@ -40673,7 +40704,7 @@ func LoadNS() { return tmp4 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -40681,12 +40712,10 @@ func LoadNS() { } // print-ctor { - tmp0 := lang.NewSymbol("print-ctor").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(95), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(95), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("print-args"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym_print_DASH_ctor.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(95), kw_column, int(7), kw_end_DASH_line, int(95), kw_end_DASH_column, int(16), kw_arglists, lang.NewList(lang.NewVector(sym_o, sym_print_DASH_args, sym_w)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -40695,7 +40724,7 @@ func LoadNS() { _ = v5 tmp6 := lang.Apply(lang.WriteWriter, []any{v5, "#=("}) _ = tmp6 - tmp7 := checkDerefVar(glojure_DOT_core_class) + tmp7 := checkDerefVar(var_glojure_DOT_core_class) tmp8 := lang.Apply(tmp7, []any{v3}) tmp9, ok := lang.FieldOrMethod(tmp8, "Name") if !ok { @@ -40717,7 +40746,7 @@ func LoadNS() { tmp14 := lang.Apply(lang.WriteWriter, []any{v5, ")"}) return tmp14 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -40725,32 +40754,28 @@ func LoadNS() { } // print-dup { - tmp0 := lang.NewSymbol("print-dup").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3667), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(3667), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym_print_DASH_dup.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3667), kw_column, int(11), kw_end_DASH_line, int(3667), kw_end_DASH_column, int(19), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v4 := args[0] _ = v4 v5 := args[1] _ = v5 - tmp6 := checkDerefVar(glojure_DOT_core_class) + tmp6 := checkDerefVar(var_glojure_DOT_core_class) tmp7 := lang.Apply(tmp6, []any{v4}) return tmp7 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3667), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(3667), lang.NewKeyword("end-column"), int(45))).(lang.FnFunc) - tmp2 := lang.NewMultiFn("print-dup", tmp3, lang.NewKeyword("default"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")).FindInternedVar(lang.NewSymbol("global-hierarchy"))) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3667), kw_column, int(21), kw_end_DASH_line, int(3667), kw_end_DASH_column, int(45))).(lang.FnFunc) + tmp2 := lang.NewMultiFn("print-dup", tmp3, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) var tmp4 lang.FnFunc tmp4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v5 := args[0] _ = v5 v6 := args[1] _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_print_method) + tmp7 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) tmp8 := lang.Apply(tmp7, []any{v5, v6}) return tmp8 }) @@ -40758,14 +40783,12 @@ func LoadNS() { tmp5 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() var tmp6 lang.FnFunc tmp6 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v7 := args[0] _ = v7 v8 := args[1] _ = v8 - tmp9 := checkDerefVar(glojure_DOT_core_print_method) + tmp9 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) tmp10 := lang.Apply(tmp9, []any{v7, v8}) return tmp10 }) @@ -40773,14 +40796,12 @@ func LoadNS() { tmp7 := reflect.TypeOf((*lang.IPersistentList)(nil)).Elem() var tmp8 lang.FnFunc tmp8 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v9 := args[0] _ = v9 v10 := args[1] _ = v10 - tmp11 := checkDerefVar(glojure_DOT_core_print_method) + tmp11 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) tmp12 := lang.Apply(tmp11, []any{v9, v10}) return tmp12 }) @@ -40788,14 +40809,12 @@ func LoadNS() { tmp9 := reflect.TypeOf((*lang.Symbol)(nil)) var tmp10 lang.FnFunc tmp10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v11 := args[0] _ = v11 v12 := args[1] _ = v12 - tmp13 := checkDerefVar(glojure_DOT_core_print_method) + tmp13 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) tmp14 := lang.Apply(tmp13, []any{v11, v12}) return tmp14 }) @@ -40803,19 +40822,17 @@ func LoadNS() { tmp11 := reflect.TypeOf((*lang.IRecord)(nil)).Elem() var tmp12 lang.FnFunc tmp12 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v13 := args[0] _ = v13 v14 := args[1] _ = v14 - tmp15 := checkDerefVar(glojure_DOT_core_print_meta) + tmp15 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) tmp16 := lang.Apply(tmp15, []any{v13, v14}) _ = tmp16 tmp17 := lang.Apply(lang.WriteWriter, []any{v14, "#"}) _ = tmp17 - tmp18 := checkDerefVar(glojure_DOT_core_class) + tmp18 := checkDerefVar(var_glojure_DOT_core_class) tmp19 := lang.Apply(tmp18, []any{v13}) tmp20, ok := lang.FieldOrMethod(tmp19, "Name") if !ok { @@ -40831,16 +40848,16 @@ func LoadNS() { tmp22 := lang.Apply(lang.WriteWriter, []any{v14, tmp21}) _ = tmp22 var tmp23 any - tmp24 := checkDerefVar(glojure_DOT_core__STAR_verbose_defrecords_STAR_) + tmp24 := checkDerefVar(var_glojure_DOT_core__STAR_verbose_DASH_defrecords_STAR_) if lang.IsTruthy(tmp24) { - tmp25 := checkDerefVar(glojure_DOT_core_print_map) - tmp26 := checkDerefVar(glojure_DOT_core_print_dup) + tmp25 := checkDerefVar(var_glojure_DOT_core_print_DASH_map) + tmp26 := checkDerefVar(var_glojure_DOT_core_print_DASH_dup) tmp27 := lang.Apply(tmp25, []any{v13, tmp26, v14}) tmp23 = tmp27 } else { - tmp28 := checkDerefVar(glojure_DOT_core_print_sequential) - tmp29 := checkDerefVar(glojure_DOT_core_pr_on) - tmp30 := checkDerefVar(glojure_DOT_core_vals) + tmp28 := checkDerefVar(var_glojure_DOT_core_print_DASH_sequential) + tmp29 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) + tmp30 := checkDerefVar(var_glojure_DOT_core_vals) tmp31 := lang.Apply(tmp30, []any{v13}) tmp32 := lang.Apply(tmp28, []any{"[", tmp29, ", ", "]", tmp31, v14}) tmp23 = tmp32 @@ -40851,14 +40868,12 @@ func LoadNS() { tmp13 := reflect.TypeOf((*lang.Set)(nil)) var tmp14 lang.FnFunc tmp14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v15 := args[0] _ = v15 v16 := args[1] _ = v16 - tmp17 := checkDerefVar(glojure_DOT_core_print_method) + tmp17 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) tmp18 := lang.Apply(tmp17, []any{v15, v16}) return tmp18 }) @@ -40866,14 +40881,12 @@ func LoadNS() { tmp15 := reflect.TypeOf((*lang.PersistentHashMap)(nil)) var tmp16 lang.FnFunc tmp16 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v17 := args[0] _ = v17 v18 := args[1] _ = v18 - tmp19 := checkDerefVar(glojure_DOT_core_print_method) + tmp19 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) tmp20 := lang.Apply(tmp19, []any{v17, v18}) return tmp20 }) @@ -40881,14 +40894,12 @@ func LoadNS() { tmp17 := reflect.TypeOf(int64(0)) var tmp18 lang.FnFunc tmp18 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v19 := args[0] _ = v19 v20 := args[1] _ = v20 - tmp21 := checkDerefVar(glojure_DOT_core_print_method) + tmp21 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) tmp22 := lang.Apply(tmp21, []any{v19, v20}) return tmp22 }) @@ -40896,14 +40907,12 @@ func LoadNS() { tmp19 := reflect.TypeOf((*lang.Vector)(nil)) var tmp20 lang.FnFunc tmp20 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v21 := args[0] _ = v21 v22 := args[1] _ = v22 - tmp23 := checkDerefVar(glojure_DOT_core_print_method) + tmp23 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) tmp24 := lang.Apply(tmp23, []any{v21, v22}) return tmp24 }) @@ -40911,14 +40920,12 @@ func LoadNS() { tmp21 := reflect.TypeOf(float64(0)) var tmp22 lang.FnFunc tmp22 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v23 := args[0] _ = v23 v24 := args[1] _ = v24 - tmp25 := checkDerefVar(glojure_DOT_core_print_method) + tmp25 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) tmp26 := lang.Apply(tmp25, []any{v23, v24}) return tmp26 }) @@ -40926,14 +40933,12 @@ func LoadNS() { tmp23 := reflect.TypeOf("") var tmp24 lang.FnFunc tmp24 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v25 := args[0] _ = v25 v26 := args[1] _ = v26 - tmp27 := checkDerefVar(glojure_DOT_core_print_method) + tmp27 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) tmp28 := lang.Apply(tmp27, []any{v25, v26}) return tmp28 }) @@ -40941,19 +40946,17 @@ func LoadNS() { tmp25 := reflect.TypeOf((*lang.IPersistentCollection)(nil)).Elem() var tmp26 lang.FnFunc tmp26 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v27 := args[0] _ = v27 v28 := args[1] _ = v28 - tmp29 := checkDerefVar(glojure_DOT_core_print_meta) + tmp29 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) tmp30 := lang.Apply(tmp29, []any{v27, v28}) _ = tmp30 tmp31 := lang.Apply(lang.WriteWriter, []any{v28, "#=("}) _ = tmp31 - tmp32 := checkDerefVar(glojure_DOT_core_class) + tmp32 := checkDerefVar(var_glojure_DOT_core_class) tmp33 := lang.Apply(tmp32, []any{v27}) tmp34, ok := lang.FieldOrMethod(tmp33, "Name") if !ok { @@ -40970,8 +40973,8 @@ func LoadNS() { _ = tmp36 tmp37 := lang.Apply(lang.WriteWriter, []any{v28, "/create "}) _ = tmp37 - tmp38 := checkDerefVar(glojure_DOT_core_print_sequential) - tmp39 := checkDerefVar(glojure_DOT_core_print_dup) + tmp38 := checkDerefVar(var_glojure_DOT_core_print_DASH_sequential) + tmp39 := checkDerefVar(var_glojure_DOT_core_print_DASH_dup) tmp40 := lang.Apply(tmp38, []any{"[", tmp39, " ", "]", v27, v28}) _ = tmp40 tmp41 := lang.Apply(lang.WriteWriter, []any{v28, ")"}) @@ -40981,14 +40984,12 @@ func LoadNS() { tmp27 := reflect.TypeOf(int32(0)) var tmp28 lang.FnFunc tmp28 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v29 := args[0] _ = v29 v30 := args[1] _ = v30 - tmp31 := checkDerefVar(glojure_DOT_core_print_method) + tmp31 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) tmp32 := lang.Apply(tmp31, []any{v29, v30}) return tmp32 }) @@ -40996,19 +40997,17 @@ func LoadNS() { tmp29 := reflect.TypeOf((*lang.IPersistentMap)(nil)).Elem() var tmp30 lang.FnFunc tmp30 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v31 := args[0] _ = v31 v32 := args[1] _ = v32 - tmp33 := checkDerefVar(glojure_DOT_core_print_meta) + tmp33 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) tmp34 := lang.Apply(tmp33, []any{v31, v32}) _ = tmp34 tmp35 := lang.Apply(lang.WriteWriter, []any{v32, "#=("}) _ = tmp35 - tmp36 := checkDerefVar(glojure_DOT_core_class) + tmp36 := checkDerefVar(var_glojure_DOT_core_class) tmp37 := lang.Apply(tmp36, []any{v31}) tmp38, ok := lang.FieldOrMethod(tmp37, "Name") if !ok { @@ -41025,8 +41024,8 @@ func LoadNS() { _ = tmp40 tmp41 := lang.Apply(lang.WriteWriter, []any{v32, "/create "}) _ = tmp41 - tmp42 := checkDerefVar(glojure_DOT_core_print_map) - tmp43 := checkDerefVar(glojure_DOT_core_print_dup) + tmp42 := checkDerefVar(var_glojure_DOT_core_print_DASH_map) + tmp43 := checkDerefVar(var_glojure_DOT_core_print_DASH_dup) tmp44 := lang.Apply(tmp42, []any{v31, tmp43, v32}) _ = tmp44 tmp45 := lang.Apply(lang.WriteWriter, []any{v32, ")"}) @@ -41036,16 +41035,14 @@ func LoadNS() { tmp31 := reflect.TypeOf((*lang.Namespace)(nil)) var tmp32 lang.FnFunc tmp32 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v33 := args[0] _ = v33 v34 := args[1] _ = v34 tmp35 := lang.Apply(lang.WriteWriter, []any{v34, "#=(find-ns "}) _ = tmp35 - tmp36 := checkDerefVar(glojure_DOT_core_print_dup) + tmp36 := checkDerefVar(var_glojure_DOT_core_print_DASH_dup) tmp37, ok := lang.FieldOrMethod(v33, "name") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v33, "name"))) @@ -41066,14 +41063,12 @@ func LoadNS() { tmp33 := reflect.TypeOf(false) var tmp34 lang.FnFunc tmp34 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v35 := args[0] _ = v35 v36 := args[1] _ = v36 - tmp37 := checkDerefVar(glojure_DOT_core_print_method) + tmp37 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) tmp38 := lang.Apply(tmp37, []any{v35, v36}) return tmp38 }) @@ -41081,14 +41076,12 @@ func LoadNS() { tmp35 := reflect.TypeOf((*regexp15.Regexp)(nil)) var tmp36 lang.FnFunc tmp36 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v37 := args[0] _ = v37 v38 := args[1] _ = v38 - tmp39 := checkDerefVar(glojure_DOT_core_print_method) + tmp39 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) tmp40 := lang.Apply(tmp39, []any{v37, v38}) return tmp40 }) @@ -41096,14 +41089,12 @@ func LoadNS() { tmp37 := reflect.TypeOf((*lang.Ratio)(nil)) var tmp38 lang.FnFunc tmp38 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v39 := args[0] _ = v39 v40 := args[1] _ = v40 - tmp41 := checkDerefVar(glojure_DOT_core_print_method) + tmp41 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) tmp42 := lang.Apply(tmp41, []any{v39, v40}) return tmp42 }) @@ -41111,14 +41102,12 @@ func LoadNS() { tmp39 := reflect.TypeOf((*lang.Var)(nil)) var tmp40 lang.FnFunc tmp40 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v41 := args[0] _ = v41 v42 := args[1] _ = v42 - tmp43 := checkDerefVar(glojure_DOT_core_str) + tmp43 := checkDerefVar(var_glojure_DOT_core_str) tmp44, ok := lang.FieldOrMethod(v41, "Namespace") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v41, "Namespace"))) @@ -41160,14 +41149,12 @@ func LoadNS() { tmp41 := reflect.TypeOf((*lang.BigDecimal)(nil)) var tmp42 lang.FnFunc tmp42 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v43 := args[0] _ = v43 v44 := args[1] _ = v44 - tmp45 := checkDerefVar(glojure_DOT_core_print_method) + tmp45 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) tmp46 := lang.Apply(tmp45, []any{v43, v44}) return tmp46 }) @@ -41175,14 +41162,12 @@ func LoadNS() { tmp43 := reflect.TypeOf((*lang.BigInt)(nil)) var tmp44 lang.FnFunc tmp44 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v45 := args[0] _ = v45 v46 := args[1] _ = v46 - tmp47 := checkDerefVar(glojure_DOT_core_print_method) + tmp47 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) tmp48 := lang.Apply(tmp47, []any{v45, v46}) return tmp48 }) @@ -41190,26 +41175,22 @@ func LoadNS() { tmp45 := reflect.TypeOf((*runtime7.Fn)(nil)) var tmp46 lang.FnFunc tmp46 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v47 := args[0] _ = v47 v48 := args[1] _ = v48 - tmp49 := checkDerefVar(glojure_DOT_core_print_ctor) + tmp49 := checkDerefVar(var_glojure_DOT_core_print_DASH_ctor) var tmp50 lang.FnFunc tmp50 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v51 := args[0] _ = v51 v52 := args[1] _ = v52 return nil }) - tmp51 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(167), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(167), lang.NewKeyword("end-column"), int(26)) + tmp51 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(167), kw_column, int(17), kw_end_DASH_line, int(167), kw_end_DASH_column, int(26)) tmp52, err := lang.WithMeta(tmp50, tmp51.(lang.IPersistentMap)) if err != nil { panic(err) @@ -41221,14 +41202,12 @@ func LoadNS() { tmp47 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() var tmp48 lang.FnFunc tmp48 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v49 := args[0] _ = v49 v50 := args[1] _ = v50 - tmp51 := checkDerefVar(glojure_DOT_core_print_method) + tmp51 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) tmp52 := lang.Apply(tmp51, []any{v49, v50}) return tmp52 }) @@ -41252,7 +41231,7 @@ func LoadNS() { } // print-initialized { - tmp0 := lang.NewSymbol("print-initialized").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(520), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(520), lang.NewKeyword("end-column"), int(39), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym_print_DASH_initialized.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core_print.glj", kw_line, int(520), kw_column, int(6), kw_end_DASH_line, int(520), kw_end_DASH_column, int(39), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) tmp1 := ns.InternWithValue(tmp0, true, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -41260,23 +41239,21 @@ func LoadNS() { } // print-map { - tmp0 := lang.NewSymbol("print-map").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(252), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(252), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("print-one"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym_print_DASH_map.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(252), kw_column, int(8), kw_end_DASH_line, int(252), kw_end_DASH_column, int(16), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_m, sym_print_DASH_one, sym_w)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] _ = v4 v5 := args[2] _ = v5 - tmp6 := checkDerefVar(glojure_DOT_core_print_prefix_map) + tmp6 := checkDerefVar(var_glojure_DOT_core_print_DASH_prefix_DASH_map) tmp7 := lang.Apply(tmp6, []any{nil, v3, v4, v5}) return tmp7 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -41284,12 +41261,10 @@ func LoadNS() { } // print-meta { - tmp0 := lang.NewSymbol("print-meta").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(70), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(70), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym_print_DASH_meta.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(70), kw_column, int(8), kw_end_DASH_line, int(70), kw_end_DASH_column, int(17), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_o, sym_w)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -41297,7 +41272,7 @@ func LoadNS() { var tmp5 any { // let // let binding "temp__0__auto__" - tmp6 := checkDerefVar(glojure_DOT_core_meta) + tmp6 := checkDerefVar(var_glojure_DOT_core_meta) tmp7 := lang.Apply(tmp6, []any{v3}) var v8 any = tmp7 _ = v8 @@ -41312,8 +41287,8 @@ func LoadNS() { var tmp13 any { // let // let binding "and__0__auto__" - tmp14 := checkDerefVar(glojure_DOT_core_pos_QMARK_) - tmp15 := checkDerefVar(glojure_DOT_core_count) + tmp14 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp15 := checkDerefVar(var_glojure_DOT_core_count) tmp16 := lang.Apply(tmp15, []any{v11}) tmp17 := lang.Apply(tmp14, []any{tmp16}) var v18 any = tmp17 @@ -41323,7 +41298,7 @@ func LoadNS() { var tmp20 any { // let // let binding "or__0__auto__" - tmp21 := checkDerefVar(glojure_DOT_core__STAR_print_dup_STAR_) + tmp21 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_dup_STAR_) var v22 any = tmp21 _ = v22 var tmp23 any @@ -41333,12 +41308,12 @@ func LoadNS() { var tmp24 any { // let // let binding "and__0__auto__" - tmp25 := checkDerefVar(glojure_DOT_core__STAR_print_meta_STAR_) + tmp25 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_meta_STAR_) var v26 any = tmp25 _ = v26 var tmp27 any if lang.IsTruthy(v26) { - tmp28 := checkDerefVar(glojure_DOT_core__STAR_print_readably_STAR_) + tmp28 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_readably_STAR_) tmp27 = tmp28 } else { tmp27 = v26 @@ -41362,15 +41337,15 @@ func LoadNS() { var tmp16 any { // let // let binding "and__0__auto__" - tmp17 := checkDerefVar(glojure_DOT_core__EQ_) - tmp18 := checkDerefVar(glojure_DOT_core_count) + tmp17 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp18 := checkDerefVar(var_glojure_DOT_core_count) tmp19 := lang.Apply(tmp18, []any{v11}) tmp20 := lang.Apply(tmp17, []any{tmp19, int64(1)}) var v21 any = tmp20 _ = v21 var tmp22 any if lang.IsTruthy(v21) { - tmp23 := lang.Apply(lang.NewKeyword("tag"), []any{v11}) + tmp23 := lang.Apply(kw_tag, []any{v11}) tmp22 = tmp23 } else { tmp22 = v21 @@ -41378,12 +41353,12 @@ func LoadNS() { tmp16 = tmp22 } // end let if lang.IsTruthy(tmp16) { - tmp17 := checkDerefVar(glojure_DOT_core_pr_on) - tmp18 := lang.Apply(lang.NewKeyword("tag"), []any{v11}) + tmp17 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) + tmp18 := lang.Apply(kw_tag, []any{v11}) tmp19 := lang.Apply(tmp17, []any{tmp18, v4}) tmp15 = tmp19 } else { - tmp20 := checkDerefVar(glojure_DOT_core_pr_on) + tmp20 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) tmp21 := lang.Apply(tmp20, []any{v11, v4}) tmp15 = tmp21 } @@ -41401,7 +41376,7 @@ func LoadNS() { } // end let return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -41409,12 +41384,10 @@ func LoadNS() { } // print-method { - tmp0 := lang.NewSymbol("print-method").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3664), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(3664), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym_print_DASH_method.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3664), kw_column, int(11), kw_end_DASH_line, int(3664), kw_end_DASH_column, int(22), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -41422,19 +41395,19 @@ func LoadNS() { var tmp6 any { // let // let binding "t" - tmp7 := checkDerefVar(glojure_DOT_core_get) - tmp8 := checkDerefVar(glojure_DOT_core_meta) + tmp7 := checkDerefVar(var_glojure_DOT_core_get) + tmp8 := checkDerefVar(var_glojure_DOT_core_meta) tmp9 := lang.Apply(tmp8, []any{v4}) - tmp10 := lang.Apply(tmp7, []any{tmp9, lang.NewKeyword("type")}) + tmp10 := lang.Apply(tmp7, []any{tmp9, kw_type}) var v11 any = tmp10 _ = v11 var tmp12 any - tmp13 := checkDerefVar(glojure_DOT_core_keyword_QMARK_) + tmp13 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) tmp14 := lang.Apply(tmp13, []any{v11}) if lang.IsTruthy(tmp14) { tmp12 = v11 } else { - tmp15 := checkDerefVar(glojure_DOT_core_class) + tmp15 := checkDerefVar(var_glojure_DOT_core_class) tmp16 := lang.Apply(tmp15, []any{v4}) tmp12 = tmp16 } @@ -41442,13 +41415,11 @@ func LoadNS() { } // end let return tmp6 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3664), lang.NewKeyword("column"), int(24), lang.NewKeyword("end-line"), int(3666), lang.NewKeyword("end-column"), int(58))).(lang.FnFunc) - tmp2 := lang.NewMultiFn("print-method", tmp3, lang.NewKeyword("default"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")).FindInternedVar(lang.NewSymbol("global-hierarchy"))) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3664), kw_column, int(24), kw_end_DASH_line, int(3666), kw_end_DASH_column, int(58))).(lang.FnFunc) + tmp2 := lang.NewMultiFn("print-method", tmp3, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) var tmp4 lang.FnFunc tmp4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v5 := args[0] _ = v5 v6 := args[1] @@ -41460,14 +41431,12 @@ func LoadNS() { tmp5 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() var tmp6 lang.FnFunc tmp6 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v7 := args[0] _ = v7 v8 := args[1] _ = v8 - tmp9 := checkDerefVar(glojure_DOT_core_str) + tmp9 := checkDerefVar(var_glojure_DOT_core_str) tmp10 := lang.Apply(tmp9, []any{v7}) tmp11 := lang.Apply(lang.WriteWriter, []any{v8, tmp10}) return tmp11 @@ -41476,14 +41445,12 @@ func LoadNS() { tmp7 := reflect.TypeOf(uint32(0)) var tmp8 lang.FnFunc tmp8 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v9 := args[0] _ = v9 v10 := args[1] _ = v10 - tmp11 := checkDerefVar(glojure_DOT_core_str) + tmp11 := checkDerefVar(var_glojure_DOT_core_str) tmp12 := lang.Apply(tmp11, []any{v9}) tmp13, _ := lang.FieldOrMethod(v10, "write") if reflect.TypeOf(tmp13).Kind() != reflect.Func { @@ -41496,14 +41463,12 @@ func LoadNS() { tmp9 := reflect.TypeOf((*lang.Symbol)(nil)) var tmp10 lang.FnFunc tmp10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v11 := args[0] _ = v11 v12 := args[1] _ = v12 - tmp13 := checkDerefVar(glojure_DOT_core_print_simple) + tmp13 := checkDerefVar(var_glojure_DOT_core_print_DASH_simple) tmp14 := lang.Apply(tmp13, []any{v11, v12}) return tmp14 }) @@ -41511,19 +41476,17 @@ func LoadNS() { tmp11 := reflect.TypeOf((*lang.IRecord)(nil)).Elem() var tmp12 lang.FnFunc tmp12 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v13 := args[0] _ = v13 v14 := args[1] _ = v14 - tmp15 := checkDerefVar(glojure_DOT_core_print_meta) + tmp15 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) tmp16 := lang.Apply(tmp15, []any{v13, v14}) _ = tmp16 tmp17 := lang.Apply(lang.WriteWriter, []any{v14, "#"}) _ = tmp17 - tmp18 := checkDerefVar(glojure_DOT_core_class) + tmp18 := checkDerefVar(var_glojure_DOT_core_class) tmp19 := lang.Apply(tmp18, []any{v13}) tmp20, ok := lang.FieldOrMethod(tmp19, "Name") if !ok { @@ -41538,8 +41501,8 @@ func LoadNS() { } tmp22 := lang.Apply(lang.WriteWriter, []any{v14, tmp21}) _ = tmp22 - tmp23 := checkDerefVar(glojure_DOT_core_print_map) - tmp24 := checkDerefVar(glojure_DOT_core_pr_on) + tmp23 := checkDerefVar(var_glojure_DOT_core_print_DASH_map) + tmp24 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) tmp25 := lang.Apply(tmp23, []any{v13, tmp24, v14}) return tmp25 }) @@ -41547,14 +41510,12 @@ func LoadNS() { tmp13 := reflect.TypeOf(uint(0)) var tmp14 lang.FnFunc tmp14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v15 := args[0] _ = v15 v16 := args[1] _ = v16 - tmp17 := checkDerefVar(glojure_DOT_core_str) + tmp17 := checkDerefVar(var_glojure_DOT_core_str) tmp18 := lang.Apply(tmp17, []any{v15}) tmp19, _ := lang.FieldOrMethod(v16, "write") if reflect.TypeOf(tmp19).Kind() != reflect.Func { @@ -41567,14 +41528,12 @@ func LoadNS() { tmp15 := reflect.TypeOf(int64(0)) var tmp16 lang.FnFunc tmp16 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v17 := args[0] _ = v17 v18 := args[1] _ = v18 - tmp19 := checkDerefVar(glojure_DOT_core_str) + tmp19 := checkDerefVar(var_glojure_DOT_core_str) tmp20 := lang.Apply(tmp19, []any{v17}) tmp21, _ := lang.FieldOrMethod(v18, "write") if reflect.TypeOf(tmp21).Kind() != reflect.Func { @@ -41586,32 +41545,28 @@ func LoadNS() { tmp2.AddMethod(tmp15, tmp16) var tmp17 lang.FnFunc tmp17 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v18 := args[0] _ = v18 v19 := args[1] _ = v19 var tmp20 any - tmp21 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp21 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp22 := reflect.TypeOf((*lang.IObj)(nil)).Elem() tmp23 := lang.Apply(tmp21, []any{tmp22, v18}) if lang.IsTruthy(tmp23) { - tmp24 := checkDerefVar(glojure_DOT_core_print_method) - tmp25 := checkDerefVar(glojure_DOT_core_vary_meta) + tmp24 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp25 := checkDerefVar(var_glojure_DOT_core_vary_DASH_meta) var tmp26 lang.FnFunc tmp26 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v27 := args[0] _ = v27 - tmp28 := checkDerefVar(glojure_DOT_core_dissoc) - tmp29 := lang.Apply(tmp28, []any{v27, lang.NewKeyword("type")}) + tmp28 := checkDerefVar(var_glojure_DOT_core_dissoc) + tmp29 := lang.Apply(tmp28, []any{v27, kw_type}) return tmp29 }) - tmp27 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(87), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(87), lang.NewKeyword("end-column"), int(48)) + tmp27 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(87), kw_column, int(32), kw_end_DASH_line, int(87), kw_end_DASH_column, int(48)) tmp28, err := lang.WithMeta(tmp26, tmp27.(lang.IPersistentMap)) if err != nil { panic(err) @@ -41620,25 +41575,23 @@ func LoadNS() { tmp30 := lang.Apply(tmp24, []any{tmp29, v19}) tmp20 = tmp30 } else { - tmp31 := checkDerefVar(glojure_DOT_core_print_simple) + tmp31 := checkDerefVar(var_glojure_DOT_core_print_DASH_simple) tmp32 := lang.Apply(tmp31, []any{v18, v19}) tmp20 = tmp32 } return tmp20 }) - tmp2.AddMethod(lang.NewKeyword("default"), tmp17) + tmp2.AddMethod(kw_default, tmp17) tmp18 := reflect.TypeOf(float64(0)) var tmp19 lang.FnFunc tmp19 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v20 := args[0] _ = v20 v21 := args[1] _ = v21 var tmp22 any - tmp23 := checkDerefVar(glojure_DOT_core__EQ_) + tmp23 := checkDerefVar(var_glojure_DOT_core__EQ_) tmp24 := lang.Apply(math6.Inf, []any{int64(1)}) tmp25 := lang.Apply(tmp23, []any{tmp24, v20}) if lang.IsTruthy(tmp25) { @@ -41646,7 +41599,7 @@ func LoadNS() { tmp22 = tmp26 } else { var tmp27 any - tmp28 := checkDerefVar(glojure_DOT_core__EQ_) + tmp28 := checkDerefVar(var_glojure_DOT_core__EQ_) tmp29 := lang.Apply(math6.Inf, []any{int64(-1)}) tmp30 := lang.Apply(tmp28, []any{tmp29, v20}) if lang.IsTruthy(tmp30) { @@ -41660,8 +41613,8 @@ func LoadNS() { tmp32 = tmp34 } else { var tmp35 any - if lang.IsTruthy(lang.NewKeyword("else")) { - tmp36 := checkDerefVar(glojure_DOT_core_str) + if lang.IsTruthy(kw_else) { + tmp36 := checkDerefVar(var_glojure_DOT_core_str) tmp37 := lang.Apply(tmp36, []any{v20}) tmp38 := lang.Apply(lang.WriteWriter, []any{v21, tmp37}) tmp35 = tmp38 @@ -41679,9 +41632,7 @@ func LoadNS() { tmp20 := reflect.TypeOf("") var tmp21 lang.FnFunc tmp21 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v22 := args[0] _ = v22 v23 := args[1] @@ -41690,14 +41641,14 @@ func LoadNS() { var tmp25 any { // let // let binding "or__0__auto__" - tmp26 := checkDerefVar(glojure_DOT_core__STAR_print_dup_STAR_) + tmp26 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_dup_STAR_) var v27 any = tmp26 _ = v27 var tmp28 any if lang.IsTruthy(v27) { tmp28 = v27 } else { - tmp29 := checkDerefVar(glojure_DOT_core__STAR_print_readably_STAR_) + tmp29 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_readably_STAR_) tmp28 = tmp29 } tmp25 = tmp28 @@ -41708,8 +41659,8 @@ func LoadNS() { var tmp27 any { // let // let binding "n__0__auto__" - tmp28 := checkDerefVar(glojure_DOT_core_long) - tmp29 := checkDerefVar(glojure_DOT_core_count) + tmp28 := checkDerefVar(var_glojure_DOT_core_long) + tmp29 := checkDerefVar(var_glojure_DOT_core_count) tmp30 := lang.Apply(tmp29, []any{v22}) tmp31 := lang.Apply(tmp28, []any{tmp30}) var v32 any = tmp31 @@ -41721,7 +41672,7 @@ func LoadNS() { _ = v34 for { var tmp35 any - tmp36 := checkDerefVar(glojure_DOT_core__LT_) + tmp36 := checkDerefVar(var_glojure_DOT_core__LT_) tmp37 := lang.Apply(tmp36, []any{v34, v32}) if lang.IsTruthy(tmp37) { var tmp38 any @@ -41731,7 +41682,7 @@ func LoadNS() { var v40 any = tmp39 _ = v40 // let binding "e" - tmp41 := checkDerefVar(glojure_DOT_core_char_escape_string) + tmp41 := checkDerefVar(var_glojure_DOT_core_char_DASH_escape_DASH_string) tmp42 := lang.Apply(tmp41, []any{v40}) var v43 any = tmp42 _ = v43 @@ -41746,7 +41697,7 @@ func LoadNS() { tmp38 = tmp44 } // end let _ = tmp38 - tmp40 := checkDerefVar(glojure_DOT_core_unchecked_inc) + tmp40 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) tmp41 := lang.Apply(tmp40, []any{v34}) var tmp39 any = tmp41 v34 = tmp39 @@ -41773,9 +41724,7 @@ func LoadNS() { tmp22 := reflect.TypeOf(int32(0)) var tmp23 lang.FnFunc tmp23 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v24 := args[0] _ = v24 v25 := args[1] @@ -41784,14 +41733,14 @@ func LoadNS() { var tmp27 any { // let // let binding "or__0__auto__" - tmp28 := checkDerefVar(glojure_DOT_core__STAR_print_dup_STAR_) + tmp28 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_dup_STAR_) var v29 any = tmp28 _ = v29 var tmp30 any if lang.IsTruthy(v29) { tmp30 = v29 } else { - tmp31 := checkDerefVar(glojure_DOT_core__STAR_print_readably_STAR_) + tmp31 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_readably_STAR_) tmp30 = tmp31 } tmp27 = tmp30 @@ -41802,7 +41751,7 @@ func LoadNS() { var tmp29 any { // let // let binding "n" - tmp30 := checkDerefVar(glojure_DOT_core_char_name_string) + tmp30 := checkDerefVar(var_glojure_DOT_core_char_DASH_name_DASH_string) tmp31 := lang.Apply(tmp30, []any{v24}) var v32 any = tmp31 _ = v32 @@ -41828,44 +41777,42 @@ func LoadNS() { tmp24 := reflect.TypeOf((*lang.IPersistentMap)(nil)).Elem() var tmp25 lang.FnFunc tmp25 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v26 := args[0] _ = v26 v27 := args[1] _ = v27 - tmp28 := checkDerefVar(glojure_DOT_core_print_meta) + tmp28 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) tmp29 := lang.Apply(tmp28, []any{v26, v27}) _ = tmp29 var tmp30 any { // let // let binding "vec__234" - tmp31 := checkDerefVar(glojure_DOT_core_lift_ns) + tmp31 := checkDerefVar(var_glojure_DOT_core_lift_DASH_ns) tmp32 := lang.Apply(tmp31, []any{v26}) var v33 any = tmp32 _ = v33 // let binding "ns" - tmp34 := checkDerefVar(glojure_DOT_core_nth) + tmp34 := checkDerefVar(var_glojure_DOT_core_nth) tmp35 := lang.Apply(tmp34, []any{v33, int64(0), nil}) var v36 any = tmp35 _ = v36 // let binding "lift-kvs" - tmp37 := checkDerefVar(glojure_DOT_core_nth) + tmp37 := checkDerefVar(var_glojure_DOT_core_nth) tmp38 := lang.Apply(tmp37, []any{v33, int64(1), nil}) var v39 any = tmp38 _ = v39 var tmp40 any if lang.IsTruthy(v36) { - tmp41 := checkDerefVar(glojure_DOT_core_print_prefix_map) - tmp42 := checkDerefVar(glojure_DOT_core_str) + tmp41 := checkDerefVar(var_glojure_DOT_core_print_DASH_prefix_DASH_map) + tmp42 := checkDerefVar(var_glojure_DOT_core_str) tmp43 := lang.Apply(tmp42, []any{"#:", v36}) - tmp44 := checkDerefVar(glojure_DOT_core_pr_on) + tmp44 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) tmp45 := lang.Apply(tmp41, []any{tmp43, v39, tmp44, v27}) tmp40 = tmp45 } else { - tmp46 := checkDerefVar(glojure_DOT_core_print_map) - tmp47 := checkDerefVar(glojure_DOT_core_pr_on) + tmp46 := checkDerefVar(var_glojure_DOT_core_print_DASH_map) + tmp47 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) tmp48 := lang.Apply(tmp46, []any{v26, tmp47, v27}) tmp40 = tmp48 } @@ -41877,18 +41824,16 @@ func LoadNS() { tmp26 := reflect.TypeOf((*lang.IPersistentVector)(nil)).Elem() var tmp27 lang.FnFunc tmp27 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v28 := args[0] _ = v28 v29 := args[1] _ = v29 - tmp30 := checkDerefVar(glojure_DOT_core_print_meta) + tmp30 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) tmp31 := lang.Apply(tmp30, []any{v28, v29}) _ = tmp31 - tmp32 := checkDerefVar(glojure_DOT_core_print_sequential) - tmp33 := checkDerefVar(glojure_DOT_core_pr_on) + tmp32 := checkDerefVar(var_glojure_DOT_core_print_DASH_sequential) + tmp33 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) tmp34 := lang.Apply(tmp32, []any{"[", tmp33, " ", "]", v28, v29}) return tmp34 }) @@ -41896,19 +41841,17 @@ func LoadNS() { tmp28 := reflect.TypeOf((*lang.IPersistentSet)(nil)).Elem() var tmp29 lang.FnFunc tmp29 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v30 := args[0] _ = v30 v31 := args[1] _ = v31 - tmp32 := checkDerefVar(glojure_DOT_core_print_meta) + tmp32 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) tmp33 := lang.Apply(tmp32, []any{v30, v31}) _ = tmp33 - tmp34 := checkDerefVar(glojure_DOT_core_print_sequential) - tmp35 := checkDerefVar(glojure_DOT_core_pr_on) - tmp36 := checkDerefVar(glojure_DOT_core_seq) + tmp34 := checkDerefVar(var_glojure_DOT_core_print_DASH_sequential) + tmp35 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) + tmp36 := checkDerefVar(var_glojure_DOT_core_seq) tmp37 := lang.Apply(tmp36, []any{v30}) tmp38 := lang.Apply(tmp34, []any{"#{", tmp35, " ", "}", tmp37, v31}) return tmp38 @@ -41917,14 +41860,12 @@ func LoadNS() { tmp30 := reflect.TypeOf(uint8(0)) var tmp31 lang.FnFunc tmp31 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v32 := args[0] _ = v32 v33 := args[1] _ = v33 - tmp34 := checkDerefVar(glojure_DOT_core_str) + tmp34 := checkDerefVar(var_glojure_DOT_core_str) tmp35 := lang.Apply(tmp34, []any{v32}) tmp36, _ := lang.FieldOrMethod(v33, "write") if reflect.TypeOf(tmp36).Kind() != reflect.Func { @@ -41937,15 +41878,13 @@ func LoadNS() { tmp32 := reflect.TypeOf((*lang.IDeref)(nil)).Elem() var tmp33 lang.FnFunc tmp33 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v34 := args[0] _ = v34 v35 := args[1] _ = v35 - tmp36 := checkDerefVar(glojure_DOT_core_print_tagged_object) - tmp37 := checkDerefVar(glojure_DOT_core_deref_as_map) + tmp36 := checkDerefVar(var_glojure_DOT_core_print_DASH_tagged_DASH_object) + tmp37 := checkDerefVar(var_glojure_DOT_core_deref_DASH_as_DASH_map) tmp38 := lang.Apply(tmp37, []any{v34}) tmp39 := lang.Apply(tmp36, []any{v34, tmp38, v35}) return tmp39 @@ -41954,14 +41893,12 @@ func LoadNS() { tmp34 := reflect.TypeOf(false) var tmp35 lang.FnFunc tmp35 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v36 := args[0] _ = v36 v37 := args[1] _ = v37 - tmp38 := checkDerefVar(glojure_DOT_core_str) + tmp38 := checkDerefVar(var_glojure_DOT_core_str) tmp39 := lang.Apply(tmp38, []any{v36}) tmp40 := lang.Apply(lang.WriteWriter, []any{v37, tmp39}) return tmp40 @@ -41970,14 +41907,12 @@ func LoadNS() { tmp36 := reflect.TypeOf((*lang.Object)(nil)).Elem() var tmp37 lang.FnFunc tmp37 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v38 := args[0] _ = v38 v39 := args[1] _ = v39 - tmp40 := checkDerefVar(glojure_DOT_core_print_object) + tmp40 := checkDerefVar(var_glojure_DOT_core_print_DASH_object) tmp41 := lang.Apply(tmp40, []any{v38, v39}) return tmp41 }) @@ -41985,14 +41920,12 @@ func LoadNS() { tmp38 := reflect.TypeOf(int(0)) var tmp39 lang.FnFunc tmp39 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v40 := args[0] _ = v40 v41 := args[1] _ = v41 - tmp42 := checkDerefVar(glojure_DOT_core_str) + tmp42 := checkDerefVar(var_glojure_DOT_core_str) tmp43 := lang.Apply(tmp42, []any{v40}) tmp44, _ := lang.FieldOrMethod(v41, "write") if reflect.TypeOf(tmp44).Kind() != reflect.Func { @@ -42005,9 +41938,7 @@ func LoadNS() { tmp40 := reflect.TypeOf((*regexp15.Regexp)(nil)) var tmp41 lang.FnFunc tmp41 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v42 := args[0] _ = v42 v43 := args[1] @@ -42017,7 +41948,7 @@ func LoadNS() { var tmp45 any { // let // let binding "G__240" - tmp46 := checkDerefVar(glojure_DOT_core_seq) + tmp46 := checkDerefVar(var_glojure_DOT_core_seq) tmp47, ok := lang.FieldOrMethod(v42, "String") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v42, "String"))) @@ -42036,17 +41967,17 @@ func LoadNS() { var v51 any = v50 _ = v51 // let binding "seq__242" - tmp52 := checkDerefVar(glojure_DOT_core_seq) + tmp52 := checkDerefVar(var_glojure_DOT_core_seq) tmp53 := lang.Apply(tmp52, []any{v51}) var v54 any = tmp53 _ = v54 // let binding "first__243" - tmp55 := checkDerefVar(glojure_DOT_core_first) + tmp55 := checkDerefVar(var_glojure_DOT_core_first) tmp56 := lang.Apply(tmp55, []any{v54}) var v57 any = tmp56 _ = v57 // let binding "seq__242" - tmp58 := checkDerefVar(glojure_DOT_core_next) + tmp58 := checkDerefVar(var_glojure_DOT_core_next) tmp59 := lang.Apply(tmp58, []any{v54}) var v60 any = tmp59 _ = v60 @@ -42077,17 +42008,17 @@ func LoadNS() { var v69 any = v66 _ = v69 // let binding "seq__245" - tmp70 := checkDerefVar(glojure_DOT_core_seq) + tmp70 := checkDerefVar(var_glojure_DOT_core_seq) tmp71 := lang.Apply(tmp70, []any{v69}) var v72 any = tmp71 _ = v72 // let binding "first__246" - tmp73 := checkDerefVar(glojure_DOT_core_first) + tmp73 := checkDerefVar(var_glojure_DOT_core_first) tmp74 := lang.Apply(tmp73, []any{v72}) var v75 any = tmp74 _ = v75 // let binding "seq__245" - tmp76 := checkDerefVar(glojure_DOT_core_next) + tmp76 := checkDerefVar(var_glojure_DOT_core_next) tmp77 := lang.Apply(tmp76, []any{v72}) var v78 any = tmp77 _ = v78 @@ -42106,7 +42037,7 @@ func LoadNS() { var tmp83 any if lang.IsTruthy(v81) { var tmp84 any - tmp85 := checkDerefVar(glojure_DOT_core__EQ_) + tmp85 := checkDerefVar(var_glojure_DOT_core__EQ_) tmp86 := lang.Apply(tmp85, []any{v79, lang.NewChar(92)}) if lang.IsTruthy(tmp86) { var tmp87 any @@ -42115,17 +42046,17 @@ func LoadNS() { var v88 any = v80 _ = v88 // let binding "seq__248" - tmp89 := checkDerefVar(glojure_DOT_core_seq) + tmp89 := checkDerefVar(var_glojure_DOT_core_seq) tmp90 := lang.Apply(tmp89, []any{v88}) var v91 any = tmp90 _ = v91 // let binding "first__249" - tmp92 := checkDerefVar(glojure_DOT_core_first) + tmp92 := checkDerefVar(var_glojure_DOT_core_first) tmp93 := lang.Apply(tmp92, []any{v91}) var v94 any = tmp93 _ = v94 // let binding "seq__248" - tmp95 := checkDerefVar(glojure_DOT_core_next) + tmp95 := checkDerefVar(var_glojure_DOT_core_next) tmp96 := lang.Apply(tmp95, []any{v91}) var v97 any = tmp96 _ = v97 @@ -42142,7 +42073,7 @@ func LoadNS() { var tmp102 any if lang.IsTruthy(v82) { var tmp103 any = v99 - tmp105 := checkDerefVar(glojure_DOT_core_not_EQ_) + tmp105 := checkDerefVar(var_glojure_DOT_core_not_EQ_) tmp106 := lang.Apply(tmp105, []any{v98, lang.NewChar(69)}) var tmp104 any = tmp106 v66 = tmp103 @@ -42150,7 +42081,7 @@ func LoadNS() { continue } else { var tmp107 any = v99 - tmp109 := checkDerefVar(glojure_DOT_core__EQ_) + tmp109 := checkDerefVar(var_glojure_DOT_core__EQ_) tmp110 := lang.Apply(tmp109, []any{v98, lang.NewChar(81)}) var tmp108 any = tmp110 v66 = tmp107 @@ -42162,7 +42093,7 @@ func LoadNS() { tmp84 = tmp87 } else { var tmp88 any - tmp89 := checkDerefVar(glojure_DOT_core__EQ_) + tmp89 := checkDerefVar(var_glojure_DOT_core__EQ_) tmp90 := lang.Apply(tmp89, []any{v79, lang.NewChar(34)}) if lang.IsTruthy(tmp90) { var tmp91 any @@ -42181,7 +42112,7 @@ func LoadNS() { continue } else { var tmp96 any - if lang.IsTruthy(lang.NewKeyword("else")) { + if lang.IsTruthy(kw_else) { tmp97 := lang.Apply(lang.AppendWriter, []any{v43, v79}) _ = tmp97 var tmp98 any = v80 @@ -42214,14 +42145,12 @@ func LoadNS() { tmp42 := reflect.TypeOf(int32(0)) var tmp43 lang.FnFunc tmp43 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v44 := args[0] _ = v44 v45 := args[1] _ = v45 - tmp46 := checkDerefVar(glojure_DOT_core_str) + tmp46 := checkDerefVar(var_glojure_DOT_core_str) tmp47 := lang.Apply(tmp46, []any{v44}) tmp48, _ := lang.FieldOrMethod(v45, "write") if reflect.TypeOf(tmp48).Kind() != reflect.Func { @@ -42234,14 +42163,12 @@ func LoadNS() { tmp44 := reflect.TypeOf((*lang.Ratio)(nil)) var tmp45 lang.FnFunc tmp45 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v46 := args[0] _ = v46 v47 := args[1] _ = v47 - tmp48 := checkDerefVar(glojure_DOT_core_str) + tmp48 := checkDerefVar(var_glojure_DOT_core_str) tmp49 := lang.Apply(tmp48, []any{v46}) tmp50, _ := lang.FieldOrMethod(v47, "write") if reflect.TypeOf(tmp50).Kind() != reflect.Func { @@ -42254,15 +42181,13 @@ func LoadNS() { tmp46 := reflect.TypeOf(float32(0)) var tmp47 lang.FnFunc tmp47 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v48 := args[0] _ = v48 v49 := args[1] _ = v49 var tmp50 any - tmp51 := checkDerefVar(glojure_DOT_core__EQ_) + tmp51 := checkDerefVar(var_glojure_DOT_core__EQ_) tmp52 := lang.Apply(math6.Inf, []any{int64(1)}) tmp53 := lang.Apply(lang.Builtins["float32"], []any{tmp52}) tmp54 := lang.Apply(tmp51, []any{tmp53, v48}) @@ -42271,7 +42196,7 @@ func LoadNS() { tmp50 = tmp55 } else { var tmp56 any - tmp57 := checkDerefVar(glojure_DOT_core__EQ_) + tmp57 := checkDerefVar(var_glojure_DOT_core__EQ_) tmp58 := lang.Apply(math6.Inf, []any{int64(-1)}) tmp59 := lang.Apply(lang.Builtins["float32"], []any{tmp58}) tmp60 := lang.Apply(tmp57, []any{tmp59, v48}) @@ -42286,8 +42211,8 @@ func LoadNS() { tmp62 = tmp64 } else { var tmp65 any - if lang.IsTruthy(lang.NewKeyword("else")) { - tmp66 := checkDerefVar(glojure_DOT_core_str) + if lang.IsTruthy(kw_else) { + tmp66 := checkDerefVar(var_glojure_DOT_core_str) tmp67 := lang.Apply(tmp66, []any{v48}) tmp68 := lang.Apply(lang.WriteWriter, []any{v49, tmp67}) tmp65 = tmp68 @@ -42305,14 +42230,12 @@ func LoadNS() { tmp48 := reflect.TypeOf(int16(0)) var tmp49 lang.FnFunc tmp49 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v50 := args[0] _ = v50 v51 := args[1] _ = v51 - tmp52 := checkDerefVar(glojure_DOT_core_str) + tmp52 := checkDerefVar(var_glojure_DOT_core_str) tmp53 := lang.Apply(tmp52, []any{v50}) tmp54, _ := lang.FieldOrMethod(v51, "write") if reflect.TypeOf(tmp54).Kind() != reflect.Func { @@ -42325,14 +42248,12 @@ func LoadNS() { tmp50 := reflect.TypeOf((*lang.Var)(nil)) var tmp51 lang.FnFunc tmp51 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v52 := args[0] _ = v52 v53 := args[1] _ = v53 - tmp54 := checkDerefVar(glojure_DOT_core_print_simple) + tmp54 := checkDerefVar(var_glojure_DOT_core_print_DASH_simple) tmp55 := lang.Apply(tmp54, []any{v52, v53}) return tmp55 }) @@ -42340,14 +42261,12 @@ func LoadNS() { tmp52 := reflect.TypeOf(int8(0)) var tmp53 lang.FnFunc tmp53 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v54 := args[0] _ = v54 v55 := args[1] _ = v55 - tmp56 := checkDerefVar(glojure_DOT_core_str) + tmp56 := checkDerefVar(var_glojure_DOT_core_str) tmp57 := lang.Apply(tmp56, []any{v54}) tmp58, _ := lang.FieldOrMethod(v55, "write") if reflect.TypeOf(tmp58).Kind() != reflect.Func { @@ -42360,14 +42279,12 @@ func LoadNS() { tmp54 := reflect.TypeOf(uint16(0)) var tmp55 lang.FnFunc tmp55 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v56 := args[0] _ = v56 v57 := args[1] _ = v57 - tmp58 := checkDerefVar(glojure_DOT_core_str) + tmp58 := checkDerefVar(var_glojure_DOT_core_str) tmp59 := lang.Apply(tmp58, []any{v56}) tmp60, _ := lang.FieldOrMethod(v57, "write") if reflect.TypeOf(tmp60).Kind() != reflect.Func { @@ -42380,14 +42297,12 @@ func LoadNS() { tmp56 := reflect.TypeOf(uint64(0)) var tmp57 lang.FnFunc tmp57 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v58 := args[0] _ = v58 v59 := args[1] _ = v59 - tmp60 := checkDerefVar(glojure_DOT_core_str) + tmp60 := checkDerefVar(var_glojure_DOT_core_str) tmp61 := lang.Apply(tmp60, []any{v58}) tmp62, _ := lang.FieldOrMethod(v59, "write") if reflect.TypeOf(tmp62).Kind() != reflect.Func { @@ -42400,14 +42315,12 @@ func LoadNS() { tmp58 := reflect.TypeOf((*lang.BigDecimal)(nil)) var tmp59 lang.FnFunc tmp59 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v60 := args[0] _ = v60 v61 := args[1] _ = v61 - tmp62 := checkDerefVar(glojure_DOT_core_str) + tmp62 := checkDerefVar(var_glojure_DOT_core_str) tmp63 := lang.Apply(tmp62, []any{v60}) tmp64 := lang.Apply(lang.WriteWriter, []any{v61, tmp63}) _ = tmp64 @@ -42418,14 +42331,12 @@ func LoadNS() { tmp60 := reflect.TypeOf((*lang.BigInt)(nil)) var tmp61 lang.FnFunc tmp61 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v62 := args[0] _ = v62 v63 := args[1] _ = v63 - tmp64 := checkDerefVar(glojure_DOT_core_str) + tmp64 := checkDerefVar(var_glojure_DOT_core_str) tmp65 := lang.Apply(tmp64, []any{v62}) tmp66 := lang.Apply(lang.WriteWriter, []any{v63, tmp65}) _ = tmp66 @@ -42436,18 +42347,16 @@ func LoadNS() { tmp62 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() var tmp63 lang.FnFunc tmp63 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v64 := args[0] _ = v64 v65 := args[1] _ = v65 - tmp66 := checkDerefVar(glojure_DOT_core_print_meta) + tmp66 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) tmp67 := lang.Apply(tmp66, []any{v64, v65}) _ = tmp67 - tmp68 := checkDerefVar(glojure_DOT_core_print_sequential) - tmp69 := checkDerefVar(glojure_DOT_core_pr_on) + tmp68 := checkDerefVar(var_glojure_DOT_core_print_DASH_sequential) + tmp69 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) tmp70 := lang.Apply(tmp68, []any{"(", tmp69, " ", ")", v64, v65}) return tmp70 }) @@ -42465,23 +42374,21 @@ func LoadNS() { } // print-object { - tmp0 := lang.NewSymbol("print-object").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(115), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(115), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym_print_DASH_object.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(115), kw_column, int(8), kw_end_DASH_line, int(115), kw_end_DASH_column, int(19), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_o, sym_w)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_print_tagged_object) - tmp6 := checkDerefVar(glojure_DOT_core_str) + tmp5 := checkDerefVar(var_glojure_DOT_core_print_DASH_tagged_DASH_object) + tmp6 := checkDerefVar(var_glojure_DOT_core_str) tmp7 := lang.Apply(tmp6, []any{v3}) tmp8 := lang.Apply(tmp5, []any{v3, tmp7, v4}) return tmp8 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -42489,12 +42396,10 @@ func LoadNS() { } // print-prefix-map { - tmp0 := lang.NewSymbol("print-prefix-map").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(243), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(243), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("prefix"), lang.NewSymbol("kvs"), lang.NewSymbol("print-one"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym_print_DASH_prefix_DASH_map.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(243), kw_column, int(8), kw_end_DASH_line, int(243), kw_end_DASH_column, int(23), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_prefix, sym_kvs, sym_print_DASH_one, sym_w)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 4) v3 := args[0] _ = v3 v4 := args[1] @@ -42503,14 +42408,12 @@ func LoadNS() { _ = v5 v6 := args[3] _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_print_sequential) - tmp8 := checkDerefVar(glojure_DOT_core_str) + tmp7 := checkDerefVar(var_glojure_DOT_core_print_DASH_sequential) + tmp8 := checkDerefVar(var_glojure_DOT_core_str) tmp9 := lang.Apply(tmp8, []any{v3, "{"}) var tmp10 lang.FnFunc tmp10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v11 := args[0] _ = v11 v12 := args[1] @@ -42521,12 +42424,12 @@ func LoadNS() { var v14 any = v11 _ = v14 // let binding "k" - tmp15 := checkDerefVar(glojure_DOT_core_nth) + tmp15 := checkDerefVar(var_glojure_DOT_core_nth) tmp16 := lang.Apply(tmp15, []any{v14, int64(0), nil}) var v17 any = tmp16 _ = v17 // let binding "v" - tmp18 := checkDerefVar(glojure_DOT_core_nth) + tmp18 := checkDerefVar(var_glojure_DOT_core_nth) tmp19 := lang.Apply(tmp18, []any{v14, int64(1), nil}) var v20 any = tmp19 _ = v20 @@ -42539,7 +42442,7 @@ func LoadNS() { } // end let return tmp13 }) - tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(246), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(247), lang.NewKeyword("end-column"), int(107)) + tmp11 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(246), kw_column, int(5), kw_end_DASH_line, int(247), kw_end_DASH_column, int(107)) tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) if err != nil { panic(err) @@ -42547,7 +42450,7 @@ func LoadNS() { tmp13 := lang.Apply(tmp7, []any{tmp9, tmp12, ", ", "}", v4, v6}) return tmp13 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -42555,12 +42458,10 @@ func LoadNS() { } // print-sequential { - tmp0 := lang.NewSymbol("print-sequential").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(46), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(46), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("begin"), lang.NewSymbol("print-one"), lang.NewSymbol("sep"), lang.NewSymbol("end"), lang.NewSymbol("sequence"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym_print_DASH_sequential.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(46), kw_column, int(8), kw_end_DASH_line, int(46), kw_end_DASH_column, int(23), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_begin, sym_print_DASH_one, sym_sep, sym_end, sym_sequence, sym_w)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 6 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 6) v3 := args[0] _ = v3 v4 := args[1] @@ -42575,14 +42476,14 @@ func LoadNS() { _ = v8 var tmp9 any { // let - tmp10 := checkDerefVar(glojure_DOT_core_push_thread_bindings) - tmp11 := checkDerefVar(glojure_DOT_core_hash_map) - tmp12 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*print-level*")) + tmp10 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp11 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp12 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_print_DASH_level_STAR_) var tmp13 any { // let // let binding "and__0__auto__" - tmp14 := checkDerefVar(glojure_DOT_core_not) - tmp15 := checkDerefVar(glojure_DOT_core__STAR_print_dup_STAR_) + tmp14 := checkDerefVar(var_glojure_DOT_core_not) + tmp15 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_dup_STAR_) tmp16 := lang.Apply(tmp14, []any{tmp15}) var v17 any = tmp16 _ = v17 @@ -42591,13 +42492,13 @@ func LoadNS() { var tmp19 any { // let // let binding "and__0__auto__" - tmp20 := checkDerefVar(glojure_DOT_core__STAR_print_level_STAR_) + tmp20 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_level_STAR_) var v21 any = tmp20 _ = v21 var tmp22 any if lang.IsTruthy(v21) { - tmp23 := checkDerefVar(glojure_DOT_core_dec) - tmp24 := checkDerefVar(glojure_DOT_core__STAR_print_level_STAR_) + tmp23 := checkDerefVar(var_glojure_DOT_core_dec) + tmp24 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_level_STAR_) tmp25 := lang.Apply(tmp23, []any{tmp24}) tmp22 = tmp25 } else { @@ -42617,7 +42518,7 @@ func LoadNS() { var tmp16 any func() { defer func() { - tmp17 := checkDerefVar(glojure_DOT_core_pop_thread_bindings) + tmp17 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) tmp18 := lang.Apply(tmp17, nil) _ = tmp18 }() @@ -42625,13 +42526,13 @@ func LoadNS() { var tmp20 any { // let // let binding "and__0__auto__" - tmp21 := checkDerefVar(glojure_DOT_core__STAR_print_level_STAR_) + tmp21 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_level_STAR_) var v22 any = tmp21 _ = v22 var tmp23 any if lang.IsTruthy(v22) { - tmp24 := checkDerefVar(glojure_DOT_core_neg_QMARK_) - tmp25 := checkDerefVar(glojure_DOT_core__STAR_print_level_STAR_) + tmp24 := checkDerefVar(var_glojure_DOT_core_neg_QMARK_) + tmp25 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_level_STAR_) tmp26 := lang.Apply(tmp24, []any{tmp25}) tmp23 = tmp26 } else { @@ -42648,7 +42549,7 @@ func LoadNS() { var tmp23 any { // let // let binding "temp__0__auto__" - tmp24 := checkDerefVar(glojure_DOT_core_seq) + tmp24 := checkDerefVar(var_glojure_DOT_core_seq) tmp25 := lang.Apply(tmp24, []any{v7}) var v26 any = tmp25 _ = v26 @@ -42663,14 +42564,14 @@ func LoadNS() { var tmp31 any { // let // let binding "and__0__auto__" - tmp32 := checkDerefVar(glojure_DOT_core_not) - tmp33 := checkDerefVar(glojure_DOT_core__STAR_print_dup_STAR_) + tmp32 := checkDerefVar(var_glojure_DOT_core_not) + tmp33 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_dup_STAR_) tmp34 := lang.Apply(tmp32, []any{tmp33}) var v35 any = tmp34 _ = v35 var tmp36 any if lang.IsTruthy(v35) { - tmp37 := checkDerefVar(glojure_DOT_core__STAR_print_length_STAR_) + tmp37 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_length_STAR_) tmp36 = tmp37 } else { tmp36 = v35 @@ -42687,17 +42588,17 @@ func LoadNS() { var v34 any = v33 _ = v34 // let binding "seq__196" - tmp35 := checkDerefVar(glojure_DOT_core_seq) + tmp35 := checkDerefVar(var_glojure_DOT_core_seq) tmp36 := lang.Apply(tmp35, []any{v34}) var v37 any = tmp36 _ = v37 // let binding "first__197" - tmp38 := checkDerefVar(glojure_DOT_core_first) + tmp38 := checkDerefVar(var_glojure_DOT_core_first) tmp39 := lang.Apply(tmp38, []any{v37}) var v40 any = tmp39 _ = v40 // let binding "seq__196" - tmp41 := checkDerefVar(glojure_DOT_core_next) + tmp41 := checkDerefVar(var_glojure_DOT_core_next) tmp42 := lang.Apply(tmp41, []any{v37}) var v43 any = tmp42 _ = v43 @@ -42708,7 +42609,7 @@ func LoadNS() { var v45 any = v43 _ = v45 // let binding "print-length" - tmp46 := checkDerefVar(glojure_DOT_core__STAR_print_length_STAR_) + tmp46 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_length_STAR_) var v47 any = tmp46 _ = v47 var tmp48 any @@ -42726,17 +42627,17 @@ func LoadNS() { var v52 any = v49 _ = v52 // let binding "seq__199" - tmp53 := checkDerefVar(glojure_DOT_core_seq) + tmp53 := checkDerefVar(var_glojure_DOT_core_seq) tmp54 := lang.Apply(tmp53, []any{v52}) var v55 any = tmp54 _ = v55 // let binding "first__200" - tmp56 := checkDerefVar(glojure_DOT_core_first) + tmp56 := checkDerefVar(var_glojure_DOT_core_first) tmp57 := lang.Apply(tmp56, []any{v55}) var v58 any = tmp57 _ = v58 // let binding "seq__199" - tmp59 := checkDerefVar(glojure_DOT_core_next) + tmp59 := checkDerefVar(var_glojure_DOT_core_next) tmp60 := lang.Apply(tmp59, []any{v55}) var v61 any = tmp60 _ = v61 @@ -42750,7 +42651,7 @@ func LoadNS() { var v64 any = v50 _ = v64 var tmp65 any - tmp66 := checkDerefVar(glojure_DOT_core_zero_QMARK_) + tmp66 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) tmp67 := lang.Apply(tmp66, []any{v64}) if lang.IsTruthy(tmp67) { tmp68 := lang.Apply(lang.WriteWriter, []any{v8, "..."}) @@ -42763,7 +42664,7 @@ func LoadNS() { tmp71 := lang.Apply(lang.WriteWriter, []any{v8, v5}) _ = tmp71 var tmp72 any = v63 - tmp74 := checkDerefVar(glojure_DOT_core_dec) + tmp74 := checkDerefVar(var_glojure_DOT_core_dec) tmp75 := lang.Apply(tmp74, []any{v64}) var tmp73 any = tmp75 v49 = tmp72 @@ -42792,17 +42693,17 @@ func LoadNS() { var v35 any = v34 _ = v35 // let binding "seq__206" - tmp36 := checkDerefVar(glojure_DOT_core_seq) + tmp36 := checkDerefVar(var_glojure_DOT_core_seq) tmp37 := lang.Apply(tmp36, []any{v35}) var v38 any = tmp37 _ = v38 // let binding "first__207" - tmp39 := checkDerefVar(glojure_DOT_core_first) + tmp39 := checkDerefVar(var_glojure_DOT_core_first) tmp40 := lang.Apply(tmp39, []any{v38}) var v41 any = tmp40 _ = v41 // let binding "seq__206" - tmp42 := checkDerefVar(glojure_DOT_core_next) + tmp42 := checkDerefVar(var_glojure_DOT_core_next) tmp43 := lang.Apply(tmp42, []any{v38}) var v44 any = tmp43 _ = v44 @@ -42824,17 +42725,17 @@ func LoadNS() { var v50 any = v48 _ = v50 // let binding "seq__209" - tmp51 := checkDerefVar(glojure_DOT_core_seq) + tmp51 := checkDerefVar(var_glojure_DOT_core_seq) tmp52 := lang.Apply(tmp51, []any{v50}) var v53 any = tmp52 _ = v53 // let binding "first__210" - tmp54 := checkDerefVar(glojure_DOT_core_first) + tmp54 := checkDerefVar(var_glojure_DOT_core_first) tmp55 := lang.Apply(tmp54, []any{v53}) var v56 any = tmp55 _ = v56 // let binding "seq__209" - tmp57 := checkDerefVar(glojure_DOT_core_next) + tmp57 := checkDerefVar(var_glojure_DOT_core_next) tmp58 := lang.Apply(tmp57, []any{v53}) var v59 any = tmp58 _ = v59 @@ -42882,7 +42783,7 @@ func LoadNS() { } // end let return tmp9 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -42890,25 +42791,23 @@ func LoadNS() { } // print-simple { - tmp0 := lang.NewSymbol("print-simple").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(81), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(81), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym_print_DASH_simple.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(81), kw_column, int(7), kw_end_DASH_line, int(81), kw_end_DASH_column, int(18), kw_arglists, lang.NewList(lang.NewVector(sym_o, sym_w)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_print_meta) + tmp5 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) tmp6 := lang.Apply(tmp5, []any{v3, v4}) _ = tmp6 - tmp7 := checkDerefVar(glojure_DOT_core_str) + tmp7 := checkDerefVar(var_glojure_DOT_core_str) tmp8 := lang.Apply(tmp7, []any{v3}) tmp9 := lang.Apply(lang.WriteWriter, []any{v4, tmp8}) return tmp9 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -42917,14 +42816,12 @@ func LoadNS() { // print-str { tmp1 := reflect.TypeOf("") - tmp0 := lang.NewSymbol("print-str").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("xs"))), lang.NewKeyword("doc"), "print to a string, returning it", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4776), lang.NewKeyword("end-line"), int(4776))).(*lang.Symbol) + tmp0 := sym_print_DASH_str.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_xs)), kw_doc, "print to a string, returning it", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(4776), kw_end_DASH_line, int(4776))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var v4 any = lang.NewList(args[0:]...) _ = v4 var tmp5 any @@ -42934,24 +42831,24 @@ func LoadNS() { _ = v6 var tmp7 any { // let - tmp8 := checkDerefVar(glojure_DOT_core_push_thread_bindings) - tmp9 := checkDerefVar(glojure_DOT_core_hash_map) - tmp10 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*out*")) + tmp8 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp9 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp10 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) tmp11 := lang.Apply(tmp9, []any{tmp10, v6}) tmp12 := lang.Apply(tmp8, []any{tmp11}) _ = tmp12 var tmp13 any func() { defer func() { - tmp14 := checkDerefVar(glojure_DOT_core_pop_thread_bindings) + tmp14 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) tmp15 := lang.Apply(tmp14, nil) _ = tmp15 }() - tmp16 := checkDerefVar(glojure_DOT_core_apply) - tmp17 := checkDerefVar(glojure_DOT_core_print) + tmp16 := checkDerefVar(var_glojure_DOT_core_apply) + tmp17 := checkDerefVar(var_glojure_DOT_core_print) tmp18 := lang.Apply(tmp16, []any{tmp17, v4}) _ = tmp18 - tmp19 := checkDerefVar(glojure_DOT_core_str) + tmp19 := checkDerefVar(var_glojure_DOT_core_str) tmp20 := lang.Apply(tmp19, []any{v6}) tmp13 = tmp20 }() @@ -42963,7 +42860,7 @@ func LoadNS() { } }) tmp4 := reflect.TypeOf("") - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -42971,12 +42868,10 @@ func LoadNS() { } // print-tagged-object { - tmp0 := lang.NewSymbol("print-tagged-object").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(102), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(102), lang.NewKeyword("end-column"), int(26), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("rep"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym_print_DASH_tagged_DASH_object.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(102), kw_column, int(8), kw_end_DASH_line, int(102), kw_end_DASH_column, int(26), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_o, sym_rep, sym_w)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -42984,11 +42879,11 @@ func LoadNS() { v5 := args[2] _ = v5 var tmp6 any - tmp7 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp7 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp8 := reflect.TypeOf((*lang.IMeta)(nil)).Elem() tmp9 := lang.Apply(tmp7, []any{tmp8, v3}) if lang.IsTruthy(tmp9) { - tmp10 := checkDerefVar(glojure_DOT_core_print_meta) + tmp10 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) tmp11 := lang.Apply(tmp10, []any{v3, v5}) tmp6 = tmp11 } else { @@ -42999,13 +42894,13 @@ func LoadNS() { var tmp13 any { // let // let binding "c" - tmp14 := checkDerefVar(glojure_DOT_core_class) + tmp14 := checkDerefVar(var_glojure_DOT_core_class) tmp15 := lang.Apply(tmp14, []any{v3}) var v16 any = tmp15 _ = v16 var tmp17 any if lang.IsTruthy(false) { - tmp18 := checkDerefVar(glojure_DOT_core_print_method) + tmp18 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) tmp19, ok := lang.FieldOrMethod(v16, "Name") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v16, "Name"))) @@ -43039,18 +42934,18 @@ func LoadNS() { _ = tmp13 tmp14 := lang.Apply(lang.WriteWriter, []any{v5, " "}) _ = tmp14 - tmp15 := checkDerefVar(glojure_DOT_core_format) + tmp15 := checkDerefVar(var_glojure_DOT_core_format) tmp16 := lang.Apply(lang.IdentityHash, []any{v3}) tmp17 := lang.Apply(tmp15, []any{"0x%x ", tmp16}) tmp18 := lang.Apply(lang.WriteWriter, []any{v5, tmp17}) _ = tmp18 - tmp19 := checkDerefVar(glojure_DOT_core_print_method) + tmp19 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) tmp20 := lang.Apply(tmp19, []any{v4, v5}) _ = tmp20 tmp21 := lang.Apply(lang.WriteWriter, []any{v5, "]"}) return tmp21 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -43058,12 +42953,10 @@ func LoadNS() { } // print-throwable { - tmp0 := lang.NewSymbol("print-throwable").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(478), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(478), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("o"), lang.NewSymbol("w"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym_print_DASH_throwable.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(478), kw_column, int(8), kw_end_DASH_line, int(478), kw_end_DASH_column, int(22), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_o, sym_w)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -43073,29 +42966,29 @@ func LoadNS() { var tmp6 any { // let // let binding "map__253" - tmp7 := checkDerefVar(glojure_DOT_core_Throwable__GT_map) + tmp7 := checkDerefVar(var_glojure_DOT_core_Throwable_DASH__GT_map) tmp8 := lang.Apply(tmp7, []any{v3}) var v9 any = tmp8 _ = v9 // let binding "map__253" var tmp10 any - tmp11 := checkDerefVar(glojure_DOT_core_seq_QMARK_) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) tmp12 := lang.Apply(tmp11, []any{v9}) if lang.IsTruthy(tmp12) { var tmp13 any - tmp14 := checkDerefVar(glojure_DOT_core_next) + tmp14 := checkDerefVar(var_glojure_DOT_core_next) tmp15 := lang.Apply(tmp14, []any{v9}) if lang.IsTruthy(tmp15) { - tmp16 := checkDerefVar(glojure_DOT_core_to_array) + tmp16 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) tmp17 := lang.Apply(tmp16, []any{v9}) tmp18 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{tmp17}) tmp13 = tmp18 } else { var tmp19 any - tmp20 := checkDerefVar(glojure_DOT_core_seq) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) tmp21 := lang.Apply(tmp20, []any{v9}) if lang.IsTruthy(tmp21) { - tmp22 := checkDerefVar(glojure_DOT_core_first) + tmp22 := checkDerefVar(var_glojure_DOT_core_first) tmp23 := lang.Apply(tmp22, []any{v9}) tmp19 = tmp23 } else { @@ -43109,49 +43002,47 @@ func LoadNS() { var v24 any = tmp10 _ = v24 // let binding "cause" - tmp25 := checkDerefVar(glojure_DOT_core_get) - tmp26 := lang.Apply(tmp25, []any{v24, lang.NewKeyword("cause")}) + tmp25 := checkDerefVar(var_glojure_DOT_core_get) + tmp26 := lang.Apply(tmp25, []any{v24, kw_cause}) var v27 any = tmp26 _ = v27 // let binding "data" - tmp28 := checkDerefVar(glojure_DOT_core_get) - tmp29 := lang.Apply(tmp28, []any{v24, lang.NewKeyword("data")}) + tmp28 := checkDerefVar(var_glojure_DOT_core_get) + tmp29 := lang.Apply(tmp28, []any{v24, kw_data}) var v30 any = tmp29 _ = v30 // let binding "via" - tmp31 := checkDerefVar(glojure_DOT_core_get) - tmp32 := lang.Apply(tmp31, []any{v24, lang.NewKeyword("via")}) + tmp31 := checkDerefVar(var_glojure_DOT_core_get) + tmp32 := lang.Apply(tmp31, []any{v24, kw_via}) var v33 any = tmp32 _ = v33 // let binding "trace" - tmp34 := checkDerefVar(glojure_DOT_core_get) - tmp35 := lang.Apply(tmp34, []any{v24, lang.NewKeyword("trace")}) + tmp34 := checkDerefVar(var_glojure_DOT_core_get) + tmp35 := lang.Apply(tmp34, []any{v24, kw_trace}) var v36 any = tmp35 _ = v36 // let binding "print-via" var tmp37 lang.FnFunc tmp37 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v38 := args[0] _ = v38 tmp39 := lang.Apply(lang.WriteWriter, []any{v4, "{:type "}) _ = tmp39 - tmp40 := checkDerefVar(glojure_DOT_core_print_method) - tmp41 := lang.Apply(lang.NewKeyword("type"), []any{v38}) + tmp40 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp41 := lang.Apply(kw_type, []any{v38}) tmp42 := lang.Apply(tmp40, []any{tmp41, v4}) _ = tmp42 tmp43 := lang.Apply(lang.WriteWriter, []any{v4, "\n :message "}) _ = tmp43 - tmp44 := checkDerefVar(glojure_DOT_core_print_method) - tmp45 := lang.Apply(lang.NewKeyword("message"), []any{v38}) + tmp44 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp45 := lang.Apply(kw_message, []any{v38}) tmp46 := lang.Apply(tmp44, []any{tmp45, v4}) _ = tmp46 var tmp47 any { // let // let binding "temp__0__auto__" - tmp48 := lang.Apply(lang.NewKeyword("data"), []any{v38}) + tmp48 := lang.Apply(kw_data, []any{v38}) var v49 any = tmp48 _ = v49 var tmp50 any @@ -43163,7 +43054,7 @@ func LoadNS() { _ = v52 tmp53 := lang.Apply(lang.WriteWriter, []any{v4, "\n :data "}) _ = tmp53 - tmp54 := checkDerefVar(glojure_DOT_core_print_method) + tmp54 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) tmp55 := lang.Apply(tmp54, []any{v52, v4}) tmp51 = tmp55 } // end let @@ -43176,7 +43067,7 @@ func LoadNS() { var tmp48 any { // let // let binding "temp__0__auto__" - tmp49 := lang.Apply(lang.NewKeyword("at"), []any{v38}) + tmp49 := lang.Apply(kw_at, []any{v38}) var v50 any = tmp49 _ = v50 var tmp51 any @@ -43188,8 +43079,8 @@ func LoadNS() { _ = v53 tmp54 := lang.Apply(lang.WriteWriter, []any{v4, "\n :at "}) _ = tmp54 - tmp55 := checkDerefVar(glojure_DOT_core_print_method) - tmp56 := lang.Apply(lang.NewKeyword("at"), []any{v38}) + tmp55 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp56 := lang.Apply(kw_at, []any{v38}) tmp57 := lang.Apply(tmp55, []any{tmp56, v4}) tmp52 = tmp57 } // end let @@ -43202,21 +43093,21 @@ func LoadNS() { tmp49 := lang.Apply(lang.WriteWriter, []any{v4, "}"}) return tmp49 }) - tmp38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(481), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(491), lang.NewKeyword("end-column"), int(73)) + tmp38 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(481), kw_column, int(19), kw_end_DASH_line, int(491), kw_end_DASH_column, int(73)) tmp39, err := lang.WithMeta(tmp37, tmp38.(lang.IPersistentMap)) if err != nil { panic(err) } var v40 any = tmp39 _ = v40 - tmp41 := checkDerefVar(glojure_DOT_core_print_method) + tmp41 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) tmp42 := lang.Apply(tmp41, []any{v27, v4}) _ = tmp42 var tmp43 any if lang.IsTruthy(v30) { tmp44 := lang.Apply(lang.WriteWriter, []any{v4, "\n :data "}) _ = tmp44 - tmp45 := checkDerefVar(glojure_DOT_core_print_method) + tmp45 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) tmp46 := lang.Apply(tmp45, []any{v30, v4}) tmp43 = tmp46 } else { @@ -43229,7 +43120,7 @@ func LoadNS() { var tmp49 any { // let // let binding "temp__0__auto__" - tmp50 := checkDerefVar(glojure_DOT_core_first) + tmp50 := checkDerefVar(var_glojure_DOT_core_first) tmp51 := lang.Apply(tmp50, []any{v33}) var v52 any = tmp51 _ = v52 @@ -43245,8 +43136,8 @@ func LoadNS() { var tmp57 any { // let // let binding "seq_254" - tmp58 := checkDerefVar(glojure_DOT_core_seq) - tmp59 := checkDerefVar(glojure_DOT_core_rest) + tmp58 := checkDerefVar(var_glojure_DOT_core_seq) + tmp59 := checkDerefVar(var_glojure_DOT_core_rest) tmp60 := lang.Apply(tmp59, []any{v33}) tmp61 := lang.Apply(tmp58, []any{tmp60}) var v62 any = tmp61 @@ -43262,7 +43153,7 @@ func LoadNS() { _ = v65 for { var tmp66 any - tmp67 := checkDerefVar(glojure_DOT_core__LT_) + tmp67 := checkDerefVar(var_glojure_DOT_core__LT_) tmp68 := lang.Apply(tmp67, []any{v65, v64}) if lang.IsTruthy(tmp68) { var tmp69 any @@ -43282,7 +43173,7 @@ func LoadNS() { var tmp75 any = v62 var tmp76 any = v63 var tmp77 any = v64 - tmp79 := checkDerefVar(glojure_DOT_core_unchecked_inc) + tmp79 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) tmp80 := lang.Apply(tmp79, []any{v65}) var tmp78 any = tmp80 v62 = tmp75 @@ -43296,7 +43187,7 @@ func LoadNS() { var tmp70 any { // let // let binding "temp__0__auto__" - tmp71 := checkDerefVar(glojure_DOT_core_seq) + tmp71 := checkDerefVar(var_glojure_DOT_core_seq) tmp72 := lang.Apply(tmp71, []any{v62}) var v73 any = tmp72 _ = v73 @@ -43308,26 +43199,26 @@ func LoadNS() { var v76 any = v73 _ = v76 var tmp77 any - tmp78 := checkDerefVar(glojure_DOT_core_chunked_seq_QMARK_) + tmp78 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) tmp79 := lang.Apply(tmp78, []any{v76}) if lang.IsTruthy(tmp79) { var tmp80 any { // let // let binding "c__0__auto__" - tmp81 := checkDerefVar(glojure_DOT_core_chunk_first) + tmp81 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) tmp82 := lang.Apply(tmp81, []any{v76}) var v83 any = tmp82 _ = v83 - tmp85 := checkDerefVar(glojure_DOT_core_chunk_rest) + tmp85 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) tmp86 := lang.Apply(tmp85, []any{v76}) var tmp84 any = tmp86 var tmp87 any = v83 - tmp89 := checkDerefVar(glojure_DOT_core_int) - tmp90 := checkDerefVar(glojure_DOT_core_count) + tmp89 := checkDerefVar(var_glojure_DOT_core_int) + tmp90 := checkDerefVar(var_glojure_DOT_core_count) tmp91 := lang.Apply(tmp90, []any{v83}) tmp92 := lang.Apply(tmp89, []any{tmp91}) var tmp88 any = tmp92 - tmp94 := checkDerefVar(glojure_DOT_core_int) + tmp94 := checkDerefVar(var_glojure_DOT_core_int) tmp95 := lang.Apply(tmp94, []any{int64(0)}) var tmp93 any = tmp95 v62 = tmp84 @@ -43341,7 +43232,7 @@ func LoadNS() { var tmp81 any { // let // let binding "v" - tmp82 := checkDerefVar(glojure_DOT_core_first) + tmp82 := checkDerefVar(var_glojure_DOT_core_first) tmp83 := lang.Apply(tmp82, []any{v76}) var v84 any = tmp83 _ = v84 @@ -43349,7 +43240,7 @@ func LoadNS() { _ = tmp85 tmp86 := lang.Apply(v40, []any{v84}) _ = tmp86 - tmp88 := checkDerefVar(glojure_DOT_core_next) + tmp88 := checkDerefVar(var_glojure_DOT_core_next) tmp89 := lang.Apply(tmp88, []any{v76}) var tmp87 any = tmp89 var tmp90 any = nil @@ -43396,7 +43287,7 @@ func LoadNS() { var tmp53 any { // let // let binding "temp__0__auto__" - tmp54 := checkDerefVar(glojure_DOT_core_first) + tmp54 := checkDerefVar(var_glojure_DOT_core_first) tmp55 := lang.Apply(tmp54, []any{v36}) var v56 any = tmp55 _ = v56 @@ -43407,14 +43298,14 @@ func LoadNS() { // let binding "ft" var v59 any = v56 _ = v59 - tmp60 := checkDerefVar(glojure_DOT_core_print_method) + tmp60 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) tmp61 := lang.Apply(tmp60, []any{v59, v4}) _ = tmp61 var tmp62 any { // let // let binding "seq_258" - tmp63 := checkDerefVar(glojure_DOT_core_seq) - tmp64 := checkDerefVar(glojure_DOT_core_rest) + tmp63 := checkDerefVar(var_glojure_DOT_core_seq) + tmp64 := checkDerefVar(var_glojure_DOT_core_rest) tmp65 := lang.Apply(tmp64, []any{v36}) tmp66 := lang.Apply(tmp63, []any{tmp65}) var v67 any = tmp66 @@ -43430,7 +43321,7 @@ func LoadNS() { _ = v70 for { var tmp71 any - tmp72 := checkDerefVar(glojure_DOT_core__LT_) + tmp72 := checkDerefVar(var_glojure_DOT_core__LT_) tmp73 := lang.Apply(tmp72, []any{v70, v69}) if lang.IsTruthy(tmp73) { var tmp74 any @@ -43445,13 +43336,13 @@ func LoadNS() { _ = v77 tmp78 := lang.Apply(lang.WriteWriter, []any{v4, "\n "}) _ = tmp78 - tmp79 := checkDerefVar(glojure_DOT_core_print_method) + tmp79 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) tmp80 := lang.Apply(tmp79, []any{v77, v4}) _ = tmp80 var tmp81 any = v67 var tmp82 any = v68 var tmp83 any = v69 - tmp85 := checkDerefVar(glojure_DOT_core_unchecked_inc) + tmp85 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) tmp86 := lang.Apply(tmp85, []any{v70}) var tmp84 any = tmp86 v67 = tmp81 @@ -43465,7 +43356,7 @@ func LoadNS() { var tmp75 any { // let // let binding "temp__0__auto__" - tmp76 := checkDerefVar(glojure_DOT_core_seq) + tmp76 := checkDerefVar(var_glojure_DOT_core_seq) tmp77 := lang.Apply(tmp76, []any{v67}) var v78 any = tmp77 _ = v78 @@ -43477,26 +43368,26 @@ func LoadNS() { var v81 any = v78 _ = v81 var tmp82 any - tmp83 := checkDerefVar(glojure_DOT_core_chunked_seq_QMARK_) + tmp83 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) tmp84 := lang.Apply(tmp83, []any{v81}) if lang.IsTruthy(tmp84) { var tmp85 any { // let // let binding "c__0__auto__" - tmp86 := checkDerefVar(glojure_DOT_core_chunk_first) + tmp86 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) tmp87 := lang.Apply(tmp86, []any{v81}) var v88 any = tmp87 _ = v88 - tmp90 := checkDerefVar(glojure_DOT_core_chunk_rest) + tmp90 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) tmp91 := lang.Apply(tmp90, []any{v81}) var tmp89 any = tmp91 var tmp92 any = v88 - tmp94 := checkDerefVar(glojure_DOT_core_int) - tmp95 := checkDerefVar(glojure_DOT_core_count) + tmp94 := checkDerefVar(var_glojure_DOT_core_int) + tmp95 := checkDerefVar(var_glojure_DOT_core_count) tmp96 := lang.Apply(tmp95, []any{v88}) tmp97 := lang.Apply(tmp94, []any{tmp96}) var tmp93 any = tmp97 - tmp99 := checkDerefVar(glojure_DOT_core_int) + tmp99 := checkDerefVar(var_glojure_DOT_core_int) tmp100 := lang.Apply(tmp99, []any{int64(0)}) var tmp98 any = tmp100 v67 = tmp89 @@ -43510,16 +43401,16 @@ func LoadNS() { var tmp86 any { // let // let binding "t" - tmp87 := checkDerefVar(glojure_DOT_core_first) + tmp87 := checkDerefVar(var_glojure_DOT_core_first) tmp88 := lang.Apply(tmp87, []any{v81}) var v89 any = tmp88 _ = v89 tmp90 := lang.Apply(lang.WriteWriter, []any{v4, "\n "}) _ = tmp90 - tmp91 := checkDerefVar(glojure_DOT_core_print_method) + tmp91 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) tmp92 := lang.Apply(tmp91, []any{v89, v4}) _ = tmp92 - tmp94 := checkDerefVar(glojure_DOT_core_next) + tmp94 := checkDerefVar(var_glojure_DOT_core_next) tmp95 := lang.Apply(tmp94, []any{v81}) var tmp93 any = tmp95 var tmp96 any = nil @@ -43564,7 +43455,7 @@ func LoadNS() { tmp7 := lang.Apply(lang.WriteWriter, []any{v4, "}"}) return tmp7 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -43572,27 +43463,25 @@ func LoadNS() { } // printf { - tmp0 := lang.NewSymbol("printf").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("fmt"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Prints formatted output, as per format", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5725), lang.NewKeyword("end-line"), int(5725))).(*lang.Symbol) + tmp0 := sym_printf.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_fmt, sym__AMP_, sym_args)), kw_doc, "Prints formatted output, as per format", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(5725), kw_end_DASH_line, int(5725))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var v4 any = lang.NewList(args[1:]...) _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_print) - tmp6 := checkDerefVar(glojure_DOT_core_apply) - tmp7 := checkDerefVar(glojure_DOT_core_format) + tmp5 := checkDerefVar(var_glojure_DOT_core_print) + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_format) tmp8 := lang.Apply(tmp6, []any{tmp7, v3, v4}) tmp9 := lang.Apply(tmp5, []any{tmp8}) return tmp9 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -43600,33 +43489,31 @@ func LoadNS() { } // println { - tmp0 := lang.NewSymbol("println").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Same as print followed by (newline)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3734), lang.NewKeyword("end-line"), int(3734))).(*lang.Symbol) + tmp0 := sym_println.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_more)), kw_doc, "Same as print followed by (newline)", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(3734), kw_end_DASH_line, int(3734))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 var tmp4 any { // let - tmp5 := checkDerefVar(glojure_DOT_core_push_thread_bindings) - tmp6 := checkDerefVar(glojure_DOT_core_hash_map) - tmp7 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*print-readably*")) + tmp5 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp6 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp7 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_print_DASH_readably_STAR_) tmp8 := lang.Apply(tmp6, []any{tmp7, nil}) tmp9 := lang.Apply(tmp5, []any{tmp8}) _ = tmp9 var tmp10 any func() { defer func() { - tmp11 := checkDerefVar(glojure_DOT_core_pop_thread_bindings) + tmp11 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) tmp12 := lang.Apply(tmp11, nil) _ = tmp12 }() - tmp13 := checkDerefVar(glojure_DOT_core_apply) - tmp14 := checkDerefVar(glojure_DOT_core_prn) + tmp13 := checkDerefVar(var_glojure_DOT_core_apply) + tmp14 := checkDerefVar(var_glojure_DOT_core_prn) tmp15 := lang.Apply(tmp13, []any{tmp14, v3}) tmp10 = tmp15 }() @@ -43635,7 +43522,7 @@ func LoadNS() { return tmp4 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -43644,14 +43531,12 @@ func LoadNS() { // println-str { tmp1 := reflect.TypeOf("") - tmp0 := lang.NewSymbol("println-str").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("xs"))), lang.NewKeyword("doc"), "println to a string, returning it", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4785), lang.NewKeyword("end-line"), int(4785))).(*lang.Symbol) + tmp0 := sym_println_DASH_str.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_xs)), kw_doc, "println to a string, returning it", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(4785), kw_end_DASH_line, int(4785))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var v4 any = lang.NewList(args[0:]...) _ = v4 var tmp5 any @@ -43661,24 +43546,24 @@ func LoadNS() { _ = v6 var tmp7 any { // let - tmp8 := checkDerefVar(glojure_DOT_core_push_thread_bindings) - tmp9 := checkDerefVar(glojure_DOT_core_hash_map) - tmp10 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*out*")) + tmp8 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp9 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp10 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) tmp11 := lang.Apply(tmp9, []any{tmp10, v6}) tmp12 := lang.Apply(tmp8, []any{tmp11}) _ = tmp12 var tmp13 any func() { defer func() { - tmp14 := checkDerefVar(glojure_DOT_core_pop_thread_bindings) + tmp14 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) tmp15 := lang.Apply(tmp14, nil) _ = tmp15 }() - tmp16 := checkDerefVar(glojure_DOT_core_apply) - tmp17 := checkDerefVar(glojure_DOT_core_println) + tmp16 := checkDerefVar(var_glojure_DOT_core_apply) + tmp17 := checkDerefVar(var_glojure_DOT_core_println) tmp18 := lang.Apply(tmp16, []any{tmp17, v4}) _ = tmp18 - tmp19 := checkDerefVar(glojure_DOT_core_str) + tmp19 := checkDerefVar(var_glojure_DOT_core_str) tmp20 := lang.Apply(tmp19, []any{v6}) tmp13 = tmp20 }() @@ -43690,7 +43575,7 @@ func LoadNS() { } }) tmp4 := reflect.TypeOf("") - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -43698,27 +43583,25 @@ func LoadNS() { } // prn { - tmp0 := lang.NewSymbol("prn").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "Same as pr followed by (newline). Observes *flush-on-newline*", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3715), lang.NewKeyword("end-line"), int(3715))).(*lang.Symbol) + tmp0 := sym_prn.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_more)), kw_doc, "Same as pr followed by (newline). Observes *flush-on-newline*", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(3715), kw_end_DASH_line, int(3715))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_apply) - tmp5 := checkDerefVar(glojure_DOT_core_pr) + tmp4 := checkDerefVar(var_glojure_DOT_core_apply) + tmp5 := checkDerefVar(var_glojure_DOT_core_pr) tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) _ = tmp6 - tmp7 := checkDerefVar(glojure_DOT_core_newline) + tmp7 := checkDerefVar(var_glojure_DOT_core_newline) tmp8 := lang.Apply(tmp7, nil) _ = tmp8 var tmp9 any - tmp10 := checkDerefVar(glojure_DOT_core__STAR_flush_on_newline_STAR_) + tmp10 := checkDerefVar(var_glojure_DOT_core__STAR_flush_DASH_on_DASH_newline_STAR_) if lang.IsTruthy(tmp10) { - tmp11 := checkDerefVar(glojure_DOT_core_flush) + tmp11 := checkDerefVar(var_glojure_DOT_core_flush) tmp12 := lang.Apply(tmp11, nil) tmp9 = tmp12 } else { @@ -43726,7 +43609,7 @@ func LoadNS() { return tmp9 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -43735,14 +43618,12 @@ func LoadNS() { // prn-str { tmp1 := reflect.TypeOf("") - tmp0 := lang.NewSymbol("prn-str").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("xs"))), lang.NewKeyword("doc"), "prn to a string, returning it", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4767), lang.NewKeyword("end-line"), int(4767))).(*lang.Symbol) + tmp0 := sym_prn_DASH_str.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_xs)), kw_doc, "prn to a string, returning it", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4767), kw_end_DASH_line, int(4767))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var v4 any = lang.NewList(args[0:]...) _ = v4 var tmp5 any @@ -43752,24 +43633,24 @@ func LoadNS() { _ = v6 var tmp7 any { // let - tmp8 := checkDerefVar(glojure_DOT_core_push_thread_bindings) - tmp9 := checkDerefVar(glojure_DOT_core_hash_map) - tmp10 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*out*")) + tmp8 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp9 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp10 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) tmp11 := lang.Apply(tmp9, []any{tmp10, v6}) tmp12 := lang.Apply(tmp8, []any{tmp11}) _ = tmp12 var tmp13 any func() { defer func() { - tmp14 := checkDerefVar(glojure_DOT_core_pop_thread_bindings) + tmp14 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) tmp15 := lang.Apply(tmp14, nil) _ = tmp15 }() - tmp16 := checkDerefVar(glojure_DOT_core_apply) - tmp17 := checkDerefVar(glojure_DOT_core_prn) + tmp16 := checkDerefVar(var_glojure_DOT_core_apply) + tmp17 := checkDerefVar(var_glojure_DOT_core_prn) tmp18 := lang.Apply(tmp16, []any{tmp17, v4}) _ = tmp18 - tmp19 := checkDerefVar(glojure_DOT_core_str) + tmp19 := checkDerefVar(var_glojure_DOT_core_str) tmp20 := lang.Apply(tmp19, []any{v6}) tmp13 = tmp20 }() @@ -43781,7 +43662,7 @@ func LoadNS() { } }) tmp4 := reflect.TypeOf("") - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -43789,12 +43670,10 @@ func LoadNS() { } // promise { - tmp0 := lang.NewSymbol("promise").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Returns a promise object that can be read with deref/@, and set,\n once only, with deliver. Calls to deref/@ prior to delivery will\n block, unless the variant of deref with timeout is used. All\n subsequent derefs will return the same delivered value without\n blocking. See also - realized?.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7078), lang.NewKeyword("end-line"), int(7078))).(*lang.Symbol) + tmp0 := sym_promise.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Returns a promise object that can be read with deref/@, and set,\n once only, with deliver. Calls to deref/@ prior to delivery will\n block, unless the variant of deref with timeout is used. All\n subsequent derefs will return the same delivered value without\n blocking. See also - realized?.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(7078), kw_end_DASH_line, int(7078))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var tmp3 any { // let // let binding "d" @@ -43802,14 +43681,14 @@ func LoadNS() { var v5 any = tmp4 _ = v5 // let binding "v" - tmp6 := checkDerefVar(glojure_DOT_core_atom) + tmp6 := checkDerefVar(var_glojure_DOT_core_atom) tmp7 := lang.Apply(tmp6, []any{v5}) var v8 any = tmp7 _ = v8 tmp9 := reflect.TypeOf((*lang.IDeref)(nil)).Elem() - tmp10 := checkDerefVar(glojure_DOT_core_deref) + tmp10 := checkDerefVar(var_glojure_DOT_core_deref) tmp11 := lang.NewVector(nil) - tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7091), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(7091), lang.NewKeyword("end-column"), int(17)) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7091), kw_column, int(15), kw_end_DASH_line, int(7091), kw_end_DASH_column, int(17)) tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) if err != nil { panic(err) @@ -43825,13 +43704,13 @@ func LoadNS() { default: tmp15 = tmp14 } - tmp16 := checkDerefVar(glojure_DOT_core_deref) + tmp16 := checkDerefVar(var_glojure_DOT_core_deref) tmp17 := lang.Apply(tmp16, []any{v8}) tmp18 := lang.Apply(tmp10, []any{tmp13, tmp15, tmp17}) tmp19 := reflect.TypeOf((*lang.IBlockingDeref)(nil)).Elem() - tmp20 := checkDerefVar(glojure_DOT_core_deref) + tmp20 := checkDerefVar(var_glojure_DOT_core_deref) tmp21 := lang.NewVector(nil, nil, nil) - tmp22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7094), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(7094), lang.NewKeyword("end-column"), int(34)) + tmp22 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7094), kw_column, int(9), kw_end_DASH_line, int(7094), kw_end_DASH_column, int(34)) tmp23, err := lang.WithMeta(tmp21, tmp22.(lang.IPersistentMap)) if err != nil { panic(err) @@ -43843,7 +43722,7 @@ func LoadNS() { } tmp26 := lang.Apply(tmp25, []any{nil, time10.Millisecond}) if lang.IsTruthy(tmp26) { - tmp27 := checkDerefVar(glojure_DOT_core_deref) + tmp27 := checkDerefVar(var_glojure_DOT_core_deref) tmp28 := lang.Apply(tmp27, []any{v8}) tmp24 = tmp28 } else { @@ -43851,12 +43730,12 @@ func LoadNS() { tmp29 := lang.Apply(tmp20, []any{tmp23, tmp24}) tmp30 := reflect.TypeOf((*lang.IPending)(nil)).Elem() tmp31 := lang.NewVector(nil) - tmp32 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7099), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(7099), lang.NewKeyword("end-column"), int(24)) + tmp32 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7099), kw_column, int(19), kw_end_DASH_line, int(7099), kw_end_DASH_column, int(24)) tmp33, err := lang.WithMeta(tmp31, tmp32.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp34 := checkDerefVar(glojure_DOT_core_zero_QMARK_) + tmp34 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) tmp35, ok := lang.FieldOrMethod(v5, "getCount") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "getCount"))) @@ -43871,7 +43750,7 @@ func LoadNS() { tmp37 := lang.Apply(tmp34, []any{tmp36}) tmp38 := lang.Apply(nil, []any{tmp33, tmp37}) tmp39 := lang.NewVector(nil, nil) - tmp40 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7103), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(7103), lang.NewKeyword("end-column"), int(14)) + tmp40 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7103), kw_column, int(7), kw_end_DASH_line, int(7103), kw_end_DASH_column, int(14)) tmp41, err := lang.WithMeta(tmp39, tmp40.(lang.IPersistentMap)) if err != nil { panic(err) @@ -43880,7 +43759,7 @@ func LoadNS() { var tmp43 any { // let // let binding "and__0__auto__" - tmp44 := checkDerefVar(glojure_DOT_core_pos_QMARK_) + tmp44 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) tmp45, ok := lang.FieldOrMethod(v5, "getCount") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "getCount"))) @@ -43897,7 +43776,7 @@ func LoadNS() { _ = v48 var tmp49 any if lang.IsTruthy(v48) { - tmp50 := checkDerefVar(glojure_DOT_core_compare_and_set_BANG_) + tmp50 := checkDerefVar(var_glojure_DOT_core_compare_DASH_and_DASH_set_BANG_) tmp51 := lang.Apply(tmp50, []any{v8, v5, nil}) tmp49 = tmp51 } else { @@ -43926,7 +43805,7 @@ func LoadNS() { } // end let return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -43934,23 +43813,21 @@ func LoadNS() { } // protocol? { - tmp0 := lang.NewSymbol("protocol?").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_deftype.glj", lang.NewKeyword("line"), int(110), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(110), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("maybe-p"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym_protocol_QMARK_.WithMeta(lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(110), kw_column, int(8), kw_end_DASH_line, int(110), kw_end_DASH_column, int(16), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_maybe_DASH_p)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any - tmp5 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp6 := reflect.TypeOf((*lang.IAtom)(nil)).Elem() tmp7 := lang.Apply(tmp5, []any{tmp6, v3}) if lang.IsTruthy(tmp7) { - tmp8 := checkDerefVar(glojure_DOT_core_boolean) - tmp9 := checkDerefVar(glojure_DOT_core_deref) + tmp8 := checkDerefVar(var_glojure_DOT_core_boolean) + tmp9 := checkDerefVar(var_glojure_DOT_core_deref) tmp10 := lang.Apply(tmp9, []any{v3}) - tmp11 := lang.Apply(lang.NewKeyword("on-interface"), []any{tmp10}) + tmp11 := lang.Apply(kw_on_DASH_interface, []any{tmp10}) tmp12 := lang.Apply(tmp8, []any{tmp11}) tmp4 = tmp12 } else { @@ -43958,7 +43835,7 @@ func LoadNS() { } return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -43966,18 +43843,16 @@ func LoadNS() { } // push-thread-bindings { - tmp0 := lang.NewSymbol("push-thread-bindings").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"))), lang.NewKeyword("doc"), "WARNING: This is a low-level function. Prefer high-level macros like\n binding where ever possible.\n\n Takes a map of Var/value pairs. Binds each Var to the associated value for\n the current thread. Each call *MUST* be accompanied by a matching call to\n pop-thread-bindings wrapped in a try-finally!\n \n (push-thread-bindings bindings)\n (try\n ...\n (finally\n (pop-thread-bindings)))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(26), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1911), lang.NewKeyword("end-line"), int(1911))).(*lang.Symbol) + tmp0 := sym_push_DASH_thread_DASH_bindings.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_bindings)), kw_doc, "WARNING: This is a low-level function. Prefer high-level macros like\n binding where ever possible.\n\n Takes a map of Var/value pairs. Binds each Var to the associated value for\n the current thread. Each call *MUST* be accompanied by a matching call to\n pop-thread-bindings wrapped in a try-finally!\n \n (push-thread-bindings bindings)\n (try\n ...\n (finally\n (pop-thread-bindings)))", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(26), kw_column, int(7), kw_line, int(1911), kw_end_DASH_line, int(1911))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4 := lang.Apply(lang.PushThreadBindings, []any{v3}) return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -43985,43 +43860,39 @@ func LoadNS() { } // pvalues { - tmp0 := lang.NewSymbol("pvalues").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("exprs"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the values of the exprs, which are\n evaluated in parallel", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7063), lang.NewKeyword("end-line"), int(7063))).(*lang.Symbol) + tmp0 := sym_pvalues.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_exprs)), kw_doc, "Returns a lazy sequence of the values of the exprs, which are\n evaluated in parallel", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(7063), kw_end_DASH_line, int(7063))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 var v5 any = lang.NewList(args[2:]...) _ = v5 - tmp6 := checkDerefVar(glojure_DOT_core_seq) - tmp7 := checkDerefVar(glojure_DOT_core_concat) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("glojure.core/pcalls")}) - tmp10 := checkDerefVar(glojure_DOT_core_map) + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_pcalls}) + tmp10 := checkDerefVar(var_glojure_DOT_core_map) var tmp11 lang.FnFunc tmp11 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v12 := args[0] _ = v12 - tmp13 := checkDerefVar(glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) tmp14 := lang.NewVector() - tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7069), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(7069), lang.NewKeyword("end-column"), int(31)) + tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7069), kw_column, int(30), kw_end_DASH_line, int(7069), kw_end_DASH_column, int(31)) tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp17 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/fn"), tmp16, v12}) + tmp17 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_fn, tmp16, v12}) return tmp17 }) - tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7069), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(7069), lang.NewKeyword("end-column"), int(34)) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7069), kw_column, int(19), kw_end_DASH_line, int(7069), kw_end_DASH_column, int(34)) tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) if err != nil { panic(err) @@ -44032,7 +43903,7 @@ func LoadNS() { return tmp16 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -44040,19 +43911,17 @@ func LoadNS() { } // qualified-ident? { - tmp0 := lang.NewSymbol("qualified-ident?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a symbol or keyword with a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1618), lang.NewKeyword("end-line"), int(1618))).(*lang.Symbol) + tmp0 := sym_qualified_DASH_ident_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a symbol or keyword with a namespace", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(22), kw_column, int(7), kw_line, int(1618), kw_end_DASH_line, int(1618))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_boolean) + tmp4 := checkDerefVar(var_glojure_DOT_core_boolean) var tmp5 any { // let // let binding "and__0__auto__" - tmp6 := checkDerefVar(glojure_DOT_core_ident_QMARK_) + tmp6 := checkDerefVar(var_glojure_DOT_core_ident_QMARK_) tmp7 := lang.Apply(tmp6, []any{v3}) var v8 any = tmp7 _ = v8 @@ -44061,7 +43930,7 @@ func LoadNS() { var tmp10 any { // let // let binding "and__0__auto__" - tmp11 := checkDerefVar(glojure_DOT_core_namespace) + tmp11 := checkDerefVar(var_glojure_DOT_core_namespace) tmp12 := lang.Apply(tmp11, []any{v3}) var v13 any = tmp12 _ = v13 @@ -44082,7 +43951,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp4, []any{tmp5}) return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -44090,19 +43959,17 @@ func LoadNS() { } // qualified-keyword? { - tmp0 := lang.NewSymbol("qualified-keyword?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a keyword with a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1638), lang.NewKeyword("end-line"), int(1638))).(*lang.Symbol) + tmp0 := sym_qualified_DASH_keyword_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a keyword with a namespace", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(24), kw_column, int(7), kw_line, int(1638), kw_end_DASH_line, int(1638))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_boolean) + tmp4 := checkDerefVar(var_glojure_DOT_core_boolean) var tmp5 any { // let // let binding "and__0__auto__" - tmp6 := checkDerefVar(glojure_DOT_core_keyword_QMARK_) + tmp6 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) tmp7 := lang.Apply(tmp6, []any{v3}) var v8 any = tmp7 _ = v8 @@ -44111,7 +43978,7 @@ func LoadNS() { var tmp10 any { // let // let binding "and__0__auto__" - tmp11 := checkDerefVar(glojure_DOT_core_namespace) + tmp11 := checkDerefVar(var_glojure_DOT_core_namespace) tmp12 := lang.Apply(tmp11, []any{v3}) var v13 any = tmp12 _ = v13 @@ -44132,7 +43999,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp4, []any{tmp5}) return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -44140,19 +44007,17 @@ func LoadNS() { } // qualified-symbol? { - tmp0 := lang.NewSymbol("qualified-symbol?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a symbol with a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1628), lang.NewKeyword("end-line"), int(1628))).(*lang.Symbol) + tmp0 := sym_qualified_DASH_symbol_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a symbol with a namespace", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(7), kw_line, int(1628), kw_end_DASH_line, int(1628))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_boolean) + tmp4 := checkDerefVar(var_glojure_DOT_core_boolean) var tmp5 any { // let // let binding "and__0__auto__" - tmp6 := checkDerefVar(glojure_DOT_core_symbol_QMARK_) + tmp6 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) tmp7 := lang.Apply(tmp6, []any{v3}) var v8 any = tmp7 _ = v8 @@ -44161,7 +44026,7 @@ func LoadNS() { var tmp10 any { // let // let binding "and__0__auto__" - tmp11 := checkDerefVar(glojure_DOT_core_namespace) + tmp11 := checkDerefVar(var_glojure_DOT_core_namespace) tmp12 := lang.Apply(tmp11, []any{v3}) var v13 any = tmp12 _ = v13 @@ -44182,7 +44047,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp4, []any{tmp5}) return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -44194,27 +44059,25 @@ func LoadNS() { { // function quot__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_seq) - tmp6 := checkDerefVar(glojure_DOT_core_concat) - tmp7 := checkDerefVar(glojure_DOT_core_list) - tmp8 := lang.Apply(tmp7, []any{lang.NewSymbol(".")}) - tmp9 := checkDerefVar(glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp11 := checkDerefVar(glojure_DOT_core_list) - tmp12 := checkDerefVar(glojure_DOT_core_seq) - tmp13 := checkDerefVar(glojure_DOT_core_concat) - tmp14 := checkDerefVar(glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("glojure.core/Quotient")}) - tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Quotient}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) - tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) tmp19 := lang.Apply(tmp18, []any{v4}) tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) tmp21 := lang.Apply(tmp12, []any{tmp20}) @@ -44226,12 +44089,10 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("quot").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"), lang.NewSymbol("div"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "quot[ient] of dividing numerator by denominator.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1266), lang.NewKeyword("end-line"), int(1266))).(*lang.Symbol) + tmp0 := sym_quot.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_num, sym_div)), kw_inline, tmp1, kw_doc, "quot[ient] of dividing numerator by denominator.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1266), kw_end_DASH_line, int(1266))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -44243,7 +44104,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -44251,7 +44112,7 @@ func LoadNS() { } // rand { - tmp0 := lang.NewSymbol("rand").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns a random floating point number between 0 (inclusive) and\n n (default 1) (exclusive).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4935), lang.NewKeyword("end-line"), int(4935))).(*lang.Symbol) + tmp0 := sym_rand.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_n)), kw_doc, "Returns a random floating point number between 0 (inclusive) and\n n (default 1) (exclusive).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(4935), kw_end_DASH_line, int(4935))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -44261,16 +44122,17 @@ func LoadNS() { case 1: v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core__STAR_) - tmp5 := checkDerefVar(glojure_DOT_core_rand) + tmp4 := checkDerefVar(var_glojure_DOT_core__STAR_) + tmp5 := checkDerefVar(var_glojure_DOT_core_rand) tmp6 := lang.Apply(tmp5, nil) tmp7 := lang.Apply(tmp4, []any{v3, tmp6}) return tmp7 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -44278,21 +44140,19 @@ func LoadNS() { } // rand-int { - tmp0 := lang.NewSymbol("rand-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns a random integer between 0 (inclusive) and n (exclusive).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4943), lang.NewKeyword("end-line"), int(4943))).(*lang.Symbol) + tmp0 := sym_rand_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_doc, "Returns a random integer between 0 (inclusive) and n (exclusive).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(4943), kw_end_DASH_line, int(4943))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_int) - tmp5 := checkDerefVar(glojure_DOT_core_rand) + tmp4 := checkDerefVar(var_glojure_DOT_core_int) + tmp5 := checkDerefVar(var_glojure_DOT_core_rand) tmp6 := lang.Apply(tmp5, []any{v3}) tmp7 := lang.Apply(tmp4, []any{tmp6}) return tmp7 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -44300,23 +44160,21 @@ func LoadNS() { } // rand-nth { - tmp0 := lang.NewSymbol("rand-nth").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return a random element of the (sequential) collection. Will have\n the same performance characteristics as nth for the given\n collection.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7213), lang.NewKeyword("end-line"), int(7213))).(*lang.Symbol) + tmp0 := sym_rand_DASH_nth.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Return a random element of the (sequential) collection. Will have\n the same performance characteristics as nth for the given\n collection.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(7213), kw_end_DASH_line, int(7213))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_nth) - tmp5 := checkDerefVar(glojure_DOT_core_rand_int) - tmp6 := checkDerefVar(glojure_DOT_core_count) + tmp4 := checkDerefVar(var_glojure_DOT_core_nth) + tmp5 := checkDerefVar(var_glojure_DOT_core_rand_DASH_int) + tmp6 := checkDerefVar(var_glojure_DOT_core_count) tmp7 := lang.Apply(tmp6, []any{v3}) tmp8 := lang.Apply(tmp5, []any{tmp7}) tmp9 := lang.Apply(tmp4, []any{v3, tmp8}) return tmp9 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -44324,28 +44182,26 @@ func LoadNS() { } // random-sample { - tmp0 := lang.NewSymbol("random-sample").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("prob")), lang.NewVector(lang.NewSymbol("prob"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns items from coll with random probability of prob (0.0 -\n 1.0). Returns a transducer when no collection is provided.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7699), lang.NewKeyword("end-line"), int(7699))).(*lang.Symbol) + tmp0 := sym_random_DASH_sample.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_prob), lang.NewVector(sym_prob, sym_coll)), kw_doc, "Returns items from coll with random probability of prob (0.0 -\n 1.0). Returns a transducer when no collection is provided.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(7699), kw_end_DASH_line, int(7699))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_filter) + tmp4 := checkDerefVar(var_glojure_DOT_core_filter) var tmp5 lang.FnFunc tmp5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v6 := args[0] _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core__LT_) - tmp8 := checkDerefVar(glojure_DOT_core_rand) + tmp7 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp8 := checkDerefVar(var_glojure_DOT_core_rand) tmp9 := lang.Apply(tmp8, nil) tmp10 := lang.Apply(tmp7, []any{tmp9, v3}) return tmp10 }) - tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7704), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(7704), lang.NewKeyword("end-column"), int(37)) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7704), kw_column, int(14), kw_end_DASH_line, int(7704), kw_end_DASH_column, int(37)) tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) if err != nil { panic(err) @@ -44357,21 +44213,19 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_filter) + tmp5 := checkDerefVar(var_glojure_DOT_core_filter) var tmp6 lang.FnFunc tmp6 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v7 := args[0] _ = v7 - tmp8 := checkDerefVar(glojure_DOT_core__LT_) - tmp9 := checkDerefVar(glojure_DOT_core_rand) + tmp8 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp9 := checkDerefVar(var_glojure_DOT_core_rand) tmp10 := lang.Apply(tmp9, nil) tmp11 := lang.Apply(tmp8, []any{tmp10, v3}) return tmp11 }) - tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7706), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(7706), lang.NewKeyword("end-column"), int(37)) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7706), kw_column, int(14), kw_end_DASH_line, int(7706), kw_end_DASH_column, int(37)) tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) if err != nil { panic(err) @@ -44379,10 +44233,11 @@ func LoadNS() { tmp9 := lang.Apply(tmp5, []any{tmp8, v4}) return tmp9 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -44390,16 +44245,14 @@ func LoadNS() { } // random-uuid { - tmp0 := lang.NewSymbol("random-uuid").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Returns a pseudo-randomly generated java.util.UUID instance (i.e. type 4).\n\n See: https://docs.oracle.com/javase/8/docs/api/java/util/UUID.html#randomUUID--", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6852), lang.NewKeyword("end-line"), int(6852))).(*lang.Symbol) + tmp0 := sym_random_DASH_uuid.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Returns a pseudo-randomly generated java.util.UUID instance (i.e. type 4).\n\n See: https://docs.oracle.com/javase/8/docs/api/java/util/UUID.html#randomUUID--", kw_file, "glojure/core.glj", kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(6852), kw_end_DASH_line, int(6852))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) tmp3 := lang.Apply(uuid13.NewV7, nil) return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -44407,20 +44260,20 @@ func LoadNS() { } // range { - tmp0 := lang.NewSymbol("range").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("end")), lang.NewVector(lang.NewSymbol("start"), lang.NewSymbol("end")), lang.NewVector(lang.NewSymbol("start"), lang.NewSymbol("end"), lang.NewSymbol("step"))), lang.NewKeyword("doc"), "Returns a lazy seq of nums from start (inclusive) to end\n (exclusive), by step, where start defaults to 0, step to 1, and end to\n infinity. When step is equal to 0, returns an infinite sequence of\n start. When start is equal to end, returns empty list.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3018), lang.NewKeyword("end-line"), int(3018))).(*lang.Symbol) + tmp0 := sym_range.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_end), lang.NewVector(sym_start, sym_end), lang.NewVector(sym_start, sym_end, sym_step)), kw_doc, "Returns a lazy seq of nums from start (inclusive) to end\n (exclusive), by step, where start defaults to 0, step to 1, and end to\n infinity. When step is equal to 0, returns an infinite sequence of\n start. When start is equal to end, returns empty list.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3018), kw_end_DASH_line, int(3018))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - tmp3 := checkDerefVar(glojure_DOT_core_iterate) - tmp4 := checkDerefVar(glojure_DOT_core_inc_U0027_) + tmp3 := checkDerefVar(var_glojure_DOT_core_iterate) + tmp4 := checkDerefVar(var_glojure_DOT_core_inc_TICK_) tmp5 := lang.Apply(tmp3, []any{tmp4, int64(0)}) return tmp5 case 1: v3 := args[0] _ = v3 var tmp4 any - tmp5 := checkDerefVar(glojure_DOT_core_int_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) tmp6 := lang.Apply(tmp5, []any{v3}) if lang.IsTruthy(tmp6) { tmp7 := lang.Apply(lang.NewLongRange, []any{int64(0), v3, int64(1)}) @@ -44439,13 +44292,13 @@ func LoadNS() { var tmp6 any { // let // let binding "and__0__auto__" - tmp7 := checkDerefVar(glojure_DOT_core_int_QMARK_) + tmp7 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) tmp8 := lang.Apply(tmp7, []any{v3}) var v9 any = tmp8 _ = v9 var tmp10 any if lang.IsTruthy(v9) { - tmp11 := checkDerefVar(glojure_DOT_core_int_QMARK_) + tmp11 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) tmp12 := lang.Apply(tmp11, []any{v4}) tmp10 = tmp12 } else { @@ -44472,7 +44325,7 @@ func LoadNS() { var tmp7 any { // let // let binding "and__0__auto__" - tmp8 := checkDerefVar(glojure_DOT_core_int_QMARK_) + tmp8 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) tmp9 := lang.Apply(tmp8, []any{v3}) var v10 any = tmp9 _ = v10 @@ -44481,13 +44334,13 @@ func LoadNS() { var tmp12 any { // let // let binding "and__0__auto__" - tmp13 := checkDerefVar(glojure_DOT_core_int_QMARK_) + tmp13 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) tmp14 := lang.Apply(tmp13, []any{v4}) var v15 any = tmp14 _ = v15 var tmp16 any if lang.IsTruthy(v15) { - tmp17 := checkDerefVar(glojure_DOT_core_int_QMARK_) + tmp17 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) tmp18 := lang.Apply(tmp17, []any{v5}) tmp16 = tmp18 } else { @@ -44510,10 +44363,11 @@ func LoadNS() { } return tmp6 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -44521,20 +44375,18 @@ func LoadNS() { } // ratio? { - tmp0 := lang.NewSymbol("ratio?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is a Ratio", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3577), lang.NewKeyword("end-line"), int(3577))).(*lang.Symbol) + tmp0 := sym_ratio_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_doc, "Returns true if n is a Ratio", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(3577), kw_end_DASH_line, int(3577))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp5 := reflect.TypeOf((*lang.Ratio)(nil)) tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -44542,18 +44394,16 @@ func LoadNS() { } // rational? { - tmp0 := lang.NewSymbol("rational?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Returns true if n is a rational number", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3613), lang.NewKeyword("end-line"), int(3613))).(*lang.Symbol) + tmp0 := sym_rational_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_doc, "Returns true if n is a rational number", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(3613), kw_end_DASH_line, int(3613))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any { // let // let binding "or__0__auto__" - tmp5 := checkDerefVar(glojure_DOT_core_integer_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_integer_QMARK_) tmp6 := lang.Apply(tmp5, []any{v3}) var v7 any = tmp6 _ = v7 @@ -44564,7 +44414,7 @@ func LoadNS() { var tmp9 any { // let // let binding "or__0__auto__" - tmp10 := checkDerefVar(glojure_DOT_core_ratio_QMARK_) + tmp10 := checkDerefVar(var_glojure_DOT_core_ratio_QMARK_) tmp11 := lang.Apply(tmp10, []any{v3}) var v12 any = tmp11 _ = v12 @@ -44572,7 +44422,7 @@ func LoadNS() { if lang.IsTruthy(v12) { tmp13 = v12 } else { - tmp14 := checkDerefVar(glojure_DOT_core_decimal_QMARK_) + tmp14 := checkDerefVar(var_glojure_DOT_core_decimal_QMARK_) tmp15 := lang.Apply(tmp14, []any{v3}) tmp13 = tmp15 } @@ -44584,7 +44434,7 @@ func LoadNS() { } // end let return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -44592,12 +44442,10 @@ func LoadNS() { } // rationalize { - tmp0 := lang.NewSymbol("rationalize").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("doc"), "returns the rational value of num", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1282), lang.NewKeyword("end-line"), int(1282))).(*lang.Symbol) + tmp0 := sym_rationalize.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_num)), kw_doc, "returns the rational value of num", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(1282), kw_end_DASH_line, int(1282))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Rationalize") @@ -44607,7 +44455,7 @@ func LoadNS() { tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -44615,7 +44463,7 @@ func LoadNS() { } // re-find { - tmp0 := lang.NewSymbol("re-find").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m")), lang.NewVector(lang.NewSymbol("re"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns the next regex match, if any, of string to pattern, using\n java.util.regex.Matcher.find(). Uses re-groups to return the\n groups.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4922), lang.NewKeyword("end-line"), int(4922))).(*lang.Symbol) + tmp0 := sym_re_DASH_find.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m), lang.NewVector(sym_re, sym_s)), kw_doc, "Returns the next regex match, if any, of string to pattern, using\n java.util.regex.Matcher.find(). Uses re-groups to return the\n groups.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4922), kw_end_DASH_line, int(4922))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -44629,7 +44477,7 @@ func LoadNS() { } tmp6 := lang.Apply(tmp5, []any{}) if lang.IsTruthy(tmp6) { - tmp7 := checkDerefVar(glojure_DOT_core_re_groups) + tmp7 := checkDerefVar(var_glojure_DOT_core_re_DASH_groups) tmp8 := lang.Apply(tmp7, []any{v3}) tmp4 = tmp8 } else { @@ -44643,20 +44491,21 @@ func LoadNS() { var tmp5 any { // let // let binding "m" - tmp6 := checkDerefVar(glojure_DOT_core_re_matcher) + tmp6 := checkDerefVar(var_glojure_DOT_core_re_DASH_matcher) tmp7 := lang.Apply(tmp6, []any{v3, v4}) var v8 any = tmp7 _ = v8 - tmp9 := checkDerefVar(glojure_DOT_core_re_find) + tmp9 := checkDerefVar(var_glojure_DOT_core_re_DASH_find) tmp10 := lang.Apply(tmp9, []any{v8}) tmp5 = tmp10 } // end let return tmp5 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -44664,12 +44513,10 @@ func LoadNS() { } // re-groups { - tmp0 := lang.NewSymbol("re-groups").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"))), lang.NewKeyword("doc"), "Returns the groups from the most recent match/find. If there are no\n nested groups, returns a string of the entire match. If there are\n nested groups, returns a vector of the groups, the first element\n being the entire match.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4882), lang.NewKeyword("end-line"), int(4882))).(*lang.Symbol) + tmp0 := sym_re_DASH_groups.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m)), kw_doc, "Returns the groups from the most recent match/find. If there are no\n nested groups, returns a string of the entire match. If there are\n nested groups, returns a vector of the groups, the first element\n being the entire match.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(4882), kw_end_DASH_line, int(4882))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any @@ -44683,7 +44530,7 @@ func LoadNS() { var v7 any = tmp6 _ = v7 var tmp8 any - tmp9 := checkDerefVar(glojure_DOT_core_zero_QMARK_) + tmp9 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) tmp10 := lang.Apply(tmp9, []any{v7}) if lang.IsTruthy(tmp10) { tmp11, _ := lang.FieldOrMethod(v3, "group") @@ -44697,7 +44544,7 @@ func LoadNS() { { // let // let binding "ret" tmp14 := lang.NewVector() - tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4893), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(4893), lang.NewKeyword("end-column"), int(21)) + tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4893), kw_column, int(20), kw_end_DASH_line, int(4893), kw_end_DASH_column, int(21)) tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) if err != nil { panic(err) @@ -44709,10 +44556,10 @@ func LoadNS() { _ = v18 for { var tmp19 any - tmp20 := checkDerefVar(glojure_DOT_core__LT__EQ_) + tmp20 := checkDerefVar(var_glojure_DOT_core__LT__EQ_) tmp21 := lang.Apply(tmp20, []any{v18, v7}) if lang.IsTruthy(tmp21) { - tmp23 := checkDerefVar(glojure_DOT_core_conj) + tmp23 := checkDerefVar(var_glojure_DOT_core_conj) tmp24, _ := lang.FieldOrMethod(v3, "groupInt") if reflect.TypeOf(tmp24).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("groupInt is not a function"))) @@ -44720,7 +44567,7 @@ func LoadNS() { tmp25 := lang.Apply(tmp24, []any{v18}) tmp26 := lang.Apply(tmp23, []any{v17, tmp25}) var tmp22 any = tmp26 - tmp28 := checkDerefVar(glojure_DOT_core_inc) + tmp28 := checkDerefVar(var_glojure_DOT_core_inc) tmp29 := lang.Apply(tmp28, []any{v18}) var tmp27 any = tmp29 v17 = tmp22 @@ -44739,7 +44586,7 @@ func LoadNS() { } // end let return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -44748,12 +44595,10 @@ func LoadNS() { // re-matcher { tmp1 := reflect.TypeOf((*lang.RegexpMatcher)(nil)) - tmp0 := lang.NewSymbol("re-matcher").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("re"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns an instance of java.util.regex.Matcher, for use, e.g. in\n re-find.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4873), lang.NewKeyword("end-line"), int(4873))).(*lang.Symbol) + tmp0 := sym_re_DASH_matcher.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_re, sym_s)), kw_doc, "Returns an instance of java.util.regex.Matcher, for use, e.g. in\n re-find.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4873), kw_end_DASH_line, int(4873))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -44762,7 +44607,7 @@ func LoadNS() { return tmp6 }) tmp4 := reflect.TypeOf((*lang.RegexpMatcher)(nil)) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -44770,12 +44615,10 @@ func LoadNS() { } // re-matches { - tmp0 := lang.NewSymbol("re-matches").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("re"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns the match, if any, of string to pattern, using\n java.util.regex.Matcher.matches(). Uses re-groups to return the\n groups.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4910), lang.NewKeyword("end-line"), int(4910))).(*lang.Symbol) + tmp0 := sym_re_DASH_matches.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_re, sym_s)), kw_doc, "Returns the match, if any, of string to pattern, using\n java.util.regex.Matcher.matches(). Uses re-groups to return the\n groups.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4910), kw_end_DASH_line, int(4910))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -44783,7 +44626,7 @@ func LoadNS() { var tmp5 any { // let // let binding "m" - tmp6 := checkDerefVar(glojure_DOT_core_re_matcher) + tmp6 := checkDerefVar(var_glojure_DOT_core_re_DASH_matcher) tmp7 := lang.Apply(tmp6, []any{v3, v4}) var v8 any = tmp7 _ = v8 @@ -44794,7 +44637,7 @@ func LoadNS() { } tmp11 := lang.Apply(tmp10, []any{}) if lang.IsTruthy(tmp11) { - tmp12 := checkDerefVar(glojure_DOT_core_re_groups) + tmp12 := checkDerefVar(var_glojure_DOT_core_re_DASH_groups) tmp13 := lang.Apply(tmp12, []any{v8}) tmp9 = tmp13 } else { @@ -44803,7 +44646,7 @@ func LoadNS() { } // end let return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -44812,16 +44655,14 @@ func LoadNS() { // re-pattern { tmp1 := reflect.TypeOf((*regexp15.Regexp)(nil)) - tmp0 := lang.NewSymbol("re-pattern").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns an instance of java.util.regex.Pattern, for use, e.g. in\n re-matcher.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4863), lang.NewKeyword("end-line"), int(4863))).(*lang.Symbol) + tmp0 := sym_re_DASH_pattern.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_doc, "Returns an instance of java.util.regex.Pattern, for use, e.g. in\n re-matcher.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4863), kw_end_DASH_line, int(4863))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 var tmp5 any - tmp6 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp6 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp7 := reflect.TypeOf((*regexp15.Regexp)(nil)) tmp8 := lang.Apply(tmp6, []any{tmp7, v4}) if lang.IsTruthy(tmp8) { @@ -44833,7 +44674,7 @@ func LoadNS() { return tmp5 }) tmp4 := reflect.TypeOf((*regexp15.Regexp)(nil)) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -44841,12 +44682,10 @@ func LoadNS() { } // re-seq { - tmp0 := lang.NewSymbol("re-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("re"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns a lazy sequence of successive matches of pattern in string,\n using java.util.regex.Matcher.find(), each such match processed with\n re-groups.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4898), lang.NewKeyword("end-line"), int(4898))).(*lang.Symbol) + tmp0 := sym_re_DASH_seq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_re, sym_s)), kw_doc, "Returns a lazy sequence of successive matches of pattern in string,\n using java.util.regex.Matcher.find(), each such match processed with\n re-groups.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(4898), kw_end_DASH_line, int(4898))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -44854,7 +44693,7 @@ func LoadNS() { var tmp5 any { // let // let binding "m" - tmp6 := checkDerefVar(glojure_DOT_core_re_matcher) + tmp6 := checkDerefVar(var_glojure_DOT_core_re_DASH_matcher) tmp7 := lang.Apply(tmp6, []any{v3, v4}) var v8 any = tmp7 _ = v8 @@ -44862,9 +44701,7 @@ func LoadNS() { { // function step var v10 lang.FnFunc tmp9 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var tmp11 any tmp12, _ := lang.FieldOrMethod(v8, "find") if reflect.TypeOf(tmp12).Kind() != reflect.Func { @@ -44872,14 +44709,12 @@ func LoadNS() { } tmp13 := lang.Apply(tmp12, []any{}) if lang.IsTruthy(tmp13) { - tmp14 := checkDerefVar(glojure_DOT_core_cons) - tmp15 := checkDerefVar(glojure_DOT_core_re_groups) + tmp14 := checkDerefVar(var_glojure_DOT_core_cons) + tmp15 := checkDerefVar(var_glojure_DOT_core_re_DASH_groups) tmp16 := lang.Apply(tmp15, []any{v8}) var tmp17 lang.FnFunc tmp17 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) tmp18 := lang.Apply(v10, nil) return tmp18 }) @@ -44893,7 +44728,7 @@ func LoadNS() { v10 = tmp9 _ = v10 } - tmp10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4906), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(4908), lang.NewKeyword("end-column"), int(49)) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4906), kw_column, int(6), kw_end_DASH_line, int(4908), kw_end_DASH_column, int(49)) tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) if err != nil { panic(err) @@ -44903,7 +44738,7 @@ func LoadNS() { } // end let return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -44911,19 +44746,19 @@ func LoadNS() { } // read { - tmp0 := lang.NewSymbol("read").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("stream")), lang.NewVector(lang.NewSymbol("stream"), lang.NewSymbol("eof-error?"), lang.NewSymbol("eof-value")), lang.NewVector(lang.NewSymbol("stream"), lang.NewSymbol("eof-error?"), lang.NewSymbol("eof-value"), lang.NewSymbol("recursive?")), lang.NewVector(lang.NewSymbol("opts"), lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Reads the next object from stream, which must be an instance of\n java.io.PushbackReader or some derivee. stream defaults to the\n current value of *in*.\n\n Opts is a persistent map with valid keys:\n :read-cond - :allow to process reader conditionals, or\n :preserve to keep all branches\n :features - persistent set of feature keywords for reader conditionals\n :eof - on eof, return value unless :eofthrow, then throw.\n if not specified, will throw\n\n Note that read can execute code (controlled by *read-eval*),\n and as such should be used only with trusted sources.\n\n For data structure interop use glojure.edn/read", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3742), lang.NewKeyword("end-line"), int(3742))).(*lang.Symbol) + tmp0 := sym_read.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_stream), lang.NewVector(sym_stream, sym_eof_DASH_error_QMARK_, sym_eof_DASH_value), lang.NewVector(sym_stream, sym_eof_DASH_error_QMARK_, sym_eof_DASH_value, sym_recursive_QMARK_), lang.NewVector(sym_opts, sym_stream)), kw_doc, "Reads the next object from stream, which must be an instance of\n java.io.PushbackReader or some derivee. stream defaults to the\n current value of *in*.\n\n Opts is a persistent map with valid keys:\n :read-cond - :allow to process reader conditionals, or\n :preserve to keep all branches\n :features - persistent set of feature keywords for reader conditionals\n :eof - on eof, return value unless :eofthrow, then throw.\n if not specified, will throw\n\n Note that read can execute code (controlled by *read-eval*),\n and as such should be used only with trusted sources.\n\n For data structure interop use glojure.edn/read", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3742), kw_end_DASH_line, int(3742))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - tmp3 := checkDerefVar(glojure_DOT_core_read) - tmp4 := checkDerefVar(glojure_DOT_core__STAR_in_STAR_) + tmp3 := checkDerefVar(var_glojure_DOT_core_read) + tmp4 := checkDerefVar(var_glojure_DOT_core__STAR_in_STAR_) tmp5 := lang.Apply(tmp3, []any{tmp4}) return tmp5 case 1: v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_read) + tmp4 := checkDerefVar(var_glojure_DOT_core_read) tmp5 := lang.Apply(tmp4, []any{v3, true, nil}) return tmp5 case 3: @@ -44933,7 +44768,7 @@ func LoadNS() { _ = v4 v5 := args[2] _ = v5 - tmp6 := checkDerefVar(glojure_DOT_core_read) + tmp6 := checkDerefVar(var_glojure_DOT_core_read) tmp7 := lang.Apply(tmp6, []any{v3, v4, v5, false}) return tmp7 case 4: @@ -44945,7 +44780,7 @@ func LoadNS() { _ = v5 v6 := args[3] _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_boolean) + tmp7 := checkDerefVar(var_glojure_DOT_core_boolean) tmp8 := lang.Apply(tmp7, []any{v4}) tmp9, _ := lang.FieldOrMethod(nil, "read") if reflect.TypeOf(tmp9).Kind() != reflect.Func { @@ -44965,10 +44800,11 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v4, v3}) return tmp6 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -44976,19 +44812,19 @@ func LoadNS() { } // read+string { - tmp0 := lang.NewSymbol("read+string").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("stream")), lang.NewVector(lang.NewSymbol("stream"), lang.NewSymbol("eof-error?"), lang.NewSymbol("eof-value")), lang.NewVector(lang.NewSymbol("stream"), lang.NewSymbol("eof-error?"), lang.NewSymbol("eof-value"), lang.NewSymbol("recursive?")), lang.NewVector(lang.NewSymbol("opts"), lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Like read, and taking the same args. stream must be a LineNumberingPushbackReader.\n Returns a vector containing the object read and the (whitespace-trimmed) string read.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3771), lang.NewKeyword("end-line"), int(3771))).(*lang.Symbol) + tmp0 := sym_read_PLUS_string.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_stream), lang.NewVector(sym_stream, sym_eof_DASH_error_QMARK_, sym_eof_DASH_value), lang.NewVector(sym_stream, sym_eof_DASH_error_QMARK_, sym_eof_DASH_value, sym_recursive_QMARK_), lang.NewVector(sym_opts, sym_stream)), kw_doc, "Like read, and taking the same args. stream must be a LineNumberingPushbackReader.\n Returns a vector containing the object read and the (whitespace-trimmed) string read.", kw_file, "glojure/core.glj", kw_added, "1.10", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(3771), kw_end_DASH_line, int(3771))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - tmp3 := checkDerefVar(glojure_DOT_core_read_PLUS_string) - tmp4 := checkDerefVar(glojure_DOT_core__STAR_in_STAR_) + tmp3 := checkDerefVar(var_glojure_DOT_core_read_PLUS_string) + tmp4 := checkDerefVar(var_glojure_DOT_core__STAR_in_STAR_) tmp5 := lang.Apply(tmp3, []any{tmp4}) return tmp5 case 1: v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_read_PLUS_string) + tmp4 := checkDerefVar(var_glojure_DOT_core_read_PLUS_string) tmp5 := lang.Apply(tmp4, []any{v3, true, nil}) return tmp5 case 3: @@ -44998,7 +44834,7 @@ func LoadNS() { _ = v4 v5 := args[2] _ = v5 - tmp6 := checkDerefVar(glojure_DOT_core_read_PLUS_string) + tmp6 := checkDerefVar(var_glojure_DOT_core_read_PLUS_string) tmp7 := lang.Apply(tmp6, []any{v3, v4, v5, false}) return tmp7 case 4: @@ -45050,7 +44886,7 @@ func LoadNS() { var tmp10 any { // let // let binding "o" - tmp11 := checkDerefVar(glojure_DOT_core_read) + tmp11 := checkDerefVar(var_glojure_DOT_core_read) tmp12 := lang.Apply(tmp11, []any{v3, v4, v5, v6}) var v13 any = tmp12 _ = v13 @@ -45080,7 +44916,7 @@ func LoadNS() { var v18 any = tmp17 _ = v18 tmp19 := lang.NewVector(v13, v18) - tmp20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3783), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(3783), lang.NewKeyword("end-column"), int(12)) + tmp20 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3783), kw_column, int(8), kw_end_DASH_line, int(3783), kw_end_DASH_column, int(12)) tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) if err != nil { panic(err) @@ -45135,7 +44971,7 @@ func LoadNS() { var tmp8 any { // let // let binding "o" - tmp9 := checkDerefVar(glojure_DOT_core_read) + tmp9 := checkDerefVar(var_glojure_DOT_core_read) tmp10 := lang.Apply(tmp9, []any{v3, v4}) var v11 any = tmp10 _ = v11 @@ -45165,7 +45001,7 @@ func LoadNS() { var v16 any = tmp15 _ = v16 tmp17 := lang.NewVector(v11, v16) - tmp18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3792), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(3792), lang.NewKeyword("end-column"), int(12)) + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3792), kw_column, int(8), kw_end_DASH_line, int(3792), kw_end_DASH_column, int(12)) tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) if err != nil { panic(err) @@ -45176,10 +45012,11 @@ func LoadNS() { }() return tmp5 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -45187,18 +45024,16 @@ func LoadNS() { } // read-line { - tmp0 := lang.NewSymbol("read-line").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Reads the next line from stream that is the current value of *in* .", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3797), lang.NewKeyword("end-line"), int(3797))).(*lang.Symbol) + tmp0 := sym_read_DASH_line.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Reads the next line from stream that is the current value of *in* .", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(3797), kw_end_DASH_line, int(3797))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var tmp3 any - tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) - tmp5 := checkDerefVar(glojure_DOT_core__STAR_in_STAR_) + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_in_STAR_) tmp6 := lang.Apply(tmp4, []any{nil, tmp5}) if lang.IsTruthy(tmp6) { - tmp7 := checkDerefVar(glojure_DOT_core__STAR_in_STAR_) + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_in_STAR_) tmp8, ok := lang.FieldOrMethod(tmp7, "readLine") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp7, "readLine"))) @@ -45212,7 +45047,7 @@ func LoadNS() { } tmp3 = tmp9 } else { - tmp10 := checkDerefVar(glojure_DOT_core__STAR_in_STAR_) + tmp10 := checkDerefVar(var_glojure_DOT_core__STAR_in_STAR_) tmp11, ok := lang.FieldOrMethod(tmp10, "readLine") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp10, "readLine"))) @@ -45228,7 +45063,7 @@ func LoadNS() { } return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -45236,7 +45071,7 @@ func LoadNS() { } // read-string { - tmp0 := lang.NewSymbol("read-string").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s")), lang.NewVector(lang.NewSymbol("opts"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Reads one object from the string s. Optionally include reader\n options, as specified in read.\n\n Note that read-string can execute code (controlled by *read-eval*),\n and as such should be used only with trusted sources.\n\n For data structure interop use glojure.edn/read-string", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3806), lang.NewKeyword("end-line"), int(3806))).(*lang.Symbol) + tmp0 := sym_read_DASH_string.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s), lang.NewVector(sym_opts, sym_s)), kw_doc, "Reads one object from the string s. Optionally include reader\n options, as specified in read.\n\n Note that read-string can execute code (controlled by *read-eval*),\n and as such should be used only with trusted sources.\n\n For data structure interop use glojure.edn/read-string", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(3806), kw_end_DASH_line, int(3806))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -45253,10 +45088,11 @@ func LoadNS() { tmp5 := lang.Apply(runtime7.RTReadString, []any{v4, v3}) return tmp5 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -45264,12 +45100,10 @@ func LoadNS() { } // reader-conditional { - tmp0 := lang.NewSymbol("reader-conditional").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("form"), lang.NewSymbol("splicing?"))), lang.NewKeyword("doc"), "Construct a data representation of a reader conditional.\n If true, splicing? indicates read-cond-splicing.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7782), lang.NewKeyword("end-line"), int(7782))).(*lang.Symbol) + tmp0 := sym_reader_DASH_conditional.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_form, sym_splicing_QMARK_)), kw_doc, "Construct a data representation of a reader conditional.\n If true, splicing? indicates read-cond-splicing.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(24), kw_column, int(7), kw_line, int(7782), kw_end_DASH_line, int(7782))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -45277,7 +45111,7 @@ func LoadNS() { tmp5 := lang.Apply(nil, []any{v3, v4}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -45285,19 +45119,17 @@ func LoadNS() { } // reader-conditional? { - tmp0 := lang.NewSymbol("reader-conditional?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("value"))), lang.NewKeyword("doc"), "Return true if the value is the data representation of a reader conditional", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7776), lang.NewKeyword("end-line"), int(7776))).(*lang.Symbol) + tmp0 := sym_reader_DASH_conditional_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_value)), kw_doc, "Return true if the value is the data representation of a reader conditional", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(25), kw_column, int(7), kw_line, int(7776), kw_end_DASH_line, int(7776))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp5 := lang.Apply(tmp4, []any{nil, v3}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -45305,12 +45137,10 @@ func LoadNS() { } // realized? { - tmp0 := lang.NewSymbol("realized?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if a value has been produced for a promise, delay, future or lazy sequence.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7559), lang.NewKeyword("end-line"), int(7559))).(*lang.Symbol) + tmp0 := sym_realized_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if a value has been produced for a promise, delay, future or lazy sequence.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(7559), kw_end_DASH_line, int(7559))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4, ok := lang.FieldOrMethod(v3, "isRealized") @@ -45326,7 +45156,7 @@ func LoadNS() { } return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -45334,7 +45164,7 @@ func LoadNS() { } // reduce { - tmp0 := lang.NewSymbol("reduce").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("val"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "f should be a function of 2 arguments. If val is not supplied,\n returns the result of applying f to the first 2 items in coll, then\n applying f to that result and the 3rd item, etc. If coll contains no\n items, f must accept no arguments as well, and reduce returns the\n result of calling f with no arguments. If coll has only 1 item, it\n is returned and f is not called. If val is supplied, returns the\n result of applying f to val and the first item in coll, then\n applying f to that result and the 2nd item, etc. If coll contains no\n items, returns val and f is not called.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6860), lang.NewKeyword("end-line"), int(6860))).(*lang.Symbol) + tmp0 := sym_reduce.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_coll), lang.NewVector(sym_f, sym_val, sym_coll)), kw_doc, "f should be a function of 2 arguments. If val is not supplied,\n returns the result of applying f to the first 2 items in coll, then\n applying f to that result and the 3rd item, etc. If coll contains no\n items, f must accept no arguments as well, and reduce returns the\n result of calling f with no arguments. If coll has only 1 item, it\n is returned and f is not called. If val is supplied, returns the\n result of applying f to val and the first item in coll, then\n applying f to that result and the 2nd item, etc. If coll contains no\n items, returns val and f is not called.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(6860), kw_end_DASH_line, int(6860))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -45344,7 +45174,7 @@ func LoadNS() { v4 := args[1] _ = v4 var tmp5 any - tmp6 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp6 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp7 := reflect.TypeOf((*lang.IReduce)(nil)).Elem() tmp8 := lang.Apply(tmp6, []any{tmp7, v4}) if lang.IsTruthy(tmp8) { @@ -45355,7 +45185,7 @@ func LoadNS() { tmp10 := lang.Apply(tmp9, []any{v3}) tmp5 = tmp10 } else { - tmp11 := checkDerefVar(glojure_DOT_core_DOT_protocols_coll_reduce) + tmp11 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_coll_DASH_reduce) tmp12 := lang.Apply(tmp11, []any{v4, v3}) tmp5 = tmp12 } @@ -45368,7 +45198,7 @@ func LoadNS() { v5 := args[2] _ = v5 var tmp6 any - tmp7 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp7 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp8 := reflect.TypeOf((*lang.IReduceInit)(nil)).Elem() tmp9 := lang.Apply(tmp7, []any{tmp8, v5}) if lang.IsTruthy(tmp9) { @@ -45379,16 +45209,17 @@ func LoadNS() { tmp11 := lang.Apply(tmp10, []any{v3, v4}) tmp6 = tmp11 } else { - tmp12 := checkDerefVar(glojure_DOT_core_DOT_protocols_coll_reduce) + tmp12 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_coll_DASH_reduce) tmp13 := lang.Apply(tmp12, []any{v5, v3, v4}) tmp6 = tmp13 } return tmp6 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -45396,23 +45227,21 @@ func LoadNS() { } // reduce-kv { - tmp0 := lang.NewSymbol("reduce-kv").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Reduces an associative collection. f should be a function of 3\n arguments. Returns the result of applying f to init, the first key\n and the first value in coll, then applying f to that result and the\n 2nd key and value, etc. If coll contains no entries, returns init\n and f is not called. Note that reduce-kv is supported on vectors,\n where the keys will be the ordinals.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.4", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6882), lang.NewKeyword("end-line"), int(6882))).(*lang.Symbol) + tmp0 := sym_reduce_DASH_kv.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_init, sym_coll)), kw_doc, "Reduces an associative collection. f should be a function of 3\n arguments. Returns the result of applying f to init, the first key\n and the first value in coll, then applying f to that result and the\n 2nd key and value, etc. If coll contains no entries, returns init\n and f is not called. Note that reduce-kv is supported on vectors,\n where the keys will be the ordinals.", kw_file, "glojure/core.glj", kw_added, "1.4", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(6882), kw_end_DASH_line, int(6882))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] _ = v4 v5 := args[2] _ = v5 - tmp6 := checkDerefVar(glojure_DOT_core_DOT_protocols_kv_reduce) + tmp6 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_kv_DASH_reduce) tmp7 := lang.Apply(tmp6, []any{v5, v3, v4}) return tmp7 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -45420,7 +45249,7 @@ func LoadNS() { } // reduce1 { - tmp0 := lang.NewSymbol("reduce1").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(923), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(924), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("val"), lang.NewSymbol("coll"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym_reduce1.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(923), kw_column, int(7), kw_end_DASH_line, int(924), kw_end_DASH_column, int(9), kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_coll), lang.NewVector(sym_f, sym_val, sym_coll)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -45432,16 +45261,16 @@ func LoadNS() { var tmp5 any { // let // let binding "s" - tmp6 := checkDerefVar(glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) tmp7 := lang.Apply(tmp6, []any{v4}) var v8 any = tmp7 _ = v8 var tmp9 any if lang.IsTruthy(v8) { - tmp10 := checkDerefVar(glojure_DOT_core_reduce1) - tmp11 := checkDerefVar(glojure_DOT_core_first) + tmp10 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp11 := checkDerefVar(var_glojure_DOT_core_first) tmp12 := lang.Apply(tmp11, []any{v8}) - tmp13 := checkDerefVar(glojure_DOT_core_next) + tmp13 := checkDerefVar(var_glojure_DOT_core_next) tmp14 := lang.Apply(tmp13, []any{v8}) tmp15 := lang.Apply(tmp10, []any{v3, tmp12, tmp14}) tmp9 = tmp15 @@ -45463,18 +45292,18 @@ func LoadNS() { var tmp6 any { // let // let binding "s" - tmp7 := checkDerefVar(glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) tmp8 := lang.Apply(tmp7, []any{v5}) var v9 any = tmp8 _ = v9 var tmp10 any if lang.IsTruthy(v9) { var tmp11 any - tmp12 := checkDerefVar(glojure_DOT_core_chunked_seq_QMARK_) + tmp12 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) tmp13 := lang.Apply(tmp12, []any{v9}) if lang.IsTruthy(tmp13) { var tmp14 any = v3 - tmp16 := checkDerefVar(glojure_DOT_core_chunk_first) + tmp16 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) tmp17 := lang.Apply(tmp16, []any{v9}) tmp18, _ := lang.FieldOrMethod(tmp17, "ReduceInit") if reflect.TypeOf(tmp18).Kind() != reflect.Func { @@ -45482,7 +45311,7 @@ func LoadNS() { } tmp19 := lang.Apply(tmp18, []any{v3, v4}) var tmp15 any = tmp19 - tmp21 := checkDerefVar(glojure_DOT_core_chunk_next) + tmp21 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_next) tmp22 := lang.Apply(tmp21, []any{v9}) var tmp20 any = tmp22 v3 = tmp14 @@ -45491,11 +45320,11 @@ func LoadNS() { goto recur_loop_156 } else { var tmp23 any = v3 - tmp25 := checkDerefVar(glojure_DOT_core_first) + tmp25 := checkDerefVar(var_glojure_DOT_core_first) tmp26 := lang.Apply(tmp25, []any{v9}) tmp27 := lang.Apply(v3, []any{v4, tmp26}) var tmp24 any = tmp27 - tmp29 := checkDerefVar(glojure_DOT_core_next) + tmp29 := checkDerefVar(var_glojure_DOT_core_next) tmp30 := lang.Apply(tmp29, []any{v9}) var tmp28 any = tmp30 v3 = tmp23 @@ -45511,10 +45340,11 @@ func LoadNS() { } // end let return tmp6 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -45522,18 +45352,16 @@ func LoadNS() { } // reduced { - tmp0 := lang.NewSymbol("reduced").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Wraps x in a way such that a reduce will terminate with the value x", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2828), lang.NewKeyword("end-line"), int(2828))).(*lang.Symbol) + tmp0 := sym_reduced.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Wraps x in a way such that a reduce will terminate with the value x", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(2828), kw_end_DASH_line, int(2828))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4 := lang.Apply(lang.NewReduced, []any{v3}) return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -45545,16 +45373,14 @@ func LoadNS() { { // function reduced?__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) - tmp5 := checkDerefVar(glojure_DOT_core_concat) - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.IsReduced")}) - tmp8 := checkDerefVar(glojure_DOT_core_list) + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_IsReduced}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{v3}) tmp10 := lang.Apply(tmp5, []any{tmp7, tmp9}) tmp11 := lang.Apply(tmp4, []any{tmp10}) @@ -45563,18 +45389,16 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("reduced?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns true if x is the result of a call to reduced", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1)})), lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2834), lang.NewKeyword("end-line"), int(2834))).(*lang.Symbol) + tmp0 := sym_reduced_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns true if x is the result of a call to reduced", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1)})), kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(2834), kw_end_DASH_line, int(2834))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 tmp5 := lang.Apply(lang.IsReduced, []any{v4}) return tmp5 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -45582,7 +45406,7 @@ func LoadNS() { } // reductions { - tmp0 := lang.NewSymbol("reductions").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy seq of the intermediate values of the reduction (as\n per reduce) of coll by f, starting with init.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7196), lang.NewKeyword("end-line"), int(7196))).(*lang.Symbol) + tmp0 := sym_reductions.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_coll), lang.NewVector(sym_f, sym_init, sym_coll)), kw_doc, "Returns a lazy seq of the intermediate values of the reduction (as\n per reduce) of coll by f, starting with init.", kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(7196), kw_end_DASH_line, int(7196))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -45593,13 +45417,11 @@ func LoadNS() { _ = v4 var tmp5 lang.FnFunc tmp5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var tmp6 any { // let // let binding "temp__0__auto__" - tmp7 := checkDerefVar(glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) tmp8 := lang.Apply(tmp7, []any{v4}) var v9 any = tmp8 _ = v9 @@ -45610,17 +45432,17 @@ func LoadNS() { // let binding "s" var v12 any = v9 _ = v12 - tmp13 := checkDerefVar(glojure_DOT_core_reductions) - tmp14 := checkDerefVar(glojure_DOT_core_first) + tmp13 := checkDerefVar(var_glojure_DOT_core_reductions) + tmp14 := checkDerefVar(var_glojure_DOT_core_first) tmp15 := lang.Apply(tmp14, []any{v12}) - tmp16 := checkDerefVar(glojure_DOT_core_rest) + tmp16 := checkDerefVar(var_glojure_DOT_core_rest) tmp17 := lang.Apply(tmp16, []any{v12}) tmp18 := lang.Apply(tmp13, []any{v3, tmp15, tmp17}) tmp11 = tmp18 } // end let tmp10 = tmp11 } else { - tmp12 := checkDerefVar(glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := lang.Apply(v3, nil) tmp14 := lang.Apply(tmp12, []any{tmp13}) tmp10 = tmp14 @@ -45639,25 +45461,23 @@ func LoadNS() { v5 := args[2] _ = v5 var tmp6 any - tmp7 := checkDerefVar(glojure_DOT_core_reduced_QMARK_) + tmp7 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) tmp8 := lang.Apply(tmp7, []any{v4}) if lang.IsTruthy(tmp8) { - tmp9 := checkDerefVar(glojure_DOT_core_list) - tmp10 := checkDerefVar(glojure_DOT_core_deref) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := checkDerefVar(var_glojure_DOT_core_deref) tmp11 := lang.Apply(tmp10, []any{v4}) tmp12 := lang.Apply(tmp9, []any{tmp11}) tmp6 = tmp12 } else { - tmp13 := checkDerefVar(glojure_DOT_core_cons) + tmp13 := checkDerefVar(var_glojure_DOT_core_cons) var tmp14 lang.FnFunc tmp14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var tmp15 any { // let // let binding "temp__0__auto__" - tmp16 := checkDerefVar(glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_seq) tmp17 := lang.Apply(tmp16, []any{v5}) var v18 any = tmp17 _ = v18 @@ -45668,11 +45488,11 @@ func LoadNS() { // let binding "s" var v21 any = v18 _ = v21 - tmp22 := checkDerefVar(glojure_DOT_core_reductions) - tmp23 := checkDerefVar(glojure_DOT_core_first) + tmp22 := checkDerefVar(var_glojure_DOT_core_reductions) + tmp23 := checkDerefVar(var_glojure_DOT_core_first) tmp24 := lang.Apply(tmp23, []any{v21}) tmp25 := lang.Apply(v3, []any{v4, tmp24}) - tmp26 := checkDerefVar(glojure_DOT_core_rest) + tmp26 := checkDerefVar(var_glojure_DOT_core_rest) tmp27 := lang.Apply(tmp26, []any{v21}) tmp28 := lang.Apply(tmp22, []any{v3, tmp25, tmp27}) tmp20 = tmp28 @@ -45690,10 +45510,11 @@ func LoadNS() { } return tmp6 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -45701,7 +45522,7 @@ func LoadNS() { } // ref { - tmp0 := lang.NewSymbol("ref").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Creates and returns a Ref with an initial value of x and zero or\n more options (in any order):\n\n :meta metadata-map\n\n :validator validate-fn\n\n :min-history (default 0)\n :max-history (default 10)\n\n If metadata-map is supplied, it will become the metadata on the\n ref. validate-fn must be nil or a side-effect-free fn of one\n argument, which will be passed the intended new state on any state\n change. If the new state is unacceptable, the validate-fn should\n return false or throw an exception. validate-fn will be called on\n transaction commit, when all refs have their final values.\n\n Normally refs accumulate history dynamically as needed to deal with\n read demands. If you know in advance you will need history you can\n set :min-history to ensure it will be available when first needed (instead\n of after a read fault). History is limited, and the limit can be set\n with :max-history.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2260), lang.NewKeyword("end-line"), int(2260))).(*lang.Symbol) + tmp0 := sym_ref.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym__AMP_, sym_options)), kw_doc, "Creates and returns a Ref with an initial value of x and zero or\n more options (in any order):\n\n :meta metadata-map\n\n :validator validate-fn\n\n :min-history (default 0)\n :max-history (default 10)\n\n If metadata-map is supplied, it will become the metadata on the\n ref. validate-fn must be nil or a side-effect-free fn of one\n argument, which will be passed the intended new state on any state\n change. If the new state is unacceptable, the validate-fn should\n return false or throw an exception. validate-fn will be called on\n transaction commit, when all refs have their final values.\n\n Normally refs accumulate history dynamically as needed to deal with\n read demands. If you know in advance you will need history you can\n set :min-history to ensure it will be available when first needed (instead\n of after a read fault). History is limited, and the limit can be set\n with :max-history.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(2260), kw_end_DASH_line, int(2260))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -45711,9 +45532,7 @@ func LoadNS() { tmp4 := lang.Apply(lang.NewRef, []any{v3}) return tmp4 default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var v4 any = lang.NewList(args[1:]...) @@ -45721,22 +45540,22 @@ func LoadNS() { var tmp5 any { // let // let binding "r" - tmp6 := checkDerefVar(glojure_DOT_core_setup_reference) - tmp7 := checkDerefVar(glojure_DOT_core_ref) + tmp6 := checkDerefVar(var_glojure_DOT_core_setup_DASH_reference) + tmp7 := checkDerefVar(var_glojure_DOT_core_ref) tmp8 := lang.Apply(tmp7, []any{v3}) tmp9 := lang.Apply(tmp6, []any{tmp8, v4}) var v10 any = tmp9 _ = v10 // let binding "opts" - tmp11 := checkDerefVar(glojure_DOT_core_apply) - tmp12 := checkDerefVar(glojure_DOT_core_hash_map) + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + tmp12 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) tmp13 := lang.Apply(tmp11, []any{tmp12, v4}) var v14 any = tmp13 _ = v14 var tmp15 any - tmp16 := lang.Apply(lang.NewKeyword("max-history"), []any{v14}) + tmp16 := lang.Apply(kw_max_DASH_history, []any{v14}) if lang.IsTruthy(tmp16) { - tmp17 := lang.Apply(lang.NewKeyword("max-history"), []any{v14}) + tmp17 := lang.Apply(kw_max_DASH_history, []any{v14}) tmp18, _ := lang.FieldOrMethod(v10, "setMaxHistory") if reflect.TypeOf(tmp18).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMaxHistory is not a function"))) @@ -45747,9 +45566,9 @@ func LoadNS() { } _ = tmp15 var tmp20 any - tmp21 := lang.Apply(lang.NewKeyword("min-history"), []any{v14}) + tmp21 := lang.Apply(kw_min_DASH_history, []any{v14}) if lang.IsTruthy(tmp21) { - tmp22 := lang.Apply(lang.NewKeyword("min-history"), []any{v14}) + tmp22 := lang.Apply(kw_min_DASH_history, []any{v14}) tmp23, _ := lang.FieldOrMethod(v10, "setMinHistory") if reflect.TypeOf(tmp23).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMinHistory is not a function"))) @@ -45764,7 +45583,7 @@ func LoadNS() { return tmp5 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -45772,12 +45591,10 @@ func LoadNS() { } // ref-history-count { - tmp0 := lang.NewSymbol("ref-history-count").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref"))), lang.NewKeyword("doc"), "Returns the history count of a ref", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2455), lang.NewKeyword("end-line"), int(2455))).(*lang.Symbol) + tmp0 := sym_ref_DASH_history_DASH_count.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ref)), kw_doc, "Returns the history count of a ref", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(7), kw_line, int(2455), kw_end_DASH_line, int(2455))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4, ok := lang.FieldOrMethod(v3, "getHistoryCount") @@ -45793,7 +45610,7 @@ func LoadNS() { } return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -45801,7 +45618,7 @@ func LoadNS() { } // ref-max-history { - tmp0 := lang.NewSymbol("ref-max-history").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref")), lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Gets the max-history of a ref, or sets it and returns the ref", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2471), lang.NewKeyword("end-line"), int(2471))).(*lang.Symbol) + tmp0 := sym_ref_DASH_max_DASH_history.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ref), lang.NewVector(sym_ref, sym_n)), kw_doc, "Gets the max-history of a ref, or sets it and returns the ref", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(2471), kw_end_DASH_line, int(2471))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -45832,10 +45649,11 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v4}) return tmp6 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -45843,7 +45661,7 @@ func LoadNS() { } // ref-min-history { - tmp0 := lang.NewSymbol("ref-min-history").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref")), lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Gets the min-history of a ref, or sets it and returns the ref", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2462), lang.NewKeyword("end-line"), int(2462))).(*lang.Symbol) + tmp0 := sym_ref_DASH_min_DASH_history.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ref), lang.NewVector(sym_ref, sym_n)), kw_doc, "Gets the min-history of a ref, or sets it and returns the ref", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(2462), kw_end_DASH_line, int(2462))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -45874,10 +45692,11 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v4}) return tmp6 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -45885,12 +45704,10 @@ func LoadNS() { } // ref-set { - tmp0 := lang.NewSymbol("ref-set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ref"), lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Must be called in a transaction. Sets the value of ref.\n Returns val.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2447), lang.NewKeyword("end-line"), int(2447))).(*lang.Symbol) + tmp0 := sym_ref_DASH_set.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ref, sym_val)), kw_doc, "Must be called in a transaction. Sets the value of ref.\n Returns val.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(2447), kw_end_DASH_line, int(2447))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -45902,7 +45719,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v4}) return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -45910,14 +45727,12 @@ func LoadNS() { } // refer { - tmp0 := lang.NewSymbol("refer").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("ns-sym"), lang.NewSymbol("&"), lang.NewSymbol("filters"))), lang.NewKeyword("doc"), "refers to all public vars of ns, subject to filters.\n filters can include at most one each of:\n\n :exclude list-of-symbols\n :only list-of-symbols\n :rename map-of-fromsymbol-tosymbol\n\n For each public interned var in the namespace named by the symbol,\n adds a mapping from the name of the var to the var to the current\n namespace. Throws an exception if name is already mapped to\n something else in the current namespace. Filters can be used to\n select a subset, via inclusion or exclusion, or to provide a mapping\n to a symbol different from the var's name, in order to prevent\n clashes. Use :use in the ns macro in preference to calling this directly.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4216), lang.NewKeyword("end-line"), int(4216))).(*lang.Symbol) + tmp0 := sym_refer.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns_DASH_sym, sym__AMP_, sym_filters)), kw_doc, "refers to all public vars of ns, subject to filters.\n filters can include at most one each of:\n\n :exclude list-of-symbols\n :only list-of-symbols\n :rename map-of-fromsymbol-tosymbol\n\n For each public interned var in the namespace named by the symbol,\n adds a mapping from the name of the var to the var to the current\n namespace. Throws an exception if name is already mapped to\n something else in the current namespace. Filters can be used to\n select a subset, via inclusion or exclusion, or to provide a mapping\n to a symbol different from the var's name, in order to prevent\n clashes. Use :use in the ns macro in preference to calling this directly.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(4216), kw_end_DASH_line, int(4216))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var v4 any = lang.NewList(args[1:]...) @@ -45928,7 +45743,7 @@ func LoadNS() { var tmp6 any { // let // let binding "or__0__auto__" - tmp7 := checkDerefVar(glojure_DOT_core_find_ns) + tmp7 := checkDerefVar(var_glojure_DOT_core_find_DASH_ns) tmp8 := lang.Apply(tmp7, []any{v3}) var v9 any = tmp8 _ = v9 @@ -45936,7 +45751,7 @@ func LoadNS() { if lang.IsTruthy(v9) { tmp10 = v9 } else { - tmp11 := checkDerefVar(glojure_DOT_core_str) + tmp11 := checkDerefVar(var_glojure_DOT_core_str) tmp12 := lang.Apply(tmp11, []any{"No namespace: ", v3}) tmp13 := lang.Apply(errors8.New, []any{tmp12}) panic(tmp13) @@ -45946,13 +45761,13 @@ func LoadNS() { var v7 any = tmp6 _ = v7 // let binding "fs" - tmp8 := checkDerefVar(glojure_DOT_core_apply) - tmp9 := checkDerefVar(glojure_DOT_core_hash_map) + tmp8 := checkDerefVar(var_glojure_DOT_core_apply) + tmp9 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) tmp10 := lang.Apply(tmp8, []any{tmp9, v4}) var v11 any = tmp10 _ = v11 // let binding "nspublics" - tmp12 := checkDerefVar(glojure_DOT_core_ns_publics) + tmp12 := checkDerefVar(var_glojure_DOT_core_ns_DASH_publics) tmp13 := lang.Apply(tmp12, []any{v7}) var v14 any = tmp13 _ = v14 @@ -45960,7 +45775,7 @@ func LoadNS() { var tmp15 any { // let // let binding "or__0__auto__" - tmp16 := lang.Apply(lang.NewKeyword("rename"), []any{v11}) + tmp16 := lang.Apply(kw_rename, []any{v11}) var v17 any = tmp16 _ = v17 var tmp18 any @@ -45968,7 +45783,7 @@ func LoadNS() { tmp18 = v17 } else { tmp19 := lang.NewMap() - tmp20 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4236), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(4236), lang.NewKeyword("end-column"), int(36)) + tmp20 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4236), kw_column, int(35), kw_end_DASH_line, int(4236), kw_end_DASH_column, int(36)) tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) if err != nil { panic(err) @@ -45980,25 +45795,25 @@ func LoadNS() { var v16 any = tmp15 _ = v16 // let binding "exclude" - tmp17 := checkDerefVar(glojure_DOT_core_set) - tmp18 := lang.Apply(lang.NewKeyword("exclude"), []any{v11}) + tmp17 := checkDerefVar(var_glojure_DOT_core_set) + tmp18 := lang.Apply(kw_exclude, []any{v11}) tmp19 := lang.Apply(tmp17, []any{tmp18}) var v20 any = tmp19 _ = v20 // let binding "to-do" var tmp21 any - tmp22 := checkDerefVar(glojure_DOT_core__EQ_) - tmp23 := lang.Apply(lang.NewKeyword("refer"), []any{v11}) - tmp24 := lang.Apply(tmp22, []any{lang.NewKeyword("all"), tmp23}) + tmp22 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp23 := lang.Apply(kw_refer, []any{v11}) + tmp24 := lang.Apply(tmp22, []any{kw_all, tmp23}) if lang.IsTruthy(tmp24) { - tmp25 := checkDerefVar(glojure_DOT_core_keys) + tmp25 := checkDerefVar(var_glojure_DOT_core_keys) tmp26 := lang.Apply(tmp25, []any{v14}) tmp21 = tmp26 } else { var tmp27 any { // let // let binding "or__0__auto__" - tmp28 := lang.Apply(lang.NewKeyword("refer"), []any{v11}) + tmp28 := lang.Apply(kw_refer, []any{v11}) var v29 any = tmp28 _ = v29 var tmp30 any @@ -46008,14 +45823,14 @@ func LoadNS() { var tmp31 any { // let // let binding "or__0__auto__" - tmp32 := lang.Apply(lang.NewKeyword("only"), []any{v11}) + tmp32 := lang.Apply(kw_only, []any{v11}) var v33 any = tmp32 _ = v33 var tmp34 any if lang.IsTruthy(v33) { tmp34 = v33 } else { - tmp35 := checkDerefVar(glojure_DOT_core_keys) + tmp35 := checkDerefVar(var_glojure_DOT_core_keys) tmp36 := lang.Apply(tmp35, []any{v14}) tmp34 = tmp36 } @@ -46037,8 +45852,8 @@ func LoadNS() { _ = v31 var tmp32 any if lang.IsTruthy(v31) { - tmp33 := checkDerefVar(glojure_DOT_core_not) - tmp34 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp33 := checkDerefVar(var_glojure_DOT_core_not) + tmp34 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp35 := reflect.TypeOf((*lang.Sequential)(nil)).Elem() tmp36 := lang.Apply(tmp34, []any{tmp35, v28}) tmp37 := lang.Apply(tmp33, []any{tmp36}) @@ -46057,7 +45872,7 @@ func LoadNS() { var tmp32 any { // let // let binding "seq_9" - tmp33 := checkDerefVar(glojure_DOT_core_seq) + tmp33 := checkDerefVar(var_glojure_DOT_core_seq) tmp34 := lang.Apply(tmp33, []any{v28}) var v35 any = tmp34 _ = v35 @@ -46072,7 +45887,7 @@ func LoadNS() { _ = v38 for { var tmp39 any - tmp40 := checkDerefVar(glojure_DOT_core__LT_) + tmp40 := checkDerefVar(var_glojure_DOT_core__LT_) tmp41 := lang.Apply(tmp40, []any{v38, v37}) if lang.IsTruthy(tmp41) { var tmp42 any @@ -46101,7 +45916,7 @@ func LoadNS() { panic("unimplemented: new with non-constant class type") } _ = tmp51 - tmp52 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) + tmp52 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) var tmp53 any { // let // let binding "or__0__auto__" @@ -46129,7 +45944,7 @@ func LoadNS() { var tmp49 any = v35 var tmp50 any = v36 var tmp51 any = v37 - tmp53 := checkDerefVar(glojure_DOT_core_unchecked_inc) + tmp53 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) tmp54 := lang.Apply(tmp53, []any{v38}) var tmp52 any = tmp54 v35 = tmp49 @@ -46143,7 +45958,7 @@ func LoadNS() { var tmp43 any { // let // let binding "temp__0__auto__" - tmp44 := checkDerefVar(glojure_DOT_core_seq) + tmp44 := checkDerefVar(var_glojure_DOT_core_seq) tmp45 := lang.Apply(tmp44, []any{v35}) var v46 any = tmp45 _ = v46 @@ -46155,26 +45970,26 @@ func LoadNS() { var v49 any = v46 _ = v49 var tmp50 any - tmp51 := checkDerefVar(glojure_DOT_core_chunked_seq_QMARK_) + tmp51 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) tmp52 := lang.Apply(tmp51, []any{v49}) if lang.IsTruthy(tmp52) { var tmp53 any { // let // let binding "c__0__auto__" - tmp54 := checkDerefVar(glojure_DOT_core_chunk_first) + tmp54 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) tmp55 := lang.Apply(tmp54, []any{v49}) var v56 any = tmp55 _ = v56 - tmp58 := checkDerefVar(glojure_DOT_core_chunk_rest) + tmp58 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) tmp59 := lang.Apply(tmp58, []any{v49}) var tmp57 any = tmp59 var tmp60 any = v56 - tmp62 := checkDerefVar(glojure_DOT_core_int) - tmp63 := checkDerefVar(glojure_DOT_core_count) + tmp62 := checkDerefVar(var_glojure_DOT_core_int) + tmp63 := checkDerefVar(var_glojure_DOT_core_count) tmp64 := lang.Apply(tmp63, []any{v56}) tmp65 := lang.Apply(tmp62, []any{tmp64}) var tmp61 any = tmp65 - tmp67 := checkDerefVar(glojure_DOT_core_int) + tmp67 := checkDerefVar(var_glojure_DOT_core_int) tmp68 := lang.Apply(tmp67, []any{int64(0)}) var tmp66 any = tmp68 v35 = tmp57 @@ -46188,7 +46003,7 @@ func LoadNS() { var tmp54 any { // let // let binding "sym" - tmp55 := checkDerefVar(glojure_DOT_core_first) + tmp55 := checkDerefVar(var_glojure_DOT_core_first) tmp56 := lang.Apply(tmp55, []any{v49}) var v57 any = tmp56 _ = v57 @@ -46208,7 +46023,7 @@ func LoadNS() { panic("unimplemented: new with non-constant class type") } _ = tmp63 - tmp64 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) + tmp64 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) var tmp65 any { // let // let binding "or__0__auto__" @@ -46233,7 +46048,7 @@ func LoadNS() { tmp58 = tmp60 } _ = tmp58 - tmp62 := checkDerefVar(glojure_DOT_core_next) + tmp62 := checkDerefVar(var_glojure_DOT_core_next) tmp63 := lang.Apply(tmp62, []any{v49}) var tmp61 any = tmp63 var tmp64 any = nil @@ -46265,7 +46080,7 @@ func LoadNS() { return tmp5 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -46273,31 +46088,29 @@ func LoadNS() { } // refer-glojure { - tmp0 := lang.NewSymbol("refer-glojure").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("filters"))), lang.NewKeyword("doc"), "Same as (refer 'glojure.core )", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5800), lang.NewKeyword("end-line"), int(5800))).(*lang.Symbol) + tmp0 := sym_refer_DASH_glojure.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_filters)), kw_doc, "Same as (refer 'glojure.core )", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(11), kw_line, int(5800), kw_end_DASH_line, int(5800))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 var v5 any = lang.NewList(args[2:]...) _ = v5 - tmp6 := checkDerefVar(glojure_DOT_core_seq) - tmp7 := checkDerefVar(glojure_DOT_core_concat) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("glojure.core/refer")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := checkDerefVar(glojure_DOT_core_seq) - tmp12 := checkDerefVar(glojure_DOT_core_concat) - tmp13 := checkDerefVar(glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("quote")}) - tmp15 := checkDerefVar(glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("glojure.core")}) + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_refer}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_quote}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) tmp18 := lang.Apply(tmp11, []any{tmp17}) tmp19 := lang.Apply(tmp10, []any{tmp18}) @@ -46306,7 +46119,7 @@ func LoadNS() { return tmp21 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -46314,16 +46127,14 @@ func LoadNS() { } // release-pending-sends { - tmp0 := lang.NewSymbol("release-pending-sends").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Normally, actions sent directly or indirectly during another action\n are held until the action completes (changes the agent's\n state). This function can be used to dispatch any pending sent\n actions immediately. This has no impact on actions sent during a\n transaction, which are still held until commit. If no action is\n occurring, does nothing. Returns the number of actions dispatched.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2131), lang.NewKeyword("end-line"), int(2131))).(*lang.Symbol) + tmp0 := sym_release_DASH_pending_DASH_sends.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Normally, actions sent directly or indirectly during another action\n are held until the action completes (changes the agent's\n state). This function can be used to dispatch any pending sent\n actions immediately. This has no impact on actions sent during a\n transaction, which are still held until commit. If no action is\n occurring, does nothing. Returns the number of actions dispatched.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(27), kw_column, int(7), kw_line, int(2131), kw_end_DASH_line, int(2131))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) tmp3 := lang.Apply(nil, nil) return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -46335,27 +46146,25 @@ func LoadNS() { { // function rem__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_seq) - tmp6 := checkDerefVar(glojure_DOT_core_concat) - tmp7 := checkDerefVar(glojure_DOT_core_list) - tmp8 := lang.Apply(tmp7, []any{lang.NewSymbol(".")}) - tmp9 := checkDerefVar(glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp11 := checkDerefVar(glojure_DOT_core_list) - tmp12 := checkDerefVar(glojure_DOT_core_seq) - tmp13 := checkDerefVar(glojure_DOT_core_concat) - tmp14 := checkDerefVar(glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("glojure.core/Remainder")}) - tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Remainder}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) - tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) tmp19 := lang.Apply(tmp18, []any{v4}) tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) tmp21 := lang.Apply(tmp12, []any{tmp20}) @@ -46367,12 +46176,10 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("rem").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"), lang.NewSymbol("div"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "remainder of dividing numerator by denominator.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1274), lang.NewKeyword("end-line"), int(1274))).(*lang.Symbol) + tmp0 := sym_rem.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_num, sym_div)), kw_inline, tmp1, kw_doc, "remainder of dividing numerator by denominator.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(1274), kw_end_DASH_line, int(1274))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -46384,7 +46191,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -46392,15 +46199,15 @@ func LoadNS() { } // remove { - tmp0 := lang.NewSymbol("remove").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred")), lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the items in coll for which\n (pred item) returns logical false. pred must be free of side-effects.\n Returns a transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2818), lang.NewKeyword("end-line"), int(2818))).(*lang.Symbol) + tmp0 := sym_remove.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred), lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns a lazy sequence of the items in coll for which\n (pred item) returns logical false. pred must be free of side-effects.\n Returns a transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(2818), kw_end_DASH_line, int(2818))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_filter) - tmp5 := checkDerefVar(glojure_DOT_core_complement) + tmp4 := checkDerefVar(var_glojure_DOT_core_filter) + tmp5 := checkDerefVar(var_glojure_DOT_core_complement) tmp6 := lang.Apply(tmp5, []any{v3}) tmp7 := lang.Apply(tmp4, []any{tmp6}) return tmp7 @@ -46409,16 +46216,17 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_filter) - tmp6 := checkDerefVar(glojure_DOT_core_complement) + tmp5 := checkDerefVar(var_glojure_DOT_core_filter) + tmp6 := checkDerefVar(var_glojure_DOT_core_complement) tmp7 := lang.Apply(tmp6, []any{v3}) tmp8 := lang.Apply(tmp5, []any{tmp7, v4}) return tmp8 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -46426,12 +46234,10 @@ func LoadNS() { } // remove-all-methods { - tmp0 := lang.NewSymbol("remove-all-methods").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"))), lang.NewKeyword("doc"), "Removes all of the methods of multimethod.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1787), lang.NewKeyword("end-line"), int(1787))).(*lang.Symbol) + tmp0 := sym_remove_DASH_all_DASH_methods.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_multifn)), kw_doc, "Removes all of the methods of multimethod.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(24), kw_column, int(7), kw_line, int(1787), kw_end_DASH_line, int(1787))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4, ok := lang.FieldOrMethod(v3, "reset") @@ -46447,7 +46253,7 @@ func LoadNS() { } return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -46455,12 +46261,10 @@ func LoadNS() { } // remove-method { - tmp0 := lang.NewSymbol("remove-method").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("multifn"), lang.NewSymbol("dispatch-val"))), lang.NewKeyword("doc"), "Removes the method of multimethod associated with dispatch-value.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1794), lang.NewKeyword("end-line"), int(1794))).(*lang.Symbol) + tmp0 := sym_remove_DASH_method.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_multifn, sym_dispatch_DASH_val)), kw_doc, "Removes the method of multimethod associated with dispatch-value.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(1794), kw_end_DASH_line, int(1794))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -46472,7 +46276,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v4}) return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -46480,18 +46284,16 @@ func LoadNS() { } // remove-ns { - tmp0 := lang.NewSymbol("remove-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Removes the namespace named by the symbol. Use with caution.\n Cannot be used to remove the glojure namespace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4139), lang.NewKeyword("end-line"), int(4139))).(*lang.Symbol) + tmp0 := sym_remove_DASH_ns.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_sym)), kw_doc, "Removes the namespace named by the symbol. Use with caution.\n Cannot be used to remove the glojure namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(4139), kw_end_DASH_line, int(4139))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4 := lang.Apply(lang.RemoveNamespace, []any{v3}) return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -46499,22 +46301,20 @@ func LoadNS() { } // remove-tap { - tmp0 := lang.NewSymbol("remove-tap").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Remove f from the tap set.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7883), lang.NewKeyword("end-line"), int(7883))).(*lang.Symbol) + tmp0 := sym_remove_DASH_tap.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f)), kw_doc, "Remove f from the tap set.", kw_file, "glojure/core.glj", kw_added, "1.10", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(7883), kw_end_DASH_line, int(7883))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_swap_BANG_) - tmp5 := checkDerefVar(glojure_DOT_core_tapset) - tmp6 := checkDerefVar(glojure_DOT_core_disj) + tmp4 := checkDerefVar(var_glojure_DOT_core_swap_BANG_) + tmp5 := checkDerefVar(var_glojure_DOT_core_tapset) + tmp6 := checkDerefVar(var_glojure_DOT_core_disj) tmp7 := lang.Apply(tmp4, []any{tmp5, tmp6, v3}) _ = tmp7 return nil }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -46522,12 +46322,10 @@ func LoadNS() { } // remove-watch { - tmp0 := lang.NewSymbol("remove-watch").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("reference"), lang.NewSymbol("key"))), lang.NewKeyword("doc"), "Removes a watch (set by add-watch) from a reference", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2160), lang.NewKeyword("end-line"), int(2160))).(*lang.Symbol) + tmp0 := sym_remove_DASH_watch.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_reference, sym_key)), kw_doc, "Removes a watch (set by add-watch) from a reference", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(2160), kw_end_DASH_line, int(2160))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -46539,7 +46337,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v4}) return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -46547,7 +46345,7 @@ func LoadNS() { } // repeat { - tmp0 := lang.NewSymbol("repeat").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns a lazy (infinite!, or length n if supplied) sequence of xs.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2997), lang.NewKeyword("end-line"), int(2997))).(*lang.Symbol) + tmp0 := sym_repeat.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_n, sym_x)), kw_doc, "Returns a lazy (infinite!, or length n if supplied) sequence of xs.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(2997), kw_end_DASH_line, int(2997))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -46564,10 +46362,11 @@ func LoadNS() { tmp5 := lang.Apply(lang.NewRepeatN, []any{v3, v4}) return tmp5 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -46575,7 +46374,7 @@ func LoadNS() { } // repeatedly { - tmp0 := lang.NewSymbol("repeatedly").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("f"))), lang.NewKeyword("doc"), "Takes a function of no args, presumably with side effects, and\n returns an infinite (or length n if supplied) lazy sequence of calls\n to it", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5167), lang.NewKeyword("end-line"), int(5167))).(*lang.Symbol) + tmp0 := sym_repeatedly.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_n, sym_f)), kw_doc, "Takes a function of no args, presumably with side effects, and\n returns an infinite (or length n if supplied) lazy sequence of calls\n to it", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(5167), kw_end_DASH_line, int(5167))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -46584,12 +46383,10 @@ func LoadNS() { _ = v3 var tmp4 lang.FnFunc tmp4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - tmp5 := checkDerefVar(glojure_DOT_core_cons) + checkArity(args, 0) + tmp5 := checkDerefVar(var_glojure_DOT_core_cons) tmp6 := lang.Apply(v3, nil) - tmp7 := checkDerefVar(glojure_DOT_core_repeatedly) + tmp7 := checkDerefVar(var_glojure_DOT_core_repeatedly) tmp8 := lang.Apply(tmp7, []any{v3}) tmp9 := lang.Apply(tmp5, []any{tmp6, tmp8}) return tmp9 @@ -46601,16 +46398,17 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_take) - tmp6 := checkDerefVar(glojure_DOT_core_repeatedly) + tmp5 := checkDerefVar(var_glojure_DOT_core_take) + tmp6 := checkDerefVar(var_glojure_DOT_core_repeatedly) tmp7 := lang.Apply(tmp6, []any{v4}) tmp8 := lang.Apply(tmp5, []any{v3, tmp7}) return tmp8 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -46618,25 +46416,23 @@ func LoadNS() { } // replace { - tmp0 := lang.NewSymbol("replace").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("smap")), lang.NewVector(lang.NewSymbol("smap"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Given a map of replacement pairs and a vector/collection, returns a\n vector/seq with any elements = a key in smap replaced with the\n corresponding val in smap. Returns a transducer when no collection\n is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5082), lang.NewKeyword("end-line"), int(5082))).(*lang.Symbol) + tmp0 := sym_replace.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_smap), lang.NewVector(sym_smap, sym_coll)), kw_doc, "Given a map of replacement pairs and a vector/collection, returns a\n vector/seq with any elements = a key in smap replaced with the\n corresponding val in smap. Returns a transducer when no collection\n is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(5082), kw_end_DASH_line, int(5082))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_map) + tmp4 := checkDerefVar(var_glojure_DOT_core_map) var tmp5 lang.FnFunc tmp5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v6 := args[0] _ = v6 var tmp7 any { // let // let binding "temp__0__auto__" - tmp8 := checkDerefVar(glojure_DOT_core_find) + tmp8 := checkDerefVar(var_glojure_DOT_core_find) tmp9 := lang.Apply(tmp8, []any{v3, v6}) var v10 any = tmp9 _ = v10 @@ -46647,7 +46443,7 @@ func LoadNS() { // let binding "e" var v13 any = v10 _ = v13 - tmp14 := checkDerefVar(glojure_DOT_core_val) + tmp14 := checkDerefVar(var_glojure_DOT_core_val) tmp15 := lang.Apply(tmp14, []any{v13}) tmp12 = tmp15 } // end let @@ -46659,7 +46455,7 @@ func LoadNS() { } // end let return tmp7 }) - tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5090), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5090), lang.NewKeyword("end-column"), int(47)) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5090), kw_column, int(11), kw_end_DASH_line, int(5090), kw_end_DASH_column, int(47)) tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) if err != nil { panic(err) @@ -46672,15 +46468,13 @@ func LoadNS() { v4 := args[1] _ = v4 var tmp5 any - tmp6 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp6 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) tmp7 := lang.Apply(tmp6, []any{v4}) if lang.IsTruthy(tmp7) { - tmp8 := checkDerefVar(glojure_DOT_core_reduce1) + tmp8 := checkDerefVar(var_glojure_DOT_core_reduce1) var tmp9 lang.FnFunc tmp9 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v10 := args[0] _ = v10 v11 := args[1] @@ -46688,8 +46482,8 @@ func LoadNS() { var tmp12 any { // let // let binding "temp__0__auto__" - tmp13 := checkDerefVar(glojure_DOT_core_find) - tmp14 := checkDerefVar(glojure_DOT_core_nth) + tmp13 := checkDerefVar(var_glojure_DOT_core_find) + tmp14 := checkDerefVar(var_glojure_DOT_core_nth) tmp15 := lang.Apply(tmp14, []any{v10, v11}) tmp16 := lang.Apply(tmp13, []any{v3, tmp15}) var v17 any = tmp16 @@ -46701,8 +46495,8 @@ func LoadNS() { // let binding "e" var v20 any = v17 _ = v20 - tmp21 := checkDerefVar(glojure_DOT_core_assoc) - tmp22 := checkDerefVar(glojure_DOT_core_val) + tmp21 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp22 := checkDerefVar(var_glojure_DOT_core_val) tmp23 := lang.Apply(tmp22, []any{v20}) tmp24 := lang.Apply(tmp21, []any{v10, v11, tmp23}) tmp19 = tmp24 @@ -46715,30 +46509,28 @@ func LoadNS() { } // end let return tmp12 }) - tmp10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5093), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(5096), lang.NewKeyword("end-column"), int(23)) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5093), kw_column, int(17), kw_end_DASH_line, int(5096), kw_end_DASH_column, int(23)) tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp12 := checkDerefVar(glojure_DOT_core_range) - tmp13 := checkDerefVar(glojure_DOT_core_count) + tmp12 := checkDerefVar(var_glojure_DOT_core_range) + tmp13 := checkDerefVar(var_glojure_DOT_core_count) tmp14 := lang.Apply(tmp13, []any{v4}) tmp15 := lang.Apply(tmp12, []any{tmp14}) tmp16 := lang.Apply(tmp8, []any{tmp11, v4, tmp15}) tmp5 = tmp16 } else { - tmp17 := checkDerefVar(glojure_DOT_core_map) + tmp17 := checkDerefVar(var_glojure_DOT_core_map) var tmp18 lang.FnFunc tmp18 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v19 := args[0] _ = v19 var tmp20 any { // let // let binding "temp__0__auto__" - tmp21 := checkDerefVar(glojure_DOT_core_find) + tmp21 := checkDerefVar(var_glojure_DOT_core_find) tmp22 := lang.Apply(tmp21, []any{v3, v19}) var v23 any = tmp22 _ = v23 @@ -46749,7 +46541,7 @@ func LoadNS() { // let binding "e" var v26 any = v23 _ = v26 - tmp27 := checkDerefVar(glojure_DOT_core_val) + tmp27 := checkDerefVar(var_glojure_DOT_core_val) tmp28 := lang.Apply(tmp27, []any{v26}) tmp25 = tmp28 } // end let @@ -46761,7 +46553,7 @@ func LoadNS() { } // end let return tmp20 }) - tmp19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5098), lang.NewKeyword("column"), int(13), lang.NewKeyword("end-line"), int(5098), lang.NewKeyword("end-column"), int(49)) + tmp19 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5098), kw_column, int(13), kw_end_DASH_line, int(5098), kw_end_DASH_column, int(49)) tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) if err != nil { panic(err) @@ -46771,10 +46563,11 @@ func LoadNS() { } return tmp5 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -46782,23 +46575,21 @@ func LoadNS() { } // replicate { - tmp0 := lang.NewSymbol("replicate").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("x"))), lang.NewKeyword("doc"), "DEPRECATED: Use 'repeat' instead.\n Returns a lazy seq of n xs.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("deprecated"), "1.3", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3004), lang.NewKeyword("end-line"), int(3004))).(*lang.Symbol) + tmp0 := sym_replicate.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n, sym_x)), kw_doc, "DEPRECATED: Use 'repeat' instead.\n Returns a lazy seq of n xs.", kw_file, "glojure/core.glj", kw_deprecated, "1.3", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(3004), kw_end_DASH_line, int(3004))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_take) - tmp6 := checkDerefVar(glojure_DOT_core_repeat) + tmp5 := checkDerefVar(var_glojure_DOT_core_take) + tmp6 := checkDerefVar(var_glojure_DOT_core_repeat) tmp7 := lang.Apply(tmp6, []any{v4}) tmp8 := lang.Apply(tmp5, []any{v3, tmp7}) return tmp8 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -46806,23 +46597,21 @@ func LoadNS() { } // require { - tmp0 := lang.NewSymbol("require").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Loads libs, skipping any that are already loaded. Each argument is\n either a libspec that identifies a lib, a prefix list that identifies\n multiple libs whose names share a common prefix, or a flag that modifies\n how all the identified libs are loaded. Use :require in the ns macro\n in preference to calling this directly.\n\n Libs\n\n A 'lib' is a named set of resources in classpath whose contents define a\n library of Clojure code. Lib names are symbols and each lib is associated\n with a Clojure namespace and a Java package that share its name. A lib's\n name also locates its root directory within classpath using Java's\n package name to classpath-relative path mapping. All resources in a lib\n should be contained in the directory structure under its root directory.\n All definitions a lib makes should be in its associated namespace.\n\n 'require loads a lib by loading its root resource. The root resource path\n is derived from the lib name in the following manner:\n Consider a lib named by the symbol 'x.y.z; it has the root directory\n /x/y/, and its root resource is /x/y/z.clj, or\n /x/y/z.cljc if /x/y/z.clj does not exist. The\n root resource should contain code to create the lib's\n namespace (usually by using the ns macro) and load any additional\n lib resources.\n\n Libspecs\n\n A libspec is a lib name or a vector containing a lib name followed by\n options expressed as sequential keywords and arguments.\n\n Recognized options:\n :as takes a symbol as its argument and makes that symbol an alias to the\n lib's namespace in the current namespace.\n :as-alias takes a symbol as its argument and aliases like :as, however\n the lib will not be loaded. If the lib has not been loaded, a new\n empty namespace will be created (as with create-ns).\n :refer takes a list of symbols to refer from the namespace or the :all\n keyword to bring in all public vars.\n\n Prefix Lists\n\n It's common for Clojure code to depend on several libs whose names have\n the same prefix. When specifying libs, prefix lists can be used to reduce\n repetition. A prefix list contains the shared prefix followed by libspecs\n with the shared prefix removed from the lib names. After removing the\n prefix, the names that remain must not contain any periods.\n\n Flags\n\n A flag is a keyword.\n Recognized flags: :reload, :reload-all, :verbose\n :reload forces loading of all the identified libs even if they are\n already loaded (has no effect on libspecs using :as-alias)\n :reload-all implies :reload and also forces loading of all libs that the\n identified libs directly or indirectly load via require or use\n (has no effect on libspecs using :as-alias)\n :verbose triggers printing information about each load, alias, and refer\n\n Example:\n\n The following would load the libraries glojure.zip and glojure.set\n abbreviated as 's'.\n\n (require '(glojure zip [set :as s]))", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5989), lang.NewKeyword("end-line"), int(5989))).(*lang.Symbol) + tmp0 := sym_require.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_args)), kw_doc, "Loads libs, skipping any that are already loaded. Each argument is\n either a libspec that identifies a lib, a prefix list that identifies\n multiple libs whose names share a common prefix, or a flag that modifies\n how all the identified libs are loaded. Use :require in the ns macro\n in preference to calling this directly.\n\n Libs\n\n A 'lib' is a named set of resources in classpath whose contents define a\n library of Clojure code. Lib names are symbols and each lib is associated\n with a Clojure namespace and a Java package that share its name. A lib's\n name also locates its root directory within classpath using Java's\n package name to classpath-relative path mapping. All resources in a lib\n should be contained in the directory structure under its root directory.\n All definitions a lib makes should be in its associated namespace.\n\n 'require loads a lib by loading its root resource. The root resource path\n is derived from the lib name in the following manner:\n Consider a lib named by the symbol 'x.y.z; it has the root directory\n /x/y/, and its root resource is /x/y/z.clj, or\n /x/y/z.cljc if /x/y/z.clj does not exist. The\n root resource should contain code to create the lib's\n namespace (usually by using the ns macro) and load any additional\n lib resources.\n\n Libspecs\n\n A libspec is a lib name or a vector containing a lib name followed by\n options expressed as sequential keywords and arguments.\n\n Recognized options:\n :as takes a symbol as its argument and makes that symbol an alias to the\n lib's namespace in the current namespace.\n :as-alias takes a symbol as its argument and aliases like :as, however\n the lib will not be loaded. If the lib has not been loaded, a new\n empty namespace will be created (as with create-ns).\n :refer takes a list of symbols to refer from the namespace or the :all\n keyword to bring in all public vars.\n\n Prefix Lists\n\n It's common for Clojure code to depend on several libs whose names have\n the same prefix. When specifying libs, prefix lists can be used to reduce\n repetition. A prefix list contains the shared prefix followed by libspecs\n with the shared prefix removed from the lib names. After removing the\n prefix, the names that remain must not contain any periods.\n\n Flags\n\n A flag is a keyword.\n Recognized flags: :reload, :reload-all, :verbose\n :reload forces loading of all the identified libs even if they are\n already loaded (has no effect on libspecs using :as-alias)\n :reload-all implies :reload and also forces loading of all libs that the\n identified libs directly or indirectly load via require or use\n (has no effect on libspecs using :as-alias)\n :verbose triggers printing information about each load, alias, and refer\n\n Example:\n\n The following would load the libraries glojure.zip and glojure.set\n abbreviated as 's'.\n\n (require '(glojure zip [set :as s]))", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(5989), kw_end_DASH_line, int(5989))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_apply) - tmp5 := checkDerefVar(glojure_DOT_core_load_libs) - tmp6 := lang.Apply(tmp4, []any{tmp5, lang.NewKeyword("require"), v3}) + tmp4 := checkDerefVar(var_glojure_DOT_core_apply) + tmp5 := checkDerefVar(var_glojure_DOT_core_load_DASH_libs) + tmp6 := lang.Apply(tmp4, []any{tmp5, kw_require, v3}) return tmp6 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -46830,22 +46619,20 @@ func LoadNS() { } // requiring-resolve { - tmp0 := lang.NewSymbol("requiring-resolve").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "Resolves namespace-qualified sym per 'resolve'. If initial resolve\nfails, attempts to require sym's namespace and retries.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6068), lang.NewKeyword("end-line"), int(6068))).(*lang.Symbol) + tmp0 := sym_requiring_DASH_resolve.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_sym)), kw_doc, "Resolves namespace-qualified sym per 'resolve'. If initial resolve\nfails, attempts to require sym's namespace and retries.", kw_file, "glojure/core.glj", kw_added, "1.10", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(7), kw_line, int(6068), kw_end_DASH_line, int(6068))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any - tmp5 := checkDerefVar(glojure_DOT_core_qualified_symbol_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_qualified_DASH_symbol_QMARK_) tmp6 := lang.Apply(tmp5, []any{v3}) if lang.IsTruthy(tmp6) { var tmp7 any { // let // let binding "or__0__auto__" - tmp8 := checkDerefVar(glojure_DOT_core_resolve) + tmp8 := checkDerefVar(var_glojure_DOT_core_resolve) tmp9 := lang.Apply(tmp8, []any{v3}) var v10 any = tmp9 _ = v10 @@ -46853,14 +46640,14 @@ func LoadNS() { if lang.IsTruthy(v10) { tmp11 = v10 } else { - tmp12 := checkDerefVar(glojure_DOT_core_serialized_require) - tmp13 := checkDerefVar(glojure_DOT_core_symbol) - tmp14 := checkDerefVar(glojure_DOT_core_namespace) + tmp12 := checkDerefVar(var_glojure_DOT_core_serialized_DASH_require) + tmp13 := checkDerefVar(var_glojure_DOT_core_symbol) + tmp14 := checkDerefVar(var_glojure_DOT_core_namespace) tmp15 := lang.Apply(tmp14, []any{v3}) tmp16 := lang.Apply(tmp13, []any{tmp15}) tmp17 := lang.Apply(tmp12, []any{tmp16}) _ = tmp17 - tmp18 := checkDerefVar(glojure_DOT_core_resolve) + tmp18 := checkDerefVar(var_glojure_DOT_core_resolve) tmp19 := lang.Apply(tmp18, []any{v3}) tmp11 = tmp19 } @@ -46868,14 +46655,14 @@ func LoadNS() { } // end let tmp4 = tmp7 } else { - tmp8 := checkDerefVar(glojure_DOT_core_str) + tmp8 := checkDerefVar(var_glojure_DOT_core_str) tmp9 := lang.Apply(tmp8, []any{"Not a qualified symbol: ", v3}) tmp10 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp9}) panic(tmp10) } return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -46883,12 +46670,10 @@ func LoadNS() { } // reset! { - tmp0 := lang.NewSymbol("reset!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atom"), lang.NewSymbol("newval"))), lang.NewKeyword("doc"), "Sets the value of atom to newval without regard for the\n current value. Returns newval.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2368), lang.NewKeyword("end-line"), int(2368))).(*lang.Symbol) + tmp0 := sym_reset_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_atom, sym_newval)), kw_doc, "Sets the value of atom to newval without regard for the\n current value. Returns newval.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(2368), kw_end_DASH_line, int(2368))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -46900,7 +46685,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v4}) return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -46908,12 +46693,10 @@ func LoadNS() { } // reset-meta! { - tmp0 := lang.NewSymbol("reset-meta!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("iref"), lang.NewSymbol("metadata-map"))), lang.NewKeyword("doc"), "Atomically resets the metadata for a namespace/var/ref/agent/atom", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2408), lang.NewKeyword("end-line"), int(2408))).(*lang.Symbol) + tmp0 := sym_reset_DASH_meta_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_iref, sym_metadata_DASH_map)), kw_doc, "Atomically resets the metadata for a namespace/var/ref/agent/atom", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(2408), kw_end_DASH_line, int(2408))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -46925,7 +46708,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v4}) return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -46933,12 +46716,10 @@ func LoadNS() { } // reset-vals! { - tmp0 := lang.NewSymbol("reset-vals!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atom"), lang.NewSymbol("newval"))), lang.NewKeyword("doc"), "Sets the value of atom to newval. Returns [old new], the value of the\n atom before and after the reset.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2375), lang.NewKeyword("end-line"), int(2375))).(*lang.Symbol) + tmp0 := sym_reset_DASH_vals_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_atom, sym_newval)), kw_doc, "Sets the value of atom to newval. Returns [old new], the value of the\n atom before and after the reset.", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(2375), kw_end_DASH_line, int(2375))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -46950,7 +46731,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v4}) return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -46958,15 +46739,15 @@ func LoadNS() { } // resolve { - tmp0 := lang.NewSymbol("resolve").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sym")), lang.NewVector(lang.NewSymbol("env"), lang.NewSymbol("sym"))), lang.NewKeyword("doc"), "same as (ns-resolve *ns* symbol) or (ns-resolve *ns* &env symbol)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4371), lang.NewKeyword("end-line"), int(4371))).(*lang.Symbol) + tmp0 := sym_resolve.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_sym), lang.NewVector(sym_env, sym_sym)), kw_doc, "same as (ns-resolve *ns* symbol) or (ns-resolve *ns* &env symbol)", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4371), kw_end_DASH_line, int(4371))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_ns_resolve) - tmp5 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) + tmp4 := checkDerefVar(var_glojure_DOT_core_ns_DASH_resolve) + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) return tmp6 case 2: @@ -46974,15 +46755,16 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_ns_resolve) - tmp6 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) + tmp5 := checkDerefVar(var_glojure_DOT_core_ns_DASH_resolve) + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) tmp7 := lang.Apply(tmp5, []any{tmp6, v3, v4}) return tmp7 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -46991,20 +46773,18 @@ func LoadNS() { // rest { tmp1 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() - tmp0 := lang.NewSymbol("rest").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a possibly empty seq of the items after the first. Calls seq on its\n argument.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(64), lang.NewKeyword("end-line"), int(70))).(*lang.Symbol) + tmp0 := sym_rest.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a possibly empty seq of the items after the first. Calls seq on its\n argument.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(5), kw_column, int(2), kw_line, int(64), kw_end_DASH_line, int(70))).(*lang.Symbol) var tmp3 lang.FnFunc { // function rest var v4 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v5 := args[0] _ = v5 tmp6 := lang.Apply(lang.Rest, []any{v5}) return tmp6 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(70), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(70), lang.NewKeyword("end-column"), int(77))).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(70), kw_column, int(7), kw_end_DASH_line, int(70), kw_end_DASH_column, int(77))).(lang.FnFunc) v4 = tmp3 _ = v4 } @@ -47015,14 +46795,12 @@ func LoadNS() { } // restart-agent { - tmp0 := lang.NewSymbol("restart-agent").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("new-state"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "When an agent is failed, changes the agent state to new-state and\n then un-fails the agent so that sends are allowed again. If\n a :clear-actions true option is given, any actions queued on the\n agent that were being held while it was failed will be discarded,\n otherwise those held actions will proceed. The new-state must pass\n the validator if any, or restart will throw an exception and the\n agent will remain failed with its old state and error. Watchers, if\n any, will NOT be notified of the new state. Throws an exception if\n the agent is not failed.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2175), lang.NewKeyword("end-line"), int(2175))).(*lang.Symbol) + tmp0 := sym_restart_DASH_agent.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a, sym_new_DASH_state, sym__AMP_, sym_options)), kw_doc, "When an agent is failed, changes the agent state to new-state and\n then un-fails the agent so that sends are allowed again. If\n a :clear-actions true option is given, any actions queued on the\n agent that were being held while it was failed will be discarded,\n otherwise those held actions will proceed. The new-state must pass\n the validator if any, or restart will throw an exception and the\n agent will remain failed with its old state and error. Watchers, if\n any, will NOT be notified of the new state. Throws an exception if\n the agent is not failed.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(2175), kw_end_DASH_line, int(2175))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -47032,13 +46810,13 @@ func LoadNS() { var tmp6 any { // let // let binding "opts" - tmp7 := checkDerefVar(glojure_DOT_core_apply) - tmp8 := checkDerefVar(glojure_DOT_core_hash_map) + tmp7 := checkDerefVar(var_glojure_DOT_core_apply) + tmp8 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) tmp9 := lang.Apply(tmp7, []any{tmp8, v5}) var v10 any = tmp9 _ = v10 var tmp11 any - tmp12 := lang.Apply(lang.NewKeyword("clear-actions"), []any{v10}) + tmp12 := lang.Apply(kw_clear_DASH_actions, []any{v10}) if lang.IsTruthy(tmp12) { tmp11 = true } else { @@ -47054,7 +46832,7 @@ func LoadNS() { return tmp6 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -47062,12 +46840,10 @@ func LoadNS() { } // resultset-seq { - tmp0 := lang.NewSymbol("resultset-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rs"))), lang.NewKeyword("doc"), "Creates and returns a lazy sequence of structmaps corresponding to\n the rows in the java.sql.ResultSet rs", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5681), lang.NewKeyword("end-line"), int(5681))).(*lang.Symbol) + tmp0 := sym_resultset_DASH_seq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_rs)), kw_doc, "Creates and returns a lazy sequence of structmaps corresponding to\n the rows in the java.sql.ResultSet rs", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(5681), kw_end_DASH_line, int(5681))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any @@ -47081,8 +46857,8 @@ func LoadNS() { var v7 any = tmp6 _ = v7 // let binding "idxs" - tmp8 := checkDerefVar(glojure_DOT_core_range) - tmp9 := checkDerefVar(glojure_DOT_core_inc) + tmp8 := checkDerefVar(var_glojure_DOT_core_range) + tmp9 := checkDerefVar(var_glojure_DOT_core_inc) tmp10, _ := lang.FieldOrMethod(v7, "getColumnCount") if reflect.TypeOf(tmp10).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("getColumnCount is not a function"))) @@ -47093,14 +46869,12 @@ func LoadNS() { var v14 any = tmp13 _ = v14 // let binding "keys" - tmp15 := checkDerefVar(glojure_DOT_core_map) - tmp16 := checkDerefVar(glojure_DOT_core_comp) - tmp17 := checkDerefVar(glojure_DOT_core_keyword) + tmp15 := checkDerefVar(var_glojure_DOT_core_map) + tmp16 := checkDerefVar(var_glojure_DOT_core_comp) + tmp17 := checkDerefVar(var_glojure_DOT_core_keyword) var tmp18 lang.FnFunc tmp18 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v19 := args[0] _ = v19 tmp20, ok := lang.FieldOrMethod(v19, "toLowerCase") @@ -47116,18 +46890,16 @@ func LoadNS() { } return tmp21 }) - tmp19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5688), lang.NewKeyword("column"), int(35), lang.NewKeyword("end-line"), int(5688), lang.NewKeyword("end-column"), int(62)) + tmp19 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5688), kw_column, int(35), kw_end_DASH_line, int(5688), kw_end_DASH_column, int(62)) tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) if err != nil { panic(err) } tmp21 := lang.Apply(tmp16, []any{tmp17, tmp20}) - tmp22 := checkDerefVar(glojure_DOT_core_map) + tmp22 := checkDerefVar(var_glojure_DOT_core_map) var tmp23 lang.FnFunc tmp23 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v24 := args[0] _ = v24 tmp25, _ := lang.FieldOrMethod(v7, "getColumnLabel") @@ -47137,7 +46909,7 @@ func LoadNS() { tmp26 := lang.Apply(tmp25, []any{v24}) return tmp26 }) - tmp24 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5689), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(5689), lang.NewKeyword("end-column"), int(63)) + tmp24 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5689), kw_column, int(26), kw_end_DASH_line, int(5689), kw_end_DASH_column, int(63)) tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) if err != nil { panic(err) @@ -47150,8 +46922,8 @@ func LoadNS() { var tmp29 any { // let // let binding "or__0__auto__" - tmp30 := checkDerefVar(glojure_DOT_core_apply) - tmp31 := checkDerefVar(glojure_DOT_core_distinct_QMARK_) + tmp30 := checkDerefVar(var_glojure_DOT_core_apply) + tmp31 := checkDerefVar(var_glojure_DOT_core_distinct_QMARK_) tmp32 := lang.Apply(tmp30, []any{tmp31, v28}) var v33 any = tmp32 _ = v33 @@ -47167,23 +46939,19 @@ func LoadNS() { var v30 any = tmp29 _ = v30 // let binding "row-struct" - tmp31 := checkDerefVar(glojure_DOT_core_apply) - tmp32 := checkDerefVar(glojure_DOT_core_create_struct) + tmp31 := checkDerefVar(var_glojure_DOT_core_apply) + tmp32 := checkDerefVar(var_glojure_DOT_core_create_DASH_struct) tmp33 := lang.Apply(tmp31, []any{tmp32, v28}) var v34 any = tmp33 _ = v34 // let binding "row-values" var tmp35 lang.FnFunc tmp35 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - tmp36 := checkDerefVar(glojure_DOT_core_map) + checkArity(args, 0) + tmp36 := checkDerefVar(var_glojure_DOT_core_map) var tmp37 lang.FnFunc tmp37 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v38 := args[0] _ = v38 tmp39, _ := lang.FieldOrMethod(v3, "getObject") @@ -47193,7 +46961,7 @@ func LoadNS() { tmp40 := lang.Apply(tmp39, []any{v38}) return tmp40 }) - tmp38 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5694), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(5694), lang.NewKeyword("end-column"), int(71)) + tmp38 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5694), kw_column, int(34), kw_end_DASH_line, int(5694), kw_end_DASH_column, int(71)) tmp39, err := lang.WithMeta(tmp37, tmp38.(lang.IPersistentMap)) if err != nil { panic(err) @@ -47201,7 +46969,7 @@ func LoadNS() { tmp40 := lang.Apply(tmp36, []any{tmp39, v14}) return tmp40 }) - tmp36 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5694), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(5694), lang.NewKeyword("end-column"), int(78)) + tmp36 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5694), kw_column, int(22), kw_end_DASH_line, int(5694), kw_end_DASH_column, int(78)) tmp37, err := lang.WithMeta(tmp35, tmp36.(lang.IPersistentMap)) if err != nil { panic(err) @@ -47213,9 +46981,7 @@ func LoadNS() { { // function thisfn var v40 lang.FnFunc tmp39 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var tmp41 any tmp42, _ := lang.FieldOrMethod(v3, "next") if reflect.TypeOf(tmp42).Kind() != reflect.Func { @@ -47223,16 +46989,14 @@ func LoadNS() { } tmp43 := lang.Apply(tmp42, []any{}) if lang.IsTruthy(tmp43) { - tmp44 := checkDerefVar(glojure_DOT_core_cons) - tmp45 := checkDerefVar(glojure_DOT_core_apply) - tmp46 := checkDerefVar(glojure_DOT_core_struct) + tmp44 := checkDerefVar(var_glojure_DOT_core_cons) + tmp45 := checkDerefVar(var_glojure_DOT_core_apply) + tmp46 := checkDerefVar(var_glojure_DOT_core_struct) tmp47 := lang.Apply(v38, nil) tmp48 := lang.Apply(tmp45, []any{tmp46, v34, tmp47}) var tmp49 lang.FnFunc tmp49 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) tmp50 := lang.Apply(v40, nil) return tmp50 }) @@ -47246,7 +47010,7 @@ func LoadNS() { v40 = tmp39 _ = v40 } - tmp40 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5695), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(5697), lang.NewKeyword("end-column"), int(86)) + tmp40 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5695), kw_column, int(16), kw_end_DASH_line, int(5697), kw_end_DASH_column, int(86)) tmp41, err := lang.WithMeta(tmp39, tmp40.(lang.IPersistentMap)) if err != nil { panic(err) @@ -47258,7 +47022,7 @@ func LoadNS() { } // end let return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -47266,20 +47030,18 @@ func LoadNS() { } // reverse { - tmp0 := lang.NewSymbol("reverse").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a seq of the items in coll in reverse order. Not lazy.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(940), lang.NewKeyword("end-line"), int(940))).(*lang.Symbol) + tmp0 := sym_reverse.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a seq of the items in coll in reverse order. Not lazy.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(940), kw_end_DASH_line, int(940))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_reduce1) - tmp5 := checkDerefVar(glojure_DOT_core_conj) + tmp4 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp5 := checkDerefVar(var_glojure_DOT_core_conj) tmp6 := lang.Apply(tmp4, []any{tmp5, lang.NewList(), v3}) return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -47287,19 +47049,17 @@ func LoadNS() { } // reversible? { - tmp0 := lang.NewSymbol("reversible?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements Reversible", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6257), lang.NewKeyword("end-line"), int(6257))).(*lang.Symbol) + tmp0 := sym_reversible_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns true if coll implements Reversible", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(6257), kw_end_DASH_line, int(6257))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp5 := lang.Apply(tmp4, []any{nil, v3}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -47307,29 +47067,27 @@ func LoadNS() { } // root-directory { - tmp0 := lang.NewSymbol("root-directory").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"))), lang.NewKeyword("doc"), "Returns the root resource path for a lib", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5871), lang.NewKeyword("end-line"), int(5871), lang.NewKeyword("private"), true)).(*lang.Symbol) + tmp0 := sym_root_DASH_directory.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_lib)), kw_doc, "Returns the root resource path for a lib", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(8), kw_line, int(5871), kw_end_DASH_line, int(5871), kw_private, true)).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any { // let // let binding "d" - tmp5 := checkDerefVar(glojure_DOT_core_root_resource) + tmp5 := checkDerefVar(var_glojure_DOT_core_root_DASH_resource) tmp6 := lang.Apply(tmp5, []any{v3}) var v7 any = tmp6 _ = v7 - tmp8 := checkDerefVar(glojure_DOT_core_subs) + tmp8 := checkDerefVar(var_glojure_DOT_core_subs) tmp9 := lang.Apply(strings11.LastIndex, []any{v7, "/"}) tmp10 := lang.Apply(tmp8, []any{v7, int64(0), tmp9}) tmp4 = tmp10 } // end let return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -47338,16 +47096,14 @@ func LoadNS() { // root-resource { tmp1 := reflect.TypeOf("") - tmp0 := lang.NewSymbol("root-resource").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("lib"))), lang.NewKeyword("doc"), "Returns the root directory path for a lib", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5864), lang.NewKeyword("end-line"), int(5864), lang.NewKeyword("private"), true)).(*lang.Symbol) + tmp0 := sym_root_DASH_resource.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_lib)), kw_doc, "Returns the root directory path for a lib", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(8), kw_line, int(5864), kw_end_DASH_line, int(5864), kw_private, true)).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_str) - tmp6 := checkDerefVar(glojure_DOT_core_name) + tmp5 := checkDerefVar(var_glojure_DOT_core_str) + tmp6 := checkDerefVar(var_glojure_DOT_core_name) tmp7 := lang.Apply(tmp6, []any{v4}) tmp8 := lang.Apply(strings11.ReplaceAll, []any{tmp7, "-", "_"}) tmp9 := lang.Apply(strings11.ReplaceAll, []any{tmp8, ".", "/"}) @@ -47355,7 +47111,7 @@ func LoadNS() { return tmp10 }) tmp4 := reflect.TypeOf("") - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -47363,12 +47119,10 @@ func LoadNS() { } // rseq { - tmp0 := lang.NewSymbol("rseq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("rev"))), lang.NewKeyword("doc"), "Returns, in constant time, a seq of the items in rev (which\n can be a vector or sorted-map), in reverse order. If rev is empty returns nil", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1577), lang.NewKeyword("end-line"), int(1577))).(*lang.Symbol) + tmp0 := sym_rseq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_rev)), kw_doc, "Returns, in constant time, a seq of the items in rev (which\n can be a vector or sorted-map), in reverse order. If rev is empty returns nil", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1577), kw_end_DASH_line, int(1577))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4, _ := lang.FieldOrMethod(v3, "rseq") @@ -47378,7 +47132,7 @@ func LoadNS() { tmp5 := lang.Apply(tmp4, []any{}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -47386,7 +47140,7 @@ func LoadNS() { } // rsubseq { - tmp0 := lang.NewSymbol("rsubseq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sc"), lang.NewSymbol("test"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("sc"), lang.NewSymbol("start-test"), lang.NewSymbol("start-key"), lang.NewSymbol("end-test"), lang.NewSymbol("end-key"))), lang.NewKeyword("doc"), "sc must be a sorted collection, test(s) one of <, <=, > or\n >=. Returns a reverse seq of those entries with keys ek for\n which (test (.. sc comparator (compare ek key)) 0) is true", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5150), lang.NewKeyword("end-line"), int(5150))).(*lang.Symbol) + tmp0 := sym_rsubseq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_sc, sym_test, sym_key), lang.NewVector(sym_sc, sym_start_DASH_test, sym_start_DASH_key, sym_end_DASH_test, sym_end_DASH_key)), kw_doc, "sc must be a sorted collection, test(s) one of <, <=, > or\n >=. Returns a reverse seq of those entries with keys ek for\n which (test (.. sc comparator (compare ek key)) 0) is true", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(5150), kw_end_DASH_line, int(5150))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -47400,15 +47154,15 @@ func LoadNS() { var tmp6 any { // let // let binding "include" - tmp7 := checkDerefVar(glojure_DOT_core_mk_bound_fn) + tmp7 := checkDerefVar(var_glojure_DOT_core_mk_DASH_bound_DASH_fn) tmp8 := lang.Apply(tmp7, []any{v3, v4, v5}) var v9 any = tmp8 _ = v9 var tmp10 any - tmp11 := checkDerefVar(glojure_DOT_core__LT_) - tmp12 := checkDerefVar(glojure_DOT_core__LT__EQ_) + tmp11 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp12 := checkDerefVar(var_glojure_DOT_core__LT__EQ_) tmp13 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{tmp11, tmp12})) - tmp14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5158), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5158), lang.NewKeyword("end-column"), int(17)) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5158), kw_column, int(11), kw_end_DASH_line, int(5158), kw_end_DASH_column, int(17)) tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) if err != nil { panic(err) @@ -47433,7 +47187,7 @@ func LoadNS() { var v23 any = v20 _ = v23 // let binding "e" - tmp24 := checkDerefVar(glojure_DOT_core_nth) + tmp24 := checkDerefVar(var_glojure_DOT_core_nth) tmp25 := lang.Apply(tmp24, []any{v23, int64(0), nil}) var v26 any = tmp25 _ = v26 @@ -47445,7 +47199,7 @@ func LoadNS() { if lang.IsTruthy(tmp29) { tmp28 = v27 } else { - tmp30 := checkDerefVar(glojure_DOT_core_next) + tmp30 := checkDerefVar(var_glojure_DOT_core_next) tmp31 := lang.Apply(tmp30, []any{v27}) tmp28 = tmp31 } @@ -47458,7 +47212,7 @@ func LoadNS() { } // end let tmp10 = tmp17 } else { - tmp18 := checkDerefVar(glojure_DOT_core_take_while) + tmp18 := checkDerefVar(var_glojure_DOT_core_take_DASH_while) tmp19, _ := lang.FieldOrMethod(v3, "seq") if reflect.TypeOf(tmp19).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("seq is not a function"))) @@ -47499,24 +47253,24 @@ func LoadNS() { var v14 any = v11 _ = v14 // let binding "e" - tmp15 := checkDerefVar(glojure_DOT_core_nth) + tmp15 := checkDerefVar(var_glojure_DOT_core_nth) tmp16 := lang.Apply(tmp15, []any{v14, int64(0), nil}) var v17 any = tmp16 _ = v17 // let binding "s" var v18 any = v14 _ = v18 - tmp19 := checkDerefVar(glojure_DOT_core_take_while) - tmp20 := checkDerefVar(glojure_DOT_core_mk_bound_fn) + tmp19 := checkDerefVar(var_glojure_DOT_core_take_DASH_while) + tmp20 := checkDerefVar(var_glojure_DOT_core_mk_DASH_bound_DASH_fn) tmp21 := lang.Apply(tmp20, []any{v3, v4, v5}) var tmp22 any - tmp23 := checkDerefVar(glojure_DOT_core_mk_bound_fn) + tmp23 := checkDerefVar(var_glojure_DOT_core_mk_DASH_bound_DASH_fn) tmp24 := lang.Apply(tmp23, []any{v3, v6, v7}) tmp25 := lang.Apply(tmp24, []any{v17}) if lang.IsTruthy(tmp25) { tmp22 = v18 } else { - tmp26 := checkDerefVar(glojure_DOT_core_next) + tmp26 := checkDerefVar(var_glojure_DOT_core_next) tmp27 := lang.Apply(tmp26, []any{v18}) tmp22 = tmp27 } @@ -47530,10 +47284,11 @@ func LoadNS() { } // end let return tmp8 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -47541,22 +47296,18 @@ func LoadNS() { } // run! { - tmp0 := lang.NewSymbol("run!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("proc"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Runs the supplied procedure (via reduce), for purposes of side\n effects, on successive items in the collection. Returns nil", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7708), lang.NewKeyword("end-line"), int(7708))).(*lang.Symbol) + tmp0 := sym_run_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_proc, sym_coll)), kw_doc, "Runs the supplied procedure (via reduce), for purposes of side\n effects, on successive items in the collection. Returns nil", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(7708), kw_end_DASH_line, int(7708))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_reduce) + tmp5 := checkDerefVar(var_glojure_DOT_core_reduce) var tmp6 lang.FnFunc tmp6 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v7 := args[0] _ = v7 v8 := args[1] @@ -47564,7 +47315,7 @@ func LoadNS() { tmp9 := lang.Apply(v3, []any{v8}) return tmp9 }) - tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7713), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(7713), lang.NewKeyword("end-column"), int(20)) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7713), kw_column, int(11), kw_end_DASH_line, int(7713), kw_end_DASH_column, int(20)) tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) if err != nil { panic(err) @@ -47573,7 +47324,7 @@ func LoadNS() { _ = tmp9 return nil }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -47581,23 +47332,21 @@ func LoadNS() { } // second { - tmp0 := lang.NewSymbol("second").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Same as (first (next x))", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(91), lang.NewKeyword("end-line"), int(95))).(*lang.Symbol) + tmp0 := sym_second.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Same as (first (next x))", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(2), kw_line, int(91), kw_end_DASH_line, int(95))).(*lang.Symbol) var tmp2 lang.FnFunc { // function second var v3 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_first) - tmp6 := checkDerefVar(glojure_DOT_core_next) + tmp5 := checkDerefVar(var_glojure_DOT_core_first) + tmp6 := checkDerefVar(var_glojure_DOT_core_next) tmp7 := lang.Apply(tmp6, []any{v4}) tmp8 := lang.Apply(tmp5, []any{tmp7}) return tmp8 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(95), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(95), lang.NewKeyword("end-column"), int(49))).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(95), kw_column, int(9), kw_end_DASH_line, int(95), kw_end_DASH_column, int(49))).(lang.FnFunc) v3 = tmp2 _ = v3 } @@ -47608,12 +47357,10 @@ func LoadNS() { } // select-keys { - tmp0 := lang.NewSymbol("select-keys").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"), lang.NewSymbol("keyseq"))), lang.NewKeyword("doc"), "Returns a map containing only those entries in map whose key is in keys", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1536), lang.NewKeyword("end-line"), int(1536))).(*lang.Symbol) + tmp0 := sym_select_DASH_keys.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_map, sym_keyseq)), kw_doc, "Returns a map containing only those entries in map whose key is in keys", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(1536), kw_end_DASH_line, int(1536))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -47622,7 +47369,7 @@ func LoadNS() { { // let // let binding "ret" tmp6 := lang.NewMap() - tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(1541), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(1541), lang.NewKeyword("end-column"), int(17)) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(1541), kw_column, int(16), kw_end_DASH_line, int(1541), kw_end_DASH_column, int(17)) tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) if err != nil { panic(err) @@ -47630,7 +47377,7 @@ func LoadNS() { var v9 any = tmp8 _ = v9 // let binding "keys" - tmp10 := checkDerefVar(glojure_DOT_core_seq) + tmp10 := checkDerefVar(var_glojure_DOT_core_seq) tmp11 := lang.Apply(tmp10, []any{v4}) var v12 any = tmp11 _ = v12 @@ -47640,7 +47387,7 @@ func LoadNS() { var tmp14 any { // let // let binding "entry" - tmp15 := checkDerefVar(glojure_DOT_core_first) + tmp15 := checkDerefVar(var_glojure_DOT_core_first) tmp16 := lang.Apply(tmp15, []any{v12}) tmp17, _ := lang.FieldOrMethod(runtime7.RT, "Find") if reflect.TypeOf(tmp17).Kind() != reflect.Func { @@ -47651,14 +47398,14 @@ func LoadNS() { _ = v19 var tmp21 any if lang.IsTruthy(v19) { - tmp22 := checkDerefVar(glojure_DOT_core_conj) + tmp22 := checkDerefVar(var_glojure_DOT_core_conj) tmp23 := lang.Apply(tmp22, []any{v9, v19}) tmp21 = tmp23 } else { tmp21 = v9 } var tmp20 any = tmp21 - tmp25 := checkDerefVar(glojure_DOT_core_next) + tmp25 := checkDerefVar(var_glojure_DOT_core_next) tmp26 := lang.Apply(tmp25, []any{v12}) var tmp24 any = tmp26 v9 = tmp20 @@ -47667,8 +47414,8 @@ func LoadNS() { } // end let tmp13 = tmp14 } else { - tmp15 := checkDerefVar(glojure_DOT_core_with_meta) - tmp16 := checkDerefVar(glojure_DOT_core_meta) + tmp15 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp16 := checkDerefVar(var_glojure_DOT_core_meta) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := lang.Apply(tmp15, []any{v9, tmp17}) tmp13 = tmp18 @@ -47679,7 +47426,7 @@ func LoadNS() { } // end let return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -47687,27 +47434,25 @@ func LoadNS() { } // send { - tmp0 := lang.NewSymbol("send").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Dispatch an action to an agent. Returns the agent immediately.\n Subsequently, in a thread from a thread pool, the state of the agent\n will be set to the value of:\n\n (apply action-fn state-of-agent args)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2109), lang.NewKeyword("end-line"), int(2109))).(*lang.Symbol) + tmp0 := sym_send.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a, sym_f, sym__AMP_, sym_args)), kw_doc, "Dispatch an action to an agent. Returns the agent immediately.\n Subsequently, in a thread from a thread pool, the state of the agent\n will be set to the value of:\n\n (apply action-fn state-of-agent args)", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(2109), kw_end_DASH_line, int(2109))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 var v5 any = lang.NewList(args[2:]...) _ = v5 - tmp6 := checkDerefVar(glojure_DOT_core_apply) - tmp7 := checkDerefVar(glojure_DOT_core_send_via) + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_send_DASH_via) tmp8 := lang.Apply(tmp6, []any{tmp7, nil, v3, v4, v5}) return tmp8 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -47715,27 +47460,25 @@ func LoadNS() { } // send-off { - tmp0 := lang.NewSymbol("send-off").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Dispatch a potentially blocking action to an agent. Returns the\n agent immediately. Subsequently, in a separate thread, the state of\n the agent will be set to the value of:\n\n (apply action-fn state-of-agent args)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2120), lang.NewKeyword("end-line"), int(2120))).(*lang.Symbol) + tmp0 := sym_send_DASH_off.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a, sym_f, sym__AMP_, sym_args)), kw_doc, "Dispatch a potentially blocking action to an agent. Returns the\n agent immediately. Subsequently, in a separate thread, the state of\n the agent will be set to the value of:\n\n (apply action-fn state-of-agent args)", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(2120), kw_end_DASH_line, int(2120))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 var v5 any = lang.NewList(args[2:]...) _ = v5 - tmp6 := checkDerefVar(glojure_DOT_core_apply) - tmp7 := checkDerefVar(glojure_DOT_core_send_via) + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_send_DASH_via) tmp8 := lang.Apply(tmp6, []any{tmp7, nil, v3, v4, v5}) return tmp8 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -47743,14 +47486,12 @@ func LoadNS() { } // send-via { - tmp0 := lang.NewSymbol("send-via").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("executor"), lang.NewSymbol("a"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Dispatch an action to an agent. Returns the agent immediately.\n Subsequently, in a thread supplied by executor, the state of the agent\n will be set to the value of:\n\n (apply action-fn state-of-agent args)", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2099), lang.NewKeyword("end-line"), int(2099))).(*lang.Symbol) + tmp0 := sym_send_DASH_via.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_executor, sym_a, sym_f, sym__AMP_, sym_args)), kw_doc, "Dispatch an action to an agent. Returns the agent immediately.\n Subsequently, in a thread supplied by executor, the state of the agent\n will be set to the value of:\n\n (apply action-fn state-of-agent args)", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(2099), kw_end_DASH_line, int(2099))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -47761,20 +47502,20 @@ func LoadNS() { _ = v6 var tmp7 any { // let - tmp8 := checkDerefVar(glojure_DOT_core_push_thread_bindings) - tmp9 := checkDerefVar(glojure_DOT_core_hash_map) - tmp10 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("*agent*")) + tmp8 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp9 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp10 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_agent_STAR_) tmp11 := lang.Apply(tmp9, []any{tmp10, v4}) tmp12 := lang.Apply(tmp8, []any{tmp11}) _ = tmp12 var tmp13 any func() { defer func() { - tmp14 := checkDerefVar(glojure_DOT_core_pop_thread_bindings) + tmp14 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) tmp15 := lang.Apply(tmp14, nil) _ = tmp15 }() - tmp16 := checkDerefVar(glojure_DOT_core_binding_conveyor_fn) + tmp16 := checkDerefVar(var_glojure_DOT_core_binding_DASH_conveyor_DASH_fn) tmp17 := lang.Apply(tmp16, []any{v5}) tmp13 = tmp17 }() @@ -47788,7 +47529,7 @@ func LoadNS() { return tmp9 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -47797,20 +47538,18 @@ func LoadNS() { // seq { tmp1 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() - tmp0 := lang.NewSymbol("seq").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a seq on the collection. If the collection is\n empty, returns nil. (seq nil) returns nil. seq also works on\n Strings, native Java arrays (of reference types) and any objects\n that implement Iterable. Note that seqs cache values, thus seq\n should not be used on any Iterable whose iterator repeatedly\n returns the same mutable object.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(4), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(126), lang.NewKeyword("end-line"), int(136))).(*lang.Symbol) + tmp0 := sym_seq.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a seq on the collection. If the collection is\n empty, returns nil. (seq nil) returns nil. seq also works on\n Strings, native Java arrays (of reference types) and any objects\n that implement Iterable. Note that seqs cache values, thus seq\n should not be used on any Iterable whose iterator repeatedly\n returns the same mutable object.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(4), kw_column, int(2), kw_line, int(126), kw_end_DASH_line, int(136))).(*lang.Symbol) var tmp3 lang.FnFunc { // function seq var v4 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v5 := args[0] _ = v5 tmp6 := lang.Apply(lang.Seq, []any{v5}) return tmp6 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(136), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(136), lang.NewKeyword("end-column"), int(126))).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(136), kw_column, int(6), kw_end_DASH_line, int(136), kw_end_DASH_column, int(126))).(lang.FnFunc) v4 = tmp3 _ = v4 } @@ -47821,28 +47560,26 @@ func LoadNS() { } // seq-to-map-for-destructuring { - tmp0 := lang.NewSymbol("seq-to-map-for-destructuring").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Builds a map from a seq as described in\n https://glojure.org/reference/special_forms#keyword-arguments", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(34), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4390), lang.NewKeyword("end-line"), int(4390))).(*lang.Symbol) + tmp0 := sym_seq_DASH_to_DASH_map_DASH_for_DASH_destructuring.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_doc, "Builds a map from a seq as described in\n https://glojure.org/reference/special_forms#keyword-arguments", kw_file, "glojure/core.glj", kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(34), kw_column, int(7), kw_line, int(4390), kw_end_DASH_line, int(4390))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any - tmp5 := checkDerefVar(glojure_DOT_core_next) + tmp5 := checkDerefVar(var_glojure_DOT_core_next) tmp6 := lang.Apply(tmp5, []any{v3}) if lang.IsTruthy(tmp6) { - tmp7 := checkDerefVar(glojure_DOT_core_to_array) + tmp7 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) tmp8 := lang.Apply(tmp7, []any{v3}) tmp9 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{tmp8}) tmp4 = tmp9 } else { var tmp10 any - tmp11 := checkDerefVar(glojure_DOT_core_seq) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := lang.Apply(tmp11, []any{v3}) if lang.IsTruthy(tmp12) { - tmp13 := checkDerefVar(glojure_DOT_core_first) + tmp13 := checkDerefVar(var_glojure_DOT_core_first) tmp14 := lang.Apply(tmp13, []any{v3}) tmp10 = tmp14 } else { @@ -47851,7 +47588,7 @@ func LoadNS() { } return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -47859,22 +47596,20 @@ func LoadNS() { } // seq? { - tmp0 := lang.NewSymbol("seq?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x implements ISeq", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(146), lang.NewKeyword("end-line"), int(150))).(*lang.Symbol) + tmp0 := sym_seq_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x implements ISeq", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(5), kw_column, int(2), kw_line, int(146), kw_end_DASH_line, int(150))).(*lang.Symbol) var tmp2 lang.FnFunc { // function seq? var v3 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp6 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() tmp7 := lang.Apply(tmp5, []any{tmp6, v4}) return tmp7 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(150), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(150), lang.NewKeyword("end-column"), int(87))).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(150), kw_column, int(7), kw_end_DASH_line, int(150), kw_end_DASH_column, int(87))).(lang.FnFunc) v3 = tmp2 _ = v3 } @@ -47885,18 +47620,16 @@ func LoadNS() { } // seqable? { - tmp0 := lang.NewSymbol("seqable?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if the seq function is supported for x", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6204), lang.NewKeyword("end-line"), int(6204))).(*lang.Symbol) + tmp0 := sym_seqable_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if the seq function is supported for x", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(6204), kw_end_DASH_line, int(6204))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4 := lang.Apply(nil, []any{v3}) return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -47904,14 +47637,14 @@ func LoadNS() { } // seque { - tmp0 := lang.NewSymbol("seque").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s")), lang.NewVector(lang.NewSymbol("n-or-q"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Creates a queued seq on another (presumably lazy) seq s. The queued\n seq will produce a concrete seq in the background, and can get up to\n n items ahead of the consumer. n-or-q can be an integer n buffer\n size, or an instance of java.util.concurrent BlockingQueue. Note\n that reading from a seque can block if the reader gets ahead of the\n producer.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5419), lang.NewKeyword("end-line"), int(5419))).(*lang.Symbol) + tmp0 := sym_seque.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s), lang.NewVector(sym_n_DASH_or_DASH_q, sym_s)), kw_doc, "Creates a queued seq on another (presumably lazy) seq s. The queued\n seq will produce a concrete seq in the background, and can get up to\n n items ahead of the consumer. n-or-q can be an integer n buffer\n size, or an instance of java.util.concurrent BlockingQueue. Note\n that reading from a seque can block if the reader gets ahead of the\n producer.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(5419), kw_end_DASH_line, int(5419))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seque) + tmp4 := checkDerefVar(var_glojure_DOT_core_seque) tmp5 := lang.Apply(tmp4, []any{int64(100), v3}) return tmp5 case 2: @@ -47923,12 +47656,12 @@ func LoadNS() { { // let // let binding "q" var tmp6 any - tmp7 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp7 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp8 := lang.Apply(tmp7, []any{nil, v3}) if lang.IsTruthy(tmp8) { tmp6 = v3 } else { - tmp9 := checkDerefVar(glojure_DOT_core_int) + tmp9 := checkDerefVar(var_glojure_DOT_core_int) tmp10 := lang.Apply(tmp9, []any{v3}) tmp11 := lang.Apply(nil, []any{tmp10}) tmp6 = tmp11 @@ -47952,12 +47685,10 @@ func LoadNS() { var v17 any = tmp16 _ = v17 // let binding "agt" - tmp18 := checkDerefVar(glojure_DOT_core_agent) + tmp18 := checkDerefVar(var_glojure_DOT_core_agent) var tmp19 lang.FnFunc tmp19 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) return v4 }) tmp20 := lang.Apply(lang.NewLazySeq, []any{tmp19}) @@ -47967,9 +47698,7 @@ func LoadNS() { // let binding "log-error" var tmp23 lang.FnFunc tmp23 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v24 := args[0] _ = v24 v25 := args[1] @@ -47987,7 +47716,7 @@ func LoadNS() { } return tmp26 }) - tmp24 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5435), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(5438), lang.NewKeyword("end-column"), int(26)) + tmp24 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5435), kw_column, int(20), kw_end_DASH_line, int(5438), kw_end_DASH_column, int(26)) tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) if err != nil { panic(err) @@ -47997,15 +47726,13 @@ func LoadNS() { // let binding "fill" var tmp27 lang.FnFunc tmp27 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v28 := args[0] _ = v28 var tmp29 any if lang.IsTruthy(v28) { var tmp30 any - tmp31 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp31 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp32 := lang.Apply(tmp31, []any{nil, v28}) if lang.IsTruthy(tmp32) { tmp33 := lang.Apply(v26, []any{v12, v28}) @@ -48028,7 +47755,7 @@ func LoadNS() { var tmp35 any { // let // let binding "G__89" - tmp36 := checkDerefVar(glojure_DOT_core_seq) + tmp36 := checkDerefVar(var_glojure_DOT_core_seq) tmp37 := lang.Apply(tmp36, []any{v28}) var v38 any = tmp37 _ = v38 @@ -48036,17 +47763,17 @@ func LoadNS() { var v39 any = v38 _ = v39 // let binding "seq__91" - tmp40 := checkDerefVar(glojure_DOT_core_seq) + tmp40 := checkDerefVar(var_glojure_DOT_core_seq) tmp41 := lang.Apply(tmp40, []any{v39}) var v42 any = tmp41 _ = v42 // let binding "first__92" - tmp43 := checkDerefVar(glojure_DOT_core_first) + tmp43 := checkDerefVar(var_glojure_DOT_core_first) tmp44 := lang.Apply(tmp43, []any{v42}) var v45 any = tmp44 _ = v45 // let binding "seq__91" - tmp46 := checkDerefVar(glojure_DOT_core_next) + tmp46 := checkDerefVar(var_glojure_DOT_core_next) tmp47 := lang.Apply(tmp46, []any{v42}) var v48 any = tmp47 _ = v48 @@ -48071,17 +47798,17 @@ func LoadNS() { var v55 any = v53 _ = v55 // let binding "seq__94" - tmp56 := checkDerefVar(glojure_DOT_core_seq) + tmp56 := checkDerefVar(var_glojure_DOT_core_seq) tmp57 := lang.Apply(tmp56, []any{v55}) var v58 any = tmp57 _ = v58 // let binding "first__95" - tmp59 := checkDerefVar(glojure_DOT_core_first) + tmp59 := checkDerefVar(var_glojure_DOT_core_first) tmp60 := lang.Apply(tmp59, []any{v58}) var v61 any = tmp60 _ = v61 // let binding "seq__94" - tmp62 := checkDerefVar(glojure_DOT_core_next) + tmp62 := checkDerefVar(var_glojure_DOT_core_next) tmp63 := lang.Apply(tmp62, []any{v58}) var v64 any = tmp63 _ = v64 @@ -48098,7 +47825,7 @@ func LoadNS() { if lang.IsTruthy(v67) { var tmp69 any var tmp70 any - tmp71 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp71 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) tmp72 := lang.Apply(tmp71, []any{v65}) if lang.IsTruthy(tmp72) { tmp70 = v17 @@ -48148,7 +47875,7 @@ func LoadNS() { } return tmp29 }) - tmp28 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5439), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(5452), lang.NewKeyword("end-column"), int(44)) + tmp28 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5439), kw_column, int(15), kw_end_DASH_line, int(5452), kw_end_DASH_column, int(44)) tmp29, err := lang.WithMeta(tmp27, tmp28.(lang.IPersistentMap)) if err != nil { panic(err) @@ -48160,14 +47887,10 @@ func LoadNS() { { // function drain var v32 lang.FnFunc tmp31 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var tmp33 lang.FnFunc tmp33 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var tmp34 any { // let // let binding "x" @@ -48185,22 +47908,22 @@ func LoadNS() { var v37 any = tmp36 _ = v37 var tmp38 any - tmp39 := checkDerefVar(glojure_DOT_core_identical_QMARK_) + tmp39 := checkDerefVar(var_glojure_DOT_core_identical_QMARK_) tmp40 := lang.Apply(tmp39, []any{v37, v12}) if lang.IsTruthy(tmp40) { - tmp41 := checkDerefVar(glojure_DOT_core_deref) + tmp41 := checkDerefVar(var_glojure_DOT_core_deref) tmp42 := lang.Apply(tmp41, []any{v22}) _ = tmp42 } else { - tmp43 := checkDerefVar(glojure_DOT_core_send_off) + tmp43 := checkDerefVar(var_glojure_DOT_core_send_DASH_off) tmp44 := lang.Apply(tmp43, []any{v22, v30}) _ = tmp44 - tmp45 := checkDerefVar(glojure_DOT_core_release_pending_sends) + tmp45 := checkDerefVar(var_glojure_DOT_core_release_DASH_pending_DASH_sends) tmp46 := lang.Apply(tmp45, nil) _ = tmp46 - tmp47 := checkDerefVar(glojure_DOT_core_cons) + tmp47 := checkDerefVar(var_glojure_DOT_core_cons) var tmp48 any - tmp49 := checkDerefVar(glojure_DOT_core_identical_QMARK_) + tmp49 := checkDerefVar(var_glojure_DOT_core_identical_QMARK_) tmp50 := lang.Apply(tmp49, []any{v37, v17}) if lang.IsTruthy(tmp50) { } else { @@ -48220,14 +47943,14 @@ func LoadNS() { v32 = tmp31 _ = v32 } - tmp32 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5453), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(5461), lang.NewKeyword("end-column"), int(73)) + tmp32 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5453), kw_column, int(16), kw_end_DASH_line, int(5461), kw_end_DASH_column, int(73)) tmp33, err := lang.WithMeta(tmp31, tmp32.(lang.IPersistentMap)) if err != nil { panic(err) } var v34 any = tmp33 _ = v34 - tmp35 := checkDerefVar(glojure_DOT_core_send_off) + tmp35 := checkDerefVar(var_glojure_DOT_core_send_DASH_off) tmp36 := lang.Apply(tmp35, []any{v22, v30}) _ = tmp36 tmp37 := lang.Apply(v34, nil) @@ -48235,10 +47958,11 @@ func LoadNS() { } // end let return tmp5 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -48246,7 +47970,7 @@ func LoadNS() { } // sequence { - tmp0 := lang.NewSymbol("sequence").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("coll"), lang.NewSymbol("&"), lang.NewSymbol("colls"))), lang.NewKeyword("doc"), "Coerces coll to a (possibly empty) sequence, if it is not already\n one. Will not force a lazy seq. (sequence nil) yields (), When a\n transducer is supplied, returns a lazy sequence of applications of\n the transform to the items in coll(s), i.e. to the set of first\n items of each coll, followed by the set of second\n items in each coll, until any one of the colls is exhausted. Any\n remaining items in other colls are ignored. The transform should accept\n number-of-colls arguments", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2639), lang.NewKeyword("end-line"), int(2639))).(*lang.Symbol) + tmp0 := sym_sequence.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll), lang.NewVector(sym_xform, sym_coll), lang.NewVector(sym_xform, sym_coll, sym__AMP_, sym_colls)), kw_doc, "Coerces coll to a (possibly empty) sequence, if it is not already\n one. Will not force a lazy seq. (sequence nil) yields (), When a\n transducer is supplied, returns a lazy sequence of applications of\n the transform to the items in coll(s), i.e. to the set of first\n items of each coll, followed by the set of second\n items in each coll, until any one of the colls is exhausted. Any\n remaining items in other colls are ignored. The transform should accept\n number-of-colls arguments", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(2639), kw_end_DASH_line, int(2639))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -48254,7 +47978,7 @@ func LoadNS() { v3 := args[0] _ = v3 var tmp4 any - tmp5 := checkDerefVar(glojure_DOT_core_seq_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) tmp6 := lang.Apply(tmp5, []any{v3}) if lang.IsTruthy(tmp6) { tmp4 = v3 @@ -48262,7 +47986,7 @@ func LoadNS() { var tmp7 any { // let // let binding "or__0__auto__" - tmp8 := checkDerefVar(glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) tmp9 := lang.Apply(tmp8, []any{v3}) var v10 any = tmp9 _ = v10 @@ -48300,9 +48024,7 @@ func LoadNS() { } // end let return tmp5 default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -48312,23 +48034,21 @@ func LoadNS() { var tmp6 any { // let // let binding "or__0__auto__" - tmp7 := checkDerefVar(glojure_DOT_core_map) + tmp7 := checkDerefVar(var_glojure_DOT_core_map) var tmp8 lang.FnFunc tmp8 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v9 := args[0] _ = v9 tmp10 := lang.Apply(nil, []any{v9}) return tmp10 }) - tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2661), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(2661), lang.NewKeyword("end-column"), int(41)) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2661), kw_column, int(17), kw_end_DASH_line, int(2661), kw_end_DASH_column, int(41)) tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp11 := checkDerefVar(glojure_DOT_core_cons) + tmp11 := checkDerefVar(var_glojure_DOT_core_cons) tmp12 := lang.Apply(tmp11, []any{v4, v5}) tmp13 := lang.Apply(tmp7, []any{tmp10, tmp12}) tmp14 := lang.Apply(nil, []any{v3, tmp13}) @@ -48346,7 +48066,7 @@ func LoadNS() { return tmp6 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -48354,20 +48074,18 @@ func LoadNS() { } // sequential? { - tmp0 := lang.NewSymbol("sequential?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements Sequential", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6229), lang.NewKeyword("end-line"), int(6229))).(*lang.Symbol) + tmp0 := sym_sequential_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns true if coll implements Sequential", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(6229), kw_end_DASH_line, int(6229))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp5 := reflect.TypeOf((*lang.Sequential)(nil)).Elem() tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -48375,14 +48093,12 @@ func LoadNS() { } // serialized-require { - tmp0 := lang.NewSymbol("serialized-require").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Like 'require', but serializes loading.\n Interim function preferred over 'require' for known asynchronous loads.\n Future changes may make these equivalent.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.10", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(6059), lang.NewKeyword("end-line"), int(6059), lang.NewKeyword("private"), true)).(*lang.Symbol) + tmp0 := sym_serialized_DASH_require.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_args)), kw_doc, "Like 'require', but serializes loading.\n Interim function preferred over 'require' for known asynchronous loads.\n Future changes may make these equivalent.", kw_file, "glojure/core.glj", kw_added, "1.10", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(25), kw_column, int(8), kw_line, int(6059), kw_end_DASH_line, int(6059), kw_private, true)).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 var tmp4 any @@ -48405,8 +48121,8 @@ func LoadNS() { tmp11 := lang.Apply(nil, []any{v8}) _ = tmp11 }() - tmp12 := checkDerefVar(glojure_DOT_core_apply) - tmp13 := checkDerefVar(glojure_DOT_core_require) + tmp12 := checkDerefVar(var_glojure_DOT_core_apply) + tmp13 := checkDerefVar(var_glojure_DOT_core_require) tmp14 := lang.Apply(tmp12, []any{tmp13, v3}) tmp10 = tmp14 }() @@ -48419,7 +48135,7 @@ func LoadNS() { return tmp4 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -48427,32 +48143,30 @@ func LoadNS() { } // set { - tmp0 := lang.NewSymbol("set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a set of the distinct elements of coll.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4104), lang.NewKeyword("end-line"), int(4104))).(*lang.Symbol) + tmp0 := sym_set.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a set of the distinct elements of coll.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(4104), kw_end_DASH_line, int(4104))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any - tmp5 := checkDerefVar(glojure_DOT_core_set_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_set_QMARK_) tmp6 := lang.Apply(tmp5, []any{v3}) if lang.IsTruthy(tmp6) { - tmp7 := checkDerefVar(glojure_DOT_core_with_meta) + tmp7 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) tmp8 := lang.Apply(tmp7, []any{v3, nil}) tmp4 = tmp8 } else { var tmp9 any - tmp10 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp10 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp11 := reflect.TypeOf((*lang.IReduceInit)(nil)).Elem() tmp12 := lang.Apply(tmp10, []any{tmp11, v3}) if lang.IsTruthy(tmp12) { - tmp13 := checkDerefVar(glojure_DOT_core_persistent_BANG_) - tmp14 := checkDerefVar(glojure_DOT_core_conj_BANG_) - tmp15 := checkDerefVar(glojure_DOT_core_transient) + tmp13 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp14 := checkDerefVar(var_glojure_DOT_core_conj_BANG_) + tmp15 := checkDerefVar(var_glojure_DOT_core_transient) tmp16 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) - tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4112), lang.NewKeyword("column"), int(108), lang.NewKeyword("end-line"), int(4112), lang.NewKeyword("end-column"), int(110)) + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4112), kw_column, int(108), kw_end_DASH_line, int(4112), kw_end_DASH_column, int(110)) tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) if err != nil { panic(err) @@ -48466,12 +48180,12 @@ func LoadNS() { tmp22 := lang.Apply(tmp13, []any{tmp21}) tmp9 = tmp22 } else { - tmp23 := checkDerefVar(glojure_DOT_core_persistent_BANG_) - tmp24 := checkDerefVar(glojure_DOT_core_reduce1) - tmp25 := checkDerefVar(glojure_DOT_core_conj_BANG_) - tmp26 := checkDerefVar(glojure_DOT_core_transient) + tmp23 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp24 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp25 := checkDerefVar(var_glojure_DOT_core_conj_BANG_) + tmp26 := checkDerefVar(var_glojure_DOT_core_transient) tmp27 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) - tmp28 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4113), lang.NewKeyword("column"), int(46), lang.NewKeyword("end-line"), int(4113), lang.NewKeyword("end-column"), int(48)) + tmp28 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4113), kw_column, int(46), kw_end_DASH_line, int(4113), kw_end_DASH_column, int(48)) tmp29, err := lang.WithMeta(tmp27, tmp28.(lang.IPersistentMap)) if err != nil { panic(err) @@ -48485,7 +48199,7 @@ func LoadNS() { } return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -48493,17 +48207,15 @@ func LoadNS() { } // set-agent-send-executor! { - tmp0 := lang.NewSymbol("set-agent-send-executor!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("executor"))), lang.NewKeyword("doc"), "Sets the ExecutorService to be used by send", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(30), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2087), lang.NewKeyword("end-line"), int(2087))).(*lang.Symbol) + tmp0 := sym_set_DASH_agent_DASH_send_DASH_executor_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_executor)), kw_doc, "Sets the ExecutorService to be used by send", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(30), kw_column, int(7), kw_line, int(2087), kw_end_DASH_line, int(2087))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 return nil }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -48511,17 +48223,15 @@ func LoadNS() { } // set-agent-send-off-executor! { - tmp0 := lang.NewSymbol("set-agent-send-off-executor!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("executor"))), lang.NewKeyword("doc"), "Sets the ExecutorService to be used by send-off", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(34), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2093), lang.NewKeyword("end-line"), int(2093))).(*lang.Symbol) + tmp0 := sym_set_DASH_agent_DASH_send_DASH_off_DASH_executor_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_executor)), kw_doc, "Sets the ExecutorService to be used by send-off", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(34), kw_column, int(7), kw_line, int(2093), kw_end_DASH_line, int(2093))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 return nil }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -48529,12 +48239,10 @@ func LoadNS() { } // set-error-handler! { - tmp0 := lang.NewSymbol("set-error-handler!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("handler-fn"))), lang.NewKeyword("doc"), "Sets the error-handler of agent a to handler-fn. If an action\n being run by the agent throws an exception or doesn't pass the\n validator fn, handler-fn will be called with two arguments: the\n agent and the exception.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2192), lang.NewKeyword("end-line"), int(2192))).(*lang.Symbol) + tmp0 := sym_set_DASH_error_DASH_handler_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a, sym_handler_DASH_fn)), kw_doc, "Sets the error-handler of agent a to handler-fn. If an action\n being run by the agent throws an exception or doesn't pass the\n validator fn, handler-fn will be called with two arguments: the\n agent and the exception.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(24), kw_column, int(7), kw_line, int(2192), kw_end_DASH_line, int(2192))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -48546,7 +48254,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v4}) return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -48554,12 +48262,10 @@ func LoadNS() { } // set-error-mode! { - tmp0 := lang.NewSymbol("set-error-mode!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("mode-keyword"))), lang.NewKeyword("doc"), "Sets the error-mode of agent a to mode-keyword, which must be\n either :fail or :continue. If an action being run by the agent\n throws an exception or doesn't pass the validator fn, an\n error-handler may be called (see set-error-handler!), after which,\n if the mode is :continue, the agent will continue as if neither the\n action that caused the error nor the error itself ever happened.\n \n If the mode is :fail, the agent will become failed and will stop\n accepting new 'send' and 'send-off' actions, and any previously\n queued actions will be held until a 'restart-agent'. Deref will\n still work, returning the state of the agent before the error.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2210), lang.NewKeyword("end-line"), int(2210))).(*lang.Symbol) + tmp0 := sym_set_DASH_error_DASH_mode_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a, sym_mode_DASH_keyword)), kw_doc, "Sets the error-mode of agent a to mode-keyword, which must be\n either :fail or :continue. If an action being run by the agent\n throws an exception or doesn't pass the validator fn, an\n error-handler may be called (see set-error-handler!), after which,\n if the mode is :continue, the agent will continue as if neither the\n action that caused the error nor the error itself ever happened.\n \n If the mode is :fail, the agent will become failed and will stop\n accepting new 'send' and 'send-off' actions, and any previously\n queued actions will be held until a 'restart-agent'. Deref will\n still work, returning the state of the agent before the error.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(2210), kw_end_DASH_line, int(2210))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -48571,7 +48277,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v4}) return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -48579,12 +48285,10 @@ func LoadNS() { } // set-validator! { - tmp0 := lang.NewSymbol("set-validator!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("iref"), lang.NewSymbol("validator-fn"))), lang.NewKeyword("doc"), "Sets the validator-fn for a var/ref/agent/atom. validator-fn must be nil or a\n side-effect-free fn of one argument, which will be passed the intended\n new state on any state change. If the new state is unacceptable, the\n validator-fn should return false or throw an exception. If the current state (root\n value if var) is not acceptable to the new validator, an exception\n will be thrown and the validator will not be changed.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2381), lang.NewKeyword("end-line"), int(2381))).(*lang.Symbol) + tmp0 := sym_set_DASH_validator_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_iref, sym_validator_DASH_fn)), kw_doc, "Sets the validator-fn for a var/ref/agent/atom. validator-fn must be nil or a\n side-effect-free fn of one argument, which will be passed the intended\n new state on any state change. If the new state is unacceptable, the\n validator-fn should return false or throw an exception. If the current state (root\n value if var) is not acceptable to the new validator, an exception\n will be thrown and the validator will not be changed.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(2381), kw_end_DASH_line, int(2381))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -48596,7 +48300,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v4}) return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -48604,20 +48308,18 @@ func LoadNS() { } // set? { - tmp0 := lang.NewSymbol("set?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x implements IPersistentSet", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4098), lang.NewKeyword("end-line"), int(4098))).(*lang.Symbol) + tmp0 := sym_set_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x implements IPersistentSet", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(4098), kw_end_DASH_line, int(4098))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp5 := reflect.TypeOf((*lang.IPersistentSet)(nil)).Elem() tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -48625,12 +48327,10 @@ func LoadNS() { } // setup-reference { - tmp0 := lang.NewSymbol("setup-reference").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2043), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(2044), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("r"), lang.NewSymbol("options"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym_setup_DASH_reference.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(2043), kw_column, int(7), kw_end_DASH_line, int(2044), kw_end_DASH_column, int(17), kw_arglists, lang.NewList(lang.NewVector(sym_r, sym_options)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -48638,15 +48338,15 @@ func LoadNS() { var tmp5 any { // let // let binding "opts" - tmp6 := checkDerefVar(glojure_DOT_core_apply) - tmp7 := checkDerefVar(glojure_DOT_core_hash_map) + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) tmp8 := lang.Apply(tmp6, []any{tmp7, v4}) var v9 any = tmp8 _ = v9 var tmp10 any - tmp11 := lang.Apply(lang.NewKeyword("meta"), []any{v9}) + tmp11 := lang.Apply(kw_meta, []any{v9}) if lang.IsTruthy(tmp11) { - tmp12 := lang.Apply(lang.NewKeyword("meta"), []any{v9}) + tmp12 := lang.Apply(kw_meta, []any{v9}) tmp13, _ := lang.FieldOrMethod(v3, "ResetMeta") if reflect.TypeOf(tmp13).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("ResetMeta is not a function"))) @@ -48657,9 +48357,9 @@ func LoadNS() { } _ = tmp10 var tmp15 any - tmp16 := lang.Apply(lang.NewKeyword("validator"), []any{v9}) + tmp16 := lang.Apply(kw_validator, []any{v9}) if lang.IsTruthy(tmp16) { - tmp17 := lang.Apply(lang.NewKeyword("validator"), []any{v9}) + tmp17 := lang.Apply(kw_validator, []any{v9}) tmp18, _ := lang.FieldOrMethod(v3, "setValidator") if reflect.TypeOf(tmp18).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("setValidator is not a function"))) @@ -48673,7 +48373,7 @@ func LoadNS() { } // end let return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -48681,25 +48381,23 @@ func LoadNS() { } // shift-mask { - tmp0 := lang.NewSymbol("shift-mask").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6598), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(6598), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("shift"), lang.NewSymbol("mask"), lang.NewSymbol("x"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym_shift_DASH_mask.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6598), kw_column, int(8), kw_end_DASH_line, int(6598), kw_end_DASH_column, int(17), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_shift, sym_mask, sym_x)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] _ = v4 v5 := args[2] _ = v5 - tmp6 := checkDerefVar(glojure_DOT_core_bit_and) - tmp7 := checkDerefVar(glojure_DOT_core_bit_shift_right) + tmp6 := checkDerefVar(var_glojure_DOT_core_bit_DASH_and) + tmp7 := checkDerefVar(var_glojure_DOT_core_bit_DASH_shift_DASH_right) tmp8 := lang.Apply(tmp7, []any{v5, v3}) tmp9 := lang.Apply(tmp6, []any{tmp8, v4}) return tmp9 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -48711,30 +48409,28 @@ func LoadNS() { { // function short__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) - tmp5 := checkDerefVar(glojure_DOT_core_concat) - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := checkDerefVar(glojure_DOT_core_seq) - tmp12 := checkDerefVar(glojure_DOT_core_concat) - tmp13 := checkDerefVar(glojure_DOT_core_list) + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) var tmp14 any - tmp15 := checkDerefVar(glojure_DOT_core__STAR_unchecked_math_STAR_) + tmp15 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp15) { - tmp14 = lang.NewSymbol("uncheckedShortCast") + tmp14 = sym_uncheckedShortCast } else { - tmp14 = lang.NewSymbol("shortCast") + tmp14 = sym_shortCast } tmp16 := lang.Apply(tmp13, []any{tmp14}) - tmp17 := checkDerefVar(glojure_DOT_core_list) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) tmp18 := lang.Apply(tmp17, []any{v3}) tmp19 := lang.Apply(tmp12, []any{tmp16, tmp18}) tmp20 := lang.Apply(tmp11, []any{tmp19}) @@ -48746,18 +48442,16 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("short").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to short", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3499), lang.NewKeyword("end-line"), int(3499))).(*lang.Symbol) + tmp0 := sym_short.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to short", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3499), kw_end_DASH_line, int(3499))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 tmp5 := lang.Apply(lang.ShortCast, []any{v4}) return tmp5 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -48771,26 +48465,24 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) - tmp5 := checkDerefVar(glojure_DOT_core_concat) - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol("glojure.core/ShortArray")}) - tmp12 := checkDerefVar(glojure_DOT_core_list) - tmp13 := checkDerefVar(glojure_DOT_core_seq) - tmp14 := checkDerefVar(glojure_DOT_core_concat) - tmp15 := checkDerefVar(glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("glojure.core/unquote-splicing")}) - tmp17 := checkDerefVar(glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol("glojure.core/args")}) + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_ShortArray}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_unquote_DASH_splicing}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_glojure_DOT_core_SLASH_args}) tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) tmp20 := lang.Apply(tmp13, []any{tmp19}) tmp21 := lang.Apply(tmp12, []any{tmp20}) @@ -48802,7 +48494,7 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("short-array").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("size-or-seq")), lang.NewVector(lang.NewSymbol("size"), lang.NewSymbol("init-val-or-seq"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Creates an array of shorts", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("inline-arities"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5333), lang.NewKeyword("end-line"), int(5333))).(*lang.Symbol) + tmp0 := sym_short_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_size_DASH_or_DASH_seq), lang.NewVector(sym_size, sym_init_DASH_val_DASH_or_DASH_seq)), kw_inline, tmp1, kw_doc, "Creates an array of shorts", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(5333), kw_end_DASH_line, int(5333))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -48827,10 +48519,11 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -48842,20 +48535,18 @@ func LoadNS() { { // function shorts var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) - tmp5 := checkDerefVar(glojure_DOT_core_concat) - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{lang.NewSymbol("glojure.core/Shorts")}) - tmp12 := checkDerefVar(glojure_DOT_core_list) + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Shorts}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := lang.Apply(tmp12, []any{v3}) tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) tmp15 := lang.Apply(tmp4, []any{tmp14}) @@ -48864,12 +48555,10 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("shorts").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xs"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Casts to shorts[]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(12), lang.NewKeyword("line"), int(5387), lang.NewKeyword("end-line"), int(5387))).(*lang.Symbol) + tmp0 := sym_shorts.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xs)), kw_inline, tmp1, kw_doc, "Casts to shorts[]", kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(12), kw_line, int(5387), kw_end_DASH_line, int(5387))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Shorts") @@ -48879,7 +48568,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v4}) return tmp6 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -48887,18 +48576,16 @@ func LoadNS() { } // shuffle { - tmp0 := lang.NewSymbol("shuffle").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Return a random permutation of coll", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7300), lang.NewKeyword("end-line"), int(7300))).(*lang.Symbol) + tmp0 := sym_shuffle.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Return a random permutation of coll", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(7300), kw_end_DASH_line, int(7300))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any { // let // let binding "al" - tmp5 := checkDerefVar(glojure_DOT_core_to_array) + tmp5 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) tmp6 := lang.Apply(tmp5, []any{v3}) tmp7 := lang.Apply(lang.NewArrayList, []any{tmp6}) var v8 any = tmp7 @@ -48921,7 +48608,7 @@ func LoadNS() { } // end let return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -48929,16 +48616,14 @@ func LoadNS() { } // shutdown-agents { - tmp0 := lang.NewSymbol("shutdown-agents").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("doc"), "Initiates a shutdown of the thread pools that back the agent\n system. Running actions will complete, but no new actions will be\n accepted", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2252), lang.NewKeyword("end-line"), int(2252))).(*lang.Symbol) + tmp0 := sym_shutdown_DASH_agents.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Initiates a shutdown of the thread pools that back the agent\n system. Running actions will complete, but no new actions will be\n accepted", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(2252), kw_end_DASH_line, int(2252))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) tmp3 := lang.Apply(lang.ShutdownAgents, nil) return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -48946,15 +48631,13 @@ func LoadNS() { } // sigs { - tmp0 := lang.NewSymbol("sigs").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(223), lang.NewKeyword("column"), int(2), lang.NewKeyword("end-line"), int(224), lang.NewKeyword("end-column"), int(5), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym_sigs.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(223), kw_column, int(2), kw_end_DASH_line, int(224), kw_end_DASH_column, int(5), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_assert_valid_fdecl) + tmp4 := checkDerefVar(var_glojure_DOT_core_assert_DASH_valid_DASH_fdecl) tmp5 := lang.Apply(tmp4, []any{v3}) _ = tmp5 var tmp6 any @@ -48962,23 +48645,21 @@ func LoadNS() { // let binding "asig" var tmp7 lang.FnFunc tmp7 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v8 := args[0] _ = v8 var tmp9 any { // let // let binding "arglist" - tmp10 := checkDerefVar(glojure_DOT_core_first) + tmp10 := checkDerefVar(var_glojure_DOT_core_first) tmp11 := lang.Apply(tmp10, []any{v8}) var v12 any = tmp11 _ = v12 // let binding "arglist" var tmp13 any - tmp14 := checkDerefVar(glojure_DOT_core_first) + tmp14 := checkDerefVar(var_glojure_DOT_core_first) tmp15 := lang.Apply(tmp14, []any{v12}) - tmp16 := lang.Apply(lang.Equals, []any{lang.NewSymbol("&form"), tmp15}) + tmp16 := lang.Apply(lang.Equals, []any{sym__AMP_form, tmp15}) if lang.IsTruthy(tmp16) { tmp17 := lang.Apply(lang.Count, []any{v12}) tmp18 := lang.Apply(lang.Subvec, []any{v12, int64(2), tmp17}) @@ -48989,39 +48670,39 @@ func LoadNS() { var v19 any = tmp13 _ = v19 // let binding "body" - tmp20 := checkDerefVar(glojure_DOT_core_next) + tmp20 := checkDerefVar(var_glojure_DOT_core_next) tmp21 := lang.Apply(tmp20, []any{v8}) var v22 any = tmp21 _ = v22 var tmp23 any - tmp24 := checkDerefVar(glojure_DOT_core_map_QMARK_) - tmp25 := checkDerefVar(glojure_DOT_core_first) + tmp24 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp25 := checkDerefVar(var_glojure_DOT_core_first) tmp26 := lang.Apply(tmp25, []any{v22}) tmp27 := lang.Apply(tmp24, []any{tmp26}) if lang.IsTruthy(tmp27) { var tmp28 any - tmp29 := checkDerefVar(glojure_DOT_core_next) + tmp29 := checkDerefVar(var_glojure_DOT_core_next) tmp30 := lang.Apply(tmp29, []any{v22}) if lang.IsTruthy(tmp30) { - tmp31 := checkDerefVar(glojure_DOT_core_with_meta) - tmp32 := checkDerefVar(glojure_DOT_core_conj) + tmp31 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp32 := checkDerefVar(var_glojure_DOT_core_conj) var tmp33 any - tmp34 := checkDerefVar(glojure_DOT_core_meta) + tmp34 := checkDerefVar(var_glojure_DOT_core_meta) tmp35 := lang.Apply(tmp34, []any{v19}) if lang.IsTruthy(tmp35) { - tmp36 := checkDerefVar(glojure_DOT_core_meta) + tmp36 := checkDerefVar(var_glojure_DOT_core_meta) tmp37 := lang.Apply(tmp36, []any{v19}) tmp33 = tmp37 } else { tmp38 := lang.NewMap() - tmp39 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(237), lang.NewKeyword("column"), int(77), lang.NewKeyword("end-line"), int(237), lang.NewKeyword("end-column"), int(78)) + tmp39 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(237), kw_column, int(77), kw_end_DASH_line, int(237), kw_end_DASH_column, int(78)) tmp40, err := lang.WithMeta(tmp38, tmp39.(lang.IPersistentMap)) if err != nil { panic(err) } tmp33 = tmp40 } - tmp41 := checkDerefVar(glojure_DOT_core_first) + tmp41 := checkDerefVar(var_glojure_DOT_core_first) tmp42 := lang.Apply(tmp41, []any{v22}) tmp43 := lang.Apply(tmp32, []any{tmp33, tmp42}) tmp44 := lang.Apply(tmp31, []any{v19, tmp43}) @@ -49037,7 +48718,7 @@ func LoadNS() { } // end let return tmp9 }) - tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(228), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(239), lang.NewKeyword("end-column"), int(25)) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(228), kw_column, int(10), kw_end_DASH_line, int(239), kw_end_DASH_column, int(25)) tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) if err != nil { panic(err) @@ -49047,24 +48728,22 @@ func LoadNS() { // let binding "resolve-tag" var tmp11 lang.FnFunc tmp11 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v12 := args[0] _ = v12 var tmp13 any { // let // let binding "m" - tmp14 := checkDerefVar(glojure_DOT_core_meta) + tmp14 := checkDerefVar(var_glojure_DOT_core_meta) tmp15 := lang.Apply(tmp14, []any{v12}) var v16 any = tmp15 _ = v16 // let binding "tag" - tmp17 := lang.Apply(lang.NewKeyword("tag"), []any{v16}) + tmp17 := lang.Apply(kw_tag, []any{v16}) var v18 any = tmp17 _ = v18 var tmp19 any - tmp20 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp20 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp21 := reflect.TypeOf((*lang.Symbol)(nil)) tmp22 := lang.Apply(tmp20, []any{tmp21, v18}) if lang.IsTruthy(tmp22) { @@ -49093,8 +48772,8 @@ func LoadNS() { _ = v31 var tmp32 any if lang.IsTruthy(v31) { - tmp33 := checkDerefVar(glojure_DOT_core_with_meta) - tmp34 := checkDerefVar(glojure_DOT_core_assoc) + tmp33 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp34 := checkDerefVar(var_glojure_DOT_core_assoc) tmp35, ok := lang.FieldOrMethod(v31, "Name") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v31, "Name"))) @@ -49107,7 +48786,7 @@ func LoadNS() { tmp36 = tmp35 } tmp37 := lang.Apply(lang.NewSymbol, []any{tmp36}) - tmp38 := lang.Apply(tmp34, []any{v16, lang.NewKeyword("tag"), tmp37}) + tmp38 := lang.Apply(tmp34, []any{v16, kw_tag, tmp37}) tmp39 := lang.Apply(tmp33, []any{v12, tmp38}) tmp32 = tmp39 } else { @@ -49131,7 +48810,7 @@ func LoadNS() { } // end let return tmp13 }) - tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(240), lang.NewKeyword("column"), int(22), lang.NewKeyword("end-line"), int(252), lang.NewKeyword("end-column"), int(37)) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(240), kw_column, int(22), kw_end_DASH_line, int(252), kw_end_DASH_column, int(37)) tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) if err != nil { panic(err) @@ -49139,8 +48818,8 @@ func LoadNS() { var v14 any = tmp13 _ = v14 var tmp15 any - tmp16 := checkDerefVar(glojure_DOT_core_seq_QMARK_) - tmp17 := checkDerefVar(glojure_DOT_core_first) + tmp16 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp17 := checkDerefVar(var_glojure_DOT_core_first) tmp18 := lang.Apply(tmp17, []any{v3}) tmp19 := lang.Apply(tmp16, []any{tmp18}) if lang.IsTruthy(tmp19) { @@ -49148,7 +48827,7 @@ func LoadNS() { { // let // let binding "ret" tmp21 := lang.NewVector() - tmp22 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(254), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(254), lang.NewKeyword("end-column"), int(20)) + tmp22 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(254), kw_column, int(19), kw_end_DASH_line, int(254), kw_end_DASH_column, int(20)) tmp23, err := lang.WithMeta(tmp21, tmp22.(lang.IPersistentMap)) if err != nil { panic(err) @@ -49161,21 +48840,21 @@ func LoadNS() { for { var tmp26 any if lang.IsTruthy(v25) { - tmp28 := checkDerefVar(glojure_DOT_core_conj) - tmp29 := checkDerefVar(glojure_DOT_core_first) + tmp28 := checkDerefVar(var_glojure_DOT_core_conj) + tmp29 := checkDerefVar(var_glojure_DOT_core_first) tmp30 := lang.Apply(tmp29, []any{v25}) tmp31 := lang.Apply(v10, []any{tmp30}) tmp32 := lang.Apply(v14, []any{tmp31}) tmp33 := lang.Apply(tmp28, []any{v24, tmp32}) var tmp27 any = tmp33 - tmp35 := checkDerefVar(glojure_DOT_core_next) + tmp35 := checkDerefVar(var_glojure_DOT_core_next) tmp36 := lang.Apply(tmp35, []any{v25}) var tmp34 any = tmp36 v24 = tmp27 v25 = tmp34 continue } else { - tmp37 := checkDerefVar(glojure_DOT_core_seq) + tmp37 := checkDerefVar(var_glojure_DOT_core_seq) tmp38 := lang.Apply(tmp37, []any{v24}) tmp26 = tmp38 } @@ -49185,7 +48864,7 @@ func LoadNS() { } // end let tmp15 = tmp20 } else { - tmp21 := checkDerefVar(glojure_DOT_core_list) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) tmp22 := lang.Apply(v10, []any{v3}) tmp23 := lang.Apply(v14, []any{tmp22}) tmp24 := lang.Apply(tmp21, []any{tmp23}) @@ -49195,7 +48874,7 @@ func LoadNS() { } // end let return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(225), lang.NewKeyword("column"), int(2), lang.NewKeyword("end-line"), int(258), lang.NewKeyword("end-column"), int(43))).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(225), kw_column, int(2), kw_end_DASH_line, int(258), kw_end_DASH_column, int(43))).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -49203,25 +48882,23 @@ func LoadNS() { } // simple-ident? { - tmp0 := lang.NewSymbol("simple-ident?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a symbol or keyword without a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1613), lang.NewKeyword("end-line"), int(1613))).(*lang.Symbol) + tmp0 := sym_simple_DASH_ident_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a symbol or keyword without a namespace", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(1613), kw_end_DASH_line, int(1613))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any { // let // let binding "and__0__auto__" - tmp5 := checkDerefVar(glojure_DOT_core_ident_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_ident_QMARK_) tmp6 := lang.Apply(tmp5, []any{v3}) var v7 any = tmp6 _ = v7 var tmp8 any if lang.IsTruthy(v7) { - tmp9 := checkDerefVar(glojure_DOT_core_nil_QMARK_) - tmp10 := checkDerefVar(glojure_DOT_core_namespace) + tmp9 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp10 := checkDerefVar(var_glojure_DOT_core_namespace) tmp11 := lang.Apply(tmp10, []any{v3}) tmp12 := lang.Apply(tmp9, []any{tmp11}) tmp8 = tmp12 @@ -49232,7 +48909,7 @@ func LoadNS() { } // end let return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -49240,25 +48917,23 @@ func LoadNS() { } // simple-keyword? { - tmp0 := lang.NewSymbol("simple-keyword?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a keyword without a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1633), lang.NewKeyword("end-line"), int(1633))).(*lang.Symbol) + tmp0 := sym_simple_DASH_keyword_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a keyword without a namespace", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(1633), kw_end_DASH_line, int(1633))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any { // let // let binding "and__0__auto__" - tmp5 := checkDerefVar(glojure_DOT_core_keyword_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) tmp6 := lang.Apply(tmp5, []any{v3}) var v7 any = tmp6 _ = v7 var tmp8 any if lang.IsTruthy(v7) { - tmp9 := checkDerefVar(glojure_DOT_core_nil_QMARK_) - tmp10 := checkDerefVar(glojure_DOT_core_namespace) + tmp9 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp10 := checkDerefVar(var_glojure_DOT_core_namespace) tmp11 := lang.Apply(tmp10, []any{v3}) tmp12 := lang.Apply(tmp9, []any{tmp11}) tmp8 = tmp12 @@ -49269,7 +48944,7 @@ func LoadNS() { } // end let return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -49277,25 +48952,23 @@ func LoadNS() { } // simple-symbol? { - tmp0 := lang.NewSymbol("simple-symbol?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a symbol without a namespace", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1623), lang.NewKeyword("end-line"), int(1623))).(*lang.Symbol) + tmp0 := sym_simple_DASH_symbol_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a symbol without a namespace", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(1623), kw_end_DASH_line, int(1623))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any { // let // let binding "and__0__auto__" - tmp5 := checkDerefVar(glojure_DOT_core_symbol_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) tmp6 := lang.Apply(tmp5, []any{v3}) var v7 any = tmp6 _ = v7 var tmp8 any if lang.IsTruthy(v7) { - tmp9 := checkDerefVar(glojure_DOT_core_nil_QMARK_) - tmp10 := checkDerefVar(glojure_DOT_core_namespace) + tmp9 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp10 := checkDerefVar(var_glojure_DOT_core_namespace) tmp11 := lang.Apply(tmp10, []any{v3}) tmp12 := lang.Apply(tmp9, []any{tmp11}) tmp8 = tmp12 @@ -49306,7 +48979,7 @@ func LoadNS() { } // end let return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -49315,14 +48988,12 @@ func LoadNS() { // slurp { tmp1 := reflect.TypeOf("") - tmp0 := lang.NewSymbol("slurp").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("opts"))), lang.NewKeyword("doc"), "Opens a reader on f and reads all its contents, returning a string.\n See glojure.java.io/reader for a complete list of supported arguments.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6982), lang.NewKeyword("end-line"), int(6982))).(*lang.Symbol) + tmp0 := sym_slurp.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_f, sym__AMP_, sym_opts)), kw_doc, "Opens a reader on f and reads all its contents, returning a string.\n See glojure.java.io/reader for a complete list of supported arguments.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(6982), kw_end_DASH_line, int(6982))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 var v5 any = lang.NewList(args[1:]...) @@ -49330,7 +49001,7 @@ func LoadNS() { var tmp6 any { // let // let binding "opts" - tmp7 := checkDerefVar(glojure_DOT_core_normalize_slurp_opts) + tmp7 := checkDerefVar(var_glojure_DOT_core_normalize_DASH_slurp_DASH_opts) tmp8 := lang.Apply(tmp7, []any{v5}) var v9 any = tmp8 _ = v9 @@ -49340,8 +49011,8 @@ func LoadNS() { var tmp11 any { // let // let binding "r" - tmp12 := checkDerefVar(glojure_DOT_core_apply) - tmp13 := checkDerefVar(glojure_DOT_go_DOT_io_reader) + tmp12 := checkDerefVar(var_glojure_DOT_core_apply) + tmp13 := checkDerefVar(var_glojure_DOT_go_DOT_io_reader) tmp14 := lang.Apply(tmp12, []any{tmp13, v4, v9}) var v15 any = tmp14 _ = v15 @@ -49361,7 +49032,7 @@ func LoadNS() { } _ = tmp18 }() - tmp19 := checkDerefVar(glojure_DOT_go_DOT_io_copy) + tmp19 := checkDerefVar(var_glojure_DOT_go_DOT_io_copy) tmp20 := lang.Apply(tmp19, []any{v15, v10}) _ = tmp20 tmp21 := lang.Apply(lang.ToString, []any{v10}) @@ -49375,7 +49046,7 @@ func LoadNS() { } }) tmp4 := reflect.TypeOf("") - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -49383,12 +49054,10 @@ func LoadNS() { } // some { - tmp0 := lang.NewSymbol("some").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns the first logical true value of (pred x) for any x in coll,\n else nil. One common idiom is to use a set as pred, for example\n this will return :fred if :fred is in the sequence, otherwise nil:\n (some #{:fred} coll)", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2684), lang.NewKeyword("end-line"), int(2684))).(*lang.Symbol) + tmp0 := sym_some.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns the first logical true value of (pred x) for any x in coll,\n else nil. One common idiom is to use a set as pred, for example\n this will return :fred if :fred is in the sequence, otherwise nil:\n (some #{:fred} coll)", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(2684), kw_end_DASH_line, int(2684))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -49397,7 +49066,7 @@ func LoadNS() { var tmp5 any { // let // let binding "temp__0__auto__" - tmp6 := checkDerefVar(glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) tmp7 := lang.Apply(tmp6, []any{v4}) var v8 any = tmp7 _ = v8 @@ -49411,7 +49080,7 @@ func LoadNS() { var tmp12 any { // let // let binding "or__0__auto__" - tmp13 := checkDerefVar(glojure_DOT_core_first) + tmp13 := checkDerefVar(var_glojure_DOT_core_first) tmp14 := lang.Apply(tmp13, []any{v11}) tmp15 := lang.Apply(v3, []any{tmp14}) var v16 any = tmp15 @@ -49421,7 +49090,7 @@ func LoadNS() { tmp17 = v16 } else { var tmp18 any = v3 - tmp20 := checkDerefVar(glojure_DOT_core_next) + tmp20 := checkDerefVar(var_glojure_DOT_core_next) tmp21 := lang.Apply(tmp20, []any{v11}) var tmp19 any = tmp21 v3 = tmp18 @@ -49439,7 +49108,7 @@ func LoadNS() { } // end let return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -49447,14 +49116,12 @@ func LoadNS() { } // some-> { - tmp0 := lang.NewSymbol("some->").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "When expr is not nil, threads it into the first form (via ->),\n and when that result is not nil, through the next etc", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7610), lang.NewKeyword("end-line"), int(7610))).(*lang.Symbol) + tmp0 := sym_some_DASH__GT_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_expr, sym__AMP_, sym_forms)), kw_doc, "When expr is not nil, threads it into the first form (via ->),\n and when that result is not nil, through the next etc", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(11), kw_line, int(7610), kw_end_DASH_line, int(7610))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -49466,43 +49133,41 @@ func LoadNS() { var tmp7 any { // let // let binding "g" - tmp8 := checkDerefVar(glojure_DOT_core_gensym) + tmp8 := checkDerefVar(var_glojure_DOT_core_gensym) tmp9 := lang.Apply(tmp8, nil) var v10 any = tmp9 _ = v10 // let binding "steps" - tmp11 := checkDerefVar(glojure_DOT_core_map) + tmp11 := checkDerefVar(var_glojure_DOT_core_map) var tmp12 lang.FnFunc tmp12 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v13 := args[0] _ = v13 - tmp14 := checkDerefVar(glojure_DOT_core_seq) - tmp15 := checkDerefVar(glojure_DOT_core_concat) - tmp16 := checkDerefVar(glojure_DOT_core_list) - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("if")}) - tmp18 := checkDerefVar(glojure_DOT_core_list) - tmp19 := checkDerefVar(glojure_DOT_core_seq) - tmp20 := checkDerefVar(glojure_DOT_core_concat) - tmp21 := checkDerefVar(glojure_DOT_core_list) - tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("glojure.core/nil?")}) - tmp23 := checkDerefVar(glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{sym_if}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := checkDerefVar(var_glojure_DOT_core_seq) + tmp20 := checkDerefVar(var_glojure_DOT_core_concat) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{sym_glojure_DOT_core_SLASH_nil_QMARK_}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) tmp24 := lang.Apply(tmp23, []any{v10}) tmp25 := lang.Apply(tmp20, []any{tmp22, tmp24}) tmp26 := lang.Apply(tmp19, []any{tmp25}) tmp27 := lang.Apply(tmp18, []any{tmp26}) - tmp28 := checkDerefVar(glojure_DOT_core_list) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) tmp29 := lang.Apply(tmp28, []any{nil}) - tmp30 := checkDerefVar(glojure_DOT_core_list) - tmp31 := checkDerefVar(glojure_DOT_core_seq) - tmp32 := checkDerefVar(glojure_DOT_core_concat) - tmp33 := checkDerefVar(glojure_DOT_core_list) - tmp34 := lang.Apply(tmp33, []any{lang.NewSymbol("glojure.core/->")}) - tmp35 := checkDerefVar(glojure_DOT_core_list) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := checkDerefVar(var_glojure_DOT_core_seq) + tmp32 := checkDerefVar(var_glojure_DOT_core_concat) + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{sym_glojure_DOT_core_SLASH__DASH__GT_}) + tmp35 := checkDerefVar(var_glojure_DOT_core_list) tmp36 := lang.Apply(tmp35, []any{v10}) - tmp37 := checkDerefVar(glojure_DOT_core_list) + tmp37 := checkDerefVar(var_glojure_DOT_core_list) tmp38 := lang.Apply(tmp37, []any{v13}) tmp39 := lang.Apply(tmp32, []any{tmp34, tmp36, tmp38}) tmp40 := lang.Apply(tmp31, []any{tmp39}) @@ -49511,7 +49176,7 @@ func LoadNS() { tmp43 := lang.Apply(tmp14, []any{tmp42}) return tmp43 }) - tmp13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7616), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7616), lang.NewKeyword("end-column"), int(64)) + tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7616), kw_column, int(20), kw_end_DASH_line, int(7616), kw_end_DASH_column, int(64)) tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) if err != nil { panic(err) @@ -49519,37 +49184,37 @@ func LoadNS() { tmp15 := lang.Apply(tmp11, []any{tmp14, v6}) var v16 any = tmp15 _ = v16 - tmp17 := checkDerefVar(glojure_DOT_core_seq) - tmp18 := checkDerefVar(glojure_DOT_core_concat) - tmp19 := checkDerefVar(glojure_DOT_core_list) - tmp20 := lang.Apply(tmp19, []any{lang.NewSymbol("glojure.core/let")}) - tmp21 := checkDerefVar(glojure_DOT_core_list) - tmp22 := checkDerefVar(glojure_DOT_core_apply) - tmp23 := checkDerefVar(glojure_DOT_core_vector) - tmp24 := checkDerefVar(glojure_DOT_core_seq) - tmp25 := checkDerefVar(glojure_DOT_core_concat) - tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp17 := checkDerefVar(var_glojure_DOT_core_seq) + tmp18 := checkDerefVar(var_glojure_DOT_core_concat) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{sym_glojure_DOT_core_SLASH_let}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := checkDerefVar(var_glojure_DOT_core_apply) + tmp23 := checkDerefVar(var_glojure_DOT_core_vector) + tmp24 := checkDerefVar(var_glojure_DOT_core_seq) + tmp25 := checkDerefVar(var_glojure_DOT_core_concat) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) tmp27 := lang.Apply(tmp26, []any{v10}) - tmp28 := checkDerefVar(glojure_DOT_core_list) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) tmp29 := lang.Apply(tmp28, []any{v5}) - tmp30 := checkDerefVar(glojure_DOT_core_interleave) - tmp31 := checkDerefVar(glojure_DOT_core_repeat) + tmp30 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp31 := checkDerefVar(var_glojure_DOT_core_repeat) tmp32 := lang.Apply(tmp31, []any{v10}) - tmp33 := checkDerefVar(glojure_DOT_core_butlast) + tmp33 := checkDerefVar(var_glojure_DOT_core_butlast) tmp34 := lang.Apply(tmp33, []any{v16}) tmp35 := lang.Apply(tmp30, []any{tmp32, tmp34}) tmp36 := lang.Apply(tmp25, []any{tmp27, tmp29, tmp35}) tmp37 := lang.Apply(tmp24, []any{tmp36}) tmp38 := lang.Apply(tmp22, []any{tmp23, tmp37}) tmp39 := lang.Apply(tmp21, []any{tmp38}) - tmp40 := checkDerefVar(glojure_DOT_core_list) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) var tmp41 any - tmp42 := checkDerefVar(glojure_DOT_core_empty_QMARK_) + tmp42 := checkDerefVar(var_glojure_DOT_core_empty_QMARK_) tmp43 := lang.Apply(tmp42, []any{v16}) if lang.IsTruthy(tmp43) { tmp41 = v10 } else { - tmp44 := checkDerefVar(glojure_DOT_core_last) + tmp44 := checkDerefVar(var_glojure_DOT_core_last) tmp45 := lang.Apply(tmp44, []any{v16}) tmp41 = tmp45 } @@ -49561,7 +49226,7 @@ func LoadNS() { return tmp7 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -49569,14 +49234,12 @@ func LoadNS() { } // some->> { - tmp0 := lang.NewSymbol("some->>").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"), lang.NewSymbol("&"), lang.NewSymbol("forms"))), lang.NewKeyword("doc"), "When expr is not nil, threads it into the first form (via ->>),\n and when that result is not nil, through the next etc", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.5", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7624), lang.NewKeyword("end-line"), int(7624))).(*lang.Symbol) + tmp0 := sym_some_DASH__GT__GT_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_expr, sym__AMP_, sym_forms)), kw_doc, "When expr is not nil, threads it into the first form (via ->>),\n and when that result is not nil, through the next etc", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(7624), kw_end_DASH_line, int(7624))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -49588,43 +49251,41 @@ func LoadNS() { var tmp7 any { // let // let binding "g" - tmp8 := checkDerefVar(glojure_DOT_core_gensym) + tmp8 := checkDerefVar(var_glojure_DOT_core_gensym) tmp9 := lang.Apply(tmp8, nil) var v10 any = tmp9 _ = v10 // let binding "steps" - tmp11 := checkDerefVar(glojure_DOT_core_map) + tmp11 := checkDerefVar(var_glojure_DOT_core_map) var tmp12 lang.FnFunc tmp12 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v13 := args[0] _ = v13 - tmp14 := checkDerefVar(glojure_DOT_core_seq) - tmp15 := checkDerefVar(glojure_DOT_core_concat) - tmp16 := checkDerefVar(glojure_DOT_core_list) - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("if")}) - tmp18 := checkDerefVar(glojure_DOT_core_list) - tmp19 := checkDerefVar(glojure_DOT_core_seq) - tmp20 := checkDerefVar(glojure_DOT_core_concat) - tmp21 := checkDerefVar(glojure_DOT_core_list) - tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("glojure.core/nil?")}) - tmp23 := checkDerefVar(glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{sym_if}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := checkDerefVar(var_glojure_DOT_core_seq) + tmp20 := checkDerefVar(var_glojure_DOT_core_concat) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{sym_glojure_DOT_core_SLASH_nil_QMARK_}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) tmp24 := lang.Apply(tmp23, []any{v10}) tmp25 := lang.Apply(tmp20, []any{tmp22, tmp24}) tmp26 := lang.Apply(tmp19, []any{tmp25}) tmp27 := lang.Apply(tmp18, []any{tmp26}) - tmp28 := checkDerefVar(glojure_DOT_core_list) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) tmp29 := lang.Apply(tmp28, []any{nil}) - tmp30 := checkDerefVar(glojure_DOT_core_list) - tmp31 := checkDerefVar(glojure_DOT_core_seq) - tmp32 := checkDerefVar(glojure_DOT_core_concat) - tmp33 := checkDerefVar(glojure_DOT_core_list) - tmp34 := lang.Apply(tmp33, []any{lang.NewSymbol("glojure.core/->>")}) - tmp35 := checkDerefVar(glojure_DOT_core_list) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := checkDerefVar(var_glojure_DOT_core_seq) + tmp32 := checkDerefVar(var_glojure_DOT_core_concat) + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{sym_glojure_DOT_core_SLASH__DASH__GT__GT_}) + tmp35 := checkDerefVar(var_glojure_DOT_core_list) tmp36 := lang.Apply(tmp35, []any{v10}) - tmp37 := checkDerefVar(glojure_DOT_core_list) + tmp37 := checkDerefVar(var_glojure_DOT_core_list) tmp38 := lang.Apply(tmp37, []any{v13}) tmp39 := lang.Apply(tmp32, []any{tmp34, tmp36, tmp38}) tmp40 := lang.Apply(tmp31, []any{tmp39}) @@ -49633,7 +49294,7 @@ func LoadNS() { tmp43 := lang.Apply(tmp14, []any{tmp42}) return tmp43 }) - tmp13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7630), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(7630), lang.NewKeyword("end-column"), int(65)) + tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7630), kw_column, int(20), kw_end_DASH_line, int(7630), kw_end_DASH_column, int(65)) tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) if err != nil { panic(err) @@ -49641,37 +49302,37 @@ func LoadNS() { tmp15 := lang.Apply(tmp11, []any{tmp14, v6}) var v16 any = tmp15 _ = v16 - tmp17 := checkDerefVar(glojure_DOT_core_seq) - tmp18 := checkDerefVar(glojure_DOT_core_concat) - tmp19 := checkDerefVar(glojure_DOT_core_list) - tmp20 := lang.Apply(tmp19, []any{lang.NewSymbol("glojure.core/let")}) - tmp21 := checkDerefVar(glojure_DOT_core_list) - tmp22 := checkDerefVar(glojure_DOT_core_apply) - tmp23 := checkDerefVar(glojure_DOT_core_vector) - tmp24 := checkDerefVar(glojure_DOT_core_seq) - tmp25 := checkDerefVar(glojure_DOT_core_concat) - tmp26 := checkDerefVar(glojure_DOT_core_list) + tmp17 := checkDerefVar(var_glojure_DOT_core_seq) + tmp18 := checkDerefVar(var_glojure_DOT_core_concat) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{sym_glojure_DOT_core_SLASH_let}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := checkDerefVar(var_glojure_DOT_core_apply) + tmp23 := checkDerefVar(var_glojure_DOT_core_vector) + tmp24 := checkDerefVar(var_glojure_DOT_core_seq) + tmp25 := checkDerefVar(var_glojure_DOT_core_concat) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) tmp27 := lang.Apply(tmp26, []any{v10}) - tmp28 := checkDerefVar(glojure_DOT_core_list) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) tmp29 := lang.Apply(tmp28, []any{v5}) - tmp30 := checkDerefVar(glojure_DOT_core_interleave) - tmp31 := checkDerefVar(glojure_DOT_core_repeat) + tmp30 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp31 := checkDerefVar(var_glojure_DOT_core_repeat) tmp32 := lang.Apply(tmp31, []any{v10}) - tmp33 := checkDerefVar(glojure_DOT_core_butlast) + tmp33 := checkDerefVar(var_glojure_DOT_core_butlast) tmp34 := lang.Apply(tmp33, []any{v16}) tmp35 := lang.Apply(tmp30, []any{tmp32, tmp34}) tmp36 := lang.Apply(tmp25, []any{tmp27, tmp29, tmp35}) tmp37 := lang.Apply(tmp24, []any{tmp36}) tmp38 := lang.Apply(tmp22, []any{tmp23, tmp37}) tmp39 := lang.Apply(tmp21, []any{tmp38}) - tmp40 := checkDerefVar(glojure_DOT_core_list) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) var tmp41 any - tmp42 := checkDerefVar(glojure_DOT_core_empty_QMARK_) + tmp42 := checkDerefVar(var_glojure_DOT_core_empty_QMARK_) tmp43 := lang.Apply(tmp42, []any{v16}) if lang.IsTruthy(tmp43) { tmp41 = v10 } else { - tmp44 := checkDerefVar(glojure_DOT_core_last) + tmp44 := checkDerefVar(var_glojure_DOT_core_last) tmp45 := lang.Apply(tmp44, []any{v16}) tmp41 = tmp45 } @@ -49683,7 +49344,7 @@ func LoadNS() { return tmp7 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -49691,7 +49352,7 @@ func LoadNS() { } // some-fn { - tmp0 := lang.NewSymbol("some-fn").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("p")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2"), lang.NewSymbol("p3")), lang.NewVector(lang.NewSymbol("p1"), lang.NewSymbol("p2"), lang.NewSymbol("p3"), lang.NewSymbol("&"), lang.NewSymbol("ps"))), lang.NewKeyword("doc"), "Takes a set of predicates and returns a function f that returns the first logical true value\n returned by one of its composing predicates against any of its arguments, else it returns\n logical false. Note that f is short-circuiting in that it will stop execution on the first\n argument that triggers a logical true result against the original predicates.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7462), lang.NewKeyword("end-line"), int(7462))).(*lang.Symbol) + tmp0 := sym_some_DASH_fn.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_p), lang.NewVector(sym_p1, sym_p2), lang.NewVector(sym_p1, sym_p2, sym_p3), lang.NewVector(sym_p1, sym_p2, sym_p3, sym__AMP_, sym_ps)), kw_doc, "Takes a set of predicates and returns a function f that returns the first logical true value\n returned by one of its composing predicates against any of its arguments, else it returns\n logical false. Note that f is short-circuiting in that it will stop execution on the first\n argument that triggers a logical true result against the original predicates.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(7462), kw_end_DASH_line, int(7462))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -49769,9 +49430,7 @@ func LoadNS() { } // end let return tmp9 default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v6 := args[0] _ = v6 v7 := args[1] @@ -49790,7 +49449,7 @@ func LoadNS() { if lang.IsTruthy(v12) { tmp13 = v12 } else { - tmp14 := checkDerefVar(glojure_DOT_core_some) + tmp14 := checkDerefVar(var_glojure_DOT_core_some) tmp15 := lang.Apply(tmp14, []any{v3, v9}) tmp13 = tmp15 } @@ -49802,7 +49461,7 @@ func LoadNS() { v5 = tmp4 _ = v5 } - tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7469), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7475), lang.NewKeyword("end-column"), int(43)) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7469), kw_column, int(6), kw_end_DASH_line, int(7475), kw_end_DASH_column, int(43)) tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) if err != nil { panic(err) @@ -49968,9 +49627,7 @@ func LoadNS() { } // end let return tmp10 default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v7 := args[0] _ = v7 v8 := args[1] @@ -49989,12 +49646,10 @@ func LoadNS() { if lang.IsTruthy(v13) { tmp14 = v13 } else { - tmp15 := checkDerefVar(glojure_DOT_core_some) + tmp15 := checkDerefVar(var_glojure_DOT_core_some) var tmp16 lang.FnFunc tmp16 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v17 := args[0] _ = v17 var tmp18 any @@ -50014,7 +49669,7 @@ func LoadNS() { } // end let return tmp18 }) - tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7483), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(7483), lang.NewKeyword("end-column"), int(52)) + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7483), kw_column, int(34), kw_end_DASH_line, int(7483), kw_end_DASH_column, int(52)) tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) if err != nil { panic(err) @@ -50030,7 +49685,7 @@ func LoadNS() { v6 = tmp5 _ = v6 } - tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7477), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7483), lang.NewKeyword("end-column"), int(61)) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7477), kw_column, int(6), kw_end_DASH_line, int(7483), kw_end_DASH_column, int(61)) tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) if err != nil { panic(err) @@ -50282,9 +49937,7 @@ func LoadNS() { } // end let return tmp11 default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v8 := args[0] _ = v8 v9 := args[1] @@ -50303,12 +49956,10 @@ func LoadNS() { if lang.IsTruthy(v14) { tmp15 = v14 } else { - tmp16 := checkDerefVar(glojure_DOT_core_some) + tmp16 := checkDerefVar(var_glojure_DOT_core_some) var tmp17 lang.FnFunc tmp17 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v18 := args[0] _ = v18 var tmp19 any @@ -50342,7 +49993,7 @@ func LoadNS() { } // end let return tmp19 }) - tmp18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7491), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(7491), lang.NewKeyword("end-column"), int(59)) + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7491), kw_column, int(34), kw_end_DASH_line, int(7491), kw_end_DASH_column, int(59)) tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) if err != nil { panic(err) @@ -50358,16 +50009,14 @@ func LoadNS() { v7 = tmp6 _ = v7 } - tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7485), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(7491), lang.NewKeyword("end-column"), int(68)) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7485), kw_column, int(6), kw_end_DASH_line, int(7491), kw_end_DASH_column, int(68)) tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) if err != nil { panic(err) } return tmp8 default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -50379,7 +50028,7 @@ func LoadNS() { var tmp7 any { // let // let binding "ps" - tmp8 := checkDerefVar(glojure_DOT_core_list_STAR_) + tmp8 := checkDerefVar(var_glojure_DOT_core_list_STAR_) tmp9 := lang.Apply(tmp8, []any{v3, v4, v5, v6}) var v10 any = tmp9 _ = v10 @@ -50393,18 +50042,16 @@ func LoadNS() { case 1: v13 := args[0] _ = v13 - tmp14 := checkDerefVar(glojure_DOT_core_some) + tmp14 := checkDerefVar(var_glojure_DOT_core_some) var tmp15 lang.FnFunc tmp15 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v16 := args[0] _ = v16 tmp17 := lang.Apply(v16, []any{v13}) return tmp17 }) - tmp16 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7496), lang.NewKeyword("column"), int(21), lang.NewKeyword("end-line"), int(7496), lang.NewKeyword("end-column"), int(26)) + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7496), kw_column, int(21), kw_end_DASH_line, int(7496), kw_end_DASH_column, int(26)) tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) if err != nil { panic(err) @@ -50416,12 +50063,10 @@ func LoadNS() { _ = v13 v14 := args[1] _ = v14 - tmp15 := checkDerefVar(glojure_DOT_core_some) + tmp15 := checkDerefVar(var_glojure_DOT_core_some) var tmp16 lang.FnFunc tmp16 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v17 := args[0] _ = v17 var tmp18 any @@ -50441,7 +50086,7 @@ func LoadNS() { } // end let return tmp18 }) - tmp17 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7497), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(7497), lang.NewKeyword("end-column"), int(39)) + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7497), kw_column, int(23), kw_end_DASH_line, int(7497), kw_end_DASH_column, int(39)) tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) if err != nil { panic(err) @@ -50455,12 +50100,10 @@ func LoadNS() { _ = v14 v15 := args[2] _ = v15 - tmp16 := checkDerefVar(glojure_DOT_core_some) + tmp16 := checkDerefVar(var_glojure_DOT_core_some) var tmp17 lang.FnFunc tmp17 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v18 := args[0] _ = v18 var tmp19 any @@ -50494,7 +50137,7 @@ func LoadNS() { } // end let return tmp19 }) - tmp18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7498), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7498), lang.NewKeyword("end-column"), int(47)) + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7498), kw_column, int(25), kw_end_DASH_line, int(7498), kw_end_DASH_column, int(47)) tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) if err != nil { panic(err) @@ -50502,9 +50145,7 @@ func LoadNS() { tmp20 := lang.Apply(tmp16, []any{tmp19, v10}) return tmp20 default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v13 := args[0] _ = v13 v14 := args[1] @@ -50523,19 +50164,17 @@ func LoadNS() { if lang.IsTruthy(v19) { tmp20 = v19 } else { - tmp21 := checkDerefVar(glojure_DOT_core_some) + tmp21 := checkDerefVar(var_glojure_DOT_core_some) var tmp22 lang.FnFunc tmp22 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v23 := args[0] _ = v23 - tmp24 := checkDerefVar(glojure_DOT_core_some) + tmp24 := checkDerefVar(var_glojure_DOT_core_some) tmp25 := lang.Apply(tmp24, []any{v23, v16}) return tmp25 }) - tmp23 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7500), lang.NewKeyword("column"), int(36), lang.NewKeyword("end-line"), int(7500), lang.NewKeyword("end-column"), int(49)) + tmp23 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7500), kw_column, int(36), kw_end_DASH_line, int(7500), kw_end_DASH_column, int(49)) tmp24, err := lang.WithMeta(tmp22, tmp23.(lang.IPersistentMap)) if err != nil { panic(err) @@ -50551,7 +50190,7 @@ func LoadNS() { v12 = tmp11 _ = v12 } - tmp12 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7494), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(7500), lang.NewKeyword("end-column"), int(56)) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7494), kw_column, int(8), kw_end_DASH_line, int(7500), kw_end_DASH_column, int(56)) tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) if err != nil { panic(err) @@ -50561,7 +50200,7 @@ func LoadNS() { return tmp7 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -50570,22 +50209,20 @@ func LoadNS() { // some? { tmp1 := reflect.TypeOf(false) - tmp0 := lang.NewSymbol("some?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is not nil, false otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(530), lang.NewKeyword("end-line"), int(530))).(*lang.Symbol) + tmp0 := sym_some_QMARK_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x is not nil, false otherwise.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.6", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(530), kw_end_DASH_line, int(530))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_not) - tmp6 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_not) + tmp6 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) tmp7 := lang.Apply(tmp6, []any{v4}) tmp8 := lang.Apply(tmp5, []any{tmp7}) return tmp8 }) tmp4 := reflect.TypeOf(false) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -50593,15 +50230,15 @@ func LoadNS() { } // sort { - tmp0 := lang.NewSymbol("sort").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("comp"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a sorted sequence of the items in coll. If no comparator is\n supplied, uses compare. comparator must implement\n java.util.Comparator. Guaranteed to be stable: equal elements will\n not be reordered. If coll is a Java array, it will be modified. To\n avoid this, sort a copy of the array.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3085), lang.NewKeyword("end-line"), int(3085))).(*lang.Symbol) + tmp0 := sym_sort.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll), lang.NewVector(sym_comp, sym_coll)), kw_doc, "Returns a sorted sequence of the items in coll. If no comparator is\n supplied, uses compare. comparator must implement\n java.util.Comparator. Guaranteed to be stable: equal elements will\n not be reordered. If coll is a Java array, it will be modified. To\n avoid this, sort a copy of the array.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3085), kw_end_DASH_line, int(3085))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_sort) - tmp5 := checkDerefVar(glojure_DOT_core_compare) + tmp4 := checkDerefVar(var_glojure_DOT_core_sort) + tmp5 := checkDerefVar(var_glojure_DOT_core_compare) tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) return tmp6 case 2: @@ -50610,22 +50247,22 @@ func LoadNS() { v4 := args[1] _ = v4 var tmp5 any - tmp6 := checkDerefVar(glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) tmp7 := lang.Apply(tmp6, []any{v4}) if lang.IsTruthy(tmp7) { var tmp8 any { // let // let binding "a" - tmp9 := checkDerefVar(glojure_DOT_core_to_array) + tmp9 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) tmp10 := lang.Apply(tmp9, []any{v4}) var v11 any = tmp10 _ = v11 tmp12 := lang.Apply(lang.SortSlice, []any{v11, v3}) _ = tmp12 - tmp13 := checkDerefVar(glojure_DOT_core_with_meta) - tmp14 := checkDerefVar(glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) tmp15 := lang.Apply(tmp14, []any{v11}) - tmp16 := checkDerefVar(glojure_DOT_core_meta) + tmp16 := checkDerefVar(var_glojure_DOT_core_meta) tmp17 := lang.Apply(tmp16, []any{v4}) tmp18 := lang.Apply(tmp13, []any{tmp15, tmp17}) tmp8 = tmp18 @@ -50636,10 +50273,11 @@ func LoadNS() { } return tmp5 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -50647,7 +50285,7 @@ func LoadNS() { } // sort-by { - tmp0 := lang.NewSymbol("sort-by").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("keyfn"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("keyfn"), lang.NewSymbol("comp"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a sorted sequence of the items in coll, where the sort\n order is determined by comparing (keyfn item). If no comparator is\n supplied, uses compare. comparator must implement\n java.util.Comparator. Guaranteed to be stable: equal elements will\n not be reordered. If coll is a Java array, it will be modified. To\n avoid this, sort a copy of the array.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3102), lang.NewKeyword("end-line"), int(3102))).(*lang.Symbol) + tmp0 := sym_sort_DASH_by.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_keyfn, sym_coll), lang.NewVector(sym_keyfn, sym_comp, sym_coll)), kw_doc, "Returns a sorted sequence of the items in coll, where the sort\n order is determined by comparing (keyfn item). If no comparator is\n supplied, uses compare. comparator must implement\n java.util.Comparator. Guaranteed to be stable: equal elements will\n not be reordered. If coll is a Java array, it will be modified. To\n avoid this, sort a copy of the array.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(3102), kw_end_DASH_line, int(3102))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -50656,8 +50294,8 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_sort_by) - tmp6 := checkDerefVar(glojure_DOT_core_compare) + tmp5 := checkDerefVar(var_glojure_DOT_core_sort_DASH_by) + tmp6 := checkDerefVar(var_glojure_DOT_core_compare) tmp7 := lang.Apply(tmp5, []any{v3, tmp6, v4}) return tmp7 case 3: @@ -50667,12 +50305,10 @@ func LoadNS() { _ = v4 v5 := args[2] _ = v5 - tmp6 := checkDerefVar(glojure_DOT_core_sort) + tmp6 := checkDerefVar(var_glojure_DOT_core_sort) var tmp7 lang.FnFunc tmp7 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v8 := args[0] _ = v8 v9 := args[1] @@ -50682,7 +50318,7 @@ func LoadNS() { tmp12 := lang.Apply(v4, []any{tmp10, tmp11}) return tmp12 }) - tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3114), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(3114), lang.NewKeyword("end-column"), int(46)) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3114), kw_column, int(10), kw_end_DASH_line, int(3114), kw_end_DASH_column, int(46)) tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) if err != nil { panic(err) @@ -50690,10 +50326,11 @@ func LoadNS() { tmp10 := lang.Apply(tmp6, []any{tmp9, v5}) return tmp10 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -50701,21 +50338,19 @@ func LoadNS() { } // sorted-map { - tmp0 := lang.NewSymbol("sorted-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keyvals"))), lang.NewKeyword("doc"), "keyval => key val\n Returns a new sorted map with supplied mappings. If any keys are\n equal, they are handled as if by repeated uses of assoc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(397), lang.NewKeyword("end-line"), int(397))).(*lang.Symbol) + tmp0 := sym_sorted_DASH_map.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_keyvals)), kw_doc, "keyval => key val\n Returns a new sorted map with supplied mappings. If any keys are\n equal, they are handled as if by repeated uses of assoc.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(397), kw_end_DASH_line, int(397))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 tmp4 := lang.Apply(lang.CreatePersistentTreeMap, []any{v3}) return tmp4 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -50723,14 +50358,12 @@ func LoadNS() { } // sorted-map-by { - tmp0 := lang.NewSymbol("sorted-map-by").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("comparator"), lang.NewSymbol("&"), lang.NewSymbol("keyvals"))), lang.NewKeyword("doc"), "keyval => key val\n Returns a new sorted map with supplied mappings, using the supplied\n comparator. If any keys are equal, they are handled as if by\n repeated uses of assoc.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(406), lang.NewKeyword("end-line"), int(406))).(*lang.Symbol) + tmp0 := sym_sorted_DASH_map_DASH_by.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_comparator, sym__AMP_, sym_keyvals)), kw_doc, "keyval => key val\n Returns a new sorted map with supplied mappings, using the supplied\n comparator. If any keys are equal, they are handled as if by\n repeated uses of assoc.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(406), kw_end_DASH_line, int(406))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var v4 any = lang.NewList(args[1:]...) @@ -50739,7 +50372,7 @@ func LoadNS() { return tmp5 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -50747,21 +50380,19 @@ func LoadNS() { } // sorted-set { - tmp0 := lang.NewSymbol("sorted-set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("keys"))), lang.NewKeyword("doc"), "Returns a new sorted set with supplied keys. Any equal keys are\n handled as if by repeated uses of conj.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(416), lang.NewKeyword("end-line"), int(416))).(*lang.Symbol) + tmp0 := sym_sorted_DASH_set.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_keys)), kw_doc, "Returns a new sorted set with supplied keys. Any equal keys are\n handled as if by repeated uses of conj.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(416), kw_end_DASH_line, int(416))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 tmp4 := lang.Apply(lang.CreatePersistentTreeSet, []any{v3}) return tmp4 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -50769,14 +50400,12 @@ func LoadNS() { } // sorted-set-by { - tmp0 := lang.NewSymbol("sorted-set-by").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("comparator"), lang.NewSymbol("&"), lang.NewSymbol("keys"))), lang.NewKeyword("doc"), "Returns a new sorted set with supplied keys, using the supplied\n comparator. Any equal keys are handled as if by repeated uses of\n conj.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(424), lang.NewKeyword("end-line"), int(424))).(*lang.Symbol) + tmp0 := sym_sorted_DASH_set_DASH_by.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_comparator, sym__AMP_, sym_keys)), kw_doc, "Returns a new sorted set with supplied keys, using the supplied\n comparator. Any equal keys are handled as if by repeated uses of\n conj.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(424), kw_end_DASH_line, int(424))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var v4 any = lang.NewList(args[1:]...) @@ -50785,7 +50414,7 @@ func LoadNS() { return tmp5 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -50793,19 +50422,17 @@ func LoadNS() { } // sorted? { - tmp0 := lang.NewSymbol("sorted?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns true if coll implements Sorted", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6235), lang.NewKeyword("end-line"), int(6235))).(*lang.Symbol) + tmp0 := sym_sorted_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns true if coll implements Sorted", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(6235), kw_end_DASH_line, int(6235))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp5 := lang.Apply(tmp4, []any{nil, v3}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -50813,15 +50440,13 @@ func LoadNS() { } // special-symbol? { - tmp0 := lang.NewSymbol("special-symbol?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Returns true if s names a special form", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4992), lang.NewKeyword("end-line"), int(4992))).(*lang.Symbol) + tmp0 := sym_special_DASH_symbol_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_doc, "Returns true if s names a special form", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(4992), kw_end_DASH_line, int(4992))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_contains_QMARK_) + tmp4 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) tmp5, ok := lang.FieldOrMethod(runtime7.Compiler, "specials") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", runtime7.Compiler, "specials"))) @@ -50836,7 +50461,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp4, []any{tmp6, v3}) return tmp7 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -50844,14 +50469,12 @@ func LoadNS() { } // spit { - tmp0 := lang.NewSymbol("spit").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("content"), lang.NewSymbol("&"), lang.NewSymbol("options"))), lang.NewKeyword("doc"), "Opposite of slurp. Opens f with writer, writes content, then\n closes f. Options passed to glojure.java.io/writer.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6994), lang.NewKeyword("end-line"), int(6994))).(*lang.Symbol) + tmp0 := sym_spit.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_content, sym__AMP_, sym_options)), kw_doc, "Opposite of slurp. Opens f with writer, writes content, then\n closes f. Options passed to glojure.java.io/writer.", kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(6994), kw_end_DASH_line, int(6994))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -50861,7 +50484,7 @@ func LoadNS() { var tmp6 any { // let // let binding "w" - tmp7 := checkDerefVar(glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_apply) tmp8 := lang.Apply(tmp7, []any{nil, v3, v5}) var v9 any = tmp8 _ = v9 @@ -50881,7 +50504,7 @@ func LoadNS() { } _ = tmp12 }() - tmp13 := checkDerefVar(glojure_DOT_core_str) + tmp13 := checkDerefVar(var_glojure_DOT_core_str) tmp14 := lang.Apply(tmp13, []any{v4}) tmp15 := lang.Apply(lang.WriteWriter, []any{v9, tmp14}) tmp10 = tmp15 @@ -50891,7 +50514,7 @@ func LoadNS() { return tmp6 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -50899,29 +50522,27 @@ func LoadNS() { } // split-at { - tmp0 := lang.NewSymbol("split-at").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a vector of [(take n coll) (drop n coll)]", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2983), lang.NewKeyword("end-line"), int(2983))).(*lang.Symbol) + tmp0 := sym_split_DASH_at.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n, sym_coll)), kw_doc, "Returns a vector of [(take n coll) (drop n coll)]", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(2983), kw_end_DASH_line, int(2983))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_take) + tmp5 := checkDerefVar(var_glojure_DOT_core_take) tmp6 := lang.Apply(tmp5, []any{v3, v4}) - tmp7 := checkDerefVar(glojure_DOT_core_drop) + tmp7 := checkDerefVar(var_glojure_DOT_core_drop) tmp8 := lang.Apply(tmp7, []any{v3, v4}) tmp9 := lang.NewVector(tmp6, tmp8) - tmp10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2988), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2988), lang.NewKeyword("end-column"), int(33)) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2988), kw_column, int(5), kw_end_DASH_line, int(2988), kw_end_DASH_column, int(33)) tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) if err != nil { panic(err) } return tmp11 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -50929,29 +50550,27 @@ func LoadNS() { } // split-with { - tmp0 := lang.NewSymbol("split-with").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a vector of [(take-while pred coll) (drop-while pred coll)]", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2990), lang.NewKeyword("end-line"), int(2990))).(*lang.Symbol) + tmp0 := sym_split_DASH_with.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns a vector of [(take-while pred coll) (drop-while pred coll)]", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(2990), kw_end_DASH_line, int(2990))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_take_while) + tmp5 := checkDerefVar(var_glojure_DOT_core_take_DASH_while) tmp6 := lang.Apply(tmp5, []any{v3, v4}) - tmp7 := checkDerefVar(glojure_DOT_core_drop_while) + tmp7 := checkDerefVar(var_glojure_DOT_core_drop_DASH_while) tmp8 := lang.Apply(tmp7, []any{v3, v4}) tmp9 := lang.NewVector(tmp6, tmp8) - tmp10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2995), lang.NewKeyword("column"), int(5), lang.NewKeyword("end-line"), int(2995), lang.NewKeyword("end-column"), int(51)) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2995), kw_column, int(5), kw_end_DASH_line, int(2995), kw_end_DASH_column, int(51)) tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) if err != nil { panic(err) } return tmp11 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -50959,37 +50578,35 @@ func LoadNS() { } // splitv-at { - tmp0 := lang.NewSymbol("splitv-at").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a vector of [(into [] (take n) coll) (drop n coll)]", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7256), lang.NewKeyword("end-line"), int(7256))).(*lang.Symbol) + tmp0 := sym_splitv_DASH_at.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n, sym_coll)), kw_doc, "Returns a vector of [(into [] (take n) coll) (drop n coll)]", kw_file, "glojure/core.glj", kw_added, "1.12", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(7256), kw_end_DASH_line, int(7256))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_into) + tmp5 := checkDerefVar(var_glojure_DOT_core_into) tmp6 := lang.NewVector() - tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7260), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(7260), lang.NewKeyword("end-column"), int(11)) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7260), kw_column, int(10), kw_end_DASH_line, int(7260), kw_end_DASH_column, int(11)) tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp9 := checkDerefVar(glojure_DOT_core_take) + tmp9 := checkDerefVar(var_glojure_DOT_core_take) tmp10 := lang.Apply(tmp9, []any{v3}) tmp11 := lang.Apply(tmp5, []any{tmp8, tmp10, v4}) - tmp12 := checkDerefVar(glojure_DOT_core_drop) + tmp12 := checkDerefVar(var_glojure_DOT_core_drop) tmp13 := lang.Apply(tmp12, []any{v3, v4}) tmp14 := lang.NewVector(tmp11, tmp13) - tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7260), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(7260), lang.NewKeyword("end-column"), int(41)) + tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7260), kw_column, int(3), kw_end_DASH_line, int(7260), kw_end_DASH_column, int(41)) tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) if err != nil { panic(err) } return tmp16 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -50997,38 +50614,36 @@ func LoadNS() { } // spread { - tmp0 := lang.NewSymbol("spread").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("arglist"))), lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(632), lang.NewKeyword("end-line"), int(632), lang.NewKeyword("private"), true)).(*lang.Symbol) + tmp0 := sym_spread.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_arglist)), kw_static, true, kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(632), kw_end_DASH_line, int(632), kw_private, true)).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any - tmp5 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) tmp6 := lang.Apply(tmp5, []any{v3}) if lang.IsTruthy(tmp6) { } else { var tmp7 any - tmp8 := checkDerefVar(glojure_DOT_core_nil_QMARK_) - tmp9 := checkDerefVar(glojure_DOT_core_next) + tmp8 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp9 := checkDerefVar(var_glojure_DOT_core_next) tmp10 := lang.Apply(tmp9, []any{v3}) tmp11 := lang.Apply(tmp8, []any{tmp10}) if lang.IsTruthy(tmp11) { - tmp12 := checkDerefVar(glojure_DOT_core_seq) - tmp13 := checkDerefVar(glojure_DOT_core_first) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_first) tmp14 := lang.Apply(tmp13, []any{v3}) tmp15 := lang.Apply(tmp12, []any{tmp14}) tmp7 = tmp15 } else { var tmp16 any - if lang.IsTruthy(lang.NewKeyword("else")) { - tmp17 := checkDerefVar(glojure_DOT_core_cons) - tmp18 := checkDerefVar(glojure_DOT_core_first) + if lang.IsTruthy(kw_else) { + tmp17 := checkDerefVar(var_glojure_DOT_core_cons) + tmp18 := checkDerefVar(var_glojure_DOT_core_first) tmp19 := lang.Apply(tmp18, []any{v3}) - tmp20 := checkDerefVar(glojure_DOT_core_spread) - tmp21 := checkDerefVar(glojure_DOT_core_next) + tmp20 := checkDerefVar(var_glojure_DOT_core_spread) + tmp21 := checkDerefVar(var_glojure_DOT_core_next) tmp22 := lang.Apply(tmp21, []any{v3}) tmp23 := lang.Apply(tmp20, []any{tmp22}) tmp24 := lang.Apply(tmp17, []any{tmp19, tmp23}) @@ -51041,7 +50656,7 @@ func LoadNS() { } return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -51050,7 +50665,7 @@ func LoadNS() { // str { tmp1 := reflect.TypeOf("") - tmp0 := lang.NewSymbol("str").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("&"), lang.NewSymbol("ys"))), lang.NewKeyword("doc"), "With no args, returns the empty string. With one arg x, returns\n x.toString(). (str nil) returns the empty string. With more than\n one arg, returns the concatenation of the str values of the args.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(543), lang.NewKeyword("end-line"), int(543))).(*lang.Symbol) + tmp0 := sym_str.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_x), lang.NewVector(sym_x, sym__AMP_, sym_ys)), kw_doc, "With no args, returns the empty string. With one arg x, returns\n x.toString(). (str nil) returns the empty string. With more than\n one arg, returns the concatenation of the str values of the args.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(543), kw_end_DASH_line, int(543))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -51060,7 +50675,7 @@ func LoadNS() { v4 := args[0] _ = v4 var tmp5 any - tmp6 := checkDerefVar(glojure_DOT_core_nil_QMARK_) + tmp6 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) tmp7 := lang.Apply(tmp6, []any{v4}) if lang.IsTruthy(tmp7) { tmp5 = "" @@ -51070,18 +50685,14 @@ func LoadNS() { } return tmp5 default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 var v5 any = lang.NewList(args[1:]...) _ = v5 var tmp6 lang.FnFunc tmp6 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v7 := args[0] _ = v7 v8 := args[1] @@ -51089,8 +50700,8 @@ func LoadNS() { recur_loop_74: var tmp9 any if lang.IsTruthy(v8) { - tmp11 := checkDerefVar(glojure_DOT_core_str) - tmp12 := checkDerefVar(glojure_DOT_core_first) + tmp11 := checkDerefVar(var_glojure_DOT_core_str) + tmp12 := checkDerefVar(var_glojure_DOT_core_first) tmp13 := lang.Apply(tmp12, []any{v8}) tmp14 := lang.Apply(tmp11, []any{tmp13}) tmp15, _ := lang.FieldOrMethod(v7, "WriteString") @@ -51100,7 +50711,7 @@ func LoadNS() { tmp16 := lang.Apply(tmp15, []any{tmp14}) _ = tmp16 var tmp10 any = v7 - tmp18 := checkDerefVar(glojure_DOT_core_next) + tmp18 := checkDerefVar(var_glojure_DOT_core_next) tmp19 := lang.Apply(tmp18, []any{v8}) var tmp17 any = tmp19 v7 = tmp10 @@ -51122,19 +50733,19 @@ func LoadNS() { } return tmp9 }) - tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(554), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(554), lang.NewKeyword("end-column"), int(127)) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(554), kw_column, int(7), kw_end_DASH_line, int(554), kw_end_DASH_column, int(127)) tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp9 := checkDerefVar(glojure_DOT_core_cons) + tmp9 := checkDerefVar(var_glojure_DOT_core_cons) tmp10 := lang.Apply(tmp9, []any{v4, v5}) tmp11 := lang.Apply(tmp8, []any{"unimplemented: new with non-constant class type", tmp10}) return tmp11 } }) tmp4 := reflect.TypeOf("") - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -51142,7 +50753,7 @@ func LoadNS() { } // stream-into! { - tmp0 := lang.NewSymbol("stream-into!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("stream")), lang.NewVector(lang.NewSymbol("to"), lang.NewSymbol("xform"), lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Returns a new coll consisting of coll with all of the items of the\n stream conjoined. This is a terminal operation on the stream.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6810), lang.NewKeyword("end-line"), int(6810))).(*lang.Symbol) + tmp0 := sym_stream_DASH_into_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_to, sym_stream), lang.NewVector(sym_to, sym_xform, sym_stream)), kw_doc, "Returns a new coll consisting of coll with all of the items of the\n stream conjoined. This is a terminal operation on the stream.", kw_file, "glojure/core.glj", kw_added, "1.12", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(6810), kw_end_DASH_line, int(6810))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -51152,25 +50763,25 @@ func LoadNS() { v4 := args[1] _ = v4 var tmp5 any - tmp6 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp6 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp7 := reflect.TypeOf((*lang.IEditableCollection)(nil)).Elem() tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) if lang.IsTruthy(tmp8) { - tmp9 := checkDerefVar(glojure_DOT_core_with_meta) - tmp10 := checkDerefVar(glojure_DOT_core_persistent_BANG_) - tmp11 := checkDerefVar(glojure_DOT_core_stream_reduce_BANG_) - tmp12 := checkDerefVar(glojure_DOT_core_conj_BANG_) - tmp13 := checkDerefVar(glojure_DOT_core_transient) + tmp9 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp10 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp11 := checkDerefVar(var_glojure_DOT_core_stream_DASH_reduce_BANG_) + tmp12 := checkDerefVar(var_glojure_DOT_core_conj_BANG_) + tmp13 := checkDerefVar(var_glojure_DOT_core_transient) tmp14 := lang.Apply(tmp13, []any{v3}) tmp15 := lang.Apply(tmp11, []any{tmp12, tmp14, v4}) tmp16 := lang.Apply(tmp10, []any{tmp15}) - tmp17 := checkDerefVar(glojure_DOT_core_meta) + tmp17 := checkDerefVar(var_glojure_DOT_core_meta) tmp18 := lang.Apply(tmp17, []any{v3}) tmp19 := lang.Apply(tmp9, []any{tmp16, tmp18}) tmp5 = tmp19 } else { - tmp20 := checkDerefVar(glojure_DOT_core_stream_reduce_BANG_) - tmp21 := checkDerefVar(glojure_DOT_core_conj) + tmp20 := checkDerefVar(var_glojure_DOT_core_stream_DASH_reduce_BANG_) + tmp21 := checkDerefVar(var_glojure_DOT_core_conj) tmp22 := lang.Apply(tmp20, []any{tmp21, v3, v4}) tmp5 = tmp22 } @@ -51183,34 +50794,35 @@ func LoadNS() { v5 := args[2] _ = v5 var tmp6 any - tmp7 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp7 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp8 := reflect.TypeOf((*lang.IEditableCollection)(nil)).Elem() tmp9 := lang.Apply(tmp7, []any{tmp8, v3}) if lang.IsTruthy(tmp9) { - tmp10 := checkDerefVar(glojure_DOT_core_with_meta) - tmp11 := checkDerefVar(glojure_DOT_core_persistent_BANG_) - tmp12 := checkDerefVar(glojure_DOT_core_stream_transduce_BANG_) - tmp13 := checkDerefVar(glojure_DOT_core_conj_BANG_) - tmp14 := checkDerefVar(glojure_DOT_core_transient) + tmp10 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp11 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp12 := checkDerefVar(var_glojure_DOT_core_stream_DASH_transduce_BANG_) + tmp13 := checkDerefVar(var_glojure_DOT_core_conj_BANG_) + tmp14 := checkDerefVar(var_glojure_DOT_core_transient) tmp15 := lang.Apply(tmp14, []any{v3}) tmp16 := lang.Apply(tmp12, []any{v4, tmp13, tmp15, v5}) tmp17 := lang.Apply(tmp11, []any{tmp16}) - tmp18 := checkDerefVar(glojure_DOT_core_meta) + tmp18 := checkDerefVar(var_glojure_DOT_core_meta) tmp19 := lang.Apply(tmp18, []any{v3}) tmp20 := lang.Apply(tmp10, []any{tmp17, tmp19}) tmp6 = tmp20 } else { - tmp21 := checkDerefVar(glojure_DOT_core_stream_transduce_BANG_) - tmp22 := checkDerefVar(glojure_DOT_core_conj) + tmp21 := checkDerefVar(var_glojure_DOT_core_stream_DASH_transduce_BANG_) + tmp22 := checkDerefVar(var_glojure_DOT_core_conj) tmp23 := lang.Apply(tmp21, []any{v4, tmp22, v3, v5}) tmp6 = tmp23 } return tmp6 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -51218,7 +50830,7 @@ func LoadNS() { } // stream-reduce! { - tmp0 := lang.NewSymbol("stream-reduce!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("s")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("s"))), lang.NewKeyword("doc"), "Works like reduce but takes a java.util.stream.BaseStream as its source.\n Honors 'reduced', is a terminal operation on the stream", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6784), lang.NewKeyword("end-line"), int(6784))).(*lang.Symbol) + tmp0 := sym_stream_DASH_reduce_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_s), lang.NewVector(sym_f, sym_init, sym_s)), kw_doc, "Works like reduce but takes a java.util.stream.BaseStream as its source.\n Honors 'reduced', is a terminal operation on the stream", kw_file, "glojure/core.glj", kw_added, "1.12", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(6784), kw_end_DASH_line, int(6784))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -51261,10 +50873,11 @@ func LoadNS() { tmp8 := lang.Apply(nil, []any{tmp7, v3, v4}) return tmp8 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -51272,15 +50885,13 @@ func LoadNS() { } // stream-seq! { - tmp0 := lang.NewSymbol("stream-seq!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Takes a java.util.stream.BaseStream instance s and returns a seq of its\n contents. This is a terminal operation on the stream.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6793), lang.NewKeyword("end-line"), int(6793))).(*lang.Symbol) + tmp0 := sym_stream_DASH_seq_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_stream)), kw_doc, "Takes a java.util.stream.BaseStream instance s and returns a seq of its\n contents. This is a terminal operation on the stream.", kw_file, "glojure/core.glj", kw_added, "1.12", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(6793), kw_end_DASH_line, int(6793))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_iterator_seq) + tmp4 := checkDerefVar(var_glojure_DOT_core_iterator_DASH_seq) tmp5, ok := lang.FieldOrMethod(v3, "iterator") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "iterator"))) @@ -51295,7 +50906,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp4, []any{tmp6}) return tmp7 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -51303,7 +50914,7 @@ func LoadNS() { } // stream-transduce! { - tmp0 := lang.NewSymbol("stream-transduce!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("f"), lang.NewSymbol("stream")), lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("stream"))), lang.NewKeyword("doc"), "Works like transduce but takes a java.util.stream.BaseStream as its source.\n This is a terminal operation on the stream.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.12", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6800), lang.NewKeyword("end-line"), int(6800))).(*lang.Symbol) + tmp0 := sym_stream_DASH_transduce_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xform, sym_f, sym_stream), lang.NewVector(sym_xform, sym_f, sym_init, sym_stream)), kw_doc, "Works like transduce but takes a java.util.stream.BaseStream as its source.\n This is a terminal operation on the stream.", kw_file, "glojure/core.glj", kw_added, "1.12", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(7), kw_line, int(6800), kw_end_DASH_line, int(6800))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -51314,7 +50925,7 @@ func LoadNS() { _ = v4 v5 := args[2] _ = v5 - tmp6 := checkDerefVar(glojure_DOT_core_stream_transduce_BANG_) + tmp6 := checkDerefVar(var_glojure_DOT_core_stream_DASH_transduce_BANG_) tmp7 := lang.Apply(v4, nil) tmp8 := lang.Apply(tmp6, []any{v3, v4, tmp7, v5}) return tmp8 @@ -51334,7 +50945,7 @@ func LoadNS() { var v9 any = tmp8 _ = v9 // let binding "ret" - tmp10 := checkDerefVar(glojure_DOT_core_stream_reduce_BANG_) + tmp10 := checkDerefVar(var_glojure_DOT_core_stream_DASH_reduce_BANG_) tmp11 := lang.Apply(tmp10, []any{v9, v5, v6}) var v12 any = tmp11 _ = v12 @@ -51343,10 +50954,11 @@ func LoadNS() { } // end let return tmp7 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -51354,21 +50966,19 @@ func LoadNS() { } // string? { - tmp0 := lang.NewSymbol("string?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a String", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(160), lang.NewKeyword("end-line"), int(164))).(*lang.Symbol) + tmp0 := sym_string_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a String", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(2), kw_line, int(160), kw_end_DASH_line, int(164))).(*lang.Symbol) var tmp2 lang.FnFunc { // function string? var v3 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp6 := lang.Apply(tmp5, []any{lang.Builtins["string"], v4}) return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(164), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(164), lang.NewKeyword("end-column"), int(58))).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(164), kw_column, int(10), kw_end_DASH_line, int(164), kw_end_DASH_column, int(58))).(lang.FnFunc) v3 = tmp2 _ = v3 } @@ -51379,33 +50989,31 @@ func LoadNS() { } // strip-ns { - tmp0 := lang.NewSymbol("strip-ns").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core_print.glj", lang.NewKeyword("line"), int(255), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(255), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("private"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("named"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym_strip_DASH_ns.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(255), kw_column, int(8), kw_end_DASH_line, int(255), kw_end_DASH_column, int(15), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_named)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any - tmp5 := checkDerefVar(glojure_DOT_core_symbol_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) tmp6 := lang.Apply(tmp5, []any{v3}) if lang.IsTruthy(tmp6) { - tmp7 := checkDerefVar(glojure_DOT_core_symbol) - tmp8 := checkDerefVar(glojure_DOT_core_name) + tmp7 := checkDerefVar(var_glojure_DOT_core_symbol) + tmp8 := checkDerefVar(var_glojure_DOT_core_name) tmp9 := lang.Apply(tmp8, []any{v3}) tmp10 := lang.Apply(tmp7, []any{nil, tmp9}) tmp4 = tmp10 } else { - tmp11 := checkDerefVar(glojure_DOT_core_keyword) - tmp12 := checkDerefVar(glojure_DOT_core_name) + tmp11 := checkDerefVar(var_glojure_DOT_core_keyword) + tmp12 := checkDerefVar(var_glojure_DOT_core_name) tmp13 := lang.Apply(tmp12, []any{v3}) tmp14 := lang.Apply(tmp11, []any{nil, tmp13}) tmp4 = tmp14 } return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -51413,14 +51021,12 @@ func LoadNS() { } // struct { - tmp0 := lang.NewSymbol("struct").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("&"), lang.NewSymbol("vals"))), lang.NewKeyword("doc"), "Returns a new structmap instance with the keys of the\n structure-basis. vals must be supplied for basis keys in order -\n where values are not supplied they will default to nil.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4061), lang.NewKeyword("end-line"), int(4061))).(*lang.Symbol) + tmp0 := sym_struct.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s, sym__AMP_, sym_vals)), kw_doc, "Returns a new structmap instance with the keys of the\n structure-basis. vals must be supplied for basis keys in order -\n where values are not supplied they will default to nil.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(4061), kw_end_DASH_line, int(4061))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var v4 any = lang.NewList(args[1:]...) @@ -51429,7 +51035,7 @@ func LoadNS() { return tmp5 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -51437,14 +51043,12 @@ func LoadNS() { } // struct-map { - tmp0 := lang.NewSymbol("struct-map").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("&"), lang.NewSymbol("inits"))), lang.NewKeyword("doc"), "Returns a new structmap instance with the keys of the\n structure-basis. keyvals may contain all, some or none of the basis\n keys - where values are not supplied they will default to nil.\n keyvals can also contain keys not in the basis.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4051), lang.NewKeyword("end-line"), int(4051))).(*lang.Symbol) + tmp0 := sym_struct_DASH_map.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s, sym__AMP_, sym_inits)), kw_doc, "Returns a new structmap instance with the keys of the\n structure-basis. keyvals may contain all, some or none of the basis\n keys - where values are not supplied they will default to nil.\n keyvals can also contain keys not in the basis.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4051), kw_end_DASH_line, int(4051))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var v4 any = lang.NewList(args[1:]...) @@ -51453,7 +51057,7 @@ func LoadNS() { return tmp5 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -51461,7 +51065,7 @@ func LoadNS() { } // subs { - tmp0 := lang.NewSymbol("subs").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("start")), lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("start"), lang.NewSymbol("end"))), lang.NewKeyword("doc"), "Returns the substring of s beginning at start inclusive, and ending\n at end (defaults to length of string), exclusive.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5005), lang.NewKeyword("end-line"), int(5005))).(*lang.Symbol) + tmp0 := sym_subs.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s, sym_start), lang.NewVector(sym_s, sym_start, sym_end)), kw_doc, "Returns the substring of s beginning at start inclusive, and ending\n at end (defaults to length of string), exclusive.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(5005), kw_end_DASH_line, int(5005))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -51482,10 +51086,11 @@ func LoadNS() { tmp6 := lang.Apply(lang.Builtins["slice"], []any{v3, v4, v5}) return tmp6 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -51493,7 +51098,7 @@ func LoadNS() { } // subseq { - tmp0 := lang.NewSymbol("subseq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("sc"), lang.NewSymbol("test"), lang.NewSymbol("key")), lang.NewVector(lang.NewSymbol("sc"), lang.NewSymbol("start-test"), lang.NewSymbol("start-key"), lang.NewSymbol("end-test"), lang.NewSymbol("end-key"))), lang.NewKeyword("doc"), "sc must be a sorted collection, test(s) one of <, <=, > or\n >=. Returns a seq of those entries with keys ek for\n which (test (.. sc comparator (compare ek key)) 0) is true", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5133), lang.NewKeyword("end-line"), int(5133))).(*lang.Symbol) + tmp0 := sym_subseq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_sc, sym_test, sym_key), lang.NewVector(sym_sc, sym_start_DASH_test, sym_start_DASH_key, sym_end_DASH_test, sym_end_DASH_key)), kw_doc, "sc must be a sorted collection, test(s) one of <, <=, > or\n >=. Returns a seq of those entries with keys ek for\n which (test (.. sc comparator (compare ek key)) 0) is true", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(5133), kw_end_DASH_line, int(5133))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -51507,15 +51112,15 @@ func LoadNS() { var tmp6 any { // let // let binding "include" - tmp7 := checkDerefVar(glojure_DOT_core_mk_bound_fn) + tmp7 := checkDerefVar(var_glojure_DOT_core_mk_DASH_bound_DASH_fn) tmp8 := lang.Apply(tmp7, []any{v3, v4, v5}) var v9 any = tmp8 _ = v9 var tmp10 any - tmp11 := checkDerefVar(glojure_DOT_core__GT_) - tmp12 := checkDerefVar(glojure_DOT_core__GT__EQ_) + tmp11 := checkDerefVar(var_glojure_DOT_core__GT_) + tmp12 := checkDerefVar(var_glojure_DOT_core__GT__EQ_) tmp13 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{tmp11, tmp12})) - tmp14 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5141), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5141), lang.NewKeyword("end-column"), int(17)) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5141), kw_column, int(11), kw_end_DASH_line, int(5141), kw_end_DASH_column, int(17)) tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) if err != nil { panic(err) @@ -51540,7 +51145,7 @@ func LoadNS() { var v23 any = v20 _ = v23 // let binding "e" - tmp24 := checkDerefVar(glojure_DOT_core_nth) + tmp24 := checkDerefVar(var_glojure_DOT_core_nth) tmp25 := lang.Apply(tmp24, []any{v23, int64(0), nil}) var v26 any = tmp25 _ = v26 @@ -51552,7 +51157,7 @@ func LoadNS() { if lang.IsTruthy(tmp29) { tmp28 = v27 } else { - tmp30 := checkDerefVar(glojure_DOT_core_next) + tmp30 := checkDerefVar(var_glojure_DOT_core_next) tmp31 := lang.Apply(tmp30, []any{v27}) tmp28 = tmp31 } @@ -51565,7 +51170,7 @@ func LoadNS() { } // end let tmp10 = tmp17 } else { - tmp18 := checkDerefVar(glojure_DOT_core_take_while) + tmp18 := checkDerefVar(var_glojure_DOT_core_take_DASH_while) tmp19, _ := lang.FieldOrMethod(v3, "seq") if reflect.TypeOf(tmp19).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("seq is not a function"))) @@ -51606,24 +51211,24 @@ func LoadNS() { var v14 any = v11 _ = v14 // let binding "e" - tmp15 := checkDerefVar(glojure_DOT_core_nth) + tmp15 := checkDerefVar(var_glojure_DOT_core_nth) tmp16 := lang.Apply(tmp15, []any{v14, int64(0), nil}) var v17 any = tmp16 _ = v17 // let binding "s" var v18 any = v14 _ = v18 - tmp19 := checkDerefVar(glojure_DOT_core_take_while) - tmp20 := checkDerefVar(glojure_DOT_core_mk_bound_fn) + tmp19 := checkDerefVar(var_glojure_DOT_core_take_DASH_while) + tmp20 := checkDerefVar(var_glojure_DOT_core_mk_DASH_bound_DASH_fn) tmp21 := lang.Apply(tmp20, []any{v3, v6, v7}) var tmp22 any - tmp23 := checkDerefVar(glojure_DOT_core_mk_bound_fn) + tmp23 := checkDerefVar(var_glojure_DOT_core_mk_DASH_bound_DASH_fn) tmp24 := lang.Apply(tmp23, []any{v3, v4, v5}) tmp25 := lang.Apply(tmp24, []any{v17}) if lang.IsTruthy(tmp25) { tmp22 = v18 } else { - tmp26 := checkDerefVar(glojure_DOT_core_next) + tmp26 := checkDerefVar(var_glojure_DOT_core_next) tmp27 := lang.Apply(tmp26, []any{v18}) tmp22 = tmp27 } @@ -51637,10 +51242,11 @@ func LoadNS() { } // end let return tmp8 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -51648,7 +51254,7 @@ func LoadNS() { } // subvec { - tmp0 := lang.NewSymbol("subvec").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("v"), lang.NewSymbol("start")), lang.NewVector(lang.NewSymbol("v"), lang.NewSymbol("start"), lang.NewSymbol("end"))), lang.NewKeyword("doc"), "Returns a persistent vector of the items in vector from\n start (inclusive) to end (exclusive). If end is not supplied,\n defaults to (count vector). This operation is O(1) and very fast, as\n the resulting vector shares structure with the original and no\n trimming is done.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3819), lang.NewKeyword("end-line"), int(3819))).(*lang.Symbol) + tmp0 := sym_subvec.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_v, sym_start), lang.NewVector(sym_v, sym_start, sym_end)), kw_doc, "Returns a persistent vector of the items in vector from\n start (inclusive) to end (exclusive). If end is not supplied,\n defaults to (count vector). This operation is O(1) and very fast, as\n the resulting vector shares structure with the original and no\n trimming is done.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(3819), kw_end_DASH_line, int(3819))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -51657,8 +51263,8 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_subvec) - tmp6 := checkDerefVar(glojure_DOT_core_count) + tmp5 := checkDerefVar(var_glojure_DOT_core_subvec) + tmp6 := checkDerefVar(var_glojure_DOT_core_count) tmp7 := lang.Apply(tmp6, []any{v3}) tmp8 := lang.Apply(tmp5, []any{v3, v4, tmp7}) return tmp8 @@ -51676,10 +51282,11 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v3, v4, v5}) return tmp7 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -51687,19 +51294,17 @@ func LoadNS() { } // supers { - tmp0 := lang.NewSymbol("supers").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("class"))), lang.NewKeyword("doc"), "Returns the immediate and indirect superclasses and interfaces of c, if any", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5532), lang.NewKeyword("end-line"), int(5532))).(*lang.Symbol) + tmp0 := sym_supers.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_class)), kw_doc, "Returns the immediate and indirect superclasses and interfaces of c, if any", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(5532), kw_end_DASH_line, int(5532))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any { // let // let binding "ret" - tmp5 := checkDerefVar(glojure_DOT_core_set) - tmp6 := checkDerefVar(glojure_DOT_core_bases) + tmp5 := checkDerefVar(var_glojure_DOT_core_set) + tmp6 := checkDerefVar(var_glojure_DOT_core_bases) tmp7 := lang.Apply(tmp6, []any{v3}) tmp8 := lang.Apply(tmp5, []any{tmp7}) var v9 any = tmp8 @@ -51709,26 +51314,26 @@ func LoadNS() { _ = v10 for { var tmp11 any - tmp12 := checkDerefVar(glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := lang.Apply(tmp12, []any{v10}) if lang.IsTruthy(tmp13) { var tmp14 any { // let // let binding "c" - tmp15 := checkDerefVar(glojure_DOT_core_first) + tmp15 := checkDerefVar(var_glojure_DOT_core_first) tmp16 := lang.Apply(tmp15, []any{v10}) var v17 any = tmp16 _ = v17 // let binding "bs" - tmp18 := checkDerefVar(glojure_DOT_core_bases) + tmp18 := checkDerefVar(var_glojure_DOT_core_bases) tmp19 := lang.Apply(tmp18, []any{v17}) var v20 any = tmp19 _ = v20 - tmp22 := checkDerefVar(glojure_DOT_core_into1) + tmp22 := checkDerefVar(var_glojure_DOT_core_into1) tmp23 := lang.Apply(tmp22, []any{v9, v20}) var tmp21 any = tmp23 - tmp25 := checkDerefVar(glojure_DOT_core_into1) - tmp26 := checkDerefVar(glojure_DOT_core_disj) + tmp25 := checkDerefVar(var_glojure_DOT_core_into1) + tmp26 := checkDerefVar(var_glojure_DOT_core_disj) tmp27 := lang.Apply(tmp26, []any{v10, v17}) tmp28 := lang.Apply(tmp25, []any{tmp27, v20}) var tmp24 any = tmp28 @@ -51738,7 +51343,7 @@ func LoadNS() { } // end let tmp11 = tmp14 } else { - tmp15 := checkDerefVar(glojure_DOT_core_not_empty) + tmp15 := checkDerefVar(var_glojure_DOT_core_not_DASH_empty) tmp16 := lang.Apply(tmp15, []any{v9}) tmp11 = tmp16 } @@ -51748,7 +51353,7 @@ func LoadNS() { } // end let return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -51756,14 +51361,12 @@ func LoadNS() { } // swap! { - tmp0 := lang.NewSymbol("swap!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atom"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Atomically swaps the value of atom to be:\n (apply f current-value-of-atom args). Note that f may be called\n multiple times, and thus should be free of side effects. Returns\n the value that was swapped in.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2343), lang.NewKeyword("end-line"), int(2343))).(*lang.Symbol) + tmp0 := sym_swap_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_atom, sym_f, sym__AMP_, sym_args)), kw_doc, "Atomically swaps the value of atom to be:\n (apply f current-value-of-atom args). Note that f may be called\n multiple times, and thus should be free of side effects. Returns\n the value that was swapped in.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(2343), kw_end_DASH_line, int(2343))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -51778,7 +51381,7 @@ func LoadNS() { return tmp7 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -51786,14 +51389,12 @@ func LoadNS() { } // swap-vals! { - tmp0 := lang.NewSymbol("swap-vals!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("atom"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Atomically swaps the value of atom to be:\n (apply f current-value-of-atom args). Note that f may be called\n multiple times, and thus should be free of side effects.\n Returns [old new], the value of the atom before and after the swap.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2352), lang.NewKeyword("end-line"), int(2352))).(*lang.Symbol) + tmp0 := sym_swap_DASH_vals_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_atom, sym_f, sym__AMP_, sym_args)), kw_doc, "Atomically swaps the value of atom to be:\n (apply f current-value-of-atom args). Note that f may be called\n multiple times, and thus should be free of side effects.\n Returns [old new], the value of the atom before and after the swap.", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(2352), kw_end_DASH_line, int(2352))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -51808,7 +51409,7 @@ func LoadNS() { return tmp7 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -51817,7 +51418,7 @@ func LoadNS() { // symbol { tmp1 := reflect.TypeOf((*lang.Symbol)(nil)) - tmp0 := lang.NewSymbol("symbol").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name")), lang.NewVector(lang.NewSymbol("ns"), lang.NewSymbol("name"))), lang.NewKeyword("doc"), "Returns a Symbol with the given namespace and name. Arity-1 works\n on strings, keywords, and vars.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(584), lang.NewKeyword("end-line"), int(584))).(*lang.Symbol) + tmp0 := sym_symbol.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_name), lang.NewVector(sym_ns, sym_name)), kw_doc, "Returns a Symbol with the given namespace and name. Arity-1 works\n on strings, keywords, and vars.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(584), kw_end_DASH_line, int(584))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -51825,20 +51426,20 @@ func LoadNS() { v4 := args[0] _ = v4 var tmp5 any - tmp6 := checkDerefVar(glojure_DOT_core_symbol_QMARK_) + tmp6 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) tmp7 := lang.Apply(tmp6, []any{v4}) if lang.IsTruthy(tmp7) { tmp5 = v4 } else { var tmp8 any - tmp9 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp9 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp10 := lang.Apply(tmp9, []any{lang.Builtins["string"], v4}) if lang.IsTruthy(tmp10) { tmp11 := lang.Apply(lang.NewSymbol, []any{v4}) tmp8 = tmp11 } else { var tmp12 any - tmp13 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp13 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp14 := reflect.TypeOf((*lang.Var)(nil)) tmp15 := lang.Apply(tmp13, []any{tmp14, v4}) if lang.IsTruthy(tmp15) { @@ -51856,7 +51457,7 @@ func LoadNS() { tmp12 = tmp17 } else { var tmp18 any - tmp19 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp19 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp20 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() tmp21 := lang.Apply(tmp19, []any{tmp20, v4}) if lang.IsTruthy(tmp21) { @@ -51874,7 +51475,7 @@ func LoadNS() { tmp18 = tmp23 } else { var tmp24 any - if lang.IsTruthy(lang.NewKeyword("else")) { + if lang.IsTruthy(kw_else) { tmp25 := lang.Apply(lang.NewIllegalArgumentError, []any{"no conversion to symbol"}) panic(tmp25) } else { @@ -51896,11 +51497,12 @@ func LoadNS() { tmp6 := lang.Apply(lang.InternSymbol, []any{v4, v5}) return tmp6 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) tmp4 := reflect.TypeOf((*lang.Symbol)(nil)) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -51908,20 +51510,18 @@ func LoadNS() { } // symbol? { - tmp0 := lang.NewSymbol("symbol?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a Symbol", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(557), lang.NewKeyword("end-line"), int(557))).(*lang.Symbol) + tmp0 := sym_symbol_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a Symbol", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(557), kw_end_DASH_line, int(557))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp5 := reflect.TypeOf((*lang.Symbol)(nil)) tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -51929,14 +51529,12 @@ func LoadNS() { } // sync { - tmp0 := lang.NewSymbol("sync").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("flags-ignored-for-now"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "transaction-flags => TBD, pass nil for now\n\n Runs the exprs (in an implicit do) in a transaction that encompasses\n exprs and any nested calls. Starts a transaction if none is already\n running on this thread. Any uncaught exception will abort the\n transaction and flow out of sync. The exprs may be run more than\n once, but any effects on Refs will be atomic.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(2490), lang.NewKeyword("end-line"), int(2490))).(*lang.Symbol) + tmp0 := sym_sync.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_flags_DASH_ignored_DASH_for_DASH_now, sym__AMP_, sym_body)), kw_doc, "transaction-flags => TBD, pass nil for now\n\n Runs the exprs (in an implicit do) in a transaction that encompasses\n exprs and any nested calls. Starts a transaction if none is already\n running on this thread. Any uncaught exception will abort the\n transaction and flow out of sync. The exprs may be run more than\n once, but any effects on Refs will be atomic.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(11), kw_line, int(2490), kw_end_DASH_line, int(2490))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -51945,27 +51543,27 @@ func LoadNS() { _ = v5 var v6 any = lang.NewList(args[3:]...) _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_seq) - tmp8 := checkDerefVar(glojure_DOT_core_concat) - tmp9 := checkDerefVar(glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol(".")}) - tmp11 := checkDerefVar(glojure_DOT_core_list) - tmp12 := lang.Apply(tmp11, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.LockingTransaction")}) - tmp13 := checkDerefVar(glojure_DOT_core_list) - tmp14 := checkDerefVar(glojure_DOT_core_seq) - tmp15 := checkDerefVar(glojure_DOT_core_concat) - tmp16 := checkDerefVar(glojure_DOT_core_list) - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("glojure.core/RunInTransaction")}) - tmp18 := checkDerefVar(glojure_DOT_core_list) - tmp19 := checkDerefVar(glojure_DOT_core_seq) - tmp20 := checkDerefVar(glojure_DOT_core_concat) - tmp21 := checkDerefVar(glojure_DOT_core_list) - tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("glojure.core/fn")}) - tmp23 := checkDerefVar(glojure_DOT_core_list) - tmp24 := checkDerefVar(glojure_DOT_core_apply) - tmp25 := checkDerefVar(glojure_DOT_core_vector) - tmp26 := checkDerefVar(glojure_DOT_core_seq) - tmp27 := checkDerefVar(glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_LockingTransaction}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{sym_glojure_DOT_core_SLASH_RunInTransaction}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := checkDerefVar(var_glojure_DOT_core_seq) + tmp20 := checkDerefVar(var_glojure_DOT_core_concat) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{sym_glojure_DOT_core_SLASH_fn}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_apply) + tmp25 := checkDerefVar(var_glojure_DOT_core_vector) + tmp26 := checkDerefVar(var_glojure_DOT_core_seq) + tmp27 := checkDerefVar(var_glojure_DOT_core_concat) tmp28 := lang.Apply(tmp27, nil) tmp29 := lang.Apply(tmp26, []any{tmp28}) tmp30 := lang.Apply(tmp24, []any{tmp25, tmp29}) @@ -51981,7 +51579,7 @@ func LoadNS() { return tmp39 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -51989,7 +51587,7 @@ func LoadNS() { } // system-newline { - tmp0 := lang.NewSymbol("system-newline").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(3695), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(3695), lang.NewKeyword("end-column"), int(40), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym_system_DASH_newline.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(3695), kw_column, int(6), kw_end_DASH_line, int(3695), kw_end_DASH_column, int(40), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) tmp1 := ns.InternWithValue(tmp0, "\n", true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -51997,12 +51595,10 @@ func LoadNS() { } // tagged-literal { - tmp0 := lang.NewSymbol("tagged-literal").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag"), lang.NewSymbol("form"))), lang.NewKeyword("doc"), "Construct a data representation of a tagged literal from a\n tag symbol and a form.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7769), lang.NewKeyword("end-line"), int(7769))).(*lang.Symbol) + tmp0 := sym_tagged_DASH_literal.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_tag, sym_form)), kw_doc, "Construct a data representation of a tagged literal from a\n tag symbol and a form.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(7769), kw_end_DASH_line, int(7769))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -52010,7 +51606,7 @@ func LoadNS() { tmp5 := lang.Apply(nil, []any{v3, v4}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -52018,19 +51614,17 @@ func LoadNS() { } // tagged-literal? { - tmp0 := lang.NewSymbol("tagged-literal?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("value"))), lang.NewKeyword("doc"), "Return true if the value is the data representation of a tagged literal", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7763), lang.NewKeyword("end-line"), int(7763))).(*lang.Symbol) + tmp0 := sym_tagged_DASH_literal_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_value)), kw_doc, "Return true if the value is the data representation of a tagged literal", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(7763), kw_end_DASH_line, int(7763))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp5 := lang.Apply(tmp4, []any{nil, v3}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -52038,7 +51632,7 @@ func LoadNS() { } // take { - tmp0 := lang.NewSymbol("take").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the first n items in coll, or all items if\n there are fewer than n. Returns a stateful transducer when\n no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2853), lang.NewKeyword("end-line"), int(2853))).(*lang.Symbol) + tmp0 := sym_take.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n), lang.NewVector(sym_n, sym_coll)), kw_doc, "Returns a lazy sequence of the first n items in coll, or all items if\n there are fewer than n. Returns a stateful transducer when\n no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(2853), kw_end_DASH_line, int(2853))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -52047,15 +51641,13 @@ func LoadNS() { _ = v3 var tmp4 lang.FnFunc tmp4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v5 := args[0] _ = v5 var tmp6 any { // let // let binding "nv" - tmp7 := checkDerefVar(glojure_DOT_core_volatile_BANG_) + tmp7 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) tmp8 := lang.Apply(tmp7, []any{v3}) var v9 any = tmp8 _ = v9 @@ -52078,12 +51670,12 @@ func LoadNS() { var tmp13 any { // let // let binding "n" - tmp14 := checkDerefVar(glojure_DOT_core_deref) + tmp14 := checkDerefVar(var_glojure_DOT_core_deref) tmp15 := lang.Apply(tmp14, []any{v9}) var v16 any = tmp15 _ = v16 // let binding "nn" - tmp17 := checkDerefVar(glojure_DOT_core_dec) + tmp17 := checkDerefVar(var_glojure_DOT_core_dec) tmp18, ok := lang.FieldOrMethod(v9, "Deref") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v9, "Deref"))) @@ -52105,7 +51697,7 @@ func LoadNS() { _ = v23 // let binding "result" var tmp24 any - tmp25 := checkDerefVar(glojure_DOT_core_pos_QMARK_) + tmp25 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) tmp26 := lang.Apply(tmp25, []any{v16}) if lang.IsTruthy(tmp26) { tmp27 := lang.Apply(v5, []any{v11, v12}) @@ -52116,12 +51708,12 @@ func LoadNS() { var v28 any = tmp24 _ = v28 var tmp29 any - tmp30 := checkDerefVar(glojure_DOT_core_not) - tmp31 := checkDerefVar(glojure_DOT_core_pos_QMARK_) + tmp30 := checkDerefVar(var_glojure_DOT_core_not) + tmp31 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) tmp32 := lang.Apply(tmp31, []any{v23}) tmp33 := lang.Apply(tmp30, []any{tmp32}) if lang.IsTruthy(tmp33) { - tmp34 := checkDerefVar(glojure_DOT_core_ensure_reduced) + tmp34 := checkDerefVar(var_glojure_DOT_core_ensure_DASH_reduced) tmp35 := lang.Apply(tmp34, []any{v28}) tmp29 = tmp35 } else { @@ -52131,10 +51723,11 @@ func LoadNS() { } // end let return tmp13 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2862), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(2873), lang.NewKeyword("end-column"), int(28)) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2862), kw_column, int(10), kw_end_DASH_line, int(2873), kw_end_DASH_column, int(28)) tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) if err != nil { panic(err) @@ -52143,7 +51736,7 @@ func LoadNS() { } // end let return tmp6 }) - tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2860), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2873), lang.NewKeyword("end-column"), int(30)) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2860), kw_column, int(6), kw_end_DASH_line, int(2873), kw_end_DASH_column, int(30)) tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) if err != nil { panic(err) @@ -52156,17 +51749,15 @@ func LoadNS() { _ = v4 var tmp5 lang.FnFunc tmp5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var tmp6 any - tmp7 := checkDerefVar(glojure_DOT_core_pos_QMARK_) + tmp7 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) tmp8 := lang.Apply(tmp7, []any{v3}) if lang.IsTruthy(tmp8) { var tmp9 any { // let // let binding "temp__0__auto__" - tmp10 := checkDerefVar(glojure_DOT_core_seq) + tmp10 := checkDerefVar(var_glojure_DOT_core_seq) tmp11 := lang.Apply(tmp10, []any{v4}) var v12 any = tmp11 _ = v12 @@ -52177,13 +51768,13 @@ func LoadNS() { // let binding "s" var v15 any = v12 _ = v15 - tmp16 := checkDerefVar(glojure_DOT_core_cons) - tmp17 := checkDerefVar(glojure_DOT_core_first) + tmp16 := checkDerefVar(var_glojure_DOT_core_cons) + tmp17 := checkDerefVar(var_glojure_DOT_core_first) tmp18 := lang.Apply(tmp17, []any{v15}) - tmp19 := checkDerefVar(glojure_DOT_core_take) - tmp20 := checkDerefVar(glojure_DOT_core_dec) + tmp19 := checkDerefVar(var_glojure_DOT_core_take) + tmp20 := checkDerefVar(var_glojure_DOT_core_dec) tmp21 := lang.Apply(tmp20, []any{v3}) - tmp22 := checkDerefVar(glojure_DOT_core_rest) + tmp22 := checkDerefVar(var_glojure_DOT_core_rest) tmp23 := lang.Apply(tmp22, []any{v15}) tmp24 := lang.Apply(tmp19, []any{tmp21, tmp23}) tmp25 := lang.Apply(tmp16, []any{tmp18, tmp24}) @@ -52202,10 +51793,11 @@ func LoadNS() { tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) return tmp6 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -52213,12 +51805,10 @@ func LoadNS() { } // take-last { - tmp0 := lang.NewSymbol("take-last").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a seq of the last n items in coll. Depending on the type\n of coll may be no better than linear time. For vectors, see also subvec.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2939), lang.NewKeyword("end-line"), int(2939))).(*lang.Symbol) + tmp0 := sym_take_DASH_last.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n, sym_coll)), kw_doc, "Returns a seq of the last n items in coll. Depending on the type\n of coll may be no better than linear time. For vectors, see also subvec.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(2939), kw_end_DASH_line, int(2939))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -52226,13 +51816,13 @@ func LoadNS() { var tmp5 any { // let // let binding "s" - tmp6 := checkDerefVar(glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) tmp7 := lang.Apply(tmp6, []any{v4}) var v8 any = tmp7 _ = v8 // let binding "lead" - tmp9 := checkDerefVar(glojure_DOT_core_seq) - tmp10 := checkDerefVar(glojure_DOT_core_drop) + tmp9 := checkDerefVar(var_glojure_DOT_core_seq) + tmp10 := checkDerefVar(var_glojure_DOT_core_drop) tmp11 := lang.Apply(tmp10, []any{v3, v4}) tmp12 := lang.Apply(tmp9, []any{tmp11}) var v13 any = tmp12 @@ -52240,10 +51830,10 @@ func LoadNS() { for { var tmp14 any if lang.IsTruthy(v13) { - tmp16 := checkDerefVar(glojure_DOT_core_next) + tmp16 := checkDerefVar(var_glojure_DOT_core_next) tmp17 := lang.Apply(tmp16, []any{v8}) var tmp15 any = tmp17 - tmp19 := checkDerefVar(glojure_DOT_core_next) + tmp19 := checkDerefVar(var_glojure_DOT_core_next) tmp20 := lang.Apply(tmp19, []any{v13}) var tmp18 any = tmp20 v8 = tmp15 @@ -52258,7 +51848,7 @@ func LoadNS() { } // end let return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -52266,7 +51856,7 @@ func LoadNS() { } // take-nth { - tmp0 := lang.NewSymbol("take-nth").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n")), lang.NewVector(lang.NewSymbol("n"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy seq of every nth item in coll. Returns a stateful\n transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4287), lang.NewKeyword("end-line"), int(4287))).(*lang.Symbol) + tmp0 := sym_take_DASH_nth.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n), lang.NewVector(sym_n, sym_coll)), kw_doc, "Returns a lazy seq of every nth item in coll. Returns a stateful\n transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(4287), kw_end_DASH_line, int(4287))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -52275,15 +51865,13 @@ func LoadNS() { _ = v3 var tmp4 lang.FnFunc tmp4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v5 := args[0] _ = v5 var tmp6 any { // let // let binding "iv" - tmp7 := checkDerefVar(glojure_DOT_core_volatile_BANG_) + tmp7 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) tmp8 := lang.Apply(tmp7, []any{int64(-1)}) var v9 any = tmp8 _ = v9 @@ -52306,7 +51894,7 @@ func LoadNS() { var tmp13 any { // let // let binding "i" - tmp14 := checkDerefVar(glojure_DOT_core_inc) + tmp14 := checkDerefVar(var_glojure_DOT_core_inc) tmp15, ok := lang.FieldOrMethod(v9, "Deref") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v9, "Deref"))) @@ -52327,8 +51915,8 @@ func LoadNS() { var v20 any = tmp19 _ = v20 var tmp21 any - tmp22 := checkDerefVar(glojure_DOT_core_zero_QMARK_) - tmp23 := checkDerefVar(glojure_DOT_core_rem) + tmp22 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) + tmp23 := checkDerefVar(var_glojure_DOT_core_rem) tmp24 := lang.Apply(tmp23, []any{v20, v3}) tmp25 := lang.Apply(tmp22, []any{tmp24}) if lang.IsTruthy(tmp25) { @@ -52341,10 +51929,11 @@ func LoadNS() { } // end let return tmp13 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4295), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(4302), lang.NewKeyword("end-column"), int(28)) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4295), kw_column, int(10), kw_end_DASH_line, int(4302), kw_end_DASH_column, int(28)) tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) if err != nil { panic(err) @@ -52353,7 +51942,7 @@ func LoadNS() { } // end let return tmp6 }) - tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4293), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(4302), lang.NewKeyword("end-column"), int(30)) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4293), kw_column, int(6), kw_end_DASH_line, int(4302), kw_end_DASH_column, int(30)) tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) if err != nil { panic(err) @@ -52366,13 +51955,11 @@ func LoadNS() { _ = v4 var tmp5 lang.FnFunc tmp5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var tmp6 any { // let // let binding "temp__0__auto__" - tmp7 := checkDerefVar(glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) tmp8 := lang.Apply(tmp7, []any{v4}) var v9 any = tmp8 _ = v9 @@ -52383,11 +51970,11 @@ func LoadNS() { // let binding "s" var v12 any = v9 _ = v12 - tmp13 := checkDerefVar(glojure_DOT_core_cons) - tmp14 := checkDerefVar(glojure_DOT_core_first) + tmp13 := checkDerefVar(var_glojure_DOT_core_cons) + tmp14 := checkDerefVar(var_glojure_DOT_core_first) tmp15 := lang.Apply(tmp14, []any{v12}) - tmp16 := checkDerefVar(glojure_DOT_core_take_nth) - tmp17 := checkDerefVar(glojure_DOT_core_drop) + tmp16 := checkDerefVar(var_glojure_DOT_core_take_DASH_nth) + tmp17 := checkDerefVar(var_glojure_DOT_core_drop) tmp18 := lang.Apply(tmp17, []any{v3, v12}) tmp19 := lang.Apply(tmp16, []any{v3, tmp18}) tmp20 := lang.Apply(tmp13, []any{tmp15, tmp19}) @@ -52403,10 +51990,11 @@ func LoadNS() { tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) return tmp6 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -52414,7 +52002,7 @@ func LoadNS() { } // take-while { - tmp0 := lang.NewSymbol("take-while").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred")), lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a lazy sequence of successive items from coll while\n (pred item) returns logical true. pred must be free of side-effects.\n Returns a transducer when no collection is provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2880), lang.NewKeyword("end-line"), int(2880))).(*lang.Symbol) + tmp0 := sym_take_DASH_while.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred), lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns a lazy sequence of successive items from coll while\n (pred item) returns logical true. pred must be free of side-effects.\n Returns a transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(2880), kw_end_DASH_line, int(2880))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -52423,9 +52011,7 @@ func LoadNS() { _ = v3 var tmp4 lang.FnFunc tmp4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v5 := args[0] _ = v5 var tmp6 lang.FnFunc @@ -52450,23 +52036,24 @@ func LoadNS() { tmp11 := lang.Apply(v5, []any{v7, v8}) tmp9 = tmp11 } else { - tmp12 := checkDerefVar(glojure_DOT_core_reduced) + tmp12 := checkDerefVar(var_glojure_DOT_core_reduced) tmp13 := lang.Apply(tmp12, []any{v7}) tmp9 = tmp13 } return tmp9 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2888), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(2894), lang.NewKeyword("end-column"), int(33)) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2888), kw_column, int(8), kw_end_DASH_line, int(2894), kw_end_DASH_column, int(33)) tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) if err != nil { panic(err) } return tmp8 }) - tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2887), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(2894), lang.NewKeyword("end-column"), int(34)) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2887), kw_column, int(6), kw_end_DASH_line, int(2894), kw_end_DASH_column, int(34)) tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) if err != nil { panic(err) @@ -52479,13 +52066,11 @@ func LoadNS() { _ = v4 var tmp5 lang.FnFunc tmp5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var tmp6 any { // let // let binding "temp__0__auto__" - tmp7 := checkDerefVar(glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) tmp8 := lang.Apply(tmp7, []any{v4}) var v9 any = tmp8 _ = v9 @@ -52497,15 +52082,15 @@ func LoadNS() { var v12 any = v9 _ = v12 var tmp13 any - tmp14 := checkDerefVar(glojure_DOT_core_first) + tmp14 := checkDerefVar(var_glojure_DOT_core_first) tmp15 := lang.Apply(tmp14, []any{v12}) tmp16 := lang.Apply(v3, []any{tmp15}) if lang.IsTruthy(tmp16) { - tmp17 := checkDerefVar(glojure_DOT_core_cons) - tmp18 := checkDerefVar(glojure_DOT_core_first) + tmp17 := checkDerefVar(var_glojure_DOT_core_cons) + tmp18 := checkDerefVar(var_glojure_DOT_core_first) tmp19 := lang.Apply(tmp18, []any{v12}) - tmp20 := checkDerefVar(glojure_DOT_core_take_while) - tmp21 := checkDerefVar(glojure_DOT_core_rest) + tmp20 := checkDerefVar(var_glojure_DOT_core_take_DASH_while) + tmp21 := checkDerefVar(var_glojure_DOT_core_rest) tmp22 := lang.Apply(tmp21, []any{v12}) tmp23 := lang.Apply(tmp20, []any{v3, tmp22}) tmp24 := lang.Apply(tmp17, []any{tmp19, tmp23}) @@ -52524,10 +52109,11 @@ func LoadNS() { tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) return tmp6 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -52535,7 +52121,7 @@ func LoadNS() { } // tapset { - tmp0 := lang.NewSymbol("tapset").WithMeta(lang.NewMap(lang.NewKeyword("private"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7882), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(7882), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")))).(*lang.Symbol) + tmp0 := sym_tapset.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(7882), kw_column, int(10), kw_end_DASH_line, int(7882), kw_end_DASH_column, int(25), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) tmp2 := lang.NewAtom(lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{}))) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { @@ -52544,35 +52130,33 @@ func LoadNS() { } // test { - tmp0 := lang.NewSymbol("test").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("v"))), lang.NewKeyword("doc"), "test [v] finds fn at key :test in var metadata and calls it,\n presuming failure will throw exception", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4853), lang.NewKeyword("end-line"), int(4853))).(*lang.Symbol) + tmp0 := sym_test.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_v)), kw_doc, "test [v] finds fn at key :test in var metadata and calls it,\n presuming failure will throw exception", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(4853), kw_end_DASH_line, int(4853))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any { // let // let binding "f" - tmp5 := checkDerefVar(glojure_DOT_core_meta) + tmp5 := checkDerefVar(var_glojure_DOT_core_meta) tmp6 := lang.Apply(tmp5, []any{v3}) - tmp7 := lang.Apply(lang.NewKeyword("test"), []any{tmp6}) + tmp7 := lang.Apply(kw_test, []any{tmp6}) var v8 any = tmp7 _ = v8 var tmp9 any if lang.IsTruthy(v8) { tmp10 := lang.Apply(v8, nil) _ = tmp10 - tmp9 = lang.NewKeyword("ok") + tmp9 = kw_ok } else { - tmp9 = lang.NewKeyword("no-test") + tmp9 = kw_no_DASH_test } tmp4 = tmp9 } // end let return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -52580,16 +52164,14 @@ func LoadNS() { } // the-ns { - tmp0 := lang.NewSymbol("the-ns").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "If passed a namespace, returns it. Else, when passed a symbol,\n returns the namespace named by it, throwing an exception if not\n found.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4152), lang.NewKeyword("end-line"), int(4152))).(*lang.Symbol) + tmp0 := sym_the_DASH_ns.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "If passed a namespace, returns it. Else, when passed a symbol,\n returns the namespace named by it, throwing an exception if not\n found.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(4152), kw_end_DASH_line, int(4152))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any - tmp5 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp6 := reflect.TypeOf((*lang.Namespace)(nil)) tmp7 := lang.Apply(tmp5, []any{tmp6, v3}) if lang.IsTruthy(tmp7) { @@ -52598,7 +52180,7 @@ func LoadNS() { var tmp8 any { // let // let binding "or__0__auto__" - tmp9 := checkDerefVar(glojure_DOT_core_find_ns) + tmp9 := checkDerefVar(var_glojure_DOT_core_find_DASH_ns) tmp10 := lang.Apply(tmp9, []any{v3}) var v11 any = tmp10 _ = v11 @@ -52606,7 +52188,7 @@ func LoadNS() { if lang.IsTruthy(v11) { tmp12 = v11 } else { - tmp13 := checkDerefVar(glojure_DOT_core_str) + tmp13 := checkDerefVar(var_glojure_DOT_core_str) tmp14 := lang.Apply(tmp13, []any{"No namespace: ", v3, " found"}) tmp15 := lang.Apply(lang.NewError, []any{tmp14}) panic(tmp15) @@ -52617,7 +52199,7 @@ func LoadNS() { } return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -52625,22 +52207,18 @@ func LoadNS() { } // thread-bound? { - tmp0 := lang.NewSymbol("thread-bound?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("vars"))), lang.NewKeyword("doc"), "Returns true if all of the vars provided as arguments have thread-local bindings.\n Implies that set!'ing the provided vars will succeed. Returns true if no vars are provided.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.2", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5499), lang.NewKeyword("end-line"), int(5499))).(*lang.Symbol) + tmp0 := sym_thread_DASH_bound_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_vars)), kw_doc, "Returns true if all of the vars provided as arguments have thread-local bindings.\n Implies that set!'ing the provided vars will succeed. Returns true if no vars are provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(5499), kw_end_DASH_line, int(5499))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_every_QMARK_) + tmp4 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) var tmp5 lang.FnFunc tmp5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v6 := args[0] _ = v6 tmp7, ok := lang.FieldOrMethod(v6, "getThreadBinding") @@ -52656,7 +52234,7 @@ func LoadNS() { } return tmp8 }) - tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5505), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5505), lang.NewKeyword("end-column"), int(78)) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5505), kw_column, int(11), kw_end_DASH_line, int(5505), kw_end_DASH_column, int(78)) tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) if err != nil { panic(err) @@ -52665,7 +52243,7 @@ func LoadNS() { return tmp8 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -52673,14 +52251,12 @@ func LoadNS() { } // throw-if { - tmp0 := lang.NewSymbol("throw-if").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("pred"), lang.NewSymbol("fmt"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Throws a CompilerException with a message if pred is true", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(8), lang.NewKeyword("line"), int(5832), lang.NewKeyword("end-line"), int(5832), lang.NewKeyword("private"), true)).(*lang.Symbol) + tmp0 := sym_throw_DASH_if.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred, sym_fmt, sym__AMP_, sym_args)), kw_doc, "Throws a CompilerException with a message if pred is true", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(8), kw_line, int(5832), kw_end_DASH_line, int(5832), kw_private, true)).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -52692,8 +52268,8 @@ func LoadNS() { var tmp7 any { // let // let binding "message" - tmp8 := checkDerefVar(glojure_DOT_core_apply) - tmp9 := checkDerefVar(glojure_DOT_core_format) + tmp8 := checkDerefVar(var_glojure_DOT_core_apply) + tmp9 := checkDerefVar(var_glojure_DOT_core_format) tmp10 := lang.Apply(tmp8, []any{tmp9, v4, v5}) var v11 any = tmp10 _ = v11 @@ -52718,12 +52294,10 @@ func LoadNS() { // let binding "boring?" var tmp17 lang.FnFunc tmp17 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v18 := args[0] _ = v18 - tmp19 := checkDerefVar(glojure_DOT_core_not_EQ_) + tmp19 := checkDerefVar(var_glojure_DOT_core_not_EQ_) tmp20, ok := lang.FieldOrMethod(v18, "getMethodName") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v18, "getMethodName"))) @@ -52738,7 +52312,7 @@ func LoadNS() { tmp22 := lang.Apply(tmp19, []any{tmp21, "doInvoke"}) return tmp22 }) - tmp18 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5839), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(5839), lang.NewKeyword("end-column"), int(74)) + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5839), kw_column, int(19), kw_end_DASH_line, int(5839), kw_end_DASH_column, int(74)) tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) if err != nil { panic(err) @@ -52746,9 +52320,9 @@ func LoadNS() { var v20 any = tmp19 _ = v20 // let binding "trace" - tmp21 := checkDerefVar(glojure_DOT_core_into_array) - tmp22 := checkDerefVar(glojure_DOT_core_drop) - tmp23 := checkDerefVar(glojure_DOT_core_drop_while) + tmp21 := checkDerefVar(var_glojure_DOT_core_into_DASH_array) + tmp22 := checkDerefVar(var_glojure_DOT_core_drop) + tmp23 := checkDerefVar(var_glojure_DOT_core_drop_DASH_while) tmp24 := lang.Apply(tmp23, []any{v20, v16}) tmp25 := lang.Apply(tmp22, []any{int64(2), tmp24}) tmp26 := lang.Apply(tmp21, []any{nil, tmp25}) @@ -52760,7 +52334,7 @@ func LoadNS() { } tmp29 := lang.Apply(tmp28, []any{v27}) _ = tmp29 - tmp30 := checkDerefVar(glojure_DOT_core__STAR_file_STAR_) + tmp30 := checkDerefVar(var_glojure_DOT_core__STAR_file_STAR_) tmp31, ok := lang.FieldOrMethod(nil, "Deref") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "Deref"))) @@ -52792,7 +52366,7 @@ func LoadNS() { return tmp6 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -52800,110 +52374,108 @@ func LoadNS() { } // time { - tmp0 := lang.NewSymbol("time").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("expr"))), lang.NewKeyword("doc"), "Evaluates expr and prints the time it took. Returns the value of\n expr.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3885), lang.NewKeyword("end-line"), int(3885))).(*lang.Symbol) + tmp0 := sym_time.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_expr)), kw_doc, "Evaluates expr and prints the time it took. Returns the value of\n expr.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(11), kw_line, int(3885), kw_end_DASH_line, int(3885))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] _ = v4 v5 := args[2] _ = v5 - tmp6 := checkDerefVar(glojure_DOT_core_seq) - tmp7 := checkDerefVar(glojure_DOT_core_concat) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("glojure.core/let")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := checkDerefVar(glojure_DOT_core_apply) - tmp12 := checkDerefVar(glojure_DOT_core_vector) - tmp13 := checkDerefVar(glojure_DOT_core_seq) - tmp14 := checkDerefVar(glojure_DOT_core_concat) - tmp15 := checkDerefVar(glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("start__0__auto__")}) - tmp17 := checkDerefVar(glojure_DOT_core_list) - tmp18 := checkDerefVar(glojure_DOT_core_seq) - tmp19 := checkDerefVar(glojure_DOT_core_concat) - tmp20 := checkDerefVar(glojure_DOT_core_list) - tmp21 := lang.Apply(tmp20, []any{lang.NewSymbol(".UnixNano")}) - tmp22 := checkDerefVar(glojure_DOT_core_list) - tmp23 := checkDerefVar(glojure_DOT_core_seq) - tmp24 := checkDerefVar(glojure_DOT_core_concat) - tmp25 := checkDerefVar(glojure_DOT_core_list) - tmp26 := lang.Apply(tmp25, []any{lang.NewSymbol("time.Now")}) + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_let}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + tmp12 := checkDerefVar(var_glojure_DOT_core_vector) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_start__0__auto__}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{sym__DOT_UnixNano}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := checkDerefVar(var_glojure_DOT_core_seq) + tmp24 := checkDerefVar(var_glojure_DOT_core_concat) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := lang.Apply(tmp25, []any{sym_time_DOT_Now}) tmp27 := lang.Apply(tmp24, []any{tmp26}) tmp28 := lang.Apply(tmp23, []any{tmp27}) tmp29 := lang.Apply(tmp22, []any{tmp28}) tmp30 := lang.Apply(tmp19, []any{tmp21, tmp29}) tmp31 := lang.Apply(tmp18, []any{tmp30}) tmp32 := lang.Apply(tmp17, []any{tmp31}) - tmp33 := checkDerefVar(glojure_DOT_core_list) - tmp34 := lang.Apply(tmp33, []any{lang.NewSymbol("ret__1__auto__")}) - tmp35 := checkDerefVar(glojure_DOT_core_list) + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{sym_ret__1__auto__}) + tmp35 := checkDerefVar(var_glojure_DOT_core_list) tmp36 := lang.Apply(tmp35, []any{v5}) tmp37 := lang.Apply(tmp14, []any{tmp16, tmp32, tmp34, tmp36}) tmp38 := lang.Apply(tmp13, []any{tmp37}) tmp39 := lang.Apply(tmp11, []any{tmp12, tmp38}) tmp40 := lang.Apply(tmp10, []any{tmp39}) - tmp41 := checkDerefVar(glojure_DOT_core_list) - tmp42 := checkDerefVar(glojure_DOT_core_seq) - tmp43 := checkDerefVar(glojure_DOT_core_concat) - tmp44 := checkDerefVar(glojure_DOT_core_list) - tmp45 := lang.Apply(tmp44, []any{lang.NewSymbol("glojure.core/prn")}) - tmp46 := checkDerefVar(glojure_DOT_core_list) - tmp47 := checkDerefVar(glojure_DOT_core_seq) - tmp48 := checkDerefVar(glojure_DOT_core_concat) - tmp49 := checkDerefVar(glojure_DOT_core_list) - tmp50 := lang.Apply(tmp49, []any{lang.NewSymbol("glojure.core/str")}) - tmp51 := checkDerefVar(glojure_DOT_core_list) + tmp41 := checkDerefVar(var_glojure_DOT_core_list) + tmp42 := checkDerefVar(var_glojure_DOT_core_seq) + tmp43 := checkDerefVar(var_glojure_DOT_core_concat) + tmp44 := checkDerefVar(var_glojure_DOT_core_list) + tmp45 := lang.Apply(tmp44, []any{sym_glojure_DOT_core_SLASH_prn}) + tmp46 := checkDerefVar(var_glojure_DOT_core_list) + tmp47 := checkDerefVar(var_glojure_DOT_core_seq) + tmp48 := checkDerefVar(var_glojure_DOT_core_concat) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) + tmp50 := lang.Apply(tmp49, []any{sym_glojure_DOT_core_SLASH_str}) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) tmp52 := lang.Apply(tmp51, []any{"Elapsed time: "}) - tmp53 := checkDerefVar(glojure_DOT_core_list) - tmp54 := checkDerefVar(glojure_DOT_core_seq) - tmp55 := checkDerefVar(glojure_DOT_core_concat) - tmp56 := checkDerefVar(glojure_DOT_core_list) - tmp57 := lang.Apply(tmp56, []any{lang.NewSymbol("glojure.core//")}) - tmp58 := checkDerefVar(glojure_DOT_core_list) - tmp59 := checkDerefVar(glojure_DOT_core_seq) - tmp60 := checkDerefVar(glojure_DOT_core_concat) - tmp61 := checkDerefVar(glojure_DOT_core_list) - tmp62 := lang.Apply(tmp61, []any{lang.NewSymbol("glojure.core/double")}) - tmp63 := checkDerefVar(glojure_DOT_core_list) - tmp64 := checkDerefVar(glojure_DOT_core_seq) - tmp65 := checkDerefVar(glojure_DOT_core_concat) - tmp66 := checkDerefVar(glojure_DOT_core_list) - tmp67 := lang.Apply(tmp66, []any{lang.NewSymbol("glojure.core/-")}) - tmp68 := checkDerefVar(glojure_DOT_core_list) - tmp69 := checkDerefVar(glojure_DOT_core_seq) - tmp70 := checkDerefVar(glojure_DOT_core_concat) - tmp71 := checkDerefVar(glojure_DOT_core_list) - tmp72 := lang.Apply(tmp71, []any{lang.NewSymbol(".UnixNano")}) - tmp73 := checkDerefVar(glojure_DOT_core_list) - tmp74 := checkDerefVar(glojure_DOT_core_seq) - tmp75 := checkDerefVar(glojure_DOT_core_concat) - tmp76 := checkDerefVar(glojure_DOT_core_list) - tmp77 := lang.Apply(tmp76, []any{lang.NewSymbol("time.Now")}) + tmp53 := checkDerefVar(var_glojure_DOT_core_list) + tmp54 := checkDerefVar(var_glojure_DOT_core_seq) + tmp55 := checkDerefVar(var_glojure_DOT_core_concat) + tmp56 := checkDerefVar(var_glojure_DOT_core_list) + tmp57 := lang.Apply(tmp56, []any{sym_glojure_DOT_core_SLASH__SLASH_}) + tmp58 := checkDerefVar(var_glojure_DOT_core_list) + tmp59 := checkDerefVar(var_glojure_DOT_core_seq) + tmp60 := checkDerefVar(var_glojure_DOT_core_concat) + tmp61 := checkDerefVar(var_glojure_DOT_core_list) + tmp62 := lang.Apply(tmp61, []any{sym_glojure_DOT_core_SLASH_double}) + tmp63 := checkDerefVar(var_glojure_DOT_core_list) + tmp64 := checkDerefVar(var_glojure_DOT_core_seq) + tmp65 := checkDerefVar(var_glojure_DOT_core_concat) + tmp66 := checkDerefVar(var_glojure_DOT_core_list) + tmp67 := lang.Apply(tmp66, []any{sym_glojure_DOT_core_SLASH__DASH_}) + tmp68 := checkDerefVar(var_glojure_DOT_core_list) + tmp69 := checkDerefVar(var_glojure_DOT_core_seq) + tmp70 := checkDerefVar(var_glojure_DOT_core_concat) + tmp71 := checkDerefVar(var_glojure_DOT_core_list) + tmp72 := lang.Apply(tmp71, []any{sym__DOT_UnixNano}) + tmp73 := checkDerefVar(var_glojure_DOT_core_list) + tmp74 := checkDerefVar(var_glojure_DOT_core_seq) + tmp75 := checkDerefVar(var_glojure_DOT_core_concat) + tmp76 := checkDerefVar(var_glojure_DOT_core_list) + tmp77 := lang.Apply(tmp76, []any{sym_time_DOT_Now}) tmp78 := lang.Apply(tmp75, []any{tmp77}) tmp79 := lang.Apply(tmp74, []any{tmp78}) tmp80 := lang.Apply(tmp73, []any{tmp79}) tmp81 := lang.Apply(tmp70, []any{tmp72, tmp80}) tmp82 := lang.Apply(tmp69, []any{tmp81}) tmp83 := lang.Apply(tmp68, []any{tmp82}) - tmp84 := checkDerefVar(glojure_DOT_core_list) - tmp85 := lang.Apply(tmp84, []any{lang.NewSymbol("start__0__auto__")}) + tmp84 := checkDerefVar(var_glojure_DOT_core_list) + tmp85 := lang.Apply(tmp84, []any{sym_start__0__auto__}) tmp86 := lang.Apply(tmp65, []any{tmp67, tmp83, tmp85}) tmp87 := lang.Apply(tmp64, []any{tmp86}) tmp88 := lang.Apply(tmp63, []any{tmp87}) tmp89 := lang.Apply(tmp60, []any{tmp62, tmp88}) tmp90 := lang.Apply(tmp59, []any{tmp89}) tmp91 := lang.Apply(tmp58, []any{tmp90}) - tmp92 := checkDerefVar(glojure_DOT_core_list) + tmp92 := checkDerefVar(var_glojure_DOT_core_list) tmp93 := lang.Apply(tmp92, []any{float64(1e+06)}) tmp94 := lang.Apply(tmp55, []any{tmp57, tmp91, tmp93}) tmp95 := lang.Apply(tmp54, []any{tmp94}) tmp96 := lang.Apply(tmp53, []any{tmp95}) - tmp97 := checkDerefVar(glojure_DOT_core_list) + tmp97 := checkDerefVar(var_glojure_DOT_core_list) tmp98 := lang.Apply(tmp97, []any{" msecs"}) tmp99 := lang.Apply(tmp48, []any{tmp50, tmp52, tmp96, tmp98}) tmp100 := lang.Apply(tmp47, []any{tmp99}) @@ -52911,13 +52483,13 @@ func LoadNS() { tmp102 := lang.Apply(tmp43, []any{tmp45, tmp101}) tmp103 := lang.Apply(tmp42, []any{tmp102}) tmp104 := lang.Apply(tmp41, []any{tmp103}) - tmp105 := checkDerefVar(glojure_DOT_core_list) - tmp106 := lang.Apply(tmp105, []any{lang.NewSymbol("ret__1__auto__")}) + tmp105 := checkDerefVar(var_glojure_DOT_core_list) + tmp106 := lang.Apply(tmp105, []any{sym_ret__1__auto__}) tmp107 := lang.Apply(tmp7, []any{tmp9, tmp40, tmp104, tmp106}) tmp108 := lang.Apply(tmp6, []any{tmp107}) return tmp108 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -52925,12 +52497,10 @@ func LoadNS() { } // to-array { - tmp0 := lang.NewSymbol("to-array").WithMeta(lang.NewMap(lang.NewKeyword("tag"), "[Ljava.lang.Object;", lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns an array of Objects containing the contents of coll, which\n can be any Collection. Maps to java.util.Collection.toArray().", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(337), lang.NewKeyword("end-line"), int(337))).(*lang.Symbol) + tmp0 := sym_to_DASH_array.WithMeta(lang.NewMap(kw_tag, "[Ljava.lang.Object;", kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns an array of Objects containing the contents of coll, which\n can be any Collection. Maps to java.util.Collection.toArray().", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(337), kw_end_DASH_line, int(337))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4, _ := lang.FieldOrMethod(runtime7.RT, "ToArray") @@ -52940,7 +52510,7 @@ func LoadNS() { tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), "[Ljava.lang.Object;")).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, "[Ljava.lang.Object;")).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -52948,18 +52518,16 @@ func LoadNS() { } // to-array-2d { - tmp0 := lang.NewSymbol("to-array-2d").WithMeta(lang.NewMap(lang.NewKeyword("tag"), "[[Ljava.lang.Object;", lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a (potentially-ragged) 2-dimensional array of Objects\n containing the contents of coll, which can be any Collection of any\n Collection.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4002), lang.NewKeyword("end-line"), int(4002))).(*lang.Symbol) + tmp0 := sym_to_DASH_array_DASH_2d.WithMeta(lang.NewMap(kw_tag, "[[Ljava.lang.Object;", kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a (potentially-ragged) 2-dimensional array of Objects\n containing the contents of coll, which can be any Collection of any\n Collection.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(4002), kw_end_DASH_line, int(4002))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any { // let // let binding "ret" - tmp5 := checkDerefVar(glojure_DOT_core_make_array) + tmp5 := checkDerefVar(var_glojure_DOT_core_make_DASH_array) tmp6 := reflect.TypeOf((*reflect.Type)(nil)).Elem() tmp7, _ := lang.FieldOrMethod(tmp6, "forName") if reflect.TypeOf(tmp7).Kind() != reflect.Func { @@ -52980,24 +52548,24 @@ func LoadNS() { var v14 any = int64(0) _ = v14 // let binding "xs" - tmp15 := checkDerefVar(glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) tmp16 := lang.Apply(tmp15, []any{v3}) var v17 any = tmp16 _ = v17 for { var tmp18 any if lang.IsTruthy(v17) { - tmp19 := checkDerefVar(glojure_DOT_core_aset) - tmp20 := checkDerefVar(glojure_DOT_core_to_array) - tmp21 := checkDerefVar(glojure_DOT_core_first) + tmp19 := checkDerefVar(var_glojure_DOT_core_aset) + tmp20 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) + tmp21 := checkDerefVar(var_glojure_DOT_core_first) tmp22 := lang.Apply(tmp21, []any{v17}) tmp23 := lang.Apply(tmp20, []any{tmp22}) tmp24 := lang.Apply(tmp19, []any{v12, v14, tmp23}) _ = tmp24 - tmp26 := checkDerefVar(glojure_DOT_core_inc) + tmp26 := checkDerefVar(var_glojure_DOT_core_inc) tmp27 := lang.Apply(tmp26, []any{v14}) var tmp25 any = tmp27 - tmp29 := checkDerefVar(glojure_DOT_core_next) + tmp29 := checkDerefVar(var_glojure_DOT_core_next) tmp30 := lang.Apply(tmp29, []any{v17}) var tmp28 any = tmp30 v14 = tmp25 @@ -53014,7 +52582,7 @@ func LoadNS() { } // end let return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), "[[Ljava.lang.Object;")).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, "[[Ljava.lang.Object;")).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -53022,7 +52590,7 @@ func LoadNS() { } // trampoline { - tmp0 := lang.NewSymbol("trampoline").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "trampoline can be used to convert algorithms requiring mutual\n recursion without stack consumption. Calls f with supplied args, if\n any. If f returns a fn, calls that fn with no arguments, and\n continues to repeat, until the return value is not a fn, then\n returns that non-fn value. Note that if you want to return a fn as a\n final value, you must wrap it in some data structure and unpack it\n after trampoline returns.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6293), lang.NewKeyword("end-line"), int(6293))).(*lang.Symbol) + tmp0 := sym_trampoline.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym__AMP_, sym_args)), kw_doc, "trampoline can be used to convert algorithms requiring mutual\n recursion without stack consumption. Calls f with supplied args, if\n any. If f returns a fn, calls that fn with no arguments, and\n continues to repeat, until the return value is not a fn, then\n returns that non-fn value. Note that if you want to return a fn as a\n final value, you must wrap it in some data structure and unpack it\n after trampoline returns.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(6293), kw_end_DASH_line, int(6293))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -53037,7 +52605,7 @@ func LoadNS() { var v6 any = tmp5 _ = v6 var tmp7 any - tmp8 := checkDerefVar(glojure_DOT_core_fn_QMARK_) + tmp8 := checkDerefVar(var_glojure_DOT_core_fn_QMARK_) tmp9 := lang.Apply(tmp8, []any{v6}) if lang.IsTruthy(tmp9) { var tmp10 any = v6 @@ -53050,24 +52618,20 @@ func LoadNS() { } // end let return tmp4 default: - if len(args) < 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var v4 any = lang.NewList(args[1:]...) _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_trampoline) + tmp5 := checkDerefVar(var_glojure_DOT_core_trampoline) var tmp6 lang.FnFunc tmp6 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - tmp7 := checkDerefVar(glojure_DOT_core_apply) + checkArity(args, 0) + tmp7 := checkDerefVar(var_glojure_DOT_core_apply) tmp8 := lang.Apply(tmp7, []any{v3, v4}) return tmp8 }) - tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6309), lang.NewKeyword("column"), int(18), lang.NewKeyword("end-line"), int(6309), lang.NewKeyword("end-column"), int(32)) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6309), kw_column, int(18), kw_end_DASH_line, int(6309), kw_end_DASH_column, int(32)) tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) if err != nil { panic(err) @@ -53076,7 +52640,7 @@ func LoadNS() { return tmp9 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -53084,7 +52648,7 @@ func LoadNS() { } // transduce { - tmp0 := lang.NewSymbol("transduce").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("f"), lang.NewSymbol("coll")), lang.NewVector(lang.NewSymbol("xform"), lang.NewSymbol("f"), lang.NewSymbol("init"), lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "reduce with a transformation of f (xf). If init is not\n supplied, (f) will be called to produce it. f should be a reducing\n step function that accepts both 1 and 2 arguments, if it accepts\n only 2 you can add the arity-1 with 'completing'. Returns the result\n of applying (the transformed) xf to init and the first item in coll,\n then applying xf to that result and the 2nd item, etc. If coll\n contains no items, returns init and f is not called. Note that\n certain transforms may inject or skip items.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6905), lang.NewKeyword("end-line"), int(6905))).(*lang.Symbol) + tmp0 := sym_transduce.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xform, sym_f, sym_coll), lang.NewVector(sym_xform, sym_f, sym_init, sym_coll)), kw_doc, "reduce with a transformation of f (xf). If init is not\n supplied, (f) will be called to produce it. f should be a reducing\n step function that accepts both 1 and 2 arguments, if it accepts\n only 2 you can add the arity-1 with 'completing'. Returns the result\n of applying (the transformed) xf to init and the first item in coll,\n then applying xf to that result and the 2nd item, etc. If coll\n contains no items, returns init and f is not called. Note that\n certain transforms may inject or skip items.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(6905), kw_end_DASH_line, int(6905))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -53095,7 +52659,7 @@ func LoadNS() { _ = v4 v5 := args[2] _ = v5 - tmp6 := checkDerefVar(glojure_DOT_core_transduce) + tmp6 := checkDerefVar(var_glojure_DOT_core_transduce) tmp7 := lang.Apply(v4, nil) tmp8 := lang.Apply(tmp6, []any{v3, v4, tmp7, v5}) return tmp8 @@ -53116,7 +52680,7 @@ func LoadNS() { _ = v9 // let binding "ret" var tmp10 any - tmp11 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp11 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp12 := reflect.TypeOf((*lang.IReduceInit)(nil)).Elem() tmp13 := lang.Apply(tmp11, []any{tmp12, v6}) if lang.IsTruthy(tmp13) { @@ -53127,7 +52691,7 @@ func LoadNS() { tmp15 := lang.Apply(tmp14, []any{v9, v5}) tmp10 = tmp15 } else { - tmp16 := checkDerefVar(glojure_DOT_core_DOT_protocols_coll_reduce) + tmp16 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_coll_DASH_reduce) tmp17 := lang.Apply(tmp16, []any{v6, v9, v5}) tmp10 = tmp17 } @@ -53138,10 +52702,11 @@ func LoadNS() { } // end let return tmp7 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -53149,12 +52714,10 @@ func LoadNS() { } // transient { - tmp0 := lang.NewSymbol("transient").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Returns a new, transient version of the collection, in constant time.\n\n Transients support a parallel set of 'changing' operations, with similar names\n followed by ! - assoc!, conj! etc. These do the same things as their persistent\n counterparts except the return values are themselves transient.\n\n Note in particular that transients are not designed to be bashed in-place. You\n must capture and use the return value in the next call. In this way, they support\n the same code structure as the functional persistent code they replace.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3335), lang.NewKeyword("end-line"), int(3335))).(*lang.Symbol) + tmp0 := sym_transient.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a new, transient version of the collection, in constant time.\n\n Transients support a parallel set of 'changing' operations, with similar names\n followed by ! - assoc!, conj! etc. These do the same things as their persistent\n counterparts except the return values are themselves transient.\n\n Note in particular that transients are not designed to be bashed in-place. You\n must capture and use the return value in the next call. In this way, they support\n the same code structure as the functional persistent code they replace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(3335), kw_end_DASH_line, int(3335))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4, ok := lang.FieldOrMethod(v3, "AsTransient") @@ -53170,7 +52733,7 @@ func LoadNS() { } return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -53178,12 +52741,10 @@ func LoadNS() { } // tree-seq { - tmp0 := lang.NewSymbol("tree-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("branch?"), lang.NewSymbol("children"), lang.NewSymbol("root"))), lang.NewKeyword("doc"), "Returns a lazy sequence of the nodes in a tree, via a depth-first walk.\n branch? must be a fn of one arg that returns true if passed a node\n that can have children (but may not). children must be a fn of one\n arg that returns a sequence of the children. Will only be called on\n nodes for which branch? returns true. Root is the root node of the\n tree.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4955), lang.NewKeyword("end-line"), int(4955))).(*lang.Symbol) + tmp0 := sym_tree_DASH_seq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_branch_QMARK_, sym_children, sym_root)), kw_doc, "Returns a lazy sequence of the nodes in a tree, via a depth-first walk.\n branch? must be a fn of one arg that returns true if passed a node\n that can have children (but may not). children must be a fn of one\n arg that returns a sequence of the children. Will only be called on\n nodes for which branch? returns true. Root is the root node of the\n tree.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(4955), kw_end_DASH_line, int(4955))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -53197,21 +52758,17 @@ func LoadNS() { { // function walk var v8 lang.FnFunc tmp7 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v9 := args[0] _ = v9 var tmp10 lang.FnFunc tmp10 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - tmp11 := checkDerefVar(glojure_DOT_core_cons) + checkArity(args, 0) + tmp11 := checkDerefVar(var_glojure_DOT_core_cons) var tmp12 any tmp13 := lang.Apply(v3, []any{v9}) if lang.IsTruthy(tmp13) { - tmp14 := checkDerefVar(glojure_DOT_core_mapcat) + tmp14 := checkDerefVar(var_glojure_DOT_core_mapcat) tmp15 := lang.Apply(v4, []any{v9}) tmp16 := lang.Apply(tmp14, []any{v8, tmp15}) tmp12 = tmp16 @@ -53226,7 +52783,7 @@ func LoadNS() { v8 = tmp7 _ = v8 } - tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(4965), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(4969), lang.NewKeyword("end-column"), int(53)) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4965), kw_column, int(15), kw_end_DASH_line, int(4969), kw_end_DASH_column, int(53)) tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) if err != nil { panic(err) @@ -53238,7 +52795,7 @@ func LoadNS() { } // end let return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -53247,19 +52804,17 @@ func LoadNS() { // true? { tmp1 := reflect.TypeOf(false) - tmp0 := lang.NewSymbol("true?").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is the value true, false otherwise.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(511), lang.NewKeyword("end-line"), int(511))).(*lang.Symbol) + tmp0 := sym_true_QMARK_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x is the value true, false otherwise.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(511), kw_end_DASH_line, int(511))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 tmp5 := lang.Apply(lang.Identical, []any{v4, true}) return tmp5 }) tmp4 := reflect.TypeOf(false) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -53267,28 +52822,26 @@ func LoadNS() { } // type { - tmp0 := lang.NewSymbol("type").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns the :type metadata of x, or its Class if none", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3467), lang.NewKeyword("end-line"), int(3467))).(*lang.Symbol) + tmp0 := sym_type.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns the :type metadata of x, or its Class if none", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3467), kw_end_DASH_line, int(3467))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any { // let // let binding "or__0__auto__" - tmp5 := checkDerefVar(glojure_DOT_core_get) - tmp6 := checkDerefVar(glojure_DOT_core_meta) + tmp5 := checkDerefVar(var_glojure_DOT_core_get) + tmp6 := checkDerefVar(var_glojure_DOT_core_meta) tmp7 := lang.Apply(tmp6, []any{v3}) - tmp8 := lang.Apply(tmp5, []any{tmp7, lang.NewKeyword("type")}) + tmp8 := lang.Apply(tmp5, []any{tmp7, kw_type}) var v9 any = tmp8 _ = v9 var tmp10 any if lang.IsTruthy(v9) { tmp10 = v9 } else { - tmp11 := checkDerefVar(glojure_DOT_core_class) + tmp11 := checkDerefVar(var_glojure_DOT_core_class) tmp12 := lang.Apply(tmp11, []any{v3}) tmp10 = tmp12 } @@ -53296,7 +52849,7 @@ func LoadNS() { } // end let return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -53308,27 +52861,25 @@ func LoadNS() { { // function unchecked-add__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_seq) - tmp6 := checkDerefVar(glojure_DOT_core_concat) - tmp7 := checkDerefVar(glojure_DOT_core_list) - tmp8 := lang.Apply(tmp7, []any{lang.NewSymbol(".")}) - tmp9 := checkDerefVar(glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp11 := checkDerefVar(glojure_DOT_core_list) - tmp12 := checkDerefVar(glojure_DOT_core_seq) - tmp13 := checkDerefVar(glojure_DOT_core_concat) - tmp14 := checkDerefVar(glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("glojure.core/UncheckedAdd")}) - tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_UncheckedAdd}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) - tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) tmp19 := lang.Apply(tmp18, []any{v4}) tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) tmp21 := lang.Apply(tmp12, []any{tmp20}) @@ -53340,12 +52891,10 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("unchecked-add").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the sum of x and y, both long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1203), lang.NewKeyword("end-line"), int(1203))).(*lang.Symbol) + tmp0 := sym_unchecked_DASH_add.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Returns the sum of x and y, both long.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(1203), kw_end_DASH_line, int(1203))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -53357,7 +52906,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -53369,27 +52918,25 @@ func LoadNS() { { // function unchecked-add-int__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_seq) - tmp6 := checkDerefVar(glojure_DOT_core_concat) - tmp7 := checkDerefVar(glojure_DOT_core_list) - tmp8 := lang.Apply(tmp7, []any{lang.NewSymbol(".")}) - tmp9 := checkDerefVar(glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp11 := checkDerefVar(glojure_DOT_core_list) - tmp12 := checkDerefVar(glojure_DOT_core_seq) - tmp13 := checkDerefVar(glojure_DOT_core_concat) - tmp14 := checkDerefVar(glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("glojure.core/Unchecked_int_add")}) - tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_add}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) - tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) tmp19 := lang.Apply(tmp18, []any{v4}) tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) tmp21 := lang.Apply(tmp12, []any{tmp20}) @@ -53401,12 +52948,10 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("unchecked-add-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the sum of x and y, both int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1196), lang.NewKeyword("end-line"), int(1196))).(*lang.Symbol) + tmp0 := sym_unchecked_DASH_add_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Returns the sum of x and y, both int.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(7), kw_line, int(1196), kw_end_DASH_line, int(1196))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -53418,7 +52963,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -53430,23 +52975,21 @@ func LoadNS() { { // function unchecked-byte__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) - tmp5 := checkDerefVar(glojure_DOT_core_concat) - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := checkDerefVar(glojure_DOT_core_seq) - tmp12 := checkDerefVar(glojure_DOT_core_concat) - tmp13 := checkDerefVar(glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/UncheckedByteCast")}) - tmp15 := checkDerefVar(glojure_DOT_core_list) + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedByteCast}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) tmp18 := lang.Apply(tmp11, []any{tmp17}) @@ -53458,18 +53001,16 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("unchecked-byte").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to byte. Subject to rounding or truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3517), lang.NewKeyword("end-line"), int(3517))).(*lang.Symbol) + tmp0 := sym_unchecked_DASH_byte.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to byte. Subject to rounding or truncation.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(3517), kw_end_DASH_line, int(3517))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 tmp5 := lang.Apply(lang.UncheckedByteCast, []any{v4}) return tmp5 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -53481,23 +53022,21 @@ func LoadNS() { { // function unchecked-char__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) - tmp5 := checkDerefVar(glojure_DOT_core_concat) - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := checkDerefVar(glojure_DOT_core_seq) - tmp12 := checkDerefVar(glojure_DOT_core_concat) - tmp13 := checkDerefVar(glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/UncheckedCharCast")}) - tmp15 := checkDerefVar(glojure_DOT_core_list) + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedCharCast}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) tmp18 := lang.Apply(tmp11, []any{tmp17}) @@ -53509,12 +53048,10 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("unchecked-char").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to char. Subject to rounding or truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3529), lang.NewKeyword("end-line"), int(3529))).(*lang.Symbol) + tmp0 := sym_unchecked_DASH_char.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to char. Subject to rounding or truncation.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(3529), kw_end_DASH_line, int(3529))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 tmp5, _ := lang.FieldOrMethod(runtime7.RT, "UncheckedCharCast") @@ -53524,7 +53061,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v4}) return tmp6 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -53536,23 +53073,21 @@ func LoadNS() { { // function unchecked-dec__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) - tmp5 := checkDerefVar(glojure_DOT_core_concat) - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := checkDerefVar(glojure_DOT_core_seq) - tmp12 := checkDerefVar(glojure_DOT_core_concat) - tmp13 := checkDerefVar(glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/UncheckedDec")}) - tmp15 := checkDerefVar(glojure_DOT_core_list) + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedDec}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) tmp18 := lang.Apply(tmp11, []any{tmp17}) @@ -53564,12 +53099,10 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("unchecked-dec").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns a number one less than x, a long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1175), lang.NewKeyword("end-line"), int(1175))).(*lang.Symbol) + tmp0 := sym_unchecked_DASH_dec.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns a number one less than x, a long.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(1175), kw_end_DASH_line, int(1175))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 tmp5, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedDec") @@ -53579,7 +53112,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v4}) return tmp6 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -53591,23 +53124,21 @@ func LoadNS() { { // function unchecked-dec-int__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) - tmp5 := checkDerefVar(glojure_DOT_core_concat) - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := checkDerefVar(glojure_DOT_core_seq) - tmp12 := checkDerefVar(glojure_DOT_core_concat) - tmp13 := checkDerefVar(glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/Unchecked_int_dec")}) - tmp15 := checkDerefVar(glojure_DOT_core_list) + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_dec}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) tmp18 := lang.Apply(tmp11, []any{tmp17}) @@ -53619,12 +53150,10 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("unchecked-dec-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns a number one less than x, an int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1168), lang.NewKeyword("end-line"), int(1168))).(*lang.Symbol) + tmp0 := sym_unchecked_DASH_dec_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns a number one less than x, an int.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(7), kw_line, int(1168), kw_end_DASH_line, int(1168))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_dec") @@ -53634,7 +53163,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v4}) return tmp6 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -53646,27 +53175,25 @@ func LoadNS() { { // function unchecked-divide-int__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_seq) - tmp6 := checkDerefVar(glojure_DOT_core_concat) - tmp7 := checkDerefVar(glojure_DOT_core_list) - tmp8 := lang.Apply(tmp7, []any{lang.NewSymbol(".")}) - tmp9 := checkDerefVar(glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp11 := checkDerefVar(glojure_DOT_core_list) - tmp12 := checkDerefVar(glojure_DOT_core_seq) - tmp13 := checkDerefVar(glojure_DOT_core_concat) - tmp14 := checkDerefVar(glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("glojure.core/UncheckedIntDivide")}) - tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_UncheckedIntDivide}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) - tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) tmp19 := lang.Apply(tmp18, []any{v4}) tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) tmp21 := lang.Apply(tmp12, []any{tmp20}) @@ -53678,12 +53205,10 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("unchecked-divide-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the division of x by y, both int.\n Note - uses a primitive operator subject to truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(26), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1238), lang.NewKeyword("end-line"), int(1238))).(*lang.Symbol) + tmp0 := sym_unchecked_DASH_divide_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Returns the division of x by y, both int.\n Note - uses a primitive operator subject to truncation.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(26), kw_column, int(7), kw_line, int(1238), kw_end_DASH_line, int(1238))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -53695,7 +53220,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -53707,23 +53232,21 @@ func LoadNS() { { // function unchecked-double__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) - tmp5 := checkDerefVar(glojure_DOT_core_concat) - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := checkDerefVar(glojure_DOT_core_seq) - tmp12 := checkDerefVar(glojure_DOT_core_concat) - tmp13 := checkDerefVar(glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/UncheckedDoubleCast")}) - tmp15 := checkDerefVar(glojure_DOT_core_list) + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedDoubleCast}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) tmp18 := lang.Apply(tmp11, []any{tmp17}) @@ -53735,18 +53258,16 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("unchecked-double").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to double. Subject to rounding.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3553), lang.NewKeyword("end-line"), int(3553))).(*lang.Symbol) + tmp0 := sym_unchecked_DASH_double.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to double. Subject to rounding.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(22), kw_column, int(7), kw_line, int(3553), kw_end_DASH_line, int(3553))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 tmp5 := lang.Apply(lang.AsFloat64, []any{v4}) return tmp5 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -53758,23 +53279,21 @@ func LoadNS() { { // function unchecked-float__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) - tmp5 := checkDerefVar(glojure_DOT_core_concat) - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := checkDerefVar(glojure_DOT_core_seq) - tmp12 := checkDerefVar(glojure_DOT_core_concat) - tmp13 := checkDerefVar(glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/UncheckedFloatCast")}) - tmp15 := checkDerefVar(glojure_DOT_core_list) + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedFloatCast}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) tmp18 := lang.Apply(tmp11, []any{tmp17}) @@ -53786,18 +53305,16 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("unchecked-float").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to float. Subject to rounding.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3547), lang.NewKeyword("end-line"), int(3547))).(*lang.Symbol) + tmp0 := sym_unchecked_DASH_float.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to float. Subject to rounding.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(3547), kw_end_DASH_line, int(3547))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 tmp5 := lang.Apply(lang.UncheckedFloatCast, []any{v4}) return tmp5 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -53809,23 +53326,21 @@ func LoadNS() { { // function unchecked-inc__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) - tmp5 := checkDerefVar(glojure_DOT_core_concat) - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := checkDerefVar(glojure_DOT_core_seq) - tmp12 := checkDerefVar(glojure_DOT_core_concat) - tmp13 := checkDerefVar(glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/Unchecked_inc")}) - tmp15 := checkDerefVar(glojure_DOT_core_list) + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Unchecked_inc}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) tmp18 := lang.Apply(tmp11, []any{tmp17}) @@ -53837,12 +53352,10 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("unchecked-inc").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns a number one greater than x, a long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1161), lang.NewKeyword("end-line"), int(1161))).(*lang.Symbol) + tmp0 := sym_unchecked_DASH_inc.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns a number one greater than x, a long.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(1161), kw_end_DASH_line, int(1161))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_inc") @@ -53852,7 +53365,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v4}) return tmp6 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -53864,23 +53377,21 @@ func LoadNS() { { // function unchecked-inc-int__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) - tmp5 := checkDerefVar(glojure_DOT_core_concat) - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := checkDerefVar(glojure_DOT_core_seq) - tmp12 := checkDerefVar(glojure_DOT_core_concat) - tmp13 := checkDerefVar(glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/Unchecked_int_inc")}) - tmp15 := checkDerefVar(glojure_DOT_core_list) + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_inc}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) tmp18 := lang.Apply(tmp11, []any{tmp17}) @@ -53892,12 +53403,10 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("unchecked-inc-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns a number one greater than x, an int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1154), lang.NewKeyword("end-line"), int(1154))).(*lang.Symbol) + tmp0 := sym_unchecked_DASH_inc_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns a number one greater than x, an int.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(7), kw_line, int(1154), kw_end_DASH_line, int(1154))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_inc") @@ -53907,7 +53416,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v4}) return tmp6 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -53919,23 +53428,21 @@ func LoadNS() { { // function unchecked-int__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) - tmp5 := checkDerefVar(glojure_DOT_core_concat) - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := checkDerefVar(glojure_DOT_core_seq) - tmp12 := checkDerefVar(glojure_DOT_core_concat) - tmp13 := checkDerefVar(glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/UncheckedIntCast")}) - tmp15 := checkDerefVar(glojure_DOT_core_list) + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedIntCast}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) tmp18 := lang.Apply(tmp11, []any{tmp17}) @@ -53947,18 +53454,16 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("unchecked-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to int. Subject to rounding or truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3535), lang.NewKeyword("end-line"), int(3535))).(*lang.Symbol) + tmp0 := sym_unchecked_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to int. Subject to rounding or truncation.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(3535), kw_end_DASH_line, int(3535))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 tmp5 := lang.Apply(lang.UncheckedIntCast, []any{v4}) return tmp5 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -53970,23 +53475,21 @@ func LoadNS() { { // function unchecked-long__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) - tmp5 := checkDerefVar(glojure_DOT_core_concat) - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := checkDerefVar(glojure_DOT_core_seq) - tmp12 := checkDerefVar(glojure_DOT_core_concat) - tmp13 := checkDerefVar(glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/UncheckedLongCast")}) - tmp15 := checkDerefVar(glojure_DOT_core_list) + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedLongCast}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) tmp18 := lang.Apply(tmp11, []any{tmp17}) @@ -53998,18 +53501,16 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("unchecked-long").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to long. Subject to rounding or truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3541), lang.NewKeyword("end-line"), int(3541))).(*lang.Symbol) + tmp0 := sym_unchecked_DASH_long.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to long. Subject to rounding or truncation.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(3541), kw_end_DASH_line, int(3541))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 tmp5 := lang.Apply(lang.UncheckedLongCast, []any{v4}) return tmp5 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -54021,27 +53522,25 @@ func LoadNS() { { // function unchecked-multiply__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_seq) - tmp6 := checkDerefVar(glojure_DOT_core_concat) - tmp7 := checkDerefVar(glojure_DOT_core_list) - tmp8 := lang.Apply(tmp7, []any{lang.NewSymbol(".")}) - tmp9 := checkDerefVar(glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp11 := checkDerefVar(glojure_DOT_core_list) - tmp12 := checkDerefVar(glojure_DOT_core_seq) - tmp13 := checkDerefVar(glojure_DOT_core_concat) - tmp14 := checkDerefVar(glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("glojure.core/Unchecked_multiply")}) - tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_multiply}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) - tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) tmp19 := lang.Apply(tmp18, []any{v4}) tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) tmp21 := lang.Apply(tmp12, []any{tmp20}) @@ -54053,12 +53552,10 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("unchecked-multiply").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the product of x and y, both long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1231), lang.NewKeyword("end-line"), int(1231))).(*lang.Symbol) + tmp0 := sym_unchecked_DASH_multiply.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Returns the product of x and y, both long.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(24), kw_column, int(7), kw_line, int(1231), kw_end_DASH_line, int(1231))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -54070,7 +53567,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -54082,27 +53579,25 @@ func LoadNS() { { // function unchecked-multiply-int__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_seq) - tmp6 := checkDerefVar(glojure_DOT_core_concat) - tmp7 := checkDerefVar(glojure_DOT_core_list) - tmp8 := lang.Apply(tmp7, []any{lang.NewSymbol(".")}) - tmp9 := checkDerefVar(glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp11 := checkDerefVar(glojure_DOT_core_list) - tmp12 := checkDerefVar(glojure_DOT_core_seq) - tmp13 := checkDerefVar(glojure_DOT_core_concat) - tmp14 := checkDerefVar(glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("glojure.core/Unchecked_int_multiply")}) - tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_multiply}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) - tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) tmp19 := lang.Apply(tmp18, []any{v4}) tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) tmp21 := lang.Apply(tmp12, []any{tmp20}) @@ -54114,12 +53609,10 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("unchecked-multiply-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the product of x and y, both int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1224), lang.NewKeyword("end-line"), int(1224))).(*lang.Symbol) + tmp0 := sym_unchecked_DASH_multiply_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Returns the product of x and y, both int.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(28), kw_column, int(7), kw_line, int(1224), kw_end_DASH_line, int(1224))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -54131,7 +53624,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -54143,23 +53636,21 @@ func LoadNS() { { // function unchecked-negate__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) - tmp5 := checkDerefVar(glojure_DOT_core_concat) - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := checkDerefVar(glojure_DOT_core_seq) - tmp12 := checkDerefVar(glojure_DOT_core_concat) - tmp13 := checkDerefVar(glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/Unchecked_minus")}) - tmp15 := checkDerefVar(glojure_DOT_core_list) + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Unchecked_minus}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) tmp18 := lang.Apply(tmp11, []any{tmp17}) @@ -54171,12 +53662,10 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("unchecked-negate").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the negation of x, a long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1189), lang.NewKeyword("end-line"), int(1189))).(*lang.Symbol) + tmp0 := sym_unchecked_DASH_negate.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns the negation of x, a long.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(22), kw_column, int(7), kw_line, int(1189), kw_end_DASH_line, int(1189))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_negate") @@ -54186,7 +53675,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v4}) return tmp6 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -54198,23 +53687,21 @@ func LoadNS() { { // function unchecked-negate-int__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) - tmp5 := checkDerefVar(glojure_DOT_core_concat) - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := checkDerefVar(glojure_DOT_core_seq) - tmp12 := checkDerefVar(glojure_DOT_core_concat) - tmp13 := checkDerefVar(glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/Unchecked_int_negate")}) - tmp15 := checkDerefVar(glojure_DOT_core_list) + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_negate}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) tmp18 := lang.Apply(tmp11, []any{tmp17}) @@ -54226,12 +53713,10 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("unchecked-negate-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the negation of x, an int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(26), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1182), lang.NewKeyword("end-line"), int(1182))).(*lang.Symbol) + tmp0 := sym_unchecked_DASH_negate_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns the negation of x, an int.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(26), kw_column, int(7), kw_line, int(1182), kw_end_DASH_line, int(1182))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_negate") @@ -54241,7 +53726,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v4}) return tmp6 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -54253,27 +53738,25 @@ func LoadNS() { { // function unchecked-remainder-int__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_seq) - tmp6 := checkDerefVar(glojure_DOT_core_concat) - tmp7 := checkDerefVar(glojure_DOT_core_list) - tmp8 := lang.Apply(tmp7, []any{lang.NewSymbol(".")}) - tmp9 := checkDerefVar(glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp11 := checkDerefVar(glojure_DOT_core_list) - tmp12 := checkDerefVar(glojure_DOT_core_seq) - tmp13 := checkDerefVar(glojure_DOT_core_concat) - tmp14 := checkDerefVar(glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("glojure.core/Unchecked_int_remainder")}) - tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_remainder}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) - tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) tmp19 := lang.Apply(tmp18, []any{v4}) tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) tmp21 := lang.Apply(tmp12, []any{tmp20}) @@ -54285,12 +53768,10 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("unchecked-remainder-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the remainder of division of x by y, both int.\n Note - uses a primitive operator subject to truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(29), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1245), lang.NewKeyword("end-line"), int(1245))).(*lang.Symbol) + tmp0 := sym_unchecked_DASH_remainder_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Returns the remainder of division of x by y, both int.\n Note - uses a primitive operator subject to truncation.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(29), kw_column, int(7), kw_line, int(1245), kw_end_DASH_line, int(1245))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -54302,7 +53783,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -54314,23 +53795,21 @@ func LoadNS() { { // function unchecked-short__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) - tmp5 := checkDerefVar(glojure_DOT_core_concat) - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := checkDerefVar(glojure_DOT_core_seq) - tmp12 := checkDerefVar(glojure_DOT_core_concat) - tmp13 := checkDerefVar(glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/UncheckedShortCast")}) - tmp15 := checkDerefVar(glojure_DOT_core_list) + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedShortCast}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) tmp18 := lang.Apply(tmp11, []any{tmp17}) @@ -54342,18 +53821,16 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("unchecked-short").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Coerce to short. Subject to rounding or truncation.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(3523), lang.NewKeyword("end-line"), int(3523))).(*lang.Symbol) + tmp0 := sym_unchecked_DASH_short.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to short. Subject to rounding or truncation.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(3523), kw_end_DASH_line, int(3523))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 tmp5 := lang.Apply(lang.UncheckedShortCast, []any{v4}) return tmp5 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -54365,27 +53842,25 @@ func LoadNS() { { // function unchecked-subtract__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_seq) - tmp6 := checkDerefVar(glojure_DOT_core_concat) - tmp7 := checkDerefVar(glojure_DOT_core_list) - tmp8 := lang.Apply(tmp7, []any{lang.NewSymbol(".")}) - tmp9 := checkDerefVar(glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp11 := checkDerefVar(glojure_DOT_core_list) - tmp12 := checkDerefVar(glojure_DOT_core_seq) - tmp13 := checkDerefVar(glojure_DOT_core_concat) - tmp14 := checkDerefVar(glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("glojure.core/Unchecked_minus")}) - tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_minus}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) - tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) tmp19 := lang.Apply(tmp18, []any{v4}) tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) tmp21 := lang.Apply(tmp12, []any{tmp20}) @@ -54397,12 +53872,10 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("unchecked-subtract").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the difference of x and y, both long.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1217), lang.NewKeyword("end-line"), int(1217))).(*lang.Symbol) + tmp0 := sym_unchecked_DASH_subtract.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Returns the difference of x and y, both long.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(24), kw_column, int(7), kw_line, int(1217), kw_end_DASH_line, int(1217))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -54414,7 +53887,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -54426,27 +53899,25 @@ func LoadNS() { { // function unchecked-subtract-int__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_seq) - tmp6 := checkDerefVar(glojure_DOT_core_concat) - tmp7 := checkDerefVar(glojure_DOT_core_list) - tmp8 := lang.Apply(tmp7, []any{lang.NewSymbol(".")}) - tmp9 := checkDerefVar(glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp11 := checkDerefVar(glojure_DOT_core_list) - tmp12 := checkDerefVar(glojure_DOT_core_seq) - tmp13 := checkDerefVar(glojure_DOT_core_concat) - tmp14 := checkDerefVar(glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("glojure.core/Unchecked_int_subtract")}) - tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_subtract}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) - tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) tmp19 := lang.Apply(tmp18, []any{v4}) tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) tmp21 := lang.Apply(tmp12, []any{tmp20}) @@ -54458,12 +53929,10 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("unchecked-subtract-int").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("y"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns the difference of x and y, both int.\n Note - uses a primitive operator subject to overflow.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(28), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1210), lang.NewKeyword("end-line"), int(1210))).(*lang.Symbol) + tmp0 := sym_unchecked_DASH_subtract_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Returns the difference of x and y, both int.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(28), kw_column, int(7), kw_line, int(1210), kw_end_DASH_line, int(1210))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -54475,7 +53944,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -54483,7 +53952,7 @@ func LoadNS() { } // underive { - tmp0 := lang.NewSymbol("underive").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("tag"), lang.NewSymbol("parent")), lang.NewVector(lang.NewSymbol("h"), lang.NewSymbol("tag"), lang.NewSymbol("parent"))), lang.NewKeyword("doc"), "Removes a parent/child relationship between parent and\n tag. h must be a hierarchy obtained from make-hierarchy, if not\n supplied defaults to, and modifies, the global hierarchy.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(5643), lang.NewKeyword("end-line"), int(5643))).(*lang.Symbol) + tmp0 := sym_underive.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_tag, sym_parent), lang.NewVector(sym_h, sym_tag, sym_parent)), kw_doc, "Removes a parent/child relationship between parent and\n tag. h must be a hierarchy obtained from make-hierarchy, if not\n supplied defaults to, and modifies, the global hierarchy.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(5643), kw_end_DASH_line, int(5643))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -54492,9 +53961,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_alter_var_root) - tmp6 := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("global-hierarchy")) - tmp7 := checkDerefVar(glojure_DOT_core_underive) + tmp5 := checkDerefVar(var_glojure_DOT_core_alter_DASH_var_DASH_root) + tmp6 := lang.InternVarName(sym_glojure_DOT_core, sym_global_DASH_hierarchy) + tmp7 := checkDerefVar(var_glojure_DOT_core_underive) tmp8 := lang.Apply(tmp5, []any{tmp6, tmp7, v3, v4}) _ = tmp8 return nil @@ -54508,20 +53977,20 @@ func LoadNS() { var tmp6 any { // let // let binding "parentMap" - tmp7 := lang.Apply(lang.NewKeyword("parents"), []any{v3}) + tmp7 := lang.Apply(kw_parents, []any{v3}) var v8 any = tmp7 _ = v8 // let binding "childsParents" var tmp9 any tmp10 := lang.Apply(v8, []any{v4}) if lang.IsTruthy(tmp10) { - tmp11 := checkDerefVar(glojure_DOT_core_disj) + tmp11 := checkDerefVar(var_glojure_DOT_core_disj) tmp12 := lang.Apply(v8, []any{v4}) tmp13 := lang.Apply(tmp11, []any{tmp12, v5}) tmp9 = tmp13 } else { tmp14 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) - tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5652), lang.NewKeyword("column"), int(36), lang.NewKeyword("end-line"), int(5652), lang.NewKeyword("end-column"), int(38)) + tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5652), kw_column, int(36), kw_end_DASH_line, int(5652), kw_end_DASH_column, int(38)) tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) if err != nil { panic(err) @@ -54532,80 +54001,76 @@ func LoadNS() { _ = v17 // let binding "newParents" var tmp18 any - tmp19 := checkDerefVar(glojure_DOT_core_not_empty) + tmp19 := checkDerefVar(var_glojure_DOT_core_not_DASH_empty) tmp20 := lang.Apply(tmp19, []any{v17}) if lang.IsTruthy(tmp20) { - tmp21 := checkDerefVar(glojure_DOT_core_assoc) + tmp21 := checkDerefVar(var_glojure_DOT_core_assoc) tmp22 := lang.Apply(tmp21, []any{v8, v4, v17}) tmp18 = tmp22 } else { - tmp23 := checkDerefVar(glojure_DOT_core_dissoc) + tmp23 := checkDerefVar(var_glojure_DOT_core_dissoc) tmp24 := lang.Apply(tmp23, []any{v8, v4}) tmp18 = tmp24 } var v25 any = tmp18 _ = v25 // let binding "deriv-seq" - tmp26 := checkDerefVar(glojure_DOT_core_flatten) - tmp27 := checkDerefVar(glojure_DOT_core_map) + tmp26 := checkDerefVar(var_glojure_DOT_core_flatten) + tmp27 := checkDerefVar(var_glojure_DOT_core_map) var tmp28 lang.FnFunc tmp28 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v29 := args[0] _ = v29 - tmp30 := checkDerefVar(glojure_DOT_core_cons) - tmp31 := checkDerefVar(glojure_DOT_core_key) + tmp30 := checkDerefVar(var_glojure_DOT_core_cons) + tmp31 := checkDerefVar(var_glojure_DOT_core_key) tmp32 := lang.Apply(tmp31, []any{v29}) - tmp33 := checkDerefVar(glojure_DOT_core_interpose) - tmp34 := checkDerefVar(glojure_DOT_core_key) + tmp33 := checkDerefVar(var_glojure_DOT_core_interpose) + tmp34 := checkDerefVar(var_glojure_DOT_core_key) tmp35 := lang.Apply(tmp34, []any{v29}) - tmp36 := checkDerefVar(glojure_DOT_core_val) + tmp36 := checkDerefVar(var_glojure_DOT_core_val) tmp37 := lang.Apply(tmp36, []any{v29}) tmp38 := lang.Apply(tmp33, []any{tmp35, tmp37}) tmp39 := lang.Apply(tmp30, []any{tmp32, tmp38}) return tmp39 }) - tmp29 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5656), lang.NewKeyword("column"), int(28), lang.NewKeyword("end-line"), int(5656), lang.NewKeyword("end-column"), int(70)) + tmp29 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5656), kw_column, int(28), kw_end_DASH_line, int(5656), kw_end_DASH_column, int(70)) tmp30, err := lang.WithMeta(tmp28, tmp29.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp31 := checkDerefVar(glojure_DOT_core_seq) + tmp31 := checkDerefVar(var_glojure_DOT_core_seq) tmp32 := lang.Apply(tmp31, []any{v25}) tmp33 := lang.Apply(tmp27, []any{tmp30, tmp32}) tmp34 := lang.Apply(tmp26, []any{tmp33}) var v35 any = tmp34 _ = v35 var tmp36 any - tmp37 := checkDerefVar(glojure_DOT_core_contains_QMARK_) + tmp37 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) tmp38 := lang.Apply(v8, []any{v4}) tmp39 := lang.Apply(tmp37, []any{tmp38, v5}) if lang.IsTruthy(tmp39) { - tmp40 := checkDerefVar(glojure_DOT_core_reduce1) + tmp40 := checkDerefVar(var_glojure_DOT_core_reduce1) var tmp41 lang.FnFunc tmp41 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v42 := args[0] _ = v42 v43 := args[1] _ = v43 - tmp44 := checkDerefVar(glojure_DOT_core_apply) - tmp45 := checkDerefVar(glojure_DOT_core_derive) + tmp44 := checkDerefVar(var_glojure_DOT_core_apply) + tmp45 := checkDerefVar(var_glojure_DOT_core_derive) tmp46 := lang.Apply(tmp44, []any{tmp45, v42, v43}) return tmp46 }) - tmp42 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5659), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5659), lang.NewKeyword("end-column"), int(31)) + tmp42 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5659), kw_column, int(11), kw_end_DASH_line, int(5659), kw_end_DASH_column, int(31)) tmp43, err := lang.WithMeta(tmp41, tmp42.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp44 := checkDerefVar(glojure_DOT_core_make_hierarchy) + tmp44 := checkDerefVar(var_glojure_DOT_core_make_DASH_hierarchy) tmp45 := lang.Apply(tmp44, nil) - tmp46 := checkDerefVar(glojure_DOT_core_partition) + tmp46 := checkDerefVar(var_glojure_DOT_core_partition) tmp47 := lang.Apply(tmp46, []any{int64(2), v35}) tmp48 := lang.Apply(tmp40, []any{tmp43, tmp45, tmp47}) tmp36 = tmp48 @@ -54616,10 +54081,11 @@ func LoadNS() { } // end let return tmp6 default: - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -54627,7 +54093,7 @@ func LoadNS() { } // unquote { - tmp0 := lang.NewSymbol("unquote").WithMeta(lang.NewMap()).(*lang.Symbol) + tmp0 := sym_unquote.WithMeta(lang.NewMap()).(*lang.Symbol) tmp1 := ns.Intern(tmp0) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -54635,7 +54101,7 @@ func LoadNS() { } // unquote-splicing { - tmp0 := lang.NewSymbol("unquote-splicing").WithMeta(lang.NewMap()).(*lang.Symbol) + tmp0 := sym_unquote_DASH_splicing.WithMeta(lang.NewMap()).(*lang.Symbol) tmp1 := ns.Intern(tmp0) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -54643,19 +54109,17 @@ func LoadNS() { } // unreduced { - tmp0 := lang.NewSymbol("unreduced").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "If x is reduced?, returns (deref x), else returns x", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2847), lang.NewKeyword("end-line"), int(2847))).(*lang.Symbol) + tmp0 := sym_unreduced.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "If x is reduced?, returns (deref x), else returns x", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(2847), kw_end_DASH_line, int(2847))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any - tmp5 := checkDerefVar(glojure_DOT_core_reduced_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) tmp6 := lang.Apply(tmp5, []any{v3}) if lang.IsTruthy(tmp6) { - tmp7 := checkDerefVar(glojure_DOT_core_deref) + tmp7 := checkDerefVar(var_glojure_DOT_core_deref) tmp8 := lang.Apply(tmp7, []any{v3}) tmp4 = tmp8 } else { @@ -54663,7 +54127,7 @@ func LoadNS() { } return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -54675,27 +54139,25 @@ func LoadNS() { { // function unsigned-bit-shift-right__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_seq) - tmp6 := checkDerefVar(glojure_DOT_core_concat) - tmp7 := checkDerefVar(glojure_DOT_core_list) - tmp8 := lang.Apply(tmp7, []any{lang.NewSymbol(".")}) - tmp9 := checkDerefVar(glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp11 := checkDerefVar(glojure_DOT_core_list) - tmp12 := checkDerefVar(glojure_DOT_core_seq) - tmp13 := checkDerefVar(glojure_DOT_core_concat) - tmp14 := checkDerefVar(glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{lang.NewSymbol("glojure.core/UnsignedShiftRight")}) - tmp16 := checkDerefVar(glojure_DOT_core_list) + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_UnsignedShiftRight}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) - tmp18 := checkDerefVar(glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) tmp19 := lang.Apply(tmp18, []any{v4}) tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) tmp21 := lang.Apply(tmp12, []any{tmp20}) @@ -54707,12 +54169,10 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("unsigned-bit-shift-right").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("n"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Bitwise shift right, without sign-extension.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(30), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1373), lang.NewKeyword("end-line"), int(1373))).(*lang.Symbol) + tmp0 := sym_unsigned_DASH_bit_DASH_shift_DASH_right.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_n)), kw_inline, tmp1, kw_doc, "Bitwise shift right, without sign-extension.", kw_file, "glojure/core.glj", kw_added, "1.6", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(30), kw_column, int(7), kw_line, int(1373), kw_end_DASH_line, int(1373))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -54724,7 +54184,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -54732,7 +54192,7 @@ func LoadNS() { } // update { - tmp0 := lang.NewSymbol("update").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f"), lang.NewSymbol("x")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("z")), lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("k"), lang.NewSymbol("f"), lang.NewSymbol("x"), lang.NewSymbol("y"), lang.NewSymbol("z"), lang.NewSymbol("&"), lang.NewSymbol("more"))), lang.NewKeyword("doc"), "'Updates' a value in an associative structure, where k is a\n key and f is a function that will take the old value\n and any supplied args and return the new value, and returns a new\n structure. If the key does not exist, nil is passed as the old value.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6174), lang.NewKeyword("end-line"), int(6174))).(*lang.Symbol) + tmp0 := sym_update.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m, sym_k, sym_f), lang.NewVector(sym_m, sym_k, sym_f, sym_x), lang.NewVector(sym_m, sym_k, sym_f, sym_x, sym_y), lang.NewVector(sym_m, sym_k, sym_f, sym_x, sym_y, sym_z), lang.NewVector(sym_m, sym_k, sym_f, sym_x, sym_y, sym_z, sym__AMP_, sym_more)), kw_doc, "'Updates' a value in an associative structure, where k is a\n key and f is a function that will take the old value\n and any supplied args and return the new value, and returns a new\n structure. If the key does not exist, nil is passed as the old value.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(6174), kw_end_DASH_line, int(6174))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -54743,8 +54203,8 @@ func LoadNS() { _ = v4 v5 := args[2] _ = v5 - tmp6 := checkDerefVar(glojure_DOT_core_assoc) - tmp7 := checkDerefVar(glojure_DOT_core_get) + tmp6 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp7 := checkDerefVar(var_glojure_DOT_core_get) tmp8 := lang.Apply(tmp7, []any{v3, v4}) tmp9 := lang.Apply(v5, []any{tmp8}) tmp10 := lang.Apply(tmp6, []any{v3, v4, tmp9}) @@ -54758,8 +54218,8 @@ func LoadNS() { _ = v5 v6 := args[3] _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_assoc) - tmp8 := checkDerefVar(glojure_DOT_core_get) + tmp7 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp8 := checkDerefVar(var_glojure_DOT_core_get) tmp9 := lang.Apply(tmp8, []any{v3, v4}) tmp10 := lang.Apply(v5, []any{tmp9, v6}) tmp11 := lang.Apply(tmp7, []any{v3, v4, tmp10}) @@ -54775,8 +54235,8 @@ func LoadNS() { _ = v6 v7 := args[4] _ = v7 - tmp8 := checkDerefVar(glojure_DOT_core_assoc) - tmp9 := checkDerefVar(glojure_DOT_core_get) + tmp8 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp9 := checkDerefVar(var_glojure_DOT_core_get) tmp10 := lang.Apply(tmp9, []any{v3, v4}) tmp11 := lang.Apply(v5, []any{tmp10, v6, v7}) tmp12 := lang.Apply(tmp8, []any{v3, v4, tmp11}) @@ -54794,16 +54254,14 @@ func LoadNS() { _ = v7 v8 := args[5] _ = v8 - tmp9 := checkDerefVar(glojure_DOT_core_assoc) - tmp10 := checkDerefVar(glojure_DOT_core_get) + tmp9 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp10 := checkDerefVar(var_glojure_DOT_core_get) tmp11 := lang.Apply(tmp10, []any{v3, v4}) tmp12 := lang.Apply(v5, []any{tmp11, v6, v7, v8}) tmp13 := lang.Apply(tmp9, []any{v3, v4, tmp12}) return tmp13 default: - if len(args) < 6 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 6) v3 := args[0] _ = v3 v4 := args[1] @@ -54818,16 +54276,16 @@ func LoadNS() { _ = v8 var v9 any = lang.NewList(args[6:]...) _ = v9 - tmp10 := checkDerefVar(glojure_DOT_core_assoc) - tmp11 := checkDerefVar(glojure_DOT_core_apply) - tmp12 := checkDerefVar(glojure_DOT_core_get) + tmp10 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + tmp12 := checkDerefVar(var_glojure_DOT_core_get) tmp13 := lang.Apply(tmp12, []any{v3, v4}) tmp14 := lang.Apply(tmp11, []any{v5, tmp13, v6, v7, v8, v9}) tmp15 := lang.Apply(tmp10, []any{v3, v4, tmp14}) return tmp15 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -54835,14 +54293,12 @@ func LoadNS() { } // update-in { - tmp0 := lang.NewSymbol("update-in").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("ks"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "'Updates' a value in a nested associative structure, where ks is a\n sequence of keys and f is a function that will take the old value\n and any supplied args and return the new value, and returns a new\n nested structure. If any levels do not exist, hash-maps will be\n created.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6158), lang.NewKeyword("end-line"), int(6158))).(*lang.Symbol) + tmp0 := sym_update_DASH_in.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m, sym_ks, sym_f, sym__AMP_, sym_args)), kw_doc, "'Updates' a value in a nested associative structure, where ks is a\n sequence of keys and f is a function that will take the old value\n and any supplied args and return the new value, and returns a new\n nested structure. If any levels do not exist, hash-maps will be\n created.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(6158), kw_end_DASH_line, int(6158))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -54858,9 +54314,7 @@ func LoadNS() { { // function up var v9 lang.FnFunc tmp8 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 4) v10 := args[0] _ = v10 v11 := args[1] @@ -54875,17 +54329,17 @@ func LoadNS() { var v15 any = v11 _ = v15 // let binding "seq__142" - tmp16 := checkDerefVar(glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_seq) tmp17 := lang.Apply(tmp16, []any{v15}) var v18 any = tmp17 _ = v18 // let binding "first__143" - tmp19 := checkDerefVar(glojure_DOT_core_first) + tmp19 := checkDerefVar(var_glojure_DOT_core_first) tmp20 := lang.Apply(tmp19, []any{v18}) var v21 any = tmp20 _ = v21 // let binding "seq__142" - tmp22 := checkDerefVar(glojure_DOT_core_next) + tmp22 := checkDerefVar(var_glojure_DOT_core_next) tmp23 := lang.Apply(tmp22, []any{v18}) var v24 any = tmp23 _ = v24 @@ -54897,16 +54351,16 @@ func LoadNS() { _ = v26 var tmp27 any if lang.IsTruthy(v26) { - tmp28 := checkDerefVar(glojure_DOT_core_assoc) - tmp29 := checkDerefVar(glojure_DOT_core_get) + tmp28 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp29 := checkDerefVar(var_glojure_DOT_core_get) tmp30 := lang.Apply(tmp29, []any{v10, v25}) tmp31 := lang.Apply(v9, []any{tmp30, v26, v12, v13}) tmp32 := lang.Apply(tmp28, []any{v10, v25, tmp31}) tmp27 = tmp32 } else { - tmp33 := checkDerefVar(glojure_DOT_core_assoc) - tmp34 := checkDerefVar(glojure_DOT_core_apply) - tmp35 := checkDerefVar(glojure_DOT_core_get) + tmp33 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp34 := checkDerefVar(var_glojure_DOT_core_apply) + tmp35 := checkDerefVar(var_glojure_DOT_core_get) tmp36 := lang.Apply(tmp35, []any{v10, v25}) tmp37 := lang.Apply(tmp34, []any{v12, tmp36, v13}) tmp38 := lang.Apply(tmp33, []any{v10, v25, tmp37}) @@ -54919,7 +54373,7 @@ func LoadNS() { v9 = tmp8 _ = v9 } - tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6167), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(6171), lang.NewKeyword("end-column"), int(59)) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6167), kw_column, int(15), kw_end_DASH_line, int(6171), kw_end_DASH_column, int(59)) tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) if err != nil { panic(err) @@ -54932,7 +54386,7 @@ func LoadNS() { return tmp7 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -54940,12 +54394,10 @@ func LoadNS() { } // update-keys { - tmp0 := lang.NewSymbol("update-keys").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("f"))), lang.NewKeyword("doc"), "m f => {(f k) v ...}\n\n Given a map m and a function f of 1-argument, returns a new map whose\n keys are the result of applying f to the keys of m, mapped to the\n corresponding values of m.\n f must return a unique key for each key of m, else the behavior is undefined.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7906), lang.NewKeyword("end-line"), int(7906))).(*lang.Symbol) + tmp0 := sym_update_DASH_keys.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m, sym_f)), kw_doc, "m f => {(f k) v ...}\n\n Given a map m and a function f of 1-argument, returns a new map whose\n keys are the result of applying f to the keys of m, mapped to the\n corresponding values of m.\n f must return a unique key for each key of m, else the behavior is undefined.", kw_file, "glojure/core.glj", kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(7906), kw_end_DASH_line, int(7906))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -54953,32 +54405,30 @@ func LoadNS() { var tmp5 any { // let // let binding "ret" - tmp6 := checkDerefVar(glojure_DOT_core_persistent_BANG_) - tmp7 := checkDerefVar(glojure_DOT_core_reduce_kv) + tmp6 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce_DASH_kv) var tmp8 lang.FnFunc tmp8 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v9 := args[0] _ = v9 v10 := args[1] _ = v10 v11 := args[2] _ = v11 - tmp12 := checkDerefVar(glojure_DOT_core_assoc_BANG_) + tmp12 := checkDerefVar(var_glojure_DOT_core_assoc_BANG_) tmp13 := lang.Apply(v4, []any{v10}) tmp14 := lang.Apply(tmp12, []any{v9, tmp13, v11}) return tmp14 }) - tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7916), lang.NewKeyword("column"), int(25), lang.NewKeyword("end-line"), int(7916), lang.NewKeyword("end-column"), int(59)) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7916), kw_column, int(25), kw_end_DASH_line, int(7916), kw_end_DASH_column, int(59)) tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp11 := checkDerefVar(glojure_DOT_core_transient) + tmp11 := checkDerefVar(var_glojure_DOT_core_transient) tmp12 := lang.NewMap() - tmp13 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7917), lang.NewKeyword("column"), int(36), lang.NewKeyword("end-line"), int(7917), lang.NewKeyword("end-column"), int(37)) + tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7917), kw_column, int(36), kw_end_DASH_line, int(7917), kw_end_DASH_column, int(37)) tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) if err != nil { panic(err) @@ -54988,15 +54438,15 @@ func LoadNS() { tmp17 := lang.Apply(tmp6, []any{tmp16}) var v18 any = tmp17 _ = v18 - tmp19 := checkDerefVar(glojure_DOT_core_with_meta) - tmp20 := checkDerefVar(glojure_DOT_core_meta) + tmp19 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp20 := checkDerefVar(var_glojure_DOT_core_meta) tmp21 := lang.Apply(tmp20, []any{v3}) tmp22 := lang.Apply(tmp19, []any{v18, tmp21}) tmp5 = tmp22 } // end let return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -55004,52 +54454,48 @@ func LoadNS() { } // update-vals { - tmp0 := lang.NewSymbol("update-vals").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("m"), lang.NewSymbol("f"))), lang.NewKeyword("doc"), "m f => {k (f v) ...}\n\n Given a map m and a function f of 1-argument, returns a new map where the keys of m\n are mapped to result of applying f to the corresponding values of m.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.11", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7890), lang.NewKeyword("end-line"), int(7890))).(*lang.Symbol) + tmp0 := sym_update_DASH_vals.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m, sym_f)), kw_doc, "m f => {k (f v) ...}\n\n Given a map m and a function f of 1-argument, returns a new map where the keys of m\n are mapped to result of applying f to the corresponding values of m.", kw_file, "glojure/core.glj", kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(7890), kw_end_DASH_line, int(7890))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_with_meta) - tmp6 := checkDerefVar(glojure_DOT_core_persistent_BANG_) - tmp7 := checkDerefVar(glojure_DOT_core_reduce_kv) + tmp5 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp6 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce_DASH_kv) var tmp8 lang.FnFunc tmp8 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v9 := args[0] _ = v9 v10 := args[1] _ = v10 v11 := args[2] _ = v11 - tmp12 := checkDerefVar(glojure_DOT_core_assoc_BANG_) + tmp12 := checkDerefVar(var_glojure_DOT_core_assoc_BANG_) tmp13 := lang.Apply(v4, []any{v11}) tmp14 := lang.Apply(tmp12, []any{v9, v10, tmp13}) return tmp14 }) - tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7899), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(7899), lang.NewKeyword("end-column"), int(51)) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7899), kw_column, int(17), kw_end_DASH_line, int(7899), kw_end_DASH_column, int(51)) tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) if err != nil { panic(err) } var tmp11 any - tmp12 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp12 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp13 := reflect.TypeOf((*lang.IEditableCollection)(nil)).Elem() tmp14 := lang.Apply(tmp12, []any{tmp13, v3}) if lang.IsTruthy(tmp14) { - tmp15 := checkDerefVar(glojure_DOT_core_transient) + tmp15 := checkDerefVar(var_glojure_DOT_core_transient) tmp16 := lang.Apply(tmp15, []any{v3}) tmp11 = tmp16 } else { - tmp17 := checkDerefVar(glojure_DOT_core_transient) + tmp17 := checkDerefVar(var_glojure_DOT_core_transient) tmp18 := lang.NewMap() - tmp19 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7902), lang.NewKeyword("column"), int(30), lang.NewKeyword("end-line"), int(7902), lang.NewKeyword("end-column"), int(31)) + tmp19 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7902), kw_column, int(30), kw_end_DASH_line, int(7902), kw_end_DASH_column, int(31)) tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) if err != nil { panic(err) @@ -55059,12 +54505,12 @@ func LoadNS() { } tmp22 := lang.Apply(tmp7, []any{tmp10, tmp11, v3}) tmp23 := lang.Apply(tmp6, []any{tmp22}) - tmp24 := checkDerefVar(glojure_DOT_core_meta) + tmp24 := checkDerefVar(var_glojure_DOT_core_meta) tmp25 := lang.Apply(tmp24, []any{v3}) tmp26 := lang.Apply(tmp5, []any{tmp23, tmp25}) return tmp26 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -55072,20 +54518,18 @@ func LoadNS() { } // uri? { - tmp0 := lang.NewSymbol("uri?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a java.net.URI", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7877), lang.NewKeyword("end-line"), int(7877))).(*lang.Symbol) + tmp0 := sym_uri_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a java.net.URI", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(7877), kw_end_DASH_line, int(7877))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp5 := reflect.TypeOf((*url4.URL)(nil)).Elem() tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -55093,23 +54537,21 @@ func LoadNS() { } // use { - tmp0 := lang.NewSymbol("use").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Like 'require, but also refers to each lib's namespace using\n glojure.core/refer. Use :use in the ns macro in preference to calling\n this directly.\n\n 'use accepts additional options in libspecs: :exclude, :only, :rename.\n The arguments and semantics for :exclude, :only, and :rename are the same\n as those documented for glojure.core/refer.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6079), lang.NewKeyword("end-line"), int(6079))).(*lang.Symbol) + tmp0 := sym_use.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_args)), kw_doc, "Like 'require, but also refers to each lib's namespace using\n glojure.core/refer. Use :use in the ns macro in preference to calling\n this directly.\n\n 'use accepts additional options in libspecs: :exclude, :only, :rename.\n The arguments and semantics for :exclude, :only, and :rename are the same\n as those documented for glojure.core/refer.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(6079), kw_end_DASH_line, int(6079))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_apply) - tmp5 := checkDerefVar(glojure_DOT_core_load_libs) - tmp6 := lang.Apply(tmp4, []any{tmp5, lang.NewKeyword("require"), lang.NewKeyword("use"), v3}) + tmp4 := checkDerefVar(var_glojure_DOT_core_apply) + tmp5 := checkDerefVar(var_glojure_DOT_core_load_DASH_libs) + tmp6 := lang.Apply(tmp4, []any{tmp5, kw_require, kw_use, v3}) return tmp6 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -55117,20 +54559,18 @@ func LoadNS() { } // uuid? { - tmp0 := lang.NewSymbol("uuid?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x is a java.util.UUID", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.9", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6847), lang.NewKeyword("end-line"), int(6847))).(*lang.Symbol) + tmp0 := sym_uuid_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a java.util.UUID", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(6847), kw_end_DASH_line, int(6847))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp5 := reflect.TypeOf([16]uint8{}) tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -55138,12 +54578,10 @@ func LoadNS() { } // val { - tmp0 := lang.NewSymbol("val").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("e"))), lang.NewKeyword("doc"), "Returns the value in the map entry.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1570), lang.NewKeyword("end-line"), int(1570))).(*lang.Symbol) + tmp0 := sym_val.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_e)), kw_doc, "Returns the value in the map entry.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(1570), kw_end_DASH_line, int(1570))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4, _ := lang.FieldOrMethod(v3, "GetValue") @@ -55153,7 +54591,7 @@ func LoadNS() { tmp5 := lang.Apply(tmp4, []any{}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -55161,18 +54599,16 @@ func LoadNS() { } // vals { - tmp0 := lang.NewSymbol("vals").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("map"))), lang.NewKeyword("doc"), "Returns a sequence of the map's values, in the same order as (seq map).", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1557), lang.NewKeyword("end-line"), int(1557))).(*lang.Symbol) + tmp0 := sym_vals.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_map)), kw_doc, "Returns a sequence of the map's values, in the same order as (seq map).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1557), kw_end_DASH_line, int(1557))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4 := lang.Apply(lang.Vals, []any{v3}) return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -55180,12 +54616,10 @@ func LoadNS() { } // var-get { - tmp0 := lang.NewSymbol("var-get").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Gets the value in the var object", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4326), lang.NewKeyword("end-line"), int(4326))).(*lang.Symbol) + tmp0 := sym_var_DASH_get.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Gets the value in the var object", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4326), kw_end_DASH_line, int(4326))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 tmp4, _ := lang.FieldOrMethod(v3, "Get") @@ -55195,7 +54629,7 @@ func LoadNS() { tmp5 := lang.Apply(tmp4, []any{}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -55203,12 +54637,10 @@ func LoadNS() { } // var-set { - tmp0 := lang.NewSymbol("var-set").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"), lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Sets the value in the var object to val. The var must be\n thread-locally bound.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4332), lang.NewKeyword("end-line"), int(4332))).(*lang.Symbol) + tmp0 := sym_var_DASH_set.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_val)), kw_doc, "Sets the value in the var object to val. The var must be\n thread-locally bound.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4332), kw_end_DASH_line, int(4332))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -55220,7 +54652,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v4}) return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -55228,20 +54660,18 @@ func LoadNS() { } // var? { - tmp0 := lang.NewSymbol("var?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("v"))), lang.NewKeyword("doc"), "Returns true if v is of type glojure.lang.Var", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4999), lang.NewKeyword("end-line"), int(4999))).(*lang.Symbol) + tmp0 := sym_var_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_v)), kw_doc, "Returns true if v is of type glojure.lang.Var", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(4999), kw_end_DASH_line, int(4999))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp5 := reflect.TypeOf((*lang.Var)(nil)) tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -55249,30 +54679,28 @@ func LoadNS() { } // vary-meta { - tmp0 := lang.NewSymbol("vary-meta").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("obj"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Returns an object of the same type and value as obj, with\n (apply f (meta obj) args) as its metadata.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(668), lang.NewKeyword("end-line"), int(668))).(*lang.Symbol) + tmp0 := sym_vary_DASH_meta.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_obj, sym_f, sym__AMP_, sym_args)), kw_doc, "Returns an object of the same type and value as obj, with\n (apply f (meta obj) args) as its metadata.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(668), kw_end_DASH_line, int(668))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 var v5 any = lang.NewList(args[2:]...) _ = v5 - tmp6 := checkDerefVar(glojure_DOT_core_with_meta) - tmp7 := checkDerefVar(glojure_DOT_core_apply) - tmp8 := checkDerefVar(glojure_DOT_core_meta) + tmp6 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp7 := checkDerefVar(var_glojure_DOT_core_apply) + tmp8 := checkDerefVar(var_glojure_DOT_core_meta) tmp9 := lang.Apply(tmp8, []any{v3}) tmp10 := lang.Apply(tmp7, []any{v4, tmp9, v5}) tmp11 := lang.Apply(tmp6, []any{v3, tmp10}) return tmp11 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -55280,24 +54708,22 @@ func LoadNS() { } // vec { - tmp0 := lang.NewSymbol("vec").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("coll"))), lang.NewKeyword("doc"), "Creates a new vector containing the contents of coll. Java arrays\n will be aliased and should not be modified.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(366), lang.NewKeyword("end-line"), int(366))).(*lang.Symbol) + tmp0 := sym_vec.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Creates a new vector containing the contents of coll. Java arrays\n will be aliased and should not be modified.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(366), kw_end_DASH_line, int(366))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any - tmp5 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) tmp6 := lang.Apply(tmp5, []any{v3}) if lang.IsTruthy(tmp6) { var tmp7 any - tmp8 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp8 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp9 := reflect.TypeOf((*lang.IObj)(nil)).Elem() tmp10 := lang.Apply(tmp8, []any{tmp9, v3}) if lang.IsTruthy(tmp10) { - tmp11 := checkDerefVar(glojure_DOT_core_with_meta) + tmp11 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) tmp12 := lang.Apply(tmp11, []any{v3, nil}) tmp7 = tmp12 } else { @@ -55311,7 +54737,7 @@ func LoadNS() { } return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -55319,13 +54745,13 @@ func LoadNS() { } // vector { - tmp0 := lang.NewSymbol("vector").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(), lang.NewVector(lang.NewSymbol("a")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d"), lang.NewSymbol("e")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d"), lang.NewSymbol("e"), lang.NewSymbol("f")), lang.NewVector(lang.NewSymbol("a"), lang.NewSymbol("b"), lang.NewSymbol("c"), lang.NewSymbol("d"), lang.NewSymbol("e"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Creates a new vector containing the args.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(352), lang.NewKeyword("end-line"), int(352))).(*lang.Symbol) + tmp0 := sym_vector.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_a), lang.NewVector(sym_a, sym_b), lang.NewVector(sym_a, sym_b, sym_c), lang.NewVector(sym_a, sym_b, sym_c, sym_d), lang.NewVector(sym_a, sym_b, sym_c, sym_d, sym_e), lang.NewVector(sym_a, sym_b, sym_c, sym_d, sym_e, sym_f), lang.NewVector(sym_a, sym_b, sym_c, sym_d, sym_e, sym_f, sym__AMP_, sym_args)), kw_doc, "Creates a new vector containing the args.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(352), kw_end_DASH_line, int(352))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: tmp3 := lang.NewVector() - tmp4 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(356), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(356), lang.NewKeyword("end-column"), int(8)) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(356), kw_column, int(7), kw_end_DASH_line, int(356), kw_end_DASH_column, int(8)) tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) if err != nil { panic(err) @@ -55335,7 +54761,7 @@ func LoadNS() { v3 := args[0] _ = v3 tmp4 := lang.NewVector(v3) - tmp5 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(357), lang.NewKeyword("column"), int(8), lang.NewKeyword("end-line"), int(357), lang.NewKeyword("end-column"), int(10)) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(357), kw_column, int(8), kw_end_DASH_line, int(357), kw_end_DASH_column, int(10)) tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) if err != nil { panic(err) @@ -55347,7 +54773,7 @@ func LoadNS() { v4 := args[1] _ = v4 tmp5 := lang.NewVector(v3, v4) - tmp6 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(358), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(358), lang.NewKeyword("end-column"), int(14)) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(358), kw_column, int(10), kw_end_DASH_line, int(358), kw_end_DASH_column, int(14)) tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) if err != nil { panic(err) @@ -55361,7 +54787,7 @@ func LoadNS() { v5 := args[2] _ = v5 tmp6 := lang.NewVector(v3, v4, v5) - tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(359), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(359), lang.NewKeyword("end-column"), int(18)) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(359), kw_column, int(12), kw_end_DASH_line, int(359), kw_end_DASH_column, int(18)) tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) if err != nil { panic(err) @@ -55377,7 +54803,7 @@ func LoadNS() { v6 := args[3] _ = v6 tmp7 := lang.NewVector(v3, v4, v5, v6) - tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(360), lang.NewKeyword("column"), int(14), lang.NewKeyword("end-line"), int(360), lang.NewKeyword("end-column"), int(22)) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(360), kw_column, int(14), kw_end_DASH_line, int(360), kw_end_DASH_column, int(22)) tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) if err != nil { panic(err) @@ -55395,7 +54821,7 @@ func LoadNS() { v7 := args[4] _ = v7 tmp8 := lang.NewVector(v3, v4, v5, v6, v7) - tmp9 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(361), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(361), lang.NewKeyword("end-column"), int(25)) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(361), kw_column, int(15), kw_end_DASH_line, int(361), kw_end_DASH_column, int(25)) tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) if err != nil { panic(err) @@ -55415,16 +54841,14 @@ func LoadNS() { v8 := args[5] _ = v8 tmp9 := lang.NewVector(v3, v4, v5, v6, v7, v8) - tmp10 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(362), lang.NewKeyword("column"), int(17), lang.NewKeyword("end-line"), int(362), lang.NewKeyword("end-column"), int(29)) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(362), kw_column, int(17), kw_end_DASH_line, int(362), kw_end_DASH_column, int(29)) tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) if err != nil { panic(err) } return tmp11 default: - if len(args) < 6 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 6) v3 := args[0] _ = v3 v4 := args[1] @@ -55439,12 +54863,12 @@ func LoadNS() { _ = v8 var v9 any = lang.NewList(args[6:]...) _ = v9 - tmp10 := checkDerefVar(glojure_DOT_core_cons) - tmp11 := checkDerefVar(glojure_DOT_core_cons) - tmp12 := checkDerefVar(glojure_DOT_core_cons) - tmp13 := checkDerefVar(glojure_DOT_core_cons) - tmp14 := checkDerefVar(glojure_DOT_core_cons) - tmp15 := checkDerefVar(glojure_DOT_core_cons) + tmp10 := checkDerefVar(var_glojure_DOT_core_cons) + tmp11 := checkDerefVar(var_glojure_DOT_core_cons) + tmp12 := checkDerefVar(var_glojure_DOT_core_cons) + tmp13 := checkDerefVar(var_glojure_DOT_core_cons) + tmp14 := checkDerefVar(var_glojure_DOT_core_cons) + tmp15 := checkDerefVar(var_glojure_DOT_core_cons) tmp16 := lang.Apply(tmp15, []any{v8, v9}) tmp17 := lang.Apply(tmp14, []any{v7, tmp16}) tmp18 := lang.Apply(tmp13, []any{v6, tmp17}) @@ -55455,7 +54879,7 @@ func LoadNS() { return tmp22 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -55463,22 +54887,20 @@ func LoadNS() { } // vector? { - tmp0 := lang.NewSymbol("vector?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Return true if x implements IPersistentVector", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(174), lang.NewKeyword("end-line"), int(178))).(*lang.Symbol) + tmp0 := sym_vector_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x implements IPersistentVector", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(2), kw_line, int(174), kw_end_DASH_line, int(178))).(*lang.Symbol) var tmp2 lang.FnFunc { // function vector? var v3 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 - tmp5 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp6 := reflect.TypeOf((*lang.IPersistentVector)(nil)).Elem() tmp7 := lang.Apply(tmp5, []any{tmp6, v4}) return tmp7 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(178), lang.NewKeyword("column"), int(10), lang.NewKeyword("end-line"), int(178), lang.NewKeyword("end-column"), int(106))).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(178), kw_column, int(10), kw_end_DASH_line, int(178), kw_end_DASH_column, int(106))).(lang.FnFunc) v3 = tmp2 _ = v3 } @@ -55490,19 +54912,17 @@ func LoadNS() { // volatile! { tmp1 := reflect.TypeOf((*lang.Volatile)(nil)).Elem() - tmp0 := lang.NewSymbol("volatile!").WithMeta(lang.NewMap(lang.NewKeyword("tag"), tmp1, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("val"))), lang.NewKeyword("doc"), "Creates and returns a Volatile with an initial value of val.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2517), lang.NewKeyword("end-line"), int(2517))).(*lang.Symbol) + tmp0 := sym_volatile_BANG_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_val)), kw_doc, "Creates and returns a Volatile with an initial value of val.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(2517), kw_end_DASH_line, int(2517))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 tmp5 := lang.Apply(lang.NewVolatile, []any{v4}) return tmp5 }) tmp4 := reflect.TypeOf((*lang.Volatile)(nil)).Elem() - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), tmp4)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -55510,20 +54930,18 @@ func LoadNS() { } // volatile? { - tmp0 := lang.NewSymbol("volatile?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("x"))), lang.NewKeyword("doc"), "Returns true if x is a volatile.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2540), lang.NewKeyword("end-line"), int(2540))).(*lang.Symbol) + tmp0 := sym_volatile_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x is a volatile.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(2540), kw_end_DASH_line, int(2540))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_instance_QMARK_) + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) tmp5 := reflect.TypeOf((*lang.Volatile)(nil)).Elem() tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -55531,12 +54949,10 @@ func LoadNS() { } // vreset! { - tmp0 := lang.NewSymbol("vreset!").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("vol"), lang.NewSymbol("newval"))), lang.NewKeyword("doc"), "Sets the value of volatile to newval without regard for the\n current value. Returns newval.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(2524), lang.NewKeyword("end-line"), int(2524))).(*lang.Symbol) + tmp0 := sym_vreset_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_vol, sym_newval)), kw_doc, "Sets the value of volatile to newval without regard for the\n current value. Returns newval.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(2524), kw_end_DASH_line, int(2524))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -55548,7 +54964,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v4}) return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -55556,14 +54972,12 @@ func LoadNS() { } // vswap! { - tmp0 := lang.NewSymbol("vswap!").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("vol"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Non-atomically swaps the value of the volatile as if:\n (apply f current-value-of-vol args). Returns the value that\n was swapped in.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.7", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(2531), lang.NewKeyword("end-line"), int(2531))).(*lang.Symbol) + tmp0 := sym_vswap_BANG_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_vol, sym_f, sym__AMP_, sym_args)), kw_doc, "Non-atomically swaps the value of the volatile as if:\n (apply f current-value-of-vol args). Returns the value that\n was swapped in.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(11), kw_line, int(2531), kw_end_DASH_line, int(2531))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 4 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 4) v3 := args[0] _ = v3 v4 := args[1] @@ -55577,9 +54991,9 @@ func LoadNS() { var tmp8 any { // let // let binding "v" - tmp9 := checkDerefVar(glojure_DOT_core_with_meta) - tmp10 := lang.NewMap(lang.NewKeyword("tag"), lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Volatile")) - tmp11 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(2537), lang.NewKeyword("column"), int(26), lang.NewKeyword("end-line"), int(2537), lang.NewKeyword("end-column"), int(81)) + tmp9 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp10 := lang.NewMap(kw_tag, sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Volatile) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2537), kw_column, int(26), kw_end_DASH_line, int(2537), kw_end_DASH_column, int(81)) tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) if err != nil { panic(err) @@ -55587,23 +55001,23 @@ func LoadNS() { tmp13 := lang.Apply(tmp9, []any{v5, tmp12}) var v14 any = tmp13 _ = v14 - tmp15 := checkDerefVar(glojure_DOT_core_seq) - tmp16 := checkDerefVar(glojure_DOT_core_concat) - tmp17 := checkDerefVar(glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{lang.NewSymbol(".reset")}) - tmp19 := checkDerefVar(glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym__DOT_reset}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) tmp20 := lang.Apply(tmp19, []any{v14}) - tmp21 := checkDerefVar(glojure_DOT_core_list) - tmp22 := checkDerefVar(glojure_DOT_core_seq) - tmp23 := checkDerefVar(glojure_DOT_core_concat) - tmp24 := checkDerefVar(glojure_DOT_core_list) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := checkDerefVar(var_glojure_DOT_core_seq) + tmp23 := checkDerefVar(var_glojure_DOT_core_concat) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) tmp25 := lang.Apply(tmp24, []any{v6}) - tmp26 := checkDerefVar(glojure_DOT_core_list) - tmp27 := checkDerefVar(glojure_DOT_core_seq) - tmp28 := checkDerefVar(glojure_DOT_core_concat) - tmp29 := checkDerefVar(glojure_DOT_core_list) - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol(".Deref")}) - tmp31 := checkDerefVar(glojure_DOT_core_list) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := checkDerefVar(var_glojure_DOT_core_seq) + tmp28 := checkDerefVar(var_glojure_DOT_core_concat) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{sym__DOT_Deref}) + tmp31 := checkDerefVar(var_glojure_DOT_core_list) tmp32 := lang.Apply(tmp31, []any{v14}) tmp33 := lang.Apply(tmp28, []any{tmp30, tmp32}) tmp34 := lang.Apply(tmp27, []any{tmp33}) @@ -55618,7 +55032,7 @@ func LoadNS() { return tmp8 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -55626,14 +55040,12 @@ func LoadNS() { } // when { - tmp0 := lang.NewSymbol("when").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("test"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Evaluates test. If logical true, evaluates body in an implicit do.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(14), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(492), lang.NewKeyword("end-line"), int(492))).(*lang.Symbol) + tmp0 := sym_when.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_test, sym__AMP_, sym_body)), kw_doc, "Evaluates test. If logical true, evaluates body in an implicit do.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(11), kw_line, int(492), kw_end_DASH_line, int(492))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -55642,14 +55054,14 @@ func LoadNS() { _ = v5 var v6 any = lang.NewList(args[3:]...) _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_list) - tmp8 := checkDerefVar(glojure_DOT_core_cons) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("do"), v6}) - tmp10 := lang.Apply(tmp7, []any{lang.NewSymbol("if"), v5, tmp9}) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := checkDerefVar(var_glojure_DOT_core_cons) + tmp9 := lang.Apply(tmp8, []any{sym_do, v6}) + tmp10 := lang.Apply(tmp7, []any{sym_if, v5, tmp9}) return tmp10 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -55657,14 +55069,12 @@ func LoadNS() { } // when-first { - tmp0 := lang.NewSymbol("when-first").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "bindings => x xs\n\n Roughly the same as (when (seq xs) (let [x (first xs)] body)) but xs is evaluated only once", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4622), lang.NewKeyword("end-line"), int(4622))).(*lang.Symbol) + tmp0 := sym_when_DASH_first.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "bindings => x xs\n\n Roughly the same as (when (seq xs) (let [x (first xs)] body)) but xs is evaluated only once", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(11), kw_line, int(4622), kw_end_DASH_line, int(4622))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -55674,36 +55084,36 @@ func LoadNS() { var v6 any = lang.NewList(args[3:]...) _ = v6 var tmp7 any - tmp8 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp8 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) tmp9 := lang.Apply(tmp8, []any{v5}) if lang.IsTruthy(tmp9) { } else { - tmp10 := checkDerefVar(glojure_DOT_core_str) - tmp11 := checkDerefVar(glojure_DOT_core_first) + tmp10 := checkDerefVar(var_glojure_DOT_core_str) + tmp11 := checkDerefVar(var_glojure_DOT_core_first) tmp12 := lang.Apply(tmp11, []any{v3}) - tmp13 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) - tmp14 := checkDerefVar(glojure_DOT_core_meta) + tmp13 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp14 := checkDerefVar(var_glojure_DOT_core_meta) tmp15 := lang.Apply(tmp14, []any{v3}) - tmp16 := lang.Apply(lang.NewKeyword("line"), []any{tmp15}) + tmp16 := lang.Apply(kw_line, []any{tmp15}) tmp17 := lang.Apply(tmp10, []any{tmp12, " requires ", "a vector for its binding", " in ", tmp13, ":", tmp16}) tmp18 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp17}) panic(tmp18) } _ = tmp7 var tmp19 any - tmp20 := checkDerefVar(glojure_DOT_core__EQ_) - tmp21 := checkDerefVar(glojure_DOT_core_count) + tmp20 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp21 := checkDerefVar(var_glojure_DOT_core_count) tmp22 := lang.Apply(tmp21, []any{v5}) tmp23 := lang.Apply(tmp20, []any{int64(2), tmp22}) if lang.IsTruthy(tmp23) { } else { - tmp24 := checkDerefVar(glojure_DOT_core_str) - tmp25 := checkDerefVar(glojure_DOT_core_first) + tmp24 := checkDerefVar(var_glojure_DOT_core_str) + tmp25 := checkDerefVar(var_glojure_DOT_core_first) tmp26 := lang.Apply(tmp25, []any{v3}) - tmp27 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) - tmp28 := checkDerefVar(glojure_DOT_core_meta) + tmp27 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp28 := checkDerefVar(var_glojure_DOT_core_meta) tmp29 := lang.Apply(tmp28, []any{v3}) - tmp30 := lang.Apply(lang.NewKeyword("line"), []any{tmp29}) + tmp30 := lang.Apply(kw_line, []any{tmp29}) tmp31 := lang.Apply(tmp24, []any{tmp26, " requires ", "exactly 2 forms in binding vector", " in ", tmp27, ":", tmp30}) tmp32 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp31}) panic(tmp32) @@ -55715,32 +55125,32 @@ func LoadNS() { var v34 any = v5 _ = v34 // let binding "x" - tmp35 := checkDerefVar(glojure_DOT_core_nth) + tmp35 := checkDerefVar(var_glojure_DOT_core_nth) tmp36 := lang.Apply(tmp35, []any{v34, int64(0), nil}) var v37 any = tmp36 _ = v37 // let binding "xs" - tmp38 := checkDerefVar(glojure_DOT_core_nth) + tmp38 := checkDerefVar(var_glojure_DOT_core_nth) tmp39 := lang.Apply(tmp38, []any{v34, int64(1), nil}) var v40 any = tmp39 _ = v40 - tmp41 := checkDerefVar(glojure_DOT_core_seq) - tmp42 := checkDerefVar(glojure_DOT_core_concat) - tmp43 := checkDerefVar(glojure_DOT_core_list) - tmp44 := lang.Apply(tmp43, []any{lang.NewSymbol("glojure.core/when-let")}) - tmp45 := checkDerefVar(glojure_DOT_core_list) - tmp46 := checkDerefVar(glojure_DOT_core_apply) - tmp47 := checkDerefVar(glojure_DOT_core_vector) - tmp48 := checkDerefVar(glojure_DOT_core_seq) - tmp49 := checkDerefVar(glojure_DOT_core_concat) - tmp50 := checkDerefVar(glojure_DOT_core_list) - tmp51 := lang.Apply(tmp50, []any{lang.NewSymbol("xs__0__auto__")}) - tmp52 := checkDerefVar(glojure_DOT_core_list) - tmp53 := checkDerefVar(glojure_DOT_core_seq) - tmp54 := checkDerefVar(glojure_DOT_core_concat) - tmp55 := checkDerefVar(glojure_DOT_core_list) - tmp56 := lang.Apply(tmp55, []any{lang.NewSymbol("glojure.core/seq")}) - tmp57 := checkDerefVar(glojure_DOT_core_list) + tmp41 := checkDerefVar(var_glojure_DOT_core_seq) + tmp42 := checkDerefVar(var_glojure_DOT_core_concat) + tmp43 := checkDerefVar(var_glojure_DOT_core_list) + tmp44 := lang.Apply(tmp43, []any{sym_glojure_DOT_core_SLASH_when_DASH_let}) + tmp45 := checkDerefVar(var_glojure_DOT_core_list) + tmp46 := checkDerefVar(var_glojure_DOT_core_apply) + tmp47 := checkDerefVar(var_glojure_DOT_core_vector) + tmp48 := checkDerefVar(var_glojure_DOT_core_seq) + tmp49 := checkDerefVar(var_glojure_DOT_core_concat) + tmp50 := checkDerefVar(var_glojure_DOT_core_list) + tmp51 := lang.Apply(tmp50, []any{sym_xs__0__auto__}) + tmp52 := checkDerefVar(var_glojure_DOT_core_list) + tmp53 := checkDerefVar(var_glojure_DOT_core_seq) + tmp54 := checkDerefVar(var_glojure_DOT_core_concat) + tmp55 := checkDerefVar(var_glojure_DOT_core_list) + tmp56 := lang.Apply(tmp55, []any{sym_glojure_DOT_core_SLASH_seq}) + tmp57 := checkDerefVar(var_glojure_DOT_core_list) tmp58 := lang.Apply(tmp57, []any{v40}) tmp59 := lang.Apply(tmp54, []any{tmp56, tmp58}) tmp60 := lang.Apply(tmp53, []any{tmp59}) @@ -55749,25 +55159,25 @@ func LoadNS() { tmp63 := lang.Apply(tmp48, []any{tmp62}) tmp64 := lang.Apply(tmp46, []any{tmp47, tmp63}) tmp65 := lang.Apply(tmp45, []any{tmp64}) - tmp66 := checkDerefVar(glojure_DOT_core_list) - tmp67 := checkDerefVar(glojure_DOT_core_seq) - tmp68 := checkDerefVar(glojure_DOT_core_concat) - tmp69 := checkDerefVar(glojure_DOT_core_list) - tmp70 := lang.Apply(tmp69, []any{lang.NewSymbol("glojure.core/let")}) - tmp71 := checkDerefVar(glojure_DOT_core_list) - tmp72 := checkDerefVar(glojure_DOT_core_apply) - tmp73 := checkDerefVar(glojure_DOT_core_vector) - tmp74 := checkDerefVar(glojure_DOT_core_seq) - tmp75 := checkDerefVar(glojure_DOT_core_concat) - tmp76 := checkDerefVar(glojure_DOT_core_list) + tmp66 := checkDerefVar(var_glojure_DOT_core_list) + tmp67 := checkDerefVar(var_glojure_DOT_core_seq) + tmp68 := checkDerefVar(var_glojure_DOT_core_concat) + tmp69 := checkDerefVar(var_glojure_DOT_core_list) + tmp70 := lang.Apply(tmp69, []any{sym_glojure_DOT_core_SLASH_let}) + tmp71 := checkDerefVar(var_glojure_DOT_core_list) + tmp72 := checkDerefVar(var_glojure_DOT_core_apply) + tmp73 := checkDerefVar(var_glojure_DOT_core_vector) + tmp74 := checkDerefVar(var_glojure_DOT_core_seq) + tmp75 := checkDerefVar(var_glojure_DOT_core_concat) + tmp76 := checkDerefVar(var_glojure_DOT_core_list) tmp77 := lang.Apply(tmp76, []any{v37}) - tmp78 := checkDerefVar(glojure_DOT_core_list) - tmp79 := checkDerefVar(glojure_DOT_core_seq) - tmp80 := checkDerefVar(glojure_DOT_core_concat) - tmp81 := checkDerefVar(glojure_DOT_core_list) - tmp82 := lang.Apply(tmp81, []any{lang.NewSymbol("glojure.core/first")}) - tmp83 := checkDerefVar(glojure_DOT_core_list) - tmp84 := lang.Apply(tmp83, []any{lang.NewSymbol("xs__0__auto__")}) + tmp78 := checkDerefVar(var_glojure_DOT_core_list) + tmp79 := checkDerefVar(var_glojure_DOT_core_seq) + tmp80 := checkDerefVar(var_glojure_DOT_core_concat) + tmp81 := checkDerefVar(var_glojure_DOT_core_list) + tmp82 := lang.Apply(tmp81, []any{sym_glojure_DOT_core_SLASH_first}) + tmp83 := checkDerefVar(var_glojure_DOT_core_list) + tmp84 := lang.Apply(tmp83, []any{sym_xs__0__auto__}) tmp85 := lang.Apply(tmp80, []any{tmp82, tmp84}) tmp86 := lang.Apply(tmp79, []any{tmp85}) tmp87 := lang.Apply(tmp78, []any{tmp86}) @@ -55785,7 +55195,7 @@ func LoadNS() { return tmp33 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -55793,14 +55203,12 @@ func LoadNS() { } // when-let { - tmp0 := lang.NewSymbol("when-let").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "bindings => binding-form test\n\n When test is true, evaluates body with binding-form bound to the value of test", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1859), lang.NewKeyword("end-line"), int(1859))).(*lang.Symbol) + tmp0 := sym_when_DASH_let.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "bindings => binding-form test\n\n When test is true, evaluates body with binding-form bound to the value of test", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(11), kw_line, int(1859), kw_end_DASH_line, int(1859))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -55810,36 +55218,36 @@ func LoadNS() { var v6 any = lang.NewList(args[3:]...) _ = v6 var tmp7 any - tmp8 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp8 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) tmp9 := lang.Apply(tmp8, []any{v5}) if lang.IsTruthy(tmp9) { } else { - tmp10 := checkDerefVar(glojure_DOT_core_str) - tmp11 := checkDerefVar(glojure_DOT_core_first) + tmp10 := checkDerefVar(var_glojure_DOT_core_str) + tmp11 := checkDerefVar(var_glojure_DOT_core_first) tmp12 := lang.Apply(tmp11, []any{v3}) - tmp13 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) - tmp14 := checkDerefVar(glojure_DOT_core_meta) + tmp13 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp14 := checkDerefVar(var_glojure_DOT_core_meta) tmp15 := lang.Apply(tmp14, []any{v3}) - tmp16 := lang.Apply(lang.NewKeyword("line"), []any{tmp15}) + tmp16 := lang.Apply(kw_line, []any{tmp15}) tmp17 := lang.Apply(tmp10, []any{tmp12, " requires ", "a vector for its binding", " in ", tmp13, ":", tmp16}) tmp18 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp17}) panic(tmp18) } _ = tmp7 var tmp19 any - tmp20 := checkDerefVar(glojure_DOT_core__EQ_) - tmp21 := checkDerefVar(glojure_DOT_core_count) + tmp20 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp21 := checkDerefVar(var_glojure_DOT_core_count) tmp22 := lang.Apply(tmp21, []any{v5}) tmp23 := lang.Apply(tmp20, []any{int64(2), tmp22}) if lang.IsTruthy(tmp23) { } else { - tmp24 := checkDerefVar(glojure_DOT_core_str) - tmp25 := checkDerefVar(glojure_DOT_core_first) + tmp24 := checkDerefVar(var_glojure_DOT_core_str) + tmp25 := checkDerefVar(var_glojure_DOT_core_first) tmp26 := lang.Apply(tmp25, []any{v3}) - tmp27 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) - tmp28 := checkDerefVar(glojure_DOT_core_meta) + tmp27 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp28 := checkDerefVar(var_glojure_DOT_core_meta) tmp29 := lang.Apply(tmp28, []any{v3}) - tmp30 := lang.Apply(lang.NewKeyword("line"), []any{tmp29}) + tmp30 := lang.Apply(kw_line, []any{tmp29}) tmp31 := lang.Apply(tmp24, []any{tmp26, " requires ", "exactly 2 forms in binding vector", " in ", tmp27, ":", tmp30}) tmp32 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp31}) panic(tmp32) @@ -55855,44 +55263,44 @@ func LoadNS() { tmp36 := lang.Apply(v5, []any{int64(1)}) var v37 any = tmp36 _ = v37 - tmp38 := checkDerefVar(glojure_DOT_core_seq) - tmp39 := checkDerefVar(glojure_DOT_core_concat) - tmp40 := checkDerefVar(glojure_DOT_core_list) - tmp41 := lang.Apply(tmp40, []any{lang.NewSymbol("glojure.core/let")}) - tmp42 := checkDerefVar(glojure_DOT_core_list) - tmp43 := checkDerefVar(glojure_DOT_core_apply) - tmp44 := checkDerefVar(glojure_DOT_core_vector) - tmp45 := checkDerefVar(glojure_DOT_core_seq) - tmp46 := checkDerefVar(glojure_DOT_core_concat) - tmp47 := checkDerefVar(glojure_DOT_core_list) - tmp48 := lang.Apply(tmp47, []any{lang.NewSymbol("temp__0__auto__")}) - tmp49 := checkDerefVar(glojure_DOT_core_list) + tmp38 := checkDerefVar(var_glojure_DOT_core_seq) + tmp39 := checkDerefVar(var_glojure_DOT_core_concat) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{sym_glojure_DOT_core_SLASH_let}) + tmp42 := checkDerefVar(var_glojure_DOT_core_list) + tmp43 := checkDerefVar(var_glojure_DOT_core_apply) + tmp44 := checkDerefVar(var_glojure_DOT_core_vector) + tmp45 := checkDerefVar(var_glojure_DOT_core_seq) + tmp46 := checkDerefVar(var_glojure_DOT_core_concat) + tmp47 := checkDerefVar(var_glojure_DOT_core_list) + tmp48 := lang.Apply(tmp47, []any{sym_temp__0__auto__}) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) tmp50 := lang.Apply(tmp49, []any{v37}) tmp51 := lang.Apply(tmp46, []any{tmp48, tmp50}) tmp52 := lang.Apply(tmp45, []any{tmp51}) tmp53 := lang.Apply(tmp43, []any{tmp44, tmp52}) tmp54 := lang.Apply(tmp42, []any{tmp53}) - tmp55 := checkDerefVar(glojure_DOT_core_list) - tmp56 := checkDerefVar(glojure_DOT_core_seq) - tmp57 := checkDerefVar(glojure_DOT_core_concat) - tmp58 := checkDerefVar(glojure_DOT_core_list) - tmp59 := lang.Apply(tmp58, []any{lang.NewSymbol("glojure.core/when")}) - tmp60 := checkDerefVar(glojure_DOT_core_list) - tmp61 := lang.Apply(tmp60, []any{lang.NewSymbol("temp__0__auto__")}) - tmp62 := checkDerefVar(glojure_DOT_core_list) - tmp63 := checkDerefVar(glojure_DOT_core_seq) - tmp64 := checkDerefVar(glojure_DOT_core_concat) - tmp65 := checkDerefVar(glojure_DOT_core_list) - tmp66 := lang.Apply(tmp65, []any{lang.NewSymbol("glojure.core/let")}) - tmp67 := checkDerefVar(glojure_DOT_core_list) - tmp68 := checkDerefVar(glojure_DOT_core_apply) - tmp69 := checkDerefVar(glojure_DOT_core_vector) - tmp70 := checkDerefVar(glojure_DOT_core_seq) - tmp71 := checkDerefVar(glojure_DOT_core_concat) - tmp72 := checkDerefVar(glojure_DOT_core_list) + tmp55 := checkDerefVar(var_glojure_DOT_core_list) + tmp56 := checkDerefVar(var_glojure_DOT_core_seq) + tmp57 := checkDerefVar(var_glojure_DOT_core_concat) + tmp58 := checkDerefVar(var_glojure_DOT_core_list) + tmp59 := lang.Apply(tmp58, []any{sym_glojure_DOT_core_SLASH_when}) + tmp60 := checkDerefVar(var_glojure_DOT_core_list) + tmp61 := lang.Apply(tmp60, []any{sym_temp__0__auto__}) + tmp62 := checkDerefVar(var_glojure_DOT_core_list) + tmp63 := checkDerefVar(var_glojure_DOT_core_seq) + tmp64 := checkDerefVar(var_glojure_DOT_core_concat) + tmp65 := checkDerefVar(var_glojure_DOT_core_list) + tmp66 := lang.Apply(tmp65, []any{sym_glojure_DOT_core_SLASH_let}) + tmp67 := checkDerefVar(var_glojure_DOT_core_list) + tmp68 := checkDerefVar(var_glojure_DOT_core_apply) + tmp69 := checkDerefVar(var_glojure_DOT_core_vector) + tmp70 := checkDerefVar(var_glojure_DOT_core_seq) + tmp71 := checkDerefVar(var_glojure_DOT_core_concat) + tmp72 := checkDerefVar(var_glojure_DOT_core_list) tmp73 := lang.Apply(tmp72, []any{v35}) - tmp74 := checkDerefVar(glojure_DOT_core_list) - tmp75 := lang.Apply(tmp74, []any{lang.NewSymbol("temp__0__auto__")}) + tmp74 := checkDerefVar(var_glojure_DOT_core_list) + tmp75 := lang.Apply(tmp74, []any{sym_temp__0__auto__}) tmp76 := lang.Apply(tmp71, []any{tmp73, tmp75}) tmp77 := lang.Apply(tmp70, []any{tmp76}) tmp78 := lang.Apply(tmp68, []any{tmp69, tmp77}) @@ -55910,7 +55318,7 @@ func LoadNS() { return tmp33 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -55918,14 +55326,12 @@ func LoadNS() { } // when-not { - tmp0 := lang.NewSymbol("when-not").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("test"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Evaluates test. If logical false, evaluates body in an implicit do.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(498), lang.NewKeyword("end-line"), int(498))).(*lang.Symbol) + tmp0 := sym_when_DASH_not.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_test, sym__AMP_, sym_body)), kw_doc, "Evaluates test. If logical false, evaluates body in an implicit do.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(11), kw_line, int(498), kw_end_DASH_line, int(498))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -55934,14 +55340,14 @@ func LoadNS() { _ = v5 var v6 any = lang.NewList(args[3:]...) _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_list) - tmp8 := checkDerefVar(glojure_DOT_core_cons) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("do"), v6}) - tmp10 := lang.Apply(tmp7, []any{lang.NewSymbol("if"), v5, nil, tmp9}) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := checkDerefVar(var_glojure_DOT_core_cons) + tmp9 := lang.Apply(tmp8, []any{sym_do, v6}) + tmp10 := lang.Apply(tmp7, []any{sym_if, v5, nil, tmp9}) return tmp10 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -55949,14 +55355,12 @@ func LoadNS() { } // when-some { - tmp0 := lang.NewSymbol("when-some").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "bindings => binding-form test\n\n When test is not nil, evaluates body with binding-form bound to the\n value of test", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.6", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1894), lang.NewKeyword("end-line"), int(1894))).(*lang.Symbol) + tmp0 := sym_when_DASH_some.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "bindings => binding-form test\n\n When test is not nil, evaluates body with binding-form bound to the\n value of test", kw_file, "glojure/core.glj", kw_added, "1.6", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(11), kw_line, int(1894), kw_end_DASH_line, int(1894))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -55966,36 +55370,36 @@ func LoadNS() { var v6 any = lang.NewList(args[3:]...) _ = v6 var tmp7 any - tmp8 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp8 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) tmp9 := lang.Apply(tmp8, []any{v5}) if lang.IsTruthy(tmp9) { } else { - tmp10 := checkDerefVar(glojure_DOT_core_str) - tmp11 := checkDerefVar(glojure_DOT_core_first) + tmp10 := checkDerefVar(var_glojure_DOT_core_str) + tmp11 := checkDerefVar(var_glojure_DOT_core_first) tmp12 := lang.Apply(tmp11, []any{v3}) - tmp13 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) - tmp14 := checkDerefVar(glojure_DOT_core_meta) + tmp13 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp14 := checkDerefVar(var_glojure_DOT_core_meta) tmp15 := lang.Apply(tmp14, []any{v3}) - tmp16 := lang.Apply(lang.NewKeyword("line"), []any{tmp15}) + tmp16 := lang.Apply(kw_line, []any{tmp15}) tmp17 := lang.Apply(tmp10, []any{tmp12, " requires ", "a vector for its binding", " in ", tmp13, ":", tmp16}) tmp18 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp17}) panic(tmp18) } _ = tmp7 var tmp19 any - tmp20 := checkDerefVar(glojure_DOT_core__EQ_) - tmp21 := checkDerefVar(glojure_DOT_core_count) + tmp20 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp21 := checkDerefVar(var_glojure_DOT_core_count) tmp22 := lang.Apply(tmp21, []any{v5}) tmp23 := lang.Apply(tmp20, []any{int64(2), tmp22}) if lang.IsTruthy(tmp23) { } else { - tmp24 := checkDerefVar(glojure_DOT_core_str) - tmp25 := checkDerefVar(glojure_DOT_core_first) + tmp24 := checkDerefVar(var_glojure_DOT_core_str) + tmp25 := checkDerefVar(var_glojure_DOT_core_first) tmp26 := lang.Apply(tmp25, []any{v3}) - tmp27 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) - tmp28 := checkDerefVar(glojure_DOT_core_meta) + tmp27 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp28 := checkDerefVar(var_glojure_DOT_core_meta) tmp29 := lang.Apply(tmp28, []any{v3}) - tmp30 := lang.Apply(lang.NewKeyword("line"), []any{tmp29}) + tmp30 := lang.Apply(kw_line, []any{tmp29}) tmp31 := lang.Apply(tmp24, []any{tmp26, " requires ", "exactly 2 forms in binding vector", " in ", tmp27, ":", tmp30}) tmp32 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp31}) panic(tmp32) @@ -56011,54 +55415,54 @@ func LoadNS() { tmp36 := lang.Apply(v5, []any{int64(1)}) var v37 any = tmp36 _ = v37 - tmp38 := checkDerefVar(glojure_DOT_core_seq) - tmp39 := checkDerefVar(glojure_DOT_core_concat) - tmp40 := checkDerefVar(glojure_DOT_core_list) - tmp41 := lang.Apply(tmp40, []any{lang.NewSymbol("glojure.core/let")}) - tmp42 := checkDerefVar(glojure_DOT_core_list) - tmp43 := checkDerefVar(glojure_DOT_core_apply) - tmp44 := checkDerefVar(glojure_DOT_core_vector) - tmp45 := checkDerefVar(glojure_DOT_core_seq) - tmp46 := checkDerefVar(glojure_DOT_core_concat) - tmp47 := checkDerefVar(glojure_DOT_core_list) - tmp48 := lang.Apply(tmp47, []any{lang.NewSymbol("temp__0__auto__")}) - tmp49 := checkDerefVar(glojure_DOT_core_list) + tmp38 := checkDerefVar(var_glojure_DOT_core_seq) + tmp39 := checkDerefVar(var_glojure_DOT_core_concat) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{sym_glojure_DOT_core_SLASH_let}) + tmp42 := checkDerefVar(var_glojure_DOT_core_list) + tmp43 := checkDerefVar(var_glojure_DOT_core_apply) + tmp44 := checkDerefVar(var_glojure_DOT_core_vector) + tmp45 := checkDerefVar(var_glojure_DOT_core_seq) + tmp46 := checkDerefVar(var_glojure_DOT_core_concat) + tmp47 := checkDerefVar(var_glojure_DOT_core_list) + tmp48 := lang.Apply(tmp47, []any{sym_temp__0__auto__}) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) tmp50 := lang.Apply(tmp49, []any{v37}) tmp51 := lang.Apply(tmp46, []any{tmp48, tmp50}) tmp52 := lang.Apply(tmp45, []any{tmp51}) tmp53 := lang.Apply(tmp43, []any{tmp44, tmp52}) tmp54 := lang.Apply(tmp42, []any{tmp53}) - tmp55 := checkDerefVar(glojure_DOT_core_list) - tmp56 := checkDerefVar(glojure_DOT_core_seq) - tmp57 := checkDerefVar(glojure_DOT_core_concat) - tmp58 := checkDerefVar(glojure_DOT_core_list) - tmp59 := lang.Apply(tmp58, []any{lang.NewSymbol("if")}) - tmp60 := checkDerefVar(glojure_DOT_core_list) - tmp61 := checkDerefVar(glojure_DOT_core_seq) - tmp62 := checkDerefVar(glojure_DOT_core_concat) - tmp63 := checkDerefVar(glojure_DOT_core_list) - tmp64 := lang.Apply(tmp63, []any{lang.NewSymbol("glojure.core/nil?")}) - tmp65 := checkDerefVar(glojure_DOT_core_list) - tmp66 := lang.Apply(tmp65, []any{lang.NewSymbol("temp__0__auto__")}) + tmp55 := checkDerefVar(var_glojure_DOT_core_list) + tmp56 := checkDerefVar(var_glojure_DOT_core_seq) + tmp57 := checkDerefVar(var_glojure_DOT_core_concat) + tmp58 := checkDerefVar(var_glojure_DOT_core_list) + tmp59 := lang.Apply(tmp58, []any{sym_if}) + tmp60 := checkDerefVar(var_glojure_DOT_core_list) + tmp61 := checkDerefVar(var_glojure_DOT_core_seq) + tmp62 := checkDerefVar(var_glojure_DOT_core_concat) + tmp63 := checkDerefVar(var_glojure_DOT_core_list) + tmp64 := lang.Apply(tmp63, []any{sym_glojure_DOT_core_SLASH_nil_QMARK_}) + tmp65 := checkDerefVar(var_glojure_DOT_core_list) + tmp66 := lang.Apply(tmp65, []any{sym_temp__0__auto__}) tmp67 := lang.Apply(tmp62, []any{tmp64, tmp66}) tmp68 := lang.Apply(tmp61, []any{tmp67}) tmp69 := lang.Apply(tmp60, []any{tmp68}) - tmp70 := checkDerefVar(glojure_DOT_core_list) + tmp70 := checkDerefVar(var_glojure_DOT_core_list) tmp71 := lang.Apply(tmp70, []any{nil}) - tmp72 := checkDerefVar(glojure_DOT_core_list) - tmp73 := checkDerefVar(glojure_DOT_core_seq) - tmp74 := checkDerefVar(glojure_DOT_core_concat) - tmp75 := checkDerefVar(glojure_DOT_core_list) - tmp76 := lang.Apply(tmp75, []any{lang.NewSymbol("glojure.core/let")}) - tmp77 := checkDerefVar(glojure_DOT_core_list) - tmp78 := checkDerefVar(glojure_DOT_core_apply) - tmp79 := checkDerefVar(glojure_DOT_core_vector) - tmp80 := checkDerefVar(glojure_DOT_core_seq) - tmp81 := checkDerefVar(glojure_DOT_core_concat) - tmp82 := checkDerefVar(glojure_DOT_core_list) + tmp72 := checkDerefVar(var_glojure_DOT_core_list) + tmp73 := checkDerefVar(var_glojure_DOT_core_seq) + tmp74 := checkDerefVar(var_glojure_DOT_core_concat) + tmp75 := checkDerefVar(var_glojure_DOT_core_list) + tmp76 := lang.Apply(tmp75, []any{sym_glojure_DOT_core_SLASH_let}) + tmp77 := checkDerefVar(var_glojure_DOT_core_list) + tmp78 := checkDerefVar(var_glojure_DOT_core_apply) + tmp79 := checkDerefVar(var_glojure_DOT_core_vector) + tmp80 := checkDerefVar(var_glojure_DOT_core_seq) + tmp81 := checkDerefVar(var_glojure_DOT_core_concat) + tmp82 := checkDerefVar(var_glojure_DOT_core_list) tmp83 := lang.Apply(tmp82, []any{v35}) - tmp84 := checkDerefVar(glojure_DOT_core_list) - tmp85 := lang.Apply(tmp84, []any{lang.NewSymbol("temp__0__auto__")}) + tmp84 := checkDerefVar(var_glojure_DOT_core_list) + tmp85 := lang.Apply(tmp84, []any{sym_temp__0__auto__}) tmp86 := lang.Apply(tmp81, []any{tmp83, tmp85}) tmp87 := lang.Apply(tmp80, []any{tmp86}) tmp88 := lang.Apply(tmp78, []any{tmp79, tmp87}) @@ -56076,7 +55480,7 @@ func LoadNS() { return tmp33 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -56084,14 +55488,12 @@ func LoadNS() { } // while { - tmp0 := lang.NewSymbol("while").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("test"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Repeatedly executes body while test expression is true. Presumes\n some side-effect will cause test to become false/nil. Returns nil", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(6327), lang.NewKeyword("end-line"), int(6327))).(*lang.Symbol) + tmp0 := sym_while.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_test, sym__AMP_, sym_body)), kw_doc, "Repeatedly executes body while test expression is true. Presumes\n some side-effect will cause test to become false/nil. Returns nil", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(11), kw_line, int(6327), kw_end_DASH_line, int(6327))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -56100,31 +55502,31 @@ func LoadNS() { _ = v5 var v6 any = lang.NewList(args[3:]...) _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_seq) - tmp8 := checkDerefVar(glojure_DOT_core_concat) - tmp9 := checkDerefVar(glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("glojure.core/loop")}) - tmp11 := checkDerefVar(glojure_DOT_core_list) - tmp12 := checkDerefVar(glojure_DOT_core_apply) - tmp13 := checkDerefVar(glojure_DOT_core_vector) - tmp14 := checkDerefVar(glojure_DOT_core_seq) - tmp15 := checkDerefVar(glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_core_SLASH_loop}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_apply) + tmp13 := checkDerefVar(var_glojure_DOT_core_vector) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) tmp16 := lang.Apply(tmp15, nil) tmp17 := lang.Apply(tmp14, []any{tmp16}) tmp18 := lang.Apply(tmp12, []any{tmp13, tmp17}) tmp19 := lang.Apply(tmp11, []any{tmp18}) - tmp20 := checkDerefVar(glojure_DOT_core_list) - tmp21 := checkDerefVar(glojure_DOT_core_seq) - tmp22 := checkDerefVar(glojure_DOT_core_concat) - tmp23 := checkDerefVar(glojure_DOT_core_list) - tmp24 := lang.Apply(tmp23, []any{lang.NewSymbol("glojure.core/when")}) - tmp25 := checkDerefVar(glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := checkDerefVar(var_glojure_DOT_core_seq) + tmp22 := checkDerefVar(var_glojure_DOT_core_concat) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := lang.Apply(tmp23, []any{sym_glojure_DOT_core_SLASH_when}) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) tmp26 := lang.Apply(tmp25, []any{v5}) - tmp27 := checkDerefVar(glojure_DOT_core_list) - tmp28 := checkDerefVar(glojure_DOT_core_seq) - tmp29 := checkDerefVar(glojure_DOT_core_concat) - tmp30 := checkDerefVar(glojure_DOT_core_list) - tmp31 := lang.Apply(tmp30, []any{lang.NewSymbol("recur")}) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := checkDerefVar(var_glojure_DOT_core_seq) + tmp29 := checkDerefVar(var_glojure_DOT_core_concat) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := lang.Apply(tmp30, []any{sym_recur}) tmp32 := lang.Apply(tmp29, []any{tmp31}) tmp33 := lang.Apply(tmp28, []any{tmp32}) tmp34 := lang.Apply(tmp27, []any{tmp33}) @@ -56136,7 +55538,7 @@ func LoadNS() { return tmp39 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -56144,14 +55546,12 @@ func LoadNS() { } // with-bindings { - tmp0 := lang.NewSymbol("with-bindings").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("binding-map"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Takes a map of Var/value pairs. Installs for the given Vars the associated\n values as thread-local bindings. Then executes body. Pops the installed\n bindings after body was evaluated. Returns the value of body.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(1984), lang.NewKeyword("end-line"), int(1984))).(*lang.Symbol) + tmp0 := sym_with_DASH_bindings.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_binding_DASH_map, sym__AMP_, sym_body)), kw_doc, "Takes a map of Var/value pairs. Installs for the given Vars the associated\n values as thread-local bindings. Then executes body. Pops the installed\n bindings after body was evaluated. Returns the value of body.", kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(11), kw_line, int(1984), kw_end_DASH_line, int(1984))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -56160,22 +55560,22 @@ func LoadNS() { _ = v5 var v6 any = lang.NewList(args[3:]...) _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_seq) - tmp8 := checkDerefVar(glojure_DOT_core_concat) - tmp9 := checkDerefVar(glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("glojure.core/with-bindings*")}) - tmp11 := checkDerefVar(glojure_DOT_core_list) + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_core_SLASH_with_DASH_bindings_STAR_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) tmp12 := lang.Apply(tmp11, []any{v5}) - tmp13 := checkDerefVar(glojure_DOT_core_list) - tmp14 := checkDerefVar(glojure_DOT_core_seq) - tmp15 := checkDerefVar(glojure_DOT_core_concat) - tmp16 := checkDerefVar(glojure_DOT_core_list) - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("glojure.core/fn")}) - tmp18 := checkDerefVar(glojure_DOT_core_list) - tmp19 := checkDerefVar(glojure_DOT_core_apply) - tmp20 := checkDerefVar(glojure_DOT_core_vector) - tmp21 := checkDerefVar(glojure_DOT_core_seq) - tmp22 := checkDerefVar(glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{sym_glojure_DOT_core_SLASH_fn}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := checkDerefVar(var_glojure_DOT_core_apply) + tmp20 := checkDerefVar(var_glojure_DOT_core_vector) + tmp21 := checkDerefVar(var_glojure_DOT_core_seq) + tmp22 := checkDerefVar(var_glojure_DOT_core_concat) tmp23 := lang.Apply(tmp22, nil) tmp24 := lang.Apply(tmp21, []any{tmp23}) tmp25 := lang.Apply(tmp19, []any{tmp20, tmp24}) @@ -56188,7 +55588,7 @@ func LoadNS() { return tmp31 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -56196,38 +55596,36 @@ func LoadNS() { } // with-bindings* { - tmp0 := lang.NewSymbol("with-bindings*").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("binding-map"), lang.NewSymbol("f"), lang.NewSymbol("&"), lang.NewSymbol("args"))), lang.NewKeyword("doc"), "Takes a map of Var/value pairs. Installs for the given Vars the associated\n values as thread-local bindings. Then calls f with the supplied arguments.\n Pops the installed bindings after f returned. Returns whatever f returns.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.1", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(1971), lang.NewKeyword("end-line"), int(1971))).(*lang.Symbol) + tmp0 := sym_with_DASH_bindings_STAR_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_binding_DASH_map, sym_f, sym__AMP_, sym_args)), kw_doc, "Takes a map of Var/value pairs. Installs for the given Vars the associated\n values as thread-local bindings. Then calls f with the supplied arguments.\n Pops the installed bindings after f returned. Returns whatever f returns.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(1971), kw_end_DASH_line, int(1971))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 var v5 any = lang.NewList(args[2:]...) _ = v5 - tmp6 := checkDerefVar(glojure_DOT_core_push_thread_bindings) + tmp6 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) tmp7 := lang.Apply(tmp6, []any{v3}) _ = tmp7 var tmp8 any func() { defer func() { - tmp9 := checkDerefVar(glojure_DOT_core_pop_thread_bindings) + tmp9 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) tmp10 := lang.Apply(tmp9, nil) _ = tmp10 }() - tmp11 := checkDerefVar(glojure_DOT_core_apply) + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) tmp12 := lang.Apply(tmp11, []any{v4, v5}) tmp8 = tmp12 }() return tmp8 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -56235,14 +55633,12 @@ func LoadNS() { } // with-in-str { - tmp0 := lang.NewSymbol("with-in-str").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("s"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Evaluates body in a context in which *in* is bound to a fresh\n StringReader initialized with the string s.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4749), lang.NewKeyword("end-line"), int(4749))).(*lang.Symbol) + tmp0 := sym_with_DASH_in_DASH_str.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_s, sym__AMP_, sym_body)), kw_doc, "Evaluates body in a context in which *in* is bound to a fresh\n StringReader initialized with the string s.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(11), kw_line, int(4749), kw_end_DASH_line, int(4749))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -56251,34 +55647,34 @@ func LoadNS() { _ = v5 var v6 any = lang.NewList(args[3:]...) _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_seq) - tmp8 := checkDerefVar(glojure_DOT_core_concat) - tmp9 := checkDerefVar(glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("glojure.core/with-open")}) - tmp11 := checkDerefVar(glojure_DOT_core_list) - tmp12 := checkDerefVar(glojure_DOT_core_apply) - tmp13 := checkDerefVar(glojure_DOT_core_vector) - tmp14 := checkDerefVar(glojure_DOT_core_seq) - tmp15 := checkDerefVar(glojure_DOT_core_concat) - tmp16 := checkDerefVar(glojure_DOT_core_list) - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("s__0__auto__")}) - tmp18 := checkDerefVar(glojure_DOT_core_list) - tmp19 := checkDerefVar(glojure_DOT_core_seq) - tmp20 := checkDerefVar(glojure_DOT_core_concat) - tmp21 := checkDerefVar(glojure_DOT_core_list) - tmp22 := lang.Apply(tmp21, []any{lang.NewSymbol("glojure.core/->")}) - tmp23 := checkDerefVar(glojure_DOT_core_list) - tmp24 := checkDerefVar(glojure_DOT_core_seq) - tmp25 := checkDerefVar(glojure_DOT_core_concat) - tmp26 := checkDerefVar(glojure_DOT_core_list) - tmp27 := lang.Apply(tmp26, []any{lang.NewSymbol("java.io.StringReader.")}) - tmp28 := checkDerefVar(glojure_DOT_core_list) + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_core_SLASH_with_DASH_open}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_apply) + tmp13 := checkDerefVar(var_glojure_DOT_core_vector) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{sym_s__0__auto__}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := checkDerefVar(var_glojure_DOT_core_seq) + tmp20 := checkDerefVar(var_glojure_DOT_core_concat) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{sym_glojure_DOT_core_SLASH__DASH__GT_}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_seq) + tmp25 := checkDerefVar(var_glojure_DOT_core_concat) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{sym_java_DOT_io_DOT_StringReader_DOT_}) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) tmp29 := lang.Apply(tmp28, []any{v5}) tmp30 := lang.Apply(tmp25, []any{tmp27, tmp29}) tmp31 := lang.Apply(tmp24, []any{tmp30}) tmp32 := lang.Apply(tmp23, []any{tmp31}) - tmp33 := checkDerefVar(glojure_DOT_core_list) - tmp34 := lang.Apply(tmp33, []any{lang.NewSymbol("glojure.lang.LineNumberingPushbackReader.")}) + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{sym_glojure_DOT_lang_DOT_LineNumberingPushbackReader_DOT_}) tmp35 := lang.Apply(tmp20, []any{tmp22, tmp32, tmp34}) tmp36 := lang.Apply(tmp19, []any{tmp35}) tmp37 := lang.Apply(tmp18, []any{tmp36}) @@ -56286,20 +55682,20 @@ func LoadNS() { tmp39 := lang.Apply(tmp14, []any{tmp38}) tmp40 := lang.Apply(tmp12, []any{tmp13, tmp39}) tmp41 := lang.Apply(tmp11, []any{tmp40}) - tmp42 := checkDerefVar(glojure_DOT_core_list) - tmp43 := checkDerefVar(glojure_DOT_core_seq) - tmp44 := checkDerefVar(glojure_DOT_core_concat) - tmp45 := checkDerefVar(glojure_DOT_core_list) - tmp46 := lang.Apply(tmp45, []any{lang.NewSymbol("glojure.core/binding")}) - tmp47 := checkDerefVar(glojure_DOT_core_list) - tmp48 := checkDerefVar(glojure_DOT_core_apply) - tmp49 := checkDerefVar(glojure_DOT_core_vector) - tmp50 := checkDerefVar(glojure_DOT_core_seq) - tmp51 := checkDerefVar(glojure_DOT_core_concat) - tmp52 := checkDerefVar(glojure_DOT_core_list) - tmp53 := lang.Apply(tmp52, []any{lang.NewSymbol("glojure.core/*in*")}) - tmp54 := checkDerefVar(glojure_DOT_core_list) - tmp55 := lang.Apply(tmp54, []any{lang.NewSymbol("s__0__auto__")}) + tmp42 := checkDerefVar(var_glojure_DOT_core_list) + tmp43 := checkDerefVar(var_glojure_DOT_core_seq) + tmp44 := checkDerefVar(var_glojure_DOT_core_concat) + tmp45 := checkDerefVar(var_glojure_DOT_core_list) + tmp46 := lang.Apply(tmp45, []any{sym_glojure_DOT_core_SLASH_binding}) + tmp47 := checkDerefVar(var_glojure_DOT_core_list) + tmp48 := checkDerefVar(var_glojure_DOT_core_apply) + tmp49 := checkDerefVar(var_glojure_DOT_core_vector) + tmp50 := checkDerefVar(var_glojure_DOT_core_seq) + tmp51 := checkDerefVar(var_glojure_DOT_core_concat) + tmp52 := checkDerefVar(var_glojure_DOT_core_list) + tmp53 := lang.Apply(tmp52, []any{sym_glojure_DOT_core_SLASH__STAR_in_STAR_}) + tmp54 := checkDerefVar(var_glojure_DOT_core_list) + tmp55 := lang.Apply(tmp54, []any{sym_s__0__auto__}) tmp56 := lang.Apply(tmp51, []any{tmp53, tmp55}) tmp57 := lang.Apply(tmp50, []any{tmp56}) tmp58 := lang.Apply(tmp48, []any{tmp49, tmp57}) @@ -56312,7 +55708,7 @@ func LoadNS() { return tmp64 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -56320,48 +55716,46 @@ func LoadNS() { } // with-loading-context { - tmp0 := lang.NewSymbol("with-loading-context").WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5734), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(5734), lang.NewKeyword("end-column"), int(30), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("macro"), true)).(*lang.Symbol) + tmp0 := sym_with_DASH_loading_DASH_context.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5734), kw_column, int(11), kw_end_DASH_line, int(5734), kw_end_DASH_column, int(30), kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_body)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_macro, true)).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 var v5 any = lang.NewList(args[2:]...) _ = v5 - tmp6 := checkDerefVar(glojure_DOT_core_seq) - tmp7 := checkDerefVar(glojure_DOT_core_concat) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := checkDerefVar(glojure_DOT_core_seq) - tmp10 := checkDerefVar(glojure_DOT_core_concat) - tmp11 := checkDerefVar(glojure_DOT_core_list) - tmp12 := lang.Apply(tmp11, []any{lang.NewSymbol("glojure.core/fn")}) - tmp13 := checkDerefVar(glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("loading__0__auto__")}) - tmp15 := checkDerefVar(glojure_DOT_core_list) - tmp16 := checkDerefVar(glojure_DOT_core_apply) - tmp17 := checkDerefVar(glojure_DOT_core_vector) - tmp18 := checkDerefVar(glojure_DOT_core_seq) - tmp19 := checkDerefVar(glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := checkDerefVar(var_glojure_DOT_core_seq) + tmp10 := checkDerefVar(var_glojure_DOT_core_concat) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_glojure_DOT_core_SLASH_fn}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_loading__0__auto__}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := checkDerefVar(var_glojure_DOT_core_apply) + tmp17 := checkDerefVar(var_glojure_DOT_core_vector) + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) tmp20 := lang.Apply(tmp19, nil) tmp21 := lang.Apply(tmp18, []any{tmp20}) tmp22 := lang.Apply(tmp16, []any{tmp17, tmp21}) tmp23 := lang.Apply(tmp15, []any{tmp22}) - tmp24 := checkDerefVar(glojure_DOT_core_list) - tmp25 := checkDerefVar(glojure_DOT_core_seq) - tmp26 := checkDerefVar(glojure_DOT_core_concat) - tmp27 := checkDerefVar(glojure_DOT_core_list) - tmp28 := lang.Apply(tmp27, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.PushThreadBindings")}) - tmp29 := checkDerefVar(glojure_DOT_core_list) - tmp30 := checkDerefVar(glojure_DOT_core_apply) - tmp31 := checkDerefVar(glojure_DOT_core_hash_map) - tmp32 := checkDerefVar(glojure_DOT_core_seq) - tmp33 := checkDerefVar(glojure_DOT_core_concat) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := checkDerefVar(var_glojure_DOT_core_seq) + tmp26 := checkDerefVar(var_glojure_DOT_core_concat) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_PushThreadBindings}) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := checkDerefVar(var_glojure_DOT_core_apply) + tmp31 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp32 := checkDerefVar(var_glojure_DOT_core_seq) + tmp33 := checkDerefVar(var_glojure_DOT_core_concat) tmp34 := lang.Apply(tmp33, nil) tmp35 := lang.Apply(tmp32, []any{tmp34}) tmp36 := lang.Apply(tmp30, []any{tmp31, tmp35}) @@ -56369,21 +55763,21 @@ func LoadNS() { tmp38 := lang.Apply(tmp26, []any{tmp28, tmp37}) tmp39 := lang.Apply(tmp25, []any{tmp38}) tmp40 := lang.Apply(tmp24, []any{tmp39}) - tmp41 := checkDerefVar(glojure_DOT_core_list) - tmp42 := checkDerefVar(glojure_DOT_core_seq) - tmp43 := checkDerefVar(glojure_DOT_core_concat) - tmp44 := checkDerefVar(glojure_DOT_core_list) - tmp45 := lang.Apply(tmp44, []any{lang.NewSymbol("try")}) - tmp46 := checkDerefVar(glojure_DOT_core_list) - tmp47 := checkDerefVar(glojure_DOT_core_seq) - tmp48 := checkDerefVar(glojure_DOT_core_concat) - tmp49 := checkDerefVar(glojure_DOT_core_list) - tmp50 := lang.Apply(tmp49, []any{lang.NewSymbol("finally")}) - tmp51 := checkDerefVar(glojure_DOT_core_list) - tmp52 := checkDerefVar(glojure_DOT_core_seq) - tmp53 := checkDerefVar(glojure_DOT_core_concat) - tmp54 := checkDerefVar(glojure_DOT_core_list) - tmp55 := lang.Apply(tmp54, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.PopThreadBindings")}) + tmp41 := checkDerefVar(var_glojure_DOT_core_list) + tmp42 := checkDerefVar(var_glojure_DOT_core_seq) + tmp43 := checkDerefVar(var_glojure_DOT_core_concat) + tmp44 := checkDerefVar(var_glojure_DOT_core_list) + tmp45 := lang.Apply(tmp44, []any{sym_try}) + tmp46 := checkDerefVar(var_glojure_DOT_core_list) + tmp47 := checkDerefVar(var_glojure_DOT_core_seq) + tmp48 := checkDerefVar(var_glojure_DOT_core_concat) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) + tmp50 := lang.Apply(tmp49, []any{sym_finally}) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := checkDerefVar(var_glojure_DOT_core_seq) + tmp53 := checkDerefVar(var_glojure_DOT_core_concat) + tmp54 := checkDerefVar(var_glojure_DOT_core_list) + tmp55 := lang.Apply(tmp54, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_PopThreadBindings}) tmp56 := lang.Apply(tmp53, []any{tmp55}) tmp57 := lang.Apply(tmp52, []any{tmp56}) tmp58 := lang.Apply(tmp51, []any{tmp57}) @@ -56401,7 +55795,7 @@ func LoadNS() { return tmp69 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -56409,14 +55803,12 @@ func LoadNS() { } // with-local-vars { - tmp0 := lang.NewSymbol("with-local-vars").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("name-vals-vec"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "varbinding=> symbol init-expr\n\n Executes the exprs in a context in which the symbols are bound to\n vars with per-thread bindings to the init-exprs. The symbols refer\n to the var objects themselves, and must be accessed with var-get and\n var-set", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4339), lang.NewKeyword("end-line"), int(4339))).(*lang.Symbol) + tmp0 := sym_with_DASH_local_DASH_vars.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name_DASH_vals_DASH_vec, sym__AMP_, sym_body)), kw_doc, "varbinding=> symbol init-expr\n\n Executes the exprs in a context in which the symbols are bound to\n vars with per-thread bindings to the init-exprs. The symbols refer\n to the var objects themselves, and must be accessed with var-get and\n var-set", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(25), kw_column, int(11), kw_line, int(4339), kw_end_DASH_line, int(4339))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -56426,70 +55818,70 @@ func LoadNS() { var v6 any = lang.NewList(args[3:]...) _ = v6 var tmp7 any - tmp8 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp8 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) tmp9 := lang.Apply(tmp8, []any{v5}) if lang.IsTruthy(tmp9) { } else { - tmp10 := checkDerefVar(glojure_DOT_core_str) - tmp11 := checkDerefVar(glojure_DOT_core_first) + tmp10 := checkDerefVar(var_glojure_DOT_core_str) + tmp11 := checkDerefVar(var_glojure_DOT_core_first) tmp12 := lang.Apply(tmp11, []any{v3}) - tmp13 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) - tmp14 := checkDerefVar(glojure_DOT_core_meta) + tmp13 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp14 := checkDerefVar(var_glojure_DOT_core_meta) tmp15 := lang.Apply(tmp14, []any{v3}) - tmp16 := lang.Apply(lang.NewKeyword("line"), []any{tmp15}) + tmp16 := lang.Apply(kw_line, []any{tmp15}) tmp17 := lang.Apply(tmp10, []any{tmp12, " requires ", "a vector for its binding", " in ", tmp13, ":", tmp16}) tmp18 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp17}) panic(tmp18) } _ = tmp7 var tmp19 any - tmp20 := checkDerefVar(glojure_DOT_core_even_QMARK_) - tmp21 := checkDerefVar(glojure_DOT_core_count) + tmp20 := checkDerefVar(var_glojure_DOT_core_even_QMARK_) + tmp21 := checkDerefVar(var_glojure_DOT_core_count) tmp22 := lang.Apply(tmp21, []any{v5}) tmp23 := lang.Apply(tmp20, []any{tmp22}) if lang.IsTruthy(tmp23) { } else { - tmp24 := checkDerefVar(glojure_DOT_core_str) - tmp25 := checkDerefVar(glojure_DOT_core_first) + tmp24 := checkDerefVar(var_glojure_DOT_core_str) + tmp25 := checkDerefVar(var_glojure_DOT_core_first) tmp26 := lang.Apply(tmp25, []any{v3}) - tmp27 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) - tmp28 := checkDerefVar(glojure_DOT_core_meta) + tmp27 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp28 := checkDerefVar(var_glojure_DOT_core_meta) tmp29 := lang.Apply(tmp28, []any{v3}) - tmp30 := lang.Apply(lang.NewKeyword("line"), []any{tmp29}) + tmp30 := lang.Apply(kw_line, []any{tmp29}) tmp31 := lang.Apply(tmp24, []any{tmp26, " requires ", "an even number of forms in binding vector", " in ", tmp27, ":", tmp30}) tmp32 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp31}) panic(tmp32) } _ = tmp19 - tmp33 := checkDerefVar(glojure_DOT_core_seq) - tmp34 := checkDerefVar(glojure_DOT_core_concat) - tmp35 := checkDerefVar(glojure_DOT_core_list) - tmp36 := lang.Apply(tmp35, []any{lang.NewSymbol("glojure.core/let")}) - tmp37 := checkDerefVar(glojure_DOT_core_list) - tmp38 := checkDerefVar(glojure_DOT_core_apply) - tmp39 := checkDerefVar(glojure_DOT_core_vector) - tmp40 := checkDerefVar(glojure_DOT_core_seq) - tmp41 := checkDerefVar(glojure_DOT_core_concat) - tmp42 := checkDerefVar(glojure_DOT_core_interleave) - tmp43 := checkDerefVar(glojure_DOT_core_take_nth) + tmp33 := checkDerefVar(var_glojure_DOT_core_seq) + tmp34 := checkDerefVar(var_glojure_DOT_core_concat) + tmp35 := checkDerefVar(var_glojure_DOT_core_list) + tmp36 := lang.Apply(tmp35, []any{sym_glojure_DOT_core_SLASH_let}) + tmp37 := checkDerefVar(var_glojure_DOT_core_list) + tmp38 := checkDerefVar(var_glojure_DOT_core_apply) + tmp39 := checkDerefVar(var_glojure_DOT_core_vector) + tmp40 := checkDerefVar(var_glojure_DOT_core_seq) + tmp41 := checkDerefVar(var_glojure_DOT_core_concat) + tmp42 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp43 := checkDerefVar(var_glojure_DOT_core_take_DASH_nth) tmp44 := lang.Apply(tmp43, []any{int64(2), v5}) - tmp45 := checkDerefVar(glojure_DOT_core_repeat) - tmp46 := lang.Apply(tmp45, []any{lang.NewList(lang.NewSymbol(".."), lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.*Var"), lang.NewSymbol("create"), lang.NewSymbol("setDynamic"))}) + tmp45 := checkDerefVar(var_glojure_DOT_core_repeat) + tmp46 := lang.Apply(tmp45, []any{lang.NewList(sym__DOT__DOT_, sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT__STAR_Var, sym_create, sym_setDynamic)}) tmp47 := lang.Apply(tmp42, []any{tmp44, tmp46}) tmp48 := lang.Apply(tmp41, []any{tmp47}) tmp49 := lang.Apply(tmp40, []any{tmp48}) tmp50 := lang.Apply(tmp38, []any{tmp39, tmp49}) tmp51 := lang.Apply(tmp37, []any{tmp50}) - tmp52 := checkDerefVar(glojure_DOT_core_list) - tmp53 := checkDerefVar(glojure_DOT_core_seq) - tmp54 := checkDerefVar(glojure_DOT_core_concat) - tmp55 := checkDerefVar(glojure_DOT_core_list) - tmp56 := lang.Apply(tmp55, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.PushThreadBindings")}) - tmp57 := checkDerefVar(glojure_DOT_core_list) - tmp58 := checkDerefVar(glojure_DOT_core_apply) - tmp59 := checkDerefVar(glojure_DOT_core_hash_map) - tmp60 := checkDerefVar(glojure_DOT_core_seq) - tmp61 := checkDerefVar(glojure_DOT_core_concat) + tmp52 := checkDerefVar(var_glojure_DOT_core_list) + tmp53 := checkDerefVar(var_glojure_DOT_core_seq) + tmp54 := checkDerefVar(var_glojure_DOT_core_concat) + tmp55 := checkDerefVar(var_glojure_DOT_core_list) + tmp56 := lang.Apply(tmp55, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_PushThreadBindings}) + tmp57 := checkDerefVar(var_glojure_DOT_core_list) + tmp58 := checkDerefVar(var_glojure_DOT_core_apply) + tmp59 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp60 := checkDerefVar(var_glojure_DOT_core_seq) + tmp61 := checkDerefVar(var_glojure_DOT_core_concat) tmp62 := lang.Apply(tmp61, nil) tmp63 := lang.Apply(tmp60, []any{tmp62}) tmp64 := lang.Apply(tmp58, []any{tmp59, tmp63}) @@ -56497,21 +55889,21 @@ func LoadNS() { tmp66 := lang.Apply(tmp54, []any{tmp56, tmp65}) tmp67 := lang.Apply(tmp53, []any{tmp66}) tmp68 := lang.Apply(tmp52, []any{tmp67}) - tmp69 := checkDerefVar(glojure_DOT_core_list) - tmp70 := checkDerefVar(glojure_DOT_core_seq) - tmp71 := checkDerefVar(glojure_DOT_core_concat) - tmp72 := checkDerefVar(glojure_DOT_core_list) - tmp73 := lang.Apply(tmp72, []any{lang.NewSymbol("try")}) - tmp74 := checkDerefVar(glojure_DOT_core_list) - tmp75 := checkDerefVar(glojure_DOT_core_seq) - tmp76 := checkDerefVar(glojure_DOT_core_concat) - tmp77 := checkDerefVar(glojure_DOT_core_list) - tmp78 := lang.Apply(tmp77, []any{lang.NewSymbol("finally")}) - tmp79 := checkDerefVar(glojure_DOT_core_list) - tmp80 := checkDerefVar(glojure_DOT_core_seq) - tmp81 := checkDerefVar(glojure_DOT_core_concat) - tmp82 := checkDerefVar(glojure_DOT_core_list) - tmp83 := lang.Apply(tmp82, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.PopThreadBindings")}) + tmp69 := checkDerefVar(var_glojure_DOT_core_list) + tmp70 := checkDerefVar(var_glojure_DOT_core_seq) + tmp71 := checkDerefVar(var_glojure_DOT_core_concat) + tmp72 := checkDerefVar(var_glojure_DOT_core_list) + tmp73 := lang.Apply(tmp72, []any{sym_try}) + tmp74 := checkDerefVar(var_glojure_DOT_core_list) + tmp75 := checkDerefVar(var_glojure_DOT_core_seq) + tmp76 := checkDerefVar(var_glojure_DOT_core_concat) + tmp77 := checkDerefVar(var_glojure_DOT_core_list) + tmp78 := lang.Apply(tmp77, []any{sym_finally}) + tmp79 := checkDerefVar(var_glojure_DOT_core_list) + tmp80 := checkDerefVar(var_glojure_DOT_core_seq) + tmp81 := checkDerefVar(var_glojure_DOT_core_concat) + tmp82 := checkDerefVar(var_glojure_DOT_core_list) + tmp83 := lang.Apply(tmp82, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_PopThreadBindings}) tmp84 := lang.Apply(tmp81, []any{tmp83}) tmp85 := lang.Apply(tmp80, []any{tmp84}) tmp86 := lang.Apply(tmp79, []any{tmp85}) @@ -56526,7 +55918,7 @@ func LoadNS() { return tmp94 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -56534,14 +55926,12 @@ func LoadNS() { } // with-meta { - tmp0 := lang.NewSymbol("with-meta").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("obj"), lang.NewSymbol("m"))), lang.NewKeyword("doc"), "Returns an object of the same type and value as obj, with\n map m as its metadata.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(10), lang.NewKeyword("column"), int(2), lang.NewKeyword("line"), int(211), lang.NewKeyword("end-line"), int(216))).(*lang.Symbol) + tmp0 := sym_with_DASH_meta.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_obj, sym_m)), kw_doc, "Returns an object of the same type and value as obj, with\n map m as its metadata.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(2), kw_line, int(211), kw_end_DASH_line, int(216))).(*lang.Symbol) var tmp2 lang.FnFunc { // function with-meta var v3 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -56553,7 +55943,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v5}) return tmp7 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(216), lang.NewKeyword("column"), int(12), lang.NewKeyword("end-line"), int(217), lang.NewKeyword("end-column"), int(32))).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(216), kw_column, int(12), kw_end_DASH_line, int(217), kw_end_DASH_column, int(32))).(lang.FnFunc) v3 = tmp2 _ = v3 } @@ -56564,14 +55954,12 @@ func LoadNS() { } // with-open { - tmp0 := lang.NewSymbol("with-open").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "bindings => [name init ...]\n\n Evaluates body in a try expression with names bound to the values\n of the inits, and a finally clause that calls (.close name) on each\n name in reverse order.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(19), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(3832), lang.NewKeyword("end-line"), int(3832))).(*lang.Symbol) + tmp0 := sym_with_DASH_open.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "bindings => [name init ...]\n\n Evaluates body in a try expression with names bound to the values\n of the inits, and a finally clause that calls (.close name) on each\n name in reverse order.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(11), kw_line, int(3832), kw_end_DASH_line, int(3832))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -56581,100 +55969,100 @@ func LoadNS() { var v6 any = lang.NewList(args[3:]...) _ = v6 var tmp7 any - tmp8 := checkDerefVar(glojure_DOT_core_vector_QMARK_) + tmp8 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) tmp9 := lang.Apply(tmp8, []any{v5}) if lang.IsTruthy(tmp9) { } else { - tmp10 := checkDerefVar(glojure_DOT_core_str) - tmp11 := checkDerefVar(glojure_DOT_core_first) + tmp10 := checkDerefVar(var_glojure_DOT_core_str) + tmp11 := checkDerefVar(var_glojure_DOT_core_first) tmp12 := lang.Apply(tmp11, []any{v3}) - tmp13 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) - tmp14 := checkDerefVar(glojure_DOT_core_meta) + tmp13 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp14 := checkDerefVar(var_glojure_DOT_core_meta) tmp15 := lang.Apply(tmp14, []any{v3}) - tmp16 := lang.Apply(lang.NewKeyword("line"), []any{tmp15}) + tmp16 := lang.Apply(kw_line, []any{tmp15}) tmp17 := lang.Apply(tmp10, []any{tmp12, " requires ", "a vector for its binding", " in ", tmp13, ":", tmp16}) tmp18 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp17}) panic(tmp18) } _ = tmp7 var tmp19 any - tmp20 := checkDerefVar(glojure_DOT_core_even_QMARK_) - tmp21 := checkDerefVar(glojure_DOT_core_count) + tmp20 := checkDerefVar(var_glojure_DOT_core_even_QMARK_) + tmp21 := checkDerefVar(var_glojure_DOT_core_count) tmp22 := lang.Apply(tmp21, []any{v5}) tmp23 := lang.Apply(tmp20, []any{tmp22}) if lang.IsTruthy(tmp23) { } else { - tmp24 := checkDerefVar(glojure_DOT_core_str) - tmp25 := checkDerefVar(glojure_DOT_core_first) + tmp24 := checkDerefVar(var_glojure_DOT_core_str) + tmp25 := checkDerefVar(var_glojure_DOT_core_first) tmp26 := lang.Apply(tmp25, []any{v3}) - tmp27 := checkDerefVar(glojure_DOT_core__STAR_ns_STAR_) - tmp28 := checkDerefVar(glojure_DOT_core_meta) + tmp27 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp28 := checkDerefVar(var_glojure_DOT_core_meta) tmp29 := lang.Apply(tmp28, []any{v3}) - tmp30 := lang.Apply(lang.NewKeyword("line"), []any{tmp29}) + tmp30 := lang.Apply(kw_line, []any{tmp29}) tmp31 := lang.Apply(tmp24, []any{tmp26, " requires ", "an even number of forms in binding vector", " in ", tmp27, ":", tmp30}) tmp32 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp31}) panic(tmp32) } _ = tmp19 var tmp33 any - tmp34 := checkDerefVar(glojure_DOT_core__EQ_) - tmp35 := checkDerefVar(glojure_DOT_core_count) + tmp34 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp35 := checkDerefVar(var_glojure_DOT_core_count) tmp36 := lang.Apply(tmp35, []any{v5}) tmp37 := lang.Apply(tmp34, []any{tmp36, int64(0)}) if lang.IsTruthy(tmp37) { - tmp38 := checkDerefVar(glojure_DOT_core_seq) - tmp39 := checkDerefVar(glojure_DOT_core_concat) - tmp40 := checkDerefVar(glojure_DOT_core_list) - tmp41 := lang.Apply(tmp40, []any{lang.NewSymbol("do")}) + tmp38 := checkDerefVar(var_glojure_DOT_core_seq) + tmp39 := checkDerefVar(var_glojure_DOT_core_concat) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{sym_do}) tmp42 := lang.Apply(tmp39, []any{tmp41, v6}) tmp43 := lang.Apply(tmp38, []any{tmp42}) tmp33 = tmp43 } else { var tmp44 any - tmp45 := checkDerefVar(glojure_DOT_core_symbol_QMARK_) + tmp45 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) tmp46 := lang.Apply(v5, []any{int64(0)}) tmp47 := lang.Apply(tmp45, []any{tmp46}) if lang.IsTruthy(tmp47) { - tmp48 := checkDerefVar(glojure_DOT_core_seq) - tmp49 := checkDerefVar(glojure_DOT_core_concat) - tmp50 := checkDerefVar(glojure_DOT_core_list) - tmp51 := lang.Apply(tmp50, []any{lang.NewSymbol("glojure.core/let")}) - tmp52 := checkDerefVar(glojure_DOT_core_list) - tmp53 := checkDerefVar(glojure_DOT_core_subvec) + tmp48 := checkDerefVar(var_glojure_DOT_core_seq) + tmp49 := checkDerefVar(var_glojure_DOT_core_concat) + tmp50 := checkDerefVar(var_glojure_DOT_core_list) + tmp51 := lang.Apply(tmp50, []any{sym_glojure_DOT_core_SLASH_let}) + tmp52 := checkDerefVar(var_glojure_DOT_core_list) + tmp53 := checkDerefVar(var_glojure_DOT_core_subvec) tmp54 := lang.Apply(tmp53, []any{v5, int64(0), int64(2)}) tmp55 := lang.Apply(tmp52, []any{tmp54}) - tmp56 := checkDerefVar(glojure_DOT_core_list) - tmp57 := checkDerefVar(glojure_DOT_core_seq) - tmp58 := checkDerefVar(glojure_DOT_core_concat) - tmp59 := checkDerefVar(glojure_DOT_core_list) - tmp60 := lang.Apply(tmp59, []any{lang.NewSymbol("try")}) - tmp61 := checkDerefVar(glojure_DOT_core_list) - tmp62 := checkDerefVar(glojure_DOT_core_seq) - tmp63 := checkDerefVar(glojure_DOT_core_concat) - tmp64 := checkDerefVar(glojure_DOT_core_list) - tmp65 := lang.Apply(tmp64, []any{lang.NewSymbol("glojure.core/with-open")}) - tmp66 := checkDerefVar(glojure_DOT_core_list) - tmp67 := checkDerefVar(glojure_DOT_core_subvec) + tmp56 := checkDerefVar(var_glojure_DOT_core_list) + tmp57 := checkDerefVar(var_glojure_DOT_core_seq) + tmp58 := checkDerefVar(var_glojure_DOT_core_concat) + tmp59 := checkDerefVar(var_glojure_DOT_core_list) + tmp60 := lang.Apply(tmp59, []any{sym_try}) + tmp61 := checkDerefVar(var_glojure_DOT_core_list) + tmp62 := checkDerefVar(var_glojure_DOT_core_seq) + tmp63 := checkDerefVar(var_glojure_DOT_core_concat) + tmp64 := checkDerefVar(var_glojure_DOT_core_list) + tmp65 := lang.Apply(tmp64, []any{sym_glojure_DOT_core_SLASH_with_DASH_open}) + tmp66 := checkDerefVar(var_glojure_DOT_core_list) + tmp67 := checkDerefVar(var_glojure_DOT_core_subvec) tmp68 := lang.Apply(tmp67, []any{v5, int64(2)}) tmp69 := lang.Apply(tmp66, []any{tmp68}) tmp70 := lang.Apply(tmp63, []any{tmp65, tmp69, v6}) tmp71 := lang.Apply(tmp62, []any{tmp70}) tmp72 := lang.Apply(tmp61, []any{tmp71}) - tmp73 := checkDerefVar(glojure_DOT_core_list) - tmp74 := checkDerefVar(glojure_DOT_core_seq) - tmp75 := checkDerefVar(glojure_DOT_core_concat) - tmp76 := checkDerefVar(glojure_DOT_core_list) - tmp77 := lang.Apply(tmp76, []any{lang.NewSymbol("finally")}) - tmp78 := checkDerefVar(glojure_DOT_core_list) - tmp79 := checkDerefVar(glojure_DOT_core_seq) - tmp80 := checkDerefVar(glojure_DOT_core_concat) - tmp81 := checkDerefVar(glojure_DOT_core_list) - tmp82 := lang.Apply(tmp81, []any{lang.NewSymbol(".")}) - tmp83 := checkDerefVar(glojure_DOT_core_list) + tmp73 := checkDerefVar(var_glojure_DOT_core_list) + tmp74 := checkDerefVar(var_glojure_DOT_core_seq) + tmp75 := checkDerefVar(var_glojure_DOT_core_concat) + tmp76 := checkDerefVar(var_glojure_DOT_core_list) + tmp77 := lang.Apply(tmp76, []any{sym_finally}) + tmp78 := checkDerefVar(var_glojure_DOT_core_list) + tmp79 := checkDerefVar(var_glojure_DOT_core_seq) + tmp80 := checkDerefVar(var_glojure_DOT_core_concat) + tmp81 := checkDerefVar(var_glojure_DOT_core_list) + tmp82 := lang.Apply(tmp81, []any{sym__DOT_}) + tmp83 := checkDerefVar(var_glojure_DOT_core_list) tmp84 := lang.Apply(v5, []any{int64(0)}) tmp85 := lang.Apply(tmp83, []any{tmp84}) - tmp86 := checkDerefVar(glojure_DOT_core_list) - tmp87 := lang.Apply(tmp86, []any{lang.NewSymbol("close")}) + tmp86 := checkDerefVar(var_glojure_DOT_core_list) + tmp87 := lang.Apply(tmp86, []any{sym_close}) tmp88 := lang.Apply(tmp80, []any{tmp82, tmp85, tmp87}) tmp89 := lang.Apply(tmp79, []any{tmp88}) tmp90 := lang.Apply(tmp78, []any{tmp89}) @@ -56689,7 +56077,7 @@ func LoadNS() { tmp44 = tmp98 } else { var tmp99 any - if lang.IsTruthy(lang.NewKeyword("else")) { + if lang.IsTruthy(kw_else) { tmp100 := lang.Apply(lang.NewIllegalArgumentError, []any{"with-open only allows Symbols in bindings"}) panic(tmp100) } else { @@ -56701,7 +56089,7 @@ func LoadNS() { return tmp33 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -56709,38 +56097,36 @@ func LoadNS() { } // with-out-str { - tmp0 := lang.NewSymbol("with-out-str").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "Evaluates exprs in a context in which *out* is bound to a fresh\n StringWriter. Returns the string created by any nested printing\n calls.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(4738), lang.NewKeyword("end-line"), int(4738))).(*lang.Symbol) + tmp0 := sym_with_DASH_out_DASH_str.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_body)), kw_doc, "Evaluates exprs in a context in which *out* is bound to a fresh\n StringWriter. Returns the string created by any nested printing\n calls.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(22), kw_column, int(11), kw_line, int(4738), kw_end_DASH_line, int(4738))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 var v5 any = lang.NewList(args[2:]...) _ = v5 - tmp6 := checkDerefVar(glojure_DOT_core_seq) - tmp7 := checkDerefVar(glojure_DOT_core_concat) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("glojure.core/let")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := checkDerefVar(glojure_DOT_core_apply) - tmp12 := checkDerefVar(glojure_DOT_core_vector) - tmp13 := checkDerefVar(glojure_DOT_core_seq) - tmp14 := checkDerefVar(glojure_DOT_core_concat) - tmp15 := checkDerefVar(glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{lang.NewSymbol("s__0__auto__")}) - tmp17 := checkDerefVar(glojure_DOT_core_list) - tmp18 := checkDerefVar(glojure_DOT_core_seq) - tmp19 := checkDerefVar(glojure_DOT_core_concat) - tmp20 := checkDerefVar(glojure_DOT_core_list) - tmp21 := lang.Apply(tmp20, []any{lang.NewSymbol("new")}) - tmp22 := checkDerefVar(glojure_DOT_core_list) - tmp23 := lang.Apply(tmp22, []any{lang.NewSymbol("strings.Builder")}) + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_let}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + tmp12 := checkDerefVar(var_glojure_DOT_core_vector) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_s__0__auto__}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{sym_new}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{sym_strings_DOT_Builder}) tmp24 := lang.Apply(tmp19, []any{tmp21, tmp23}) tmp25 := lang.Apply(tmp18, []any{tmp24}) tmp26 := lang.Apply(tmp17, []any{tmp25}) @@ -56748,31 +56134,31 @@ func LoadNS() { tmp28 := lang.Apply(tmp13, []any{tmp27}) tmp29 := lang.Apply(tmp11, []any{tmp12, tmp28}) tmp30 := lang.Apply(tmp10, []any{tmp29}) - tmp31 := checkDerefVar(glojure_DOT_core_list) - tmp32 := checkDerefVar(glojure_DOT_core_seq) - tmp33 := checkDerefVar(glojure_DOT_core_concat) - tmp34 := checkDerefVar(glojure_DOT_core_list) - tmp35 := lang.Apply(tmp34, []any{lang.NewSymbol("glojure.core/binding")}) - tmp36 := checkDerefVar(glojure_DOT_core_list) - tmp37 := checkDerefVar(glojure_DOT_core_apply) - tmp38 := checkDerefVar(glojure_DOT_core_vector) - tmp39 := checkDerefVar(glojure_DOT_core_seq) - tmp40 := checkDerefVar(glojure_DOT_core_concat) - tmp41 := checkDerefVar(glojure_DOT_core_list) - tmp42 := lang.Apply(tmp41, []any{lang.NewSymbol("glojure.core/*out*")}) - tmp43 := checkDerefVar(glojure_DOT_core_list) - tmp44 := lang.Apply(tmp43, []any{lang.NewSymbol("s__0__auto__")}) + tmp31 := checkDerefVar(var_glojure_DOT_core_list) + tmp32 := checkDerefVar(var_glojure_DOT_core_seq) + tmp33 := checkDerefVar(var_glojure_DOT_core_concat) + tmp34 := checkDerefVar(var_glojure_DOT_core_list) + tmp35 := lang.Apply(tmp34, []any{sym_glojure_DOT_core_SLASH_binding}) + tmp36 := checkDerefVar(var_glojure_DOT_core_list) + tmp37 := checkDerefVar(var_glojure_DOT_core_apply) + tmp38 := checkDerefVar(var_glojure_DOT_core_vector) + tmp39 := checkDerefVar(var_glojure_DOT_core_seq) + tmp40 := checkDerefVar(var_glojure_DOT_core_concat) + tmp41 := checkDerefVar(var_glojure_DOT_core_list) + tmp42 := lang.Apply(tmp41, []any{sym_glojure_DOT_core_SLASH__STAR_out_STAR_}) + tmp43 := checkDerefVar(var_glojure_DOT_core_list) + tmp44 := lang.Apply(tmp43, []any{sym_s__0__auto__}) tmp45 := lang.Apply(tmp40, []any{tmp42, tmp44}) tmp46 := lang.Apply(tmp39, []any{tmp45}) tmp47 := lang.Apply(tmp37, []any{tmp38, tmp46}) tmp48 := lang.Apply(tmp36, []any{tmp47}) - tmp49 := checkDerefVar(glojure_DOT_core_list) - tmp50 := checkDerefVar(glojure_DOT_core_seq) - tmp51 := checkDerefVar(glojure_DOT_core_concat) - tmp52 := checkDerefVar(glojure_DOT_core_list) - tmp53 := lang.Apply(tmp52, []any{lang.NewSymbol("glojure.core/str")}) - tmp54 := checkDerefVar(glojure_DOT_core_list) - tmp55 := lang.Apply(tmp54, []any{lang.NewSymbol("s__0__auto__")}) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) + tmp50 := checkDerefVar(var_glojure_DOT_core_seq) + tmp51 := checkDerefVar(var_glojure_DOT_core_concat) + tmp52 := checkDerefVar(var_glojure_DOT_core_list) + tmp53 := lang.Apply(tmp52, []any{sym_glojure_DOT_core_SLASH_str}) + tmp54 := checkDerefVar(var_glojure_DOT_core_list) + tmp55 := lang.Apply(tmp54, []any{sym_s__0__auto__}) tmp56 := lang.Apply(tmp51, []any{tmp53, tmp55}) tmp57 := lang.Apply(tmp50, []any{tmp56}) tmp58 := lang.Apply(tmp49, []any{tmp57}) @@ -56784,7 +56170,7 @@ func LoadNS() { return tmp63 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -56792,14 +56178,12 @@ func LoadNS() { } // with-precision { - tmp0 := lang.NewSymbol("with-precision").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("precision"), lang.NewSymbol("&"), lang.NewSymbol("exprs"))), lang.NewKeyword("doc"), "Sets the precision and rounding mode to be used for BigDecimal operations.\n\n Usage: (with-precision 10 (/ 1M 3))\n or: (with-precision 10 :rounding HALF_DOWN (/ 1M 3))\n\n The rounding mode is one of CEILING, FLOOR, HALF_UP, HALF_DOWN,\n HALF_EVEN, UP, DOWN and UNNECESSARY; it defaults to HALF_UP.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(24), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(5110), lang.NewKeyword("end-line"), int(5110))).(*lang.Symbol) + tmp0 := sym_with_DASH_precision.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_precision, sym__AMP_, sym_exprs)), kw_doc, "Sets the precision and rounding mode to be used for BigDecimal operations.\n\n Usage: (with-precision 10 (/ 1M 3))\n or: (with-precision 10 :rounding HALF_DOWN (/ 1M 3))\n\n The rounding mode is one of CEILING, FLOOR, HALF_UP, HALF_DOWN,\n HALF_EVEN, UP, DOWN and UNNECESSARY; it defaults to HALF_UP.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(24), kw_column, int(11), kw_line, int(5110), kw_end_DASH_line, int(5110))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -56812,26 +56196,26 @@ func LoadNS() { { // let // let binding "vec__65" var tmp8 any - tmp9 := checkDerefVar(glojure_DOT_core__EQ_) - tmp10 := checkDerefVar(glojure_DOT_core_first) + tmp9 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp10 := checkDerefVar(var_glojure_DOT_core_first) tmp11 := lang.Apply(tmp10, []any{v6}) - tmp12 := lang.Apply(tmp9, []any{tmp11, lang.NewKeyword("rounding")}) + tmp12 := lang.Apply(tmp9, []any{tmp11, kw_rounding}) if lang.IsTruthy(tmp12) { - tmp13 := checkDerefVar(glojure_DOT_core_next) - tmp14 := checkDerefVar(glojure_DOT_core_next) + tmp13 := checkDerefVar(var_glojure_DOT_core_next) + tmp14 := checkDerefVar(var_glojure_DOT_core_next) tmp15 := lang.Apply(tmp14, []any{v6}) tmp16 := lang.Apply(tmp13, []any{tmp15}) - tmp17 := checkDerefVar(glojure_DOT_core_seq) - tmp18 := checkDerefVar(glojure_DOT_core_concat) - tmp19 := checkDerefVar(glojure_DOT_core_list) - tmp20 := checkDerefVar(glojure_DOT_core_seq) - tmp21 := checkDerefVar(glojure_DOT_core_concat) - tmp22 := checkDerefVar(glojure_DOT_core_list) - tmp23 := lang.Apply(tmp22, []any{lang.NewSymbol(".")}) - tmp24 := checkDerefVar(glojure_DOT_core_list) - tmp25 := lang.Apply(tmp24, []any{lang.NewSymbol("java.math.RoundingMode")}) - tmp26 := checkDerefVar(glojure_DOT_core_list) - tmp27 := checkDerefVar(glojure_DOT_core_second) + tmp17 := checkDerefVar(var_glojure_DOT_core_seq) + tmp18 := checkDerefVar(var_glojure_DOT_core_concat) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{sym__DOT_}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{sym_java_DOT_math_DOT_RoundingMode}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := checkDerefVar(var_glojure_DOT_core_second) tmp28 := lang.Apply(tmp27, []any{v6}) tmp29 := lang.Apply(tmp26, []any{tmp28}) tmp30 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp29}) @@ -56840,7 +56224,7 @@ func LoadNS() { tmp33 := lang.Apply(tmp18, []any{tmp32}) tmp34 := lang.Apply(tmp17, []any{tmp33}) tmp35 := lang.NewVector(tmp16, tmp34) - tmp36 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5121), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(5122), lang.NewKeyword("end-column"), int(69)) + tmp36 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5121), kw_column, int(23), kw_end_DASH_line, int(5122), kw_end_DASH_column, int(69)) tmp37, err := lang.WithMeta(tmp35, tmp36.(lang.IPersistentMap)) if err != nil { panic(err) @@ -56848,7 +56232,7 @@ func LoadNS() { tmp8 = tmp37 } else { tmp38 := lang.NewVector(v6, nil) - tmp39 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(5123), lang.NewKeyword("column"), int(23), lang.NewKeyword("end-line"), int(5123), lang.NewKeyword("end-column"), int(33)) + tmp39 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5123), kw_column, int(23), kw_end_DASH_line, int(5123), kw_end_DASH_column, int(33)) tmp40, err := lang.WithMeta(tmp38, tmp39.(lang.IPersistentMap)) if err != nil { panic(err) @@ -56858,32 +56242,32 @@ func LoadNS() { var v41 any = tmp8 _ = v41 // let binding "body" - tmp42 := checkDerefVar(glojure_DOT_core_nth) + tmp42 := checkDerefVar(var_glojure_DOT_core_nth) tmp43 := lang.Apply(tmp42, []any{v41, int64(0), nil}) var v44 any = tmp43 _ = v44 // let binding "rm" - tmp45 := checkDerefVar(glojure_DOT_core_nth) + tmp45 := checkDerefVar(var_glojure_DOT_core_nth) tmp46 := lang.Apply(tmp45, []any{v41, int64(1), nil}) var v47 any = tmp46 _ = v47 - tmp48 := checkDerefVar(glojure_DOT_core_seq) - tmp49 := checkDerefVar(glojure_DOT_core_concat) - tmp50 := checkDerefVar(glojure_DOT_core_list) - tmp51 := lang.Apply(tmp50, []any{lang.NewSymbol("glojure.core/binding")}) - tmp52 := checkDerefVar(glojure_DOT_core_list) - tmp53 := checkDerefVar(glojure_DOT_core_apply) - tmp54 := checkDerefVar(glojure_DOT_core_vector) - tmp55 := checkDerefVar(glojure_DOT_core_seq) - tmp56 := checkDerefVar(glojure_DOT_core_concat) - tmp57 := checkDerefVar(glojure_DOT_core_list) - tmp58 := lang.Apply(tmp57, []any{lang.NewSymbol("glojure.core/*math-context*")}) - tmp59 := checkDerefVar(glojure_DOT_core_list) - tmp60 := checkDerefVar(glojure_DOT_core_seq) - tmp61 := checkDerefVar(glojure_DOT_core_concat) - tmp62 := checkDerefVar(glojure_DOT_core_list) - tmp63 := lang.Apply(tmp62, []any{lang.NewSymbol("java.math.MathContext.")}) - tmp64 := checkDerefVar(glojure_DOT_core_list) + tmp48 := checkDerefVar(var_glojure_DOT_core_seq) + tmp49 := checkDerefVar(var_glojure_DOT_core_concat) + tmp50 := checkDerefVar(var_glojure_DOT_core_list) + tmp51 := lang.Apply(tmp50, []any{sym_glojure_DOT_core_SLASH_binding}) + tmp52 := checkDerefVar(var_glojure_DOT_core_list) + tmp53 := checkDerefVar(var_glojure_DOT_core_apply) + tmp54 := checkDerefVar(var_glojure_DOT_core_vector) + tmp55 := checkDerefVar(var_glojure_DOT_core_seq) + tmp56 := checkDerefVar(var_glojure_DOT_core_concat) + tmp57 := checkDerefVar(var_glojure_DOT_core_list) + tmp58 := lang.Apply(tmp57, []any{sym_glojure_DOT_core_SLASH__STAR_math_DASH_context_STAR_}) + tmp59 := checkDerefVar(var_glojure_DOT_core_list) + tmp60 := checkDerefVar(var_glojure_DOT_core_seq) + tmp61 := checkDerefVar(var_glojure_DOT_core_concat) + tmp62 := checkDerefVar(var_glojure_DOT_core_list) + tmp63 := lang.Apply(tmp62, []any{sym_java_DOT_math_DOT_MathContext_DOT_}) + tmp64 := checkDerefVar(var_glojure_DOT_core_list) tmp65 := lang.Apply(tmp64, []any{v5}) tmp66 := lang.Apply(tmp61, []any{tmp63, tmp65, v47}) tmp67 := lang.Apply(tmp60, []any{tmp66}) @@ -56899,7 +56283,7 @@ func LoadNS() { return tmp7 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -56907,14 +56291,12 @@ func LoadNS() { } // with-redefs { - tmp0 := lang.NewSymbol("with-redefs").WithMeta(lang.NewMap(lang.NewKeyword("macro"), true, lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("bindings"), lang.NewSymbol("&"), lang.NewSymbol("body"))), lang.NewKeyword("doc"), "binding => var-symbol temp-value-expr\n\n Temporarily redefines Vars while executing the body. The\n temp-value-exprs will be evaluated and each resulting value will\n replace in parallel the root value of its Var. After the body is\n executed, the root values of all the Vars will be set back to their\n old values. These temporary changes will be visible in all threads.\n Useful for mocking out functions during testing.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("column"), int(11), lang.NewKeyword("line"), int(7544), lang.NewKeyword("end-line"), int(7544))).(*lang.Symbol) + tmp0 := sym_with_DASH_redefs.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "binding => var-symbol temp-value-expr\n\n Temporarily redefines Vars while executing the body. The\n temp-value-exprs will be evaluated and each resulting value will\n replace in parallel the root value of its Var. After the body is\n executed, the root values of all the Vars will be set back to their\n old values. These temporary changes will be visible in all threads.\n Useful for mocking out functions during testing.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(11), kw_line, int(7544), kw_end_DASH_line, int(7544))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - if len(args) < 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -56923,48 +56305,46 @@ func LoadNS() { _ = v5 var v6 any = lang.NewList(args[3:]...) _ = v6 - tmp7 := checkDerefVar(glojure_DOT_core_seq) - tmp8 := checkDerefVar(glojure_DOT_core_concat) - tmp9 := checkDerefVar(glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{lang.NewSymbol("glojure.core/with-redefs-fn")}) - tmp11 := checkDerefVar(glojure_DOT_core_list) - tmp12 := checkDerefVar(glojure_DOT_core_zipmap) - tmp13 := checkDerefVar(glojure_DOT_core_map) + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_core_SLASH_with_DASH_redefs_DASH_fn}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_zipmap) + tmp13 := checkDerefVar(var_glojure_DOT_core_map) var tmp14 lang.FnFunc tmp14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v15 := args[0] _ = v15 - tmp16 := checkDerefVar(glojure_DOT_core_list) - tmp17 := lang.Apply(tmp16, []any{lang.NewSymbol("var"), v15}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{sym_var, v15}) return tmp17 }) - tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7555), lang.NewKeyword("column"), int(34), lang.NewKeyword("end-line"), int(7555), lang.NewKeyword("end-column"), int(47)) + tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7555), kw_column, int(34), kw_end_DASH_line, int(7555), kw_end_DASH_column, int(47)) tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp17 := checkDerefVar(glojure_DOT_core_take_nth) + tmp17 := checkDerefVar(var_glojure_DOT_core_take_DASH_nth) tmp18 := lang.Apply(tmp17, []any{int64(2), v5}) tmp19 := lang.Apply(tmp13, []any{tmp16, tmp18}) - tmp20 := checkDerefVar(glojure_DOT_core_take_nth) - tmp21 := checkDerefVar(glojure_DOT_core_next) + tmp20 := checkDerefVar(var_glojure_DOT_core_take_DASH_nth) + tmp21 := checkDerefVar(var_glojure_DOT_core_next) tmp22 := lang.Apply(tmp21, []any{v5}) tmp23 := lang.Apply(tmp20, []any{int64(2), tmp22}) tmp24 := lang.Apply(tmp12, []any{tmp19, tmp23}) tmp25 := lang.Apply(tmp11, []any{tmp24}) - tmp26 := checkDerefVar(glojure_DOT_core_list) - tmp27 := checkDerefVar(glojure_DOT_core_seq) - tmp28 := checkDerefVar(glojure_DOT_core_concat) - tmp29 := checkDerefVar(glojure_DOT_core_list) - tmp30 := lang.Apply(tmp29, []any{lang.NewSymbol("glojure.core/fn")}) - tmp31 := checkDerefVar(glojure_DOT_core_list) - tmp32 := checkDerefVar(glojure_DOT_core_apply) - tmp33 := checkDerefVar(glojure_DOT_core_vector) - tmp34 := checkDerefVar(glojure_DOT_core_seq) - tmp35 := checkDerefVar(glojure_DOT_core_concat) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := checkDerefVar(var_glojure_DOT_core_seq) + tmp28 := checkDerefVar(var_glojure_DOT_core_concat) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{sym_glojure_DOT_core_SLASH_fn}) + tmp31 := checkDerefVar(var_glojure_DOT_core_list) + tmp32 := checkDerefVar(var_glojure_DOT_core_apply) + tmp33 := checkDerefVar(var_glojure_DOT_core_vector) + tmp34 := checkDerefVar(var_glojure_DOT_core_seq) + tmp35 := checkDerefVar(var_glojure_DOT_core_concat) tmp36 := lang.Apply(tmp35, nil) tmp37 := lang.Apply(tmp34, []any{tmp36}) tmp38 := lang.Apply(tmp32, []any{tmp33, tmp37}) @@ -56977,7 +56357,7 @@ func LoadNS() { return tmp44 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -56985,12 +56365,10 @@ func LoadNS() { } // with-redefs-fn { - tmp0 := lang.NewSymbol("with-redefs-fn").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("binding-map"), lang.NewSymbol("func"))), lang.NewKeyword("doc"), "Temporarily redefines Vars during a call to func. Each val of\n binding-map will replace the root value of its key which must be\n a Var. After func is called with no args, the root values of all\n the Vars will be set back to their old values. These temporary\n changes will be visible in all threads. Useful for mocking out\n functions during testing.", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.3", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(7524), lang.NewKeyword("end-line"), int(7524))).(*lang.Symbol) + tmp0 := sym_with_DASH_redefs_DASH_fn.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_binding_DASH_map, sym_func)), kw_doc, "Temporarily redefines Vars during a call to func. Each val of\n binding-map will replace the root value of its key which must be\n a Var. After func is called with no args, the root values of all\n the Vars will be set back to their old values. These temporary\n changes will be visible in all threads. Useful for mocking out\n functions during testing.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(7524), kw_end_DASH_line, int(7524))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -57000,15 +56378,13 @@ func LoadNS() { // let binding "root-bind" var tmp6 lang.FnFunc tmp6 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v7 := args[0] _ = v7 var tmp8 any { // let // let binding "seq_338" - tmp9 := checkDerefVar(glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_seq) tmp10 := lang.Apply(tmp9, []any{v7}) var v11 any = tmp10 _ = v11 @@ -57023,7 +56399,7 @@ func LoadNS() { _ = v14 for { var tmp15 any - tmp16 := checkDerefVar(glojure_DOT_core__LT_) + tmp16 := checkDerefVar(var_glojure_DOT_core__LT_) tmp17 := lang.Apply(tmp16, []any{v14, v13}) if lang.IsTruthy(tmp17) { var tmp18 any @@ -57037,12 +56413,12 @@ func LoadNS() { var v21 any = tmp20 _ = v21 // let binding "a-var" - tmp22 := checkDerefVar(glojure_DOT_core_nth) + tmp22 := checkDerefVar(var_glojure_DOT_core_nth) tmp23 := lang.Apply(tmp22, []any{v21, int64(0), nil}) var v24 any = tmp23 _ = v24 // let binding "a-val" - tmp25 := checkDerefVar(glojure_DOT_core_nth) + tmp25 := checkDerefVar(var_glojure_DOT_core_nth) tmp26 := lang.Apply(tmp25, []any{v21, int64(1), nil}) var v27 any = tmp26 _ = v27 @@ -57055,7 +56431,7 @@ func LoadNS() { var tmp30 any = v11 var tmp31 any = v12 var tmp32 any = v13 - tmp34 := checkDerefVar(glojure_DOT_core_unchecked_inc) + tmp34 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) tmp35 := lang.Apply(tmp34, []any{v14}) var tmp33 any = tmp35 v11 = tmp30 @@ -57069,7 +56445,7 @@ func LoadNS() { var tmp19 any { // let // let binding "temp__0__auto__" - tmp20 := checkDerefVar(glojure_DOT_core_seq) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) tmp21 := lang.Apply(tmp20, []any{v11}) var v22 any = tmp21 _ = v22 @@ -57081,26 +56457,26 @@ func LoadNS() { var v25 any = v22 _ = v25 var tmp26 any - tmp27 := checkDerefVar(glojure_DOT_core_chunked_seq_QMARK_) + tmp27 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) tmp28 := lang.Apply(tmp27, []any{v25}) if lang.IsTruthy(tmp28) { var tmp29 any { // let // let binding "c__0__auto__" - tmp30 := checkDerefVar(glojure_DOT_core_chunk_first) + tmp30 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) tmp31 := lang.Apply(tmp30, []any{v25}) var v32 any = tmp31 _ = v32 - tmp34 := checkDerefVar(glojure_DOT_core_chunk_rest) + tmp34 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) tmp35 := lang.Apply(tmp34, []any{v25}) var tmp33 any = tmp35 var tmp36 any = v32 - tmp38 := checkDerefVar(glojure_DOT_core_int) - tmp39 := checkDerefVar(glojure_DOT_core_count) + tmp38 := checkDerefVar(var_glojure_DOT_core_int) + tmp39 := checkDerefVar(var_glojure_DOT_core_count) tmp40 := lang.Apply(tmp39, []any{v32}) tmp41 := lang.Apply(tmp38, []any{tmp40}) var tmp37 any = tmp41 - tmp43 := checkDerefVar(glojure_DOT_core_int) + tmp43 := checkDerefVar(var_glojure_DOT_core_int) tmp44 := lang.Apply(tmp43, []any{int64(0)}) var tmp42 any = tmp44 v11 = tmp33 @@ -57114,17 +56490,17 @@ func LoadNS() { var tmp30 any { // let // let binding "vec__345" - tmp31 := checkDerefVar(glojure_DOT_core_first) + tmp31 := checkDerefVar(var_glojure_DOT_core_first) tmp32 := lang.Apply(tmp31, []any{v25}) var v33 any = tmp32 _ = v33 // let binding "a-var" - tmp34 := checkDerefVar(glojure_DOT_core_nth) + tmp34 := checkDerefVar(var_glojure_DOT_core_nth) tmp35 := lang.Apply(tmp34, []any{v33, int64(0), nil}) var v36 any = tmp35 _ = v36 // let binding "a-val" - tmp37 := checkDerefVar(glojure_DOT_core_nth) + tmp37 := checkDerefVar(var_glojure_DOT_core_nth) tmp38 := lang.Apply(tmp37, []any{v33, int64(1), nil}) var v39 any = tmp38 _ = v39 @@ -57134,7 +56510,7 @@ func LoadNS() { } tmp41 := lang.Apply(tmp40, []any{v39}) _ = tmp41 - tmp43 := checkDerefVar(glojure_DOT_core_next) + tmp43 := checkDerefVar(var_glojure_DOT_core_next) tmp44 := lang.Apply(tmp43, []any{v25}) var tmp42 any = tmp44 var tmp45 any = nil @@ -57163,7 +56539,7 @@ func LoadNS() { } // end let return tmp8 }) - tmp7 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7533), lang.NewKeyword("column"), int(19), lang.NewKeyword("end-line"), int(7535), lang.NewKeyword("end-column"), int(93)) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7533), kw_column, int(19), kw_end_DASH_line, int(7535), kw_end_DASH_column, int(93)) tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) if err != nil { panic(err) @@ -57171,15 +56547,13 @@ func LoadNS() { var v9 any = tmp8 _ = v9 // let binding "old-vals" - tmp10 := checkDerefVar(glojure_DOT_core_zipmap) - tmp11 := checkDerefVar(glojure_DOT_core_keys) + tmp10 := checkDerefVar(var_glojure_DOT_core_zipmap) + tmp11 := checkDerefVar(var_glojure_DOT_core_keys) tmp12 := lang.Apply(tmp11, []any{v3}) - tmp13 := checkDerefVar(glojure_DOT_core_map) + tmp13 := checkDerefVar(var_glojure_DOT_core_map) var tmp14 lang.FnFunc tmp14 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v15 := args[0] _ = v15 tmp16, ok := lang.FieldOrMethod(v15, "getRawRoot") @@ -57195,12 +56569,12 @@ func LoadNS() { } return tmp17 }) - tmp15 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(7537), lang.NewKeyword("column"), int(31), lang.NewKeyword("end-line"), int(7537), lang.NewKeyword("end-column"), int(92)) + tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7537), kw_column, int(31), kw_end_DASH_line, int(7537), kw_end_DASH_column, int(92)) tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp17 := checkDerefVar(glojure_DOT_core_keys) + tmp17 := checkDerefVar(var_glojure_DOT_core_keys) tmp18 := lang.Apply(tmp17, []any{v3}) tmp19 := lang.Apply(tmp13, []any{tmp16, tmp18}) tmp20 := lang.Apply(tmp10, []any{tmp12, tmp19}) @@ -57221,7 +56595,7 @@ func LoadNS() { } // end let return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -57229,25 +56603,23 @@ func LoadNS() { } // xml-seq { - tmp0 := lang.NewSymbol("xml-seq").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("root"))), lang.NewKeyword("doc"), "A tree seq on the xml elements as per xml/parse", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(4982), lang.NewKeyword("end-line"), int(4982))).(*lang.Symbol) + tmp0 := sym_xml_DASH_seq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_root)), kw_doc, "A tree seq on the xml elements as per xml/parse", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4982), kw_end_DASH_line, int(4982))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_tree_seq) - tmp5 := checkDerefVar(glojure_DOT_core_complement) - tmp6 := checkDerefVar(glojure_DOT_core_string_QMARK_) + tmp4 := checkDerefVar(var_glojure_DOT_core_tree_DASH_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_complement) + tmp6 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) tmp7 := lang.Apply(tmp5, []any{tmp6}) - tmp8 := checkDerefVar(glojure_DOT_core_comp) - tmp9 := checkDerefVar(glojure_DOT_core_seq) - tmp10 := lang.Apply(tmp8, []any{tmp9, lang.NewKeyword("content")}) + tmp8 := checkDerefVar(var_glojure_DOT_core_comp) + tmp9 := checkDerefVar(var_glojure_DOT_core_seq) + tmp10 := lang.Apply(tmp8, []any{tmp9, kw_content}) tmp11 := lang.Apply(tmp4, []any{tmp7, tmp10, v3}) return tmp11 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -57259,23 +56631,21 @@ func LoadNS() { { // function zero?__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(glojure_DOT_core_seq) - tmp5 := checkDerefVar(glojure_DOT_core_concat) - tmp6 := checkDerefVar(glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{lang.NewSymbol(".")}) - tmp8 := checkDerefVar(glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers")}) - tmp10 := checkDerefVar(glojure_DOT_core_list) - tmp11 := checkDerefVar(glojure_DOT_core_seq) - tmp12 := checkDerefVar(glojure_DOT_core_concat) - tmp13 := checkDerefVar(glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{lang.NewSymbol("glojure.core/IsZero")}) - tmp15 := checkDerefVar(glojure_DOT_core_list) + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_IsZero}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) tmp18 := lang.Apply(tmp11, []any{tmp17}) @@ -57287,12 +56657,10 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := lang.NewSymbol("zero?").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("num"))), lang.NewKeyword("inline"), tmp1, lang.NewKeyword("doc"), "Returns true if num is zero, else false", lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(860), lang.NewKeyword("end-line"), int(860))).(*lang.Symbol) + tmp0 := sym_zero_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_num)), kw_inline, tmp1, kw_doc, "Returns true if num is zero, else false", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(860), kw_end_DASH_line, int(860))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v4 := args[0] _ = v4 tmp5, _ := lang.FieldOrMethod(lang.Numbers, "IsZero") @@ -57302,7 +56670,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v4}) return tmp6 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp2 := ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -57310,12 +56678,10 @@ func LoadNS() { } // zipmap { - tmp0 := lang.NewSymbol("zipmap").WithMeta(lang.NewMap(lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("keys"), lang.NewSymbol("vals"))), lang.NewKeyword("doc"), "Returns a map with the keys mapped to the corresponding vals.", lang.NewKeyword("static"), true, lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("added"), "1.0", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")), lang.NewKeyword("end-column"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("line"), int(6583), lang.NewKeyword("end-line"), int(6583))).(*lang.Symbol) + tmp0 := sym_zipmap.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_keys, sym_vals)), kw_doc, "Returns a map with the keys mapped to the corresponding vals.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(6583), kw_end_DASH_line, int(6583))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -57323,9 +56689,9 @@ func LoadNS() { var tmp5 any { // let // let binding "map" - tmp6 := checkDerefVar(glojure_DOT_core_transient) + tmp6 := checkDerefVar(var_glojure_DOT_core_transient) tmp7 := lang.NewMap() - tmp8 := lang.NewMap(lang.NewKeyword("file"), "glojure/core.glj", lang.NewKeyword("line"), int(6588), lang.NewKeyword("column"), int(27), lang.NewKeyword("end-line"), int(6588), lang.NewKeyword("end-column"), int(28)) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6588), kw_column, int(27), kw_end_DASH_line, int(6588), kw_end_DASH_column, int(28)) tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) if err != nil { panic(err) @@ -57334,12 +56700,12 @@ func LoadNS() { var v11 any = tmp10 _ = v11 // let binding "ks" - tmp12 := checkDerefVar(glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := lang.Apply(tmp12, []any{v3}) var v14 any = tmp13 _ = v14 // let binding "vs" - tmp15 := checkDerefVar(glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) tmp16 := lang.Apply(tmp15, []any{v4}) var v17 any = tmp16 _ = v17 @@ -57359,17 +56725,17 @@ func LoadNS() { tmp19 = tmp21 } // end let if lang.IsTruthy(tmp19) { - tmp21 := checkDerefVar(glojure_DOT_core_assoc_BANG_) - tmp22 := checkDerefVar(glojure_DOT_core_first) + tmp21 := checkDerefVar(var_glojure_DOT_core_assoc_BANG_) + tmp22 := checkDerefVar(var_glojure_DOT_core_first) tmp23 := lang.Apply(tmp22, []any{v14}) - tmp24 := checkDerefVar(glojure_DOT_core_first) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) tmp25 := lang.Apply(tmp24, []any{v17}) tmp26 := lang.Apply(tmp21, []any{v11, tmp23, tmp25}) var tmp20 any = tmp26 - tmp28 := checkDerefVar(glojure_DOT_core_next) + tmp28 := checkDerefVar(var_glojure_DOT_core_next) tmp29 := lang.Apply(tmp28, []any{v14}) var tmp27 any = tmp29 - tmp31 := checkDerefVar(glojure_DOT_core_next) + tmp31 := checkDerefVar(var_glojure_DOT_core_next) tmp32 := lang.Apply(tmp31, []any{v17}) var tmp30 any = tmp32 v11 = tmp20 @@ -57377,7 +56743,7 @@ func LoadNS() { v17 = tmp30 continue } else { - tmp33 := checkDerefVar(glojure_DOT_core_persistent_BANG_) + tmp33 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) tmp34 := lang.Apply(tmp33, []any{v11}) tmp18 = tmp34 } @@ -57387,7 +56753,7 @@ func LoadNS() { } // end let return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) diff --git a/pkg/codegen/testdata/codegen/test/def_simple/load.go.out b/pkg/codegen/testdata/codegen/test/def_simple/load.go.out index 58433900..dd97932d 100644 --- a/pkg/codegen/testdata/codegen/test/def_simple/load.go.out +++ b/pkg/codegen/testdata/codegen/test/def_simple/load.go.out @@ -1,27 +1,35 @@ // Code generated by glojure codegen. DO NOT EDIT. -package def_simple +package def_DASH_simple import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" ) +func checkDerefVar(v *lang.Var) any { + if v.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) + } + return v.Get() +} +func checkArity(args []any, expected int) { + if len(args) != expected { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + // LoadNS initializes the namespace "codegen.test.def-simple" func LoadNS() { - checkDerefMacro := func(v *lang.Var) { - if v.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) - } - } - _ = checkDerefMacro + sym_codegen_DOT_test_DOT_def_DASH_simple := lang.NewSymbol("codegen.test.def-simple") + sym_foo := lang.NewSymbol("foo") // reference fmt to avoid unused import error _ = fmt.Printf - ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.def-simple")) + ns := lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_def_DASH_simple) _ = ns // foo { - tmp0 := lang.NewSymbol("foo").WithMeta(lang.NewMap()).(*lang.Symbol) + tmp0 := sym_foo.WithMeta(lang.NewMap()).(*lang.Symbol) tmp1 := ns.Intern(tmp0) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) diff --git a/pkg/codegen/testdata/codegen/test/fn_closure/load.go.out b/pkg/codegen/testdata/codegen/test/fn_closure/load.go.out index 901d467e..0150efbd 100644 --- a/pkg/codegen/testdata/codegen/test/fn_closure/load.go.out +++ b/pkg/codegen/testdata/codegen/test/fn_closure/load.go.out @@ -1,33 +1,59 @@ // Code generated by glojure codegen. DO NOT EDIT. -package fn_closure +package fn_DASH_closure import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" ) +func checkDerefVar(v *lang.Var) any { + if v.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) + } + return v.Get() +} +func checkArity(args []any, expected int) { + if len(args) != expected { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + // LoadNS initializes the namespace "codegen.test.fn-closure" func LoadNS() { - checkDerefMacro := func(v *lang.Var) { - if v.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) - } - } - _ = checkDerefMacro + sym__DASH_main := lang.NewSymbol("-main") + sym_closed := lang.NewSymbol("closed") + sym_codegen_DOT_test_DOT_fn_DASH_closure := lang.NewSymbol("codegen.test.fn-closure") + sym_deref := lang.NewSymbol("deref") + sym_gen_DASH_closure := lang.NewSymbol("gen-closure") + sym_get_DASH_atom := lang.NewSymbol("get-atom") + sym_glojure_DOT_core := lang.NewSymbol("glojure.core") + sym_inc := lang.NewSymbol("inc") + sym_inc_DASH_atom := lang.NewSymbol("inc-atom") + sym_swap_BANG_ := lang.NewSymbol("swap!") + sym_the_DASH_result := lang.NewSymbol("the-result") + kw_arglists := lang.NewKeyword("arglists") + kw_column := lang.NewKeyword("column") + kw_end_DASH_column := lang.NewKeyword("end-column") + kw_end_DASH_line := lang.NewKeyword("end-line") + kw_expected_DASH_output := lang.NewKeyword("expected-output") + kw_file := lang.NewKeyword("file") + kw_line := lang.NewKeyword("line") + kw_ns := lang.NewKeyword("ns") + kw_rettag := lang.NewKeyword("rettag") // var codegen.test.fn-closure/closed - codegen_DOT_test_DOT_fn_closure_closed := lang.InternVarName(lang.NewSymbol("codegen.test.fn-closure"), lang.NewSymbol("closed")) + var_codegen_DOT_test_DOT_fn_DASH_closure_closed := lang.InternVarName(sym_codegen_DOT_test_DOT_fn_DASH_closure, sym_closed) // var codegen.test.fn-closure/get-atom - codegen_DOT_test_DOT_fn_closure_get_atom := lang.InternVarName(lang.NewSymbol("codegen.test.fn-closure"), lang.NewSymbol("get-atom")) + var_codegen_DOT_test_DOT_fn_DASH_closure_get_DASH_atom := lang.InternVarName(sym_codegen_DOT_test_DOT_fn_DASH_closure, sym_get_DASH_atom) // var codegen.test.fn-closure/inc-atom - codegen_DOT_test_DOT_fn_closure_inc_atom := lang.InternVarName(lang.NewSymbol("codegen.test.fn-closure"), lang.NewSymbol("inc-atom")) + var_codegen_DOT_test_DOT_fn_DASH_closure_inc_DASH_atom := lang.InternVarName(sym_codegen_DOT_test_DOT_fn_DASH_closure, sym_inc_DASH_atom) // var glojure.core/deref - glojure_DOT_core_deref := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("deref")) + var_glojure_DOT_core_deref := lang.InternVarName(sym_glojure_DOT_core, sym_deref) // var glojure.core/inc - glojure_DOT_core_inc := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("inc")) + var_glojure_DOT_core_inc := lang.InternVarName(sym_glojure_DOT_core, sym_inc) // var glojure.core/swap! - glojure_DOT_core_swap_BANG_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("swap!")) - // Closed-over values + var_glojure_DOT_core_swap_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_swap_BANG_) + // //////////////////////////////////////////////////////////////////////////////// Closed-over values var closed0 any { closed0 = int64(42) @@ -40,35 +66,30 @@ func LoadNS() { // reference fmt to avoid unused import error _ = fmt.Printf - ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.fn-closure")) + ns := lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_fn_DASH_closure) _ = ns // -main { - tmp0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), lang.NewVector(int64(42), int64(1)), lang.NewKeyword("file"), "codegen/test/fn_closure.glj", lang.NewKeyword("line"), int(13), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(13), lang.NewKeyword("end-column"), int(38), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.fn-closure")))).(*lang.Symbol) + tmp0 := sym__DASH_main.WithMeta(lang.NewMap(kw_expected_DASH_output, lang.NewVector(int64(42), int64(1)), kw_file, "codegen/test/fn_closure.glj", kw_line, int(13), kw_column, int(7), kw_end_DASH_line, int(13), kw_end_DASH_column, int(38), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_fn_DASH_closure))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - checkDerefMacro(codegen_DOT_test_DOT_fn_closure_inc_atom) - tmp3 := codegen_DOT_test_DOT_fn_closure_inc_atom.Get() + checkArity(args, 0) + tmp3 := checkDerefVar(var_codegen_DOT_test_DOT_fn_DASH_closure_inc_DASH_atom) tmp4 := lang.Apply(tmp3, nil) _ = tmp4 - checkDerefMacro(codegen_DOT_test_DOT_fn_closure_closed) - tmp5 := codegen_DOT_test_DOT_fn_closure_closed.Get() + tmp5 := checkDerefVar(var_codegen_DOT_test_DOT_fn_DASH_closure_closed) tmp6 := lang.Apply(tmp5, nil) - checkDerefMacro(codegen_DOT_test_DOT_fn_closure_get_atom) - tmp7 := codegen_DOT_test_DOT_fn_closure_get_atom.Get() + tmp7 := checkDerefVar(var_codegen_DOT_test_DOT_fn_DASH_closure_get_DASH_atom) tmp8 := lang.Apply(tmp7, nil) tmp9 := lang.NewVector(tmp6, tmp8) - tmp10 := lang.NewMap(lang.NewKeyword("file"), "codegen/test/fn_closure.glj", lang.NewKeyword("line"), int(15), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(16), lang.NewKeyword("end-column"), int(14)) + tmp10 := lang.NewMap(kw_file, "codegen/test/fn_closure.glj", kw_line, int(15), kw_column, int(3), kw_end_DASH_line, int(16), kw_end_DASH_column, int(14)) tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) if err != nil { panic(err) } return tmp11 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -76,15 +97,13 @@ func LoadNS() { } // closed { - tmp0 := lang.NewSymbol("closed").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/fn_closure.glj", lang.NewKeyword("line"), int(5), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(5), lang.NewKeyword("end-column"), int(11), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.fn-closure")))).(*lang.Symbol) + tmp0 := sym_closed.WithMeta(lang.NewMap(kw_file, "codegen/test/fn_closure.glj", kw_line, int(5), kw_column, int(6), kw_end_DASH_line, int(5), kw_end_DASH_column, int(11), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_fn_DASH_closure))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) return closed0 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/fn_closure.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(49))).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "codegen/test/fn_closure.glj", kw_line, int(3), kw_column, int(32), kw_end_DASH_line, int(3), kw_end_DASH_column, int(49))).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -92,29 +111,25 @@ func LoadNS() { } // gen-closure { - tmp0 := lang.NewSymbol("gen-closure").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/fn_closure.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("the-result"))), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.fn-closure")))).(*lang.Symbol) + tmp0 := sym_gen_DASH_closure.WithMeta(lang.NewMap(kw_file, "codegen/test/fn_closure.glj", kw_line, int(3), kw_column, int(7), kw_end_DASH_line, int(3), kw_end_DASH_column, int(17), kw_arglists, lang.NewList(lang.NewVector(sym_the_DASH_result)), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_fn_DASH_closure))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 lang.FnFunc tmp4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) return v3 }) - tmp5 := lang.NewMap(lang.NewKeyword("file"), "codegen/test/fn_closure.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(32), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(49)) + tmp5 := lang.NewMap(kw_file, "codegen/test/fn_closure.glj", kw_line, int(3), kw_column, int(32), kw_end_DASH_line, int(3), kw_end_DASH_column, int(49)) tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) if err != nil { panic(err) } return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -122,18 +137,15 @@ func LoadNS() { } // get-atom { - tmp0 := lang.NewSymbol("get-atom").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/fn_closure.glj", lang.NewKeyword("line"), int(10), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(10), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.fn-closure")))).(*lang.Symbol) + tmp0 := sym_get_DASH_atom.WithMeta(lang.NewMap(kw_file, "codegen/test/fn_closure.glj", kw_line, int(10), kw_column, int(9), kw_end_DASH_line, int(10), kw_end_DASH_column, int(16), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_fn_DASH_closure))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - checkDerefMacro(glojure_DOT_core_deref) - tmp3 := glojure_DOT_core_deref.Get() + checkArity(args, 0) + tmp3 := checkDerefVar(var_glojure_DOT_core_deref) tmp4 := lang.Apply(tmp3, []any{closed1}) return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -141,20 +153,16 @@ func LoadNS() { } // inc-atom { - tmp0 := lang.NewSymbol("inc-atom").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/fn_closure.glj", lang.NewKeyword("line"), int(8), lang.NewKeyword("column"), int(9), lang.NewKeyword("end-line"), int(8), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.fn-closure")))).(*lang.Symbol) + tmp0 := sym_inc_DASH_atom.WithMeta(lang.NewMap(kw_file, "codegen/test/fn_closure.glj", kw_line, int(8), kw_column, int(9), kw_end_DASH_line, int(8), kw_end_DASH_column, int(16), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_fn_DASH_closure))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - checkDerefMacro(glojure_DOT_core_swap_BANG_) - tmp3 := glojure_DOT_core_swap_BANG_.Get() - checkDerefMacro(glojure_DOT_core_inc) - tmp4 := glojure_DOT_core_inc.Get() + checkArity(args, 0) + tmp3 := checkDerefVar(var_glojure_DOT_core_swap_BANG_) + tmp4 := checkDerefVar(var_glojure_DOT_core_inc) tmp5 := lang.Apply(tmp3, []any{closed1, tmp4}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) diff --git a/pkg/codegen/testdata/codegen/test/fn_recur/load.go.out b/pkg/codegen/testdata/codegen/test/fn_recur/load.go.out index 7b84e487..b845d107 100644 --- a/pkg/codegen/testdata/codegen/test/fn_recur/load.go.out +++ b/pkg/codegen/testdata/codegen/test/fn_recur/load.go.out @@ -1,46 +1,67 @@ // Code generated by glojure codegen. DO NOT EDIT. -package fn_recur +package fn_DASH_recur import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" ) +func checkDerefVar(v *lang.Var) any { + if v.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) + } + return v.Get() +} +func checkArity(args []any, expected int) { + if len(args) != expected { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + // LoadNS initializes the namespace "codegen.test.fn-recur" func LoadNS() { - checkDerefMacro := func(v *lang.Var) { - if v.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) - } - } - _ = checkDerefMacro + sym__PLUS_ := lang.NewSymbol("+") + sym__DASH_main := lang.NewSymbol("-main") + sym__EQ_ := lang.NewSymbol("=") + sym_codegen_DOT_test_DOT_fn_DASH_recur := lang.NewSymbol("codegen.test.fn-recur") + sym_fib := lang.NewSymbol("fib") + sym_glojure_DOT_core := lang.NewSymbol("glojure.core") + sym_inc := lang.NewSymbol("inc") + sym_n := lang.NewSymbol("n") + kw_arglists := lang.NewKeyword("arglists") + kw_column := lang.NewKeyword("column") + kw_doc := lang.NewKeyword("doc") + kw_end_DASH_column := lang.NewKeyword("end-column") + kw_end_DASH_line := lang.NewKeyword("end-line") + kw_expected_DASH_output := lang.NewKeyword("expected-output") + kw_file := lang.NewKeyword("file") + kw_line := lang.NewKeyword("line") + kw_ns := lang.NewKeyword("ns") + kw_rettag := lang.NewKeyword("rettag") // var codegen.test.fn-recur/fib - codegen_DOT_test_DOT_fn_recur_fib := lang.InternVarName(lang.NewSymbol("codegen.test.fn-recur"), lang.NewSymbol("fib")) + var_codegen_DOT_test_DOT_fn_DASH_recur_fib := lang.InternVarName(sym_codegen_DOT_test_DOT_fn_DASH_recur, sym_fib) // var glojure.core/= - glojure_DOT_core__EQ_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("=")) + var_glojure_DOT_core__EQ_ := lang.InternVarName(sym_glojure_DOT_core, sym__EQ_) // var glojure.core/+ - glojure_DOT_core__PLUS_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("+")) + var_glojure_DOT_core__PLUS_ := lang.InternVarName(sym_glojure_DOT_core, sym__PLUS_) // var glojure.core/inc - glojure_DOT_core_inc := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("inc")) + var_glojure_DOT_core_inc := lang.InternVarName(sym_glojure_DOT_core, sym_inc) // reference fmt to avoid unused import error _ = fmt.Printf - ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.fn-recur")) + ns := lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_fn_DASH_recur) _ = ns // -main { - tmp0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), int64(55), lang.NewKeyword("file"), "codegen/test/fn_recur.glj", lang.NewKeyword("line"), int(12), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(12), lang.NewKeyword("end-column"), int(34), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.fn-recur")))).(*lang.Symbol) + tmp0 := sym__DASH_main.WithMeta(lang.NewMap(kw_expected_DASH_output, int64(55), kw_file, "codegen/test/fn_recur.glj", kw_line, int(12), kw_column, int(7), kw_end_DASH_line, int(12), kw_end_DASH_column, int(34), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_fn_DASH_recur))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - checkDerefMacro(codegen_DOT_test_DOT_fn_recur_fib) - tmp3 := codegen_DOT_test_DOT_fn_recur_fib.Get() + checkArity(args, 0) + tmp3 := checkDerefVar(var_codegen_DOT_test_DOT_fn_DASH_recur_fib) tmp4 := lang.Apply(tmp3, []any{int64(10)}) return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -48,12 +69,10 @@ func LoadNS() { } // fib { - tmp0 := lang.NewSymbol("fib").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/fn_recur.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(9), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector(lang.NewSymbol("n"))), lang.NewKeyword("doc"), "Calculates the nth Fibonacci number using iteration with recur.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.fn-recur")))).(*lang.Symbol) + tmp0 := sym_fib.WithMeta(lang.NewMap(kw_file, "codegen/test/fn_recur.glj", kw_line, int(3), kw_column, int(7), kw_end_DASH_line, int(3), kw_end_DASH_column, int(9), kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_doc, "Calculates the nth Fibonacci number using iteration with recur.", kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_fn_DASH_recur))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 1 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any @@ -63,9 +82,7 @@ func LoadNS() { { // function fib-helper var v6 lang.FnFunc tmp5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 3 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 3) v7 := args[0] _ = v7 v8 := args[1] @@ -74,19 +91,16 @@ func LoadNS() { _ = v9 recur_loop_1612: var tmp10 any - checkDerefMacro(glojure_DOT_core__EQ_) - tmp11 := glojure_DOT_core__EQ_.Get() + tmp11 := checkDerefVar(var_glojure_DOT_core__EQ_) tmp12 := lang.Apply(tmp11, []any{v9, v3}) if lang.IsTruthy(tmp12) { tmp10 = v7 } else { var tmp13 any = v8 - checkDerefMacro(glojure_DOT_core__PLUS_) - tmp15 := glojure_DOT_core__PLUS_.Get() + tmp15 := checkDerefVar(var_glojure_DOT_core__PLUS_) tmp16 := lang.Apply(tmp15, []any{v7, v8}) var tmp14 any = tmp16 - checkDerefMacro(glojure_DOT_core_inc) - tmp18 := glojure_DOT_core_inc.Get() + tmp18 := checkDerefVar(var_glojure_DOT_core_inc) tmp19 := lang.Apply(tmp18, []any{v9}) var tmp17 any = tmp19 v7 = tmp13 @@ -99,7 +113,7 @@ func LoadNS() { v6 = tmp5 _ = v6 } - tmp6 := lang.NewMap(lang.NewKeyword("file"), "codegen/test/fn_recur.glj", lang.NewKeyword("line"), int(6), lang.NewKeyword("column"), int(20), lang.NewKeyword("end-line"), int(9), lang.NewKeyword("end-column"), int(50)) + tmp6 := lang.NewMap(kw_file, "codegen/test/fn_recur.glj", kw_line, int(6), kw_column, int(20), kw_end_DASH_line, int(9), kw_end_DASH_column, int(50)) tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) if err != nil { panic(err) @@ -111,7 +125,7 @@ func LoadNS() { } // end let return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) diff --git a/pkg/codegen/testdata/codegen/test/loop_simple/load.go.out b/pkg/codegen/testdata/codegen/test/loop_simple/load.go.out index 57dd724a..f7394aff 100644 --- a/pkg/codegen/testdata/codegen/test/loop_simple/load.go.out +++ b/pkg/codegen/testdata/codegen/test/loop_simple/load.go.out @@ -1,44 +1,62 @@ // Code generated by glojure codegen. DO NOT EDIT. -package loop_simple +package loop_DASH_simple import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" ) +func checkDerefVar(v *lang.Var) any { + if v.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) + } + return v.Get() +} +func checkArity(args []any, expected int) { + if len(args) != expected { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + // LoadNS initializes the namespace "codegen.test.loop-simple" func LoadNS() { - checkDerefMacro := func(v *lang.Var) { - if v.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) - } - } - _ = checkDerefMacro + sym__DASH_main := lang.NewSymbol("-main") + sym__LT_ := lang.NewSymbol("<") + sym_codegen_DOT_test_DOT_loop_DASH_simple := lang.NewSymbol("codegen.test.loop-simple") + sym_glojure_DOT_core := lang.NewSymbol("glojure.core") + sym_inc := lang.NewSymbol("inc") + sym_simple_DASH_loop := lang.NewSymbol("simple-loop") + kw_arglists := lang.NewKeyword("arglists") + kw_column := lang.NewKeyword("column") + kw_end_DASH_column := lang.NewKeyword("end-column") + kw_end_DASH_line := lang.NewKeyword("end-line") + kw_expected_DASH_output := lang.NewKeyword("expected-output") + kw_file := lang.NewKeyword("file") + kw_line := lang.NewKeyword("line") + kw_ns := lang.NewKeyword("ns") + kw_rettag := lang.NewKeyword("rettag") // var codegen.test.loop-simple/simple-loop - codegen_DOT_test_DOT_loop_simple_simple_loop := lang.InternVarName(lang.NewSymbol("codegen.test.loop-simple"), lang.NewSymbol("simple-loop")) + var_codegen_DOT_test_DOT_loop_DASH_simple_simple_DASH_loop := lang.InternVarName(sym_codegen_DOT_test_DOT_loop_DASH_simple, sym_simple_DASH_loop) // var glojure.core/< - glojure_DOT_core__LT_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("<")) + var_glojure_DOT_core__LT_ := lang.InternVarName(sym_glojure_DOT_core, sym__LT_) // var glojure.core/inc - glojure_DOT_core_inc := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("inc")) + var_glojure_DOT_core_inc := lang.InternVarName(sym_glojure_DOT_core, sym_inc) // reference fmt to avoid unused import error _ = fmt.Printf - ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.loop-simple")) + ns := lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_loop_DASH_simple) _ = ns // -main { - tmp0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), int64(10), lang.NewKeyword("file"), "codegen/test/loop_simple.glj", lang.NewKeyword("line"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(10), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.loop-simple")))).(*lang.Symbol) + tmp0 := sym__DASH_main.WithMeta(lang.NewMap(kw_expected_DASH_output, int64(10), kw_file, "codegen/test/loop_simple.glj", kw_line, int(9), kw_column, int(7), kw_end_DASH_line, int(10), kw_end_DASH_column, int(7), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_loop_DASH_simple))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - checkDerefMacro(codegen_DOT_test_DOT_loop_simple_simple_loop) - tmp3 := codegen_DOT_test_DOT_loop_simple_simple_loop.Get() + checkArity(args, 0) + tmp3 := checkDerefVar(var_codegen_DOT_test_DOT_loop_DASH_simple_simple_DASH_loop) tmp4 := lang.Apply(tmp3, nil) return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -46,12 +64,10 @@ func LoadNS() { } // simple-loop { - tmp0 := lang.NewSymbol("simple-loop").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/loop_simple.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(17), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.loop-simple")))).(*lang.Symbol) + tmp0 := sym_simple_DASH_loop.WithMeta(lang.NewMap(kw_file, "codegen/test/loop_simple.glj", kw_line, int(3), kw_column, int(7), kw_end_DASH_line, int(3), kw_end_DASH_column, int(17), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_loop_DASH_simple))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var tmp3 any { // let // let binding "i" @@ -59,12 +75,10 @@ func LoadNS() { _ = v4 for { var tmp5 any - checkDerefMacro(glojure_DOT_core__LT_) - tmp6 := glojure_DOT_core__LT_.Get() + tmp6 := checkDerefVar(var_glojure_DOT_core__LT_) tmp7 := lang.Apply(tmp6, []any{v4, int64(10)}) if lang.IsTruthy(tmp7) { - checkDerefMacro(glojure_DOT_core_inc) - tmp9 := glojure_DOT_core_inc.Get() + tmp9 := checkDerefVar(var_glojure_DOT_core_inc) tmp10 := lang.Apply(tmp9, []any{v4}) var tmp8 any = tmp10 v4 = tmp8 @@ -78,7 +92,7 @@ func LoadNS() { } // end let return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) diff --git a/pkg/codegen/testdata/codegen/test/maybe_class/load.go.out b/pkg/codegen/testdata/codegen/test/maybe_class/load.go.out index 7c5e85b2..abe91fed 100644 --- a/pkg/codegen/testdata/codegen/test/maybe_class/load.go.out +++ b/pkg/codegen/testdata/codegen/test/maybe_class/load.go.out @@ -1,6 +1,6 @@ // Code generated by glojure codegen. DO NOT EDIT. -package maybe_class +package maybe_DASH_class import ( fmt "fmt" @@ -8,35 +8,51 @@ import ( strings2 "strings" ) +func checkDerefVar(v *lang.Var) any { + if v.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) + } + return v.Get() +} +func checkArity(args []any, expected int) { + if len(args) != expected { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + // LoadNS initializes the namespace "codegen.test.maybe-class" func LoadNS() { - checkDerefMacro := func(v *lang.Var) { - if v.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) - } - } - _ = checkDerefMacro + sym__DASH_main := lang.NewSymbol("-main") + sym_codegen_DOT_test_DOT_maybe_DASH_class := lang.NewSymbol("codegen.test.maybe-class") + sym_glojure_DOT_core := lang.NewSymbol("glojure.core") + sym_vec := lang.NewSymbol("vec") + kw_arglists := lang.NewKeyword("arglists") + kw_column := lang.NewKeyword("column") + kw_end_DASH_column := lang.NewKeyword("end-column") + kw_end_DASH_line := lang.NewKeyword("end-line") + kw_expected_DASH_output := lang.NewKeyword("expected-output") + kw_file := lang.NewKeyword("file") + kw_line := lang.NewKeyword("line") + kw_ns := lang.NewKeyword("ns") + kw_rettag := lang.NewKeyword("rettag") // var glojure.core/vec - glojure_DOT_core_vec := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("vec")) + var_glojure_DOT_core_vec := lang.InternVarName(sym_glojure_DOT_core, sym_vec) // reference fmt to avoid unused import error _ = fmt.Printf - ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.maybe-class")) + ns := lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_maybe_DASH_class) _ = ns // -main { - tmp0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), lang.NewVector("1", "2", "3"), lang.NewKeyword("file"), "codegen/test/maybe_class.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(45), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.maybe-class")))).(*lang.Symbol) + tmp0 := sym__DASH_main.WithMeta(lang.NewMap(kw_expected_DASH_output, lang.NewVector("1", "2", "3"), kw_file, "codegen/test/maybe_class.glj", kw_line, int(3), kw_column, int(7), kw_end_DASH_line, int(3), kw_end_DASH_column, int(45), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_maybe_DASH_class))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - checkDerefMacro(glojure_DOT_core_vec) - tmp3 := glojure_DOT_core_vec.Get() + checkArity(args, 0) + tmp3 := checkDerefVar(var_glojure_DOT_core_vec) tmp4 := lang.Apply(strings2.Split, []any{"1,2,3", ","}) tmp5 := lang.Apply(tmp3, []any{tmp4}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) diff --git a/pkg/codegen/testdata/codegen/test/multifn/load.go.out b/pkg/codegen/testdata/codegen/test/multifn/load.go.out index d019e5e2..1d5ff0bb 100644 --- a/pkg/codegen/testdata/codegen/test/multifn/load.go.out +++ b/pkg/codegen/testdata/codegen/test/multifn/load.go.out @@ -8,49 +8,68 @@ import ( reflect "reflect" ) +func checkDerefVar(v *lang.Var) any { + if v.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) + } + return v.Get() +} +func checkArity(args []any, expected int) { + if len(args) != expected { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + // LoadNS initializes the namespace "codegen.test.multifn" func LoadNS() { - checkDerefMacro := func(v *lang.Var) { - if v.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) - } - } - _ = checkDerefMacro + sym__PLUS_ := lang.NewSymbol("+") + sym__DASH_main := lang.NewSymbol("-main") + sym_add := lang.NewSymbol("add") + sym_codegen_DOT_test_DOT_multifn := lang.NewSymbol("codegen.test.multifn") + sym_global_DASH_hierarchy := lang.NewSymbol("global-hierarchy") + sym_glojure_DOT_core := lang.NewSymbol("glojure.core") + sym_str := lang.NewSymbol("str") + sym_type := lang.NewSymbol("type") + kw_arglists := lang.NewKeyword("arglists") + kw_column := lang.NewKeyword("column") + kw_default := lang.NewKeyword("default") + kw_doc := lang.NewKeyword("doc") + kw_end_DASH_column := lang.NewKeyword("end-column") + kw_end_DASH_line := lang.NewKeyword("end-line") + kw_expected_DASH_output := lang.NewKeyword("expected-output") + kw_file := lang.NewKeyword("file") + kw_line := lang.NewKeyword("line") + kw_ns := lang.NewKeyword("ns") + kw_rettag := lang.NewKeyword("rettag") // var codegen.test.multifn/add - codegen_DOT_test_DOT_multifn_add := lang.InternVarName(lang.NewSymbol("codegen.test.multifn"), lang.NewSymbol("add")) + var_codegen_DOT_test_DOT_multifn_add := lang.InternVarName(sym_codegen_DOT_test_DOT_multifn, sym_add) // var glojure.core/+ - glojure_DOT_core__PLUS_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("+")) + var_glojure_DOT_core__PLUS_ := lang.InternVarName(sym_glojure_DOT_core, sym__PLUS_) // var glojure.core/str - glojure_DOT_core_str := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("str")) + var_glojure_DOT_core_str := lang.InternVarName(sym_glojure_DOT_core, sym_str) // var glojure.core/type - glojure_DOT_core_type := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("type")) + var_glojure_DOT_core_type := lang.InternVarName(sym_glojure_DOT_core, sym_type) // reference fmt to avoid unused import error _ = fmt.Printf - ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.multifn")) + ns := lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_multifn) _ = ns // -main { - tmp0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), "int64: 7 float64: 8.0 default: 3 4", lang.NewKeyword("file"), "codegen/test/multifn.glj", lang.NewKeyword("line"), int(8), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(8), lang.NewKeyword("end-column"), int(68), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.multifn")))).(*lang.Symbol) + tmp0 := sym__DASH_main.WithMeta(lang.NewMap(kw_expected_DASH_output, "int64: 7 float64: 8.0 default: 3 4", kw_file, "codegen/test/multifn.glj", kw_line, int(8), kw_column, int(7), kw_end_DASH_line, int(8), kw_end_DASH_column, int(68), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_multifn))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - checkDerefMacro(glojure_DOT_core_str) - tmp3 := glojure_DOT_core_str.Get() - checkDerefMacro(codegen_DOT_test_DOT_multifn_add) - tmp4 := codegen_DOT_test_DOT_multifn_add.Get() + checkArity(args, 0) + tmp3 := checkDerefVar(var_glojure_DOT_core_str) + tmp4 := checkDerefVar(var_codegen_DOT_test_DOT_multifn_add) tmp5 := lang.Apply(tmp4, []any{int64(3), int64(4)}) - checkDerefMacro(codegen_DOT_test_DOT_multifn_add) - tmp6 := codegen_DOT_test_DOT_multifn_add.Get() + tmp6 := checkDerefVar(var_codegen_DOT_test_DOT_multifn_add) tmp7 := lang.Apply(tmp6, []any{float64(3.5), float64(4.5)}) - checkDerefMacro(codegen_DOT_test_DOT_multifn_add) - tmp8 := codegen_DOT_test_DOT_multifn_add.Get() + tmp8 := checkDerefVar(var_codegen_DOT_test_DOT_multifn_add) tmp9 := lang.Apply(tmp8, []any{"3", "4"}) tmp10 := lang.Apply(tmp3, []any{tmp5, " ", tmp7, " ", tmp9}) return tmp10 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -58,37 +77,30 @@ func LoadNS() { } // add { - tmp0 := lang.NewSymbol("add").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/multifn.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(11), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("doc"), "a multimethod for addition", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.multifn")))).(*lang.Symbol) + tmp0 := sym_add.WithMeta(lang.NewMap(kw_file, "codegen/test/multifn.glj", kw_line, int(3), kw_column, int(11), kw_end_DASH_line, int(3), kw_end_DASH_column, int(13), kw_doc, "a multimethod for addition", kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_multifn))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v4 := args[0] _ = v4 v5 := args[1] _ = v5 - checkDerefMacro(glojure_DOT_core_type) - tmp6 := glojure_DOT_core_type.Get() + tmp6 := checkDerefVar(var_glojure_DOT_core_type) tmp7 := lang.Apply(tmp6, []any{v4}) return tmp7 }) - tmp3 = tmp3.WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/multifn.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(44), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(62))).(lang.FnFunc) - tmp2 := lang.NewMultiFn("add", tmp3, lang.NewKeyword("default"), lang.FindOrCreateNamespace(lang.NewSymbol("glojure.core")).FindInternedVar(lang.NewSymbol("global-hierarchy"))) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_file, "codegen/test/multifn.glj", kw_line, int(3), kw_column, int(44), kw_end_DASH_line, int(3), kw_end_DASH_column, int(62))).(lang.FnFunc) + tmp2 := lang.NewMultiFn("add", tmp3, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) tmp4 := reflect.TypeOf(int64(0)) var tmp5 lang.FnFunc tmp5 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v6 := args[0] _ = v6 v7 := args[1] _ = v7 - checkDerefMacro(glojure_DOT_core_str) - tmp8 := glojure_DOT_core_str.Get() - checkDerefMacro(glojure_DOT_core__PLUS_) - tmp9 := glojure_DOT_core__PLUS_.Get() + tmp8 := checkDerefVar(var_glojure_DOT_core_str) + tmp9 := checkDerefVar(var_glojure_DOT_core__PLUS_) tmp10 := lang.Apply(tmp9, []any{v6, v7}) tmp11 := lang.Apply(tmp8, []any{"int64: ", tmp10}) return tmp11 @@ -97,17 +109,13 @@ func LoadNS() { tmp6 := reflect.TypeOf(float64(0)) var tmp7 lang.FnFunc tmp7 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v8 := args[0] _ = v8 v9 := args[1] _ = v9 - checkDerefMacro(glojure_DOT_core_str) - tmp10 := glojure_DOT_core_str.Get() - checkDerefMacro(glojure_DOT_core__PLUS_) - tmp11 := glojure_DOT_core__PLUS_.Get() + tmp10 := checkDerefVar(var_glojure_DOT_core_str) + tmp11 := checkDerefVar(var_glojure_DOT_core__PLUS_) tmp12 := lang.Apply(tmp11, []any{v8, v9}) tmp13 := lang.Apply(tmp10, []any{"float64: ", tmp12}) return tmp13 @@ -115,19 +123,16 @@ func LoadNS() { tmp2.AddMethod(tmp6, tmp7) var tmp8 lang.FnFunc tmp8 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 2 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 2) v9 := args[0] _ = v9 v10 := args[1] _ = v10 - checkDerefMacro(glojure_DOT_core_str) - tmp11 := glojure_DOT_core_str.Get() + tmp11 := checkDerefVar(var_glojure_DOT_core_str) tmp12 := lang.Apply(tmp11, []any{"default: ", v9, " ", v10}) return tmp12 }) - tmp2.AddMethod(lang.NewKeyword("default"), tmp8) + tmp2.AddMethod(kw_default, tmp8) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) diff --git a/pkg/codegen/testdata/codegen/test/ns_skip/load.go.out b/pkg/codegen/testdata/codegen/test/ns_skip/load.go.out index a9050b8e..2fda3a38 100644 --- a/pkg/codegen/testdata/codegen/test/ns_skip/load.go.out +++ b/pkg/codegen/testdata/codegen/test/ns_skip/load.go.out @@ -1,22 +1,29 @@ // Code generated by glojure codegen. DO NOT EDIT. -package ns_skip +package ns_DASH_skip import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" ) +func checkDerefVar(v *lang.Var) any { + if v.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) + } + return v.Get() +} +func checkArity(args []any, expected int) { + if len(args) != expected { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + // LoadNS initializes the namespace "codegen.test.ns-skip" func LoadNS() { - checkDerefMacro := func(v *lang.Var) { - if v.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) - } - } - _ = checkDerefMacro + sym_codegen_DOT_test_DOT_ns_DASH_skip := lang.NewSymbol("codegen.test.ns-skip") // reference fmt to avoid unused import error _ = fmt.Printf - ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.ns-skip")) + ns := lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_ns_DASH_skip) _ = ns } diff --git a/pkg/codegen/testdata/codegen/test/quote_simple/load.go.out b/pkg/codegen/testdata/codegen/test/quote_simple/load.go.out index 4964834b..3d610c7b 100644 --- a/pkg/codegen/testdata/codegen/test/quote_simple/load.go.out +++ b/pkg/codegen/testdata/codegen/test/quote_simple/load.go.out @@ -1,35 +1,50 @@ // Code generated by glojure codegen. DO NOT EDIT. -package quote_simple +package quote_DASH_simple import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" ) +func checkDerefVar(v *lang.Var) any { + if v.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) + } + return v.Get() +} +func checkArity(args []any, expected int) { + if len(args) != expected { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + // LoadNS initializes the namespace "codegen.test.quote-simple" func LoadNS() { - checkDerefMacro := func(v *lang.Var) { - if v.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) - } - } - _ = checkDerefMacro + sym__DASH_main := lang.NewSymbol("-main") + sym_codegen_DOT_test_DOT_quote_DASH_simple := lang.NewSymbol("codegen.test.quote-simple") + kw_arglists := lang.NewKeyword("arglists") + kw_column := lang.NewKeyword("column") + kw_end_DASH_column := lang.NewKeyword("end-column") + kw_end_DASH_line := lang.NewKeyword("end-line") + kw_expected_DASH_output := lang.NewKeyword("expected-output") + kw_file := lang.NewKeyword("file") + kw_line := lang.NewKeyword("line") + kw_ns := lang.NewKeyword("ns") + kw_rettag := lang.NewKeyword("rettag") // reference fmt to avoid unused import error _ = fmt.Printf - ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.quote-simple")) + ns := lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_quote_DASH_simple) _ = ns // -main { - tmp0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), lang.NewList(int64(1), int64(2), int64(3)), lang.NewKeyword("file"), "codegen/test/quote_simple.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(44), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.quote-simple")))).(*lang.Symbol) + tmp0 := sym__DASH_main.WithMeta(lang.NewMap(kw_expected_DASH_output, lang.NewList(int64(1), int64(2), int64(3)), kw_file, "codegen/test/quote_simple.glj", kw_line, int(3), kw_column, int(7), kw_end_DASH_line, int(3), kw_end_DASH_column, int(44), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_quote_DASH_simple))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) return lang.NewList(int64(1), int64(2), int64(3)) }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) diff --git a/pkg/codegen/testdata/codegen/test/ref/load.go.out b/pkg/codegen/testdata/codegen/test/ref/load.go.out index e15df75e..983a4abf 100644 --- a/pkg/codegen/testdata/codegen/test/ref/load.go.out +++ b/pkg/codegen/testdata/codegen/test/ref/load.go.out @@ -7,38 +7,55 @@ import ( lang "github.com/glojurelang/glojure/pkg/lang" ) +func checkDerefVar(v *lang.Var) any { + if v.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) + } + return v.Get() +} +func checkArity(args []any, expected int) { + if len(args) != expected { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + // LoadNS initializes the namespace "codegen.test.ref" func LoadNS() { - checkDerefMacro := func(v *lang.Var) { - if v.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) - } - } - _ = checkDerefMacro + sym__DASH_main := lang.NewSymbol("-main") + sym_codegen_DOT_test_DOT_ref := lang.NewSymbol("codegen.test.ref") + sym_deref := lang.NewSymbol("deref") + sym_glojure_DOT_core := lang.NewSymbol("glojure.core") + sym_test_DASH_ref := lang.NewSymbol("test-ref") + kw_arglists := lang.NewKeyword("arglists") + kw_column := lang.NewKeyword("column") + kw_doc := lang.NewKeyword("doc") + kw_end_DASH_column := lang.NewKeyword("end-column") + kw_end_DASH_line := lang.NewKeyword("end-line") + kw_expected_DASH_output := lang.NewKeyword("expected-output") + kw_file := lang.NewKeyword("file") + kw_line := lang.NewKeyword("line") + kw_ns := lang.NewKeyword("ns") + kw_rettag := lang.NewKeyword("rettag") // var codegen.test.ref/test-ref - codegen_DOT_test_DOT_ref_test_ref := lang.InternVarName(lang.NewSymbol("codegen.test.ref"), lang.NewSymbol("test-ref")) + var_codegen_DOT_test_DOT_ref_test_DASH_ref := lang.InternVarName(sym_codegen_DOT_test_DOT_ref, sym_test_DASH_ref) // var glojure.core/deref - glojure_DOT_core_deref := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("deref")) + var_glojure_DOT_core_deref := lang.InternVarName(sym_glojure_DOT_core, sym_deref) // reference fmt to avoid unused import error _ = fmt.Printf - ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.ref")) + ns := lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_ref) _ = ns // -main { - tmp0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2), int64(3)})), lang.NewKeyword("file"), "codegen/test/ref.glj", lang.NewKeyword("line"), int(8), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(9), lang.NewKeyword("end-column"), int(7), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.ref")))).(*lang.Symbol) + tmp0 := sym__DASH_main.WithMeta(lang.NewMap(kw_expected_DASH_output, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2), int64(3)})), kw_file, "codegen/test/ref.glj", kw_line, int(8), kw_column, int(3), kw_end_DASH_line, int(9), kw_end_DASH_column, int(7), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_ref))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - checkDerefMacro(glojure_DOT_core_deref) - tmp3 := glojure_DOT_core_deref.Get() - checkDerefMacro(codegen_DOT_test_DOT_ref_test_ref) - tmp4 := codegen_DOT_test_DOT_ref_test_ref.Get() + checkArity(args, 0) + tmp3 := checkDerefVar(var_glojure_DOT_core_deref) + tmp4 := checkDerefVar(var_codegen_DOT_test_DOT_ref_test_DASH_ref) tmp5 := lang.Apply(tmp3, []any{tmp4}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -46,7 +63,7 @@ func LoadNS() { } // test-ref { - tmp0 := lang.NewSymbol("test-ref").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/ref.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(13), lang.NewKeyword("doc"), "A reference to a set.", lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.ref")))).(*lang.Symbol) + tmp0 := sym_test_DASH_ref.WithMeta(lang.NewMap(kw_file, "codegen/test/ref.glj", kw_line, int(3), kw_column, int(6), kw_end_DASH_line, int(3), kw_end_DASH_column, int(13), kw_doc, "A reference to a set.", kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_ref))).(*lang.Symbol) tmp2 := lang.NewRef(lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2), int64(3)}))) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { diff --git a/pkg/codegen/testdata/codegen/test/the_var/load.go.out b/pkg/codegen/testdata/codegen/test/the_var/load.go.out index 95b8e674..bc31440b 100644 --- a/pkg/codegen/testdata/codegen/test/the_var/load.go.out +++ b/pkg/codegen/testdata/codegen/test/the_var/load.go.out @@ -1,6 +1,6 @@ // Code generated by glojure codegen. DO NOT EDIT. -package the_var +package the_DASH_var import ( fmt "fmt" @@ -8,27 +8,43 @@ import ( reflect "reflect" ) +func checkDerefVar(v *lang.Var) any { + if v.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) + } + return v.Get() +} +func checkArity(args []any, expected int) { + if len(args) != expected { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + // LoadNS initializes the namespace "codegen.test.the-var" func LoadNS() { - checkDerefMacro := func(v *lang.Var) { - if v.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) - } - } - _ = checkDerefMacro + sym__DASH_main := lang.NewSymbol("-main") + sym_codegen_DOT_test_DOT_the_DASH_var := lang.NewSymbol("codegen.test.the-var") + sym_foo := lang.NewSymbol("foo") + kw_arglists := lang.NewKeyword("arglists") + kw_column := lang.NewKeyword("column") + kw_end_DASH_column := lang.NewKeyword("end-column") + kw_end_DASH_line := lang.NewKeyword("end-line") + kw_expected_DASH_output := lang.NewKeyword("expected-output") + kw_file := lang.NewKeyword("file") + kw_line := lang.NewKeyword("line") + kw_ns := lang.NewKeyword("ns") + kw_rettag := lang.NewKeyword("rettag") // reference fmt to avoid unused import error _ = fmt.Printf - ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.the-var")) + ns := lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_the_DASH_var) _ = ns // -main { - tmp0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), int64(42), lang.NewKeyword("file"), "codegen/test/the_var.glj", lang.NewKeyword("line"), int(5), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(5), lang.NewKeyword("end-column"), int(34), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.the-var")))).(*lang.Symbol) + tmp0 := sym__DASH_main.WithMeta(lang.NewMap(kw_expected_DASH_output, int64(42), kw_file, "codegen/test/the_var.glj", kw_line, int(5), kw_column, int(7), kw_end_DASH_line, int(5), kw_end_DASH_column, int(34), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_the_DASH_var))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - tmp3 := lang.InternVarName(lang.NewSymbol("codegen.test.the-var"), lang.NewSymbol("foo")) + checkArity(args, 0) + tmp3 := lang.InternVarName(sym_codegen_DOT_test_DOT_the_DASH_var, sym_foo) tmp4, ok := lang.FieldOrMethod(tmp3, "get") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp3, "get"))) @@ -42,7 +58,7 @@ func LoadNS() { } return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -50,7 +66,7 @@ func LoadNS() { } // foo { - tmp0 := lang.NewSymbol("foo").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/the_var.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(8), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.the-var")))).(*lang.Symbol) + tmp0 := sym_foo.WithMeta(lang.NewMap(kw_file, "codegen/test/the_var.glj", kw_line, int(3), kw_column, int(6), kw_end_DASH_line, int(3), kw_end_DASH_column, int(8), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_the_DASH_var))).(*lang.Symbol) tmp1 := ns.InternWithValue(tmp0, int64(42), true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) diff --git a/pkg/codegen/testdata/codegen/test/throw_simple/load.go.out b/pkg/codegen/testdata/codegen/test/throw_simple/load.go.out index b9ee93aa..9e5169c5 100644 --- a/pkg/codegen/testdata/codegen/test/throw_simple/load.go.out +++ b/pkg/codegen/testdata/codegen/test/throw_simple/load.go.out @@ -1,35 +1,50 @@ // Code generated by glojure codegen. DO NOT EDIT. -package throw_simple +package throw_DASH_simple import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" ) +func checkDerefVar(v *lang.Var) any { + if v.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) + } + return v.Get() +} +func checkArity(args []any, expected int) { + if len(args) != expected { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + // LoadNS initializes the namespace "codegen.test.throw-simple" func LoadNS() { - checkDerefMacro := func(v *lang.Var) { - if v.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) - } - } - _ = checkDerefMacro + sym__DASH_main := lang.NewSymbol("-main") + sym_codegen_DOT_test_DOT_throw_DASH_simple := lang.NewSymbol("codegen.test.throw-simple") + kw_arglists := lang.NewKeyword("arglists") + kw_column := lang.NewKeyword("column") + kw_end_DASH_column := lang.NewKeyword("end-column") + kw_end_DASH_line := lang.NewKeyword("end-line") + kw_expected_DASH_throw := lang.NewKeyword("expected-throw") + kw_file := lang.NewKeyword("file") + kw_line := lang.NewKeyword("line") + kw_ns := lang.NewKeyword("ns") + kw_rettag := lang.NewKeyword("rettag") // reference fmt to avoid unused import error _ = fmt.Printf - ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.throw-simple")) + ns := lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_throw_DASH_simple) _ = ns // -main { - tmp0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-throw"), "uncaught error", lang.NewKeyword("file"), "codegen/test/throw_simple.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(47), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.throw-simple")))).(*lang.Symbol) + tmp0 := sym__DASH_main.WithMeta(lang.NewMap(kw_expected_DASH_throw, "uncaught error", kw_file, "codegen/test/throw_simple.glj", kw_line, int(3), kw_column, int(7), kw_end_DASH_line, int(3), kw_end_DASH_column, int(47), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_throw_DASH_simple))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) panic("uncaught error") }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) diff --git a/pkg/codegen/testdata/codegen/test/try_advanced/load.go.out b/pkg/codegen/testdata/codegen/test/try_advanced/load.go.out index 92af9d32..150fa3eb 100644 --- a/pkg/codegen/testdata/codegen/test/try_advanced/load.go.out +++ b/pkg/codegen/testdata/codegen/test/try_advanced/load.go.out @@ -1,47 +1,66 @@ // Code generated by glojure codegen. DO NOT EDIT. -package try_advanced +package try_DASH_advanced import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" ) +func checkDerefVar(v *lang.Var) any { + if v.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) + } + return v.Get() +} +func checkArity(args []any, expected int) { + if len(args) != expected { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + // LoadNS initializes the namespace "codegen.test.try-advanced" func LoadNS() { - checkDerefMacro := func(v *lang.Var) { - if v.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) - } - } - _ = checkDerefMacro + sym__DASH_main := lang.NewSymbol("-main") + sym__EQ_ := lang.NewSymbol("=") + sym_catch_DASH_binding_DASH_scope := lang.NewSymbol("catch-binding-scope") + sym_catch_DASH_binding_DASH_scope_DASH_2 := lang.NewSymbol("catch-binding-scope-2") + sym_codegen_DOT_test_DOT_try_DASH_advanced := lang.NewSymbol("codegen.test.try-advanced") + sym_finally_DASH_with_DASH_return := lang.NewSymbol("finally-with-return") + sym_glojure_DOT_core := lang.NewSymbol("glojure.core") + sym_try_DASH_custom_DASH_value := lang.NewSymbol("try-custom-value") + kw_arglists := lang.NewKeyword("arglists") + kw_column := lang.NewKeyword("column") + kw_end_DASH_column := lang.NewKeyword("end-column") + kw_end_DASH_line := lang.NewKeyword("end-line") + kw_expected_DASH_output := lang.NewKeyword("expected-output") + kw_file := lang.NewKeyword("file") + kw_line := lang.NewKeyword("line") + kw_ns := lang.NewKeyword("ns") + kw_rettag := lang.NewKeyword("rettag") // var codegen.test.try-advanced/catch-binding-scope - codegen_DOT_test_DOT_try_advanced_catch_binding_scope := lang.InternVarName(lang.NewSymbol("codegen.test.try-advanced"), lang.NewSymbol("catch-binding-scope")) + var_codegen_DOT_test_DOT_try_DASH_advanced_catch_DASH_binding_DASH_scope := lang.InternVarName(sym_codegen_DOT_test_DOT_try_DASH_advanced, sym_catch_DASH_binding_DASH_scope) // var codegen.test.try-advanced/catch-binding-scope-2 - codegen_DOT_test_DOT_try_advanced_catch_binding_scope_2 := lang.InternVarName(lang.NewSymbol("codegen.test.try-advanced"), lang.NewSymbol("catch-binding-scope-2")) + var_codegen_DOT_test_DOT_try_DASH_advanced_catch_DASH_binding_DASH_scope_DASH_2 := lang.InternVarName(sym_codegen_DOT_test_DOT_try_DASH_advanced, sym_catch_DASH_binding_DASH_scope_DASH_2) // var codegen.test.try-advanced/finally-with-return - codegen_DOT_test_DOT_try_advanced_finally_with_return := lang.InternVarName(lang.NewSymbol("codegen.test.try-advanced"), lang.NewSymbol("finally-with-return")) + var_codegen_DOT_test_DOT_try_DASH_advanced_finally_DASH_with_DASH_return := lang.InternVarName(sym_codegen_DOT_test_DOT_try_DASH_advanced, sym_finally_DASH_with_DASH_return) // var codegen.test.try-advanced/try-custom-value - codegen_DOT_test_DOT_try_advanced_try_custom_value := lang.InternVarName(lang.NewSymbol("codegen.test.try-advanced"), lang.NewSymbol("try-custom-value")) + var_codegen_DOT_test_DOT_try_DASH_advanced_try_DASH_custom_DASH_value := lang.InternVarName(sym_codegen_DOT_test_DOT_try_DASH_advanced, sym_try_DASH_custom_DASH_value) // var glojure.core/= - glojure_DOT_core__EQ_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("=")) + var_glojure_DOT_core__EQ_ := lang.InternVarName(sym_glojure_DOT_core, sym__EQ_) // reference fmt to avoid unused import error _ = fmt.Printf - ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-advanced")) + ns := lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_try_DASH_advanced) _ = ns // -main { - tmp0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), "advanced tests passed", lang.NewKeyword("file"), "codegen/test/try_advanced.glj", lang.NewKeyword("line"), int(30), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(30), lang.NewKeyword("end-column"), int(55), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-advanced")))).(*lang.Symbol) + tmp0 := sym__DASH_main.WithMeta(lang.NewMap(kw_expected_DASH_output, "advanced tests passed", kw_file, "codegen/test/try_advanced.glj", kw_line, int(30), kw_column, int(7), kw_end_DASH_line, int(30), kw_end_DASH_column, int(55), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_try_DASH_advanced))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var tmp3 any - checkDerefMacro(glojure_DOT_core__EQ_) - tmp4 := glojure_DOT_core__EQ_.Get() - checkDerefMacro(codegen_DOT_test_DOT_try_advanced_try_custom_value) - tmp5 := codegen_DOT_test_DOT_try_advanced_try_custom_value.Get() + tmp4 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp5 := checkDerefVar(var_codegen_DOT_test_DOT_try_DASH_advanced_try_DASH_custom_DASH_value) tmp6 := lang.Apply(tmp5, nil) tmp7 := lang.Apply(tmp4, []any{tmp6, "custom error"}) if lang.IsTruthy(tmp7) { @@ -50,10 +69,8 @@ func LoadNS() { } _ = tmp3 var tmp8 any - checkDerefMacro(glojure_DOT_core__EQ_) - tmp9 := glojure_DOT_core__EQ_.Get() - checkDerefMacro(codegen_DOT_test_DOT_try_advanced_catch_binding_scope) - tmp10 := codegen_DOT_test_DOT_try_advanced_catch_binding_scope.Get() + tmp9 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp10 := checkDerefVar(var_codegen_DOT_test_DOT_try_DASH_advanced_catch_DASH_binding_DASH_scope) tmp11 := lang.Apply(tmp10, nil) tmp12 := lang.Apply(tmp9, []any{tmp11, "test"}) if lang.IsTruthy(tmp12) { @@ -62,10 +79,8 @@ func LoadNS() { } _ = tmp8 var tmp13 any - checkDerefMacro(glojure_DOT_core__EQ_) - tmp14 := glojure_DOT_core__EQ_.Get() - checkDerefMacro(codegen_DOT_test_DOT_try_advanced_catch_binding_scope_2) - tmp15 := codegen_DOT_test_DOT_try_advanced_catch_binding_scope_2.Get() + tmp14 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp15 := checkDerefVar(var_codegen_DOT_test_DOT_try_DASH_advanced_catch_DASH_binding_DASH_scope_DASH_2) tmp16 := lang.Apply(tmp15, nil) tmp17 := lang.Apply(tmp14, []any{tmp16, "outer"}) if lang.IsTruthy(tmp17) { @@ -74,10 +89,8 @@ func LoadNS() { } _ = tmp13 var tmp18 any - checkDerefMacro(glojure_DOT_core__EQ_) - tmp19 := glojure_DOT_core__EQ_.Get() - checkDerefMacro(codegen_DOT_test_DOT_try_advanced_finally_with_return) - tmp20 := codegen_DOT_test_DOT_try_advanced_finally_with_return.Get() + tmp19 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp20 := checkDerefVar(var_codegen_DOT_test_DOT_try_DASH_advanced_finally_DASH_with_DASH_return) tmp21 := lang.Apply(tmp20, nil) tmp22 := lang.Apply(tmp19, []any{tmp21, int64(42)}) if lang.IsTruthy(tmp22) { @@ -87,7 +100,7 @@ func LoadNS() { _ = tmp18 return "advanced tests passed" }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -95,12 +108,10 @@ func LoadNS() { } // catch-binding-scope { - tmp0 := lang.NewSymbol("catch-binding-scope").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_advanced.glj", lang.NewKeyword("line"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(9), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-advanced")))).(*lang.Symbol) + tmp0 := sym_catch_DASH_binding_DASH_scope.WithMeta(lang.NewMap(kw_file, "codegen/test/try_advanced.glj", kw_line, int(9), kw_column, int(7), kw_end_DASH_line, int(9), kw_end_DASH_column, int(25), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_try_DASH_advanced))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var tmp3 any { // let // let binding "e" @@ -125,7 +136,7 @@ func LoadNS() { } // end let return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -133,12 +144,10 @@ func LoadNS() { } // catch-binding-scope-2 { - tmp0 := lang.NewSymbol("catch-binding-scope-2").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_advanced.glj", lang.NewKeyword("line"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(16), lang.NewKeyword("end-column"), int(27), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-advanced")))).(*lang.Symbol) + tmp0 := sym_catch_DASH_binding_DASH_scope_DASH_2.WithMeta(lang.NewMap(kw_file, "codegen/test/try_advanced.glj", kw_line, int(16), kw_column, int(7), kw_end_DASH_line, int(16), kw_end_DASH_column, int(27), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_try_DASH_advanced))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var tmp3 any { // let // let binding "e" @@ -164,7 +173,7 @@ func LoadNS() { } // end let return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -172,12 +181,10 @@ func LoadNS() { } // finally-with-return { - tmp0 := lang.NewSymbol("finally-with-return").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_advanced.glj", lang.NewKeyword("line"), int(24), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(24), lang.NewKeyword("end-column"), int(25), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-advanced")))).(*lang.Symbol) + tmp0 := sym_finally_DASH_with_DASH_return.WithMeta(lang.NewMap(kw_file, "codegen/test/try_advanced.glj", kw_line, int(24), kw_column, int(7), kw_end_DASH_line, int(24), kw_end_DASH_column, int(25), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_try_DASH_advanced))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var tmp3 any func() { defer func() { @@ -187,7 +194,7 @@ func LoadNS() { }() return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -195,12 +202,10 @@ func LoadNS() { } // try-custom-value { - tmp0 := lang.NewSymbol("try-custom-value").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_advanced.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-advanced")))).(*lang.Symbol) + tmp0 := sym_try_DASH_custom_DASH_value.WithMeta(lang.NewMap(kw_file, "codegen/test/try_advanced.glj", kw_line, int(3), kw_column, int(7), kw_end_DASH_line, int(3), kw_end_DASH_column, int(22), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_try_DASH_advanced))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var tmp3 any func() { defer func() { @@ -218,7 +223,7 @@ func LoadNS() { }() return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) diff --git a/pkg/codegen/testdata/codegen/test/try_basic/load.go.out b/pkg/codegen/testdata/codegen/test/try_basic/load.go.out index 75a91de7..f4b35a98 100644 --- a/pkg/codegen/testdata/codegen/test/try_basic/load.go.out +++ b/pkg/codegen/testdata/codegen/test/try_basic/load.go.out @@ -1,51 +1,72 @@ // Code generated by glojure codegen. DO NOT EDIT. -package try_basic +package try_DASH_basic import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" ) +func checkDerefVar(v *lang.Var) any { + if v.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) + } + return v.Get() +} +func checkArity(args []any, expected int) { + if len(args) != expected { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + // LoadNS initializes the namespace "codegen.test.try-basic" func LoadNS() { - checkDerefMacro := func(v *lang.Var) { - if v.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) - } - } - _ = checkDerefMacro + sym__DASH_main := lang.NewSymbol("-main") + sym__EQ_ := lang.NewSymbol("=") + sym_basic_DASH_try := lang.NewSymbol("basic-try") + sym_codegen_DOT_test_DOT_try_DASH_basic := lang.NewSymbol("codegen.test.try-basic") + sym_glojure_DOT_core := lang.NewSymbol("glojure.core") + sym_nested_DASH_try := lang.NewSymbol("nested-try") + sym_try_DASH_catch_DASH_finally := lang.NewSymbol("try-catch-finally") + sym_try_DASH_finally_DASH_only := lang.NewSymbol("try-finally-only") + sym_try_DASH_no_DASH_catch := lang.NewSymbol("try-no-catch") + sym_try_DASH_with_DASH_throw := lang.NewSymbol("try-with-throw") + kw_arglists := lang.NewKeyword("arglists") + kw_column := lang.NewKeyword("column") + kw_end_DASH_column := lang.NewKeyword("end-column") + kw_end_DASH_line := lang.NewKeyword("end-line") + kw_expected_DASH_output := lang.NewKeyword("expected-output") + kw_file := lang.NewKeyword("file") + kw_line := lang.NewKeyword("line") + kw_ns := lang.NewKeyword("ns") + kw_rettag := lang.NewKeyword("rettag") // var codegen.test.try-basic/basic-try - codegen_DOT_test_DOT_try_basic_basic_try := lang.InternVarName(lang.NewSymbol("codegen.test.try-basic"), lang.NewSymbol("basic-try")) + var_codegen_DOT_test_DOT_try_DASH_basic_basic_DASH_try := lang.InternVarName(sym_codegen_DOT_test_DOT_try_DASH_basic, sym_basic_DASH_try) // var codegen.test.try-basic/nested-try - codegen_DOT_test_DOT_try_basic_nested_try := lang.InternVarName(lang.NewSymbol("codegen.test.try-basic"), lang.NewSymbol("nested-try")) + var_codegen_DOT_test_DOT_try_DASH_basic_nested_DASH_try := lang.InternVarName(sym_codegen_DOT_test_DOT_try_DASH_basic, sym_nested_DASH_try) // var codegen.test.try-basic/try-catch-finally - codegen_DOT_test_DOT_try_basic_try_catch_finally := lang.InternVarName(lang.NewSymbol("codegen.test.try-basic"), lang.NewSymbol("try-catch-finally")) + var_codegen_DOT_test_DOT_try_DASH_basic_try_DASH_catch_DASH_finally := lang.InternVarName(sym_codegen_DOT_test_DOT_try_DASH_basic, sym_try_DASH_catch_DASH_finally) // var codegen.test.try-basic/try-finally-only - codegen_DOT_test_DOT_try_basic_try_finally_only := lang.InternVarName(lang.NewSymbol("codegen.test.try-basic"), lang.NewSymbol("try-finally-only")) + var_codegen_DOT_test_DOT_try_DASH_basic_try_DASH_finally_DASH_only := lang.InternVarName(sym_codegen_DOT_test_DOT_try_DASH_basic, sym_try_DASH_finally_DASH_only) // var codegen.test.try-basic/try-no-catch - codegen_DOT_test_DOT_try_basic_try_no_catch := lang.InternVarName(lang.NewSymbol("codegen.test.try-basic"), lang.NewSymbol("try-no-catch")) + var_codegen_DOT_test_DOT_try_DASH_basic_try_DASH_no_DASH_catch := lang.InternVarName(sym_codegen_DOT_test_DOT_try_DASH_basic, sym_try_DASH_no_DASH_catch) // var codegen.test.try-basic/try-with-throw - codegen_DOT_test_DOT_try_basic_try_with_throw := lang.InternVarName(lang.NewSymbol("codegen.test.try-basic"), lang.NewSymbol("try-with-throw")) + var_codegen_DOT_test_DOT_try_DASH_basic_try_DASH_with_DASH_throw := lang.InternVarName(sym_codegen_DOT_test_DOT_try_DASH_basic, sym_try_DASH_with_DASH_throw) // var glojure.core/= - glojure_DOT_core__EQ_ := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("=")) + var_glojure_DOT_core__EQ_ := lang.InternVarName(sym_glojure_DOT_core, sym__EQ_) // reference fmt to avoid unused import error _ = fmt.Printf - ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")) + ns := lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_try_DASH_basic) _ = ns // -main { - tmp0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), "all tests passed", lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(43), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(43), lang.NewKeyword("end-column"), int(50), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")))).(*lang.Symbol) + tmp0 := sym__DASH_main.WithMeta(lang.NewMap(kw_expected_DASH_output, "all tests passed", kw_file, "codegen/test/try_basic.glj", kw_line, int(43), kw_column, int(7), kw_end_DASH_line, int(43), kw_end_DASH_column, int(50), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_try_DASH_basic))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var tmp3 any - checkDerefMacro(glojure_DOT_core__EQ_) - tmp4 := glojure_DOT_core__EQ_.Get() - checkDerefMacro(codegen_DOT_test_DOT_try_basic_basic_try) - tmp5 := codegen_DOT_test_DOT_try_basic_basic_try.Get() + tmp4 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp5 := checkDerefVar(var_codegen_DOT_test_DOT_try_DASH_basic_basic_DASH_try) tmp6 := lang.Apply(tmp5, nil) tmp7 := lang.Apply(tmp4, []any{tmp6, "success"}) if lang.IsTruthy(tmp7) { @@ -54,10 +75,8 @@ func LoadNS() { } _ = tmp3 var tmp8 any - checkDerefMacro(glojure_DOT_core__EQ_) - tmp9 := glojure_DOT_core__EQ_.Get() - checkDerefMacro(codegen_DOT_test_DOT_try_basic_try_with_throw) - tmp10 := codegen_DOT_test_DOT_try_basic_try_with_throw.Get() + tmp9 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp10 := checkDerefVar(var_codegen_DOT_test_DOT_try_DASH_basic_try_DASH_with_DASH_throw) tmp11 := lang.Apply(tmp10, nil) tmp12 := lang.Apply(tmp9, []any{tmp11, "caught exception"}) if lang.IsTruthy(tmp12) { @@ -66,10 +85,8 @@ func LoadNS() { } _ = tmp8 var tmp13 any - checkDerefMacro(glojure_DOT_core__EQ_) - tmp14 := glojure_DOT_core__EQ_.Get() - checkDerefMacro(codegen_DOT_test_DOT_try_basic_try_no_catch) - tmp15 := codegen_DOT_test_DOT_try_basic_try_no_catch.Get() + tmp14 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp15 := checkDerefVar(var_codegen_DOT_test_DOT_try_DASH_basic_try_DASH_no_DASH_catch) tmp16 := lang.Apply(tmp15, nil) tmp17 := lang.Apply(tmp14, []any{tmp16, "just body"}) if lang.IsTruthy(tmp17) { @@ -78,10 +95,8 @@ func LoadNS() { } _ = tmp13 var tmp18 any - checkDerefMacro(glojure_DOT_core__EQ_) - tmp19 := glojure_DOT_core__EQ_.Get() - checkDerefMacro(codegen_DOT_test_DOT_try_basic_try_finally_only) - tmp20 := codegen_DOT_test_DOT_try_basic_try_finally_only.Get() + tmp19 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp20 := checkDerefVar(var_codegen_DOT_test_DOT_try_DASH_basic_try_DASH_finally_DASH_only) tmp21 := lang.Apply(tmp20, nil) tmp22 := lang.Apply(tmp19, []any{tmp21, "body"}) if lang.IsTruthy(tmp22) { @@ -90,10 +105,8 @@ func LoadNS() { } _ = tmp18 var tmp23 any - checkDerefMacro(glojure_DOT_core__EQ_) - tmp24 := glojure_DOT_core__EQ_.Get() - checkDerefMacro(codegen_DOT_test_DOT_try_basic_try_catch_finally) - tmp25 := codegen_DOT_test_DOT_try_basic_try_catch_finally.Get() + tmp24 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp25 := checkDerefVar(var_codegen_DOT_test_DOT_try_DASH_basic_try_DASH_catch_DASH_finally) tmp26 := lang.Apply(tmp25, nil) tmp27 := lang.Apply(tmp24, []any{tmp26, "caught"}) if lang.IsTruthy(tmp27) { @@ -102,10 +115,8 @@ func LoadNS() { } _ = tmp23 var tmp28 any - checkDerefMacro(glojure_DOT_core__EQ_) - tmp29 := glojure_DOT_core__EQ_.Get() - checkDerefMacro(codegen_DOT_test_DOT_try_basic_nested_try) - tmp30 := codegen_DOT_test_DOT_try_basic_nested_try.Get() + tmp29 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp30 := checkDerefVar(var_codegen_DOT_test_DOT_try_DASH_basic_nested_DASH_try) tmp31 := lang.Apply(tmp30, nil) tmp32 := lang.Apply(tmp29, []any{tmp31, "inner caught"}) if lang.IsTruthy(tmp32) { @@ -115,7 +126,7 @@ func LoadNS() { _ = tmp28 return "all tests passed" }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -123,12 +134,10 @@ func LoadNS() { } // basic-try { - tmp0 := lang.NewSymbol("basic-try").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(15), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")))).(*lang.Symbol) + tmp0 := sym_basic_DASH_try.WithMeta(lang.NewMap(kw_file, "codegen/test/try_basic.glj", kw_line, int(3), kw_column, int(7), kw_end_DASH_line, int(3), kw_end_DASH_column, int(15), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_try_DASH_basic))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var tmp3 any func() { defer func() { @@ -146,7 +155,7 @@ func LoadNS() { }() return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -154,12 +163,10 @@ func LoadNS() { } // nested-try { - tmp0 := lang.NewSymbol("nested-try").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(34), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(34), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")))).(*lang.Symbol) + tmp0 := sym_nested_DASH_try.WithMeta(lang.NewMap(kw_file, "codegen/test/try_basic.glj", kw_line, int(34), kw_column, int(7), kw_end_DASH_line, int(34), kw_end_DASH_column, int(16), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_try_DASH_basic))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var tmp3 any func() { defer func() { @@ -192,7 +199,7 @@ func LoadNS() { }() return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -200,12 +207,10 @@ func LoadNS() { } // try-catch-finally { - tmp0 := lang.NewSymbol("try-catch-finally").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(26), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(26), lang.NewKeyword("end-column"), int(23), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")))).(*lang.Symbol) + tmp0 := sym_try_DASH_catch_DASH_finally.WithMeta(lang.NewMap(kw_file, "codegen/test/try_basic.glj", kw_line, int(26), kw_column, int(7), kw_end_DASH_line, int(26), kw_end_DASH_column, int(23), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_try_DASH_basic))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var tmp3 any func() { defer func() { @@ -225,7 +230,7 @@ func LoadNS() { }() return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -233,12 +238,10 @@ func LoadNS() { } // try-finally-only { - tmp0 := lang.NewSymbol("try-finally-only").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(20), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(20), lang.NewKeyword("end-column"), int(22), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")))).(*lang.Symbol) + tmp0 := sym_try_DASH_finally_DASH_only.WithMeta(lang.NewMap(kw_file, "codegen/test/try_basic.glj", kw_line, int(20), kw_column, int(7), kw_end_DASH_line, int(20), kw_end_DASH_column, int(22), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_try_DASH_basic))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var tmp3 any func() { defer func() { @@ -247,7 +250,7 @@ func LoadNS() { }() return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -255,19 +258,17 @@ func LoadNS() { } // try-no-catch { - tmp0 := lang.NewSymbol("try-no-catch").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(16), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(16), lang.NewKeyword("end-column"), int(18), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")))).(*lang.Symbol) + tmp0 := sym_try_DASH_no_DASH_catch.WithMeta(lang.NewMap(kw_file, "codegen/test/try_basic.glj", kw_line, int(16), kw_column, int(7), kw_end_DASH_line, int(16), kw_end_DASH_column, int(18), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_try_DASH_basic))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var tmp3 any func() { tmp3 = "just body" }() return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -275,12 +276,10 @@ func LoadNS() { } // try-with-throw { - tmp0 := lang.NewSymbol("try-with-throw").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/try_basic.glj", lang.NewKeyword("line"), int(9), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(9), lang.NewKeyword("end-column"), int(20), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.try-basic")))).(*lang.Symbol) + tmp0 := sym_try_DASH_with_DASH_throw.WithMeta(lang.NewMap(kw_file, "codegen/test/try_basic.glj", kw_line, int(9), kw_column, int(7), kw_end_DASH_line, int(9), kw_end_DASH_column, int(20), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_try_DASH_basic))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } + checkArity(args, 0) var tmp3 any func() { defer func() { @@ -299,7 +298,7 @@ func LoadNS() { }() return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) diff --git a/pkg/codegen/testdata/codegen/test/values/load.go.out b/pkg/codegen/testdata/codegen/test/values/load.go.out index 51356eac..d62ba9f0 100644 --- a/pkg/codegen/testdata/codegen/test/values/load.go.out +++ b/pkg/codegen/testdata/codegen/test/values/load.go.out @@ -10,21 +10,40 @@ import ( reflect "reflect" ) +func checkDerefVar(v *lang.Var) any { + if v.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) + } + return v.Get() +} +func checkArity(args []any, expected int) { + if len(args) != expected { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + // LoadNS initializes the namespace "codegen.test.values" func LoadNS() { - checkDerefMacro := func(v *lang.Var) { - if v.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) - } - } - _ = checkDerefMacro + sym__DASH_main := lang.NewSymbol("-main") + sym_big_DASH_decimal := lang.NewSymbol("big-decimal") + sym_big_DASH_decimal_DASH_type := lang.NewSymbol("big-decimal-type") + sym_codegen_DOT_test_DOT_values := lang.NewSymbol("codegen.test.values") + kw_arglists := lang.NewKeyword("arglists") + kw_column := lang.NewKeyword("column") + kw_end_DASH_column := lang.NewKeyword("end-column") + kw_end_DASH_line := lang.NewKeyword("end-line") + kw_expected_DASH_output := lang.NewKeyword("expected-output") + kw_file := lang.NewKeyword("file") + kw_line := lang.NewKeyword("line") + kw_ns := lang.NewKeyword("ns") + kw_rettag := lang.NewKeyword("rettag") // var codegen.test.values/big-decimal - codegen_DOT_test_DOT_values_big_decimal := lang.InternVarName(lang.NewSymbol("codegen.test.values"), lang.NewSymbol("big-decimal")) + var_codegen_DOT_test_DOT_values_big_DASH_decimal := lang.InternVarName(sym_codegen_DOT_test_DOT_values, sym_big_DASH_decimal) // var codegen.test.values/big-decimal-type - codegen_DOT_test_DOT_values_big_decimal_type := lang.InternVarName(lang.NewSymbol("codegen.test.values"), lang.NewSymbol("big-decimal-type")) + var_codegen_DOT_test_DOT_values_big_DASH_decimal_DASH_type := lang.InternVarName(sym_codegen_DOT_test_DOT_values, sym_big_DASH_decimal_DASH_type) // reference fmt to avoid unused import error _ = fmt.Printf - ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.values")) + ns := lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_values) _ = ns // -main { @@ -37,25 +56,21 @@ func LoadNS() { return &z })()) tmp2 := reflect.TypeOf((*lang.BigDecimal)(nil)) - tmp0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), lang.NewVector(tmp1, tmp2), lang.NewKeyword("file"), "codegen/test/values.glj", lang.NewKeyword("line"), int(6), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(6), lang.NewKeyword("end-column"), int(56), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.values")))).(*lang.Symbol) + tmp0 := sym__DASH_main.WithMeta(lang.NewMap(kw_expected_DASH_output, lang.NewVector(tmp1, tmp2), kw_file, "codegen/test/values.glj", kw_line, int(6), kw_column, int(7), kw_end_DASH_line, int(6), kw_end_DASH_column, int(56), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_values))).(*lang.Symbol) var tmp4 lang.FnFunc tmp4 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - checkDerefMacro(codegen_DOT_test_DOT_values_big_decimal) - tmp5 := codegen_DOT_test_DOT_values_big_decimal.Get() - checkDerefMacro(codegen_DOT_test_DOT_values_big_decimal_type) - tmp6 := codegen_DOT_test_DOT_values_big_decimal_type.Get() + checkArity(args, 0) + tmp5 := checkDerefVar(var_codegen_DOT_test_DOT_values_big_DASH_decimal) + tmp6 := checkDerefVar(var_codegen_DOT_test_DOT_values_big_DASH_decimal_DASH_type) tmp7 := lang.NewVector(tmp5, tmp6) - tmp8 := lang.NewMap(lang.NewKeyword("file"), "codegen/test/values.glj", lang.NewKeyword("line"), int(7), lang.NewKeyword("column"), int(3), lang.NewKeyword("end-line"), int(7), lang.NewKeyword("end-column"), int(32)) + tmp8 := lang.NewMap(kw_file, "codegen/test/values.glj", kw_line, int(7), kw_column, int(3), kw_end_DASH_line, int(7), kw_end_DASH_column, int(32)) tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) if err != nil { panic(err) } return tmp9 }) - tmp4 = tmp4.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp4 = tmp4.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp3 := ns.InternWithValue(tmp0, tmp4, true) if tmp0.Meta() != nil { tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -63,7 +78,7 @@ func LoadNS() { } // big-decimal { - tmp0 := lang.NewSymbol("big-decimal").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/values.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(16), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.values")))).(*lang.Symbol) + tmp0 := sym_big_DASH_decimal.WithMeta(lang.NewMap(kw_file, "codegen/test/values.glj", kw_line, int(3), kw_column, int(6), kw_end_DASH_line, int(3), kw_end_DASH_column, int(16), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_values))).(*lang.Symbol) tmp2 := lang.NewBigDecimalFromBigFloat((func() *big3.Float { var z big3.Float b, _ := hex2.DecodeString("010a0000004000000004a000000000000000") @@ -79,7 +94,7 @@ func LoadNS() { } // big-decimal-type { - tmp0 := lang.NewSymbol("big-decimal-type").WithMeta(lang.NewMap(lang.NewKeyword("file"), "codegen/test/values.glj", lang.NewKeyword("line"), int(4), lang.NewKeyword("column"), int(6), lang.NewKeyword("end-line"), int(4), lang.NewKeyword("end-column"), int(21), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.values")))).(*lang.Symbol) + tmp0 := sym_big_DASH_decimal_DASH_type.WithMeta(lang.NewMap(kw_file, "codegen/test/values.glj", kw_line, int(4), kw_column, int(6), kw_end_DASH_line, int(4), kw_end_DASH_column, int(21), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_values))).(*lang.Symbol) tmp2 := reflect.TypeOf((*lang.BigDecimal)(nil)) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { diff --git a/pkg/codegen/testdata/codegen/test/with_meta/load.go.out b/pkg/codegen/testdata/codegen/test/with_meta/load.go.out index 2040dd36..4f49387c 100644 --- a/pkg/codegen/testdata/codegen/test/with_meta/load.go.out +++ b/pkg/codegen/testdata/codegen/test/with_meta/load.go.out @@ -1,39 +1,57 @@ // Code generated by glojure codegen. DO NOT EDIT. -package with_meta +package with_DASH_meta import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" ) +func checkDerefVar(v *lang.Var) any { + if v.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) + } + return v.Get() +} +func checkArity(args []any, expected int) { + if len(args) != expected { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + // LoadNS initializes the namespace "codegen.test.with-meta" func LoadNS() { - checkDerefMacro := func(v *lang.Var) { - if v.IsMacro() { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) - } - } - _ = checkDerefMacro + sym__DASH_main := lang.NewSymbol("-main") + sym_codegen_DOT_test_DOT_with_DASH_meta := lang.NewSymbol("codegen.test.with-meta") + sym_glojure_DOT_core := lang.NewSymbol("glojure.core") + sym_meta := lang.NewSymbol("meta") + kw_arglists := lang.NewKeyword("arglists") + kw_bar := lang.NewKeyword("bar") + kw_column := lang.NewKeyword("column") + kw_end_DASH_column := lang.NewKeyword("end-column") + kw_end_DASH_line := lang.NewKeyword("end-line") + kw_expected_DASH_output := lang.NewKeyword("expected-output") + kw_file := lang.NewKeyword("file") + kw_foo := lang.NewKeyword("foo") + kw_line := lang.NewKeyword("line") + kw_ns := lang.NewKeyword("ns") + kw_rettag := lang.NewKeyword("rettag") // var glojure.core/meta - glojure_DOT_core_meta := lang.InternVarName(lang.NewSymbol("glojure.core"), lang.NewSymbol("meta")) + var_glojure_DOT_core_meta := lang.InternVarName(sym_glojure_DOT_core, sym_meta) // reference fmt to avoid unused import error _ = fmt.Printf - ns := lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.with-meta")) + ns := lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_with_DASH_meta) _ = ns // -main { - tmp0 := lang.NewSymbol("-main").WithMeta(lang.NewMap(lang.NewKeyword("expected-output"), lang.NewKeyword("bar"), lang.NewKeyword("file"), "codegen/test/with_meta.glj", lang.NewKeyword("line"), int(3), lang.NewKeyword("column"), int(7), lang.NewKeyword("end-line"), int(3), lang.NewKeyword("end-column"), int(36), lang.NewKeyword("arglists"), lang.NewList(lang.NewVector()), lang.NewKeyword("ns"), lang.FindOrCreateNamespace(lang.NewSymbol("codegen.test.with-meta")))).(*lang.Symbol) + tmp0 := sym__DASH_main.WithMeta(lang.NewMap(kw_expected_DASH_output, kw_bar, kw_file, "codegen/test/with_meta.glj", kw_line, int(3), kw_column, int(7), kw_end_DASH_line, int(3), kw_end_DASH_column, int(36), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_with_DASH_meta))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - if len(args) != 0 { - panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) - } - checkDerefMacro(glojure_DOT_core_meta) - tmp3 := glojure_DOT_core_meta.Get() + checkArity(args, 0) + tmp3 := checkDerefVar(var_glojure_DOT_core_meta) tmp4 := lang.NewVector() - tmp5 := lang.NewMap(lang.NewKeyword("foo"), lang.NewKeyword("bar"), lang.NewKeyword("file"), "codegen/test/with_meta.glj", lang.NewKeyword("line"), int(4), lang.NewKeyword("column"), int(15), lang.NewKeyword("end-line"), int(4), lang.NewKeyword("end-column"), int(28)) - tmp6 := lang.NewMap(lang.NewKeyword("file"), "codegen/test/with_meta.glj", lang.NewKeyword("line"), int(4), lang.NewKeyword("column"), int(16), lang.NewKeyword("end-line"), int(4), lang.NewKeyword("end-column"), int(26)) + tmp5 := lang.NewMap(kw_foo, kw_bar, kw_file, "codegen/test/with_meta.glj", kw_line, int(4), kw_column, int(15), kw_end_DASH_line, int(4), kw_end_DASH_column, int(28)) + tmp6 := lang.NewMap(kw_file, "codegen/test/with_meta.glj", kw_line, int(4), kw_column, int(16), kw_end_DASH_line, int(4), kw_end_DASH_column, int(26)) tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) if err != nil { panic(err) @@ -43,10 +61,10 @@ func LoadNS() { panic(err) } tmp9 := lang.Apply(tmp3, []any{tmp8}) - tmp10 := lang.Apply(lang.NewKeyword("foo"), []any{tmp9}) + tmp10 := lang.Apply(kw_foo, []any{tmp9}) return tmp10 }) - tmp2 = tmp2.WithMeta(lang.NewMap(lang.NewKeyword("rettag"), nil)).(lang.FnFunc) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp1 := ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) From 393167e86780b22dca1decbdc4f70bacf7bed303 Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sat, 30 Aug 2025 21:43:41 -0700 Subject: [PATCH 51/67] Register pre-compiled namespaces with runtime Signed-off-by: James Hamlin --- .gitignore | 4 + pkg/codegen/codegen.go | 14 ++ .../codegen/test/const_keyword/load.go.out | 6 + .../codegen/test/const_number/load.go.out | 6 + .../codegen/test/const_string/load.go.out | 6 + .../testdata/codegen/test/core/load.go.out | 125 +++++++++--------- .../codegen/test/def_simple/load.go.out | 6 + .../codegen/test/fn_closure/load.go.out | 6 + .../codegen/test/fn_recur/load.go.out | 6 + .../codegen/test/loop_simple/load.go.out | 6 + .../codegen/test/maybe_class/load.go.out | 10 +- .../testdata/codegen/test/multifn/load.go.out | 6 + .../testdata/codegen/test/ns_skip/load.go.out | 6 + .../codegen/test/quote_simple/load.go.out | 6 + .../testdata/codegen/test/ref/load.go.out | 6 + .../testdata/codegen/test/the_var/load.go.out | 6 + .../codegen/test/throw_simple/load.go.out | 6 + .../codegen/test/try_advanced/load.go.out | 6 + .../codegen/test/try_basic/load.go.out | 6 + .../testdata/codegen/test/values/load.go.out | 22 +-- .../codegen/test/with_meta/load.go.out | 6 + pkg/gen/gljimports/gljimports_darwin_amd64.go | 4 +- pkg/gen/gljimports/gljimports_darwin_arm64.go | 4 +- pkg/gen/gljimports/gljimports_js_wasm.go | 4 +- pkg/gen/gljimports/gljimports_linux_amd64.go | 4 +- pkg/gen/gljimports/gljimports_linux_arm64.go | 4 +- .../gljimports/gljimports_windows_amd64.go | 4 +- pkg/gen/gljimports/gljimports_windows_arm.go | 4 +- pkg/runtime/envinit.go | 51 +------ pkg/runtime/nsloaders.go | 21 +++ 30 files changed, 239 insertions(+), 132 deletions(-) create mode 100644 pkg/runtime/nsloaders.go diff --git a/.gitignore b/.gitignore index 36f5ee90..da67b1b1 100644 --- a/.gitignore +++ b/.gitignore @@ -1,2 +1,6 @@ bin doc/repl/glj.wasm +.direnv + +# useful to symlink in for context +clojure diff --git a/pkg/codegen/codegen.go b/pkg/codegen/codegen.go index 3e5f9583..a60eb7f9 100644 --- a/pkg/codegen/codegen.go +++ b/pkg/codegen/codegen.go @@ -102,6 +102,7 @@ func (g *Generator) Generate(ns *lang.Namespace) error { // add lang import g.addImport("github.com/glojurelang/glojure/pkg/lang") + g.addImport("github.com/glojurelang/glojure/pkg/runtime") g.addImport("fmt") // for error formatting g.writef("// reference fmt to avoid unused import error\n") g.writef("_ = fmt.Printf\n") @@ -183,18 +184,31 @@ func (g *Generator) Generate(ns *lang.Namespace) error { // Now construct the complete init function var initBuf bytes.Buffer + { + // Reproduce the behavior of root-resource function + rootResourceName := "/" + ns.Name().String() + rootResourceName = strings.ReplaceAll(rootResourceName, "-", "_") + rootResourceName = strings.ReplaceAll(rootResourceName, ".", "/") + initBuf.WriteString(`func init() { +runtime.RegisterNSLoader(` + fmt.Sprintf("%q", rootResourceName) + `, LoadNS) +} + +`) + } initBuf.WriteString(`func checkDerefVar (v *lang.Var) any { if v.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) } return v.Get() } + `) initBuf.WriteString(`func checkArity(args []any, expected int) { if len(args) != expected { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) } } + `) initBuf.WriteString(fmt.Sprintf("// LoadNS initializes the namespace %q\n", ns.Name().String())) initBuf.WriteString("func LoadNS() {\n") diff --git a/pkg/codegen/testdata/codegen/test/const_keyword/load.go.out b/pkg/codegen/testdata/codegen/test/const_keyword/load.go.out index b8a97d12..11e67d8f 100644 --- a/pkg/codegen/testdata/codegen/test/const_keyword/load.go.out +++ b/pkg/codegen/testdata/codegen/test/const_keyword/load.go.out @@ -5,14 +5,20 @@ package const_DASH_keyword import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" + runtime "github.com/glojurelang/glojure/pkg/runtime" ) +func init() { + runtime.RegisterNSLoader("codegen.test.const-keyword", LoadNS) +} + func checkDerefVar(v *lang.Var) any { if v.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) } return v.Get() } + func checkArity(args []any, expected int) { if len(args) != expected { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) diff --git a/pkg/codegen/testdata/codegen/test/const_number/load.go.out b/pkg/codegen/testdata/codegen/test/const_number/load.go.out index 165ffbcb..e4e4a760 100644 --- a/pkg/codegen/testdata/codegen/test/const_number/load.go.out +++ b/pkg/codegen/testdata/codegen/test/const_number/load.go.out @@ -5,14 +5,20 @@ package const_DASH_number import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" + runtime "github.com/glojurelang/glojure/pkg/runtime" ) +func init() { + runtime.RegisterNSLoader("codegen.test.const-number", LoadNS) +} + func checkDerefVar(v *lang.Var) any { if v.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) } return v.Get() } + func checkArity(args []any, expected int) { if len(args) != expected { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) diff --git a/pkg/codegen/testdata/codegen/test/const_string/load.go.out b/pkg/codegen/testdata/codegen/test/const_string/load.go.out index 5dad0fba..e251fc7b 100644 --- a/pkg/codegen/testdata/codegen/test/const_string/load.go.out +++ b/pkg/codegen/testdata/codegen/test/const_string/load.go.out @@ -5,14 +5,20 @@ package const_DASH_string import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" + runtime "github.com/glojurelang/glojure/pkg/runtime" ) +func init() { + runtime.RegisterNSLoader("codegen.test.const-string", LoadNS) +} + func checkDerefVar(v *lang.Var) any { if v.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) } return v.Get() } + func checkArity(args []any, expected int) { if len(args) != expected { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) diff --git a/pkg/codegen/testdata/codegen/test/core/load.go.out b/pkg/codegen/testdata/codegen/test/core/load.go.out index f176d890..acee8149 100644 --- a/pkg/codegen/testdata/codegen/test/core/load.go.out +++ b/pkg/codegen/testdata/codegen/test/core/load.go.out @@ -6,15 +6,15 @@ import ( errors8 "errors" fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" - runtime7 "github.com/glojurelang/glojure/pkg/runtime" + runtime "github.com/glojurelang/glojure/pkg/runtime" uuid13 "github.com/google/uuid" - io3 "io" - math6 "math" + io4 "io" + math7 "math" big9 "math/big" rand16 "math/rand" http17 "net/http" - url4 "net/url" - os5 "os" + url5 "net/url" + os6 "os" reflect "reflect" regexp15 "regexp" runtime14 "runtime" @@ -23,12 +23,17 @@ import ( time10 "time" ) +func init() { + runtime.RegisterNSLoader("glojure.core", LoadNS) +} + func checkDerefVar(v *lang.Var) any { if v.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) } return v.Get() } + func checkArity(args []any, expected int) { if len(args) != expected { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -2830,7 +2835,7 @@ func LoadNS() { var tmp3 any { // let // let binding "vec__307" - tmp4 := lang.Apply(url4.ParseRequestURI, []any{v1}) + tmp4 := lang.Apply(url5.ParseRequestURI, []any{v1}) var v5 any = tmp4 _ = v5 // let binding "url" @@ -2849,7 +2854,7 @@ func LoadNS() { var tmp14 any { // let // let binding "res__0__auto__" - tmp15 := lang.Apply(os5.Open, []any{v1}) + tmp15 := lang.Apply(os6.Open, []any{v1}) var v16 any = tmp15 _ = v16 // let binding "vec__310" @@ -3038,7 +3043,7 @@ func LoadNS() { var tmp6 any { // let // let binding "res__0__auto__" - tmp7 := lang.Apply(os5.Open, []any{v1}) + tmp7 := lang.Apply(os6.Open, []any{v1}) tmp8 := lang.Apply(tmp7, nil) var v9 any = tmp8 _ = v9 @@ -3133,7 +3138,7 @@ func LoadNS() { var tmp5 any { // let // let binding "res__0__auto__" - tmp6 := lang.Apply(url4.Parse, []any{v1}) + tmp6 := lang.Apply(url5.Parse, []any{v1}) tmp7 := lang.Apply(tmp6, nil) var v8 any = tmp7 _ = v8 @@ -5406,7 +5411,7 @@ func LoadNS() { } }) tmp32 := lang.NewMultiFn("make-reader", tmp33, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) - tmp34 := reflect.TypeOf((*io3.Reader)(nil)).Elem() + tmp34 := reflect.TypeOf((*io4.Reader)(nil)).Elem() var tmp35 lang.FnFunc tmp35 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -5424,7 +5429,7 @@ func LoadNS() { } }) tmp32.AddMethod(tmp34, tmp35) - tmp36 := reflect.TypeOf((*url4.URL)(nil)) + tmp36 := reflect.TypeOf((*url5.URL)(nil)) var tmp37 lang.FnFunc tmp37 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -5475,7 +5480,7 @@ func LoadNS() { } }) tmp40 := lang.NewMultiFn("make-writer", tmp41, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) - tmp42 := reflect.TypeOf((*io3.Reader)(nil)).Elem() + tmp42 := reflect.TypeOf((*io4.Reader)(nil)).Elem() var tmp43 lang.FnFunc tmp43 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -5493,7 +5498,7 @@ func LoadNS() { } }) tmp40.AddMethod(tmp42, tmp43) - tmp44 := reflect.TypeOf((*url4.URL)(nil)) + tmp44 := reflect.TypeOf((*url5.URL)(nil)) var tmp45 lang.FnFunc tmp45 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -5544,7 +5549,7 @@ func LoadNS() { } }) tmp48 := lang.NewMultiFn("make-input-stream", tmp49, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) - tmp50 := reflect.TypeOf((*io3.Reader)(nil)).Elem() + tmp50 := reflect.TypeOf((*io4.Reader)(nil)).Elem() var tmp51 lang.FnFunc tmp51 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -5562,7 +5567,7 @@ func LoadNS() { } }) tmp48.AddMethod(tmp50, tmp51) - tmp52 := reflect.TypeOf((*os5.File)(nil)) + tmp52 := reflect.TypeOf((*os6.File)(nil)) var tmp53 lang.FnFunc tmp53 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -5580,7 +5585,7 @@ func LoadNS() { } }) tmp48.AddMethod(tmp52, tmp53) - tmp54 := reflect.TypeOf((*url4.URL)(nil)) + tmp54 := reflect.TypeOf((*url5.URL)(nil)) var tmp55 lang.FnFunc tmp55 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -5631,7 +5636,7 @@ func LoadNS() { } }) tmp58 := lang.NewMultiFn("make-output-stream", tmp59, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) - tmp60 := reflect.TypeOf((*io3.Reader)(nil)).Elem() + tmp60 := reflect.TypeOf((*io4.Reader)(nil)).Elem() var tmp61 lang.FnFunc tmp61 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -5649,7 +5654,7 @@ func LoadNS() { } }) tmp58.AddMethod(tmp60, tmp61) - tmp62 := reflect.TypeOf((*os5.File)(nil)) + tmp62 := reflect.TypeOf((*os6.File)(nil)) var tmp63 lang.FnFunc tmp63 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -5667,7 +5672,7 @@ func LoadNS() { } }) tmp58.AddMethod(tmp62, tmp63) - tmp64 := reflect.TypeOf((*url4.URL)(nil)) + tmp64 := reflect.TypeOf((*url5.URL)(nil)) var tmp65 lang.FnFunc tmp65 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -6670,7 +6675,7 @@ func LoadNS() { checkArity(args, 1) v4 := args[0] _ = v4 - tmp5 := lang.Apply(math6.IsNaN, []any{v4}) + tmp5 := lang.Apply(math7.IsNaN, []any{v4}) return tmp5 }) tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -7187,7 +7192,7 @@ func LoadNS() { checkArity(args, 1) v4 := args[0] _ = v4 - tmp5, _ := lang.FieldOrMethod(runtime7.RT, "Aclone") + tmp5, _ := lang.FieldOrMethod(runtime.RT, "Aclone") if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Aclone is not a function"))) } @@ -7559,7 +7564,7 @@ func LoadNS() { checkArity(args, 1) v4 := args[0] _ = v4 - tmp5, _ := lang.FieldOrMethod(runtime7.RT, "Alength") + tmp5, _ := lang.FieldOrMethod(runtime.RT, "Alength") if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Alength is not a function"))) } @@ -11725,7 +11730,7 @@ func LoadNS() { checkArity(args, 1) v4 := args[0] _ = v4 - tmp5, _ := lang.FieldOrMethod(runtime7.RT, "BooleanCast") + tmp5, _ := lang.FieldOrMethod(runtime.RT, "BooleanCast") if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("BooleanCast is not a function"))) } @@ -12581,7 +12586,7 @@ func LoadNS() { var tmp108 any if lang.IsTruthy(v107) { tmp109 := checkDerefVar(var_glojure_DOT_core__LT__EQ_) - tmp110 := lang.Apply(tmp109, []any{math6.MinInt, v103, math6.MaxInt}) + tmp110 := lang.Apply(tmp109, []any{math7.MinInt, v103, math7.MaxInt}) tmp108 = tmp110 } else { tmp108 = v107 @@ -13048,7 +13053,7 @@ func LoadNS() { checkArity(args, 1) v4 := args[0] _ = v4 - tmp5, _ := lang.FieldOrMethod(runtime7.RT, "CharCast") + tmp5, _ := lang.FieldOrMethod(runtime.RT, "CharCast") if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("CharCast is not a function"))) } @@ -14980,7 +14985,7 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(runtime7.RT, "Contains") + tmp5, _ := lang.FieldOrMethod(runtime.RT, "Contains") if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Contains is not a function"))) } @@ -18645,7 +18650,7 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(runtime7.RT, "Dissoc") + tmp5, _ := lang.FieldOrMethod(runtime.RT, "Dissoc") if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Dissoc is not a function"))) } @@ -21394,7 +21399,7 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(runtime7.Compiler, "Eval") + tmp4, _ := lang.FieldOrMethod(runtime.Compiler, "Eval") if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Eval is not a function"))) } @@ -23338,7 +23343,7 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(runtime7.RT, "Find") + tmp5, _ := lang.FieldOrMethod(runtime.RT, "Find") if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Find is not a function"))) } @@ -23431,7 +23436,7 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(runtime7.RT, "FindVar") + tmp4, _ := lang.FieldOrMethod(runtime.RT, "FindVar") if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("FindVar is not a function"))) } @@ -24129,7 +24134,7 @@ func LoadNS() { v3 := args[0] _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp5 := reflect.TypeOf((*runtime7.Fn)(nil)) + tmp5 := reflect.TypeOf((*runtime.Fn)(nil)) tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) return tmp6 }) @@ -25964,7 +25969,7 @@ func LoadNS() { _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_str) tmp5 := checkDerefVar(var_glojure_DOT_core_str) - tmp6, _ := lang.FieldOrMethod(runtime7.RT, "NextID") + tmp6, _ := lang.FieldOrMethod(runtime.RT, "NextID") if reflect.TypeOf(tmp6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("NextID is not a function"))) } @@ -27466,7 +27471,7 @@ func LoadNS() { checkArity(args, 1) v4 := args[0] _ = v4 - tmp5, _ := lang.FieldOrMethod(runtime7.RT, "IntCast") + tmp5, _ := lang.FieldOrMethod(runtime.RT, "IntCast") if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("IntCast is not a function"))) } @@ -30540,7 +30545,7 @@ func LoadNS() { _ = tmp54 }() tmp55 := lang.Apply(strings11.TrimPrefix, []any{v28, "/"}) - tmp56, _ := lang.FieldOrMethod(runtime7.RT, "Load") + tmp56, _ := lang.FieldOrMethod(runtime.RT, "Load") if reflect.TypeOf(tmp56).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Load is not a function"))) } @@ -30681,7 +30686,7 @@ func LoadNS() { _ = tmp66 }() tmp67 := lang.Apply(strings11.TrimPrefix, []any{v40, "/"}) - tmp68, _ := lang.FieldOrMethod(runtime7.RT, "Load") + tmp68, _ := lang.FieldOrMethod(runtime.RT, "Load") if reflect.TypeOf(tmp68).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Load is not a function"))) } @@ -32302,7 +32307,7 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(runtime7.Compiler, "load") + tmp4, _ := lang.FieldOrMethod(runtime.Compiler, "load") if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("load is not a function"))) } @@ -32902,7 +32907,7 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(runtime7.Compiler, "macroexpand1") + tmp4, _ := lang.FieldOrMethod(runtime.Compiler, "macroexpand1") if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("macroexpand1 is not a function"))) } @@ -37393,7 +37398,7 @@ func LoadNS() { } else { tmp9 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) tmp10 := lang.Apply(tmp9, []any{v3}) - tmp11, _ := lang.FieldOrMethod(runtime7.Compiler, "maybeResolveIn") + tmp11, _ := lang.FieldOrMethod(runtime.Compiler, "maybeResolveIn") if reflect.TypeOf(tmp11).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("maybeResolveIn is not a function"))) } @@ -37538,7 +37543,7 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6, _ := lang.FieldOrMethod(runtime7.RT, "Nth") + tmp6, _ := lang.FieldOrMethod(runtime.RT, "Nth") if reflect.TypeOf(tmp6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Nth is not a function"))) } @@ -37551,7 +37556,7 @@ func LoadNS() { _ = v5 v6 := args[2] _ = v6 - tmp7, _ := lang.FieldOrMethod(runtime7.RT, "NthDefault") + tmp7, _ := lang.FieldOrMethod(runtime.RT, "NthDefault") if reflect.TypeOf(tmp7).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("NthDefault is not a function"))) } @@ -37914,7 +37919,7 @@ func LoadNS() { checkArity(args, 1) v4 := args[0] _ = v4 - tmp5, _ := lang.FieldOrMethod(runtime7.RT, "Object_array") + tmp5, _ := lang.FieldOrMethod(runtime.RT, "Object_array") if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Object_array is not a function"))) } @@ -39594,7 +39599,7 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(runtime7.RT, "Peek") + tmp4, _ := lang.FieldOrMethod(runtime.RT, "Peek") if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Peek is not a function"))) } @@ -39876,7 +39881,7 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(runtime7.RT, "Pop") + tmp4, _ := lang.FieldOrMethod(runtime.RT, "Pop") if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Pop is not a function"))) } @@ -41172,7 +41177,7 @@ func LoadNS() { return tmp48 }) tmp2.AddMethod(tmp43, tmp44) - tmp45 := reflect.TypeOf((*runtime7.Fn)(nil)) + tmp45 := reflect.TypeOf((*runtime.Fn)(nil)) var tmp46 lang.FnFunc tmp46 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 2) @@ -41213,7 +41218,7 @@ func LoadNS() { }) tmp2.AddMethod(tmp47, tmp48) tmp49 := reflect.TypeOf((*lang.IPersistentCollection)(nil)).Elem() - tmp50 := reflect.TypeOf((*runtime7.Fn)(nil)) + tmp50 := reflect.TypeOf((*runtime.Fn)(nil)) tmp2.PreferMethod(tmp49, tmp50) tmp51 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() tmp52 := reflect.TypeOf((*lang.IPersistentCollection)(nil)).Elem() @@ -41592,7 +41597,7 @@ func LoadNS() { _ = v21 var tmp22 any tmp23 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp24 := lang.Apply(math6.Inf, []any{int64(1)}) + tmp24 := lang.Apply(math7.Inf, []any{int64(1)}) tmp25 := lang.Apply(tmp23, []any{tmp24, v20}) if lang.IsTruthy(tmp25) { tmp26 := lang.Apply(lang.WriteWriter, []any{v21, "##Inf"}) @@ -41600,14 +41605,14 @@ func LoadNS() { } else { var tmp27 any tmp28 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp29 := lang.Apply(math6.Inf, []any{int64(-1)}) + tmp29 := lang.Apply(math7.Inf, []any{int64(-1)}) tmp30 := lang.Apply(tmp28, []any{tmp29, v20}) if lang.IsTruthy(tmp30) { tmp31 := lang.Apply(lang.WriteWriter, []any{v21, "##-Inf"}) tmp27 = tmp31 } else { var tmp32 any - tmp33 := lang.Apply(math6.IsNaN, []any{v20}) + tmp33 := lang.Apply(math7.IsNaN, []any{v20}) if lang.IsTruthy(tmp33) { tmp34 := lang.Apply(lang.WriteWriter, []any{v21, "##NaN"}) tmp32 = tmp34 @@ -42188,7 +42193,7 @@ func LoadNS() { _ = v49 var tmp50 any tmp51 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp52 := lang.Apply(math6.Inf, []any{int64(1)}) + tmp52 := lang.Apply(math7.Inf, []any{int64(1)}) tmp53 := lang.Apply(lang.Builtins["float32"], []any{tmp52}) tmp54 := lang.Apply(tmp51, []any{tmp53, v48}) if lang.IsTruthy(tmp54) { @@ -42197,7 +42202,7 @@ func LoadNS() { } else { var tmp56 any tmp57 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp58 := lang.Apply(math6.Inf, []any{int64(-1)}) + tmp58 := lang.Apply(math7.Inf, []any{int64(-1)}) tmp59 := lang.Apply(lang.Builtins["float32"], []any{tmp58}) tmp60 := lang.Apply(tmp57, []any{tmp59, v48}) if lang.IsTruthy(tmp60) { @@ -42205,7 +42210,7 @@ func LoadNS() { tmp56 = tmp61 } else { var tmp62 any - tmp63 := lang.Apply(math6.IsNaN, []any{v48}) + tmp63 := lang.Apply(math7.IsNaN, []any{v48}) if lang.IsTruthy(tmp63) { tmp64 := lang.Apply(lang.WriteWriter, []any{v49, "##NaN"}) tmp62 = tmp64 @@ -45078,14 +45083,14 @@ func LoadNS() { case 1: v3 := args[0] _ = v3 - tmp4 := lang.Apply(runtime7.RTReadString, []any{v3}) + tmp4 := lang.Apply(runtime.RTReadString, []any{v3}) return tmp4 case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - tmp5 := lang.Apply(runtime7.RTReadString, []any{v4, v3}) + tmp5 := lang.Apply(runtime.RTReadString, []any{v4, v3}) return tmp5 default: checkArity(args, -1) @@ -47389,7 +47394,7 @@ func LoadNS() { // let binding "entry" tmp15 := checkDerefVar(var_glojure_DOT_core_first) tmp16 := lang.Apply(tmp15, []any{v12}) - tmp17, _ := lang.FieldOrMethod(runtime7.RT, "Find") + tmp17, _ := lang.FieldOrMethod(runtime.RT, "Find") if reflect.TypeOf(tmp17).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Find is not a function"))) } @@ -50447,9 +50452,9 @@ func LoadNS() { v3 := args[0] _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) - tmp5, ok := lang.FieldOrMethod(runtime7.Compiler, "specials") + tmp5, ok := lang.FieldOrMethod(runtime.Compiler, "specials") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", runtime7.Compiler, "specials"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", runtime.Compiler, "specials"))) } var tmp6 any switch reflect.TypeOf(tmp5).Kind() { @@ -51275,7 +51280,7 @@ func LoadNS() { _ = v4 v5 := args[2] _ = v5 - tmp6, _ := lang.FieldOrMethod(runtime7.RT, "Subvec") + tmp6, _ := lang.FieldOrMethod(runtime.RT, "Subvec") if reflect.TypeOf(tmp6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Subvec is not a function"))) } @@ -52503,7 +52508,7 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(runtime7.RT, "ToArray") + tmp4, _ := lang.FieldOrMethod(runtime.RT, "ToArray") if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("ToArray is not a function"))) } @@ -53054,7 +53059,7 @@ func LoadNS() { checkArity(args, 1) v4 := args[0] _ = v4 - tmp5, _ := lang.FieldOrMethod(runtime7.RT, "UncheckedCharCast") + tmp5, _ := lang.FieldOrMethod(runtime.RT, "UncheckedCharCast") if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedCharCast is not a function"))) } @@ -54525,7 +54530,7 @@ func LoadNS() { v3 := args[0] _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp5 := reflect.TypeOf((*url4.URL)(nil)).Elem() + tmp5 := reflect.TypeOf((*url5.URL)(nil)).Elem() tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) return tmp6 }) diff --git a/pkg/codegen/testdata/codegen/test/def_simple/load.go.out b/pkg/codegen/testdata/codegen/test/def_simple/load.go.out index dd97932d..2fa585b6 100644 --- a/pkg/codegen/testdata/codegen/test/def_simple/load.go.out +++ b/pkg/codegen/testdata/codegen/test/def_simple/load.go.out @@ -5,14 +5,20 @@ package def_DASH_simple import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" + runtime "github.com/glojurelang/glojure/pkg/runtime" ) +func init() { + runtime.RegisterNSLoader("codegen.test.def-simple", LoadNS) +} + func checkDerefVar(v *lang.Var) any { if v.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) } return v.Get() } + func checkArity(args []any, expected int) { if len(args) != expected { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) diff --git a/pkg/codegen/testdata/codegen/test/fn_closure/load.go.out b/pkg/codegen/testdata/codegen/test/fn_closure/load.go.out index 0150efbd..ce8d7148 100644 --- a/pkg/codegen/testdata/codegen/test/fn_closure/load.go.out +++ b/pkg/codegen/testdata/codegen/test/fn_closure/load.go.out @@ -5,14 +5,20 @@ package fn_DASH_closure import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" + runtime "github.com/glojurelang/glojure/pkg/runtime" ) +func init() { + runtime.RegisterNSLoader("codegen.test.fn-closure", LoadNS) +} + func checkDerefVar(v *lang.Var) any { if v.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) } return v.Get() } + func checkArity(args []any, expected int) { if len(args) != expected { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) diff --git a/pkg/codegen/testdata/codegen/test/fn_recur/load.go.out b/pkg/codegen/testdata/codegen/test/fn_recur/load.go.out index b845d107..a0645e30 100644 --- a/pkg/codegen/testdata/codegen/test/fn_recur/load.go.out +++ b/pkg/codegen/testdata/codegen/test/fn_recur/load.go.out @@ -5,14 +5,20 @@ package fn_DASH_recur import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" + runtime "github.com/glojurelang/glojure/pkg/runtime" ) +func init() { + runtime.RegisterNSLoader("codegen.test.fn-recur", LoadNS) +} + func checkDerefVar(v *lang.Var) any { if v.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) } return v.Get() } + func checkArity(args []any, expected int) { if len(args) != expected { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) diff --git a/pkg/codegen/testdata/codegen/test/loop_simple/load.go.out b/pkg/codegen/testdata/codegen/test/loop_simple/load.go.out index f7394aff..1c9eb548 100644 --- a/pkg/codegen/testdata/codegen/test/loop_simple/load.go.out +++ b/pkg/codegen/testdata/codegen/test/loop_simple/load.go.out @@ -5,14 +5,20 @@ package loop_DASH_simple import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" + runtime "github.com/glojurelang/glojure/pkg/runtime" ) +func init() { + runtime.RegisterNSLoader("codegen.test.loop-simple", LoadNS) +} + func checkDerefVar(v *lang.Var) any { if v.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) } return v.Get() } + func checkArity(args []any, expected int) { if len(args) != expected { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) diff --git a/pkg/codegen/testdata/codegen/test/maybe_class/load.go.out b/pkg/codegen/testdata/codegen/test/maybe_class/load.go.out index abe91fed..5dd79382 100644 --- a/pkg/codegen/testdata/codegen/test/maybe_class/load.go.out +++ b/pkg/codegen/testdata/codegen/test/maybe_class/load.go.out @@ -5,15 +5,21 @@ package maybe_DASH_class import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" - strings2 "strings" + runtime "github.com/glojurelang/glojure/pkg/runtime" + strings3 "strings" ) +func init() { + runtime.RegisterNSLoader("codegen.test.maybe-class", LoadNS) +} + func checkDerefVar(v *lang.Var) any { if v.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) } return v.Get() } + func checkArity(args []any, expected int) { if len(args) != expected { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -48,7 +54,7 @@ func LoadNS() { tmp2 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 0) tmp3 := checkDerefVar(var_glojure_DOT_core_vec) - tmp4 := lang.Apply(strings2.Split, []any{"1,2,3", ","}) + tmp4 := lang.Apply(strings3.Split, []any{"1,2,3", ","}) tmp5 := lang.Apply(tmp3, []any{tmp4}) return tmp5 }) diff --git a/pkg/codegen/testdata/codegen/test/multifn/load.go.out b/pkg/codegen/testdata/codegen/test/multifn/load.go.out index 1d5ff0bb..814d7f57 100644 --- a/pkg/codegen/testdata/codegen/test/multifn/load.go.out +++ b/pkg/codegen/testdata/codegen/test/multifn/load.go.out @@ -5,15 +5,21 @@ package multifn import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" + runtime "github.com/glojurelang/glojure/pkg/runtime" reflect "reflect" ) +func init() { + runtime.RegisterNSLoader("codegen.test.multifn", LoadNS) +} + func checkDerefVar(v *lang.Var) any { if v.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) } return v.Get() } + func checkArity(args []any, expected int) { if len(args) != expected { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) diff --git a/pkg/codegen/testdata/codegen/test/ns_skip/load.go.out b/pkg/codegen/testdata/codegen/test/ns_skip/load.go.out index 2fda3a38..fa21ce77 100644 --- a/pkg/codegen/testdata/codegen/test/ns_skip/load.go.out +++ b/pkg/codegen/testdata/codegen/test/ns_skip/load.go.out @@ -5,14 +5,20 @@ package ns_DASH_skip import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" + runtime "github.com/glojurelang/glojure/pkg/runtime" ) +func init() { + runtime.RegisterNSLoader("codegen.test.ns-skip", LoadNS) +} + func checkDerefVar(v *lang.Var) any { if v.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) } return v.Get() } + func checkArity(args []any, expected int) { if len(args) != expected { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) diff --git a/pkg/codegen/testdata/codegen/test/quote_simple/load.go.out b/pkg/codegen/testdata/codegen/test/quote_simple/load.go.out index 3d610c7b..7fb7baa7 100644 --- a/pkg/codegen/testdata/codegen/test/quote_simple/load.go.out +++ b/pkg/codegen/testdata/codegen/test/quote_simple/load.go.out @@ -5,14 +5,20 @@ package quote_DASH_simple import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" + runtime "github.com/glojurelang/glojure/pkg/runtime" ) +func init() { + runtime.RegisterNSLoader("codegen.test.quote-simple", LoadNS) +} + func checkDerefVar(v *lang.Var) any { if v.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) } return v.Get() } + func checkArity(args []any, expected int) { if len(args) != expected { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) diff --git a/pkg/codegen/testdata/codegen/test/ref/load.go.out b/pkg/codegen/testdata/codegen/test/ref/load.go.out index 983a4abf..d7cae9f4 100644 --- a/pkg/codegen/testdata/codegen/test/ref/load.go.out +++ b/pkg/codegen/testdata/codegen/test/ref/load.go.out @@ -5,14 +5,20 @@ package ref import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" + runtime "github.com/glojurelang/glojure/pkg/runtime" ) +func init() { + runtime.RegisterNSLoader("codegen.test.ref", LoadNS) +} + func checkDerefVar(v *lang.Var) any { if v.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) } return v.Get() } + func checkArity(args []any, expected int) { if len(args) != expected { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) diff --git a/pkg/codegen/testdata/codegen/test/the_var/load.go.out b/pkg/codegen/testdata/codegen/test/the_var/load.go.out index bc31440b..260b5d56 100644 --- a/pkg/codegen/testdata/codegen/test/the_var/load.go.out +++ b/pkg/codegen/testdata/codegen/test/the_var/load.go.out @@ -5,15 +5,21 @@ package the_DASH_var import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" + runtime "github.com/glojurelang/glojure/pkg/runtime" reflect "reflect" ) +func init() { + runtime.RegisterNSLoader("codegen.test.the-var", LoadNS) +} + func checkDerefVar(v *lang.Var) any { if v.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) } return v.Get() } + func checkArity(args []any, expected int) { if len(args) != expected { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) diff --git a/pkg/codegen/testdata/codegen/test/throw_simple/load.go.out b/pkg/codegen/testdata/codegen/test/throw_simple/load.go.out index 9e5169c5..49aad441 100644 --- a/pkg/codegen/testdata/codegen/test/throw_simple/load.go.out +++ b/pkg/codegen/testdata/codegen/test/throw_simple/load.go.out @@ -5,14 +5,20 @@ package throw_DASH_simple import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" + runtime "github.com/glojurelang/glojure/pkg/runtime" ) +func init() { + runtime.RegisterNSLoader("codegen.test.throw-simple", LoadNS) +} + func checkDerefVar(v *lang.Var) any { if v.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) } return v.Get() } + func checkArity(args []any, expected int) { if len(args) != expected { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) diff --git a/pkg/codegen/testdata/codegen/test/try_advanced/load.go.out b/pkg/codegen/testdata/codegen/test/try_advanced/load.go.out index 150fa3eb..cd0f9153 100644 --- a/pkg/codegen/testdata/codegen/test/try_advanced/load.go.out +++ b/pkg/codegen/testdata/codegen/test/try_advanced/load.go.out @@ -5,14 +5,20 @@ package try_DASH_advanced import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" + runtime "github.com/glojurelang/glojure/pkg/runtime" ) +func init() { + runtime.RegisterNSLoader("codegen.test.try-advanced", LoadNS) +} + func checkDerefVar(v *lang.Var) any { if v.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) } return v.Get() } + func checkArity(args []any, expected int) { if len(args) != expected { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) diff --git a/pkg/codegen/testdata/codegen/test/try_basic/load.go.out b/pkg/codegen/testdata/codegen/test/try_basic/load.go.out index f4b35a98..90f3c141 100644 --- a/pkg/codegen/testdata/codegen/test/try_basic/load.go.out +++ b/pkg/codegen/testdata/codegen/test/try_basic/load.go.out @@ -5,14 +5,20 @@ package try_DASH_basic import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" + runtime "github.com/glojurelang/glojure/pkg/runtime" ) +func init() { + runtime.RegisterNSLoader("codegen.test.try-basic", LoadNS) +} + func checkDerefVar(v *lang.Var) any { if v.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) } return v.Get() } + func checkArity(args []any, expected int) { if len(args) != expected { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) diff --git a/pkg/codegen/testdata/codegen/test/values/load.go.out b/pkg/codegen/testdata/codegen/test/values/load.go.out index d62ba9f0..fdc1acff 100644 --- a/pkg/codegen/testdata/codegen/test/values/load.go.out +++ b/pkg/codegen/testdata/codegen/test/values/load.go.out @@ -3,19 +3,25 @@ package values import ( - hex2 "encoding/hex" + hex3 "encoding/hex" fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" - big3 "math/big" + runtime "github.com/glojurelang/glojure/pkg/runtime" + big4 "math/big" reflect "reflect" ) +func init() { + runtime.RegisterNSLoader("codegen.test.values", LoadNS) +} + func checkDerefVar(v *lang.Var) any { if v.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) } return v.Get() } + func checkArity(args []any, expected int) { if len(args) != expected { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) @@ -47,9 +53,9 @@ func LoadNS() { _ = ns // -main { - tmp1 := lang.NewBigDecimalFromBigFloat((func() *big3.Float { - var z big3.Float - b, _ := hex2.DecodeString("010a0000004000000004a000000000000000") + tmp1 := lang.NewBigDecimalFromBigFloat((func() *big4.Float { + var z big4.Float + b, _ := hex3.DecodeString("010a0000004000000004a000000000000000") if err := z.GobDecode(b); err != nil { panic(err) } @@ -79,9 +85,9 @@ func LoadNS() { // big-decimal { tmp0 := sym_big_DASH_decimal.WithMeta(lang.NewMap(kw_file, "codegen/test/values.glj", kw_line, int(3), kw_column, int(6), kw_end_DASH_line, int(3), kw_end_DASH_column, int(16), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_values))).(*lang.Symbol) - tmp2 := lang.NewBigDecimalFromBigFloat((func() *big3.Float { - var z big3.Float - b, _ := hex2.DecodeString("010a0000004000000004a000000000000000") + tmp2 := lang.NewBigDecimalFromBigFloat((func() *big4.Float { + var z big4.Float + b, _ := hex3.DecodeString("010a0000004000000004a000000000000000") if err := z.GobDecode(b); err != nil { panic(err) } diff --git a/pkg/codegen/testdata/codegen/test/with_meta/load.go.out b/pkg/codegen/testdata/codegen/test/with_meta/load.go.out index 4f49387c..09deacdc 100644 --- a/pkg/codegen/testdata/codegen/test/with_meta/load.go.out +++ b/pkg/codegen/testdata/codegen/test/with_meta/load.go.out @@ -5,14 +5,20 @@ package with_DASH_meta import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" + runtime "github.com/glojurelang/glojure/pkg/runtime" ) +func init() { + runtime.RegisterNSLoader("codegen.test.with-meta", LoadNS) +} + func checkDerefVar(v *lang.Var) any { if v.IsMacro() { panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) } return v.Get() } + func checkArity(args []any, expected int) { if len(args) != expected { panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) diff --git a/pkg/gen/gljimports/gljimports_darwin_amd64.go b/pkg/gen/gljimports/gljimports_darwin_amd64.go index 028fed4b..0822164e 100644 --- a/pkg/gen/gljimports/gljimports_darwin_amd64.go +++ b/pkg/gen/gljimports/gljimports_darwin_amd64.go @@ -3977,10 +3977,9 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/runtime.EvalOption", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.EvalOption)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.Fn", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Fn)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.*Fn", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Fn)(nil))) + _register("github.com/glojurelang/glojure/pkg/runtime.GetNSLoader", github_com_glojurelang_glojure_pkg_runtime.GetNSLoader) _register("github.com/glojurelang/glojure/pkg/runtime.NewEnvironment", github_com_glojurelang_glojure_pkg_runtime.NewEnvironment) _register("github.com/glojurelang/glojure/pkg/runtime.NewFn", github_com_glojurelang_glojure_pkg_runtime.NewFn) - _register("github.com/glojurelang/glojure/pkg/runtime.Program", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Program)(nil)).Elem()) - _register("github.com/glojurelang/glojure/pkg/runtime.*Program", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Program)(nil))) _register("github.com/glojurelang/glojure/pkg/runtime.RT", github_com_glojurelang_glojure_pkg_runtime.RT) _register("github.com/glojurelang/glojure/pkg/runtime.RTEvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTEvalError)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.*RTEvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTEvalError)(nil))) @@ -3989,6 +3988,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/runtime.RTReadString", github_com_glojurelang_glojure_pkg_runtime.RTReadString) _register("github.com/glojurelang/glojure/pkg/runtime.ReadEval", github_com_glojurelang_glojure_pkg_runtime.ReadEval) _register("github.com/glojurelang/glojure/pkg/runtime.ReadEvalOption", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.ReadEvalOption)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/runtime.RegisterNSLoader", github_com_glojurelang_glojure_pkg_runtime.RegisterNSLoader) _register("github.com/glojurelang/glojure/pkg/runtime.SymInNS", github_com_glojurelang_glojure_pkg_runtime.SymInNS) _register("github.com/glojurelang/glojure/pkg/runtime.SymNS", github_com_glojurelang_glojure_pkg_runtime.SymNS) _register("github.com/glojurelang/glojure/pkg/runtime.SymbolDot", github_com_glojurelang_glojure_pkg_runtime.SymbolDot) diff --git a/pkg/gen/gljimports/gljimports_darwin_arm64.go b/pkg/gen/gljimports/gljimports_darwin_arm64.go index 0d4dbe5e..59844132 100644 --- a/pkg/gen/gljimports/gljimports_darwin_arm64.go +++ b/pkg/gen/gljimports/gljimports_darwin_arm64.go @@ -3977,10 +3977,9 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/runtime.EvalOption", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.EvalOption)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.Fn", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Fn)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.*Fn", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Fn)(nil))) + _register("github.com/glojurelang/glojure/pkg/runtime.GetNSLoader", github_com_glojurelang_glojure_pkg_runtime.GetNSLoader) _register("github.com/glojurelang/glojure/pkg/runtime.NewEnvironment", github_com_glojurelang_glojure_pkg_runtime.NewEnvironment) _register("github.com/glojurelang/glojure/pkg/runtime.NewFn", github_com_glojurelang_glojure_pkg_runtime.NewFn) - _register("github.com/glojurelang/glojure/pkg/runtime.Program", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Program)(nil)).Elem()) - _register("github.com/glojurelang/glojure/pkg/runtime.*Program", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Program)(nil))) _register("github.com/glojurelang/glojure/pkg/runtime.RT", github_com_glojurelang_glojure_pkg_runtime.RT) _register("github.com/glojurelang/glojure/pkg/runtime.RTEvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTEvalError)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.*RTEvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTEvalError)(nil))) @@ -3989,6 +3988,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/runtime.RTReadString", github_com_glojurelang_glojure_pkg_runtime.RTReadString) _register("github.com/glojurelang/glojure/pkg/runtime.ReadEval", github_com_glojurelang_glojure_pkg_runtime.ReadEval) _register("github.com/glojurelang/glojure/pkg/runtime.ReadEvalOption", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.ReadEvalOption)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/runtime.RegisterNSLoader", github_com_glojurelang_glojure_pkg_runtime.RegisterNSLoader) _register("github.com/glojurelang/glojure/pkg/runtime.SymInNS", github_com_glojurelang_glojure_pkg_runtime.SymInNS) _register("github.com/glojurelang/glojure/pkg/runtime.SymNS", github_com_glojurelang_glojure_pkg_runtime.SymNS) _register("github.com/glojurelang/glojure/pkg/runtime.SymbolDot", github_com_glojurelang_glojure_pkg_runtime.SymbolDot) diff --git a/pkg/gen/gljimports/gljimports_js_wasm.go b/pkg/gen/gljimports/gljimports_js_wasm.go index 93c25a71..c27666e5 100644 --- a/pkg/gen/gljimports/gljimports_js_wasm.go +++ b/pkg/gen/gljimports/gljimports_js_wasm.go @@ -3977,10 +3977,9 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/runtime.EvalOption", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.EvalOption)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.Fn", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Fn)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.*Fn", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Fn)(nil))) + _register("github.com/glojurelang/glojure/pkg/runtime.GetNSLoader", github_com_glojurelang_glojure_pkg_runtime.GetNSLoader) _register("github.com/glojurelang/glojure/pkg/runtime.NewEnvironment", github_com_glojurelang_glojure_pkg_runtime.NewEnvironment) _register("github.com/glojurelang/glojure/pkg/runtime.NewFn", github_com_glojurelang_glojure_pkg_runtime.NewFn) - _register("github.com/glojurelang/glojure/pkg/runtime.Program", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Program)(nil)).Elem()) - _register("github.com/glojurelang/glojure/pkg/runtime.*Program", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Program)(nil))) _register("github.com/glojurelang/glojure/pkg/runtime.RT", github_com_glojurelang_glojure_pkg_runtime.RT) _register("github.com/glojurelang/glojure/pkg/runtime.RTEvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTEvalError)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.*RTEvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTEvalError)(nil))) @@ -3989,6 +3988,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/runtime.RTReadString", github_com_glojurelang_glojure_pkg_runtime.RTReadString) _register("github.com/glojurelang/glojure/pkg/runtime.ReadEval", github_com_glojurelang_glojure_pkg_runtime.ReadEval) _register("github.com/glojurelang/glojure/pkg/runtime.ReadEvalOption", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.ReadEvalOption)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/runtime.RegisterNSLoader", github_com_glojurelang_glojure_pkg_runtime.RegisterNSLoader) _register("github.com/glojurelang/glojure/pkg/runtime.SymInNS", github_com_glojurelang_glojure_pkg_runtime.SymInNS) _register("github.com/glojurelang/glojure/pkg/runtime.SymNS", github_com_glojurelang_glojure_pkg_runtime.SymNS) _register("github.com/glojurelang/glojure/pkg/runtime.SymbolDot", github_com_glojurelang_glojure_pkg_runtime.SymbolDot) diff --git a/pkg/gen/gljimports/gljimports_linux_amd64.go b/pkg/gen/gljimports/gljimports_linux_amd64.go index 8b83539b..c2b0d1a7 100644 --- a/pkg/gen/gljimports/gljimports_linux_amd64.go +++ b/pkg/gen/gljimports/gljimports_linux_amd64.go @@ -3977,10 +3977,9 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/runtime.EvalOption", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.EvalOption)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.Fn", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Fn)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.*Fn", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Fn)(nil))) + _register("github.com/glojurelang/glojure/pkg/runtime.GetNSLoader", github_com_glojurelang_glojure_pkg_runtime.GetNSLoader) _register("github.com/glojurelang/glojure/pkg/runtime.NewEnvironment", github_com_glojurelang_glojure_pkg_runtime.NewEnvironment) _register("github.com/glojurelang/glojure/pkg/runtime.NewFn", github_com_glojurelang_glojure_pkg_runtime.NewFn) - _register("github.com/glojurelang/glojure/pkg/runtime.Program", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Program)(nil)).Elem()) - _register("github.com/glojurelang/glojure/pkg/runtime.*Program", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Program)(nil))) _register("github.com/glojurelang/glojure/pkg/runtime.RT", github_com_glojurelang_glojure_pkg_runtime.RT) _register("github.com/glojurelang/glojure/pkg/runtime.RTEvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTEvalError)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.*RTEvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTEvalError)(nil))) @@ -3989,6 +3988,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/runtime.RTReadString", github_com_glojurelang_glojure_pkg_runtime.RTReadString) _register("github.com/glojurelang/glojure/pkg/runtime.ReadEval", github_com_glojurelang_glojure_pkg_runtime.ReadEval) _register("github.com/glojurelang/glojure/pkg/runtime.ReadEvalOption", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.ReadEvalOption)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/runtime.RegisterNSLoader", github_com_glojurelang_glojure_pkg_runtime.RegisterNSLoader) _register("github.com/glojurelang/glojure/pkg/runtime.SymInNS", github_com_glojurelang_glojure_pkg_runtime.SymInNS) _register("github.com/glojurelang/glojure/pkg/runtime.SymNS", github_com_glojurelang_glojure_pkg_runtime.SymNS) _register("github.com/glojurelang/glojure/pkg/runtime.SymbolDot", github_com_glojurelang_glojure_pkg_runtime.SymbolDot) diff --git a/pkg/gen/gljimports/gljimports_linux_arm64.go b/pkg/gen/gljimports/gljimports_linux_arm64.go index 378fbbdb..9249eccd 100644 --- a/pkg/gen/gljimports/gljimports_linux_arm64.go +++ b/pkg/gen/gljimports/gljimports_linux_arm64.go @@ -3977,10 +3977,9 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/runtime.EvalOption", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.EvalOption)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.Fn", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Fn)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.*Fn", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Fn)(nil))) + _register("github.com/glojurelang/glojure/pkg/runtime.GetNSLoader", github_com_glojurelang_glojure_pkg_runtime.GetNSLoader) _register("github.com/glojurelang/glojure/pkg/runtime.NewEnvironment", github_com_glojurelang_glojure_pkg_runtime.NewEnvironment) _register("github.com/glojurelang/glojure/pkg/runtime.NewFn", github_com_glojurelang_glojure_pkg_runtime.NewFn) - _register("github.com/glojurelang/glojure/pkg/runtime.Program", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Program)(nil)).Elem()) - _register("github.com/glojurelang/glojure/pkg/runtime.*Program", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Program)(nil))) _register("github.com/glojurelang/glojure/pkg/runtime.RT", github_com_glojurelang_glojure_pkg_runtime.RT) _register("github.com/glojurelang/glojure/pkg/runtime.RTEvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTEvalError)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.*RTEvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTEvalError)(nil))) @@ -3989,6 +3988,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/runtime.RTReadString", github_com_glojurelang_glojure_pkg_runtime.RTReadString) _register("github.com/glojurelang/glojure/pkg/runtime.ReadEval", github_com_glojurelang_glojure_pkg_runtime.ReadEval) _register("github.com/glojurelang/glojure/pkg/runtime.ReadEvalOption", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.ReadEvalOption)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/runtime.RegisterNSLoader", github_com_glojurelang_glojure_pkg_runtime.RegisterNSLoader) _register("github.com/glojurelang/glojure/pkg/runtime.SymInNS", github_com_glojurelang_glojure_pkg_runtime.SymInNS) _register("github.com/glojurelang/glojure/pkg/runtime.SymNS", github_com_glojurelang_glojure_pkg_runtime.SymNS) _register("github.com/glojurelang/glojure/pkg/runtime.SymbolDot", github_com_glojurelang_glojure_pkg_runtime.SymbolDot) diff --git a/pkg/gen/gljimports/gljimports_windows_amd64.go b/pkg/gen/gljimports/gljimports_windows_amd64.go index 0aae41a4..198e03cc 100644 --- a/pkg/gen/gljimports/gljimports_windows_amd64.go +++ b/pkg/gen/gljimports/gljimports_windows_amd64.go @@ -3977,10 +3977,9 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/runtime.EvalOption", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.EvalOption)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.Fn", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Fn)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.*Fn", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Fn)(nil))) + _register("github.com/glojurelang/glojure/pkg/runtime.GetNSLoader", github_com_glojurelang_glojure_pkg_runtime.GetNSLoader) _register("github.com/glojurelang/glojure/pkg/runtime.NewEnvironment", github_com_glojurelang_glojure_pkg_runtime.NewEnvironment) _register("github.com/glojurelang/glojure/pkg/runtime.NewFn", github_com_glojurelang_glojure_pkg_runtime.NewFn) - _register("github.com/glojurelang/glojure/pkg/runtime.Program", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Program)(nil)).Elem()) - _register("github.com/glojurelang/glojure/pkg/runtime.*Program", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Program)(nil))) _register("github.com/glojurelang/glojure/pkg/runtime.RT", github_com_glojurelang_glojure_pkg_runtime.RT) _register("github.com/glojurelang/glojure/pkg/runtime.RTEvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTEvalError)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.*RTEvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTEvalError)(nil))) @@ -3989,6 +3988,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/runtime.RTReadString", github_com_glojurelang_glojure_pkg_runtime.RTReadString) _register("github.com/glojurelang/glojure/pkg/runtime.ReadEval", github_com_glojurelang_glojure_pkg_runtime.ReadEval) _register("github.com/glojurelang/glojure/pkg/runtime.ReadEvalOption", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.ReadEvalOption)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/runtime.RegisterNSLoader", github_com_glojurelang_glojure_pkg_runtime.RegisterNSLoader) _register("github.com/glojurelang/glojure/pkg/runtime.SymInNS", github_com_glojurelang_glojure_pkg_runtime.SymInNS) _register("github.com/glojurelang/glojure/pkg/runtime.SymNS", github_com_glojurelang_glojure_pkg_runtime.SymNS) _register("github.com/glojurelang/glojure/pkg/runtime.SymbolDot", github_com_glojurelang_glojure_pkg_runtime.SymbolDot) diff --git a/pkg/gen/gljimports/gljimports_windows_arm.go b/pkg/gen/gljimports/gljimports_windows_arm.go index 70f63c47..4982ccb5 100644 --- a/pkg/gen/gljimports/gljimports_windows_arm.go +++ b/pkg/gen/gljimports/gljimports_windows_arm.go @@ -3977,10 +3977,9 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/runtime.EvalOption", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.EvalOption)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.Fn", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Fn)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.*Fn", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Fn)(nil))) + _register("github.com/glojurelang/glojure/pkg/runtime.GetNSLoader", github_com_glojurelang_glojure_pkg_runtime.GetNSLoader) _register("github.com/glojurelang/glojure/pkg/runtime.NewEnvironment", github_com_glojurelang_glojure_pkg_runtime.NewEnvironment) _register("github.com/glojurelang/glojure/pkg/runtime.NewFn", github_com_glojurelang_glojure_pkg_runtime.NewFn) - _register("github.com/glojurelang/glojure/pkg/runtime.Program", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Program)(nil)).Elem()) - _register("github.com/glojurelang/glojure/pkg/runtime.*Program", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Program)(nil))) _register("github.com/glojurelang/glojure/pkg/runtime.RT", github_com_glojurelang_glojure_pkg_runtime.RT) _register("github.com/glojurelang/glojure/pkg/runtime.RTEvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTEvalError)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.*RTEvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTEvalError)(nil))) @@ -3989,6 +3988,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/runtime.RTReadString", github_com_glojurelang_glojure_pkg_runtime.RTReadString) _register("github.com/glojurelang/glojure/pkg/runtime.ReadEval", github_com_glojurelang_glojure_pkg_runtime.ReadEval) _register("github.com/glojurelang/glojure/pkg/runtime.ReadEvalOption", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.ReadEvalOption)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/runtime.RegisterNSLoader", github_com_glojurelang_glojure_pkg_runtime.RegisterNSLoader) _register("github.com/glojurelang/glojure/pkg/runtime.SymInNS", github_com_glojurelang_glojure_pkg_runtime.SymInNS) _register("github.com/glojurelang/glojure/pkg/runtime.SymNS", github_com_glojurelang_glojure_pkg_runtime.SymNS) _register("github.com/glojurelang/glojure/pkg/runtime.SymbolDot", github_com_glojurelang_glojure_pkg_runtime.SymbolDot) diff --git a/pkg/runtime/envinit.go b/pkg/runtime/envinit.go index df8ce6ca..9c18143a 100644 --- a/pkg/runtime/envinit.go +++ b/pkg/runtime/envinit.go @@ -5,17 +5,10 @@ import ( "fmt" "io" "os" - "strings" "github.com/glojurelang/glojure/pkg/lang" - "github.com/glojurelang/glojure/pkg/reader" - "github.com/glojurelang/glojure/pkg/stdlib" ) -type Program struct { - nodes []interface{} -} - type evalOptions struct { stdout io.Writer stderr io.Writer @@ -64,7 +57,7 @@ func NewEnvironment(opts ...EvalOption) lang.Environment { env = newEnvironment(context.Background(), options.stdout, options.stderr) env.loadPath = options.loadPath } - // TODO: this is rather rather hacky + // this is rather rather hacky lang.GlobalEnv = env // bootstrap namespace control @@ -85,46 +78,8 @@ func NewEnvironment(opts ...EvalOption) lang.Environment { })) } - { - // Add stdlib - evalFile := func(path string) { - core, err := stdlib.StdLib.ReadFile(path) - if err != nil { - panic(fmt.Sprintf("could not read stdlib core.glj: %v", err)) - } - r := reader.New(strings.NewReader(string(core)), reader.WithFilename(path), reader.WithGetCurrentNS(func() *lang.Namespace { - return env.CurrentNamespace() - })) - - for { - expr, err := r.ReadOne() - if err == reader.ErrEOF { - break - } - if err != nil { - panic(fmt.Sprintf("error reading core lib %v: %v", path, err)) - } - _, err = env.Eval(expr) - if err != nil { - panic(fmt.Sprintf("error evaluating core lib %v: %v", path, err)) - } - } - } - evalFile("glojure/core.glj") - } + // Add stdlib + RT.Load("glojure/core") return env } - -func (p *Program) Eval(opts ...EvalOption) (interface{}, error) { - env := NewEnvironment(opts...) - - for _, node := range p.nodes { - _, err := env.Eval(node) - if err != nil { - return nil, err - } - } - - return nil, nil -} diff --git a/pkg/runtime/nsloaders.go b/pkg/runtime/nsloaders.go new file mode 100644 index 00000000..0a1a2598 --- /dev/null +++ b/pkg/runtime/nsloaders.go @@ -0,0 +1,21 @@ +package runtime + +var ( + // nsLoaders is a map of namespace resource names to their loader + // functions. Used for pre-compiled namespaces. + nsLoaders = map[string]func(){} +) + +// RegisterNSLoader registers a loader function for a namespace given its resource name +// (i.e. root path with slashes, no extension). +func RegisterNSLoader(nsResource string, loader func()) { + if _, exists := nsLoaders[nsResource]; exists { + panic("namespace loader already registered for " + nsResource) + } + nsLoaders[nsResource] = loader +} + +// GetNSLoader retrieves the loader function for a namespace given its resource name. +func GetNSLoader(nsResource string) func() { + return nsLoaders[nsResource] +} From 2f4449d7bf541c3a56c35021c82bca0981672908 Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sat, 30 Aug 2025 22:34:10 -0700 Subject: [PATCH 52/67] Move codegen to the runtime package Signed-off-by: James Hamlin --- pkg/codegen/TODO.txt | 17 ----- pkg/codegen/analyze.go | 55 ---------------- pkg/{codegen => runtime}/codegen.go | 65 +++++++++++++++++-- pkg/{codegen => runtime}/codegen_test.go | 4 +- .../codegengotest/codegengo_test.go | 0 .../testdata/codegen/test/const_keyword.glj | 0 .../codegen/test/const_keyword/load.go.out | 0 .../testdata/codegen/test/const_number.glj | 0 .../codegen/test/const_number/load.go.out | 0 .../testdata/codegen/test/const_string.glj | 0 .../codegen/test/const_string/load.go.out | 0 .../testdata/codegen/test/core/load.go.out | 0 .../testdata/codegen/test/def_simple.glj | 0 .../codegen/test/def_simple/load.go.out | 0 .../testdata/codegen/test/fn_closure.glj | 0 .../codegen/test/fn_closure/load.go.out | 0 .../testdata/codegen/test/fn_recur.glj | 0 .../codegen/test/fn_recur/load.go.out | 0 .../testdata/codegen/test/loop_simple.glj | 0 .../codegen/test/loop_simple/load.go.out | 0 .../testdata/codegen/test/maybe_class.glj | 0 .../codegen/test/maybe_class/load.go.out | 0 .../testdata/codegen/test/multifn.glj | 0 .../testdata/codegen/test/multifn/load.go.out | 0 .../testdata/codegen/test/ns_skip.glj | 0 .../testdata/codegen/test/ns_skip/load.go.out | 0 .../testdata/codegen/test/quote_simple.glj | 0 .../codegen/test/quote_simple/load.go.out | 0 .../testdata/codegen/test/ref.glj | 0 .../testdata/codegen/test/ref/load.go.out | 0 .../testdata/codegen/test/the_var.glj | 0 .../testdata/codegen/test/the_var/load.go.out | 0 .../testdata/codegen/test/throw_simple.glj | 0 .../codegen/test/throw_simple/load.go.out | 0 .../testdata/codegen/test/try_advanced.glj | 0 .../codegen/test/try_advanced/load.go.out | 0 .../testdata/codegen/test/try_basic.glj | 0 .../codegen/test/try_basic/load.go.out | 0 .../testdata/codegen/test/values.glj | 0 .../testdata/codegen/test/values/load.go.out | 0 .../testdata/codegen/test/with_meta.glj | 0 .../codegen/test/with_meta/load.go.out | 0 42 files changed, 60 insertions(+), 81 deletions(-) delete mode 100644 pkg/codegen/TODO.txt delete mode 100644 pkg/codegen/analyze.go rename pkg/{codegen => runtime}/codegen.go (97%) rename pkg/{codegen => runtime}/codegen_test.go (99%) rename pkg/{codegen => runtime}/codegengotest/codegengo_test.go (100%) rename pkg/{codegen => runtime}/testdata/codegen/test/const_keyword.glj (100%) rename pkg/{codegen => runtime}/testdata/codegen/test/const_keyword/load.go.out (100%) rename pkg/{codegen => runtime}/testdata/codegen/test/const_number.glj (100%) rename pkg/{codegen => runtime}/testdata/codegen/test/const_number/load.go.out (100%) rename pkg/{codegen => runtime}/testdata/codegen/test/const_string.glj (100%) rename pkg/{codegen => runtime}/testdata/codegen/test/const_string/load.go.out (100%) rename pkg/{codegen => runtime}/testdata/codegen/test/core/load.go.out (100%) rename pkg/{codegen => runtime}/testdata/codegen/test/def_simple.glj (100%) rename pkg/{codegen => runtime}/testdata/codegen/test/def_simple/load.go.out (100%) rename pkg/{codegen => runtime}/testdata/codegen/test/fn_closure.glj (100%) rename pkg/{codegen => runtime}/testdata/codegen/test/fn_closure/load.go.out (100%) rename pkg/{codegen => runtime}/testdata/codegen/test/fn_recur.glj (100%) rename pkg/{codegen => runtime}/testdata/codegen/test/fn_recur/load.go.out (100%) rename pkg/{codegen => runtime}/testdata/codegen/test/loop_simple.glj (100%) rename pkg/{codegen => runtime}/testdata/codegen/test/loop_simple/load.go.out (100%) rename pkg/{codegen => runtime}/testdata/codegen/test/maybe_class.glj (100%) rename pkg/{codegen => runtime}/testdata/codegen/test/maybe_class/load.go.out (100%) rename pkg/{codegen => runtime}/testdata/codegen/test/multifn.glj (100%) rename pkg/{codegen => runtime}/testdata/codegen/test/multifn/load.go.out (100%) rename pkg/{codegen => runtime}/testdata/codegen/test/ns_skip.glj (100%) rename pkg/{codegen => runtime}/testdata/codegen/test/ns_skip/load.go.out (100%) rename pkg/{codegen => runtime}/testdata/codegen/test/quote_simple.glj (100%) rename pkg/{codegen => runtime}/testdata/codegen/test/quote_simple/load.go.out (100%) rename pkg/{codegen => runtime}/testdata/codegen/test/ref.glj (100%) rename pkg/{codegen => runtime}/testdata/codegen/test/ref/load.go.out (100%) rename pkg/{codegen => runtime}/testdata/codegen/test/the_var.glj (100%) rename pkg/{codegen => runtime}/testdata/codegen/test/the_var/load.go.out (100%) rename pkg/{codegen => runtime}/testdata/codegen/test/throw_simple.glj (100%) rename pkg/{codegen => runtime}/testdata/codegen/test/throw_simple/load.go.out (100%) rename pkg/{codegen => runtime}/testdata/codegen/test/try_advanced.glj (100%) rename pkg/{codegen => runtime}/testdata/codegen/test/try_advanced/load.go.out (100%) rename pkg/{codegen => runtime}/testdata/codegen/test/try_basic.glj (100%) rename pkg/{codegen => runtime}/testdata/codegen/test/try_basic/load.go.out (100%) rename pkg/{codegen => runtime}/testdata/codegen/test/values.glj (100%) rename pkg/{codegen => runtime}/testdata/codegen/test/values/load.go.out (100%) rename pkg/{codegen => runtime}/testdata/codegen/test/with_meta.glj (100%) rename pkg/{codegen => runtime}/testdata/codegen/test/with_meta/load.go.out (100%) diff --git a/pkg/codegen/TODO.txt b/pkg/codegen/TODO.txt deleted file mode 100644 index 8084b04b..00000000 --- a/pkg/codegen/TODO.txt +++ /dev/null @@ -1,17 +0,0 @@ - -- locals scope should start EMPTY when generating values! -- handle namespace requires/uses/etc. -- handle let bindings that are shared across multiple vars -- test repeated let bindings of the same name, where previous bindings are shadowed - - -Handle -- ExceptionInfo15 "ExceptionInfo" -- LinkedBlockingQueue28 "LinkedBlockingQueue" -- glojure.lang.LineNumberingPushbackReader19 "glojure.lang.LineNumberingPushbackReader" -- glojure.lang4 "glojure.lang" -- java.io.InputStreamReader20 "java.io.InputStreamReader" -- java.io.StringReader21 "java.io.StringReader" -- java.lang.UnsupportedOperationException14 "java.lang.UnsupportedOperationException" -- java.util.concurrent.CountDownLatch25 "java.util.concurrent.CountDownLatch" -- java.util.concurrent8 "java.util.concurrent" diff --git a/pkg/codegen/analyze.go b/pkg/codegen/analyze.go deleted file mode 100644 index b15bd2a4..00000000 --- a/pkg/codegen/analyze.go +++ /dev/null @@ -1,55 +0,0 @@ -package codegen - -import ( - "github.com/glojurelang/glojure/pkg/ast" -) - -func nodeRecurs(n *ast.Node, loopID string) bool { - switch n.Op { - case ast.OpRecur: - recurNode := n.Sub.(*ast.RecurNode) - return recurNode.LoopID.Name() == loopID - case ast.OpDo: - doNode := n.Sub.(*ast.DoNode) - return nodeRecurs(doNode.Ret, loopID) - case ast.OpLet, ast.OpLoop: - letNode := n.Sub.(*ast.LetNode) - return nodeRecurs(letNode.Body, loopID) - case ast.OpLetFn: - letFnNode := n.Sub.(*ast.LetFnNode) - return nodeRecurs(letFnNode.Body, loopID) - case ast.OpIf: - ifNode := n.Sub.(*ast.IfNode) - return nodeRecurs(ifNode.Then, loopID) || nodeRecurs(ifNode.Else, loopID) - case ast.OpTry: - tryNode := n.Sub.(*ast.TryNode) - if nodeRecurs(tryNode.Body, loopID) { - return true - } - for _, catch := range tryNode.Catches { - if nodeRecurs(catch, loopID) { - return true - } - } - case ast.OpCatch: - catchNode := n.Sub.(*ast.CatchNode) - return nodeRecurs(catchNode.Body, loopID) - case ast.OpCase: - caseNode := n.Sub.(*ast.CaseNode) - if nodeRecurs(caseNode.Default, loopID) { - return true - } - for _, branch := range caseNode.Nodes { - if nodeRecurs(branch, loopID) { - return true - } - } - case ast.OpCaseNode: - caseNode := n.Sub.(*ast.CaseNodeNode) - return nodeRecurs(caseNode.Then, loopID) - default: - return false // can't recur in this node type - } - - return false -} diff --git a/pkg/codegen/codegen.go b/pkg/runtime/codegen.go similarity index 97% rename from pkg/codegen/codegen.go rename to pkg/runtime/codegen.go index a60eb7f9..44b95632 100644 --- a/pkg/codegen/codegen.go +++ b/pkg/runtime/codegen.go @@ -1,4 +1,4 @@ -package codegen +package runtime import ( "bytes" @@ -13,7 +13,6 @@ import ( "github.com/glojurelang/glojure/pkg/ast" "github.com/glojurelang/glojure/pkg/lang" "github.com/glojurelang/glojure/pkg/pkgmap" - "github.com/glojurelang/glojure/pkg/runtime" ) // TODO @@ -78,8 +77,8 @@ var ( } ) -// New creates a new code generator -func New(w io.Writer) *Generator { +// NewGenerator creates a new code generator +func NewGenerator(w io.Writer) *Generator { return &Generator{ originalWriter: w, w: w, @@ -344,7 +343,7 @@ func (g *Generator) generateValue(value any) string { return fmt.Sprintf("lang.FindOrCreateNamespace(%s).FindInternedVar(%s)", g.allocSymVar(ns.Name().String()), g.allocSymVar(sym.String())) case *lang.Namespace: return fmt.Sprintf("lang.FindOrCreateNamespace(%s)", g.allocSymVar(v.Name().String())) - case *runtime.Fn: + case *Fn: return g.generateFn(v) case lang.FnFunc: return g.generateFnFunc(v) @@ -725,7 +724,7 @@ func (g *Generator) generateFnFunc(fn lang.FnFunc) string { panic("cannot generate opaque go function values") } -func (g *Generator) generateFn(fn *runtime.Fn) string { +func (g *Generator) generateFn(fn *Fn) string { // Save and restore current environment prevEnv := g.currentFnEnv g.currentFnEnv = fn.GetEnvironment() // Set the captured environment for this function @@ -926,7 +925,7 @@ func (g *Generator) generateASTNode(node *ast.Node) (res string) { case ast.OpQuote: return g.generateValue(node.Sub.(*ast.QuoteNode).Expr.Sub.(*ast.ConstNode).Value) case ast.OpFn: - return g.generateFn(runtime.NewFn(node, nil)) + return g.generateFn(NewFn(node, nil)) case ast.OpHostCall: return g.generateHostCall(node) case ast.OpHostInterop: @@ -1787,3 +1786,55 @@ func getWellKnownFunctionName(fn any) (string, bool) { name, ok := wellKnownFunctions[ptr] return name, ok } + +/////////////////////////////////////////////////////////////////////////////// + +func nodeRecurs(n *ast.Node, loopID string) bool { + switch n.Op { + case ast.OpRecur: + recurNode := n.Sub.(*ast.RecurNode) + return recurNode.LoopID.Name() == loopID + case ast.OpDo: + doNode := n.Sub.(*ast.DoNode) + return nodeRecurs(doNode.Ret, loopID) + case ast.OpLet, ast.OpLoop: + letNode := n.Sub.(*ast.LetNode) + return nodeRecurs(letNode.Body, loopID) + case ast.OpLetFn: + letFnNode := n.Sub.(*ast.LetFnNode) + return nodeRecurs(letFnNode.Body, loopID) + case ast.OpIf: + ifNode := n.Sub.(*ast.IfNode) + return nodeRecurs(ifNode.Then, loopID) || nodeRecurs(ifNode.Else, loopID) + case ast.OpTry: + tryNode := n.Sub.(*ast.TryNode) + if nodeRecurs(tryNode.Body, loopID) { + return true + } + for _, catch := range tryNode.Catches { + if nodeRecurs(catch, loopID) { + return true + } + } + case ast.OpCatch: + catchNode := n.Sub.(*ast.CatchNode) + return nodeRecurs(catchNode.Body, loopID) + case ast.OpCase: + caseNode := n.Sub.(*ast.CaseNode) + if nodeRecurs(caseNode.Default, loopID) { + return true + } + for _, branch := range caseNode.Nodes { + if nodeRecurs(branch, loopID) { + return true + } + } + case ast.OpCaseNode: + caseNode := n.Sub.(*ast.CaseNodeNode) + return nodeRecurs(caseNode.Then, loopID) + default: + return false // can't recur in this node type + } + + return false +} diff --git a/pkg/codegen/codegen_test.go b/pkg/runtime/codegen_test.go similarity index 99% rename from pkg/codegen/codegen_test.go rename to pkg/runtime/codegen_test.go index 5a7d6275..f1245147 100644 --- a/pkg/codegen/codegen_test.go +++ b/pkg/runtime/codegen_test.go @@ -1,4 +1,4 @@ -package codegen_test +package runtime_test import ( "bytes" @@ -84,7 +84,7 @@ func generateAndTestNamespace(t *testing.T, ns *lang.Namespace, goldenFile strin // Generate code for the namespace var buf bytes.Buffer - gen := codegen.New(&buf) + gen := codegen.NewGenerator(&buf) if err := gen.Generate(ns); err != nil { if os.Getenv("UPDATE_SNAPSHOT") == "1" { // write the output anyway if we're updating the snapshot diff --git a/pkg/codegen/codegengotest/codegengo_test.go b/pkg/runtime/codegengotest/codegengo_test.go similarity index 100% rename from pkg/codegen/codegengotest/codegengo_test.go rename to pkg/runtime/codegengotest/codegengo_test.go diff --git a/pkg/codegen/testdata/codegen/test/const_keyword.glj b/pkg/runtime/testdata/codegen/test/const_keyword.glj similarity index 100% rename from pkg/codegen/testdata/codegen/test/const_keyword.glj rename to pkg/runtime/testdata/codegen/test/const_keyword.glj diff --git a/pkg/codegen/testdata/codegen/test/const_keyword/load.go.out b/pkg/runtime/testdata/codegen/test/const_keyword/load.go.out similarity index 100% rename from pkg/codegen/testdata/codegen/test/const_keyword/load.go.out rename to pkg/runtime/testdata/codegen/test/const_keyword/load.go.out diff --git a/pkg/codegen/testdata/codegen/test/const_number.glj b/pkg/runtime/testdata/codegen/test/const_number.glj similarity index 100% rename from pkg/codegen/testdata/codegen/test/const_number.glj rename to pkg/runtime/testdata/codegen/test/const_number.glj diff --git a/pkg/codegen/testdata/codegen/test/const_number/load.go.out b/pkg/runtime/testdata/codegen/test/const_number/load.go.out similarity index 100% rename from pkg/codegen/testdata/codegen/test/const_number/load.go.out rename to pkg/runtime/testdata/codegen/test/const_number/load.go.out diff --git a/pkg/codegen/testdata/codegen/test/const_string.glj b/pkg/runtime/testdata/codegen/test/const_string.glj similarity index 100% rename from pkg/codegen/testdata/codegen/test/const_string.glj rename to pkg/runtime/testdata/codegen/test/const_string.glj diff --git a/pkg/codegen/testdata/codegen/test/const_string/load.go.out b/pkg/runtime/testdata/codegen/test/const_string/load.go.out similarity index 100% rename from pkg/codegen/testdata/codegen/test/const_string/load.go.out rename to pkg/runtime/testdata/codegen/test/const_string/load.go.out diff --git a/pkg/codegen/testdata/codegen/test/core/load.go.out b/pkg/runtime/testdata/codegen/test/core/load.go.out similarity index 100% rename from pkg/codegen/testdata/codegen/test/core/load.go.out rename to pkg/runtime/testdata/codegen/test/core/load.go.out diff --git a/pkg/codegen/testdata/codegen/test/def_simple.glj b/pkg/runtime/testdata/codegen/test/def_simple.glj similarity index 100% rename from pkg/codegen/testdata/codegen/test/def_simple.glj rename to pkg/runtime/testdata/codegen/test/def_simple.glj diff --git a/pkg/codegen/testdata/codegen/test/def_simple/load.go.out b/pkg/runtime/testdata/codegen/test/def_simple/load.go.out similarity index 100% rename from pkg/codegen/testdata/codegen/test/def_simple/load.go.out rename to pkg/runtime/testdata/codegen/test/def_simple/load.go.out diff --git a/pkg/codegen/testdata/codegen/test/fn_closure.glj b/pkg/runtime/testdata/codegen/test/fn_closure.glj similarity index 100% rename from pkg/codegen/testdata/codegen/test/fn_closure.glj rename to pkg/runtime/testdata/codegen/test/fn_closure.glj diff --git a/pkg/codegen/testdata/codegen/test/fn_closure/load.go.out b/pkg/runtime/testdata/codegen/test/fn_closure/load.go.out similarity index 100% rename from pkg/codegen/testdata/codegen/test/fn_closure/load.go.out rename to pkg/runtime/testdata/codegen/test/fn_closure/load.go.out diff --git a/pkg/codegen/testdata/codegen/test/fn_recur.glj b/pkg/runtime/testdata/codegen/test/fn_recur.glj similarity index 100% rename from pkg/codegen/testdata/codegen/test/fn_recur.glj rename to pkg/runtime/testdata/codegen/test/fn_recur.glj diff --git a/pkg/codegen/testdata/codegen/test/fn_recur/load.go.out b/pkg/runtime/testdata/codegen/test/fn_recur/load.go.out similarity index 100% rename from pkg/codegen/testdata/codegen/test/fn_recur/load.go.out rename to pkg/runtime/testdata/codegen/test/fn_recur/load.go.out diff --git a/pkg/codegen/testdata/codegen/test/loop_simple.glj b/pkg/runtime/testdata/codegen/test/loop_simple.glj similarity index 100% rename from pkg/codegen/testdata/codegen/test/loop_simple.glj rename to pkg/runtime/testdata/codegen/test/loop_simple.glj diff --git a/pkg/codegen/testdata/codegen/test/loop_simple/load.go.out b/pkg/runtime/testdata/codegen/test/loop_simple/load.go.out similarity index 100% rename from pkg/codegen/testdata/codegen/test/loop_simple/load.go.out rename to pkg/runtime/testdata/codegen/test/loop_simple/load.go.out diff --git a/pkg/codegen/testdata/codegen/test/maybe_class.glj b/pkg/runtime/testdata/codegen/test/maybe_class.glj similarity index 100% rename from pkg/codegen/testdata/codegen/test/maybe_class.glj rename to pkg/runtime/testdata/codegen/test/maybe_class.glj diff --git a/pkg/codegen/testdata/codegen/test/maybe_class/load.go.out b/pkg/runtime/testdata/codegen/test/maybe_class/load.go.out similarity index 100% rename from pkg/codegen/testdata/codegen/test/maybe_class/load.go.out rename to pkg/runtime/testdata/codegen/test/maybe_class/load.go.out diff --git a/pkg/codegen/testdata/codegen/test/multifn.glj b/pkg/runtime/testdata/codegen/test/multifn.glj similarity index 100% rename from pkg/codegen/testdata/codegen/test/multifn.glj rename to pkg/runtime/testdata/codegen/test/multifn.glj diff --git a/pkg/codegen/testdata/codegen/test/multifn/load.go.out b/pkg/runtime/testdata/codegen/test/multifn/load.go.out similarity index 100% rename from pkg/codegen/testdata/codegen/test/multifn/load.go.out rename to pkg/runtime/testdata/codegen/test/multifn/load.go.out diff --git a/pkg/codegen/testdata/codegen/test/ns_skip.glj b/pkg/runtime/testdata/codegen/test/ns_skip.glj similarity index 100% rename from pkg/codegen/testdata/codegen/test/ns_skip.glj rename to pkg/runtime/testdata/codegen/test/ns_skip.glj diff --git a/pkg/codegen/testdata/codegen/test/ns_skip/load.go.out b/pkg/runtime/testdata/codegen/test/ns_skip/load.go.out similarity index 100% rename from pkg/codegen/testdata/codegen/test/ns_skip/load.go.out rename to pkg/runtime/testdata/codegen/test/ns_skip/load.go.out diff --git a/pkg/codegen/testdata/codegen/test/quote_simple.glj b/pkg/runtime/testdata/codegen/test/quote_simple.glj similarity index 100% rename from pkg/codegen/testdata/codegen/test/quote_simple.glj rename to pkg/runtime/testdata/codegen/test/quote_simple.glj diff --git a/pkg/codegen/testdata/codegen/test/quote_simple/load.go.out b/pkg/runtime/testdata/codegen/test/quote_simple/load.go.out similarity index 100% rename from pkg/codegen/testdata/codegen/test/quote_simple/load.go.out rename to pkg/runtime/testdata/codegen/test/quote_simple/load.go.out diff --git a/pkg/codegen/testdata/codegen/test/ref.glj b/pkg/runtime/testdata/codegen/test/ref.glj similarity index 100% rename from pkg/codegen/testdata/codegen/test/ref.glj rename to pkg/runtime/testdata/codegen/test/ref.glj diff --git a/pkg/codegen/testdata/codegen/test/ref/load.go.out b/pkg/runtime/testdata/codegen/test/ref/load.go.out similarity index 100% rename from pkg/codegen/testdata/codegen/test/ref/load.go.out rename to pkg/runtime/testdata/codegen/test/ref/load.go.out diff --git a/pkg/codegen/testdata/codegen/test/the_var.glj b/pkg/runtime/testdata/codegen/test/the_var.glj similarity index 100% rename from pkg/codegen/testdata/codegen/test/the_var.glj rename to pkg/runtime/testdata/codegen/test/the_var.glj diff --git a/pkg/codegen/testdata/codegen/test/the_var/load.go.out b/pkg/runtime/testdata/codegen/test/the_var/load.go.out similarity index 100% rename from pkg/codegen/testdata/codegen/test/the_var/load.go.out rename to pkg/runtime/testdata/codegen/test/the_var/load.go.out diff --git a/pkg/codegen/testdata/codegen/test/throw_simple.glj b/pkg/runtime/testdata/codegen/test/throw_simple.glj similarity index 100% rename from pkg/codegen/testdata/codegen/test/throw_simple.glj rename to pkg/runtime/testdata/codegen/test/throw_simple.glj diff --git a/pkg/codegen/testdata/codegen/test/throw_simple/load.go.out b/pkg/runtime/testdata/codegen/test/throw_simple/load.go.out similarity index 100% rename from pkg/codegen/testdata/codegen/test/throw_simple/load.go.out rename to pkg/runtime/testdata/codegen/test/throw_simple/load.go.out diff --git a/pkg/codegen/testdata/codegen/test/try_advanced.glj b/pkg/runtime/testdata/codegen/test/try_advanced.glj similarity index 100% rename from pkg/codegen/testdata/codegen/test/try_advanced.glj rename to pkg/runtime/testdata/codegen/test/try_advanced.glj diff --git a/pkg/codegen/testdata/codegen/test/try_advanced/load.go.out b/pkg/runtime/testdata/codegen/test/try_advanced/load.go.out similarity index 100% rename from pkg/codegen/testdata/codegen/test/try_advanced/load.go.out rename to pkg/runtime/testdata/codegen/test/try_advanced/load.go.out diff --git a/pkg/codegen/testdata/codegen/test/try_basic.glj b/pkg/runtime/testdata/codegen/test/try_basic.glj similarity index 100% rename from pkg/codegen/testdata/codegen/test/try_basic.glj rename to pkg/runtime/testdata/codegen/test/try_basic.glj diff --git a/pkg/codegen/testdata/codegen/test/try_basic/load.go.out b/pkg/runtime/testdata/codegen/test/try_basic/load.go.out similarity index 100% rename from pkg/codegen/testdata/codegen/test/try_basic/load.go.out rename to pkg/runtime/testdata/codegen/test/try_basic/load.go.out diff --git a/pkg/codegen/testdata/codegen/test/values.glj b/pkg/runtime/testdata/codegen/test/values.glj similarity index 100% rename from pkg/codegen/testdata/codegen/test/values.glj rename to pkg/runtime/testdata/codegen/test/values.glj diff --git a/pkg/codegen/testdata/codegen/test/values/load.go.out b/pkg/runtime/testdata/codegen/test/values/load.go.out similarity index 100% rename from pkg/codegen/testdata/codegen/test/values/load.go.out rename to pkg/runtime/testdata/codegen/test/values/load.go.out diff --git a/pkg/codegen/testdata/codegen/test/with_meta.glj b/pkg/runtime/testdata/codegen/test/with_meta.glj similarity index 100% rename from pkg/codegen/testdata/codegen/test/with_meta.glj rename to pkg/runtime/testdata/codegen/test/with_meta.glj diff --git a/pkg/codegen/testdata/codegen/test/with_meta/load.go.out b/pkg/runtime/testdata/codegen/test/with_meta/load.go.out similarity index 100% rename from pkg/codegen/testdata/codegen/test/with_meta/load.go.out rename to pkg/runtime/testdata/codegen/test/with_meta/load.go.out From 0f531a4b772a4345713475060e85e86d233b2dad Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sun, 31 Aug 2025 08:27:32 -0700 Subject: [PATCH 53/67] Poor man's topological sort when generating AOT Signed-off-by: James Hamlin --- Makefile | 3 + pkg/gljmain/gljmain.go | 4 + pkg/runtime/codegen.go | 155 +- pkg/runtime/codegen_test.go | 5 +- pkg/runtime/rtcompat.go | 70 +- .../codegen/test/const_keyword/load.go.out | 11 +- .../codegen/test/const_number/load.go.out | 11 +- .../codegen/test/const_string/load.go.out | 11 +- .../testdata/codegen/test/core/load.go.out | 96960 ++++++++-------- .../codegen/test/def_simple/load.go.out | 11 +- .../codegen/test/fn_closure/load.go.out | 143 +- .../codegen/test/fn_recur/load.go.out | 101 +- .../codegen/test/loop_simple/load.go.out | 61 +- .../codegen/test/maybe_class/load.go.out | 27 +- .../testdata/codegen/test/multifn/load.go.out | 116 +- .../testdata/codegen/test/ns_skip/load.go.out | 5 +- .../codegen/test/quote_simple/load.go.out | 17 +- .../testdata/codegen/test/ref/load.go.out | 43 +- .../testdata/codegen/test/the_var/load.go.out | 38 +- .../codegen/test/throw_simple/load.go.out | 17 +- .../codegen/test/try_advanced/load.go.out | 209 +- .../codegen/test/try_basic/load.go.out | 281 +- .../testdata/codegen/test/values/load.go.out | 84 +- .../codegen/test/with_meta/load.go.out | 35 +- pkg/stdlib/glojure/core/async/loader.go | 2053 + pkg/stdlib/glojure/core/loader.go | 56320 +++++++++ pkg/stdlib/glojure/core_deftype/loader.go | 55664 +++++++++ pkg/stdlib/glojure/core_print/loader.go | 56233 +++++++++ pkg/stdlib/glojure/protocols/loader.go | 1382 + 29 files changed, 221313 insertions(+), 48757 deletions(-) create mode 100644 pkg/stdlib/glojure/core/async/loader.go create mode 100644 pkg/stdlib/glojure/core/loader.go create mode 100644 pkg/stdlib/glojure/core_deftype/loader.go create mode 100644 pkg/stdlib/glojure/core_print/loader.go create mode 100644 pkg/stdlib/glojure/protocols/loader.go diff --git a/Makefile b/Makefile index ef05f707..4237f6ea 100644 --- a/Makefile +++ b/Makefile @@ -30,6 +30,9 @@ gocmd: .PHONY: generate generate: @go generate ./... + @echo "(compile 'glojure.core)" | GLOJURE_STDLIB_PATH=./pkg/stdlib $(GO_CMD) run ./cmd/glj + @echo "(compile 'glojure.core.async)" | GLOJURE_STDLIB_PATH=./pkg/stdlib $(GO_CMD) run ./cmd/glj + @echo "(compile 'glojure.protocols)" | GLOJURE_STDLIB_PATH=./pkg/stdlib $(GO_CMD) run ./cmd/glj pkg/gen/gljimports/gljimports_%.go: ./scripts/gen-gljimports.sh ./cmd/gen-import-interop/main.go ./internal/genpkg/genpkg.go \ $(wildcard ./pkg/lang/*.go) $(wildcard ./pkg/runtime/*.go) diff --git a/pkg/gljmain/gljmain.go b/pkg/gljmain/gljmain.go index 5f56197c..7a88080b 100644 --- a/pkg/gljmain/gljmain.go +++ b/pkg/gljmain/gljmain.go @@ -8,6 +8,10 @@ import ( // bootstrap the runtime _ "github.com/glojurelang/glojure/pkg/glj" + _ "github.com/glojurelang/glojure/pkg/stdlib/glojure/core" + _ "github.com/glojurelang/glojure/pkg/stdlib/glojure/core/async" + _ "github.com/glojurelang/glojure/pkg/stdlib/glojure/protocols" + "github.com/glojurelang/glojure/pkg/lang" "github.com/glojurelang/glojure/pkg/reader" "github.com/glojurelang/glojure/pkg/repl" diff --git a/pkg/runtime/codegen.go b/pkg/runtime/codegen.go index 44b95632..8c506493 100644 --- a/pkg/runtime/codegen.go +++ b/pkg/runtime/codegen.go @@ -51,18 +51,29 @@ type varInfo struct { sym string } +type valueInit struct { + name string // Name of the variable or var being initialized + buf bytes.Buffer // Buffer holding the initialization code + deps map[string]struct{} // Set of var/value names this value depends on +} + // Generator handles the conversion of AST nodes to Go code type Generator struct { originalWriter io.Writer - w io.Writer - varScopes []varScope // stack of variable scopes - recurStack []recurContext // stack of recur contexts for nested loops + + currentWriter io.Writer + currentValueInit *valueInit // current value initialization being generated + + varScopes []varScope // stack of variable scopes + recurStack []recurContext // stack of recur contexts for nested loops imports map[string]string // set of imported packages with their aliases varVariables map[varInfo]string // map of vars to their Go variable names symbolVariables map[string]string // set of all generated symbols to minimize allocations kwVariables map[string]string // set of all generated keywords to minimize allocations + valueInits []*valueInit // map of value initializations + // Fields for handling closures liftedValues map[liftedKey]*liftedValue // Dedupe by composite key liftedCounter int // Counter for closed0, closed1... @@ -81,7 +92,7 @@ var ( func NewGenerator(w io.Writer) *Generator { return &Generator{ originalWriter: w, - w: w, + currentWriter: w, varScopes: []varScope{{nextNum: 0, names: make(map[string]string)}}, recurStack: []recurContext{}, imports: make(map[string]string), @@ -95,16 +106,19 @@ func NewGenerator(w io.Writer) *Generator { // Generate takes a namespace and generates Go code that populates the same namespace func (g *Generator) Generate(ns *lang.Namespace) error { - // Buffer for the vars and namespace setup - var varsBuf bytes.Buffer - g.w = &varsBuf - // add lang import g.addImport("github.com/glojurelang/glojure/pkg/lang") g.addImport("github.com/glojurelang/glojure/pkg/runtime") - g.addImport("fmt") // for error formatting + g.addImport("fmt") // for error formatting + g.addImport("reflect") // for reflect.TypeOf + + var nsBuf bytes.Buffer + g.currentWriter = &nsBuf + g.writef("// reference fmt to avoid unused import error\n") g.writef("_ = fmt.Printf\n") + g.writef("// reference reflect to avoid unused import error\n") + g.writef("_ = reflect.TypeOf\n") g.writef(" ns := lang.FindOrCreateNamespace(%s)\n", g.allocSymVar(ns.Name().String())) g.writef(" _ = ns\n") @@ -146,13 +160,13 @@ func (g *Generator) Generate(ns *lang.Namespace) error { // Skip runtime-owned vars continue } + if err := g.generateVar("ns", nv.name, nv.vr); err != nil { return fmt.Errorf("failed to generate code for var %s: %w", nv.name, err) } } //////////////////////////////////////////////////////////////////////////////// - var liftedBuf bytes.Buffer // Generate lifted values at the beginning of init() if any if len(g.liftedValues) > 0 { // Sort by variable name for deterministic output @@ -165,8 +179,8 @@ func (g *Generator) Generate(ns *lang.Namespace) error { }) // Generate code for each lifted value - g.w = &liftedBuf for _, lifted := range sortedLifted { + g.startNewValueInit(lifted.varName) // Generate the value - this will write any needed initialization g.writef("var %s any\n", lifted.varName) g.pushVarScope() @@ -185,7 +199,7 @@ func (g *Generator) Generate(ns *lang.Namespace) error { var initBuf bytes.Buffer { // Reproduce the behavior of root-resource function - rootResourceName := "/" + ns.Name().String() + rootResourceName := ns.Name().String() rootResourceName = strings.ReplaceAll(rootResourceName, "-", "_") rootResourceName = strings.ReplaceAll(rootResourceName, ".", "/") initBuf.WriteString(`func init() { @@ -252,18 +266,81 @@ runtime.RegisterNSLoader(` + fmt.Sprintf("%q", rootResourceName) + `, LoadNS) initBuf.WriteString(fmt.Sprintf("%s := lang.InternVarName(%s, %s)\n", varName, g.allocSymVar(vi.ns), g.allocSymVar(vi.sym))) } - // Add lifted values if any - if liftedBuf.Len() > 0 { - initBuf.WriteString(strings.Repeat("/", 80)) - initBuf.WriteString("// Closed-over values\n") - initBuf.Write(liftedBuf.Bytes()) - initBuf.WriteString("\n") + ///////////////////////////// + // Var and closed-over value inits + + // NS boilerplate + initBuf.Write(nsBuf.Bytes()) + + { + sort.Slice(g.valueInits, func(i, j int) bool { + return g.valueInits[i].name < g.valueInits[j].name + }) + + dependents := make(map[string][]*valueInit) + + for _, vi := range g.valueInits { + for dep := range vi.deps { + if dep == vi.name { + continue // skip self-dependency + } + dependents[dep] = append(dependents[dep], vi) + } + } + // // print dependencies for debugging + // for _, vi := range g.valueInits { + // fmt.Printf("# %s\n", vi.name) + // for dep := range vi.deps { + // fmt.Printf(" -> %s\n", dep) + // } + // fmt.Println() + // } + + // Simple dependency resolution: repeatedly emit value inits that have no remaining deps + emitted := make(map[string]bool) + for len(emitted) < len(g.valueInits) { + progress := false + for _, vi := range g.valueInits { + if emitted[vi.name] { + continue // already emitted + } + // Check if all dependencies have been emitted + allDepsEmitted := true + for dep := range vi.deps { + if !emitted[dep] { + allDepsEmitted = false + break + } + } + if allDepsEmitted { + // Emit this value init + initBuf.WriteString(vi.buf.String()) + emitted[vi.name] = true + progress = true + // Remove this from dependents + for _, depVi := range dependents[vi.name] { + delete(depVi.deps, vi.name) + } + } + } + if !progress { + // Circular dependency detected; break the cycle by emitting one of the remaining inits + for _, vi := range g.valueInits { + if !emitted[vi.name] { + initBuf.WriteString(vi.buf.String()) + emitted[vi.name] = true + break + } + } + } + } } - // Add the vars code after the lifted values - initBuf.Write(varsBuf.Bytes()) + // Closing brace for LoadNS initBuf.WriteString("}\n") + //////////////////////////////////////////////////////////////////////////////// + // Prepare the final source sourceBytes := []byte(g.header(mungeID(getLastNSPart(ns.Name().String())))) // File header with package and imports sourceBytes = append(sourceBytes, initBuf.Bytes()...) // The complete init function @@ -290,6 +367,10 @@ func (g *Generator) generateVar(nsVariableName string, name *lang.Symbol, vr *la return nil } + // Generate code for the var + varVar := g.allocVarVar(vr.Namespace().Name().String(), name.String()) + g.startNewValueInit(varVar) + g.pushVarScope() defer g.popVarScope() @@ -307,11 +388,10 @@ func (g *Generator) generateVar(nsVariableName string, name *lang.Symbol, vr *la } // check if the var has a value - varVar := g.allocateTempVar() if vr.IsBound() { - g.writef("%s := %s.InternWithValue(%s, %s, true)\n", varVar, nsVariableName, varSym, g.generateValue(vr.Get())) + g.writef("%s = %s.InternWithValue(%s, %s, true)\n", varVar, nsVariableName, varSym, g.generateValue(vr.Get())) } else { - g.writef("%s := %s.Intern(%s)\n", varVar, nsVariableName, varSym) + g.writef("%s = %s.Intern(%s)\n", varVar, nsVariableName, varSym) } // Set metadata on the var if the symbol has metadata @@ -403,8 +483,6 @@ func (g *Generator) generateValue(value any) string { } func (g *Generator) generateTypeValue(t reflect.Type) string { - g.addImport("reflect") - resultId := g.allocateTempVar() // Generate the appropriate zero value expression based on the type @@ -951,6 +1029,10 @@ func (g *Generator) generateVarDeref(node *ast.Node) string { // Look up the var variable varId := g.allocVarVar(varNamespace.Name().String(), varSymbol.String()) + // add as a dependency to the current value init if we're in one + if g.currentValueInit != nil && varId != g.currentValueInit.name { + g.currentValueInit.deps[varId] = struct{}{} + } resultId := g.allocateTempVar() g.writef("%s := checkDerefVar(%s)\n", resultId, varId) @@ -1375,8 +1457,6 @@ func (g *Generator) generateHostCall(node *ast.Node) string { argIds[i] = g.generateASTNode(arg) } - g.addImport("reflect") - methodName := method.Name() methodId := g.allocateTempVar() g.writef("%s, _ := lang.FieldOrMethod(%s, %q)\n", methodId, tgtId, methodName) @@ -1402,8 +1482,6 @@ func (g *Generator) generateHostInterop(node *ast.Node) string { g.writef(" panic(lang.NewIllegalArgumentError(fmt.Sprintf(\"no such field or method on %%T: %%s\", %s, %q)))\n", tgtId, mOrF) g.writef("}\n") - g.addImport("reflect") - resultId := g.allocateTempVar() g.writef("var %s any\n", resultId) g.writef("switch reflect.TypeOf(%s).Kind() {\n", mOrFId) @@ -1517,7 +1595,7 @@ import ( } func (g *Generator) writef(format string, args ...any) error { - _, err := fmt.Fprintf(g.w, format, args...) + _, err := fmt.Fprintf(g.currentWriter, format, args...) return err } @@ -1529,6 +1607,17 @@ func (g *Generator) writeAssign(varName, rValue string) { g.writef("%s = %s\n", varName, rValue) } +func (g *Generator) startNewValueInit(name string) *valueInit { + valInit := &valueInit{ + name: name, + deps: make(map[string]struct{}), + } + g.currentValueInit = valInit + g.currentWriter = &valInit.buf + g.valueInits = append(g.valueInits, valInit) + return valInit +} + //////////////////////////////////////////////////////////////////////////////// // Variable scope management and other helpers @@ -1642,6 +1731,12 @@ func (g *Generator) getLocal(name string) string { value: value, varName: varName, } + + // Add as a dependency to the current value init if we're in one + if g.currentValueInit != nil && varName != g.currentValueInit.name { + g.currentValueInit.deps[varName] = struct{}{} + } + return varName } } diff --git a/pkg/runtime/codegen_test.go b/pkg/runtime/codegen_test.go index f1245147..28c4e481 100644 --- a/pkg/runtime/codegen_test.go +++ b/pkg/runtime/codegen_test.go @@ -11,7 +11,6 @@ import ( "strings" "testing" - "github.com/glojurelang/glojure/pkg/codegen" "github.com/glojurelang/glojure/pkg/glj" "github.com/glojurelang/glojure/pkg/lang" "github.com/glojurelang/glojure/pkg/reader" @@ -20,7 +19,7 @@ import ( func TestCodegen(t *testing.T) { var testFiles []string - err := filepath.Walk("testdata", func(path string, info os.FileInfo, err error) error { + err := filepath.Walk("testdata/codegen", func(path string, info os.FileInfo, err error) error { if err != nil { return err } @@ -84,7 +83,7 @@ func generateAndTestNamespace(t *testing.T, ns *lang.Namespace, goldenFile strin // Generate code for the namespace var buf bytes.Buffer - gen := codegen.NewGenerator(&buf) + gen := runtime.NewGenerator(&buf) if err := gen.Generate(ns); err != nil { if os.Getenv("UPDATE_SNAPSHOT") == "1" { // write the output anyway if we're updating the snapshot diff --git a/pkg/runtime/rtcompat.go b/pkg/runtime/rtcompat.go index 2f13ba16..032a6829 100644 --- a/pkg/runtime/rtcompat.go +++ b/pkg/runtime/rtcompat.go @@ -1,9 +1,12 @@ package runtime import ( + "bytes" "fmt" "io" "io/fs" + "os" + "path/filepath" "reflect" "strings" "sync" @@ -17,12 +20,25 @@ import ( ) var ( + // TODO: don't use a global RT instance; incurs overhead from dynamic lookup + // of methods. Instead, generate direct calls to functions in this package. RT = &RTMethods{} - loadPath = []fs.FS{stdlib.StdLib} + loadPath = []fs.FS{} loadPathLock sync.Mutex + + useAot = os.Getenv("GLOJURE_USE_AOT") == "1" ) +func init() { + stdlibPath := os.Getenv("GLOJURE_STDLIB_PATH") + if stdlibPath != "" { + AddLoadPath(os.DirFS(stdlibPath)) + } else { + AddLoadPath(stdlib.StdLib) + } +} + // AddLoadPath adds a filesystem to the load path. func AddLoadPath(fs fs.FS) { loadPathLock.Lock() @@ -130,10 +146,21 @@ func (rt *RTMethods) Load(scriptBase string) { PushThreadBindings(NewMap(kvs...)) defer PopThreadBindings() + if useAot { + // check nsloaders + if loader := GetNSLoader(strings.TrimPrefix(scriptBase, "/")); loader != nil { + fmt.Printf("Using custom loader for %s\n", scriptBase) + loader() + return + } + } + fmt.Printf("Loading %s\n", scriptBase) + filename := scriptBase + ".glj" var buf []byte var err error + var foundFS fs.FS loadPathLock.Lock() lp := loadPath @@ -141,6 +168,7 @@ func (rt *RTMethods) Load(scriptBase string) { for _, fs := range lp { buf, err = readFile(fs, filename) if err == nil { + foundFS = fs break } } @@ -148,6 +176,46 @@ func (rt *RTMethods) Load(scriptBase string) { panic(err) } ReadEval(string(buf), WithFilename(filename)) + + compileFiles := VarCompileFiles.Get().(bool) + if !compileFiles { + return + } + + compileNSToFile(foundFS, scriptBase) +} + +// compileNSToFile compiles the given namespace to a Go source file, +// given a fs.FS and the script base name (without extension). +func compileNSToFile(fs fs.FS, scriptBase string) { + // check if the found FS is writable + // we use the fact that os.DirFS(".") is just a named string type under the hood + if reflect.TypeOf(fs).Kind() != reflect.String { + panic(fmt.Errorf("cannot compile %s: filesystem is not writable", scriptBase)) + } + fsDir := fmt.Sprintf("%s", fs) + + // compile to .go files + targetDir := filepath.Join(fsDir, scriptBase) + targetFile := filepath.Join(targetDir, "loader.go") + fmt.Printf("Compiling %s to %s\n", scriptBase, targetFile) + + // ensure directory exists + err := os.MkdirAll(targetDir, 0755) + if err != nil { + panic(err) + } + + var buf bytes.Buffer + gen := NewGenerator(&buf) + currNS := VarCurrentNS.Deref().(*lang.Namespace) + if err = gen.Generate(currNS); err != nil { + panic(fmt.Errorf("failed to generate code for namespace %s: %w", currNS.Name(), err)) + } + err = os.WriteFile(targetFile, buf.Bytes(), 0644) + if err != nil { + panic(fmt.Errorf("failed to write generated code to %s: %w", targetFile, err)) + } } func readFile(fs fs.FS, filename string) ([]byte, error) { diff --git a/pkg/runtime/testdata/codegen/test/const_keyword/load.go.out b/pkg/runtime/testdata/codegen/test/const_keyword/load.go.out index 11e67d8f..840db50f 100644 --- a/pkg/runtime/testdata/codegen/test/const_keyword/load.go.out +++ b/pkg/runtime/testdata/codegen/test/const_keyword/load.go.out @@ -6,10 +6,11 @@ import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" runtime "github.com/glojurelang/glojure/pkg/runtime" + reflect "reflect" ) func init() { - runtime.RegisterNSLoader("codegen.test.const-keyword", LoadNS) + runtime.RegisterNSLoader("codegen/test/const_keyword", LoadNS) } func checkDerefVar(v *lang.Var) any { @@ -36,16 +37,20 @@ func LoadNS() { kw_foo := lang.NewKeyword("foo") kw_line := lang.NewKeyword("line") kw_ns := lang.NewKeyword("ns") + // var codegen.test.const-keyword/const-keyword + var_codegen_DOT_test_DOT_const_DASH_keyword_const_DASH_keyword := lang.InternVarName(sym_codegen_DOT_test_DOT_const_DASH_keyword, sym_const_DASH_keyword) // reference fmt to avoid unused import error _ = fmt.Printf + // reference reflect to avoid unused import error + _ = reflect.TypeOf ns := lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_const_DASH_keyword) _ = ns // const-keyword { tmp0 := sym_const_DASH_keyword.WithMeta(lang.NewMap(kw_file, "codegen/test/const_keyword.glj", kw_line, int(3), kw_column, int(6), kw_end_DASH_line, int(3), kw_end_DASH_column, int(18), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_const_DASH_keyword))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, kw_foo, true) + var_codegen_DOT_test_DOT_const_DASH_keyword_const_DASH_keyword = ns.InternWithValue(tmp0, kw_foo, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_codegen_DOT_test_DOT_const_DASH_keyword_const_DASH_keyword.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } } diff --git a/pkg/runtime/testdata/codegen/test/const_number/load.go.out b/pkg/runtime/testdata/codegen/test/const_number/load.go.out index e4e4a760..271013dd 100644 --- a/pkg/runtime/testdata/codegen/test/const_number/load.go.out +++ b/pkg/runtime/testdata/codegen/test/const_number/load.go.out @@ -6,10 +6,11 @@ import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" runtime "github.com/glojurelang/glojure/pkg/runtime" + reflect "reflect" ) func init() { - runtime.RegisterNSLoader("codegen.test.const-number", LoadNS) + runtime.RegisterNSLoader("codegen/test/const_number", LoadNS) } func checkDerefVar(v *lang.Var) any { @@ -36,16 +37,20 @@ func LoadNS() { kw_file := lang.NewKeyword("file") kw_line := lang.NewKeyword("line") kw_ns := lang.NewKeyword("ns") + // var codegen.test.const-number/const-number + var_codegen_DOT_test_DOT_const_DASH_number_const_DASH_number := lang.InternVarName(sym_codegen_DOT_test_DOT_const_DASH_number, sym_const_DASH_number) // reference fmt to avoid unused import error _ = fmt.Printf + // reference reflect to avoid unused import error + _ = reflect.TypeOf ns := lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_const_DASH_number) _ = ns // const-number { tmp0 := sym_const_DASH_number.WithMeta(lang.NewMap(kw_file, "codegen/test/const_number.glj", kw_line, int(3), kw_column, int(6), kw_end_DASH_line, int(3), kw_end_DASH_column, int(17), kw_doc, "A constant number.", kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_const_DASH_number))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, int64(42), true) + var_codegen_DOT_test_DOT_const_DASH_number_const_DASH_number = ns.InternWithValue(tmp0, int64(42), true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_codegen_DOT_test_DOT_const_DASH_number_const_DASH_number.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } } diff --git a/pkg/runtime/testdata/codegen/test/const_string/load.go.out b/pkg/runtime/testdata/codegen/test/const_string/load.go.out index e251fc7b..e9bc418d 100644 --- a/pkg/runtime/testdata/codegen/test/const_string/load.go.out +++ b/pkg/runtime/testdata/codegen/test/const_string/load.go.out @@ -6,10 +6,11 @@ import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" runtime "github.com/glojurelang/glojure/pkg/runtime" + reflect "reflect" ) func init() { - runtime.RegisterNSLoader("codegen.test.const-string", LoadNS) + runtime.RegisterNSLoader("codegen/test/const_string", LoadNS) } func checkDerefVar(v *lang.Var) any { @@ -36,16 +37,20 @@ func LoadNS() { kw_hello := lang.NewKeyword("hello") kw_line := lang.NewKeyword("line") kw_ns := lang.NewKeyword("ns") + // var codegen.test.const-string/const-string + var_codegen_DOT_test_DOT_const_DASH_string_const_DASH_string := lang.InternVarName(sym_codegen_DOT_test_DOT_const_DASH_string, sym_const_DASH_string) // reference fmt to avoid unused import error _ = fmt.Printf + // reference reflect to avoid unused import error + _ = reflect.TypeOf ns := lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_const_DASH_string) _ = ns // const-string { tmp0 := sym_const_DASH_string.WithMeta(lang.NewMap(kw_hello, true, kw_file, "codegen/test/const_string.glj", kw_line, int(3), kw_column, int(6), kw_end_DASH_line, int(3), kw_end_DASH_column, int(25), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_const_DASH_string))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, "Hello, World!", true) + var_codegen_DOT_test_DOT_const_DASH_string_const_DASH_string = ns.InternWithValue(tmp0, "Hello, World!", true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_codegen_DOT_test_DOT_const_DASH_string_const_DASH_string.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } } diff --git a/pkg/runtime/testdata/codegen/test/core/load.go.out b/pkg/runtime/testdata/codegen/test/core/load.go.out index acee8149..80f8253b 100644 --- a/pkg/runtime/testdata/codegen/test/core/load.go.out +++ b/pkg/runtime/testdata/codegen/test/core/load.go.out @@ -24,7 +24,7 @@ import ( ) func init() { - runtime.RegisterNSLoader("glojure.core", LoadNS) + runtime.RegisterNSLoader("glojure/core", LoadNS) } func checkDerefVar(v *lang.Var) any { @@ -255,24 +255,6 @@ func LoadNS() { sym_clauses := lang.NewSymbol("clauses") sym_clear_DASH_agent_DASH_errors := lang.NewSymbol("clear-agent-errors") sym_close := lang.NewSymbol("close") - sym_codegen_DOT_test_DOT_const_DASH_keyword := lang.NewSymbol("codegen.test.const-keyword") - sym_codegen_DOT_test_DOT_const_DASH_number := lang.NewSymbol("codegen.test.const-number") - sym_codegen_DOT_test_DOT_const_DASH_string := lang.NewSymbol("codegen.test.const-string") - sym_codegen_DOT_test_DOT_def_DASH_simple := lang.NewSymbol("codegen.test.def-simple") - sym_codegen_DOT_test_DOT_fn_DASH_closure := lang.NewSymbol("codegen.test.fn-closure") - sym_codegen_DOT_test_DOT_fn_DASH_recur := lang.NewSymbol("codegen.test.fn-recur") - sym_codegen_DOT_test_DOT_loop_DASH_simple := lang.NewSymbol("codegen.test.loop-simple") - sym_codegen_DOT_test_DOT_maybe_DASH_class := lang.NewSymbol("codegen.test.maybe-class") - sym_codegen_DOT_test_DOT_multifn := lang.NewSymbol("codegen.test.multifn") - sym_codegen_DOT_test_DOT_ns_DASH_skip := lang.NewSymbol("codegen.test.ns-skip") - sym_codegen_DOT_test_DOT_quote_DASH_simple := lang.NewSymbol("codegen.test.quote-simple") - sym_codegen_DOT_test_DOT_ref := lang.NewSymbol("codegen.test.ref") - sym_codegen_DOT_test_DOT_the_DASH_var := lang.NewSymbol("codegen.test.the-var") - sym_codegen_DOT_test_DOT_throw_DASH_simple := lang.NewSymbol("codegen.test.throw-simple") - sym_codegen_DOT_test_DOT_try_DASH_advanced := lang.NewSymbol("codegen.test.try-advanced") - sym_codegen_DOT_test_DOT_try_DASH_basic := lang.NewSymbol("codegen.test.try-basic") - sym_codegen_DOT_test_DOT_values := lang.NewSymbol("codegen.test.values") - sym_codegen_DOT_test_DOT_with_DASH_meta := lang.NewSymbol("codegen.test.with-meta") sym_coerce := lang.NewSymbol("coerce") sym_coll := lang.NewSymbol("coll") sym_coll_DASH_reduce := lang.NewSymbol("coll-reduce") @@ -1410,20 +1392,34 @@ func LoadNS() { var_glojure_DOT_core_DOT_protocols_kv_DASH_reduce := lang.InternVarName(sym_glojure_DOT_core_DOT_protocols, sym_kv_DASH_reduce) // var glojure.core.protocols/seq-reduce var_glojure_DOT_core_DOT_protocols_seq_DASH_reduce := lang.InternVarName(sym_glojure_DOT_core_DOT_protocols, sym_seq_DASH_reduce) + // var glojure.core/NaN? + var_glojure_DOT_core_NaN_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_NaN_QMARK_) // var glojure.core/StackTraceElement->vec var_glojure_DOT_core_StackTraceElement_DASH__GT_vec := lang.InternVarName(sym_glojure_DOT_core, sym_StackTraceElement_DASH__GT_vec) // var glojure.core/Throwable->map var_glojure_DOT_core_Throwable_DASH__GT_map := lang.InternVarName(sym_glojure_DOT_core, sym_Throwable_DASH__GT_map) // var glojure.core/- var_glojure_DOT_core__DASH_ := lang.InternVarName(sym_glojure_DOT_core, sym__DASH_) + // var glojure.core/-> + var_glojure_DOT_core__DASH__GT_ := lang.InternVarName(sym_glojure_DOT_core, sym__DASH__GT_) + // var glojure.core/->> + var_glojure_DOT_core__DASH__GT__GT_ := lang.InternVarName(sym_glojure_DOT_core, sym__DASH__GT__GT_) // var glojure.core/-' var_glojure_DOT_core__DASH__TICK_ := lang.InternVarName(sym_glojure_DOT_core, sym__DASH__TICK_) + // var glojure.core/-protocols + var_glojure_DOT_core__DASH_protocols := lang.InternVarName(sym_glojure_DOT_core, sym__DASH_protocols) + // var glojure.core/.. + var_glojure_DOT_core__DOT__DOT_ := lang.InternVarName(sym_glojure_DOT_core, sym__DOT__DOT_) // var glojure.core/= var_glojure_DOT_core__EQ_ := lang.InternVarName(sym_glojure_DOT_core, sym__EQ_) // var glojure.core/== var_glojure_DOT_core__EQ__EQ_ := lang.InternVarName(sym_glojure_DOT_core, sym__EQ__EQ_) // var glojure.core/> var_glojure_DOT_core__GT_ := lang.InternVarName(sym_glojure_DOT_core, sym__GT_) + // var glojure.core/>0? + var_glojure_DOT_core__GT_0_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym__GT_0_QMARK_) + // var glojure.core/>1? + var_glojure_DOT_core__GT_1_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym__GT_1_QMARK_) // var glojure.core/>= var_glojure_DOT_core__GT__EQ_ := lang.InternVarName(sym_glojure_DOT_core, sym__GT__EQ_) // var glojure.core/< @@ -1438,12 +1434,34 @@ func LoadNS() { var_glojure_DOT_core__SLASH_ := lang.InternVarName(sym_glojure_DOT_core, sym__SLASH_) // var glojure.core/* var_glojure_DOT_core__STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_) + // var glojure.core/*1 + var_glojure_DOT_core__STAR_1 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_1) + // var glojure.core/*2 + var_glojure_DOT_core__STAR_2 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_2) + // var glojure.core/*3 + var_glojure_DOT_core__STAR_3 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_3) // var glojure.core/*' var_glojure_DOT_core__STAR__TICK_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR__TICK_) // var glojure.core/*agent* var_glojure_DOT_core__STAR_agent_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_agent_STAR_) // var glojure.core/*assert* var_glojure_DOT_core__STAR_assert_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_assert_STAR_) + // var glojure.core/*command-line-args* + var_glojure_DOT_core__STAR_command_DASH_line_DASH_args_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_command_DASH_line_DASH_args_STAR_) + // var glojure.core/*compile-files* + var_glojure_DOT_core__STAR_compile_DASH_files_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_compile_DASH_files_STAR_) + // var glojure.core/*compile-path* + var_glojure_DOT_core__STAR_compile_DASH_path_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_compile_DASH_path_STAR_) + // var glojure.core/*compiler-options* + var_glojure_DOT_core__STAR_compiler_DASH_options_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_compiler_DASH_options_STAR_) + // var glojure.core/*data-readers* + var_glojure_DOT_core__STAR_data_DASH_readers_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_data_DASH_readers_STAR_) + // var glojure.core/*default-data-reader-fn* + var_glojure_DOT_core__STAR_default_DASH_data_DASH_reader_DASH_fn_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_default_DASH_data_DASH_reader_DASH_fn_STAR_) + // var glojure.core/*e + var_glojure_DOT_core__STAR_e := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_e) + // var glojure.core/*err* + var_glojure_DOT_core__STAR_err_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_err_STAR_) // var glojure.core/*file* var_glojure_DOT_core__STAR_file_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_file_STAR_) // var glojure.core/*flush-on-newline* @@ -1472,26 +1490,66 @@ func LoadNS() { var_glojure_DOT_core__STAR_print_DASH_namespace_DASH_maps_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_print_DASH_namespace_DASH_maps_STAR_) // var glojure.core/*print-readably* var_glojure_DOT_core__STAR_print_DASH_readably_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_print_DASH_readably_STAR_) + // var glojure.core/*read-eval* + var_glojure_DOT_core__STAR_read_DASH_eval_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_read_DASH_eval_STAR_) + // var glojure.core/*repl* + var_glojure_DOT_core__STAR_repl_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_repl_STAR_) // var glojure.core/*unchecked-math* var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_unchecked_DASH_math_STAR_) // var glojure.core/*verbose-defrecords* var_glojure_DOT_core__STAR_verbose_DASH_defrecords_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_verbose_DASH_defrecords_STAR_) + // var glojure.core/*warn-on-reflection* + var_glojure_DOT_core__STAR_warn_DASH_on_DASH_reflection_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_warn_DASH_on_DASH_reflection_STAR_) + // var glojure.core/abs + var_glojure_DOT_core_abs := lang.InternVarName(sym_glojure_DOT_core, sym_abs) + // var glojure.core/accessor + var_glojure_DOT_core_accessor := lang.InternVarName(sym_glojure_DOT_core, sym_accessor) + // var glojure.core/aclone + var_glojure_DOT_core_aclone := lang.InternVarName(sym_glojure_DOT_core, sym_aclone) + // var glojure.core/add-classpath + var_glojure_DOT_core_add_DASH_classpath := lang.InternVarName(sym_glojure_DOT_core, sym_add_DASH_classpath) + // var glojure.core/add-doc-and-meta + var_glojure_DOT_core_add_DASH_doc_DASH_and_DASH_meta := lang.InternVarName(sym_glojure_DOT_core, sym_add_DASH_doc_DASH_and_DASH_meta) + // var glojure.core/add-watch + var_glojure_DOT_core_add_DASH_watch := lang.InternVarName(sym_glojure_DOT_core, sym_add_DASH_watch) // var glojure.core/agent var_glojure_DOT_core_agent := lang.InternVarName(sym_glojure_DOT_core, sym_agent) // var glojure.core/agent-error var_glojure_DOT_core_agent_DASH_error := lang.InternVarName(sym_glojure_DOT_core, sym_agent_DASH_error) + // var glojure.core/agent-errors + var_glojure_DOT_core_agent_DASH_errors := lang.InternVarName(sym_glojure_DOT_core, sym_agent_DASH_errors) // var glojure.core/aget var_glojure_DOT_core_aget := lang.InternVarName(sym_glojure_DOT_core, sym_aget) // var glojure.core/alength var_glojure_DOT_core_alength := lang.InternVarName(sym_glojure_DOT_core, sym_alength) // var glojure.core/alias var_glojure_DOT_core_alias := lang.InternVarName(sym_glojure_DOT_core, sym_alias) + // var glojure.core/all-ns + var_glojure_DOT_core_all_DASH_ns := lang.InternVarName(sym_glojure_DOT_core, sym_all_DASH_ns) + // var glojure.core/alter + var_glojure_DOT_core_alter := lang.InternVarName(sym_glojure_DOT_core, sym_alter) + // var glojure.core/alter-meta! + var_glojure_DOT_core_alter_DASH_meta_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_alter_DASH_meta_BANG_) // var glojure.core/alter-var-root var_glojure_DOT_core_alter_DASH_var_DASH_root := lang.InternVarName(sym_glojure_DOT_core, sym_alter_DASH_var_DASH_root) + // var glojure.core/amap + var_glojure_DOT_core_amap := lang.InternVarName(sym_glojure_DOT_core, sym_amap) // var glojure.core/ancestors var_glojure_DOT_core_ancestors := lang.InternVarName(sym_glojure_DOT_core, sym_ancestors) + // var glojure.core/and + var_glojure_DOT_core_and := lang.InternVarName(sym_glojure_DOT_core, sym_and) + // var glojure.core/any? + var_glojure_DOT_core_any_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_any_QMARK_) // var glojure.core/apply var_glojure_DOT_core_apply := lang.InternVarName(sym_glojure_DOT_core, sym_apply) + // var glojure.core/areduce + var_glojure_DOT_core_areduce := lang.InternVarName(sym_glojure_DOT_core, sym_areduce) + // var glojure.core/array + var_glojure_DOT_core_array := lang.InternVarName(sym_glojure_DOT_core, sym_array) + // var glojure.core/array-map + var_glojure_DOT_core_array_DASH_map := lang.InternVarName(sym_glojure_DOT_core, sym_array_DASH_map) + // var glojure.core/as-> + var_glojure_DOT_core_as_DASH__GT_ := lang.InternVarName(sym_glojure_DOT_core, sym_as_DASH__GT_) // var glojure.core/aset var_glojure_DOT_core_aset := lang.InternVarName(sym_glojure_DOT_core, sym_aset) // var glojure.core/aset-boolean @@ -1510,6 +1568,10 @@ func LoadNS() { var_glojure_DOT_core_aset_DASH_long := lang.InternVarName(sym_glojure_DOT_core, sym_aset_DASH_long) // var glojure.core/aset-short var_glojure_DOT_core_aset_DASH_short := lang.InternVarName(sym_glojure_DOT_core, sym_aset_DASH_short) + // var glojure.core/assert + var_glojure_DOT_core_assert := lang.InternVarName(sym_glojure_DOT_core, sym_assert) + // var glojure.core/assert-args + var_glojure_DOT_core_assert_DASH_args := lang.InternVarName(sym_glojure_DOT_core, sym_assert_DASH_args) // var glojure.core/assert-valid-fdecl var_glojure_DOT_core_assert_DASH_valid_DASH_fdecl := lang.InternVarName(sym_glojure_DOT_core, sym_assert_DASH_valid_DASH_fdecl) // var glojure.core/assoc @@ -1518,44 +1580,96 @@ func LoadNS() { var_glojure_DOT_core_assoc_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_assoc_BANG_) // var glojure.core/assoc-in var_glojure_DOT_core_assoc_DASH_in := lang.InternVarName(sym_glojure_DOT_core, sym_assoc_DASH_in) + // var glojure.core/associative? + var_glojure_DOT_core_associative_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_associative_QMARK_) // var glojure.core/atom var_glojure_DOT_core_atom := lang.InternVarName(sym_glojure_DOT_core, sym_atom) // var glojure.core/await var_glojure_DOT_core_await := lang.InternVarName(sym_glojure_DOT_core, sym_await) + // var glojure.core/await1 + var_glojure_DOT_core_await1 := lang.InternVarName(sym_glojure_DOT_core, sym_await1) + // var glojure.core/await-for + var_glojure_DOT_core_await_DASH_for := lang.InternVarName(sym_glojure_DOT_core, sym_await_DASH_for) // var glojure.core/bases var_glojure_DOT_core_bases := lang.InternVarName(sym_glojure_DOT_core, sym_bases) + // var glojure.core/bigdec + var_glojure_DOT_core_bigdec := lang.InternVarName(sym_glojure_DOT_core, sym_bigdec) // var glojure.core/bigint var_glojure_DOT_core_bigint := lang.InternVarName(sym_glojure_DOT_core, sym_bigint) + // var glojure.core/biginteger + var_glojure_DOT_core_biginteger := lang.InternVarName(sym_glojure_DOT_core, sym_biginteger) + // var glojure.core/binding + var_glojure_DOT_core_binding := lang.InternVarName(sym_glojure_DOT_core, sym_binding) // var glojure.core/binding-conveyor-fn var_glojure_DOT_core_binding_DASH_conveyor_DASH_fn := lang.InternVarName(sym_glojure_DOT_core, sym_binding_DASH_conveyor_DASH_fn) // var glojure.core/bit-and var_glojure_DOT_core_bit_DASH_and := lang.InternVarName(sym_glojure_DOT_core, sym_bit_DASH_and) // var glojure.core/bit-and-not var_glojure_DOT_core_bit_DASH_and_DASH_not := lang.InternVarName(sym_glojure_DOT_core, sym_bit_DASH_and_DASH_not) + // var glojure.core/bit-clear + var_glojure_DOT_core_bit_DASH_clear := lang.InternVarName(sym_glojure_DOT_core, sym_bit_DASH_clear) + // var glojure.core/bit-flip + var_glojure_DOT_core_bit_DASH_flip := lang.InternVarName(sym_glojure_DOT_core, sym_bit_DASH_flip) + // var glojure.core/bit-not + var_glojure_DOT_core_bit_DASH_not := lang.InternVarName(sym_glojure_DOT_core, sym_bit_DASH_not) // var glojure.core/bit-or var_glojure_DOT_core_bit_DASH_or := lang.InternVarName(sym_glojure_DOT_core, sym_bit_DASH_or) + // var glojure.core/bit-set + var_glojure_DOT_core_bit_DASH_set := lang.InternVarName(sym_glojure_DOT_core, sym_bit_DASH_set) // var glojure.core/bit-shift-left var_glojure_DOT_core_bit_DASH_shift_DASH_left := lang.InternVarName(sym_glojure_DOT_core, sym_bit_DASH_shift_DASH_left) // var glojure.core/bit-shift-right var_glojure_DOT_core_bit_DASH_shift_DASH_right := lang.InternVarName(sym_glojure_DOT_core, sym_bit_DASH_shift_DASH_right) + // var glojure.core/bit-test + var_glojure_DOT_core_bit_DASH_test := lang.InternVarName(sym_glojure_DOT_core, sym_bit_DASH_test) // var glojure.core/bit-xor var_glojure_DOT_core_bit_DASH_xor := lang.InternVarName(sym_glojure_DOT_core, sym_bit_DASH_xor) // var glojure.core/boolean var_glojure_DOT_core_boolean := lang.InternVarName(sym_glojure_DOT_core, sym_boolean) + // var glojure.core/boolean-array + var_glojure_DOT_core_boolean_DASH_array := lang.InternVarName(sym_glojure_DOT_core, sym_boolean_DASH_array) + // var glojure.core/boolean? + var_glojure_DOT_core_boolean_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_boolean_QMARK_) + // var glojure.core/booleans + var_glojure_DOT_core_booleans := lang.InternVarName(sym_glojure_DOT_core, sym_booleans) + // var glojure.core/bound-fn + var_glojure_DOT_core_bound_DASH_fn := lang.InternVarName(sym_glojure_DOT_core, sym_bound_DASH_fn) + // var glojure.core/bound-fn* + var_glojure_DOT_core_bound_DASH_fn_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym_bound_DASH_fn_STAR_) + // var glojure.core/bound? + var_glojure_DOT_core_bound_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_bound_QMARK_) + // var glojure.core/bounded-count + var_glojure_DOT_core_bounded_DASH_count := lang.InternVarName(sym_glojure_DOT_core, sym_bounded_DASH_count) // var glojure.core/butlast var_glojure_DOT_core_butlast := lang.InternVarName(sym_glojure_DOT_core, sym_butlast) // var glojure.core/byte var_glojure_DOT_core_byte := lang.InternVarName(sym_glojure_DOT_core, sym_byte) + // var glojure.core/byte-array + var_glojure_DOT_core_byte_DASH_array := lang.InternVarName(sym_glojure_DOT_core, sym_byte_DASH_array) + // var glojure.core/bytes + var_glojure_DOT_core_bytes := lang.InternVarName(sym_glojure_DOT_core, sym_bytes) + // var glojure.core/bytes? + var_glojure_DOT_core_bytes_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_bytes_QMARK_) + // var glojure.core/case + var_glojure_DOT_core_case := lang.InternVarName(sym_glojure_DOT_core, sym_case) // var glojure.core/case-map var_glojure_DOT_core_case_DASH_map := lang.InternVarName(sym_glojure_DOT_core, sym_case_DASH_map) + // var glojure.core/cast + var_glojure_DOT_core_cast := lang.InternVarName(sym_glojure_DOT_core, sym_cast) // var glojure.core/cat var_glojure_DOT_core_cat := lang.InternVarName(sym_glojure_DOT_core, sym_cat) // var glojure.core/char var_glojure_DOT_core_char := lang.InternVarName(sym_glojure_DOT_core, sym_char) + // var glojure.core/char-array + var_glojure_DOT_core_char_DASH_array := lang.InternVarName(sym_glojure_DOT_core, sym_char_DASH_array) // var glojure.core/char-escape-string var_glojure_DOT_core_char_DASH_escape_DASH_string := lang.InternVarName(sym_glojure_DOT_core, sym_char_DASH_escape_DASH_string) // var glojure.core/char-name-string var_glojure_DOT_core_char_DASH_name_DASH_string := lang.InternVarName(sym_glojure_DOT_core, sym_char_DASH_name_DASH_string) + // var glojure.core/char? + var_glojure_DOT_core_char_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_char_QMARK_) + // var glojure.core/chars + var_glojure_DOT_core_chars := lang.InternVarName(sym_glojure_DOT_core, sym_chars) // var glojure.core/check-cyclic-dependency var_glojure_DOT_core_check_DASH_cyclic_DASH_dependency := lang.InternVarName(sym_glojure_DOT_core, sym_check_DASH_cyclic_DASH_dependency) // var glojure.core/check-valid-options @@ -1580,26 +1694,46 @@ func LoadNS() { var_glojure_DOT_core_class := lang.InternVarName(sym_glojure_DOT_core, sym_class) // var glojure.core/class? var_glojure_DOT_core_class_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_class_QMARK_) + // var glojure.core/clear-agent-errors + var_glojure_DOT_core_clear_DASH_agent_DASH_errors := lang.InternVarName(sym_glojure_DOT_core, sym_clear_DASH_agent_DASH_errors) + // var glojure.core/coll? + var_glojure_DOT_core_coll_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_coll_QMARK_) + // var glojure.core/comment + var_glojure_DOT_core_comment := lang.InternVarName(sym_glojure_DOT_core, sym_comment) // var glojure.core/commute var_glojure_DOT_core_commute := lang.InternVarName(sym_glojure_DOT_core, sym_commute) // var glojure.core/comp var_glojure_DOT_core_comp := lang.InternVarName(sym_glojure_DOT_core, sym_comp) + // var glojure.core/comparator + var_glojure_DOT_core_comparator := lang.InternVarName(sym_glojure_DOT_core, sym_comparator) // var glojure.core/compare var_glojure_DOT_core_compare := lang.InternVarName(sym_glojure_DOT_core, sym_compare) // var glojure.core/compare-and-set! var_glojure_DOT_core_compare_DASH_and_DASH_set_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_compare_DASH_and_DASH_set_BANG_) + // var glojure.core/compile + var_glojure_DOT_core_compile := lang.InternVarName(sym_glojure_DOT_core, sym_compile) // var glojure.core/complement var_glojure_DOT_core_complement := lang.InternVarName(sym_glojure_DOT_core, sym_complement) // var glojure.core/completing var_glojure_DOT_core_completing := lang.InternVarName(sym_glojure_DOT_core, sym_completing) // var glojure.core/concat var_glojure_DOT_core_concat := lang.InternVarName(sym_glojure_DOT_core, sym_concat) + // var glojure.core/cond + var_glojure_DOT_core_cond := lang.InternVarName(sym_glojure_DOT_core, sym_cond) + // var glojure.core/cond-> + var_glojure_DOT_core_cond_DASH__GT_ := lang.InternVarName(sym_glojure_DOT_core, sym_cond_DASH__GT_) + // var glojure.core/cond->> + var_glojure_DOT_core_cond_DASH__GT__GT_ := lang.InternVarName(sym_glojure_DOT_core, sym_cond_DASH__GT__GT_) + // var glojure.core/condp + var_glojure_DOT_core_condp := lang.InternVarName(sym_glojure_DOT_core, sym_condp) // var glojure.core/conj var_glojure_DOT_core_conj := lang.InternVarName(sym_glojure_DOT_core, sym_conj) // var glojure.core/conj! var_glojure_DOT_core_conj_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_conj_BANG_) // var glojure.core/cons var_glojure_DOT_core_cons := lang.InternVarName(sym_glojure_DOT_core, sym_cons) + // var glojure.core/constantly + var_glojure_DOT_core_constantly := lang.InternVarName(sym_glojure_DOT_core, sym_constantly) // var glojure.core/contains? var_glojure_DOT_core_contains_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_contains_QMARK_) // var glojure.core/count @@ -1610,16 +1744,50 @@ func LoadNS() { var_glojure_DOT_core_create_DASH_ns := lang.InternVarName(sym_glojure_DOT_core, sym_create_DASH_ns) // var glojure.core/create-struct var_glojure_DOT_core_create_DASH_struct := lang.InternVarName(sym_glojure_DOT_core, sym_create_DASH_struct) + // var glojure.core/cycle + var_glojure_DOT_core_cycle := lang.InternVarName(sym_glojure_DOT_core, sym_cycle) // var glojure.core/data-reader-urls var_glojure_DOT_core_data_DASH_reader_DASH_urls := lang.InternVarName(sym_glojure_DOT_core, sym_data_DASH_reader_DASH_urls) // var glojure.core/data-reader-var var_glojure_DOT_core_data_DASH_reader_DASH_var := lang.InternVarName(sym_glojure_DOT_core, sym_data_DASH_reader_DASH_var) // var glojure.core/dec var_glojure_DOT_core_dec := lang.InternVarName(sym_glojure_DOT_core, sym_dec) + // var glojure.core/dec' + var_glojure_DOT_core_dec_TICK_ := lang.InternVarName(sym_glojure_DOT_core, sym_dec_TICK_) // var glojure.core/decimal? var_glojure_DOT_core_decimal_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_decimal_QMARK_) + // var glojure.core/declare + var_glojure_DOT_core_declare := lang.InternVarName(sym_glojure_DOT_core, sym_declare) // var glojure.core/dedupe var_glojure_DOT_core_dedupe := lang.InternVarName(sym_glojure_DOT_core, sym_dedupe) + // var glojure.core/def-aset + var_glojure_DOT_core_def_DASH_aset := lang.InternVarName(sym_glojure_DOT_core, sym_def_DASH_aset) + // var glojure.core/definline + var_glojure_DOT_core_definline := lang.InternVarName(sym_glojure_DOT_core, sym_definline) + // var glojure.core/defmacro + var_glojure_DOT_core_defmacro := lang.InternVarName(sym_glojure_DOT_core, sym_defmacro) + // var glojure.core/defmethod + var_glojure_DOT_core_defmethod := lang.InternVarName(sym_glojure_DOT_core, sym_defmethod) + // var glojure.core/defmulti + var_glojure_DOT_core_defmulti := lang.InternVarName(sym_glojure_DOT_core, sym_defmulti) + // var glojure.core/defn + var_glojure_DOT_core_defn := lang.InternVarName(sym_glojure_DOT_core, sym_defn) + // var glojure.core/defn- + var_glojure_DOT_core_defn_DASH_ := lang.InternVarName(sym_glojure_DOT_core, sym_defn_DASH_) + // var glojure.core/defonce + var_glojure_DOT_core_defonce := lang.InternVarName(sym_glojure_DOT_core, sym_defonce) + // var glojure.core/defprotocol + var_glojure_DOT_core_defprotocol := lang.InternVarName(sym_glojure_DOT_core, sym_defprotocol) + // var glojure.core/defstruct + var_glojure_DOT_core_defstruct := lang.InternVarName(sym_glojure_DOT_core, sym_defstruct) + // var glojure.core/delay + var_glojure_DOT_core_delay := lang.InternVarName(sym_glojure_DOT_core, sym_delay) + // var glojure.core/delay? + var_glojure_DOT_core_delay_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_delay_QMARK_) + // var glojure.core/deliver + var_glojure_DOT_core_deliver := lang.InternVarName(sym_glojure_DOT_core, sym_deliver) + // var glojure.core/denominator + var_glojure_DOT_core_denominator := lang.InternVarName(sym_glojure_DOT_core, sym_denominator) // var glojure.core/deref var_glojure_DOT_core_deref := lang.InternVarName(sym_glojure_DOT_core, sym_deref) // var glojure.core/deref-as-map @@ -1634,16 +1802,36 @@ func LoadNS() { var_glojure_DOT_core_destructure := lang.InternVarName(sym_glojure_DOT_core, sym_destructure) // var glojure.core/disj var_glojure_DOT_core_disj := lang.InternVarName(sym_glojure_DOT_core, sym_disj) + // var glojure.core/disj! + var_glojure_DOT_core_disj_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_disj_BANG_) // var glojure.core/dissoc var_glojure_DOT_core_dissoc := lang.InternVarName(sym_glojure_DOT_core, sym_dissoc) + // var glojure.core/dissoc! + var_glojure_DOT_core_dissoc_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_dissoc_BANG_) + // var glojure.core/distinct + var_glojure_DOT_core_distinct := lang.InternVarName(sym_glojure_DOT_core, sym_distinct) // var glojure.core/distinct? var_glojure_DOT_core_distinct_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_distinct_QMARK_) // var glojure.core/doall var_glojure_DOT_core_doall := lang.InternVarName(sym_glojure_DOT_core, sym_doall) // var glojure.core/dorun var_glojure_DOT_core_dorun := lang.InternVarName(sym_glojure_DOT_core, sym_dorun) + // var glojure.core/doseq + var_glojure_DOT_core_doseq := lang.InternVarName(sym_glojure_DOT_core, sym_doseq) + // var glojure.core/dosync + var_glojure_DOT_core_dosync := lang.InternVarName(sym_glojure_DOT_core, sym_dosync) + // var glojure.core/dotimes + var_glojure_DOT_core_dotimes := lang.InternVarName(sym_glojure_DOT_core, sym_dotimes) + // var glojure.core/doto + var_glojure_DOT_core_doto := lang.InternVarName(sym_glojure_DOT_core, sym_doto) // var glojure.core/double var_glojure_DOT_core_double := lang.InternVarName(sym_glojure_DOT_core, sym_double) + // var glojure.core/double-array + var_glojure_DOT_core_double_DASH_array := lang.InternVarName(sym_glojure_DOT_core, sym_double_DASH_array) + // var glojure.core/double? + var_glojure_DOT_core_double_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_double_QMARK_) + // var glojure.core/doubles + var_glojure_DOT_core_doubles := lang.InternVarName(sym_glojure_DOT_core, sym_doubles) // var glojure.core/drop var_glojure_DOT_core_drop := lang.InternVarName(sym_glojure_DOT_core, sym_drop) // var glojure.core/drop-last @@ -1658,30 +1846,62 @@ func LoadNS() { var_glojure_DOT_core_emit_DASH_extend_DASH_type := lang.InternVarName(sym_glojure_DOT_core, sym_emit_DASH_extend_DASH_type) // var glojure.core/emit-hinted-impl var_glojure_DOT_core_emit_DASH_hinted_DASH_impl := lang.InternVarName(sym_glojure_DOT_core, sym_emit_DASH_hinted_DASH_impl) + // var glojure.core/empty + var_glojure_DOT_core_empty := lang.InternVarName(sym_glojure_DOT_core, sym_empty) // var glojure.core/empty? var_glojure_DOT_core_empty_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_empty_QMARK_) + // var glojure.core/ensure + var_glojure_DOT_core_ensure := lang.InternVarName(sym_glojure_DOT_core, sym_ensure) // var glojure.core/ensure-reduced var_glojure_DOT_core_ensure_DASH_reduced := lang.InternVarName(sym_glojure_DOT_core, sym_ensure_DASH_reduced) + // var glojure.core/enumeration-seq + var_glojure_DOT_core_enumeration_DASH_seq := lang.InternVarName(sym_glojure_DOT_core, sym_enumeration_DASH_seq) + // var glojure.core/error-handler + var_glojure_DOT_core_error_DASH_handler := lang.InternVarName(sym_glojure_DOT_core, sym_error_DASH_handler) + // var glojure.core/error-mode + var_glojure_DOT_core_error_DASH_mode := lang.InternVarName(sym_glojure_DOT_core, sym_error_DASH_mode) // var glojure.core/eval var_glojure_DOT_core_eval := lang.InternVarName(sym_glojure_DOT_core, sym_eval) // var glojure.core/even? var_glojure_DOT_core_even_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_even_QMARK_) + // var glojure.core/every-pred + var_glojure_DOT_core_every_DASH_pred := lang.InternVarName(sym_glojure_DOT_core, sym_every_DASH_pred) // var glojure.core/every? var_glojure_DOT_core_every_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_every_QMARK_) + // var glojure.core/ex-cause + var_glojure_DOT_core_ex_DASH_cause := lang.InternVarName(sym_glojure_DOT_core, sym_ex_DASH_cause) // var glojure.core/ex-data var_glojure_DOT_core_ex_DASH_data := lang.InternVarName(sym_glojure_DOT_core, sym_ex_DASH_data) // var glojure.core/ex-info var_glojure_DOT_core_ex_DASH_info := lang.InternVarName(sym_glojure_DOT_core, sym_ex_DASH_info) + // var glojure.core/ex-message + var_glojure_DOT_core_ex_DASH_message := lang.InternVarName(sym_glojure_DOT_core, sym_ex_DASH_message) + // var glojure.core/extend + var_glojure_DOT_core_extend := lang.InternVarName(sym_glojure_DOT_core, sym_extend) + // var glojure.core/extend-protocol + var_glojure_DOT_core_extend_DASH_protocol := lang.InternVarName(sym_glojure_DOT_core, sym_extend_DASH_protocol) + // var glojure.core/extend-type + var_glojure_DOT_core_extend_DASH_type := lang.InternVarName(sym_glojure_DOT_core, sym_extend_DASH_type) + // var glojure.core/false? + var_glojure_DOT_core_false_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_false_QMARK_) // var glojure.core/ffirst var_glojure_DOT_core_ffirst := lang.InternVarName(sym_glojure_DOT_core, sym_ffirst) + // var glojure.core/file-seq + var_glojure_DOT_core_file_DASH_seq := lang.InternVarName(sym_glojure_DOT_core, sym_file_DASH_seq) // var glojure.core/filter var_glojure_DOT_core_filter := lang.InternVarName(sym_glojure_DOT_core, sym_filter) // var glojure.core/filter-key var_glojure_DOT_core_filter_DASH_key := lang.InternVarName(sym_glojure_DOT_core, sym_filter_DASH_key) + // var glojure.core/filterv + var_glojure_DOT_core_filterv := lang.InternVarName(sym_glojure_DOT_core, sym_filterv) // var glojure.core/find var_glojure_DOT_core_find := lang.InternVarName(sym_glojure_DOT_core, sym_find) + // var glojure.core/find-keyword + var_glojure_DOT_core_find_DASH_keyword := lang.InternVarName(sym_glojure_DOT_core, sym_find_DASH_keyword) // var glojure.core/find-ns var_glojure_DOT_core_find_DASH_ns := lang.InternVarName(sym_glojure_DOT_core, sym_find_DASH_ns) + // var glojure.core/find-var + var_glojure_DOT_core_find_DASH_var := lang.InternVarName(sym_glojure_DOT_core, sym_find_DASH_var) // var glojure.core/first var_glojure_DOT_core_first := lang.InternVarName(sym_glojure_DOT_core, sym_first) // var glojure.core/fits-table? @@ -1690,48 +1910,106 @@ func LoadNS() { var_glojure_DOT_core_flatten := lang.InternVarName(sym_glojure_DOT_core, sym_flatten) // var glojure.core/float var_glojure_DOT_core_float := lang.InternVarName(sym_glojure_DOT_core, sym_float) + // var glojure.core/float-array + var_glojure_DOT_core_float_DASH_array := lang.InternVarName(sym_glojure_DOT_core, sym_float_DASH_array) // var glojure.core/float? var_glojure_DOT_core_float_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_float_QMARK_) + // var glojure.core/floats + var_glojure_DOT_core_floats := lang.InternVarName(sym_glojure_DOT_core, sym_floats) // var glojure.core/flush var_glojure_DOT_core_flush := lang.InternVarName(sym_glojure_DOT_core, sym_flush) + // var glojure.core/fn + var_glojure_DOT_core_fn := lang.InternVarName(sym_glojure_DOT_core, sym_fn) // var glojure.core/fn? var_glojure_DOT_core_fn_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_fn_QMARK_) + // var glojure.core/fnext + var_glojure_DOT_core_fnext := lang.InternVarName(sym_glojure_DOT_core, sym_fnext) // var glojure.core/fnil var_glojure_DOT_core_fnil := lang.InternVarName(sym_glojure_DOT_core, sym_fnil) + // var glojure.core/for + var_glojure_DOT_core_for := lang.InternVarName(sym_glojure_DOT_core, sym_for) + // var glojure.core/force + var_glojure_DOT_core_force := lang.InternVarName(sym_glojure_DOT_core, sym_force) // var glojure.core/format var_glojure_DOT_core_format := lang.InternVarName(sym_glojure_DOT_core, sym_format) + // var glojure.core/frequencies + var_glojure_DOT_core_frequencies := lang.InternVarName(sym_glojure_DOT_core, sym_frequencies) + // var glojure.core/future + var_glojure_DOT_core_future := lang.InternVarName(sym_glojure_DOT_core, sym_future) // var glojure.core/future-call var_glojure_DOT_core_future_DASH_call := lang.InternVarName(sym_glojure_DOT_core, sym_future_DASH_call) + // var glojure.core/future-cancel + var_glojure_DOT_core_future_DASH_cancel := lang.InternVarName(sym_glojure_DOT_core, sym_future_DASH_cancel) + // var glojure.core/future-cancelled? + var_glojure_DOT_core_future_DASH_cancelled_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_future_DASH_cancelled_QMARK_) + // var glojure.core/future-done? + var_glojure_DOT_core_future_DASH_done_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_future_DASH_done_QMARK_) + // var glojure.core/future? + var_glojure_DOT_core_future_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_future_QMARK_) + // var glojure.core/gen-class + var_glojure_DOT_core_gen_DASH_class := lang.InternVarName(sym_glojure_DOT_core, sym_gen_DASH_class) // var glojure.core/gensym var_glojure_DOT_core_gensym := lang.InternVarName(sym_glojure_DOT_core, sym_gensym) // var glojure.core/get var_glojure_DOT_core_get := lang.InternVarName(sym_glojure_DOT_core, sym_get) // var glojure.core/get-in var_glojure_DOT_core_get_DASH_in := lang.InternVarName(sym_glojure_DOT_core, sym_get_DASH_in) + // var glojure.core/get-method + var_glojure_DOT_core_get_DASH_method := lang.InternVarName(sym_glojure_DOT_core, sym_get_DASH_method) // var glojure.core/get-thread-bindings var_glojure_DOT_core_get_DASH_thread_DASH_bindings := lang.InternVarName(sym_glojure_DOT_core, sym_get_DASH_thread_DASH_bindings) + // var glojure.core/get-validator + var_glojure_DOT_core_get_DASH_validator := lang.InternVarName(sym_glojure_DOT_core, sym_get_DASH_validator) // var glojure.core/global-hierarchy var_glojure_DOT_core_global_DASH_hierarchy := lang.InternVarName(sym_glojure_DOT_core, sym_global_DASH_hierarchy) + // var glojure.core/group-by + var_glojure_DOT_core_group_DASH_by := lang.InternVarName(sym_glojure_DOT_core, sym_group_DASH_by) // var glojure.core/halt-when var_glojure_DOT_core_halt_DASH_when := lang.InternVarName(sym_glojure_DOT_core, sym_halt_DASH_when) + // var glojure.core/hash + var_glojure_DOT_core_hash := lang.InternVarName(sym_glojure_DOT_core, sym_hash) // var glojure.core/hash-map var_glojure_DOT_core_hash_DASH_map := lang.InternVarName(sym_glojure_DOT_core, sym_hash_DASH_map) + // var glojure.core/hash-ordered-coll + var_glojure_DOT_core_hash_DASH_ordered_DASH_coll := lang.InternVarName(sym_glojure_DOT_core, sym_hash_DASH_ordered_DASH_coll) // var glojure.core/hash-set var_glojure_DOT_core_hash_DASH_set := lang.InternVarName(sym_glojure_DOT_core, sym_hash_DASH_set) + // var glojure.core/hash-unordered-coll + var_glojure_DOT_core_hash_DASH_unordered_DASH_coll := lang.InternVarName(sym_glojure_DOT_core, sym_hash_DASH_unordered_DASH_coll) // var glojure.core/ident? var_glojure_DOT_core_ident_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_ident_QMARK_) // var glojure.core/identical? var_glojure_DOT_core_identical_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_identical_QMARK_) // var glojure.core/identity var_glojure_DOT_core_identity := lang.InternVarName(sym_glojure_DOT_core, sym_identity) + // var glojure.core/if-let + var_glojure_DOT_core_if_DASH_let := lang.InternVarName(sym_glojure_DOT_core, sym_if_DASH_let) + // var glojure.core/if-not + var_glojure_DOT_core_if_DASH_not := lang.InternVarName(sym_glojure_DOT_core, sym_if_DASH_not) + // var glojure.core/if-some + var_glojure_DOT_core_if_DASH_some := lang.InternVarName(sym_glojure_DOT_core, sym_if_DASH_some) + // var glojure.core/ifn? + var_glojure_DOT_core_ifn_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_ifn_QMARK_) + // var glojure.core/import + var_glojure_DOT_core_import := lang.InternVarName(sym_glojure_DOT_core, sym_import) // var glojure.core/inc var_glojure_DOT_core_inc := lang.InternVarName(sym_glojure_DOT_core, sym_inc) // var glojure.core/inc' var_glojure_DOT_core_inc_TICK_ := lang.InternVarName(sym_glojure_DOT_core, sym_inc_TICK_) + // var glojure.core/indexed? + var_glojure_DOT_core_indexed_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_indexed_QMARK_) + // var glojure.core/infinite? + var_glojure_DOT_core_infinite_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_infinite_QMARK_) + // var glojure.core/inst-ms + var_glojure_DOT_core_inst_DASH_ms := lang.InternVarName(sym_glojure_DOT_core, sym_inst_DASH_ms) + // var glojure.core/inst? + var_glojure_DOT_core_inst_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_inst_QMARK_) // var glojure.core/instance? var_glojure_DOT_core_instance_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_instance_QMARK_) // var glojure.core/int var_glojure_DOT_core_int := lang.InternVarName(sym_glojure_DOT_core, sym_int) + // var glojure.core/int-array + var_glojure_DOT_core_int_DASH_array := lang.InternVarName(sym_glojure_DOT_core, sym_int_DASH_array) // var glojure.core/int? var_glojure_DOT_core_int_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_int_QMARK_) // var glojure.core/integer? @@ -1748,14 +2026,24 @@ func LoadNS() { var_glojure_DOT_core_into1 := lang.InternVarName(sym_glojure_DOT_core, sym_into1) // var glojure.core/into-array var_glojure_DOT_core_into_DASH_array := lang.InternVarName(sym_glojure_DOT_core, sym_into_DASH_array) + // var glojure.core/ints + var_glojure_DOT_core_ints := lang.InternVarName(sym_glojure_DOT_core, sym_ints) + // var glojure.core/io! + var_glojure_DOT_core_io_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_io_BANG_) // var glojure.core/isa? var_glojure_DOT_core_isa_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_isa_QMARK_) // var glojure.core/iterate var_glojure_DOT_core_iterate := lang.InternVarName(sym_glojure_DOT_core, sym_iterate) + // var glojure.core/iteration + var_glojure_DOT_core_iteration := lang.InternVarName(sym_glojure_DOT_core, sym_iteration) // var glojure.core/iterator-seq var_glojure_DOT_core_iterator_DASH_seq := lang.InternVarName(sym_glojure_DOT_core, sym_iterator_DASH_seq) + // var glojure.core/juxt + var_glojure_DOT_core_juxt := lang.InternVarName(sym_glojure_DOT_core, sym_juxt) // var glojure.core/keep var_glojure_DOT_core_keep := lang.InternVarName(sym_glojure_DOT_core, sym_keep) + // var glojure.core/keep-indexed + var_glojure_DOT_core_keep_DASH_indexed := lang.InternVarName(sym_glojure_DOT_core, sym_keep_DASH_indexed) // var glojure.core/key var_glojure_DOT_core_key := lang.InternVarName(sym_glojure_DOT_core, sym_key) // var glojure.core/keys @@ -1766,6 +2054,14 @@ func LoadNS() { var_glojure_DOT_core_keyword_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_keyword_QMARK_) // var glojure.core/last var_glojure_DOT_core_last := lang.InternVarName(sym_glojure_DOT_core, sym_last) + // var glojure.core/lazy-cat + var_glojure_DOT_core_lazy_DASH_cat := lang.InternVarName(sym_glojure_DOT_core, sym_lazy_DASH_cat) + // var glojure.core/lazy-seq + var_glojure_DOT_core_lazy_DASH_seq := lang.InternVarName(sym_glojure_DOT_core, sym_lazy_DASH_seq) + // var glojure.core/let + var_glojure_DOT_core_let := lang.InternVarName(sym_glojure_DOT_core, sym_let) + // var glojure.core/letfn + var_glojure_DOT_core_letfn := lang.InternVarName(sym_glojure_DOT_core, sym_letfn) // var glojure.core/libspec? var_glojure_DOT_core_libspec_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_libspec_QMARK_) // var glojure.core/lift-ns @@ -1774,6 +2070,8 @@ func LoadNS() { var_glojure_DOT_core_line_DASH_seq := lang.InternVarName(sym_glojure_DOT_core, sym_line_DASH_seq) // var glojure.core/list var_glojure_DOT_core_list := lang.InternVarName(sym_glojure_DOT_core, sym_list) + // var glojure.core/list? + var_glojure_DOT_core_list_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_list_QMARK_) // var glojure.core/list* var_glojure_DOT_core_list_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym_list_STAR_) // var glojure.core/load @@ -1782,6 +2080,10 @@ func LoadNS() { var_glojure_DOT_core_load_DASH_all := lang.InternVarName(sym_glojure_DOT_core, sym_load_DASH_all) // var glojure.core/load-data-reader-file var_glojure_DOT_core_load_DASH_data_DASH_reader_DASH_file := lang.InternVarName(sym_glojure_DOT_core, sym_load_DASH_data_DASH_reader_DASH_file) + // var glojure.core/load-data-readers + var_glojure_DOT_core_load_DASH_data_DASH_readers := lang.InternVarName(sym_glojure_DOT_core, sym_load_DASH_data_DASH_readers) + // var glojure.core/load-file + var_glojure_DOT_core_load_DASH_file := lang.InternVarName(sym_glojure_DOT_core, sym_load_DASH_file) // var glojure.core/load-lib var_glojure_DOT_core_load_DASH_lib := lang.InternVarName(sym_glojure_DOT_core, sym_load_DASH_lib) // var glojure.core/load-libs @@ -1790,8 +2092,20 @@ func LoadNS() { var_glojure_DOT_core_load_DASH_one := lang.InternVarName(sym_glojure_DOT_core, sym_load_DASH_one) // var glojure.core/load-reader var_glojure_DOT_core_load_DASH_reader := lang.InternVarName(sym_glojure_DOT_core, sym_load_DASH_reader) + // var glojure.core/load-string + var_glojure_DOT_core_load_DASH_string := lang.InternVarName(sym_glojure_DOT_core, sym_load_DASH_string) + // var glojure.core/loaded-libs + var_glojure_DOT_core_loaded_DASH_libs := lang.InternVarName(sym_glojure_DOT_core, sym_loaded_DASH_libs) + // var glojure.core/locking + var_glojure_DOT_core_locking := lang.InternVarName(sym_glojure_DOT_core, sym_locking) // var glojure.core/long var_glojure_DOT_core_long := lang.InternVarName(sym_glojure_DOT_core, sym_long) + // var glojure.core/long-array + var_glojure_DOT_core_long_DASH_array := lang.InternVarName(sym_glojure_DOT_core, sym_long_DASH_array) + // var glojure.core/longs + var_glojure_DOT_core_longs := lang.InternVarName(sym_glojure_DOT_core, sym_longs) + // var glojure.core/loop + var_glojure_DOT_core_loop := lang.InternVarName(sym_glojure_DOT_core, sym_loop) // var glojure.core/macroexpand var_glojure_DOT_core_macroexpand := lang.InternVarName(sym_glojure_DOT_core, sym_macroexpand) // var glojure.core/macroexpand-1 @@ -1802,12 +2116,20 @@ func LoadNS() { var_glojure_DOT_core_make_DASH_hierarchy := lang.InternVarName(sym_glojure_DOT_core, sym_make_DASH_hierarchy) // var glojure.core/map var_glojure_DOT_core_map := lang.InternVarName(sym_glojure_DOT_core, sym_map) + // var glojure.core/map-entry? + var_glojure_DOT_core_map_DASH_entry_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_map_DASH_entry_QMARK_) + // var glojure.core/map-indexed + var_glojure_DOT_core_map_DASH_indexed := lang.InternVarName(sym_glojure_DOT_core, sym_map_DASH_indexed) // var glojure.core/map? var_glojure_DOT_core_map_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_map_QMARK_) // var glojure.core/mapcat var_glojure_DOT_core_mapcat := lang.InternVarName(sym_glojure_DOT_core, sym_mapcat) + // var glojure.core/mapv + var_glojure_DOT_core_mapv := lang.InternVarName(sym_glojure_DOT_core, sym_mapv) // var glojure.core/max var_glojure_DOT_core_max := lang.InternVarName(sym_glojure_DOT_core, sym_max) + // var glojure.core/max-key + var_glojure_DOT_core_max_DASH_key := lang.InternVarName(sym_glojure_DOT_core, sym_max_DASH_key) // var glojure.core/max-mask-bits var_glojure_DOT_core_max_DASH_mask_DASH_bits := lang.InternVarName(sym_glojure_DOT_core, sym_max_DASH_mask_DASH_bits) // var glojure.core/max-switch-table-size @@ -1816,28 +2138,48 @@ func LoadNS() { var_glojure_DOT_core_maybe_DASH_destructured := lang.InternVarName(sym_glojure_DOT_core, sym_maybe_DASH_destructured) // var glojure.core/maybe-min-hash var_glojure_DOT_core_maybe_DASH_min_DASH_hash := lang.InternVarName(sym_glojure_DOT_core, sym_maybe_DASH_min_DASH_hash) + // var glojure.core/memfn + var_glojure_DOT_core_memfn := lang.InternVarName(sym_glojure_DOT_core, sym_memfn) + // var glojure.core/memoize + var_glojure_DOT_core_memoize := lang.InternVarName(sym_glojure_DOT_core, sym_memoize) // var glojure.core/merge var_glojure_DOT_core_merge := lang.InternVarName(sym_glojure_DOT_core, sym_merge) // var glojure.core/merge-hash-collisions var_glojure_DOT_core_merge_DASH_hash_DASH_collisions := lang.InternVarName(sym_glojure_DOT_core, sym_merge_DASH_hash_DASH_collisions) + // var glojure.core/merge-with + var_glojure_DOT_core_merge_DASH_with := lang.InternVarName(sym_glojure_DOT_core, sym_merge_DASH_with) // var glojure.core/meta var_glojure_DOT_core_meta := lang.InternVarName(sym_glojure_DOT_core, sym_meta) + // var glojure.core/methods + var_glojure_DOT_core_methods := lang.InternVarName(sym_glojure_DOT_core, sym_methods) // var glojure.core/min var_glojure_DOT_core_min := lang.InternVarName(sym_glojure_DOT_core, sym_min) + // var glojure.core/min-key + var_glojure_DOT_core_min_DASH_key := lang.InternVarName(sym_glojure_DOT_core, sym_min_DASH_key) + // var glojure.core/mix-collection-hash + var_glojure_DOT_core_mix_DASH_collection_DASH_hash := lang.InternVarName(sym_glojure_DOT_core, sym_mix_DASH_collection_DASH_hash) // var glojure.core/mk-bound-fn var_glojure_DOT_core_mk_DASH_bound_DASH_fn := lang.InternVarName(sym_glojure_DOT_core, sym_mk_DASH_bound_DASH_fn) + // var glojure.core/mod + var_glojure_DOT_core_mod := lang.InternVarName(sym_glojure_DOT_core, sym_mod) // var glojure.core/name var_glojure_DOT_core_name := lang.InternVarName(sym_glojure_DOT_core, sym_name) // var glojure.core/namespace var_glojure_DOT_core_namespace := lang.InternVarName(sym_glojure_DOT_core, sym_namespace) // var glojure.core/nary-inline var_glojure_DOT_core_nary_DASH_inline := lang.InternVarName(sym_glojure_DOT_core, sym_nary_DASH_inline) + // var glojure.core/nat-int? + var_glojure_DOT_core_nat_DASH_int_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_nat_DASH_int_QMARK_) + // var glojure.core/neg-int? + var_glojure_DOT_core_neg_DASH_int_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_neg_DASH_int_QMARK_) // var glojure.core/neg? var_glojure_DOT_core_neg_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_neg_QMARK_) // var glojure.core/newline var_glojure_DOT_core_newline := lang.InternVarName(sym_glojure_DOT_core, sym_newline) // var glojure.core/next var_glojure_DOT_core_next := lang.InternVarName(sym_glojure_DOT_core, sym_next) + // var glojure.core/nfirst + var_glojure_DOT_core_nfirst := lang.InternVarName(sym_glojure_DOT_core, sym_nfirst) // var glojure.core/nil? var_glojure_DOT_core_nil_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_nil_QMARK_) // var glojure.core/nnext @@ -1850,28 +2192,62 @@ func LoadNS() { var_glojure_DOT_core_not_DASH_any_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_not_DASH_any_QMARK_) // var glojure.core/not-empty var_glojure_DOT_core_not_DASH_empty := lang.InternVarName(sym_glojure_DOT_core, sym_not_DASH_empty) + // var glojure.core/not-every? + var_glojure_DOT_core_not_DASH_every_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_not_DASH_every_QMARK_) // var glojure.core/not= var_glojure_DOT_core_not_EQ_ := lang.InternVarName(sym_glojure_DOT_core, sym_not_EQ_) + // var glojure.core/ns + var_glojure_DOT_core_ns := lang.InternVarName(sym_glojure_DOT_core, sym_ns) + // var glojure.core/ns-aliases + var_glojure_DOT_core_ns_DASH_aliases := lang.InternVarName(sym_glojure_DOT_core, sym_ns_DASH_aliases) + // var glojure.core/ns-imports + var_glojure_DOT_core_ns_DASH_imports := lang.InternVarName(sym_glojure_DOT_core, sym_ns_DASH_imports) + // var glojure.core/ns-interns + var_glojure_DOT_core_ns_DASH_interns := lang.InternVarName(sym_glojure_DOT_core, sym_ns_DASH_interns) // var glojure.core/ns-map var_glojure_DOT_core_ns_DASH_map := lang.InternVarName(sym_glojure_DOT_core, sym_ns_DASH_map) // var glojure.core/ns-name var_glojure_DOT_core_ns_DASH_name := lang.InternVarName(sym_glojure_DOT_core, sym_ns_DASH_name) // var glojure.core/ns-publics var_glojure_DOT_core_ns_DASH_publics := lang.InternVarName(sym_glojure_DOT_core, sym_ns_DASH_publics) + // var glojure.core/ns-refers + var_glojure_DOT_core_ns_DASH_refers := lang.InternVarName(sym_glojure_DOT_core, sym_ns_DASH_refers) // var glojure.core/ns-resolve var_glojure_DOT_core_ns_DASH_resolve := lang.InternVarName(sym_glojure_DOT_core, sym_ns_DASH_resolve) + // var glojure.core/ns-unalias + var_glojure_DOT_core_ns_DASH_unalias := lang.InternVarName(sym_glojure_DOT_core, sym_ns_DASH_unalias) + // var glojure.core/ns-unmap + var_glojure_DOT_core_ns_DASH_unmap := lang.InternVarName(sym_glojure_DOT_core, sym_ns_DASH_unmap) // var glojure.core/nth var_glojure_DOT_core_nth := lang.InternVarName(sym_glojure_DOT_core, sym_nth) + // var glojure.core/nthnext + var_glojure_DOT_core_nthnext := lang.InternVarName(sym_glojure_DOT_core, sym_nthnext) // var glojure.core/nthrest var_glojure_DOT_core_nthrest := lang.InternVarName(sym_glojure_DOT_core, sym_nthrest) + // var glojure.core/num + var_glojure_DOT_core_num := lang.InternVarName(sym_glojure_DOT_core, sym_num) // var glojure.core/number? var_glojure_DOT_core_number_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_number_QMARK_) + // var glojure.core/numerator + var_glojure_DOT_core_numerator := lang.InternVarName(sym_glojure_DOT_core, sym_numerator) + // var glojure.core/object-array + var_glojure_DOT_core_object_DASH_array := lang.InternVarName(sym_glojure_DOT_core, sym_object_DASH_array) // var glojure.core/odd? var_glojure_DOT_core_odd_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_odd_QMARK_) + // var glojure.core/or + var_glojure_DOT_core_or := lang.InternVarName(sym_glojure_DOT_core, sym_or) // var glojure.core/parents var_glojure_DOT_core_parents := lang.InternVarName(sym_glojure_DOT_core, sym_parents) + // var glojure.core/parse-boolean + var_glojure_DOT_core_parse_DASH_boolean := lang.InternVarName(sym_glojure_DOT_core, sym_parse_DASH_boolean) + // var glojure.core/parse-double + var_glojure_DOT_core_parse_DASH_double := lang.InternVarName(sym_glojure_DOT_core, sym_parse_DASH_double) // var glojure.core/parse-impls var_glojure_DOT_core_parse_DASH_impls := lang.InternVarName(sym_glojure_DOT_core, sym_parse_DASH_impls) + // var glojure.core/parse-long + var_glojure_DOT_core_parse_DASH_long := lang.InternVarName(sym_glojure_DOT_core, sym_parse_DASH_long) + // var glojure.core/parse-uuid + var_glojure_DOT_core_parse_DASH_uuid := lang.InternVarName(sym_glojure_DOT_core, sym_parse_DASH_uuid) // var glojure.core/parsing-err var_glojure_DOT_core_parsing_DASH_err := lang.InternVarName(sym_glojure_DOT_core, sym_parsing_DASH_err) // var glojure.core/partial @@ -1886,6 +2262,8 @@ func LoadNS() { var_glojure_DOT_core_partitionv := lang.InternVarName(sym_glojure_DOT_core, sym_partitionv) // var glojure.core/partitionv-all var_glojure_DOT_core_partitionv_DASH_all := lang.InternVarName(sym_glojure_DOT_core, sym_partitionv_DASH_all) + // var glojure.core/pcalls + var_glojure_DOT_core_pcalls := lang.InternVarName(sym_glojure_DOT_core, sym_pcalls) // var glojure.core/peek var_glojure_DOT_core_peek := lang.InternVarName(sym_glojure_DOT_core, sym_peek) // var glojure.core/persistent! @@ -1894,8 +2272,12 @@ func LoadNS() { var_glojure_DOT_core_pmap := lang.InternVarName(sym_glojure_DOT_core, sym_pmap) // var glojure.core/pop var_glojure_DOT_core_pop := lang.InternVarName(sym_glojure_DOT_core, sym_pop) + // var glojure.core/pop! + var_glojure_DOT_core_pop_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_pop_BANG_) // var glojure.core/pop-thread-bindings var_glojure_DOT_core_pop_DASH_thread_DASH_bindings := lang.InternVarName(sym_glojure_DOT_core, sym_pop_DASH_thread_DASH_bindings) + // var glojure.core/pos-int? + var_glojure_DOT_core_pos_DASH_int_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_pos_DASH_int_QMARK_) // var glojure.core/pos? var_glojure_DOT_core_pos_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_pos_QMARK_) // var glojure.core/pr @@ -1904,6 +2286,10 @@ func LoadNS() { var_glojure_DOT_core_pr_DASH_on := lang.InternVarName(sym_glojure_DOT_core, sym_pr_DASH_on) // var glojure.core/pr-str var_glojure_DOT_core_pr_DASH_str := lang.InternVarName(sym_glojure_DOT_core, sym_pr_DASH_str) + // var glojure.core/prefer-method + var_glojure_DOT_core_prefer_DASH_method := lang.InternVarName(sym_glojure_DOT_core, sym_prefer_DASH_method) + // var glojure.core/prefers + var_glojure_DOT_core_prefers := lang.InternVarName(sym_glojure_DOT_core, sym_prefers) // var glojure.core/prep-hashes var_glojure_DOT_core_prep_DASH_hashes := lang.InternVarName(sym_glojure_DOT_core, sym_prep_DASH_hashes) // var glojure.core/prep-ints @@ -1918,6 +2304,8 @@ func LoadNS() { var_glojure_DOT_core_print_DASH_ctor := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_ctor) // var glojure.core/print-dup var_glojure_DOT_core_print_DASH_dup := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_dup) + // var glojure.core/print-initialized + var_glojure_DOT_core_print_DASH_initialized := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_initialized) // var glojure.core/print-map var_glojure_DOT_core_print_DASH_map := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_map) // var glojure.core/print-meta @@ -1936,38 +2324,78 @@ func LoadNS() { var_glojure_DOT_core_print_DASH_str := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_str) // var glojure.core/print-tagged-object var_glojure_DOT_core_print_DASH_tagged_DASH_object := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_tagged_DASH_object) + // var glojure.core/print-throwable + var_glojure_DOT_core_print_DASH_throwable := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_throwable) // var glojure.core/printf var_glojure_DOT_core_printf := lang.InternVarName(sym_glojure_DOT_core, sym_printf) // var glojure.core/println var_glojure_DOT_core_println := lang.InternVarName(sym_glojure_DOT_core, sym_println) + // var glojure.core/println-str + var_glojure_DOT_core_println_DASH_str := lang.InternVarName(sym_glojure_DOT_core, sym_println_DASH_str) // var glojure.core/prn var_glojure_DOT_core_prn := lang.InternVarName(sym_glojure_DOT_core, sym_prn) + // var glojure.core/prn-str + var_glojure_DOT_core_prn_DASH_str := lang.InternVarName(sym_glojure_DOT_core, sym_prn_DASH_str) + // var glojure.core/promise + var_glojure_DOT_core_promise := lang.InternVarName(sym_glojure_DOT_core, sym_promise) // var glojure.core/protocol? var_glojure_DOT_core_protocol_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_protocol_QMARK_) // var glojure.core/push-thread-bindings var_glojure_DOT_core_push_DASH_thread_DASH_bindings := lang.InternVarName(sym_glojure_DOT_core, sym_push_DASH_thread_DASH_bindings) + // var glojure.core/pvalues + var_glojure_DOT_core_pvalues := lang.InternVarName(sym_glojure_DOT_core, sym_pvalues) // var glojure.core/qualified-ident? var_glojure_DOT_core_qualified_DASH_ident_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_qualified_DASH_ident_QMARK_) + // var glojure.core/qualified-keyword? + var_glojure_DOT_core_qualified_DASH_keyword_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_qualified_DASH_keyword_QMARK_) // var glojure.core/qualified-symbol? var_glojure_DOT_core_qualified_DASH_symbol_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_qualified_DASH_symbol_QMARK_) + // var glojure.core/quot + var_glojure_DOT_core_quot := lang.InternVarName(sym_glojure_DOT_core, sym_quot) // var glojure.core/rand var_glojure_DOT_core_rand := lang.InternVarName(sym_glojure_DOT_core, sym_rand) // var glojure.core/rand-int var_glojure_DOT_core_rand_DASH_int := lang.InternVarName(sym_glojure_DOT_core, sym_rand_DASH_int) + // var glojure.core/rand-nth + var_glojure_DOT_core_rand_DASH_nth := lang.InternVarName(sym_glojure_DOT_core, sym_rand_DASH_nth) + // var glojure.core/random-sample + var_glojure_DOT_core_random_DASH_sample := lang.InternVarName(sym_glojure_DOT_core, sym_random_DASH_sample) + // var glojure.core/random-uuid + var_glojure_DOT_core_random_DASH_uuid := lang.InternVarName(sym_glojure_DOT_core, sym_random_DASH_uuid) // var glojure.core/range var_glojure_DOT_core_range := lang.InternVarName(sym_glojure_DOT_core, sym_range) // var glojure.core/ratio? var_glojure_DOT_core_ratio_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_ratio_QMARK_) + // var glojure.core/rational? + var_glojure_DOT_core_rational_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_rational_QMARK_) + // var glojure.core/rationalize + var_glojure_DOT_core_rationalize := lang.InternVarName(sym_glojure_DOT_core, sym_rationalize) // var glojure.core/re-find var_glojure_DOT_core_re_DASH_find := lang.InternVarName(sym_glojure_DOT_core, sym_re_DASH_find) // var glojure.core/re-groups var_glojure_DOT_core_re_DASH_groups := lang.InternVarName(sym_glojure_DOT_core, sym_re_DASH_groups) // var glojure.core/re-matcher var_glojure_DOT_core_re_DASH_matcher := lang.InternVarName(sym_glojure_DOT_core, sym_re_DASH_matcher) + // var glojure.core/re-matches + var_glojure_DOT_core_re_DASH_matches := lang.InternVarName(sym_glojure_DOT_core, sym_re_DASH_matches) + // var glojure.core/re-pattern + var_glojure_DOT_core_re_DASH_pattern := lang.InternVarName(sym_glojure_DOT_core, sym_re_DASH_pattern) + // var glojure.core/re-seq + var_glojure_DOT_core_re_DASH_seq := lang.InternVarName(sym_glojure_DOT_core, sym_re_DASH_seq) // var glojure.core/read var_glojure_DOT_core_read := lang.InternVarName(sym_glojure_DOT_core, sym_read) + // var glojure.core/read-line + var_glojure_DOT_core_read_DASH_line := lang.InternVarName(sym_glojure_DOT_core, sym_read_DASH_line) + // var glojure.core/read-string + var_glojure_DOT_core_read_DASH_string := lang.InternVarName(sym_glojure_DOT_core, sym_read_DASH_string) // var glojure.core/read+string var_glojure_DOT_core_read_PLUS_string := lang.InternVarName(sym_glojure_DOT_core, sym_read_PLUS_string) + // var glojure.core/reader-conditional + var_glojure_DOT_core_reader_DASH_conditional := lang.InternVarName(sym_glojure_DOT_core, sym_reader_DASH_conditional) + // var glojure.core/reader-conditional? + var_glojure_DOT_core_reader_DASH_conditional_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_reader_DASH_conditional_QMARK_) + // var glojure.core/realized? + var_glojure_DOT_core_realized_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_realized_QMARK_) // var glojure.core/reduce var_glojure_DOT_core_reduce := lang.InternVarName(sym_glojure_DOT_core, sym_reduce) // var glojure.core/reduce1 @@ -1982,32 +2410,74 @@ func LoadNS() { var_glojure_DOT_core_reductions := lang.InternVarName(sym_glojure_DOT_core, sym_reductions) // var glojure.core/ref var_glojure_DOT_core_ref := lang.InternVarName(sym_glojure_DOT_core, sym_ref) + // var glojure.core/ref-history-count + var_glojure_DOT_core_ref_DASH_history_DASH_count := lang.InternVarName(sym_glojure_DOT_core, sym_ref_DASH_history_DASH_count) + // var glojure.core/ref-max-history + var_glojure_DOT_core_ref_DASH_max_DASH_history := lang.InternVarName(sym_glojure_DOT_core, sym_ref_DASH_max_DASH_history) + // var glojure.core/ref-min-history + var_glojure_DOT_core_ref_DASH_min_DASH_history := lang.InternVarName(sym_glojure_DOT_core, sym_ref_DASH_min_DASH_history) + // var glojure.core/ref-set + var_glojure_DOT_core_ref_DASH_set := lang.InternVarName(sym_glojure_DOT_core, sym_ref_DASH_set) // var glojure.core/refer var_glojure_DOT_core_refer := lang.InternVarName(sym_glojure_DOT_core, sym_refer) + // var glojure.core/refer-glojure + var_glojure_DOT_core_refer_DASH_glojure := lang.InternVarName(sym_glojure_DOT_core, sym_refer_DASH_glojure) // var glojure.core/release-pending-sends var_glojure_DOT_core_release_DASH_pending_DASH_sends := lang.InternVarName(sym_glojure_DOT_core, sym_release_DASH_pending_DASH_sends) // var glojure.core/rem var_glojure_DOT_core_rem := lang.InternVarName(sym_glojure_DOT_core, sym_rem) // var glojure.core/remove var_glojure_DOT_core_remove := lang.InternVarName(sym_glojure_DOT_core, sym_remove) + // var glojure.core/remove-all-methods + var_glojure_DOT_core_remove_DASH_all_DASH_methods := lang.InternVarName(sym_glojure_DOT_core, sym_remove_DASH_all_DASH_methods) + // var glojure.core/remove-method + var_glojure_DOT_core_remove_DASH_method := lang.InternVarName(sym_glojure_DOT_core, sym_remove_DASH_method) // var glojure.core/remove-ns var_glojure_DOT_core_remove_DASH_ns := lang.InternVarName(sym_glojure_DOT_core, sym_remove_DASH_ns) + // var glojure.core/remove-tap + var_glojure_DOT_core_remove_DASH_tap := lang.InternVarName(sym_glojure_DOT_core, sym_remove_DASH_tap) + // var glojure.core/remove-watch + var_glojure_DOT_core_remove_DASH_watch := lang.InternVarName(sym_glojure_DOT_core, sym_remove_DASH_watch) // var glojure.core/repeat var_glojure_DOT_core_repeat := lang.InternVarName(sym_glojure_DOT_core, sym_repeat) // var glojure.core/repeatedly var_glojure_DOT_core_repeatedly := lang.InternVarName(sym_glojure_DOT_core, sym_repeatedly) + // var glojure.core/replace + var_glojure_DOT_core_replace := lang.InternVarName(sym_glojure_DOT_core, sym_replace) + // var glojure.core/replicate + var_glojure_DOT_core_replicate := lang.InternVarName(sym_glojure_DOT_core, sym_replicate) // var glojure.core/require var_glojure_DOT_core_require := lang.InternVarName(sym_glojure_DOT_core, sym_require) + // var glojure.core/requiring-resolve + var_glojure_DOT_core_requiring_DASH_resolve := lang.InternVarName(sym_glojure_DOT_core, sym_requiring_DASH_resolve) + // var glojure.core/reset! + var_glojure_DOT_core_reset_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_reset_BANG_) + // var glojure.core/reset-meta! + var_glojure_DOT_core_reset_DASH_meta_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_reset_DASH_meta_BANG_) + // var glojure.core/reset-vals! + var_glojure_DOT_core_reset_DASH_vals_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_reset_DASH_vals_BANG_) // var glojure.core/resolve var_glojure_DOT_core_resolve := lang.InternVarName(sym_glojure_DOT_core, sym_resolve) // var glojure.core/rest var_glojure_DOT_core_rest := lang.InternVarName(sym_glojure_DOT_core, sym_rest) // var glojure.core/restart-agent var_glojure_DOT_core_restart_DASH_agent := lang.InternVarName(sym_glojure_DOT_core, sym_restart_DASH_agent) + // var glojure.core/resultset-seq + var_glojure_DOT_core_resultset_DASH_seq := lang.InternVarName(sym_glojure_DOT_core, sym_resultset_DASH_seq) + // var glojure.core/reverse + var_glojure_DOT_core_reverse := lang.InternVarName(sym_glojure_DOT_core, sym_reverse) + // var glojure.core/reversible? + var_glojure_DOT_core_reversible_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_reversible_QMARK_) // var glojure.core/root-directory var_glojure_DOT_core_root_DASH_directory := lang.InternVarName(sym_glojure_DOT_core, sym_root_DASH_directory) // var glojure.core/root-resource var_glojure_DOT_core_root_DASH_resource := lang.InternVarName(sym_glojure_DOT_core, sym_root_DASH_resource) + // var glojure.core/rseq + var_glojure_DOT_core_rseq := lang.InternVarName(sym_glojure_DOT_core, sym_rseq) + // var glojure.core/rsubseq + var_glojure_DOT_core_rsubseq := lang.InternVarName(sym_glojure_DOT_core, sym_rsubseq) + // var glojure.core/run! + var_glojure_DOT_core_run_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_run_BANG_) // var glojure.core/second var_glojure_DOT_core_second := lang.InternVarName(sym_glojure_DOT_core, sym_second) // var glojure.core/select-keys @@ -2020,8 +2490,12 @@ func LoadNS() { var_glojure_DOT_core_send_DASH_via := lang.InternVarName(sym_glojure_DOT_core, sym_send_DASH_via) // var glojure.core/seq var_glojure_DOT_core_seq := lang.InternVarName(sym_glojure_DOT_core, sym_seq) + // var glojure.core/seq-to-map-for-destructuring + var_glojure_DOT_core_seq_DASH_to_DASH_map_DASH_for_DASH_destructuring := lang.InternVarName(sym_glojure_DOT_core, sym_seq_DASH_to_DASH_map_DASH_for_DASH_destructuring) // var glojure.core/seq? var_glojure_DOT_core_seq_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_seq_QMARK_) + // var glojure.core/seqable? + var_glojure_DOT_core_seqable_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_seqable_QMARK_) // var glojure.core/seque var_glojure_DOT_core_seque := lang.InternVarName(sym_glojure_DOT_core, sym_seque) // var glojure.core/sequence @@ -2032,6 +2506,16 @@ func LoadNS() { var_glojure_DOT_core_serialized_DASH_require := lang.InternVarName(sym_glojure_DOT_core, sym_serialized_DASH_require) // var glojure.core/set var_glojure_DOT_core_set := lang.InternVarName(sym_glojure_DOT_core, sym_set) + // var glojure.core/set-agent-send-executor! + var_glojure_DOT_core_set_DASH_agent_DASH_send_DASH_executor_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_set_DASH_agent_DASH_send_DASH_executor_BANG_) + // var glojure.core/set-agent-send-off-executor! + var_glojure_DOT_core_set_DASH_agent_DASH_send_DASH_off_DASH_executor_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_set_DASH_agent_DASH_send_DASH_off_DASH_executor_BANG_) + // var glojure.core/set-error-handler! + var_glojure_DOT_core_set_DASH_error_DASH_handler_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_set_DASH_error_DASH_handler_BANG_) + // var glojure.core/set-error-mode! + var_glojure_DOT_core_set_DASH_error_DASH_mode_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_set_DASH_error_DASH_mode_BANG_) + // var glojure.core/set-validator! + var_glojure_DOT_core_set_DASH_validator_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_set_DASH_validator_BANG_) // var glojure.core/set? var_glojure_DOT_core_set_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_set_QMARK_) // var glojure.core/setup-reference @@ -2040,10 +2524,32 @@ func LoadNS() { var_glojure_DOT_core_shift_DASH_mask := lang.InternVarName(sym_glojure_DOT_core, sym_shift_DASH_mask) // var glojure.core/short var_glojure_DOT_core_short := lang.InternVarName(sym_glojure_DOT_core, sym_short) + // var glojure.core/short-array + var_glojure_DOT_core_short_DASH_array := lang.InternVarName(sym_glojure_DOT_core, sym_short_DASH_array) + // var glojure.core/shorts + var_glojure_DOT_core_shorts := lang.InternVarName(sym_glojure_DOT_core, sym_shorts) + // var glojure.core/shuffle + var_glojure_DOT_core_shuffle := lang.InternVarName(sym_glojure_DOT_core, sym_shuffle) + // var glojure.core/shutdown-agents + var_glojure_DOT_core_shutdown_DASH_agents := lang.InternVarName(sym_glojure_DOT_core, sym_shutdown_DASH_agents) // var glojure.core/sigs var_glojure_DOT_core_sigs := lang.InternVarName(sym_glojure_DOT_core, sym_sigs) + // var glojure.core/simple-ident? + var_glojure_DOT_core_simple_DASH_ident_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_simple_DASH_ident_QMARK_) + // var glojure.core/simple-keyword? + var_glojure_DOT_core_simple_DASH_keyword_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_simple_DASH_keyword_QMARK_) + // var glojure.core/simple-symbol? + var_glojure_DOT_core_simple_DASH_symbol_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_simple_DASH_symbol_QMARK_) + // var glojure.core/slurp + var_glojure_DOT_core_slurp := lang.InternVarName(sym_glojure_DOT_core, sym_slurp) // var glojure.core/some var_glojure_DOT_core_some := lang.InternVarName(sym_glojure_DOT_core, sym_some) + // var glojure.core/some-> + var_glojure_DOT_core_some_DASH__GT_ := lang.InternVarName(sym_glojure_DOT_core, sym_some_DASH__GT_) + // var glojure.core/some->> + var_glojure_DOT_core_some_DASH__GT__GT_ := lang.InternVarName(sym_glojure_DOT_core, sym_some_DASH__GT__GT_) + // var glojure.core/some-fn + var_glojure_DOT_core_some_DASH_fn := lang.InternVarName(sym_glojure_DOT_core, sym_some_DASH_fn) // var glojure.core/some? var_glojure_DOT_core_some_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_some_QMARK_) // var glojure.core/sort @@ -2052,18 +2558,34 @@ func LoadNS() { var_glojure_DOT_core_sort_DASH_by := lang.InternVarName(sym_glojure_DOT_core, sym_sort_DASH_by) // var glojure.core/sorted-map var_glojure_DOT_core_sorted_DASH_map := lang.InternVarName(sym_glojure_DOT_core, sym_sorted_DASH_map) + // var glojure.core/sorted-map-by + var_glojure_DOT_core_sorted_DASH_map_DASH_by := lang.InternVarName(sym_glojure_DOT_core, sym_sorted_DASH_map_DASH_by) // var glojure.core/sorted-set var_glojure_DOT_core_sorted_DASH_set := lang.InternVarName(sym_glojure_DOT_core, sym_sorted_DASH_set) + // var glojure.core/sorted-set-by + var_glojure_DOT_core_sorted_DASH_set_DASH_by := lang.InternVarName(sym_glojure_DOT_core, sym_sorted_DASH_set_DASH_by) + // var glojure.core/sorted? + var_glojure_DOT_core_sorted_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_sorted_QMARK_) + // var glojure.core/special-symbol? + var_glojure_DOT_core_special_DASH_symbol_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_special_DASH_symbol_QMARK_) + // var glojure.core/spit + var_glojure_DOT_core_spit := lang.InternVarName(sym_glojure_DOT_core, sym_spit) // var glojure.core/split-at var_glojure_DOT_core_split_DASH_at := lang.InternVarName(sym_glojure_DOT_core, sym_split_DASH_at) // var glojure.core/split-with var_glojure_DOT_core_split_DASH_with := lang.InternVarName(sym_glojure_DOT_core, sym_split_DASH_with) + // var glojure.core/splitv-at + var_glojure_DOT_core_splitv_DASH_at := lang.InternVarName(sym_glojure_DOT_core, sym_splitv_DASH_at) // var glojure.core/spread var_glojure_DOT_core_spread := lang.InternVarName(sym_glojure_DOT_core, sym_spread) // var glojure.core/str var_glojure_DOT_core_str := lang.InternVarName(sym_glojure_DOT_core, sym_str) + // var glojure.core/stream-into! + var_glojure_DOT_core_stream_DASH_into_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_stream_DASH_into_BANG_) // var glojure.core/stream-reduce! var_glojure_DOT_core_stream_DASH_reduce_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_stream_DASH_reduce_BANG_) + // var glojure.core/stream-seq! + var_glojure_DOT_core_stream_DASH_seq_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_stream_DASH_seq_BANG_) // var glojure.core/stream-transduce! var_glojure_DOT_core_stream_DASH_transduce_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_stream_DASH_transduce_BANG_) // var glojure.core/string? @@ -2072,34 +2594,56 @@ func LoadNS() { var_glojure_DOT_core_strip_DASH_ns := lang.InternVarName(sym_glojure_DOT_core, sym_strip_DASH_ns) // var glojure.core/struct var_glojure_DOT_core_struct := lang.InternVarName(sym_glojure_DOT_core, sym_struct) + // var glojure.core/struct-map + var_glojure_DOT_core_struct_DASH_map := lang.InternVarName(sym_glojure_DOT_core, sym_struct_DASH_map) // var glojure.core/subs var_glojure_DOT_core_subs := lang.InternVarName(sym_glojure_DOT_core, sym_subs) + // var glojure.core/subseq + var_glojure_DOT_core_subseq := lang.InternVarName(sym_glojure_DOT_core, sym_subseq) // var glojure.core/subvec var_glojure_DOT_core_subvec := lang.InternVarName(sym_glojure_DOT_core, sym_subvec) // var glojure.core/supers var_glojure_DOT_core_supers := lang.InternVarName(sym_glojure_DOT_core, sym_supers) // var glojure.core/swap! var_glojure_DOT_core_swap_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_swap_BANG_) + // var glojure.core/swap-vals! + var_glojure_DOT_core_swap_DASH_vals_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_swap_DASH_vals_BANG_) // var glojure.core/symbol var_glojure_DOT_core_symbol := lang.InternVarName(sym_glojure_DOT_core, sym_symbol) // var glojure.core/symbol? var_glojure_DOT_core_symbol_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_symbol_QMARK_) + // var glojure.core/sync + var_glojure_DOT_core_sync := lang.InternVarName(sym_glojure_DOT_core, sym_sync) // var glojure.core/system-newline var_glojure_DOT_core_system_DASH_newline := lang.InternVarName(sym_glojure_DOT_core, sym_system_DASH_newline) + // var glojure.core/tagged-literal + var_glojure_DOT_core_tagged_DASH_literal := lang.InternVarName(sym_glojure_DOT_core, sym_tagged_DASH_literal) + // var glojure.core/tagged-literal? + var_glojure_DOT_core_tagged_DASH_literal_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_tagged_DASH_literal_QMARK_) // var glojure.core/take var_glojure_DOT_core_take := lang.InternVarName(sym_glojure_DOT_core, sym_take) + // var glojure.core/take-last + var_glojure_DOT_core_take_DASH_last := lang.InternVarName(sym_glojure_DOT_core, sym_take_DASH_last) // var glojure.core/take-nth var_glojure_DOT_core_take_DASH_nth := lang.InternVarName(sym_glojure_DOT_core, sym_take_DASH_nth) // var glojure.core/take-while var_glojure_DOT_core_take_DASH_while := lang.InternVarName(sym_glojure_DOT_core, sym_take_DASH_while) // var glojure.core/tapset var_glojure_DOT_core_tapset := lang.InternVarName(sym_glojure_DOT_core, sym_tapset) + // var glojure.core/test + var_glojure_DOT_core_test := lang.InternVarName(sym_glojure_DOT_core, sym_test) // var glojure.core/the-ns var_glojure_DOT_core_the_DASH_ns := lang.InternVarName(sym_glojure_DOT_core, sym_the_DASH_ns) + // var glojure.core/thread-bound? + var_glojure_DOT_core_thread_DASH_bound_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_thread_DASH_bound_QMARK_) // var glojure.core/throw-if var_glojure_DOT_core_throw_DASH_if := lang.InternVarName(sym_glojure_DOT_core, sym_throw_DASH_if) + // var glojure.core/time + var_glojure_DOT_core_time := lang.InternVarName(sym_glojure_DOT_core, sym_time) // var glojure.core/to-array var_glojure_DOT_core_to_DASH_array := lang.InternVarName(sym_glojure_DOT_core, sym_to_DASH_array) + // var glojure.core/to-array-2d + var_glojure_DOT_core_to_DASH_array_DASH_2d := lang.InternVarName(sym_glojure_DOT_core, sym_to_DASH_array_DASH_2d) // var glojure.core/trampoline var_glojure_DOT_core_trampoline := lang.InternVarName(sym_glojure_DOT_core, sym_trampoline) // var glojure.core/transduce @@ -2108,18 +2652,86 @@ func LoadNS() { var_glojure_DOT_core_transient := lang.InternVarName(sym_glojure_DOT_core, sym_transient) // var glojure.core/tree-seq var_glojure_DOT_core_tree_DASH_seq := lang.InternVarName(sym_glojure_DOT_core, sym_tree_DASH_seq) + // var glojure.core/true? + var_glojure_DOT_core_true_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_true_QMARK_) + // var glojure.core/type + var_glojure_DOT_core_type := lang.InternVarName(sym_glojure_DOT_core, sym_type) + // var glojure.core/unchecked-add + var_glojure_DOT_core_unchecked_DASH_add := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_add) + // var glojure.core/unchecked-add-int + var_glojure_DOT_core_unchecked_DASH_add_DASH_int := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_add_DASH_int) + // var glojure.core/unchecked-byte + var_glojure_DOT_core_unchecked_DASH_byte := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_byte) + // var glojure.core/unchecked-char + var_glojure_DOT_core_unchecked_DASH_char := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_char) + // var glojure.core/unchecked-dec + var_glojure_DOT_core_unchecked_DASH_dec := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_dec) + // var glojure.core/unchecked-dec-int + var_glojure_DOT_core_unchecked_DASH_dec_DASH_int := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_dec_DASH_int) + // var glojure.core/unchecked-divide-int + var_glojure_DOT_core_unchecked_DASH_divide_DASH_int := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_divide_DASH_int) + // var glojure.core/unchecked-double + var_glojure_DOT_core_unchecked_DASH_double := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_double) + // var glojure.core/unchecked-float + var_glojure_DOT_core_unchecked_DASH_float := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_float) // var glojure.core/unchecked-inc var_glojure_DOT_core_unchecked_DASH_inc := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_inc) + // var glojure.core/unchecked-inc-int + var_glojure_DOT_core_unchecked_DASH_inc_DASH_int := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_inc_DASH_int) + // var glojure.core/unchecked-int + var_glojure_DOT_core_unchecked_DASH_int := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_int) + // var glojure.core/unchecked-long + var_glojure_DOT_core_unchecked_DASH_long := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_long) + // var glojure.core/unchecked-multiply + var_glojure_DOT_core_unchecked_DASH_multiply := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_multiply) + // var glojure.core/unchecked-multiply-int + var_glojure_DOT_core_unchecked_DASH_multiply_DASH_int := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_multiply_DASH_int) + // var glojure.core/unchecked-negate + var_glojure_DOT_core_unchecked_DASH_negate := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_negate) + // var glojure.core/unchecked-negate-int + var_glojure_DOT_core_unchecked_DASH_negate_DASH_int := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_negate_DASH_int) + // var glojure.core/unchecked-remainder-int + var_glojure_DOT_core_unchecked_DASH_remainder_DASH_int := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_remainder_DASH_int) + // var glojure.core/unchecked-short + var_glojure_DOT_core_unchecked_DASH_short := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_short) + // var glojure.core/unchecked-subtract + var_glojure_DOT_core_unchecked_DASH_subtract := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_subtract) + // var glojure.core/unchecked-subtract-int + var_glojure_DOT_core_unchecked_DASH_subtract_DASH_int := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_subtract_DASH_int) // var glojure.core/underive var_glojure_DOT_core_underive := lang.InternVarName(sym_glojure_DOT_core, sym_underive) + // var glojure.core/unquote + var_glojure_DOT_core_unquote := lang.InternVarName(sym_glojure_DOT_core, sym_unquote) + // var glojure.core/unquote-splicing + var_glojure_DOT_core_unquote_DASH_splicing := lang.InternVarName(sym_glojure_DOT_core, sym_unquote_DASH_splicing) // var glojure.core/unreduced var_glojure_DOT_core_unreduced := lang.InternVarName(sym_glojure_DOT_core, sym_unreduced) + // var glojure.core/unsigned-bit-shift-right + var_glojure_DOT_core_unsigned_DASH_bit_DASH_shift_DASH_right := lang.InternVarName(sym_glojure_DOT_core, sym_unsigned_DASH_bit_DASH_shift_DASH_right) // var glojure.core/update var_glojure_DOT_core_update := lang.InternVarName(sym_glojure_DOT_core, sym_update) + // var glojure.core/update-in + var_glojure_DOT_core_update_DASH_in := lang.InternVarName(sym_glojure_DOT_core, sym_update_DASH_in) + // var glojure.core/update-keys + var_glojure_DOT_core_update_DASH_keys := lang.InternVarName(sym_glojure_DOT_core, sym_update_DASH_keys) + // var glojure.core/update-vals + var_glojure_DOT_core_update_DASH_vals := lang.InternVarName(sym_glojure_DOT_core, sym_update_DASH_vals) + // var glojure.core/uri? + var_glojure_DOT_core_uri_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_uri_QMARK_) + // var glojure.core/use + var_glojure_DOT_core_use := lang.InternVarName(sym_glojure_DOT_core, sym_use) + // var glojure.core/uuid? + var_glojure_DOT_core_uuid_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_uuid_QMARK_) // var glojure.core/val var_glojure_DOT_core_val := lang.InternVarName(sym_glojure_DOT_core, sym_val) // var glojure.core/vals var_glojure_DOT_core_vals := lang.InternVarName(sym_glojure_DOT_core, sym_vals) + // var glojure.core/var-get + var_glojure_DOT_core_var_DASH_get := lang.InternVarName(sym_glojure_DOT_core, sym_var_DASH_get) + // var glojure.core/var-set + var_glojure_DOT_core_var_DASH_set := lang.InternVarName(sym_glojure_DOT_core, sym_var_DASH_set) + // var glojure.core/var? + var_glojure_DOT_core_var_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_var_QMARK_) // var glojure.core/vary-meta var_glojure_DOT_core_vary_DASH_meta := lang.InternVarName(sym_glojure_DOT_core, sym_vary_DASH_meta) // var glojure.core/vec @@ -2130,12 +2742,48 @@ func LoadNS() { var_glojure_DOT_core_vector_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_vector_QMARK_) // var glojure.core/volatile! var_glojure_DOT_core_volatile_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_volatile_BANG_) + // var glojure.core/volatile? + var_glojure_DOT_core_volatile_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_volatile_QMARK_) // var glojure.core/vreset! var_glojure_DOT_core_vreset_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_vreset_BANG_) + // var glojure.core/vswap! + var_glojure_DOT_core_vswap_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_vswap_BANG_) + // var glojure.core/when + var_glojure_DOT_core_when := lang.InternVarName(sym_glojure_DOT_core, sym_when) + // var glojure.core/when-first + var_glojure_DOT_core_when_DASH_first := lang.InternVarName(sym_glojure_DOT_core, sym_when_DASH_first) + // var glojure.core/when-let + var_glojure_DOT_core_when_DASH_let := lang.InternVarName(sym_glojure_DOT_core, sym_when_DASH_let) + // var glojure.core/when-not + var_glojure_DOT_core_when_DASH_not := lang.InternVarName(sym_glojure_DOT_core, sym_when_DASH_not) + // var glojure.core/when-some + var_glojure_DOT_core_when_DASH_some := lang.InternVarName(sym_glojure_DOT_core, sym_when_DASH_some) + // var glojure.core/while + var_glojure_DOT_core_while := lang.InternVarName(sym_glojure_DOT_core, sym_while) + // var glojure.core/with-bindings + var_glojure_DOT_core_with_DASH_bindings := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_bindings) // var glojure.core/with-bindings* var_glojure_DOT_core_with_DASH_bindings_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_bindings_STAR_) + // var glojure.core/with-in-str + var_glojure_DOT_core_with_DASH_in_DASH_str := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_in_DASH_str) + // var glojure.core/with-loading-context + var_glojure_DOT_core_with_DASH_loading_DASH_context := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_loading_DASH_context) + // var glojure.core/with-local-vars + var_glojure_DOT_core_with_DASH_local_DASH_vars := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_local_DASH_vars) // var glojure.core/with-meta var_glojure_DOT_core_with_DASH_meta := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_meta) + // var glojure.core/with-open + var_glojure_DOT_core_with_DASH_open := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_open) + // var glojure.core/with-out-str + var_glojure_DOT_core_with_DASH_out_DASH_str := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_out_DASH_str) + // var glojure.core/with-precision + var_glojure_DOT_core_with_DASH_precision := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_precision) + // var glojure.core/with-redefs + var_glojure_DOT_core_with_DASH_redefs := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_redefs) + // var glojure.core/with-redefs-fn + var_glojure_DOT_core_with_DASH_redefs_DASH_fn := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_redefs_DASH_fn) + // var glojure.core/xml-seq + var_glojure_DOT_core_xml_DASH_seq := lang.InternVarName(sym_glojure_DOT_core, sym_xml_DASH_seq) // var glojure.core/zero? var_glojure_DOT_core_zero_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_zero_QMARK_) // var glojure.core/zipmap @@ -2150,7 +2798,12 @@ func LoadNS() { var_glojure_DOT_go_DOT_io_make_DASH_writer := lang.InternVarName(sym_glojure_DOT_go_DOT_io, sym_make_DASH_writer) // var glojure.go.io/reader var_glojure_DOT_go_DOT_io_reader := lang.InternVarName(sym_glojure_DOT_go_DOT_io, sym_reader) - // //////////////////////////////////////////////////////////////////////////////// Closed-over values + // reference fmt to avoid unused import error + _ = fmt.Printf + // reference reflect to avoid unused import error + _ = reflect.TypeOf + ns := lang.FindOrCreateNamespace(sym_glojure_DOT_core) + _ = ns var closed0 any { closed0 = sym_unchecked_multiply @@ -2195,66 +2848,6 @@ func LoadNS() { }) closed10 = tmp0 } - var closed11 any - { - var tmp0 lang.FnFunc - tmp0 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: - v1 := args[0] - _ = v1 - v2 := args[1] - _ = v2 - tmp3 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_seq_DASH_reduce) - tmp4 := lang.Apply(tmp3, []any{v1, v2}) - return tmp4 - case 3: - v1 := args[0] - _ = v1 - v2 := args[1] - _ = v2 - v3 := args[2] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_seq_DASH_reduce) - tmp5 := lang.Apply(tmp4, []any{v1, v2, v3}) - return tmp5 - default: - checkArity(args, -1) - panic("unreachable") - } - }) - closed11 = tmp0 - } - var closed12 any - { - var tmp0 lang.FnFunc - tmp0 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: - v1 := args[0] - _ = v1 - v2 := args[1] - _ = v2 - tmp3 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_seq_DASH_reduce) - tmp4 := lang.Apply(tmp3, []any{v1, v2}) - return tmp4 - case 3: - v1 := args[0] - _ = v1 - v2 := args[1] - _ = v2 - v3 := args[2] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_seq_DASH_reduce) - tmp5 := lang.Apply(tmp4, []any{v1, v2, v3}) - return tmp5 - default: - checkArity(args, -1) - panic("unreachable") - } - }) - closed12 = tmp0 - } var closed13 any { var tmp0 lang.FnFunc @@ -2270,186 +2863,6 @@ func LoadNS() { }) closed13 = tmp0 } - var closed14 any - { - var tmp0 lang.FnFunc - tmp0 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 3) - v1 := args[0] - _ = v1 - v2 := args[1] - _ = v2 - v3 := args[2] - _ = v3 - recur_loop_1275: - var tmp4 any - { // let - // let binding "temp__0__auto__" - tmp5 := checkDerefVar(var_glojure_DOT_core_seq) - tmp6 := lang.Apply(tmp5, []any{v1}) - var v7 any = tmp6 - _ = v7 - var tmp8 any - if lang.IsTruthy(v7) { - var tmp9 any - { // let - // let binding "s" - var v10 any = v7 - _ = v10 - var tmp11 any - tmp12 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) - tmp13 := lang.Apply(tmp12, []any{v10}) - if lang.IsTruthy(tmp13) { - var tmp14 any - { // let - // let binding "ret" - tmp15 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) - tmp16 := lang.Apply(tmp15, []any{v10}) - tmp17, _ := lang.FieldOrMethod(tmp16, "ReduceInit") - if reflect.TypeOf(tmp17).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) - } - tmp18 := lang.Apply(tmp17, []any{v2, v3}) - var v19 any = tmp18 - _ = v19 - var tmp20 any - tmp21 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) - tmp22 := lang.Apply(tmp21, []any{v19}) - if lang.IsTruthy(tmp22) { - tmp23 := checkDerefVar(var_glojure_DOT_core_deref) - tmp24 := lang.Apply(tmp23, []any{v19}) - tmp20 = tmp24 - } else { - tmp26 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_next) - tmp27 := lang.Apply(tmp26, []any{v10}) - var tmp25 any = tmp27 - var tmp28 any = v2 - var tmp29 any = v19 - v1 = tmp25 - v2 = tmp28 - v3 = tmp29 - goto recur_loop_1275 - } - tmp14 = tmp20 - } // end let - tmp11 = tmp14 - } else { - tmp15 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_interface_DASH_or_DASH_naive_DASH_reduce) - tmp16 := lang.Apply(tmp15, []any{v10, v2, v3}) - tmp11 = tmp16 - } - tmp9 = tmp11 - } // end let - tmp8 = tmp9 - } else { - tmp8 = v3 - } - tmp4 = tmp8 - } // end let - return tmp4 - }) - closed14 = tmp0 - } - var closed15 any - { - var tmp0 lang.FnFunc - tmp0 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 3) - v1 := args[0] - _ = v1 - v2 := args[1] - _ = v2 - v3 := args[2] - _ = v3 - var tmp4 any - { // let - // let binding "cls" - tmp5 := checkDerefVar(var_glojure_DOT_core_class) - tmp6 := lang.Apply(tmp5, []any{v1}) - var v7 any = tmp6 - _ = v7 - // let binding "s" - var v8 any = v1 - _ = v8 - // let binding "f" - var v9 any = v2 - _ = v9 - // let binding "val" - var v10 any = v3 - _ = v10 - for { - var tmp11 any - { // let - // let binding "temp__0__auto__" - tmp12 := checkDerefVar(var_glojure_DOT_core_seq) - tmp13 := lang.Apply(tmp12, []any{v8}) - var v14 any = tmp13 - _ = v14 - var tmp15 any - if lang.IsTruthy(v14) { - var tmp16 any - { // let - // let binding "s" - var v17 any = v14 - _ = v17 - var tmp18 any - tmp19 := checkDerefVar(var_glojure_DOT_core_identical_QMARK_) - tmp20 := checkDerefVar(var_glojure_DOT_core_class) - tmp21 := lang.Apply(tmp20, []any{v17}) - tmp22 := lang.Apply(tmp19, []any{tmp21, v7}) - if lang.IsTruthy(tmp22) { - var tmp23 any - { // let - // let binding "ret" - tmp24 := checkDerefVar(var_glojure_DOT_core_first) - tmp25 := lang.Apply(tmp24, []any{v17}) - tmp26 := lang.Apply(v9, []any{v10, tmp25}) - var v27 any = tmp26 - _ = v27 - var tmp28 any - tmp29 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) - tmp30 := lang.Apply(tmp29, []any{v27}) - if lang.IsTruthy(tmp30) { - tmp31 := checkDerefVar(var_glojure_DOT_core_deref) - tmp32 := lang.Apply(tmp31, []any{v27}) - tmp28 = tmp32 - } else { - var tmp33 any = v7 - tmp35 := checkDerefVar(var_glojure_DOT_core_next) - tmp36 := lang.Apply(tmp35, []any{v17}) - var tmp34 any = tmp36 - var tmp37 any = v9 - var tmp38 any = v27 - v7 = tmp33 - v8 = tmp34 - v9 = tmp37 - v10 = tmp38 - continue - } - tmp23 = tmp28 - } // end let - tmp18 = tmp23 - } else { - tmp24 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_interface_DASH_or_DASH_naive_DASH_reduce) - tmp25 := lang.Apply(tmp24, []any{v17, v9, v10}) - tmp18 = tmp25 - } - tmp16 = tmp18 - } // end let - tmp15 = tmp16 - } else { - tmp15 = v10 - } - tmp11 = tmp15 - } // end let - tmp4 = tmp11 - break - } - } // end let - return tmp4 - }) - closed15 = tmp0 - } var closed16 any { var tmp0 lang.FnFunc @@ -2475,7 +2888,11 @@ func LoadNS() { tmp0 = tmp0.WithMeta(lang.NewMap(kw_file, "glojure/go/io.glj", kw_line, int(188), kw_column, int(18), kw_end_DASH_line, int(188), kw_end_DASH_column, int(32))).(lang.FnFunc) closed17 = tmp0 } - var closed18 any + var closed2 any + { + closed2 = sym_multiplyP + } + var closed20 any { var tmp0 lang.FnFunc tmp0 = lang.NewFnFunc(func(args ...any) any { @@ -2484,14 +2901,12 @@ func LoadNS() { _ = v1 v2 := args[1] _ = v2 - tmp3 := checkDerefVar(var_glojure_DOT_go_DOT_io_make_DASH_input_DASH_stream) - tmp4 := lang.Apply(tmp3, []any{v1, v2}) - return tmp4 + return v1 }) - tmp0 = tmp0.WithMeta(lang.NewMap(kw_file, "glojure/go/io.glj", kw_line, int(167), kw_column, int(17), kw_end_DASH_line, int(167), kw_end_DASH_column, int(56))).(lang.FnFunc) - closed18 = tmp0 + tmp0 = tmp0.WithMeta(lang.NewMap(kw_file, "glojure/go/io.glj", kw_line, int(187), kw_column, int(24), kw_end_DASH_line, int(187), kw_end_DASH_column, int(38))).(lang.FnFunc) + closed20 = tmp0 } - var closed19 any + var closed21 any { var tmp0 lang.FnFunc tmp0 = lang.NewFnFunc(func(args ...any) any { @@ -2500,20 +2915,12 @@ func LoadNS() { _ = v1 v2 := args[1] _ = v2 - tmp3 := checkDerefVar(var_glojure_DOT_go_DOT_io_make_DASH_writer) - tmp4 := checkDerefVar(var_glojure_DOT_go_DOT_io_make_DASH_output_DASH_stream) - tmp5 := lang.Apply(tmp4, []any{v1, v2}) - tmp6 := lang.Apply(tmp3, []any{tmp5, v2}) - return tmp6 + return v1 }) - tmp0 = tmp0.WithMeta(lang.NewMap(kw_file, "glojure/go/io.glj", kw_line, int(168), kw_column, int(17), kw_end_DASH_line, int(168), kw_end_DASH_column, int(76))).(lang.FnFunc) - closed19 = tmp0 - } - var closed2 any - { - closed2 = sym_multiplyP + tmp0 = tmp0.WithMeta(lang.NewMap(kw_file, "glojure/go/io.glj", kw_line, int(226), kw_column, int(24), kw_end_DASH_line, int(226), kw_end_DASH_column, int(48))).(lang.FnFunc) + closed21 = tmp0 } - var closed20 any + var closed25 any { var tmp0 lang.FnFunc tmp0 = lang.NewFnFunc(func(args ...any) any { @@ -2524,1000 +2931,919 @@ func LoadNS() { _ = v2 return v1 }) - tmp0 = tmp0.WithMeta(lang.NewMap(kw_file, "glojure/go/io.glj", kw_line, int(187), kw_column, int(24), kw_end_DASH_line, int(187), kw_end_DASH_column, int(38))).(lang.FnFunc) - closed20 = tmp0 + tmp0 = tmp0.WithMeta(lang.NewMap(kw_file, "glojure/go/io.glj", kw_line, int(227), kw_column, int(25), kw_end_DASH_line, int(227), kw_end_DASH_column, int(49))).(lang.FnFunc) + closed25 = tmp0 } - var closed21 any + var closed28 any + { + closed28 = sym_divide + } + var closed29 any + { + closed29 = sym_and + } + var closed3 any + { + closed3 = sym_unchecked_add + } + var closed30 any + { + closed30 = sym_andNot + } + var closed31 any + { + closed31 = sym_or + } + var closed32 any + { + closed32 = sym_xor + } + var closed33 any + { + closed33 = sym_max + } + var closed34 any + { + closed34 = sym_min + } + var closed35 any { var tmp0 lang.FnFunc tmp0 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) + checkArity(args, 1) v1 := args[0] _ = v1 - v2 := args[1] - _ = v2 - return v1 + var tmp2 any + if lang.IsTruthy(v1) { + tmp2 = false + } else { + tmp2 = true + } + return tmp2 }) - tmp0 = tmp0.WithMeta(lang.NewMap(kw_file, "glojure/go/io.glj", kw_line, int(226), kw_column, int(24), kw_end_DASH_line, int(226), kw_end_DASH_column, int(48))).(lang.FnFunc) - closed21 = tmp0 + tmp1 := reflect.TypeOf(false) + tmp0 = tmp0.WithMeta(lang.NewMap(kw_rettag, tmp1)).(lang.FnFunc) + closed35 = tmp0 } - var closed22 any + var closed4 any + { + closed4 = sym_add + } + var closed5 any + { + closed5 = sym_addP + } + var closed6 any + { + closed6 = sym_unchecked_minus + } + var closed7 any + { + closed7 = sym_minus + } + var closed8 any + { + closed8 = sym_minusP + } + var closed9 any { var tmp0 lang.FnFunc tmp0 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v1 := args[0] - _ = v1 - v2 := args[1] + switch len(args) { + case 2: + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + tmp3 := lang.Apply(v2, nil) + return tmp3 + case 3: + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + v3 := args[2] + _ = v3 + return v3 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + closed9 = tmp0 + } + // >0? + { + tmp0 := sym__GT_0_QMARK_.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(963), kw_column, int(7), kw_end_DASH_line, int(963), kw_end_DASH_column, int(19), kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] _ = v2 - tmp3 := checkDerefVar(var_glojure_DOT_go_DOT_io_make_DASH_input_DASH_stream) - var tmp4 any - tmp5 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp6, ok := lang.FieldOrMethod(v1, "scheme") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v1, "scheme"))) + tmp3, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - var tmp7 any - switch reflect.TypeOf(tmp6).Kind() { - case reflect.Func: - tmp7 = lang.Apply(tmp6, nil) - default: - tmp7 = tmp6 + tmp4 := lang.Apply(tmp3, []any{nil, int64(0)}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__GT_0_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__GT_0_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // >1? + { + tmp0 := sym__GT_1_QMARK_.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(962), kw_column, int(7), kw_end_DASH_line, int(962), kw_end_DASH_column, int(19), kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp8 := lang.Apply(tmp5, []any{"file", tmp7}) - if lang.IsTruthy(tmp8) { - tmp9 := lang.Apply(nil, []any{v1}) - tmp4 = tmp9 - } else { - var tmp10 any - { // let - // let binding "req" - var tmp11 any - { // let - // let binding "res__0__auto__" - tmp12, ok := lang.FieldOrMethod(v1, "String") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v1, "String"))) - } - var tmp13 any - switch reflect.TypeOf(tmp12).Kind() { - case reflect.Func: - tmp13 = lang.Apply(tmp12, nil) - default: - tmp13 = tmp12 - } - tmp14 := lang.Apply(http17.NewRequest, []any{http17.MethodGet, tmp13, nil}) - var v15 any = tmp14 - _ = v15 - // let binding "vec__295" - var tmp16 any - tmp17 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) - tmp18 := lang.Apply(tmp17, []any{v15}) - if lang.IsTruthy(tmp18) { - tmp19 := checkDerefVar(var_glojure_DOT_core_pop) - tmp20 := lang.Apply(tmp19, []any{v15}) - tmp21 := checkDerefVar(var_glojure_DOT_core_last) - tmp22 := lang.Apply(tmp21, []any{v15}) - tmp23 := lang.NewVector(tmp20, tmp22) - tmp24 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(358), kw_column, int(10), kw_end_DASH_line, int(358), kw_end_DASH_column, int(14)) - tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp16 = tmp25 - } else { - tmp26 := lang.NewVector(nil, v15) - tmp27 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(358), kw_column, int(10), kw_end_DASH_line, int(358), kw_end_DASH_column, int(14)) - tmp28, err := lang.WithMeta(tmp26, tmp27.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp16 = tmp28 - } - var v29 any = tmp16 - _ = v29 - // let binding "vec__298" - tmp30 := checkDerefVar(var_glojure_DOT_core_nth) - tmp31 := lang.Apply(tmp30, []any{v29, int64(0), nil}) - var v32 any = tmp31 - _ = v32 - // let binding "seq__299" - tmp33 := checkDerefVar(var_glojure_DOT_core_seq) - tmp34 := lang.Apply(tmp33, []any{v32}) - var v35 any = tmp34 - _ = v35 - // let binding "first__300" - tmp36 := checkDerefVar(var_glojure_DOT_core_first) - tmp37 := lang.Apply(tmp36, []any{v35}) - var v38 any = tmp37 - _ = v38 - // let binding "seq__299" - tmp39 := checkDerefVar(var_glojure_DOT_core_next) - tmp40 := lang.Apply(tmp39, []any{v35}) - var v41 any = tmp40 - _ = v41 - // let binding "fst__1__auto__" - var v42 any = v38 - _ = v42 - // let binding "rst__2__auto__" - var v43 any = v41 - _ = v43 - // let binding "res__0__auto__" - var v44 any = v32 - _ = v44 - // let binding "err__3__auto__" - tmp45 := checkDerefVar(var_glojure_DOT_core_nth) - tmp46 := lang.Apply(tmp45, []any{v29, int64(1), nil}) - var v47 any = tmp46 - _ = v47 - // let binding "res__0__auto__" - var tmp48 any - tmp49 := checkDerefVar(var_glojure_DOT_core_not_DASH_empty) - tmp50 := lang.Apply(tmp49, []any{v43}) - if lang.IsTruthy(tmp50) { - tmp48 = v44 - } else { - tmp48 = v42 - } - var v51 any = tmp48 - _ = v51 - var tmp52 any - if lang.IsTruthy(v47) { - panic(v47) - } else { - } - _ = tmp52 - tmp11 = v51 - } // end let - var v12 any = tmp11 - _ = v12 - // let binding "res" - var tmp13 any - { // let - // let binding "res__0__auto__" - tmp14, _ := lang.FieldOrMethod(http17.DefaultClient, "Do") - if reflect.TypeOf(tmp14).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Do is not a function"))) - } - tmp15 := lang.Apply(tmp14, []any{v12}) - var v16 any = tmp15 - _ = v16 - // let binding "vec__301" - var tmp17 any - tmp18 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) - tmp19 := lang.Apply(tmp18, []any{v16}) - if lang.IsTruthy(tmp19) { - tmp20 := checkDerefVar(var_glojure_DOT_core_pop) - tmp21 := lang.Apply(tmp20, []any{v16}) - tmp22 := checkDerefVar(var_glojure_DOT_core_last) - tmp23 := lang.Apply(tmp22, []any{v16}) - tmp24 := lang.NewVector(tmp21, tmp23) - tmp25 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(358), kw_column, int(10), kw_end_DASH_line, int(358), kw_end_DASH_column, int(14)) - tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp17 = tmp26 - } else { - tmp27 := lang.NewVector(nil, v16) - tmp28 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(358), kw_column, int(10), kw_end_DASH_line, int(358), kw_end_DASH_column, int(14)) - tmp29, err := lang.WithMeta(tmp27, tmp28.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp17 = tmp29 - } - var v30 any = tmp17 - _ = v30 - // let binding "vec__304" - tmp31 := checkDerefVar(var_glojure_DOT_core_nth) - tmp32 := lang.Apply(tmp31, []any{v30, int64(0), nil}) - var v33 any = tmp32 - _ = v33 - // let binding "seq__305" - tmp34 := checkDerefVar(var_glojure_DOT_core_seq) - tmp35 := lang.Apply(tmp34, []any{v33}) - var v36 any = tmp35 - _ = v36 - // let binding "first__306" - tmp37 := checkDerefVar(var_glojure_DOT_core_first) - tmp38 := lang.Apply(tmp37, []any{v36}) - var v39 any = tmp38 - _ = v39 - // let binding "seq__305" - tmp40 := checkDerefVar(var_glojure_DOT_core_next) - tmp41 := lang.Apply(tmp40, []any{v36}) - var v42 any = tmp41 - _ = v42 - // let binding "fst__1__auto__" - var v43 any = v39 - _ = v43 - // let binding "rst__2__auto__" - var v44 any = v42 - _ = v44 - // let binding "res__0__auto__" - var v45 any = v33 - _ = v45 - // let binding "err__3__auto__" - tmp46 := checkDerefVar(var_glojure_DOT_core_nth) - tmp47 := lang.Apply(tmp46, []any{v30, int64(1), nil}) - var v48 any = tmp47 - _ = v48 - // let binding "res__0__auto__" - var tmp49 any - tmp50 := checkDerefVar(var_glojure_DOT_core_not_DASH_empty) - tmp51 := lang.Apply(tmp50, []any{v44}) - if lang.IsTruthy(tmp51) { - tmp49 = v45 - } else { - tmp49 = v43 - } - var v52 any = tmp49 - _ = v52 - var tmp53 any - if lang.IsTruthy(v48) { - panic(v48) - } else { - } - _ = tmp53 - tmp13 = v52 - } // end let - var v14 any = tmp13 - _ = v14 - // let binding "status" - tmp15, ok := lang.FieldOrMethod(v14, "StatusCode") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v14, "StatusCode"))) - } - var tmp16 any - switch reflect.TypeOf(tmp15).Kind() { - case reflect.Func: - tmp16 = lang.Apply(tmp15, nil) - default: - tmp16 = tmp15 - } - var v17 any = tmp16 - _ = v17 - // let binding "body" - tmp18, ok := lang.FieldOrMethod(v14, "Body") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v14, "Body"))) - } - var tmp19 any - switch reflect.TypeOf(tmp18).Kind() { - case reflect.Func: - tmp19 = lang.Apply(tmp18, nil) - default: - tmp19 = tmp18 - } - var v20 any = tmp19 - _ = v20 - var tmp21 any - tmp22 := checkDerefVar(var_glojure_DOT_core_not_EQ_) - tmp23 := lang.Apply(tmp22, []any{int64(200), v17}) - if lang.IsTruthy(tmp23) { - tmp24, ok := lang.FieldOrMethod(v20, "Close") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v20, "Close"))) - } - var tmp25 any - switch reflect.TypeOf(tmp24).Kind() { - case reflect.Func: - tmp25 = lang.Apply(tmp24, nil) - default: - tmp25 = tmp24 - } - _ = tmp25 - tmp26 := lang.Apply(fmt.Errorf, []any{"http error: %s", v17}) - panic(tmp26) - } else { - } - _ = tmp21 - tmp10 = v20 - } // end let - tmp4 = tmp10 - } - tmp11 := lang.Apply(tmp3, []any{tmp4, v2}) - return tmp11 + tmp4 := lang.Apply(tmp3, []any{nil, int64(1)}) + return tmp4 }) - tmp0 = tmp0.WithMeta(lang.NewMap(kw_file, "glojure/go/io.glj", kw_line, int(232), kw_column, int(24), kw_end_DASH_line, int(244), kw_end_DASH_column, int(32))).(lang.FnFunc) - closed22 = tmp0 + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__GT_1_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__GT_1_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } } - var closed23 any + // *1 { - var tmp0 lang.FnFunc - tmp0 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v1 := args[0] - _ = v1 - v2 := args[1] - _ = v2 - var tmp3 any - { // let - // let binding "vec__307" - tmp4 := lang.Apply(url5.ParseRequestURI, []any{v1}) - var v5 any = tmp4 - _ = v5 - // let binding "url" - tmp6 := checkDerefVar(var_glojure_DOT_core_nth) - tmp7 := lang.Apply(tmp6, []any{v5, int64(0), nil}) - var v8 any = tmp7 - _ = v8 - // let binding "err" - tmp9 := checkDerefVar(var_glojure_DOT_core_nth) - tmp10 := lang.Apply(tmp9, []any{v5, int64(1), nil}) - var v11 any = tmp10 - _ = v11 - var tmp12 any - if lang.IsTruthy(v11) { - tmp13 := checkDerefVar(var_glojure_DOT_go_DOT_io_make_DASH_input_DASH_stream) - var tmp14 any - { // let - // let binding "res__0__auto__" - tmp15 := lang.Apply(os6.Open, []any{v1}) - var v16 any = tmp15 - _ = v16 - // let binding "vec__310" - var tmp17 any - tmp18 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) - tmp19 := lang.Apply(tmp18, []any{v16}) - if lang.IsTruthy(tmp19) { - tmp20 := checkDerefVar(var_glojure_DOT_core_pop) - tmp21 := lang.Apply(tmp20, []any{v16}) - tmp22 := checkDerefVar(var_glojure_DOT_core_last) - tmp23 := lang.Apply(tmp22, []any{v16}) - tmp24 := lang.NewVector(tmp21, tmp23) - tmp25 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(358), kw_column, int(10), kw_end_DASH_line, int(358), kw_end_DASH_column, int(14)) - tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp17 = tmp26 - } else { - tmp27 := lang.NewVector(nil, v16) - tmp28 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(358), kw_column, int(10), kw_end_DASH_line, int(358), kw_end_DASH_column, int(14)) - tmp29, err := lang.WithMeta(tmp27, tmp28.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp17 = tmp29 - } - var v30 any = tmp17 - _ = v30 - // let binding "vec__313" - tmp31 := checkDerefVar(var_glojure_DOT_core_nth) - tmp32 := lang.Apply(tmp31, []any{v30, int64(0), nil}) - var v33 any = tmp32 - _ = v33 - // let binding "seq__314" - tmp34 := checkDerefVar(var_glojure_DOT_core_seq) - tmp35 := lang.Apply(tmp34, []any{v33}) - var v36 any = tmp35 - _ = v36 - // let binding "first__315" - tmp37 := checkDerefVar(var_glojure_DOT_core_first) - tmp38 := lang.Apply(tmp37, []any{v36}) - var v39 any = tmp38 - _ = v39 - // let binding "seq__314" - tmp40 := checkDerefVar(var_glojure_DOT_core_next) - tmp41 := lang.Apply(tmp40, []any{v36}) - var v42 any = tmp41 - _ = v42 - // let binding "fst__1__auto__" - var v43 any = v39 - _ = v43 - // let binding "rst__2__auto__" - var v44 any = v42 - _ = v44 - // let binding "res__0__auto__" - var v45 any = v33 - _ = v45 - // let binding "err__3__auto__" - tmp46 := checkDerefVar(var_glojure_DOT_core_nth) - tmp47 := lang.Apply(tmp46, []any{v30, int64(1), nil}) - var v48 any = tmp47 - _ = v48 - // let binding "res__0__auto__" - var tmp49 any - tmp50 := checkDerefVar(var_glojure_DOT_core_not_DASH_empty) - tmp51 := lang.Apply(tmp50, []any{v44}) - if lang.IsTruthy(tmp51) { - tmp49 = v45 - } else { - tmp49 = v43 - } - var v52 any = tmp49 - _ = v52 - var tmp53 any - if lang.IsTruthy(v48) { - panic(v48) - } else { - } - _ = tmp53 - tmp14 = v52 - } // end let - tmp15 := lang.Apply(tmp13, []any{tmp14, v2}) - tmp12 = tmp15 - } else { - tmp16 := checkDerefVar(var_glojure_DOT_go_DOT_io_make_DASH_input_DASH_stream) - tmp17 := lang.Apply(tmp16, []any{v8, v2}) - tmp12 = tmp17 - } - tmp3 = tmp12 - } // end let - return tmp3 - }) - tmp0 = tmp0.WithMeta(lang.NewMap(kw_file, "glojure/go/io.glj", kw_line, int(259), kw_column, int(24), kw_end_DASH_line, int(263), kw_end_DASH_column, int(60))).(lang.FnFunc) - closed23 = tmp0 + tmp0 := sym__STAR_1.WithMeta(lang.NewMap()).(*lang.Symbol) + var_glojure_DOT_core__STAR_1 = ns.Intern(tmp0) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } } - var closed24 any + // *2 { - var tmp0 lang.FnFunc - tmp0 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v1 := args[0] - _ = v1 - v2 := args[1] - _ = v2 - tmp3 := checkDerefVar(var_glojure_DOT_core_str) - tmp4 := checkDerefVar(var_glojure_DOT_core_pr_DASH_str) - tmp5 := lang.Apply(tmp4, []any{v1}) - tmp6 := lang.Apply(tmp3, []any{"Cannot open <", tmp5, "> as an OutputStream."}) - tmp7 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp6}) - panic(tmp7) - }) - tmp0 = tmp0.WithMeta(lang.NewMap(kw_file, "glojure/go/io.glj", kw_line, int(172), kw_column, int(24), kw_end_DASH_line, int(174), kw_end_DASH_column, int(92))).(lang.FnFunc) - closed24 = tmp0 + tmp0 := sym__STAR_2.WithMeta(lang.NewMap()).(*lang.Symbol) + var_glojure_DOT_core__STAR_2 = ns.Intern(tmp0) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } } - var closed25 any + // *3 { - var tmp0 lang.FnFunc - tmp0 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym__STAR_3.WithMeta(lang.NewMap()).(*lang.Symbol) + var_glojure_DOT_core__STAR_3 = ns.Intern(tmp0) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *agent* + { + tmp0 := sym__STAR_agent_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_agent_STAR_ = ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_agent_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *assert* + { + tmp0 := sym__STAR_assert_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "When set to logical false, 'assert' will omit assertion checks in\n compiled code. Defaults to true.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_assert_STAR_ = ns.InternWithValue(tmp0, false, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_assert_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *command-line-args* + { + tmp0 := sym__STAR_command_DASH_line_DASH_args_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "A sequence of the supplied command line arguments, or nil if\n none were supplied", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_command_DASH_line_DASH_args_STAR_ = ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_command_DASH_line_DASH_args_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *compile-files* + { + tmp0 := sym__STAR_compile_DASH_files_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "Set to true when compiling files, false otherwise.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_compile_DASH_files_STAR_ = ns.InternWithValue(tmp0, false, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_compile_DASH_files_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *compile-path* + { + tmp0 := sym__STAR_compile_DASH_path_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "Specifies the directory where 'compile' will write out .class\n files. This directory must be in the classpath for 'compile' to\n work.\n\n Defaults to \"classes\"", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_compile_DASH_path_STAR_ = ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_compile_DASH_path_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *compiler-options* + { + tmp0 := sym__STAR_compiler_DASH_options_STAR_.WithMeta(lang.NewMap(kw_added, "1.4", kw_doc, "A map of keys to options.\n Note, when binding dynamically make sure to merge with previous value.\n Supported options:\n :elide-meta - a collection of metadata keys to elide during compilation.\n :disable-locals-clearing - set to true to disable clearing, useful for using a debugger\n :direct-linking - set to true to use direct static invocation of functions, rather than vars\n Note that call sites compiled with direct linking will not be affected by var redefinition.\n Use ^:redef (or ^:dynamic) on a var to prevent direct linking and allow redefinition.\n See https://glojure.org/reference/compilation for more information.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_compiler_DASH_options_STAR_ = ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_compiler_DASH_options_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *data-readers* + { + tmp0 := sym__STAR_data_DASH_readers_STAR_.WithMeta(lang.NewMap(kw_doc, "Map from reader tag symbols to data reader Vars.\n\n When Clojure starts, it searches for files named 'data_readers.clj'\n and 'data_readers.cljc' at the root of the classpath. Each such file\n must contain a literal map of symbols, like this:\n\n {foo/bar my.project.foo/bar\n foo/baz my.project/baz}\n\n The first symbol in each pair is a tag that will be recognized by\n the Clojure reader. The second symbol in the pair is the\n fully-qualified name of a Var which will be invoked by the reader to\n parse the form following the tag. For example, given the\n data_readers.clj file above, the Clojure reader would parse this\n form:\n\n #foo/bar [1 2 3]\n\n by invoking the Var #'my.project.foo/bar on the vector [1 2 3]. The\n data reader function is invoked on the form AFTER it has been read\n as a normal Clojure data structure by the reader.\n\n Reader tags without namespace qualifiers are reserved for\n Clojure. Default reader tags are defined in\n glojure.core/default-data-readers but may be overridden in\n data_readers.clj, data_readers.cljc, or by rebinding this Var.", kw_file, "glojure/core.glj", kw_added, "1.4", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(49), kw_column, int(6), kw_line, int(7794), kw_end_DASH_line, int(7794), kw_dynamic, true)).(*lang.Symbol) + var_glojure_DOT_core__STAR_data_DASH_readers_STAR_ = ns.InternWithValue(tmp0, lang.NewMap(), true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_data_DASH_readers_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *default-data-reader-fn* + { + tmp0 := sym__STAR_default_DASH_data_DASH_reader_DASH_fn_STAR_.WithMeta(lang.NewMap(kw_doc, "When no data reader is found for a tag and *default-data-reader-fn*\n is non-nil, it will be called with two arguments,\n the tag and the value. If *default-data-reader-fn* is nil (the\n default), an exception will be thrown for the unknown tag.", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(59), kw_column, int(6), kw_line, int(7823), kw_end_DASH_line, int(7823), kw_dynamic, true)).(*lang.Symbol) + var_glojure_DOT_core__STAR_default_DASH_data_DASH_reader_DASH_fn_STAR_ = ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_default_DASH_data_DASH_reader_DASH_fn_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *e + { + tmp0 := sym__STAR_e.WithMeta(lang.NewMap()).(*lang.Symbol) + var_glojure_DOT_core__STAR_e = ns.Intern(tmp0) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_e.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *err* + { + tmp0 := sym__STAR_err_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "A java.io.Writer object representing standard error for print operations.\n\n Defaults to System/err, wrapped in a PrintWriter", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_err_STAR_ = ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_err_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *file* + { + tmp0 := sym__STAR_file_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "The path of the file being evaluated, as a String.\n\n When there is no file, e.g. in the REPL, the value is not defined.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_file_STAR_ = ns.InternWithValue(tmp0, "NO_SOURCE_FILE", true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_file_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *flush-on-newline* + { + tmp0 := sym__STAR_flush_DASH_on_DASH_newline_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "When set to true, output will be flushed whenever a newline is printed.\n\n Defaults to true.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_flush_DASH_on_DASH_newline_STAR_ = ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_flush_DASH_on_DASH_newline_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *loaded-libs* + { + tmp0 := sym__STAR_loaded_DASH_libs_STAR_.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core.glj", kw_line, int(5817), kw_column, int(10), kw_end_DASH_line, int(5820), kw_end_DASH_column, int(15), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + tmp1 := lang.NewRef(lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{sym_glojure_DOT_core_DOT_protocols, sym_glojure_DOT_string, sym_glojure_DOT_go_DOT_io}))) + var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *loading-verbosely* + { + tmp0 := sym__STAR_loading_DASH_verbosely_STAR_.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core.glj", kw_line, int(5827), kw_column, int(10), kw_end_DASH_line, int(5830), kw_end_DASH_column, int(21), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_ = ns.InternWithValue(tmp0, false, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *ns* + { + tmp0 := sym__STAR_ns_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "A glojure.lang.Namespace object representing the current namespace.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_ns_STAR_ = ns.InternWithValue(tmp0, lang.FindOrCreateNamespace(sym_glojure_DOT_core), true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_ns_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *pending-paths* + { + tmp0 := sym__STAR_pending_DASH_paths_STAR_.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core.glj", kw_line, int(5822), kw_column, int(10), kw_end_DASH_line, int(5825), kw_end_DASH_column, int(17), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_ = ns.InternWithValue(tmp0, lang.NewList(), true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *print-dup* + { + tmp0 := sym__STAR_print_DASH_dup_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "When set to logical true, objects will be printed in a way that preserves\n their type when read in later.\n\n Defaults to false.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_print_DASH_dup_STAR_ = ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_print_DASH_dup_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *print-length* + { + tmp0 := sym__STAR_print_DASH_length_STAR_.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core_print.glj", kw_line, int(14), kw_column, int(6), kw_end_DASH_line, int(23), kw_end_DASH_column, int(15), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_print_DASH_length_STAR_ = ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_print_DASH_length_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *print-level* + { + tmp0 := sym__STAR_print_DASH_level_STAR_.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core_print.glj", kw_line, int(25), kw_column, int(6), kw_end_DASH_line, int(35), kw_end_DASH_column, int(14), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_print_DASH_level_STAR_ = ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_print_DASH_level_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *print-meta* + { + tmp0 := sym__STAR_print_DASH_meta_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "If set to logical true, when printing an object, its metadata will also\n be printed in a form that can be read back by the reader.\n\n Defaults to false.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_print_DASH_meta_STAR_ = ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_print_DASH_meta_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *print-namespace-maps* + { + tmp0 := sym__STAR_print_DASH_namespace_DASH_maps_STAR_.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core_print.glj", kw_line, int(39), kw_column, int(6), kw_end_DASH_line, int(44), kw_end_DASH_column, int(23), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_print_DASH_namespace_DASH_maps_STAR_ = ns.InternWithValue(tmp0, false, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_print_DASH_namespace_DASH_maps_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *print-readably* + { + tmp0 := sym__STAR_print_DASH_readably_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "When set to logical false, strings and characters will be printed with\n non-alphanumeric characters converted to the appropriate escape sequences.\n\n Defaults to true", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_print_DASH_readably_STAR_ = ns.InternWithValue(tmp0, true, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_print_DASH_readably_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *read-eval* + { + tmp0 := sym__STAR_read_DASH_eval_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "Defaults to true (or value specified by system property, see below)\n ***This setting implies that the full power of the reader is in play,\n including syntax that can cause code to execute. It should never be\n used with untrusted sources. See also: glojure.edn/read.***\n\n When set to logical false in the thread-local binding,\n the eval reader (#=) and record/type literal syntax are disabled in read/load.\n Example (will fail): (binding [*read-eval* false] (read-string \"#=(* 2 21)\"))\n\n The default binding can be controlled by the system property\n 'glojure.read.eval' System properties can be set on the command line\n like this:\n\n java -Dglojure.read.eval=false ...\n\n The system property can also be set to 'unknown' via\n -Dglojure.read.eval=unknown, in which case the default binding\n is :unknown and all reads will fail in contexts where *read-eval*\n has not been explicitly bound to either true or false. This setting\n can be a useful diagnostic tool to ensure that all of your reads\n occur in considered contexts. You can also accomplish this in a\n particular scope by binding *read-eval* to :unknown\n ", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_read_DASH_eval_STAR_ = ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_read_DASH_eval_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *repl* + { + tmp0 := sym__STAR_repl_STAR_.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core.glj", kw_line, int(6288), kw_column, int(6), kw_end_DASH_line, int(6291), kw_end_DASH_column, int(8), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_repl_STAR_ = ns.InternWithValue(tmp0, false, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_repl_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *unchecked-math* + { + tmp0 := sym__STAR_unchecked_DASH_math_STAR_.WithMeta(lang.NewMap(kw_added, "1.3", kw_doc, "While bound to true, compilations of +, -, *, inc, dec and the\n coercions will be done without overflow checks. While bound\n to :warn-on-boxed, same behavior as true, and a warning is emitted\n when compilation uses boxed math. Default: false.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_ = ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *verbose-defrecords* + { + tmp0 := sym__STAR_verbose_DASH_defrecords_STAR_.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core_print.glj", kw_line, int(37), kw_column, int(6), kw_end_DASH_line, int(37), kw_end_DASH_column, int(35), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_verbose_DASH_defrecords_STAR_ = ns.InternWithValue(tmp0, false, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_verbose_DASH_defrecords_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *warn-on-reflection* + { + tmp0 := sym__STAR_warn_DASH_on_DASH_reflection_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "When set to true, the compiler will emit warnings when reflection is\n needed to resolve Java method calls or field accesses.\n\n Defaults to false.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_warn_DASH_on_DASH_reflection_STAR_ = ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_warn_DASH_on_DASH_reflection_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // accessor + { + tmp0 := sym_accessor.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s, sym_key)), kw_doc, "Returns a fn that, given an instance of a structmap with the basis,\n returns the value at the key. The key must be in the basis. The\n returned function should be (slightly) more efficient than using\n get, but such use of accessors should be limited to known\n performance-critical areas.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(4070), kw_end_DASH_line, int(4070))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 2) - v1 := args[0] - _ = v1 - v2 := args[1] + v2 := args[0] _ = v2 - return v1 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(nil, "getAccessor") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getAccessor is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + return tmp5 }) - tmp0 = tmp0.WithMeta(lang.NewMap(kw_file, "glojure/go/io.glj", kw_line, int(227), kw_column, int(25), kw_end_DASH_line, int(227), kw_end_DASH_column, int(49))).(lang.FnFunc) - closed25 = tmp0 + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_accessor = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_accessor.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } } - var closed26 any + // add-watch { - var tmp0 lang.FnFunc - tmp0 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v1 := args[0] - _ = v1 - v2 := args[1] + tmp0 := sym_add_DASH_watch.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_reference, sym_key, sym_fn)), kw_doc, "Adds a watch function to an agent/atom/var/ref reference. The watch\n fn must be a fn of 4 args: a key, the reference, its old-state, its\n new-state. Whenever the reference's state might have been changed,\n any registered watches will have their functions called. The watch fn\n will be called synchronously, on the agent's thread if an agent,\n before any pending sends if agent or ref. Note that an atom's or\n ref's state may have changed again prior to the fn call, so use\n old/new-state rather than derefing the reference. Note also that watch\n fns may be called from multiple threads simultaneously. Var watchers\n are triggered only by root binding changes, not thread-local\n set!s. Keys must be unique per reference, and can be used to remove\n the watch with remove-watch, but are otherwise considered opaque by\n the watch mechanism.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(2142), kw_end_DASH_line, int(2142))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] _ = v2 - var tmp3 any - tmp4 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp5, ok := lang.FieldOrMethod(v1, "scheme") + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5, _ := lang.FieldOrMethod(v2, "addWatch") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("addWatch is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_add_DASH_watch = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_add_DASH_watch.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // agent-error + { + tmp0 := sym_agent_DASH_error.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a)), kw_doc, "Returns the exception thrown during an asynchronous action of the\n agent if the agent is failed. Returns nil if the agent is not\n failed.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(2167), kw_end_DASH_line, int(2167))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "getError") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v1, "scheme"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getError"))) } - var tmp6 any - switch reflect.TypeOf(tmp5).Kind() { + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { case reflect.Func: - tmp6 = lang.Apply(tmp5, nil) + tmp4 = lang.Apply(tmp3, nil) default: - tmp6 = tmp5 + tmp4 = tmp3 } - tmp7 := lang.Apply(tmp4, []any{"file", tmp6}) - if lang.IsTruthy(tmp7) { - tmp8 := checkDerefVar(var_glojure_DOT_go_DOT_io_make_DASH_output_DASH_stream) - tmp9 := lang.Apply(nil, []any{v1}) - tmp10 := lang.Apply(tmp8, []any{tmp9, v2}) - tmp3 = tmp10 - } else { - tmp11 := checkDerefVar(var_glojure_DOT_core_str) - tmp12 := lang.Apply(tmp11, []any{"Can not write to non-file URL <", v1, ">"}) - tmp13 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp12}) - panic(tmp13) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_agent_DASH_error = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_agent_DASH_error.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // all-ns + { + tmp0 := sym_all_DASH_ns.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Returns a sequence of all namespaces.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(4146), kw_end_DASH_line, int(4146))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp2 := lang.Apply(nil, nil) + return tmp2 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_all_DASH_ns = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_all_DASH_ns.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // alter + { + tmp0 := sym_alter.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ref, sym_fun, sym__AMP_, sym_args)), kw_doc, "Must be called in a transaction. Sets the in-transaction-value of\n ref to:\n\n (apply fun in-transaction-value-of-ref args)\n\n and returns the in-transaction-value of ref.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(2435), kw_end_DASH_line, int(2435))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5, _ := lang.FieldOrMethod(v2, "alter") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("alter is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 } - return tmp3 }) - tmp0 = tmp0.WithMeta(lang.NewMap(kw_file, "glojure/go/io.glj", kw_line, int(245), kw_column, int(25), kw_end_DASH_line, int(248), kw_end_DASH_column, int(149))).(lang.FnFunc) - closed26 = tmp0 + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_alter = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_alter.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } } - var closed27 any + // alter-meta! { - var tmp0 lang.FnFunc - tmp0 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_alter_DASH_meta_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_iref, sym_f, sym__AMP_, sym_args)), kw_doc, "Atomically sets the metadata for a namespace/var/ref/agent/atom to be:\n\n (apply f its-current-meta args)\n\n f must be free of side-effects", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(2398), kw_end_DASH_line, int(2398))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5, _ := lang.FieldOrMethod(v2, "AlterMeta") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("AlterMeta is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_alter_DASH_meta_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_alter_DASH_meta_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // alter-var-root + { + tmp0 := sym_alter_DASH_var_DASH_root.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_v, sym_f, sym__AMP_, sym_args)), kw_doc, "Atomically alters the root binding of var v by applying f to its\n current value plus any args", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(5484), kw_end_DASH_line, int(5484))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5, _ := lang.FieldOrMethod(v2, "alterRoot") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("alterRoot is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_alter_DASH_var_DASH_root = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_alter_DASH_var_DASH_root.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // any? + { + tmp1 := reflect.TypeOf(false) + tmp0 := sym_any_QMARK_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true given any argument.", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(537), kw_end_DASH_line, int(537))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + return true + }) + tmp3 := reflect.TypeOf(false) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_any_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_any_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bit-clear + { + tmp0 := sym_bit_DASH_clear.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_n)), kw_doc, "Clear bit at index n", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(1336), kw_end_DASH_line, int(1336))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 2) - v1 := args[0] - _ = v1 - v2 := args[1] + v2 := args[0] _ = v2 - var tmp3 any - func() { - defer func() { - if r := recover(); r != nil { - if lang.CatchMatches(r, lang.Builtins["any"]) { - v4 := r - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_go_DOT_io_make_DASH_output_DASH_stream) - var tmp6 any - { // let - // let binding "res__0__auto__" - tmp7 := lang.Apply(os6.Open, []any{v1}) - tmp8 := lang.Apply(tmp7, nil) - var v9 any = tmp8 - _ = v9 - // let binding "vec__322" - var tmp10 any - tmp11 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) - tmp12 := lang.Apply(tmp11, []any{v9}) - if lang.IsTruthy(tmp12) { - tmp13 := checkDerefVar(var_glojure_DOT_core_pop) - tmp14 := lang.Apply(tmp13, []any{v9}) - tmp15 := checkDerefVar(var_glojure_DOT_core_last) - tmp16 := lang.Apply(tmp15, []any{v9}) - tmp17 := lang.NewVector(tmp14, tmp16) - tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(358), kw_column, int(10), kw_end_DASH_line, int(358), kw_end_DASH_column, int(14)) - tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp10 = tmp19 - } else { - tmp20 := lang.NewVector(nil, v9) - tmp21 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(358), kw_column, int(10), kw_end_DASH_line, int(358), kw_end_DASH_column, int(14)) - tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp10 = tmp22 - } - var v23 any = tmp10 - _ = v23 - // let binding "vec__325" - tmp24 := checkDerefVar(var_glojure_DOT_core_nth) - tmp25 := lang.Apply(tmp24, []any{v23, int64(0), nil}) - var v26 any = tmp25 - _ = v26 - // let binding "seq__326" - tmp27 := checkDerefVar(var_glojure_DOT_core_seq) - tmp28 := lang.Apply(tmp27, []any{v26}) - var v29 any = tmp28 - _ = v29 - // let binding "first__327" - tmp30 := checkDerefVar(var_glojure_DOT_core_first) - tmp31 := lang.Apply(tmp30, []any{v29}) - var v32 any = tmp31 - _ = v32 - // let binding "seq__326" - tmp33 := checkDerefVar(var_glojure_DOT_core_next) - tmp34 := lang.Apply(tmp33, []any{v29}) - var v35 any = tmp34 - _ = v35 - // let binding "fst__1__auto__" - var v36 any = v32 - _ = v36 - // let binding "rst__2__auto__" - var v37 any = v35 - _ = v37 - // let binding "res__0__auto__" - var v38 any = v26 - _ = v38 - // let binding "err__3__auto__" - tmp39 := checkDerefVar(var_glojure_DOT_core_nth) - tmp40 := lang.Apply(tmp39, []any{v23, int64(1), nil}) - var v41 any = tmp40 - _ = v41 - // let binding "res__0__auto__" - var tmp42 any - tmp43 := checkDerefVar(var_glojure_DOT_core_not_DASH_empty) - tmp44 := lang.Apply(tmp43, []any{v37}) - if lang.IsTruthy(tmp44) { - tmp42 = v38 - } else { - tmp42 = v36 - } - var v45 any = tmp42 - _ = v45 - var tmp46 any - if lang.IsTruthy(v41) { - panic(v41) - } else { - } - _ = tmp46 - tmp6 = v45 - } // end let - tmp7 := lang.Apply(tmp5, []any{tmp6, v2}) - tmp3 = tmp7 - } else { - panic(r) - } - } - }() - tmp4 := checkDerefVar(var_glojure_DOT_go_DOT_io_make_DASH_output_DASH_stream) - var tmp5 any - { // let - // let binding "res__0__auto__" - tmp6 := lang.Apply(url5.Parse, []any{v1}) - tmp7 := lang.Apply(tmp6, nil) - var v8 any = tmp7 - _ = v8 - // let binding "vec__316" - var tmp9 any - tmp10 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) - tmp11 := lang.Apply(tmp10, []any{v8}) - if lang.IsTruthy(tmp11) { - tmp12 := checkDerefVar(var_glojure_DOT_core_pop) - tmp13 := lang.Apply(tmp12, []any{v8}) - tmp14 := checkDerefVar(var_glojure_DOT_core_last) - tmp15 := lang.Apply(tmp14, []any{v8}) - tmp16 := lang.NewVector(tmp13, tmp15) - tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(358), kw_column, int(10), kw_end_DASH_line, int(358), kw_end_DASH_column, int(14)) - tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp9 = tmp18 - } else { - tmp19 := lang.NewVector(nil, v8) - tmp20 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(358), kw_column, int(10), kw_end_DASH_line, int(358), kw_end_DASH_column, int(14)) - tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp9 = tmp21 - } - var v22 any = tmp9 - _ = v22 - // let binding "vec__319" - tmp23 := checkDerefVar(var_glojure_DOT_core_nth) - tmp24 := lang.Apply(tmp23, []any{v22, int64(0), nil}) - var v25 any = tmp24 - _ = v25 - // let binding "seq__320" - tmp26 := checkDerefVar(var_glojure_DOT_core_seq) - tmp27 := lang.Apply(tmp26, []any{v25}) - var v28 any = tmp27 - _ = v28 - // let binding "first__321" - tmp29 := checkDerefVar(var_glojure_DOT_core_first) - tmp30 := lang.Apply(tmp29, []any{v28}) - var v31 any = tmp30 - _ = v31 - // let binding "seq__320" - tmp32 := checkDerefVar(var_glojure_DOT_core_next) - tmp33 := lang.Apply(tmp32, []any{v28}) - var v34 any = tmp33 - _ = v34 - // let binding "fst__1__auto__" - var v35 any = v31 - _ = v35 - // let binding "rst__2__auto__" - var v36 any = v34 - _ = v36 - // let binding "res__0__auto__" - var v37 any = v25 - _ = v37 - // let binding "err__3__auto__" - tmp38 := checkDerefVar(var_glojure_DOT_core_nth) - tmp39 := lang.Apply(tmp38, []any{v22, int64(1), nil}) - var v40 any = tmp39 - _ = v40 - // let binding "res__0__auto__" - var tmp41 any - tmp42 := checkDerefVar(var_glojure_DOT_core_not_DASH_empty) - tmp43 := lang.Apply(tmp42, []any{v36}) - if lang.IsTruthy(tmp43) { - tmp41 = v37 - } else { - tmp41 = v35 - } - var v44 any = tmp41 - _ = v44 - var tmp45 any - if lang.IsTruthy(v40) { - panic(v40) - } else { - } - _ = tmp45 - tmp5 = v44 - } // end let - tmp6 := lang.Apply(tmp4, []any{tmp5, v2}) - tmp3 = tmp6 - }() - return tmp3 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "ClearBit") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ClearBit is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + return tmp5 }) - tmp0 = tmp0.WithMeta(lang.NewMap(kw_file, "glojure/go/io.glj", kw_line, int(264), kw_column, int(25), kw_end_DASH_line, int(268), kw_end_DASH_column, int(79))).(lang.FnFunc) - closed27 = tmp0 + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bit_DASH_clear = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bit_DASH_clear.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } } - var closed28 any + // bit-flip { - closed28 = sym_divide + tmp0 := sym_bit_DASH_flip.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_n)), kw_doc, "Flip bit at index n", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(1348), kw_end_DASH_line, int(1348))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "FlipBit") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("FlipBit is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bit_DASH_flip = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bit_DASH_flip.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } } - var closed29 any + // bit-set { - closed29 = sym_and + tmp0 := sym_bit_DASH_set.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_n)), kw_doc, "Set bit at index n", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(1342), kw_end_DASH_line, int(1342))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "SetBit") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("SetBit is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bit_DASH_set = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bit_DASH_set.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } } - var closed3 any + // bit-test { - closed3 = sym_unchecked_add + tmp0 := sym_bit_DASH_test.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_n)), kw_doc, "Test bit at index n", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(1354), kw_end_DASH_line, int(1354))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "TestBit") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("TestBit is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bit_DASH_test = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bit_DASH_test.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } } - var closed30 any + // cast { - closed30 = sym_andNot + tmp0 := sym_cast.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_c, sym_x)), kw_doc, "Throws a ClassCastException if x is not a c, else returns x.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(345), kw_end_DASH_line, int(345))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "cast") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("cast is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_cast = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_cast.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } } - var closed31 any + // char-escape-string { - closed31 = sym_or + tmp1 := reflect.TypeOf("") + tmp0 := sym_char_DASH_escape_DASH_string.WithMeta(lang.NewMap(kw_tag, tmp1, kw_doc, "Returns escape string for char or nil if none", kw_file, "glojure/core_print.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(6), kw_line, int(214), kw_end_DASH_line, int(217))).(*lang.Symbol) + var_glojure_DOT_core_char_DASH_escape_DASH_string = ns.InternWithValue(tmp0, lang.NewMap(lang.NewChar(10), "\\n", lang.NewChar(9), "\\t", lang.NewChar(13), "\\r", lang.NewChar(34), "\\\"", lang.NewChar(92), "\\\\", lang.NewChar(12), "\\f", lang.NewChar(8), "\\b"), true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_char_DASH_escape_DASH_string.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } } - var closed32 any + // char-name-string { - closed32 = sym_xor + tmp1 := reflect.TypeOf("") + tmp0 := sym_char_DASH_name_DASH_string.WithMeta(lang.NewMap(kw_tag, tmp1, kw_doc, "Returns name string for char or nil if none", kw_file, "glojure/core_print.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(6), kw_line, int(335), kw_end_DASH_line, int(338))).(*lang.Symbol) + var_glojure_DOT_core_char_DASH_name_DASH_string = ns.InternWithValue(tmp0, lang.NewMap(lang.NewChar(10), "newline", lang.NewChar(9), "tab", lang.NewChar(32), "space", lang.NewChar(8), "backspace", lang.NewChar(12), "formfeed", lang.NewChar(13), "return"), true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_char_DASH_name_DASH_string.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } } - var closed33 any + // chunk { - closed33 = sym_max + tmp0 := sym_chunk.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(691), kw_column, int(7), kw_end_DASH_line, int(691), kw_end_DASH_column, int(41), kw_arglists, lang.NewList(lang.NewVector(sym_b)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "chunk") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "chunk"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_chunk = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_chunk.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } } - var closed34 any + // chunk-append { - closed34 = sym_min + tmp0 := sym_chunk_DASH_append.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(688), kw_column, int(7), kw_end_DASH_line, int(688), kw_end_DASH_column, int(27), kw_arglists, lang.NewList(lang.NewVector(sym_b, sym_x)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "add") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_chunk_DASH_append = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_chunk_DASH_append.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } } - var closed35 any + // chunk-buffer { - var tmp0 lang.FnFunc - tmp0 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_chunk_DASH_buffer.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(685), kw_column, int(7), kw_end_DASH_line, int(685), kw_end_DASH_column, int(53), kw_arglists, lang.NewList(lang.NewVector(sym_capacity)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v1 := args[0] - _ = v1 - var tmp2 any - if lang.IsTruthy(v1) { - tmp2 = false - } else { - tmp2 = true - } - return tmp2 + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(lang.NewChunkBuffer, []any{v2}) + return tmp3 }) - tmp1 := reflect.TypeOf(false) - tmp0 = tmp0.WithMeta(lang.NewMap(kw_rettag, tmp1)).(lang.FnFunc) - closed35 = tmp0 + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_chunk_DASH_buffer = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_chunk_DASH_buffer.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } } - var closed36 any + // chunk-cons { - var tmp0 lang.FnFunc - tmp0 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_chunk_DASH_cons.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(703), kw_column, int(7), kw_end_DASH_line, int(703), kw_end_DASH_column, int(25), kw_arglists, lang.NewList(lang.NewVector(sym_chunk, sym_rest)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 2) - v1 := args[0] - _ = v1 - v2 := args[1] + v2 := args[0] _ = v2 - recur_loop_481: - var tmp3 any - { // let - // let binding "temp__0__auto__" - tmp4 := checkDerefVar(var_glojure_DOT_core_seq) - tmp5 := lang.Apply(tmp4, []any{v2}) - var v6 any = tmp5 - _ = v6 - var tmp7 any - if lang.IsTruthy(v6) { - var tmp8 any - { // let - // let binding "s" - var v9 any = v6 - _ = v9 - var tmp10 any - { // let - // let binding "or__0__auto__" - tmp11 := checkDerefVar(var_glojure_DOT_core_first) - tmp12 := lang.Apply(tmp11, []any{v9}) - tmp13 := lang.Apply(v1, []any{tmp12}) - var v14 any = tmp13 - _ = v14 - var tmp15 any - if lang.IsTruthy(v14) { - tmp15 = v14 - } else { - var tmp16 any = v1 - tmp18 := checkDerefVar(var_glojure_DOT_core_next) - tmp19 := lang.Apply(tmp18, []any{v9}) - var tmp17 any = tmp19 - v1 = tmp16 - v2 = tmp17 - goto recur_loop_481 - } - tmp10 = tmp15 - } // end let - tmp8 = tmp10 - } // end let - tmp7 = tmp8 - } else { - } - tmp3 = tmp7 - } // end let - return tmp3 + v3 := args[1] + _ = v3 + var tmp4 any + tmp5 := lang.Apply(lang.Count, []any{v2}) + tmp6 := lang.Apply(lang.IsZero, []any{tmp5}) + if lang.IsTruthy(tmp6) { + tmp4 = v3 + } else { + tmp7 := lang.Apply(lang.NewChunkedCons, []any{v2, v3}) + tmp4 = tmp7 + } + return tmp4 }) - tmp0 = tmp0.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - closed36 = tmp0 + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_chunk_DASH_cons = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_chunk_DASH_cons.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } } - var closed37 any + // chunk-first { - var tmp0 lang.FnFunc - tmp0 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v1 := args[0] - _ = v1 - v2 := args[1] + tmp0 := sym_chunk_DASH_first.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(694), kw_column, int(7), kw_end_DASH_line, int(694), kw_end_DASH_column, int(48), kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] _ = v2 - recur_loop_480: - var tmp3 any - tmp4 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) - tmp5 := checkDerefVar(var_glojure_DOT_core_seq) - tmp6 := lang.Apply(tmp5, []any{v2}) - tmp7 := lang.Apply(tmp4, []any{tmp6}) - if lang.IsTruthy(tmp7) { - tmp3 = true - } else { - var tmp8 any - tmp9 := checkDerefVar(var_glojure_DOT_core_first) - tmp10 := lang.Apply(tmp9, []any{v2}) - tmp11 := lang.Apply(v1, []any{tmp10}) - if lang.IsTruthy(tmp11) { - var tmp12 any = v1 - tmp14 := checkDerefVar(var_glojure_DOT_core_next) - tmp15 := lang.Apply(tmp14, []any{v2}) - var tmp13 any = tmp15 - v1 = tmp12 - v2 = tmp13 - goto recur_loop_480 - } else { - var tmp16 any - if lang.IsTruthy(kw_else) { - tmp16 = false - } else { - } - tmp8 = tmp16 - } - tmp3 = tmp8 + tmp3, ok := lang.FieldOrMethod(v2, "chunkedFirst") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "chunkedFirst"))) } - return tmp3 + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 }) - tmp1 := reflect.TypeOf(false) - tmp0 = tmp0.WithMeta(lang.NewMap(kw_rettag, tmp1)).(lang.FnFunc) - closed37 = tmp0 - } - var closed4 any - { - closed4 = sym_add - } - var closed5 any - { - closed5 = sym_addP - } - var closed6 any - { - closed6 = sym_unchecked_minus - } - var closed7 any - { - closed7 = sym_minus + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_chunk_DASH_first = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_chunk_DASH_first.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } } - var closed8 any + // chunk-next { - closed8 = sym_minusP + tmp0 := sym_chunk_DASH_next.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(700), kw_column, int(7), kw_end_DASH_line, int(700), kw_end_DASH_column, int(71), kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "chunkedNext") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "chunkedNext"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_chunk_DASH_next = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_chunk_DASH_next.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } } - var closed9 any + // chunk-rest { - var tmp0 lang.FnFunc - tmp0 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: - v1 := args[0] - _ = v1 - v2 := args[1] - _ = v2 - tmp3 := lang.Apply(v2, nil) - return tmp3 - case 3: - v1 := args[0] - _ = v1 - v2 := args[1] - _ = v2 - v3 := args[2] - _ = v3 - return v3 + tmp0 := sym_chunk_DASH_rest.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(697), kw_column, int(7), kw_end_DASH_line, int(697), kw_end_DASH_column, int(71), kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "chunkedMore") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "chunkedMore"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) default: - checkArity(args, -1) - panic("unreachable") + tmp4 = tmp3 } + return tmp4 }) - closed9 = tmp0 + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_chunk_DASH_rest = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_chunk_DASH_rest.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } } - - // reference fmt to avoid unused import error - _ = fmt.Printf - ns := lang.FindOrCreateNamespace(sym_glojure_DOT_core) - _ = ns - // * + // comment { + tmp0 := sym_comment.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_body)), kw_doc, "Ignores body, yields nil", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(4733), kw_end_DASH_line, int(4733))).(*lang.Symbol) var tmp1 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 1: - v2 := args[0] - _ = v2 - var tmp3 any - { // let - // let binding "op" - var tmp4 any - tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) - if lang.IsTruthy(tmp5) { - tmp4 = closed0 - } else { - tmp4 = closed1 - } - var v6 any = tmp4 - _ = v6 - tmp7 := checkDerefVar(var_glojure_DOT_core_seq) - tmp8 := checkDerefVar(var_glojure_DOT_core_concat) - tmp9 := checkDerefVar(var_glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) - tmp11 := checkDerefVar(var_glojure_DOT_core_list) - tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := checkDerefVar(var_glojure_DOT_core_seq) - tmp15 := checkDerefVar(var_glojure_DOT_core_concat) - tmp16 := checkDerefVar(var_glojure_DOT_core_list) - tmp17 := lang.Apply(tmp16, []any{v6}) - tmp18 := checkDerefVar(var_glojure_DOT_core_list) - tmp19 := lang.Apply(tmp18, []any{v2}) - tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) - tmp21 := lang.Apply(tmp14, []any{tmp20}) - tmp22 := lang.Apply(tmp13, []any{tmp21}) - tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) - tmp24 := lang.Apply(tmp7, []any{tmp23}) - tmp3 = tmp24 - } // end let - return tmp3 - case 2: + default: + checkArity(args, 2) v2 := args[0] _ = v2 v3 := args[1] _ = v3 - var tmp4 any - { // let - // let binding "op" - var tmp5 any - tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) - if lang.IsTruthy(tmp6) { - tmp5 = closed0 - } else { - tmp5 = closed1 - } - var v7 any = tmp5 - _ = v7 - tmp8 := checkDerefVar(var_glojure_DOT_core_seq) - tmp9 := checkDerefVar(var_glojure_DOT_core_concat) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) - tmp12 := checkDerefVar(var_glojure_DOT_core_list) - tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := checkDerefVar(var_glojure_DOT_core_seq) - tmp16 := checkDerefVar(var_glojure_DOT_core_concat) - tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{v7}) - tmp19 := checkDerefVar(var_glojure_DOT_core_list) - tmp20 := lang.Apply(tmp19, []any{v2}) - tmp21 := checkDerefVar(var_glojure_DOT_core_list) - tmp22 := lang.Apply(tmp21, []any{v3}) - tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) - tmp24 := lang.Apply(tmp15, []any{tmp23}) - tmp25 := lang.Apply(tmp14, []any{tmp24}) - tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) - tmp27 := lang.Apply(tmp8, []any{tmp26}) - tmp4 = tmp27 - } // end let - return tmp4 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + return nil + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_comment = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_comment.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // commute + { + tmp0 := sym_commute.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ref, sym_fun, sym__AMP_, sym_args)), kw_doc, "Must be called in a transaction. Sets the in-transaction-value of\n ref to:\n\n (apply fun in-transaction-value-of-ref args)\n\n and returns the in-transaction-value of ref.\n\n At the commit point of the transaction, sets the value of ref to be:\n\n (apply fun most-recently-committed-value-of-ref args)\n\n Thus fun should be commutative, or, failing that, you must accept\n last-one-in-wins behavior. commute allows for more concurrency than\n ref-set.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(2414), kw_end_DASH_line, int(2414))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { default: checkArity(args, 2) v2 := args[0] @@ -3526,3874 +3852,3175 @@ func LoadNS() { _ = v3 var v4 any = lang.NewList(args[2:]...) _ = v4 - var tmp5 any - { // let - // let binding "op" - var tmp6 any - tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) - if lang.IsTruthy(tmp7) { - tmp6 = closed0 + tmp5, _ := lang.FieldOrMethod(v2, "Commute") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Commute is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_commute = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_commute.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // comparator + { + tmp0 := sym_comparator.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred)), kw_doc, "Returns an implementation of java.util.Comparator based upon pred.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(3077), kw_end_DASH_line, int(3077))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var tmp6 any + tmp7 := lang.Apply(v2, []any{v4, v5}) + if lang.IsTruthy(tmp7) { + tmp6 = int64(-1) + } else { + var tmp8 any + tmp9 := lang.Apply(v2, []any{v5, v4}) + if lang.IsTruthy(tmp9) { + tmp8 = int64(1) } else { - tmp6 = closed1 - } - var v8 any = tmp6 - _ = v8 - tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) - var tmp10 lang.FnFunc - tmp10 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v11 := args[0] - _ = v11 - v12 := args[1] - _ = v12 - tmp13 := checkDerefVar(var_glojure_DOT_core_seq) - tmp14 := checkDerefVar(var_glojure_DOT_core_concat) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) - tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp19 := checkDerefVar(var_glojure_DOT_core_list) - tmp20 := checkDerefVar(var_glojure_DOT_core_seq) - tmp21 := checkDerefVar(var_glojure_DOT_core_concat) - tmp22 := checkDerefVar(var_glojure_DOT_core_list) - tmp23 := lang.Apply(tmp22, []any{v8}) - tmp24 := checkDerefVar(var_glojure_DOT_core_list) - tmp25 := lang.Apply(tmp24, []any{v11}) - tmp26 := checkDerefVar(var_glojure_DOT_core_list) - tmp27 := lang.Apply(tmp26, []any{v12}) - tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) - tmp29 := lang.Apply(tmp20, []any{tmp28}) - tmp30 := lang.Apply(tmp19, []any{tmp29}) - tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) - tmp32 := lang.Apply(tmp13, []any{tmp31}) - return tmp32 - }) - tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) - if err != nil { - panic(err) + var tmp10 any + if lang.IsTruthy(kw_else) { + tmp10 = int64(0) + } else { + } + tmp8 = tmp10 } - tmp13 := checkDerefVar(var_glojure_DOT_core_seq) - tmp14 := checkDerefVar(var_glojure_DOT_core_concat) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) - tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp19 := checkDerefVar(var_glojure_DOT_core_list) - tmp20 := checkDerefVar(var_glojure_DOT_core_seq) - tmp21 := checkDerefVar(var_glojure_DOT_core_concat) - tmp22 := checkDerefVar(var_glojure_DOT_core_list) - tmp23 := lang.Apply(tmp22, []any{v8}) - tmp24 := checkDerefVar(var_glojure_DOT_core_list) - tmp25 := lang.Apply(tmp24, []any{v2}) - tmp26 := checkDerefVar(var_glojure_DOT_core_list) - tmp27 := lang.Apply(tmp26, []any{v3}) - tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) - tmp29 := lang.Apply(tmp20, []any{tmp28}) - tmp30 := lang.Apply(tmp19, []any{tmp29}) - tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) - tmp32 := lang.Apply(tmp13, []any{tmp31}) - tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) - tmp5 = tmp33 - } // end let - return tmp5 + tmp6 = tmp8 + } + return tmp6 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3082), kw_column, int(5), kw_end_DASH_line, int(3083), kw_end_DASH_column, int(48)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) } + return tmp5 }) - tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_comparator = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_comparator.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // compare-and-set! + { + tmp0 := sym_compare_DASH_and_DASH_set_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_atom, sym_oldval, sym_newval)), kw_doc, "Atomically sets the value of atom to newval if and only if the\n current value of the atom is identical to oldval. Returns true if\n set happened, else false", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(22), kw_column, int(7), kw_line, int(2360), kw_end_DASH_line, int(2360))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5, _ := lang.FieldOrMethod(v2, "compareAndSet") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("compareAndSet is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_compare_DASH_and_DASH_set_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_compare_DASH_and_DASH_set_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // cons + { + tmp0 := sym_cons.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_seq)), kw_doc, "Returns a new seq where x is the first element and seq is\n the rest.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(5), kw_column, int(2), kw_line, int(21), kw_end_DASH_line, int(27))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function cons + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(lang.NewCons, []any{v3, v4}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(27), kw_column, int(7), kw_end_DASH_line, int(27), kw_end_DASH_column, int(89))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_cons = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_cons.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // constantly + { + tmp0 := sym_constantly.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns a function that takes any number of arguments and returns x.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(1440), kw_end_DASH_line, int(1440))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v3 := args[0] + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v4 any = lang.NewList(args[0:]...) + _ = v4 + return v2 + } + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(1444), kw_column, int(7), kw_end_DASH_line, int(1444), kw_end_DASH_column, int(21)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_constantly = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_constantly.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // contains? + { + tmp0 := sym_contains_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll, sym_key)), kw_doc, "Returns true if key is present in the given collection, otherwise\n returns false. Note that for numerically indexed collections like\n vectors and Java arrays, this tests if the numeric key is within the\n range of indexes. 'contains?' operates constant or logarithmic time;\n it will not perform a linear search for a value. See also 'some'.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(1479), kw_end_DASH_line, int(1479))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + tmp4, _ := lang.FieldOrMethod(runtime.RT, "Contains") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Contains is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + tmp5 := lang.Apply(tmp4, []any{v2, v3}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp0 := sym__STAR_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns the product of nums. (*) returns 1. Does not auto-promote\n longs, will throw on overflow. See also: *'", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(7), kw_line, int(1001), kw_end_DASH_line, int(1001))).(*lang.Symbol) - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_contains_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_contains_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // create-ns + { + tmp0 := sym_create_DASH_ns.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_sym)), kw_doc, "Create a new namespace named by the symbol if one doesn't already\n exist, returns it or the already-existing namespace of the same\n name.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(4131), kw_end_DASH_line, int(4131))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(nil, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_create_DASH_ns = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_create_DASH_ns.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // create-struct + { + tmp0 := sym_create_DASH_struct.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_keys)), kw_doc, "Returns a structure basis object.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(4037), kw_end_DASH_line, int(4037))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 0: - return int64(1) - case 1: - v5 := args[0] - _ = v5 - tmp6 := lang.Apply(lang.MustAsNumber, []any{v5}) - return tmp6 - case 2: - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - tmp7, _ := lang.FieldOrMethod(lang.Numbers, "Multiply") - if reflect.TypeOf(tmp7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Multiply is not a function"))) - } - tmp8 := lang.Apply(tmp7, []any{v5, v6}) - return tmp8 default: - checkArity(args, 2) - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - var v7 any = lang.NewList(args[2:]...) - _ = v7 - tmp8 := checkDerefVar(var_glojure_DOT_core_reduce1) - tmp9 := checkDerefVar(var_glojure_DOT_core__STAR_) - tmp10 := checkDerefVar(var_glojure_DOT_core__STAR_) - tmp11 := lang.Apply(tmp10, []any{v5, v6}) - tmp12 := lang.Apply(tmp8, []any{tmp9, tmp11, v7}) - return tmp12 + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + tmp3 := lang.Apply(lang.CreatePersistentStructMapSlotMap, []any{v2}) + return tmp3 } }) - tmp4 = tmp4.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp3 := ns.InternWithValue(tmp0, tmp4, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_create_DASH_struct = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_create_DASH_struct.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // *' + // data-reader-urls { + tmp0 := sym_data_DASH_reader_DASH_urls.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7830), kw_column, int(8), kw_end_DASH_line, int(7830), kw_end_DASH_column, int(23), kw_private, true, kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp1 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v2 := args[0] - _ = v2 - var tmp3 any - { // let - // let binding "op" - var tmp4 any - tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) - if lang.IsTruthy(tmp5) { - tmp4 = closed2 - } else { - tmp4 = closed2 - } - var v6 any = tmp4 - _ = v6 - tmp7 := checkDerefVar(var_glojure_DOT_core_seq) - tmp8 := checkDerefVar(var_glojure_DOT_core_concat) - tmp9 := checkDerefVar(var_glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) - tmp11 := checkDerefVar(var_glojure_DOT_core_list) - tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := checkDerefVar(var_glojure_DOT_core_seq) - tmp15 := checkDerefVar(var_glojure_DOT_core_concat) - tmp16 := checkDerefVar(var_glojure_DOT_core_list) - tmp17 := lang.Apply(tmp16, []any{v6}) - tmp18 := checkDerefVar(var_glojure_DOT_core_list) - tmp19 := lang.Apply(tmp18, []any{v2}) - tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) - tmp21 := lang.Apply(tmp14, []any{tmp20}) - tmp22 := lang.Apply(tmp13, []any{tmp21}) - tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) - tmp24 := lang.Apply(tmp7, []any{tmp23}) - tmp3 = tmp24 - } // end let - return tmp3 - case 2: - v2 := args[0] - _ = v2 - v3 := args[1] - _ = v3 - var tmp4 any - { // let - // let binding "op" - var tmp5 any - tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) - if lang.IsTruthy(tmp6) { - tmp5 = closed2 - } else { - tmp5 = closed2 - } - var v7 any = tmp5 - _ = v7 - tmp8 := checkDerefVar(var_glojure_DOT_core_seq) - tmp9 := checkDerefVar(var_glojure_DOT_core_concat) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) - tmp12 := checkDerefVar(var_glojure_DOT_core_list) - tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := checkDerefVar(var_glojure_DOT_core_seq) - tmp16 := checkDerefVar(var_glojure_DOT_core_concat) - tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{v7}) - tmp19 := checkDerefVar(var_glojure_DOT_core_list) - tmp20 := lang.Apply(tmp19, []any{v2}) - tmp21 := checkDerefVar(var_glojure_DOT_core_list) - tmp22 := lang.Apply(tmp21, []any{v3}) - tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) - tmp24 := lang.Apply(tmp15, []any{tmp23}) - tmp25 := lang.Apply(tmp14, []any{tmp24}) - tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) - tmp27 := lang.Apply(tmp8, []any{tmp26}) - tmp4 = tmp27 - } // end let - return tmp4 - default: - checkArity(args, 2) - v2 := args[0] - _ = v2 - v3 := args[1] - _ = v3 - var v4 any = lang.NewList(args[2:]...) - _ = v4 - var tmp5 any - { // let - // let binding "op" - var tmp6 any - tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) - if lang.IsTruthy(tmp7) { - tmp6 = closed2 - } else { - tmp6 = closed2 - } - var v8 any = tmp6 - _ = v8 - tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) - var tmp10 lang.FnFunc - tmp10 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v11 := args[0] - _ = v11 - v12 := args[1] - _ = v12 - tmp13 := checkDerefVar(var_glojure_DOT_core_seq) - tmp14 := checkDerefVar(var_glojure_DOT_core_concat) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) - tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp19 := checkDerefVar(var_glojure_DOT_core_list) - tmp20 := checkDerefVar(var_glojure_DOT_core_seq) - tmp21 := checkDerefVar(var_glojure_DOT_core_concat) - tmp22 := checkDerefVar(var_glojure_DOT_core_list) - tmp23 := lang.Apply(tmp22, []any{v8}) - tmp24 := checkDerefVar(var_glojure_DOT_core_list) - tmp25 := lang.Apply(tmp24, []any{v11}) - tmp26 := checkDerefVar(var_glojure_DOT_core_list) - tmp27 := lang.Apply(tmp26, []any{v12}) - tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) - tmp29 := lang.Apply(tmp20, []any{tmp28}) - tmp30 := lang.Apply(tmp19, []any{tmp29}) - tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) - tmp32 := lang.Apply(tmp13, []any{tmp31}) - return tmp32 - }) - tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp13 := checkDerefVar(var_glojure_DOT_core_seq) - tmp14 := checkDerefVar(var_glojure_DOT_core_concat) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) - tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp19 := checkDerefVar(var_glojure_DOT_core_list) - tmp20 := checkDerefVar(var_glojure_DOT_core_seq) - tmp21 := checkDerefVar(var_glojure_DOT_core_concat) - tmp22 := checkDerefVar(var_glojure_DOT_core_list) - tmp23 := lang.Apply(tmp22, []any{v8}) - tmp24 := checkDerefVar(var_glojure_DOT_core_list) - tmp25 := lang.Apply(tmp24, []any{v2}) - tmp26 := checkDerefVar(var_glojure_DOT_core_list) - tmp27 := lang.Apply(tmp26, []any{v3}) - tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) - tmp29 := lang.Apply(tmp20, []any{tmp28}) - tmp30 := lang.Apply(tmp19, []any{tmp29}) - tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) - tmp32 := lang.Apply(tmp13, []any{tmp31}) - tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) - tmp5 = tmp33 - } // end let - return tmp5 - } + checkArity(args, 0) + return lang.NewList() }) - tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_data_DASH_reader_DASH_urls = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_data_DASH_reader_DASH_urls.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // deliver + { + tmp0 := sym_deliver.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_promise, sym_val)), kw_doc, "Delivers the supplied value to the promise, releasing any pending\n derefs. A subsequent call to deliver on a promise will have no effect.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(7109), kw_end_DASH_line, int(7109))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := lang.Apply(v2, []any{v3}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_deliver = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_deliver.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // denominator + { + tmp1 := reflect.TypeOf((*big9.Int)(nil)) + tmp0 := sym_denominator.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_r)), kw_doc, "Returns the denominator part of a Ratio.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(3591), kw_end_DASH_line, int(3591))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + tmp4, ok := lang.FieldOrMethod(v3, "denominator") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "denominator"))) + } + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { + case reflect.Func: + tmp5 = lang.Apply(tmp4, nil) + default: + tmp5 = tmp4 } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp0 := sym__STAR__TICK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns the product of nums. (*') returns 1. Supports arbitrary precision.\n See also: *", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(7), kw_line, int(989), kw_end_DASH_line, int(989))).(*lang.Symbol) - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { + tmp3 := reflect.TypeOf((*big9.Int)(nil)) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_denominator = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_denominator.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // deref-future + { + tmp0 := sym_deref_DASH_future.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(2296), kw_column, int(7), kw_end_DASH_line, int(2296), kw_end_DASH_column, int(28), kw_arglists, lang.NewList(lang.NewVector(sym_fut), lang.NewVector(sym_fut, sym_timeout_DASH_ms, sym_timeout_DASH_val)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 0: - return int64(1) case 1: - v5 := args[0] - _ = v5 - tmp6 := lang.Apply(lang.MustAsNumber, []any{v5}) - return tmp6 - case 2: - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - tmp7, _ := lang.FieldOrMethod(lang.Numbers, "MultiplyP") - if reflect.TypeOf(tmp7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("MultiplyP is not a function"))) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "Get") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "Get"))) } - tmp8 := lang.Apply(tmp7, []any{v5, v6}) - return tmp8 + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + func() { + defer func() { + if r := recover(); r != nil { + tmp6 := reflect.TypeOf((*lang.TimeoutError)(nil)).Elem() + if lang.CatchMatches(r, tmp6) { + v7 := r + _ = v7 + tmp5 = v4 + } else { + panic(r) + } + } + }() + tmp7, _ := lang.FieldOrMethod(v2, "Get") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Get is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v3, time10.Millisecond}) + tmp5 = tmp8 + }() + return tmp5 default: - checkArity(args, 2) - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - var v7 any = lang.NewList(args[2:]...) - _ = v7 - tmp8 := checkDerefVar(var_glojure_DOT_core_reduce1) - tmp9 := checkDerefVar(var_glojure_DOT_core__STAR__TICK_) - tmp10 := checkDerefVar(var_glojure_DOT_core__STAR__TICK_) - tmp11 := lang.Apply(tmp10, []any{v5, v6}) - tmp12 := lang.Apply(tmp8, []any{tmp9, tmp11, v7}) - return tmp12 + checkArity(args, -1) + panic("unreachable") } }) - tmp4 = tmp4.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp3 := ns.InternWithValue(tmp0, tmp4, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_deref_DASH_future = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_deref_DASH_future.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // *1 + // ensure { - tmp0 := sym__STAR_1.WithMeta(lang.NewMap()).(*lang.Symbol) - tmp1 := ns.Intern(tmp0) + tmp0 := sym_ensure.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ref)), kw_doc, "Must be called in a transaction. Protects the ref from modification\n by other transactions. Returns the in-transaction-value of\n ref. Allows for more concurrency than (ref-set ref @ref)", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(2480), kw_end_DASH_line, int(2480))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(v2, "touch") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("touch is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{}) + _ = tmp4 + tmp5, _ := lang.FieldOrMethod(v2, "deref") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("deref is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ensure = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_ensure.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // *2 + // enumeration-seq { - tmp0 := sym__STAR_2.WithMeta(lang.NewMap()).(*lang.Symbol) - tmp1 := ns.Intern(tmp0) + tmp0 := sym_enumeration_DASH_seq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_e)), kw_doc, "Returns a seq on a java.util.Enumeration", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(5710), kw_end_DASH_line, int(5710))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(nil, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_enumeration_DASH_seq = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_enumeration_DASH_seq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // *3 + // error-handler { - tmp0 := sym__STAR_3.WithMeta(lang.NewMap()).(*lang.Symbol) - tmp1 := ns.Intern(tmp0) + tmp0 := sym_error_DASH_handler.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a)), kw_doc, "Returns the error-handler of agent a, or nil if there is none.\n See set-error-handler!", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(2202), kw_end_DASH_line, int(2202))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "getErrorHandler") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getErrorHandler"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_error_DASH_handler = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_error_DASH_handler.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // *agent* + // error-mode { - tmp0 := sym__STAR_agent_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, nil, true) + tmp0 := sym_error_DASH_mode.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a)), kw_doc, "Returns the error-mode of agent a. See set-error-mode!", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(2227), kw_end_DASH_line, int(2227))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "getErrorMode") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getErrorMode"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_error_DASH_mode = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_error_DASH_mode.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // *assert* + // eval { - tmp0 := sym__STAR_assert_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "When set to logical false, 'assert' will omit assertion checks in\n compiled code. Defaults to true.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, false, true) + tmp0 := sym_eval.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_form)), kw_doc, "Evaluates the form data structure (not text!) and returns the result.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3203), kw_end_DASH_line, int(3203))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(runtime.Compiler, "Eval") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Eval is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_eval = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_eval.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // *command-line-args* + // false? { - tmp0 := sym__STAR_command_DASH_line_DASH_args_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "A sequence of the supplied command line arguments, or nil if\n none were supplied", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, nil, true) + tmp1 := reflect.TypeOf(false) + tmp0 := sym_false_QMARK_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x is the value false, false otherwise.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(504), kw_end_DASH_line, int(504))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.Identical, []any{v3, false}) + return tmp4 + }) + tmp3 := reflect.TypeOf(false) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_false_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_false_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // *compile-files* + // find { - tmp0 := sym__STAR_compile_DASH_files_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "Set to true when compiling files, false otherwise.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, false, true) + tmp0 := sym_find.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_map, sym_key)), kw_doc, "Returns the map entry for key, or nil if key not present.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1530), kw_end_DASH_line, int(1530))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(runtime.RT, "Find") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Find is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_find = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_find.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // *compile-path* + // find-ns { - tmp0 := sym__STAR_compile_DASH_path_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "Specifies the directory where 'compile' will write out .class\n files. This directory must be in the classpath for 'compile' to\n work.\n\n Defaults to \"classes\"", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, nil, true) + tmp0 := sym_find_DASH_ns.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_sym)), kw_doc, "Returns the namespace named by the symbol or nil if it doesn't exist.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4125), kw_end_DASH_line, int(4125))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(lang.FindNamespace, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_find_DASH_ns = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_find_DASH_ns.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // *compiler-options* + // find-var { - tmp0 := sym__STAR_compiler_DASH_options_STAR_.WithMeta(lang.NewMap(kw_added, "1.4", kw_doc, "A map of keys to options.\n Note, when binding dynamically make sure to merge with previous value.\n Supported options:\n :elide-meta - a collection of metadata keys to elide during compilation.\n :disable-locals-clearing - set to true to disable clearing, useful for using a debugger\n :direct-linking - set to true to use direct static invocation of functions, rather than vars\n Note that call sites compiled with direct linking will not be affected by var redefinition.\n Use ^:redef (or ^:dynamic) on a var to prevent direct linking and allow redefinition.\n See https://glojure.org/reference/compilation for more information.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, nil, true) + tmp0 := sym_find_DASH_var.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_sym)), kw_doc, "Returns the global var named by the namespace-qualified symbol, or\n nil if no var with that name.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(2013), kw_end_DASH_line, int(2013))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(runtime.RT, "FindVar") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("FindVar is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_find_DASH_var = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_find_DASH_var.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // *data-readers* + // first { - tmp0 := sym__STAR_data_DASH_readers_STAR_.WithMeta(lang.NewMap(kw_doc, "Map from reader tag symbols to data reader Vars.\n\n When Clojure starts, it searches for files named 'data_readers.clj'\n and 'data_readers.cljc' at the root of the classpath. Each such file\n must contain a literal map of symbols, like this:\n\n {foo/bar my.project.foo/bar\n foo/baz my.project/baz}\n\n The first symbol in each pair is a tag that will be recognized by\n the Clojure reader. The second symbol in the pair is the\n fully-qualified name of a Var which will be invoked by the reader to\n parse the form following the tag. For example, given the\n data_readers.clj file above, the Clojure reader would parse this\n form:\n\n #foo/bar [1 2 3]\n\n by invoking the Var #'my.project.foo/bar on the vector [1 2 3]. The\n data reader function is invoked on the form AFTER it has been read\n as a normal Clojure data structure by the reader.\n\n Reader tags without namespace qualifiers are reserved for\n Clojure. Default reader tags are defined in\n glojure.core/default-data-readers but may be overridden in\n data_readers.clj, data_readers.cljc, or by rebinding this Var.", kw_file, "glojure/core.glj", kw_added, "1.4", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(49), kw_column, int(6), kw_line, int(7794), kw_end_DASH_line, int(7794), kw_dynamic, true)).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, lang.NewMap(), true) + tmp0 := sym_first.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns the first item in the collection. Calls seq on its\n argument. If coll is nil, returns nil.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(6), kw_column, int(2), kw_line, int(47), kw_end_DASH_line, int(52))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function first + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.First, []any{v3}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(52), kw_column, int(8), kw_end_DASH_line, int(52), kw_end_DASH_column, int(86))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_first = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_first.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // *default-data-reader-fn* + // force { - tmp0 := sym__STAR_default_DASH_data_DASH_reader_DASH_fn_STAR_.WithMeta(lang.NewMap(kw_doc, "When no data reader is found for a tag and *default-data-reader-fn*\n is non-nil, it will be called with two arguments,\n the tag and the value. If *default-data-reader-fn* is nil (the\n default), an exception will be thrown for the unknown tag.", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(59), kw_column, int(6), kw_line, int(7823), kw_end_DASH_line, int(7823), kw_dynamic, true)).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, nil, true) + tmp0 := sym_force.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "If x is a Delay, returns the (possibly cached) value of its expression, else returns x", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(754), kw_end_DASH_line, int(754))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(nil, "force") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("force is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_force = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_force.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // *e + // future-cancel { - tmp0 := sym__STAR_e.WithMeta(lang.NewMap()).(*lang.Symbol) - tmp1 := ns.Intern(tmp0) + tmp0 := sym_future_DASH_cancel.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f)), kw_doc, "Cancels the future, if possible.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(7019), kw_end_DASH_line, int(7019))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(v2, "cancel") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("cancel is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{true}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_future_DASH_cancel = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_future_DASH_cancel.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // *err* + // future-cancelled? { - tmp0 := sym__STAR_err_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "A java.io.Writer object representing standard error for print operations.\n\n Defaults to System/err, wrapped in a PrintWriter", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, nil, true) + tmp0 := sym_future_DASH_cancelled_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f)), kw_doc, "Returns true if future f is cancelled", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(7), kw_line, int(7025), kw_end_DASH_line, int(7025))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "isCancelled") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "isCancelled"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_future_DASH_cancelled_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_future_DASH_cancelled_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // *file* + // future-done? { - tmp0 := sym__STAR_file_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "The path of the file being evaluated, as a String.\n\n When there is no file, e.g. in the REPL, the value is not defined.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, "NO_SOURCE_FILE", true) + tmp0 := sym_future_DASH_done_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f)), kw_doc, "Returns true if future f is done", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(6538), kw_end_DASH_line, int(6538))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "isDone") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "isDone"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_future_DASH_done_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_future_DASH_done_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // *flush-on-newline* + // gen-class { - tmp0 := sym__STAR_flush_DASH_on_DASH_newline_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "When set to true, output will be flushed whenever a newline is printed.\n\n Defaults to true.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, nil, true) + tmp0 := sym_gen_DASH_class.WithMeta(lang.NewMap()).(*lang.Symbol) + var_glojure_DOT_core_gen_DASH_class = ns.Intern(tmp0) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_gen_DASH_class.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // *loaded-libs* + // get-method { - tmp0 := sym__STAR_loaded_DASH_libs_STAR_.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core.glj", kw_line, int(5817), kw_column, int(10), kw_end_DASH_line, int(5820), kw_end_DASH_column, int(15), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - tmp2 := lang.NewRef(lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{sym_glojure_DOT_core_DOT_protocols, sym_glojure_DOT_string, sym_glojure_DOT_go_DOT_io, sym_codegen_DOT_test_DOT_const_DASH_keyword, sym_codegen_DOT_test_DOT_const_DASH_number, sym_codegen_DOT_test_DOT_const_DASH_string, sym_codegen_DOT_test_DOT_def_DASH_simple, sym_codegen_DOT_test_DOT_fn_DASH_closure, sym_codegen_DOT_test_DOT_fn_DASH_recur, sym_codegen_DOT_test_DOT_loop_DASH_simple, sym_codegen_DOT_test_DOT_maybe_DASH_class, sym_codegen_DOT_test_DOT_multifn, sym_codegen_DOT_test_DOT_ns_DASH_skip, sym_codegen_DOT_test_DOT_quote_DASH_simple, sym_codegen_DOT_test_DOT_ref, sym_codegen_DOT_test_DOT_the_DASH_var, sym_codegen_DOT_test_DOT_throw_DASH_simple, sym_codegen_DOT_test_DOT_try_DASH_advanced, sym_codegen_DOT_test_DOT_try_DASH_basic, sym_codegen_DOT_test_DOT_values, sym_codegen_DOT_test_DOT_with_DASH_meta}))) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp0 := sym_get_DASH_method.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_multifn, sym_dispatch_DASH_val)), kw_doc, "Given a multimethod and a dispatch value, returns the dispatch fn\n that would apply to that value, or nil if none apply and no default", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(1815), kw_end_DASH_line, int(1815))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "getMethod") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getMethod is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_get_DASH_method = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_get_DASH_method.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // *loading-verbosely* + // get-thread-bindings { - tmp0 := sym__STAR_loading_DASH_verbosely_STAR_.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core.glj", kw_line, int(5827), kw_column, int(10), kw_end_DASH_line, int(5830), kw_end_DASH_column, int(21), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, false, true) + tmp0 := sym_get_DASH_thread_DASH_bindings.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Get a map with the Var/value pairs which is currently in effect for the\n current thread.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(25), kw_column, int(7), kw_line, int(1937), kw_end_DASH_line, int(1937))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp2 := lang.Apply(nil, nil) + return tmp2 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_get_DASH_thread_DASH_bindings = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_get_DASH_thread_DASH_bindings.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // *ns* + // get-validator { - tmp0 := sym__STAR_ns_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "A glojure.lang.Namespace object representing the current namespace.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, lang.FindOrCreateNamespace(sym_glojure_DOT_core), true) + tmp0 := sym_get_DASH_validator.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_iref)), kw_doc, "Gets the validator-fn for a var/ref/agent/atom.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(2392), kw_end_DASH_line, int(2392))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(v2, "getValidator") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getValidator is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_get_DASH_validator = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_get_DASH_validator.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // *pending-paths* + // global-hierarchy { - tmp0 := sym__STAR_pending_DASH_paths_STAR_.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core.glj", kw_line, int(5822), kw_column, int(10), kw_end_DASH_line, int(5825), kw_end_DASH_column, int(17), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, lang.NewList(), true) + tmp0 := sym_global_DASH_hierarchy.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(5513), kw_column, int(6), kw_end_DASH_line, int(5514), kw_end_DASH_column, int(21), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core_global_DASH_hierarchy = ns.InternWithValue(tmp0, lang.NewMap(kw_parents, lang.NewMap(), kw_descendants, lang.NewMap(), kw_ancestors, lang.NewMap()), true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_global_DASH_hierarchy.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // *print-dup* + // hash { - tmp0 := sym__STAR_print_DASH_dup_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "When set to logical true, objects will be printed in a way that preserves\n their type when read in later.\n\n Defaults to false.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, nil, true) + tmp0 := sym_hash.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns the hash code of its argument. Note this is the hash code\n consistent with =, and thus is different than .hashCode for Integer,\n Short, Byte and Clojure collections.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(5189), kw_end_DASH_line, int(5189))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(lang.HashEq, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_hash = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_hash.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // *print-length* + // hash-map { - tmp0 := sym__STAR_print_DASH_length_STAR_.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core_print.glj", kw_line, int(14), kw_column, int(6), kw_end_DASH_line, int(23), kw_end_DASH_column, int(15), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, nil, true) + tmp0 := sym_hash_DASH_map.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym__AMP_, sym_keyvals)), kw_doc, "keyval => key val\n Returns a new hash map with supplied mappings. If any keys are\n equal, they are handled as if by repeated uses of assoc.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(378), kw_end_DASH_line, int(378))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp2 := lang.NewMap() + tmp3 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(384), kw_column, int(7), kw_end_DASH_line, int(384), kw_end_DASH_column, int(8)) + tmp4, err := lang.WithMeta(tmp2, tmp3.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp4 + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + tmp3 := lang.Apply(lang.CreatePersistentHashMap, []any{v2}) + return tmp3 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_hash_DASH_map = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_hash_DASH_map.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // *print-level* + // hash-ordered-coll { - tmp0 := sym__STAR_print_DASH_level_STAR_.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core_print.glj", kw_line, int(25), kw_column, int(6), kw_end_DASH_line, int(35), kw_end_DASH_column, int(14), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, nil, true) + tmp0 := sym_hash_DASH_ordered_DASH_coll.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns the hash code, consistent with =, for an external ordered\n collection implementing Iterable.\n See http://glojure.org/data_structures#hash for full algorithms.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.6", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(7), kw_line, int(5210), kw_end_DASH_line, int(5210))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(nil, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_hash_DASH_ordered_DASH_coll = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_hash_DASH_ordered_DASH_coll.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // *print-meta* + // hash-set { - tmp0 := sym__STAR_print_DASH_meta_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "If set to logical true, when printing an object, its metadata will also\n be printed in a form that can be read back by the reader.\n\n Defaults to false.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, nil, true) + tmp0 := sym_hash_DASH_set.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym__AMP_, sym_keys)), kw_doc, "Returns a new hash set with supplied keys. Any equal keys are\n handled as if by repeated uses of conj.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(388), kw_end_DASH_line, int(388))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp2 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp3 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(393), kw_column, int(7), kw_end_DASH_line, int(393), kw_end_DASH_column, int(9)) + tmp4, err := lang.WithMeta(tmp2, tmp3.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp4 + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + tmp3 := lang.Apply(nil, []any{v2}) + return tmp3 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_hash_DASH_set = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_hash_DASH_set.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // *print-namespace-maps* + // hash-unordered-coll { - tmp0 := sym__STAR_print_DASH_namespace_DASH_maps_STAR_.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core_print.glj", kw_line, int(39), kw_column, int(6), kw_end_DASH_line, int(44), kw_end_DASH_column, int(23), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, false, true) + tmp0 := sym_hash_DASH_unordered_DASH_coll.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns the hash code, consistent with =, for an external unordered\n collection implementing Iterable. For maps, the iterator should\n return map entries whose hash is computed as\n (hash-ordered-coll [k v]).\n See http://glojure.org/data_structures#hash for full algorithms.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.6", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(25), kw_column, int(7), kw_line, int(5219), kw_end_DASH_line, int(5219))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(nil, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_hash_DASH_unordered_DASH_coll = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_hash_DASH_unordered_DASH_coll.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // *print-readably* + // identity { - tmp0 := sym__STAR_print_DASH_readably_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "When set to logical false, strings and characters will be printed with\n non-alphanumeric characters converted to the appropriate escape sequences.\n\n Defaults to true", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, true, true) + tmp0 := sym_identity.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns its argument.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(1446), kw_end_DASH_line, int(1446))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + return v2 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_identity = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_identity.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // *read-eval* + // inst-ms { - tmp0 := sym__STAR_read_DASH_eval_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "Defaults to true (or value specified by system property, see below)\n ***This setting implies that the full power of the reader is in play,\n including syntax that can cause code to execute. It should never be\n used with untrusted sources. See also: glojure.edn/read.***\n\n When set to logical false in the thread-local binding,\n the eval reader (#=) and record/type literal syntax are disabled in read/load.\n Example (will fail): (binding [*read-eval* false] (read-string \"#=(* 2 21)\"))\n\n The default binding can be controlled by the system property\n 'glojure.read.eval' System properties can be set on the command line\n like this:\n\n java -Dglojure.read.eval=false ...\n\n The system property can also be set to 'unknown' via\n -Dglojure.read.eval=unknown, in which case the default binding\n is :unknown and all reads will fail in contexts where *read-eval*\n has not been explicitly bound to either true or false. This setting\n can be a useful diagnostic tool to ensure that all of your reads\n occur in considered contexts. You can also accomplish this in a\n particular scope by binding *read-eval* to :unknown\n ", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, nil, true) + tmp0 := sym_inst_DASH_ms.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_inst)), kw_doc, "Return the number of milliseconds since January 1, 1970, 00:00:00 GMT", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(6831), kw_end_DASH_line, int(6831))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(nil, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_inst_DASH_ms = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_inst_DASH_ms.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // *repl* + // inst? { - tmp0 := sym__STAR_repl_STAR_.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core.glj", kw_line, int(6288), kw_column, int(6), kw_end_DASH_line, int(6291), kw_end_DASH_column, int(8), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, false, true) + tmp0 := sym_inst_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x satisfies Inst", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(6837), kw_end_DASH_line, int(6837))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + return nil + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_inst_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_inst_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // *unchecked-math* + // instance? { - tmp0 := sym__STAR_unchecked_DASH_math_STAR_.WithMeta(lang.NewMap(kw_added, "1.3", kw_doc, "While bound to true, compilations of +, -, *, inc, dec and the\n coercions will be done without overflow checks. While bound\n to :warn-on-boxed, same behavior as true, and a warning is emitted\n when compilation uses boxed math. Default: false.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, nil, true) + tmp0 := sym_instance_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_c, sym_x)), kw_doc, "Evaluates x and tests if it is an instance of the type\n t. Returns true or false", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(2), kw_line, int(139), kw_end_DASH_line, int(143))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function instance? + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(lang.HasType, []any{v3, v4}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(143), kw_column, int(12), kw_end_DASH_line, int(143), kw_end_DASH_column, int(85))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_instance_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_instance_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // *verbose-defrecords* + // int? { - tmp0 := sym__STAR_verbose_DASH_defrecords_STAR_.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core_print.glj", kw_line, int(37), kw_column, int(6), kw_end_DASH_line, int(37), kw_end_DASH_column, int(35), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, false, true) + tmp0 := sym_int_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a fixed precision integer", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1395), kw_end_DASH_line, int(1395))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "or__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := lang.Apply(tmp4, []any{lang.Builtins["int64"], v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + tmp7 = v6 + } else { + var tmp8 any + { // let + // let binding "or__0__auto__" + tmp9 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp10 := lang.Apply(tmp9, []any{nil, v2}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + tmp12 = v11 + } else { + var tmp13 any + { // let + // let binding "or__0__auto__" + tmp14 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp15 := lang.Apply(tmp14, []any{nil, v2}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + if lang.IsTruthy(v16) { + tmp17 = v16 + } else { + tmp18 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp19 := lang.Apply(tmp18, []any{nil, v2}) + tmp17 = tmp19 + } + tmp13 = tmp17 + } // end let + tmp12 = tmp13 + } + tmp8 = tmp12 + } // end let + tmp7 = tmp8 + } + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_int_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_int_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // *warn-on-reflection* + // integer? { - tmp0 := sym__STAR_warn_DASH_on_DASH_reflection_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "When set to true, the compiler will emit warnings when reflection is\n needed to resolve Java method calls or field accesses.\n\n Defaults to false.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, nil, true) + tmp0 := sym_integer_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_doc, "Returns true if n is an integer", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(1379), kw_end_DASH_line, int(1379))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(lang.IsInteger, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_integer_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_integer_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // + + // iterate { + tmp0 := sym_iterate.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_x)), kw_doc, "Returns a lazy (infinite!) sequence of x, (f x), (f (f x)) etc.\n f must be free of side-effects", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(3011), kw_end_DASH_line, int(3011))).(*lang.Symbol) var tmp1 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v2 := args[0] - _ = v2 - var tmp3 any - { // let - // let binding "op" - var tmp4 any - tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) - if lang.IsTruthy(tmp5) { - tmp4 = closed3 - } else { - tmp4 = closed4 - } - var v6 any = tmp4 - _ = v6 - tmp7 := checkDerefVar(var_glojure_DOT_core_seq) - tmp8 := checkDerefVar(var_glojure_DOT_core_concat) - tmp9 := checkDerefVar(var_glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) - tmp11 := checkDerefVar(var_glojure_DOT_core_list) - tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := checkDerefVar(var_glojure_DOT_core_seq) - tmp15 := checkDerefVar(var_glojure_DOT_core_concat) - tmp16 := checkDerefVar(var_glojure_DOT_core_list) - tmp17 := lang.Apply(tmp16, []any{v6}) - tmp18 := checkDerefVar(var_glojure_DOT_core_list) - tmp19 := lang.Apply(tmp18, []any{v2}) - tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) - tmp21 := lang.Apply(tmp14, []any{tmp20}) - tmp22 := lang.Apply(tmp13, []any{tmp21}) - tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) - tmp24 := lang.Apply(tmp7, []any{tmp23}) - tmp3 = tmp24 - } // end let - return tmp3 - case 2: - v2 := args[0] - _ = v2 - v3 := args[1] - _ = v3 - var tmp4 any - { // let - // let binding "op" - var tmp5 any - tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) - if lang.IsTruthy(tmp6) { - tmp5 = closed3 - } else { - tmp5 = closed4 - } - var v7 any = tmp5 - _ = v7 - tmp8 := checkDerefVar(var_glojure_DOT_core_seq) - tmp9 := checkDerefVar(var_glojure_DOT_core_concat) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) - tmp12 := checkDerefVar(var_glojure_DOT_core_list) - tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := checkDerefVar(var_glojure_DOT_core_seq) - tmp16 := checkDerefVar(var_glojure_DOT_core_concat) - tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{v7}) - tmp19 := checkDerefVar(var_glojure_DOT_core_list) - tmp20 := lang.Apply(tmp19, []any{v2}) - tmp21 := checkDerefVar(var_glojure_DOT_core_list) - tmp22 := lang.Apply(tmp21, []any{v3}) - tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) - tmp24 := lang.Apply(tmp15, []any{tmp23}) - tmp25 := lang.Apply(tmp14, []any{tmp24}) - tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) - tmp27 := lang.Apply(tmp8, []any{tmp26}) - tmp4 = tmp27 - } // end let - return tmp4 - default: - checkArity(args, 2) - v2 := args[0] - _ = v2 - v3 := args[1] - _ = v3 - var v4 any = lang.NewList(args[2:]...) - _ = v4 - var tmp5 any - { // let - // let binding "op" - var tmp6 any - tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) - if lang.IsTruthy(tmp7) { - tmp6 = closed3 - } else { - tmp6 = closed4 - } - var v8 any = tmp6 - _ = v8 - tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) - var tmp10 lang.FnFunc - tmp10 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v11 := args[0] - _ = v11 - v12 := args[1] - _ = v12 - tmp13 := checkDerefVar(var_glojure_DOT_core_seq) - tmp14 := checkDerefVar(var_glojure_DOT_core_concat) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) - tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp19 := checkDerefVar(var_glojure_DOT_core_list) - tmp20 := checkDerefVar(var_glojure_DOT_core_seq) - tmp21 := checkDerefVar(var_glojure_DOT_core_concat) - tmp22 := checkDerefVar(var_glojure_DOT_core_list) - tmp23 := lang.Apply(tmp22, []any{v8}) - tmp24 := checkDerefVar(var_glojure_DOT_core_list) - tmp25 := lang.Apply(tmp24, []any{v11}) - tmp26 := checkDerefVar(var_glojure_DOT_core_list) - tmp27 := lang.Apply(tmp26, []any{v12}) - tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) - tmp29 := lang.Apply(tmp20, []any{tmp28}) - tmp30 := lang.Apply(tmp19, []any{tmp29}) - tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) - tmp32 := lang.Apply(tmp13, []any{tmp31}) - return tmp32 - }) - tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp13 := checkDerefVar(var_glojure_DOT_core_seq) - tmp14 := checkDerefVar(var_glojure_DOT_core_concat) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) - tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp19 := checkDerefVar(var_glojure_DOT_core_list) - tmp20 := checkDerefVar(var_glojure_DOT_core_seq) - tmp21 := checkDerefVar(var_glojure_DOT_core_concat) - tmp22 := checkDerefVar(var_glojure_DOT_core_list) - tmp23 := lang.Apply(tmp22, []any{v8}) - tmp24 := checkDerefVar(var_glojure_DOT_core_list) - tmp25 := lang.Apply(tmp24, []any{v2}) - tmp26 := checkDerefVar(var_glojure_DOT_core_list) - tmp27 := lang.Apply(tmp26, []any{v3}) - tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) - tmp29 := lang.Apply(tmp20, []any{tmp28}) - tmp30 := lang.Apply(tmp19, []any{tmp29}) - tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) - tmp32 := lang.Apply(tmp13, []any{tmp31}) - tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) - tmp5 = tmp33 - } // end let - return tmp5 - } + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := lang.Apply(nil, []any{v2, v3}) + return tmp4 }) - tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_iterate = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_iterate.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // iterator-seq + { + tmp0 := sym_iterator_DASH_seq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_iter)), kw_doc, "Returns a seq on a java.util.Iterator. Note that most collections\n providing iterators implement Iterable and thus support seq directly.\n Seqs cache values, thus iterator-seq should not be used on any\n iterator that repeatedly returns the same mutable object.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(5700), kw_end_DASH_line, int(5700))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(nil, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_iterator_DASH_seq = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_iterator_DASH_seq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // key + { + tmp0 := sym_key.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_e)), kw_doc, "Returns the key of the map entry.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(1563), kw_end_DASH_line, int(1563))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(v2, "GetKey") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("GetKey is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + tmp4 := lang.Apply(tmp3, []any{}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_key = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_key.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // keys + { + tmp0 := sym_keys.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_map)), kw_doc, "Returns a sequence of the map's keys, in the same order as (seq map).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1551), kw_end_DASH_line, int(1551))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(lang.Keys, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_keys = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_keys.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // keyword? + { + tmp0 := sym_keyword_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a Keyword", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(563), kw_end_DASH_line, int(563))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp0 := sym__PLUS_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns the sum of nums. (+) returns 0. Does not auto-promote\n longs, will throw on overflow. See also: +'", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(7), kw_line, int(977), kw_end_DASH_line, int(977))).(*lang.Symbol) - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - return int64(0) - case 1: - v5 := args[0] - _ = v5 - tmp6 := lang.Apply(lang.MustAsNumber, []any{v5}) - return tmp6 - case 2: - v5 := args[0] - _ = v5 - v6 := args[1] + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_keyword_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_keyword_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // line-seq + { + tmp0 := sym_line_DASH_seq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_rdr)), kw_doc, "Returns the lines of text from rdr as a lazy sequence of strings.\n rdr must implement java.io.BufferedReader.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(3068), kw_end_DASH_line, int(3068))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "temp__0__auto__" + tmp4, ok := lang.FieldOrMethod(v2, "readLine") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "readLine"))) + } + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { + case reflect.Func: + tmp5 = lang.Apply(tmp4, nil) + default: + tmp5 = tmp4 + } + var v6 any = tmp5 _ = v6 - tmp7, _ := lang.FieldOrMethod(lang.Numbers, "Add") - if reflect.TypeOf(tmp7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Add is not a function"))) + var tmp7 any + if lang.IsTruthy(v6) { + var tmp8 any + { // let + // let binding "line" + var v9 any = v6 + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_cons) + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp12 := checkDerefVar(var_glojure_DOT_core_line_DASH_seq) + tmp13 := lang.Apply(tmp12, []any{v2}) + return tmp13 + }) + tmp12 := lang.Apply(lang.NewLazySeq, []any{tmp11}) + tmp13 := lang.Apply(tmp10, []any{v9, tmp12}) + tmp8 = tmp13 + } // end let + tmp7 = tmp8 + } else { } - tmp8 := lang.Apply(tmp7, []any{v5, v6}) - return tmp8 - default: - checkArity(args, 2) - v5 := args[0] - _ = v5 - v6 := args[1] + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_line_DASH_seq = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_line_DASH_seq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // list + { + tmp0 := sym_list.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_items)), kw_doc, "Creates a new list containing the items.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(6), kw_column, int(2), kw_line, int(15), kw_end_DASH_line, int(18))).(*lang.Symbol) + var_glojure_DOT_core_list = ns.InternWithValue(tmp0, lang.NewList, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_list.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // list? + { + tmp0 := sym_list_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x implements IPersistentList", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(6198), kw_end_DASH_line, int(6198))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*lang.IPersistentList)(nil)).Elem() + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_list_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_list_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // load-file + { + tmp0 := sym_load_DASH_file.WithMeta(lang.NewMap(kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core_load_DASH_file = ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_load_DASH_file.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // load-reader + { + tmp0 := sym_load_DASH_reader.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_rdr)), kw_doc, "Sequentially read and evaluate the set of forms contained in the\n stream/file", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(4081), kw_end_DASH_line, int(4081))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(runtime.Compiler, "load") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("load is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_load_DASH_reader = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_load_DASH_reader.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // load-string + { + tmp0 := sym_load_DASH_string.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_doc, "Sequentially read and evaluate the set of forms contained in the\n string", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(4088), kw_end_DASH_line, int(4088))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "rdr" + tmp4 := lang.Apply(nil, []any{v2}) + tmp5 := lang.Apply(nil, []any{tmp4}) + var v6 any = tmp5 _ = v6 - var v7 any = lang.NewList(args[2:]...) - _ = v7 - tmp8 := checkDerefVar(var_glojure_DOT_core_reduce1) - tmp9 := checkDerefVar(var_glojure_DOT_core__PLUS_) - tmp10 := checkDerefVar(var_glojure_DOT_core__PLUS_) - tmp11 := lang.Apply(tmp10, []any{v5, v6}) - tmp12 := lang.Apply(tmp8, []any{tmp9, tmp11, v7}) - return tmp12 + tmp7 := checkDerefVar(var_glojure_DOT_core_load_DASH_reader) + tmp8 := lang.Apply(tmp7, []any{v6}) + tmp3 = tmp8 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_load_DASH_string = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_load_DASH_string.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // macroexpand-1 + { + tmp0 := sym_macroexpand_DASH_1.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_form)), kw_doc, "If form represents a macro form, returns its expansion,\n else returns form.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(4017), kw_end_DASH_line, int(4017))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(runtime.Compiler, "macroexpand1") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("macroexpand1 is not a function"))) } + tmp4 := lang.Apply(tmp3, []any{v2}) + return tmp4 }) - tmp4 = tmp4.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp3 := ns.InternWithValue(tmp0, tmp4, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_macroexpand_DASH_1 = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_macroexpand_DASH_1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // +' + // make-hierarchy { + tmp0 := sym_make_DASH_hierarchy.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Creates a hierarchy object for use with derive, isa? etc.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(5507), kw_end_DASH_line, int(5507))).(*lang.Symbol) var tmp1 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v2 := args[0] - _ = v2 - var tmp3 any - { // let - // let binding "op" - var tmp4 any - tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) - if lang.IsTruthy(tmp5) { - tmp4 = closed5 - } else { - tmp4 = closed5 - } - var v6 any = tmp4 - _ = v6 - tmp7 := checkDerefVar(var_glojure_DOT_core_seq) - tmp8 := checkDerefVar(var_glojure_DOT_core_concat) - tmp9 := checkDerefVar(var_glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) - tmp11 := checkDerefVar(var_glojure_DOT_core_list) - tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := checkDerefVar(var_glojure_DOT_core_seq) - tmp15 := checkDerefVar(var_glojure_DOT_core_concat) - tmp16 := checkDerefVar(var_glojure_DOT_core_list) - tmp17 := lang.Apply(tmp16, []any{v6}) - tmp18 := checkDerefVar(var_glojure_DOT_core_list) - tmp19 := lang.Apply(tmp18, []any{v2}) - tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) - tmp21 := lang.Apply(tmp14, []any{tmp20}) - tmp22 := lang.Apply(tmp13, []any{tmp21}) - tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) - tmp24 := lang.Apply(tmp7, []any{tmp23}) - tmp3 = tmp24 - } // end let - return tmp3 - case 2: - v2 := args[0] - _ = v2 - v3 := args[1] - _ = v3 - var tmp4 any - { // let - // let binding "op" - var tmp5 any - tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) - if lang.IsTruthy(tmp6) { - tmp5 = closed5 - } else { - tmp5 = closed5 - } - var v7 any = tmp5 - _ = v7 - tmp8 := checkDerefVar(var_glojure_DOT_core_seq) - tmp9 := checkDerefVar(var_glojure_DOT_core_concat) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) - tmp12 := checkDerefVar(var_glojure_DOT_core_list) - tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := checkDerefVar(var_glojure_DOT_core_seq) - tmp16 := checkDerefVar(var_glojure_DOT_core_concat) - tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{v7}) - tmp19 := checkDerefVar(var_glojure_DOT_core_list) - tmp20 := lang.Apply(tmp19, []any{v2}) - tmp21 := checkDerefVar(var_glojure_DOT_core_list) - tmp22 := lang.Apply(tmp21, []any{v3}) - tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) - tmp24 := lang.Apply(tmp15, []any{tmp23}) - tmp25 := lang.Apply(tmp14, []any{tmp24}) - tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) - tmp27 := lang.Apply(tmp8, []any{tmp26}) - tmp4 = tmp27 - } // end let - return tmp4 - default: - checkArity(args, 2) - v2 := args[0] - _ = v2 - v3 := args[1] - _ = v3 - var v4 any = lang.NewList(args[2:]...) - _ = v4 - var tmp5 any - { // let - // let binding "op" - var tmp6 any - tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) - if lang.IsTruthy(tmp7) { - tmp6 = closed5 - } else { - tmp6 = closed5 - } - var v8 any = tmp6 - _ = v8 - tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) - var tmp10 lang.FnFunc - tmp10 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v11 := args[0] - _ = v11 - v12 := args[1] - _ = v12 - tmp13 := checkDerefVar(var_glojure_DOT_core_seq) - tmp14 := checkDerefVar(var_glojure_DOT_core_concat) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) - tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp19 := checkDerefVar(var_glojure_DOT_core_list) - tmp20 := checkDerefVar(var_glojure_DOT_core_seq) - tmp21 := checkDerefVar(var_glojure_DOT_core_concat) - tmp22 := checkDerefVar(var_glojure_DOT_core_list) - tmp23 := lang.Apply(tmp22, []any{v8}) - tmp24 := checkDerefVar(var_glojure_DOT_core_list) - tmp25 := lang.Apply(tmp24, []any{v11}) - tmp26 := checkDerefVar(var_glojure_DOT_core_list) - tmp27 := lang.Apply(tmp26, []any{v12}) - tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) - tmp29 := lang.Apply(tmp20, []any{tmp28}) - tmp30 := lang.Apply(tmp19, []any{tmp29}) - tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) - tmp32 := lang.Apply(tmp13, []any{tmp31}) - return tmp32 - }) - tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp13 := checkDerefVar(var_glojure_DOT_core_seq) - tmp14 := checkDerefVar(var_glojure_DOT_core_concat) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) - tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp19 := checkDerefVar(var_glojure_DOT_core_list) - tmp20 := checkDerefVar(var_glojure_DOT_core_seq) - tmp21 := checkDerefVar(var_glojure_DOT_core_concat) - tmp22 := checkDerefVar(var_glojure_DOT_core_list) - tmp23 := lang.Apply(tmp22, []any{v8}) - tmp24 := checkDerefVar(var_glojure_DOT_core_list) - tmp25 := lang.Apply(tmp24, []any{v2}) - tmp26 := checkDerefVar(var_glojure_DOT_core_list) - tmp27 := lang.Apply(tmp26, []any{v3}) - tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) - tmp29 := lang.Apply(tmp20, []any{tmp28}) - tmp30 := lang.Apply(tmp19, []any{tmp29}) - tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) - tmp32 := lang.Apply(tmp13, []any{tmp31}) - tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) - tmp5 = tmp33 - } // end let - return tmp5 + checkArity(args, 0) + tmp2 := lang.NewMap() + tmp3 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5511), kw_column, int(16), kw_end_DASH_line, int(5511), kw_end_DASH_column, int(17)) + tmp4, err := lang.WithMeta(tmp2, tmp3.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp5 := lang.NewMap() + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5511), kw_column, int(32), kw_end_DASH_line, int(5511), kw_end_DASH_column, int(33)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp8 := lang.NewMap() + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5511), kw_column, int(46), kw_end_DASH_line, int(5511), kw_end_DASH_column, int(47)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp11 := lang.NewMap(kw_parents, tmp4, kw_descendants, tmp7, kw_ancestors, tmp10) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5511), kw_column, int(6), kw_end_DASH_line, int(5511), kw_end_DASH_column, int(48)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) } + return tmp13 }) - tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_make_DASH_hierarchy = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_make_DASH_hierarchy.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // map-entry? + { + tmp0 := sym_map_DASH_entry_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a map entry", kw_file, "glojure/core.glj", kw_added, "1.8", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(1473), kw_end_DASH_line, int(1473))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) - } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*lang.MapEntry)(nil)).Elem() + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp0 := sym__PLUS__TICK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns the sum of nums. (+') returns 0. Supports arbitrary precision.\n See also: +", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(7), kw_line, int(965), kw_end_DASH_line, int(965))).(*lang.Symbol) - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - return int64(0) - case 1: - v5 := args[0] - _ = v5 - tmp6 := lang.Apply(lang.MustAsNumber, []any{v5}) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_map_DASH_entry_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_map_DASH_entry_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // map? + { + tmp0 := sym_map_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x implements IPersistentMap", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(5), kw_column, int(2), kw_line, int(167), kw_end_DASH_line, int(171))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function map? + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := reflect.TypeOf((*lang.IPersistentMap)(nil)).Elem() + tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) return tmp6 - case 2: - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - tmp7, _ := lang.FieldOrMethod(lang.Numbers, "AddP") - if reflect.TypeOf(tmp7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("AddP is not a function"))) - } - tmp8 := lang.Apply(tmp7, []any{v5, v6}) - return tmp8 - default: - checkArity(args, 2) - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - var v7 any = lang.NewList(args[2:]...) - _ = v7 - tmp8 := checkDerefVar(var_glojure_DOT_core_reduce1) - tmp9 := checkDerefVar(var_glojure_DOT_core__PLUS__TICK_) - tmp10 := checkDerefVar(var_glojure_DOT_core__PLUS__TICK_) - tmp11 := lang.Apply(tmp10, []any{v5, v6}) - tmp12 := lang.Apply(tmp8, []any{tmp9, tmp11, v7}) - return tmp12 - } - }) - tmp4 = tmp4.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp3 := ns.InternWithValue(tmp0, tmp4, true) + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(171), kw_column, int(7), kw_end_DASH_line, int(171), kw_end_DASH_column, int(97))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_map_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_map_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // - + // max-mask-bits + { + tmp0 := sym_max_DASH_mask_DASH_bits.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(6601), kw_column, int(6), kw_end_DASH_line, int(6601), kw_end_DASH_column, int(28), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core_max_DASH_mask_DASH_bits = ns.InternWithValue(tmp0, int64(13), true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_max_DASH_mask_DASH_bits.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // max-switch-table-size + { + tmp0 := sym_max_DASH_switch_DASH_table_DASH_size.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(6602), kw_column, int(6), kw_end_DASH_line, int(6602), kw_end_DASH_column, int(36), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core_max_DASH_switch_DASH_table_DASH_size = ns.InternWithValue(tmp0, int64(8192), true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_max_DASH_switch_DASH_table_DASH_size.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // meta { + tmp0 := sym_meta.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_obj)), kw_doc, "Returns the metadata of obj, returns nil if there is no metadata.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(5), kw_column, int(2), kw_line, int(202), kw_end_DASH_line, int(206))).(*lang.Symbol) var tmp1 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v2 := args[0] - _ = v2 - var tmp3 any - { // let - // let binding "op" - var tmp4 any - tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) - if lang.IsTruthy(tmp5) { - tmp4 = closed6 - } else { - tmp4 = closed7 - } - var v6 any = tmp4 - _ = v6 - tmp7 := checkDerefVar(var_glojure_DOT_core_seq) - tmp8 := checkDerefVar(var_glojure_DOT_core_concat) - tmp9 := checkDerefVar(var_glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) - tmp11 := checkDerefVar(var_glojure_DOT_core_list) - tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := checkDerefVar(var_glojure_DOT_core_seq) - tmp15 := checkDerefVar(var_glojure_DOT_core_concat) - tmp16 := checkDerefVar(var_glojure_DOT_core_list) - tmp17 := lang.Apply(tmp16, []any{v6}) - tmp18 := checkDerefVar(var_glojure_DOT_core_list) - tmp19 := lang.Apply(tmp18, []any{v2}) - tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) - tmp21 := lang.Apply(tmp14, []any{tmp20}) - tmp22 := lang.Apply(tmp13, []any{tmp21}) - tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) - tmp24 := lang.Apply(tmp7, []any{tmp23}) - tmp3 = tmp24 - } // end let - return tmp3 - case 2: - v2 := args[0] - _ = v2 - v3 := args[1] + { // function meta + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] _ = v3 var tmp4 any - { // let - // let binding "op" - var tmp5 any - tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) - if lang.IsTruthy(tmp6) { - tmp5 = closed6 - } else { - tmp5 = closed7 + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp6 := reflect.TypeOf((*lang.IMeta)(nil)).Elem() + tmp7 := lang.Apply(tmp5, []any{tmp6, v3}) + if lang.IsTruthy(tmp7) { + tmp8, ok := lang.FieldOrMethod(v3, "Meta") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "Meta"))) } - var v7 any = tmp5 - _ = v7 - tmp8 := checkDerefVar(var_glojure_DOT_core_seq) - tmp9 := checkDerefVar(var_glojure_DOT_core_concat) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) - tmp12 := checkDerefVar(var_glojure_DOT_core_list) - tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := checkDerefVar(var_glojure_DOT_core_seq) - tmp16 := checkDerefVar(var_glojure_DOT_core_concat) - tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{v7}) - tmp19 := checkDerefVar(var_glojure_DOT_core_list) - tmp20 := lang.Apply(tmp19, []any{v2}) - tmp21 := checkDerefVar(var_glojure_DOT_core_list) - tmp22 := lang.Apply(tmp21, []any{v3}) - tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) - tmp24 := lang.Apply(tmp15, []any{tmp23}) - tmp25 := lang.Apply(tmp14, []any{tmp24}) - tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) - tmp27 := lang.Apply(tmp8, []any{tmp26}) - tmp4 = tmp27 - } // end let + var tmp9 any + switch reflect.TypeOf(tmp8).Kind() { + case reflect.Func: + tmp9 = lang.Apply(tmp8, nil) + default: + tmp9 = tmp8 + } + tmp4 = tmp9 + } else { + } return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(206), kw_column, int(7), kw_end_DASH_line, int(208), kw_end_DASH_column, int(21))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_meta = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_meta.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // methods + { + tmp0 := sym_methods.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_multifn)), kw_doc, "Given a multimethod, returns a map of dispatch values -> dispatch fns", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(1809), kw_end_DASH_line, int(1809))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "getMethodTable") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getMethodTable"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) default: - checkArity(args, 2) - v2 := args[0] - _ = v2 - v3 := args[1] - _ = v3 - var v4 any = lang.NewList(args[2:]...) - _ = v4 - var tmp5 any - { // let - // let binding "op" - var tmp6 any - tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) - if lang.IsTruthy(tmp7) { - tmp6 = closed6 - } else { - tmp6 = closed7 - } - var v8 any = tmp6 - _ = v8 - tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) - var tmp10 lang.FnFunc - tmp10 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v11 := args[0] - _ = v11 - v12 := args[1] - _ = v12 - tmp13 := checkDerefVar(var_glojure_DOT_core_seq) - tmp14 := checkDerefVar(var_glojure_DOT_core_concat) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) - tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp19 := checkDerefVar(var_glojure_DOT_core_list) - tmp20 := checkDerefVar(var_glojure_DOT_core_seq) - tmp21 := checkDerefVar(var_glojure_DOT_core_concat) - tmp22 := checkDerefVar(var_glojure_DOT_core_list) - tmp23 := lang.Apply(tmp22, []any{v8}) - tmp24 := checkDerefVar(var_glojure_DOT_core_list) - tmp25 := lang.Apply(tmp24, []any{v11}) - tmp26 := checkDerefVar(var_glojure_DOT_core_list) - tmp27 := lang.Apply(tmp26, []any{v12}) - tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) - tmp29 := lang.Apply(tmp20, []any{tmp28}) - tmp30 := lang.Apply(tmp19, []any{tmp29}) - tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) - tmp32 := lang.Apply(tmp13, []any{tmp31}) - return tmp32 - }) - tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp13 := checkDerefVar(var_glojure_DOT_core_seq) - tmp14 := checkDerefVar(var_glojure_DOT_core_concat) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) - tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp19 := checkDerefVar(var_glojure_DOT_core_list) - tmp20 := checkDerefVar(var_glojure_DOT_core_seq) - tmp21 := checkDerefVar(var_glojure_DOT_core_concat) - tmp22 := checkDerefVar(var_glojure_DOT_core_list) - tmp23 := lang.Apply(tmp22, []any{v8}) - tmp24 := checkDerefVar(var_glojure_DOT_core_list) - tmp25 := lang.Apply(tmp24, []any{v2}) - tmp26 := checkDerefVar(var_glojure_DOT_core_list) - tmp27 := lang.Apply(tmp26, []any{v3}) - tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) - tmp29 := lang.Apply(tmp20, []any{tmp28}) - tmp30 := lang.Apply(tmp19, []any{tmp29}) - tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) - tmp32 := lang.Apply(tmp13, []any{tmp31}) - tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) - tmp5 = tmp33 - } // end let - return tmp5 + tmp4 = tmp3 } + return tmp4 }) - tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_methods = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_methods.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // mix-collection-hash + { + tmp0 := sym_mix_DASH_collection_DASH_hash.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_hash_DASH_basis, sym_count)), kw_doc, "Mix final collection hash for ordered or unordered collections.\n hash-basis is the combined collection hash, count is the number\n of elements included in the basis. Note this is the hash code\n consistent with =, different from .hashCode.\n See http://glojure.org/data_structures#hash for full algorithms.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.6", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(25), kw_column, int(7), kw_line, int(5199), kw_end_DASH_line, int(5199))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) - } - tmp5 := lang.Apply(tmp4, []any{nil, int64(0)}) - return tmp5 + tmp4 := lang.Apply(nil, []any{v2, v3}) + return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp0 := sym__DASH_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "If no ys are supplied, returns the negation of x, else subtracts\n the ys from x and returns the result. Does not auto-promote\n longs, will throw on overflow. See also: -'", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(7), kw_line, int(1036), kw_end_DASH_line, int(1036))).(*lang.Symbol) - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v5 := args[0] - _ = v5 - tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_) - tmp7 := lang.Apply(tmp6, []any{int64(-1), v5}) - return tmp7 - case 2: - v5 := args[0] - _ = v5 - v6 := args[1] + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_mix_DASH_collection_DASH_hash = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_mix_DASH_collection_DASH_hash.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // mk-bound-fn + { + tmp0 := sym_mk_DASH_bound_DASH_fn.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5127), kw_column, int(7), kw_end_DASH_line, int(5127), kw_end_DASH_column, int(17), kw_arglists, lang.NewList(lang.NewVector(sym_sc, sym_test, sym_key)), kw_private, true, kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v6 := args[0] _ = v6 - tmp7, _ := lang.FieldOrMethod(lang.Numbers, "Minus") - if reflect.TypeOf(tmp7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Minus is not a function"))) + tmp7, ok := lang.FieldOrMethod(v2, "comparator") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "comparator"))) } - tmp8 := lang.Apply(tmp7, []any{v5, v6}) - return tmp8 - default: - checkArity(args, 2) - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - var v7 any = lang.NewList(args[2:]...) - _ = v7 - tmp8 := checkDerefVar(var_glojure_DOT_core_reduce1) - tmp9 := checkDerefVar(var_glojure_DOT_core__DASH_) - tmp10 := checkDerefVar(var_glojure_DOT_core__DASH_) - tmp11 := lang.Apply(tmp10, []any{v5, v6}) - tmp12 := lang.Apply(tmp8, []any{tmp9, tmp11, v7}) - return tmp12 + var tmp8 any + switch reflect.TypeOf(tmp7).Kind() { + case reflect.Func: + tmp8 = lang.Apply(tmp7, nil) + default: + tmp8 = tmp7 + } + tmp9, _ := lang.FieldOrMethod(v2, "entryKey") + if reflect.TypeOf(tmp9).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("entryKey is not a function"))) + } + tmp10 := lang.Apply(tmp9, []any{v6}) + tmp11, _ := lang.FieldOrMethod(tmp8, "compare") + if reflect.TypeOf(tmp11).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("compare is not a function"))) + } + tmp12 := lang.Apply(tmp11, []any{tmp10, v4}) + tmp13 := lang.Apply(v3, []any{tmp12, int64(0)}) + return tmp13 + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5130), kw_column, int(3), kw_end_DASH_line, int(5131), kw_end_DASH_column, int(64)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) } + return tmp7 }) - tmp4 = tmp4.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp3 := ns.InternWithValue(tmp0, tmp4, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_mk_DASH_bound_DASH_fn = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_mk_DASH_bound_DASH_fn.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // -' + // namespace { - var tmp1 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v2 := args[0] - _ = v2 - var tmp3 any - { // let - // let binding "op" - var tmp4 any - tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) - if lang.IsTruthy(tmp5) { - tmp4 = closed8 - } else { - tmp4 = closed8 - } - var v6 any = tmp4 - _ = v6 - tmp7 := checkDerefVar(var_glojure_DOT_core_seq) - tmp8 := checkDerefVar(var_glojure_DOT_core_concat) - tmp9 := checkDerefVar(var_glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) - tmp11 := checkDerefVar(var_glojure_DOT_core_list) - tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := checkDerefVar(var_glojure_DOT_core_seq) - tmp15 := checkDerefVar(var_glojure_DOT_core_concat) - tmp16 := checkDerefVar(var_glojure_DOT_core_list) - tmp17 := lang.Apply(tmp16, []any{v6}) - tmp18 := checkDerefVar(var_glojure_DOT_core_list) - tmp19 := lang.Apply(tmp18, []any{v2}) - tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) - tmp21 := lang.Apply(tmp14, []any{tmp20}) - tmp22 := lang.Apply(tmp13, []any{tmp21}) - tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) - tmp24 := lang.Apply(tmp7, []any{tmp23}) - tmp3 = tmp24 - } // end let - return tmp3 - case 2: - v2 := args[0] - _ = v2 - v3 := args[1] - _ = v3 - var tmp4 any - { // let - // let binding "op" - var tmp5 any - tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) - if lang.IsTruthy(tmp6) { - tmp5 = closed8 - } else { - tmp5 = closed8 - } - var v7 any = tmp5 - _ = v7 - tmp8 := checkDerefVar(var_glojure_DOT_core_seq) - tmp9 := checkDerefVar(var_glojure_DOT_core_concat) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) - tmp12 := checkDerefVar(var_glojure_DOT_core_list) - tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := checkDerefVar(var_glojure_DOT_core_seq) - tmp16 := checkDerefVar(var_glojure_DOT_core_concat) - tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{v7}) - tmp19 := checkDerefVar(var_glojure_DOT_core_list) - tmp20 := lang.Apply(tmp19, []any{v2}) - tmp21 := checkDerefVar(var_glojure_DOT_core_list) - tmp22 := lang.Apply(tmp21, []any{v3}) - tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) - tmp24 := lang.Apply(tmp15, []any{tmp23}) - tmp25 := lang.Apply(tmp14, []any{tmp24}) - tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) - tmp27 := lang.Apply(tmp8, []any{tmp26}) - tmp4 = tmp27 - } // end let - return tmp4 - default: - checkArity(args, 2) - v2 := args[0] - _ = v2 - v3 := args[1] - _ = v3 - var v4 any = lang.NewList(args[2:]...) - _ = v4 - var tmp5 any - { // let - // let binding "op" - var tmp6 any - tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) - if lang.IsTruthy(tmp7) { - tmp6 = closed8 - } else { - tmp6 = closed8 - } - var v8 any = tmp6 - _ = v8 - tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) - var tmp10 lang.FnFunc - tmp10 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v11 := args[0] - _ = v11 - v12 := args[1] - _ = v12 - tmp13 := checkDerefVar(var_glojure_DOT_core_seq) - tmp14 := checkDerefVar(var_glojure_DOT_core_concat) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) - tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp19 := checkDerefVar(var_glojure_DOT_core_list) - tmp20 := checkDerefVar(var_glojure_DOT_core_seq) - tmp21 := checkDerefVar(var_glojure_DOT_core_concat) - tmp22 := checkDerefVar(var_glojure_DOT_core_list) - tmp23 := lang.Apply(tmp22, []any{v8}) - tmp24 := checkDerefVar(var_glojure_DOT_core_list) - tmp25 := lang.Apply(tmp24, []any{v11}) - tmp26 := checkDerefVar(var_glojure_DOT_core_list) - tmp27 := lang.Apply(tmp26, []any{v12}) - tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) - tmp29 := lang.Apply(tmp20, []any{tmp28}) - tmp30 := lang.Apply(tmp19, []any{tmp29}) - tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) - tmp32 := lang.Apply(tmp13, []any{tmp31}) - return tmp32 - }) - tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp13 := checkDerefVar(var_glojure_DOT_core_seq) - tmp14 := checkDerefVar(var_glojure_DOT_core_concat) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) - tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp19 := checkDerefVar(var_glojure_DOT_core_list) - tmp20 := checkDerefVar(var_glojure_DOT_core_seq) - tmp21 := checkDerefVar(var_glojure_DOT_core_concat) - tmp22 := checkDerefVar(var_glojure_DOT_core_list) - tmp23 := lang.Apply(tmp22, []any{v8}) - tmp24 := checkDerefVar(var_glojure_DOT_core_list) - tmp25 := lang.Apply(tmp24, []any{v2}) - tmp26 := checkDerefVar(var_glojure_DOT_core_list) - tmp27 := lang.Apply(tmp26, []any{v3}) - tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) - tmp29 := lang.Apply(tmp20, []any{tmp28}) - tmp30 := lang.Apply(tmp19, []any{tmp29}) - tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) - tmp32 := lang.Apply(tmp13, []any{tmp31}) - tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) - tmp5 = tmp33 - } // end let - return tmp5 - } - }) - tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) + tmp1 := reflect.TypeOf("") + tmp0 := sym_namespace.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns the namespace String of a symbol or keyword, or nil if not present.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(1593), kw_end_DASH_line, int(1593))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + tmp4, _ := lang.FieldOrMethod(v3, "Namespace") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Namespace is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(0)}) + tmp5 := lang.Apply(tmp4, []any{}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp0 := sym__DASH__TICK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "If no ys are supplied, returns the negation of x, else subtracts\n the ys from x and returns the result. Supports arbitrary precision.\n See also: -", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(7), kw_line, int(1024), kw_end_DASH_line, int(1024))).(*lang.Symbol) - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v5 := args[0] - _ = v5 - tmp6 := checkDerefVar(var_glojure_DOT_core__STAR__TICK_) - tmp7 := lang.Apply(tmp6, []any{int64(-1), v5}) - return tmp7 - case 2: - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - tmp7, _ := lang.FieldOrMethod(lang.Numbers, "MinusP") - if reflect.TypeOf(tmp7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("MinusP is not a function"))) - } - tmp8 := lang.Apply(tmp7, []any{v5, v6}) - return tmp8 - default: - checkArity(args, 2) - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - var v7 any = lang.NewList(args[2:]...) - _ = v7 - tmp8 := checkDerefVar(var_glojure_DOT_core_reduce1) - tmp9 := checkDerefVar(var_glojure_DOT_core__DASH__TICK_) - tmp10 := checkDerefVar(var_glojure_DOT_core__DASH__TICK_) - tmp11 := lang.Apply(tmp10, []any{v5, v6}) - tmp12 := lang.Apply(tmp8, []any{tmp9, tmp11, v7}) - return tmp12 - } - }) - tmp4 = tmp4.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp3 := ns.InternWithValue(tmp0, tmp4, true) + tmp3 := reflect.TypeOf("") + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_namespace = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_namespace.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // -> + // next { - tmp0 := sym__DASH__GT_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_x, sym__AMP_, sym_forms)), kw_doc, "Threads the expr through the forms. Inserts x as the\n second item in the first form, making a list of it if it is not a\n list already. If there are more forms, inserts the first form as the\n second item in second form, etc.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(11), kw_line, int(1675), kw_end_DASH_line, int(1675))).(*lang.Symbol) + tmp1 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() + tmp0 := sym_next.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a seq of the items after the first. Calls seq on its\n argument. If there are no more items, returns nil.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(5), kw_column, int(2), kw_line, int(55), kw_end_DASH_line, int(61))).(*lang.Symbol) var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 3) + { // function next + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + tmp5 := lang.Apply(lang.Next, []any{v4}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(61), kw_column, int(7), kw_end_DASH_line, int(61), kw_end_DASH_column, int(77))).(lang.FnFunc) + v3 = tmp2 + _ = v3 + } + var_glojure_DOT_core_next = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_next.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // nfirst + { + tmp0 := sym_nfirst.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Same as (next (first x))", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(2), kw_line, int(105), kw_end_DASH_line, int(109))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function nfirst + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) v3 := args[0] _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any - { // let - // let binding "x" - var v8 any = v5 - _ = v8 - // let binding "forms" - var v9 any = v6 - _ = v9 - for { - var tmp10 any - if lang.IsTruthy(v9) { - var tmp11 any - { // let - // let binding "form" - tmp12 := checkDerefVar(var_glojure_DOT_core_first) - tmp13 := lang.Apply(tmp12, []any{v9}) - var v14 any = tmp13 - _ = v14 - // let binding "threaded" - var tmp15 any - tmp16 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) - tmp17 := lang.Apply(tmp16, []any{v14}) - if lang.IsTruthy(tmp17) { - tmp18 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) - tmp19 := checkDerefVar(var_glojure_DOT_core_seq) - tmp20 := checkDerefVar(var_glojure_DOT_core_concat) - tmp21 := checkDerefVar(var_glojure_DOT_core_list) - tmp22 := checkDerefVar(var_glojure_DOT_core_first) - tmp23 := lang.Apply(tmp22, []any{v14}) - tmp24 := lang.Apply(tmp21, []any{tmp23}) - tmp25 := checkDerefVar(var_glojure_DOT_core_list) - tmp26 := lang.Apply(tmp25, []any{v8}) - tmp27 := checkDerefVar(var_glojure_DOT_core_next) - tmp28 := lang.Apply(tmp27, []any{v14}) - tmp29 := lang.Apply(tmp20, []any{tmp24, tmp26, tmp28}) - tmp30 := lang.Apply(tmp19, []any{tmp29}) - tmp31 := checkDerefVar(var_glojure_DOT_core_meta) - tmp32 := lang.Apply(tmp31, []any{v14}) - tmp33 := lang.Apply(tmp18, []any{tmp30, tmp32}) - tmp15 = tmp33 - } else { - tmp34 := checkDerefVar(var_glojure_DOT_core_list) - tmp35 := lang.Apply(tmp34, []any{v14, v8}) - tmp15 = tmp35 - } - var v36 any = tmp15 - _ = v36 - var tmp37 any = v36 - tmp39 := checkDerefVar(var_glojure_DOT_core_next) - tmp40 := lang.Apply(tmp39, []any{v9}) - var tmp38 any = tmp40 - v8 = tmp37 - v9 = tmp38 - continue - } // end let - tmp10 = tmp11 - } else { - tmp10 = v8 - } - tmp7 = tmp10 - break - } - } // end let + tmp4 := checkDerefVar(var_glojure_DOT_core_next) + tmp5 := checkDerefVar(var_glojure_DOT_core_first) + tmp6 := lang.Apply(tmp5, []any{v3}) + tmp7 := lang.Apply(tmp4, []any{tmp6}) return tmp7 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(109), kw_column, int(9), kw_end_DASH_line, int(109), kw_end_DASH_column, int(49))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_nfirst = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_nfirst.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // ->> + // nil? { - tmp0 := sym__DASH__GT__GT_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_x, sym__AMP_, sym_forms)), kw_doc, "Threads the expr through the forms. Inserts x as the\n last item in the first form, making a list of it if it is not a\n list already. If there are more forms, inserts the first form as the\n last item in second form, etc.", kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(11), kw_line, int(1691), kw_end_DASH_line, int(1691))).(*lang.Symbol) + tmp1 := reflect.TypeOf(false) var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 3) + { // function nil?__inliner + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_list) + tmp6 := lang.Apply(tmp5, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Identical, v4, nil}) + return tmp6 + }) + v3 = tmp2 + _ = v3 + } + tmp0 := sym_nil_QMARK_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp2, kw_doc, "Returns true if x is nil, false otherwise.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(435), kw_end_DASH_line, int(435))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + tmp5 := lang.Apply(lang.IsNil, []any{v4}) + return tmp5 + }) + tmp4 := reflect.TypeOf(false) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) + var_glojure_DOT_core_nil_QMARK_ = ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_nil_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // nnext + { + tmp0 := sym_nnext.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Same as (next (next x))", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(6), kw_column, int(2), kw_line, int(119), kw_end_DASH_line, int(123))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function nnext + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) v3 := args[0] _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any - { // let - // let binding "x" - var v8 any = v5 - _ = v8 - // let binding "forms" - var v9 any = v6 - _ = v9 - for { - var tmp10 any - if lang.IsTruthy(v9) { - var tmp11 any - { // let - // let binding "form" - tmp12 := checkDerefVar(var_glojure_DOT_core_first) - tmp13 := lang.Apply(tmp12, []any{v9}) - var v14 any = tmp13 - _ = v14 - // let binding "threaded" - var tmp15 any - tmp16 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) - tmp17 := lang.Apply(tmp16, []any{v14}) - if lang.IsTruthy(tmp17) { - tmp18 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) - tmp19 := checkDerefVar(var_glojure_DOT_core_seq) - tmp20 := checkDerefVar(var_glojure_DOT_core_concat) - tmp21 := checkDerefVar(var_glojure_DOT_core_list) - tmp22 := checkDerefVar(var_glojure_DOT_core_first) - tmp23 := lang.Apply(tmp22, []any{v14}) - tmp24 := lang.Apply(tmp21, []any{tmp23}) - tmp25 := checkDerefVar(var_glojure_DOT_core_next) - tmp26 := lang.Apply(tmp25, []any{v14}) - tmp27 := checkDerefVar(var_glojure_DOT_core_list) - tmp28 := lang.Apply(tmp27, []any{v8}) - tmp29 := lang.Apply(tmp20, []any{tmp24, tmp26, tmp28}) - tmp30 := lang.Apply(tmp19, []any{tmp29}) - tmp31 := checkDerefVar(var_glojure_DOT_core_meta) - tmp32 := lang.Apply(tmp31, []any{v14}) - tmp33 := lang.Apply(tmp18, []any{tmp30, tmp32}) - tmp15 = tmp33 - } else { - tmp34 := checkDerefVar(var_glojure_DOT_core_list) - tmp35 := lang.Apply(tmp34, []any{v14, v8}) - tmp15 = tmp35 - } - var v36 any = tmp15 - _ = v36 - var tmp37 any = v36 - tmp39 := checkDerefVar(var_glojure_DOT_core_next) - tmp40 := lang.Apply(tmp39, []any{v9}) - var tmp38 any = tmp40 - v8 = tmp37 - v9 = tmp38 - continue - } // end let - tmp10 = tmp11 - } else { - tmp10 = v8 - } - tmp7 = tmp10 - break - } - } // end let + tmp4 := checkDerefVar(var_glojure_DOT_core_next) + tmp5 := checkDerefVar(var_glojure_DOT_core_next) + tmp6 := lang.Apply(tmp5, []any{v3}) + tmp7 := lang.Apply(tmp4, []any{tmp6}) return tmp7 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(123), kw_column, int(8), kw_end_DASH_line, int(123), kw_end_DASH_column, int(46))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_nnext = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_nnext.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // not + { + tmp1 := reflect.TypeOf(false) + tmp0 := sym_not.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x is logical false, false otherwise.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(523), kw_end_DASH_line, int(523))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + var tmp4 any + if lang.IsTruthy(v3) { + tmp4 = false + } else { + tmp4 = true } + return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp3 := reflect.TypeOf(false) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_not = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_not.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // -protocols + // number? { - tmp0 := sym__DASH_protocols.WithMeta(lang.NewMap(kw_private, true, kw_doc, "Private store of protocols. Go's reflection capabilities\n don't yet support a native interface-based implementation, so\n protocols are implemented in Glojure as maps from type to protocol\n method implementations.", kw_file, "glojure/core_deftype.glj", kw_line, int(21), kw_column, int(3), kw_end_DASH_line, int(26), kw_end_DASH_column, int(12), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - var tmp5 lang.FnFunc - tmp5 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 1) - v6 := args[0] - _ = v6 - var v7 any = lang.NewList(args[1:]...) - _ = v7 - tmp8 := checkDerefVar(var_glojure_DOT_core_class) - tmp9 := lang.Apply(tmp8, []any{v6}) - return tmp9 - } + tmp0 := sym_number_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x is a Number", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(3560), kw_end_DASH_line, int(3560))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(lang.IsNumber, []any{v2}) + return tmp3 }) - tmp4 := lang.NewMultiFn("coll-reduce", tmp5, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) - var tmp6 lang.FnFunc - tmp6 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 1) - v7 := args[0] - _ = v7 - var v8 any = lang.NewList(args[1:]...) - _ = v8 - tmp9 := checkDerefVar(var_glojure_DOT_core_apply) - tmp10 := checkDerefVar(var_glojure_DOT_core_cons) - tmp11 := lang.Apply(tmp10, []any{v7, v8}) - tmp12 := lang.Apply(tmp9, []any{closed9, tmp11}) - return tmp12 + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_number_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_number_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // numerator + { + tmp1 := reflect.TypeOf((*big9.Int)(nil)) + tmp0 := sym_numerator.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_r)), kw_doc, "Returns the numerator part of a Ratio.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(3583), kw_end_DASH_line, int(3583))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, ok := lang.FieldOrMethod(v3, "numerator") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "numerator"))) } - }) - tmp4.AddMethod(nil, tmp6) - tmp7 := reflect.TypeOf((*lang.IReduceInit)(nil)).Elem() - var tmp8 lang.FnFunc - tmp8 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { + case reflect.Func: + tmp5 = lang.Apply(tmp4, nil) default: - checkArity(args, 1) - v9 := args[0] - _ = v9 - var v10 any = lang.NewList(args[1:]...) - _ = v10 - tmp11 := checkDerefVar(var_glojure_DOT_core_apply) - tmp12 := checkDerefVar(var_glojure_DOT_core_cons) - tmp13 := lang.Apply(tmp12, []any{v9, v10}) - tmp14 := lang.Apply(tmp11, []any{closed10, tmp13}) - return tmp14 + tmp5 = tmp4 } + return tmp5 }) - tmp4.AddMethod(tmp7, tmp8) - tmp9 := reflect.TypeOf((*lang.LazySeq)(nil)) - var tmp10 lang.FnFunc - tmp10 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 1) - v11 := args[0] - _ = v11 - var v12 any = lang.NewList(args[1:]...) - _ = v12 - tmp13 := checkDerefVar(var_glojure_DOT_core_apply) - tmp14 := checkDerefVar(var_glojure_DOT_core_cons) - tmp15 := lang.Apply(tmp14, []any{v11, v12}) - tmp16 := lang.Apply(tmp13, []any{closed11, tmp15}) - return tmp16 + tmp3 := reflect.TypeOf((*big9.Int)(nil)) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_numerator = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_numerator.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // peek + { + tmp0 := sym_peek.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "For a list or queue, same as first, for a vector, same as, but much\n more efficient than, last. If the collection is empty, returns nil.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1455), kw_end_DASH_line, int(1455))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(runtime.RT, "Peek") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Peek is not a function"))) } + tmp4 := lang.Apply(tmp3, []any{v2}) + return tmp4 }) - tmp4.AddMethod(tmp9, tmp10) - tmp11 := reflect.TypeOf((*lang.Vector)(nil)) - var tmp12 lang.FnFunc - tmp12 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 1) - v13 := args[0] - _ = v13 - var v14 any = lang.NewList(args[1:]...) - _ = v14 - tmp15 := checkDerefVar(var_glojure_DOT_core_apply) - tmp16 := checkDerefVar(var_glojure_DOT_core_cons) - tmp17 := lang.Apply(tmp16, []any{v13, v14}) - tmp18 := lang.Apply(tmp15, []any{closed12, tmp17}) - return tmp18 + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_peek = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_peek.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // persistent! + { + tmp0 := sym_persistent_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a new, persistent version of the transient collection, in\n constant time. The transient collection cannot be used after this\n call, any such use will throw an exception.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(3350), kw_end_DASH_line, int(3350))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "Persistent") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "Persistent"))) } - }) - tmp4.AddMethod(tmp11, tmp12) - tmp3 := lang.NewAtom(lang.NewMap(kw_multis, lang.NewMap(kw_coll_DASH_reduce, tmp4), kw_on_DASH_interface, true, kw_sigs, lang.NewList(lang.NewList(sym_coll_DASH_reduce, lang.NewVector(sym_coll, sym_f), lang.NewVector(sym_coll, sym_f, sym_val))))) - var tmp15 lang.FnFunc - tmp15 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) default: - checkArity(args, 1) - v16 := args[0] - _ = v16 - var v17 any = lang.NewList(args[1:]...) - _ = v17 - tmp18 := checkDerefVar(var_glojure_DOT_core_class) - tmp19 := lang.Apply(tmp18, []any{v16}) - return tmp19 + tmp4 = tmp3 } + return tmp4 }) - tmp14 := lang.NewMultiFn("internal-reduce", tmp15, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) - var tmp16 lang.FnFunc - tmp16 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 1) - v17 := args[0] - _ = v17 - var v18 any = lang.NewList(args[1:]...) - _ = v18 - tmp19 := checkDerefVar(var_glojure_DOT_core_apply) - tmp20 := checkDerefVar(var_glojure_DOT_core_cons) - tmp21 := lang.Apply(tmp20, []any{v17, v18}) - tmp22 := lang.Apply(tmp19, []any{closed13, tmp21}) - return tmp22 + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_persistent_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_persistent_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // pop + { + tmp0 := sym_pop.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "For a list or queue, returns a new list/queue without the first\n item, for a vector, returns a new vector without the last item. If\n the collection is empty, throws an exception. Note - not the same\n as next/butlast.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(1462), kw_end_DASH_line, int(1462))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(runtime.RT, "Pop") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Pop is not a function"))) } + tmp4 := lang.Apply(tmp3, []any{v2}) + return tmp4 }) - tmp14.AddMethod(nil, tmp16) - tmp17 := reflect.TypeOf((*lang.IChunkedSeq)(nil)).Elem() - var tmp18 lang.FnFunc - tmp18 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 1) - v19 := args[0] - _ = v19 - var v20 any = lang.NewList(args[1:]...) - _ = v20 - tmp21 := checkDerefVar(var_glojure_DOT_core_apply) - tmp22 := checkDerefVar(var_glojure_DOT_core_cons) - tmp23 := lang.Apply(tmp22, []any{v19, v20}) - tmp24 := lang.Apply(tmp21, []any{closed14, tmp23}) - return tmp24 - } - }) - tmp14.AddMethod(tmp17, tmp18) - tmp19 := reflect.TypeOf((*lang.Object)(nil)).Elem() - var tmp20 lang.FnFunc - tmp20 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 1) - v21 := args[0] - _ = v21 - var v22 any = lang.NewList(args[1:]...) - _ = v22 - tmp23 := checkDerefVar(var_glojure_DOT_core_apply) - tmp24 := checkDerefVar(var_glojure_DOT_core_cons) - tmp25 := lang.Apply(tmp24, []any{v21, v22}) - tmp26 := lang.Apply(tmp23, []any{closed15, tmp25}) - return tmp26 - } - }) - tmp14.AddMethod(tmp19, tmp20) - tmp13 := lang.NewAtom(lang.NewMap(kw_multis, lang.NewMap(kw_internal_DASH_reduce, tmp14), kw_on_DASH_interface, true, kw_sigs, lang.NewList(lang.NewList(sym_internal_DASH_reduce, lang.NewVector(sym_seq, sym_f, sym_start))))) - var tmp23 lang.FnFunc - tmp23 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 1) - v24 := args[0] - _ = v24 - var v25 any = lang.NewList(args[1:]...) - _ = v25 - tmp26 := checkDerefVar(var_glojure_DOT_core_class) - tmp27 := lang.Apply(tmp26, []any{v24}) - return tmp27 - } - }) - tmp22 := lang.NewMultiFn("kv-reduce", tmp23, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) - tmp21 := lang.NewAtom(lang.NewMap(kw_multis, lang.NewMap(kw_kv_DASH_reduce, tmp22), kw_on_DASH_interface, true, kw_sigs, lang.NewList(lang.NewList(sym_kv_DASH_reduce, lang.NewVector(sym_amap, sym_f, sym_init))))) - var tmp26 lang.FnFunc - tmp26 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 1) - v27 := args[0] - _ = v27 - var v28 any = lang.NewList(args[1:]...) - _ = v28 - tmp29 := checkDerefVar(var_glojure_DOT_core_class) - tmp30 := lang.Apply(tmp29, []any{v27}) - return tmp30 - } - }) - tmp25 := lang.NewMultiFn("datafy", tmp26, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) - var tmp27 lang.FnFunc - tmp27 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 1) - v28 := args[0] - _ = v28 - var v29 any = lang.NewList(args[1:]...) - _ = v29 - tmp30 := checkDerefVar(var_glojure_DOT_core_apply) - tmp31 := checkDerefVar(var_glojure_DOT_core_cons) - tmp32 := lang.Apply(tmp31, []any{v28, v29}) - tmp33 := lang.Apply(tmp30, []any{closed16, tmp32}) - return tmp33 + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_pop = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_pop.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // pop! + { + tmp0 := sym_pop_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Removes the last item from a transient vector. If\n the collection is empty, throws an exception. Returns coll", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3393), kw_end_DASH_line, int(3393))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "pop") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "pop"))) } - }) - tmp25.AddMethod(nil, tmp27) - tmp24 := lang.NewAtom(lang.NewMap(kw_multis, lang.NewMap(kw_datafy, tmp25), kw_on_DASH_interface, true, kw_sigs, lang.NewList(lang.NewList(sym_datafy, lang.NewVector(sym_o), "return a representation of o as data (default identity)")))) - var tmp30 lang.FnFunc - tmp30 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) default: - checkArity(args, 1) - v31 := args[0] - _ = v31 - var v32 any = lang.NewList(args[1:]...) - _ = v32 - tmp33 := checkDerefVar(var_glojure_DOT_core_class) - tmp34 := lang.Apply(tmp33, []any{v31}) - return tmp34 + tmp4 = tmp3 } + return tmp4 }) - tmp29 := lang.NewMultiFn("nav", tmp30, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) - tmp28 := lang.NewAtom(lang.NewMap(kw_multis, lang.NewMap(kw_nav, tmp29), kw_on_DASH_interface, true, kw_sigs, lang.NewList(lang.NewList(sym_nav, lang.NewVector(sym_coll, sym_k, sym_v), "return (possibly transformed) v in the context of coll and k (a key/index or nil),\ndefaults to returning v.")))) - var tmp33 lang.FnFunc - tmp33 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 1) - v34 := args[0] - _ = v34 - var v35 any = lang.NewList(args[1:]...) - _ = v35 - tmp36 := checkDerefVar(var_glojure_DOT_core_class) - tmp37 := lang.Apply(tmp36, []any{v34}) - return tmp37 - } + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_pop_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_pop_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // pop-thread-bindings + { + tmp0 := sym_pop_DASH_thread_DASH_bindings.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Pop one set of bindings pushed with push-binding before. It is an error to\n pop bindings without pushing before.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(25), kw_column, int(7), kw_line, int(1929), kw_end_DASH_line, int(1929))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp2 := lang.Apply(lang.PopThreadBindings, nil) + return tmp2 }) - tmp32 := lang.NewMultiFn("make-reader", tmp33, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) - tmp34 := reflect.TypeOf((*io4.Reader)(nil)).Elem() - var tmp35 lang.FnFunc - tmp35 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 1) - v36 := args[0] - _ = v36 - var v37 any = lang.NewList(args[1:]...) - _ = v37 - tmp38 := checkDerefVar(var_glojure_DOT_core_apply) - tmp39 := checkDerefVar(var_glojure_DOT_core_cons) - tmp40 := lang.Apply(tmp39, []any{v36, v37}) - tmp41 := lang.Apply(tmp38, []any{closed17, tmp40}) - return tmp41 + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_pop_DASH_thread_DASH_bindings = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_pop_DASH_thread_DASH_bindings.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // prefer-method + { + tmp0 := sym_prefer_DASH_method.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_multifn, sym_dispatch_DASH_val_DASH_x, sym_dispatch_DASH_val_DASH_y)), kw_doc, "Causes the multimethod to prefer matches of dispatch-val-x over dispatch-val-y \n when there is a conflict", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(1801), kw_end_DASH_line, int(1801))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5, _ := lang.FieldOrMethod(v2, "PreferMethod") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("PreferMethod is not a function"))) } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 }) - tmp32.AddMethod(tmp34, tmp35) - tmp36 := reflect.TypeOf((*url5.URL)(nil)) - var tmp37 lang.FnFunc - tmp37 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 1) - v38 := args[0] - _ = v38 - var v39 any = lang.NewList(args[1:]...) - _ = v39 - tmp40 := checkDerefVar(var_glojure_DOT_core_apply) - tmp41 := checkDerefVar(var_glojure_DOT_core_cons) - tmp42 := lang.Apply(tmp41, []any{v38, v39}) - tmp43 := lang.Apply(tmp40, []any{closed18, tmp42}) - return tmp43 + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_prefer_DASH_method = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_prefer_DASH_method.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // prefers + { + tmp0 := sym_prefers.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_multifn)), kw_doc, "Given a multimethod, returns a map of preferred value -> set of other values", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(1822), kw_end_DASH_line, int(1822))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "getPreferTable") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getPreferTable"))) } - }) - tmp32.AddMethod(tmp36, tmp37) - tmp38 := reflect.TypeOf("") - var tmp39 lang.FnFunc - tmp39 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) default: - checkArity(args, 1) - v40 := args[0] - _ = v40 - var v41 any = lang.NewList(args[1:]...) - _ = v41 - tmp42 := checkDerefVar(var_glojure_DOT_core_apply) - tmp43 := checkDerefVar(var_glojure_DOT_core_cons) - tmp44 := lang.Apply(tmp43, []any{v40, v41}) - tmp45 := lang.Apply(tmp42, []any{closed18, tmp44}) - return tmp45 + tmp4 = tmp3 } + return tmp4 }) - tmp32.AddMethod(tmp38, tmp39) - var tmp41 lang.FnFunc - tmp41 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 1) - v42 := args[0] - _ = v42 - var v43 any = lang.NewList(args[1:]...) - _ = v43 - tmp44 := checkDerefVar(var_glojure_DOT_core_class) - tmp45 := lang.Apply(tmp44, []any{v42}) - return tmp45 - } + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_prefers = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_prefers.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print-initialized + { + tmp0 := sym_print_DASH_initialized.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core_print.glj", kw_line, int(520), kw_column, int(6), kw_end_DASH_line, int(520), kw_end_DASH_column, int(39), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core_print_DASH_initialized = ns.InternWithValue(tmp0, true, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_print_DASH_initialized.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // push-thread-bindings + { + tmp0 := sym_push_DASH_thread_DASH_bindings.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_bindings)), kw_doc, "WARNING: This is a low-level function. Prefer high-level macros like\n binding where ever possible.\n\n Takes a map of Var/value pairs. Binds each Var to the associated value for\n the current thread. Each call *MUST* be accompanied by a matching call to\n pop-thread-bindings wrapped in a try-finally!\n \n (push-thread-bindings bindings)\n (try\n ...\n (finally\n (pop-thread-bindings)))", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(26), kw_column, int(7), kw_line, int(1911), kw_end_DASH_line, int(1911))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(lang.PushThreadBindings, []any{v2}) + return tmp3 }) - tmp40 := lang.NewMultiFn("make-writer", tmp41, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) - tmp42 := reflect.TypeOf((*io4.Reader)(nil)).Elem() - var tmp43 lang.FnFunc - tmp43 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 1) - v44 := args[0] - _ = v44 - var v45 any = lang.NewList(args[1:]...) - _ = v45 - tmp46 := checkDerefVar(var_glojure_DOT_core_apply) - tmp47 := checkDerefVar(var_glojure_DOT_core_cons) - tmp48 := lang.Apply(tmp47, []any{v44, v45}) - tmp49 := lang.Apply(tmp46, []any{closed19, tmp48}) - return tmp49 - } + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_push_DASH_thread_DASH_bindings = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_push_DASH_thread_DASH_bindings.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // random-uuid + { + tmp0 := sym_random_DASH_uuid.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Returns a pseudo-randomly generated java.util.UUID instance (i.e. type 4).\n\n See: https://docs.oracle.com/javase/8/docs/api/java/util/UUID.html#randomUUID--", kw_file, "glojure/core.glj", kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(6852), kw_end_DASH_line, int(6852))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp2 := lang.Apply(uuid13.NewV7, nil) + return tmp2 }) - tmp40.AddMethod(tmp42, tmp43) - tmp44 := reflect.TypeOf((*url5.URL)(nil)) - var tmp45 lang.FnFunc - tmp45 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 1) - v46 := args[0] - _ = v46 - var v47 any = lang.NewList(args[1:]...) - _ = v47 - tmp48 := checkDerefVar(var_glojure_DOT_core_apply) - tmp49 := checkDerefVar(var_glojure_DOT_core_cons) - tmp50 := lang.Apply(tmp49, []any{v46, v47}) - tmp51 := lang.Apply(tmp48, []any{closed19, tmp50}) - return tmp51 - } + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_random_DASH_uuid = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_random_DASH_uuid.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ratio? + { + tmp0 := sym_ratio_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_doc, "Returns true if n is a Ratio", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(3577), kw_end_DASH_line, int(3577))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*lang.Ratio)(nil)) + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 }) - tmp40.AddMethod(tmp44, tmp45) - tmp46 := reflect.TypeOf("") - var tmp47 lang.FnFunc - tmp47 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 1) - v48 := args[0] - _ = v48 - var v49 any = lang.NewList(args[1:]...) - _ = v49 - tmp50 := checkDerefVar(var_glojure_DOT_core_apply) - tmp51 := checkDerefVar(var_glojure_DOT_core_cons) - tmp52 := lang.Apply(tmp51, []any{v48, v49}) - tmp53 := lang.Apply(tmp50, []any{closed19, tmp52}) - return tmp53 + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ratio_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ratio_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // rationalize + { + tmp0 := sym_rationalize.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_num)), kw_doc, "returns the rational value of num", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(1282), kw_end_DASH_line, int(1282))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(lang.Numbers, "Rationalize") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Rationalize is not a function"))) } + tmp4 := lang.Apply(tmp3, []any{v2}) + return tmp4 }) - tmp40.AddMethod(tmp46, tmp47) - var tmp49 lang.FnFunc - tmp49 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 1) - v50 := args[0] - _ = v50 - var v51 any = lang.NewList(args[1:]...) - _ = v51 - tmp52 := checkDerefVar(var_glojure_DOT_core_class) - tmp53 := lang.Apply(tmp52, []any{v50}) - return tmp53 - } + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_rationalize = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_rationalize.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // re-matcher + { + tmp1 := reflect.TypeOf((*lang.RegexpMatcher)(nil)) + tmp0 := sym_re_DASH_matcher.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_re, sym_s)), kw_doc, "Returns an instance of java.util.regex.Matcher, for use, e.g. in\n re-find.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4873), kw_end_DASH_line, int(4873))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(lang.NewRegexpMatcher, []any{v3, v4}) + return tmp5 }) - tmp48 := lang.NewMultiFn("make-input-stream", tmp49, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) - tmp50 := reflect.TypeOf((*io4.Reader)(nil)).Elem() - var tmp51 lang.FnFunc - tmp51 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 1) - v52 := args[0] - _ = v52 - var v53 any = lang.NewList(args[1:]...) - _ = v53 - tmp54 := checkDerefVar(var_glojure_DOT_core_apply) - tmp55 := checkDerefVar(var_glojure_DOT_core_cons) - tmp56 := lang.Apply(tmp55, []any{v52, v53}) - tmp57 := lang.Apply(tmp54, []any{closed20, tmp56}) - return tmp57 + tmp3 := reflect.TypeOf((*lang.RegexpMatcher)(nil)) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_re_DASH_matcher = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_re_DASH_matcher.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // re-pattern + { + tmp1 := reflect.TypeOf((*regexp15.Regexp)(nil)) + tmp0 := sym_re_DASH_pattern.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_doc, "Returns an instance of java.util.regex.Pattern, for use, e.g. in\n re-matcher.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4863), kw_end_DASH_line, int(4863))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp6 := reflect.TypeOf((*regexp15.Regexp)(nil)) + tmp7 := lang.Apply(tmp5, []any{tmp6, v3}) + if lang.IsTruthy(tmp7) { + tmp4 = v3 + } else { + tmp8 := lang.Apply(regexp15.MustCompile, []any{v3}) + tmp4 = tmp8 } + return tmp4 }) - tmp48.AddMethod(tmp50, tmp51) - tmp52 := reflect.TypeOf((*os6.File)(nil)) - var tmp53 lang.FnFunc - tmp53 = lang.NewFnFunc(func(args ...any) any { + tmp3 := reflect.TypeOf((*regexp15.Regexp)(nil)) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_re_DASH_pattern = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_re_DASH_pattern.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // read-string + { + tmp0 := sym_read_DASH_string.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s), lang.NewVector(sym_opts, sym_s)), kw_doc, "Reads one object from the string s. Optionally include reader\n options, as specified in read.\n\n Note that read-string can execute code (controlled by *read-eval*),\n and as such should be used only with trusted sources.\n\n For data structure interop use glojure.edn/read-string", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(3806), kw_end_DASH_line, int(3806))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(runtime.RTReadString, []any{v2}) + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := lang.Apply(runtime.RTReadString, []any{v3, v2}) + return tmp4 default: - checkArity(args, 1) - v54 := args[0] - _ = v54 - var v55 any = lang.NewList(args[1:]...) - _ = v55 - tmp56 := checkDerefVar(var_glojure_DOT_core_apply) - tmp57 := checkDerefVar(var_glojure_DOT_core_cons) - tmp58 := lang.Apply(tmp57, []any{v54, v55}) - tmp59 := lang.Apply(tmp56, []any{closed21, tmp58}) - return tmp59 + checkArity(args, -1) + panic("unreachable") } }) - tmp48.AddMethod(tmp52, tmp53) - tmp54 := reflect.TypeOf((*url5.URL)(nil)) - var tmp55 lang.FnFunc - tmp55 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 1) - v56 := args[0] - _ = v56 - var v57 any = lang.NewList(args[1:]...) - _ = v57 - tmp58 := checkDerefVar(var_glojure_DOT_core_apply) - tmp59 := checkDerefVar(var_glojure_DOT_core_cons) - tmp60 := lang.Apply(tmp59, []any{v56, v57}) - tmp61 := lang.Apply(tmp58, []any{closed22, tmp60}) - return tmp61 - } + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_read_DASH_string = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_read_DASH_string.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reader-conditional + { + tmp0 := sym_reader_DASH_conditional.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_form, sym_splicing_QMARK_)), kw_doc, "Construct a data representation of a reader conditional.\n If true, splicing? indicates read-cond-splicing.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(24), kw_column, int(7), kw_line, int(7782), kw_end_DASH_line, int(7782))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := lang.Apply(nil, []any{v2, v3}) + return tmp4 }) - tmp48.AddMethod(tmp54, tmp55) - tmp56 := reflect.TypeOf("") - var tmp57 lang.FnFunc - tmp57 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 1) - v58 := args[0] - _ = v58 - var v59 any = lang.NewList(args[1:]...) - _ = v59 - tmp60 := checkDerefVar(var_glojure_DOT_core_apply) - tmp61 := checkDerefVar(var_glojure_DOT_core_cons) - tmp62 := lang.Apply(tmp61, []any{v58, v59}) - tmp63 := lang.Apply(tmp60, []any{closed23, tmp62}) - return tmp63 - } + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_reader_DASH_conditional = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_reader_DASH_conditional.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reader-conditional? + { + tmp0 := sym_reader_DASH_conditional_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_value)), kw_doc, "Return true if the value is the data representation of a reader conditional", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(25), kw_column, int(7), kw_line, int(7776), kw_end_DASH_line, int(7776))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := lang.Apply(tmp3, []any{nil, v2}) + return tmp4 }) - tmp48.AddMethod(tmp56, tmp57) - var tmp59 lang.FnFunc - tmp59 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 1) - v60 := args[0] - _ = v60 - var v61 any = lang.NewList(args[1:]...) - _ = v61 - tmp62 := checkDerefVar(var_glojure_DOT_core_class) - tmp63 := lang.Apply(tmp62, []any{v60}) - return tmp63 + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_reader_DASH_conditional_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_reader_DASH_conditional_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // realized? + { + tmp0 := sym_realized_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if a value has been produced for a promise, delay, future or lazy sequence.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(7559), kw_end_DASH_line, int(7559))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "isRealized") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "isRealized"))) } - }) - tmp58 := lang.NewMultiFn("make-output-stream", tmp59, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) - tmp60 := reflect.TypeOf((*io4.Reader)(nil)).Elem() - var tmp61 lang.FnFunc - tmp61 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) default: - checkArity(args, 1) - v62 := args[0] - _ = v62 - var v63 any = lang.NewList(args[1:]...) - _ = v63 - tmp64 := checkDerefVar(var_glojure_DOT_core_apply) - tmp65 := checkDerefVar(var_glojure_DOT_core_cons) - tmp66 := lang.Apply(tmp65, []any{v62, v63}) - tmp67 := lang.Apply(tmp64, []any{closed24, tmp66}) - return tmp67 + tmp4 = tmp3 } + return tmp4 }) - tmp58.AddMethod(tmp60, tmp61) - tmp62 := reflect.TypeOf((*os6.File)(nil)) - var tmp63 lang.FnFunc - tmp63 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 1) - v64 := args[0] - _ = v64 - var v65 any = lang.NewList(args[1:]...) - _ = v65 - tmp66 := checkDerefVar(var_glojure_DOT_core_apply) - tmp67 := checkDerefVar(var_glojure_DOT_core_cons) - tmp68 := lang.Apply(tmp67, []any{v64, v65}) - tmp69 := lang.Apply(tmp66, []any{closed25, tmp68}) - return tmp69 - } + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_realized_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_realized_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reduced + { + tmp0 := sym_reduced.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Wraps x in a way such that a reduce will terminate with the value x", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(2828), kw_end_DASH_line, int(2828))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(lang.NewReduced, []any{v2}) + return tmp3 }) - tmp58.AddMethod(tmp62, tmp63) - tmp64 := reflect.TypeOf((*url5.URL)(nil)) - var tmp65 lang.FnFunc - tmp65 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 1) - v66 := args[0] - _ = v66 - var v67 any = lang.NewList(args[1:]...) - _ = v67 - tmp68 := checkDerefVar(var_glojure_DOT_core_apply) - tmp69 := checkDerefVar(var_glojure_DOT_core_cons) - tmp70 := lang.Apply(tmp69, []any{v66, v67}) - tmp71 := lang.Apply(tmp68, []any{closed26, tmp70}) - return tmp71 + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_reduced = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_reduced.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ref-history-count + { + tmp0 := sym_ref_DASH_history_DASH_count.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ref)), kw_doc, "Returns the history count of a ref", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(7), kw_line, int(2455), kw_end_DASH_line, int(2455))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "getHistoryCount") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getHistoryCount"))) } - }) - tmp58.AddMethod(tmp64, tmp65) - tmp66 := reflect.TypeOf("") - var tmp67 lang.FnFunc - tmp67 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) default: - checkArity(args, 1) - v68 := args[0] - _ = v68 - var v69 any = lang.NewList(args[1:]...) - _ = v69 - tmp70 := checkDerefVar(var_glojure_DOT_core_apply) - tmp71 := checkDerefVar(var_glojure_DOT_core_cons) - tmp72 := lang.Apply(tmp71, []any{v68, v69}) - tmp73 := lang.Apply(tmp70, []any{closed27, tmp72}) - return tmp73 + tmp4 = tmp3 } + return tmp4 }) - tmp58.AddMethod(tmp66, tmp67) - tmp31 := lang.NewAtom(lang.NewMap(kw_multis, lang.NewMap(kw_make_DASH_reader, tmp32, kw_make_DASH_writer, tmp40, kw_make_DASH_input_DASH_stream, tmp48, kw_make_DASH_output_DASH_stream, tmp58), kw_on_DASH_interface, true, kw_sigs, lang.NewList(lang.NewList(sym_make_DASH_reader, lang.NewVector(sym_x, sym_opts), "Creates an io.Reader. See also IOFactory docs."), lang.NewList(sym_make_DASH_writer, lang.NewVector(sym_x, sym_opts), "Creates an io.Reader. See also IOFactory docs."), lang.NewList(sym_make_DASH_input_DASH_stream, lang.NewVector(sym_x, sym_opts), "Creates a BufferedInputStream. See also IOFactory docs."), lang.NewList(sym_make_DASH_output_DASH_stream, lang.NewVector(sym_x, sym_opts), "Creates a BufferedOutputStream. See also IOFactory docs.")))) - tmp2 := lang.NewAtom(lang.NewMap(sym_CollReduce, tmp3, sym_InternalReduce, tmp13, sym_IKVReduce, tmp21, sym_Datafiable, tmp24, sym_Navigable, tmp28, sym_IOFactory, tmp31)) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ref_DASH_history_DASH_count = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_ref_DASH_history_DASH_count.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // .. + // ref-max-history { - tmp0 := sym__DOT__DOT_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_form), lang.NewVector(sym_x, sym_form, sym__AMP_, sym_more)), kw_doc, "form => fieldName-symbol or (instanceMethodName-symbol args*)\n\n Expands into a member access (.) of the first member on the first\n argument, followed by the next member on the result, etc. For\n instance:\n\n (.. System (getProperties) (get \"os.name\"))\n\n expands to:\n\n (. (. System (getProperties)) (get \"os.name\"))\n\n but is easier to write, read, and understand.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(11), kw_line, int(1657), kw_end_DASH_line, int(1657))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_ref_DASH_max_DASH_history.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ref), lang.NewVector(sym_ref, sym_n)), kw_doc, "Gets the max-history of a ref, or sets it and returns the ref", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(2471), kw_end_DASH_line, int(2471))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 4: - v3 := args[0] + case 1: + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "getMaxHistory") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getMaxHistory"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - tmp7 := checkDerefVar(var_glojure_DOT_core_seq) - tmp8 := checkDerefVar(var_glojure_DOT_core_concat) - tmp9 := checkDerefVar(var_glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) - tmp11 := checkDerefVar(var_glojure_DOT_core_list) - tmp12 := lang.Apply(tmp11, []any{v5}) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{v6}) - tmp15 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp14}) - tmp16 := lang.Apply(tmp7, []any{tmp15}) - return tmp16 + tmp4, _ := lang.FieldOrMethod(v2, "setMaxHistory") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMaxHistory is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 default: - checkArity(args, 4) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - var v7 any = lang.NewList(args[4:]...) - _ = v7 - tmp8 := checkDerefVar(var_glojure_DOT_core_seq) - tmp9 := checkDerefVar(var_glojure_DOT_core_concat) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym__DOT__DOT_}) - tmp12 := checkDerefVar(var_glojure_DOT_core_list) - tmp13 := checkDerefVar(var_glojure_DOT_core_seq) - tmp14 := checkDerefVar(var_glojure_DOT_core_concat) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) - tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{v5}) - tmp19 := checkDerefVar(var_glojure_DOT_core_list) - tmp20 := lang.Apply(tmp19, []any{v6}) - tmp21 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp20}) - tmp22 := lang.Apply(tmp13, []any{tmp21}) - tmp23 := lang.Apply(tmp12, []any{tmp22}) - tmp24 := lang.Apply(tmp9, []any{tmp11, tmp23, v7}) - tmp25 := lang.Apply(tmp8, []any{tmp24}) - return tmp25 + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ref_DASH_max_DASH_history = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_ref_DASH_max_DASH_history.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // / + // ref-min-history { + tmp0 := sym_ref_DASH_min_DASH_history.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ref), lang.NewVector(sym_ref, sym_n)), kw_doc, "Gets the min-history of a ref, or sets it and returns the ref", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(2462), kw_end_DASH_line, int(2462))).(*lang.Symbol) var tmp1 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v2 := args[0] _ = v2 - var tmp3 any - { // let - // let binding "op" - var tmp4 any - tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) - if lang.IsTruthy(tmp5) { - tmp4 = closed28 - } else { - tmp4 = closed28 - } - var v6 any = tmp4 - _ = v6 - tmp7 := checkDerefVar(var_glojure_DOT_core_seq) - tmp8 := checkDerefVar(var_glojure_DOT_core_concat) - tmp9 := checkDerefVar(var_glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) - tmp11 := checkDerefVar(var_glojure_DOT_core_list) - tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := checkDerefVar(var_glojure_DOT_core_seq) - tmp15 := checkDerefVar(var_glojure_DOT_core_concat) - tmp16 := checkDerefVar(var_glojure_DOT_core_list) - tmp17 := lang.Apply(tmp16, []any{v6}) - tmp18 := checkDerefVar(var_glojure_DOT_core_list) - tmp19 := lang.Apply(tmp18, []any{v2}) - tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) - tmp21 := lang.Apply(tmp14, []any{tmp20}) - tmp22 := lang.Apply(tmp13, []any{tmp21}) - tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) - tmp24 := lang.Apply(tmp7, []any{tmp23}) - tmp3 = tmp24 - } // end let - return tmp3 + tmp3, ok := lang.FieldOrMethod(v2, "getMinHistory") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getMinHistory"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 case 2: v2 := args[0] _ = v2 v3 := args[1] _ = v3 - var tmp4 any - { // let - // let binding "op" - var tmp5 any - tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) - if lang.IsTruthy(tmp6) { - tmp5 = closed28 - } else { - tmp5 = closed28 - } - var v7 any = tmp5 - _ = v7 - tmp8 := checkDerefVar(var_glojure_DOT_core_seq) - tmp9 := checkDerefVar(var_glojure_DOT_core_concat) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) - tmp12 := checkDerefVar(var_glojure_DOT_core_list) - tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := checkDerefVar(var_glojure_DOT_core_seq) - tmp16 := checkDerefVar(var_glojure_DOT_core_concat) - tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{v7}) - tmp19 := checkDerefVar(var_glojure_DOT_core_list) - tmp20 := lang.Apply(tmp19, []any{v2}) - tmp21 := checkDerefVar(var_glojure_DOT_core_list) - tmp22 := lang.Apply(tmp21, []any{v3}) - tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) - tmp24 := lang.Apply(tmp15, []any{tmp23}) - tmp25 := lang.Apply(tmp14, []any{tmp24}) - tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) - tmp27 := lang.Apply(tmp8, []any{tmp26}) - tmp4 = tmp27 - } // end let - return tmp4 - default: - checkArity(args, 2) - v2 := args[0] - _ = v2 - v3 := args[1] - _ = v3 - var v4 any = lang.NewList(args[2:]...) - _ = v4 - var tmp5 any - { // let - // let binding "op" - var tmp6 any - tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) - if lang.IsTruthy(tmp7) { - tmp6 = closed28 - } else { - tmp6 = closed28 - } - var v8 any = tmp6 - _ = v8 - tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) - var tmp10 lang.FnFunc - tmp10 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v11 := args[0] - _ = v11 - v12 := args[1] - _ = v12 - tmp13 := checkDerefVar(var_glojure_DOT_core_seq) - tmp14 := checkDerefVar(var_glojure_DOT_core_concat) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) - tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp19 := checkDerefVar(var_glojure_DOT_core_list) - tmp20 := checkDerefVar(var_glojure_DOT_core_seq) - tmp21 := checkDerefVar(var_glojure_DOT_core_concat) - tmp22 := checkDerefVar(var_glojure_DOT_core_list) - tmp23 := lang.Apply(tmp22, []any{v8}) - tmp24 := checkDerefVar(var_glojure_DOT_core_list) - tmp25 := lang.Apply(tmp24, []any{v11}) - tmp26 := checkDerefVar(var_glojure_DOT_core_list) - tmp27 := lang.Apply(tmp26, []any{v12}) - tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) - tmp29 := lang.Apply(tmp20, []any{tmp28}) - tmp30 := lang.Apply(tmp19, []any{tmp29}) - tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) - tmp32 := lang.Apply(tmp13, []any{tmp31}) - return tmp32 - }) - tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp13 := checkDerefVar(var_glojure_DOT_core_seq) - tmp14 := checkDerefVar(var_glojure_DOT_core_concat) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) - tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp19 := checkDerefVar(var_glojure_DOT_core_list) - tmp20 := checkDerefVar(var_glojure_DOT_core_seq) - tmp21 := checkDerefVar(var_glojure_DOT_core_concat) - tmp22 := checkDerefVar(var_glojure_DOT_core_list) - tmp23 := lang.Apply(tmp22, []any{v8}) - tmp24 := checkDerefVar(var_glojure_DOT_core_list) - tmp25 := lang.Apply(tmp24, []any{v2}) - tmp26 := checkDerefVar(var_glojure_DOT_core_list) - tmp27 := lang.Apply(tmp26, []any{v3}) - tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) - tmp29 := lang.Apply(tmp20, []any{tmp28}) - tmp30 := lang.Apply(tmp19, []any{tmp29}) - tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) - tmp32 := lang.Apply(tmp13, []any{tmp31}) - tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) - tmp5 = tmp33 - } // end let + tmp4, _ := lang.FieldOrMethod(v2, "setMinHistory") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMinHistory is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 + default: + checkArity(args, -1) + panic("unreachable") } }) - tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ref_DASH_min_DASH_history = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ref_DASH_min_DASH_history.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ref-set + { + tmp0 := sym_ref_DASH_set.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ref, sym_val)), kw_doc, "Must be called in a transaction. Sets the value of ref.\n Returns val.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(2447), kw_end_DASH_line, int(2447))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + tmp4, _ := lang.FieldOrMethod(v2, "set") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("set is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp0 := sym__SLASH_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "If no denominators are supplied, returns 1/numerator,\n else returns numerator divided by all of the denominators.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(7), kw_line, int(1013), kw_end_DASH_line, int(1013))).(*lang.Symbol) - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v5 := args[0] - _ = v5 - tmp6 := checkDerefVar(var_glojure_DOT_core__SLASH_) - tmp7 := lang.Apply(tmp6, []any{int64(1), v5}) - return tmp7 - case 2: - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - tmp7, _ := lang.FieldOrMethod(lang.Numbers, "Divide") - if reflect.TypeOf(tmp7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Divide is not a function"))) - } - tmp8 := lang.Apply(tmp7, []any{v5, v6}) - return tmp8 + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ref_DASH_set = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ref_DASH_set.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // release-pending-sends + { + tmp0 := sym_release_DASH_pending_DASH_sends.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Normally, actions sent directly or indirectly during another action\n are held until the action completes (changes the agent's\n state). This function can be used to dispatch any pending sent\n actions immediately. This has no impact on actions sent during a\n transaction, which are still held until commit. If no action is\n occurring, does nothing. Returns the number of actions dispatched.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(27), kw_column, int(7), kw_line, int(2131), kw_end_DASH_line, int(2131))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp2 := lang.Apply(nil, nil) + return tmp2 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_release_DASH_pending_DASH_sends = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_release_DASH_pending_DASH_sends.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // remove-all-methods + { + tmp0 := sym_remove_DASH_all_DASH_methods.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_multifn)), kw_doc, "Removes all of the methods of multimethod.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(24), kw_column, int(7), kw_line, int(1787), kw_end_DASH_line, int(1787))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "reset") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "reset"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) default: - checkArity(args, 2) - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - var v7 any = lang.NewList(args[2:]...) - _ = v7 - tmp8 := checkDerefVar(var_glojure_DOT_core_reduce1) - tmp9 := checkDerefVar(var_glojure_DOT_core__SLASH_) - tmp10 := checkDerefVar(var_glojure_DOT_core__SLASH_) - tmp11 := lang.Apply(tmp10, []any{v5, v6}) - tmp12 := lang.Apply(tmp8, []any{tmp9, tmp11, v7}) - return tmp12 + tmp4 = tmp3 } + return tmp4 }) - tmp4 = tmp4.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp3 := ns.InternWithValue(tmp0, tmp4, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_remove_DASH_all_DASH_methods = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_remove_DASH_all_DASH_methods.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // < + // remove-method { + tmp0 := sym_remove_DASH_method.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_multifn, sym_dispatch_DASH_val)), kw_doc, "Removes the method of multimethod associated with dispatch-value.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(1794), kw_end_DASH_line, int(1794))).(*lang.Symbol) var tmp1 lang.FnFunc - { // function <__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_seq) - tmp6 := checkDerefVar(var_glojure_DOT_core_concat) - tmp7 := checkDerefVar(var_glojure_DOT_core_list) - tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) - tmp9 := checkDerefVar(var_glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp11 := checkDerefVar(var_glojure_DOT_core_list) - tmp12 := checkDerefVar(var_glojure_DOT_core_seq) - tmp13 := checkDerefVar(var_glojure_DOT_core_concat) - tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Lt}) - tmp16 := checkDerefVar(var_glojure_DOT_core_list) - tmp17 := lang.Apply(tmp16, []any{v3}) - tmp18 := checkDerefVar(var_glojure_DOT_core_list) - tmp19 := lang.Apply(tmp18, []any{v4}) - tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) - tmp21 := lang.Apply(tmp12, []any{tmp20}) - tmp22 := lang.Apply(tmp11, []any{tmp21}) - tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) - tmp24 := lang.Apply(tmp5, []any{tmp23}) - return tmp24 - }) - v2 = tmp1 + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "removeMethod") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("removeMethod is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_remove_DASH_method = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_remove_DASH_method.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // remove-ns + { + tmp0 := sym_remove_DASH_ns.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_sym)), kw_doc, "Removes the namespace named by the symbol. Use with caution.\n Cannot be used to remove the glojure namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(4139), kw_end_DASH_line, int(4139))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] _ = v2 + tmp3 := lang.Apply(lang.RemoveNamespace, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_remove_DASH_ns = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_remove_DASH_ns.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } - tmp0 := sym__LT_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns non-nil if nums are in monotonically increasing order,\n otherwise false.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(7), kw_line, int(893), kw_end_DASH_line, int(893))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { + } + // remove-watch + { + tmp0 := sym_remove_DASH_watch.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_reference, sym_key)), kw_doc, "Removes a watch (set by add-watch) from a reference", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(2160), kw_end_DASH_line, int(2160))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "removeWatch") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("removeWatch is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_remove_DASH_watch = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_remove_DASH_watch.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // repeat + { + tmp0 := sym_repeat.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_n, sym_x)), kw_doc, "Returns a lazy (infinite!, or length n if supplied) sequence of xs.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(2997), kw_end_DASH_line, int(2997))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: - v4 := args[0] - _ = v4 - return true + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(lang.NewRepeat, []any{v2}) + return tmp3 case 2: - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Lt") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Lt is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := lang.Apply(lang.NewRepeatN, []any{v2, v3}) + return tmp4 default: - checkArity(args, 2) + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_repeat = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_repeat.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reset! + { + tmp0 := sym_reset_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_atom, sym_newval)), kw_doc, "Sets the value of atom to newval without regard for the\n current value. Returns newval.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(2368), kw_end_DASH_line, int(2368))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "reset") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_reset_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_reset_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reset-meta! + { + tmp0 := sym_reset_DASH_meta_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_iref, sym_metadata_DASH_map)), kw_doc, "Atomically resets the metadata for a namespace/var/ref/agent/atom", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(2408), kw_end_DASH_line, int(2408))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "ResetMeta") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ResetMeta is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_reset_DASH_meta_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_reset_DASH_meta_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reset-vals! + { + tmp0 := sym_reset_DASH_vals_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_atom, sym_newval)), kw_doc, "Sets the value of atom to newval. Returns [old new], the value of the\n atom before and after the reset.", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(2375), kw_end_DASH_line, int(2375))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "resetVals") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("resetVals is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_reset_DASH_vals_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_reset_DASH_vals_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // rest + { + tmp1 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() + tmp0 := sym_rest.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a possibly empty seq of the items after the first. Calls seq on its\n argument.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(5), kw_column, int(2), kw_line, int(64), kw_end_DASH_line, int(70))).(*lang.Symbol) + var tmp2 lang.FnFunc + { // function rest + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) v4 := args[0] _ = v4 - v5 := args[1] - _ = v5 - var v6 any = lang.NewList(args[2:]...) - _ = v6 - recur_loop_150: - var tmp7 any - tmp8 := checkDerefVar(var_glojure_DOT_core__LT_) - tmp9 := lang.Apply(tmp8, []any{v4, v5}) - if lang.IsTruthy(tmp9) { - var tmp10 any - tmp11 := checkDerefVar(var_glojure_DOT_core_next) - tmp12 := lang.Apply(tmp11, []any{v6}) - if lang.IsTruthy(tmp12) { - var tmp13 any = v5 - tmp15 := checkDerefVar(var_glojure_DOT_core_first) - tmp16 := lang.Apply(tmp15, []any{v6}) - var tmp14 any = tmp16 - tmp18 := checkDerefVar(var_glojure_DOT_core_next) - tmp19 := lang.Apply(tmp18, []any{v6}) - var tmp17 any = tmp19 - v4 = tmp13 - v5 = tmp14 - v6 = tmp17 - goto recur_loop_150 - } else { - tmp20 := checkDerefVar(var_glojure_DOT_core__LT_) - tmp21 := checkDerefVar(var_glojure_DOT_core_first) - tmp22 := lang.Apply(tmp21, []any{v6}) - tmp23 := lang.Apply(tmp20, []any{v5, tmp22}) - tmp10 = tmp23 - } - tmp7 = tmp10 - } else { - tmp7 = false - } - return tmp7 + tmp5 := lang.Apply(lang.Rest, []any{v4}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(70), kw_column, int(7), kw_end_DASH_line, int(70), kw_end_DASH_column, int(77))).(lang.FnFunc) + v3 = tmp2 + _ = v3 + } + var_glojure_DOT_core_rest = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_rest.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reversible? + { + tmp0 := sym_reversible_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns true if coll implements Reversible", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(6257), kw_end_DASH_line, int(6257))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := lang.Apply(tmp3, []any{nil, v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_reversible_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_reversible_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // rseq + { + tmp0 := sym_rseq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_rev)), kw_doc, "Returns, in constant time, a seq of the items in rev (which\n can be a vector or sorted-map), in reverse order. If rev is empty returns nil", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1577), kw_end_DASH_line, int(1577))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(v2, "rseq") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("rseq is not a function"))) } + tmp4 := lang.Apply(tmp3, []any{}) + return tmp4 }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_rseq = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_rseq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // <= + // second { + tmp0 := sym_second.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Same as (first (next x))", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(2), kw_line, int(91), kw_end_DASH_line, int(95))).(*lang.Symbol) var tmp1 lang.FnFunc - { // function <=__inliner + { // function second var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) + checkArity(args, 1) v3 := args[0] _ = v3 - v4 := args[1] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_seq) - tmp6 := checkDerefVar(var_glojure_DOT_core_concat) - tmp7 := checkDerefVar(var_glojure_DOT_core_list) - tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) - tmp9 := checkDerefVar(var_glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp11 := checkDerefVar(var_glojure_DOT_core_list) - tmp12 := checkDerefVar(var_glojure_DOT_core_seq) - tmp13 := checkDerefVar(var_glojure_DOT_core_concat) - tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Lte}) - tmp16 := checkDerefVar(var_glojure_DOT_core_list) - tmp17 := lang.Apply(tmp16, []any{v3}) - tmp18 := checkDerefVar(var_glojure_DOT_core_list) - tmp19 := lang.Apply(tmp18, []any{v4}) - tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) - tmp21 := lang.Apply(tmp12, []any{tmp20}) - tmp22 := lang.Apply(tmp11, []any{tmp21}) - tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) - tmp24 := lang.Apply(tmp5, []any{tmp23}) - return tmp24 + tmp4 := checkDerefVar(var_glojure_DOT_core_first) + tmp5 := checkDerefVar(var_glojure_DOT_core_next) + tmp6 := lang.Apply(tmp5, []any{v3}) + tmp7 := lang.Apply(tmp4, []any{tmp6}) + return tmp7 }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(95), kw_column, int(9), kw_end_DASH_line, int(95), kw_end_DASH_column, int(49))).(lang.FnFunc) v2 = tmp1 _ = v2 } - tmp0 := sym__LT__EQ_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns non-nil if nums are in monotonically non-decreasing order,\n otherwise false.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(7), kw_line, int(1048), kw_end_DASH_line, int(1048))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v4 := args[0] - _ = v4 - return true - case 2: - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Lte") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Lte is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 - default: - checkArity(args, 2) + var_glojure_DOT_core_second = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_second.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // seq + { + tmp1 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() + tmp0 := sym_seq.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a seq on the collection. If the collection is\n empty, returns nil. (seq nil) returns nil. seq also works on\n Strings, native Java arrays (of reference types) and any objects\n that implement Iterable. Note that seqs cache values, thus seq\n should not be used on any Iterable whose iterator repeatedly\n returns the same mutable object.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(4), kw_column, int(2), kw_line, int(126), kw_end_DASH_line, int(136))).(*lang.Symbol) + var tmp2 lang.FnFunc + { // function seq + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) v4 := args[0] _ = v4 - v5 := args[1] - _ = v5 - var v6 any = lang.NewList(args[2:]...) - _ = v6 - recur_loop_194: - var tmp7 any - tmp8 := checkDerefVar(var_glojure_DOT_core__LT__EQ_) - tmp9 := lang.Apply(tmp8, []any{v4, v5}) - if lang.IsTruthy(tmp9) { - var tmp10 any - tmp11 := checkDerefVar(var_glojure_DOT_core_next) - tmp12 := lang.Apply(tmp11, []any{v6}) - if lang.IsTruthy(tmp12) { - var tmp13 any = v5 - tmp15 := checkDerefVar(var_glojure_DOT_core_first) - tmp16 := lang.Apply(tmp15, []any{v6}) - var tmp14 any = tmp16 - tmp18 := checkDerefVar(var_glojure_DOT_core_next) - tmp19 := lang.Apply(tmp18, []any{v6}) - var tmp17 any = tmp19 - v4 = tmp13 - v5 = tmp14 - v6 = tmp17 - goto recur_loop_194 - } else { - tmp20 := checkDerefVar(var_glojure_DOT_core__LT__EQ_) - tmp21 := checkDerefVar(var_glojure_DOT_core_first) - tmp22 := lang.Apply(tmp21, []any{v6}) - tmp23 := lang.Apply(tmp20, []any{v5, tmp22}) - tmp10 = tmp23 - } - tmp7 = tmp10 - } else { - tmp7 = false - } - return tmp7 - } - }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp5 := lang.Apply(lang.Seq, []any{v4}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(136), kw_column, int(6), kw_end_DASH_line, int(136), kw_end_DASH_column, int(126))).(lang.FnFunc) + v3 = tmp2 + _ = v3 + } + var_glojure_DOT_core_seq = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_seq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // = + // seq? { + tmp0 := sym_seq_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x implements ISeq", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(5), kw_column, int(2), kw_line, int(146), kw_end_DASH_line, int(150))).(*lang.Symbol) var tmp1 lang.FnFunc - { // function =__inliner + { // function seq? var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) + checkArity(args, 1) v3 := args[0] _ = v3 - v4 := args[1] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_seq) - tmp6 := checkDerefVar(var_glojure_DOT_core_concat) - tmp7 := checkDerefVar(var_glojure_DOT_core_list) - tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) - tmp9 := checkDerefVar(var_glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_lang_DOT_Util}) - tmp11 := checkDerefVar(var_glojure_DOT_core_list) - tmp12 := lang.Apply(tmp11, []any{sym_glojure_DOT_core_SLASH_equiv}) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{v3}) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{v4}) - tmp17 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp12, tmp14, tmp16}) - tmp18 := lang.Apply(tmp5, []any{tmp17}) - return tmp18 + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() + tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) + return tmp6 }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(150), kw_column, int(7), kw_end_DASH_line, int(150), kw_end_DASH_column, int(87))).(lang.FnFunc) v2 = tmp1 _ = v2 } - tmp0 := sym__EQ_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Equality. Returns true if x equals y, false if not. Same as\n Java x.equals(y) except it also works for nil, and compares\n numbers and collections in a type-independent manner. Clojure's immutable data\n structures define equals() (and thus =) as a value, not an identity,\n comparison.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(7), kw_line, int(776), kw_end_DASH_line, int(776))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v4 := args[0] - _ = v4 - return true - case 2: - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6 := lang.Apply(lang.Equiv, []any{v4, v5}) - return tmp6 - default: - checkArity(args, 2) - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - var v6 any = lang.NewList(args[2:]...) - _ = v6 - recur_loop_126: - var tmp7 any - tmp8 := lang.Apply(lang.Equiv, []any{v4, v5}) - if lang.IsTruthy(tmp8) { - var tmp9 any - tmp10 := checkDerefVar(var_glojure_DOT_core_next) - tmp11 := lang.Apply(tmp10, []any{v6}) - if lang.IsTruthy(tmp11) { - var tmp12 any = v5 - tmp14 := checkDerefVar(var_glojure_DOT_core_first) - tmp15 := lang.Apply(tmp14, []any{v6}) - var tmp13 any = tmp15 - tmp17 := checkDerefVar(var_glojure_DOT_core_next) - tmp18 := lang.Apply(tmp17, []any{v6}) - var tmp16 any = tmp18 - v4 = tmp12 - v5 = tmp13 - v6 = tmp16 - goto recur_loop_126 - } else { - tmp19 := checkDerefVar(var_glojure_DOT_core_first) - tmp20 := lang.Apply(tmp19, []any{v6}) - tmp21 := lang.Apply(lang.Equiv, []any{v5, tmp20}) - tmp9 = tmp21 - } - tmp7 = tmp9 - } else { - tmp7 = false - } - return tmp7 - } + var_glojure_DOT_core_seq_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_seq_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // seqable? + { + tmp0 := sym_seqable_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if the seq function is supported for x", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(6204), kw_end_DASH_line, int(6204))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(nil, []any{v2}) + return tmp3 }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_seqable_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_seqable_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // == + // sequential? { + tmp0 := sym_sequential_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns true if coll implements Sequential", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(6229), kw_end_DASH_line, int(6229))).(*lang.Symbol) var tmp1 lang.FnFunc - { // function ==__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_seq) - tmp6 := checkDerefVar(var_glojure_DOT_core_concat) - tmp7 := checkDerefVar(var_glojure_DOT_core_list) - tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) - tmp9 := checkDerefVar(var_glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp11 := checkDerefVar(var_glojure_DOT_core_list) - tmp12 := checkDerefVar(var_glojure_DOT_core_seq) - tmp13 := checkDerefVar(var_glojure_DOT_core_concat) - tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Equiv}) - tmp16 := checkDerefVar(var_glojure_DOT_core_list) - tmp17 := lang.Apply(tmp16, []any{v3}) - tmp18 := checkDerefVar(var_glojure_DOT_core_list) - tmp19 := lang.Apply(tmp18, []any{v4}) - tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) - tmp21 := lang.Apply(tmp12, []any{tmp20}) - tmp22 := lang.Apply(tmp11, []any{tmp21}) - tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) - tmp24 := lang.Apply(tmp5, []any{tmp23}) - return tmp24 - }) - v2 = tmp1 + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*lang.Sequential)(nil)).Elem() + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_sequential_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_sequential_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } - tmp0 := sym__EQ__EQ_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns non-nil if nums all have the equivalent\n value (type-independent), otherwise false", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(7), kw_line, int(1093), kw_end_DASH_line, int(1093))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v4 := args[0] - _ = v4 - return true - case 2: - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Equiv") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Equiv is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 - default: - checkArity(args, 2) - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - var v6 any = lang.NewList(args[2:]...) - _ = v6 - recur_loop_206: - var tmp7 any - tmp8 := checkDerefVar(var_glojure_DOT_core__EQ__EQ_) - tmp9 := lang.Apply(tmp8, []any{v4, v5}) - if lang.IsTruthy(tmp9) { - var tmp10 any - tmp11 := checkDerefVar(var_glojure_DOT_core_next) - tmp12 := lang.Apply(tmp11, []any{v6}) - if lang.IsTruthy(tmp12) { - var tmp13 any = v5 - tmp15 := checkDerefVar(var_glojure_DOT_core_first) - tmp16 := lang.Apply(tmp15, []any{v6}) - var tmp14 any = tmp16 - tmp18 := checkDerefVar(var_glojure_DOT_core_next) - tmp19 := lang.Apply(tmp18, []any{v6}) - var tmp17 any = tmp19 - v4 = tmp13 - v5 = tmp14 - v6 = tmp17 - goto recur_loop_206 - } else { - tmp20 := checkDerefVar(var_glojure_DOT_core__EQ__EQ_) - tmp21 := checkDerefVar(var_glojure_DOT_core_first) - tmp22 := lang.Apply(tmp21, []any{v6}) - tmp23 := lang.Apply(tmp20, []any{v5, tmp22}) - tmp10 = tmp23 - } - tmp7 = tmp10 - } else { - tmp7 = false - } - return tmp7 - } + } + // set-agent-send-executor! + { + tmp0 := sym_set_DASH_agent_DASH_send_DASH_executor_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_executor)), kw_doc, "Sets the ExecutorService to be used by send", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(30), kw_column, int(7), kw_line, int(2087), kw_end_DASH_line, int(2087))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + return nil }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_set_DASH_agent_DASH_send_DASH_executor_BANG_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_set_DASH_agent_DASH_send_DASH_executor_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // > + // set-agent-send-off-executor! { + tmp0 := sym_set_DASH_agent_DASH_send_DASH_off_DASH_executor_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_executor)), kw_doc, "Sets the ExecutorService to be used by send-off", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(34), kw_column, int(7), kw_line, int(2093), kw_end_DASH_line, int(2093))).(*lang.Symbol) var tmp1 lang.FnFunc - { // function >__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_seq) - tmp6 := checkDerefVar(var_glojure_DOT_core_concat) - tmp7 := checkDerefVar(var_glojure_DOT_core_list) - tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) - tmp9 := checkDerefVar(var_glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp11 := checkDerefVar(var_glojure_DOT_core_list) - tmp12 := checkDerefVar(var_glojure_DOT_core_seq) - tmp13 := checkDerefVar(var_glojure_DOT_core_concat) - tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Gt}) - tmp16 := checkDerefVar(var_glojure_DOT_core_list) - tmp17 := lang.Apply(tmp16, []any{v3}) - tmp18 := checkDerefVar(var_glojure_DOT_core_list) - tmp19 := lang.Apply(tmp18, []any{v4}) - tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) - tmp21 := lang.Apply(tmp12, []any{tmp20}) - tmp22 := lang.Apply(tmp11, []any{tmp21}) - tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) - tmp24 := lang.Apply(tmp5, []any{tmp23}) - return tmp24 - }) - v2 = tmp1 + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] _ = v2 + return nil + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_set_DASH_agent_DASH_send_DASH_off_DASH_executor_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_set_DASH_agent_DASH_send_DASH_off_DASH_executor_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } - tmp0 := sym__GT_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns non-nil if nums are in monotonically decreasing order,\n otherwise false.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(7), kw_line, int(1063), kw_end_DASH_line, int(1063))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v4 := args[0] - _ = v4 - return true - case 2: - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Gt") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 - default: - checkArity(args, 2) - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - var v6 any = lang.NewList(args[2:]...) - _ = v6 - recur_loop_198: - var tmp7 any - tmp8 := checkDerefVar(var_glojure_DOT_core__GT_) - tmp9 := lang.Apply(tmp8, []any{v4, v5}) - if lang.IsTruthy(tmp9) { - var tmp10 any - tmp11 := checkDerefVar(var_glojure_DOT_core_next) - tmp12 := lang.Apply(tmp11, []any{v6}) - if lang.IsTruthy(tmp12) { - var tmp13 any = v5 - tmp15 := checkDerefVar(var_glojure_DOT_core_first) - tmp16 := lang.Apply(tmp15, []any{v6}) - var tmp14 any = tmp16 - tmp18 := checkDerefVar(var_glojure_DOT_core_next) - tmp19 := lang.Apply(tmp18, []any{v6}) - var tmp17 any = tmp19 - v4 = tmp13 - v5 = tmp14 - v6 = tmp17 - goto recur_loop_198 - } else { - tmp20 := checkDerefVar(var_glojure_DOT_core__GT_) - tmp21 := checkDerefVar(var_glojure_DOT_core_first) - tmp22 := lang.Apply(tmp21, []any{v6}) - tmp23 := lang.Apply(tmp20, []any{v5, tmp22}) - tmp10 = tmp23 - } - tmp7 = tmp10 - } else { - tmp7 = false - } - return tmp7 + } + // set-error-handler! + { + tmp0 := sym_set_DASH_error_DASH_handler_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a, sym_handler_DASH_fn)), kw_doc, "Sets the error-handler of agent a to handler-fn. If an action\n being run by the agent throws an exception or doesn't pass the\n validator fn, handler-fn will be called with two arguments: the\n agent and the exception.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(24), kw_column, int(7), kw_line, int(2192), kw_end_DASH_line, int(2192))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "setErrorHandler") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorHandler is not a function"))) } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_set_DASH_error_DASH_handler_BANG_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_set_DASH_error_DASH_handler_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // >0? + // set-error-mode! { - tmp0 := sym__GT_0_QMARK_.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(963), kw_column, int(7), kw_end_DASH_line, int(963), kw_end_DASH_column, int(19), kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] + tmp0 := sym_set_DASH_error_DASH_mode_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a, sym_mode_DASH_keyword)), kw_doc, "Sets the error-mode of agent a to mode-keyword, which must be\n either :fail or :continue. If an action being run by the agent\n throws an exception or doesn't pass the validator fn, an\n error-handler may be called (see set-error-handler!), after which,\n if the mode is :continue, the agent will continue as if neither the\n action that caused the error nor the error itself ever happened.\n \n If the mode is :fail, the agent will become failed and will stop\n accepting new 'send' and 'send-off' actions, and any previously\n queued actions will be held until a 'restart-agent'. Deref will\n still work, returning the state of the agent before the error.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(2210), kw_end_DASH_line, int(2210))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + tmp4, _ := lang.FieldOrMethod(v2, "setErrorMode") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorMode is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(0)}) + tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_set_DASH_error_DASH_mode_BANG_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_set_DASH_error_DASH_mode_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // >1? + // set-validator! { - tmp0 := sym__GT_1_QMARK_.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(962), kw_column, int(7), kw_end_DASH_line, int(962), kw_end_DASH_column, int(19), kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] + tmp0 := sym_set_DASH_validator_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_iref, sym_validator_DASH_fn)), kw_doc, "Sets the validator-fn for a var/ref/agent/atom. validator-fn must be nil or a\n side-effect-free fn of one argument, which will be passed the intended\n new state on any state change. If the new state is unacceptable, the\n validator-fn should return false or throw an exception. If the current state (root\n value if var) is not acceptable to the new validator, an exception\n will be thrown and the validator will not be changed.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(2381), kw_end_DASH_line, int(2381))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + tmp4, _ := lang.FieldOrMethod(v2, "setValidator") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setValidator is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_set_DASH_validator_BANG_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_set_DASH_validator_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // >= + // set? { + tmp0 := sym_set_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x implements IPersistentSet", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(4098), kw_end_DASH_line, int(4098))).(*lang.Symbol) var tmp1 lang.FnFunc - { // function >=__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_seq) - tmp6 := checkDerefVar(var_glojure_DOT_core_concat) - tmp7 := checkDerefVar(var_glojure_DOT_core_list) - tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) - tmp9 := checkDerefVar(var_glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp11 := checkDerefVar(var_glojure_DOT_core_list) - tmp12 := checkDerefVar(var_glojure_DOT_core_seq) - tmp13 := checkDerefVar(var_glojure_DOT_core_concat) - tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Gte}) - tmp16 := checkDerefVar(var_glojure_DOT_core_list) - tmp17 := lang.Apply(tmp16, []any{v3}) - tmp18 := checkDerefVar(var_glojure_DOT_core_list) - tmp19 := lang.Apply(tmp18, []any{v4}) - tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) - tmp21 := lang.Apply(tmp12, []any{tmp20}) - tmp22 := lang.Apply(tmp11, []any{tmp21}) - tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) - tmp24 := lang.Apply(tmp5, []any{tmp23}) - return tmp24 - }) - v2 = tmp1 + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*lang.IPersistentSet)(nil)).Elem() + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_set_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_set_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } - tmp0 := sym__GT__EQ_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns non-nil if nums are in monotonically non-increasing order,\n otherwise false.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(7), kw_line, int(1078), kw_end_DASH_line, int(1078))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v4 := args[0] - _ = v4 - return true - case 2: - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Gte") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gte is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 - default: - checkArity(args, 2) - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - var v6 any = lang.NewList(args[2:]...) + } + // shutdown-agents + { + tmp0 := sym_shutdown_DASH_agents.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Initiates a shutdown of the thread pools that back the agent\n system. Running actions will complete, but no new actions will be\n accepted", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(2252), kw_end_DASH_line, int(2252))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp2 := lang.Apply(lang.ShutdownAgents, nil) + return tmp2 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_shutdown_DASH_agents = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_shutdown_DASH_agents.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // simple-keyword? + { + tmp0 := sym_simple_DASH_keyword_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a keyword without a namespace", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(1633), kw_end_DASH_line, int(1633))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "and__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 _ = v6 - recur_loop_202: var tmp7 any - tmp8 := checkDerefVar(var_glojure_DOT_core__GT__EQ_) - tmp9 := lang.Apply(tmp8, []any{v4, v5}) - if lang.IsTruthy(tmp9) { - var tmp10 any - tmp11 := checkDerefVar(var_glojure_DOT_core_next) - tmp12 := lang.Apply(tmp11, []any{v6}) - if lang.IsTruthy(tmp12) { - var tmp13 any = v5 - tmp15 := checkDerefVar(var_glojure_DOT_core_first) - tmp16 := lang.Apply(tmp15, []any{v6}) - var tmp14 any = tmp16 - tmp18 := checkDerefVar(var_glojure_DOT_core_next) - tmp19 := lang.Apply(tmp18, []any{v6}) - var tmp17 any = tmp19 - v4 = tmp13 - v5 = tmp14 - v6 = tmp17 - goto recur_loop_202 - } else { - tmp20 := checkDerefVar(var_glojure_DOT_core__GT__EQ_) - tmp21 := checkDerefVar(var_glojure_DOT_core_first) - tmp22 := lang.Apply(tmp21, []any{v6}) - tmp23 := lang.Apply(tmp20, []any{v5, tmp22}) - tmp10 = tmp23 - } - tmp7 = tmp10 + if lang.IsTruthy(v6) { + tmp8 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp9 := checkDerefVar(var_glojure_DOT_core_namespace) + tmp10 := lang.Apply(tmp9, []any{v2}) + tmp11 := lang.Apply(tmp8, []any{tmp10}) + tmp7 = tmp11 } else { - tmp7 = false + tmp7 = v6 } - return tmp7 - } + tmp3 = tmp7 + } // end let + return tmp3 }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_simple_DASH_keyword_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_simple_DASH_keyword_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // NaN? + // some { + tmp0 := sym_some.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns the first logical true value of (pred x) for any x in coll,\n else nil. One common idiom is to use a set as pred, for example\n this will return :fred if :fred is in the sequence, otherwise nil:\n (some #{:fred} coll)", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(2684), kw_end_DASH_line, int(2684))).(*lang.Symbol) var tmp1 lang.FnFunc - { // function NaN?__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_seq) - tmp5 := checkDerefVar(var_glojure_DOT_core_concat) - tmp6 := checkDerefVar(var_glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{sym_math_DOT_IsNaN}) - tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{v3}) - tmp10 := lang.Apply(tmp5, []any{tmp7, tmp9}) - tmp11 := lang.Apply(tmp4, []any{tmp10}) - return tmp11 - }) - v2 = tmp1 + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] _ = v2 - } - tmp0 := sym_NaN_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_num)), kw_inline, tmp1, kw_doc, "Returns true if num is NaN, else false", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1)})), kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(7968), kw_end_DASH_line, int(7968))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5 := lang.Apply(math7.IsNaN, []any{v4}) - return tmp5 + v3 := args[1] + _ = v3 + recur_loop_481: + var tmp4 any + { // let + // let binding "temp__0__auto__" + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := lang.Apply(tmp5, []any{v3}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + if lang.IsTruthy(v7) { + var tmp9 any + { // let + // let binding "s" + var v10 any = v7 + _ = v10 + var tmp11 any + { // let + // let binding "or__0__auto__" + tmp12 := checkDerefVar(var_glojure_DOT_core_first) + tmp13 := lang.Apply(tmp12, []any{v10}) + tmp14 := lang.Apply(v2, []any{tmp13}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + if lang.IsTruthy(v15) { + tmp16 = v15 + } else { + var tmp17 any = v2 + tmp19 := checkDerefVar(var_glojure_DOT_core_next) + tmp20 := lang.Apply(tmp19, []any{v10}) + var tmp18 any = tmp20 + v2 = tmp17 + v3 = tmp18 + goto recur_loop_481 + } + tmp11 = tmp16 + } // end let + tmp9 = tmp11 + } // end let + tmp8 = tmp9 + } else { + } + tmp4 = tmp8 + } // end let + return tmp4 }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_some = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_some.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // StackTraceElement->vec + // some? { - tmp0 := sym_StackTraceElement_DASH__GT_vec.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_o)), kw_doc, "Constructs a data representation for a StackTraceElement: [class method file line]", kw_file, "glojure/core_print.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(28), kw_column, int(7), kw_line, int(436), kw_end_DASH_line, int(436))).(*lang.Symbol) + tmp1 := reflect.TypeOf(false) + tmp0 := sym_some_QMARK_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x is not nil, false otherwise.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.6", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(530), kw_end_DASH_line, int(530))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_symbol) - tmp5, ok := lang.FieldOrMethod(v3, "getClassName") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getClassName"))) - } - var tmp6 any - switch reflect.TypeOf(tmp5).Kind() { - case reflect.Func: - tmp6 = lang.Apply(tmp5, nil) - default: - tmp6 = tmp5 - } + tmp4 := checkDerefVar(var_glojure_DOT_core_not) + tmp5 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) tmp7 := lang.Apply(tmp4, []any{tmp6}) - tmp8 := checkDerefVar(var_glojure_DOT_core_symbol) - tmp9, ok := lang.FieldOrMethod(v3, "getMethodName") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getMethodName"))) - } - var tmp10 any - switch reflect.TypeOf(tmp9).Kind() { - case reflect.Func: - tmp10 = lang.Apply(tmp9, nil) - default: - tmp10 = tmp9 - } - tmp11 := lang.Apply(tmp8, []any{tmp10}) - tmp12, ok := lang.FieldOrMethod(v3, "getFileName") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getFileName"))) - } - var tmp13 any - switch reflect.TypeOf(tmp12).Kind() { - case reflect.Func: - tmp13 = lang.Apply(tmp12, nil) - default: - tmp13 = tmp12 - } - tmp14, ok := lang.FieldOrMethod(v3, "getLineNumber") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getLineNumber"))) - } - var tmp15 any - switch reflect.TypeOf(tmp14).Kind() { - case reflect.Func: - tmp15 = lang.Apply(tmp14, nil) - default: - tmp15 = tmp14 - } - tmp16 := lang.NewVector(tmp7, tmp11, tmp13, tmp15) - tmp17 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(440), kw_column, int(3), kw_end_DASH_line, int(440), kw_end_DASH_column, int(94)) - tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp18 + return tmp7 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp3 := reflect.TypeOf(false) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_some_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_some_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // Throwable->map + // sorted-map { - tmp0 := sym_Throwable_DASH__GT_map.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_o)), kw_doc, "Constructs a data representation for a Throwable with keys:\n :cause - root cause message\n :phase - error phase\n :via - cause chain, with cause keys:\n :type - exception class symbol\n :message - exception message\n :data - ex-data\n :at - top stack element\n :trace - root cause stack elements", kw_file, "glojure/core_print.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(442), kw_end_DASH_line, int(442))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "base" - var tmp5 lang.FnFunc - tmp5 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v6 := args[0] - _ = v6 - tmp7 := checkDerefVar(var_glojure_DOT_core_merge) - tmp8 := checkDerefVar(var_glojure_DOT_core_symbol) - tmp9 := checkDerefVar(var_glojure_DOT_core_class) - tmp10 := lang.Apply(tmp9, []any{v6}) - tmp11, ok := lang.FieldOrMethod(tmp10, "Name") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp10, "Name"))) - } - var tmp12 any - switch reflect.TypeOf(tmp11).Kind() { - case reflect.Func: - tmp12 = lang.Apply(tmp11, nil) - default: - tmp12 = tmp11 - } - tmp13 := lang.Apply(tmp8, []any{tmp12}) - tmp14 := lang.NewMap(kw_type, tmp13) - tmp15 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(455), kw_column, int(23), kw_end_DASH_line, int(455), kw_end_DASH_column, int(56)) - tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var tmp17 any - { // let - // let binding "temp__0__auto__" - tmp18, ok := lang.FieldOrMethod(v6, "getLocalizedMessage") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "getLocalizedMessage"))) - } - var tmp19 any - switch reflect.TypeOf(tmp18).Kind() { - case reflect.Func: - tmp19 = lang.Apply(tmp18, nil) - default: - tmp19 = tmp18 - } - var v20 any = tmp19 - _ = v20 - var tmp21 any - if lang.IsTruthy(v20) { - var tmp22 any - { // let - // let binding "msg" - var v23 any = v20 - _ = v23 - tmp24 := lang.NewMap(kw_message, v23) - tmp25 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(457), kw_column, int(20), kw_end_DASH_line, int(457), kw_end_DASH_column, int(33)) - tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp22 = tmp26 - } // end let - tmp21 = tmp22 - } else { - } - tmp17 = tmp21 - } // end let - var tmp18 any - { // let - // let binding "temp__0__auto__" - tmp19 := checkDerefVar(var_glojure_DOT_core_ex_DASH_data) - tmp20 := lang.Apply(tmp19, []any{v6}) - var v21 any = tmp20 - _ = v21 - var tmp22 any - if lang.IsTruthy(v21) { - var tmp23 any - { // let - // let binding "ed" - var v24 any = v21 - _ = v24 - tmp25 := lang.NewMap(kw_data, v24) - tmp26 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(459), kw_column, int(20), kw_end_DASH_line, int(459), kw_end_DASH_column, int(29)) - tmp27, err := lang.WithMeta(tmp25, tmp26.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp23 = tmp27 - } // end let - tmp22 = tmp23 - } else { - } - tmp18 = tmp22 - } // end let - var tmp19 any - { // let - // let binding "st" - tmp20, ok := lang.FieldOrMethod(v6, "getStackTrace") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "getStackTrace"))) - } - var tmp21 any - switch reflect.TypeOf(tmp20).Kind() { - case reflect.Func: - tmp21 = lang.Apply(tmp20, nil) - default: - tmp21 = tmp20 - } - var v22 any = tmp21 - _ = v22 - var tmp23 any - tmp24 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) - tmp25 := checkDerefVar(var_glojure_DOT_core_alength) - tmp26 := lang.Apply(tmp25, []any{v22}) - tmp27 := lang.Apply(tmp24, []any{tmp26}) - if lang.IsTruthy(tmp27) { - tmp28 := checkDerefVar(var_glojure_DOT_core_StackTraceElement_DASH__GT_vec) - tmp29 := checkDerefVar(var_glojure_DOT_core_aget) - tmp30 := lang.Apply(tmp29, []any{v22, int64(0)}) - tmp31 := lang.Apply(tmp28, []any{tmp30}) - tmp32 := lang.NewMap(kw_at, tmp31) - tmp33 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(462), kw_column, int(22), kw_end_DASH_line, int(462), kw_end_DASH_column, int(63)) - tmp34, err := lang.WithMeta(tmp32, tmp33.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp23 = tmp34 - } else { - } - tmp19 = tmp23 - } // end let - tmp20 := lang.Apply(tmp7, []any{tmp16, tmp17, tmp18, tmp19}) - return tmp20 - }) - tmp6 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(454), kw_column, int(14), kw_end_DASH_line, int(462), kw_end_DASH_column, int(67)) - tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v8 any = tmp7 - _ = v8 - // let binding "via" - var tmp9 any - { // let - // let binding "via" - tmp10 := lang.NewVector() - tmp11 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(463), kw_column, int(24), kw_end_DASH_line, int(463), kw_end_DASH_column, int(25)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v13 any = tmp12 - _ = v13 - // let binding "t" - var v14 any = v3 - _ = v14 - for { - var tmp15 any - if lang.IsTruthy(v14) { - tmp17 := checkDerefVar(var_glojure_DOT_core_conj) - tmp18 := lang.Apply(tmp17, []any{v13, v14}) - var tmp16 any = tmp18 - tmp20, ok := lang.FieldOrMethod(v14, "getCause") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v14, "getCause"))) - } - var tmp21 any - switch reflect.TypeOf(tmp20).Kind() { - case reflect.Func: - tmp21 = lang.Apply(tmp20, nil) - default: - tmp21 = tmp20 - } - var tmp19 any = tmp21 - v13 = tmp16 - v14 = tmp19 - continue - } else { - tmp15 = v13 - } - tmp9 = tmp15 - break - } - } // end let - var v10 any = tmp9 - _ = v10 - // let binding "root" - tmp11 := checkDerefVar(var_glojure_DOT_core_peek) - tmp12 := lang.Apply(tmp11, []any{v10}) - var v13 any = tmp12 - _ = v13 - tmp14 := checkDerefVar(var_glojure_DOT_core_merge) - tmp15 := checkDerefVar(var_glojure_DOT_core_vec) - tmp16 := checkDerefVar(var_glojure_DOT_core_map) - tmp17 := lang.Apply(tmp16, []any{v8, v10}) - tmp18 := lang.Apply(tmp15, []any{tmp17}) - tmp19 := checkDerefVar(var_glojure_DOT_core_vec) - tmp20 := checkDerefVar(var_glojure_DOT_core_map) - tmp21 := checkDerefVar(var_glojure_DOT_core_StackTraceElement_DASH__GT_vec) - var tmp22 any - { // let - // let binding "or__0__auto__" - var v23 any = v13 - _ = v23 - var tmp24 any - if lang.IsTruthy(v23) { - tmp24 = v23 - } else { - tmp24 = v3 - } - tmp22 = tmp24 - } // end let - tmp23, ok := lang.FieldOrMethod(tmp22, "getStackTrace") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp22, "getStackTrace"))) - } - var tmp24 any - switch reflect.TypeOf(tmp23).Kind() { - case reflect.Func: - tmp24 = lang.Apply(tmp23, nil) - default: - tmp24 = tmp23 - } - tmp25 := lang.Apply(tmp20, []any{tmp21, tmp24}) - tmp26 := lang.Apply(tmp19, []any{tmp25}) - tmp27 := lang.NewMap(kw_via, tmp18, kw_trace, tmp26) - tmp28 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(468), kw_column, int(12), kw_end_DASH_line, int(470), kw_end_DASH_column, int(111)) - tmp29, err := lang.WithMeta(tmp27, tmp28.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var tmp30 any - { // let - // let binding "temp__0__auto__" - tmp31, ok := lang.FieldOrMethod(v13, "getLocalizedMessage") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v13, "getLocalizedMessage"))) - } - var tmp32 any - switch reflect.TypeOf(tmp31).Kind() { - case reflect.Func: - tmp32 = lang.Apply(tmp31, nil) - default: - tmp32 = tmp31 - } - var v33 any = tmp32 - _ = v33 - var tmp34 any - if lang.IsTruthy(v33) { - var tmp35 any - { // let - // let binding "root-msg" - var v36 any = v33 - _ = v36 - tmp37 := lang.NewMap(kw_cause, v36) - tmp38 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(472), kw_column, int(9), kw_end_DASH_line, int(472), kw_end_DASH_column, int(25)) - tmp39, err := lang.WithMeta(tmp37, tmp38.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp35 = tmp39 - } // end let - tmp34 = tmp35 - } else { - } - tmp30 = tmp34 - } // end let - var tmp31 any - { // let - // let binding "temp__0__auto__" - tmp32 := checkDerefVar(var_glojure_DOT_core_ex_DASH_data) - tmp33 := lang.Apply(tmp32, []any{v13}) - var v34 any = tmp33 - _ = v34 - var tmp35 any - if lang.IsTruthy(v34) { - var tmp36 any - { // let - // let binding "data" - var v37 any = v34 - _ = v37 - tmp38 := lang.NewMap(kw_data, v37) - tmp39 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(474), kw_column, int(9), kw_end_DASH_line, int(474), kw_end_DASH_column, int(20)) - tmp40, err := lang.WithMeta(tmp38, tmp39.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp36 = tmp40 - } // end let - tmp35 = tmp36 - } else { - } - tmp31 = tmp35 - } // end let - var tmp32 any - { // let - // let binding "temp__0__auto__" - tmp33 := checkDerefVar(var_glojure_DOT_core_ex_DASH_data) - tmp34 := lang.Apply(tmp33, []any{v3}) - tmp35 := lang.Apply(kw_glojure_DOT_error_SLASH_phase, []any{tmp34}) - var v36 any = tmp35 - _ = v36 - var tmp37 any - if lang.IsTruthy(v36) { - var tmp38 any - { // let - // let binding "phase" - var v39 any = v36 - _ = v39 - tmp40 := lang.NewMap(kw_phase, v39) - tmp41 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(476), kw_column, int(9), kw_end_DASH_line, int(476), kw_end_DASH_column, int(22)) - tmp42, err := lang.WithMeta(tmp40, tmp41.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp38 = tmp42 - } // end let - tmp37 = tmp38 - } else { - } - tmp32 = tmp37 - } // end let - tmp33 := lang.Apply(tmp14, []any{tmp29, tmp30, tmp31, tmp32}) - tmp4 = tmp33 - } // end let - return tmp4 + tmp0 := sym_sorted_DASH_map.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_keyvals)), kw_doc, "keyval => key val\n Returns a new sorted map with supplied mappings. If any keys are\n equal, they are handled as if by repeated uses of assoc.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(397), kw_end_DASH_line, int(397))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + tmp3 := lang.Apply(lang.CreatePersistentTreeMap, []any{v2}) + return tmp3 + } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_sorted_DASH_map = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_sorted_DASH_map.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // abs + // sorted-map-by { + tmp0 := sym_sorted_DASH_map_DASH_by.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_comparator, sym__AMP_, sym_keyvals)), kw_doc, "keyval => key val\n Returns a new sorted map with supplied mappings, using the supplied\n comparator. If any keys are equal, they are handled as if by\n repeated uses of assoc.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(406), kw_end_DASH_line, int(406))).(*lang.Symbol) var tmp1 lang.FnFunc - { // function abs__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: checkArity(args, 1) - v3 := args[0] + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_seq) - tmp5 := checkDerefVar(var_glojure_DOT_core_concat) - tmp6 := checkDerefVar(var_glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Abs}) - tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{v3}) - tmp10 := lang.Apply(tmp5, []any{tmp7, tmp9}) - tmp11 := lang.Apply(tmp4, []any{tmp10}) - return tmp11 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := sym_abs.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a)), kw_inline, tmp1, kw_doc, "Returns the absolute value of a.\n If a is Long/MIN_VALUE => Long/MIN_VALUE\n If a is a double and zero => +0.0\n If a is a double and ##Inf or ##-Inf => ##Inf\n If a is a double and ##NaN => ##NaN", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1)})), kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(1128), kw_end_DASH_line, int(1128))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5 := lang.Apply(lang.Abs, []any{v4}) - return tmp5 + tmp4 := lang.Apply(nil, []any{v2, v3}) + return tmp4 + } }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_sorted_DASH_map_DASH_by = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_sorted_DASH_map_DASH_by.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // accessor + // sorted-set { - tmp0 := sym_accessor.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s, sym_key)), kw_doc, "Returns a fn that, given an instance of a structmap with the basis,\n returns the value at the key. The key must be in the basis. The\n returned function should be (slightly) more efficient than using\n get, but such use of accessors should be limited to known\n performance-critical areas.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(4070), kw_end_DASH_line, int(4070))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5, _ := lang.FieldOrMethod(nil, "getAccessor") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("getAccessor is not a function"))) + tmp0 := sym_sorted_DASH_set.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_keys)), kw_doc, "Returns a new sorted set with supplied keys. Any equal keys are\n handled as if by repeated uses of conj.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(416), kw_end_DASH_line, int(416))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + tmp3 := lang.Apply(lang.CreatePersistentTreeSet, []any{v2}) + return tmp3 } - tmp6 := lang.Apply(tmp5, []any{v3, v4}) - return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_sorted_DASH_set = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_sorted_DASH_set.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // aclone + // sorted-set-by { + tmp0 := sym_sorted_DASH_set_DASH_by.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_comparator, sym__AMP_, sym_keys)), kw_doc, "Returns a new sorted set with supplied keys, using the supplied\n comparator. Any equal keys are handled as if by repeated uses of\n conj.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(424), kw_end_DASH_line, int(424))).(*lang.Symbol) var tmp1 lang.FnFunc - { // function aclone__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: checkArity(args, 1) - v3 := args[0] + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_seq) - tmp5 := checkDerefVar(var_glojure_DOT_core_concat) - tmp6 := checkDerefVar(var_glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) - tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := checkDerefVar(var_glojure_DOT_core_seq) - tmp12 := checkDerefVar(var_glojure_DOT_core_concat) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Aclone}) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{v3}) - tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) - tmp18 := lang.Apply(tmp11, []any{tmp17}) - tmp19 := lang.Apply(tmp10, []any{tmp18}) - tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) - tmp21 := lang.Apply(tmp4, []any{tmp20}) - return tmp21 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := sym_aclone.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array)), kw_inline, tmp1, kw_doc, "Returns a clone of the Java array. Works on arrays of known\n types.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(3904), kw_end_DASH_line, int(3904))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(runtime.RT, "Aclone") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Aclone is not a function"))) + tmp4 := lang.Apply(lang.CreatePersistentTreeSetWithComparator, []any{v2, v3}) + return tmp4 } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_sorted_DASH_set_DASH_by = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_sorted_DASH_set_DASH_by.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // add-classpath + // sorted? { - tmp0 := sym_add_DASH_classpath.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_url)), kw_doc, "DEPRECATED \n\n Adds the url (String or URL object) to the classpath per\n URLClassLoader.addURL", kw_file, "glojure/core.glj", kw_deprecated, "1.1", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(5176), kw_end_DASH_line, int(5176))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_sorted_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns true if coll implements Sorted", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(6235), kw_end_DASH_line, int(6235))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_println) - tmp5 := lang.Apply(tmp4, []any{"WARNING: add-classpath is deprecated"}) - _ = tmp5 - tmp6 := lang.Apply(nil, []any{v3}) - return tmp6 + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := lang.Apply(tmp3, []any{nil, v2}) + return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_sorted_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_sorted_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // add-doc-and-meta + // special-symbol? { - tmp0 := sym_add_DASH_doc_DASH_and_DASH_meta.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym_docstring, sym_meta)), kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(26), kw_column, int(11), kw_line, int(6400), kw_end_DASH_line, int(6400), kw_private, true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 5) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - v7 := args[4] - _ = v7 - tmp8 := checkDerefVar(var_glojure_DOT_core_seq) - tmp9 := checkDerefVar(var_glojure_DOT_core_concat) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_alter_DASH_meta_BANG_}) - tmp12 := checkDerefVar(var_glojure_DOT_core_list) - tmp13 := checkDerefVar(var_glojure_DOT_core_seq) - tmp14 := checkDerefVar(var_glojure_DOT_core_concat) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{sym_var}) - tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{v5}) - tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) - tmp20 := lang.Apply(tmp13, []any{tmp19}) - tmp21 := lang.Apply(tmp12, []any{tmp20}) - tmp22 := checkDerefVar(var_glojure_DOT_core_list) - tmp23 := lang.Apply(tmp22, []any{sym_glojure_DOT_core_SLASH_merge}) - tmp24 := checkDerefVar(var_glojure_DOT_core_list) - tmp25 := checkDerefVar(var_glojure_DOT_core_seq) - tmp26 := checkDerefVar(var_glojure_DOT_core_concat) - tmp27 := checkDerefVar(var_glojure_DOT_core_list) - tmp28 := lang.Apply(tmp27, []any{sym_glojure_DOT_core_SLASH_assoc}) - tmp29 := checkDerefVar(var_glojure_DOT_core_list) - tmp30 := lang.Apply(tmp29, []any{v7}) - tmp31 := checkDerefVar(var_glojure_DOT_core_list) - tmp32 := lang.Apply(tmp31, []any{kw_doc}) - tmp33 := checkDerefVar(var_glojure_DOT_core_list) - tmp34 := lang.Apply(tmp33, []any{v6}) - tmp35 := lang.Apply(tmp26, []any{tmp28, tmp30, tmp32, tmp34}) - tmp36 := lang.Apply(tmp25, []any{tmp35}) - tmp37 := lang.Apply(tmp24, []any{tmp36}) - tmp38 := lang.Apply(tmp9, []any{tmp11, tmp21, tmp23, tmp37}) - tmp39 := lang.Apply(tmp8, []any{tmp38}) - return tmp39 + tmp0 := sym_special_DASH_symbol_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_doc, "Returns true if s names a special form", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(4992), kw_end_DASH_line, int(4992))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp4, ok := lang.FieldOrMethod(runtime.Compiler, "specials") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", runtime.Compiler, "specials"))) + } + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { + case reflect.Func: + tmp5 = lang.Apply(tmp4, nil) + default: + tmp5 = tmp4 + } + tmp6 := lang.Apply(tmp3, []any{tmp5, v2}) + return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_special_DASH_symbol_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_special_DASH_symbol_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // add-watch + // spread { - tmp0 := sym_add_DASH_watch.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_reference, sym_key, sym_fn)), kw_doc, "Adds a watch function to an agent/atom/var/ref reference. The watch\n fn must be a fn of 4 args: a key, the reference, its old-state, its\n new-state. Whenever the reference's state might have been changed,\n any registered watches will have their functions called. The watch fn\n will be called synchronously, on the agent's thread if an agent,\n before any pending sends if agent or ref. Note that an atom's or\n ref's state may have changed again prior to the fn call, so use\n old/new-state rather than derefing the reference. Note also that watch\n fns may be called from multiple threads simultaneously. Var watchers\n are triggered only by root binding changes, not thread-local\n set!s. Keys must be unique per reference, and can be used to remove\n the watch with remove-watch, but are otherwise considered opaque by\n the watch mechanism.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(2142), kw_end_DASH_line, int(2142))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 3) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6, _ := lang.FieldOrMethod(v3, "addWatch") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("addWatch is not a function"))) + tmp0 := sym_spread.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_arglist)), kw_static, true, kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(632), kw_end_DASH_line, int(632), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + } else { + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp8 := checkDerefVar(var_glojure_DOT_core_next) + tmp9 := lang.Apply(tmp8, []any{v2}) + tmp10 := lang.Apply(tmp7, []any{tmp9}) + if lang.IsTruthy(tmp10) { + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_first) + tmp13 := lang.Apply(tmp12, []any{v2}) + tmp14 := lang.Apply(tmp11, []any{tmp13}) + tmp6 = tmp14 + } else { + var tmp15 any + if lang.IsTruthy(kw_else) { + tmp16 := checkDerefVar(var_glojure_DOT_core_cons) + tmp17 := checkDerefVar(var_glojure_DOT_core_first) + tmp18 := lang.Apply(tmp17, []any{v2}) + tmp19 := checkDerefVar(var_glojure_DOT_core_spread) + tmp20 := checkDerefVar(var_glojure_DOT_core_next) + tmp21 := lang.Apply(tmp20, []any{v2}) + tmp22 := lang.Apply(tmp19, []any{tmp21}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp22}) + tmp15 = tmp23 + } else { + } + tmp6 = tmp15 + } + tmp3 = tmp6 } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 + return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_spread = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_spread.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // agent + // str { - tmp0 := sym_agent.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_state, sym__AMP_, sym_options)), kw_doc, "Creates and returns an agent with an initial value of state and\n zero or more options (in any order):\n\n :meta metadata-map\n\n :validator validate-fn\n\n :error-handler handler-fn\n\n :error-mode mode-keyword\n\n If metadata-map is supplied, it will become the metadata on the\n agent. validate-fn must be nil or a side-effect-free fn of one\n argument, which will be passed the intended new state on any state\n change. If the new state is unacceptable, the validate-fn should\n return false or throw an exception. handler-fn is called if an\n action throws an exception or if validate-fn rejects a new state --\n see set-error-handler! for details. The mode-keyword may be either\n :continue (the default if an error-handler is given) or :fail (the\n default if no error-handler is given) -- see set-error-mode! for\n details.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(2052), kw_end_DASH_line, int(2052))).(*lang.Symbol) + tmp1 := reflect.TypeOf("") + tmp0 := sym_str.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_x), lang.NewVector(sym_x, sym__AMP_, sym_ys)), kw_doc, "With no args, returns the empty string. With one arg x, returns\n x.toString(). (str nil) returns the empty string. With more than\n one arg, returns the concatenation of the str values of the args.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(543), kw_end_DASH_line, int(543))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { + case 0: + return "" + case 1: + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + tmp4 = "" + } else { + tmp7 := lang.Apply(lang.ToString, []any{v3}) + tmp4 = tmp7 + } + return tmp4 default: checkArity(args, 1) v3 := args[0] _ = v3 var v4 any = lang.NewList(args[1:]...) _ = v4 - var tmp5 any - { // let - // let binding "a" - var v6 any = "unimplemented: new with non-constant class type" + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v6 := args[0] _ = v6 - // let binding "opts" - tmp7 := checkDerefVar(var_glojure_DOT_core_apply) - tmp8 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) - tmp9 := lang.Apply(tmp7, []any{tmp8, v4}) - var v10 any = tmp9 - _ = v10 - tmp11 := checkDerefVar(var_glojure_DOT_core_setup_DASH_reference) - tmp12 := lang.Apply(tmp11, []any{v6, v4}) - _ = tmp12 - var tmp13 any - tmp14 := lang.Apply(kw_error_DASH_handler, []any{v10}) - if lang.IsTruthy(tmp14) { - tmp15 := lang.Apply(kw_error_DASH_handler, []any{v10}) - tmp16, _ := lang.FieldOrMethod(v6, "setErrorHandler") - if reflect.TypeOf(tmp16).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorHandler is not a function"))) + v7 := args[1] + _ = v7 + recur_loop_74: + var tmp8 any + if lang.IsTruthy(v7) { + tmp10 := checkDerefVar(var_glojure_DOT_core_str) + tmp11 := checkDerefVar(var_glojure_DOT_core_first) + tmp12 := lang.Apply(tmp11, []any{v7}) + tmp13 := lang.Apply(tmp10, []any{tmp12}) + tmp14, _ := lang.FieldOrMethod(v6, "WriteString") + if reflect.TypeOf(tmp14).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("WriteString is not a function"))) } - tmp17 := lang.Apply(tmp16, []any{tmp15}) - tmp13 = tmp17 + tmp15 := lang.Apply(tmp14, []any{tmp13}) + _ = tmp15 + var tmp9 any = v6 + tmp17 := checkDerefVar(var_glojure_DOT_core_next) + tmp18 := lang.Apply(tmp17, []any{v7}) + var tmp16 any = tmp18 + v6 = tmp9 + v7 = tmp16 + goto recur_loop_74 } else { - } - _ = tmp13 - var tmp18 any - { // let - // let binding "or__0__auto__" - tmp19 := lang.Apply(kw_error_DASH_mode, []any{v10}) - var v20 any = tmp19 - _ = v20 - var tmp21 any - if lang.IsTruthy(v20) { - tmp21 = v20 - } else { - var tmp22 any - tmp23 := lang.Apply(kw_error_DASH_handler, []any{v10}) - if lang.IsTruthy(tmp23) { - tmp22 = kw_continue - } else { - tmp22 = kw_fail - } - tmp21 = tmp22 + tmp19, ok := lang.FieldOrMethod(v6, "String") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "String"))) } - tmp18 = tmp21 - } // end let - tmp19, _ := lang.FieldOrMethod(v6, "setErrorMode") - if reflect.TypeOf(tmp19).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorMode is not a function"))) + var tmp20 any + switch reflect.TypeOf(tmp19).Kind() { + case reflect.Func: + tmp20 = lang.Apply(tmp19, nil) + default: + tmp20 = tmp19 + } + tmp8 = tmp20 } - tmp20 := lang.Apply(tmp19, []any{tmp18}) - _ = tmp20 - tmp5 = v6 - } // end let - return tmp5 + return tmp8 + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(554), kw_column, int(7), kw_end_DASH_line, int(554), kw_end_DASH_column, int(127)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp8 := checkDerefVar(var_glojure_DOT_core_cons) + tmp9 := lang.Apply(tmp8, []any{v3, v4}) + tmp10 := lang.Apply(tmp7, []any{"unimplemented: new with non-constant class type", tmp9}) + return tmp10 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp3 := reflect.TypeOf("") + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_str = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_str.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // agent-error + // stream-reduce! { - tmp0 := sym_agent_DASH_error.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a)), kw_doc, "Returns the exception thrown during an asynchronous action of the\n agent if the agent is failed. Returns nil if the agent is not\n failed.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(2167), kw_end_DASH_line, int(2167))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_stream_DASH_reduce_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_s), lang.NewVector(sym_f, sym_init, sym_s)), kw_doc, "Works like reduce but takes a java.util.stream.BaseStream as its source.\n Honors 'reduced', is a terminal operation on the stream", kw_file, "glojure/core.glj", kw_added, "1.12", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(6784), kw_end_DASH_line, int(6784))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, ok := lang.FieldOrMethod(v3, "iterator") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "iterator"))) + } + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { + case reflect.Func: + tmp5 = lang.Apply(tmp4, nil) + default: + tmp5 = tmp4 + } + tmp6 := lang.Apply(nil, []any{tmp5, v2}) + return tmp6 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5, ok := lang.FieldOrMethod(v4, "iterator") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "iterator"))) + } + var tmp6 any + switch reflect.TypeOf(tmp5).Kind() { + case reflect.Func: + tmp6 = lang.Apply(tmp5, nil) + default: + tmp6 = tmp5 + } + tmp7 := lang.Apply(nil, []any{tmp6, v2, v3}) + return tmp7 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_stream_DASH_reduce_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_stream_DASH_reduce_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // stream-seq! + { + tmp0 := sym_stream_DASH_seq_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_stream)), kw_doc, "Takes a java.util.stream.BaseStream instance s and returns a seq of its\n contents. This is a terminal operation on the stream.", kw_file, "glojure/core.glj", kw_added, "1.12", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(6793), kw_end_DASH_line, int(6793))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4, ok := lang.FieldOrMethod(v3, "getError") + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_iterator_DASH_seq) + tmp4, ok := lang.FieldOrMethod(v2, "iterator") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getError"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "iterator"))) } var tmp5 any switch reflect.TypeOf(tmp4).Kind() { @@ -7402,3189 +7029,2246 @@ func LoadNS() { default: tmp5 = tmp4 } - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // agent-errors - { - tmp0 := sym_agent_DASH_errors.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a)), kw_doc, "DEPRECATED: Use 'agent-error' instead.\n Returns a sequence of the exceptions thrown during asynchronous\n actions of the agent.", kw_file, "glojure/core.glj", kw_deprecated, "1.2", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(2234), kw_end_DASH_line, int(2234))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "temp__0__auto__" - tmp5 := checkDerefVar(var_glojure_DOT_core_agent_DASH_error) - tmp6 := lang.Apply(tmp5, []any{v3}) - var v7 any = tmp6 - _ = v7 - var tmp8 any - if lang.IsTruthy(v7) { - var tmp9 any - { // let - // let binding "e" - var v10 any = v7 - _ = v10 - tmp11 := checkDerefVar(var_glojure_DOT_core_list) - tmp12 := lang.Apply(tmp11, []any{v10}) - tmp9 = tmp12 - } // end let - tmp8 = tmp9 - } else { - } - tmp4 = tmp8 - } // end let - return tmp4 + tmp6 := lang.Apply(tmp3, []any{tmp5}) + return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_stream_DASH_seq_BANG_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_stream_DASH_seq_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // aget + // stream-transduce! { + tmp0 := sym_stream_DASH_transduce_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xform, sym_f, sym_stream), lang.NewVector(sym_xform, sym_f, sym_init, sym_stream)), kw_doc, "Works like transduce but takes a java.util.stream.BaseStream as its source.\n This is a terminal operation on the stream.", kw_file, "glojure/core.glj", kw_added, "1.12", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(7), kw_line, int(6800), kw_end_DASH_line, int(6800))).(*lang.Symbol) var tmp1 lang.FnFunc - { // function aget__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + v4 := args[2] _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_seq) - tmp6 := checkDerefVar(var_glojure_DOT_core_concat) - tmp7 := checkDerefVar(var_glojure_DOT_core_list) - tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) - tmp9 := checkDerefVar(var_glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) - tmp11 := checkDerefVar(var_glojure_DOT_core_list) - tmp12 := checkDerefVar(var_glojure_DOT_core_seq) - tmp13 := checkDerefVar(var_glojure_DOT_core_concat) - tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Aget}) - tmp16 := checkDerefVar(var_glojure_DOT_core_list) - tmp17 := lang.Apply(tmp16, []any{v3}) - tmp18 := checkDerefVar(var_glojure_DOT_core_list) - tmp19 := checkDerefVar(var_glojure_DOT_core_seq) - tmp20 := checkDerefVar(var_glojure_DOT_core_concat) - tmp21 := checkDerefVar(var_glojure_DOT_core_list) - tmp22 := lang.Apply(tmp21, []any{sym_glojure_DOT_core_SLASH_int}) - tmp23 := checkDerefVar(var_glojure_DOT_core_list) - tmp24 := lang.Apply(tmp23, []any{v4}) - tmp25 := lang.Apply(tmp20, []any{tmp22, tmp24}) - tmp26 := lang.Apply(tmp19, []any{tmp25}) - tmp27 := lang.Apply(tmp18, []any{tmp26}) - tmp28 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp27}) - tmp29 := lang.Apply(tmp12, []any{tmp28}) - tmp30 := lang.Apply(tmp11, []any{tmp29}) - tmp31 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp30}) - tmp32 := lang.Apply(tmp5, []any{tmp31}) - return tmp32 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := sym_aget.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx), lang.NewVector(sym_array, sym_idx, sym__AMP_, sym_idxs)), kw_inline, tmp1, kw_doc, "Returns the value at the index/indices. Works on Java arrays of all\n types.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3911), kw_end_DASH_line, int(3911))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: - v4 := args[0] + tmp5 := checkDerefVar(var_glojure_DOT_core_stream_DASH_transduce_BANG_) + tmp6 := lang.Apply(v3, nil) + tmp7 := lang.Apply(tmp5, []any{v2, v3, tmp6, v4}) + return tmp7 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] _ = v4 - v5 := args[1] + v5 := args[3] _ = v5 - tmp6 := lang.Apply(lang.Get, []any{v4, v5}) + var tmp6 any + { // let + // let binding "f" + tmp7 := lang.Apply(v2, []any{v3}) + var v8 any = tmp7 + _ = v8 + // let binding "ret" + tmp9 := checkDerefVar(var_glojure_DOT_core_stream_DASH_reduce_BANG_) + tmp10 := lang.Apply(tmp9, []any{v8, v4, v5}) + var v11 any = tmp10 + _ = v11 + tmp12 := lang.Apply(v8, []any{v11}) + tmp6 = tmp12 + } // end let return tmp6 default: - checkArity(args, 2) - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - var v6 any = lang.NewList(args[2:]...) - _ = v6 - tmp7 := checkDerefVar(var_glojure_DOT_core_apply) - tmp8 := checkDerefVar(var_glojure_DOT_core_aget) - tmp9 := checkDerefVar(var_glojure_DOT_core_aget) - tmp10 := lang.Apply(tmp9, []any{v4, v5}) - tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) - return tmp11 + checkArity(args, -1) + panic("unreachable") } }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_stream_DASH_transduce_BANG_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_stream_DASH_transduce_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // alength + // string? { + tmp0 := sym_string_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a String", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(2), kw_line, int(160), kw_end_DASH_line, int(164))).(*lang.Symbol) var tmp1 lang.FnFunc - { // function alength__inliner + { // function string? var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_seq) - tmp5 := checkDerefVar(var_glojure_DOT_core_concat) - tmp6 := checkDerefVar(var_glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) - tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := checkDerefVar(var_glojure_DOT_core_seq) - tmp12 := checkDerefVar(var_glojure_DOT_core_concat) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Alength}) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{v3}) - tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) - tmp18 := lang.Apply(tmp11, []any{tmp17}) - tmp19 := lang.Apply(tmp10, []any{tmp18}) - tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) - tmp21 := lang.Apply(tmp4, []any{tmp20}) - return tmp21 + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := lang.Apply(tmp4, []any{lang.Builtins["string"], v3}) + return tmp5 }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(164), kw_column, int(10), kw_end_DASH_line, int(164), kw_end_DASH_column, int(58))).(lang.FnFunc) v2 = tmp1 _ = v2 } - tmp0 := sym_alength.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array)), kw_inline, tmp1, kw_doc, "Returns the length of the Java array. Works on arrays of all\n types.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(3897), kw_end_DASH_line, int(3897))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(runtime.RT, "Alength") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Alength is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + var_glojure_DOT_core_string_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_string_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // alias + // struct { - tmp0 := sym_alias.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_alias, sym_namespace_DASH_sym)), kw_doc, "Add an alias in the current namespace to another\n namespace. Arguments are two symbols: the alias to be used, and\n the symbolic name of the target namespace. Use :as in the ns macro in preference\n to calling this directly.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(4263), kw_end_DASH_line, int(4263))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) - tmp6 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) - tmp7 := lang.Apply(tmp6, []any{v4}) - tmp8, _ := lang.FieldOrMethod(tmp5, "AddAlias") - if reflect.TypeOf(tmp8).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("AddAlias is not a function"))) + tmp0 := sym_struct.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s, sym__AMP_, sym_vals)), kw_doc, "Returns a new structmap instance with the keys of the\n structure-basis. vals must be supplied for basis keys in order -\n where values are not supplied they will default to nil.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(4061), kw_end_DASH_line, int(4061))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + tmp4 := lang.Apply(lang.ConstructPersistentStructMap, []any{v2, v3}) + return tmp4 } - tmp9 := lang.Apply(tmp8, []any{v3, tmp7}) - return tmp9 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_struct = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_struct.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // all-ns + // struct-map { - tmp0 := sym_all_DASH_ns.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Returns a sequence of all namespaces.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(4146), kw_end_DASH_line, int(4146))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - tmp3 := lang.Apply(nil, nil) - return tmp3 + tmp0 := sym_struct_DASH_map.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s, sym__AMP_, sym_inits)), kw_doc, "Returns a new structmap instance with the keys of the\n structure-basis. keyvals may contain all, some or none of the basis\n keys - where values are not supplied they will default to nil.\n keyvals can also contain keys not in the basis.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4051), kw_end_DASH_line, int(4051))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + tmp4 := lang.Apply(lang.CreatePersistentStructMap, []any{v2, v3}) + return tmp4 + } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_struct_DASH_map = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_struct_DASH_map.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // alter + // subs { - tmp0 := sym_alter.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ref, sym_fun, sym__AMP_, sym_args)), kw_doc, "Must be called in a transaction. Sets the in-transaction-value of\n ref to:\n\n (apply fun in-transaction-value-of-ref args)\n\n and returns the in-transaction-value of ref.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(2435), kw_end_DASH_line, int(2435))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_subs.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s, sym_start), lang.NewVector(sym_s, sym_start, sym_end)), kw_doc, "Returns the substring of s beginning at start inclusive, and ending\n at end (defaults to length of string), exclusive.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(5005), kw_end_DASH_line, int(5005))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - default: - checkArity(args, 2) - v3 := args[0] + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + tmp4 := lang.Apply(lang.Builtins["slice"], []any{v2, v3}) + return tmp4 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - tmp6, _ := lang.FieldOrMethod(v3, "alter") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("alter is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 + tmp5 := lang.Apply(lang.Builtins["slice"], []any{v2, v3, v4}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_subs = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_subs.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // alter-meta! + // swap! { - tmp0 := sym_alter_DASH_meta_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_iref, sym_f, sym__AMP_, sym_args)), kw_doc, "Atomically sets the metadata for a namespace/var/ref/agent/atom to be:\n\n (apply f its-current-meta args)\n\n f must be free of side-effects", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(2398), kw_end_DASH_line, int(2398))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_swap_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_atom, sym_f, sym__AMP_, sym_args)), kw_doc, "Atomically swaps the value of atom to be:\n (apply f current-value-of-atom args). Note that f may be called\n multiple times, and thus should be free of side effects. Returns\n the value that was swapped in.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(2343), kw_end_DASH_line, int(2343))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: checkArity(args, 2) - v3 := args[0] + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + var v4 any = lang.NewList(args[2:]...) _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - tmp6, _ := lang.FieldOrMethod(v3, "AlterMeta") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("AlterMeta is not a function"))) + tmp5, _ := lang.FieldOrMethod(v2, "swap") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("swap is not a function"))) } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_swap_BANG_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_swap_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // alter-var-root + // swap-vals! { - tmp0 := sym_alter_DASH_var_DASH_root.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_v, sym_f, sym__AMP_, sym_args)), kw_doc, "Atomically alters the root binding of var v by applying f to its\n current value plus any args", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(5484), kw_end_DASH_line, int(5484))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_swap_DASH_vals_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_atom, sym_f, sym__AMP_, sym_args)), kw_doc, "Atomically swaps the value of atom to be:\n (apply f current-value-of-atom args). Note that f may be called\n multiple times, and thus should be free of side effects.\n Returns [old new], the value of the atom before and after the swap.", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(2352), kw_end_DASH_line, int(2352))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: checkArity(args, 2) - v3 := args[0] + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + var v4 any = lang.NewList(args[2:]...) _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - tmp6, _ := lang.FieldOrMethod(v3, "alterRoot") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("alterRoot is not a function"))) + tmp5, _ := lang.FieldOrMethod(v2, "swapVals") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("swapVals is not a function"))) } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_swap_DASH_vals_BANG_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_swap_DASH_vals_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // amap + // symbol? { - tmp0 := sym_amap.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_a, sym_idx, sym_ret, sym_expr)), kw_doc, "Maps an expression across an array a, using an index named idx, and\n return value named ret, initialized to a clone of a, then setting \n each element of ret to the evaluation of expr, returning the new \n array ret.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(11), kw_line, int(5273), kw_end_DASH_line, int(5273))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 6) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - v7 := args[4] - _ = v7 - v8 := args[5] - _ = v8 - tmp9 := checkDerefVar(var_glojure_DOT_core_seq) - tmp10 := checkDerefVar(var_glojure_DOT_core_concat) - tmp11 := checkDerefVar(var_glojure_DOT_core_list) - tmp12 := lang.Apply(tmp11, []any{sym_glojure_DOT_core_SLASH_let}) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := checkDerefVar(var_glojure_DOT_core_apply) - tmp15 := checkDerefVar(var_glojure_DOT_core_vector) - tmp16 := checkDerefVar(var_glojure_DOT_core_seq) - tmp17 := checkDerefVar(var_glojure_DOT_core_concat) - tmp18 := checkDerefVar(var_glojure_DOT_core_list) - tmp19 := lang.Apply(tmp18, []any{sym_a__0__auto__}) - tmp20 := checkDerefVar(var_glojure_DOT_core_list) - tmp21 := lang.Apply(tmp20, []any{v5}) - tmp22 := checkDerefVar(var_glojure_DOT_core_list) - tmp23 := lang.Apply(tmp22, []any{sym_l__1__auto__}) - tmp24 := checkDerefVar(var_glojure_DOT_core_list) - tmp25 := checkDerefVar(var_glojure_DOT_core_seq) - tmp26 := checkDerefVar(var_glojure_DOT_core_concat) - tmp27 := checkDerefVar(var_glojure_DOT_core_list) - tmp28 := lang.Apply(tmp27, []any{sym_glojure_DOT_core_SLASH_alength}) - tmp29 := checkDerefVar(var_glojure_DOT_core_list) - tmp30 := lang.Apply(tmp29, []any{sym_a__0__auto__}) - tmp31 := lang.Apply(tmp26, []any{tmp28, tmp30}) - tmp32 := lang.Apply(tmp25, []any{tmp31}) - tmp33 := lang.Apply(tmp24, []any{tmp32}) - tmp34 := checkDerefVar(var_glojure_DOT_core_list) - tmp35 := lang.Apply(tmp34, []any{v7}) - tmp36 := checkDerefVar(var_glojure_DOT_core_list) - tmp37 := checkDerefVar(var_glojure_DOT_core_seq) - tmp38 := checkDerefVar(var_glojure_DOT_core_concat) - tmp39 := checkDerefVar(var_glojure_DOT_core_list) - tmp40 := lang.Apply(tmp39, []any{sym_glojure_DOT_core_SLASH_aclone}) - tmp41 := checkDerefVar(var_glojure_DOT_core_list) - tmp42 := lang.Apply(tmp41, []any{sym_a__0__auto__}) - tmp43 := lang.Apply(tmp38, []any{tmp40, tmp42}) - tmp44 := lang.Apply(tmp37, []any{tmp43}) - tmp45 := lang.Apply(tmp36, []any{tmp44}) - tmp46 := lang.Apply(tmp17, []any{tmp19, tmp21, tmp23, tmp33, tmp35, tmp45}) - tmp47 := lang.Apply(tmp16, []any{tmp46}) - tmp48 := lang.Apply(tmp14, []any{tmp15, tmp47}) - tmp49 := lang.Apply(tmp13, []any{tmp48}) - tmp50 := checkDerefVar(var_glojure_DOT_core_list) - tmp51 := checkDerefVar(var_glojure_DOT_core_seq) - tmp52 := checkDerefVar(var_glojure_DOT_core_concat) - tmp53 := checkDerefVar(var_glojure_DOT_core_list) - tmp54 := lang.Apply(tmp53, []any{sym_glojure_DOT_core_SLASH_loop}) - tmp55 := checkDerefVar(var_glojure_DOT_core_list) - tmp56 := checkDerefVar(var_glojure_DOT_core_apply) - tmp57 := checkDerefVar(var_glojure_DOT_core_vector) - tmp58 := checkDerefVar(var_glojure_DOT_core_seq) - tmp59 := checkDerefVar(var_glojure_DOT_core_concat) - tmp60 := checkDerefVar(var_glojure_DOT_core_list) - tmp61 := lang.Apply(tmp60, []any{v6}) - tmp62 := checkDerefVar(var_glojure_DOT_core_list) - tmp63 := lang.Apply(tmp62, []any{int64(0)}) - tmp64 := lang.Apply(tmp59, []any{tmp61, tmp63}) - tmp65 := lang.Apply(tmp58, []any{tmp64}) - tmp66 := lang.Apply(tmp56, []any{tmp57, tmp65}) - tmp67 := lang.Apply(tmp55, []any{tmp66}) - tmp68 := checkDerefVar(var_glojure_DOT_core_list) - tmp69 := checkDerefVar(var_glojure_DOT_core_seq) - tmp70 := checkDerefVar(var_glojure_DOT_core_concat) - tmp71 := checkDerefVar(var_glojure_DOT_core_list) - tmp72 := lang.Apply(tmp71, []any{sym_if}) - tmp73 := checkDerefVar(var_glojure_DOT_core_list) - tmp74 := checkDerefVar(var_glojure_DOT_core_seq) - tmp75 := checkDerefVar(var_glojure_DOT_core_concat) - tmp76 := checkDerefVar(var_glojure_DOT_core_list) - tmp77 := lang.Apply(tmp76, []any{sym_glojure_DOT_core_SLASH__LT_}) - tmp78 := checkDerefVar(var_glojure_DOT_core_list) - tmp79 := lang.Apply(tmp78, []any{v6}) - tmp80 := checkDerefVar(var_glojure_DOT_core_list) - tmp81 := lang.Apply(tmp80, []any{sym_l__1__auto__}) - tmp82 := lang.Apply(tmp75, []any{tmp77, tmp79, tmp81}) - tmp83 := lang.Apply(tmp74, []any{tmp82}) - tmp84 := lang.Apply(tmp73, []any{tmp83}) - tmp85 := checkDerefVar(var_glojure_DOT_core_list) - tmp86 := checkDerefVar(var_glojure_DOT_core_seq) - tmp87 := checkDerefVar(var_glojure_DOT_core_concat) - tmp88 := checkDerefVar(var_glojure_DOT_core_list) - tmp89 := lang.Apply(tmp88, []any{sym_do}) - tmp90 := checkDerefVar(var_glojure_DOT_core_list) - tmp91 := checkDerefVar(var_glojure_DOT_core_seq) - tmp92 := checkDerefVar(var_glojure_DOT_core_concat) - tmp93 := checkDerefVar(var_glojure_DOT_core_list) - tmp94 := lang.Apply(tmp93, []any{sym_glojure_DOT_core_SLASH_aset}) - tmp95 := checkDerefVar(var_glojure_DOT_core_list) - tmp96 := lang.Apply(tmp95, []any{v7}) - tmp97 := checkDerefVar(var_glojure_DOT_core_list) - tmp98 := lang.Apply(tmp97, []any{v6}) - tmp99 := checkDerefVar(var_glojure_DOT_core_list) - tmp100 := lang.Apply(tmp99, []any{v8}) - tmp101 := lang.Apply(tmp92, []any{tmp94, tmp96, tmp98, tmp100}) - tmp102 := lang.Apply(tmp91, []any{tmp101}) - tmp103 := lang.Apply(tmp90, []any{tmp102}) - tmp104 := checkDerefVar(var_glojure_DOT_core_list) - tmp105 := checkDerefVar(var_glojure_DOT_core_seq) - tmp106 := checkDerefVar(var_glojure_DOT_core_concat) - tmp107 := checkDerefVar(var_glojure_DOT_core_list) - tmp108 := lang.Apply(tmp107, []any{sym_recur}) - tmp109 := checkDerefVar(var_glojure_DOT_core_list) - tmp110 := checkDerefVar(var_glojure_DOT_core_seq) - tmp111 := checkDerefVar(var_glojure_DOT_core_concat) - tmp112 := checkDerefVar(var_glojure_DOT_core_list) - tmp113 := lang.Apply(tmp112, []any{sym_glojure_DOT_core_SLASH_unchecked_DASH_inc}) - tmp114 := checkDerefVar(var_glojure_DOT_core_list) - tmp115 := lang.Apply(tmp114, []any{v6}) - tmp116 := lang.Apply(tmp111, []any{tmp113, tmp115}) - tmp117 := lang.Apply(tmp110, []any{tmp116}) - tmp118 := lang.Apply(tmp109, []any{tmp117}) - tmp119 := lang.Apply(tmp106, []any{tmp108, tmp118}) - tmp120 := lang.Apply(tmp105, []any{tmp119}) - tmp121 := lang.Apply(tmp104, []any{tmp120}) - tmp122 := lang.Apply(tmp87, []any{tmp89, tmp103, tmp121}) - tmp123 := lang.Apply(tmp86, []any{tmp122}) - tmp124 := lang.Apply(tmp85, []any{tmp123}) - tmp125 := checkDerefVar(var_glojure_DOT_core_list) - tmp126 := lang.Apply(tmp125, []any{v7}) - tmp127 := lang.Apply(tmp70, []any{tmp72, tmp84, tmp124, tmp126}) - tmp128 := lang.Apply(tmp69, []any{tmp127}) - tmp129 := lang.Apply(tmp68, []any{tmp128}) - tmp130 := lang.Apply(tmp52, []any{tmp54, tmp67, tmp129}) - tmp131 := lang.Apply(tmp51, []any{tmp130}) - tmp132 := lang.Apply(tmp50, []any{tmp131}) - tmp133 := lang.Apply(tmp10, []any{tmp12, tmp49, tmp132}) - tmp134 := lang.Apply(tmp9, []any{tmp133}) - return tmp134 + tmp0 := sym_symbol_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a Symbol", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(557), kw_end_DASH_line, int(557))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*lang.Symbol)(nil)) + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_symbol_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_symbol_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // ancestors + // system-newline { - tmp0 := sym_ancestors.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_tag), lang.NewVector(sym_h, sym_tag)), kw_doc, "Returns the immediate and indirect parents of tag, either via a Java type\n inheritance relationship or a relationship established via derive. h\n must be a hierarchy obtained from make-hierarchy, if not supplied\n defaults to the global hierarchy", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(5577), kw_end_DASH_line, int(5577))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_ancestors) - tmp5 := checkDerefVar(var_glojure_DOT_core_global_DASH_hierarchy) - tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) - return tmp6 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_not_DASH_empty) - var tmp6 any - { // let - // let binding "ta" - tmp7 := checkDerefVar(var_glojure_DOT_core_get) - tmp8 := lang.Apply(kw_ancestors, []any{v3}) - tmp9 := lang.Apply(tmp7, []any{tmp8, v4}) - var v10 any = tmp9 - _ = v10 - var tmp11 any - tmp12 := checkDerefVar(var_glojure_DOT_core_class_QMARK_) - tmp13 := lang.Apply(tmp12, []any{v4}) - if lang.IsTruthy(tmp13) { - var tmp14 any - { // let - // let binding "superclasses" - tmp15 := checkDerefVar(var_glojure_DOT_core_set) - tmp16 := checkDerefVar(var_glojure_DOT_core_supers) - tmp17 := lang.Apply(tmp16, []any{v4}) - tmp18 := lang.Apply(tmp15, []any{tmp17}) - var v19 any = tmp18 - _ = v19 - tmp20 := checkDerefVar(var_glojure_DOT_core_reduce1) - tmp21 := checkDerefVar(var_glojure_DOT_core_into1) - tmp22 := checkDerefVar(var_glojure_DOT_core_cons) - tmp23 := checkDerefVar(var_glojure_DOT_core_map) - var tmp24 lang.FnFunc - tmp24 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v25 := args[0] - _ = v25 - tmp26 := checkDerefVar(var_glojure_DOT_core_get) - tmp27 := lang.Apply(kw_ancestors, []any{v3}) - tmp28 := lang.Apply(tmp26, []any{tmp27, v25}) - return tmp28 - }) - tmp25 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5590), kw_column, int(32), kw_end_DASH_line, int(5590), kw_end_DASH_column, int(54)) - tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp27 := lang.Apply(tmp23, []any{tmp26, v19}) - tmp28 := lang.Apply(tmp22, []any{v10, tmp27}) - tmp29 := lang.Apply(tmp20, []any{tmp21, v19, tmp28}) - tmp14 = tmp29 - } // end let - tmp11 = tmp14 - } else { - tmp11 = v10 - } - tmp6 = tmp11 - } // end let - tmp7 := lang.Apply(tmp5, []any{tmp6}) - return tmp7 - default: - checkArity(args, -1) - panic("unreachable") - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp0 := sym_system_DASH_newline.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(3695), kw_column, int(6), kw_end_DASH_line, int(3695), kw_end_DASH_column, int(40), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core_system_DASH_newline = ns.InternWithValue(tmp0, "\n", true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_system_DASH_newline.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // and + // tagged-literal { - tmp0 := sym_and.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_x), lang.NewVector(sym_x, sym__AMP_, sym_next)), kw_doc, "Evaluates exprs one at a time, from left to right. If a form\n returns logical false (nil or false), and returns that value and\n doesn't evaluate any of the other expressions, otherwise it returns\n the value of the last expr. (and) returns true.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(11), kw_line, int(835), kw_end_DASH_line, int(835))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - return true - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - return v5 - default: - checkArity(args, 3) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - tmp7 := checkDerefVar(var_glojure_DOT_core_seq) - tmp8 := checkDerefVar(var_glojure_DOT_core_concat) - tmp9 := checkDerefVar(var_glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_core_SLASH_let}) - tmp11 := checkDerefVar(var_glojure_DOT_core_list) - tmp12 := checkDerefVar(var_glojure_DOT_core_apply) - tmp13 := checkDerefVar(var_glojure_DOT_core_vector) - tmp14 := checkDerefVar(var_glojure_DOT_core_seq) - tmp15 := checkDerefVar(var_glojure_DOT_core_concat) - tmp16 := checkDerefVar(var_glojure_DOT_core_list) - tmp17 := lang.Apply(tmp16, []any{sym_and__0__auto__}) - tmp18 := checkDerefVar(var_glojure_DOT_core_list) - tmp19 := lang.Apply(tmp18, []any{v5}) - tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) - tmp21 := lang.Apply(tmp14, []any{tmp20}) - tmp22 := lang.Apply(tmp12, []any{tmp13, tmp21}) - tmp23 := lang.Apply(tmp11, []any{tmp22}) - tmp24 := checkDerefVar(var_glojure_DOT_core_list) - tmp25 := checkDerefVar(var_glojure_DOT_core_seq) - tmp26 := checkDerefVar(var_glojure_DOT_core_concat) - tmp27 := checkDerefVar(var_glojure_DOT_core_list) - tmp28 := lang.Apply(tmp27, []any{sym_if}) - tmp29 := checkDerefVar(var_glojure_DOT_core_list) - tmp30 := lang.Apply(tmp29, []any{sym_and__0__auto__}) - tmp31 := checkDerefVar(var_glojure_DOT_core_list) - tmp32 := checkDerefVar(var_glojure_DOT_core_seq) - tmp33 := checkDerefVar(var_glojure_DOT_core_concat) - tmp34 := checkDerefVar(var_glojure_DOT_core_list) - tmp35 := lang.Apply(tmp34, []any{sym_glojure_DOT_core_SLASH_and}) - tmp36 := lang.Apply(tmp33, []any{tmp35, v6}) - tmp37 := lang.Apply(tmp32, []any{tmp36}) - tmp38 := lang.Apply(tmp31, []any{tmp37}) - tmp39 := checkDerefVar(var_glojure_DOT_core_list) - tmp40 := lang.Apply(tmp39, []any{sym_and__0__auto__}) - tmp41 := lang.Apply(tmp26, []any{tmp28, tmp30, tmp38, tmp40}) - tmp42 := lang.Apply(tmp25, []any{tmp41}) - tmp43 := lang.Apply(tmp24, []any{tmp42}) - tmp44 := lang.Apply(tmp8, []any{tmp10, tmp23, tmp43}) - tmp45 := lang.Apply(tmp7, []any{tmp44}) - return tmp45 - } + tmp0 := sym_tagged_DASH_literal.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_tag, sym_form)), kw_doc, "Construct a data representation of a tagged literal from a\n tag symbol and a form.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(7769), kw_end_DASH_line, int(7769))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := lang.Apply(nil, []any{v2, v3}) + return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_tagged_DASH_literal = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_tagged_DASH_literal.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // any? + // tagged-literal? { - tmp1 := reflect.TypeOf(false) - tmp0 := sym_any_QMARK_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true given any argument.", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(537), kw_end_DASH_line, int(537))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_tagged_DASH_literal_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_value)), kw_doc, "Return true if the value is the data representation of a tagged literal", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(7763), kw_end_DASH_line, int(7763))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v4 := args[0] - _ = v4 - return true + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := lang.Apply(tmp3, []any{nil, v2}) + return tmp4 }) - tmp4 := reflect.TypeOf(false) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_tagged_DASH_literal_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_tagged_DASH_literal_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // apply + // take-while { - tmp0 := sym_apply.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_args), lang.NewVector(sym_f, sym_x, sym_args), lang.NewVector(sym_f, sym_x, sym_y, sym_args), lang.NewVector(sym_f, sym_x, sym_y, sym_z, sym_args), lang.NewVector(sym_f, sym_a, sym_b, sym_c, sym_d, sym__AMP_, sym_args)), kw_doc, "Applies fn f to the argument list formed by prepending intervening arguments to args.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(653), kw_end_DASH_line, int(653))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_take_DASH_while.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred), lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns a lazy sequence of successive items from coll while\n (pred item) returns logical true. pred must be free of side-effects.\n Returns a transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(2880), kw_end_DASH_line, int(2880))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp6 := lang.Apply(v4, nil) + return tmp6 + case 1: + v6 := args[0] + _ = v6 + tmp7 := lang.Apply(v4, []any{v6}) + return tmp7 + case 2: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + var tmp8 any + tmp9 := lang.Apply(v2, []any{v7}) + if lang.IsTruthy(tmp9) { + tmp10 := lang.Apply(v4, []any{v6, v7}) + tmp8 = tmp10 + } else { + tmp11 := checkDerefVar(var_glojure_DOT_core_reduced) + tmp12 := lang.Apply(tmp11, []any{v6}) + tmp8 = tmp12 + } + return tmp8 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2888), kw_column, int(8), kw_end_DASH_line, int(2894), kw_end_DASH_column, int(33)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp7 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2887), kw_column, int(6), kw_end_DASH_line, int(2894), kw_end_DASH_column, int(34)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_seq) - tmp6 := lang.Apply(tmp5, []any{v4}) - tmp7 := lang.Apply(lang.Apply, []any{v3, tmp6}) - return tmp7 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6 := checkDerefVar(var_glojure_DOT_core_list_STAR_) - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - tmp8 := lang.Apply(lang.Apply, []any{v3, tmp7}) - return tmp8 - case 4: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - tmp7 := checkDerefVar(var_glojure_DOT_core_list_STAR_) - tmp8 := lang.Apply(tmp7, []any{v4, v5, v6}) - tmp9 := lang.Apply(lang.Apply, []any{v3, tmp8}) - return tmp9 - case 5: - v3 := args[0] + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - v7 := args[4] - _ = v7 - tmp8 := checkDerefVar(var_glojure_DOT_core_list_STAR_) - tmp9 := lang.Apply(tmp8, []any{v4, v5, v6, v7}) - tmp10 := lang.Apply(lang.Apply, []any{v3, tmp9}) - return tmp10 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp5 any + { // let + // let binding "temp__0__auto__" + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := lang.Apply(tmp6, []any{v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + var tmp10 any + { // let + // let binding "s" + var v11 any = v8 + _ = v11 + var tmp12 any + tmp13 := checkDerefVar(var_glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v11}) + tmp15 := lang.Apply(v2, []any{tmp14}) + if lang.IsTruthy(tmp15) { + tmp16 := checkDerefVar(var_glojure_DOT_core_cons) + tmp17 := checkDerefVar(var_glojure_DOT_core_first) + tmp18 := lang.Apply(tmp17, []any{v11}) + tmp19 := checkDerefVar(var_glojure_DOT_core_take_DASH_while) + tmp20 := checkDerefVar(var_glojure_DOT_core_rest) + tmp21 := lang.Apply(tmp20, []any{v11}) + tmp22 := lang.Apply(tmp19, []any{v2, tmp21}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp22}) + tmp12 = tmp23 + } else { + } + tmp10 = tmp12 + } // end let + tmp9 = tmp10 + } else { + } + tmp5 = tmp9 + } // end let + return tmp5 + }) + tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) + return tmp5 default: - checkArity(args, 5) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - v7 := args[4] - _ = v7 - var v8 any = lang.NewList(args[5:]...) - _ = v8 - tmp9 := checkDerefVar(var_glojure_DOT_core_cons) - tmp10 := checkDerefVar(var_glojure_DOT_core_cons) - tmp11 := checkDerefVar(var_glojure_DOT_core_cons) - tmp12 := checkDerefVar(var_glojure_DOT_core_cons) - tmp13 := checkDerefVar(var_glojure_DOT_core_spread) - tmp14 := lang.Apply(tmp13, []any{v8}) - tmp15 := lang.Apply(tmp12, []any{v7, tmp14}) - tmp16 := lang.Apply(tmp11, []any{v6, tmp15}) - tmp17 := lang.Apply(tmp10, []any{v5, tmp16}) - tmp18 := lang.Apply(tmp9, []any{v4, tmp17}) - tmp19 := lang.Apply(lang.Apply, []any{v3, tmp18}) - return tmp19 + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_take_DASH_while = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_take_DASH_while.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // areduce + // tapset { - tmp0 := sym_areduce.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_a, sym_idx, sym_ret, sym_init, sym_expr)), kw_doc, "Reduces an expression across an array a, using an index named idx,\n and return value named ret, initialized to init, setting ret to the \n evaluation of expr at each step, returning ret.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(5289), kw_end_DASH_line, int(5289))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 7) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - v7 := args[4] - _ = v7 - v8 := args[5] - _ = v8 - v9 := args[6] - _ = v9 - tmp10 := checkDerefVar(var_glojure_DOT_core_seq) - tmp11 := checkDerefVar(var_glojure_DOT_core_concat) - tmp12 := checkDerefVar(var_glojure_DOT_core_list) - tmp13 := lang.Apply(tmp12, []any{sym_glojure_DOT_core_SLASH_let}) - tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := checkDerefVar(var_glojure_DOT_core_apply) - tmp16 := checkDerefVar(var_glojure_DOT_core_vector) - tmp17 := checkDerefVar(var_glojure_DOT_core_seq) - tmp18 := checkDerefVar(var_glojure_DOT_core_concat) - tmp19 := checkDerefVar(var_glojure_DOT_core_list) - tmp20 := lang.Apply(tmp19, []any{sym_a__0__auto__}) - tmp21 := checkDerefVar(var_glojure_DOT_core_list) - tmp22 := lang.Apply(tmp21, []any{v5}) - tmp23 := checkDerefVar(var_glojure_DOT_core_list) - tmp24 := lang.Apply(tmp23, []any{sym_l__1__auto__}) - tmp25 := checkDerefVar(var_glojure_DOT_core_list) - tmp26 := checkDerefVar(var_glojure_DOT_core_seq) - tmp27 := checkDerefVar(var_glojure_DOT_core_concat) - tmp28 := checkDerefVar(var_glojure_DOT_core_list) - tmp29 := lang.Apply(tmp28, []any{sym_glojure_DOT_core_SLASH_alength}) - tmp30 := checkDerefVar(var_glojure_DOT_core_list) - tmp31 := lang.Apply(tmp30, []any{sym_a__0__auto__}) - tmp32 := lang.Apply(tmp27, []any{tmp29, tmp31}) - tmp33 := lang.Apply(tmp26, []any{tmp32}) - tmp34 := lang.Apply(tmp25, []any{tmp33}) - tmp35 := lang.Apply(tmp18, []any{tmp20, tmp22, tmp24, tmp34}) - tmp36 := lang.Apply(tmp17, []any{tmp35}) - tmp37 := lang.Apply(tmp15, []any{tmp16, tmp36}) - tmp38 := lang.Apply(tmp14, []any{tmp37}) - tmp39 := checkDerefVar(var_glojure_DOT_core_list) - tmp40 := checkDerefVar(var_glojure_DOT_core_seq) - tmp41 := checkDerefVar(var_glojure_DOT_core_concat) - tmp42 := checkDerefVar(var_glojure_DOT_core_list) - tmp43 := lang.Apply(tmp42, []any{sym_glojure_DOT_core_SLASH_loop}) - tmp44 := checkDerefVar(var_glojure_DOT_core_list) - tmp45 := checkDerefVar(var_glojure_DOT_core_apply) - tmp46 := checkDerefVar(var_glojure_DOT_core_vector) - tmp47 := checkDerefVar(var_glojure_DOT_core_seq) - tmp48 := checkDerefVar(var_glojure_DOT_core_concat) - tmp49 := checkDerefVar(var_glojure_DOT_core_list) - tmp50 := lang.Apply(tmp49, []any{v6}) - tmp51 := checkDerefVar(var_glojure_DOT_core_list) - tmp52 := lang.Apply(tmp51, []any{int64(0)}) - tmp53 := checkDerefVar(var_glojure_DOT_core_list) - tmp54 := lang.Apply(tmp53, []any{v7}) - tmp55 := checkDerefVar(var_glojure_DOT_core_list) - tmp56 := lang.Apply(tmp55, []any{v8}) - tmp57 := lang.Apply(tmp48, []any{tmp50, tmp52, tmp54, tmp56}) - tmp58 := lang.Apply(tmp47, []any{tmp57}) - tmp59 := lang.Apply(tmp45, []any{tmp46, tmp58}) - tmp60 := lang.Apply(tmp44, []any{tmp59}) - tmp61 := checkDerefVar(var_glojure_DOT_core_list) - tmp62 := checkDerefVar(var_glojure_DOT_core_seq) - tmp63 := checkDerefVar(var_glojure_DOT_core_concat) - tmp64 := checkDerefVar(var_glojure_DOT_core_list) - tmp65 := lang.Apply(tmp64, []any{sym_if}) - tmp66 := checkDerefVar(var_glojure_DOT_core_list) - tmp67 := checkDerefVar(var_glojure_DOT_core_seq) - tmp68 := checkDerefVar(var_glojure_DOT_core_concat) - tmp69 := checkDerefVar(var_glojure_DOT_core_list) - tmp70 := lang.Apply(tmp69, []any{sym_glojure_DOT_core_SLASH__LT_}) - tmp71 := checkDerefVar(var_glojure_DOT_core_list) - tmp72 := lang.Apply(tmp71, []any{v6}) - tmp73 := checkDerefVar(var_glojure_DOT_core_list) - tmp74 := lang.Apply(tmp73, []any{sym_l__1__auto__}) - tmp75 := lang.Apply(tmp68, []any{tmp70, tmp72, tmp74}) - tmp76 := lang.Apply(tmp67, []any{tmp75}) - tmp77 := lang.Apply(tmp66, []any{tmp76}) - tmp78 := checkDerefVar(var_glojure_DOT_core_list) - tmp79 := checkDerefVar(var_glojure_DOT_core_seq) - tmp80 := checkDerefVar(var_glojure_DOT_core_concat) - tmp81 := checkDerefVar(var_glojure_DOT_core_list) - tmp82 := lang.Apply(tmp81, []any{sym_recur}) - tmp83 := checkDerefVar(var_glojure_DOT_core_list) - tmp84 := checkDerefVar(var_glojure_DOT_core_seq) - tmp85 := checkDerefVar(var_glojure_DOT_core_concat) - tmp86 := checkDerefVar(var_glojure_DOT_core_list) - tmp87 := lang.Apply(tmp86, []any{sym_glojure_DOT_core_SLASH_unchecked_DASH_inc_DASH_int}) - tmp88 := checkDerefVar(var_glojure_DOT_core_list) - tmp89 := lang.Apply(tmp88, []any{v6}) - tmp90 := lang.Apply(tmp85, []any{tmp87, tmp89}) - tmp91 := lang.Apply(tmp84, []any{tmp90}) - tmp92 := lang.Apply(tmp83, []any{tmp91}) - tmp93 := checkDerefVar(var_glojure_DOT_core_list) - tmp94 := lang.Apply(tmp93, []any{v9}) - tmp95 := lang.Apply(tmp80, []any{tmp82, tmp92, tmp94}) - tmp96 := lang.Apply(tmp79, []any{tmp95}) - tmp97 := lang.Apply(tmp78, []any{tmp96}) - tmp98 := checkDerefVar(var_glojure_DOT_core_list) - tmp99 := lang.Apply(tmp98, []any{v7}) - tmp100 := lang.Apply(tmp63, []any{tmp65, tmp77, tmp97, tmp99}) - tmp101 := lang.Apply(tmp62, []any{tmp100}) - tmp102 := lang.Apply(tmp61, []any{tmp101}) - tmp103 := lang.Apply(tmp41, []any{tmp43, tmp60, tmp102}) - tmp104 := lang.Apply(tmp40, []any{tmp103}) - tmp105 := lang.Apply(tmp39, []any{tmp104}) - tmp106 := lang.Apply(tmp11, []any{tmp13, tmp38, tmp105}) - tmp107 := lang.Apply(tmp10, []any{tmp106}) - return tmp107 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp0 := sym_tapset.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(7882), kw_column, int(10), kw_end_DASH_line, int(7882), kw_end_DASH_column, int(25), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + tmp1 := lang.NewAtom(lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{}))) + var_glojure_DOT_core_tapset = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_tapset.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // array + // test { - tmp0 := sym_array.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(3457), kw_column, int(7), kw_end_DASH_line, int(3458), kw_end_DASH_column, int(7), kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_items)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 0) - var v3 any = lang.NewList(args[0:]...) - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_into_DASH_array) - tmp5 := lang.Apply(tmp4, []any{v3}) - return tmp5 - } + tmp0 := sym_test.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_v)), kw_doc, "test [v] finds fn at key :test in var metadata and calls it,\n presuming failure will throw exception", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(4853), kw_end_DASH_line, int(4853))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "f" + tmp4 := checkDerefVar(var_glojure_DOT_core_meta) + tmp5 := lang.Apply(tmp4, []any{v2}) + tmp6 := lang.Apply(kw_test, []any{tmp5}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + if lang.IsTruthy(v7) { + tmp9 := lang.Apply(v7, nil) + _ = tmp9 + tmp8 = kw_ok + } else { + tmp8 = kw_no_DASH_test + } + tmp3 = tmp8 + } // end let + return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_test = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_test.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // array-map + // the-ns { - tmp0 := sym_array_DASH_map.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym__AMP_, sym_keyvals)), kw_doc, "Constructs an array-map. If any keys are equal, they are handled as\n if by repeated uses of assoc.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(4378), kw_end_DASH_line, int(4378))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp3, ok := lang.FieldOrMethod(nil, "EMPTY") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "EMPTY"))) - } - var tmp4 any - switch reflect.TypeOf(tmp3).Kind() { - case reflect.Func: - tmp4 = lang.Apply(tmp3, nil) - default: - tmp4 = tmp3 - } - return tmp4 - default: - checkArity(args, 0) - var v3 any = lang.NewList(args[0:]...) - _ = v3 - var tmp4 any + tmp0 := sym_the_DASH_ns.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "If passed a namespace, returns it. Else, when passed a symbol,\n returns the namespace named by it, throwing an exception if not\n found.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(4152), kw_end_DASH_line, int(4152))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := reflect.TypeOf((*lang.Namespace)(nil)) + tmp6 := lang.Apply(tmp4, []any{tmp5, v2}) + if lang.IsTruthy(tmp6) { + tmp3 = v2 + } else { + var tmp7 any { // let - // let binding "ary" - tmp5 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) - tmp6 := lang.Apply(tmp5, []any{v3}) - var v7 any = tmp6 - _ = v7 - var tmp8 any - tmp9 := checkDerefVar(var_glojure_DOT_core_odd_QMARK_) - tmp10 := checkDerefVar(var_glojure_DOT_core_alength) - tmp11 := lang.Apply(tmp10, []any{v7}) - tmp12 := lang.Apply(tmp9, []any{tmp11}) - if lang.IsTruthy(tmp12) { - tmp13 := checkDerefVar(var_glojure_DOT_core_str) - tmp14 := checkDerefVar(var_glojure_DOT_core_last) - tmp15 := lang.Apply(tmp14, []any{v3}) - tmp16 := lang.Apply(tmp13, []any{"No value supplied for key: ", tmp15}) - tmp17 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp16}) - panic(tmp17) + // let binding "or__0__auto__" + tmp8 := checkDerefVar(var_glojure_DOT_core_find_DASH_ns) + tmp9 := lang.Apply(tmp8, []any{v2}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + if lang.IsTruthy(v10) { + tmp11 = v10 } else { - tmp18 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{v7}) - tmp8 = tmp18 + tmp12 := checkDerefVar(var_glojure_DOT_core_str) + tmp13 := lang.Apply(tmp12, []any{"No namespace: ", v2, " found"}) + tmp14 := lang.Apply(lang.NewError, []any{tmp13}) + panic(tmp14) } - tmp4 = tmp8 + tmp7 = tmp11 } // end let - return tmp4 + tmp3 = tmp7 } + return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_the_DASH_ns = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_the_DASH_ns.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // as-> + // to-array { - tmp0 := sym_as_DASH__GT_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_expr, sym_name, sym__AMP_, sym_forms)), kw_doc, "Binds name to expr, evaluates the first form in the lexical context\n of that binding, then binds name to that result, repeating for each\n successive form, returning the result of the last form.", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(11), kw_line, int(7598), kw_end_DASH_line, int(7598))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 4) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - var v7 any = lang.NewList(args[4:]...) - _ = v7 - tmp8 := checkDerefVar(var_glojure_DOT_core_seq) - tmp9 := checkDerefVar(var_glojure_DOT_core_concat) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_let}) - tmp12 := checkDerefVar(var_glojure_DOT_core_list) - tmp13 := checkDerefVar(var_glojure_DOT_core_apply) - tmp14 := checkDerefVar(var_glojure_DOT_core_vector) - tmp15 := checkDerefVar(var_glojure_DOT_core_seq) - tmp16 := checkDerefVar(var_glojure_DOT_core_concat) - tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{v6}) - tmp19 := checkDerefVar(var_glojure_DOT_core_list) - tmp20 := lang.Apply(tmp19, []any{v5}) - tmp21 := checkDerefVar(var_glojure_DOT_core_interleave) - tmp22 := checkDerefVar(var_glojure_DOT_core_repeat) - tmp23 := lang.Apply(tmp22, []any{v6}) - tmp24 := checkDerefVar(var_glojure_DOT_core_butlast) - tmp25 := lang.Apply(tmp24, []any{v7}) - tmp26 := lang.Apply(tmp21, []any{tmp23, tmp25}) - tmp27 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp26}) - tmp28 := lang.Apply(tmp15, []any{tmp27}) - tmp29 := lang.Apply(tmp13, []any{tmp14, tmp28}) - tmp30 := lang.Apply(tmp12, []any{tmp29}) - tmp31 := checkDerefVar(var_glojure_DOT_core_list) - var tmp32 any - tmp33 := checkDerefVar(var_glojure_DOT_core_empty_QMARK_) - tmp34 := lang.Apply(tmp33, []any{v7}) - if lang.IsTruthy(tmp34) { - tmp32 = v6 - } else { - tmp35 := checkDerefVar(var_glojure_DOT_core_last) - tmp36 := lang.Apply(tmp35, []any{v7}) - tmp32 = tmp36 - } - tmp37 := lang.Apply(tmp31, []any{tmp32}) - tmp38 := lang.Apply(tmp9, []any{tmp11, tmp30, tmp37}) - tmp39 := lang.Apply(tmp8, []any{tmp38}) - return tmp39 + tmp0 := sym_to_DASH_array.WithMeta(lang.NewMap(kw_tag, "[Ljava.lang.Object;", kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns an array of Objects containing the contents of coll, which\n can be any Collection. Maps to java.util.Collection.toArray().", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(337), kw_end_DASH_line, int(337))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(runtime.RT, "ToArray") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ToArray is not a function"))) } + tmp4 := lang.Apply(tmp3, []any{v2}) + return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, "[Ljava.lang.Object;")).(lang.FnFunc) + var_glojure_DOT_core_to_DASH_array = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_to_DASH_array.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // aset + // transient { + tmp0 := sym_transient.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a new, transient version of the collection, in constant time.\n\n Transients support a parallel set of 'changing' operations, with similar names\n followed by ! - assoc!, conj! etc. These do the same things as their persistent\n counterparts except the return values are themselves transient.\n\n Note in particular that transients are not designed to be bashed in-place. You\n must capture and use the return value in the next call. In this way, they support\n the same code structure as the functional persistent code they replace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(3335), kw_end_DASH_line, int(3335))).(*lang.Symbol) var tmp1 lang.FnFunc - { // function aset__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 3) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6 := checkDerefVar(var_glojure_DOT_core_seq) - tmp7 := checkDerefVar(var_glojure_DOT_core_concat) - tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{sym__DOT_}) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) - tmp12 := checkDerefVar(var_glojure_DOT_core_list) - tmp13 := checkDerefVar(var_glojure_DOT_core_seq) - tmp14 := checkDerefVar(var_glojure_DOT_core_concat) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_Aset}) - tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{v3}) - tmp19 := checkDerefVar(var_glojure_DOT_core_list) - tmp20 := checkDerefVar(var_glojure_DOT_core_seq) - tmp21 := checkDerefVar(var_glojure_DOT_core_concat) - tmp22 := checkDerefVar(var_glojure_DOT_core_list) - tmp23 := lang.Apply(tmp22, []any{sym_glojure_DOT_core_SLASH_int}) - tmp24 := checkDerefVar(var_glojure_DOT_core_list) - tmp25 := lang.Apply(tmp24, []any{v4}) - tmp26 := lang.Apply(tmp21, []any{tmp23, tmp25}) - tmp27 := lang.Apply(tmp20, []any{tmp26}) - tmp28 := lang.Apply(tmp19, []any{tmp27}) - tmp29 := checkDerefVar(var_glojure_DOT_core_list) - tmp30 := lang.Apply(tmp29, []any{v5}) - tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp28, tmp30}) - tmp32 := lang.Apply(tmp13, []any{tmp31}) - tmp33 := lang.Apply(tmp12, []any{tmp32}) - tmp34 := lang.Apply(tmp7, []any{tmp9, tmp11, tmp33}) - tmp35 := lang.Apply(tmp6, []any{tmp34}) - return tmp35 - }) - v2 = tmp1 + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] _ = v2 - } - tmp0 := sym_aset.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx, sym_val), lang.NewVector(sym_array, sym_idx, sym_idx2, sym__AMP_, sym_idxv)), kw_inline, tmp1, kw_doc, "Sets the value at the index/indices. Works on Java arrays of\n reference types. Returns val.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(3)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3922), kw_end_DASH_line, int(3922))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 3: - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - v6 := args[2] - _ = v6 - tmp7 := lang.Apply(lang.SliceSet, []any{v4, v5, v6}) - _ = tmp7 - return v6 + tmp3, ok := lang.FieldOrMethod(v2, "AsTransient") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "AsTransient"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) default: - checkArity(args, 3) - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - v6 := args[2] - _ = v6 - var v7 any = lang.NewList(args[3:]...) - _ = v7 - tmp8 := checkDerefVar(var_glojure_DOT_core_apply) - tmp9 := checkDerefVar(var_glojure_DOT_core_aset) - tmp10 := checkDerefVar(var_glojure_DOT_core_aget) - tmp11 := lang.Apply(tmp10, []any{v4, v5}) - tmp12 := lang.Apply(tmp8, []any{tmp9, tmp11, v6, v7}) - return tmp12 + tmp4 = tmp3 } + return tmp4 }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_transient = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_transient.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // aset-boolean + // true? { - tmp0 := sym_aset_DASH_boolean.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx, sym_val), lang.NewVector(sym_array, sym_idx, sym_idx2, sym__AMP_, sym_idxv)), kw_doc, "Sets the value at the index/indices. Works on arrays of boolean. Returns val.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(3), kw_line, int(3956), kw_end_DASH_line, int(3958))).(*lang.Symbol) + tmp1 := reflect.TypeOf(false) + tmp0 := sym_true_QMARK_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x is the value true, false otherwise.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(511), kw_end_DASH_line, int(511))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6 := checkDerefVar(var_glojure_DOT_core_boolean) - tmp7 := lang.Apply(tmp6, []any{v5}) - tmp8, _ := lang.FieldOrMethod(nil, "setBoolean") - if reflect.TypeOf(tmp8).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setBoolean is not a function"))) - } - tmp9 := lang.Apply(tmp8, []any{v3, v4, tmp7}) - _ = tmp9 - return v5 - default: - checkArity(args, 3) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - tmp7 := checkDerefVar(var_glojure_DOT_core_apply) - tmp8 := checkDerefVar(var_glojure_DOT_core_aset_DASH_boolean) - tmp9 := checkDerefVar(var_glojure_DOT_core_aget) - tmp10 := lang.Apply(tmp9, []any{v3, v4}) - tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v5, v6}) - return tmp11 - } + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.Identical, []any{v3, true}) + return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp3 := reflect.TypeOf(false) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_true_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_true_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // aset-byte + // unquote { - tmp0 := sym_aset_DASH_byte.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx, sym_val), lang.NewVector(sym_array, sym_idx, sym_idx2, sym__AMP_, sym_idxv)), kw_doc, "Sets the value at the index/indices. Works on arrays of byte. Returns val.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(3), kw_line, int(3976), kw_end_DASH_line, int(3978))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6 := checkDerefVar(var_glojure_DOT_core_byte) - tmp7 := lang.Apply(tmp6, []any{v5}) - tmp8, _ := lang.FieldOrMethod(nil, "setByte") - if reflect.TypeOf(tmp8).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setByte is not a function"))) - } - tmp9 := lang.Apply(tmp8, []any{v3, v4, tmp7}) - _ = tmp9 - return v5 - default: - checkArity(args, 3) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - tmp7 := checkDerefVar(var_glojure_DOT_core_apply) - tmp8 := checkDerefVar(var_glojure_DOT_core_aset_DASH_byte) - tmp9 := checkDerefVar(var_glojure_DOT_core_aget) - tmp10 := lang.Apply(tmp9, []any{v3, v4}) - tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v5, v6}) - return tmp11 + tmp0 := sym_unquote.WithMeta(lang.NewMap()).(*lang.Symbol) + var_glojure_DOT_core_unquote = ns.Intern(tmp0) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unquote.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unquote-splicing + { + tmp0 := sym_unquote_DASH_splicing.WithMeta(lang.NewMap()).(*lang.Symbol) + var_glojure_DOT_core_unquote_DASH_splicing = ns.Intern(tmp0) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unquote_DASH_splicing.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // uri? + { + tmp0 := sym_uri_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a java.net.URI", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(7877), kw_end_DASH_line, int(7877))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*url5.URL)(nil)).Elem() + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_uri_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_uri_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // uuid? + { + tmp0 := sym_uuid_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a java.util.UUID", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(6847), kw_end_DASH_line, int(6847))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf([16]uint8{}) + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_uuid_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_uuid_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // val + { + tmp0 := sym_val.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_e)), kw_doc, "Returns the value in the map entry.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(1570), kw_end_DASH_line, int(1570))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(v2, "GetValue") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("GetValue is not a function"))) } + tmp4 := lang.Apply(tmp3, []any{}) + return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_val = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_val.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // aset-char + // vals { - tmp0 := sym_aset_DASH_char.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx, sym_val), lang.NewVector(sym_array, sym_idx, sym_idx2, sym__AMP_, sym_idxv)), kw_doc, "Sets the value at the index/indices. Works on arrays of char. Returns val.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(3), kw_line, int(3981), kw_end_DASH_line, int(3983))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6 := checkDerefVar(var_glojure_DOT_core_char) - tmp7 := lang.Apply(tmp6, []any{v5}) - tmp8, _ := lang.FieldOrMethod(nil, "setChar") - if reflect.TypeOf(tmp8).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setChar is not a function"))) - } - tmp9 := lang.Apply(tmp8, []any{v3, v4, tmp7}) - _ = tmp9 - return v5 - default: - checkArity(args, 3) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - tmp7 := checkDerefVar(var_glojure_DOT_core_apply) - tmp8 := checkDerefVar(var_glojure_DOT_core_aset_DASH_char) - tmp9 := checkDerefVar(var_glojure_DOT_core_aget) - tmp10 := lang.Apply(tmp9, []any{v3, v4}) - tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v5, v6}) - return tmp11 + tmp0 := sym_vals.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_map)), kw_doc, "Returns a sequence of the map's values, in the same order as (seq map).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1557), kw_end_DASH_line, int(1557))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(lang.Vals, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_vals = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_vals.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // var-get + { + tmp0 := sym_var_DASH_get.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Gets the value in the var object", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4326), kw_end_DASH_line, int(4326))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(v2, "Get") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Get is not a function"))) } + tmp4 := lang.Apply(tmp3, []any{}) + return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_var_DASH_get = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_var_DASH_get.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // aset-double + // var-set { - tmp0 := sym_aset_DASH_double.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx, sym_val), lang.NewVector(sym_array, sym_idx, sym_idx2, sym__AMP_, sym_idxv)), kw_doc, "Sets the value at the index/indices. Works on arrays of double. Returns val.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(3), kw_line, int(3966), kw_end_DASH_line, int(3968))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6 := checkDerefVar(var_glojure_DOT_core_double) - tmp7 := lang.Apply(tmp6, []any{v5}) - tmp8, _ := lang.FieldOrMethod(nil, "setDouble") - if reflect.TypeOf(tmp8).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setDouble is not a function"))) - } - tmp9 := lang.Apply(tmp8, []any{v3, v4, tmp7}) - _ = tmp9 - return v5 - default: - checkArity(args, 3) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - tmp7 := checkDerefVar(var_glojure_DOT_core_apply) - tmp8 := checkDerefVar(var_glojure_DOT_core_aset_DASH_double) - tmp9 := checkDerefVar(var_glojure_DOT_core_aget) - tmp10 := lang.Apply(tmp9, []any{v3, v4}) - tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v5, v6}) - return tmp11 + tmp0 := sym_var_DASH_set.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_val)), kw_doc, "Sets the value in the var object to val. The var must be\n thread-locally bound.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4332), kw_end_DASH_line, int(4332))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "Set") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Set is not a function"))) } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_var_DASH_set = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_var_DASH_set.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // aset-float + // var? { - tmp0 := sym_aset_DASH_float.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx, sym_val), lang.NewVector(sym_array, sym_idx, sym_idx2, sym__AMP_, sym_idxv)), kw_doc, "Sets the value at the index/indices. Works on arrays of float. Returns val.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(3), kw_line, int(3961), kw_end_DASH_line, int(3963))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_var_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_v)), kw_doc, "Returns true if v is of type glojure.lang.Var", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(4999), kw_end_DASH_line, int(4999))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*lang.Var)(nil)) + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_var_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_var_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // vector + { + tmp0 := sym_vector.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_a), lang.NewVector(sym_a, sym_b), lang.NewVector(sym_a, sym_b, sym_c), lang.NewVector(sym_a, sym_b, sym_c, sym_d), lang.NewVector(sym_a, sym_b, sym_c, sym_d, sym_e), lang.NewVector(sym_a, sym_b, sym_c, sym_d, sym_e, sym_f), lang.NewVector(sym_a, sym_b, sym_c, sym_d, sym_e, sym_f, sym__AMP_, sym_args)), kw_doc, "Creates a new vector containing the args.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(352), kw_end_DASH_line, int(352))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { + case 0: + tmp2 := lang.NewVector() + tmp3 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(356), kw_column, int(7), kw_end_DASH_line, int(356), kw_end_DASH_column, int(8)) + tmp4, err := lang.WithMeta(tmp2, tmp3.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp4 + case 1: + v2 := args[0] + _ = v2 + tmp3 := lang.NewVector(v2) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(357), kw_column, int(8), kw_end_DASH_line, int(357), kw_end_DASH_column, int(10)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := lang.NewVector(v2, v3) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(358), kw_column, int(10), kw_end_DASH_line, int(358), kw_end_DASH_column, int(14)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 case 3: - v3 := args[0] + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + v4 := args[2] _ = v4 - v5 := args[2] + tmp5 := lang.NewVector(v2, v3, v4) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(359), kw_column, int(12), kw_end_DASH_line, int(359), kw_end_DASH_column, int(18)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp7 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] _ = v5 - tmp6 := checkDerefVar(var_glojure_DOT_core_float) - tmp7 := lang.Apply(tmp6, []any{v5}) - tmp8, _ := lang.FieldOrMethod(nil, "setFloat") - if reflect.TypeOf(tmp8).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setFloat is not a function"))) + tmp6 := lang.NewVector(v2, v3, v4, v5) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(360), kw_column, int(14), kw_end_DASH_line, int(360), kw_end_DASH_column, int(22)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) } - tmp9 := lang.Apply(tmp8, []any{v3, v4, tmp7}) - _ = tmp9 - return v5 - default: - checkArity(args, 3) - v3 := args[0] + return tmp8 + case 5: + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + v4 := args[2] _ = v4 - v5 := args[2] + v5 := args[3] _ = v5 - var v6 any = lang.NewList(args[3:]...) + v6 := args[4] _ = v6 - tmp7 := checkDerefVar(var_glojure_DOT_core_apply) - tmp8 := checkDerefVar(var_glojure_DOT_core_aset_DASH_float) - tmp9 := checkDerefVar(var_glojure_DOT_core_aget) - tmp10 := lang.Apply(tmp9, []any{v3, v4}) - tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v5, v6}) - return tmp11 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // aset-int - { - tmp0 := sym_aset_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx, sym_val), lang.NewVector(sym_array, sym_idx, sym_idx2, sym__AMP_, sym_idxv)), kw_doc, "Sets the value at the index/indices. Works on arrays of int. Returns val.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(3), kw_line, int(3946), kw_end_DASH_line, int(3948))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 3: - v3 := args[0] + tmp7 := lang.NewVector(v2, v3, v4, v5, v6) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(361), kw_column, int(15), kw_end_DASH_line, int(361), kw_end_DASH_column, int(25)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp9 + case 6: + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + v4 := args[2] _ = v4 - v5 := args[2] + v5 := args[3] _ = v5 - tmp6 := checkDerefVar(var_glojure_DOT_core_int) - tmp7 := lang.Apply(tmp6, []any{v5}) - tmp8, _ := lang.FieldOrMethod(nil, "setInt") - if reflect.TypeOf(tmp8).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setInt is not a function"))) + v6 := args[4] + _ = v6 + v7 := args[5] + _ = v7 + tmp8 := lang.NewVector(v2, v3, v4, v5, v6, v7) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(362), kw_column, int(17), kw_end_DASH_line, int(362), kw_end_DASH_column, int(29)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) } - tmp9 := lang.Apply(tmp8, []any{v3, v4, tmp7}) - _ = tmp9 - return v5 + return tmp10 default: - checkArity(args, 3) - v3 := args[0] + checkArity(args, 6) + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + v4 := args[2] _ = v4 - v5 := args[2] + v5 := args[3] _ = v5 - var v6 any = lang.NewList(args[3:]...) + v6 := args[4] _ = v6 - tmp7 := checkDerefVar(var_glojure_DOT_core_apply) - tmp8 := checkDerefVar(var_glojure_DOT_core_aset_DASH_int) - tmp9 := checkDerefVar(var_glojure_DOT_core_aget) - tmp10 := lang.Apply(tmp9, []any{v3, v4}) - tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v5, v6}) - return tmp11 + v7 := args[5] + _ = v7 + var v8 any = lang.NewList(args[6:]...) + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_cons) + tmp10 := checkDerefVar(var_glojure_DOT_core_cons) + tmp11 := checkDerefVar(var_glojure_DOT_core_cons) + tmp12 := checkDerefVar(var_glojure_DOT_core_cons) + tmp13 := checkDerefVar(var_glojure_DOT_core_cons) + tmp14 := checkDerefVar(var_glojure_DOT_core_cons) + tmp15 := lang.Apply(tmp14, []any{v7, v8}) + tmp16 := lang.Apply(tmp13, []any{v6, tmp15}) + tmp17 := lang.Apply(tmp12, []any{v5, tmp16}) + tmp18 := lang.Apply(tmp11, []any{v4, tmp17}) + tmp19 := lang.Apply(tmp10, []any{v3, tmp18}) + tmp20 := lang.Apply(tmp9, []any{v2, tmp19}) + tmp21 := lang.Apply(lang.CreateLazilyPersistentVector, []any{tmp20}) + return tmp21 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_vector = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_vector.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // aset-long + // vector? { - tmp0 := sym_aset_DASH_long.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx, sym_val), lang.NewVector(sym_array, sym_idx, sym_idx2, sym__AMP_, sym_idxv)), kw_doc, "Sets the value at the index/indices. Works on arrays of long. Returns val.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(3), kw_line, int(3951), kw_end_DASH_line, int(3953))).(*lang.Symbol) + tmp0 := sym_vector_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x implements IPersistentVector", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(2), kw_line, int(174), kw_end_DASH_line, int(178))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function vector? + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := reflect.TypeOf((*lang.IPersistentVector)(nil)).Elem() + tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(178), kw_column, int(10), kw_end_DASH_line, int(178), kw_end_DASH_column, int(106))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_vector_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_vector_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // volatile! + { + tmp1 := reflect.TypeOf((*lang.Volatile)(nil)).Elem() + tmp0 := sym_volatile_BANG_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_val)), kw_doc, "Creates and returns a Volatile with an initial value of val.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(2517), kw_end_DASH_line, int(2517))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.NewVolatile, []any{v3}) + return tmp4 + }) + tmp3 := reflect.TypeOf((*lang.Volatile)(nil)).Elem() + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_volatile_BANG_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_volatile_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // volatile? + { + tmp0 := sym_volatile_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x is a volatile.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(2540), kw_end_DASH_line, int(2540))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*lang.Volatile)(nil)).Elem() + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_volatile_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_volatile_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // vreset! + { + tmp0 := sym_vreset_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_vol, sym_newval)), kw_doc, "Sets the value of volatile to newval without regard for the\n current value. Returns newval.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(2524), kw_end_DASH_line, int(2524))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "reset") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_vreset_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_vreset_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // when + { + tmp0 := sym_when.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_test, sym__AMP_, sym_body)), kw_doc, "Evaluates test. If logical true, evaluates body in an implicit do.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(11), kw_line, int(492), kw_end_DASH_line, int(492))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6 := checkDerefVar(var_glojure_DOT_core_long) - tmp7 := lang.Apply(tmp6, []any{v5}) - tmp8, _ := lang.FieldOrMethod(nil, "setLong") - if reflect.TypeOf(tmp8).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setLong is not a function"))) - } - tmp9 := lang.Apply(tmp8, []any{v3, v4, tmp7}) - _ = tmp9 - return v5 default: checkArity(args, 3) - v3 := args[0] + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + v4 := args[2] _ = v4 - v5 := args[2] + var v5 any = lang.NewList(args[3:]...) _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - tmp7 := checkDerefVar(var_glojure_DOT_core_apply) - tmp8 := checkDerefVar(var_glojure_DOT_core_aset_DASH_long) - tmp9 := checkDerefVar(var_glojure_DOT_core_aget) - tmp10 := lang.Apply(tmp9, []any{v3, v4}) - tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v5, v6}) - return tmp11 + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := checkDerefVar(var_glojure_DOT_core_cons) + tmp8 := lang.Apply(tmp7, []any{sym_do, v5}) + tmp9 := lang.Apply(tmp6, []any{sym_if, v4, tmp8}) + return tmp9 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_when = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_when.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // aset-short + // when-not { - tmp0 := sym_aset_DASH_short.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx, sym_val), lang.NewVector(sym_array, sym_idx, sym_idx2, sym__AMP_, sym_idxv)), kw_doc, "Sets the value at the index/indices. Works on arrays of short. Returns val.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(3), kw_line, int(3971), kw_end_DASH_line, int(3973))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_when_DASH_not.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_test, sym__AMP_, sym_body)), kw_doc, "Evaluates test. If logical false, evaluates body in an implicit do.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(11), kw_line, int(498), kw_end_DASH_line, int(498))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6 := checkDerefVar(var_glojure_DOT_core_short) - tmp7 := lang.Apply(tmp6, []any{v5}) - tmp8, _ := lang.FieldOrMethod(nil, "setShort") - if reflect.TypeOf(tmp8).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setShort is not a function"))) - } - tmp9 := lang.Apply(tmp8, []any{v3, v4, tmp7}) - _ = tmp9 - return v5 default: checkArity(args, 3) - v3 := args[0] + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + v4 := args[2] _ = v4 - v5 := args[2] + var v5 any = lang.NewList(args[3:]...) _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - tmp7 := checkDerefVar(var_glojure_DOT_core_apply) - tmp8 := checkDerefVar(var_glojure_DOT_core_aset_DASH_short) - tmp9 := checkDerefVar(var_glojure_DOT_core_aget) - tmp10 := lang.Apply(tmp9, []any{v3, v4}) - tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v5, v6}) - return tmp11 + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := checkDerefVar(var_glojure_DOT_core_cons) + tmp8 := lang.Apply(tmp7, []any{sym_do, v5}) + tmp9 := lang.Apply(tmp6, []any{sym_if, v4, nil, tmp8}) + return tmp9 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_when_DASH_not = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_when_DASH_not.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // assert + // with-meta { - tmp0 := sym_assert.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_message)), kw_doc, "Evaluates expression x and throws an AssertionError with optional\n message if x does not evaluate to logical true.\n\n Assertion checks are omitted from compiled code if '*assert*' is\n false.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(11), kw_line, int(4837), kw_end_DASH_line, int(4837))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 3: + tmp0 := sym_with_DASH_meta.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_obj, sym_m)), kw_doc, "Returns an object of the same type and value as obj, with\n map m as its metadata.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(2), kw_line, int(211), kw_end_DASH_line, int(216))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function with-meta + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 - v5 := args[2] - _ = v5 - var tmp6 any - tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_assert_STAR_) - if lang.IsTruthy(tmp7) { - tmp8 := checkDerefVar(var_glojure_DOT_core_seq) - tmp9 := checkDerefVar(var_glojure_DOT_core_concat) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_when_DASH_not}) - tmp12 := checkDerefVar(var_glojure_DOT_core_list) - tmp13 := lang.Apply(tmp12, []any{v5}) - tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := checkDerefVar(var_glojure_DOT_core_seq) - tmp16 := checkDerefVar(var_glojure_DOT_core_concat) - tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{sym_throw}) - tmp19 := checkDerefVar(var_glojure_DOT_core_list) - tmp20 := checkDerefVar(var_glojure_DOT_core_seq) - tmp21 := checkDerefVar(var_glojure_DOT_core_concat) - tmp22 := checkDerefVar(var_glojure_DOT_core_list) - tmp23 := lang.Apply(tmp22, []any{sym_new}) - tmp24 := checkDerefVar(var_glojure_DOT_core_list) - tmp25 := lang.Apply(tmp24, []any{sym_glojure_DOT_core_SLASH_AssertionError}) - tmp26 := checkDerefVar(var_glojure_DOT_core_list) - tmp27 := checkDerefVar(var_glojure_DOT_core_seq) - tmp28 := checkDerefVar(var_glojure_DOT_core_concat) - tmp29 := checkDerefVar(var_glojure_DOT_core_list) - tmp30 := lang.Apply(tmp29, []any{sym_glojure_DOT_core_SLASH_str}) - tmp31 := checkDerefVar(var_glojure_DOT_core_list) - tmp32 := lang.Apply(tmp31, []any{"Assert failed: "}) - tmp33 := checkDerefVar(var_glojure_DOT_core_list) - tmp34 := checkDerefVar(var_glojure_DOT_core_seq) - tmp35 := checkDerefVar(var_glojure_DOT_core_concat) - tmp36 := checkDerefVar(var_glojure_DOT_core_list) - tmp37 := lang.Apply(tmp36, []any{sym_glojure_DOT_core_SLASH_pr_DASH_str}) - tmp38 := checkDerefVar(var_glojure_DOT_core_list) - tmp39 := checkDerefVar(var_glojure_DOT_core_seq) - tmp40 := checkDerefVar(var_glojure_DOT_core_concat) - tmp41 := checkDerefVar(var_glojure_DOT_core_list) - tmp42 := lang.Apply(tmp41, []any{sym_quote}) - tmp43 := checkDerefVar(var_glojure_DOT_core_list) - tmp44 := lang.Apply(tmp43, []any{v5}) - tmp45 := lang.Apply(tmp40, []any{tmp42, tmp44}) - tmp46 := lang.Apply(tmp39, []any{tmp45}) - tmp47 := lang.Apply(tmp38, []any{tmp46}) - tmp48 := lang.Apply(tmp35, []any{tmp37, tmp47}) - tmp49 := lang.Apply(tmp34, []any{tmp48}) - tmp50 := lang.Apply(tmp33, []any{tmp49}) - tmp51 := lang.Apply(tmp28, []any{tmp30, tmp32, tmp50}) - tmp52 := lang.Apply(tmp27, []any{tmp51}) - tmp53 := lang.Apply(tmp26, []any{tmp52}) - tmp54 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp53}) - tmp55 := lang.Apply(tmp20, []any{tmp54}) - tmp56 := lang.Apply(tmp19, []any{tmp55}) - tmp57 := lang.Apply(tmp16, []any{tmp18, tmp56}) - tmp58 := lang.Apply(tmp15, []any{tmp57}) - tmp59 := lang.Apply(tmp14, []any{tmp58}) - tmp60 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp59}) - tmp61 := lang.Apply(tmp8, []any{tmp60}) - tmp6 = tmp61 - } else { + tmp5, _ := lang.FieldOrMethod(v3, "WithMeta") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("WithMeta is not a function"))) } + tmp6 := lang.Apply(tmp5, []any{v4}) return tmp6 - case 4: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(216), kw_column, int(12), kw_end_DASH_line, int(217), kw_end_DASH_column, int(32))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_with_DASH_meta = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_with_DASH_meta.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + var closed36 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + recur_loop_481: + var tmp3 any + { // let + // let binding "temp__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 _ = v6 var tmp7 any - tmp8 := checkDerefVar(var_glojure_DOT_core__STAR_assert_STAR_) - if lang.IsTruthy(tmp8) { - tmp9 := checkDerefVar(var_glojure_DOT_core_seq) - tmp10 := checkDerefVar(var_glojure_DOT_core_concat) - tmp11 := checkDerefVar(var_glojure_DOT_core_list) - tmp12 := lang.Apply(tmp11, []any{sym_glojure_DOT_core_SLASH_when_DASH_not}) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{v5}) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := checkDerefVar(var_glojure_DOT_core_seq) - tmp17 := checkDerefVar(var_glojure_DOT_core_concat) - tmp18 := checkDerefVar(var_glojure_DOT_core_list) - tmp19 := lang.Apply(tmp18, []any{sym_throw}) - tmp20 := checkDerefVar(var_glojure_DOT_core_list) - tmp21 := checkDerefVar(var_glojure_DOT_core_seq) - tmp22 := checkDerefVar(var_glojure_DOT_core_concat) - tmp23 := checkDerefVar(var_glojure_DOT_core_list) - tmp24 := lang.Apply(tmp23, []any{sym_new}) - tmp25 := checkDerefVar(var_glojure_DOT_core_list) - tmp26 := lang.Apply(tmp25, []any{sym_glojure_DOT_core_SLASH_AssertionError}) - tmp27 := checkDerefVar(var_glojure_DOT_core_list) - tmp28 := checkDerefVar(var_glojure_DOT_core_seq) - tmp29 := checkDerefVar(var_glojure_DOT_core_concat) - tmp30 := checkDerefVar(var_glojure_DOT_core_list) - tmp31 := lang.Apply(tmp30, []any{sym_glojure_DOT_core_SLASH_str}) - tmp32 := checkDerefVar(var_glojure_DOT_core_list) - tmp33 := lang.Apply(tmp32, []any{"Assert failed: "}) - tmp34 := checkDerefVar(var_glojure_DOT_core_list) - tmp35 := lang.Apply(tmp34, []any{v6}) - tmp36 := checkDerefVar(var_glojure_DOT_core_list) - tmp37 := lang.Apply(tmp36, []any{"\n"}) - tmp38 := checkDerefVar(var_glojure_DOT_core_list) - tmp39 := checkDerefVar(var_glojure_DOT_core_seq) - tmp40 := checkDerefVar(var_glojure_DOT_core_concat) - tmp41 := checkDerefVar(var_glojure_DOT_core_list) - tmp42 := lang.Apply(tmp41, []any{sym_glojure_DOT_core_SLASH_pr_DASH_str}) - tmp43 := checkDerefVar(var_glojure_DOT_core_list) - tmp44 := checkDerefVar(var_glojure_DOT_core_seq) - tmp45 := checkDerefVar(var_glojure_DOT_core_concat) - tmp46 := checkDerefVar(var_glojure_DOT_core_list) - tmp47 := lang.Apply(tmp46, []any{sym_quote}) - tmp48 := checkDerefVar(var_glojure_DOT_core_list) - tmp49 := lang.Apply(tmp48, []any{v5}) - tmp50 := lang.Apply(tmp45, []any{tmp47, tmp49}) - tmp51 := lang.Apply(tmp44, []any{tmp50}) - tmp52 := lang.Apply(tmp43, []any{tmp51}) - tmp53 := lang.Apply(tmp40, []any{tmp42, tmp52}) - tmp54 := lang.Apply(tmp39, []any{tmp53}) - tmp55 := lang.Apply(tmp38, []any{tmp54}) - tmp56 := lang.Apply(tmp29, []any{tmp31, tmp33, tmp35, tmp37, tmp55}) - tmp57 := lang.Apply(tmp28, []any{tmp56}) - tmp58 := lang.Apply(tmp27, []any{tmp57}) - tmp59 := lang.Apply(tmp22, []any{tmp24, tmp26, tmp58}) - tmp60 := lang.Apply(tmp21, []any{tmp59}) - tmp61 := lang.Apply(tmp20, []any{tmp60}) - tmp62 := lang.Apply(tmp17, []any{tmp19, tmp61}) - tmp63 := lang.Apply(tmp16, []any{tmp62}) - tmp64 := lang.Apply(tmp15, []any{tmp63}) - tmp65 := lang.Apply(tmp10, []any{tmp12, tmp14, tmp64}) - tmp66 := lang.Apply(tmp9, []any{tmp65}) - tmp7 = tmp66 + if lang.IsTruthy(v6) { + var tmp8 any + { // let + // let binding "s" + var v9 any = v6 + _ = v9 + var tmp10 any + { // let + // let binding "or__0__auto__" + tmp11 := checkDerefVar(var_glojure_DOT_core_first) + tmp12 := lang.Apply(tmp11, []any{v9}) + tmp13 := lang.Apply(v1, []any{tmp12}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + tmp15 = v14 + } else { + var tmp16 any = v1 + tmp18 := checkDerefVar(var_glojure_DOT_core_next) + tmp19 := lang.Apply(tmp18, []any{v9}) + var tmp17 any = tmp19 + v1 = tmp16 + v2 = tmp17 + goto recur_loop_481 + } + tmp10 = tmp15 + } // end let + tmp8 = tmp10 + } // end let + tmp7 = tmp8 } else { } - return tmp7 - default: - checkArity(args, -1) - panic("unreachable") - } + tmp3 = tmp7 + } // end let + return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } + tmp0 = tmp0.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + closed36 = tmp0 } - // assert-args + var closed37 any { - tmp0 := sym_assert_DASH_args.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_pairs)), kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(38), kw_column, int(11), kw_line, int(1830), kw_end_DASH_line, int(1830), kw_private, true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - tmp6 := checkDerefVar(var_glojure_DOT_core_seq) - tmp7 := checkDerefVar(var_glojure_DOT_core_concat) - tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{sym_do}) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := checkDerefVar(var_glojure_DOT_core_seq) - tmp12 := checkDerefVar(var_glojure_DOT_core_concat) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_when_DASH_not}) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := checkDerefVar(var_glojure_DOT_core_first) - tmp17 := lang.Apply(tmp16, []any{v5}) - tmp18 := lang.Apply(tmp15, []any{tmp17}) - tmp19 := checkDerefVar(var_glojure_DOT_core_list) - tmp20 := checkDerefVar(var_glojure_DOT_core_seq) - tmp21 := checkDerefVar(var_glojure_DOT_core_concat) - tmp22 := checkDerefVar(var_glojure_DOT_core_list) - tmp23 := lang.Apply(tmp22, []any{sym_throw}) - tmp24 := checkDerefVar(var_glojure_DOT_core_list) - tmp25 := checkDerefVar(var_glojure_DOT_core_seq) - tmp26 := checkDerefVar(var_glojure_DOT_core_concat) - tmp27 := checkDerefVar(var_glojure_DOT_core_list) - tmp28 := lang.Apply(tmp27, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_NewIllegalArgumentError}) - tmp29 := checkDerefVar(var_glojure_DOT_core_list) - tmp30 := checkDerefVar(var_glojure_DOT_core_seq) - tmp31 := checkDerefVar(var_glojure_DOT_core_concat) - tmp32 := checkDerefVar(var_glojure_DOT_core_list) - tmp33 := lang.Apply(tmp32, []any{sym_glojure_DOT_core_SLASH_str}) - tmp34 := checkDerefVar(var_glojure_DOT_core_list) - tmp35 := checkDerefVar(var_glojure_DOT_core_seq) - tmp36 := checkDerefVar(var_glojure_DOT_core_concat) - tmp37 := checkDerefVar(var_glojure_DOT_core_list) - tmp38 := lang.Apply(tmp37, []any{sym_glojure_DOT_core_SLASH_first}) - tmp39 := checkDerefVar(var_glojure_DOT_core_list) - tmp40 := lang.Apply(tmp39, []any{sym__AMP_form}) - tmp41 := lang.Apply(tmp36, []any{tmp38, tmp40}) - tmp42 := lang.Apply(tmp35, []any{tmp41}) - tmp43 := lang.Apply(tmp34, []any{tmp42}) - tmp44 := checkDerefVar(var_glojure_DOT_core_list) - tmp45 := lang.Apply(tmp44, []any{" requires "}) - tmp46 := checkDerefVar(var_glojure_DOT_core_list) - tmp47 := checkDerefVar(var_glojure_DOT_core_second) - tmp48 := lang.Apply(tmp47, []any{v5}) - tmp49 := lang.Apply(tmp46, []any{tmp48}) - tmp50 := checkDerefVar(var_glojure_DOT_core_list) - tmp51 := lang.Apply(tmp50, []any{" in "}) - tmp52 := checkDerefVar(var_glojure_DOT_core_list) - tmp53 := lang.Apply(tmp52, []any{sym__STAR_ns_STAR_}) - tmp54 := checkDerefVar(var_glojure_DOT_core_list) - tmp55 := lang.Apply(tmp54, []any{":"}) - tmp56 := checkDerefVar(var_glojure_DOT_core_list) - tmp57 := checkDerefVar(var_glojure_DOT_core_seq) - tmp58 := checkDerefVar(var_glojure_DOT_core_concat) - tmp59 := checkDerefVar(var_glojure_DOT_core_list) - tmp60 := lang.Apply(tmp59, []any{kw_line}) - tmp61 := checkDerefVar(var_glojure_DOT_core_list) - tmp62 := checkDerefVar(var_glojure_DOT_core_seq) - tmp63 := checkDerefVar(var_glojure_DOT_core_concat) - tmp64 := checkDerefVar(var_glojure_DOT_core_list) - tmp65 := lang.Apply(tmp64, []any{sym_glojure_DOT_core_SLASH_meta}) - tmp66 := checkDerefVar(var_glojure_DOT_core_list) - tmp67 := lang.Apply(tmp66, []any{sym__AMP_form}) - tmp68 := lang.Apply(tmp63, []any{tmp65, tmp67}) - tmp69 := lang.Apply(tmp62, []any{tmp68}) - tmp70 := lang.Apply(tmp61, []any{tmp69}) - tmp71 := lang.Apply(tmp58, []any{tmp60, tmp70}) - tmp72 := lang.Apply(tmp57, []any{tmp71}) - tmp73 := lang.Apply(tmp56, []any{tmp72}) - tmp74 := lang.Apply(tmp31, []any{tmp33, tmp43, tmp45, tmp49, tmp51, tmp53, tmp55, tmp73}) - tmp75 := lang.Apply(tmp30, []any{tmp74}) - tmp76 := lang.Apply(tmp29, []any{tmp75}) - tmp77 := lang.Apply(tmp26, []any{tmp28, tmp76}) - tmp78 := lang.Apply(tmp25, []any{tmp77}) - tmp79 := lang.Apply(tmp24, []any{tmp78}) - tmp80 := lang.Apply(tmp21, []any{tmp23, tmp79}) - tmp81 := lang.Apply(tmp20, []any{tmp80}) - tmp82 := lang.Apply(tmp19, []any{tmp81}) - tmp83 := lang.Apply(tmp12, []any{tmp14, tmp18, tmp82}) - tmp84 := lang.Apply(tmp11, []any{tmp83}) - tmp85 := lang.Apply(tmp10, []any{tmp84}) - tmp86 := checkDerefVar(var_glojure_DOT_core_list) - var tmp87 any - { // let - // let binding "more" - tmp88 := checkDerefVar(var_glojure_DOT_core_nnext) - tmp89 := lang.Apply(tmp88, []any{v5}) - var v90 any = tmp89 - _ = v90 - var tmp91 any - if lang.IsTruthy(v90) { - tmp92 := checkDerefVar(var_glojure_DOT_core_list_STAR_) - tmp93 := lang.Apply(tmp92, []any{sym_glojure_DOT_core_SLASH_assert_DASH_args, v90}) - tmp91 = tmp93 + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + recur_loop_480: + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := lang.Apply(tmp5, []any{v2}) + tmp7 := lang.Apply(tmp4, []any{tmp6}) + if lang.IsTruthy(tmp7) { + tmp3 = true + } else { + var tmp8 any + tmp9 := checkDerefVar(var_glojure_DOT_core_first) + tmp10 := lang.Apply(tmp9, []any{v2}) + tmp11 := lang.Apply(v1, []any{tmp10}) + if lang.IsTruthy(tmp11) { + var tmp12 any = v1 + tmp14 := checkDerefVar(var_glojure_DOT_core_next) + tmp15 := lang.Apply(tmp14, []any{v2}) + var tmp13 any = tmp15 + v1 = tmp12 + v2 = tmp13 + goto recur_loop_480 + } else { + var tmp16 any + if lang.IsTruthy(kw_else) { + tmp16 = false } else { } - tmp87 = tmp91 - } // end let - tmp88 := lang.Apply(tmp86, []any{tmp87}) - tmp89 := lang.Apply(tmp7, []any{tmp9, tmp85, tmp88}) - tmp90 := lang.Apply(tmp6, []any{tmp89}) - return tmp90 + tmp8 = tmp16 + } + tmp3 = tmp8 } + return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } + tmp1 := reflect.TypeOf(false) + tmp0 = tmp0.WithMeta(lang.NewMap(kw_rettag, tmp1)).(lang.FnFunc) + closed37 = tmp0 } - // assert-valid-fdecl + // agent-errors { - tmp0 := sym_assert_DASH_valid_DASH_fdecl.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_fdecl)), kw_doc, "A good fdecl looks like (([a] ...) ([a b] ...)) near the end of defn.", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(42), kw_column, int(8), kw_line, int(7502), kw_end_DASH_line, int(7502), kw_private, true, kw_dynamic, true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_agent_DASH_errors.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a)), kw_doc, "DEPRECATED: Use 'agent-error' instead.\n Returns a sequence of the exceptions thrown during asynchronous\n actions of the agent.", kw_file, "glojure/core.glj", kw_deprecated, "1.2", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(2234), kw_end_DASH_line, int(2234))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := checkDerefVar(var_glojure_DOT_core_empty_QMARK_) - tmp6 := lang.Apply(tmp5, []any{v3}) - if lang.IsTruthy(tmp6) { - tmp7 := lang.Apply(lang.NewIllegalArgumentError, []any{"Parameter declaration missing"}) - panic(tmp7) - } else { - } - _ = tmp4 - var tmp8 any + v2 := args[0] + _ = v2 + var tmp3 any { // let - // let binding "argdecls" - tmp9 := checkDerefVar(var_glojure_DOT_core_map) - var tmp10 lang.FnFunc - tmp10 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v11 := args[0] - _ = v11 - var tmp12 any - tmp13 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) - tmp14 := lang.Apply(tmp13, []any{v11}) - if lang.IsTruthy(tmp14) { - tmp15 := checkDerefVar(var_glojure_DOT_core_first) - tmp16 := lang.Apply(tmp15, []any{v11}) - tmp12 = tmp16 - } else { - var tmp17 any - tmp18 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) - tmp19 := checkDerefVar(var_glojure_DOT_core_first) - tmp20 := lang.Apply(tmp19, []any{v3}) - tmp21 := lang.Apply(tmp18, []any{tmp20}) - if lang.IsTruthy(tmp21) { - tmp22 := checkDerefVar(var_glojure_DOT_core_str) - tmp23 := lang.Apply(tmp22, []any{"Invalid signature \"", v11, "\" should be a list"}) - tmp17 = tmp23 - } else { - tmp24 := checkDerefVar(var_glojure_DOT_core_str) - tmp25 := lang.Apply(tmp24, []any{"Parameter declaration \"", v11, "\" should be a vector"}) - tmp17 = tmp25 - } - tmp26 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp17}) - panic(tmp26) - } - return tmp12 - }) - tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7508), kw_column, int(20), kw_end_DASH_line, int(7517), kw_end_DASH_column, int(59)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp13 := lang.Apply(tmp9, []any{tmp12, v3}) - var v14 any = tmp13 - _ = v14 - // let binding "bad-args" - tmp15 := checkDerefVar(var_glojure_DOT_core_seq) - tmp16 := checkDerefVar(var_glojure_DOT_core_remove) - var tmp17 lang.FnFunc - tmp17 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v18 := args[0] - _ = v18 - tmp19 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) - tmp20 := lang.Apply(tmp19, []any{v18}) - return tmp20 - }) - tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7519), kw_column, int(31), kw_end_DASH_line, int(7519), kw_end_DASH_column, int(42)) - tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp20 := lang.Apply(tmp16, []any{tmp19, v14}) - tmp21 := lang.Apply(tmp15, []any{tmp20}) - var v22 any = tmp21 - _ = v22 - var tmp23 any - if lang.IsTruthy(v22) { - tmp24 := checkDerefVar(var_glojure_DOT_core_str) - tmp25 := checkDerefVar(var_glojure_DOT_core_first) - tmp26 := lang.Apply(tmp25, []any{v22}) - tmp27 := lang.Apply(tmp24, []any{"Parameter declaration \"", tmp26, "\" should be a vector"}) - tmp28 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp27}) - panic(tmp28) + // let binding "temp__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_agent_DASH_error) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + var tmp8 any + { // let + // let binding "e" + var v9 any = v6 + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{v9}) + tmp8 = tmp11 + } // end let + tmp7 = tmp8 } else { } - tmp8 = tmp23 + tmp3 = tmp7 } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_agent_DASH_errors = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_agent_DASH_errors.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // alias + { + tmp0 := sym_alias.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_alias, sym_namespace_DASH_sym)), kw_doc, "Add an alias in the current namespace to another\n namespace. Arguments are two symbols: the alias to be used, and\n the symbolic name of the target namespace. Use :as in the ns macro in preference\n to calling this directly.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(4263), kw_end_DASH_line, int(4263))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp5 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) + tmp6 := lang.Apply(tmp5, []any{v3}) + tmp7, _ := lang.FieldOrMethod(tmp4, "AddAlias") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("AddAlias is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v2, tmp6}) return tmp8 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_alias = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_alias.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // assoc { tmp0 := sym_assoc.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_map, sym_key, sym_val), lang.NewVector(sym_map, sym_key, sym_val, sym__AMP_, sym_kvs)), kw_doc, "assoc[iate]. When applied to a map, returns a new map of the\n same (hashed/sorted) type, that contains the mapping of key(s) to\n val(s). When applied to a vector, returns a new vector that\n contains val at index. Note - index must be <= (count vector).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(6), kw_column, int(2), kw_line, int(181), kw_end_DASH_line, int(188))).(*lang.Symbol) - var tmp2 lang.FnFunc + var tmp1 lang.FnFunc { // function assoc - var v3 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 3: - v4 := args[0] + v3 := args[0] + _ = v3 + v4 := args[1] _ = v4 - v5 := args[1] + v5 := args[2] _ = v5 - v6 := args[2] - _ = v6 - tmp7 := lang.Apply(lang.Assoc, []any{v4, v5, v6}) - return tmp7 + tmp6 := lang.Apply(lang.Assoc, []any{v3, v4, v5}) + return tmp6 default: checkArity(args, 3) - v4 := args[0] + v3 := args[0] + _ = v3 + v4 := args[1] _ = v4 - v5 := args[1] + v5 := args[2] _ = v5 - v6 := args[2] + var v6 any = lang.NewList(args[3:]...) _ = v6 - var v7 any = lang.NewList(args[3:]...) - _ = v7 recur_loop_24: - var tmp8 any + var tmp7 any { // let // let binding "ret" - tmp9 := lang.Apply(lang.Assoc, []any{v4, v5, v6}) - var v10 any = tmp9 - _ = v10 - var tmp11 any - if lang.IsTruthy(v7) { - var tmp12 any - tmp13 := checkDerefVar(var_glojure_DOT_core_next) - tmp14 := lang.Apply(tmp13, []any{v7}) - if lang.IsTruthy(tmp14) { - var tmp15 any = v10 - tmp17 := checkDerefVar(var_glojure_DOT_core_first) - tmp18 := lang.Apply(tmp17, []any{v7}) - var tmp16 any = tmp18 - tmp20 := checkDerefVar(var_glojure_DOT_core_second) - tmp21 := lang.Apply(tmp20, []any{v7}) - var tmp19 any = tmp21 - tmp23 := checkDerefVar(var_glojure_DOT_core_nnext) - tmp24 := lang.Apply(tmp23, []any{v7}) - var tmp22 any = tmp24 + tmp8 := lang.Apply(lang.Assoc, []any{v3, v4, v5}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v6) { + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core_next) + tmp13 := lang.Apply(tmp12, []any{v6}) + if lang.IsTruthy(tmp13) { + var tmp14 any = v9 + tmp16 := checkDerefVar(var_glojure_DOT_core_first) + tmp17 := lang.Apply(tmp16, []any{v6}) + var tmp15 any = tmp17 + tmp19 := checkDerefVar(var_glojure_DOT_core_second) + tmp20 := lang.Apply(tmp19, []any{v6}) + var tmp18 any = tmp20 + tmp22 := checkDerefVar(var_glojure_DOT_core_nnext) + tmp23 := lang.Apply(tmp22, []any{v6}) + var tmp21 any = tmp23 + v3 = tmp14 v4 = tmp15 - v5 = tmp16 - v6 = tmp19 - v7 = tmp22 + v5 = tmp18 + v6 = tmp21 goto recur_loop_24 } else { - tmp25 := lang.Apply(lang.NewIllegalArgumentError, []any{"assoc expects even number of arguments after map/vector, found odd number"}) - panic(tmp25) + tmp24 := lang.Apply(lang.NewIllegalArgumentError, []any{"assoc expects even number of arguments after map/vector, found odd number"}) + panic(tmp24) } - tmp11 = tmp12 + tmp10 = tmp11 } else { - tmp11 = v10 + tmp10 = v9 } - tmp8 = tmp11 + tmp7 = tmp10 } // end let - return tmp8 + return tmp7 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(189), kw_column, int(2), kw_end_DASH_line, int(198), kw_end_DASH_column, int(15))).(lang.FnFunc) - v3 = tmp2 - _ = v3 + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(189), kw_column, int(2), kw_end_DASH_line, int(198), kw_end_DASH_column, int(15))).(lang.FnFunc) + v2 = tmp1 + _ = v2 } - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core_assoc = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_assoc.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // assoc! { tmp0 := sym_assoc_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll, sym_key, sym_val), lang.NewVector(sym_coll, sym_key, sym_val, sym__AMP_, sym_kvs)), kw_doc, "When applied to a transient map, adds mapping of key(s) to\n val(s). When applied to a transient vector, sets the val at index.\n Note - index must be <= (count vector). Returns coll.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(3369), kw_end_DASH_line, int(3369))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 3: - v3 := args[0] + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + v4 := args[2] _ = v4 - v5 := args[2] - _ = v5 - tmp6, _ := lang.FieldOrMethod(v3, "Assoc") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { + tmp5, _ := lang.FieldOrMethod(v2, "Assoc") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Assoc is not a function"))) } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 default: checkArity(args, 3) - v3 := args[0] + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + v4 := args[2] _ = v4 - v5 := args[2] + var v5 any = lang.NewList(args[3:]...) _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 recur_loop_609: - var tmp7 any + var tmp6 any { // let // let binding "ret" - tmp8, _ := lang.FieldOrMethod(v3, "Assoc") - if reflect.TypeOf(tmp8).Kind() != reflect.Func { + tmp7, _ := lang.FieldOrMethod(v2, "Assoc") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Assoc is not a function"))) } - tmp9 := lang.Apply(tmp8, []any{v4, v5}) - var v10 any = tmp9 - _ = v10 - var tmp11 any - if lang.IsTruthy(v6) { - var tmp12 any = v10 - tmp14 := checkDerefVar(var_glojure_DOT_core_first) - tmp15 := lang.Apply(tmp14, []any{v6}) - var tmp13 any = tmp15 - tmp17 := checkDerefVar(var_glojure_DOT_core_second) - tmp18 := lang.Apply(tmp17, []any{v6}) - var tmp16 any = tmp18 - tmp20 := checkDerefVar(var_glojure_DOT_core_nnext) - tmp21 := lang.Apply(tmp20, []any{v6}) - var tmp19 any = tmp21 + tmp8 := lang.Apply(tmp7, []any{v3, v4}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v5) { + var tmp11 any = v9 + tmp13 := checkDerefVar(var_glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v5}) + var tmp12 any = tmp14 + tmp16 := checkDerefVar(var_glojure_DOT_core_second) + tmp17 := lang.Apply(tmp16, []any{v5}) + var tmp15 any = tmp17 + tmp19 := checkDerefVar(var_glojure_DOT_core_nnext) + tmp20 := lang.Apply(tmp19, []any{v5}) + var tmp18 any = tmp20 + v2 = tmp11 v3 = tmp12 - v4 = tmp13 - v5 = tmp16 - v6 = tmp19 + v4 = tmp15 + v5 = tmp18 goto recur_loop_609 } else { - tmp11 = v10 + tmp10 = v9 } - tmp7 = tmp11 + tmp6 = tmp10 } // end let - return tmp7 + return tmp6 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_assoc_BANG_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_assoc_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // assoc-in + // associative? { - tmp0 := sym_assoc_DASH_in.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m, lang.NewVector(sym_k, sym__AMP_, sym_ks), sym_v)), kw_doc, "Associates a value in a nested associative structure, where ks is a\n sequence of keys and v is the new value and returns a new nested structure.\n If any levels do not exist, hash-maps will be created.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(6147), kw_end_DASH_line, int(6147))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 3) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var tmp6 any - { // let - // let binding "vec__138" - var v7 any = v4 - _ = v7 - // let binding "seq__139" - tmp8 := checkDerefVar(var_glojure_DOT_core_seq) - tmp9 := lang.Apply(tmp8, []any{v7}) - var v10 any = tmp9 - _ = v10 - // let binding "first__140" - tmp11 := checkDerefVar(var_glojure_DOT_core_first) - tmp12 := lang.Apply(tmp11, []any{v10}) - var v13 any = tmp12 - _ = v13 - // let binding "seq__139" - tmp14 := checkDerefVar(var_glojure_DOT_core_next) - tmp15 := lang.Apply(tmp14, []any{v10}) - var v16 any = tmp15 - _ = v16 - // let binding "k" - var v17 any = v13 - _ = v17 - // let binding "ks" - var v18 any = v16 - _ = v18 - var tmp19 any - if lang.IsTruthy(v18) { - tmp20 := checkDerefVar(var_glojure_DOT_core_assoc) - tmp21 := checkDerefVar(var_glojure_DOT_core_assoc_DASH_in) - tmp22 := checkDerefVar(var_glojure_DOT_core_get) - tmp23 := lang.Apply(tmp22, []any{v3, v17}) - tmp24 := lang.Apply(tmp21, []any{tmp23, v18, v5}) - tmp25 := lang.Apply(tmp20, []any{v3, v17, tmp24}) - tmp19 = tmp25 - } else { - tmp26 := checkDerefVar(var_glojure_DOT_core_assoc) - tmp27 := lang.Apply(tmp26, []any{v3, v17, v5}) - tmp19 = tmp27 - } - tmp6 = tmp19 - } // end let - return tmp6 + tmp0 := sym_associative_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns true if coll implements Associative", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(6223), kw_end_DASH_line, int(6223))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := lang.Apply(tmp3, []any{nil, v2}) + return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_associative_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_associative_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // associative? + // bases { - tmp0 := sym_associative_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns true if coll implements Associative", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(6223), kw_end_DASH_line, int(6223))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_bases.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_c)), kw_doc, "Returns the immediate superclass and direct interfaces of c, if any", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(5522), kw_end_DASH_line, int(5522))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp5 := lang.Apply(tmp4, []any{nil, v3}) - return tmp5 + v2 := args[0] + _ = v2 + var tmp3 any + if lang.IsTruthy(v2) { + var tmp4 any + { // let + // let binding "i" + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := lang.Apply(tmp5, []any{nil}) + var v7 any = tmp6 + _ = v7 + // let binding "s" + var v8 any = nil + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + tmp10 := checkDerefVar(var_glojure_DOT_core_cons) + tmp11 := lang.Apply(tmp10, []any{v8, v7}) + tmp9 = tmp11 + } else { + tmp9 = v7 + } + tmp4 = tmp9 + } // end let + tmp3 = tmp4 + } else { + } + return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bases = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_bases.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // atom + // boolean? { - tmp0 := sym_atom.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym__AMP_, sym_options)), kw_doc, "Creates and returns an Atom with an initial value of x and zero or\n more options (in any order):\n\n :meta metadata-map\n\n :validator validate-fn\n\n If metadata-map is supplied, it will become the metadata on the\n atom. validate-fn must be nil or a side-effect-free fn of one\n argument, which will be passed the intended new state on any state\n change. If the new state is unacceptable, the validate-fn should\n return false or throw an exception.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(2325), kw_end_DASH_line, int(2325))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - tmp4 := lang.Apply(lang.NewAtom, []any{v3}) - return tmp4 - default: + tmp0 := sym_boolean_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a Boolean", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(518), kw_end_DASH_line, int(518))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := lang.Apply(tmp3, []any{lang.Builtins["bool"], v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_boolean_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_boolean_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // char? + { + tmp0 := sym_char_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a Character", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(6), kw_column, int(2), kw_line, int(153), kw_end_DASH_line, int(157))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function char? + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) v3 := args[0] _ = v3 - var v4 any = lang.NewList(args[1:]...) - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_setup_DASH_reference) - tmp6 := checkDerefVar(var_glojure_DOT_core_atom) - tmp7 := lang.Apply(tmp6, []any{v3}) - tmp8 := lang.Apply(tmp5, []any{tmp7, v4}) - return tmp8 + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := reflect.TypeOf(int32(0)) + tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(157), kw_column, int(8), kw_end_DASH_line, int(157), kw_end_DASH_column, int(89))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_char_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_char_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // chunked-seq? + { + tmp0 := sym_chunked_DASH_seq_QMARK_.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(708), kw_column, int(7), kw_end_DASH_line, int(708), kw_end_DASH_column, int(27), kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*lang.IChunkedSeq)(nil)).Elem() + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_chunked_DASH_seq_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_chunked_DASH_seq_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // class + { + tmp0 := sym_class.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns the Class of x", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3461), kw_end_DASH_line, int(3461))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + tmp3 = v2 + } else { + tmp6 := lang.Apply(lang.TypeOf, []any{v2}) + tmp3 = tmp6 } + return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_class = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_class.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // await + // class? { - tmp0 := sym_await.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_agents)), kw_doc, "Blocks the current thread (indefinitely!) until all actions\n dispatched thus far, from this thread or agent, to the agent(s) have\n occurred. Will block on failed agents. Will never return if\n a failed agent is restarted with :clear-actions true or shutdown-agents was called.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3267), kw_end_DASH_line, int(3267))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_class_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x is an instance of Class", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(5465), kw_end_DASH_line, int(5465))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*reflect.Type)(nil)).Elem() + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_class_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_class_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // coll? + { + tmp0 := sym_coll_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x implements IPersistentCollection", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(6192), kw_end_DASH_line, int(6192))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*lang.IPersistentCollection)(nil)).Elem() + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_coll_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_coll_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // completing + { + tmp0 := sym_completing.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_cf)), kw_doc, "Takes a reducing function f of 2 args and returns a fn suitable for\n transduce by adding an arity-1 signature that calls cf (default -\n identity) on the result argument.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(6893), kw_end_DASH_line, int(6893))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - default: - checkArity(args, 0) - var v3 any = lang.NewList(args[0:]...) + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_completing) + tmp4 := checkDerefVar(var_glojure_DOT_core_identity) + tmp5 := lang.Apply(tmp3, []any{v2, tmp4}) + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - var tmp4 any - tmp5 := lang.Apply(nil, nil) - if lang.IsTruthy(tmp5) { - panic("unimplemented: new with non-constant class type") - } else { - var tmp6 any - tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_agent_STAR_) - if lang.IsTruthy(tmp7) { - tmp8 := lang.Apply(errors8.New, []any{"Can't await in agent action"}) - panic(tmp8) - } else { + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp5 := lang.Apply(v2, nil) + return tmp5 + case 1: + v5 := args[0] + _ = v5 + tmp6 := lang.Apply(v3, []any{v5}) + return tmp6 + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + tmp7 := lang.Apply(v2, []any{v5, v6}) + return tmp7 + default: + checkArity(args, -1) + panic("unreachable") } - _ = tmp6 - var tmp9 any - { // let - // let binding "latch" - var v10 any = "unimplemented: new with non-constant class type" - _ = v10 - // let binding "count-down" - var tmp11 lang.FnFunc - tmp11 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v12 := args[0] - _ = v12 - tmp13, _ := lang.FieldOrMethod(v10, "countDown") - if reflect.TypeOf(tmp13).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("countDown is not a function"))) - } - tmp14 := lang.Apply(tmp13, []any{}) - _ = tmp14 - return v12 - }) - tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3279), kw_column, int(22), kw_end_DASH_line, int(3279), kw_end_DASH_column, int(61)) - tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v14 any = tmp13 - _ = v14 - var tmp15 any - { // let - // let binding "seq_1" - tmp16 := checkDerefVar(var_glojure_DOT_core_seq) - tmp17 := lang.Apply(tmp16, []any{v3}) - var v18 any = tmp17 - _ = v18 - // let binding "chunk_2" - var v19 any = nil - _ = v19 - // let binding "count_3" - var v20 any = int64(0) - _ = v20 - // let binding "i_4" - var v21 any = int64(0) - _ = v21 - for { - var tmp22 any - tmp23 := checkDerefVar(var_glojure_DOT_core__LT_) - tmp24 := lang.Apply(tmp23, []any{v21, v20}) - if lang.IsTruthy(tmp24) { - var tmp25 any - { // let - // let binding "agent" - tmp26, _ := lang.FieldOrMethod(v19, "nth") - if reflect.TypeOf(tmp26).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) - } - tmp27 := lang.Apply(tmp26, []any{v21}) - var v28 any = tmp27 - _ = v28 - tmp29 := checkDerefVar(var_glojure_DOT_core_send) - tmp30 := lang.Apply(tmp29, []any{v28, v14}) - _ = tmp30 - var tmp31 any = v18 - var tmp32 any = v19 - var tmp33 any = v20 - tmp35 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) - tmp36 := lang.Apply(tmp35, []any{v21}) - var tmp34 any = tmp36 - v18 = tmp31 - v19 = tmp32 - v20 = tmp33 - v21 = tmp34 - continue - } // end let - tmp22 = tmp25 - } else { - var tmp26 any - { // let - // let binding "temp__0__auto__" - tmp27 := checkDerefVar(var_glojure_DOT_core_seq) - tmp28 := lang.Apply(tmp27, []any{v18}) - var v29 any = tmp28 - _ = v29 - var tmp30 any - if lang.IsTruthy(v29) { - var tmp31 any - { // let - // let binding "seq_1" - var v32 any = v29 - _ = v32 - var tmp33 any - tmp34 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) - tmp35 := lang.Apply(tmp34, []any{v32}) - if lang.IsTruthy(tmp35) { - var tmp36 any - { // let - // let binding "c__0__auto__" - tmp37 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) - tmp38 := lang.Apply(tmp37, []any{v32}) - var v39 any = tmp38 - _ = v39 - tmp41 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) - tmp42 := lang.Apply(tmp41, []any{v32}) - var tmp40 any = tmp42 - var tmp43 any = v39 - tmp45 := checkDerefVar(var_glojure_DOT_core_int) - tmp46 := checkDerefVar(var_glojure_DOT_core_count) - tmp47 := lang.Apply(tmp46, []any{v39}) - tmp48 := lang.Apply(tmp45, []any{tmp47}) - var tmp44 any = tmp48 - tmp50 := checkDerefVar(var_glojure_DOT_core_int) - tmp51 := lang.Apply(tmp50, []any{int64(0)}) - var tmp49 any = tmp51 - v18 = tmp40 - v19 = tmp43 - v20 = tmp44 - v21 = tmp49 - continue - } // end let - tmp33 = tmp36 - } else { - var tmp37 any - { // let - // let binding "agent" - tmp38 := checkDerefVar(var_glojure_DOT_core_first) - tmp39 := lang.Apply(tmp38, []any{v32}) - var v40 any = tmp39 - _ = v40 - tmp41 := checkDerefVar(var_glojure_DOT_core_send) - tmp42 := lang.Apply(tmp41, []any{v40, v14}) - _ = tmp42 - tmp44 := checkDerefVar(var_glojure_DOT_core_next) - tmp45 := lang.Apply(tmp44, []any{v32}) - var tmp43 any = tmp45 - var tmp46 any = nil - var tmp47 any = int64(0) - var tmp48 any = int64(0) - v18 = tmp43 - v19 = tmp46 - v20 = tmp47 - v21 = tmp48 - continue - } // end let - tmp33 = tmp37 - } - tmp31 = tmp33 - } // end let - tmp30 = tmp31 - } else { - } - tmp26 = tmp30 - } // end let - tmp22 = tmp26 - } - tmp15 = tmp22 - break - } - } // end let - _ = tmp15 - tmp16, _ := lang.FieldOrMethod(v10, "await") - if reflect.TypeOf(tmp16).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) - } - tmp17 := lang.Apply(tmp16, []any{}) - tmp9 = tmp17 - } // end let - tmp4 = tmp9 + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6900), kw_column, int(6), kw_end_DASH_line, int(6903), kw_end_DASH_column, int(23)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) } - return tmp4 + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_completing = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_completing.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // await-for + // concat { - tmp0 := sym_await_DASH_for.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_timeout_DASH_ms, sym__AMP_, sym_agents)), kw_doc, "Blocks the current thread until all actions dispatched thus\n far (from this thread or agent) to the agents have occurred, or the\n timeout (in milliseconds) has elapsed. Returns logical false if\n returning due to timeout, logical true otherwise.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(3289), kw_end_DASH_line, int(3289))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_concat.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_zs)), kw_doc, "Returns a lazy seq representing the concatenation of the elements in the supplied colls.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(711), kw_end_DASH_line, int(711))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - default: - checkArity(args, 1) - v3 := args[0] + case 0: + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + return nil + }) + tmp3 := lang.Apply(lang.NewLazySeq, []any{tmp2}) + return tmp3 + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + return v2 + }) + tmp4 := lang.Apply(lang.NewLazySeq, []any{tmp3}) + return tmp4 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[1:]...) - _ = v4 - var tmp5 any - tmp6 := lang.Apply(nil, nil) - if lang.IsTruthy(tmp6) { - panic("unimplemented: new with non-constant class type") - } else { - var tmp7 any - tmp8 := checkDerefVar(var_glojure_DOT_core__STAR_agent_STAR_) - if lang.IsTruthy(tmp8) { - tmp9 := lang.Apply(errors8.New, []any{"Can't await in agent action"}) - panic(tmp9) - } else { - } - _ = tmp7 - var tmp10 any + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp5 any { // let - // let binding "latch" - var v11 any = "unimplemented: new with non-constant class type" - _ = v11 - // let binding "count-down" - var tmp12 lang.FnFunc - tmp12 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v13 := args[0] - _ = v13 - tmp14, _ := lang.FieldOrMethod(v11, "countDown") - if reflect.TypeOf(tmp14).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("countDown is not a function"))) + // let binding "s" + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := lang.Apply(tmp6, []any{v2}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + var tmp10 any + tmp11 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp12 := lang.Apply(tmp11, []any{v8}) + if lang.IsTruthy(tmp12) { + tmp13 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_cons) + tmp14 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp15 := lang.Apply(tmp14, []any{v8}) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp18 := lang.Apply(tmp17, []any{v8}) + tmp19 := lang.Apply(tmp16, []any{tmp18, v3}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp19}) + tmp10 = tmp20 + } else { + tmp21 := checkDerefVar(var_glojure_DOT_core_cons) + tmp22 := checkDerefVar(var_glojure_DOT_core_first) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_concat) + tmp25 := checkDerefVar(var_glojure_DOT_core_rest) + tmp26 := lang.Apply(tmp25, []any{v8}) + tmp27 := lang.Apply(tmp24, []any{tmp26, v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp27}) + tmp10 = tmp28 } - tmp15 := lang.Apply(tmp14, []any{}) - _ = tmp15 - return v13 - }) - tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3301), kw_column, int(23), kw_end_DASH_line, int(3301), kw_end_DASH_column, int(62)) - tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) - if err != nil { - panic(err) + tmp9 = tmp10 + } else { + tmp9 = v3 } - var v15 any = tmp14 - _ = v15 - var tmp16 any - { // let - // let binding "seq_5" - tmp17 := checkDerefVar(var_glojure_DOT_core_seq) - tmp18 := lang.Apply(tmp17, []any{v4}) - var v19 any = tmp18 - _ = v19 - // let binding "chunk_6" - var v20 any = nil - _ = v20 - // let binding "count_7" - var v21 any = int64(0) - _ = v21 - // let binding "i_8" - var v22 any = int64(0) - _ = v22 - for { - var tmp23 any - tmp24 := checkDerefVar(var_glojure_DOT_core__LT_) - tmp25 := lang.Apply(tmp24, []any{v22, v21}) - if lang.IsTruthy(tmp25) { - var tmp26 any - { // let - // let binding "agent" - tmp27, _ := lang.FieldOrMethod(v20, "nth") - if reflect.TypeOf(tmp27).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + tmp5 = tmp9 + } // end let + return tmp5 + }) + tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) + return tmp5 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "cat" + var tmp6 lang.FnFunc + { // function cat + var v7 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp11 any + { // let + // let binding "xys" + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := lang.Apply(tmp12, []any{v8}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + var tmp16 any + tmp17 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp18 := lang.Apply(tmp17, []any{v14}) + if lang.IsTruthy(tmp18) { + tmp19 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_cons) + tmp20 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp21 := lang.Apply(tmp20, []any{v14}) + tmp22 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp23 := lang.Apply(tmp22, []any{v14}) + tmp24 := lang.Apply(v7, []any{tmp23, v9}) + tmp25 := lang.Apply(tmp19, []any{tmp21, tmp24}) + tmp16 = tmp25 + } else { + tmp26 := checkDerefVar(var_glojure_DOT_core_cons) + tmp27 := checkDerefVar(var_glojure_DOT_core_first) + tmp28 := lang.Apply(tmp27, []any{v14}) + tmp29 := checkDerefVar(var_glojure_DOT_core_rest) + tmp30 := lang.Apply(tmp29, []any{v14}) + tmp31 := lang.Apply(v7, []any{tmp30, v9}) + tmp32 := lang.Apply(tmp26, []any{tmp28, tmp31}) + tmp16 = tmp32 } - tmp28 := lang.Apply(tmp27, []any{v22}) - var v29 any = tmp28 - _ = v29 - tmp30 := checkDerefVar(var_glojure_DOT_core_send) - tmp31 := lang.Apply(tmp30, []any{v29, v15}) - _ = tmp31 - var tmp32 any = v19 - var tmp33 any = v20 - var tmp34 any = v21 - tmp36 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) - tmp37 := lang.Apply(tmp36, []any{v22}) - var tmp35 any = tmp37 - v19 = tmp32 - v20 = tmp33 - v21 = tmp34 - v22 = tmp35 - continue - } // end let - tmp23 = tmp26 - } else { - var tmp27 any - { // let - // let binding "temp__0__auto__" - tmp28 := checkDerefVar(var_glojure_DOT_core_seq) - tmp29 := lang.Apply(tmp28, []any{v19}) - var v30 any = tmp29 - _ = v30 - var tmp31 any - if lang.IsTruthy(v30) { - var tmp32 any - { // let - // let binding "seq_5" - var v33 any = v30 - _ = v33 - var tmp34 any - tmp35 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) - tmp36 := lang.Apply(tmp35, []any{v33}) - if lang.IsTruthy(tmp36) { - var tmp37 any - { // let - // let binding "c__0__auto__" - tmp38 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) - tmp39 := lang.Apply(tmp38, []any{v33}) - var v40 any = tmp39 - _ = v40 - tmp42 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) - tmp43 := lang.Apply(tmp42, []any{v33}) - var tmp41 any = tmp43 - var tmp44 any = v40 - tmp46 := checkDerefVar(var_glojure_DOT_core_int) - tmp47 := checkDerefVar(var_glojure_DOT_core_count) - tmp48 := lang.Apply(tmp47, []any{v40}) - tmp49 := lang.Apply(tmp46, []any{tmp48}) - var tmp45 any = tmp49 - tmp51 := checkDerefVar(var_glojure_DOT_core_int) - tmp52 := lang.Apply(tmp51, []any{int64(0)}) - var tmp50 any = tmp52 - v19 = tmp41 - v20 = tmp44 - v21 = tmp45 - v22 = tmp50 - continue - } // end let - tmp34 = tmp37 - } else { - var tmp38 any - { // let - // let binding "agent" - tmp39 := checkDerefVar(var_glojure_DOT_core_first) - tmp40 := lang.Apply(tmp39, []any{v33}) - var v41 any = tmp40 - _ = v41 - tmp42 := checkDerefVar(var_glojure_DOT_core_send) - tmp43 := lang.Apply(tmp42, []any{v41, v15}) - _ = tmp43 - tmp45 := checkDerefVar(var_glojure_DOT_core_next) - tmp46 := lang.Apply(tmp45, []any{v33}) - var tmp44 any = tmp46 - var tmp47 any = nil - var tmp48 any = int64(0) - var tmp49 any = int64(0) - v19 = tmp44 - v20 = tmp47 - v21 = tmp48 - v22 = tmp49 - continue - } // end let - tmp34 = tmp38 - } - tmp32 = tmp34 - } // end let - tmp31 = tmp32 + tmp15 = tmp16 + } else { + var tmp33 any + if lang.IsTruthy(v9) { + tmp34 := checkDerefVar(var_glojure_DOT_core_first) + tmp35 := lang.Apply(tmp34, []any{v9}) + tmp36 := checkDerefVar(var_glojure_DOT_core_next) + tmp37 := lang.Apply(tmp36, []any{v9}) + tmp38 := lang.Apply(v7, []any{tmp35, tmp37}) + tmp33 = tmp38 } else { } - tmp27 = tmp31 - } // end let - tmp23 = tmp27 - } - tmp16 = tmp23 - break - } - } // end let - _ = tmp16 - tmp17, ok := lang.FieldOrMethod(nil, "MILLISECONDS") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "MILLISECONDS"))) - } - var tmp18 any - switch reflect.TypeOf(tmp17).Kind() { - case reflect.Func: - tmp18 = lang.Apply(tmp17, nil) - default: - tmp18 = tmp17 - } - tmp19, _ := lang.FieldOrMethod(v11, "await") - if reflect.TypeOf(tmp19).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) - } - tmp20 := lang.Apply(tmp19, []any{v3, tmp18}) - tmp10 = tmp20 - } // end let - tmp5 = tmp10 - } + tmp15 = tmp33 + } + tmp11 = tmp15 + } // end let + return tmp11 + }) + tmp11 := lang.Apply(lang.NewLazySeq, []any{tmp10}) + return tmp11 + }) + v7 = tmp6 + _ = v7 + } + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(726), kw_column, int(16), kw_end_DASH_line, int(735), kw_end_DASH_column, int(56)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v9 any = tmp8 + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_concat) + tmp11 := lang.Apply(tmp10, []any{v2, v3}) + tmp12 := lang.Apply(v9, []any{tmp11, v4}) + tmp5 = tmp12 + } // end let return tmp5 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_concat = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_concat.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // await1 + // cond { - tmp0 := sym_await1.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(3284), kw_column, int(7), kw_end_DASH_line, int(3284), kw_end_DASH_column, int(21), kw_arglists, lang.NewList(lang.NewVector(sym_a)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) - tmp6, ok := lang.FieldOrMethod(v3, "getQueueCount") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getQueueCount"))) - } - var tmp7 any - switch reflect.TypeOf(tmp6).Kind() { - case reflect.Func: - tmp7 = lang.Apply(tmp6, nil) + tmp0 := sym_cond.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_clauses)), kw_doc, "Takes a set of test/expr pairs. It evaluates each test one at a\n time. If a test returns logical true, cond evaluates and returns\n the value of the corresponding expr and doesn't evaluate any of the\n other tests or exprs. (cond) returns nil.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(11), kw_line, int(569), kw_end_DASH_line, int(569))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { default: - tmp7 = tmp6 - } - tmp8 := lang.Apply(tmp5, []any{tmp7}) - if lang.IsTruthy(tmp8) { - tmp9 := checkDerefVar(var_glojure_DOT_core_await) - tmp10 := lang.Apply(tmp9, []any{v3}) - tmp4 = tmp10 - } else { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + if lang.IsTruthy(v4) { + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := checkDerefVar(var_glojure_DOT_core_first) + tmp8 := lang.Apply(tmp7, []any{v4}) + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_next) + tmp11 := lang.Apply(tmp10, []any{v4}) + if lang.IsTruthy(tmp11) { + tmp12 := checkDerefVar(var_glojure_DOT_core_second) + tmp13 := lang.Apply(tmp12, []any{v4}) + tmp9 = tmp13 + } else { + tmp14 := lang.Apply(lang.NewIllegalArgumentError, []any{"cond requires an even number of forms"}) + panic(tmp14) + } + tmp15 := checkDerefVar(var_glojure_DOT_core_cons) + tmp16 := checkDerefVar(var_glojure_DOT_core_next) + tmp17 := checkDerefVar(var_glojure_DOT_core_next) + tmp18 := lang.Apply(tmp17, []any{v4}) + tmp19 := lang.Apply(tmp16, []any{tmp18}) + tmp20 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_cond, tmp19}) + tmp21 := lang.Apply(tmp6, []any{sym_if, tmp8, tmp9, tmp20}) + tmp5 = tmp21 + } else { + } + return tmp5 } - _ = tmp4 - return v3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_cond = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_cond.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // bases + // conj { - tmp0 := sym_bases.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_c)), kw_doc, "Returns the immediate superclass and direct interfaces of c, if any", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(5522), kw_end_DASH_line, int(5522))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 any - if lang.IsTruthy(v3) { - var tmp5 any - { // let - // let binding "i" - tmp6 := checkDerefVar(var_glojure_DOT_core_seq) - tmp7 := lang.Apply(tmp6, []any{nil}) - var v8 any = tmp7 - _ = v8 - // let binding "s" - var v9 any = nil - _ = v9 - var tmp10 any - if lang.IsTruthy(v9) { - tmp11 := checkDerefVar(var_glojure_DOT_core_cons) - tmp12 := lang.Apply(tmp11, []any{v9, v8}) - tmp10 = tmp12 + tmp0 := sym_conj.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_coll), lang.NewVector(sym_coll, sym_x), lang.NewVector(sym_coll, sym_x, sym__AMP_, sym_xs)), kw_doc, "conj[oin]. Returns a new collection with the xs\n 'added'. (conj nil item) returns (item).\n (conj coll) returns coll. (conj) returns [].\n The 'addition' may happen at different 'places' depending\n on the concrete type.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(5), kw_column, int(2), kw_line, int(73), kw_end_DASH_line, int(81))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function conj + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp3 := lang.NewVector() + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(82), kw_column, int(13), kw_end_DASH_line, int(82), kw_end_DASH_column, int(14)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 1: + v3 := args[0] + _ = v3 + return v3 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(lang.Conj, []any{v3, v4}) + return tmp5 + default: + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + recur_loop_10: + var tmp6 any + if lang.IsTruthy(v5) { + tmp8 := lang.Apply(lang.Conj, []any{v3, v4}) + var tmp7 any = tmp8 + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v5}) + var tmp9 any = tmp11 + tmp13 := checkDerefVar(var_glojure_DOT_core_next) + tmp14 := lang.Apply(tmp13, []any{v5}) + var tmp12 any = tmp14 + v3 = tmp7 + v4 = tmp9 + v5 = tmp12 + goto recur_loop_10 } else { - tmp10 = v8 + tmp15 := lang.Apply(lang.Conj, []any{v3, v4}) + tmp6 = tmp15 } - tmp5 = tmp10 - } // end let - tmp4 = tmp5 - } else { + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(81), kw_column, int(7), kw_end_DASH_line, int(88), kw_end_DASH_column, int(67))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_conj = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_conj.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // conj! + { + tmp0 := sym_conj_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_coll), lang.NewVector(sym_coll, sym_x)), kw_doc, "Adds x to the transient collection, and return coll. The 'addition'\n may happen at different 'places' depending on the concrete type.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3359), kw_end_DASH_line, int(3359))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp2 := checkDerefVar(var_glojure_DOT_core_transient) + tmp3 := lang.NewVector() + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3364), kw_column, int(18), kw_end_DASH_line, int(3364), kw_end_DASH_column, int(19)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp6 := lang.Apply(tmp2, []any{tmp5}) + return tmp6 + case 1: + v2 := args[0] + _ = v2 + return v2 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "Conj") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Conj is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_conj_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_conj_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // count + { + var tmp1 lang.FnFunc + { // function count__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Count}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_count.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_inline, tmp1, kw_doc, "Returns the number of items in the collection. (count nil) returns\n 0. Also works on strings, arrays, and Java Collections and Maps", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(867), kw_end_DASH_line, int(867))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.Count, []any{v3}) return tmp4 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core_count = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_count.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // bigdec + // counted? { - tmp1 := reflect.TypeOf((*lang.BigDecimal)(nil)) - tmp0 := sym_bigdec.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Coerce to BigDecimal", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(3648), kw_end_DASH_line, int(3648))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_counted_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns true if coll implements count in constant time", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(6241), kw_end_DASH_line, int(6241))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v4 := args[0] - _ = v4 - var tmp5 any - tmp6 := checkDerefVar(var_glojure_DOT_core_decimal_QMARK_) - tmp7 := lang.Apply(tmp6, []any{v4}) - if lang.IsTruthy(tmp7) { - tmp5 = v4 - } else { - var tmp8 any - tmp9 := checkDerefVar(var_glojure_DOT_core_float_QMARK_) - tmp10 := lang.Apply(tmp9, []any{v4}) - if lang.IsTruthy(tmp10) { - tmp11 := checkDerefVar(var_glojure_DOT_core_double) - tmp12 := lang.Apply(tmp11, []any{v4}) - tmp13 := lang.Apply(lang.NewBigDecimalFromFloat64, []any{tmp12}) - tmp8 = tmp13 - } else { - var tmp14 any - tmp15 := checkDerefVar(var_glojure_DOT_core_ratio_QMARK_) - tmp16 := lang.Apply(tmp15, []any{v4}) - if lang.IsTruthy(tmp16) { - tmp17 := checkDerefVar(var_glojure_DOT_core__SLASH_) - tmp18 := lang.Apply(lang.NewBigDecimalFromRatio, []any{v4}) - tmp19, ok := lang.FieldOrMethod(v4, "denominator") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "denominator"))) - } - var tmp20 any - switch reflect.TypeOf(tmp19).Kind() { - case reflect.Func: - tmp20 = lang.Apply(tmp19, nil) - default: - tmp20 = tmp19 - } - tmp21 := lang.Apply(tmp17, []any{tmp18, tmp20}) - tmp14 = tmp21 - } else { - var tmp22 any - tmp23 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp24 := reflect.TypeOf((*lang.BigInt)(nil)) - tmp25 := lang.Apply(tmp23, []any{tmp24, v4}) - if lang.IsTruthy(tmp25) { - tmp26, ok := lang.FieldOrMethod(v4, "toBigDecimal") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "toBigDecimal"))) - } - var tmp27 any - switch reflect.TypeOf(tmp26).Kind() { - case reflect.Func: - tmp27 = lang.Apply(tmp26, nil) - default: - tmp27 = tmp26 - } - tmp22 = tmp27 - } else { - var tmp28 any - tmp29 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp30 := reflect.TypeOf((*big9.Int)(nil)) - tmp31 := lang.Apply(tmp29, []any{tmp30, v4}) - if lang.IsTruthy(tmp31) { - tmp32 := lang.Apply(lang.NewBigDecimal, []any{v4}) - tmp28 = tmp32 - } else { - var tmp33 any - tmp34 := checkDerefVar(var_glojure_DOT_core_number_QMARK_) - tmp35 := lang.Apply(tmp34, []any{v4}) - if lang.IsTruthy(tmp35) { - tmp36 := checkDerefVar(var_glojure_DOT_core_long) - tmp37 := lang.Apply(tmp36, []any{v4}) - tmp38 := lang.Apply(lang.NewBigDecimalFromInt64, []any{tmp37}) - tmp33 = tmp38 - } else { - var tmp39 any - if lang.IsTruthy(kw_else) { - tmp40 := lang.Apply(lang.NewBigDecimal, []any{v4}) - tmp39 = tmp40 - } else { - } - tmp33 = tmp39 - } - tmp28 = tmp33 - } - tmp22 = tmp28 - } - tmp14 = tmp22 - } - tmp8 = tmp14 - } - tmp5 = tmp8 - } + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*lang.Counted)(nil)).Elem() + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) return tmp5 }) - tmp4 := reflect.TypeOf((*lang.BigDecimal)(nil)) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_counted_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_counted_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // bigint + // cycle { - tmp1 := reflect.TypeOf((*lang.BigInt)(nil)) - tmp0 := sym_bigint.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Coerce to BigInt", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(3620), kw_end_DASH_line, int(3620))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_cycle.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a lazy (infinite!) sequence of repetitions of the items in coll.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(2977), kw_end_DASH_line, int(2977))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v4 := args[0] - _ = v4 - var tmp5 any - tmp6 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp7 := reflect.TypeOf((*lang.BigInt)(nil)) - tmp8 := lang.Apply(tmp6, []any{tmp7, v4}) - if lang.IsTruthy(tmp8) { - tmp5 = v4 - } else { - var tmp9 any - tmp10 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp11 := reflect.TypeOf((*big9.Int)(nil)) - tmp12 := lang.Apply(tmp10, []any{tmp11, v4}) - if lang.IsTruthy(tmp12) { - tmp13 := lang.Apply(lang.NewBigIntFromGoBigInt, []any{v4}) - tmp9 = tmp13 - } else { - var tmp14 any - tmp15 := checkDerefVar(var_glojure_DOT_core_decimal_QMARK_) - tmp16 := lang.Apply(tmp15, []any{v4}) - if lang.IsTruthy(tmp16) { - tmp17 := checkDerefVar(var_glojure_DOT_core_bigint) - tmp18, ok := lang.FieldOrMethod(v4, "toBigInteger") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "toBigInteger"))) - } - var tmp19 any - switch reflect.TypeOf(tmp18).Kind() { - case reflect.Func: - tmp19 = lang.Apply(tmp18, nil) - default: - tmp19 = tmp18 - } - tmp20 := lang.Apply(tmp17, []any{tmp19}) - tmp14 = tmp20 - } else { - var tmp21 any - tmp22 := checkDerefVar(var_glojure_DOT_core_float_QMARK_) - tmp23 := lang.Apply(tmp22, []any{v4}) - if lang.IsTruthy(tmp23) { - tmp24 := checkDerefVar(var_glojure_DOT_core_bigint) - tmp25 := checkDerefVar(var_glojure_DOT_core_double) - tmp26 := lang.Apply(tmp25, []any{v4}) - tmp27 := lang.Apply(lang.NewBigDecimalFromFloat64, []any{tmp26}) - tmp28 := lang.Apply(tmp24, []any{tmp27}) - tmp21 = tmp28 - } else { - var tmp29 any - tmp30 := checkDerefVar(var_glojure_DOT_core_ratio_QMARK_) - tmp31 := lang.Apply(tmp30, []any{v4}) - if lang.IsTruthy(tmp31) { - tmp32 := checkDerefVar(var_glojure_DOT_core_bigint) - tmp33, ok := lang.FieldOrMethod(v4, "bigIntegerValue") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "bigIntegerValue"))) - } - var tmp34 any - switch reflect.TypeOf(tmp33).Kind() { - case reflect.Func: - tmp34 = lang.Apply(tmp33, nil) - default: - tmp34 = tmp33 - } - tmp35 := lang.Apply(tmp32, []any{tmp34}) - tmp29 = tmp35 - } else { - var tmp36 any - tmp37 := checkDerefVar(var_glojure_DOT_core_number_QMARK_) - tmp38 := lang.Apply(tmp37, []any{v4}) - if lang.IsTruthy(tmp38) { - tmp39 := checkDerefVar(var_glojure_DOT_core_long) - tmp40 := lang.Apply(tmp39, []any{v4}) - tmp41 := lang.Apply(lang.NewBigIntFromInt64, []any{tmp40}) - tmp36 = tmp41 - } else { - var tmp42 any - if lang.IsTruthy(kw_else) { - tmp43 := checkDerefVar(var_glojure_DOT_core_bigint) - tmp44 := lang.Apply(lang.NewBigInt, []any{v4}) - tmp45 := lang.Apply(tmp43, []any{tmp44}) - tmp42 = tmp45 - } else { - } - tmp36 = tmp42 - } - tmp29 = tmp36 - } - tmp21 = tmp29 - } - tmp14 = tmp21 - } - tmp9 = tmp14 - } - tmp5 = tmp9 - } + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_seq) + tmp4 := lang.Apply(tmp3, []any{v2}) + tmp5 := lang.Apply(lang.NewCycle, []any{tmp4}) return tmp5 }) - tmp4 := reflect.TypeOf((*lang.BigInt)(nil)) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_cycle = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_cycle.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // biginteger + // dec { - tmp1 := reflect.TypeOf((*big9.Int)(nil)) - tmp0 := sym_biginteger.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Coerce to BigInteger", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(3634), kw_end_DASH_line, int(3634))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - var tmp5 any - tmp6 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp7 := reflect.TypeOf((*big9.Int)(nil)) - tmp8 := lang.Apply(tmp6, []any{tmp7, v4}) - if lang.IsTruthy(tmp8) { - tmp5 = v4 - } else { - var tmp9 any - tmp10 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp11 := reflect.TypeOf((*lang.BigInt)(nil)) - tmp12 := lang.Apply(tmp10, []any{tmp11, v4}) - if lang.IsTruthy(tmp12) { - tmp13, ok := lang.FieldOrMethod(v4, "toBigInteger") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "toBigInteger"))) - } - var tmp14 any - switch reflect.TypeOf(tmp13).Kind() { - case reflect.Func: - tmp14 = lang.Apply(tmp13, nil) - default: - tmp14 = tmp13 - } - tmp9 = tmp14 + var tmp1 lang.FnFunc + { // function dec__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp15) { + tmp14 = sym_unchecked_dec } else { - var tmp15 any - tmp16 := checkDerefVar(var_glojure_DOT_core_decimal_QMARK_) - tmp17 := lang.Apply(tmp16, []any{v4}) - if lang.IsTruthy(tmp17) { - tmp18, ok := lang.FieldOrMethod(v4, "toBigInteger") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "toBigInteger"))) - } - var tmp19 any - switch reflect.TypeOf(tmp18).Kind() { - case reflect.Func: - tmp19 = lang.Apply(tmp18, nil) - default: - tmp19 = tmp18 - } - tmp15 = tmp19 - } else { - var tmp20 any - tmp21 := checkDerefVar(var_glojure_DOT_core_float_QMARK_) - tmp22 := lang.Apply(tmp21, []any{v4}) - if lang.IsTruthy(tmp22) { - tmp23 := checkDerefVar(var_glojure_DOT_core_double) - tmp24 := lang.Apply(tmp23, []any{v4}) - tmp25 := lang.Apply(lang.NewBigDecimalFromFloat64, []any{tmp24}) - tmp26, ok := lang.FieldOrMethod(tmp25, "toBigInteger") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp25, "toBigInteger"))) - } - var tmp27 any - switch reflect.TypeOf(tmp26).Kind() { - case reflect.Func: - tmp27 = lang.Apply(tmp26, nil) - default: - tmp27 = tmp26 - } - tmp20 = tmp27 - } else { - var tmp28 any - tmp29 := checkDerefVar(var_glojure_DOT_core_ratio_QMARK_) - tmp30 := lang.Apply(tmp29, []any{v4}) - if lang.IsTruthy(tmp30) { - tmp31, ok := lang.FieldOrMethod(v4, "bigIntegerValue") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "bigIntegerValue"))) - } - var tmp32 any - switch reflect.TypeOf(tmp31).Kind() { - case reflect.Func: - tmp32 = lang.Apply(tmp31, nil) - default: - tmp32 = tmp31 - } - tmp28 = tmp32 - } else { - var tmp33 any - tmp34 := checkDerefVar(var_glojure_DOT_core_number_QMARK_) - tmp35 := lang.Apply(tmp34, []any{v4}) - if lang.IsTruthy(tmp35) { - tmp36 := checkDerefVar(var_glojure_DOT_core_long) - tmp37 := lang.Apply(tmp36, []any{v4}) - tmp38 := lang.Apply(big9.NewInt, []any{tmp37}) - tmp33 = tmp38 - } else { - var tmp39 any - if lang.IsTruthy(kw_else) { - tmp40 := lang.Apply(lang.NewBigInt, []any{v4}) - tmp39 = tmp40 - } else { - } - tmp33 = tmp39 - } - tmp28 = tmp33 - } - tmp20 = tmp28 - } - tmp15 = tmp20 - } - tmp9 = tmp15 + tmp14 = sym_dec } - tmp5 = tmp9 + tmp16 := lang.Apply(tmp13, []any{tmp14}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := lang.Apply(tmp12, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp11, []any{tmp19}) + tmp21 := lang.Apply(tmp10, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_dec.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns a number one less than num. Does not auto-promote\n longs, will throw on overflow. See also: dec'", kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(1147), kw_end_DASH_line, int(1147))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Dec") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Dec is not a function"))) } + tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 }) - tmp4 := reflect.TypeOf((*big9.Int)(nil)) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_dec = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_dec.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // binding + // dec' { - tmp0 := sym_binding.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "binding => var-symbol init-expr\n\n Creates new bindings for the (already-existing) vars, with the\n supplied initial values, executes the exprs in an implicit do, then\n re-establishes the bindings that existed before. The new bindings\n are made in parallel (unlike let); all init-exprs are evaluated\n before the vars are bound to their new values.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(1945), kw_end_DASH_line, int(1945))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function dec'__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_DecP}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_dec_TICK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns a number one less than num. Supports arbitrary precision.\n See also: dec", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1140), kw_end_DASH_line, int(1140))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "DecP") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("DecP is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_dec_TICK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_dec_TICK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // decimal? + { + tmp0 := sym_decimal_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_doc, "Returns true if n is a BigDecimal", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(3599), kw_end_DASH_line, int(3599))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*lang.BigDecimal)(nil)) + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_decimal_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_decimal_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // defmethod + { + tmp0 := sym_defmethod.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_multifn, sym_dispatch_DASH_val, sym__AMP_, sym_fn_DASH_tail)), kw_doc, "Creates and installs a new method of multimethod associated with dispatch-value. ", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(11), kw_line, int(1781), kw_end_DASH_line, int(1781))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) - v3 := args[0] + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + v4 := args[2] _ = v4 - v5 := args[2] + v5 := args[3] _ = v5 - var v6 any = lang.NewList(args[3:]...) + var v6 any = lang.NewList(args[4:]...) _ = v6 - var tmp7 any - tmp8 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) - tmp9 := lang.Apply(tmp8, []any{v5}) - if lang.IsTruthy(tmp9) { - } else { - tmp10 := checkDerefVar(var_glojure_DOT_core_str) - tmp11 := checkDerefVar(var_glojure_DOT_core_first) - tmp12 := lang.Apply(tmp11, []any{v3}) - tmp13 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) - tmp14 := checkDerefVar(var_glojure_DOT_core_meta) - tmp15 := lang.Apply(tmp14, []any{v3}) - tmp16 := lang.Apply(kw_line, []any{tmp15}) - tmp17 := lang.Apply(tmp10, []any{tmp12, " requires ", "a vector for its binding", " in ", tmp13, ":", tmp16}) - tmp18 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp17}) - panic(tmp18) + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp13 := lang.NewMap(kw_tag, sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT__STAR_MultiFn) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(1785), kw_column, int(27), kw_end_DASH_line, int(1785), kw_end_DASH_column, int(82)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) } - _ = tmp7 - var tmp19 any - tmp20 := checkDerefVar(var_glojure_DOT_core_even_QMARK_) - tmp21 := checkDerefVar(var_glojure_DOT_core_count) - tmp22 := lang.Apply(tmp21, []any{v5}) - tmp23 := lang.Apply(tmp20, []any{tmp22}) - if lang.IsTruthy(tmp23) { - } else { - tmp24 := checkDerefVar(var_glojure_DOT_core_str) - tmp25 := checkDerefVar(var_glojure_DOT_core_first) - tmp26 := lang.Apply(tmp25, []any{v3}) - tmp27 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) - tmp28 := checkDerefVar(var_glojure_DOT_core_meta) - tmp29 := lang.Apply(tmp28, []any{v3}) - tmp30 := lang.Apply(kw_line, []any{tmp29}) - tmp31 := lang.Apply(tmp24, []any{tmp26, " requires ", "an even number of forms in binding vector", " in ", tmp27, ":", tmp30}) - tmp32 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp31}) - panic(tmp32) - } - _ = tmp19 - var tmp33 any - { // let - // let binding "var-ize" - var tmp34 lang.FnFunc - tmp34 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v35 := args[0] - _ = v35 - var tmp36 any - { // let - // let binding "ret" - tmp37 := lang.NewVector() - tmp38 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(1959), kw_column, int(30), kw_end_DASH_line, int(1959), kw_end_DASH_column, int(31)) - tmp39, err := lang.WithMeta(tmp37, tmp38.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v40 any = tmp39 - _ = v40 - // let binding "vvs" - tmp41 := checkDerefVar(var_glojure_DOT_core_seq) - tmp42 := lang.Apply(tmp41, []any{v35}) - var v43 any = tmp42 - _ = v43 - for { - var tmp44 any - if lang.IsTruthy(v43) { - tmp46 := checkDerefVar(var_glojure_DOT_core_conj) - tmp47 := checkDerefVar(var_glojure_DOT_core_conj) - tmp48 := checkDerefVar(var_glojure_DOT_core_seq) - tmp49 := checkDerefVar(var_glojure_DOT_core_concat) - tmp50 := checkDerefVar(var_glojure_DOT_core_list) - tmp51 := lang.Apply(tmp50, []any{sym_var}) - tmp52 := checkDerefVar(var_glojure_DOT_core_list) - tmp53 := checkDerefVar(var_glojure_DOT_core_first) - tmp54 := lang.Apply(tmp53, []any{v43}) - tmp55 := lang.Apply(tmp52, []any{tmp54}) - tmp56 := lang.Apply(tmp49, []any{tmp51, tmp55}) - tmp57 := lang.Apply(tmp48, []any{tmp56}) - tmp58 := lang.Apply(tmp47, []any{v40, tmp57}) - tmp59 := checkDerefVar(var_glojure_DOT_core_second) - tmp60 := lang.Apply(tmp59, []any{v43}) - tmp61 := lang.Apply(tmp46, []any{tmp58, tmp60}) - var tmp45 any = tmp61 - tmp63 := checkDerefVar(var_glojure_DOT_core_next) - tmp64 := checkDerefVar(var_glojure_DOT_core_next) - tmp65 := lang.Apply(tmp64, []any{v43}) - tmp66 := lang.Apply(tmp63, []any{tmp65}) - var tmp62 any = tmp66 - v40 = tmp45 - v43 = tmp62 - continue - } else { - tmp67 := checkDerefVar(var_glojure_DOT_core_seq) - tmp68 := lang.Apply(tmp67, []any{v40}) - tmp44 = tmp68 - } - tmp36 = tmp44 - break - } - } // end let - return tmp36 - }) - tmp35 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(1958), kw_column, int(17), kw_end_DASH_line, int(1963), kw_end_DASH_column, int(34)) - tmp36, err := lang.WithMeta(tmp34, tmp35.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v37 any = tmp36 - _ = v37 - tmp38 := checkDerefVar(var_glojure_DOT_core_seq) - tmp39 := checkDerefVar(var_glojure_DOT_core_concat) - tmp40 := checkDerefVar(var_glojure_DOT_core_list) - tmp41 := lang.Apply(tmp40, []any{sym_glojure_DOT_core_SLASH_let}) - tmp42 := checkDerefVar(var_glojure_DOT_core_list) - tmp43 := checkDerefVar(var_glojure_DOT_core_apply) - tmp44 := checkDerefVar(var_glojure_DOT_core_vector) - tmp45 := checkDerefVar(var_glojure_DOT_core_seq) - tmp46 := checkDerefVar(var_glojure_DOT_core_concat) - tmp47 := lang.Apply(tmp46, nil) - tmp48 := lang.Apply(tmp45, []any{tmp47}) - tmp49 := lang.Apply(tmp43, []any{tmp44, tmp48}) - tmp50 := lang.Apply(tmp42, []any{tmp49}) - tmp51 := checkDerefVar(var_glojure_DOT_core_list) - tmp52 := checkDerefVar(var_glojure_DOT_core_seq) - tmp53 := checkDerefVar(var_glojure_DOT_core_concat) - tmp54 := checkDerefVar(var_glojure_DOT_core_list) - tmp55 := lang.Apply(tmp54, []any{sym_glojure_DOT_core_SLASH_push_DASH_thread_DASH_bindings}) - tmp56 := checkDerefVar(var_glojure_DOT_core_list) - tmp57 := checkDerefVar(var_glojure_DOT_core_seq) - tmp58 := checkDerefVar(var_glojure_DOT_core_concat) - tmp59 := checkDerefVar(var_glojure_DOT_core_list) - tmp60 := lang.Apply(tmp59, []any{sym_glojure_DOT_core_SLASH_hash_DASH_map}) - tmp61 := lang.Apply(v37, []any{v5}) - tmp62 := lang.Apply(tmp58, []any{tmp60, tmp61}) - tmp63 := lang.Apply(tmp57, []any{tmp62}) - tmp64 := lang.Apply(tmp56, []any{tmp63}) - tmp65 := lang.Apply(tmp53, []any{tmp55, tmp64}) - tmp66 := lang.Apply(tmp52, []any{tmp65}) - tmp67 := lang.Apply(tmp51, []any{tmp66}) - tmp68 := checkDerefVar(var_glojure_DOT_core_list) - tmp69 := checkDerefVar(var_glojure_DOT_core_seq) - tmp70 := checkDerefVar(var_glojure_DOT_core_concat) - tmp71 := checkDerefVar(var_glojure_DOT_core_list) - tmp72 := lang.Apply(tmp71, []any{sym_try}) - tmp73 := checkDerefVar(var_glojure_DOT_core_list) - tmp74 := checkDerefVar(var_glojure_DOT_core_seq) - tmp75 := checkDerefVar(var_glojure_DOT_core_concat) - tmp76 := checkDerefVar(var_glojure_DOT_core_list) - tmp77 := lang.Apply(tmp76, []any{sym_finally}) - tmp78 := checkDerefVar(var_glojure_DOT_core_list) - tmp79 := checkDerefVar(var_glojure_DOT_core_seq) - tmp80 := checkDerefVar(var_glojure_DOT_core_concat) - tmp81 := checkDerefVar(var_glojure_DOT_core_list) - tmp82 := lang.Apply(tmp81, []any{sym_glojure_DOT_core_SLASH_pop_DASH_thread_DASH_bindings}) - tmp83 := lang.Apply(tmp80, []any{tmp82}) - tmp84 := lang.Apply(tmp79, []any{tmp83}) - tmp85 := lang.Apply(tmp78, []any{tmp84}) - tmp86 := lang.Apply(tmp75, []any{tmp77, tmp85}) - tmp87 := lang.Apply(tmp74, []any{tmp86}) - tmp88 := lang.Apply(tmp73, []any{tmp87}) - tmp89 := lang.Apply(tmp70, []any{tmp72, v6, tmp88}) - tmp90 := lang.Apply(tmp69, []any{tmp89}) - tmp91 := lang.Apply(tmp68, []any{tmp90}) - tmp92 := lang.Apply(tmp39, []any{tmp41, tmp50, tmp67, tmp91}) - tmp93 := lang.Apply(tmp38, []any{tmp92}) - tmp33 = tmp93 - } // end let - return tmp33 + tmp16 := lang.Apply(tmp12, []any{v4, tmp15}) + tmp17 := lang.Apply(tmp11, []any{tmp16}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{sym_glojure_DOT_core_SLASH_AddMethod}) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{v5}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := checkDerefVar(var_glojure_DOT_core_seq) + tmp24 := checkDerefVar(var_glojure_DOT_core_concat) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := lang.Apply(tmp25, []any{sym_glojure_DOT_core_SLASH_fn}) + tmp27 := lang.Apply(tmp24, []any{tmp26, v6}) + tmp28 := lang.Apply(tmp23, []any{tmp27}) + tmp29 := lang.Apply(tmp22, []any{tmp28}) + tmp30 := lang.Apply(tmp8, []any{tmp10, tmp17, tmp19, tmp21, tmp29}) + tmp31 := lang.Apply(tmp7, []any{tmp30}) + return tmp31 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_defmethod = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_defmethod.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // binding-conveyor-fn + // defstruct { - tmp0 := sym_binding_DASH_conveyor_DASH_fn.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f)), kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(25), kw_column, int(7), kw_line, int(2020), kw_end_DASH_line, int(2020), kw_private, true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_defstruct.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym__AMP_, sym_keys)), kw_doc, "Same as (def name (create-struct keys...))", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(11), kw_line, int(4044), kw_end_DASH_line, int(4044))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_def}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{v4}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_create_DASH_struct}) + tmp17 := lang.Apply(tmp14, []any{tmp16, v5}) + tmp18 := lang.Apply(tmp13, []any{tmp17}) + tmp19 := lang.Apply(tmp12, []any{tmp18}) + tmp20 := lang.Apply(tmp7, []any{tmp9, tmp11, tmp19}) + tmp21 := lang.Apply(tmp6, []any{tmp20}) + return tmp21 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_defstruct = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_defstruct.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // delay? + { + tmp0 := sym_delay_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "returns true if x is a Delay created with delay", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(748), kw_end_DASH_line, int(748))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "frame" - tmp5 := lang.Apply(lang.CloneThreadBindingFrame, nil) - var v6 any = tmp5 - _ = v6 - var tmp7 lang.FnFunc - tmp7 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp8 := lang.Apply(lang.ResetThreadBindingFrame, []any{v6}) - _ = tmp8 - tmp9 := lang.Apply(v3, nil) - return tmp9 - case 1: - v8 := args[0] - _ = v8 - tmp9 := lang.Apply(lang.ResetThreadBindingFrame, []any{v6}) - _ = tmp9 - tmp10 := lang.Apply(v3, []any{v8}) - return tmp10 - case 2: - v8 := args[0] - _ = v8 - v9 := args[1] - _ = v9 - tmp10 := lang.Apply(lang.ResetThreadBindingFrame, []any{v6}) - _ = tmp10 - tmp11 := lang.Apply(v3, []any{v8, v9}) - return tmp11 - case 3: - v8 := args[0] - _ = v8 - v9 := args[1] - _ = v9 - v10 := args[2] - _ = v10 - tmp11 := lang.Apply(lang.ResetThreadBindingFrame, []any{v6}) - _ = tmp11 - tmp12 := lang.Apply(v3, []any{v8, v9, v10}) - return tmp12 - default: - checkArity(args, 3) - v8 := args[0] - _ = v8 - v9 := args[1] - _ = v9 - v10 := args[2] - _ = v10 - var v11 any = lang.NewList(args[3:]...) - _ = v11 - tmp12 := lang.Apply(lang.ResetThreadBindingFrame, []any{v6}) - _ = tmp12 - tmp13 := checkDerefVar(var_glojure_DOT_core_apply) - tmp14 := lang.Apply(tmp13, []any{v3, v8, v9, v10, v11}) - return tmp14 - } - }) - tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2025), kw_column, int(5), kw_end_DASH_line, int(2040), kw_end_DASH_column, int(31)) - tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp4 = tmp9 - } // end let + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := lang.Apply(tmp3, []any{nil, v2}) return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_delay_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_delay_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // bit-and + // deref { + tmp0 := sym_deref.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ref), lang.NewVector(sym_ref, sym_timeout_DASH_ms, sym_timeout_DASH_val)), kw_doc, "Also reader macro: @ref/@agent/@var/@atom/@delay/@future/@promise. Within a transaction,\n returns the in-transaction-value of ref, else returns the\n most-recently-committed value of ref. When applied to a var, agent\n or atom, returns its current state. When applied to a delay, forces\n it if not already forced. When applied to a future, will block if\n computation not complete. When applied to a promise, will block\n until a value is delivered. The variant taking a timeout can be\n used for blocking references (futures and promises), and will return\n timeout-val if the timeout (in milliseconds) is reached before a\n value is available. See also - realized?.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(2304), kw_end_DASH_line, int(2304))).(*lang.Symbol) var tmp1 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -10592,77 +9276,88 @@ func LoadNS() { v2 := args[0] _ = v2 var tmp3 any - { // let - // let binding "op" - var tmp4 any - tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) - if lang.IsTruthy(tmp5) { - tmp4 = closed29 - } else { - tmp4 = closed29 + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := reflect.TypeOf((*lang.IDeref)(nil)).Elem() + tmp6 := lang.Apply(tmp4, []any{tmp5, v2}) + if lang.IsTruthy(tmp6) { + tmp7, ok := lang.FieldOrMethod(v2, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "Deref"))) } - var v6 any = tmp4 - _ = v6 - tmp7 := checkDerefVar(var_glojure_DOT_core_seq) - tmp8 := checkDerefVar(var_glojure_DOT_core_concat) - tmp9 := checkDerefVar(var_glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) - tmp11 := checkDerefVar(var_glojure_DOT_core_list) - tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := checkDerefVar(var_glojure_DOT_core_seq) - tmp15 := checkDerefVar(var_glojure_DOT_core_concat) - tmp16 := checkDerefVar(var_glojure_DOT_core_list) - tmp17 := lang.Apply(tmp16, []any{v6}) - tmp18 := checkDerefVar(var_glojure_DOT_core_list) - tmp19 := lang.Apply(tmp18, []any{v2}) - tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) - tmp21 := lang.Apply(tmp14, []any{tmp20}) - tmp22 := lang.Apply(tmp13, []any{tmp21}) - tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) - tmp24 := lang.Apply(tmp7, []any{tmp23}) - tmp3 = tmp24 - } // end let + var tmp8 any + switch reflect.TypeOf(tmp7).Kind() { + case reflect.Func: + tmp8 = lang.Apply(tmp7, nil) + default: + tmp8 = tmp7 + } + tmp3 = tmp8 + } else { + tmp9 := checkDerefVar(var_glojure_DOT_core_deref_DASH_future) + tmp10 := lang.Apply(tmp9, []any{v2}) + tmp3 = tmp10 + } return tmp3 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp7 := reflect.TypeOf((*lang.IBlockingDeref)(nil)).Elem() + tmp8 := lang.Apply(tmp6, []any{tmp7, v2}) + if lang.IsTruthy(tmp8) { + tmp9, _ := lang.FieldOrMethod(v2, "DerefWithTimeout") + if reflect.TypeOf(tmp9).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("DerefWithTimeout is not a function"))) + } + tmp10 := lang.Apply(tmp9, []any{v3, v4}) + tmp5 = tmp10 + } else { + tmp11 := checkDerefVar(var_glojure_DOT_core_deref_DASH_future) + tmp12 := lang.Apply(tmp11, []any{v2, v3, v4}) + tmp5 = tmp12 + } + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_deref = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_deref.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // disj + { + tmp0 := sym_disj.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_set), lang.NewVector(sym_set, sym_key), lang.NewVector(sym_set, sym_key, sym__AMP_, sym_ks)), kw_doc, "disj[oin]. Returns a new set of the same (hashed/sorted) type, that\n does not contain key(s).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1514), kw_end_DASH_line, int(1514))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + return v2 case 2: v2 := args[0] _ = v2 v3 := args[1] _ = v3 var tmp4 any - { // let - // let binding "op" - var tmp5 any - tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) - if lang.IsTruthy(tmp6) { - tmp5 = closed29 - } else { - tmp5 = closed29 + if lang.IsTruthy(v2) { + tmp5, _ := lang.FieldOrMethod(v2, "Disjoin") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Disjoin is not a function"))) } - var v7 any = tmp5 - _ = v7 - tmp8 := checkDerefVar(var_glojure_DOT_core_seq) - tmp9 := checkDerefVar(var_glojure_DOT_core_concat) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) - tmp12 := checkDerefVar(var_glojure_DOT_core_list) - tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := checkDerefVar(var_glojure_DOT_core_seq) - tmp16 := checkDerefVar(var_glojure_DOT_core_concat) - tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{v7}) - tmp19 := checkDerefVar(var_glojure_DOT_core_list) - tmp20 := lang.Apply(tmp19, []any{v2}) - tmp21 := checkDerefVar(var_glojure_DOT_core_list) - tmp22 := lang.Apply(tmp21, []any{v3}) - tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) - tmp24 := lang.Apply(tmp15, []any{tmp23}) - tmp25 := lang.Apply(tmp14, []any{tmp24}) - tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) - tmp27 := lang.Apply(tmp8, []any{tmp26}) - tmp4 = tmp27 - } // end let + tmp6 := lang.Apply(tmp5, []any{v3}) + tmp4 = tmp6 + } else { + } return tmp4 default: checkArity(args, 2) @@ -10672,211 +9367,194 @@ func LoadNS() { _ = v3 var v4 any = lang.NewList(args[2:]...) _ = v4 + recur_loop_304: var tmp5 any - { // let - // let binding "op" + if lang.IsTruthy(v2) { var tmp6 any - tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) - if lang.IsTruthy(tmp7) { - tmp6 = closed29 - } else { - tmp6 = closed29 - } - var v8 any = tmp6 - _ = v8 - tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) - var tmp10 lang.FnFunc - tmp10 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v11 := args[0] - _ = v11 - v12 := args[1] - _ = v12 - tmp13 := checkDerefVar(var_glojure_DOT_core_seq) - tmp14 := checkDerefVar(var_glojure_DOT_core_concat) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) - tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp19 := checkDerefVar(var_glojure_DOT_core_list) - tmp20 := checkDerefVar(var_glojure_DOT_core_seq) - tmp21 := checkDerefVar(var_glojure_DOT_core_concat) - tmp22 := checkDerefVar(var_glojure_DOT_core_list) - tmp23 := lang.Apply(tmp22, []any{v8}) - tmp24 := checkDerefVar(var_glojure_DOT_core_list) - tmp25 := lang.Apply(tmp24, []any{v11}) - tmp26 := checkDerefVar(var_glojure_DOT_core_list) - tmp27 := lang.Apply(tmp26, []any{v12}) - tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) - tmp29 := lang.Apply(tmp20, []any{tmp28}) - tmp30 := lang.Apply(tmp19, []any{tmp29}) - tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) - tmp32 := lang.Apply(tmp13, []any{tmp31}) - return tmp32 - }) - tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp13 := checkDerefVar(var_glojure_DOT_core_seq) - tmp14 := checkDerefVar(var_glojure_DOT_core_concat) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) - tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp19 := checkDerefVar(var_glojure_DOT_core_list) - tmp20 := checkDerefVar(var_glojure_DOT_core_seq) - tmp21 := checkDerefVar(var_glojure_DOT_core_concat) - tmp22 := checkDerefVar(var_glojure_DOT_core_list) - tmp23 := lang.Apply(tmp22, []any{v8}) - tmp24 := checkDerefVar(var_glojure_DOT_core_list) - tmp25 := lang.Apply(tmp24, []any{v2}) - tmp26 := checkDerefVar(var_glojure_DOT_core_list) - tmp27 := lang.Apply(tmp26, []any{v3}) - tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) - tmp29 := lang.Apply(tmp20, []any{tmp28}) - tmp30 := lang.Apply(tmp19, []any{tmp29}) - tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) - tmp32 := lang.Apply(tmp13, []any{tmp31}) - tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) - tmp5 = tmp33 - } // end let + { // let + // let binding "ret" + tmp7 := checkDerefVar(var_glojure_DOT_core_disj) + tmp8 := lang.Apply(tmp7, []any{v2, v3}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v4) { + var tmp11 any = v9 + tmp13 := checkDerefVar(var_glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v4}) + var tmp12 any = tmp14 + tmp16 := checkDerefVar(var_glojure_DOT_core_next) + tmp17 := lang.Apply(tmp16, []any{v4}) + var tmp15 any = tmp17 + v2 = tmp11 + v3 = tmp12 + v4 = tmp15 + goto recur_loop_304 + } else { + tmp10 = v9 + } + tmp6 = tmp10 + } // end let + tmp5 = tmp6 + } else { + } return tmp5 } }) - tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) - } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp0 := sym_bit_DASH_and.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Bitwise and", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(1298), kw_end_DASH_line, int(1298))).(*lang.Symbol) - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_disj = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_disj.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // disj! + { + tmp0 := sym_disj_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_set), lang.NewVector(sym_set, sym_key), lang.NewVector(sym_set, sym_key, sym__AMP_, sym_ks)), kw_doc, "disj[oin]. Returns a transient set of the same (hashed/sorted) type, that\n does not contain key(s).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3401), kw_end_DASH_line, int(3401))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { + case 1: + v2 := args[0] + _ = v2 + return v2 case 2: - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - tmp7, _ := lang.FieldOrMethod(lang.Numbers, "And") - if reflect.TypeOf(tmp7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("And is not a function"))) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "Disjoin") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Disjoin is not a function"))) } - tmp8 := lang.Apply(tmp7, []any{v5, v6}) - return tmp8 + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 default: checkArity(args, 2) - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - var v7 any = lang.NewList(args[2:]...) - _ = v7 - tmp8 := checkDerefVar(var_glojure_DOT_core_reduce1) - tmp9 := checkDerefVar(var_glojure_DOT_core_bit_DASH_and) - tmp10 := checkDerefVar(var_glojure_DOT_core_bit_DASH_and) - tmp11 := lang.Apply(tmp10, []any{v5, v6}) - tmp12 := lang.Apply(tmp8, []any{tmp9, tmp11, v7}) - return tmp12 + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + recur_loop_615: + var tmp5 any + { // let + // let binding "ret" + tmp6, _ := lang.FieldOrMethod(v2, "Disjoin") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Disjoin is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v4) { + var tmp10 any = v8 + tmp12 := checkDerefVar(var_glojure_DOT_core_first) + tmp13 := lang.Apply(tmp12, []any{v4}) + var tmp11 any = tmp13 + tmp15 := checkDerefVar(var_glojure_DOT_core_next) + tmp16 := lang.Apply(tmp15, []any{v4}) + var tmp14 any = tmp16 + v2 = tmp10 + v3 = tmp11 + v4 = tmp14 + goto recur_loop_615 + } else { + tmp9 = v8 + } + tmp5 = tmp9 + } // end let + return tmp5 } }) - tmp4 = tmp4.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp3 := ns.InternWithValue(tmp0, tmp4, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_disj_BANG_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_disj_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // bit-and-not + // dissoc { + tmp0 := sym_dissoc.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_map), lang.NewVector(sym_map, sym_key), lang.NewVector(sym_map, sym_key, sym__AMP_, sym_ks)), kw_doc, "dissoc[iate]. Returns a new map of the same (hashed/sorted) type,\n that does not contain a mapping for key(s).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(1500), kw_end_DASH_line, int(1500))).(*lang.Symbol) var tmp1 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v2 := args[0] _ = v2 - var tmp3 any - { // let - // let binding "op" - var tmp4 any - tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) - if lang.IsTruthy(tmp5) { - tmp4 = closed30 - } else { - tmp4 = closed30 - } - var v6 any = tmp4 - _ = v6 - tmp7 := checkDerefVar(var_glojure_DOT_core_seq) - tmp8 := checkDerefVar(var_glojure_DOT_core_concat) - tmp9 := checkDerefVar(var_glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) - tmp11 := checkDerefVar(var_glojure_DOT_core_list) - tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := checkDerefVar(var_glojure_DOT_core_seq) - tmp15 := checkDerefVar(var_glojure_DOT_core_concat) - tmp16 := checkDerefVar(var_glojure_DOT_core_list) - tmp17 := lang.Apply(tmp16, []any{v6}) - tmp18 := checkDerefVar(var_glojure_DOT_core_list) - tmp19 := lang.Apply(tmp18, []any{v2}) - tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) - tmp21 := lang.Apply(tmp14, []any{tmp20}) - tmp22 := lang.Apply(tmp13, []any{tmp21}) - tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) - tmp24 := lang.Apply(tmp7, []any{tmp23}) - tmp3 = tmp24 - } // end let - return tmp3 + return v2 case 2: v2 := args[0] _ = v2 v3 := args[1] _ = v3 - var tmp4 any + tmp4, _ := lang.FieldOrMethod(runtime.RT, "Dissoc") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Dissoc is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + return tmp5 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + recur_loop_301: + var tmp5 any { // let - // let binding "op" - var tmp5 any - tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) - if lang.IsTruthy(tmp6) { - tmp5 = closed30 + // let binding "ret" + tmp6 := checkDerefVar(var_glojure_DOT_core_dissoc) + tmp7 := lang.Apply(tmp6, []any{v2, v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v4) { + var tmp10 any = v8 + tmp12 := checkDerefVar(var_glojure_DOT_core_first) + tmp13 := lang.Apply(tmp12, []any{v4}) + var tmp11 any = tmp13 + tmp15 := checkDerefVar(var_glojure_DOT_core_next) + tmp16 := lang.Apply(tmp15, []any{v4}) + var tmp14 any = tmp16 + v2 = tmp10 + v3 = tmp11 + v4 = tmp14 + goto recur_loop_301 } else { - tmp5 = closed30 + tmp9 = v8 } - var v7 any = tmp5 - _ = v7 - tmp8 := checkDerefVar(var_glojure_DOT_core_seq) - tmp9 := checkDerefVar(var_glojure_DOT_core_concat) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) - tmp12 := checkDerefVar(var_glojure_DOT_core_list) - tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := checkDerefVar(var_glojure_DOT_core_seq) - tmp16 := checkDerefVar(var_glojure_DOT_core_concat) - tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{v7}) - tmp19 := checkDerefVar(var_glojure_DOT_core_list) - tmp20 := lang.Apply(tmp19, []any{v2}) - tmp21 := checkDerefVar(var_glojure_DOT_core_list) - tmp22 := lang.Apply(tmp21, []any{v3}) - tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) - tmp24 := lang.Apply(tmp15, []any{tmp23}) - tmp25 := lang.Apply(tmp14, []any{tmp24}) - tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) - tmp27 := lang.Apply(tmp8, []any{tmp26}) - tmp4 = tmp27 + tmp5 = tmp9 } // end let - return tmp4 + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_dissoc = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_dissoc.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // dissoc! + { + tmp0 := sym_dissoc_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_map, sym_key), lang.NewVector(sym_map, sym_key, sym__AMP_, sym_ks)), kw_doc, "Returns a transient map that doesn't contain a mapping for key(s).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(3382), kw_end_DASH_line, int(3382))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "without") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("without is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 default: checkArity(args, 2) v2 := args[0] @@ -10885,180 +9563,79 @@ func LoadNS() { _ = v3 var v4 any = lang.NewList(args[2:]...) _ = v4 + recur_loop_611: var tmp5 any { // let - // let binding "op" - var tmp6 any - tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) - if lang.IsTruthy(tmp7) { - tmp6 = closed30 - } else { - tmp6 = closed30 + // let binding "ret" + tmp6, _ := lang.FieldOrMethod(v2, "without") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("without is not a function"))) } - var v8 any = tmp6 + tmp7 := lang.Apply(tmp6, []any{v3}) + var v8 any = tmp7 _ = v8 - tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) - var tmp10 lang.FnFunc - tmp10 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v11 := args[0] - _ = v11 - v12 := args[1] - _ = v12 - tmp13 := checkDerefVar(var_glojure_DOT_core_seq) - tmp14 := checkDerefVar(var_glojure_DOT_core_concat) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) - tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp19 := checkDerefVar(var_glojure_DOT_core_list) - tmp20 := checkDerefVar(var_glojure_DOT_core_seq) - tmp21 := checkDerefVar(var_glojure_DOT_core_concat) - tmp22 := checkDerefVar(var_glojure_DOT_core_list) - tmp23 := lang.Apply(tmp22, []any{v8}) - tmp24 := checkDerefVar(var_glojure_DOT_core_list) - tmp25 := lang.Apply(tmp24, []any{v11}) - tmp26 := checkDerefVar(var_glojure_DOT_core_list) - tmp27 := lang.Apply(tmp26, []any{v12}) - tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) - tmp29 := lang.Apply(tmp20, []any{tmp28}) - tmp30 := lang.Apply(tmp19, []any{tmp29}) - tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) - tmp32 := lang.Apply(tmp13, []any{tmp31}) - return tmp32 - }) - tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) - if err != nil { - panic(err) + var tmp9 any + if lang.IsTruthy(v4) { + var tmp10 any = v8 + tmp12 := checkDerefVar(var_glojure_DOT_core_first) + tmp13 := lang.Apply(tmp12, []any{v4}) + var tmp11 any = tmp13 + tmp15 := checkDerefVar(var_glojure_DOT_core_next) + tmp16 := lang.Apply(tmp15, []any{v4}) + var tmp14 any = tmp16 + v2 = tmp10 + v3 = tmp11 + v4 = tmp14 + goto recur_loop_611 + } else { + tmp9 = v8 } - tmp13 := checkDerefVar(var_glojure_DOT_core_seq) - tmp14 := checkDerefVar(var_glojure_DOT_core_concat) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) - tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp19 := checkDerefVar(var_glojure_DOT_core_list) - tmp20 := checkDerefVar(var_glojure_DOT_core_seq) - tmp21 := checkDerefVar(var_glojure_DOT_core_concat) - tmp22 := checkDerefVar(var_glojure_DOT_core_list) - tmp23 := lang.Apply(tmp22, []any{v8}) - tmp24 := checkDerefVar(var_glojure_DOT_core_list) - tmp25 := lang.Apply(tmp24, []any{v2}) - tmp26 := checkDerefVar(var_glojure_DOT_core_list) - tmp27 := lang.Apply(tmp26, []any{v3}) - tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) - tmp29 := lang.Apply(tmp20, []any{tmp28}) - tmp30 := lang.Apply(tmp19, []any{tmp29}) - tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) - tmp32 := lang.Apply(tmp13, []any{tmp31}) - tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) - tmp5 = tmp33 + tmp5 = tmp9 } // end let return tmp5 } }) - tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) - } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp0 := sym_bit_DASH_and_DASH_not.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Bitwise and with complement", kw_static, true, kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(1325), kw_end_DASH_line, int(1325))).(*lang.Symbol) - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - tmp7, _ := lang.FieldOrMethod(lang.Numbers, "AndNot") - if reflect.TypeOf(tmp7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("AndNot is not a function"))) - } - tmp8 := lang.Apply(tmp7, []any{v5, v6}) - return tmp8 - default: - checkArity(args, 2) - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - var v7 any = lang.NewList(args[2:]...) - _ = v7 - tmp8 := checkDerefVar(var_glojure_DOT_core_reduce1) - tmp9 := checkDerefVar(var_glojure_DOT_core_bit_DASH_and_DASH_not) - tmp10 := checkDerefVar(var_glojure_DOT_core_bit_DASH_and_DASH_not) - tmp11 := lang.Apply(tmp10, []any{v5, v6}) - tmp12 := lang.Apply(tmp8, []any{tmp9, tmp11, v7}) - return tmp12 - } - }) - tmp4 = tmp4.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp3 := ns.InternWithValue(tmp0, tmp4, true) - if tmp0.Meta() != nil { - tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // bit-clear - { - tmp0 := sym_bit_DASH_clear.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_n)), kw_doc, "Clear bit at index n", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(1336), kw_end_DASH_line, int(1336))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "ClearBit") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ClearBit is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v3, v4}) - return tmp6 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_dissoc_BANG_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_dissoc_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // bit-flip + // dosync { - tmp0 := sym_bit_DASH_flip.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_n)), kw_doc, "Flip bit at index n", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(1348), kw_end_DASH_line, int(1348))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "FlipBit") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("FlipBit is not a function"))) + tmp0 := sym_dosync.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_exprs)), kw_doc, "Runs the exprs (in an implicit do) in a transaction that encompasses\n exprs and any nested calls. Starts a transaction if none is already\n running on this thread. Any uncaught exception will abort the\n transaction and flow out of dosync. The exprs may be run more than\n once, but any effects on Refs will be atomic.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(11), kw_line, int(5100), kw_end_DASH_line, int(5100))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym_glojure_DOT_core_SLASH_sync}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{nil}) + tmp11 := lang.Apply(tmp6, []any{tmp8, tmp10, v4}) + tmp12 := lang.Apply(tmp5, []any{tmp11}) + return tmp12 } - tmp6 := lang.Apply(tmp5, []any{v3, v4}) - return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_dosync = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_dosync.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // bit-not + // double { var tmp1 lang.FnFunc - { // function bit-not__inliner + { // function double__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) @@ -11069,12 +9646,12 @@ func LoadNS() { tmp6 := checkDerefVar(var_glojure_DOT_core_list) tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Not}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_DoubleCast}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -11087,439 +9664,247 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := sym_bit_DASH_not.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Bitwise complement", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(1291), kw_end_DASH_line, int(1291))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_double.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to double", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(3493), kw_end_DASH_line, int(3493))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Not") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Not is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.AsFloat64, []any{v3}) + return tmp4 }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_double = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_double.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // bit-or + // double-array { var tmp1 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v2 := args[0] - _ = v2 - var tmp3 any - { // let - // let binding "op" - var tmp4 any - tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) - if lang.IsTruthy(tmp5) { - tmp4 = closed31 - } else { - tmp4 = closed31 - } - var v6 any = tmp4 - _ = v6 - tmp7 := checkDerefVar(var_glojure_DOT_core_seq) - tmp8 := checkDerefVar(var_glojure_DOT_core_concat) - tmp9 := checkDerefVar(var_glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) - tmp11 := checkDerefVar(var_glojure_DOT_core_list) - tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := checkDerefVar(var_glojure_DOT_core_seq) - tmp15 := checkDerefVar(var_glojure_DOT_core_concat) - tmp16 := checkDerefVar(var_glojure_DOT_core_list) - tmp17 := lang.Apply(tmp16, []any{v6}) - tmp18 := checkDerefVar(var_glojure_DOT_core_list) - tmp19 := lang.Apply(tmp18, []any{v2}) - tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) - tmp21 := lang.Apply(tmp14, []any{tmp20}) - tmp22 := lang.Apply(tmp13, []any{tmp21}) - tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) - tmp24 := lang.Apply(tmp7, []any{tmp23}) - tmp3 = tmp24 - } // end let - return tmp3 - case 2: - v2 := args[0] - _ = v2 - v3 := args[1] - _ = v3 - var tmp4 any - { // let - // let binding "op" - var tmp5 any - tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) - if lang.IsTruthy(tmp6) { - tmp5 = closed31 - } else { - tmp5 = closed31 - } - var v7 any = tmp5 - _ = v7 - tmp8 := checkDerefVar(var_glojure_DOT_core_seq) - tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + { // function double-array__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_DoubleArray}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) - tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := checkDerefVar(var_glojure_DOT_core_seq) - tmp16 := checkDerefVar(var_glojure_DOT_core_concat) - tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{v7}) - tmp19 := checkDerefVar(var_glojure_DOT_core_list) - tmp20 := lang.Apply(tmp19, []any{v2}) - tmp21 := checkDerefVar(var_glojure_DOT_core_list) - tmp22 := lang.Apply(tmp21, []any{v3}) - tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) - tmp24 := lang.Apply(tmp15, []any{tmp23}) - tmp25 := lang.Apply(tmp14, []any{tmp24}) - tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) - tmp27 := lang.Apply(tmp8, []any{tmp26}) - tmp4 = tmp27 - } // end let - return tmp4 - default: - checkArity(args, 2) - v2 := args[0] - _ = v2 - v3 := args[1] - _ = v3 - var v4 any = lang.NewList(args[2:]...) - _ = v4 - var tmp5 any - { // let - // let binding "op" - var tmp6 any - tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) - if lang.IsTruthy(tmp7) { - tmp6 = closed31 - } else { - tmp6 = closed31 - } - var v8 any = tmp6 - _ = v8 - tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) - var tmp10 lang.FnFunc - tmp10 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v11 := args[0] - _ = v11 - v12 := args[1] - _ = v12 - tmp13 := checkDerefVar(var_glojure_DOT_core_seq) - tmp14 := checkDerefVar(var_glojure_DOT_core_concat) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) - tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp19 := checkDerefVar(var_glojure_DOT_core_list) - tmp20 := checkDerefVar(var_glojure_DOT_core_seq) - tmp21 := checkDerefVar(var_glojure_DOT_core_concat) - tmp22 := checkDerefVar(var_glojure_DOT_core_list) - tmp23 := lang.Apply(tmp22, []any{v8}) - tmp24 := checkDerefVar(var_glojure_DOT_core_list) - tmp25 := lang.Apply(tmp24, []any{v11}) - tmp26 := checkDerefVar(var_glojure_DOT_core_list) - tmp27 := lang.Apply(tmp26, []any{v12}) - tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) - tmp29 := lang.Apply(tmp20, []any{tmp28}) - tmp30 := lang.Apply(tmp19, []any{tmp29}) - tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) - tmp32 := lang.Apply(tmp13, []any{tmp31}) - return tmp32 - }) - tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) - if err != nil { - panic(err) - } tmp13 := checkDerefVar(var_glojure_DOT_core_seq) tmp14 := checkDerefVar(var_glojure_DOT_core_concat) tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_unquote_DASH_splicing}) tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp19 := checkDerefVar(var_glojure_DOT_core_list) - tmp20 := checkDerefVar(var_glojure_DOT_core_seq) - tmp21 := checkDerefVar(var_glojure_DOT_core_concat) - tmp22 := checkDerefVar(var_glojure_DOT_core_list) - tmp23 := lang.Apply(tmp22, []any{v8}) - tmp24 := checkDerefVar(var_glojure_DOT_core_list) - tmp25 := lang.Apply(tmp24, []any{v2}) - tmp26 := checkDerefVar(var_glojure_DOT_core_list) - tmp27 := lang.Apply(tmp26, []any{v3}) - tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) - tmp29 := lang.Apply(tmp20, []any{tmp28}) - tmp30 := lang.Apply(tmp19, []any{tmp29}) - tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) - tmp32 := lang.Apply(tmp13, []any{tmp31}) - tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) - tmp5 = tmp33 - } // end let - return tmp5 - } - }) - tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) + tmp18 := lang.Apply(tmp17, []any{sym_glojure_DOT_core_SLASH_args}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + } + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_double_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_size_DASH_or_DASH_seq), lang.NewVector(sym_size, sym_init_DASH_val_DASH_or_DASH_seq)), kw_inline, tmp1, kw_doc, "Creates an array of doubles", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(5341), kw_end_DASH_line, int(5341))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) - } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp0 := sym_bit_DASH_or.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Bitwise or", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(1307), kw_end_DASH_line, int(1307))).(*lang.Symbol) - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { switch len(args) { + case 1: + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "DoubleArray") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("DoubleArray is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 case 2: - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - tmp7, _ := lang.FieldOrMethod(lang.Numbers, "Or") - if reflect.TypeOf(tmp7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Or is not a function"))) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "DoubleArrayInit") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("DoubleArrayInit is not a function"))) } - tmp8 := lang.Apply(tmp7, []any{v5, v6}) - return tmp8 + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 default: - checkArity(args, 2) - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - var v7 any = lang.NewList(args[2:]...) - _ = v7 - tmp8 := checkDerefVar(var_glojure_DOT_core_reduce1) - tmp9 := checkDerefVar(var_glojure_DOT_core_bit_DASH_or) - tmp10 := checkDerefVar(var_glojure_DOT_core_bit_DASH_or) - tmp11 := lang.Apply(tmp10, []any{v5, v6}) - tmp12 := lang.Apply(tmp8, []any{tmp9, tmp11, v7}) - return tmp12 + checkArity(args, -1) + panic("unreachable") } }) - tmp4 = tmp4.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp3 := ns.InternWithValue(tmp0, tmp4, true) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_double_DASH_array = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_double_DASH_array.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // bit-set + // double? { - tmp0 := sym_bit_DASH_set.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_n)), kw_doc, "Set bit at index n", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(1342), kw_end_DASH_line, int(1342))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "SetBit") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("SetBit is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v3, v4}) - return tmp6 + tmp0 := sym_double_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a Double", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(1421), kw_end_DASH_line, int(1421))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := lang.Apply(tmp3, []any{lang.Builtins["float64"], v2}) + return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_double_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_double_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // bit-shift-left + // doubles { var tmp1 lang.FnFunc - { // function bit-shift-left__inliner + { // function doubles var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) + checkArity(args, 1) v3 := args[0] _ = v3 - v4 := args[1] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_seq) - tmp6 := checkDerefVar(var_glojure_DOT_core_concat) - tmp7 := checkDerefVar(var_glojure_DOT_core_list) - tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) - tmp9 := checkDerefVar(var_glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp11 := checkDerefVar(var_glojure_DOT_core_list) - tmp12 := checkDerefVar(var_glojure_DOT_core_seq) - tmp13 := checkDerefVar(var_glojure_DOT_core_concat) - tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_ShiftLeft}) - tmp16 := checkDerefVar(var_glojure_DOT_core_list) - tmp17 := lang.Apply(tmp16, []any{v3}) - tmp18 := checkDerefVar(var_glojure_DOT_core_list) - tmp19 := lang.Apply(tmp18, []any{v4}) - tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) - tmp21 := lang.Apply(tmp12, []any{tmp20}) - tmp22 := lang.Apply(tmp11, []any{tmp21}) - tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) - tmp24 := lang.Apply(tmp5, []any{tmp23}) - return tmp24 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Doubles}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 }) v2 = tmp1 _ = v2 } - tmp0 := sym_bit_DASH_shift_DASH_left.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_n)), kw_inline, tmp1, kw_doc, "Bitwise shift left", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(1361), kw_end_DASH_line, int(1361))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "ShiftLeft") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ShiftLeft is not a function"))) + tmp0 := sym_doubles.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xs)), kw_inline, tmp1, kw_doc, "Casts to double[]", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(12), kw_line, int(5402), kw_end_DASH_line, int(5402))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Doubles") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Doubles is not a function"))) } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_doubles = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_doubles.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // bit-shift-right - { - var tmp1 lang.FnFunc - { // function bit-shift-right__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_seq) - tmp6 := checkDerefVar(var_glojure_DOT_core_concat) - tmp7 := checkDerefVar(var_glojure_DOT_core_list) - tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) - tmp9 := checkDerefVar(var_glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp11 := checkDerefVar(var_glojure_DOT_core_list) - tmp12 := checkDerefVar(var_glojure_DOT_core_seq) - tmp13 := checkDerefVar(var_glojure_DOT_core_concat) - tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_ShiftRight}) - tmp16 := checkDerefVar(var_glojure_DOT_core_list) - tmp17 := lang.Apply(tmp16, []any{v3}) - tmp18 := checkDerefVar(var_glojure_DOT_core_list) - tmp19 := lang.Apply(tmp18, []any{v4}) - tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) - tmp21 := lang.Apply(tmp12, []any{tmp20}) - tmp22 := lang.Apply(tmp11, []any{tmp21}) - tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) - tmp24 := lang.Apply(tmp5, []any{tmp23}) - return tmp24 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := sym_bit_DASH_shift_DASH_right.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_n)), kw_inline, tmp1, kw_doc, "Bitwise shift right", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(1367), kw_end_DASH_line, int(1367))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "ShiftRight") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ShiftRight is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // bit-test - { - tmp0 := sym_bit_DASH_test.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_n)), kw_doc, "Test bit at index n", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(1354), kw_end_DASH_line, int(1354))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "TestBit") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("TestBit is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v3, v4}) - return tmp6 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // bit-xor + // drop-while { + tmp0 := sym_drop_DASH_while.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred), lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns a lazy sequence of the items in coll starting from the\n first item for which (pred item) returns logical false. Returns a\n stateful transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(2950), kw_end_DASH_line, int(2950))).(*lang.Symbol) var tmp1 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v2 := args[0] _ = v2 - var tmp3 any - { // let - // let binding "op" - var tmp4 any - tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) - if lang.IsTruthy(tmp5) { - tmp4 = closed32 - } else { - tmp4 = closed32 - } - var v6 any = tmp4 - _ = v6 - tmp7 := checkDerefVar(var_glojure_DOT_core_seq) - tmp8 := checkDerefVar(var_glojure_DOT_core_concat) - tmp9 := checkDerefVar(var_glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) - tmp11 := checkDerefVar(var_glojure_DOT_core_list) - tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := checkDerefVar(var_glojure_DOT_core_seq) - tmp15 := checkDerefVar(var_glojure_DOT_core_concat) - tmp16 := checkDerefVar(var_glojure_DOT_core_list) - tmp17 := lang.Apply(tmp16, []any{v6}) - tmp18 := checkDerefVar(var_glojure_DOT_core_list) - tmp19 := lang.Apply(tmp18, []any{v2}) - tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) - tmp21 := lang.Apply(tmp14, []any{tmp20}) - tmp22 := lang.Apply(tmp13, []any{tmp21}) - tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) - tmp24 := lang.Apply(tmp7, []any{tmp23}) - tmp3 = tmp24 - } // end let - return tmp3 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 any + { // let + // let binding "dv" + tmp6 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) + tmp7 := lang.Apply(tmp6, []any{true}) + var v8 any = tmp7 + _ = v8 + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp10 := lang.Apply(v4, nil) + return tmp10 + case 1: + v10 := args[0] + _ = v10 + tmp11 := lang.Apply(v4, []any{v10}) + return tmp11 + case 2: + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + var tmp12 any + { // let + // let binding "drop?" + tmp13 := checkDerefVar(var_glojure_DOT_core_deref) + tmp14 := lang.Apply(tmp13, []any{v8}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + var tmp17 any + { // let + // let binding "and__0__auto__" + var v18 any = v15 + _ = v18 + var tmp19 any + if lang.IsTruthy(v18) { + tmp20 := lang.Apply(v2, []any{v11}) + tmp19 = tmp20 + } else { + tmp19 = v18 + } + tmp17 = tmp19 + } // end let + if lang.IsTruthy(tmp17) { + tmp16 = v10 + } else { + tmp18 := checkDerefVar(var_glojure_DOT_core_vreset_BANG_) + tmp19 := lang.Apply(tmp18, []any{v8, nil}) + _ = tmp19 + tmp20 := lang.Apply(v4, []any{v10, v11}) + tmp16 = tmp20 + } + tmp12 = tmp16 + } // end let + return tmp12 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2959), kw_column, int(10), kw_end_DASH_line, int(2968), kw_end_DASH_column, int(42)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp5 = tmp11 + } // end let + return tmp5 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2957), kw_column, int(6), kw_end_DASH_line, int(2968), kw_end_DASH_column, int(44)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 case 2: v2 := args[0] _ = v2 @@ -11527,617 +9912,433 @@ func LoadNS() { _ = v3 var tmp4 any { // let - // let binding "op" - var tmp5 any - tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) - if lang.IsTruthy(tmp6) { - tmp5 = closed32 - } else { - tmp5 = closed32 - } - var v7 any = tmp5 - _ = v7 - tmp8 := checkDerefVar(var_glojure_DOT_core_seq) - tmp9 := checkDerefVar(var_glojure_DOT_core_concat) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) - tmp12 := checkDerefVar(var_glojure_DOT_core_list) - tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := checkDerefVar(var_glojure_DOT_core_seq) - tmp16 := checkDerefVar(var_glojure_DOT_core_concat) - tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{v7}) - tmp19 := checkDerefVar(var_glojure_DOT_core_list) - tmp20 := lang.Apply(tmp19, []any{v2}) - tmp21 := checkDerefVar(var_glojure_DOT_core_list) - tmp22 := lang.Apply(tmp21, []any{v3}) - tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) - tmp24 := lang.Apply(tmp15, []any{tmp23}) - tmp25 := lang.Apply(tmp14, []any{tmp24}) - tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) - tmp27 := lang.Apply(tmp8, []any{tmp26}) - tmp4 = tmp27 - } // end let - return tmp4 - default: - checkArity(args, 2) - v2 := args[0] - _ = v2 - v3 := args[1] - _ = v3 - var v4 any = lang.NewList(args[2:]...) - _ = v4 - var tmp5 any - { // let - // let binding "op" - var tmp6 any - tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) - if lang.IsTruthy(tmp7) { - tmp6 = closed32 - } else { - tmp6 = closed32 - } - var v8 any = tmp6 - _ = v8 - tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) - var tmp10 lang.FnFunc - tmp10 = lang.NewFnFunc(func(args ...any) any { + // let binding "step" + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 2) - v11 := args[0] - _ = v11 - v12 := args[1] - _ = v12 - tmp13 := checkDerefVar(var_glojure_DOT_core_seq) - tmp14 := checkDerefVar(var_glojure_DOT_core_concat) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) - tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp19 := checkDerefVar(var_glojure_DOT_core_list) - tmp20 := checkDerefVar(var_glojure_DOT_core_seq) - tmp21 := checkDerefVar(var_glojure_DOT_core_concat) - tmp22 := checkDerefVar(var_glojure_DOT_core_list) - tmp23 := lang.Apply(tmp22, []any{v8}) - tmp24 := checkDerefVar(var_glojure_DOT_core_list) - tmp25 := lang.Apply(tmp24, []any{v11}) - tmp26 := checkDerefVar(var_glojure_DOT_core_list) - tmp27 := lang.Apply(tmp26, []any{v12}) - tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) - tmp29 := lang.Apply(tmp20, []any{tmp28}) - tmp30 := lang.Apply(tmp19, []any{tmp29}) - tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) - tmp32 := lang.Apply(tmp13, []any{tmp31}) - return tmp32 + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + recur_loop_552: + var tmp8 any + { // let + // let binding "s" + tmp9 := checkDerefVar(var_glojure_DOT_core_seq) + tmp10 := lang.Apply(tmp9, []any{v7}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + var tmp13 any + { // let + // let binding "and__0__auto__" + var v14 any = v11 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + tmp16 := checkDerefVar(var_glojure_DOT_core_first) + tmp17 := lang.Apply(tmp16, []any{v11}) + tmp18 := lang.Apply(v6, []any{tmp17}) + tmp15 = tmp18 + } else { + tmp15 = v14 + } + tmp13 = tmp15 + } // end let + if lang.IsTruthy(tmp13) { + var tmp14 any = v6 + tmp16 := checkDerefVar(var_glojure_DOT_core_rest) + tmp17 := lang.Apply(tmp16, []any{v11}) + var tmp15 any = tmp17 + v6 = tmp14 + v7 = tmp15 + goto recur_loop_552 + } else { + tmp12 = v11 + } + tmp8 = tmp12 + } // end let + return tmp8 }) - tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2970), kw_column, int(17), kw_end_DASH_line, int(2974), kw_end_DASH_column, int(26)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp13 := checkDerefVar(var_glojure_DOT_core_seq) - tmp14 := checkDerefVar(var_glojure_DOT_core_concat) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) - tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp19 := checkDerefVar(var_glojure_DOT_core_list) - tmp20 := checkDerefVar(var_glojure_DOT_core_seq) - tmp21 := checkDerefVar(var_glojure_DOT_core_concat) - tmp22 := checkDerefVar(var_glojure_DOT_core_list) - tmp23 := lang.Apply(tmp22, []any{v8}) - tmp24 := checkDerefVar(var_glojure_DOT_core_list) - tmp25 := lang.Apply(tmp24, []any{v2}) - tmp26 := checkDerefVar(var_glojure_DOT_core_list) - tmp27 := lang.Apply(tmp26, []any{v3}) - tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) - tmp29 := lang.Apply(tmp20, []any{tmp28}) - tmp30 := lang.Apply(tmp19, []any{tmp29}) - tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) - tmp32 := lang.Apply(tmp13, []any{tmp31}) - tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) - tmp5 = tmp33 + var v8 any = tmp7 + _ = v8 + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp10 := lang.Apply(v8, []any{v2, v3}) + return tmp10 + }) + tmp10 := lang.Apply(lang.NewLazySeq, []any{tmp9}) + tmp4 = tmp10 } // end let - return tmp5 + return tmp4 + default: + checkArity(args, -1) + panic("unreachable") } }) - tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_drop_DASH_while = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_drop_DASH_while.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // empty + { + tmp0 := sym_empty.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns an empty collection of the same category as coll, or nil", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(5265), kw_end_DASH_line, int(5265))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := reflect.TypeOf((*lang.IPersistentCollection)(nil)).Elem() + tmp6 := lang.Apply(tmp4, []any{tmp5, v2}) + if lang.IsTruthy(tmp6) { + tmp7, ok := lang.FieldOrMethod(v2, "empty") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "empty"))) + } + var tmp8 any + switch reflect.TypeOf(tmp7).Kind() { + case reflect.Func: + tmp8 = lang.Apply(tmp7, nil) + default: + tmp8 = tmp7 + } + tmp3 = tmp8 + } else { + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_empty = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_empty.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // every? + { + tmp1 := reflect.TypeOf(false) + tmp0 := sym_every_QMARK_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns true if (pred x) is logical true for every x in coll, else\n false.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(2664), kw_end_DASH_line, int(2664))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) + checkArity(args, 2) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + v4 := args[1] + _ = v4 + recur_loop_480: + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := lang.Apply(tmp7, []any{v4}) + tmp9 := lang.Apply(tmp6, []any{tmp8}) + if lang.IsTruthy(tmp9) { + tmp5 = true + } else { + var tmp10 any + tmp11 := checkDerefVar(var_glojure_DOT_core_first) + tmp12 := lang.Apply(tmp11, []any{v4}) + tmp13 := lang.Apply(v3, []any{tmp12}) + if lang.IsTruthy(tmp13) { + var tmp14 any = v3 + tmp16 := checkDerefVar(var_glojure_DOT_core_next) + tmp17 := lang.Apply(tmp16, []any{v4}) + var tmp15 any = tmp17 + v3 = tmp14 + v4 = tmp15 + goto recur_loop_480 + } else { + var tmp18 any + if lang.IsTruthy(kw_else) { + tmp18 = false + } else { + } + tmp10 = tmp18 + } + tmp5 = tmp10 } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp0 := sym_bit_DASH_xor.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Bitwise exclusive or", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(1316), kw_end_DASH_line, int(1316))).(*lang.Symbol) - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - tmp7, _ := lang.FieldOrMethod(lang.Numbers, "Xor") - if reflect.TypeOf(tmp7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Xor is not a function"))) + tmp3 := reflect.TypeOf(false) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_every_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_every_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ex-cause + { + tmp0 := sym_ex_DASH_cause.WithMeta(lang.NewMap(kw_tag, nil, kw_arglists, lang.NewList(lang.NewVector(sym_ex)), kw_doc, "Returns the cause of ex if ex is a Throwable.\n Otherwise returns nil.", kw_file, "glojure/core.glj", kw_added, "1.10", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(4828), kw_end_DASH_line, int(4828))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := lang.Apply(tmp4, []any{lang.Throwable, v2}) + if lang.IsTruthy(tmp5) { + tmp6, ok := lang.FieldOrMethod(v2, "getCause") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getCause"))) } - tmp8 := lang.Apply(tmp7, []any{v5, v6}) - return tmp8 - default: - checkArity(args, 2) - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - var v7 any = lang.NewList(args[2:]...) - _ = v7 - tmp8 := checkDerefVar(var_glojure_DOT_core_reduce1) - tmp9 := checkDerefVar(var_glojure_DOT_core_bit_DASH_xor) - tmp10 := checkDerefVar(var_glojure_DOT_core_bit_DASH_xor) - tmp11 := lang.Apply(tmp10, []any{v5, v6}) - tmp12 := lang.Apply(tmp8, []any{tmp9, tmp11, v7}) - return tmp12 + var tmp7 any + switch reflect.TypeOf(tmp6).Kind() { + case reflect.Func: + tmp7 = lang.Apply(tmp6, nil) + default: + tmp7 = tmp6 + } + tmp3 = tmp7 + } else { } + return tmp3 }) - tmp4 = tmp4.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp3 := ns.InternWithValue(tmp0, tmp4, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ex_DASH_cause = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_ex_DASH_cause.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // boolean + // ex-data { + tmp0 := sym_ex_DASH_data.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ex)), kw_doc, "Returns exception data (a map) if ex is an IExceptionInfo.\n Otherwise returns nil.", kw_file, "glojure/core.glj", kw_added, "1.4", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4812), kw_end_DASH_line, int(4812))).(*lang.Symbol) var tmp1 lang.FnFunc - { // function boolean__inliner + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := lang.Apply(tmp4, []any{nil, v2}) + if lang.IsTruthy(tmp5) { + tmp6, ok := lang.FieldOrMethod(v2, "getData") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getData"))) + } + var tmp7 any + switch reflect.TypeOf(tmp6).Kind() { + case reflect.Func: + tmp7 = lang.Apply(tmp6, nil) + default: + tmp7 = tmp6 + } + tmp3 = tmp7 + } else { + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ex_DASH_data = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ex_DASH_data.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ex-message + { + tmp0 := sym_ex_DASH_message.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ex)), kw_doc, "Returns the message attached to ex if ex is a Throwable.\n Otherwise returns nil.", kw_file, "glojure/core.glj", kw_added, "1.10", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4820), kw_end_DASH_line, int(4820))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := lang.Apply(tmp4, []any{lang.Throwable, v2}) + if lang.IsTruthy(tmp5) { + tmp6, ok := lang.FieldOrMethod(v2, "getMessage") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getMessage"))) + } + var tmp7 any + switch reflect.TypeOf(tmp6).Kind() { + case reflect.Func: + tmp7 = lang.Apply(tmp6, nil) + default: + tmp7 = tmp6 + } + tmp3 = tmp7 + } else { + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ex_DASH_message = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ex_DASH_message.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ffirst + { + tmp0 := sym_ffirst.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Same as (first (first x))", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(2), kw_line, int(98), kw_end_DASH_line, int(102))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function ffirst var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_seq) - tmp5 := checkDerefVar(var_glojure_DOT_core_concat) - tmp6 := checkDerefVar(var_glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) - tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := checkDerefVar(var_glojure_DOT_core_seq) - tmp12 := checkDerefVar(var_glojure_DOT_core_concat) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_BooleanCast}) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{v3}) - tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) - tmp18 := lang.Apply(tmp11, []any{tmp17}) - tmp19 := lang.Apply(tmp10, []any{tmp18}) - tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) - tmp21 := lang.Apply(tmp4, []any{tmp20}) - return tmp21 + tmp4 := checkDerefVar(var_glojure_DOT_core_first) + tmp5 := checkDerefVar(var_glojure_DOT_core_first) + tmp6 := lang.Apply(tmp5, []any{v3}) + tmp7 := lang.Apply(tmp4, []any{tmp6}) + return tmp7 }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(102), kw_column, int(9), kw_end_DASH_line, int(102), kw_end_DASH_column, int(50))).(lang.FnFunc) v2 = tmp1 _ = v2 } - tmp0 := sym_boolean.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to boolean", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(1601), kw_end_DASH_line, int(1601))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(runtime.RT, "BooleanCast") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("BooleanCast is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + var_glojure_DOT_core_ffirst = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_ffirst.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // boolean-array + // filter-key { + tmp0 := sym_filter_DASH_key.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_keyfn, sym_pred, sym_amap)), kw_static, true, kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(4115), kw_end_DASH_line, int(4117), kw_private, true)).(*lang.Symbol) var tmp1 lang.FnFunc - { // function boolean-array__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 0) - var v3 any = lang.NewList(args[0:]...) - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_seq) - tmp5 := checkDerefVar(var_glojure_DOT_core_concat) - tmp6 := checkDerefVar(var_glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) - tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_BooleanArray}) - tmp12 := checkDerefVar(var_glojure_DOT_core_list) - tmp13 := checkDerefVar(var_glojure_DOT_core_seq) - tmp14 := checkDerefVar(var_glojure_DOT_core_concat) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_unquote_DASH_splicing}) - tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{sym_glojure_DOT_core_SLASH_args}) - tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) - tmp20 := lang.Apply(tmp13, []any{tmp19}) - tmp21 := lang.Apply(tmp12, []any{tmp20}) - tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp21}) - tmp23 := lang.Apply(tmp4, []any{tmp22}) - return tmp23 - } - }) - v2 = tmp1 + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] _ = v2 - } - tmp0 := sym_boolean_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_size_DASH_or_DASH_seq), lang.NewVector(sym_size, sym_init_DASH_val_DASH_or_DASH_seq)), kw_inline, tmp1, kw_doc, "Creates an array of booleans", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(5309), kw_end_DASH_line, int(5309))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "BooleanArray") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("BooleanArray is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - case 2: - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "BooleanArrayInit") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("BooleanArrayInit is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 - default: - checkArity(args, -1) - panic("unreachable") - } - }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // boolean? - { - tmp0 := sym_boolean_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a Boolean", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(518), kw_end_DASH_line, int(518))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] + v3 := args[1] _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp5 := lang.Apply(tmp4, []any{lang.Builtins["bool"], v3}) - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // booleans - { - var tmp1 lang.FnFunc - { // function booleans - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_seq) - tmp5 := checkDerefVar(var_glojure_DOT_core_concat) - tmp6 := checkDerefVar(var_glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) - tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Booleans}) - tmp12 := checkDerefVar(var_glojure_DOT_core_list) - tmp13 := lang.Apply(tmp12, []any{v3}) - tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) - tmp15 := lang.Apply(tmp4, []any{tmp14}) - return tmp15 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := sym_booleans.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xs)), kw_inline, tmp1, kw_doc, "Casts to boolean[]", kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(12), kw_line, int(5372), kw_end_DASH_line, int(5372))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] + v4 := args[2] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Booleans") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Booleans is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // bound-fn - { - tmp0 := sym_bound_DASH_fn.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_fntail)), kw_doc, "Returns a function defined by the given fntail, which will install the\n same bindings in effect as in the thread at the time bound-fn was called.\n This may be used to define a helper function which runs on a different\n thread, but needs the same bindings in place.", kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(11), kw_line, int(2004), kw_end_DASH_line, int(2004))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - tmp6 := checkDerefVar(var_glojure_DOT_core_seq) - tmp7 := checkDerefVar(var_glojure_DOT_core_concat) - tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_bound_DASH_fn_STAR_}) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := checkDerefVar(var_glojure_DOT_core_seq) - tmp12 := checkDerefVar(var_glojure_DOT_core_concat) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_fn}) - tmp15 := lang.Apply(tmp12, []any{tmp14, v5}) - tmp16 := lang.Apply(tmp11, []any{tmp15}) - tmp17 := lang.Apply(tmp10, []any{tmp16}) - tmp18 := lang.Apply(tmp7, []any{tmp9, tmp17}) - tmp19 := lang.Apply(tmp6, []any{tmp18}) - return tmp19 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // bound-fn* - { - tmp0 := sym_bound_DASH_fn_STAR_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f)), kw_doc, "Returns a function, which will install the same bindings in effect as in\n the thread at the time bound-fn* was called and then call f with any given\n arguments. This may be used to define a helper function which runs on a\n different thread, but needs the same bindings in place.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(1992), kw_end_DASH_line, int(1992))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 any + var tmp5 any { // let - // let binding "bindings" - tmp5 := checkDerefVar(var_glojure_DOT_core_get_DASH_thread_DASH_bindings) - tmp6 := lang.Apply(tmp5, nil) - var v7 any = tmp6 - _ = v7 - var tmp8 lang.FnFunc - tmp8 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 0) - var v9 any = lang.NewList(args[0:]...) - _ = v9 - tmp10 := checkDerefVar(var_glojure_DOT_core_apply) - tmp11 := checkDerefVar(var_glojure_DOT_core_with_DASH_bindings_STAR_) - tmp12 := lang.Apply(tmp10, []any{tmp11, v7, v3, v9}) - return tmp12 - } - }) - tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2001), kw_column, int(5), kw_end_DASH_line, int(2002), kw_end_DASH_column, int(45)) - tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp4 = tmp10 - } // end let - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // bound? - { - tmp0 := sym_bound_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_vars)), kw_doc, "Returns true if all of the vars provided as arguments have any bound value, root or thread-local.\n Implies that deref'ing the provided vars will succeed. Returns true if no vars are provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(5491), kw_end_DASH_line, int(5491))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 0) - var v3 any = lang.NewList(args[0:]...) - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) - var tmp5 lang.FnFunc - tmp5 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v6 := args[0] - _ = v6 - tmp7, ok := lang.FieldOrMethod(v6, "isBound") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "isBound"))) - } - var tmp8 any - switch reflect.TypeOf(tmp7).Kind() { - case reflect.Func: - tmp8 = lang.Apply(tmp7, nil) - default: - tmp8 = tmp7 - } - return tmp8 - }) - tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5497), kw_column, int(11), kw_end_DASH_line, int(5497), kw_end_DASH_column, int(69)) - tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + // let binding "ret" + tmp6 := lang.NewMap() + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4118), kw_column, int(16), kw_end_DASH_line, int(4118), kw_end_DASH_column, int(17)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp8 := lang.Apply(tmp4, []any{tmp7, v3}) - return tmp8 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // bounded-count - { - tmp0 := sym_bounded_DASH_count.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n, sym_coll)), kw_doc, "If coll is counted? returns its count, else will count at most the first n\n elements of coll using its seq", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(7410), kw_end_DASH_line, int(7410))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - tmp6 := checkDerefVar(var_glojure_DOT_core_counted_QMARK_) - tmp7 := lang.Apply(tmp6, []any{v4}) - if lang.IsTruthy(tmp7) { - tmp8 := checkDerefVar(var_glojure_DOT_core_count) - tmp9 := lang.Apply(tmp8, []any{v4}) - tmp5 = tmp9 - } else { - var tmp10 any - { // let - // let binding "i" - var v11 any = int64(0) - _ = v11 - // let binding "s" - tmp12 := checkDerefVar(var_glojure_DOT_core_seq) - tmp13 := lang.Apply(tmp12, []any{v4}) - var v14 any = tmp13 - _ = v14 - for { - var tmp15 any - var tmp16 any - { // let - // let binding "and__0__auto__" - var v17 any = v14 - _ = v17 - var tmp18 any - if lang.IsTruthy(v17) { - tmp19 := checkDerefVar(var_glojure_DOT_core__LT_) - tmp20 := lang.Apply(tmp19, []any{v11, v3}) - tmp18 = tmp20 - } else { - tmp18 = v17 - } - tmp16 = tmp18 - } // end let - if lang.IsTruthy(tmp16) { - tmp18 := checkDerefVar(var_glojure_DOT_core_inc) - tmp19 := lang.Apply(tmp18, []any{v11}) - var tmp17 any = tmp19 - tmp21 := checkDerefVar(var_glojure_DOT_core_next) - tmp22 := lang.Apply(tmp21, []any{v14}) - var tmp20 any = tmp22 - v11 = tmp17 - v14 = tmp20 + var v9 any = tmp8 + _ = v9 + // let binding "es" + tmp10 := checkDerefVar(var_glojure_DOT_core_seq) + tmp11 := lang.Apply(tmp10, []any{v4}) + var v12 any = tmp11 + _ = v12 + for { + var tmp13 any + if lang.IsTruthy(v12) { + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core_first) + tmp16 := lang.Apply(tmp15, []any{v12}) + tmp17 := lang.Apply(v2, []any{tmp16}) + tmp18 := lang.Apply(v3, []any{tmp17}) + if lang.IsTruthy(tmp18) { + tmp20 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp21 := checkDerefVar(var_glojure_DOT_core_key) + tmp22 := checkDerefVar(var_glojure_DOT_core_first) + tmp23 := lang.Apply(tmp22, []any{v12}) + tmp24 := lang.Apply(tmp21, []any{tmp23}) + tmp25 := checkDerefVar(var_glojure_DOT_core_val) + tmp26 := checkDerefVar(var_glojure_DOT_core_first) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp25, []any{tmp27}) + tmp29 := lang.Apply(tmp20, []any{v9, tmp24, tmp28}) + var tmp19 any = tmp29 + tmp31 := checkDerefVar(var_glojure_DOT_core_next) + tmp32 := lang.Apply(tmp31, []any{v12}) + var tmp30 any = tmp32 + v9 = tmp19 + v12 = tmp30 continue } else { - tmp15 = v11 + var tmp33 any = v9 + tmp35 := checkDerefVar(var_glojure_DOT_core_next) + tmp36 := lang.Apply(tmp35, []any{v12}) + var tmp34 any = tmp36 + v9 = tmp33 + v12 = tmp34 + continue } - tmp10 = tmp15 - break + tmp13 = tmp14 + } else { + tmp13 = v9 } - } // end let - tmp5 = tmp10 - } + tmp5 = tmp13 + break + } + } // end let return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_filter_DASH_key = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_filter_DASH_key.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // butlast + // find-keyword { - tmp0 := sym_butlast.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Return a seq of all but the last item in coll, in linear time", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(2), kw_line, int(272), kw_end_DASH_line, int(276))).(*lang.Symbol) + tmp1 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() + tmp0 := sym_find_DASH_keyword.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_name), lang.NewVector(sym_ns, sym_name)), kw_doc, "Returns a Keyword with the given namespace and name if one already\n exists. This function will not intern a new keyword. If the keyword\n has not already been interned, it will return nil. Do not use :\n in the keyword strings, it will be added automatically.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(618), kw_end_DASH_line, int(618))).(*lang.Symbol) var tmp2 lang.FnFunc - { // function butlast - var v3 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - var tmp5 any - { // let - // let binding "ret" - tmp6 := lang.NewVector() - tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(277), kw_column, int(23), kw_end_DASH_line, int(277), kw_end_DASH_column, int(24)) - tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v9 any = tmp8 - _ = v9 - // let binding "s" - var v10 any = v4 - _ = v10 - for { + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + tmp4 = v3 + } else { + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp9 := lang.Apply(tmp8, []any{v3}) + if lang.IsTruthy(tmp9) { + tmp10 := lang.Apply(nil, []any{v3}) + tmp7 = tmp10 + } else { var tmp11 any - tmp12 := checkDerefVar(var_glojure_DOT_core_next) - tmp13 := lang.Apply(tmp12, []any{v10}) + tmp12 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp13 := lang.Apply(tmp12, []any{v3}) if lang.IsTruthy(tmp13) { - tmp15 := checkDerefVar(var_glojure_DOT_core_conj) - tmp16 := checkDerefVar(var_glojure_DOT_core_first) - tmp17 := lang.Apply(tmp16, []any{v10}) - tmp18 := lang.Apply(tmp15, []any{v9, tmp17}) - var tmp14 any = tmp18 - tmp20 := checkDerefVar(var_glojure_DOT_core_next) - tmp21 := lang.Apply(tmp20, []any{v10}) - var tmp19 any = tmp21 - v9 = tmp14 - v10 = tmp19 - continue + tmp14 := lang.Apply(nil, []any{v3}) + tmp11 = tmp14 } else { - tmp22 := checkDerefVar(var_glojure_DOT_core_seq) - tmp23 := lang.Apply(tmp22, []any{v9}) - tmp11 = tmp23 } - tmp5 = tmp11 - break + tmp7 = tmp11 } - } // end let + tmp4 = tmp7 + } + return tmp4 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(nil, []any{v3, v4}) return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(276), kw_column, int(10), kw_end_DASH_line, int(280), kw_end_DASH_column, int(27))).(lang.FnFunc) - v3 = tmp2 - _ = v3 - } - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp3 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_find_DASH_keyword = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_find_DASH_keyword.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // byte + // float { var tmp1 lang.FnFunc - { // function byte__inliner + { // function float__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) @@ -12156,9 +10357,9 @@ func LoadNS() { var tmp14 any tmp15 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp15) { - tmp14 = sym_uncheckedByteCast + tmp14 = sym_uncheckedFloatCast } else { - tmp14 = sym_byteCast + tmp14 = sym_floatCast } tmp16 := lang.Apply(tmp13, []any{tmp14}) tmp17 := checkDerefVar(var_glojure_DOT_core_list) @@ -12173,25 +10374,25 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := sym_byte.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to byte", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3505), kw_end_DASH_line, int(3505))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_float.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to float", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3487), kw_end_DASH_line, int(3487))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5 := lang.Apply(lang.ByteCast, []any{v4}) - return tmp5 + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.FloatCast, []any{v3}) + return tmp4 }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_float = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_float.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // byte-array + // float-array { var tmp1 lang.FnFunc - { // function byte-array__inliner + { // function float-array__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -12206,7 +10407,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_ByteArray}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_FloatArray}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := checkDerefVar(var_glojure_DOT_core_seq) tmp14 := checkDerefVar(var_glojure_DOT_core_concat) @@ -12225,45 +10426,78 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := sym_byte_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_size_DASH_or_DASH_seq), lang.NewVector(sym_size, sym_init_DASH_val_DASH_or_DASH_seq)), kw_inline, tmp1, kw_doc, "Creates an array of bytes", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(5317), kw_end_DASH_line, int(5317))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_float_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_size_DASH_or_DASH_seq), lang.NewVector(sym_size, sym_init_DASH_val_DASH_or_DASH_seq)), kw_inline, tmp1, kw_doc, "Creates an array of floats", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(5301), kw_end_DASH_line, int(5301))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "ByteArray") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ByteArray is not a function"))) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "FloatArray") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("FloatArray is not a function"))) } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 case 2: - v4 := args[0] + v3 := args[0] + _ = v3 + v4 := args[1] _ = v4 - v5 := args[1] - _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "ByteArrayInit") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ByteArrayInit is not a function"))) + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "FloatArrayInit") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("FloatArrayInit is not a function"))) } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 default: checkArity(args, -1) panic("unreachable") } }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_float_DASH_array = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_float_DASH_array.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // bytes + // float? { + tmp0 := sym_float_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_doc, "Returns true if n is a floating point number", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(3605), kw_end_DASH_line, int(3605))).(*lang.Symbol) var tmp1 lang.FnFunc - { // function bytes + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "or__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := lang.Apply(tmp4, []any{lang.Builtins["float64"], v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + tmp7 = v6 + } else { + tmp8 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp9 := lang.Apply(tmp8, []any{lang.Builtins["float32"], v2}) + tmp7 = tmp9 + } + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_float_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_float_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // floats + { + var tmp1 lang.FnFunc + { // function floats var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) @@ -12276,7 +10510,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Bytes}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Floats}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := lang.Apply(tmp12, []any{v3}) tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) @@ -12286,2722 +10520,1865 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := sym_bytes.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xs)), kw_inline, tmp1, kw_doc, "Casts to bytes[]", kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(12), kw_line, int(5377), kw_end_DASH_line, int(5377))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_floats.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xs)), kw_inline, tmp1, kw_doc, "Casts to float[]", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(12), kw_line, int(5392), kw_end_DASH_line, int(5392))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Bytes") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Bytes is not a function"))) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Floats") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Floats is not a function"))) } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_floats = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_floats.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // bytes? + // fn? { - tmp0 := sym_bytes_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a byte array", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(5412), kw_end_DASH_line, int(5412))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_fn_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x implements Fn, i.e. is an object created via fn.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(6216), kw_end_DASH_line, int(6216))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) - tmp6 := lang.Apply(tmp5, []any{v3}) - if lang.IsTruthy(tmp6) { - tmp4 = false - } else { - tmp7 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp8 := checkDerefVar(var_glojure_DOT_core_class) - tmp9 := lang.Apply(tmp8, []any{v3}) - tmp10, ok := lang.FieldOrMethod(tmp9, "getComponentType") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp9, "getComponentType"))) - } - var tmp11 any - switch reflect.TypeOf(tmp10).Kind() { - case reflect.Func: - tmp11 = lang.Apply(tmp10, nil) - default: - tmp11 = tmp10 - } - tmp12 := lang.Apply(tmp7, []any{tmp11, nil}) - tmp4 = tmp12 - } - return tmp4 + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*runtime.Fn)(nil)) + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_fn_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_fn_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // case + // fnext { - tmp0 := sym_case.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_e, sym__AMP_, sym_clauses)), kw_doc, "Takes an expression, and a set of clauses.\n\n Each clause can take the form of either:\n\n test-constant result-expr\n\n (test-constant1 ... test-constantN) result-expr\n\n The test-constants are not evaluated. They must be compile-time\n literals, and need not be quoted. If the expression is equal to a\n test-constant, the corresponding result-expr is returned. A single\n default expression can follow the clauses, and its value will be\n returned if no clause matches. If no default expression is provided\n and no clause matches, an IllegalArgumentException is thrown.\n\n Unlike cond and condp, case does a constant-time dispatch, the\n clauses are not considered sequentially. All manner of constant\n expressions are acceptable in case, including numbers, strings,\n symbols, keywords, and (Clojure) composites thereof. Note that since\n lists are used to group multiple constants that map to the same\n expression, a vector can be used to match a list if needed. The\n test-constants need not be all of the same type.", kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(11), kw_line, int(6712), kw_end_DASH_line, int(6712))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 3) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any - { // let - // let binding "ge" - tmp8 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) - tmp9 := checkDerefVar(var_glojure_DOT_core_gensym) - tmp10 := lang.Apply(tmp9, nil) - tmp11 := reflect.TypeOf((*lang.Object)(nil)).Elem() - tmp12 := lang.NewMap(kw_tag, tmp11) - tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6738), kw_column, int(32), kw_end_DASH_line, int(6738), kw_end_DASH_column, int(84)) - tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp15 := lang.Apply(tmp8, []any{tmp10, tmp14}) - var v16 any = tmp15 - _ = v16 - // let binding "default" - var tmp17 any - tmp18 := checkDerefVar(var_glojure_DOT_core_odd_QMARK_) - tmp19 := checkDerefVar(var_glojure_DOT_core_count) - tmp20 := lang.Apply(tmp19, []any{v6}) - tmp21 := lang.Apply(tmp18, []any{tmp20}) - if lang.IsTruthy(tmp21) { - tmp22 := checkDerefVar(var_glojure_DOT_core_last) - tmp23 := lang.Apply(tmp22, []any{v6}) - tmp17 = tmp23 - } else { - tmp24 := checkDerefVar(var_glojure_DOT_core_seq) - tmp25 := checkDerefVar(var_glojure_DOT_core_concat) - tmp26 := checkDerefVar(var_glojure_DOT_core_list) - tmp27 := lang.Apply(tmp26, []any{sym_throw}) - tmp28 := checkDerefVar(var_glojure_DOT_core_list) - tmp29 := checkDerefVar(var_glojure_DOT_core_seq) - tmp30 := checkDerefVar(var_glojure_DOT_core_concat) - tmp31 := checkDerefVar(var_glojure_DOT_core_list) - tmp32 := lang.Apply(tmp31, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_NewIllegalArgumentError}) - tmp33 := checkDerefVar(var_glojure_DOT_core_list) - tmp34 := checkDerefVar(var_glojure_DOT_core_seq) - tmp35 := checkDerefVar(var_glojure_DOT_core_concat) - tmp36 := checkDerefVar(var_glojure_DOT_core_list) - tmp37 := lang.Apply(tmp36, []any{sym_glojure_DOT_core_SLASH_str}) - tmp38 := checkDerefVar(var_glojure_DOT_core_list) - tmp39 := lang.Apply(tmp38, []any{"No matching clause: "}) - tmp40 := checkDerefVar(var_glojure_DOT_core_list) - tmp41 := lang.Apply(tmp40, []any{v16}) - tmp42 := lang.Apply(tmp35, []any{tmp37, tmp39, tmp41}) - tmp43 := lang.Apply(tmp34, []any{tmp42}) - tmp44 := lang.Apply(tmp33, []any{tmp43}) - tmp45 := lang.Apply(tmp30, []any{tmp32, tmp44}) - tmp46 := lang.Apply(tmp29, []any{tmp45}) - tmp47 := lang.Apply(tmp28, []any{tmp46}) - tmp48 := lang.Apply(tmp25, []any{tmp27, tmp47}) - tmp49 := lang.Apply(tmp24, []any{tmp48}) - tmp17 = tmp49 - } - var v50 any = tmp17 - _ = v50 - var tmp51 any - tmp52 := checkDerefVar(var_glojure_DOT_core__GT_) - tmp53 := checkDerefVar(var_glojure_DOT_core_count) - tmp54 := lang.Apply(tmp53, []any{v6}) - tmp55 := lang.Apply(tmp52, []any{int64(2), tmp54}) - if lang.IsTruthy(tmp55) { - tmp56 := checkDerefVar(var_glojure_DOT_core_seq) - tmp57 := checkDerefVar(var_glojure_DOT_core_concat) - tmp58 := checkDerefVar(var_glojure_DOT_core_list) - tmp59 := lang.Apply(tmp58, []any{sym_glojure_DOT_core_SLASH_let}) - tmp60 := checkDerefVar(var_glojure_DOT_core_list) - tmp61 := checkDerefVar(var_glojure_DOT_core_apply) - tmp62 := checkDerefVar(var_glojure_DOT_core_vector) - tmp63 := checkDerefVar(var_glojure_DOT_core_seq) - tmp64 := checkDerefVar(var_glojure_DOT_core_concat) - tmp65 := checkDerefVar(var_glojure_DOT_core_list) - tmp66 := lang.Apply(tmp65, []any{v16}) - tmp67 := checkDerefVar(var_glojure_DOT_core_list) - tmp68 := lang.Apply(tmp67, []any{v5}) - tmp69 := lang.Apply(tmp64, []any{tmp66, tmp68}) - tmp70 := lang.Apply(tmp63, []any{tmp69}) - tmp71 := lang.Apply(tmp61, []any{tmp62, tmp70}) - tmp72 := lang.Apply(tmp60, []any{tmp71}) - tmp73 := checkDerefVar(var_glojure_DOT_core_list) - tmp74 := lang.Apply(tmp73, []any{v50}) - tmp75 := lang.Apply(tmp57, []any{tmp59, tmp72, tmp74}) - tmp76 := lang.Apply(tmp56, []any{tmp75}) - tmp51 = tmp76 - } else { - var tmp77 any - { // let - // let binding "pairs" - tmp78 := checkDerefVar(var_glojure_DOT_core_partition) - tmp79 := lang.Apply(tmp78, []any{int64(2), v6}) - var v80 any = tmp79 - _ = v80 - // let binding "assoc-test" - var tmp81 lang.FnFunc - { // function assoc-test - var v82 lang.FnFunc - tmp81 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 3) - v83 := args[0] - _ = v83 - v84 := args[1] - _ = v84 - v85 := args[2] - _ = v85 - var tmp86 any - tmp87 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) - tmp88 := lang.Apply(tmp87, []any{v83, v84}) - if lang.IsTruthy(tmp88) { - tmp89 := checkDerefVar(var_glojure_DOT_core_str) - tmp90 := lang.Apply(tmp89, []any{"Duplicate case test constant: ", v84}) - tmp91 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp90}) - panic(tmp91) - } else { - tmp92 := checkDerefVar(var_glojure_DOT_core_assoc) - tmp93 := lang.Apply(tmp92, []any{v83, v84, v85}) - tmp86 = tmp93 - } - return tmp86 - }) - v82 = tmp81 - _ = v82 - } - tmp82 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6745), kw_column, int(24), kw_end_DASH_line, int(6748), kw_end_DASH_column, int(48)) - tmp83, err := lang.WithMeta(tmp81, tmp82.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v84 any = tmp83 - _ = v84 - // let binding "pairs" - tmp85 := checkDerefVar(var_glojure_DOT_core_reduce1) - var tmp86 lang.FnFunc - tmp86 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v87 := args[0] - _ = v87 - v88 := args[1] - _ = v88 - var tmp89 any - { // let - // let binding "vec__177" - var v90 any = v88 - _ = v90 - // let binding "test" - tmp91 := checkDerefVar(var_glojure_DOT_core_nth) - tmp92 := lang.Apply(tmp91, []any{v90, int64(0), nil}) - var v93 any = tmp92 - _ = v93 - // let binding "expr" - tmp94 := checkDerefVar(var_glojure_DOT_core_nth) - tmp95 := lang.Apply(tmp94, []any{v90, int64(1), nil}) - var v96 any = tmp95 - _ = v96 - var tmp97 any - tmp98 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) - tmp99 := lang.Apply(tmp98, []any{v93}) - if lang.IsTruthy(tmp99) { - tmp100 := checkDerefVar(var_glojure_DOT_core_reduce1) - var tmp101 lang.FnFunc - tmp101 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v102 := args[0] - _ = v102 - v103 := args[1] - _ = v103 - tmp104 := lang.Apply(v84, []any{v102, v103, v96}) - return tmp104 - }) - tmp102 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6752), kw_column, int(37), kw_end_DASH_line, int(6752), kw_end_DASH_column, int(60)) - tmp103, err := lang.WithMeta(tmp101, tmp102.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp104 := lang.Apply(tmp100, []any{tmp103, v87, v93}) - tmp97 = tmp104 - } else { - tmp105 := lang.Apply(v84, []any{v87, v93, v96}) - tmp97 = tmp105 - } - tmp89 = tmp97 - } // end let - return tmp89 - }) - tmp87 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6750), kw_column, int(24), kw_end_DASH_line, int(6753), kw_end_DASH_column, int(53)) - tmp88, err := lang.WithMeta(tmp86, tmp87.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp89 := lang.NewMap() - tmp90 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6754), kw_column, int(24), kw_end_DASH_line, int(6754), kw_end_DASH_column, int(25)) - tmp91, err := lang.WithMeta(tmp89, tmp90.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp92 := lang.Apply(tmp85, []any{tmp88, tmp91, v80}) - var v93 any = tmp92 - _ = v93 - // let binding "tests" - tmp94 := checkDerefVar(var_glojure_DOT_core_keys) - tmp95 := lang.Apply(tmp94, []any{v93}) - var v96 any = tmp95 - _ = v96 - // let binding "thens" - tmp97 := checkDerefVar(var_glojure_DOT_core_vals) - tmp98 := lang.Apply(tmp97, []any{v93}) - var v99 any = tmp98 - _ = v99 - // let binding "mode" - var tmp100 any - tmp101 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) - var tmp102 lang.FnFunc - tmp102 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v103 := args[0] - _ = v103 - var tmp104 any - { // let - // let binding "and__0__auto__" - tmp105 := checkDerefVar(var_glojure_DOT_core_integer_QMARK_) - tmp106 := lang.Apply(tmp105, []any{v103}) - var v107 any = tmp106 - _ = v107 - var tmp108 any - if lang.IsTruthy(v107) { - tmp109 := checkDerefVar(var_glojure_DOT_core__LT__EQ_) - tmp110 := lang.Apply(tmp109, []any{math7.MinInt, v103, math7.MaxInt}) - tmp108 = tmp110 - } else { - tmp108 = v107 - } - tmp104 = tmp108 - } // end let - return tmp104 - }) - tmp103 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6758), kw_column, int(28), kw_end_DASH_line, int(6758), kw_end_DASH_column, int(77)) - tmp104, err := lang.WithMeta(tmp102, tmp103.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp105 := lang.Apply(tmp101, []any{tmp104, v96}) - if lang.IsTruthy(tmp105) { - tmp100 = kw_ints - } else { - var tmp106 any - tmp107 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) - tmp108 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) - tmp109 := lang.Apply(tmp107, []any{tmp108, v96}) - if lang.IsTruthy(tmp109) { - tmp106 = kw_identity - } else { - var tmp110 any - if lang.IsTruthy(kw_else) { - tmp110 = kw_hashes - } else { - } - tmp106 = tmp110 - } - tmp100 = tmp106 - } - var v111 any = tmp100 - _ = v111 - var tmp112 any - { // let - // let binding "pred__180" - tmp113 := checkDerefVar(var_glojure_DOT_core__EQ_) - var v114 any = tmp113 - _ = v114 - // let binding "expr__181" - var v115 any = v111 - _ = v115 - var tmp116 any - tmp117 := lang.Apply(v114, []any{kw_ints, v115}) - if lang.IsTruthy(tmp117) { - var tmp118 any - { // let - // let binding "vec__182" - tmp119 := checkDerefVar(var_glojure_DOT_core_prep_DASH_ints) - tmp120 := lang.Apply(tmp119, []any{v96, v99}) - var v121 any = tmp120 - _ = v121 - // let binding "shift" - tmp122 := checkDerefVar(var_glojure_DOT_core_nth) - tmp123 := lang.Apply(tmp122, []any{v121, int64(0), nil}) - var v124 any = tmp123 - _ = v124 - // let binding "mask" - tmp125 := checkDerefVar(var_glojure_DOT_core_nth) - tmp126 := lang.Apply(tmp125, []any{v121, int64(1), nil}) - var v127 any = tmp126 - _ = v127 - // let binding "imap" - tmp128 := checkDerefVar(var_glojure_DOT_core_nth) - tmp129 := lang.Apply(tmp128, []any{v121, int64(2), nil}) - var v130 any = tmp129 - _ = v130 - // let binding "switch-type" - tmp131 := checkDerefVar(var_glojure_DOT_core_nth) - tmp132 := lang.Apply(tmp131, []any{v121, int64(3), nil}) - var v133 any = tmp132 - _ = v133 - tmp134 := checkDerefVar(var_glojure_DOT_core_seq) - tmp135 := checkDerefVar(var_glojure_DOT_core_concat) - tmp136 := checkDerefVar(var_glojure_DOT_core_list) - tmp137 := lang.Apply(tmp136, []any{sym_glojure_DOT_core_SLASH_let}) - tmp138 := checkDerefVar(var_glojure_DOT_core_list) - tmp139 := checkDerefVar(var_glojure_DOT_core_apply) - tmp140 := checkDerefVar(var_glojure_DOT_core_vector) - tmp141 := checkDerefVar(var_glojure_DOT_core_seq) - tmp142 := checkDerefVar(var_glojure_DOT_core_concat) - tmp143 := checkDerefVar(var_glojure_DOT_core_list) - tmp144 := lang.Apply(tmp143, []any{v16}) - tmp145 := checkDerefVar(var_glojure_DOT_core_list) - tmp146 := lang.Apply(tmp145, []any{v5}) - tmp147 := lang.Apply(tmp142, []any{tmp144, tmp146}) - tmp148 := lang.Apply(tmp141, []any{tmp147}) - tmp149 := lang.Apply(tmp139, []any{tmp140, tmp148}) - tmp150 := lang.Apply(tmp138, []any{tmp149}) - tmp151 := checkDerefVar(var_glojure_DOT_core_list) - tmp152 := checkDerefVar(var_glojure_DOT_core_seq) - tmp153 := checkDerefVar(var_glojure_DOT_core_concat) - tmp154 := checkDerefVar(var_glojure_DOT_core_list) - tmp155 := lang.Apply(tmp154, []any{sym_case_STAR_}) - tmp156 := checkDerefVar(var_glojure_DOT_core_list) - tmp157 := lang.Apply(tmp156, []any{v16}) - tmp158 := checkDerefVar(var_glojure_DOT_core_list) - tmp159 := lang.Apply(tmp158, []any{v124}) - tmp160 := checkDerefVar(var_glojure_DOT_core_list) - tmp161 := lang.Apply(tmp160, []any{v127}) - tmp162 := checkDerefVar(var_glojure_DOT_core_list) - tmp163 := lang.Apply(tmp162, []any{v50}) - tmp164 := checkDerefVar(var_glojure_DOT_core_list) - tmp165 := lang.Apply(tmp164, []any{v130}) - tmp166 := checkDerefVar(var_glojure_DOT_core_list) - tmp167 := lang.Apply(tmp166, []any{v133}) - tmp168 := checkDerefVar(var_glojure_DOT_core_list) - tmp169 := lang.Apply(tmp168, []any{kw_int}) - tmp170 := lang.Apply(tmp153, []any{tmp155, tmp157, tmp159, tmp161, tmp163, tmp165, tmp167, tmp169}) - tmp171 := lang.Apply(tmp152, []any{tmp170}) - tmp172 := lang.Apply(tmp151, []any{tmp171}) - tmp173 := lang.Apply(tmp135, []any{tmp137, tmp150, tmp172}) - tmp174 := lang.Apply(tmp134, []any{tmp173}) - tmp118 = tmp174 - } // end let - tmp116 = tmp118 - } else { - var tmp119 any - tmp120 := lang.Apply(v114, []any{kw_hashes, v115}) - if lang.IsTruthy(tmp120) { - var tmp121 any - { // let - // let binding "vec__185" - tmp122 := checkDerefVar(var_glojure_DOT_core_prep_DASH_hashes) - tmp123 := lang.Apply(tmp122, []any{v16, v50, v96, v99}) - var v124 any = tmp123 - _ = v124 - // let binding "shift" - tmp125 := checkDerefVar(var_glojure_DOT_core_nth) - tmp126 := lang.Apply(tmp125, []any{v124, int64(0), nil}) - var v127 any = tmp126 - _ = v127 - // let binding "mask" - tmp128 := checkDerefVar(var_glojure_DOT_core_nth) - tmp129 := lang.Apply(tmp128, []any{v124, int64(1), nil}) - var v130 any = tmp129 - _ = v130 - // let binding "imap" - tmp131 := checkDerefVar(var_glojure_DOT_core_nth) - tmp132 := lang.Apply(tmp131, []any{v124, int64(2), nil}) - var v133 any = tmp132 - _ = v133 - // let binding "switch-type" - tmp134 := checkDerefVar(var_glojure_DOT_core_nth) - tmp135 := lang.Apply(tmp134, []any{v124, int64(3), nil}) - var v136 any = tmp135 - _ = v136 - // let binding "skip-check" - tmp137 := checkDerefVar(var_glojure_DOT_core_nth) - tmp138 := lang.Apply(tmp137, []any{v124, int64(4), nil}) - var v139 any = tmp138 - _ = v139 - tmp140 := checkDerefVar(var_glojure_DOT_core_seq) - tmp141 := checkDerefVar(var_glojure_DOT_core_concat) - tmp142 := checkDerefVar(var_glojure_DOT_core_list) - tmp143 := lang.Apply(tmp142, []any{sym_glojure_DOT_core_SLASH_let}) - tmp144 := checkDerefVar(var_glojure_DOT_core_list) - tmp145 := checkDerefVar(var_glojure_DOT_core_apply) - tmp146 := checkDerefVar(var_glojure_DOT_core_vector) - tmp147 := checkDerefVar(var_glojure_DOT_core_seq) - tmp148 := checkDerefVar(var_glojure_DOT_core_concat) - tmp149 := checkDerefVar(var_glojure_DOT_core_list) - tmp150 := lang.Apply(tmp149, []any{v16}) - tmp151 := checkDerefVar(var_glojure_DOT_core_list) - tmp152 := lang.Apply(tmp151, []any{v5}) - tmp153 := lang.Apply(tmp148, []any{tmp150, tmp152}) - tmp154 := lang.Apply(tmp147, []any{tmp153}) - tmp155 := lang.Apply(tmp145, []any{tmp146, tmp154}) - tmp156 := lang.Apply(tmp144, []any{tmp155}) - tmp157 := checkDerefVar(var_glojure_DOT_core_list) - tmp158 := checkDerefVar(var_glojure_DOT_core_seq) - tmp159 := checkDerefVar(var_glojure_DOT_core_concat) - tmp160 := checkDerefVar(var_glojure_DOT_core_list) - tmp161 := lang.Apply(tmp160, []any{sym_case_STAR_}) - tmp162 := checkDerefVar(var_glojure_DOT_core_list) - tmp163 := lang.Apply(tmp162, []any{v16}) - tmp164 := checkDerefVar(var_glojure_DOT_core_list) - tmp165 := lang.Apply(tmp164, []any{v127}) - tmp166 := checkDerefVar(var_glojure_DOT_core_list) - tmp167 := lang.Apply(tmp166, []any{v130}) - tmp168 := checkDerefVar(var_glojure_DOT_core_list) - tmp169 := lang.Apply(tmp168, []any{v50}) - tmp170 := checkDerefVar(var_glojure_DOT_core_list) - tmp171 := lang.Apply(tmp170, []any{v133}) - tmp172 := checkDerefVar(var_glojure_DOT_core_list) - tmp173 := lang.Apply(tmp172, []any{v136}) - tmp174 := checkDerefVar(var_glojure_DOT_core_list) - tmp175 := lang.Apply(tmp174, []any{kw_hash_DASH_equiv}) - tmp176 := checkDerefVar(var_glojure_DOT_core_list) - tmp177 := lang.Apply(tmp176, []any{v139}) - tmp178 := lang.Apply(tmp159, []any{tmp161, tmp163, tmp165, tmp167, tmp169, tmp171, tmp173, tmp175, tmp177}) - tmp179 := lang.Apply(tmp158, []any{tmp178}) - tmp180 := lang.Apply(tmp157, []any{tmp179}) - tmp181 := lang.Apply(tmp141, []any{tmp143, tmp156, tmp180}) - tmp182 := lang.Apply(tmp140, []any{tmp181}) - tmp121 = tmp182 - } // end let - tmp119 = tmp121 - } else { - var tmp122 any - tmp123 := lang.Apply(v114, []any{kw_identity, v115}) - if lang.IsTruthy(tmp123) { - var tmp124 any - { // let - // let binding "vec__188" - tmp125 := checkDerefVar(var_glojure_DOT_core_prep_DASH_hashes) - tmp126 := lang.Apply(tmp125, []any{v16, v50, v96, v99}) - var v127 any = tmp126 - _ = v127 - // let binding "shift" - tmp128 := checkDerefVar(var_glojure_DOT_core_nth) - tmp129 := lang.Apply(tmp128, []any{v127, int64(0), nil}) - var v130 any = tmp129 - _ = v130 - // let binding "mask" - tmp131 := checkDerefVar(var_glojure_DOT_core_nth) - tmp132 := lang.Apply(tmp131, []any{v127, int64(1), nil}) - var v133 any = tmp132 - _ = v133 - // let binding "imap" - tmp134 := checkDerefVar(var_glojure_DOT_core_nth) - tmp135 := lang.Apply(tmp134, []any{v127, int64(2), nil}) - var v136 any = tmp135 - _ = v136 - // let binding "switch-type" - tmp137 := checkDerefVar(var_glojure_DOT_core_nth) - tmp138 := lang.Apply(tmp137, []any{v127, int64(3), nil}) - var v139 any = tmp138 - _ = v139 - // let binding "skip-check" - tmp140 := checkDerefVar(var_glojure_DOT_core_nth) - tmp141 := lang.Apply(tmp140, []any{v127, int64(4), nil}) - var v142 any = tmp141 - _ = v142 - tmp143 := checkDerefVar(var_glojure_DOT_core_seq) - tmp144 := checkDerefVar(var_glojure_DOT_core_concat) - tmp145 := checkDerefVar(var_glojure_DOT_core_list) - tmp146 := lang.Apply(tmp145, []any{sym_glojure_DOT_core_SLASH_let}) - tmp147 := checkDerefVar(var_glojure_DOT_core_list) - tmp148 := checkDerefVar(var_glojure_DOT_core_apply) - tmp149 := checkDerefVar(var_glojure_DOT_core_vector) - tmp150 := checkDerefVar(var_glojure_DOT_core_seq) - tmp151 := checkDerefVar(var_glojure_DOT_core_concat) - tmp152 := checkDerefVar(var_glojure_DOT_core_list) - tmp153 := lang.Apply(tmp152, []any{v16}) - tmp154 := checkDerefVar(var_glojure_DOT_core_list) - tmp155 := lang.Apply(tmp154, []any{v5}) - tmp156 := lang.Apply(tmp151, []any{tmp153, tmp155}) - tmp157 := lang.Apply(tmp150, []any{tmp156}) - tmp158 := lang.Apply(tmp148, []any{tmp149, tmp157}) - tmp159 := lang.Apply(tmp147, []any{tmp158}) - tmp160 := checkDerefVar(var_glojure_DOT_core_list) - tmp161 := checkDerefVar(var_glojure_DOT_core_seq) - tmp162 := checkDerefVar(var_glojure_DOT_core_concat) - tmp163 := checkDerefVar(var_glojure_DOT_core_list) - tmp164 := lang.Apply(tmp163, []any{sym_case_STAR_}) - tmp165 := checkDerefVar(var_glojure_DOT_core_list) - tmp166 := lang.Apply(tmp165, []any{v16}) - tmp167 := checkDerefVar(var_glojure_DOT_core_list) - tmp168 := lang.Apply(tmp167, []any{v130}) - tmp169 := checkDerefVar(var_glojure_DOT_core_list) - tmp170 := lang.Apply(tmp169, []any{v133}) - tmp171 := checkDerefVar(var_glojure_DOT_core_list) - tmp172 := lang.Apply(tmp171, []any{v50}) - tmp173 := checkDerefVar(var_glojure_DOT_core_list) - tmp174 := lang.Apply(tmp173, []any{v136}) - tmp175 := checkDerefVar(var_glojure_DOT_core_list) - tmp176 := lang.Apply(tmp175, []any{v139}) - tmp177 := checkDerefVar(var_glojure_DOT_core_list) - tmp178 := lang.Apply(tmp177, []any{kw_hash_DASH_identity}) - tmp179 := checkDerefVar(var_glojure_DOT_core_list) - tmp180 := lang.Apply(tmp179, []any{v142}) - tmp181 := lang.Apply(tmp162, []any{tmp164, tmp166, tmp168, tmp170, tmp172, tmp174, tmp176, tmp178, tmp180}) - tmp182 := lang.Apply(tmp161, []any{tmp181}) - tmp183 := lang.Apply(tmp160, []any{tmp182}) - tmp184 := lang.Apply(tmp144, []any{tmp146, tmp159, tmp183}) - tmp185 := lang.Apply(tmp143, []any{tmp184}) - tmp124 = tmp185 - } // end let - tmp122 = tmp124 - } else { - tmp125 := checkDerefVar(var_glojure_DOT_core_str) - tmp126 := lang.Apply(tmp125, []any{"No matching clause: ", v115}) - tmp127 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp126}) - panic(tmp127) - } - tmp119 = tmp122 - } - tmp116 = tmp119 - } - tmp112 = tmp116 - } // end let - tmp77 = tmp112 - } // end let - tmp51 = tmp77 - } - tmp7 = tmp51 - } // end let + tmp0 := sym_fnext.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Same as (first (next x))", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(6), kw_column, int(2), kw_line, int(112), kw_end_DASH_line, int(116))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function fnext + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_first) + tmp5 := checkDerefVar(var_glojure_DOT_core_next) + tmp6 := lang.Apply(tmp5, []any{v3}) + tmp7 := lang.Apply(tmp4, []any{tmp6}) return tmp7 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // case-map - { - tmp0 := sym_case_DASH_map.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_case_DASH_f, sym_test_DASH_f, sym_tests, sym_thens)), kw_doc, "Transforms a sequence of test constants and a corresponding sequence of then\n expressions into a sorted map to be consumed by case*. The form of the map\n entries are {(case-f test) [(test-f test) then]}.", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(8), kw_line, int(6614), kw_end_DASH_line, int(6614), kw_private, true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 4) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - tmp7 := checkDerefVar(var_glojure_DOT_core_into1) - tmp8 := checkDerefVar(var_glojure_DOT_core_sorted_DASH_map) - tmp9 := lang.Apply(tmp8, nil) - tmp10 := checkDerefVar(var_glojure_DOT_core_zipmap) - tmp11 := checkDerefVar(var_glojure_DOT_core_map) - tmp12 := lang.Apply(tmp11, []any{v3, v5}) - tmp13 := checkDerefVar(var_glojure_DOT_core_map) - tmp14 := checkDerefVar(var_glojure_DOT_core_vector) - tmp15 := checkDerefVar(var_glojure_DOT_core_map) - tmp16 := lang.Apply(tmp15, []any{v4, v5}) - tmp17 := lang.Apply(tmp13, []any{tmp14, tmp16, v6}) - tmp18 := lang.Apply(tmp10, []any{tmp12, tmp17}) - tmp19 := lang.Apply(tmp7, []any{tmp9, tmp18}) - return tmp19 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(116), kw_column, int(8), kw_end_DASH_line, int(116), kw_end_DASH_column, int(47))).(lang.FnFunc) + v2 = tmp1 + _ = v2 } - } - // cast - { - tmp0 := sym_cast.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_c, sym_x)), kw_doc, "Throws a ClassCastException if x is not a c, else returns x.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(345), kw_end_DASH_line, int(345))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5, _ := lang.FieldOrMethod(v3, "cast") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("cast is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core_fnext = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_fnext.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // cat + // future? { - tmp0 := sym_cat.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_rf)), kw_doc, "A transducer which concatenates the contents of each input, which must be a\n collection, into the reduction.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(7645), kw_end_DASH_line, int(7645))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_future_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x is a future", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(6532), kw_end_DASH_line, int(6532))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "rrf" - tmp5 := checkDerefVar(var_glojure_DOT_core_preserving_DASH_reduced) - tmp6 := lang.Apply(tmp5, []any{v3}) - var v7 any = tmp6 - _ = v7 - var tmp8 lang.FnFunc - tmp8 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp9 := lang.Apply(v3, nil) - return tmp9 - case 1: - v9 := args[0] - _ = v9 - tmp10 := lang.Apply(v3, []any{v9}) - return tmp10 - case 2: - v9 := args[0] - _ = v9 - v10 := args[1] - _ = v10 - tmp11 := checkDerefVar(var_glojure_DOT_core_reduce) - tmp12 := lang.Apply(tmp11, []any{v7, v9, v10}) - return tmp12 - default: - checkArity(args, -1) - panic("unreachable") - } - }) - tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7651), kw_column, int(5), kw_end_DASH_line, int(7655), kw_end_DASH_column, int(36)) - tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp4 = tmp10 - } // end let + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := lang.Apply(tmp3, []any{nil, v2}) return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_future_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_future_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // char + // gensym { + tmp0 := sym_gensym.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_prefix_DASH_string)), kw_doc, "Returns a new symbol with a unique name. If a prefix string is\n supplied, the name is prefix# where # is some unique number. If\n prefix is not supplied, the prefix is 'G__'.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(599), kw_end_DASH_line, int(599))).(*lang.Symbol) var tmp1 lang.FnFunc - { // function char__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_seq) - tmp5 := checkDerefVar(var_glojure_DOT_core_concat) - tmp6 := checkDerefVar(var_glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) - tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := checkDerefVar(var_glojure_DOT_core_seq) - tmp12 := checkDerefVar(var_glojure_DOT_core_concat) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - var tmp14 any - tmp15 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) - if lang.IsTruthy(tmp15) { - tmp14 = sym_uncheckedCharCast - } else { - tmp14 = sym_charCast + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp2 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp3 := lang.Apply(tmp2, []any{"G__"}) + return tmp3 + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_str) + tmp4 := checkDerefVar(var_glojure_DOT_core_str) + tmp5, _ := lang.FieldOrMethod(runtime.RT, "NextID") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("NextID is not a function"))) } - tmp16 := lang.Apply(tmp13, []any{tmp14}) - tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{v3}) - tmp19 := lang.Apply(tmp12, []any{tmp16, tmp18}) - tmp20 := lang.Apply(tmp11, []any{tmp19}) - tmp21 := lang.Apply(tmp10, []any{tmp20}) - tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp21}) - tmp23 := lang.Apply(tmp4, []any{tmp22}) - return tmp23 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := sym_char.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to char", kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3511), kw_end_DASH_line, int(3511))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(runtime.RT, "CharCast") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("CharCast is not a function"))) + tmp6 := lang.Apply(tmp5, []any{}) + tmp7 := lang.Apply(tmp4, []any{tmp6}) + tmp8 := lang.Apply(tmp3, []any{v2, tmp7}) + tmp9 := lang.Apply(lang.NewSymbol, []any{tmp8}) + return tmp9 + default: + checkArity(args, -1) + panic("unreachable") } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_gensym = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_gensym.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // char-array + // get { var tmp1 lang.FnFunc - { // function char-array__inliner + { // function get__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) - var v3 any = lang.NewList(args[0:]...) + checkArity(args, 2) + v3 := args[0] _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_seq) - tmp5 := checkDerefVar(var_glojure_DOT_core_concat) - tmp6 := checkDerefVar(var_glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp9 := lang.Apply(tmp8, []any{sym__DOT_}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_CharArray}) + tmp11 := lang.Apply(tmp10, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := checkDerefVar(var_glojure_DOT_core_seq) tmp14 := checkDerefVar(var_glojure_DOT_core_concat) tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_unquote_DASH_splicing}) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_Get}) tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{sym_glojure_DOT_core_SLASH_args}) - tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) - tmp20 := lang.Apply(tmp13, []any{tmp19}) - tmp21 := lang.Apply(tmp12, []any{tmp20}) - tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp21}) - tmp23 := lang.Apply(tmp4, []any{tmp22}) - return tmp23 + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v4}) + tmp21 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp20, v5}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp12, []any{tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp9, tmp11, tmp23}) + tmp25 := lang.Apply(tmp6, []any{tmp24}) + return tmp25 } }) v2 = tmp1 _ = v2 } - tmp0 := sym_char_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_size_DASH_or_DASH_seq), lang.NewVector(sym_size, sym_init_DASH_val_DASH_or_DASH_seq)), kw_inline, tmp1, kw_doc, "Creates an array of chars", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(5325), kw_end_DASH_line, int(5325))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_get.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_map, sym_key), lang.NewVector(sym_map, sym_key, sym_not_DASH_found)), kw_inline, tmp1, kw_doc, "Returns the value mapped to key, not-found or nil if key not present\n in associative collection, set, string, array, or ILookup instance.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2), int64(3)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(1489), kw_end_DASH_line, int(1489))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 1: - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "CharArray") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("CharArray is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 case 2: - v4 := args[0] + v3 := args[0] + _ = v3 + v4 := args[1] _ = v4 - v5 := args[1] + tmp5 := lang.Apply(lang.Get, []any{v3, v4}) + return tmp5 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "CharArrayInit") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("CharArrayInit is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 + tmp6 := lang.Apply(lang.GetDefault, []any{v3, v4, v5}) + return tmp6 default: checkArity(args, -1) panic("unreachable") } }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_get = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_get.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // char-escape-string + // halt-when { - tmp1 := reflect.TypeOf("") - tmp0 := sym_char_DASH_escape_DASH_string.WithMeta(lang.NewMap(kw_tag, tmp1, kw_doc, "Returns escape string for char or nil if none", kw_file, "glojure/core_print.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(6), kw_line, int(214), kw_end_DASH_line, int(217))).(*lang.Symbol) - tmp2 := ns.InternWithValue(tmp0, lang.NewMap(lang.NewChar(10), "\\n", lang.NewChar(9), "\\t", lang.NewChar(13), "\\r", lang.NewChar(34), "\\\"", lang.NewChar(92), "\\\\", lang.NewChar(12), "\\f", lang.NewChar(8), "\\b"), true) + tmp0 := sym_halt_DASH_when.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred), lang.NewVector(sym_pred, sym_retf)), kw_doc, "Returns a transducer that ends transduction when pred returns true\n for an input. When retf is supplied it must be a fn of 2 arguments -\n it will be passed the (completed) result so far and the input that\n triggered the predicate, and its return value (if it does not throw\n an exception) will be the return value of the transducer. If retf\n is not supplied, the input that triggered the predicate will be\n returned. If the predicate never returns true the transduction is\n unaffected.", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(7657), kw_end_DASH_line, int(7657))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_halt_DASH_when) + tmp4 := lang.Apply(tmp3, []any{v2, nil}) + return tmp4 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v5 := args[0] + _ = v5 + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp7 := lang.Apply(v5, nil) + return tmp7 + case 1: + v7 := args[0] + _ = v7 + var tmp8 any + var tmp9 any + { // let + // let binding "and__0__auto__" + tmp10 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp11 := lang.Apply(tmp10, []any{v7}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + tmp14 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp15 := lang.Apply(tmp14, []any{v7, kw_glojure_DOT_core_SLASH_halt}) + tmp13 = tmp15 + } else { + tmp13 = v12 + } + tmp9 = tmp13 + } // end let + if lang.IsTruthy(tmp9) { + tmp10 := lang.Apply(kw_glojure_DOT_core_SLASH_halt, []any{v7}) + tmp8 = tmp10 + } else { + tmp11 := lang.Apply(v5, []any{v7}) + tmp8 = tmp11 + } + return tmp8 + case 2: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + var tmp9 any + tmp10 := lang.Apply(v2, []any{v8}) + if lang.IsTruthy(tmp10) { + tmp11 := checkDerefVar(var_glojure_DOT_core_reduced) + var tmp12 any + if lang.IsTruthy(v3) { + tmp13 := lang.Apply(v5, []any{v7}) + tmp14 := lang.Apply(v3, []any{tmp13, v8}) + tmp12 = tmp14 + } else { + tmp12 = v8 + } + tmp15 := lang.NewMap(kw_glojure_DOT_core_SLASH_halt, tmp12) + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7678), kw_column, int(24), kw_end_DASH_line, int(7678), kw_end_DASH_column, int(72)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp9 = tmp18 + } else { + tmp19 := lang.Apply(v5, []any{v7, v8}) + tmp9 = tmp19 + } + return tmp9 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7670), kw_column, int(8), kw_end_DASH_line, int(7679), kw_end_DASH_column, int(34)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp8 + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7669), kw_column, int(6), kw_end_DASH_line, int(7679), kw_end_DASH_column, int(35)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_halt_DASH_when = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_halt_DASH_when.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // char-name-string + // ident? { - tmp1 := reflect.TypeOf("") - tmp0 := sym_char_DASH_name_DASH_string.WithMeta(lang.NewMap(kw_tag, tmp1, kw_doc, "Returns name string for char or nil if none", kw_file, "glojure/core_print.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(6), kw_line, int(335), kw_end_DASH_line, int(338))).(*lang.Symbol) - tmp2 := ns.InternWithValue(tmp0, lang.NewMap(lang.NewChar(10), "newline", lang.NewChar(9), "tab", lang.NewChar(32), "space", lang.NewChar(8), "backspace", lang.NewChar(12), "formfeed", lang.NewChar(13), "return"), true) + tmp0 := sym_ident_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a symbol or keyword", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(1608), kw_end_DASH_line, int(1608))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "or__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + tmp7 = v6 + } else { + tmp8 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp9 := lang.Apply(tmp8, []any{v2}) + tmp7 = tmp9 + } + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ident_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_ident_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // char? + // identical? { - tmp0 := sym_char_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a Character", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(6), kw_column, int(2), kw_line, int(153), kw_end_DASH_line, int(157))).(*lang.Symbol) - var tmp2 lang.FnFunc - { // function char? - var v3 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] + var tmp1 lang.FnFunc + { // function identical?__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp6 := reflect.TypeOf(int32(0)) - tmp7 := lang.Apply(tmp5, []any{tmp6, v4}) - return tmp7 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(157), kw_column, int(8), kw_end_DASH_line, int(157), kw_end_DASH_column, int(89))).(lang.FnFunc) - v3 = tmp2 - _ = v3 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_lang_DOT_Util}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_glojure_DOT_core_SLASH_identical}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{v3}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v4}) + tmp17 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp12, tmp14, tmp16}) + tmp18 := lang.Apply(tmp5, []any{tmp17}) + return tmp18 + }) + v2 = tmp1 + _ = v2 } - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp0 := sym_identical_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Tests if 2 arguments are the same object", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(768), kw_end_DASH_line, int(768))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(lang.Identical, []any{v3, v4}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_identical_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_identical_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // chars + // if-not { + tmp0 := sym_if_DASH_not.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_test, sym_then), lang.NewVector(sym_test, sym_then, sym_else)), kw_doc, "Evaluates test. If logical false, evaluates and returns then expr, \n otherwise else expr, if supplied, else nil.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(11), kw_line, int(760), kw_end_DASH_line, int(760))).(*lang.Symbol) var tmp1 lang.FnFunc - { // function chars - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_seq) - tmp5 := checkDerefVar(var_glojure_DOT_core_concat) - tmp6 := checkDerefVar(var_glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_if_DASH_not}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Chars}) + tmp11 := lang.Apply(tmp10, []any{v4}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) - tmp13 := lang.Apply(tmp12, []any{v3}) - tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) - tmp15 := lang.Apply(tmp4, []any{tmp14}) - return tmp15 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := sym_chars.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xs)), kw_inline, tmp1, kw_doc, "Casts to chars[]", kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(12), kw_line, int(5382), kw_end_DASH_line, int(5382))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Chars") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Chars is not a function"))) + tmp13 := lang.Apply(tmp12, []any{v5}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{nil}) + tmp16 := lang.Apply(tmp7, []any{tmp9, tmp11, tmp13, tmp15}) + tmp17 := lang.Apply(tmp6, []any{tmp16}) + return tmp17 + case 5: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_if}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_not}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v4}) + tmp18 := lang.Apply(tmp13, []any{tmp15, tmp17}) + tmp19 := lang.Apply(tmp12, []any{tmp18}) + tmp20 := lang.Apply(tmp11, []any{tmp19}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v5}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := lang.Apply(tmp23, []any{v6}) + tmp25 := lang.Apply(tmp8, []any{tmp10, tmp20, tmp22, tmp24}) + tmp26 := lang.Apply(tmp7, []any{tmp25}) + return tmp26 + default: + checkArity(args, -1) + panic("unreachable") } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_if_DASH_not = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_if_DASH_not.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // check-cyclic-dependency + // ifn? { - tmp0 := sym_check_DASH_cyclic_DASH_dependency.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_path)), kw_doc, "Detects and rejects non-trivial cyclic load dependencies. The\n exception message shows the dependency chain with the cycle\n highlighted. Ignores the trivial case of a file attempting to load\n itself because that can occur when a gen-class'd class loads its\n implementation.", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(30), kw_column, int(8), kw_line, int(5974), kw_end_DASH_line, int(5974), kw_private, true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_ifn_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x implements IFn. Note that many data structures\n (e.g. sets and maps) implement IFn", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(6209), kw_end_DASH_line, int(6209))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := checkDerefVar(var_glojure_DOT_core_some) - tmp6 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{v3})) - tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5981), kw_column, int(15), kw_end_DASH_line, int(5981), kw_end_DASH_column, int(21)) - tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp9 := checkDerefVar(var_glojure_DOT_core_rest) - tmp10 := checkDerefVar(var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_) - tmp11 := lang.Apply(tmp9, []any{tmp10}) - tmp12 := lang.Apply(tmp5, []any{tmp8, tmp11}) - if lang.IsTruthy(tmp12) { - var tmp13 any - { // let - // let binding "pending" - tmp14 := checkDerefVar(var_glojure_DOT_core_map) - var tmp15 lang.FnFunc - tmp15 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v16 := args[0] - _ = v16 - var tmp17 any - tmp18 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp19 := lang.Apply(tmp18, []any{v16, v3}) - if lang.IsTruthy(tmp19) { - tmp20 := checkDerefVar(var_glojure_DOT_core_str) - tmp21 := lang.Apply(tmp20, []any{"[ ", v16, " ]"}) - tmp17 = tmp21 - } else { - tmp17 = v16 - } - return tmp17 - }) - tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5982), kw_column, int(24), kw_end_DASH_line, int(5982), kw_end_DASH_column, int(59)) - tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp18 := checkDerefVar(var_glojure_DOT_core_cons) - tmp19 := checkDerefVar(var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_) - tmp20 := lang.Apply(tmp18, []any{v3, tmp19}) - tmp21 := lang.Apply(tmp14, []any{tmp17, tmp20}) - var v22 any = tmp21 - _ = v22 - // let binding "chain" - tmp23 := checkDerefVar(var_glojure_DOT_core_apply) - tmp24 := checkDerefVar(var_glojure_DOT_core_str) - tmp25 := checkDerefVar(var_glojure_DOT_core_interpose) - tmp26 := lang.Apply(tmp25, []any{"->", v22}) - tmp27 := lang.Apply(tmp23, []any{tmp24, tmp26}) - var v28 any = tmp27 - _ = v28 - tmp29 := checkDerefVar(var_glojure_DOT_core_throw_DASH_if) - tmp30 := lang.Apply(tmp29, []any{true, "Cyclic load dependency: %s", v28}) - tmp13 = tmp30 - } // end let - tmp4 = tmp13 - } else { - } + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := lang.Apply(tmp3, []any{nil, v2}) return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ifn_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_ifn_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // check-valid-options + // inc { - tmp0 := sym_check_DASH_valid_DASH_options.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_options, sym__AMP_, sym_valid_DASH_keys)), kw_doc, "Throws an exception if the given option map contains keys not listed\n as valid, else returns nil.", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(35), kw_column, int(7), kw_line, int(1709), kw_end_DASH_line, int(1709), kw_private, true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: + var tmp1 lang.FnFunc + { // function inc__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) v3 := args[0] _ = v3 - var v4 any = lang.NewList(args[1:]...) - _ = v4 - var tmp5 any - tmp6 := checkDerefVar(var_glojure_DOT_core_seq) - tmp7 := checkDerefVar(var_glojure_DOT_core_apply) - tmp8 := checkDerefVar(var_glojure_DOT_core_disj) - tmp9 := checkDerefVar(var_glojure_DOT_core_apply) - tmp10 := checkDerefVar(var_glojure_DOT_core_hash_DASH_set) - tmp11 := checkDerefVar(var_glojure_DOT_core_keys) - tmp12 := lang.Apply(tmp11, []any{v3}) - tmp13 := lang.Apply(tmp9, []any{tmp10, tmp12}) - tmp14 := lang.Apply(tmp7, []any{tmp8, tmp13, v4}) - tmp15 := lang.Apply(tmp6, []any{tmp14}) + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp15) { - tmp16 := checkDerefVar(var_glojure_DOT_core_apply) - tmp17 := checkDerefVar(var_glojure_DOT_core_str) - tmp18 := checkDerefVar(var_glojure_DOT_core_first) - tmp19 := lang.Apply(tmp18, []any{v4}) - tmp20 := checkDerefVar(var_glojure_DOT_core_map) - var tmp21 lang.FnFunc - tmp21 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v22 := args[0] - _ = v22 - tmp23 := checkDerefVar(var_glojure_DOT_core_str) - tmp24 := lang.Apply(tmp23, []any{", ", v22}) - return tmp24 - }) - tmp22 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(1718), kw_column, int(16), kw_end_DASH_line, int(1718), kw_end_DASH_column, int(28)) - tmp23, err := lang.WithMeta(tmp21, tmp22.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp24 := checkDerefVar(var_glojure_DOT_core_rest) - tmp25 := lang.Apply(tmp24, []any{v4}) - tmp26 := lang.Apply(tmp20, []any{tmp23, tmp25}) - tmp27 := lang.Apply(tmp16, []any{tmp17, "Only these options are valid: ", tmp19, tmp26}) - tmp28 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp27}) - panic(tmp28) + tmp14 = sym_unchecked_inc } else { + tmp14 = sym_inc } - return tmp5 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + tmp16 := lang.Apply(tmp13, []any{tmp14}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := lang.Apply(tmp12, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp11, []any{tmp19}) + tmp21 := lang.Apply(tmp10, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + }) + v2 = tmp1 + _ = v2 } - } - // chunk - { - tmp0 := sym_chunk.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(691), kw_column, int(7), kw_end_DASH_line, int(691), kw_end_DASH_column, int(41), kw_arglists, lang.NewList(lang.NewVector(sym_b)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + tmp0 := sym_inc.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns a number one greater than num. Does not auto-promote\n longs, will throw on overflow. See also: inc'", kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(915), kw_end_DASH_line, int(915))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, ok := lang.FieldOrMethod(v3, "chunk") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "chunk"))) - } - var tmp5 any - switch reflect.TypeOf(tmp4).Kind() { - case reflect.Func: - tmp5 = lang.Apply(tmp4, nil) - default: - tmp5 = tmp4 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Inc") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Inc is not a function"))) } + tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core_inc = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_inc.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // chunk-append + // inc' { - tmp0 := sym_chunk_DASH_append.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(688), kw_column, int(7), kw_end_DASH_line, int(688), kw_end_DASH_column, int(27), kw_arglists, lang.NewList(lang.NewVector(sym_b, sym_x)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function inc'__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_IncP}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_inc_TICK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns a number one greater than num. Supports arbitrary precision.\n See also: inc", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(908), kw_end_DASH_line, int(908))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) + checkArity(args, 1) v3 := args[0] _ = v3 - v4 := args[1] - _ = v4 - tmp5, _ := lang.FieldOrMethod(v3, "add") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "IncP") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("IncP is not a function"))) } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core_inc_TICK_ = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_inc_TICK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // chunk-buffer + // indexed? { - tmp0 := sym_chunk_DASH_buffer.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(685), kw_column, int(7), kw_end_DASH_line, int(685), kw_end_DASH_column, int(53), kw_arglists, lang.NewList(lang.NewVector(sym_capacity)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_indexed_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Return true if coll implements Indexed, indicating efficient lookup by index", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(6263), kw_end_DASH_line, int(6263))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := lang.Apply(lang.NewChunkBuffer, []any{v3}) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := lang.Apply(tmp3, []any{nil, v2}) return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_indexed_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_indexed_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // chunk-cons + // infinite? { - tmp0 := sym_chunk_DASH_cons.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(703), kw_column, int(7), kw_end_DASH_line, int(703), kw_end_DASH_column, int(25), kw_arglists, lang.NewList(lang.NewVector(sym_chunk, sym_rest)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function infinite?__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym_Double_SLASH_isInfinite}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{v3}) + tmp10 := lang.Apply(tmp5, []any{tmp7, tmp9}) + tmp11 := lang.Apply(tmp4, []any{tmp10}) + return tmp11 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_infinite_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_num)), kw_inline, tmp1, kw_doc, "Returns true if num is negative or positive infinity, else false", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1)})), kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(7977), kw_end_DASH_line, int(7977))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) + checkArity(args, 1) v3 := args[0] _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - tmp6 := lang.Apply(lang.Count, []any{v3}) - tmp7 := lang.Apply(lang.IsZero, []any{tmp6}) - if lang.IsTruthy(tmp7) { - tmp5 = v4 - } else { - tmp8 := lang.Apply(lang.NewChunkedCons, []any{v3, v4}) - tmp5 = tmp8 - } - return tmp5 + tmp4 := lang.Apply(nil, []any{v3}) + return tmp4 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core_infinite_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_infinite_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // chunk-first + // int { - tmp0 := sym_chunk_DASH_first.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(694), kw_column, int(7), kw_end_DASH_line, int(694), kw_end_DASH_column, int(48), kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function int__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp15) { + tmp14 = sym_uncheckedIntCast + } else { + tmp14 = sym_intCast + } + tmp16 := lang.Apply(tmp13, []any{tmp14}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := lang.Apply(tmp12, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp11, []any{tmp19}) + tmp21 := lang.Apply(tmp10, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to int", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(875), kw_end_DASH_line, int(875))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, ok := lang.FieldOrMethod(v3, "chunkedFirst") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "chunkedFirst"))) - } - var tmp5 any - switch reflect.TypeOf(tmp4).Kind() { - case reflect.Func: - tmp5 = lang.Apply(tmp4, nil) - default: - tmp5 = tmp4 + tmp4, _ := lang.FieldOrMethod(runtime.RT, "IntCast") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("IntCast is not a function"))) } + tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core_int = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_int.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // chunk-next + // int-array { - tmp0 := sym_chunk_DASH_next.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(700), kw_column, int(7), kw_end_DASH_line, int(700), kw_end_DASH_column, int(71), kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function int-array__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_IntArray}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_unquote_DASH_splicing}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_glojure_DOT_core_SLASH_args}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + } + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_int_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_size_DASH_or_DASH_seq), lang.NewVector(sym_size, sym_init_DASH_val_DASH_or_DASH_seq)), kw_inline, tmp1, kw_doc, "Creates an array of ints", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(5356), kw_end_DASH_line, int(5356))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4, ok := lang.FieldOrMethod(v3, "chunkedNext") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "chunkedNext"))) - } - var tmp5 any - switch reflect.TypeOf(tmp4).Kind() { - case reflect.Func: - tmp5 = lang.Apply(tmp4, nil) + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "IntArray") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("IntArray is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "IntArrayInit") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("IntArrayInit is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 default: - tmp5 = tmp4 + checkArity(args, -1) + panic("unreachable") } - return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core_int_DASH_array = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_int_DASH_array.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // chunk-rest + // intern { - tmp0 := sym_chunk_DASH_rest.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(697), kw_column, int(7), kw_end_DASH_line, int(697), kw_end_DASH_column, int(71), kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4, ok := lang.FieldOrMethod(v3, "chunkedMore") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "chunkedMore"))) - } - var tmp5 any - switch reflect.TypeOf(tmp4).Kind() { - case reflect.Func: - tmp5 = lang.Apply(tmp4, nil) + tmp0 := sym_intern.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns, sym_name), lang.NewVector(sym_ns, sym_name, sym_val)), kw_doc, "Finds or creates a var named by the symbol name in the namespace\n ns (which can be a symbol or a namespace), setting its root binding\n to val if supplied. The namespace must exist. The var will adopt any\n metadata from the name symbol. Returns the var.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(6311), kw_end_DASH_line, int(6311))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "v" + tmp5 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) + tmp6 := lang.Apply(tmp5, []any{v2}) + tmp7 := lang.Apply(nil, []any{tmp6, v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_meta) + tmp11 := lang.Apply(tmp10, []any{v3}) + if lang.IsTruthy(tmp11) { + tmp12 := checkDerefVar(var_glojure_DOT_core_meta) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14, _ := lang.FieldOrMethod(v8, "setMeta") + if reflect.TypeOf(tmp14).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMeta is not a function"))) + } + tmp15 := lang.Apply(tmp14, []any{tmp13}) + tmp9 = tmp15 + } else { + } + _ = tmp9 + tmp4 = v8 + } // end let + return tmp4 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + { // let + // let binding "v" + tmp6 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) + tmp7 := lang.Apply(tmp6, []any{v2}) + tmp8 := lang.Apply(nil, []any{tmp7, v3, v4}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + tmp11 := checkDerefVar(var_glojure_DOT_core_meta) + tmp12 := lang.Apply(tmp11, []any{v3}) + if lang.IsTruthy(tmp12) { + tmp13 := checkDerefVar(var_glojure_DOT_core_meta) + tmp14 := lang.Apply(tmp13, []any{v3}) + tmp15, _ := lang.FieldOrMethod(v9, "setMeta") + if reflect.TypeOf(tmp15).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMeta is not a function"))) + } + tmp16 := lang.Apply(tmp15, []any{tmp14}) + tmp10 = tmp16 + } else { + } + _ = tmp10 + tmp5 = v9 + } // end let + return tmp5 default: - tmp5 = tmp4 + checkArity(args, -1) + panic("unreachable") } - return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_intern = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_intern.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // chunked-seq? + // into-array { - tmp0 := sym_chunked_DASH_seq_QMARK_.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(708), kw_column, int(7), kw_end_DASH_line, int(708), kw_end_DASH_column, int(27), kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp5 := reflect.TypeOf((*lang.IChunkedSeq)(nil)).Elem() - tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) - return tmp6 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // class - { - tmp0 := sym_class.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns the Class of x", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3461), kw_end_DASH_line, int(3461))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) - tmp6 := lang.Apply(tmp5, []any{v3}) - if lang.IsTruthy(tmp6) { - tmp4 = v3 - } else { - tmp7 := lang.Apply(lang.TypeOf, []any{v3}) - tmp4 = tmp7 - } - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // class? - { - tmp0 := sym_class_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x is an instance of Class", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(5465), kw_end_DASH_line, int(5465))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp5 := reflect.TypeOf((*reflect.Type)(nil)).Elem() - tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) - return tmp6 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // clear-agent-errors - { - tmp0 := sym_clear_DASH_agent_DASH_errors.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a)), kw_doc, "DEPRECATED: Use 'restart-agent' instead.\n Clears any exceptions thrown during asynchronous actions of the\n agent, allowing subsequent actions to occur.", kw_file, "glojure/core.glj", kw_deprecated, "1.2", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(24), kw_column, int(7), kw_line, int(2244), kw_end_DASH_line, int(2244))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_restart_DASH_agent) - tmp5, ok := lang.FieldOrMethod(v3, "Deref") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "Deref"))) - } - var tmp6 any - switch reflect.TypeOf(tmp5).Kind() { - case reflect.Func: - tmp6 = lang.Apply(tmp5, nil) + tmp0 := sym_into_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_aseq), lang.NewVector(sym_type, sym_aseq)), kw_doc, "Returns an array with components set to the values in aseq. The array's\n component type is type if provided, or the type of the first value in\n aseq if present, or Object. All values in aseq must be compatible with\n the component type. Class objects for the primitive types can be obtained\n using, e.g., Integer/TYPE.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(3444), kw_end_DASH_line, int(3444))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_seq) + tmp4 := lang.Apply(tmp3, []any{v2}) + tmp5 := lang.Apply(nil, []any{tmp4}) + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := lang.Apply(tmp4, []any{v3}) + tmp6 := lang.Apply(nil, []any{v2, tmp5}) + return tmp6 default: - tmp6 = tmp5 + checkArity(args, -1) + panic("unreachable") } - tmp7 := lang.Apply(tmp4, []any{v3, tmp6}) - return tmp7 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_into_DASH_array = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_into_DASH_array.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // coll? + // ints { - tmp0 := sym_coll_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x implements IPersistentCollection", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(6192), kw_end_DASH_line, int(6192))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function ints + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Ints}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_ints.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xs)), kw_inline, tmp1, kw_doc, "Casts to int[]", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(12), kw_line, int(5397), kw_end_DASH_line, int(5397))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp5 := reflect.TypeOf((*lang.IPersistentCollection)(nil)).Elem() - tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) - return tmp6 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // comment - { - tmp0 := sym_comment.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_body)), kw_doc, "Ignores body, yields nil", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(4733), kw_end_DASH_line, int(4733))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - return nil + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Ints") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Ints is not a function"))) } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core_ints = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_ints.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // commute + // io! { - tmp0 := sym_commute.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ref, sym_fun, sym__AMP_, sym_args)), kw_doc, "Must be called in a transaction. Sets the in-transaction-value of\n ref to:\n\n (apply fun in-transaction-value-of-ref args)\n\n and returns the in-transaction-value of ref.\n\n At the commit point of the transaction, sets the value of ref to be:\n\n (apply fun most-recently-committed-value-of-ref args)\n\n Thus fun should be commutative, or, failing that, you must accept\n last-one-in-wins behavior. commute allows for more concurrency than\n ref-set.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(2414), kw_end_DASH_line, int(2414))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_io_BANG_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_body)), kw_doc, "If an io! block occurs in a transaction, throws an\n IllegalStateException, else runs body in an implicit do. If the\n first expression in body is a literal string, will use that as the\n exception message.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(11), kw_line, int(2504), kw_end_DASH_line, int(2504))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: checkArity(args, 2) - v3 := args[0] + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + var v4 any = lang.NewList(args[2:]...) _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - tmp6, _ := lang.FieldOrMethod(v3, "Commute") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Commute is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 + var tmp5 any + { // let + // let binding "message" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp8 := checkDerefVar(var_glojure_DOT_core_first) + tmp9 := lang.Apply(tmp8, []any{v4}) + tmp10 := lang.Apply(tmp7, []any{tmp9}) + if lang.IsTruthy(tmp10) { + tmp11 := checkDerefVar(var_glojure_DOT_core_first) + tmp12 := lang.Apply(tmp11, []any{v4}) + tmp6 = tmp12 + } else { + } + var v13 any = tmp6 + _ = v13 + // let binding "body" + var tmp14 any + if lang.IsTruthy(v13) { + tmp15 := checkDerefVar(var_glojure_DOT_core_next) + tmp16 := lang.Apply(tmp15, []any{v4}) + tmp14 = tmp16 + } else { + tmp14 = v4 + } + var v17 any = tmp14 + _ = v17 + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{sym_if}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := checkDerefVar(var_glojure_DOT_core_seq) + tmp24 := checkDerefVar(var_glojure_DOT_core_concat) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := lang.Apply(tmp25, []any{sym_glojure_DOT_lang_DOT_LockingTransaction_SLASH_isRunning}) + tmp27 := lang.Apply(tmp24, []any{tmp26}) + tmp28 := lang.Apply(tmp23, []any{tmp27}) + tmp29 := lang.Apply(tmp22, []any{tmp28}) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := checkDerefVar(var_glojure_DOT_core_seq) + tmp32 := checkDerefVar(var_glojure_DOT_core_concat) + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{sym_throw}) + tmp35 := checkDerefVar(var_glojure_DOT_core_list) + tmp36 := checkDerefVar(var_glojure_DOT_core_seq) + tmp37 := checkDerefVar(var_glojure_DOT_core_concat) + tmp38 := checkDerefVar(var_glojure_DOT_core_list) + tmp39 := lang.Apply(tmp38, []any{sym_new}) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{sym_glojure_DOT_core_SLASH_IllegalStateException}) + tmp42 := checkDerefVar(var_glojure_DOT_core_list) + var tmp43 any + { // let + // let binding "or__0__auto__" + var v44 any = v13 + _ = v44 + var tmp45 any + if lang.IsTruthy(v44) { + tmp45 = v44 + } else { + tmp45 = "I/O in transaction" + } + tmp43 = tmp45 + } // end let + tmp44 := lang.Apply(tmp42, []any{tmp43}) + tmp45 := lang.Apply(tmp37, []any{tmp39, tmp41, tmp44}) + tmp46 := lang.Apply(tmp36, []any{tmp45}) + tmp47 := lang.Apply(tmp35, []any{tmp46}) + tmp48 := lang.Apply(tmp32, []any{tmp34, tmp47}) + tmp49 := lang.Apply(tmp31, []any{tmp48}) + tmp50 := lang.Apply(tmp30, []any{tmp49}) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := checkDerefVar(var_glojure_DOT_core_seq) + tmp53 := checkDerefVar(var_glojure_DOT_core_concat) + tmp54 := checkDerefVar(var_glojure_DOT_core_list) + tmp55 := lang.Apply(tmp54, []any{sym_do}) + tmp56 := lang.Apply(tmp53, []any{tmp55, v17}) + tmp57 := lang.Apply(tmp52, []any{tmp56}) + tmp58 := lang.Apply(tmp51, []any{tmp57}) + tmp59 := lang.Apply(tmp19, []any{tmp21, tmp29, tmp50, tmp58}) + tmp60 := lang.Apply(tmp18, []any{tmp59}) + tmp5 = tmp60 + } // end let + return tmp5 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_io_BANG_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_io_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // comp + // keep-indexed { - tmp0 := sym_comp.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_f), lang.NewVector(sym_f, sym_g), lang.NewVector(sym_f, sym_g, sym__AMP_, sym_fs)), kw_doc, "Takes a set of functions and returns a fn that is the composition\n of those fns. The returned fn takes a variable number of args,\n applies the rightmost of fns to the args, the next\n fn (right-to-left) to the result, etc.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(2549), kw_end_DASH_line, int(2549))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_keep_DASH_indexed.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_coll)), kw_doc, "Returns a lazy sequence of the non-nil results of (f index item). Note,\n this means false return values will be included. f must be free of\n side-effects. Returns a stateful transducer when no collection is\n provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(7372), kw_end_DASH_line, int(7372))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 0: - tmp3 := checkDerefVar(var_glojure_DOT_core_identity) - return tmp3 case 1: - v3 := args[0] - _ = v3 - return v3 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 lang.FnFunc - tmp5 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp6 := lang.Apply(v4, nil) - tmp7 := lang.Apply(v3, []any{tmp6}) - return tmp7 - case 1: - v6 := args[0] - _ = v6 - tmp7 := lang.Apply(v4, []any{v6}) - tmp8 := lang.Apply(v3, []any{tmp7}) - return tmp8 - case 2: - v6 := args[0] - _ = v6 - v7 := args[1] - _ = v7 - tmp8 := lang.Apply(v4, []any{v6, v7}) - tmp9 := lang.Apply(v3, []any{tmp8}) - return tmp9 - case 3: - v6 := args[0] - _ = v6 - v7 := args[1] - _ = v7 - v8 := args[2] - _ = v8 - tmp9 := lang.Apply(v4, []any{v6, v7, v8}) - tmp10 := lang.Apply(v3, []any{tmp9}) - return tmp10 - default: - checkArity(args, 3) - v6 := args[0] - _ = v6 - v7 := args[1] - _ = v7 - v8 := args[2] + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 any + { // let + // let binding "iv" + tmp6 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) + tmp7 := lang.Apply(tmp6, []any{int64(-1)}) + var v8 any = tmp7 _ = v8 - var v9 any = lang.NewList(args[3:]...) - _ = v9 - tmp10 := checkDerefVar(var_glojure_DOT_core_apply) - tmp11 := lang.Apply(tmp10, []any{v4, v6, v7, v8, v9}) - tmp12 := lang.Apply(v3, []any{tmp11}) - return tmp12 - } + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp10 := lang.Apply(v4, nil) + return tmp10 + case 1: + v10 := args[0] + _ = v10 + tmp11 := lang.Apply(v4, []any{v10}) + return tmp11 + case 2: + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + var tmp12 any + { // let + // let binding "i" + tmp13 := checkDerefVar(var_glojure_DOT_core_inc) + tmp14, ok := lang.FieldOrMethod(v8, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "Deref"))) + } + var tmp15 any + switch reflect.TypeOf(tmp14).Kind() { + case reflect.Func: + tmp15 = lang.Apply(tmp14, nil) + default: + tmp15 = tmp14 + } + tmp16 := lang.Apply(tmp13, []any{tmp15}) + tmp17, _ := lang.FieldOrMethod(v8, "reset") + if reflect.TypeOf(tmp17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) + } + tmp18 := lang.Apply(tmp17, []any{tmp16}) + var v19 any = tmp18 + _ = v19 + // let binding "v" + tmp20 := lang.Apply(v2, []any{v19, v11}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + tmp23 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp24 := lang.Apply(tmp23, []any{v21}) + if lang.IsTruthy(tmp24) { + tmp22 = v10 + } else { + tmp25 := lang.Apply(v4, []any{v10, v21}) + tmp22 = tmp25 + } + tmp12 = tmp22 + } // end let + return tmp12 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7382), kw_column, int(8), kw_end_DASH_line, int(7390), kw_end_DASH_column, int(33)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp5 = tmp11 + } // end let + return tmp5 }) - tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2559), kw_column, int(6), kw_end_DASH_line, int(2564), kw_end_DASH_column, int(49)) - tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7380), kw_column, int(4), kw_end_DASH_line, int(7390), kw_end_DASH_column, int(35)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) if err != nil { panic(err) } - return tmp7 - default: - checkArity(args, 2) - v3 := args[0] + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - tmp6 := checkDerefVar(var_glojure_DOT_core_reduce1) - tmp7 := checkDerefVar(var_glojure_DOT_core_comp) - tmp8 := checkDerefVar(var_glojure_DOT_core_list_STAR_) - tmp9 := lang.Apply(tmp8, []any{v3, v4, v5}) - tmp10 := lang.Apply(tmp6, []any{tmp7, tmp9}) - return tmp10 + return nil + default: + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_keep_DASH_indexed = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_keep_DASH_indexed.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // comparator + // keyword { - tmp0 := sym_comparator.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred)), kw_doc, "Returns an implementation of java.util.Comparator based upon pred.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(3077), kw_end_DASH_line, int(3077))).(*lang.Symbol) + tmp1 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() + tmp0 := sym_keyword.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_name), lang.NewVector(sym_ns, sym_name)), kw_doc, "Returns a Keyword with the given namespace and name. Do not use :\n in the keyword strings, it will be added automatically.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(609), kw_end_DASH_line, int(609))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - var tmp7 any - tmp8 := lang.Apply(v3, []any{v5, v6}) - if lang.IsTruthy(tmp8) { - tmp7 = int64(-1) + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + tmp4 = v3 } else { - var tmp9 any - tmp10 := lang.Apply(v3, []any{v6, v5}) - if lang.IsTruthy(tmp10) { - tmp9 = int64(1) + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp9 := lang.Apply(tmp8, []any{v3}) + if lang.IsTruthy(tmp9) { + tmp10 := lang.Apply(lang.InternKeywordSymbol, []any{v3}) + tmp7 = tmp10 } else { var tmp11 any - if lang.IsTruthy(kw_else) { - tmp11 = int64(0) + tmp12 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp13 := lang.Apply(tmp12, []any{v3}) + if lang.IsTruthy(tmp13) { + tmp14 := lang.Apply(lang.InternKeywordString, []any{v3}) + tmp11 = tmp14 } else { } - tmp9 = tmp11 + tmp7 = tmp11 } - tmp7 = tmp9 + tmp4 = tmp7 } - return tmp7 - }) - tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3082), kw_column, int(5), kw_end_DASH_line, int(3083), kw_end_DASH_column, int(48)) - tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) - if err != nil { - panic(err) + return tmp4 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(lang.InternKeyword, []any{v3, v4}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") } - return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp3 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_keyword = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_keyword.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // compare + // last { + tmp0 := sym_last.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Return the last item in coll, in linear time", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(5), kw_column, int(2), kw_line, int(262), kw_end_DASH_line, int(266))).(*lang.Symbol) var tmp1 lang.FnFunc - { // function compare__inliner + { // function last var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) + checkArity(args, 1) v3 := args[0] _ = v3 - v4 := args[1] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_seq) - tmp6 := checkDerefVar(var_glojure_DOT_core_concat) - tmp7 := checkDerefVar(var_glojure_DOT_core_list) - tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) - tmp9 := checkDerefVar(var_glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_lang_DOT_Util}) - tmp11 := checkDerefVar(var_glojure_DOT_core_list) - tmp12 := lang.Apply(tmp11, []any{sym_glojure_DOT_core_SLASH_compare}) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{v3}) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{v4}) - tmp17 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp12, tmp14, tmp16}) - tmp18 := lang.Apply(tmp5, []any{tmp17}) - return tmp18 + recur_loop_32: + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_next) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + tmp8 := checkDerefVar(var_glojure_DOT_core_next) + tmp9 := lang.Apply(tmp8, []any{v3}) + var tmp7 any = tmp9 + v3 = tmp7 + goto recur_loop_32 + } else { + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v3}) + tmp4 = tmp11 + } + return tmp4 }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(266), kw_column, int(7), kw_end_DASH_line, int(269), kw_end_DASH_column, int(21))).(lang.FnFunc) v2 = tmp1 _ = v2 } - tmp0 := sym_compare.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Comparator. Returns a negative number, zero, or a positive number\n when x is logically 'less than', 'equal to', or 'greater than'\n y. Same as Java x.compareTo(y) except it also works for nil, and\n compares numbers and collections in a type-independent manner. x\n must implement Comparable", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(824), kw_end_DASH_line, int(824))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6 := lang.Apply(lang.Compare, []any{v4, v5}) - return tmp6 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // compare-and-set! - { - tmp0 := sym_compare_DASH_and_DASH_set_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_atom, sym_oldval, sym_newval)), kw_doc, "Atomically sets the value of atom to newval if and only if the\n current value of the atom is identical to oldval. Returns true if\n set happened, else false", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(22), kw_column, int(7), kw_line, int(2360), kw_end_DASH_line, int(2360))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 3) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6, _ := lang.FieldOrMethod(v3, "compareAndSet") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("compareAndSet is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core_last = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_last.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // compile + // libspec? { - tmp0 := sym_compile.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_lib)), kw_doc, "Compiles the namespace named by the symbol lib into a set of\n classfiles. The source for the lib must be in a proper\n classpath-relative directory. The output files will go into the\n directory specified by *compile-path*, and that directory too must\n be in the classpath.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(6114), kw_end_DASH_line, int(6114))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_libspec_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x is a libspec", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(8), kw_line, int(5848), kw_end_DASH_line, int(5848), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 any + v2 := args[0] + _ = v2 + var tmp3 any { // let - tmp5 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) - tmp6 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) - tmp7 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_compile_DASH_files_STAR_) - tmp8 := lang.Apply(tmp6, []any{tmp7, true}) - tmp9 := lang.Apply(tmp5, []any{tmp8}) - _ = tmp9 - var tmp10 any - func() { - defer func() { - tmp11 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) - tmp12 := lang.Apply(tmp11, nil) - _ = tmp12 - }() - tmp13 := checkDerefVar(var_glojure_DOT_core_load_DASH_one) - tmp14 := lang.Apply(tmp13, []any{v3, true, true}) - tmp10 = tmp14 - }() - tmp4 = tmp10 - } // end let - _ = tmp4 - return v3 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // complement - { - tmp0 := sym_complement.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f)), kw_doc, "Takes a fn f and returns a fn that takes the same arguments as f,\n has the same effects, if any, and returns the opposite truth value.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(1428), kw_end_DASH_line, int(1428))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp5 := checkDerefVar(var_glojure_DOT_core_not) - tmp6 := lang.Apply(v3, nil) - tmp7 := lang.Apply(tmp5, []any{tmp6}) - return tmp7 - case 1: - v5 := args[0] - _ = v5 - tmp6 := checkDerefVar(var_glojure_DOT_core_not) - tmp7 := lang.Apply(v3, []any{v5}) - tmp8 := lang.Apply(tmp6, []any{tmp7}) - return tmp8 - case 2: - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - tmp7 := checkDerefVar(var_glojure_DOT_core_not) - tmp8 := lang.Apply(v3, []any{v5, v6}) - tmp9 := lang.Apply(tmp7, []any{tmp8}) - return tmp9 - default: - checkArity(args, 2) - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - var v7 any = lang.NewList(args[2:]...) - _ = v7 - tmp8 := checkDerefVar(var_glojure_DOT_core_not) - tmp9 := checkDerefVar(var_glojure_DOT_core_apply) - tmp10 := lang.Apply(tmp9, []any{v3, v5, v6, v7}) - tmp11 := lang.Apply(tmp8, []any{tmp10}) - return tmp11 + // let binding "or__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + tmp7 = v6 + } else { + var tmp8 any + { // let + // let binding "and__0__auto__" + tmp9 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp10 := lang.Apply(tmp9, []any{v2}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + var tmp13 any + { // let + // let binding "or__0__auto__" + tmp14 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp15 := checkDerefVar(var_glojure_DOT_core_second) + tmp16 := lang.Apply(tmp15, []any{v2}) + tmp17 := lang.Apply(tmp14, []any{tmp16}) + var v18 any = tmp17 + _ = v18 + var tmp19 any + if lang.IsTruthy(v18) { + tmp19 = v18 + } else { + tmp20 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp21 := checkDerefVar(var_glojure_DOT_core_second) + tmp22 := lang.Apply(tmp21, []any{v2}) + tmp23 := lang.Apply(tmp20, []any{tmp22}) + tmp19 = tmp23 + } + tmp13 = tmp19 + } // end let + tmp12 = tmp13 + } else { + tmp12 = v11 + } + tmp8 = tmp12 + } // end let + tmp7 = tmp8 } - }) - tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(1434), kw_column, int(3), kw_end_DASH_line, int(1438), kw_end_DASH_column, int(40)) - tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp6 + tmp3 = tmp7 + } // end let + return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_libspec_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_libspec_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // completing + // list* { - tmp0 := sym_completing.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_cf)), kw_doc, "Takes a reducing function f of 2 args and returns a fn suitable for\n transduce by adding an arity-1 signature that calls cf (default -\n identity) on the result argument.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(6893), kw_end_DASH_line, int(6893))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_list_STAR_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_args), lang.NewVector(sym_a, sym_args), lang.NewVector(sym_a, sym_b, sym_args), lang.NewVector(sym_a, sym_b, sym_c, sym_args), lang.NewVector(sym_a, sym_b, sym_c, sym_d, sym__AMP_, sym_more)), kw_doc, "Creates a new seq containing the items prepended to the rest, the\n last of which will be treated as a sequence.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(641), kw_end_DASH_line, int(641))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_completing) - tmp5 := checkDerefVar(var_glojure_DOT_core_identity) - tmp6 := lang.Apply(tmp4, []any{v3, tmp5}) - return tmp6 + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_seq) + tmp4 := lang.Apply(tmp3, []any{v2}) + return tmp4 case 2: - v3 := args[0] + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + tmp4 := checkDerefVar(var_glojure_DOT_core_cons) + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + return tmp5 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] _ = v4 - var tmp5 lang.FnFunc - tmp5 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp6 := lang.Apply(v3, nil) - return tmp6 - case 1: - v6 := args[0] - _ = v6 - tmp7 := lang.Apply(v4, []any{v6}) - return tmp7 - case 2: - v6 := args[0] - _ = v6 - v7 := args[1] - _ = v7 - tmp8 := lang.Apply(v3, []any{v6, v7}) - return tmp8 - default: - checkArity(args, -1) - panic("unreachable") - } - }) - tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6900), kw_column, int(6), kw_end_DASH_line, int(6903), kw_end_DASH_column, int(23)) - tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp7 + tmp5 := checkDerefVar(var_glojure_DOT_core_cons) + tmp6 := checkDerefVar(var_glojure_DOT_core_cons) + tmp7 := lang.Apply(tmp6, []any{v3, v4}) + tmp8 := lang.Apply(tmp5, []any{v2, tmp7}) + return tmp8 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_cons) + tmp7 := checkDerefVar(var_glojure_DOT_core_cons) + tmp8 := checkDerefVar(var_glojure_DOT_core_cons) + tmp9 := lang.Apply(tmp8, []any{v4, v5}) + tmp10 := lang.Apply(tmp7, []any{v3, tmp9}) + tmp11 := lang.Apply(tmp6, []any{v2, tmp10}) + return tmp11 default: - checkArity(args, -1) - panic("unreachable") + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var v6 any = lang.NewList(args[4:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_cons) + tmp8 := checkDerefVar(var_glojure_DOT_core_cons) + tmp9 := checkDerefVar(var_glojure_DOT_core_cons) + tmp10 := checkDerefVar(var_glojure_DOT_core_cons) + tmp11 := checkDerefVar(var_glojure_DOT_core_spread) + tmp12 := lang.Apply(tmp11, []any{v6}) + tmp13 := lang.Apply(tmp10, []any{v5, tmp12}) + tmp14 := lang.Apply(tmp9, []any{v4, tmp13}) + tmp15 := lang.Apply(tmp8, []any{v3, tmp14}) + tmp16 := lang.Apply(tmp7, []any{v2, tmp15}) + return tmp16 } }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_list_STAR_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_list_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // loaded-libs + { + tmp0 := sym_loaded_DASH_libs.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Returns a sorted set of symbols naming the currently loaded libs", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(6090), kw_end_DASH_line, int(6090))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp2 := checkDerefVar(var_glojure_DOT_core_deref) + tmp3 := checkDerefVar(var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_) + tmp4 := lang.Apply(tmp2, []any{tmp3}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_loaded_DASH_libs = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_loaded_DASH_libs.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // long + { + var tmp1 lang.FnFunc + { // function long__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_LongCast}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_long.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to long", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3481), kw_end_DASH_line, int(3481))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.LongCast, []any{v3}) + return tmp4 + }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core_long = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_long.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // concat + // long-array { - tmp0 := sym_concat.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_zs)), kw_doc, "Returns a lazy seq representing the concatenation of the elements in the supplied colls.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(711), kw_end_DASH_line, int(711))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function long-array__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_LongArray}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_unquote_DASH_splicing}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_glojure_DOT_core_SLASH_args}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + } + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_long_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_size_DASH_or_DASH_seq), lang.NewVector(sym_size, sym_init_DASH_val_DASH_or_DASH_seq)), kw_inline, tmp1, kw_doc, "Creates an array of longs", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(5364), kw_end_DASH_line, int(5364))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 0: - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - return nil - }) - tmp4 := lang.Apply(lang.NewLazySeq, []any{tmp3}) - return tmp4 case 1: v3 := args[0] _ = v3 - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - return v3 - }) - tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "LongArray") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("LongArray is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - var tmp5 lang.FnFunc - tmp5 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - var tmp6 any - { // let - // let binding "s" - tmp7 := checkDerefVar(var_glojure_DOT_core_seq) - tmp8 := lang.Apply(tmp7, []any{v3}) - var v9 any = tmp8 - _ = v9 - var tmp10 any - if lang.IsTruthy(v9) { - var tmp11 any - tmp12 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) - tmp13 := lang.Apply(tmp12, []any{v9}) - if lang.IsTruthy(tmp13) { - tmp14 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_cons) - tmp15 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) - tmp16 := lang.Apply(tmp15, []any{v9}) - tmp17 := checkDerefVar(var_glojure_DOT_core_concat) - tmp18 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) - tmp19 := lang.Apply(tmp18, []any{v9}) - tmp20 := lang.Apply(tmp17, []any{tmp19, v4}) - tmp21 := lang.Apply(tmp14, []any{tmp16, tmp20}) - tmp11 = tmp21 - } else { - tmp22 := checkDerefVar(var_glojure_DOT_core_cons) - tmp23 := checkDerefVar(var_glojure_DOT_core_first) - tmp24 := lang.Apply(tmp23, []any{v9}) - tmp25 := checkDerefVar(var_glojure_DOT_core_concat) - tmp26 := checkDerefVar(var_glojure_DOT_core_rest) - tmp27 := lang.Apply(tmp26, []any{v9}) - tmp28 := lang.Apply(tmp25, []any{tmp27, v4}) - tmp29 := lang.Apply(tmp22, []any{tmp24, tmp28}) - tmp11 = tmp29 - } - tmp10 = tmp11 - } else { - tmp10 = v4 - } - tmp6 = tmp10 - } // end let - return tmp6 - }) - tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "LongArrayInit") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("LongArrayInit is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 default: - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - var tmp6 any - { // let - // let binding "cat" - var tmp7 lang.FnFunc - { // function cat - var v8 lang.FnFunc - tmp7 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v9 := args[0] - _ = v9 - v10 := args[1] - _ = v10 - var tmp11 lang.FnFunc - tmp11 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - var tmp12 any - { // let - // let binding "xys" - tmp13 := checkDerefVar(var_glojure_DOT_core_seq) - tmp14 := lang.Apply(tmp13, []any{v9}) - var v15 any = tmp14 - _ = v15 - var tmp16 any - if lang.IsTruthy(v15) { - var tmp17 any - tmp18 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) - tmp19 := lang.Apply(tmp18, []any{v15}) - if lang.IsTruthy(tmp19) { - tmp20 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_cons) - tmp21 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) - tmp22 := lang.Apply(tmp21, []any{v15}) - tmp23 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) - tmp24 := lang.Apply(tmp23, []any{v15}) - tmp25 := lang.Apply(v8, []any{tmp24, v10}) - tmp26 := lang.Apply(tmp20, []any{tmp22, tmp25}) - tmp17 = tmp26 - } else { - tmp27 := checkDerefVar(var_glojure_DOT_core_cons) - tmp28 := checkDerefVar(var_glojure_DOT_core_first) - tmp29 := lang.Apply(tmp28, []any{v15}) - tmp30 := checkDerefVar(var_glojure_DOT_core_rest) - tmp31 := lang.Apply(tmp30, []any{v15}) - tmp32 := lang.Apply(v8, []any{tmp31, v10}) - tmp33 := lang.Apply(tmp27, []any{tmp29, tmp32}) - tmp17 = tmp33 - } - tmp16 = tmp17 - } else { - var tmp34 any - if lang.IsTruthy(v10) { - tmp35 := checkDerefVar(var_glojure_DOT_core_first) - tmp36 := lang.Apply(tmp35, []any{v10}) - tmp37 := checkDerefVar(var_glojure_DOT_core_next) - tmp38 := lang.Apply(tmp37, []any{v10}) - tmp39 := lang.Apply(v8, []any{tmp36, tmp38}) - tmp34 = tmp39 - } else { - } - tmp16 = tmp34 - } - tmp12 = tmp16 - } // end let - return tmp12 - }) - tmp12 := lang.Apply(lang.NewLazySeq, []any{tmp11}) - return tmp12 - }) - v8 = tmp7 - _ = v8 - } - tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(726), kw_column, int(16), kw_end_DASH_line, int(735), kw_end_DASH_column, int(56)) - tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v10 any = tmp9 - _ = v10 - tmp11 := checkDerefVar(var_glojure_DOT_core_concat) - tmp12 := lang.Apply(tmp11, []any{v3, v4}) - tmp13 := lang.Apply(v10, []any{tmp12, v5}) - tmp6 = tmp13 - } // end let - return tmp6 + checkArity(args, -1) + panic("unreachable") } }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core_long_DASH_array = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_long_DASH_array.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // cond + // longs { - tmp0 := sym_cond.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_clauses)), kw_doc, "Takes a set of test/expr pairs. It evaluates each test one at a\n time. If a test returns logical true, cond evaluates and returns\n the value of the corresponding expr and doesn't evaluate any of the\n other tests or exprs. (cond) returns nil.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(11), kw_line, int(569), kw_end_DASH_line, int(569))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 2) + var tmp1 lang.FnFunc + { // function longs + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) v3 := args[0] _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - var tmp6 any - if lang.IsTruthy(v5) { - tmp7 := checkDerefVar(var_glojure_DOT_core_list) - tmp8 := checkDerefVar(var_glojure_DOT_core_first) - tmp9 := lang.Apply(tmp8, []any{v5}) - var tmp10 any - tmp11 := checkDerefVar(var_glojure_DOT_core_next) - tmp12 := lang.Apply(tmp11, []any{v5}) - if lang.IsTruthy(tmp12) { - tmp13 := checkDerefVar(var_glojure_DOT_core_second) - tmp14 := lang.Apply(tmp13, []any{v5}) - tmp10 = tmp14 - } else { - tmp15 := lang.Apply(lang.NewIllegalArgumentError, []any{"cond requires an even number of forms"}) - panic(tmp15) - } - tmp16 := checkDerefVar(var_glojure_DOT_core_cons) - tmp17 := checkDerefVar(var_glojure_DOT_core_next) - tmp18 := checkDerefVar(var_glojure_DOT_core_next) - tmp19 := lang.Apply(tmp18, []any{v5}) - tmp20 := lang.Apply(tmp17, []any{tmp19}) - tmp21 := lang.Apply(tmp16, []any{sym_glojure_DOT_core_SLASH_cond, tmp20}) - tmp22 := lang.Apply(tmp7, []any{sym_if, tmp9, tmp10, tmp21}) - tmp6 = tmp22 - } else { - } - return tmp6 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Longs}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_longs.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xs)), kw_inline, tmp1, kw_doc, "Casts to long[]", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(12), kw_line, int(5407), kw_end_DASH_line, int(5407))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Longs") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Longs is not a function"))) } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core_longs = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_longs.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // cond-> + // macroexpand { - tmp0 := sym_cond_DASH__GT_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_expr, sym__AMP_, sym_clauses)), kw_doc, "Takes an expression and a set of test/form pairs. Threads expr (via ->)\n through each form for which the corresponding test\n expression is true. Note that, unlike cond branching, cond-> threading does\n not short circuit after the first true test expression.", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(11), kw_line, int(7564), kw_end_DASH_line, int(7564))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 3) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) + tmp0 := sym_macroexpand.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_form)), kw_doc, "Repeatedly calls macroexpand-1 on form until it no longer\n represents a macro form, then returns it. Note neither\n macroexpand-1 nor macroexpand expand macros in subforms.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(4025), kw_end_DASH_line, int(4025))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "ex" + tmp4 := checkDerefVar(var_glojure_DOT_core_macroexpand_DASH_1) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 _ = v6 var tmp7 any - { // let - // let binding "g" - tmp8 := checkDerefVar(var_glojure_DOT_core_gensym) - tmp9 := lang.Apply(tmp8, nil) - var v10 any = tmp9 - _ = v10 - // let binding "steps" - tmp11 := checkDerefVar(var_glojure_DOT_core_map) - var tmp12 lang.FnFunc - tmp12 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v13 := args[0] - _ = v13 - var tmp14 any - { // let - // let binding "vec__349" - var v15 any = v13 - _ = v15 - // let binding "test" - tmp16 := checkDerefVar(var_glojure_DOT_core_nth) - tmp17 := lang.Apply(tmp16, []any{v15, int64(0), nil}) - var v18 any = tmp17 - _ = v18 - // let binding "step" - tmp19 := checkDerefVar(var_glojure_DOT_core_nth) - tmp20 := lang.Apply(tmp19, []any{v15, int64(1), nil}) - var v21 any = tmp20 - _ = v21 - tmp22 := checkDerefVar(var_glojure_DOT_core_seq) - tmp23 := checkDerefVar(var_glojure_DOT_core_concat) - tmp24 := checkDerefVar(var_glojure_DOT_core_list) - tmp25 := lang.Apply(tmp24, []any{sym_if}) - tmp26 := checkDerefVar(var_glojure_DOT_core_list) - tmp27 := lang.Apply(tmp26, []any{v18}) - tmp28 := checkDerefVar(var_glojure_DOT_core_list) - tmp29 := checkDerefVar(var_glojure_DOT_core_seq) - tmp30 := checkDerefVar(var_glojure_DOT_core_concat) - tmp31 := checkDerefVar(var_glojure_DOT_core_list) - tmp32 := lang.Apply(tmp31, []any{sym_glojure_DOT_core_SLASH__DASH__GT_}) - tmp33 := checkDerefVar(var_glojure_DOT_core_list) - tmp34 := lang.Apply(tmp33, []any{v10}) - tmp35 := checkDerefVar(var_glojure_DOT_core_list) - tmp36 := lang.Apply(tmp35, []any{v21}) - tmp37 := lang.Apply(tmp30, []any{tmp32, tmp34, tmp36}) - tmp38 := lang.Apply(tmp29, []any{tmp37}) - tmp39 := lang.Apply(tmp28, []any{tmp38}) - tmp40 := checkDerefVar(var_glojure_DOT_core_list) - tmp41 := lang.Apply(tmp40, []any{v10}) - tmp42 := lang.Apply(tmp23, []any{tmp25, tmp27, tmp39, tmp41}) - tmp43 := lang.Apply(tmp22, []any{tmp42}) - tmp14 = tmp43 - } // end let - return tmp14 - }) - tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7573), kw_column, int(20), kw_end_DASH_line, int(7573), kw_end_DASH_column, int(66)) - tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp15 := checkDerefVar(var_glojure_DOT_core_partition) - tmp16 := lang.Apply(tmp15, []any{int64(2), v6}) - tmp17 := lang.Apply(tmp11, []any{tmp14, tmp16}) - var v18 any = tmp17 - _ = v18 - tmp19 := checkDerefVar(var_glojure_DOT_core_seq) - tmp20 := checkDerefVar(var_glojure_DOT_core_concat) - tmp21 := checkDerefVar(var_glojure_DOT_core_list) - tmp22 := lang.Apply(tmp21, []any{sym_glojure_DOT_core_SLASH_let}) - tmp23 := checkDerefVar(var_glojure_DOT_core_list) - tmp24 := checkDerefVar(var_glojure_DOT_core_apply) - tmp25 := checkDerefVar(var_glojure_DOT_core_vector) - tmp26 := checkDerefVar(var_glojure_DOT_core_seq) - tmp27 := checkDerefVar(var_glojure_DOT_core_concat) - tmp28 := checkDerefVar(var_glojure_DOT_core_list) - tmp29 := lang.Apply(tmp28, []any{v10}) - tmp30 := checkDerefVar(var_glojure_DOT_core_list) - tmp31 := lang.Apply(tmp30, []any{v5}) - tmp32 := checkDerefVar(var_glojure_DOT_core_interleave) - tmp33 := checkDerefVar(var_glojure_DOT_core_repeat) - tmp34 := lang.Apply(tmp33, []any{v10}) - tmp35 := checkDerefVar(var_glojure_DOT_core_butlast) - tmp36 := lang.Apply(tmp35, []any{v18}) - tmp37 := lang.Apply(tmp32, []any{tmp34, tmp36}) - tmp38 := lang.Apply(tmp27, []any{tmp29, tmp31, tmp37}) - tmp39 := lang.Apply(tmp26, []any{tmp38}) - tmp40 := lang.Apply(tmp24, []any{tmp25, tmp39}) - tmp41 := lang.Apply(tmp23, []any{tmp40}) - tmp42 := checkDerefVar(var_glojure_DOT_core_list) - var tmp43 any - tmp44 := checkDerefVar(var_glojure_DOT_core_empty_QMARK_) - tmp45 := lang.Apply(tmp44, []any{v18}) - if lang.IsTruthy(tmp45) { - tmp43 = v10 - } else { - tmp46 := checkDerefVar(var_glojure_DOT_core_last) - tmp47 := lang.Apply(tmp46, []any{v18}) - tmp43 = tmp47 - } - tmp48 := lang.Apply(tmp42, []any{tmp43}) - tmp49 := lang.Apply(tmp20, []any{tmp22, tmp41, tmp48}) - tmp50 := lang.Apply(tmp19, []any{tmp49}) - tmp7 = tmp50 - } // end let - return tmp7 - } + tmp8 := checkDerefVar(var_glojure_DOT_core_identical_QMARK_) + tmp9 := lang.Apply(tmp8, []any{v6, v2}) + if lang.IsTruthy(tmp9) { + tmp7 = v2 + } else { + tmp10 := checkDerefVar(var_glojure_DOT_core_macroexpand) + tmp11 := lang.Apply(tmp10, []any{v6}) + tmp7 = tmp11 + } + tmp3 = tmp7 + } // end let + return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_macroexpand = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_macroexpand.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // cond->> + // map-indexed { - tmp0 := sym_cond_DASH__GT__GT_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_expr, sym__AMP_, sym_clauses)), kw_doc, "Takes an expression and a set of test/form pairs. Threads expr (via ->>)\n through each form for which the corresponding test expression\n is true. Note that, unlike cond branching, cond->> threading does not short circuit\n after the first true test expression.", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(7581), kw_end_DASH_line, int(7581))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_map_DASH_indexed.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_coll)), kw_doc, "Returns a lazy sequence consisting of the result of applying f to 0\n and the first item of coll, followed by applying f to 1 and the second\n item in coll, etc, until coll is exhausted. Thus function f should\n accept 2 arguments, index and item. Returns a stateful transducer when\n no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(7309), kw_end_DASH_line, int(7309))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - default: - checkArity(args, 3) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any - { // let - // let binding "g" - tmp8 := checkDerefVar(var_glojure_DOT_core_gensym) - tmp9 := lang.Apply(tmp8, nil) - var v10 any = tmp9 - _ = v10 - // let binding "steps" - tmp11 := checkDerefVar(var_glojure_DOT_core_map) - var tmp12 lang.FnFunc - tmp12 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v13 := args[0] - _ = v13 - var tmp14 any - { // let - // let binding "vec__353" - var v15 any = v13 - _ = v15 - // let binding "test" - tmp16 := checkDerefVar(var_glojure_DOT_core_nth) - tmp17 := lang.Apply(tmp16, []any{v15, int64(0), nil}) - var v18 any = tmp17 - _ = v18 - // let binding "step" - tmp19 := checkDerefVar(var_glojure_DOT_core_nth) - tmp20 := lang.Apply(tmp19, []any{v15, int64(1), nil}) - var v21 any = tmp20 - _ = v21 - tmp22 := checkDerefVar(var_glojure_DOT_core_seq) - tmp23 := checkDerefVar(var_glojure_DOT_core_concat) - tmp24 := checkDerefVar(var_glojure_DOT_core_list) - tmp25 := lang.Apply(tmp24, []any{sym_if}) - tmp26 := checkDerefVar(var_glojure_DOT_core_list) - tmp27 := lang.Apply(tmp26, []any{v18}) - tmp28 := checkDerefVar(var_glojure_DOT_core_list) - tmp29 := checkDerefVar(var_glojure_DOT_core_seq) - tmp30 := checkDerefVar(var_glojure_DOT_core_concat) - tmp31 := checkDerefVar(var_glojure_DOT_core_list) - tmp32 := lang.Apply(tmp31, []any{sym_glojure_DOT_core_SLASH__DASH__GT__GT_}) - tmp33 := checkDerefVar(var_glojure_DOT_core_list) - tmp34 := lang.Apply(tmp33, []any{v10}) - tmp35 := checkDerefVar(var_glojure_DOT_core_list) - tmp36 := lang.Apply(tmp35, []any{v21}) - tmp37 := lang.Apply(tmp30, []any{tmp32, tmp34, tmp36}) - tmp38 := lang.Apply(tmp29, []any{tmp37}) - tmp39 := lang.Apply(tmp28, []any{tmp38}) - tmp40 := checkDerefVar(var_glojure_DOT_core_list) - tmp41 := lang.Apply(tmp40, []any{v10}) - tmp42 := lang.Apply(tmp23, []any{tmp25, tmp27, tmp39, tmp41}) - tmp43 := lang.Apply(tmp22, []any{tmp42}) - tmp14 = tmp43 - } // end let - return tmp14 - }) - tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7590), kw_column, int(20), kw_end_DASH_line, int(7590), kw_end_DASH_column, int(67)) - tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp15 := checkDerefVar(var_glojure_DOT_core_partition) - tmp16 := lang.Apply(tmp15, []any{int64(2), v6}) - tmp17 := lang.Apply(tmp11, []any{tmp14, tmp16}) - var v18 any = tmp17 - _ = v18 - tmp19 := checkDerefVar(var_glojure_DOT_core_seq) - tmp20 := checkDerefVar(var_glojure_DOT_core_concat) - tmp21 := checkDerefVar(var_glojure_DOT_core_list) - tmp22 := lang.Apply(tmp21, []any{sym_glojure_DOT_core_SLASH_let}) - tmp23 := checkDerefVar(var_glojure_DOT_core_list) - tmp24 := checkDerefVar(var_glojure_DOT_core_apply) - tmp25 := checkDerefVar(var_glojure_DOT_core_vector) - tmp26 := checkDerefVar(var_glojure_DOT_core_seq) - tmp27 := checkDerefVar(var_glojure_DOT_core_concat) - tmp28 := checkDerefVar(var_glojure_DOT_core_list) - tmp29 := lang.Apply(tmp28, []any{v10}) - tmp30 := checkDerefVar(var_glojure_DOT_core_list) - tmp31 := lang.Apply(tmp30, []any{v5}) - tmp32 := checkDerefVar(var_glojure_DOT_core_interleave) - tmp33 := checkDerefVar(var_glojure_DOT_core_repeat) - tmp34 := lang.Apply(tmp33, []any{v10}) - tmp35 := checkDerefVar(var_glojure_DOT_core_butlast) - tmp36 := lang.Apply(tmp35, []any{v18}) - tmp37 := lang.Apply(tmp32, []any{tmp34, tmp36}) - tmp38 := lang.Apply(tmp27, []any{tmp29, tmp31, tmp37}) - tmp39 := lang.Apply(tmp26, []any{tmp38}) - tmp40 := lang.Apply(tmp24, []any{tmp25, tmp39}) - tmp41 := lang.Apply(tmp23, []any{tmp40}) - tmp42 := checkDerefVar(var_glojure_DOT_core_list) - var tmp43 any - tmp44 := checkDerefVar(var_glojure_DOT_core_empty_QMARK_) - tmp45 := lang.Apply(tmp44, []any{v18}) - if lang.IsTruthy(tmp45) { - tmp43 = v10 - } else { - tmp46 := checkDerefVar(var_glojure_DOT_core_last) - tmp47 := lang.Apply(tmp46, []any{v18}) - tmp43 = tmp47 - } - tmp48 := lang.Apply(tmp42, []any{tmp43}) - tmp49 := lang.Apply(tmp20, []any{tmp22, tmp41, tmp48}) - tmp50 := lang.Apply(tmp19, []any{tmp49}) - tmp7 = tmp50 - } // end let - return tmp7 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // condp - { - tmp0 := sym_condp.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_pred, sym_expr, sym__AMP_, sym_clauses)), kw_doc, "Takes a binary predicate, an expression, and a set of clauses.\n Each clause can take the form of either:\n\n test-expr result-expr\n\n test-expr :>> result-fn\n\n Note :>> is an ordinary keyword.\n\n For each clause, (pred test-expr expr) is evaluated. If it returns\n logical true, the clause is a match. If a binary clause matches, the\n result-expr is returned, if a ternary clause matches, its result-fn,\n which must be a unary function, is called with the result of the\n predicate as its argument, the result of that call being the return\n value of condp. A single default expression can follow the clauses,\n and its value will be returned if no clause matches. If no default\n expression is provided and no clause matches, an\n IllegalArgumentException is thrown.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(11), kw_line, int(6353), kw_end_DASH_line, int(6353))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 4) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - var v7 any = lang.NewList(args[4:]...) - _ = v7 - var tmp8 any - { // let - // let binding "gpred" - tmp9 := checkDerefVar(var_glojure_DOT_core_gensym) - tmp10 := lang.Apply(tmp9, []any{"pred__"}) - var v11 any = tmp10 - _ = v11 - // let binding "gexpr" - tmp12 := checkDerefVar(var_glojure_DOT_core_gensym) - tmp13 := lang.Apply(tmp12, []any{"expr__"}) - var v14 any = tmp13 - _ = v14 - // let binding "emit" - var tmp15 lang.FnFunc - { // function emit - var v16 lang.FnFunc - tmp15 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 3) - v17 := args[0] - _ = v17 - v18 := args[1] - _ = v18 - v19 := args[2] - _ = v19 - var tmp20 any - { // let - // let binding "vec__144" - tmp21 := checkDerefVar(var_glojure_DOT_core_split_DASH_at) - var tmp22 any - tmp23 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp24 := checkDerefVar(var_glojure_DOT_core_second) - tmp25 := lang.Apply(tmp24, []any{v19}) - tmp26 := lang.Apply(tmp23, []any{kw__GT__GT_, tmp25}) - if lang.IsTruthy(tmp26) { - tmp22 = int64(3) - } else { - tmp22 = int64(2) + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 any + { // let + // let binding "i" + tmp6 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) + tmp7 := lang.Apply(tmp6, []any{int64(-1)}) + var v8 any = tmp7 + _ = v8 + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp10 := lang.Apply(v4, nil) + return tmp10 + case 1: + v10 := args[0] + _ = v10 + tmp11 := lang.Apply(v4, []any{v10}) + return tmp11 + case 2: + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_inc) + tmp13, ok := lang.FieldOrMethod(v8, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "Deref"))) } - tmp27 := lang.Apply(tmp21, []any{tmp22, v19}) - var v28 any = tmp27 - _ = v28 - // let binding "vec__147" - tmp29 := checkDerefVar(var_glojure_DOT_core_nth) - tmp30 := lang.Apply(tmp29, []any{v28, int64(0), nil}) - var v31 any = tmp30 - _ = v31 - // let binding "a" - tmp32 := checkDerefVar(var_glojure_DOT_core_nth) - tmp33 := lang.Apply(tmp32, []any{v31, int64(0), nil}) - var v34 any = tmp33 - _ = v34 - // let binding "b" - tmp35 := checkDerefVar(var_glojure_DOT_core_nth) - tmp36 := lang.Apply(tmp35, []any{v31, int64(1), nil}) - var v37 any = tmp36 - _ = v37 - // let binding "c" - tmp38 := checkDerefVar(var_glojure_DOT_core_nth) - tmp39 := lang.Apply(tmp38, []any{v31, int64(2), nil}) - var v40 any = tmp39 - _ = v40 - // let binding "clause" - var v41 any = v31 - _ = v41 - // let binding "more" - tmp42 := checkDerefVar(var_glojure_DOT_core_nth) - tmp43 := lang.Apply(tmp42, []any{v28, int64(1), nil}) - var v44 any = tmp43 - _ = v44 - // let binding "n" - tmp45 := checkDerefVar(var_glojure_DOT_core_count) - tmp46 := lang.Apply(tmp45, []any{v41}) - var v47 any = tmp46 - _ = v47 - var tmp48 any - tmp49 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp50 := lang.Apply(tmp49, []any{int64(0), v47}) - if lang.IsTruthy(tmp50) { - tmp51 := checkDerefVar(var_glojure_DOT_core_seq) - tmp52 := checkDerefVar(var_glojure_DOT_core_concat) - tmp53 := checkDerefVar(var_glojure_DOT_core_list) - tmp54 := lang.Apply(tmp53, []any{sym_throw}) - tmp55 := checkDerefVar(var_glojure_DOT_core_list) - tmp56 := checkDerefVar(var_glojure_DOT_core_seq) - tmp57 := checkDerefVar(var_glojure_DOT_core_concat) - tmp58 := checkDerefVar(var_glojure_DOT_core_list) - tmp59 := lang.Apply(tmp58, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_NewIllegalArgumentError}) - tmp60 := checkDerefVar(var_glojure_DOT_core_list) - tmp61 := checkDerefVar(var_glojure_DOT_core_seq) - tmp62 := checkDerefVar(var_glojure_DOT_core_concat) - tmp63 := checkDerefVar(var_glojure_DOT_core_list) - tmp64 := lang.Apply(tmp63, []any{sym_glojure_DOT_core_SLASH_str}) - tmp65 := checkDerefVar(var_glojure_DOT_core_list) - tmp66 := lang.Apply(tmp65, []any{"No matching clause: "}) - tmp67 := checkDerefVar(var_glojure_DOT_core_list) - tmp68 := lang.Apply(tmp67, []any{v18}) - tmp69 := lang.Apply(tmp62, []any{tmp64, tmp66, tmp68}) - tmp70 := lang.Apply(tmp61, []any{tmp69}) - tmp71 := lang.Apply(tmp60, []any{tmp70}) - tmp72 := lang.Apply(tmp57, []any{tmp59, tmp71}) - tmp73 := lang.Apply(tmp56, []any{tmp72}) - tmp74 := lang.Apply(tmp55, []any{tmp73}) - tmp75 := lang.Apply(tmp52, []any{tmp54, tmp74}) - tmp76 := lang.Apply(tmp51, []any{tmp75}) - tmp48 = tmp76 - } else { - var tmp77 any - tmp78 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp79 := lang.Apply(tmp78, []any{int64(1), v47}) - if lang.IsTruthy(tmp79) { - tmp77 = v34 - } else { - var tmp80 any - tmp81 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp82 := lang.Apply(tmp81, []any{int64(2), v47}) - if lang.IsTruthy(tmp82) { - tmp83 := checkDerefVar(var_glojure_DOT_core_seq) - tmp84 := checkDerefVar(var_glojure_DOT_core_concat) - tmp85 := checkDerefVar(var_glojure_DOT_core_list) - tmp86 := lang.Apply(tmp85, []any{sym_if}) - tmp87 := checkDerefVar(var_glojure_DOT_core_list) - tmp88 := checkDerefVar(var_glojure_DOT_core_seq) - tmp89 := checkDerefVar(var_glojure_DOT_core_concat) - tmp90 := checkDerefVar(var_glojure_DOT_core_list) - tmp91 := lang.Apply(tmp90, []any{v17}) - tmp92 := checkDerefVar(var_glojure_DOT_core_list) - tmp93 := lang.Apply(tmp92, []any{v34}) - tmp94 := checkDerefVar(var_glojure_DOT_core_list) - tmp95 := lang.Apply(tmp94, []any{v18}) - tmp96 := lang.Apply(tmp89, []any{tmp91, tmp93, tmp95}) - tmp97 := lang.Apply(tmp88, []any{tmp96}) - tmp98 := lang.Apply(tmp87, []any{tmp97}) - tmp99 := checkDerefVar(var_glojure_DOT_core_list) - tmp100 := lang.Apply(tmp99, []any{v37}) - tmp101 := checkDerefVar(var_glojure_DOT_core_list) - tmp102 := lang.Apply(v16, []any{v17, v18, v44}) - tmp103 := lang.Apply(tmp101, []any{tmp102}) - tmp104 := lang.Apply(tmp84, []any{tmp86, tmp98, tmp100, tmp103}) - tmp105 := lang.Apply(tmp83, []any{tmp104}) - tmp80 = tmp105 - } else { - var tmp106 any - if lang.IsTruthy(kw_else) { - tmp107 := checkDerefVar(var_glojure_DOT_core_seq) - tmp108 := checkDerefVar(var_glojure_DOT_core_concat) - tmp109 := checkDerefVar(var_glojure_DOT_core_list) - tmp110 := lang.Apply(tmp109, []any{sym_glojure_DOT_core_SLASH_if_DASH_let}) - tmp111 := checkDerefVar(var_glojure_DOT_core_list) - tmp112 := checkDerefVar(var_glojure_DOT_core_apply) - tmp113 := checkDerefVar(var_glojure_DOT_core_vector) - tmp114 := checkDerefVar(var_glojure_DOT_core_seq) - tmp115 := checkDerefVar(var_glojure_DOT_core_concat) - tmp116 := checkDerefVar(var_glojure_DOT_core_list) - tmp117 := lang.Apply(tmp116, []any{sym_p__0__auto__}) - tmp118 := checkDerefVar(var_glojure_DOT_core_list) - tmp119 := checkDerefVar(var_glojure_DOT_core_seq) - tmp120 := checkDerefVar(var_glojure_DOT_core_concat) - tmp121 := checkDerefVar(var_glojure_DOT_core_list) - tmp122 := lang.Apply(tmp121, []any{v17}) - tmp123 := checkDerefVar(var_glojure_DOT_core_list) - tmp124 := lang.Apply(tmp123, []any{v34}) - tmp125 := checkDerefVar(var_glojure_DOT_core_list) - tmp126 := lang.Apply(tmp125, []any{v18}) - tmp127 := lang.Apply(tmp120, []any{tmp122, tmp124, tmp126}) - tmp128 := lang.Apply(tmp119, []any{tmp127}) - tmp129 := lang.Apply(tmp118, []any{tmp128}) - tmp130 := lang.Apply(tmp115, []any{tmp117, tmp129}) - tmp131 := lang.Apply(tmp114, []any{tmp130}) - tmp132 := lang.Apply(tmp112, []any{tmp113, tmp131}) - tmp133 := lang.Apply(tmp111, []any{tmp132}) - tmp134 := checkDerefVar(var_glojure_DOT_core_list) - tmp135 := checkDerefVar(var_glojure_DOT_core_seq) - tmp136 := checkDerefVar(var_glojure_DOT_core_concat) - tmp137 := checkDerefVar(var_glojure_DOT_core_list) - tmp138 := lang.Apply(tmp137, []any{v40}) - tmp139 := checkDerefVar(var_glojure_DOT_core_list) - tmp140 := lang.Apply(tmp139, []any{sym_p__0__auto__}) - tmp141 := lang.Apply(tmp136, []any{tmp138, tmp140}) - tmp142 := lang.Apply(tmp135, []any{tmp141}) - tmp143 := lang.Apply(tmp134, []any{tmp142}) - tmp144 := checkDerefVar(var_glojure_DOT_core_list) - tmp145 := lang.Apply(v16, []any{v17, v18, v44}) - tmp146 := lang.Apply(tmp144, []any{tmp145}) - tmp147 := lang.Apply(tmp108, []any{tmp110, tmp133, tmp143, tmp146}) - tmp148 := lang.Apply(tmp107, []any{tmp147}) - tmp106 = tmp148 - } else { - } - tmp80 = tmp106 - } - tmp77 = tmp80 - } - tmp48 = tmp77 + var tmp14 any + switch reflect.TypeOf(tmp13).Kind() { + case reflect.Func: + tmp14 = lang.Apply(tmp13, nil) + default: + tmp14 = tmp13 } - tmp20 = tmp48 - } // end let - return tmp20 + tmp15 := lang.Apply(tmp12, []any{tmp14}) + tmp16, _ := lang.FieldOrMethod(v8, "reset") + if reflect.TypeOf(tmp16).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) + } + tmp17 := lang.Apply(tmp16, []any{tmp15}) + tmp18 := lang.Apply(v2, []any{tmp17, v11}) + tmp19 := lang.Apply(v4, []any{v10, tmp18}) + return tmp19 + default: + checkArity(args, -1) + panic("unreachable") + } }) - v16 = tmp15 - _ = v16 - } - tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6377), kw_column, int(14), kw_end_DASH_line, int(6389), kw_end_DASH_column, int(53)) - tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v18 any = tmp17 - _ = v18 - tmp19 := checkDerefVar(var_glojure_DOT_core_seq) - tmp20 := checkDerefVar(var_glojure_DOT_core_concat) - tmp21 := checkDerefVar(var_glojure_DOT_core_list) - tmp22 := lang.Apply(tmp21, []any{sym_glojure_DOT_core_SLASH_let}) - tmp23 := checkDerefVar(var_glojure_DOT_core_list) - tmp24 := checkDerefVar(var_glojure_DOT_core_apply) - tmp25 := checkDerefVar(var_glojure_DOT_core_vector) - tmp26 := checkDerefVar(var_glojure_DOT_core_seq) - tmp27 := checkDerefVar(var_glojure_DOT_core_concat) - tmp28 := checkDerefVar(var_glojure_DOT_core_list) - tmp29 := lang.Apply(tmp28, []any{v11}) - tmp30 := checkDerefVar(var_glojure_DOT_core_list) - tmp31 := lang.Apply(tmp30, []any{v5}) - tmp32 := checkDerefVar(var_glojure_DOT_core_list) - tmp33 := lang.Apply(tmp32, []any{v14}) - tmp34 := checkDerefVar(var_glojure_DOT_core_list) - tmp35 := lang.Apply(tmp34, []any{v6}) - tmp36 := lang.Apply(tmp27, []any{tmp29, tmp31, tmp33, tmp35}) - tmp37 := lang.Apply(tmp26, []any{tmp36}) - tmp38 := lang.Apply(tmp24, []any{tmp25, tmp37}) - tmp39 := lang.Apply(tmp23, []any{tmp38}) - tmp40 := checkDerefVar(var_glojure_DOT_core_list) - tmp41 := lang.Apply(v18, []any{v11, v14, v7}) - tmp42 := lang.Apply(tmp40, []any{tmp41}) - tmp43 := lang.Apply(tmp20, []any{tmp22, tmp39, tmp42}) - tmp44 := lang.Apply(tmp19, []any{tmp43}) - tmp8 = tmp44 - } // end let - return tmp8 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // conj - { - tmp0 := sym_conj.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_coll), lang.NewVector(sym_coll, sym_x), lang.NewVector(sym_coll, sym_x, sym__AMP_, sym_xs)), kw_doc, "conj[oin]. Returns a new collection with the xs\n 'added'. (conj nil item) returns (item).\n (conj coll) returns coll. (conj) returns [].\n The 'addition' may happen at different 'places' depending\n on the concrete type.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(5), kw_column, int(2), kw_line, int(73), kw_end_DASH_line, int(81))).(*lang.Symbol) - var tmp2 lang.FnFunc - { // function conj - var v3 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp4 := lang.NewVector() - tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(82), kw_column, int(13), kw_end_DASH_line, int(82), kw_end_DASH_column, int(14)) - tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp6 - case 1: - v4 := args[0] - _ = v4 - return v4 - case 2: - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6 := lang.Apply(lang.Conj, []any{v4, v5}) - return tmp6 - default: - checkArity(args, 2) - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - var v6 any = lang.NewList(args[2:]...) - _ = v6 - recur_loop_10: - var tmp7 any - if lang.IsTruthy(v6) { - tmp9 := lang.Apply(lang.Conj, []any{v4, v5}) - var tmp8 any = tmp9 - tmp11 := checkDerefVar(var_glojure_DOT_core_first) - tmp12 := lang.Apply(tmp11, []any{v6}) - var tmp10 any = tmp12 - tmp14 := checkDerefVar(var_glojure_DOT_core_next) - tmp15 := lang.Apply(tmp14, []any{v6}) - var tmp13 any = tmp15 - v4 = tmp8 - v5 = tmp10 - v6 = tmp13 - goto recur_loop_10 - } else { - tmp16 := lang.Apply(lang.Conj, []any{v4, v5}) - tmp7 = tmp16 - } - return tmp7 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(81), kw_column, int(7), kw_end_DASH_line, int(88), kw_end_DASH_column, int(67))).(lang.FnFunc) - v3 = tmp2 - _ = v3 - } - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // conj! - { - tmp0 := sym_conj_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_coll), lang.NewVector(sym_coll, sym_x)), kw_doc, "Adds x to the transient collection, and return coll. The 'addition'\n may happen at different 'places' depending on the concrete type.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3359), kw_end_DASH_line, int(3359))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp3 := checkDerefVar(var_glojure_DOT_core_transient) - tmp4 := lang.NewVector() - tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3364), kw_column, int(18), kw_end_DASH_line, int(3364), kw_end_DASH_column, int(19)) - tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7320), kw_column, int(8), kw_end_DASH_line, int(7324), kw_end_DASH_column, int(48)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp5 = tmp11 + } // end let + return tmp5 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7318), kw_column, int(4), kw_end_DASH_line, int(7324), kw_end_DASH_column, int(50)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp7 := lang.Apply(tmp3, []any{tmp6}) - return tmp7 - case 1: - v3 := args[0] - _ = v3 - return v3 + return tmp5 case 2: - v3 := args[0] + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] - _ = v4 - tmp5, _ := lang.FieldOrMethod(v3, "Conj") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Conj is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 + return nil default: checkArity(args, -1) panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_map_DASH_indexed = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_map_DASH_indexed.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // cons - { - tmp0 := sym_cons.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_seq)), kw_doc, "Returns a new seq where x is the first element and seq is\n the rest.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(5), kw_column, int(2), kw_line, int(21), kw_end_DASH_line, int(27))).(*lang.Symbol) - var tmp2 lang.FnFunc - { // function cons - var v3 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6 := lang.Apply(lang.NewCons, []any{v4, v5}) - return tmp6 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(27), kw_column, int(7), kw_end_DASH_line, int(27), kw_end_DASH_column, int(89))).(lang.FnFunc) - v3 = tmp2 - _ = v3 - } - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // constantly + // maybe-destructured { - tmp0 := sym_constantly.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns a function that takes any number of arguments and returns x.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(1440), kw_end_DASH_line, int(1440))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] + tmp0 := sym_maybe_DASH_destructured.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(4514), kw_column, int(7), kw_end_DASH_line, int(4515), kw_end_DASH_column, int(20), kw_arglists, lang.NewList(lang.NewVector(sym_params, sym_body)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 0) - var v5 any = lang.NewList(args[0:]...) - _ = v5 - return v3 - } - }) - tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(1444), kw_column, int(7), kw_end_DASH_line, int(1444), kw_end_DASH_column, int(21)) - tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) - if err != nil { - panic(err) + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + tmp6 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp7 := lang.Apply(tmp5, []any{tmp6, v2}) + if lang.IsTruthy(tmp7) { + tmp8 := checkDerefVar(var_glojure_DOT_core_cons) + tmp9 := lang.Apply(tmp8, []any{v2, v3}) + tmp4 = tmp9 + } else { + var tmp10 any + { // let + // let binding "params" + var v11 any = v2 + _ = v11 + // let binding "new-params" + tmp12 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp13 := lang.NewVector() + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4520), kw_column, int(34), kw_end_DASH_line, int(4520), kw_end_DASH_column, int(35)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp16 := checkDerefVar(var_glojure_DOT_core_meta) + tmp17 := lang.Apply(tmp16, []any{v11}) + tmp18 := lang.Apply(tmp12, []any{tmp15, tmp17}) + var v19 any = tmp18 + _ = v19 + // let binding "lets" + tmp20 := lang.NewVector() + tmp21 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4521), kw_column, int(17), kw_end_DASH_line, int(4521), kw_end_DASH_column, int(18)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v23 any = tmp22 + _ = v23 + for { + var tmp24 any + if lang.IsTruthy(v11) { + var tmp25 any + tmp26 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp27 := checkDerefVar(var_glojure_DOT_core_first) + tmp28 := lang.Apply(tmp27, []any{v11}) + tmp29 := lang.Apply(tmp26, []any{tmp28}) + if lang.IsTruthy(tmp29) { + tmp31 := checkDerefVar(var_glojure_DOT_core_next) + tmp32 := lang.Apply(tmp31, []any{v11}) + var tmp30 any = tmp32 + tmp34 := checkDerefVar(var_glojure_DOT_core_conj) + tmp35 := checkDerefVar(var_glojure_DOT_core_first) + tmp36 := lang.Apply(tmp35, []any{v11}) + tmp37 := lang.Apply(tmp34, []any{v19, tmp36}) + var tmp33 any = tmp37 + var tmp38 any = v23 + v11 = tmp30 + v19 = tmp33 + v23 = tmp38 + continue + } else { + var tmp39 any + { // let + // let binding "gparam" + tmp40 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp41 := lang.Apply(tmp40, []any{"p__"}) + var v42 any = tmp41 + _ = v42 + tmp44 := checkDerefVar(var_glojure_DOT_core_next) + tmp45 := lang.Apply(tmp44, []any{v11}) + var tmp43 any = tmp45 + tmp47 := checkDerefVar(var_glojure_DOT_core_conj) + tmp48 := lang.Apply(tmp47, []any{v19, v42}) + var tmp46 any = tmp48 + tmp50 := checkDerefVar(var_glojure_DOT_core_conj) + tmp51 := checkDerefVar(var_glojure_DOT_core_conj) + tmp52 := checkDerefVar(var_glojure_DOT_core_first) + tmp53 := lang.Apply(tmp52, []any{v11}) + tmp54 := lang.Apply(tmp51, []any{v23, tmp53}) + tmp55 := lang.Apply(tmp50, []any{tmp54, v42}) + var tmp49 any = tmp55 + v11 = tmp43 + v19 = tmp46 + v23 = tmp49 + continue + } // end let + tmp25 = tmp39 + } + tmp24 = tmp25 + } else { + tmp40 := checkDerefVar(var_glojure_DOT_core_seq) + tmp41 := checkDerefVar(var_glojure_DOT_core_concat) + tmp42 := checkDerefVar(var_glojure_DOT_core_list) + tmp43 := lang.Apply(tmp42, []any{v19}) + tmp44 := checkDerefVar(var_glojure_DOT_core_list) + tmp45 := checkDerefVar(var_glojure_DOT_core_seq) + tmp46 := checkDerefVar(var_glojure_DOT_core_concat) + tmp47 := checkDerefVar(var_glojure_DOT_core_list) + tmp48 := lang.Apply(tmp47, []any{sym_glojure_DOT_core_SLASH_let}) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) + tmp50 := lang.Apply(tmp49, []any{v23}) + tmp51 := lang.Apply(tmp46, []any{tmp48, tmp50, v3}) + tmp52 := lang.Apply(tmp45, []any{tmp51}) + tmp53 := lang.Apply(tmp44, []any{tmp52}) + tmp54 := lang.Apply(tmp41, []any{tmp43, tmp53}) + tmp55 := lang.Apply(tmp40, []any{tmp54}) + tmp24 = tmp55 + } + tmp10 = tmp24 + break + } + } // end let + tmp4 = tmp10 } - return tmp6 + return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_maybe_DASH_destructured = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_maybe_DASH_destructured.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // contains? + // name { - tmp0 := sym_contains_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll, sym_key)), kw_doc, "Returns true if key is present in the given collection, otherwise\n returns false. Note that for numerically indexed collections like\n vectors and Java arrays, this tests if the numeric key is within the\n range of indexes. 'contains?' operates constant or logarithmic time;\n it will not perform a linear search for a value. See also 'some'.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(1479), kw_end_DASH_line, int(1479))).(*lang.Symbol) + tmp1 := reflect.TypeOf("") + tmp0 := sym_name.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns the name String of a string, symbol or keyword.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1585), kw_end_DASH_line, int(1585))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) + checkArity(args, 1) v3 := args[0] _ = v3 - v4 := args[1] - _ = v4 - tmp5, _ := lang.FieldOrMethod(runtime.RT, "Contains") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Contains is not a function"))) + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + tmp4 = v3 + } else { + tmp7, _ := lang.FieldOrMethod(v3, "Name") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Name is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{}) + tmp4 = tmp8 } - tmp6 := lang.Apply(tmp5, []any{v3, v4}) - return tmp6 + return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp3 := reflect.TypeOf("") + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_name = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_name.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // count + // neg? { var tmp1 lang.FnFunc - { // function count__inliner + { // function neg?__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) @@ -15012,12 +12389,12 @@ func LoadNS() { tmp6 := checkDerefVar(var_glojure_DOT_core_list) tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Count}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_IsNeg}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -15030,142 +12407,393 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := sym_count.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_inline, tmp1, kw_doc, "Returns the number of items in the collection. (count nil) returns\n 0. Also works on strings, arrays, and Java Collections and Maps", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(867), kw_end_DASH_line, int(867))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5 := lang.Apply(lang.Count, []any{v4}) - return tmp5 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // counted? - { - tmp0 := sym_counted_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns true if coll implements count in constant time", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(6241), kw_end_DASH_line, int(6241))).(*lang.Symbol) + tmp0 := sym_neg_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_num)), kw_inline, tmp1, kw_doc, "Returns true if num is less than zero, else false", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1259), kw_end_DASH_line, int(1259))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp5 := reflect.TypeOf((*lang.Counted)(nil)).Elem() - tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) - return tmp6 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "IsNeg") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("IsNeg is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core_neg_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_neg_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // create-ns + // not-empty { - tmp0 := sym_create_DASH_ns.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_sym)), kw_doc, "Create a new namespace named by the symbol if one doesn't already\n exist, returns it or the already-existing namespace of the same\n name.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(4131), kw_end_DASH_line, int(4131))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_not_DASH_empty.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "If coll is empty, returns nil, else coll", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(5516), kw_end_DASH_line, int(5516))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := lang.Apply(nil, []any{v3}) - return tmp4 + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + tmp3 = v2 + } else { + } + return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_not_DASH_empty = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_not_DASH_empty.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // create-struct + // ns-aliases { - tmp0 := sym_create_DASH_struct.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_keys)), kw_doc, "Returns a structure basis object.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(4037), kw_end_DASH_line, int(4037))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { + tmp0 := sym_ns_DASH_aliases.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns)), kw_doc, "Returns a map of the aliases for the namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4273), kw_end_DASH_line, int(4273))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) + tmp4 := lang.Apply(tmp3, []any{v2}) + tmp5, ok := lang.FieldOrMethod(tmp4, "getAliases") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp4, "getAliases"))) + } + var tmp6 any + switch reflect.TypeOf(tmp5).Kind() { + case reflect.Func: + tmp6 = lang.Apply(tmp5, nil) default: - checkArity(args, 0) - var v3 any = lang.NewList(args[0:]...) - _ = v3 - tmp4 := lang.Apply(lang.CreatePersistentStructMapSlotMap, []any{v3}) - return tmp4 + tmp6 = tmp5 } + return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ns_DASH_aliases = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_ns_DASH_aliases.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // cycle + // ns-map { - tmp0 := sym_cycle.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a lazy (infinite!) sequence of repetitions of the items in coll.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(2977), kw_end_DASH_line, int(2977))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_ns_DASH_map.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns)), kw_doc, "Returns a map of all the mappings for the namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(4170), kw_end_DASH_line, int(4170))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_seq) - tmp5 := lang.Apply(tmp4, []any{v3}) - tmp6 := lang.Apply(lang.NewCycle, []any{tmp5}) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) + tmp4 := lang.Apply(tmp3, []any{v2}) + tmp5, ok := lang.FieldOrMethod(tmp4, "Mappings") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp4, "Mappings"))) + } + var tmp6 any + switch reflect.TypeOf(tmp5).Kind() { + case reflect.Func: + tmp6 = lang.Apply(tmp5, nil) + default: + tmp6 = tmp5 + } return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ns_DASH_map = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_ns_DASH_map.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // data-reader-urls + // ns-name { - tmp0 := sym_data_DASH_reader_DASH_urls.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7830), kw_column, int(8), kw_end_DASH_line, int(7830), kw_end_DASH_column, int(23), kw_private, true, kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + tmp0 := sym_ns_DASH_name.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns)), kw_doc, "Returns the name of the namespace, a symbol.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4163), kw_end_DASH_line, int(4163))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) + tmp4 := lang.Apply(tmp3, []any{v2}) + tmp5, ok := lang.FieldOrMethod(tmp4, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp4, "Name"))) + } + var tmp6 any + switch reflect.TypeOf(tmp5).Kind() { + case reflect.Func: + tmp6 = lang.Apply(tmp5, nil) + default: + tmp6 = tmp5 + } + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ns_DASH_name = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ns_DASH_name.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ns-resolve + { + tmp0 := sym_ns_DASH_resolve.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns, sym_sym), lang.NewVector(sym_ns, sym_env, sym_sym)), kw_doc, "Returns the var or Class to which a symbol will be resolved in the\n namespace (unless found in the environment), else nil. Note that\n if the symbol is fully qualified, the var/Class to which it resolves\n need not be present in the namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4358), kw_end_DASH_line, int(4358))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_ns_DASH_resolve) + tmp5 := lang.Apply(tmp4, []any{v2, nil, v3}) + return tmp5 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp7 := lang.Apply(tmp6, []any{v3, v4}) + if lang.IsTruthy(tmp7) { + } else { + tmp8 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) + tmp9 := lang.Apply(tmp8, []any{v2}) + tmp10, _ := lang.FieldOrMethod(runtime.Compiler, "maybeResolveIn") + if reflect.TypeOf(tmp10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("maybeResolveIn is not a function"))) + } + tmp11 := lang.Apply(tmp10, []any{tmp9, v4}) + tmp5 = tmp11 + } + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ns_DASH_resolve = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ns_DASH_resolve.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ns-unalias + { + tmp0 := sym_ns_DASH_unalias.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns, sym_sym)), kw_doc, "Removes the alias for the symbol from the namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4280), kw_end_DASH_line, int(4280))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) + tmp5 := lang.Apply(tmp4, []any{v2}) + tmp6, _ := lang.FieldOrMethod(tmp5, "removeAlias") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("removeAlias is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v3}) + return tmp7 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ns_DASH_unalias = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ns_DASH_unalias.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ns-unmap + { + tmp0 := sym_ns_DASH_unmap.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns, sym_sym)), kw_doc, "Removes the mappings for the symbol from the namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(4177), kw_end_DASH_line, int(4177))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) + tmp5 := lang.Apply(tmp4, []any{v2}) + tmp6, _ := lang.FieldOrMethod(tmp5, "unmap") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unmap is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v3}) + return tmp7 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ns_DASH_unmap = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ns_DASH_unmap.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // nth + { + var tmp1 lang.FnFunc + { // function nth__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym__DOT_}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_Nth}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{sym_glojure_DOT_core_SLASH_unquote}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{sym_glojure_DOT_core_SLASH_c}) + tmp24 := lang.Apply(tmp19, []any{tmp21, tmp23}) + tmp25 := lang.Apply(tmp18, []any{tmp24}) + tmp26 := lang.Apply(tmp17, []any{tmp25}) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := checkDerefVar(var_glojure_DOT_core_seq) + tmp29 := checkDerefVar(var_glojure_DOT_core_concat) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := lang.Apply(tmp30, []any{sym_glojure_DOT_core_SLASH_unquote}) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := lang.Apply(tmp32, []any{sym_glojure_DOT_core_SLASH_i}) + tmp34 := lang.Apply(tmp29, []any{tmp31, tmp33}) + tmp35 := lang.Apply(tmp28, []any{tmp34}) + tmp36 := lang.Apply(tmp27, []any{tmp35}) + tmp37 := checkDerefVar(var_glojure_DOT_core_list) + tmp38 := checkDerefVar(var_glojure_DOT_core_seq) + tmp39 := checkDerefVar(var_glojure_DOT_core_concat) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{sym_glojure_DOT_core_SLASH_unquote_DASH_splicing}) + tmp42 := checkDerefVar(var_glojure_DOT_core_list) + tmp43 := lang.Apply(tmp42, []any{sym_glojure_DOT_core_SLASH_nf}) + tmp44 := lang.Apply(tmp39, []any{tmp41, tmp43}) + tmp45 := lang.Apply(tmp38, []any{tmp44}) + tmp46 := lang.Apply(tmp37, []any{tmp45}) + tmp47 := lang.Apply(tmp14, []any{tmp16, tmp26, tmp36, tmp46}) + tmp48 := lang.Apply(tmp13, []any{tmp47}) + tmp49 := lang.Apply(tmp12, []any{tmp48}) + tmp50 := lang.Apply(tmp7, []any{tmp9, tmp11, tmp49}) + tmp51 := lang.Apply(tmp6, []any{tmp50}) + return tmp51 + } + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_nth.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll, sym_index), lang.NewVector(sym_coll, sym_index, sym_not_DASH_found)), kw_inline, tmp1, kw_doc, "Returns the value at the index. get returns nil if index out of\n bounds, nth throws an exception unless not-found is supplied. nth\n also works for strings, Java arrays, regex Matchers and Lists, and,\n in O(n) time, for sequences.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2), int64(3)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(882), kw_end_DASH_line, int(882))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - return lang.NewList() + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(runtime.RT, "Nth") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Nth is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6, _ := lang.FieldOrMethod(runtime.RT, "NthDefault") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("NthDefault is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v3, v4, v5}) + return tmp7 + default: + checkArity(args, -1) + panic("unreachable") + } }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core_nth = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_nth.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // data-reader-var + // num { - tmp0 := sym_data_DASH_reader_DASH_var.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7832), kw_column, int(8), kw_end_DASH_line, int(7832), kw_end_DASH_column, int(22), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_sym)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function num__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Num}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_num.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to Number", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(3474), kw_end_DASH_line, int(3474))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_intern) - tmp5 := checkDerefVar(var_glojure_DOT_core_create_DASH_ns) - tmp6 := checkDerefVar(var_glojure_DOT_core_symbol) - tmp7 := checkDerefVar(var_glojure_DOT_core_namespace) - tmp8 := lang.Apply(tmp7, []any{v3}) - tmp9 := lang.Apply(tmp6, []any{tmp8}) - tmp10 := lang.Apply(tmp5, []any{tmp9}) - tmp11 := checkDerefVar(var_glojure_DOT_core_symbol) - tmp12 := checkDerefVar(var_glojure_DOT_core_name) - tmp13 := lang.Apply(tmp12, []any{v3}) - tmp14 := lang.Apply(tmp11, []any{tmp13}) - tmp15 := lang.Apply(tmp4, []any{tmp10, tmp14}) - return tmp15 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Num") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Num is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core_num = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_num.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // dec + // object-array { var tmp1 lang.FnFunc - { // function dec__inliner + { // function object-array__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) @@ -15176,54 +12804,199 @@ func LoadNS() { tmp6 := checkDerefVar(var_glojure_DOT_core_list) tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := checkDerefVar(var_glojure_DOT_core_seq) - tmp12 := checkDerefVar(var_glojure_DOT_core_concat) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - var tmp14 any - tmp15 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) - if lang.IsTruthy(tmp15) { - tmp14 = sym_unchecked_dec - } else { - tmp14 = sym_dec - } - tmp16 := lang.Apply(tmp13, []any{tmp14}) - tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{v3}) - tmp19 := lang.Apply(tmp12, []any{tmp16, tmp18}) - tmp20 := lang.Apply(tmp11, []any{tmp19}) - tmp21 := lang.Apply(tmp10, []any{tmp20}) - tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp21}) - tmp23 := lang.Apply(tmp4, []any{tmp22}) - return tmp23 + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Object_array}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 }) v2 = tmp1 _ = v2 } - tmp0 := sym_dec.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns a number one less than num. Does not auto-promote\n longs, will throw on overflow. See also: dec'", kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(1147), kw_end_DASH_line, int(1147))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_object_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_size_DASH_or_DASH_seq)), kw_inline, tmp1, kw_doc, "Creates an array of objects", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1)})), kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(5349), kw_end_DASH_line, int(5349))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Dec") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Dec is not a function"))) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(runtime.RT, "Object_array") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Object_array is not a function"))) } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_object_DASH_array = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_object_DASH_array.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // dec' + // parse-impls { + tmp0 := sym_parse_DASH_impls.WithMeta(lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(13), kw_column, int(8), kw_end_DASH_line, int(13), kw_end_DASH_column, int(18), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_specs)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp1 lang.FnFunc - { // function dec'__inliner + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "ret" + tmp4 := lang.NewMap() + tmp5 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(14), kw_column, int(14), kw_end_DASH_line, int(14), kw_end_DASH_column, int(15)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v7 any = tmp6 + _ = v7 + // let binding "s" + var v8 any = v2 + _ = v8 + for { + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_seq) + tmp11 := lang.Apply(tmp10, []any{v8}) + if lang.IsTruthy(tmp11) { + tmp13 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp14 := checkDerefVar(var_glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v8}) + tmp16 := checkDerefVar(var_glojure_DOT_core_take_DASH_while) + tmp17 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp18 := checkDerefVar(var_glojure_DOT_core_next) + tmp19 := lang.Apply(tmp18, []any{v8}) + tmp20 := lang.Apply(tmp16, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp13, []any{v7, tmp15, tmp20}) + var tmp12 any = tmp21 + tmp23 := checkDerefVar(var_glojure_DOT_core_drop_DASH_while) + tmp24 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp25 := checkDerefVar(var_glojure_DOT_core_next) + tmp26 := lang.Apply(tmp25, []any{v8}) + tmp27 := lang.Apply(tmp23, []any{tmp24, tmp26}) + var tmp22 any = tmp27 + v7 = tmp12 + v8 = tmp22 + continue + } else { + tmp9 = v7 + } + tmp3 = tmp9 + break + } + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_parse_DASH_impls = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_parse_DASH_impls.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // parse-uuid + { + tmp0 := sym_parse_DASH_uuid.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_doc, "Parse a string representing a UUID and return a java.util.UUID instance,\n or nil if parse fails.\n\n Grammar: https://docs.oracle.com/javase/8/docs/api/java/util/UUID.html#toString--", kw_file, "glojure/core.glj", kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(7946), kw_end_DASH_line, int(7946))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + func() { + defer func() { + if r := recover(); r != nil { + tmp4 := reflect.TypeOf((*lang.IllegalArgumentError)(nil)) + if lang.CatchMatches(r, tmp4) { + v5 := r + _ = v5 + } else { + panic(r) + } + } + }() + var tmp5 any + { // let + // let binding "vec__362" + tmp6 := lang.Apply(uuid13.Parse, []any{v2}) + var v7 any = tmp6 + _ = v7 + // let binding "uuid" + tmp8 := checkDerefVar(var_glojure_DOT_core_nth) + tmp9 := lang.Apply(tmp8, []any{v7, int64(0), nil}) + var v10 any = tmp9 + _ = v10 + // let binding "err" + tmp11 := checkDerefVar(var_glojure_DOT_core_nth) + tmp12 := lang.Apply(tmp11, []any{v7, int64(1), nil}) + var v13 any = tmp12 + _ = v13 + var tmp14 any + if lang.IsTruthy(v13) { + tmp15 := checkDerefVar(var_glojure_DOT_core_str) + tmp16 := lang.Apply(tmp15, []any{"Error parsing UUID: ", v13}) + tmp17 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp16}) + panic(tmp17) + } else { + tmp14 = v10 + } + tmp5 = tmp14 + } // end let + tmp3 = tmp5 + }() + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_parse_DASH_uuid = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_parse_DASH_uuid.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // parsing-err + { + tmp0 := sym_parsing_DASH_err.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_val)), kw_doc, "Construct message for parsing for non-string parsing error", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(8), kw_line, int(7921), kw_end_DASH_line, int(7921), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_str) + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v2}) + if lang.IsTruthy(tmp6) { + tmp4 = "nil" + } else { + tmp7 := checkDerefVar(var_glojure_DOT_core_class) + tmp8 := lang.Apply(tmp7, []any{v2}) + tmp9, ok := lang.FieldOrMethod(tmp8, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp8, "Name"))) + } + var tmp10 any + switch reflect.TypeOf(tmp9).Kind() { + case reflect.Func: + tmp10 = lang.Apply(tmp9, nil) + default: + tmp10 = tmp9 + } + tmp4 = tmp10 + } + tmp11 := lang.Apply(tmp3, []any{"Expected string, got ", tmp4}) + return tmp11 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_parsing_DASH_err = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_parsing_DASH_err.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // pos? + { + var tmp1 lang.FnFunc + { // function pos?__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) @@ -15239,7 +13012,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_DecP}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_IsPos}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -15252,2239 +13025,1057 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := sym_dec_TICK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns a number one less than num. Supports arbitrary precision.\n See also: dec", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1140), kw_end_DASH_line, int(1140))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_pos_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_num)), kw_inline, tmp1, kw_doc, "Returns true if num is greater than zero, else false", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1252), kw_end_DASH_line, int(1252))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "DecP") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("DecP is not a function"))) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "IsPos") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("IsPos is not a function"))) } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_pos_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_pos_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // decimal? + // prependss { - tmp0 := sym_decimal_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_doc, "Returns true if n is a BigDecimal", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(3599), kw_end_DASH_line, int(3599))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] + tmp0 := sym_prependss.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_coll)), kw_doc, "Prepends a symbol or a seq to coll", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(8), kw_line, int(5857), kw_end_DASH_line, int(5857), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp5 := reflect.TypeOf((*lang.BigDecimal)(nil)) - tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) - return tmp6 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v2}) + if lang.IsTruthy(tmp6) { + tmp7 := checkDerefVar(var_glojure_DOT_core_cons) + tmp8 := lang.Apply(tmp7, []any{v2, v3}) + tmp4 = tmp8 + } else { + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := lang.Apply(tmp9, []any{v2, v3}) + tmp4 = tmp10 + } + return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_prependss = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_prependss.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // declare + // print-ctor { - tmp0 := sym_declare.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_names)), kw_doc, "defs the supplied var names with no bindings, useful for making forward declarations.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(2768), kw_end_DASH_line, int(2768))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { + tmp0 := sym_print_DASH_ctor.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(95), kw_column, int(7), kw_end_DASH_line, int(95), kw_end_DASH_column, int(16), kw_arglists, lang.NewList(lang.NewVector(sym_o, sym_print_DASH_args, sym_w)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := lang.Apply(lang.WriteWriter, []any{v4, "#=("}) + _ = tmp5 + tmp6 := checkDerefVar(var_glojure_DOT_core_class) + tmp7 := lang.Apply(tmp6, []any{v2}) + tmp8, ok := lang.FieldOrMethod(tmp7, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp7, "Name"))) + } + var tmp9 any + switch reflect.TypeOf(tmp8).Kind() { + case reflect.Func: + tmp9 = lang.Apply(tmp8, nil) default: - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - tmp6 := checkDerefVar(var_glojure_DOT_core_seq) - tmp7 := checkDerefVar(var_glojure_DOT_core_concat) - tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{sym_do}) - tmp10 := checkDerefVar(var_glojure_DOT_core_map) - var tmp11 lang.FnFunc - tmp11 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v12 := args[0] - _ = v12 - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := checkDerefVar(var_glojure_DOT_core_vary_DASH_meta) - tmp15 := checkDerefVar(var_glojure_DOT_core_assoc) - tmp16 := lang.Apply(tmp14, []any{v12, tmp15, kw_declared, true}) - tmp17 := lang.Apply(tmp13, []any{sym_def, tmp16}) - return tmp17 - }) - tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2771), kw_column, int(25), kw_end_DASH_line, int(2771), kw_end_DASH_column, int(71)) - tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp14 := lang.Apply(tmp10, []any{tmp13, v5}) - tmp15 := lang.Apply(tmp7, []any{tmp9, tmp14}) - tmp16 := lang.Apply(tmp6, []any{tmp15}) - return tmp16 + tmp9 = tmp8 } + tmp10 := lang.Apply(lang.WriteWriter, []any{v4, tmp9}) + _ = tmp10 + tmp11 := lang.Apply(lang.WriteWriter, []any{v4, ". "}) + _ = tmp11 + tmp12 := lang.Apply(v3, []any{v2, v4}) + _ = tmp12 + tmp13 := lang.Apply(lang.WriteWriter, []any{v4, ")"}) + return tmp13 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_print_DASH_ctor = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_print_DASH_ctor.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // dedupe + // quot { - tmp0 := sym_dedupe.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_coll)), kw_doc, "Returns a lazy sequence removing consecutive duplicates in coll.\n Returns a transducer when no collection is provided.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(7681), kw_end_DASH_line, int(7681))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - var tmp5 any - { // let - // let binding "pv" - tmp6 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) - tmp7 := lang.Apply(tmp6, []any{kw_glojure_DOT_core_SLASH_none}) - var v8 any = tmp7 - _ = v8 - var tmp9 lang.FnFunc - tmp9 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp10 := lang.Apply(v4, nil) - return tmp10 - case 1: - v10 := args[0] - _ = v10 - tmp11 := lang.Apply(v4, []any{v10}) - return tmp11 - case 2: - v10 := args[0] - _ = v10 - v11 := args[1] - _ = v11 - var tmp12 any - { // let - // let binding "prior" - tmp13 := checkDerefVar(var_glojure_DOT_core_deref) - tmp14 := lang.Apply(tmp13, []any{v8}) - var v15 any = tmp14 - _ = v15 - tmp16 := checkDerefVar(var_glojure_DOT_core_vreset_BANG_) - tmp17 := lang.Apply(tmp16, []any{v8, v11}) - _ = tmp17 - var tmp18 any - tmp19 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp20 := lang.Apply(tmp19, []any{v15, v11}) - if lang.IsTruthy(tmp20) { - tmp18 = v10 - } else { - tmp21 := lang.Apply(v4, []any{v10, v11}) - tmp18 = tmp21 - } - tmp12 = tmp18 - } // end let - return tmp12 - default: - checkArity(args, -1) - panic("unreachable") - } - }) - tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7688), kw_column, int(8), kw_end_DASH_line, int(7696), kw_end_DASH_column, int(37)) - tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp5 = tmp11 - } // end let - return tmp5 - }) - tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7686), kw_column, int(4), kw_end_DASH_line, int(7696), kw_end_DASH_column, int(39)) - tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp5 - case 1: + var tmp1 lang.FnFunc + { // function quot__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_sequence) - tmp5 := checkDerefVar(var_glojure_DOT_core_dedupe) - tmp6 := lang.Apply(tmp5, nil) - tmp7 := lang.Apply(tmp4, []any{tmp6, v3}) - return tmp7 - default: - checkArity(args, -1) - panic("unreachable") - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Quotient}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 } - } - // def-aset - { - tmp0 := sym_def_DASH_aset.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym_method, sym_coerce)), kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(3), kw_line, int(3935), kw_end_DASH_line, int(3936), kw_private, true)).(*lang.Symbol) + tmp0 := sym_quot.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_num, sym_div)), kw_inline, tmp1, kw_doc, "quot[ient] of dividing numerator by denominator.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1266), kw_end_DASH_line, int(1266))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 5) + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - v7 := args[4] - _ = v7 - tmp8 := checkDerefVar(var_glojure_DOT_core_seq) - tmp9 := checkDerefVar(var_glojure_DOT_core_concat) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_defn}) - tmp12 := checkDerefVar(var_glojure_DOT_core_list) - tmp13 := lang.Apply(tmp12, []any{v5}) - tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := checkDerefVar(var_glojure_DOT_core_apply) - tmp16 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) - tmp17 := checkDerefVar(var_glojure_DOT_core_seq) - tmp18 := checkDerefVar(var_glojure_DOT_core_concat) - tmp19 := checkDerefVar(var_glojure_DOT_core_list) - tmp20 := lang.Apply(tmp19, []any{kw_arglists}) - tmp21 := checkDerefVar(var_glojure_DOT_core_list) - tmp22 := checkDerefVar(var_glojure_DOT_core_seq) - tmp23 := checkDerefVar(var_glojure_DOT_core_concat) - tmp24 := checkDerefVar(var_glojure_DOT_core_list) - tmp25 := lang.Apply(tmp24, []any{sym_quote}) - tmp26 := checkDerefVar(var_glojure_DOT_core_list) - tmp27 := checkDerefVar(var_glojure_DOT_core_seq) - tmp28 := checkDerefVar(var_glojure_DOT_core_concat) - tmp29 := checkDerefVar(var_glojure_DOT_core_list) - tmp30 := checkDerefVar(var_glojure_DOT_core_apply) - tmp31 := checkDerefVar(var_glojure_DOT_core_vector) - tmp32 := checkDerefVar(var_glojure_DOT_core_seq) - tmp33 := checkDerefVar(var_glojure_DOT_core_concat) - tmp34 := checkDerefVar(var_glojure_DOT_core_list) - tmp35 := lang.Apply(tmp34, []any{sym_array}) - tmp36 := checkDerefVar(var_glojure_DOT_core_list) - tmp37 := lang.Apply(tmp36, []any{sym_idx}) - tmp38 := checkDerefVar(var_glojure_DOT_core_list) - tmp39 := lang.Apply(tmp38, []any{sym_val}) - tmp40 := lang.Apply(tmp33, []any{tmp35, tmp37, tmp39}) - tmp41 := lang.Apply(tmp32, []any{tmp40}) - tmp42 := lang.Apply(tmp30, []any{tmp31, tmp41}) - tmp43 := lang.Apply(tmp29, []any{tmp42}) - tmp44 := checkDerefVar(var_glojure_DOT_core_list) - tmp45 := checkDerefVar(var_glojure_DOT_core_apply) - tmp46 := checkDerefVar(var_glojure_DOT_core_vector) - tmp47 := checkDerefVar(var_glojure_DOT_core_seq) - tmp48 := checkDerefVar(var_glojure_DOT_core_concat) - tmp49 := checkDerefVar(var_glojure_DOT_core_list) - tmp50 := lang.Apply(tmp49, []any{sym_array}) - tmp51 := checkDerefVar(var_glojure_DOT_core_list) - tmp52 := lang.Apply(tmp51, []any{sym_idx}) - tmp53 := checkDerefVar(var_glojure_DOT_core_list) - tmp54 := lang.Apply(tmp53, []any{sym_idx2}) - tmp55 := checkDerefVar(var_glojure_DOT_core_list) - tmp56 := lang.Apply(tmp55, []any{sym__AMP_}) - tmp57 := checkDerefVar(var_glojure_DOT_core_list) - tmp58 := lang.Apply(tmp57, []any{sym_idxv}) - tmp59 := lang.Apply(tmp48, []any{tmp50, tmp52, tmp54, tmp56, tmp58}) - tmp60 := lang.Apply(tmp47, []any{tmp59}) - tmp61 := lang.Apply(tmp45, []any{tmp46, tmp60}) - tmp62 := lang.Apply(tmp44, []any{tmp61}) - tmp63 := lang.Apply(tmp28, []any{tmp43, tmp62}) - tmp64 := lang.Apply(tmp27, []any{tmp63}) - tmp65 := lang.Apply(tmp26, []any{tmp64}) - tmp66 := lang.Apply(tmp23, []any{tmp25, tmp65}) - tmp67 := lang.Apply(tmp22, []any{tmp66}) - tmp68 := lang.Apply(tmp21, []any{tmp67}) - tmp69 := lang.Apply(tmp18, []any{tmp20, tmp68}) - tmp70 := lang.Apply(tmp17, []any{tmp69}) - tmp71 := lang.Apply(tmp15, []any{tmp16, tmp70}) - tmp72 := lang.Apply(tmp14, []any{tmp71}) - tmp73 := checkDerefVar(var_glojure_DOT_core_list) - tmp74 := checkDerefVar(var_glojure_DOT_core_seq) - tmp75 := checkDerefVar(var_glojure_DOT_core_concat) - tmp76 := checkDerefVar(var_glojure_DOT_core_list) - tmp77 := checkDerefVar(var_glojure_DOT_core_apply) - tmp78 := checkDerefVar(var_glojure_DOT_core_vector) - tmp79 := checkDerefVar(var_glojure_DOT_core_seq) - tmp80 := checkDerefVar(var_glojure_DOT_core_concat) - tmp81 := checkDerefVar(var_glojure_DOT_core_list) - tmp82 := lang.Apply(tmp81, []any{sym_array__0__auto__}) - tmp83 := checkDerefVar(var_glojure_DOT_core_list) - tmp84 := lang.Apply(tmp83, []any{sym_idx__1__auto__}) - tmp85 := checkDerefVar(var_glojure_DOT_core_list) - tmp86 := lang.Apply(tmp85, []any{sym_val__2__auto__}) - tmp87 := lang.Apply(tmp80, []any{tmp82, tmp84, tmp86}) - tmp88 := lang.Apply(tmp79, []any{tmp87}) - tmp89 := lang.Apply(tmp77, []any{tmp78, tmp88}) - tmp90 := lang.Apply(tmp76, []any{tmp89}) - tmp91 := checkDerefVar(var_glojure_DOT_core_list) - tmp92 := checkDerefVar(var_glojure_DOT_core_seq) - tmp93 := checkDerefVar(var_glojure_DOT_core_concat) - tmp94 := checkDerefVar(var_glojure_DOT_core_list) - tmp95 := lang.Apply(tmp94, []any{sym__DOT_}) - tmp96 := checkDerefVar(var_glojure_DOT_core_list) - tmp97 := lang.Apply(tmp96, []any{sym_glojure_DOT_core_SLASH_Array}) - tmp98 := checkDerefVar(var_glojure_DOT_core_list) - tmp99 := checkDerefVar(var_glojure_DOT_core_seq) - tmp100 := checkDerefVar(var_glojure_DOT_core_concat) - tmp101 := checkDerefVar(var_glojure_DOT_core_list) - tmp102 := lang.Apply(tmp101, []any{v6}) - tmp103 := checkDerefVar(var_glojure_DOT_core_list) - tmp104 := lang.Apply(tmp103, []any{sym_array__0__auto__}) - tmp105 := checkDerefVar(var_glojure_DOT_core_list) - tmp106 := lang.Apply(tmp105, []any{sym_idx__1__auto__}) - tmp107 := checkDerefVar(var_glojure_DOT_core_list) - tmp108 := checkDerefVar(var_glojure_DOT_core_seq) - tmp109 := checkDerefVar(var_glojure_DOT_core_concat) - tmp110 := checkDerefVar(var_glojure_DOT_core_list) - tmp111 := lang.Apply(tmp110, []any{v7}) - tmp112 := checkDerefVar(var_glojure_DOT_core_list) - tmp113 := lang.Apply(tmp112, []any{sym_val__2__auto__}) - tmp114 := lang.Apply(tmp109, []any{tmp111, tmp113}) - tmp115 := lang.Apply(tmp108, []any{tmp114}) - tmp116 := lang.Apply(tmp107, []any{tmp115}) - tmp117 := lang.Apply(tmp100, []any{tmp102, tmp104, tmp106, tmp116}) - tmp118 := lang.Apply(tmp99, []any{tmp117}) - tmp119 := lang.Apply(tmp98, []any{tmp118}) - tmp120 := lang.Apply(tmp93, []any{tmp95, tmp97, tmp119}) - tmp121 := lang.Apply(tmp92, []any{tmp120}) - tmp122 := lang.Apply(tmp91, []any{tmp121}) - tmp123 := checkDerefVar(var_glojure_DOT_core_list) - tmp124 := lang.Apply(tmp123, []any{sym_val__2__auto__}) - tmp125 := lang.Apply(tmp75, []any{tmp90, tmp122, tmp124}) - tmp126 := lang.Apply(tmp74, []any{tmp125}) - tmp127 := lang.Apply(tmp73, []any{tmp126}) - tmp128 := checkDerefVar(var_glojure_DOT_core_list) - tmp129 := checkDerefVar(var_glojure_DOT_core_seq) - tmp130 := checkDerefVar(var_glojure_DOT_core_concat) - tmp131 := checkDerefVar(var_glojure_DOT_core_list) - tmp132 := checkDerefVar(var_glojure_DOT_core_apply) - tmp133 := checkDerefVar(var_glojure_DOT_core_vector) - tmp134 := checkDerefVar(var_glojure_DOT_core_seq) - tmp135 := checkDerefVar(var_glojure_DOT_core_concat) - tmp136 := checkDerefVar(var_glojure_DOT_core_list) - tmp137 := lang.Apply(tmp136, []any{sym_array__0__auto__}) - tmp138 := checkDerefVar(var_glojure_DOT_core_list) - tmp139 := lang.Apply(tmp138, []any{sym_idx__1__auto__}) - tmp140 := checkDerefVar(var_glojure_DOT_core_list) - tmp141 := lang.Apply(tmp140, []any{sym_idx2__3__auto__}) - tmp142 := checkDerefVar(var_glojure_DOT_core_list) - tmp143 := lang.Apply(tmp142, []any{sym__AMP_}) - tmp144 := checkDerefVar(var_glojure_DOT_core_list) - tmp145 := lang.Apply(tmp144, []any{sym_idxv__4__auto__}) - tmp146 := lang.Apply(tmp135, []any{tmp137, tmp139, tmp141, tmp143, tmp145}) - tmp147 := lang.Apply(tmp134, []any{tmp146}) - tmp148 := lang.Apply(tmp132, []any{tmp133, tmp147}) - tmp149 := lang.Apply(tmp131, []any{tmp148}) - tmp150 := checkDerefVar(var_glojure_DOT_core_list) - tmp151 := checkDerefVar(var_glojure_DOT_core_seq) - tmp152 := checkDerefVar(var_glojure_DOT_core_concat) - tmp153 := checkDerefVar(var_glojure_DOT_core_list) - tmp154 := lang.Apply(tmp153, []any{sym_glojure_DOT_core_SLASH_apply}) - tmp155 := checkDerefVar(var_glojure_DOT_core_list) - tmp156 := lang.Apply(tmp155, []any{v5}) - tmp157 := checkDerefVar(var_glojure_DOT_core_list) - tmp158 := checkDerefVar(var_glojure_DOT_core_seq) - tmp159 := checkDerefVar(var_glojure_DOT_core_concat) - tmp160 := checkDerefVar(var_glojure_DOT_core_list) - tmp161 := lang.Apply(tmp160, []any{sym_glojure_DOT_core_SLASH_aget}) - tmp162 := checkDerefVar(var_glojure_DOT_core_list) - tmp163 := lang.Apply(tmp162, []any{sym_array__0__auto__}) - tmp164 := checkDerefVar(var_glojure_DOT_core_list) - tmp165 := lang.Apply(tmp164, []any{sym_idx__1__auto__}) - tmp166 := lang.Apply(tmp159, []any{tmp161, tmp163, tmp165}) - tmp167 := lang.Apply(tmp158, []any{tmp166}) - tmp168 := lang.Apply(tmp157, []any{tmp167}) - tmp169 := checkDerefVar(var_glojure_DOT_core_list) - tmp170 := lang.Apply(tmp169, []any{sym_idx2__3__auto__}) - tmp171 := checkDerefVar(var_glojure_DOT_core_list) - tmp172 := lang.Apply(tmp171, []any{sym_idxv__4__auto__}) - tmp173 := lang.Apply(tmp152, []any{tmp154, tmp156, tmp168, tmp170, tmp172}) - tmp174 := lang.Apply(tmp151, []any{tmp173}) - tmp175 := lang.Apply(tmp150, []any{tmp174}) - tmp176 := lang.Apply(tmp130, []any{tmp149, tmp175}) - tmp177 := lang.Apply(tmp129, []any{tmp176}) - tmp178 := lang.Apply(tmp128, []any{tmp177}) - tmp179 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp72, tmp127, tmp178}) - tmp180 := lang.Apply(tmp8, []any{tmp179}) - return tmp180 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Quotient") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Quotient is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core_quot = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_quot.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // definline + // range { - tmp0 := sym_definline.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym__AMP_, sym_decl)), kw_doc, "Experimental - like defmacro, except defines a named function whose\n body is the expansion, calls to which may be expanded inline as if\n it were a macro. Cannot be used with variadic (&) args.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(11), kw_line, int(5253), kw_end_DASH_line, int(5253))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_range.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_end), lang.NewVector(sym_start, sym_end), lang.NewVector(sym_start, sym_end, sym_step)), kw_doc, "Returns a lazy seq of nums from start (inclusive) to end\n (exclusive), by step, where start defaults to 0, step to 1, and end to\n infinity. When step is equal to 0, returns an infinite sequence of\n start. When start is equal to end, returns empty list.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3018), kw_end_DASH_line, int(3018))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - default: - checkArity(args, 3) - v3 := args[0] + case 0: + tmp2 := checkDerefVar(var_glojure_DOT_core_iterate) + tmp3 := checkDerefVar(var_glojure_DOT_core_inc_TICK_) + tmp4 := lang.Apply(tmp2, []any{tmp3, int64(0)}) + return tmp4 + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + tmp6 := lang.Apply(lang.NewLongRange, []any{int64(0), v2, int64(1)}) + tmp3 = tmp6 + } else { + tmp7 := lang.Apply(lang.NewRange, []any{int64(0), v2, int64(1)}) + tmp3 = tmp7 + } + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any + var tmp4 any + var tmp5 any { // let - // let binding "vec__80" - tmp8 := checkDerefVar(var_glojure_DOT_core_split_DASH_with) - tmp9 := checkDerefVar(var_glojure_DOT_core_comp) - tmp10 := checkDerefVar(var_glojure_DOT_core_not) - tmp11 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) - tmp12 := lang.Apply(tmp9, []any{tmp10, tmp11}) - tmp13 := lang.Apply(tmp8, []any{tmp12, v6}) - var v14 any = tmp13 - _ = v14 - // let binding "pre-args" - tmp15 := checkDerefVar(var_glojure_DOT_core_nth) - tmp16 := lang.Apply(tmp15, []any{v14, int64(0), nil}) - var v17 any = tmp16 - _ = v17 - // let binding "vec__83" - tmp18 := checkDerefVar(var_glojure_DOT_core_nth) - tmp19 := lang.Apply(tmp18, []any{v14, int64(1), nil}) - var v20 any = tmp19 - _ = v20 - // let binding "args" - tmp21 := checkDerefVar(var_glojure_DOT_core_nth) - tmp22 := lang.Apply(tmp21, []any{v20, int64(0), nil}) - var v23 any = tmp22 - _ = v23 - // let binding "expr" - tmp24 := checkDerefVar(var_glojure_DOT_core_nth) - tmp25 := lang.Apply(tmp24, []any{v20, int64(1), nil}) - var v26 any = tmp25 - _ = v26 - tmp27 := checkDerefVar(var_glojure_DOT_core_seq) - tmp28 := checkDerefVar(var_glojure_DOT_core_concat) - tmp29 := checkDerefVar(var_glojure_DOT_core_list) - tmp30 := lang.Apply(tmp29, []any{sym_do}) - tmp31 := checkDerefVar(var_glojure_DOT_core_list) - tmp32 := checkDerefVar(var_glojure_DOT_core_seq) - tmp33 := checkDerefVar(var_glojure_DOT_core_concat) - tmp34 := checkDerefVar(var_glojure_DOT_core_list) - tmp35 := lang.Apply(tmp34, []any{sym_glojure_DOT_core_SLASH_defn}) - tmp36 := checkDerefVar(var_glojure_DOT_core_list) - tmp37 := lang.Apply(tmp36, []any{v5}) - tmp38 := checkDerefVar(var_glojure_DOT_core_list) - tmp39 := lang.Apply(tmp38, []any{v23}) - tmp40 := checkDerefVar(var_glojure_DOT_core_list) - tmp41 := checkDerefVar(var_glojure_DOT_core_apply) - tmp42 := checkDerefVar(var_glojure_DOT_core_eval) - tmp43 := checkDerefVar(var_glojure_DOT_core_list) - tmp44 := lang.Apply(tmp43, []any{sym_glojure_DOT_core_SLASH_fn, v23, v26}) - tmp45 := lang.Apply(tmp42, []any{tmp44}) - tmp46 := lang.Apply(tmp41, []any{tmp45, v23}) - tmp47 := lang.Apply(tmp40, []any{tmp46}) - tmp48 := lang.Apply(tmp33, []any{tmp35, tmp37, v17, tmp39, tmp47}) - tmp49 := lang.Apply(tmp32, []any{tmp48}) - tmp50 := lang.Apply(tmp31, []any{tmp49}) - tmp51 := checkDerefVar(var_glojure_DOT_core_list) - tmp52 := checkDerefVar(var_glojure_DOT_core_seq) - tmp53 := checkDerefVar(var_glojure_DOT_core_concat) - tmp54 := checkDerefVar(var_glojure_DOT_core_list) - tmp55 := lang.Apply(tmp54, []any{sym_glojure_DOT_core_SLASH_alter_DASH_meta_BANG_}) - tmp56 := checkDerefVar(var_glojure_DOT_core_list) - tmp57 := checkDerefVar(var_glojure_DOT_core_seq) - tmp58 := checkDerefVar(var_glojure_DOT_core_concat) - tmp59 := checkDerefVar(var_glojure_DOT_core_list) - tmp60 := lang.Apply(tmp59, []any{sym_var}) - tmp61 := checkDerefVar(var_glojure_DOT_core_list) - tmp62 := lang.Apply(tmp61, []any{v5}) - tmp63 := lang.Apply(tmp58, []any{tmp60, tmp62}) - tmp64 := lang.Apply(tmp57, []any{tmp63}) - tmp65 := lang.Apply(tmp56, []any{tmp64}) - tmp66 := checkDerefVar(var_glojure_DOT_core_list) - tmp67 := lang.Apply(tmp66, []any{sym_glojure_DOT_core_SLASH_assoc}) - tmp68 := checkDerefVar(var_glojure_DOT_core_list) - tmp69 := lang.Apply(tmp68, []any{kw_inline}) - tmp70 := checkDerefVar(var_glojure_DOT_core_list) - tmp71 := checkDerefVar(var_glojure_DOT_core_seq) - tmp72 := checkDerefVar(var_glojure_DOT_core_concat) - tmp73 := checkDerefVar(var_glojure_DOT_core_list) - tmp74 := lang.Apply(tmp73, []any{sym_glojure_DOT_core_SLASH_fn}) - tmp75 := checkDerefVar(var_glojure_DOT_core_list) - tmp76 := lang.Apply(tmp75, []any{v5}) - tmp77 := checkDerefVar(var_glojure_DOT_core_list) - tmp78 := lang.Apply(tmp77, []any{v23}) - tmp79 := checkDerefVar(var_glojure_DOT_core_list) - tmp80 := lang.Apply(tmp79, []any{v26}) - tmp81 := lang.Apply(tmp72, []any{tmp74, tmp76, tmp78, tmp80}) - tmp82 := lang.Apply(tmp71, []any{tmp81}) - tmp83 := lang.Apply(tmp70, []any{tmp82}) - tmp84 := lang.Apply(tmp53, []any{tmp55, tmp65, tmp67, tmp69, tmp83}) - tmp85 := lang.Apply(tmp52, []any{tmp84}) - tmp86 := lang.Apply(tmp51, []any{tmp85}) - tmp87 := checkDerefVar(var_glojure_DOT_core_list) - tmp88 := checkDerefVar(var_glojure_DOT_core_seq) - tmp89 := checkDerefVar(var_glojure_DOT_core_concat) - tmp90 := checkDerefVar(var_glojure_DOT_core_list) - tmp91 := lang.Apply(tmp90, []any{sym_var}) - tmp92 := checkDerefVar(var_glojure_DOT_core_list) - tmp93 := lang.Apply(tmp92, []any{v5}) - tmp94 := lang.Apply(tmp89, []any{tmp91, tmp93}) - tmp95 := lang.Apply(tmp88, []any{tmp94}) - tmp96 := lang.Apply(tmp87, []any{tmp95}) - tmp97 := lang.Apply(tmp28, []any{tmp30, tmp50, tmp86, tmp96}) - tmp98 := lang.Apply(tmp27, []any{tmp97}) - tmp7 = tmp98 + // let binding "and__0__auto__" + tmp6 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) + tmp7 := lang.Apply(tmp6, []any{v2}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + tmp10 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) + tmp11 := lang.Apply(tmp10, []any{v3}) + tmp9 = tmp11 + } else { + tmp9 = v8 + } + tmp5 = tmp9 } // end let - return tmp7 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // defmacro - { - tmp0 := sym_defmacro.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym_doc_DASH_string_QMARK_, sym_attr_DASH_map_QMARK_, lang.NewVector(sym_params_STAR_), sym_body), lang.NewVector(sym_name, sym_doc_DASH_string_QMARK_, sym_attr_DASH_map_QMARK_, lang.NewList(lang.NewVector(sym_params_STAR_), sym_body), sym__PLUS_, sym_attr_DASH_map_QMARK_)), kw_doc, "Like defn, but the resulting function name is declared as a\n macro and will be used as a macro by the compiler when it is\n called.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(2), kw_line, int(445), kw_end_DASH_line, int(451))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 3) - v3 := args[0] + if lang.IsTruthy(tmp5) { + tmp6 := lang.Apply(lang.NewLongRange, []any{v2, v3, int64(1)}) + tmp4 = tmp6 + } else { + tmp7 := lang.Apply(lang.NewRange, []any{v2, v3, int64(1)}) + tmp4 = tmp7 + } + return tmp4 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + v4 := args[2] _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any + var tmp5 any + var tmp6 any { // let - // let binding "prefix" - var tmp8 any - { // let - // let binding "p" - tmp9 := checkDerefVar(var_glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{v5}) - var v11 any = tmp10 - _ = v11 - // let binding "args" - var v12 any = v6 - _ = v12 - for { - var tmp13 any - { // let - // let binding "f" - tmp14 := checkDerefVar(var_glojure_DOT_core_first) - tmp15 := lang.Apply(tmp14, []any{v12}) - var v16 any = tmp15 - _ = v16 - var tmp17 any - tmp18 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) - tmp19 := lang.Apply(tmp18, []any{v16}) - if lang.IsTruthy(tmp19) { - tmp21 := checkDerefVar(var_glojure_DOT_core_cons) - tmp22 := lang.Apply(tmp21, []any{v16, v11}) - var tmp20 any = tmp22 - tmp24 := checkDerefVar(var_glojure_DOT_core_next) - tmp25 := lang.Apply(tmp24, []any{v12}) - var tmp23 any = tmp25 - v11 = tmp20 - v12 = tmp23 - continue - } else { - var tmp26 any - tmp27 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) - tmp28 := lang.Apply(tmp27, []any{v16}) - if lang.IsTruthy(tmp28) { - tmp30 := checkDerefVar(var_glojure_DOT_core_cons) - tmp31 := lang.Apply(tmp30, []any{v16, v11}) - var tmp29 any = tmp31 - tmp33 := checkDerefVar(var_glojure_DOT_core_next) - tmp34 := lang.Apply(tmp33, []any{v12}) - var tmp32 any = tmp34 - v11 = tmp29 - v12 = tmp32 - continue - } else { - tmp26 = v11 - } - tmp17 = tmp26 - } - tmp13 = tmp17 - } // end let - tmp8 = tmp13 - break - } - } // end let + // let binding "and__0__auto__" + tmp7 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v2}) var v9 any = tmp8 _ = v9 - // let binding "fdecl" var tmp10 any - { // let - // let binding "fd" - var v11 any = v6 - _ = v11 - for { - var tmp12 any - tmp13 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) - tmp14 := checkDerefVar(var_glojure_DOT_core_first) - tmp15 := lang.Apply(tmp14, []any{v11}) - tmp16 := lang.Apply(tmp13, []any{tmp15}) - if lang.IsTruthy(tmp16) { - tmp18 := checkDerefVar(var_glojure_DOT_core_next) - tmp19 := lang.Apply(tmp18, []any{v11}) - var tmp17 any = tmp19 - v11 = tmp17 - continue + if lang.IsTruthy(v9) { + var tmp11 any + { // let + // let binding "and__0__auto__" + tmp12 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) + tmp13 := lang.Apply(tmp12, []any{v3}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + tmp16 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) + tmp17 := lang.Apply(tmp16, []any{v4}) + tmp15 = tmp17 } else { - var tmp20 any - tmp21 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) - tmp22 := checkDerefVar(var_glojure_DOT_core_first) - tmp23 := lang.Apply(tmp22, []any{v11}) - tmp24 := lang.Apply(tmp21, []any{tmp23}) - if lang.IsTruthy(tmp24) { - tmp26 := checkDerefVar(var_glojure_DOT_core_next) - tmp27 := lang.Apply(tmp26, []any{v11}) - var tmp25 any = tmp27 - v11 = tmp25 - continue - } else { - tmp20 = v11 - } - tmp12 = tmp20 + tmp15 = v14 } - tmp10 = tmp12 - break - } - } // end let - var v11 any = tmp10 - _ = v11 - // let binding "fdecl" - var tmp12 any - tmp13 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) - tmp14 := checkDerefVar(var_glojure_DOT_core_first) - tmp15 := lang.Apply(tmp14, []any{v11}) - tmp16 := lang.Apply(tmp13, []any{tmp15}) - if lang.IsTruthy(tmp16) { - tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{v11}) - tmp12 = tmp18 - } else { - tmp12 = v11 - } - var v19 any = tmp12 - _ = v19 - // let binding "add-implicit-args" - var tmp20 lang.FnFunc - tmp20 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v21 := args[0] - _ = v21 - var tmp22 any - { // let - // let binding "args" - tmp23 := checkDerefVar(var_glojure_DOT_core_first) - tmp24 := lang.Apply(tmp23, []any{v21}) - var v25 any = tmp24 - _ = v25 - tmp26 := checkDerefVar(var_glojure_DOT_core_cons) - tmp27 := checkDerefVar(var_glojure_DOT_core_vec) - tmp28 := checkDerefVar(var_glojure_DOT_core_cons) - tmp29 := checkDerefVar(var_glojure_DOT_core_cons) - tmp30 := lang.Apply(tmp29, []any{sym__AMP_env, v25}) - tmp31 := lang.Apply(tmp28, []any{sym__AMP_form, tmp30}) - tmp32 := lang.Apply(tmp27, []any{tmp31}) - tmp33 := checkDerefVar(var_glojure_DOT_core_next) - tmp34 := lang.Apply(tmp33, []any{v21}) - tmp35 := lang.Apply(tmp26, []any{tmp32, tmp34}) - tmp22 = tmp35 + tmp11 = tmp15 } // end let - return tmp22 - }) - tmp21 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(469), kw_column, int(38), kw_end_DASH_line, int(471), kw_end_DASH_column, int(87)) - tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v23 any = tmp22 - _ = v23 - // let binding "add-args" - var tmp24 lang.FnFunc - tmp24 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v25 := args[0] - _ = v25 - v26 := args[1] - _ = v26 - recur_loop_61: - var tmp27 any - tmp28 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) - tmp29 := lang.Apply(tmp28, []any{v26}) - if lang.IsTruthy(tmp29) { - tmp27 = v25 - } else { - var tmp30 any - { // let - // let binding "d" - tmp31 := checkDerefVar(var_glojure_DOT_core_first) - tmp32 := lang.Apply(tmp31, []any{v26}) - var v33 any = tmp32 - _ = v33 - var tmp34 any - tmp35 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) - tmp36 := lang.Apply(tmp35, []any{v33}) - if lang.IsTruthy(tmp36) { - tmp37 := checkDerefVar(var_glojure_DOT_core_conj) - tmp38 := lang.Apply(tmp37, []any{v25, v33}) - tmp34 = tmp38 - } else { - tmp40 := checkDerefVar(var_glojure_DOT_core_conj) - tmp41 := lang.Apply(v23, []any{v33}) - tmp42 := lang.Apply(tmp40, []any{v25, tmp41}) - var tmp39 any = tmp42 - tmp44 := checkDerefVar(var_glojure_DOT_core_next) - tmp45 := lang.Apply(tmp44, []any{v26}) - var tmp43 any = tmp45 - v25 = tmp39 - v26 = tmp43 - goto recur_loop_61 - } - tmp30 = tmp34 - } // end let - tmp27 = tmp30 - } - return tmp27 - }) - tmp25 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(472), kw_column, int(29), kw_end_DASH_line, int(478), kw_end_DASH_column, int(90)) - tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v27 any = tmp26 - _ = v27 - // let binding "fdecl" - tmp28 := checkDerefVar(var_glojure_DOT_core_seq) - tmp29 := lang.NewVector() - tmp30 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(479), kw_column, int(41), kw_end_DASH_line, int(479), kw_end_DASH_column, int(42)) - tmp31, err := lang.WithMeta(tmp29, tmp30.(lang.IPersistentMap)) - if err != nil { - panic(err) + tmp10 = tmp11 + } else { + tmp10 = v9 } - tmp32 := lang.Apply(v27, []any{tmp31, v19}) - tmp33 := lang.Apply(tmp28, []any{tmp32}) - var v34 any = tmp33 - _ = v34 - // let binding "decl" - var tmp35 any - { // let - // let binding "p" - var v36 any = v9 - _ = v36 - // let binding "d" - var v37 any = v34 - _ = v37 - for { - var tmp38 any - if lang.IsTruthy(v36) { - tmp40 := checkDerefVar(var_glojure_DOT_core_next) - tmp41 := lang.Apply(tmp40, []any{v36}) - var tmp39 any = tmp41 - tmp43 := checkDerefVar(var_glojure_DOT_core_cons) - tmp44 := checkDerefVar(var_glojure_DOT_core_first) - tmp45 := lang.Apply(tmp44, []any{v36}) - tmp46 := lang.Apply(tmp43, []any{tmp45, v37}) - var tmp42 any = tmp46 - v36 = tmp39 - v37 = tmp42 - continue - } else { - tmp38 = v37 - } - tmp35 = tmp38 - break - } - } // end let - var v36 any = tmp35 - _ = v36 - tmp37 := checkDerefVar(var_glojure_DOT_core_list) - tmp38 := checkDerefVar(var_glojure_DOT_core_cons) - tmp39 := lang.Apply(tmp38, []any{sym_glojure_DOT_core_SLASH_defn, v36}) - tmp40 := checkDerefVar(var_glojure_DOT_core_list) - tmp41 := checkDerefVar(var_glojure_DOT_core_list) - tmp42 := lang.Apply(tmp41, []any{sym_var, v5}) - tmp43 := lang.Apply(tmp40, []any{sym__DOT_, tmp42, lang.NewList(sym_SetMacro)}) - tmp44 := checkDerefVar(var_glojure_DOT_core_list) - tmp45 := lang.Apply(tmp44, []any{sym_var, v5}) - tmp46 := lang.Apply(tmp37, []any{sym_do, tmp39, tmp43, tmp45}) - tmp7 = tmp46 + tmp6 = tmp10 } // end let - return tmp7 + if lang.IsTruthy(tmp6) { + tmp7 := lang.Apply(lang.NewLongRange, []any{v2, v3, v4}) + tmp5 = tmp7 + } else { + tmp8 := lang.Apply(lang.NewRange, []any{v2, v3, v4}) + tmp5 = tmp8 + } + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(451), kw_column, int(11), kw_end_DASH_line, int(487), kw_end_DASH_column, int(40))).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_range = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_range.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // defmethod + // rational? { - tmp0 := sym_defmethod.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_multifn, sym_dispatch_DASH_val, sym__AMP_, sym_fn_DASH_tail)), kw_doc, "Creates and installs a new method of multimethod associated with dispatch-value. ", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(11), kw_line, int(1781), kw_end_DASH_line, int(1781))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 4) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] + tmp0 := sym_rational_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_doc, "Returns true if n is a rational number", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(3613), kw_end_DASH_line, int(3613))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "or__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_integer_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 _ = v6 - var v7 any = lang.NewList(args[4:]...) - _ = v7 - tmp8 := checkDerefVar(var_glojure_DOT_core_seq) - tmp9 := checkDerefVar(var_glojure_DOT_core_concat) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) - tmp12 := checkDerefVar(var_glojure_DOT_core_list) - tmp13 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) - tmp14 := lang.NewMap(kw_tag, sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT__STAR_MultiFn) - tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(1785), kw_column, int(27), kw_end_DASH_line, int(1785), kw_end_DASH_column, int(82)) - tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) - if err != nil { - panic(err) + var tmp7 any + if lang.IsTruthy(v6) { + tmp7 = v6 + } else { + var tmp8 any + { // let + // let binding "or__0__auto__" + tmp9 := checkDerefVar(var_glojure_DOT_core_ratio_QMARK_) + tmp10 := lang.Apply(tmp9, []any{v2}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + tmp12 = v11 + } else { + tmp13 := checkDerefVar(var_glojure_DOT_core_decimal_QMARK_) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp12 = tmp14 + } + tmp8 = tmp12 + } // end let + tmp7 = tmp8 } - tmp17 := lang.Apply(tmp13, []any{v5, tmp16}) - tmp18 := lang.Apply(tmp12, []any{tmp17}) - tmp19 := checkDerefVar(var_glojure_DOT_core_list) - tmp20 := lang.Apply(tmp19, []any{sym_glojure_DOT_core_SLASH_AddMethod}) - tmp21 := checkDerefVar(var_glojure_DOT_core_list) - tmp22 := lang.Apply(tmp21, []any{v6}) - tmp23 := checkDerefVar(var_glojure_DOT_core_list) - tmp24 := checkDerefVar(var_glojure_DOT_core_seq) - tmp25 := checkDerefVar(var_glojure_DOT_core_concat) - tmp26 := checkDerefVar(var_glojure_DOT_core_list) - tmp27 := lang.Apply(tmp26, []any{sym_glojure_DOT_core_SLASH_fn}) - tmp28 := lang.Apply(tmp25, []any{tmp27, v7}) - tmp29 := lang.Apply(tmp24, []any{tmp28}) - tmp30 := lang.Apply(tmp23, []any{tmp29}) - tmp31 := lang.Apply(tmp9, []any{tmp11, tmp18, tmp20, tmp22, tmp30}) - tmp32 := lang.Apply(tmp8, []any{tmp31}) - return tmp32 - } + tmp3 = tmp7 + } // end let + return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_rational_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_rational_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // defmulti + // reduce1 { - tmp0 := sym_defmulti.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym_docstring_QMARK_, sym_attr_DASH_map_QMARK_, sym_dispatch_DASH_fn, sym__AMP_, sym_options)), kw_doc, "Creates a new multimethod with the associated dispatch function.\n The docstring and attr-map are optional.\n\n Options are key-value pairs and may be one of:\n\n :default\n\n The default dispatch value, defaults to :default\n\n :hierarchy\n\n The value used for hierarchical dispatch (e.g. ::square is-a ::shape)\n\n Hierarchies are type-like relationships that do not depend upon type\n inheritance. By default Clojure's multimethods dispatch off of a\n global hierarchy map. However, a hierarchy relationship can be\n created with the derive function used to augment the root ancestor\n created with make-hierarchy.\n\n Multimethods expect the value of the hierarchy option to be supplied as\n a reference type e.g. a var (i.e. via the Var-quote dispatch macro #'\n or the var special form).", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(11), kw_line, int(1723), kw_end_DASH_line, int(1723))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_reduce1.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(923), kw_column, int(7), kw_end_DASH_line, int(924), kw_end_DASH_column, int(9), kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_coll), lang.NewVector(sym_f, sym_val, sym_coll)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - default: - checkArity(args, 3) - v3 := args[0] + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any + var tmp4 any { // let - // let binding "docstring" + // let binding "s" + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := lang.Apply(tmp5, []any{v3}) + var v7 any = tmp6 + _ = v7 var tmp8 any - tmp9 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) - tmp10 := checkDerefVar(var_glojure_DOT_core_first) - tmp11 := lang.Apply(tmp10, []any{v6}) - tmp12 := lang.Apply(tmp9, []any{tmp11}) - if lang.IsTruthy(tmp12) { - tmp13 := checkDerefVar(var_glojure_DOT_core_first) - tmp14 := lang.Apply(tmp13, []any{v6}) + if lang.IsTruthy(v7) { + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v7}) + tmp12 := checkDerefVar(var_glojure_DOT_core_next) + tmp13 := lang.Apply(tmp12, []any{v7}) + tmp14 := lang.Apply(tmp9, []any{v2, tmp11, tmp13}) tmp8 = tmp14 } else { + tmp15 := lang.Apply(v2, nil) + tmp8 = tmp15 } - var v15 any = tmp8 - _ = v15 - // let binding "options" - var tmp16 any - tmp17 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) - tmp18 := checkDerefVar(var_glojure_DOT_core_first) - tmp19 := lang.Apply(tmp18, []any{v6}) - tmp20 := lang.Apply(tmp17, []any{tmp19}) - if lang.IsTruthy(tmp20) { - tmp21 := checkDerefVar(var_glojure_DOT_core_next) - tmp22 := lang.Apply(tmp21, []any{v6}) - tmp16 = tmp22 - } else { - tmp16 = v6 - } - var v23 any = tmp16 - _ = v23 - // let binding "m" - var tmp24 any - tmp25 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) - tmp26 := checkDerefVar(var_glojure_DOT_core_first) - tmp27 := lang.Apply(tmp26, []any{v23}) - tmp28 := lang.Apply(tmp25, []any{tmp27}) - if lang.IsTruthy(tmp28) { - tmp29 := checkDerefVar(var_glojure_DOT_core_first) - tmp30 := lang.Apply(tmp29, []any{v23}) - tmp24 = tmp30 - } else { - tmp31 := lang.NewMap() - tmp32 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(1757), kw_column, int(23), kw_end_DASH_line, int(1757), kw_end_DASH_column, int(24)) - tmp33, err := lang.WithMeta(tmp31, tmp32.(lang.IPersistentMap)) - if err != nil { - panic(err) + tmp4 = tmp8 + } // end let + return tmp4 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + recur_loop_156: + var tmp5 any + { // let + // let binding "s" + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := lang.Apply(tmp6, []any{v4}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + var tmp10 any + tmp11 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp12 := lang.Apply(tmp11, []any{v8}) + if lang.IsTruthy(tmp12) { + var tmp13 any = v2 + tmp15 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp16 := lang.Apply(tmp15, []any{v8}) + tmp17, _ := lang.FieldOrMethod(tmp16, "ReduceInit") + if reflect.TypeOf(tmp17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) + } + tmp18 := lang.Apply(tmp17, []any{v2, v3}) + var tmp14 any = tmp18 + tmp20 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_next) + tmp21 := lang.Apply(tmp20, []any{v8}) + var tmp19 any = tmp21 + v2 = tmp13 + v3 = tmp14 + v4 = tmp19 + goto recur_loop_156 + } else { + var tmp22 any = v2 + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v8}) + tmp26 := lang.Apply(v2, []any{v3, tmp25}) + var tmp23 any = tmp26 + tmp28 := checkDerefVar(var_glojure_DOT_core_next) + tmp29 := lang.Apply(tmp28, []any{v8}) + var tmp27 any = tmp29 + v2 = tmp22 + v3 = tmp23 + v4 = tmp27 + goto recur_loop_156 } - tmp24 = tmp33 - } - var v34 any = tmp24 - _ = v34 - // let binding "options" - var tmp35 any - tmp36 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) - tmp37 := checkDerefVar(var_glojure_DOT_core_first) - tmp38 := lang.Apply(tmp37, []any{v23}) - tmp39 := lang.Apply(tmp36, []any{tmp38}) - if lang.IsTruthy(tmp39) { - tmp40 := checkDerefVar(var_glojure_DOT_core_next) - tmp41 := lang.Apply(tmp40, []any{v23}) - tmp35 = tmp41 - } else { - tmp35 = v23 - } - var v42 any = tmp35 - _ = v42 - // let binding "dispatch-fn" - tmp43 := checkDerefVar(var_glojure_DOT_core_first) - tmp44 := lang.Apply(tmp43, []any{v42}) - var v45 any = tmp44 - _ = v45 - // let binding "options" - tmp46 := checkDerefVar(var_glojure_DOT_core_next) - tmp47 := lang.Apply(tmp46, []any{v42}) - var v48 any = tmp47 - _ = v48 - // let binding "m" - var tmp49 any - if lang.IsTruthy(v15) { - tmp50 := checkDerefVar(var_glojure_DOT_core_assoc) - tmp51 := lang.Apply(tmp50, []any{v34, kw_doc, v15}) - tmp49 = tmp51 - } else { - tmp49 = v34 - } - var v52 any = tmp49 - _ = v52 - // let binding "m" - var tmp53 any - tmp54 := checkDerefVar(var_glojure_DOT_core_meta) - tmp55 := lang.Apply(tmp54, []any{v5}) - if lang.IsTruthy(tmp55) { - tmp56 := checkDerefVar(var_glojure_DOT_core_conj) - tmp57 := checkDerefVar(var_glojure_DOT_core_meta) - tmp58 := lang.Apply(tmp57, []any{v5}) - tmp59 := lang.Apply(tmp56, []any{tmp58, v52}) - tmp53 = tmp59 - } else { - tmp53 = v52 - } - var v60 any = tmp53 - _ = v60 - // let binding "mm-name" - tmp61 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) - tmp62 := lang.Apply(tmp61, []any{v5, v60}) - var v63 any = tmp62 - _ = v63 - var tmp64 any - tmp65 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp66 := checkDerefVar(var_glojure_DOT_core_count) - tmp67 := lang.Apply(tmp66, []any{v48}) - tmp68 := lang.Apply(tmp65, []any{tmp67, int64(1)}) - if lang.IsTruthy(tmp68) { - tmp69 := lang.Apply(lang.NewError, []any{"The syntax for defmulti has changed. Example: (defmulti name dispatch-fn :default dispatch-value)"}) - panic(tmp69) + tmp9 = tmp10 } else { + tmp9 = v3 } - _ = tmp64 - var tmp70 any - { // let - // let binding "options" - tmp71 := checkDerefVar(var_glojure_DOT_core_apply) - tmp72 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) - tmp73 := lang.Apply(tmp71, []any{tmp72, v48}) - var v74 any = tmp73 - _ = v74 - // let binding "default" - tmp75 := checkDerefVar(var_glojure_DOT_core_get) - tmp76 := lang.Apply(tmp75, []any{v74, kw_default, kw_default}) - var v77 any = tmp76 - _ = v77 - // let binding "hierarchy" - tmp78 := checkDerefVar(var_glojure_DOT_core_get) - tmp79 := lang.InternVarName(sym_glojure_DOT_core, sym_global_DASH_hierarchy) - tmp80 := lang.Apply(tmp78, []any{v74, kw_hierarchy, tmp79}) - var v81 any = tmp80 - _ = v81 - tmp82 := checkDerefVar(var_glojure_DOT_core_check_DASH_valid_DASH_options) - tmp83 := lang.Apply(tmp82, []any{v74, kw_default, kw_hierarchy}) - _ = tmp83 - tmp84 := checkDerefVar(var_glojure_DOT_core_seq) - tmp85 := checkDerefVar(var_glojure_DOT_core_concat) - tmp86 := checkDerefVar(var_glojure_DOT_core_list) - tmp87 := lang.Apply(tmp86, []any{sym_glojure_DOT_core_SLASH_let}) - tmp88 := checkDerefVar(var_glojure_DOT_core_list) - tmp89 := checkDerefVar(var_glojure_DOT_core_apply) - tmp90 := checkDerefVar(var_glojure_DOT_core_vector) - tmp91 := checkDerefVar(var_glojure_DOT_core_seq) - tmp92 := checkDerefVar(var_glojure_DOT_core_concat) - tmp93 := checkDerefVar(var_glojure_DOT_core_list) - tmp94 := lang.Apply(tmp93, []any{sym_v__0__auto__}) - tmp95 := checkDerefVar(var_glojure_DOT_core_list) - tmp96 := checkDerefVar(var_glojure_DOT_core_seq) - tmp97 := checkDerefVar(var_glojure_DOT_core_concat) - tmp98 := checkDerefVar(var_glojure_DOT_core_list) - tmp99 := lang.Apply(tmp98, []any{sym_def}) - tmp100 := checkDerefVar(var_glojure_DOT_core_list) - tmp101 := lang.Apply(tmp100, []any{v63}) - tmp102 := lang.Apply(tmp97, []any{tmp99, tmp101}) - tmp103 := lang.Apply(tmp96, []any{tmp102}) - tmp104 := lang.Apply(tmp95, []any{tmp103}) - tmp105 := lang.Apply(tmp92, []any{tmp94, tmp104}) - tmp106 := lang.Apply(tmp91, []any{tmp105}) - tmp107 := lang.Apply(tmp89, []any{tmp90, tmp106}) - tmp108 := lang.Apply(tmp88, []any{tmp107}) - tmp109 := checkDerefVar(var_glojure_DOT_core_list) - tmp110 := checkDerefVar(var_glojure_DOT_core_seq) - tmp111 := checkDerefVar(var_glojure_DOT_core_concat) - tmp112 := checkDerefVar(var_glojure_DOT_core_list) - tmp113 := lang.Apply(tmp112, []any{sym_glojure_DOT_core_SLASH_when_DASH_not}) - tmp114 := checkDerefVar(var_glojure_DOT_core_list) - tmp115 := checkDerefVar(var_glojure_DOT_core_seq) - tmp116 := checkDerefVar(var_glojure_DOT_core_concat) - tmp117 := checkDerefVar(var_glojure_DOT_core_list) - tmp118 := lang.Apply(tmp117, []any{sym_glojure_DOT_core_SLASH_and}) - tmp119 := checkDerefVar(var_glojure_DOT_core_list) - tmp120 := checkDerefVar(var_glojure_DOT_core_seq) - tmp121 := checkDerefVar(var_glojure_DOT_core_concat) - tmp122 := checkDerefVar(var_glojure_DOT_core_list) - tmp123 := lang.Apply(tmp122, []any{sym__DOT_HasRoot}) - tmp124 := checkDerefVar(var_glojure_DOT_core_list) - tmp125 := lang.Apply(tmp124, []any{sym_v__0__auto__}) - tmp126 := lang.Apply(tmp121, []any{tmp123, tmp125}) - tmp127 := lang.Apply(tmp120, []any{tmp126}) - tmp128 := lang.Apply(tmp119, []any{tmp127}) - tmp129 := checkDerefVar(var_glojure_DOT_core_list) - tmp130 := checkDerefVar(var_glojure_DOT_core_seq) - tmp131 := checkDerefVar(var_glojure_DOT_core_concat) - tmp132 := checkDerefVar(var_glojure_DOT_core_list) - tmp133 := lang.Apply(tmp132, []any{sym_glojure_DOT_core_SLASH_instance_QMARK_}) - tmp134 := checkDerefVar(var_glojure_DOT_core_list) - tmp135 := lang.Apply(tmp134, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT__STAR_MultiFn}) - tmp136 := checkDerefVar(var_glojure_DOT_core_list) - tmp137 := checkDerefVar(var_glojure_DOT_core_seq) - tmp138 := checkDerefVar(var_glojure_DOT_core_concat) - tmp139 := checkDerefVar(var_glojure_DOT_core_list) - tmp140 := lang.Apply(tmp139, []any{sym_glojure_DOT_core_SLASH_deref}) - tmp141 := checkDerefVar(var_glojure_DOT_core_list) - tmp142 := lang.Apply(tmp141, []any{sym_v__0__auto__}) - tmp143 := lang.Apply(tmp138, []any{tmp140, tmp142}) - tmp144 := lang.Apply(tmp137, []any{tmp143}) - tmp145 := lang.Apply(tmp136, []any{tmp144}) - tmp146 := lang.Apply(tmp131, []any{tmp133, tmp135, tmp145}) - tmp147 := lang.Apply(tmp130, []any{tmp146}) - tmp148 := lang.Apply(tmp129, []any{tmp147}) - tmp149 := lang.Apply(tmp116, []any{tmp118, tmp128, tmp148}) - tmp150 := lang.Apply(tmp115, []any{tmp149}) - tmp151 := lang.Apply(tmp114, []any{tmp150}) - tmp152 := checkDerefVar(var_glojure_DOT_core_list) - tmp153 := checkDerefVar(var_glojure_DOT_core_seq) - tmp154 := checkDerefVar(var_glojure_DOT_core_concat) - tmp155 := checkDerefVar(var_glojure_DOT_core_list) - tmp156 := lang.Apply(tmp155, []any{sym_def}) - tmp157 := checkDerefVar(var_glojure_DOT_core_list) - tmp158 := lang.Apply(tmp157, []any{v63}) - tmp159 := checkDerefVar(var_glojure_DOT_core_list) - tmp160 := checkDerefVar(var_glojure_DOT_core_seq) - tmp161 := checkDerefVar(var_glojure_DOT_core_concat) - tmp162 := checkDerefVar(var_glojure_DOT_core_list) - tmp163 := lang.Apply(tmp162, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_NewMultiFn}) - tmp164 := checkDerefVar(var_glojure_DOT_core_list) - tmp165 := checkDerefVar(var_glojure_DOT_core_name) - tmp166 := lang.Apply(tmp165, []any{v63}) - tmp167 := lang.Apply(tmp164, []any{tmp166}) - tmp168 := checkDerefVar(var_glojure_DOT_core_list) - tmp169 := lang.Apply(tmp168, []any{v45}) - tmp170 := checkDerefVar(var_glojure_DOT_core_list) - tmp171 := lang.Apply(tmp170, []any{v77}) - tmp172 := checkDerefVar(var_glojure_DOT_core_list) - tmp173 := lang.Apply(tmp172, []any{v81}) - tmp174 := lang.Apply(tmp161, []any{tmp163, tmp167, tmp169, tmp171, tmp173}) - tmp175 := lang.Apply(tmp160, []any{tmp174}) - tmp176 := lang.Apply(tmp159, []any{tmp175}) - tmp177 := lang.Apply(tmp154, []any{tmp156, tmp158, tmp176}) - tmp178 := lang.Apply(tmp153, []any{tmp177}) - tmp179 := lang.Apply(tmp152, []any{tmp178}) - tmp180 := lang.Apply(tmp111, []any{tmp113, tmp151, tmp179}) - tmp181 := lang.Apply(tmp110, []any{tmp180}) - tmp182 := lang.Apply(tmp109, []any{tmp181}) - tmp183 := lang.Apply(tmp85, []any{tmp87, tmp108, tmp182}) - tmp184 := lang.Apply(tmp84, []any{tmp183}) - tmp70 = tmp184 - } // end let - tmp7 = tmp70 + tmp5 = tmp9 } // end let - return tmp7 + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_reduce1 = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_reduce1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // defn + // reduced? { - tmp0 := sym_defn.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym_doc_DASH_string_QMARK_, sym_attr_DASH_map_QMARK_, lang.NewVector(sym_params_STAR_), sym_prepost_DASH_map_QMARK_, sym_body), lang.NewVector(sym_name, sym_doc_DASH_string_QMARK_, sym_attr_DASH_map_QMARK_, lang.NewList(lang.NewVector(sym_params_STAR_), sym_prepost_DASH_map_QMARK_, sym_body), sym__PLUS_, sym_attr_DASH_map_QMARK_)), kw_doc, "Same as (def name (fn [params* ] exprs*)) or (def\n name (fn ([params* ] exprs*)+)) with any doc-string or attrs added\n to the var metadata. prepost-map defines a map with optional keys\n :pre and :post that contain collections of pre or post conditions.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(5), kw_column, int(2), kw_line, int(284), kw_end_DASH_line, int(291))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function reduced?__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_IsReduced}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{v3}) + tmp10 := lang.Apply(tmp5, []any{tmp7, tmp9}) + tmp11 := lang.Apply(tmp4, []any{tmp10}) + return tmp11 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_reduced_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns true if x is the result of a call to reduced", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1)})), kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(2834), kw_end_DASH_line, int(2834))).(*lang.Symbol) var tmp2 lang.FnFunc - { // function defn - var v3 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 3) - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - v6 := args[2] - _ = v6 - var v7 any = lang.NewList(args[3:]...) - _ = v7 - var tmp8 any - tmp9 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp10 := reflect.TypeOf((*lang.Symbol)(nil)) - tmp11 := lang.Apply(tmp9, []any{tmp10, v6}) - if lang.IsTruthy(tmp11) { - } else { - tmp12 := lang.Apply(lang.NewIllegalArgumentError, []any{"First argument to defn must be a symbol"}) - panic(tmp12) - } - _ = tmp8 - var tmp13 any + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.IsReduced, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_reduced_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_reduced_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reductions + { + tmp0 := sym_reductions.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_coll), lang.NewVector(sym_f, sym_init, sym_coll)), kw_doc, "Returns a lazy seq of the intermediate values of the reduction (as\n per reduce) of coll by f, starting with init.", kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(7196), kw_end_DASH_line, int(7196))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp5 any { // let - // let binding "m" - var tmp14 any - tmp15 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) - tmp16 := checkDerefVar(var_glojure_DOT_core_first) - tmp17 := lang.Apply(tmp16, []any{v7}) - tmp18 := lang.Apply(tmp15, []any{tmp17}) - if lang.IsTruthy(tmp18) { - tmp19 := checkDerefVar(var_glojure_DOT_core_first) - tmp20 := lang.Apply(tmp19, []any{v7}) - tmp21 := lang.NewMap(kw_doc, tmp20) - tmp22 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(297), kw_column, int(19), kw_end_DASH_line, int(297), kw_end_DASH_column, int(38)) - tmp23, err := lang.WithMeta(tmp21, tmp22.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp14 = tmp23 - } else { - tmp24 := lang.NewMap() - tmp25 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(298), kw_column, int(19), kw_end_DASH_line, int(298), kw_end_DASH_column, int(20)) - tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp14 = tmp26 - } - var v27 any = tmp14 - _ = v27 - // let binding "fdecl" - var tmp28 any - tmp29 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) - tmp30 := checkDerefVar(var_glojure_DOT_core_first) - tmp31 := lang.Apply(tmp30, []any{v7}) - tmp32 := lang.Apply(tmp29, []any{tmp31}) - if lang.IsTruthy(tmp32) { - tmp33 := checkDerefVar(var_glojure_DOT_core_next) - tmp34 := lang.Apply(tmp33, []any{v7}) - tmp28 = tmp34 - } else { - tmp28 = v7 - } - var v35 any = tmp28 - _ = v35 - // let binding "m" - var tmp36 any - tmp37 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) - tmp38 := checkDerefVar(var_glojure_DOT_core_first) - tmp39 := lang.Apply(tmp38, []any{v35}) - tmp40 := lang.Apply(tmp37, []any{tmp39}) - if lang.IsTruthy(tmp40) { - tmp41 := checkDerefVar(var_glojure_DOT_core_conj) - tmp42 := checkDerefVar(var_glojure_DOT_core_first) - tmp43 := lang.Apply(tmp42, []any{v35}) - tmp44 := lang.Apply(tmp41, []any{v27, tmp43}) - tmp36 = tmp44 - } else { - tmp36 = v27 - } - var v45 any = tmp36 - _ = v45 - // let binding "fdecl" - var tmp46 any - tmp47 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) - tmp48 := checkDerefVar(var_glojure_DOT_core_first) - tmp49 := lang.Apply(tmp48, []any{v35}) - tmp50 := lang.Apply(tmp47, []any{tmp49}) - if lang.IsTruthy(tmp50) { - tmp51 := checkDerefVar(var_glojure_DOT_core_next) - tmp52 := lang.Apply(tmp51, []any{v35}) - tmp46 = tmp52 - } else { - tmp46 = v35 - } - var v53 any = tmp46 - _ = v53 - // let binding "fdecl" - var tmp54 any - tmp55 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) - tmp56 := checkDerefVar(var_glojure_DOT_core_first) - tmp57 := lang.Apply(tmp56, []any{v53}) - tmp58 := lang.Apply(tmp55, []any{tmp57}) - if lang.IsTruthy(tmp58) { - tmp59 := checkDerefVar(var_glojure_DOT_core_list) - tmp60 := lang.Apply(tmp59, []any{v53}) - tmp54 = tmp60 - } else { - tmp54 = v53 - } - var v61 any = tmp54 - _ = v61 - // let binding "m" - var tmp62 any - tmp63 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) - tmp64 := checkDerefVar(var_glojure_DOT_core_last) - tmp65 := lang.Apply(tmp64, []any{v61}) - tmp66 := lang.Apply(tmp63, []any{tmp65}) - if lang.IsTruthy(tmp66) { - tmp67 := checkDerefVar(var_glojure_DOT_core_conj) - tmp68 := checkDerefVar(var_glojure_DOT_core_last) - tmp69 := lang.Apply(tmp68, []any{v61}) - tmp70 := lang.Apply(tmp67, []any{v45, tmp69}) - tmp62 = tmp70 - } else { - tmp62 = v45 - } - var v71 any = tmp62 - _ = v71 - // let binding "fdecl" - var tmp72 any - tmp73 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) - tmp74 := checkDerefVar(var_glojure_DOT_core_last) - tmp75 := lang.Apply(tmp74, []any{v61}) - tmp76 := lang.Apply(tmp73, []any{tmp75}) - if lang.IsTruthy(tmp76) { - tmp77 := checkDerefVar(var_glojure_DOT_core_butlast) - tmp78 := lang.Apply(tmp77, []any{v61}) - tmp72 = tmp78 + // let binding "temp__0__auto__" + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := lang.Apply(tmp6, []any{v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + var tmp10 any + { // let + // let binding "s" + var v11 any = v8 + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_reductions) + tmp13 := checkDerefVar(var_glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v11}) + tmp15 := checkDerefVar(var_glojure_DOT_core_rest) + tmp16 := lang.Apply(tmp15, []any{v11}) + tmp17 := lang.Apply(tmp12, []any{v2, tmp14, tmp16}) + tmp10 = tmp17 + } // end let + tmp9 = tmp10 } else { - tmp72 = v61 - } - var v79 any = tmp72 - _ = v79 - // let binding "m" - tmp80 := checkDerefVar(var_glojure_DOT_core_conj) - tmp81 := checkDerefVar(var_glojure_DOT_core_list) - tmp82 := checkDerefVar(var_glojure_DOT_core_sigs) - tmp83 := lang.Apply(tmp82, []any{v79}) - tmp84 := lang.Apply(tmp81, []any{sym_quote, tmp83}) - tmp85 := lang.NewMap(kw_arglists, tmp84) - tmp86 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(317), kw_column, int(23), kw_end_DASH_line, int(317), kw_end_DASH_column, int(60)) - tmp87, err := lang.WithMeta(tmp85, tmp86.(lang.IPersistentMap)) - if err != nil { - panic(err) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(v2, nil) + tmp13 := lang.Apply(tmp11, []any{tmp12}) + tmp9 = tmp13 } - tmp88 := lang.Apply(tmp80, []any{tmp87, v71}) - var v89 any = tmp88 - _ = v89 - // let binding "m" - var tmp90 any + tmp5 = tmp9 + } // end let + return tmp5 + }) + tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) + return tmp5 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) + tmp7 := lang.Apply(tmp6, []any{v3}) + if lang.IsTruthy(tmp7) { + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := checkDerefVar(var_glojure_DOT_core_deref) + tmp10 := lang.Apply(tmp9, []any{v3}) + tmp11 := lang.Apply(tmp8, []any{tmp10}) + tmp5 = tmp11 + } else { + tmp12 := checkDerefVar(var_glojure_DOT_core_cons) + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp14 any { // let - // let binding "inline" - tmp91 := lang.Apply(kw_inline, []any{v89}) - var v92 any = tmp91 - _ = v92 - // let binding "ifn" - tmp93 := checkDerefVar(var_glojure_DOT_core_first) - tmp94 := lang.Apply(tmp93, []any{v92}) - var v95 any = tmp94 - _ = v95 - // let binding "iname" - tmp96 := checkDerefVar(var_glojure_DOT_core_second) - tmp97 := lang.Apply(tmp96, []any{v92}) - var v98 any = tmp97 - _ = v98 - var tmp99 any - var tmp100 any - tmp101 := lang.Apply(lang.Equiv, []any{sym_fn, v95}) - if lang.IsTruthy(tmp101) { - var tmp102 any - tmp103 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp104 := reflect.TypeOf((*lang.Symbol)(nil)) - tmp105 := lang.Apply(tmp103, []any{tmp104, v98}) - if lang.IsTruthy(tmp105) { - tmp102 = false - } else { - tmp102 = true - } - tmp100 = tmp102 - } else { - } - if lang.IsTruthy(tmp100) { - tmp106 := checkDerefVar(var_glojure_DOT_core_assoc) - tmp107 := checkDerefVar(var_glojure_DOT_core_cons) - tmp108 := checkDerefVar(var_glojure_DOT_core_cons) - tmp109, ok := lang.FieldOrMethod(v6, "Name") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "Name"))) - } - var tmp110 any - switch reflect.TypeOf(tmp109).Kind() { - case reflect.Func: - tmp110 = lang.Apply(tmp109, nil) - default: - tmp110 = tmp109 - } - tmp111 := lang.Apply(lang.ConcatStrings, []any{tmp110, "__inliner"}) - tmp112 := lang.Apply(lang.NewSymbol, []any{tmp111}) - tmp113 := checkDerefVar(var_glojure_DOT_core_next) - tmp114 := lang.Apply(tmp113, []any{v92}) - tmp115 := lang.Apply(tmp108, []any{tmp112, tmp114}) - tmp116 := lang.Apply(tmp107, []any{v95, tmp115}) - tmp117 := lang.Apply(tmp106, []any{v89, kw_inline, tmp116}) - tmp99 = tmp117 + // let binding "temp__0__auto__" + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := lang.Apply(tmp15, []any{v4}) + var v17 any = tmp16 + _ = v17 + var tmp18 any + if lang.IsTruthy(v17) { + var tmp19 any + { // let + // let binding "s" + var v20 any = v17 + _ = v20 + tmp21 := checkDerefVar(var_glojure_DOT_core_reductions) + tmp22 := checkDerefVar(var_glojure_DOT_core_first) + tmp23 := lang.Apply(tmp22, []any{v20}) + tmp24 := lang.Apply(v2, []any{v3, tmp23}) + tmp25 := checkDerefVar(var_glojure_DOT_core_rest) + tmp26 := lang.Apply(tmp25, []any{v20}) + tmp27 := lang.Apply(tmp21, []any{v2, tmp24, tmp26}) + tmp19 = tmp27 + } // end let + tmp18 = tmp19 } else { - tmp99 = v89 } - tmp90 = tmp99 + tmp14 = tmp18 } // end let - var v91 any = tmp90 - _ = v91 - // let binding "m" - tmp92 := checkDerefVar(var_glojure_DOT_core_conj) - var tmp93 any - tmp94 := checkDerefVar(var_glojure_DOT_core_meta) - tmp95 := lang.Apply(tmp94, []any{v6}) - if lang.IsTruthy(tmp95) { - tmp96 := checkDerefVar(var_glojure_DOT_core_meta) - tmp97 := lang.Apply(tmp96, []any{v6}) - tmp93 = tmp97 - } else { - tmp98 := lang.NewMap() - tmp99 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(328), kw_column, int(51), kw_end_DASH_line, int(328), kw_end_DASH_column, int(52)) - tmp100, err := lang.WithMeta(tmp98, tmp99.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp93 = tmp100 - } - tmp101 := lang.Apply(tmp92, []any{tmp93, v91}) - var v102 any = tmp101 - _ = v102 - tmp103 := checkDerefVar(var_glojure_DOT_core_list) - tmp104 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) - tmp105 := lang.Apply(tmp104, []any{v6, v102}) - tmp106 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) - tmp107 := checkDerefVar(var_glojure_DOT_core_cons) - tmp108 := lang.Apply(tmp107, []any{sym_glojure_DOT_core_SLASH_fn, v79}) - tmp109 := lang.Apply(kw_tag, []any{v102}) - tmp110 := lang.NewMap(kw_rettag, tmp109) - tmp111 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(333), kw_column, int(37), kw_end_DASH_line, int(333), kw_end_DASH_column, int(54)) - tmp112, err := lang.WithMeta(tmp110, tmp111.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp113 := lang.Apply(tmp106, []any{tmp108, tmp112}) - tmp114 := lang.Apply(tmp103, []any{sym_def, tmp105, tmp113}) - tmp13 = tmp114 - } // end let - return tmp13 + return tmp14 + }) + tmp14 := lang.Apply(lang.NewLazySeq, []any{tmp13}) + tmp15 := lang.Apply(tmp12, []any{v3, tmp14}) + tmp5 = tmp15 } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(291), kw_column, int(7), kw_end_DASH_line, int(333), kw_end_DASH_column, int(58))).(lang.FnFunc) - v3 = tmp2 - _ = v3 - } - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_reductions = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_reductions.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // defn- + // refer-glojure { - tmp0 := sym_defn_DASH_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym__AMP_, sym_decls)), kw_doc, "same as defn, yielding non-public def", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(11), kw_line, int(4949), kw_end_DASH_line, int(4949))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_refer_DASH_glojure.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_filters)), kw_doc, "Same as (refer 'glojure.core )", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(11), kw_line, int(5800), kw_end_DASH_line, int(5800))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) - v3 := args[0] + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + var v4 any = lang.NewList(args[2:]...) _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - tmp7 := checkDerefVar(var_glojure_DOT_core_list_STAR_) - tmp8 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) - tmp9 := checkDerefVar(var_glojure_DOT_core_assoc) - tmp10 := checkDerefVar(var_glojure_DOT_core_meta) - tmp11 := lang.Apply(tmp10, []any{v5}) - tmp12 := lang.Apply(tmp9, []any{tmp11, kw_private, true}) - tmp13 := lang.Apply(tmp8, []any{v5, tmp12}) - tmp14 := lang.Apply(tmp7, []any{sym_glojure_DOT_core_SLASH_defn, tmp13, v6}) - return tmp14 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym_glojure_DOT_core_SLASH_refer}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := checkDerefVar(var_glojure_DOT_core_seq) + tmp11 := checkDerefVar(var_glojure_DOT_core_concat) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_quote}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core}) + tmp16 := lang.Apply(tmp11, []any{tmp13, tmp15}) + tmp17 := lang.Apply(tmp10, []any{tmp16}) + tmp18 := lang.Apply(tmp9, []any{tmp17}) + tmp19 := lang.Apply(tmp6, []any{tmp8, tmp18, v4}) + tmp20 := lang.Apply(tmp5, []any{tmp19}) + return tmp20 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_refer_DASH_glojure = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_refer_DASH_glojure.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // defonce + // rem { - tmp0 := sym_defonce.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym_expr)), kw_doc, "defs name to have the root value of the expr iff the named var has no root value,\n else expr is unevaluated", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(5806), kw_end_DASH_line, int(5806))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function rem__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Remainder}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_rem.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_num, sym_div)), kw_inline, tmp1, kw_doc, "remainder of dividing numerator by denominator.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(1274), kw_end_DASH_line, int(1274))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 4) + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - tmp7 := checkDerefVar(var_glojure_DOT_core_seq) - tmp8 := checkDerefVar(var_glojure_DOT_core_concat) - tmp9 := checkDerefVar(var_glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_core_SLASH_let}) - tmp11 := checkDerefVar(var_glojure_DOT_core_list) - tmp12 := checkDerefVar(var_glojure_DOT_core_apply) - tmp13 := checkDerefVar(var_glojure_DOT_core_vector) - tmp14 := checkDerefVar(var_glojure_DOT_core_seq) - tmp15 := checkDerefVar(var_glojure_DOT_core_concat) - tmp16 := checkDerefVar(var_glojure_DOT_core_list) - tmp17 := lang.Apply(tmp16, []any{sym_v__0__auto__}) - tmp18 := checkDerefVar(var_glojure_DOT_core_list) - tmp19 := checkDerefVar(var_glojure_DOT_core_seq) - tmp20 := checkDerefVar(var_glojure_DOT_core_concat) - tmp21 := checkDerefVar(var_glojure_DOT_core_list) - tmp22 := lang.Apply(tmp21, []any{sym_def}) - tmp23 := checkDerefVar(var_glojure_DOT_core_list) - tmp24 := lang.Apply(tmp23, []any{v5}) - tmp25 := lang.Apply(tmp20, []any{tmp22, tmp24}) - tmp26 := lang.Apply(tmp19, []any{tmp25}) - tmp27 := lang.Apply(tmp18, []any{tmp26}) - tmp28 := lang.Apply(tmp15, []any{tmp17, tmp27}) - tmp29 := lang.Apply(tmp14, []any{tmp28}) - tmp30 := lang.Apply(tmp12, []any{tmp13, tmp29}) - tmp31 := lang.Apply(tmp11, []any{tmp30}) - tmp32 := checkDerefVar(var_glojure_DOT_core_list) - tmp33 := checkDerefVar(var_glojure_DOT_core_seq) - tmp34 := checkDerefVar(var_glojure_DOT_core_concat) - tmp35 := checkDerefVar(var_glojure_DOT_core_list) - tmp36 := lang.Apply(tmp35, []any{sym_glojure_DOT_core_SLASH_when_DASH_not}) - tmp37 := checkDerefVar(var_glojure_DOT_core_list) - tmp38 := checkDerefVar(var_glojure_DOT_core_seq) - tmp39 := checkDerefVar(var_glojure_DOT_core_concat) - tmp40 := checkDerefVar(var_glojure_DOT_core_list) - tmp41 := lang.Apply(tmp40, []any{sym__DOT_HasRoot}) - tmp42 := checkDerefVar(var_glojure_DOT_core_list) - tmp43 := lang.Apply(tmp42, []any{sym_v__0__auto__}) - tmp44 := lang.Apply(tmp39, []any{tmp41, tmp43}) - tmp45 := lang.Apply(tmp38, []any{tmp44}) - tmp46 := lang.Apply(tmp37, []any{tmp45}) - tmp47 := checkDerefVar(var_glojure_DOT_core_list) - tmp48 := checkDerefVar(var_glojure_DOT_core_seq) - tmp49 := checkDerefVar(var_glojure_DOT_core_concat) - tmp50 := checkDerefVar(var_glojure_DOT_core_list) - tmp51 := lang.Apply(tmp50, []any{sym_def}) - tmp52 := checkDerefVar(var_glojure_DOT_core_list) - tmp53 := lang.Apply(tmp52, []any{v5}) - tmp54 := checkDerefVar(var_glojure_DOT_core_list) - tmp55 := lang.Apply(tmp54, []any{v6}) - tmp56 := lang.Apply(tmp49, []any{tmp51, tmp53, tmp55}) - tmp57 := lang.Apply(tmp48, []any{tmp56}) - tmp58 := lang.Apply(tmp47, []any{tmp57}) - tmp59 := lang.Apply(tmp34, []any{tmp36, tmp46, tmp58}) - tmp60 := lang.Apply(tmp33, []any{tmp59}) - tmp61 := lang.Apply(tmp32, []any{tmp60}) - tmp62 := lang.Apply(tmp8, []any{tmp10, tmp31, tmp61}) - tmp63 := lang.Apply(tmp7, []any{tmp62}) - return tmp63 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Remainder") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Remainder is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core_rem = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_rem.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // defprotocol + // remove-tap { - tmp0 := sym_defprotocol.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym__AMP_, sym_opts_PLUS_sigs)), kw_doc, "A protocol is a named set of named methods and their signatures:\n (defprotocol AProtocolName\n\n ;optional doc string\n \"A doc string for AProtocol abstraction\"\n\n ;options\n :extend-via-metadata true\n\n ;method signatures\n (bar [this a b] \"bar docs\")\n (baz [this a] [this a b] [this a b c] \"baz docs\"))\n\n No implementations are provided. Docs can be specified for the\n protocol overall and for each method. The above yields a set of\n polymorphic functions and a protocol object. All are\n namespace-qualified by the ns enclosing the definition The resulting\n functions dispatch on the type of their first argument, which is\n required and corresponds to the implicit target object ('this' in \n Java parlance). defprotocol is dynamic, has no special compile-time \n effect, and defines no new types or classes. Implementations of \n the protocol methods can be provided using extend.\n\n When :extend-via-metadata is true, values can extend protocols by\n adding metadata where keys are fully-qualified protocol function\n symbols and values are function implementations. Protocol\n implementations are checked first for direct definitions (defrecord,\n deftype, reify), then metadata definitions, then external\n extensions (extend, extend-type, extend-protocol)\n\n defprotocol will automatically generate a corresponding interface,\n with the same name as the protocol, i.e. given a protocol:\n my.ns/Protocol, an interface: my.ns.Protocol. The interface will\n have methods corresponding to the protocol functions, and the\n protocol will automatically work with instances of the interface.\n\n Note that you should not use this interface with deftype or\n reify, as they support the protocol directly:\n\n (defprotocol P \n (foo [this]) \n (bar-me [this] [this y]))\n\n (deftype Foo [a b c] \n P\n (foo [this] a)\n (bar-me [this] b)\n (bar-me [this y] (+ c y)))\n \n (bar-me (Foo. 1 2 3) 42)\n => 45\n\n (foo \n (let [x 42]\n (reify P \n (foo [this] 17)\n (bar-me [this] x)\n (bar-me [this y] x))))\n => 17", kw_file, "glojure/core_deftype.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(11), kw_line, int(28), kw_end_DASH_line, int(28))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_remove_DASH_tap.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f)), kw_doc, "Remove f from the tap set.", kw_file, "glojure/core.glj", kw_added, "1.10", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(7883), kw_end_DASH_line, int(7883))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_swap_BANG_) + tmp4 := checkDerefVar(var_glojure_DOT_core_tapset) + tmp5 := checkDerefVar(var_glojure_DOT_core_disj) + tmp6 := lang.Apply(tmp3, []any{tmp4, tmp5, v2}) + _ = tmp6 + return nil + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_remove_DASH_tap = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_remove_DASH_tap.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // resolve + { + tmp0 := sym_resolve.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_sym), lang.NewVector(sym_env, sym_sym)), kw_doc, "same as (ns-resolve *ns* symbol) or (ns-resolve *ns* &env symbol)", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4371), kw_end_DASH_line, int(4371))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - default: - checkArity(args, 3) - v3 := args[0] + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_ns_DASH_resolve) + tmp4 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any - { // let - // let binding "doc" - var tmp8 any - tmp9 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) - tmp10 := checkDerefVar(var_glojure_DOT_core_first) - tmp11 := lang.Apply(tmp10, []any{v6}) - tmp12 := lang.Apply(tmp9, []any{tmp11}) - if lang.IsTruthy(tmp12) { - tmp13 := checkDerefVar(var_glojure_DOT_core_first) - tmp14 := lang.Apply(tmp13, []any{v6}) - tmp8 = tmp14 - } else { - } - var v15 any = tmp8 - _ = v15 - // let binding "opts+sigs" - var tmp16 any - if lang.IsTruthy(v15) { - tmp17 := checkDerefVar(var_glojure_DOT_core_rest) - tmp18 := lang.Apply(tmp17, []any{v6}) - tmp16 = tmp18 - } else { - tmp16 = v6 - } - var v19 any = tmp16 - _ = v19 - // let binding "opts" - tmp20 := checkDerefVar(var_glojure_DOT_core_take_DASH_while) - var tmp21 lang.FnFunc - tmp21 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v22 := args[0] - _ = v22 - tmp23 := checkDerefVar(var_glojure_DOT_core_not) - tmp24 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) - tmp25 := lang.Apply(tmp24, []any{v22}) - tmp26 := lang.Apply(tmp23, []any{tmp25}) - return tmp26 - }) - tmp22 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(92), kw_column, int(26), kw_end_DASH_line, int(92), kw_end_DASH_column, int(40)) - tmp23, err := lang.WithMeta(tmp21, tmp22.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp24 := lang.Apply(tmp20, []any{tmp23, v19}) - var v25 any = tmp24 - _ = v25 - // let binding "sigs" - tmp26 := checkDerefVar(var_glojure_DOT_core_drop_DASH_while) - var tmp27 lang.FnFunc - tmp27 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v28 := args[0] - _ = v28 - tmp29 := checkDerefVar(var_glojure_DOT_core_not) - tmp30 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) - tmp31 := lang.Apply(tmp30, []any{v28}) - tmp32 := lang.Apply(tmp29, []any{tmp31}) - return tmp32 - }) - tmp28 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(93), kw_column, int(26), kw_end_DASH_line, int(93), kw_end_DASH_column, int(40)) - tmp29, err := lang.WithMeta(tmp27, tmp28.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp30 := lang.Apply(tmp26, []any{tmp29, v19}) - var v31 any = tmp30 - _ = v31 - // let binding "opts" - var tmp32 any - tmp33 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp34 := lang.Apply(tmp33, []any{v31, v25}) - if lang.IsTruthy(tmp34) { - } else { - tmp32 = v25 - } - var v35 any = tmp32 - _ = v35 - tmp36 := checkDerefVar(var_glojure_DOT_core_seq) - tmp37 := checkDerefVar(var_glojure_DOT_core_concat) - tmp38 := checkDerefVar(var_glojure_DOT_core_list) - tmp39 := lang.Apply(tmp38, []any{sym_do}) - tmp40 := checkDerefVar(var_glojure_DOT_core_list) - tmp41 := checkDerefVar(var_glojure_DOT_core_seq) - tmp42 := checkDerefVar(var_glojure_DOT_core_concat) - tmp43 := checkDerefVar(var_glojure_DOT_core_list) - tmp44 := lang.Apply(tmp43, []any{sym_def}) - tmp45 := checkDerefVar(var_glojure_DOT_core_list) - tmp46 := lang.Apply(tmp45, []any{v5}) - tmp47 := checkDerefVar(var_glojure_DOT_core_list) - tmp48 := checkDerefVar(var_glojure_DOT_core_seq) - tmp49 := checkDerefVar(var_glojure_DOT_core_concat) - tmp50 := checkDerefVar(var_glojure_DOT_core_list) - tmp51 := lang.Apply(tmp50, []any{sym_glojure_DOT_core_SLASH_atom}) - tmp52 := checkDerefVar(var_glojure_DOT_core_list) - tmp53 := checkDerefVar(var_glojure_DOT_core_apply) - tmp54 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) - tmp55 := checkDerefVar(var_glojure_DOT_core_seq) - tmp56 := checkDerefVar(var_glojure_DOT_core_concat) - tmp57 := checkDerefVar(var_glojure_DOT_core_list) - tmp58 := lang.Apply(tmp57, []any{kw_on_DASH_interface}) - tmp59 := checkDerefVar(var_glojure_DOT_core_list) - tmp60 := lang.Apply(tmp59, []any{true}) - tmp61 := checkDerefVar(var_glojure_DOT_core_list) - tmp62 := lang.Apply(tmp61, []any{kw_sigs}) - tmp63 := checkDerefVar(var_glojure_DOT_core_list) - tmp64 := checkDerefVar(var_glojure_DOT_core_seq) - tmp65 := checkDerefVar(var_glojure_DOT_core_concat) - tmp66 := checkDerefVar(var_glojure_DOT_core_list) - tmp67 := lang.Apply(tmp66, []any{sym_quote}) - tmp68 := checkDerefVar(var_glojure_DOT_core_list) - tmp69 := lang.Apply(tmp68, []any{v31}) - tmp70 := lang.Apply(tmp65, []any{tmp67, tmp69}) - tmp71 := lang.Apply(tmp64, []any{tmp70}) - tmp72 := lang.Apply(tmp63, []any{tmp71}) - tmp73 := checkDerefVar(var_glojure_DOT_core_list) - tmp74 := lang.Apply(tmp73, []any{kw_multis}) - tmp75 := checkDerefVar(var_glojure_DOT_core_list) - tmp76 := checkDerefVar(var_glojure_DOT_core_apply) - tmp77 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) - tmp78 := checkDerefVar(var_glojure_DOT_core_seq) - tmp79 := checkDerefVar(var_glojure_DOT_core_concat) - tmp80 := lang.Apply(tmp79, nil) - tmp81 := lang.Apply(tmp78, []any{tmp80}) - tmp82 := lang.Apply(tmp76, []any{tmp77, tmp81}) - tmp83 := lang.Apply(tmp75, []any{tmp82}) - tmp84 := lang.Apply(tmp56, []any{tmp58, tmp60, tmp62, tmp72, tmp74, tmp83}) - tmp85 := lang.Apply(tmp55, []any{tmp84}) - tmp86 := lang.Apply(tmp53, []any{tmp54, tmp85}) - tmp87 := lang.Apply(tmp52, []any{tmp86}) - tmp88 := lang.Apply(tmp49, []any{tmp51, tmp87}) - tmp89 := lang.Apply(tmp48, []any{tmp88}) - tmp90 := lang.Apply(tmp47, []any{tmp89}) - tmp91 := lang.Apply(tmp42, []any{tmp44, tmp46, tmp90}) - tmp92 := lang.Apply(tmp41, []any{tmp91}) - tmp93 := lang.Apply(tmp40, []any{tmp92}) - tmp94 := checkDerefVar(var_glojure_DOT_core_list) - tmp95 := checkDerefVar(var_glojure_DOT_core_seq) - tmp96 := checkDerefVar(var_glojure_DOT_core_concat) - tmp97 := checkDerefVar(var_glojure_DOT_core_list) - tmp98 := lang.Apply(tmp97, []any{sym_glojure_DOT_core_SLASH_swap_BANG_}) - tmp99 := checkDerefVar(var_glojure_DOT_core_list) - tmp100 := lang.Apply(tmp99, []any{sym_glojure_DOT_core_SLASH__DASH_protocols}) - tmp101 := checkDerefVar(var_glojure_DOT_core_list) - tmp102 := lang.Apply(tmp101, []any{sym_glojure_DOT_core_SLASH_assoc}) - tmp103 := checkDerefVar(var_glojure_DOT_core_list) - tmp104 := checkDerefVar(var_glojure_DOT_core_seq) - tmp105 := checkDerefVar(var_glojure_DOT_core_concat) - tmp106 := checkDerefVar(var_glojure_DOT_core_list) - tmp107 := lang.Apply(tmp106, []any{sym_quote}) - tmp108 := checkDerefVar(var_glojure_DOT_core_list) - tmp109 := lang.Apply(tmp108, []any{v5}) - tmp110 := lang.Apply(tmp105, []any{tmp107, tmp109}) - tmp111 := lang.Apply(tmp104, []any{tmp110}) - tmp112 := lang.Apply(tmp103, []any{tmp111}) - tmp113 := checkDerefVar(var_glojure_DOT_core_list) - tmp114 := lang.Apply(tmp113, []any{v5}) - tmp115 := lang.Apply(tmp96, []any{tmp98, tmp100, tmp102, tmp112, tmp114}) - tmp116 := lang.Apply(tmp95, []any{tmp115}) - tmp117 := lang.Apply(tmp94, []any{tmp116}) - tmp118 := checkDerefVar(var_glojure_DOT_core_map) - var tmp119 lang.FnFunc - tmp119 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v120 := args[0] - _ = v120 - tmp121 := checkDerefVar(var_glojure_DOT_core_seq) - tmp122 := checkDerefVar(var_glojure_DOT_core_concat) - tmp123 := checkDerefVar(var_glojure_DOT_core_list) - tmp124 := lang.Apply(tmp123, []any{sym_do}) - tmp125 := checkDerefVar(var_glojure_DOT_core_list) - tmp126 := checkDerefVar(var_glojure_DOT_core_seq) - tmp127 := checkDerefVar(var_glojure_DOT_core_concat) - tmp128 := checkDerefVar(var_glojure_DOT_core_list) - tmp129 := lang.Apply(tmp128, []any{sym_glojure_DOT_core_SLASH_defmulti}) - tmp130 := checkDerefVar(var_glojure_DOT_core_list) - tmp131 := checkDerefVar(var_glojure_DOT_core_first) - tmp132 := lang.Apply(tmp131, []any{v120}) - tmp133 := lang.Apply(tmp130, []any{tmp132}) - tmp134 := checkDerefVar(var_glojure_DOT_core_list) - tmp135 := checkDerefVar(var_glojure_DOT_core_seq) - tmp136 := checkDerefVar(var_glojure_DOT_core_concat) - tmp137 := checkDerefVar(var_glojure_DOT_core_list) - tmp138 := lang.Apply(tmp137, []any{sym_glojure_DOT_core_SLASH_fn}) - tmp139 := checkDerefVar(var_glojure_DOT_core_list) - tmp140 := checkDerefVar(var_glojure_DOT_core_apply) - tmp141 := checkDerefVar(var_glojure_DOT_core_vector) - tmp142 := checkDerefVar(var_glojure_DOT_core_seq) - tmp143 := checkDerefVar(var_glojure_DOT_core_concat) - tmp144 := checkDerefVar(var_glojure_DOT_core_list) - tmp145 := lang.Apply(tmp144, []any{sym_this}) - tmp146 := checkDerefVar(var_glojure_DOT_core_list) - tmp147 := lang.Apply(tmp146, []any{sym__AMP_}) - tmp148 := checkDerefVar(var_glojure_DOT_core_list) - tmp149 := lang.Apply(tmp148, []any{sym_args}) - tmp150 := lang.Apply(tmp143, []any{tmp145, tmp147, tmp149}) - tmp151 := lang.Apply(tmp142, []any{tmp150}) - tmp152 := lang.Apply(tmp140, []any{tmp141, tmp151}) - tmp153 := lang.Apply(tmp139, []any{tmp152}) - tmp154 := checkDerefVar(var_glojure_DOT_core_list) - tmp155 := checkDerefVar(var_glojure_DOT_core_seq) - tmp156 := checkDerefVar(var_glojure_DOT_core_concat) - tmp157 := checkDerefVar(var_glojure_DOT_core_list) - tmp158 := lang.Apply(tmp157, []any{sym_glojure_DOT_core_SLASH_class}) - tmp159 := checkDerefVar(var_glojure_DOT_core_list) - tmp160 := lang.Apply(tmp159, []any{sym_this}) - tmp161 := lang.Apply(tmp156, []any{tmp158, tmp160}) - tmp162 := lang.Apply(tmp155, []any{tmp161}) - tmp163 := lang.Apply(tmp154, []any{tmp162}) - tmp164 := lang.Apply(tmp136, []any{tmp138, tmp153, tmp163}) - tmp165 := lang.Apply(tmp135, []any{tmp164}) - tmp166 := lang.Apply(tmp134, []any{tmp165}) - tmp167 := lang.Apply(tmp127, []any{tmp129, tmp133, tmp166}) - tmp168 := lang.Apply(tmp126, []any{tmp167}) - tmp169 := lang.Apply(tmp125, []any{tmp168}) - tmp170 := checkDerefVar(var_glojure_DOT_core_list) - tmp171 := checkDerefVar(var_glojure_DOT_core_seq) - tmp172 := checkDerefVar(var_glojure_DOT_core_concat) - tmp173 := checkDerefVar(var_glojure_DOT_core_list) - tmp174 := lang.Apply(tmp173, []any{sym_glojure_DOT_core_SLASH_swap_BANG_}) - tmp175 := checkDerefVar(var_glojure_DOT_core_list) - tmp176 := lang.Apply(tmp175, []any{v5}) - tmp177 := checkDerefVar(var_glojure_DOT_core_list) - tmp178 := lang.Apply(tmp177, []any{sym_glojure_DOT_core_SLASH_assoc_DASH_in}) - tmp179 := checkDerefVar(var_glojure_DOT_core_list) - tmp180 := checkDerefVar(var_glojure_DOT_core_apply) - tmp181 := checkDerefVar(var_glojure_DOT_core_vector) - tmp182 := checkDerefVar(var_glojure_DOT_core_seq) - tmp183 := checkDerefVar(var_glojure_DOT_core_concat) - tmp184 := checkDerefVar(var_glojure_DOT_core_list) - tmp185 := lang.Apply(tmp184, []any{kw_multis}) - tmp186 := checkDerefVar(var_glojure_DOT_core_list) - tmp187 := checkDerefVar(var_glojure_DOT_core_seq) - tmp188 := checkDerefVar(var_glojure_DOT_core_concat) - tmp189 := checkDerefVar(var_glojure_DOT_core_list) - tmp190 := lang.Apply(tmp189, []any{sym_glojure_DOT_core_SLASH_keyword}) - tmp191 := checkDerefVar(var_glojure_DOT_core_list) - tmp192 := checkDerefVar(var_glojure_DOT_core_seq) - tmp193 := checkDerefVar(var_glojure_DOT_core_concat) - tmp194 := checkDerefVar(var_glojure_DOT_core_list) - tmp195 := lang.Apply(tmp194, []any{sym_quote}) - tmp196 := checkDerefVar(var_glojure_DOT_core_list) - tmp197 := checkDerefVar(var_glojure_DOT_core_first) - tmp198 := lang.Apply(tmp197, []any{v120}) - tmp199 := lang.Apply(tmp196, []any{tmp198}) - tmp200 := lang.Apply(tmp193, []any{tmp195, tmp199}) - tmp201 := lang.Apply(tmp192, []any{tmp200}) - tmp202 := lang.Apply(tmp191, []any{tmp201}) - tmp203 := lang.Apply(tmp188, []any{tmp190, tmp202}) - tmp204 := lang.Apply(tmp187, []any{tmp203}) - tmp205 := lang.Apply(tmp186, []any{tmp204}) - tmp206 := lang.Apply(tmp183, []any{tmp185, tmp205}) - tmp207 := lang.Apply(tmp182, []any{tmp206}) - tmp208 := lang.Apply(tmp180, []any{tmp181, tmp207}) - tmp209 := lang.Apply(tmp179, []any{tmp208}) - tmp210 := checkDerefVar(var_glojure_DOT_core_list) - tmp211 := checkDerefVar(var_glojure_DOT_core_first) - tmp212 := lang.Apply(tmp211, []any{v120}) - tmp213 := lang.Apply(tmp210, []any{tmp212}) - tmp214 := lang.Apply(tmp172, []any{tmp174, tmp176, tmp178, tmp209, tmp213}) - tmp215 := lang.Apply(tmp171, []any{tmp214}) - tmp216 := lang.Apply(tmp170, []any{tmp215}) - tmp217 := lang.Apply(tmp122, []any{tmp124, tmp169, tmp216}) - tmp218 := lang.Apply(tmp121, []any{tmp217}) - return tmp218 - }) - tmp120 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(102), kw_column, int(13), kw_end_DASH_line, int(104), kw_end_DASH_column, int(90)) - tmp121, err := lang.WithMeta(tmp119, tmp120.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp122 := lang.Apply(tmp118, []any{tmp121, v31}) - tmp123 := checkDerefVar(var_glojure_DOT_core_list) - tmp124 := checkDerefVar(var_glojure_DOT_core_seq) - tmp125 := checkDerefVar(var_glojure_DOT_core_concat) - tmp126 := checkDerefVar(var_glojure_DOT_core_list) - tmp127 := lang.Apply(tmp126, []any{sym_var}) - tmp128 := checkDerefVar(var_glojure_DOT_core_list) - tmp129 := lang.Apply(tmp128, []any{v5}) - tmp130 := lang.Apply(tmp125, []any{tmp127, tmp129}) - tmp131 := lang.Apply(tmp124, []any{tmp130}) - tmp132 := lang.Apply(tmp123, []any{tmp131}) - tmp133 := lang.Apply(tmp37, []any{tmp39, tmp93, tmp117, tmp122, tmp132}) - tmp134 := lang.Apply(tmp36, []any{tmp133}) - tmp7 = tmp134 - } // end let - return tmp7 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // defstruct - { - tmp0 := sym_defstruct.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym__AMP_, sym_keys)), kw_doc, "Same as (def name (create-struct keys...))", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(11), kw_line, int(4044), kw_end_DASH_line, int(4044))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { + tmp4 := checkDerefVar(var_glojure_DOT_core_ns_DASH_resolve) + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp6 := lang.Apply(tmp4, []any{tmp5, v2, v3}) + return tmp6 default: - checkArity(args, 3) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - tmp7 := checkDerefVar(var_glojure_DOT_core_seq) - tmp8 := checkDerefVar(var_glojure_DOT_core_concat) - tmp9 := checkDerefVar(var_glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{sym_def}) - tmp11 := checkDerefVar(var_glojure_DOT_core_list) - tmp12 := lang.Apply(tmp11, []any{v5}) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := checkDerefVar(var_glojure_DOT_core_seq) - tmp15 := checkDerefVar(var_glojure_DOT_core_concat) - tmp16 := checkDerefVar(var_glojure_DOT_core_list) - tmp17 := lang.Apply(tmp16, []any{sym_glojure_DOT_core_SLASH_create_DASH_struct}) - tmp18 := lang.Apply(tmp15, []any{tmp17, v6}) - tmp19 := lang.Apply(tmp14, []any{tmp18}) - tmp20 := lang.Apply(tmp13, []any{tmp19}) - tmp21 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp20}) - tmp22 := lang.Apply(tmp7, []any{tmp21}) - return tmp22 + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_resolve = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_resolve.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // delay + // reverse { - tmp0 := sym_delay.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_body)), kw_doc, "Takes a body of expressions and yields a Delay object that will\n invoke the body only the first time it is forced (with force or deref/@), and\n will cache the result and return it on all subsequent force\n calls. See also - realized?", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(11), kw_line, int(739), kw_end_DASH_line, int(739))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - tmp6 := checkDerefVar(var_glojure_DOT_core_list) - tmp7 := checkDerefVar(var_glojure_DOT_core_list_STAR_) - tmp8 := lang.NewVector() - tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(746), kw_column, int(62), kw_end_DASH_line, int(746), kw_end_DASH_column, int(63)) - tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp11 := lang.Apply(tmp7, []any{sym_fn_STAR_, tmp10, v5}) - tmp12 := lang.Apply(tmp6, []any{sym_new, sym_glojure_DOT_lang_DOT_Delay, tmp11}) - return tmp12 - } + tmp0 := sym_reverse.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a seq of the items in coll in reverse order. Not lazy.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(940), kw_end_DASH_line, int(940))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp4 := checkDerefVar(var_glojure_DOT_core_conj) + tmp5 := lang.Apply(tmp3, []any{tmp4, lang.NewList(), v2}) + return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_reverse = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_reverse.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // delay? + // root-resource { - tmp0 := sym_delay_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "returns true if x is a Delay created with delay", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(748), kw_end_DASH_line, int(748))).(*lang.Symbol) + tmp1 := reflect.TypeOf("") + tmp0 := sym_root_DASH_resource.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_lib)), kw_doc, "Returns the root directory path for a lib", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(8), kw_line, int(5864), kw_end_DASH_line, int(5864), kw_private, true)).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp5 := lang.Apply(tmp4, []any{nil, v3}) - return tmp5 + tmp4 := checkDerefVar(var_glojure_DOT_core_str) + tmp5 := checkDerefVar(var_glojure_DOT_core_name) + tmp6 := lang.Apply(tmp5, []any{v3}) + tmp7 := lang.Apply(strings11.ReplaceAll, []any{tmp6, "-", "_"}) + tmp8 := lang.Apply(strings11.ReplaceAll, []any{tmp7, ".", "/"}) + tmp9 := lang.Apply(tmp4, []any{lang.NewChar(47), tmp8}) + return tmp9 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp3 := reflect.TypeOf("") + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_root_DASH_resource = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_root_DASH_resource.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // deliver + // select-keys { - tmp0 := sym_deliver.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_promise, sym_val)), kw_doc, "Delivers the supplied value to the promise, releasing any pending\n derefs. A subsequent call to deliver on a promise will have no effect.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(7109), kw_end_DASH_line, int(7109))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_select_DASH_keys.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_map, sym_keyseq)), kw_doc, "Returns a map containing only those entries in map whose key is in keys", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(1536), kw_end_DASH_line, int(1536))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 2) - v3 := args[0] + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.Apply(v3, []any{v4}) - return tmp5 + var tmp4 any + { // let + // let binding "ret" + tmp5 := lang.NewMap() + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(1541), kw_column, int(16), kw_end_DASH_line, int(1541), kw_end_DASH_column, int(17)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v8 any = tmp7 + _ = v8 + // let binding "keys" + tmp9 := checkDerefVar(var_glojure_DOT_core_seq) + tmp10 := lang.Apply(tmp9, []any{v3}) + var v11 any = tmp10 + _ = v11 + for { + var tmp12 any + if lang.IsTruthy(v11) { + var tmp13 any + { // let + // let binding "entry" + tmp14 := checkDerefVar(var_glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v11}) + tmp16, _ := lang.FieldOrMethod(runtime.RT, "Find") + if reflect.TypeOf(tmp16).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Find is not a function"))) + } + tmp17 := lang.Apply(tmp16, []any{v2, tmp15}) + var v18 any = tmp17 + _ = v18 + var tmp20 any + if lang.IsTruthy(v18) { + tmp21 := checkDerefVar(var_glojure_DOT_core_conj) + tmp22 := lang.Apply(tmp21, []any{v8, v18}) + tmp20 = tmp22 + } else { + tmp20 = v8 + } + var tmp19 any = tmp20 + tmp24 := checkDerefVar(var_glojure_DOT_core_next) + tmp25 := lang.Apply(tmp24, []any{v11}) + var tmp23 any = tmp25 + v8 = tmp19 + v11 = tmp23 + continue + } // end let + tmp12 = tmp13 + } else { + tmp14 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp15 := checkDerefVar(var_glojure_DOT_core_meta) + tmp16 := lang.Apply(tmp15, []any{v2}) + tmp17 := lang.Apply(tmp14, []any{v8, tmp16}) + tmp12 = tmp17 + } + tmp4 = tmp12 + break + } + } // end let + return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_select_DASH_keys = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_select_DASH_keys.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // denominator + // seq-to-map-for-destructuring { - tmp1 := reflect.TypeOf((*big9.Int)(nil)) - tmp0 := sym_denominator.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_r)), kw_doc, "Returns the denominator part of a Ratio.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(3591), kw_end_DASH_line, int(3591))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_seq_DASH_to_DASH_map_DASH_for_DASH_destructuring.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_doc, "Builds a map from a seq as described in\n https://glojure.org/reference/special_forms#keyword-arguments", kw_file, "glojure/core.glj", kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(34), kw_column, int(7), kw_line, int(4390), kw_end_DASH_line, int(4390))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5, ok := lang.FieldOrMethod(v4, "denominator") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "denominator"))) - } - var tmp6 any - switch reflect.TypeOf(tmp5).Kind() { - case reflect.Func: - tmp6 = lang.Apply(tmp5, nil) - default: - tmp6 = tmp5 + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_next) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + tmp6 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) + tmp7 := lang.Apply(tmp6, []any{v2}) + tmp8 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{tmp7}) + tmp3 = tmp8 + } else { + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_seq) + tmp11 := lang.Apply(tmp10, []any{v2}) + if lang.IsTruthy(tmp11) { + tmp12 := checkDerefVar(var_glojure_DOT_core_first) + tmp13 := lang.Apply(tmp12, []any{v2}) + tmp9 = tmp13 + } else { + } + tmp3 = tmp9 } - return tmp6 + return tmp3 }) - tmp4 := reflect.TypeOf((*big9.Int)(nil)) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_seq_DASH_to_DASH_map_DASH_for_DASH_destructuring = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_seq_DASH_to_DASH_map_DASH_for_DASH_destructuring.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // deref + // set { - tmp0 := sym_deref.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ref), lang.NewVector(sym_ref, sym_timeout_DASH_ms, sym_timeout_DASH_val)), kw_doc, "Also reader macro: @ref/@agent/@var/@atom/@delay/@future/@promise. Within a transaction,\n returns the in-transaction-value of ref, else returns the\n most-recently-committed value of ref. When applied to a var, agent\n or atom, returns its current state. When applied to a delay, forces\n it if not already forced. When applied to a future, will block if\n computation not complete. When applied to a promise, will block\n until a value is delivered. The variant taking a timeout can be\n used for blocking references (futures and promises), and will return\n timeout-val if the timeout (in milliseconds) is reached before a\n value is available. See also - realized?.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(2304), kw_end_DASH_line, int(2304))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp6 := reflect.TypeOf((*lang.IDeref)(nil)).Elem() - tmp7 := lang.Apply(tmp5, []any{tmp6, v3}) - if lang.IsTruthy(tmp7) { - tmp8, ok := lang.FieldOrMethod(v3, "Deref") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "Deref"))) + tmp0 := sym_set.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a set of the distinct elements of coll.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(4104), kw_end_DASH_line, int(4104))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_set_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + tmp6 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp7 := lang.Apply(tmp6, []any{v2, nil}) + tmp3 = tmp7 + } else { + var tmp8 any + tmp9 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp10 := reflect.TypeOf((*lang.IReduceInit)(nil)).Elem() + tmp11 := lang.Apply(tmp9, []any{tmp10, v2}) + if lang.IsTruthy(tmp11) { + tmp12 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp13 := checkDerefVar(var_glojure_DOT_core_conj_BANG_) + tmp14 := checkDerefVar(var_glojure_DOT_core_transient) + tmp15 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4112), kw_column, int(108), kw_end_DASH_line, int(4112), kw_end_DASH_column, int(110)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) } - var tmp9 any - switch reflect.TypeOf(tmp8).Kind() { - case reflect.Func: - tmp9 = lang.Apply(tmp8, nil) - default: - tmp9 = tmp8 + tmp18 := lang.Apply(tmp14, []any{tmp17}) + tmp19, _ := lang.FieldOrMethod(v2, "ReduceInit") + if reflect.TypeOf(tmp19).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) } - tmp4 = tmp9 + tmp20 := lang.Apply(tmp19, []any{tmp13, tmp18}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp8 = tmp21 } else { - tmp10 := checkDerefVar(var_glojure_DOT_core_deref_DASH_future) - tmp11 := lang.Apply(tmp10, []any{v3}) - tmp4 = tmp11 - } - return tmp4 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var tmp6 any - tmp7 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp8 := reflect.TypeOf((*lang.IBlockingDeref)(nil)).Elem() - tmp9 := lang.Apply(tmp7, []any{tmp8, v3}) - if lang.IsTruthy(tmp9) { - tmp10, _ := lang.FieldOrMethod(v3, "DerefWithTimeout") - if reflect.TypeOf(tmp10).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("DerefWithTimeout is not a function"))) + tmp22 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp23 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp24 := checkDerefVar(var_glojure_DOT_core_conj_BANG_) + tmp25 := checkDerefVar(var_glojure_DOT_core_transient) + tmp26 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp27 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4113), kw_column, int(46), kw_end_DASH_line, int(4113), kw_end_DASH_column, int(48)) + tmp28, err := lang.WithMeta(tmp26, tmp27.(lang.IPersistentMap)) + if err != nil { + panic(err) } - tmp11 := lang.Apply(tmp10, []any{v4, v5}) - tmp6 = tmp11 - } else { - tmp12 := checkDerefVar(var_glojure_DOT_core_deref_DASH_future) - tmp13 := lang.Apply(tmp12, []any{v3, v4, v5}) - tmp6 = tmp13 + tmp29 := lang.Apply(tmp25, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp24, tmp29, v2}) + tmp31 := lang.Apply(tmp22, []any{tmp30}) + tmp8 = tmp31 } - return tmp6 - default: - checkArity(args, -1) - panic("unreachable") + tmp3 = tmp8 } + return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_set = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_set.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // deref-as-map + // short { - tmp0 := sym_deref_DASH_as_DASH_map.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(408), kw_column, int(8), kw_end_DASH_line, int(408), kw_end_DASH_column, int(19), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_o)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function short__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp15) { + tmp14 = sym_uncheckedShortCast + } else { + tmp14 = sym_shortCast + } + tmp16 := lang.Apply(tmp13, []any{tmp14}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := lang.Apply(tmp12, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp11, []any{tmp19}) + tmp21 := lang.Apply(tmp10, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_short.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to short", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3499), kw_end_DASH_line, int(3499))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) v3 := args[0] _ = v3 - var tmp4 any - { // let - // let binding "pending" - var tmp5 any - { // let - // let binding "and__0__auto__" - tmp6 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp7 := reflect.TypeOf((*lang.IPending)(nil)).Elem() - tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) - var v9 any = tmp8 - _ = v9 - var tmp10 any - if lang.IsTruthy(v9) { - tmp11 := checkDerefVar(var_glojure_DOT_core_not) - tmp12, ok := lang.FieldOrMethod(v3, "isRealized") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "isRealized"))) - } - var tmp13 any - switch reflect.TypeOf(tmp12).Kind() { - case reflect.Func: - tmp13 = lang.Apply(tmp12, nil) - default: - tmp13 = tmp12 - } - tmp14 := lang.Apply(tmp11, []any{tmp13}) - tmp10 = tmp14 - } else { - tmp10 = v9 - } - tmp5 = tmp10 - } // end let - var v6 any = tmp5 - _ = v6 - // let binding "vec__250" - var tmp7 any - if lang.IsTruthy(v6) { - } else { - var tmp8 any - func() { - defer func() { - if r := recover(); r != nil { - if lang.CatchMatches(r, lang.Throwable) { - v9 := r - _ = v9 - tmp10 := lang.NewVector(true, v9) - tmp11 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(415), kw_column, int(18), kw_end_DASH_line, int(415), kw_end_DASH_column, int(25)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp8 = tmp12 - } else { - panic(r) - } - } - }() - tmp9 := checkDerefVar(var_glojure_DOT_core_deref) - tmp10 := lang.Apply(tmp9, []any{v3}) - tmp11 := lang.NewVector(false, tmp10) - tmp12 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(413), kw_column, int(16), kw_end_DASH_line, int(413), kw_end_DASH_column, int(32)) - tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp8 = tmp13 - }() - tmp7 = tmp8 - } - var v14 any = tmp7 - _ = v14 - // let binding "ex" - tmp15 := checkDerefVar(var_glojure_DOT_core_nth) - tmp16 := lang.Apply(tmp15, []any{v14, int64(0), nil}) - var v17 any = tmp16 - _ = v17 - // let binding "val" - tmp18 := checkDerefVar(var_glojure_DOT_core_nth) - tmp19 := lang.Apply(tmp18, []any{v14, int64(1), nil}) - var v20 any = tmp19 - _ = v20 - var tmp21 any - var tmp22 any - { // let - // let binding "or__0__auto__" - var v23 any = v17 - _ = v23 - var tmp24 any - if lang.IsTruthy(v23) { - tmp24 = v23 - } else { - var tmp25 any - { // let - // let binding "and__0__auto__" - tmp26 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp27 := reflect.TypeOf((*lang.Agent)(nil)) - tmp28 := lang.Apply(tmp26, []any{tmp27, v3}) - var v29 any = tmp28 - _ = v29 - var tmp30 any - if lang.IsTruthy(v29) { - tmp31 := checkDerefVar(var_glojure_DOT_core_agent_DASH_error) - tmp32 := lang.Apply(tmp31, []any{v3}) - tmp30 = tmp32 - } else { - tmp30 = v29 - } - tmp25 = tmp30 - } // end let - tmp24 = tmp25 - } - tmp22 = tmp24 - } // end let - if lang.IsTruthy(tmp22) { - tmp21 = kw_failed - } else { - var tmp23 any - if lang.IsTruthy(v6) { - tmp23 = kw_pending - } else { - var tmp24 any - if lang.IsTruthy(kw_else) { - tmp24 = kw_ready - } else { - } - tmp23 = tmp24 - } - tmp21 = tmp23 - } - tmp25 := lang.NewMap(kw_status, tmp21, kw_val, v20) - tmp26 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(416), kw_column, int(5), kw_end_DASH_line, int(429), kw_end_DASH_column, int(14)) - tmp27, err := lang.WithMeta(tmp25, tmp26.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp4 = tmp27 - } // end let + tmp4 := lang.Apply(lang.ShortCast, []any{v3}) return tmp4 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core_short = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_short.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // deref-future + // short-array { - tmp0 := sym_deref_DASH_future.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(2296), kw_column, int(7), kw_end_DASH_line, int(2296), kw_end_DASH_column, int(28), kw_arglists, lang.NewList(lang.NewVector(sym_fut), lang.NewVector(sym_fut, sym_timeout_DASH_ms, sym_timeout_DASH_val)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function short-array__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_ShortArray}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_unquote_DASH_splicing}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_glojure_DOT_core_SLASH_args}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + } + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_short_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_size_DASH_or_DASH_seq), lang.NewVector(sym_size, sym_init_DASH_val_DASH_or_DASH_seq)), kw_inline, tmp1, kw_doc, "Creates an array of shorts", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(5333), kw_end_DASH_line, int(5333))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - tmp4, ok := lang.FieldOrMethod(v3, "Get") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "Get"))) - } - var tmp5 any - switch reflect.TypeOf(tmp4).Kind() { - case reflect.Func: - tmp5 = lang.Apply(tmp4, nil) - default: - tmp5 = tmp4 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "ShortArray") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ShortArray is not a function"))) } + tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 - case 3: + case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - v5 := args[2] - _ = v5 - var tmp6 any - func() { - defer func() { - if r := recover(); r != nil { - tmp7 := reflect.TypeOf((*lang.TimeoutError)(nil)).Elem() - if lang.CatchMatches(r, tmp7) { - v8 := r - _ = v8 - tmp6 = v5 - } else { - panic(r) - } - } - }() - tmp8, _ := lang.FieldOrMethod(v3, "Get") - if reflect.TypeOf(tmp8).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Get is not a function"))) - } - tmp9 := lang.Apply(tmp8, []any{v4, time10.Millisecond}) - tmp6 = tmp9 - }() + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "ShortArrayInit") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ShortArrayInit is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 default: checkArity(args, -1) @@ -17492,1756 +14083,1114 @@ func LoadNS() { } }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core_short_DASH_array = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_short_DASH_array.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // derive + // shorts { - tmp0 := sym_derive.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_tag, sym_parent), lang.NewVector(sym_h, sym_tag, sym_parent)), kw_doc, "Establishes a parent/child relationship between parent and\n tag. Parent must be a namespace-qualified symbol or keyword and\n child can be either a namespace-qualified symbol or keyword or a\n class. h must be a hierarchy obtained from make-hierarchy, if not\n supplied defaults to, and modifies, the global hierarchy.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(5605), kw_end_DASH_line, int(5605))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_alter_DASH_var_DASH_root) - tmp6 := lang.InternVarName(sym_glojure_DOT_core, sym_global_DASH_hierarchy) - tmp7 := checkDerefVar(var_glojure_DOT_core_derive) - tmp8 := lang.Apply(tmp5, []any{tmp6, tmp7, v3, v4}) - _ = tmp8 - return nil - case 3: + var tmp1 lang.FnFunc + { // function shorts + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) v3 := args[0] _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var tmp6 any - { // let - // let binding "tp" - tmp7 := lang.Apply(kw_parents, []any{v3}) - var v8 any = tmp7 - _ = v8 - // let binding "td" - tmp9 := lang.Apply(kw_descendants, []any{v3}) - var v10 any = tmp9 - _ = v10 - // let binding "ta" - tmp11 := lang.Apply(kw_ancestors, []any{v3}) - var v12 any = tmp11 - _ = v12 - // let binding "tf" - var tmp13 lang.FnFunc - tmp13 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 5) - v14 := args[0] - _ = v14 - v15 := args[1] - _ = v15 - v16 := args[2] - _ = v16 - v17 := args[3] - _ = v17 - v18 := args[4] - _ = v18 - tmp19 := checkDerefVar(var_glojure_DOT_core_reduce1) - var tmp20 lang.FnFunc - tmp20 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v21 := args[0] - _ = v21 - v22 := args[1] - _ = v22 - tmp23 := checkDerefVar(var_glojure_DOT_core_assoc) - tmp24 := checkDerefVar(var_glojure_DOT_core_reduce1) - tmp25 := checkDerefVar(var_glojure_DOT_core_conj) - tmp26 := checkDerefVar(var_glojure_DOT_core_get) - tmp27 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) - tmp28 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5628), kw_column, int(61), kw_end_DASH_line, int(5628), kw_end_DASH_column, int(63)) - tmp29, err := lang.WithMeta(tmp27, tmp28.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp30 := lang.Apply(tmp26, []any{v18, v22, tmp29}) - tmp31 := checkDerefVar(var_glojure_DOT_core_cons) - tmp32 := lang.Apply(v18, []any{v17}) - tmp33 := lang.Apply(tmp31, []any{v17, tmp32}) - tmp34 := lang.Apply(tmp24, []any{tmp25, tmp30, tmp33}) - tmp35 := lang.Apply(tmp23, []any{v21, v22, tmp34}) - return tmp35 - }) - tmp21 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5626), kw_column, int(24), kw_end_DASH_line, int(5628), kw_end_DASH_column, int(98)) - tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp23 := checkDerefVar(var_glojure_DOT_core_cons) - tmp24 := lang.Apply(v16, []any{v15}) - tmp25 := lang.Apply(tmp23, []any{v15, tmp24}) - tmp26 := lang.Apply(tmp19, []any{tmp22, v14, tmp25}) - return tmp26 - }) - tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5625), kw_column, int(13), kw_end_DASH_line, int(5629), kw_end_DASH_column, int(56)) - tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v16 any = tmp15 - _ = v16 - var tmp17 any - { // let - // let binding "or__0__auto__" - var tmp18 any - tmp19 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) - tmp20 := lang.Apply(v8, []any{v4}) - tmp21 := lang.Apply(tmp19, []any{tmp20, v5}) - if lang.IsTruthy(tmp21) { - } else { - var tmp22 any - tmp23 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) - tmp24 := lang.Apply(v12, []any{v4}) - tmp25 := lang.Apply(tmp23, []any{tmp24, v5}) - if lang.IsTruthy(tmp25) { - tmp26 := checkDerefVar(var_glojure_DOT_core_print_DASH_str) - tmp27 := lang.Apply(tmp26, []any{v4, "already has", v5, "as ancestor"}) - tmp28 := lang.Apply(lang.NewError, []any{tmp27}) - panic(tmp28) - } else { - } - _ = tmp22 - var tmp29 any - tmp30 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) - tmp31 := lang.Apply(v12, []any{v5}) - tmp32 := lang.Apply(tmp30, []any{tmp31, v4}) - if lang.IsTruthy(tmp32) { - tmp33 := checkDerefVar(var_glojure_DOT_core_print_DASH_str) - tmp34 := lang.Apply(tmp33, []any{"Cyclic derivation:", v5, "has", v4, "as ancestor"}) - tmp35 := lang.Apply(lang.NewError, []any{tmp34}) - panic(tmp35) - } else { - } - _ = tmp29 - tmp36 := checkDerefVar(var_glojure_DOT_core_assoc) - tmp37 := lang.Apply(kw_parents, []any{v3}) - tmp38 := checkDerefVar(var_glojure_DOT_core_conj) - tmp39 := checkDerefVar(var_glojure_DOT_core_get) - tmp40 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) - tmp41 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5636), kw_column, int(61), kw_end_DASH_line, int(5636), kw_end_DASH_column, int(63)) - tmp42, err := lang.WithMeta(tmp40, tmp41.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp43 := lang.Apply(tmp39, []any{v8, v4, tmp42}) - tmp44 := lang.Apply(tmp38, []any{tmp43, v5}) - tmp45 := lang.Apply(tmp36, []any{tmp37, v4, tmp44}) - tmp46 := lang.Apply(kw_ancestors, []any{v3}) - tmp47 := lang.Apply(v16, []any{tmp46, v4, v10, v5, v12}) - tmp48 := lang.Apply(kw_descendants, []any{v3}) - tmp49 := lang.Apply(v16, []any{tmp48, v5, v12, v4, v10}) - tmp50 := lang.NewMap(kw_parents, tmp45, kw_ancestors, tmp47, kw_descendants, tmp49) - tmp51 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5636), kw_column, int(9), kw_end_DASH_line, int(5638), kw_end_DASH_column, int(61)) - tmp52, err := lang.WithMeta(tmp50, tmp51.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp18 = tmp52 - } - var v53 any = tmp18 - _ = v53 - var tmp54 any - if lang.IsTruthy(v53) { - tmp54 = v53 - } else { - tmp54 = v3 - } - tmp17 = tmp54 - } // end let - tmp6 = tmp17 - } // end let - return tmp6 - default: - checkArity(args, -1) - panic("unreachable") - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Shorts}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 + }) + v2 = tmp1 + _ = v2 } - } - // descendants - { - tmp0 := sym_descendants.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_tag), lang.NewVector(sym_h, sym_tag)), kw_doc, "Returns the immediate and indirect children of tag, through a\n relationship established via derive. h must be a hierarchy obtained\n from make-hierarchy, if not supplied defaults to the global\n hierarchy. Note: does not work on Java type inheritance\n relationships.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(5593), kw_end_DASH_line, int(5593))).(*lang.Symbol) + tmp0 := sym_shorts.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xs)), kw_inline, tmp1, kw_doc, "Casts to shorts[]", kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(12), kw_line, int(5387), kw_end_DASH_line, int(5387))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_descendants) - tmp5 := checkDerefVar(var_glojure_DOT_core_global_DASH_hierarchy) - tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) - return tmp6 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - tmp6 := checkDerefVar(var_glojure_DOT_core_class_QMARK_) - tmp7 := lang.Apply(tmp6, []any{v4}) - if lang.IsTruthy(tmp7) { - tmp8 := lang.Apply(lang.NewUnsupportedOperationError, []any{"Can't get descendants of classes"}) - panic(tmp8) - } else { - tmp9 := checkDerefVar(var_glojure_DOT_core_not_DASH_empty) - tmp10 := checkDerefVar(var_glojure_DOT_core_get) - tmp11 := lang.Apply(kw_descendants, []any{v3}) - tmp12 := lang.Apply(tmp10, []any{tmp11, v4}) - tmp13 := lang.Apply(tmp9, []any{tmp12}) - tmp5 = tmp13 - } - return tmp5 - default: - checkArity(args, -1) - panic("unreachable") + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Shorts") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Shorts is not a function"))) } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core_shorts = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_shorts.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // destructure + // shuffle { - tmp0 := sym_destructure.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4400), kw_column, int(7), kw_end_DASH_line, int(4400), kw_end_DASH_column, int(17), kw_arglists, lang.NewList(lang.NewVector(sym_bindings)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_shuffle.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Return a random permutation of coll", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(7300), kw_end_DASH_line, int(7300))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 any + v2 := args[0] + _ = v2 + var tmp3 any { // let - // let binding "bents" - tmp5 := checkDerefVar(var_glojure_DOT_core_partition) - tmp6 := lang.Apply(tmp5, []any{int64(2), v3}) + // let binding "al" + tmp4 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) + tmp5 := lang.Apply(tmp4, []any{v2}) + tmp6 := lang.Apply(lang.NewArrayList, []any{tmp5}) var v7 any = tmp6 _ = v7 - // let binding "pb" - var tmp8 lang.FnFunc - { // function pb - var v9 lang.FnFunc - tmp8 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 3) - v10 := args[0] - _ = v10 - v11 := args[1] - _ = v11 - v12 := args[2] - _ = v12 - var tmp13 any - { // let - // let binding "pvec" - var tmp14 lang.FnFunc - tmp14 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 3) - v15 := args[0] - _ = v15 - v16 := args[1] - _ = v16 - v17 := args[2] - _ = v17 - var tmp18 any - { // let - // let binding "gvec" - tmp19 := checkDerefVar(var_glojure_DOT_core_gensym) - tmp20 := lang.Apply(tmp19, []any{"vec__"}) - var v21 any = tmp20 - _ = v21 - // let binding "gseq" - tmp22 := checkDerefVar(var_glojure_DOT_core_gensym) - tmp23 := lang.Apply(tmp22, []any{"seq__"}) - var v24 any = tmp23 - _ = v24 - // let binding "gfirst" - tmp25 := checkDerefVar(var_glojure_DOT_core_gensym) - tmp26 := lang.Apply(tmp25, []any{"first__"}) - var v27 any = tmp26 - _ = v27 - // let binding "has-rest" - tmp28 := checkDerefVar(var_glojure_DOT_core_some) - tmp29 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{sym__AMP_})) - tmp30 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4408), kw_column, int(43), kw_end_DASH_line, int(4408), kw_end_DASH_column, int(47)) - tmp31, err := lang.WithMeta(tmp29, tmp30.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp32 := lang.Apply(tmp28, []any{tmp31, v16}) - var v33 any = tmp32 - _ = v33 - var tmp34 any - { // let - // let binding "ret" - var tmp35 any - { // let - // let binding "ret" - tmp36 := checkDerefVar(var_glojure_DOT_core_conj) - tmp37 := lang.Apply(tmp36, []any{v15, v21, v17}) - var v38 any = tmp37 - _ = v38 - var tmp39 any - if lang.IsTruthy(v33) { - tmp40 := checkDerefVar(var_glojure_DOT_core_conj) - tmp41 := checkDerefVar(var_glojure_DOT_core_list) - tmp42 := lang.Apply(tmp41, []any{sym_glojure_DOT_core_SLASH_seq, v21}) - tmp43 := lang.Apply(tmp40, []any{v38, v24, tmp42}) - tmp39 = tmp43 - } else { - tmp39 = v38 - } - tmp35 = tmp39 - } // end let - var v36 any = tmp35 - _ = v36 - // let binding "n" - var v37 any = int64(0) - _ = v37 - // let binding "bs" - var v38 any = v16 - _ = v38 - // let binding "seen-rest?" - var v39 any = false - _ = v39 - for { - var tmp40 any - tmp41 := checkDerefVar(var_glojure_DOT_core_seq) - tmp42 := lang.Apply(tmp41, []any{v38}) - if lang.IsTruthy(tmp42) { - var tmp43 any - { // let - // let binding "firstb" - tmp44 := checkDerefVar(var_glojure_DOT_core_first) - tmp45 := lang.Apply(tmp44, []any{v38}) - var v46 any = tmp45 - _ = v46 - var tmp47 any - tmp48 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp49 := lang.Apply(tmp48, []any{v46, sym__AMP_}) - if lang.IsTruthy(tmp49) { - tmp51 := checkDerefVar(var_glojure_DOT_core_second) - tmp52 := lang.Apply(tmp51, []any{v38}) - tmp53 := lang.Apply(v9, []any{v36, tmp52, v24}) - var tmp50 any = tmp53 - var tmp54 any = v37 - tmp56 := checkDerefVar(var_glojure_DOT_core_nnext) - tmp57 := lang.Apply(tmp56, []any{v38}) - var tmp55 any = tmp57 - var tmp58 any = true - v36 = tmp50 - v37 = tmp54 - v38 = tmp55 - v39 = tmp58 - continue - } else { - var tmp59 any - tmp60 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp61 := lang.Apply(tmp60, []any{v46, kw_as}) - if lang.IsTruthy(tmp61) { - tmp62 := checkDerefVar(var_glojure_DOT_core_second) - tmp63 := lang.Apply(tmp62, []any{v38}) - tmp64 := lang.Apply(v9, []any{v36, tmp63, v21}) - tmp59 = tmp64 - } else { - var tmp65 any - if lang.IsTruthy(kw_else) { - var tmp66 any - if lang.IsTruthy(v39) { - tmp67 := lang.Apply(errors8.New, []any{"Unsupported binding form, only :as can follow & parameter"}) - panic(tmp67) - } else { - var tmp69 any - if lang.IsTruthy(v33) { - tmp70 := checkDerefVar(var_glojure_DOT_core_conj) - tmp71 := checkDerefVar(var_glojure_DOT_core_seq) - tmp72 := checkDerefVar(var_glojure_DOT_core_concat) - tmp73 := checkDerefVar(var_glojure_DOT_core_list) - tmp74 := lang.Apply(tmp73, []any{sym_glojure_DOT_core_SLASH_first}) - tmp75 := checkDerefVar(var_glojure_DOT_core_list) - tmp76 := lang.Apply(tmp75, []any{v24}) - tmp77 := lang.Apply(tmp72, []any{tmp74, tmp76}) - tmp78 := lang.Apply(tmp71, []any{tmp77}) - tmp79 := checkDerefVar(var_glojure_DOT_core_seq) - tmp80 := checkDerefVar(var_glojure_DOT_core_concat) - tmp81 := checkDerefVar(var_glojure_DOT_core_list) - tmp82 := lang.Apply(tmp81, []any{sym_glojure_DOT_core_SLASH_next}) - tmp83 := checkDerefVar(var_glojure_DOT_core_list) - tmp84 := lang.Apply(tmp83, []any{v24}) - tmp85 := lang.Apply(tmp80, []any{tmp82, tmp84}) - tmp86 := lang.Apply(tmp79, []any{tmp85}) - tmp87 := lang.Apply(tmp70, []any{v36, v27, tmp78, v24, tmp86}) - tmp69 = tmp87 - } else { - tmp69 = v36 - } - var tmp88 any - if lang.IsTruthy(v33) { - tmp88 = v27 - } else { - tmp89 := checkDerefVar(var_glojure_DOT_core_list) - tmp90 := lang.Apply(tmp89, []any{sym_glojure_DOT_core_SLASH_nth, v21, v37, nil}) - tmp88 = tmp90 - } - tmp91 := lang.Apply(v9, []any{tmp69, v46, tmp88}) - var tmp68 any = tmp91 - tmp93 := checkDerefVar(var_glojure_DOT_core_inc) - tmp94 := lang.Apply(tmp93, []any{v37}) - var tmp92 any = tmp94 - tmp96 := checkDerefVar(var_glojure_DOT_core_next) - tmp97 := lang.Apply(tmp96, []any{v38}) - var tmp95 any = tmp97 - var tmp98 any = v39 - v36 = tmp68 - v37 = tmp92 - v38 = tmp95 - v39 = tmp98 - continue - } - tmp65 = tmp66 - } else { - } - tmp59 = tmp65 - } - tmp47 = tmp59 - } - tmp43 = tmp47 - } // end let - tmp40 = tmp43 - } else { - tmp40 = v36 - } - tmp34 = tmp40 - break - } - } // end let - tmp18 = tmp34 - } // end let - return tmp18 - }) - tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4404), kw_column, int(20), kw_end_DASH_line, int(4438), kw_end_DASH_column, int(34)) - tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v17 any = tmp16 - _ = v17 - // let binding "pmap" - var tmp18 lang.FnFunc - tmp18 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 3) - v19 := args[0] - _ = v19 - v20 := args[1] - _ = v20 - v21 := args[2] - _ = v21 - var tmp22 any - { // let - // let binding "gmap" - tmp23 := checkDerefVar(var_glojure_DOT_core_gensym) - tmp24 := lang.Apply(tmp23, []any{"map__"}) - var v25 any = tmp24 - _ = v25 - // let binding "gmapseq" - tmp26 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) - tmp27 := lang.NewMap(kw_tag, sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_ISeq) - tmp28 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4442), kw_column, int(52), kw_end_DASH_line, int(4442), kw_end_DASH_column, int(103)) - tmp29, err := lang.WithMeta(tmp27, tmp28.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp30 := lang.Apply(tmp26, []any{v25, tmp29}) - var v31 any = tmp30 - _ = v31 - // let binding "defaults" - tmp32 := lang.Apply(kw_or, []any{v20}) - var v33 any = tmp32 - _ = v33 - var tmp34 any - { // let - // let binding "ret" - var tmp35 lang.FnFunc - tmp35 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v36 := args[0] - _ = v36 - var tmp37 any - tmp38 := lang.Apply(kw_as, []any{v20}) - if lang.IsTruthy(tmp38) { - tmp39 := checkDerefVar(var_glojure_DOT_core_conj) - tmp40 := lang.Apply(kw_as, []any{v20}) - tmp41 := lang.Apply(tmp39, []any{v36, tmp40, v25}) - tmp37 = tmp41 - } else { - tmp37 = v36 - } - return tmp37 - }) - tmp36 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4450), kw_column, int(40), kw_end_DASH_line, int(4453), kw_end_DASH_column, int(48)) - tmp37, err := lang.WithMeta(tmp35, tmp36.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp38 := checkDerefVar(var_glojure_DOT_core_conj) - tmp39 := checkDerefVar(var_glojure_DOT_core_conj) - tmp40 := checkDerefVar(var_glojure_DOT_core_conj) - tmp41 := checkDerefVar(var_glojure_DOT_core_conj) - tmp42 := lang.Apply(tmp41, []any{v19, v25}) - tmp43 := lang.Apply(tmp40, []any{tmp42, v21}) - tmp44 := lang.Apply(tmp39, []any{tmp43, v25}) - tmp45 := checkDerefVar(var_glojure_DOT_core_seq) - tmp46 := checkDerefVar(var_glojure_DOT_core_concat) - tmp47 := checkDerefVar(var_glojure_DOT_core_list) - tmp48 := lang.Apply(tmp47, []any{sym_if}) - tmp49 := checkDerefVar(var_glojure_DOT_core_list) - tmp50 := checkDerefVar(var_glojure_DOT_core_seq) - tmp51 := checkDerefVar(var_glojure_DOT_core_concat) - tmp52 := checkDerefVar(var_glojure_DOT_core_list) - tmp53 := lang.Apply(tmp52, []any{sym_glojure_DOT_core_SLASH_seq_QMARK_}) - tmp54 := checkDerefVar(var_glojure_DOT_core_list) - tmp55 := lang.Apply(tmp54, []any{v25}) - tmp56 := lang.Apply(tmp51, []any{tmp53, tmp55}) - tmp57 := lang.Apply(tmp50, []any{tmp56}) - tmp58 := lang.Apply(tmp49, []any{tmp57}) - tmp59 := checkDerefVar(var_glojure_DOT_core_list) - tmp60 := checkDerefVar(var_glojure_DOT_core_seq) - tmp61 := checkDerefVar(var_glojure_DOT_core_concat) - tmp62 := checkDerefVar(var_glojure_DOT_core_list) - tmp63 := lang.Apply(tmp62, []any{sym_if}) - tmp64 := checkDerefVar(var_glojure_DOT_core_list) - tmp65 := checkDerefVar(var_glojure_DOT_core_seq) - tmp66 := checkDerefVar(var_glojure_DOT_core_concat) - tmp67 := checkDerefVar(var_glojure_DOT_core_list) - tmp68 := lang.Apply(tmp67, []any{sym_glojure_DOT_core_SLASH_next}) - tmp69 := checkDerefVar(var_glojure_DOT_core_list) - tmp70 := lang.Apply(tmp69, []any{v31}) - tmp71 := lang.Apply(tmp66, []any{tmp68, tmp70}) - tmp72 := lang.Apply(tmp65, []any{tmp71}) - tmp73 := lang.Apply(tmp64, []any{tmp72}) - tmp74 := checkDerefVar(var_glojure_DOT_core_list) - tmp75 := checkDerefVar(var_glojure_DOT_core_seq) - tmp76 := checkDerefVar(var_glojure_DOT_core_concat) - tmp77 := checkDerefVar(var_glojure_DOT_core_list) - tmp78 := lang.Apply(tmp77, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_NewPersistentArrayMapAsIfByAssoc}) - tmp79 := checkDerefVar(var_glojure_DOT_core_list) - tmp80 := checkDerefVar(var_glojure_DOT_core_seq) - tmp81 := checkDerefVar(var_glojure_DOT_core_concat) - tmp82 := checkDerefVar(var_glojure_DOT_core_list) - tmp83 := lang.Apply(tmp82, []any{sym_glojure_DOT_core_SLASH_to_DASH_array}) - tmp84 := checkDerefVar(var_glojure_DOT_core_list) - tmp85 := lang.Apply(tmp84, []any{v31}) - tmp86 := lang.Apply(tmp81, []any{tmp83, tmp85}) - tmp87 := lang.Apply(tmp80, []any{tmp86}) - tmp88 := lang.Apply(tmp79, []any{tmp87}) - tmp89 := lang.Apply(tmp76, []any{tmp78, tmp88}) - tmp90 := lang.Apply(tmp75, []any{tmp89}) - tmp91 := lang.Apply(tmp74, []any{tmp90}) - tmp92 := checkDerefVar(var_glojure_DOT_core_list) - tmp93 := checkDerefVar(var_glojure_DOT_core_seq) - tmp94 := checkDerefVar(var_glojure_DOT_core_concat) - tmp95 := checkDerefVar(var_glojure_DOT_core_list) - tmp96 := lang.Apply(tmp95, []any{sym_if}) - tmp97 := checkDerefVar(var_glojure_DOT_core_list) - tmp98 := checkDerefVar(var_glojure_DOT_core_seq) - tmp99 := checkDerefVar(var_glojure_DOT_core_concat) - tmp100 := checkDerefVar(var_glojure_DOT_core_list) - tmp101 := lang.Apply(tmp100, []any{sym_glojure_DOT_core_SLASH_seq}) - tmp102 := checkDerefVar(var_glojure_DOT_core_list) - tmp103 := lang.Apply(tmp102, []any{v31}) - tmp104 := lang.Apply(tmp99, []any{tmp101, tmp103}) - tmp105 := lang.Apply(tmp98, []any{tmp104}) - tmp106 := lang.Apply(tmp97, []any{tmp105}) - tmp107 := checkDerefVar(var_glojure_DOT_core_list) - tmp108 := checkDerefVar(var_glojure_DOT_core_seq) - tmp109 := checkDerefVar(var_glojure_DOT_core_concat) - tmp110 := checkDerefVar(var_glojure_DOT_core_list) - tmp111 := lang.Apply(tmp110, []any{sym_glojure_DOT_core_SLASH_first}) - tmp112 := checkDerefVar(var_glojure_DOT_core_list) - tmp113 := lang.Apply(tmp112, []any{v31}) - tmp114 := lang.Apply(tmp109, []any{tmp111, tmp113}) - tmp115 := lang.Apply(tmp108, []any{tmp114}) - tmp116 := lang.Apply(tmp107, []any{tmp115}) - tmp117 := checkDerefVar(var_glojure_DOT_core_list) - tmp118 := lang.Apply(tmp117, []any{sym_glojure_DOT_lang_DOT_PersistentArrayMap_SLASH_EMPTY}) - tmp119 := lang.Apply(tmp94, []any{tmp96, tmp106, tmp116, tmp118}) - tmp120 := lang.Apply(tmp93, []any{tmp119}) - tmp121 := lang.Apply(tmp92, []any{tmp120}) - tmp122 := lang.Apply(tmp61, []any{tmp63, tmp73, tmp91, tmp121}) - tmp123 := lang.Apply(tmp60, []any{tmp122}) - tmp124 := lang.Apply(tmp59, []any{tmp123}) - tmp125 := checkDerefVar(var_glojure_DOT_core_list) - tmp126 := lang.Apply(tmp125, []any{v25}) - tmp127 := lang.Apply(tmp46, []any{tmp48, tmp58, tmp124, tmp126}) - tmp128 := lang.Apply(tmp45, []any{tmp127}) - tmp129 := lang.Apply(tmp38, []any{tmp44, tmp128}) - tmp130 := lang.Apply(tmp37, []any{tmp129}) - var v131 any = tmp130 - _ = v131 - // let binding "bes" - var tmp132 any - { // let - // let binding "transforms" - tmp133 := checkDerefVar(var_glojure_DOT_core_reduce1) - var tmp134 lang.FnFunc - tmp134 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v135 := args[0] - _ = v135 - v136 := args[1] - _ = v136 - var tmp137 any - tmp138 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) - tmp139 := lang.Apply(tmp138, []any{v136}) - if lang.IsTruthy(tmp139) { - var tmp140 any - { // let - // let binding "mkns" - tmp141 := checkDerefVar(var_glojure_DOT_core_namespace) - tmp142 := lang.Apply(tmp141, []any{v136}) - var v143 any = tmp142 - _ = v143 - // let binding "mkn" - tmp144 := checkDerefVar(var_glojure_DOT_core_name) - tmp145 := lang.Apply(tmp144, []any{v136}) - var v146 any = tmp145 - _ = v146 - var tmp147 any - tmp148 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp149 := lang.Apply(tmp148, []any{v146, "keys"}) - if lang.IsTruthy(tmp149) { - tmp150 := checkDerefVar(var_glojure_DOT_core_assoc) - var tmp151 lang.FnFunc - tmp151 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v152 := args[0] - _ = v152 - tmp153 := checkDerefVar(var_glojure_DOT_core_keyword) - var tmp154 any - { // let - // let binding "or__0__auto__" - var v155 any = v143 - _ = v155 - var tmp156 any - if lang.IsTruthy(v155) { - tmp156 = v155 - } else { - tmp157 := checkDerefVar(var_glojure_DOT_core_namespace) - tmp158 := lang.Apply(tmp157, []any{v152}) - tmp156 = tmp158 - } - tmp154 = tmp156 - } // end let - tmp155 := checkDerefVar(var_glojure_DOT_core_name) - tmp156 := lang.Apply(tmp155, []any{v152}) - tmp157 := lang.Apply(tmp153, []any{tmp154, tmp156}) - return tmp157 - }) - tmp152 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4460), kw_column, int(93), kw_end_DASH_line, int(4460), kw_end_DASH_column, int(135)) - tmp153, err := lang.WithMeta(tmp151, tmp152.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp154 := lang.Apply(tmp150, []any{v135, v136, tmp153}) - tmp147 = tmp154 - } else { - var tmp155 any - tmp156 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp157 := lang.Apply(tmp156, []any{v146, "syms"}) - if lang.IsTruthy(tmp157) { - tmp158 := checkDerefVar(var_glojure_DOT_core_assoc) - var tmp159 lang.FnFunc - tmp159 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v160 := args[0] - _ = v160 - tmp161 := checkDerefVar(var_glojure_DOT_core_list) - tmp162 := checkDerefVar(var_glojure_DOT_core_symbol) - var tmp163 any - { // let - // let binding "or__0__auto__" - var v164 any = v143 - _ = v164 - var tmp165 any - if lang.IsTruthy(v164) { - tmp165 = v164 - } else { - tmp166 := checkDerefVar(var_glojure_DOT_core_namespace) - tmp167 := lang.Apply(tmp166, []any{v160}) - tmp165 = tmp167 - } - tmp163 = tmp165 - } // end let - tmp164 := checkDerefVar(var_glojure_DOT_core_name) - tmp165 := lang.Apply(tmp164, []any{v160}) - tmp166 := lang.Apply(tmp162, []any{tmp163, tmp165}) - tmp167 := lang.Apply(tmp161, []any{sym_quote, tmp166}) - return tmp167 - }) - tmp160 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4461), kw_column, int(93), kw_end_DASH_line, int(4461), kw_end_DASH_column, int(148)) - tmp161, err := lang.WithMeta(tmp159, tmp160.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp162 := lang.Apply(tmp158, []any{v135, v136, tmp161}) - tmp155 = tmp162 - } else { - var tmp163 any - tmp164 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp165 := lang.Apply(tmp164, []any{v146, "strs"}) - if lang.IsTruthy(tmp165) { - tmp166 := checkDerefVar(var_glojure_DOT_core_assoc) - tmp167 := checkDerefVar(var_glojure_DOT_core_str) - tmp168 := lang.Apply(tmp166, []any{v135, v136, tmp167}) - tmp163 = tmp168 - } else { - var tmp169 any - if lang.IsTruthy(kw_else) { - tmp169 = v135 - } else { - } - tmp163 = tmp169 - } - tmp155 = tmp163 - } - tmp147 = tmp155 - } - tmp140 = tmp147 - } // end let - tmp137 = tmp140 - } else { - tmp137 = v135 - } - return tmp137 - }) - tmp135 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4456), kw_column, int(45), kw_end_DASH_line, int(4464), kw_end_DASH_column, int(60)) - tmp136, err := lang.WithMeta(tmp134, tmp135.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp137 := lang.NewMap() - tmp138 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4465), kw_column, int(45), kw_end_DASH_line, int(4465), kw_end_DASH_column, int(46)) - tmp139, err := lang.WithMeta(tmp137, tmp138.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp140 := checkDerefVar(var_glojure_DOT_core_keys) - tmp141 := lang.Apply(tmp140, []any{v20}) - tmp142 := lang.Apply(tmp133, []any{tmp136, tmp139, tmp141}) - var v143 any = tmp142 - _ = v143 - tmp144 := checkDerefVar(var_glojure_DOT_core_reduce1) - var tmp145 lang.FnFunc - tmp145 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v146 := args[0] - _ = v146 - v147 := args[1] - _ = v147 - tmp148 := checkDerefVar(var_glojure_DOT_core_reduce1) - var tmp149 lang.FnFunc - tmp149 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v150 := args[0] - _ = v150 - v151 := args[1] - _ = v151 - tmp152 := checkDerefVar(var_glojure_DOT_core_assoc) - tmp153 := checkDerefVar(var_glojure_DOT_core_val) - tmp154 := lang.Apply(tmp153, []any{v147}) - tmp155 := lang.Apply(tmp154, []any{v151}) - tmp156 := lang.Apply(tmp152, []any{v150, v151, tmp155}) - return tmp156 - }) - tmp150 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4469), kw_column, int(52), kw_end_DASH_line, int(4469), kw_end_DASH_column, int(82)) - tmp151, err := lang.WithMeta(tmp149, tmp150.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp152 := checkDerefVar(var_glojure_DOT_core_dissoc) - tmp153 := checkDerefVar(var_glojure_DOT_core_key) - tmp154 := lang.Apply(tmp153, []any{v147}) - tmp155 := lang.Apply(tmp152, []any{v146, tmp154}) - tmp156 := checkDerefVar(var_glojure_DOT_core_key) - tmp157 := lang.Apply(tmp156, []any{v147}) - tmp158 := lang.Apply(tmp157, []any{v146}) - tmp159 := lang.Apply(tmp148, []any{tmp151, tmp155, tmp158}) - return tmp159 - }) - tmp146 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4468), kw_column, int(41), kw_end_DASH_line, int(4471), kw_end_DASH_column, int(70)) - tmp147, err := lang.WithMeta(tmp145, tmp146.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp148 := checkDerefVar(var_glojure_DOT_core_dissoc) - tmp149 := lang.Apply(tmp148, []any{v20, kw_as, kw_or}) - tmp150 := lang.Apply(tmp144, []any{tmp147, tmp149, v143}) - tmp132 = tmp150 - } // end let - var v133 any = tmp132 - _ = v133 - for { - var tmp134 any - tmp135 := checkDerefVar(var_glojure_DOT_core_seq) - tmp136 := lang.Apply(tmp135, []any{v133}) - if lang.IsTruthy(tmp136) { - var tmp137 any - { // let - // let binding "bb" - tmp138 := checkDerefVar(var_glojure_DOT_core_key) - tmp139 := checkDerefVar(var_glojure_DOT_core_first) - tmp140 := lang.Apply(tmp139, []any{v133}) - tmp141 := lang.Apply(tmp138, []any{tmp140}) - var v142 any = tmp141 - _ = v142 - // let binding "bk" - tmp143 := checkDerefVar(var_glojure_DOT_core_val) - tmp144 := checkDerefVar(var_glojure_DOT_core_first) - tmp145 := lang.Apply(tmp144, []any{v133}) - tmp146 := lang.Apply(tmp143, []any{tmp145}) - var v147 any = tmp146 - _ = v147 - // let binding "local" - var tmp148 any - tmp149 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp150 := reflect.TypeOf((*lang.Named)(nil)).Elem() - tmp151 := lang.Apply(tmp149, []any{tmp150, v142}) - if lang.IsTruthy(tmp151) { - tmp152 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) - tmp153 := checkDerefVar(var_glojure_DOT_core_symbol) - tmp154 := checkDerefVar(var_glojure_DOT_core_name) - tmp155 := lang.Apply(tmp154, []any{v142}) - tmp156 := lang.Apply(tmp153, []any{nil, tmp155}) - tmp157 := checkDerefVar(var_glojure_DOT_core_meta) - tmp158 := lang.Apply(tmp157, []any{v142}) - tmp159 := lang.Apply(tmp152, []any{tmp156, tmp158}) - tmp148 = tmp159 - } else { - tmp148 = v142 - } - var v160 any = tmp148 - _ = v160 - // let binding "bv" - var tmp161 any - tmp162 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) - tmp163 := lang.Apply(tmp162, []any{v33, v160}) - if lang.IsTruthy(tmp163) { - tmp164 := checkDerefVar(var_glojure_DOT_core_list) - tmp165 := lang.Apply(v33, []any{v160}) - tmp166 := lang.Apply(tmp164, []any{sym_glojure_DOT_core_SLASH_get, v25, v147, tmp165}) - tmp161 = tmp166 - } else { - tmp167 := checkDerefVar(var_glojure_DOT_core_list) - tmp168 := lang.Apply(tmp167, []any{sym_glojure_DOT_core_SLASH_get, v25, v147}) - tmp161 = tmp168 - } - var v169 any = tmp161 - _ = v169 - var tmp171 any - tmp172 := checkDerefVar(var_glojure_DOT_core_ident_QMARK_) - tmp173 := lang.Apply(tmp172, []any{v142}) - if lang.IsTruthy(tmp173) { - tmp174 := checkDerefVar(var_glojure_DOT_core_conj) - tmp175 := lang.Apply(tmp174, []any{v131, v160, v169}) - tmp171 = tmp175 - } else { - tmp176 := lang.Apply(v9, []any{v131, v142, v169}) - tmp171 = tmp176 - } - var tmp170 any = tmp171 - tmp178 := checkDerefVar(var_glojure_DOT_core_next) - tmp179 := lang.Apply(tmp178, []any{v133}) - var tmp177 any = tmp179 - v131 = tmp170 - v133 = tmp177 - continue - } // end let - tmp134 = tmp137 - } else { - tmp134 = v131 - } - tmp34 = tmp134 - break - } - } // end let - tmp22 = tmp34 - } // end let - return tmp22 - }) - tmp19 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4440), kw_column, int(20), kw_end_DASH_line, int(4485), kw_end_DASH_column, int(34)) - tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v21 any = tmp20 - _ = v21 - var tmp22 any - tmp23 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) - tmp24 := lang.Apply(tmp23, []any{v11}) - if lang.IsTruthy(tmp24) { - tmp25 := checkDerefVar(var_glojure_DOT_core_conj) - tmp26 := checkDerefVar(var_glojure_DOT_core_conj) - tmp27 := lang.Apply(tmp26, []any{v10, v11}) - tmp28 := lang.Apply(tmp25, []any{tmp27, v12}) - tmp22 = tmp28 - } else { - var tmp29 any - tmp30 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) - tmp31 := lang.Apply(tmp30, []any{v11}) - if lang.IsTruthy(tmp31) { - tmp32 := lang.Apply(v17, []any{v10, v11, v12}) - tmp29 = tmp32 - } else { - var tmp33 any - tmp34 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) - tmp35 := lang.Apply(tmp34, []any{v11}) - if lang.IsTruthy(tmp35) { - tmp36 := lang.Apply(v21, []any{v10, v11, v12}) - tmp33 = tmp36 - } else { - var tmp37 any - if lang.IsTruthy(kw_else) { - tmp38 := checkDerefVar(var_glojure_DOT_core_str) - tmp39 := lang.Apply(tmp38, []any{"Unsupported binding form: ", v11}) - tmp40 := lang.Apply(errors8.New, []any{tmp39}) - panic(tmp40) - } else { - } - tmp33 = tmp37 - } - tmp29 = tmp33 - } - tmp22 = tmp29 - } - tmp13 = tmp22 - } // end let - return tmp13 - }) - v9 = tmp8 - _ = v9 - } - tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4402), kw_column, int(12), kw_end_DASH_line, int(4490), kw_end_DASH_column, int(82)) - tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v11 any = tmp10 - _ = v11 - // let binding "process-entry" - var tmp12 lang.FnFunc - tmp12 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v13 := args[0] - _ = v13 - v14 := args[1] - _ = v14 - tmp15 := checkDerefVar(var_glojure_DOT_core_first) - tmp16 := lang.Apply(tmp15, []any{v14}) - tmp17 := checkDerefVar(var_glojure_DOT_core_second) - tmp18 := lang.Apply(tmp17, []any{v14}) - tmp19 := lang.Apply(v11, []any{v13, tmp16, tmp18}) - return tmp19 - }) - tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4491), kw_column, int(23), kw_end_DASH_line, int(4491), kw_end_DASH_column, int(66)) - tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) - if err != nil { - panic(err) + tmp8 := lang.Apply(nil, []any{v7}) + _ = tmp8 + tmp9, ok := lang.FieldOrMethod(v7, "toArray") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "toArray"))) } - var v15 any = tmp14 - _ = v15 - var tmp16 any - tmp17 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) - tmp18 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) - tmp19 := checkDerefVar(var_glojure_DOT_core_map) - tmp20 := checkDerefVar(var_glojure_DOT_core_first) - tmp21 := lang.Apply(tmp19, []any{tmp20, v7}) - tmp22 := lang.Apply(tmp17, []any{tmp18, tmp21}) - if lang.IsTruthy(tmp22) { - tmp16 = v3 - } else { - tmp23 := checkDerefVar(var_glojure_DOT_core_reduce1) - tmp24 := lang.NewVector() - tmp25 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4494), kw_column, int(30), kw_end_DASH_line, int(4494), kw_end_DASH_column, int(31)) - tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp27 := lang.Apply(tmp23, []any{v15, tmp26, v7}) - tmp16 = tmp27 + var tmp10 any + switch reflect.TypeOf(tmp9).Kind() { + case reflect.Func: + tmp10 = lang.Apply(tmp9, nil) + default: + tmp10 = tmp9 } - tmp4 = tmp16 + tmp11 := lang.Apply(nil, []any{tmp10}) + tmp3 = tmp11 } // end let - return tmp4 + return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_shuffle = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_shuffle.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // disj + // simple-ident? { - tmp0 := sym_disj.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_set), lang.NewVector(sym_set, sym_key), lang.NewVector(sym_set, sym_key, sym__AMP_, sym_ks)), kw_doc, "disj[oin]. Returns a new set of the same (hashed/sorted) type, that\n does not contain key(s).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1514), kw_end_DASH_line, int(1514))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - return v3 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - if lang.IsTruthy(v3) { - tmp6, _ := lang.FieldOrMethod(v3, "Disjoin") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Disjoin is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4}) - tmp5 = tmp7 + tmp0 := sym_simple_DASH_ident_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a symbol or keyword without a namespace", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(1613), kw_end_DASH_line, int(1613))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "and__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_ident_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + tmp8 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp9 := checkDerefVar(var_glojure_DOT_core_namespace) + tmp10 := lang.Apply(tmp9, []any{v2}) + tmp11 := lang.Apply(tmp8, []any{tmp10}) + tmp7 = tmp11 } else { + tmp7 = v6 } - return tmp5 - default: - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - recur_loop_304: - var tmp6 any - if lang.IsTruthy(v3) { - var tmp7 any - { // let - // let binding "ret" - tmp8 := checkDerefVar(var_glojure_DOT_core_disj) - tmp9 := lang.Apply(tmp8, []any{v3, v4}) - var v10 any = tmp9 - _ = v10 - var tmp11 any - if lang.IsTruthy(v5) { - var tmp12 any = v10 - tmp14 := checkDerefVar(var_glojure_DOT_core_first) - tmp15 := lang.Apply(tmp14, []any{v5}) - var tmp13 any = tmp15 - tmp17 := checkDerefVar(var_glojure_DOT_core_next) - tmp18 := lang.Apply(tmp17, []any{v5}) - var tmp16 any = tmp18 - v3 = tmp12 - v4 = tmp13 - v5 = tmp16 - goto recur_loop_304 - } else { - tmp11 = v10 - } - tmp7 = tmp11 - } // end let - tmp6 = tmp7 + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_simple_DASH_ident_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_simple_DASH_ident_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // simple-symbol? + { + tmp0 := sym_simple_DASH_symbol_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a symbol without a namespace", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(1623), kw_end_DASH_line, int(1623))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "and__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + tmp8 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp9 := checkDerefVar(var_glojure_DOT_core_namespace) + tmp10 := lang.Apply(tmp9, []any{v2}) + tmp11 := lang.Apply(tmp8, []any{tmp10}) + tmp7 = tmp11 } else { + tmp7 = v6 } - return tmp6 - } + tmp3 = tmp7 + } // end let + return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_simple_DASH_symbol_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_simple_DASH_symbol_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // disj! + // some-fn { - tmp0 := sym_disj_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_set), lang.NewVector(sym_set, sym_key), lang.NewVector(sym_set, sym_key, sym__AMP_, sym_ks)), kw_doc, "disj[oin]. Returns a transient set of the same (hashed/sorted) type, that\n does not contain key(s).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3401), kw_end_DASH_line, int(3401))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_some_DASH_fn.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_p), lang.NewVector(sym_p1, sym_p2), lang.NewVector(sym_p1, sym_p2, sym_p3), lang.NewVector(sym_p1, sym_p2, sym_p3, sym__AMP_, sym_ps)), kw_doc, "Takes a set of predicates and returns a function f that returns the first logical true value\n returned by one of its composing predicates against any of its arguments, else it returns\n logical false. Note that f is short-circuiting in that it will stop execution on the first\n argument that triggers a logical true result against the original predicates.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(7462), kw_end_DASH_line, int(7462))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: - v3 := args[0] - _ = v3 - return v3 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5, _ := lang.FieldOrMethod(v3, "Disjoin") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Disjoin is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - default: - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - recur_loop_615: - var tmp6 any - { // let - // let binding "ret" - tmp7, _ := lang.FieldOrMethod(v3, "Disjoin") - if reflect.TypeOf(tmp7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Disjoin is not a function"))) - } - tmp8 := lang.Apply(tmp7, []any{v4}) - var v9 any = tmp8 - _ = v9 - var tmp10 any - if lang.IsTruthy(v5) { - var tmp11 any = v9 - tmp13 := checkDerefVar(var_glojure_DOT_core_first) - tmp14 := lang.Apply(tmp13, []any{v5}) - var tmp12 any = tmp14 - tmp16 := checkDerefVar(var_glojure_DOT_core_next) - tmp17 := lang.Apply(tmp16, []any{v5}) - var tmp15 any = tmp17 - v3 = tmp11 - v4 = tmp12 - v5 = tmp15 - goto recur_loop_615 - } else { - tmp10 = v9 - } - tmp6 = tmp10 - } // end let - return tmp6 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // dissoc - { - tmp0 := sym_dissoc.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_map), lang.NewVector(sym_map, sym_key), lang.NewVector(sym_map, sym_key, sym__AMP_, sym_ks)), kw_doc, "dissoc[iate]. Returns a new map of the same (hashed/sorted) type,\n that does not contain a mapping for key(s).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(1500), kw_end_DASH_line, int(1500))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - return v3 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5, _ := lang.FieldOrMethod(runtime.RT, "Dissoc") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Dissoc is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v3, v4}) - return tmp6 - default: - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - recur_loop_301: - var tmp6 any - { // let - // let binding "ret" - tmp7 := checkDerefVar(var_glojure_DOT_core_dissoc) - tmp8 := lang.Apply(tmp7, []any{v3, v4}) - var v9 any = tmp8 - _ = v9 - var tmp10 any - if lang.IsTruthy(v5) { - var tmp11 any = v9 - tmp13 := checkDerefVar(var_glojure_DOT_core_first) - tmp14 := lang.Apply(tmp13, []any{v5}) - var tmp12 any = tmp14 - tmp16 := checkDerefVar(var_glojure_DOT_core_next) - tmp17 := lang.Apply(tmp16, []any{v5}) - var tmp15 any = tmp17 - v3 = tmp11 - v4 = tmp12 - v5 = tmp15 - goto recur_loop_301 - } else { - tmp10 = v9 - } - tmp6 = tmp10 - } // end let - return tmp6 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // dissoc! - { - tmp0 := sym_dissoc_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_map, sym_key), lang.NewVector(sym_map, sym_key, sym__AMP_, sym_ks)), kw_doc, "Returns a transient map that doesn't contain a mapping for key(s).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(3382), kw_end_DASH_line, int(3382))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5, _ := lang.FieldOrMethod(v3, "without") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("without is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - default: - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - recur_loop_611: - var tmp6 any - { // let - // let binding "ret" - tmp7, _ := lang.FieldOrMethod(v3, "without") - if reflect.TypeOf(tmp7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("without is not a function"))) - } - tmp8 := lang.Apply(tmp7, []any{v4}) - var v9 any = tmp8 - _ = v9 - var tmp10 any - if lang.IsTruthy(v5) { - var tmp11 any = v9 - tmp13 := checkDerefVar(var_glojure_DOT_core_first) - tmp14 := lang.Apply(tmp13, []any{v5}) - var tmp12 any = tmp14 - tmp16 := checkDerefVar(var_glojure_DOT_core_next) - tmp17 := lang.Apply(tmp16, []any{v5}) - var tmp15 any = tmp17 - v3 = tmp11 - v4 = tmp12 - v5 = tmp15 - goto recur_loop_611 - } else { - tmp10 = v9 - } - tmp6 = tmp10 - } // end let - return tmp6 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // distinct - { - tmp0 := sym_distinct.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_coll)), kw_doc, "Returns a lazy sequence of the elements of coll with duplicates removed.\n Returns a stateful transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(5053), kw_end_DASH_line, int(5053))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: + v2 := args[0] + _ = v2 var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - var tmp5 any - { // let - // let binding "seen" - tmp6 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) - tmp7 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) - tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5060), kw_column, int(28), kw_end_DASH_line, int(5060), kw_end_DASH_column, int(30)) - tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp10 := lang.Apply(tmp6, []any{tmp9}) - var v11 any = tmp10 - _ = v11 - var tmp12 lang.FnFunc - tmp12 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp13 := lang.Apply(v4, nil) - return tmp13 - case 1: - v13 := args[0] - _ = v13 - tmp14 := lang.Apply(v4, []any{v13}) - return tmp14 - case 2: - v13 := args[0] - _ = v13 - v14 := args[1] - _ = v14 - var tmp15 any - tmp16 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) - tmp17 := checkDerefVar(var_glojure_DOT_core_deref) - tmp18 := lang.Apply(tmp17, []any{v11}) - tmp19 := lang.Apply(tmp16, []any{tmp18, v14}) - if lang.IsTruthy(tmp19) { - tmp15 = v13 + { // function sp1 + var v4 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return nil + case 1: + v5 := args[0] + _ = v5 + tmp6 := lang.Apply(v2, []any{v5}) + return tmp6 + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + var tmp7 any + { // let + // let binding "or__0__auto__" + tmp8 := lang.Apply(v2, []any{v5}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + tmp10 = v9 } else { - tmp20 := checkDerefVar(var_glojure_DOT_core_conj) - tmp21, ok := lang.FieldOrMethod(v11, "Deref") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v11, "Deref"))) - } - var tmp22 any - switch reflect.TypeOf(tmp21).Kind() { - case reflect.Func: - tmp22 = lang.Apply(tmp21, nil) - default: - tmp22 = tmp21 - } - tmp23 := lang.Apply(tmp20, []any{tmp22, v14}) - tmp24, _ := lang.FieldOrMethod(v11, "reset") - if reflect.TypeOf(tmp24).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) - } - tmp25 := lang.Apply(tmp24, []any{tmp23}) - _ = tmp25 - tmp26 := lang.Apply(v4, []any{v13, v14}) - tmp15 = tmp26 + tmp11 := lang.Apply(v2, []any{v6}) + tmp10 = tmp11 } - return tmp15 - default: - checkArity(args, -1) - panic("unreachable") - } - }) - tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5061), kw_column, int(8), kw_end_DASH_line, int(5068), kw_end_DASH_column, int(37)) - tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) - if err != nil { - panic(err) + tmp7 = tmp10 + } // end let + return tmp7 + case 3: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := args[2] + _ = v7 + var tmp8 any + { // let + // let binding "or__0__auto__" + tmp9 := lang.Apply(v2, []any{v5}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + if lang.IsTruthy(v10) { + tmp11 = v10 + } else { + var tmp12 any + { // let + // let binding "or__0__auto__" + tmp13 := lang.Apply(v2, []any{v6}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + tmp15 = v14 + } else { + tmp16 := lang.Apply(v2, []any{v7}) + tmp15 = tmp16 + } + tmp12 = tmp15 + } // end let + tmp11 = tmp12 + } + tmp8 = tmp11 + } // end let + return tmp8 + default: + checkArity(args, 3) + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := args[2] + _ = v7 + var v8 any = lang.NewList(args[3:]...) + _ = v8 + var tmp9 any + { // let + // let binding "or__0__auto__" + tmp10 := lang.Apply(v4, []any{v5, v6, v7}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + tmp12 = v11 + } else { + tmp13 := checkDerefVar(var_glojure_DOT_core_some) + tmp14 := lang.Apply(tmp13, []any{v2, v8}) + tmp12 = tmp14 + } + tmp9 = tmp12 + } // end let + return tmp9 } - tmp5 = tmp14 - } // end let - return tmp5 - }) - tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5059), kw_column, int(4), kw_end_DASH_line, int(5068), kw_end_DASH_column, int(39)) + }) + v4 = tmp3 + _ = v4 + } + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7469), kw_column, int(6), kw_end_DASH_line, int(7475), kw_end_DASH_column, int(43)) tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) if err != nil { panic(err) } return tmp5 - case 1: - v3 := args[0] + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - var tmp4 any - { // let - // let binding "step" - var tmp5 lang.FnFunc - { // function step - var v6 lang.FnFunc - tmp5 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v7 := args[0] + var tmp4 lang.FnFunc + { // function sp2 + var v5 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return nil + case 1: + v6 := args[0] + _ = v6 + var tmp7 any + { // let + // let binding "or__0__auto__" + tmp8 := lang.Apply(v2, []any{v6}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + tmp10 = v9 + } else { + tmp11 := lang.Apply(v3, []any{v6}) + tmp10 = tmp11 + } + tmp7 = tmp10 + } // end let + return tmp7 + case 2: + v6 := args[0] + _ = v6 + v7 := args[1] _ = v7 - v8 := args[1] + var tmp8 any + { // let + // let binding "or__0__auto__" + tmp9 := lang.Apply(v2, []any{v6}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + if lang.IsTruthy(v10) { + tmp11 = v10 + } else { + var tmp12 any + { // let + // let binding "or__0__auto__" + tmp13 := lang.Apply(v2, []any{v7}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + tmp15 = v14 + } else { + var tmp16 any + { // let + // let binding "or__0__auto__" + tmp17 := lang.Apply(v3, []any{v6}) + var v18 any = tmp17 + _ = v18 + var tmp19 any + if lang.IsTruthy(v18) { + tmp19 = v18 + } else { + tmp20 := lang.Apply(v3, []any{v7}) + tmp19 = tmp20 + } + tmp16 = tmp19 + } // end let + tmp15 = tmp16 + } + tmp12 = tmp15 + } // end let + tmp11 = tmp12 + } + tmp8 = tmp11 + } // end let + return tmp8 + case 3: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] _ = v8 - var tmp9 lang.FnFunc - tmp9 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - var tmp10 lang.FnFunc - tmp10 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v11 := args[0] - _ = v11 - v12 := args[1] - _ = v12 - recur_loop_877: + var tmp9 any + { // let + // let binding "or__0__auto__" + tmp10 := lang.Apply(v2, []any{v6}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + tmp12 = v11 + } else { var tmp13 any { // let - // let binding "vec__62" - var v14 any = v11 - _ = v14 - // let binding "f" - tmp15 := checkDerefVar(var_glojure_DOT_core_nth) - tmp16 := lang.Apply(tmp15, []any{v14, int64(0), nil}) - var v17 any = tmp16 - _ = v17 - // let binding "xs" - var v18 any = v14 - _ = v18 - var tmp19 any + // let binding "or__0__auto__" + tmp14 := lang.Apply(v2, []any{v7}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + if lang.IsTruthy(v15) { + tmp16 = v15 + } else { + var tmp17 any + { // let + // let binding "or__0__auto__" + tmp18 := lang.Apply(v2, []any{v8}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + tmp20 = v19 + } else { + var tmp21 any + { // let + // let binding "or__0__auto__" + tmp22 := lang.Apply(v3, []any{v6}) + var v23 any = tmp22 + _ = v23 + var tmp24 any + if lang.IsTruthy(v23) { + tmp24 = v23 + } else { + var tmp25 any + { // let + // let binding "or__0__auto__" + tmp26 := lang.Apply(v3, []any{v7}) + var v27 any = tmp26 + _ = v27 + var tmp28 any + if lang.IsTruthy(v27) { + tmp28 = v27 + } else { + tmp29 := lang.Apply(v3, []any{v8}) + tmp28 = tmp29 + } + tmp25 = tmp28 + } // end let + tmp24 = tmp25 + } + tmp21 = tmp24 + } // end let + tmp20 = tmp21 + } + tmp17 = tmp20 + } // end let + tmp16 = tmp17 + } + tmp13 = tmp16 + } // end let + tmp12 = tmp13 + } + tmp9 = tmp12 + } // end let + return tmp9 + default: + checkArity(args, 3) + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + var v9 any = lang.NewList(args[3:]...) + _ = v9 + var tmp10 any + { // let + // let binding "or__0__auto__" + tmp11 := lang.Apply(v5, []any{v6, v7, v8}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + tmp13 = v12 + } else { + tmp14 := checkDerefVar(var_glojure_DOT_core_some) + var tmp15 lang.FnFunc + tmp15 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v16 := args[0] + _ = v16 + var tmp17 any { // let - // let binding "temp__0__auto__" - tmp20 := checkDerefVar(var_glojure_DOT_core_seq) - tmp21 := lang.Apply(tmp20, []any{v18}) - var v22 any = tmp21 - _ = v22 - var tmp23 any - if lang.IsTruthy(v22) { - var tmp24 any - { // let - // let binding "s" - var v25 any = v22 - _ = v25 - var tmp26 any - tmp27 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) - tmp28 := lang.Apply(tmp27, []any{v12, v17}) - if lang.IsTruthy(tmp28) { - tmp30 := checkDerefVar(var_glojure_DOT_core_rest) - tmp31 := lang.Apply(tmp30, []any{v25}) - var tmp29 any = tmp31 - var tmp32 any = v12 - v11 = tmp29 - v12 = tmp32 - goto recur_loop_877 - } else { - tmp33 := checkDerefVar(var_glojure_DOT_core_cons) - tmp34 := checkDerefVar(var_glojure_DOT_core_rest) - tmp35 := lang.Apply(tmp34, []any{v25}) - tmp36 := checkDerefVar(var_glojure_DOT_core_conj) - tmp37 := lang.Apply(tmp36, []any{v12, v17}) - tmp38 := lang.Apply(v6, []any{tmp35, tmp37}) - tmp39 := lang.Apply(tmp33, []any{v17, tmp38}) - tmp26 = tmp39 - } - tmp24 = tmp26 - } // end let - tmp23 = tmp24 + // let binding "or__0__auto__" + tmp18 := lang.Apply(v2, []any{v16}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + tmp20 = v19 } else { + tmp21 := lang.Apply(v3, []any{v16}) + tmp20 = tmp21 } - tmp19 = tmp23 + tmp17 = tmp20 } // end let - tmp13 = tmp19 - } // end let - return tmp13 - }) - tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5072), kw_column, int(20), kw_end_DASH_line, int(5076), kw_end_DASH_column, int(66)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) - if err != nil { - panic(err) + return tmp17 + }) + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7483), kw_column, int(34), kw_end_DASH_line, int(7483), kw_end_DASH_column, int(52)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp18 := lang.Apply(tmp14, []any{tmp17, v9}) + tmp13 = tmp18 } - tmp13 := lang.Apply(tmp12, []any{v7, v8}) - return tmp13 - }) - tmp10 := lang.Apply(lang.NewLazySeq, []any{tmp9}) + tmp10 = tmp13 + } // end let return tmp10 - }) - v6 = tmp5 - _ = v6 - } - tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5070), kw_column, int(15), kw_end_DASH_line, int(5077), kw_end_DASH_column, int(29)) - tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v8 any = tmp7 - _ = v8 - tmp9 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) - tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5078), kw_column, int(17), kw_end_DASH_line, int(5078), kw_end_DASH_column, int(19)) - tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp12 := lang.Apply(v8, []any{v3, tmp11}) - tmp4 = tmp12 - } // end let - return tmp4 - default: - checkArity(args, -1) - panic("unreachable") - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // distinct? - { - tmp1 := reflect.TypeOf(false) - tmp0 := sym_distinct_QMARK_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_doc, "Returns true if no two of the arguments are =", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(5664), kw_end_DASH_line, int(5664))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v4 := args[0] - _ = v4 - return true - case 2: - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6 := checkDerefVar(var_glojure_DOT_core_not) - tmp7 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp8 := lang.Apply(tmp7, []any{v4, v5}) - tmp9 := lang.Apply(tmp6, []any{tmp8}) - return tmp9 + } + }) + v5 = tmp4 + _ = v5 + } + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7477), kw_column, int(6), kw_end_DASH_line, int(7483), kw_end_DASH_column, int(61)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 lang.FnFunc + { // function sp3 + var v6 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return nil + case 1: + v7 := args[0] + _ = v7 + var tmp8 any + { // let + // let binding "or__0__auto__" + tmp9 := lang.Apply(v2, []any{v7}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + if lang.IsTruthy(v10) { + tmp11 = v10 + } else { + var tmp12 any + { // let + // let binding "or__0__auto__" + tmp13 := lang.Apply(v3, []any{v7}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + tmp15 = v14 + } else { + tmp16 := lang.Apply(v4, []any{v7}) + tmp15 = tmp16 + } + tmp12 = tmp15 + } // end let + tmp11 = tmp12 + } + tmp8 = tmp11 + } // end let + return tmp8 + case 2: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + var tmp9 any + { // let + // let binding "or__0__auto__" + tmp10 := lang.Apply(v2, []any{v7}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + tmp12 = v11 + } else { + var tmp13 any + { // let + // let binding "or__0__auto__" + tmp14 := lang.Apply(v2, []any{v8}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + if lang.IsTruthy(v15) { + tmp16 = v15 + } else { + var tmp17 any + { // let + // let binding "or__0__auto__" + tmp18 := lang.Apply(v3, []any{v7}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + tmp20 = v19 + } else { + var tmp21 any + { // let + // let binding "or__0__auto__" + tmp22 := lang.Apply(v3, []any{v8}) + var v23 any = tmp22 + _ = v23 + var tmp24 any + if lang.IsTruthy(v23) { + tmp24 = v23 + } else { + var tmp25 any + { // let + // let binding "or__0__auto__" + tmp26 := lang.Apply(v4, []any{v7}) + var v27 any = tmp26 + _ = v27 + var tmp28 any + if lang.IsTruthy(v27) { + tmp28 = v27 + } else { + tmp29 := lang.Apply(v4, []any{v8}) + tmp28 = tmp29 + } + tmp25 = tmp28 + } // end let + tmp24 = tmp25 + } + tmp21 = tmp24 + } // end let + tmp20 = tmp21 + } + tmp17 = tmp20 + } // end let + tmp16 = tmp17 + } + tmp13 = tmp16 + } // end let + tmp12 = tmp13 + } + tmp9 = tmp12 + } // end let + return tmp9 + case 3: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + var tmp10 any + { // let + // let binding "or__0__auto__" + tmp11 := lang.Apply(v2, []any{v7}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + tmp13 = v12 + } else { + var tmp14 any + { // let + // let binding "or__0__auto__" + tmp15 := lang.Apply(v2, []any{v8}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + if lang.IsTruthy(v16) { + tmp17 = v16 + } else { + var tmp18 any + { // let + // let binding "or__0__auto__" + tmp19 := lang.Apply(v2, []any{v9}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + tmp21 = v20 + } else { + var tmp22 any + { // let + // let binding "or__0__auto__" + tmp23 := lang.Apply(v3, []any{v7}) + var v24 any = tmp23 + _ = v24 + var tmp25 any + if lang.IsTruthy(v24) { + tmp25 = v24 + } else { + var tmp26 any + { // let + // let binding "or__0__auto__" + tmp27 := lang.Apply(v3, []any{v8}) + var v28 any = tmp27 + _ = v28 + var tmp29 any + if lang.IsTruthy(v28) { + tmp29 = v28 + } else { + var tmp30 any + { // let + // let binding "or__0__auto__" + tmp31 := lang.Apply(v3, []any{v9}) + var v32 any = tmp31 + _ = v32 + var tmp33 any + if lang.IsTruthy(v32) { + tmp33 = v32 + } else { + var tmp34 any + { // let + // let binding "or__0__auto__" + tmp35 := lang.Apply(v4, []any{v7}) + var v36 any = tmp35 + _ = v36 + var tmp37 any + if lang.IsTruthy(v36) { + tmp37 = v36 + } else { + var tmp38 any + { // let + // let binding "or__0__auto__" + tmp39 := lang.Apply(v4, []any{v8}) + var v40 any = tmp39 + _ = v40 + var tmp41 any + if lang.IsTruthy(v40) { + tmp41 = v40 + } else { + tmp42 := lang.Apply(v4, []any{v9}) + tmp41 = tmp42 + } + tmp38 = tmp41 + } // end let + tmp37 = tmp38 + } + tmp34 = tmp37 + } // end let + tmp33 = tmp34 + } + tmp30 = tmp33 + } // end let + tmp29 = tmp30 + } + tmp26 = tmp29 + } // end let + tmp25 = tmp26 + } + tmp22 = tmp25 + } // end let + tmp21 = tmp22 + } + tmp18 = tmp21 + } // end let + tmp17 = tmp18 + } + tmp14 = tmp17 + } // end let + tmp13 = tmp14 + } + tmp10 = tmp13 + } // end let + return tmp10 + default: + checkArity(args, 3) + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + var v10 any = lang.NewList(args[3:]...) + _ = v10 + var tmp11 any + { // let + // let binding "or__0__auto__" + tmp12 := lang.Apply(v6, []any{v7, v8, v9}) + var v13 any = tmp12 + _ = v13 + var tmp14 any + if lang.IsTruthy(v13) { + tmp14 = v13 + } else { + tmp15 := checkDerefVar(var_glojure_DOT_core_some) + var tmp16 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v17 := args[0] + _ = v17 + var tmp18 any + { // let + // let binding "or__0__auto__" + tmp19 := lang.Apply(v2, []any{v17}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + tmp21 = v20 + } else { + var tmp22 any + { // let + // let binding "or__0__auto__" + tmp23 := lang.Apply(v3, []any{v17}) + var v24 any = tmp23 + _ = v24 + var tmp25 any + if lang.IsTruthy(v24) { + tmp25 = v24 + } else { + tmp26 := lang.Apply(v4, []any{v17}) + tmp25 = tmp26 + } + tmp22 = tmp25 + } // end let + tmp21 = tmp22 + } + tmp18 = tmp21 + } // end let + return tmp18 + }) + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7491), kw_column, int(34), kw_end_DASH_line, int(7491), kw_end_DASH_column, int(59)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp19 := lang.Apply(tmp15, []any{tmp18, v10}) + tmp14 = tmp19 + } + tmp11 = tmp14 + } // end let + return tmp11 + } + }) + v6 = tmp5 + _ = v6 + } + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7485), kw_column, int(6), kw_end_DASH_line, int(7491), kw_end_DASH_column, int(68)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp7 default: - checkArity(args, 2) - v4 := args[0] + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] _ = v4 - v5 := args[1] + var v5 any = lang.NewList(args[3:]...) _ = v5 - var v6 any = lang.NewList(args[2:]...) - _ = v6 - var tmp7 any - tmp8 := checkDerefVar(var_glojure_DOT_core_not_EQ_) - tmp9 := lang.Apply(tmp8, []any{v4, v5}) - if lang.IsTruthy(tmp9) { - var tmp10 any - { // let - // let binding "s" - tmp11 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{v4, v5})) - tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5673), kw_column, int(15), kw_end_DASH_line, int(5673), kw_end_DASH_column, int(20)) - tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v14 any = tmp13 - _ = v14 - // let binding "G__99" - var v15 any = v6 - _ = v15 - // let binding "vec__100" - var v16 any = v15 - _ = v16 - // let binding "seq__101" - tmp17 := checkDerefVar(var_glojure_DOT_core_seq) - tmp18 := lang.Apply(tmp17, []any{v16}) - var v19 any = tmp18 - _ = v19 - // let binding "first__102" - tmp20 := checkDerefVar(var_glojure_DOT_core_first) - tmp21 := lang.Apply(tmp20, []any{v19}) - var v22 any = tmp21 - _ = v22 - // let binding "seq__101" - tmp23 := checkDerefVar(var_glojure_DOT_core_next) - tmp24 := lang.Apply(tmp23, []any{v19}) - var v25 any = tmp24 - _ = v25 - // let binding "x" - var v26 any = v22 - _ = v26 - // let binding "etc" - var v27 any = v25 - _ = v27 - // let binding "xs" - var v28 any = v16 - _ = v28 - var tmp29 any - { // let - // let binding "s" - var v30 any = v14 - _ = v30 - // let binding "G__99" - var v31 any = v15 - _ = v31 - for { - var tmp32 any - { // let - // let binding "s" - var v33 any = v30 - _ = v33 - // let binding "vec__103" - var v34 any = v31 - _ = v34 - // let binding "seq__104" - tmp35 := checkDerefVar(var_glojure_DOT_core_seq) - tmp36 := lang.Apply(tmp35, []any{v34}) - var v37 any = tmp36 - _ = v37 - // let binding "first__105" - tmp38 := checkDerefVar(var_glojure_DOT_core_first) - tmp39 := lang.Apply(tmp38, []any{v37}) - var v40 any = tmp39 - _ = v40 - // let binding "seq__104" - tmp41 := checkDerefVar(var_glojure_DOT_core_next) - tmp42 := lang.Apply(tmp41, []any{v37}) - var v43 any = tmp42 - _ = v43 - // let binding "x" - var v44 any = v40 - _ = v44 - // let binding "etc" - var v45 any = v43 - _ = v45 - // let binding "xs" - var v46 any = v34 - _ = v46 - var tmp47 any - if lang.IsTruthy(v46) { - var tmp48 any - tmp49 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) - tmp50 := lang.Apply(tmp49, []any{v33, v44}) - if lang.IsTruthy(tmp50) { - tmp48 = false + var tmp6 any + { // let + // let binding "ps" + tmp7 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp8 := lang.Apply(tmp7, []any{v2, v3, v4, v5}) + var v9 any = tmp8 + _ = v9 + var tmp10 lang.FnFunc + { // function spn + var v11 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return nil + case 1: + v12 := args[0] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_some) + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v15 := args[0] + _ = v15 + tmp16 := lang.Apply(v15, []any{v12}) + return tmp16 + }) + tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7496), kw_column, int(21), kw_end_DASH_line, int(7496), kw_end_DASH_column, int(26)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp17 := lang.Apply(tmp13, []any{tmp16, v9}) + return tmp17 + case 2: + v12 := args[0] + _ = v12 + v13 := args[1] + _ = v13 + tmp14 := checkDerefVar(var_glojure_DOT_core_some) + var tmp15 lang.FnFunc + tmp15 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v16 := args[0] + _ = v16 + var tmp17 any + { // let + // let binding "or__0__auto__" + tmp18 := lang.Apply(v16, []any{v12}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + tmp20 = v19 } else { - tmp52 := checkDerefVar(var_glojure_DOT_core_conj) - tmp53 := lang.Apply(tmp52, []any{v33, v44}) - var tmp51 any = tmp53 - var tmp54 any = v45 - v30 = tmp51 - v31 = tmp54 - continue + tmp21 := lang.Apply(v16, []any{v13}) + tmp20 = tmp21 + } + tmp17 = tmp20 + } // end let + return tmp17 + }) + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7497), kw_column, int(23), kw_end_DASH_line, int(7497), kw_end_DASH_column, int(39)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp18 := lang.Apply(tmp14, []any{tmp17, v9}) + return tmp18 + case 3: + v12 := args[0] + _ = v12 + v13 := args[1] + _ = v13 + v14 := args[2] + _ = v14 + tmp15 := checkDerefVar(var_glojure_DOT_core_some) + var tmp16 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v17 := args[0] + _ = v17 + var tmp18 any + { // let + // let binding "or__0__auto__" + tmp19 := lang.Apply(v17, []any{v12}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + tmp21 = v20 + } else { + var tmp22 any + { // let + // let binding "or__0__auto__" + tmp23 := lang.Apply(v17, []any{v13}) + var v24 any = tmp23 + _ = v24 + var tmp25 any + if lang.IsTruthy(v24) { + tmp25 = v24 + } else { + tmp26 := lang.Apply(v17, []any{v14}) + tmp25 = tmp26 + } + tmp22 = tmp25 + } // end let + tmp21 = tmp22 } - tmp47 = tmp48 + tmp18 = tmp21 + } // end let + return tmp18 + }) + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7498), kw_column, int(25), kw_end_DASH_line, int(7498), kw_end_DASH_column, int(47)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp19 := lang.Apply(tmp15, []any{tmp18, v9}) + return tmp19 + default: + checkArity(args, 3) + v12 := args[0] + _ = v12 + v13 := args[1] + _ = v13 + v14 := args[2] + _ = v14 + var v15 any = lang.NewList(args[3:]...) + _ = v15 + var tmp16 any + { // let + // let binding "or__0__auto__" + tmp17 := lang.Apply(v11, []any{v12, v13, v14}) + var v18 any = tmp17 + _ = v18 + var tmp19 any + if lang.IsTruthy(v18) { + tmp19 = v18 } else { - tmp47 = true + tmp20 := checkDerefVar(var_glojure_DOT_core_some) + var tmp21 lang.FnFunc + tmp21 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v22 := args[0] + _ = v22 + tmp23 := checkDerefVar(var_glojure_DOT_core_some) + tmp24 := lang.Apply(tmp23, []any{v22, v15}) + return tmp24 + }) + tmp22 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7500), kw_column, int(36), kw_end_DASH_line, int(7500), kw_end_DASH_column, int(49)) + tmp23, err := lang.WithMeta(tmp21, tmp22.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp24 := lang.Apply(tmp20, []any{tmp23, v9}) + tmp19 = tmp24 } - tmp32 = tmp47 + tmp16 = tmp19 } // end let - tmp29 = tmp32 - break + return tmp16 } - } // end let - tmp10 = tmp29 - } // end let - tmp7 = tmp10 - } else { - tmp7 = false - } - return tmp7 + }) + v11 = tmp10 + _ = v11 + } + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7494), kw_column, int(8), kw_end_DASH_line, int(7500), kw_end_DASH_column, int(56)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp6 = tmp12 + } // end let + return tmp6 } }) - tmp4 := reflect.TypeOf(false) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_some_DASH_fn = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_some_DASH_fn.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // doall + // split-with { - tmp0 := sym_doall.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll), lang.NewVector(sym_n, sym_coll)), kw_doc, "When lazy sequences are produced via functions that have side\n effects, any effects other than those needed to produce the first\n element in the seq do not occur until the seq is consumed. doall can\n be used to force any effects. Walks through the successive nexts of\n the seq, retains the head and returns it, thus causing the entire\n seq to reside in memory at one time.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3131), kw_end_DASH_line, int(3131))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_dorun) - tmp5 := lang.Apply(tmp4, []any{v3}) - _ = tmp5 - return v3 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_dorun) - tmp6 := lang.Apply(tmp5, []any{v3, v4}) - _ = tmp6 - return v4 - default: - checkArity(args, -1) - panic("unreachable") + tmp0 := sym_split_DASH_with.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns a vector of [(take-while pred coll) (drop-while pred coll)]", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(2990), kw_end_DASH_line, int(2990))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_take_DASH_while) + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + tmp6 := checkDerefVar(var_glojure_DOT_core_drop_DASH_while) + tmp7 := lang.Apply(tmp6, []any{v2, v3}) + tmp8 := lang.NewVector(tmp5, tmp7) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2995), kw_column, int(5), kw_end_DASH_line, int(2995), kw_end_DASH_column, int(51)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) } + return tmp10 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_split_DASH_with = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_split_DASH_with.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // dorun + // stream-into! { - tmp0 := sym_dorun.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll), lang.NewVector(sym_n, sym_coll)), kw_doc, "When lazy sequences are produced via functions that have side\n effects, any effects other than those needed to produce the first\n element in the seq do not occur until the seq is consumed. dorun can\n be used to force any effects. Walks through the successive nexts of\n the seq, does not retain the head and returns nil.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3116), kw_end_DASH_line, int(3116))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_stream_DASH_into_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_to, sym_stream), lang.NewVector(sym_to, sym_xform, sym_stream)), kw_doc, "Returns a new coll consisting of coll with all of the items of the\n stream conjoined. This is a terminal operation on the stream.", kw_file, "glojure/core.glj", kw_added, "1.12", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(6810), kw_end_DASH_line, int(6810))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 1: - v3 := args[0] + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - recur_loop_579: var tmp4 any - { // let - // let binding "temp__0__auto__" - tmp5 := checkDerefVar(var_glojure_DOT_core_seq) - tmp6 := lang.Apply(tmp5, []any{v3}) - var v7 any = tmp6 - _ = v7 - var tmp8 any - if lang.IsTruthy(v7) { - var tmp9 any - { // let - // let binding "s" - var v10 any = v7 - _ = v10 - tmp12 := checkDerefVar(var_glojure_DOT_core_next) - tmp13 := lang.Apply(tmp12, []any{v10}) - var tmp11 any = tmp13 - v3 = tmp11 - goto recur_loop_579 - } // end let - tmp8 = tmp9 - } else { - } - tmp4 = tmp8 - } // end let + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp6 := reflect.TypeOf((*lang.IEditableCollection)(nil)).Elem() + tmp7 := lang.Apply(tmp5, []any{tmp6, v2}) + if lang.IsTruthy(tmp7) { + tmp8 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp9 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp10 := checkDerefVar(var_glojure_DOT_core_stream_DASH_reduce_BANG_) + tmp11 := checkDerefVar(var_glojure_DOT_core_conj_BANG_) + tmp12 := checkDerefVar(var_glojure_DOT_core_transient) + tmp13 := lang.Apply(tmp12, []any{v2}) + tmp14 := lang.Apply(tmp10, []any{tmp11, tmp13, v3}) + tmp15 := lang.Apply(tmp9, []any{tmp14}) + tmp16 := checkDerefVar(var_glojure_DOT_core_meta) + tmp17 := lang.Apply(tmp16, []any{v2}) + tmp18 := lang.Apply(tmp8, []any{tmp15, tmp17}) + tmp4 = tmp18 + } else { + tmp19 := checkDerefVar(var_glojure_DOT_core_stream_DASH_reduce_BANG_) + tmp20 := checkDerefVar(var_glojure_DOT_core_conj) + tmp21 := lang.Apply(tmp19, []any{tmp20, v2, v3}) + tmp4 = tmp21 + } return tmp4 - case 2: - v3 := args[0] + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + v4 := args[2] _ = v4 - recur_loop_580: var tmp5 any - var tmp6 any - { // let - // let binding "and__0__auto__" - tmp7 := checkDerefVar(var_glojure_DOT_core_seq) - tmp8 := lang.Apply(tmp7, []any{v4}) - var v9 any = tmp8 - _ = v9 - var tmp10 any - if lang.IsTruthy(v9) { - tmp11 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) - tmp12 := lang.Apply(tmp11, []any{v3}) - tmp10 = tmp12 - } else { - tmp10 = v9 - } - tmp6 = tmp10 - } // end let - if lang.IsTruthy(tmp6) { - tmp8 := checkDerefVar(var_glojure_DOT_core_dec) - tmp9 := lang.Apply(tmp8, []any{v3}) - var tmp7 any = tmp9 - tmp11 := checkDerefVar(var_glojure_DOT_core_next) - tmp12 := lang.Apply(tmp11, []any{v4}) - var tmp10 any = tmp12 - v3 = tmp7 - v4 = tmp10 - goto recur_loop_580 + tmp6 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp7 := reflect.TypeOf((*lang.IEditableCollection)(nil)).Elem() + tmp8 := lang.Apply(tmp6, []any{tmp7, v2}) + if lang.IsTruthy(tmp8) { + tmp9 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp10 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp11 := checkDerefVar(var_glojure_DOT_core_stream_DASH_transduce_BANG_) + tmp12 := checkDerefVar(var_glojure_DOT_core_conj_BANG_) + tmp13 := checkDerefVar(var_glojure_DOT_core_transient) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(tmp11, []any{v3, tmp12, tmp14, v4}) + tmp16 := lang.Apply(tmp10, []any{tmp15}) + tmp17 := checkDerefVar(var_glojure_DOT_core_meta) + tmp18 := lang.Apply(tmp17, []any{v2}) + tmp19 := lang.Apply(tmp9, []any{tmp16, tmp18}) + tmp5 = tmp19 } else { + tmp20 := checkDerefVar(var_glojure_DOT_core_stream_DASH_transduce_BANG_) + tmp21 := checkDerefVar(var_glojure_DOT_core_conj) + tmp22 := lang.Apply(tmp20, []any{v3, tmp21, v2, v4}) + tmp5 = tmp22 } return tmp5 default: @@ -19249,961 +15198,358 @@ func LoadNS() { panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_stream_DASH_into_BANG_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_stream_DASH_into_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // doseq + // subvec { - tmp0 := sym_doseq.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_seq_DASH_exprs, sym__AMP_, sym_body)), kw_doc, "Repeatedly executes body (presumably for side-effects) with\n bindings and filtering as provided by \"for\". Does not retain\n the head of the sequence. Returns nil.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(11), kw_line, int(3209), kw_end_DASH_line, int(3209))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_subvec.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_v, sym_start), lang.NewVector(sym_v, sym_start, sym_end)), kw_doc, "Returns a persistent vector of the items in vector from\n start (inclusive) to end (exclusive). If end is not supplied,\n defaults to (count vector). This operation is O(1) and very fast, as\n the resulting vector shares structure with the original and no\n trimming is done.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(3819), kw_end_DASH_line, int(3819))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - default: - checkArity(args, 3) - v3 := args[0] + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + tmp4 := checkDerefVar(var_glojure_DOT_core_subvec) + tmp5 := checkDerefVar(var_glojure_DOT_core_count) + tmp6 := lang.Apply(tmp5, []any{v2}) + tmp7 := lang.Apply(tmp4, []any{v2, v3, tmp6}) + return tmp7 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any - tmp8 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) - tmp9 := lang.Apply(tmp8, []any{v5}) - if lang.IsTruthy(tmp9) { - } else { - tmp10 := checkDerefVar(var_glojure_DOT_core_str) - tmp11 := checkDerefVar(var_glojure_DOT_core_first) - tmp12 := lang.Apply(tmp11, []any{v3}) - tmp13 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) - tmp14 := checkDerefVar(var_glojure_DOT_core_meta) - tmp15 := lang.Apply(tmp14, []any{v3}) - tmp16 := lang.Apply(kw_line, []any{tmp15}) - tmp17 := lang.Apply(tmp10, []any{tmp12, " requires ", "a vector for its binding", " in ", tmp13, ":", tmp16}) - tmp18 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp17}) - panic(tmp18) + tmp5, _ := lang.FieldOrMethod(runtime.RT, "Subvec") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Subvec is not a function"))) } - _ = tmp7 - var tmp19 any - tmp20 := checkDerefVar(var_glojure_DOT_core_even_QMARK_) - tmp21 := checkDerefVar(var_glojure_DOT_core_count) - tmp22 := lang.Apply(tmp21, []any{v5}) - tmp23 := lang.Apply(tmp20, []any{tmp22}) - if lang.IsTruthy(tmp23) { - } else { - tmp24 := checkDerefVar(var_glojure_DOT_core_str) - tmp25 := checkDerefVar(var_glojure_DOT_core_first) - tmp26 := lang.Apply(tmp25, []any{v3}) - tmp27 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) - tmp28 := checkDerefVar(var_glojure_DOT_core_meta) - tmp29 := lang.Apply(tmp28, []any{v3}) - tmp30 := lang.Apply(kw_line, []any{tmp29}) - tmp31 := lang.Apply(tmp24, []any{tmp26, " requires ", "an even number of forms in binding vector", " in ", tmp27, ":", tmp30}) - tmp32 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp31}) - panic(tmp32) - } - _ = tmp19 - var tmp33 any - { // let - // let binding "step" - var tmp34 lang.FnFunc - { // function step - var v35 lang.FnFunc - tmp34 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v36 := args[0] - _ = v36 - v37 := args[1] - _ = v37 - var tmp38 any - tmp39 := checkDerefVar(var_glojure_DOT_core_not) - tmp40 := lang.Apply(tmp39, []any{v37}) - if lang.IsTruthy(tmp40) { - tmp41 := checkDerefVar(var_glojure_DOT_core_seq) - tmp42 := checkDerefVar(var_glojure_DOT_core_concat) - tmp43 := checkDerefVar(var_glojure_DOT_core_list) - tmp44 := lang.Apply(tmp43, []any{sym_do}) - tmp45 := lang.Apply(tmp42, []any{tmp44, v6}) - tmp46 := lang.Apply(tmp41, []any{tmp45}) - tmp47 := lang.NewVector(true, tmp46) - tmp48 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3220), kw_column, int(18), kw_end_DASH_line, int(3220), kw_end_DASH_column, int(36)) - tmp49, err := lang.WithMeta(tmp47, tmp48.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp38 = tmp49 - } else { - var tmp50 any - { // let - // let binding "k" - tmp51 := checkDerefVar(var_glojure_DOT_core_first) - tmp52 := lang.Apply(tmp51, []any{v37}) - var v53 any = tmp52 - _ = v53 - // let binding "v" - tmp54 := checkDerefVar(var_glojure_DOT_core_second) - tmp55 := lang.Apply(tmp54, []any{v37}) - var v56 any = tmp55 - _ = v56 - var tmp57 any - tmp58 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) - tmp59 := lang.Apply(tmp58, []any{v53}) - if lang.IsTruthy(tmp59) { - var tmp60 any - { // let - // let binding "steppair" - tmp61 := checkDerefVar(var_glojure_DOT_core_nnext) - tmp62 := lang.Apply(tmp61, []any{v37}) - tmp63 := lang.Apply(v35, []any{v36, tmp62}) - var v64 any = tmp63 - _ = v64 - // let binding "needrec" - tmp65 := lang.Apply(v64, []any{int64(0)}) - var v66 any = tmp65 - _ = v66 - // let binding "subform" - tmp67 := lang.Apply(v64, []any{int64(1)}) - var v68 any = tmp67 - _ = v68 - var tmp69 any - tmp70 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp71 := lang.Apply(tmp70, []any{v53, kw_let}) - if lang.IsTruthy(tmp71) { - tmp72 := checkDerefVar(var_glojure_DOT_core_seq) - tmp73 := checkDerefVar(var_glojure_DOT_core_concat) - tmp74 := checkDerefVar(var_glojure_DOT_core_list) - tmp75 := lang.Apply(tmp74, []any{sym_glojure_DOT_core_SLASH_let}) - tmp76 := checkDerefVar(var_glojure_DOT_core_list) - tmp77 := lang.Apply(tmp76, []any{v56}) - tmp78 := checkDerefVar(var_glojure_DOT_core_list) - tmp79 := lang.Apply(tmp78, []any{v68}) - tmp80 := lang.Apply(tmp73, []any{tmp75, tmp77, tmp79}) - tmp81 := lang.Apply(tmp72, []any{tmp80}) - tmp82 := lang.NewVector(v66, tmp81) - tmp83 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3228), kw_column, int(37), kw_end_DASH_line, int(3228), kw_end_DASH_column, int(64)) - tmp84, err := lang.WithMeta(tmp82, tmp83.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp69 = tmp84 - } else { - var tmp85 any - tmp86 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp87 := lang.Apply(tmp86, []any{v53, kw_while}) - if lang.IsTruthy(tmp87) { - tmp88 := checkDerefVar(var_glojure_DOT_core_seq) - tmp89 := checkDerefVar(var_glojure_DOT_core_concat) - tmp90 := checkDerefVar(var_glojure_DOT_core_list) - tmp91 := lang.Apply(tmp90, []any{sym_glojure_DOT_core_SLASH_when}) - tmp92 := checkDerefVar(var_glojure_DOT_core_list) - tmp93 := lang.Apply(tmp92, []any{v56}) - tmp94 := checkDerefVar(var_glojure_DOT_core_list) - tmp95 := lang.Apply(tmp94, []any{v68}) - var tmp96 any - if lang.IsTruthy(v66) { - tmp97 := lang.NewVector(v36) - tmp98 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3231), kw_column, int(65), kw_end_DASH_line, int(3231), kw_end_DASH_column, int(73)) - tmp99, err := lang.WithMeta(tmp97, tmp98.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp96 = tmp99 - } else { - } - tmp100 := lang.Apply(tmp89, []any{tmp91, tmp93, tmp95, tmp96}) - tmp101 := lang.Apply(tmp88, []any{tmp100}) - tmp102 := lang.NewVector(false, tmp101) - tmp103 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3229), kw_column, int(39), kw_end_DASH_line, int(3231), kw_end_DASH_column, int(76)) - tmp104, err := lang.WithMeta(tmp102, tmp103.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp85 = tmp104 - } else { - var tmp105 any - tmp106 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp107 := lang.Apply(tmp106, []any{v53, kw_when}) - if lang.IsTruthy(tmp107) { - tmp108 := checkDerefVar(var_glojure_DOT_core_seq) - tmp109 := checkDerefVar(var_glojure_DOT_core_concat) - tmp110 := checkDerefVar(var_glojure_DOT_core_list) - tmp111 := lang.Apply(tmp110, []any{sym_if}) - tmp112 := checkDerefVar(var_glojure_DOT_core_list) - tmp113 := lang.Apply(tmp112, []any{v56}) - tmp114 := checkDerefVar(var_glojure_DOT_core_list) - tmp115 := checkDerefVar(var_glojure_DOT_core_seq) - tmp116 := checkDerefVar(var_glojure_DOT_core_concat) - tmp117 := checkDerefVar(var_glojure_DOT_core_list) - tmp118 := lang.Apply(tmp117, []any{sym_do}) - tmp119 := checkDerefVar(var_glojure_DOT_core_list) - tmp120 := lang.Apply(tmp119, []any{v68}) - var tmp121 any - if lang.IsTruthy(v66) { - tmp122 := lang.NewVector(v36) - tmp123 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3235), kw_column, int(66), kw_end_DASH_line, int(3235), kw_end_DASH_column, int(74)) - tmp124, err := lang.WithMeta(tmp122, tmp123.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp121 = tmp124 - } else { - } - tmp125 := lang.Apply(tmp116, []any{tmp118, tmp120, tmp121}) - tmp126 := lang.Apply(tmp115, []any{tmp125}) - tmp127 := lang.Apply(tmp114, []any{tmp126}) - tmp128 := checkDerefVar(var_glojure_DOT_core_list) - tmp129 := lang.Apply(tmp128, []any{v36}) - tmp130 := lang.Apply(tmp109, []any{tmp111, tmp113, tmp127, tmp129}) - tmp131 := lang.Apply(tmp108, []any{tmp130}) - tmp132 := lang.NewVector(false, tmp131) - tmp133 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3232), kw_column, int(38), kw_end_DASH_line, int(3236), kw_end_DASH_column, int(57)) - tmp134, err := lang.WithMeta(tmp132, tmp133.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp105 = tmp134 - } else { - } - tmp85 = tmp105 - } - tmp69 = tmp85 - } - tmp60 = tmp69 - } // end let - tmp57 = tmp60 - } else { - var tmp61 any - { // let - // let binding "seq-" - tmp62 := checkDerefVar(var_glojure_DOT_core_gensym) - tmp63 := lang.Apply(tmp62, []any{"seq_"}) - var v64 any = tmp63 - _ = v64 - // let binding "chunk-" - tmp65 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) - tmp66 := checkDerefVar(var_glojure_DOT_core_gensym) - tmp67 := lang.Apply(tmp66, []any{"chunk_"}) - tmp68 := lang.NewMap(kw_tag, sym_glojure_DOT_lang_DOT_IChunk) - tmp69 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3239), kw_column, int(46), kw_end_DASH_line, int(3239), kw_end_DASH_column, int(72)) - tmp70, err := lang.WithMeta(tmp68, tmp69.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp71 := lang.Apply(tmp65, []any{tmp67, tmp70}) - var v72 any = tmp71 - _ = v72 - // let binding "count-" - tmp73 := checkDerefVar(var_glojure_DOT_core_gensym) - tmp74 := lang.Apply(tmp73, []any{"count_"}) - var v75 any = tmp74 - _ = v75 - // let binding "i-" - tmp76 := checkDerefVar(var_glojure_DOT_core_gensym) - tmp77 := lang.Apply(tmp76, []any{"i_"}) - var v78 any = tmp77 - _ = v78 - // let binding "recform" - tmp79 := checkDerefVar(var_glojure_DOT_core_seq) - tmp80 := checkDerefVar(var_glojure_DOT_core_concat) - tmp81 := checkDerefVar(var_glojure_DOT_core_list) - tmp82 := lang.Apply(tmp81, []any{sym_recur}) - tmp83 := checkDerefVar(var_glojure_DOT_core_list) - tmp84 := checkDerefVar(var_glojure_DOT_core_seq) - tmp85 := checkDerefVar(var_glojure_DOT_core_concat) - tmp86 := checkDerefVar(var_glojure_DOT_core_list) - tmp87 := lang.Apply(tmp86, []any{sym_glojure_DOT_core_SLASH_next}) - tmp88 := checkDerefVar(var_glojure_DOT_core_list) - tmp89 := lang.Apply(tmp88, []any{v64}) - tmp90 := lang.Apply(tmp85, []any{tmp87, tmp89}) - tmp91 := lang.Apply(tmp84, []any{tmp90}) - tmp92 := lang.Apply(tmp83, []any{tmp91}) - tmp93 := checkDerefVar(var_glojure_DOT_core_list) - tmp94 := lang.Apply(tmp93, []any{nil}) - tmp95 := checkDerefVar(var_glojure_DOT_core_list) - tmp96 := lang.Apply(tmp95, []any{int64(0)}) - tmp97 := checkDerefVar(var_glojure_DOT_core_list) - tmp98 := lang.Apply(tmp97, []any{int64(0)}) - tmp99 := lang.Apply(tmp80, []any{tmp82, tmp92, tmp94, tmp96, tmp98}) - tmp100 := lang.Apply(tmp79, []any{tmp99}) - var v101 any = tmp100 - _ = v101 - // let binding "steppair" - tmp102 := checkDerefVar(var_glojure_DOT_core_nnext) - tmp103 := lang.Apply(tmp102, []any{v37}) - tmp104 := lang.Apply(v35, []any{v101, tmp103}) - var v105 any = tmp104 - _ = v105 - // let binding "needrec" - tmp106 := lang.Apply(v105, []any{int64(0)}) - var v107 any = tmp106 - _ = v107 - // let binding "subform" - tmp108 := lang.Apply(v105, []any{int64(1)}) - var v109 any = tmp108 - _ = v109 - // let binding "recform-chunk" - tmp110 := checkDerefVar(var_glojure_DOT_core_seq) - tmp111 := checkDerefVar(var_glojure_DOT_core_concat) - tmp112 := checkDerefVar(var_glojure_DOT_core_list) - tmp113 := lang.Apply(tmp112, []any{sym_recur}) - tmp114 := checkDerefVar(var_glojure_DOT_core_list) - tmp115 := lang.Apply(tmp114, []any{v64}) - tmp116 := checkDerefVar(var_glojure_DOT_core_list) - tmp117 := lang.Apply(tmp116, []any{v72}) - tmp118 := checkDerefVar(var_glojure_DOT_core_list) - tmp119 := lang.Apply(tmp118, []any{v75}) - tmp120 := checkDerefVar(var_glojure_DOT_core_list) - tmp121 := checkDerefVar(var_glojure_DOT_core_seq) - tmp122 := checkDerefVar(var_glojure_DOT_core_concat) - tmp123 := checkDerefVar(var_glojure_DOT_core_list) - tmp124 := lang.Apply(tmp123, []any{sym_glojure_DOT_core_SLASH_unchecked_DASH_inc}) - tmp125 := checkDerefVar(var_glojure_DOT_core_list) - tmp126 := lang.Apply(tmp125, []any{v78}) - tmp127 := lang.Apply(tmp122, []any{tmp124, tmp126}) - tmp128 := lang.Apply(tmp121, []any{tmp127}) - tmp129 := lang.Apply(tmp120, []any{tmp128}) - tmp130 := lang.Apply(tmp111, []any{tmp113, tmp115, tmp117, tmp119, tmp129}) - tmp131 := lang.Apply(tmp110, []any{tmp130}) - var v132 any = tmp131 - _ = v132 - // let binding "steppair-chunk" - tmp133 := checkDerefVar(var_glojure_DOT_core_nnext) - tmp134 := lang.Apply(tmp133, []any{v37}) - tmp135 := lang.Apply(v35, []any{v132, tmp134}) - var v136 any = tmp135 - _ = v136 - // let binding "subform-chunk" - tmp137 := lang.Apply(v136, []any{int64(1)}) - var v138 any = tmp137 - _ = v138 - tmp139 := checkDerefVar(var_glojure_DOT_core_seq) - tmp140 := checkDerefVar(var_glojure_DOT_core_concat) - tmp141 := checkDerefVar(var_glojure_DOT_core_list) - tmp142 := lang.Apply(tmp141, []any{sym_glojure_DOT_core_SLASH_loop}) - tmp143 := checkDerefVar(var_glojure_DOT_core_list) - tmp144 := checkDerefVar(var_glojure_DOT_core_apply) - tmp145 := checkDerefVar(var_glojure_DOT_core_vector) - tmp146 := checkDerefVar(var_glojure_DOT_core_seq) - tmp147 := checkDerefVar(var_glojure_DOT_core_concat) - tmp148 := checkDerefVar(var_glojure_DOT_core_list) - tmp149 := lang.Apply(tmp148, []any{v64}) - tmp150 := checkDerefVar(var_glojure_DOT_core_list) - tmp151 := checkDerefVar(var_glojure_DOT_core_seq) - tmp152 := checkDerefVar(var_glojure_DOT_core_concat) - tmp153 := checkDerefVar(var_glojure_DOT_core_list) - tmp154 := lang.Apply(tmp153, []any{sym_glojure_DOT_core_SLASH_seq}) - tmp155 := checkDerefVar(var_glojure_DOT_core_list) - tmp156 := lang.Apply(tmp155, []any{v56}) - tmp157 := lang.Apply(tmp152, []any{tmp154, tmp156}) - tmp158 := lang.Apply(tmp151, []any{tmp157}) - tmp159 := lang.Apply(tmp150, []any{tmp158}) - tmp160 := checkDerefVar(var_glojure_DOT_core_list) - tmp161 := lang.Apply(tmp160, []any{v72}) - tmp162 := checkDerefVar(var_glojure_DOT_core_list) - tmp163 := lang.Apply(tmp162, []any{nil}) - tmp164 := checkDerefVar(var_glojure_DOT_core_list) - tmp165 := lang.Apply(tmp164, []any{v75}) - tmp166 := checkDerefVar(var_glojure_DOT_core_list) - tmp167 := lang.Apply(tmp166, []any{int64(0)}) - tmp168 := checkDerefVar(var_glojure_DOT_core_list) - tmp169 := lang.Apply(tmp168, []any{v78}) - tmp170 := checkDerefVar(var_glojure_DOT_core_list) - tmp171 := lang.Apply(tmp170, []any{int64(0)}) - tmp172 := lang.Apply(tmp147, []any{tmp149, tmp159, tmp161, tmp163, tmp165, tmp167, tmp169, tmp171}) - tmp173 := lang.Apply(tmp146, []any{tmp172}) - tmp174 := lang.Apply(tmp144, []any{tmp145, tmp173}) - tmp175 := lang.Apply(tmp143, []any{tmp174}) - tmp176 := checkDerefVar(var_glojure_DOT_core_list) - tmp177 := checkDerefVar(var_glojure_DOT_core_seq) - tmp178 := checkDerefVar(var_glojure_DOT_core_concat) - tmp179 := checkDerefVar(var_glojure_DOT_core_list) - tmp180 := lang.Apply(tmp179, []any{sym_if}) - tmp181 := checkDerefVar(var_glojure_DOT_core_list) - tmp182 := checkDerefVar(var_glojure_DOT_core_seq) - tmp183 := checkDerefVar(var_glojure_DOT_core_concat) - tmp184 := checkDerefVar(var_glojure_DOT_core_list) - tmp185 := lang.Apply(tmp184, []any{sym_glojure_DOT_core_SLASH__LT_}) - tmp186 := checkDerefVar(var_glojure_DOT_core_list) - tmp187 := lang.Apply(tmp186, []any{v78}) - tmp188 := checkDerefVar(var_glojure_DOT_core_list) - tmp189 := lang.Apply(tmp188, []any{v75}) - tmp190 := lang.Apply(tmp183, []any{tmp185, tmp187, tmp189}) - tmp191 := lang.Apply(tmp182, []any{tmp190}) - tmp192 := lang.Apply(tmp181, []any{tmp191}) - tmp193 := checkDerefVar(var_glojure_DOT_core_list) - tmp194 := checkDerefVar(var_glojure_DOT_core_seq) - tmp195 := checkDerefVar(var_glojure_DOT_core_concat) - tmp196 := checkDerefVar(var_glojure_DOT_core_list) - tmp197 := lang.Apply(tmp196, []any{sym_glojure_DOT_core_SLASH_let}) - tmp198 := checkDerefVar(var_glojure_DOT_core_list) - tmp199 := checkDerefVar(var_glojure_DOT_core_apply) - tmp200 := checkDerefVar(var_glojure_DOT_core_vector) - tmp201 := checkDerefVar(var_glojure_DOT_core_seq) - tmp202 := checkDerefVar(var_glojure_DOT_core_concat) - tmp203 := checkDerefVar(var_glojure_DOT_core_list) - tmp204 := lang.Apply(tmp203, []any{v53}) - tmp205 := checkDerefVar(var_glojure_DOT_core_list) - tmp206 := checkDerefVar(var_glojure_DOT_core_seq) - tmp207 := checkDerefVar(var_glojure_DOT_core_concat) - tmp208 := checkDerefVar(var_glojure_DOT_core_list) - tmp209 := lang.Apply(tmp208, []any{sym__DOT_nth}) - tmp210 := checkDerefVar(var_glojure_DOT_core_list) - tmp211 := lang.Apply(tmp210, []any{v72}) - tmp212 := checkDerefVar(var_glojure_DOT_core_list) - tmp213 := lang.Apply(tmp212, []any{v78}) - tmp214 := lang.Apply(tmp207, []any{tmp209, tmp211, tmp213}) - tmp215 := lang.Apply(tmp206, []any{tmp214}) - tmp216 := lang.Apply(tmp205, []any{tmp215}) - tmp217 := lang.Apply(tmp202, []any{tmp204, tmp216}) - tmp218 := lang.Apply(tmp201, []any{tmp217}) - tmp219 := lang.Apply(tmp199, []any{tmp200, tmp218}) - tmp220 := lang.Apply(tmp198, []any{tmp219}) - tmp221 := checkDerefVar(var_glojure_DOT_core_list) - tmp222 := lang.Apply(tmp221, []any{v138}) - var tmp223 any - if lang.IsTruthy(v107) { - tmp224 := lang.NewVector(v132) - tmp225 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3256), kw_column, int(48), kw_end_DASH_line, int(3256), kw_end_DASH_column, int(62)) - tmp226, err := lang.WithMeta(tmp224, tmp225.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp223 = tmp226 - } else { - } - tmp227 := lang.Apply(tmp195, []any{tmp197, tmp220, tmp222, tmp223}) - tmp228 := lang.Apply(tmp194, []any{tmp227}) - tmp229 := lang.Apply(tmp193, []any{tmp228}) - tmp230 := checkDerefVar(var_glojure_DOT_core_list) - tmp231 := checkDerefVar(var_glojure_DOT_core_seq) - tmp232 := checkDerefVar(var_glojure_DOT_core_concat) - tmp233 := checkDerefVar(var_glojure_DOT_core_list) - tmp234 := lang.Apply(tmp233, []any{sym_glojure_DOT_core_SLASH_when_DASH_let}) - tmp235 := checkDerefVar(var_glojure_DOT_core_list) - tmp236 := checkDerefVar(var_glojure_DOT_core_apply) - tmp237 := checkDerefVar(var_glojure_DOT_core_vector) - tmp238 := checkDerefVar(var_glojure_DOT_core_seq) - tmp239 := checkDerefVar(var_glojure_DOT_core_concat) - tmp240 := checkDerefVar(var_glojure_DOT_core_list) - tmp241 := lang.Apply(tmp240, []any{v64}) - tmp242 := checkDerefVar(var_glojure_DOT_core_list) - tmp243 := checkDerefVar(var_glojure_DOT_core_seq) - tmp244 := checkDerefVar(var_glojure_DOT_core_concat) - tmp245 := checkDerefVar(var_glojure_DOT_core_list) - tmp246 := lang.Apply(tmp245, []any{sym_glojure_DOT_core_SLASH_seq}) - tmp247 := checkDerefVar(var_glojure_DOT_core_list) - tmp248 := lang.Apply(tmp247, []any{v64}) - tmp249 := lang.Apply(tmp244, []any{tmp246, tmp248}) - tmp250 := lang.Apply(tmp243, []any{tmp249}) - tmp251 := lang.Apply(tmp242, []any{tmp250}) - tmp252 := lang.Apply(tmp239, []any{tmp241, tmp251}) - tmp253 := lang.Apply(tmp238, []any{tmp252}) - tmp254 := lang.Apply(tmp236, []any{tmp237, tmp253}) - tmp255 := lang.Apply(tmp235, []any{tmp254}) - tmp256 := checkDerefVar(var_glojure_DOT_core_list) - tmp257 := checkDerefVar(var_glojure_DOT_core_seq) - tmp258 := checkDerefVar(var_glojure_DOT_core_concat) - tmp259 := checkDerefVar(var_glojure_DOT_core_list) - tmp260 := lang.Apply(tmp259, []any{sym_if}) - tmp261 := checkDerefVar(var_glojure_DOT_core_list) - tmp262 := checkDerefVar(var_glojure_DOT_core_seq) - tmp263 := checkDerefVar(var_glojure_DOT_core_concat) - tmp264 := checkDerefVar(var_glojure_DOT_core_list) - tmp265 := lang.Apply(tmp264, []any{sym_glojure_DOT_core_SLASH_chunked_DASH_seq_QMARK_}) - tmp266 := checkDerefVar(var_glojure_DOT_core_list) - tmp267 := lang.Apply(tmp266, []any{v64}) - tmp268 := lang.Apply(tmp263, []any{tmp265, tmp267}) - tmp269 := lang.Apply(tmp262, []any{tmp268}) - tmp270 := lang.Apply(tmp261, []any{tmp269}) - tmp271 := checkDerefVar(var_glojure_DOT_core_list) - tmp272 := checkDerefVar(var_glojure_DOT_core_seq) - tmp273 := checkDerefVar(var_glojure_DOT_core_concat) - tmp274 := checkDerefVar(var_glojure_DOT_core_list) - tmp275 := lang.Apply(tmp274, []any{sym_glojure_DOT_core_SLASH_let}) - tmp276 := checkDerefVar(var_glojure_DOT_core_list) - tmp277 := checkDerefVar(var_glojure_DOT_core_apply) - tmp278 := checkDerefVar(var_glojure_DOT_core_vector) - tmp279 := checkDerefVar(var_glojure_DOT_core_seq) - tmp280 := checkDerefVar(var_glojure_DOT_core_concat) - tmp281 := checkDerefVar(var_glojure_DOT_core_list) - tmp282 := lang.Apply(tmp281, []any{sym_c__0__auto__}) - tmp283 := checkDerefVar(var_glojure_DOT_core_list) - tmp284 := checkDerefVar(var_glojure_DOT_core_seq) - tmp285 := checkDerefVar(var_glojure_DOT_core_concat) - tmp286 := checkDerefVar(var_glojure_DOT_core_list) - tmp287 := lang.Apply(tmp286, []any{sym_glojure_DOT_core_SLASH_chunk_DASH_first}) - tmp288 := checkDerefVar(var_glojure_DOT_core_list) - tmp289 := lang.Apply(tmp288, []any{v64}) - tmp290 := lang.Apply(tmp285, []any{tmp287, tmp289}) - tmp291 := lang.Apply(tmp284, []any{tmp290}) - tmp292 := lang.Apply(tmp283, []any{tmp291}) - tmp293 := lang.Apply(tmp280, []any{tmp282, tmp292}) - tmp294 := lang.Apply(tmp279, []any{tmp293}) - tmp295 := lang.Apply(tmp277, []any{tmp278, tmp294}) - tmp296 := lang.Apply(tmp276, []any{tmp295}) - tmp297 := checkDerefVar(var_glojure_DOT_core_list) - tmp298 := checkDerefVar(var_glojure_DOT_core_seq) - tmp299 := checkDerefVar(var_glojure_DOT_core_concat) - tmp300 := checkDerefVar(var_glojure_DOT_core_list) - tmp301 := lang.Apply(tmp300, []any{sym_recur}) - tmp302 := checkDerefVar(var_glojure_DOT_core_list) - tmp303 := checkDerefVar(var_glojure_DOT_core_seq) - tmp304 := checkDerefVar(var_glojure_DOT_core_concat) - tmp305 := checkDerefVar(var_glojure_DOT_core_list) - tmp306 := lang.Apply(tmp305, []any{sym_glojure_DOT_core_SLASH_chunk_DASH_rest}) - tmp307 := checkDerefVar(var_glojure_DOT_core_list) - tmp308 := lang.Apply(tmp307, []any{v64}) - tmp309 := lang.Apply(tmp304, []any{tmp306, tmp308}) - tmp310 := lang.Apply(tmp303, []any{tmp309}) - tmp311 := lang.Apply(tmp302, []any{tmp310}) - tmp312 := checkDerefVar(var_glojure_DOT_core_list) - tmp313 := lang.Apply(tmp312, []any{sym_c__0__auto__}) - tmp314 := checkDerefVar(var_glojure_DOT_core_list) - tmp315 := checkDerefVar(var_glojure_DOT_core_seq) - tmp316 := checkDerefVar(var_glojure_DOT_core_concat) - tmp317 := checkDerefVar(var_glojure_DOT_core_list) - tmp318 := lang.Apply(tmp317, []any{sym_glojure_DOT_core_SLASH_int}) - tmp319 := checkDerefVar(var_glojure_DOT_core_list) - tmp320 := checkDerefVar(var_glojure_DOT_core_seq) - tmp321 := checkDerefVar(var_glojure_DOT_core_concat) - tmp322 := checkDerefVar(var_glojure_DOT_core_list) - tmp323 := lang.Apply(tmp322, []any{sym_glojure_DOT_core_SLASH_count}) - tmp324 := checkDerefVar(var_glojure_DOT_core_list) - tmp325 := lang.Apply(tmp324, []any{sym_c__0__auto__}) - tmp326 := lang.Apply(tmp321, []any{tmp323, tmp325}) - tmp327 := lang.Apply(tmp320, []any{tmp326}) - tmp328 := lang.Apply(tmp319, []any{tmp327}) - tmp329 := lang.Apply(tmp316, []any{tmp318, tmp328}) - tmp330 := lang.Apply(tmp315, []any{tmp329}) - tmp331 := lang.Apply(tmp314, []any{tmp330}) - tmp332 := checkDerefVar(var_glojure_DOT_core_list) - tmp333 := checkDerefVar(var_glojure_DOT_core_seq) - tmp334 := checkDerefVar(var_glojure_DOT_core_concat) - tmp335 := checkDerefVar(var_glojure_DOT_core_list) - tmp336 := lang.Apply(tmp335, []any{sym_glojure_DOT_core_SLASH_int}) - tmp337 := checkDerefVar(var_glojure_DOT_core_list) - tmp338 := lang.Apply(tmp337, []any{int64(0)}) - tmp339 := lang.Apply(tmp334, []any{tmp336, tmp338}) - tmp340 := lang.Apply(tmp333, []any{tmp339}) - tmp341 := lang.Apply(tmp332, []any{tmp340}) - tmp342 := lang.Apply(tmp299, []any{tmp301, tmp311, tmp313, tmp331, tmp341}) - tmp343 := lang.Apply(tmp298, []any{tmp342}) - tmp344 := lang.Apply(tmp297, []any{tmp343}) - tmp345 := lang.Apply(tmp273, []any{tmp275, tmp296, tmp344}) - tmp346 := lang.Apply(tmp272, []any{tmp345}) - tmp347 := lang.Apply(tmp271, []any{tmp346}) - tmp348 := checkDerefVar(var_glojure_DOT_core_list) - tmp349 := checkDerefVar(var_glojure_DOT_core_seq) - tmp350 := checkDerefVar(var_glojure_DOT_core_concat) - tmp351 := checkDerefVar(var_glojure_DOT_core_list) - tmp352 := lang.Apply(tmp351, []any{sym_glojure_DOT_core_SLASH_let}) - tmp353 := checkDerefVar(var_glojure_DOT_core_list) - tmp354 := checkDerefVar(var_glojure_DOT_core_apply) - tmp355 := checkDerefVar(var_glojure_DOT_core_vector) - tmp356 := checkDerefVar(var_glojure_DOT_core_seq) - tmp357 := checkDerefVar(var_glojure_DOT_core_concat) - tmp358 := checkDerefVar(var_glojure_DOT_core_list) - tmp359 := lang.Apply(tmp358, []any{v53}) - tmp360 := checkDerefVar(var_glojure_DOT_core_list) - tmp361 := checkDerefVar(var_glojure_DOT_core_seq) - tmp362 := checkDerefVar(var_glojure_DOT_core_concat) - tmp363 := checkDerefVar(var_glojure_DOT_core_list) - tmp364 := lang.Apply(tmp363, []any{sym_glojure_DOT_core_SLASH_first}) - tmp365 := checkDerefVar(var_glojure_DOT_core_list) - tmp366 := lang.Apply(tmp365, []any{v64}) - tmp367 := lang.Apply(tmp362, []any{tmp364, tmp366}) - tmp368 := lang.Apply(tmp361, []any{tmp367}) - tmp369 := lang.Apply(tmp360, []any{tmp368}) - tmp370 := lang.Apply(tmp357, []any{tmp359, tmp369}) - tmp371 := lang.Apply(tmp356, []any{tmp370}) - tmp372 := lang.Apply(tmp354, []any{tmp355, tmp371}) - tmp373 := lang.Apply(tmp353, []any{tmp372}) - tmp374 := checkDerefVar(var_glojure_DOT_core_list) - tmp375 := lang.Apply(tmp374, []any{v109}) - var tmp376 any - if lang.IsTruthy(v107) { - tmp377 := lang.NewVector(v101) - tmp378 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3264), kw_column, int(52), kw_end_DASH_line, int(3264), kw_end_DASH_column, int(60)) - tmp379, err := lang.WithMeta(tmp377, tmp378.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp376 = tmp379 - } else { - } - tmp380 := lang.Apply(tmp350, []any{tmp352, tmp373, tmp375, tmp376}) - tmp381 := lang.Apply(tmp349, []any{tmp380}) - tmp382 := lang.Apply(tmp348, []any{tmp381}) - tmp383 := lang.Apply(tmp258, []any{tmp260, tmp270, tmp347, tmp382}) - tmp384 := lang.Apply(tmp257, []any{tmp383}) - tmp385 := lang.Apply(tmp256, []any{tmp384}) - tmp386 := lang.Apply(tmp232, []any{tmp234, tmp255, tmp385}) - tmp387 := lang.Apply(tmp231, []any{tmp386}) - tmp388 := lang.Apply(tmp230, []any{tmp387}) - tmp389 := lang.Apply(tmp178, []any{tmp180, tmp192, tmp229, tmp388}) - tmp390 := lang.Apply(tmp177, []any{tmp389}) - tmp391 := lang.Apply(tmp176, []any{tmp390}) - tmp392 := lang.Apply(tmp140, []any{tmp142, tmp175, tmp391}) - tmp393 := lang.Apply(tmp139, []any{tmp392}) - tmp394 := lang.NewVector(true, tmp393) - tmp395 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3250), kw_column, int(24), kw_end_DASH_line, int(3264), kw_end_DASH_column, int(67)) - tmp396, err := lang.WithMeta(tmp394, tmp395.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp61 = tmp396 - } // end let - tmp57 = tmp61 - } - tmp50 = tmp57 - } // end let - tmp38 = tmp50 - } - return tmp38 - }) - v35 = tmp34 - _ = v35 - } - tmp35 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3218), kw_column, int(14), kw_end_DASH_line, int(3264), kw_end_DASH_column, int(72)) - tmp36, err := lang.WithMeta(tmp34, tmp35.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v37 any = tmp36 - _ = v37 - tmp38 := checkDerefVar(var_glojure_DOT_core_nth) - tmp39 := checkDerefVar(var_glojure_DOT_core_seq) - tmp40 := lang.Apply(tmp39, []any{v5}) - tmp41 := lang.Apply(v37, []any{nil, tmp40}) - tmp42 := lang.Apply(tmp38, []any{tmp41, int64(1)}) - tmp33 = tmp42 - } // end let - return tmp33 + tmp6 := lang.Apply(tmp5, []any{v2, v3, v4}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_subvec = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_subvec.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // dosync + // symbol { - tmp0 := sym_dosync.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_exprs)), kw_doc, "Runs the exprs (in an implicit do) in a transaction that encompasses\n exprs and any nested calls. Starts a transaction if none is already\n running on this thread. Any uncaught exception will abort the\n transaction and flow out of dosync. The exprs may be run more than\n once, but any effects on Refs will be atomic.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(11), kw_line, int(5100), kw_end_DASH_line, int(5100))).(*lang.Symbol) + tmp1 := reflect.TypeOf((*lang.Symbol)(nil)) + tmp0 := sym_symbol.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_name), lang.NewVector(sym_ns, sym_name)), kw_doc, "Returns a Symbol with the given namespace and name. Arity-1 works\n on strings, keywords, and vars.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(584), kw_end_DASH_line, int(584))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - default: - checkArity(args, 2) + case 1: + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + tmp4 = v3 + } else { + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp9 := lang.Apply(tmp8, []any{lang.Builtins["string"], v3}) + if lang.IsTruthy(tmp9) { + tmp10 := lang.Apply(lang.NewSymbol, []any{v3}) + tmp7 = tmp10 + } else { + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp13 := reflect.TypeOf((*lang.Var)(nil)) + tmp14 := lang.Apply(tmp12, []any{tmp13, v3}) + if lang.IsTruthy(tmp14) { + tmp15, ok := lang.FieldOrMethod(v3, "toSymbol") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "toSymbol"))) + } + var tmp16 any + switch reflect.TypeOf(tmp15).Kind() { + case reflect.Func: + tmp16 = lang.Apply(tmp15, nil) + default: + tmp16 = tmp15 + } + tmp11 = tmp16 + } else { + var tmp17 any + tmp18 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp19 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() + tmp20 := lang.Apply(tmp18, []any{tmp19, v3}) + if lang.IsTruthy(tmp20) { + tmp21, ok := lang.FieldOrMethod(v3, "sym") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "sym"))) + } + var tmp22 any + switch reflect.TypeOf(tmp21).Kind() { + case reflect.Func: + tmp22 = lang.Apply(tmp21, nil) + default: + tmp22 = tmp21 + } + tmp17 = tmp22 + } else { + var tmp23 any + if lang.IsTruthy(kw_else) { + tmp24 := lang.Apply(lang.NewIllegalArgumentError, []any{"no conversion to symbol"}) + panic(tmp24) + } else { + } + tmp17 = tmp23 + } + tmp11 = tmp17 + } + tmp7 = tmp11 + } + tmp4 = tmp7 + } + return tmp4 + case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - tmp6 := checkDerefVar(var_glojure_DOT_core_seq) - tmp7 := checkDerefVar(var_glojure_DOT_core_concat) - tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_sync}) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{nil}) - tmp12 := lang.Apply(tmp7, []any{tmp9, tmp11, v5}) - tmp13 := lang.Apply(tmp6, []any{tmp12}) - return tmp13 + tmp5 := lang.Apply(lang.InternSymbol, []any{v3, v4}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp3 := reflect.TypeOf((*lang.Symbol)(nil)) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_symbol = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_symbol.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // dotimes + // thread-bound? { - tmp0 := sym_dotimes.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "bindings => name n\n\n Repeatedly executes body (presumably for side-effects) with name\n bound to integers from 0 through n-1.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(3306), kw_end_DASH_line, int(3306))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_thread_DASH_bound_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_vars)), kw_doc, "Returns true if all of the vars provided as arguments have thread-local bindings.\n Implies that set!'ing the provided vars will succeed. Returns true if no vars are provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(5499), kw_end_DASH_line, int(5499))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any - tmp8 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) - tmp9 := lang.Apply(tmp8, []any{v5}) - if lang.IsTruthy(tmp9) { - } else { - tmp10 := checkDerefVar(var_glojure_DOT_core_str) - tmp11 := checkDerefVar(var_glojure_DOT_core_first) - tmp12 := lang.Apply(tmp11, []any{v3}) - tmp13 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) - tmp14 := checkDerefVar(var_glojure_DOT_core_meta) - tmp15 := lang.Apply(tmp14, []any{v3}) - tmp16 := lang.Apply(kw_line, []any{tmp15}) - tmp17 := lang.Apply(tmp10, []any{tmp12, " requires ", "a vector for its binding", " in ", tmp13, ":", tmp16}) - tmp18 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp17}) - panic(tmp18) + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v5 := args[0] + _ = v5 + tmp6, ok := lang.FieldOrMethod(v5, "getThreadBinding") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "getThreadBinding"))) + } + var tmp7 any + switch reflect.TypeOf(tmp6).Kind() { + case reflect.Func: + tmp7 = lang.Apply(tmp6, nil) + default: + tmp7 = tmp6 + } + return tmp7 + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5505), kw_column, int(11), kw_end_DASH_line, int(5505), kw_end_DASH_column, int(78)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) } - _ = tmp7 - var tmp19 any - tmp20 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp21 := checkDerefVar(var_glojure_DOT_core_count) - tmp22 := lang.Apply(tmp21, []any{v5}) - tmp23 := lang.Apply(tmp20, []any{int64(2), tmp22}) - if lang.IsTruthy(tmp23) { - } else { - tmp24 := checkDerefVar(var_glojure_DOT_core_str) - tmp25 := checkDerefVar(var_glojure_DOT_core_first) - tmp26 := lang.Apply(tmp25, []any{v3}) - tmp27 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) - tmp28 := checkDerefVar(var_glojure_DOT_core_meta) - tmp29 := lang.Apply(tmp28, []any{v3}) - tmp30 := lang.Apply(kw_line, []any{tmp29}) - tmp31 := lang.Apply(tmp24, []any{tmp26, " requires ", "exactly 2 forms in binding vector", " in ", tmp27, ":", tmp30}) - tmp32 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp31}) - panic(tmp32) - } - _ = tmp19 - var tmp33 any - { // let - // let binding "i" - tmp34 := checkDerefVar(var_glojure_DOT_core_first) - tmp35 := lang.Apply(tmp34, []any{v5}) - var v36 any = tmp35 - _ = v36 - // let binding "n" - tmp37 := checkDerefVar(var_glojure_DOT_core_second) - tmp38 := lang.Apply(tmp37, []any{v5}) - var v39 any = tmp38 - _ = v39 - tmp40 := checkDerefVar(var_glojure_DOT_core_seq) - tmp41 := checkDerefVar(var_glojure_DOT_core_concat) - tmp42 := checkDerefVar(var_glojure_DOT_core_list) - tmp43 := lang.Apply(tmp42, []any{sym_glojure_DOT_core_SLASH_let}) - tmp44 := checkDerefVar(var_glojure_DOT_core_list) - tmp45 := checkDerefVar(var_glojure_DOT_core_apply) - tmp46 := checkDerefVar(var_glojure_DOT_core_vector) - tmp47 := checkDerefVar(var_glojure_DOT_core_seq) - tmp48 := checkDerefVar(var_glojure_DOT_core_concat) - tmp49 := checkDerefVar(var_glojure_DOT_core_list) - tmp50 := lang.Apply(tmp49, []any{sym_n__0__auto__}) - tmp51 := checkDerefVar(var_glojure_DOT_core_list) - tmp52 := checkDerefVar(var_glojure_DOT_core_seq) - tmp53 := checkDerefVar(var_glojure_DOT_core_concat) - tmp54 := checkDerefVar(var_glojure_DOT_core_list) - tmp55 := lang.Apply(tmp54, []any{sym_glojure_DOT_core_SLASH_long}) - tmp56 := checkDerefVar(var_glojure_DOT_core_list) - tmp57 := lang.Apply(tmp56, []any{v39}) - tmp58 := lang.Apply(tmp53, []any{tmp55, tmp57}) - tmp59 := lang.Apply(tmp52, []any{tmp58}) - tmp60 := lang.Apply(tmp51, []any{tmp59}) - tmp61 := lang.Apply(tmp48, []any{tmp50, tmp60}) - tmp62 := lang.Apply(tmp47, []any{tmp61}) - tmp63 := lang.Apply(tmp45, []any{tmp46, tmp62}) - tmp64 := lang.Apply(tmp44, []any{tmp63}) - tmp65 := checkDerefVar(var_glojure_DOT_core_list) - tmp66 := checkDerefVar(var_glojure_DOT_core_seq) - tmp67 := checkDerefVar(var_glojure_DOT_core_concat) - tmp68 := checkDerefVar(var_glojure_DOT_core_list) - tmp69 := lang.Apply(tmp68, []any{sym_glojure_DOT_core_SLASH_loop}) - tmp70 := checkDerefVar(var_glojure_DOT_core_list) - tmp71 := checkDerefVar(var_glojure_DOT_core_apply) - tmp72 := checkDerefVar(var_glojure_DOT_core_vector) - tmp73 := checkDerefVar(var_glojure_DOT_core_seq) - tmp74 := checkDerefVar(var_glojure_DOT_core_concat) - tmp75 := checkDerefVar(var_glojure_DOT_core_list) - tmp76 := lang.Apply(tmp75, []any{v36}) - tmp77 := checkDerefVar(var_glojure_DOT_core_list) - tmp78 := lang.Apply(tmp77, []any{int64(0)}) - tmp79 := lang.Apply(tmp74, []any{tmp76, tmp78}) - tmp80 := lang.Apply(tmp73, []any{tmp79}) - tmp81 := lang.Apply(tmp71, []any{tmp72, tmp80}) - tmp82 := lang.Apply(tmp70, []any{tmp81}) - tmp83 := checkDerefVar(var_glojure_DOT_core_list) - tmp84 := checkDerefVar(var_glojure_DOT_core_seq) - tmp85 := checkDerefVar(var_glojure_DOT_core_concat) - tmp86 := checkDerefVar(var_glojure_DOT_core_list) - tmp87 := lang.Apply(tmp86, []any{sym_glojure_DOT_core_SLASH_when}) - tmp88 := checkDerefVar(var_glojure_DOT_core_list) - tmp89 := checkDerefVar(var_glojure_DOT_core_seq) - tmp90 := checkDerefVar(var_glojure_DOT_core_concat) - tmp91 := checkDerefVar(var_glojure_DOT_core_list) - tmp92 := lang.Apply(tmp91, []any{sym_glojure_DOT_core_SLASH__LT_}) - tmp93 := checkDerefVar(var_glojure_DOT_core_list) - tmp94 := lang.Apply(tmp93, []any{v36}) - tmp95 := checkDerefVar(var_glojure_DOT_core_list) - tmp96 := lang.Apply(tmp95, []any{sym_n__0__auto__}) - tmp97 := lang.Apply(tmp90, []any{tmp92, tmp94, tmp96}) - tmp98 := lang.Apply(tmp89, []any{tmp97}) - tmp99 := lang.Apply(tmp88, []any{tmp98}) - tmp100 := checkDerefVar(var_glojure_DOT_core_list) - tmp101 := checkDerefVar(var_glojure_DOT_core_seq) - tmp102 := checkDerefVar(var_glojure_DOT_core_concat) - tmp103 := checkDerefVar(var_glojure_DOT_core_list) - tmp104 := lang.Apply(tmp103, []any{sym_recur}) - tmp105 := checkDerefVar(var_glojure_DOT_core_list) - tmp106 := checkDerefVar(var_glojure_DOT_core_seq) - tmp107 := checkDerefVar(var_glojure_DOT_core_concat) - tmp108 := checkDerefVar(var_glojure_DOT_core_list) - tmp109 := lang.Apply(tmp108, []any{sym_glojure_DOT_core_SLASH_unchecked_DASH_inc}) - tmp110 := checkDerefVar(var_glojure_DOT_core_list) - tmp111 := lang.Apply(tmp110, []any{v36}) - tmp112 := lang.Apply(tmp107, []any{tmp109, tmp111}) - tmp113 := lang.Apply(tmp106, []any{tmp112}) - tmp114 := lang.Apply(tmp105, []any{tmp113}) - tmp115 := lang.Apply(tmp102, []any{tmp104, tmp114}) - tmp116 := lang.Apply(tmp101, []any{tmp115}) - tmp117 := lang.Apply(tmp100, []any{tmp116}) - tmp118 := lang.Apply(tmp85, []any{tmp87, tmp99, v6, tmp117}) - tmp119 := lang.Apply(tmp84, []any{tmp118}) - tmp120 := lang.Apply(tmp83, []any{tmp119}) - tmp121 := lang.Apply(tmp67, []any{tmp69, tmp82, tmp120}) - tmp122 := lang.Apply(tmp66, []any{tmp121}) - tmp123 := lang.Apply(tmp65, []any{tmp122}) - tmp124 := lang.Apply(tmp41, []any{tmp43, tmp64, tmp123}) - tmp125 := lang.Apply(tmp40, []any{tmp124}) - tmp33 = tmp125 - } // end let - return tmp33 + tmp7 := lang.Apply(tmp3, []any{tmp6, v2}) + return tmp7 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_thread_DASH_bound_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_thread_DASH_bound_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // doto + // type { - tmp0 := sym_doto.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_x, sym__AMP_, sym_forms)), kw_doc, "Evaluates x then calls all of the methods and functions with the\n value of x supplied at the front of the given arguments. The forms\n are evaluated in order. Returns x.\n\n (doto (new java.util.HashMap) (.put \"a\" 1) (.put \"b\" 2))", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(11), kw_line, int(3853), kw_end_DASH_line, int(3853))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 3) + tmp0 := sym_type.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns the :type metadata of x, or its Class if none", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3467), kw_end_DASH_line, int(3467))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "or__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_get) + tmp5 := checkDerefVar(var_glojure_DOT_core_meta) + tmp6 := lang.Apply(tmp5, []any{v2}) + tmp7 := lang.Apply(tmp4, []any{tmp6, kw_type}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + tmp9 = v8 + } else { + tmp10 := checkDerefVar(var_glojure_DOT_core_class) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp9 = tmp11 + } + tmp3 = tmp9 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_type = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_type.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-add + { + var tmp1 lang.FnFunc + { // function unchecked-add__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any - { // let - // let binding "gx" - tmp8 := checkDerefVar(var_glojure_DOT_core_gensym) - tmp9 := lang.Apply(tmp8, nil) - var v10 any = tmp9 - _ = v10 - tmp11 := checkDerefVar(var_glojure_DOT_core_seq) - tmp12 := checkDerefVar(var_glojure_DOT_core_concat) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_let}) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := checkDerefVar(var_glojure_DOT_core_apply) - tmp17 := checkDerefVar(var_glojure_DOT_core_vector) - tmp18 := checkDerefVar(var_glojure_DOT_core_seq) - tmp19 := checkDerefVar(var_glojure_DOT_core_concat) - tmp20 := checkDerefVar(var_glojure_DOT_core_list) - tmp21 := lang.Apply(tmp20, []any{v10}) - tmp22 := checkDerefVar(var_glojure_DOT_core_list) - tmp23 := lang.Apply(tmp22, []any{v5}) - tmp24 := lang.Apply(tmp19, []any{tmp21, tmp23}) - tmp25 := lang.Apply(tmp18, []any{tmp24}) - tmp26 := lang.Apply(tmp16, []any{tmp17, tmp25}) - tmp27 := lang.Apply(tmp15, []any{tmp26}) - tmp28 := checkDerefVar(var_glojure_DOT_core_map) - var tmp29 lang.FnFunc - tmp29 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v30 := args[0] - _ = v30 - tmp31 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) - var tmp32 any - tmp33 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) - tmp34 := lang.Apply(tmp33, []any{v30}) - if lang.IsTruthy(tmp34) { - tmp35 := checkDerefVar(var_glojure_DOT_core_seq) - tmp36 := checkDerefVar(var_glojure_DOT_core_concat) - tmp37 := checkDerefVar(var_glojure_DOT_core_list) - tmp38 := checkDerefVar(var_glojure_DOT_core_first) - tmp39 := lang.Apply(tmp38, []any{v30}) - tmp40 := lang.Apply(tmp37, []any{tmp39}) - tmp41 := checkDerefVar(var_glojure_DOT_core_list) - tmp42 := lang.Apply(tmp41, []any{v10}) - tmp43 := checkDerefVar(var_glojure_DOT_core_next) - tmp44 := lang.Apply(tmp43, []any{v30}) - tmp45 := lang.Apply(tmp36, []any{tmp40, tmp42, tmp44}) - tmp46 := lang.Apply(tmp35, []any{tmp45}) - tmp32 = tmp46 - } else { - tmp47 := checkDerefVar(var_glojure_DOT_core_seq) - tmp48 := checkDerefVar(var_glojure_DOT_core_concat) - tmp49 := checkDerefVar(var_glojure_DOT_core_list) - tmp50 := lang.Apply(tmp49, []any{v30}) - tmp51 := checkDerefVar(var_glojure_DOT_core_list) - tmp52 := lang.Apply(tmp51, []any{v10}) - tmp53 := lang.Apply(tmp48, []any{tmp50, tmp52}) - tmp54 := lang.Apply(tmp47, []any{tmp53}) - tmp32 = tmp54 - } - tmp55 := checkDerefVar(var_glojure_DOT_core_meta) - tmp56 := lang.Apply(tmp55, []any{v30}) - tmp57 := lang.Apply(tmp31, []any{tmp32, tmp56}) - return tmp57 - }) - tmp30 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3863), kw_column, int(17), kw_end_DASH_line, int(3868), kw_end_DASH_column, int(30)) - tmp31, err := lang.WithMeta(tmp29, tmp30.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp32 := lang.Apply(tmp28, []any{tmp31, v6}) - tmp33 := checkDerefVar(var_glojure_DOT_core_list) - tmp34 := lang.Apply(tmp33, []any{v10}) - tmp35 := lang.Apply(tmp12, []any{tmp14, tmp27, tmp32, tmp34}) - tmp36 := lang.Apply(tmp11, []any{tmp35}) - tmp7 = tmp36 - } // end let - return tmp7 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_UncheckedAdd}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_add.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Returns the sum of x and y, both long.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(1203), kw_end_DASH_line, int(1203))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedAdd") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedAdd is not a function"))) } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core_unchecked_DASH_add = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_unchecked_DASH_add.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // double + // unchecked-add-int { var tmp1 lang.FnFunc - { // function double__inliner + { // function unchecked-add-int__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) + checkArity(args, 2) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_seq) - tmp5 := checkDerefVar(var_glojure_DOT_core_concat) - tmp6 := checkDerefVar(var_glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_add}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_add_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Returns the sum of x and y, both int.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(7), kw_line, int(1196), kw_end_DASH_line, int(1196))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_add") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_add is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_add_DASH_int = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_add_DASH_int.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-byte + { + var tmp1 lang.FnFunc + { // function unchecked-byte__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_DoubleCast}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedByteCast}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -20216,115 +15562,76 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := sym_double.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to double", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(3493), kw_end_DASH_line, int(3493))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_unchecked_DASH_byte.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to byte. Subject to rounding or truncation.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(3517), kw_end_DASH_line, int(3517))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5 := lang.Apply(lang.AsFloat64, []any{v4}) - return tmp5 + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.UncheckedByteCast, []any{v3}) + return tmp4 }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_byte = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_unchecked_DASH_byte.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // double-array + // unchecked-char { var tmp1 lang.FnFunc - { // function double-array__inliner + { // function unchecked-char__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 0) - var v3 any = lang.NewList(args[0:]...) - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_seq) - tmp5 := checkDerefVar(var_glojure_DOT_core_concat) - tmp6 := checkDerefVar(var_glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) - tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_DoubleArray}) - tmp12 := checkDerefVar(var_glojure_DOT_core_list) - tmp13 := checkDerefVar(var_glojure_DOT_core_seq) - tmp14 := checkDerefVar(var_glojure_DOT_core_concat) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_unquote_DASH_splicing}) - tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{sym_glojure_DOT_core_SLASH_args}) - tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) - tmp20 := lang.Apply(tmp13, []any{tmp19}) - tmp21 := lang.Apply(tmp12, []any{tmp20}) - tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp21}) - tmp23 := lang.Apply(tmp4, []any{tmp22}) - return tmp23 - } + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedCharCast}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 }) v2 = tmp1 _ = v2 } - tmp0 := sym_double_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_size_DASH_or_DASH_seq), lang.NewVector(sym_size, sym_init_DASH_val_DASH_or_DASH_seq)), kw_inline, tmp1, kw_doc, "Creates an array of doubles", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(5341), kw_end_DASH_line, int(5341))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "DoubleArray") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("DoubleArray is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - case 2: - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "DoubleArrayInit") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("DoubleArrayInit is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 - default: - checkArity(args, -1) - panic("unreachable") - } - }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // double? - { - tmp0 := sym_double_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a Double", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(1421), kw_end_DASH_line, int(1421))).(*lang.Symbol) + tmp0 := sym_unchecked_DASH_char.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to char. Subject to rounding or truncation.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(3529), kw_end_DASH_line, int(3529))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp5 := lang.Apply(tmp4, []any{lang.Builtins["float64"], v3}) + tmp4, _ := lang.FieldOrMethod(runtime.RT, "UncheckedCharCast") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedCharCast is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core_unchecked_DASH_char = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_unchecked_DASH_char.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // doubles + // unchecked-dec { var tmp1 lang.FnFunc - { // function doubles + { // function unchecked-dec__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) @@ -20337,5700 +15644,4834 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Doubles}) - tmp12 := checkDerefVar(var_glojure_DOT_core_list) - tmp13 := lang.Apply(tmp12, []any{v3}) - tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) - tmp15 := lang.Apply(tmp4, []any{tmp14}) - return tmp15 + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedDec}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 }) v2 = tmp1 _ = v2 } - tmp0 := sym_doubles.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xs)), kw_inline, tmp1, kw_doc, "Casts to double[]", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(12), kw_line, int(5402), kw_end_DASH_line, int(5402))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_unchecked_DASH_dec.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns a number one less than x, a long.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(1175), kw_end_DASH_line, int(1175))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Doubles") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Doubles is not a function"))) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedDec") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedDec is not a function"))) } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_dec = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_unchecked_DASH_dec.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // drop + // unchecked-dec-int { - tmp0 := sym_drop.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n), lang.NewVector(sym_n, sym_coll)), kw_doc, "Returns a laziness-preserving sequence of all but the first n items in coll.\n Returns a stateful transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(2901), kw_end_DASH_line, int(2901))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v5 := args[0] - _ = v5 - var tmp6 any - { // let - // let binding "nv" - tmp7 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) - tmp8 := lang.Apply(tmp7, []any{v3}) - var v9 any = tmp8 - _ = v9 - var tmp10 lang.FnFunc - tmp10 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp11 := lang.Apply(v5, nil) - return tmp11 - case 1: - v11 := args[0] - _ = v11 - tmp12 := lang.Apply(v5, []any{v11}) - return tmp12 - case 2: - v11 := args[0] - _ = v11 - v12 := args[1] - _ = v12 - var tmp13 any - { // let - // let binding "n" - tmp14 := checkDerefVar(var_glojure_DOT_core_deref) - tmp15 := lang.Apply(tmp14, []any{v9}) - var v16 any = tmp15 - _ = v16 - tmp17 := checkDerefVar(var_glojure_DOT_core_dec) - tmp18, ok := lang.FieldOrMethod(v9, "Deref") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v9, "Deref"))) - } - var tmp19 any - switch reflect.TypeOf(tmp18).Kind() { - case reflect.Func: - tmp19 = lang.Apply(tmp18, nil) - default: - tmp19 = tmp18 - } - tmp20 := lang.Apply(tmp17, []any{tmp19}) - tmp21, _ := lang.FieldOrMethod(v9, "reset") - if reflect.TypeOf(tmp21).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) - } - tmp22 := lang.Apply(tmp21, []any{tmp20}) - _ = tmp22 - var tmp23 any - tmp24 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) - tmp25 := lang.Apply(tmp24, []any{v16}) - if lang.IsTruthy(tmp25) { - tmp23 = v11 - } else { - tmp26 := lang.Apply(v5, []any{v11, v12}) - tmp23 = tmp26 - } - tmp13 = tmp23 - } // end let - return tmp13 - default: - checkArity(args, -1) - panic("unreachable") - } - }) - tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2909), kw_column, int(10), kw_end_DASH_line, int(2917), kw_end_DASH_column, int(39)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp6 = tmp12 - } // end let - return tmp6 - }) - tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2907), kw_column, int(6), kw_end_DASH_line, int(2917), kw_end_DASH_column, int(41)) - tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp6 - case 2: + var tmp1 lang.FnFunc + { // function unchecked-dec-int__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) v3 := args[0] _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - tmp6 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp7 := reflect.TypeOf((*lang.IDrop)(nil)).Elem() - tmp8 := lang.Apply(tmp6, []any{tmp7, v4}) - if lang.IsTruthy(tmp8) { - var tmp9 any - { // let - // let binding "or__0__auto__" - var tmp10 any - tmp11 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) - tmp12 := lang.Apply(tmp11, []any{v3}) - if lang.IsTruthy(tmp12) { - var tmp13 any - tmp14 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) - tmp15 := lang.Apply(tmp14, []any{v3}) - if lang.IsTruthy(tmp15) { - tmp13 = v3 - } else { - tmp16 := lang.Apply(nil, []any{v3}) - tmp13 = tmp16 - } - tmp17, _ := lang.FieldOrMethod(v4, "drop") - if reflect.TypeOf(tmp17).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("drop is not a function"))) - } - tmp18 := lang.Apply(tmp17, []any{tmp13}) - tmp10 = tmp18 - } else { - tmp19 := checkDerefVar(var_glojure_DOT_core_seq) - tmp20 := lang.Apply(tmp19, []any{v4}) - tmp10 = tmp20 - } - var v21 any = tmp10 - _ = v21 - var tmp22 any - if lang.IsTruthy(v21) { - tmp22 = v21 - } else { - tmp22 = lang.NewList() - } - tmp9 = tmp22 - } // end let - tmp5 = tmp9 - } else { - var tmp10 any - { // let - // let binding "step" - var tmp11 lang.FnFunc - tmp11 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v12 := args[0] - _ = v12 - v13 := args[1] - _ = v13 - recur_loop_539: - var tmp14 any - { // let - // let binding "s" - tmp15 := checkDerefVar(var_glojure_DOT_core_seq) - tmp16 := lang.Apply(tmp15, []any{v13}) - var v17 any = tmp16 - _ = v17 - var tmp18 any - var tmp19 any - { // let - // let binding "and__0__auto__" - tmp20 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) - tmp21 := lang.Apply(tmp20, []any{v12}) - var v22 any = tmp21 - _ = v22 - var tmp23 any - if lang.IsTruthy(v22) { - tmp23 = v17 - } else { - tmp23 = v22 - } - tmp19 = tmp23 - } // end let - if lang.IsTruthy(tmp19) { - tmp21 := checkDerefVar(var_glojure_DOT_core_dec) - tmp22 := lang.Apply(tmp21, []any{v12}) - var tmp20 any = tmp22 - tmp24 := checkDerefVar(var_glojure_DOT_core_rest) - tmp25 := lang.Apply(tmp24, []any{v17}) - var tmp23 any = tmp25 - v12 = tmp20 - v13 = tmp23 - goto recur_loop_539 - } else { - tmp18 = v17 - } - tmp14 = tmp18 - } // end let - return tmp14 - }) - tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2925), kw_column, int(19), kw_end_DASH_line, int(2929), kw_end_DASH_column, int(28)) - tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v14 any = tmp13 - _ = v14 - var tmp15 lang.FnFunc - tmp15 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - tmp16 := lang.Apply(v14, []any{v3, v4}) - return tmp16 - }) - tmp16 := lang.Apply(lang.NewLazySeq, []any{tmp15}) - tmp10 = tmp16 - } // end let - tmp5 = tmp10 - } - return tmp5 - default: - checkArity(args, -1) - panic("unreachable") + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_dec}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_dec_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns a number one less than x, an int.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(7), kw_line, int(1168), kw_end_DASH_line, int(1168))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_dec") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_dec is not a function"))) } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core_unchecked_DASH_dec_DASH_int = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_unchecked_DASH_dec_DASH_int.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // drop-last + // unchecked-divide-int { - tmp0 := sym_drop_DASH_last.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll), lang.NewVector(sym_n, sym_coll)), kw_doc, "Return a lazy sequence of all but the last n (default 1) items in coll", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(2932), kw_end_DASH_line, int(2932))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_drop_DASH_last) - tmp5 := lang.Apply(tmp4, []any{int64(1), v3}) - return tmp5 - case 2: + var tmp1 lang.FnFunc + { // function unchecked-divide-int__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_map) - var tmp6 lang.FnFunc - tmp6 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v7 := args[0] - _ = v7 - v8 := args[1] - _ = v8 - return v7 - }) - tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2937), kw_column, int(18), kw_end_DASH_line, int(2937), kw_end_DASH_column, int(29)) - tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp9 := checkDerefVar(var_glojure_DOT_core_drop) - tmp10 := lang.Apply(tmp9, []any{v3, v4}) - tmp11 := lang.Apply(tmp5, []any{tmp8, v4, tmp10}) - return tmp11 - default: - checkArity(args, -1) - panic("unreachable") + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_UncheckedIntDivide}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_divide_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Returns the division of x by y, both int.\n Note - uses a primitive operator subject to truncation.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(26), kw_column, int(7), kw_line, int(1238), kw_end_DASH_line, int(1238))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedIntDivide") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedIntDivide is not a function"))) } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core_unchecked_DASH_divide_DASH_int = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_unchecked_DASH_divide_DASH_int.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // drop-while + // unchecked-double { - tmp0 := sym_drop_DASH_while.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred), lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns a lazy sequence of the items in coll starting from the\n first item for which (pred item) returns logical false. Returns a\n stateful transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(2950), kw_end_DASH_line, int(2950))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: + var tmp1 lang.FnFunc + { // function unchecked-double__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) v3 := args[0] _ = v3 - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v5 := args[0] - _ = v5 - var tmp6 any - { // let - // let binding "dv" - tmp7 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) - tmp8 := lang.Apply(tmp7, []any{true}) - var v9 any = tmp8 - _ = v9 - var tmp10 lang.FnFunc - tmp10 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp11 := lang.Apply(v5, nil) - return tmp11 - case 1: - v11 := args[0] - _ = v11 - tmp12 := lang.Apply(v5, []any{v11}) - return tmp12 - case 2: - v11 := args[0] - _ = v11 - v12 := args[1] - _ = v12 - var tmp13 any - { // let - // let binding "drop?" - tmp14 := checkDerefVar(var_glojure_DOT_core_deref) - tmp15 := lang.Apply(tmp14, []any{v9}) - var v16 any = tmp15 - _ = v16 - var tmp17 any - var tmp18 any - { // let - // let binding "and__0__auto__" - var v19 any = v16 - _ = v19 - var tmp20 any - if lang.IsTruthy(v19) { - tmp21 := lang.Apply(v3, []any{v12}) - tmp20 = tmp21 - } else { - tmp20 = v19 - } - tmp18 = tmp20 - } // end let - if lang.IsTruthy(tmp18) { - tmp17 = v11 - } else { - tmp19 := checkDerefVar(var_glojure_DOT_core_vreset_BANG_) - tmp20 := lang.Apply(tmp19, []any{v9, nil}) - _ = tmp20 - tmp21 := lang.Apply(v5, []any{v11, v12}) - tmp17 = tmp21 - } - tmp13 = tmp17 - } // end let - return tmp13 - default: - checkArity(args, -1) - panic("unreachable") - } - }) - tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2959), kw_column, int(10), kw_end_DASH_line, int(2968), kw_end_DASH_column, int(42)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp6 = tmp12 - } // end let - return tmp6 - }) - tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2957), kw_column, int(6), kw_end_DASH_line, int(2968), kw_end_DASH_column, int(44)) - tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp6 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - { // let - // let binding "step" - var tmp6 lang.FnFunc - tmp6 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v7 := args[0] - _ = v7 - v8 := args[1] - _ = v8 - recur_loop_552: - var tmp9 any - { // let - // let binding "s" - tmp10 := checkDerefVar(var_glojure_DOT_core_seq) - tmp11 := lang.Apply(tmp10, []any{v8}) - var v12 any = tmp11 - _ = v12 - var tmp13 any - var tmp14 any - { // let - // let binding "and__0__auto__" - var v15 any = v12 - _ = v15 - var tmp16 any - if lang.IsTruthy(v15) { - tmp17 := checkDerefVar(var_glojure_DOT_core_first) - tmp18 := lang.Apply(tmp17, []any{v12}) - tmp19 := lang.Apply(v7, []any{tmp18}) - tmp16 = tmp19 - } else { - tmp16 = v15 - } - tmp14 = tmp16 - } // end let - if lang.IsTruthy(tmp14) { - var tmp15 any = v7 - tmp17 := checkDerefVar(var_glojure_DOT_core_rest) - tmp18 := lang.Apply(tmp17, []any{v12}) - var tmp16 any = tmp18 - v7 = tmp15 - v8 = tmp16 - goto recur_loop_552 - } else { - tmp13 = v12 - } - tmp9 = tmp13 - } // end let - return tmp9 - }) - tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2970), kw_column, int(17), kw_end_DASH_line, int(2974), kw_end_DASH_column, int(26)) - tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v9 any = tmp8 - _ = v9 - var tmp10 lang.FnFunc - tmp10 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - tmp11 := lang.Apply(v9, []any{v3, v4}) - return tmp11 - }) - tmp11 := lang.Apply(lang.NewLazySeq, []any{tmp10}) - tmp5 = tmp11 - } // end let - return tmp5 - default: - checkArity(args, -1) - panic("unreachable") - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedDoubleCast}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 } - } - // elide-top-frames - { - tmp0 := sym_elide_DASH_top_DASH_frames.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(4794), kw_column, int(7), kw_end_DASH_line, int(4794), kw_end_DASH_column, int(32), kw_arglists, lang.NewList(lang.NewVector(sym_ex, sym_class_DASH_name)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + tmp0 := sym_unchecked_DASH_double.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to double. Subject to rounding.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(22), kw_column, int(7), kw_line, int(3553), kw_end_DASH_line, int(3553))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) + checkArity(args, 1) v3 := args[0] _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - { // let - // let binding "tr" - tmp6, ok := lang.FieldOrMethod(v3, "getStackTrace") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getStackTrace"))) - } - var tmp7 any - switch reflect.TypeOf(tmp6).Kind() { - case reflect.Func: - tmp7 = lang.Apply(tmp6, nil) - default: - tmp7 = tmp6 - } - var v8 any = tmp7 - _ = v8 - var tmp9 any - { // let - // let binding "G__54" - var v10 any = v3 - _ = v10 - var tmp11 any - if lang.IsTruthy(v8) { - tmp12 := checkDerefVar(var_glojure_DOT_core_into_DASH_array) - tmp13 := checkDerefVar(var_glojure_DOT_core_drop_DASH_while) - var tmp14 lang.FnFunc - tmp14 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v15 := args[0] - _ = v15 - tmp16 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp17, ok := lang.FieldOrMethod(v15, "getClassName") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v15, "getClassName"))) - } - var tmp18 any - switch reflect.TypeOf(tmp17).Kind() { - case reflect.Func: - tmp18 = lang.Apply(tmp17, nil) - default: - tmp18 = tmp17 - } - tmp19 := lang.Apply(tmp16, []any{v4, tmp18}) - return tmp19 - }) - tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4801), kw_column, int(25), kw_end_DASH_line, int(4801), kw_end_DASH_column, int(77)) - tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp17 := lang.Apply(tmp13, []any{tmp16, v8}) - tmp18 := lang.Apply(tmp12, []any{nil, tmp17}) - tmp11 = tmp18 - } else { - } - tmp19, _ := lang.FieldOrMethod(v10, "setStackTrace") - if reflect.TypeOf(tmp19).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setStackTrace is not a function"))) - } - tmp20 := lang.Apply(tmp19, []any{tmp11}) - _ = tmp20 - tmp9 = v10 - } // end let - tmp5 = tmp9 - } // end let - return tmp5 + tmp4 := lang.Apply(lang.AsFloat64, []any{v3}) + return tmp4 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core_unchecked_DASH_double = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_unchecked_DASH_double.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // emit-extend-protocol + // unchecked-float { - tmp0 := sym_emit_DASH_extend_DASH_protocol.WithMeta(lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(205), kw_column, int(8), kw_end_DASH_line, int(205), kw_end_DASH_column, int(27), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_p, sym_specs)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function unchecked-float__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedFloatCast}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_float.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to float. Subject to rounding.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(3547), kw_end_DASH_line, int(3547))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) + checkArity(args, 1) v3 := args[0] _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - { // let - // let binding "impls" - tmp6 := checkDerefVar(var_glojure_DOT_core_parse_DASH_impls) - tmp7 := lang.Apply(tmp6, []any{v4}) - var v8 any = tmp7 - _ = v8 - tmp9 := checkDerefVar(var_glojure_DOT_core_seq) - tmp10 := checkDerefVar(var_glojure_DOT_core_concat) - tmp11 := checkDerefVar(var_glojure_DOT_core_list) - tmp12 := lang.Apply(tmp11, []any{sym_do}) - tmp13 := checkDerefVar(var_glojure_DOT_core_map) - var tmp14 lang.FnFunc - tmp14 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v15 := args[0] - _ = v15 - var tmp16 any - { // let - // let binding "vec__292" - var v17 any = v15 - _ = v17 - // let binding "t" - tmp18 := checkDerefVar(var_glojure_DOT_core_nth) - tmp19 := lang.Apply(tmp18, []any{v17, int64(0), nil}) - var v20 any = tmp19 - _ = v20 - // let binding "fs" - tmp21 := checkDerefVar(var_glojure_DOT_core_nth) - tmp22 := lang.Apply(tmp21, []any{v17, int64(1), nil}) - var v23 any = tmp22 - _ = v23 - tmp24 := checkDerefVar(var_glojure_DOT_core_seq) - tmp25 := checkDerefVar(var_glojure_DOT_core_concat) - tmp26 := checkDerefVar(var_glojure_DOT_core_list) - tmp27 := lang.Apply(tmp26, []any{sym_glojure_DOT_core_SLASH_extend_DASH_type}) - tmp28 := checkDerefVar(var_glojure_DOT_core_list) - tmp29 := lang.Apply(tmp28, []any{v20}) - tmp30 := checkDerefVar(var_glojure_DOT_core_list) - tmp31 := lang.Apply(tmp30, []any{v3}) - tmp32 := lang.Apply(tmp25, []any{tmp27, tmp29, tmp31, v23}) - tmp33 := lang.Apply(tmp24, []any{tmp32}) - tmp16 = tmp33 - } // end let - return tmp16 - }) - tmp15 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(208), kw_column, int(15), kw_end_DASH_line, int(209), kw_end_DASH_column, int(42)) - tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp17 := lang.Apply(tmp13, []any{tmp16, v8}) - tmp18 := lang.Apply(tmp10, []any{tmp12, tmp17}) - tmp19 := lang.Apply(tmp9, []any{tmp18}) - tmp5 = tmp19 - } // end let - return tmp5 + tmp4 := lang.Apply(lang.UncheckedFloatCast, []any{v3}) + return tmp4 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core_unchecked_DASH_float = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_unchecked_DASH_float.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // emit-extend-type + // unchecked-inc { - tmp0 := sym_emit_DASH_extend_DASH_type.WithMeta(lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(175), kw_column, int(8), kw_end_DASH_line, int(175), kw_end_DASH_column, int(23), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_c, sym_specs)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function unchecked-inc__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Unchecked_inc}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_inc.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns a number one greater than x, a long.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(1161), kw_end_DASH_line, int(1161))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) + checkArity(args, 1) v3 := args[0] _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - { // let - // let binding "impls" - tmp6 := checkDerefVar(var_glojure_DOT_core_parse_DASH_impls) - tmp7 := lang.Apply(tmp6, []any{v4}) - var v8 any = tmp7 - _ = v8 - tmp9 := checkDerefVar(var_glojure_DOT_core_seq) - tmp10 := checkDerefVar(var_glojure_DOT_core_concat) - tmp11 := checkDerefVar(var_glojure_DOT_core_list) - tmp12 := lang.Apply(tmp11, []any{sym_glojure_DOT_core_SLASH_extend}) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{v3}) - tmp15 := checkDerefVar(var_glojure_DOT_core_mapcat) - tmp16 := checkDerefVar(var_glojure_DOT_core_partial) - tmp17 := checkDerefVar(var_glojure_DOT_core_emit_DASH_hinted_DASH_impl) - tmp18 := lang.Apply(tmp16, []any{tmp17, v3}) - tmp19 := lang.Apply(tmp15, []any{tmp18, v8}) - tmp20 := lang.Apply(tmp10, []any{tmp12, tmp14, tmp19}) - tmp21 := lang.Apply(tmp9, []any{tmp20}) - tmp5 = tmp21 - } // end let + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_inc") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_inc is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core_unchecked_DASH_inc = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_unchecked_DASH_inc.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // emit-hinted-impl + // unchecked-inc-int { - tmp0 := sym_emit_DASH_hinted_DASH_impl.WithMeta(lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(163), kw_column, int(8), kw_end_DASH_line, int(163), kw_end_DASH_column, int(23), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_c, lang.NewVector(sym_p, sym_fs))), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function unchecked-inc-int__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_inc}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_inc_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns a number one greater than x, an int.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(7), kw_line, int(1154), kw_end_DASH_line, int(1154))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) + checkArity(args, 1) v3 := args[0] _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - { // let - // let binding "vec__281" - var v6 any = v4 - _ = v6 - // let binding "p" - tmp7 := checkDerefVar(var_glojure_DOT_core_nth) - tmp8 := lang.Apply(tmp7, []any{v6, int64(0), nil}) - var v9 any = tmp8 - _ = v9 - // let binding "fs" - tmp10 := checkDerefVar(var_glojure_DOT_core_nth) - tmp11 := lang.Apply(tmp10, []any{v6, int64(1), nil}) - var v12 any = tmp11 - _ = v12 - var tmp13 any - { // let - // let binding "hint" - var tmp14 lang.FnFunc - tmp14 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v15 := args[0] - _ = v15 - var tmp16 any - { // let - // let binding "specs" - var tmp17 any - tmp18 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) - tmp19 := checkDerefVar(var_glojure_DOT_core_first) - tmp20 := lang.Apply(tmp19, []any{v15}) - tmp21 := lang.Apply(tmp18, []any{tmp20}) - if lang.IsTruthy(tmp21) { - tmp22 := checkDerefVar(var_glojure_DOT_core_list) - tmp23 := lang.Apply(tmp22, []any{v15}) - tmp17 = tmp23 - } else { - tmp17 = v15 - } - var v24 any = tmp17 - _ = v24 - tmp25 := checkDerefVar(var_glojure_DOT_core_map) - var tmp26 lang.FnFunc - tmp26 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v27 := args[0] - _ = v27 - var tmp28 any - { // let - // let binding "vec__285" - var v29 any = v27 - _ = v29 - // let binding "seq__286" - tmp30 := checkDerefVar(var_glojure_DOT_core_seq) - tmp31 := lang.Apply(tmp30, []any{v29}) - var v32 any = tmp31 - _ = v32 - // let binding "first__287" - tmp33 := checkDerefVar(var_glojure_DOT_core_first) - tmp34 := lang.Apply(tmp33, []any{v32}) - var v35 any = tmp34 - _ = v35 - // let binding "seq__286" - tmp36 := checkDerefVar(var_glojure_DOT_core_next) - tmp37 := lang.Apply(tmp36, []any{v32}) - var v38 any = tmp37 - _ = v38 - // let binding "vec__288" - var v39 any = v35 - _ = v39 - // let binding "seq__289" - tmp40 := checkDerefVar(var_glojure_DOT_core_seq) - tmp41 := lang.Apply(tmp40, []any{v39}) - var v42 any = tmp41 - _ = v42 - // let binding "first__290" - tmp43 := checkDerefVar(var_glojure_DOT_core_first) - tmp44 := lang.Apply(tmp43, []any{v42}) - var v45 any = tmp44 - _ = v45 - // let binding "seq__289" - tmp46 := checkDerefVar(var_glojure_DOT_core_next) - tmp47 := lang.Apply(tmp46, []any{v42}) - var v48 any = tmp47 - _ = v48 - // let binding "target" - var v49 any = v45 - _ = v49 - // let binding "args" - var v50 any = v48 - _ = v50 - // let binding "body" - var v51 any = v38 - _ = v51 - tmp52 := checkDerefVar(var_glojure_DOT_core_cons) - tmp53 := checkDerefVar(var_glojure_DOT_core_apply) - tmp54 := checkDerefVar(var_glojure_DOT_core_vector) - tmp55 := checkDerefVar(var_glojure_DOT_core_vary_DASH_meta) - tmp56 := checkDerefVar(var_glojure_DOT_core_assoc) - tmp57 := lang.Apply(tmp55, []any{v49, tmp56, kw_tag, v3}) - tmp58 := lang.Apply(tmp53, []any{tmp54, tmp57, v50}) - tmp59 := lang.Apply(tmp52, []any{tmp58, v51}) - tmp28 = tmp59 - } // end let - return tmp28 - }) - tmp27 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(168), kw_column, int(23), kw_end_DASH_line, int(170), kw_end_DASH_column, int(36)) - tmp28, err := lang.WithMeta(tmp26, tmp27.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp29 := lang.Apply(tmp25, []any{tmp28, v24}) - tmp16 = tmp29 - } // end let - return tmp16 - }) - tmp15 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(164), kw_column, int(14), kw_end_DASH_line, int(171), kw_end_DASH_column, int(30)) - tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v17 any = tmp16 - _ = v17 - tmp18 := checkDerefVar(var_glojure_DOT_core_zipmap) - tmp19 := checkDerefVar(var_glojure_DOT_core_map) - var tmp20 lang.FnFunc - tmp20 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v21 := args[0] - _ = v21 - tmp22 := checkDerefVar(var_glojure_DOT_core_keyword) - tmp23 := checkDerefVar(var_glojure_DOT_core_name) - tmp24 := checkDerefVar(var_glojure_DOT_core_first) - tmp25 := lang.Apply(tmp24, []any{v21}) - tmp26 := lang.Apply(tmp23, []any{tmp25}) - tmp27 := lang.Apply(tmp22, []any{tmp26}) - return tmp27 - }) - tmp21 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(172), kw_column, int(21), kw_end_DASH_line, int(172), kw_end_DASH_column, int(46)) - tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp23 := lang.Apply(tmp19, []any{tmp22, v12}) - tmp24 := checkDerefVar(var_glojure_DOT_core_map) - var tmp25 lang.FnFunc - tmp25 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v26 := args[0] - _ = v26 - tmp27 := checkDerefVar(var_glojure_DOT_core_cons) - tmp28 := checkDerefVar(var_glojure_DOT_core_drop) - tmp29 := lang.Apply(tmp28, []any{int64(1), v26}) - tmp30 := lang.Apply(v17, []any{tmp29}) - tmp31 := lang.Apply(tmp27, []any{sym_glojure_DOT_core_SLASH_fn, tmp30}) - return tmp31 - }) - tmp26 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(173), kw_column, int(21), kw_end_DASH_line, int(173), kw_end_DASH_column, int(49)) - tmp27, err := lang.WithMeta(tmp25, tmp26.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp28 := lang.Apply(tmp24, []any{tmp27, v12}) - tmp29 := lang.Apply(tmp18, []any{tmp23, tmp28}) - tmp30 := lang.NewVector(v9, tmp29) - tmp31 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(172), kw_column, int(5), kw_end_DASH_line, int(173), kw_end_DASH_column, int(55)) - tmp32, err := lang.WithMeta(tmp30, tmp31.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp13 = tmp32 - } // end let - tmp5 = tmp13 - } // end let + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_inc") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_inc is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core_unchecked_DASH_inc_DASH_int = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_unchecked_DASH_inc_DASH_int.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // empty + // unchecked-int { - tmp0 := sym_empty.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns an empty collection of the same category as coll, or nil", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(5265), kw_end_DASH_line, int(5265))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function unchecked-int__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedIntCast}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to int. Subject to rounding or truncation.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(3535), kw_end_DASH_line, int(3535))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) v3 := args[0] _ = v3 - var tmp4 any - tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp6 := reflect.TypeOf((*lang.IPersistentCollection)(nil)).Elem() - tmp7 := lang.Apply(tmp5, []any{tmp6, v3}) - if lang.IsTruthy(tmp7) { - tmp8, ok := lang.FieldOrMethod(v3, "empty") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "empty"))) - } - var tmp9 any - switch reflect.TypeOf(tmp8).Kind() { - case reflect.Func: - tmp9 = lang.Apply(tmp8, nil) - default: - tmp9 = tmp8 - } - tmp4 = tmp9 - } else { - } + tmp4 := lang.Apply(lang.UncheckedIntCast, []any{v3}) return tmp4 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core_unchecked_DASH_int = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_unchecked_DASH_int.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // empty? + // unchecked-long { - tmp0 := sym_empty_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns true if coll has no items. To check the emptiness of a seq,\n please use the idiom (seq x) rather than (not (empty? x))", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(6247), kw_end_DASH_line, int(6247))).(*lang.Symbol) - var tmp2 lang.FnFunc + var tmp1 lang.FnFunc + { // function unchecked-long__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedLongCast}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_long.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to long. Subject to rounding or truncation.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(3541), kw_end_DASH_line, int(3541))).(*lang.Symbol) + var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) v3 := args[0] _ = v3 - var tmp4 any - tmp5 := checkDerefVar(var_glojure_DOT_core_counted_QMARK_) - tmp6 := lang.Apply(tmp5, []any{v3}) - if lang.IsTruthy(tmp6) { - tmp7 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) - tmp8 := checkDerefVar(var_glojure_DOT_core_count) - tmp9 := lang.Apply(tmp8, []any{v3}) - tmp10 := lang.Apply(tmp7, []any{tmp9}) - tmp4 = tmp10 - } else { - tmp11 := checkDerefVar(var_glojure_DOT_core_not) - tmp12 := checkDerefVar(var_glojure_DOT_core_seq) - tmp13 := lang.Apply(tmp12, []any{v3}) - tmp14 := lang.Apply(tmp11, []any{tmp13}) - tmp4 = tmp14 - } + tmp4 := lang.Apply(lang.UncheckedLongCast, []any{v3}) return tmp4 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core_unchecked_DASH_long = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_unchecked_DASH_long.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // ensure + // unchecked-multiply { - tmp0 := sym_ensure.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ref)), kw_doc, "Must be called in a transaction. Protects the ref from modification\n by other transactions. Returns the in-transaction-value of\n ref. Allows for more concurrency than (ref-set ref @ref)", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(2480), kw_end_DASH_line, int(2480))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function unchecked-multiply__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_multiply}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_multiply.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Returns the product of x and y, both long.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(24), kw_column, int(7), kw_line, int(1231), kw_end_DASH_line, int(1231))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) + checkArity(args, 2) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(v3, "touch") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("touch is not a function"))) - } - tmp5 := lang.Apply(tmp4, []any{}) - _ = tmp5 - tmp6, _ := lang.FieldOrMethod(v3, "deref") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("deref is not a function"))) + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_multiply") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_multiply is not a function"))) } - tmp7 := lang.Apply(tmp6, []any{}) - return tmp7 + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core_unchecked_DASH_multiply = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_unchecked_DASH_multiply.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // ensure-reduced + // unchecked-multiply-int { - tmp0 := sym_ensure_DASH_reduced.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "If x is already reduced?, returns it, else returns (reduced x)", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(2841), kw_end_DASH_line, int(2841))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function unchecked-multiply-int__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_multiply}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_multiply_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Returns the product of x and y, both int.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(28), kw_column, int(7), kw_line, int(1224), kw_end_DASH_line, int(1224))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) + checkArity(args, 2) v3 := args[0] _ = v3 - var tmp4 any - tmp5 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) - tmp6 := lang.Apply(tmp5, []any{v3}) - if lang.IsTruthy(tmp6) { - tmp4 = v3 - } else { - tmp7 := checkDerefVar(var_glojure_DOT_core_reduced) - tmp8 := lang.Apply(tmp7, []any{v3}) - tmp4 = tmp8 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_multiply") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_multiply is not a function"))) } - return tmp4 + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core_unchecked_DASH_multiply_DASH_int = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_unchecked_DASH_multiply_DASH_int.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // enumeration-seq + // unchecked-negate { - tmp0 := sym_enumeration_DASH_seq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_e)), kw_doc, "Returns a seq on a java.util.Enumeration", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(5710), kw_end_DASH_line, int(5710))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function unchecked-negate__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Unchecked_minus}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_negate.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns the negation of x, a long.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(22), kw_column, int(7), kw_line, int(1189), kw_end_DASH_line, int(1189))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := lang.Apply(nil, []any{v3}) - return tmp4 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_negate") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_negate is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core_unchecked_DASH_negate = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_unchecked_DASH_negate.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // error-handler + // unchecked-negate-int { - tmp0 := sym_error_DASH_handler.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a)), kw_doc, "Returns the error-handler of agent a, or nil if there is none.\n See set-error-handler!", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(2202), kw_end_DASH_line, int(2202))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function unchecked-negate-int__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_negate}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_negate_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns the negation of x, an int.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(26), kw_column, int(7), kw_line, int(1182), kw_end_DASH_line, int(1182))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, ok := lang.FieldOrMethod(v3, "getErrorHandler") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getErrorHandler"))) - } - var tmp5 any - switch reflect.TypeOf(tmp4).Kind() { - case reflect.Func: - tmp5 = lang.Apply(tmp4, nil) - default: - tmp5 = tmp4 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_negate") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_negate is not a function"))) } + tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core_unchecked_DASH_negate_DASH_int = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_unchecked_DASH_negate_DASH_int.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // error-mode + // unchecked-remainder-int { - tmp0 := sym_error_DASH_mode.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a)), kw_doc, "Returns the error-mode of agent a. See set-error-mode!", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(2227), kw_end_DASH_line, int(2227))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function unchecked-remainder-int__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_remainder}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_remainder_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Returns the remainder of division of x by y, both int.\n Note - uses a primitive operator subject to truncation.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(29), kw_column, int(7), kw_line, int(1245), kw_end_DASH_line, int(1245))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) + checkArity(args, 2) v3 := args[0] _ = v3 - tmp4, ok := lang.FieldOrMethod(v3, "getErrorMode") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getErrorMode"))) - } - var tmp5 any - switch reflect.TypeOf(tmp4).Kind() { - case reflect.Func: - tmp5 = lang.Apply(tmp4, nil) - default: - tmp5 = tmp4 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_remainder") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_remainder is not a function"))) } - return tmp5 + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core_unchecked_DASH_remainder_DASH_int = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_unchecked_DASH_remainder_DASH_int.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // eval + // unchecked-short { - tmp0 := sym_eval.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_form)), kw_doc, "Evaluates the form data structure (not text!) and returns the result.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3203), kw_end_DASH_line, int(3203))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function unchecked-short__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedShortCast}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_short.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to short. Subject to rounding or truncation.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(3523), kw_end_DASH_line, int(3523))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(runtime.Compiler, "Eval") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Eval is not a function"))) - } - tmp5 := lang.Apply(tmp4, []any{v3}) - return tmp5 + tmp4 := lang.Apply(lang.UncheckedShortCast, []any{v3}) + return tmp4 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core_unchecked_DASH_short = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_unchecked_DASH_short.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // even? + // unchecked-subtract { - tmp0 := sym_even_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_doc, "Returns true if n is even, throws an exception if n is not an integer", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(1381), kw_end_DASH_line, int(1381))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function unchecked-subtract__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_minus}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_subtract.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Returns the difference of x and y, both long.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(24), kw_column, int(7), kw_line, int(1217), kw_end_DASH_line, int(1217))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) + checkArity(args, 2) v3 := args[0] _ = v3 - var tmp4 any - tmp5 := checkDerefVar(var_glojure_DOT_core_integer_QMARK_) - tmp6 := lang.Apply(tmp5, []any{v3}) - if lang.IsTruthy(tmp6) { - tmp7 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) - tmp8 := checkDerefVar(var_glojure_DOT_core_bit_DASH_and) - tmp9 := lang.Apply(lang.UncheckedLongCast, []any{v3}) - tmp10 := lang.Apply(tmp8, []any{tmp9, int64(1)}) - tmp11 := lang.Apply(tmp7, []any{tmp10}) - tmp4 = tmp11 - } else { - tmp12 := checkDerefVar(var_glojure_DOT_core_str) - tmp13 := lang.Apply(tmp12, []any{"Argument must be an integer: ", v3}) - tmp14 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp13}) - panic(tmp14) + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_minus") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_minus is not a function"))) } - return tmp4 + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core_unchecked_DASH_subtract = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_unchecked_DASH_subtract.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // every-pred + // unchecked-subtract-int { - tmp0 := sym_every_DASH_pred.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_p), lang.NewVector(sym_p1, sym_p2), lang.NewVector(sym_p1, sym_p2, sym_p3), lang.NewVector(sym_p1, sym_p2, sym_p3, sym__AMP_, sym_ps)), kw_doc, "Takes a set of predicates and returns a function f that returns true if all of its\n composing predicates return a logical true value against all of its arguments, else it returns\n false. Note that f is short-circuiting in that it will stop execution on the first\n argument that triggers a logical false result against the original predicates.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(7422), kw_end_DASH_line, int(7422))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - var tmp4 lang.FnFunc - { // function ep1 - var v5 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - return true - case 1: - v6 := args[0] - _ = v6 - tmp7 := checkDerefVar(var_glojure_DOT_core_boolean) - tmp8 := lang.Apply(v3, []any{v6}) - tmp9 := lang.Apply(tmp7, []any{tmp8}) - return tmp9 - case 2: - v6 := args[0] - _ = v6 - v7 := args[1] - _ = v7 - tmp8 := checkDerefVar(var_glojure_DOT_core_boolean) - var tmp9 any - { // let - // let binding "and__0__auto__" - tmp10 := lang.Apply(v3, []any{v6}) - var v11 any = tmp10 - _ = v11 - var tmp12 any - if lang.IsTruthy(v11) { - tmp13 := lang.Apply(v3, []any{v7}) - tmp12 = tmp13 - } else { - tmp12 = v11 - } - tmp9 = tmp12 - } // end let - tmp10 := lang.Apply(tmp8, []any{tmp9}) - return tmp10 - case 3: - v6 := args[0] - _ = v6 - v7 := args[1] - _ = v7 - v8 := args[2] - _ = v8 - tmp9 := checkDerefVar(var_glojure_DOT_core_boolean) - var tmp10 any - { // let - // let binding "and__0__auto__" - tmp11 := lang.Apply(v3, []any{v6}) - var v12 any = tmp11 - _ = v12 - var tmp13 any - if lang.IsTruthy(v12) { - var tmp14 any - { // let - // let binding "and__0__auto__" - tmp15 := lang.Apply(v3, []any{v7}) - var v16 any = tmp15 - _ = v16 - var tmp17 any - if lang.IsTruthy(v16) { - tmp18 := lang.Apply(v3, []any{v8}) - tmp17 = tmp18 - } else { - tmp17 = v16 - } - tmp14 = tmp17 - } // end let - tmp13 = tmp14 - } else { - tmp13 = v12 - } - tmp10 = tmp13 - } // end let - tmp11 := lang.Apply(tmp9, []any{tmp10}) - return tmp11 - default: - checkArity(args, 3) - v6 := args[0] - _ = v6 - v7 := args[1] - _ = v7 - v8 := args[2] - _ = v8 - var v9 any = lang.NewList(args[3:]...) - _ = v9 - tmp10 := checkDerefVar(var_glojure_DOT_core_boolean) - var tmp11 any - { // let - // let binding "and__0__auto__" - tmp12 := lang.Apply(v5, []any{v6, v7, v8}) - var v13 any = tmp12 - _ = v13 - var tmp14 any - if lang.IsTruthy(v13) { - tmp15 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) - tmp16 := lang.Apply(tmp15, []any{v3, v9}) - tmp14 = tmp16 - } else { - tmp14 = v13 - } - tmp11 = tmp14 - } // end let - tmp12 := lang.Apply(tmp10, []any{tmp11}) - return tmp12 - } - }) - v5 = tmp4 - _ = v5 - } - tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7429), kw_column, int(6), kw_end_DASH_line, int(7435), kw_end_DASH_column, int(56)) - tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp6 - case 2: + var tmp1 lang.FnFunc + { // function unchecked-subtract-int__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 - var tmp5 lang.FnFunc - { // function ep2 - var v6 lang.FnFunc - tmp5 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - return true - case 1: - v7 := args[0] - _ = v7 - tmp8 := checkDerefVar(var_glojure_DOT_core_boolean) - var tmp9 any - { // let - // let binding "and__0__auto__" - tmp10 := lang.Apply(v3, []any{v7}) - var v11 any = tmp10 - _ = v11 - var tmp12 any - if lang.IsTruthy(v11) { - tmp13 := lang.Apply(v4, []any{v7}) - tmp12 = tmp13 - } else { - tmp12 = v11 - } - tmp9 = tmp12 - } // end let - tmp10 := lang.Apply(tmp8, []any{tmp9}) - return tmp10 - case 2: - v7 := args[0] - _ = v7 - v8 := args[1] - _ = v8 - tmp9 := checkDerefVar(var_glojure_DOT_core_boolean) - var tmp10 any - { // let - // let binding "and__0__auto__" - tmp11 := lang.Apply(v3, []any{v7}) - var v12 any = tmp11 - _ = v12 - var tmp13 any - if lang.IsTruthy(v12) { - var tmp14 any - { // let - // let binding "and__0__auto__" - tmp15 := lang.Apply(v3, []any{v8}) - var v16 any = tmp15 - _ = v16 - var tmp17 any - if lang.IsTruthy(v16) { - var tmp18 any - { // let - // let binding "and__0__auto__" - tmp19 := lang.Apply(v4, []any{v7}) - var v20 any = tmp19 - _ = v20 - var tmp21 any - if lang.IsTruthy(v20) { - tmp22 := lang.Apply(v4, []any{v8}) - tmp21 = tmp22 - } else { - tmp21 = v20 - } - tmp18 = tmp21 - } // end let - tmp17 = tmp18 - } else { - tmp17 = v16 - } - tmp14 = tmp17 - } // end let - tmp13 = tmp14 - } else { - tmp13 = v12 - } - tmp10 = tmp13 - } // end let - tmp11 := lang.Apply(tmp9, []any{tmp10}) - return tmp11 - case 3: - v7 := args[0] - _ = v7 - v8 := args[1] - _ = v8 - v9 := args[2] - _ = v9 - tmp10 := checkDerefVar(var_glojure_DOT_core_boolean) - var tmp11 any - { // let - // let binding "and__0__auto__" - tmp12 := lang.Apply(v3, []any{v7}) - var v13 any = tmp12 - _ = v13 - var tmp14 any - if lang.IsTruthy(v13) { - var tmp15 any - { // let - // let binding "and__0__auto__" - tmp16 := lang.Apply(v3, []any{v8}) - var v17 any = tmp16 - _ = v17 - var tmp18 any - if lang.IsTruthy(v17) { - var tmp19 any - { // let - // let binding "and__0__auto__" - tmp20 := lang.Apply(v3, []any{v9}) - var v21 any = tmp20 - _ = v21 - var tmp22 any - if lang.IsTruthy(v21) { - var tmp23 any - { // let - // let binding "and__0__auto__" - tmp24 := lang.Apply(v4, []any{v7}) - var v25 any = tmp24 - _ = v25 - var tmp26 any - if lang.IsTruthy(v25) { - var tmp27 any - { // let - // let binding "and__0__auto__" - tmp28 := lang.Apply(v4, []any{v8}) - var v29 any = tmp28 - _ = v29 - var tmp30 any - if lang.IsTruthy(v29) { - tmp31 := lang.Apply(v4, []any{v9}) - tmp30 = tmp31 - } else { - tmp30 = v29 - } - tmp27 = tmp30 - } // end let - tmp26 = tmp27 - } else { - tmp26 = v25 - } - tmp23 = tmp26 - } // end let - tmp22 = tmp23 - } else { - tmp22 = v21 - } - tmp19 = tmp22 - } // end let - tmp18 = tmp19 - } else { - tmp18 = v17 - } - tmp15 = tmp18 - } // end let - tmp14 = tmp15 - } else { - tmp14 = v13 - } - tmp11 = tmp14 - } // end let - tmp12 := lang.Apply(tmp10, []any{tmp11}) - return tmp12 - default: - checkArity(args, 3) - v7 := args[0] - _ = v7 - v8 := args[1] - _ = v8 - v9 := args[2] - _ = v9 - var v10 any = lang.NewList(args[3:]...) - _ = v10 - tmp11 := checkDerefVar(var_glojure_DOT_core_boolean) - var tmp12 any - { // let - // let binding "and__0__auto__" - tmp13 := lang.Apply(v6, []any{v7, v8, v9}) - var v14 any = tmp13 - _ = v14 - var tmp15 any - if lang.IsTruthy(v14) { - tmp16 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) - var tmp17 lang.FnFunc - tmp17 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v18 := args[0] - _ = v18 - var tmp19 any - { // let - // let binding "and__0__auto__" - tmp20 := lang.Apply(v3, []any{v18}) - var v21 any = tmp20 - _ = v21 - var tmp22 any - if lang.IsTruthy(v21) { - tmp23 := lang.Apply(v4, []any{v18}) - tmp22 = tmp23 - } else { - tmp22 = v21 - } - tmp19 = tmp22 - } // end let - return tmp19 - }) - tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7443), kw_column, int(46), kw_end_DASH_line, int(7443), kw_end_DASH_column, int(65)) - tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp20 := lang.Apply(tmp16, []any{tmp19, v10}) - tmp15 = tmp20 - } else { - tmp15 = v14 - } - tmp12 = tmp15 - } // end let - tmp13 := lang.Apply(tmp11, []any{tmp12}) - return tmp13 - } - }) - v6 = tmp5 - _ = v6 - } - tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7437), kw_column, int(6), kw_end_DASH_line, int(7443), kw_end_DASH_column, int(75)) - tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp7 - case 3: + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_subtract}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_subtract_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Returns the difference of x and y, both int.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(28), kw_column, int(7), kw_line, int(1210), kw_end_DASH_line, int(1210))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_subtract") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_subtract is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_subtract_DASH_int = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_subtract_DASH_int.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unreduced + { + tmp0 := sym_unreduced.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "If x is reduced?, returns (deref x), else returns x", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(2847), kw_end_DASH_line, int(2847))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + tmp6 := checkDerefVar(var_glojure_DOT_core_deref) + tmp7 := lang.Apply(tmp6, []any{v2}) + tmp3 = tmp7 + } else { + tmp3 = v2 + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unreduced = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unreduced.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unsigned-bit-shift-right + { + var tmp1 lang.FnFunc + { // function unsigned-bit-shift-right__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 - v5 := args[2] - _ = v5 - var tmp6 lang.FnFunc - { // function ep3 - var v7 lang.FnFunc - tmp6 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - return true - case 1: - v8 := args[0] - _ = v8 - tmp9 := checkDerefVar(var_glojure_DOT_core_boolean) - var tmp10 any - { // let - // let binding "and__0__auto__" - tmp11 := lang.Apply(v3, []any{v8}) - var v12 any = tmp11 - _ = v12 - var tmp13 any - if lang.IsTruthy(v12) { - var tmp14 any - { // let - // let binding "and__0__auto__" - tmp15 := lang.Apply(v4, []any{v8}) - var v16 any = tmp15 - _ = v16 - var tmp17 any - if lang.IsTruthy(v16) { - tmp18 := lang.Apply(v5, []any{v8}) - tmp17 = tmp18 - } else { - tmp17 = v16 - } - tmp14 = tmp17 - } // end let - tmp13 = tmp14 - } else { - tmp13 = v12 - } - tmp10 = tmp13 - } // end let - tmp11 := lang.Apply(tmp9, []any{tmp10}) - return tmp11 - case 2: - v8 := args[0] - _ = v8 - v9 := args[1] - _ = v9 - tmp10 := checkDerefVar(var_glojure_DOT_core_boolean) - var tmp11 any - { // let - // let binding "and__0__auto__" - tmp12 := lang.Apply(v3, []any{v8}) - var v13 any = tmp12 - _ = v13 - var tmp14 any - if lang.IsTruthy(v13) { - var tmp15 any - { // let - // let binding "and__0__auto__" - tmp16 := lang.Apply(v3, []any{v9}) - var v17 any = tmp16 - _ = v17 - var tmp18 any - if lang.IsTruthy(v17) { - var tmp19 any - { // let - // let binding "and__0__auto__" - tmp20 := lang.Apply(v4, []any{v8}) - var v21 any = tmp20 - _ = v21 - var tmp22 any - if lang.IsTruthy(v21) { - var tmp23 any - { // let - // let binding "and__0__auto__" - tmp24 := lang.Apply(v4, []any{v9}) - var v25 any = tmp24 - _ = v25 - var tmp26 any - if lang.IsTruthy(v25) { - var tmp27 any - { // let - // let binding "and__0__auto__" - tmp28 := lang.Apply(v5, []any{v8}) - var v29 any = tmp28 - _ = v29 - var tmp30 any - if lang.IsTruthy(v29) { - tmp31 := lang.Apply(v5, []any{v9}) - tmp30 = tmp31 - } else { - tmp30 = v29 - } - tmp27 = tmp30 - } // end let - tmp26 = tmp27 - } else { - tmp26 = v25 - } - tmp23 = tmp26 - } // end let - tmp22 = tmp23 - } else { - tmp22 = v21 - } - tmp19 = tmp22 - } // end let - tmp18 = tmp19 - } else { - tmp18 = v17 - } - tmp15 = tmp18 - } // end let - tmp14 = tmp15 - } else { - tmp14 = v13 - } - tmp11 = tmp14 - } // end let - tmp12 := lang.Apply(tmp10, []any{tmp11}) - return tmp12 - case 3: - v8 := args[0] - _ = v8 - v9 := args[1] - _ = v9 - v10 := args[2] - _ = v10 - tmp11 := checkDerefVar(var_glojure_DOT_core_boolean) - var tmp12 any - { // let - // let binding "and__0__auto__" - tmp13 := lang.Apply(v3, []any{v8}) - var v14 any = tmp13 - _ = v14 - var tmp15 any - if lang.IsTruthy(v14) { - var tmp16 any - { // let - // let binding "and__0__auto__" - tmp17 := lang.Apply(v3, []any{v9}) - var v18 any = tmp17 - _ = v18 - var tmp19 any - if lang.IsTruthy(v18) { - var tmp20 any - { // let - // let binding "and__0__auto__" - tmp21 := lang.Apply(v3, []any{v10}) - var v22 any = tmp21 - _ = v22 - var tmp23 any - if lang.IsTruthy(v22) { - var tmp24 any - { // let - // let binding "and__0__auto__" - tmp25 := lang.Apply(v4, []any{v8}) - var v26 any = tmp25 - _ = v26 - var tmp27 any - if lang.IsTruthy(v26) { - var tmp28 any - { // let - // let binding "and__0__auto__" - tmp29 := lang.Apply(v4, []any{v9}) - var v30 any = tmp29 - _ = v30 - var tmp31 any - if lang.IsTruthy(v30) { - var tmp32 any - { // let - // let binding "and__0__auto__" - tmp33 := lang.Apply(v4, []any{v10}) - var v34 any = tmp33 - _ = v34 - var tmp35 any - if lang.IsTruthy(v34) { - var tmp36 any - { // let - // let binding "and__0__auto__" - tmp37 := lang.Apply(v5, []any{v8}) - var v38 any = tmp37 - _ = v38 - var tmp39 any - if lang.IsTruthy(v38) { - var tmp40 any - { // let - // let binding "and__0__auto__" - tmp41 := lang.Apply(v5, []any{v9}) - var v42 any = tmp41 - _ = v42 - var tmp43 any - if lang.IsTruthy(v42) { - tmp44 := lang.Apply(v5, []any{v10}) - tmp43 = tmp44 - } else { - tmp43 = v42 - } - tmp40 = tmp43 - } // end let - tmp39 = tmp40 - } else { - tmp39 = v38 - } - tmp36 = tmp39 - } // end let - tmp35 = tmp36 - } else { - tmp35 = v34 - } - tmp32 = tmp35 - } // end let - tmp31 = tmp32 - } else { - tmp31 = v30 - } - tmp28 = tmp31 - } // end let - tmp27 = tmp28 - } else { - tmp27 = v26 - } - tmp24 = tmp27 - } // end let - tmp23 = tmp24 - } else { - tmp23 = v22 - } - tmp20 = tmp23 - } // end let - tmp19 = tmp20 - } else { - tmp19 = v18 - } - tmp16 = tmp19 - } // end let - tmp15 = tmp16 - } else { - tmp15 = v14 - } - tmp12 = tmp15 - } // end let - tmp13 := lang.Apply(tmp11, []any{tmp12}) - return tmp13 - default: - checkArity(args, 3) - v8 := args[0] - _ = v8 - v9 := args[1] - _ = v9 - v10 := args[2] - _ = v10 - var v11 any = lang.NewList(args[3:]...) - _ = v11 - tmp12 := checkDerefVar(var_glojure_DOT_core_boolean) - var tmp13 any - { // let - // let binding "and__0__auto__" - tmp14 := lang.Apply(v7, []any{v8, v9, v10}) - var v15 any = tmp14 - _ = v15 - var tmp16 any - if lang.IsTruthy(v15) { - tmp17 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) - var tmp18 lang.FnFunc - tmp18 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v19 := args[0] - _ = v19 - var tmp20 any - { // let - // let binding "and__0__auto__" - tmp21 := lang.Apply(v3, []any{v19}) - var v22 any = tmp21 - _ = v22 - var tmp23 any - if lang.IsTruthy(v22) { - var tmp24 any - { // let - // let binding "and__0__auto__" - tmp25 := lang.Apply(v4, []any{v19}) - var v26 any = tmp25 - _ = v26 - var tmp27 any - if lang.IsTruthy(v26) { - tmp28 := lang.Apply(v5, []any{v19}) - tmp27 = tmp28 - } else { - tmp27 = v26 - } - tmp24 = tmp27 - } // end let - tmp23 = tmp24 - } else { - tmp23 = v22 - } - tmp20 = tmp23 - } // end let - return tmp20 - }) - tmp19 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7451), kw_column, int(46), kw_end_DASH_line, int(7451), kw_end_DASH_column, int(72)) - tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp21 := lang.Apply(tmp17, []any{tmp20, v11}) - tmp16 = tmp21 - } else { - tmp16 = v15 - } - tmp13 = tmp16 - } // end let - tmp14 := lang.Apply(tmp12, []any{tmp13}) - return tmp14 - } - }) - v7 = tmp6 - _ = v7 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_UnsignedShiftRight}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unsigned_DASH_bit_DASH_shift_DASH_right.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_n)), kw_inline, tmp1, kw_doc, "Bitwise shift right, without sign-extension.", kw_file, "glojure/core.glj", kw_added, "1.6", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(30), kw_column, int(7), kw_line, int(1373), kw_end_DASH_line, int(1373))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "UnsignedShiftRight") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("UnsignedShiftRight is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unsigned_DASH_bit_DASH_shift_DASH_right = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unsigned_DASH_bit_DASH_shift_DASH_right.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // vec + { + tmp0 := sym_vec.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Creates a new vector containing the contents of coll. Java arrays\n will be aliased and should not be modified.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(366), kw_end_DASH_line, int(366))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp8 := reflect.TypeOf((*lang.IObj)(nil)).Elem() + tmp9 := lang.Apply(tmp7, []any{tmp8, v2}) + if lang.IsTruthy(tmp9) { + tmp10 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp11 := lang.Apply(tmp10, []any{v2, nil}) + tmp6 = tmp11 + } else { + tmp12 := lang.Apply(lang.CreateLazilyPersistentVector, []any{v2}) + tmp6 = tmp12 } - tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7445), kw_column, int(6), kw_end_DASH_line, int(7451), kw_end_DASH_column, int(82)) + tmp3 = tmp6 + } else { + tmp13 := lang.Apply(lang.CreateLazilyPersistentVector, []any{v2}) + tmp3 = tmp13 + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_vec = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_vec.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // vswap! + { + tmp0 := sym_vswap_BANG_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_vol, sym_f, sym__AMP_, sym_args)), kw_doc, "Non-atomically swaps the value of the volatile as if:\n (apply f current-value-of-vol args). Returns the value that\n was swapped in.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(11), kw_line, int(2531), kw_end_DASH_line, int(2531))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var v6 any = lang.NewList(args[4:]...) + _ = v6 + var tmp7 any + { // let + // let binding "v" + tmp8 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp9 := lang.NewMap(kw_tag, sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Volatile) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2537), kw_column, int(26), kw_end_DASH_line, int(2537), kw_end_DASH_column, int(81)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp12 := lang.Apply(tmp8, []any{v4, tmp11}) + var v13 any = tmp12 + _ = v13 + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{sym__DOT_reset}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v13}) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := checkDerefVar(var_glojure_DOT_core_seq) + tmp22 := checkDerefVar(var_glojure_DOT_core_concat) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := lang.Apply(tmp23, []any{v5}) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := checkDerefVar(var_glojure_DOT_core_seq) + tmp27 := checkDerefVar(var_glojure_DOT_core_concat) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := lang.Apply(tmp28, []any{sym__DOT_Deref}) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := lang.Apply(tmp30, []any{v13}) + tmp32 := lang.Apply(tmp27, []any{tmp29, tmp31}) + tmp33 := lang.Apply(tmp26, []any{tmp32}) + tmp34 := lang.Apply(tmp25, []any{tmp33}) + tmp35 := lang.Apply(tmp22, []any{tmp24, tmp34, v6}) + tmp36 := lang.Apply(tmp21, []any{tmp35}) + tmp37 := lang.Apply(tmp20, []any{tmp36}) + tmp38 := lang.Apply(tmp15, []any{tmp17, tmp19, tmp37}) + tmp39 := lang.Apply(tmp14, []any{tmp38}) + tmp7 = tmp39 + } // end let + return tmp7 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_vswap_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_vswap_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // zero? + { + var tmp1 lang.FnFunc + { // function zero?__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_IsZero}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_zero_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_num)), kw_inline, tmp1, kw_doc, "Returns true if num is zero, else false", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(860), kw_end_DASH_line, int(860))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "IsZero") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("IsZero is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_zero_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_zero_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // zipmap + { + tmp0 := sym_zipmap.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_keys, sym_vals)), kw_doc, "Returns a map with the keys mapped to the corresponding vals.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(6583), kw_end_DASH_line, int(6583))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "map" + tmp5 := checkDerefVar(var_glojure_DOT_core_transient) + tmp6 := lang.NewMap() + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6588), kw_column, int(27), kw_end_DASH_line, int(6588), kw_end_DASH_column, int(28)) tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) if err != nil { panic(err) } - return tmp8 + tmp9 := lang.Apply(tmp5, []any{tmp8}) + var v10 any = tmp9 + _ = v10 + // let binding "ks" + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := lang.Apply(tmp11, []any{v2}) + var v13 any = tmp12 + _ = v13 + // let binding "vs" + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := lang.Apply(tmp14, []any{v3}) + var v16 any = tmp15 + _ = v16 + for { + var tmp17 any + var tmp18 any + { // let + // let binding "and__0__auto__" + var v19 any = v13 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + tmp20 = v16 + } else { + tmp20 = v19 + } + tmp18 = tmp20 + } // end let + if lang.IsTruthy(tmp18) { + tmp20 := checkDerefVar(var_glojure_DOT_core_assoc_BANG_) + tmp21 := checkDerefVar(var_glojure_DOT_core_first) + tmp22 := lang.Apply(tmp21, []any{v13}) + tmp23 := checkDerefVar(var_glojure_DOT_core_first) + tmp24 := lang.Apply(tmp23, []any{v16}) + tmp25 := lang.Apply(tmp20, []any{v10, tmp22, tmp24}) + var tmp19 any = tmp25 + tmp27 := checkDerefVar(var_glojure_DOT_core_next) + tmp28 := lang.Apply(tmp27, []any{v13}) + var tmp26 any = tmp28 + tmp30 := checkDerefVar(var_glojure_DOT_core_next) + tmp31 := lang.Apply(tmp30, []any{v16}) + var tmp29 any = tmp31 + v10 = tmp19 + v13 = tmp26 + v16 = tmp29 + continue + } else { + tmp32 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp33 := lang.Apply(tmp32, []any{v10}) + tmp17 = tmp33 + } + tmp4 = tmp17 + break + } + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_zipmap = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_zipmap.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // NaN? + { + var tmp1 lang.FnFunc + { // function NaN?__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym_math_DOT_IsNaN}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{v3}) + tmp10 := lang.Apply(tmp5, []any{tmp7, tmp9}) + tmp11 := lang.Apply(tmp4, []any{tmp10}) + return tmp11 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_NaN_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_num)), kw_inline, tmp1, kw_doc, "Returns true if num is NaN, else false", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1)})), kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(7968), kw_end_DASH_line, int(7968))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(math7.IsNaN, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_NaN_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_NaN_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // StackTraceElement->vec + { + tmp0 := sym_StackTraceElement_DASH__GT_vec.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_o)), kw_doc, "Constructs a data representation for a StackTraceElement: [class method file line]", kw_file, "glojure/core_print.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(28), kw_column, int(7), kw_line, int(436), kw_end_DASH_line, int(436))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_symbol) + tmp4, ok := lang.FieldOrMethod(v2, "getClassName") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getClassName"))) + } + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { + case reflect.Func: + tmp5 = lang.Apply(tmp4, nil) + default: + tmp5 = tmp4 + } + tmp6 := lang.Apply(tmp3, []any{tmp5}) + tmp7 := checkDerefVar(var_glojure_DOT_core_symbol) + tmp8, ok := lang.FieldOrMethod(v2, "getMethodName") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getMethodName"))) + } + var tmp9 any + switch reflect.TypeOf(tmp8).Kind() { + case reflect.Func: + tmp9 = lang.Apply(tmp8, nil) + default: + tmp9 = tmp8 + } + tmp10 := lang.Apply(tmp7, []any{tmp9}) + tmp11, ok := lang.FieldOrMethod(v2, "getFileName") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getFileName"))) + } + var tmp12 any + switch reflect.TypeOf(tmp11).Kind() { + case reflect.Func: + tmp12 = lang.Apply(tmp11, nil) + default: + tmp12 = tmp11 + } + tmp13, ok := lang.FieldOrMethod(v2, "getLineNumber") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getLineNumber"))) + } + var tmp14 any + switch reflect.TypeOf(tmp13).Kind() { + case reflect.Func: + tmp14 = lang.Apply(tmp13, nil) + default: + tmp14 = tmp13 + } + tmp15 := lang.NewVector(tmp6, tmp10, tmp12, tmp14) + tmp16 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(440), kw_column, int(3), kw_end_DASH_line, int(440), kw_end_DASH_column, int(94)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp17 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_StackTraceElement_DASH__GT_vec = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_StackTraceElement_DASH__GT_vec.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // -> + { + tmp0 := sym__DASH__GT_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_x, sym__AMP_, sym_forms)), kw_doc, "Threads the expr through the forms. Inserts x as the\n second item in the first form, making a list of it if it is not a\n list already. If there are more forms, inserts the first form as the\n second item in second form, etc.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(11), kw_line, int(1675), kw_end_DASH_line, int(1675))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { default: checkArity(args, 3) - v3 := args[0] + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + v4 := args[2] _ = v4 - v5 := args[2] + var v5 any = lang.NewList(args[3:]...) _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any + var tmp6 any { // let - // let binding "ps" - tmp8 := checkDerefVar(var_glojure_DOT_core_list_STAR_) - tmp9 := lang.Apply(tmp8, []any{v3, v4, v5, v6}) - var v10 any = tmp9 - _ = v10 - var tmp11 lang.FnFunc - { // function epn - var v12 lang.FnFunc - tmp11 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - return true - case 1: - v13 := args[0] - _ = v13 - tmp14 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) - var tmp15 lang.FnFunc - tmp15 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v16 := args[0] - _ = v16 - tmp17 := lang.Apply(v16, []any{v13}) - return tmp17 - }) - tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7456), kw_column, int(23), kw_end_DASH_line, int(7456), kw_end_DASH_column, int(28)) - tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp18 := lang.Apply(tmp14, []any{tmp17, v10}) - return tmp18 - case 2: - v13 := args[0] - _ = v13 - v14 := args[1] - _ = v14 - tmp15 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) - var tmp16 lang.FnFunc - tmp16 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v17 := args[0] - _ = v17 - var tmp18 any - { // let - // let binding "and__0__auto__" - tmp19 := lang.Apply(v17, []any{v13}) - var v20 any = tmp19 - _ = v20 - var tmp21 any - if lang.IsTruthy(v20) { - tmp22 := lang.Apply(v17, []any{v14}) - tmp21 = tmp22 - } else { - tmp21 = v20 - } - tmp18 = tmp21 - } // end let - return tmp18 - }) - tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7457), kw_column, int(25), kw_end_DASH_line, int(7457), kw_end_DASH_column, int(42)) - tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp19 := lang.Apply(tmp15, []any{tmp18, v10}) - return tmp19 - case 3: - v13 := args[0] + // let binding "x" + var v7 any = v4 + _ = v7 + // let binding "forms" + var v8 any = v5 + _ = v8 + for { + var tmp9 any + if lang.IsTruthy(v8) { + var tmp10 any + { // let + // let binding "form" + tmp11 := checkDerefVar(var_glojure_DOT_core_first) + tmp12 := lang.Apply(tmp11, []any{v8}) + var v13 any = tmp12 _ = v13 - v14 := args[1] - _ = v14 - v15 := args[2] - _ = v15 - tmp16 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) - var tmp17 lang.FnFunc - tmp17 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v18 := args[0] - _ = v18 - var tmp19 any - { // let - // let binding "and__0__auto__" - tmp20 := lang.Apply(v18, []any{v13}) - var v21 any = tmp20 - _ = v21 - var tmp22 any - if lang.IsTruthy(v21) { - var tmp23 any - { // let - // let binding "and__0__auto__" - tmp24 := lang.Apply(v18, []any{v14}) - var v25 any = tmp24 - _ = v25 - var tmp26 any - if lang.IsTruthy(v25) { - tmp27 := lang.Apply(v18, []any{v15}) - tmp26 = tmp27 - } else { - tmp26 = v25 - } - tmp23 = tmp26 - } // end let - tmp22 = tmp23 - } else { - tmp22 = v21 - } - tmp19 = tmp22 - } // end let - return tmp19 - }) - tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7458), kw_column, int(27), kw_end_DASH_line, int(7458), kw_end_DASH_column, int(50)) - tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) - if err != nil { - panic(err) + // let binding "threaded" + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp16 := lang.Apply(tmp15, []any{v13}) + if lang.IsTruthy(tmp16) { + tmp17 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := checkDerefVar(var_glojure_DOT_core_first) + tmp22 := lang.Apply(tmp21, []any{v13}) + tmp23 := lang.Apply(tmp20, []any{tmp22}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v7}) + tmp26 := checkDerefVar(var_glojure_DOT_core_next) + tmp27 := lang.Apply(tmp26, []any{v13}) + tmp28 := lang.Apply(tmp19, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp18, []any{tmp28}) + tmp30 := checkDerefVar(var_glojure_DOT_core_meta) + tmp31 := lang.Apply(tmp30, []any{v13}) + tmp32 := lang.Apply(tmp17, []any{tmp29, tmp31}) + tmp14 = tmp32 + } else { + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{v13, v7}) + tmp14 = tmp34 } - tmp20 := lang.Apply(tmp16, []any{tmp19, v10}) - return tmp20 - default: - checkArity(args, 3) - v13 := args[0] - _ = v13 - v14 := args[1] - _ = v14 - v15 := args[2] - _ = v15 - var v16 any = lang.NewList(args[3:]...) - _ = v16 - tmp17 := checkDerefVar(var_glojure_DOT_core_boolean) - var tmp18 any - { // let - // let binding "and__0__auto__" - tmp19 := lang.Apply(v12, []any{v13, v14, v15}) - var v20 any = tmp19 - _ = v20 - var tmp21 any - if lang.IsTruthy(v20) { - tmp22 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) - var tmp23 lang.FnFunc - tmp23 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v24 := args[0] - _ = v24 - tmp25 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) - tmp26 := lang.Apply(tmp25, []any{v24, v16}) - return tmp26 - }) - tmp24 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7460), kw_column, int(48), kw_end_DASH_line, int(7460), kw_end_DASH_column, int(63)) - tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp26 := lang.Apply(tmp22, []any{tmp25, v10}) - tmp21 = tmp26 - } else { - tmp21 = v20 - } - tmp18 = tmp21 - } // end let - tmp19 := lang.Apply(tmp17, []any{tmp18}) - return tmp19 - } - }) - v12 = tmp11 - _ = v12 - } - tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7454), kw_column, int(8), kw_end_DASH_line, int(7460), kw_end_DASH_column, int(71)) - tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) - if err != nil { - panic(err) + var v35 any = tmp14 + _ = v35 + var tmp36 any = v35 + tmp38 := checkDerefVar(var_glojure_DOT_core_next) + tmp39 := lang.Apply(tmp38, []any{v8}) + var tmp37 any = tmp39 + v7 = tmp36 + v8 = tmp37 + continue + } // end let + tmp9 = tmp10 + } else { + tmp9 = v7 + } + tmp6 = tmp9 + break } - tmp7 = tmp13 } // end let - return tmp7 + return tmp6 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__DASH__GT_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core__DASH__GT_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // every? + // ->> { - tmp1 := reflect.TypeOf(false) - tmp0 := sym_every_QMARK_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns true if (pred x) is logical true for every x in coll, else\n false.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(2664), kw_end_DASH_line, int(2664))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - recur_loop_480: - var tmp6 any - tmp7 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) - tmp8 := checkDerefVar(var_glojure_DOT_core_seq) - tmp9 := lang.Apply(tmp8, []any{v5}) - tmp10 := lang.Apply(tmp7, []any{tmp9}) - if lang.IsTruthy(tmp10) { - tmp6 = true - } else { - var tmp11 any - tmp12 := checkDerefVar(var_glojure_DOT_core_first) - tmp13 := lang.Apply(tmp12, []any{v5}) - tmp14 := lang.Apply(v4, []any{tmp13}) - if lang.IsTruthy(tmp14) { - var tmp15 any = v4 - tmp17 := checkDerefVar(var_glojure_DOT_core_next) - tmp18 := lang.Apply(tmp17, []any{v5}) - var tmp16 any = tmp18 - v4 = tmp15 - v5 = tmp16 - goto recur_loop_480 - } else { - var tmp19 any - if lang.IsTruthy(kw_else) { - tmp19 = false - } else { + tmp0 := sym__DASH__GT__GT_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_x, sym__AMP_, sym_forms)), kw_doc, "Threads the expr through the forms. Inserts x as the\n last item in the first form, making a list of it if it is not a\n list already. If there are more forms, inserts the first form as the\n last item in second form, etc.", kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(11), kw_line, int(1691), kw_end_DASH_line, int(1691))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "x" + var v7 any = v4 + _ = v7 + // let binding "forms" + var v8 any = v5 + _ = v8 + for { + var tmp9 any + if lang.IsTruthy(v8) { + var tmp10 any + { // let + // let binding "form" + tmp11 := checkDerefVar(var_glojure_DOT_core_first) + tmp12 := lang.Apply(tmp11, []any{v8}) + var v13 any = tmp12 + _ = v13 + // let binding "threaded" + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp16 := lang.Apply(tmp15, []any{v13}) + if lang.IsTruthy(tmp16) { + tmp17 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := checkDerefVar(var_glojure_DOT_core_first) + tmp22 := lang.Apply(tmp21, []any{v13}) + tmp23 := lang.Apply(tmp20, []any{tmp22}) + tmp24 := checkDerefVar(var_glojure_DOT_core_next) + tmp25 := lang.Apply(tmp24, []any{v13}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v7}) + tmp28 := lang.Apply(tmp19, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp18, []any{tmp28}) + tmp30 := checkDerefVar(var_glojure_DOT_core_meta) + tmp31 := lang.Apply(tmp30, []any{v13}) + tmp32 := lang.Apply(tmp17, []any{tmp29, tmp31}) + tmp14 = tmp32 + } else { + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{v13, v7}) + tmp14 = tmp34 + } + var v35 any = tmp14 + _ = v35 + var tmp36 any = v35 + tmp38 := checkDerefVar(var_glojure_DOT_core_next) + tmp39 := lang.Apply(tmp38, []any{v8}) + var tmp37 any = tmp39 + v7 = tmp36 + v8 = tmp37 + continue + } // end let + tmp9 = tmp10 + } else { + tmp9 = v7 + } + tmp6 = tmp9 + break } - tmp11 = tmp19 - } - tmp6 = tmp11 + } // end let + return tmp6 } - return tmp6 }) - tmp4 := reflect.TypeOf(false) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__DASH__GT__GT_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core__DASH__GT__GT_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // ex-cause + // .. { - tmp0 := sym_ex_DASH_cause.WithMeta(lang.NewMap(kw_tag, nil, kw_arglists, lang.NewList(lang.NewVector(sym_ex)), kw_doc, "Returns the cause of ex if ex is a Throwable.\n Otherwise returns nil.", kw_file, "glojure/core.glj", kw_added, "1.10", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(4828), kw_end_DASH_line, int(4828))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp6 := lang.Apply(tmp5, []any{lang.Throwable, v3}) - if lang.IsTruthy(tmp6) { - tmp7, ok := lang.FieldOrMethod(v3, "getCause") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getCause"))) - } - var tmp8 any - switch reflect.TypeOf(tmp7).Kind() { - case reflect.Func: - tmp8 = lang.Apply(tmp7, nil) - default: - tmp8 = tmp7 - } - tmp4 = tmp8 - } else { + tmp0 := sym__DOT__DOT_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_form), lang.NewVector(sym_x, sym_form, sym__AMP_, sym_more)), kw_doc, "form => fieldName-symbol or (instanceMethodName-symbol args*)\n\n Expands into a member access (.) of the first member on the first\n argument, followed by the next member on the result, etc. For\n instance:\n\n (.. System (getProperties) (get \"os.name\"))\n\n expands to:\n\n (. (. System (getProperties)) (get \"os.name\"))\n\n but is easier to write, read, and understand.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(11), kw_line, int(1657), kw_end_DASH_line, int(1657))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym__DOT_}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{v4}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v5}) + tmp14 := lang.Apply(tmp7, []any{tmp9, tmp11, tmp13}) + tmp15 := lang.Apply(tmp6, []any{tmp14}) + return tmp15 + default: + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var v6 any = lang.NewList(args[4:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym__DOT_}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v4}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v5}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp22, v6}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + return tmp24 } - return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__DOT__DOT_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core__DOT__DOT_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // ex-data + // = { - tmp0 := sym_ex_DASH_data.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ex)), kw_doc, "Returns exception data (a map) if ex is an IExceptionInfo.\n Otherwise returns nil.", kw_file, "glojure/core.glj", kw_added, "1.4", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4812), kw_end_DASH_line, int(4812))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp6 := lang.Apply(tmp5, []any{nil, v3}) - if lang.IsTruthy(tmp6) { - tmp7, ok := lang.FieldOrMethod(v3, "getData") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getData"))) - } - var tmp8 any - switch reflect.TypeOf(tmp7).Kind() { - case reflect.Func: - tmp8 = lang.Apply(tmp7, nil) - default: - tmp8 = tmp7 - } - tmp4 = tmp8 - } else { - } - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var tmp1 lang.FnFunc + { // function =__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_lang_DOT_Util}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_glojure_DOT_core_SLASH_equiv}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{v3}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v4}) + tmp17 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp12, tmp14, tmp16}) + tmp18 := lang.Apply(tmp5, []any{tmp17}) + return tmp18 + }) + v2 = tmp1 + _ = v2 } - } - // ex-info - { - tmp0 := sym_ex_DASH_info.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_msg, sym_map), lang.NewVector(sym_msg, sym_map, sym_cause)), kw_doc, "Create an instance of ExceptionInfo, a RuntimeException subclass\n that carries a map of additional data.", kw_file, "glojure/core.glj", kw_added, "1.4", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4803), kw_end_DASH_line, int(4803))).(*lang.Symbol) + tmp0 := sym__EQ_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Equality. Returns true if x equals y, false if not. Same as\n Java x.equals(y) except it also works for nil, and compares\n numbers and collections in a type-independent manner. Clojure's immutable data\n structures define equals() (and thus =) as a value, not an identity,\n comparison.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(7), kw_line, int(776), kw_end_DASH_line, int(776))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { + case 1: + v3 := args[0] + _ = v3 + return true case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_elide_DASH_top_DASH_frames) - tmp6 := lang.Apply(nil, []any{v3, v4}) - tmp7 := lang.Apply(tmp5, []any{tmp6, "glojure.core$ex_info"}) - return tmp7 - case 3: + tmp5 := lang.Apply(lang.Equiv, []any{v3, v4}) + return tmp5 + default: + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 - v5 := args[2] + var v5 any = lang.NewList(args[2:]...) _ = v5 - tmp6 := checkDerefVar(var_glojure_DOT_core_elide_DASH_top_DASH_frames) - tmp7 := lang.Apply(nil, []any{v3, v4, v5}) - tmp8 := lang.Apply(tmp6, []any{tmp7, "glojure.core$ex_info"}) - return tmp8 - default: - checkArity(args, -1) - panic("unreachable") - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // ex-message - { - tmp0 := sym_ex_DASH_message.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ex)), kw_doc, "Returns the message attached to ex if ex is a Throwable.\n Otherwise returns nil.", kw_file, "glojure/core.glj", kw_added, "1.10", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4820), kw_end_DASH_line, int(4820))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp6 := lang.Apply(tmp5, []any{lang.Throwable, v3}) - if lang.IsTruthy(tmp6) { - tmp7, ok := lang.FieldOrMethod(v3, "getMessage") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getMessage"))) - } - var tmp8 any - switch reflect.TypeOf(tmp7).Kind() { - case reflect.Func: - tmp8 = lang.Apply(tmp7, nil) - default: - tmp8 = tmp7 + recur_loop_126: + var tmp6 any + tmp7 := lang.Apply(lang.Equiv, []any{v3, v4}) + if lang.IsTruthy(tmp7) { + var tmp8 any + tmp9 := checkDerefVar(var_glojure_DOT_core_next) + tmp10 := lang.Apply(tmp9, []any{v5}) + if lang.IsTruthy(tmp10) { + var tmp11 any = v4 + tmp13 := checkDerefVar(var_glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v5}) + var tmp12 any = tmp14 + tmp16 := checkDerefVar(var_glojure_DOT_core_next) + tmp17 := lang.Apply(tmp16, []any{v5}) + var tmp15 any = tmp17 + v3 = tmp11 + v4 = tmp12 + v5 = tmp15 + goto recur_loop_126 + } else { + tmp18 := checkDerefVar(var_glojure_DOT_core_first) + tmp19 := lang.Apply(tmp18, []any{v5}) + tmp20 := lang.Apply(lang.Equiv, []any{v4, tmp19}) + tmp8 = tmp20 + } + tmp6 = tmp8 + } else { + tmp6 = false } - tmp4 = tmp8 - } else { + return tmp6 } - return tmp4 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core__EQ_ = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core__EQ_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // extend + // == { - tmp0 := sym_extend.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_atype, sym__AMP_, sym_proto_PLUS_mmaps)), kw_doc, "Implementations of protocol methods can be provided using the extend construct:\n\n (extend AType\n AProtocol\n {:foo an-existing-fn\n :bar (fn [a b] ...)\n :baz (fn ([a]...) ([a b] ...)...)}\n BProtocol \n {...} \n ...)\n \n extend takes a type/class (or interface, see below), and one or more\n protocol + method map pairs. It will extend the polymorphism of the\n protocol's methods to call the supplied methods when an AType is\n provided as the first argument. \n\n Method maps are maps of the keyword-ized method names to ordinary\n fns. This facilitates easy reuse of existing fns and fn maps, for\n code reuse/mixins without derivation or composition. You can extend\n an interface to a protocol. This is primarily to facilitate interop\n with the host (e.g. Java) but opens the door to incidental multiple\n inheritance of implementation since a class can inherit from more\n than one interface, both of which extend the protocol. It is TBD how\n to specify which impl to use. You can extend a protocol on nil.\n\n If you are supplying the definitions explicitly (i.e. not reusing\n exsting functions or mixin maps), you may find it more convenient to\n use the extend-type or extend-protocol macros.\n\n Note that multiple independent extend clauses can exist for the same\n type, not all protocols need be defined in a single extend call.\n\n See also:\n extends?, satisfies?, extenders", kw_file, "glojure/core_deftype.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(116), kw_end_DASH_line, int(116))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 1) + var tmp1 lang.FnFunc + { // function ==__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) v3 := args[0] _ = v3 - var v4 any = lang.NewList(args[1:]...) + v4 := args[1] _ = v4 - var tmp5 any - { // let - // let binding "seq_262" - tmp6 := checkDerefVar(var_glojure_DOT_core_seq) - tmp7 := checkDerefVar(var_glojure_DOT_core_partition) - tmp8 := lang.Apply(tmp7, []any{int64(2), v4}) - tmp9 := lang.Apply(tmp6, []any{tmp8}) - var v10 any = tmp9 - _ = v10 - // let binding "chunk_263" - var v11 any = nil - _ = v11 - // let binding "count_264" - var v12 any = int64(0) - _ = v12 - // let binding "i_265" - var v13 any = int64(0) - _ = v13 - for { - var tmp14 any - tmp15 := checkDerefVar(var_glojure_DOT_core__LT_) - tmp16 := lang.Apply(tmp15, []any{v13, v12}) - if lang.IsTruthy(tmp16) { - var tmp17 any - { // let - // let binding "vec__266" - tmp18, _ := lang.FieldOrMethod(v11, "nth") - if reflect.TypeOf(tmp18).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) - } - tmp19 := lang.Apply(tmp18, []any{v13}) - var v20 any = tmp19 - _ = v20 - // let binding "proto" - tmp21 := checkDerefVar(var_glojure_DOT_core_nth) - tmp22 := lang.Apply(tmp21, []any{v20, int64(0), nil}) - var v23 any = tmp22 - _ = v23 - // let binding "mmap" - tmp24 := checkDerefVar(var_glojure_DOT_core_nth) - tmp25 := lang.Apply(tmp24, []any{v20, int64(1), nil}) - var v26 any = tmp25 - _ = v26 - var tmp27 any - tmp28 := checkDerefVar(var_glojure_DOT_core_protocol_QMARK_) - tmp29 := lang.Apply(tmp28, []any{v23}) - if lang.IsTruthy(tmp29) { - } else { - tmp30 := checkDerefVar(var_glojure_DOT_core_str) - tmp31 := lang.Apply(tmp30, []any{v23, " is not a protocol"}) - tmp32 := lang.Apply(errors8.New, []any{tmp31}) - panic(tmp32) - } - _ = tmp27 - tmp33 := checkDerefVar(var_glojure_DOT_core_reduce1) - var tmp34 lang.FnFunc - tmp34 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v35 := args[0] - _ = v35 - v36 := args[1] - _ = v36 - var tmp37 any - { // let - // let binding "vec__270" - var v38 any = v36 - _ = v38 - // let binding "k" - tmp39 := checkDerefVar(var_glojure_DOT_core_nth) - tmp40 := lang.Apply(tmp39, []any{v38, int64(0), nil}) - var v41 any = tmp40 - _ = v41 - // let binding "v" - tmp42 := checkDerefVar(var_glojure_DOT_core_nth) - tmp43 := lang.Apply(tmp42, []any{v38, int64(1), nil}) - var v44 any = tmp43 - _ = v44 - tmp45 := checkDerefVar(var_glojure_DOT_core_get_DASH_in) - tmp46 := checkDerefVar(var_glojure_DOT_core_deref) - tmp47 := lang.Apply(tmp46, []any{v23}) - tmp48 := lang.NewVector(kw_multis, v41) - tmp49 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(158), kw_column, int(33), kw_end_DASH_line, int(158), kw_end_DASH_column, int(43)) - tmp50, err := lang.WithMeta(tmp48, tmp49.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp51 := lang.Apply(tmp45, []any{tmp47, tmp50}) - var tmp52 lang.FnFunc - tmp52 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 1) - v53 := args[0] - _ = v53 - var v54 any = lang.NewList(args[1:]...) - _ = v54 - tmp55 := checkDerefVar(var_glojure_DOT_core_apply) - tmp56 := checkDerefVar(var_glojure_DOT_core_cons) - tmp57 := lang.Apply(tmp56, []any{v53, v54}) - tmp58 := lang.Apply(tmp55, []any{v44, tmp57}) - return tmp58 - } - }) - tmp53, _ := lang.FieldOrMethod(tmp51, "AddMethod") - if reflect.TypeOf(tmp53).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("AddMethod is not a function"))) - } - tmp54 := lang.Apply(tmp53, []any{v3, tmp52}) - tmp37 = tmp54 - } // end let - return tmp37 - }) - tmp35 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(156), kw_column, int(14), kw_end_DASH_line, int(160), kw_end_DASH_column, int(45)) - tmp36, err := lang.WithMeta(tmp34, tmp35.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp37 := lang.Apply(tmp33, []any{tmp36, nil, v26}) - _ = tmp37 - var tmp38 any = v10 - var tmp39 any = v11 - var tmp40 any = v12 - tmp42 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) - tmp43 := lang.Apply(tmp42, []any{v13}) - var tmp41 any = tmp43 - v10 = tmp38 - v11 = tmp39 - v12 = tmp40 - v13 = tmp41 - continue - } // end let - tmp14 = tmp17 - } else { - var tmp18 any - { // let - // let binding "temp__0__auto__" - tmp19 := checkDerefVar(var_glojure_DOT_core_seq) - tmp20 := lang.Apply(tmp19, []any{v10}) - var v21 any = tmp20 - _ = v21 - var tmp22 any - if lang.IsTruthy(v21) { - var tmp23 any - { // let - // let binding "seq_262" - var v24 any = v21 - _ = v24 - var tmp25 any - tmp26 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) - tmp27 := lang.Apply(tmp26, []any{v24}) - if lang.IsTruthy(tmp27) { - var tmp28 any - { // let - // let binding "c__0__auto__" - tmp29 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) - tmp30 := lang.Apply(tmp29, []any{v24}) - var v31 any = tmp30 - _ = v31 - tmp33 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) - tmp34 := lang.Apply(tmp33, []any{v24}) - var tmp32 any = tmp34 - var tmp35 any = v31 - tmp37 := checkDerefVar(var_glojure_DOT_core_int) - tmp38 := checkDerefVar(var_glojure_DOT_core_count) - tmp39 := lang.Apply(tmp38, []any{v31}) - tmp40 := lang.Apply(tmp37, []any{tmp39}) - var tmp36 any = tmp40 - tmp42 := checkDerefVar(var_glojure_DOT_core_int) - tmp43 := lang.Apply(tmp42, []any{int64(0)}) - var tmp41 any = tmp43 - v10 = tmp32 - v11 = tmp35 - v12 = tmp36 - v13 = tmp41 - continue - } // end let - tmp25 = tmp28 - } else { - var tmp29 any - { // let - // let binding "vec__273" - tmp30 := checkDerefVar(var_glojure_DOT_core_first) - tmp31 := lang.Apply(tmp30, []any{v24}) - var v32 any = tmp31 - _ = v32 - // let binding "proto" - tmp33 := checkDerefVar(var_glojure_DOT_core_nth) - tmp34 := lang.Apply(tmp33, []any{v32, int64(0), nil}) - var v35 any = tmp34 - _ = v35 - // let binding "mmap" - tmp36 := checkDerefVar(var_glojure_DOT_core_nth) - tmp37 := lang.Apply(tmp36, []any{v32, int64(1), nil}) - var v38 any = tmp37 - _ = v38 - var tmp39 any - tmp40 := checkDerefVar(var_glojure_DOT_core_protocol_QMARK_) - tmp41 := lang.Apply(tmp40, []any{v35}) - if lang.IsTruthy(tmp41) { - } else { - tmp42 := checkDerefVar(var_glojure_DOT_core_str) - tmp43 := lang.Apply(tmp42, []any{v35, " is not a protocol"}) - tmp44 := lang.Apply(errors8.New, []any{tmp43}) - panic(tmp44) - } - _ = tmp39 - tmp45 := checkDerefVar(var_glojure_DOT_core_reduce1) - var tmp46 lang.FnFunc - tmp46 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v47 := args[0] - _ = v47 - v48 := args[1] - _ = v48 - var tmp49 any - { // let - // let binding "vec__277" - var v50 any = v48 - _ = v50 - // let binding "k" - tmp51 := checkDerefVar(var_glojure_DOT_core_nth) - tmp52 := lang.Apply(tmp51, []any{v50, int64(0), nil}) - var v53 any = tmp52 - _ = v53 - // let binding "v" - tmp54 := checkDerefVar(var_glojure_DOT_core_nth) - tmp55 := lang.Apply(tmp54, []any{v50, int64(1), nil}) - var v56 any = tmp55 - _ = v56 - tmp57 := checkDerefVar(var_glojure_DOT_core_get_DASH_in) - tmp58 := checkDerefVar(var_glojure_DOT_core_deref) - tmp59 := lang.Apply(tmp58, []any{v35}) - tmp60 := lang.NewVector(kw_multis, v53) - tmp61 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(158), kw_column, int(33), kw_end_DASH_line, int(158), kw_end_DASH_column, int(43)) - tmp62, err := lang.WithMeta(tmp60, tmp61.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp63 := lang.Apply(tmp57, []any{tmp59, tmp62}) - var tmp64 lang.FnFunc - tmp64 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 1) - v65 := args[0] - _ = v65 - var v66 any = lang.NewList(args[1:]...) - _ = v66 - tmp67 := checkDerefVar(var_glojure_DOT_core_apply) - tmp68 := checkDerefVar(var_glojure_DOT_core_cons) - tmp69 := lang.Apply(tmp68, []any{v65, v66}) - tmp70 := lang.Apply(tmp67, []any{v56, tmp69}) - return tmp70 - } - }) - tmp65, _ := lang.FieldOrMethod(tmp63, "AddMethod") - if reflect.TypeOf(tmp65).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("AddMethod is not a function"))) - } - tmp66 := lang.Apply(tmp65, []any{v3, tmp64}) - tmp49 = tmp66 - } // end let - return tmp49 - }) - tmp47 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(156), kw_column, int(14), kw_end_DASH_line, int(160), kw_end_DASH_column, int(45)) - tmp48, err := lang.WithMeta(tmp46, tmp47.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp49 := lang.Apply(tmp45, []any{tmp48, nil, v38}) - _ = tmp49 - tmp51 := checkDerefVar(var_glojure_DOT_core_next) - tmp52 := lang.Apply(tmp51, []any{v24}) - var tmp50 any = tmp52 - var tmp53 any = nil - var tmp54 any = int64(0) - var tmp55 any = int64(0) - v10 = tmp50 - v11 = tmp53 - v12 = tmp54 - v13 = tmp55 - continue - } // end let - tmp25 = tmp29 - } - tmp23 = tmp25 - } // end let - tmp22 = tmp23 - } else { - } - tmp18 = tmp22 - } // end let - tmp14 = tmp18 - } - tmp5 = tmp14 - break - } - } // end let - return tmp5 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Equiv}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 } - } - // extend-protocol - { - tmp0 := sym_extend_DASH_protocol.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_p, sym__AMP_, sym_specs)), kw_doc, "Useful when you want to provide several implementations of the same\n protocol all at once. Takes a single protocol and the implementation\n of that protocol for one or more types.\n\n (extend-protocol Protocol\n AType\n (foo [x] ...)\n (bar [x y] ...)\n BType\n (foo [x] ...)\n (bar [x y] ...)\n AClass\n (foo [x] ...)\n (bar [x y] ...)\n nil\n (foo [x] ...)\n (bar [x y] ...))\n\n expands into:\n\n (do\n (clojure.core/extend-type AType Protocol \n (foo [x] ...) \n (bar [x y] ...))\n (clojure.core/extend-type BType Protocol \n (foo [x] ...) \n (bar [x y] ...))\n (clojure.core/extend-type AClass Protocol \n (foo [x] ...) \n (bar [x y] ...))\n (clojure.core/extend-type nil Protocol \n (foo [x] ...) \n (bar [x y] ...)))", kw_file, "glojure/core_deftype.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(25), kw_column, int(11), kw_line, int(212), kw_end_DASH_line, int(212))).(*lang.Symbol) + tmp0 := sym__EQ__EQ_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns non-nil if nums all have the equivalent\n value (type-independent), otherwise false", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(7), kw_line, int(1093), kw_end_DASH_line, int(1093))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { + case 1: + v3 := args[0] + _ = v3 + return true + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Equiv") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Equiv is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 default: - checkArity(args, 3) + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 - v5 := args[2] + var v5 any = lang.NewList(args[2:]...) _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - tmp7 := checkDerefVar(var_glojure_DOT_core_emit_DASH_extend_DASH_protocol) - tmp8 := lang.Apply(tmp7, []any{v5, v6}) - return tmp8 + recur_loop_206: + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__EQ__EQ_) + tmp8 := lang.Apply(tmp7, []any{v3, v4}) + if lang.IsTruthy(tmp8) { + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_next) + tmp11 := lang.Apply(tmp10, []any{v5}) + if lang.IsTruthy(tmp11) { + var tmp12 any = v4 + tmp14 := checkDerefVar(var_glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v5}) + var tmp13 any = tmp15 + tmp17 := checkDerefVar(var_glojure_DOT_core_next) + tmp18 := lang.Apply(tmp17, []any{v5}) + var tmp16 any = tmp18 + v3 = tmp12 + v4 = tmp13 + v5 = tmp16 + goto recur_loop_206 + } else { + tmp19 := checkDerefVar(var_glojure_DOT_core__EQ__EQ_) + tmp20 := checkDerefVar(var_glojure_DOT_core_first) + tmp21 := lang.Apply(tmp20, []any{v5}) + tmp22 := lang.Apply(tmp19, []any{v4, tmp21}) + tmp9 = tmp22 + } + tmp6 = tmp9 + } else { + tmp6 = false + } + return tmp6 } }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core__EQ__EQ_ = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core__EQ__EQ_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // extend-type + // > { - tmp0 := sym_extend_DASH_type.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_t, sym__AMP_, sym_specs)), kw_doc, "A macro that expands into an extend call. Useful when you are\n supplying the definitions explicitly inline, extend-type\n automatically creates the maps required by extend. Propagates the\n class as a type hint on the first argument of all fns.\n\n (extend-type MyType \n Countable\n (cnt [c] ...)\n Foo\n (bar [x y] ...)\n (baz ([x] ...) ([x y & zs] ...)))\n\n expands into:\n\n (extend MyType\n Countable\n {:cnt (fn [c] ...)}\n Foo\n {:baz (fn ([x] ...) ([x y & zs] ...))\n :bar (fn [x y] ...)})", kw_file, "glojure/core_deftype.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(11), kw_line, int(180), kw_end_DASH_line, int(180))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function >__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Gt}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym__GT_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns non-nil if nums are in monotonically decreasing order,\n otherwise false.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(7), kw_line, int(1063), kw_end_DASH_line, int(1063))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { + case 1: + v3 := args[0] + _ = v3 + return true + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 default: - checkArity(args, 3) + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 - v5 := args[2] + var v5 any = lang.NewList(args[2:]...) _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - tmp7 := checkDerefVar(var_glojure_DOT_core_emit_DASH_extend_DASH_type) - tmp8 := lang.Apply(tmp7, []any{v5, v6}) - return tmp8 + recur_loop_198: + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__GT_) + tmp8 := lang.Apply(tmp7, []any{v3, v4}) + if lang.IsTruthy(tmp8) { + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_next) + tmp11 := lang.Apply(tmp10, []any{v5}) + if lang.IsTruthy(tmp11) { + var tmp12 any = v4 + tmp14 := checkDerefVar(var_glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v5}) + var tmp13 any = tmp15 + tmp17 := checkDerefVar(var_glojure_DOT_core_next) + tmp18 := lang.Apply(tmp17, []any{v5}) + var tmp16 any = tmp18 + v3 = tmp12 + v4 = tmp13 + v5 = tmp16 + goto recur_loop_198 + } else { + tmp19 := checkDerefVar(var_glojure_DOT_core__GT_) + tmp20 := checkDerefVar(var_glojure_DOT_core_first) + tmp21 := lang.Apply(tmp20, []any{v5}) + tmp22 := lang.Apply(tmp19, []any{v4, tmp21}) + tmp9 = tmp22 + } + tmp6 = tmp9 + } else { + tmp6 = false + } + return tmp6 } }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // false? - { - tmp1 := reflect.TypeOf(false) - tmp0 := sym_false_QMARK_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x is the value false, false otherwise.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(504), kw_end_DASH_line, int(504))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5 := lang.Apply(lang.Identical, []any{v4, false}) - return tmp5 - }) - tmp4 := reflect.TypeOf(false) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + var_glojure_DOT_core__GT_ = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core__GT_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // ffirst + // >= { - tmp0 := sym_ffirst.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Same as (first (first x))", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(2), kw_line, int(98), kw_end_DASH_line, int(102))).(*lang.Symbol) - var tmp2 lang.FnFunc - { // function ffirst - var v3 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] + var tmp1 lang.FnFunc + { // function >=__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_first) - tmp6 := checkDerefVar(var_glojure_DOT_core_first) - tmp7 := lang.Apply(tmp6, []any{v4}) - tmp8 := lang.Apply(tmp5, []any{tmp7}) - return tmp8 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(102), kw_column, int(9), kw_end_DASH_line, int(102), kw_end_DASH_column, int(50))).(lang.FnFunc) - v3 = tmp2 - _ = v3 - } - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // file-seq - { - tmp0 := sym_file_DASH_seq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_dir)), kw_doc, "A tree seq on java.io.Files", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(4972), kw_end_DASH_line, int(4972))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_tree_DASH_seq) - var tmp5 lang.FnFunc - tmp5 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v6 := args[0] - _ = v6 - tmp7, _ := lang.FieldOrMethod(v6, "isDirectory") - if reflect.TypeOf(tmp7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("isDirectory is not a function"))) - } - tmp8 := lang.Apply(tmp7, []any{}) - return tmp8 - }) - tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4978), kw_column, int(6), kw_end_DASH_line, int(4978), kw_end_DASH_column, int(47)) - tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var tmp8 lang.FnFunc - tmp8 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v9 := args[0] - _ = v9 - tmp10 := checkDerefVar(var_glojure_DOT_core_seq) - tmp11, _ := lang.FieldOrMethod(v9, "listFiles") - if reflect.TypeOf(tmp11).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("listFiles is not a function"))) - } - tmp12 := lang.Apply(tmp11, []any{}) - tmp13 := lang.Apply(tmp10, []any{tmp12}) - return tmp13 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Gte}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 }) - tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4979), kw_column, int(6), kw_end_DASH_line, int(4979), kw_end_DASH_column, int(51)) - tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp11 := lang.Apply(tmp4, []any{tmp7, tmp10, v3}) - return tmp11 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + v2 = tmp1 + _ = v2 } - } - // filter - { - tmp0 := sym_filter.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred), lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns a lazy sequence of the items in coll for which\n (pred item) returns logical true. pred must be free of side-effects.\n Returns a transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(2785), kw_end_DASH_line, int(2785))).(*lang.Symbol) + tmp0 := sym__GT__EQ_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns non-nil if nums are in monotonically non-increasing order,\n otherwise false.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(7), kw_line, int(1078), kw_end_DASH_line, int(1078))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v5 := args[0] - _ = v5 - var tmp6 lang.FnFunc - tmp6 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp7 := lang.Apply(v5, nil) - return tmp7 - case 1: - v7 := args[0] - _ = v7 - tmp8 := lang.Apply(v5, []any{v7}) - return tmp8 - case 2: - v7 := args[0] - _ = v7 - v8 := args[1] - _ = v8 - var tmp9 any - tmp10 := lang.Apply(v3, []any{v8}) - if lang.IsTruthy(tmp10) { - tmp11 := lang.Apply(v5, []any{v7, v8}) - tmp9 = tmp11 - } else { - tmp9 = v7 - } - return tmp9 - default: - checkArity(args, -1) - panic("unreachable") - } - }) - tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2793), kw_column, int(7), kw_end_DASH_line, int(2799), kw_end_DASH_column, int(22)) - tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp8 - }) - tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2792), kw_column, int(5), kw_end_DASH_line, int(2799), kw_end_DASH_column, int(23)) - tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp6 + return true case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - var tmp5 lang.FnFunc - tmp5 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - var tmp6 any - { // let - // let binding "temp__0__auto__" - tmp7 := checkDerefVar(var_glojure_DOT_core_seq) - tmp8 := lang.Apply(tmp7, []any{v4}) - var v9 any = tmp8 - _ = v9 - var tmp10 any - if lang.IsTruthy(v9) { - var tmp11 any - { // let - // let binding "s" - var v12 any = v9 - _ = v12 - var tmp13 any - tmp14 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) - tmp15 := lang.Apply(tmp14, []any{v12}) - if lang.IsTruthy(tmp15) { - var tmp16 any - { // let - // let binding "c" - tmp17 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) - tmp18 := lang.Apply(tmp17, []any{v12}) - var v19 any = tmp18 - _ = v19 - // let binding "size" - tmp20 := checkDerefVar(var_glojure_DOT_core_count) - tmp21 := lang.Apply(tmp20, []any{v19}) - var v22 any = tmp21 - _ = v22 - // let binding "b" - tmp23 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_buffer) - tmp24 := lang.Apply(tmp23, []any{v22}) - var v25 any = tmp24 - _ = v25 - var tmp26 any - { // let - // let binding "n__0__auto__" - tmp27 := lang.Apply(lang.LongCast, []any{v22}) - var v28 any = tmp27 - _ = v28 - var tmp29 any - { // let - // let binding "i" - var v30 any = int64(0) - _ = v30 - for { - var tmp31 any - tmp32 := checkDerefVar(var_glojure_DOT_core__LT_) - tmp33 := lang.Apply(tmp32, []any{v30, v28}) - if lang.IsTruthy(tmp33) { - var tmp34 any - { // let - // let binding "v" - tmp35, _ := lang.FieldOrMethod(v19, "nth") - if reflect.TypeOf(tmp35).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) - } - tmp36 := lang.Apply(tmp35, []any{v30}) - var v37 any = tmp36 - _ = v37 - var tmp38 any - tmp39 := lang.Apply(v3, []any{v37}) - if lang.IsTruthy(tmp39) { - tmp40 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_append) - tmp41 := lang.Apply(tmp40, []any{v25, v37}) - tmp38 = tmp41 - } else { - } - tmp34 = tmp38 - } // end let - _ = tmp34 - tmp36 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) - tmp37 := lang.Apply(tmp36, []any{v30}) - var tmp35 any = tmp37 - v30 = tmp35 - continue - } else { - } - tmp29 = tmp31 - break - } - } // end let - tmp26 = tmp29 - } // end let - _ = tmp26 - tmp27 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_cons) - tmp28 := checkDerefVar(var_glojure_DOT_core_chunk) - tmp29 := lang.Apply(tmp28, []any{v25}) - tmp30 := checkDerefVar(var_glojure_DOT_core_filter) - tmp31 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) - tmp32 := lang.Apply(tmp31, []any{v12}) - tmp33 := lang.Apply(tmp30, []any{v3, tmp32}) - tmp34 := lang.Apply(tmp27, []any{tmp29, tmp33}) - tmp16 = tmp34 - } // end let - tmp13 = tmp16 - } else { - var tmp17 any - { // let - // let binding "f" - tmp18 := checkDerefVar(var_glojure_DOT_core_first) - tmp19 := lang.Apply(tmp18, []any{v12}) - var v20 any = tmp19 - _ = v20 - // let binding "r" - tmp21 := checkDerefVar(var_glojure_DOT_core_rest) - tmp22 := lang.Apply(tmp21, []any{v12}) - var v23 any = tmp22 - _ = v23 - var tmp24 any - tmp25 := lang.Apply(v3, []any{v20}) - if lang.IsTruthy(tmp25) { - tmp26 := checkDerefVar(var_glojure_DOT_core_cons) - tmp27 := checkDerefVar(var_glojure_DOT_core_filter) - tmp28 := lang.Apply(tmp27, []any{v3, v23}) - tmp29 := lang.Apply(tmp26, []any{v20, tmp28}) - tmp24 = tmp29 - } else { - tmp30 := checkDerefVar(var_glojure_DOT_core_filter) - tmp31 := lang.Apply(tmp30, []any{v3, v23}) - tmp24 = tmp31 - } - tmp17 = tmp24 - } // end let - tmp13 = tmp17 - } - tmp11 = tmp13 - } // end let - tmp10 = tmp11 - } else { - } - tmp6 = tmp10 - } // end let - return tmp6 - }) - tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Gte") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gte is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 default: - checkArity(args, -1) - panic("unreachable") - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // filter-key - { - tmp0 := sym_filter_DASH_key.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_keyfn, sym_pred, sym_amap)), kw_static, true, kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(4115), kw_end_DASH_line, int(4117), kw_private, true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 3) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var tmp6 any - { // let - // let binding "ret" - tmp7 := lang.NewMap() - tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4118), kw_column, int(16), kw_end_DASH_line, int(4118), kw_end_DASH_column, int(17)) - tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v10 any = tmp9 - _ = v10 - // let binding "es" - tmp11 := checkDerefVar(var_glojure_DOT_core_seq) - tmp12 := lang.Apply(tmp11, []any{v5}) - var v13 any = tmp12 - _ = v13 - for { - var tmp14 any - if lang.IsTruthy(v13) { - var tmp15 any - tmp16 := checkDerefVar(var_glojure_DOT_core_first) - tmp17 := lang.Apply(tmp16, []any{v13}) - tmp18 := lang.Apply(v3, []any{tmp17}) - tmp19 := lang.Apply(v4, []any{tmp18}) - if lang.IsTruthy(tmp19) { - tmp21 := checkDerefVar(var_glojure_DOT_core_assoc) - tmp22 := checkDerefVar(var_glojure_DOT_core_key) - tmp23 := checkDerefVar(var_glojure_DOT_core_first) - tmp24 := lang.Apply(tmp23, []any{v13}) - tmp25 := lang.Apply(tmp22, []any{tmp24}) - tmp26 := checkDerefVar(var_glojure_DOT_core_val) - tmp27 := checkDerefVar(var_glojure_DOT_core_first) - tmp28 := lang.Apply(tmp27, []any{v13}) - tmp29 := lang.Apply(tmp26, []any{tmp28}) - tmp30 := lang.Apply(tmp21, []any{v10, tmp25, tmp29}) - var tmp20 any = tmp30 - tmp32 := checkDerefVar(var_glojure_DOT_core_next) - tmp33 := lang.Apply(tmp32, []any{v13}) - var tmp31 any = tmp33 - v10 = tmp20 - v13 = tmp31 - continue - } else { - var tmp34 any = v10 - tmp36 := checkDerefVar(var_glojure_DOT_core_next) - tmp37 := lang.Apply(tmp36, []any{v13}) - var tmp35 any = tmp37 - v10 = tmp34 - v13 = tmp35 - continue - } - tmp14 = tmp15 + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + recur_loop_202: + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__GT__EQ_) + tmp8 := lang.Apply(tmp7, []any{v3, v4}) + if lang.IsTruthy(tmp8) { + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_next) + tmp11 := lang.Apply(tmp10, []any{v5}) + if lang.IsTruthy(tmp11) { + var tmp12 any = v4 + tmp14 := checkDerefVar(var_glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v5}) + var tmp13 any = tmp15 + tmp17 := checkDerefVar(var_glojure_DOT_core_next) + tmp18 := lang.Apply(tmp17, []any{v5}) + var tmp16 any = tmp18 + v3 = tmp12 + v4 = tmp13 + v5 = tmp16 + goto recur_loop_202 } else { - tmp14 = v10 + tmp19 := checkDerefVar(var_glojure_DOT_core__GT__EQ_) + tmp20 := checkDerefVar(var_glojure_DOT_core_first) + tmp21 := lang.Apply(tmp20, []any{v5}) + tmp22 := lang.Apply(tmp19, []any{v4, tmp21}) + tmp9 = tmp22 } - tmp6 = tmp14 - break + tmp6 = tmp9 + } else { + tmp6 = false } - } // end let - return tmp6 + return tmp6 + } }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core__GT__EQ_ = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core__GT__EQ_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // filterv + // < { - tmp0 := sym_filterv.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns a vector of the items in coll for which\n (pred item) returns logical true. pred must be free of side-effects.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.4", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(6961), kw_end_DASH_line, int(6961))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function <__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Lt}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym__LT_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns non-nil if nums are in monotonically increasing order,\n otherwise false.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(7), kw_line, int(893), kw_end_DASH_line, int(893))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) - tmp6 := checkDerefVar(var_glojure_DOT_core_reduce) - var tmp7 lang.FnFunc - tmp7 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + return true + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Lt") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Lt is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + default: checkArity(args, 2) - v8 := args[0] - _ = v8 - v9 := args[1] - _ = v9 - var tmp10 any - tmp11 := lang.Apply(v3, []any{v9}) - if lang.IsTruthy(tmp11) { - tmp12 := checkDerefVar(var_glojure_DOT_core_conj_BANG_) - tmp13 := lang.Apply(tmp12, []any{v8, v9}) - tmp10 = tmp13 + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + recur_loop_150: + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp8 := lang.Apply(tmp7, []any{v3, v4}) + if lang.IsTruthy(tmp8) { + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_next) + tmp11 := lang.Apply(tmp10, []any{v5}) + if lang.IsTruthy(tmp11) { + var tmp12 any = v4 + tmp14 := checkDerefVar(var_glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v5}) + var tmp13 any = tmp15 + tmp17 := checkDerefVar(var_glojure_DOT_core_next) + tmp18 := lang.Apply(tmp17, []any{v5}) + var tmp16 any = tmp18 + v3 = tmp12 + v4 = tmp13 + v5 = tmp16 + goto recur_loop_150 + } else { + tmp19 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp20 := checkDerefVar(var_glojure_DOT_core_first) + tmp21 := lang.Apply(tmp20, []any{v5}) + tmp22 := lang.Apply(tmp19, []any{v4, tmp21}) + tmp9 = tmp22 + } + tmp6 = tmp9 } else { - tmp10 = v8 + tmp6 = false } - return tmp10 - }) - tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6967), kw_column, int(15), kw_end_DASH_line, int(6967), kw_end_DASH_column, int(52)) - tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp10 := checkDerefVar(var_glojure_DOT_core_transient) - tmp11 := lang.NewVector() - tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6968), kw_column, int(26), kw_end_DASH_line, int(6968), kw_end_DASH_column, int(27)) - tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) - if err != nil { - panic(err) + return tmp6 } - tmp14 := lang.Apply(tmp10, []any{tmp13}) - tmp15 := lang.Apply(tmp6, []any{tmp9, tmp14, v4}) - tmp16 := lang.Apply(tmp5, []any{tmp15}) - return tmp16 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core__LT_ = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core__LT_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // find + // <= { - tmp0 := sym_find.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_map, sym_key)), kw_doc, "Returns the map entry for key, or nil if key not present.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1530), kw_end_DASH_line, int(1530))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function <=__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Lte}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym__LT__EQ_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns non-nil if nums are in monotonically non-decreasing order,\n otherwise false.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(7), kw_line, int(1048), kw_end_DASH_line, int(1048))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5, _ := lang.FieldOrMethod(runtime.RT, "Find") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Find is not a function"))) + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + return true + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Lte") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Lte is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + default: + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + recur_loop_194: + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__LT__EQ_) + tmp8 := lang.Apply(tmp7, []any{v3, v4}) + if lang.IsTruthy(tmp8) { + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_next) + tmp11 := lang.Apply(tmp10, []any{v5}) + if lang.IsTruthy(tmp11) { + var tmp12 any = v4 + tmp14 := checkDerefVar(var_glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v5}) + var tmp13 any = tmp15 + tmp17 := checkDerefVar(var_glojure_DOT_core_next) + tmp18 := lang.Apply(tmp17, []any{v5}) + var tmp16 any = tmp18 + v3 = tmp12 + v4 = tmp13 + v5 = tmp16 + goto recur_loop_194 + } else { + tmp19 := checkDerefVar(var_glojure_DOT_core__LT__EQ_) + tmp20 := checkDerefVar(var_glojure_DOT_core_first) + tmp21 := lang.Apply(tmp20, []any{v5}) + tmp22 := lang.Apply(tmp19, []any{v4, tmp21}) + tmp9 = tmp22 + } + tmp6 = tmp9 + } else { + tmp6 = false + } + return tmp6 } - tmp6 := lang.Apply(tmp5, []any{v3, v4}) - return tmp6 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core__LT__EQ_ = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core__LT__EQ_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // find-keyword + // + { - tmp1 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() - tmp0 := sym_find_DASH_keyword.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_name), lang.NewVector(sym_ns, sym_name)), kw_doc, "Returns a Keyword with the given namespace and name if one already\n exists. This function will not intern a new keyword. If the keyword\n has not already been interned, it will return nil. Do not use :\n in the keyword strings, it will be added automatically.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(618), kw_end_DASH_line, int(618))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: - v4 := args[0] + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed3 + } else { + tmp4 = closed4 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed3 + } else { + tmp5 = closed4 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) _ = v4 var tmp5 any - tmp6 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) - tmp7 := lang.Apply(tmp6, []any{v4}) - if lang.IsTruthy(tmp7) { - tmp5 = v4 - } else { - var tmp8 any - tmp9 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) - tmp10 := lang.Apply(tmp9, []any{v4}) - if lang.IsTruthy(tmp10) { - tmp11 := lang.Apply(nil, []any{v4}) - tmp8 = tmp11 + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed3 } else { - var tmp12 any - tmp13 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) - tmp14 := lang.Apply(tmp13, []any{v4}) - if lang.IsTruthy(tmp14) { - tmp15 := lang.Apply(nil, []any{v4}) - tmp12 = tmp15 - } else { - } - tmp8 = tmp12 + tmp6 = closed4 } - tmp5 = tmp8 - } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let return tmp5 - case 2: - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6 := lang.Apply(nil, []any{v4, v5}) - return tmp6 - default: - checkArity(args, -1) - panic("unreachable") } }) - tmp4 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // find-ns - { - tmp0 := sym_find_DASH_ns.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_sym)), kw_doc, "Returns the namespace named by the symbol or nil if it doesn't exist.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4125), kw_end_DASH_line, int(4125))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := lang.Apply(lang.FindNamespace, []any{v3}) - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // find-var - { - tmp0 := sym_find_DASH_var.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_sym)), kw_doc, "Returns the global var named by the namespace-qualified symbol, or\n nil if no var with that name.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(2013), kw_end_DASH_line, int(2013))).(*lang.Symbol) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(runtime.RT, "FindVar") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("FindVar is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{v3}) + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp0 := sym__PLUS_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns the sum of nums. (+) returns 0. Does not auto-promote\n longs, will throw on overflow. See also: +'", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(7), kw_line, int(977), kw_end_DASH_line, int(977))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return int64(0) + case 1: + v4 := args[0] + _ = v4 + tmp5 := lang.Apply(lang.MustAsNumber, []any{v4}) + return tmp5 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Add") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Add is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp8 := checkDerefVar(var_glojure_DOT_core__PLUS_) + tmp9 := checkDerefVar(var_glojure_DOT_core__PLUS_) + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) + return tmp11 + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__PLUS_ = ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core__PLUS_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // first + // +' { - tmp0 := sym_first.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns the first item in the collection. Calls seq on its\n argument. If coll is nil, returns nil.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(6), kw_column, int(2), kw_line, int(47), kw_end_DASH_line, int(52))).(*lang.Symbol) - var tmp2 lang.FnFunc - { // function first - var v3 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed5 + } else { + tmp4 = closed5 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed5 + } else { + tmp5 = closed5 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) _ = v4 - tmp5 := lang.Apply(lang.First, []any{v4}) + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed5 + } else { + tmp6 = closed5 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(52), kw_column, int(8), kw_end_DASH_line, int(52), kw_end_DASH_column, int(86))).(lang.FnFunc) - v3 = tmp2 - _ = v3 - } - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // fits-table? - { - tmp0 := sym_fits_DASH_table_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ints)), kw_doc, "Returns true if the collection of ints can fit within the\n max-table-switch-size, false otherwise.", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(8), kw_line, int(6625), kw_end_DASH_line, int(6625), kw_private, true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core__LT_) - tmp5 := checkDerefVar(var_glojure_DOT_core__DASH_) - tmp6 := checkDerefVar(var_glojure_DOT_core_apply) - tmp7 := checkDerefVar(var_glojure_DOT_core_max) - tmp8 := checkDerefVar(var_glojure_DOT_core_seq) - tmp9 := lang.Apply(tmp8, []any{v3}) - tmp10 := lang.Apply(tmp6, []any{tmp7, tmp9}) - tmp11 := checkDerefVar(var_glojure_DOT_core_apply) - tmp12 := checkDerefVar(var_glojure_DOT_core_min) - tmp13 := checkDerefVar(var_glojure_DOT_core_seq) - tmp14 := lang.Apply(tmp13, []any{v3}) - tmp15 := lang.Apply(tmp11, []any{tmp12, tmp14}) - tmp16 := lang.Apply(tmp5, []any{tmp10, tmp15}) - tmp17 := checkDerefVar(var_glojure_DOT_core_max_DASH_switch_DASH_table_DASH_size) - tmp18 := lang.Apply(tmp4, []any{tmp16, tmp17}) - return tmp18 + } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // flatten - { - tmp0 := sym_flatten.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Takes any nested combination of sequential things (lists, vectors,\n etc.) and returns their contents as a single, flat lazy sequence.\n (flatten nil) returns an empty sequence.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(7118), kw_end_DASH_line, int(7118))).(*lang.Symbol) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_filter) - tmp5 := checkDerefVar(var_glojure_DOT_core_complement) - tmp6 := checkDerefVar(var_glojure_DOT_core_sequential_QMARK_) - tmp7 := lang.Apply(tmp5, []any{tmp6}) - tmp8 := checkDerefVar(var_glojure_DOT_core_rest) - tmp9 := checkDerefVar(var_glojure_DOT_core_tree_DASH_seq) - tmp10 := checkDerefVar(var_glojure_DOT_core_sequential_QMARK_) - tmp11 := checkDerefVar(var_glojure_DOT_core_seq) - tmp12 := lang.Apply(tmp9, []any{tmp10, tmp11, v3}) - tmp13 := lang.Apply(tmp8, []any{tmp12}) - tmp14 := lang.Apply(tmp4, []any{tmp7, tmp13}) - return tmp14 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // float - { - var tmp1 lang.FnFunc - { // function float__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_seq) - tmp5 := checkDerefVar(var_glojure_DOT_core_concat) - tmp6 := checkDerefVar(var_glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) - tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := checkDerefVar(var_glojure_DOT_core_seq) - tmp12 := checkDerefVar(var_glojure_DOT_core_concat) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - var tmp14 any - tmp15 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) - if lang.IsTruthy(tmp15) { - tmp14 = sym_uncheckedFloatCast - } else { - tmp14 = sym_floatCast - } - tmp16 := lang.Apply(tmp13, []any{tmp14}) - tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{v3}) - tmp19 := lang.Apply(tmp12, []any{tmp16, tmp18}) - tmp20 := lang.Apply(tmp11, []any{tmp19}) - tmp21 := lang.Apply(tmp10, []any{tmp20}) - tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp21}) - tmp23 := lang.Apply(tmp4, []any{tmp22}) - return tmp23 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := sym_float.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to float", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3487), kw_end_DASH_line, int(3487))).(*lang.Symbol) + tmp0 := sym__PLUS__TICK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns the sum of nums. (+') returns 0. Supports arbitrary precision.\n See also: +", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(7), kw_line, int(965), kw_end_DASH_line, int(965))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5 := lang.Apply(lang.FloatCast, []any{v4}) - return tmp5 + switch len(args) { + case 0: + return int64(0) + case 1: + v4 := args[0] + _ = v4 + tmp5 := lang.Apply(lang.MustAsNumber, []any{v4}) + return tmp5 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "AddP") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("AddP is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp8 := checkDerefVar(var_glojure_DOT_core__PLUS__TICK_) + tmp9 := checkDerefVar(var_glojure_DOT_core__PLUS__TICK_) + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) + return tmp11 + } }) tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + var_glojure_DOT_core__PLUS__TICK_ = ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core__PLUS__TICK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // float-array + // / { var tmp1 lang.FnFunc - { // function float-array__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 0) - var v3 any = lang.NewList(args[0:]...) - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_seq) - tmp5 := checkDerefVar(var_glojure_DOT_core_concat) - tmp6 := checkDerefVar(var_glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) - tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed28 + } else { + tmp4 = closed28 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed28 + } else { + tmp5 = closed28 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_FloatArray}) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed28 + } else { + tmp6 = closed28 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } tmp13 := checkDerefVar(var_glojure_DOT_core_seq) tmp14 := checkDerefVar(var_glojure_DOT_core_concat) tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_unquote_DASH_splicing}) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{sym_glojure_DOT_core_SLASH_args}) - tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) - tmp20 := lang.Apply(tmp13, []any{tmp19}) - tmp21 := lang.Apply(tmp12, []any{tmp20}) - tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp21}) - tmp23 := lang.Apply(tmp4, []any{tmp22}) - return tmp23 - } - }) - v2 = tmp1 - _ = v2 - } - tmp0 := sym_float_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_size_DASH_or_DASH_seq), lang.NewVector(sym_size, sym_init_DASH_val_DASH_or_DASH_seq)), kw_inline, tmp1, kw_doc, "Creates an array of floats", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(5301), kw_end_DASH_line, int(5301))).(*lang.Symbol) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym__SLASH_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "If no denominators are supplied, returns 1/numerator,\n else returns numerator divided by all of the denominators.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(7), kw_line, int(1013), kw_end_DASH_line, int(1013))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v4 := args[0] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "FloatArray") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("FloatArray is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) + tmp5 := checkDerefVar(var_glojure_DOT_core__SLASH_) + tmp6 := lang.Apply(tmp5, []any{int64(1), v4}) return tmp6 case 2: v4 := args[0] _ = v4 v5 := args[1] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "FloatArrayInit") + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Divide") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("FloatArrayInit is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Divide is not a function"))) } tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - checkArity(args, -1) - panic("unreachable") + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp8 := checkDerefVar(var_glojure_DOT_core__SLASH_) + tmp9 := checkDerefVar(var_glojure_DOT_core__SLASH_) + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) + return tmp11 } }) tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // float? - { - tmp0 := sym_float_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_doc, "Returns true if n is a floating point number", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(3605), kw_end_DASH_line, int(3605))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "or__0__auto__" - tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp6 := lang.Apply(tmp5, []any{lang.Builtins["float64"], v3}) - var v7 any = tmp6 - _ = v7 - var tmp8 any - if lang.IsTruthy(v7) { - tmp8 = v7 - } else { - tmp9 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp10 := lang.Apply(tmp9, []any{lang.Builtins["float32"], v3}) - tmp8 = tmp10 - } - tmp4 = tmp8 - } // end let - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core__SLASH_ = ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core__SLASH_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // floats + // * { var tmp1 lang.FnFunc - { // function floats - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_seq) - tmp5 := checkDerefVar(var_glojure_DOT_core_concat) - tmp6 := checkDerefVar(var_glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) - tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Floats}) - tmp12 := checkDerefVar(var_glojure_DOT_core_list) - tmp13 := lang.Apply(tmp12, []any{v3}) - tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) - tmp15 := lang.Apply(tmp4, []any{tmp14}) - return tmp15 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := sym_floats.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xs)), kw_inline, tmp1, kw_doc, "Casts to float[]", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(12), kw_line, int(5392), kw_end_DASH_line, int(5392))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Floats") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Floats is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // flush - { - tmp0 := sym_flush.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Flushes the output stream that is the current value of\n *out*", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3706), kw_end_DASH_line, int(3706))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - tmp3 := checkDerefVar(var_glojure_DOT_core__STAR_out_STAR_) - tmp4, _ := lang.FieldOrMethod(tmp3, "Sync") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Sync is not a function"))) - } - tmp5 := lang.Apply(tmp4, []any{}) - _ = tmp5 - return nil - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // fn - { - tmp0 := sym_fn.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_sigs)), kw_doc, "params => positional-params*, or positional-params* & rest-param\n positional-param => binding-form\n rest-param => binding-form\n binding-form => name, or destructuring-form\n\n Defines a function.\n\n See https://glojure.org/reference/special_forms#fn for more information", kw_forms, lang.NewVector(lang.NewList(sym_fn, sym_name_QMARK_, lang.NewVector(sym_params_STAR_), sym_exprs_STAR_), lang.NewList(sym_fn, sym_name_QMARK_, lang.NewList(lang.NewVector(sym_params_STAR_), sym_exprs_STAR_), sym__PLUS_)), kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(11), kw_line, int(4533), kw_end_DASH_line, int(4533), kw_special_DASH_form, true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed0 + } else { + tmp4 = closed1 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed0 + } else { + tmp5 = closed1 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 default: checkArity(args, 2) - v3 := args[0] + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + var v4 any = lang.NewList(args[2:]...) _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - var tmp6 any + var tmp5 any { // let - // let binding "name" - var tmp7 any - tmp8 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) - tmp9 := checkDerefVar(var_glojure_DOT_core_first) - tmp10 := lang.Apply(tmp9, []any{v5}) - tmp11 := lang.Apply(tmp8, []any{tmp10}) - if lang.IsTruthy(tmp11) { - tmp12 := checkDerefVar(var_glojure_DOT_core_first) - tmp13 := lang.Apply(tmp12, []any{v5}) - tmp7 = tmp13 - } else { - } - var v14 any = tmp7 - _ = v14 - // let binding "sigs" - var tmp15 any - if lang.IsTruthy(v14) { - tmp16 := checkDerefVar(var_glojure_DOT_core_next) - tmp17 := lang.Apply(tmp16, []any{v5}) - tmp15 = tmp17 + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed0 } else { - tmp15 = v5 + tmp6 = closed1 } - var v18 any = tmp15 - _ = v18 - // let binding "sigs" - var tmp19 any - tmp20 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) - tmp21 := checkDerefVar(var_glojure_DOT_core_first) - tmp22 := lang.Apply(tmp21, []any{v18}) - tmp23 := lang.Apply(tmp20, []any{tmp22}) - if lang.IsTruthy(tmp23) { + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) tmp24 := checkDerefVar(var_glojure_DOT_core_list) - tmp25 := lang.Apply(tmp24, []any{v18}) - tmp19 = tmp25 - } else { - var tmp26 any - tmp27 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) - tmp28 := checkDerefVar(var_glojure_DOT_core_first) - tmp29 := lang.Apply(tmp28, []any{v18}) - tmp30 := lang.Apply(tmp27, []any{tmp29}) - if lang.IsTruthy(tmp30) { - tmp26 = v18 - } else { - var tmp31 any - tmp32 := checkDerefVar(var_glojure_DOT_core_seq) - tmp33 := lang.Apply(tmp32, []any{v18}) - if lang.IsTruthy(tmp33) { - tmp34 := checkDerefVar(var_glojure_DOT_core_str) - tmp35 := checkDerefVar(var_glojure_DOT_core_first) - tmp36 := lang.Apply(tmp35, []any{v18}) - tmp37 := lang.Apply(tmp34, []any{"Parameter declaration ", tmp36, " should be a vector"}) - tmp31 = tmp37 - } else { - tmp38 := checkDerefVar(var_glojure_DOT_core_str) - tmp39 := lang.Apply(tmp38, []any{"Parameter declaration missing"}) - tmp31 = tmp39 - } - tmp40 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp31}) - panic(tmp40) - } - tmp19 = tmp26 - } - var v41 any = tmp19 - _ = v41 - // let binding "psig" - var tmp42 lang.FnFunc - tmp42 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v43 := args[0] - _ = v43 - var tmp44 any - tmp45 := checkDerefVar(var_glojure_DOT_core_not) - tmp46 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) - tmp47 := lang.Apply(tmp46, []any{v43}) - tmp48 := lang.Apply(tmp45, []any{tmp47}) - if lang.IsTruthy(tmp48) { - tmp49 := checkDerefVar(var_glojure_DOT_core_str) - tmp50 := lang.Apply(tmp49, []any{"Invalid signature ", v43, " should be a list"}) - tmp51 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp50}) - panic(tmp51) - } else { - } - _ = tmp44 - var tmp52 any - { // let - // let binding "vec__13" - var v53 any = v43 - _ = v53 - // let binding "seq__14" - tmp54 := checkDerefVar(var_glojure_DOT_core_seq) - tmp55 := lang.Apply(tmp54, []any{v53}) - var v56 any = tmp55 - _ = v56 - // let binding "first__15" - tmp57 := checkDerefVar(var_glojure_DOT_core_first) - tmp58 := lang.Apply(tmp57, []any{v56}) - var v59 any = tmp58 - _ = v59 - // let binding "seq__14" - tmp60 := checkDerefVar(var_glojure_DOT_core_next) - tmp61 := lang.Apply(tmp60, []any{v56}) - var v62 any = tmp61 - _ = v62 - // let binding "params" - var v63 any = v59 - _ = v63 - // let binding "body" - var v64 any = v62 - _ = v64 - // let binding "_" - var tmp65 any - tmp66 := checkDerefVar(var_glojure_DOT_core_not) - tmp67 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) - tmp68 := lang.Apply(tmp67, []any{v63}) - tmp69 := lang.Apply(tmp66, []any{tmp68}) - if lang.IsTruthy(tmp69) { - var tmp70 any - tmp71 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) - tmp72 := checkDerefVar(var_glojure_DOT_core_first) - tmp73 := lang.Apply(tmp72, []any{v41}) - tmp74 := lang.Apply(tmp71, []any{tmp73}) - if lang.IsTruthy(tmp74) { - tmp75 := checkDerefVar(var_glojure_DOT_core_str) - tmp76 := lang.Apply(tmp75, []any{"Parameter declaration ", v63, " should be a vector"}) - tmp70 = tmp76 - } else { - tmp77 := checkDerefVar(var_glojure_DOT_core_str) - tmp78 := lang.Apply(tmp77, []any{"Invalid signature ", v43, " should be a list"}) - tmp70 = tmp78 - } - tmp79 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp70}) - panic(tmp79) - } else { - } - var v80 any = tmp65 - _ = v80 - // let binding "conds" - var tmp81 any - var tmp82 any - { // let - // let binding "and__0__auto__" - tmp83 := checkDerefVar(var_glojure_DOT_core_next) - tmp84 := lang.Apply(tmp83, []any{v64}) - var v85 any = tmp84 - _ = v85 - var tmp86 any - if lang.IsTruthy(v85) { - tmp87 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) - tmp88 := checkDerefVar(var_glojure_DOT_core_first) - tmp89 := lang.Apply(tmp88, []any{v64}) - tmp90 := lang.Apply(tmp87, []any{tmp89}) - tmp86 = tmp90 - } else { - tmp86 = v85 - } - tmp82 = tmp86 - } // end let - if lang.IsTruthy(tmp82) { - tmp83 := checkDerefVar(var_glojure_DOT_core_first) - tmp84 := lang.Apply(tmp83, []any{v64}) - tmp81 = tmp84 - } else { - } - var v85 any = tmp81 - _ = v85 - // let binding "body" - var tmp86 any - if lang.IsTruthy(v85) { - tmp87 := checkDerefVar(var_glojure_DOT_core_next) - tmp88 := lang.Apply(tmp87, []any{v64}) - tmp86 = tmp88 - } else { - tmp86 = v64 - } - var v89 any = tmp86 - _ = v89 - // let binding "conds" - var tmp90 any - { // let - // let binding "or__0__auto__" - var v91 any = v85 - _ = v91 - var tmp92 any - if lang.IsTruthy(v91) { - tmp92 = v91 - } else { - tmp93 := checkDerefVar(var_glojure_DOT_core_meta) - tmp94 := lang.Apply(tmp93, []any{v63}) - tmp92 = tmp94 - } - tmp90 = tmp92 - } // end let - var v91 any = tmp90 - _ = v91 - // let binding "pre" - tmp92 := lang.Apply(kw_pre, []any{v91}) - var v93 any = tmp92 - _ = v93 - // let binding "post" - tmp94 := lang.Apply(kw_post, []any{v91}) - var v95 any = tmp94 - _ = v95 - // let binding "body" - var tmp96 any - if lang.IsTruthy(v95) { - tmp97 := checkDerefVar(var_glojure_DOT_core_seq) - tmp98 := checkDerefVar(var_glojure_DOT_core_concat) - tmp99 := checkDerefVar(var_glojure_DOT_core_list) - tmp100 := checkDerefVar(var_glojure_DOT_core_seq) - tmp101 := checkDerefVar(var_glojure_DOT_core_concat) - tmp102 := checkDerefVar(var_glojure_DOT_core_list) - tmp103 := lang.Apply(tmp102, []any{sym_glojure_DOT_core_SLASH_let}) - tmp104 := checkDerefVar(var_glojure_DOT_core_list) - tmp105 := checkDerefVar(var_glojure_DOT_core_apply) - tmp106 := checkDerefVar(var_glojure_DOT_core_vector) - tmp107 := checkDerefVar(var_glojure_DOT_core_seq) - tmp108 := checkDerefVar(var_glojure_DOT_core_concat) - tmp109 := checkDerefVar(var_glojure_DOT_core_list) - tmp110 := lang.Apply(tmp109, []any{sym__PCT_}) - tmp111 := checkDerefVar(var_glojure_DOT_core_list) - var tmp112 any - tmp113 := checkDerefVar(var_glojure_DOT_core__LT_) - tmp114 := checkDerefVar(var_glojure_DOT_core_count) - tmp115 := lang.Apply(tmp114, []any{v89}) - tmp116 := lang.Apply(tmp113, []any{int64(1), tmp115}) - if lang.IsTruthy(tmp116) { - tmp117 := checkDerefVar(var_glojure_DOT_core_seq) - tmp118 := checkDerefVar(var_glojure_DOT_core_concat) - tmp119 := checkDerefVar(var_glojure_DOT_core_list) - tmp120 := lang.Apply(tmp119, []any{sym_do}) - tmp121 := lang.Apply(tmp118, []any{tmp120, v89}) - tmp122 := lang.Apply(tmp117, []any{tmp121}) - tmp112 = tmp122 - } else { - tmp123 := checkDerefVar(var_glojure_DOT_core_first) - tmp124 := lang.Apply(tmp123, []any{v89}) - tmp112 = tmp124 - } - tmp125 := lang.Apply(tmp111, []any{tmp112}) - tmp126 := lang.Apply(tmp108, []any{tmp110, tmp125}) - tmp127 := lang.Apply(tmp107, []any{tmp126}) - tmp128 := lang.Apply(tmp105, []any{tmp106, tmp127}) - tmp129 := lang.Apply(tmp104, []any{tmp128}) - tmp130 := checkDerefVar(var_glojure_DOT_core_map) - var tmp131 lang.FnFunc - tmp131 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v132 := args[0] - _ = v132 - tmp133 := checkDerefVar(var_glojure_DOT_core_seq) - tmp134 := checkDerefVar(var_glojure_DOT_core_concat) - tmp135 := checkDerefVar(var_glojure_DOT_core_list) - tmp136 := lang.Apply(tmp135, []any{sym_glojure_DOT_core_SLASH_assert}) - tmp137 := checkDerefVar(var_glojure_DOT_core_list) - tmp138 := lang.Apply(tmp137, []any{v132}) - tmp139 := lang.Apply(tmp134, []any{tmp136, tmp138}) - tmp140 := lang.Apply(tmp133, []any{tmp139}) - return tmp140 - }) - tmp132 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4582), kw_column, int(41), kw_end_DASH_line, int(4582), kw_end_DASH_column, int(62)) - tmp133, err := lang.WithMeta(tmp131, tmp132.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp134 := lang.Apply(tmp130, []any{tmp133, v95}) - tmp135 := checkDerefVar(var_glojure_DOT_core_list) - tmp136 := lang.Apply(tmp135, []any{sym__PCT_}) - tmp137 := lang.Apply(tmp101, []any{tmp103, tmp129, tmp134, tmp136}) - tmp138 := lang.Apply(tmp100, []any{tmp137}) - tmp139 := lang.Apply(tmp99, []any{tmp138}) - tmp140 := lang.Apply(tmp98, []any{tmp139}) - tmp141 := lang.Apply(tmp97, []any{tmp140}) - tmp96 = tmp141 - } else { - tmp96 = v89 - } - var v142 any = tmp96 - _ = v142 - // let binding "body" - var tmp143 any - if lang.IsTruthy(v93) { - tmp144 := checkDerefVar(var_glojure_DOT_core_concat) - tmp145 := checkDerefVar(var_glojure_DOT_core_map) - var tmp146 lang.FnFunc - tmp146 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v147 := args[0] - _ = v147 - tmp148 := checkDerefVar(var_glojure_DOT_core_seq) - tmp149 := checkDerefVar(var_glojure_DOT_core_concat) - tmp150 := checkDerefVar(var_glojure_DOT_core_list) - tmp151 := lang.Apply(tmp150, []any{sym_glojure_DOT_core_SLASH_assert}) - tmp152 := checkDerefVar(var_glojure_DOT_core_list) - tmp153 := lang.Apply(tmp152, []any{v147}) - tmp154 := lang.Apply(tmp149, []any{tmp151, tmp153}) - tmp155 := lang.Apply(tmp148, []any{tmp154}) - return tmp155 - }) - tmp147 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4586), kw_column, int(44), kw_end_DASH_line, int(4586), kw_end_DASH_column, int(65)) - tmp148, err := lang.WithMeta(tmp146, tmp147.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp149 := lang.Apply(tmp145, []any{tmp148, v93}) - tmp150 := lang.Apply(tmp144, []any{tmp149, v142}) - tmp143 = tmp150 - } else { - tmp143 = v142 - } - var v151 any = tmp143 - _ = v151 - tmp152 := checkDerefVar(var_glojure_DOT_core_maybe_DASH_destructured) - tmp153 := lang.Apply(tmp152, []any{v63, v151}) - tmp52 = tmp153 - } // end let - return tmp52 + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 }) - tmp43 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4558), kw_column, int(16), kw_end_DASH_line, int(4589), kw_end_DASH_column, int(53)) - tmp44, err := lang.WithMeta(tmp42, tmp43.(lang.IPersistentMap)) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) if err != nil { panic(err) } - var v45 any = tmp44 - _ = v45 - // let binding "new-sigs" - tmp46 := checkDerefVar(var_glojure_DOT_core_map) - tmp47 := lang.Apply(tmp46, []any{v45, v41}) - var v48 any = tmp47 - _ = v48 - tmp49 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) - var tmp50 any - if lang.IsTruthy(v14) { - tmp51 := checkDerefVar(var_glojure_DOT_core_list_STAR_) - tmp52 := lang.Apply(tmp51, []any{sym_fn_STAR_, v14, v48}) - tmp50 = tmp52 - } else { - tmp53 := checkDerefVar(var_glojure_DOT_core_cons) - tmp54 := lang.Apply(tmp53, []any{sym_fn_STAR_, v48}) - tmp50 = tmp54 - } - tmp55 := checkDerefVar(var_glojure_DOT_core_meta) - tmp56 := lang.Apply(tmp55, []any{v3}) - tmp57 := lang.Apply(tmp49, []any{tmp50, tmp56}) - tmp6 = tmp57 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 } // end let - return tmp6 + return tmp5 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // fn? - { - tmp0 := sym_fn_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x implements Fn, i.e. is an object created via fn.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(6216), kw_end_DASH_line, int(6216))).(*lang.Symbol) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp5 := reflect.TypeOf((*runtime.Fn)(nil)) - tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) - return tmp6 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // fnext - { - tmp0 := sym_fnext.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Same as (first (next x))", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(6), kw_column, int(2), kw_line, int(112), kw_end_DASH_line, int(116))).(*lang.Symbol) - var tmp2 lang.FnFunc - { // function fnext - var v3 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) + tmp0 := sym__STAR_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns the product of nums. (*) returns 1. Does not auto-promote\n longs, will throw on overflow. See also: *'", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(7), kw_line, int(1001), kw_end_DASH_line, int(1001))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return int64(1) + case 1: v4 := args[0] _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_first) - tmp6 := checkDerefVar(var_glojure_DOT_core_next) - tmp7 := lang.Apply(tmp6, []any{v4}) - tmp8 := lang.Apply(tmp5, []any{tmp7}) - return tmp8 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(116), kw_column, int(8), kw_end_DASH_line, int(116), kw_end_DASH_column, int(47))).(lang.FnFunc) - v3 = tmp2 - _ = v3 - } - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp5 := lang.Apply(lang.MustAsNumber, []any{v4}) + return tmp5 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Multiply") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Multiply is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp8 := checkDerefVar(var_glojure_DOT_core__STAR_) + tmp9 := checkDerefVar(var_glojure_DOT_core__STAR_) + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) + return tmp11 + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__STAR_ = ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core__STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // fnil + // *' { - tmp0 := sym_fnil.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_x), lang.NewVector(sym_f, sym_x, sym_y), lang.NewVector(sym_f, sym_x, sym_y, sym_z)), kw_doc, "Takes a function f, and returns a function that calls f, replacing\n a nil first argument to f with the supplied value x. Higher arity\n versions can replace arguments in the second and third\n positions (y, z). Note that the function f can take any number of\n arguments, not just the one(s) being nil-patched.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(6558), kw_end_DASH_line, int(6558))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed2 + } else { + tmp4 = closed2 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 case 2: - v3 := args[0] + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] - _ = v4 - var tmp5 lang.FnFunc - tmp5 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v6 := args[0] - _ = v6 - var tmp7 any - tmp8 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) - tmp9 := lang.Apply(tmp8, []any{v6}) - if lang.IsTruthy(tmp9) { - tmp7 = v4 - } else { - tmp7 = v6 - } - tmp10 := lang.Apply(v3, []any{tmp7}) - return tmp10 - case 2: - v6 := args[0] - _ = v6 - v7 := args[1] - _ = v7 - var tmp8 any - tmp9 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) - tmp10 := lang.Apply(tmp9, []any{v6}) - if lang.IsTruthy(tmp10) { - tmp8 = v4 - } else { - tmp8 = v6 - } - tmp11 := lang.Apply(v3, []any{tmp8, v7}) - return tmp11 - case 3: - v6 := args[0] - _ = v6 - v7 := args[1] - _ = v7 - v8 := args[2] - _ = v8 - var tmp9 any - tmp10 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) - tmp11 := lang.Apply(tmp10, []any{v6}) - if lang.IsTruthy(tmp11) { - tmp9 = v4 - } else { - tmp9 = v6 - } - tmp12 := lang.Apply(v3, []any{tmp9, v7, v8}) - return tmp12 - default: - checkArity(args, 3) - v6 := args[0] - _ = v6 - v7 := args[1] - _ = v7 - v8 := args[2] - _ = v8 - var v9 any = lang.NewList(args[3:]...) - _ = v9 - tmp10 := checkDerefVar(var_glojure_DOT_core_apply) - var tmp11 any - tmp12 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) - tmp13 := lang.Apply(tmp12, []any{v6}) - if lang.IsTruthy(tmp13) { - tmp11 = v4 - } else { - tmp11 = v6 - } - tmp14 := lang.Apply(tmp10, []any{v3, tmp11, v7, v8, v9}) - return tmp14 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed2 + } else { + tmp5 = closed2 } - }) - tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6567), kw_column, int(4), kw_end_DASH_line, int(6571), kw_end_DASH_column, int(55)) - tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp7 - case 3: - v3 := args[0] + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + var v4 any = lang.NewList(args[2:]...) _ = v4 - v5 := args[2] - _ = v5 - var tmp6 lang.FnFunc - tmp6 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: - v7 := args[0] - _ = v7 - v8 := args[1] - _ = v8 - var tmp9 any - tmp10 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) - tmp11 := lang.Apply(tmp10, []any{v7}) - if lang.IsTruthy(tmp11) { - tmp9 = v4 - } else { - tmp9 = v7 - } - var tmp12 any - tmp13 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) - tmp14 := lang.Apply(tmp13, []any{v8}) - if lang.IsTruthy(tmp14) { - tmp12 = v5 - } else { - tmp12 = v8 - } - tmp15 := lang.Apply(v3, []any{tmp9, tmp12}) - return tmp15 - case 3: - v7 := args[0] - _ = v7 - v8 := args[1] - _ = v8 - v9 := args[2] - _ = v9 - var tmp10 any - tmp11 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) - tmp12 := lang.Apply(tmp11, []any{v7}) - if lang.IsTruthy(tmp12) { - tmp10 = v4 - } else { - tmp10 = v7 - } - var tmp13 any - tmp14 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) - tmp15 := lang.Apply(tmp14, []any{v8}) - if lang.IsTruthy(tmp15) { - tmp13 = v5 - } else { - tmp13 = v8 - } - tmp16 := lang.Apply(v3, []any{tmp10, tmp13, v9}) - return tmp16 - default: - checkArity(args, 3) - v7 := args[0] - _ = v7 - v8 := args[1] - _ = v8 - v9 := args[2] - _ = v9 - var v10 any = lang.NewList(args[3:]...) - _ = v10 - tmp11 := checkDerefVar(var_glojure_DOT_core_apply) - var tmp12 any - tmp13 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) - tmp14 := lang.Apply(tmp13, []any{v7}) - if lang.IsTruthy(tmp14) { - tmp12 = v4 - } else { - tmp12 = v7 - } - var tmp15 any - tmp16 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) - tmp17 := lang.Apply(tmp16, []any{v8}) - if lang.IsTruthy(tmp17) { - tmp15 = v5 - } else { - tmp15 = v8 - } - tmp18 := lang.Apply(tmp11, []any{v3, tmp12, tmp15, v9, v10}) - return tmp18 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed2 + } else { + tmp6 = closed2 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) } - }) - tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6573), kw_column, int(4), kw_end_DASH_line, int(6576), kw_end_DASH_column, int(71)) - tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp8 - case 4: - v3 := args[0] - _ = v3 - v4 := args[1] + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym__STAR__TICK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns the product of nums. (*') returns 1. Supports arbitrary precision.\n See also: *", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(7), kw_line, int(989), kw_end_DASH_line, int(989))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return int64(1) + case 1: + v4 := args[0] _ = v4 - v5 := args[2] + tmp5 := lang.Apply(lang.MustAsNumber, []any{v4}) + return tmp5 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] _ = v5 - v6 := args[3] - _ = v6 - var tmp7 lang.FnFunc - tmp7 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: - v8 := args[0] - _ = v8 - v9 := args[1] - _ = v9 - var tmp10 any - tmp11 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) - tmp12 := lang.Apply(tmp11, []any{v8}) - if lang.IsTruthy(tmp12) { - tmp10 = v4 - } else { - tmp10 = v8 - } - var tmp13 any - tmp14 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) - tmp15 := lang.Apply(tmp14, []any{v9}) - if lang.IsTruthy(tmp15) { - tmp13 = v5 - } else { - tmp13 = v9 - } - tmp16 := lang.Apply(v3, []any{tmp10, tmp13}) - return tmp16 - case 3: - v8 := args[0] - _ = v8 - v9 := args[1] - _ = v9 - v10 := args[2] - _ = v10 - var tmp11 any - tmp12 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) - tmp13 := lang.Apply(tmp12, []any{v8}) - if lang.IsTruthy(tmp13) { - tmp11 = v4 - } else { - tmp11 = v8 - } - var tmp14 any - tmp15 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) - tmp16 := lang.Apply(tmp15, []any{v9}) - if lang.IsTruthy(tmp16) { - tmp14 = v5 - } else { - tmp14 = v9 - } - var tmp17 any - tmp18 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) - tmp19 := lang.Apply(tmp18, []any{v10}) - if lang.IsTruthy(tmp19) { - tmp17 = v6 - } else { - tmp17 = v10 - } - tmp20 := lang.Apply(v3, []any{tmp11, tmp14, tmp17}) - return tmp20 - default: - checkArity(args, 3) - v8 := args[0] - _ = v8 - v9 := args[1] - _ = v9 - v10 := args[2] - _ = v10 - var v11 any = lang.NewList(args[3:]...) - _ = v11 - tmp12 := checkDerefVar(var_glojure_DOT_core_apply) - var tmp13 any - tmp14 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) - tmp15 := lang.Apply(tmp14, []any{v8}) - if lang.IsTruthy(tmp15) { - tmp13 = v4 - } else { - tmp13 = v8 - } - var tmp16 any - tmp17 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) - tmp18 := lang.Apply(tmp17, []any{v9}) - if lang.IsTruthy(tmp18) { - tmp16 = v5 - } else { - tmp16 = v9 - } - var tmp19 any - tmp20 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) - tmp21 := lang.Apply(tmp20, []any{v10}) - if lang.IsTruthy(tmp21) { - tmp19 = v6 - } else { - tmp19 = v10 - } - tmp22 := lang.Apply(tmp12, []any{v3, tmp13, tmp16, tmp19, v11}) - return tmp22 - } - }) - tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6578), kw_column, int(4), kw_end_DASH_line, int(6581), kw_end_DASH_column, int(87)) - tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) - if err != nil { - panic(err) + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "MultiplyP") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("MultiplyP is not a function"))) } - return tmp9 + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 default: - checkArity(args, -1) - panic("unreachable") + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp8 := checkDerefVar(var_glojure_DOT_core__STAR__TICK_) + tmp9 := checkDerefVar(var_glojure_DOT_core__STAR__TICK_) + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) + return tmp11 } }) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__STAR__TICK_ = ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR__TICK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // abs + { + var tmp1 lang.FnFunc + { // function abs__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Abs}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{v3}) + tmp10 := lang.Apply(tmp5, []any{tmp7, tmp9}) + tmp11 := lang.Apply(tmp4, []any{tmp10}) + return tmp11 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_abs.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a)), kw_inline, tmp1, kw_doc, "Returns the absolute value of a.\n If a is Long/MIN_VALUE => Long/MIN_VALUE\n If a is a double and zero => +0.0\n If a is a double and ##Inf or ##-Inf => ##Inf\n If a is a double and ##NaN => ##NaN", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1)})), kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(1128), kw_end_DASH_line, int(1128))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.Abs, []any{v3}) + return tmp4 + }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core_abs = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_abs.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // for + // aclone { - tmp0 := sym_for.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_seq_DASH_exprs, sym_body_DASH_expr)), kw_doc, "List comprehension. Takes a vector of one or more\n binding-form/collection-expr pairs, each followed by zero or more\n modifiers, and yields a lazy sequence of evaluations of expr.\n Collections are iterated in a nested fashion, rightmost fastest,\n and nested coll-exprs can refer to bindings created in prior\n binding-forms. Supported modifiers are: :let [binding-form expr ...],\n :while test, :when test.\n\n (take 100 (for [x (range 100000000) y (range 1000000) :while (< y x)] [x y]))", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(11), kw_line, int(4646), kw_end_DASH_line, int(4646))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function aclone__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Aclone}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_aclone.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array)), kw_inline, tmp1, kw_doc, "Returns a clone of the Java array. Works on arrays of known\n types.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(3904), kw_end_DASH_line, int(3904))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 4) + checkArity(args, 1) v3 := args[0] _ = v3 - v4 := args[1] + tmp4, _ := lang.FieldOrMethod(runtime.RT, "Aclone") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Aclone is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_aclone = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_aclone.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // add-doc-and-meta + { + tmp0 := sym_add_DASH_doc_DASH_and_DASH_meta.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym_docstring, sym_meta)), kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(26), kw_column, int(11), kw_line, int(6400), kw_end_DASH_line, int(6400), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 5) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] _ = v4 - v5 := args[2] + v5 := args[3] _ = v5 - v6 := args[3] + v6 := args[4] _ = v6 - var tmp7 any - tmp8 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) - tmp9 := lang.Apply(tmp8, []any{v5}) - if lang.IsTruthy(tmp9) { - } else { - tmp10 := checkDerefVar(var_glojure_DOT_core_str) - tmp11 := checkDerefVar(var_glojure_DOT_core_first) - tmp12 := lang.Apply(tmp11, []any{v3}) - tmp13 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) - tmp14 := checkDerefVar(var_glojure_DOT_core_meta) - tmp15 := lang.Apply(tmp14, []any{v3}) - tmp16 := lang.Apply(kw_line, []any{tmp15}) - tmp17 := lang.Apply(tmp10, []any{tmp12, " requires ", "a vector for its binding", " in ", tmp13, ":", tmp16}) - tmp18 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp17}) - panic(tmp18) - } - _ = tmp7 - var tmp19 any - tmp20 := checkDerefVar(var_glojure_DOT_core_even_QMARK_) - tmp21 := checkDerefVar(var_glojure_DOT_core_count) - tmp22 := lang.Apply(tmp21, []any{v5}) - tmp23 := lang.Apply(tmp20, []any{tmp22}) - if lang.IsTruthy(tmp23) { - } else { - tmp24 := checkDerefVar(var_glojure_DOT_core_str) - tmp25 := checkDerefVar(var_glojure_DOT_core_first) - tmp26 := lang.Apply(tmp25, []any{v3}) - tmp27 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) - tmp28 := checkDerefVar(var_glojure_DOT_core_meta) - tmp29 := lang.Apply(tmp28, []any{v3}) - tmp30 := lang.Apply(kw_line, []any{tmp29}) - tmp31 := lang.Apply(tmp24, []any{tmp26, " requires ", "an even number of forms in binding vector", " in ", tmp27, ":", tmp30}) - tmp32 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp31}) - panic(tmp32) - } - _ = tmp19 - var tmp33 any - { // let - // let binding "to-groups" - var tmp34 lang.FnFunc - tmp34 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v35 := args[0] - _ = v35 - tmp36 := checkDerefVar(var_glojure_DOT_core_reduce1) - var tmp37 lang.FnFunc - tmp37 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v38 := args[0] - _ = v38 - v39 := args[1] - _ = v39 - var tmp40 any - { // let - // let binding "vec__24" - var v41 any = v39 - _ = v41 - // let binding "k" - tmp42 := checkDerefVar(var_glojure_DOT_core_nth) - tmp43 := lang.Apply(tmp42, []any{v41, int64(0), nil}) - var v44 any = tmp43 - _ = v44 - // let binding "v" - tmp45 := checkDerefVar(var_glojure_DOT_core_nth) - tmp46 := lang.Apply(tmp45, []any{v41, int64(1), nil}) - var v47 any = tmp46 - _ = v47 - var tmp48 any - tmp49 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) - tmp50 := lang.Apply(tmp49, []any{v44}) - if lang.IsTruthy(tmp50) { - tmp51 := checkDerefVar(var_glojure_DOT_core_conj) - tmp52 := checkDerefVar(var_glojure_DOT_core_pop) - tmp53 := lang.Apply(tmp52, []any{v38}) - tmp54 := checkDerefVar(var_glojure_DOT_core_conj) - tmp55 := checkDerefVar(var_glojure_DOT_core_peek) - tmp56 := lang.Apply(tmp55, []any{v38}) - tmp57 := lang.NewVector(v44, v47) - tmp58 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4664), kw_column, int(72), kw_end_DASH_line, int(4664), kw_end_DASH_column, int(76)) - tmp59, err := lang.WithMeta(tmp57, tmp58.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp60 := lang.Apply(tmp54, []any{tmp56, tmp59}) - tmp61 := lang.Apply(tmp51, []any{tmp53, tmp60}) - tmp48 = tmp61 - } else { - tmp62 := checkDerefVar(var_glojure_DOT_core_conj) - tmp63 := lang.NewVector(v44, v47) - tmp64 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4665), kw_column, int(46), kw_end_DASH_line, int(4665), kw_end_DASH_column, int(50)) - tmp65, err := lang.WithMeta(tmp63, tmp64.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp66 := lang.Apply(tmp62, []any{v38, tmp65}) - tmp48 = tmp66 - } - tmp40 = tmp48 - } // end let - return tmp40 - }) - tmp38 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4662), kw_column, int(30), kw_end_DASH_line, int(4665), kw_end_DASH_column, int(53)) - tmp39, err := lang.WithMeta(tmp37, tmp38.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp40 := lang.NewVector() - tmp41 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4666), kw_column, int(29), kw_end_DASH_line, int(4666), kw_end_DASH_column, int(30)) - tmp42, err := lang.WithMeta(tmp40, tmp41.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp43 := checkDerefVar(var_glojure_DOT_core_partition) - tmp44 := lang.Apply(tmp43, []any{int64(2), v35}) - tmp45 := lang.Apply(tmp36, []any{tmp39, tmp42, tmp44}) - return tmp45 - }) - tmp35 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4661), kw_column, int(19), kw_end_DASH_line, int(4666), kw_end_DASH_column, int(56)) - tmp36, err := lang.WithMeta(tmp34, tmp35.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v37 any = tmp36 - _ = v37 - // let binding "err" - var tmp38 lang.FnFunc - tmp38 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 0) - var v39 any = lang.NewList(args[0:]...) - _ = v39 - tmp40 := checkDerefVar(var_glojure_DOT_core_apply) - tmp41 := checkDerefVar(var_glojure_DOT_core_str) - tmp42 := lang.Apply(tmp40, []any{tmp41, v39}) - tmp43 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp42}) - panic(tmp43) - } - }) - tmp39 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4667), kw_column, int(13), kw_end_DASH_line, int(4667), kw_end_DASH_column, int(125)) - tmp40, err := lang.WithMeta(tmp38, tmp39.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v41 any = tmp40 - _ = v41 - // let binding "emit-bind" - var tmp42 lang.FnFunc - { // function emit-bind - var v43 lang.FnFunc - tmp42 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v44 := args[0] - _ = v44 - var tmp45 any - { // let - // let binding "vec__28" - var v46 any = v44 - _ = v46 - // let binding "seq__29" - tmp47 := checkDerefVar(var_glojure_DOT_core_seq) - tmp48 := lang.Apply(tmp47, []any{v46}) - var v49 any = tmp48 - _ = v49 - // let binding "first__30" - tmp50 := checkDerefVar(var_glojure_DOT_core_first) - tmp51 := lang.Apply(tmp50, []any{v49}) - var v52 any = tmp51 - _ = v52 - // let binding "seq__29" - tmp53 := checkDerefVar(var_glojure_DOT_core_next) - tmp54 := lang.Apply(tmp53, []any{v49}) - var v55 any = tmp54 - _ = v55 - // let binding "vec__31" - var v56 any = v52 - _ = v56 - // let binding "seq__32" - tmp57 := checkDerefVar(var_glojure_DOT_core_seq) - tmp58 := lang.Apply(tmp57, []any{v56}) - var v59 any = tmp58 - _ = v59 - // let binding "first__33" - tmp60 := checkDerefVar(var_glojure_DOT_core_first) - tmp61 := lang.Apply(tmp60, []any{v59}) - var v62 any = tmp61 - _ = v62 - // let binding "seq__32" - tmp63 := checkDerefVar(var_glojure_DOT_core_next) - tmp64 := lang.Apply(tmp63, []any{v59}) - var v65 any = tmp64 - _ = v65 - // let binding "bind" - var v66 any = v62 - _ = v66 - // let binding "first__33" - tmp67 := checkDerefVar(var_glojure_DOT_core_first) - tmp68 := lang.Apply(tmp67, []any{v65}) - var v69 any = tmp68 - _ = v69 - // let binding "seq__32" - tmp70 := checkDerefVar(var_glojure_DOT_core_next) - tmp71 := lang.Apply(tmp70, []any{v65}) - var v72 any = tmp71 - _ = v72 - // let binding "expr" - var v73 any = v69 - _ = v73 - // let binding "mod-pairs" - var v74 any = v72 - _ = v74 - // let binding "vec__34" - var v75 any = v55 - _ = v75 - // let binding "vec__37" - tmp76 := checkDerefVar(var_glojure_DOT_core_nth) - tmp77 := lang.Apply(tmp76, []any{v75, int64(0), nil}) - var v78 any = tmp77 - _ = v78 - // let binding "_" - tmp79 := checkDerefVar(var_glojure_DOT_core_nth) - tmp80 := lang.Apply(tmp79, []any{v78, int64(0), nil}) - var v81 any = tmp80 - _ = v81 - // let binding "next-expr" - tmp82 := checkDerefVar(var_glojure_DOT_core_nth) - tmp83 := lang.Apply(tmp82, []any{v78, int64(1), nil}) - var v84 any = tmp83 - _ = v84 - // let binding "next-groups" - var v85 any = v75 - _ = v85 - var tmp86 any - { // let - // let binding "giter" - tmp87 := checkDerefVar(var_glojure_DOT_core_gensym) - tmp88 := lang.Apply(tmp87, []any{"iter__"}) - var v89 any = tmp88 - _ = v89 - // let binding "gxs" - tmp90 := checkDerefVar(var_glojure_DOT_core_gensym) - tmp91 := lang.Apply(tmp90, []any{"s__"}) - var v92 any = tmp91 - _ = v92 - // let binding "do-mod" - var tmp93 lang.FnFunc - { // function do-mod - var v94 lang.FnFunc - tmp93 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v95 := args[0] - _ = v95 - var tmp96 any - { // let - // let binding "vec__41" - var v97 any = v95 - _ = v97 - // let binding "seq__42" - tmp98 := checkDerefVar(var_glojure_DOT_core_seq) - tmp99 := lang.Apply(tmp98, []any{v97}) - var v100 any = tmp99 - _ = v100 - // let binding "first__43" - tmp101 := checkDerefVar(var_glojure_DOT_core_first) - tmp102 := lang.Apply(tmp101, []any{v100}) - var v103 any = tmp102 - _ = v103 - // let binding "seq__42" - tmp104 := checkDerefVar(var_glojure_DOT_core_next) - tmp105 := lang.Apply(tmp104, []any{v100}) - var v106 any = tmp105 - _ = v106 - // let binding "vec__44" - var v107 any = v103 - _ = v107 - // let binding "k" - tmp108 := checkDerefVar(var_glojure_DOT_core_nth) - tmp109 := lang.Apply(tmp108, []any{v107, int64(0), nil}) - var v110 any = tmp109 - _ = v110 - // let binding "v" - tmp111 := checkDerefVar(var_glojure_DOT_core_nth) - tmp112 := lang.Apply(tmp111, []any{v107, int64(1), nil}) - var v113 any = tmp112 - _ = v113 - // let binding "pair" - var v114 any = v107 - _ = v114 - // let binding "etc" - var v115 any = v106 - _ = v115 - var tmp116 any - tmp117 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp118 := lang.Apply(tmp117, []any{v110, kw_let}) - if lang.IsTruthy(tmp118) { - tmp119 := checkDerefVar(var_glojure_DOT_core_seq) - tmp120 := checkDerefVar(var_glojure_DOT_core_concat) - tmp121 := checkDerefVar(var_glojure_DOT_core_list) - tmp122 := lang.Apply(tmp121, []any{sym_glojure_DOT_core_SLASH_let}) - tmp123 := checkDerefVar(var_glojure_DOT_core_list) - tmp124 := lang.Apply(tmp123, []any{v113}) - tmp125 := checkDerefVar(var_glojure_DOT_core_list) - tmp126 := lang.Apply(v94, []any{v115}) - tmp127 := lang.Apply(tmp125, []any{tmp126}) - tmp128 := lang.Apply(tmp120, []any{tmp122, tmp124, tmp127}) - tmp129 := lang.Apply(tmp119, []any{tmp128}) - tmp116 = tmp129 - } else { - var tmp130 any - tmp131 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp132 := lang.Apply(tmp131, []any{v110, kw_while}) - if lang.IsTruthy(tmp132) { - tmp133 := checkDerefVar(var_glojure_DOT_core_seq) - tmp134 := checkDerefVar(var_glojure_DOT_core_concat) - tmp135 := checkDerefVar(var_glojure_DOT_core_list) - tmp136 := lang.Apply(tmp135, []any{sym_glojure_DOT_core_SLASH_when}) - tmp137 := checkDerefVar(var_glojure_DOT_core_list) - tmp138 := lang.Apply(tmp137, []any{v113}) - tmp139 := checkDerefVar(var_glojure_DOT_core_list) - tmp140 := lang.Apply(v94, []any{v115}) - tmp141 := lang.Apply(tmp139, []any{tmp140}) - tmp142 := lang.Apply(tmp134, []any{tmp136, tmp138, tmp141}) - tmp143 := lang.Apply(tmp133, []any{tmp142}) - tmp130 = tmp143 - } else { - var tmp144 any - tmp145 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp146 := lang.Apply(tmp145, []any{v110, kw_when}) - if lang.IsTruthy(tmp146) { - tmp147 := checkDerefVar(var_glojure_DOT_core_seq) - tmp148 := checkDerefVar(var_glojure_DOT_core_concat) - tmp149 := checkDerefVar(var_glojure_DOT_core_list) - tmp150 := lang.Apply(tmp149, []any{sym_if}) - tmp151 := checkDerefVar(var_glojure_DOT_core_list) - tmp152 := lang.Apply(tmp151, []any{v113}) - tmp153 := checkDerefVar(var_glojure_DOT_core_list) - tmp154 := lang.Apply(v94, []any{v115}) - tmp155 := lang.Apply(tmp153, []any{tmp154}) - tmp156 := checkDerefVar(var_glojure_DOT_core_list) - tmp157 := checkDerefVar(var_glojure_DOT_core_seq) - tmp158 := checkDerefVar(var_glojure_DOT_core_concat) - tmp159 := checkDerefVar(var_glojure_DOT_core_list) - tmp160 := lang.Apply(tmp159, []any{sym_recur}) - tmp161 := checkDerefVar(var_glojure_DOT_core_list) - tmp162 := checkDerefVar(var_glojure_DOT_core_seq) - tmp163 := checkDerefVar(var_glojure_DOT_core_concat) - tmp164 := checkDerefVar(var_glojure_DOT_core_list) - tmp165 := lang.Apply(tmp164, []any{sym_glojure_DOT_core_SLASH_rest}) - tmp166 := checkDerefVar(var_glojure_DOT_core_list) - tmp167 := lang.Apply(tmp166, []any{v92}) - tmp168 := lang.Apply(tmp163, []any{tmp165, tmp167}) - tmp169 := lang.Apply(tmp162, []any{tmp168}) - tmp170 := lang.Apply(tmp161, []any{tmp169}) - tmp171 := lang.Apply(tmp158, []any{tmp160, tmp170}) - tmp172 := lang.Apply(tmp157, []any{tmp171}) - tmp173 := lang.Apply(tmp156, []any{tmp172}) - tmp174 := lang.Apply(tmp148, []any{tmp150, tmp152, tmp155, tmp173}) - tmp175 := lang.Apply(tmp147, []any{tmp174}) - tmp144 = tmp175 - } else { - var tmp176 any - tmp177 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) - tmp178 := lang.Apply(tmp177, []any{v110}) - if lang.IsTruthy(tmp178) { - tmp179 := lang.Apply(v41, []any{"Invalid 'for' keyword ", v110}) - tmp176 = tmp179 - } else { - var tmp180 any - if lang.IsTruthy(v85) { - tmp181 := checkDerefVar(var_glojure_DOT_core_seq) - tmp182 := checkDerefVar(var_glojure_DOT_core_concat) - tmp183 := checkDerefVar(var_glojure_DOT_core_list) - tmp184 := lang.Apply(tmp183, []any{sym_glojure_DOT_core_SLASH_let}) - tmp185 := checkDerefVar(var_glojure_DOT_core_list) - tmp186 := checkDerefVar(var_glojure_DOT_core_apply) - tmp187 := checkDerefVar(var_glojure_DOT_core_vector) - tmp188 := checkDerefVar(var_glojure_DOT_core_seq) - tmp189 := checkDerefVar(var_glojure_DOT_core_concat) - tmp190 := checkDerefVar(var_glojure_DOT_core_list) - tmp191 := lang.Apply(tmp190, []any{sym_iterys__0__auto__}) - tmp192 := checkDerefVar(var_glojure_DOT_core_list) - tmp193 := lang.Apply(v43, []any{v85}) - tmp194 := lang.Apply(tmp192, []any{tmp193}) - tmp195 := checkDerefVar(var_glojure_DOT_core_list) - tmp196 := lang.Apply(tmp195, []any{sym_fs__1__auto__}) - tmp197 := checkDerefVar(var_glojure_DOT_core_list) - tmp198 := checkDerefVar(var_glojure_DOT_core_seq) - tmp199 := checkDerefVar(var_glojure_DOT_core_concat) - tmp200 := checkDerefVar(var_glojure_DOT_core_list) - tmp201 := lang.Apply(tmp200, []any{sym_glojure_DOT_core_SLASH_seq}) - tmp202 := checkDerefVar(var_glojure_DOT_core_list) - tmp203 := checkDerefVar(var_glojure_DOT_core_seq) - tmp204 := checkDerefVar(var_glojure_DOT_core_concat) - tmp205 := checkDerefVar(var_glojure_DOT_core_list) - tmp206 := lang.Apply(tmp205, []any{sym_iterys__0__auto__}) - tmp207 := checkDerefVar(var_glojure_DOT_core_list) - tmp208 := lang.Apply(tmp207, []any{v84}) - tmp209 := lang.Apply(tmp204, []any{tmp206, tmp208}) - tmp210 := lang.Apply(tmp203, []any{tmp209}) - tmp211 := lang.Apply(tmp202, []any{tmp210}) - tmp212 := lang.Apply(tmp199, []any{tmp201, tmp211}) - tmp213 := lang.Apply(tmp198, []any{tmp212}) - tmp214 := lang.Apply(tmp197, []any{tmp213}) - tmp215 := lang.Apply(tmp189, []any{tmp191, tmp194, tmp196, tmp214}) - tmp216 := lang.Apply(tmp188, []any{tmp215}) - tmp217 := lang.Apply(tmp186, []any{tmp187, tmp216}) - tmp218 := lang.Apply(tmp185, []any{tmp217}) - tmp219 := checkDerefVar(var_glojure_DOT_core_list) - tmp220 := checkDerefVar(var_glojure_DOT_core_seq) - tmp221 := checkDerefVar(var_glojure_DOT_core_concat) - tmp222 := checkDerefVar(var_glojure_DOT_core_list) - tmp223 := lang.Apply(tmp222, []any{sym_if}) - tmp224 := checkDerefVar(var_glojure_DOT_core_list) - tmp225 := lang.Apply(tmp224, []any{sym_fs__1__auto__}) - tmp226 := checkDerefVar(var_glojure_DOT_core_list) - tmp227 := checkDerefVar(var_glojure_DOT_core_seq) - tmp228 := checkDerefVar(var_glojure_DOT_core_concat) - tmp229 := checkDerefVar(var_glojure_DOT_core_list) - tmp230 := lang.Apply(tmp229, []any{sym_glojure_DOT_core_SLASH_concat}) - tmp231 := checkDerefVar(var_glojure_DOT_core_list) - tmp232 := lang.Apply(tmp231, []any{sym_fs__1__auto__}) - tmp233 := checkDerefVar(var_glojure_DOT_core_list) - tmp234 := checkDerefVar(var_glojure_DOT_core_seq) - tmp235 := checkDerefVar(var_glojure_DOT_core_concat) - tmp236 := checkDerefVar(var_glojure_DOT_core_list) - tmp237 := lang.Apply(tmp236, []any{v89}) - tmp238 := checkDerefVar(var_glojure_DOT_core_list) - tmp239 := checkDerefVar(var_glojure_DOT_core_seq) - tmp240 := checkDerefVar(var_glojure_DOT_core_concat) - tmp241 := checkDerefVar(var_glojure_DOT_core_list) - tmp242 := lang.Apply(tmp241, []any{sym_glojure_DOT_core_SLASH_rest}) - tmp243 := checkDerefVar(var_glojure_DOT_core_list) - tmp244 := lang.Apply(tmp243, []any{v92}) - tmp245 := lang.Apply(tmp240, []any{tmp242, tmp244}) - tmp246 := lang.Apply(tmp239, []any{tmp245}) - tmp247 := lang.Apply(tmp238, []any{tmp246}) - tmp248 := lang.Apply(tmp235, []any{tmp237, tmp247}) - tmp249 := lang.Apply(tmp234, []any{tmp248}) - tmp250 := lang.Apply(tmp233, []any{tmp249}) - tmp251 := lang.Apply(tmp228, []any{tmp230, tmp232, tmp250}) - tmp252 := lang.Apply(tmp227, []any{tmp251}) - tmp253 := lang.Apply(tmp226, []any{tmp252}) - tmp254 := checkDerefVar(var_glojure_DOT_core_list) - tmp255 := checkDerefVar(var_glojure_DOT_core_seq) - tmp256 := checkDerefVar(var_glojure_DOT_core_concat) - tmp257 := checkDerefVar(var_glojure_DOT_core_list) - tmp258 := lang.Apply(tmp257, []any{sym_recur}) - tmp259 := checkDerefVar(var_glojure_DOT_core_list) - tmp260 := checkDerefVar(var_glojure_DOT_core_seq) - tmp261 := checkDerefVar(var_glojure_DOT_core_concat) - tmp262 := checkDerefVar(var_glojure_DOT_core_list) - tmp263 := lang.Apply(tmp262, []any{sym_glojure_DOT_core_SLASH_rest}) - tmp264 := checkDerefVar(var_glojure_DOT_core_list) - tmp265 := lang.Apply(tmp264, []any{v92}) - tmp266 := lang.Apply(tmp261, []any{tmp263, tmp265}) - tmp267 := lang.Apply(tmp260, []any{tmp266}) - tmp268 := lang.Apply(tmp259, []any{tmp267}) - tmp269 := lang.Apply(tmp256, []any{tmp258, tmp268}) - tmp270 := lang.Apply(tmp255, []any{tmp269}) - tmp271 := lang.Apply(tmp254, []any{tmp270}) - tmp272 := lang.Apply(tmp221, []any{tmp223, tmp225, tmp253, tmp271}) - tmp273 := lang.Apply(tmp220, []any{tmp272}) - tmp274 := lang.Apply(tmp219, []any{tmp273}) - tmp275 := lang.Apply(tmp182, []any{tmp184, tmp218, tmp274}) - tmp276 := lang.Apply(tmp181, []any{tmp275}) - tmp180 = tmp276 - } else { - var tmp277 any - if lang.IsTruthy(kw_else) { - tmp278 := checkDerefVar(var_glojure_DOT_core_seq) - tmp279 := checkDerefVar(var_glojure_DOT_core_concat) - tmp280 := checkDerefVar(var_glojure_DOT_core_list) - tmp281 := lang.Apply(tmp280, []any{sym_glojure_DOT_core_SLASH_cons}) - tmp282 := checkDerefVar(var_glojure_DOT_core_list) - tmp283 := lang.Apply(tmp282, []any{v6}) - tmp284 := checkDerefVar(var_glojure_DOT_core_list) - tmp285 := checkDerefVar(var_glojure_DOT_core_seq) - tmp286 := checkDerefVar(var_glojure_DOT_core_concat) - tmp287 := checkDerefVar(var_glojure_DOT_core_list) - tmp288 := lang.Apply(tmp287, []any{v89}) - tmp289 := checkDerefVar(var_glojure_DOT_core_list) - tmp290 := checkDerefVar(var_glojure_DOT_core_seq) - tmp291 := checkDerefVar(var_glojure_DOT_core_concat) - tmp292 := checkDerefVar(var_glojure_DOT_core_list) - tmp293 := lang.Apply(tmp292, []any{sym_glojure_DOT_core_SLASH_rest}) - tmp294 := checkDerefVar(var_glojure_DOT_core_list) - tmp295 := lang.Apply(tmp294, []any{v92}) - tmp296 := lang.Apply(tmp291, []any{tmp293, tmp295}) - tmp297 := lang.Apply(tmp290, []any{tmp296}) - tmp298 := lang.Apply(tmp289, []any{tmp297}) - tmp299 := lang.Apply(tmp286, []any{tmp288, tmp298}) - tmp300 := lang.Apply(tmp285, []any{tmp299}) - tmp301 := lang.Apply(tmp284, []any{tmp300}) - tmp302 := lang.Apply(tmp279, []any{tmp281, tmp283, tmp301}) - tmp303 := lang.Apply(tmp278, []any{tmp302}) - tmp277 = tmp303 - } else { - } - tmp180 = tmp277 - } - tmp176 = tmp180 - } - tmp144 = tmp176 - } - tmp130 = tmp144 - } - tmp116 = tmp130 - } - tmp96 = tmp116 - } // end let - return tmp96 - }) - v94 = tmp93 - _ = v94 - } - tmp94 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4672), kw_column, int(34), kw_end_DASH_line, int(4687), kw_end_DASH_column, int(73)) - tmp95, err := lang.WithMeta(tmp93, tmp94.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v96 any = tmp95 - _ = v96 - var tmp97 any - if lang.IsTruthy(v85) { - tmp98 := checkDerefVar(var_glojure_DOT_core_seq) - tmp99 := checkDerefVar(var_glojure_DOT_core_concat) - tmp100 := checkDerefVar(var_glojure_DOT_core_list) - tmp101 := lang.Apply(tmp100, []any{sym_glojure_DOT_core_SLASH_fn}) - tmp102 := checkDerefVar(var_glojure_DOT_core_list) - tmp103 := lang.Apply(tmp102, []any{v89}) - tmp104 := checkDerefVar(var_glojure_DOT_core_list) - tmp105 := checkDerefVar(var_glojure_DOT_core_apply) - tmp106 := checkDerefVar(var_glojure_DOT_core_vector) - tmp107 := checkDerefVar(var_glojure_DOT_core_seq) - tmp108 := checkDerefVar(var_glojure_DOT_core_concat) - tmp109 := checkDerefVar(var_glojure_DOT_core_list) - tmp110 := lang.Apply(tmp109, []any{v92}) - tmp111 := lang.Apply(tmp108, []any{tmp110}) - tmp112 := lang.Apply(tmp107, []any{tmp111}) - tmp113 := lang.Apply(tmp105, []any{tmp106, tmp112}) - tmp114 := lang.Apply(tmp104, []any{tmp113}) - tmp115 := checkDerefVar(var_glojure_DOT_core_list) - tmp116 := checkDerefVar(var_glojure_DOT_core_seq) - tmp117 := checkDerefVar(var_glojure_DOT_core_concat) - tmp118 := checkDerefVar(var_glojure_DOT_core_list) - tmp119 := lang.Apply(tmp118, []any{sym_glojure_DOT_core_SLASH_lazy_DASH_seq}) - tmp120 := checkDerefVar(var_glojure_DOT_core_list) - tmp121 := checkDerefVar(var_glojure_DOT_core_seq) - tmp122 := checkDerefVar(var_glojure_DOT_core_concat) - tmp123 := checkDerefVar(var_glojure_DOT_core_list) - tmp124 := lang.Apply(tmp123, []any{sym_glojure_DOT_core_SLASH_loop}) - tmp125 := checkDerefVar(var_glojure_DOT_core_list) - tmp126 := checkDerefVar(var_glojure_DOT_core_apply) - tmp127 := checkDerefVar(var_glojure_DOT_core_vector) - tmp128 := checkDerefVar(var_glojure_DOT_core_seq) - tmp129 := checkDerefVar(var_glojure_DOT_core_concat) - tmp130 := checkDerefVar(var_glojure_DOT_core_list) - tmp131 := lang.Apply(tmp130, []any{v92}) - tmp132 := checkDerefVar(var_glojure_DOT_core_list) - tmp133 := lang.Apply(tmp132, []any{v92}) - tmp134 := lang.Apply(tmp129, []any{tmp131, tmp133}) - tmp135 := lang.Apply(tmp128, []any{tmp134}) - tmp136 := lang.Apply(tmp126, []any{tmp127, tmp135}) - tmp137 := lang.Apply(tmp125, []any{tmp136}) - tmp138 := checkDerefVar(var_glojure_DOT_core_list) - tmp139 := checkDerefVar(var_glojure_DOT_core_seq) - tmp140 := checkDerefVar(var_glojure_DOT_core_concat) - tmp141 := checkDerefVar(var_glojure_DOT_core_list) - tmp142 := lang.Apply(tmp141, []any{sym_glojure_DOT_core_SLASH_when_DASH_first}) - tmp143 := checkDerefVar(var_glojure_DOT_core_list) - tmp144 := checkDerefVar(var_glojure_DOT_core_apply) - tmp145 := checkDerefVar(var_glojure_DOT_core_vector) - tmp146 := checkDerefVar(var_glojure_DOT_core_seq) - tmp147 := checkDerefVar(var_glojure_DOT_core_concat) - tmp148 := checkDerefVar(var_glojure_DOT_core_list) - tmp149 := lang.Apply(tmp148, []any{v66}) - tmp150 := checkDerefVar(var_glojure_DOT_core_list) - tmp151 := lang.Apply(tmp150, []any{v92}) - tmp152 := lang.Apply(tmp147, []any{tmp149, tmp151}) - tmp153 := lang.Apply(tmp146, []any{tmp152}) - tmp154 := lang.Apply(tmp144, []any{tmp145, tmp153}) - tmp155 := lang.Apply(tmp143, []any{tmp154}) - tmp156 := checkDerefVar(var_glojure_DOT_core_list) - tmp157 := lang.Apply(v96, []any{v74}) - tmp158 := lang.Apply(tmp156, []any{tmp157}) - tmp159 := lang.Apply(tmp140, []any{tmp142, tmp155, tmp158}) - tmp160 := lang.Apply(tmp139, []any{tmp159}) - tmp161 := lang.Apply(tmp138, []any{tmp160}) - tmp162 := lang.Apply(tmp122, []any{tmp124, tmp137, tmp161}) - tmp163 := lang.Apply(tmp121, []any{tmp162}) - tmp164 := lang.Apply(tmp120, []any{tmp163}) - tmp165 := lang.Apply(tmp117, []any{tmp119, tmp164}) - tmp166 := lang.Apply(tmp116, []any{tmp165}) - tmp167 := lang.Apply(tmp115, []any{tmp166}) - tmp168 := lang.Apply(tmp99, []any{tmp101, tmp103, tmp114, tmp167}) - tmp169 := lang.Apply(tmp98, []any{tmp168}) - tmp97 = tmp169 - } else { - var tmp170 any - { // let - // let binding "gi" - tmp171 := checkDerefVar(var_glojure_DOT_core_gensym) - tmp172 := lang.Apply(tmp171, []any{"i__"}) - var v173 any = tmp172 - _ = v173 - // let binding "gb" - tmp174 := checkDerefVar(var_glojure_DOT_core_gensym) - tmp175 := lang.Apply(tmp174, []any{"b__"}) - var v176 any = tmp175 - _ = v176 - // let binding "do-cmod" - var tmp177 lang.FnFunc - { // function do-cmod - var v178 lang.FnFunc - tmp177 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v179 := args[0] - _ = v179 - var tmp180 any - { // let - // let binding "vec__48" - var v181 any = v179 - _ = v181 - // let binding "seq__49" - tmp182 := checkDerefVar(var_glojure_DOT_core_seq) - tmp183 := lang.Apply(tmp182, []any{v181}) - var v184 any = tmp183 - _ = v184 - // let binding "first__50" - tmp185 := checkDerefVar(var_glojure_DOT_core_first) - tmp186 := lang.Apply(tmp185, []any{v184}) - var v187 any = tmp186 - _ = v187 - // let binding "seq__49" - tmp188 := checkDerefVar(var_glojure_DOT_core_next) - tmp189 := lang.Apply(tmp188, []any{v184}) - var v190 any = tmp189 - _ = v190 - // let binding "vec__51" - var v191 any = v187 - _ = v191 - // let binding "k" - tmp192 := checkDerefVar(var_glojure_DOT_core_nth) - tmp193 := lang.Apply(tmp192, []any{v191, int64(0), nil}) - var v194 any = tmp193 - _ = v194 - // let binding "v" - tmp195 := checkDerefVar(var_glojure_DOT_core_nth) - tmp196 := lang.Apply(tmp195, []any{v191, int64(1), nil}) - var v197 any = tmp196 - _ = v197 - // let binding "pair" - var v198 any = v191 - _ = v198 - // let binding "etc" - var v199 any = v190 - _ = v199 - var tmp200 any - tmp201 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp202 := lang.Apply(tmp201, []any{v194, kw_let}) - if lang.IsTruthy(tmp202) { - tmp203 := checkDerefVar(var_glojure_DOT_core_seq) - tmp204 := checkDerefVar(var_glojure_DOT_core_concat) - tmp205 := checkDerefVar(var_glojure_DOT_core_list) - tmp206 := lang.Apply(tmp205, []any{sym_glojure_DOT_core_SLASH_let}) - tmp207 := checkDerefVar(var_glojure_DOT_core_list) - tmp208 := lang.Apply(tmp207, []any{v197}) - tmp209 := checkDerefVar(var_glojure_DOT_core_list) - tmp210 := lang.Apply(v178, []any{v199}) - tmp211 := lang.Apply(tmp209, []any{tmp210}) - tmp212 := lang.Apply(tmp204, []any{tmp206, tmp208, tmp211}) - tmp213 := lang.Apply(tmp203, []any{tmp212}) - tmp200 = tmp213 - } else { - var tmp214 any - tmp215 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp216 := lang.Apply(tmp215, []any{v194, kw_while}) - if lang.IsTruthy(tmp216) { - tmp217 := checkDerefVar(var_glojure_DOT_core_seq) - tmp218 := checkDerefVar(var_glojure_DOT_core_concat) - tmp219 := checkDerefVar(var_glojure_DOT_core_list) - tmp220 := lang.Apply(tmp219, []any{sym_glojure_DOT_core_SLASH_when}) - tmp221 := checkDerefVar(var_glojure_DOT_core_list) - tmp222 := lang.Apply(tmp221, []any{v197}) - tmp223 := checkDerefVar(var_glojure_DOT_core_list) - tmp224 := lang.Apply(v178, []any{v199}) - tmp225 := lang.Apply(tmp223, []any{tmp224}) - tmp226 := lang.Apply(tmp218, []any{tmp220, tmp222, tmp225}) - tmp227 := lang.Apply(tmp217, []any{tmp226}) - tmp214 = tmp227 - } else { - var tmp228 any - tmp229 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp230 := lang.Apply(tmp229, []any{v194, kw_when}) - if lang.IsTruthy(tmp230) { - tmp231 := checkDerefVar(var_glojure_DOT_core_seq) - tmp232 := checkDerefVar(var_glojure_DOT_core_concat) - tmp233 := checkDerefVar(var_glojure_DOT_core_list) - tmp234 := lang.Apply(tmp233, []any{sym_if}) - tmp235 := checkDerefVar(var_glojure_DOT_core_list) - tmp236 := lang.Apply(tmp235, []any{v197}) - tmp237 := checkDerefVar(var_glojure_DOT_core_list) - tmp238 := lang.Apply(v178, []any{v199}) - tmp239 := lang.Apply(tmp237, []any{tmp238}) - tmp240 := checkDerefVar(var_glojure_DOT_core_list) - tmp241 := checkDerefVar(var_glojure_DOT_core_seq) - tmp242 := checkDerefVar(var_glojure_DOT_core_concat) - tmp243 := checkDerefVar(var_glojure_DOT_core_list) - tmp244 := lang.Apply(tmp243, []any{sym_recur}) - tmp245 := checkDerefVar(var_glojure_DOT_core_list) - tmp246 := checkDerefVar(var_glojure_DOT_core_seq) - tmp247 := checkDerefVar(var_glojure_DOT_core_concat) - tmp248 := checkDerefVar(var_glojure_DOT_core_list) - tmp249 := lang.Apply(tmp248, []any{sym_glojure_DOT_core_SLASH_unchecked_DASH_inc}) - tmp250 := checkDerefVar(var_glojure_DOT_core_list) - tmp251 := lang.Apply(tmp250, []any{v173}) - tmp252 := lang.Apply(tmp247, []any{tmp249, tmp251}) - tmp253 := lang.Apply(tmp246, []any{tmp252}) - tmp254 := lang.Apply(tmp245, []any{tmp253}) - tmp255 := lang.Apply(tmp242, []any{tmp244, tmp254}) - tmp256 := lang.Apply(tmp241, []any{tmp255}) - tmp257 := lang.Apply(tmp240, []any{tmp256}) - tmp258 := lang.Apply(tmp232, []any{tmp234, tmp236, tmp239, tmp257}) - tmp259 := lang.Apply(tmp231, []any{tmp258}) - tmp228 = tmp259 - } else { - var tmp260 any - tmp261 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) - tmp262 := lang.Apply(tmp261, []any{v194}) - if lang.IsTruthy(tmp262) { - tmp263 := lang.Apply(v41, []any{"Invalid 'for' keyword ", v194}) - tmp260 = tmp263 - } else { - var tmp264 any - if lang.IsTruthy(kw_else) { - tmp265 := checkDerefVar(var_glojure_DOT_core_seq) - tmp266 := checkDerefVar(var_glojure_DOT_core_concat) - tmp267 := checkDerefVar(var_glojure_DOT_core_list) - tmp268 := lang.Apply(tmp267, []any{sym_do}) - tmp269 := checkDerefVar(var_glojure_DOT_core_list) - tmp270 := checkDerefVar(var_glojure_DOT_core_seq) - tmp271 := checkDerefVar(var_glojure_DOT_core_concat) - tmp272 := checkDerefVar(var_glojure_DOT_core_list) - tmp273 := lang.Apply(tmp272, []any{sym_glojure_DOT_core_SLASH_chunk_DASH_append}) - tmp274 := checkDerefVar(var_glojure_DOT_core_list) - tmp275 := lang.Apply(tmp274, []any{v176}) - tmp276 := checkDerefVar(var_glojure_DOT_core_list) - tmp277 := lang.Apply(tmp276, []any{v6}) - tmp278 := lang.Apply(tmp271, []any{tmp273, tmp275, tmp277}) - tmp279 := lang.Apply(tmp270, []any{tmp278}) - tmp280 := lang.Apply(tmp269, []any{tmp279}) - tmp281 := checkDerefVar(var_glojure_DOT_core_list) - tmp282 := checkDerefVar(var_glojure_DOT_core_seq) - tmp283 := checkDerefVar(var_glojure_DOT_core_concat) - tmp284 := checkDerefVar(var_glojure_DOT_core_list) - tmp285 := lang.Apply(tmp284, []any{sym_recur}) - tmp286 := checkDerefVar(var_glojure_DOT_core_list) - tmp287 := checkDerefVar(var_glojure_DOT_core_seq) - tmp288 := checkDerefVar(var_glojure_DOT_core_concat) - tmp289 := checkDerefVar(var_glojure_DOT_core_list) - tmp290 := lang.Apply(tmp289, []any{sym_glojure_DOT_core_SLASH_unchecked_DASH_inc}) - tmp291 := checkDerefVar(var_glojure_DOT_core_list) - tmp292 := lang.Apply(tmp291, []any{v173}) - tmp293 := lang.Apply(tmp288, []any{tmp290, tmp292}) - tmp294 := lang.Apply(tmp287, []any{tmp293}) - tmp295 := lang.Apply(tmp286, []any{tmp294}) - tmp296 := lang.Apply(tmp283, []any{tmp285, tmp295}) - tmp297 := lang.Apply(tmp282, []any{tmp296}) - tmp298 := lang.Apply(tmp281, []any{tmp297}) - tmp299 := lang.Apply(tmp266, []any{tmp268, tmp280, tmp298}) - tmp300 := lang.Apply(tmp265, []any{tmp299}) - tmp264 = tmp300 - } else { - } - tmp260 = tmp264 - } - tmp228 = tmp260 - } - tmp214 = tmp228 - } - tmp200 = tmp214 - } - tmp180 = tmp200 - } // end let - return tmp180 - }) - v178 = tmp177 - _ = v178 - } - tmp178 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4698), kw_column, int(39), kw_end_DASH_line, int(4710), kw_end_DASH_column, int(79)) - tmp179, err := lang.WithMeta(tmp177, tmp178.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v180 any = tmp179 - _ = v180 - tmp181 := checkDerefVar(var_glojure_DOT_core_seq) - tmp182 := checkDerefVar(var_glojure_DOT_core_concat) - tmp183 := checkDerefVar(var_glojure_DOT_core_list) - tmp184 := lang.Apply(tmp183, []any{sym_glojure_DOT_core_SLASH_fn}) - tmp185 := checkDerefVar(var_glojure_DOT_core_list) - tmp186 := lang.Apply(tmp185, []any{v89}) - tmp187 := checkDerefVar(var_glojure_DOT_core_list) - tmp188 := checkDerefVar(var_glojure_DOT_core_apply) - tmp189 := checkDerefVar(var_glojure_DOT_core_vector) - tmp190 := checkDerefVar(var_glojure_DOT_core_seq) - tmp191 := checkDerefVar(var_glojure_DOT_core_concat) - tmp192 := checkDerefVar(var_glojure_DOT_core_list) - tmp193 := lang.Apply(tmp192, []any{v92}) - tmp194 := lang.Apply(tmp191, []any{tmp193}) - tmp195 := lang.Apply(tmp190, []any{tmp194}) - tmp196 := lang.Apply(tmp188, []any{tmp189, tmp195}) - tmp197 := lang.Apply(tmp187, []any{tmp196}) - tmp198 := checkDerefVar(var_glojure_DOT_core_list) - tmp199 := checkDerefVar(var_glojure_DOT_core_seq) - tmp200 := checkDerefVar(var_glojure_DOT_core_concat) - tmp201 := checkDerefVar(var_glojure_DOT_core_list) - tmp202 := lang.Apply(tmp201, []any{sym_glojure_DOT_core_SLASH_lazy_DASH_seq}) - tmp203 := checkDerefVar(var_glojure_DOT_core_list) - tmp204 := checkDerefVar(var_glojure_DOT_core_seq) - tmp205 := checkDerefVar(var_glojure_DOT_core_concat) - tmp206 := checkDerefVar(var_glojure_DOT_core_list) - tmp207 := lang.Apply(tmp206, []any{sym_glojure_DOT_core_SLASH_loop}) - tmp208 := checkDerefVar(var_glojure_DOT_core_list) - tmp209 := checkDerefVar(var_glojure_DOT_core_apply) - tmp210 := checkDerefVar(var_glojure_DOT_core_vector) - tmp211 := checkDerefVar(var_glojure_DOT_core_seq) - tmp212 := checkDerefVar(var_glojure_DOT_core_concat) - tmp213 := checkDerefVar(var_glojure_DOT_core_list) - tmp214 := lang.Apply(tmp213, []any{v92}) - tmp215 := checkDerefVar(var_glojure_DOT_core_list) - tmp216 := lang.Apply(tmp215, []any{v92}) - tmp217 := lang.Apply(tmp212, []any{tmp214, tmp216}) - tmp218 := lang.Apply(tmp211, []any{tmp217}) - tmp219 := lang.Apply(tmp209, []any{tmp210, tmp218}) - tmp220 := lang.Apply(tmp208, []any{tmp219}) - tmp221 := checkDerefVar(var_glojure_DOT_core_list) - tmp222 := checkDerefVar(var_glojure_DOT_core_seq) - tmp223 := checkDerefVar(var_glojure_DOT_core_concat) - tmp224 := checkDerefVar(var_glojure_DOT_core_list) - tmp225 := lang.Apply(tmp224, []any{sym_glojure_DOT_core_SLASH_when_DASH_let}) - tmp226 := checkDerefVar(var_glojure_DOT_core_list) - tmp227 := checkDerefVar(var_glojure_DOT_core_apply) - tmp228 := checkDerefVar(var_glojure_DOT_core_vector) - tmp229 := checkDerefVar(var_glojure_DOT_core_seq) - tmp230 := checkDerefVar(var_glojure_DOT_core_concat) - tmp231 := checkDerefVar(var_glojure_DOT_core_list) - tmp232 := lang.Apply(tmp231, []any{v92}) - tmp233 := checkDerefVar(var_glojure_DOT_core_list) - tmp234 := checkDerefVar(var_glojure_DOT_core_seq) - tmp235 := checkDerefVar(var_glojure_DOT_core_concat) - tmp236 := checkDerefVar(var_glojure_DOT_core_list) - tmp237 := lang.Apply(tmp236, []any{sym_glojure_DOT_core_SLASH_seq}) - tmp238 := checkDerefVar(var_glojure_DOT_core_list) - tmp239 := lang.Apply(tmp238, []any{v92}) - tmp240 := lang.Apply(tmp235, []any{tmp237, tmp239}) - tmp241 := lang.Apply(tmp234, []any{tmp240}) - tmp242 := lang.Apply(tmp233, []any{tmp241}) - tmp243 := lang.Apply(tmp230, []any{tmp232, tmp242}) - tmp244 := lang.Apply(tmp229, []any{tmp243}) - tmp245 := lang.Apply(tmp227, []any{tmp228, tmp244}) - tmp246 := lang.Apply(tmp226, []any{tmp245}) - tmp247 := checkDerefVar(var_glojure_DOT_core_list) - tmp248 := checkDerefVar(var_glojure_DOT_core_seq) - tmp249 := checkDerefVar(var_glojure_DOT_core_concat) - tmp250 := checkDerefVar(var_glojure_DOT_core_list) - tmp251 := lang.Apply(tmp250, []any{sym_if}) - tmp252 := checkDerefVar(var_glojure_DOT_core_list) - tmp253 := checkDerefVar(var_glojure_DOT_core_seq) - tmp254 := checkDerefVar(var_glojure_DOT_core_concat) - tmp255 := checkDerefVar(var_glojure_DOT_core_list) - tmp256 := lang.Apply(tmp255, []any{sym_glojure_DOT_core_SLASH_chunked_DASH_seq_QMARK_}) - tmp257 := checkDerefVar(var_glojure_DOT_core_list) - tmp258 := lang.Apply(tmp257, []any{v92}) - tmp259 := lang.Apply(tmp254, []any{tmp256, tmp258}) - tmp260 := lang.Apply(tmp253, []any{tmp259}) - tmp261 := lang.Apply(tmp252, []any{tmp260}) - tmp262 := checkDerefVar(var_glojure_DOT_core_list) - tmp263 := checkDerefVar(var_glojure_DOT_core_seq) - tmp264 := checkDerefVar(var_glojure_DOT_core_concat) - tmp265 := checkDerefVar(var_glojure_DOT_core_list) - tmp266 := lang.Apply(tmp265, []any{sym_glojure_DOT_core_SLASH_let}) - tmp267 := checkDerefVar(var_glojure_DOT_core_list) - tmp268 := checkDerefVar(var_glojure_DOT_core_apply) - tmp269 := checkDerefVar(var_glojure_DOT_core_vector) - tmp270 := checkDerefVar(var_glojure_DOT_core_seq) - tmp271 := checkDerefVar(var_glojure_DOT_core_concat) - tmp272 := checkDerefVar(var_glojure_DOT_core_list) - tmp273 := lang.Apply(tmp272, []any{sym_c__0__auto__}) - tmp274 := checkDerefVar(var_glojure_DOT_core_list) - tmp275 := checkDerefVar(var_glojure_DOT_core_seq) - tmp276 := checkDerefVar(var_glojure_DOT_core_concat) - tmp277 := checkDerefVar(var_glojure_DOT_core_list) - tmp278 := lang.Apply(tmp277, []any{sym_glojure_DOT_core_SLASH_chunk_DASH_first}) - tmp279 := checkDerefVar(var_glojure_DOT_core_list) - tmp280 := lang.Apply(tmp279, []any{v92}) - tmp281 := lang.Apply(tmp276, []any{tmp278, tmp280}) - tmp282 := lang.Apply(tmp275, []any{tmp281}) - tmp283 := lang.Apply(tmp274, []any{tmp282}) - tmp284 := checkDerefVar(var_glojure_DOT_core_list) - tmp285 := lang.Apply(tmp284, []any{sym_size__1__auto__}) - tmp286 := checkDerefVar(var_glojure_DOT_core_list) - tmp287 := checkDerefVar(var_glojure_DOT_core_seq) - tmp288 := checkDerefVar(var_glojure_DOT_core_concat) - tmp289 := checkDerefVar(var_glojure_DOT_core_list) - tmp290 := lang.Apply(tmp289, []any{sym_glojure_DOT_core_SLASH_int}) - tmp291 := checkDerefVar(var_glojure_DOT_core_list) - tmp292 := checkDerefVar(var_glojure_DOT_core_seq) - tmp293 := checkDerefVar(var_glojure_DOT_core_concat) - tmp294 := checkDerefVar(var_glojure_DOT_core_list) - tmp295 := lang.Apply(tmp294, []any{sym_glojure_DOT_core_SLASH_count}) - tmp296 := checkDerefVar(var_glojure_DOT_core_list) - tmp297 := lang.Apply(tmp296, []any{sym_c__0__auto__}) - tmp298 := lang.Apply(tmp293, []any{tmp295, tmp297}) - tmp299 := lang.Apply(tmp292, []any{tmp298}) - tmp300 := lang.Apply(tmp291, []any{tmp299}) - tmp301 := lang.Apply(tmp288, []any{tmp290, tmp300}) - tmp302 := lang.Apply(tmp287, []any{tmp301}) - tmp303 := lang.Apply(tmp286, []any{tmp302}) - tmp304 := checkDerefVar(var_glojure_DOT_core_list) - tmp305 := lang.Apply(tmp304, []any{v176}) - tmp306 := checkDerefVar(var_glojure_DOT_core_list) - tmp307 := checkDerefVar(var_glojure_DOT_core_seq) - tmp308 := checkDerefVar(var_glojure_DOT_core_concat) - tmp309 := checkDerefVar(var_glojure_DOT_core_list) - tmp310 := lang.Apply(tmp309, []any{sym_glojure_DOT_core_SLASH_chunk_DASH_buffer}) - tmp311 := checkDerefVar(var_glojure_DOT_core_list) - tmp312 := lang.Apply(tmp311, []any{sym_size__1__auto__}) - tmp313 := lang.Apply(tmp308, []any{tmp310, tmp312}) - tmp314 := lang.Apply(tmp307, []any{tmp313}) - tmp315 := lang.Apply(tmp306, []any{tmp314}) - tmp316 := lang.Apply(tmp271, []any{tmp273, tmp283, tmp285, tmp303, tmp305, tmp315}) - tmp317 := lang.Apply(tmp270, []any{tmp316}) - tmp318 := lang.Apply(tmp268, []any{tmp269, tmp317}) - tmp319 := lang.Apply(tmp267, []any{tmp318}) - tmp320 := checkDerefVar(var_glojure_DOT_core_list) - tmp321 := checkDerefVar(var_glojure_DOT_core_seq) - tmp322 := checkDerefVar(var_glojure_DOT_core_concat) - tmp323 := checkDerefVar(var_glojure_DOT_core_list) - tmp324 := lang.Apply(tmp323, []any{sym_if}) - tmp325 := checkDerefVar(var_glojure_DOT_core_list) - tmp326 := checkDerefVar(var_glojure_DOT_core_seq) - tmp327 := checkDerefVar(var_glojure_DOT_core_concat) - tmp328 := checkDerefVar(var_glojure_DOT_core_list) - tmp329 := lang.Apply(tmp328, []any{sym_glojure_DOT_core_SLASH_loop}) - tmp330 := checkDerefVar(var_glojure_DOT_core_list) - tmp331 := checkDerefVar(var_glojure_DOT_core_apply) - tmp332 := checkDerefVar(var_glojure_DOT_core_vector) - tmp333 := checkDerefVar(var_glojure_DOT_core_seq) - tmp334 := checkDerefVar(var_glojure_DOT_core_concat) - tmp335 := checkDerefVar(var_glojure_DOT_core_list) - tmp336 := lang.Apply(tmp335, []any{v173}) - tmp337 := checkDerefVar(var_glojure_DOT_core_list) - tmp338 := checkDerefVar(var_glojure_DOT_core_seq) - tmp339 := checkDerefVar(var_glojure_DOT_core_concat) - tmp340 := checkDerefVar(var_glojure_DOT_core_list) - tmp341 := lang.Apply(tmp340, []any{sym_glojure_DOT_core_SLASH_int}) - tmp342 := checkDerefVar(var_glojure_DOT_core_list) - tmp343 := lang.Apply(tmp342, []any{int64(0)}) - tmp344 := lang.Apply(tmp339, []any{tmp341, tmp343}) - tmp345 := lang.Apply(tmp338, []any{tmp344}) - tmp346 := lang.Apply(tmp337, []any{tmp345}) - tmp347 := lang.Apply(tmp334, []any{tmp336, tmp346}) - tmp348 := lang.Apply(tmp333, []any{tmp347}) - tmp349 := lang.Apply(tmp331, []any{tmp332, tmp348}) - tmp350 := lang.Apply(tmp330, []any{tmp349}) - tmp351 := checkDerefVar(var_glojure_DOT_core_list) - tmp352 := checkDerefVar(var_glojure_DOT_core_seq) - tmp353 := checkDerefVar(var_glojure_DOT_core_concat) - tmp354 := checkDerefVar(var_glojure_DOT_core_list) - tmp355 := lang.Apply(tmp354, []any{sym_if}) - tmp356 := checkDerefVar(var_glojure_DOT_core_list) - tmp357 := checkDerefVar(var_glojure_DOT_core_seq) - tmp358 := checkDerefVar(var_glojure_DOT_core_concat) - tmp359 := checkDerefVar(var_glojure_DOT_core_list) - tmp360 := lang.Apply(tmp359, []any{sym_glojure_DOT_core_SLASH__LT_}) - tmp361 := checkDerefVar(var_glojure_DOT_core_list) - tmp362 := lang.Apply(tmp361, []any{v173}) - tmp363 := checkDerefVar(var_glojure_DOT_core_list) - tmp364 := lang.Apply(tmp363, []any{sym_size__1__auto__}) - tmp365 := lang.Apply(tmp358, []any{tmp360, tmp362, tmp364}) - tmp366 := lang.Apply(tmp357, []any{tmp365}) - tmp367 := lang.Apply(tmp356, []any{tmp366}) - tmp368 := checkDerefVar(var_glojure_DOT_core_list) - tmp369 := checkDerefVar(var_glojure_DOT_core_seq) - tmp370 := checkDerefVar(var_glojure_DOT_core_concat) - tmp371 := checkDerefVar(var_glojure_DOT_core_list) - tmp372 := lang.Apply(tmp371, []any{sym_glojure_DOT_core_SLASH_let}) - tmp373 := checkDerefVar(var_glojure_DOT_core_list) - tmp374 := checkDerefVar(var_glojure_DOT_core_apply) - tmp375 := checkDerefVar(var_glojure_DOT_core_vector) - tmp376 := checkDerefVar(var_glojure_DOT_core_seq) - tmp377 := checkDerefVar(var_glojure_DOT_core_concat) - tmp378 := checkDerefVar(var_glojure_DOT_core_list) - tmp379 := lang.Apply(tmp378, []any{v66}) - tmp380 := checkDerefVar(var_glojure_DOT_core_list) - tmp381 := checkDerefVar(var_glojure_DOT_core_seq) - tmp382 := checkDerefVar(var_glojure_DOT_core_concat) - tmp383 := checkDerefVar(var_glojure_DOT_core_list) - tmp384 := lang.Apply(tmp383, []any{sym__DOT_nth}) - tmp385 := checkDerefVar(var_glojure_DOT_core_list) - tmp386 := lang.Apply(tmp385, []any{sym_c__0__auto__}) - tmp387 := checkDerefVar(var_glojure_DOT_core_list) - tmp388 := lang.Apply(tmp387, []any{v173}) - tmp389 := lang.Apply(tmp382, []any{tmp384, tmp386, tmp388}) - tmp390 := lang.Apply(tmp381, []any{tmp389}) - tmp391 := lang.Apply(tmp380, []any{tmp390}) - tmp392 := lang.Apply(tmp377, []any{tmp379, tmp391}) - tmp393 := lang.Apply(tmp376, []any{tmp392}) - tmp394 := lang.Apply(tmp374, []any{tmp375, tmp393}) - tmp395 := lang.Apply(tmp373, []any{tmp394}) - tmp396 := checkDerefVar(var_glojure_DOT_core_list) - tmp397 := lang.Apply(v180, []any{v74}) - tmp398 := lang.Apply(tmp396, []any{tmp397}) - tmp399 := lang.Apply(tmp370, []any{tmp372, tmp395, tmp398}) - tmp400 := lang.Apply(tmp369, []any{tmp399}) - tmp401 := lang.Apply(tmp368, []any{tmp400}) - tmp402 := checkDerefVar(var_glojure_DOT_core_list) - tmp403 := lang.Apply(tmp402, []any{true}) - tmp404 := lang.Apply(tmp353, []any{tmp355, tmp367, tmp401, tmp403}) - tmp405 := lang.Apply(tmp352, []any{tmp404}) - tmp406 := lang.Apply(tmp351, []any{tmp405}) - tmp407 := lang.Apply(tmp327, []any{tmp329, tmp350, tmp406}) - tmp408 := lang.Apply(tmp326, []any{tmp407}) - tmp409 := lang.Apply(tmp325, []any{tmp408}) - tmp410 := checkDerefVar(var_glojure_DOT_core_list) - tmp411 := checkDerefVar(var_glojure_DOT_core_seq) - tmp412 := checkDerefVar(var_glojure_DOT_core_concat) - tmp413 := checkDerefVar(var_glojure_DOT_core_list) - tmp414 := lang.Apply(tmp413, []any{sym_glojure_DOT_core_SLASH_chunk_DASH_cons}) - tmp415 := checkDerefVar(var_glojure_DOT_core_list) - tmp416 := checkDerefVar(var_glojure_DOT_core_seq) - tmp417 := checkDerefVar(var_glojure_DOT_core_concat) - tmp418 := checkDerefVar(var_glojure_DOT_core_list) - tmp419 := lang.Apply(tmp418, []any{sym_glojure_DOT_core_SLASH_chunk}) - tmp420 := checkDerefVar(var_glojure_DOT_core_list) - tmp421 := lang.Apply(tmp420, []any{v176}) - tmp422 := lang.Apply(tmp417, []any{tmp419, tmp421}) - tmp423 := lang.Apply(tmp416, []any{tmp422}) - tmp424 := lang.Apply(tmp415, []any{tmp423}) - tmp425 := checkDerefVar(var_glojure_DOT_core_list) - tmp426 := checkDerefVar(var_glojure_DOT_core_seq) - tmp427 := checkDerefVar(var_glojure_DOT_core_concat) - tmp428 := checkDerefVar(var_glojure_DOT_core_list) - tmp429 := lang.Apply(tmp428, []any{v89}) - tmp430 := checkDerefVar(var_glojure_DOT_core_list) - tmp431 := checkDerefVar(var_glojure_DOT_core_seq) - tmp432 := checkDerefVar(var_glojure_DOT_core_concat) - tmp433 := checkDerefVar(var_glojure_DOT_core_list) - tmp434 := lang.Apply(tmp433, []any{sym_glojure_DOT_core_SLASH_chunk_DASH_rest}) - tmp435 := checkDerefVar(var_glojure_DOT_core_list) - tmp436 := lang.Apply(tmp435, []any{v92}) - tmp437 := lang.Apply(tmp432, []any{tmp434, tmp436}) - tmp438 := lang.Apply(tmp431, []any{tmp437}) - tmp439 := lang.Apply(tmp430, []any{tmp438}) - tmp440 := lang.Apply(tmp427, []any{tmp429, tmp439}) - tmp441 := lang.Apply(tmp426, []any{tmp440}) - tmp442 := lang.Apply(tmp425, []any{tmp441}) - tmp443 := lang.Apply(tmp412, []any{tmp414, tmp424, tmp442}) - tmp444 := lang.Apply(tmp411, []any{tmp443}) - tmp445 := lang.Apply(tmp410, []any{tmp444}) - tmp446 := checkDerefVar(var_glojure_DOT_core_list) - tmp447 := checkDerefVar(var_glojure_DOT_core_seq) - tmp448 := checkDerefVar(var_glojure_DOT_core_concat) - tmp449 := checkDerefVar(var_glojure_DOT_core_list) - tmp450 := lang.Apply(tmp449, []any{sym_glojure_DOT_core_SLASH_chunk_DASH_cons}) - tmp451 := checkDerefVar(var_glojure_DOT_core_list) - tmp452 := checkDerefVar(var_glojure_DOT_core_seq) - tmp453 := checkDerefVar(var_glojure_DOT_core_concat) - tmp454 := checkDerefVar(var_glojure_DOT_core_list) - tmp455 := lang.Apply(tmp454, []any{sym_glojure_DOT_core_SLASH_chunk}) - tmp456 := checkDerefVar(var_glojure_DOT_core_list) - tmp457 := lang.Apply(tmp456, []any{v176}) - tmp458 := lang.Apply(tmp453, []any{tmp455, tmp457}) - tmp459 := lang.Apply(tmp452, []any{tmp458}) - tmp460 := lang.Apply(tmp451, []any{tmp459}) - tmp461 := checkDerefVar(var_glojure_DOT_core_list) - tmp462 := lang.Apply(tmp461, []any{nil}) - tmp463 := lang.Apply(tmp448, []any{tmp450, tmp460, tmp462}) - tmp464 := lang.Apply(tmp447, []any{tmp463}) - tmp465 := lang.Apply(tmp446, []any{tmp464}) - tmp466 := lang.Apply(tmp322, []any{tmp324, tmp409, tmp445, tmp465}) - tmp467 := lang.Apply(tmp321, []any{tmp466}) - tmp468 := lang.Apply(tmp320, []any{tmp467}) - tmp469 := lang.Apply(tmp264, []any{tmp266, tmp319, tmp468}) - tmp470 := lang.Apply(tmp263, []any{tmp469}) - tmp471 := lang.Apply(tmp262, []any{tmp470}) - tmp472 := checkDerefVar(var_glojure_DOT_core_list) - tmp473 := checkDerefVar(var_glojure_DOT_core_seq) - tmp474 := checkDerefVar(var_glojure_DOT_core_concat) - tmp475 := checkDerefVar(var_glojure_DOT_core_list) - tmp476 := lang.Apply(tmp475, []any{sym_glojure_DOT_core_SLASH_let}) - tmp477 := checkDerefVar(var_glojure_DOT_core_list) - tmp478 := checkDerefVar(var_glojure_DOT_core_apply) - tmp479 := checkDerefVar(var_glojure_DOT_core_vector) - tmp480 := checkDerefVar(var_glojure_DOT_core_seq) - tmp481 := checkDerefVar(var_glojure_DOT_core_concat) - tmp482 := checkDerefVar(var_glojure_DOT_core_list) - tmp483 := lang.Apply(tmp482, []any{v66}) - tmp484 := checkDerefVar(var_glojure_DOT_core_list) - tmp485 := checkDerefVar(var_glojure_DOT_core_seq) - tmp486 := checkDerefVar(var_glojure_DOT_core_concat) - tmp487 := checkDerefVar(var_glojure_DOT_core_list) - tmp488 := lang.Apply(tmp487, []any{sym_glojure_DOT_core_SLASH_first}) - tmp489 := checkDerefVar(var_glojure_DOT_core_list) - tmp490 := lang.Apply(tmp489, []any{v92}) - tmp491 := lang.Apply(tmp486, []any{tmp488, tmp490}) - tmp492 := lang.Apply(tmp485, []any{tmp491}) - tmp493 := lang.Apply(tmp484, []any{tmp492}) - tmp494 := lang.Apply(tmp481, []any{tmp483, tmp493}) - tmp495 := lang.Apply(tmp480, []any{tmp494}) - tmp496 := lang.Apply(tmp478, []any{tmp479, tmp495}) - tmp497 := lang.Apply(tmp477, []any{tmp496}) - tmp498 := checkDerefVar(var_glojure_DOT_core_list) - tmp499 := lang.Apply(v96, []any{v74}) - tmp500 := lang.Apply(tmp498, []any{tmp499}) - tmp501 := lang.Apply(tmp474, []any{tmp476, tmp497, tmp500}) - tmp502 := lang.Apply(tmp473, []any{tmp501}) - tmp503 := lang.Apply(tmp472, []any{tmp502}) - tmp504 := lang.Apply(tmp249, []any{tmp251, tmp261, tmp471, tmp503}) - tmp505 := lang.Apply(tmp248, []any{tmp504}) - tmp506 := lang.Apply(tmp247, []any{tmp505}) - tmp507 := lang.Apply(tmp223, []any{tmp225, tmp246, tmp506}) - tmp508 := lang.Apply(tmp222, []any{tmp507}) - tmp509 := lang.Apply(tmp221, []any{tmp508}) - tmp510 := lang.Apply(tmp205, []any{tmp207, tmp220, tmp509}) - tmp511 := lang.Apply(tmp204, []any{tmp510}) - tmp512 := lang.Apply(tmp203, []any{tmp511}) - tmp513 := lang.Apply(tmp200, []any{tmp202, tmp512}) - tmp514 := lang.Apply(tmp199, []any{tmp513}) - tmp515 := lang.Apply(tmp198, []any{tmp514}) - tmp516 := lang.Apply(tmp182, []any{tmp184, tmp186, tmp197, tmp515}) - tmp517 := lang.Apply(tmp181, []any{tmp516}) - tmp170 = tmp517 - } // end let - tmp97 = tmp170 - } - tmp86 = tmp97 - } // end let - tmp45 = tmp86 - } // end let - return tmp45 - }) - v43 = tmp42 - _ = v43 - } - tmp43 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4668), kw_column, int(19), kw_end_DASH_line, int(4729), kw_end_DASH_column, int(68)) - tmp44, err := lang.WithMeta(tmp42, tmp43.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v45 any = tmp44 - _ = v45 - tmp46 := checkDerefVar(var_glojure_DOT_core_seq) - tmp47 := checkDerefVar(var_glojure_DOT_core_concat) - tmp48 := checkDerefVar(var_glojure_DOT_core_list) - tmp49 := lang.Apply(tmp48, []any{sym_glojure_DOT_core_SLASH_let}) - tmp50 := checkDerefVar(var_glojure_DOT_core_list) - tmp51 := checkDerefVar(var_glojure_DOT_core_apply) - tmp52 := checkDerefVar(var_glojure_DOT_core_vector) - tmp53 := checkDerefVar(var_glojure_DOT_core_seq) - tmp54 := checkDerefVar(var_glojure_DOT_core_concat) - tmp55 := checkDerefVar(var_glojure_DOT_core_list) - tmp56 := lang.Apply(tmp55, []any{sym_iter__0__auto__}) - tmp57 := checkDerefVar(var_glojure_DOT_core_list) - tmp58 := lang.Apply(v37, []any{v5}) - tmp59 := lang.Apply(v45, []any{tmp58}) - tmp60 := lang.Apply(tmp57, []any{tmp59}) - tmp61 := lang.Apply(tmp54, []any{tmp56, tmp60}) - tmp62 := lang.Apply(tmp53, []any{tmp61}) - tmp63 := lang.Apply(tmp51, []any{tmp52, tmp62}) - tmp64 := lang.Apply(tmp50, []any{tmp63}) - tmp65 := checkDerefVar(var_glojure_DOT_core_list) - tmp66 := checkDerefVar(var_glojure_DOT_core_seq) - tmp67 := checkDerefVar(var_glojure_DOT_core_concat) - tmp68 := checkDerefVar(var_glojure_DOT_core_list) - tmp69 := lang.Apply(tmp68, []any{sym_iter__0__auto__}) - tmp70 := checkDerefVar(var_glojure_DOT_core_list) - tmp71 := checkDerefVar(var_glojure_DOT_core_second) - tmp72 := lang.Apply(tmp71, []any{v5}) - tmp73 := lang.Apply(tmp70, []any{tmp72}) - tmp74 := lang.Apply(tmp67, []any{tmp69, tmp73}) - tmp75 := lang.Apply(tmp66, []any{tmp74}) - tmp76 := lang.Apply(tmp65, []any{tmp75}) - tmp77 := lang.Apply(tmp47, []any{tmp49, tmp64, tmp76}) - tmp78 := lang.Apply(tmp46, []any{tmp77}) - tmp33 = tmp78 - } // end let - return tmp33 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_core_SLASH_alter_DASH_meta_BANG_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_var}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v4}) + tmp18 := lang.Apply(tmp13, []any{tmp15, tmp17}) + tmp19 := lang.Apply(tmp12, []any{tmp18}) + tmp20 := lang.Apply(tmp11, []any{tmp19}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{sym_glojure_DOT_core_SLASH_merge}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_seq) + tmp25 := checkDerefVar(var_glojure_DOT_core_concat) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{sym_glojure_DOT_core_SLASH_assoc}) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := lang.Apply(tmp28, []any{v6}) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := lang.Apply(tmp30, []any{kw_doc}) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := lang.Apply(tmp32, []any{v5}) + tmp34 := lang.Apply(tmp25, []any{tmp27, tmp29, tmp31, tmp33}) + tmp35 := lang.Apply(tmp24, []any{tmp34}) + tmp36 := lang.Apply(tmp23, []any{tmp35}) + tmp37 := lang.Apply(tmp8, []any{tmp10, tmp20, tmp22, tmp36}) + tmp38 := lang.Apply(tmp7, []any{tmp37}) + return tmp38 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_add_DASH_doc_DASH_and_DASH_meta = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_add_DASH_doc_DASH_and_DASH_meta.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // alength + { + var tmp1 lang.FnFunc + { // function alength__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Alength}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 } - } - // force - { - tmp0 := sym_force.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "If x is a Delay, returns the (possibly cached) value of its expression, else returns x", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(754), kw_end_DASH_line, int(754))).(*lang.Symbol) + tmp0 := sym_alength.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array)), kw_inline, tmp1, kw_doc, "Returns the length of the Java array. Works on arrays of all\n types.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(3897), kw_end_DASH_line, int(3897))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(nil, "force") + tmp4, _ := lang.FieldOrMethod(runtime.RT, "Alength") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("force is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Alength is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core_alength = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_alength.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // format + // apply { - tmp0 := sym_format.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_fmt, sym__AMP_, sym_args)), kw_doc, "Formats a string using java.lang.String.format, see java.util.Formatter for format\n string syntax", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(5717), kw_end_DASH_line, int(5717))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_apply.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_args), lang.NewVector(sym_f, sym_x, sym_args), lang.NewVector(sym_f, sym_x, sym_y, sym_args), lang.NewVector(sym_f, sym_x, sym_y, sym_z, sym_args), lang.NewVector(sym_f, sym_a, sym_b, sym_c, sym_d, sym__AMP_, sym_args)), kw_doc, "Applies fn f to the argument list formed by prepending intervening arguments to args.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(653), kw_end_DASH_line, int(653))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := lang.Apply(tmp4, []any{v3}) + tmp6 := lang.Apply(lang.Apply, []any{v2, tmp5}) + return tmp6 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + tmp7 := lang.Apply(lang.Apply, []any{v2, tmp6}) + return tmp7 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp7 := lang.Apply(tmp6, []any{v3, v4, v5}) + tmp8 := lang.Apply(lang.Apply, []any{v2, tmp7}) + return tmp8 + case 5: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp8 := lang.Apply(tmp7, []any{v3, v4, v5, v6}) + tmp9 := lang.Apply(lang.Apply, []any{v2, tmp8}) + return tmp9 default: - checkArity(args, 1) - v3 := args[0] + checkArity(args, 5) + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[1:]...) + v4 := args[2] _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_apply) - tmp6 := lang.Apply(tmp5, []any{fmt.Sprintf, v3, v4}) - return tmp6 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + var v7 any = lang.NewList(args[5:]...) + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_cons) + tmp9 := checkDerefVar(var_glojure_DOT_core_cons) + tmp10 := checkDerefVar(var_glojure_DOT_core_cons) + tmp11 := checkDerefVar(var_glojure_DOT_core_cons) + tmp12 := checkDerefVar(var_glojure_DOT_core_spread) + tmp13 := lang.Apply(tmp12, []any{v7}) + tmp14 := lang.Apply(tmp11, []any{v6, tmp13}) + tmp15 := lang.Apply(tmp10, []any{v5, tmp14}) + tmp16 := lang.Apply(tmp9, []any{v4, tmp15}) + tmp17 := lang.Apply(tmp8, []any{v3, tmp16}) + tmp18 := lang.Apply(lang.Apply, []any{v2, tmp17}) + return tmp18 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_apply = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_apply.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // frequencies + // areduce { - tmp0 := sym_frequencies.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a map from distinct items in coll to the number of times\n they appear.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(7185), kw_end_DASH_line, int(7185))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] + tmp0 := sym_areduce.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_a, sym_idx, sym_ret, sym_init, sym_expr)), kw_doc, "Reduces an expression across an array a, using an index named idx,\n and return value named ret, initialized to init, setting ret to the \n evaluation of expr at each step, returning ret.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(5289), kw_end_DASH_line, int(5289))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 7) + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) - tmp5 := checkDerefVar(var_glojure_DOT_core_reduce) - var tmp6 lang.FnFunc - tmp6 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v7 := args[0] - _ = v7 - v8 := args[1] - _ = v8 - tmp9 := checkDerefVar(var_glojure_DOT_core_assoc_BANG_) - tmp10 := checkDerefVar(var_glojure_DOT_core_inc) - tmp11 := checkDerefVar(var_glojure_DOT_core_get) - tmp12 := lang.Apply(tmp11, []any{v7, v8, int64(0)}) - tmp13 := lang.Apply(tmp10, []any{tmp12}) - tmp14 := lang.Apply(tmp9, []any{v7, v8, tmp13}) - return tmp14 - }) - tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7192), kw_column, int(12), kw_end_DASH_line, int(7193), kw_end_DASH_column, int(54)) - tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) - if err != nil { - panic(err) + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + v7 := args[5] + _ = v7 + v8 := args[6] + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_seq) + tmp10 := checkDerefVar(var_glojure_DOT_core_concat) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_glojure_DOT_core_SLASH_let}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_apply) + tmp15 := checkDerefVar(var_glojure_DOT_core_vector) + tmp16 := checkDerefVar(var_glojure_DOT_core_seq) + tmp17 := checkDerefVar(var_glojure_DOT_core_concat) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{sym_a__0__auto__}) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{v4}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{sym_l__1__auto__}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := checkDerefVar(var_glojure_DOT_core_seq) + tmp26 := checkDerefVar(var_glojure_DOT_core_concat) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{sym_glojure_DOT_core_SLASH_alength}) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{sym_a__0__auto__}) + tmp31 := lang.Apply(tmp26, []any{tmp28, tmp30}) + tmp32 := lang.Apply(tmp25, []any{tmp31}) + tmp33 := lang.Apply(tmp24, []any{tmp32}) + tmp34 := lang.Apply(tmp17, []any{tmp19, tmp21, tmp23, tmp33}) + tmp35 := lang.Apply(tmp16, []any{tmp34}) + tmp36 := lang.Apply(tmp14, []any{tmp15, tmp35}) + tmp37 := lang.Apply(tmp13, []any{tmp36}) + tmp38 := checkDerefVar(var_glojure_DOT_core_list) + tmp39 := checkDerefVar(var_glojure_DOT_core_seq) + tmp40 := checkDerefVar(var_glojure_DOT_core_concat) + tmp41 := checkDerefVar(var_glojure_DOT_core_list) + tmp42 := lang.Apply(tmp41, []any{sym_glojure_DOT_core_SLASH_loop}) + tmp43 := checkDerefVar(var_glojure_DOT_core_list) + tmp44 := checkDerefVar(var_glojure_DOT_core_apply) + tmp45 := checkDerefVar(var_glojure_DOT_core_vector) + tmp46 := checkDerefVar(var_glojure_DOT_core_seq) + tmp47 := checkDerefVar(var_glojure_DOT_core_concat) + tmp48 := checkDerefVar(var_glojure_DOT_core_list) + tmp49 := lang.Apply(tmp48, []any{v5}) + tmp50 := checkDerefVar(var_glojure_DOT_core_list) + tmp51 := lang.Apply(tmp50, []any{int64(0)}) + tmp52 := checkDerefVar(var_glojure_DOT_core_list) + tmp53 := lang.Apply(tmp52, []any{v6}) + tmp54 := checkDerefVar(var_glojure_DOT_core_list) + tmp55 := lang.Apply(tmp54, []any{v7}) + tmp56 := lang.Apply(tmp47, []any{tmp49, tmp51, tmp53, tmp55}) + tmp57 := lang.Apply(tmp46, []any{tmp56}) + tmp58 := lang.Apply(tmp44, []any{tmp45, tmp57}) + tmp59 := lang.Apply(tmp43, []any{tmp58}) + tmp60 := checkDerefVar(var_glojure_DOT_core_list) + tmp61 := checkDerefVar(var_glojure_DOT_core_seq) + tmp62 := checkDerefVar(var_glojure_DOT_core_concat) + tmp63 := checkDerefVar(var_glojure_DOT_core_list) + tmp64 := lang.Apply(tmp63, []any{sym_if}) + tmp65 := checkDerefVar(var_glojure_DOT_core_list) + tmp66 := checkDerefVar(var_glojure_DOT_core_seq) + tmp67 := checkDerefVar(var_glojure_DOT_core_concat) + tmp68 := checkDerefVar(var_glojure_DOT_core_list) + tmp69 := lang.Apply(tmp68, []any{sym_glojure_DOT_core_SLASH__LT_}) + tmp70 := checkDerefVar(var_glojure_DOT_core_list) + tmp71 := lang.Apply(tmp70, []any{v5}) + tmp72 := checkDerefVar(var_glojure_DOT_core_list) + tmp73 := lang.Apply(tmp72, []any{sym_l__1__auto__}) + tmp74 := lang.Apply(tmp67, []any{tmp69, tmp71, tmp73}) + tmp75 := lang.Apply(tmp66, []any{tmp74}) + tmp76 := lang.Apply(tmp65, []any{tmp75}) + tmp77 := checkDerefVar(var_glojure_DOT_core_list) + tmp78 := checkDerefVar(var_glojure_DOT_core_seq) + tmp79 := checkDerefVar(var_glojure_DOT_core_concat) + tmp80 := checkDerefVar(var_glojure_DOT_core_list) + tmp81 := lang.Apply(tmp80, []any{sym_recur}) + tmp82 := checkDerefVar(var_glojure_DOT_core_list) + tmp83 := checkDerefVar(var_glojure_DOT_core_seq) + tmp84 := checkDerefVar(var_glojure_DOT_core_concat) + tmp85 := checkDerefVar(var_glojure_DOT_core_list) + tmp86 := lang.Apply(tmp85, []any{sym_glojure_DOT_core_SLASH_unchecked_DASH_inc_DASH_int}) + tmp87 := checkDerefVar(var_glojure_DOT_core_list) + tmp88 := lang.Apply(tmp87, []any{v5}) + tmp89 := lang.Apply(tmp84, []any{tmp86, tmp88}) + tmp90 := lang.Apply(tmp83, []any{tmp89}) + tmp91 := lang.Apply(tmp82, []any{tmp90}) + tmp92 := checkDerefVar(var_glojure_DOT_core_list) + tmp93 := lang.Apply(tmp92, []any{v8}) + tmp94 := lang.Apply(tmp79, []any{tmp81, tmp91, tmp93}) + tmp95 := lang.Apply(tmp78, []any{tmp94}) + tmp96 := lang.Apply(tmp77, []any{tmp95}) + tmp97 := checkDerefVar(var_glojure_DOT_core_list) + tmp98 := lang.Apply(tmp97, []any{v6}) + tmp99 := lang.Apply(tmp62, []any{tmp64, tmp76, tmp96, tmp98}) + tmp100 := lang.Apply(tmp61, []any{tmp99}) + tmp101 := lang.Apply(tmp60, []any{tmp100}) + tmp102 := lang.Apply(tmp40, []any{tmp42, tmp59, tmp101}) + tmp103 := lang.Apply(tmp39, []any{tmp102}) + tmp104 := lang.Apply(tmp38, []any{tmp103}) + tmp105 := lang.Apply(tmp10, []any{tmp12, tmp37, tmp104}) + tmp106 := lang.Apply(tmp9, []any{tmp105}) + return tmp106 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_areduce = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_areduce.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // array + { + tmp0 := sym_array.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(3457), kw_column, int(7), kw_end_DASH_line, int(3458), kw_end_DASH_column, int(7), kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_items)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_into_DASH_array) + tmp4 := lang.Apply(tmp3, []any{v2}) + return tmp4 } - tmp9 := checkDerefVar(var_glojure_DOT_core_transient) - tmp10 := lang.NewMap() - tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7194), kw_column, int(23), kw_end_DASH_line, int(7194), kw_end_DASH_column, int(24)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) - if err != nil { - panic(err) + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_array = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_array.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // assert + { + tmp0 := sym_assert.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_message)), kw_doc, "Evaluates expression x and throws an AssertionError with optional\n message if x does not evaluate to logical true.\n\n Assertion checks are omitted from compiled code if '*assert*' is\n false.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(11), kw_line, int(4837), kw_end_DASH_line, int(4837))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_assert_STAR_) + if lang.IsTruthy(tmp6) { + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_core_SLASH_when_DASH_not}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{v4}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{sym_throw}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := checkDerefVar(var_glojure_DOT_core_seq) + tmp20 := checkDerefVar(var_glojure_DOT_core_concat) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{sym_new}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := lang.Apply(tmp23, []any{sym_glojure_DOT_core_SLASH_AssertionError}) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := checkDerefVar(var_glojure_DOT_core_seq) + tmp27 := checkDerefVar(var_glojure_DOT_core_concat) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := lang.Apply(tmp28, []any{sym_glojure_DOT_core_SLASH_str}) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := lang.Apply(tmp30, []any{"Assert failed: "}) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := checkDerefVar(var_glojure_DOT_core_seq) + tmp34 := checkDerefVar(var_glojure_DOT_core_concat) + tmp35 := checkDerefVar(var_glojure_DOT_core_list) + tmp36 := lang.Apply(tmp35, []any{sym_glojure_DOT_core_SLASH_pr_DASH_str}) + tmp37 := checkDerefVar(var_glojure_DOT_core_list) + tmp38 := checkDerefVar(var_glojure_DOT_core_seq) + tmp39 := checkDerefVar(var_glojure_DOT_core_concat) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{sym_quote}) + tmp42 := checkDerefVar(var_glojure_DOT_core_list) + tmp43 := lang.Apply(tmp42, []any{v4}) + tmp44 := lang.Apply(tmp39, []any{tmp41, tmp43}) + tmp45 := lang.Apply(tmp38, []any{tmp44}) + tmp46 := lang.Apply(tmp37, []any{tmp45}) + tmp47 := lang.Apply(tmp34, []any{tmp36, tmp46}) + tmp48 := lang.Apply(tmp33, []any{tmp47}) + tmp49 := lang.Apply(tmp32, []any{tmp48}) + tmp50 := lang.Apply(tmp27, []any{tmp29, tmp31, tmp49}) + tmp51 := lang.Apply(tmp26, []any{tmp50}) + tmp52 := lang.Apply(tmp25, []any{tmp51}) + tmp53 := lang.Apply(tmp20, []any{tmp22, tmp24, tmp52}) + tmp54 := lang.Apply(tmp19, []any{tmp53}) + tmp55 := lang.Apply(tmp18, []any{tmp54}) + tmp56 := lang.Apply(tmp15, []any{tmp17, tmp55}) + tmp57 := lang.Apply(tmp14, []any{tmp56}) + tmp58 := lang.Apply(tmp13, []any{tmp57}) + tmp59 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp58}) + tmp60 := lang.Apply(tmp7, []any{tmp59}) + tmp5 = tmp60 + } else { + } + return tmp5 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_assert_STAR_) + if lang.IsTruthy(tmp7) { + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_when_DASH_not}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v4}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_throw}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{sym_new}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{sym_glojure_DOT_core_SLASH_AssertionError}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := checkDerefVar(var_glojure_DOT_core_seq) + tmp28 := checkDerefVar(var_glojure_DOT_core_concat) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{sym_glojure_DOT_core_SLASH_str}) + tmp31 := checkDerefVar(var_glojure_DOT_core_list) + tmp32 := lang.Apply(tmp31, []any{"Assert failed: "}) + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{v5}) + tmp35 := checkDerefVar(var_glojure_DOT_core_list) + tmp36 := lang.Apply(tmp35, []any{"\n"}) + tmp37 := checkDerefVar(var_glojure_DOT_core_list) + tmp38 := checkDerefVar(var_glojure_DOT_core_seq) + tmp39 := checkDerefVar(var_glojure_DOT_core_concat) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{sym_glojure_DOT_core_SLASH_pr_DASH_str}) + tmp42 := checkDerefVar(var_glojure_DOT_core_list) + tmp43 := checkDerefVar(var_glojure_DOT_core_seq) + tmp44 := checkDerefVar(var_glojure_DOT_core_concat) + tmp45 := checkDerefVar(var_glojure_DOT_core_list) + tmp46 := lang.Apply(tmp45, []any{sym_quote}) + tmp47 := checkDerefVar(var_glojure_DOT_core_list) + tmp48 := lang.Apply(tmp47, []any{v4}) + tmp49 := lang.Apply(tmp44, []any{tmp46, tmp48}) + tmp50 := lang.Apply(tmp43, []any{tmp49}) + tmp51 := lang.Apply(tmp42, []any{tmp50}) + tmp52 := lang.Apply(tmp39, []any{tmp41, tmp51}) + tmp53 := lang.Apply(tmp38, []any{tmp52}) + tmp54 := lang.Apply(tmp37, []any{tmp53}) + tmp55 := lang.Apply(tmp28, []any{tmp30, tmp32, tmp34, tmp36, tmp54}) + tmp56 := lang.Apply(tmp27, []any{tmp55}) + tmp57 := lang.Apply(tmp26, []any{tmp56}) + tmp58 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp57}) + tmp59 := lang.Apply(tmp20, []any{tmp58}) + tmp60 := lang.Apply(tmp19, []any{tmp59}) + tmp61 := lang.Apply(tmp16, []any{tmp18, tmp60}) + tmp62 := lang.Apply(tmp15, []any{tmp61}) + tmp63 := lang.Apply(tmp14, []any{tmp62}) + tmp64 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp63}) + tmp65 := lang.Apply(tmp8, []any{tmp64}) + tmp6 = tmp65 + } else { + } + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") } - tmp13 := lang.Apply(tmp9, []any{tmp12}) - tmp14 := lang.Apply(tmp5, []any{tmp8, tmp13, v3}) - tmp15 := lang.Apply(tmp4, []any{tmp14}) - return tmp15 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_assert = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_assert.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // future + // assert-args { - tmp0 := sym_future.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_body)), kw_doc, "Takes a body of expressions and yields a future object that will\n invoke the body in another thread, and will cache the result and\n return it on all subsequent calls to deref/@. If the computation has\n not yet finished, calls to deref/@ will block, unless the variant of\n deref with timeout is used. See also - realized?.", kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(11), kw_line, int(7009), kw_end_DASH_line, int(7009))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_assert_DASH_args.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_pairs)), kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(38), kw_column, int(11), kw_line, int(1830), kw_end_DASH_line, int(1830), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: checkArity(args, 2) - v3 := args[0] + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + var v4 any = lang.NewList(args[2:]...) _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - tmp6 := checkDerefVar(var_glojure_DOT_core_seq) - tmp7 := checkDerefVar(var_glojure_DOT_core_concat) - tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_future_DASH_call}) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := checkDerefVar(var_glojure_DOT_core_seq) - tmp12 := checkDerefVar(var_glojure_DOT_core_concat) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_fn_STAR_}) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := checkDerefVar(var_glojure_DOT_core_apply) - tmp17 := checkDerefVar(var_glojure_DOT_core_vector) - tmp18 := checkDerefVar(var_glojure_DOT_core_seq) - tmp19 := checkDerefVar(var_glojure_DOT_core_concat) - tmp20 := lang.Apply(tmp19, nil) - tmp21 := lang.Apply(tmp18, []any{tmp20}) - tmp22 := lang.Apply(tmp16, []any{tmp17, tmp21}) - tmp23 := lang.Apply(tmp15, []any{tmp22}) - tmp24 := lang.Apply(tmp12, []any{tmp14, tmp23, v5}) - tmp25 := lang.Apply(tmp11, []any{tmp24}) - tmp26 := lang.Apply(tmp10, []any{tmp25}) - tmp27 := lang.Apply(tmp7, []any{tmp9, tmp26}) - tmp28 := lang.Apply(tmp6, []any{tmp27}) - return tmp28 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym_do}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := checkDerefVar(var_glojure_DOT_core_seq) + tmp11 := checkDerefVar(var_glojure_DOT_core_concat) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_glojure_DOT_core_SLASH_when_DASH_not}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_first) + tmp16 := lang.Apply(tmp15, []any{v4}) + tmp17 := lang.Apply(tmp14, []any{tmp16}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := checkDerefVar(var_glojure_DOT_core_seq) + tmp20 := checkDerefVar(var_glojure_DOT_core_concat) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{sym_throw}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_seq) + tmp25 := checkDerefVar(var_glojure_DOT_core_concat) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_NewIllegalArgumentError}) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := checkDerefVar(var_glojure_DOT_core_seq) + tmp30 := checkDerefVar(var_glojure_DOT_core_concat) + tmp31 := checkDerefVar(var_glojure_DOT_core_list) + tmp32 := lang.Apply(tmp31, []any{sym_glojure_DOT_core_SLASH_str}) + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := checkDerefVar(var_glojure_DOT_core_seq) + tmp35 := checkDerefVar(var_glojure_DOT_core_concat) + tmp36 := checkDerefVar(var_glojure_DOT_core_list) + tmp37 := lang.Apply(tmp36, []any{sym_glojure_DOT_core_SLASH_first}) + tmp38 := checkDerefVar(var_glojure_DOT_core_list) + tmp39 := lang.Apply(tmp38, []any{sym__AMP_form}) + tmp40 := lang.Apply(tmp35, []any{tmp37, tmp39}) + tmp41 := lang.Apply(tmp34, []any{tmp40}) + tmp42 := lang.Apply(tmp33, []any{tmp41}) + tmp43 := checkDerefVar(var_glojure_DOT_core_list) + tmp44 := lang.Apply(tmp43, []any{" requires "}) + tmp45 := checkDerefVar(var_glojure_DOT_core_list) + tmp46 := checkDerefVar(var_glojure_DOT_core_second) + tmp47 := lang.Apply(tmp46, []any{v4}) + tmp48 := lang.Apply(tmp45, []any{tmp47}) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) + tmp50 := lang.Apply(tmp49, []any{" in "}) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := lang.Apply(tmp51, []any{sym__STAR_ns_STAR_}) + tmp53 := checkDerefVar(var_glojure_DOT_core_list) + tmp54 := lang.Apply(tmp53, []any{":"}) + tmp55 := checkDerefVar(var_glojure_DOT_core_list) + tmp56 := checkDerefVar(var_glojure_DOT_core_seq) + tmp57 := checkDerefVar(var_glojure_DOT_core_concat) + tmp58 := checkDerefVar(var_glojure_DOT_core_list) + tmp59 := lang.Apply(tmp58, []any{kw_line}) + tmp60 := checkDerefVar(var_glojure_DOT_core_list) + tmp61 := checkDerefVar(var_glojure_DOT_core_seq) + tmp62 := checkDerefVar(var_glojure_DOT_core_concat) + tmp63 := checkDerefVar(var_glojure_DOT_core_list) + tmp64 := lang.Apply(tmp63, []any{sym_glojure_DOT_core_SLASH_meta}) + tmp65 := checkDerefVar(var_glojure_DOT_core_list) + tmp66 := lang.Apply(tmp65, []any{sym__AMP_form}) + tmp67 := lang.Apply(tmp62, []any{tmp64, tmp66}) + tmp68 := lang.Apply(tmp61, []any{tmp67}) + tmp69 := lang.Apply(tmp60, []any{tmp68}) + tmp70 := lang.Apply(tmp57, []any{tmp59, tmp69}) + tmp71 := lang.Apply(tmp56, []any{tmp70}) + tmp72 := lang.Apply(tmp55, []any{tmp71}) + tmp73 := lang.Apply(tmp30, []any{tmp32, tmp42, tmp44, tmp48, tmp50, tmp52, tmp54, tmp72}) + tmp74 := lang.Apply(tmp29, []any{tmp73}) + tmp75 := lang.Apply(tmp28, []any{tmp74}) + tmp76 := lang.Apply(tmp25, []any{tmp27, tmp75}) + tmp77 := lang.Apply(tmp24, []any{tmp76}) + tmp78 := lang.Apply(tmp23, []any{tmp77}) + tmp79 := lang.Apply(tmp20, []any{tmp22, tmp78}) + tmp80 := lang.Apply(tmp19, []any{tmp79}) + tmp81 := lang.Apply(tmp18, []any{tmp80}) + tmp82 := lang.Apply(tmp11, []any{tmp13, tmp17, tmp81}) + tmp83 := lang.Apply(tmp10, []any{tmp82}) + tmp84 := lang.Apply(tmp9, []any{tmp83}) + tmp85 := checkDerefVar(var_glojure_DOT_core_list) + var tmp86 any + { // let + // let binding "more" + tmp87 := checkDerefVar(var_glojure_DOT_core_nnext) + tmp88 := lang.Apply(tmp87, []any{v4}) + var v89 any = tmp88 + _ = v89 + var tmp90 any + if lang.IsTruthy(v89) { + tmp91 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp92 := lang.Apply(tmp91, []any{sym_glojure_DOT_core_SLASH_assert_DASH_args, v89}) + tmp90 = tmp92 + } else { + } + tmp86 = tmp90 + } // end let + tmp87 := lang.Apply(tmp85, []any{tmp86}) + tmp88 := lang.Apply(tmp6, []any{tmp8, tmp84, tmp87}) + tmp89 := lang.Apply(tmp5, []any{tmp88}) + return tmp89 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_assert_DASH_args = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_assert_DASH_args.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // future-call + // assoc-in { - tmp0 := sym_future_DASH_call.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f)), kw_doc, "Takes a function of no args and yields a future object that will\n invoke the function in another thread, and will cache the result and\n return it on all subsequent calls to deref/@. If the computation has\n not yet finished, calls to deref/@ will block, unless the variant\n of deref with timeout is used. See also - realized?.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(7003), kw_end_DASH_line, int(7003))).(*lang.Symbol) + tmp0 := sym_assoc_DASH_in.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m, lang.NewVector(sym_k, sym__AMP_, sym_ks), sym_v)), kw_doc, "Associates a value in a nested associative structure, where ks is a\n sequence of keys and v is the new value and returns a new nested structure.\n If any levels do not exist, hash-maps will be created.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(6147), kw_end_DASH_line, int(6147))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + { // let + // let binding "vec__138" + var v6 any = v3 + _ = v6 + // let binding "seq__139" + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := lang.Apply(tmp7, []any{v6}) + var v9 any = tmp8 + _ = v9 + // let binding "first__140" + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v9}) + var v12 any = tmp11 + _ = v12 + // let binding "seq__139" + tmp13 := checkDerefVar(var_glojure_DOT_core_next) + tmp14 := lang.Apply(tmp13, []any{v9}) + var v15 any = tmp14 + _ = v15 + // let binding "k" + var v16 any = v12 + _ = v16 + // let binding "ks" + var v17 any = v15 + _ = v17 + var tmp18 any + if lang.IsTruthy(v17) { + tmp19 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp20 := checkDerefVar(var_glojure_DOT_core_assoc_DASH_in) + tmp21 := checkDerefVar(var_glojure_DOT_core_get) + tmp22 := lang.Apply(tmp21, []any{v2, v16}) + tmp23 := lang.Apply(tmp20, []any{tmp22, v17, v4}) + tmp24 := lang.Apply(tmp19, []any{v2, v16, tmp23}) + tmp18 = tmp24 + } else { + tmp25 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp26 := lang.Apply(tmp25, []any{v2, v16, v4}) + tmp18 = tmp26 + } + tmp5 = tmp18 + } // end let + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_assoc_DASH_in = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_assoc_DASH_in.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bigdec + { + tmp1 := reflect.TypeOf((*lang.BigDecimal)(nil)) + tmp0 := sym_bigdec.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Coerce to BigDecimal", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(3648), kw_end_DASH_line, int(3648))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) v3 := args[0] _ = v3 var tmp4 any - { // let - // let binding "f" - tmp5 := checkDerefVar(var_glojure_DOT_core_binding_DASH_conveyor_DASH_fn) - tmp6 := lang.Apply(tmp5, []any{v3}) - var v7 any = tmp6 - _ = v7 - // let binding "fut" - tmp8 := lang.Apply(lang.AgentSubmit, []any{v7}) - var v9 any = tmp8 - _ = v9 - tmp4 = v9 - } // end let + tmp5 := checkDerefVar(var_glojure_DOT_core_decimal_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + tmp4 = v3 + } else { + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core_float_QMARK_) + tmp9 := lang.Apply(tmp8, []any{v3}) + if lang.IsTruthy(tmp9) { + tmp10 := checkDerefVar(var_glojure_DOT_core_double) + tmp11 := lang.Apply(tmp10, []any{v3}) + tmp12 := lang.Apply(lang.NewBigDecimalFromFloat64, []any{tmp11}) + tmp7 = tmp12 + } else { + var tmp13 any + tmp14 := checkDerefVar(var_glojure_DOT_core_ratio_QMARK_) + tmp15 := lang.Apply(tmp14, []any{v3}) + if lang.IsTruthy(tmp15) { + tmp16 := checkDerefVar(var_glojure_DOT_core__SLASH_) + tmp17 := lang.Apply(lang.NewBigDecimalFromRatio, []any{v3}) + tmp18, ok := lang.FieldOrMethod(v3, "denominator") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "denominator"))) + } + var tmp19 any + switch reflect.TypeOf(tmp18).Kind() { + case reflect.Func: + tmp19 = lang.Apply(tmp18, nil) + default: + tmp19 = tmp18 + } + tmp20 := lang.Apply(tmp16, []any{tmp17, tmp19}) + tmp13 = tmp20 + } else { + var tmp21 any + tmp22 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp23 := reflect.TypeOf((*lang.BigInt)(nil)) + tmp24 := lang.Apply(tmp22, []any{tmp23, v3}) + if lang.IsTruthy(tmp24) { + tmp25, ok := lang.FieldOrMethod(v3, "toBigDecimal") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "toBigDecimal"))) + } + var tmp26 any + switch reflect.TypeOf(tmp25).Kind() { + case reflect.Func: + tmp26 = lang.Apply(tmp25, nil) + default: + tmp26 = tmp25 + } + tmp21 = tmp26 + } else { + var tmp27 any + tmp28 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp29 := reflect.TypeOf((*big9.Int)(nil)) + tmp30 := lang.Apply(tmp28, []any{tmp29, v3}) + if lang.IsTruthy(tmp30) { + tmp31 := lang.Apply(lang.NewBigDecimal, []any{v3}) + tmp27 = tmp31 + } else { + var tmp32 any + tmp33 := checkDerefVar(var_glojure_DOT_core_number_QMARK_) + tmp34 := lang.Apply(tmp33, []any{v3}) + if lang.IsTruthy(tmp34) { + tmp35 := checkDerefVar(var_glojure_DOT_core_long) + tmp36 := lang.Apply(tmp35, []any{v3}) + tmp37 := lang.Apply(lang.NewBigDecimalFromInt64, []any{tmp36}) + tmp32 = tmp37 + } else { + var tmp38 any + if lang.IsTruthy(kw_else) { + tmp39 := lang.Apply(lang.NewBigDecimal, []any{v3}) + tmp38 = tmp39 + } else { + } + tmp32 = tmp38 + } + tmp27 = tmp32 + } + tmp21 = tmp27 + } + tmp13 = tmp21 + } + tmp7 = tmp13 + } + tmp4 = tmp7 + } + return tmp4 + }) + tmp3 := reflect.TypeOf((*lang.BigDecimal)(nil)) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_bigdec = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bigdec.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bigint + { + tmp1 := reflect.TypeOf((*lang.BigInt)(nil)) + tmp0 := sym_bigint.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Coerce to BigInt", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(3620), kw_end_DASH_line, int(3620))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp6 := reflect.TypeOf((*lang.BigInt)(nil)) + tmp7 := lang.Apply(tmp5, []any{tmp6, v3}) + if lang.IsTruthy(tmp7) { + tmp4 = v3 + } else { + var tmp8 any + tmp9 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp10 := reflect.TypeOf((*big9.Int)(nil)) + tmp11 := lang.Apply(tmp9, []any{tmp10, v3}) + if lang.IsTruthy(tmp11) { + tmp12 := lang.Apply(lang.NewBigIntFromGoBigInt, []any{v3}) + tmp8 = tmp12 + } else { + var tmp13 any + tmp14 := checkDerefVar(var_glojure_DOT_core_decimal_QMARK_) + tmp15 := lang.Apply(tmp14, []any{v3}) + if lang.IsTruthy(tmp15) { + tmp16 := checkDerefVar(var_glojure_DOT_core_bigint) + tmp17, ok := lang.FieldOrMethod(v3, "toBigInteger") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "toBigInteger"))) + } + var tmp18 any + switch reflect.TypeOf(tmp17).Kind() { + case reflect.Func: + tmp18 = lang.Apply(tmp17, nil) + default: + tmp18 = tmp17 + } + tmp19 := lang.Apply(tmp16, []any{tmp18}) + tmp13 = tmp19 + } else { + var tmp20 any + tmp21 := checkDerefVar(var_glojure_DOT_core_float_QMARK_) + tmp22 := lang.Apply(tmp21, []any{v3}) + if lang.IsTruthy(tmp22) { + tmp23 := checkDerefVar(var_glojure_DOT_core_bigint) + tmp24 := checkDerefVar(var_glojure_DOT_core_double) + tmp25 := lang.Apply(tmp24, []any{v3}) + tmp26 := lang.Apply(lang.NewBigDecimalFromFloat64, []any{tmp25}) + tmp27 := lang.Apply(tmp23, []any{tmp26}) + tmp20 = tmp27 + } else { + var tmp28 any + tmp29 := checkDerefVar(var_glojure_DOT_core_ratio_QMARK_) + tmp30 := lang.Apply(tmp29, []any{v3}) + if lang.IsTruthy(tmp30) { + tmp31 := checkDerefVar(var_glojure_DOT_core_bigint) + tmp32, ok := lang.FieldOrMethod(v3, "bigIntegerValue") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "bigIntegerValue"))) + } + var tmp33 any + switch reflect.TypeOf(tmp32).Kind() { + case reflect.Func: + tmp33 = lang.Apply(tmp32, nil) + default: + tmp33 = tmp32 + } + tmp34 := lang.Apply(tmp31, []any{tmp33}) + tmp28 = tmp34 + } else { + var tmp35 any + tmp36 := checkDerefVar(var_glojure_DOT_core_number_QMARK_) + tmp37 := lang.Apply(tmp36, []any{v3}) + if lang.IsTruthy(tmp37) { + tmp38 := checkDerefVar(var_glojure_DOT_core_long) + tmp39 := lang.Apply(tmp38, []any{v3}) + tmp40 := lang.Apply(lang.NewBigIntFromInt64, []any{tmp39}) + tmp35 = tmp40 + } else { + var tmp41 any + if lang.IsTruthy(kw_else) { + tmp42 := checkDerefVar(var_glojure_DOT_core_bigint) + tmp43 := lang.Apply(lang.NewBigInt, []any{v3}) + tmp44 := lang.Apply(tmp42, []any{tmp43}) + tmp41 = tmp44 + } else { + } + tmp35 = tmp41 + } + tmp28 = tmp35 + } + tmp20 = tmp28 + } + tmp13 = tmp20 + } + tmp8 = tmp13 + } + tmp4 = tmp8 + } return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp3 := reflect.TypeOf((*lang.BigInt)(nil)) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_bigint = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_bigint.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // future-cancel + // biginteger { - tmp0 := sym_future_DASH_cancel.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f)), kw_doc, "Cancels the future, if possible.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(7019), kw_end_DASH_line, int(7019))).(*lang.Symbol) + tmp1 := reflect.TypeOf((*big9.Int)(nil)) + tmp0 := sym_biginteger.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Coerce to BigInteger", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(3634), kw_end_DASH_line, int(3634))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(v3, "cancel") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("cancel is not a function"))) + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp6 := reflect.TypeOf((*big9.Int)(nil)) + tmp7 := lang.Apply(tmp5, []any{tmp6, v3}) + if lang.IsTruthy(tmp7) { + tmp4 = v3 + } else { + var tmp8 any + tmp9 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp10 := reflect.TypeOf((*lang.BigInt)(nil)) + tmp11 := lang.Apply(tmp9, []any{tmp10, v3}) + if lang.IsTruthy(tmp11) { + tmp12, ok := lang.FieldOrMethod(v3, "toBigInteger") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "toBigInteger"))) + } + var tmp13 any + switch reflect.TypeOf(tmp12).Kind() { + case reflect.Func: + tmp13 = lang.Apply(tmp12, nil) + default: + tmp13 = tmp12 + } + tmp8 = tmp13 + } else { + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core_decimal_QMARK_) + tmp16 := lang.Apply(tmp15, []any{v3}) + if lang.IsTruthy(tmp16) { + tmp17, ok := lang.FieldOrMethod(v3, "toBigInteger") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "toBigInteger"))) + } + var tmp18 any + switch reflect.TypeOf(tmp17).Kind() { + case reflect.Func: + tmp18 = lang.Apply(tmp17, nil) + default: + tmp18 = tmp17 + } + tmp14 = tmp18 + } else { + var tmp19 any + tmp20 := checkDerefVar(var_glojure_DOT_core_float_QMARK_) + tmp21 := lang.Apply(tmp20, []any{v3}) + if lang.IsTruthy(tmp21) { + tmp22 := checkDerefVar(var_glojure_DOT_core_double) + tmp23 := lang.Apply(tmp22, []any{v3}) + tmp24 := lang.Apply(lang.NewBigDecimalFromFloat64, []any{tmp23}) + tmp25, ok := lang.FieldOrMethod(tmp24, "toBigInteger") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp24, "toBigInteger"))) + } + var tmp26 any + switch reflect.TypeOf(tmp25).Kind() { + case reflect.Func: + tmp26 = lang.Apply(tmp25, nil) + default: + tmp26 = tmp25 + } + tmp19 = tmp26 + } else { + var tmp27 any + tmp28 := checkDerefVar(var_glojure_DOT_core_ratio_QMARK_) + tmp29 := lang.Apply(tmp28, []any{v3}) + if lang.IsTruthy(tmp29) { + tmp30, ok := lang.FieldOrMethod(v3, "bigIntegerValue") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "bigIntegerValue"))) + } + var tmp31 any + switch reflect.TypeOf(tmp30).Kind() { + case reflect.Func: + tmp31 = lang.Apply(tmp30, nil) + default: + tmp31 = tmp30 + } + tmp27 = tmp31 + } else { + var tmp32 any + tmp33 := checkDerefVar(var_glojure_DOT_core_number_QMARK_) + tmp34 := lang.Apply(tmp33, []any{v3}) + if lang.IsTruthy(tmp34) { + tmp35 := checkDerefVar(var_glojure_DOT_core_long) + tmp36 := lang.Apply(tmp35, []any{v3}) + tmp37 := lang.Apply(big9.NewInt, []any{tmp36}) + tmp32 = tmp37 + } else { + var tmp38 any + if lang.IsTruthy(kw_else) { + tmp39 := lang.Apply(lang.NewBigInt, []any{v3}) + tmp38 = tmp39 + } else { + } + tmp32 = tmp38 + } + tmp27 = tmp32 + } + tmp19 = tmp27 + } + tmp14 = tmp19 + } + tmp8 = tmp14 + } + tmp4 = tmp8 } - tmp5 := lang.Apply(tmp4, []any{true}) - return tmp5 + return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp3 := reflect.TypeOf((*big9.Int)(nil)) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_biginteger = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_biginteger.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // future-cancelled? + // binding-conveyor-fn { - tmp0 := sym_future_DASH_cancelled_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f)), kw_doc, "Returns true if future f is cancelled", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(7), kw_line, int(7025), kw_end_DASH_line, int(7025))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_binding_DASH_conveyor_DASH_fn.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f)), kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(25), kw_column, int(7), kw_line, int(2020), kw_end_DASH_line, int(2020), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4, ok := lang.FieldOrMethod(v3, "isCancelled") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "isCancelled"))) - } - var tmp5 any - switch reflect.TypeOf(tmp4).Kind() { - case reflect.Func: - tmp5 = lang.Apply(tmp4, nil) - default: - tmp5 = tmp4 - } - return tmp5 + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "frame" + tmp4 := lang.Apply(lang.CloneThreadBindingFrame, nil) + var v5 any = tmp4 + _ = v5 + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp7 := lang.Apply(lang.ResetThreadBindingFrame, []any{v5}) + _ = tmp7 + tmp8 := lang.Apply(v2, nil) + return tmp8 + case 1: + v7 := args[0] + _ = v7 + tmp8 := lang.Apply(lang.ResetThreadBindingFrame, []any{v5}) + _ = tmp8 + tmp9 := lang.Apply(v2, []any{v7}) + return tmp9 + case 2: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + tmp9 := lang.Apply(lang.ResetThreadBindingFrame, []any{v5}) + _ = tmp9 + tmp10 := lang.Apply(v2, []any{v7, v8}) + return tmp10 + case 3: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + tmp10 := lang.Apply(lang.ResetThreadBindingFrame, []any{v5}) + _ = tmp10 + tmp11 := lang.Apply(v2, []any{v7, v8, v9}) + return tmp11 + default: + checkArity(args, 3) + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + var v10 any = lang.NewList(args[3:]...) + _ = v10 + tmp11 := lang.Apply(lang.ResetThreadBindingFrame, []any{v5}) + _ = tmp11 + tmp12 := checkDerefVar(var_glojure_DOT_core_apply) + tmp13 := lang.Apply(tmp12, []any{v2, v7, v8, v9, v10}) + return tmp13 + } + }) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2025), kw_column, int(5), kw_end_DASH_line, int(2040), kw_end_DASH_column, int(31)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp3 = tmp8 + } // end let + return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_binding_DASH_conveyor_DASH_fn = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_binding_DASH_conveyor_DASH_fn.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // future-done? + // bit-and { - tmp0 := sym_future_DASH_done_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f)), kw_doc, "Returns true if future f is done", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(6538), kw_end_DASH_line, int(6538))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4, ok := lang.FieldOrMethod(v3, "isDone") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "isDone"))) - } - var tmp5 any - switch reflect.TypeOf(tmp4).Kind() { - case reflect.Func: - tmp5 = lang.Apply(tmp4, nil) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed29 + } else { + tmp4 = closed29 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed29 + } else { + tmp5 = closed29 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 default: - tmp5 = tmp4 + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed29 + } else { + tmp6 = closed29 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 } - return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // future? - { - tmp0 := sym_future_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x is a future", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(6532), kw_end_DASH_line, int(6532))).(*lang.Symbol) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp5 := lang.Apply(tmp4, []any{nil, v3}) + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // gen-class - { - tmp0 := sym_gen_DASH_class.WithMeta(lang.NewMap()).(*lang.Symbol) - tmp1 := ns.Intern(tmp0) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // gensym - { - tmp0 := sym_gensym.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_prefix_DASH_string)), kw_doc, "Returns a new symbol with a unique name. If a prefix string is\n supplied, the name is prefix# where # is some unique number. If\n prefix is not supplied, the prefix is 'G__'.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(599), kw_end_DASH_line, int(599))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_bit_DASH_and.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Bitwise and", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(1298), kw_end_DASH_line, int(1298))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 0: - tmp3 := checkDerefVar(var_glojure_DOT_core_gensym) - tmp4 := lang.Apply(tmp3, []any{"G__"}) - return tmp4 - case 1: - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_str) - tmp5 := checkDerefVar(var_glojure_DOT_core_str) - tmp6, _ := lang.FieldOrMethod(runtime.RT, "NextID") + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "And") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("NextID is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("And is not a function"))) } - tmp7 := lang.Apply(tmp6, []any{}) - tmp8 := lang.Apply(tmp5, []any{tmp7}) - tmp9 := lang.Apply(tmp4, []any{v3, tmp8}) - tmp10 := lang.Apply(lang.NewSymbol, []any{tmp9}) - return tmp10 + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 default: - checkArity(args, -1) - panic("unreachable") + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp8 := checkDerefVar(var_glojure_DOT_core_bit_DASH_and) + tmp9 := checkDerefVar(var_glojure_DOT_core_bit_DASH_and) + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) + return tmp11 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bit_DASH_and = ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_bit_DASH_and.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // get + // bit-and-not { var tmp1 lang.FnFunc - { // function get__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - tmp6 := checkDerefVar(var_glojure_DOT_core_seq) - tmp7 := checkDerefVar(var_glojure_DOT_core_concat) - tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{sym__DOT_}) + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed30 + } else { + tmp4 = closed30 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed30 + } else { + tmp5 = closed30 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed30 + } else { + tmp6 = closed30 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } tmp13 := checkDerefVar(var_glojure_DOT_core_seq) tmp14 := checkDerefVar(var_glojure_DOT_core_concat) tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_Get}) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{v3}) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp19 := checkDerefVar(var_glojure_DOT_core_list) - tmp20 := lang.Apply(tmp19, []any{v4}) - tmp21 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp20, v5}) - tmp22 := lang.Apply(tmp13, []any{tmp21}) - tmp23 := lang.Apply(tmp12, []any{tmp22}) - tmp24 := lang.Apply(tmp7, []any{tmp9, tmp11, tmp23}) - tmp25 := lang.Apply(tmp6, []any{tmp24}) - return tmp25 - } - }) - v2 = tmp1 - _ = v2 - } - tmp0 := sym_get.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_map, sym_key), lang.NewVector(sym_map, sym_key, sym_not_DASH_found)), kw_inline, tmp1, kw_doc, "Returns the value mapped to key, not-found or nil if key not present\n in associative collection, set, string, array, or ILookup instance.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2), int64(3)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(1489), kw_end_DASH_line, int(1489))).(*lang.Symbol) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym_bit_DASH_and_DASH_not.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Bitwise and with complement", kw_static, true, kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(1325), kw_end_DASH_line, int(1325))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -26039,517 +20480,302 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6 := lang.Apply(lang.Get, []any{v4, v5}) - return tmp6 - case 3: + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "AndNot") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("AndNot is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + checkArity(args, 2) v4 := args[0] _ = v4 v5 := args[1] _ = v5 - v6 := args[2] + var v6 any = lang.NewList(args[2:]...) _ = v6 - tmp7 := lang.Apply(lang.GetDefault, []any{v4, v5, v6}) - return tmp7 - default: - checkArity(args, -1) - panic("unreachable") + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp8 := checkDerefVar(var_glojure_DOT_core_bit_DASH_and_DASH_not) + tmp9 := checkDerefVar(var_glojure_DOT_core_bit_DASH_and_DASH_not) + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) + return tmp11 } }) tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + var_glojure_DOT_core_bit_DASH_and_DASH_not = ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_bit_DASH_and_DASH_not.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // get-in + // bit-not { - tmp0 := sym_get_DASH_in.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m, sym_ks), lang.NewVector(sym_m, sym_ks, sym_not_DASH_found)), kw_doc, "Returns the value in a nested associative structure,\n where ks is a sequence of keys. Returns nil if the key\n is not present, or the not-found value if supplied.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(6128), kw_end_DASH_line, int(6128))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_reduce1) - tmp6 := checkDerefVar(var_glojure_DOT_core_get) - tmp7 := lang.Apply(tmp5, []any{tmp6, v3, v4}) - return tmp7 - case 3: + var tmp1 lang.FnFunc + { // function bit-not__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) v3 := args[0] _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var tmp6 any - { // let - // let binding "sentinel" - tmp7 := lang.Apply(reflect.StructOf, []any{nil}) - tmp8 := lang.Apply(reflect.New, []any{tmp7}) - tmp9, ok := lang.FieldOrMethod(tmp8, "Interface") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp8, "Interface"))) - } - var tmp10 any - switch reflect.TypeOf(tmp9).Kind() { - case reflect.Func: - tmp10 = lang.Apply(tmp9, nil) - default: - tmp10 = tmp9 - } - var v11 any = tmp10 - _ = v11 - // let binding "m" - var v12 any = v3 - _ = v12 - // let binding "ks" - tmp13 := checkDerefVar(var_glojure_DOT_core_seq) - tmp14 := lang.Apply(tmp13, []any{v4}) - var v15 any = tmp14 - _ = v15 - for { - var tmp16 any - if lang.IsTruthy(v15) { - var tmp17 any - { // let - // let binding "m" - tmp18 := checkDerefVar(var_glojure_DOT_core_get) - tmp19 := checkDerefVar(var_glojure_DOT_core_first) - tmp20 := lang.Apply(tmp19, []any{v15}) - tmp21 := lang.Apply(tmp18, []any{v12, tmp20, v11}) - var v22 any = tmp21 - _ = v22 - var tmp23 any - tmp24 := checkDerefVar(var_glojure_DOT_core_identical_QMARK_) - tmp25 := lang.Apply(tmp24, []any{v11, v22}) - if lang.IsTruthy(tmp25) { - tmp23 = v5 - } else { - var tmp26 any = v11 - var tmp27 any = v22 - tmp29 := checkDerefVar(var_glojure_DOT_core_next) - tmp30 := lang.Apply(tmp29, []any{v15}) - var tmp28 any = tmp30 - v11 = tmp26 - v12 = tmp27 - v15 = tmp28 - continue - } - tmp17 = tmp23 - } // end let - tmp16 = tmp17 - } else { - tmp16 = v12 - } - tmp6 = tmp16 - break - } - } // end let - return tmp6 - default: - checkArity(args, -1) - panic("unreachable") - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // get-method - { - tmp0 := sym_get_DASH_method.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_multifn, sym_dispatch_DASH_val)), kw_doc, "Given a multimethod and a dispatch value, returns the dispatch fn\n that would apply to that value, or nil if none apply and no default", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(1815), kw_end_DASH_line, int(1815))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5, _ := lang.FieldOrMethod(v3, "getMethod") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("getMethod is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // get-thread-bindings - { - tmp0 := sym_get_DASH_thread_DASH_bindings.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Get a map with the Var/value pairs which is currently in effect for the\n current thread.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(25), kw_column, int(7), kw_line, int(1937), kw_end_DASH_line, int(1937))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - tmp3 := lang.Apply(nil, nil) - return tmp3 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Not}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 } - } - // get-validator - { - tmp0 := sym_get_DASH_validator.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_iref)), kw_doc, "Gets the validator-fn for a var/ref/agent/atom.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(2392), kw_end_DASH_line, int(2392))).(*lang.Symbol) + tmp0 := sym_bit_DASH_not.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Bitwise complement", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(1291), kw_end_DASH_line, int(1291))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(v3, "getValidator") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Not") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("getValidator is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Not is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{}) + tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // global-hierarchy - { - tmp0 := sym_global_DASH_hierarchy.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(5513), kw_column, int(6), kw_end_DASH_line, int(5514), kw_end_DASH_column, int(21), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, lang.NewMap(kw_parents, lang.NewMap(), kw_descendants, lang.NewMap(), kw_ancestors, lang.NewMap()), true) + var_glojure_DOT_core_bit_DASH_not = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_bit_DASH_not.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // group-by + // bit-or { - tmp0 := sym_group_DASH_by.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_coll)), kw_doc, "Returns a map of the elements of coll keyed by the result of\n f on each element. The value at each key will be a vector of the\n corresponding elements, in the order they appeared in coll.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(7128), kw_end_DASH_line, int(7128))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) - tmp6 := checkDerefVar(var_glojure_DOT_core_reduce) - var tmp7 lang.FnFunc - tmp7 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v8 := args[0] - _ = v8 - v9 := args[1] - _ = v9 - var tmp10 any + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any { // let - // let binding "k" - tmp11 := lang.Apply(v3, []any{v9}) - var v12 any = tmp11 - _ = v12 - tmp13 := checkDerefVar(var_glojure_DOT_core_assoc_BANG_) - tmp14 := checkDerefVar(var_glojure_DOT_core_conj) - tmp15 := checkDerefVar(var_glojure_DOT_core_get) - tmp16 := lang.NewVector() - tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7139), kw_column, int(40), kw_end_DASH_line, int(7139), kw_end_DASH_column, int(41)) - tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) - if err != nil { - panic(err) + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed31 + } else { + tmp4 = closed31 } - tmp19 := lang.Apply(tmp15, []any{v8, v12, tmp18}) - tmp20 := lang.Apply(tmp14, []any{tmp19, v9}) - tmp21 := lang.Apply(tmp13, []any{v8, v12, tmp20}) - tmp10 = tmp21 + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 } // end let - return tmp10 - }) - tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7137), kw_column, int(5), kw_end_DASH_line, int(7139), kw_end_DASH_column, int(48)) - tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp10 := checkDerefVar(var_glojure_DOT_core_transient) - tmp11 := lang.NewMap() - tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7140), kw_column, int(16), kw_end_DASH_line, int(7140), kw_end_DASH_column, int(17)) - tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp14 := lang.Apply(tmp10, []any{tmp13}) - tmp15 := lang.Apply(tmp6, []any{tmp9, tmp14, v4}) - tmp16 := lang.Apply(tmp5, []any{tmp15}) - return tmp16 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // halt-when - { - tmp0 := sym_halt_DASH_when.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred), lang.NewVector(sym_pred, sym_retf)), kw_doc, "Returns a transducer that ends transduction when pred returns true\n for an input. When retf is supplied it must be a fn of 2 arguments -\n it will be passed the (completed) result so far and the input that\n triggered the predicate, and its return value (if it does not throw\n an exception) will be the return value of the transducer. If retf\n is not supplied, the input that triggered the predicate will be\n returned. If the predicate never returns true the transduction is\n unaffected.", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(7657), kw_end_DASH_line, int(7657))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_halt_DASH_when) - tmp5 := lang.Apply(tmp4, []any{v3, nil}) - return tmp5 + return tmp3 case 2: - v3 := args[0] + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed31 + } else { + tmp5 = closed31 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) _ = v4 - var tmp5 lang.FnFunc - tmp5 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v6 := args[0] - _ = v6 - var tmp7 lang.FnFunc - tmp7 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp8 := lang.Apply(v6, nil) - return tmp8 - case 1: - v8 := args[0] - _ = v8 - var tmp9 any - var tmp10 any - { // let - // let binding "and__0__auto__" - tmp11 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) - tmp12 := lang.Apply(tmp11, []any{v8}) - var v13 any = tmp12 - _ = v13 - var tmp14 any - if lang.IsTruthy(v13) { - tmp15 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) - tmp16 := lang.Apply(tmp15, []any{v8, kw_glojure_DOT_core_SLASH_halt}) - tmp14 = tmp16 - } else { - tmp14 = v13 - } - tmp10 = tmp14 - } // end let - if lang.IsTruthy(tmp10) { - tmp11 := lang.Apply(kw_glojure_DOT_core_SLASH_halt, []any{v8}) - tmp9 = tmp11 - } else { - tmp12 := lang.Apply(v6, []any{v8}) - tmp9 = tmp12 - } - return tmp9 - case 2: - v8 := args[0] - _ = v8 - v9 := args[1] - _ = v9 - var tmp10 any - tmp11 := lang.Apply(v3, []any{v9}) - if lang.IsTruthy(tmp11) { - tmp12 := checkDerefVar(var_glojure_DOT_core_reduced) - var tmp13 any - if lang.IsTruthy(v4) { - tmp14 := lang.Apply(v6, []any{v8}) - tmp15 := lang.Apply(v4, []any{tmp14, v9}) - tmp13 = tmp15 - } else { - tmp13 = v9 - } - tmp16 := lang.NewMap(kw_glojure_DOT_core_SLASH_halt, tmp13) - tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7678), kw_column, int(24), kw_end_DASH_line, int(7678), kw_end_DASH_column, int(72)) - tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp19 := lang.Apply(tmp12, []any{tmp18}) - tmp10 = tmp19 - } else { - tmp20 := lang.Apply(v6, []any{v8, v9}) - tmp10 = tmp20 - } - return tmp10 - default: - checkArity(args, -1) - panic("unreachable") - } + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed31 + } else { + tmp6 = closed31 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 }) - tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7670), kw_column, int(8), kw_end_DASH_line, int(7679), kw_end_DASH_column, int(34)) - tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) if err != nil { panic(err) } - return tmp9 - }) - tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7669), kw_column, int(6), kw_end_DASH_line, int(7679), kw_end_DASH_column, int(35)) - tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp7 - default: - checkArity(args, -1) - panic("unreachable") - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // hash - { - tmp0 := sym_hash.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns the hash code of its argument. Note this is the hash code\n consistent with =, and thus is different than .hashCode for Integer,\n Short, Byte and Clojure collections.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(5189), kw_end_DASH_line, int(5189))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := lang.Apply(lang.HashEq, []any{v3}) - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // hash-map - { - tmp0 := sym_hash_DASH_map.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym__AMP_, sym_keyvals)), kw_doc, "keyval => key val\n Returns a new hash map with supplied mappings. If any keys are\n equal, they are handled as if by repeated uses of assoc.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(378), kw_end_DASH_line, int(378))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp3 := lang.NewMap() - tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(384), kw_column, int(7), kw_end_DASH_line, int(384), kw_end_DASH_column, int(8)) - tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) - if err != nil { - panic(err) - } + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let return tmp5 - default: - checkArity(args, 0) - var v3 any = lang.NewList(args[0:]...) - _ = v3 - tmp4 := lang.Apply(lang.CreatePersistentHashMap, []any{v3}) - return tmp4 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // hash-ordered-coll - { - tmp0 := sym_hash_DASH_ordered_DASH_coll.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns the hash code, consistent with =, for an external ordered\n collection implementing Iterable.\n See http://glojure.org/data_structures#hash for full algorithms.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.6", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(7), kw_line, int(5210), kw_end_DASH_line, int(5210))).(*lang.Symbol) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := lang.Apply(nil, []any{v3}) - return tmp4 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // hash-set - { - tmp0 := sym_hash_DASH_set.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym__AMP_, sym_keys)), kw_doc, "Returns a new hash set with supplied keys. Any equal keys are\n handled as if by repeated uses of conj.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(388), kw_end_DASH_line, int(388))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_bit_DASH_or.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Bitwise or", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(1307), kw_end_DASH_line, int(1307))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 0: - tmp3 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) - tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(393), kw_column, int(7), kw_end_DASH_line, int(393), kw_end_DASH_column, int(9)) - tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) - if err != nil { - panic(err) + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Or") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Or is not a function"))) } - return tmp5 + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 default: - checkArity(args, 0) - var v3 any = lang.NewList(args[0:]...) - _ = v3 - tmp4 := lang.Apply(nil, []any{v3}) - return tmp4 + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp8 := checkDerefVar(var_glojure_DOT_core_bit_DASH_or) + tmp9 := checkDerefVar(var_glojure_DOT_core_bit_DASH_or) + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) + return tmp11 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // hash-unordered-coll - { - tmp0 := sym_hash_DASH_unordered_DASH_coll.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns the hash code, consistent with =, for an external unordered\n collection implementing Iterable. For maps, the iterator should\n return map entries whose hash is computed as\n (hash-ordered-coll [k v]).\n See http://glojure.org/data_structures#hash for full algorithms.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.6", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(25), kw_column, int(7), kw_line, int(5219), kw_end_DASH_line, int(5219))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := lang.Apply(nil, []any{v3}) - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // ident? - { - tmp0 := sym_ident_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a symbol or keyword", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(1608), kw_end_DASH_line, int(1608))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "or__0__auto__" - tmp5 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) - tmp6 := lang.Apply(tmp5, []any{v3}) - var v7 any = tmp6 - _ = v7 - var tmp8 any - if lang.IsTruthy(v7) { - tmp8 = v7 - } else { - tmp9 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) - tmp10 := lang.Apply(tmp9, []any{v3}) - tmp8 = tmp10 - } - tmp4 = tmp8 - } // end let - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bit_DASH_or = ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_bit_DASH_or.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // identical? + // bit-shift-left { var tmp1 lang.FnFunc - { // function identical?__inliner + { // function bit-shift-left__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 2) @@ -26562,711 +20788,321 @@ func LoadNS() { tmp7 := checkDerefVar(var_glojure_DOT_core_list) tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) tmp9 := checkDerefVar(var_glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_lang_DOT_Util}) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp11 := checkDerefVar(var_glojure_DOT_core_list) - tmp12 := lang.Apply(tmp11, []any{sym_glojure_DOT_core_SLASH_identical}) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{v3}) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{v4}) - tmp17 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp12, tmp14, tmp16}) - tmp18 := lang.Apply(tmp5, []any{tmp17}) - return tmp18 + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_ShiftLeft}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 }) v2 = tmp1 _ = v2 } - tmp0 := sym_identical_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Tests if 2 arguments are the same object", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(768), kw_end_DASH_line, int(768))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6 := lang.Apply(lang.Identical, []any{v4, v5}) - return tmp6 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // identity - { - tmp0 := sym_identity.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns its argument.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(1446), kw_end_DASH_line, int(1446))).(*lang.Symbol) + tmp0 := sym_bit_DASH_shift_DASH_left.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_n)), kw_inline, tmp1, kw_doc, "Bitwise shift left", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(1361), kw_end_DASH_line, int(1361))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) + checkArity(args, 2) v3 := args[0] _ = v3 - return v3 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // if-let - { - tmp0 := sym_if_DASH_let.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym_then), lang.NewVector(sym_bindings, sym_then, sym_else, sym__AMP_, sym_oldform)), kw_doc, "bindings => binding-form test\n\n If test is true, evaluates then with binding-form bound to the value of \n test, if not, yields else", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(11), kw_line, int(1839), kw_end_DASH_line, int(1839))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 4: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - tmp7 := checkDerefVar(var_glojure_DOT_core_seq) - tmp8 := checkDerefVar(var_glojure_DOT_core_concat) - tmp9 := checkDerefVar(var_glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_core_SLASH_if_DASH_let}) - tmp11 := checkDerefVar(var_glojure_DOT_core_list) - tmp12 := lang.Apply(tmp11, []any{v5}) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{v6}) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{nil}) - tmp17 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp14, tmp16}) - tmp18 := lang.Apply(tmp7, []any{tmp17}) - return tmp18 - default: - checkArity(args, 5) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - v7 := args[4] - _ = v7 - var v8 any = lang.NewList(args[5:]...) - _ = v8 - var tmp9 any - tmp10 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) - tmp11 := lang.Apply(tmp10, []any{v5}) - if lang.IsTruthy(tmp11) { - } else { - tmp12 := checkDerefVar(var_glojure_DOT_core_str) - tmp13 := checkDerefVar(var_glojure_DOT_core_first) - tmp14 := lang.Apply(tmp13, []any{v3}) - tmp15 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) - tmp16 := checkDerefVar(var_glojure_DOT_core_meta) - tmp17 := lang.Apply(tmp16, []any{v3}) - tmp18 := lang.Apply(kw_line, []any{tmp17}) - tmp19 := lang.Apply(tmp12, []any{tmp14, " requires ", "a vector for its binding", " in ", tmp15, ":", tmp18}) - tmp20 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp19}) - panic(tmp20) - } - _ = tmp9 - var tmp21 any - tmp22 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) - tmp23 := lang.Apply(tmp22, []any{v8}) - if lang.IsTruthy(tmp23) { - } else { - tmp24 := checkDerefVar(var_glojure_DOT_core_str) - tmp25 := checkDerefVar(var_glojure_DOT_core_first) - tmp26 := lang.Apply(tmp25, []any{v3}) - tmp27 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) - tmp28 := checkDerefVar(var_glojure_DOT_core_meta) - tmp29 := lang.Apply(tmp28, []any{v3}) - tmp30 := lang.Apply(kw_line, []any{tmp29}) - tmp31 := lang.Apply(tmp24, []any{tmp26, " requires ", "1 or 2 forms after binding vector", " in ", tmp27, ":", tmp30}) - tmp32 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp31}) - panic(tmp32) - } - _ = tmp21 - var tmp33 any - tmp34 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp35 := checkDerefVar(var_glojure_DOT_core_count) - tmp36 := lang.Apply(tmp35, []any{v5}) - tmp37 := lang.Apply(tmp34, []any{int64(2), tmp36}) - if lang.IsTruthy(tmp37) { - } else { - tmp38 := checkDerefVar(var_glojure_DOT_core_str) - tmp39 := checkDerefVar(var_glojure_DOT_core_first) - tmp40 := lang.Apply(tmp39, []any{v3}) - tmp41 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) - tmp42 := checkDerefVar(var_glojure_DOT_core_meta) - tmp43 := lang.Apply(tmp42, []any{v3}) - tmp44 := lang.Apply(kw_line, []any{tmp43}) - tmp45 := lang.Apply(tmp38, []any{tmp40, " requires ", "exactly 2 forms in binding vector", " in ", tmp41, ":", tmp44}) - tmp46 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp45}) - panic(tmp46) - } - _ = tmp33 - var tmp47 any - { // let - // let binding "form" - tmp48 := lang.Apply(v5, []any{int64(0)}) - var v49 any = tmp48 - _ = v49 - // let binding "tst" - tmp50 := lang.Apply(v5, []any{int64(1)}) - var v51 any = tmp50 - _ = v51 - tmp52 := checkDerefVar(var_glojure_DOT_core_seq) - tmp53 := checkDerefVar(var_glojure_DOT_core_concat) - tmp54 := checkDerefVar(var_glojure_DOT_core_list) - tmp55 := lang.Apply(tmp54, []any{sym_glojure_DOT_core_SLASH_let}) - tmp56 := checkDerefVar(var_glojure_DOT_core_list) - tmp57 := checkDerefVar(var_glojure_DOT_core_apply) - tmp58 := checkDerefVar(var_glojure_DOT_core_vector) - tmp59 := checkDerefVar(var_glojure_DOT_core_seq) - tmp60 := checkDerefVar(var_glojure_DOT_core_concat) - tmp61 := checkDerefVar(var_glojure_DOT_core_list) - tmp62 := lang.Apply(tmp61, []any{sym_temp__0__auto__}) - tmp63 := checkDerefVar(var_glojure_DOT_core_list) - tmp64 := lang.Apply(tmp63, []any{v51}) - tmp65 := lang.Apply(tmp60, []any{tmp62, tmp64}) - tmp66 := lang.Apply(tmp59, []any{tmp65}) - tmp67 := lang.Apply(tmp57, []any{tmp58, tmp66}) - tmp68 := lang.Apply(tmp56, []any{tmp67}) - tmp69 := checkDerefVar(var_glojure_DOT_core_list) - tmp70 := checkDerefVar(var_glojure_DOT_core_seq) - tmp71 := checkDerefVar(var_glojure_DOT_core_concat) - tmp72 := checkDerefVar(var_glojure_DOT_core_list) - tmp73 := lang.Apply(tmp72, []any{sym_if}) - tmp74 := checkDerefVar(var_glojure_DOT_core_list) - tmp75 := lang.Apply(tmp74, []any{sym_temp__0__auto__}) - tmp76 := checkDerefVar(var_glojure_DOT_core_list) - tmp77 := checkDerefVar(var_glojure_DOT_core_seq) - tmp78 := checkDerefVar(var_glojure_DOT_core_concat) - tmp79 := checkDerefVar(var_glojure_DOT_core_list) - tmp80 := lang.Apply(tmp79, []any{sym_glojure_DOT_core_SLASH_let}) - tmp81 := checkDerefVar(var_glojure_DOT_core_list) - tmp82 := checkDerefVar(var_glojure_DOT_core_apply) - tmp83 := checkDerefVar(var_glojure_DOT_core_vector) - tmp84 := checkDerefVar(var_glojure_DOT_core_seq) - tmp85 := checkDerefVar(var_glojure_DOT_core_concat) - tmp86 := checkDerefVar(var_glojure_DOT_core_list) - tmp87 := lang.Apply(tmp86, []any{v49}) - tmp88 := checkDerefVar(var_glojure_DOT_core_list) - tmp89 := lang.Apply(tmp88, []any{sym_temp__0__auto__}) - tmp90 := lang.Apply(tmp85, []any{tmp87, tmp89}) - tmp91 := lang.Apply(tmp84, []any{tmp90}) - tmp92 := lang.Apply(tmp82, []any{tmp83, tmp91}) - tmp93 := lang.Apply(tmp81, []any{tmp92}) - tmp94 := checkDerefVar(var_glojure_DOT_core_list) - tmp95 := lang.Apply(tmp94, []any{v6}) - tmp96 := lang.Apply(tmp78, []any{tmp80, tmp93, tmp95}) - tmp97 := lang.Apply(tmp77, []any{tmp96}) - tmp98 := lang.Apply(tmp76, []any{tmp97}) - tmp99 := checkDerefVar(var_glojure_DOT_core_list) - tmp100 := lang.Apply(tmp99, []any{v7}) - tmp101 := lang.Apply(tmp71, []any{tmp73, tmp75, tmp98, tmp100}) - tmp102 := lang.Apply(tmp70, []any{tmp101}) - tmp103 := lang.Apply(tmp69, []any{tmp102}) - tmp104 := lang.Apply(tmp53, []any{tmp55, tmp68, tmp103}) - tmp105 := lang.Apply(tmp52, []any{tmp104}) - tmp47 = tmp105 - } // end let - return tmp47 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "ShiftLeft") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ShiftLeft is not a function"))) } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core_bit_DASH_shift_DASH_left = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_bit_DASH_shift_DASH_left.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // if-not + // bit-shift-right { - tmp0 := sym_if_DASH_not.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_test, sym_then), lang.NewVector(sym_test, sym_then, sym_else)), kw_doc, "Evaluates test. If logical false, evaluates and returns then expr, \n otherwise else expr, if supplied, else nil.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(11), kw_line, int(760), kw_end_DASH_line, int(760))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 4: + var tmp1 lang.FnFunc + { // function bit-shift-right__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - tmp7 := checkDerefVar(var_glojure_DOT_core_seq) - tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) tmp9 := checkDerefVar(var_glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_core_SLASH_if_DASH_not}) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp11 := checkDerefVar(var_glojure_DOT_core_list) - tmp12 := lang.Apply(tmp11, []any{v5}) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{v6}) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{nil}) - tmp17 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp14, tmp16}) - tmp18 := lang.Apply(tmp7, []any{tmp17}) - return tmp18 - case 5: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - v7 := args[4] - _ = v7 - tmp8 := checkDerefVar(var_glojure_DOT_core_seq) - tmp9 := checkDerefVar(var_glojure_DOT_core_concat) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_if}) - tmp12 := checkDerefVar(var_glojure_DOT_core_list) - tmp13 := checkDerefVar(var_glojure_DOT_core_seq) - tmp14 := checkDerefVar(var_glojure_DOT_core_concat) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_not}) - tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{v5}) - tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) - tmp20 := lang.Apply(tmp13, []any{tmp19}) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_ShiftRight}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) tmp21 := lang.Apply(tmp12, []any{tmp20}) - tmp22 := checkDerefVar(var_glojure_DOT_core_list) - tmp23 := lang.Apply(tmp22, []any{v6}) - tmp24 := checkDerefVar(var_glojure_DOT_core_list) - tmp25 := lang.Apply(tmp24, []any{v7}) - tmp26 := lang.Apply(tmp9, []any{tmp11, tmp21, tmp23, tmp25}) - tmp27 := lang.Apply(tmp8, []any{tmp26}) - return tmp27 - default: - checkArity(args, -1) - panic("unreachable") - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // if-some - { - tmp0 := sym_if_DASH_some.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym_then), lang.NewVector(sym_bindings, sym_then, sym_else, sym__AMP_, sym_oldform)), kw_doc, "bindings => binding-form test\n\n If test is not nil, evaluates then with binding-form bound to the\n value of test, if not, yields else", kw_file, "glojure/core.glj", kw_added, "1.6", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(1874), kw_end_DASH_line, int(1874))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 4: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - tmp7 := checkDerefVar(var_glojure_DOT_core_seq) - tmp8 := checkDerefVar(var_glojure_DOT_core_concat) - tmp9 := checkDerefVar(var_glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_core_SLASH_if_DASH_some}) - tmp11 := checkDerefVar(var_glojure_DOT_core_list) - tmp12 := lang.Apply(tmp11, []any{v5}) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{v6}) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{nil}) - tmp17 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp14, tmp16}) - tmp18 := lang.Apply(tmp7, []any{tmp17}) - return tmp18 - default: - checkArity(args, 5) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - v7 := args[4] - _ = v7 - var v8 any = lang.NewList(args[5:]...) - _ = v8 - var tmp9 any - tmp10 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) - tmp11 := lang.Apply(tmp10, []any{v5}) - if lang.IsTruthy(tmp11) { - } else { - tmp12 := checkDerefVar(var_glojure_DOT_core_str) - tmp13 := checkDerefVar(var_glojure_DOT_core_first) - tmp14 := lang.Apply(tmp13, []any{v3}) - tmp15 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) - tmp16 := checkDerefVar(var_glojure_DOT_core_meta) - tmp17 := lang.Apply(tmp16, []any{v3}) - tmp18 := lang.Apply(kw_line, []any{tmp17}) - tmp19 := lang.Apply(tmp12, []any{tmp14, " requires ", "a vector for its binding", " in ", tmp15, ":", tmp18}) - tmp20 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp19}) - panic(tmp20) - } - _ = tmp9 - var tmp21 any - tmp22 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) - tmp23 := lang.Apply(tmp22, []any{v8}) - if lang.IsTruthy(tmp23) { - } else { - tmp24 := checkDerefVar(var_glojure_DOT_core_str) - tmp25 := checkDerefVar(var_glojure_DOT_core_first) - tmp26 := lang.Apply(tmp25, []any{v3}) - tmp27 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) - tmp28 := checkDerefVar(var_glojure_DOT_core_meta) - tmp29 := lang.Apply(tmp28, []any{v3}) - tmp30 := lang.Apply(kw_line, []any{tmp29}) - tmp31 := lang.Apply(tmp24, []any{tmp26, " requires ", "1 or 2 forms after binding vector", " in ", tmp27, ":", tmp30}) - tmp32 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp31}) - panic(tmp32) - } - _ = tmp21 - var tmp33 any - tmp34 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp35 := checkDerefVar(var_glojure_DOT_core_count) - tmp36 := lang.Apply(tmp35, []any{v5}) - tmp37 := lang.Apply(tmp34, []any{int64(2), tmp36}) - if lang.IsTruthy(tmp37) { - } else { - tmp38 := checkDerefVar(var_glojure_DOT_core_str) - tmp39 := checkDerefVar(var_glojure_DOT_core_first) - tmp40 := lang.Apply(tmp39, []any{v3}) - tmp41 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) - tmp42 := checkDerefVar(var_glojure_DOT_core_meta) - tmp43 := lang.Apply(tmp42, []any{v3}) - tmp44 := lang.Apply(kw_line, []any{tmp43}) - tmp45 := lang.Apply(tmp38, []any{tmp40, " requires ", "exactly 2 forms in binding vector", " in ", tmp41, ":", tmp44}) - tmp46 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp45}) - panic(tmp46) - } - _ = tmp33 - var tmp47 any - { // let - // let binding "form" - tmp48 := lang.Apply(v5, []any{int64(0)}) - var v49 any = tmp48 - _ = v49 - // let binding "tst" - tmp50 := lang.Apply(v5, []any{int64(1)}) - var v51 any = tmp50 - _ = v51 - tmp52 := checkDerefVar(var_glojure_DOT_core_seq) - tmp53 := checkDerefVar(var_glojure_DOT_core_concat) - tmp54 := checkDerefVar(var_glojure_DOT_core_list) - tmp55 := lang.Apply(tmp54, []any{sym_glojure_DOT_core_SLASH_let}) - tmp56 := checkDerefVar(var_glojure_DOT_core_list) - tmp57 := checkDerefVar(var_glojure_DOT_core_apply) - tmp58 := checkDerefVar(var_glojure_DOT_core_vector) - tmp59 := checkDerefVar(var_glojure_DOT_core_seq) - tmp60 := checkDerefVar(var_glojure_DOT_core_concat) - tmp61 := checkDerefVar(var_glojure_DOT_core_list) - tmp62 := lang.Apply(tmp61, []any{sym_temp__0__auto__}) - tmp63 := checkDerefVar(var_glojure_DOT_core_list) - tmp64 := lang.Apply(tmp63, []any{v51}) - tmp65 := lang.Apply(tmp60, []any{tmp62, tmp64}) - tmp66 := lang.Apply(tmp59, []any{tmp65}) - tmp67 := lang.Apply(tmp57, []any{tmp58, tmp66}) - tmp68 := lang.Apply(tmp56, []any{tmp67}) - tmp69 := checkDerefVar(var_glojure_DOT_core_list) - tmp70 := checkDerefVar(var_glojure_DOT_core_seq) - tmp71 := checkDerefVar(var_glojure_DOT_core_concat) - tmp72 := checkDerefVar(var_glojure_DOT_core_list) - tmp73 := lang.Apply(tmp72, []any{sym_if}) - tmp74 := checkDerefVar(var_glojure_DOT_core_list) - tmp75 := checkDerefVar(var_glojure_DOT_core_seq) - tmp76 := checkDerefVar(var_glojure_DOT_core_concat) - tmp77 := checkDerefVar(var_glojure_DOT_core_list) - tmp78 := lang.Apply(tmp77, []any{sym_glojure_DOT_core_SLASH_nil_QMARK_}) - tmp79 := checkDerefVar(var_glojure_DOT_core_list) - tmp80 := lang.Apply(tmp79, []any{sym_temp__0__auto__}) - tmp81 := lang.Apply(tmp76, []any{tmp78, tmp80}) - tmp82 := lang.Apply(tmp75, []any{tmp81}) - tmp83 := lang.Apply(tmp74, []any{tmp82}) - tmp84 := checkDerefVar(var_glojure_DOT_core_list) - tmp85 := lang.Apply(tmp84, []any{v7}) - tmp86 := checkDerefVar(var_glojure_DOT_core_list) - tmp87 := checkDerefVar(var_glojure_DOT_core_seq) - tmp88 := checkDerefVar(var_glojure_DOT_core_concat) - tmp89 := checkDerefVar(var_glojure_DOT_core_list) - tmp90 := lang.Apply(tmp89, []any{sym_glojure_DOT_core_SLASH_let}) - tmp91 := checkDerefVar(var_glojure_DOT_core_list) - tmp92 := checkDerefVar(var_glojure_DOT_core_apply) - tmp93 := checkDerefVar(var_glojure_DOT_core_vector) - tmp94 := checkDerefVar(var_glojure_DOT_core_seq) - tmp95 := checkDerefVar(var_glojure_DOT_core_concat) - tmp96 := checkDerefVar(var_glojure_DOT_core_list) - tmp97 := lang.Apply(tmp96, []any{v49}) - tmp98 := checkDerefVar(var_glojure_DOT_core_list) - tmp99 := lang.Apply(tmp98, []any{sym_temp__0__auto__}) - tmp100 := lang.Apply(tmp95, []any{tmp97, tmp99}) - tmp101 := lang.Apply(tmp94, []any{tmp100}) - tmp102 := lang.Apply(tmp92, []any{tmp93, tmp101}) - tmp103 := lang.Apply(tmp91, []any{tmp102}) - tmp104 := checkDerefVar(var_glojure_DOT_core_list) - tmp105 := lang.Apply(tmp104, []any{v6}) - tmp106 := lang.Apply(tmp88, []any{tmp90, tmp103, tmp105}) - tmp107 := lang.Apply(tmp87, []any{tmp106}) - tmp108 := lang.Apply(tmp86, []any{tmp107}) - tmp109 := lang.Apply(tmp71, []any{tmp73, tmp83, tmp85, tmp108}) - tmp110 := lang.Apply(tmp70, []any{tmp109}) - tmp111 := lang.Apply(tmp69, []any{tmp110}) - tmp112 := lang.Apply(tmp53, []any{tmp55, tmp68, tmp111}) - tmp113 := lang.Apply(tmp52, []any{tmp112}) - tmp47 = tmp113 - } // end let - return tmp47 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 } - } - // ifn? - { - tmp0 := sym_ifn_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x implements IFn. Note that many data structures\n (e.g. sets and maps) implement IFn", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(6209), kw_end_DASH_line, int(6209))).(*lang.Symbol) + tmp0 := sym_bit_DASH_shift_DASH_right.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_n)), kw_inline, tmp1, kw_doc, "Bitwise shift right", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(1367), kw_end_DASH_line, int(1367))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) + checkArity(args, 2) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp5 := lang.Apply(tmp4, []any{nil, v3}) - return tmp5 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "ShiftRight") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ShiftRight is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core_bit_DASH_shift_DASH_right = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_bit_DASH_shift_DASH_right.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // import + // bit-xor { - tmp0 := sym_import.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_import_DASH_symbols_DASH_or_DASH_lists)), kw_doc, "import-list => (package-symbol class-name-symbols*)\n\n For each name in class-name-symbols, adds a mapping from name to the\n class named by package.name to the current namespace. Use :import in the ns\n macro in preference to calling this directly.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(11), kw_line, int(3426), kw_end_DASH_line, int(3426))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed32 + } else { + tmp4 = closed32 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed32 + } else { + tmp5 = closed32 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 default: checkArity(args, 2) - v3 := args[0] + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + var v4 any = lang.NewList(args[2:]...) _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - var tmp6 any + var tmp5 any { // let - // let binding "specs" - tmp7 := checkDerefVar(var_glojure_DOT_core_map) - var tmp8 lang.FnFunc - tmp8 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v9 := args[0] - _ = v9 - var tmp10 any - var tmp11 any - { // let - // let binding "and__0__auto__" - tmp12 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) - tmp13 := lang.Apply(tmp12, []any{v9}) - var v14 any = tmp13 - _ = v14 - var tmp15 any - if lang.IsTruthy(v14) { - tmp16 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp17 := checkDerefVar(var_glojure_DOT_core_first) - tmp18 := lang.Apply(tmp17, []any{v9}) - tmp19 := lang.Apply(tmp16, []any{sym_quote, tmp18}) - tmp15 = tmp19 - } else { - tmp15 = v14 - } - tmp11 = tmp15 - } // end let - if lang.IsTruthy(tmp11) { - tmp12 := checkDerefVar(var_glojure_DOT_core_second) - tmp13 := lang.Apply(tmp12, []any{v9}) - tmp10 = tmp13 - } else { - tmp10 = v9 - } - return tmp10 + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed32 + } else { + tmp6 = closed32 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 }) - tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3434), kw_column, int(20), kw_end_DASH_line, int(3434), kw_end_DASH_column, int(73)) - tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp11 := lang.Apply(tmp7, []any{tmp10, v5}) - var v12 any = tmp11 - _ = v12 tmp13 := checkDerefVar(var_glojure_DOT_core_seq) tmp14 := checkDerefVar(var_glojure_DOT_core_concat) tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{sym_do}) - tmp17 := checkDerefVar(var_glojure_DOT_core_map) - var tmp18 lang.FnFunc - tmp18 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v19 := args[0] - _ = v19 - tmp20 := checkDerefVar(var_glojure_DOT_core_list) - tmp21 := lang.Apply(tmp20, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Import, v19}) - return tmp21 - }) - tmp19 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3436), kw_column, int(17), kw_end_DASH_line, int(3436), kw_end_DASH_column, int(73)) - tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp21 := checkDerefVar(var_glojure_DOT_core_reduce1) - var tmp22 lang.FnFunc - tmp22 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v23 := args[0] - _ = v23 - v24 := args[1] - _ = v24 - var tmp25 any - tmp26 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) - tmp27 := lang.Apply(tmp26, []any{v24}) - if lang.IsTruthy(tmp27) { - tmp28 := checkDerefVar(var_glojure_DOT_core_conj) - tmp29 := checkDerefVar(var_glojure_DOT_core_name) - tmp30 := lang.Apply(tmp29, []any{v24}) - tmp31 := lang.Apply(tmp28, []any{v23, tmp30}) - tmp25 = tmp31 - } else { - var tmp32 any - { // let - // let binding "p" - tmp33 := checkDerefVar(var_glojure_DOT_core_first) - tmp34 := lang.Apply(tmp33, []any{v24}) - var v35 any = tmp34 - _ = v35 - // let binding "cs" - tmp36 := checkDerefVar(var_glojure_DOT_core_rest) - tmp37 := lang.Apply(tmp36, []any{v24}) - var v38 any = tmp37 - _ = v38 - tmp39 := checkDerefVar(var_glojure_DOT_core_into1) - tmp40 := checkDerefVar(var_glojure_DOT_core_map) - var tmp41 lang.FnFunc - tmp41 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v42 := args[0] - _ = v42 - tmp43 := checkDerefVar(var_glojure_DOT_core_str) - tmp44 := lang.Apply(tmp43, []any{v35, ".", v42}) - return tmp44 - }) - tmp42 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3441), kw_column, int(45), kw_end_DASH_line, int(3441), kw_end_DASH_column, int(58)) - tmp43, err := lang.WithMeta(tmp41, tmp42.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp44 := lang.Apply(tmp40, []any{tmp43, v38}) - tmp45 := lang.Apply(tmp39, []any{v23, tmp44}) - tmp32 = tmp45 - } // end let - tmp25 = tmp32 - } - return tmp25 - }) - tmp23 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3437), kw_column, int(26), kw_end_DASH_line, int(3441), kw_end_DASH_column, int(66)) - tmp24, err := lang.WithMeta(tmp22, tmp23.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp25 := lang.NewVector() - tmp26 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3442), kw_column, int(25), kw_end_DASH_line, int(3442), kw_end_DASH_column, int(26)) - tmp27, err := lang.WithMeta(tmp25, tmp26.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp28 := lang.Apply(tmp21, []any{tmp24, tmp27, v12}) - tmp29 := lang.Apply(tmp17, []any{tmp20, tmp28}) - tmp30 := lang.Apply(tmp14, []any{tmp16, tmp29}) - tmp31 := lang.Apply(tmp13, []any{tmp30}) - tmp6 = tmp31 + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 } // end let - return tmp6 + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // inc - { - var tmp1 lang.FnFunc - { // function inc__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_seq) - tmp5 := checkDerefVar(var_glojure_DOT_core_concat) - tmp6 := checkDerefVar(var_glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) - tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := checkDerefVar(var_glojure_DOT_core_seq) - tmp12 := checkDerefVar(var_glojure_DOT_core_concat) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - var tmp14 any - tmp15 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) - if lang.IsTruthy(tmp15) { - tmp14 = sym_unchecked_inc - } else { - tmp14 = sym_inc - } - tmp16 := lang.Apply(tmp13, []any{tmp14}) - tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{v3}) - tmp19 := lang.Apply(tmp12, []any{tmp16, tmp18}) - tmp20 := lang.Apply(tmp11, []any{tmp19}) - tmp21 := lang.Apply(tmp10, []any{tmp20}) - tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp21}) - tmp23 := lang.Apply(tmp4, []any{tmp22}) - return tmp23 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := sym_inc.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns a number one greater than num. Does not auto-promote\n longs, will throw on overflow. See also: inc'", kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(915), kw_end_DASH_line, int(915))).(*lang.Symbol) + tmp0 := sym_bit_DASH_xor.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Bitwise exclusive or", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(1316), kw_end_DASH_line, int(1316))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Inc") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Inc is not a function"))) + switch len(args) { + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Xor") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Xor is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp8 := checkDerefVar(var_glojure_DOT_core_bit_DASH_xor) + tmp9 := checkDerefVar(var_glojure_DOT_core_bit_DASH_xor) + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) + return tmp11 } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 }) tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + var_glojure_DOT_core_bit_DASH_xor = ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_bit_DASH_xor.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // inc' + // boolean { var tmp1 lang.FnFunc - { // function inc'__inliner + { // function boolean__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) @@ -27277,12 +21113,12 @@ func LoadNS() { tmp6 := checkDerefVar(var_glojure_DOT_core_list) tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_IncP}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_BooleanCast}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -27295,47 +21131,101 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := sym_inc_TICK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns a number one greater than num. Supports arbitrary precision.\n See also: inc", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(908), kw_end_DASH_line, int(908))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_boolean.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to boolean", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(1601), kw_end_DASH_line, int(1601))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "IncP") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("IncP is not a function"))) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(runtime.RT, "BooleanCast") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("BooleanCast is not a function"))) } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_boolean = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_boolean.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // indexed? + // boolean-array { - tmp0 := sym_indexed_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Return true if coll implements Indexed, indicating efficient lookup by index", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(6263), kw_end_DASH_line, int(6263))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function boolean-array__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_BooleanArray}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_unquote_DASH_splicing}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_glojure_DOT_core_SLASH_args}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + } + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_boolean_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_size_DASH_or_DASH_seq), lang.NewVector(sym_size, sym_init_DASH_val_DASH_or_DASH_seq)), kw_inline, tmp1, kw_doc, "Creates an array of booleans", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(5309), kw_end_DASH_line, int(5309))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp5 := lang.Apply(tmp4, []any{nil, v3}) - return tmp5 + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "BooleanArray") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("BooleanArray is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "BooleanArrayInit") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("BooleanArrayInit is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core_boolean_DASH_array = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_boolean_DASH_array.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // infinite? + // booleans { var tmp1 lang.FnFunc - { // function infinite?__inliner + { // function booleans var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) @@ -27344,92 +21234,256 @@ func LoadNS() { tmp4 := checkDerefVar(var_glojure_DOT_core_seq) tmp5 := checkDerefVar(var_glojure_DOT_core_concat) tmp6 := checkDerefVar(var_glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{sym_Double_SLASH_isInfinite}) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{v3}) - tmp10 := lang.Apply(tmp5, []any{tmp7, tmp9}) - tmp11 := lang.Apply(tmp4, []any{tmp10}) - return tmp11 + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Booleans}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 }) v2 = tmp1 _ = v2 } - tmp0 := sym_infinite_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_num)), kw_inline, tmp1, kw_doc, "Returns true if num is negative or positive infinity, else false", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1)})), kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(7977), kw_end_DASH_line, int(7977))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_booleans.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xs)), kw_inline, tmp1, kw_doc, "Casts to boolean[]", kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(12), kw_line, int(5372), kw_end_DASH_line, int(5372))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5 := lang.Apply(nil, []any{v4}) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Booleans") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Booleans is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_booleans = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_booleans.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // inst-ms + // bound-fn { - tmp0 := sym_inst_DASH_ms.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_inst)), kw_doc, "Return the number of milliseconds since January 1, 1970, 00:00:00 GMT", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(6831), kw_end_DASH_line, int(6831))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := lang.Apply(nil, []any{v3}) - return tmp4 + tmp0 := sym_bound_DASH_fn.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_fntail)), kw_doc, "Returns a function defined by the given fntail, which will install the\n same bindings in effect as in the thread at the time bound-fn was called.\n This may be used to define a helper function which runs on a different\n thread, but needs the same bindings in place.", kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(11), kw_line, int(2004), kw_end_DASH_line, int(2004))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym_glojure_DOT_core_SLASH_bound_DASH_fn_STAR_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := checkDerefVar(var_glojure_DOT_core_seq) + tmp11 := checkDerefVar(var_glojure_DOT_core_concat) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_glojure_DOT_core_SLASH_fn}) + tmp14 := lang.Apply(tmp11, []any{tmp13, v4}) + tmp15 := lang.Apply(tmp10, []any{tmp14}) + tmp16 := lang.Apply(tmp9, []any{tmp15}) + tmp17 := lang.Apply(tmp6, []any{tmp8, tmp16}) + tmp18 := lang.Apply(tmp5, []any{tmp17}) + return tmp18 + } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bound_DASH_fn = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_bound_DASH_fn.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // inst? + // bound? { - tmp0 := sym_inst_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x satisfies Inst", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(6837), kw_end_DASH_line, int(6837))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] + tmp0 := sym_bound_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_vars)), kw_doc, "Returns true if all of the vars provided as arguments have any bound value, root or thread-local.\n Implies that deref'ing the provided vars will succeed. Returns true if no vars are provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(5491), kw_end_DASH_line, int(5491))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v5 := args[0] + _ = v5 + tmp6, ok := lang.FieldOrMethod(v5, "isBound") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "isBound"))) + } + var tmp7 any + switch reflect.TypeOf(tmp6).Kind() { + case reflect.Func: + tmp7 = lang.Apply(tmp6, nil) + default: + tmp7 = tmp6 + } + return tmp7 + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5497), kw_column, int(11), kw_end_DASH_line, int(5497), kw_end_DASH_column, int(69)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp7 := lang.Apply(tmp3, []any{tmp6, v2}) + return tmp7 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bound_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bound_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bounded-count + { + tmp0 := sym_bounded_DASH_count.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n, sym_coll)), kw_doc, "If coll is counted? returns its count, else will count at most the first n\n elements of coll using its seq", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(7410), kw_end_DASH_line, int(7410))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - return nil + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_counted_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + tmp7 := checkDerefVar(var_glojure_DOT_core_count) + tmp8 := lang.Apply(tmp7, []any{v3}) + tmp4 = tmp8 + } else { + var tmp9 any + { // let + // let binding "i" + var v10 any = int64(0) + _ = v10 + // let binding "s" + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := lang.Apply(tmp11, []any{v3}) + var v13 any = tmp12 + _ = v13 + for { + var tmp14 any + var tmp15 any + { // let + // let binding "and__0__auto__" + var v16 any = v13 + _ = v16 + var tmp17 any + if lang.IsTruthy(v16) { + tmp18 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp19 := lang.Apply(tmp18, []any{v10, v2}) + tmp17 = tmp19 + } else { + tmp17 = v16 + } + tmp15 = tmp17 + } // end let + if lang.IsTruthy(tmp15) { + tmp17 := checkDerefVar(var_glojure_DOT_core_inc) + tmp18 := lang.Apply(tmp17, []any{v10}) + var tmp16 any = tmp18 + tmp20 := checkDerefVar(var_glojure_DOT_core_next) + tmp21 := lang.Apply(tmp20, []any{v13}) + var tmp19 any = tmp21 + v10 = tmp16 + v13 = tmp19 + continue + } else { + tmp14 = v10 + } + tmp9 = tmp14 + break + } + } // end let + tmp4 = tmp9 + } + return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bounded_DASH_count = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_bounded_DASH_count.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // instance? + // butlast { - tmp0 := sym_instance_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_c, sym_x)), kw_doc, "Evaluates x and tests if it is an instance of the type\n t. Returns true or false", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(2), kw_line, int(139), kw_end_DASH_line, int(143))).(*lang.Symbol) - var tmp2 lang.FnFunc - { // function instance? - var v3 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6 := lang.Apply(lang.HasType, []any{v4, v5}) - return tmp6 + tmp0 := sym_butlast.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Return a seq of all but the last item in coll, in linear time", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(2), kw_line, int(272), kw_end_DASH_line, int(276))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function butlast + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + var tmp4 any + { // let + // let binding "ret" + tmp5 := lang.NewVector() + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(277), kw_column, int(23), kw_end_DASH_line, int(277), kw_end_DASH_column, int(24)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v8 any = tmp7 + _ = v8 + // let binding "s" + var v9 any = v3 + _ = v9 + for { + var tmp10 any + tmp11 := checkDerefVar(var_glojure_DOT_core_next) + tmp12 := lang.Apply(tmp11, []any{v9}) + if lang.IsTruthy(tmp12) { + tmp14 := checkDerefVar(var_glojure_DOT_core_conj) + tmp15 := checkDerefVar(var_glojure_DOT_core_first) + tmp16 := lang.Apply(tmp15, []any{v9}) + tmp17 := lang.Apply(tmp14, []any{v8, tmp16}) + var tmp13 any = tmp17 + tmp19 := checkDerefVar(var_glojure_DOT_core_next) + tmp20 := lang.Apply(tmp19, []any{v9}) + var tmp18 any = tmp20 + v8 = tmp13 + v9 = tmp18 + continue + } else { + tmp21 := checkDerefVar(var_glojure_DOT_core_seq) + tmp22 := lang.Apply(tmp21, []any{v8}) + tmp10 = tmp22 + } + tmp4 = tmp10 + break + } + } // end let + return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(143), kw_column, int(12), kw_end_DASH_line, int(143), kw_end_DASH_column, int(85))).(lang.FnFunc) - v3 = tmp2 - _ = v3 + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(276), kw_column, int(10), kw_end_DASH_line, int(280), kw_end_DASH_column, int(27))).(lang.FnFunc) + v2 = tmp1 + _ = v2 } - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core_butlast = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_butlast.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // int + // byte { var tmp1 lang.FnFunc - { // function int__inliner + { // function byte__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) @@ -27448,9 +21502,9 @@ func LoadNS() { var tmp14 any tmp15 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp15) { - tmp14 = sym_uncheckedIntCast + tmp14 = sym_uncheckedByteCast } else { - tmp14 = sym_intCast + tmp14 = sym_byteCast } tmp16 := lang.Apply(tmp13, []any{tmp14}) tmp17 := checkDerefVar(var_glojure_DOT_core_list) @@ -27465,29 +21519,25 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := sym_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to int", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(875), kw_end_DASH_line, int(875))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_byte.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to byte", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3505), kw_end_DASH_line, int(3505))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(runtime.RT, "IntCast") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("IntCast is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.ByteCast, []any{v3}) + return tmp4 }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_byte = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_byte.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // int-array + // byte-array { var tmp1 lang.FnFunc - { // function int-array__inliner + { // function byte-array__inliner var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { @@ -27502,7 +21552,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_IntArray}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_ByteArray}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := checkDerefVar(var_glojure_DOT_core_seq) tmp14 := checkDerefVar(var_glojure_DOT_core_concat) @@ -27521,639 +21571,45 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := sym_int_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_size_DASH_or_DASH_seq), lang.NewVector(sym_size, sym_init_DASH_val_DASH_or_DASH_seq)), kw_inline, tmp1, kw_doc, "Creates an array of ints", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(5356), kw_end_DASH_line, int(5356))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "IntArray") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("IntArray is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - case 2: - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "IntArrayInit") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("IntArrayInit is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 - default: - checkArity(args, -1) - panic("unreachable") - } - }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // int? - { - tmp0 := sym_int_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a fixed precision integer", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1395), kw_end_DASH_line, int(1395))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "or__0__auto__" - tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp6 := lang.Apply(tmp5, []any{lang.Builtins["int64"], v3}) - var v7 any = tmp6 - _ = v7 - var tmp8 any - if lang.IsTruthy(v7) { - tmp8 = v7 - } else { - var tmp9 any - { // let - // let binding "or__0__auto__" - tmp10 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp11 := lang.Apply(tmp10, []any{nil, v3}) - var v12 any = tmp11 - _ = v12 - var tmp13 any - if lang.IsTruthy(v12) { - tmp13 = v12 - } else { - var tmp14 any - { // let - // let binding "or__0__auto__" - tmp15 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp16 := lang.Apply(tmp15, []any{nil, v3}) - var v17 any = tmp16 - _ = v17 - var tmp18 any - if lang.IsTruthy(v17) { - tmp18 = v17 - } else { - tmp19 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp20 := lang.Apply(tmp19, []any{nil, v3}) - tmp18 = tmp20 - } - tmp14 = tmp18 - } // end let - tmp13 = tmp14 - } - tmp9 = tmp13 - } // end let - tmp8 = tmp9 - } - tmp4 = tmp8 - } // end let - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // integer? - { - tmp0 := sym_integer_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_doc, "Returns true if n is an integer", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(1379), kw_end_DASH_line, int(1379))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := lang.Apply(lang.IsInteger, []any{v3}) - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // interleave - { - tmp0 := sym_interleave.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_c1), lang.NewVector(sym_c1, sym_c2), lang.NewVector(sym_c1, sym_c2, sym__AMP_, sym_colls)), kw_doc, "Returns a lazy seq of the first item in each coll, then the second etc.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4308), kw_end_DASH_line, int(4308))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - return lang.NewList() - case 1: - v3 := args[0] - _ = v3 - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - return v3 - }) - tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) - return tmp5 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 lang.FnFunc - tmp5 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - var tmp6 any - { // let - // let binding "s1" - tmp7 := checkDerefVar(var_glojure_DOT_core_seq) - tmp8 := lang.Apply(tmp7, []any{v3}) - var v9 any = tmp8 - _ = v9 - // let binding "s2" - tmp10 := checkDerefVar(var_glojure_DOT_core_seq) - tmp11 := lang.Apply(tmp10, []any{v4}) - var v12 any = tmp11 - _ = v12 - var tmp13 any - var tmp14 any - { // let - // let binding "and__0__auto__" - var v15 any = v9 - _ = v15 - var tmp16 any - if lang.IsTruthy(v15) { - tmp16 = v12 - } else { - tmp16 = v15 - } - tmp14 = tmp16 - } // end let - if lang.IsTruthy(tmp14) { - tmp15 := checkDerefVar(var_glojure_DOT_core_cons) - tmp16 := checkDerefVar(var_glojure_DOT_core_first) - tmp17 := lang.Apply(tmp16, []any{v9}) - tmp18 := checkDerefVar(var_glojure_DOT_core_cons) - tmp19 := checkDerefVar(var_glojure_DOT_core_first) - tmp20 := lang.Apply(tmp19, []any{v12}) - tmp21 := checkDerefVar(var_glojure_DOT_core_interleave) - tmp22 := checkDerefVar(var_glojure_DOT_core_rest) - tmp23 := lang.Apply(tmp22, []any{v9}) - tmp24 := checkDerefVar(var_glojure_DOT_core_rest) - tmp25 := lang.Apply(tmp24, []any{v12}) - tmp26 := lang.Apply(tmp21, []any{tmp23, tmp25}) - tmp27 := lang.Apply(tmp18, []any{tmp20, tmp26}) - tmp28 := lang.Apply(tmp15, []any{tmp17, tmp27}) - tmp13 = tmp28 - } else { - } - tmp6 = tmp13 - } // end let - return tmp6 - }) - tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) - return tmp6 - default: - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - var tmp6 lang.FnFunc - tmp6 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - var tmp7 any - { // let - // let binding "ss" - tmp8 := checkDerefVar(var_glojure_DOT_core_map) - tmp9 := checkDerefVar(var_glojure_DOT_core_seq) - tmp10 := checkDerefVar(var_glojure_DOT_core_conj) - tmp11 := lang.Apply(tmp10, []any{v5, v4, v3}) - tmp12 := lang.Apply(tmp8, []any{tmp9, tmp11}) - var v13 any = tmp12 - _ = v13 - var tmp14 any - tmp15 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) - tmp16 := checkDerefVar(var_glojure_DOT_core_identity) - tmp17 := lang.Apply(tmp15, []any{tmp16, v13}) - if lang.IsTruthy(tmp17) { - tmp18 := checkDerefVar(var_glojure_DOT_core_concat) - tmp19 := checkDerefVar(var_glojure_DOT_core_map) - tmp20 := checkDerefVar(var_glojure_DOT_core_first) - tmp21 := lang.Apply(tmp19, []any{tmp20, v13}) - tmp22 := checkDerefVar(var_glojure_DOT_core_apply) - tmp23 := checkDerefVar(var_glojure_DOT_core_interleave) - tmp24 := checkDerefVar(var_glojure_DOT_core_map) - tmp25 := checkDerefVar(var_glojure_DOT_core_rest) - tmp26 := lang.Apply(tmp24, []any{tmp25, v13}) - tmp27 := lang.Apply(tmp22, []any{tmp23, tmp26}) - tmp28 := lang.Apply(tmp18, []any{tmp21, tmp27}) - tmp14 = tmp28 - } else { - } - tmp7 = tmp14 - } // end let - return tmp7 - }) - tmp7 := lang.Apply(lang.NewLazySeq, []any{tmp6}) - return tmp7 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // intern - { - tmp0 := sym_intern.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns, sym_name), lang.NewVector(sym_ns, sym_name, sym_val)), kw_doc, "Finds or creates a var named by the symbol name in the namespace\n ns (which can be a symbol or a namespace), setting its root binding\n to val if supplied. The namespace must exist. The var will adopt any\n metadata from the name symbol. Returns the var.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(6311), kw_end_DASH_line, int(6311))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - { // let - // let binding "v" - tmp6 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) - tmp7 := lang.Apply(tmp6, []any{v3}) - tmp8 := lang.Apply(nil, []any{tmp7, v4}) - var v9 any = tmp8 - _ = v9 - var tmp10 any - tmp11 := checkDerefVar(var_glojure_DOT_core_meta) - tmp12 := lang.Apply(tmp11, []any{v4}) - if lang.IsTruthy(tmp12) { - tmp13 := checkDerefVar(var_glojure_DOT_core_meta) - tmp14 := lang.Apply(tmp13, []any{v4}) - tmp15, _ := lang.FieldOrMethod(v9, "setMeta") - if reflect.TypeOf(tmp15).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMeta is not a function"))) - } - tmp16 := lang.Apply(tmp15, []any{tmp14}) - tmp10 = tmp16 - } else { - } - _ = tmp10 - tmp5 = v9 - } // end let - return tmp5 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var tmp6 any - { // let - // let binding "v" - tmp7 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) - tmp8 := lang.Apply(tmp7, []any{v3}) - tmp9 := lang.Apply(nil, []any{tmp8, v4, v5}) - var v10 any = tmp9 - _ = v10 - var tmp11 any - tmp12 := checkDerefVar(var_glojure_DOT_core_meta) - tmp13 := lang.Apply(tmp12, []any{v4}) - if lang.IsTruthy(tmp13) { - tmp14 := checkDerefVar(var_glojure_DOT_core_meta) - tmp15 := lang.Apply(tmp14, []any{v4}) - tmp16, _ := lang.FieldOrMethod(v10, "setMeta") - if reflect.TypeOf(tmp16).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMeta is not a function"))) - } - tmp17 := lang.Apply(tmp16, []any{tmp15}) - tmp11 = tmp17 - } else { - } - _ = tmp11 - tmp6 = v10 - } // end let - return tmp6 - default: - checkArity(args, -1) - panic("unreachable") - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // interpose - { - tmp0 := sym_interpose.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_sep), lang.NewVector(sym_sep, sym_coll)), kw_doc, "Returns a lazy seq of the elements of coll separated by sep.\n Returns a stateful transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(5230), kw_end_DASH_line, int(5230))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v5 := args[0] - _ = v5 - var tmp6 any - { // let - // let binding "started" - tmp7 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) - tmp8 := lang.Apply(tmp7, []any{false}) - var v9 any = tmp8 - _ = v9 - var tmp10 lang.FnFunc - tmp10 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp11 := lang.Apply(v5, nil) - return tmp11 - case 1: - v11 := args[0] - _ = v11 - tmp12 := lang.Apply(v5, []any{v11}) - return tmp12 - case 2: - v11 := args[0] - _ = v11 - v12 := args[1] - _ = v12 - var tmp13 any - tmp14 := checkDerefVar(var_glojure_DOT_core_deref) - tmp15 := lang.Apply(tmp14, []any{v9}) - if lang.IsTruthy(tmp15) { - var tmp16 any - { // let - // let binding "sepr" - tmp17 := lang.Apply(v5, []any{v11, v3}) - var v18 any = tmp17 - _ = v18 - var tmp19 any - tmp20 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) - tmp21 := lang.Apply(tmp20, []any{v18}) - if lang.IsTruthy(tmp21) { - tmp19 = v18 - } else { - tmp22 := lang.Apply(v5, []any{v18, v12}) - tmp19 = tmp22 - } - tmp16 = tmp19 - } // end let - tmp13 = tmp16 - } else { - tmp17 := checkDerefVar(var_glojure_DOT_core_vreset_BANG_) - tmp18 := lang.Apply(tmp17, []any{v9, true}) - _ = tmp18 - tmp19 := lang.Apply(v5, []any{v11, v12}) - tmp13 = tmp19 - } - return tmp13 - default: - checkArity(args, -1) - panic("unreachable") - } - }) - tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5238), kw_column, int(8), kw_end_DASH_line, int(5249), kw_end_DASH_column, int(35)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp6 = tmp12 - } // end let - return tmp6 - }) - tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5236), kw_column, int(4), kw_end_DASH_line, int(5249), kw_end_DASH_column, int(37)) - tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp6 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_drop) - tmp6 := checkDerefVar(var_glojure_DOT_core_interleave) - tmp7 := checkDerefVar(var_glojure_DOT_core_repeat) - tmp8 := lang.Apply(tmp7, []any{v3}) - tmp9 := lang.Apply(tmp6, []any{tmp8, v4}) - tmp10 := lang.Apply(tmp5, []any{int64(1), tmp9}) - return tmp10 - default: - checkArity(args, -1) - panic("unreachable") - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // into - { - tmp0 := sym_into.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_to), lang.NewVector(sym_to, sym_from), lang.NewVector(sym_to, sym_xform, sym_from)), kw_doc, "Returns a new coll consisting of to with all of the items of\n from conjoined. A transducer may be supplied.\n (into x) returns x. (into) returns [].", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(6922), kw_end_DASH_line, int(6922))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp3 := lang.NewVector() - tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6928), kw_column, int(7), kw_end_DASH_line, int(6928), kw_end_DASH_column, int(8)) - tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp5 - case 1: - v3 := args[0] - _ = v3 - return v3 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - tmp6 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp7 := reflect.TypeOf((*lang.IEditableCollection)(nil)).Elem() - tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) - if lang.IsTruthy(tmp8) { - tmp9 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) - tmp10 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) - tmp11 := checkDerefVar(var_glojure_DOT_core_reduce) - tmp12 := checkDerefVar(var_glojure_DOT_core_conj_BANG_) - tmp13 := checkDerefVar(var_glojure_DOT_core_transient) - tmp14 := lang.Apply(tmp13, []any{v3}) - tmp15 := lang.Apply(tmp11, []any{tmp12, tmp14, v4}) - tmp16 := lang.Apply(tmp10, []any{tmp15}) - tmp17 := checkDerefVar(var_glojure_DOT_core_meta) - tmp18 := lang.Apply(tmp17, []any{v3}) - tmp19 := lang.Apply(tmp9, []any{tmp16, tmp18}) - tmp5 = tmp19 - } else { - tmp20 := checkDerefVar(var_glojure_DOT_core_reduce) - tmp21 := checkDerefVar(var_glojure_DOT_core_conj) - tmp22 := lang.Apply(tmp20, []any{tmp21, v3, v4}) - tmp5 = tmp22 - } - return tmp5 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var tmp6 any - tmp7 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp8 := reflect.TypeOf((*lang.IEditableCollection)(nil)).Elem() - tmp9 := lang.Apply(tmp7, []any{tmp8, v3}) - if lang.IsTruthy(tmp9) { - var tmp10 any - { // let - // let binding "tm" - tmp11 := checkDerefVar(var_glojure_DOT_core_meta) - tmp12 := lang.Apply(tmp11, []any{v3}) - var v13 any = tmp12 - _ = v13 - // let binding "rf" - var tmp14 lang.FnFunc - tmp14 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v15 := args[0] - _ = v15 - tmp16 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) - tmp17 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) - tmp18 := lang.Apply(tmp17, []any{v15}) - tmp19 := lang.Apply(tmp16, []any{tmp18, v13}) - return tmp19 - case 2: - v15 := args[0] - _ = v15 - v16 := args[1] - _ = v16 - tmp17 := checkDerefVar(var_glojure_DOT_core_conj_BANG_) - tmp18 := lang.Apply(tmp17, []any{v15, v16}) - return tmp18 - default: - checkArity(args, -1) - panic("unreachable") - } - }) - tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6937), kw_column, int(17), kw_end_DASH_line, int(6939), kw_end_DASH_column, int(44)) - tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v17 any = tmp16 - _ = v17 - tmp18 := checkDerefVar(var_glojure_DOT_core_transduce) - tmp19 := checkDerefVar(var_glojure_DOT_core_transient) - tmp20 := lang.Apply(tmp19, []any{v3}) - tmp21 := lang.Apply(tmp18, []any{v4, v17, tmp20, v5}) - tmp10 = tmp21 - } // end let - tmp6 = tmp10 - } else { - tmp11 := checkDerefVar(var_glojure_DOT_core_transduce) - tmp12 := checkDerefVar(var_glojure_DOT_core_conj) - tmp13 := lang.Apply(tmp11, []any{v4, tmp12, v3, v5}) - tmp6 = tmp13 - } - return tmp6 - default: - checkArity(args, -1) - panic("unreachable") - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // into-array - { - tmp0 := sym_into_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_aseq), lang.NewVector(sym_type, sym_aseq)), kw_doc, "Returns an array with components set to the values in aseq. The array's\n component type is type if provided, or the type of the first value in\n aseq if present, or Object. All values in aseq must be compatible with\n the component type. Class objects for the primitive types can be obtained\n using, e.g., Integer/TYPE.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(3444), kw_end_DASH_line, int(3444))).(*lang.Symbol) + tmp0 := sym_byte_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_size_DASH_or_DASH_seq), lang.NewVector(sym_size, sym_init_DASH_val_DASH_or_DASH_seq)), kw_inline, tmp1, kw_doc, "Creates an array of bytes", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(5317), kw_end_DASH_line, int(5317))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: v3 := args[0] _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "ByteArray") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ByteArray is not a function"))) + } tmp5 := lang.Apply(tmp4, []any{v3}) - tmp6 := lang.Apply(nil, []any{tmp5}) - return tmp6 + return tmp5 case 2: v3 := args[0] _ = v3 v4 := args[1] _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_seq) - tmp6 := lang.Apply(tmp5, []any{v4}) - tmp7 := lang.Apply(nil, []any{v3, tmp6}) - return tmp7 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "ByteArrayInit") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ByteArrayInit is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 default: checkArity(args, -1) panic("unreachable") } }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // into1 - { - tmp0 := sym_into1.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_to, sym_from)), kw_doc, "Returns a new coll consisting of to-coll with all of the items of\n from-coll conjoined.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(3416), kw_end_DASH_line, int(3416), kw_private, true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - tmp6 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp7 := reflect.TypeOf((*lang.IEditableCollection)(nil)).Elem() - tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) - if lang.IsTruthy(tmp8) { - tmp9 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) - tmp10 := checkDerefVar(var_glojure_DOT_core_reduce1) - tmp11 := checkDerefVar(var_glojure_DOT_core_conj_BANG_) - tmp12 := checkDerefVar(var_glojure_DOT_core_transient) - tmp13 := lang.Apply(tmp12, []any{v3}) - tmp14 := lang.Apply(tmp10, []any{tmp11, tmp13, v4}) - tmp15 := lang.Apply(tmp9, []any{tmp14}) - tmp5 = tmp15 - } else { - tmp16 := checkDerefVar(var_glojure_DOT_core_reduce1) - tmp17 := checkDerefVar(var_glojure_DOT_core_conj) - tmp18 := lang.Apply(tmp16, []any{tmp17, v3, v4}) - tmp5 = tmp18 - } - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core_byte_DASH_array = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_byte_DASH_array.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // ints + // bytes { var tmp1 lang.FnFunc - { // function ints + { // function bytes var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) @@ -28166,7 +21622,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Ints}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Bytes}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := lang.Apply(tmp12, []any{v3}) tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) @@ -28176,698 +21632,278 @@ func LoadNS() { v2 = tmp1 _ = v2 } - tmp0 := sym_ints.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xs)), kw_inline, tmp1, kw_doc, "Casts to int[]", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(12), kw_line, int(5397), kw_end_DASH_line, int(5397))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_bytes.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xs)), kw_inline, tmp1, kw_doc, "Casts to bytes[]", kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(12), kw_line, int(5377), kw_end_DASH_line, int(5377))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Ints") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Ints is not a function"))) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Bytes") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Bytes is not a function"))) } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bytes = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_bytes.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // io! + // bytes? { - tmp0 := sym_io_BANG_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_body)), kw_doc, "If an io! block occurs in a transaction, throws an\n IllegalStateException, else runs body in an implicit do. If the\n first expression in body is a literal string, will use that as the\n exception message.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(11), kw_line, int(2504), kw_end_DASH_line, int(2504))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - var tmp6 any - { // let - // let binding "message" - var tmp7 any - tmp8 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) - tmp9 := checkDerefVar(var_glojure_DOT_core_first) - tmp10 := lang.Apply(tmp9, []any{v5}) - tmp11 := lang.Apply(tmp8, []any{tmp10}) - if lang.IsTruthy(tmp11) { - tmp12 := checkDerefVar(var_glojure_DOT_core_first) - tmp13 := lang.Apply(tmp12, []any{v5}) - tmp7 = tmp13 - } else { - } - var v14 any = tmp7 - _ = v14 - // let binding "body" - var tmp15 any - if lang.IsTruthy(v14) { - tmp16 := checkDerefVar(var_glojure_DOT_core_next) - tmp17 := lang.Apply(tmp16, []any{v5}) - tmp15 = tmp17 - } else { - tmp15 = v5 - } - var v18 any = tmp15 - _ = v18 - tmp19 := checkDerefVar(var_glojure_DOT_core_seq) - tmp20 := checkDerefVar(var_glojure_DOT_core_concat) - tmp21 := checkDerefVar(var_glojure_DOT_core_list) - tmp22 := lang.Apply(tmp21, []any{sym_if}) - tmp23 := checkDerefVar(var_glojure_DOT_core_list) - tmp24 := checkDerefVar(var_glojure_DOT_core_seq) - tmp25 := checkDerefVar(var_glojure_DOT_core_concat) - tmp26 := checkDerefVar(var_glojure_DOT_core_list) - tmp27 := lang.Apply(tmp26, []any{sym_glojure_DOT_lang_DOT_LockingTransaction_SLASH_isRunning}) - tmp28 := lang.Apply(tmp25, []any{tmp27}) - tmp29 := lang.Apply(tmp24, []any{tmp28}) - tmp30 := lang.Apply(tmp23, []any{tmp29}) - tmp31 := checkDerefVar(var_glojure_DOT_core_list) - tmp32 := checkDerefVar(var_glojure_DOT_core_seq) - tmp33 := checkDerefVar(var_glojure_DOT_core_concat) - tmp34 := checkDerefVar(var_glojure_DOT_core_list) - tmp35 := lang.Apply(tmp34, []any{sym_throw}) - tmp36 := checkDerefVar(var_glojure_DOT_core_list) - tmp37 := checkDerefVar(var_glojure_DOT_core_seq) - tmp38 := checkDerefVar(var_glojure_DOT_core_concat) - tmp39 := checkDerefVar(var_glojure_DOT_core_list) - tmp40 := lang.Apply(tmp39, []any{sym_new}) - tmp41 := checkDerefVar(var_glojure_DOT_core_list) - tmp42 := lang.Apply(tmp41, []any{sym_glojure_DOT_core_SLASH_IllegalStateException}) - tmp43 := checkDerefVar(var_glojure_DOT_core_list) - var tmp44 any - { // let - // let binding "or__0__auto__" - var v45 any = v14 - _ = v45 - var tmp46 any - if lang.IsTruthy(v45) { - tmp46 = v45 - } else { - tmp46 = "I/O in transaction" - } - tmp44 = tmp46 - } // end let - tmp45 := lang.Apply(tmp43, []any{tmp44}) - tmp46 := lang.Apply(tmp38, []any{tmp40, tmp42, tmp45}) - tmp47 := lang.Apply(tmp37, []any{tmp46}) - tmp48 := lang.Apply(tmp36, []any{tmp47}) - tmp49 := lang.Apply(tmp33, []any{tmp35, tmp48}) - tmp50 := lang.Apply(tmp32, []any{tmp49}) - tmp51 := lang.Apply(tmp31, []any{tmp50}) - tmp52 := checkDerefVar(var_glojure_DOT_core_list) - tmp53 := checkDerefVar(var_glojure_DOT_core_seq) - tmp54 := checkDerefVar(var_glojure_DOT_core_concat) - tmp55 := checkDerefVar(var_glojure_DOT_core_list) - tmp56 := lang.Apply(tmp55, []any{sym_do}) - tmp57 := lang.Apply(tmp54, []any{tmp56, v18}) - tmp58 := lang.Apply(tmp53, []any{tmp57}) - tmp59 := lang.Apply(tmp52, []any{tmp58}) - tmp60 := lang.Apply(tmp20, []any{tmp22, tmp30, tmp51, tmp59}) - tmp61 := lang.Apply(tmp19, []any{tmp60}) - tmp6 = tmp61 - } // end let - return tmp6 + tmp0 := sym_bytes_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a byte array", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(5412), kw_end_DASH_line, int(5412))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + tmp3 = false + } else { + tmp6 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp7 := checkDerefVar(var_glojure_DOT_core_class) + tmp8 := lang.Apply(tmp7, []any{v2}) + tmp9, ok := lang.FieldOrMethod(tmp8, "getComponentType") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp8, "getComponentType"))) + } + var tmp10 any + switch reflect.TypeOf(tmp9).Kind() { + case reflect.Func: + tmp10 = lang.Apply(tmp9, nil) + default: + tmp10 = tmp9 + } + tmp11 := lang.Apply(tmp6, []any{tmp10, nil}) + tmp3 = tmp11 } + return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bytes_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_bytes_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // isa? + // char { - tmp0 := sym_isa_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_child, sym_parent), lang.NewVector(sym_h, sym_child, sym_parent)), kw_doc, "Returns true if (= child parent), or child is directly or indirectly derived from\n parent, either via a Java type inheritance relationship or a\n relationship established via derive. h must be a hierarchy obtained\n from make-hierarchy, if not supplied defaults to the global\n hierarchy", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(5543), kw_end_DASH_line, int(5543))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_isa_QMARK_) - tmp6 := checkDerefVar(var_glojure_DOT_core_global_DASH_hierarchy) - tmp7 := lang.Apply(tmp5, []any{tmp6, v3, v4}) - return tmp7 - case 3: + var tmp1 lang.FnFunc + { // function char__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) v3 := args[0] _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var tmp6 any - { // let - // let binding "or__0__auto__" - tmp7 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp8 := lang.Apply(tmp7, []any{v4, v5}) - var v9 any = tmp8 - _ = v9 - var tmp10 any - if lang.IsTruthy(v9) { - tmp10 = v9 - } else { - var tmp11 any - { // let - // let binding "or__0__auto__" - var tmp12 any - { // let - // let binding "and__0__auto__" - tmp13 := checkDerefVar(var_glojure_DOT_core_class_QMARK_) - tmp14 := lang.Apply(tmp13, []any{v5}) - var v15 any = tmp14 - _ = v15 - var tmp16 any - if lang.IsTruthy(v15) { - var tmp17 any - { // let - // let binding "and__0__auto__" - tmp18 := checkDerefVar(var_glojure_DOT_core_class_QMARK_) - tmp19 := lang.Apply(tmp18, []any{v4}) - var v20 any = tmp19 - _ = v20 - var tmp21 any - if lang.IsTruthy(v20) { - tmp22, _ := lang.FieldOrMethod(v4, "AssignableTo") - if reflect.TypeOf(tmp22).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("AssignableTo is not a function"))) - } - tmp23 := lang.Apply(tmp22, []any{v5}) - tmp21 = tmp23 - } else { - tmp21 = v20 - } - tmp17 = tmp21 - } // end let - tmp16 = tmp17 - } else { - tmp16 = v15 - } - tmp12 = tmp16 - } // end let - var v13 any = tmp12 - _ = v13 - var tmp14 any - if lang.IsTruthy(v13) { - tmp14 = v13 - } else { - var tmp15 any - { // let - // let binding "or__0__auto__" - tmp16 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) - tmp17 := lang.Apply(kw_ancestors, []any{v3}) - tmp18 := lang.Apply(tmp17, []any{v4}) - tmp19 := lang.Apply(tmp16, []any{tmp18, v5}) - var v20 any = tmp19 - _ = v20 - var tmp21 any - if lang.IsTruthy(v20) { - tmp21 = v20 - } else { - var tmp22 any - { // let - // let binding "or__0__auto__" - var tmp23 any - { // let - // let binding "and__0__auto__" - tmp24 := checkDerefVar(var_glojure_DOT_core_class_QMARK_) - tmp25 := lang.Apply(tmp24, []any{v4}) - var v26 any = tmp25 - _ = v26 - var tmp27 any - if lang.IsTruthy(v26) { - tmp28 := checkDerefVar(var_glojure_DOT_core_some) - var tmp29 lang.FnFunc - tmp29 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v30 := args[0] - _ = v30 - tmp31 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) - tmp32 := lang.Apply(kw_ancestors, []any{v3}) - tmp33 := lang.Apply(tmp32, []any{v30}) - tmp34 := lang.Apply(tmp31, []any{tmp33, v5}) - return tmp34 - }) - tmp30 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5556), kw_column, int(34), kw_end_DASH_line, int(5556), kw_end_DASH_column, int(71)) - tmp31, err := lang.WithMeta(tmp29, tmp30.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp32 := checkDerefVar(var_glojure_DOT_core_supers) - tmp33 := lang.Apply(tmp32, []any{v4}) - tmp34 := lang.Apply(tmp28, []any{tmp31, tmp33}) - tmp27 = tmp34 - } else { - tmp27 = v26 - } - tmp23 = tmp27 - } // end let - var v24 any = tmp23 - _ = v24 - var tmp25 any - if lang.IsTruthy(v24) { - tmp25 = v24 - } else { - var tmp26 any - { // let - // let binding "and__0__auto__" - tmp27 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) - tmp28 := lang.Apply(tmp27, []any{v5}) - var v29 any = tmp28 - _ = v29 - var tmp30 any - if lang.IsTruthy(v29) { - var tmp31 any - { // let - // let binding "and__0__auto__" - tmp32 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) - tmp33 := lang.Apply(tmp32, []any{v4}) - var v34 any = tmp33 - _ = v34 - var tmp35 any - if lang.IsTruthy(v34) { - var tmp36 any - { // let - // let binding "and__0__auto__" - tmp37 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp38 := checkDerefVar(var_glojure_DOT_core_count) - tmp39 := lang.Apply(tmp38, []any{v5}) - tmp40 := checkDerefVar(var_glojure_DOT_core_count) - tmp41 := lang.Apply(tmp40, []any{v4}) - tmp42 := lang.Apply(tmp37, []any{tmp39, tmp41}) - var v43 any = tmp42 - _ = v43 - var tmp44 any - if lang.IsTruthy(v43) { - var tmp45 any - { // let - // let binding "ret" - var v46 any = true - _ = v46 - // let binding "i" - var v47 any = int64(0) - _ = v47 - for { - var tmp48 any - var tmp49 any - { // let - // let binding "or__0__auto__" - tmp50 := checkDerefVar(var_glojure_DOT_core_not) - tmp51 := lang.Apply(tmp50, []any{v46}) - var v52 any = tmp51 - _ = v52 - var tmp53 any - if lang.IsTruthy(v52) { - tmp53 = v52 - } else { - tmp54 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp55 := checkDerefVar(var_glojure_DOT_core_count) - tmp56 := lang.Apply(tmp55, []any{v5}) - tmp57 := lang.Apply(tmp54, []any{v47, tmp56}) - tmp53 = tmp57 - } - tmp49 = tmp53 - } // end let - if lang.IsTruthy(tmp49) { - tmp48 = v46 - } else { - tmp51 := checkDerefVar(var_glojure_DOT_core_isa_QMARK_) - tmp52 := lang.Apply(v4, []any{v47}) - tmp53 := lang.Apply(v5, []any{v47}) - tmp54 := lang.Apply(tmp51, []any{v3, tmp52, tmp53}) - var tmp50 any = tmp54 - tmp56 := checkDerefVar(var_glojure_DOT_core_inc) - tmp57 := lang.Apply(tmp56, []any{v47}) - var tmp55 any = tmp57 - v46 = tmp50 - v47 = tmp55 - continue - } - tmp45 = tmp48 - break - } - } // end let - tmp44 = tmp45 - } else { - tmp44 = v43 - } - tmp36 = tmp44 - } // end let - tmp35 = tmp36 - } else { - tmp35 = v34 - } - tmp31 = tmp35 - } // end let - tmp30 = tmp31 - } else { - tmp30 = v29 - } - tmp26 = tmp30 - } // end let - tmp25 = tmp26 - } - tmp22 = tmp25 - } // end let - tmp21 = tmp22 - } - tmp15 = tmp21 - } // end let - tmp14 = tmp15 - } - tmp11 = tmp14 - } // end let - tmp10 = tmp11 - } - tmp6 = tmp10 - } // end let - return tmp6 - default: - checkArity(args, -1) - panic("unreachable") - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp15) { + tmp14 = sym_uncheckedCharCast + } else { + tmp14 = sym_charCast + } + tmp16 := lang.Apply(tmp13, []any{tmp14}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := lang.Apply(tmp12, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp11, []any{tmp19}) + tmp21 := lang.Apply(tmp10, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + }) + v2 = tmp1 + _ = v2 } - } - // iterate - { - tmp0 := sym_iterate.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_x)), kw_doc, "Returns a lazy (infinite!) sequence of x, (f x), (f (f x)) etc.\n f must be free of side-effects", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(3011), kw_end_DASH_line, int(3011))).(*lang.Symbol) + tmp0 := sym_char.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to char", kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3511), kw_end_DASH_line, int(3511))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) + checkArity(args, 1) v3 := args[0] _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.Apply(nil, []any{v3, v4}) + tmp4, _ := lang.FieldOrMethod(runtime.RT, "CharCast") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("CharCast is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core_char = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_char.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // iteration + // char-array { - tmp0 := sym_iteration.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_step, sym__AMP_, lang.NewMap(kw_keys, lang.NewVector(sym_somef, sym_vf, sym_kf, sym_initk), kw_or, lang.NewMap(sym_vf, sym_identity, sym_kf, sym_identity, sym_somef, sym_some_QMARK_, sym_initk, nil)))), kw_doc, "Creates a seqable/reducible via repeated calls to step,\n a function of some (continuation token) 'k'. The first call to step\n will be passed initk, returning 'ret'. Iff (somef ret) is true,\n (vf ret) will be included in the iteration, else iteration will\n terminate and vf/kf will not be called. If (kf ret) is non-nil it\n will be passed to the next step call, else iteration will terminate.\n\n This can be used e.g. to consume APIs that return paginated or batched data.\n\n step - (possibly impure) fn of 'k' -> 'ret'\n\n :somef - fn of 'ret' -> logical true/false, default 'some?'\n :vf - fn of 'ret' -> 'v', a value produced by the iteration, default 'identity'\n :kf - fn of 'ret' -> 'next-k' or nil (signaling 'do not continue'), default 'identity'\n :initk - the first value passed to step, default 'nil'\n\n It is presumed that step with non-initk is unreproducible/non-idempotent.\n If step with initk is unreproducible it is on the consumer to not consume twice.", kw_file, "glojure/core.glj", kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(7716), kw_end_DASH_line, int(7716))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function char-array__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_CharArray}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_unquote_DASH_splicing}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_glojure_DOT_core_SLASH_args}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + } + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_char_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_size_DASH_or_DASH_seq), lang.NewVector(sym_size, sym_init_DASH_val_DASH_or_DASH_seq)), kw_inline, tmp1, kw_doc, "Creates an array of chars", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(5325), kw_end_DASH_line, int(5325))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - default: - checkArity(args, 1) + case 1: v3 := args[0] _ = v3 - var v4 any = lang.NewList(args[1:]...) - _ = v4 - var tmp5 any - { // let - // let binding "map__357" - var v6 any = v4 - _ = v6 - // let binding "map__357" - var tmp7 any - tmp8 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) - tmp9 := lang.Apply(tmp8, []any{v6}) - if lang.IsTruthy(tmp9) { - var tmp10 any - tmp11 := checkDerefVar(var_glojure_DOT_core_next) - tmp12 := lang.Apply(tmp11, []any{v6}) - if lang.IsTruthy(tmp12) { - tmp13 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) - tmp14 := lang.Apply(tmp13, []any{v6}) - tmp15 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{tmp14}) - tmp10 = tmp15 - } else { - var tmp16 any - tmp17 := checkDerefVar(var_glojure_DOT_core_seq) - tmp18 := lang.Apply(tmp17, []any{v6}) - if lang.IsTruthy(tmp18) { - tmp19 := checkDerefVar(var_glojure_DOT_core_first) - tmp20 := lang.Apply(tmp19, []any{v6}) - tmp16 = tmp20 - } else { - } - tmp10 = tmp16 - } - tmp7 = tmp10 - } else { - tmp7 = v6 - } - var v21 any = tmp7 - _ = v21 - // let binding "somef" - tmp22 := checkDerefVar(var_glojure_DOT_core_get) - tmp23 := checkDerefVar(var_glojure_DOT_core_some_QMARK_) - tmp24 := lang.Apply(tmp22, []any{v21, kw_somef, tmp23}) - var v25 any = tmp24 - _ = v25 - // let binding "vf" - tmp26 := checkDerefVar(var_glojure_DOT_core_get) - tmp27 := checkDerefVar(var_glojure_DOT_core_identity) - tmp28 := lang.Apply(tmp26, []any{v21, kw_vf, tmp27}) - var v29 any = tmp28 - _ = v29 - // let binding "kf" - tmp30 := checkDerefVar(var_glojure_DOT_core_get) - tmp31 := checkDerefVar(var_glojure_DOT_core_identity) - tmp32 := lang.Apply(tmp30, []any{v21, kw_kf, tmp31}) - var v33 any = tmp32 - _ = v33 - // let binding "initk" - tmp34 := checkDerefVar(var_glojure_DOT_core_get) - tmp35 := lang.Apply(tmp34, []any{v21, kw_initk, nil}) - var v36 any = tmp35 - _ = v36 - tmp37 := checkDerefVar(var_glojure_DOT_core_seq) - tmp38 := lang.NewVector(nil) - tmp39 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7743), kw_column, int(9), kw_end_DASH_line, int(7743), kw_end_DASH_column, int(11)) - tmp40, err := lang.WithMeta(tmp38, tmp39.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var tmp41 lang.FnFunc - { // function next - var v42 lang.FnFunc - tmp41 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v43 := args[0] - _ = v43 - var tmp44 any - tmp45 := lang.Apply(v25, []any{v43}) - if lang.IsTruthy(tmp45) { - tmp46 := checkDerefVar(var_glojure_DOT_core_cons) - tmp47 := lang.Apply(v29, []any{v43}) - var tmp48 any - { // let - // let binding "temp__0__auto__" - tmp49 := lang.Apply(v33, []any{v43}) - var v50 any = tmp49 - _ = v50 - var tmp51 any - tmp52 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) - tmp53 := lang.Apply(tmp52, []any{v50}) - if lang.IsTruthy(tmp53) { - } else { - var tmp54 any - { // let - // let binding "k" - var v55 any = v50 - _ = v55 - var tmp56 lang.FnFunc - tmp56 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - tmp57 := lang.Apply(v3, []any{v55}) - tmp58 := lang.Apply(v42, []any{tmp57}) - return tmp58 - }) - tmp57 := lang.Apply(lang.NewLazySeq, []any{tmp56}) - tmp54 = tmp57 - } // end let - tmp51 = tmp54 - } - tmp48 = tmp51 - } // end let - tmp49 := lang.Apply(tmp46, []any{tmp47, tmp48}) - tmp44 = tmp49 - } else { - } - return tmp44 - }) - v42 = tmp41 - _ = v42 - } - tmp42 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7744), kw_column, int(10), kw_end_DASH_line, int(7748), kw_end_DASH_column, int(51)) - tmp43, err := lang.WithMeta(tmp41, tmp42.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp44 := lang.Apply(v3, []any{v36}) - tmp45 := lang.Apply(tmp43, []any{tmp44}) - tmp46 := lang.Apply(tmp37, []any{tmp40, tmp45}) - tmp47 := reflect.TypeOf((*lang.IReduceInit)(nil)).Elem() - tmp48 := checkDerefVar(var_glojure_DOT_core_reduce) - tmp49 := lang.NewVector(nil, nil, nil) - tmp50 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7751), kw_column, int(12), kw_end_DASH_line, int(7751), kw_end_DASH_column, int(22)) - tmp51, err := lang.WithMeta(tmp49, tmp50.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var tmp52 any - { // let - // let binding "acc" - var v53 any = nil - _ = v53 - // let binding "ret" - tmp54 := lang.Apply(v3, []any{v36}) - var v55 any = tmp54 - _ = v55 - for { - var tmp56 any - tmp57 := lang.Apply(v25, []any{v55}) - if lang.IsTruthy(tmp57) { - var tmp58 any - { // let - // let binding "acc" - tmp59 := lang.Apply(v29, []any{v55}) - tmp60 := lang.Apply(nil, []any{v53, tmp59}) - var v61 any = tmp60 - _ = v61 - var tmp62 any - tmp63 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) - tmp64 := lang.Apply(tmp63, []any{v61}) - if lang.IsTruthy(tmp64) { - tmp65 := checkDerefVar(var_glojure_DOT_core_deref) - tmp66 := lang.Apply(tmp65, []any{v61}) - tmp62 = tmp66 - } else { - var tmp67 any - { // let - // let binding "temp__0__auto__" - tmp68 := lang.Apply(v33, []any{v55}) - var v69 any = tmp68 - _ = v69 - var tmp70 any - tmp71 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) - tmp72 := lang.Apply(tmp71, []any{v69}) - if lang.IsTruthy(tmp72) { - tmp70 = v61 - } else { - var tmp73 any - { // let - // let binding "k" - var v74 any = v69 - _ = v74 - var tmp75 any = v61 - tmp77 := lang.Apply(v3, []any{v74}) - var tmp76 any = tmp77 - v53 = tmp75 - v55 = tmp76 - continue - } // end let - tmp70 = tmp73 - } - tmp67 = tmp70 - } // end let - tmp62 = tmp67 - } - tmp58 = tmp62 - } // end let - tmp56 = tmp58 - } else { - tmp56 = v53 - } - tmp52 = tmp56 - break - } - } // end let - tmp53 := lang.Apply(tmp48, []any{tmp51, tmp52}) - tmp54 := lang.Apply(nil, []any{nil, tmp46, tmp47, tmp53}) - tmp5 = tmp54 - } // end let + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "CharArray") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("CharArray is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "CharArrayInit") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("CharArrayInit is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") } }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core_char_DASH_array = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_char_DASH_array.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // iterator-seq + // chars { - tmp0 := sym_iterator_DASH_seq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_iter)), kw_doc, "Returns a seq on a java.util.Iterator. Note that most collections\n providing iterators implement Iterable and thus support seq directly.\n Seqs cache values, thus iterator-seq should not be used on any\n iterator that repeatedly returns the same mutable object.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(5700), kw_end_DASH_line, int(5700))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function chars + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Chars}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_chars.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xs)), kw_inline, tmp1, kw_doc, "Casts to chars[]", kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(12), kw_line, int(5382), kw_end_DASH_line, int(5382))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) v3 := args[0] - _ = v3 - tmp4 := lang.Apply(nil, []any{v3}) - return tmp4 + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Chars") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Chars is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core_chars = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_chars.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // juxt + // comp { - tmp0 := sym_juxt.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_g), lang.NewVector(sym_f, sym_g, sym_h), lang.NewVector(sym_f, sym_g, sym_h, sym__AMP_, sym_fs)), kw_doc, "Takes a set of functions and returns a fn that is the juxtaposition\n of those fns. The returned fn takes a variable number of args, and\n returns a vector containing the result of applying each fn to the\n args (left-to-right).\n ((juxt a b c) x) => [(a x) (b x) (c x)]", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(2568), kw_end_DASH_line, int(2568))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_comp.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_f), lang.NewVector(sym_f, sym_g), lang.NewVector(sym_f, sym_g, sym__AMP_, sym_fs)), kw_doc, "Takes a set of functions and returns a fn that is the composition\n of those fns. The returned fn takes a variable number of args,\n applies the rightmost of fns to the args, the next\n fn (right-to-left) to the result, etc.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(2549), kw_end_DASH_line, int(2549))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { + case 0: + tmp2 := checkDerefVar(var_glojure_DOT_core_identity) + return tmp2 case 1: - v3 := args[0] + v2 := args[0] + _ = v2 + return v2 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 var tmp4 lang.FnFunc tmp4 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: tmp5 := lang.Apply(v3, nil) - tmp6 := lang.NewVector(tmp5) - tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2578), kw_column, int(12), kw_end_DASH_line, int(2578), kw_end_DASH_column, int(16)) - tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp8 + tmp6 := lang.Apply(v2, []any{tmp5}) + return tmp6 case 1: v5 := args[0] _ = v5 tmp6 := lang.Apply(v3, []any{v5}) - tmp7 := lang.NewVector(tmp6) - tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2579), kw_column, int(13), kw_end_DASH_line, int(2579), kw_end_DASH_column, int(19)) - tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp9 + tmp7 := lang.Apply(v2, []any{tmp6}) + return tmp7 case 2: v5 := args[0] _ = v5 v6 := args[1] _ = v6 tmp7 := lang.Apply(v3, []any{v5, v6}) - tmp8 := lang.NewVector(tmp7) - tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2580), kw_column, int(15), kw_end_DASH_line, int(2580), kw_end_DASH_column, int(23)) - tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp10 + tmp8 := lang.Apply(v2, []any{tmp7}) + return tmp8 case 3: v5 := args[0] _ = v5 @@ -28876,13 +21912,8 @@ func LoadNS() { v7 := args[2] _ = v7 tmp8 := lang.Apply(v3, []any{v5, v6, v7}) - tmp9 := lang.NewVector(tmp8) - tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2581), kw_column, int(17), kw_end_DASH_line, int(2581), kw_end_DASH_column, int(27)) - tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp11 + tmp9 := lang.Apply(v2, []any{tmp8}) + return tmp9 default: checkArity(args, 3) v5 := args[0] @@ -28895,1406 +21926,1833 @@ func LoadNS() { _ = v8 tmp9 := checkDerefVar(var_glojure_DOT_core_apply) tmp10 := lang.Apply(tmp9, []any{v3, v5, v6, v7, v8}) - tmp11 := lang.NewVector(tmp10) - tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2582), kw_column, int(24), kw_end_DASH_line, int(2582), kw_end_DASH_column, int(45)) - tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp13 + tmp11 := lang.Apply(v2, []any{tmp10}) + return tmp11 } }) - tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2577), kw_column, int(6), kw_end_DASH_line, int(2582), kw_end_DASH_column, int(47)) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2559), kw_column, int(6), kw_end_DASH_line, int(2564), kw_end_DASH_column, int(49)) tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) if err != nil { panic(err) } return tmp6 - case 2: - v3 := args[0] + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + var v4 any = lang.NewList(args[2:]...) _ = v4 - var tmp5 lang.FnFunc - tmp5 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp6 := lang.Apply(v3, nil) - tmp7 := lang.Apply(v4, nil) - tmp8 := lang.NewVector(tmp6, tmp7) - tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2585), kw_column, int(12), kw_end_DASH_line, int(2585), kw_end_DASH_column, int(20)) - tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp10 - case 1: - v6 := args[0] - _ = v6 - tmp7 := lang.Apply(v3, []any{v6}) - tmp8 := lang.Apply(v4, []any{v6}) - tmp9 := lang.NewVector(tmp7, tmp8) - tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2586), kw_column, int(13), kw_end_DASH_line, int(2586), kw_end_DASH_column, int(25)) - tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp11 - case 2: - v6 := args[0] - _ = v6 - v7 := args[1] - _ = v7 - tmp8 := lang.Apply(v3, []any{v6, v7}) - tmp9 := lang.Apply(v4, []any{v6, v7}) - tmp10 := lang.NewVector(tmp8, tmp9) - tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2587), kw_column, int(15), kw_end_DASH_line, int(2587), kw_end_DASH_column, int(31)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp12 - case 3: - v6 := args[0] - _ = v6 - v7 := args[1] - _ = v7 - v8 := args[2] - _ = v8 - tmp9 := lang.Apply(v3, []any{v6, v7, v8}) - tmp10 := lang.Apply(v4, []any{v6, v7, v8}) - tmp11 := lang.NewVector(tmp9, tmp10) - tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2588), kw_column, int(17), kw_end_DASH_line, int(2588), kw_end_DASH_column, int(37)) - tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp13 - default: - checkArity(args, 3) - v6 := args[0] - _ = v6 - v7 := args[1] - _ = v7 - v8 := args[2] - _ = v8 - var v9 any = lang.NewList(args[3:]...) - _ = v9 - tmp10 := checkDerefVar(var_glojure_DOT_core_apply) - tmp11 := lang.Apply(tmp10, []any{v3, v6, v7, v8, v9}) - tmp12 := checkDerefVar(var_glojure_DOT_core_apply) - tmp13 := lang.Apply(tmp12, []any{v4, v6, v7, v8, v9}) - tmp14 := lang.NewVector(tmp11, tmp13) - tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2589), kw_column, int(24), kw_end_DASH_line, int(2589), kw_end_DASH_column, int(66)) - tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp16 - } - }) - tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2584), kw_column, int(6), kw_end_DASH_line, int(2589), kw_end_DASH_column, int(68)) - tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp7 - case 3: + tmp5 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp6 := checkDerefVar(var_glojure_DOT_core_comp) + tmp7 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp8 := lang.Apply(tmp7, []any{v2, v3, v4}) + tmp9 := lang.Apply(tmp5, []any{tmp6, tmp8}) + return tmp9 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_comp = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_comp.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // compare + { + var tmp1 lang.FnFunc + { // function compare__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) v3 := args[0] _ = v3 v4 := args[1] _ = v4 - v5 := args[2] - _ = v5 - var tmp6 lang.FnFunc - tmp6 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp7 := lang.Apply(v3, nil) - tmp8 := lang.Apply(v4, nil) - tmp9 := lang.Apply(v5, nil) - tmp10 := lang.NewVector(tmp7, tmp8, tmp9) - tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2592), kw_column, int(12), kw_end_DASH_line, int(2592), kw_end_DASH_column, int(24)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp12 - case 1: - v7 := args[0] - _ = v7 - tmp8 := lang.Apply(v3, []any{v7}) - tmp9 := lang.Apply(v4, []any{v7}) - tmp10 := lang.Apply(v5, []any{v7}) - tmp11 := lang.NewVector(tmp8, tmp9, tmp10) - tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2593), kw_column, int(13), kw_end_DASH_line, int(2593), kw_end_DASH_column, int(31)) - tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp13 - case 2: - v7 := args[0] - _ = v7 - v8 := args[1] - _ = v8 - tmp9 := lang.Apply(v3, []any{v7, v8}) - tmp10 := lang.Apply(v4, []any{v7, v8}) - tmp11 := lang.Apply(v5, []any{v7, v8}) - tmp12 := lang.NewVector(tmp9, tmp10, tmp11) - tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2594), kw_column, int(15), kw_end_DASH_line, int(2594), kw_end_DASH_column, int(39)) - tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp14 - case 3: - v7 := args[0] - _ = v7 - v8 := args[1] - _ = v8 - v9 := args[2] - _ = v9 - tmp10 := lang.Apply(v3, []any{v7, v8, v9}) - tmp11 := lang.Apply(v4, []any{v7, v8, v9}) - tmp12 := lang.Apply(v5, []any{v7, v8, v9}) - tmp13 := lang.NewVector(tmp10, tmp11, tmp12) - tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2595), kw_column, int(17), kw_end_DASH_line, int(2595), kw_end_DASH_column, int(47)) - tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp15 - default: - checkArity(args, 3) - v7 := args[0] - _ = v7 - v8 := args[1] - _ = v8 - v9 := args[2] - _ = v9 - var v10 any = lang.NewList(args[3:]...) - _ = v10 - tmp11 := checkDerefVar(var_glojure_DOT_core_apply) - tmp12 := lang.Apply(tmp11, []any{v3, v7, v8, v9, v10}) - tmp13 := checkDerefVar(var_glojure_DOT_core_apply) - tmp14 := lang.Apply(tmp13, []any{v4, v7, v8, v9, v10}) - tmp15 := checkDerefVar(var_glojure_DOT_core_apply) - tmp16 := lang.Apply(tmp15, []any{v5, v7, v8, v9, v10}) - tmp17 := lang.NewVector(tmp12, tmp14, tmp16) - tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2596), kw_column, int(24), kw_end_DASH_line, int(2596), kw_end_DASH_column, int(87)) - tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp19 - } - }) - tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2591), kw_column, int(6), kw_end_DASH_line, int(2596), kw_end_DASH_column, int(89)) - tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) - if err != nil { - panic(err) + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_lang_DOT_Util}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_glojure_DOT_core_SLASH_compare}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{v3}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v4}) + tmp17 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp12, tmp14, tmp16}) + tmp18 := lang.Apply(tmp5, []any{tmp17}) + return tmp18 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_compare.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Comparator. Returns a negative number, zero, or a positive number\n when x is logically 'less than', 'equal to', or 'greater than'\n y. Same as Java x.compareTo(y) except it also works for nil, and\n compares numbers and collections in a type-independent manner. x\n must implement Comparable", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(824), kw_end_DASH_line, int(824))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(lang.Compare, []any{v3, v4}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_compare = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_compare.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // complement + { + tmp0 := sym_complement.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f)), kw_doc, "Takes a fn f and returns a fn that takes the same arguments as f,\n has the same effects, if any, and returns the opposite truth value.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(1428), kw_end_DASH_line, int(1428))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp4 := checkDerefVar(var_glojure_DOT_core_not) + tmp5 := lang.Apply(v2, nil) + tmp6 := lang.Apply(tmp4, []any{tmp5}) + return tmp6 + case 1: + v4 := args[0] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_not) + tmp6 := lang.Apply(v2, []any{v4}) + tmp7 := lang.Apply(tmp5, []any{tmp6}) + return tmp7 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_not) + tmp7 := lang.Apply(v2, []any{v4, v5}) + tmp8 := lang.Apply(tmp6, []any{tmp7}) + return tmp8 + default: + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_not) + tmp8 := checkDerefVar(var_glojure_DOT_core_apply) + tmp9 := lang.Apply(tmp8, []any{v2, v4, v5, v6}) + tmp10 := lang.Apply(tmp7, []any{tmp9}) + return tmp10 } - return tmp8 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(1434), kw_column, int(3), kw_end_DASH_line, int(1438), kw_end_DASH_column, int(40)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_complement = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_complement.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // data-reader-var + { + tmp0 := sym_data_DASH_reader_DASH_var.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7832), kw_column, int(8), kw_end_DASH_line, int(7832), kw_end_DASH_column, int(22), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_sym)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_intern) + tmp4 := checkDerefVar(var_glojure_DOT_core_create_DASH_ns) + tmp5 := checkDerefVar(var_glojure_DOT_core_symbol) + tmp6 := checkDerefVar(var_glojure_DOT_core_namespace) + tmp7 := lang.Apply(tmp6, []any{v2}) + tmp8 := lang.Apply(tmp5, []any{tmp7}) + tmp9 := lang.Apply(tmp4, []any{tmp8}) + tmp10 := checkDerefVar(var_glojure_DOT_core_symbol) + tmp11 := checkDerefVar(var_glojure_DOT_core_name) + tmp12 := lang.Apply(tmp11, []any{v2}) + tmp13 := lang.Apply(tmp10, []any{tmp12}) + tmp14 := lang.Apply(tmp3, []any{tmp9, tmp13}) + return tmp14 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_data_DASH_reader_DASH_var = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_data_DASH_reader_DASH_var.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // def-aset + { + tmp0 := sym_def_DASH_aset.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym_method, sym_coerce)), kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(3), kw_line, int(3935), kw_end_DASH_line, int(3936), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 5) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_core_SLASH_defn}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{v4}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_apply) + tmp15 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp16 := checkDerefVar(var_glojure_DOT_core_seq) + tmp17 := checkDerefVar(var_glojure_DOT_core_concat) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{kw_arglists}) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := checkDerefVar(var_glojure_DOT_core_seq) + tmp22 := checkDerefVar(var_glojure_DOT_core_concat) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := lang.Apply(tmp23, []any{sym_quote}) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := checkDerefVar(var_glojure_DOT_core_seq) + tmp27 := checkDerefVar(var_glojure_DOT_core_concat) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := checkDerefVar(var_glojure_DOT_core_apply) + tmp30 := checkDerefVar(var_glojure_DOT_core_vector) + tmp31 := checkDerefVar(var_glojure_DOT_core_seq) + tmp32 := checkDerefVar(var_glojure_DOT_core_concat) + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{sym_array}) + tmp35 := checkDerefVar(var_glojure_DOT_core_list) + tmp36 := lang.Apply(tmp35, []any{sym_idx}) + tmp37 := checkDerefVar(var_glojure_DOT_core_list) + tmp38 := lang.Apply(tmp37, []any{sym_val}) + tmp39 := lang.Apply(tmp32, []any{tmp34, tmp36, tmp38}) + tmp40 := lang.Apply(tmp31, []any{tmp39}) + tmp41 := lang.Apply(tmp29, []any{tmp30, tmp40}) + tmp42 := lang.Apply(tmp28, []any{tmp41}) + tmp43 := checkDerefVar(var_glojure_DOT_core_list) + tmp44 := checkDerefVar(var_glojure_DOT_core_apply) + tmp45 := checkDerefVar(var_glojure_DOT_core_vector) + tmp46 := checkDerefVar(var_glojure_DOT_core_seq) + tmp47 := checkDerefVar(var_glojure_DOT_core_concat) + tmp48 := checkDerefVar(var_glojure_DOT_core_list) + tmp49 := lang.Apply(tmp48, []any{sym_array}) + tmp50 := checkDerefVar(var_glojure_DOT_core_list) + tmp51 := lang.Apply(tmp50, []any{sym_idx}) + tmp52 := checkDerefVar(var_glojure_DOT_core_list) + tmp53 := lang.Apply(tmp52, []any{sym_idx2}) + tmp54 := checkDerefVar(var_glojure_DOT_core_list) + tmp55 := lang.Apply(tmp54, []any{sym__AMP_}) + tmp56 := checkDerefVar(var_glojure_DOT_core_list) + tmp57 := lang.Apply(tmp56, []any{sym_idxv}) + tmp58 := lang.Apply(tmp47, []any{tmp49, tmp51, tmp53, tmp55, tmp57}) + tmp59 := lang.Apply(tmp46, []any{tmp58}) + tmp60 := lang.Apply(tmp44, []any{tmp45, tmp59}) + tmp61 := lang.Apply(tmp43, []any{tmp60}) + tmp62 := lang.Apply(tmp27, []any{tmp42, tmp61}) + tmp63 := lang.Apply(tmp26, []any{tmp62}) + tmp64 := lang.Apply(tmp25, []any{tmp63}) + tmp65 := lang.Apply(tmp22, []any{tmp24, tmp64}) + tmp66 := lang.Apply(tmp21, []any{tmp65}) + tmp67 := lang.Apply(tmp20, []any{tmp66}) + tmp68 := lang.Apply(tmp17, []any{tmp19, tmp67}) + tmp69 := lang.Apply(tmp16, []any{tmp68}) + tmp70 := lang.Apply(tmp14, []any{tmp15, tmp69}) + tmp71 := lang.Apply(tmp13, []any{tmp70}) + tmp72 := checkDerefVar(var_glojure_DOT_core_list) + tmp73 := checkDerefVar(var_glojure_DOT_core_seq) + tmp74 := checkDerefVar(var_glojure_DOT_core_concat) + tmp75 := checkDerefVar(var_glojure_DOT_core_list) + tmp76 := checkDerefVar(var_glojure_DOT_core_apply) + tmp77 := checkDerefVar(var_glojure_DOT_core_vector) + tmp78 := checkDerefVar(var_glojure_DOT_core_seq) + tmp79 := checkDerefVar(var_glojure_DOT_core_concat) + tmp80 := checkDerefVar(var_glojure_DOT_core_list) + tmp81 := lang.Apply(tmp80, []any{sym_array__0__auto__}) + tmp82 := checkDerefVar(var_glojure_DOT_core_list) + tmp83 := lang.Apply(tmp82, []any{sym_idx__1__auto__}) + tmp84 := checkDerefVar(var_glojure_DOT_core_list) + tmp85 := lang.Apply(tmp84, []any{sym_val__2__auto__}) + tmp86 := lang.Apply(tmp79, []any{tmp81, tmp83, tmp85}) + tmp87 := lang.Apply(tmp78, []any{tmp86}) + tmp88 := lang.Apply(tmp76, []any{tmp77, tmp87}) + tmp89 := lang.Apply(tmp75, []any{tmp88}) + tmp90 := checkDerefVar(var_glojure_DOT_core_list) + tmp91 := checkDerefVar(var_glojure_DOT_core_seq) + tmp92 := checkDerefVar(var_glojure_DOT_core_concat) + tmp93 := checkDerefVar(var_glojure_DOT_core_list) + tmp94 := lang.Apply(tmp93, []any{sym__DOT_}) + tmp95 := checkDerefVar(var_glojure_DOT_core_list) + tmp96 := lang.Apply(tmp95, []any{sym_glojure_DOT_core_SLASH_Array}) + tmp97 := checkDerefVar(var_glojure_DOT_core_list) + tmp98 := checkDerefVar(var_glojure_DOT_core_seq) + tmp99 := checkDerefVar(var_glojure_DOT_core_concat) + tmp100 := checkDerefVar(var_glojure_DOT_core_list) + tmp101 := lang.Apply(tmp100, []any{v5}) + tmp102 := checkDerefVar(var_glojure_DOT_core_list) + tmp103 := lang.Apply(tmp102, []any{sym_array__0__auto__}) + tmp104 := checkDerefVar(var_glojure_DOT_core_list) + tmp105 := lang.Apply(tmp104, []any{sym_idx__1__auto__}) + tmp106 := checkDerefVar(var_glojure_DOT_core_list) + tmp107 := checkDerefVar(var_glojure_DOT_core_seq) + tmp108 := checkDerefVar(var_glojure_DOT_core_concat) + tmp109 := checkDerefVar(var_glojure_DOT_core_list) + tmp110 := lang.Apply(tmp109, []any{v6}) + tmp111 := checkDerefVar(var_glojure_DOT_core_list) + tmp112 := lang.Apply(tmp111, []any{sym_val__2__auto__}) + tmp113 := lang.Apply(tmp108, []any{tmp110, tmp112}) + tmp114 := lang.Apply(tmp107, []any{tmp113}) + tmp115 := lang.Apply(tmp106, []any{tmp114}) + tmp116 := lang.Apply(tmp99, []any{tmp101, tmp103, tmp105, tmp115}) + tmp117 := lang.Apply(tmp98, []any{tmp116}) + tmp118 := lang.Apply(tmp97, []any{tmp117}) + tmp119 := lang.Apply(tmp92, []any{tmp94, tmp96, tmp118}) + tmp120 := lang.Apply(tmp91, []any{tmp119}) + tmp121 := lang.Apply(tmp90, []any{tmp120}) + tmp122 := checkDerefVar(var_glojure_DOT_core_list) + tmp123 := lang.Apply(tmp122, []any{sym_val__2__auto__}) + tmp124 := lang.Apply(tmp74, []any{tmp89, tmp121, tmp123}) + tmp125 := lang.Apply(tmp73, []any{tmp124}) + tmp126 := lang.Apply(tmp72, []any{tmp125}) + tmp127 := checkDerefVar(var_glojure_DOT_core_list) + tmp128 := checkDerefVar(var_glojure_DOT_core_seq) + tmp129 := checkDerefVar(var_glojure_DOT_core_concat) + tmp130 := checkDerefVar(var_glojure_DOT_core_list) + tmp131 := checkDerefVar(var_glojure_DOT_core_apply) + tmp132 := checkDerefVar(var_glojure_DOT_core_vector) + tmp133 := checkDerefVar(var_glojure_DOT_core_seq) + tmp134 := checkDerefVar(var_glojure_DOT_core_concat) + tmp135 := checkDerefVar(var_glojure_DOT_core_list) + tmp136 := lang.Apply(tmp135, []any{sym_array__0__auto__}) + tmp137 := checkDerefVar(var_glojure_DOT_core_list) + tmp138 := lang.Apply(tmp137, []any{sym_idx__1__auto__}) + tmp139 := checkDerefVar(var_glojure_DOT_core_list) + tmp140 := lang.Apply(tmp139, []any{sym_idx2__3__auto__}) + tmp141 := checkDerefVar(var_glojure_DOT_core_list) + tmp142 := lang.Apply(tmp141, []any{sym__AMP_}) + tmp143 := checkDerefVar(var_glojure_DOT_core_list) + tmp144 := lang.Apply(tmp143, []any{sym_idxv__4__auto__}) + tmp145 := lang.Apply(tmp134, []any{tmp136, tmp138, tmp140, tmp142, tmp144}) + tmp146 := lang.Apply(tmp133, []any{tmp145}) + tmp147 := lang.Apply(tmp131, []any{tmp132, tmp146}) + tmp148 := lang.Apply(tmp130, []any{tmp147}) + tmp149 := checkDerefVar(var_glojure_DOT_core_list) + tmp150 := checkDerefVar(var_glojure_DOT_core_seq) + tmp151 := checkDerefVar(var_glojure_DOT_core_concat) + tmp152 := checkDerefVar(var_glojure_DOT_core_list) + tmp153 := lang.Apply(tmp152, []any{sym_glojure_DOT_core_SLASH_apply}) + tmp154 := checkDerefVar(var_glojure_DOT_core_list) + tmp155 := lang.Apply(tmp154, []any{v4}) + tmp156 := checkDerefVar(var_glojure_DOT_core_list) + tmp157 := checkDerefVar(var_glojure_DOT_core_seq) + tmp158 := checkDerefVar(var_glojure_DOT_core_concat) + tmp159 := checkDerefVar(var_glojure_DOT_core_list) + tmp160 := lang.Apply(tmp159, []any{sym_glojure_DOT_core_SLASH_aget}) + tmp161 := checkDerefVar(var_glojure_DOT_core_list) + tmp162 := lang.Apply(tmp161, []any{sym_array__0__auto__}) + tmp163 := checkDerefVar(var_glojure_DOT_core_list) + tmp164 := lang.Apply(tmp163, []any{sym_idx__1__auto__}) + tmp165 := lang.Apply(tmp158, []any{tmp160, tmp162, tmp164}) + tmp166 := lang.Apply(tmp157, []any{tmp165}) + tmp167 := lang.Apply(tmp156, []any{tmp166}) + tmp168 := checkDerefVar(var_glojure_DOT_core_list) + tmp169 := lang.Apply(tmp168, []any{sym_idx2__3__auto__}) + tmp170 := checkDerefVar(var_glojure_DOT_core_list) + tmp171 := lang.Apply(tmp170, []any{sym_idxv__4__auto__}) + tmp172 := lang.Apply(tmp151, []any{tmp153, tmp155, tmp167, tmp169, tmp171}) + tmp173 := lang.Apply(tmp150, []any{tmp172}) + tmp174 := lang.Apply(tmp149, []any{tmp173}) + tmp175 := lang.Apply(tmp129, []any{tmp148, tmp174}) + tmp176 := lang.Apply(tmp128, []any{tmp175}) + tmp177 := lang.Apply(tmp127, []any{tmp176}) + tmp178 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp71, tmp126, tmp177}) + tmp179 := lang.Apply(tmp7, []any{tmp178}) + return tmp179 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_def_DASH_aset = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_def_DASH_aset.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // definline + { + tmp0 := sym_definline.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym__AMP_, sym_decl)), kw_doc, "Experimental - like defmacro, except defines a named function whose\n body is the expansion, calls to which may be expanded inline as if\n it were a macro. Cannot be used with variadic (&) args.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(11), kw_line, int(5253), kw_end_DASH_line, int(5253))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { default: checkArity(args, 3) - v3 := args[0] + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + v4 := args[2] _ = v4 - v5 := args[2] + var v5 any = lang.NewList(args[3:]...) _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any + var tmp6 any { // let - // let binding "fs" - tmp8 := checkDerefVar(var_glojure_DOT_core_list_STAR_) - tmp9 := lang.Apply(tmp8, []any{v3, v4, v5, v6}) - var v10 any = tmp9 - _ = v10 - var tmp11 lang.FnFunc - tmp11 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp12 := checkDerefVar(var_glojure_DOT_core_reduce1) - var tmp13 lang.FnFunc - tmp13 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v14 := args[0] - _ = v14 - v15 := args[1] - _ = v15 - tmp16 := checkDerefVar(var_glojure_DOT_core_conj) - tmp17 := lang.Apply(v15, nil) - tmp18 := lang.Apply(tmp16, []any{v14, tmp17}) - return tmp18 - }) - tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2600), kw_column, int(23), kw_end_DASH_line, int(2600), kw_end_DASH_column, int(37)) - tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp16 := lang.NewVector() - tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2600), kw_column, int(39), kw_end_DASH_line, int(2600), kw_end_DASH_column, int(40)) - tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp19 := lang.Apply(tmp12, []any{tmp15, tmp18, v10}) - return tmp19 - case 1: - v12 := args[0] - _ = v12 - tmp13 := checkDerefVar(var_glojure_DOT_core_reduce1) - var tmp14 lang.FnFunc - tmp14 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v15 := args[0] - _ = v15 - v16 := args[1] - _ = v16 - tmp17 := checkDerefVar(var_glojure_DOT_core_conj) - tmp18 := lang.Apply(v16, []any{v12}) - tmp19 := lang.Apply(tmp17, []any{v15, tmp18}) - return tmp19 - }) - tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2601), kw_column, int(24), kw_end_DASH_line, int(2601), kw_end_DASH_column, int(40)) - tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp17 := lang.NewVector() - tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2601), kw_column, int(42), kw_end_DASH_line, int(2601), kw_end_DASH_column, int(43)) - tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp20 := lang.Apply(tmp13, []any{tmp16, tmp19, v10}) - return tmp20 - case 2: - v12 := args[0] - _ = v12 - v13 := args[1] - _ = v13 - tmp14 := checkDerefVar(var_glojure_DOT_core_reduce1) - var tmp15 lang.FnFunc - tmp15 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v16 := args[0] - _ = v16 - v17 := args[1] - _ = v17 - tmp18 := checkDerefVar(var_glojure_DOT_core_conj) - tmp19 := lang.Apply(v17, []any{v12, v13}) - tmp20 := lang.Apply(tmp18, []any{v16, tmp19}) - return tmp20 - }) - tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2602), kw_column, int(26), kw_end_DASH_line, int(2602), kw_end_DASH_column, int(44)) - tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp18 := lang.NewVector() - tmp19 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2602), kw_column, int(46), kw_end_DASH_line, int(2602), kw_end_DASH_column, int(47)) - tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp21 := lang.Apply(tmp14, []any{tmp17, tmp20, v10}) - return tmp21 - case 3: - v12 := args[0] - _ = v12 - v13 := args[1] - _ = v13 - v14 := args[2] - _ = v14 - tmp15 := checkDerefVar(var_glojure_DOT_core_reduce1) - var tmp16 lang.FnFunc - tmp16 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v17 := args[0] - _ = v17 - v18 := args[1] - _ = v18 - tmp19 := checkDerefVar(var_glojure_DOT_core_conj) - tmp20 := lang.Apply(v18, []any{v12, v13, v14}) - tmp21 := lang.Apply(tmp19, []any{v17, tmp20}) - return tmp21 - }) - tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2603), kw_column, int(28), kw_end_DASH_line, int(2603), kw_end_DASH_column, int(48)) - tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp19 := lang.NewVector() - tmp20 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2603), kw_column, int(50), kw_end_DASH_line, int(2603), kw_end_DASH_column, int(51)) - tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp22 := lang.Apply(tmp15, []any{tmp18, tmp21, v10}) - return tmp22 - default: - checkArity(args, 3) - v12 := args[0] - _ = v12 - v13 := args[1] - _ = v13 - v14 := args[2] - _ = v14 - var v15 any = lang.NewList(args[3:]...) - _ = v15 - tmp16 := checkDerefVar(var_glojure_DOT_core_reduce1) - var tmp17 lang.FnFunc - tmp17 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v18 := args[0] - _ = v18 - v19 := args[1] - _ = v19 - tmp20 := checkDerefVar(var_glojure_DOT_core_conj) - tmp21 := checkDerefVar(var_glojure_DOT_core_apply) - tmp22 := lang.Apply(tmp21, []any{v19, v12, v13, v14, v15}) - tmp23 := lang.Apply(tmp20, []any{v18, tmp22}) - return tmp23 - }) - tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2604), kw_column, int(35), kw_end_DASH_line, int(2604), kw_end_DASH_column, int(66)) - tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp20 := lang.NewVector() - tmp21 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2604), kw_column, int(68), kw_end_DASH_line, int(2604), kw_end_DASH_column, int(69)) - tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp23 := lang.Apply(tmp16, []any{tmp19, tmp22, v10}) - return tmp23 - } - }) - tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2599), kw_column, int(8), kw_end_DASH_line, int(2604), kw_end_DASH_column, int(75)) - tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp7 = tmp13 + // let binding "vec__80" + tmp7 := checkDerefVar(var_glojure_DOT_core_split_DASH_with) + tmp8 := checkDerefVar(var_glojure_DOT_core_comp) + tmp9 := checkDerefVar(var_glojure_DOT_core_not) + tmp10 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp11 := lang.Apply(tmp8, []any{tmp9, tmp10}) + tmp12 := lang.Apply(tmp7, []any{tmp11, v5}) + var v13 any = tmp12 + _ = v13 + // let binding "pre-args" + tmp14 := checkDerefVar(var_glojure_DOT_core_nth) + tmp15 := lang.Apply(tmp14, []any{v13, int64(0), nil}) + var v16 any = tmp15 + _ = v16 + // let binding "vec__83" + tmp17 := checkDerefVar(var_glojure_DOT_core_nth) + tmp18 := lang.Apply(tmp17, []any{v13, int64(1), nil}) + var v19 any = tmp18 + _ = v19 + // let binding "args" + tmp20 := checkDerefVar(var_glojure_DOT_core_nth) + tmp21 := lang.Apply(tmp20, []any{v19, int64(0), nil}) + var v22 any = tmp21 + _ = v22 + // let binding "expr" + tmp23 := checkDerefVar(var_glojure_DOT_core_nth) + tmp24 := lang.Apply(tmp23, []any{v19, int64(1), nil}) + var v25 any = tmp24 + _ = v25 + tmp26 := checkDerefVar(var_glojure_DOT_core_seq) + tmp27 := checkDerefVar(var_glojure_DOT_core_concat) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := lang.Apply(tmp28, []any{sym_do}) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := checkDerefVar(var_glojure_DOT_core_seq) + tmp32 := checkDerefVar(var_glojure_DOT_core_concat) + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{sym_glojure_DOT_core_SLASH_defn}) + tmp35 := checkDerefVar(var_glojure_DOT_core_list) + tmp36 := lang.Apply(tmp35, []any{v4}) + tmp37 := checkDerefVar(var_glojure_DOT_core_list) + tmp38 := lang.Apply(tmp37, []any{v22}) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := checkDerefVar(var_glojure_DOT_core_apply) + tmp41 := checkDerefVar(var_glojure_DOT_core_eval) + tmp42 := checkDerefVar(var_glojure_DOT_core_list) + tmp43 := lang.Apply(tmp42, []any{sym_glojure_DOT_core_SLASH_fn, v22, v25}) + tmp44 := lang.Apply(tmp41, []any{tmp43}) + tmp45 := lang.Apply(tmp40, []any{tmp44, v22}) + tmp46 := lang.Apply(tmp39, []any{tmp45}) + tmp47 := lang.Apply(tmp32, []any{tmp34, tmp36, v16, tmp38, tmp46}) + tmp48 := lang.Apply(tmp31, []any{tmp47}) + tmp49 := lang.Apply(tmp30, []any{tmp48}) + tmp50 := checkDerefVar(var_glojure_DOT_core_list) + tmp51 := checkDerefVar(var_glojure_DOT_core_seq) + tmp52 := checkDerefVar(var_glojure_DOT_core_concat) + tmp53 := checkDerefVar(var_glojure_DOT_core_list) + tmp54 := lang.Apply(tmp53, []any{sym_glojure_DOT_core_SLASH_alter_DASH_meta_BANG_}) + tmp55 := checkDerefVar(var_glojure_DOT_core_list) + tmp56 := checkDerefVar(var_glojure_DOT_core_seq) + tmp57 := checkDerefVar(var_glojure_DOT_core_concat) + tmp58 := checkDerefVar(var_glojure_DOT_core_list) + tmp59 := lang.Apply(tmp58, []any{sym_var}) + tmp60 := checkDerefVar(var_glojure_DOT_core_list) + tmp61 := lang.Apply(tmp60, []any{v4}) + tmp62 := lang.Apply(tmp57, []any{tmp59, tmp61}) + tmp63 := lang.Apply(tmp56, []any{tmp62}) + tmp64 := lang.Apply(tmp55, []any{tmp63}) + tmp65 := checkDerefVar(var_glojure_DOT_core_list) + tmp66 := lang.Apply(tmp65, []any{sym_glojure_DOT_core_SLASH_assoc}) + tmp67 := checkDerefVar(var_glojure_DOT_core_list) + tmp68 := lang.Apply(tmp67, []any{kw_inline}) + tmp69 := checkDerefVar(var_glojure_DOT_core_list) + tmp70 := checkDerefVar(var_glojure_DOT_core_seq) + tmp71 := checkDerefVar(var_glojure_DOT_core_concat) + tmp72 := checkDerefVar(var_glojure_DOT_core_list) + tmp73 := lang.Apply(tmp72, []any{sym_glojure_DOT_core_SLASH_fn}) + tmp74 := checkDerefVar(var_glojure_DOT_core_list) + tmp75 := lang.Apply(tmp74, []any{v4}) + tmp76 := checkDerefVar(var_glojure_DOT_core_list) + tmp77 := lang.Apply(tmp76, []any{v22}) + tmp78 := checkDerefVar(var_glojure_DOT_core_list) + tmp79 := lang.Apply(tmp78, []any{v25}) + tmp80 := lang.Apply(tmp71, []any{tmp73, tmp75, tmp77, tmp79}) + tmp81 := lang.Apply(tmp70, []any{tmp80}) + tmp82 := lang.Apply(tmp69, []any{tmp81}) + tmp83 := lang.Apply(tmp52, []any{tmp54, tmp64, tmp66, tmp68, tmp82}) + tmp84 := lang.Apply(tmp51, []any{tmp83}) + tmp85 := lang.Apply(tmp50, []any{tmp84}) + tmp86 := checkDerefVar(var_glojure_DOT_core_list) + tmp87 := checkDerefVar(var_glojure_DOT_core_seq) + tmp88 := checkDerefVar(var_glojure_DOT_core_concat) + tmp89 := checkDerefVar(var_glojure_DOT_core_list) + tmp90 := lang.Apply(tmp89, []any{sym_var}) + tmp91 := checkDerefVar(var_glojure_DOT_core_list) + tmp92 := lang.Apply(tmp91, []any{v4}) + tmp93 := lang.Apply(tmp88, []any{tmp90, tmp92}) + tmp94 := lang.Apply(tmp87, []any{tmp93}) + tmp95 := lang.Apply(tmp86, []any{tmp94}) + tmp96 := lang.Apply(tmp27, []any{tmp29, tmp49, tmp85, tmp95}) + tmp97 := lang.Apply(tmp26, []any{tmp96}) + tmp6 = tmp97 } // end let - return tmp7 + return tmp6 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_definline = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_definline.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // keep + // defmacro { - tmp0 := sym_keep.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_coll)), kw_doc, "Returns a lazy sequence of the non-nil results of (f item). Note,\n this means false return values will be included. f must be free of\n side-effects. Returns a transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(7339), kw_end_DASH_line, int(7339))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_defmacro.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym_doc_DASH_string_QMARK_, sym_attr_DASH_map_QMARK_, lang.NewVector(sym_params_STAR_), sym_body), lang.NewVector(sym_name, sym_doc_DASH_string_QMARK_, sym_attr_DASH_map_QMARK_, lang.NewList(lang.NewVector(sym_params_STAR_), sym_body), sym__PLUS_, sym_attr_DASH_map_QMARK_)), kw_doc, "Like defn, but the resulting function name is declared as a\n macro and will be used as a macro by the compiler when it is\n called.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(2), kw_line, int(445), kw_end_DASH_line, int(451))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 1: - v3 := args[0] + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v5 := args[0] - _ = v5 - var tmp6 lang.FnFunc - tmp6 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp7 := lang.Apply(v5, nil) - return tmp7 - case 1: - v7 := args[0] - _ = v7 - tmp8 := lang.Apply(v5, []any{v7}) - return tmp8 - case 2: - v7 := args[0] - _ = v7 - v8 := args[1] - _ = v8 - var tmp9 any + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "prefix" + var tmp7 any + { // let + // let binding "p" + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{v4}) + var v10 any = tmp9 + _ = v10 + // let binding "args" + var v11 any = v5 + _ = v11 + for { + var tmp12 any { // let - // let binding "v" - tmp10 := lang.Apply(v3, []any{v8}) - var v11 any = tmp10 - _ = v11 - var tmp12 any - tmp13 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + // let binding "f" + tmp13 := checkDerefVar(var_glojure_DOT_core_first) tmp14 := lang.Apply(tmp13, []any{v11}) - if lang.IsTruthy(tmp14) { - tmp12 = v7 + var v15 any = tmp14 + _ = v15 + var tmp16 any + tmp17 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp18 := lang.Apply(tmp17, []any{v15}) + if lang.IsTruthy(tmp18) { + tmp20 := checkDerefVar(var_glojure_DOT_core_cons) + tmp21 := lang.Apply(tmp20, []any{v15, v10}) + var tmp19 any = tmp21 + tmp23 := checkDerefVar(var_glojure_DOT_core_next) + tmp24 := lang.Apply(tmp23, []any{v11}) + var tmp22 any = tmp24 + v10 = tmp19 + v11 = tmp22 + continue } else { - tmp15 := lang.Apply(v5, []any{v7, v11}) - tmp12 = tmp15 + var tmp25 any + tmp26 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp27 := lang.Apply(tmp26, []any{v15}) + if lang.IsTruthy(tmp27) { + tmp29 := checkDerefVar(var_glojure_DOT_core_cons) + tmp30 := lang.Apply(tmp29, []any{v15, v10}) + var tmp28 any = tmp30 + tmp32 := checkDerefVar(var_glojure_DOT_core_next) + tmp33 := lang.Apply(tmp32, []any{v11}) + var tmp31 any = tmp33 + v10 = tmp28 + v11 = tmp31 + continue + } else { + tmp25 = v10 + } + tmp16 = tmp25 } - tmp9 = tmp12 + tmp12 = tmp16 } // end let - return tmp9 - default: - checkArity(args, -1) - panic("unreachable") + tmp7 = tmp12 + break + } + } // end let + var v8 any = tmp7 + _ = v8 + // let binding "fdecl" + var tmp9 any + { // let + // let binding "fd" + var v10 any = v5 + _ = v10 + for { + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp13 := checkDerefVar(var_glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v10}) + tmp15 := lang.Apply(tmp12, []any{tmp14}) + if lang.IsTruthy(tmp15) { + tmp17 := checkDerefVar(var_glojure_DOT_core_next) + tmp18 := lang.Apply(tmp17, []any{v10}) + var tmp16 any = tmp18 + v10 = tmp16 + continue + } else { + var tmp19 any + tmp20 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp21 := checkDerefVar(var_glojure_DOT_core_first) + tmp22 := lang.Apply(tmp21, []any{v10}) + tmp23 := lang.Apply(tmp20, []any{tmp22}) + if lang.IsTruthy(tmp23) { + tmp25 := checkDerefVar(var_glojure_DOT_core_next) + tmp26 := lang.Apply(tmp25, []any{v10}) + var tmp24 any = tmp26 + v10 = tmp24 + continue + } else { + tmp19 = v10 + } + tmp11 = tmp19 + } + tmp9 = tmp11 + break } + } // end let + var v10 any = tmp9 + _ = v10 + // let binding "fdecl" + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp13 := checkDerefVar(var_glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v10}) + tmp15 := lang.Apply(tmp12, []any{tmp14}) + if lang.IsTruthy(tmp15) { + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v10}) + tmp11 = tmp17 + } else { + tmp11 = v10 + } + var v18 any = tmp11 + _ = v18 + // let binding "add-implicit-args" + var tmp19 lang.FnFunc + tmp19 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v20 := args[0] + _ = v20 + var tmp21 any + { // let + // let binding "args" + tmp22 := checkDerefVar(var_glojure_DOT_core_first) + tmp23 := lang.Apply(tmp22, []any{v20}) + var v24 any = tmp23 + _ = v24 + tmp25 := checkDerefVar(var_glojure_DOT_core_cons) + tmp26 := checkDerefVar(var_glojure_DOT_core_vec) + tmp27 := checkDerefVar(var_glojure_DOT_core_cons) + tmp28 := checkDerefVar(var_glojure_DOT_core_cons) + tmp29 := lang.Apply(tmp28, []any{sym__AMP_env, v24}) + tmp30 := lang.Apply(tmp27, []any{sym__AMP_form, tmp29}) + tmp31 := lang.Apply(tmp26, []any{tmp30}) + tmp32 := checkDerefVar(var_glojure_DOT_core_next) + tmp33 := lang.Apply(tmp32, []any{v20}) + tmp34 := lang.Apply(tmp25, []any{tmp31, tmp33}) + tmp21 = tmp34 + } // end let + return tmp21 }) - tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7347), kw_column, int(6), kw_end_DASH_line, int(7354), kw_end_DASH_column, int(31)) - tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + tmp20 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(469), kw_column, int(38), kw_end_DASH_line, int(471), kw_end_DASH_column, int(87)) + tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) if err != nil { panic(err) } - return tmp8 - }) - tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7346), kw_column, int(4), kw_end_DASH_line, int(7354), kw_end_DASH_column, int(32)) - tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) - if err != nil { - panic(err) - } + var v22 any = tmp21 + _ = v22 + // let binding "add-args" + var tmp23 lang.FnFunc + tmp23 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v24 := args[0] + _ = v24 + v25 := args[1] + _ = v25 + recur_loop_61: + var tmp26 any + tmp27 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp28 := lang.Apply(tmp27, []any{v25}) + if lang.IsTruthy(tmp28) { + tmp26 = v24 + } else { + var tmp29 any + { // let + // let binding "d" + tmp30 := checkDerefVar(var_glojure_DOT_core_first) + tmp31 := lang.Apply(tmp30, []any{v25}) + var v32 any = tmp31 + _ = v32 + var tmp33 any + tmp34 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp35 := lang.Apply(tmp34, []any{v32}) + if lang.IsTruthy(tmp35) { + tmp36 := checkDerefVar(var_glojure_DOT_core_conj) + tmp37 := lang.Apply(tmp36, []any{v24, v32}) + tmp33 = tmp37 + } else { + tmp39 := checkDerefVar(var_glojure_DOT_core_conj) + tmp40 := lang.Apply(v22, []any{v32}) + tmp41 := lang.Apply(tmp39, []any{v24, tmp40}) + var tmp38 any = tmp41 + tmp43 := checkDerefVar(var_glojure_DOT_core_next) + tmp44 := lang.Apply(tmp43, []any{v25}) + var tmp42 any = tmp44 + v24 = tmp38 + v25 = tmp42 + goto recur_loop_61 + } + tmp29 = tmp33 + } // end let + tmp26 = tmp29 + } + return tmp26 + }) + tmp24 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(472), kw_column, int(29), kw_end_DASH_line, int(478), kw_end_DASH_column, int(90)) + tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v26 any = tmp25 + _ = v26 + // let binding "fdecl" + tmp27 := checkDerefVar(var_glojure_DOT_core_seq) + tmp28 := lang.NewVector() + tmp29 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(479), kw_column, int(41), kw_end_DASH_line, int(479), kw_end_DASH_column, int(42)) + tmp30, err := lang.WithMeta(tmp28, tmp29.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp31 := lang.Apply(v26, []any{tmp30, v18}) + tmp32 := lang.Apply(tmp27, []any{tmp31}) + var v33 any = tmp32 + _ = v33 + // let binding "decl" + var tmp34 any + { // let + // let binding "p" + var v35 any = v8 + _ = v35 + // let binding "d" + var v36 any = v33 + _ = v36 + for { + var tmp37 any + if lang.IsTruthy(v35) { + tmp39 := checkDerefVar(var_glojure_DOT_core_next) + tmp40 := lang.Apply(tmp39, []any{v35}) + var tmp38 any = tmp40 + tmp42 := checkDerefVar(var_glojure_DOT_core_cons) + tmp43 := checkDerefVar(var_glojure_DOT_core_first) + tmp44 := lang.Apply(tmp43, []any{v35}) + tmp45 := lang.Apply(tmp42, []any{tmp44, v36}) + var tmp41 any = tmp45 + v35 = tmp38 + v36 = tmp41 + continue + } else { + tmp37 = v36 + } + tmp34 = tmp37 + break + } + } // end let + var v35 any = tmp34 + _ = v35 + tmp36 := checkDerefVar(var_glojure_DOT_core_list) + tmp37 := checkDerefVar(var_glojure_DOT_core_cons) + tmp38 := lang.Apply(tmp37, []any{sym_glojure_DOT_core_SLASH_defn, v35}) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{sym_var, v4}) + tmp42 := lang.Apply(tmp39, []any{sym__DOT_, tmp41, lang.NewList(sym_SetMacro)}) + tmp43 := checkDerefVar(var_glojure_DOT_core_list) + tmp44 := lang.Apply(tmp43, []any{sym_var, v4}) + tmp45 := lang.Apply(tmp36, []any{sym_do, tmp38, tmp42, tmp44}) + tmp6 = tmp45 + } // end let return tmp6 - case 2: - v3 := args[0] + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(451), kw_column, int(11), kw_end_DASH_line, int(487), kw_end_DASH_column, int(40))).(lang.FnFunc) + var_glojure_DOT_core_defmacro = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_defmacro.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // defn- + { + tmp0 := sym_defn_DASH_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym__AMP_, sym_decls)), kw_doc, "same as defn, yielding non-public def", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(11), kw_line, int(4949), kw_end_DASH_line, int(4949))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + v4 := args[2] _ = v4 - var tmp5 lang.FnFunc - tmp5 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - var tmp6 any - { // let - // let binding "temp__0__auto__" - tmp7 := checkDerefVar(var_glojure_DOT_core_seq) - tmp8 := lang.Apply(tmp7, []any{v4}) - var v9 any = tmp8 - _ = v9 - var tmp10 any - if lang.IsTruthy(v9) { - var tmp11 any - { // let - // let binding "s" - var v12 any = v9 - _ = v12 - var tmp13 any - tmp14 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) - tmp15 := lang.Apply(tmp14, []any{v12}) - if lang.IsTruthy(tmp15) { - var tmp16 any - { // let - // let binding "c" - tmp17 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) - tmp18 := lang.Apply(tmp17, []any{v12}) - var v19 any = tmp18 - _ = v19 - // let binding "size" - tmp20 := checkDerefVar(var_glojure_DOT_core_count) - tmp21 := lang.Apply(tmp20, []any{v19}) - var v22 any = tmp21 - _ = v22 - // let binding "b" - tmp23 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_buffer) - tmp24 := lang.Apply(tmp23, []any{v22}) - var v25 any = tmp24 - _ = v25 - var tmp26 any - { // let - // let binding "n__0__auto__" - tmp27 := checkDerefVar(var_glojure_DOT_core_long) - tmp28 := lang.Apply(tmp27, []any{v22}) - var v29 any = tmp28 - _ = v29 - var tmp30 any - { // let - // let binding "i" - var v31 any = int64(0) - _ = v31 - for { - var tmp32 any - tmp33 := checkDerefVar(var_glojure_DOT_core__LT_) - tmp34 := lang.Apply(tmp33, []any{v31, v29}) - if lang.IsTruthy(tmp34) { - var tmp35 any - { // let - // let binding "x" - tmp36, _ := lang.FieldOrMethod(v19, "nth") - if reflect.TypeOf(tmp36).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) - } - tmp37 := lang.Apply(tmp36, []any{v31}) - tmp38 := lang.Apply(v3, []any{tmp37}) - var v39 any = tmp38 - _ = v39 - var tmp40 any - tmp41 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) - tmp42 := lang.Apply(tmp41, []any{v39}) - if lang.IsTruthy(tmp42) { - } else { - tmp43 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_append) - tmp44 := lang.Apply(tmp43, []any{v25, v39}) - tmp40 = tmp44 - } - tmp35 = tmp40 - } // end let - _ = tmp35 - tmp37 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) - tmp38 := lang.Apply(tmp37, []any{v31}) - var tmp36 any = tmp38 - v31 = tmp36 - continue - } else { - } - tmp30 = tmp32 - break - } - } // end let - tmp26 = tmp30 - } // end let - _ = tmp26 - tmp27 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_cons) - tmp28 := checkDerefVar(var_glojure_DOT_core_chunk) - tmp29 := lang.Apply(tmp28, []any{v25}) - tmp30 := checkDerefVar(var_glojure_DOT_core_keep) - tmp31 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) - tmp32 := lang.Apply(tmp31, []any{v12}) - tmp33 := lang.Apply(tmp30, []any{v3, tmp32}) - tmp34 := lang.Apply(tmp27, []any{tmp29, tmp33}) - tmp16 = tmp34 - } // end let - tmp13 = tmp16 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp7 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp8 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp9 := checkDerefVar(var_glojure_DOT_core_meta) + tmp10 := lang.Apply(tmp9, []any{v4}) + tmp11 := lang.Apply(tmp8, []any{tmp10, kw_private, true}) + tmp12 := lang.Apply(tmp7, []any{v4, tmp11}) + tmp13 := lang.Apply(tmp6, []any{sym_glojure_DOT_core_SLASH_defn, tmp12, v5}) + return tmp13 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_defn_DASH_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_defn_DASH_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // defonce + { + tmp0 := sym_defonce.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym_expr)), kw_doc, "defs name to have the root value of the expr iff the named var has no root value,\n else expr is unevaluated", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(5806), kw_end_DASH_line, int(5806))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_let}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + tmp12 := checkDerefVar(var_glojure_DOT_core_vector) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_v__0__auto__}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{sym_def}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v4}) + tmp24 := lang.Apply(tmp19, []any{tmp21, tmp23}) + tmp25 := lang.Apply(tmp18, []any{tmp24}) + tmp26 := lang.Apply(tmp17, []any{tmp25}) + tmp27 := lang.Apply(tmp14, []any{tmp16, tmp26}) + tmp28 := lang.Apply(tmp13, []any{tmp27}) + tmp29 := lang.Apply(tmp11, []any{tmp12, tmp28}) + tmp30 := lang.Apply(tmp10, []any{tmp29}) + tmp31 := checkDerefVar(var_glojure_DOT_core_list) + tmp32 := checkDerefVar(var_glojure_DOT_core_seq) + tmp33 := checkDerefVar(var_glojure_DOT_core_concat) + tmp34 := checkDerefVar(var_glojure_DOT_core_list) + tmp35 := lang.Apply(tmp34, []any{sym_glojure_DOT_core_SLASH_when_DASH_not}) + tmp36 := checkDerefVar(var_glojure_DOT_core_list) + tmp37 := checkDerefVar(var_glojure_DOT_core_seq) + tmp38 := checkDerefVar(var_glojure_DOT_core_concat) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := lang.Apply(tmp39, []any{sym__DOT_HasRoot}) + tmp41 := checkDerefVar(var_glojure_DOT_core_list) + tmp42 := lang.Apply(tmp41, []any{sym_v__0__auto__}) + tmp43 := lang.Apply(tmp38, []any{tmp40, tmp42}) + tmp44 := lang.Apply(tmp37, []any{tmp43}) + tmp45 := lang.Apply(tmp36, []any{tmp44}) + tmp46 := checkDerefVar(var_glojure_DOT_core_list) + tmp47 := checkDerefVar(var_glojure_DOT_core_seq) + tmp48 := checkDerefVar(var_glojure_DOT_core_concat) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) + tmp50 := lang.Apply(tmp49, []any{sym_def}) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := lang.Apply(tmp51, []any{v4}) + tmp53 := checkDerefVar(var_glojure_DOT_core_list) + tmp54 := lang.Apply(tmp53, []any{v5}) + tmp55 := lang.Apply(tmp48, []any{tmp50, tmp52, tmp54}) + tmp56 := lang.Apply(tmp47, []any{tmp55}) + tmp57 := lang.Apply(tmp46, []any{tmp56}) + tmp58 := lang.Apply(tmp33, []any{tmp35, tmp45, tmp57}) + tmp59 := lang.Apply(tmp32, []any{tmp58}) + tmp60 := lang.Apply(tmp31, []any{tmp59}) + tmp61 := lang.Apply(tmp7, []any{tmp9, tmp30, tmp60}) + tmp62 := lang.Apply(tmp6, []any{tmp61}) + return tmp62 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_defonce = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_defonce.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // delay + { + tmp0 := sym_delay.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_body)), kw_doc, "Takes a body of expressions and yields a Delay object that will\n invoke the body only the first time it is forced (with force or deref/@), and\n will cache the result and return it on all subsequent force\n calls. See also - realized?", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(11), kw_line, int(739), kw_end_DASH_line, int(739))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_list) + tmp6 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp7 := lang.NewVector() + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(746), kw_column, int(62), kw_end_DASH_line, int(746), kw_end_DASH_column, int(63)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp10 := lang.Apply(tmp6, []any{sym_fn_STAR_, tmp9, v4}) + tmp11 := lang.Apply(tmp5, []any{sym_new, sym_glojure_DOT_lang_DOT_Delay, tmp10}) + return tmp11 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_delay = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_delay.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // deref-as-map + { + tmp0 := sym_deref_DASH_as_DASH_map.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(408), kw_column, int(8), kw_end_DASH_line, int(408), kw_end_DASH_column, int(19), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_o)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "pending" + var tmp4 any + { // let + // let binding "and__0__auto__" + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp6 := reflect.TypeOf((*lang.IPending)(nil)).Elem() + tmp7 := lang.Apply(tmp5, []any{tmp6, v2}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + tmp10 := checkDerefVar(var_glojure_DOT_core_not) + tmp11, ok := lang.FieldOrMethod(v2, "isRealized") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "isRealized"))) + } + var tmp12 any + switch reflect.TypeOf(tmp11).Kind() { + case reflect.Func: + tmp12 = lang.Apply(tmp11, nil) + default: + tmp12 = tmp11 + } + tmp13 := lang.Apply(tmp10, []any{tmp12}) + tmp9 = tmp13 + } else { + tmp9 = v8 + } + tmp4 = tmp9 + } // end let + var v5 any = tmp4 + _ = v5 + // let binding "vec__250" + var tmp6 any + if lang.IsTruthy(v5) { + } else { + var tmp7 any + func() { + defer func() { + if r := recover(); r != nil { + if lang.CatchMatches(r, lang.Throwable) { + v8 := r + _ = v8 + tmp9 := lang.NewVector(true, v8) + tmp10 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(415), kw_column, int(18), kw_end_DASH_line, int(415), kw_end_DASH_column, int(25)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp7 = tmp11 } else { - var tmp17 any - { // let - // let binding "x" - tmp18 := checkDerefVar(var_glojure_DOT_core_first) - tmp19 := lang.Apply(tmp18, []any{v12}) - tmp20 := lang.Apply(v3, []any{tmp19}) - var v21 any = tmp20 - _ = v21 - var tmp22 any - tmp23 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) - tmp24 := lang.Apply(tmp23, []any{v21}) - if lang.IsTruthy(tmp24) { - tmp25 := checkDerefVar(var_glojure_DOT_core_keep) - tmp26 := checkDerefVar(var_glojure_DOT_core_rest) - tmp27 := lang.Apply(tmp26, []any{v12}) - tmp28 := lang.Apply(tmp25, []any{v3, tmp27}) - tmp22 = tmp28 - } else { - tmp29 := checkDerefVar(var_glojure_DOT_core_cons) - tmp30 := checkDerefVar(var_glojure_DOT_core_keep) - tmp31 := checkDerefVar(var_glojure_DOT_core_rest) - tmp32 := lang.Apply(tmp31, []any{v12}) - tmp33 := lang.Apply(tmp30, []any{v3, tmp32}) - tmp34 := lang.Apply(tmp29, []any{v21, tmp33}) - tmp22 = tmp34 - } - tmp17 = tmp22 - } // end let - tmp13 = tmp17 + panic(r) } - tmp11 = tmp13 - } // end let - tmp10 = tmp11 + } + }() + tmp8 := checkDerefVar(var_glojure_DOT_core_deref) + tmp9 := lang.Apply(tmp8, []any{v2}) + tmp10 := lang.NewVector(false, tmp9) + tmp11 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(413), kw_column, int(16), kw_end_DASH_line, int(413), kw_end_DASH_column, int(32)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp7 = tmp12 + }() + tmp6 = tmp7 + } + var v13 any = tmp6 + _ = v13 + // let binding "ex" + tmp14 := checkDerefVar(var_glojure_DOT_core_nth) + tmp15 := lang.Apply(tmp14, []any{v13, int64(0), nil}) + var v16 any = tmp15 + _ = v16 + // let binding "val" + tmp17 := checkDerefVar(var_glojure_DOT_core_nth) + tmp18 := lang.Apply(tmp17, []any{v13, int64(1), nil}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + var tmp21 any + { // let + // let binding "or__0__auto__" + var v22 any = v16 + _ = v22 + var tmp23 any + if lang.IsTruthy(v22) { + tmp23 = v22 + } else { + var tmp24 any + { // let + // let binding "and__0__auto__" + tmp25 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp26 := reflect.TypeOf((*lang.Agent)(nil)) + tmp27 := lang.Apply(tmp25, []any{tmp26, v2}) + var v28 any = tmp27 + _ = v28 + var tmp29 any + if lang.IsTruthy(v28) { + tmp30 := checkDerefVar(var_glojure_DOT_core_agent_DASH_error) + tmp31 := lang.Apply(tmp30, []any{v2}) + tmp29 = tmp31 + } else { + tmp29 = v28 + } + tmp24 = tmp29 + } // end let + tmp23 = tmp24 + } + tmp21 = tmp23 + } // end let + if lang.IsTruthy(tmp21) { + tmp20 = kw_failed + } else { + var tmp22 any + if lang.IsTruthy(v5) { + tmp22 = kw_pending + } else { + var tmp23 any + if lang.IsTruthy(kw_else) { + tmp23 = kw_ready } else { } - tmp6 = tmp10 - } // end let - return tmp6 - }) - tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) - return tmp6 + tmp22 = tmp23 + } + tmp20 = tmp22 + } + tmp24 := lang.NewMap(kw_status, tmp20, kw_val, v19) + tmp25 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(416), kw_column, int(5), kw_end_DASH_line, int(429), kw_end_DASH_column, int(14)) + tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp3 = tmp26 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_deref_DASH_as_DASH_map = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_deref_DASH_as_DASH_map.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // descendants + { + tmp0 := sym_descendants.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_tag), lang.NewVector(sym_h, sym_tag)), kw_doc, "Returns the immediate and indirect children of tag, through a\n relationship established via derive. h must be a hierarchy obtained\n from make-hierarchy, if not supplied defaults to the global\n hierarchy. Note: does not work on Java type inheritance\n relationships.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(5593), kw_end_DASH_line, int(5593))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_descendants) + tmp4 := checkDerefVar(var_glojure_DOT_core_global_DASH_hierarchy) + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_class_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + tmp7 := lang.Apply(lang.NewUnsupportedOperationError, []any{"Can't get descendants of classes"}) + panic(tmp7) + } else { + tmp8 := checkDerefVar(var_glojure_DOT_core_not_DASH_empty) + tmp9 := checkDerefVar(var_glojure_DOT_core_get) + tmp10 := lang.Apply(kw_descendants, []any{v2}) + tmp11 := lang.Apply(tmp9, []any{tmp10, v3}) + tmp12 := lang.Apply(tmp8, []any{tmp11}) + tmp4 = tmp12 + } + return tmp4 default: checkArity(args, -1) panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_descendants = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_descendants.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // keep-indexed + // distinct { - tmp0 := sym_keep_DASH_indexed.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_coll)), kw_doc, "Returns a lazy sequence of the non-nil results of (f index item). Note,\n this means false return values will be included. f must be free of\n side-effects. Returns a stateful transducer when no collection is\n provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(7372), kw_end_DASH_line, int(7372))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_distinct.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_coll)), kw_doc, "Returns a lazy sequence of the elements of coll with duplicates removed.\n Returns a stateful transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(5053), kw_end_DASH_line, int(5053))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 1: - v3 := args[0] - _ = v3 - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { + case 0: + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v5 := args[0] - _ = v5 - var tmp6 any + v3 := args[0] + _ = v3 + var tmp4 any { // let - // let binding "iv" - tmp7 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) - tmp8 := lang.Apply(tmp7, []any{int64(-1)}) - var v9 any = tmp8 - _ = v9 - var tmp10 lang.FnFunc - tmp10 = lang.NewFnFunc(func(args ...any) any { + // let binding "seen" + tmp5 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) + tmp6 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5060), kw_column, int(28), kw_end_DASH_line, int(5060), kw_end_DASH_column, int(30)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp9 := lang.Apply(tmp5, []any{tmp8}) + var v10 any = tmp9 + _ = v10 + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - tmp11 := lang.Apply(v5, nil) - return tmp11 - case 1: - v11 := args[0] - _ = v11 - tmp12 := lang.Apply(v5, []any{v11}) + tmp12 := lang.Apply(v3, nil) return tmp12 + case 1: + v12 := args[0] + _ = v12 + tmp13 := lang.Apply(v3, []any{v12}) + return tmp13 case 2: - v11 := args[0] - _ = v11 - v12 := args[1] + v12 := args[0] _ = v12 - var tmp13 any - { // let - // let binding "i" - tmp14 := checkDerefVar(var_glojure_DOT_core_inc) - tmp15, ok := lang.FieldOrMethod(v9, "Deref") + v13 := args[1] + _ = v13 + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp16 := checkDerefVar(var_glojure_DOT_core_deref) + tmp17 := lang.Apply(tmp16, []any{v10}) + tmp18 := lang.Apply(tmp15, []any{tmp17, v13}) + if lang.IsTruthy(tmp18) { + tmp14 = v12 + } else { + tmp19 := checkDerefVar(var_glojure_DOT_core_conj) + tmp20, ok := lang.FieldOrMethod(v10, "Deref") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v9, "Deref"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v10, "Deref"))) } - var tmp16 any - switch reflect.TypeOf(tmp15).Kind() { + var tmp21 any + switch reflect.TypeOf(tmp20).Kind() { case reflect.Func: - tmp16 = lang.Apply(tmp15, nil) + tmp21 = lang.Apply(tmp20, nil) default: - tmp16 = tmp15 + tmp21 = tmp20 } - tmp17 := lang.Apply(tmp14, []any{tmp16}) - tmp18, _ := lang.FieldOrMethod(v9, "reset") - if reflect.TypeOf(tmp18).Kind() != reflect.Func { + tmp22 := lang.Apply(tmp19, []any{tmp21, v13}) + tmp23, _ := lang.FieldOrMethod(v10, "reset") + if reflect.TypeOf(tmp23).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) } - tmp19 := lang.Apply(tmp18, []any{tmp17}) - var v20 any = tmp19 - _ = v20 - // let binding "v" - tmp21 := lang.Apply(v3, []any{v20, v12}) - var v22 any = tmp21 - _ = v22 - var tmp23 any - tmp24 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) - tmp25 := lang.Apply(tmp24, []any{v22}) - if lang.IsTruthy(tmp25) { - tmp23 = v11 - } else { - tmp26 := lang.Apply(v5, []any{v11, v22}) - tmp23 = tmp26 - } - tmp13 = tmp23 - } // end let - return tmp13 + tmp24 := lang.Apply(tmp23, []any{tmp22}) + _ = tmp24 + tmp25 := lang.Apply(v3, []any{v12, v13}) + tmp14 = tmp25 + } + return tmp14 default: checkArity(args, -1) panic("unreachable") } }) - tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7382), kw_column, int(8), kw_end_DASH_line, int(7390), kw_end_DASH_column, int(33)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5061), kw_column, int(8), kw_end_DASH_line, int(5068), kw_end_DASH_column, int(37)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp6 = tmp12 + tmp4 = tmp13 } // end let - return tmp6 + return tmp4 }) - tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7380), kw_column, int(4), kw_end_DASH_line, int(7390), kw_end_DASH_column, int(35)) - tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + tmp3 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5059), kw_column, int(4), kw_end_DASH_line, int(5068), kw_end_DASH_column, int(39)) + tmp4, err := lang.WithMeta(tmp2, tmp3.(lang.IPersistentMap)) if err != nil { panic(err) } - return tmp6 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - return nil + return tmp4 + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "step" + var tmp4 lang.FnFunc + { // function step + var v5 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + var tmp8 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + recur_loop_877: + var tmp12 any + { // let + // let binding "vec__62" + var v13 any = v10 + _ = v13 + // let binding "f" + tmp14 := checkDerefVar(var_glojure_DOT_core_nth) + tmp15 := lang.Apply(tmp14, []any{v13, int64(0), nil}) + var v16 any = tmp15 + _ = v16 + // let binding "xs" + var v17 any = v13 + _ = v17 + var tmp18 any + { // let + // let binding "temp__0__auto__" + tmp19 := checkDerefVar(var_glojure_DOT_core_seq) + tmp20 := lang.Apply(tmp19, []any{v17}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + if lang.IsTruthy(v21) { + var tmp23 any + { // let + // let binding "s" + var v24 any = v21 + _ = v24 + var tmp25 any + tmp26 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp27 := lang.Apply(tmp26, []any{v11, v16}) + if lang.IsTruthy(tmp27) { + tmp29 := checkDerefVar(var_glojure_DOT_core_rest) + tmp30 := lang.Apply(tmp29, []any{v24}) + var tmp28 any = tmp30 + var tmp31 any = v11 + v10 = tmp28 + v11 = tmp31 + goto recur_loop_877 + } else { + tmp32 := checkDerefVar(var_glojure_DOT_core_cons) + tmp33 := checkDerefVar(var_glojure_DOT_core_rest) + tmp34 := lang.Apply(tmp33, []any{v24}) + tmp35 := checkDerefVar(var_glojure_DOT_core_conj) + tmp36 := lang.Apply(tmp35, []any{v11, v16}) + tmp37 := lang.Apply(v5, []any{tmp34, tmp36}) + tmp38 := lang.Apply(tmp32, []any{v16, tmp37}) + tmp25 = tmp38 + } + tmp23 = tmp25 + } // end let + tmp22 = tmp23 + } else { + } + tmp18 = tmp22 + } // end let + tmp12 = tmp18 + } // end let + return tmp12 + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5072), kw_column, int(20), kw_end_DASH_line, int(5076), kw_end_DASH_column, int(66)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp12 := lang.Apply(tmp11, []any{v6, v7}) + return tmp12 + }) + tmp9 := lang.Apply(lang.NewLazySeq, []any{tmp8}) + return tmp9 + }) + v5 = tmp4 + _ = v5 + } + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5070), kw_column, int(15), kw_end_DASH_line, int(5077), kw_end_DASH_column, int(29)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v7 any = tmp6 + _ = v7 + tmp8 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5078), kw_column, int(17), kw_end_DASH_line, int(5078), kw_end_DASH_column, int(19)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp11 := lang.Apply(v7, []any{v2, tmp10}) + tmp3 = tmp11 + } // end let + return tmp3 default: checkArity(args, -1) panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // key - { - tmp0 := sym_key.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_e)), kw_doc, "Returns the key of the map entry.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(1563), kw_end_DASH_line, int(1563))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4, _ := lang.FieldOrMethod(v3, "GetKey") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("GetKey is not a function"))) - } - tmp5 := lang.Apply(tmp4, []any{}) - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // keys - { - tmp0 := sym_keys.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_map)), kw_doc, "Returns a sequence of the map's keys, in the same order as (seq map).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1551), kw_end_DASH_line, int(1551))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := lang.Apply(lang.Keys, []any{v3}) - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_distinct = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_distinct.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // keyword + // dorun { - tmp1 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() - tmp0 := sym_keyword.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_name), lang.NewVector(sym_ns, sym_name)), kw_doc, "Returns a Keyword with the given namespace and name. Do not use :\n in the keyword strings, it will be added automatically.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(609), kw_end_DASH_line, int(609))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_dorun.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll), lang.NewVector(sym_n, sym_coll)), kw_doc, "When lazy sequences are produced via functions that have side\n effects, any effects other than those needed to produce the first\n element in the seq do not occur until the seq is consumed. dorun can\n be used to force any effects. Walks through the successive nexts of\n the seq, does not retain the head and returns nil.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3116), kw_end_DASH_line, int(3116))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: - v4 := args[0] - _ = v4 - var tmp5 any - tmp6 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) - tmp7 := lang.Apply(tmp6, []any{v4}) - if lang.IsTruthy(tmp7) { - tmp5 = v4 - } else { - var tmp8 any - tmp9 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) - tmp10 := lang.Apply(tmp9, []any{v4}) - if lang.IsTruthy(tmp10) { - tmp11 := lang.Apply(lang.InternKeywordSymbol, []any{v4}) - tmp8 = tmp11 + v2 := args[0] + _ = v2 + recur_loop_579: + var tmp3 any + { // let + // let binding "temp__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + var tmp8 any + { // let + // let binding "s" + var v9 any = v6 + _ = v9 + tmp11 := checkDerefVar(var_glojure_DOT_core_next) + tmp12 := lang.Apply(tmp11, []any{v9}) + var tmp10 any = tmp12 + v2 = tmp10 + goto recur_loop_579 + } // end let + tmp7 = tmp8 } else { - var tmp12 any - tmp13 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) - tmp14 := lang.Apply(tmp13, []any{v4}) - if lang.IsTruthy(tmp14) { - tmp15 := lang.Apply(lang.InternKeywordString, []any{v4}) - tmp12 = tmp15 - } else { - } - tmp8 = tmp12 } - tmp5 = tmp8 - } - return tmp5 + tmp3 = tmp7 + } // end let + return tmp3 case 2: - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6 := lang.Apply(lang.InternKeyword, []any{v4, v5}) - return tmp6 - default: - checkArity(args, -1) - panic("unreachable") - } - }) - tmp4 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // keyword? - { - tmp0 := sym_keyword_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a Keyword", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(563), kw_end_DASH_line, int(563))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp5 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() - tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) - return tmp6 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // last - { - tmp0 := sym_last.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Return the last item in coll, in linear time", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(5), kw_column, int(2), kw_line, int(262), kw_end_DASH_line, int(266))).(*lang.Symbol) - var tmp2 lang.FnFunc - { // function last - var v3 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - recur_loop_32: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + recur_loop_580: + var tmp4 any var tmp5 any - tmp6 := checkDerefVar(var_glojure_DOT_core_next) - tmp7 := lang.Apply(tmp6, []any{v4}) - if lang.IsTruthy(tmp7) { - tmp9 := checkDerefVar(var_glojure_DOT_core_next) - tmp10 := lang.Apply(tmp9, []any{v4}) - var tmp8 any = tmp10 - v4 = tmp8 - goto recur_loop_32 + { // let + // let binding "and__0__auto__" + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := lang.Apply(tmp6, []any{v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + tmp10 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp9 = tmp11 + } else { + tmp9 = v8 + } + tmp5 = tmp9 + } // end let + if lang.IsTruthy(tmp5) { + tmp7 := checkDerefVar(var_glojure_DOT_core_dec) + tmp8 := lang.Apply(tmp7, []any{v2}) + var tmp6 any = tmp8 + tmp10 := checkDerefVar(var_glojure_DOT_core_next) + tmp11 := lang.Apply(tmp10, []any{v3}) + var tmp9 any = tmp11 + v2 = tmp6 + v3 = tmp9 + goto recur_loop_580 } else { - tmp11 := checkDerefVar(var_glojure_DOT_core_first) - tmp12 := lang.Apply(tmp11, []any{v4}) - tmp5 = tmp12 - } - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(266), kw_column, int(7), kw_end_DASH_line, int(269), kw_end_DASH_column, int(21))).(lang.FnFunc) - v3 = tmp2 - _ = v3 - } - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // lazy-cat - { - tmp0 := sym_lazy_DASH_cat.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_colls)), kw_doc, "Expands to code which yields a lazy sequence of the concatenation\n of the supplied colls. Each coll expr is not evaluated until it is\n needed. \n\n (lazy-cat xs ys zs) === (concat (lazy-seq xs) (lazy-seq ys) (lazy-seq zs))", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(11), kw_line, int(4636), kw_end_DASH_line, int(4636))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - tmp6 := checkDerefVar(var_glojure_DOT_core_seq) - tmp7 := checkDerefVar(var_glojure_DOT_core_concat) - tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_concat}) - tmp10 := checkDerefVar(var_glojure_DOT_core_map) - var tmp11 lang.FnFunc - tmp11 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v12 := args[0] - _ = v12 - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_lazy_DASH_seq, v12}) - return tmp14 - }) - tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4644), kw_column, int(19), kw_end_DASH_line, int(4644), kw_end_DASH_column, int(37)) - tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) - if err != nil { - panic(err) } - tmp14 := lang.Apply(tmp10, []any{tmp13, v5}) - tmp15 := lang.Apply(tmp7, []any{tmp9, tmp14}) - tmp16 := lang.Apply(tmp6, []any{tmp15}) - return tmp16 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // lazy-seq - { - tmp0 := sym_lazy_DASH_seq.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_body)), kw_doc, "Takes a body of expressions that returns an ISeq or nil, and yields\n a Seqable object that will invoke the body only the first time seq\n is called, and will cache the result and return it on all subsequent\n seq calls. See also - realized?", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(11), kw_line, int(676), kw_end_DASH_line, int(676))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { + return tmp4 default: - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - tmp6 := checkDerefVar(var_glojure_DOT_core_list) - tmp7 := checkDerefVar(var_glojure_DOT_core_list_STAR_) - tmp8 := lang.NewVector() - tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(683), kw_column, int(101), kw_end_DASH_line, int(683), kw_end_DASH_column, int(102)) - tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp11 := lang.Apply(tmp7, []any{sym_fn_STAR_, tmp10, v5}) - tmp12 := lang.Apply(tmp6, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_NewLazySeq, tmp11}) - return tmp12 + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_dorun = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_dorun.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // let + // dotimes { - tmp0 := sym_let.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "binding => binding-form init-expr\n binding-form => name, or destructuring-form\n destructuring-form => map-destructure-form, or seq-destructure-form\n\n Evaluates the exprs in a lexical context in which the symbols in\n the binding-forms are bound to their respective init-exprs or parts\n therein.\n\n See https://glojure.org/reference/special_forms#binding-forms for\n more information about destructuring.", kw_forms, lang.NewVector(lang.NewList(sym_let, lang.NewVector(sym_bindings_STAR_), sym_exprs_STAR_)), kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(11), kw_line, int(4496), kw_end_DASH_line, int(4496), kw_special_DASH_form, true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_dotimes.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "bindings => name n\n\n Repeatedly executes body (presumably for side-effects) with name\n bound to integers from 0 through n-1.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(3306), kw_end_DASH_line, int(3306))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: checkArity(args, 3) - v3 := args[0] + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + v4 := args[2] _ = v4 - v5 := args[2] + var v5 any = lang.NewList(args[3:]...) _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any - tmp8 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) - tmp9 := lang.Apply(tmp8, []any{v5}) - if lang.IsTruthy(tmp9) { + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v4}) + if lang.IsTruthy(tmp8) { } else { - tmp10 := checkDerefVar(var_glojure_DOT_core_str) - tmp11 := checkDerefVar(var_glojure_DOT_core_first) - tmp12 := lang.Apply(tmp11, []any{v3}) - tmp13 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) - tmp14 := checkDerefVar(var_glojure_DOT_core_meta) - tmp15 := lang.Apply(tmp14, []any{v3}) - tmp16 := lang.Apply(kw_line, []any{tmp15}) - tmp17 := lang.Apply(tmp10, []any{tmp12, " requires ", "a vector for its binding", " in ", tmp13, ":", tmp16}) - tmp18 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp17}) - panic(tmp18) + tmp9 := checkDerefVar(var_glojure_DOT_core_str) + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp13 := checkDerefVar(var_glojure_DOT_core_meta) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(kw_line, []any{tmp14}) + tmp16 := lang.Apply(tmp9, []any{tmp11, " requires ", "a vector for its binding", " in ", tmp12, ":", tmp15}) + tmp17 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp16}) + panic(tmp17) } - _ = tmp7 - var tmp19 any - tmp20 := checkDerefVar(var_glojure_DOT_core_even_QMARK_) - tmp21 := checkDerefVar(var_glojure_DOT_core_count) - tmp22 := lang.Apply(tmp21, []any{v5}) - tmp23 := lang.Apply(tmp20, []any{tmp22}) - if lang.IsTruthy(tmp23) { + _ = tmp6 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp20 := checkDerefVar(var_glojure_DOT_core_count) + tmp21 := lang.Apply(tmp20, []any{v4}) + tmp22 := lang.Apply(tmp19, []any{int64(2), tmp21}) + if lang.IsTruthy(tmp22) { } else { - tmp24 := checkDerefVar(var_glojure_DOT_core_str) - tmp25 := checkDerefVar(var_glojure_DOT_core_first) - tmp26 := lang.Apply(tmp25, []any{v3}) - tmp27 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) - tmp28 := checkDerefVar(var_glojure_DOT_core_meta) - tmp29 := lang.Apply(tmp28, []any{v3}) - tmp30 := lang.Apply(kw_line, []any{tmp29}) - tmp31 := lang.Apply(tmp24, []any{tmp26, " requires ", "an even number of forms in binding vector", " in ", tmp27, ":", tmp30}) - tmp32 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp31}) - panic(tmp32) - } - _ = tmp19 - tmp33 := checkDerefVar(var_glojure_DOT_core_seq) - tmp34 := checkDerefVar(var_glojure_DOT_core_concat) - tmp35 := checkDerefVar(var_glojure_DOT_core_list) - tmp36 := lang.Apply(tmp35, []any{sym_let_STAR_}) - tmp37 := checkDerefVar(var_glojure_DOT_core_list) - tmp38 := checkDerefVar(var_glojure_DOT_core_destructure) - tmp39 := lang.Apply(tmp38, []any{v5}) - tmp40 := lang.Apply(tmp37, []any{tmp39}) - tmp41 := lang.Apply(tmp34, []any{tmp36, tmp40, v6}) - tmp42 := lang.Apply(tmp33, []any{tmp41}) - return tmp42 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // letfn - { - tmp0 := sym_letfn.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_fnspecs, sym__AMP_, sym_body)), kw_doc, "fnspec ==> (fname [params*] exprs) or (fname ([params*] exprs)+)\n\n Takes a vector of function specs and a body, and generates a set of\n bindings of functions to their names. All of the names are available\n in all of the definitions of the functions, as well as the body.", kw_forms, lang.NewVector(lang.NewList(sym_letfn, lang.NewVector(sym_fnspecs_STAR_), sym_exprs_STAR_)), kw_url, nil, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(11), kw_line, int(6545), kw_end_DASH_line, int(6545), kw_special_DASH_form, true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 3) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - tmp7 := checkDerefVar(var_glojure_DOT_core_seq) - tmp8 := checkDerefVar(var_glojure_DOT_core_concat) - tmp9 := checkDerefVar(var_glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{sym_letfn_STAR_}) - tmp11 := checkDerefVar(var_glojure_DOT_core_list) - tmp12 := checkDerefVar(var_glojure_DOT_core_vec) - tmp13 := checkDerefVar(var_glojure_DOT_core_interleave) - tmp14 := checkDerefVar(var_glojure_DOT_core_map) - tmp15 := checkDerefVar(var_glojure_DOT_core_first) - tmp16 := lang.Apply(tmp14, []any{tmp15, v5}) - tmp17 := checkDerefVar(var_glojure_DOT_core_map) - var tmp18 lang.FnFunc - tmp18 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v19 := args[0] - _ = v19 - tmp20 := checkDerefVar(var_glojure_DOT_core_cons) - tmp21 := lang.Apply(tmp20, []any{sym_glojure_DOT_core_SLASH_fn, v19}) - return tmp21 - }) - tmp19 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6555), kw_column, int(35), kw_end_DASH_line, int(6555), kw_end_DASH_column, int(47)) - tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp21 := lang.Apply(tmp17, []any{tmp20, v5}) - tmp22 := lang.Apply(tmp13, []any{tmp16, tmp21}) - tmp23 := lang.Apply(tmp12, []any{tmp22}) - tmp24 := lang.Apply(tmp11, []any{tmp23}) - tmp25 := lang.Apply(tmp8, []any{tmp10, tmp24, v6}) - tmp26 := lang.Apply(tmp7, []any{tmp25}) - return tmp26 + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp27 := checkDerefVar(var_glojure_DOT_core_meta) + tmp28 := lang.Apply(tmp27, []any{v2}) + tmp29 := lang.Apply(kw_line, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp25, " requires ", "exactly 2 forms in binding vector", " in ", tmp26, ":", tmp29}) + tmp31 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp31) + } + _ = tmp18 + var tmp32 any + { // let + // let binding "i" + tmp33 := checkDerefVar(var_glojure_DOT_core_first) + tmp34 := lang.Apply(tmp33, []any{v4}) + var v35 any = tmp34 + _ = v35 + // let binding "n" + tmp36 := checkDerefVar(var_glojure_DOT_core_second) + tmp37 := lang.Apply(tmp36, []any{v4}) + var v38 any = tmp37 + _ = v38 + tmp39 := checkDerefVar(var_glojure_DOT_core_seq) + tmp40 := checkDerefVar(var_glojure_DOT_core_concat) + tmp41 := checkDerefVar(var_glojure_DOT_core_list) + tmp42 := lang.Apply(tmp41, []any{sym_glojure_DOT_core_SLASH_let}) + tmp43 := checkDerefVar(var_glojure_DOT_core_list) + tmp44 := checkDerefVar(var_glojure_DOT_core_apply) + tmp45 := checkDerefVar(var_glojure_DOT_core_vector) + tmp46 := checkDerefVar(var_glojure_DOT_core_seq) + tmp47 := checkDerefVar(var_glojure_DOT_core_concat) + tmp48 := checkDerefVar(var_glojure_DOT_core_list) + tmp49 := lang.Apply(tmp48, []any{sym_n__0__auto__}) + tmp50 := checkDerefVar(var_glojure_DOT_core_list) + tmp51 := checkDerefVar(var_glojure_DOT_core_seq) + tmp52 := checkDerefVar(var_glojure_DOT_core_concat) + tmp53 := checkDerefVar(var_glojure_DOT_core_list) + tmp54 := lang.Apply(tmp53, []any{sym_glojure_DOT_core_SLASH_long}) + tmp55 := checkDerefVar(var_glojure_DOT_core_list) + tmp56 := lang.Apply(tmp55, []any{v38}) + tmp57 := lang.Apply(tmp52, []any{tmp54, tmp56}) + tmp58 := lang.Apply(tmp51, []any{tmp57}) + tmp59 := lang.Apply(tmp50, []any{tmp58}) + tmp60 := lang.Apply(tmp47, []any{tmp49, tmp59}) + tmp61 := lang.Apply(tmp46, []any{tmp60}) + tmp62 := lang.Apply(tmp44, []any{tmp45, tmp61}) + tmp63 := lang.Apply(tmp43, []any{tmp62}) + tmp64 := checkDerefVar(var_glojure_DOT_core_list) + tmp65 := checkDerefVar(var_glojure_DOT_core_seq) + tmp66 := checkDerefVar(var_glojure_DOT_core_concat) + tmp67 := checkDerefVar(var_glojure_DOT_core_list) + tmp68 := lang.Apply(tmp67, []any{sym_glojure_DOT_core_SLASH_loop}) + tmp69 := checkDerefVar(var_glojure_DOT_core_list) + tmp70 := checkDerefVar(var_glojure_DOT_core_apply) + tmp71 := checkDerefVar(var_glojure_DOT_core_vector) + tmp72 := checkDerefVar(var_glojure_DOT_core_seq) + tmp73 := checkDerefVar(var_glojure_DOT_core_concat) + tmp74 := checkDerefVar(var_glojure_DOT_core_list) + tmp75 := lang.Apply(tmp74, []any{v35}) + tmp76 := checkDerefVar(var_glojure_DOT_core_list) + tmp77 := lang.Apply(tmp76, []any{int64(0)}) + tmp78 := lang.Apply(tmp73, []any{tmp75, tmp77}) + tmp79 := lang.Apply(tmp72, []any{tmp78}) + tmp80 := lang.Apply(tmp70, []any{tmp71, tmp79}) + tmp81 := lang.Apply(tmp69, []any{tmp80}) + tmp82 := checkDerefVar(var_glojure_DOT_core_list) + tmp83 := checkDerefVar(var_glojure_DOT_core_seq) + tmp84 := checkDerefVar(var_glojure_DOT_core_concat) + tmp85 := checkDerefVar(var_glojure_DOT_core_list) + tmp86 := lang.Apply(tmp85, []any{sym_glojure_DOT_core_SLASH_when}) + tmp87 := checkDerefVar(var_glojure_DOT_core_list) + tmp88 := checkDerefVar(var_glojure_DOT_core_seq) + tmp89 := checkDerefVar(var_glojure_DOT_core_concat) + tmp90 := checkDerefVar(var_glojure_DOT_core_list) + tmp91 := lang.Apply(tmp90, []any{sym_glojure_DOT_core_SLASH__LT_}) + tmp92 := checkDerefVar(var_glojure_DOT_core_list) + tmp93 := lang.Apply(tmp92, []any{v35}) + tmp94 := checkDerefVar(var_glojure_DOT_core_list) + tmp95 := lang.Apply(tmp94, []any{sym_n__0__auto__}) + tmp96 := lang.Apply(tmp89, []any{tmp91, tmp93, tmp95}) + tmp97 := lang.Apply(tmp88, []any{tmp96}) + tmp98 := lang.Apply(tmp87, []any{tmp97}) + tmp99 := checkDerefVar(var_glojure_DOT_core_list) + tmp100 := checkDerefVar(var_glojure_DOT_core_seq) + tmp101 := checkDerefVar(var_glojure_DOT_core_concat) + tmp102 := checkDerefVar(var_glojure_DOT_core_list) + tmp103 := lang.Apply(tmp102, []any{sym_recur}) + tmp104 := checkDerefVar(var_glojure_DOT_core_list) + tmp105 := checkDerefVar(var_glojure_DOT_core_seq) + tmp106 := checkDerefVar(var_glojure_DOT_core_concat) + tmp107 := checkDerefVar(var_glojure_DOT_core_list) + tmp108 := lang.Apply(tmp107, []any{sym_glojure_DOT_core_SLASH_unchecked_DASH_inc}) + tmp109 := checkDerefVar(var_glojure_DOT_core_list) + tmp110 := lang.Apply(tmp109, []any{v35}) + tmp111 := lang.Apply(tmp106, []any{tmp108, tmp110}) + tmp112 := lang.Apply(tmp105, []any{tmp111}) + tmp113 := lang.Apply(tmp104, []any{tmp112}) + tmp114 := lang.Apply(tmp101, []any{tmp103, tmp113}) + tmp115 := lang.Apply(tmp100, []any{tmp114}) + tmp116 := lang.Apply(tmp99, []any{tmp115}) + tmp117 := lang.Apply(tmp84, []any{tmp86, tmp98, v5, tmp116}) + tmp118 := lang.Apply(tmp83, []any{tmp117}) + tmp119 := lang.Apply(tmp82, []any{tmp118}) + tmp120 := lang.Apply(tmp66, []any{tmp68, tmp81, tmp119}) + tmp121 := lang.Apply(tmp65, []any{tmp120}) + tmp122 := lang.Apply(tmp64, []any{tmp121}) + tmp123 := lang.Apply(tmp40, []any{tmp42, tmp63, tmp122}) + tmp124 := lang.Apply(tmp39, []any{tmp123}) + tmp32 = tmp124 + } // end let + return tmp32 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_dotimes = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_dotimes.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // libspec? + // drop { - tmp0 := sym_libspec_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x is a libspec", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(8), kw_line, int(5848), kw_end_DASH_line, int(5848), kw_private, true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "or__0__auto__" - tmp5 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) - tmp6 := lang.Apply(tmp5, []any{v3}) - var v7 any = tmp6 - _ = v7 - var tmp8 any - if lang.IsTruthy(v7) { - tmp8 = v7 - } else { - var tmp9 any + tmp0 := sym_drop.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n), lang.NewVector(sym_n, sym_coll)), kw_doc, "Returns a laziness-preserving sequence of all but the first n items in coll.\n Returns a stateful transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(2901), kw_end_DASH_line, int(2901))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 any { // let - // let binding "and__0__auto__" - tmp10 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) - tmp11 := lang.Apply(tmp10, []any{v3}) - var v12 any = tmp11 - _ = v12 - var tmp13 any - if lang.IsTruthy(v12) { - var tmp14 any - { // let - // let binding "or__0__auto__" - tmp15 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) - tmp16 := checkDerefVar(var_glojure_DOT_core_second) - tmp17 := lang.Apply(tmp16, []any{v3}) - tmp18 := lang.Apply(tmp15, []any{tmp17}) - var v19 any = tmp18 - _ = v19 - var tmp20 any - if lang.IsTruthy(v19) { - tmp20 = v19 - } else { - tmp21 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) - tmp22 := checkDerefVar(var_glojure_DOT_core_second) - tmp23 := lang.Apply(tmp22, []any{v3}) - tmp24 := lang.Apply(tmp21, []any{tmp23}) - tmp20 = tmp24 - } - tmp14 = tmp20 - } // end let - tmp13 = tmp14 - } else { - tmp13 = v12 + // let binding "nv" + tmp6 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) + tmp7 := lang.Apply(tmp6, []any{v2}) + var v8 any = tmp7 + _ = v8 + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp10 := lang.Apply(v4, nil) + return tmp10 + case 1: + v10 := args[0] + _ = v10 + tmp11 := lang.Apply(v4, []any{v10}) + return tmp11 + case 2: + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + var tmp12 any + { // let + // let binding "n" + tmp13 := checkDerefVar(var_glojure_DOT_core_deref) + tmp14 := lang.Apply(tmp13, []any{v8}) + var v15 any = tmp14 + _ = v15 + tmp16 := checkDerefVar(var_glojure_DOT_core_dec) + tmp17, ok := lang.FieldOrMethod(v8, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "Deref"))) + } + var tmp18 any + switch reflect.TypeOf(tmp17).Kind() { + case reflect.Func: + tmp18 = lang.Apply(tmp17, nil) + default: + tmp18 = tmp17 + } + tmp19 := lang.Apply(tmp16, []any{tmp18}) + tmp20, _ := lang.FieldOrMethod(v8, "reset") + if reflect.TypeOf(tmp20).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) + } + tmp21 := lang.Apply(tmp20, []any{tmp19}) + _ = tmp21 + var tmp22 any + tmp23 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp24 := lang.Apply(tmp23, []any{v15}) + if lang.IsTruthy(tmp24) { + tmp22 = v10 + } else { + tmp25 := lang.Apply(v4, []any{v10, v11}) + tmp22 = tmp25 + } + tmp12 = tmp22 + } // end let + return tmp12 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2909), kw_column, int(10), kw_end_DASH_line, int(2917), kw_end_DASH_column, int(39)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) } - tmp9 = tmp13 + tmp5 = tmp11 } // end let - tmp8 = tmp9 + return tmp5 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2907), kw_column, int(6), kw_end_DASH_line, int(2917), kw_end_DASH_column, int(41)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) } - tmp4 = tmp8 - } // end let - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // lift-ns - { - tmp0 := sym_lift_DASH_ns.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m)), kw_doc, "Returns [lifted-ns lifted-kvs] or nil if m can't be lifted.", kw_file, "glojure/core_print.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(8), kw_line, int(261), kw_end_DASH_line, int(261), kw_private, true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_namespace_DASH_maps_STAR_) - if lang.IsTruthy(tmp5) { - var tmp6 any - { // let - // let binding "ns" - var v7 any = nil - _ = v7 - // let binding "G__221" - tmp8 := checkDerefVar(var_glojure_DOT_core_seq) - tmp9 := lang.Apply(tmp8, []any{v3}) - var v10 any = tmp9 - _ = v10 - // let binding "vec__222" - var v11 any = v10 - _ = v11 - // let binding "seq__223" - tmp12 := checkDerefVar(var_glojure_DOT_core_seq) - tmp13 := lang.Apply(tmp12, []any{v11}) - var v14 any = tmp13 - _ = v14 - // let binding "first__224" - tmp15 := checkDerefVar(var_glojure_DOT_core_first) - tmp16 := lang.Apply(tmp15, []any{v14}) - var v17 any = tmp16 - _ = v17 - // let binding "seq__223" - tmp18 := checkDerefVar(var_glojure_DOT_core_next) - tmp19 := lang.Apply(tmp18, []any{v14}) - var v20 any = tmp19 - _ = v20 - // let binding "vec__225" - var v21 any = v17 - _ = v21 - // let binding "k" - tmp22 := checkDerefVar(var_glojure_DOT_core_nth) - tmp23 := lang.Apply(tmp22, []any{v21, int64(0), nil}) - var v24 any = tmp23 - _ = v24 - // let binding "v" - tmp25 := checkDerefVar(var_glojure_DOT_core_nth) - tmp26 := lang.Apply(tmp25, []any{v21, int64(1), nil}) - var v27 any = tmp26 - _ = v27 - // let binding "entry" - var v28 any = v21 - _ = v28 - // let binding "entries" - var v29 any = v20 - _ = v29 - // let binding "kvs" - tmp30 := lang.NewVector() - tmp31 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(267), kw_column, int(16), kw_end_DASH_line, int(267), kw_end_DASH_column, int(17)) - tmp32, err := lang.WithMeta(tmp30, tmp31.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v33 any = tmp32 - _ = v33 - var tmp34 any + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp6 := reflect.TypeOf((*lang.IDrop)(nil)).Elem() + tmp7 := lang.Apply(tmp5, []any{tmp6, v3}) + if lang.IsTruthy(tmp7) { + var tmp8 any { // let - // let binding "ns" - var v35 any = v7 - _ = v35 - // let binding "G__221" - var v36 any = v10 - _ = v36 - // let binding "kvs" - var v37 any = v33 - _ = v37 - for { - var tmp38 any + // let binding "or__0__auto__" + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp11 := lang.Apply(tmp10, []any{v2}) + if lang.IsTruthy(tmp11) { + var tmp12 any + tmp13 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) + tmp14 := lang.Apply(tmp13, []any{v2}) + if lang.IsTruthy(tmp14) { + tmp12 = v2 + } else { + tmp15 := lang.Apply(nil, []any{v2}) + tmp12 = tmp15 + } + tmp16, _ := lang.FieldOrMethod(v3, "drop") + if reflect.TypeOf(tmp16).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("drop is not a function"))) + } + tmp17 := lang.Apply(tmp16, []any{tmp12}) + tmp9 = tmp17 + } else { + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := lang.Apply(tmp18, []any{v3}) + tmp9 = tmp19 + } + var v20 any = tmp9 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + tmp21 = v20 + } else { + tmp21 = lang.NewList() + } + tmp8 = tmp21 + } // end let + tmp4 = tmp8 + } else { + var tmp9 any + { // let + // let binding "step" + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + recur_loop_539: + var tmp13 any { // let - // let binding "ns" - var v39 any = v35 - _ = v39 - // let binding "vec__228" - var v40 any = v36 - _ = v40 - // let binding "seq__229" - tmp41 := checkDerefVar(var_glojure_DOT_core_seq) - tmp42 := lang.Apply(tmp41, []any{v40}) - var v43 any = tmp42 - _ = v43 - // let binding "first__230" - tmp44 := checkDerefVar(var_glojure_DOT_core_first) - tmp45 := lang.Apply(tmp44, []any{v43}) - var v46 any = tmp45 - _ = v46 - // let binding "seq__229" - tmp47 := checkDerefVar(var_glojure_DOT_core_next) - tmp48 := lang.Apply(tmp47, []any{v43}) - var v49 any = tmp48 - _ = v49 - // let binding "vec__231" - var v50 any = v46 - _ = v50 - // let binding "k" - tmp51 := checkDerefVar(var_glojure_DOT_core_nth) - tmp52 := lang.Apply(tmp51, []any{v50, int64(0), nil}) - var v53 any = tmp52 - _ = v53 - // let binding "v" - tmp54 := checkDerefVar(var_glojure_DOT_core_nth) - tmp55 := lang.Apply(tmp54, []any{v50, int64(1), nil}) - var v56 any = tmp55 - _ = v56 - // let binding "entry" - var v57 any = v50 - _ = v57 - // let binding "entries" - var v58 any = v49 - _ = v58 - // let binding "kvs" - var v59 any = v37 - _ = v59 - var tmp60 any - if lang.IsTruthy(v57) { - var tmp61 any - tmp62 := checkDerefVar(var_glojure_DOT_core_qualified_DASH_ident_QMARK_) - tmp63 := lang.Apply(tmp62, []any{v53}) - if lang.IsTruthy(tmp63) { - var tmp64 any - if lang.IsTruthy(v39) { - var tmp65 any - tmp66 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp67 := checkDerefVar(var_glojure_DOT_core_namespace) - tmp68 := lang.Apply(tmp67, []any{v53}) - tmp69 := lang.Apply(tmp66, []any{v39, tmp68}) - if lang.IsTruthy(tmp69) { - var tmp70 any = v39 - var tmp71 any = v58 - tmp73 := checkDerefVar(var_glojure_DOT_core_conj) - tmp74 := checkDerefVar(var_glojure_DOT_core_strip_DASH_ns) - tmp75 := lang.Apply(tmp74, []any{v53}) - tmp76 := lang.NewVector(tmp75, v56) - tmp77 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(272), kw_column, int(43), kw_end_DASH_line, int(272), kw_end_DASH_column, int(58)) - tmp78, err := lang.WithMeta(tmp76, tmp77.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp79 := lang.Apply(tmp73, []any{v59, tmp78}) - var tmp72 any = tmp79 - v35 = tmp70 - v36 = tmp71 - v37 = tmp72 - continue - } else { - } - tmp64 = tmp65 - } else { - var tmp80 any - { // let - // let binding "temp__0__auto__" - tmp81 := checkDerefVar(var_glojure_DOT_core_namespace) - tmp82 := lang.Apply(tmp81, []any{v53}) - var v83 any = tmp82 - _ = v83 - var tmp84 any - if lang.IsTruthy(v83) { - var tmp85 any - { // let - // let binding "new-ns" - var v86 any = v83 - _ = v86 - var tmp87 any = v86 - var tmp88 any = v58 - tmp90 := checkDerefVar(var_glojure_DOT_core_conj) - tmp91 := checkDerefVar(var_glojure_DOT_core_strip_DASH_ns) - tmp92 := lang.Apply(tmp91, []any{v53}) - tmp93 := lang.NewVector(tmp92, v56) - tmp94 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(274), kw_column, int(47), kw_end_DASH_line, int(274), kw_end_DASH_column, int(62)) - tmp95, err := lang.WithMeta(tmp93, tmp94.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp96 := lang.Apply(tmp90, []any{v59, tmp95}) - var tmp89 any = tmp96 - v35 = tmp87 - v36 = tmp88 - v37 = tmp89 - continue - } // end let - tmp84 = tmp85 - } else { - } - tmp80 = tmp84 - } // end let - tmp64 = tmp80 - } - tmp61 = tmp64 + // let binding "s" + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := lang.Apply(tmp14, []any{v12}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + var tmp18 any + { // let + // let binding "and__0__auto__" + tmp19 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp20 := lang.Apply(tmp19, []any{v11}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + if lang.IsTruthy(v21) { + tmp22 = v16 } else { + tmp22 = v21 } - tmp60 = tmp61 + tmp18 = tmp22 + } // end let + if lang.IsTruthy(tmp18) { + tmp20 := checkDerefVar(var_glojure_DOT_core_dec) + tmp21 := lang.Apply(tmp20, []any{v11}) + var tmp19 any = tmp21 + tmp23 := checkDerefVar(var_glojure_DOT_core_rest) + tmp24 := lang.Apply(tmp23, []any{v16}) + var tmp22 any = tmp24 + v11 = tmp19 + v12 = tmp22 + goto recur_loop_539 } else { - tmp81 := lang.NewVector(v39, v59) - tmp82 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(275), kw_column, int(9), kw_end_DASH_line, int(275), kw_end_DASH_column, int(16)) - tmp83, err := lang.WithMeta(tmp81, tmp82.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp60 = tmp83 + tmp17 = v16 } - tmp38 = tmp60 + tmp13 = tmp17 } // end let - tmp34 = tmp38 - break + return tmp13 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2925), kw_column, int(19), kw_end_DASH_line, int(2929), kw_end_DASH_column, int(28)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) } + var v13 any = tmp12 + _ = v13 + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp15 := lang.Apply(v13, []any{v2, v3}) + return tmp15 + }) + tmp15 := lang.Apply(lang.NewLazySeq, []any{tmp14}) + tmp9 = tmp15 } // end let - tmp6 = tmp34 - } // end let - tmp4 = tmp6 - } else { + tmp4 = tmp9 + } + return tmp4 + default: + checkArity(args, -1) + panic("unreachable") } - return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_drop = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_drop.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // line-seq + // elide-top-frames { - tmp0 := sym_line_DASH_seq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_rdr)), kw_doc, "Returns the lines of text from rdr as a lazy sequence of strings.\n rdr must implement java.io.BufferedReader.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(3068), kw_end_DASH_line, int(3068))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] + tmp0 := sym_elide_DASH_top_DASH_frames.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(4794), kw_column, int(7), kw_end_DASH_line, int(4794), kw_end_DASH_column, int(32), kw_arglists, lang.NewList(lang.NewVector(sym_ex, sym_class_DASH_name)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 var tmp4 any { // let - // let binding "temp__0__auto__" - tmp5, ok := lang.FieldOrMethod(v3, "readLine") + // let binding "tr" + tmp5, ok := lang.FieldOrMethod(v2, "getStackTrace") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "readLine"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getStackTrace"))) } var tmp6 any switch reflect.TypeOf(tmp5).Kind() { @@ -30306,3464 +23764,3425 @@ func LoadNS() { var v7 any = tmp6 _ = v7 var tmp8 any - if lang.IsTruthy(v7) { - var tmp9 any - { // let - // let binding "line" - var v10 any = v7 - _ = v10 - tmp11 := checkDerefVar(var_glojure_DOT_core_cons) - var tmp12 lang.FnFunc - tmp12 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - tmp13 := checkDerefVar(var_glojure_DOT_core_line_DASH_seq) - tmp14 := lang.Apply(tmp13, []any{v3}) - return tmp14 + { // let + // let binding "G__54" + var v9 any = v2 + _ = v9 + var tmp10 any + if lang.IsTruthy(v7) { + tmp11 := checkDerefVar(var_glojure_DOT_core_into_DASH_array) + tmp12 := checkDerefVar(var_glojure_DOT_core_drop_DASH_while) + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v14 := args[0] + _ = v14 + tmp15 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp16, ok := lang.FieldOrMethod(v14, "getClassName") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v14, "getClassName"))) + } + var tmp17 any + switch reflect.TypeOf(tmp16).Kind() { + case reflect.Func: + tmp17 = lang.Apply(tmp16, nil) + default: + tmp17 = tmp16 + } + tmp18 := lang.Apply(tmp15, []any{v3, tmp17}) + return tmp18 }) - tmp13 := lang.Apply(lang.NewLazySeq, []any{tmp12}) - tmp14 := lang.Apply(tmp11, []any{v10, tmp13}) - tmp9 = tmp14 - } // end let - tmp8 = tmp9 - } else { - } + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4801), kw_column, int(25), kw_end_DASH_line, int(4801), kw_end_DASH_column, int(77)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp16 := lang.Apply(tmp12, []any{tmp15, v7}) + tmp17 := lang.Apply(tmp11, []any{nil, tmp16}) + tmp10 = tmp17 + } else { + } + tmp18, _ := lang.FieldOrMethod(v9, "setStackTrace") + if reflect.TypeOf(tmp18).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setStackTrace is not a function"))) + } + tmp19 := lang.Apply(tmp18, []any{tmp10}) + _ = tmp19 + tmp8 = v9 + } // end let tmp4 = tmp8 } // end let return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_elide_DASH_top_DASH_frames = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_elide_DASH_top_DASH_frames.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // list + // empty? { - tmp0 := sym_list.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_items)), kw_doc, "Creates a new list containing the items.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(6), kw_column, int(2), kw_line, int(15), kw_end_DASH_line, int(18))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, lang.NewList, true) + tmp0 := sym_empty_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns true if coll has no items. To check the emptiness of a seq,\n please use the idiom (seq x) rather than (not (empty? x))", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(6247), kw_end_DASH_line, int(6247))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_counted_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + tmp6 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) + tmp7 := checkDerefVar(var_glojure_DOT_core_count) + tmp8 := lang.Apply(tmp7, []any{v2}) + tmp9 := lang.Apply(tmp6, []any{tmp8}) + tmp3 = tmp9 + } else { + tmp10 := checkDerefVar(var_glojure_DOT_core_not) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := lang.Apply(tmp11, []any{v2}) + tmp13 := lang.Apply(tmp10, []any{tmp12}) + tmp3 = tmp13 + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_empty_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_empty_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // list* + // ensure-reduced { - tmp0 := sym_list_STAR_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_args), lang.NewVector(sym_a, sym_args), lang.NewVector(sym_a, sym_b, sym_args), lang.NewVector(sym_a, sym_b, sym_c, sym_args), lang.NewVector(sym_a, sym_b, sym_c, sym_d, sym__AMP_, sym_more)), kw_doc, "Creates a new seq containing the items prepended to the rest, the\n last of which will be treated as a sequence.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(641), kw_end_DASH_line, int(641))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_seq) - tmp5 := lang.Apply(tmp4, []any{v3}) - return tmp5 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_cons) - tmp6 := lang.Apply(tmp5, []any{v3, v4}) - return tmp6 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6 := checkDerefVar(var_glojure_DOT_core_cons) - tmp7 := checkDerefVar(var_glojure_DOT_core_cons) - tmp8 := lang.Apply(tmp7, []any{v4, v5}) - tmp9 := lang.Apply(tmp6, []any{v3, tmp8}) - return tmp9 - case 4: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - tmp7 := checkDerefVar(var_glojure_DOT_core_cons) - tmp8 := checkDerefVar(var_glojure_DOT_core_cons) - tmp9 := checkDerefVar(var_glojure_DOT_core_cons) - tmp10 := lang.Apply(tmp9, []any{v5, v6}) - tmp11 := lang.Apply(tmp8, []any{v4, tmp10}) - tmp12 := lang.Apply(tmp7, []any{v3, tmp11}) - return tmp12 - default: - checkArity(args, 4) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - var v7 any = lang.NewList(args[4:]...) - _ = v7 - tmp8 := checkDerefVar(var_glojure_DOT_core_cons) - tmp9 := checkDerefVar(var_glojure_DOT_core_cons) - tmp10 := checkDerefVar(var_glojure_DOT_core_cons) - tmp11 := checkDerefVar(var_glojure_DOT_core_cons) - tmp12 := checkDerefVar(var_glojure_DOT_core_spread) - tmp13 := lang.Apply(tmp12, []any{v7}) - tmp14 := lang.Apply(tmp11, []any{v6, tmp13}) - tmp15 := lang.Apply(tmp10, []any{v5, tmp14}) - tmp16 := lang.Apply(tmp9, []any{v4, tmp15}) - tmp17 := lang.Apply(tmp8, []any{v3, tmp16}) - return tmp17 + tmp0 := sym_ensure_DASH_reduced.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "If x is already reduced?, returns it, else returns (reduced x)", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(2841), kw_end_DASH_line, int(2841))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + tmp3 = v2 + } else { + tmp6 := checkDerefVar(var_glojure_DOT_core_reduced) + tmp7 := lang.Apply(tmp6, []any{v2}) + tmp3 = tmp7 } + return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ensure_DASH_reduced = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_ensure_DASH_reduced.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // list? + // even? { - tmp0 := sym_list_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x implements IPersistentList", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(6198), kw_end_DASH_line, int(6198))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_even_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_doc, "Returns true if n is even, throws an exception if n is not an integer", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(1381), kw_end_DASH_line, int(1381))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp5 := reflect.TypeOf((*lang.IPersistentList)(nil)).Elem() - tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) - return tmp6 + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_integer_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + tmp6 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) + tmp7 := checkDerefVar(var_glojure_DOT_core_bit_DASH_and) + tmp8 := lang.Apply(lang.UncheckedLongCast, []any{v2}) + tmp9 := lang.Apply(tmp7, []any{tmp8, int64(1)}) + tmp10 := lang.Apply(tmp6, []any{tmp9}) + tmp3 = tmp10 + } else { + tmp11 := checkDerefVar(var_glojure_DOT_core_str) + tmp12 := lang.Apply(tmp11, []any{"Argument must be an integer: ", v2}) + tmp13 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp12}) + panic(tmp13) + } + return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_even_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_even_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // load + // every-pred { - tmp0 := sym_load.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_paths)), kw_doc, "Loads Clojure code from resources in classpath. A path is interpreted as\n classpath-relative if it begins with a slash or relative to the root\n directory for the current namespace otherwise.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_redef, true, kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(6095), kw_end_DASH_line, int(6095))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_every_DASH_pred.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_p), lang.NewVector(sym_p1, sym_p2), lang.NewVector(sym_p1, sym_p2, sym_p3), lang.NewVector(sym_p1, sym_p2, sym_p3, sym__AMP_, sym_ps)), kw_doc, "Takes a set of predicates and returns a function f that returns true if all of its\n composing predicates return a logical true value against all of its arguments, else it returns\n false. Note that f is short-circuiting in that it will stop execution on the first\n argument that triggers a logical false result against the original predicates.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(7422), kw_end_DASH_line, int(7422))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - default: - checkArity(args, 0) - var v3 any = lang.NewList(args[0:]...) - _ = v3 - var tmp4 any - { // let - // let binding "seq_133" - tmp5 := checkDerefVar(var_glojure_DOT_core_seq) - tmp6 := lang.Apply(tmp5, []any{v3}) - var v7 any = tmp6 - _ = v7 - // let binding "chunk_134" - var v8 any = nil - _ = v8 - // let binding "count_135" - var v9 any = int64(0) - _ = v9 - // let binding "i_136" - var v10 any = int64(0) - _ = v10 - for { - var tmp11 any - tmp12 := checkDerefVar(var_glojure_DOT_core__LT_) - tmp13 := lang.Apply(tmp12, []any{v10, v9}) - if lang.IsTruthy(tmp13) { - var tmp14 any + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + { // function ep1 + var v4 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return true + case 1: + v5 := args[0] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_boolean) + tmp7 := lang.Apply(v2, []any{v5}) + tmp8 := lang.Apply(tmp6, []any{tmp7}) + return tmp8 + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp8 any { // let - // let binding "path" - tmp15, _ := lang.FieldOrMethod(v8, "nth") - if reflect.TypeOf(tmp15).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + // let binding "and__0__auto__" + tmp9 := lang.Apply(v2, []any{v5}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + if lang.IsTruthy(v10) { + tmp12 := lang.Apply(v2, []any{v6}) + tmp11 = tmp12 + } else { + tmp11 = v10 } - tmp16 := lang.Apply(tmp15, []any{v10}) - var v17 any = tmp16 - _ = v17 - var tmp18 any - { // let - // let binding "path" - var tmp19 any - tmp20 := lang.Apply(strings11.HasPrefix, []any{v17, "/"}) - if lang.IsTruthy(tmp20) { - tmp19 = v17 - } else { - tmp21 := checkDerefVar(var_glojure_DOT_core_str) - tmp22 := checkDerefVar(var_glojure_DOT_core_root_DASH_directory) - tmp23 := checkDerefVar(var_glojure_DOT_core_ns_DASH_name) - tmp24 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) - tmp25 := lang.Apply(tmp23, []any{tmp24}) - tmp26 := lang.Apply(tmp22, []any{tmp25}) - tmp27 := lang.Apply(tmp21, []any{tmp26, lang.NewChar(47), v17}) - tmp19 = tmp27 - } - var v28 any = tmp19 - _ = v28 - var tmp29 any - tmp30 := checkDerefVar(var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_) - if lang.IsTruthy(tmp30) { - tmp31 := checkDerefVar(var_glojure_DOT_core_printf) - tmp32 := lang.Apply(tmp31, []any{"(glojure.core/load \"%s\")\n", v28}) - _ = tmp32 - tmp33 := checkDerefVar(var_glojure_DOT_core_flush) - tmp34 := lang.Apply(tmp33, nil) - tmp29 = tmp34 - } else { - } - _ = tmp29 - tmp35 := checkDerefVar(var_glojure_DOT_core_check_DASH_cyclic_DASH_dependency) - tmp36 := lang.Apply(tmp35, []any{v28}) - _ = tmp36 - var tmp37 any - tmp38 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp39 := checkDerefVar(var_glojure_DOT_core_first) - tmp40 := checkDerefVar(var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_) - tmp41 := lang.Apply(tmp39, []any{tmp40}) - tmp42 := lang.Apply(tmp38, []any{v28, tmp41}) - if lang.IsTruthy(tmp42) { - } else { - var tmp43 any - { // let - tmp44 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) - tmp45 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) - tmp46 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_pending_DASH_paths_STAR_) - tmp47 := checkDerefVar(var_glojure_DOT_core_conj) - tmp48 := checkDerefVar(var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_) - tmp49 := lang.Apply(tmp47, []any{tmp48, v28}) - tmp50 := lang.Apply(tmp45, []any{tmp46, tmp49}) - tmp51 := lang.Apply(tmp44, []any{tmp50}) - _ = tmp51 - var tmp52 any - func() { - defer func() { - tmp53 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) - tmp54 := lang.Apply(tmp53, nil) - _ = tmp54 - }() - tmp55 := lang.Apply(strings11.TrimPrefix, []any{v28, "/"}) - tmp56, _ := lang.FieldOrMethod(runtime.RT, "Load") - if reflect.TypeOf(tmp56).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Load is not a function"))) - } - tmp57 := lang.Apply(tmp56, []any{tmp55}) - tmp52 = tmp57 - }() - tmp43 = tmp52 - } // end let - tmp37 = tmp43 - } - tmp18 = tmp37 - } // end let - _ = tmp18 - var tmp19 any = v7 - var tmp20 any = v8 - var tmp21 any = v9 - tmp23 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) - tmp24 := lang.Apply(tmp23, []any{v10}) - var tmp22 any = tmp24 - v7 = tmp19 - v8 = tmp20 - v9 = tmp21 - v10 = tmp22 - continue + tmp8 = tmp11 } // end let - tmp11 = tmp14 - } else { - var tmp15 any + tmp9 := lang.Apply(tmp7, []any{tmp8}) + return tmp9 + case 3: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := args[2] + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp9 any { // let - // let binding "temp__0__auto__" - tmp16 := checkDerefVar(var_glojure_DOT_core_seq) - tmp17 := lang.Apply(tmp16, []any{v7}) - var v18 any = tmp17 - _ = v18 - var tmp19 any - if lang.IsTruthy(v18) { - var tmp20 any + // let binding "and__0__auto__" + tmp10 := lang.Apply(v2, []any{v5}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + var tmp13 any { // let - // let binding "seq_133" - var v21 any = v18 - _ = v21 - var tmp22 any - tmp23 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) - tmp24 := lang.Apply(tmp23, []any{v21}) - if lang.IsTruthy(tmp24) { - var tmp25 any - { // let - // let binding "c__0__auto__" - tmp26 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) - tmp27 := lang.Apply(tmp26, []any{v21}) - var v28 any = tmp27 - _ = v28 - tmp30 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) - tmp31 := lang.Apply(tmp30, []any{v21}) - var tmp29 any = tmp31 - var tmp32 any = v28 - tmp34 := checkDerefVar(var_glojure_DOT_core_int) - tmp35 := checkDerefVar(var_glojure_DOT_core_count) - tmp36 := lang.Apply(tmp35, []any{v28}) - tmp37 := lang.Apply(tmp34, []any{tmp36}) - var tmp33 any = tmp37 - tmp39 := checkDerefVar(var_glojure_DOT_core_int) - tmp40 := lang.Apply(tmp39, []any{int64(0)}) - var tmp38 any = tmp40 - v7 = tmp29 - v8 = tmp32 - v9 = tmp33 - v10 = tmp38 - continue - } // end let - tmp22 = tmp25 + // let binding "and__0__auto__" + tmp14 := lang.Apply(v2, []any{v6}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + if lang.IsTruthy(v15) { + tmp17 := lang.Apply(v2, []any{v7}) + tmp16 = tmp17 } else { - var tmp26 any - { // let - // let binding "path" - tmp27 := checkDerefVar(var_glojure_DOT_core_first) - tmp28 := lang.Apply(tmp27, []any{v21}) - var v29 any = tmp28 - _ = v29 - var tmp30 any - { // let - // let binding "path" - var tmp31 any - tmp32 := lang.Apply(strings11.HasPrefix, []any{v29, "/"}) - if lang.IsTruthy(tmp32) { - tmp31 = v29 - } else { - tmp33 := checkDerefVar(var_glojure_DOT_core_str) - tmp34 := checkDerefVar(var_glojure_DOT_core_root_DASH_directory) - tmp35 := checkDerefVar(var_glojure_DOT_core_ns_DASH_name) - tmp36 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) - tmp37 := lang.Apply(tmp35, []any{tmp36}) - tmp38 := lang.Apply(tmp34, []any{tmp37}) - tmp39 := lang.Apply(tmp33, []any{tmp38, lang.NewChar(47), v29}) - tmp31 = tmp39 - } - var v40 any = tmp31 - _ = v40 - var tmp41 any - tmp42 := checkDerefVar(var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_) - if lang.IsTruthy(tmp42) { - tmp43 := checkDerefVar(var_glojure_DOT_core_printf) - tmp44 := lang.Apply(tmp43, []any{"(glojure.core/load \"%s\")\n", v40}) - _ = tmp44 - tmp45 := checkDerefVar(var_glojure_DOT_core_flush) - tmp46 := lang.Apply(tmp45, nil) - tmp41 = tmp46 - } else { - } - _ = tmp41 - tmp47 := checkDerefVar(var_glojure_DOT_core_check_DASH_cyclic_DASH_dependency) - tmp48 := lang.Apply(tmp47, []any{v40}) - _ = tmp48 - var tmp49 any - tmp50 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp51 := checkDerefVar(var_glojure_DOT_core_first) - tmp52 := checkDerefVar(var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_) - tmp53 := lang.Apply(tmp51, []any{tmp52}) - tmp54 := lang.Apply(tmp50, []any{v40, tmp53}) - if lang.IsTruthy(tmp54) { - } else { - var tmp55 any - { // let - tmp56 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) - tmp57 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) - tmp58 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_pending_DASH_paths_STAR_) - tmp59 := checkDerefVar(var_glojure_DOT_core_conj) - tmp60 := checkDerefVar(var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_) - tmp61 := lang.Apply(tmp59, []any{tmp60, v40}) - tmp62 := lang.Apply(tmp57, []any{tmp58, tmp61}) - tmp63 := lang.Apply(tmp56, []any{tmp62}) - _ = tmp63 - var tmp64 any - func() { - defer func() { - tmp65 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) - tmp66 := lang.Apply(tmp65, nil) - _ = tmp66 - }() - tmp67 := lang.Apply(strings11.TrimPrefix, []any{v40, "/"}) - tmp68, _ := lang.FieldOrMethod(runtime.RT, "Load") - if reflect.TypeOf(tmp68).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Load is not a function"))) - } - tmp69 := lang.Apply(tmp68, []any{tmp67}) - tmp64 = tmp69 - }() - tmp55 = tmp64 - } // end let - tmp49 = tmp55 - } - tmp30 = tmp49 - } // end let - _ = tmp30 - tmp32 := checkDerefVar(var_glojure_DOT_core_next) - tmp33 := lang.Apply(tmp32, []any{v21}) - var tmp31 any = tmp33 - var tmp34 any = nil - var tmp35 any = int64(0) - var tmp36 any = int64(0) - v7 = tmp31 - v8 = tmp34 - v9 = tmp35 - v10 = tmp36 - continue - } // end let - tmp22 = tmp26 + tmp16 = v15 } - tmp20 = tmp22 + tmp13 = tmp16 } // end let - tmp19 = tmp20 + tmp12 = tmp13 } else { + tmp12 = v11 } - tmp15 = tmp19 + tmp9 = tmp12 } // end let - tmp11 = tmp15 + tmp10 := lang.Apply(tmp8, []any{tmp9}) + return tmp10 + default: + checkArity(args, 3) + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := args[2] + _ = v7 + var v8 any = lang.NewList(args[3:]...) + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp10 any + { // let + // let binding "and__0__auto__" + tmp11 := lang.Apply(v4, []any{v5, v6, v7}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + tmp14 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + tmp15 := lang.Apply(tmp14, []any{v2, v8}) + tmp13 = tmp15 + } else { + tmp13 = v12 + } + tmp10 = tmp13 + } // end let + tmp11 := lang.Apply(tmp9, []any{tmp10}) + return tmp11 } - tmp4 = tmp11 - break - } - } // end let - return tmp4 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // load-all - { - tmp0 := sym_load_DASH_all.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_lib, sym_need_DASH_ns, sym_require)), kw_doc, "Loads a lib given its name and forces a load of any libs it directly or\n indirectly loads. If need-ns, ensures that the associated namespace\n exists after loading. If require, records the load so any duplicate loads\n can be skipped.", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(8), kw_line, int(5892), kw_end_DASH_line, int(5892), kw_private, true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 3) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var tmp6 lang.FnFunc - tmp6 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - tmp7 := checkDerefVar(var_glojure_DOT_core_commute) - tmp8 := checkDerefVar(var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_) - var tmp9 lang.FnFunc - tmp9 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v10 := args[0] - _ = v10 - v11 := args[1] - _ = v11 - tmp12 := checkDerefVar(var_glojure_DOT_core_reduce1) - tmp13 := checkDerefVar(var_glojure_DOT_core_conj) - tmp14 := lang.Apply(tmp12, []any{tmp13, v10, v11}) - return tmp14 - }) - tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5899), kw_column, int(27), kw_end_DASH_line, int(5899), kw_end_DASH_column, int(47)) - tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + }) + v4 = tmp3 + _ = v4 + } + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7429), kw_column, int(6), kw_end_DASH_line, int(7435), kw_end_DASH_column, int(56)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) if err != nil { panic(err) } - var tmp12 any - { // let - tmp13 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) - tmp14 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) - tmp15 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_loaded_DASH_libs_STAR_) - tmp16 := checkDerefVar(var_glojure_DOT_core_ref) - tmp17 := checkDerefVar(var_glojure_DOT_core_sorted_DASH_set) - tmp18 := lang.Apply(tmp17, nil) - tmp19 := lang.Apply(tmp16, []any{tmp18}) - tmp20 := lang.Apply(tmp14, []any{tmp15, tmp19}) - tmp21 := lang.Apply(tmp13, []any{tmp20}) - _ = tmp21 - var tmp22 any - func() { - defer func() { - tmp23 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) - tmp24 := lang.Apply(tmp23, nil) - _ = tmp24 - }() - tmp25 := checkDerefVar(var_glojure_DOT_core_load_DASH_one) - tmp26 := lang.Apply(tmp25, []any{v3, v4, v5}) - _ = tmp26 - tmp27 := checkDerefVar(var_glojure_DOT_core_deref) - tmp28 := checkDerefVar(var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_) - tmp29 := lang.Apply(tmp27, []any{tmp28}) - tmp22 = tmp29 - }() - tmp12 = tmp22 - } // end let - tmp13 := lang.Apply(tmp7, []any{tmp8, tmp11, tmp12}) - return tmp13 - }) - tmp7, _ := lang.FieldOrMethod(lang.LockingTransaction, "RunInTransaction") - if reflect.TypeOf(tmp7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("RunInTransaction is not a function"))) - } - tmp8 := lang.Apply(tmp7, []any{tmp6}) - return tmp8 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // load-data-reader-file - { - tmp0 := sym_load_DASH_data_DASH_reader_DASH_file.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7836), kw_column, int(8), kw_end_DASH_line, int(7836), kw_end_DASH_column, int(28), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_mappings, sym_url)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - { // let - // let binding "rdr" - tmp6, ok := lang.FieldOrMethod(v4, "openStream") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "openStream"))) - } - var tmp7 any - switch reflect.TypeOf(tmp6).Kind() { - case reflect.Func: - tmp7 = lang.Apply(tmp6, nil) - default: - tmp7 = tmp6 - } - tmp8 := lang.Apply(nil, []any{tmp7, "UTF-8"}) - tmp9 := lang.Apply(nil, []any{tmp8}) - var v10 any = tmp9 - _ = v10 - var tmp11 any - func() { - defer func() { - tmp12, ok := lang.FieldOrMethod(v10, "close") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v10, "close"))) - } - var tmp13 any - switch reflect.TypeOf(tmp12).Kind() { - case reflect.Func: - tmp13 = lang.Apply(tmp12, nil) - default: - tmp13 = tmp12 - } - _ = tmp13 - }() - var tmp14 any - { // let - tmp15 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) - tmp16 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) - tmp17 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_file_STAR_) - tmp18, ok := lang.FieldOrMethod(v4, "getFile") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "getFile"))) - } - var tmp19 any - switch reflect.TypeOf(tmp18).Kind() { - case reflect.Func: - tmp19 = lang.Apply(tmp18, nil) - default: - tmp19 = tmp18 - } - tmp20 := lang.Apply(tmp16, []any{tmp17, tmp19}) - tmp21 := lang.Apply(tmp15, []any{tmp20}) - _ = tmp21 - var tmp22 any - func() { - defer func() { - tmp23 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) - tmp24 := lang.Apply(tmp23, nil) - _ = tmp24 - }() - var tmp25 any + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + { // function ep2 + var v5 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return true + case 1: + v6 := args[0] + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp8 any { // let - // let binding "read-opts" - var tmp26 any - tmp27, ok := lang.FieldOrMethod(v4, "getPath") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "getPath"))) + // let binding "and__0__auto__" + tmp9 := lang.Apply(v2, []any{v6}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + if lang.IsTruthy(v10) { + tmp12 := lang.Apply(v3, []any{v6}) + tmp11 = tmp12 + } else { + tmp11 = v10 } - var tmp28 any - switch reflect.TypeOf(tmp27).Kind() { - case reflect.Func: - tmp28 = lang.Apply(tmp27, nil) - default: - tmp28 = tmp27 + tmp8 = tmp11 + } // end let + tmp9 := lang.Apply(tmp7, []any{tmp8}) + return tmp9 + case 2: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp9 any + { // let + // let binding "and__0__auto__" + tmp10 := lang.Apply(v2, []any{v6}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + var tmp13 any + { // let + // let binding "and__0__auto__" + tmp14 := lang.Apply(v2, []any{v7}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + if lang.IsTruthy(v15) { + var tmp17 any + { // let + // let binding "and__0__auto__" + tmp18 := lang.Apply(v3, []any{v6}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + tmp21 := lang.Apply(v3, []any{v7}) + tmp20 = tmp21 + } else { + tmp20 = v19 + } + tmp17 = tmp20 + } // end let + tmp16 = tmp17 + } else { + tmp16 = v15 + } + tmp13 = tmp16 + } // end let + tmp12 = tmp13 + } else { + tmp12 = v11 } - tmp29, _ := lang.FieldOrMethod(tmp28, "endsWith") - if reflect.TypeOf(tmp29).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("endsWith is not a function"))) + tmp9 = tmp12 + } // end let + tmp10 := lang.Apply(tmp8, []any{tmp9}) + return tmp10 + case 3: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp10 any + { // let + // let binding "and__0__auto__" + tmp11 := lang.Apply(v2, []any{v6}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + var tmp14 any + { // let + // let binding "and__0__auto__" + tmp15 := lang.Apply(v2, []any{v7}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + if lang.IsTruthy(v16) { + var tmp18 any + { // let + // let binding "and__0__auto__" + tmp19 := lang.Apply(v2, []any{v8}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + var tmp22 any + { // let + // let binding "and__0__auto__" + tmp23 := lang.Apply(v3, []any{v6}) + var v24 any = tmp23 + _ = v24 + var tmp25 any + if lang.IsTruthy(v24) { + var tmp26 any + { // let + // let binding "and__0__auto__" + tmp27 := lang.Apply(v3, []any{v7}) + var v28 any = tmp27 + _ = v28 + var tmp29 any + if lang.IsTruthy(v28) { + tmp30 := lang.Apply(v3, []any{v8}) + tmp29 = tmp30 + } else { + tmp29 = v28 + } + tmp26 = tmp29 + } // end let + tmp25 = tmp26 + } else { + tmp25 = v24 + } + tmp22 = tmp25 + } // end let + tmp21 = tmp22 + } else { + tmp21 = v20 + } + tmp18 = tmp21 + } // end let + tmp17 = tmp18 + } else { + tmp17 = v16 + } + tmp14 = tmp17 + } // end let + tmp13 = tmp14 + } else { + tmp13 = v12 } - tmp30 := lang.Apply(tmp29, []any{"cljc"}) - if lang.IsTruthy(tmp30) { - tmp31 := lang.NewMap(kw_eof, nil, kw_read_DASH_cond, kw_allow) - tmp32 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7842), kw_column, int(25), kw_end_DASH_line, int(7842), kw_end_DASH_column, int(52)) - tmp33, err := lang.WithMeta(tmp31, tmp32.(lang.IPersistentMap)) + tmp10 = tmp13 + } // end let + tmp11 := lang.Apply(tmp9, []any{tmp10}) + return tmp11 + default: + checkArity(args, 3) + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + var v9 any = lang.NewList(args[3:]...) + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp11 any + { // let + // let binding "and__0__auto__" + tmp12 := lang.Apply(v5, []any{v6, v7, v8}) + var v13 any = tmp12 + _ = v13 + var tmp14 any + if lang.IsTruthy(v13) { + tmp15 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + var tmp16 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v17 := args[0] + _ = v17 + var tmp18 any + { // let + // let binding "and__0__auto__" + tmp19 := lang.Apply(v2, []any{v17}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + tmp22 := lang.Apply(v3, []any{v17}) + tmp21 = tmp22 + } else { + tmp21 = v20 + } + tmp18 = tmp21 + } // end let + return tmp18 + }) + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7443), kw_column, int(46), kw_end_DASH_line, int(7443), kw_end_DASH_column, int(65)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp26 = tmp33 + tmp19 := lang.Apply(tmp15, []any{tmp18, v9}) + tmp14 = tmp19 } else { - tmp34 := lang.NewMap(kw_eof, nil) - tmp35 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7843), kw_column, int(25), kw_end_DASH_line, int(7843), kw_end_DASH_column, int(34)) - tmp36, err := lang.WithMeta(tmp34, tmp35.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp26 = tmp36 + tmp14 = v13 } - var v37 any = tmp26 - _ = v37 - // let binding "new-mappings" - tmp38 := checkDerefVar(var_glojure_DOT_core_read) - tmp39 := lang.Apply(tmp38, []any{v37, v10}) - var v40 any = tmp39 - _ = v40 - var tmp41 any - tmp42 := checkDerefVar(var_glojure_DOT_core_not) - tmp43 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) - tmp44 := lang.Apply(tmp43, []any{v40}) - tmp45 := lang.Apply(tmp42, []any{tmp44}) - if lang.IsTruthy(tmp45) { - tmp46 := checkDerefVar(var_glojure_DOT_core_ex_DASH_info) - tmp47 := checkDerefVar(var_glojure_DOT_core_str) - tmp48 := lang.Apply(tmp47, []any{"Not a valid data-reader map"}) - tmp49 := lang.NewMap(kw_url, v4) - tmp50 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7847), kw_column, int(27), kw_end_DASH_line, int(7847), kw_end_DASH_column, int(36)) - tmp51, err := lang.WithMeta(tmp49, tmp50.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp52 := lang.Apply(tmp46, []any{tmp48, tmp51}) - panic(tmp52) + tmp11 = tmp14 + } // end let + tmp12 := lang.Apply(tmp10, []any{tmp11}) + return tmp12 + } + }) + v5 = tmp4 + _ = v5 + } + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7437), kw_column, int(6), kw_end_DASH_line, int(7443), kw_end_DASH_column, int(75)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 lang.FnFunc + { // function ep3 + var v6 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return true + case 1: + v7 := args[0] + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp9 any + { // let + // let binding "and__0__auto__" + tmp10 := lang.Apply(v2, []any{v7}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + var tmp13 any + { // let + // let binding "and__0__auto__" + tmp14 := lang.Apply(v3, []any{v7}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + if lang.IsTruthy(v15) { + tmp17 := lang.Apply(v4, []any{v7}) + tmp16 = tmp17 + } else { + tmp16 = v15 + } + tmp13 = tmp16 + } // end let + tmp12 = tmp13 } else { + tmp12 = v11 } - _ = tmp41 - tmp53 := checkDerefVar(var_glojure_DOT_core_reduce) - var tmp54 lang.FnFunc - tmp54 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v55 := args[0] - _ = v55 - v56 := args[1] - _ = v56 - var tmp57 any + tmp9 = tmp12 + } // end let + tmp10 := lang.Apply(tmp8, []any{tmp9}) + return tmp10 + case 2: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp10 any + { // let + // let binding "and__0__auto__" + tmp11 := lang.Apply(v2, []any{v7}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + var tmp14 any { // let - // let binding "vec__359" - var v58 any = v56 - _ = v58 - // let binding "k" - tmp59 := checkDerefVar(var_glojure_DOT_core_nth) - tmp60 := lang.Apply(tmp59, []any{v58, int64(0), nil}) - var v61 any = tmp60 - _ = v61 - // let binding "v" - tmp62 := checkDerefVar(var_glojure_DOT_core_nth) - tmp63 := lang.Apply(tmp62, []any{v58, int64(1), nil}) - var v64 any = tmp63 - _ = v64 - var tmp65 any - tmp66 := checkDerefVar(var_glojure_DOT_core_not) - tmp67 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) - tmp68 := lang.Apply(tmp67, []any{v61}) - tmp69 := lang.Apply(tmp66, []any{tmp68}) - if lang.IsTruthy(tmp69) { - tmp70 := checkDerefVar(var_glojure_DOT_core_ex_DASH_info) - tmp71 := checkDerefVar(var_glojure_DOT_core_str) - tmp72 := lang.Apply(tmp71, []any{"Invalid form in data-reader file"}) - tmp73 := lang.NewMap(kw_url, v4, kw_form, v61) - tmp74 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7852), kw_column, int(30), kw_end_DASH_line, int(7853), kw_end_DASH_column, int(38)) - tmp75, err := lang.WithMeta(tmp73, tmp74.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp76 := lang.Apply(tmp70, []any{tmp72, tmp75}) - panic(tmp76) + // let binding "and__0__auto__" + tmp15 := lang.Apply(v2, []any{v8}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + if lang.IsTruthy(v16) { + var tmp18 any + { // let + // let binding "and__0__auto__" + tmp19 := lang.Apply(v3, []any{v7}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + var tmp22 any + { // let + // let binding "and__0__auto__" + tmp23 := lang.Apply(v3, []any{v8}) + var v24 any = tmp23 + _ = v24 + var tmp25 any + if lang.IsTruthy(v24) { + var tmp26 any + { // let + // let binding "and__0__auto__" + tmp27 := lang.Apply(v4, []any{v7}) + var v28 any = tmp27 + _ = v28 + var tmp29 any + if lang.IsTruthy(v28) { + tmp30 := lang.Apply(v4, []any{v8}) + tmp29 = tmp30 + } else { + tmp29 = v28 + } + tmp26 = tmp29 + } // end let + tmp25 = tmp26 + } else { + tmp25 = v24 + } + tmp22 = tmp25 + } // end let + tmp21 = tmp22 + } else { + tmp21 = v20 + } + tmp18 = tmp21 + } // end let + tmp17 = tmp18 } else { + tmp17 = v16 } - _ = tmp65 - var tmp77 any - { // let - // let binding "v-var" - tmp78 := checkDerefVar(var_glojure_DOT_core_data_DASH_reader_DASH_var) - tmp79 := lang.Apply(tmp78, []any{v64}) - var v80 any = tmp79 - _ = v80 - var tmp81 any - var tmp82 any + tmp14 = tmp17 + } // end let + tmp13 = tmp14 + } else { + tmp13 = v12 + } + tmp10 = tmp13 + } // end let + tmp11 := lang.Apply(tmp9, []any{tmp10}) + return tmp11 + case 3: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp11 any + { // let + // let binding "and__0__auto__" + tmp12 := lang.Apply(v2, []any{v7}) + var v13 any = tmp12 + _ = v13 + var tmp14 any + if lang.IsTruthy(v13) { + var tmp15 any + { // let + // let binding "and__0__auto__" + tmp16 := lang.Apply(v2, []any{v8}) + var v17 any = tmp16 + _ = v17 + var tmp18 any + if lang.IsTruthy(v17) { + var tmp19 any { // let // let binding "and__0__auto__" - tmp83 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) - tmp84 := lang.Apply(tmp83, []any{v3, v61}) - var v85 any = tmp84 - _ = v85 - var tmp86 any - if lang.IsTruthy(v85) { - tmp87 := checkDerefVar(var_glojure_DOT_core_not_EQ_) - tmp88 := lang.Apply(v3, []any{v61}) - tmp89 := lang.Apply(tmp87, []any{tmp88, v80}) - tmp86 = tmp89 + tmp20 := lang.Apply(v2, []any{v9}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + if lang.IsTruthy(v21) { + var tmp23 any + { // let + // let binding "and__0__auto__" + tmp24 := lang.Apply(v3, []any{v7}) + var v25 any = tmp24 + _ = v25 + var tmp26 any + if lang.IsTruthy(v25) { + var tmp27 any + { // let + // let binding "and__0__auto__" + tmp28 := lang.Apply(v3, []any{v8}) + var v29 any = tmp28 + _ = v29 + var tmp30 any + if lang.IsTruthy(v29) { + var tmp31 any + { // let + // let binding "and__0__auto__" + tmp32 := lang.Apply(v3, []any{v9}) + var v33 any = tmp32 + _ = v33 + var tmp34 any + if lang.IsTruthy(v33) { + var tmp35 any + { // let + // let binding "and__0__auto__" + tmp36 := lang.Apply(v4, []any{v7}) + var v37 any = tmp36 + _ = v37 + var tmp38 any + if lang.IsTruthy(v37) { + var tmp39 any + { // let + // let binding "and__0__auto__" + tmp40 := lang.Apply(v4, []any{v8}) + var v41 any = tmp40 + _ = v41 + var tmp42 any + if lang.IsTruthy(v41) { + tmp43 := lang.Apply(v4, []any{v9}) + tmp42 = tmp43 + } else { + tmp42 = v41 + } + tmp39 = tmp42 + } // end let + tmp38 = tmp39 + } else { + tmp38 = v37 + } + tmp35 = tmp38 + } // end let + tmp34 = tmp35 + } else { + tmp34 = v33 + } + tmp31 = tmp34 + } // end let + tmp30 = tmp31 + } else { + tmp30 = v29 + } + tmp27 = tmp30 + } // end let + tmp26 = tmp27 + } else { + tmp26 = v25 + } + tmp23 = tmp26 + } // end let + tmp22 = tmp23 } else { - tmp86 = v85 + tmp22 = v21 } - tmp82 = tmp86 + tmp19 = tmp22 } // end let - if lang.IsTruthy(tmp82) { - tmp83 := checkDerefVar(var_glojure_DOT_core_ex_DASH_info) - tmp84 := lang.NewMap(kw_url, v4, kw_conflict, v61, kw_mappings, v55) - tmp85 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7858), kw_column, int(32), kw_end_DASH_line, int(7860), kw_end_DASH_column, int(44)) - tmp86, err := lang.WithMeta(tmp84, tmp85.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp87 := lang.Apply(tmp83, []any{"Conflicting data-reader mapping", tmp86}) - panic(tmp87) + tmp18 = tmp19 + } else { + tmp18 = v17 + } + tmp15 = tmp18 + } // end let + tmp14 = tmp15 + } else { + tmp14 = v13 + } + tmp11 = tmp14 + } // end let + tmp12 := lang.Apply(tmp10, []any{tmp11}) + return tmp12 + default: + checkArity(args, 3) + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + var v10 any = lang.NewList(args[3:]...) + _ = v10 + tmp11 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp12 any + { // let + // let binding "and__0__auto__" + tmp13 := lang.Apply(v6, []any{v7, v8, v9}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + tmp16 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + var tmp17 lang.FnFunc + tmp17 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v18 := args[0] + _ = v18 + var tmp19 any + { // let + // let binding "and__0__auto__" + tmp20 := lang.Apply(v2, []any{v18}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + if lang.IsTruthy(v21) { + var tmp23 any + { // let + // let binding "and__0__auto__" + tmp24 := lang.Apply(v3, []any{v18}) + var v25 any = tmp24 + _ = v25 + var tmp26 any + if lang.IsTruthy(v25) { + tmp27 := lang.Apply(v4, []any{v18}) + tmp26 = tmp27 + } else { + tmp26 = v25 + } + tmp23 = tmp26 + } // end let + tmp22 = tmp23 } else { + tmp22 = v21 } - _ = tmp81 - tmp88 := checkDerefVar(var_glojure_DOT_core_assoc) - tmp89 := lang.Apply(tmp88, []any{v55, v61, v80}) - tmp77 = tmp89 + tmp19 = tmp22 } // end let - tmp57 = tmp77 - } // end let - return tmp57 - }) - tmp55 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7849), kw_column, int(10), kw_end_DASH_line, int(7861), kw_end_DASH_column, int(32)) - tmp56, err := lang.WithMeta(tmp54, tmp55.(lang.IPersistentMap)) - if err != nil { - panic(err) + return tmp19 + }) + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7451), kw_column, int(46), kw_end_DASH_line, int(7451), kw_end_DASH_column, int(72)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp20 := lang.Apply(tmp16, []any{tmp19, v10}) + tmp15 = tmp20 + } else { + tmp15 = v14 } - tmp57 := lang.Apply(tmp53, []any{tmp56, v3, v40}) - tmp25 = tmp57 + tmp12 = tmp15 } // end let - tmp22 = tmp25 - }() - tmp14 = tmp22 - } // end let - tmp11 = tmp14 - }() - tmp5 = tmp11 - } // end let - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // load-data-readers - { - tmp0 := sym_load_DASH_data_DASH_readers.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7865), kw_column, int(8), kw_end_DASH_line, int(7865), kw_end_DASH_column, int(24), kw_private, true, kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - tmp3 := checkDerefVar(var_glojure_DOT_core_alter_DASH_var_DASH_root) - tmp4 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_data_DASH_readers_STAR_) - var tmp5 lang.FnFunc - tmp5 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v6 := args[0] - _ = v6 - tmp7 := checkDerefVar(var_glojure_DOT_core_reduce) - tmp8 := checkDerefVar(var_glojure_DOT_core_load_DASH_data_DASH_reader_DASH_file) - tmp9 := checkDerefVar(var_glojure_DOT_core_data_DASH_reader_DASH_urls) - tmp10 := lang.Apply(tmp9, nil) - tmp11 := lang.Apply(tmp7, []any{tmp8, v6, tmp10}) - return tmp11 - }) - tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7867), kw_column, int(19), kw_end_DASH_line, int(7869), kw_end_DASH_column, int(57)) - tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp8 := lang.Apply(tmp3, []any{tmp4, tmp7}) - return tmp8 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // load-file - { - tmp0 := sym_load_DASH_file.WithMeta(lang.NewMap(kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, nil, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // load-lib - { - tmp0 := sym_load_DASH_lib.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_prefix, sym_lib, sym__AMP_, sym_options)), kw_doc, "Loads a lib with options", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(8), kw_line, int(5904), kw_end_DASH_line, int(5904), kw_private, true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { + tmp13 := lang.Apply(tmp11, []any{tmp12}) + return tmp13 + } + }) + v6 = tmp5 + _ = v6 + } + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7445), kw_column, int(6), kw_end_DASH_line, int(7451), kw_end_DASH_column, int(82)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp7 default: - checkArity(args, 2) - v3 := args[0] + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[2:]...) + var v5 any = lang.NewList(args[3:]...) _ = v5 - tmp6 := checkDerefVar(var_glojure_DOT_core_throw_DASH_if) - var tmp7 any - { // let - // let binding "and__0__auto__" - var v8 any = v3 - _ = v8 - var tmp9 any - if lang.IsTruthy(v8) { - tmp10 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) - tmp11 := checkDerefVar(var_glojure_DOT_core_name) - tmp12 := lang.Apply(tmp11, []any{v4}) - tmp13 := checkDerefVar(var_glojure_DOT_core_int) - tmp14 := lang.Apply(tmp13, []any{lang.NewChar(46)}) - tmp15 := lang.Apply(strings11.Index, []any{tmp12, tmp14}) - tmp16 := lang.Apply(tmp10, []any{tmp15}) - tmp9 = tmp16 - } else { - tmp9 = v8 - } - tmp7 = tmp9 - } // end let - tmp8 := checkDerefVar(var_glojure_DOT_core_name) - tmp9 := lang.Apply(tmp8, []any{v4}) - tmp10 := lang.Apply(tmp6, []any{tmp7, "Found lib name '%s' containing period with prefix '%s'. lib names inside prefix lists must not contain periods", tmp9, v3}) - _ = tmp10 - var tmp11 any + var tmp6 any { // let - // let binding "lib" - var tmp12 any - if lang.IsTruthy(v3) { - tmp13 := checkDerefVar(var_glojure_DOT_core_symbol) - tmp14 := checkDerefVar(var_glojure_DOT_core_str) - tmp15 := lang.Apply(tmp14, []any{v3, lang.NewChar(46), v4}) - tmp16 := lang.Apply(tmp13, []any{tmp15}) - tmp12 = tmp16 - } else { - tmp12 = v4 - } - var v17 any = tmp12 - _ = v17 - // let binding "opts" - tmp18 := checkDerefVar(var_glojure_DOT_core_apply) - tmp19 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) - tmp20 := lang.Apply(tmp18, []any{tmp19, v5}) - var v21 any = tmp20 - _ = v21 - // let binding "map__110" - var v22 any = v21 - _ = v22 - // let binding "map__110" - var tmp23 any - tmp24 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) - tmp25 := lang.Apply(tmp24, []any{v22}) - if lang.IsTruthy(tmp25) { - var tmp26 any - tmp27 := checkDerefVar(var_glojure_DOT_core_next) - tmp28 := lang.Apply(tmp27, []any{v22}) - if lang.IsTruthy(tmp28) { - tmp29 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) - tmp30 := lang.Apply(tmp29, []any{v22}) - tmp31 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{tmp30}) - tmp26 = tmp31 - } else { - var tmp32 any - tmp33 := checkDerefVar(var_glojure_DOT_core_seq) - tmp34 := lang.Apply(tmp33, []any{v22}) - if lang.IsTruthy(tmp34) { - tmp35 := checkDerefVar(var_glojure_DOT_core_first) - tmp36 := lang.Apply(tmp35, []any{v22}) - tmp32 = tmp36 - } else { - } - tmp26 = tmp32 - } - tmp23 = tmp26 - } else { - tmp23 = v22 - } - var v37 any = tmp23 - _ = v37 - // let binding "as" - tmp38 := checkDerefVar(var_glojure_DOT_core_get) - tmp39 := lang.Apply(tmp38, []any{v37, kw_as}) - var v40 any = tmp39 - _ = v40 - // let binding "reload" - tmp41 := checkDerefVar(var_glojure_DOT_core_get) - tmp42 := lang.Apply(tmp41, []any{v37, kw_reload}) - var v43 any = tmp42 - _ = v43 - // let binding "reload-all" - tmp44 := checkDerefVar(var_glojure_DOT_core_get) - tmp45 := lang.Apply(tmp44, []any{v37, kw_reload_DASH_all}) - var v46 any = tmp45 - _ = v46 - // let binding "require" - tmp47 := checkDerefVar(var_glojure_DOT_core_get) - tmp48 := lang.Apply(tmp47, []any{v37, kw_require}) - var v49 any = tmp48 - _ = v49 - // let binding "use" - tmp50 := checkDerefVar(var_glojure_DOT_core_get) - tmp51 := lang.Apply(tmp50, []any{v37, kw_use}) - var v52 any = tmp51 - _ = v52 - // let binding "verbose" - tmp53 := checkDerefVar(var_glojure_DOT_core_get) - tmp54 := lang.Apply(tmp53, []any{v37, kw_verbose}) - var v55 any = tmp54 - _ = v55 - // let binding "as-alias" - tmp56 := checkDerefVar(var_glojure_DOT_core_get) - tmp57 := lang.Apply(tmp56, []any{v37, kw_as_DASH_alias}) - var v58 any = tmp57 - _ = v58 - // let binding "loaded" - tmp59 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) - tmp60 := checkDerefVar(var_glojure_DOT_core_deref) - tmp61 := checkDerefVar(var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_) - tmp62 := lang.Apply(tmp60, []any{tmp61}) - tmp63 := lang.Apply(tmp59, []any{tmp62, v17}) - var v64 any = tmp63 - _ = v64 - // let binding "need-ns" - var tmp65 any - { // let - // let binding "or__0__auto__" - var v66 any = v40 - _ = v66 - var tmp67 any - if lang.IsTruthy(v66) { - tmp67 = v66 - } else { - tmp67 = v52 - } - tmp65 = tmp67 - } // end let - var v66 any = tmp65 - _ = v66 - // let binding "load" - var tmp67 any - if lang.IsTruthy(v46) { - tmp68 := checkDerefVar(var_glojure_DOT_core_load_DASH_all) - tmp67 = tmp68 - } else { - var tmp69 any - if lang.IsTruthy(v43) { - tmp70 := checkDerefVar(var_glojure_DOT_core_load_DASH_one) - tmp69 = tmp70 - } else { - var tmp71 any - tmp72 := checkDerefVar(var_glojure_DOT_core_not) - tmp73 := lang.Apply(tmp72, []any{v64}) - if lang.IsTruthy(tmp73) { - var tmp74 any - if lang.IsTruthy(v66) { - tmp75 := checkDerefVar(var_glojure_DOT_core_load_DASH_one) - tmp74 = tmp75 - } else { - var tmp76 any - if lang.IsTruthy(v58) { - var tmp77 lang.FnFunc - tmp77 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 3) - v78 := args[0] - _ = v78 - v79 := args[1] - _ = v79 - v80 := args[2] - _ = v80 - tmp81 := checkDerefVar(var_glojure_DOT_core_create_DASH_ns) - tmp82 := lang.Apply(tmp81, []any{v78}) - return tmp82 - }) - tmp78 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5918), kw_column, int(48), kw_end_DASH_line, int(5918), kw_end_DASH_column, int(88)) - tmp79, err := lang.WithMeta(tmp77, tmp78.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp76 = tmp79 - } else { - var tmp80 any - if lang.IsTruthy(kw_else) { - tmp81 := checkDerefVar(var_glojure_DOT_core_load_DASH_one) - tmp80 = tmp81 + // let binding "ps" + tmp7 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp8 := lang.Apply(tmp7, []any{v2, v3, v4, v5}) + var v9 any = tmp8 + _ = v9 + var tmp10 lang.FnFunc + { // function epn + var v11 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return true + case 1: + v12 := args[0] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v15 := args[0] + _ = v15 + tmp16 := lang.Apply(v15, []any{v12}) + return tmp16 + }) + tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7456), kw_column, int(23), kw_end_DASH_line, int(7456), kw_end_DASH_column, int(28)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp17 := lang.Apply(tmp13, []any{tmp16, v9}) + return tmp17 + case 2: + v12 := args[0] + _ = v12 + v13 := args[1] + _ = v13 + tmp14 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + var tmp15 lang.FnFunc + tmp15 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v16 := args[0] + _ = v16 + var tmp17 any + { // let + // let binding "and__0__auto__" + tmp18 := lang.Apply(v16, []any{v12}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + tmp21 := lang.Apply(v16, []any{v13}) + tmp20 = tmp21 } else { + tmp20 = v19 } - tmp76 = tmp80 - } - tmp74 = tmp76 + tmp17 = tmp20 + } // end let + return tmp17 + }) + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7457), kw_column, int(25), kw_end_DASH_line, int(7457), kw_end_DASH_column, int(42)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) } - tmp71 = tmp74 - } else { - } - tmp69 = tmp71 - } - tmp67 = tmp69 - } - var v82 any = tmp67 - _ = v82 - // let binding "filter-opts" - tmp83 := checkDerefVar(var_glojure_DOT_core_select_DASH_keys) - tmp84 := lang.Apply(tmp83, []any{v21, lang.NewList(kw_exclude, kw_only, kw_rename, kw_refer)}) - var v85 any = tmp84 - _ = v85 - // let binding "undefined-on-entry" - tmp86 := checkDerefVar(var_glojure_DOT_core_not) - tmp87 := checkDerefVar(var_glojure_DOT_core_find_DASH_ns) - tmp88 := lang.Apply(tmp87, []any{v17}) - tmp89 := lang.Apply(tmp86, []any{tmp88}) - var v90 any = tmp89 - _ = v90 - var tmp91 any - { // let - tmp92 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) - tmp93 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) - tmp94 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_loading_DASH_verbosely_STAR_) - var tmp95 any - { // let - // let binding "or__0__auto__" - tmp96 := checkDerefVar(var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_) - var v97 any = tmp96 - _ = v97 - var tmp98 any - if lang.IsTruthy(v97) { - tmp98 = v97 - } else { - tmp98 = v55 - } - tmp95 = tmp98 - } // end let - tmp96 := lang.Apply(tmp93, []any{tmp94, tmp95}) - tmp97 := lang.Apply(tmp92, []any{tmp96}) - _ = tmp97 - var tmp98 any - func() { - defer func() { - tmp99 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) - tmp100 := lang.Apply(tmp99, nil) - _ = tmp100 - }() - var tmp101 any - if lang.IsTruthy(v82) { - var tmp102 any - func() { - defer func() { - if r := recover(); r != nil { - if lang.CatchMatches(r, lang.Builtins["any"]) { - v103 := r - _ = v103 - var tmp104 any - if lang.IsTruthy(v90) { - tmp105 := checkDerefVar(var_glojure_DOT_core_remove_DASH_ns) - tmp106 := lang.Apply(tmp105, []any{v17}) - tmp104 = tmp106 + tmp18 := lang.Apply(tmp14, []any{tmp17, v9}) + return tmp18 + case 3: + v12 := args[0] + _ = v12 + v13 := args[1] + _ = v13 + v14 := args[2] + _ = v14 + tmp15 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + var tmp16 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v17 := args[0] + _ = v17 + var tmp18 any + { // let + // let binding "and__0__auto__" + tmp19 := lang.Apply(v17, []any{v12}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + var tmp22 any + { // let + // let binding "and__0__auto__" + tmp23 := lang.Apply(v17, []any{v13}) + var v24 any = tmp23 + _ = v24 + var tmp25 any + if lang.IsTruthy(v24) { + tmp26 := lang.Apply(v17, []any{v14}) + tmp25 = tmp26 } else { + tmp25 = v24 } - _ = tmp104 - panic(v103) - } else { - panic(r) - } + tmp22 = tmp25 + } // end let + tmp21 = tmp22 + } else { + tmp21 = v20 } - }() - tmp103 := lang.Apply(v82, []any{v17, v66, v49}) - tmp102 = tmp103 - }() - tmp101 = tmp102 - } else { - tmp104 := checkDerefVar(var_glojure_DOT_core_throw_DASH_if) - var tmp105 any + tmp18 = tmp21 + } // end let + return tmp18 + }) + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7458), kw_column, int(27), kw_end_DASH_line, int(7458), kw_end_DASH_column, int(50)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp19 := lang.Apply(tmp15, []any{tmp18, v9}) + return tmp19 + default: + checkArity(args, 3) + v12 := args[0] + _ = v12 + v13 := args[1] + _ = v13 + v14 := args[2] + _ = v14 + var v15 any = lang.NewList(args[3:]...) + _ = v15 + tmp16 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp17 any { // let // let binding "and__0__auto__" - var v106 any = v66 - _ = v106 - var tmp107 any - if lang.IsTruthy(v106) { - tmp108 := checkDerefVar(var_glojure_DOT_core_not) - tmp109 := checkDerefVar(var_glojure_DOT_core_find_DASH_ns) - tmp110 := lang.Apply(tmp109, []any{v17}) - tmp111 := lang.Apply(tmp108, []any{tmp110}) - tmp107 = tmp111 + tmp18 := lang.Apply(v11, []any{v12, v13, v14}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + tmp21 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + var tmp22 lang.FnFunc + tmp22 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v23 := args[0] + _ = v23 + tmp24 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + tmp25 := lang.Apply(tmp24, []any{v23, v15}) + return tmp25 + }) + tmp23 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7460), kw_column, int(48), kw_end_DASH_line, int(7460), kw_end_DASH_column, int(63)) + tmp24, err := lang.WithMeta(tmp22, tmp23.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp25 := lang.Apply(tmp21, []any{tmp24, v9}) + tmp20 = tmp25 } else { - tmp107 = v106 + tmp20 = v19 } - tmp105 = tmp107 + tmp17 = tmp20 } // end let - tmp106 := lang.Apply(tmp104, []any{tmp105, "namespace '%s' not found", v17}) - tmp101 = tmp106 - } - _ = tmp101 - var tmp107 any - var tmp108 any - { // let - // let binding "and__0__auto__" - var v109 any = v66 - _ = v109 - var tmp110 any - if lang.IsTruthy(v109) { - tmp111 := checkDerefVar(var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_) - tmp110 = tmp111 - } else { - tmp110 = v109 - } - tmp108 = tmp110 - } // end let - if lang.IsTruthy(tmp108) { - tmp109 := checkDerefVar(var_glojure_DOT_core_printf) - tmp110 := checkDerefVar(var_glojure_DOT_core_ns_DASH_name) - tmp111 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) - tmp112 := lang.Apply(tmp110, []any{tmp111}) - tmp113 := lang.Apply(tmp109, []any{"(glojure.core/in-ns '%s)\n", tmp112}) - tmp107 = tmp113 - } else { - } - _ = tmp107 - var tmp114 any - if lang.IsTruthy(v40) { - var tmp115 any - tmp116 := checkDerefVar(var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_) - if lang.IsTruthy(tmp116) { - tmp117 := checkDerefVar(var_glojure_DOT_core_printf) - tmp118 := lang.Apply(tmp117, []any{"(glojure.core/alias '%s '%s)\n", v40, v17}) - tmp115 = tmp118 - } else { - } - _ = tmp115 - tmp119 := checkDerefVar(var_glojure_DOT_core_alias) - tmp120 := lang.Apply(tmp119, []any{v40, v17}) - tmp114 = tmp120 - } else { - } - _ = tmp114 - var tmp121 any - if lang.IsTruthy(v58) { - var tmp122 any - tmp123 := checkDerefVar(var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_) - if lang.IsTruthy(tmp123) { - tmp124 := checkDerefVar(var_glojure_DOT_core_printf) - tmp125 := lang.Apply(tmp124, []any{"(glojure.core/alias '%s '%s)\n", v58, v17}) - tmp122 = tmp125 - } else { - } - _ = tmp122 - tmp126 := checkDerefVar(var_glojure_DOT_core_alias) - tmp127 := lang.Apply(tmp126, []any{v58, v17}) - tmp121 = tmp127 - } else { - } - _ = tmp121 - var tmp128 any - var tmp129 any - { // let - // let binding "or__0__auto__" - var v130 any = v52 - _ = v130 - var tmp131 any - if lang.IsTruthy(v130) { - tmp131 = v130 - } else { - tmp132 := lang.Apply(kw_refer, []any{v85}) - tmp131 = tmp132 - } - tmp129 = tmp131 - } // end let - if lang.IsTruthy(tmp129) { - var tmp130 any - tmp131 := checkDerefVar(var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_) - if lang.IsTruthy(tmp131) { - tmp132 := checkDerefVar(var_glojure_DOT_core_printf) - tmp133 := lang.Apply(tmp132, []any{"(glojure.core/refer '%s", v17}) - _ = tmp133 - var tmp134 any - { // let - // let binding "seq_111" - tmp135 := checkDerefVar(var_glojure_DOT_core_seq) - tmp136 := lang.Apply(tmp135, []any{v85}) - var v137 any = tmp136 - _ = v137 - // let binding "chunk_112" - var v138 any = nil - _ = v138 - // let binding "count_113" - var v139 any = int64(0) - _ = v139 - // let binding "i_114" - var v140 any = int64(0) - _ = v140 - for { - var tmp141 any - tmp142 := checkDerefVar(var_glojure_DOT_core__LT_) - tmp143 := lang.Apply(tmp142, []any{v140, v139}) - if lang.IsTruthy(tmp143) { - var tmp144 any - { // let - // let binding "opt" - tmp145, _ := lang.FieldOrMethod(v138, "nth") - if reflect.TypeOf(tmp145).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) - } - tmp146 := lang.Apply(tmp145, []any{v140}) - var v147 any = tmp146 - _ = v147 - tmp148 := checkDerefVar(var_glojure_DOT_core_printf) - tmp149 := checkDerefVar(var_glojure_DOT_core_key) - tmp150 := lang.Apply(tmp149, []any{v147}) - tmp151 := checkDerefVar(var_glojure_DOT_core_print_DASH_str) - tmp152 := checkDerefVar(var_glojure_DOT_core_val) - tmp153 := lang.Apply(tmp152, []any{v147}) - tmp154 := lang.Apply(tmp151, []any{tmp153}) - tmp155 := lang.Apply(tmp148, []any{" %s '%s", tmp150, tmp154}) - _ = tmp155 - var tmp156 any = v137 - var tmp157 any = v138 - var tmp158 any = v139 - tmp160 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) - tmp161 := lang.Apply(tmp160, []any{v140}) - var tmp159 any = tmp161 - v137 = tmp156 - v138 = tmp157 - v139 = tmp158 - v140 = tmp159 - continue - } // end let - tmp141 = tmp144 - } else { - var tmp145 any - { // let - // let binding "temp__0__auto__" - tmp146 := checkDerefVar(var_glojure_DOT_core_seq) - tmp147 := lang.Apply(tmp146, []any{v137}) - var v148 any = tmp147 - _ = v148 - var tmp149 any - if lang.IsTruthy(v148) { - var tmp150 any - { // let - // let binding "seq_111" - var v151 any = v148 - _ = v151 - var tmp152 any - tmp153 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) - tmp154 := lang.Apply(tmp153, []any{v151}) - if lang.IsTruthy(tmp154) { - var tmp155 any - { // let - // let binding "c__0__auto__" - tmp156 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) - tmp157 := lang.Apply(tmp156, []any{v151}) - var v158 any = tmp157 - _ = v158 - tmp160 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) - tmp161 := lang.Apply(tmp160, []any{v151}) - var tmp159 any = tmp161 - var tmp162 any = v158 - tmp164 := checkDerefVar(var_glojure_DOT_core_int) - tmp165 := checkDerefVar(var_glojure_DOT_core_count) - tmp166 := lang.Apply(tmp165, []any{v158}) - tmp167 := lang.Apply(tmp164, []any{tmp166}) - var tmp163 any = tmp167 - tmp169 := checkDerefVar(var_glojure_DOT_core_int) - tmp170 := lang.Apply(tmp169, []any{int64(0)}) - var tmp168 any = tmp170 - v137 = tmp159 - v138 = tmp162 - v139 = tmp163 - v140 = tmp168 - continue - } // end let - tmp152 = tmp155 - } else { - var tmp156 any - { // let - // let binding "opt" - tmp157 := checkDerefVar(var_glojure_DOT_core_first) - tmp158 := lang.Apply(tmp157, []any{v151}) - var v159 any = tmp158 - _ = v159 - tmp160 := checkDerefVar(var_glojure_DOT_core_printf) - tmp161 := checkDerefVar(var_glojure_DOT_core_key) - tmp162 := lang.Apply(tmp161, []any{v159}) - tmp163 := checkDerefVar(var_glojure_DOT_core_print_DASH_str) - tmp164 := checkDerefVar(var_glojure_DOT_core_val) - tmp165 := lang.Apply(tmp164, []any{v159}) - tmp166 := lang.Apply(tmp163, []any{tmp165}) - tmp167 := lang.Apply(tmp160, []any{" %s '%s", tmp162, tmp166}) - _ = tmp167 - tmp169 := checkDerefVar(var_glojure_DOT_core_next) - tmp170 := lang.Apply(tmp169, []any{v151}) - var tmp168 any = tmp170 - var tmp171 any = nil - var tmp172 any = int64(0) - var tmp173 any = int64(0) - v137 = tmp168 - v138 = tmp171 - v139 = tmp172 - v140 = tmp173 - continue - } // end let - tmp152 = tmp156 - } - tmp150 = tmp152 - } // end let - tmp149 = tmp150 - } else { - } - tmp145 = tmp149 - } // end let - tmp141 = tmp145 - } - tmp134 = tmp141 - break - } - } // end let - _ = tmp134 - tmp135 := checkDerefVar(var_glojure_DOT_core_printf) - tmp136 := lang.Apply(tmp135, []any{")\n"}) - tmp130 = tmp136 - } else { - } - _ = tmp130 - tmp137 := checkDerefVar(var_glojure_DOT_core_apply) - tmp138 := checkDerefVar(var_glojure_DOT_core_refer) - tmp139 := checkDerefVar(var_glojure_DOT_core_mapcat) - tmp140 := checkDerefVar(var_glojure_DOT_core_seq) - tmp141 := lang.Apply(tmp139, []any{tmp140, v85}) - tmp142 := lang.Apply(tmp137, []any{tmp138, v17, tmp141}) - tmp128 = tmp142 - } else { + tmp18 := lang.Apply(tmp16, []any{tmp17}) + return tmp18 } - tmp98 = tmp128 - }() - tmp91 = tmp98 - } // end let - tmp11 = tmp91 + }) + v11 = tmp10 + _ = v11 + } + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7454), kw_column, int(8), kw_end_DASH_line, int(7460), kw_end_DASH_column, int(71)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp6 = tmp12 } // end let - return tmp11 + return tmp6 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_every_DASH_pred = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_every_DASH_pred.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // load-libs + // ex-info { - tmp0 := sym_load_DASH_libs.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_args)), kw_doc, "Loads libs, interpreting libspecs, prefix lists, and flags for\n forwarding to load-lib", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(8), kw_line, int(5951), kw_end_DASH_line, int(5951), kw_private, true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_ex_DASH_info.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_msg, sym_map), lang.NewVector(sym_msg, sym_map, sym_cause)), kw_doc, "Create an instance of ExceptionInfo, a RuntimeException subclass\n that carries a map of additional data.", kw_file, "glojure/core.glj", kw_added, "1.4", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4803), kw_end_DASH_line, int(4803))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - default: - checkArity(args, 0) - var v3 any = lang.NewList(args[0:]...) + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - var tmp4 any - { // let - // let binding "flags" - tmp5 := checkDerefVar(var_glojure_DOT_core_filter) - tmp6 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) - tmp7 := lang.Apply(tmp5, []any{tmp6, v3}) - var v8 any = tmp7 - _ = v8 - // let binding "opts" - tmp9 := checkDerefVar(var_glojure_DOT_core_interleave) - tmp10 := checkDerefVar(var_glojure_DOT_core_repeat) - tmp11 := lang.Apply(tmp10, []any{true}) - tmp12 := lang.Apply(tmp9, []any{v8, tmp11}) - var v13 any = tmp12 - _ = v13 - // let binding "args" - tmp14 := checkDerefVar(var_glojure_DOT_core_filter) - tmp15 := checkDerefVar(var_glojure_DOT_core_complement) - tmp16 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) - tmp17 := lang.Apply(tmp15, []any{tmp16}) - tmp18 := lang.Apply(tmp14, []any{tmp17, v3}) - var v19 any = tmp18 - _ = v19 - var tmp20 any - { // let - // let binding "supported" - tmp21 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{kw_as, kw_reload, kw_reload_DASH_all, kw_require, kw_use, kw_verbose, kw_refer, kw_as_DASH_alias})) - tmp22 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5959), kw_column, int(21), kw_end_DASH_line, int(5959), kw_end_DASH_column, int(86)) - tmp23, err := lang.WithMeta(tmp21, tmp22.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v24 any = tmp23 - _ = v24 - // let binding "unsupported" - tmp25 := checkDerefVar(var_glojure_DOT_core_seq) - tmp26 := checkDerefVar(var_glojure_DOT_core_remove) - tmp27 := lang.Apply(tmp26, []any{v24, v8}) - tmp28 := lang.Apply(tmp25, []any{tmp27}) - var v29 any = tmp28 - _ = v29 - tmp30 := checkDerefVar(var_glojure_DOT_core_throw_DASH_if) - tmp31 := checkDerefVar(var_glojure_DOT_core_apply) - tmp32 := checkDerefVar(var_glojure_DOT_core_str) - tmp33 := checkDerefVar(var_glojure_DOT_core_interpose) - tmp34 := lang.Apply(tmp33, []any{lang.NewChar(44), v29}) - tmp35 := lang.Apply(tmp31, []any{tmp32, "Unsupported option(s) supplied: ", tmp34}) - tmp36 := lang.Apply(tmp30, []any{v29, tmp35}) - tmp20 = tmp36 - } // end let - _ = tmp20 - tmp21 := checkDerefVar(var_glojure_DOT_core_throw_DASH_if) - tmp22 := checkDerefVar(var_glojure_DOT_core_not) - tmp23 := checkDerefVar(var_glojure_DOT_core_seq) - tmp24 := lang.Apply(tmp23, []any{v19}) - tmp25 := lang.Apply(tmp22, []any{tmp24}) - tmp26 := lang.Apply(tmp21, []any{tmp25, "Nothing specified to load"}) - _ = tmp26 - var tmp27 any - { // let - // let binding "seq_115" - tmp28 := checkDerefVar(var_glojure_DOT_core_seq) - tmp29 := lang.Apply(tmp28, []any{v19}) - var v30 any = tmp29 - _ = v30 - // let binding "chunk_116" - var v31 any = nil - _ = v31 - // let binding "count_117" - var v32 any = int64(0) - _ = v32 - // let binding "i_118" - var v33 any = int64(0) - _ = v33 - for { - var tmp34 any - tmp35 := checkDerefVar(var_glojure_DOT_core__LT_) - tmp36 := lang.Apply(tmp35, []any{v33, v32}) - if lang.IsTruthy(tmp36) { - var tmp37 any - { // let - // let binding "arg" - tmp38, _ := lang.FieldOrMethod(v31, "nth") - if reflect.TypeOf(tmp38).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) - } - tmp39 := lang.Apply(tmp38, []any{v33}) - var v40 any = tmp39 - _ = v40 - var tmp41 any - tmp42 := checkDerefVar(var_glojure_DOT_core_libspec_QMARK_) - tmp43 := lang.Apply(tmp42, []any{v40}) - if lang.IsTruthy(tmp43) { - tmp44 := checkDerefVar(var_glojure_DOT_core_apply) - tmp45 := checkDerefVar(var_glojure_DOT_core_load_DASH_lib) - tmp46 := checkDerefVar(var_glojure_DOT_core_prependss) - tmp47 := lang.Apply(tmp46, []any{v40, v13}) - tmp48 := lang.Apply(tmp44, []any{tmp45, nil, tmp47}) - tmp41 = tmp48 - } else { - var tmp49 any - { // let - // let binding "vec__119" - var v50 any = v40 - _ = v50 - // let binding "seq__120" - tmp51 := checkDerefVar(var_glojure_DOT_core_seq) - tmp52 := lang.Apply(tmp51, []any{v50}) - var v53 any = tmp52 - _ = v53 - // let binding "first__121" - tmp54 := checkDerefVar(var_glojure_DOT_core_first) - tmp55 := lang.Apply(tmp54, []any{v53}) - var v56 any = tmp55 - _ = v56 - // let binding "seq__120" - tmp57 := checkDerefVar(var_glojure_DOT_core_next) - tmp58 := lang.Apply(tmp57, []any{v53}) - var v59 any = tmp58 - _ = v59 - // let binding "prefix" - var v60 any = v56 - _ = v60 - // let binding "args" - var v61 any = v59 - _ = v61 - tmp62 := checkDerefVar(var_glojure_DOT_core_throw_DASH_if) - tmp63 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) - tmp64 := lang.Apply(tmp63, []any{v60}) - tmp65 := lang.Apply(tmp62, []any{tmp64, "prefix cannot be nil"}) - _ = tmp65 - var tmp66 any - { // let - // let binding "seq_122" - tmp67 := checkDerefVar(var_glojure_DOT_core_seq) - tmp68 := lang.Apply(tmp67, []any{v61}) - var v69 any = tmp68 - _ = v69 - // let binding "chunk_123" - var v70 any = nil - _ = v70 - // let binding "count_124" - var v71 any = int64(0) - _ = v71 - // let binding "i_125" - var v72 any = int64(0) - _ = v72 - for { - var tmp73 any - tmp74 := checkDerefVar(var_glojure_DOT_core__LT_) - tmp75 := lang.Apply(tmp74, []any{v72, v71}) - if lang.IsTruthy(tmp75) { - var tmp76 any - { // let - // let binding "arg" - tmp77, _ := lang.FieldOrMethod(v70, "nth") - if reflect.TypeOf(tmp77).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) - } - tmp78 := lang.Apply(tmp77, []any{v72}) - var v79 any = tmp78 - _ = v79 - tmp80 := checkDerefVar(var_glojure_DOT_core_apply) - tmp81 := checkDerefVar(var_glojure_DOT_core_load_DASH_lib) - tmp82 := checkDerefVar(var_glojure_DOT_core_prependss) - tmp83 := lang.Apply(tmp82, []any{v79, v13}) - tmp84 := lang.Apply(tmp80, []any{tmp81, v60, tmp83}) - _ = tmp84 - var tmp85 any = v69 - var tmp86 any = v70 - var tmp87 any = v71 - tmp89 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) - tmp90 := lang.Apply(tmp89, []any{v72}) - var tmp88 any = tmp90 - v69 = tmp85 - v70 = tmp86 - v71 = tmp87 - v72 = tmp88 - continue - } // end let - tmp73 = tmp76 - } else { - var tmp77 any - { // let - // let binding "temp__0__auto__" - tmp78 := checkDerefVar(var_glojure_DOT_core_seq) - tmp79 := lang.Apply(tmp78, []any{v69}) - var v80 any = tmp79 - _ = v80 - var tmp81 any - if lang.IsTruthy(v80) { - var tmp82 any - { // let - // let binding "seq_122" - var v83 any = v80 - _ = v83 - var tmp84 any - tmp85 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) - tmp86 := lang.Apply(tmp85, []any{v83}) - if lang.IsTruthy(tmp86) { - var tmp87 any - { // let - // let binding "c__0__auto__" - tmp88 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) - tmp89 := lang.Apply(tmp88, []any{v83}) - var v90 any = tmp89 - _ = v90 - tmp92 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) - tmp93 := lang.Apply(tmp92, []any{v83}) - var tmp91 any = tmp93 - var tmp94 any = v90 - tmp96 := checkDerefVar(var_glojure_DOT_core_int) - tmp97 := checkDerefVar(var_glojure_DOT_core_count) - tmp98 := lang.Apply(tmp97, []any{v90}) - tmp99 := lang.Apply(tmp96, []any{tmp98}) - var tmp95 any = tmp99 - tmp101 := checkDerefVar(var_glojure_DOT_core_int) - tmp102 := lang.Apply(tmp101, []any{int64(0)}) - var tmp100 any = tmp102 - v69 = tmp91 - v70 = tmp94 - v71 = tmp95 - v72 = tmp100 - continue - } // end let - tmp84 = tmp87 - } else { - var tmp88 any - { // let - // let binding "arg" - tmp89 := checkDerefVar(var_glojure_DOT_core_first) - tmp90 := lang.Apply(tmp89, []any{v83}) - var v91 any = tmp90 - _ = v91 - tmp92 := checkDerefVar(var_glojure_DOT_core_apply) - tmp93 := checkDerefVar(var_glojure_DOT_core_load_DASH_lib) - tmp94 := checkDerefVar(var_glojure_DOT_core_prependss) - tmp95 := lang.Apply(tmp94, []any{v91, v13}) - tmp96 := lang.Apply(tmp92, []any{tmp93, v60, tmp95}) - _ = tmp96 - tmp98 := checkDerefVar(var_glojure_DOT_core_next) - tmp99 := lang.Apply(tmp98, []any{v83}) - var tmp97 any = tmp99 - var tmp100 any = nil - var tmp101 any = int64(0) - var tmp102 any = int64(0) - v69 = tmp97 - v70 = tmp100 - v71 = tmp101 - v72 = tmp102 - continue - } // end let - tmp84 = tmp88 - } - tmp82 = tmp84 - } // end let - tmp81 = tmp82 - } else { - } - tmp77 = tmp81 - } // end let - tmp73 = tmp77 - } - tmp66 = tmp73 - break - } - } // end let - tmp49 = tmp66 - } // end let - tmp41 = tmp49 - } - _ = tmp41 - var tmp50 any = v30 - var tmp51 any = v31 - var tmp52 any = v32 - tmp54 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) - tmp55 := lang.Apply(tmp54, []any{v33}) - var tmp53 any = tmp55 - v30 = tmp50 - v31 = tmp51 - v32 = tmp52 - v33 = tmp53 - continue - } // end let - tmp34 = tmp37 + tmp4 := checkDerefVar(var_glojure_DOT_core_elide_DASH_top_DASH_frames) + tmp5 := lang.Apply(nil, []any{v2, v3}) + tmp6 := lang.Apply(tmp4, []any{tmp5, "glojure.core$ex_info"}) + return tmp6 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_elide_DASH_top_DASH_frames) + tmp6 := lang.Apply(nil, []any{v2, v3, v4}) + tmp7 := lang.Apply(tmp5, []any{tmp6, "glojure.core$ex_info"}) + return tmp7 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ex_DASH_info = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ex_DASH_info.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // filter + { + tmp0 := sym_filter.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred), lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns a lazy sequence of the items in coll for which\n (pred item) returns logical true. pred must be free of side-effects.\n Returns a transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(2785), kw_end_DASH_line, int(2785))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp6 := lang.Apply(v4, nil) + return tmp6 + case 1: + v6 := args[0] + _ = v6 + tmp7 := lang.Apply(v4, []any{v6}) + return tmp7 + case 2: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + var tmp8 any + tmp9 := lang.Apply(v2, []any{v7}) + if lang.IsTruthy(tmp9) { + tmp10 := lang.Apply(v4, []any{v6, v7}) + tmp8 = tmp10 } else { - var tmp38 any - { // let - // let binding "temp__0__auto__" - tmp39 := checkDerefVar(var_glojure_DOT_core_seq) - tmp40 := lang.Apply(tmp39, []any{v30}) - var v41 any = tmp40 - _ = v41 - var tmp42 any - if lang.IsTruthy(v41) { - var tmp43 any - { // let - // let binding "seq_115" - var v44 any = v41 - _ = v44 - var tmp45 any - tmp46 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) - tmp47 := lang.Apply(tmp46, []any{v44}) - if lang.IsTruthy(tmp47) { - var tmp48 any - { // let - // let binding "c__0__auto__" - tmp49 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) - tmp50 := lang.Apply(tmp49, []any{v44}) - var v51 any = tmp50 - _ = v51 - tmp53 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) - tmp54 := lang.Apply(tmp53, []any{v44}) - var tmp52 any = tmp54 - var tmp55 any = v51 - tmp57 := checkDerefVar(var_glojure_DOT_core_int) - tmp58 := checkDerefVar(var_glojure_DOT_core_count) - tmp59 := lang.Apply(tmp58, []any{v51}) - tmp60 := lang.Apply(tmp57, []any{tmp59}) - var tmp56 any = tmp60 - tmp62 := checkDerefVar(var_glojure_DOT_core_int) - tmp63 := lang.Apply(tmp62, []any{int64(0)}) - var tmp61 any = tmp63 - v30 = tmp52 - v31 = tmp55 - v32 = tmp56 - v33 = tmp61 - continue - } // end let - tmp45 = tmp48 - } else { - var tmp49 any - { // let - // let binding "arg" - tmp50 := checkDerefVar(var_glojure_DOT_core_first) - tmp51 := lang.Apply(tmp50, []any{v44}) - var v52 any = tmp51 - _ = v52 - var tmp53 any - tmp54 := checkDerefVar(var_glojure_DOT_core_libspec_QMARK_) - tmp55 := lang.Apply(tmp54, []any{v52}) - if lang.IsTruthy(tmp55) { - tmp56 := checkDerefVar(var_glojure_DOT_core_apply) - tmp57 := checkDerefVar(var_glojure_DOT_core_load_DASH_lib) - tmp58 := checkDerefVar(var_glojure_DOT_core_prependss) - tmp59 := lang.Apply(tmp58, []any{v52, v13}) - tmp60 := lang.Apply(tmp56, []any{tmp57, nil, tmp59}) - tmp53 = tmp60 - } else { - var tmp61 any - { // let - // let binding "vec__126" - var v62 any = v52 - _ = v62 - // let binding "seq__127" - tmp63 := checkDerefVar(var_glojure_DOT_core_seq) - tmp64 := lang.Apply(tmp63, []any{v62}) - var v65 any = tmp64 - _ = v65 - // let binding "first__128" - tmp66 := checkDerefVar(var_glojure_DOT_core_first) - tmp67 := lang.Apply(tmp66, []any{v65}) - var v68 any = tmp67 - _ = v68 - // let binding "seq__127" - tmp69 := checkDerefVar(var_glojure_DOT_core_next) - tmp70 := lang.Apply(tmp69, []any{v65}) - var v71 any = tmp70 - _ = v71 - // let binding "prefix" - var v72 any = v68 - _ = v72 - // let binding "args" - var v73 any = v71 - _ = v73 - tmp74 := checkDerefVar(var_glojure_DOT_core_throw_DASH_if) - tmp75 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) - tmp76 := lang.Apply(tmp75, []any{v72}) - tmp77 := lang.Apply(tmp74, []any{tmp76, "prefix cannot be nil"}) - _ = tmp77 - var tmp78 any - { // let - // let binding "seq_129" - tmp79 := checkDerefVar(var_glojure_DOT_core_seq) - tmp80 := lang.Apply(tmp79, []any{v73}) - var v81 any = tmp80 - _ = v81 - // let binding "chunk_130" - var v82 any = nil - _ = v82 - // let binding "count_131" - var v83 any = int64(0) - _ = v83 - // let binding "i_132" - var v84 any = int64(0) - _ = v84 - for { - var tmp85 any - tmp86 := checkDerefVar(var_glojure_DOT_core__LT_) - tmp87 := lang.Apply(tmp86, []any{v84, v83}) - if lang.IsTruthy(tmp87) { - var tmp88 any - { // let - // let binding "arg" - tmp89, _ := lang.FieldOrMethod(v82, "nth") - if reflect.TypeOf(tmp89).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) - } - tmp90 := lang.Apply(tmp89, []any{v84}) - var v91 any = tmp90 - _ = v91 - tmp92 := checkDerefVar(var_glojure_DOT_core_apply) - tmp93 := checkDerefVar(var_glojure_DOT_core_load_DASH_lib) - tmp94 := checkDerefVar(var_glojure_DOT_core_prependss) - tmp95 := lang.Apply(tmp94, []any{v91, v13}) - tmp96 := lang.Apply(tmp92, []any{tmp93, v72, tmp95}) - _ = tmp96 - var tmp97 any = v81 - var tmp98 any = v82 - var tmp99 any = v83 - tmp101 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) - tmp102 := lang.Apply(tmp101, []any{v84}) - var tmp100 any = tmp102 - v81 = tmp97 - v82 = tmp98 - v83 = tmp99 - v84 = tmp100 - continue - } // end let - tmp85 = tmp88 - } else { - var tmp89 any - { // let - // let binding "temp__0__auto__" - tmp90 := checkDerefVar(var_glojure_DOT_core_seq) - tmp91 := lang.Apply(tmp90, []any{v81}) - var v92 any = tmp91 - _ = v92 - var tmp93 any - if lang.IsTruthy(v92) { - var tmp94 any - { // let - // let binding "seq_129" - var v95 any = v92 - _ = v95 - var tmp96 any - tmp97 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) - tmp98 := lang.Apply(tmp97, []any{v95}) - if lang.IsTruthy(tmp98) { - var tmp99 any - { // let - // let binding "c__0__auto__" - tmp100 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) - tmp101 := lang.Apply(tmp100, []any{v95}) - var v102 any = tmp101 - _ = v102 - tmp104 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) - tmp105 := lang.Apply(tmp104, []any{v95}) - var tmp103 any = tmp105 - var tmp106 any = v102 - tmp108 := checkDerefVar(var_glojure_DOT_core_int) - tmp109 := checkDerefVar(var_glojure_DOT_core_count) - tmp110 := lang.Apply(tmp109, []any{v102}) - tmp111 := lang.Apply(tmp108, []any{tmp110}) - var tmp107 any = tmp111 - tmp113 := checkDerefVar(var_glojure_DOT_core_int) - tmp114 := lang.Apply(tmp113, []any{int64(0)}) - var tmp112 any = tmp114 - v81 = tmp103 - v82 = tmp106 - v83 = tmp107 - v84 = tmp112 - continue - } // end let - tmp96 = tmp99 - } else { - var tmp100 any - { // let - // let binding "arg" - tmp101 := checkDerefVar(var_glojure_DOT_core_first) - tmp102 := lang.Apply(tmp101, []any{v95}) - var v103 any = tmp102 - _ = v103 - tmp104 := checkDerefVar(var_glojure_DOT_core_apply) - tmp105 := checkDerefVar(var_glojure_DOT_core_load_DASH_lib) - tmp106 := checkDerefVar(var_glojure_DOT_core_prependss) - tmp107 := lang.Apply(tmp106, []any{v103, v13}) - tmp108 := lang.Apply(tmp104, []any{tmp105, v72, tmp107}) - _ = tmp108 - tmp110 := checkDerefVar(var_glojure_DOT_core_next) - tmp111 := lang.Apply(tmp110, []any{v95}) - var tmp109 any = tmp111 - var tmp112 any = nil - var tmp113 any = int64(0) - var tmp114 any = int64(0) - v81 = tmp109 - v82 = tmp112 - v83 = tmp113 - v84 = tmp114 - continue - } // end let - tmp96 = tmp100 - } - tmp94 = tmp96 - } // end let - tmp93 = tmp94 - } else { - } - tmp89 = tmp93 - } // end let - tmp85 = tmp89 - } - tmp78 = tmp85 - break - } - } // end let - tmp61 = tmp78 + tmp8 = v6 + } + return tmp8 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2793), kw_column, int(7), kw_end_DASH_line, int(2799), kw_end_DASH_column, int(22)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp7 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2792), kw_column, int(5), kw_end_DASH_line, int(2799), kw_end_DASH_column, int(23)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp5 any + { // let + // let binding "temp__0__auto__" + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := lang.Apply(tmp6, []any{v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + var tmp10 any + { // let + // let binding "s" + var v11 any = v8 + _ = v11 + var tmp12 any + tmp13 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp14 := lang.Apply(tmp13, []any{v11}) + if lang.IsTruthy(tmp14) { + var tmp15 any + { // let + // let binding "c" + tmp16 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp17 := lang.Apply(tmp16, []any{v11}) + var v18 any = tmp17 + _ = v18 + // let binding "size" + tmp19 := checkDerefVar(var_glojure_DOT_core_count) + tmp20 := lang.Apply(tmp19, []any{v18}) + var v21 any = tmp20 + _ = v21 + // let binding "b" + tmp22 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_buffer) + tmp23 := lang.Apply(tmp22, []any{v21}) + var v24 any = tmp23 + _ = v24 + var tmp25 any + { // let + // let binding "n__0__auto__" + tmp26 := lang.Apply(lang.LongCast, []any{v21}) + var v27 any = tmp26 + _ = v27 + var tmp28 any + { // let + // let binding "i" + var v29 any = int64(0) + _ = v29 + for { + var tmp30 any + tmp31 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp32 := lang.Apply(tmp31, []any{v29, v27}) + if lang.IsTruthy(tmp32) { + var tmp33 any + { // let + // let binding "v" + tmp34, _ := lang.FieldOrMethod(v18, "nth") + if reflect.TypeOf(tmp34).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp35 := lang.Apply(tmp34, []any{v29}) + var v36 any = tmp35 + _ = v36 + var tmp37 any + tmp38 := lang.Apply(v2, []any{v36}) + if lang.IsTruthy(tmp38) { + tmp39 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_append) + tmp40 := lang.Apply(tmp39, []any{v24, v36}) + tmp37 = tmp40 + } else { + } + tmp33 = tmp37 } // end let - tmp53 = tmp61 + _ = tmp33 + tmp35 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp36 := lang.Apply(tmp35, []any{v29}) + var tmp34 any = tmp36 + v29 = tmp34 + continue + } else { } - _ = tmp53 - tmp63 := checkDerefVar(var_glojure_DOT_core_next) - tmp64 := lang.Apply(tmp63, []any{v44}) - var tmp62 any = tmp64 - var tmp65 any = nil - var tmp66 any = int64(0) - var tmp67 any = int64(0) - v30 = tmp62 - v31 = tmp65 - v32 = tmp66 - v33 = tmp67 - continue - } // end let - tmp45 = tmp49 - } - tmp43 = tmp45 + tmp28 = tmp30 + break + } + } // end let + tmp25 = tmp28 } // end let - tmp42 = tmp43 - } else { - } - tmp38 = tmp42 - } // end let - tmp34 = tmp38 - } - tmp27 = tmp34 - break + _ = tmp25 + tmp26 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_cons) + tmp27 := checkDerefVar(var_glojure_DOT_core_chunk) + tmp28 := lang.Apply(tmp27, []any{v24}) + tmp29 := checkDerefVar(var_glojure_DOT_core_filter) + tmp30 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp31 := lang.Apply(tmp30, []any{v11}) + tmp32 := lang.Apply(tmp29, []any{v2, tmp31}) + tmp33 := lang.Apply(tmp26, []any{tmp28, tmp32}) + tmp15 = tmp33 + } // end let + tmp12 = tmp15 + } else { + var tmp16 any + { // let + // let binding "f" + tmp17 := checkDerefVar(var_glojure_DOT_core_first) + tmp18 := lang.Apply(tmp17, []any{v11}) + var v19 any = tmp18 + _ = v19 + // let binding "r" + tmp20 := checkDerefVar(var_glojure_DOT_core_rest) + tmp21 := lang.Apply(tmp20, []any{v11}) + var v22 any = tmp21 + _ = v22 + var tmp23 any + tmp24 := lang.Apply(v2, []any{v19}) + if lang.IsTruthy(tmp24) { + tmp25 := checkDerefVar(var_glojure_DOT_core_cons) + tmp26 := checkDerefVar(var_glojure_DOT_core_filter) + tmp27 := lang.Apply(tmp26, []any{v2, v22}) + tmp28 := lang.Apply(tmp25, []any{v19, tmp27}) + tmp23 = tmp28 + } else { + tmp29 := checkDerefVar(var_glojure_DOT_core_filter) + tmp30 := lang.Apply(tmp29, []any{v2, v22}) + tmp23 = tmp30 + } + tmp16 = tmp23 + } // end let + tmp12 = tmp16 + } + tmp10 = tmp12 + } // end let + tmp9 = tmp10 + } else { } + tmp5 = tmp9 } // end let - tmp4 = tmp27 - } // end let - return tmp4 + return tmp5 + }) + tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_filter = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_filter.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // load-one + // fnil { - tmp0 := sym_load_DASH_one.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_lib, sym_need_DASH_ns, sym_require)), kw_doc, "Loads a lib given its name. If need-ns, ensures that the associated\n namespace exists after loading. If require, records the load so any\n duplicate loads can be skipped.", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(8), kw_line, int(5879), kw_end_DASH_line, int(5879), kw_private, true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 3) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6 := checkDerefVar(var_glojure_DOT_core_load) - tmp7 := checkDerefVar(var_glojure_DOT_core_root_DASH_resource) - tmp8 := lang.Apply(tmp7, []any{v3}) - tmp9 := lang.Apply(tmp6, []any{tmp8}) - _ = tmp9 - tmp10 := checkDerefVar(var_glojure_DOT_core_throw_DASH_if) - var tmp11 any - { // let - // let binding "and__0__auto__" - var v12 any = v4 - _ = v12 - var tmp13 any - if lang.IsTruthy(v12) { - tmp14 := checkDerefVar(var_glojure_DOT_core_not) - tmp15 := checkDerefVar(var_glojure_DOT_core_find_DASH_ns) - tmp16 := lang.Apply(tmp15, []any{v3}) - tmp17 := lang.Apply(tmp14, []any{tmp16}) - tmp13 = tmp17 - } else { - tmp13 = v12 + tmp0 := sym_fnil.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_x), lang.NewVector(sym_f, sym_x, sym_y), lang.NewVector(sym_f, sym_x, sym_y, sym_z)), kw_doc, "Takes a function f, and returns a function that calls f, replacing\n a nil first argument to f with the supplied value x. Higher arity\n versions can replace arguments in the second and third\n positions (y, z). Note that the function f can take any number of\n arguments, not just the one(s) being nil-patched.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(6558), kw_end_DASH_line, int(6558))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v5 := args[0] + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v5}) + if lang.IsTruthy(tmp8) { + tmp6 = v3 + } else { + tmp6 = v5 + } + tmp9 := lang.Apply(v2, []any{tmp6}) + return tmp9 + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp9 := lang.Apply(tmp8, []any{v5}) + if lang.IsTruthy(tmp9) { + tmp7 = v3 + } else { + tmp7 = v5 + } + tmp10 := lang.Apply(v2, []any{tmp7, v6}) + return tmp10 + case 3: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := args[2] + _ = v7 + var tmp8 any + tmp9 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp10 := lang.Apply(tmp9, []any{v5}) + if lang.IsTruthy(tmp10) { + tmp8 = v3 + } else { + tmp8 = v5 + } + tmp11 := lang.Apply(v2, []any{tmp8, v6, v7}) + return tmp11 + default: + checkArity(args, 3) + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := args[2] + _ = v7 + var v8 any = lang.NewList(args[3:]...) + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_apply) + var tmp10 any + tmp11 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp12 := lang.Apply(tmp11, []any{v5}) + if lang.IsTruthy(tmp12) { + tmp10 = v3 + } else { + tmp10 = v5 + } + tmp13 := lang.Apply(tmp9, []any{v2, tmp10, v6, v7, v8}) + return tmp13 + } + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6567), kw_column, int(4), kw_end_DASH_line, int(6571), kw_end_DASH_column, int(55)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) } - tmp11 = tmp13 - } // end let - tmp12 := checkDerefVar(var_glojure_DOT_core_root_DASH_resource) - tmp13 := lang.Apply(tmp12, []any{v3}) - tmp14 := lang.Apply(tmp10, []any{tmp11, "namespace '%s' not found after loading '%s'", v3, tmp13}) - _ = tmp14 - var tmp15 any - if lang.IsTruthy(v5) { - var tmp16 lang.FnFunc - tmp16 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - tmp17 := checkDerefVar(var_glojure_DOT_core_commute) - tmp18 := checkDerefVar(var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_) - tmp19 := checkDerefVar(var_glojure_DOT_core_conj) - tmp20 := lang.Apply(tmp17, []any{tmp18, tmp19, v3}) - return tmp20 + return tmp6 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + var tmp8 any + tmp9 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp10 := lang.Apply(tmp9, []any{v6}) + if lang.IsTruthy(tmp10) { + tmp8 = v3 + } else { + tmp8 = v6 + } + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp13 := lang.Apply(tmp12, []any{v7}) + if lang.IsTruthy(tmp13) { + tmp11 = v4 + } else { + tmp11 = v7 + } + tmp14 := lang.Apply(v2, []any{tmp8, tmp11}) + return tmp14 + case 3: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp11 := lang.Apply(tmp10, []any{v6}) + if lang.IsTruthy(tmp11) { + tmp9 = v3 + } else { + tmp9 = v6 + } + var tmp12 any + tmp13 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp14 := lang.Apply(tmp13, []any{v7}) + if lang.IsTruthy(tmp14) { + tmp12 = v4 + } else { + tmp12 = v7 + } + tmp15 := lang.Apply(v2, []any{tmp9, tmp12, v8}) + return tmp15 + default: + checkArity(args, 3) + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + var v9 any = lang.NewList(args[3:]...) + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_apply) + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp13 := lang.Apply(tmp12, []any{v6}) + if lang.IsTruthy(tmp13) { + tmp11 = v3 + } else { + tmp11 = v6 + } + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp16 := lang.Apply(tmp15, []any{v7}) + if lang.IsTruthy(tmp16) { + tmp14 = v4 + } else { + tmp14 = v7 + } + tmp17 := lang.Apply(tmp10, []any{v2, tmp11, tmp14, v8, v9}) + return tmp17 + } }) - tmp17, _ := lang.FieldOrMethod(lang.LockingTransaction, "RunInTransaction") - if reflect.TypeOf(tmp17).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("RunInTransaction is not a function"))) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6573), kw_column, int(4), kw_end_DASH_line, int(6576), kw_end_DASH_column, int(71)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) } - tmp18 := lang.Apply(tmp17, []any{tmp16}) - tmp15 = tmp18 - } else { + return tmp7 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp11 := lang.Apply(tmp10, []any{v7}) + if lang.IsTruthy(tmp11) { + tmp9 = v3 + } else { + tmp9 = v7 + } + var tmp12 any + tmp13 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp14 := lang.Apply(tmp13, []any{v8}) + if lang.IsTruthy(tmp14) { + tmp12 = v4 + } else { + tmp12 = v8 + } + tmp15 := lang.Apply(v2, []any{tmp9, tmp12}) + return tmp15 + case 3: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + var tmp10 any + tmp11 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp12 := lang.Apply(tmp11, []any{v7}) + if lang.IsTruthy(tmp12) { + tmp10 = v3 + } else { + tmp10 = v7 + } + var tmp13 any + tmp14 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp15 := lang.Apply(tmp14, []any{v8}) + if lang.IsTruthy(tmp15) { + tmp13 = v4 + } else { + tmp13 = v8 + } + var tmp16 any + tmp17 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp18 := lang.Apply(tmp17, []any{v9}) + if lang.IsTruthy(tmp18) { + tmp16 = v5 + } else { + tmp16 = v9 + } + tmp19 := lang.Apply(v2, []any{tmp10, tmp13, tmp16}) + return tmp19 + default: + checkArity(args, 3) + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + var v10 any = lang.NewList(args[3:]...) + _ = v10 + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + var tmp12 any + tmp13 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp14 := lang.Apply(tmp13, []any{v7}) + if lang.IsTruthy(tmp14) { + tmp12 = v3 + } else { + tmp12 = v7 + } + var tmp15 any + tmp16 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp17 := lang.Apply(tmp16, []any{v8}) + if lang.IsTruthy(tmp17) { + tmp15 = v4 + } else { + tmp15 = v8 + } + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp20 := lang.Apply(tmp19, []any{v9}) + if lang.IsTruthy(tmp20) { + tmp18 = v5 + } else { + tmp18 = v9 + } + tmp21 := lang.Apply(tmp11, []any{v2, tmp12, tmp15, tmp18, v10}) + return tmp21 + } + }) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6578), kw_column, int(4), kw_end_DASH_line, int(6581), kw_end_DASH_column, int(87)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp8 + default: + checkArity(args, -1) + panic("unreachable") } - return tmp15 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_fnil = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_fnil.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // load-reader + // format { - tmp0 := sym_load_DASH_reader.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_rdr)), kw_doc, "Sequentially read and evaluate the set of forms contained in the\n stream/file", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(4081), kw_end_DASH_line, int(4081))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4, _ := lang.FieldOrMethod(runtime.Compiler, "load") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("load is not a function"))) + tmp0 := sym_format.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_fmt, sym__AMP_, sym_args)), kw_doc, "Formats a string using java.lang.String.format, see java.util.Formatter for format\n string syntax", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(5717), kw_end_DASH_line, int(5717))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_apply) + tmp5 := lang.Apply(tmp4, []any{fmt.Sprintf, v2, v3}) + return tmp5 } - tmp5 := lang.Apply(tmp4, []any{v3}) - return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_format = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_format.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // load-string + // future { - tmp0 := sym_load_DASH_string.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_doc, "Sequentially read and evaluate the set of forms contained in the\n string", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(4088), kw_end_DASH_line, int(4088))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_future.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_body)), kw_doc, "Takes a body of expressions and yields a future object that will\n invoke the body in another thread, and will cache the result and\n return it on all subsequent calls to deref/@. If the computation has\n not yet finished, calls to deref/@ will block, unless the variant of\n deref with timeout is used. See also - realized?.", kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(11), kw_line, int(7009), kw_end_DASH_line, int(7009))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym_glojure_DOT_core_SLASH_future_DASH_call}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := checkDerefVar(var_glojure_DOT_core_seq) + tmp11 := checkDerefVar(var_glojure_DOT_core_concat) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_fn_STAR_}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_apply) + tmp16 := checkDerefVar(var_glojure_DOT_core_vector) + tmp17 := checkDerefVar(var_glojure_DOT_core_seq) + tmp18 := checkDerefVar(var_glojure_DOT_core_concat) + tmp19 := lang.Apply(tmp18, nil) + tmp20 := lang.Apply(tmp17, []any{tmp19}) + tmp21 := lang.Apply(tmp15, []any{tmp16, tmp20}) + tmp22 := lang.Apply(tmp14, []any{tmp21}) + tmp23 := lang.Apply(tmp11, []any{tmp13, tmp22, v4}) + tmp24 := lang.Apply(tmp10, []any{tmp23}) + tmp25 := lang.Apply(tmp9, []any{tmp24}) + tmp26 := lang.Apply(tmp6, []any{tmp8, tmp25}) + tmp27 := lang.Apply(tmp5, []any{tmp26}) + return tmp27 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_future = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_future.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // future-call + { + tmp0 := sym_future_DASH_call.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f)), kw_doc, "Takes a function of no args and yields a future object that will\n invoke the function in another thread, and will cache the result and\n return it on all subsequent calls to deref/@. If the computation has\n not yet finished, calls to deref/@ will block, unless the variant\n of deref with timeout is used. See also - realized?.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(7003), kw_end_DASH_line, int(7003))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 any + v2 := args[0] + _ = v2 + var tmp3 any { // let - // let binding "rdr" - tmp5 := lang.Apply(nil, []any{v3}) - tmp6 := lang.Apply(nil, []any{tmp5}) - var v7 any = tmp6 - _ = v7 - tmp8 := checkDerefVar(var_glojure_DOT_core_load_DASH_reader) - tmp9 := lang.Apply(tmp8, []any{v7}) - tmp4 = tmp9 + // let binding "f" + tmp4 := checkDerefVar(var_glojure_DOT_core_binding_DASH_conveyor_DASH_fn) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + // let binding "fut" + tmp7 := lang.Apply(lang.AgentSubmit, []any{v6}) + var v8 any = tmp7 + _ = v8 + tmp3 = v8 } // end let - return tmp4 + return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_future_DASH_call = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_future_DASH_call.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // loaded-libs + // get-in { - tmp0 := sym_loaded_DASH_libs.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Returns a sorted set of symbols naming the currently loaded libs", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(6090), kw_end_DASH_line, int(6090))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - tmp3 := checkDerefVar(var_glojure_DOT_core_deref) - tmp4 := checkDerefVar(var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_) - tmp5 := lang.Apply(tmp3, []any{tmp4}) - return tmp5 + tmp0 := sym_get_DASH_in.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m, sym_ks), lang.NewVector(sym_m, sym_ks, sym_not_DASH_found)), kw_doc, "Returns the value in a nested associative structure,\n where ks is a sequence of keys. Returns nil if the key\n is not present, or the not-found value if supplied.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(6128), kw_end_DASH_line, int(6128))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp5 := checkDerefVar(var_glojure_DOT_core_get) + tmp6 := lang.Apply(tmp4, []any{tmp5, v2, v3}) + return tmp6 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + { // let + // let binding "sentinel" + tmp6 := lang.Apply(reflect.StructOf, []any{nil}) + tmp7 := lang.Apply(reflect.New, []any{tmp6}) + tmp8, ok := lang.FieldOrMethod(tmp7, "Interface") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp7, "Interface"))) + } + var tmp9 any + switch reflect.TypeOf(tmp8).Kind() { + case reflect.Func: + tmp9 = lang.Apply(tmp8, nil) + default: + tmp9 = tmp8 + } + var v10 any = tmp9 + _ = v10 + // let binding "m" + var v11 any = v2 + _ = v11 + // let binding "ks" + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := lang.Apply(tmp12, []any{v3}) + var v14 any = tmp13 + _ = v14 + for { + var tmp15 any + if lang.IsTruthy(v14) { + var tmp16 any + { // let + // let binding "m" + tmp17 := checkDerefVar(var_glojure_DOT_core_get) + tmp18 := checkDerefVar(var_glojure_DOT_core_first) + tmp19 := lang.Apply(tmp18, []any{v14}) + tmp20 := lang.Apply(tmp17, []any{v11, tmp19, v10}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + tmp23 := checkDerefVar(var_glojure_DOT_core_identical_QMARK_) + tmp24 := lang.Apply(tmp23, []any{v10, v21}) + if lang.IsTruthy(tmp24) { + tmp22 = v4 + } else { + var tmp25 any = v10 + var tmp26 any = v21 + tmp28 := checkDerefVar(var_glojure_DOT_core_next) + tmp29 := lang.Apply(tmp28, []any{v14}) + var tmp27 any = tmp29 + v10 = tmp25 + v11 = tmp26 + v14 = tmp27 + continue + } + tmp16 = tmp22 + } // end let + tmp15 = tmp16 + } else { + tmp15 = v11 + } + tmp5 = tmp15 + break + } + } // end let + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_get_DASH_in = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_get_DASH_in.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // locking + // if-let { - tmp0 := sym_locking.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_x, sym__AMP_, sym_body)), kw_doc, "Executes exprs in an implicit do, while holding the monitor of x.\n Will release the monitor of x in all circumstances.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(1643), kw_end_DASH_line, int(1643))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_if_DASH_let.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym_then), lang.NewVector(sym_bindings, sym_then, sym_else, sym__AMP_, sym_oldform)), kw_doc, "bindings => binding-form test\n\n If test is true, evaluates then with binding-form bound to the value of \n test, if not, yields else", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(11), kw_line, int(1839), kw_end_DASH_line, int(1839))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_if_DASH_let}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{v4}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v5}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{nil}) + tmp16 := lang.Apply(tmp7, []any{tmp9, tmp11, tmp13, tmp15}) + tmp17 := lang.Apply(tmp6, []any{tmp16}) + return tmp17 default: - checkArity(args, 3) - v3 := args[0] + checkArity(args, 5) + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + v4 := args[2] _ = v4 - v5 := args[2] + v5 := args[3] _ = v5 - var v6 any = lang.NewList(args[3:]...) + v6 := args[4] _ = v6 - tmp7 := checkDerefVar(var_glojure_DOT_core_seq) - tmp8 := checkDerefVar(var_glojure_DOT_core_concat) - tmp9 := checkDerefVar(var_glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_core_SLASH_let}) - tmp11 := checkDerefVar(var_glojure_DOT_core_list) - tmp12 := checkDerefVar(var_glojure_DOT_core_apply) - tmp13 := checkDerefVar(var_glojure_DOT_core_vector) - tmp14 := checkDerefVar(var_glojure_DOT_core_seq) - tmp15 := checkDerefVar(var_glojure_DOT_core_concat) - tmp16 := checkDerefVar(var_glojure_DOT_core_list) - tmp17 := lang.Apply(tmp16, []any{sym_lockee__0__auto__}) - tmp18 := checkDerefVar(var_glojure_DOT_core_list) - tmp19 := lang.Apply(tmp18, []any{v5}) - tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) - tmp21 := lang.Apply(tmp14, []any{tmp20}) - tmp22 := lang.Apply(tmp12, []any{tmp13, tmp21}) - tmp23 := lang.Apply(tmp11, []any{tmp22}) - tmp24 := checkDerefVar(var_glojure_DOT_core_list) - tmp25 := checkDerefVar(var_glojure_DOT_core_seq) - tmp26 := checkDerefVar(var_glojure_DOT_core_concat) - tmp27 := checkDerefVar(var_glojure_DOT_core_list) - tmp28 := lang.Apply(tmp27, []any{sym_try}) - tmp29 := checkDerefVar(var_glojure_DOT_core_list) - tmp30 := checkDerefVar(var_glojure_DOT_core_seq) - tmp31 := checkDerefVar(var_glojure_DOT_core_concat) - tmp32 := checkDerefVar(var_glojure_DOT_core_list) - tmp33 := lang.Apply(tmp32, []any{sym_glojure_DOT_core_SLASH_let}) - tmp34 := checkDerefVar(var_glojure_DOT_core_list) - tmp35 := checkDerefVar(var_glojure_DOT_core_apply) - tmp36 := checkDerefVar(var_glojure_DOT_core_vector) - tmp37 := checkDerefVar(var_glojure_DOT_core_seq) - tmp38 := checkDerefVar(var_glojure_DOT_core_concat) - tmp39 := checkDerefVar(var_glojure_DOT_core_list) - tmp40 := lang.Apply(tmp39, []any{sym_locklocal__1__auto__}) - tmp41 := checkDerefVar(var_glojure_DOT_core_list) - tmp42 := lang.Apply(tmp41, []any{sym_lockee__0__auto__}) - tmp43 := lang.Apply(tmp38, []any{tmp40, tmp42}) - tmp44 := lang.Apply(tmp37, []any{tmp43}) - tmp45 := lang.Apply(tmp35, []any{tmp36, tmp44}) - tmp46 := lang.Apply(tmp34, []any{tmp45}) - tmp47 := checkDerefVar(var_glojure_DOT_core_list) - tmp48 := checkDerefVar(var_glojure_DOT_core_seq) - tmp49 := checkDerefVar(var_glojure_DOT_core_concat) - tmp50 := checkDerefVar(var_glojure_DOT_core_list) - tmp51 := lang.Apply(tmp50, []any{sym_monitor_DASH_enter}) - tmp52 := checkDerefVar(var_glojure_DOT_core_list) - tmp53 := lang.Apply(tmp52, []any{sym_locklocal__1__auto__}) - tmp54 := lang.Apply(tmp49, []any{tmp51, tmp53}) - tmp55 := lang.Apply(tmp48, []any{tmp54}) - tmp56 := lang.Apply(tmp47, []any{tmp55}) - tmp57 := checkDerefVar(var_glojure_DOT_core_list) - tmp58 := checkDerefVar(var_glojure_DOT_core_seq) - tmp59 := checkDerefVar(var_glojure_DOT_core_concat) - tmp60 := checkDerefVar(var_glojure_DOT_core_list) - tmp61 := lang.Apply(tmp60, []any{sym_try}) - tmp62 := checkDerefVar(var_glojure_DOT_core_list) - tmp63 := checkDerefVar(var_glojure_DOT_core_seq) - tmp64 := checkDerefVar(var_glojure_DOT_core_concat) - tmp65 := checkDerefVar(var_glojure_DOT_core_list) - tmp66 := lang.Apply(tmp65, []any{sym_finally}) - tmp67 := checkDerefVar(var_glojure_DOT_core_list) - tmp68 := checkDerefVar(var_glojure_DOT_core_seq) - tmp69 := checkDerefVar(var_glojure_DOT_core_concat) - tmp70 := checkDerefVar(var_glojure_DOT_core_list) - tmp71 := lang.Apply(tmp70, []any{sym_monitor_DASH_exit}) - tmp72 := checkDerefVar(var_glojure_DOT_core_list) - tmp73 := lang.Apply(tmp72, []any{sym_locklocal__1__auto__}) - tmp74 := lang.Apply(tmp69, []any{tmp71, tmp73}) - tmp75 := lang.Apply(tmp68, []any{tmp74}) - tmp76 := lang.Apply(tmp67, []any{tmp75}) - tmp77 := lang.Apply(tmp64, []any{tmp66, tmp76}) - tmp78 := lang.Apply(tmp63, []any{tmp77}) - tmp79 := lang.Apply(tmp62, []any{tmp78}) - tmp80 := lang.Apply(tmp59, []any{tmp61, v6, tmp79}) - tmp81 := lang.Apply(tmp58, []any{tmp80}) - tmp82 := lang.Apply(tmp57, []any{tmp81}) - tmp83 := lang.Apply(tmp31, []any{tmp33, tmp46, tmp56, tmp82}) - tmp84 := lang.Apply(tmp30, []any{tmp83}) - tmp85 := lang.Apply(tmp29, []any{tmp84}) - tmp86 := lang.Apply(tmp26, []any{tmp28, tmp85}) - tmp87 := lang.Apply(tmp25, []any{tmp86}) - tmp88 := lang.Apply(tmp24, []any{tmp87}) - tmp89 := lang.Apply(tmp8, []any{tmp10, tmp23, tmp88}) - tmp90 := lang.Apply(tmp7, []any{tmp89}) - return tmp90 + var v7 any = lang.NewList(args[5:]...) + _ = v7 + var tmp8 any + tmp9 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp10 := lang.Apply(tmp9, []any{v4}) + if lang.IsTruthy(tmp10) { + } else { + tmp11 := checkDerefVar(var_glojure_DOT_core_str) + tmp12 := checkDerefVar(var_glojure_DOT_core_first) + tmp13 := lang.Apply(tmp12, []any{v2}) + tmp14 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp15 := checkDerefVar(var_glojure_DOT_core_meta) + tmp16 := lang.Apply(tmp15, []any{v2}) + tmp17 := lang.Apply(kw_line, []any{tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp13, " requires ", "a vector for its binding", " in ", tmp14, ":", tmp17}) + tmp19 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp18}) + panic(tmp19) + } + _ = tmp8 + var tmp20 any + tmp21 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp22 := lang.Apply(tmp21, []any{v7}) + if lang.IsTruthy(tmp22) { + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp27 := checkDerefVar(var_glojure_DOT_core_meta) + tmp28 := lang.Apply(tmp27, []any{v2}) + tmp29 := lang.Apply(kw_line, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp25, " requires ", "1 or 2 forms after binding vector", " in ", tmp26, ":", tmp29}) + tmp31 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp31) + } + _ = tmp20 + var tmp32 any + tmp33 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp34 := checkDerefVar(var_glojure_DOT_core_count) + tmp35 := lang.Apply(tmp34, []any{v4}) + tmp36 := lang.Apply(tmp33, []any{int64(2), tmp35}) + if lang.IsTruthy(tmp36) { + } else { + tmp37 := checkDerefVar(var_glojure_DOT_core_str) + tmp38 := checkDerefVar(var_glojure_DOT_core_first) + tmp39 := lang.Apply(tmp38, []any{v2}) + tmp40 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp41 := checkDerefVar(var_glojure_DOT_core_meta) + tmp42 := lang.Apply(tmp41, []any{v2}) + tmp43 := lang.Apply(kw_line, []any{tmp42}) + tmp44 := lang.Apply(tmp37, []any{tmp39, " requires ", "exactly 2 forms in binding vector", " in ", tmp40, ":", tmp43}) + tmp45 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp44}) + panic(tmp45) + } + _ = tmp32 + var tmp46 any + { // let + // let binding "form" + tmp47 := lang.Apply(v4, []any{int64(0)}) + var v48 any = tmp47 + _ = v48 + // let binding "tst" + tmp49 := lang.Apply(v4, []any{int64(1)}) + var v50 any = tmp49 + _ = v50 + tmp51 := checkDerefVar(var_glojure_DOT_core_seq) + tmp52 := checkDerefVar(var_glojure_DOT_core_concat) + tmp53 := checkDerefVar(var_glojure_DOT_core_list) + tmp54 := lang.Apply(tmp53, []any{sym_glojure_DOT_core_SLASH_let}) + tmp55 := checkDerefVar(var_glojure_DOT_core_list) + tmp56 := checkDerefVar(var_glojure_DOT_core_apply) + tmp57 := checkDerefVar(var_glojure_DOT_core_vector) + tmp58 := checkDerefVar(var_glojure_DOT_core_seq) + tmp59 := checkDerefVar(var_glojure_DOT_core_concat) + tmp60 := checkDerefVar(var_glojure_DOT_core_list) + tmp61 := lang.Apply(tmp60, []any{sym_temp__0__auto__}) + tmp62 := checkDerefVar(var_glojure_DOT_core_list) + tmp63 := lang.Apply(tmp62, []any{v50}) + tmp64 := lang.Apply(tmp59, []any{tmp61, tmp63}) + tmp65 := lang.Apply(tmp58, []any{tmp64}) + tmp66 := lang.Apply(tmp56, []any{tmp57, tmp65}) + tmp67 := lang.Apply(tmp55, []any{tmp66}) + tmp68 := checkDerefVar(var_glojure_DOT_core_list) + tmp69 := checkDerefVar(var_glojure_DOT_core_seq) + tmp70 := checkDerefVar(var_glojure_DOT_core_concat) + tmp71 := checkDerefVar(var_glojure_DOT_core_list) + tmp72 := lang.Apply(tmp71, []any{sym_if}) + tmp73 := checkDerefVar(var_glojure_DOT_core_list) + tmp74 := lang.Apply(tmp73, []any{sym_temp__0__auto__}) + tmp75 := checkDerefVar(var_glojure_DOT_core_list) + tmp76 := checkDerefVar(var_glojure_DOT_core_seq) + tmp77 := checkDerefVar(var_glojure_DOT_core_concat) + tmp78 := checkDerefVar(var_glojure_DOT_core_list) + tmp79 := lang.Apply(tmp78, []any{sym_glojure_DOT_core_SLASH_let}) + tmp80 := checkDerefVar(var_glojure_DOT_core_list) + tmp81 := checkDerefVar(var_glojure_DOT_core_apply) + tmp82 := checkDerefVar(var_glojure_DOT_core_vector) + tmp83 := checkDerefVar(var_glojure_DOT_core_seq) + tmp84 := checkDerefVar(var_glojure_DOT_core_concat) + tmp85 := checkDerefVar(var_glojure_DOT_core_list) + tmp86 := lang.Apply(tmp85, []any{v48}) + tmp87 := checkDerefVar(var_glojure_DOT_core_list) + tmp88 := lang.Apply(tmp87, []any{sym_temp__0__auto__}) + tmp89 := lang.Apply(tmp84, []any{tmp86, tmp88}) + tmp90 := lang.Apply(tmp83, []any{tmp89}) + tmp91 := lang.Apply(tmp81, []any{tmp82, tmp90}) + tmp92 := lang.Apply(tmp80, []any{tmp91}) + tmp93 := checkDerefVar(var_glojure_DOT_core_list) + tmp94 := lang.Apply(tmp93, []any{v5}) + tmp95 := lang.Apply(tmp77, []any{tmp79, tmp92, tmp94}) + tmp96 := lang.Apply(tmp76, []any{tmp95}) + tmp97 := lang.Apply(tmp75, []any{tmp96}) + tmp98 := checkDerefVar(var_glojure_DOT_core_list) + tmp99 := lang.Apply(tmp98, []any{v6}) + tmp100 := lang.Apply(tmp70, []any{tmp72, tmp74, tmp97, tmp99}) + tmp101 := lang.Apply(tmp69, []any{tmp100}) + tmp102 := lang.Apply(tmp68, []any{tmp101}) + tmp103 := lang.Apply(tmp52, []any{tmp54, tmp67, tmp102}) + tmp104 := lang.Apply(tmp51, []any{tmp103}) + tmp46 = tmp104 + } // end let + return tmp46 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_if_DASH_let = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_if_DASH_let.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // long + // if-some { + tmp0 := sym_if_DASH_some.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym_then), lang.NewVector(sym_bindings, sym_then, sym_else, sym__AMP_, sym_oldform)), kw_doc, "bindings => binding-form test\n\n If test is not nil, evaluates then with binding-form bound to the\n value of test, if not, yields else", kw_file, "glojure/core.glj", kw_added, "1.6", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(1874), kw_end_DASH_line, int(1874))).(*lang.Symbol) var tmp1 lang.FnFunc - { // function long__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_seq) - tmp5 := checkDerefVar(var_glojure_DOT_core_concat) - tmp6 := checkDerefVar(var_glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_if_DASH_some}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := checkDerefVar(var_glojure_DOT_core_seq) - tmp12 := checkDerefVar(var_glojure_DOT_core_concat) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_LongCast}) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{v3}) - tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) - tmp18 := lang.Apply(tmp11, []any{tmp17}) - tmp19 := lang.Apply(tmp10, []any{tmp18}) - tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) - tmp21 := lang.Apply(tmp4, []any{tmp20}) - return tmp21 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := sym_long.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to long", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3481), kw_end_DASH_line, int(3481))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5 := lang.Apply(lang.LongCast, []any{v4}) - return tmp5 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // long-array - { - var tmp1 lang.FnFunc - { // function long-array__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 0) - var v3 any = lang.NewList(args[0:]...) - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_seq) - tmp5 := checkDerefVar(var_glojure_DOT_core_concat) - tmp6 := checkDerefVar(var_glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) - tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_LongArray}) - tmp12 := checkDerefVar(var_glojure_DOT_core_list) - tmp13 := checkDerefVar(var_glojure_DOT_core_seq) - tmp14 := checkDerefVar(var_glojure_DOT_core_concat) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_unquote_DASH_splicing}) - tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{sym_glojure_DOT_core_SLASH_args}) - tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) - tmp20 := lang.Apply(tmp13, []any{tmp19}) - tmp21 := lang.Apply(tmp12, []any{tmp20}) - tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp21}) - tmp23 := lang.Apply(tmp4, []any{tmp22}) - return tmp23 - } - }) - v2 = tmp1 - _ = v2 - } - tmp0 := sym_long_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_size_DASH_or_DASH_seq), lang.NewVector(sym_size, sym_init_DASH_val_DASH_or_DASH_seq)), kw_inline, tmp1, kw_doc, "Creates an array of longs", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(5364), kw_end_DASH_line, int(5364))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "LongArray") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("LongArray is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - case 2: - v4 := args[0] + tmp11 := lang.Apply(tmp10, []any{v4}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v5}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{nil}) + tmp16 := lang.Apply(tmp7, []any{tmp9, tmp11, tmp13, tmp15}) + tmp17 := lang.Apply(tmp6, []any{tmp16}) + return tmp17 + default: + checkArity(args, 5) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] _ = v4 - v5 := args[1] + v5 := args[3] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "LongArrayInit") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("LongArrayInit is not a function"))) + v6 := args[4] + _ = v6 + var v7 any = lang.NewList(args[5:]...) + _ = v7 + var tmp8 any + tmp9 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp10 := lang.Apply(tmp9, []any{v4}) + if lang.IsTruthy(tmp10) { + } else { + tmp11 := checkDerefVar(var_glojure_DOT_core_str) + tmp12 := checkDerefVar(var_glojure_DOT_core_first) + tmp13 := lang.Apply(tmp12, []any{v2}) + tmp14 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp15 := checkDerefVar(var_glojure_DOT_core_meta) + tmp16 := lang.Apply(tmp15, []any{v2}) + tmp17 := lang.Apply(kw_line, []any{tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp13, " requires ", "a vector for its binding", " in ", tmp14, ":", tmp17}) + tmp19 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp18}) + panic(tmp19) } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 - default: - checkArity(args, -1) - panic("unreachable") + _ = tmp8 + var tmp20 any + tmp21 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp22 := lang.Apply(tmp21, []any{v7}) + if lang.IsTruthy(tmp22) { + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp27 := checkDerefVar(var_glojure_DOT_core_meta) + tmp28 := lang.Apply(tmp27, []any{v2}) + tmp29 := lang.Apply(kw_line, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp25, " requires ", "1 or 2 forms after binding vector", " in ", tmp26, ":", tmp29}) + tmp31 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp31) + } + _ = tmp20 + var tmp32 any + tmp33 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp34 := checkDerefVar(var_glojure_DOT_core_count) + tmp35 := lang.Apply(tmp34, []any{v4}) + tmp36 := lang.Apply(tmp33, []any{int64(2), tmp35}) + if lang.IsTruthy(tmp36) { + } else { + tmp37 := checkDerefVar(var_glojure_DOT_core_str) + tmp38 := checkDerefVar(var_glojure_DOT_core_first) + tmp39 := lang.Apply(tmp38, []any{v2}) + tmp40 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp41 := checkDerefVar(var_glojure_DOT_core_meta) + tmp42 := lang.Apply(tmp41, []any{v2}) + tmp43 := lang.Apply(kw_line, []any{tmp42}) + tmp44 := lang.Apply(tmp37, []any{tmp39, " requires ", "exactly 2 forms in binding vector", " in ", tmp40, ":", tmp43}) + tmp45 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp44}) + panic(tmp45) + } + _ = tmp32 + var tmp46 any + { // let + // let binding "form" + tmp47 := lang.Apply(v4, []any{int64(0)}) + var v48 any = tmp47 + _ = v48 + // let binding "tst" + tmp49 := lang.Apply(v4, []any{int64(1)}) + var v50 any = tmp49 + _ = v50 + tmp51 := checkDerefVar(var_glojure_DOT_core_seq) + tmp52 := checkDerefVar(var_glojure_DOT_core_concat) + tmp53 := checkDerefVar(var_glojure_DOT_core_list) + tmp54 := lang.Apply(tmp53, []any{sym_glojure_DOT_core_SLASH_let}) + tmp55 := checkDerefVar(var_glojure_DOT_core_list) + tmp56 := checkDerefVar(var_glojure_DOT_core_apply) + tmp57 := checkDerefVar(var_glojure_DOT_core_vector) + tmp58 := checkDerefVar(var_glojure_DOT_core_seq) + tmp59 := checkDerefVar(var_glojure_DOT_core_concat) + tmp60 := checkDerefVar(var_glojure_DOT_core_list) + tmp61 := lang.Apply(tmp60, []any{sym_temp__0__auto__}) + tmp62 := checkDerefVar(var_glojure_DOT_core_list) + tmp63 := lang.Apply(tmp62, []any{v50}) + tmp64 := lang.Apply(tmp59, []any{tmp61, tmp63}) + tmp65 := lang.Apply(tmp58, []any{tmp64}) + tmp66 := lang.Apply(tmp56, []any{tmp57, tmp65}) + tmp67 := lang.Apply(tmp55, []any{tmp66}) + tmp68 := checkDerefVar(var_glojure_DOT_core_list) + tmp69 := checkDerefVar(var_glojure_DOT_core_seq) + tmp70 := checkDerefVar(var_glojure_DOT_core_concat) + tmp71 := checkDerefVar(var_glojure_DOT_core_list) + tmp72 := lang.Apply(tmp71, []any{sym_if}) + tmp73 := checkDerefVar(var_glojure_DOT_core_list) + tmp74 := checkDerefVar(var_glojure_DOT_core_seq) + tmp75 := checkDerefVar(var_glojure_DOT_core_concat) + tmp76 := checkDerefVar(var_glojure_DOT_core_list) + tmp77 := lang.Apply(tmp76, []any{sym_glojure_DOT_core_SLASH_nil_QMARK_}) + tmp78 := checkDerefVar(var_glojure_DOT_core_list) + tmp79 := lang.Apply(tmp78, []any{sym_temp__0__auto__}) + tmp80 := lang.Apply(tmp75, []any{tmp77, tmp79}) + tmp81 := lang.Apply(tmp74, []any{tmp80}) + tmp82 := lang.Apply(tmp73, []any{tmp81}) + tmp83 := checkDerefVar(var_glojure_DOT_core_list) + tmp84 := lang.Apply(tmp83, []any{v6}) + tmp85 := checkDerefVar(var_glojure_DOT_core_list) + tmp86 := checkDerefVar(var_glojure_DOT_core_seq) + tmp87 := checkDerefVar(var_glojure_DOT_core_concat) + tmp88 := checkDerefVar(var_glojure_DOT_core_list) + tmp89 := lang.Apply(tmp88, []any{sym_glojure_DOT_core_SLASH_let}) + tmp90 := checkDerefVar(var_glojure_DOT_core_list) + tmp91 := checkDerefVar(var_glojure_DOT_core_apply) + tmp92 := checkDerefVar(var_glojure_DOT_core_vector) + tmp93 := checkDerefVar(var_glojure_DOT_core_seq) + tmp94 := checkDerefVar(var_glojure_DOT_core_concat) + tmp95 := checkDerefVar(var_glojure_DOT_core_list) + tmp96 := lang.Apply(tmp95, []any{v48}) + tmp97 := checkDerefVar(var_glojure_DOT_core_list) + tmp98 := lang.Apply(tmp97, []any{sym_temp__0__auto__}) + tmp99 := lang.Apply(tmp94, []any{tmp96, tmp98}) + tmp100 := lang.Apply(tmp93, []any{tmp99}) + tmp101 := lang.Apply(tmp91, []any{tmp92, tmp100}) + tmp102 := lang.Apply(tmp90, []any{tmp101}) + tmp103 := checkDerefVar(var_glojure_DOT_core_list) + tmp104 := lang.Apply(tmp103, []any{v5}) + tmp105 := lang.Apply(tmp87, []any{tmp89, tmp102, tmp104}) + tmp106 := lang.Apply(tmp86, []any{tmp105}) + tmp107 := lang.Apply(tmp85, []any{tmp106}) + tmp108 := lang.Apply(tmp70, []any{tmp72, tmp82, tmp84, tmp107}) + tmp109 := lang.Apply(tmp69, []any{tmp108}) + tmp110 := lang.Apply(tmp68, []any{tmp109}) + tmp111 := lang.Apply(tmp52, []any{tmp54, tmp67, tmp110}) + tmp112 := lang.Apply(tmp51, []any{tmp111}) + tmp46 = tmp112 + } // end let + return tmp46 } }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_if_DASH_some = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_if_DASH_some.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // longs + // into1 { + tmp0 := sym_into1.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_to, sym_from)), kw_doc, "Returns a new coll consisting of to-coll with all of the items of\n from-coll conjoined.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(3416), kw_end_DASH_line, int(3416), kw_private, true)).(*lang.Symbol) var tmp1 lang.FnFunc - { // function longs - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_seq) - tmp5 := checkDerefVar(var_glojure_DOT_core_concat) - tmp6 := checkDerefVar(var_glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) - tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Longs}) - tmp12 := checkDerefVar(var_glojure_DOT_core_list) - tmp13 := lang.Apply(tmp12, []any{v3}) - tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) - tmp15 := lang.Apply(tmp4, []any{tmp14}) - return tmp15 - }) - v2 = tmp1 + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] _ = v2 - } - tmp0 := sym_longs.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xs)), kw_inline, tmp1, kw_doc, "Casts to long[]", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(12), kw_line, int(5407), kw_end_DASH_line, int(5407))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Longs") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Longs is not a function"))) + v3 := args[1] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp6 := reflect.TypeOf((*lang.IEditableCollection)(nil)).Elem() + tmp7 := lang.Apply(tmp5, []any{tmp6, v2}) + if lang.IsTruthy(tmp7) { + tmp8 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp10 := checkDerefVar(var_glojure_DOT_core_conj_BANG_) + tmp11 := checkDerefVar(var_glojure_DOT_core_transient) + tmp12 := lang.Apply(tmp11, []any{v2}) + tmp13 := lang.Apply(tmp9, []any{tmp10, tmp12, v3}) + tmp14 := lang.Apply(tmp8, []any{tmp13}) + tmp4 = tmp14 + } else { + tmp15 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp16 := checkDerefVar(var_glojure_DOT_core_conj) + tmp17 := lang.Apply(tmp15, []any{tmp16, v2, v3}) + tmp4 = tmp17 } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 + return tmp4 }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_into1 = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_into1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // loop + // juxt { - tmp0 := sym_loop.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "Evaluates the exprs in a lexical context in which the symbols in\n the binding-forms are bound to their respective init-exprs or parts\n therein. Acts as a recur target.", kw_forms, lang.NewVector(lang.NewList(sym_loop, lang.NewVector(sym_bindings_STAR_), sym_exprs_STAR_)), kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(11), kw_line, int(4597), kw_end_DASH_line, int(4597), kw_special_DASH_form, true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_juxt.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_g), lang.NewVector(sym_f, sym_g, sym_h), lang.NewVector(sym_f, sym_g, sym_h, sym__AMP_, sym_fs)), kw_doc, "Takes a set of functions and returns a fn that is the juxtaposition\n of those fns. The returned fn takes a variable number of args, and\n returns a vector containing the result of applying each fn to the\n args (left-to-right).\n ((juxt a b c) x) => [(a x) (b x) (c x)]", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(2568), kw_end_DASH_line, int(2568))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp4 := lang.Apply(v2, nil) + tmp5 := lang.NewVector(tmp4) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2578), kw_column, int(12), kw_end_DASH_line, int(2578), kw_end_DASH_column, int(16)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp7 + case 1: + v4 := args[0] + _ = v4 + tmp5 := lang.Apply(v2, []any{v4}) + tmp6 := lang.NewVector(tmp5) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2579), kw_column, int(13), kw_end_DASH_line, int(2579), kw_end_DASH_column, int(19)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp8 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6 := lang.Apply(v2, []any{v4, v5}) + tmp7 := lang.NewVector(tmp6) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2580), kw_column, int(15), kw_end_DASH_line, int(2580), kw_end_DASH_column, int(23)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp9 + case 3: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := args[2] + _ = v6 + tmp7 := lang.Apply(v2, []any{v4, v5, v6}) + tmp8 := lang.NewVector(tmp7) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2581), kw_column, int(17), kw_end_DASH_line, int(2581), kw_end_DASH_column, int(27)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp10 + default: + checkArity(args, 3) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := args[2] + _ = v6 + var v7 any = lang.NewList(args[3:]...) + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_apply) + tmp9 := lang.Apply(tmp8, []any{v2, v4, v5, v6, v7}) + tmp10 := lang.NewVector(tmp9) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2582), kw_column, int(24), kw_end_DASH_line, int(2582), kw_end_DASH_column, int(45)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp12 + } + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2577), kw_column, int(6), kw_end_DASH_line, int(2582), kw_end_DASH_column, int(47)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp5 := lang.Apply(v2, nil) + tmp6 := lang.Apply(v3, nil) + tmp7 := lang.NewVector(tmp5, tmp6) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2585), kw_column, int(12), kw_end_DASH_line, int(2585), kw_end_DASH_column, int(20)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp9 + case 1: + v5 := args[0] + _ = v5 + tmp6 := lang.Apply(v2, []any{v5}) + tmp7 := lang.Apply(v3, []any{v5}) + tmp8 := lang.NewVector(tmp6, tmp7) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2586), kw_column, int(13), kw_end_DASH_line, int(2586), kw_end_DASH_column, int(25)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp10 + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + tmp7 := lang.Apply(v2, []any{v5, v6}) + tmp8 := lang.Apply(v3, []any{v5, v6}) + tmp9 := lang.NewVector(tmp7, tmp8) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2587), kw_column, int(15), kw_end_DASH_line, int(2587), kw_end_DASH_column, int(31)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp11 + case 3: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := args[2] + _ = v7 + tmp8 := lang.Apply(v2, []any{v5, v6, v7}) + tmp9 := lang.Apply(v3, []any{v5, v6, v7}) + tmp10 := lang.NewVector(tmp8, tmp9) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2588), kw_column, int(17), kw_end_DASH_line, int(2588), kw_end_DASH_column, int(37)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp12 + default: + checkArity(args, 3) + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := args[2] + _ = v7 + var v8 any = lang.NewList(args[3:]...) + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_apply) + tmp10 := lang.Apply(tmp9, []any{v2, v5, v6, v7, v8}) + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + tmp12 := lang.Apply(tmp11, []any{v3, v5, v6, v7, v8}) + tmp13 := lang.NewVector(tmp10, tmp12) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2589), kw_column, int(24), kw_end_DASH_line, int(2589), kw_end_DASH_column, int(66)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp15 + } + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2584), kw_column, int(6), kw_end_DASH_line, int(2589), kw_end_DASH_column, int(68)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp6 := lang.Apply(v2, nil) + tmp7 := lang.Apply(v3, nil) + tmp8 := lang.Apply(v4, nil) + tmp9 := lang.NewVector(tmp6, tmp7, tmp8) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2592), kw_column, int(12), kw_end_DASH_line, int(2592), kw_end_DASH_column, int(24)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp11 + case 1: + v6 := args[0] + _ = v6 + tmp7 := lang.Apply(v2, []any{v6}) + tmp8 := lang.Apply(v3, []any{v6}) + tmp9 := lang.Apply(v4, []any{v6}) + tmp10 := lang.NewVector(tmp7, tmp8, tmp9) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2593), kw_column, int(13), kw_end_DASH_line, int(2593), kw_end_DASH_column, int(31)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp12 + case 2: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + tmp8 := lang.Apply(v2, []any{v6, v7}) + tmp9 := lang.Apply(v3, []any{v6, v7}) + tmp10 := lang.Apply(v4, []any{v6, v7}) + tmp11 := lang.NewVector(tmp8, tmp9, tmp10) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2594), kw_column, int(15), kw_end_DASH_line, int(2594), kw_end_DASH_column, int(39)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp13 + case 3: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + tmp9 := lang.Apply(v2, []any{v6, v7, v8}) + tmp10 := lang.Apply(v3, []any{v6, v7, v8}) + tmp11 := lang.Apply(v4, []any{v6, v7, v8}) + tmp12 := lang.NewVector(tmp9, tmp10, tmp11) + tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2595), kw_column, int(17), kw_end_DASH_line, int(2595), kw_end_DASH_column, int(47)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp14 + default: + checkArity(args, 3) + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + var v9 any = lang.NewList(args[3:]...) + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_apply) + tmp11 := lang.Apply(tmp10, []any{v2, v6, v7, v8, v9}) + tmp12 := checkDerefVar(var_glojure_DOT_core_apply) + tmp13 := lang.Apply(tmp12, []any{v3, v6, v7, v8, v9}) + tmp14 := checkDerefVar(var_glojure_DOT_core_apply) + tmp15 := lang.Apply(tmp14, []any{v4, v6, v7, v8, v9}) + tmp16 := lang.NewVector(tmp11, tmp13, tmp15) + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2596), kw_column, int(24), kw_end_DASH_line, int(2596), kw_end_DASH_column, int(87)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp18 + } + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2591), kw_column, int(6), kw_end_DASH_line, int(2596), kw_end_DASH_column, int(89)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp7 default: checkArity(args, 3) - v3 := args[0] + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + v4 := args[2] _ = v4 - v5 := args[2] + var v5 any = lang.NewList(args[3:]...) _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any - tmp8 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) - tmp9 := lang.Apply(tmp8, []any{v5}) - if lang.IsTruthy(tmp9) { - } else { - tmp10 := checkDerefVar(var_glojure_DOT_core_str) - tmp11 := checkDerefVar(var_glojure_DOT_core_first) - tmp12 := lang.Apply(tmp11, []any{v3}) - tmp13 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) - tmp14 := checkDerefVar(var_glojure_DOT_core_meta) - tmp15 := lang.Apply(tmp14, []any{v3}) - tmp16 := lang.Apply(kw_line, []any{tmp15}) - tmp17 := lang.Apply(tmp10, []any{tmp12, " requires ", "a vector for its binding", " in ", tmp13, ":", tmp16}) - tmp18 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp17}) - panic(tmp18) - } - _ = tmp7 - var tmp19 any - tmp20 := checkDerefVar(var_glojure_DOT_core_even_QMARK_) - tmp21 := checkDerefVar(var_glojure_DOT_core_count) - tmp22 := lang.Apply(tmp21, []any{v5}) - tmp23 := lang.Apply(tmp20, []any{tmp22}) - if lang.IsTruthy(tmp23) { - } else { - tmp24 := checkDerefVar(var_glojure_DOT_core_str) - tmp25 := checkDerefVar(var_glojure_DOT_core_first) - tmp26 := lang.Apply(tmp25, []any{v3}) - tmp27 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) - tmp28 := checkDerefVar(var_glojure_DOT_core_meta) - tmp29 := lang.Apply(tmp28, []any{v3}) - tmp30 := lang.Apply(kw_line, []any{tmp29}) - tmp31 := lang.Apply(tmp24, []any{tmp26, " requires ", "an even number of forms in binding vector", " in ", tmp27, ":", tmp30}) - tmp32 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp31}) - panic(tmp32) - } - _ = tmp19 - var tmp33 any + var tmp6 any { // let - // let binding "db" - tmp34 := checkDerefVar(var_glojure_DOT_core_destructure) - tmp35 := lang.Apply(tmp34, []any{v5}) - var v36 any = tmp35 - _ = v36 - var tmp37 any - tmp38 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp39 := lang.Apply(tmp38, []any{v36, v5}) - if lang.IsTruthy(tmp39) { - tmp40 := checkDerefVar(var_glojure_DOT_core_seq) - tmp41 := checkDerefVar(var_glojure_DOT_core_concat) - tmp42 := checkDerefVar(var_glojure_DOT_core_list) - tmp43 := lang.Apply(tmp42, []any{sym_loop_STAR_}) - tmp44 := checkDerefVar(var_glojure_DOT_core_list) - tmp45 := lang.Apply(tmp44, []any{v5}) - tmp46 := lang.Apply(tmp41, []any{tmp43, tmp45, v6}) - tmp47 := lang.Apply(tmp40, []any{tmp46}) - tmp37 = tmp47 - } else { - var tmp48 any - { // let - // let binding "vs" - tmp49 := checkDerefVar(var_glojure_DOT_core_take_DASH_nth) - tmp50 := checkDerefVar(var_glojure_DOT_core_drop) - tmp51 := lang.Apply(tmp50, []any{int64(1), v5}) - tmp52 := lang.Apply(tmp49, []any{int64(2), tmp51}) - var v53 any = tmp52 - _ = v53 - // let binding "bs" - tmp54 := checkDerefVar(var_glojure_DOT_core_take_DASH_nth) - tmp55 := lang.Apply(tmp54, []any{int64(2), v5}) - var v56 any = tmp55 - _ = v56 - // let binding "gs" - tmp57 := checkDerefVar(var_glojure_DOT_core_map) - var tmp58 lang.FnFunc - tmp58 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v59 := args[0] - _ = v59 - var tmp60 any - tmp61 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) - tmp62 := lang.Apply(tmp61, []any{v59}) - if lang.IsTruthy(tmp62) { - tmp60 = v59 - } else { - tmp63 := checkDerefVar(var_glojure_DOT_core_gensym) - tmp64 := lang.Apply(tmp63, nil) - tmp60 = tmp64 - } - return tmp60 + // let binding "fs" + tmp7 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp8 := lang.Apply(tmp7, []any{v2, v3, v4, v5}) + var v9 any = tmp8 + _ = v9 + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp11 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp12 lang.FnFunc + tmp12 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v13 := args[0] + _ = v13 + v14 := args[1] + _ = v14 + tmp15 := checkDerefVar(var_glojure_DOT_core_conj) + tmp16 := lang.Apply(v14, nil) + tmp17 := lang.Apply(tmp15, []any{v13, tmp16}) + return tmp17 }) - tmp59 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4611), kw_column, int(23), kw_end_DASH_line, int(4611), kw_end_DASH_column, int(58)) - tmp60, err := lang.WithMeta(tmp58, tmp59.(lang.IPersistentMap)) + tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2600), kw_column, int(23), kw_end_DASH_line, int(2600), kw_end_DASH_column, int(37)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp61 := lang.Apply(tmp57, []any{tmp60, v56}) - var v62 any = tmp61 - _ = v62 - // let binding "bfs" - tmp63 := checkDerefVar(var_glojure_DOT_core_reduce1) - var tmp64 lang.FnFunc - tmp64 = lang.NewFnFunc(func(args ...any) any { + tmp15 := lang.NewVector() + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2600), kw_column, int(39), kw_end_DASH_line, int(2600), kw_end_DASH_column, int(40)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp18 := lang.Apply(tmp11, []any{tmp14, tmp17, v9}) + return tmp18 + case 1: + v11 := args[0] + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 2) - v65 := args[0] - _ = v65 - v66 := args[1] - _ = v66 - var tmp67 any - { // let - // let binding "vec__17" - var v68 any = v66 - _ = v68 - // let binding "b" - tmp69 := checkDerefVar(var_glojure_DOT_core_nth) - tmp70 := lang.Apply(tmp69, []any{v68, int64(0), nil}) - var v71 any = tmp70 - _ = v71 - // let binding "v" - tmp72 := checkDerefVar(var_glojure_DOT_core_nth) - tmp73 := lang.Apply(tmp72, []any{v68, int64(1), nil}) - var v74 any = tmp73 - _ = v74 - // let binding "g" - tmp75 := checkDerefVar(var_glojure_DOT_core_nth) - tmp76 := lang.Apply(tmp75, []any{v68, int64(2), nil}) - var v77 any = tmp76 - _ = v77 - var tmp78 any - tmp79 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) - tmp80 := lang.Apply(tmp79, []any{v71}) - if lang.IsTruthy(tmp80) { - tmp81 := checkDerefVar(var_glojure_DOT_core_conj) - tmp82 := lang.Apply(tmp81, []any{v65, v77, v74}) - tmp78 = tmp82 - } else { - tmp83 := checkDerefVar(var_glojure_DOT_core_conj) - tmp84 := lang.Apply(tmp83, []any{v65, v77, v74, v71, v77}) - tmp78 = tmp84 - } - tmp67 = tmp78 - } // end let - return tmp67 + v14 := args[0] + _ = v14 + v15 := args[1] + _ = v15 + tmp16 := checkDerefVar(var_glojure_DOT_core_conj) + tmp17 := lang.Apply(v15, []any{v11}) + tmp18 := lang.Apply(tmp16, []any{v14, tmp17}) + return tmp18 }) - tmp65 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4612), kw_column, int(28), kw_end_DASH_line, int(4615), kw_end_DASH_column, int(50)) - tmp66, err := lang.WithMeta(tmp64, tmp65.(lang.IPersistentMap)) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2601), kw_column, int(24), kw_end_DASH_line, int(2601), kw_end_DASH_column, int(40)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp67 := lang.NewVector() - tmp68 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4616), kw_column, int(27), kw_end_DASH_line, int(4616), kw_end_DASH_column, int(28)) - tmp69, err := lang.WithMeta(tmp67, tmp68.(lang.IPersistentMap)) + tmp16 := lang.NewVector() + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2601), kw_column, int(42), kw_end_DASH_line, int(2601), kw_end_DASH_column, int(43)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp70 := checkDerefVar(var_glojure_DOT_core_map) - tmp71 := checkDerefVar(var_glojure_DOT_core_vector) - tmp72 := lang.Apply(tmp70, []any{tmp71, v56, v53, v62}) - tmp73 := lang.Apply(tmp63, []any{tmp66, tmp69, tmp72}) - var v74 any = tmp73 - _ = v74 - tmp75 := checkDerefVar(var_glojure_DOT_core_seq) - tmp76 := checkDerefVar(var_glojure_DOT_core_concat) - tmp77 := checkDerefVar(var_glojure_DOT_core_list) - tmp78 := lang.Apply(tmp77, []any{sym_glojure_DOT_core_SLASH_let}) - tmp79 := checkDerefVar(var_glojure_DOT_core_list) - tmp80 := lang.Apply(tmp79, []any{v74}) - tmp81 := checkDerefVar(var_glojure_DOT_core_list) - tmp82 := checkDerefVar(var_glojure_DOT_core_seq) - tmp83 := checkDerefVar(var_glojure_DOT_core_concat) - tmp84 := checkDerefVar(var_glojure_DOT_core_list) - tmp85 := lang.Apply(tmp84, []any{sym_loop_STAR_}) - tmp86 := checkDerefVar(var_glojure_DOT_core_list) - tmp87 := checkDerefVar(var_glojure_DOT_core_vec) - tmp88 := checkDerefVar(var_glojure_DOT_core_interleave) - tmp89 := lang.Apply(tmp88, []any{v62, v62}) - tmp90 := lang.Apply(tmp87, []any{tmp89}) - tmp91 := lang.Apply(tmp86, []any{tmp90}) - tmp92 := checkDerefVar(var_glojure_DOT_core_list) - tmp93 := checkDerefVar(var_glojure_DOT_core_seq) - tmp94 := checkDerefVar(var_glojure_DOT_core_concat) - tmp95 := checkDerefVar(var_glojure_DOT_core_list) - tmp96 := lang.Apply(tmp95, []any{sym_glojure_DOT_core_SLASH_let}) - tmp97 := checkDerefVar(var_glojure_DOT_core_list) - tmp98 := checkDerefVar(var_glojure_DOT_core_vec) - tmp99 := checkDerefVar(var_glojure_DOT_core_interleave) - tmp100 := lang.Apply(tmp99, []any{v56, v62}) - tmp101 := lang.Apply(tmp98, []any{tmp100}) - tmp102 := lang.Apply(tmp97, []any{tmp101}) - tmp103 := lang.Apply(tmp94, []any{tmp96, tmp102, v6}) - tmp104 := lang.Apply(tmp93, []any{tmp103}) - tmp105 := lang.Apply(tmp92, []any{tmp104}) - tmp106 := lang.Apply(tmp83, []any{tmp85, tmp91, tmp105}) - tmp107 := lang.Apply(tmp82, []any{tmp106}) - tmp108 := lang.Apply(tmp81, []any{tmp107}) - tmp109 := lang.Apply(tmp76, []any{tmp78, tmp80, tmp108}) - tmp110 := lang.Apply(tmp75, []any{tmp109}) - tmp48 = tmp110 - } // end let - tmp37 = tmp48 + tmp19 := lang.Apply(tmp12, []any{tmp15, tmp18, v9}) + return tmp19 + case 2: + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v15 := args[0] + _ = v15 + v16 := args[1] + _ = v16 + tmp17 := checkDerefVar(var_glojure_DOT_core_conj) + tmp18 := lang.Apply(v16, []any{v11, v12}) + tmp19 := lang.Apply(tmp17, []any{v15, tmp18}) + return tmp19 + }) + tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2602), kw_column, int(26), kw_end_DASH_line, int(2602), kw_end_DASH_column, int(44)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp17 := lang.NewVector() + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2602), kw_column, int(46), kw_end_DASH_line, int(2602), kw_end_DASH_column, int(47)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp20 := lang.Apply(tmp13, []any{tmp16, tmp19, v9}) + return tmp20 + case 3: + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + v13 := args[2] + _ = v13 + tmp14 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp15 lang.FnFunc + tmp15 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v16 := args[0] + _ = v16 + v17 := args[1] + _ = v17 + tmp18 := checkDerefVar(var_glojure_DOT_core_conj) + tmp19 := lang.Apply(v17, []any{v11, v12, v13}) + tmp20 := lang.Apply(tmp18, []any{v16, tmp19}) + return tmp20 + }) + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2603), kw_column, int(28), kw_end_DASH_line, int(2603), kw_end_DASH_column, int(48)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp18 := lang.NewVector() + tmp19 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2603), kw_column, int(50), kw_end_DASH_line, int(2603), kw_end_DASH_column, int(51)) + tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp21 := lang.Apply(tmp14, []any{tmp17, tmp20, v9}) + return tmp21 + default: + checkArity(args, 3) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + v13 := args[2] + _ = v13 + var v14 any = lang.NewList(args[3:]...) + _ = v14 + tmp15 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp16 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v17 := args[0] + _ = v17 + v18 := args[1] + _ = v18 + tmp19 := checkDerefVar(var_glojure_DOT_core_conj) + tmp20 := checkDerefVar(var_glojure_DOT_core_apply) + tmp21 := lang.Apply(tmp20, []any{v18, v11, v12, v13, v14}) + tmp22 := lang.Apply(tmp19, []any{v17, tmp21}) + return tmp22 + }) + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2604), kw_column, int(35), kw_end_DASH_line, int(2604), kw_end_DASH_column, int(66)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp19 := lang.NewVector() + tmp20 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2604), kw_column, int(68), kw_end_DASH_line, int(2604), kw_end_DASH_column, int(69)) + tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp22 := lang.Apply(tmp15, []any{tmp18, tmp21, v9}) + return tmp22 + } + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2599), kw_column, int(8), kw_end_DASH_line, int(2604), kw_end_DASH_column, int(75)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) } - tmp33 = tmp37 + tmp6 = tmp12 } // end let - return tmp33 + return tmp6 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_juxt = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_juxt.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // macroexpand + // keep { - tmp0 := sym_macroexpand.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_form)), kw_doc, "Repeatedly calls macroexpand-1 on form until it no longer\n represents a macro form, then returns it. Note neither\n macroexpand-1 nor macroexpand expand macros in subforms.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(4025), kw_end_DASH_line, int(4025))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "ex" - tmp5 := checkDerefVar(var_glojure_DOT_core_macroexpand_DASH_1) - tmp6 := lang.Apply(tmp5, []any{v3}) - var v7 any = tmp6 - _ = v7 - var tmp8 any - tmp9 := checkDerefVar(var_glojure_DOT_core_identical_QMARK_) - tmp10 := lang.Apply(tmp9, []any{v7, v3}) - if lang.IsTruthy(tmp10) { - tmp8 = v3 - } else { - tmp11 := checkDerefVar(var_glojure_DOT_core_macroexpand) - tmp12 := lang.Apply(tmp11, []any{v7}) - tmp8 = tmp12 + tmp0 := sym_keep.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_coll)), kw_doc, "Returns a lazy sequence of the non-nil results of (f item). Note,\n this means false return values will be included. f must be free of\n side-effects. Returns a transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(7339), kw_end_DASH_line, int(7339))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp6 := lang.Apply(v4, nil) + return tmp6 + case 1: + v6 := args[0] + _ = v6 + tmp7 := lang.Apply(v4, []any{v6}) + return tmp7 + case 2: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + var tmp8 any + { // let + // let binding "v" + tmp9 := lang.Apply(v2, []any{v7}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp13 := lang.Apply(tmp12, []any{v10}) + if lang.IsTruthy(tmp13) { + tmp11 = v6 + } else { + tmp14 := lang.Apply(v4, []any{v6, v10}) + tmp11 = tmp14 + } + tmp8 = tmp11 + } // end let + return tmp8 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7347), kw_column, int(6), kw_end_DASH_line, int(7354), kw_end_DASH_column, int(31)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp7 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7346), kw_column, int(4), kw_end_DASH_line, int(7354), kw_end_DASH_column, int(32)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) } - tmp4 = tmp8 - } // end let - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // macroexpand-1 - { - tmp0 := sym_macroexpand_DASH_1.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_form)), kw_doc, "If form represents a macro form, returns its expansion,\n else returns form.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(4017), kw_end_DASH_line, int(4017))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4, _ := lang.FieldOrMethod(runtime.Compiler, "macroexpand1") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("macroexpand1 is not a function"))) + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp5 any + { // let + // let binding "temp__0__auto__" + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := lang.Apply(tmp6, []any{v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + var tmp10 any + { // let + // let binding "s" + var v11 any = v8 + _ = v11 + var tmp12 any + tmp13 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp14 := lang.Apply(tmp13, []any{v11}) + if lang.IsTruthy(tmp14) { + var tmp15 any + { // let + // let binding "c" + tmp16 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp17 := lang.Apply(tmp16, []any{v11}) + var v18 any = tmp17 + _ = v18 + // let binding "size" + tmp19 := checkDerefVar(var_glojure_DOT_core_count) + tmp20 := lang.Apply(tmp19, []any{v18}) + var v21 any = tmp20 + _ = v21 + // let binding "b" + tmp22 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_buffer) + tmp23 := lang.Apply(tmp22, []any{v21}) + var v24 any = tmp23 + _ = v24 + var tmp25 any + { // let + // let binding "n__0__auto__" + tmp26 := checkDerefVar(var_glojure_DOT_core_long) + tmp27 := lang.Apply(tmp26, []any{v21}) + var v28 any = tmp27 + _ = v28 + var tmp29 any + { // let + // let binding "i" + var v30 any = int64(0) + _ = v30 + for { + var tmp31 any + tmp32 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp33 := lang.Apply(tmp32, []any{v30, v28}) + if lang.IsTruthy(tmp33) { + var tmp34 any + { // let + // let binding "x" + tmp35, _ := lang.FieldOrMethod(v18, "nth") + if reflect.TypeOf(tmp35).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp36 := lang.Apply(tmp35, []any{v30}) + tmp37 := lang.Apply(v2, []any{tmp36}) + var v38 any = tmp37 + _ = v38 + var tmp39 any + tmp40 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp41 := lang.Apply(tmp40, []any{v38}) + if lang.IsTruthy(tmp41) { + } else { + tmp42 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_append) + tmp43 := lang.Apply(tmp42, []any{v24, v38}) + tmp39 = tmp43 + } + tmp34 = tmp39 + } // end let + _ = tmp34 + tmp36 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp37 := lang.Apply(tmp36, []any{v30}) + var tmp35 any = tmp37 + v30 = tmp35 + continue + } else { + } + tmp29 = tmp31 + break + } + } // end let + tmp25 = tmp29 + } // end let + _ = tmp25 + tmp26 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_cons) + tmp27 := checkDerefVar(var_glojure_DOT_core_chunk) + tmp28 := lang.Apply(tmp27, []any{v24}) + tmp29 := checkDerefVar(var_glojure_DOT_core_keep) + tmp30 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp31 := lang.Apply(tmp30, []any{v11}) + tmp32 := lang.Apply(tmp29, []any{v2, tmp31}) + tmp33 := lang.Apply(tmp26, []any{tmp28, tmp32}) + tmp15 = tmp33 + } // end let + tmp12 = tmp15 + } else { + var tmp16 any + { // let + // let binding "x" + tmp17 := checkDerefVar(var_glojure_DOT_core_first) + tmp18 := lang.Apply(tmp17, []any{v11}) + tmp19 := lang.Apply(v2, []any{tmp18}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + tmp22 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp23 := lang.Apply(tmp22, []any{v20}) + if lang.IsTruthy(tmp23) { + tmp24 := checkDerefVar(var_glojure_DOT_core_keep) + tmp25 := checkDerefVar(var_glojure_DOT_core_rest) + tmp26 := lang.Apply(tmp25, []any{v11}) + tmp27 := lang.Apply(tmp24, []any{v2, tmp26}) + tmp21 = tmp27 + } else { + tmp28 := checkDerefVar(var_glojure_DOT_core_cons) + tmp29 := checkDerefVar(var_glojure_DOT_core_keep) + tmp30 := checkDerefVar(var_glojure_DOT_core_rest) + tmp31 := lang.Apply(tmp30, []any{v11}) + tmp32 := lang.Apply(tmp29, []any{v2, tmp31}) + tmp33 := lang.Apply(tmp28, []any{v20, tmp32}) + tmp21 = tmp33 + } + tmp16 = tmp21 + } // end let + tmp12 = tmp16 + } + tmp10 = tmp12 + } // end let + tmp9 = tmp10 + } else { + } + tmp5 = tmp9 + } // end let + return tmp5 + }) + tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") } - tmp5 := lang.Apply(tmp4, []any{v3}) - return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_keep = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_keep.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // make-array + // lazy-seq { - tmp0 := sym_make_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_type, sym_len), lang.NewVector(sym_type, sym_dim, sym__AMP_, sym_more_DASH_dims)), kw_doc, "Creates and returns an array of instances of the specified class of\n the specified dimension(s). Note that a class object is required.\n Class objects can be obtained by using their imported or\n fully-qualified name. Class objects for the primitive types can be\n obtained using, e.g., Integer/TYPE.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(3985), kw_end_DASH_line, int(3985))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_lazy_DASH_seq.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_body)), kw_doc, "Takes a body of expressions that returns an ISeq or nil, and yields\n a Seqable object that will invoke the body only the first time seq\n is called, and will cache the result and return it on all subsequent\n seq calls. See also - realized?", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(11), kw_line, int(676), kw_end_DASH_line, int(676))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_int) - tmp6 := lang.Apply(tmp5, []any{v4}) - tmp7, _ := lang.FieldOrMethod(nil, "newInstance") - if reflect.TypeOf(tmp7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("newInstance is not a function"))) - } - tmp8 := lang.Apply(tmp7, []any{v3, tmp6}) - return tmp8 default: checkArity(args, 2) - v3 := args[0] + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + var v4 any = lang.NewList(args[2:]...) _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - var tmp6 any - { // let - // let binding "dims" - tmp7 := checkDerefVar(var_glojure_DOT_core_cons) - tmp8 := lang.Apply(tmp7, []any{v4, v5}) - var v9 any = tmp8 - _ = v9 - // let binding "dimarray" - tmp10 := checkDerefVar(var_glojure_DOT_core_make_DASH_array) - tmp11, ok := lang.FieldOrMethod(nil, "TYPE") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "TYPE"))) - } - var tmp12 any - switch reflect.TypeOf(tmp11).Kind() { - case reflect.Func: - tmp12 = lang.Apply(tmp11, nil) - default: - tmp12 = tmp11 - } - tmp13 := checkDerefVar(var_glojure_DOT_core_count) - tmp14 := lang.Apply(tmp13, []any{v9}) - tmp15 := lang.Apply(tmp10, []any{tmp12, tmp14}) - var v16 any = tmp15 - _ = v16 - var tmp17 any - { // let - // let binding "n__0__auto__" - tmp18 := checkDerefVar(var_glojure_DOT_core_long) - tmp19 := checkDerefVar(var_glojure_DOT_core_alength) - tmp20 := lang.Apply(tmp19, []any{v16}) - tmp21 := lang.Apply(tmp18, []any{tmp20}) - var v22 any = tmp21 - _ = v22 - var tmp23 any - { // let - // let binding "i" - var v24 any = int64(0) - _ = v24 - for { - var tmp25 any - tmp26 := checkDerefVar(var_glojure_DOT_core__LT_) - tmp27 := lang.Apply(tmp26, []any{v24, v22}) - if lang.IsTruthy(tmp27) { - tmp28 := checkDerefVar(var_glojure_DOT_core_aset_DASH_int) - tmp29 := checkDerefVar(var_glojure_DOT_core_nth) - tmp30 := lang.Apply(tmp29, []any{v9, v24}) - tmp31 := lang.Apply(tmp28, []any{v16, v24, tmp30}) - _ = tmp31 - tmp33 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) - tmp34 := lang.Apply(tmp33, []any{v24}) - var tmp32 any = tmp34 - v24 = tmp32 - continue - } else { - } - tmp23 = tmp25 - break - } - } // end let - tmp17 = tmp23 - } // end let - _ = tmp17 - tmp18, _ := lang.FieldOrMethod(nil, "newInstance") - if reflect.TypeOf(tmp18).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("newInstance is not a function"))) - } - tmp19 := lang.Apply(tmp18, []any{v3, v16}) - tmp6 = tmp19 - } // end let - return tmp6 + tmp5 := checkDerefVar(var_glojure_DOT_core_list) + tmp6 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp7 := lang.NewVector() + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(683), kw_column, int(101), kw_end_DASH_line, int(683), kw_end_DASH_column, int(102)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp10 := lang.Apply(tmp6, []any{sym_fn_STAR_, tmp9, v4}) + tmp11 := lang.Apply(tmp5, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_NewLazySeq, tmp10}) + return tmp11 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_lazy_DASH_seq = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_lazy_DASH_seq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // make-hierarchy + // locking { - tmp0 := sym_make_DASH_hierarchy.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Creates a hierarchy object for use with derive, isa? etc.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(5507), kw_end_DASH_line, int(5507))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - tmp3 := lang.NewMap() - tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5511), kw_column, int(16), kw_end_DASH_line, int(5511), kw_end_DASH_column, int(17)) - tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp6 := lang.NewMap() - tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5511), kw_column, int(32), kw_end_DASH_line, int(5511), kw_end_DASH_column, int(33)) - tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp9 := lang.NewMap() - tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5511), kw_column, int(46), kw_end_DASH_line, int(5511), kw_end_DASH_column, int(47)) - tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp12 := lang.NewMap(kw_parents, tmp5, kw_descendants, tmp8, kw_ancestors, tmp11) - tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5511), kw_column, int(6), kw_end_DASH_line, int(5511), kw_end_DASH_column, int(48)) - tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) - if err != nil { - panic(err) + tmp0 := sym_locking.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_x, sym__AMP_, sym_body)), kw_doc, "Executes exprs in an implicit do, while holding the monitor of x.\n Will release the monitor of x in all circumstances.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(1643), kw_end_DASH_line, int(1643))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_let}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + tmp12 := checkDerefVar(var_glojure_DOT_core_vector) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_lockee__0__auto__}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v4}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp19}) + tmp21 := lang.Apply(tmp11, []any{tmp12, tmp20}) + tmp22 := lang.Apply(tmp10, []any{tmp21}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_seq) + tmp25 := checkDerefVar(var_glojure_DOT_core_concat) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{sym_try}) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := checkDerefVar(var_glojure_DOT_core_seq) + tmp30 := checkDerefVar(var_glojure_DOT_core_concat) + tmp31 := checkDerefVar(var_glojure_DOT_core_list) + tmp32 := lang.Apply(tmp31, []any{sym_glojure_DOT_core_SLASH_let}) + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := checkDerefVar(var_glojure_DOT_core_apply) + tmp35 := checkDerefVar(var_glojure_DOT_core_vector) + tmp36 := checkDerefVar(var_glojure_DOT_core_seq) + tmp37 := checkDerefVar(var_glojure_DOT_core_concat) + tmp38 := checkDerefVar(var_glojure_DOT_core_list) + tmp39 := lang.Apply(tmp38, []any{sym_locklocal__1__auto__}) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{sym_lockee__0__auto__}) + tmp42 := lang.Apply(tmp37, []any{tmp39, tmp41}) + tmp43 := lang.Apply(tmp36, []any{tmp42}) + tmp44 := lang.Apply(tmp34, []any{tmp35, tmp43}) + tmp45 := lang.Apply(tmp33, []any{tmp44}) + tmp46 := checkDerefVar(var_glojure_DOT_core_list) + tmp47 := checkDerefVar(var_glojure_DOT_core_seq) + tmp48 := checkDerefVar(var_glojure_DOT_core_concat) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) + tmp50 := lang.Apply(tmp49, []any{sym_monitor_DASH_enter}) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := lang.Apply(tmp51, []any{sym_locklocal__1__auto__}) + tmp53 := lang.Apply(tmp48, []any{tmp50, tmp52}) + tmp54 := lang.Apply(tmp47, []any{tmp53}) + tmp55 := lang.Apply(tmp46, []any{tmp54}) + tmp56 := checkDerefVar(var_glojure_DOT_core_list) + tmp57 := checkDerefVar(var_glojure_DOT_core_seq) + tmp58 := checkDerefVar(var_glojure_DOT_core_concat) + tmp59 := checkDerefVar(var_glojure_DOT_core_list) + tmp60 := lang.Apply(tmp59, []any{sym_try}) + tmp61 := checkDerefVar(var_glojure_DOT_core_list) + tmp62 := checkDerefVar(var_glojure_DOT_core_seq) + tmp63 := checkDerefVar(var_glojure_DOT_core_concat) + tmp64 := checkDerefVar(var_glojure_DOT_core_list) + tmp65 := lang.Apply(tmp64, []any{sym_finally}) + tmp66 := checkDerefVar(var_glojure_DOT_core_list) + tmp67 := checkDerefVar(var_glojure_DOT_core_seq) + tmp68 := checkDerefVar(var_glojure_DOT_core_concat) + tmp69 := checkDerefVar(var_glojure_DOT_core_list) + tmp70 := lang.Apply(tmp69, []any{sym_monitor_DASH_exit}) + tmp71 := checkDerefVar(var_glojure_DOT_core_list) + tmp72 := lang.Apply(tmp71, []any{sym_locklocal__1__auto__}) + tmp73 := lang.Apply(tmp68, []any{tmp70, tmp72}) + tmp74 := lang.Apply(tmp67, []any{tmp73}) + tmp75 := lang.Apply(tmp66, []any{tmp74}) + tmp76 := lang.Apply(tmp63, []any{tmp65, tmp75}) + tmp77 := lang.Apply(tmp62, []any{tmp76}) + tmp78 := lang.Apply(tmp61, []any{tmp77}) + tmp79 := lang.Apply(tmp58, []any{tmp60, v5, tmp78}) + tmp80 := lang.Apply(tmp57, []any{tmp79}) + tmp81 := lang.Apply(tmp56, []any{tmp80}) + tmp82 := lang.Apply(tmp30, []any{tmp32, tmp45, tmp55, tmp81}) + tmp83 := lang.Apply(tmp29, []any{tmp82}) + tmp84 := lang.Apply(tmp28, []any{tmp83}) + tmp85 := lang.Apply(tmp25, []any{tmp27, tmp84}) + tmp86 := lang.Apply(tmp24, []any{tmp85}) + tmp87 := lang.Apply(tmp23, []any{tmp86}) + tmp88 := lang.Apply(tmp7, []any{tmp9, tmp22, tmp87}) + tmp89 := lang.Apply(tmp6, []any{tmp88}) + return tmp89 } - return tmp14 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_locking = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_locking.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // map { tmp0 := sym_map.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_coll), lang.NewVector(sym_f, sym_c1, sym_c2), lang.NewVector(sym_f, sym_c1, sym_c2, sym_c3), lang.NewVector(sym_f, sym_c1, sym_c2, sym_c3, sym__AMP_, sym_colls)), kw_doc, "Returns a lazy sequence consisting of the result of applying f to\n the set of first items of each coll, followed by applying f to the\n set of second items in each coll, until any one of the colls is\n exhausted. Any remaining items in other colls are ignored. Function\n f should accept number-of-colls arguments. Returns a transducer when\n no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(2719), kw_end_DASH_line, int(2719))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: - v3 := args[0] - _ = v3 - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v5 := args[0] - _ = v5 - var tmp6 lang.FnFunc - tmp6 = lang.NewFnFunc(func(args ...any) any { + v4 := args[0] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - tmp7 := lang.Apply(v5, nil) - return tmp7 + tmp6 := lang.Apply(v4, nil) + return tmp6 case 1: - v7 := args[0] - _ = v7 - tmp8 := lang.Apply(v5, []any{v7}) - return tmp8 + v6 := args[0] + _ = v6 + tmp7 := lang.Apply(v4, []any{v6}) + return tmp7 case 2: - v7 := args[0] + v6 := args[0] + _ = v6 + v7 := args[1] _ = v7 - v8 := args[1] - _ = v8 - tmp9 := lang.Apply(v3, []any{v8}) - tmp10 := lang.Apply(v5, []any{v7, tmp9}) - return tmp10 + tmp8 := lang.Apply(v2, []any{v7}) + tmp9 := lang.Apply(v4, []any{v6, tmp8}) + return tmp9 default: checkArity(args, 2) - v7 := args[0] + v6 := args[0] + _ = v6 + v7 := args[1] _ = v7 - v8 := args[1] + var v8 any = lang.NewList(args[2:]...) _ = v8 - var v9 any = lang.NewList(args[2:]...) - _ = v9 - tmp10 := checkDerefVar(var_glojure_DOT_core_apply) - tmp11 := lang.Apply(tmp10, []any{v3, v8, v9}) - tmp12 := lang.Apply(v5, []any{v7, tmp11}) - return tmp12 + tmp9 := checkDerefVar(var_glojure_DOT_core_apply) + tmp10 := lang.Apply(tmp9, []any{v2, v7, v8}) + tmp11 := lang.Apply(v4, []any{v6, tmp10}) + return tmp11 } }) - tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2730), kw_column, int(7), kw_end_DASH_line, int(2736), kw_end_DASH_column, int(47)) - tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2730), kw_column, int(7), kw_end_DASH_line, int(2736), kw_end_DASH_column, int(47)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) if err != nil { panic(err) } - return tmp8 + return tmp7 }) - tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2729), kw_column, int(5), kw_end_DASH_line, int(2736), kw_end_DASH_column, int(48)) - tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2729), kw_column, int(5), kw_end_DASH_line, int(2736), kw_end_DASH_column, int(48)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) if err != nil { panic(err) } - return tmp6 + return tmp5 case 2: - v3 := args[0] + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] - _ = v4 - var tmp5 lang.FnFunc - tmp5 = lang.NewFnFunc(func(args ...any) any { + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 0) - var tmp6 any + var tmp5 any { // let // let binding "temp__0__auto__" - tmp7 := checkDerefVar(var_glojure_DOT_core_seq) - tmp8 := lang.Apply(tmp7, []any{v4}) - var v9 any = tmp8 - _ = v9 - var tmp10 any - if lang.IsTruthy(v9) { - var tmp11 any + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := lang.Apply(tmp6, []any{v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + var tmp10 any { // let // let binding "s" - var v12 any = v9 - _ = v12 - var tmp13 any - tmp14 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) - tmp15 := lang.Apply(tmp14, []any{v12}) - if lang.IsTruthy(tmp15) { - var tmp16 any + var v11 any = v8 + _ = v11 + var tmp12 any + tmp13 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp14 := lang.Apply(tmp13, []any{v11}) + if lang.IsTruthy(tmp14) { + var tmp15 any { // let // let binding "c" - tmp17 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) - tmp18 := lang.Apply(tmp17, []any{v12}) - var v19 any = tmp18 - _ = v19 + tmp16 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp17 := lang.Apply(tmp16, []any{v11}) + var v18 any = tmp17 + _ = v18 // let binding "size" - tmp20 := checkDerefVar(var_glojure_DOT_core_int) - tmp21 := checkDerefVar(var_glojure_DOT_core_count) - tmp22 := lang.Apply(tmp21, []any{v19}) - tmp23 := lang.Apply(tmp20, []any{tmp22}) - var v24 any = tmp23 - _ = v24 + tmp19 := checkDerefVar(var_glojure_DOT_core_int) + tmp20 := checkDerefVar(var_glojure_DOT_core_count) + tmp21 := lang.Apply(tmp20, []any{v18}) + tmp22 := lang.Apply(tmp19, []any{tmp21}) + var v23 any = tmp22 + _ = v23 // let binding "b" - tmp25 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_buffer) - tmp26 := lang.Apply(tmp25, []any{v24}) - var v27 any = tmp26 - _ = v27 - var tmp28 any + tmp24 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_buffer) + tmp25 := lang.Apply(tmp24, []any{v23}) + var v26 any = tmp25 + _ = v26 + var tmp27 any { // let // let binding "n__0__auto__" - tmp29 := lang.Apply(lang.LongCast, []any{v24}) - var v30 any = tmp29 - _ = v30 - var tmp31 any + tmp28 := lang.Apply(lang.LongCast, []any{v23}) + var v29 any = tmp28 + _ = v29 + var tmp30 any { // let // let binding "i" - var v32 any = int64(0) - _ = v32 + var v31 any = int64(0) + _ = v31 for { - var tmp33 any - tmp34 := checkDerefVar(var_glojure_DOT_core__LT_) - tmp35 := lang.Apply(tmp34, []any{v32, v30}) - if lang.IsTruthy(tmp35) { - tmp36 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_append) - tmp37, _ := lang.FieldOrMethod(v19, "nth") - if reflect.TypeOf(tmp37).Kind() != reflect.Func { + var tmp32 any + tmp33 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp34 := lang.Apply(tmp33, []any{v31, v29}) + if lang.IsTruthy(tmp34) { + tmp35 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_append) + tmp36, _ := lang.FieldOrMethod(v18, "nth") + if reflect.TypeOf(tmp36).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) } - tmp38 := lang.Apply(tmp37, []any{v32}) - tmp39 := lang.Apply(v3, []any{tmp38}) - tmp40 := lang.Apply(tmp36, []any{v27, tmp39}) - _ = tmp40 - tmp42 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) - tmp43 := lang.Apply(tmp42, []any{v32}) - var tmp41 any = tmp43 - v32 = tmp41 + tmp37 := lang.Apply(tmp36, []any{v31}) + tmp38 := lang.Apply(v2, []any{tmp37}) + tmp39 := lang.Apply(tmp35, []any{v26, tmp38}) + _ = tmp39 + tmp41 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp42 := lang.Apply(tmp41, []any{v31}) + var tmp40 any = tmp42 + v31 = tmp40 continue } else { } - tmp31 = tmp33 + tmp30 = tmp32 break } } // end let - tmp28 = tmp31 + tmp27 = tmp30 } // end let - _ = tmp28 - tmp29 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_cons) - tmp30 := checkDerefVar(var_glojure_DOT_core_chunk) - tmp31 := lang.Apply(tmp30, []any{v27}) - tmp32 := checkDerefVar(var_glojure_DOT_core_map) - tmp33 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) - tmp34 := lang.Apply(tmp33, []any{v12}) - tmp35 := lang.Apply(tmp32, []any{v3, tmp34}) - tmp36 := lang.Apply(tmp29, []any{tmp31, tmp35}) - tmp16 = tmp36 + _ = tmp27 + tmp28 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_cons) + tmp29 := checkDerefVar(var_glojure_DOT_core_chunk) + tmp30 := lang.Apply(tmp29, []any{v26}) + tmp31 := checkDerefVar(var_glojure_DOT_core_map) + tmp32 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp33 := lang.Apply(tmp32, []any{v11}) + tmp34 := lang.Apply(tmp31, []any{v2, tmp33}) + tmp35 := lang.Apply(tmp28, []any{tmp30, tmp34}) + tmp15 = tmp35 } // end let - tmp13 = tmp16 + tmp12 = tmp15 } else { - tmp17 := checkDerefVar(var_glojure_DOT_core_cons) - tmp18 := checkDerefVar(var_glojure_DOT_core_first) - tmp19 := lang.Apply(tmp18, []any{v12}) - tmp20 := lang.Apply(v3, []any{tmp19}) - tmp21 := checkDerefVar(var_glojure_DOT_core_map) - tmp22 := checkDerefVar(var_glojure_DOT_core_rest) - tmp23 := lang.Apply(tmp22, []any{v12}) - tmp24 := lang.Apply(tmp21, []any{v3, tmp23}) - tmp25 := lang.Apply(tmp17, []any{tmp20, tmp24}) - tmp13 = tmp25 + tmp16 := checkDerefVar(var_glojure_DOT_core_cons) + tmp17 := checkDerefVar(var_glojure_DOT_core_first) + tmp18 := lang.Apply(tmp17, []any{v11}) + tmp19 := lang.Apply(v2, []any{tmp18}) + tmp20 := checkDerefVar(var_glojure_DOT_core_map) + tmp21 := checkDerefVar(var_glojure_DOT_core_rest) + tmp22 := lang.Apply(tmp21, []any{v11}) + tmp23 := lang.Apply(tmp20, []any{v2, tmp22}) + tmp24 := lang.Apply(tmp16, []any{tmp19, tmp23}) + tmp12 = tmp24 } - tmp11 = tmp13 + tmp10 = tmp12 } // end let - tmp10 = tmp11 + tmp9 = tmp10 } else { } - tmp6 = tmp10 + tmp5 = tmp9 } // end let - return tmp6 + return tmp5 }) - tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) - return tmp6 + tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) + return tmp5 case 3: - v3 := args[0] + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + v4 := args[2] _ = v4 - v5 := args[2] - _ = v5 - var tmp6 lang.FnFunc - tmp6 = lang.NewFnFunc(func(args ...any) any { + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 0) - var tmp7 any + var tmp6 any { // let // let binding "s1" - tmp8 := checkDerefVar(var_glojure_DOT_core_seq) - tmp9 := lang.Apply(tmp8, []any{v4}) - var v10 any = tmp9 - _ = v10 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := lang.Apply(tmp7, []any{v3}) + var v9 any = tmp8 + _ = v9 // let binding "s2" - tmp11 := checkDerefVar(var_glojure_DOT_core_seq) - tmp12 := lang.Apply(tmp11, []any{v5}) - var v13 any = tmp12 - _ = v13 + tmp10 := checkDerefVar(var_glojure_DOT_core_seq) + tmp11 := lang.Apply(tmp10, []any{v4}) + var v12 any = tmp11 + _ = v12 + var tmp13 any var tmp14 any - var tmp15 any { // let // let binding "and__0__auto__" - var v16 any = v10 - _ = v16 - var tmp17 any - if lang.IsTruthy(v16) { - tmp17 = v13 + var v15 any = v9 + _ = v15 + var tmp16 any + if lang.IsTruthy(v15) { + tmp16 = v12 } else { - tmp17 = v16 + tmp16 = v15 } - tmp15 = tmp17 + tmp14 = tmp16 } // end let - if lang.IsTruthy(tmp15) { - tmp16 := checkDerefVar(var_glojure_DOT_core_cons) - tmp17 := checkDerefVar(var_glojure_DOT_core_first) - tmp18 := lang.Apply(tmp17, []any{v10}) - tmp19 := checkDerefVar(var_glojure_DOT_core_first) - tmp20 := lang.Apply(tmp19, []any{v13}) - tmp21 := lang.Apply(v3, []any{tmp18, tmp20}) - tmp22 := checkDerefVar(var_glojure_DOT_core_map) - tmp23 := checkDerefVar(var_glojure_DOT_core_rest) - tmp24 := lang.Apply(tmp23, []any{v10}) - tmp25 := checkDerefVar(var_glojure_DOT_core_rest) - tmp26 := lang.Apply(tmp25, []any{v13}) - tmp27 := lang.Apply(tmp22, []any{v3, tmp24, tmp26}) - tmp28 := lang.Apply(tmp16, []any{tmp21, tmp27}) - tmp14 = tmp28 + if lang.IsTruthy(tmp14) { + tmp15 := checkDerefVar(var_glojure_DOT_core_cons) + tmp16 := checkDerefVar(var_glojure_DOT_core_first) + tmp17 := lang.Apply(tmp16, []any{v9}) + tmp18 := checkDerefVar(var_glojure_DOT_core_first) + tmp19 := lang.Apply(tmp18, []any{v12}) + tmp20 := lang.Apply(v2, []any{tmp17, tmp19}) + tmp21 := checkDerefVar(var_glojure_DOT_core_map) + tmp22 := checkDerefVar(var_glojure_DOT_core_rest) + tmp23 := lang.Apply(tmp22, []any{v9}) + tmp24 := checkDerefVar(var_glojure_DOT_core_rest) + tmp25 := lang.Apply(tmp24, []any{v12}) + tmp26 := lang.Apply(tmp21, []any{v2, tmp23, tmp25}) + tmp27 := lang.Apply(tmp15, []any{tmp20, tmp26}) + tmp13 = tmp27 } else { } - tmp7 = tmp14 + tmp6 = tmp13 } // end let - return tmp7 + return tmp6 }) - tmp7 := lang.Apply(lang.NewLazySeq, []any{tmp6}) - return tmp7 + tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) + return tmp6 case 4: - v3 := args[0] + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + v4 := args[2] _ = v4 - v5 := args[2] + v5 := args[3] _ = v5 - v6 := args[3] - _ = v6 - var tmp7 lang.FnFunc - tmp7 = lang.NewFnFunc(func(args ...any) any { + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 0) - var tmp8 any + var tmp7 any { // let // let binding "s1" - tmp9 := checkDerefVar(var_glojure_DOT_core_seq) - tmp10 := lang.Apply(tmp9, []any{v4}) - var v11 any = tmp10 - _ = v11 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := lang.Apply(tmp8, []any{v3}) + var v10 any = tmp9 + _ = v10 // let binding "s2" - tmp12 := checkDerefVar(var_glojure_DOT_core_seq) - tmp13 := lang.Apply(tmp12, []any{v5}) - var v14 any = tmp13 - _ = v14 + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := lang.Apply(tmp11, []any{v4}) + var v13 any = tmp12 + _ = v13 // let binding "s3" - tmp15 := checkDerefVar(var_glojure_DOT_core_seq) - tmp16 := lang.Apply(tmp15, []any{v6}) - var v17 any = tmp16 - _ = v17 + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := lang.Apply(tmp14, []any{v5}) + var v16 any = tmp15 + _ = v16 + var tmp17 any var tmp18 any - var tmp19 any { // let // let binding "and__0__auto__" - var v20 any = v11 - _ = v20 - var tmp21 any - if lang.IsTruthy(v20) { - var tmp22 any + var v19 any = v10 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + var tmp21 any { // let // let binding "and__0__auto__" - var v23 any = v14 - _ = v23 - var tmp24 any - if lang.IsTruthy(v23) { - tmp24 = v17 + var v22 any = v13 + _ = v22 + var tmp23 any + if lang.IsTruthy(v22) { + tmp23 = v16 } else { - tmp24 = v23 + tmp23 = v22 } - tmp22 = tmp24 + tmp21 = tmp23 } // end let - tmp21 = tmp22 + tmp20 = tmp21 } else { - tmp21 = v20 + tmp20 = v19 } - tmp19 = tmp21 + tmp18 = tmp20 } // end let - if lang.IsTruthy(tmp19) { - tmp20 := checkDerefVar(var_glojure_DOT_core_cons) - tmp21 := checkDerefVar(var_glojure_DOT_core_first) - tmp22 := lang.Apply(tmp21, []any{v11}) - tmp23 := checkDerefVar(var_glojure_DOT_core_first) - tmp24 := lang.Apply(tmp23, []any{v14}) - tmp25 := checkDerefVar(var_glojure_DOT_core_first) - tmp26 := lang.Apply(tmp25, []any{v17}) - tmp27 := lang.Apply(v3, []any{tmp22, tmp24, tmp26}) - tmp28 := checkDerefVar(var_glojure_DOT_core_map) - tmp29 := checkDerefVar(var_glojure_DOT_core_rest) - tmp30 := lang.Apply(tmp29, []any{v11}) - tmp31 := checkDerefVar(var_glojure_DOT_core_rest) - tmp32 := lang.Apply(tmp31, []any{v14}) - tmp33 := checkDerefVar(var_glojure_DOT_core_rest) - tmp34 := lang.Apply(tmp33, []any{v17}) - tmp35 := lang.Apply(tmp28, []any{v3, tmp30, tmp32, tmp34}) - tmp36 := lang.Apply(tmp20, []any{tmp27, tmp35}) - tmp18 = tmp36 - } else { - } - tmp8 = tmp18 - } // end let - return tmp8 - }) - tmp8 := lang.Apply(lang.NewLazySeq, []any{tmp7}) - return tmp8 - default: - checkArity(args, 4) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - var v7 any = lang.NewList(args[4:]...) - _ = v7 - var tmp8 any - { // let - // let binding "step" - var tmp9 lang.FnFunc - { // function step - var v10 lang.FnFunc - tmp9 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v11 := args[0] - _ = v11 - var tmp12 lang.FnFunc - tmp12 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - var tmp13 any - { // let - // let binding "ss" - tmp14 := checkDerefVar(var_glojure_DOT_core_map) - tmp15 := checkDerefVar(var_glojure_DOT_core_seq) - tmp16 := lang.Apply(tmp14, []any{tmp15, v11}) - var v17 any = tmp16 - _ = v17 - var tmp18 any - tmp19 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) - tmp20 := checkDerefVar(var_glojure_DOT_core_identity) - tmp21 := lang.Apply(tmp19, []any{tmp20, v17}) - if lang.IsTruthy(tmp21) { - tmp22 := checkDerefVar(var_glojure_DOT_core_cons) - tmp23 := checkDerefVar(var_glojure_DOT_core_map) - tmp24 := checkDerefVar(var_glojure_DOT_core_first) - tmp25 := lang.Apply(tmp23, []any{tmp24, v17}) - tmp26 := checkDerefVar(var_glojure_DOT_core_map) - tmp27 := checkDerefVar(var_glojure_DOT_core_rest) - tmp28 := lang.Apply(tmp26, []any{tmp27, v17}) - tmp29 := lang.Apply(v10, []any{tmp28}) - tmp30 := lang.Apply(tmp22, []any{tmp25, tmp29}) - tmp18 = tmp30 - } else { - } - tmp13 = tmp18 - } // end let - return tmp13 - }) - tmp13 := lang.Apply(lang.NewLazySeq, []any{tmp12}) - return tmp13 - }) - v10 = tmp9 - _ = v10 - } - tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2761), kw_column, int(15), kw_end_DASH_line, int(2765), kw_end_DASH_column, int(68)) - tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v12 any = tmp11 - _ = v12 - tmp13 := checkDerefVar(var_glojure_DOT_core_map) - var tmp14 lang.FnFunc - tmp14 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v15 := args[0] - _ = v15 - tmp16 := checkDerefVar(var_glojure_DOT_core_apply) - tmp17 := lang.Apply(tmp16, []any{v3, v15}) - return tmp17 - }) - tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2766), kw_column, int(11), kw_end_DASH_line, int(2766), kw_end_DASH_column, int(22)) - tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp17 := checkDerefVar(var_glojure_DOT_core_conj) - tmp18 := lang.Apply(tmp17, []any{v7, v6, v5, v4}) - tmp19 := lang.Apply(v12, []any{tmp18}) - tmp20 := lang.Apply(tmp13, []any{tmp16, tmp19}) - tmp8 = tmp20 - } // end let - return tmp8 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // map-entry? - { - tmp0 := sym_map_DASH_entry_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a map entry", kw_file, "glojure/core.glj", kw_added, "1.8", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(1473), kw_end_DASH_line, int(1473))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp5 := reflect.TypeOf((*lang.MapEntry)(nil)).Elem() - tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) - return tmp6 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // map-indexed - { - tmp0 := sym_map_DASH_indexed.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_coll)), kw_doc, "Returns a lazy sequence consisting of the result of applying f to 0\n and the first item of coll, followed by applying f to 1 and the second\n item in coll, etc, until coll is exhausted. Thus function f should\n accept 2 arguments, index and item. Returns a stateful transducer when\n no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(7309), kw_end_DASH_line, int(7309))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v5 := args[0] - _ = v5 - var tmp6 any - { // let - // let binding "i" - tmp7 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) - tmp8 := lang.Apply(tmp7, []any{int64(-1)}) - var v9 any = tmp8 - _ = v9 - var tmp10 lang.FnFunc - tmp10 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp11 := lang.Apply(v5, nil) - return tmp11 - case 1: - v11 := args[0] - _ = v11 - tmp12 := lang.Apply(v5, []any{v11}) - return tmp12 - case 2: - v11 := args[0] - _ = v11 - v12 := args[1] - _ = v12 - tmp13 := checkDerefVar(var_glojure_DOT_core_inc) - tmp14, ok := lang.FieldOrMethod(v9, "Deref") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v9, "Deref"))) - } - var tmp15 any - switch reflect.TypeOf(tmp14).Kind() { - case reflect.Func: - tmp15 = lang.Apply(tmp14, nil) - default: - tmp15 = tmp14 - } - tmp16 := lang.Apply(tmp13, []any{tmp15}) - tmp17, _ := lang.FieldOrMethod(v9, "reset") - if reflect.TypeOf(tmp17).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) - } - tmp18 := lang.Apply(tmp17, []any{tmp16}) - tmp19 := lang.Apply(v3, []any{tmp18, v12}) - tmp20 := lang.Apply(v5, []any{v11, tmp19}) - return tmp20 - default: - checkArity(args, -1) - panic("unreachable") - } - }) - tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7320), kw_column, int(8), kw_end_DASH_line, int(7324), kw_end_DASH_column, int(48)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp6 = tmp12 - } // end let - return tmp6 - }) - tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7318), kw_column, int(4), kw_end_DASH_line, int(7324), kw_end_DASH_column, int(50)) - tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp6 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - return nil - default: - checkArity(args, -1) - panic("unreachable") - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // map? - { - tmp0 := sym_map_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x implements IPersistentMap", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(5), kw_column, int(2), kw_line, int(167), kw_end_DASH_line, int(171))).(*lang.Symbol) - var tmp2 lang.FnFunc - { // function map? - var v3 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp6 := reflect.TypeOf((*lang.IPersistentMap)(nil)).Elem() - tmp7 := lang.Apply(tmp5, []any{tmp6, v4}) - return tmp7 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(171), kw_column, int(7), kw_end_DASH_line, int(171), kw_end_DASH_column, int(97))).(lang.FnFunc) - v3 = tmp2 - _ = v3 - } - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // mapcat - { - tmp0 := sym_mapcat.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym__AMP_, sym_colls)), kw_doc, "Returns the result of applying concat to the result of applying map\n to f and colls. Thus function f should return a collection. Returns\n a transducer when no collections are provided", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(2775), kw_end_DASH_line, int(2775))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_comp) - tmp5 := checkDerefVar(var_glojure_DOT_core_map) - tmp6 := lang.Apply(tmp5, []any{v3}) - tmp7 := checkDerefVar(var_glojure_DOT_core_cat) - tmp8 := lang.Apply(tmp4, []any{tmp6, tmp7}) - return tmp8 - default: - checkArity(args, 1) - v3 := args[0] - _ = v3 - var v4 any = lang.NewList(args[1:]...) - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_apply) - tmp6 := checkDerefVar(var_glojure_DOT_core_concat) - tmp7 := checkDerefVar(var_glojure_DOT_core_apply) - tmp8 := checkDerefVar(var_glojure_DOT_core_map) - tmp9 := lang.Apply(tmp7, []any{tmp8, v3, v4}) - tmp10 := lang.Apply(tmp5, []any{tmp6, tmp9}) - return tmp10 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // mapv - { - tmp0 := sym_mapv.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_coll), lang.NewVector(sym_f, sym_c1, sym_c2), lang.NewVector(sym_f, sym_c1, sym_c2, sym_c3), lang.NewVector(sym_f, sym_c1, sym_c2, sym_c3, sym__AMP_, sym_colls)), kw_doc, "Returns a vector consisting of the result of applying f to the\n set of first items of each coll, followed by applying f to the set\n of second items in each coll, until any one of the colls is\n exhausted. Any remaining items in other colls are ignored. Function\n f should accept number-of-colls arguments.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.4", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(6943), kw_end_DASH_line, int(6943))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) - tmp6 := checkDerefVar(var_glojure_DOT_core_reduce) - var tmp7 lang.FnFunc - tmp7 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v8 := args[0] - _ = v8 - v9 := args[1] - _ = v9 - tmp10 := checkDerefVar(var_glojure_DOT_core_conj_BANG_) - tmp11 := lang.Apply(v3, []any{v9}) - tmp12 := lang.Apply(tmp10, []any{v8, tmp11}) - return tmp12 + if lang.IsTruthy(tmp18) { + tmp19 := checkDerefVar(var_glojure_DOT_core_cons) + tmp20 := checkDerefVar(var_glojure_DOT_core_first) + tmp21 := lang.Apply(tmp20, []any{v10}) + tmp22 := checkDerefVar(var_glojure_DOT_core_first) + tmp23 := lang.Apply(tmp22, []any{v13}) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v16}) + tmp26 := lang.Apply(v2, []any{tmp21, tmp23, tmp25}) + tmp27 := checkDerefVar(var_glojure_DOT_core_map) + tmp28 := checkDerefVar(var_glojure_DOT_core_rest) + tmp29 := lang.Apply(tmp28, []any{v10}) + tmp30 := checkDerefVar(var_glojure_DOT_core_rest) + tmp31 := lang.Apply(tmp30, []any{v13}) + tmp32 := checkDerefVar(var_glojure_DOT_core_rest) + tmp33 := lang.Apply(tmp32, []any{v16}) + tmp34 := lang.Apply(tmp27, []any{v2, tmp29, tmp31, tmp33}) + tmp35 := lang.Apply(tmp19, []any{tmp26, tmp34}) + tmp17 = tmp35 + } else { + } + tmp7 = tmp17 + } // end let + return tmp7 }) - tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6952), kw_column, int(18), kw_end_DASH_line, int(6952), kw_end_DASH_column, int(43)) - tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp10 := checkDerefVar(var_glojure_DOT_core_transient) - tmp11 := lang.NewVector() - tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6952), kw_column, int(56), kw_end_DASH_line, int(6952), kw_end_DASH_column, int(57)) - tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp14 := lang.Apply(tmp10, []any{tmp13}) - tmp15 := lang.Apply(tmp6, []any{tmp9, tmp14, v4}) - tmp16 := lang.Apply(tmp5, []any{tmp15}) - return tmp16 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6 := checkDerefVar(var_glojure_DOT_core_into) - tmp7 := lang.NewVector() - tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6955), kw_column, int(12), kw_end_DASH_line, int(6955), kw_end_DASH_column, int(13)) - tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp10 := checkDerefVar(var_glojure_DOT_core_map) - tmp11 := lang.Apply(tmp10, []any{v3, v4, v5}) - tmp12 := lang.Apply(tmp6, []any{tmp9, tmp11}) - return tmp12 - case 4: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - tmp7 := checkDerefVar(var_glojure_DOT_core_into) - tmp8 := lang.NewVector() - tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6957), kw_column, int(12), kw_end_DASH_line, int(6957), kw_end_DASH_column, int(13)) - tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp11 := checkDerefVar(var_glojure_DOT_core_map) - tmp12 := lang.Apply(tmp11, []any{v3, v4, v5, v6}) - tmp13 := lang.Apply(tmp7, []any{tmp10, tmp12}) - return tmp13 + tmp7 := lang.Apply(lang.NewLazySeq, []any{tmp6}) + return tmp7 default: checkArity(args, 4) - v3 := args[0] + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + v4 := args[2] _ = v4 - v5 := args[2] + v5 := args[3] _ = v5 - v6 := args[3] + var v6 any = lang.NewList(args[4:]...) _ = v6 - var v7 any = lang.NewList(args[4:]...) - _ = v7 - tmp8 := checkDerefVar(var_glojure_DOT_core_into) - tmp9 := lang.NewVector() - tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6959), kw_column, int(12), kw_end_DASH_line, int(6959), kw_end_DASH_column, int(13)) - tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp12 := checkDerefVar(var_glojure_DOT_core_apply) - tmp13 := checkDerefVar(var_glojure_DOT_core_map) - tmp14 := lang.Apply(tmp12, []any{tmp13, v3, v4, v5, v6, v7}) - tmp15 := lang.Apply(tmp8, []any{tmp11, tmp14}) - return tmp15 + var tmp7 any + { // let + // let binding "step" + var tmp8 lang.FnFunc + { // function step + var v9 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v10 := args[0] + _ = v10 + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp12 any + { // let + // let binding "ss" + tmp13 := checkDerefVar(var_glojure_DOT_core_map) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := lang.Apply(tmp13, []any{tmp14, v10}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + tmp18 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + tmp19 := checkDerefVar(var_glojure_DOT_core_identity) + tmp20 := lang.Apply(tmp18, []any{tmp19, v16}) + if lang.IsTruthy(tmp20) { + tmp21 := checkDerefVar(var_glojure_DOT_core_cons) + tmp22 := checkDerefVar(var_glojure_DOT_core_map) + tmp23 := checkDerefVar(var_glojure_DOT_core_first) + tmp24 := lang.Apply(tmp22, []any{tmp23, v16}) + tmp25 := checkDerefVar(var_glojure_DOT_core_map) + tmp26 := checkDerefVar(var_glojure_DOT_core_rest) + tmp27 := lang.Apply(tmp25, []any{tmp26, v16}) + tmp28 := lang.Apply(v9, []any{tmp27}) + tmp29 := lang.Apply(tmp21, []any{tmp24, tmp28}) + tmp17 = tmp29 + } else { + } + tmp12 = tmp17 + } // end let + return tmp12 + }) + tmp12 := lang.Apply(lang.NewLazySeq, []any{tmp11}) + return tmp12 + }) + v9 = tmp8 + _ = v9 + } + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2761), kw_column, int(15), kw_end_DASH_line, int(2765), kw_end_DASH_column, int(68)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v11 any = tmp10 + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_map) + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v14 := args[0] + _ = v14 + tmp15 := checkDerefVar(var_glojure_DOT_core_apply) + tmp16 := lang.Apply(tmp15, []any{v2, v14}) + return tmp16 + }) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2766), kw_column, int(11), kw_end_DASH_line, int(2766), kw_end_DASH_column, int(22)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp16 := checkDerefVar(var_glojure_DOT_core_conj) + tmp17 := lang.Apply(tmp16, []any{v6, v5, v4, v3}) + tmp18 := lang.Apply(v11, []any{tmp17}) + tmp19 := lang.Apply(tmp12, []any{tmp15, tmp18}) + tmp7 = tmp19 + } // end let + return tmp7 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_map = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_map.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // max @@ -33943,1378 +27362,455 @@ func LoadNS() { }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp0 := sym_max.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns the greatest of the nums.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(1108), kw_end_DASH_line, int(1108))).(*lang.Symbol) - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: - v5 := args[0] - _ = v5 - return v5 - case 2: - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - tmp7, _ := lang.FieldOrMethod(lang.Numbers, "Max") - if reflect.TypeOf(tmp7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Max is not a function"))) - } - tmp8 := lang.Apply(tmp7, []any{v5, v6}) - return tmp8 - default: - checkArity(args, 2) - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - var v7 any = lang.NewList(args[2:]...) - _ = v7 - tmp8 := checkDerefVar(var_glojure_DOT_core_reduce1) - tmp9 := checkDerefVar(var_glojure_DOT_core_max) - tmp10 := checkDerefVar(var_glojure_DOT_core_max) - tmp11 := lang.Apply(tmp10, []any{v5, v6}) - tmp12 := lang.Apply(tmp8, []any{tmp9, tmp11, v7}) - return tmp12 - } - }) - tmp4 = tmp4.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp3 := ns.InternWithValue(tmp0, tmp4, true) - if tmp0.Meta() != nil { - tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // max-key - { - tmp0 := sym_max_DASH_key.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_k, sym_x), lang.NewVector(sym_k, sym_x, sym_y), lang.NewVector(sym_k, sym_x, sym_y, sym__AMP_, sym_more)), kw_doc, "Returns the x for which (k x), a number, is greatest.\n\n If there are multiple such xs, the last one is returned.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(5013), kw_end_DASH_line, int(5013))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] + v4 := args[0] _ = v4 return v4 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var tmp6 any - tmp7 := checkDerefVar(var_glojure_DOT_core__GT_) - tmp8 := lang.Apply(v3, []any{v4}) - tmp9 := lang.Apply(v3, []any{v5}) - tmp10 := lang.Apply(tmp7, []any{tmp8, tmp9}) - if lang.IsTruthy(tmp10) { - tmp6 = v4 - } else { - tmp6 = v5 - } - return tmp6 - default: - checkArity(args, 3) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any - { // let - // let binding "kx" - tmp8 := lang.Apply(v3, []any{v4}) - var v9 any = tmp8 - _ = v9 - // let binding "ky" - tmp10 := lang.Apply(v3, []any{v5}) - var v11 any = tmp10 - _ = v11 - // let binding "vec__55" - var tmp12 any - tmp13 := checkDerefVar(var_glojure_DOT_core__GT_) - tmp14 := lang.Apply(tmp13, []any{v9, v11}) - if lang.IsTruthy(tmp14) { - tmp15 := lang.NewVector(v4, v9) - tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5023), kw_column, int(31), kw_end_DASH_line, int(5023), kw_end_DASH_column, int(36)) - tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp12 = tmp17 - } else { - tmp18 := lang.NewVector(v5, v11) - tmp19 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5023), kw_column, int(38), kw_end_DASH_line, int(5023), kw_end_DASH_column, int(43)) - tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp12 = tmp20 - } - var v21 any = tmp12 - _ = v21 - // let binding "v" - tmp22 := checkDerefVar(var_glojure_DOT_core_nth) - tmp23 := lang.Apply(tmp22, []any{v21, int64(0), nil}) - var v24 any = tmp23 - _ = v24 - // let binding "kv" - tmp25 := checkDerefVar(var_glojure_DOT_core_nth) - tmp26 := lang.Apply(tmp25, []any{v21, int64(1), nil}) - var v27 any = tmp26 - _ = v27 - var tmp28 any - { // let - // let binding "v" - var v29 any = v24 - _ = v29 - // let binding "kv" - var v30 any = v27 - _ = v30 - // let binding "more" - var v31 any = v6 - _ = v31 - for { - var tmp32 any - if lang.IsTruthy(v31) { - var tmp33 any - { // let - // let binding "w" - tmp34 := checkDerefVar(var_glojure_DOT_core_first) - tmp35 := lang.Apply(tmp34, []any{v31}) - var v36 any = tmp35 - _ = v36 - // let binding "kw" - tmp37 := lang.Apply(v3, []any{v36}) - var v38 any = tmp37 - _ = v38 - var tmp39 any - tmp40 := checkDerefVar(var_glojure_DOT_core__GT__EQ_) - tmp41 := lang.Apply(tmp40, []any{v38, v30}) - if lang.IsTruthy(tmp41) { - var tmp42 any = v36 - var tmp43 any = v38 - tmp45 := checkDerefVar(var_glojure_DOT_core_next) - tmp46 := lang.Apply(tmp45, []any{v31}) - var tmp44 any = tmp46 - v29 = tmp42 - v30 = tmp43 - v31 = tmp44 - continue - } else { - var tmp47 any = v29 - var tmp48 any = v30 - tmp50 := checkDerefVar(var_glojure_DOT_core_next) - tmp51 := lang.Apply(tmp50, []any{v31}) - var tmp49 any = tmp51 - v29 = tmp47 - v30 = tmp48 - v31 = tmp49 - continue - } - tmp33 = tmp39 - } // end let - tmp32 = tmp33 - } else { - tmp32 = v29 - } - tmp28 = tmp32 - break - } - } // end let - tmp7 = tmp28 - } // end let - return tmp7 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // max-mask-bits - { - tmp0 := sym_max_DASH_mask_DASH_bits.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(6601), kw_column, int(6), kw_end_DASH_line, int(6601), kw_end_DASH_column, int(28), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, int64(13), true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // max-switch-table-size - { - tmp0 := sym_max_DASH_switch_DASH_table_DASH_size.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(6602), kw_column, int(6), kw_end_DASH_line, int(6602), kw_end_DASH_column, int(36), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, int64(8192), true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // maybe-destructured - { - tmp0 := sym_maybe_DASH_destructured.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(4514), kw_column, int(7), kw_end_DASH_line, int(4515), kw_end_DASH_column, int(20), kw_arglists, lang.NewList(lang.NewVector(sym_params, sym_body)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - tmp6 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) - tmp7 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) - tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) - if lang.IsTruthy(tmp8) { - tmp9 := checkDerefVar(var_glojure_DOT_core_cons) - tmp10 := lang.Apply(tmp9, []any{v3, v4}) - tmp5 = tmp10 - } else { - var tmp11 any - { // let - // let binding "params" - var v12 any = v3 - _ = v12 - // let binding "new-params" - tmp13 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) - tmp14 := lang.NewVector() - tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4520), kw_column, int(34), kw_end_DASH_line, int(4520), kw_end_DASH_column, int(35)) - tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp17 := checkDerefVar(var_glojure_DOT_core_meta) - tmp18 := lang.Apply(tmp17, []any{v12}) - tmp19 := lang.Apply(tmp13, []any{tmp16, tmp18}) - var v20 any = tmp19 - _ = v20 - // let binding "lets" - tmp21 := lang.NewVector() - tmp22 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4521), kw_column, int(17), kw_end_DASH_line, int(4521), kw_end_DASH_column, int(18)) - tmp23, err := lang.WithMeta(tmp21, tmp22.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v24 any = tmp23 - _ = v24 - for { - var tmp25 any - if lang.IsTruthy(v12) { - var tmp26 any - tmp27 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) - tmp28 := checkDerefVar(var_glojure_DOT_core_first) - tmp29 := lang.Apply(tmp28, []any{v12}) - tmp30 := lang.Apply(tmp27, []any{tmp29}) - if lang.IsTruthy(tmp30) { - tmp32 := checkDerefVar(var_glojure_DOT_core_next) - tmp33 := lang.Apply(tmp32, []any{v12}) - var tmp31 any = tmp33 - tmp35 := checkDerefVar(var_glojure_DOT_core_conj) - tmp36 := checkDerefVar(var_glojure_DOT_core_first) - tmp37 := lang.Apply(tmp36, []any{v12}) - tmp38 := lang.Apply(tmp35, []any{v20, tmp37}) - var tmp34 any = tmp38 - var tmp39 any = v24 - v12 = tmp31 - v20 = tmp34 - v24 = tmp39 - continue - } else { - var tmp40 any - { // let - // let binding "gparam" - tmp41 := checkDerefVar(var_glojure_DOT_core_gensym) - tmp42 := lang.Apply(tmp41, []any{"p__"}) - var v43 any = tmp42 - _ = v43 - tmp45 := checkDerefVar(var_glojure_DOT_core_next) - tmp46 := lang.Apply(tmp45, []any{v12}) - var tmp44 any = tmp46 - tmp48 := checkDerefVar(var_glojure_DOT_core_conj) - tmp49 := lang.Apply(tmp48, []any{v20, v43}) - var tmp47 any = tmp49 - tmp51 := checkDerefVar(var_glojure_DOT_core_conj) - tmp52 := checkDerefVar(var_glojure_DOT_core_conj) - tmp53 := checkDerefVar(var_glojure_DOT_core_first) - tmp54 := lang.Apply(tmp53, []any{v12}) - tmp55 := lang.Apply(tmp52, []any{v24, tmp54}) - tmp56 := lang.Apply(tmp51, []any{tmp55, v43}) - var tmp50 any = tmp56 - v12 = tmp44 - v20 = tmp47 - v24 = tmp50 - continue - } // end let - tmp26 = tmp40 - } - tmp25 = tmp26 - } else { - tmp41 := checkDerefVar(var_glojure_DOT_core_seq) - tmp42 := checkDerefVar(var_glojure_DOT_core_concat) - tmp43 := checkDerefVar(var_glojure_DOT_core_list) - tmp44 := lang.Apply(tmp43, []any{v20}) - tmp45 := checkDerefVar(var_glojure_DOT_core_list) - tmp46 := checkDerefVar(var_glojure_DOT_core_seq) - tmp47 := checkDerefVar(var_glojure_DOT_core_concat) - tmp48 := checkDerefVar(var_glojure_DOT_core_list) - tmp49 := lang.Apply(tmp48, []any{sym_glojure_DOT_core_SLASH_let}) - tmp50 := checkDerefVar(var_glojure_DOT_core_list) - tmp51 := lang.Apply(tmp50, []any{v24}) - tmp52 := lang.Apply(tmp47, []any{tmp49, tmp51, v4}) - tmp53 := lang.Apply(tmp46, []any{tmp52}) - tmp54 := lang.Apply(tmp45, []any{tmp53}) - tmp55 := lang.Apply(tmp42, []any{tmp44, tmp54}) - tmp56 := lang.Apply(tmp41, []any{tmp55}) - tmp25 = tmp56 - } - tmp11 = tmp25 - break - } - } // end let - tmp5 = tmp11 - } - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // maybe-min-hash - { - tmp0 := sym_maybe_DASH_min_DASH_hash.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_hashes)), kw_doc, "takes a collection of hashes and returns [shift mask] or nil if none found", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(8), kw_line, int(6604), kw_end_DASH_line, int(6604), kw_private, true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_first) - tmp5 := checkDerefVar(var_glojure_DOT_core_filter) - var tmp6 lang.FnFunc - tmp6 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v7 := args[0] - _ = v7 - var tmp8 any - { // let - // let binding "vec__151" - var v9 any = v7 - _ = v9 - // let binding "s" - tmp10 := checkDerefVar(var_glojure_DOT_core_nth) - tmp11 := lang.Apply(tmp10, []any{v9, int64(0), nil}) - var v12 any = tmp11 - _ = v12 - // let binding "m" - tmp13 := checkDerefVar(var_glojure_DOT_core_nth) - tmp14 := lang.Apply(tmp13, []any{v9, int64(1), nil}) - var v15 any = tmp14 - _ = v15 - tmp16 := checkDerefVar(var_glojure_DOT_core_apply) - tmp17 := checkDerefVar(var_glojure_DOT_core_distinct_QMARK_) - tmp18 := checkDerefVar(var_glojure_DOT_core_map) - var tmp19 lang.FnFunc - tmp19 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v20 := args[0] - _ = v20 - tmp21 := checkDerefVar(var_glojure_DOT_core_shift_DASH_mask) - tmp22 := lang.Apply(tmp21, []any{v12, v15, v20}) - return tmp22 - }) - tmp20 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6609), kw_column, int(37), kw_end_DASH_line, int(6609), kw_end_DASH_column, int(55)) - tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp22 := lang.Apply(tmp18, []any{tmp21, v3}) - tmp23 := lang.Apply(tmp16, []any{tmp17, tmp22}) - tmp8 = tmp23 - } // end let - return tmp8 - }) - tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6608), kw_column, int(13), kw_end_DASH_line, int(6609), kw_end_DASH_column, int(65)) - tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var tmp9 any - { // let - // let binding "iter__0__auto__" - var tmp10 lang.FnFunc - { // function iter__154 - var v11 lang.FnFunc - tmp10 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v12 := args[0] - _ = v12 - var tmp13 lang.FnFunc - tmp13 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - var tmp14 any - { // let - // let binding "s__155" - var v15 any = v12 - _ = v15 - for { - var tmp16 any - { // let - // let binding "temp__0__auto__" - tmp17 := checkDerefVar(var_glojure_DOT_core_seq) - tmp18 := lang.Apply(tmp17, []any{v15}) - var v19 any = tmp18 - _ = v19 - var tmp20 any - if lang.IsTruthy(v19) { - var tmp21 any - { // let - // let binding "xs__0__auto__" - var v22 any = v19 - _ = v22 - var tmp23 any - { // let - // let binding "mask" - tmp24 := checkDerefVar(var_glojure_DOT_core_first) - tmp25 := lang.Apply(tmp24, []any{v22}) - var v26 any = tmp25 - _ = v26 - var tmp27 any - { // let - // let binding "iterys__0__auto__" - var tmp28 lang.FnFunc - { // function iter__156 - var v29 lang.FnFunc - tmp28 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v30 := args[0] - _ = v30 - var tmp31 lang.FnFunc - tmp31 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - var tmp32 any - { // let - // let binding "s__157" - var v33 any = v30 - _ = v33 - for { - var tmp34 any - { // let - // let binding "temp__0__auto__" - tmp35 := checkDerefVar(var_glojure_DOT_core_seq) - tmp36 := lang.Apply(tmp35, []any{v33}) - var v37 any = tmp36 - _ = v37 - var tmp38 any - if lang.IsTruthy(v37) { - var tmp39 any - { // let - // let binding "s__157" - var v40 any = v37 - _ = v40 - var tmp41 any - tmp42 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) - tmp43 := lang.Apply(tmp42, []any{v40}) - if lang.IsTruthy(tmp43) { - var tmp44 any - { // let - // let binding "c__0__auto__" - tmp45 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) - tmp46 := lang.Apply(tmp45, []any{v40}) - var v47 any = tmp46 - _ = v47 - // let binding "size__1__auto__" - tmp48 := checkDerefVar(var_glojure_DOT_core_int) - tmp49 := checkDerefVar(var_glojure_DOT_core_count) - tmp50 := lang.Apply(tmp49, []any{v47}) - tmp51 := lang.Apply(tmp48, []any{tmp50}) - var v52 any = tmp51 - _ = v52 - // let binding "b__159" - tmp53 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_buffer) - tmp54 := lang.Apply(tmp53, []any{v52}) - var v55 any = tmp54 - _ = v55 - var tmp56 any - var tmp57 any - { // let - // let binding "i__158" - tmp58 := checkDerefVar(var_glojure_DOT_core_int) - tmp59 := lang.Apply(tmp58, []any{int64(0)}) - var v60 any = tmp59 - _ = v60 - for { - var tmp61 any - tmp62 := checkDerefVar(var_glojure_DOT_core__LT_) - tmp63 := lang.Apply(tmp62, []any{v60, v52}) - if lang.IsTruthy(tmp63) { - var tmp64 any - { // let - // let binding "shift" - tmp65, _ := lang.FieldOrMethod(v47, "nth") - if reflect.TypeOf(tmp65).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) - } - tmp66 := lang.Apply(tmp65, []any{v60}) - var v67 any = tmp66 - _ = v67 - tmp68 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_append) - tmp69 := lang.NewVector(v67, v26) - tmp70 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6612), kw_column, int(15), kw_end_DASH_line, int(6612), kw_end_DASH_column, int(26)) - tmp71, err := lang.WithMeta(tmp69, tmp70.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp72 := lang.Apply(tmp68, []any{v55, tmp71}) - _ = tmp72 - tmp74 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) - tmp75 := lang.Apply(tmp74, []any{v60}) - var tmp73 any = tmp75 - v60 = tmp73 - continue - } // end let - tmp61 = tmp64 - } else { - tmp61 = true - } - tmp57 = tmp61 - break - } - } // end let - if lang.IsTruthy(tmp57) { - tmp58 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_cons) - tmp59 := checkDerefVar(var_glojure_DOT_core_chunk) - tmp60 := lang.Apply(tmp59, []any{v55}) - tmp61 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) - tmp62 := lang.Apply(tmp61, []any{v40}) - tmp63 := lang.Apply(v29, []any{tmp62}) - tmp64 := lang.Apply(tmp58, []any{tmp60, tmp63}) - tmp56 = tmp64 - } else { - tmp65 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_cons) - tmp66 := checkDerefVar(var_glojure_DOT_core_chunk) - tmp67 := lang.Apply(tmp66, []any{v55}) - tmp68 := lang.Apply(tmp65, []any{tmp67, nil}) - tmp56 = tmp68 - } - tmp44 = tmp56 - } // end let - tmp41 = tmp44 - } else { - var tmp45 any - { // let - // let binding "shift" - tmp46 := checkDerefVar(var_glojure_DOT_core_first) - tmp47 := lang.Apply(tmp46, []any{v40}) - var v48 any = tmp47 - _ = v48 - tmp49 := checkDerefVar(var_glojure_DOT_core_cons) - tmp50 := lang.NewVector(v48, v26) - tmp51 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6612), kw_column, int(15), kw_end_DASH_line, int(6612), kw_end_DASH_column, int(26)) - tmp52, err := lang.WithMeta(tmp50, tmp51.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp53 := checkDerefVar(var_glojure_DOT_core_rest) - tmp54 := lang.Apply(tmp53, []any{v40}) - tmp55 := lang.Apply(v29, []any{tmp54}) - tmp56 := lang.Apply(tmp49, []any{tmp52, tmp55}) - tmp45 = tmp56 - } // end let - tmp41 = tmp45 - } - tmp39 = tmp41 - } // end let - tmp38 = tmp39 - } else { - } - tmp34 = tmp38 - } // end let - tmp32 = tmp34 - break - } - } // end let - return tmp32 - }) - tmp32 := lang.Apply(lang.NewLazySeq, []any{tmp31}) - return tmp32 - }) - v29 = tmp28 - _ = v29 - } - var v29 any = tmp28 - _ = v29 - // let binding "fs__1__auto__" - tmp30 := checkDerefVar(var_glojure_DOT_core_seq) - tmp31 := checkDerefVar(var_glojure_DOT_core_range) - tmp32 := lang.Apply(tmp31, []any{int64(0), int64(31)}) - tmp33 := lang.Apply(v29, []any{tmp32}) - tmp34 := lang.Apply(tmp30, []any{tmp33}) - var v35 any = tmp34 - _ = v35 - var tmp36 any - if lang.IsTruthy(v35) { - tmp37 := checkDerefVar(var_glojure_DOT_core_concat) - tmp38 := checkDerefVar(var_glojure_DOT_core_rest) - tmp39 := lang.Apply(tmp38, []any{v15}) - tmp40 := lang.Apply(v11, []any{tmp39}) - tmp41 := lang.Apply(tmp37, []any{v35, tmp40}) - tmp36 = tmp41 - } else { - tmp43 := checkDerefVar(var_glojure_DOT_core_rest) - tmp44 := lang.Apply(tmp43, []any{v15}) - var tmp42 any = tmp44 - v15 = tmp42 - continue - } - tmp27 = tmp36 - } // end let - tmp23 = tmp27 - } // end let - tmp21 = tmp23 - } // end let - tmp20 = tmp21 - } else { - } - tmp16 = tmp20 - } // end let - tmp14 = tmp16 - break - } - } // end let - return tmp14 - }) - tmp14 := lang.Apply(lang.NewLazySeq, []any{tmp13}) - return tmp14 - }) - v11 = tmp10 - _ = v11 - } - var v11 any = tmp10 - _ = v11 - tmp12 := checkDerefVar(var_glojure_DOT_core_map) - var tmp13 lang.FnFunc - tmp13 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v14 := args[0] - _ = v14 - tmp15 := checkDerefVar(var_glojure_DOT_core_dec) - tmp16 := checkDerefVar(var_glojure_DOT_core_bit_DASH_shift_DASH_left) - tmp17 := lang.Apply(tmp16, []any{int64(1), v14}) - tmp18 := lang.Apply(tmp15, []any{tmp17}) - return tmp18 - }) - tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6610), kw_column, int(29), kw_end_DASH_line, int(6610), kw_end_DASH_column, int(55)) - tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) - if err != nil { - panic(err) + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Max") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Max is not a function"))) } - tmp16 := checkDerefVar(var_glojure_DOT_core_range) - tmp17 := checkDerefVar(var_glojure_DOT_core_inc) - tmp18 := checkDerefVar(var_glojure_DOT_core_max_DASH_mask_DASH_bits) - tmp19 := lang.Apply(tmp17, []any{tmp18}) - tmp20 := lang.Apply(tmp16, []any{int64(1), tmp19}) - tmp21 := lang.Apply(tmp12, []any{tmp15, tmp20}) - tmp22 := lang.Apply(v11, []any{tmp21}) - tmp9 = tmp22 - } // end let - tmp10 := lang.Apply(tmp5, []any{tmp8, tmp9}) - tmp11 := lang.Apply(tmp4, []any{tmp10}) - return tmp11 + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp8 := checkDerefVar(var_glojure_DOT_core_max) + tmp9 := checkDerefVar(var_glojure_DOT_core_max) + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) + return tmp11 + } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_max = ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_max.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // memfn + // max-key { - tmp0 := sym_memfn.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym__AMP_, sym_args)), kw_doc, "Expands into code that creates a fn that expects to be passed an\n object and any args and calls the named instance method on the\n object passing the args. Use when you want to treat a Java method as\n a first-class fn. name may be type-hinted with the method receiver's\n type in order to avoid reflective calls.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(11), kw_line, int(3872), kw_end_DASH_line, int(3872))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_max_DASH_key.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_k, sym_x), lang.NewVector(sym_k, sym_x, sym_y), lang.NewVector(sym_k, sym_x, sym_y, sym__AMP_, sym_more)), kw_doc, "Returns the x for which (k x), a number, is greatest.\n\n If there are multiple such xs, the last one is returned.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(5013), kw_end_DASH_line, int(5013))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + return v3 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__GT_) + tmp7 := lang.Apply(v2, []any{v3}) + tmp8 := lang.Apply(v2, []any{v4}) + tmp9 := lang.Apply(tmp6, []any{tmp7, tmp8}) + if lang.IsTruthy(tmp9) { + tmp5 = v3 + } else { + tmp5 = v4 + } + return tmp5 default: checkArity(args, 3) - v3 := args[0] + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + v4 := args[2] _ = v4 - v5 := args[2] + var v5 any = lang.NewList(args[3:]...) _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any + var tmp6 any { // let - // let binding "t" - tmp8 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) - tmp9 := checkDerefVar(var_glojure_DOT_core_gensym) - tmp10 := lang.Apply(tmp9, []any{"target"}) - tmp11 := checkDerefVar(var_glojure_DOT_core_meta) - tmp12 := lang.Apply(tmp11, []any{v5}) - tmp13 := lang.Apply(tmp8, []any{tmp10, tmp12}) - var v14 any = tmp13 - _ = v14 - tmp15 := checkDerefVar(var_glojure_DOT_core_seq) - tmp16 := checkDerefVar(var_glojure_DOT_core_concat) - tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{sym_glojure_DOT_core_SLASH_fn}) - tmp19 := checkDerefVar(var_glojure_DOT_core_list) - tmp20 := checkDerefVar(var_glojure_DOT_core_apply) - tmp21 := checkDerefVar(var_glojure_DOT_core_vector) - tmp22 := checkDerefVar(var_glojure_DOT_core_seq) - tmp23 := checkDerefVar(var_glojure_DOT_core_concat) - tmp24 := checkDerefVar(var_glojure_DOT_core_list) - tmp25 := lang.Apply(tmp24, []any{v14}) - tmp26 := lang.Apply(tmp23, []any{tmp25, v6}) - tmp27 := lang.Apply(tmp22, []any{tmp26}) - tmp28 := lang.Apply(tmp20, []any{tmp21, tmp27}) - tmp29 := lang.Apply(tmp19, []any{tmp28}) - tmp30 := checkDerefVar(var_glojure_DOT_core_list) - tmp31 := checkDerefVar(var_glojure_DOT_core_seq) - tmp32 := checkDerefVar(var_glojure_DOT_core_concat) - tmp33 := checkDerefVar(var_glojure_DOT_core_list) - tmp34 := lang.Apply(tmp33, []any{sym__DOT_}) - tmp35 := checkDerefVar(var_glojure_DOT_core_list) - tmp36 := lang.Apply(tmp35, []any{v14}) - tmp37 := checkDerefVar(var_glojure_DOT_core_list) - tmp38 := checkDerefVar(var_glojure_DOT_core_seq) - tmp39 := checkDerefVar(var_glojure_DOT_core_concat) - tmp40 := checkDerefVar(var_glojure_DOT_core_list) - tmp41 := lang.Apply(tmp40, []any{v5}) - tmp42 := lang.Apply(tmp39, []any{tmp41, v6}) - tmp43 := lang.Apply(tmp38, []any{tmp42}) - tmp44 := lang.Apply(tmp37, []any{tmp43}) - tmp45 := lang.Apply(tmp32, []any{tmp34, tmp36, tmp44}) - tmp46 := lang.Apply(tmp31, []any{tmp45}) - tmp47 := lang.Apply(tmp30, []any{tmp46}) - tmp48 := lang.Apply(tmp16, []any{tmp18, tmp29, tmp47}) - tmp49 := lang.Apply(tmp15, []any{tmp48}) - tmp7 = tmp49 + // let binding "kx" + tmp7 := lang.Apply(v2, []any{v3}) + var v8 any = tmp7 + _ = v8 + // let binding "ky" + tmp9 := lang.Apply(v2, []any{v4}) + var v10 any = tmp9 + _ = v10 + // let binding "vec__55" + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core__GT_) + tmp13 := lang.Apply(tmp12, []any{v8, v10}) + if lang.IsTruthy(tmp13) { + tmp14 := lang.NewVector(v3, v8) + tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5023), kw_column, int(31), kw_end_DASH_line, int(5023), kw_end_DASH_column, int(36)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp11 = tmp16 + } else { + tmp17 := lang.NewVector(v4, v10) + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5023), kw_column, int(38), kw_end_DASH_line, int(5023), kw_end_DASH_column, int(43)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp11 = tmp19 + } + var v20 any = tmp11 + _ = v20 + // let binding "v" + tmp21 := checkDerefVar(var_glojure_DOT_core_nth) + tmp22 := lang.Apply(tmp21, []any{v20, int64(0), nil}) + var v23 any = tmp22 + _ = v23 + // let binding "kv" + tmp24 := checkDerefVar(var_glojure_DOT_core_nth) + tmp25 := lang.Apply(tmp24, []any{v20, int64(1), nil}) + var v26 any = tmp25 + _ = v26 + var tmp27 any + { // let + // let binding "v" + var v28 any = v23 + _ = v28 + // let binding "kv" + var v29 any = v26 + _ = v29 + // let binding "more" + var v30 any = v5 + _ = v30 + for { + var tmp31 any + if lang.IsTruthy(v30) { + var tmp32 any + { // let + // let binding "w" + tmp33 := checkDerefVar(var_glojure_DOT_core_first) + tmp34 := lang.Apply(tmp33, []any{v30}) + var v35 any = tmp34 + _ = v35 + // let binding "kw" + tmp36 := lang.Apply(v2, []any{v35}) + var v37 any = tmp36 + _ = v37 + var tmp38 any + tmp39 := checkDerefVar(var_glojure_DOT_core__GT__EQ_) + tmp40 := lang.Apply(tmp39, []any{v37, v29}) + if lang.IsTruthy(tmp40) { + var tmp41 any = v35 + var tmp42 any = v37 + tmp44 := checkDerefVar(var_glojure_DOT_core_next) + tmp45 := lang.Apply(tmp44, []any{v30}) + var tmp43 any = tmp45 + v28 = tmp41 + v29 = tmp42 + v30 = tmp43 + continue + } else { + var tmp46 any = v28 + var tmp47 any = v29 + tmp49 := checkDerefVar(var_glojure_DOT_core_next) + tmp50 := lang.Apply(tmp49, []any{v30}) + var tmp48 any = tmp50 + v28 = tmp46 + v29 = tmp47 + v30 = tmp48 + continue + } + tmp32 = tmp38 + } // end let + tmp31 = tmp32 + } else { + tmp31 = v28 + } + tmp27 = tmp31 + break + } + } // end let + tmp6 = tmp27 } // end let - return tmp7 + return tmp6 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_max_DASH_key = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_max_DASH_key.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // memoize + // memfn { - tmp0 := sym_memoize.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f)), kw_doc, "Returns a memoized version of a referentially transparent function. The\n memoized version of the function keeps a cache of the mapping from arguments\n to results and, when calls with the same arguments are repeated often, has\n higher performance at the expense of higher memory use.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(6337), kw_end_DASH_line, int(6337))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "mem" - tmp5 := checkDerefVar(var_glojure_DOT_core_atom) - tmp6 := lang.NewMap() - tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6345), kw_column, int(19), kw_end_DASH_line, int(6345), kw_end_DASH_column, int(20)) - tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp9 := lang.Apply(tmp5, []any{tmp8}) - var v10 any = tmp9 - _ = v10 - var tmp11 lang.FnFunc - tmp11 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 0) - var v12 any = lang.NewList(args[0:]...) - _ = v12 - var tmp13 any - { // let - // let binding "temp__0__auto__" - tmp14 := checkDerefVar(var_glojure_DOT_core_find) - tmp15 := checkDerefVar(var_glojure_DOT_core_deref) - tmp16 := lang.Apply(tmp15, []any{v10}) - tmp17 := lang.Apply(tmp14, []any{tmp16, v12}) - var v18 any = tmp17 - _ = v18 - var tmp19 any - if lang.IsTruthy(v18) { - var tmp20 any - { // let - // let binding "e" - var v21 any = v18 - _ = v21 - tmp22 := checkDerefVar(var_glojure_DOT_core_val) - tmp23 := lang.Apply(tmp22, []any{v21}) - tmp20 = tmp23 - } // end let - tmp19 = tmp20 - } else { - var tmp21 any - { // let - // let binding "ret" - tmp22 := checkDerefVar(var_glojure_DOT_core_apply) - tmp23 := lang.Apply(tmp22, []any{v3, v12}) - var v24 any = tmp23 - _ = v24 - tmp25 := checkDerefVar(var_glojure_DOT_core_swap_BANG_) - tmp26 := checkDerefVar(var_glojure_DOT_core_assoc) - tmp27 := lang.Apply(tmp25, []any{v10, tmp26, v12, v24}) - _ = tmp27 - tmp21 = v24 - } // end let - tmp19 = tmp21 - } - tmp13 = tmp19 - } // end let - return tmp13 - } - }) - tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6346), kw_column, int(5), kw_end_DASH_line, int(6351), kw_end_DASH_column, int(16)) - tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp4 = tmp13 - } // end let - return tmp4 + tmp0 := sym_memfn.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym__AMP_, sym_args)), kw_doc, "Expands into code that creates a fn that expects to be passed an\n object and any args and calls the named instance method on the\n object passing the args. Use when you want to treat a Java method as\n a first-class fn. name may be type-hinted with the method receiver's\n type in order to avoid reflective calls.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(11), kw_line, int(3872), kw_end_DASH_line, int(3872))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "t" + tmp7 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp8 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp9 := lang.Apply(tmp8, []any{"target"}) + tmp10 := checkDerefVar(var_glojure_DOT_core_meta) + tmp11 := lang.Apply(tmp10, []any{v4}) + tmp12 := lang.Apply(tmp7, []any{tmp9, tmp11}) + var v13 any = tmp12 + _ = v13 + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{sym_glojure_DOT_core_SLASH_fn}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := checkDerefVar(var_glojure_DOT_core_apply) + tmp20 := checkDerefVar(var_glojure_DOT_core_vector) + tmp21 := checkDerefVar(var_glojure_DOT_core_seq) + tmp22 := checkDerefVar(var_glojure_DOT_core_concat) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := lang.Apply(tmp23, []any{v13}) + tmp25 := lang.Apply(tmp22, []any{tmp24, v5}) + tmp26 := lang.Apply(tmp21, []any{tmp25}) + tmp27 := lang.Apply(tmp19, []any{tmp20, tmp26}) + tmp28 := lang.Apply(tmp18, []any{tmp27}) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := checkDerefVar(var_glojure_DOT_core_seq) + tmp31 := checkDerefVar(var_glojure_DOT_core_concat) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := lang.Apply(tmp32, []any{sym__DOT_}) + tmp34 := checkDerefVar(var_glojure_DOT_core_list) + tmp35 := lang.Apply(tmp34, []any{v13}) + tmp36 := checkDerefVar(var_glojure_DOT_core_list) + tmp37 := checkDerefVar(var_glojure_DOT_core_seq) + tmp38 := checkDerefVar(var_glojure_DOT_core_concat) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := lang.Apply(tmp39, []any{v4}) + tmp41 := lang.Apply(tmp38, []any{tmp40, v5}) + tmp42 := lang.Apply(tmp37, []any{tmp41}) + tmp43 := lang.Apply(tmp36, []any{tmp42}) + tmp44 := lang.Apply(tmp31, []any{tmp33, tmp35, tmp43}) + tmp45 := lang.Apply(tmp30, []any{tmp44}) + tmp46 := lang.Apply(tmp29, []any{tmp45}) + tmp47 := lang.Apply(tmp15, []any{tmp17, tmp28, tmp46}) + tmp48 := lang.Apply(tmp14, []any{tmp47}) + tmp6 = tmp48 + } // end let + return tmp6 + } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_memfn = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_memfn.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // merge { tmp0 := sym_merge.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_maps)), kw_doc, "Returns a map that consists of the rest of the maps conj-ed onto\n the first. If a key occurs in more than one map, the mapping from\n the latter (left-to-right) will be the mapping in the result.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3040), kw_end_DASH_line, int(3040))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: checkArity(args, 0) - var v3 any = lang.NewList(args[0:]...) - _ = v3 - var tmp4 any - tmp5 := checkDerefVar(var_glojure_DOT_core_some) - tmp6 := checkDerefVar(var_glojure_DOT_core_identity) - tmp7 := lang.Apply(tmp5, []any{tmp6, v3}) - if lang.IsTruthy(tmp7) { - tmp8 := checkDerefVar(var_glojure_DOT_core_reduce1) - var tmp9 lang.FnFunc - tmp9 = lang.NewFnFunc(func(args ...any) any { + var v2 any = lang.NewList(args[0:]...) + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_some) + tmp5 := checkDerefVar(var_glojure_DOT_core_identity) + tmp6 := lang.Apply(tmp4, []any{tmp5, v2}) + if lang.IsTruthy(tmp6) { + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp8 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 2) - v10 := args[0] + v9 := args[0] + _ = v9 + v10 := args[1] _ = v10 - v11 := args[1] - _ = v11 - tmp12 := checkDerefVar(var_glojure_DOT_core_conj) - var tmp13 any + tmp11 := checkDerefVar(var_glojure_DOT_core_conj) + var tmp12 any { // let // let binding "or__0__auto__" - var v14 any = v10 - _ = v14 - var tmp15 any - if lang.IsTruthy(v14) { - tmp15 = v14 + var v13 any = v9 + _ = v13 + var tmp14 any + if lang.IsTruthy(v13) { + tmp14 = v13 } else { - tmp16 := lang.NewMap() - tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3048), kw_column, int(28), kw_end_DASH_line, int(3048), kw_end_DASH_column, int(29)) - tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + tmp15 := lang.NewMap() + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3048), kw_column, int(28), kw_end_DASH_line, int(3048), kw_end_DASH_column, int(29)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp15 = tmp18 + tmp14 = tmp17 } - tmp13 = tmp15 + tmp12 = tmp14 } // end let - tmp14 := lang.Apply(tmp12, []any{tmp13, v11}) - return tmp14 + tmp13 := lang.Apply(tmp11, []any{tmp12, v10}) + return tmp13 }) - tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3048), kw_column, int(14), kw_end_DASH_line, int(3048), kw_end_DASH_column, int(34)) - tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3048), kw_column, int(14), kw_end_DASH_line, int(3048), kw_end_DASH_column, int(34)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp12 := lang.Apply(tmp8, []any{tmp11, v3}) - tmp4 = tmp12 + tmp11 := lang.Apply(tmp7, []any{tmp10, v2}) + tmp3 = tmp11 } else { } - return tmp4 + return tmp3 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // merge-hash-collisions - { - tmp0 := sym_merge_DASH_hash_DASH_collisions.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_expr_DASH_sym, sym_default, sym_tests, sym_thens)), kw_doc, "Takes a case expression, default expression, and a sequence of test constants\n and a corresponding sequence of then expressions. Returns a tuple of\n [tests thens skip-check-set] where no tests have the same hash. Each set of\n input test constants with the same hash is replaced with a single test\n constant (the case int), and their respective thens are combined into:\n (condp = expr\n test-1 then-1\n ...\n test-n then-n\n default).\n The skip-check is a set of case ints for which post-switch equivalence\n checking must not be done (the cases holding the above condp thens).", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(28), kw_column, int(8), kw_line, int(6647), kw_end_DASH_line, int(6647), kw_private, true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 4) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - var tmp7 any - { // let - // let binding "buckets" - var tmp8 any - { // let - // let binding "m" - tmp9 := lang.NewMap() - tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6661), kw_column, int(26), kw_end_DASH_line, int(6661), kw_end_DASH_column, int(27)) - tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v12 any = tmp11 - _ = v12 - // let binding "ks" - var v13 any = v5 - _ = v13 - // let binding "vs" - var v14 any = v6 - _ = v14 - for { - var tmp15 any - var tmp16 any - { // let - // let binding "and__0__auto__" - var v17 any = v13 - _ = v17 - var tmp18 any - if lang.IsTruthy(v17) { - tmp18 = v14 - } else { - tmp18 = v17 - } - tmp16 = tmp18 - } // end let - if lang.IsTruthy(tmp16) { - tmp18 := checkDerefVar(var_glojure_DOT_core_update) - tmp19 := checkDerefVar(var_glojure_DOT_core_first) - tmp20 := lang.Apply(tmp19, []any{v13}) - tmp21 := lang.Apply(lang.Hash, []any{tmp20}) - tmp22 := checkDerefVar(var_glojure_DOT_core_fnil) - tmp23 := checkDerefVar(var_glojure_DOT_core_conj) - tmp24 := lang.NewVector() - tmp25 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6664), kw_column, int(102), kw_end_DASH_line, int(6664), kw_end_DASH_column, int(103)) - tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp27 := lang.Apply(tmp22, []any{tmp23, tmp26}) - tmp28 := checkDerefVar(var_glojure_DOT_core_first) - tmp29 := lang.Apply(tmp28, []any{v13}) - tmp30 := checkDerefVar(var_glojure_DOT_core_first) - tmp31 := lang.Apply(tmp30, []any{v14}) - tmp32 := lang.NewVector(tmp29, tmp31) - tmp33 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6664), kw_column, int(106), kw_end_DASH_line, int(6664), kw_end_DASH_column, int(128)) - tmp34, err := lang.WithMeta(tmp32, tmp33.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp35 := lang.Apply(tmp18, []any{v12, tmp21, tmp27, tmp34}) - var tmp17 any = tmp35 - tmp37 := checkDerefVar(var_glojure_DOT_core_next) - tmp38 := lang.Apply(tmp37, []any{v13}) - var tmp36 any = tmp38 - tmp40 := checkDerefVar(var_glojure_DOT_core_next) - tmp41 := lang.Apply(tmp40, []any{v14}) - var tmp39 any = tmp41 - v12 = tmp17 - v13 = tmp36 - v14 = tmp39 - continue - } else { - tmp15 = v12 - } - tmp8 = tmp15 - break - } - } // end let - var v9 any = tmp8 - _ = v9 - // let binding "assoc-multi" - var tmp10 lang.FnFunc - tmp10 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 3) - v11 := args[0] - _ = v11 - v12 := args[1] - _ = v12 - v13 := args[2] - _ = v13 - var tmp14 any - { // let - // let binding "testexprs" - tmp15 := checkDerefVar(var_glojure_DOT_core_mapcat) - var tmp16 lang.FnFunc - tmp16 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v17 := args[0] - _ = v17 - tmp18 := checkDerefVar(var_glojure_DOT_core_list) - tmp19 := checkDerefVar(var_glojure_DOT_core_first) - tmp20 := lang.Apply(tmp19, []any{v17}) - tmp21 := lang.Apply(tmp18, []any{sym_quote, tmp20}) - tmp22 := checkDerefVar(var_glojure_DOT_core_second) - tmp23 := lang.Apply(tmp22, []any{v17}) - tmp24 := lang.NewVector(tmp21, tmp23) - tmp25 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6668), kw_column, int(56), kw_end_DASH_line, int(6668), kw_end_DASH_column, int(93)) - tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp26 - }) - tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6668), kw_column, int(47), kw_end_DASH_line, int(6668), kw_end_DASH_column, int(94)) - tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp19 := lang.Apply(tmp15, []any{tmp18, v13}) - var v20 any = tmp19 - _ = v20 - // let binding "expr" - tmp21 := checkDerefVar(var_glojure_DOT_core_seq) - tmp22 := checkDerefVar(var_glojure_DOT_core_concat) - tmp23 := checkDerefVar(var_glojure_DOT_core_list) - tmp24 := lang.Apply(tmp23, []any{sym_glojure_DOT_core_SLASH_condp}) - tmp25 := checkDerefVar(var_glojure_DOT_core_list) - tmp26 := lang.Apply(tmp25, []any{sym_glojure_DOT_core_SLASH__EQ_}) - tmp27 := checkDerefVar(var_glojure_DOT_core_list) - tmp28 := lang.Apply(tmp27, []any{v3}) - tmp29 := checkDerefVar(var_glojure_DOT_core_list) - tmp30 := lang.Apply(tmp29, []any{v4}) - tmp31 := lang.Apply(tmp22, []any{tmp24, tmp26, tmp28, v20, tmp30}) - tmp32 := lang.Apply(tmp21, []any{tmp31}) - var v33 any = tmp32 - _ = v33 - tmp34 := checkDerefVar(var_glojure_DOT_core_assoc) - tmp35 := lang.Apply(tmp34, []any{v11, v12, v33}) - tmp14 = tmp35 - } // end let - return tmp14 - }) - tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6667), kw_column, int(21), kw_end_DASH_line, int(6670), kw_end_DASH_column, int(42)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v13 any = tmp12 - _ = v13 - // let binding "hmap" - tmp14 := checkDerefVar(var_glojure_DOT_core_reduce1) - var tmp15 lang.FnFunc - tmp15 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v16 := args[0] - _ = v16 - v17 := args[1] - _ = v17 - var tmp18 any - { // let - // let binding "vec__164" - var v19 any = v17 - _ = v19 - // let binding "h" - tmp20 := checkDerefVar(var_glojure_DOT_core_nth) - tmp21 := lang.Apply(tmp20, []any{v19, int64(0), nil}) - var v22 any = tmp21 - _ = v22 - // let binding "bucket" - tmp23 := checkDerefVar(var_glojure_DOT_core_nth) - tmp24 := lang.Apply(tmp23, []any{v19, int64(1), nil}) - var v25 any = tmp24 - _ = v25 - var tmp26 any - tmp27 := checkDerefVar(var_glojure_DOT_core__EQ__EQ_) - tmp28 := checkDerefVar(var_glojure_DOT_core_count) - tmp29 := lang.Apply(tmp28, []any{v25}) - tmp30 := lang.Apply(tmp27, []any{int64(1), tmp29}) - if lang.IsTruthy(tmp30) { - tmp31 := checkDerefVar(var_glojure_DOT_core_assoc) - tmp32 := checkDerefVar(var_glojure_DOT_core_ffirst) - tmp33 := lang.Apply(tmp32, []any{v25}) - tmp34 := checkDerefVar(var_glojure_DOT_core_second) - tmp35 := checkDerefVar(var_glojure_DOT_core_first) - tmp36 := lang.Apply(tmp35, []any{v25}) - tmp37 := lang.Apply(tmp34, []any{tmp36}) - tmp38 := lang.Apply(tmp31, []any{v16, tmp33, tmp37}) - tmp26 = tmp38 - } else { - tmp39 := lang.Apply(v13, []any{v16, v22, v25}) - tmp26 = tmp39 - } - tmp18 = tmp26 - } // end let - return tmp18 - }) - tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6672), kw_column, int(16), kw_end_DASH_line, int(6675), kw_end_DASH_column, int(45)) - tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp18 := lang.NewMap() - tmp19 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6676), kw_column, int(16), kw_end_DASH_line, int(6676), kw_end_DASH_column, int(17)) - tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp21 := lang.Apply(tmp14, []any{tmp17, tmp20, v9}) - var v22 any = tmp21 - _ = v22 - // let binding "skip-check" - tmp23 := checkDerefVar(var_glojure_DOT_core_into1) - tmp24 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) - tmp25 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6680), kw_column, int(29), kw_end_DASH_line, int(6680), kw_end_DASH_column, int(31)) - tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp27 := checkDerefVar(var_glojure_DOT_core_map) - tmp28 := checkDerefVar(var_glojure_DOT_core_first) - tmp29 := checkDerefVar(var_glojure_DOT_core_filter) - var tmp30 lang.FnFunc - tmp30 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v31 := args[0] - _ = v31 - tmp32 := checkDerefVar(var_glojure_DOT_core__LT_) - tmp33 := checkDerefVar(var_glojure_DOT_core_count) - tmp34 := checkDerefVar(var_glojure_DOT_core_second) - tmp35 := lang.Apply(tmp34, []any{v31}) - tmp36 := lang.Apply(tmp33, []any{tmp35}) - tmp37 := lang.Apply(tmp32, []any{int64(1), tmp36}) - return tmp37 - }) - tmp31 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6678), kw_column, int(30), kw_end_DASH_line, int(6678), kw_end_DASH_column, int(54)) - tmp32, err := lang.WithMeta(tmp30, tmp31.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp33 := lang.Apply(tmp29, []any{tmp32, v9}) - tmp34 := lang.Apply(tmp27, []any{tmp28, tmp33}) - tmp35 := lang.Apply(tmp23, []any{tmp26, tmp34}) - var v36 any = tmp35 - _ = v36 - tmp37 := checkDerefVar(var_glojure_DOT_core_keys) - tmp38 := lang.Apply(tmp37, []any{v22}) - tmp39 := checkDerefVar(var_glojure_DOT_core_vals) - tmp40 := lang.Apply(tmp39, []any{v22}) - tmp41 := lang.NewVector(tmp38, tmp40, v36) - tmp42 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6681), kw_column, int(5), kw_end_DASH_line, int(6681), kw_end_DASH_column, int(40)) - tmp43, err := lang.WithMeta(tmp41, tmp42.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp7 = tmp43 - } // end let - return tmp7 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_merge = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_merge.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // merge-with { tmp0 := sym_merge_DASH_with.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym__AMP_, sym_maps)), kw_doc, "Returns a map that consists of the rest of the maps conj-ed onto\n the first. If a key occurs in more than one map, the mapping(s)\n from the latter (left-to-right) will be combined with the mapping in\n the result by calling (f val-in-result val-in-latter).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(3050), kw_end_DASH_line, int(3050))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: checkArity(args, 1) - v3 := args[0] + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) _ = v3 - var v4 any = lang.NewList(args[1:]...) - _ = v4 - var tmp5 any - tmp6 := checkDerefVar(var_glojure_DOT_core_some) - tmp7 := checkDerefVar(var_glojure_DOT_core_identity) - tmp8 := lang.Apply(tmp6, []any{tmp7, v4}) - if lang.IsTruthy(tmp8) { - var tmp9 any + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_some) + tmp6 := checkDerefVar(var_glojure_DOT_core_identity) + tmp7 := lang.Apply(tmp5, []any{tmp6, v3}) + if lang.IsTruthy(tmp7) { + var tmp8 any { // let // let binding "merge-entry" - var tmp10 lang.FnFunc - tmp10 = lang.NewFnFunc(func(args ...any) any { + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 2) - v11 := args[0] + v10 := args[0] + _ = v10 + v11 := args[1] _ = v11 - v12 := args[1] - _ = v12 - var tmp13 any + var tmp12 any { // let // let binding "k" - tmp14 := checkDerefVar(var_glojure_DOT_core_key) - tmp15 := lang.Apply(tmp14, []any{v12}) - var v16 any = tmp15 - _ = v16 + tmp13 := checkDerefVar(var_glojure_DOT_core_key) + tmp14 := lang.Apply(tmp13, []any{v11}) + var v15 any = tmp14 + _ = v15 // let binding "v" - tmp17 := checkDerefVar(var_glojure_DOT_core_val) - tmp18 := lang.Apply(tmp17, []any{v12}) - var v19 any = tmp18 - _ = v19 - var tmp20 any - tmp21 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) - tmp22 := lang.Apply(tmp21, []any{v11, v16}) - if lang.IsTruthy(tmp22) { - tmp23 := checkDerefVar(var_glojure_DOT_core_assoc) - tmp24 := checkDerefVar(var_glojure_DOT_core_get) - tmp25 := lang.Apply(tmp24, []any{v11, v16}) - tmp26 := lang.Apply(v3, []any{tmp25, v19}) - tmp27 := lang.Apply(tmp23, []any{v11, v16, tmp26}) - tmp20 = tmp27 + tmp16 := checkDerefVar(var_glojure_DOT_core_val) + tmp17 := lang.Apply(tmp16, []any{v11}) + var v18 any = tmp17 + _ = v18 + var tmp19 any + tmp20 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp21 := lang.Apply(tmp20, []any{v10, v15}) + if lang.IsTruthy(tmp21) { + tmp22 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp23 := checkDerefVar(var_glojure_DOT_core_get) + tmp24 := lang.Apply(tmp23, []any{v10, v15}) + tmp25 := lang.Apply(v2, []any{tmp24, v18}) + tmp26 := lang.Apply(tmp22, []any{v10, v15, tmp25}) + tmp19 = tmp26 } else { - tmp28 := checkDerefVar(var_glojure_DOT_core_assoc) - tmp29 := lang.Apply(tmp28, []any{v11, v16, v19}) - tmp20 = tmp29 + tmp27 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp28 := lang.Apply(tmp27, []any{v10, v15, v18}) + tmp19 = tmp28 } - tmp13 = tmp20 + tmp12 = tmp19 } // end let - return tmp13 + return tmp12 }) - tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3059), kw_column, int(23), kw_end_DASH_line, int(3063), kw_end_DASH_column, int(23)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3059), kw_column, int(23), kw_end_DASH_line, int(3063), kw_end_DASH_column, int(23)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) if err != nil { panic(err) } - var v13 any = tmp12 - _ = v13 + var v12 any = tmp11 + _ = v12 // let binding "merge2" - var tmp14 lang.FnFunc - tmp14 = lang.NewFnFunc(func(args ...any) any { + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 2) - v15 := args[0] + v14 := args[0] + _ = v14 + v15 := args[1] _ = v15 - v16 := args[1] - _ = v16 - tmp17 := checkDerefVar(var_glojure_DOT_core_reduce1) - var tmp18 any + tmp16 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp17 any { // let // let binding "or__0__auto__" - var v19 any = v15 - _ = v19 - var tmp20 any - if lang.IsTruthy(v19) { - tmp20 = v19 + var v18 any = v14 + _ = v18 + var tmp19 any + if lang.IsTruthy(v18) { + tmp19 = v18 } else { - tmp21 := lang.NewMap() - tmp22 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3065), kw_column, int(34), kw_end_DASH_line, int(3065), kw_end_DASH_column, int(35)) - tmp23, err := lang.WithMeta(tmp21, tmp22.(lang.IPersistentMap)) + tmp20 := lang.NewMap() + tmp21 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3065), kw_column, int(34), kw_end_DASH_line, int(3065), kw_end_DASH_column, int(35)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp20 = tmp23 + tmp19 = tmp22 } - tmp18 = tmp20 + tmp17 = tmp19 } // end let - tmp19 := checkDerefVar(var_glojure_DOT_core_seq) - tmp20 := lang.Apply(tmp19, []any{v16}) - tmp21 := lang.Apply(tmp17, []any{v13, tmp18, tmp20}) - return tmp21 + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := lang.Apply(tmp18, []any{v15}) + tmp20 := lang.Apply(tmp16, []any{v12, tmp17, tmp19}) + return tmp20 }) - tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3064), kw_column, int(18), kw_end_DASH_line, int(3065), kw_end_DASH_column, int(47)) - tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3064), kw_column, int(18), kw_end_DASH_line, int(3065), kw_end_DASH_column, int(47)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) if err != nil { panic(err) } - var v17 any = tmp16 - _ = v17 - tmp18 := checkDerefVar(var_glojure_DOT_core_reduce1) - tmp19 := lang.Apply(tmp18, []any{v17, v4}) - tmp9 = tmp19 + var v16 any = tmp15 + _ = v16 + tmp17 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp18 := lang.Apply(tmp17, []any{v16, v3}) + tmp8 = tmp18 } // end let - tmp5 = tmp9 - } else { - } - return tmp5 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // meta - { - tmp0 := sym_meta.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_obj)), kw_doc, "Returns the metadata of obj, returns nil if there is no metadata.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(5), kw_column, int(2), kw_line, int(202), kw_end_DASH_line, int(206))).(*lang.Symbol) - var tmp2 lang.FnFunc - { // function meta - var v3 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - var tmp5 any - tmp6 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp7 := reflect.TypeOf((*lang.IMeta)(nil)).Elem() - tmp8 := lang.Apply(tmp6, []any{tmp7, v4}) - if lang.IsTruthy(tmp8) { - tmp9, ok := lang.FieldOrMethod(v4, "Meta") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "Meta"))) - } - var tmp10 any - switch reflect.TypeOf(tmp9).Kind() { - case reflect.Func: - tmp10 = lang.Apply(tmp9, nil) - default: - tmp10 = tmp9 - } - tmp5 = tmp10 + tmp4 = tmp8 } else { } - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(206), kw_column, int(7), kw_end_DASH_line, int(208), kw_end_DASH_column, int(21))).(lang.FnFunc) - v3 = tmp2 - _ = v3 - } - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // methods - { - tmp0 := sym_methods.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_multifn)), kw_doc, "Given a multimethod, returns a map of dispatch values -> dispatch fns", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(1809), kw_end_DASH_line, int(1809))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4, ok := lang.FieldOrMethod(v3, "getMethodTable") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getMethodTable"))) - } - var tmp5 any - switch reflect.TypeOf(tmp4).Kind() { - case reflect.Func: - tmp5 = lang.Apply(tmp4, nil) - default: - tmp5 = tmp4 + return tmp4 } - return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_merge_DASH_with = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_merge_DASH_with.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // min @@ -35494,9931 +27990,13211 @@ func LoadNS() { }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) tmp0 := sym_min.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns the least of the nums.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(1118), kw_end_DASH_line, int(1118))).(*lang.Symbol) - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: - v5 := args[0] - _ = v5 - return v5 + v4 := args[0] + _ = v4 + return v4 case 2: - v5 := args[0] + v4 := args[0] + _ = v4 + v5 := args[1] _ = v5 - v6 := args[1] - _ = v6 - tmp7, _ := lang.FieldOrMethod(lang.Numbers, "Min") - if reflect.TypeOf(tmp7).Kind() != reflect.Func { + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Min") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Min is not a function"))) } - tmp8 := lang.Apply(tmp7, []any{v5, v6}) - return tmp8 + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 default: checkArity(args, 2) - v5 := args[0] + v4 := args[0] + _ = v4 + v5 := args[1] _ = v5 - v6 := args[1] + var v6 any = lang.NewList(args[2:]...) _ = v6 - var v7 any = lang.NewList(args[2:]...) - _ = v7 - tmp8 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp8 := checkDerefVar(var_glojure_DOT_core_min) tmp9 := checkDerefVar(var_glojure_DOT_core_min) - tmp10 := checkDerefVar(var_glojure_DOT_core_min) - tmp11 := lang.Apply(tmp10, []any{v5, v6}) - tmp12 := lang.Apply(tmp8, []any{tmp9, tmp11, v7}) - return tmp12 + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) + return tmp11 } }) - tmp4 = tmp4.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp3 := ns.InternWithValue(tmp0, tmp4, true) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_min = ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { - tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_min.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // min-key { tmp0 := sym_min_DASH_key.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_k, sym_x), lang.NewVector(sym_k, sym_x, sym_y), lang.NewVector(sym_k, sym_x, sym_y, sym__AMP_, sym_more)), kw_doc, "Returns the x for which (k x), a number, is least.\n\n If there are multiple such xs, the last one is returned.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(5033), kw_end_DASH_line, int(5033))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 2: - v3 := args[0] + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] - _ = v4 - return v4 + return v3 case 3: - v3 := args[0] + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + v4 := args[2] _ = v4 - v5 := args[2] - _ = v5 - var tmp6 any - tmp7 := checkDerefVar(var_glojure_DOT_core__LT_) - tmp8 := lang.Apply(v3, []any{v4}) - tmp9 := lang.Apply(v3, []any{v5}) - tmp10 := lang.Apply(tmp7, []any{tmp8, tmp9}) - if lang.IsTruthy(tmp10) { - tmp6 = v4 + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp7 := lang.Apply(v2, []any{v3}) + tmp8 := lang.Apply(v2, []any{v4}) + tmp9 := lang.Apply(tmp6, []any{tmp7, tmp8}) + if lang.IsTruthy(tmp9) { + tmp5 = v3 } else { - tmp6 = v5 + tmp5 = v4 } - return tmp6 + return tmp5 default: checkArity(args, 3) - v3 := args[0] + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + v4 := args[2] _ = v4 - v5 := args[2] + var v5 any = lang.NewList(args[3:]...) _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any + var tmp6 any { // let // let binding "kx" - tmp8 := lang.Apply(v3, []any{v4}) - var v9 any = tmp8 - _ = v9 + tmp7 := lang.Apply(v2, []any{v3}) + var v8 any = tmp7 + _ = v8 // let binding "ky" - tmp10 := lang.Apply(v3, []any{v5}) - var v11 any = tmp10 - _ = v11 + tmp9 := lang.Apply(v2, []any{v4}) + var v10 any = tmp9 + _ = v10 // let binding "vec__58" - var tmp12 any - tmp13 := checkDerefVar(var_glojure_DOT_core__LT_) - tmp14 := lang.Apply(tmp13, []any{v9, v11}) - if lang.IsTruthy(tmp14) { - tmp15 := lang.NewVector(v4, v9) - tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5043), kw_column, int(31), kw_end_DASH_line, int(5043), kw_end_DASH_column, int(36)) - tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp13 := lang.Apply(tmp12, []any{v8, v10}) + if lang.IsTruthy(tmp13) { + tmp14 := lang.NewVector(v3, v8) + tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5043), kw_column, int(31), kw_end_DASH_line, int(5043), kw_end_DASH_column, int(36)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp12 = tmp17 + tmp11 = tmp16 } else { - tmp18 := lang.NewVector(v5, v11) - tmp19 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5043), kw_column, int(38), kw_end_DASH_line, int(5043), kw_end_DASH_column, int(43)) - tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) + tmp17 := lang.NewVector(v4, v10) + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5043), kw_column, int(38), kw_end_DASH_line, int(5043), kw_end_DASH_column, int(43)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp12 = tmp20 + tmp11 = tmp19 } - var v21 any = tmp12 - _ = v21 + var v20 any = tmp11 + _ = v20 // let binding "v" - tmp22 := checkDerefVar(var_glojure_DOT_core_nth) - tmp23 := lang.Apply(tmp22, []any{v21, int64(0), nil}) - var v24 any = tmp23 - _ = v24 + tmp21 := checkDerefVar(var_glojure_DOT_core_nth) + tmp22 := lang.Apply(tmp21, []any{v20, int64(0), nil}) + var v23 any = tmp22 + _ = v23 // let binding "kv" - tmp25 := checkDerefVar(var_glojure_DOT_core_nth) - tmp26 := lang.Apply(tmp25, []any{v21, int64(1), nil}) - var v27 any = tmp26 - _ = v27 - var tmp28 any + tmp24 := checkDerefVar(var_glojure_DOT_core_nth) + tmp25 := lang.Apply(tmp24, []any{v20, int64(1), nil}) + var v26 any = tmp25 + _ = v26 + var tmp27 any { // let // let binding "v" - var v29 any = v24 - _ = v29 + var v28 any = v23 + _ = v28 // let binding "kv" - var v30 any = v27 - _ = v30 + var v29 any = v26 + _ = v29 // let binding "more" - var v31 any = v6 - _ = v31 + var v30 any = v5 + _ = v30 for { - var tmp32 any - if lang.IsTruthy(v31) { - var tmp33 any + var tmp31 any + if lang.IsTruthy(v30) { + var tmp32 any { // let // let binding "w" - tmp34 := checkDerefVar(var_glojure_DOT_core_first) - tmp35 := lang.Apply(tmp34, []any{v31}) - var v36 any = tmp35 - _ = v36 + tmp33 := checkDerefVar(var_glojure_DOT_core_first) + tmp34 := lang.Apply(tmp33, []any{v30}) + var v35 any = tmp34 + _ = v35 // let binding "kw" - tmp37 := lang.Apply(v3, []any{v36}) - var v38 any = tmp37 - _ = v38 - var tmp39 any - tmp40 := checkDerefVar(var_glojure_DOT_core__LT__EQ_) - tmp41 := lang.Apply(tmp40, []any{v38, v30}) - if lang.IsTruthy(tmp41) { - var tmp42 any = v36 - var tmp43 any = v38 - tmp45 := checkDerefVar(var_glojure_DOT_core_next) - tmp46 := lang.Apply(tmp45, []any{v31}) - var tmp44 any = tmp46 + tmp36 := lang.Apply(v2, []any{v35}) + var v37 any = tmp36 + _ = v37 + var tmp38 any + tmp39 := checkDerefVar(var_glojure_DOT_core__LT__EQ_) + tmp40 := lang.Apply(tmp39, []any{v37, v29}) + if lang.IsTruthy(tmp40) { + var tmp41 any = v35 + var tmp42 any = v37 + tmp44 := checkDerefVar(var_glojure_DOT_core_next) + tmp45 := lang.Apply(tmp44, []any{v30}) + var tmp43 any = tmp45 + v28 = tmp41 v29 = tmp42 v30 = tmp43 - v31 = tmp44 continue } else { + var tmp46 any = v28 var tmp47 any = v29 - var tmp48 any = v30 - tmp50 := checkDerefVar(var_glojure_DOT_core_next) - tmp51 := lang.Apply(tmp50, []any{v31}) - var tmp49 any = tmp51 + tmp49 := checkDerefVar(var_glojure_DOT_core_next) + tmp50 := lang.Apply(tmp49, []any{v30}) + var tmp48 any = tmp50 + v28 = tmp46 v29 = tmp47 v30 = tmp48 - v31 = tmp49 continue } - tmp33 = tmp39 + tmp32 = tmp38 } // end let - tmp32 = tmp33 + tmp31 = tmp32 } else { - tmp32 = v29 + tmp31 = v28 } - tmp28 = tmp32 + tmp27 = tmp31 break } } // end let - tmp7 = tmp28 + tmp6 = tmp27 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_min_DASH_key = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_min_DASH_key.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // mod + { + tmp0 := sym_mod.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_num, sym_div)), kw_doc, "Modulus of num and div. Truncates toward negative infinity.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(3567), kw_end_DASH_line, int(3567))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "m" + tmp5 := checkDerefVar(var_glojure_DOT_core_rem) + tmp6 := lang.Apply(tmp5, []any{v2, v3}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + var tmp9 any + { // let + // let binding "or__0__auto__" + tmp10 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) + tmp11 := lang.Apply(tmp10, []any{v7}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + tmp13 = v12 + } else { + tmp14 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp15 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp16 := lang.Apply(tmp15, []any{v2}) + tmp17 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp13 = tmp19 + } + tmp9 = tmp13 } // end let + if lang.IsTruthy(tmp9) { + tmp8 = v7 + } else { + tmp10 := checkDerefVar(var_glojure_DOT_core__PLUS_) + tmp11 := lang.Apply(tmp10, []any{v7, v3}) + tmp8 = tmp11 + } + tmp4 = tmp8 + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_mod = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_mod.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // nary-inline + { + tmp0 := sym_nary_DASH_inline.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(948), kw_column, int(7), kw_end_DASH_line, int(948), kw_end_DASH_column, int(27), kw_arglists, lang.NewList(lang.NewVector(sym_op), lang.NewVector(sym_op, sym_unchecked_DASH_op)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_nary_DASH_inline) + tmp4 := lang.Apply(tmp3, []any{v2, v2}) + return tmp4 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v5 := args[0] + _ = v5 + var tmp6 any + { // let + // let binding "op" + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp8) { + tmp7 = v3 + } else { + tmp7 = v2 + } + var v9 any = tmp7 + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_seq) + tmp11 := checkDerefVar(var_glojure_DOT_core_concat) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym__DOT_}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := checkDerefVar(var_glojure_DOT_core_seq) + tmp18 := checkDerefVar(var_glojure_DOT_core_concat) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v9}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v5}) + tmp23 := lang.Apply(tmp18, []any{tmp20, tmp22}) + tmp24 := lang.Apply(tmp17, []any{tmp23}) + tmp25 := lang.Apply(tmp16, []any{tmp24}) + tmp26 := lang.Apply(tmp11, []any{tmp13, tmp15, tmp25}) + tmp27 := lang.Apply(tmp10, []any{tmp26}) + tmp6 = tmp27 + } // end let + return tmp6 + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + var tmp7 any + { // let + // let binding "op" + var tmp8 any + tmp9 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp9) { + tmp8 = v3 + } else { + tmp8 = v2 + } + var v10 any = tmp8 + _ = v10 + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym__DOT_}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{v10}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v5}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v6}) + tmp26 := lang.Apply(tmp19, []any{tmp21, tmp23, tmp25}) + tmp27 := lang.Apply(tmp18, []any{tmp26}) + tmp28 := lang.Apply(tmp17, []any{tmp27}) + tmp29 := lang.Apply(tmp12, []any{tmp14, tmp16, tmp28}) + tmp30 := lang.Apply(tmp11, []any{tmp29}) + tmp7 = tmp30 + } // end let + return tmp7 + default: + checkArity(args, 2) + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + var v7 any = lang.NewList(args[2:]...) + _ = v7 + var tmp8 any + { // let + // let binding "op" + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp10) { + tmp9 = v3 + } else { + tmp9 = v2 + } + var v11 any = tmp9 + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v14 := args[0] + _ = v14 + v15 := args[1] + _ = v15 + tmp16 := checkDerefVar(var_glojure_DOT_core_seq) + tmp17 := checkDerefVar(var_glojure_DOT_core_concat) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{sym__DOT_}) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := checkDerefVar(var_glojure_DOT_core_seq) + tmp24 := checkDerefVar(var_glojure_DOT_core_concat) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := lang.Apply(tmp25, []any{v11}) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{v14}) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{v15}) + tmp31 := lang.Apply(tmp24, []any{tmp26, tmp28, tmp30}) + tmp32 := lang.Apply(tmp23, []any{tmp31}) + tmp33 := lang.Apply(tmp22, []any{tmp32}) + tmp34 := lang.Apply(tmp17, []any{tmp19, tmp21, tmp33}) + tmp35 := lang.Apply(tmp16, []any{tmp34}) + return tmp35 + }) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp16 := checkDerefVar(var_glojure_DOT_core_seq) + tmp17 := checkDerefVar(var_glojure_DOT_core_concat) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{sym__DOT_}) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := checkDerefVar(var_glojure_DOT_core_seq) + tmp24 := checkDerefVar(var_glojure_DOT_core_concat) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := lang.Apply(tmp25, []any{v11}) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{v5}) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{v6}) + tmp31 := lang.Apply(tmp24, []any{tmp26, tmp28, tmp30}) + tmp32 := lang.Apply(tmp23, []any{tmp31}) + tmp33 := lang.Apply(tmp22, []any{tmp32}) + tmp34 := lang.Apply(tmp17, []any{tmp19, tmp21, tmp33}) + tmp35 := lang.Apply(tmp16, []any{tmp34}) + tmp36 := lang.Apply(tmp12, []any{tmp15, tmp35, v7}) + tmp8 = tmp36 + } // end let + return tmp8 + } + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_nary_DASH_inline = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_nary_DASH_inline.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // nat-int? + { + tmp0 := sym_nat_DASH_int_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a non-negative fixed precision integer", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(1415), kw_end_DASH_line, int(1415))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "and__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + tmp8 := checkDerefVar(var_glojure_DOT_core_not) + tmp9 := checkDerefVar(var_glojure_DOT_core_neg_QMARK_) + tmp10 := lang.Apply(tmp9, []any{v2}) + tmp11 := lang.Apply(tmp8, []any{tmp10}) + tmp7 = tmp11 + } else { + tmp7 = v6 + } + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_nat_DASH_int_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_nat_DASH_int_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // neg-int? + { + tmp0 := sym_neg_DASH_int_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a negative fixed precision integer", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(1409), kw_end_DASH_line, int(1409))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "and__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + tmp8 := checkDerefVar(var_glojure_DOT_core_neg_QMARK_) + tmp9 := lang.Apply(tmp8, []any{v2}) + tmp7 = tmp9 + } else { + tmp7 = v6 + } + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_neg_DASH_int_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_neg_DASH_int_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // not-any? + { + tmp1 := reflect.TypeOf(false) + tmp0 := sym_not_DASH_any_QMARK_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns false if (pred x) is logical true for any x in coll,\n else true.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(2), kw_line, int(2696), kw_end_DASH_line, int(2701))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp3 := lang.Apply(closed36, nil) + tmp4 := lang.Apply(closed35, []any{tmp3}) + return tmp4 + case 1: + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(closed36, []any{v3}) + tmp5 := lang.Apply(closed35, []any{tmp4}) + return tmp5 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(closed36, []any{v3, v4}) + tmp6 := lang.Apply(closed35, []any{tmp5}) + return tmp6 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6 := lang.Apply(closed36, []any{v3, v4, v5}) + tmp7 := lang.Apply(closed35, []any{tmp6}) return tmp7 + default: + checkArity(args, 3) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_apply) + tmp8 := lang.Apply(tmp7, []any{closed36, v3, v4, v5, v6}) + tmp9 := lang.Apply(closed35, []any{tmp8}) + return tmp9 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2559), kw_column, int(6), kw_end_DASH_line, int(2564), kw_end_DASH_column, int(49))).(lang.FnFunc) + var_glojure_DOT_core_not_DASH_any_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_not_DASH_any_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // mix-collection-hash + // not-every? { - tmp0 := sym_mix_DASH_collection_DASH_hash.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_hash_DASH_basis, sym_count)), kw_doc, "Mix final collection hash for ordered or unordered collections.\n hash-basis is the combined collection hash, count is the number\n of elements included in the basis. Note this is the hash code\n consistent with =, different from .hashCode.\n See http://glojure.org/data_structures#hash for full algorithms.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.6", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(25), kw_column, int(7), kw_line, int(5199), kw_end_DASH_line, int(5199))).(*lang.Symbol) + tmp1 := reflect.TypeOf(false) + tmp0 := sym_not_DASH_every_QMARK_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns false if (pred x) is logical true for every x in\n coll, else true.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(2), kw_line, int(2677), kw_end_DASH_line, int(2682))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.Apply(nil, []any{v3, v4}) - return tmp5 + switch len(args) { + case 0: + tmp3 := lang.Apply(closed37, nil) + tmp4 := lang.Apply(closed35, []any{tmp3}) + return tmp4 + case 1: + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(closed37, []any{v3}) + tmp5 := lang.Apply(closed35, []any{tmp4}) + return tmp5 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(closed37, []any{v3, v4}) + tmp6 := lang.Apply(closed35, []any{tmp5}) + return tmp6 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6 := lang.Apply(closed37, []any{v3, v4, v5}) + tmp7 := lang.Apply(closed35, []any{tmp6}) + return tmp7 + default: + checkArity(args, 3) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_apply) + tmp8 := lang.Apply(tmp7, []any{closed37, v3, v4, v5, v6}) + tmp9 := lang.Apply(closed35, []any{tmp8}) + return tmp9 + } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2559), kw_column, int(6), kw_end_DASH_line, int(2564), kw_end_DASH_column, int(49))).(lang.FnFunc) + var_glojure_DOT_core_not_DASH_every_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_not_DASH_every_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // mk-bound-fn + // not= { - tmp0 := sym_mk_DASH_bound_DASH_fn.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5127), kw_column, int(7), kw_end_DASH_line, int(5127), kw_end_DASH_column, int(17), kw_arglists, lang.NewList(lang.NewVector(sym_sc, sym_test, sym_key)), kw_private, true, kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + tmp1 := reflect.TypeOf(false) + tmp0 := sym_not_EQ_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_doc, "Same as (not (= obj1 obj2))", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(812), kw_end_DASH_line, int(812))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 3) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var tmp6 lang.FnFunc - tmp6 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v7 := args[0] - _ = v7 - tmp8, ok := lang.FieldOrMethod(v3, "comparator") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "comparator"))) - } - var tmp9 any - switch reflect.TypeOf(tmp8).Kind() { - case reflect.Func: - tmp9 = lang.Apply(tmp8, nil) - default: - tmp9 = tmp8 - } - tmp10, _ := lang.FieldOrMethod(v3, "entryKey") - if reflect.TypeOf(tmp10).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("entryKey is not a function"))) - } - tmp11 := lang.Apply(tmp10, []any{v7}) - tmp12, _ := lang.FieldOrMethod(tmp9, "compare") - if reflect.TypeOf(tmp12).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("compare is not a function"))) - } - tmp13 := lang.Apply(tmp12, []any{tmp11, v5}) - tmp14 := lang.Apply(v4, []any{tmp13, int64(0)}) - return tmp14 - }) - tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5130), kw_column, int(3), kw_end_DASH_line, int(5131), kw_end_DASH_column, int(64)) - tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) - if err != nil { - panic(err) + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + return false + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_not) + tmp6 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp7 := lang.Apply(tmp6, []any{v3, v4}) + tmp8 := lang.Apply(tmp5, []any{tmp7}) + return tmp8 + default: + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_not) + tmp7 := checkDerefVar(var_glojure_DOT_core_apply) + tmp8 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp9 := lang.Apply(tmp7, []any{tmp8, v3, v4, v5}) + tmp10 := lang.Apply(tmp6, []any{tmp9}) + return tmp10 } - return tmp8 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp3 := reflect.TypeOf(false) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_not_EQ_ = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_not_EQ_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // mod + // ns-interns { - tmp0 := sym_mod.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_num, sym_div)), kw_doc, "Modulus of num and div. Truncates toward negative infinity.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(3567), kw_end_DASH_line, int(3567))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any + tmp0 := sym_ns_DASH_interns.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns)), kw_doc, "Returns a map of the intern mappings for the namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4206), kw_end_DASH_line, int(4206))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any { // let - // let binding "m" - tmp6 := checkDerefVar(var_glojure_DOT_core_rem) - tmp7 := lang.Apply(tmp6, []any{v3, v4}) - var v8 any = tmp7 - _ = v8 - var tmp9 any - var tmp10 any - { // let - // let binding "or__0__auto__" - tmp11 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) - tmp12 := lang.Apply(tmp11, []any{v8}) - var v13 any = tmp12 - _ = v13 - var tmp14 any - if lang.IsTruthy(v13) { - tmp14 = v13 - } else { - tmp15 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp16 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) - tmp17 := lang.Apply(tmp16, []any{v3}) - tmp18 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) - tmp19 := lang.Apply(tmp18, []any{v4}) - tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) - tmp14 = tmp20 - } - tmp10 = tmp14 - } // end let - if lang.IsTruthy(tmp10) { - tmp9 = v8 - } else { - tmp11 := checkDerefVar(var_glojure_DOT_core__PLUS_) - tmp12 := lang.Apply(tmp11, []any{v8, v4}) - tmp9 = tmp12 + // let binding "ns" + tmp4 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_filter_DASH_key) + tmp8 := checkDerefVar(var_glojure_DOT_core_val) + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v10 := args[0] + _ = v10 + var tmp11 any + { // let + // let binding "and__0__auto__" + tmp12 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp13 := reflect.TypeOf((*lang.Var)(nil)) + tmp14 := lang.Apply(tmp12, []any{tmp13, v10}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + if lang.IsTruthy(v15) { + tmp17 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp18, ok := lang.FieldOrMethod(v10, "Namespace") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v10, "Namespace"))) + } + var tmp19 any + switch reflect.TypeOf(tmp18).Kind() { + case reflect.Func: + tmp19 = lang.Apply(tmp18, nil) + default: + tmp19 = tmp18 + } + tmp20 := lang.Apply(tmp17, []any{v6, tmp19}) + tmp16 = tmp20 + } else { + tmp16 = v15 + } + tmp11 = tmp16 + } // end let + return tmp11 + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4212), kw_column, int(21), kw_end_DASH_line, int(4213), kw_end_DASH_column, int(56)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) } - tmp5 = tmp9 + tmp12 := checkDerefVar(var_glojure_DOT_core_ns_DASH_map) + tmp13 := lang.Apply(tmp12, []any{v6}) + tmp14 := lang.Apply(tmp7, []any{tmp8, tmp11, tmp13}) + tmp3 = tmp14 } // end let - return tmp5 + return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ns_DASH_interns = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_ns_DASH_interns.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // name + // ns-publics { - tmp1 := reflect.TypeOf("") - tmp0 := sym_name.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns the name String of a string, symbol or keyword.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1585), kw_end_DASH_line, int(1585))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_ns_DASH_publics.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns)), kw_doc, "Returns a map of the public intern mappings for the namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4188), kw_end_DASH_line, int(4188))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v4 := args[0] - _ = v4 - var tmp5 any - tmp6 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) - tmp7 := lang.Apply(tmp6, []any{v4}) - if lang.IsTruthy(tmp7) { - tmp5 = v4 - } else { - tmp8, _ := lang.FieldOrMethod(v4, "Name") - if reflect.TypeOf(tmp8).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Name is not a function"))) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "ns" + tmp4 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_filter_DASH_key) + tmp8 := checkDerefVar(var_glojure_DOT_core_val) + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v10 := args[0] + _ = v10 + var tmp11 any + { // let + // let binding "and__0__auto__" + tmp12 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp13 := reflect.TypeOf((*lang.Var)(nil)) + tmp14 := lang.Apply(tmp12, []any{tmp13, v10}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + if lang.IsTruthy(v15) { + var tmp17 any + { // let + // let binding "and__0__auto__" + tmp18 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp19, ok := lang.FieldOrMethod(v10, "Namespace") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v10, "Namespace"))) + } + var tmp20 any + switch reflect.TypeOf(tmp19).Kind() { + case reflect.Func: + tmp20 = lang.Apply(tmp19, nil) + default: + tmp20 = tmp19 + } + tmp21 := lang.Apply(tmp18, []any{v6, tmp20}) + var v22 any = tmp21 + _ = v22 + var tmp23 any + if lang.IsTruthy(v22) { + tmp24, ok := lang.FieldOrMethod(v10, "IsPublic") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v10, "IsPublic"))) + } + var tmp25 any + switch reflect.TypeOf(tmp24).Kind() { + case reflect.Func: + tmp25 = lang.Apply(tmp24, nil) + default: + tmp25 = tmp24 + } + tmp23 = tmp25 + } else { + tmp23 = v22 + } + tmp17 = tmp23 + } // end let + tmp16 = tmp17 + } else { + tmp16 = v15 + } + tmp11 = tmp16 + } // end let + return tmp11 + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4194), kw_column, int(21), kw_end_DASH_line, int(4196), kw_end_DASH_column, int(48)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) } - tmp9 := lang.Apply(tmp8, []any{}) - tmp5 = tmp9 - } - return tmp5 + tmp12 := checkDerefVar(var_glojure_DOT_core_ns_DASH_map) + tmp13 := lang.Apply(tmp12, []any{v6}) + tmp14 := lang.Apply(tmp7, []any{tmp8, tmp11, tmp13}) + tmp3 = tmp14 + } // end let + return tmp3 }) - tmp4 := reflect.TypeOf("") - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ns_DASH_publics = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_ns_DASH_publics.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // namespace + // ns-refers { - tmp1 := reflect.TypeOf("") - tmp0 := sym_namespace.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns the namespace String of a symbol or keyword, or nil if not present.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(1593), kw_end_DASH_line, int(1593))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_ns_DASH_refers.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns)), kw_doc, "Returns a map of the refer mappings for the namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(4253), kw_end_DASH_line, int(4253))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(v4, "Namespace") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Namespace is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{}) - return tmp6 + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "ns" + tmp4 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_filter_DASH_key) + tmp8 := checkDerefVar(var_glojure_DOT_core_val) + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v10 := args[0] + _ = v10 + var tmp11 any + { // let + // let binding "and__0__auto__" + tmp12 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp13 := reflect.TypeOf((*lang.Var)(nil)) + tmp14 := lang.Apply(tmp12, []any{tmp13, v10}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + if lang.IsTruthy(v15) { + tmp17 := checkDerefVar(var_glojure_DOT_core_not_EQ_) + tmp18, ok := lang.FieldOrMethod(v10, "Namespace") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v10, "Namespace"))) + } + var tmp19 any + switch reflect.TypeOf(tmp18).Kind() { + case reflect.Func: + tmp19 = lang.Apply(tmp18, nil) + default: + tmp19 = tmp18 + } + tmp20 := lang.Apply(tmp17, []any{v6, tmp19}) + tmp16 = tmp20 + } else { + tmp16 = v15 + } + tmp11 = tmp16 + } // end let + return tmp11 + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4259), kw_column, int(21), kw_end_DASH_line, int(4260), kw_end_DASH_column, int(59)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp12 := checkDerefVar(var_glojure_DOT_core_ns_DASH_map) + tmp13 := lang.Apply(tmp12, []any{v6}) + tmp14 := lang.Apply(tmp7, []any{tmp8, tmp11, tmp13}) + tmp3 = tmp14 + } // end let + return tmp3 }) - tmp4 := reflect.TypeOf("") - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ns_DASH_refers = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_ns_DASH_refers.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // nary-inline + // nthnext { - tmp0 := sym_nary_DASH_inline.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(948), kw_column, int(7), kw_end_DASH_line, int(948), kw_end_DASH_column, int(27), kw_arglists, lang.NewList(lang.NewVector(sym_op), lang.NewVector(sym_op, sym_unchecked_DASH_op)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_nary_DASH_inline) - tmp5 := lang.Apply(tmp4, []any{v3, v3}) - return tmp5 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 lang.FnFunc - tmp5 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v6 := args[0] - _ = v6 - var tmp7 any - { // let - // let binding "op" - var tmp8 any - tmp9 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) - if lang.IsTruthy(tmp9) { - tmp8 = v4 - } else { - tmp8 = v3 - } - var v10 any = tmp8 - _ = v10 - tmp11 := checkDerefVar(var_glojure_DOT_core_seq) - tmp12 := checkDerefVar(var_glojure_DOT_core_concat) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym__DOT_}) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := checkDerefVar(var_glojure_DOT_core_seq) - tmp19 := checkDerefVar(var_glojure_DOT_core_concat) - tmp20 := checkDerefVar(var_glojure_DOT_core_list) - tmp21 := lang.Apply(tmp20, []any{v10}) - tmp22 := checkDerefVar(var_glojure_DOT_core_list) - tmp23 := lang.Apply(tmp22, []any{v6}) - tmp24 := lang.Apply(tmp19, []any{tmp21, tmp23}) - tmp25 := lang.Apply(tmp18, []any{tmp24}) - tmp26 := lang.Apply(tmp17, []any{tmp25}) - tmp27 := lang.Apply(tmp12, []any{tmp14, tmp16, tmp26}) - tmp28 := lang.Apply(tmp11, []any{tmp27}) - tmp7 = tmp28 - } // end let - return tmp7 - case 2: - v6 := args[0] - _ = v6 - v7 := args[1] - _ = v7 - var tmp8 any - { // let - // let binding "op" - var tmp9 any - tmp10 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) - if lang.IsTruthy(tmp10) { - tmp9 = v4 - } else { - tmp9 = v3 - } - var v11 any = tmp9 - _ = v11 - tmp12 := checkDerefVar(var_glojure_DOT_core_seq) - tmp13 := checkDerefVar(var_glojure_DOT_core_concat) - tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym__DOT_}) - tmp16 := checkDerefVar(var_glojure_DOT_core_list) - tmp17 := lang.Apply(tmp16, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp18 := checkDerefVar(var_glojure_DOT_core_list) - tmp19 := checkDerefVar(var_glojure_DOT_core_seq) - tmp20 := checkDerefVar(var_glojure_DOT_core_concat) - tmp21 := checkDerefVar(var_glojure_DOT_core_list) - tmp22 := lang.Apply(tmp21, []any{v11}) - tmp23 := checkDerefVar(var_glojure_DOT_core_list) - tmp24 := lang.Apply(tmp23, []any{v6}) - tmp25 := checkDerefVar(var_glojure_DOT_core_list) - tmp26 := lang.Apply(tmp25, []any{v7}) - tmp27 := lang.Apply(tmp20, []any{tmp22, tmp24, tmp26}) - tmp28 := lang.Apply(tmp19, []any{tmp27}) - tmp29 := lang.Apply(tmp18, []any{tmp28}) - tmp30 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp29}) - tmp31 := lang.Apply(tmp12, []any{tmp30}) - tmp8 = tmp31 - } // end let - return tmp8 - default: - checkArity(args, 2) - v6 := args[0] - _ = v6 - v7 := args[1] - _ = v7 - var v8 any = lang.NewList(args[2:]...) - _ = v8 - var tmp9 any + tmp0 := sym_nthnext.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll, sym_n)), kw_doc, "Returns the nth next of coll, (seq coll) when n is 0.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(3147), kw_end_DASH_line, int(3147))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp6 := reflect.TypeOf((*lang.IDrop)(nil)).Elem() + tmp7 := lang.Apply(tmp5, []any{tmp6, v2}) + if lang.IsTruthy(tmp7) { + var tmp8 any + tmp9 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp10 := lang.Apply(tmp9, []any{v3}) + if lang.IsTruthy(tmp10) { + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) + tmp13 := lang.Apply(tmp12, []any{v3}) + if lang.IsTruthy(tmp13) { + tmp11 = v3 + } else { + tmp14 := lang.Apply(nil, []any{v3}) + tmp11 = tmp14 + } + tmp15, _ := lang.FieldOrMethod(v2, "drop") + if reflect.TypeOf(tmp15).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("drop is not a function"))) + } + tmp16 := lang.Apply(tmp15, []any{tmp11}) + tmp8 = tmp16 + } else { + tmp17 := checkDerefVar(var_glojure_DOT_core_seq) + tmp18 := lang.Apply(tmp17, []any{v2}) + tmp8 = tmp18 + } + tmp4 = tmp8 + } else { + var tmp19 any + { // let + // let binding "n" + var v20 any = v3 + _ = v20 + // let binding "xs" + tmp21 := checkDerefVar(var_glojure_DOT_core_seq) + tmp22 := lang.Apply(tmp21, []any{v2}) + var v23 any = tmp22 + _ = v23 + for { + var tmp24 any + var tmp25 any { // let - // let binding "op" - var tmp10 any - tmp11 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) - if lang.IsTruthy(tmp11) { - tmp10 = v4 + // let binding "and__0__auto__" + var v26 any = v23 + _ = v26 + var tmp27 any + if lang.IsTruthy(v26) { + tmp28 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp29 := lang.Apply(tmp28, []any{v20}) + tmp27 = tmp29 } else { - tmp10 = v3 - } - var v12 any = tmp10 - _ = v12 - tmp13 := checkDerefVar(var_glojure_DOT_core_reduce1) - var tmp14 lang.FnFunc - tmp14 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v15 := args[0] - _ = v15 - v16 := args[1] - _ = v16 - tmp17 := checkDerefVar(var_glojure_DOT_core_seq) - tmp18 := checkDerefVar(var_glojure_DOT_core_concat) - tmp19 := checkDerefVar(var_glojure_DOT_core_list) - tmp20 := lang.Apply(tmp19, []any{sym__DOT_}) - tmp21 := checkDerefVar(var_glojure_DOT_core_list) - tmp22 := lang.Apply(tmp21, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp23 := checkDerefVar(var_glojure_DOT_core_list) - tmp24 := checkDerefVar(var_glojure_DOT_core_seq) - tmp25 := checkDerefVar(var_glojure_DOT_core_concat) - tmp26 := checkDerefVar(var_glojure_DOT_core_list) - tmp27 := lang.Apply(tmp26, []any{v12}) - tmp28 := checkDerefVar(var_glojure_DOT_core_list) - tmp29 := lang.Apply(tmp28, []any{v15}) - tmp30 := checkDerefVar(var_glojure_DOT_core_list) - tmp31 := lang.Apply(tmp30, []any{v16}) - tmp32 := lang.Apply(tmp25, []any{tmp27, tmp29, tmp31}) - tmp33 := lang.Apply(tmp24, []any{tmp32}) - tmp34 := lang.Apply(tmp23, []any{tmp33}) - tmp35 := lang.Apply(tmp18, []any{tmp20, tmp22, tmp34}) - tmp36 := lang.Apply(tmp17, []any{tmp35}) - return tmp36 - }) - tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) - tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) - if err != nil { - panic(err) + tmp27 = v26 } - tmp17 := checkDerefVar(var_glojure_DOT_core_seq) - tmp18 := checkDerefVar(var_glojure_DOT_core_concat) - tmp19 := checkDerefVar(var_glojure_DOT_core_list) - tmp20 := lang.Apply(tmp19, []any{sym__DOT_}) - tmp21 := checkDerefVar(var_glojure_DOT_core_list) - tmp22 := lang.Apply(tmp21, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp23 := checkDerefVar(var_glojure_DOT_core_list) - tmp24 := checkDerefVar(var_glojure_DOT_core_seq) - tmp25 := checkDerefVar(var_glojure_DOT_core_concat) - tmp26 := checkDerefVar(var_glojure_DOT_core_list) - tmp27 := lang.Apply(tmp26, []any{v12}) - tmp28 := checkDerefVar(var_glojure_DOT_core_list) - tmp29 := lang.Apply(tmp28, []any{v6}) - tmp30 := checkDerefVar(var_glojure_DOT_core_list) - tmp31 := lang.Apply(tmp30, []any{v7}) - tmp32 := lang.Apply(tmp25, []any{tmp27, tmp29, tmp31}) - tmp33 := lang.Apply(tmp24, []any{tmp32}) - tmp34 := lang.Apply(tmp23, []any{tmp33}) - tmp35 := lang.Apply(tmp18, []any{tmp20, tmp22, tmp34}) - tmp36 := lang.Apply(tmp17, []any{tmp35}) - tmp37 := lang.Apply(tmp13, []any{tmp16, tmp36, v8}) - tmp9 = tmp37 + tmp25 = tmp27 } // end let - return tmp9 + if lang.IsTruthy(tmp25) { + tmp27 := checkDerefVar(var_glojure_DOT_core_dec) + tmp28 := lang.Apply(tmp27, []any{v20}) + var tmp26 any = tmp28 + tmp30 := checkDerefVar(var_glojure_DOT_core_next) + tmp31 := lang.Apply(tmp30, []any{v23}) + var tmp29 any = tmp31 + v20 = tmp26 + v23 = tmp29 + continue + } else { + tmp24 = v23 + } + tmp19 = tmp24 + break } - }) - tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86)) - tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp7 - default: - checkArity(args, -1) - panic("unreachable") + } // end let + tmp4 = tmp19 } + return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_nthnext = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_nthnext.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // nat-int? + // nthrest { - tmp0 := sym_nat_DASH_int_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a non-negative fixed precision integer", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(1415), kw_end_DASH_line, int(1415))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] + tmp0 := sym_nthrest.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll, sym_n)), kw_doc, "Returns the nth rest of coll, coll when n is 0.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(3161), kw_end_DASH_line, int(3161))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 var tmp4 any - { // let - // let binding "and__0__auto__" - tmp5 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) - tmp6 := lang.Apply(tmp5, []any{v3}) - var v7 any = tmp6 - _ = v7 - var tmp8 any - if lang.IsTruthy(v7) { - tmp9 := checkDerefVar(var_glojure_DOT_core_not) - tmp10 := checkDerefVar(var_glojure_DOT_core_neg_QMARK_) - tmp11 := lang.Apply(tmp10, []any{v3}) - tmp12 := lang.Apply(tmp9, []any{tmp11}) - tmp8 = tmp12 - } else { - tmp8 = v7 - } - tmp4 = tmp8 - } // end let + tmp5 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + var tmp7 any + { // let + // let binding "or__0__auto__" + var tmp8 any + tmp9 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp10 := reflect.TypeOf((*lang.IDrop)(nil)).Elem() + tmp11 := lang.Apply(tmp9, []any{tmp10, v2}) + if lang.IsTruthy(tmp11) { + var tmp12 any + tmp13 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) + tmp14 := lang.Apply(tmp13, []any{v3}) + if lang.IsTruthy(tmp14) { + tmp12 = v3 + } else { + tmp15 := lang.Apply(nil, []any{v3}) + tmp12 = tmp15 + } + tmp16, _ := lang.FieldOrMethod(v2, "drop") + if reflect.TypeOf(tmp16).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("drop is not a function"))) + } + tmp17 := lang.Apply(tmp16, []any{tmp12}) + tmp8 = tmp17 + } else { + var tmp18 any + { // let + // let binding "n" + var v19 any = v3 + _ = v19 + // let binding "xs" + var v20 any = v2 + _ = v20 + for { + var tmp21 any + { // let + // let binding "temp__0__auto__" + var tmp22 any + { // let + // let binding "and__0__auto__" + tmp23 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp24 := lang.Apply(tmp23, []any{v19}) + var v25 any = tmp24 + _ = v25 + var tmp26 any + if lang.IsTruthy(v25) { + tmp27 := checkDerefVar(var_glojure_DOT_core_seq) + tmp28 := lang.Apply(tmp27, []any{v20}) + tmp26 = tmp28 + } else { + tmp26 = v25 + } + tmp22 = tmp26 + } // end let + var v23 any = tmp22 + _ = v23 + var tmp24 any + if lang.IsTruthy(v23) { + var tmp25 any + { // let + // let binding "xs" + var v26 any = v23 + _ = v26 + tmp28 := checkDerefVar(var_glojure_DOT_core_dec) + tmp29 := lang.Apply(tmp28, []any{v19}) + var tmp27 any = tmp29 + tmp31 := checkDerefVar(var_glojure_DOT_core_rest) + tmp32 := lang.Apply(tmp31, []any{v26}) + var tmp30 any = tmp32 + v19 = tmp27 + v20 = tmp30 + continue + } // end let + tmp24 = tmp25 + } else { + tmp26 := checkDerefVar(var_glojure_DOT_core_seq) + tmp27 := lang.Apply(tmp26, []any{v20}) + tmp24 = tmp27 + } + tmp21 = tmp24 + } // end let + tmp18 = tmp21 + break + } + } // end let + tmp8 = tmp18 + } + var v19 any = tmp8 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + tmp20 = v19 + } else { + tmp20 = lang.NewList() + } + tmp7 = tmp20 + } // end let + tmp4 = tmp7 + } else { + tmp4 = v2 + } return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_nthrest = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_nthrest.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // neg-int? + // odd? { - tmp0 := sym_neg_DASH_int_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a negative fixed precision integer", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(1409), kw_end_DASH_line, int(1409))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_odd_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_doc, "Returns true if n is odd, throws an exception if n is not an integer", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1389), kw_end_DASH_line, int(1389))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "and__0__auto__" - tmp5 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) - tmp6 := lang.Apply(tmp5, []any{v3}) - var v7 any = tmp6 - _ = v7 - var tmp8 any - if lang.IsTruthy(v7) { - tmp9 := checkDerefVar(var_glojure_DOT_core_neg_QMARK_) - tmp10 := lang.Apply(tmp9, []any{v3}) - tmp8 = tmp10 - } else { - tmp8 = v7 - } - tmp4 = tmp8 - } // end let - return tmp4 + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_not) + tmp4 := checkDerefVar(var_glojure_DOT_core_even_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + tmp6 := lang.Apply(tmp3, []any{tmp5}) + return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_odd_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_odd_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // neg? + // or { + tmp0 := sym_or.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_x), lang.NewVector(sym_x, sym__AMP_, sym_next)), kw_doc, "Evaluates exprs one at a time, from left to right. If a form\n returns a logical true value, or returns that value and doesn't\n evaluate any of the other expressions, otherwise it returns the\n value of the last expression. (or) returns nil.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(11), kw_line, int(847), kw_end_DASH_line, int(847))).(*lang.Symbol) var tmp1 lang.FnFunc - { // function neg?__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_seq) - tmp5 := checkDerefVar(var_glojure_DOT_core_concat) - tmp6 := checkDerefVar(var_glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + return nil + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + return v4 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_let}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := checkDerefVar(var_glojure_DOT_core_seq) - tmp12 := checkDerefVar(var_glojure_DOT_core_concat) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_IsNeg}) + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + tmp12 := checkDerefVar(var_glojure_DOT_core_vector) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{v3}) - tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) - tmp18 := lang.Apply(tmp11, []any{tmp17}) - tmp19 := lang.Apply(tmp10, []any{tmp18}) - tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) - tmp21 := lang.Apply(tmp4, []any{tmp20}) - return tmp21 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := sym_neg_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_num)), kw_inline, tmp1, kw_doc, "Returns true if num is less than zero, else false", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1259), kw_end_DASH_line, int(1259))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "IsNeg") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("IsNeg is not a function"))) + tmp16 := lang.Apply(tmp15, []any{sym_or__0__auto__}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v4}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp19}) + tmp21 := lang.Apply(tmp11, []any{tmp12, tmp20}) + tmp22 := lang.Apply(tmp10, []any{tmp21}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_seq) + tmp25 := checkDerefVar(var_glojure_DOT_core_concat) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{sym_if}) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := lang.Apply(tmp28, []any{sym_or__0__auto__}) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := lang.Apply(tmp30, []any{sym_or__0__auto__}) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := checkDerefVar(var_glojure_DOT_core_seq) + tmp34 := checkDerefVar(var_glojure_DOT_core_concat) + tmp35 := checkDerefVar(var_glojure_DOT_core_list) + tmp36 := lang.Apply(tmp35, []any{sym_glojure_DOT_core_SLASH_or}) + tmp37 := lang.Apply(tmp34, []any{tmp36, v5}) + tmp38 := lang.Apply(tmp33, []any{tmp37}) + tmp39 := lang.Apply(tmp32, []any{tmp38}) + tmp40 := lang.Apply(tmp25, []any{tmp27, tmp29, tmp31, tmp39}) + tmp41 := lang.Apply(tmp24, []any{tmp40}) + tmp42 := lang.Apply(tmp23, []any{tmp41}) + tmp43 := lang.Apply(tmp7, []any{tmp9, tmp22, tmp42}) + tmp44 := lang.Apply(tmp6, []any{tmp43}) + return tmp44 } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // newline - { - tmp0 := sym_newline.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Writes a platform-specific newline to *out*", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(3698), kw_end_DASH_line, int(3698))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - tmp3 := checkDerefVar(var_glojure_DOT_core__STAR_out_STAR_) - tmp4 := checkDerefVar(var_glojure_DOT_core_system_DASH_newline) - tmp5 := lang.Apply(lang.AppendWriter, []any{tmp3, tmp4}) - _ = tmp5 - return nil }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_or = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_or.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // next - { - tmp1 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() - tmp0 := sym_next.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a seq of the items after the first. Calls seq on its\n argument. If there are no more items, returns nil.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(5), kw_column, int(2), kw_line, int(55), kw_end_DASH_line, int(61))).(*lang.Symbol) - var tmp3 lang.FnFunc - { // function next - var v4 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v5 := args[0] - _ = v5 - tmp6 := lang.Apply(lang.Next, []any{v5}) - return tmp6 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(61), kw_column, int(7), kw_end_DASH_line, int(61), kw_end_DASH_column, int(77))).(lang.FnFunc) - v4 = tmp3 - _ = v4 - } - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // nfirst - { - tmp0 := sym_nfirst.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Same as (next (first x))", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(2), kw_line, int(105), kw_end_DASH_line, int(109))).(*lang.Symbol) - var tmp2 lang.FnFunc - { // function nfirst - var v3 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_next) - tmp6 := checkDerefVar(var_glojure_DOT_core_first) - tmp7 := lang.Apply(tmp6, []any{v4}) - tmp8 := lang.Apply(tmp5, []any{tmp7}) - return tmp8 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(109), kw_column, int(9), kw_end_DASH_line, int(109), kw_end_DASH_column, int(49))).(lang.FnFunc) - v3 = tmp2 - _ = v3 - } - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // nil? + // parents { - tmp1 := reflect.TypeOf(false) - var tmp2 lang.FnFunc - { // function nil?__inliner - var v3 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_list) - tmp6 := lang.Apply(tmp5, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Identical, v4, nil}) + tmp0 := sym_parents.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_tag), lang.NewVector(sym_h, sym_tag)), kw_doc, "Returns the immediate parents of tag, either via a Java type\n inheritance relationship or a relationship established via derive. h\n must be a hierarchy obtained from make-hierarchy, if not supplied\n defaults to the global hierarchy", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(5564), kw_end_DASH_line, int(5564))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_parents) + tmp4 := checkDerefVar(var_glojure_DOT_core_global_DASH_hierarchy) + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_not_DASH_empty) + var tmp5 any + { // let + // let binding "tp" + tmp6 := checkDerefVar(var_glojure_DOT_core_get) + tmp7 := lang.Apply(kw_parents, []any{v2}) + tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + tmp11 := checkDerefVar(var_glojure_DOT_core_class_QMARK_) + tmp12 := lang.Apply(tmp11, []any{v3}) + if lang.IsTruthy(tmp12) { + tmp13 := checkDerefVar(var_glojure_DOT_core_into1) + tmp14 := checkDerefVar(var_glojure_DOT_core_set) + tmp15 := checkDerefVar(var_glojure_DOT_core_bases) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp14, []any{tmp16}) + tmp18 := lang.Apply(tmp13, []any{tmp17, v9}) + tmp10 = tmp18 + } else { + tmp10 = v9 + } + tmp5 = tmp10 + } // end let + tmp6 := lang.Apply(tmp4, []any{tmp5}) return tmp6 - }) - v3 = tmp2 - _ = v3 - } - tmp0 := sym_nil_QMARK_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp2, kw_doc, "Returns true if x is nil, false otherwise.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(435), kw_end_DASH_line, int(435))).(*lang.Symbol) - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v5 := args[0] - _ = v5 - tmp6 := lang.Apply(lang.IsNil, []any{v5}) - return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } }) - tmp5 := reflect.TypeOf(false) - tmp4 = tmp4.WithMeta(lang.NewMap(kw_rettag, tmp5)).(lang.FnFunc) - tmp3 := ns.InternWithValue(tmp0, tmp4, true) - if tmp0.Meta() != nil { - tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // nnext - { - tmp0 := sym_nnext.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Same as (next (next x))", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(6), kw_column, int(2), kw_line, int(119), kw_end_DASH_line, int(123))).(*lang.Symbol) - var tmp2 lang.FnFunc - { // function nnext - var v3 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_next) - tmp6 := checkDerefVar(var_glojure_DOT_core_next) - tmp7 := lang.Apply(tmp6, []any{v4}) - tmp8 := lang.Apply(tmp5, []any{tmp7}) - return tmp8 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(123), kw_column, int(8), kw_end_DASH_line, int(123), kw_end_DASH_column, int(46))).(lang.FnFunc) - v3 = tmp2 - _ = v3 - } - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_parents = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_parents.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // normalize-slurp-opts + // parse-boolean { - tmp0 := sym_normalize_DASH_slurp_DASH_opts.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6974), kw_column, int(8), kw_end_DASH_line, int(6974), kw_end_DASH_column, int(27), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_opts)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_parse_DASH_boolean.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_doc, "Parse strings \"true\" or \"false\" and return a boolean, or nil if invalid", kw_file, "glojure/core.glj", kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(7957), kw_end_DASH_line, int(7957))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) - tmp6 := checkDerefVar(var_glojure_DOT_core_first) - tmp7 := lang.Apply(tmp6, []any{v3}) - tmp8 := lang.Apply(tmp5, []any{tmp7}) - if lang.IsTruthy(tmp8) { - tmp9 := checkDerefVar(var_glojure_DOT_core_println) - tmp10 := lang.Apply(tmp9, []any{"WARNING: (slurp f enc) is deprecated, use (slurp f :encoding enc)."}) - _ = tmp10 - tmp11 := checkDerefVar(var_glojure_DOT_core_first) - tmp12 := lang.Apply(tmp11, []any{v3}) - tmp13 := lang.NewVector(kw_encoding, tmp12) - tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6979), kw_column, int(7), kw_end_DASH_line, int(6979), kw_end_DASH_column, int(30)) - tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp4 = tmp15 + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + var tmp6 any + { // let + // let binding "G__365" + var v7 any = v2 + _ = v7 + } // end let + tmp3 = tmp6 } else { - tmp4 = v3 + tmp7 := checkDerefVar(var_glojure_DOT_core_parsing_DASH_err) + tmp8 := lang.Apply(tmp7, []any{v2}) + tmp9 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp8}) + panic(tmp9) } - return tmp4 + return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_parse_DASH_boolean = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_parse_DASH_boolean.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // not + // parse-double { - tmp1 := reflect.TypeOf(false) - tmp0 := sym_not.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x is logical false, false otherwise.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(523), kw_end_DASH_line, int(523))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_parse_DASH_double.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_doc, "Parse string with floating point components and return a Double value,\n or nil if parse fails.\n\n Grammar: https://docs.oracle.com/javase/8/docs/api/java/lang/Double.html#valueOf-java.lang.String-", kw_file, "glojure/core.glj", kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(7935), kw_end_DASH_line, int(7935))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v4 := args[0] - _ = v4 - var tmp5 any - if lang.IsTruthy(v4) { - tmp5 = false + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + var tmp6 any + { // let + // let binding "result__3649__auto__" + tmp7 := lang.Apply(strconv12.ParseFloat, []any{v2, int64(64)}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + tmp10 := lang.Apply(v8, []any{int64(1)}) + if lang.IsTruthy(tmp10) { + } else { + tmp11 := lang.Apply(v8, []any{int64(0)}) + tmp9 = tmp11 + } + tmp6 = tmp9 + } // end let + tmp3 = tmp6 } else { - tmp5 = true - } - return tmp5 - }) - tmp4 := reflect.TypeOf(false) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // not-any? - { - tmp1 := reflect.TypeOf(false) - tmp0 := sym_not_DASH_any_QMARK_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns false if (pred x) is logical true for any x in coll,\n else true.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(2), kw_line, int(2696), kw_end_DASH_line, int(2701))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp4 := lang.Apply(closed36, nil) - tmp5 := lang.Apply(closed35, []any{tmp4}) - return tmp5 - case 1: - v4 := args[0] - _ = v4 - tmp5 := lang.Apply(closed36, []any{v4}) - tmp6 := lang.Apply(closed35, []any{tmp5}) - return tmp6 - case 2: - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6 := lang.Apply(closed36, []any{v4, v5}) - tmp7 := lang.Apply(closed35, []any{tmp6}) - return tmp7 - case 3: - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - v6 := args[2] - _ = v6 - tmp7 := lang.Apply(closed36, []any{v4, v5, v6}) - tmp8 := lang.Apply(closed35, []any{tmp7}) - return tmp8 - default: - checkArity(args, 3) - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - v6 := args[2] - _ = v6 - var v7 any = lang.NewList(args[3:]...) - _ = v7 - tmp8 := checkDerefVar(var_glojure_DOT_core_apply) - tmp9 := lang.Apply(tmp8, []any{closed36, v4, v5, v6, v7}) - tmp10 := lang.Apply(closed35, []any{tmp9}) - return tmp10 + tmp7 := checkDerefVar(var_glojure_DOT_core_parsing_DASH_err) + tmp8 := lang.Apply(tmp7, []any{v2}) + tmp9 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp8}) + panic(tmp9) } + return tmp3 }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2559), kw_column, int(6), kw_end_DASH_line, int(2564), kw_end_DASH_column, int(49))).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_parse_DASH_double = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_parse_DASH_double.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // not-empty + // parse-long { - tmp0 := sym_not_DASH_empty.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "If coll is empty, returns nil, else coll", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(5516), kw_end_DASH_line, int(5516))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_parse_DASH_long.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_doc, "Parse string of decimal digits with optional leading -/+ and return a\n Long value, or nil if parse fails", kw_file, "glojure/core.glj", kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(7926), kw_end_DASH_line, int(7926))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := checkDerefVar(var_glojure_DOT_core_seq) - tmp6 := lang.Apply(tmp5, []any{v3}) - if lang.IsTruthy(tmp6) { - tmp4 = v3 + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + var tmp6 any + { // let + // let binding "result__3648__auto__" + tmp7 := lang.Apply(strconv12.ParseInt, []any{v2, int64(10), int64(64)}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + tmp10 := lang.Apply(v8, []any{int64(1)}) + if lang.IsTruthy(tmp10) { + } else { + tmp11 := lang.Apply(v8, []any{int64(0)}) + tmp9 = tmp11 + } + tmp6 = tmp9 + } // end let + tmp3 = tmp6 } else { + tmp7 := checkDerefVar(var_glojure_DOT_core_parsing_DASH_err) + tmp8 := lang.Apply(tmp7, []any{v2}) + tmp9 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp8}) + panic(tmp9) } - return tmp4 + return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_parse_DASH_long = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_parse_DASH_long.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // not-every? + // partial { - tmp1 := reflect.TypeOf(false) - tmp0 := sym_not_DASH_every_QMARK_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns false if (pred x) is logical true for every x in\n coll, else true.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(2), kw_line, int(2677), kw_end_DASH_line, int(2682))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_partial.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_arg1), lang.NewVector(sym_f, sym_arg1, sym_arg2), lang.NewVector(sym_f, sym_arg1, sym_arg2, sym_arg3), lang.NewVector(sym_f, sym_arg1, sym_arg2, sym_arg3, sym__AMP_, sym_more)), kw_doc, "Takes a function f and fewer than the normal arguments to f, and\n returns a fn that takes a variable number of additional args. When\n called, the returned function calls f with args + additional args.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(2606), kw_end_DASH_line, int(2606))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 0: - tmp4 := lang.Apply(closed37, nil) - tmp5 := lang.Apply(closed35, []any{tmp4}) - return tmp5 case 1: - v4 := args[0] - _ = v4 - tmp5 := lang.Apply(closed37, []any{v4}) - tmp6 := lang.Apply(closed35, []any{tmp5}) - return tmp6 + v2 := args[0] + _ = v2 + return v2 case 2: - v4 := args[0] + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp5 := lang.Apply(v2, []any{v3}) + return tmp5 + case 1: + v5 := args[0] + _ = v5 + tmp6 := lang.Apply(v2, []any{v3, v5}) + return tmp6 + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + tmp7 := lang.Apply(v2, []any{v3, v5, v6}) + return tmp7 + case 3: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := args[2] + _ = v7 + tmp8 := lang.Apply(v2, []any{v3, v5, v6, v7}) + return tmp8 + default: + checkArity(args, 3) + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := args[2] + _ = v7 + var v8 any = lang.NewList(args[3:]...) + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_apply) + tmp10 := lang.Apply(tmp9, []any{v2, v3, v5, v6, v7, v8}) + return tmp10 + } + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2614), kw_column, int(4), kw_end_DASH_line, int(2619), kw_end_DASH_column, int(48)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] _ = v4 - v5 := args[1] - _ = v5 - tmp6 := lang.Apply(closed37, []any{v4, v5}) - tmp7 := lang.Apply(closed35, []any{tmp6}) + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp6 := lang.Apply(v2, []any{v3, v4}) + return tmp6 + case 1: + v6 := args[0] + _ = v6 + tmp7 := lang.Apply(v2, []any{v3, v4, v6}) + return tmp7 + case 2: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + tmp8 := lang.Apply(v2, []any{v3, v4, v6, v7}) + return tmp8 + case 3: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + tmp9 := lang.Apply(v2, []any{v3, v4, v6, v7, v8}) + return tmp9 + default: + checkArity(args, 3) + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + var v9 any = lang.NewList(args[3:]...) + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_apply) + tmp11 := lang.Apply(tmp10, []any{v2, v3, v4, v6, v7, v8, v9}) + return tmp11 + } + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2621), kw_column, int(4), kw_end_DASH_line, int(2626), kw_end_DASH_column, int(53)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } return tmp7 - case 3: - v4 := args[0] + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] _ = v4 - v5 := args[1] + v5 := args[3] _ = v5 - v6 := args[2] - _ = v6 - tmp7 := lang.Apply(closed37, []any{v4, v5, v6}) - tmp8 := lang.Apply(closed35, []any{tmp7}) + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp7 := lang.Apply(v2, []any{v3, v4, v5}) + return tmp7 + case 1: + v7 := args[0] + _ = v7 + tmp8 := lang.Apply(v2, []any{v3, v4, v5, v7}) + return tmp8 + case 2: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + tmp9 := lang.Apply(v2, []any{v3, v4, v5, v7, v8}) + return tmp9 + case 3: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + tmp10 := lang.Apply(v2, []any{v3, v4, v5, v7, v8, v9}) + return tmp10 + default: + checkArity(args, 3) + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + var v10 any = lang.NewList(args[3:]...) + _ = v10 + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + tmp12 := lang.Apply(tmp11, []any{v2, v3, v4, v5, v7, v8, v9, v10}) + return tmp12 + } + }) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2628), kw_column, int(4), kw_end_DASH_line, int(2633), kw_end_DASH_column, int(58)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } return tmp8 default: - checkArity(args, 3) - v4 := args[0] + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] _ = v4 - v5 := args[1] + v5 := args[3] _ = v5 - v6 := args[2] + var v6 any = lang.NewList(args[4:]...) _ = v6 - var v7 any = lang.NewList(args[3:]...) - _ = v7 - tmp8 := checkDerefVar(var_glojure_DOT_core_apply) - tmp9 := lang.Apply(tmp8, []any{closed37, v4, v5, v6, v7}) - tmp10 := lang.Apply(closed35, []any{tmp9}) - return tmp10 + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v8 any = lang.NewList(args[0:]...) + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_apply) + tmp10 := checkDerefVar(var_glojure_DOT_core_concat) + tmp11 := lang.Apply(tmp10, []any{v6, v8}) + tmp12 := lang.Apply(tmp9, []any{v2, v3, v4, v5, tmp11}) + return tmp12 + } + }) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2635), kw_column, int(4), kw_end_DASH_line, int(2635), kw_end_DASH_column, int(60)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp9 } }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2559), kw_column, int(6), kw_end_DASH_line, int(2564), kw_end_DASH_column, int(49))).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_partial = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_partial.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // not= + // partition-by { - tmp1 := reflect.TypeOf(false) - tmp0 := sym_not_EQ_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_doc, "Same as (not (= obj1 obj2))", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(812), kw_end_DASH_line, int(812))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_partition_DASH_by.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_coll)), kw_doc, "Applies f to each value in coll, splitting it each time f returns a\n new value. Returns a lazy seq of partitions. Returns a stateful\n transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(7142), kw_end_DASH_line, int(7142))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: - v4 := args[0] - _ = v4 - return false + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 any + { // let + // let binding "a" + var v6 any = "unimplemented: new with non-constant class type" + _ = v6 + // let binding "pv" + tmp7 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) + tmp8 := lang.Apply(tmp7, []any{kw_glojure_DOT_core_SLASH_none}) + var v9 any = tmp8 + _ = v9 + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp11 := lang.Apply(v4, nil) + return tmp11 + case 1: + v11 := args[0] + _ = v11 + var tmp12 any + { // let + // let binding "result" + var tmp13 any + tmp14, ok := lang.FieldOrMethod(v6, "isEmpty") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "isEmpty"))) + } + var tmp15 any + switch reflect.TypeOf(tmp14).Kind() { + case reflect.Func: + tmp15 = lang.Apply(tmp14, nil) + default: + tmp15 = tmp14 + } + if lang.IsTruthy(tmp15) { + tmp13 = v11 + } else { + var tmp16 any + { // let + // let binding "v" + tmp17 := checkDerefVar(var_glojure_DOT_core_vec) + tmp18, ok := lang.FieldOrMethod(v6, "toArray") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "toArray"))) + } + var tmp19 any + switch reflect.TypeOf(tmp18).Kind() { + case reflect.Func: + tmp19 = lang.Apply(tmp18, nil) + default: + tmp19 = tmp18 + } + tmp20 := lang.Apply(tmp17, []any{tmp19}) + var v21 any = tmp20 + _ = v21 + tmp22, ok := lang.FieldOrMethod(v6, "clear") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "clear"))) + } + var tmp23 any + switch reflect.TypeOf(tmp22).Kind() { + case reflect.Func: + tmp23 = lang.Apply(tmp22, nil) + default: + tmp23 = tmp22 + } + _ = tmp23 + tmp24 := checkDerefVar(var_glojure_DOT_core_unreduced) + tmp25 := lang.Apply(v4, []any{v11, v21}) + tmp26 := lang.Apply(tmp24, []any{tmp25}) + tmp16 = tmp26 + } // end let + tmp13 = tmp16 + } + var v17 any = tmp13 + _ = v17 + tmp18 := lang.Apply(v4, []any{v17}) + tmp12 = tmp18 + } // end let + return tmp12 + case 2: + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + var tmp13 any + { // let + // let binding "pval" + tmp14 := checkDerefVar(var_glojure_DOT_core_deref) + tmp15 := lang.Apply(tmp14, []any{v9}) + var v16 any = tmp15 + _ = v16 + // let binding "val" + tmp17 := lang.Apply(v2, []any{v12}) + var v18 any = tmp17 + _ = v18 + tmp19 := checkDerefVar(var_glojure_DOT_core_vreset_BANG_) + tmp20 := lang.Apply(tmp19, []any{v9, v18}) + _ = tmp20 + var tmp21 any + var tmp22 any + { // let + // let binding "or__0__auto__" + tmp23 := checkDerefVar(var_glojure_DOT_core_identical_QMARK_) + tmp24 := lang.Apply(tmp23, []any{v16, kw_glojure_DOT_core_SLASH_none}) + var v25 any = tmp24 + _ = v25 + var tmp26 any + if lang.IsTruthy(v25) { + tmp26 = v25 + } else { + tmp27 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp28 := lang.Apply(tmp27, []any{v18, v16}) + tmp26 = tmp28 + } + tmp22 = tmp26 + } // end let + if lang.IsTruthy(tmp22) { + tmp23, _ := lang.FieldOrMethod(v6, "add") + if reflect.TypeOf(tmp23).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) + } + tmp24 := lang.Apply(tmp23, []any{v12}) + _ = tmp24 + tmp21 = v11 + } else { + var tmp25 any + { // let + // let binding "v" + tmp26 := checkDerefVar(var_glojure_DOT_core_vec) + tmp27, ok := lang.FieldOrMethod(v6, "toArray") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "toArray"))) + } + var tmp28 any + switch reflect.TypeOf(tmp27).Kind() { + case reflect.Func: + tmp28 = lang.Apply(tmp27, nil) + default: + tmp28 = tmp27 + } + tmp29 := lang.Apply(tmp26, []any{tmp28}) + var v30 any = tmp29 + _ = v30 + tmp31, ok := lang.FieldOrMethod(v6, "clear") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "clear"))) + } + var tmp32 any + switch reflect.TypeOf(tmp31).Kind() { + case reflect.Func: + tmp32 = lang.Apply(tmp31, nil) + default: + tmp32 = tmp31 + } + _ = tmp32 + var tmp33 any + { // let + // let binding "ret" + tmp34 := lang.Apply(v4, []any{v11, v30}) + var v35 any = tmp34 + _ = v35 + var tmp36 any + tmp37 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) + tmp38 := lang.Apply(tmp37, []any{v35}) + if lang.IsTruthy(tmp38) { + } else { + tmp39, _ := lang.FieldOrMethod(v6, "add") + if reflect.TypeOf(tmp39).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) + } + tmp40 := lang.Apply(tmp39, []any{v12}) + tmp36 = tmp40 + } + _ = tmp36 + tmp33 = v35 + } // end let + tmp25 = tmp33 + } // end let + tmp21 = tmp25 + } + tmp13 = tmp21 + } // end let + return tmp13 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7152), kw_column, int(7), kw_end_DASH_line, int(7176), kw_end_DASH_column, int(28)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp5 = tmp12 + } // end let + return tmp5 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7149), kw_column, int(3), kw_end_DASH_line, int(7176), kw_end_DASH_column, int(30)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 case 2: - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6 := checkDerefVar(var_glojure_DOT_core_not) - tmp7 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp8 := lang.Apply(tmp7, []any{v4, v5}) - tmp9 := lang.Apply(tmp6, []any{tmp8}) - return tmp9 + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp5 any + { // let + // let binding "temp__0__auto__" + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := lang.Apply(tmp6, []any{v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + var tmp10 any + { // let + // let binding "s" + var v11 any = v8 + _ = v11 + var tmp12 any + { // let + // let binding "fst" + tmp13 := checkDerefVar(var_glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v11}) + var v15 any = tmp14 + _ = v15 + // let binding "fv" + tmp16 := lang.Apply(v2, []any{v15}) + var v17 any = tmp16 + _ = v17 + // let binding "run" + tmp18 := checkDerefVar(var_glojure_DOT_core_cons) + tmp19 := checkDerefVar(var_glojure_DOT_core_take_DASH_while) + var tmp20 lang.FnFunc + tmp20 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v21 := args[0] + _ = v21 + tmp22 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp23 := lang.Apply(v2, []any{v21}) + tmp24 := lang.Apply(tmp22, []any{v17, tmp23}) + return tmp24 + }) + tmp21 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7182), kw_column, int(41), kw_end_DASH_line, int(7182), kw_end_DASH_column, int(53)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp23 := checkDerefVar(var_glojure_DOT_core_next) + tmp24 := lang.Apply(tmp23, []any{v11}) + tmp25 := lang.Apply(tmp19, []any{tmp22, tmp24}) + tmp26 := lang.Apply(tmp18, []any{v15, tmp25}) + var v27 any = tmp26 + _ = v27 + tmp28 := checkDerefVar(var_glojure_DOT_core_cons) + tmp29 := checkDerefVar(var_glojure_DOT_core_partition_DASH_by) + var tmp30 lang.FnFunc + tmp30 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp31 := checkDerefVar(var_glojure_DOT_core_drop) + tmp32 := checkDerefVar(var_glojure_DOT_core_count) + tmp33 := lang.Apply(tmp32, []any{v27}) + tmp34 := lang.Apply(tmp31, []any{tmp33, v11}) + return tmp34 + }) + tmp31 := lang.Apply(lang.NewLazySeq, []any{tmp30}) + tmp32 := lang.Apply(tmp29, []any{v2, tmp31}) + tmp33 := lang.Apply(tmp28, []any{v27, tmp32}) + tmp12 = tmp33 + } // end let + tmp10 = tmp12 + } // end let + tmp9 = tmp10 + } else { + } + tmp5 = tmp9 + } // end let + return tmp5 + }) + tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) + return tmp5 default: - checkArity(args, 2) - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - var v6 any = lang.NewList(args[2:]...) - _ = v6 - tmp7 := checkDerefVar(var_glojure_DOT_core_not) - tmp8 := checkDerefVar(var_glojure_DOT_core_apply) - tmp9 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp10 := lang.Apply(tmp8, []any{tmp9, v4, v5, v6}) - tmp11 := lang.Apply(tmp7, []any{tmp10}) - return tmp11 + checkArity(args, -1) + panic("unreachable") } }) - tmp4 := reflect.TypeOf(false) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_partition_DASH_by = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_partition_DASH_by.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // ns + // pmap { - tmp0 := sym_ns.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym_docstring_QMARK_, sym_attr_DASH_map_QMARK_, sym_references_STAR_)), kw_doc, "Sets *ns* to the namespace named by name (unevaluated), creating it\n if needed. references can be zero or more of: (:refer-glojure ...)\n (:require ...) (:use ...) (:import ...) (:load ...) (:gen-class)\n with the syntax of refer-glojure/require/use/import/load/gen-class\n respectively, except the arguments are unevaluated and need not be\n quoted. (:gen-class ...), when supplied, defaults to :name\n corresponding to the ns name, :main true, :impl-ns same as ns, and\n :init-impl-ns true. All options of gen-class are\n supported. The :gen-class directive is ignored when not\n compiling. If :gen-class is not supplied, when compiled only an\n nsname__init.class will be generated. If :refer-glojure is not used, a\n default (refer 'glojure.core) is used. Use of ns is preferred to\n individual calls to in-ns/require/use/import:\n\n (ns foo.bar\n (:refer-glojure :exclude [ancestors printf])\n (:require (glojure.contrib sql combinatorics))\n (:use (my.lib this that))\n (:import (java.util Date Timer Random)\n (java.sql Connection Statement)))", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(11), kw_line, int(5742), kw_end_DASH_line, int(5742))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_pmap.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_coll), lang.NewVector(sym_f, sym_coll, sym__AMP_, sym_colls)), kw_doc, "Like map, except f is applied in parallel. Semi-lazy in that the\n parallel computation stays ahead of the consumption, but doesn't\n realize the entire result unless required. Only useful for\n computationally intensive functions where the time of f dominates\n the coordination overhead.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(7031), kw_end_DASH_line, int(7031))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - default: - checkArity(args, 3) - v3 := args[0] + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any + var tmp4 any { // let - // let binding "process-reference" - var tmp8 lang.FnFunc - tmp8 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v9 := args[0] - _ = v9 - var tmp10 any - { // let - // let binding "vec__107" - var v11 any = v9 - _ = v11 - // let binding "seq__108" - tmp12 := checkDerefVar(var_glojure_DOT_core_seq) - tmp13 := lang.Apply(tmp12, []any{v11}) - var v14 any = tmp13 - _ = v14 - // let binding "first__109" - tmp15 := checkDerefVar(var_glojure_DOT_core_first) - tmp16 := lang.Apply(tmp15, []any{v14}) - var v17 any = tmp16 - _ = v17 - // let binding "seq__108" - tmp18 := checkDerefVar(var_glojure_DOT_core_next) - tmp19 := lang.Apply(tmp18, []any{v14}) - var v20 any = tmp19 - _ = v20 - // let binding "kname" - var v21 any = v17 - _ = v21 - // let binding "args" - var v22 any = v20 - _ = v22 - tmp23 := checkDerefVar(var_glojure_DOT_core_seq) - tmp24 := checkDerefVar(var_glojure_DOT_core_concat) - tmp25 := checkDerefVar(var_glojure_DOT_core_list) - tmp26 := checkDerefVar(var_glojure_DOT_core_symbol) - tmp27 := checkDerefVar(var_glojure_DOT_core_name) - tmp28 := lang.Apply(tmp27, []any{v21}) - tmp29 := lang.Apply(tmp26, []any{"glojure.core", tmp28}) - tmp30 := lang.Apply(tmp25, []any{tmp29}) - tmp31 := checkDerefVar(var_glojure_DOT_core_map) - var tmp32 lang.FnFunc - tmp32 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v33 := args[0] - _ = v33 - tmp34 := checkDerefVar(var_glojure_DOT_core_list) - tmp35 := lang.Apply(tmp34, []any{sym_quote, v33}) - return tmp35 - }) - tmp33 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5769), kw_column, int(21), kw_end_DASH_line, int(5769), kw_end_DASH_column, int(36)) - tmp34, err := lang.WithMeta(tmp32, tmp33.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp35 := lang.Apply(tmp31, []any{tmp34, v22}) - tmp36 := lang.Apply(tmp24, []any{tmp30, tmp35}) - tmp37 := lang.Apply(tmp23, []any{tmp36}) - tmp10 = tmp37 - } // end let - return tmp10 - }) - tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5767), kw_column, int(9), kw_end_DASH_line, int(5769), kw_end_DASH_column, int(44)) - tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v11 any = tmp10 - _ = v11 - // let binding "docstring" - var tmp12 any - tmp13 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) - tmp14 := checkDerefVar(var_glojure_DOT_core_first) - tmp15 := lang.Apply(tmp14, []any{v6}) - tmp16 := lang.Apply(tmp13, []any{tmp15}) - if lang.IsTruthy(tmp16) { - tmp17 := checkDerefVar(var_glojure_DOT_core_first) - tmp18 := lang.Apply(tmp17, []any{v6}) - tmp12 = tmp18 - } else { - } - var v19 any = tmp12 - _ = v19 - // let binding "references" - var tmp20 any - if lang.IsTruthy(v19) { - tmp21 := checkDerefVar(var_glojure_DOT_core_next) - tmp22 := lang.Apply(tmp21, []any{v6}) - tmp20 = tmp22 - } else { - tmp20 = v6 - } - var v23 any = tmp20 - _ = v23 - // let binding "name" - var tmp24 any - if lang.IsTruthy(v19) { - tmp25 := checkDerefVar(var_glojure_DOT_core_vary_DASH_meta) - tmp26 := checkDerefVar(var_glojure_DOT_core_assoc) - tmp27 := lang.Apply(tmp25, []any{v5, tmp26, kw_doc, v19}) - tmp24 = tmp27 - } else { - tmp24 = v5 - } - var v28 any = tmp24 - _ = v28 - // let binding "metadata" - var tmp29 any - tmp30 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) - tmp31 := checkDerefVar(var_glojure_DOT_core_first) - tmp32 := lang.Apply(tmp31, []any{v23}) - tmp33 := lang.Apply(tmp30, []any{tmp32}) - if lang.IsTruthy(tmp33) { - tmp34 := checkDerefVar(var_glojure_DOT_core_first) - tmp35 := lang.Apply(tmp34, []any{v23}) - tmp29 = tmp35 - } else { - } - var v36 any = tmp29 - _ = v36 - // let binding "references" - var tmp37 any - if lang.IsTruthy(v36) { - tmp38 := checkDerefVar(var_glojure_DOT_core_next) - tmp39 := lang.Apply(tmp38, []any{v23}) - tmp37 = tmp39 - } else { - tmp37 = v23 - } - var v40 any = tmp37 - _ = v40 - // let binding "name" - var tmp41 any - if lang.IsTruthy(v36) { - tmp42 := checkDerefVar(var_glojure_DOT_core_vary_DASH_meta) - tmp43 := checkDerefVar(var_glojure_DOT_core_merge) - tmp44 := lang.Apply(tmp42, []any{v28, tmp43, v36}) - tmp41 = tmp44 - } else { - tmp41 = v28 - } - var v45 any = tmp41 - _ = v45 - // let binding "gen-class-clause" - tmp46 := checkDerefVar(var_glojure_DOT_core_first) - tmp47 := checkDerefVar(var_glojure_DOT_core_filter) - var tmp48 lang.FnFunc - tmp48 = lang.NewFnFunc(func(args ...any) any { + // let binding "n" + tmp5 := checkDerefVar(var_glojure_DOT_core__PLUS_) + tmp6 := lang.Apply(runtime14.NumCPU, nil) + tmp7 := lang.Apply(tmp5, []any{int64(2), tmp6}) + var v8 any = tmp7 + _ = v8 + // let binding "rets" + tmp9 := checkDerefVar(var_glojure_DOT_core_map) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v49 := args[0] - _ = v49 - tmp50 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp51 := checkDerefVar(var_glojure_DOT_core_first) - tmp52 := lang.Apply(tmp51, []any{v49}) - tmp53 := lang.Apply(tmp50, []any{kw_gen_DASH_class, tmp52}) - return tmp53 + v11 := args[0] + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_future_DASH_call) + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp14 := lang.Apply(v2, []any{v11}) + return tmp14 + }) + tmp14 := lang.Apply(tmp12, []any{tmp13}) + return tmp14 }) - tmp49 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5780), kw_column, int(41), kw_end_DASH_line, int(5780), kw_end_DASH_column, int(65)) - tmp50, err := lang.WithMeta(tmp48, tmp49.(lang.IPersistentMap)) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7041), kw_column, int(20), kw_end_DASH_line, int(7041), kw_end_DASH_column, int(34)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp51 := lang.Apply(tmp47, []any{tmp50, v40}) - tmp52 := lang.Apply(tmp46, []any{tmp51}) - var v53 any = tmp52 - _ = v53 - // let binding "gen-class-call" - var tmp54 any - if lang.IsTruthy(v53) { - tmp55 := checkDerefVar(var_glojure_DOT_core_list_STAR_) - tmp56 := checkDerefVar(var_glojure_DOT_core_str) - tmp57 := lang.Apply(tmp56, []any{v45}) - tmp58, _ := lang.FieldOrMethod(tmp57, "replace") - if reflect.TypeOf(tmp58).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("replace is not a function"))) - } - tmp59 := lang.Apply(tmp58, []any{lang.NewChar(45), lang.NewChar(95)}) - tmp60 := checkDerefVar(var_glojure_DOT_core_next) - tmp61 := lang.Apply(tmp60, []any{v53}) - tmp62 := lang.Apply(tmp55, []any{sym_glojure_DOT_core_SLASH_gen_DASH_class, kw_name, tmp59, kw_impl_DASH_ns, v45, kw_main, true, tmp61}) - tmp54 = tmp62 - } else { + tmp13 := lang.Apply(tmp9, []any{tmp12, v3}) + var v14 any = tmp13 + _ = v14 + // let binding "step" + var tmp15 lang.FnFunc + { // function step + var v16 lang.FnFunc + tmp15 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v17 := args[0] + _ = v17 + v18 := args[1] + _ = v18 + var tmp19 any + { // let + // let binding "vec__335" + var v20 any = v17 + _ = v20 + // let binding "seq__336" + tmp21 := checkDerefVar(var_glojure_DOT_core_seq) + tmp22 := lang.Apply(tmp21, []any{v20}) + var v23 any = tmp22 + _ = v23 + // let binding "first__337" + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v23}) + var v26 any = tmp25 + _ = v26 + // let binding "seq__336" + tmp27 := checkDerefVar(var_glojure_DOT_core_next) + tmp28 := lang.Apply(tmp27, []any{v23}) + var v29 any = tmp28 + _ = v29 + // let binding "x" + var v30 any = v26 + _ = v30 + // let binding "xs" + var v31 any = v29 + _ = v31 + // let binding "vs" + var v32 any = v20 + _ = v32 + var tmp33 lang.FnFunc + tmp33 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp34 any + { // let + // let binding "temp__0__auto__" + tmp35 := checkDerefVar(var_glojure_DOT_core_seq) + tmp36 := lang.Apply(tmp35, []any{v18}) + var v37 any = tmp36 + _ = v37 + var tmp38 any + if lang.IsTruthy(v37) { + var tmp39 any + { // let + // let binding "s" + var v40 any = v37 + _ = v40 + tmp41 := checkDerefVar(var_glojure_DOT_core_cons) + tmp42 := checkDerefVar(var_glojure_DOT_core_deref) + tmp43 := lang.Apply(tmp42, []any{v30}) + tmp44 := checkDerefVar(var_glojure_DOT_core_rest) + tmp45 := lang.Apply(tmp44, []any{v40}) + tmp46 := lang.Apply(v16, []any{v31, tmp45}) + tmp47 := lang.Apply(tmp41, []any{tmp43, tmp46}) + tmp39 = tmp47 + } // end let + tmp38 = tmp39 + } else { + tmp40 := checkDerefVar(var_glojure_DOT_core_map) + tmp41 := checkDerefVar(var_glojure_DOT_core_deref) + tmp42 := lang.Apply(tmp40, []any{tmp41, v32}) + tmp38 = tmp42 + } + tmp34 = tmp38 + } // end let + return tmp34 + }) + tmp34 := lang.Apply(lang.NewLazySeq, []any{tmp33}) + tmp19 = tmp34 + } // end let + return tmp19 + }) + v16 = tmp15 + _ = v16 } - var v63 any = tmp54 - _ = v63 - // let binding "references" - tmp64 := checkDerefVar(var_glojure_DOT_core_remove) - var tmp65 lang.FnFunc - tmp65 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v66 := args[0] - _ = v66 - tmp67 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp68 := checkDerefVar(var_glojure_DOT_core_first) - tmp69 := lang.Apply(tmp68, []any{v66}) - tmp70 := lang.Apply(tmp67, []any{kw_gen_DASH_class, tmp69}) - return tmp70 - }) - tmp66 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5784), kw_column, int(28), kw_end_DASH_line, int(5784), kw_end_DASH_column, int(52)) - tmp67, err := lang.WithMeta(tmp65, tmp66.(lang.IPersistentMap)) + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7042), kw_column, int(15), kw_end_DASH_line, int(7046), kw_end_DASH_column, int(36)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp68 := lang.Apply(tmp64, []any{tmp67, v40}) - var v69 any = tmp68 - _ = v69 - // let binding "name-metadata" - tmp70 := checkDerefVar(var_glojure_DOT_core_meta) - tmp71 := lang.Apply(tmp70, []any{v45}) - var v72 any = tmp71 - _ = v72 - tmp73 := checkDerefVar(var_glojure_DOT_core_seq) - tmp74 := checkDerefVar(var_glojure_DOT_core_concat) - tmp75 := checkDerefVar(var_glojure_DOT_core_list) - tmp76 := lang.Apply(tmp75, []any{sym_do}) - tmp77 := checkDerefVar(var_glojure_DOT_core_list) - tmp78 := checkDerefVar(var_glojure_DOT_core_seq) - tmp79 := checkDerefVar(var_glojure_DOT_core_concat) - tmp80 := checkDerefVar(var_glojure_DOT_core_list) - tmp81 := lang.Apply(tmp80, []any{sym_glojure_DOT_core_SLASH_in_DASH_ns}) - tmp82 := checkDerefVar(var_glojure_DOT_core_list) - tmp83 := checkDerefVar(var_glojure_DOT_core_seq) - tmp84 := checkDerefVar(var_glojure_DOT_core_concat) - tmp85 := checkDerefVar(var_glojure_DOT_core_list) - tmp86 := lang.Apply(tmp85, []any{sym_quote}) - tmp87 := checkDerefVar(var_glojure_DOT_core_list) - tmp88 := lang.Apply(tmp87, []any{v45}) - tmp89 := lang.Apply(tmp84, []any{tmp86, tmp88}) - tmp90 := lang.Apply(tmp83, []any{tmp89}) - tmp91 := lang.Apply(tmp82, []any{tmp90}) - tmp92 := lang.Apply(tmp79, []any{tmp81, tmp91}) - tmp93 := lang.Apply(tmp78, []any{tmp92}) - tmp94 := lang.Apply(tmp77, []any{tmp93}) - var tmp95 any - if lang.IsTruthy(v72) { - tmp96 := checkDerefVar(var_glojure_DOT_core_seq) - tmp97 := checkDerefVar(var_glojure_DOT_core_concat) - tmp98 := checkDerefVar(var_glojure_DOT_core_list) - tmp99 := checkDerefVar(var_glojure_DOT_core_seq) - tmp100 := checkDerefVar(var_glojure_DOT_core_concat) - tmp101 := checkDerefVar(var_glojure_DOT_core_list) - tmp102 := lang.Apply(tmp101, []any{sym__DOT_ResetMeta}) - tmp103 := checkDerefVar(var_glojure_DOT_core_list) - tmp104 := checkDerefVar(var_glojure_DOT_core_seq) - tmp105 := checkDerefVar(var_glojure_DOT_core_concat) - tmp106 := checkDerefVar(var_glojure_DOT_core_list) - tmp107 := lang.Apply(tmp106, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_FindNamespace}) - tmp108 := checkDerefVar(var_glojure_DOT_core_list) - tmp109 := checkDerefVar(var_glojure_DOT_core_seq) - tmp110 := checkDerefVar(var_glojure_DOT_core_concat) - tmp111 := checkDerefVar(var_glojure_DOT_core_list) - tmp112 := lang.Apply(tmp111, []any{sym_quote}) - tmp113 := checkDerefVar(var_glojure_DOT_core_list) - tmp114 := lang.Apply(tmp113, []any{v45}) - tmp115 := lang.Apply(tmp110, []any{tmp112, tmp114}) - tmp116 := lang.Apply(tmp109, []any{tmp115}) - tmp117 := lang.Apply(tmp108, []any{tmp116}) - tmp118 := lang.Apply(tmp105, []any{tmp107, tmp117}) - tmp119 := lang.Apply(tmp104, []any{tmp118}) - tmp120 := lang.Apply(tmp103, []any{tmp119}) - tmp121 := checkDerefVar(var_glojure_DOT_core_list) - tmp122 := lang.Apply(tmp121, []any{v72}) - tmp123 := lang.Apply(tmp100, []any{tmp102, tmp120, tmp122}) - tmp124 := lang.Apply(tmp99, []any{tmp123}) - tmp125 := lang.Apply(tmp98, []any{tmp124}) - tmp126 := lang.Apply(tmp97, []any{tmp125}) - tmp127 := lang.Apply(tmp96, []any{tmp126}) - tmp95 = tmp127 - } else { + var v18 any = tmp17 + _ = v18 + tmp19 := checkDerefVar(var_glojure_DOT_core_drop) + tmp20 := lang.Apply(tmp19, []any{v8, v14}) + tmp21 := lang.Apply(v18, []any{v14, tmp20}) + tmp4 = tmp21 + } // end let + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "step" + var tmp6 lang.FnFunc + { // function step + var v7 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v8 := args[0] + _ = v8 + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp10 any + { // let + // let binding "ss" + tmp11 := checkDerefVar(var_glojure_DOT_core_map) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := lang.Apply(tmp11, []any{tmp12, v8}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + tmp16 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + tmp17 := checkDerefVar(var_glojure_DOT_core_identity) + tmp18 := lang.Apply(tmp16, []any{tmp17, v14}) + if lang.IsTruthy(tmp18) { + tmp19 := checkDerefVar(var_glojure_DOT_core_cons) + tmp20 := checkDerefVar(var_glojure_DOT_core_map) + tmp21 := checkDerefVar(var_glojure_DOT_core_first) + tmp22 := lang.Apply(tmp20, []any{tmp21, v14}) + tmp23 := checkDerefVar(var_glojure_DOT_core_map) + tmp24 := checkDerefVar(var_glojure_DOT_core_rest) + tmp25 := lang.Apply(tmp23, []any{tmp24, v14}) + tmp26 := lang.Apply(v7, []any{tmp25}) + tmp27 := lang.Apply(tmp19, []any{tmp22, tmp26}) + tmp15 = tmp27 + } else { + } + tmp10 = tmp15 + } // end let + return tmp10 + }) + tmp10 := lang.Apply(lang.NewLazySeq, []any{tmp9}) + return tmp10 + }) + v7 = tmp6 + _ = v7 } - tmp128 := checkDerefVar(var_glojure_DOT_core_list) - tmp129 := checkDerefVar(var_glojure_DOT_core_seq) - tmp130 := checkDerefVar(var_glojure_DOT_core_concat) - tmp131 := checkDerefVar(var_glojure_DOT_core_list) - tmp132 := lang.Apply(tmp131, []any{sym_glojure_DOT_core_SLASH_with_DASH_loading_DASH_context}) - var tmp133 any - if lang.IsTruthy(v63) { - tmp134 := checkDerefVar(var_glojure_DOT_core_list) - tmp135 := lang.Apply(tmp134, []any{v63}) - tmp133 = tmp135 - } else { + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7049), kw_column, int(15), kw_end_DASH_line, int(7053), kw_end_DASH_column, int(67)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) } - var tmp136 any - var tmp137 any - { // let - // let binding "and__0__auto__" - tmp138 := checkDerefVar(var_glojure_DOT_core_not_EQ_) - tmp139 := lang.Apply(tmp138, []any{v45, sym_glojure_DOT_core}) - var v140 any = tmp139 - _ = v140 - var tmp141 any - if lang.IsTruthy(v140) { - tmp142 := checkDerefVar(var_glojure_DOT_core_not_DASH_any_QMARK_) - var tmp143 lang.FnFunc - tmp143 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v144 := args[0] - _ = v144 - tmp145 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp146 := checkDerefVar(var_glojure_DOT_core_first) - tmp147 := lang.Apply(tmp146, []any{v144}) - tmp148 := lang.Apply(tmp145, []any{kw_refer_DASH_glojure, tmp147}) - return tmp148 - }) - tmp144 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5793), kw_column, int(58), kw_end_DASH_line, int(5793), kw_end_DASH_column, int(86)) - tmp145, err := lang.WithMeta(tmp143, tmp144.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp146 := lang.Apply(tmp142, []any{tmp145, v69}) - tmp141 = tmp146 - } else { - tmp141 = v140 - } - tmp137 = tmp141 - } // end let - if lang.IsTruthy(tmp137) { - tmp138 := checkDerefVar(var_glojure_DOT_core_seq) - tmp139 := checkDerefVar(var_glojure_DOT_core_concat) - tmp140 := checkDerefVar(var_glojure_DOT_core_list) - tmp141 := checkDerefVar(var_glojure_DOT_core_seq) - tmp142 := checkDerefVar(var_glojure_DOT_core_concat) - tmp143 := checkDerefVar(var_glojure_DOT_core_list) - tmp144 := lang.Apply(tmp143, []any{sym_glojure_DOT_core_SLASH_refer}) - tmp145 := checkDerefVar(var_glojure_DOT_core_list) - tmp146 := checkDerefVar(var_glojure_DOT_core_seq) - tmp147 := checkDerefVar(var_glojure_DOT_core_concat) - tmp148 := checkDerefVar(var_glojure_DOT_core_list) - tmp149 := lang.Apply(tmp148, []any{sym_quote}) - tmp150 := checkDerefVar(var_glojure_DOT_core_list) - tmp151 := lang.Apply(tmp150, []any{sym_glojure_DOT_core}) - tmp152 := lang.Apply(tmp147, []any{tmp149, tmp151}) - tmp153 := lang.Apply(tmp146, []any{tmp152}) - tmp154 := lang.Apply(tmp145, []any{tmp153}) - tmp155 := lang.Apply(tmp142, []any{tmp144, tmp154}) - tmp156 := lang.Apply(tmp141, []any{tmp155}) - tmp157 := lang.Apply(tmp140, []any{tmp156}) - tmp158 := lang.Apply(tmp139, []any{tmp157}) - tmp159 := lang.Apply(tmp138, []any{tmp158}) - tmp136 = tmp159 - } else { + var v9 any = tmp8 + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_pmap) + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v12 := args[0] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_apply) + tmp14 := lang.Apply(tmp13, []any{v2, v12}) + return tmp14 + }) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7054), kw_column, int(12), kw_end_DASH_line, int(7054), kw_end_DASH_column, int(23)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) } - tmp160 := checkDerefVar(var_glojure_DOT_core_map) - tmp161 := lang.Apply(tmp160, []any{v11, v69}) - tmp162 := lang.Apply(tmp130, []any{tmp132, tmp133, tmp136, tmp161}) - tmp163 := lang.Apply(tmp129, []any{tmp162}) - tmp164 := lang.Apply(tmp128, []any{tmp163}) - tmp165 := checkDerefVar(var_glojure_DOT_core_list) - tmp166 := checkDerefVar(var_glojure_DOT_core_seq) - tmp167 := checkDerefVar(var_glojure_DOT_core_concat) - tmp168 := checkDerefVar(var_glojure_DOT_core_list) - tmp169 := lang.Apply(tmp168, []any{sym_if}) - tmp170 := checkDerefVar(var_glojure_DOT_core_list) - tmp171 := checkDerefVar(var_glojure_DOT_core_seq) - tmp172 := checkDerefVar(var_glojure_DOT_core_concat) - tmp173 := checkDerefVar(var_glojure_DOT_core_list) - tmp174 := lang.Apply(tmp173, []any{sym__DOT_Equals}) - tmp175 := checkDerefVar(var_glojure_DOT_core_list) - tmp176 := checkDerefVar(var_glojure_DOT_core_seq) - tmp177 := checkDerefVar(var_glojure_DOT_core_concat) - tmp178 := checkDerefVar(var_glojure_DOT_core_list) - tmp179 := lang.Apply(tmp178, []any{sym_quote}) - tmp180 := checkDerefVar(var_glojure_DOT_core_list) - tmp181 := lang.Apply(tmp180, []any{v45}) - tmp182 := lang.Apply(tmp177, []any{tmp179, tmp181}) - tmp183 := lang.Apply(tmp176, []any{tmp182}) - tmp184 := lang.Apply(tmp175, []any{tmp183}) - tmp185 := checkDerefVar(var_glojure_DOT_core_list) - tmp186 := checkDerefVar(var_glojure_DOT_core_seq) - tmp187 := checkDerefVar(var_glojure_DOT_core_concat) - tmp188 := checkDerefVar(var_glojure_DOT_core_list) - tmp189 := lang.Apply(tmp188, []any{sym_quote}) - tmp190 := checkDerefVar(var_glojure_DOT_core_list) - tmp191 := lang.Apply(tmp190, []any{sym_glojure_DOT_core}) - tmp192 := lang.Apply(tmp187, []any{tmp189, tmp191}) - tmp193 := lang.Apply(tmp186, []any{tmp192}) - tmp194 := lang.Apply(tmp185, []any{tmp193}) - tmp195 := lang.Apply(tmp172, []any{tmp174, tmp184, tmp194}) - tmp196 := lang.Apply(tmp171, []any{tmp195}) - tmp197 := lang.Apply(tmp170, []any{tmp196}) - tmp198 := checkDerefVar(var_glojure_DOT_core_list) - tmp199 := lang.Apply(tmp198, []any{nil}) - tmp200 := checkDerefVar(var_glojure_DOT_core_list) - tmp201 := checkDerefVar(var_glojure_DOT_core_seq) - tmp202 := checkDerefVar(var_glojure_DOT_core_concat) - tmp203 := checkDerefVar(var_glojure_DOT_core_list) - tmp204 := lang.Apply(tmp203, []any{sym_do}) - tmp205 := checkDerefVar(var_glojure_DOT_core_list) - tmp206 := checkDerefVar(var_glojure_DOT_core_seq) - tmp207 := checkDerefVar(var_glojure_DOT_core_concat) - tmp208 := checkDerefVar(var_glojure_DOT_core_list) - tmp209 := lang.Apply(tmp208, []any{sym_glojure_DOT_core_SLASH_dosync}) - tmp210 := checkDerefVar(var_glojure_DOT_core_list) - tmp211 := checkDerefVar(var_glojure_DOT_core_seq) - tmp212 := checkDerefVar(var_glojure_DOT_core_concat) - tmp213 := checkDerefVar(var_glojure_DOT_core_list) - tmp214 := lang.Apply(tmp213, []any{sym_glojure_DOT_core_SLASH_commute}) - tmp215 := checkDerefVar(var_glojure_DOT_core_list) - tmp216 := checkDerefVar(var_glojure_DOT_core_seq) - tmp217 := checkDerefVar(var_glojure_DOT_core_concat) - tmp218 := checkDerefVar(var_glojure_DOT_core_list) - tmp219 := lang.Apply(tmp218, []any{sym_glojure_DOT_core_SLASH_deref}) - tmp220 := checkDerefVar(var_glojure_DOT_core_list) - tmp221 := checkDerefVar(var_glojure_DOT_core_seq) - tmp222 := checkDerefVar(var_glojure_DOT_core_concat) - tmp223 := checkDerefVar(var_glojure_DOT_core_list) - tmp224 := lang.Apply(tmp223, []any{sym_var}) - tmp225 := checkDerefVar(var_glojure_DOT_core_list) - tmp226 := lang.Apply(tmp225, []any{sym_glojure_DOT_core_SLASH__STAR_loaded_DASH_libs_STAR_}) - tmp227 := lang.Apply(tmp222, []any{tmp224, tmp226}) - tmp228 := lang.Apply(tmp221, []any{tmp227}) - tmp229 := lang.Apply(tmp220, []any{tmp228}) - tmp230 := lang.Apply(tmp217, []any{tmp219, tmp229}) - tmp231 := lang.Apply(tmp216, []any{tmp230}) - tmp232 := lang.Apply(tmp215, []any{tmp231}) - tmp233 := checkDerefVar(var_glojure_DOT_core_list) - tmp234 := lang.Apply(tmp233, []any{sym_glojure_DOT_core_SLASH_conj}) - tmp235 := checkDerefVar(var_glojure_DOT_core_list) - tmp236 := checkDerefVar(var_glojure_DOT_core_seq) - tmp237 := checkDerefVar(var_glojure_DOT_core_concat) - tmp238 := checkDerefVar(var_glojure_DOT_core_list) - tmp239 := lang.Apply(tmp238, []any{sym_quote}) - tmp240 := checkDerefVar(var_glojure_DOT_core_list) - tmp241 := lang.Apply(tmp240, []any{v45}) - tmp242 := lang.Apply(tmp237, []any{tmp239, tmp241}) - tmp243 := lang.Apply(tmp236, []any{tmp242}) - tmp244 := lang.Apply(tmp235, []any{tmp243}) - tmp245 := lang.Apply(tmp212, []any{tmp214, tmp232, tmp234, tmp244}) - tmp246 := lang.Apply(tmp211, []any{tmp245}) - tmp247 := lang.Apply(tmp210, []any{tmp246}) - tmp248 := lang.Apply(tmp207, []any{tmp209, tmp247}) - tmp249 := lang.Apply(tmp206, []any{tmp248}) - tmp250 := lang.Apply(tmp205, []any{tmp249}) - tmp251 := checkDerefVar(var_glojure_DOT_core_list) - tmp252 := lang.Apply(tmp251, []any{nil}) - tmp253 := lang.Apply(tmp202, []any{tmp204, tmp250, tmp252}) - tmp254 := lang.Apply(tmp201, []any{tmp253}) - tmp255 := lang.Apply(tmp200, []any{tmp254}) - tmp256 := lang.Apply(tmp167, []any{tmp169, tmp197, tmp199, tmp255}) - tmp257 := lang.Apply(tmp166, []any{tmp256}) - tmp258 := lang.Apply(tmp165, []any{tmp257}) - tmp259 := lang.Apply(tmp74, []any{tmp76, tmp94, tmp95, tmp164, tmp258}) - tmp260 := lang.Apply(tmp73, []any{tmp259}) - tmp7 = tmp260 + tmp14 := checkDerefVar(var_glojure_DOT_core_cons) + tmp15 := lang.Apply(tmp14, []any{v3, v4}) + tmp16 := lang.Apply(v9, []any{tmp15}) + tmp17 := lang.Apply(tmp10, []any{tmp13, tmp16}) + tmp5 = tmp17 } // end let - return tmp7 + return tmp5 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_pmap = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_pmap.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // ns-aliases + // pos-int? { - tmp0 := sym_ns_DASH_aliases.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns)), kw_doc, "Returns a map of the aliases for the namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4273), kw_end_DASH_line, int(4273))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_pos_DASH_int_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a positive fixed precision integer", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(1403), kw_end_DASH_line, int(1403))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) - tmp5 := lang.Apply(tmp4, []any{v3}) - tmp6, ok := lang.FieldOrMethod(tmp5, "getAliases") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp5, "getAliases"))) - } - var tmp7 any - switch reflect.TypeOf(tmp6).Kind() { - case reflect.Func: - tmp7 = lang.Apply(tmp6, nil) - default: - tmp7 = tmp6 - } - return tmp7 + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "and__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + tmp8 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp9 := lang.Apply(tmp8, []any{v2}) + tmp7 = tmp9 + } else { + tmp7 = v6 + } + tmp3 = tmp7 + } // end let + return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_pos_DASH_int_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_pos_DASH_int_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // ns-imports + // preserving-reduced { - tmp0 := sym_ns_DASH_imports.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns)), kw_doc, "Returns a map of the import mappings for the namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4199), kw_end_DASH_line, int(4199))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_preserving_DASH_reduced.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(7638), kw_column, int(7), kw_end_DASH_line, int(7638), kw_end_DASH_column, int(34), kw_arglists, lang.NewList(lang.NewVector(sym_rf)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_filter_DASH_key) - tmp5 := checkDerefVar(var_glojure_DOT_core_val) - tmp6 := checkDerefVar(var_glojure_DOT_core_partial) - tmp7 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp8 := reflect.TypeOf((*reflect.Type)(nil)).Elem() - tmp9 := lang.Apply(tmp6, []any{tmp7, tmp8}) - tmp10 := checkDerefVar(var_glojure_DOT_core_ns_DASH_map) - tmp11 := lang.Apply(tmp10, []any{v3}) - tmp12 := lang.Apply(tmp4, []any{tmp5, tmp9, tmp11}) - return tmp12 + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var tmp6 any + { // let + // let binding "ret" + tmp7 := lang.Apply(v2, []any{v4, v5}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) + tmp11 := lang.Apply(tmp10, []any{v8}) + if lang.IsTruthy(tmp11) { + tmp12 := checkDerefVar(var_glojure_DOT_core_reduced) + tmp13 := lang.Apply(tmp12, []any{v8}) + tmp9 = tmp13 + } else { + tmp9 = v8 + } + tmp6 = tmp9 + } // end let + return tmp6 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7640), kw_column, int(3), kw_end_DASH_line, int(7643), kw_end_DASH_column, int(12)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_preserving_DASH_reduced = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_preserving_DASH_reduced.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // ns-interns + // print-sequential { - tmp0 := sym_ns_DASH_interns.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns)), kw_doc, "Returns a map of the intern mappings for the namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4206), kw_end_DASH_line, int(4206))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] + tmp0 := sym_print_DASH_sequential.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(46), kw_column, int(8), kw_end_DASH_line, int(46), kw_end_DASH_column, int(23), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_begin, sym_print_DASH_one, sym_sep, sym_end, sym_sequence, sym_w)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 6) + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - var tmp4 any + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + v7 := args[5] + _ = v7 + var tmp8 any { // let - // let binding "ns" - tmp5 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) - tmp6 := lang.Apply(tmp5, []any{v3}) - var v7 any = tmp6 - _ = v7 - tmp8 := checkDerefVar(var_glojure_DOT_core_filter_DASH_key) - tmp9 := checkDerefVar(var_glojure_DOT_core_val) - var tmp10 lang.FnFunc - tmp10 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v11 := args[0] - _ = v11 - var tmp12 any + tmp9 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp10 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp11 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_print_DASH_level_STAR_) + var tmp12 any + { // let + // let binding "and__0__auto__" + tmp13 := checkDerefVar(var_glojure_DOT_core_not) + tmp14 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_dup_STAR_) + tmp15 := lang.Apply(tmp13, []any{tmp14}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + if lang.IsTruthy(v16) { + var tmp18 any + { // let + // let binding "and__0__auto__" + tmp19 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_level_STAR_) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + tmp22 := checkDerefVar(var_glojure_DOT_core_dec) + tmp23 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_level_STAR_) + tmp24 := lang.Apply(tmp22, []any{tmp23}) + tmp21 = tmp24 + } else { + tmp21 = v20 + } + tmp18 = tmp21 + } // end let + tmp17 = tmp18 + } else { + tmp17 = v16 + } + tmp12 = tmp17 + } // end let + tmp13 := lang.Apply(tmp10, []any{tmp11, tmp12}) + tmp14 := lang.Apply(tmp9, []any{tmp13}) + _ = tmp14 + var tmp15 any + func() { + defer func() { + tmp16 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp17 := lang.Apply(tmp16, nil) + _ = tmp17 + }() + var tmp18 any + var tmp19 any { // let // let binding "and__0__auto__" - tmp13 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp14 := reflect.TypeOf((*lang.Var)(nil)) - tmp15 := lang.Apply(tmp13, []any{tmp14, v11}) - var v16 any = tmp15 - _ = v16 - var tmp17 any - if lang.IsTruthy(v16) { - tmp18 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp19, ok := lang.FieldOrMethod(v11, "Namespace") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v11, "Namespace"))) - } - var tmp20 any - switch reflect.TypeOf(tmp19).Kind() { - case reflect.Func: - tmp20 = lang.Apply(tmp19, nil) - default: - tmp20 = tmp19 - } - tmp21 := lang.Apply(tmp18, []any{v7, tmp20}) - tmp17 = tmp21 + tmp20 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_level_STAR_) + var v21 any = tmp20 + _ = v21 + var tmp22 any + if lang.IsTruthy(v21) { + tmp23 := checkDerefVar(var_glojure_DOT_core_neg_QMARK_) + tmp24 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_level_STAR_) + tmp25 := lang.Apply(tmp23, []any{tmp24}) + tmp22 = tmp25 } else { - tmp17 = v16 + tmp22 = v21 } - tmp12 = tmp17 + tmp19 = tmp22 } // end let - return tmp12 - }) - tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4212), kw_column, int(21), kw_end_DASH_line, int(4213), kw_end_DASH_column, int(56)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp13 := checkDerefVar(var_glojure_DOT_core_ns_DASH_map) - tmp14 := lang.Apply(tmp13, []any{v7}) - tmp15 := lang.Apply(tmp8, []any{tmp9, tmp12, tmp14}) - tmp4 = tmp15 + if lang.IsTruthy(tmp19) { + tmp20 := lang.Apply(lang.WriteWriter, []any{v7, "#"}) + tmp18 = tmp20 + } else { + tmp21 := lang.Apply(lang.WriteWriter, []any{v7, v2}) + _ = tmp21 + var tmp22 any + { // let + // let binding "temp__0__auto__" + tmp23 := checkDerefVar(var_glojure_DOT_core_seq) + tmp24 := lang.Apply(tmp23, []any{v6}) + var v25 any = tmp24 + _ = v25 + var tmp26 any + if lang.IsTruthy(v25) { + var tmp27 any + { // let + // let binding "xs" + var v28 any = v25 + _ = v28 + var tmp29 any + var tmp30 any + { // let + // let binding "and__0__auto__" + tmp31 := checkDerefVar(var_glojure_DOT_core_not) + tmp32 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_dup_STAR_) + tmp33 := lang.Apply(tmp31, []any{tmp32}) + var v34 any = tmp33 + _ = v34 + var tmp35 any + if lang.IsTruthy(v34) { + tmp36 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_length_STAR_) + tmp35 = tmp36 + } else { + tmp35 = v34 + } + tmp30 = tmp35 + } // end let + if lang.IsTruthy(tmp30) { + var tmp31 any + { // let + // let binding "G__194" + var v32 any = v28 + _ = v32 + // let binding "vec__195" + var v33 any = v32 + _ = v33 + // let binding "seq__196" + tmp34 := checkDerefVar(var_glojure_DOT_core_seq) + tmp35 := lang.Apply(tmp34, []any{v33}) + var v36 any = tmp35 + _ = v36 + // let binding "first__197" + tmp37 := checkDerefVar(var_glojure_DOT_core_first) + tmp38 := lang.Apply(tmp37, []any{v36}) + var v39 any = tmp38 + _ = v39 + // let binding "seq__196" + tmp40 := checkDerefVar(var_glojure_DOT_core_next) + tmp41 := lang.Apply(tmp40, []any{v36}) + var v42 any = tmp41 + _ = v42 + // let binding "x" + var v43 any = v39 + _ = v43 + // let binding "xs" + var v44 any = v42 + _ = v44 + // let binding "print-length" + tmp45 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_length_STAR_) + var v46 any = tmp45 + _ = v46 + var tmp47 any + { // let + // let binding "G__194" + var v48 any = v32 + _ = v48 + // let binding "print-length" + var v49 any = v46 + _ = v49 + for { + var tmp50 any + { // let + // let binding "vec__198" + var v51 any = v48 + _ = v51 + // let binding "seq__199" + tmp52 := checkDerefVar(var_glojure_DOT_core_seq) + tmp53 := lang.Apply(tmp52, []any{v51}) + var v54 any = tmp53 + _ = v54 + // let binding "first__200" + tmp55 := checkDerefVar(var_glojure_DOT_core_first) + tmp56 := lang.Apply(tmp55, []any{v54}) + var v57 any = tmp56 + _ = v57 + // let binding "seq__199" + tmp58 := checkDerefVar(var_glojure_DOT_core_next) + tmp59 := lang.Apply(tmp58, []any{v54}) + var v60 any = tmp59 + _ = v60 + // let binding "x" + var v61 any = v57 + _ = v61 + // let binding "xs" + var v62 any = v60 + _ = v62 + // let binding "print-length" + var v63 any = v49 + _ = v63 + var tmp64 any + tmp65 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) + tmp66 := lang.Apply(tmp65, []any{v63}) + if lang.IsTruthy(tmp66) { + tmp67 := lang.Apply(lang.WriteWriter, []any{v7, "..."}) + tmp64 = tmp67 + } else { + tmp68 := lang.Apply(v3, []any{v61, v7}) + _ = tmp68 + var tmp69 any + if lang.IsTruthy(v62) { + tmp70 := lang.Apply(lang.WriteWriter, []any{v7, v4}) + _ = tmp70 + var tmp71 any = v62 + tmp73 := checkDerefVar(var_glojure_DOT_core_dec) + tmp74 := lang.Apply(tmp73, []any{v63}) + var tmp72 any = tmp74 + v48 = tmp71 + v49 = tmp72 + continue + } else { + } + tmp64 = tmp69 + } + tmp50 = tmp64 + } // end let + tmp47 = tmp50 + break + } + } // end let + tmp31 = tmp47 + } // end let + tmp29 = tmp31 + } else { + var tmp32 any + { // let + // let binding "G__204" + var v33 any = v28 + _ = v33 + // let binding "vec__205" + var v34 any = v33 + _ = v34 + // let binding "seq__206" + tmp35 := checkDerefVar(var_glojure_DOT_core_seq) + tmp36 := lang.Apply(tmp35, []any{v34}) + var v37 any = tmp36 + _ = v37 + // let binding "first__207" + tmp38 := checkDerefVar(var_glojure_DOT_core_first) + tmp39 := lang.Apply(tmp38, []any{v37}) + var v40 any = tmp39 + _ = v40 + // let binding "seq__206" + tmp41 := checkDerefVar(var_glojure_DOT_core_next) + tmp42 := lang.Apply(tmp41, []any{v37}) + var v43 any = tmp42 + _ = v43 + // let binding "x" + var v44 any = v40 + _ = v44 + // let binding "xs" + var v45 any = v43 + _ = v45 + var tmp46 any + { // let + // let binding "G__204" + var v47 any = v33 + _ = v47 + for { + var tmp48 any + { // let + // let binding "vec__208" + var v49 any = v47 + _ = v49 + // let binding "seq__209" + tmp50 := checkDerefVar(var_glojure_DOT_core_seq) + tmp51 := lang.Apply(tmp50, []any{v49}) + var v52 any = tmp51 + _ = v52 + // let binding "first__210" + tmp53 := checkDerefVar(var_glojure_DOT_core_first) + tmp54 := lang.Apply(tmp53, []any{v52}) + var v55 any = tmp54 + _ = v55 + // let binding "seq__209" + tmp56 := checkDerefVar(var_glojure_DOT_core_next) + tmp57 := lang.Apply(tmp56, []any{v52}) + var v58 any = tmp57 + _ = v58 + // let binding "x" + var v59 any = v55 + _ = v59 + // let binding "xs" + var v60 any = v58 + _ = v60 + tmp61 := lang.Apply(v3, []any{v59, v7}) + _ = tmp61 + var tmp62 any + if lang.IsTruthy(v60) { + tmp63 := lang.Apply(lang.WriteWriter, []any{v7, v4}) + _ = tmp63 + var tmp64 any = v60 + v47 = tmp64 + continue + } else { + } + tmp48 = tmp62 + } // end let + tmp46 = tmp48 + break + } + } // end let + tmp32 = tmp46 + } // end let + tmp29 = tmp32 + } + tmp27 = tmp29 + } // end let + tmp26 = tmp27 + } else { + } + tmp22 = tmp26 + } // end let + _ = tmp22 + tmp23 := lang.Apply(lang.WriteWriter, []any{v7, v5}) + tmp18 = tmp23 + } + tmp15 = tmp18 + }() + tmp8 = tmp15 } // end let - return tmp4 + return tmp8 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_print_DASH_sequential = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_print_DASH_sequential.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // ns-map + // protocol? { - tmp0 := sym_ns_DASH_map.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns)), kw_doc, "Returns a map of all the mappings for the namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(4170), kw_end_DASH_line, int(4170))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_protocol_QMARK_.WithMeta(lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(110), kw_column, int(8), kw_end_DASH_line, int(110), kw_end_DASH_column, int(16), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_maybe_DASH_p)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) - tmp5 := lang.Apply(tmp4, []any{v3}) - tmp6, ok := lang.FieldOrMethod(tmp5, "Mappings") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp5, "Mappings"))) - } - var tmp7 any - switch reflect.TypeOf(tmp6).Kind() { - case reflect.Func: - tmp7 = lang.Apply(tmp6, nil) - default: - tmp7 = tmp6 + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := reflect.TypeOf((*lang.IAtom)(nil)).Elem() + tmp6 := lang.Apply(tmp4, []any{tmp5, v2}) + if lang.IsTruthy(tmp6) { + tmp7 := checkDerefVar(var_glojure_DOT_core_boolean) + tmp8 := checkDerefVar(var_glojure_DOT_core_deref) + tmp9 := lang.Apply(tmp8, []any{v2}) + tmp10 := lang.Apply(kw_on_DASH_interface, []any{tmp9}) + tmp11 := lang.Apply(tmp7, []any{tmp10}) + tmp3 = tmp11 + } else { + tmp3 = false } - return tmp7 + return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_protocol_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_protocol_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // ns-name + // pvalues { - tmp0 := sym_ns_DASH_name.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns)), kw_doc, "Returns the name of the namespace, a symbol.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4163), kw_end_DASH_line, int(4163))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) - tmp5 := lang.Apply(tmp4, []any{v3}) - tmp6, ok := lang.FieldOrMethod(tmp5, "Name") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp5, "Name"))) - } - var tmp7 any - switch reflect.TypeOf(tmp6).Kind() { - case reflect.Func: - tmp7 = lang.Apply(tmp6, nil) + tmp0 := sym_pvalues.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_exprs)), kw_doc, "Returns a lazy sequence of the values of the exprs, which are\n evaluated in parallel", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(7063), kw_end_DASH_line, int(7063))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { default: - tmp7 = tmp6 + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym_glojure_DOT_core_SLASH_pcalls}) + tmp9 := checkDerefVar(var_glojure_DOT_core_map) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v11 := args[0] + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.NewVector() + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7069), kw_column, int(30), kw_end_DASH_line, int(7069), kw_end_DASH_column, int(31)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp16 := lang.Apply(tmp12, []any{sym_glojure_DOT_core_SLASH_fn, tmp15, v11}) + return tmp16 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7069), kw_column, int(19), kw_end_DASH_line, int(7069), kw_end_DASH_column, int(34)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := lang.Apply(tmp9, []any{tmp12, v4}) + tmp14 := lang.Apply(tmp6, []any{tmp8, tmp13}) + tmp15 := lang.Apply(tmp5, []any{tmp14}) + return tmp15 } - return tmp7 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_pvalues = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_pvalues.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // ns-publics + // qualified-ident? { - tmp0 := sym_ns_DASH_publics.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns)), kw_doc, "Returns a map of the public intern mappings for the namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4188), kw_end_DASH_line, int(4188))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_qualified_DASH_ident_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a symbol or keyword with a namespace", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(22), kw_column, int(7), kw_line, int(1618), kw_end_DASH_line, int(1618))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v3 := args[0] - _ = v3 + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_boolean) var tmp4 any { // let - // let binding "ns" - tmp5 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) - tmp6 := lang.Apply(tmp5, []any{v3}) + // let binding "and__0__auto__" + tmp5 := checkDerefVar(var_glojure_DOT_core_ident_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v2}) var v7 any = tmp6 _ = v7 - tmp8 := checkDerefVar(var_glojure_DOT_core_filter_DASH_key) - tmp9 := checkDerefVar(var_glojure_DOT_core_val) - var tmp10 lang.FnFunc - tmp10 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v11 := args[0] - _ = v11 - var tmp12 any + var tmp8 any + if lang.IsTruthy(v7) { + var tmp9 any { // let // let binding "and__0__auto__" - tmp13 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp14 := reflect.TypeOf((*lang.Var)(nil)) - tmp15 := lang.Apply(tmp13, []any{tmp14, v11}) - var v16 any = tmp15 - _ = v16 - var tmp17 any - if lang.IsTruthy(v16) { - var tmp18 any - { // let - // let binding "and__0__auto__" - tmp19 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp20, ok := lang.FieldOrMethod(v11, "Namespace") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v11, "Namespace"))) - } - var tmp21 any - switch reflect.TypeOf(tmp20).Kind() { - case reflect.Func: - tmp21 = lang.Apply(tmp20, nil) - default: - tmp21 = tmp20 - } - tmp22 := lang.Apply(tmp19, []any{v7, tmp21}) - var v23 any = tmp22 - _ = v23 - var tmp24 any - if lang.IsTruthy(v23) { - tmp25, ok := lang.FieldOrMethod(v11, "IsPublic") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v11, "IsPublic"))) - } - var tmp26 any - switch reflect.TypeOf(tmp25).Kind() { - case reflect.Func: - tmp26 = lang.Apply(tmp25, nil) - default: - tmp26 = tmp25 - } - tmp24 = tmp26 - } else { - tmp24 = v23 - } - tmp18 = tmp24 - } // end let - tmp17 = tmp18 + tmp10 := checkDerefVar(var_glojure_DOT_core_namespace) + tmp11 := lang.Apply(tmp10, []any{v2}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + tmp13 = true + } else { + tmp13 = v12 + } + tmp9 = tmp13 + } // end let + tmp8 = tmp9 + } else { + tmp8 = v7 + } + tmp4 = tmp8 + } // end let + tmp5 := lang.Apply(tmp3, []any{tmp4}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_qualified_DASH_ident_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_qualified_DASH_ident_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // qualified-keyword? + { + tmp0 := sym_qualified_DASH_keyword_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a keyword with a namespace", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(24), kw_column, int(7), kw_line, int(1638), kw_end_DASH_line, int(1638))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp4 any + { // let + // let binding "and__0__auto__" + tmp5 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v2}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + if lang.IsTruthy(v7) { + var tmp9 any + { // let + // let binding "and__0__auto__" + tmp10 := checkDerefVar(var_glojure_DOT_core_namespace) + tmp11 := lang.Apply(tmp10, []any{v2}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + tmp13 = true } else { - tmp17 = v16 + tmp13 = v12 } - tmp12 = tmp17 + tmp9 = tmp13 } // end let - return tmp12 - }) - tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4194), kw_column, int(21), kw_end_DASH_line, int(4196), kw_end_DASH_column, int(48)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) - if err != nil { - panic(err) + tmp8 = tmp9 + } else { + tmp8 = v7 } - tmp13 := checkDerefVar(var_glojure_DOT_core_ns_DASH_map) - tmp14 := lang.Apply(tmp13, []any{v7}) - tmp15 := lang.Apply(tmp8, []any{tmp9, tmp12, tmp14}) - tmp4 = tmp15 + tmp4 = tmp8 } // end let - return tmp4 + tmp5 := lang.Apply(tmp3, []any{tmp4}) + return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_qualified_DASH_keyword_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_qualified_DASH_keyword_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // ns-refers + // qualified-symbol? { - tmp0 := sym_ns_DASH_refers.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns)), kw_doc, "Returns a map of the refer mappings for the namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(4253), kw_end_DASH_line, int(4253))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_qualified_DASH_symbol_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a symbol with a namespace", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(7), kw_line, int(1628), kw_end_DASH_line, int(1628))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v3 := args[0] - _ = v3 + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_boolean) var tmp4 any { // let - // let binding "ns" - tmp5 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) - tmp6 := lang.Apply(tmp5, []any{v3}) + // let binding "and__0__auto__" + tmp5 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v2}) var v7 any = tmp6 _ = v7 - tmp8 := checkDerefVar(var_glojure_DOT_core_filter_DASH_key) - tmp9 := checkDerefVar(var_glojure_DOT_core_val) - var tmp10 lang.FnFunc - tmp10 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v11 := args[0] - _ = v11 - var tmp12 any + var tmp8 any + if lang.IsTruthy(v7) { + var tmp9 any { // let // let binding "and__0__auto__" - tmp13 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp14 := reflect.TypeOf((*lang.Var)(nil)) - tmp15 := lang.Apply(tmp13, []any{tmp14, v11}) - var v16 any = tmp15 - _ = v16 - var tmp17 any - if lang.IsTruthy(v16) { - tmp18 := checkDerefVar(var_glojure_DOT_core_not_EQ_) - tmp19, ok := lang.FieldOrMethod(v11, "Namespace") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v11, "Namespace"))) - } - var tmp20 any - switch reflect.TypeOf(tmp19).Kind() { - case reflect.Func: - tmp20 = lang.Apply(tmp19, nil) - default: - tmp20 = tmp19 - } - tmp21 := lang.Apply(tmp18, []any{v7, tmp20}) - tmp17 = tmp21 + tmp10 := checkDerefVar(var_glojure_DOT_core_namespace) + tmp11 := lang.Apply(tmp10, []any{v2}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + tmp13 = true } else { - tmp17 = v16 + tmp13 = v12 } - tmp12 = tmp17 + tmp9 = tmp13 } // end let - return tmp12 - }) - tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4259), kw_column, int(21), kw_end_DASH_line, int(4260), kw_end_DASH_column, int(59)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) - if err != nil { - panic(err) + tmp8 = tmp9 + } else { + tmp8 = v7 } - tmp13 := checkDerefVar(var_glojure_DOT_core_ns_DASH_map) - tmp14 := lang.Apply(tmp13, []any{v7}) - tmp15 := lang.Apply(tmp8, []any{tmp9, tmp12, tmp14}) - tmp4 = tmp15 + tmp4 = tmp8 } // end let - return tmp4 + tmp5 := lang.Apply(tmp3, []any{tmp4}) + return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_qualified_DASH_symbol_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_qualified_DASH_symbol_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // ns-resolve + // rand { - tmp0 := sym_ns_DASH_resolve.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns, sym_sym), lang.NewVector(sym_ns, sym_env, sym_sym)), kw_doc, "Returns the var or Class to which a symbol will be resolved in the\n namespace (unless found in the environment), else nil. Note that\n if the symbol is fully qualified, the var/Class to which it resolves\n need not be present in the namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4358), kw_end_DASH_line, int(4358))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_rand.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_n)), kw_doc, "Returns a random floating point number between 0 (inclusive) and\n n (default 1) (exclusive).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(4935), kw_end_DASH_line, int(4935))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_ns_DASH_resolve) - tmp6 := lang.Apply(tmp5, []any{v3, nil, v4}) - return tmp6 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var tmp6 any - tmp7 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) - tmp8 := lang.Apply(tmp7, []any{v4, v5}) - if lang.IsTruthy(tmp8) { - } else { - tmp9 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) - tmp10 := lang.Apply(tmp9, []any{v3}) - tmp11, _ := lang.FieldOrMethod(runtime.Compiler, "maybeResolveIn") - if reflect.TypeOf(tmp11).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("maybeResolveIn is not a function"))) - } - tmp12 := lang.Apply(tmp11, []any{tmp10, v5}) - tmp6 = tmp12 - } + case 0: + tmp2 := lang.Apply(rand16.Float64, nil) + return tmp2 + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core__STAR_) + tmp4 := checkDerefVar(var_glojure_DOT_core_rand) + tmp5 := lang.Apply(tmp4, nil) + tmp6 := lang.Apply(tmp3, []any{v2, tmp5}) return tmp6 default: checkArity(args, -1) panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_rand = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_rand.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // ns-unalias + // rand-int { - tmp0 := sym_ns_DASH_unalias.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns, sym_sym)), kw_doc, "Removes the alias for the symbol from the namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4280), kw_end_DASH_line, int(4280))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) - tmp6 := lang.Apply(tmp5, []any{v3}) - tmp7, _ := lang.FieldOrMethod(tmp6, "removeAlias") - if reflect.TypeOf(tmp7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("removeAlias is not a function"))) - } - tmp8 := lang.Apply(tmp7, []any{v4}) - return tmp8 + tmp0 := sym_rand_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_doc, "Returns a random integer between 0 (inclusive) and n (exclusive).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(4943), kw_end_DASH_line, int(4943))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_int) + tmp4 := checkDerefVar(var_glojure_DOT_core_rand) + tmp5 := lang.Apply(tmp4, []any{v2}) + tmp6 := lang.Apply(tmp3, []any{tmp5}) + return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_rand_DASH_int = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_rand_DASH_int.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // ns-unmap + // rand-nth { - tmp0 := sym_ns_DASH_unmap.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns, sym_sym)), kw_doc, "Removes the mappings for the symbol from the namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(4177), kw_end_DASH_line, int(4177))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) - tmp6 := lang.Apply(tmp5, []any{v3}) - tmp7, _ := lang.FieldOrMethod(tmp6, "unmap") - if reflect.TypeOf(tmp7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("unmap is not a function"))) - } - tmp8 := lang.Apply(tmp7, []any{v4}) + tmp0 := sym_rand_DASH_nth.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Return a random element of the (sequential) collection. Will have\n the same performance characteristics as nth for the given\n collection.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(7213), kw_end_DASH_line, int(7213))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_nth) + tmp4 := checkDerefVar(var_glojure_DOT_core_rand_DASH_int) + tmp5 := checkDerefVar(var_glojure_DOT_core_count) + tmp6 := lang.Apply(tmp5, []any{v2}) + tmp7 := lang.Apply(tmp4, []any{tmp6}) + tmp8 := lang.Apply(tmp3, []any{v2, tmp7}) return tmp8 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_rand_DASH_nth = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_rand_DASH_nth.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // nth + // random-sample { + tmp0 := sym_random_DASH_sample.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_prob), lang.NewVector(sym_prob, sym_coll)), kw_doc, "Returns items from coll with random probability of prob (0.0 -\n 1.0). Returns a transducer when no collection is provided.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(7699), kw_end_DASH_line, int(7699))).(*lang.Symbol) var tmp1 lang.FnFunc - { // function nth__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - tmp6 := checkDerefVar(var_glojure_DOT_core_seq) - tmp7 := checkDerefVar(var_glojure_DOT_core_concat) - tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{sym__DOT_}) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) - tmp12 := checkDerefVar(var_glojure_DOT_core_list) - tmp13 := checkDerefVar(var_glojure_DOT_core_seq) - tmp14 := checkDerefVar(var_glojure_DOT_core_concat) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_Nth}) - tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := checkDerefVar(var_glojure_DOT_core_seq) - tmp19 := checkDerefVar(var_glojure_DOT_core_concat) - tmp20 := checkDerefVar(var_glojure_DOT_core_list) - tmp21 := lang.Apply(tmp20, []any{sym_glojure_DOT_core_SLASH_unquote}) - tmp22 := checkDerefVar(var_glojure_DOT_core_list) - tmp23 := lang.Apply(tmp22, []any{sym_glojure_DOT_core_SLASH_c}) - tmp24 := lang.Apply(tmp19, []any{tmp21, tmp23}) - tmp25 := lang.Apply(tmp18, []any{tmp24}) - tmp26 := lang.Apply(tmp17, []any{tmp25}) - tmp27 := checkDerefVar(var_glojure_DOT_core_list) - tmp28 := checkDerefVar(var_glojure_DOT_core_seq) - tmp29 := checkDerefVar(var_glojure_DOT_core_concat) - tmp30 := checkDerefVar(var_glojure_DOT_core_list) - tmp31 := lang.Apply(tmp30, []any{sym_glojure_DOT_core_SLASH_unquote}) - tmp32 := checkDerefVar(var_glojure_DOT_core_list) - tmp33 := lang.Apply(tmp32, []any{sym_glojure_DOT_core_SLASH_i}) - tmp34 := lang.Apply(tmp29, []any{tmp31, tmp33}) - tmp35 := lang.Apply(tmp28, []any{tmp34}) - tmp36 := lang.Apply(tmp27, []any{tmp35}) - tmp37 := checkDerefVar(var_glojure_DOT_core_list) - tmp38 := checkDerefVar(var_glojure_DOT_core_seq) - tmp39 := checkDerefVar(var_glojure_DOT_core_concat) - tmp40 := checkDerefVar(var_glojure_DOT_core_list) - tmp41 := lang.Apply(tmp40, []any{sym_glojure_DOT_core_SLASH_unquote_DASH_splicing}) - tmp42 := checkDerefVar(var_glojure_DOT_core_list) - tmp43 := lang.Apply(tmp42, []any{sym_glojure_DOT_core_SLASH_nf}) - tmp44 := lang.Apply(tmp39, []any{tmp41, tmp43}) - tmp45 := lang.Apply(tmp38, []any{tmp44}) - tmp46 := lang.Apply(tmp37, []any{tmp45}) - tmp47 := lang.Apply(tmp14, []any{tmp16, tmp26, tmp36, tmp46}) - tmp48 := lang.Apply(tmp13, []any{tmp47}) - tmp49 := lang.Apply(tmp12, []any{tmp48}) - tmp50 := lang.Apply(tmp7, []any{tmp9, tmp11, tmp49}) - tmp51 := lang.Apply(tmp6, []any{tmp50}) - return tmp51 - } - }) - v2 = tmp1 - _ = v2 - } - tmp0 := sym_nth.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll, sym_index), lang.NewVector(sym_coll, sym_index, sym_not_DASH_found)), kw_inline, tmp1, kw_doc, "Returns the value at the index. get returns nil if index out of\n bounds, nth throws an exception unless not-found is supplied. nth\n also works for strings, Java arrays, regex Matchers and Lists, and,\n in O(n) time, for sequences.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2), int64(3)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(882), kw_end_DASH_line, int(882))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 2: - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6, _ := lang.FieldOrMethod(runtime.RT, "Nth") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Nth is not a function"))) + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_filter) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v5 := args[0] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp7 := checkDerefVar(var_glojure_DOT_core_rand) + tmp8 := lang.Apply(tmp7, nil) + tmp9 := lang.Apply(tmp6, []any{tmp8, v2}) + return tmp9 + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7704), kw_column, int(14), kw_end_DASH_line, int(7704), kw_end_DASH_column, int(37)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) + tmp7 := lang.Apply(tmp3, []any{tmp6}) return tmp7 - case 3: - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - v6 := args[2] - _ = v6 - tmp7, _ := lang.FieldOrMethod(runtime.RT, "NthDefault") - if reflect.TypeOf(tmp7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("NthDefault is not a function"))) + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_filter) + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v6 := args[0] + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp8 := checkDerefVar(var_glojure_DOT_core_rand) + tmp9 := lang.Apply(tmp8, nil) + tmp10 := lang.Apply(tmp7, []any{tmp9, v2}) + return tmp10 + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7706), kw_column, int(14), kw_end_DASH_line, int(7706), kw_end_DASH_column, int(37)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) } - tmp8 := lang.Apply(tmp7, []any{v4, v5, v6}) + tmp8 := lang.Apply(tmp4, []any{tmp7, v3}) return tmp8 default: checkArity(args, -1) panic("unreachable") } }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_random_DASH_sample = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_random_DASH_sample.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // nthnext + // re-groups { - tmp0 := sym_nthnext.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll, sym_n)), kw_doc, "Returns the nth next of coll, (seq coll) when n is 0.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(3147), kw_end_DASH_line, int(3147))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - tmp6 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp7 := reflect.TypeOf((*lang.IDrop)(nil)).Elem() - tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) - if lang.IsTruthy(tmp8) { - var tmp9 any - tmp10 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) - tmp11 := lang.Apply(tmp10, []any{v4}) - if lang.IsTruthy(tmp11) { - var tmp12 any - tmp13 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) - tmp14 := lang.Apply(tmp13, []any{v4}) - if lang.IsTruthy(tmp14) { - tmp12 = v4 - } else { - tmp15 := lang.Apply(nil, []any{v4}) - tmp12 = tmp15 - } - tmp16, _ := lang.FieldOrMethod(v3, "drop") - if reflect.TypeOf(tmp16).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("drop is not a function"))) + tmp0 := sym_re_DASH_groups.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m)), kw_doc, "Returns the groups from the most recent match/find. If there are no\n nested groups, returns a string of the entire match. If there are\n nested groups, returns a vector of the groups, the first element\n being the entire match.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(4882), kw_end_DASH_line, int(4882))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "gc" + tmp4, _ := lang.FieldOrMethod(v2, "groupCount") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("groupCount is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) + tmp9 := lang.Apply(tmp8, []any{v6}) + if lang.IsTruthy(tmp9) { + tmp10, _ := lang.FieldOrMethod(v2, "group") + if reflect.TypeOf(tmp10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("group is not a function"))) } - tmp17 := lang.Apply(tmp16, []any{tmp12}) - tmp9 = tmp17 + tmp11 := lang.Apply(tmp10, []any{}) + tmp7 = tmp11 } else { - tmp18 := checkDerefVar(var_glojure_DOT_core_seq) - tmp19 := lang.Apply(tmp18, []any{v3}) - tmp9 = tmp19 - } - tmp5 = tmp9 - } else { - var tmp20 any - { // let - // let binding "n" - var v21 any = v4 - _ = v21 - // let binding "xs" - tmp22 := checkDerefVar(var_glojure_DOT_core_seq) - tmp23 := lang.Apply(tmp22, []any{v3}) - var v24 any = tmp23 - _ = v24 - for { - var tmp25 any - var tmp26 any - { // let - // let binding "and__0__auto__" - var v27 any = v24 - _ = v27 - var tmp28 any - if lang.IsTruthy(v27) { - tmp29 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) - tmp30 := lang.Apply(tmp29, []any{v21}) - tmp28 = tmp30 + var tmp12 any + { // let + // let binding "ret" + tmp13 := lang.NewVector() + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4893), kw_column, int(20), kw_end_DASH_line, int(4893), kw_end_DASH_column, int(21)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v16 any = tmp15 + _ = v16 + // let binding "c" + var v17 any = int64(0) + _ = v17 + for { + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core__LT__EQ_) + tmp20 := lang.Apply(tmp19, []any{v17, v6}) + if lang.IsTruthy(tmp20) { + tmp22 := checkDerefVar(var_glojure_DOT_core_conj) + tmp23, _ := lang.FieldOrMethod(v2, "groupInt") + if reflect.TypeOf(tmp23).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("groupInt is not a function"))) + } + tmp24 := lang.Apply(tmp23, []any{v17}) + tmp25 := lang.Apply(tmp22, []any{v16, tmp24}) + var tmp21 any = tmp25 + tmp27 := checkDerefVar(var_glojure_DOT_core_inc) + tmp28 := lang.Apply(tmp27, []any{v17}) + var tmp26 any = tmp28 + v16 = tmp21 + v17 = tmp26 + continue } else { - tmp28 = v27 + tmp18 = v16 } - tmp26 = tmp28 - } // end let - if lang.IsTruthy(tmp26) { - tmp28 := checkDerefVar(var_glojure_DOT_core_dec) - tmp29 := lang.Apply(tmp28, []any{v21}) - var tmp27 any = tmp29 - tmp31 := checkDerefVar(var_glojure_DOT_core_next) - tmp32 := lang.Apply(tmp31, []any{v24}) - var tmp30 any = tmp32 - v21 = tmp27 - v24 = tmp30 - continue - } else { - tmp25 = v24 - } - tmp20 = tmp25 - break - } - } // end let - tmp5 = tmp20 - } - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // nthrest - { - tmp0 := sym_nthrest.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll, sym_n)), kw_doc, "Returns the nth rest of coll, coll when n is 0.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(3161), kw_end_DASH_line, int(3161))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - tmp6 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) - tmp7 := lang.Apply(tmp6, []any{v4}) - if lang.IsTruthy(tmp7) { - var tmp8 any - { // let - // let binding "or__0__auto__" - var tmp9 any - tmp10 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp11 := reflect.TypeOf((*lang.IDrop)(nil)).Elem() - tmp12 := lang.Apply(tmp10, []any{tmp11, v3}) - if lang.IsTruthy(tmp12) { - var tmp13 any - tmp14 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) - tmp15 := lang.Apply(tmp14, []any{v4}) - if lang.IsTruthy(tmp15) { - tmp13 = v4 - } else { - tmp16 := lang.Apply(nil, []any{v4}) - tmp13 = tmp16 - } - tmp17, _ := lang.FieldOrMethod(v3, "drop") - if reflect.TypeOf(tmp17).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("drop is not a function"))) + tmp12 = tmp18 + break } - tmp18 := lang.Apply(tmp17, []any{tmp13}) - tmp9 = tmp18 - } else { - var tmp19 any - { // let - // let binding "n" - var v20 any = v4 - _ = v20 - // let binding "xs" - var v21 any = v3 - _ = v21 - for { - var tmp22 any - { // let - // let binding "temp__0__auto__" - var tmp23 any - { // let - // let binding "and__0__auto__" - tmp24 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) - tmp25 := lang.Apply(tmp24, []any{v20}) - var v26 any = tmp25 - _ = v26 - var tmp27 any - if lang.IsTruthy(v26) { - tmp28 := checkDerefVar(var_glojure_DOT_core_seq) - tmp29 := lang.Apply(tmp28, []any{v21}) - tmp27 = tmp29 - } else { - tmp27 = v26 - } - tmp23 = tmp27 - } // end let - var v24 any = tmp23 - _ = v24 - var tmp25 any - if lang.IsTruthy(v24) { - var tmp26 any - { // let - // let binding "xs" - var v27 any = v24 - _ = v27 - tmp29 := checkDerefVar(var_glojure_DOT_core_dec) - tmp30 := lang.Apply(tmp29, []any{v20}) - var tmp28 any = tmp30 - tmp32 := checkDerefVar(var_glojure_DOT_core_rest) - tmp33 := lang.Apply(tmp32, []any{v27}) - var tmp31 any = tmp33 - v20 = tmp28 - v21 = tmp31 - continue - } // end let - tmp25 = tmp26 - } else { - tmp27 := checkDerefVar(var_glojure_DOT_core_seq) - tmp28 := lang.Apply(tmp27, []any{v21}) - tmp25 = tmp28 - } - tmp22 = tmp25 - } // end let - tmp19 = tmp22 - break - } - } // end let - tmp9 = tmp19 - } - var v20 any = tmp9 - _ = v20 - var tmp21 any - if lang.IsTruthy(v20) { - tmp21 = v20 - } else { - tmp21 = lang.NewList() - } - tmp8 = tmp21 - } // end let - tmp5 = tmp8 - } else { - tmp5 = v3 - } - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // num - { - var tmp1 lang.FnFunc - { // function num__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_seq) - tmp5 := checkDerefVar(var_glojure_DOT_core_concat) - tmp6 := checkDerefVar(var_glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) - tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := checkDerefVar(var_glojure_DOT_core_seq) - tmp12 := checkDerefVar(var_glojure_DOT_core_concat) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Num}) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{v3}) - tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) - tmp18 := lang.Apply(tmp11, []any{tmp17}) - tmp19 := lang.Apply(tmp10, []any{tmp18}) - tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) - tmp21 := lang.Apply(tmp4, []any{tmp20}) - return tmp21 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := sym_num.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to Number", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(3474), kw_end_DASH_line, int(3474))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Num") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Num is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 + } // end let + tmp7 = tmp12 + } + tmp3 = tmp7 + } // end let + return tmp3 }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_re_DASH_groups = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_re_DASH_groups.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // number? + // re-matches { - tmp0 := sym_number_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x is a Number", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(3560), kw_end_DASH_line, int(3560))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] + tmp0 := sym_re_DASH_matches.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_re, sym_s)), kw_doc, "Returns the match, if any, of string to pattern, using\n java.util.regex.Matcher.matches(). Uses re-groups to return the\n groups.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4910), kw_end_DASH_line, int(4910))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - tmp4 := lang.Apply(lang.IsNumber, []any{v3}) + var tmp4 any + { // let + // let binding "m" + tmp5 := checkDerefVar(var_glojure_DOT_core_re_DASH_matcher) + tmp6 := lang.Apply(tmp5, []any{v2, v3}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + tmp9, _ := lang.FieldOrMethod(v7, "matches") + if reflect.TypeOf(tmp9).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("matches is not a function"))) + } + tmp10 := lang.Apply(tmp9, []any{}) + if lang.IsTruthy(tmp10) { + tmp11 := checkDerefVar(var_glojure_DOT_core_re_DASH_groups) + tmp12 := lang.Apply(tmp11, []any{v7}) + tmp8 = tmp12 + } else { + } + tmp4 = tmp8 + } // end let return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_re_DASH_matches = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_re_DASH_matches.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // numerator + // re-seq { - tmp1 := reflect.TypeOf((*big9.Int)(nil)) - tmp0 := sym_numerator.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_r)), kw_doc, "Returns the numerator part of a Ratio.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(3583), kw_end_DASH_line, int(3583))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5, ok := lang.FieldOrMethod(v4, "numerator") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "numerator"))) - } - var tmp6 any - switch reflect.TypeOf(tmp5).Kind() { - case reflect.Func: - tmp6 = lang.Apply(tmp5, nil) - default: - tmp6 = tmp5 - } - return tmp6 + tmp0 := sym_re_DASH_seq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_re, sym_s)), kw_doc, "Returns a lazy sequence of successive matches of pattern in string,\n using java.util.regex.Matcher.find(), each such match processed with\n re-groups.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(4898), kw_end_DASH_line, int(4898))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "m" + tmp5 := checkDerefVar(var_glojure_DOT_core_re_DASH_matcher) + tmp6 := lang.Apply(tmp5, []any{v2, v3}) + var v7 any = tmp6 + _ = v7 + var tmp8 lang.FnFunc + { // function step + var v9 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp10 any + tmp11, _ := lang.FieldOrMethod(v7, "find") + if reflect.TypeOf(tmp11).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("find is not a function"))) + } + tmp12 := lang.Apply(tmp11, []any{}) + if lang.IsTruthy(tmp12) { + tmp13 := checkDerefVar(var_glojure_DOT_core_cons) + tmp14 := checkDerefVar(var_glojure_DOT_core_re_DASH_groups) + tmp15 := lang.Apply(tmp14, []any{v7}) + var tmp16 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp17 := lang.Apply(v9, nil) + return tmp17 + }) + tmp17 := lang.Apply(lang.NewLazySeq, []any{tmp16}) + tmp18 := lang.Apply(tmp13, []any{tmp15, tmp17}) + tmp10 = tmp18 + } else { + } + return tmp10 + }) + v9 = tmp8 + _ = v9 + } + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4906), kw_column, int(6), kw_end_DASH_line, int(4908), kw_end_DASH_column, int(49)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp11 := lang.Apply(tmp10, nil) + tmp4 = tmp11 + } // end let + return tmp4 }) - tmp4 := reflect.TypeOf((*big9.Int)(nil)) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_re_DASH_seq = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_re_DASH_seq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // object-array + // refer { + tmp0 := sym_refer.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns_DASH_sym, sym__AMP_, sym_filters)), kw_doc, "refers to all public vars of ns, subject to filters.\n filters can include at most one each of:\n\n :exclude list-of-symbols\n :only list-of-symbols\n :rename map-of-fromsymbol-tosymbol\n\n For each public interned var in the namespace named by the symbol,\n adds a mapping from the name of the var to the var to the current\n namespace. Throws an exception if name is already mapped to\n something else in the current namespace. Filters can be used to\n select a subset, via inclusion or exclusion, or to provide a mapping\n to a symbol different from the var's name, in order to prevent\n clashes. Use :use in the ns macro in preference to calling this directly.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(4216), kw_end_DASH_line, int(4216))).(*lang.Symbol) var tmp1 lang.FnFunc - { // function object-array__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: checkArity(args, 1) - v3 := args[0] + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_seq) - tmp5 := checkDerefVar(var_glojure_DOT_core_concat) - tmp6 := checkDerefVar(var_glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) - tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Object_array}) - tmp12 := checkDerefVar(var_glojure_DOT_core_list) - tmp13 := lang.Apply(tmp12, []any{v3}) - tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) - tmp15 := lang.Apply(tmp4, []any{tmp14}) - return tmp15 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := sym_object_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_size_DASH_or_DASH_seq)), kw_inline, tmp1, kw_doc, "Creates an array of objects", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1)})), kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(5349), kw_end_DASH_line, int(5349))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(runtime.RT, "Object_array") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Object_array is not a function"))) + var tmp4 any + { // let + // let binding "ns" + var tmp5 any + { // let + // let binding "or__0__auto__" + tmp6 := checkDerefVar(var_glojure_DOT_core_find_DASH_ns) + tmp7 := lang.Apply(tmp6, []any{v2}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + tmp9 = v8 + } else { + tmp10 := checkDerefVar(var_glojure_DOT_core_str) + tmp11 := lang.Apply(tmp10, []any{"No namespace: ", v2}) + tmp12 := lang.Apply(errors8.New, []any{tmp11}) + panic(tmp12) + } + tmp5 = tmp9 + } // end let + var v6 any = tmp5 + _ = v6 + // let binding "fs" + tmp7 := checkDerefVar(var_glojure_DOT_core_apply) + tmp8 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp9 := lang.Apply(tmp7, []any{tmp8, v3}) + var v10 any = tmp9 + _ = v10 + // let binding "nspublics" + tmp11 := checkDerefVar(var_glojure_DOT_core_ns_DASH_publics) + tmp12 := lang.Apply(tmp11, []any{v6}) + var v13 any = tmp12 + _ = v13 + // let binding "rename" + var tmp14 any + { // let + // let binding "or__0__auto__" + tmp15 := lang.Apply(kw_rename, []any{v10}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + if lang.IsTruthy(v16) { + tmp17 = v16 + } else { + tmp18 := lang.NewMap() + tmp19 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4236), kw_column, int(35), kw_end_DASH_line, int(4236), kw_end_DASH_column, int(36)) + tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp17 = tmp20 + } + tmp14 = tmp17 + } // end let + var v15 any = tmp14 + _ = v15 + // let binding "exclude" + tmp16 := checkDerefVar(var_glojure_DOT_core_set) + tmp17 := lang.Apply(kw_exclude, []any{v10}) + tmp18 := lang.Apply(tmp16, []any{tmp17}) + var v19 any = tmp18 + _ = v19 + // let binding "to-do" + var tmp20 any + tmp21 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp22 := lang.Apply(kw_refer, []any{v10}) + tmp23 := lang.Apply(tmp21, []any{kw_all, tmp22}) + if lang.IsTruthy(tmp23) { + tmp24 := checkDerefVar(var_glojure_DOT_core_keys) + tmp25 := lang.Apply(tmp24, []any{v13}) + tmp20 = tmp25 + } else { + var tmp26 any + { // let + // let binding "or__0__auto__" + tmp27 := lang.Apply(kw_refer, []any{v10}) + var v28 any = tmp27 + _ = v28 + var tmp29 any + if lang.IsTruthy(v28) { + tmp29 = v28 + } else { + var tmp30 any + { // let + // let binding "or__0__auto__" + tmp31 := lang.Apply(kw_only, []any{v10}) + var v32 any = tmp31 + _ = v32 + var tmp33 any + if lang.IsTruthy(v32) { + tmp33 = v32 + } else { + tmp34 := checkDerefVar(var_glojure_DOT_core_keys) + tmp35 := lang.Apply(tmp34, []any{v13}) + tmp33 = tmp35 + } + tmp30 = tmp33 + } // end let + tmp29 = tmp30 + } + tmp26 = tmp29 + } // end let + tmp20 = tmp26 + } + var v27 any = tmp20 + _ = v27 + var tmp28 any + var tmp29 any + { // let + // let binding "and__0__auto__" + var v30 any = v27 + _ = v30 + var tmp31 any + if lang.IsTruthy(v30) { + tmp32 := checkDerefVar(var_glojure_DOT_core_not) + tmp33 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp34 := reflect.TypeOf((*lang.Sequential)(nil)).Elem() + tmp35 := lang.Apply(tmp33, []any{tmp34, v27}) + tmp36 := lang.Apply(tmp32, []any{tmp35}) + tmp31 = tmp36 + } else { + tmp31 = v30 + } + tmp29 = tmp31 + } // end let + if lang.IsTruthy(tmp29) { + tmp30 := lang.Apply(errors8.New, []any{":only/:refer value must be a sequential collection of symbols"}) + panic(tmp30) + } else { + } + _ = tmp28 + var tmp31 any + { // let + // let binding "seq_9" + tmp32 := checkDerefVar(var_glojure_DOT_core_seq) + tmp33 := lang.Apply(tmp32, []any{v27}) + var v34 any = tmp33 + _ = v34 + // let binding "chunk_10" + var v35 any = nil + _ = v35 + // let binding "count_11" + var v36 any = int64(0) + _ = v36 + // let binding "i_12" + var v37 any = int64(0) + _ = v37 + for { + var tmp38 any + tmp39 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp40 := lang.Apply(tmp39, []any{v37, v36}) + if lang.IsTruthy(tmp40) { + var tmp41 any + { // let + // let binding "sym" + tmp42, _ := lang.FieldOrMethod(v35, "nth") + if reflect.TypeOf(tmp42).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp43 := lang.Apply(tmp42, []any{v37}) + var v44 any = tmp43 + _ = v44 + var tmp45 any + tmp46 := lang.Apply(v19, []any{v44}) + if lang.IsTruthy(tmp46) { + } else { + var tmp47 any + { // let + // let binding "v" + tmp48 := lang.Apply(v13, []any{v44}) + var v49 any = tmp48 + _ = v49 + var tmp50 any + if lang.IsTruthy(v49) { + } else { + panic("unimplemented: new with non-constant class type") + } + _ = tmp50 + tmp51 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + var tmp52 any + { // let + // let binding "or__0__auto__" + tmp53 := lang.Apply(v15, []any{v44}) + var v54 any = tmp53 + _ = v54 + var tmp55 any + if lang.IsTruthy(v54) { + tmp55 = v54 + } else { + tmp55 = v44 + } + tmp52 = tmp55 + } // end let + tmp53, _ := lang.FieldOrMethod(tmp51, "Refer") + if reflect.TypeOf(tmp53).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Refer is not a function"))) + } + tmp54 := lang.Apply(tmp53, []any{tmp52, v49}) + tmp47 = tmp54 + } // end let + tmp45 = tmp47 + } + _ = tmp45 + var tmp48 any = v34 + var tmp49 any = v35 + var tmp50 any = v36 + tmp52 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp53 := lang.Apply(tmp52, []any{v37}) + var tmp51 any = tmp53 + v34 = tmp48 + v35 = tmp49 + v36 = tmp50 + v37 = tmp51 + continue + } // end let + tmp38 = tmp41 + } else { + var tmp42 any + { // let + // let binding "temp__0__auto__" + tmp43 := checkDerefVar(var_glojure_DOT_core_seq) + tmp44 := lang.Apply(tmp43, []any{v34}) + var v45 any = tmp44 + _ = v45 + var tmp46 any + if lang.IsTruthy(v45) { + var tmp47 any + { // let + // let binding "seq_9" + var v48 any = v45 + _ = v48 + var tmp49 any + tmp50 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp51 := lang.Apply(tmp50, []any{v48}) + if lang.IsTruthy(tmp51) { + var tmp52 any + { // let + // let binding "c__0__auto__" + tmp53 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp54 := lang.Apply(tmp53, []any{v48}) + var v55 any = tmp54 + _ = v55 + tmp57 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp58 := lang.Apply(tmp57, []any{v48}) + var tmp56 any = tmp58 + var tmp59 any = v55 + tmp61 := checkDerefVar(var_glojure_DOT_core_int) + tmp62 := checkDerefVar(var_glojure_DOT_core_count) + tmp63 := lang.Apply(tmp62, []any{v55}) + tmp64 := lang.Apply(tmp61, []any{tmp63}) + var tmp60 any = tmp64 + tmp66 := checkDerefVar(var_glojure_DOT_core_int) + tmp67 := lang.Apply(tmp66, []any{int64(0)}) + var tmp65 any = tmp67 + v34 = tmp56 + v35 = tmp59 + v36 = tmp60 + v37 = tmp65 + continue + } // end let + tmp49 = tmp52 + } else { + var tmp53 any + { // let + // let binding "sym" + tmp54 := checkDerefVar(var_glojure_DOT_core_first) + tmp55 := lang.Apply(tmp54, []any{v48}) + var v56 any = tmp55 + _ = v56 + var tmp57 any + tmp58 := lang.Apply(v19, []any{v56}) + if lang.IsTruthy(tmp58) { + } else { + var tmp59 any + { // let + // let binding "v" + tmp60 := lang.Apply(v13, []any{v56}) + var v61 any = tmp60 + _ = v61 + var tmp62 any + if lang.IsTruthy(v61) { + } else { + panic("unimplemented: new with non-constant class type") + } + _ = tmp62 + tmp63 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + var tmp64 any + { // let + // let binding "or__0__auto__" + tmp65 := lang.Apply(v15, []any{v56}) + var v66 any = tmp65 + _ = v66 + var tmp67 any + if lang.IsTruthy(v66) { + tmp67 = v66 + } else { + tmp67 = v56 + } + tmp64 = tmp67 + } // end let + tmp65, _ := lang.FieldOrMethod(tmp63, "Refer") + if reflect.TypeOf(tmp65).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Refer is not a function"))) + } + tmp66 := lang.Apply(tmp65, []any{tmp64, v61}) + tmp59 = tmp66 + } // end let + tmp57 = tmp59 + } + _ = tmp57 + tmp61 := checkDerefVar(var_glojure_DOT_core_next) + tmp62 := lang.Apply(tmp61, []any{v48}) + var tmp60 any = tmp62 + var tmp63 any = nil + var tmp64 any = int64(0) + var tmp65 any = int64(0) + v34 = tmp60 + v35 = tmp63 + v36 = tmp64 + v37 = tmp65 + continue + } // end let + tmp49 = tmp53 + } + tmp47 = tmp49 + } // end let + tmp46 = tmp47 + } else { + } + tmp42 = tmp46 + } // end let + tmp38 = tmp42 + } + tmp31 = tmp38 + break + } + } // end let + tmp4 = tmp31 + } // end let + return tmp4 } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // odd? - { - tmp0 := sym_odd_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_doc, "Returns true if n is odd, throws an exception if n is not an integer", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1389), kw_end_DASH_line, int(1389))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_not) - tmp5 := checkDerefVar(var_glojure_DOT_core_even_QMARK_) - tmp6 := lang.Apply(tmp5, []any{v3}) - tmp7 := lang.Apply(tmp4, []any{tmp6}) - return tmp7 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_refer = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_refer.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // or + // remove { - tmp0 := sym_or.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_x), lang.NewVector(sym_x, sym__AMP_, sym_next)), kw_doc, "Evaluates exprs one at a time, from left to right. If a form\n returns a logical true value, or returns that value and doesn't\n evaluate any of the other expressions, otherwise it returns the\n value of the last expression. (or) returns nil.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(11), kw_line, int(847), kw_end_DASH_line, int(847))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_remove.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred), lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns a lazy sequence of the items in coll for which\n (pred item) returns logical false. pred must be free of side-effects.\n Returns a transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(2818), kw_end_DASH_line, int(2818))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_filter) + tmp4 := checkDerefVar(var_glojure_DOT_core_complement) + tmp5 := lang.Apply(tmp4, []any{v2}) + tmp6 := lang.Apply(tmp3, []any{tmp5}) + return tmp6 case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - return nil - case 3: - v3 := args[0] + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - return v5 + tmp4 := checkDerefVar(var_glojure_DOT_core_filter) + tmp5 := checkDerefVar(var_glojure_DOT_core_complement) + tmp6 := lang.Apply(tmp5, []any{v2}) + tmp7 := lang.Apply(tmp4, []any{tmp6, v3}) + return tmp7 default: - checkArity(args, 3) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - tmp7 := checkDerefVar(var_glojure_DOT_core_seq) - tmp8 := checkDerefVar(var_glojure_DOT_core_concat) - tmp9 := checkDerefVar(var_glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_core_SLASH_let}) - tmp11 := checkDerefVar(var_glojure_DOT_core_list) - tmp12 := checkDerefVar(var_glojure_DOT_core_apply) - tmp13 := checkDerefVar(var_glojure_DOT_core_vector) - tmp14 := checkDerefVar(var_glojure_DOT_core_seq) - tmp15 := checkDerefVar(var_glojure_DOT_core_concat) - tmp16 := checkDerefVar(var_glojure_DOT_core_list) - tmp17 := lang.Apply(tmp16, []any{sym_or__0__auto__}) - tmp18 := checkDerefVar(var_glojure_DOT_core_list) - tmp19 := lang.Apply(tmp18, []any{v5}) - tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) - tmp21 := lang.Apply(tmp14, []any{tmp20}) - tmp22 := lang.Apply(tmp12, []any{tmp13, tmp21}) - tmp23 := lang.Apply(tmp11, []any{tmp22}) - tmp24 := checkDerefVar(var_glojure_DOT_core_list) - tmp25 := checkDerefVar(var_glojure_DOT_core_seq) - tmp26 := checkDerefVar(var_glojure_DOT_core_concat) - tmp27 := checkDerefVar(var_glojure_DOT_core_list) - tmp28 := lang.Apply(tmp27, []any{sym_if}) - tmp29 := checkDerefVar(var_glojure_DOT_core_list) - tmp30 := lang.Apply(tmp29, []any{sym_or__0__auto__}) - tmp31 := checkDerefVar(var_glojure_DOT_core_list) - tmp32 := lang.Apply(tmp31, []any{sym_or__0__auto__}) - tmp33 := checkDerefVar(var_glojure_DOT_core_list) - tmp34 := checkDerefVar(var_glojure_DOT_core_seq) - tmp35 := checkDerefVar(var_glojure_DOT_core_concat) - tmp36 := checkDerefVar(var_glojure_DOT_core_list) - tmp37 := lang.Apply(tmp36, []any{sym_glojure_DOT_core_SLASH_or}) - tmp38 := lang.Apply(tmp35, []any{tmp37, v6}) - tmp39 := lang.Apply(tmp34, []any{tmp38}) - tmp40 := lang.Apply(tmp33, []any{tmp39}) - tmp41 := lang.Apply(tmp26, []any{tmp28, tmp30, tmp32, tmp40}) - tmp42 := lang.Apply(tmp25, []any{tmp41}) - tmp43 := lang.Apply(tmp24, []any{tmp42}) - tmp44 := lang.Apply(tmp8, []any{tmp10, tmp23, tmp43}) - tmp45 := lang.Apply(tmp7, []any{tmp44}) - return tmp45 + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_remove = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_remove.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // parents + // replace { - tmp0 := sym_parents.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_tag), lang.NewVector(sym_h, sym_tag)), kw_doc, "Returns the immediate parents of tag, either via a Java type\n inheritance relationship or a relationship established via derive. h\n must be a hierarchy obtained from make-hierarchy, if not supplied\n defaults to the global hierarchy", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(5564), kw_end_DASH_line, int(5564))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_replace.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_smap), lang.NewVector(sym_smap, sym_coll)), kw_doc, "Given a map of replacement pairs and a vector/collection, returns a\n vector/seq with any elements = a key in smap replaced with the\n corresponding val in smap. Returns a transducer when no collection\n is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(5082), kw_end_DASH_line, int(5082))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_parents) - tmp5 := checkDerefVar(var_glojure_DOT_core_global_DASH_hierarchy) - tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) - return tmp6 + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_map) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v5 := args[0] + _ = v5 + var tmp6 any + { // let + // let binding "temp__0__auto__" + tmp7 := checkDerefVar(var_glojure_DOT_core_find) + tmp8 := lang.Apply(tmp7, []any{v2, v5}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + var tmp11 any + { // let + // let binding "e" + var v12 any = v9 + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_val) + tmp14 := lang.Apply(tmp13, []any{v12}) + tmp11 = tmp14 + } // end let + tmp10 = tmp11 + } else { + tmp10 = v5 + } + tmp6 = tmp10 + } // end let + return tmp6 + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5090), kw_column, int(11), kw_end_DASH_line, int(5090), kw_end_DASH_column, int(47)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp7 := lang.Apply(tmp3, []any{tmp6}) + return tmp7 case 2: - v3 := args[0] + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_not_DASH_empty) - var tmp6 any - { // let - // let binding "tp" - tmp7 := checkDerefVar(var_glojure_DOT_core_get) - tmp8 := lang.Apply(kw_parents, []any{v3}) - tmp9 := lang.Apply(tmp7, []any{tmp8, v4}) - var v10 any = tmp9 - _ = v10 - var tmp11 any - tmp12 := checkDerefVar(var_glojure_DOT_core_class_QMARK_) - tmp13 := lang.Apply(tmp12, []any{v4}) - if lang.IsTruthy(tmp13) { - tmp14 := checkDerefVar(var_glojure_DOT_core_into1) - tmp15 := checkDerefVar(var_glojure_DOT_core_set) - tmp16 := checkDerefVar(var_glojure_DOT_core_bases) - tmp17 := lang.Apply(tmp16, []any{v4}) - tmp18 := lang.Apply(tmp15, []any{tmp17}) - tmp19 := lang.Apply(tmp14, []any{tmp18, v10}) - tmp11 = tmp19 - } else { - tmp11 = v10 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp8 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v9 := args[0] + _ = v9 + v10 := args[1] + _ = v10 + var tmp11 any + { // let + // let binding "temp__0__auto__" + tmp12 := checkDerefVar(var_glojure_DOT_core_find) + tmp13 := checkDerefVar(var_glojure_DOT_core_nth) + tmp14 := lang.Apply(tmp13, []any{v9, v10}) + tmp15 := lang.Apply(tmp12, []any{v2, tmp14}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + if lang.IsTruthy(v16) { + var tmp18 any + { // let + // let binding "e" + var v19 any = v16 + _ = v19 + tmp20 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp21 := checkDerefVar(var_glojure_DOT_core_val) + tmp22 := lang.Apply(tmp21, []any{v19}) + tmp23 := lang.Apply(tmp20, []any{v9, v10, tmp22}) + tmp18 = tmp23 + } // end let + tmp17 = tmp18 + } else { + tmp17 = v9 + } + tmp11 = tmp17 + } // end let + return tmp11 + }) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5093), kw_column, int(17), kw_end_DASH_line, int(5096), kw_end_DASH_column, int(23)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) } - tmp6 = tmp11 - } // end let - tmp7 := lang.Apply(tmp5, []any{tmp6}) - return tmp7 + tmp11 := checkDerefVar(var_glojure_DOT_core_range) + tmp12 := checkDerefVar(var_glojure_DOT_core_count) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(tmp11, []any{tmp13}) + tmp15 := lang.Apply(tmp7, []any{tmp10, v3, tmp14}) + tmp4 = tmp15 + } else { + tmp16 := checkDerefVar(var_glojure_DOT_core_map) + var tmp17 lang.FnFunc + tmp17 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v18 := args[0] + _ = v18 + var tmp19 any + { // let + // let binding "temp__0__auto__" + tmp20 := checkDerefVar(var_glojure_DOT_core_find) + tmp21 := lang.Apply(tmp20, []any{v2, v18}) + var v22 any = tmp21 + _ = v22 + var tmp23 any + if lang.IsTruthy(v22) { + var tmp24 any + { // let + // let binding "e" + var v25 any = v22 + _ = v25 + tmp26 := checkDerefVar(var_glojure_DOT_core_val) + tmp27 := lang.Apply(tmp26, []any{v25}) + tmp24 = tmp27 + } // end let + tmp23 = tmp24 + } else { + tmp23 = v18 + } + tmp19 = tmp23 + } // end let + return tmp19 + }) + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5098), kw_column, int(13), kw_end_DASH_line, int(5098), kw_end_DASH_column, int(49)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp20 := lang.Apply(tmp16, []any{tmp19, v3}) + tmp4 = tmp20 + } + return tmp4 default: checkArity(args, -1) panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // parse-boolean - { - tmp0 := sym_parse_DASH_boolean.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_doc, "Parse strings \"true\" or \"false\" and return a boolean, or nil if invalid", kw_file, "glojure/core.glj", kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(7957), kw_end_DASH_line, int(7957))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) - tmp6 := lang.Apply(tmp5, []any{v3}) - if lang.IsTruthy(tmp6) { - var tmp7 any - { // let - // let binding "G__365" - var v8 any = v3 - _ = v8 - } // end let - tmp4 = tmp7 - } else { - tmp8 := checkDerefVar(var_glojure_DOT_core_parsing_DASH_err) - tmp9 := lang.Apply(tmp8, []any{v3}) - tmp10 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp9}) - panic(tmp10) - } - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_replace = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_replace.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // parse-double + // restart-agent { - tmp0 := sym_parse_DASH_double.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_doc, "Parse string with floating point components and return a Double value,\n or nil if parse fails.\n\n Grammar: https://docs.oracle.com/javase/8/docs/api/java/lang/Double.html#valueOf-java.lang.String-", kw_file, "glojure/core.glj", kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(7935), kw_end_DASH_line, int(7935))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) - tmp6 := lang.Apply(tmp5, []any{v3}) - if lang.IsTruthy(tmp6) { - var tmp7 any + tmp0 := sym_restart_DASH_agent.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a, sym_new_DASH_state, sym__AMP_, sym_options)), kw_doc, "When an agent is failed, changes the agent state to new-state and\n then un-fails the agent so that sends are allowed again. If\n a :clear-actions true option is given, any actions queued on the\n agent that were being held while it was failed will be discarded,\n otherwise those held actions will proceed. The new-state must pass\n the validator if any, or restart will throw an exception and the\n agent will remain failed with its old state and error. Watchers, if\n any, will NOT be notified of the new state. Throws an exception if\n the agent is not failed.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(2175), kw_end_DASH_line, int(2175))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any { // let - // let binding "result__3649__auto__" - tmp8 := lang.Apply(strconv12.ParseFloat, []any{v3, int64(64)}) + // let binding "opts" + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp8 := lang.Apply(tmp6, []any{tmp7, v4}) var v9 any = tmp8 _ = v9 var tmp10 any - tmp11 := lang.Apply(v9, []any{int64(1)}) + tmp11 := lang.Apply(kw_clear_DASH_actions, []any{v9}) if lang.IsTruthy(tmp11) { + tmp10 = true } else { - tmp12 := lang.Apply(v9, []any{int64(0)}) - tmp10 = tmp12 + tmp10 = false } - tmp7 = tmp10 + tmp12, _ := lang.FieldOrMethod(v2, "restart") + if reflect.TypeOf(tmp12).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("restart is not a function"))) + } + tmp13 := lang.Apply(tmp12, []any{v3, tmp10}) + tmp5 = tmp13 } // end let - tmp4 = tmp7 - } else { - tmp8 := checkDerefVar(var_glojure_DOT_core_parsing_DASH_err) - tmp9 := lang.Apply(tmp8, []any{v3}) - tmp10 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp9}) - panic(tmp10) + return tmp5 } - return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_restart_DASH_agent = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_restart_DASH_agent.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // parse-impls + // root-directory { - tmp0 := sym_parse_DASH_impls.WithMeta(lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(13), kw_column, int(8), kw_end_DASH_line, int(13), kw_end_DASH_column, int(18), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_specs)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_root_DASH_directory.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_lib)), kw_doc, "Returns the root resource path for a lib", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(8), kw_line, int(5871), kw_end_DASH_line, int(5871), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 any + v2 := args[0] + _ = v2 + var tmp3 any { // let - // let binding "ret" - tmp5 := lang.NewMap() - tmp6 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(14), kw_column, int(14), kw_end_DASH_line, int(14), kw_end_DASH_column, int(15)) - tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v8 any = tmp7 - _ = v8 - // let binding "s" - var v9 any = v3 - _ = v9 - for { - var tmp10 any - tmp11 := checkDerefVar(var_glojure_DOT_core_seq) - tmp12 := lang.Apply(tmp11, []any{v9}) - if lang.IsTruthy(tmp12) { - tmp14 := checkDerefVar(var_glojure_DOT_core_assoc) - tmp15 := checkDerefVar(var_glojure_DOT_core_first) - tmp16 := lang.Apply(tmp15, []any{v9}) - tmp17 := checkDerefVar(var_glojure_DOT_core_take_DASH_while) - tmp18 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) - tmp19 := checkDerefVar(var_glojure_DOT_core_next) - tmp20 := lang.Apply(tmp19, []any{v9}) - tmp21 := lang.Apply(tmp17, []any{tmp18, tmp20}) - tmp22 := lang.Apply(tmp14, []any{v8, tmp16, tmp21}) - var tmp13 any = tmp22 - tmp24 := checkDerefVar(var_glojure_DOT_core_drop_DASH_while) - tmp25 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) - tmp26 := checkDerefVar(var_glojure_DOT_core_next) - tmp27 := lang.Apply(tmp26, []any{v9}) - tmp28 := lang.Apply(tmp24, []any{tmp25, tmp27}) - var tmp23 any = tmp28 - v8 = tmp13 - v9 = tmp23 - continue - } else { - tmp10 = v8 - } - tmp4 = tmp10 - break - } + // let binding "d" + tmp4 := checkDerefVar(var_glojure_DOT_core_root_DASH_resource) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_subs) + tmp8 := lang.Apply(strings11.LastIndex, []any{v6, "/"}) + tmp9 := lang.Apply(tmp7, []any{v6, int64(0), tmp8}) + tmp3 = tmp9 } // end let - return tmp4 + return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_root_DASH_directory = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_root_DASH_directory.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // parse-long + // rsubseq { - tmp0 := sym_parse_DASH_long.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_doc, "Parse string of decimal digits with optional leading -/+ and return a\n Long value, or nil if parse fails", kw_file, "glojure/core.glj", kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(7926), kw_end_DASH_line, int(7926))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) - tmp6 := lang.Apply(tmp5, []any{v3}) - if lang.IsTruthy(tmp6) { + tmp0 := sym_rsubseq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_sc, sym_test, sym_key), lang.NewVector(sym_sc, sym_start_DASH_test, sym_start_DASH_key, sym_end_DASH_test, sym_end_DASH_key)), kw_doc, "sc must be a sorted collection, test(s) one of <, <=, > or\n >=. Returns a reverse seq of those entries with keys ek for\n which (test (.. sc comparator (compare ek key)) 0) is true", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(5150), kw_end_DASH_line, int(5150))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + { // let + // let binding "include" + tmp6 := checkDerefVar(var_glojure_DOT_core_mk_DASH_bound_DASH_fn) + tmp7 := lang.Apply(tmp6, []any{v2, v3, v4}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp11 := checkDerefVar(var_glojure_DOT_core__LT__EQ_) + tmp12 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{tmp10, tmp11})) + tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5158), kw_column, int(11), kw_end_DASH_line, int(5158), kw_end_DASH_column, int(17)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp15 := lang.Apply(tmp14, []any{v3}) + if lang.IsTruthy(tmp15) { + var tmp16 any + { // let + // let binding "temp__0__auto__" + tmp17, _ := lang.FieldOrMethod(v2, "seqFrom") + if reflect.TypeOf(tmp17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("seqFrom is not a function"))) + } + tmp18 := lang.Apply(tmp17, []any{v4, false}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + var tmp21 any + { // let + // let binding "vec__74" + var v22 any = v19 + _ = v22 + // let binding "e" + tmp23 := checkDerefVar(var_glojure_DOT_core_nth) + tmp24 := lang.Apply(tmp23, []any{v22, int64(0), nil}) + var v25 any = tmp24 + _ = v25 + // let binding "s" + var v26 any = v22 + _ = v26 + var tmp27 any + tmp28 := lang.Apply(v8, []any{v25}) + if lang.IsTruthy(tmp28) { + tmp27 = v26 + } else { + tmp29 := checkDerefVar(var_glojure_DOT_core_next) + tmp30 := lang.Apply(tmp29, []any{v26}) + tmp27 = tmp30 + } + tmp21 = tmp27 + } // end let + tmp20 = tmp21 + } else { + } + tmp16 = tmp20 + } // end let + tmp9 = tmp16 + } else { + tmp17 := checkDerefVar(var_glojure_DOT_core_take_DASH_while) + tmp18, _ := lang.FieldOrMethod(v2, "seq") + if reflect.TypeOf(tmp18).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("seq is not a function"))) + } + tmp19 := lang.Apply(tmp18, []any{false}) + tmp20 := lang.Apply(tmp17, []any{v8, tmp19}) + tmp9 = tmp20 + } + tmp5 = tmp9 + } // end let + return tmp5 + case 5: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 var tmp7 any { // let - // let binding "result__3648__auto__" - tmp8 := lang.Apply(strconv12.ParseInt, []any{v3, int64(10), int64(64)}) - var v9 any = tmp8 - _ = v9 - var tmp10 any - tmp11 := lang.Apply(v9, []any{int64(1)}) - if lang.IsTruthy(tmp11) { + // let binding "temp__0__auto__" + tmp8, _ := lang.FieldOrMethod(v2, "seqFrom") + if reflect.TypeOf(tmp8).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("seqFrom is not a function"))) + } + tmp9 := lang.Apply(tmp8, []any{v6, false}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + if lang.IsTruthy(v10) { + var tmp12 any + { // let + // let binding "vec__77" + var v13 any = v10 + _ = v13 + // let binding "e" + tmp14 := checkDerefVar(var_glojure_DOT_core_nth) + tmp15 := lang.Apply(tmp14, []any{v13, int64(0), nil}) + var v16 any = tmp15 + _ = v16 + // let binding "s" + var v17 any = v13 + _ = v17 + tmp18 := checkDerefVar(var_glojure_DOT_core_take_DASH_while) + tmp19 := checkDerefVar(var_glojure_DOT_core_mk_DASH_bound_DASH_fn) + tmp20 := lang.Apply(tmp19, []any{v2, v3, v4}) + var tmp21 any + tmp22 := checkDerefVar(var_glojure_DOT_core_mk_DASH_bound_DASH_fn) + tmp23 := lang.Apply(tmp22, []any{v2, v5, v6}) + tmp24 := lang.Apply(tmp23, []any{v16}) + if lang.IsTruthy(tmp24) { + tmp21 = v17 + } else { + tmp25 := checkDerefVar(var_glojure_DOT_core_next) + tmp26 := lang.Apply(tmp25, []any{v17}) + tmp21 = tmp26 + } + tmp27 := lang.Apply(tmp18, []any{tmp20, tmp21}) + tmp12 = tmp27 + } // end let + tmp11 = tmp12 } else { - tmp12 := lang.Apply(v9, []any{int64(0)}) - tmp10 = tmp12 } - tmp7 = tmp10 + tmp7 = tmp11 } // end let - tmp4 = tmp7 - } else { - tmp8 := checkDerefVar(var_glojure_DOT_core_parsing_DASH_err) - tmp9 := lang.Apply(tmp8, []any{v3}) - tmp10 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp9}) - panic(tmp10) + return tmp7 + default: + checkArity(args, -1) + panic("unreachable") } - return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_rsubseq = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_rsubseq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // parse-uuid + // send-via { - tmp0 := sym_parse_DASH_uuid.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_doc, "Parse a string representing a UUID and return a java.util.UUID instance,\n or nil if parse fails.\n\n Grammar: https://docs.oracle.com/javase/8/docs/api/java/util/UUID.html#toString--", kw_file, "glojure/core.glj", kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(7946), kw_end_DASH_line, int(7946))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 any - func() { - defer func() { - if r := recover(); r != nil { - tmp5 := reflect.TypeOf((*lang.IllegalArgumentError)(nil)) - if lang.CatchMatches(r, tmp5) { - v6 := r - _ = v6 - } else { - panic(r) - } - } - }() + tmp0 := sym_send_DASH_via.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_executor, sym_a, sym_f, sym__AMP_, sym_args)), kw_doc, "Dispatch an action to an agent. Returns the agent immediately.\n Subsequently, in a thread supplied by executor, the state of the agent\n will be set to the value of:\n\n (apply action-fn state-of-agent args)", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(2099), kw_end_DASH_line, int(2099))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 var tmp6 any { // let - // let binding "vec__362" - tmp7 := lang.Apply(uuid13.Parse, []any{v3}) - var v8 any = tmp7 - _ = v8 - // let binding "uuid" - tmp9 := checkDerefVar(var_glojure_DOT_core_nth) - tmp10 := lang.Apply(tmp9, []any{v8, int64(0), nil}) - var v11 any = tmp10 - _ = v11 - // let binding "err" - tmp12 := checkDerefVar(var_glojure_DOT_core_nth) - tmp13 := lang.Apply(tmp12, []any{v8, int64(1), nil}) - var v14 any = tmp13 - _ = v14 - var tmp15 any - if lang.IsTruthy(v14) { - tmp16 := checkDerefVar(var_glojure_DOT_core_str) - tmp17 := lang.Apply(tmp16, []any{"Error parsing UUID: ", v14}) - tmp18 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp17}) - panic(tmp18) - } else { - tmp15 = v11 - } - tmp6 = tmp15 + tmp7 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp8 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp9 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_agent_STAR_) + tmp10 := lang.Apply(tmp8, []any{tmp9, v3}) + tmp11 := lang.Apply(tmp7, []any{tmp10}) + _ = tmp11 + var tmp12 any + func() { + defer func() { + tmp13 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp14 := lang.Apply(tmp13, nil) + _ = tmp14 + }() + tmp15 := checkDerefVar(var_glojure_DOT_core_binding_DASH_conveyor_DASH_fn) + tmp16 := lang.Apply(tmp15, []any{v4}) + tmp12 = tmp16 + }() + tmp6 = tmp12 } // end let - tmp4 = tmp6 - }() - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // parsing-err - { - tmp0 := sym_parsing_DASH_err.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_val)), kw_doc, "Construct message for parsing for non-string parsing error", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(8), kw_line, int(7921), kw_end_DASH_line, int(7921), kw_private, true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_str) - var tmp5 any - tmp6 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) - tmp7 := lang.Apply(tmp6, []any{v3}) - if lang.IsTruthy(tmp7) { - tmp5 = "nil" - } else { - tmp8 := checkDerefVar(var_glojure_DOT_core_class) - tmp9 := lang.Apply(tmp8, []any{v3}) - tmp10, ok := lang.FieldOrMethod(tmp9, "Name") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp9, "Name"))) - } - var tmp11 any - switch reflect.TypeOf(tmp10).Kind() { - case reflect.Func: - tmp11 = lang.Apply(tmp10, nil) - default: - tmp11 = tmp10 + tmp7, _ := lang.FieldOrMethod(v3, "dispatch") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("dispatch is not a function"))) } - tmp5 = tmp11 + tmp8 := lang.Apply(tmp7, []any{tmp6, v5, v2}) + return tmp8 } - tmp12 := lang.Apply(tmp4, []any{"Expected string, got ", tmp5}) - return tmp12 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_send_DASH_via = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_send_DASH_via.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // partial + // sequence { - tmp0 := sym_partial.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_arg1), lang.NewVector(sym_f, sym_arg1, sym_arg2), lang.NewVector(sym_f, sym_arg1, sym_arg2, sym_arg3), lang.NewVector(sym_f, sym_arg1, sym_arg2, sym_arg3, sym__AMP_, sym_more)), kw_doc, "Takes a function f and fewer than the normal arguments to f, and\n returns a fn that takes a variable number of additional args. When\n called, the returned function calls f with args + additional args.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(2606), kw_end_DASH_line, int(2606))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_sequence.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll), lang.NewVector(sym_xform, sym_coll), lang.NewVector(sym_xform, sym_coll, sym__AMP_, sym_colls)), kw_doc, "Coerces coll to a (possibly empty) sequence, if it is not already\n one. Will not force a lazy seq. (sequence nil) yields (), When a\n transducer is supplied, returns a lazy sequence of applications of\n the transform to the items in coll(s), i.e. to the set of first\n items of each coll, followed by the set of second\n items in each coll, until any one of the colls is exhausted. Any\n remaining items in other colls are ignored. The transform should accept\n number-of-colls arguments", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(2639), kw_end_DASH_line, int(2639))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: - v3 := args[0] - _ = v3 - return v3 + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + tmp3 = v2 + } else { + var tmp6 any + { // let + // let binding "or__0__auto__" + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := lang.Apply(tmp7, []any{v2}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + tmp10 = v9 + } else { + tmp10 = lang.NewList() + } + tmp6 = tmp10 + } // end let + tmp3 = tmp6 + } + return tmp3 case 2: - v3 := args[0] + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] - _ = v4 - var tmp5 lang.FnFunc - tmp5 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp6 := lang.Apply(v3, []any{v4}) - return tmp6 - case 1: - v6 := args[0] - _ = v6 - tmp7 := lang.Apply(v3, []any{v4, v6}) - return tmp7 - case 2: - v6 := args[0] - _ = v6 - v7 := args[1] - _ = v7 - tmp8 := lang.Apply(v3, []any{v4, v6, v7}) - return tmp8 - case 3: - v6 := args[0] - _ = v6 - v7 := args[1] - _ = v7 - v8 := args[2] - _ = v8 - tmp9 := lang.Apply(v3, []any{v4, v6, v7, v8}) - return tmp9 - default: - checkArity(args, 3) - v6 := args[0] - _ = v6 - v7 := args[1] - _ = v7 - v8 := args[2] - _ = v8 - var v9 any = lang.NewList(args[3:]...) - _ = v9 - tmp10 := checkDerefVar(var_glojure_DOT_core_apply) - tmp11 := lang.Apply(tmp10, []any{v3, v4, v6, v7, v8, v9}) - return tmp11 + var tmp4 any + { // let + // let binding "or__0__auto__" + tmp5 := lang.Apply(nil, []any{v3}) + tmp6 := lang.Apply(nil, []any{v2, tmp5}) + tmp7 := lang.Apply(nil, []any{tmp6}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + tmp9 = v8 + } else { + tmp9 = lang.NewList() } - }) - tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2614), kw_column, int(4), kw_end_DASH_line, int(2619), kw_end_DASH_column, int(48)) - tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp7 - case 3: - v3 := args[0] + tmp4 = tmp9 + } // end let + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + var v4 any = lang.NewList(args[2:]...) _ = v4 - v5 := args[2] - _ = v5 - var tmp6 lang.FnFunc - tmp6 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp7 := lang.Apply(v3, []any{v4, v5}) - return tmp7 - case 1: - v7 := args[0] - _ = v7 - tmp8 := lang.Apply(v3, []any{v4, v5, v7}) - return tmp8 - case 2: - v7 := args[0] - _ = v7 - v8 := args[1] + var tmp5 any + { // let + // let binding "or__0__auto__" + tmp6 := checkDerefVar(var_glojure_DOT_core_map) + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v8 := args[0] _ = v8 - tmp9 := lang.Apply(v3, []any{v4, v5, v7, v8}) + tmp9 := lang.Apply(nil, []any{v8}) return tmp9 - case 3: - v7 := args[0] - _ = v7 - v8 := args[1] - _ = v8 - v9 := args[2] - _ = v9 - tmp10 := lang.Apply(v3, []any{v4, v5, v7, v8, v9}) - return tmp10 - default: - checkArity(args, 3) - v7 := args[0] - _ = v7 - v8 := args[1] - _ = v8 - v9 := args[2] - _ = v9 - var v10 any = lang.NewList(args[3:]...) - _ = v10 - tmp11 := checkDerefVar(var_glojure_DOT_core_apply) - tmp12 := lang.Apply(tmp11, []any{v3, v4, v5, v7, v8, v9, v10}) - return tmp12 + }) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2661), kw_column, int(17), kw_end_DASH_line, int(2661), kw_end_DASH_column, int(41)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp10 := checkDerefVar(var_glojure_DOT_core_cons) + tmp11 := lang.Apply(tmp10, []any{v3, v4}) + tmp12 := lang.Apply(tmp6, []any{tmp9, tmp11}) + tmp13 := lang.Apply(nil, []any{v2, tmp12}) + tmp14 := lang.Apply(nil, []any{tmp13}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + if lang.IsTruthy(v15) { + tmp16 = v15 + } else { + tmp16 = lang.NewList() + } + tmp5 = tmp16 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_sequence = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_sequence.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // setup-reference + { + tmp0 := sym_setup_DASH_reference.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(2043), kw_column, int(7), kw_end_DASH_line, int(2044), kw_end_DASH_column, int(17), kw_arglists, lang.NewList(lang.NewVector(sym_r, sym_options)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "opts" + tmp5 := checkDerefVar(var_glojure_DOT_core_apply) + tmp6 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp7 := lang.Apply(tmp5, []any{tmp6, v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + tmp10 := lang.Apply(kw_meta, []any{v8}) + if lang.IsTruthy(tmp10) { + tmp11 := lang.Apply(kw_meta, []any{v8}) + tmp12, _ := lang.FieldOrMethod(v2, "ResetMeta") + if reflect.TypeOf(tmp12).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ResetMeta is not a function"))) + } + tmp13 := lang.Apply(tmp12, []any{tmp11}) + tmp9 = tmp13 + } else { + } + _ = tmp9 + var tmp14 any + tmp15 := lang.Apply(kw_validator, []any{v8}) + if lang.IsTruthy(tmp15) { + tmp16 := lang.Apply(kw_validator, []any{v8}) + tmp17, _ := lang.FieldOrMethod(v2, "setValidator") + if reflect.TypeOf(tmp17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setValidator is not a function"))) } - }) - tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2621), kw_column, int(4), kw_end_DASH_line, int(2626), kw_end_DASH_column, int(53)) - tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) - if err != nil { - panic(err) + tmp18 := lang.Apply(tmp17, []any{tmp16}) + tmp14 = tmp18 + } else { } - return tmp8 - case 4: - v3 := args[0] + _ = tmp14 + tmp4 = v2 + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_setup_DASH_reference = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_setup_DASH_reference.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // shift-mask + { + tmp0 := sym_shift_DASH_mask.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6598), kw_column, int(8), kw_end_DASH_line, int(6598), kw_end_DASH_column, int(17), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_shift, sym_mask, sym_x)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_bit_DASH_and) + tmp6 := checkDerefVar(var_glojure_DOT_core_bit_DASH_shift_DASH_right) + tmp7 := lang.Apply(tmp6, []any{v4, v2}) + tmp8 := lang.Apply(tmp5, []any{tmp7, v3}) + return tmp8 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_shift_DASH_mask = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_shift_DASH_mask.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // sort + { + tmp0 := sym_sort.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll), lang.NewVector(sym_comp, sym_coll)), kw_doc, "Returns a sorted sequence of the items in coll. If no comparator is\n supplied, uses compare. comparator must implement\n java.util.Comparator. Guaranteed to be stable: equal elements will\n not be reordered. If coll is a Java array, it will be modified. To\n avoid this, sort a copy of the array.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3085), kw_end_DASH_line, int(3085))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_sort) + tmp4 := checkDerefVar(var_glojure_DOT_core_compare) + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - var tmp7 lang.FnFunc - tmp7 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp8 := lang.Apply(v3, []any{v4, v5, v6}) - return tmp8 - case 1: - v8 := args[0] - _ = v8 - tmp9 := lang.Apply(v3, []any{v4, v5, v6, v8}) - return tmp9 - case 2: - v8 := args[0] - _ = v8 - v9 := args[1] - _ = v9 - tmp10 := lang.Apply(v3, []any{v4, v5, v6, v8, v9}) - return tmp10 - case 3: - v8 := args[0] - _ = v8 - v9 := args[1] - _ = v9 - v10 := args[2] - _ = v10 - tmp11 := lang.Apply(v3, []any{v4, v5, v6, v8, v9, v10}) - return tmp11 - default: - checkArity(args, 3) - v8 := args[0] - _ = v8 - v9 := args[1] - _ = v9 - v10 := args[2] + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + var tmp7 any + { // let + // let binding "a" + tmp8 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) + tmp9 := lang.Apply(tmp8, []any{v3}) + var v10 any = tmp9 _ = v10 - var v11 any = lang.NewList(args[3:]...) - _ = v11 - tmp12 := checkDerefVar(var_glojure_DOT_core_apply) - tmp13 := lang.Apply(tmp12, []any{v3, v4, v5, v6, v8, v9, v10, v11}) - return tmp13 - } - }) - tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2628), kw_column, int(4), kw_end_DASH_line, int(2633), kw_end_DASH_column, int(58)) - tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) - if err != nil { - panic(err) + tmp11 := lang.Apply(lang.SortSlice, []any{v10, v2}) + _ = tmp11 + tmp12 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := lang.Apply(tmp13, []any{v10}) + tmp15 := checkDerefVar(var_glojure_DOT_core_meta) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp7 = tmp17 + } // end let + tmp4 = tmp7 + } else { + tmp4 = lang.NewList() } - return tmp9 + return tmp4 default: - checkArity(args, 4) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - var v7 any = lang.NewList(args[4:]...) - _ = v7 - var tmp8 lang.FnFunc - tmp8 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 0) - var v9 any = lang.NewList(args[0:]...) - _ = v9 - tmp10 := checkDerefVar(var_glojure_DOT_core_apply) - tmp11 := checkDerefVar(var_glojure_DOT_core_concat) - tmp12 := lang.Apply(tmp11, []any{v7, v9}) - tmp13 := lang.Apply(tmp10, []any{v3, v4, v5, v6, tmp12}) - return tmp13 - } - }) - tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2635), kw_column, int(4), kw_end_DASH_line, int(2635), kw_end_DASH_column, int(60)) - tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp10 + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_sort = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_sort.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // partition + // sort-by { - tmp0 := sym_partition.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n, sym_coll), lang.NewVector(sym_n, sym_step, sym_coll), lang.NewVector(sym_n, sym_step, sym_pad, sym_coll)), kw_doc, "Returns a lazy sequence of lists of n items each, at offsets step\n apart. If step is not supplied, defaults to n, i.e. the partitions\n do not overlap. If a pad collection is supplied, use its elements as\n necessary to complete last partition upto n items. In case there are\n not enough padding elements, return a partition with less than n items.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(3177), kw_end_DASH_line, int(3177))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_sort_DASH_by.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_keyfn, sym_coll), lang.NewVector(sym_keyfn, sym_comp, sym_coll)), kw_doc, "Returns a sorted sequence of the items in coll, where the sort\n order is determined by comparing (keyfn item). If no comparator is\n supplied, uses compare. comparator must implement\n java.util.Comparator. Guaranteed to be stable: equal elements will\n not be reordered. If coll is a Java array, it will be modified. To\n avoid this, sort a copy of the array.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(3102), kw_end_DASH_line, int(3102))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 2: - v3 := args[0] + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_partition) - tmp6 := lang.Apply(tmp5, []any{v3, v3, v4}) + tmp4 := checkDerefVar(var_glojure_DOT_core_sort_DASH_by) + tmp5 := checkDerefVar(var_glojure_DOT_core_compare) + tmp6 := lang.Apply(tmp4, []any{v2, tmp5, v3}) return tmp6 case 3: - v3 := args[0] + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + v4 := args[2] _ = v4 - v5 := args[2] - _ = v5 + tmp5 := checkDerefVar(var_glojure_DOT_core_sort) var tmp6 lang.FnFunc tmp6 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - var tmp7 any - { // let - // let binding "temp__0__auto__" - tmp8 := checkDerefVar(var_glojure_DOT_core_seq) - tmp9 := lang.Apply(tmp8, []any{v5}) - var v10 any = tmp9 - _ = v10 - var tmp11 any - if lang.IsTruthy(v10) { - var tmp12 any - { // let - // let binding "s" - var v13 any = v10 - _ = v13 - var tmp14 any - { // let - // let binding "p" - tmp15 := checkDerefVar(var_glojure_DOT_core_doall) - tmp16 := checkDerefVar(var_glojure_DOT_core_take) - tmp17 := lang.Apply(tmp16, []any{v3, v13}) - tmp18 := lang.Apply(tmp15, []any{tmp17}) - var v19 any = tmp18 - _ = v19 - var tmp20 any - tmp21 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp22 := checkDerefVar(var_glojure_DOT_core_count) - tmp23 := lang.Apply(tmp22, []any{v19}) - tmp24 := lang.Apply(tmp21, []any{v3, tmp23}) - if lang.IsTruthy(tmp24) { - tmp25 := checkDerefVar(var_glojure_DOT_core_cons) - tmp26 := checkDerefVar(var_glojure_DOT_core_partition) - tmp27 := checkDerefVar(var_glojure_DOT_core_nthrest) - tmp28 := lang.Apply(tmp27, []any{v13, v4}) - tmp29 := lang.Apply(tmp26, []any{v3, v4, tmp28}) - tmp30 := lang.Apply(tmp25, []any{v19, tmp29}) - tmp20 = tmp30 - } else { - } - tmp14 = tmp20 - } // end let - tmp12 = tmp14 - } // end let - tmp11 = tmp12 - } else { - } - tmp7 = tmp11 - } // end let - return tmp7 - }) - tmp7 := lang.Apply(lang.NewLazySeq, []any{tmp6}) - return tmp7 - case 4: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - var tmp7 lang.FnFunc - tmp7 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - var tmp8 any - { // let - // let binding "temp__0__auto__" - tmp9 := checkDerefVar(var_glojure_DOT_core_seq) - tmp10 := lang.Apply(tmp9, []any{v6}) - var v11 any = tmp10 - _ = v11 - var tmp12 any - if lang.IsTruthy(v11) { - var tmp13 any - { // let - // let binding "s" - var v14 any = v11 - _ = v14 - var tmp15 any - { // let - // let binding "p" - tmp16 := checkDerefVar(var_glojure_DOT_core_doall) - tmp17 := checkDerefVar(var_glojure_DOT_core_take) - tmp18 := lang.Apply(tmp17, []any{v3, v14}) - tmp19 := lang.Apply(tmp16, []any{tmp18}) - var v20 any = tmp19 - _ = v20 - var tmp21 any - tmp22 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp23 := checkDerefVar(var_glojure_DOT_core_count) - tmp24 := lang.Apply(tmp23, []any{v20}) - tmp25 := lang.Apply(tmp22, []any{v3, tmp24}) - if lang.IsTruthy(tmp25) { - tmp26 := checkDerefVar(var_glojure_DOT_core_cons) - tmp27 := checkDerefVar(var_glojure_DOT_core_partition) - tmp28 := checkDerefVar(var_glojure_DOT_core_nthrest) - tmp29 := lang.Apply(tmp28, []any{v14, v4}) - tmp30 := lang.Apply(tmp27, []any{v3, v4, v5, tmp29}) - tmp31 := lang.Apply(tmp26, []any{v20, tmp30}) - tmp21 = tmp31 - } else { - tmp32 := checkDerefVar(var_glojure_DOT_core_list) - tmp33 := checkDerefVar(var_glojure_DOT_core_take) - tmp34 := checkDerefVar(var_glojure_DOT_core_concat) - tmp35 := lang.Apply(tmp34, []any{v20, v5}) - tmp36 := lang.Apply(tmp33, []any{v3, tmp35}) - tmp37 := lang.Apply(tmp32, []any{tmp36}) - tmp21 = tmp37 - } - tmp15 = tmp21 - } // end let - tmp13 = tmp15 - } // end let - tmp12 = tmp13 - } else { - } - tmp8 = tmp12 - } // end let - return tmp8 + checkArity(args, 2) + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + tmp9 := lang.Apply(v2, []any{v7}) + tmp10 := lang.Apply(v2, []any{v8}) + tmp11 := lang.Apply(v3, []any{tmp9, tmp10}) + return tmp11 }) - tmp8 := lang.Apply(lang.NewLazySeq, []any{tmp7}) - return tmp8 + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3114), kw_column, int(10), kw_end_DASH_line, int(3114), kw_end_DASH_column, int(46)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp9 := lang.Apply(tmp5, []any{tmp8, v4}) + return tmp9 default: checkArity(args, -1) panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_sort_DASH_by = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_sort_DASH_by.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // partition-all + // spit { - tmp0 := sym_partition_DASH_all.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n), lang.NewVector(sym_n, sym_coll), lang.NewVector(sym_n, sym_step, sym_coll)), kw_doc, "Returns a lazy sequence of lists like partition, but may include\n partitions with fewer than n items at the end. Returns a stateful\n transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(7222), kw_end_DASH_line, int(7222))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_spit.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_content, sym__AMP_, sym_options)), kw_doc, "Opposite of slurp. Opens f with writer, writes content, then\n closes f. Options passed to glojure.java.io/writer.", kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(6994), kw_end_DASH_line, int(6994))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 1: - v3 := args[0] + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v5 := args[0] - _ = v5 - var tmp6 any - { // let - // let binding "a" - tmp7 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) - tmp8 := lang.Apply(tmp7, []any{v3}) - tmp9 := lang.Apply(lang.NewArrayList, []any{tmp8}) - var v10 any = tmp9 - _ = v10 - var tmp11 lang.FnFunc - tmp11 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp12 := lang.Apply(v5, nil) - return tmp12 - case 1: - v12 := args[0] - _ = v12 - var tmp13 any - { // let - // let binding "result" - var tmp14 any - tmp15, ok := lang.FieldOrMethod(v10, "isEmpty") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v10, "isEmpty"))) - } - var tmp16 any - switch reflect.TypeOf(tmp15).Kind() { - case reflect.Func: - tmp16 = lang.Apply(tmp15, nil) - default: - tmp16 = tmp15 - } - if lang.IsTruthy(tmp16) { - tmp14 = v12 - } else { - var tmp17 any - { // let - // let binding "v" - tmp18 := checkDerefVar(var_glojure_DOT_core_vec) - tmp19, ok := lang.FieldOrMethod(v10, "toArray") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v10, "toArray"))) - } - var tmp20 any - switch reflect.TypeOf(tmp19).Kind() { - case reflect.Func: - tmp20 = lang.Apply(tmp19, nil) - default: - tmp20 = tmp19 - } - tmp21 := lang.Apply(tmp18, []any{tmp20}) - var v22 any = tmp21 - _ = v22 - tmp23, ok := lang.FieldOrMethod(v10, "clear") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v10, "clear"))) - } - var tmp24 any - switch reflect.TypeOf(tmp23).Kind() { - case reflect.Func: - tmp24 = lang.Apply(tmp23, nil) - default: - tmp24 = tmp23 - } - _ = tmp24 - tmp25 := checkDerefVar(var_glojure_DOT_core_unreduced) - tmp26 := lang.Apply(v5, []any{v12, v22}) - tmp27 := lang.Apply(tmp25, []any{tmp26}) - tmp17 = tmp27 - } // end let - tmp14 = tmp17 - } - var v18 any = tmp14 - _ = v18 - tmp19 := lang.Apply(v5, []any{v18}) - tmp13 = tmp19 - } // end let - return tmp13 - case 2: - v12 := args[0] - _ = v12 - v13 := args[1] - _ = v13 - tmp14, _ := lang.FieldOrMethod(v10, "add") - if reflect.TypeOf(tmp14).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) - } - tmp15 := lang.Apply(tmp14, []any{v13}) - _ = tmp15 - var tmp16 any - tmp17 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp18, ok := lang.FieldOrMethod(v10, "size") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v10, "size"))) - } - var tmp19 any - switch reflect.TypeOf(tmp18).Kind() { - case reflect.Func: - tmp19 = lang.Apply(tmp18, nil) - default: - tmp19 = tmp18 - } - tmp20 := lang.Apply(tmp17, []any{v3, tmp19}) - if lang.IsTruthy(tmp20) { - var tmp21 any - { // let - // let binding "v" - tmp22 := checkDerefVar(var_glojure_DOT_core_vec) - tmp23, ok := lang.FieldOrMethod(v10, "toArray") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v10, "toArray"))) - } - var tmp24 any - switch reflect.TypeOf(tmp23).Kind() { - case reflect.Func: - tmp24 = lang.Apply(tmp23, nil) - default: - tmp24 = tmp23 - } - tmp25 := lang.Apply(tmp22, []any{tmp24}) - var v26 any = tmp25 - _ = v26 - tmp27, ok := lang.FieldOrMethod(v10, "clear") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v10, "clear"))) - } - var tmp28 any - switch reflect.TypeOf(tmp27).Kind() { - case reflect.Func: - tmp28 = lang.Apply(tmp27, nil) - default: - tmp28 = tmp27 - } - _ = tmp28 - tmp29 := lang.Apply(v5, []any{v12, v26}) - tmp21 = tmp29 - } // end let - tmp16 = tmp21 - } else { - tmp16 = v12 - } - return tmp16 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "w" + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := lang.Apply(tmp6, []any{nil, v2, v4}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + func() { + defer func() { + tmp10, ok := lang.FieldOrMethod(v8, "close") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "close"))) + } + var tmp11 any + switch reflect.TypeOf(tmp10).Kind() { + case reflect.Func: + tmp11 = lang.Apply(tmp10, nil) default: - checkArity(args, -1) - panic("unreachable") + tmp11 = tmp10 } - }) - tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7231), kw_column, int(8), kw_end_DASH_line, int(7247), kw_end_DASH_column, int(23)) - tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp6 = tmp13 - } // end let - return tmp6 - }) - tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7229), kw_column, int(4), kw_end_DASH_line, int(7247), kw_end_DASH_column, int(25)) - tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp6 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_partition_DASH_all) - tmp6 := lang.Apply(tmp5, []any{v3, v3, v4}) - return tmp6 + _ = tmp11 + }() + tmp12 := checkDerefVar(var_glojure_DOT_core_str) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(lang.WriteWriter, []any{v8, tmp13}) + tmp9 = tmp14 + }() + tmp5 = tmp9 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_spit = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_spit.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // strip-ns + { + tmp0 := sym_strip_DASH_ns.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(255), kw_column, int(8), kw_end_DASH_line, int(255), kw_end_DASH_column, int(15), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_named)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + tmp6 := checkDerefVar(var_glojure_DOT_core_symbol) + tmp7 := checkDerefVar(var_glojure_DOT_core_name) + tmp8 := lang.Apply(tmp7, []any{v2}) + tmp9 := lang.Apply(tmp6, []any{nil, tmp8}) + tmp3 = tmp9 + } else { + tmp10 := checkDerefVar(var_glojure_DOT_core_keyword) + tmp11 := checkDerefVar(var_glojure_DOT_core_name) + tmp12 := lang.Apply(tmp11, []any{v2}) + tmp13 := lang.Apply(tmp10, []any{nil, tmp12}) + tmp3 = tmp13 + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_strip_DASH_ns = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_strip_DASH_ns.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // subseq + { + tmp0 := sym_subseq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_sc, sym_test, sym_key), lang.NewVector(sym_sc, sym_start_DASH_test, sym_start_DASH_key, sym_end_DASH_test, sym_end_DASH_key)), kw_doc, "sc must be a sorted collection, test(s) one of <, <=, > or\n >=. Returns a seq of those entries with keys ek for\n which (test (.. sc comparator (compare ek key)) 0) is true", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(5133), kw_end_DASH_line, int(5133))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { case 3: - v3 := args[0] + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + v4 := args[2] _ = v4 - v5 := args[2] - _ = v5 - var tmp6 lang.FnFunc - tmp6 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - var tmp7 any - { // let - // let binding "temp__0__auto__" - tmp8 := checkDerefVar(var_glojure_DOT_core_seq) - tmp9 := lang.Apply(tmp8, []any{v5}) - var v10 any = tmp9 - _ = v10 - var tmp11 any - if lang.IsTruthy(v10) { - var tmp12 any - { // let - // let binding "s" - var v13 any = v10 - _ = v13 - var tmp14 any + var tmp5 any + { // let + // let binding "include" + tmp6 := checkDerefVar(var_glojure_DOT_core_mk_DASH_bound_DASH_fn) + tmp7 := lang.Apply(tmp6, []any{v2, v3, v4}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core__GT_) + tmp11 := checkDerefVar(var_glojure_DOT_core__GT__EQ_) + tmp12 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{tmp10, tmp11})) + tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5141), kw_column, int(11), kw_end_DASH_line, int(5141), kw_end_DASH_column, int(17)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp15 := lang.Apply(tmp14, []any{v3}) + if lang.IsTruthy(tmp15) { + var tmp16 any + { // let + // let binding "temp__0__auto__" + tmp17, _ := lang.FieldOrMethod(v2, "seqFrom") + if reflect.TypeOf(tmp17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("seqFrom is not a function"))) + } + tmp18 := lang.Apply(tmp17, []any{v4, true}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + var tmp21 any { // let - // let binding "seg" - tmp15 := checkDerefVar(var_glojure_DOT_core_doall) - tmp16 := checkDerefVar(var_glojure_DOT_core_take) - tmp17 := lang.Apply(tmp16, []any{v3, v13}) - tmp18 := lang.Apply(tmp15, []any{tmp17}) - var v19 any = tmp18 - _ = v19 - tmp20 := checkDerefVar(var_glojure_DOT_core_cons) - tmp21 := checkDerefVar(var_glojure_DOT_core_partition_DASH_all) - tmp22 := checkDerefVar(var_glojure_DOT_core_nthrest) - tmp23 := lang.Apply(tmp22, []any{v13, v4}) - tmp24 := lang.Apply(tmp21, []any{v3, v4, tmp23}) - tmp25 := lang.Apply(tmp20, []any{v19, tmp24}) - tmp14 = tmp25 + // let binding "vec__68" + var v22 any = v19 + _ = v22 + // let binding "e" + tmp23 := checkDerefVar(var_glojure_DOT_core_nth) + tmp24 := lang.Apply(tmp23, []any{v22, int64(0), nil}) + var v25 any = tmp24 + _ = v25 + // let binding "s" + var v26 any = v22 + _ = v26 + var tmp27 any + tmp28 := lang.Apply(v8, []any{v25}) + if lang.IsTruthy(tmp28) { + tmp27 = v26 + } else { + tmp29 := checkDerefVar(var_glojure_DOT_core_next) + tmp30 := lang.Apply(tmp29, []any{v26}) + tmp27 = tmp30 + } + tmp21 = tmp27 } // end let - tmp12 = tmp14 - } // end let - tmp11 = tmp12 - } else { + tmp20 = tmp21 + } else { + } + tmp16 = tmp20 + } // end let + tmp9 = tmp16 + } else { + tmp17 := checkDerefVar(var_glojure_DOT_core_take_DASH_while) + tmp18, _ := lang.FieldOrMethod(v2, "seq") + if reflect.TypeOf(tmp18).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("seq is not a function"))) } - tmp7 = tmp11 - } // end let - return tmp7 - }) - tmp7 := lang.Apply(lang.NewLazySeq, []any{tmp6}) + tmp19 := lang.Apply(tmp18, []any{true}) + tmp20 := lang.Apply(tmp17, []any{v8, tmp19}) + tmp9 = tmp20 + } + tmp5 = tmp9 + } // end let + return tmp5 + case 5: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + var tmp7 any + { // let + // let binding "temp__0__auto__" + tmp8, _ := lang.FieldOrMethod(v2, "seqFrom") + if reflect.TypeOf(tmp8).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("seqFrom is not a function"))) + } + tmp9 := lang.Apply(tmp8, []any{v4, true}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + if lang.IsTruthy(v10) { + var tmp12 any + { // let + // let binding "vec__71" + var v13 any = v10 + _ = v13 + // let binding "e" + tmp14 := checkDerefVar(var_glojure_DOT_core_nth) + tmp15 := lang.Apply(tmp14, []any{v13, int64(0), nil}) + var v16 any = tmp15 + _ = v16 + // let binding "s" + var v17 any = v13 + _ = v17 + tmp18 := checkDerefVar(var_glojure_DOT_core_take_DASH_while) + tmp19 := checkDerefVar(var_glojure_DOT_core_mk_DASH_bound_DASH_fn) + tmp20 := lang.Apply(tmp19, []any{v2, v5, v6}) + var tmp21 any + tmp22 := checkDerefVar(var_glojure_DOT_core_mk_DASH_bound_DASH_fn) + tmp23 := lang.Apply(tmp22, []any{v2, v3, v4}) + tmp24 := lang.Apply(tmp23, []any{v16}) + if lang.IsTruthy(tmp24) { + tmp21 = v17 + } else { + tmp25 := checkDerefVar(var_glojure_DOT_core_next) + tmp26 := lang.Apply(tmp25, []any{v17}) + tmp21 = tmp26 + } + tmp27 := lang.Apply(tmp18, []any{tmp20, tmp21}) + tmp12 = tmp27 + } // end let + tmp11 = tmp12 + } else { + } + tmp7 = tmp11 + } // end let return tmp7 default: checkArity(args, -1) panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_subseq = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_subseq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // partition-by + // supers { - tmp0 := sym_partition_DASH_by.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_coll)), kw_doc, "Applies f to each value in coll, splitting it each time f returns a\n new value. Returns a lazy seq of partitions. Returns a stateful\n transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(7142), kw_end_DASH_line, int(7142))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_supers.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_class)), kw_doc, "Returns the immediate and indirect superclasses and interfaces of c, if any", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(5532), kw_end_DASH_line, int(5532))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "ret" + tmp4 := checkDerefVar(var_glojure_DOT_core_set) + tmp5 := checkDerefVar(var_glojure_DOT_core_bases) + tmp6 := lang.Apply(tmp5, []any{v2}) + tmp7 := lang.Apply(tmp4, []any{tmp6}) + var v8 any = tmp7 + _ = v8 + // let binding "cs" + var v9 any = v8 + _ = v9 + for { + var tmp10 any + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := lang.Apply(tmp11, []any{v9}) + if lang.IsTruthy(tmp12) { + var tmp13 any + { // let + // let binding "c" + tmp14 := checkDerefVar(var_glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v9}) + var v16 any = tmp15 + _ = v16 + // let binding "bs" + tmp17 := checkDerefVar(var_glojure_DOT_core_bases) + tmp18 := lang.Apply(tmp17, []any{v16}) + var v19 any = tmp18 + _ = v19 + tmp21 := checkDerefVar(var_glojure_DOT_core_into1) + tmp22 := lang.Apply(tmp21, []any{v8, v19}) + var tmp20 any = tmp22 + tmp24 := checkDerefVar(var_glojure_DOT_core_into1) + tmp25 := checkDerefVar(var_glojure_DOT_core_disj) + tmp26 := lang.Apply(tmp25, []any{v9, v16}) + tmp27 := lang.Apply(tmp24, []any{tmp26, v19}) + var tmp23 any = tmp27 + v8 = tmp20 + v9 = tmp23 + continue + } // end let + tmp10 = tmp13 + } else { + tmp14 := checkDerefVar(var_glojure_DOT_core_not_DASH_empty) + tmp15 := lang.Apply(tmp14, []any{v8}) + tmp10 = tmp15 + } + tmp3 = tmp10 + break + } + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_supers = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_supers.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // sync + { + tmp0 := sym_sync.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_flags_DASH_ignored_DASH_for_DASH_now, sym__AMP_, sym_body)), kw_doc, "transaction-flags => TBD, pass nil for now\n\n Runs the exprs (in an implicit do) in a transaction that encompasses\n exprs and any nested calls. Starts a transaction if none is already\n running on this thread. Any uncaught exception will abort the\n transaction and flow out of sync. The exprs may be run more than\n once, but any effects on Refs will be atomic.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(11), kw_line, int(2490), kw_end_DASH_line, int(2490))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 1: - v3 := args[0] + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym__DOT_}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_LockingTransaction}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_RunInTransaction}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{sym_glojure_DOT_core_SLASH_fn}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := checkDerefVar(var_glojure_DOT_core_apply) + tmp24 := checkDerefVar(var_glojure_DOT_core_vector) + tmp25 := checkDerefVar(var_glojure_DOT_core_seq) + tmp26 := checkDerefVar(var_glojure_DOT_core_concat) + tmp27 := lang.Apply(tmp26, nil) + tmp28 := lang.Apply(tmp25, []any{tmp27}) + tmp29 := lang.Apply(tmp23, []any{tmp24, tmp28}) + tmp30 := lang.Apply(tmp22, []any{tmp29}) + tmp31 := lang.Apply(tmp19, []any{tmp21, tmp30, v5}) + tmp32 := lang.Apply(tmp18, []any{tmp31}) + tmp33 := lang.Apply(tmp17, []any{tmp32}) + tmp34 := lang.Apply(tmp14, []any{tmp16, tmp33}) + tmp35 := lang.Apply(tmp13, []any{tmp34}) + tmp36 := lang.Apply(tmp12, []any{tmp35}) + tmp37 := lang.Apply(tmp7, []any{tmp9, tmp11, tmp36}) + tmp38 := lang.Apply(tmp6, []any{tmp37}) + return tmp38 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_sync = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_sync.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // take + { + tmp0 := sym_take.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n), lang.NewVector(sym_n, sym_coll)), kw_doc, "Returns a lazy sequence of the first n items in coll, or all items if\n there are fewer than n. Returns a stateful transducer when\n no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(2853), kw_end_DASH_line, int(2853))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v5 := args[0] - _ = v5 - var tmp6 any + v4 := args[0] + _ = v4 + var tmp5 any { // let - // let binding "a" - var v7 any = "unimplemented: new with non-constant class type" - _ = v7 - // let binding "pv" - tmp8 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) - tmp9 := lang.Apply(tmp8, []any{kw_glojure_DOT_core_SLASH_none}) - var v10 any = tmp9 - _ = v10 - var tmp11 lang.FnFunc - tmp11 = lang.NewFnFunc(func(args ...any) any { + // let binding "nv" + tmp6 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) + tmp7 := lang.Apply(tmp6, []any{v2}) + var v8 any = tmp7 + _ = v8 + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - tmp12 := lang.Apply(v5, nil) - return tmp12 + tmp10 := lang.Apply(v4, nil) + return tmp10 case 1: - v12 := args[0] - _ = v12 - var tmp13 any + v10 := args[0] + _ = v10 + tmp11 := lang.Apply(v4, []any{v10}) + return tmp11 + case 2: + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + var tmp12 any { // let - // let binding "result" - var tmp14 any - tmp15, ok := lang.FieldOrMethod(v7, "isEmpty") + // let binding "n" + tmp13 := checkDerefVar(var_glojure_DOT_core_deref) + tmp14 := lang.Apply(tmp13, []any{v8}) + var v15 any = tmp14 + _ = v15 + // let binding "nn" + tmp16 := checkDerefVar(var_glojure_DOT_core_dec) + tmp17, ok := lang.FieldOrMethod(v8, "Deref") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "isEmpty"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "Deref"))) } - var tmp16 any - switch reflect.TypeOf(tmp15).Kind() { + var tmp18 any + switch reflect.TypeOf(tmp17).Kind() { case reflect.Func: - tmp16 = lang.Apply(tmp15, nil) + tmp18 = lang.Apply(tmp17, nil) default: - tmp16 = tmp15 + tmp18 = tmp17 } - if lang.IsTruthy(tmp16) { - tmp14 = v12 - } else { - var tmp17 any - { // let - // let binding "v" - tmp18 := checkDerefVar(var_glojure_DOT_core_vec) - tmp19, ok := lang.FieldOrMethod(v7, "toArray") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "toArray"))) - } - var tmp20 any - switch reflect.TypeOf(tmp19).Kind() { - case reflect.Func: - tmp20 = lang.Apply(tmp19, nil) - default: - tmp20 = tmp19 - } - tmp21 := lang.Apply(tmp18, []any{tmp20}) - var v22 any = tmp21 - _ = v22 - tmp23, ok := lang.FieldOrMethod(v7, "clear") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "clear"))) - } - var tmp24 any - switch reflect.TypeOf(tmp23).Kind() { - case reflect.Func: - tmp24 = lang.Apply(tmp23, nil) - default: - tmp24 = tmp23 - } - _ = tmp24 - tmp25 := checkDerefVar(var_glojure_DOT_core_unreduced) - tmp26 := lang.Apply(v5, []any{v12, v22}) - tmp27 := lang.Apply(tmp25, []any{tmp26}) - tmp17 = tmp27 - } // end let - tmp14 = tmp17 + tmp19 := lang.Apply(tmp16, []any{tmp18}) + tmp20, _ := lang.FieldOrMethod(v8, "reset") + if reflect.TypeOf(tmp20).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) } - var v18 any = tmp14 - _ = v18 - tmp19 := lang.Apply(v5, []any{v18}) - tmp13 = tmp19 - } // end let - return tmp13 - case 2: - v12 := args[0] - _ = v12 - v13 := args[1] - _ = v13 - var tmp14 any - { // let - // let binding "pval" - tmp15 := checkDerefVar(var_glojure_DOT_core_deref) - tmp16 := lang.Apply(tmp15, []any{v10}) - var v17 any = tmp16 - _ = v17 - // let binding "val" - tmp18 := lang.Apply(v3, []any{v13}) - var v19 any = tmp18 - _ = v19 - tmp20 := checkDerefVar(var_glojure_DOT_core_vreset_BANG_) - tmp21 := lang.Apply(tmp20, []any{v10, v19}) - _ = tmp21 - var tmp22 any + tmp21 := lang.Apply(tmp20, []any{tmp19}) + var v22 any = tmp21 + _ = v22 + // let binding "result" var tmp23 any - { // let - // let binding "or__0__auto__" - tmp24 := checkDerefVar(var_glojure_DOT_core_identical_QMARK_) - tmp25 := lang.Apply(tmp24, []any{v17, kw_glojure_DOT_core_SLASH_none}) - var v26 any = tmp25 - _ = v26 - var tmp27 any - if lang.IsTruthy(v26) { - tmp27 = v26 - } else { - tmp28 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp29 := lang.Apply(tmp28, []any{v19, v17}) - tmp27 = tmp29 - } - tmp23 = tmp27 - } // end let - if lang.IsTruthy(tmp23) { - tmp24, _ := lang.FieldOrMethod(v7, "add") - if reflect.TypeOf(tmp24).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) - } - tmp25 := lang.Apply(tmp24, []any{v13}) - _ = tmp25 - tmp22 = v12 + tmp24 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp25 := lang.Apply(tmp24, []any{v15}) + if lang.IsTruthy(tmp25) { + tmp26 := lang.Apply(v4, []any{v10, v11}) + tmp23 = tmp26 } else { - var tmp26 any - { // let - // let binding "v" - tmp27 := checkDerefVar(var_glojure_DOT_core_vec) - tmp28, ok := lang.FieldOrMethod(v7, "toArray") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "toArray"))) - } - var tmp29 any - switch reflect.TypeOf(tmp28).Kind() { - case reflect.Func: - tmp29 = lang.Apply(tmp28, nil) - default: - tmp29 = tmp28 - } - tmp30 := lang.Apply(tmp27, []any{tmp29}) - var v31 any = tmp30 - _ = v31 - tmp32, ok := lang.FieldOrMethod(v7, "clear") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "clear"))) - } - var tmp33 any - switch reflect.TypeOf(tmp32).Kind() { - case reflect.Func: - tmp33 = lang.Apply(tmp32, nil) - default: - tmp33 = tmp32 - } - _ = tmp33 - var tmp34 any - { // let - // let binding "ret" - tmp35 := lang.Apply(v5, []any{v12, v31}) - var v36 any = tmp35 - _ = v36 - var tmp37 any - tmp38 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) - tmp39 := lang.Apply(tmp38, []any{v36}) - if lang.IsTruthy(tmp39) { - } else { - tmp40, _ := lang.FieldOrMethod(v7, "add") - if reflect.TypeOf(tmp40).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) - } - tmp41 := lang.Apply(tmp40, []any{v13}) - tmp37 = tmp41 - } - _ = tmp37 - tmp34 = v36 - } // end let - tmp26 = tmp34 - } // end let - tmp22 = tmp26 + tmp23 = v10 + } + var v27 any = tmp23 + _ = v27 + var tmp28 any + tmp29 := checkDerefVar(var_glojure_DOT_core_not) + tmp30 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp31 := lang.Apply(tmp30, []any{v22}) + tmp32 := lang.Apply(tmp29, []any{tmp31}) + if lang.IsTruthy(tmp32) { + tmp33 := checkDerefVar(var_glojure_DOT_core_ensure_DASH_reduced) + tmp34 := lang.Apply(tmp33, []any{v27}) + tmp28 = tmp34 + } else { + tmp28 = v27 } - tmp14 = tmp22 + tmp12 = tmp28 } // end let - return tmp14 + return tmp12 default: checkArity(args, -1) panic("unreachable") } }) - tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7152), kw_column, int(7), kw_end_DASH_line, int(7176), kw_end_DASH_column, int(28)) - tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2862), kw_column, int(10), kw_end_DASH_line, int(2873), kw_end_DASH_column, int(28)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp6 = tmp13 + tmp5 = tmp11 } // end let - return tmp6 + return tmp5 }) - tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7149), kw_column, int(3), kw_end_DASH_line, int(7176), kw_end_DASH_column, int(30)) - tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2860), kw_column, int(6), kw_end_DASH_line, int(2873), kw_end_DASH_column, int(30)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) if err != nil { panic(err) } - return tmp6 + return tmp5 case 2: - v3 := args[0] + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] - _ = v4 - var tmp5 lang.FnFunc - tmp5 = lang.NewFnFunc(func(args ...any) any { + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 0) - var tmp6 any - { // let - // let binding "temp__0__auto__" - tmp7 := checkDerefVar(var_glojure_DOT_core_seq) - tmp8 := lang.Apply(tmp7, []any{v4}) - var v9 any = tmp8 - _ = v9 - var tmp10 any - if lang.IsTruthy(v9) { - var tmp11 any - { // let - // let binding "s" - var v12 any = v9 - _ = v12 + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp7 := lang.Apply(tmp6, []any{v2}) + if lang.IsTruthy(tmp7) { + var tmp8 any + { // let + // let binding "temp__0__auto__" + tmp9 := checkDerefVar(var_glojure_DOT_core_seq) + tmp10 := lang.Apply(tmp9, []any{v3}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { var tmp13 any { // let - // let binding "fst" - tmp14 := checkDerefVar(var_glojure_DOT_core_first) - tmp15 := lang.Apply(tmp14, []any{v12}) - var v16 any = tmp15 - _ = v16 - // let binding "fv" - tmp17 := lang.Apply(v3, []any{v16}) - var v18 any = tmp17 - _ = v18 - // let binding "run" - tmp19 := checkDerefVar(var_glojure_DOT_core_cons) - tmp20 := checkDerefVar(var_glojure_DOT_core_take_DASH_while) - var tmp21 lang.FnFunc - tmp21 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v22 := args[0] - _ = v22 - tmp23 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp24 := lang.Apply(v3, []any{v22}) - tmp25 := lang.Apply(tmp23, []any{v18, tmp24}) - return tmp25 - }) - tmp22 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7182), kw_column, int(41), kw_end_DASH_line, int(7182), kw_end_DASH_column, int(53)) - tmp23, err := lang.WithMeta(tmp21, tmp22.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp24 := checkDerefVar(var_glojure_DOT_core_next) - tmp25 := lang.Apply(tmp24, []any{v12}) - tmp26 := lang.Apply(tmp20, []any{tmp23, tmp25}) - tmp27 := lang.Apply(tmp19, []any{v16, tmp26}) - var v28 any = tmp27 - _ = v28 - tmp29 := checkDerefVar(var_glojure_DOT_core_cons) - tmp30 := checkDerefVar(var_glojure_DOT_core_partition_DASH_by) - var tmp31 lang.FnFunc - tmp31 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - tmp32 := checkDerefVar(var_glojure_DOT_core_drop) - tmp33 := checkDerefVar(var_glojure_DOT_core_count) - tmp34 := lang.Apply(tmp33, []any{v28}) - tmp35 := lang.Apply(tmp32, []any{tmp34, v12}) - return tmp35 - }) - tmp32 := lang.Apply(lang.NewLazySeq, []any{tmp31}) - tmp33 := lang.Apply(tmp30, []any{v3, tmp32}) - tmp34 := lang.Apply(tmp29, []any{v28, tmp33}) - tmp13 = tmp34 + // let binding "s" + var v14 any = v11 + _ = v14 + tmp15 := checkDerefVar(var_glojure_DOT_core_cons) + tmp16 := checkDerefVar(var_glojure_DOT_core_first) + tmp17 := lang.Apply(tmp16, []any{v14}) + tmp18 := checkDerefVar(var_glojure_DOT_core_take) + tmp19 := checkDerefVar(var_glojure_DOT_core_dec) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(var_glojure_DOT_core_rest) + tmp22 := lang.Apply(tmp21, []any{v14}) + tmp23 := lang.Apply(tmp18, []any{tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp17, tmp23}) + tmp13 = tmp24 } // end let - tmp11 = tmp13 - } // end let - tmp10 = tmp11 - } else { - } - tmp6 = tmp10 - } // end let - return tmp6 + tmp12 = tmp13 + } else { + } + tmp8 = tmp12 + } // end let + tmp5 = tmp8 + } else { + } + return tmp5 }) - tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) - return tmp6 + tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) + return tmp5 default: checkArity(args, -1) panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_take = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_take.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // partitionv + // take-last { - tmp0 := sym_partitionv.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n, sym_coll), lang.NewVector(sym_n, sym_step, sym_coll), lang.NewVector(sym_n, sym_step, sym_pad, sym_coll)), kw_doc, "Returns a lazy sequence of vectors of n items each, at offsets step\n apart. If step is not supplied, defaults to n, i.e. the partitions\n do not overlap. If a pad collection is supplied, use its elements as\n necessary to complete last partition upto n items. In case there are\n not enough padding elements, return a partition with less than n items.", kw_file, "glojure/core.glj", kw_added, "1.12", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(7262), kw_end_DASH_line, int(7262))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_take_DASH_last.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n, sym_coll)), kw_doc, "Returns a seq of the last n items in coll. Depending on the type\n of coll may be no better than linear time. For vectors, see also subvec.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(2939), kw_end_DASH_line, int(2939))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "s" + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := lang.Apply(tmp5, []any{v3}) + var v7 any = tmp6 + _ = v7 + // let binding "lead" + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_drop) + tmp10 := lang.Apply(tmp9, []any{v2, v3}) + tmp11 := lang.Apply(tmp8, []any{tmp10}) + var v12 any = tmp11 + _ = v12 + for { + var tmp13 any + if lang.IsTruthy(v12) { + tmp15 := checkDerefVar(var_glojure_DOT_core_next) + tmp16 := lang.Apply(tmp15, []any{v7}) + var tmp14 any = tmp16 + tmp18 := checkDerefVar(var_glojure_DOT_core_next) + tmp19 := lang.Apply(tmp18, []any{v12}) + var tmp17 any = tmp19 + v7 = tmp14 + v12 = tmp17 + continue + } else { + tmp13 = v7 + } + tmp4 = tmp13 + break + } + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_take_DASH_last = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_take_DASH_last.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // take-nth + { + tmp0 := sym_take_DASH_nth.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n), lang.NewVector(sym_n, sym_coll)), kw_doc, "Returns a lazy seq of every nth item in coll. Returns a stateful\n transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(4287), kw_end_DASH_line, int(4287))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_partitionv) - tmp6 := lang.Apply(tmp5, []any{v3, v3, v4}) - return tmp6 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var tmp6 lang.FnFunc - tmp6 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - var tmp7 any + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 any { // let - // let binding "temp__0__auto__" - tmp8 := checkDerefVar(var_glojure_DOT_core_seq) - tmp9 := lang.Apply(tmp8, []any{v5}) - var v10 any = tmp9 - _ = v10 - var tmp11 any - if lang.IsTruthy(v10) { - var tmp12 any - { // let - // let binding "s" - var v13 any = v10 - _ = v13 - var tmp14 any + // let binding "iv" + tmp6 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) + tmp7 := lang.Apply(tmp6, []any{int64(-1)}) + var v8 any = tmp7 + _ = v8 + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp10 := lang.Apply(v4, nil) + return tmp10 + case 1: + v10 := args[0] + _ = v10 + tmp11 := lang.Apply(v4, []any{v10}) + return tmp11 + case 2: + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + var tmp12 any { // let - // let binding "p" - tmp15 := checkDerefVar(var_glojure_DOT_core_into) - tmp16 := lang.NewVector() - tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7274), kw_column, int(22), kw_end_DASH_line, int(7274), kw_end_DASH_column, int(23)) - tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) - if err != nil { - panic(err) + // let binding "i" + tmp13 := checkDerefVar(var_glojure_DOT_core_inc) + tmp14, ok := lang.FieldOrMethod(v8, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "Deref"))) } - tmp19 := checkDerefVar(var_glojure_DOT_core_take) - tmp20 := lang.Apply(tmp19, []any{v3}) - tmp21 := lang.Apply(tmp15, []any{tmp18, tmp20, v13}) - var v22 any = tmp21 - _ = v22 - var tmp23 any - tmp24 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp25 := checkDerefVar(var_glojure_DOT_core_count) - tmp26 := lang.Apply(tmp25, []any{v22}) - tmp27 := lang.Apply(tmp24, []any{v3, tmp26}) - if lang.IsTruthy(tmp27) { - tmp28 := checkDerefVar(var_glojure_DOT_core_cons) - tmp29 := checkDerefVar(var_glojure_DOT_core_partitionv) - tmp30 := checkDerefVar(var_glojure_DOT_core_nthrest) - tmp31 := lang.Apply(tmp30, []any{v13, v4}) - tmp32 := lang.Apply(tmp29, []any{v3, v4, tmp31}) - tmp33 := lang.Apply(tmp28, []any{v22, tmp32}) - tmp23 = tmp33 + var tmp15 any + switch reflect.TypeOf(tmp14).Kind() { + case reflect.Func: + tmp15 = lang.Apply(tmp14, nil) + default: + tmp15 = tmp14 + } + tmp16 := lang.Apply(tmp13, []any{tmp15}) + tmp17, _ := lang.FieldOrMethod(v8, "reset") + if reflect.TypeOf(tmp17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) + } + tmp18 := lang.Apply(tmp17, []any{tmp16}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + tmp21 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) + tmp22 := checkDerefVar(var_glojure_DOT_core_rem) + tmp23 := lang.Apply(tmp22, []any{v19, v2}) + tmp24 := lang.Apply(tmp21, []any{tmp23}) + if lang.IsTruthy(tmp24) { + tmp25 := lang.Apply(v4, []any{v10, v11}) + tmp20 = tmp25 } else { + tmp20 = v10 } - tmp14 = tmp23 + tmp12 = tmp20 } // end let - tmp12 = tmp14 - } // end let - tmp11 = tmp12 - } else { + return tmp12 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4295), kw_column, int(10), kw_end_DASH_line, int(4302), kw_end_DASH_column, int(28)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) } - tmp7 = tmp11 + tmp5 = tmp11 } // end let - return tmp7 + return tmp5 }) - tmp7 := lang.Apply(lang.NewLazySeq, []any{tmp6}) - return tmp7 - case 4: - v3 := args[0] + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4293), kw_column, int(6), kw_end_DASH_line, int(4302), kw_end_DASH_column, int(30)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - var tmp7 lang.FnFunc - tmp7 = lang.NewFnFunc(func(args ...any) any { + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 0) - var tmp8 any + var tmp5 any { // let // let binding "temp__0__auto__" - tmp9 := checkDerefVar(var_glojure_DOT_core_seq) - tmp10 := lang.Apply(tmp9, []any{v6}) - var v11 any = tmp10 - _ = v11 - var tmp12 any - if lang.IsTruthy(v11) { - var tmp13 any + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := lang.Apply(tmp6, []any{v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + var tmp10 any { // let // let binding "s" - var v14 any = v11 - _ = v14 - var tmp15 any - { // let - // let binding "p" - tmp16 := checkDerefVar(var_glojure_DOT_core_into) - tmp17 := lang.NewVector() - tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7280), kw_column, int(22), kw_end_DASH_line, int(7280), kw_end_DASH_column, int(23)) - tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp20 := checkDerefVar(var_glojure_DOT_core_take) - tmp21 := lang.Apply(tmp20, []any{v3}) - tmp22 := lang.Apply(tmp16, []any{tmp19, tmp21, v14}) - var v23 any = tmp22 - _ = v23 - var tmp24 any - tmp25 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp26 := checkDerefVar(var_glojure_DOT_core_count) - tmp27 := lang.Apply(tmp26, []any{v23}) - tmp28 := lang.Apply(tmp25, []any{v3, tmp27}) - if lang.IsTruthy(tmp28) { - tmp29 := checkDerefVar(var_glojure_DOT_core_cons) - tmp30 := checkDerefVar(var_glojure_DOT_core_partitionv) - tmp31 := checkDerefVar(var_glojure_DOT_core_nthrest) - tmp32 := lang.Apply(tmp31, []any{v14, v4}) - tmp33 := lang.Apply(tmp30, []any{v3, v4, v5, tmp32}) - tmp34 := lang.Apply(tmp29, []any{v23, tmp33}) - tmp24 = tmp34 - } else { - tmp35 := checkDerefVar(var_glojure_DOT_core_list) - tmp36 := checkDerefVar(var_glojure_DOT_core_into) - tmp37 := lang.NewVector() - tmp38 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7283), kw_column, int(24), kw_end_DASH_line, int(7283), kw_end_DASH_column, int(25)) - tmp39, err := lang.WithMeta(tmp37, tmp38.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp40 := checkDerefVar(var_glojure_DOT_core_take) - tmp41 := lang.Apply(tmp40, []any{v3}) - tmp42 := checkDerefVar(var_glojure_DOT_core_concat) - tmp43 := lang.Apply(tmp42, []any{v23, v5}) - tmp44 := lang.Apply(tmp36, []any{tmp39, tmp41, tmp43}) - tmp45 := lang.Apply(tmp35, []any{tmp44}) - tmp24 = tmp45 - } - tmp15 = tmp24 - } // end let - tmp13 = tmp15 + var v11 any = v8 + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_cons) + tmp13 := checkDerefVar(var_glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v11}) + tmp15 := checkDerefVar(var_glojure_DOT_core_take_DASH_nth) + tmp16 := checkDerefVar(var_glojure_DOT_core_drop) + tmp17 := lang.Apply(tmp16, []any{v2, v11}) + tmp18 := lang.Apply(tmp15, []any{v2, tmp17}) + tmp19 := lang.Apply(tmp12, []any{tmp14, tmp18}) + tmp10 = tmp19 } // end let - tmp12 = tmp13 + tmp9 = tmp10 } else { } - tmp8 = tmp12 + tmp5 = tmp9 } // end let - return tmp8 + return tmp5 }) - tmp8 := lang.Apply(lang.NewLazySeq, []any{tmp7}) - return tmp8 + tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) + return tmp5 default: checkArity(args, -1) panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_take_DASH_nth = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_take_DASH_nth.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // partitionv-all + // throw-if { - tmp0 := sym_partitionv_DASH_all.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n), lang.NewVector(sym_n, sym_coll), lang.NewVector(sym_n, sym_step, sym_coll)), kw_doc, "Returns a lazy sequence of vector partitions, but may include\n partitions with fewer than n items at the end.\n Returns a stateful transducer when no collection is provided.", kw_file, "glojure/core.glj", kw_added, "1.12", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(7285), kw_end_DASH_line, int(7285))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_throw_DASH_if.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred, sym_fmt, sym__AMP_, sym_args)), kw_doc, "Throws a CompilerException with a message if pred is true", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(8), kw_line, int(5832), kw_end_DASH_line, int(5832), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 1: - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_partition_DASH_all) - tmp5 := lang.Apply(tmp4, []any{v3}) - return tmp5 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_partitionv_DASH_all) - tmp6 := lang.Apply(tmp5, []any{v3, v3, v4}) - return tmp6 - case 3: - v3 := args[0] + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + var v4 any = lang.NewList(args[2:]...) _ = v4 - v5 := args[2] - _ = v5 - var tmp6 lang.FnFunc - tmp6 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - var tmp7 any + var tmp5 any + if lang.IsTruthy(v2) { + var tmp6 any { // let - // let binding "temp__0__auto__" - tmp8 := checkDerefVar(var_glojure_DOT_core_seq) - tmp9 := lang.Apply(tmp8, []any{v5}) + // let binding "message" + tmp7 := checkDerefVar(var_glojure_DOT_core_apply) + tmp8 := checkDerefVar(var_glojure_DOT_core_format) + tmp9 := lang.Apply(tmp7, []any{tmp8, v3, v4}) var v10 any = tmp9 _ = v10 - var tmp11 any - if lang.IsTruthy(v10) { - var tmp12 any - { // let - // let binding "s" - var v13 any = v10 - _ = v13 - var tmp14 any - { // let - // let binding "seg" - tmp15 := checkDerefVar(var_glojure_DOT_core_into) - tmp16 := lang.NewVector() - tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7297), kw_column, int(24), kw_end_DASH_line, int(7297), kw_end_DASH_column, int(25)) - tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp19 := checkDerefVar(var_glojure_DOT_core_take) - tmp20 := lang.Apply(tmp19, []any{v3}) - tmp21 := lang.Apply(tmp15, []any{tmp18, tmp20, v5}) - var v22 any = tmp21 - _ = v22 - tmp23 := checkDerefVar(var_glojure_DOT_core_cons) - tmp24 := checkDerefVar(var_glojure_DOT_core_partitionv_DASH_all) - tmp25 := checkDerefVar(var_glojure_DOT_core_drop) - tmp26 := lang.Apply(tmp25, []any{v4, v13}) - tmp27 := lang.Apply(tmp24, []any{v3, v4, tmp26}) - tmp28 := lang.Apply(tmp23, []any{v22, tmp27}) - tmp14 = tmp28 - } // end let - tmp12 = tmp14 - } // end let - tmp11 = tmp12 - } else { + // let binding "exception" + tmp11 := lang.Apply(lang.NewError, []any{v10}) + var v12 any = tmp11 + _ = v12 + // let binding "raw-trace" + tmp13, ok := lang.FieldOrMethod(v12, "getStackTrace") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v12, "getStackTrace"))) } - tmp7 = tmp11 + var tmp14 any + switch reflect.TypeOf(tmp13).Kind() { + case reflect.Func: + tmp14 = lang.Apply(tmp13, nil) + default: + tmp14 = tmp13 + } + var v15 any = tmp14 + _ = v15 + // let binding "boring?" + var tmp16 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v17 := args[0] + _ = v17 + tmp18 := checkDerefVar(var_glojure_DOT_core_not_EQ_) + tmp19, ok := lang.FieldOrMethod(v17, "getMethodName") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v17, "getMethodName"))) + } + var tmp20 any + switch reflect.TypeOf(tmp19).Kind() { + case reflect.Func: + tmp20 = lang.Apply(tmp19, nil) + default: + tmp20 = tmp19 + } + tmp21 := lang.Apply(tmp18, []any{tmp20, "doInvoke"}) + return tmp21 + }) + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5839), kw_column, int(19), kw_end_DASH_line, int(5839), kw_end_DASH_column, int(74)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v19 any = tmp18 + _ = v19 + // let binding "trace" + tmp20 := checkDerefVar(var_glojure_DOT_core_into_DASH_array) + tmp21 := checkDerefVar(var_glojure_DOT_core_drop) + tmp22 := checkDerefVar(var_glojure_DOT_core_drop_DASH_while) + tmp23 := lang.Apply(tmp22, []any{v19, v15}) + tmp24 := lang.Apply(tmp21, []any{int64(2), tmp23}) + tmp25 := lang.Apply(tmp20, []any{nil, tmp24}) + var v26 any = tmp25 + _ = v26 + tmp27, _ := lang.FieldOrMethod(v12, "setStackTrace") + if reflect.TypeOf(tmp27).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setStackTrace is not a function"))) + } + tmp28 := lang.Apply(tmp27, []any{v26}) + _ = tmp28 + tmp29 := checkDerefVar(var_glojure_DOT_core__STAR_file_STAR_) + tmp30, ok := lang.FieldOrMethod(nil, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "Deref"))) + } + var tmp31 any + switch reflect.TypeOf(tmp30).Kind() { + case reflect.Func: + tmp31 = lang.Apply(tmp30, nil) + default: + tmp31 = tmp30 + } + tmp32, ok := lang.FieldOrMethod(nil, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "Deref"))) + } + var tmp33 any + switch reflect.TypeOf(tmp32).Kind() { + case reflect.Func: + tmp33 = lang.Apply(tmp32, nil) + default: + tmp33 = tmp32 + } + tmp34 := lang.Apply(lang.NewCompilerError, []any{tmp29, tmp31, tmp33, v12}) + panic(tmp34) } // end let - return tmp7 - }) - tmp7 := lang.Apply(lang.NewLazySeq, []any{tmp6}) - return tmp7 - default: - checkArity(args, -1) - panic("unreachable") + tmp5 = tmp6 + } else { + } + return tmp5 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_throw_DASH_if = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_throw_DASH_if.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // pcalls + // time { - tmp0 := sym_pcalls.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_fns)), kw_doc, "Executes the no-arg fns in parallel, returning a lazy sequence of\n their values", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(7056), kw_end_DASH_line, int(7056))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_time.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_expr)), kw_doc, "Evaluates expr and prints the time it took. Returns the value of\n expr.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(11), kw_line, int(3885), kw_end_DASH_line, int(3885))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym_glojure_DOT_core_SLASH_let}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := checkDerefVar(var_glojure_DOT_core_apply) + tmp11 := checkDerefVar(var_glojure_DOT_core_vector) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_start__0__auto__}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := checkDerefVar(var_glojure_DOT_core_seq) + tmp18 := checkDerefVar(var_glojure_DOT_core_concat) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{sym__DOT_UnixNano}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := checkDerefVar(var_glojure_DOT_core_seq) + tmp23 := checkDerefVar(var_glojure_DOT_core_concat) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{sym_time_DOT_Now}) + tmp26 := lang.Apply(tmp23, []any{tmp25}) + tmp27 := lang.Apply(tmp22, []any{tmp26}) + tmp28 := lang.Apply(tmp21, []any{tmp27}) + tmp29 := lang.Apply(tmp18, []any{tmp20, tmp28}) + tmp30 := lang.Apply(tmp17, []any{tmp29}) + tmp31 := lang.Apply(tmp16, []any{tmp30}) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := lang.Apply(tmp32, []any{sym_ret__1__auto__}) + tmp34 := checkDerefVar(var_glojure_DOT_core_list) + tmp35 := lang.Apply(tmp34, []any{v4}) + tmp36 := lang.Apply(tmp13, []any{tmp15, tmp31, tmp33, tmp35}) + tmp37 := lang.Apply(tmp12, []any{tmp36}) + tmp38 := lang.Apply(tmp10, []any{tmp11, tmp37}) + tmp39 := lang.Apply(tmp9, []any{tmp38}) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := checkDerefVar(var_glojure_DOT_core_seq) + tmp42 := checkDerefVar(var_glojure_DOT_core_concat) + tmp43 := checkDerefVar(var_glojure_DOT_core_list) + tmp44 := lang.Apply(tmp43, []any{sym_glojure_DOT_core_SLASH_prn}) + tmp45 := checkDerefVar(var_glojure_DOT_core_list) + tmp46 := checkDerefVar(var_glojure_DOT_core_seq) + tmp47 := checkDerefVar(var_glojure_DOT_core_concat) + tmp48 := checkDerefVar(var_glojure_DOT_core_list) + tmp49 := lang.Apply(tmp48, []any{sym_glojure_DOT_core_SLASH_str}) + tmp50 := checkDerefVar(var_glojure_DOT_core_list) + tmp51 := lang.Apply(tmp50, []any{"Elapsed time: "}) + tmp52 := checkDerefVar(var_glojure_DOT_core_list) + tmp53 := checkDerefVar(var_glojure_DOT_core_seq) + tmp54 := checkDerefVar(var_glojure_DOT_core_concat) + tmp55 := checkDerefVar(var_glojure_DOT_core_list) + tmp56 := lang.Apply(tmp55, []any{sym_glojure_DOT_core_SLASH__SLASH_}) + tmp57 := checkDerefVar(var_glojure_DOT_core_list) + tmp58 := checkDerefVar(var_glojure_DOT_core_seq) + tmp59 := checkDerefVar(var_glojure_DOT_core_concat) + tmp60 := checkDerefVar(var_glojure_DOT_core_list) + tmp61 := lang.Apply(tmp60, []any{sym_glojure_DOT_core_SLASH_double}) + tmp62 := checkDerefVar(var_glojure_DOT_core_list) + tmp63 := checkDerefVar(var_glojure_DOT_core_seq) + tmp64 := checkDerefVar(var_glojure_DOT_core_concat) + tmp65 := checkDerefVar(var_glojure_DOT_core_list) + tmp66 := lang.Apply(tmp65, []any{sym_glojure_DOT_core_SLASH__DASH_}) + tmp67 := checkDerefVar(var_glojure_DOT_core_list) + tmp68 := checkDerefVar(var_glojure_DOT_core_seq) + tmp69 := checkDerefVar(var_glojure_DOT_core_concat) + tmp70 := checkDerefVar(var_glojure_DOT_core_list) + tmp71 := lang.Apply(tmp70, []any{sym__DOT_UnixNano}) + tmp72 := checkDerefVar(var_glojure_DOT_core_list) + tmp73 := checkDerefVar(var_glojure_DOT_core_seq) + tmp74 := checkDerefVar(var_glojure_DOT_core_concat) + tmp75 := checkDerefVar(var_glojure_DOT_core_list) + tmp76 := lang.Apply(tmp75, []any{sym_time_DOT_Now}) + tmp77 := lang.Apply(tmp74, []any{tmp76}) + tmp78 := lang.Apply(tmp73, []any{tmp77}) + tmp79 := lang.Apply(tmp72, []any{tmp78}) + tmp80 := lang.Apply(tmp69, []any{tmp71, tmp79}) + tmp81 := lang.Apply(tmp68, []any{tmp80}) + tmp82 := lang.Apply(tmp67, []any{tmp81}) + tmp83 := checkDerefVar(var_glojure_DOT_core_list) + tmp84 := lang.Apply(tmp83, []any{sym_start__0__auto__}) + tmp85 := lang.Apply(tmp64, []any{tmp66, tmp82, tmp84}) + tmp86 := lang.Apply(tmp63, []any{tmp85}) + tmp87 := lang.Apply(tmp62, []any{tmp86}) + tmp88 := lang.Apply(tmp59, []any{tmp61, tmp87}) + tmp89 := lang.Apply(tmp58, []any{tmp88}) + tmp90 := lang.Apply(tmp57, []any{tmp89}) + tmp91 := checkDerefVar(var_glojure_DOT_core_list) + tmp92 := lang.Apply(tmp91, []any{float64(1e+06)}) + tmp93 := lang.Apply(tmp54, []any{tmp56, tmp90, tmp92}) + tmp94 := lang.Apply(tmp53, []any{tmp93}) + tmp95 := lang.Apply(tmp52, []any{tmp94}) + tmp96 := checkDerefVar(var_glojure_DOT_core_list) + tmp97 := lang.Apply(tmp96, []any{" msecs"}) + tmp98 := lang.Apply(tmp47, []any{tmp49, tmp51, tmp95, tmp97}) + tmp99 := lang.Apply(tmp46, []any{tmp98}) + tmp100 := lang.Apply(tmp45, []any{tmp99}) + tmp101 := lang.Apply(tmp42, []any{tmp44, tmp100}) + tmp102 := lang.Apply(tmp41, []any{tmp101}) + tmp103 := lang.Apply(tmp40, []any{tmp102}) + tmp104 := checkDerefVar(var_glojure_DOT_core_list) + tmp105 := lang.Apply(tmp104, []any{sym_ret__1__auto__}) + tmp106 := lang.Apply(tmp6, []any{tmp8, tmp39, tmp103, tmp105}) + tmp107 := lang.Apply(tmp5, []any{tmp106}) + return tmp107 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_time = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_time.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // trampoline + { + tmp0 := sym_trampoline.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym__AMP_, sym_args)), kw_doc, "trampoline can be used to convert algorithms requiring mutual\n recursion without stack consumption. Calls f with supplied args, if\n any. If f returns a fn, calls that fn with no arguments, and\n continues to repeat, until the return value is not a fn, then\n returns that non-fn value. Note that if you want to return a fn as a\n final value, you must wrap it in some data structure and unpack it\n after trampoline returns.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(6293), kw_end_DASH_line, int(6293))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { + case 1: + v2 := args[0] + _ = v2 + recur_loop_1073: + var tmp3 any + { // let + // let binding "ret" + tmp4 := lang.Apply(v2, nil) + var v5 any = tmp4 + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_fn_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v5}) + if lang.IsTruthy(tmp8) { + var tmp9 any = v5 + v2 = tmp9 + goto recur_loop_1073 + } else { + tmp6 = v5 + } + tmp3 = tmp6 + } // end let + return tmp3 default: - checkArity(args, 0) - var v3 any = lang.NewList(args[0:]...) + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_pmap) + tmp4 := checkDerefVar(var_glojure_DOT_core_trampoline) var tmp5 lang.FnFunc tmp5 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v6 := args[0] - _ = v6 - tmp7 := lang.Apply(v6, nil) + checkArity(args, 0) + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := lang.Apply(tmp6, []any{v2, v3}) return tmp7 }) - tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7061), kw_column, int(17), kw_end_DASH_line, int(7061), kw_end_DASH_column, int(20)) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6309), kw_column, int(18), kw_end_DASH_line, int(6309), kw_end_DASH_column, int(32)) tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp8 := lang.Apply(tmp4, []any{tmp7, v3}) + tmp8 := lang.Apply(tmp4, []any{tmp7}) return tmp8 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_trampoline = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_trampoline.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // peek + // update { - tmp0 := sym_peek.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "For a list or queue, same as first, for a vector, same as, but much\n more efficient than, last. If the collection is empty, returns nil.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1455), kw_end_DASH_line, int(1455))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4, _ := lang.FieldOrMethod(runtime.RT, "Peek") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Peek is not a function"))) + tmp0 := sym_update.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m, sym_k, sym_f), lang.NewVector(sym_m, sym_k, sym_f, sym_x), lang.NewVector(sym_m, sym_k, sym_f, sym_x, sym_y), lang.NewVector(sym_m, sym_k, sym_f, sym_x, sym_y, sym_z), lang.NewVector(sym_m, sym_k, sym_f, sym_x, sym_y, sym_z, sym__AMP_, sym_more)), kw_doc, "'Updates' a value in an associative structure, where k is a\n key and f is a function that will take the old value\n and any supplied args and return the new value, and returns a new\n structure. If the key does not exist, nil is passed as the old value.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(6174), kw_end_DASH_line, int(6174))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp6 := checkDerefVar(var_glojure_DOT_core_get) + tmp7 := lang.Apply(tmp6, []any{v2, v3}) + tmp8 := lang.Apply(v4, []any{tmp7}) + tmp9 := lang.Apply(tmp5, []any{v2, v3, tmp8}) + return tmp9 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp7 := checkDerefVar(var_glojure_DOT_core_get) + tmp8 := lang.Apply(tmp7, []any{v2, v3}) + tmp9 := lang.Apply(v4, []any{tmp8, v5}) + tmp10 := lang.Apply(tmp6, []any{v2, v3, tmp9}) + return tmp10 + case 5: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp8 := checkDerefVar(var_glojure_DOT_core_get) + tmp9 := lang.Apply(tmp8, []any{v2, v3}) + tmp10 := lang.Apply(v4, []any{tmp9, v5, v6}) + tmp11 := lang.Apply(tmp7, []any{v2, v3, tmp10}) + return tmp11 + case 6: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + v7 := args[5] + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp9 := checkDerefVar(var_glojure_DOT_core_get) + tmp10 := lang.Apply(tmp9, []any{v2, v3}) + tmp11 := lang.Apply(v4, []any{tmp10, v5, v6, v7}) + tmp12 := lang.Apply(tmp8, []any{v2, v3, tmp11}) + return tmp12 + default: + checkArity(args, 6) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + v7 := args[5] + _ = v7 + var v8 any = lang.NewList(args[6:]...) + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp10 := checkDerefVar(var_glojure_DOT_core_apply) + tmp11 := checkDerefVar(var_glojure_DOT_core_get) + tmp12 := lang.Apply(tmp11, []any{v2, v3}) + tmp13 := lang.Apply(tmp10, []any{v4, tmp12, v5, v6, v7, v8}) + tmp14 := lang.Apply(tmp9, []any{v2, v3, tmp13}) + return tmp14 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_update = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_update.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // update-in + { + tmp0 := sym_update_DASH_in.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m, sym_ks, sym_f, sym__AMP_, sym_args)), kw_doc, "'Updates' a value in a nested associative structure, where ks is a\n sequence of keys and f is a function that will take the old value\n and any supplied args and return the new value, and returns a new\n nested structure. If any levels do not exist, hash-maps will be\n created.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(6158), kw_end_DASH_line, int(6158))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "up" + var tmp7 lang.FnFunc + { // function up + var v8 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 4) + v9 := args[0] + _ = v9 + v10 := args[1] + _ = v10 + v11 := args[2] + _ = v11 + v12 := args[3] + _ = v12 + var tmp13 any + { // let + // let binding "vec__141" + var v14 any = v10 + _ = v14 + // let binding "seq__142" + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := lang.Apply(tmp15, []any{v14}) + var v17 any = tmp16 + _ = v17 + // let binding "first__143" + tmp18 := checkDerefVar(var_glojure_DOT_core_first) + tmp19 := lang.Apply(tmp18, []any{v17}) + var v20 any = tmp19 + _ = v20 + // let binding "seq__142" + tmp21 := checkDerefVar(var_glojure_DOT_core_next) + tmp22 := lang.Apply(tmp21, []any{v17}) + var v23 any = tmp22 + _ = v23 + // let binding "k" + var v24 any = v20 + _ = v24 + // let binding "ks" + var v25 any = v23 + _ = v25 + var tmp26 any + if lang.IsTruthy(v25) { + tmp27 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp28 := checkDerefVar(var_glojure_DOT_core_get) + tmp29 := lang.Apply(tmp28, []any{v9, v24}) + tmp30 := lang.Apply(v8, []any{tmp29, v25, v11, v12}) + tmp31 := lang.Apply(tmp27, []any{v9, v24, tmp30}) + tmp26 = tmp31 + } else { + tmp32 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp33 := checkDerefVar(var_glojure_DOT_core_apply) + tmp34 := checkDerefVar(var_glojure_DOT_core_get) + tmp35 := lang.Apply(tmp34, []any{v9, v24}) + tmp36 := lang.Apply(tmp33, []any{v11, tmp35, v12}) + tmp37 := lang.Apply(tmp32, []any{v9, v24, tmp36}) + tmp26 = tmp37 + } + tmp13 = tmp26 + } // end let + return tmp13 + }) + v8 = tmp7 + _ = v8 + } + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6167), kw_column, int(15), kw_end_DASH_line, int(6171), kw_end_DASH_column, int(59)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v10 any = tmp9 + _ = v10 + tmp11 := lang.Apply(v10, []any{v2, v3, v4, v5}) + tmp6 = tmp11 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_update_DASH_in = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_update_DASH_in.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // vary-meta + { + tmp0 := sym_vary_DASH_meta.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_obj, sym_f, sym__AMP_, sym_args)), kw_doc, "Returns an object of the same type and value as obj, with\n (apply f (meta obj) args) as its metadata.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(668), kw_end_DASH_line, int(668))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_meta) + tmp8 := lang.Apply(tmp7, []any{v2}) + tmp9 := lang.Apply(tmp6, []any{v3, tmp8, v4}) + tmp10 := lang.Apply(tmp5, []any{v2, tmp9}) + return tmp10 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_vary_DASH_meta = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_vary_DASH_meta.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // when-first + { + tmp0 := sym_when_DASH_first.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "bindings => x xs\n\n Roughly the same as (when (seq xs) (let [x (first xs)] body)) but xs is evaluated only once", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(11), kw_line, int(4622), kw_end_DASH_line, int(4622))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v4}) + if lang.IsTruthy(tmp8) { + } else { + tmp9 := checkDerefVar(var_glojure_DOT_core_str) + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp13 := checkDerefVar(var_glojure_DOT_core_meta) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(kw_line, []any{tmp14}) + tmp16 := lang.Apply(tmp9, []any{tmp11, " requires ", "a vector for its binding", " in ", tmp12, ":", tmp15}) + tmp17 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp16}) + panic(tmp17) + } + _ = tmp6 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp20 := checkDerefVar(var_glojure_DOT_core_count) + tmp21 := lang.Apply(tmp20, []any{v4}) + tmp22 := lang.Apply(tmp19, []any{int64(2), tmp21}) + if lang.IsTruthy(tmp22) { + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp27 := checkDerefVar(var_glojure_DOT_core_meta) + tmp28 := lang.Apply(tmp27, []any{v2}) + tmp29 := lang.Apply(kw_line, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp25, " requires ", "exactly 2 forms in binding vector", " in ", tmp26, ":", tmp29}) + tmp31 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp31) + } + _ = tmp18 + var tmp32 any + { // let + // let binding "vec__20" + var v33 any = v4 + _ = v33 + // let binding "x" + tmp34 := checkDerefVar(var_glojure_DOT_core_nth) + tmp35 := lang.Apply(tmp34, []any{v33, int64(0), nil}) + var v36 any = tmp35 + _ = v36 + // let binding "xs" + tmp37 := checkDerefVar(var_glojure_DOT_core_nth) + tmp38 := lang.Apply(tmp37, []any{v33, int64(1), nil}) + var v39 any = tmp38 + _ = v39 + tmp40 := checkDerefVar(var_glojure_DOT_core_seq) + tmp41 := checkDerefVar(var_glojure_DOT_core_concat) + tmp42 := checkDerefVar(var_glojure_DOT_core_list) + tmp43 := lang.Apply(tmp42, []any{sym_glojure_DOT_core_SLASH_when_DASH_let}) + tmp44 := checkDerefVar(var_glojure_DOT_core_list) + tmp45 := checkDerefVar(var_glojure_DOT_core_apply) + tmp46 := checkDerefVar(var_glojure_DOT_core_vector) + tmp47 := checkDerefVar(var_glojure_DOT_core_seq) + tmp48 := checkDerefVar(var_glojure_DOT_core_concat) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) + tmp50 := lang.Apply(tmp49, []any{sym_xs__0__auto__}) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := checkDerefVar(var_glojure_DOT_core_seq) + tmp53 := checkDerefVar(var_glojure_DOT_core_concat) + tmp54 := checkDerefVar(var_glojure_DOT_core_list) + tmp55 := lang.Apply(tmp54, []any{sym_glojure_DOT_core_SLASH_seq}) + tmp56 := checkDerefVar(var_glojure_DOT_core_list) + tmp57 := lang.Apply(tmp56, []any{v39}) + tmp58 := lang.Apply(tmp53, []any{tmp55, tmp57}) + tmp59 := lang.Apply(tmp52, []any{tmp58}) + tmp60 := lang.Apply(tmp51, []any{tmp59}) + tmp61 := lang.Apply(tmp48, []any{tmp50, tmp60}) + tmp62 := lang.Apply(tmp47, []any{tmp61}) + tmp63 := lang.Apply(tmp45, []any{tmp46, tmp62}) + tmp64 := lang.Apply(tmp44, []any{tmp63}) + tmp65 := checkDerefVar(var_glojure_DOT_core_list) + tmp66 := checkDerefVar(var_glojure_DOT_core_seq) + tmp67 := checkDerefVar(var_glojure_DOT_core_concat) + tmp68 := checkDerefVar(var_glojure_DOT_core_list) + tmp69 := lang.Apply(tmp68, []any{sym_glojure_DOT_core_SLASH_let}) + tmp70 := checkDerefVar(var_glojure_DOT_core_list) + tmp71 := checkDerefVar(var_glojure_DOT_core_apply) + tmp72 := checkDerefVar(var_glojure_DOT_core_vector) + tmp73 := checkDerefVar(var_glojure_DOT_core_seq) + tmp74 := checkDerefVar(var_glojure_DOT_core_concat) + tmp75 := checkDerefVar(var_glojure_DOT_core_list) + tmp76 := lang.Apply(tmp75, []any{v36}) + tmp77 := checkDerefVar(var_glojure_DOT_core_list) + tmp78 := checkDerefVar(var_glojure_DOT_core_seq) + tmp79 := checkDerefVar(var_glojure_DOT_core_concat) + tmp80 := checkDerefVar(var_glojure_DOT_core_list) + tmp81 := lang.Apply(tmp80, []any{sym_glojure_DOT_core_SLASH_first}) + tmp82 := checkDerefVar(var_glojure_DOT_core_list) + tmp83 := lang.Apply(tmp82, []any{sym_xs__0__auto__}) + tmp84 := lang.Apply(tmp79, []any{tmp81, tmp83}) + tmp85 := lang.Apply(tmp78, []any{tmp84}) + tmp86 := lang.Apply(tmp77, []any{tmp85}) + tmp87 := lang.Apply(tmp74, []any{tmp76, tmp86}) + tmp88 := lang.Apply(tmp73, []any{tmp87}) + tmp89 := lang.Apply(tmp71, []any{tmp72, tmp88}) + tmp90 := lang.Apply(tmp70, []any{tmp89}) + tmp91 := lang.Apply(tmp67, []any{tmp69, tmp90, v5}) + tmp92 := lang.Apply(tmp66, []any{tmp91}) + tmp93 := lang.Apply(tmp65, []any{tmp92}) + tmp94 := lang.Apply(tmp41, []any{tmp43, tmp64, tmp93}) + tmp95 := lang.Apply(tmp40, []any{tmp94}) + tmp32 = tmp95 + } // end let + return tmp32 } - tmp5 := lang.Apply(tmp4, []any{v3}) - return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_when_DASH_first = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_when_DASH_first.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // persistent! + // when-let { - tmp0 := sym_persistent_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a new, persistent version of the transient collection, in\n constant time. The transient collection cannot be used after this\n call, any such use will throw an exception.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(3350), kw_end_DASH_line, int(3350))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4, ok := lang.FieldOrMethod(v3, "Persistent") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "Persistent"))) - } - var tmp5 any - switch reflect.TypeOf(tmp4).Kind() { - case reflect.Func: - tmp5 = lang.Apply(tmp4, nil) + tmp0 := sym_when_DASH_let.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "bindings => binding-form test\n\n When test is true, evaluates body with binding-form bound to the value of test", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(11), kw_line, int(1859), kw_end_DASH_line, int(1859))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { default: - tmp5 = tmp4 + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v4}) + if lang.IsTruthy(tmp8) { + } else { + tmp9 := checkDerefVar(var_glojure_DOT_core_str) + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp13 := checkDerefVar(var_glojure_DOT_core_meta) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(kw_line, []any{tmp14}) + tmp16 := lang.Apply(tmp9, []any{tmp11, " requires ", "a vector for its binding", " in ", tmp12, ":", tmp15}) + tmp17 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp16}) + panic(tmp17) + } + _ = tmp6 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp20 := checkDerefVar(var_glojure_DOT_core_count) + tmp21 := lang.Apply(tmp20, []any{v4}) + tmp22 := lang.Apply(tmp19, []any{int64(2), tmp21}) + if lang.IsTruthy(tmp22) { + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp27 := checkDerefVar(var_glojure_DOT_core_meta) + tmp28 := lang.Apply(tmp27, []any{v2}) + tmp29 := lang.Apply(kw_line, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp25, " requires ", "exactly 2 forms in binding vector", " in ", tmp26, ":", tmp29}) + tmp31 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp31) + } + _ = tmp18 + var tmp32 any + { // let + // let binding "form" + tmp33 := lang.Apply(v4, []any{int64(0)}) + var v34 any = tmp33 + _ = v34 + // let binding "tst" + tmp35 := lang.Apply(v4, []any{int64(1)}) + var v36 any = tmp35 + _ = v36 + tmp37 := checkDerefVar(var_glojure_DOT_core_seq) + tmp38 := checkDerefVar(var_glojure_DOT_core_concat) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := lang.Apply(tmp39, []any{sym_glojure_DOT_core_SLASH_let}) + tmp41 := checkDerefVar(var_glojure_DOT_core_list) + tmp42 := checkDerefVar(var_glojure_DOT_core_apply) + tmp43 := checkDerefVar(var_glojure_DOT_core_vector) + tmp44 := checkDerefVar(var_glojure_DOT_core_seq) + tmp45 := checkDerefVar(var_glojure_DOT_core_concat) + tmp46 := checkDerefVar(var_glojure_DOT_core_list) + tmp47 := lang.Apply(tmp46, []any{sym_temp__0__auto__}) + tmp48 := checkDerefVar(var_glojure_DOT_core_list) + tmp49 := lang.Apply(tmp48, []any{v36}) + tmp50 := lang.Apply(tmp45, []any{tmp47, tmp49}) + tmp51 := lang.Apply(tmp44, []any{tmp50}) + tmp52 := lang.Apply(tmp42, []any{tmp43, tmp51}) + tmp53 := lang.Apply(tmp41, []any{tmp52}) + tmp54 := checkDerefVar(var_glojure_DOT_core_list) + tmp55 := checkDerefVar(var_glojure_DOT_core_seq) + tmp56 := checkDerefVar(var_glojure_DOT_core_concat) + tmp57 := checkDerefVar(var_glojure_DOT_core_list) + tmp58 := lang.Apply(tmp57, []any{sym_glojure_DOT_core_SLASH_when}) + tmp59 := checkDerefVar(var_glojure_DOT_core_list) + tmp60 := lang.Apply(tmp59, []any{sym_temp__0__auto__}) + tmp61 := checkDerefVar(var_glojure_DOT_core_list) + tmp62 := checkDerefVar(var_glojure_DOT_core_seq) + tmp63 := checkDerefVar(var_glojure_DOT_core_concat) + tmp64 := checkDerefVar(var_glojure_DOT_core_list) + tmp65 := lang.Apply(tmp64, []any{sym_glojure_DOT_core_SLASH_let}) + tmp66 := checkDerefVar(var_glojure_DOT_core_list) + tmp67 := checkDerefVar(var_glojure_DOT_core_apply) + tmp68 := checkDerefVar(var_glojure_DOT_core_vector) + tmp69 := checkDerefVar(var_glojure_DOT_core_seq) + tmp70 := checkDerefVar(var_glojure_DOT_core_concat) + tmp71 := checkDerefVar(var_glojure_DOT_core_list) + tmp72 := lang.Apply(tmp71, []any{v34}) + tmp73 := checkDerefVar(var_glojure_DOT_core_list) + tmp74 := lang.Apply(tmp73, []any{sym_temp__0__auto__}) + tmp75 := lang.Apply(tmp70, []any{tmp72, tmp74}) + tmp76 := lang.Apply(tmp69, []any{tmp75}) + tmp77 := lang.Apply(tmp67, []any{tmp68, tmp76}) + tmp78 := lang.Apply(tmp66, []any{tmp77}) + tmp79 := lang.Apply(tmp63, []any{tmp65, tmp78, v5}) + tmp80 := lang.Apply(tmp62, []any{tmp79}) + tmp81 := lang.Apply(tmp61, []any{tmp80}) + tmp82 := lang.Apply(tmp56, []any{tmp58, tmp60, tmp81}) + tmp83 := lang.Apply(tmp55, []any{tmp82}) + tmp84 := lang.Apply(tmp54, []any{tmp83}) + tmp85 := lang.Apply(tmp38, []any{tmp40, tmp53, tmp84}) + tmp86 := lang.Apply(tmp37, []any{tmp85}) + tmp32 = tmp86 + } // end let + return tmp32 } - return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_when_DASH_let = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_when_DASH_let.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // pmap + // when-some { - tmp0 := sym_pmap.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_coll), lang.NewVector(sym_f, sym_coll, sym__AMP_, sym_colls)), kw_doc, "Like map, except f is applied in parallel. Semi-lazy in that the\n parallel computation stays ahead of the consumption, but doesn't\n realize the entire result unless required. Only useful for\n computationally intensive functions where the time of f dominates\n the coordination overhead.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(7031), kw_end_DASH_line, int(7031))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_when_DASH_some.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "bindings => binding-form test\n\n When test is not nil, evaluates body with binding-form bound to the\n value of test", kw_file, "glojure/core.glj", kw_added, "1.6", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(11), kw_line, int(1894), kw_end_DASH_line, int(1894))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - { // let - // let binding "n" - tmp6 := checkDerefVar(var_glojure_DOT_core__PLUS_) - tmp7 := lang.Apply(runtime14.NumCPU, nil) - tmp8 := lang.Apply(tmp6, []any{int64(2), tmp7}) - var v9 any = tmp8 - _ = v9 - // let binding "rets" - tmp10 := checkDerefVar(var_glojure_DOT_core_map) - var tmp11 lang.FnFunc - tmp11 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v12 := args[0] - _ = v12 - tmp13 := checkDerefVar(var_glojure_DOT_core_future_DASH_call) - var tmp14 lang.FnFunc - tmp14 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - tmp15 := lang.Apply(v3, []any{v12}) - return tmp15 - }) - tmp15 := lang.Apply(tmp13, []any{tmp14}) - return tmp15 - }) - tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7041), kw_column, int(20), kw_end_DASH_line, int(7041), kw_end_DASH_column, int(34)) - tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp14 := lang.Apply(tmp10, []any{tmp13, v4}) - var v15 any = tmp14 - _ = v15 - // let binding "step" - var tmp16 lang.FnFunc - { // function step - var v17 lang.FnFunc - tmp16 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v18 := args[0] - _ = v18 - v19 := args[1] - _ = v19 - var tmp20 any - { // let - // let binding "vec__335" - var v21 any = v18 - _ = v21 - // let binding "seq__336" - tmp22 := checkDerefVar(var_glojure_DOT_core_seq) - tmp23 := lang.Apply(tmp22, []any{v21}) - var v24 any = tmp23 - _ = v24 - // let binding "first__337" - tmp25 := checkDerefVar(var_glojure_DOT_core_first) - tmp26 := lang.Apply(tmp25, []any{v24}) - var v27 any = tmp26 - _ = v27 - // let binding "seq__336" - tmp28 := checkDerefVar(var_glojure_DOT_core_next) - tmp29 := lang.Apply(tmp28, []any{v24}) - var v30 any = tmp29 - _ = v30 - // let binding "x" - var v31 any = v27 - _ = v31 - // let binding "xs" - var v32 any = v30 - _ = v32 - // let binding "vs" - var v33 any = v21 - _ = v33 - var tmp34 lang.FnFunc - tmp34 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - var tmp35 any - { // let - // let binding "temp__0__auto__" - tmp36 := checkDerefVar(var_glojure_DOT_core_seq) - tmp37 := lang.Apply(tmp36, []any{v19}) - var v38 any = tmp37 - _ = v38 - var tmp39 any - if lang.IsTruthy(v38) { - var tmp40 any - { // let - // let binding "s" - var v41 any = v38 - _ = v41 - tmp42 := checkDerefVar(var_glojure_DOT_core_cons) - tmp43 := checkDerefVar(var_glojure_DOT_core_deref) - tmp44 := lang.Apply(tmp43, []any{v31}) - tmp45 := checkDerefVar(var_glojure_DOT_core_rest) - tmp46 := lang.Apply(tmp45, []any{v41}) - tmp47 := lang.Apply(v17, []any{v32, tmp46}) - tmp48 := lang.Apply(tmp42, []any{tmp44, tmp47}) - tmp40 = tmp48 - } // end let - tmp39 = tmp40 - } else { - tmp41 := checkDerefVar(var_glojure_DOT_core_map) - tmp42 := checkDerefVar(var_glojure_DOT_core_deref) - tmp43 := lang.Apply(tmp41, []any{tmp42, v33}) - tmp39 = tmp43 - } - tmp35 = tmp39 - } // end let - return tmp35 - }) - tmp35 := lang.Apply(lang.NewLazySeq, []any{tmp34}) - tmp20 = tmp35 - } // end let - return tmp20 - }) - v17 = tmp16 - _ = v17 - } - tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7042), kw_column, int(15), kw_end_DASH_line, int(7046), kw_end_DASH_column, int(36)) - tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v19 any = tmp18 - _ = v19 - tmp20 := checkDerefVar(var_glojure_DOT_core_drop) - tmp21 := lang.Apply(tmp20, []any{v9, v15}) - tmp22 := lang.Apply(v19, []any{v15, tmp21}) - tmp5 = tmp22 - } // end let - return tmp5 default: - checkArity(args, 2) - v3 := args[0] + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[2:]...) + var v5 any = lang.NewList(args[3:]...) _ = v5 var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v4}) + if lang.IsTruthy(tmp8) { + } else { + tmp9 := checkDerefVar(var_glojure_DOT_core_str) + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp13 := checkDerefVar(var_glojure_DOT_core_meta) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(kw_line, []any{tmp14}) + tmp16 := lang.Apply(tmp9, []any{tmp11, " requires ", "a vector for its binding", " in ", tmp12, ":", tmp15}) + tmp17 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp16}) + panic(tmp17) + } + _ = tmp6 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp20 := checkDerefVar(var_glojure_DOT_core_count) + tmp21 := lang.Apply(tmp20, []any{v4}) + tmp22 := lang.Apply(tmp19, []any{int64(2), tmp21}) + if lang.IsTruthy(tmp22) { + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp27 := checkDerefVar(var_glojure_DOT_core_meta) + tmp28 := lang.Apply(tmp27, []any{v2}) + tmp29 := lang.Apply(kw_line, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp25, " requires ", "exactly 2 forms in binding vector", " in ", tmp26, ":", tmp29}) + tmp31 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp31) + } + _ = tmp18 + var tmp32 any { // let - // let binding "step" - var tmp7 lang.FnFunc - { // function step - var v8 lang.FnFunc - tmp7 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v9 := args[0] - _ = v9 - var tmp10 lang.FnFunc - tmp10 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - var tmp11 any - { // let - // let binding "ss" - tmp12 := checkDerefVar(var_glojure_DOT_core_map) - tmp13 := checkDerefVar(var_glojure_DOT_core_seq) - tmp14 := lang.Apply(tmp12, []any{tmp13, v9}) - var v15 any = tmp14 - _ = v15 - var tmp16 any - tmp17 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) - tmp18 := checkDerefVar(var_glojure_DOT_core_identity) - tmp19 := lang.Apply(tmp17, []any{tmp18, v15}) - if lang.IsTruthy(tmp19) { - tmp20 := checkDerefVar(var_glojure_DOT_core_cons) - tmp21 := checkDerefVar(var_glojure_DOT_core_map) - tmp22 := checkDerefVar(var_glojure_DOT_core_first) - tmp23 := lang.Apply(tmp21, []any{tmp22, v15}) - tmp24 := checkDerefVar(var_glojure_DOT_core_map) - tmp25 := checkDerefVar(var_glojure_DOT_core_rest) - tmp26 := lang.Apply(tmp24, []any{tmp25, v15}) - tmp27 := lang.Apply(v8, []any{tmp26}) - tmp28 := lang.Apply(tmp20, []any{tmp23, tmp27}) - tmp16 = tmp28 - } else { - } - tmp11 = tmp16 - } // end let - return tmp11 - }) - tmp11 := lang.Apply(lang.NewLazySeq, []any{tmp10}) - return tmp11 - }) - v8 = tmp7 - _ = v8 - } - tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7049), kw_column, int(15), kw_end_DASH_line, int(7053), kw_end_DASH_column, int(67)) - tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v10 any = tmp9 - _ = v10 - tmp11 := checkDerefVar(var_glojure_DOT_core_pmap) - var tmp12 lang.FnFunc - tmp12 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v13 := args[0] - _ = v13 - tmp14 := checkDerefVar(var_glojure_DOT_core_apply) - tmp15 := lang.Apply(tmp14, []any{v3, v13}) - return tmp15 - }) - tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7054), kw_column, int(12), kw_end_DASH_line, int(7054), kw_end_DASH_column, int(23)) - tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp15 := checkDerefVar(var_glojure_DOT_core_cons) - tmp16 := lang.Apply(tmp15, []any{v4, v5}) - tmp17 := lang.Apply(v10, []any{tmp16}) - tmp18 := lang.Apply(tmp11, []any{tmp14, tmp17}) - tmp6 = tmp18 + // let binding "form" + tmp33 := lang.Apply(v4, []any{int64(0)}) + var v34 any = tmp33 + _ = v34 + // let binding "tst" + tmp35 := lang.Apply(v4, []any{int64(1)}) + var v36 any = tmp35 + _ = v36 + tmp37 := checkDerefVar(var_glojure_DOT_core_seq) + tmp38 := checkDerefVar(var_glojure_DOT_core_concat) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := lang.Apply(tmp39, []any{sym_glojure_DOT_core_SLASH_let}) + tmp41 := checkDerefVar(var_glojure_DOT_core_list) + tmp42 := checkDerefVar(var_glojure_DOT_core_apply) + tmp43 := checkDerefVar(var_glojure_DOT_core_vector) + tmp44 := checkDerefVar(var_glojure_DOT_core_seq) + tmp45 := checkDerefVar(var_glojure_DOT_core_concat) + tmp46 := checkDerefVar(var_glojure_DOT_core_list) + tmp47 := lang.Apply(tmp46, []any{sym_temp__0__auto__}) + tmp48 := checkDerefVar(var_glojure_DOT_core_list) + tmp49 := lang.Apply(tmp48, []any{v36}) + tmp50 := lang.Apply(tmp45, []any{tmp47, tmp49}) + tmp51 := lang.Apply(tmp44, []any{tmp50}) + tmp52 := lang.Apply(tmp42, []any{tmp43, tmp51}) + tmp53 := lang.Apply(tmp41, []any{tmp52}) + tmp54 := checkDerefVar(var_glojure_DOT_core_list) + tmp55 := checkDerefVar(var_glojure_DOT_core_seq) + tmp56 := checkDerefVar(var_glojure_DOT_core_concat) + tmp57 := checkDerefVar(var_glojure_DOT_core_list) + tmp58 := lang.Apply(tmp57, []any{sym_if}) + tmp59 := checkDerefVar(var_glojure_DOT_core_list) + tmp60 := checkDerefVar(var_glojure_DOT_core_seq) + tmp61 := checkDerefVar(var_glojure_DOT_core_concat) + tmp62 := checkDerefVar(var_glojure_DOT_core_list) + tmp63 := lang.Apply(tmp62, []any{sym_glojure_DOT_core_SLASH_nil_QMARK_}) + tmp64 := checkDerefVar(var_glojure_DOT_core_list) + tmp65 := lang.Apply(tmp64, []any{sym_temp__0__auto__}) + tmp66 := lang.Apply(tmp61, []any{tmp63, tmp65}) + tmp67 := lang.Apply(tmp60, []any{tmp66}) + tmp68 := lang.Apply(tmp59, []any{tmp67}) + tmp69 := checkDerefVar(var_glojure_DOT_core_list) + tmp70 := lang.Apply(tmp69, []any{nil}) + tmp71 := checkDerefVar(var_glojure_DOT_core_list) + tmp72 := checkDerefVar(var_glojure_DOT_core_seq) + tmp73 := checkDerefVar(var_glojure_DOT_core_concat) + tmp74 := checkDerefVar(var_glojure_DOT_core_list) + tmp75 := lang.Apply(tmp74, []any{sym_glojure_DOT_core_SLASH_let}) + tmp76 := checkDerefVar(var_glojure_DOT_core_list) + tmp77 := checkDerefVar(var_glojure_DOT_core_apply) + tmp78 := checkDerefVar(var_glojure_DOT_core_vector) + tmp79 := checkDerefVar(var_glojure_DOT_core_seq) + tmp80 := checkDerefVar(var_glojure_DOT_core_concat) + tmp81 := checkDerefVar(var_glojure_DOT_core_list) + tmp82 := lang.Apply(tmp81, []any{v34}) + tmp83 := checkDerefVar(var_glojure_DOT_core_list) + tmp84 := lang.Apply(tmp83, []any{sym_temp__0__auto__}) + tmp85 := lang.Apply(tmp80, []any{tmp82, tmp84}) + tmp86 := lang.Apply(tmp79, []any{tmp85}) + tmp87 := lang.Apply(tmp77, []any{tmp78, tmp86}) + tmp88 := lang.Apply(tmp76, []any{tmp87}) + tmp89 := lang.Apply(tmp73, []any{tmp75, tmp88, v5}) + tmp90 := lang.Apply(tmp72, []any{tmp89}) + tmp91 := lang.Apply(tmp71, []any{tmp90}) + tmp92 := lang.Apply(tmp56, []any{tmp58, tmp68, tmp70, tmp91}) + tmp93 := lang.Apply(tmp55, []any{tmp92}) + tmp94 := lang.Apply(tmp54, []any{tmp93}) + tmp95 := lang.Apply(tmp38, []any{tmp40, tmp53, tmp94}) + tmp96 := lang.Apply(tmp37, []any{tmp95}) + tmp32 = tmp96 } // end let - return tmp6 + return tmp32 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_when_DASH_some = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_when_DASH_some.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // pop + // while { - tmp0 := sym_pop.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "For a list or queue, returns a new list/queue without the first\n item, for a vector, returns a new vector without the last item. If\n the collection is empty, throws an exception. Note - not the same\n as next/butlast.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(1462), kw_end_DASH_line, int(1462))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4, _ := lang.FieldOrMethod(runtime.RT, "Pop") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Pop is not a function"))) + tmp0 := sym_while.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_test, sym__AMP_, sym_body)), kw_doc, "Repeatedly executes body while test expression is true. Presumes\n some side-effect will cause test to become false/nil. Returns nil", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(11), kw_line, int(6327), kw_end_DASH_line, int(6327))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_loop}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + tmp12 := checkDerefVar(var_glojure_DOT_core_vector) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := lang.Apply(tmp14, nil) + tmp16 := lang.Apply(tmp13, []any{tmp15}) + tmp17 := lang.Apply(tmp11, []any{tmp12, tmp16}) + tmp18 := lang.Apply(tmp10, []any{tmp17}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{sym_glojure_DOT_core_SLASH_when}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v4}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := checkDerefVar(var_glojure_DOT_core_seq) + tmp28 := checkDerefVar(var_glojure_DOT_core_concat) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{sym_recur}) + tmp31 := lang.Apply(tmp28, []any{tmp30}) + tmp32 := lang.Apply(tmp27, []any{tmp31}) + tmp33 := lang.Apply(tmp26, []any{tmp32}) + tmp34 := lang.Apply(tmp21, []any{tmp23, tmp25, v5, tmp33}) + tmp35 := lang.Apply(tmp20, []any{tmp34}) + tmp36 := lang.Apply(tmp19, []any{tmp35}) + tmp37 := lang.Apply(tmp7, []any{tmp9, tmp18, tmp36}) + tmp38 := lang.Apply(tmp6, []any{tmp37}) + return tmp38 } - tmp5 := lang.Apply(tmp4, []any{v3}) - return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_while = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_while.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // pop! + // with-bindings { - tmp0 := sym_pop_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Removes the last item from a transient vector. If\n the collection is empty, throws an exception. Returns coll", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3393), kw_end_DASH_line, int(3393))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4, ok := lang.FieldOrMethod(v3, "pop") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "pop"))) - } - var tmp5 any - switch reflect.TypeOf(tmp4).Kind() { - case reflect.Func: - tmp5 = lang.Apply(tmp4, nil) + tmp0 := sym_with_DASH_bindings.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_binding_DASH_map, sym__AMP_, sym_body)), kw_doc, "Takes a map of Var/value pairs. Installs for the given Vars the associated\n values as thread-local bindings. Then executes body. Pops the installed\n bindings after body was evaluated. Returns the value of body.", kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(11), kw_line, int(1984), kw_end_DASH_line, int(1984))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { default: - tmp5 = tmp4 + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_with_DASH_bindings_STAR_}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{v4}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_fn}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_apply) + tmp19 := checkDerefVar(var_glojure_DOT_core_vector) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := lang.Apply(tmp21, nil) + tmp23 := lang.Apply(tmp20, []any{tmp22}) + tmp24 := lang.Apply(tmp18, []any{tmp19, tmp23}) + tmp25 := lang.Apply(tmp17, []any{tmp24}) + tmp26 := lang.Apply(tmp14, []any{tmp16, tmp25, v5}) + tmp27 := lang.Apply(tmp13, []any{tmp26}) + tmp28 := lang.Apply(tmp12, []any{tmp27}) + tmp29 := lang.Apply(tmp7, []any{tmp9, tmp11, tmp28}) + tmp30 := lang.Apply(tmp6, []any{tmp29}) + return tmp30 } - return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_with_DASH_bindings = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_with_DASH_bindings.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // pop-thread-bindings + // with-bindings* { - tmp0 := sym_pop_DASH_thread_DASH_bindings.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Pop one set of bindings pushed with push-binding before. It is an error to\n pop bindings without pushing before.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(25), kw_column, int(7), kw_line, int(1929), kw_end_DASH_line, int(1929))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - tmp3 := lang.Apply(lang.PopThreadBindings, nil) - return tmp3 + tmp0 := sym_with_DASH_bindings_STAR_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_binding_DASH_map, sym_f, sym__AMP_, sym_args)), kw_doc, "Takes a map of Var/value pairs. Installs for the given Vars the associated\n values as thread-local bindings. Then calls f with the supplied arguments.\n Pops the installed bindings after f returned. Returns whatever f returns.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(1971), kw_end_DASH_line, int(1971))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp6 := lang.Apply(tmp5, []any{v2}) + _ = tmp6 + var tmp7 any + func() { + defer func() { + tmp8 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp9 := lang.Apply(tmp8, nil) + _ = tmp9 + }() + tmp10 := checkDerefVar(var_glojure_DOT_core_apply) + tmp11 := lang.Apply(tmp10, []any{v3, v4}) + tmp7 = tmp11 + }() + return tmp7 + } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_with_DASH_bindings_STAR_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_with_DASH_bindings_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // pos-int? + // with-in-str { - tmp0 := sym_pos_DASH_int_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a positive fixed precision integer", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(1403), kw_end_DASH_line, int(1403))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "and__0__auto__" - tmp5 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) - tmp6 := lang.Apply(tmp5, []any{v3}) - var v7 any = tmp6 - _ = v7 - var tmp8 any - if lang.IsTruthy(v7) { - tmp9 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) - tmp10 := lang.Apply(tmp9, []any{v3}) - tmp8 = tmp10 - } else { - tmp8 = v7 - } - tmp4 = tmp8 - } // end let - return tmp4 + tmp0 := sym_with_DASH_in_DASH_str.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_s, sym__AMP_, sym_body)), kw_doc, "Evaluates body in a context in which *in* is bound to a fresh\n StringReader initialized with the string s.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(11), kw_line, int(4749), kw_end_DASH_line, int(4749))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_with_DASH_open}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + tmp12 := checkDerefVar(var_glojure_DOT_core_vector) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_s__0__auto__}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{sym_glojure_DOT_core_SLASH__DASH__GT_}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := checkDerefVar(var_glojure_DOT_core_seq) + tmp24 := checkDerefVar(var_glojure_DOT_core_concat) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := lang.Apply(tmp25, []any{sym_java_DOT_io_DOT_StringReader_DOT_}) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{v4}) + tmp29 := lang.Apply(tmp24, []any{tmp26, tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp29}) + tmp31 := lang.Apply(tmp22, []any{tmp30}) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := lang.Apply(tmp32, []any{sym_glojure_DOT_lang_DOT_LineNumberingPushbackReader_DOT_}) + tmp34 := lang.Apply(tmp19, []any{tmp21, tmp31, tmp33}) + tmp35 := lang.Apply(tmp18, []any{tmp34}) + tmp36 := lang.Apply(tmp17, []any{tmp35}) + tmp37 := lang.Apply(tmp14, []any{tmp16, tmp36}) + tmp38 := lang.Apply(tmp13, []any{tmp37}) + tmp39 := lang.Apply(tmp11, []any{tmp12, tmp38}) + tmp40 := lang.Apply(tmp10, []any{tmp39}) + tmp41 := checkDerefVar(var_glojure_DOT_core_list) + tmp42 := checkDerefVar(var_glojure_DOT_core_seq) + tmp43 := checkDerefVar(var_glojure_DOT_core_concat) + tmp44 := checkDerefVar(var_glojure_DOT_core_list) + tmp45 := lang.Apply(tmp44, []any{sym_glojure_DOT_core_SLASH_binding}) + tmp46 := checkDerefVar(var_glojure_DOT_core_list) + tmp47 := checkDerefVar(var_glojure_DOT_core_apply) + tmp48 := checkDerefVar(var_glojure_DOT_core_vector) + tmp49 := checkDerefVar(var_glojure_DOT_core_seq) + tmp50 := checkDerefVar(var_glojure_DOT_core_concat) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := lang.Apply(tmp51, []any{sym_glojure_DOT_core_SLASH__STAR_in_STAR_}) + tmp53 := checkDerefVar(var_glojure_DOT_core_list) + tmp54 := lang.Apply(tmp53, []any{sym_s__0__auto__}) + tmp55 := lang.Apply(tmp50, []any{tmp52, tmp54}) + tmp56 := lang.Apply(tmp49, []any{tmp55}) + tmp57 := lang.Apply(tmp47, []any{tmp48, tmp56}) + tmp58 := lang.Apply(tmp46, []any{tmp57}) + tmp59 := lang.Apply(tmp43, []any{tmp45, tmp58, v5}) + tmp60 := lang.Apply(tmp42, []any{tmp59}) + tmp61 := lang.Apply(tmp41, []any{tmp60}) + tmp62 := lang.Apply(tmp7, []any{tmp9, tmp40, tmp61}) + tmp63 := lang.Apply(tmp6, []any{tmp62}) + return tmp63 + } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_with_DASH_in_DASH_str = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_with_DASH_in_DASH_str.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // pos? + // with-loading-context { + tmp0 := sym_with_DASH_loading_DASH_context.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5734), kw_column, int(11), kw_end_DASH_line, int(5734), kw_end_DASH_column, int(30), kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_body)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_macro, true)).(*lang.Symbol) var tmp1 lang.FnFunc - { // function pos?__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_seq) - tmp5 := checkDerefVar(var_glojure_DOT_core_concat) - tmp6 := checkDerefVar(var_glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) - tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := checkDerefVar(var_glojure_DOT_core_seq) - tmp12 := checkDerefVar(var_glojure_DOT_core_concat) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_IsPos}) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{v3}) - tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) - tmp18 := lang.Apply(tmp11, []any{tmp17}) - tmp19 := lang.Apply(tmp10, []any{tmp18}) - tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) - tmp21 := lang.Apply(tmp4, []any{tmp20}) - return tmp21 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := sym_pos_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_num)), kw_inline, tmp1, kw_doc, "Returns true if num is greater than zero, else false", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1252), kw_end_DASH_line, int(1252))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "IsPos") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("IsPos is not a function"))) + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_fn}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_loading__0__auto__}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_apply) + tmp16 := checkDerefVar(var_glojure_DOT_core_vector) + tmp17 := checkDerefVar(var_glojure_DOT_core_seq) + tmp18 := checkDerefVar(var_glojure_DOT_core_concat) + tmp19 := lang.Apply(tmp18, nil) + tmp20 := lang.Apply(tmp17, []any{tmp19}) + tmp21 := lang.Apply(tmp15, []any{tmp16, tmp20}) + tmp22 := lang.Apply(tmp14, []any{tmp21}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_seq) + tmp25 := checkDerefVar(var_glojure_DOT_core_concat) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_PushThreadBindings}) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := checkDerefVar(var_glojure_DOT_core_apply) + tmp30 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp31 := checkDerefVar(var_glojure_DOT_core_seq) + tmp32 := checkDerefVar(var_glojure_DOT_core_concat) + tmp33 := lang.Apply(tmp32, nil) + tmp34 := lang.Apply(tmp31, []any{tmp33}) + tmp35 := lang.Apply(tmp29, []any{tmp30, tmp34}) + tmp36 := lang.Apply(tmp28, []any{tmp35}) + tmp37 := lang.Apply(tmp25, []any{tmp27, tmp36}) + tmp38 := lang.Apply(tmp24, []any{tmp37}) + tmp39 := lang.Apply(tmp23, []any{tmp38}) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := checkDerefVar(var_glojure_DOT_core_seq) + tmp42 := checkDerefVar(var_glojure_DOT_core_concat) + tmp43 := checkDerefVar(var_glojure_DOT_core_list) + tmp44 := lang.Apply(tmp43, []any{sym_try}) + tmp45 := checkDerefVar(var_glojure_DOT_core_list) + tmp46 := checkDerefVar(var_glojure_DOT_core_seq) + tmp47 := checkDerefVar(var_glojure_DOT_core_concat) + tmp48 := checkDerefVar(var_glojure_DOT_core_list) + tmp49 := lang.Apply(tmp48, []any{sym_finally}) + tmp50 := checkDerefVar(var_glojure_DOT_core_list) + tmp51 := checkDerefVar(var_glojure_DOT_core_seq) + tmp52 := checkDerefVar(var_glojure_DOT_core_concat) + tmp53 := checkDerefVar(var_glojure_DOT_core_list) + tmp54 := lang.Apply(tmp53, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_PopThreadBindings}) + tmp55 := lang.Apply(tmp52, []any{tmp54}) + tmp56 := lang.Apply(tmp51, []any{tmp55}) + tmp57 := lang.Apply(tmp50, []any{tmp56}) + tmp58 := lang.Apply(tmp47, []any{tmp49, tmp57}) + tmp59 := lang.Apply(tmp46, []any{tmp58}) + tmp60 := lang.Apply(tmp45, []any{tmp59}) + tmp61 := lang.Apply(tmp42, []any{tmp44, v4, tmp60}) + tmp62 := lang.Apply(tmp41, []any{tmp61}) + tmp63 := lang.Apply(tmp40, []any{tmp62}) + tmp64 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp22, tmp39, tmp63}) + tmp65 := lang.Apply(tmp8, []any{tmp64}) + tmp66 := lang.Apply(tmp7, []any{tmp65}) + tmp67 := lang.Apply(tmp6, []any{tmp66}) + tmp68 := lang.Apply(tmp5, []any{tmp67}) + return tmp68 } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_with_DASH_loading_DASH_context = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_with_DASH_loading_DASH_context.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // pr + // with-open { - tmp0 := sym_pr.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_x), lang.NewVector(sym_x, sym__AMP_, sym_more)), kw_doc, "Prints the object(s) to the output stream that is the current value\n of *out*. Prints the object(s), separated by spaces if there is\n more than one. By default, pr and prn print in a way that objects\n can be read by the reader", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(7), kw_line, int(3678), kw_end_DASH_line, int(3678), kw_dynamic, true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_with_DASH_open.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "bindings => [name init ...]\n\n Evaluates body in a try expression with names bound to the values\n of the inits, and a finally clause that calls (.close name) on each\n name in reverse order.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(11), kw_line, int(3832), kw_end_DASH_line, int(3832))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 0: - return nil - case 1: - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) - tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_out_STAR_) - tmp6 := lang.Apply(tmp4, []any{v3, tmp5}) - return tmp6 default: - checkArity(args, 1) - v3 := args[0] + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[1:]...) + v4 := args[2] _ = v4 - recur_loop_671: - tmp5 := checkDerefVar(var_glojure_DOT_core_pr) - tmp6 := lang.Apply(tmp5, []any{v3}) + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v4}) + if lang.IsTruthy(tmp8) { + } else { + tmp9 := checkDerefVar(var_glojure_DOT_core_str) + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp13 := checkDerefVar(var_glojure_DOT_core_meta) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(kw_line, []any{tmp14}) + tmp16 := lang.Apply(tmp9, []any{tmp11, " requires ", "a vector for its binding", " in ", tmp12, ":", tmp15}) + tmp17 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp16}) + panic(tmp17) + } _ = tmp6 - tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_out_STAR_) - tmp8 := lang.Apply(lang.AppendWriter, []any{tmp7, lang.NewChar(32)}) - _ = tmp8 - var tmp9 any - { // let - // let binding "temp__0__auto__" - tmp10 := checkDerefVar(var_glojure_DOT_core_next) - tmp11 := lang.Apply(tmp10, []any{v4}) - var v12 any = tmp11 - _ = v12 - var tmp13 any - if lang.IsTruthy(v12) { - var tmp14 any - { // let - // let binding "nmore" - var v15 any = v12 - _ = v15 - tmp17 := checkDerefVar(var_glojure_DOT_core_first) - tmp18 := lang.Apply(tmp17, []any{v4}) - var tmp16 any = tmp18 - var tmp19 any = v15 - v3 = tmp16 - v4 = tmp19 - goto recur_loop_671 - } // end let - tmp13 = tmp14 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_even_QMARK_) + tmp20 := checkDerefVar(var_glojure_DOT_core_count) + tmp21 := lang.Apply(tmp20, []any{v4}) + tmp22 := lang.Apply(tmp19, []any{tmp21}) + if lang.IsTruthy(tmp22) { + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp27 := checkDerefVar(var_glojure_DOT_core_meta) + tmp28 := lang.Apply(tmp27, []any{v2}) + tmp29 := lang.Apply(kw_line, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp25, " requires ", "an even number of forms in binding vector", " in ", tmp26, ":", tmp29}) + tmp31 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp31) + } + _ = tmp18 + var tmp32 any + tmp33 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp34 := checkDerefVar(var_glojure_DOT_core_count) + tmp35 := lang.Apply(tmp34, []any{v4}) + tmp36 := lang.Apply(tmp33, []any{tmp35, int64(0)}) + if lang.IsTruthy(tmp36) { + tmp37 := checkDerefVar(var_glojure_DOT_core_seq) + tmp38 := checkDerefVar(var_glojure_DOT_core_concat) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := lang.Apply(tmp39, []any{sym_do}) + tmp41 := lang.Apply(tmp38, []any{tmp40, v5}) + tmp42 := lang.Apply(tmp37, []any{tmp41}) + tmp32 = tmp42 + } else { + var tmp43 any + tmp44 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp45 := lang.Apply(v4, []any{int64(0)}) + tmp46 := lang.Apply(tmp44, []any{tmp45}) + if lang.IsTruthy(tmp46) { + tmp47 := checkDerefVar(var_glojure_DOT_core_seq) + tmp48 := checkDerefVar(var_glojure_DOT_core_concat) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) + tmp50 := lang.Apply(tmp49, []any{sym_glojure_DOT_core_SLASH_let}) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := checkDerefVar(var_glojure_DOT_core_subvec) + tmp53 := lang.Apply(tmp52, []any{v4, int64(0), int64(2)}) + tmp54 := lang.Apply(tmp51, []any{tmp53}) + tmp55 := checkDerefVar(var_glojure_DOT_core_list) + tmp56 := checkDerefVar(var_glojure_DOT_core_seq) + tmp57 := checkDerefVar(var_glojure_DOT_core_concat) + tmp58 := checkDerefVar(var_glojure_DOT_core_list) + tmp59 := lang.Apply(tmp58, []any{sym_try}) + tmp60 := checkDerefVar(var_glojure_DOT_core_list) + tmp61 := checkDerefVar(var_glojure_DOT_core_seq) + tmp62 := checkDerefVar(var_glojure_DOT_core_concat) + tmp63 := checkDerefVar(var_glojure_DOT_core_list) + tmp64 := lang.Apply(tmp63, []any{sym_glojure_DOT_core_SLASH_with_DASH_open}) + tmp65 := checkDerefVar(var_glojure_DOT_core_list) + tmp66 := checkDerefVar(var_glojure_DOT_core_subvec) + tmp67 := lang.Apply(tmp66, []any{v4, int64(2)}) + tmp68 := lang.Apply(tmp65, []any{tmp67}) + tmp69 := lang.Apply(tmp62, []any{tmp64, tmp68, v5}) + tmp70 := lang.Apply(tmp61, []any{tmp69}) + tmp71 := lang.Apply(tmp60, []any{tmp70}) + tmp72 := checkDerefVar(var_glojure_DOT_core_list) + tmp73 := checkDerefVar(var_glojure_DOT_core_seq) + tmp74 := checkDerefVar(var_glojure_DOT_core_concat) + tmp75 := checkDerefVar(var_glojure_DOT_core_list) + tmp76 := lang.Apply(tmp75, []any{sym_finally}) + tmp77 := checkDerefVar(var_glojure_DOT_core_list) + tmp78 := checkDerefVar(var_glojure_DOT_core_seq) + tmp79 := checkDerefVar(var_glojure_DOT_core_concat) + tmp80 := checkDerefVar(var_glojure_DOT_core_list) + tmp81 := lang.Apply(tmp80, []any{sym__DOT_}) + tmp82 := checkDerefVar(var_glojure_DOT_core_list) + tmp83 := lang.Apply(v4, []any{int64(0)}) + tmp84 := lang.Apply(tmp82, []any{tmp83}) + tmp85 := checkDerefVar(var_glojure_DOT_core_list) + tmp86 := lang.Apply(tmp85, []any{sym_close}) + tmp87 := lang.Apply(tmp79, []any{tmp81, tmp84, tmp86}) + tmp88 := lang.Apply(tmp78, []any{tmp87}) + tmp89 := lang.Apply(tmp77, []any{tmp88}) + tmp90 := lang.Apply(tmp74, []any{tmp76, tmp89}) + tmp91 := lang.Apply(tmp73, []any{tmp90}) + tmp92 := lang.Apply(tmp72, []any{tmp91}) + tmp93 := lang.Apply(tmp57, []any{tmp59, tmp71, tmp92}) + tmp94 := lang.Apply(tmp56, []any{tmp93}) + tmp95 := lang.Apply(tmp55, []any{tmp94}) + tmp96 := lang.Apply(tmp48, []any{tmp50, tmp54, tmp95}) + tmp97 := lang.Apply(tmp47, []any{tmp96}) + tmp43 = tmp97 } else { - tmp15 := checkDerefVar(var_glojure_DOT_core_apply) - tmp16 := checkDerefVar(var_glojure_DOT_core_pr) - tmp17 := lang.Apply(tmp15, []any{tmp16, v4}) - tmp13 = tmp17 + var tmp98 any + if lang.IsTruthy(kw_else) { + tmp99 := lang.Apply(lang.NewIllegalArgumentError, []any{"with-open only allows Symbols in bindings"}) + panic(tmp99) + } else { + } + tmp43 = tmp98 } - tmp9 = tmp13 - } // end let - return tmp9 + tmp32 = tmp43 + } + return tmp32 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_with_DASH_open = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_with_DASH_open.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // pr-on + // with-out-str { - tmp0 := sym_pr_DASH_on.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_w)), kw_static, true, kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3669), kw_end_DASH_line, int(3669), kw_private, true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_dup_STAR_) - if lang.IsTruthy(tmp6) { - tmp7 := checkDerefVar(var_glojure_DOT_core_print_DASH_dup) - tmp8 := lang.Apply(tmp7, []any{v3, v4}) - tmp5 = tmp8 - } else { - tmp9 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) - tmp10 := lang.Apply(tmp9, []any{v3, v4}) - tmp5 = tmp10 + tmp0 := sym_with_DASH_out_DASH_str.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_body)), kw_doc, "Evaluates exprs in a context in which *out* is bound to a fresh\n StringWriter. Returns the string created by any nested printing\n calls.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(22), kw_column, int(11), kw_line, int(4738), kw_end_DASH_line, int(4738))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym_glojure_DOT_core_SLASH_let}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := checkDerefVar(var_glojure_DOT_core_apply) + tmp11 := checkDerefVar(var_glojure_DOT_core_vector) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_s__0__auto__}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := checkDerefVar(var_glojure_DOT_core_seq) + tmp18 := checkDerefVar(var_glojure_DOT_core_concat) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{sym_new}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{sym_strings_DOT_Builder}) + tmp23 := lang.Apply(tmp18, []any{tmp20, tmp22}) + tmp24 := lang.Apply(tmp17, []any{tmp23}) + tmp25 := lang.Apply(tmp16, []any{tmp24}) + tmp26 := lang.Apply(tmp13, []any{tmp15, tmp25}) + tmp27 := lang.Apply(tmp12, []any{tmp26}) + tmp28 := lang.Apply(tmp10, []any{tmp11, tmp27}) + tmp29 := lang.Apply(tmp9, []any{tmp28}) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := checkDerefVar(var_glojure_DOT_core_seq) + tmp32 := checkDerefVar(var_glojure_DOT_core_concat) + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{sym_glojure_DOT_core_SLASH_binding}) + tmp35 := checkDerefVar(var_glojure_DOT_core_list) + tmp36 := checkDerefVar(var_glojure_DOT_core_apply) + tmp37 := checkDerefVar(var_glojure_DOT_core_vector) + tmp38 := checkDerefVar(var_glojure_DOT_core_seq) + tmp39 := checkDerefVar(var_glojure_DOT_core_concat) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{sym_glojure_DOT_core_SLASH__STAR_out_STAR_}) + tmp42 := checkDerefVar(var_glojure_DOT_core_list) + tmp43 := lang.Apply(tmp42, []any{sym_s__0__auto__}) + tmp44 := lang.Apply(tmp39, []any{tmp41, tmp43}) + tmp45 := lang.Apply(tmp38, []any{tmp44}) + tmp46 := lang.Apply(tmp36, []any{tmp37, tmp45}) + tmp47 := lang.Apply(tmp35, []any{tmp46}) + tmp48 := checkDerefVar(var_glojure_DOT_core_list) + tmp49 := checkDerefVar(var_glojure_DOT_core_seq) + tmp50 := checkDerefVar(var_glojure_DOT_core_concat) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := lang.Apply(tmp51, []any{sym_glojure_DOT_core_SLASH_str}) + tmp53 := checkDerefVar(var_glojure_DOT_core_list) + tmp54 := lang.Apply(tmp53, []any{sym_s__0__auto__}) + tmp55 := lang.Apply(tmp50, []any{tmp52, tmp54}) + tmp56 := lang.Apply(tmp49, []any{tmp55}) + tmp57 := lang.Apply(tmp48, []any{tmp56}) + tmp58 := lang.Apply(tmp32, []any{tmp34, tmp47, v4, tmp57}) + tmp59 := lang.Apply(tmp31, []any{tmp58}) + tmp60 := lang.Apply(tmp30, []any{tmp59}) + tmp61 := lang.Apply(tmp6, []any{tmp8, tmp29, tmp60}) + tmp62 := lang.Apply(tmp5, []any{tmp61}) + return tmp62 } - _ = tmp5 - return nil }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_with_DASH_out_DASH_str = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_with_DASH_out_DASH_str.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // pr-str + // with-precision { - tmp1 := reflect.TypeOf("") - tmp0 := sym_pr_DASH_str.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_xs)), kw_doc, "pr to a string, returning it", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(4758), kw_end_DASH_line, int(4758))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_with_DASH_precision.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_precision, sym__AMP_, sym_exprs)), kw_doc, "Sets the precision and rounding mode to be used for BigDecimal operations.\n\n Usage: (with-precision 10 (/ 1M 3))\n or: (with-precision 10 :rounding HALF_DOWN (/ 1M 3))\n\n The rounding mode is one of CEILING, FLOOR, HALF_UP, HALF_DOWN,\n HALF_EVEN, UP, DOWN and UNNECESSARY; it defaults to HALF_UP.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(24), kw_column, int(11), kw_line, int(5110), kw_end_DASH_line, int(5110))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) - var v4 any = lang.NewList(args[0:]...) + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] _ = v4 - var tmp5 any + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any { // let - // let binding "s__0__auto__" - var v6 any = "unimplemented: new with non-constant class type" - _ = v6 + // let binding "vec__65" var tmp7 any - { // let - tmp8 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) - tmp9 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) - tmp10 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) - tmp11 := lang.Apply(tmp9, []any{tmp10, v6}) - tmp12 := lang.Apply(tmp8, []any{tmp11}) - _ = tmp12 - var tmp13 any - func() { - defer func() { - tmp14 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) - tmp15 := lang.Apply(tmp14, nil) - _ = tmp15 - }() - tmp16 := checkDerefVar(var_glojure_DOT_core_apply) - tmp17 := checkDerefVar(var_glojure_DOT_core_pr) - tmp18 := lang.Apply(tmp16, []any{tmp17, v4}) - _ = tmp18 - tmp19 := checkDerefVar(var_glojure_DOT_core_str) - tmp20 := lang.Apply(tmp19, []any{v6}) - tmp13 = tmp20 - }() - tmp7 = tmp13 - } // end let - tmp5 = tmp7 + tmp8 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp9 := checkDerefVar(var_glojure_DOT_core_first) + tmp10 := lang.Apply(tmp9, []any{v5}) + tmp11 := lang.Apply(tmp8, []any{tmp10, kw_rounding}) + if lang.IsTruthy(tmp11) { + tmp12 := checkDerefVar(var_glojure_DOT_core_next) + tmp13 := checkDerefVar(var_glojure_DOT_core_next) + tmp14 := lang.Apply(tmp13, []any{v5}) + tmp15 := lang.Apply(tmp12, []any{tmp14}) + tmp16 := checkDerefVar(var_glojure_DOT_core_seq) + tmp17 := checkDerefVar(var_glojure_DOT_core_concat) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := checkDerefVar(var_glojure_DOT_core_seq) + tmp20 := checkDerefVar(var_glojure_DOT_core_concat) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{sym__DOT_}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := lang.Apply(tmp23, []any{sym_java_DOT_math_DOT_RoundingMode}) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := checkDerefVar(var_glojure_DOT_core_second) + tmp27 := lang.Apply(tmp26, []any{v5}) + tmp28 := lang.Apply(tmp25, []any{tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp22, tmp24, tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp18, []any{tmp30}) + tmp32 := lang.Apply(tmp17, []any{tmp31}) + tmp33 := lang.Apply(tmp16, []any{tmp32}) + tmp34 := lang.NewVector(tmp15, tmp33) + tmp35 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5121), kw_column, int(23), kw_end_DASH_line, int(5122), kw_end_DASH_column, int(69)) + tmp36, err := lang.WithMeta(tmp34, tmp35.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp7 = tmp36 + } else { + tmp37 := lang.NewVector(v5, nil) + tmp38 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5123), kw_column, int(23), kw_end_DASH_line, int(5123), kw_end_DASH_column, int(33)) + tmp39, err := lang.WithMeta(tmp37, tmp38.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp7 = tmp39 + } + var v40 any = tmp7 + _ = v40 + // let binding "body" + tmp41 := checkDerefVar(var_glojure_DOT_core_nth) + tmp42 := lang.Apply(tmp41, []any{v40, int64(0), nil}) + var v43 any = tmp42 + _ = v43 + // let binding "rm" + tmp44 := checkDerefVar(var_glojure_DOT_core_nth) + tmp45 := lang.Apply(tmp44, []any{v40, int64(1), nil}) + var v46 any = tmp45 + _ = v46 + tmp47 := checkDerefVar(var_glojure_DOT_core_seq) + tmp48 := checkDerefVar(var_glojure_DOT_core_concat) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) + tmp50 := lang.Apply(tmp49, []any{sym_glojure_DOT_core_SLASH_binding}) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := checkDerefVar(var_glojure_DOT_core_apply) + tmp53 := checkDerefVar(var_glojure_DOT_core_vector) + tmp54 := checkDerefVar(var_glojure_DOT_core_seq) + tmp55 := checkDerefVar(var_glojure_DOT_core_concat) + tmp56 := checkDerefVar(var_glojure_DOT_core_list) + tmp57 := lang.Apply(tmp56, []any{sym_glojure_DOT_core_SLASH__STAR_math_DASH_context_STAR_}) + tmp58 := checkDerefVar(var_glojure_DOT_core_list) + tmp59 := checkDerefVar(var_glojure_DOT_core_seq) + tmp60 := checkDerefVar(var_glojure_DOT_core_concat) + tmp61 := checkDerefVar(var_glojure_DOT_core_list) + tmp62 := lang.Apply(tmp61, []any{sym_java_DOT_math_DOT_MathContext_DOT_}) + tmp63 := checkDerefVar(var_glojure_DOT_core_list) + tmp64 := lang.Apply(tmp63, []any{v4}) + tmp65 := lang.Apply(tmp60, []any{tmp62, tmp64, v46}) + tmp66 := lang.Apply(tmp59, []any{tmp65}) + tmp67 := lang.Apply(tmp58, []any{tmp66}) + tmp68 := lang.Apply(tmp55, []any{tmp57, tmp67}) + tmp69 := lang.Apply(tmp54, []any{tmp68}) + tmp70 := lang.Apply(tmp52, []any{tmp53, tmp69}) + tmp71 := lang.Apply(tmp51, []any{tmp70}) + tmp72 := lang.Apply(tmp48, []any{tmp50, tmp71, v43}) + tmp73 := lang.Apply(tmp47, []any{tmp72}) + tmp6 = tmp73 } // end let - return tmp5 - } - }) - tmp4 := reflect.TypeOf("") - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // prefer-method - { - tmp0 := sym_prefer_DASH_method.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_multifn, sym_dispatch_DASH_val_DASH_x, sym_dispatch_DASH_val_DASH_y)), kw_doc, "Causes the multimethod to prefer matches of dispatch-val-x over dispatch-val-y \n when there is a conflict", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(1801), kw_end_DASH_line, int(1801))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 3) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6, _ := lang.FieldOrMethod(v3, "PreferMethod") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("PreferMethod is not a function"))) + return tmp6 } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_with_DASH_precision = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_with_DASH_precision.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // prefers + // with-redefs { - tmp0 := sym_prefers.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_multifn)), kw_doc, "Given a multimethod, returns a map of preferred value -> set of other values", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(1822), kw_end_DASH_line, int(1822))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4, ok := lang.FieldOrMethod(v3, "getPreferTable") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getPreferTable"))) - } - var tmp5 any - switch reflect.TypeOf(tmp4).Kind() { - case reflect.Func: - tmp5 = lang.Apply(tmp4, nil) + tmp0 := sym_with_DASH_redefs.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "binding => var-symbol temp-value-expr\n\n Temporarily redefines Vars while executing the body. The\n temp-value-exprs will be evaluated and each resulting value will\n replace in parallel the root value of its Var. After the body is\n executed, the root values of all the Vars will be set back to their\n old values. These temporary changes will be visible in all threads.\n Useful for mocking out functions during testing.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(11), kw_line, int(7544), kw_end_DASH_line, int(7544))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { default: - tmp5 = tmp4 - } - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // prep-hashes - { - tmp0 := sym_prep_DASH_hashes.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_expr_DASH_sym, sym_default, sym_tests, sym_thens)), kw_doc, "Takes a sequence of test constants and a corresponding sequence of then\n expressions. Returns a tuple of [shift mask case-map switch-type skip-check]\n where case-map is a map of int case values to [test then] tuples, switch-type\n is either :sparse or :compact, and skip-check is a set of case ints for which\n post-switch equivalence checking must not be done (occurs with hash\n collisions).", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(8), kw_line, int(6683), kw_end_DASH_line, int(6683), kw_private, true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 4) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - var tmp7 any - { // let - // let binding "hashcode" - var tmp8 lang.FnFunc - tmp8 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_with_DASH_redefs_DASH_fn}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_zipmap) + tmp12 := checkDerefVar(var_glojure_DOT_core_map) + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v9 := args[0] - _ = v9 - tmp10 := lang.Apply(lang.Hash, []any{v9}) - return tmp10 + v14 := args[0] + _ = v14 + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_var, v14}) + return tmp16 }) - tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6691), kw_column, int(18), kw_end_DASH_line, int(6691), kw_end_DASH_column, int(66)) - tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v11 any = tmp10 - _ = v11 - // let binding "hashes" - tmp12 := checkDerefVar(var_glojure_DOT_core_into1) - tmp13 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) - tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6692), kw_column, int(23), kw_end_DASH_line, int(6692), kw_end_DASH_column, int(25)) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7555), kw_column, int(34), kw_end_DASH_line, int(7555), kw_end_DASH_column, int(47)) tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp16 := checkDerefVar(var_glojure_DOT_core_map) - tmp17 := lang.Apply(tmp16, []any{v11, v5}) + tmp16 := checkDerefVar(var_glojure_DOT_core_take_DASH_nth) + tmp17 := lang.Apply(tmp16, []any{int64(2), v4}) tmp18 := lang.Apply(tmp12, []any{tmp15, tmp17}) - var v19 any = tmp18 - _ = v19 - var tmp20 any - tmp21 := checkDerefVar(var_glojure_DOT_core__EQ__EQ_) - tmp22 := checkDerefVar(var_glojure_DOT_core_count) - tmp23 := lang.Apply(tmp22, []any{v5}) - tmp24 := checkDerefVar(var_glojure_DOT_core_count) - tmp25 := lang.Apply(tmp24, []any{v19}) - tmp26 := lang.Apply(tmp21, []any{tmp23, tmp25}) - if lang.IsTruthy(tmp26) { - var tmp27 any - tmp28 := checkDerefVar(var_glojure_DOT_core_fits_DASH_table_QMARK_) - tmp29 := lang.Apply(tmp28, []any{v19}) - if lang.IsTruthy(tmp29) { - tmp30 := checkDerefVar(var_glojure_DOT_core_case_DASH_map) - tmp31 := checkDerefVar(var_glojure_DOT_core_identity) - tmp32 := lang.Apply(tmp30, []any{v11, tmp31, v5, v6}) - tmp33 := lang.NewVector(int64(0), int64(0), tmp32, kw_compact) - tmp34 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6696), kw_column, int(9), kw_end_DASH_line, int(6696), kw_end_DASH_column, int(63)) - tmp35, err := lang.WithMeta(tmp33, tmp34.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp27 = tmp35 - } else { - var tmp36 any - { // let - // let binding "vec__167" - var tmp37 any - { // let - // let binding "or__0__auto__" - tmp38 := checkDerefVar(var_glojure_DOT_core_maybe_DASH_min_DASH_hash) - tmp39 := lang.Apply(tmp38, []any{v19}) - var v40 any = tmp39 - _ = v40 - var tmp41 any - if lang.IsTruthy(v40) { - tmp41 = v40 - } else { - tmp42 := lang.NewVector(int64(0), int64(0)) - tmp43 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6697), kw_column, int(56), kw_end_DASH_line, int(6697), kw_end_DASH_column, int(60)) - tmp44, err := lang.WithMeta(tmp42, tmp43.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp41 = tmp44 - } - tmp37 = tmp41 - } // end let - var v38 any = tmp37 - _ = v38 - // let binding "shift" - tmp39 := checkDerefVar(var_glojure_DOT_core_nth) - tmp40 := lang.Apply(tmp39, []any{v38, int64(0), nil}) - var v41 any = tmp40 - _ = v41 - // let binding "mask" - tmp42 := checkDerefVar(var_glojure_DOT_core_nth) - tmp43 := lang.Apply(tmp42, []any{v38, int64(1), nil}) - var v44 any = tmp43 - _ = v44 - var tmp45 any - tmp46 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) - tmp47 := lang.Apply(tmp46, []any{v44}) - if lang.IsTruthy(tmp47) { - tmp48 := checkDerefVar(var_glojure_DOT_core_case_DASH_map) - tmp49 := checkDerefVar(var_glojure_DOT_core_identity) - tmp50 := lang.Apply(tmp48, []any{v11, tmp49, v5, v6}) - tmp51 := lang.NewVector(int64(0), int64(0), tmp50, kw_sparse) - tmp52 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6700), kw_column, int(13), kw_end_DASH_line, int(6700), kw_end_DASH_column, int(66)) - tmp53, err := lang.WithMeta(tmp51, tmp52.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp45 = tmp53 - } else { - tmp54 := checkDerefVar(var_glojure_DOT_core_case_DASH_map) - var tmp55 lang.FnFunc - tmp55 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v56 := args[0] - _ = v56 - tmp57 := checkDerefVar(var_glojure_DOT_core_shift_DASH_mask) - tmp58 := lang.Apply(v11, []any{v56}) - tmp59 := lang.Apply(tmp57, []any{v41, v44, tmp58}) - return tmp59 - }) - tmp56 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6702), kw_column, int(35), kw_end_DASH_line, int(6702), kw_end_DASH_column, int(71)) - tmp57, err := lang.WithMeta(tmp55, tmp56.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp58 := checkDerefVar(var_glojure_DOT_core_identity) - tmp59 := lang.Apply(tmp54, []any{tmp57, tmp58, v5, v6}) - tmp60 := lang.NewVector(v41, v44, tmp59, kw_compact) - tmp61 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6702), kw_column, int(13), kw_end_DASH_line, int(6702), kw_end_DASH_column, int(103)) - tmp62, err := lang.WithMeta(tmp60, tmp61.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp45 = tmp62 - } - tmp36 = tmp45 - } // end let - tmp27 = tmp36 - } - tmp20 = tmp27 - } else { - var tmp37 any - { // let - // let binding "vec__170" - tmp38 := checkDerefVar(var_glojure_DOT_core_merge_DASH_hash_DASH_collisions) - tmp39 := lang.Apply(tmp38, []any{v3, v4, v5, v6}) - var v40 any = tmp39 - _ = v40 - // let binding "tests" - tmp41 := checkDerefVar(var_glojure_DOT_core_nth) - tmp42 := lang.Apply(tmp41, []any{v40, int64(0), nil}) - var v43 any = tmp42 - _ = v43 - // let binding "thens" - tmp44 := checkDerefVar(var_glojure_DOT_core_nth) - tmp45 := lang.Apply(tmp44, []any{v40, int64(1), nil}) - var v46 any = tmp45 - _ = v46 - // let binding "skip-check" - tmp47 := checkDerefVar(var_glojure_DOT_core_nth) - tmp48 := lang.Apply(tmp47, []any{v40, int64(2), nil}) - var v49 any = tmp48 - _ = v49 - // let binding "vec__173" - tmp50 := checkDerefVar(var_glojure_DOT_core_prep_DASH_hashes) - tmp51 := lang.Apply(tmp50, []any{v3, v4, v43, v46}) - var v52 any = tmp51 - _ = v52 - // let binding "shift" - tmp53 := checkDerefVar(var_glojure_DOT_core_nth) - tmp54 := lang.Apply(tmp53, []any{v52, int64(0), nil}) - var v55 any = tmp54 - _ = v55 - // let binding "mask" - tmp56 := checkDerefVar(var_glojure_DOT_core_nth) - tmp57 := lang.Apply(tmp56, []any{v52, int64(1), nil}) - var v58 any = tmp57 - _ = v58 - // let binding "case-map" - tmp59 := checkDerefVar(var_glojure_DOT_core_nth) - tmp60 := lang.Apply(tmp59, []any{v52, int64(2), nil}) - var v61 any = tmp60 - _ = v61 - // let binding "switch-type" - tmp62 := checkDerefVar(var_glojure_DOT_core_nth) - tmp63 := lang.Apply(tmp62, []any{v52, int64(3), nil}) - var v64 any = tmp63 - _ = v64 - // let binding "skip-check" - var tmp65 any - tmp66 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) - tmp67 := lang.Apply(tmp66, []any{v58}) - if lang.IsTruthy(tmp67) { - tmp65 = v49 - } else { - tmp68 := checkDerefVar(var_glojure_DOT_core_into1) - tmp69 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) - tmp70 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6708), kw_column, int(33), kw_end_DASH_line, int(6708), kw_end_DASH_column, int(35)) - tmp71, err := lang.WithMeta(tmp69, tmp70.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp72 := checkDerefVar(var_glojure_DOT_core_map) - var tmp73 lang.FnFunc - tmp73 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v74 := args[0] - _ = v74 - tmp75 := checkDerefVar(var_glojure_DOT_core_shift_DASH_mask) - tmp76 := lang.Apply(tmp75, []any{v55, v58, v74}) - return tmp76 - }) - tmp74 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6708), kw_column, int(42), kw_end_DASH_line, int(6708), kw_end_DASH_column, int(67)) - tmp75, err := lang.WithMeta(tmp73, tmp74.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp76 := lang.Apply(tmp72, []any{tmp75, v49}) - tmp77 := lang.Apply(tmp68, []any{tmp71, tmp76}) - tmp65 = tmp77 - } - var v78 any = tmp65 - _ = v78 - tmp79 := lang.NewVector(v55, v58, v61, v64, v78) - tmp80 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6709), kw_column, int(9), kw_end_DASH_line, int(6709), kw_end_DASH_column, int(52)) - tmp81, err := lang.WithMeta(tmp79, tmp80.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp37 = tmp81 - } // end let - tmp20 = tmp37 - } - tmp7 = tmp20 - } // end let - return tmp7 + tmp19 := checkDerefVar(var_glojure_DOT_core_take_DASH_nth) + tmp20 := checkDerefVar(var_glojure_DOT_core_next) + tmp21 := lang.Apply(tmp20, []any{v4}) + tmp22 := lang.Apply(tmp19, []any{int64(2), tmp21}) + tmp23 := lang.Apply(tmp11, []any{tmp18, tmp22}) + tmp24 := lang.Apply(tmp10, []any{tmp23}) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := checkDerefVar(var_glojure_DOT_core_seq) + tmp27 := checkDerefVar(var_glojure_DOT_core_concat) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := lang.Apply(tmp28, []any{sym_glojure_DOT_core_SLASH_fn}) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := checkDerefVar(var_glojure_DOT_core_apply) + tmp32 := checkDerefVar(var_glojure_DOT_core_vector) + tmp33 := checkDerefVar(var_glojure_DOT_core_seq) + tmp34 := checkDerefVar(var_glojure_DOT_core_concat) + tmp35 := lang.Apply(tmp34, nil) + tmp36 := lang.Apply(tmp33, []any{tmp35}) + tmp37 := lang.Apply(tmp31, []any{tmp32, tmp36}) + tmp38 := lang.Apply(tmp30, []any{tmp37}) + tmp39 := lang.Apply(tmp27, []any{tmp29, tmp38, v5}) + tmp40 := lang.Apply(tmp26, []any{tmp39}) + tmp41 := lang.Apply(tmp25, []any{tmp40}) + tmp42 := lang.Apply(tmp7, []any{tmp9, tmp24, tmp41}) + tmp43 := lang.Apply(tmp6, []any{tmp42}) + return tmp43 + } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_with_DASH_redefs = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_with_DASH_redefs.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // prep-ints + // with-redefs-fn { - tmp0 := sym_prep_DASH_ints.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_tests, sym_thens)), kw_doc, "Takes a sequence of int-sized test constants and a corresponding sequence of\n then expressions. Returns a tuple of [shift mask case-map switch-type] where\n case-map is a map of int case values to [test then] tuples, and switch-type\n is either :sparse or :compact.", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(8), kw_line, int(6631), kw_end_DASH_line, int(6631), kw_private, true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_with_DASH_redefs_DASH_fn.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_binding_DASH_map, sym_func)), kw_doc, "Temporarily redefines Vars during a call to func. Each val of\n binding-map will replace the root value of its key which must be\n a Var. After func is called with no args, the root values of all\n the Vars will be set back to their old values. These temporary\n changes will be visible in all threads. Useful for mocking out\n functions during testing.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(7524), kw_end_DASH_line, int(7524))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 2) - v3 := args[0] + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - tmp6 := checkDerefVar(var_glojure_DOT_core_fits_DASH_table_QMARK_) - tmp7 := lang.Apply(tmp6, []any{v3}) - if lang.IsTruthy(tmp7) { - tmp8 := checkDerefVar(var_glojure_DOT_core_case_DASH_map) - tmp9 := checkDerefVar(var_glojure_DOT_core_int) - tmp10 := checkDerefVar(var_glojure_DOT_core_int) - tmp11 := lang.Apply(tmp8, []any{tmp9, tmp10, v3, v4}) - tmp12 := lang.NewVector(int64(0), int64(0), tmp11, kw_compact) - tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6639), kw_column, int(5), kw_end_DASH_line, int(6639), kw_end_DASH_column, int(49)) - tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp5 = tmp14 - } else { - var tmp15 any - { // let - // let binding "vec__160" - var tmp16 any + var tmp4 any + { // let + // let binding "root-bind" + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v6 := args[0] + _ = v6 + var tmp7 any { // let - // let binding "or__0__auto__" - tmp17 := checkDerefVar(var_glojure_DOT_core_maybe_DASH_min_DASH_hash) - tmp18 := checkDerefVar(var_glojure_DOT_core_map) - tmp19 := checkDerefVar(var_glojure_DOT_core_int) - tmp20 := lang.Apply(tmp18, []any{tmp19, v3}) - tmp21 := lang.Apply(tmp17, []any{tmp20}) - var v22 any = tmp21 - _ = v22 - var tmp23 any - if lang.IsTruthy(v22) { - tmp23 = v22 - } else { - tmp24 := lang.NewVector(int64(0), int64(0)) - tmp25 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6640), kw_column, int(61), kw_end_DASH_line, int(6640), kw_end_DASH_column, int(65)) - tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) - if err != nil { - panic(err) + // let binding "seq_338" + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := lang.Apply(tmp8, []any{v6}) + var v10 any = tmp9 + _ = v10 + // let binding "chunk_339" + var v11 any = nil + _ = v11 + // let binding "count_340" + var v12 any = int64(0) + _ = v12 + // let binding "i_341" + var v13 any = int64(0) + _ = v13 + for { + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp16 := lang.Apply(tmp15, []any{v13, v12}) + if lang.IsTruthy(tmp16) { + var tmp17 any + { // let + // let binding "vec__342" + tmp18, _ := lang.FieldOrMethod(v11, "nth") + if reflect.TypeOf(tmp18).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp19 := lang.Apply(tmp18, []any{v13}) + var v20 any = tmp19 + _ = v20 + // let binding "a-var" + tmp21 := checkDerefVar(var_glojure_DOT_core_nth) + tmp22 := lang.Apply(tmp21, []any{v20, int64(0), nil}) + var v23 any = tmp22 + _ = v23 + // let binding "a-val" + tmp24 := checkDerefVar(var_glojure_DOT_core_nth) + tmp25 := lang.Apply(tmp24, []any{v20, int64(1), nil}) + var v26 any = tmp25 + _ = v26 + tmp27, _ := lang.FieldOrMethod(v23, "bindRoot") + if reflect.TypeOf(tmp27).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("bindRoot is not a function"))) + } + tmp28 := lang.Apply(tmp27, []any{v26}) + _ = tmp28 + var tmp29 any = v10 + var tmp30 any = v11 + var tmp31 any = v12 + tmp33 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp34 := lang.Apply(tmp33, []any{v13}) + var tmp32 any = tmp34 + v10 = tmp29 + v11 = tmp30 + v12 = tmp31 + v13 = tmp32 + continue + } // end let + tmp14 = tmp17 + } else { + var tmp18 any + { // let + // let binding "temp__0__auto__" + tmp19 := checkDerefVar(var_glojure_DOT_core_seq) + tmp20 := lang.Apply(tmp19, []any{v10}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + if lang.IsTruthy(v21) { + var tmp23 any + { // let + // let binding "seq_338" + var v24 any = v21 + _ = v24 + var tmp25 any + tmp26 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp27 := lang.Apply(tmp26, []any{v24}) + if lang.IsTruthy(tmp27) { + var tmp28 any + { // let + // let binding "c__0__auto__" + tmp29 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp30 := lang.Apply(tmp29, []any{v24}) + var v31 any = tmp30 + _ = v31 + tmp33 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp34 := lang.Apply(tmp33, []any{v24}) + var tmp32 any = tmp34 + var tmp35 any = v31 + tmp37 := checkDerefVar(var_glojure_DOT_core_int) + tmp38 := checkDerefVar(var_glojure_DOT_core_count) + tmp39 := lang.Apply(tmp38, []any{v31}) + tmp40 := lang.Apply(tmp37, []any{tmp39}) + var tmp36 any = tmp40 + tmp42 := checkDerefVar(var_glojure_DOT_core_int) + tmp43 := lang.Apply(tmp42, []any{int64(0)}) + var tmp41 any = tmp43 + v10 = tmp32 + v11 = tmp35 + v12 = tmp36 + v13 = tmp41 + continue + } // end let + tmp25 = tmp28 + } else { + var tmp29 any + { // let + // let binding "vec__345" + tmp30 := checkDerefVar(var_glojure_DOT_core_first) + tmp31 := lang.Apply(tmp30, []any{v24}) + var v32 any = tmp31 + _ = v32 + // let binding "a-var" + tmp33 := checkDerefVar(var_glojure_DOT_core_nth) + tmp34 := lang.Apply(tmp33, []any{v32, int64(0), nil}) + var v35 any = tmp34 + _ = v35 + // let binding "a-val" + tmp36 := checkDerefVar(var_glojure_DOT_core_nth) + tmp37 := lang.Apply(tmp36, []any{v32, int64(1), nil}) + var v38 any = tmp37 + _ = v38 + tmp39, _ := lang.FieldOrMethod(v35, "bindRoot") + if reflect.TypeOf(tmp39).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("bindRoot is not a function"))) + } + tmp40 := lang.Apply(tmp39, []any{v38}) + _ = tmp40 + tmp42 := checkDerefVar(var_glojure_DOT_core_next) + tmp43 := lang.Apply(tmp42, []any{v24}) + var tmp41 any = tmp43 + var tmp44 any = nil + var tmp45 any = int64(0) + var tmp46 any = int64(0) + v10 = tmp41 + v11 = tmp44 + v12 = tmp45 + v13 = tmp46 + continue + } // end let + tmp25 = tmp29 + } + tmp23 = tmp25 + } // end let + tmp22 = tmp23 + } else { + } + tmp18 = tmp22 + } // end let + tmp14 = tmp18 } - tmp23 = tmp26 + tmp7 = tmp14 + break } - tmp16 = tmp23 } // end let - var v17 any = tmp16 - _ = v17 - // let binding "shift" - tmp18 := checkDerefVar(var_glojure_DOT_core_nth) - tmp19 := lang.Apply(tmp18, []any{v17, int64(0), nil}) - var v20 any = tmp19 - _ = v20 - // let binding "mask" - tmp21 := checkDerefVar(var_glojure_DOT_core_nth) - tmp22 := lang.Apply(tmp21, []any{v17, int64(1), nil}) - var v23 any = tmp22 - _ = v23 - var tmp24 any - tmp25 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) - tmp26 := lang.Apply(tmp25, []any{v23}) - if lang.IsTruthy(tmp26) { - tmp27 := checkDerefVar(var_glojure_DOT_core_case_DASH_map) - tmp28 := checkDerefVar(var_glojure_DOT_core_int) - tmp29 := checkDerefVar(var_glojure_DOT_core_int) - tmp30 := lang.Apply(tmp27, []any{tmp28, tmp29, v3, v4}) - tmp31 := lang.NewVector(int64(0), int64(0), tmp30, kw_sparse) - tmp32 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6643), kw_column, int(9), kw_end_DASH_line, int(6643), kw_end_DASH_column, int(52)) - tmp33, err := lang.WithMeta(tmp31, tmp32.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp24 = tmp33 - } else { - tmp34 := checkDerefVar(var_glojure_DOT_core_case_DASH_map) - var tmp35 lang.FnFunc - tmp35 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v36 := args[0] - _ = v36 - tmp37 := checkDerefVar(var_glojure_DOT_core_shift_DASH_mask) - tmp38 := checkDerefVar(var_glojure_DOT_core_int) - tmp39 := lang.Apply(tmp38, []any{v36}) - tmp40 := lang.Apply(tmp37, []any{v20, v23, tmp39}) - return tmp40 - }) - tmp36 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6645), kw_column, int(31), kw_end_DASH_line, int(6645), kw_end_DASH_column, int(62)) - tmp37, err := lang.WithMeta(tmp35, tmp36.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp38 := checkDerefVar(var_glojure_DOT_core_int) - tmp39 := lang.Apply(tmp34, []any{tmp37, tmp38, v3, v4}) - tmp40 := lang.NewVector(v20, v23, tmp39, kw_compact) - tmp41 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6645), kw_column, int(9), kw_end_DASH_line, int(6645), kw_end_DASH_column, int(89)) - tmp42, err := lang.WithMeta(tmp40, tmp41.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp24 = tmp42 + return tmp7 + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7533), kw_column, int(19), kw_end_DASH_line, int(7535), kw_end_DASH_column, int(93)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v8 any = tmp7 + _ = v8 + // let binding "old-vals" + tmp9 := checkDerefVar(var_glojure_DOT_core_zipmap) + tmp10 := checkDerefVar(var_glojure_DOT_core_keys) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := checkDerefVar(var_glojure_DOT_core_map) + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v14 := args[0] + _ = v14 + tmp15, ok := lang.FieldOrMethod(v14, "getRawRoot") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v14, "getRawRoot"))) } - tmp15 = tmp24 - } // end let - tmp5 = tmp15 - } - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // prependss - { - tmp0 := sym_prependss.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_coll)), kw_doc, "Prepends a symbol or a seq to coll", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(8), kw_line, int(5857), kw_end_DASH_line, int(5857), kw_private, true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - tmp6 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) - tmp7 := lang.Apply(tmp6, []any{v3}) - if lang.IsTruthy(tmp7) { - tmp8 := checkDerefVar(var_glojure_DOT_core_cons) - tmp9 := lang.Apply(tmp8, []any{v3, v4}) - tmp5 = tmp9 - } else { - tmp10 := checkDerefVar(var_glojure_DOT_core_concat) - tmp11 := lang.Apply(tmp10, []any{v3, v4}) - tmp5 = tmp11 - } - return tmp5 + var tmp16 any + switch reflect.TypeOf(tmp15).Kind() { + case reflect.Func: + tmp16 = lang.Apply(tmp15, nil) + default: + tmp16 = tmp15 + } + return tmp16 + }) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7537), kw_column, int(31), kw_end_DASH_line, int(7537), kw_end_DASH_column, int(92)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp16 := checkDerefVar(var_glojure_DOT_core_keys) + tmp17 := lang.Apply(tmp16, []any{v2}) + tmp18 := lang.Apply(tmp12, []any{tmp15, tmp17}) + tmp19 := lang.Apply(tmp9, []any{tmp11, tmp18}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + func() { + defer func() { + tmp22 := lang.Apply(v8, []any{v20}) + _ = tmp22 + }() + tmp23 := lang.Apply(v8, []any{v2}) + _ = tmp23 + tmp24 := lang.Apply(v3, nil) + tmp21 = tmp24 + }() + tmp4 = tmp21 + } // end let + return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_with_DASH_redefs_DASH_fn = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_with_DASH_redefs_DASH_fn.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // preserving-reduced + // - { - tmp0 := sym_preserving_DASH_reduced.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(7638), kw_column, int(7), kw_end_DASH_line, int(7638), kw_end_DASH_column, int(34), kw_arglists, lang.NewList(lang.NewVector(sym_rf)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - var tmp7 any + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any { // let - // let binding "ret" - tmp8 := lang.Apply(v3, []any{v5, v6}) - var v9 any = tmp8 - _ = v9 - var tmp10 any - tmp11 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) - tmp12 := lang.Apply(tmp11, []any{v9}) - if lang.IsTruthy(tmp12) { - tmp13 := checkDerefVar(var_glojure_DOT_core_reduced) - tmp14 := lang.Apply(tmp13, []any{v9}) - tmp10 = tmp14 + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed6 } else { - tmp10 = v9 + tmp4 = closed7 } - tmp7 = tmp10 + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 } // end let - return tmp7 - }) - tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7640), kw_column, int(3), kw_end_DASH_line, int(7643), kw_end_DASH_column, int(12)) - tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp6 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // print - { - tmp0 := sym_print.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_more)), kw_doc, "Prints the object(s) to the output stream that is the current value\n of *out*. print and println produce output for human consumption.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3725), kw_end_DASH_line, int(3725))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 0) - var v3 any = lang.NewList(args[0:]...) + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 var tmp4 any { // let - tmp5 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) - tmp6 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) - tmp7 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_print_DASH_readably_STAR_) - tmp8 := lang.Apply(tmp6, []any{tmp7, nil}) - tmp9 := lang.Apply(tmp5, []any{tmp8}) - _ = tmp9 - var tmp10 any - func() { - defer func() { - tmp11 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) - tmp12 := lang.Apply(tmp11, nil) - _ = tmp12 - }() - tmp13 := checkDerefVar(var_glojure_DOT_core_apply) - tmp14 := checkDerefVar(var_glojure_DOT_core_pr) - tmp15 := lang.Apply(tmp13, []any{tmp14, v3}) - tmp10 = tmp15 - }() - tmp4 = tmp10 + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed6 + } else { + tmp5 = closed7 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 } // end let return tmp4 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // print-ctor - { - tmp0 := sym_print_DASH_ctor.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(95), kw_column, int(7), kw_end_DASH_line, int(95), kw_end_DASH_column, int(16), kw_arglists, lang.NewList(lang.NewVector(sym_o, sym_print_DASH_args, sym_w)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 3) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6 := lang.Apply(lang.WriteWriter, []any{v5, "#=("}) - _ = tmp6 - tmp7 := checkDerefVar(var_glojure_DOT_core_class) - tmp8 := lang.Apply(tmp7, []any{v3}) - tmp9, ok := lang.FieldOrMethod(tmp8, "Name") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp8, "Name"))) - } - var tmp10 any - switch reflect.TypeOf(tmp9).Kind() { - case reflect.Func: - tmp10 = lang.Apply(tmp9, nil) - default: - tmp10 = tmp9 - } - tmp11 := lang.Apply(lang.WriteWriter, []any{v5, tmp10}) - _ = tmp11 - tmp12 := lang.Apply(lang.WriteWriter, []any{v5, ". "}) - _ = tmp12 - tmp13 := lang.Apply(v4, []any{v3, v5}) - _ = tmp13 - tmp14 := lang.Apply(lang.WriteWriter, []any{v5, ")"}) - return tmp14 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // print-dup - { - tmp0 := sym_print_DASH_dup.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3667), kw_column, int(11), kw_end_DASH_line, int(3667), kw_end_DASH_column, int(19), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6 := checkDerefVar(var_glojure_DOT_core_class) - tmp7 := lang.Apply(tmp6, []any{v4}) - return tmp7 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3667), kw_column, int(21), kw_end_DASH_line, int(3667), kw_end_DASH_column, int(45))).(lang.FnFunc) - tmp2 := lang.NewMultiFn("print-dup", tmp3, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - tmp7 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) - tmp8 := lang.Apply(tmp7, []any{v5, v6}) - return tmp8 - }) - tmp2.AddMethod(nil, tmp4) - tmp5 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() - var tmp6 lang.FnFunc - tmp6 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v7 := args[0] - _ = v7 - v8 := args[1] - _ = v8 - tmp9 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) - tmp10 := lang.Apply(tmp9, []any{v7, v8}) - return tmp10 - }) - tmp2.AddMethod(tmp5, tmp6) - tmp7 := reflect.TypeOf((*lang.IPersistentList)(nil)).Elem() - var tmp8 lang.FnFunc - tmp8 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v9 := args[0] - _ = v9 - v10 := args[1] - _ = v10 - tmp11 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) - tmp12 := lang.Apply(tmp11, []any{v9, v10}) - return tmp12 - }) - tmp2.AddMethod(tmp7, tmp8) - tmp9 := reflect.TypeOf((*lang.Symbol)(nil)) - var tmp10 lang.FnFunc - tmp10 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v11 := args[0] - _ = v11 - v12 := args[1] - _ = v12 - tmp13 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) - tmp14 := lang.Apply(tmp13, []any{v11, v12}) - return tmp14 - }) - tmp2.AddMethod(tmp9, tmp10) - tmp11 := reflect.TypeOf((*lang.IRecord)(nil)).Elem() - var tmp12 lang.FnFunc - tmp12 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v13 := args[0] - _ = v13 - v14 := args[1] - _ = v14 - tmp15 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) - tmp16 := lang.Apply(tmp15, []any{v13, v14}) - _ = tmp16 - tmp17 := lang.Apply(lang.WriteWriter, []any{v14, "#"}) - _ = tmp17 - tmp18 := checkDerefVar(var_glojure_DOT_core_class) - tmp19 := lang.Apply(tmp18, []any{v13}) - tmp20, ok := lang.FieldOrMethod(tmp19, "Name") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp19, "Name"))) - } - var tmp21 any - switch reflect.TypeOf(tmp20).Kind() { - case reflect.Func: - tmp21 = lang.Apply(tmp20, nil) - default: - tmp21 = tmp20 - } - tmp22 := lang.Apply(lang.WriteWriter, []any{v14, tmp21}) - _ = tmp22 - var tmp23 any - tmp24 := checkDerefVar(var_glojure_DOT_core__STAR_verbose_DASH_defrecords_STAR_) - if lang.IsTruthy(tmp24) { - tmp25 := checkDerefVar(var_glojure_DOT_core_print_DASH_map) - tmp26 := checkDerefVar(var_glojure_DOT_core_print_DASH_dup) - tmp27 := lang.Apply(tmp25, []any{v13, tmp26, v14}) - tmp23 = tmp27 - } else { - tmp28 := checkDerefVar(var_glojure_DOT_core_print_DASH_sequential) - tmp29 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) - tmp30 := checkDerefVar(var_glojure_DOT_core_vals) - tmp31 := lang.Apply(tmp30, []any{v13}) - tmp32 := lang.Apply(tmp28, []any{"[", tmp29, ", ", "]", tmp31, v14}) - tmp23 = tmp32 - } - return tmp23 - }) - tmp2.AddMethod(tmp11, tmp12) - tmp13 := reflect.TypeOf((*lang.Set)(nil)) - var tmp14 lang.FnFunc - tmp14 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v15 := args[0] - _ = v15 - v16 := args[1] - _ = v16 - tmp17 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) - tmp18 := lang.Apply(tmp17, []any{v15, v16}) - return tmp18 - }) - tmp2.AddMethod(tmp13, tmp14) - tmp15 := reflect.TypeOf((*lang.PersistentHashMap)(nil)) - var tmp16 lang.FnFunc - tmp16 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v17 := args[0] - _ = v17 - v18 := args[1] - _ = v18 - tmp19 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) - tmp20 := lang.Apply(tmp19, []any{v17, v18}) - return tmp20 - }) - tmp2.AddMethod(tmp15, tmp16) - tmp17 := reflect.TypeOf(int64(0)) - var tmp18 lang.FnFunc - tmp18 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v19 := args[0] - _ = v19 - v20 := args[1] - _ = v20 - tmp21 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) - tmp22 := lang.Apply(tmp21, []any{v19, v20}) - return tmp22 - }) - tmp2.AddMethod(tmp17, tmp18) - tmp19 := reflect.TypeOf((*lang.Vector)(nil)) - var tmp20 lang.FnFunc - tmp20 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v21 := args[0] - _ = v21 - v22 := args[1] - _ = v22 - tmp23 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) - tmp24 := lang.Apply(tmp23, []any{v21, v22}) - return tmp24 - }) - tmp2.AddMethod(tmp19, tmp20) - tmp21 := reflect.TypeOf(float64(0)) - var tmp22 lang.FnFunc - tmp22 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v23 := args[0] - _ = v23 - v24 := args[1] - _ = v24 - tmp25 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) - tmp26 := lang.Apply(tmp25, []any{v23, v24}) - return tmp26 - }) - tmp2.AddMethod(tmp21, tmp22) - tmp23 := reflect.TypeOf("") - var tmp24 lang.FnFunc - tmp24 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v25 := args[0] - _ = v25 - v26 := args[1] - _ = v26 - tmp27 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) - tmp28 := lang.Apply(tmp27, []any{v25, v26}) - return tmp28 - }) - tmp2.AddMethod(tmp23, tmp24) - tmp25 := reflect.TypeOf((*lang.IPersistentCollection)(nil)).Elem() - var tmp26 lang.FnFunc - tmp26 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v27 := args[0] - _ = v27 - v28 := args[1] - _ = v28 - tmp29 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) - tmp30 := lang.Apply(tmp29, []any{v27, v28}) - _ = tmp30 - tmp31 := lang.Apply(lang.WriteWriter, []any{v28, "#=("}) - _ = tmp31 - tmp32 := checkDerefVar(var_glojure_DOT_core_class) - tmp33 := lang.Apply(tmp32, []any{v27}) - tmp34, ok := lang.FieldOrMethod(tmp33, "Name") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp33, "Name"))) - } - var tmp35 any - switch reflect.TypeOf(tmp34).Kind() { - case reflect.Func: - tmp35 = lang.Apply(tmp34, nil) - default: - tmp35 = tmp34 - } - tmp36 := lang.Apply(lang.WriteWriter, []any{v28, tmp35}) - _ = tmp36 - tmp37 := lang.Apply(lang.WriteWriter, []any{v28, "/create "}) - _ = tmp37 - tmp38 := checkDerefVar(var_glojure_DOT_core_print_DASH_sequential) - tmp39 := checkDerefVar(var_glojure_DOT_core_print_DASH_dup) - tmp40 := lang.Apply(tmp38, []any{"[", tmp39, " ", "]", v27, v28}) - _ = tmp40 - tmp41 := lang.Apply(lang.WriteWriter, []any{v28, ")"}) - return tmp41 - }) - tmp2.AddMethod(tmp25, tmp26) - tmp27 := reflect.TypeOf(int32(0)) - var tmp28 lang.FnFunc - tmp28 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v29 := args[0] - _ = v29 - v30 := args[1] - _ = v30 - tmp31 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) - tmp32 := lang.Apply(tmp31, []any{v29, v30}) - return tmp32 - }) - tmp2.AddMethod(tmp27, tmp28) - tmp29 := reflect.TypeOf((*lang.IPersistentMap)(nil)).Elem() - var tmp30 lang.FnFunc - tmp30 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v31 := args[0] - _ = v31 - v32 := args[1] - _ = v32 - tmp33 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) - tmp34 := lang.Apply(tmp33, []any{v31, v32}) - _ = tmp34 - tmp35 := lang.Apply(lang.WriteWriter, []any{v32, "#=("}) - _ = tmp35 - tmp36 := checkDerefVar(var_glojure_DOT_core_class) - tmp37 := lang.Apply(tmp36, []any{v31}) - tmp38, ok := lang.FieldOrMethod(tmp37, "Name") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp37, "Name"))) - } - var tmp39 any - switch reflect.TypeOf(tmp38).Kind() { - case reflect.Func: - tmp39 = lang.Apply(tmp38, nil) - default: - tmp39 = tmp38 - } - tmp40 := lang.Apply(lang.WriteWriter, []any{v32, tmp39}) - _ = tmp40 - tmp41 := lang.Apply(lang.WriteWriter, []any{v32, "/create "}) - _ = tmp41 - tmp42 := checkDerefVar(var_glojure_DOT_core_print_DASH_map) - tmp43 := checkDerefVar(var_glojure_DOT_core_print_DASH_dup) - tmp44 := lang.Apply(tmp42, []any{v31, tmp43, v32}) - _ = tmp44 - tmp45 := lang.Apply(lang.WriteWriter, []any{v32, ")"}) - return tmp45 - }) - tmp2.AddMethod(tmp29, tmp30) - tmp31 := reflect.TypeOf((*lang.Namespace)(nil)) - var tmp32 lang.FnFunc - tmp32 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v33 := args[0] - _ = v33 - v34 := args[1] - _ = v34 - tmp35 := lang.Apply(lang.WriteWriter, []any{v34, "#=(find-ns "}) - _ = tmp35 - tmp36 := checkDerefVar(var_glojure_DOT_core_print_DASH_dup) - tmp37, ok := lang.FieldOrMethod(v33, "name") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v33, "name"))) - } - var tmp38 any - switch reflect.TypeOf(tmp37).Kind() { - case reflect.Func: - tmp38 = lang.Apply(tmp37, nil) - default: - tmp38 = tmp37 - } - tmp39 := lang.Apply(tmp36, []any{tmp38, v34}) - _ = tmp39 - tmp40 := lang.Apply(lang.WriteWriter, []any{v34, ")"}) - return tmp40 - }) - tmp2.AddMethod(tmp31, tmp32) - tmp33 := reflect.TypeOf(false) - var tmp34 lang.FnFunc - tmp34 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v35 := args[0] - _ = v35 - v36 := args[1] - _ = v36 - tmp37 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) - tmp38 := lang.Apply(tmp37, []any{v35, v36}) - return tmp38 - }) - tmp2.AddMethod(tmp33, tmp34) - tmp35 := reflect.TypeOf((*regexp15.Regexp)(nil)) - var tmp36 lang.FnFunc - tmp36 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v37 := args[0] - _ = v37 - v38 := args[1] - _ = v38 - tmp39 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) - tmp40 := lang.Apply(tmp39, []any{v37, v38}) - return tmp40 - }) - tmp2.AddMethod(tmp35, tmp36) - tmp37 := reflect.TypeOf((*lang.Ratio)(nil)) - var tmp38 lang.FnFunc - tmp38 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v39 := args[0] - _ = v39 - v40 := args[1] - _ = v40 - tmp41 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) - tmp42 := lang.Apply(tmp41, []any{v39, v40}) - return tmp42 - }) - tmp2.AddMethod(tmp37, tmp38) - tmp39 := reflect.TypeOf((*lang.Var)(nil)) - var tmp40 lang.FnFunc - tmp40 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v41 := args[0] - _ = v41 - v42 := args[1] - _ = v42 - tmp43 := checkDerefVar(var_glojure_DOT_core_str) - tmp44, ok := lang.FieldOrMethod(v41, "Namespace") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v41, "Namespace"))) - } - var tmp45 any - switch reflect.TypeOf(tmp44).Kind() { - case reflect.Func: - tmp45 = lang.Apply(tmp44, nil) - default: - tmp45 = tmp44 - } - tmp46, ok := lang.FieldOrMethod(tmp45, "name") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp45, "name"))) - } - var tmp47 any - switch reflect.TypeOf(tmp46).Kind() { - case reflect.Func: - tmp47 = lang.Apply(tmp46, nil) default: - tmp47 = tmp46 - } - tmp48, ok := lang.FieldOrMethod(v41, "sym") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v41, "sym"))) - } - var tmp49 any - switch reflect.TypeOf(tmp48).Kind() { - case reflect.Func: - tmp49 = lang.Apply(tmp48, nil) - default: - tmp49 = tmp48 - } - tmp50 := lang.Apply(tmp43, []any{"#=(var ", tmp47, "/", tmp49, ")"}) - tmp51 := lang.Apply(lang.WriteWriter, []any{v42, tmp50}) - return tmp51 - }) - tmp2.AddMethod(tmp39, tmp40) - tmp41 := reflect.TypeOf((*lang.BigDecimal)(nil)) - var tmp42 lang.FnFunc - tmp42 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v43 := args[0] - _ = v43 - v44 := args[1] - _ = v44 - tmp45 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) - tmp46 := lang.Apply(tmp45, []any{v43, v44}) - return tmp46 - }) - tmp2.AddMethod(tmp41, tmp42) - tmp43 := reflect.TypeOf((*lang.BigInt)(nil)) - var tmp44 lang.FnFunc - tmp44 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v45 := args[0] - _ = v45 - v46 := args[1] - _ = v46 - tmp47 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) - tmp48 := lang.Apply(tmp47, []any{v45, v46}) - return tmp48 - }) - tmp2.AddMethod(tmp43, tmp44) - tmp45 := reflect.TypeOf((*runtime.Fn)(nil)) - var tmp46 lang.FnFunc - tmp46 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v47 := args[0] - _ = v47 - v48 := args[1] - _ = v48 - tmp49 := checkDerefVar(var_glojure_DOT_core_print_DASH_ctor) - var tmp50 lang.FnFunc - tmp50 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 2) - v51 := args[0] - _ = v51 - v52 := args[1] - _ = v52 - return nil - }) - tmp51 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(167), kw_column, int(17), kw_end_DASH_line, int(167), kw_end_DASH_column, int(26)) - tmp52, err := lang.WithMeta(tmp50, tmp51.(lang.IPersistentMap)) - if err != nil { - panic(err) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed6 + } else { + tmp6 = closed7 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 } - tmp53 := lang.Apply(tmp49, []any{v47, tmp52, v48}) - return tmp53 - }) - tmp2.AddMethod(tmp45, tmp46) - tmp47 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() - var tmp48 lang.FnFunc - tmp48 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v49 := args[0] - _ = v49 - v50 := args[1] - _ = v50 - tmp51 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) - tmp52 := lang.Apply(tmp51, []any{v49, v50}) - return tmp52 }) - tmp2.AddMethod(tmp47, tmp48) - tmp49 := reflect.TypeOf((*lang.IPersistentCollection)(nil)).Elem() - tmp50 := reflect.TypeOf((*runtime.Fn)(nil)) - tmp2.PreferMethod(tmp49, tmp50) - tmp51 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() - tmp52 := reflect.TypeOf((*lang.IPersistentCollection)(nil)).Elem() - tmp2.PreferMethod(tmp51, tmp52) - tmp53 := reflect.TypeOf((*lang.IRecord)(nil)).Elem() - tmp54 := reflect.TypeOf((*lang.IPersistentMap)(nil)).Elem() - tmp2.PreferMethod(tmp53, tmp54) - tmp55 := reflect.TypeOf((*lang.IRecord)(nil)).Elem() - tmp56 := reflect.TypeOf((*lang.IPersistentCollection)(nil)).Elem() - tmp2.PreferMethod(tmp55, tmp56) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // print-initialized - { - tmp0 := sym_print_DASH_initialized.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core_print.glj", kw_line, int(520), kw_column, int(6), kw_end_DASH_line, int(520), kw_end_DASH_column, int(39), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, true, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // print-map - { - tmp0 := sym_print_DASH_map.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(252), kw_column, int(8), kw_end_DASH_line, int(252), kw_end_DASH_column, int(16), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_m, sym_print_DASH_one, sym_w)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 3) + checkArity(args, 1) v3 := args[0] _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6 := checkDerefVar(var_glojure_DOT_core_print_DASH_prefix_DASH_map) - tmp7 := lang.Apply(tmp6, []any{nil, v3, v4, v5}) - return tmp7 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(0)}) + return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp0 := sym__DASH_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "If no ys are supplied, returns the negation of x, else subtracts\n the ys from x and returns the result. Does not auto-promote\n longs, will throw on overflow. See also: -'", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(7), kw_line, int(1036), kw_end_DASH_line, int(1036))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_) + tmp6 := lang.Apply(tmp5, []any{int64(-1), v4}) + return tmp6 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Minus") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Minus is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp8 := checkDerefVar(var_glojure_DOT_core__DASH_) + tmp9 := checkDerefVar(var_glojure_DOT_core__DASH_) + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) + return tmp11 + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__DASH_ = ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core__DASH_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // print-meta + // -' { - tmp0 := sym_print_DASH_meta.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(70), kw_column, int(8), kw_end_DASH_line, int(70), kw_end_DASH_column, int(17), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_o, sym_w)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed8 + } else { + tmp4 = closed8 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed8 + } else { + tmp5 = closed8 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed8 + } else { + tmp6 = closed8 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) + checkArity(args, 1) v3 := args[0] _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - { // let - // let binding "temp__0__auto__" - tmp6 := checkDerefVar(var_glojure_DOT_core_meta) - tmp7 := lang.Apply(tmp6, []any{v3}) - var v8 any = tmp7 - _ = v8 - var tmp9 any - if lang.IsTruthy(v8) { - var tmp10 any - { // let - // let binding "m" - var v11 any = v8 - _ = v11 - var tmp12 any - var tmp13 any - { // let - // let binding "and__0__auto__" - tmp14 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) - tmp15 := checkDerefVar(var_glojure_DOT_core_count) - tmp16 := lang.Apply(tmp15, []any{v11}) - tmp17 := lang.Apply(tmp14, []any{tmp16}) - var v18 any = tmp17 - _ = v18 - var tmp19 any - if lang.IsTruthy(v18) { - var tmp20 any - { // let - // let binding "or__0__auto__" - tmp21 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_dup_STAR_) - var v22 any = tmp21 - _ = v22 - var tmp23 any - if lang.IsTruthy(v22) { - tmp23 = v22 - } else { - var tmp24 any - { // let - // let binding "and__0__auto__" - tmp25 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_meta_STAR_) - var v26 any = tmp25 - _ = v26 - var tmp27 any - if lang.IsTruthy(v26) { - tmp28 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_readably_STAR_) - tmp27 = tmp28 - } else { - tmp27 = v26 - } - tmp24 = tmp27 - } // end let - tmp23 = tmp24 - } - tmp20 = tmp23 - } // end let - tmp19 = tmp20 - } else { - tmp19 = v18 - } - tmp13 = tmp19 - } // end let - if lang.IsTruthy(tmp13) { - tmp14 := lang.Apply(lang.WriteWriter, []any{v4, "^"}) - _ = tmp14 - var tmp15 any - var tmp16 any - { // let - // let binding "and__0__auto__" - tmp17 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp18 := checkDerefVar(var_glojure_DOT_core_count) - tmp19 := lang.Apply(tmp18, []any{v11}) - tmp20 := lang.Apply(tmp17, []any{tmp19, int64(1)}) - var v21 any = tmp20 - _ = v21 - var tmp22 any - if lang.IsTruthy(v21) { - tmp23 := lang.Apply(kw_tag, []any{v11}) - tmp22 = tmp23 - } else { - tmp22 = v21 - } - tmp16 = tmp22 - } // end let - if lang.IsTruthy(tmp16) { - tmp17 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) - tmp18 := lang.Apply(kw_tag, []any{v11}) - tmp19 := lang.Apply(tmp17, []any{tmp18, v4}) - tmp15 = tmp19 - } else { - tmp20 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) - tmp21 := lang.Apply(tmp20, []any{v11, v4}) - tmp15 = tmp21 - } - _ = tmp15 - tmp22 := lang.Apply(lang.WriteWriter, []any{v4, " "}) - tmp12 = tmp22 - } else { - } - tmp10 = tmp12 - } // end let - tmp9 = tmp10 - } else { - } - tmp5 = tmp9 - } // end let + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(0)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // print-method - { - tmp0 := sym_print_DASH_method.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3664), kw_column, int(11), kw_end_DASH_line, int(3664), kw_end_DASH_column, int(22), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + tmp0 := sym__DASH__TICK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "If no ys are supplied, returns the negation of x, else subtracts\n the ys from x and returns the result. Supports arbitrary precision.\n See also: -", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(7), kw_line, int(1024), kw_end_DASH_line, int(1024))).(*lang.Symbol) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - var tmp6 any - { // let - // let binding "t" - tmp7 := checkDerefVar(var_glojure_DOT_core_get) - tmp8 := checkDerefVar(var_glojure_DOT_core_meta) - tmp9 := lang.Apply(tmp8, []any{v4}) - tmp10 := lang.Apply(tmp7, []any{tmp9, kw_type}) - var v11 any = tmp10 - _ = v11 - var tmp12 any - tmp13 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) - tmp14 := lang.Apply(tmp13, []any{v11}) - if lang.IsTruthy(tmp14) { - tmp12 = v11 - } else { - tmp15 := checkDerefVar(var_glojure_DOT_core_class) - tmp16 := lang.Apply(tmp15, []any{v4}) - tmp12 = tmp16 - } - tmp6 = tmp12 - } // end let - return tmp6 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3664), kw_column, int(24), kw_end_DASH_line, int(3666), kw_end_DASH_column, int(58))).(lang.FnFunc) - tmp2 := lang.NewMultiFn("print-method", tmp3, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v5 := args[0] - _ = v5 - v6 := args[1] - _ = v6 - tmp7 := lang.Apply(lang.WriteWriter, []any{v6, "nil"}) - return tmp7 - }) - tmp2.AddMethod(nil, tmp4) - tmp5 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() - var tmp6 lang.FnFunc - tmp6 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v7 := args[0] - _ = v7 - v8 := args[1] - _ = v8 - tmp9 := checkDerefVar(var_glojure_DOT_core_str) - tmp10 := lang.Apply(tmp9, []any{v7}) - tmp11 := lang.Apply(lang.WriteWriter, []any{v8, tmp10}) - return tmp11 - }) - tmp2.AddMethod(tmp5, tmp6) - tmp7 := reflect.TypeOf(uint32(0)) - var tmp8 lang.FnFunc - tmp8 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v9 := args[0] - _ = v9 - v10 := args[1] - _ = v10 - tmp11 := checkDerefVar(var_glojure_DOT_core_str) - tmp12 := lang.Apply(tmp11, []any{v9}) - tmp13, _ := lang.FieldOrMethod(v10, "write") - if reflect.TypeOf(tmp13).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) - } - tmp14 := lang.Apply(tmp13, []any{tmp12}) - return tmp14 - }) - tmp2.AddMethod(tmp7, tmp8) - tmp9 := reflect.TypeOf((*lang.Symbol)(nil)) - var tmp10 lang.FnFunc - tmp10 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v11 := args[0] - _ = v11 - v12 := args[1] - _ = v12 - tmp13 := checkDerefVar(var_glojure_DOT_core_print_DASH_simple) - tmp14 := lang.Apply(tmp13, []any{v11, v12}) - return tmp14 - }) - tmp2.AddMethod(tmp9, tmp10) - tmp11 := reflect.TypeOf((*lang.IRecord)(nil)).Elem() - var tmp12 lang.FnFunc - tmp12 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v13 := args[0] - _ = v13 - v14 := args[1] - _ = v14 - tmp15 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) - tmp16 := lang.Apply(tmp15, []any{v13, v14}) - _ = tmp16 - tmp17 := lang.Apply(lang.WriteWriter, []any{v14, "#"}) - _ = tmp17 - tmp18 := checkDerefVar(var_glojure_DOT_core_class) - tmp19 := lang.Apply(tmp18, []any{v13}) - tmp20, ok := lang.FieldOrMethod(tmp19, "Name") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp19, "Name"))) - } - var tmp21 any - switch reflect.TypeOf(tmp20).Kind() { - case reflect.Func: - tmp21 = lang.Apply(tmp20, nil) - default: - tmp21 = tmp20 - } - tmp22 := lang.Apply(lang.WriteWriter, []any{v14, tmp21}) - _ = tmp22 - tmp23 := checkDerefVar(var_glojure_DOT_core_print_DASH_map) - tmp24 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) - tmp25 := lang.Apply(tmp23, []any{v13, tmp24, v14}) - return tmp25 - }) - tmp2.AddMethod(tmp11, tmp12) - tmp13 := reflect.TypeOf(uint(0)) - var tmp14 lang.FnFunc - tmp14 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v15 := args[0] - _ = v15 - v16 := args[1] - _ = v16 - tmp17 := checkDerefVar(var_glojure_DOT_core_str) - tmp18 := lang.Apply(tmp17, []any{v15}) - tmp19, _ := lang.FieldOrMethod(v16, "write") - if reflect.TypeOf(tmp19).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) - } - tmp20 := lang.Apply(tmp19, []any{tmp18}) - return tmp20 - }) - tmp2.AddMethod(tmp13, tmp14) - tmp15 := reflect.TypeOf(int64(0)) - var tmp16 lang.FnFunc - tmp16 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v17 := args[0] - _ = v17 - v18 := args[1] - _ = v18 - tmp19 := checkDerefVar(var_glojure_DOT_core_str) - tmp20 := lang.Apply(tmp19, []any{v17}) - tmp21, _ := lang.FieldOrMethod(v18, "write") - if reflect.TypeOf(tmp21).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) - } - tmp22 := lang.Apply(tmp21, []any{tmp20}) - return tmp22 - }) - tmp2.AddMethod(tmp15, tmp16) - var tmp17 lang.FnFunc - tmp17 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v18 := args[0] - _ = v18 - v19 := args[1] - _ = v19 - var tmp20 any - tmp21 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp22 := reflect.TypeOf((*lang.IObj)(nil)).Elem() - tmp23 := lang.Apply(tmp21, []any{tmp22, v18}) - if lang.IsTruthy(tmp23) { - tmp24 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) - tmp25 := checkDerefVar(var_glojure_DOT_core_vary_DASH_meta) - var tmp26 lang.FnFunc - tmp26 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v27 := args[0] - _ = v27 - tmp28 := checkDerefVar(var_glojure_DOT_core_dissoc) - tmp29 := lang.Apply(tmp28, []any{v27, kw_type}) - return tmp29 - }) - tmp27 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(87), kw_column, int(32), kw_end_DASH_line, int(87), kw_end_DASH_column, int(48)) - tmp28, err := lang.WithMeta(tmp26, tmp27.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp29 := lang.Apply(tmp25, []any{v18, tmp28}) - tmp30 := lang.Apply(tmp24, []any{tmp29, v19}) - tmp20 = tmp30 - } else { - tmp31 := checkDerefVar(var_glojure_DOT_core_print_DASH_simple) - tmp32 := lang.Apply(tmp31, []any{v18, v19}) - tmp20 = tmp32 - } - return tmp20 - }) - tmp2.AddMethod(kw_default, tmp17) - tmp18 := reflect.TypeOf(float64(0)) - var tmp19 lang.FnFunc - tmp19 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v20 := args[0] - _ = v20 - v21 := args[1] - _ = v21 - var tmp22 any - tmp23 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp24 := lang.Apply(math7.Inf, []any{int64(1)}) - tmp25 := lang.Apply(tmp23, []any{tmp24, v20}) - if lang.IsTruthy(tmp25) { - tmp26 := lang.Apply(lang.WriteWriter, []any{v21, "##Inf"}) - tmp22 = tmp26 - } else { - var tmp27 any - tmp28 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp29 := lang.Apply(math7.Inf, []any{int64(-1)}) - tmp30 := lang.Apply(tmp28, []any{tmp29, v20}) - if lang.IsTruthy(tmp30) { - tmp31 := lang.Apply(lang.WriteWriter, []any{v21, "##-Inf"}) - tmp27 = tmp31 - } else { - var tmp32 any - tmp33 := lang.Apply(math7.IsNaN, []any{v20}) - if lang.IsTruthy(tmp33) { - tmp34 := lang.Apply(lang.WriteWriter, []any{v21, "##NaN"}) - tmp32 = tmp34 - } else { - var tmp35 any - if lang.IsTruthy(kw_else) { - tmp36 := checkDerefVar(var_glojure_DOT_core_str) - tmp37 := lang.Apply(tmp36, []any{v20}) - tmp38 := lang.Apply(lang.WriteWriter, []any{v21, tmp37}) - tmp35 = tmp38 - } else { - } - tmp32 = tmp35 - } - tmp27 = tmp32 + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR__TICK_) + tmp6 := lang.Apply(tmp5, []any{int64(-1), v4}) + return tmp6 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "MinusP") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("MinusP is not a function"))) } - tmp22 = tmp27 + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp8 := checkDerefVar(var_glojure_DOT_core__DASH__TICK_) + tmp9 := checkDerefVar(var_glojure_DOT_core__DASH__TICK_) + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) + return tmp11 } - return tmp22 }) - tmp2.AddMethod(tmp18, tmp19) - tmp20 := reflect.TypeOf("") - var tmp21 lang.FnFunc - tmp21 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v22 := args[0] - _ = v22 - v23 := args[1] - _ = v23 - var tmp24 any - var tmp25 any - { // let - // let binding "or__0__auto__" - tmp26 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_dup_STAR_) - var v27 any = tmp26 - _ = v27 - var tmp28 any - if lang.IsTruthy(v27) { - tmp28 = v27 - } else { - tmp29 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_readably_STAR_) - tmp28 = tmp29 - } - tmp25 = tmp28 - } // end let - if lang.IsTruthy(tmp25) { - tmp26 := lang.Apply(lang.AppendWriter, []any{v23, lang.NewChar(34)}) - _ = tmp26 - var tmp27 any + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__DASH__TICK_ = ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__DASH__TICK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // agent + { + tmp0 := sym_agent.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_state, sym__AMP_, sym_options)), kw_doc, "Creates and returns an agent with an initial value of state and\n zero or more options (in any order):\n\n :meta metadata-map\n\n :validator validate-fn\n\n :error-handler handler-fn\n\n :error-mode mode-keyword\n\n If metadata-map is supplied, it will become the metadata on the\n agent. validate-fn must be nil or a side-effect-free fn of one\n argument, which will be passed the intended new state on any state\n change. If the new state is unacceptable, the validate-fn should\n return false or throw an exception. handler-fn is called if an\n action throws an exception or if validate-fn rejects a new state --\n see set-error-handler! for details. The mode-keyword may be either\n :continue (the default if an error-handler is given) or :fail (the\n default if no error-handler is given) -- see set-error-mode! for\n details.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(2052), kw_end_DASH_line, int(2052))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + var tmp4 any { // let - // let binding "n__0__auto__" - tmp28 := checkDerefVar(var_glojure_DOT_core_long) - tmp29 := checkDerefVar(var_glojure_DOT_core_count) - tmp30 := lang.Apply(tmp29, []any{v22}) - tmp31 := lang.Apply(tmp28, []any{tmp30}) - var v32 any = tmp31 - _ = v32 - var tmp33 any + // let binding "a" + var v5 any = "unimplemented: new with non-constant class type" + _ = v5 + // let binding "opts" + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) + var v9 any = tmp8 + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_setup_DASH_reference) + tmp11 := lang.Apply(tmp10, []any{v5, v3}) + _ = tmp11 + var tmp12 any + tmp13 := lang.Apply(kw_error_DASH_handler, []any{v9}) + if lang.IsTruthy(tmp13) { + tmp14 := lang.Apply(kw_error_DASH_handler, []any{v9}) + tmp15, _ := lang.FieldOrMethod(v5, "setErrorHandler") + if reflect.TypeOf(tmp15).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorHandler is not a function"))) + } + tmp16 := lang.Apply(tmp15, []any{tmp14}) + tmp12 = tmp16 + } else { + } + _ = tmp12 + var tmp17 any { // let - // let binding "n" - var v34 any = int64(0) - _ = v34 - for { - var tmp35 any - tmp36 := checkDerefVar(var_glojure_DOT_core__LT_) - tmp37 := lang.Apply(tmp36, []any{v34, v32}) - if lang.IsTruthy(tmp37) { - var tmp38 any - { // let - // let binding "c" - tmp39 := lang.Apply(lang.CharAt, []any{v22, v34}) - var v40 any = tmp39 - _ = v40 - // let binding "e" - tmp41 := checkDerefVar(var_glojure_DOT_core_char_DASH_escape_DASH_string) - tmp42 := lang.Apply(tmp41, []any{v40}) - var v43 any = tmp42 - _ = v43 - var tmp44 any - if lang.IsTruthy(v43) { - tmp45 := lang.Apply(lang.WriteWriter, []any{v23, v43}) - tmp44 = tmp45 - } else { - tmp46 := lang.Apply(lang.AppendWriter, []any{v23, v40}) - tmp44 = tmp46 - } - tmp38 = tmp44 - } // end let - _ = tmp38 - tmp40 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) - tmp41 := lang.Apply(tmp40, []any{v34}) - var tmp39 any = tmp41 - v34 = tmp39 - continue + // let binding "or__0__auto__" + tmp18 := lang.Apply(kw_error_DASH_mode, []any{v9}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + tmp20 = v19 + } else { + var tmp21 any + tmp22 := lang.Apply(kw_error_DASH_handler, []any{v9}) + if lang.IsTruthy(tmp22) { + tmp21 = kw_continue } else { + tmp21 = kw_fail } - tmp33 = tmp35 - break + tmp20 = tmp21 } + tmp17 = tmp20 } // end let - tmp27 = tmp33 - } // end let - _ = tmp27 - tmp28 := lang.Apply(lang.AppendWriter, []any{v23, lang.NewChar(34)}) - tmp24 = tmp28 - } else { - tmp29 := lang.Apply(lang.WriteWriter, []any{v23, v22}) - tmp24 = tmp29 - } - _ = tmp24 - return nil - }) - tmp2.AddMethod(tmp20, tmp21) - tmp22 := reflect.TypeOf(int32(0)) - var tmp23 lang.FnFunc - tmp23 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v24 := args[0] - _ = v24 - v25 := args[1] - _ = v25 - var tmp26 any - var tmp27 any - { // let - // let binding "or__0__auto__" - tmp28 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_dup_STAR_) - var v29 any = tmp28 - _ = v29 - var tmp30 any - if lang.IsTruthy(v29) { - tmp30 = v29 - } else { - tmp31 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_readably_STAR_) - tmp30 = tmp31 - } - tmp27 = tmp30 - } // end let - if lang.IsTruthy(tmp27) { - tmp28 := lang.Apply(lang.AppendWriter, []any{v25, lang.NewChar(92)}) - _ = tmp28 - var tmp29 any - { // let - // let binding "n" - tmp30 := checkDerefVar(var_glojure_DOT_core_char_DASH_name_DASH_string) - tmp31 := lang.Apply(tmp30, []any{v24}) - var v32 any = tmp31 - _ = v32 - var tmp33 any - if lang.IsTruthy(v32) { - tmp34 := lang.Apply(lang.WriteWriter, []any{v25, v32}) - tmp33 = tmp34 - } else { - tmp35 := lang.Apply(lang.AppendWriter, []any{v25, v24}) - tmp33 = tmp35 + tmp18, _ := lang.FieldOrMethod(v5, "setErrorMode") + if reflect.TypeOf(tmp18).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorMode is not a function"))) } - tmp29 = tmp33 + tmp19 := lang.Apply(tmp18, []any{tmp17}) + _ = tmp19 + tmp4 = v5 } // end let - tmp26 = tmp29 - } else { - tmp30 := lang.Apply(lang.AppendWriter, []any{v25, v24}) - tmp26 = tmp30 - } - _ = tmp26 - return nil - }) - tmp2.AddMethod(tmp22, tmp23) - tmp24 := reflect.TypeOf((*lang.IPersistentMap)(nil)).Elem() - var tmp25 lang.FnFunc - tmp25 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v26 := args[0] - _ = v26 - v27 := args[1] - _ = v27 - tmp28 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) - tmp29 := lang.Apply(tmp28, []any{v26, v27}) - _ = tmp29 - var tmp30 any - { // let - // let binding "vec__234" - tmp31 := checkDerefVar(var_glojure_DOT_core_lift_DASH_ns) - tmp32 := lang.Apply(tmp31, []any{v26}) - var v33 any = tmp32 - _ = v33 - // let binding "ns" - tmp34 := checkDerefVar(var_glojure_DOT_core_nth) - tmp35 := lang.Apply(tmp34, []any{v33, int64(0), nil}) - var v36 any = tmp35 - _ = v36 - // let binding "lift-kvs" - tmp37 := checkDerefVar(var_glojure_DOT_core_nth) - tmp38 := lang.Apply(tmp37, []any{v33, int64(1), nil}) - var v39 any = tmp38 - _ = v39 - var tmp40 any - if lang.IsTruthy(v36) { - tmp41 := checkDerefVar(var_glojure_DOT_core_print_DASH_prefix_DASH_map) - tmp42 := checkDerefVar(var_glojure_DOT_core_str) - tmp43 := lang.Apply(tmp42, []any{"#:", v36}) - tmp44 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) - tmp45 := lang.Apply(tmp41, []any{tmp43, v39, tmp44, v27}) - tmp40 = tmp45 - } else { - tmp46 := checkDerefVar(var_glojure_DOT_core_print_DASH_map) - tmp47 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) - tmp48 := lang.Apply(tmp46, []any{v26, tmp47, v27}) - tmp40 = tmp48 - } - tmp30 = tmp40 - } // end let - return tmp30 - }) - tmp2.AddMethod(tmp24, tmp25) - tmp26 := reflect.TypeOf((*lang.IPersistentVector)(nil)).Elem() - var tmp27 lang.FnFunc - tmp27 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v28 := args[0] - _ = v28 - v29 := args[1] - _ = v29 - tmp30 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) - tmp31 := lang.Apply(tmp30, []any{v28, v29}) - _ = tmp31 - tmp32 := checkDerefVar(var_glojure_DOT_core_print_DASH_sequential) - tmp33 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) - tmp34 := lang.Apply(tmp32, []any{"[", tmp33, " ", "]", v28, v29}) - return tmp34 - }) - tmp2.AddMethod(tmp26, tmp27) - tmp28 := reflect.TypeOf((*lang.IPersistentSet)(nil)).Elem() - var tmp29 lang.FnFunc - tmp29 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v30 := args[0] - _ = v30 - v31 := args[1] - _ = v31 - tmp32 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) - tmp33 := lang.Apply(tmp32, []any{v30, v31}) - _ = tmp33 - tmp34 := checkDerefVar(var_glojure_DOT_core_print_DASH_sequential) - tmp35 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) - tmp36 := checkDerefVar(var_glojure_DOT_core_seq) - tmp37 := lang.Apply(tmp36, []any{v30}) - tmp38 := lang.Apply(tmp34, []any{"#{", tmp35, " ", "}", tmp37, v31}) - return tmp38 - }) - tmp2.AddMethod(tmp28, tmp29) - tmp30 := reflect.TypeOf(uint8(0)) - var tmp31 lang.FnFunc - tmp31 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v32 := args[0] - _ = v32 - v33 := args[1] - _ = v33 - tmp34 := checkDerefVar(var_glojure_DOT_core_str) - tmp35 := lang.Apply(tmp34, []any{v32}) - tmp36, _ := lang.FieldOrMethod(v33, "write") - if reflect.TypeOf(tmp36).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + return tmp4 } - tmp37 := lang.Apply(tmp36, []any{tmp35}) - return tmp37 - }) - tmp2.AddMethod(tmp30, tmp31) - tmp32 := reflect.TypeOf((*lang.IDeref)(nil)).Elem() - var tmp33 lang.FnFunc - tmp33 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v34 := args[0] - _ = v34 - v35 := args[1] - _ = v35 - tmp36 := checkDerefVar(var_glojure_DOT_core_print_DASH_tagged_DASH_object) - tmp37 := checkDerefVar(var_glojure_DOT_core_deref_DASH_as_DASH_map) - tmp38 := lang.Apply(tmp37, []any{v34}) - tmp39 := lang.Apply(tmp36, []any{v34, tmp38, v35}) - return tmp39 - }) - tmp2.AddMethod(tmp32, tmp33) - tmp34 := reflect.TypeOf(false) - var tmp35 lang.FnFunc - tmp35 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v36 := args[0] - _ = v36 - v37 := args[1] - _ = v37 - tmp38 := checkDerefVar(var_glojure_DOT_core_str) - tmp39 := lang.Apply(tmp38, []any{v36}) - tmp40 := lang.Apply(lang.WriteWriter, []any{v37, tmp39}) - return tmp40 - }) - tmp2.AddMethod(tmp34, tmp35) - tmp36 := reflect.TypeOf((*lang.Object)(nil)).Elem() - var tmp37 lang.FnFunc - tmp37 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v38 := args[0] - _ = v38 - v39 := args[1] - _ = v39 - tmp40 := checkDerefVar(var_glojure_DOT_core_print_DASH_object) - tmp41 := lang.Apply(tmp40, []any{v38, v39}) - return tmp41 }) - tmp2.AddMethod(tmp36, tmp37) - tmp38 := reflect.TypeOf(int(0)) - var tmp39 lang.FnFunc - tmp39 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v40 := args[0] - _ = v40 - v41 := args[1] - _ = v41 - tmp42 := checkDerefVar(var_glojure_DOT_core_str) - tmp43 := lang.Apply(tmp42, []any{v40}) - tmp44, _ := lang.FieldOrMethod(v41, "write") - if reflect.TypeOf(tmp44).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_agent = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_agent.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // aget + { + var tmp1 lang.FnFunc + { // function aget__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Aget}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := checkDerefVar(var_glojure_DOT_core_seq) + tmp20 := checkDerefVar(var_glojure_DOT_core_concat) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{sym_glojure_DOT_core_SLASH_int}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := lang.Apply(tmp23, []any{v4}) + tmp25 := lang.Apply(tmp20, []any{tmp22, tmp24}) + tmp26 := lang.Apply(tmp19, []any{tmp25}) + tmp27 := lang.Apply(tmp18, []any{tmp26}) + tmp28 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp27}) + tmp29 := lang.Apply(tmp12, []any{tmp28}) + tmp30 := lang.Apply(tmp11, []any{tmp29}) + tmp31 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp30}) + tmp32 := lang.Apply(tmp5, []any{tmp31}) + return tmp32 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_aget.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx), lang.NewVector(sym_array, sym_idx, sym__AMP_, sym_idxs)), kw_inline, tmp1, kw_doc, "Returns the value at the index/indices. Works on Java arrays of all\n types.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3911), kw_end_DASH_line, int(3911))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(lang.Get, []any{v3, v4}) + return tmp5 + default: + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_aget) + tmp8 := checkDerefVar(var_glojure_DOT_core_aget) + tmp9 := lang.Apply(tmp8, []any{v3, v4}) + tmp10 := lang.Apply(tmp6, []any{tmp7, tmp9, v5}) + return tmp10 } - tmp45 := lang.Apply(tmp44, []any{tmp43}) - return tmp45 }) - tmp2.AddMethod(tmp38, tmp39) - tmp40 := reflect.TypeOf((*regexp15.Regexp)(nil)) - var tmp41 lang.FnFunc - tmp41 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v42 := args[0] - _ = v42 - v43 := args[1] - _ = v43 - tmp44 := lang.Apply(lang.WriteWriter, []any{v43, "#\""}) - _ = tmp44 - var tmp45 any - { // let - // let binding "G__240" - tmp46 := checkDerefVar(var_glojure_DOT_core_seq) - tmp47, ok := lang.FieldOrMethod(v42, "String") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v42, "String"))) - } - var tmp48 any - switch reflect.TypeOf(tmp47).Kind() { - case reflect.Func: - tmp48 = lang.Apply(tmp47, nil) - default: - tmp48 = tmp47 - } - tmp49 := lang.Apply(tmp46, []any{tmp48}) - var v50 any = tmp49 - _ = v50 - // let binding "vec__241" - var v51 any = v50 - _ = v51 - // let binding "seq__242" - tmp52 := checkDerefVar(var_glojure_DOT_core_seq) - tmp53 := lang.Apply(tmp52, []any{v51}) - var v54 any = tmp53 - _ = v54 - // let binding "first__243" - tmp55 := checkDerefVar(var_glojure_DOT_core_first) - tmp56 := lang.Apply(tmp55, []any{v54}) - var v57 any = tmp56 - _ = v57 - // let binding "seq__242" - tmp58 := checkDerefVar(var_glojure_DOT_core_next) - tmp59 := lang.Apply(tmp58, []any{v54}) - var v60 any = tmp59 - _ = v60 - // let binding "c" - var v61 any = v57 - _ = v61 - // let binding "r" - var v62 any = v60 - _ = v62 - // let binding "s" - var v63 any = v51 - _ = v63 - // let binding "qmode" - var v64 any = false - _ = v64 - var tmp65 any + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_aget = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_aget.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // amap + { + tmp0 := sym_amap.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_a, sym_idx, sym_ret, sym_expr)), kw_doc, "Maps an expression across an array a, using an index named idx, and\n return value named ret, initialized to a clone of a, then setting \n each element of ret to the evaluation of expr, returning the new \n array ret.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(11), kw_line, int(5273), kw_end_DASH_line, int(5273))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 6) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + v7 := args[5] + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_let}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_apply) + tmp14 := checkDerefVar(var_glojure_DOT_core_vector) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_a__0__auto__}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v4}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{sym_l__1__auto__}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_seq) + tmp25 := checkDerefVar(var_glojure_DOT_core_concat) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{sym_glojure_DOT_core_SLASH_alength}) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := lang.Apply(tmp28, []any{sym_a__0__auto__}) + tmp30 := lang.Apply(tmp25, []any{tmp27, tmp29}) + tmp31 := lang.Apply(tmp24, []any{tmp30}) + tmp32 := lang.Apply(tmp23, []any{tmp31}) + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{v6}) + tmp35 := checkDerefVar(var_glojure_DOT_core_list) + tmp36 := checkDerefVar(var_glojure_DOT_core_seq) + tmp37 := checkDerefVar(var_glojure_DOT_core_concat) + tmp38 := checkDerefVar(var_glojure_DOT_core_list) + tmp39 := lang.Apply(tmp38, []any{sym_glojure_DOT_core_SLASH_aclone}) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{sym_a__0__auto__}) + tmp42 := lang.Apply(tmp37, []any{tmp39, tmp41}) + tmp43 := lang.Apply(tmp36, []any{tmp42}) + tmp44 := lang.Apply(tmp35, []any{tmp43}) + tmp45 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22, tmp32, tmp34, tmp44}) + tmp46 := lang.Apply(tmp15, []any{tmp45}) + tmp47 := lang.Apply(tmp13, []any{tmp14, tmp46}) + tmp48 := lang.Apply(tmp12, []any{tmp47}) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) + tmp50 := checkDerefVar(var_glojure_DOT_core_seq) + tmp51 := checkDerefVar(var_glojure_DOT_core_concat) + tmp52 := checkDerefVar(var_glojure_DOT_core_list) + tmp53 := lang.Apply(tmp52, []any{sym_glojure_DOT_core_SLASH_loop}) + tmp54 := checkDerefVar(var_glojure_DOT_core_list) + tmp55 := checkDerefVar(var_glojure_DOT_core_apply) + tmp56 := checkDerefVar(var_glojure_DOT_core_vector) + tmp57 := checkDerefVar(var_glojure_DOT_core_seq) + tmp58 := checkDerefVar(var_glojure_DOT_core_concat) + tmp59 := checkDerefVar(var_glojure_DOT_core_list) + tmp60 := lang.Apply(tmp59, []any{v5}) + tmp61 := checkDerefVar(var_glojure_DOT_core_list) + tmp62 := lang.Apply(tmp61, []any{int64(0)}) + tmp63 := lang.Apply(tmp58, []any{tmp60, tmp62}) + tmp64 := lang.Apply(tmp57, []any{tmp63}) + tmp65 := lang.Apply(tmp55, []any{tmp56, tmp64}) + tmp66 := lang.Apply(tmp54, []any{tmp65}) + tmp67 := checkDerefVar(var_glojure_DOT_core_list) + tmp68 := checkDerefVar(var_glojure_DOT_core_seq) + tmp69 := checkDerefVar(var_glojure_DOT_core_concat) + tmp70 := checkDerefVar(var_glojure_DOT_core_list) + tmp71 := lang.Apply(tmp70, []any{sym_if}) + tmp72 := checkDerefVar(var_glojure_DOT_core_list) + tmp73 := checkDerefVar(var_glojure_DOT_core_seq) + tmp74 := checkDerefVar(var_glojure_DOT_core_concat) + tmp75 := checkDerefVar(var_glojure_DOT_core_list) + tmp76 := lang.Apply(tmp75, []any{sym_glojure_DOT_core_SLASH__LT_}) + tmp77 := checkDerefVar(var_glojure_DOT_core_list) + tmp78 := lang.Apply(tmp77, []any{v5}) + tmp79 := checkDerefVar(var_glojure_DOT_core_list) + tmp80 := lang.Apply(tmp79, []any{sym_l__1__auto__}) + tmp81 := lang.Apply(tmp74, []any{tmp76, tmp78, tmp80}) + tmp82 := lang.Apply(tmp73, []any{tmp81}) + tmp83 := lang.Apply(tmp72, []any{tmp82}) + tmp84 := checkDerefVar(var_glojure_DOT_core_list) + tmp85 := checkDerefVar(var_glojure_DOT_core_seq) + tmp86 := checkDerefVar(var_glojure_DOT_core_concat) + tmp87 := checkDerefVar(var_glojure_DOT_core_list) + tmp88 := lang.Apply(tmp87, []any{sym_do}) + tmp89 := checkDerefVar(var_glojure_DOT_core_list) + tmp90 := checkDerefVar(var_glojure_DOT_core_seq) + tmp91 := checkDerefVar(var_glojure_DOT_core_concat) + tmp92 := checkDerefVar(var_glojure_DOT_core_list) + tmp93 := lang.Apply(tmp92, []any{sym_glojure_DOT_core_SLASH_aset}) + tmp94 := checkDerefVar(var_glojure_DOT_core_list) + tmp95 := lang.Apply(tmp94, []any{v6}) + tmp96 := checkDerefVar(var_glojure_DOT_core_list) + tmp97 := lang.Apply(tmp96, []any{v5}) + tmp98 := checkDerefVar(var_glojure_DOT_core_list) + tmp99 := lang.Apply(tmp98, []any{v7}) + tmp100 := lang.Apply(tmp91, []any{tmp93, tmp95, tmp97, tmp99}) + tmp101 := lang.Apply(tmp90, []any{tmp100}) + tmp102 := lang.Apply(tmp89, []any{tmp101}) + tmp103 := checkDerefVar(var_glojure_DOT_core_list) + tmp104 := checkDerefVar(var_glojure_DOT_core_seq) + tmp105 := checkDerefVar(var_glojure_DOT_core_concat) + tmp106 := checkDerefVar(var_glojure_DOT_core_list) + tmp107 := lang.Apply(tmp106, []any{sym_recur}) + tmp108 := checkDerefVar(var_glojure_DOT_core_list) + tmp109 := checkDerefVar(var_glojure_DOT_core_seq) + tmp110 := checkDerefVar(var_glojure_DOT_core_concat) + tmp111 := checkDerefVar(var_glojure_DOT_core_list) + tmp112 := lang.Apply(tmp111, []any{sym_glojure_DOT_core_SLASH_unchecked_DASH_inc}) + tmp113 := checkDerefVar(var_glojure_DOT_core_list) + tmp114 := lang.Apply(tmp113, []any{v5}) + tmp115 := lang.Apply(tmp110, []any{tmp112, tmp114}) + tmp116 := lang.Apply(tmp109, []any{tmp115}) + tmp117 := lang.Apply(tmp108, []any{tmp116}) + tmp118 := lang.Apply(tmp105, []any{tmp107, tmp117}) + tmp119 := lang.Apply(tmp104, []any{tmp118}) + tmp120 := lang.Apply(tmp103, []any{tmp119}) + tmp121 := lang.Apply(tmp86, []any{tmp88, tmp102, tmp120}) + tmp122 := lang.Apply(tmp85, []any{tmp121}) + tmp123 := lang.Apply(tmp84, []any{tmp122}) + tmp124 := checkDerefVar(var_glojure_DOT_core_list) + tmp125 := lang.Apply(tmp124, []any{v6}) + tmp126 := lang.Apply(tmp69, []any{tmp71, tmp83, tmp123, tmp125}) + tmp127 := lang.Apply(tmp68, []any{tmp126}) + tmp128 := lang.Apply(tmp67, []any{tmp127}) + tmp129 := lang.Apply(tmp51, []any{tmp53, tmp66, tmp128}) + tmp130 := lang.Apply(tmp50, []any{tmp129}) + tmp131 := lang.Apply(tmp49, []any{tmp130}) + tmp132 := lang.Apply(tmp9, []any{tmp11, tmp48, tmp131}) + tmp133 := lang.Apply(tmp8, []any{tmp132}) + return tmp133 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_amap = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_amap.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ancestors + { + tmp0 := sym_ancestors.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_tag), lang.NewVector(sym_h, sym_tag)), kw_doc, "Returns the immediate and indirect parents of tag, either via a Java type\n inheritance relationship or a relationship established via derive. h\n must be a hierarchy obtained from make-hierarchy, if not supplied\n defaults to the global hierarchy", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(5577), kw_end_DASH_line, int(5577))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_ancestors) + tmp4 := checkDerefVar(var_glojure_DOT_core_global_DASH_hierarchy) + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_not_DASH_empty) + var tmp5 any { // let - // let binding "G__240" - var v66 any = v50 - _ = v66 - // let binding "qmode" - var v67 any = v64 - _ = v67 - for { - var tmp68 any + // let binding "ta" + tmp6 := checkDerefVar(var_glojure_DOT_core_get) + tmp7 := lang.Apply(kw_ancestors, []any{v2}) + tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + tmp11 := checkDerefVar(var_glojure_DOT_core_class_QMARK_) + tmp12 := lang.Apply(tmp11, []any{v3}) + if lang.IsTruthy(tmp12) { + var tmp13 any { // let - // let binding "vec__244" - var v69 any = v66 - _ = v69 - // let binding "seq__245" - tmp70 := checkDerefVar(var_glojure_DOT_core_seq) - tmp71 := lang.Apply(tmp70, []any{v69}) - var v72 any = tmp71 - _ = v72 - // let binding "first__246" - tmp73 := checkDerefVar(var_glojure_DOT_core_first) - tmp74 := lang.Apply(tmp73, []any{v72}) - var v75 any = tmp74 - _ = v75 - // let binding "seq__245" - tmp76 := checkDerefVar(var_glojure_DOT_core_next) - tmp77 := lang.Apply(tmp76, []any{v72}) - var v78 any = tmp77 - _ = v78 - // let binding "c" - var v79 any = v75 - _ = v79 - // let binding "r" - var v80 any = v78 - _ = v80 - // let binding "s" - var v81 any = v69 - _ = v81 - // let binding "qmode" - var v82 any = v67 - _ = v82 - var tmp83 any - if lang.IsTruthy(v81) { - var tmp84 any - tmp85 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp86 := lang.Apply(tmp85, []any{v79, lang.NewChar(92)}) - if lang.IsTruthy(tmp86) { - var tmp87 any - { // let - // let binding "vec__247" - var v88 any = v80 - _ = v88 - // let binding "seq__248" - tmp89 := checkDerefVar(var_glojure_DOT_core_seq) - tmp90 := lang.Apply(tmp89, []any{v88}) - var v91 any = tmp90 - _ = v91 - // let binding "first__249" - tmp92 := checkDerefVar(var_glojure_DOT_core_first) - tmp93 := lang.Apply(tmp92, []any{v91}) - var v94 any = tmp93 - _ = v94 - // let binding "seq__248" - tmp95 := checkDerefVar(var_glojure_DOT_core_next) - tmp96 := lang.Apply(tmp95, []any{v91}) - var v97 any = tmp96 - _ = v97 - // let binding "c2" - var v98 any = v94 - _ = v98 - // let binding "r2" - var v99 any = v97 - _ = v99 - tmp100 := lang.Apply(lang.AppendWriter, []any{v43, lang.NewChar(92)}) - _ = tmp100 - tmp101 := lang.Apply(lang.AppendWriter, []any{v43, v98}) - _ = tmp101 - var tmp102 any - if lang.IsTruthy(v82) { - var tmp103 any = v99 - tmp105 := checkDerefVar(var_glojure_DOT_core_not_EQ_) - tmp106 := lang.Apply(tmp105, []any{v98, lang.NewChar(69)}) - var tmp104 any = tmp106 - v66 = tmp103 - v67 = tmp104 - continue - } else { - var tmp107 any = v99 - tmp109 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp110 := lang.Apply(tmp109, []any{v98, lang.NewChar(81)}) - var tmp108 any = tmp110 - v66 = tmp107 - v67 = tmp108 - continue - } - tmp87 = tmp102 - } // end let - tmp84 = tmp87 - } else { - var tmp88 any - tmp89 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp90 := lang.Apply(tmp89, []any{v79, lang.NewChar(34)}) - if lang.IsTruthy(tmp90) { - var tmp91 any - if lang.IsTruthy(v82) { - tmp92 := lang.Apply(lang.WriteWriter, []any{v43, "\\E\\\"\\Q"}) - tmp91 = tmp92 - } else { - tmp93 := lang.Apply(lang.WriteWriter, []any{v43, "\\\""}) - tmp91 = tmp93 - } - _ = tmp91 - var tmp94 any = v80 - var tmp95 any = v82 - v66 = tmp94 - v67 = tmp95 - continue - } else { - var tmp96 any - if lang.IsTruthy(kw_else) { - tmp97 := lang.Apply(lang.AppendWriter, []any{v43, v79}) - _ = tmp97 - var tmp98 any = v80 - var tmp99 any = v82 - v66 = tmp98 - v67 = tmp99 - continue - } else { - } - tmp88 = tmp96 - } - tmp84 = tmp88 - } - tmp83 = tmp84 - } else { + // let binding "superclasses" + tmp14 := checkDerefVar(var_glojure_DOT_core_set) + tmp15 := checkDerefVar(var_glojure_DOT_core_supers) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp14, []any{tmp16}) + var v18 any = tmp17 + _ = v18 + tmp19 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp20 := checkDerefVar(var_glojure_DOT_core_into1) + tmp21 := checkDerefVar(var_glojure_DOT_core_cons) + tmp22 := checkDerefVar(var_glojure_DOT_core_map) + var tmp23 lang.FnFunc + tmp23 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v24 := args[0] + _ = v24 + tmp25 := checkDerefVar(var_glojure_DOT_core_get) + tmp26 := lang.Apply(kw_ancestors, []any{v2}) + tmp27 := lang.Apply(tmp25, []any{tmp26, v24}) + return tmp27 + }) + tmp24 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5590), kw_column, int(32), kw_end_DASH_line, int(5590), kw_end_DASH_column, int(54)) + tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) + if err != nil { + panic(err) } - tmp68 = tmp83 - } // end let - tmp65 = tmp68 - break - } - } // end let - tmp45 = tmp65 - } // end let - _ = tmp45 - tmp46 := lang.Apply(lang.AppendWriter, []any{v43, lang.NewChar(34)}) - return tmp46 - }) - tmp2.AddMethod(tmp40, tmp41) - tmp42 := reflect.TypeOf(int32(0)) - var tmp43 lang.FnFunc - tmp43 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v44 := args[0] - _ = v44 - v45 := args[1] - _ = v45 - tmp46 := checkDerefVar(var_glojure_DOT_core_str) - tmp47 := lang.Apply(tmp46, []any{v44}) - tmp48, _ := lang.FieldOrMethod(v45, "write") - if reflect.TypeOf(tmp48).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) - } - tmp49 := lang.Apply(tmp48, []any{tmp47}) - return tmp49 - }) - tmp2.AddMethod(tmp42, tmp43) - tmp44 := reflect.TypeOf((*lang.Ratio)(nil)) - var tmp45 lang.FnFunc - tmp45 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v46 := args[0] - _ = v46 - v47 := args[1] - _ = v47 - tmp48 := checkDerefVar(var_glojure_DOT_core_str) - tmp49 := lang.Apply(tmp48, []any{v46}) - tmp50, _ := lang.FieldOrMethod(v47, "write") - if reflect.TypeOf(tmp50).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) - } - tmp51 := lang.Apply(tmp50, []any{tmp49}) - return tmp51 - }) - tmp2.AddMethod(tmp44, tmp45) - tmp46 := reflect.TypeOf(float32(0)) - var tmp47 lang.FnFunc - tmp47 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v48 := args[0] - _ = v48 - v49 := args[1] - _ = v49 - var tmp50 any - tmp51 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp52 := lang.Apply(math7.Inf, []any{int64(1)}) - tmp53 := lang.Apply(lang.Builtins["float32"], []any{tmp52}) - tmp54 := lang.Apply(tmp51, []any{tmp53, v48}) - if lang.IsTruthy(tmp54) { - tmp55 := lang.Apply(lang.WriteWriter, []any{v49, "##Inf"}) - tmp50 = tmp55 - } else { - var tmp56 any - tmp57 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp58 := lang.Apply(math7.Inf, []any{int64(-1)}) - tmp59 := lang.Apply(lang.Builtins["float32"], []any{tmp58}) - tmp60 := lang.Apply(tmp57, []any{tmp59, v48}) - if lang.IsTruthy(tmp60) { - tmp61 := lang.Apply(lang.WriteWriter, []any{v49, "##-Inf"}) - tmp56 = tmp61 - } else { - var tmp62 any - tmp63 := lang.Apply(math7.IsNaN, []any{v48}) - if lang.IsTruthy(tmp63) { - tmp64 := lang.Apply(lang.WriteWriter, []any{v49, "##NaN"}) - tmp62 = tmp64 + tmp26 := lang.Apply(tmp22, []any{tmp25, v18}) + tmp27 := lang.Apply(tmp21, []any{v9, tmp26}) + tmp28 := lang.Apply(tmp19, []any{tmp20, v18, tmp27}) + tmp13 = tmp28 + } // end let + tmp10 = tmp13 } else { - var tmp65 any - if lang.IsTruthy(kw_else) { - tmp66 := checkDerefVar(var_glojure_DOT_core_str) - tmp67 := lang.Apply(tmp66, []any{v48}) - tmp68 := lang.Apply(lang.WriteWriter, []any{v49, tmp67}) - tmp65 = tmp68 - } else { - } - tmp62 = tmp65 + tmp10 = v9 } - tmp56 = tmp62 - } - tmp50 = tmp56 - } - return tmp50 - }) - tmp2.AddMethod(tmp46, tmp47) - tmp48 := reflect.TypeOf(int16(0)) - var tmp49 lang.FnFunc - tmp49 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v50 := args[0] - _ = v50 - v51 := args[1] - _ = v51 - tmp52 := checkDerefVar(var_glojure_DOT_core_str) - tmp53 := lang.Apply(tmp52, []any{v50}) - tmp54, _ := lang.FieldOrMethod(v51, "write") - if reflect.TypeOf(tmp54).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) - } - tmp55 := lang.Apply(tmp54, []any{tmp53}) - return tmp55 - }) - tmp2.AddMethod(tmp48, tmp49) - tmp50 := reflect.TypeOf((*lang.Var)(nil)) - var tmp51 lang.FnFunc - tmp51 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v52 := args[0] - _ = v52 - v53 := args[1] - _ = v53 - tmp54 := checkDerefVar(var_glojure_DOT_core_print_DASH_simple) - tmp55 := lang.Apply(tmp54, []any{v52, v53}) - return tmp55 - }) - tmp2.AddMethod(tmp50, tmp51) - tmp52 := reflect.TypeOf(int8(0)) - var tmp53 lang.FnFunc - tmp53 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v54 := args[0] - _ = v54 - v55 := args[1] - _ = v55 - tmp56 := checkDerefVar(var_glojure_DOT_core_str) - tmp57 := lang.Apply(tmp56, []any{v54}) - tmp58, _ := lang.FieldOrMethod(v55, "write") - if reflect.TypeOf(tmp58).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + tmp5 = tmp10 + } // end let + tmp6 := lang.Apply(tmp4, []any{tmp5}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") } - tmp59 := lang.Apply(tmp58, []any{tmp57}) - return tmp59 }) - tmp2.AddMethod(tmp52, tmp53) - tmp54 := reflect.TypeOf(uint16(0)) - var tmp55 lang.FnFunc - tmp55 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v56 := args[0] - _ = v56 - v57 := args[1] - _ = v57 - tmp58 := checkDerefVar(var_glojure_DOT_core_str) - tmp59 := lang.Apply(tmp58, []any{v56}) - tmp60, _ := lang.FieldOrMethod(v57, "write") - if reflect.TypeOf(tmp60).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ancestors = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ancestors.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // and + { + tmp0 := sym_and.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_x), lang.NewVector(sym_x, sym__AMP_, sym_next)), kw_doc, "Evaluates exprs one at a time, from left to right. If a form\n returns logical false (nil or false), and returns that value and\n doesn't evaluate any of the other expressions, otherwise it returns\n the value of the last expr. (and) returns true.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(11), kw_line, int(835), kw_end_DASH_line, int(835))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + return true + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + return v4 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_let}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + tmp12 := checkDerefVar(var_glojure_DOT_core_vector) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_and__0__auto__}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v4}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp19}) + tmp21 := lang.Apply(tmp11, []any{tmp12, tmp20}) + tmp22 := lang.Apply(tmp10, []any{tmp21}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_seq) + tmp25 := checkDerefVar(var_glojure_DOT_core_concat) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{sym_if}) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := lang.Apply(tmp28, []any{sym_and__0__auto__}) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := checkDerefVar(var_glojure_DOT_core_seq) + tmp32 := checkDerefVar(var_glojure_DOT_core_concat) + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{sym_glojure_DOT_core_SLASH_and}) + tmp35 := lang.Apply(tmp32, []any{tmp34, v5}) + tmp36 := lang.Apply(tmp31, []any{tmp35}) + tmp37 := lang.Apply(tmp30, []any{tmp36}) + tmp38 := checkDerefVar(var_glojure_DOT_core_list) + tmp39 := lang.Apply(tmp38, []any{sym_and__0__auto__}) + tmp40 := lang.Apply(tmp25, []any{tmp27, tmp29, tmp37, tmp39}) + tmp41 := lang.Apply(tmp24, []any{tmp40}) + tmp42 := lang.Apply(tmp23, []any{tmp41}) + tmp43 := lang.Apply(tmp7, []any{tmp9, tmp22, tmp42}) + tmp44 := lang.Apply(tmp6, []any{tmp43}) + return tmp44 } - tmp61 := lang.Apply(tmp60, []any{tmp59}) - return tmp61 }) - tmp2.AddMethod(tmp54, tmp55) - tmp56 := reflect.TypeOf(uint64(0)) - var tmp57 lang.FnFunc - tmp57 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v58 := args[0] - _ = v58 - v59 := args[1] - _ = v59 - tmp60 := checkDerefVar(var_glojure_DOT_core_str) - tmp61 := lang.Apply(tmp60, []any{v58}) - tmp62, _ := lang.FieldOrMethod(v59, "write") - if reflect.TypeOf(tmp62).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_and = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_and.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // array-map + { + tmp0 := sym_array_DASH_map.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym__AMP_, sym_keyvals)), kw_doc, "Constructs an array-map. If any keys are equal, they are handled as\n if by repeated uses of assoc.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(4378), kw_end_DASH_line, int(4378))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp2, ok := lang.FieldOrMethod(nil, "EMPTY") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "EMPTY"))) + } + var tmp3 any + switch reflect.TypeOf(tmp2).Kind() { + case reflect.Func: + tmp3 = lang.Apply(tmp2, nil) + default: + tmp3 = tmp2 + } + return tmp3 + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + var tmp3 any + { // let + // let binding "ary" + tmp4 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core_odd_QMARK_) + tmp9 := checkDerefVar(var_glojure_DOT_core_alength) + tmp10 := lang.Apply(tmp9, []any{v6}) + tmp11 := lang.Apply(tmp8, []any{tmp10}) + if lang.IsTruthy(tmp11) { + tmp12 := checkDerefVar(var_glojure_DOT_core_str) + tmp13 := checkDerefVar(var_glojure_DOT_core_last) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(tmp12, []any{"No value supplied for key: ", tmp14}) + tmp16 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp15}) + panic(tmp16) + } else { + tmp17 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{v6}) + tmp7 = tmp17 + } + tmp3 = tmp7 + } // end let + return tmp3 } - tmp63 := lang.Apply(tmp62, []any{tmp61}) - return tmp63 - }) - tmp2.AddMethod(tmp56, tmp57) - tmp58 := reflect.TypeOf((*lang.BigDecimal)(nil)) - var tmp59 lang.FnFunc - tmp59 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v60 := args[0] - _ = v60 - v61 := args[1] - _ = v61 - tmp62 := checkDerefVar(var_glojure_DOT_core_str) - tmp63 := lang.Apply(tmp62, []any{v60}) - tmp64 := lang.Apply(lang.WriteWriter, []any{v61, tmp63}) - _ = tmp64 - tmp65 := lang.Apply(lang.WriteWriter, []any{v61, "M"}) - return tmp65 - }) - tmp2.AddMethod(tmp58, tmp59) - tmp60 := reflect.TypeOf((*lang.BigInt)(nil)) - var tmp61 lang.FnFunc - tmp61 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v62 := args[0] - _ = v62 - v63 := args[1] - _ = v63 - tmp64 := checkDerefVar(var_glojure_DOT_core_str) - tmp65 := lang.Apply(tmp64, []any{v62}) - tmp66 := lang.Apply(lang.WriteWriter, []any{v63, tmp65}) - _ = tmp66 - tmp67 := lang.Apply(lang.WriteWriter, []any{v63, "N"}) - return tmp67 }) - tmp2.AddMethod(tmp60, tmp61) - tmp62 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() - var tmp63 lang.FnFunc - tmp63 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v64 := args[0] - _ = v64 - v65 := args[1] - _ = v65 - tmp66 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) - tmp67 := lang.Apply(tmp66, []any{v64, v65}) - _ = tmp67 - tmp68 := checkDerefVar(var_glojure_DOT_core_print_DASH_sequential) - tmp69 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) - tmp70 := lang.Apply(tmp68, []any{"(", tmp69, " ", ")", v64, v65}) - return tmp70 - }) - tmp2.AddMethod(tmp62, tmp63) - tmp64 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() - tmp65 := reflect.TypeOf((*lang.IPersistentCollection)(nil)).Elem() - tmp2.PreferMethod(tmp64, tmp65) - tmp66 := reflect.TypeOf((*lang.IRecord)(nil)).Elem() - tmp67 := reflect.TypeOf((*lang.IPersistentMap)(nil)).Elem() - tmp2.PreferMethod(tmp66, tmp67) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_array_DASH_map = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_array_DASH_map.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // print-object + // aset { - tmp0 := sym_print_DASH_object.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(115), kw_column, int(8), kw_end_DASH_line, int(115), kw_end_DASH_column, int(19), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_o, sym_w)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function aset__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym__DOT_}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_Aset}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{sym_glojure_DOT_core_SLASH_int}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v4}) + tmp26 := lang.Apply(tmp21, []any{tmp23, tmp25}) + tmp27 := lang.Apply(tmp20, []any{tmp26}) + tmp28 := lang.Apply(tmp19, []any{tmp27}) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{v5}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp28, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp12, []any{tmp32}) + tmp34 := lang.Apply(tmp7, []any{tmp9, tmp11, tmp33}) + tmp35 := lang.Apply(tmp6, []any{tmp34}) + return tmp35 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_aset.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx, sym_val), lang.NewVector(sym_array, sym_idx, sym_idx2, sym__AMP_, sym_idxv)), kw_inline, tmp1, kw_doc, "Sets the value at the index/indices. Works on Java arrays of\n reference types. Returns val.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(3)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3922), kw_end_DASH_line, int(3922))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_print_DASH_tagged_DASH_object) - tmp6 := checkDerefVar(var_glojure_DOT_core_str) - tmp7 := lang.Apply(tmp6, []any{v3}) - tmp8 := lang.Apply(tmp5, []any{v3, tmp7, v4}) - return tmp8 + switch len(args) { + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6 := lang.Apply(lang.SliceSet, []any{v3, v4, v5}) + _ = tmp6 + return v5 + default: + checkArity(args, 3) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_apply) + tmp8 := checkDerefVar(var_glojure_DOT_core_aset) + tmp9 := checkDerefVar(var_glojure_DOT_core_aget) + tmp10 := lang.Apply(tmp9, []any{v3, v4}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v5, v6}) + return tmp11 + } }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core_aset = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_aset.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // print-prefix-map + // aset-boolean { - tmp0 := sym_print_DASH_prefix_DASH_map.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(243), kw_column, int(8), kw_end_DASH_line, int(243), kw_end_DASH_column, int(23), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_prefix, sym_kvs, sym_print_DASH_one, sym_w)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 4) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - tmp7 := checkDerefVar(var_glojure_DOT_core_print_DASH_sequential) - tmp8 := checkDerefVar(var_glojure_DOT_core_str) - tmp9 := lang.Apply(tmp8, []any{v3, "{"}) - var tmp10 lang.FnFunc - tmp10 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v11 := args[0] - _ = v11 - v12 := args[1] - _ = v12 - var tmp13 any - { // let - // let binding "vec__212" - var v14 any = v11 - _ = v14 - // let binding "k" - tmp15 := checkDerefVar(var_glojure_DOT_core_nth) - tmp16 := lang.Apply(tmp15, []any{v14, int64(0), nil}) - var v17 any = tmp16 - _ = v17 - // let binding "v" - tmp18 := checkDerefVar(var_glojure_DOT_core_nth) - tmp19 := lang.Apply(tmp18, []any{v14, int64(1), nil}) - var v20 any = tmp19 - _ = v20 - tmp21 := lang.Apply(v5, []any{v17, v12}) - _ = tmp21 - tmp22 := lang.Apply(lang.AppendWriter, []any{v12, lang.NewChar(32)}) - _ = tmp22 - tmp23 := lang.Apply(v5, []any{v20, v12}) - tmp13 = tmp23 - } // end let - return tmp13 - }) - tmp11 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(246), kw_column, int(5), kw_end_DASH_line, int(247), kw_end_DASH_column, int(107)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) - if err != nil { - panic(err) + tmp0 := sym_aset_DASH_boolean.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx, sym_val), lang.NewVector(sym_array, sym_idx, sym_idx2, sym__AMP_, sym_idxv)), kw_doc, "Sets the value at the index/indices. Works on arrays of boolean. Returns val.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(3), kw_line, int(3956), kw_end_DASH_line, int(3958))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_boolean) + tmp6 := lang.Apply(tmp5, []any{v4}) + tmp7, _ := lang.FieldOrMethod(nil, "setBoolean") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setBoolean is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v2, v3, tmp6}) + _ = tmp8 + return v4 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_boolean) + tmp8 := checkDerefVar(var_glojure_DOT_core_aget) + tmp9 := lang.Apply(tmp8, []any{v2, v3}) + tmp10 := lang.Apply(tmp6, []any{tmp7, tmp9, v4, v5}) + return tmp10 } - tmp13 := lang.Apply(tmp7, []any{tmp9, tmp12, ", ", "}", v4, v6}) - return tmp13 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_aset_DASH_boolean = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_aset_DASH_boolean.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // print-sequential + // aset-byte { - tmp0 := sym_print_DASH_sequential.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(46), kw_column, int(8), kw_end_DASH_line, int(46), kw_end_DASH_column, int(23), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_begin, sym_print_DASH_one, sym_sep, sym_end, sym_sequence, sym_w)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 6) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - v7 := args[4] - _ = v7 - v8 := args[5] - _ = v8 - var tmp9 any - { // let - tmp10 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) - tmp11 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) - tmp12 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_print_DASH_level_STAR_) - var tmp13 any - { // let - // let binding "and__0__auto__" - tmp14 := checkDerefVar(var_glojure_DOT_core_not) - tmp15 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_dup_STAR_) - tmp16 := lang.Apply(tmp14, []any{tmp15}) - var v17 any = tmp16 - _ = v17 - var tmp18 any - if lang.IsTruthy(v17) { - var tmp19 any - { // let - // let binding "and__0__auto__" - tmp20 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_level_STAR_) - var v21 any = tmp20 - _ = v21 - var tmp22 any - if lang.IsTruthy(v21) { - tmp23 := checkDerefVar(var_glojure_DOT_core_dec) - tmp24 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_level_STAR_) - tmp25 := lang.Apply(tmp23, []any{tmp24}) - tmp22 = tmp25 - } else { - tmp22 = v21 - } - tmp19 = tmp22 - } // end let - tmp18 = tmp19 - } else { - tmp18 = v17 - } - tmp13 = tmp18 - } // end let - tmp14 := lang.Apply(tmp11, []any{tmp12, tmp13}) - tmp15 := lang.Apply(tmp10, []any{tmp14}) - _ = tmp15 - var tmp16 any - func() { - defer func() { - tmp17 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) - tmp18 := lang.Apply(tmp17, nil) - _ = tmp18 - }() - var tmp19 any - var tmp20 any - { // let - // let binding "and__0__auto__" - tmp21 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_level_STAR_) - var v22 any = tmp21 - _ = v22 - var tmp23 any - if lang.IsTruthy(v22) { - tmp24 := checkDerefVar(var_glojure_DOT_core_neg_QMARK_) - tmp25 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_level_STAR_) - tmp26 := lang.Apply(tmp24, []any{tmp25}) - tmp23 = tmp26 - } else { - tmp23 = v22 - } - tmp20 = tmp23 - } // end let - if lang.IsTruthy(tmp20) { - tmp21 := lang.Apply(lang.WriteWriter, []any{v8, "#"}) - tmp19 = tmp21 - } else { - tmp22 := lang.Apply(lang.WriteWriter, []any{v8, v3}) - _ = tmp22 - var tmp23 any - { // let - // let binding "temp__0__auto__" - tmp24 := checkDerefVar(var_glojure_DOT_core_seq) - tmp25 := lang.Apply(tmp24, []any{v7}) - var v26 any = tmp25 - _ = v26 - var tmp27 any - if lang.IsTruthy(v26) { - var tmp28 any - { // let - // let binding "xs" - var v29 any = v26 - _ = v29 - var tmp30 any - var tmp31 any - { // let - // let binding "and__0__auto__" - tmp32 := checkDerefVar(var_glojure_DOT_core_not) - tmp33 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_dup_STAR_) - tmp34 := lang.Apply(tmp32, []any{tmp33}) - var v35 any = tmp34 - _ = v35 - var tmp36 any - if lang.IsTruthy(v35) { - tmp37 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_length_STAR_) - tmp36 = tmp37 - } else { - tmp36 = v35 - } - tmp31 = tmp36 - } // end let - if lang.IsTruthy(tmp31) { - var tmp32 any - { // let - // let binding "G__194" - var v33 any = v29 - _ = v33 - // let binding "vec__195" - var v34 any = v33 - _ = v34 - // let binding "seq__196" - tmp35 := checkDerefVar(var_glojure_DOT_core_seq) - tmp36 := lang.Apply(tmp35, []any{v34}) - var v37 any = tmp36 - _ = v37 - // let binding "first__197" - tmp38 := checkDerefVar(var_glojure_DOT_core_first) - tmp39 := lang.Apply(tmp38, []any{v37}) - var v40 any = tmp39 - _ = v40 - // let binding "seq__196" - tmp41 := checkDerefVar(var_glojure_DOT_core_next) - tmp42 := lang.Apply(tmp41, []any{v37}) - var v43 any = tmp42 - _ = v43 - // let binding "x" - var v44 any = v40 - _ = v44 - // let binding "xs" - var v45 any = v43 - _ = v45 - // let binding "print-length" - tmp46 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_length_STAR_) - var v47 any = tmp46 - _ = v47 - var tmp48 any - { // let - // let binding "G__194" - var v49 any = v33 - _ = v49 - // let binding "print-length" - var v50 any = v47 - _ = v50 - for { - var tmp51 any - { // let - // let binding "vec__198" - var v52 any = v49 - _ = v52 - // let binding "seq__199" - tmp53 := checkDerefVar(var_glojure_DOT_core_seq) - tmp54 := lang.Apply(tmp53, []any{v52}) - var v55 any = tmp54 - _ = v55 - // let binding "first__200" - tmp56 := checkDerefVar(var_glojure_DOT_core_first) - tmp57 := lang.Apply(tmp56, []any{v55}) - var v58 any = tmp57 - _ = v58 - // let binding "seq__199" - tmp59 := checkDerefVar(var_glojure_DOT_core_next) - tmp60 := lang.Apply(tmp59, []any{v55}) - var v61 any = tmp60 - _ = v61 - // let binding "x" - var v62 any = v58 - _ = v62 - // let binding "xs" - var v63 any = v61 - _ = v63 - // let binding "print-length" - var v64 any = v50 - _ = v64 - var tmp65 any - tmp66 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) - tmp67 := lang.Apply(tmp66, []any{v64}) - if lang.IsTruthy(tmp67) { - tmp68 := lang.Apply(lang.WriteWriter, []any{v8, "..."}) - tmp65 = tmp68 - } else { - tmp69 := lang.Apply(v4, []any{v62, v8}) - _ = tmp69 - var tmp70 any - if lang.IsTruthy(v63) { - tmp71 := lang.Apply(lang.WriteWriter, []any{v8, v5}) - _ = tmp71 - var tmp72 any = v63 - tmp74 := checkDerefVar(var_glojure_DOT_core_dec) - tmp75 := lang.Apply(tmp74, []any{v64}) - var tmp73 any = tmp75 - v49 = tmp72 - v50 = tmp73 - continue - } else { - } - tmp65 = tmp70 - } - tmp51 = tmp65 - } // end let - tmp48 = tmp51 - break - } - } // end let - tmp32 = tmp48 - } // end let - tmp30 = tmp32 - } else { - var tmp33 any - { // let - // let binding "G__204" - var v34 any = v29 - _ = v34 - // let binding "vec__205" - var v35 any = v34 - _ = v35 - // let binding "seq__206" - tmp36 := checkDerefVar(var_glojure_DOT_core_seq) - tmp37 := lang.Apply(tmp36, []any{v35}) - var v38 any = tmp37 - _ = v38 - // let binding "first__207" - tmp39 := checkDerefVar(var_glojure_DOT_core_first) - tmp40 := lang.Apply(tmp39, []any{v38}) - var v41 any = tmp40 - _ = v41 - // let binding "seq__206" - tmp42 := checkDerefVar(var_glojure_DOT_core_next) - tmp43 := lang.Apply(tmp42, []any{v38}) - var v44 any = tmp43 - _ = v44 - // let binding "x" - var v45 any = v41 - _ = v45 - // let binding "xs" - var v46 any = v44 - _ = v46 - var tmp47 any - { // let - // let binding "G__204" - var v48 any = v34 - _ = v48 - for { - var tmp49 any - { // let - // let binding "vec__208" - var v50 any = v48 - _ = v50 - // let binding "seq__209" - tmp51 := checkDerefVar(var_glojure_DOT_core_seq) - tmp52 := lang.Apply(tmp51, []any{v50}) - var v53 any = tmp52 - _ = v53 - // let binding "first__210" - tmp54 := checkDerefVar(var_glojure_DOT_core_first) - tmp55 := lang.Apply(tmp54, []any{v53}) - var v56 any = tmp55 - _ = v56 - // let binding "seq__209" - tmp57 := checkDerefVar(var_glojure_DOT_core_next) - tmp58 := lang.Apply(tmp57, []any{v53}) - var v59 any = tmp58 - _ = v59 - // let binding "x" - var v60 any = v56 - _ = v60 - // let binding "xs" - var v61 any = v59 - _ = v61 - tmp62 := lang.Apply(v4, []any{v60, v8}) - _ = tmp62 - var tmp63 any - if lang.IsTruthy(v61) { - tmp64 := lang.Apply(lang.WriteWriter, []any{v8, v5}) - _ = tmp64 - var tmp65 any = v61 - v48 = tmp65 - continue - } else { - } - tmp49 = tmp63 - } // end let - tmp47 = tmp49 - break - } - } // end let - tmp33 = tmp47 - } // end let - tmp30 = tmp33 - } - tmp28 = tmp30 - } // end let - tmp27 = tmp28 - } else { - } - tmp23 = tmp27 - } // end let - _ = tmp23 - tmp24 := lang.Apply(lang.WriteWriter, []any{v8, v6}) - tmp19 = tmp24 - } - tmp16 = tmp19 - }() - tmp9 = tmp16 - } // end let - return tmp9 + tmp0 := sym_aset_DASH_byte.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx, sym_val), lang.NewVector(sym_array, sym_idx, sym_idx2, sym__AMP_, sym_idxv)), kw_doc, "Sets the value at the index/indices. Works on arrays of byte. Returns val.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(3), kw_line, int(3976), kw_end_DASH_line, int(3978))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_byte) + tmp6 := lang.Apply(tmp5, []any{v4}) + tmp7, _ := lang.FieldOrMethod(nil, "setByte") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setByte is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v2, v3, tmp6}) + _ = tmp8 + return v4 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_byte) + tmp8 := checkDerefVar(var_glojure_DOT_core_aget) + tmp9 := lang.Apply(tmp8, []any{v2, v3}) + tmp10 := lang.Apply(tmp6, []any{tmp7, tmp9, v4, v5}) + return tmp10 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_aset_DASH_byte = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_aset_DASH_byte.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // aset-char + { + tmp0 := sym_aset_DASH_char.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx, sym_val), lang.NewVector(sym_array, sym_idx, sym_idx2, sym__AMP_, sym_idxv)), kw_doc, "Sets the value at the index/indices. Works on arrays of char. Returns val.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(3), kw_line, int(3981), kw_end_DASH_line, int(3983))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_char) + tmp6 := lang.Apply(tmp5, []any{v4}) + tmp7, _ := lang.FieldOrMethod(nil, "setChar") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setChar is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v2, v3, tmp6}) + _ = tmp8 + return v4 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_char) + tmp8 := checkDerefVar(var_glojure_DOT_core_aget) + tmp9 := lang.Apply(tmp8, []any{v2, v3}) + tmp10 := lang.Apply(tmp6, []any{tmp7, tmp9, v4, v5}) + return tmp10 + } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_aset_DASH_char = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_aset_DASH_char.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // print-simple + // aset-double { - tmp0 := sym_print_DASH_simple.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(81), kw_column, int(7), kw_end_DASH_line, int(81), kw_end_DASH_column, int(18), kw_arglists, lang.NewList(lang.NewVector(sym_o, sym_w)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) - tmp6 := lang.Apply(tmp5, []any{v3, v4}) - _ = tmp6 - tmp7 := checkDerefVar(var_glojure_DOT_core_str) - tmp8 := lang.Apply(tmp7, []any{v3}) - tmp9 := lang.Apply(lang.WriteWriter, []any{v4, tmp8}) - return tmp9 + tmp0 := sym_aset_DASH_double.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx, sym_val), lang.NewVector(sym_array, sym_idx, sym_idx2, sym__AMP_, sym_idxv)), kw_doc, "Sets the value at the index/indices. Works on arrays of double. Returns val.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(3), kw_line, int(3966), kw_end_DASH_line, int(3968))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_double) + tmp6 := lang.Apply(tmp5, []any{v4}) + tmp7, _ := lang.FieldOrMethod(nil, "setDouble") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setDouble is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v2, v3, tmp6}) + _ = tmp8 + return v4 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_double) + tmp8 := checkDerefVar(var_glojure_DOT_core_aget) + tmp9 := lang.Apply(tmp8, []any{v2, v3}) + tmp10 := lang.Apply(tmp6, []any{tmp7, tmp9, v4, v5}) + return tmp10 + } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_aset_DASH_double = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_aset_DASH_double.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // print-str + // aset-float { - tmp1 := reflect.TypeOf("") - tmp0 := sym_print_DASH_str.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_xs)), kw_doc, "print to a string, returning it", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(4776), kw_end_DASH_line, int(4776))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_aset_DASH_float.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx, sym_val), lang.NewVector(sym_array, sym_idx, sym_idx2, sym__AMP_, sym_idxv)), kw_doc, "Sets the value at the index/indices. Works on arrays of float. Returns val.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(3), kw_line, int(3961), kw_end_DASH_line, int(3963))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_float) + tmp6 := lang.Apply(tmp5, []any{v4}) + tmp7, _ := lang.FieldOrMethod(nil, "setFloat") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setFloat is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v2, v3, tmp6}) + _ = tmp8 + return v4 default: - checkArity(args, 0) - var v4 any = lang.NewList(args[0:]...) + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] _ = v4 - var tmp5 any - { // let - // let binding "s__0__auto__" - var v6 any = "unimplemented: new with non-constant class type" - _ = v6 - var tmp7 any - { // let - tmp8 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) - tmp9 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) - tmp10 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) - tmp11 := lang.Apply(tmp9, []any{tmp10, v6}) - tmp12 := lang.Apply(tmp8, []any{tmp11}) - _ = tmp12 - var tmp13 any - func() { - defer func() { - tmp14 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) - tmp15 := lang.Apply(tmp14, nil) - _ = tmp15 - }() - tmp16 := checkDerefVar(var_glojure_DOT_core_apply) - tmp17 := checkDerefVar(var_glojure_DOT_core_print) - tmp18 := lang.Apply(tmp16, []any{tmp17, v4}) - _ = tmp18 - tmp19 := checkDerefVar(var_glojure_DOT_core_str) - tmp20 := lang.Apply(tmp19, []any{v6}) - tmp13 = tmp20 - }() - tmp7 = tmp13 - } // end let - tmp5 = tmp7 - } // end let - return tmp5 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_float) + tmp8 := checkDerefVar(var_glojure_DOT_core_aget) + tmp9 := lang.Apply(tmp8, []any{v2, v3}) + tmp10 := lang.Apply(tmp6, []any{tmp7, tmp9, v4, v5}) + return tmp10 } }) - tmp4 := reflect.TypeOf("") - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_aset_DASH_float = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_aset_DASH_float.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // print-tagged-object + // aset-int { - tmp0 := sym_print_DASH_tagged_DASH_object.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(102), kw_column, int(8), kw_end_DASH_line, int(102), kw_end_DASH_column, int(26), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_o, sym_rep, sym_w)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 3) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var tmp6 any - tmp7 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp8 := reflect.TypeOf((*lang.IMeta)(nil)).Elem() - tmp9 := lang.Apply(tmp7, []any{tmp8, v3}) - if lang.IsTruthy(tmp9) { - tmp10 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) - tmp11 := lang.Apply(tmp10, []any{v3, v5}) - tmp6 = tmp11 - } else { + tmp0 := sym_aset_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx, sym_val), lang.NewVector(sym_array, sym_idx, sym_idx2, sym__AMP_, sym_idxv)), kw_doc, "Sets the value at the index/indices. Works on arrays of int. Returns val.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(3), kw_line, int(3946), kw_end_DASH_line, int(3948))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_int) + tmp6 := lang.Apply(tmp5, []any{v4}) + tmp7, _ := lang.FieldOrMethod(nil, "setInt") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setInt is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v2, v3, tmp6}) + _ = tmp8 + return v4 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_int) + tmp8 := checkDerefVar(var_glojure_DOT_core_aget) + tmp9 := lang.Apply(tmp8, []any{v2, v3}) + tmp10 := lang.Apply(tmp6, []any{tmp7, tmp9, v4, v5}) + return tmp10 } - _ = tmp6 - tmp12 := lang.Apply(lang.WriteWriter, []any{v5, "#object["}) - _ = tmp12 - var tmp13 any - { // let - // let binding "c" - tmp14 := checkDerefVar(var_glojure_DOT_core_class) - tmp15 := lang.Apply(tmp14, []any{v3}) - var v16 any = tmp15 - _ = v16 - var tmp17 any - if lang.IsTruthy(false) { - tmp18 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) - tmp19, ok := lang.FieldOrMethod(v16, "Name") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v16, "Name"))) - } - var tmp20 any - switch reflect.TypeOf(tmp19).Kind() { - case reflect.Func: - tmp20 = lang.Apply(tmp19, nil) - default: - tmp20 = tmp19 - } - tmp21 := lang.Apply(tmp18, []any{tmp20, v5}) - tmp17 = tmp21 - } else { - tmp22, ok := lang.FieldOrMethod(v16, "Name") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v16, "Name"))) - } - var tmp23 any - switch reflect.TypeOf(tmp22).Kind() { - case reflect.Func: - tmp23 = lang.Apply(tmp22, nil) - default: - tmp23 = tmp22 - } - tmp24 := lang.Apply(lang.WriteWriter, []any{v5, tmp23}) - tmp17 = tmp24 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_aset_DASH_int = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_aset_DASH_int.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // aset-long + { + tmp0 := sym_aset_DASH_long.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx, sym_val), lang.NewVector(sym_array, sym_idx, sym_idx2, sym__AMP_, sym_idxv)), kw_doc, "Sets the value at the index/indices. Works on arrays of long. Returns val.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(3), kw_line, int(3951), kw_end_DASH_line, int(3953))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_long) + tmp6 := lang.Apply(tmp5, []any{v4}) + tmp7, _ := lang.FieldOrMethod(nil, "setLong") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setLong is not a function"))) } - tmp13 = tmp17 - } // end let - _ = tmp13 - tmp14 := lang.Apply(lang.WriteWriter, []any{v5, " "}) - _ = tmp14 - tmp15 := checkDerefVar(var_glojure_DOT_core_format) - tmp16 := lang.Apply(lang.IdentityHash, []any{v3}) - tmp17 := lang.Apply(tmp15, []any{"0x%x ", tmp16}) - tmp18 := lang.Apply(lang.WriteWriter, []any{v5, tmp17}) - _ = tmp18 - tmp19 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) - tmp20 := lang.Apply(tmp19, []any{v4, v5}) - _ = tmp20 - tmp21 := lang.Apply(lang.WriteWriter, []any{v5, "]"}) - return tmp21 + tmp8 := lang.Apply(tmp7, []any{v2, v3, tmp6}) + _ = tmp8 + return v4 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_long) + tmp8 := checkDerefVar(var_glojure_DOT_core_aget) + tmp9 := lang.Apply(tmp8, []any{v2, v3}) + tmp10 := lang.Apply(tmp6, []any{tmp7, tmp9, v4, v5}) + return tmp10 + } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_aset_DASH_long = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_aset_DASH_long.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // print-throwable + // aset-short { - tmp0 := sym_print_DASH_throwable.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(478), kw_column, int(8), kw_end_DASH_line, int(478), kw_end_DASH_column, int(22), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_o, sym_w)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.Apply(lang.WriteWriter, []any{v4, "#error {\n :cause "}) - _ = tmp5 - var tmp6 any + tmp0 := sym_aset_DASH_short.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx, sym_val), lang.NewVector(sym_array, sym_idx, sym_idx2, sym__AMP_, sym_idxv)), kw_doc, "Sets the value at the index/indices. Works on arrays of short. Returns val.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(3), kw_line, int(3971), kw_end_DASH_line, int(3973))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_short) + tmp6 := lang.Apply(tmp5, []any{v4}) + tmp7, _ := lang.FieldOrMethod(nil, "setShort") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setShort is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v2, v3, tmp6}) + _ = tmp8 + return v4 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_short) + tmp8 := checkDerefVar(var_glojure_DOT_core_aget) + tmp9 := lang.Apply(tmp8, []any{v2, v3}) + tmp10 := lang.Apply(tmp6, []any{tmp7, tmp9, v4, v5}) + return tmp10 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_aset_DASH_short = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_aset_DASH_short.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // assert-valid-fdecl + { + tmp0 := sym_assert_DASH_valid_DASH_fdecl.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_fdecl)), kw_doc, "A good fdecl looks like (([a] ...) ([a b] ...)) near the end of defn.", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(42), kw_column, int(8), kw_line, int(7502), kw_end_DASH_line, int(7502), kw_private, true, kw_dynamic, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_empty_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + tmp6 := lang.Apply(lang.NewIllegalArgumentError, []any{"Parameter declaration missing"}) + panic(tmp6) + } else { + } + _ = tmp3 + var tmp7 any { // let - // let binding "map__253" - tmp7 := checkDerefVar(var_glojure_DOT_core_Throwable_DASH__GT_map) - tmp8 := lang.Apply(tmp7, []any{v3}) - var v9 any = tmp8 - _ = v9 - // let binding "map__253" - var tmp10 any - tmp11 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) - tmp12 := lang.Apply(tmp11, []any{v9}) - if lang.IsTruthy(tmp12) { - var tmp13 any - tmp14 := checkDerefVar(var_glojure_DOT_core_next) - tmp15 := lang.Apply(tmp14, []any{v9}) - if lang.IsTruthy(tmp15) { - tmp16 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) - tmp17 := lang.Apply(tmp16, []any{v9}) - tmp18 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{tmp17}) - tmp13 = tmp18 + // let binding "argdecls" + tmp8 := checkDerefVar(var_glojure_DOT_core_map) + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v10 := args[0] + _ = v10 + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp13 := lang.Apply(tmp12, []any{v10}) + if lang.IsTruthy(tmp13) { + tmp14 := checkDerefVar(var_glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v10}) + tmp11 = tmp15 } else { - var tmp19 any - tmp20 := checkDerefVar(var_glojure_DOT_core_seq) - tmp21 := lang.Apply(tmp20, []any{v9}) - if lang.IsTruthy(tmp21) { - tmp22 := checkDerefVar(var_glojure_DOT_core_first) - tmp23 := lang.Apply(tmp22, []any{v9}) - tmp19 = tmp23 + var tmp16 any + tmp17 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp18 := checkDerefVar(var_glojure_DOT_core_first) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp17, []any{tmp19}) + if lang.IsTruthy(tmp20) { + tmp21 := checkDerefVar(var_glojure_DOT_core_str) + tmp22 := lang.Apply(tmp21, []any{"Invalid signature \"", v10, "\" should be a list"}) + tmp16 = tmp22 } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := lang.Apply(tmp23, []any{"Parameter declaration \"", v10, "\" should be a vector"}) + tmp16 = tmp24 } - tmp13 = tmp19 + tmp25 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp16}) + panic(tmp25) } - tmp10 = tmp13 - } else { - tmp10 = v9 + return tmp11 + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7508), kw_column, int(20), kw_end_DASH_line, int(7517), kw_end_DASH_column, int(59)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) } - var v24 any = tmp10 - _ = v24 - // let binding "cause" - tmp25 := checkDerefVar(var_glojure_DOT_core_get) - tmp26 := lang.Apply(tmp25, []any{v24, kw_cause}) - var v27 any = tmp26 - _ = v27 - // let binding "data" - tmp28 := checkDerefVar(var_glojure_DOT_core_get) - tmp29 := lang.Apply(tmp28, []any{v24, kw_data}) - var v30 any = tmp29 - _ = v30 - // let binding "via" - tmp31 := checkDerefVar(var_glojure_DOT_core_get) - tmp32 := lang.Apply(tmp31, []any{v24, kw_via}) - var v33 any = tmp32 - _ = v33 - // let binding "trace" - tmp34 := checkDerefVar(var_glojure_DOT_core_get) - tmp35 := lang.Apply(tmp34, []any{v24, kw_trace}) - var v36 any = tmp35 - _ = v36 - // let binding "print-via" - var tmp37 lang.FnFunc - tmp37 = lang.NewFnFunc(func(args ...any) any { + tmp12 := lang.Apply(tmp8, []any{tmp11, v2}) + var v13 any = tmp12 + _ = v13 + // let binding "bad-args" + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_remove) + var tmp16 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v38 := args[0] - _ = v38 - tmp39 := lang.Apply(lang.WriteWriter, []any{v4, "{:type "}) - _ = tmp39 - tmp40 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) - tmp41 := lang.Apply(kw_type, []any{v38}) - tmp42 := lang.Apply(tmp40, []any{tmp41, v4}) - _ = tmp42 - tmp43 := lang.Apply(lang.WriteWriter, []any{v4, "\n :message "}) - _ = tmp43 - tmp44 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) - tmp45 := lang.Apply(kw_message, []any{v38}) - tmp46 := lang.Apply(tmp44, []any{tmp45, v4}) - _ = tmp46 - var tmp47 any - { // let - // let binding "temp__0__auto__" - tmp48 := lang.Apply(kw_data, []any{v38}) - var v49 any = tmp48 - _ = v49 - var tmp50 any - if lang.IsTruthy(v49) { - var tmp51 any - { // let - // let binding "data" - var v52 any = v49 - _ = v52 - tmp53 := lang.Apply(lang.WriteWriter, []any{v4, "\n :data "}) - _ = tmp53 - tmp54 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) - tmp55 := lang.Apply(tmp54, []any{v52, v4}) - tmp51 = tmp55 - } // end let - tmp50 = tmp51 - } else { - } - tmp47 = tmp50 - } // end let - _ = tmp47 - var tmp48 any - { // let - // let binding "temp__0__auto__" - tmp49 := lang.Apply(kw_at, []any{v38}) - var v50 any = tmp49 - _ = v50 - var tmp51 any - if lang.IsTruthy(v50) { - var tmp52 any - { // let - // let binding "at" - var v53 any = v50 - _ = v53 - tmp54 := lang.Apply(lang.WriteWriter, []any{v4, "\n :at "}) - _ = tmp54 - tmp55 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) - tmp56 := lang.Apply(kw_at, []any{v38}) - tmp57 := lang.Apply(tmp55, []any{tmp56, v4}) - tmp52 = tmp57 - } // end let - tmp51 = tmp52 - } else { - } - tmp48 = tmp51 - } // end let - _ = tmp48 - tmp49 := lang.Apply(lang.WriteWriter, []any{v4, "}"}) - return tmp49 + v17 := args[0] + _ = v17 + tmp18 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp19 := lang.Apply(tmp18, []any{v17}) + return tmp19 }) - tmp38 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(481), kw_column, int(19), kw_end_DASH_line, int(491), kw_end_DASH_column, int(73)) - tmp39, err := lang.WithMeta(tmp37, tmp38.(lang.IPersistentMap)) + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7519), kw_column, int(31), kw_end_DASH_line, int(7519), kw_end_DASH_column, int(42)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) if err != nil { panic(err) - } - var v40 any = tmp39 - _ = v40 - tmp41 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) - tmp42 := lang.Apply(tmp41, []any{v27, v4}) - _ = tmp42 - var tmp43 any - if lang.IsTruthy(v30) { - tmp44 := lang.Apply(lang.WriteWriter, []any{v4, "\n :data "}) - _ = tmp44 - tmp45 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) - tmp46 := lang.Apply(tmp45, []any{v30, v4}) - tmp43 = tmp46 - } else { - } - _ = tmp43 - var tmp47 any - if lang.IsTruthy(v33) { - tmp48 := lang.Apply(lang.WriteWriter, []any{v4, "\n :via\n ["}) - _ = tmp48 - var tmp49 any - { // let - // let binding "temp__0__auto__" - tmp50 := checkDerefVar(var_glojure_DOT_core_first) - tmp51 := lang.Apply(tmp50, []any{v33}) - var v52 any = tmp51 - _ = v52 - var tmp53 any - if lang.IsTruthy(v52) { - var tmp54 any - { // let - // let binding "fv" - var v55 any = v52 - _ = v55 - tmp56 := lang.Apply(v40, []any{v55}) - _ = tmp56 - var tmp57 any - { // let - // let binding "seq_254" - tmp58 := checkDerefVar(var_glojure_DOT_core_seq) - tmp59 := checkDerefVar(var_glojure_DOT_core_rest) - tmp60 := lang.Apply(tmp59, []any{v33}) - tmp61 := lang.Apply(tmp58, []any{tmp60}) - var v62 any = tmp61 - _ = v62 - // let binding "chunk_255" - var v63 any = nil - _ = v63 - // let binding "count_256" - var v64 any = int64(0) - _ = v64 - // let binding "i_257" - var v65 any = int64(0) - _ = v65 - for { - var tmp66 any - tmp67 := checkDerefVar(var_glojure_DOT_core__LT_) - tmp68 := lang.Apply(tmp67, []any{v65, v64}) - if lang.IsTruthy(tmp68) { - var tmp69 any - { // let - // let binding "v" - tmp70, _ := lang.FieldOrMethod(v63, "nth") - if reflect.TypeOf(tmp70).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) - } - tmp71 := lang.Apply(tmp70, []any{v65}) - var v72 any = tmp71 - _ = v72 - tmp73 := lang.Apply(lang.WriteWriter, []any{v4, "\n "}) - _ = tmp73 - tmp74 := lang.Apply(v40, []any{v72}) - _ = tmp74 - var tmp75 any = v62 - var tmp76 any = v63 - var tmp77 any = v64 - tmp79 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) - tmp80 := lang.Apply(tmp79, []any{v65}) - var tmp78 any = tmp80 - v62 = tmp75 - v63 = tmp76 - v64 = tmp77 - v65 = tmp78 - continue - } // end let - tmp66 = tmp69 - } else { - var tmp70 any - { // let - // let binding "temp__0__auto__" - tmp71 := checkDerefVar(var_glojure_DOT_core_seq) - tmp72 := lang.Apply(tmp71, []any{v62}) - var v73 any = tmp72 - _ = v73 - var tmp74 any - if lang.IsTruthy(v73) { - var tmp75 any - { // let - // let binding "seq_254" - var v76 any = v73 - _ = v76 - var tmp77 any - tmp78 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) - tmp79 := lang.Apply(tmp78, []any{v76}) - if lang.IsTruthy(tmp79) { - var tmp80 any - { // let - // let binding "c__0__auto__" - tmp81 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) - tmp82 := lang.Apply(tmp81, []any{v76}) - var v83 any = tmp82 - _ = v83 - tmp85 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) - tmp86 := lang.Apply(tmp85, []any{v76}) - var tmp84 any = tmp86 - var tmp87 any = v83 - tmp89 := checkDerefVar(var_glojure_DOT_core_int) - tmp90 := checkDerefVar(var_glojure_DOT_core_count) - tmp91 := lang.Apply(tmp90, []any{v83}) - tmp92 := lang.Apply(tmp89, []any{tmp91}) - var tmp88 any = tmp92 - tmp94 := checkDerefVar(var_glojure_DOT_core_int) - tmp95 := lang.Apply(tmp94, []any{int64(0)}) - var tmp93 any = tmp95 - v62 = tmp84 - v63 = tmp87 - v64 = tmp88 - v65 = tmp93 - continue - } // end let - tmp77 = tmp80 - } else { - var tmp81 any - { // let - // let binding "v" - tmp82 := checkDerefVar(var_glojure_DOT_core_first) - tmp83 := lang.Apply(tmp82, []any{v76}) - var v84 any = tmp83 - _ = v84 - tmp85 := lang.Apply(lang.WriteWriter, []any{v4, "\n "}) - _ = tmp85 - tmp86 := lang.Apply(v40, []any{v84}) - _ = tmp86 - tmp88 := checkDerefVar(var_glojure_DOT_core_next) - tmp89 := lang.Apply(tmp88, []any{v76}) - var tmp87 any = tmp89 - var tmp90 any = nil - var tmp91 any = int64(0) - var tmp92 any = int64(0) - v62 = tmp87 - v63 = tmp90 - v64 = tmp91 - v65 = tmp92 - continue - } // end let - tmp77 = tmp81 - } - tmp75 = tmp77 - } // end let - tmp74 = tmp75 - } else { - } - tmp70 = tmp74 - } // end let - tmp66 = tmp70 - } - tmp57 = tmp66 - break - } - } // end let - tmp54 = tmp57 - } // end let - tmp53 = tmp54 - } else { - } - tmp49 = tmp53 - } // end let - _ = tmp49 - tmp50 := lang.Apply(lang.WriteWriter, []any{v4, "]"}) - tmp47 = tmp50 - } else { - } - _ = tmp47 - var tmp51 any - if lang.IsTruthy(v36) { - tmp52 := lang.Apply(lang.WriteWriter, []any{v4, "\n :trace\n ["}) - _ = tmp52 - var tmp53 any - { // let - // let binding "temp__0__auto__" - tmp54 := checkDerefVar(var_glojure_DOT_core_first) - tmp55 := lang.Apply(tmp54, []any{v36}) - var v56 any = tmp55 - _ = v56 - var tmp57 any - if lang.IsTruthy(v56) { - var tmp58 any - { // let - // let binding "ft" - var v59 any = v56 - _ = v59 - tmp60 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) - tmp61 := lang.Apply(tmp60, []any{v59, v4}) - _ = tmp61 - var tmp62 any - { // let - // let binding "seq_258" - tmp63 := checkDerefVar(var_glojure_DOT_core_seq) - tmp64 := checkDerefVar(var_glojure_DOT_core_rest) - tmp65 := lang.Apply(tmp64, []any{v36}) - tmp66 := lang.Apply(tmp63, []any{tmp65}) - var v67 any = tmp66 - _ = v67 - // let binding "chunk_259" - var v68 any = nil - _ = v68 - // let binding "count_260" - var v69 any = int64(0) - _ = v69 - // let binding "i_261" - var v70 any = int64(0) - _ = v70 - for { - var tmp71 any - tmp72 := checkDerefVar(var_glojure_DOT_core__LT_) - tmp73 := lang.Apply(tmp72, []any{v70, v69}) - if lang.IsTruthy(tmp73) { - var tmp74 any - { // let - // let binding "t" - tmp75, _ := lang.FieldOrMethod(v68, "nth") - if reflect.TypeOf(tmp75).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) - } - tmp76 := lang.Apply(tmp75, []any{v70}) - var v77 any = tmp76 - _ = v77 - tmp78 := lang.Apply(lang.WriteWriter, []any{v4, "\n "}) - _ = tmp78 - tmp79 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) - tmp80 := lang.Apply(tmp79, []any{v77, v4}) - _ = tmp80 - var tmp81 any = v67 - var tmp82 any = v68 - var tmp83 any = v69 - tmp85 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) - tmp86 := lang.Apply(tmp85, []any{v70}) - var tmp84 any = tmp86 - v67 = tmp81 - v68 = tmp82 - v69 = tmp83 - v70 = tmp84 - continue - } // end let - tmp71 = tmp74 - } else { - var tmp75 any - { // let - // let binding "temp__0__auto__" - tmp76 := checkDerefVar(var_glojure_DOT_core_seq) - tmp77 := lang.Apply(tmp76, []any{v67}) - var v78 any = tmp77 - _ = v78 - var tmp79 any - if lang.IsTruthy(v78) { - var tmp80 any - { // let - // let binding "seq_258" - var v81 any = v78 - _ = v81 - var tmp82 any - tmp83 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) - tmp84 := lang.Apply(tmp83, []any{v81}) - if lang.IsTruthy(tmp84) { - var tmp85 any - { // let - // let binding "c__0__auto__" - tmp86 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) - tmp87 := lang.Apply(tmp86, []any{v81}) - var v88 any = tmp87 - _ = v88 - tmp90 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) - tmp91 := lang.Apply(tmp90, []any{v81}) - var tmp89 any = tmp91 - var tmp92 any = v88 - tmp94 := checkDerefVar(var_glojure_DOT_core_int) - tmp95 := checkDerefVar(var_glojure_DOT_core_count) - tmp96 := lang.Apply(tmp95, []any{v88}) - tmp97 := lang.Apply(tmp94, []any{tmp96}) - var tmp93 any = tmp97 - tmp99 := checkDerefVar(var_glojure_DOT_core_int) - tmp100 := lang.Apply(tmp99, []any{int64(0)}) - var tmp98 any = tmp100 - v67 = tmp89 - v68 = tmp92 - v69 = tmp93 - v70 = tmp98 - continue - } // end let - tmp82 = tmp85 - } else { - var tmp86 any - { // let - // let binding "t" - tmp87 := checkDerefVar(var_glojure_DOT_core_first) - tmp88 := lang.Apply(tmp87, []any{v81}) - var v89 any = tmp88 - _ = v89 - tmp90 := lang.Apply(lang.WriteWriter, []any{v4, "\n "}) - _ = tmp90 - tmp91 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) - tmp92 := lang.Apply(tmp91, []any{v89, v4}) - _ = tmp92 - tmp94 := checkDerefVar(var_glojure_DOT_core_next) - tmp95 := lang.Apply(tmp94, []any{v81}) - var tmp93 any = tmp95 - var tmp96 any = nil - var tmp97 any = int64(0) - var tmp98 any = int64(0) - v67 = tmp93 - v68 = tmp96 - v69 = tmp97 - v70 = tmp98 - continue - } // end let - tmp82 = tmp86 - } - tmp80 = tmp82 - } // end let - tmp79 = tmp80 - } else { - } - tmp75 = tmp79 - } // end let - tmp71 = tmp75 - } - tmp62 = tmp71 - break - } - } // end let - tmp58 = tmp62 - } // end let - tmp57 = tmp58 - } else { - } - tmp53 = tmp57 - } // end let - _ = tmp53 - tmp54 := lang.Apply(lang.WriteWriter, []any{v4, "]"}) - tmp51 = tmp54 + } + tmp19 := lang.Apply(tmp15, []any{tmp18, v13}) + tmp20 := lang.Apply(tmp14, []any{tmp19}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + if lang.IsTruthy(v21) { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v21}) + tmp26 := lang.Apply(tmp23, []any{"Parameter declaration \"", tmp25, "\" should be a vector"}) + tmp27 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp26}) + panic(tmp27) } else { } - tmp6 = tmp51 + tmp7 = tmp22 } // end let - _ = tmp6 - tmp7 := lang.Apply(lang.WriteWriter, []any{v4, "}"}) return tmp7 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_assert_DASH_valid_DASH_fdecl = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_assert_DASH_valid_DASH_fdecl.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // printf + // atom { - tmp0 := sym_printf.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_fmt, sym__AMP_, sym_args)), kw_doc, "Prints formatted output, as per format", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(5725), kw_end_DASH_line, int(5725))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_atom.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym__AMP_, sym_options)), kw_doc, "Creates and returns an Atom with an initial value of x and zero or\n more options (in any order):\n\n :meta metadata-map\n\n :validator validate-fn\n\n If metadata-map is supplied, it will become the metadata on the\n atom. validate-fn must be nil or a side-effect-free fn of one\n argument, which will be passed the intended new state on any state\n change. If the new state is unacceptable, the validate-fn should\n return false or throw an exception.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(2325), kw_end_DASH_line, int(2325))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(lang.NewAtom, []any{v2}) + return tmp3 default: checkArity(args, 1) - v3 := args[0] + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) _ = v3 - var v4 any = lang.NewList(args[1:]...) - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_print) - tmp6 := checkDerefVar(var_glojure_DOT_core_apply) - tmp7 := checkDerefVar(var_glojure_DOT_core_format) - tmp8 := lang.Apply(tmp6, []any{tmp7, v3, v4}) - tmp9 := lang.Apply(tmp5, []any{tmp8}) - return tmp9 + tmp4 := checkDerefVar(var_glojure_DOT_core_setup_DASH_reference) + tmp5 := checkDerefVar(var_glojure_DOT_core_atom) + tmp6 := lang.Apply(tmp5, []any{v2}) + tmp7 := lang.Apply(tmp4, []any{tmp6, v3}) + return tmp7 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_atom = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_atom.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // println + // binding { - tmp0 := sym_println.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_more)), kw_doc, "Same as print followed by (newline)", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(3734), kw_end_DASH_line, int(3734))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_binding.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "binding => var-symbol init-expr\n\n Creates new bindings for the (already-existing) vars, with the\n supplied initial values, executes the exprs in an implicit do, then\n re-establishes the bindings that existed before. The new bindings\n are made in parallel (unlike let); all init-exprs are evaluated\n before the vars are bound to their new values.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(1945), kw_end_DASH_line, int(1945))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) - var v3 any = lang.NewList(args[0:]...) + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - var tmp4 any + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v4}) + if lang.IsTruthy(tmp8) { + } else { + tmp9 := checkDerefVar(var_glojure_DOT_core_str) + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp13 := checkDerefVar(var_glojure_DOT_core_meta) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(kw_line, []any{tmp14}) + tmp16 := lang.Apply(tmp9, []any{tmp11, " requires ", "a vector for its binding", " in ", tmp12, ":", tmp15}) + tmp17 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp16}) + panic(tmp17) + } + _ = tmp6 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_even_QMARK_) + tmp20 := checkDerefVar(var_glojure_DOT_core_count) + tmp21 := lang.Apply(tmp20, []any{v4}) + tmp22 := lang.Apply(tmp19, []any{tmp21}) + if lang.IsTruthy(tmp22) { + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp27 := checkDerefVar(var_glojure_DOT_core_meta) + tmp28 := lang.Apply(tmp27, []any{v2}) + tmp29 := lang.Apply(kw_line, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp25, " requires ", "an even number of forms in binding vector", " in ", tmp26, ":", tmp29}) + tmp31 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp31) + } + _ = tmp18 + var tmp32 any { // let - tmp5 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) - tmp6 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) - tmp7 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_print_DASH_readably_STAR_) - tmp8 := lang.Apply(tmp6, []any{tmp7, nil}) - tmp9 := lang.Apply(tmp5, []any{tmp8}) - _ = tmp9 - var tmp10 any - func() { - defer func() { - tmp11 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) - tmp12 := lang.Apply(tmp11, nil) - _ = tmp12 - }() - tmp13 := checkDerefVar(var_glojure_DOT_core_apply) - tmp14 := checkDerefVar(var_glojure_DOT_core_prn) - tmp15 := lang.Apply(tmp13, []any{tmp14, v3}) - tmp10 = tmp15 - }() - tmp4 = tmp10 + // let binding "var-ize" + var tmp33 lang.FnFunc + tmp33 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v34 := args[0] + _ = v34 + var tmp35 any + { // let + // let binding "ret" + tmp36 := lang.NewVector() + tmp37 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(1959), kw_column, int(30), kw_end_DASH_line, int(1959), kw_end_DASH_column, int(31)) + tmp38, err := lang.WithMeta(tmp36, tmp37.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v39 any = tmp38 + _ = v39 + // let binding "vvs" + tmp40 := checkDerefVar(var_glojure_DOT_core_seq) + tmp41 := lang.Apply(tmp40, []any{v34}) + var v42 any = tmp41 + _ = v42 + for { + var tmp43 any + if lang.IsTruthy(v42) { + tmp45 := checkDerefVar(var_glojure_DOT_core_conj) + tmp46 := checkDerefVar(var_glojure_DOT_core_conj) + tmp47 := checkDerefVar(var_glojure_DOT_core_seq) + tmp48 := checkDerefVar(var_glojure_DOT_core_concat) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) + tmp50 := lang.Apply(tmp49, []any{sym_var}) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := checkDerefVar(var_glojure_DOT_core_first) + tmp53 := lang.Apply(tmp52, []any{v42}) + tmp54 := lang.Apply(tmp51, []any{tmp53}) + tmp55 := lang.Apply(tmp48, []any{tmp50, tmp54}) + tmp56 := lang.Apply(tmp47, []any{tmp55}) + tmp57 := lang.Apply(tmp46, []any{v39, tmp56}) + tmp58 := checkDerefVar(var_glojure_DOT_core_second) + tmp59 := lang.Apply(tmp58, []any{v42}) + tmp60 := lang.Apply(tmp45, []any{tmp57, tmp59}) + var tmp44 any = tmp60 + tmp62 := checkDerefVar(var_glojure_DOT_core_next) + tmp63 := checkDerefVar(var_glojure_DOT_core_next) + tmp64 := lang.Apply(tmp63, []any{v42}) + tmp65 := lang.Apply(tmp62, []any{tmp64}) + var tmp61 any = tmp65 + v39 = tmp44 + v42 = tmp61 + continue + } else { + tmp66 := checkDerefVar(var_glojure_DOT_core_seq) + tmp67 := lang.Apply(tmp66, []any{v39}) + tmp43 = tmp67 + } + tmp35 = tmp43 + break + } + } // end let + return tmp35 + }) + tmp34 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(1958), kw_column, int(17), kw_end_DASH_line, int(1963), kw_end_DASH_column, int(34)) + tmp35, err := lang.WithMeta(tmp33, tmp34.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v36 any = tmp35 + _ = v36 + tmp37 := checkDerefVar(var_glojure_DOT_core_seq) + tmp38 := checkDerefVar(var_glojure_DOT_core_concat) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := lang.Apply(tmp39, []any{sym_glojure_DOT_core_SLASH_let}) + tmp41 := checkDerefVar(var_glojure_DOT_core_list) + tmp42 := checkDerefVar(var_glojure_DOT_core_apply) + tmp43 := checkDerefVar(var_glojure_DOT_core_vector) + tmp44 := checkDerefVar(var_glojure_DOT_core_seq) + tmp45 := checkDerefVar(var_glojure_DOT_core_concat) + tmp46 := lang.Apply(tmp45, nil) + tmp47 := lang.Apply(tmp44, []any{tmp46}) + tmp48 := lang.Apply(tmp42, []any{tmp43, tmp47}) + tmp49 := lang.Apply(tmp41, []any{tmp48}) + tmp50 := checkDerefVar(var_glojure_DOT_core_list) + tmp51 := checkDerefVar(var_glojure_DOT_core_seq) + tmp52 := checkDerefVar(var_glojure_DOT_core_concat) + tmp53 := checkDerefVar(var_glojure_DOT_core_list) + tmp54 := lang.Apply(tmp53, []any{sym_glojure_DOT_core_SLASH_push_DASH_thread_DASH_bindings}) + tmp55 := checkDerefVar(var_glojure_DOT_core_list) + tmp56 := checkDerefVar(var_glojure_DOT_core_seq) + tmp57 := checkDerefVar(var_glojure_DOT_core_concat) + tmp58 := checkDerefVar(var_glojure_DOT_core_list) + tmp59 := lang.Apply(tmp58, []any{sym_glojure_DOT_core_SLASH_hash_DASH_map}) + tmp60 := lang.Apply(v36, []any{v4}) + tmp61 := lang.Apply(tmp57, []any{tmp59, tmp60}) + tmp62 := lang.Apply(tmp56, []any{tmp61}) + tmp63 := lang.Apply(tmp55, []any{tmp62}) + tmp64 := lang.Apply(tmp52, []any{tmp54, tmp63}) + tmp65 := lang.Apply(tmp51, []any{tmp64}) + tmp66 := lang.Apply(tmp50, []any{tmp65}) + tmp67 := checkDerefVar(var_glojure_DOT_core_list) + tmp68 := checkDerefVar(var_glojure_DOT_core_seq) + tmp69 := checkDerefVar(var_glojure_DOT_core_concat) + tmp70 := checkDerefVar(var_glojure_DOT_core_list) + tmp71 := lang.Apply(tmp70, []any{sym_try}) + tmp72 := checkDerefVar(var_glojure_DOT_core_list) + tmp73 := checkDerefVar(var_glojure_DOT_core_seq) + tmp74 := checkDerefVar(var_glojure_DOT_core_concat) + tmp75 := checkDerefVar(var_glojure_DOT_core_list) + tmp76 := lang.Apply(tmp75, []any{sym_finally}) + tmp77 := checkDerefVar(var_glojure_DOT_core_list) + tmp78 := checkDerefVar(var_glojure_DOT_core_seq) + tmp79 := checkDerefVar(var_glojure_DOT_core_concat) + tmp80 := checkDerefVar(var_glojure_DOT_core_list) + tmp81 := lang.Apply(tmp80, []any{sym_glojure_DOT_core_SLASH_pop_DASH_thread_DASH_bindings}) + tmp82 := lang.Apply(tmp79, []any{tmp81}) + tmp83 := lang.Apply(tmp78, []any{tmp82}) + tmp84 := lang.Apply(tmp77, []any{tmp83}) + tmp85 := lang.Apply(tmp74, []any{tmp76, tmp84}) + tmp86 := lang.Apply(tmp73, []any{tmp85}) + tmp87 := lang.Apply(tmp72, []any{tmp86}) + tmp88 := lang.Apply(tmp69, []any{tmp71, v5, tmp87}) + tmp89 := lang.Apply(tmp68, []any{tmp88}) + tmp90 := lang.Apply(tmp67, []any{tmp89}) + tmp91 := lang.Apply(tmp38, []any{tmp40, tmp49, tmp66, tmp90}) + tmp92 := lang.Apply(tmp37, []any{tmp91}) + tmp32 = tmp92 } // end let + return tmp32 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_binding = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_binding.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bound-fn* + { + tmp0 := sym_bound_DASH_fn_STAR_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f)), kw_doc, "Returns a function, which will install the same bindings in effect as in\n the thread at the time bound-fn* was called and then call f with any given\n arguments. This may be used to define a helper function which runs on a\n different thread, but needs the same bindings in place.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(1992), kw_end_DASH_line, int(1992))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "bindings" + tmp4 := checkDerefVar(var_glojure_DOT_core_get_DASH_thread_DASH_bindings) + tmp5 := lang.Apply(tmp4, nil) + var v6 any = tmp5 + _ = v6 + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v8 any = lang.NewList(args[0:]...) + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_apply) + tmp10 := checkDerefVar(var_glojure_DOT_core_with_DASH_bindings_STAR_) + tmp11 := lang.Apply(tmp9, []any{tmp10, v6, v2, v8}) + return tmp11 + } + }) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2001), kw_column, int(5), kw_end_DASH_line, int(2002), kw_end_DASH_column, int(45)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp3 = tmp9 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bound_DASH_fn_STAR_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bound_DASH_fn_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // case-map + { + tmp0 := sym_case_DASH_map.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_case_DASH_f, sym_test_DASH_f, sym_tests, sym_thens)), kw_doc, "Transforms a sequence of test constants and a corresponding sequence of then\n expressions into a sorted map to be consumed by case*. The form of the map\n entries are {(case-f test) [(test-f test) then]}.", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(8), kw_line, int(6614), kw_end_DASH_line, int(6614), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_into1) + tmp7 := checkDerefVar(var_glojure_DOT_core_sorted_DASH_map) + tmp8 := lang.Apply(tmp7, nil) + tmp9 := checkDerefVar(var_glojure_DOT_core_zipmap) + tmp10 := checkDerefVar(var_glojure_DOT_core_map) + tmp11 := lang.Apply(tmp10, []any{v2, v4}) + tmp12 := checkDerefVar(var_glojure_DOT_core_map) + tmp13 := checkDerefVar(var_glojure_DOT_core_vector) + tmp14 := checkDerefVar(var_glojure_DOT_core_map) + tmp15 := lang.Apply(tmp14, []any{v3, v4}) + tmp16 := lang.Apply(tmp12, []any{tmp13, tmp15, v5}) + tmp17 := lang.Apply(tmp9, []any{tmp11, tmp16}) + tmp18 := lang.Apply(tmp6, []any{tmp8, tmp17}) + return tmp18 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_case_DASH_map = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_case_DASH_map.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // check-valid-options + { + tmp0 := sym_check_DASH_valid_DASH_options.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_options, sym__AMP_, sym_valid_DASH_keys)), kw_doc, "Throws an exception if the given option map contains keys not listed\n as valid, else returns nil.", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(35), kw_column, int(7), kw_line, int(1709), kw_end_DASH_line, int(1709), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_disj) + tmp8 := checkDerefVar(var_glojure_DOT_core_apply) + tmp9 := checkDerefVar(var_glojure_DOT_core_hash_DASH_set) + tmp10 := checkDerefVar(var_glojure_DOT_core_keys) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := lang.Apply(tmp8, []any{tmp9, tmp11}) + tmp13 := lang.Apply(tmp6, []any{tmp7, tmp12, v3}) + tmp14 := lang.Apply(tmp5, []any{tmp13}) + if lang.IsTruthy(tmp14) { + tmp15 := checkDerefVar(var_glojure_DOT_core_apply) + tmp16 := checkDerefVar(var_glojure_DOT_core_str) + tmp17 := checkDerefVar(var_glojure_DOT_core_first) + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := checkDerefVar(var_glojure_DOT_core_map) + var tmp20 lang.FnFunc + tmp20 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v21 := args[0] + _ = v21 + tmp22 := checkDerefVar(var_glojure_DOT_core_str) + tmp23 := lang.Apply(tmp22, []any{", ", v21}) + return tmp23 + }) + tmp21 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(1718), kw_column, int(16), kw_end_DASH_line, int(1718), kw_end_DASH_column, int(28)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp23 := checkDerefVar(var_glojure_DOT_core_rest) + tmp24 := lang.Apply(tmp23, []any{v3}) + tmp25 := lang.Apply(tmp19, []any{tmp22, tmp24}) + tmp26 := lang.Apply(tmp15, []any{tmp16, "Only these options are valid: ", tmp18, tmp25}) + tmp27 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp26}) + panic(tmp27) + } else { + } return tmp4 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_check_DASH_valid_DASH_options = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_check_DASH_valid_DASH_options.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // println-str + // clear-agent-errors { - tmp1 := reflect.TypeOf("") - tmp0 := sym_println_DASH_str.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_xs)), kw_doc, "println to a string, returning it", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(4785), kw_end_DASH_line, int(4785))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_clear_DASH_agent_DASH_errors.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a)), kw_doc, "DEPRECATED: Use 'restart-agent' instead.\n Clears any exceptions thrown during asynchronous actions of the\n agent, allowing subsequent actions to occur.", kw_file, "glojure/core.glj", kw_deprecated, "1.2", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(24), kw_column, int(7), kw_line, int(2244), kw_end_DASH_line, int(2244))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_restart_DASH_agent) + tmp4, ok := lang.FieldOrMethod(v2, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "Deref"))) + } + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { + case reflect.Func: + tmp5 = lang.Apply(tmp4, nil) + default: + tmp5 = tmp4 + } + tmp6 := lang.Apply(tmp3, []any{v2, tmp5}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_clear_DASH_agent_DASH_errors = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_clear_DASH_agent_DASH_errors.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // declare + { + tmp0 := sym_declare.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_names)), kw_doc, "defs the supplied var names with no bindings, useful for making forward declarations.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(2768), kw_end_DASH_line, int(2768))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) - var v4 any = lang.NewList(args[0:]...) + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) _ = v4 - var tmp5 any + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym_do}) + tmp9 := checkDerefVar(var_glojure_DOT_core_map) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v11 := args[0] + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_vary_DASH_meta) + tmp14 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp15 := lang.Apply(tmp13, []any{v11, tmp14, kw_declared, true}) + tmp16 := lang.Apply(tmp12, []any{sym_def, tmp15}) + return tmp16 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2771), kw_column, int(25), kw_end_DASH_line, int(2771), kw_end_DASH_column, int(71)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := lang.Apply(tmp9, []any{tmp12, v4}) + tmp14 := lang.Apply(tmp6, []any{tmp8, tmp13}) + tmp15 := lang.Apply(tmp5, []any{tmp14}) + return tmp15 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_declare = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_declare.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // dedupe + { + tmp0 := sym_dedupe.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_coll)), kw_doc, "Returns a lazy sequence removing consecutive duplicates in coll.\n Returns a transducer when no collection is provided.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(7681), kw_end_DASH_line, int(7681))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + var tmp4 any + { // let + // let binding "pv" + tmp5 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) + tmp6 := lang.Apply(tmp5, []any{kw_glojure_DOT_core_SLASH_none}) + var v7 any = tmp6 + _ = v7 + var tmp8 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp9 := lang.Apply(v3, nil) + return tmp9 + case 1: + v9 := args[0] + _ = v9 + tmp10 := lang.Apply(v3, []any{v9}) + return tmp10 + case 2: + v9 := args[0] + _ = v9 + v10 := args[1] + _ = v10 + var tmp11 any + { // let + // let binding "prior" + tmp12 := checkDerefVar(var_glojure_DOT_core_deref) + tmp13 := lang.Apply(tmp12, []any{v7}) + var v14 any = tmp13 + _ = v14 + tmp15 := checkDerefVar(var_glojure_DOT_core_vreset_BANG_) + tmp16 := lang.Apply(tmp15, []any{v7, v10}) + _ = tmp16 + var tmp17 any + tmp18 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp19 := lang.Apply(tmp18, []any{v14, v10}) + if lang.IsTruthy(tmp19) { + tmp17 = v9 + } else { + tmp20 := lang.Apply(v3, []any{v9, v10}) + tmp17 = tmp20 + } + tmp11 = tmp17 + } // end let + return tmp11 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7688), kw_column, int(8), kw_end_DASH_line, int(7696), kw_end_DASH_column, int(37)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp4 = tmp10 + } // end let + return tmp4 + }) + tmp3 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7686), kw_column, int(4), kw_end_DASH_line, int(7696), kw_end_DASH_column, int(39)) + tmp4, err := lang.WithMeta(tmp2, tmp3.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp4 + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_sequence) + tmp4 := checkDerefVar(var_glojure_DOT_core_dedupe) + tmp5 := lang.Apply(tmp4, nil) + tmp6 := lang.Apply(tmp3, []any{tmp5, v2}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_dedupe = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_dedupe.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // defmulti + { + tmp0 := sym_defmulti.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym_docstring_QMARK_, sym_attr_DASH_map_QMARK_, sym_dispatch_DASH_fn, sym__AMP_, sym_options)), kw_doc, "Creates a new multimethod with the associated dispatch function.\n The docstring and attr-map are optional.\n\n Options are key-value pairs and may be one of:\n\n :default\n\n The default dispatch value, defaults to :default\n\n :hierarchy\n\n The value used for hierarchical dispatch (e.g. ::square is-a ::shape)\n\n Hierarchies are type-like relationships that do not depend upon type\n inheritance. By default Clojure's multimethods dispatch off of a\n global hierarchy map. However, a hierarchy relationship can be\n created with the derive function used to augment the root ancestor\n created with make-hierarchy.\n\n Multimethods expect the value of the hierarchy option to be supplied as\n a reference type e.g. a var (i.e. via the Var-quote dispatch macro #'\n or the var special form).", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(11), kw_line, int(1723), kw_end_DASH_line, int(1723))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any { // let - // let binding "s__0__auto__" - var v6 any = "unimplemented: new with non-constant class type" - _ = v6 + // let binding "docstring" var tmp7 any - { // let - tmp8 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) - tmp9 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) - tmp10 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) - tmp11 := lang.Apply(tmp9, []any{tmp10, v6}) - tmp12 := lang.Apply(tmp8, []any{tmp11}) - _ = tmp12 - var tmp13 any - func() { - defer func() { - tmp14 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) - tmp15 := lang.Apply(tmp14, nil) - _ = tmp15 - }() - tmp16 := checkDerefVar(var_glojure_DOT_core_apply) - tmp17 := checkDerefVar(var_glojure_DOT_core_println) - tmp18 := lang.Apply(tmp16, []any{tmp17, v4}) - _ = tmp18 - tmp19 := checkDerefVar(var_glojure_DOT_core_str) - tmp20 := lang.Apply(tmp19, []any{v6}) - tmp13 = tmp20 - }() + tmp8 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp9 := checkDerefVar(var_glojure_DOT_core_first) + tmp10 := lang.Apply(tmp9, []any{v5}) + tmp11 := lang.Apply(tmp8, []any{tmp10}) + if lang.IsTruthy(tmp11) { + tmp12 := checkDerefVar(var_glojure_DOT_core_first) + tmp13 := lang.Apply(tmp12, []any{v5}) tmp7 = tmp13 + } else { + } + var v14 any = tmp7 + _ = v14 + // let binding "options" + var tmp15 any + tmp16 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp17 := checkDerefVar(var_glojure_DOT_core_first) + tmp18 := lang.Apply(tmp17, []any{v5}) + tmp19 := lang.Apply(tmp16, []any{tmp18}) + if lang.IsTruthy(tmp19) { + tmp20 := checkDerefVar(var_glojure_DOT_core_next) + tmp21 := lang.Apply(tmp20, []any{v5}) + tmp15 = tmp21 + } else { + tmp15 = v5 + } + var v22 any = tmp15 + _ = v22 + // let binding "m" + var tmp23 any + tmp24 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp25 := checkDerefVar(var_glojure_DOT_core_first) + tmp26 := lang.Apply(tmp25, []any{v22}) + tmp27 := lang.Apply(tmp24, []any{tmp26}) + if lang.IsTruthy(tmp27) { + tmp28 := checkDerefVar(var_glojure_DOT_core_first) + tmp29 := lang.Apply(tmp28, []any{v22}) + tmp23 = tmp29 + } else { + tmp30 := lang.NewMap() + tmp31 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(1757), kw_column, int(23), kw_end_DASH_line, int(1757), kw_end_DASH_column, int(24)) + tmp32, err := lang.WithMeta(tmp30, tmp31.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp23 = tmp32 + } + var v33 any = tmp23 + _ = v33 + // let binding "options" + var tmp34 any + tmp35 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp36 := checkDerefVar(var_glojure_DOT_core_first) + tmp37 := lang.Apply(tmp36, []any{v22}) + tmp38 := lang.Apply(tmp35, []any{tmp37}) + if lang.IsTruthy(tmp38) { + tmp39 := checkDerefVar(var_glojure_DOT_core_next) + tmp40 := lang.Apply(tmp39, []any{v22}) + tmp34 = tmp40 + } else { + tmp34 = v22 + } + var v41 any = tmp34 + _ = v41 + // let binding "dispatch-fn" + tmp42 := checkDerefVar(var_glojure_DOT_core_first) + tmp43 := lang.Apply(tmp42, []any{v41}) + var v44 any = tmp43 + _ = v44 + // let binding "options" + tmp45 := checkDerefVar(var_glojure_DOT_core_next) + tmp46 := lang.Apply(tmp45, []any{v41}) + var v47 any = tmp46 + _ = v47 + // let binding "m" + var tmp48 any + if lang.IsTruthy(v14) { + tmp49 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp50 := lang.Apply(tmp49, []any{v33, kw_doc, v14}) + tmp48 = tmp50 + } else { + tmp48 = v33 + } + var v51 any = tmp48 + _ = v51 + // let binding "m" + var tmp52 any + tmp53 := checkDerefVar(var_glojure_DOT_core_meta) + tmp54 := lang.Apply(tmp53, []any{v4}) + if lang.IsTruthy(tmp54) { + tmp55 := checkDerefVar(var_glojure_DOT_core_conj) + tmp56 := checkDerefVar(var_glojure_DOT_core_meta) + tmp57 := lang.Apply(tmp56, []any{v4}) + tmp58 := lang.Apply(tmp55, []any{tmp57, v51}) + tmp52 = tmp58 + } else { + tmp52 = v51 + } + var v59 any = tmp52 + _ = v59 + // let binding "mm-name" + tmp60 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp61 := lang.Apply(tmp60, []any{v4, v59}) + var v62 any = tmp61 + _ = v62 + var tmp63 any + tmp64 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp65 := checkDerefVar(var_glojure_DOT_core_count) + tmp66 := lang.Apply(tmp65, []any{v47}) + tmp67 := lang.Apply(tmp64, []any{tmp66, int64(1)}) + if lang.IsTruthy(tmp67) { + tmp68 := lang.Apply(lang.NewError, []any{"The syntax for defmulti has changed. Example: (defmulti name dispatch-fn :default dispatch-value)"}) + panic(tmp68) + } else { + } + _ = tmp63 + var tmp69 any + { // let + // let binding "options" + tmp70 := checkDerefVar(var_glojure_DOT_core_apply) + tmp71 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp72 := lang.Apply(tmp70, []any{tmp71, v47}) + var v73 any = tmp72 + _ = v73 + // let binding "default" + tmp74 := checkDerefVar(var_glojure_DOT_core_get) + tmp75 := lang.Apply(tmp74, []any{v73, kw_default, kw_default}) + var v76 any = tmp75 + _ = v76 + // let binding "hierarchy" + tmp77 := checkDerefVar(var_glojure_DOT_core_get) + tmp78 := lang.InternVarName(sym_glojure_DOT_core, sym_global_DASH_hierarchy) + tmp79 := lang.Apply(tmp77, []any{v73, kw_hierarchy, tmp78}) + var v80 any = tmp79 + _ = v80 + tmp81 := checkDerefVar(var_glojure_DOT_core_check_DASH_valid_DASH_options) + tmp82 := lang.Apply(tmp81, []any{v73, kw_default, kw_hierarchy}) + _ = tmp82 + tmp83 := checkDerefVar(var_glojure_DOT_core_seq) + tmp84 := checkDerefVar(var_glojure_DOT_core_concat) + tmp85 := checkDerefVar(var_glojure_DOT_core_list) + tmp86 := lang.Apply(tmp85, []any{sym_glojure_DOT_core_SLASH_let}) + tmp87 := checkDerefVar(var_glojure_DOT_core_list) + tmp88 := checkDerefVar(var_glojure_DOT_core_apply) + tmp89 := checkDerefVar(var_glojure_DOT_core_vector) + tmp90 := checkDerefVar(var_glojure_DOT_core_seq) + tmp91 := checkDerefVar(var_glojure_DOT_core_concat) + tmp92 := checkDerefVar(var_glojure_DOT_core_list) + tmp93 := lang.Apply(tmp92, []any{sym_v__0__auto__}) + tmp94 := checkDerefVar(var_glojure_DOT_core_list) + tmp95 := checkDerefVar(var_glojure_DOT_core_seq) + tmp96 := checkDerefVar(var_glojure_DOT_core_concat) + tmp97 := checkDerefVar(var_glojure_DOT_core_list) + tmp98 := lang.Apply(tmp97, []any{sym_def}) + tmp99 := checkDerefVar(var_glojure_DOT_core_list) + tmp100 := lang.Apply(tmp99, []any{v62}) + tmp101 := lang.Apply(tmp96, []any{tmp98, tmp100}) + tmp102 := lang.Apply(tmp95, []any{tmp101}) + tmp103 := lang.Apply(tmp94, []any{tmp102}) + tmp104 := lang.Apply(tmp91, []any{tmp93, tmp103}) + tmp105 := lang.Apply(tmp90, []any{tmp104}) + tmp106 := lang.Apply(tmp88, []any{tmp89, tmp105}) + tmp107 := lang.Apply(tmp87, []any{tmp106}) + tmp108 := checkDerefVar(var_glojure_DOT_core_list) + tmp109 := checkDerefVar(var_glojure_DOT_core_seq) + tmp110 := checkDerefVar(var_glojure_DOT_core_concat) + tmp111 := checkDerefVar(var_glojure_DOT_core_list) + tmp112 := lang.Apply(tmp111, []any{sym_glojure_DOT_core_SLASH_when_DASH_not}) + tmp113 := checkDerefVar(var_glojure_DOT_core_list) + tmp114 := checkDerefVar(var_glojure_DOT_core_seq) + tmp115 := checkDerefVar(var_glojure_DOT_core_concat) + tmp116 := checkDerefVar(var_glojure_DOT_core_list) + tmp117 := lang.Apply(tmp116, []any{sym_glojure_DOT_core_SLASH_and}) + tmp118 := checkDerefVar(var_glojure_DOT_core_list) + tmp119 := checkDerefVar(var_glojure_DOT_core_seq) + tmp120 := checkDerefVar(var_glojure_DOT_core_concat) + tmp121 := checkDerefVar(var_glojure_DOT_core_list) + tmp122 := lang.Apply(tmp121, []any{sym__DOT_HasRoot}) + tmp123 := checkDerefVar(var_glojure_DOT_core_list) + tmp124 := lang.Apply(tmp123, []any{sym_v__0__auto__}) + tmp125 := lang.Apply(tmp120, []any{tmp122, tmp124}) + tmp126 := lang.Apply(tmp119, []any{tmp125}) + tmp127 := lang.Apply(tmp118, []any{tmp126}) + tmp128 := checkDerefVar(var_glojure_DOT_core_list) + tmp129 := checkDerefVar(var_glojure_DOT_core_seq) + tmp130 := checkDerefVar(var_glojure_DOT_core_concat) + tmp131 := checkDerefVar(var_glojure_DOT_core_list) + tmp132 := lang.Apply(tmp131, []any{sym_glojure_DOT_core_SLASH_instance_QMARK_}) + tmp133 := checkDerefVar(var_glojure_DOT_core_list) + tmp134 := lang.Apply(tmp133, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT__STAR_MultiFn}) + tmp135 := checkDerefVar(var_glojure_DOT_core_list) + tmp136 := checkDerefVar(var_glojure_DOT_core_seq) + tmp137 := checkDerefVar(var_glojure_DOT_core_concat) + tmp138 := checkDerefVar(var_glojure_DOT_core_list) + tmp139 := lang.Apply(tmp138, []any{sym_glojure_DOT_core_SLASH_deref}) + tmp140 := checkDerefVar(var_glojure_DOT_core_list) + tmp141 := lang.Apply(tmp140, []any{sym_v__0__auto__}) + tmp142 := lang.Apply(tmp137, []any{tmp139, tmp141}) + tmp143 := lang.Apply(tmp136, []any{tmp142}) + tmp144 := lang.Apply(tmp135, []any{tmp143}) + tmp145 := lang.Apply(tmp130, []any{tmp132, tmp134, tmp144}) + tmp146 := lang.Apply(tmp129, []any{tmp145}) + tmp147 := lang.Apply(tmp128, []any{tmp146}) + tmp148 := lang.Apply(tmp115, []any{tmp117, tmp127, tmp147}) + tmp149 := lang.Apply(tmp114, []any{tmp148}) + tmp150 := lang.Apply(tmp113, []any{tmp149}) + tmp151 := checkDerefVar(var_glojure_DOT_core_list) + tmp152 := checkDerefVar(var_glojure_DOT_core_seq) + tmp153 := checkDerefVar(var_glojure_DOT_core_concat) + tmp154 := checkDerefVar(var_glojure_DOT_core_list) + tmp155 := lang.Apply(tmp154, []any{sym_def}) + tmp156 := checkDerefVar(var_glojure_DOT_core_list) + tmp157 := lang.Apply(tmp156, []any{v62}) + tmp158 := checkDerefVar(var_glojure_DOT_core_list) + tmp159 := checkDerefVar(var_glojure_DOT_core_seq) + tmp160 := checkDerefVar(var_glojure_DOT_core_concat) + tmp161 := checkDerefVar(var_glojure_DOT_core_list) + tmp162 := lang.Apply(tmp161, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_NewMultiFn}) + tmp163 := checkDerefVar(var_glojure_DOT_core_list) + tmp164 := checkDerefVar(var_glojure_DOT_core_name) + tmp165 := lang.Apply(tmp164, []any{v62}) + tmp166 := lang.Apply(tmp163, []any{tmp165}) + tmp167 := checkDerefVar(var_glojure_DOT_core_list) + tmp168 := lang.Apply(tmp167, []any{v44}) + tmp169 := checkDerefVar(var_glojure_DOT_core_list) + tmp170 := lang.Apply(tmp169, []any{v76}) + tmp171 := checkDerefVar(var_glojure_DOT_core_list) + tmp172 := lang.Apply(tmp171, []any{v80}) + tmp173 := lang.Apply(tmp160, []any{tmp162, tmp166, tmp168, tmp170, tmp172}) + tmp174 := lang.Apply(tmp159, []any{tmp173}) + tmp175 := lang.Apply(tmp158, []any{tmp174}) + tmp176 := lang.Apply(tmp153, []any{tmp155, tmp157, tmp175}) + tmp177 := lang.Apply(tmp152, []any{tmp176}) + tmp178 := lang.Apply(tmp151, []any{tmp177}) + tmp179 := lang.Apply(tmp110, []any{tmp112, tmp150, tmp178}) + tmp180 := lang.Apply(tmp109, []any{tmp179}) + tmp181 := lang.Apply(tmp108, []any{tmp180}) + tmp182 := lang.Apply(tmp84, []any{tmp86, tmp107, tmp181}) + tmp183 := lang.Apply(tmp83, []any{tmp182}) + tmp69 = tmp183 } // end let - tmp5 = tmp7 + tmp6 = tmp69 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_defmulti = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_defmulti.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // defprotocol + { + tmp0 := sym_defprotocol.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym__AMP_, sym_opts_PLUS_sigs)), kw_doc, "A protocol is a named set of named methods and their signatures:\n (defprotocol AProtocolName\n\n ;optional doc string\n \"A doc string for AProtocol abstraction\"\n\n ;options\n :extend-via-metadata true\n\n ;method signatures\n (bar [this a b] \"bar docs\")\n (baz [this a] [this a b] [this a b c] \"baz docs\"))\n\n No implementations are provided. Docs can be specified for the\n protocol overall and for each method. The above yields a set of\n polymorphic functions and a protocol object. All are\n namespace-qualified by the ns enclosing the definition The resulting\n functions dispatch on the type of their first argument, which is\n required and corresponds to the implicit target object ('this' in \n Java parlance). defprotocol is dynamic, has no special compile-time \n effect, and defines no new types or classes. Implementations of \n the protocol methods can be provided using extend.\n\n When :extend-via-metadata is true, values can extend protocols by\n adding metadata where keys are fully-qualified protocol function\n symbols and values are function implementations. Protocol\n implementations are checked first for direct definitions (defrecord,\n deftype, reify), then metadata definitions, then external\n extensions (extend, extend-type, extend-protocol)\n\n defprotocol will automatically generate a corresponding interface,\n with the same name as the protocol, i.e. given a protocol:\n my.ns/Protocol, an interface: my.ns.Protocol. The interface will\n have methods corresponding to the protocol functions, and the\n protocol will automatically work with instances of the interface.\n\n Note that you should not use this interface with deftype or\n reify, as they support the protocol directly:\n\n (defprotocol P \n (foo [this]) \n (bar-me [this] [this y]))\n\n (deftype Foo [a b c] \n P\n (foo [this] a)\n (bar-me [this] b)\n (bar-me [this y] (+ c y)))\n \n (bar-me (Foo. 1 2 3) 42)\n => 45\n\n (foo \n (let [x 42]\n (reify P \n (foo [this] 17)\n (bar-me [this] x)\n (bar-me [this y] x))))\n => 17", kw_file, "glojure/core_deftype.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(11), kw_line, int(28), kw_end_DASH_line, int(28))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "doc" + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp9 := checkDerefVar(var_glojure_DOT_core_first) + tmp10 := lang.Apply(tmp9, []any{v5}) + tmp11 := lang.Apply(tmp8, []any{tmp10}) + if lang.IsTruthy(tmp11) { + tmp12 := checkDerefVar(var_glojure_DOT_core_first) + tmp13 := lang.Apply(tmp12, []any{v5}) + tmp7 = tmp13 + } else { + } + var v14 any = tmp7 + _ = v14 + // let binding "opts+sigs" + var tmp15 any + if lang.IsTruthy(v14) { + tmp16 := checkDerefVar(var_glojure_DOT_core_rest) + tmp17 := lang.Apply(tmp16, []any{v5}) + tmp15 = tmp17 + } else { + tmp15 = v5 + } + var v18 any = tmp15 + _ = v18 + // let binding "opts" + tmp19 := checkDerefVar(var_glojure_DOT_core_take_DASH_while) + var tmp20 lang.FnFunc + tmp20 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v21 := args[0] + _ = v21 + tmp22 := checkDerefVar(var_glojure_DOT_core_not) + tmp23 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp24 := lang.Apply(tmp23, []any{v21}) + tmp25 := lang.Apply(tmp22, []any{tmp24}) + return tmp25 + }) + tmp21 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(92), kw_column, int(26), kw_end_DASH_line, int(92), kw_end_DASH_column, int(40)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp23 := lang.Apply(tmp19, []any{tmp22, v18}) + var v24 any = tmp23 + _ = v24 + // let binding "sigs" + tmp25 := checkDerefVar(var_glojure_DOT_core_drop_DASH_while) + var tmp26 lang.FnFunc + tmp26 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v27 := args[0] + _ = v27 + tmp28 := checkDerefVar(var_glojure_DOT_core_not) + tmp29 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp30 := lang.Apply(tmp29, []any{v27}) + tmp31 := lang.Apply(tmp28, []any{tmp30}) + return tmp31 + }) + tmp27 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(93), kw_column, int(26), kw_end_DASH_line, int(93), kw_end_DASH_column, int(40)) + tmp28, err := lang.WithMeta(tmp26, tmp27.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp29 := lang.Apply(tmp25, []any{tmp28, v18}) + var v30 any = tmp29 + _ = v30 + // let binding "opts" + var tmp31 any + tmp32 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp33 := lang.Apply(tmp32, []any{v30, v24}) + if lang.IsTruthy(tmp33) { + } else { + tmp31 = v24 + } + var v34 any = tmp31 + _ = v34 + tmp35 := checkDerefVar(var_glojure_DOT_core_seq) + tmp36 := checkDerefVar(var_glojure_DOT_core_concat) + tmp37 := checkDerefVar(var_glojure_DOT_core_list) + tmp38 := lang.Apply(tmp37, []any{sym_do}) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := checkDerefVar(var_glojure_DOT_core_seq) + tmp41 := checkDerefVar(var_glojure_DOT_core_concat) + tmp42 := checkDerefVar(var_glojure_DOT_core_list) + tmp43 := lang.Apply(tmp42, []any{sym_def}) + tmp44 := checkDerefVar(var_glojure_DOT_core_list) + tmp45 := lang.Apply(tmp44, []any{v4}) + tmp46 := checkDerefVar(var_glojure_DOT_core_list) + tmp47 := checkDerefVar(var_glojure_DOT_core_seq) + tmp48 := checkDerefVar(var_glojure_DOT_core_concat) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) + tmp50 := lang.Apply(tmp49, []any{sym_glojure_DOT_core_SLASH_atom}) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := checkDerefVar(var_glojure_DOT_core_apply) + tmp53 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp54 := checkDerefVar(var_glojure_DOT_core_seq) + tmp55 := checkDerefVar(var_glojure_DOT_core_concat) + tmp56 := checkDerefVar(var_glojure_DOT_core_list) + tmp57 := lang.Apply(tmp56, []any{kw_on_DASH_interface}) + tmp58 := checkDerefVar(var_glojure_DOT_core_list) + tmp59 := lang.Apply(tmp58, []any{true}) + tmp60 := checkDerefVar(var_glojure_DOT_core_list) + tmp61 := lang.Apply(tmp60, []any{kw_sigs}) + tmp62 := checkDerefVar(var_glojure_DOT_core_list) + tmp63 := checkDerefVar(var_glojure_DOT_core_seq) + tmp64 := checkDerefVar(var_glojure_DOT_core_concat) + tmp65 := checkDerefVar(var_glojure_DOT_core_list) + tmp66 := lang.Apply(tmp65, []any{sym_quote}) + tmp67 := checkDerefVar(var_glojure_DOT_core_list) + tmp68 := lang.Apply(tmp67, []any{v30}) + tmp69 := lang.Apply(tmp64, []any{tmp66, tmp68}) + tmp70 := lang.Apply(tmp63, []any{tmp69}) + tmp71 := lang.Apply(tmp62, []any{tmp70}) + tmp72 := checkDerefVar(var_glojure_DOT_core_list) + tmp73 := lang.Apply(tmp72, []any{kw_multis}) + tmp74 := checkDerefVar(var_glojure_DOT_core_list) + tmp75 := checkDerefVar(var_glojure_DOT_core_apply) + tmp76 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp77 := checkDerefVar(var_glojure_DOT_core_seq) + tmp78 := checkDerefVar(var_glojure_DOT_core_concat) + tmp79 := lang.Apply(tmp78, nil) + tmp80 := lang.Apply(tmp77, []any{tmp79}) + tmp81 := lang.Apply(tmp75, []any{tmp76, tmp80}) + tmp82 := lang.Apply(tmp74, []any{tmp81}) + tmp83 := lang.Apply(tmp55, []any{tmp57, tmp59, tmp61, tmp71, tmp73, tmp82}) + tmp84 := lang.Apply(tmp54, []any{tmp83}) + tmp85 := lang.Apply(tmp52, []any{tmp53, tmp84}) + tmp86 := lang.Apply(tmp51, []any{tmp85}) + tmp87 := lang.Apply(tmp48, []any{tmp50, tmp86}) + tmp88 := lang.Apply(tmp47, []any{tmp87}) + tmp89 := lang.Apply(tmp46, []any{tmp88}) + tmp90 := lang.Apply(tmp41, []any{tmp43, tmp45, tmp89}) + tmp91 := lang.Apply(tmp40, []any{tmp90}) + tmp92 := lang.Apply(tmp39, []any{tmp91}) + tmp93 := checkDerefVar(var_glojure_DOT_core_list) + tmp94 := checkDerefVar(var_glojure_DOT_core_seq) + tmp95 := checkDerefVar(var_glojure_DOT_core_concat) + tmp96 := checkDerefVar(var_glojure_DOT_core_list) + tmp97 := lang.Apply(tmp96, []any{sym_glojure_DOT_core_SLASH_swap_BANG_}) + tmp98 := checkDerefVar(var_glojure_DOT_core_list) + tmp99 := lang.Apply(tmp98, []any{sym_glojure_DOT_core_SLASH__DASH_protocols}) + tmp100 := checkDerefVar(var_glojure_DOT_core_list) + tmp101 := lang.Apply(tmp100, []any{sym_glojure_DOT_core_SLASH_assoc}) + tmp102 := checkDerefVar(var_glojure_DOT_core_list) + tmp103 := checkDerefVar(var_glojure_DOT_core_seq) + tmp104 := checkDerefVar(var_glojure_DOT_core_concat) + tmp105 := checkDerefVar(var_glojure_DOT_core_list) + tmp106 := lang.Apply(tmp105, []any{sym_quote}) + tmp107 := checkDerefVar(var_glojure_DOT_core_list) + tmp108 := lang.Apply(tmp107, []any{v4}) + tmp109 := lang.Apply(tmp104, []any{tmp106, tmp108}) + tmp110 := lang.Apply(tmp103, []any{tmp109}) + tmp111 := lang.Apply(tmp102, []any{tmp110}) + tmp112 := checkDerefVar(var_glojure_DOT_core_list) + tmp113 := lang.Apply(tmp112, []any{v4}) + tmp114 := lang.Apply(tmp95, []any{tmp97, tmp99, tmp101, tmp111, tmp113}) + tmp115 := lang.Apply(tmp94, []any{tmp114}) + tmp116 := lang.Apply(tmp93, []any{tmp115}) + tmp117 := checkDerefVar(var_glojure_DOT_core_map) + var tmp118 lang.FnFunc + tmp118 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v119 := args[0] + _ = v119 + tmp120 := checkDerefVar(var_glojure_DOT_core_seq) + tmp121 := checkDerefVar(var_glojure_DOT_core_concat) + tmp122 := checkDerefVar(var_glojure_DOT_core_list) + tmp123 := lang.Apply(tmp122, []any{sym_do}) + tmp124 := checkDerefVar(var_glojure_DOT_core_list) + tmp125 := checkDerefVar(var_glojure_DOT_core_seq) + tmp126 := checkDerefVar(var_glojure_DOT_core_concat) + tmp127 := checkDerefVar(var_glojure_DOT_core_list) + tmp128 := lang.Apply(tmp127, []any{sym_glojure_DOT_core_SLASH_defmulti}) + tmp129 := checkDerefVar(var_glojure_DOT_core_list) + tmp130 := checkDerefVar(var_glojure_DOT_core_first) + tmp131 := lang.Apply(tmp130, []any{v119}) + tmp132 := lang.Apply(tmp129, []any{tmp131}) + tmp133 := checkDerefVar(var_glojure_DOT_core_list) + tmp134 := checkDerefVar(var_glojure_DOT_core_seq) + tmp135 := checkDerefVar(var_glojure_DOT_core_concat) + tmp136 := checkDerefVar(var_glojure_DOT_core_list) + tmp137 := lang.Apply(tmp136, []any{sym_glojure_DOT_core_SLASH_fn}) + tmp138 := checkDerefVar(var_glojure_DOT_core_list) + tmp139 := checkDerefVar(var_glojure_DOT_core_apply) + tmp140 := checkDerefVar(var_glojure_DOT_core_vector) + tmp141 := checkDerefVar(var_glojure_DOT_core_seq) + tmp142 := checkDerefVar(var_glojure_DOT_core_concat) + tmp143 := checkDerefVar(var_glojure_DOT_core_list) + tmp144 := lang.Apply(tmp143, []any{sym_this}) + tmp145 := checkDerefVar(var_glojure_DOT_core_list) + tmp146 := lang.Apply(tmp145, []any{sym__AMP_}) + tmp147 := checkDerefVar(var_glojure_DOT_core_list) + tmp148 := lang.Apply(tmp147, []any{sym_args}) + tmp149 := lang.Apply(tmp142, []any{tmp144, tmp146, tmp148}) + tmp150 := lang.Apply(tmp141, []any{tmp149}) + tmp151 := lang.Apply(tmp139, []any{tmp140, tmp150}) + tmp152 := lang.Apply(tmp138, []any{tmp151}) + tmp153 := checkDerefVar(var_glojure_DOT_core_list) + tmp154 := checkDerefVar(var_glojure_DOT_core_seq) + tmp155 := checkDerefVar(var_glojure_DOT_core_concat) + tmp156 := checkDerefVar(var_glojure_DOT_core_list) + tmp157 := lang.Apply(tmp156, []any{sym_glojure_DOT_core_SLASH_class}) + tmp158 := checkDerefVar(var_glojure_DOT_core_list) + tmp159 := lang.Apply(tmp158, []any{sym_this}) + tmp160 := lang.Apply(tmp155, []any{tmp157, tmp159}) + tmp161 := lang.Apply(tmp154, []any{tmp160}) + tmp162 := lang.Apply(tmp153, []any{tmp161}) + tmp163 := lang.Apply(tmp135, []any{tmp137, tmp152, tmp162}) + tmp164 := lang.Apply(tmp134, []any{tmp163}) + tmp165 := lang.Apply(tmp133, []any{tmp164}) + tmp166 := lang.Apply(tmp126, []any{tmp128, tmp132, tmp165}) + tmp167 := lang.Apply(tmp125, []any{tmp166}) + tmp168 := lang.Apply(tmp124, []any{tmp167}) + tmp169 := checkDerefVar(var_glojure_DOT_core_list) + tmp170 := checkDerefVar(var_glojure_DOT_core_seq) + tmp171 := checkDerefVar(var_glojure_DOT_core_concat) + tmp172 := checkDerefVar(var_glojure_DOT_core_list) + tmp173 := lang.Apply(tmp172, []any{sym_glojure_DOT_core_SLASH_swap_BANG_}) + tmp174 := checkDerefVar(var_glojure_DOT_core_list) + tmp175 := lang.Apply(tmp174, []any{v4}) + tmp176 := checkDerefVar(var_glojure_DOT_core_list) + tmp177 := lang.Apply(tmp176, []any{sym_glojure_DOT_core_SLASH_assoc_DASH_in}) + tmp178 := checkDerefVar(var_glojure_DOT_core_list) + tmp179 := checkDerefVar(var_glojure_DOT_core_apply) + tmp180 := checkDerefVar(var_glojure_DOT_core_vector) + tmp181 := checkDerefVar(var_glojure_DOT_core_seq) + tmp182 := checkDerefVar(var_glojure_DOT_core_concat) + tmp183 := checkDerefVar(var_glojure_DOT_core_list) + tmp184 := lang.Apply(tmp183, []any{kw_multis}) + tmp185 := checkDerefVar(var_glojure_DOT_core_list) + tmp186 := checkDerefVar(var_glojure_DOT_core_seq) + tmp187 := checkDerefVar(var_glojure_DOT_core_concat) + tmp188 := checkDerefVar(var_glojure_DOT_core_list) + tmp189 := lang.Apply(tmp188, []any{sym_glojure_DOT_core_SLASH_keyword}) + tmp190 := checkDerefVar(var_glojure_DOT_core_list) + tmp191 := checkDerefVar(var_glojure_DOT_core_seq) + tmp192 := checkDerefVar(var_glojure_DOT_core_concat) + tmp193 := checkDerefVar(var_glojure_DOT_core_list) + tmp194 := lang.Apply(tmp193, []any{sym_quote}) + tmp195 := checkDerefVar(var_glojure_DOT_core_list) + tmp196 := checkDerefVar(var_glojure_DOT_core_first) + tmp197 := lang.Apply(tmp196, []any{v119}) + tmp198 := lang.Apply(tmp195, []any{tmp197}) + tmp199 := lang.Apply(tmp192, []any{tmp194, tmp198}) + tmp200 := lang.Apply(tmp191, []any{tmp199}) + tmp201 := lang.Apply(tmp190, []any{tmp200}) + tmp202 := lang.Apply(tmp187, []any{tmp189, tmp201}) + tmp203 := lang.Apply(tmp186, []any{tmp202}) + tmp204 := lang.Apply(tmp185, []any{tmp203}) + tmp205 := lang.Apply(tmp182, []any{tmp184, tmp204}) + tmp206 := lang.Apply(tmp181, []any{tmp205}) + tmp207 := lang.Apply(tmp179, []any{tmp180, tmp206}) + tmp208 := lang.Apply(tmp178, []any{tmp207}) + tmp209 := checkDerefVar(var_glojure_DOT_core_list) + tmp210 := checkDerefVar(var_glojure_DOT_core_first) + tmp211 := lang.Apply(tmp210, []any{v119}) + tmp212 := lang.Apply(tmp209, []any{tmp211}) + tmp213 := lang.Apply(tmp171, []any{tmp173, tmp175, tmp177, tmp208, tmp212}) + tmp214 := lang.Apply(tmp170, []any{tmp213}) + tmp215 := lang.Apply(tmp169, []any{tmp214}) + tmp216 := lang.Apply(tmp121, []any{tmp123, tmp168, tmp215}) + tmp217 := lang.Apply(tmp120, []any{tmp216}) + return tmp217 + }) + tmp119 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(102), kw_column, int(13), kw_end_DASH_line, int(104), kw_end_DASH_column, int(90)) + tmp120, err := lang.WithMeta(tmp118, tmp119.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp121 := lang.Apply(tmp117, []any{tmp120, v30}) + tmp122 := checkDerefVar(var_glojure_DOT_core_list) + tmp123 := checkDerefVar(var_glojure_DOT_core_seq) + tmp124 := checkDerefVar(var_glojure_DOT_core_concat) + tmp125 := checkDerefVar(var_glojure_DOT_core_list) + tmp126 := lang.Apply(tmp125, []any{sym_var}) + tmp127 := checkDerefVar(var_glojure_DOT_core_list) + tmp128 := lang.Apply(tmp127, []any{v4}) + tmp129 := lang.Apply(tmp124, []any{tmp126, tmp128}) + tmp130 := lang.Apply(tmp123, []any{tmp129}) + tmp131 := lang.Apply(tmp122, []any{tmp130}) + tmp132 := lang.Apply(tmp36, []any{tmp38, tmp92, tmp116, tmp121, tmp131}) + tmp133 := lang.Apply(tmp35, []any{tmp132}) + tmp6 = tmp133 } // end let - return tmp5 + return tmp6 } }) - tmp4 := reflect.TypeOf("") - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_defprotocol = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_defprotocol.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // prn + // distinct? { - tmp0 := sym_prn.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_more)), kw_doc, "Same as pr followed by (newline). Observes *flush-on-newline*", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(3715), kw_end_DASH_line, int(3715))).(*lang.Symbol) + tmp1 := reflect.TypeOf(false) + tmp0 := sym_distinct_QMARK_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_doc, "Returns true if no two of the arguments are =", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(5664), kw_end_DASH_line, int(5664))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { + case 1: + v3 := args[0] + _ = v3 + return true + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_not) + tmp6 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp7 := lang.Apply(tmp6, []any{v3, v4}) + tmp8 := lang.Apply(tmp5, []any{tmp7}) + return tmp8 default: - checkArity(args, 0) - var v3 any = lang.NewList(args[0:]...) + checkArity(args, 2) + v3 := args[0] _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_apply) - tmp5 := checkDerefVar(var_glojure_DOT_core_pr) - tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) - _ = tmp6 - tmp7 := checkDerefVar(var_glojure_DOT_core_newline) - tmp8 := lang.Apply(tmp7, nil) - _ = tmp8 - var tmp9 any - tmp10 := checkDerefVar(var_glojure_DOT_core__STAR_flush_DASH_on_DASH_newline_STAR_) - if lang.IsTruthy(tmp10) { - tmp11 := checkDerefVar(var_glojure_DOT_core_flush) - tmp12 := lang.Apply(tmp11, nil) - tmp9 = tmp12 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_not_EQ_) + tmp8 := lang.Apply(tmp7, []any{v3, v4}) + if lang.IsTruthy(tmp8) { + var tmp9 any + { // let + // let binding "s" + tmp10 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{v3, v4})) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5673), kw_column, int(15), kw_end_DASH_line, int(5673), kw_end_DASH_column, int(20)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v13 any = tmp12 + _ = v13 + // let binding "G__99" + var v14 any = v5 + _ = v14 + // let binding "vec__100" + var v15 any = v14 + _ = v15 + // let binding "seq__101" + tmp16 := checkDerefVar(var_glojure_DOT_core_seq) + tmp17 := lang.Apply(tmp16, []any{v15}) + var v18 any = tmp17 + _ = v18 + // let binding "first__102" + tmp19 := checkDerefVar(var_glojure_DOT_core_first) + tmp20 := lang.Apply(tmp19, []any{v18}) + var v21 any = tmp20 + _ = v21 + // let binding "seq__101" + tmp22 := checkDerefVar(var_glojure_DOT_core_next) + tmp23 := lang.Apply(tmp22, []any{v18}) + var v24 any = tmp23 + _ = v24 + // let binding "x" + var v25 any = v21 + _ = v25 + // let binding "etc" + var v26 any = v24 + _ = v26 + // let binding "xs" + var v27 any = v15 + _ = v27 + var tmp28 any + { // let + // let binding "s" + var v29 any = v13 + _ = v29 + // let binding "G__99" + var v30 any = v14 + _ = v30 + for { + var tmp31 any + { // let + // let binding "s" + var v32 any = v29 + _ = v32 + // let binding "vec__103" + var v33 any = v30 + _ = v33 + // let binding "seq__104" + tmp34 := checkDerefVar(var_glojure_DOT_core_seq) + tmp35 := lang.Apply(tmp34, []any{v33}) + var v36 any = tmp35 + _ = v36 + // let binding "first__105" + tmp37 := checkDerefVar(var_glojure_DOT_core_first) + tmp38 := lang.Apply(tmp37, []any{v36}) + var v39 any = tmp38 + _ = v39 + // let binding "seq__104" + tmp40 := checkDerefVar(var_glojure_DOT_core_next) + tmp41 := lang.Apply(tmp40, []any{v36}) + var v42 any = tmp41 + _ = v42 + // let binding "x" + var v43 any = v39 + _ = v43 + // let binding "etc" + var v44 any = v42 + _ = v44 + // let binding "xs" + var v45 any = v33 + _ = v45 + var tmp46 any + if lang.IsTruthy(v45) { + var tmp47 any + tmp48 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp49 := lang.Apply(tmp48, []any{v32, v43}) + if lang.IsTruthy(tmp49) { + tmp47 = false + } else { + tmp51 := checkDerefVar(var_glojure_DOT_core_conj) + tmp52 := lang.Apply(tmp51, []any{v32, v43}) + var tmp50 any = tmp52 + var tmp53 any = v44 + v29 = tmp50 + v30 = tmp53 + continue + } + tmp46 = tmp47 + } else { + tmp46 = true + } + tmp31 = tmp46 + } // end let + tmp28 = tmp31 + break + } + } // end let + tmp9 = tmp28 + } // end let + tmp6 = tmp9 } else { + tmp6 = false } - return tmp9 + return tmp6 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp3 := reflect.TypeOf(false) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_distinct_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_distinct_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // prn-str + // doall { - tmp1 := reflect.TypeOf("") - tmp0 := sym_prn_DASH_str.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_xs)), kw_doc, "prn to a string, returning it", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4767), kw_end_DASH_line, int(4767))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_doall.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll), lang.NewVector(sym_n, sym_coll)), kw_doc, "When lazy sequences are produced via functions that have side\n effects, any effects other than those needed to produce the first\n element in the seq do not occur until the seq is consumed. doall can\n be used to force any effects. Walks through the successive nexts of\n the seq, retains the head and returns it, thus causing the entire\n seq to reside in memory at one time.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3131), kw_end_DASH_line, int(3131))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_dorun) + tmp4 := lang.Apply(tmp3, []any{v2}) + _ = tmp4 + return v2 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_dorun) + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + _ = tmp5 + return v3 default: - checkArity(args, 0) - var v4 any = lang.NewList(args[0:]...) - _ = v4 - var tmp5 any - { // let - // let binding "s__0__auto__" - var v6 any = "unimplemented: new with non-constant class type" - _ = v6 - var tmp7 any - { // let - tmp8 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) - tmp9 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) - tmp10 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) - tmp11 := lang.Apply(tmp9, []any{tmp10, v6}) - tmp12 := lang.Apply(tmp8, []any{tmp11}) - _ = tmp12 - var tmp13 any - func() { - defer func() { - tmp14 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) - tmp15 := lang.Apply(tmp14, nil) - _ = tmp15 - }() - tmp16 := checkDerefVar(var_glojure_DOT_core_apply) - tmp17 := checkDerefVar(var_glojure_DOT_core_prn) - tmp18 := lang.Apply(tmp16, []any{tmp17, v4}) - _ = tmp18 - tmp19 := checkDerefVar(var_glojure_DOT_core_str) - tmp20 := lang.Apply(tmp19, []any{v6}) - tmp13 = tmp20 - }() - tmp7 = tmp13 - } // end let - tmp5 = tmp7 - } // end let - return tmp5 + checkArity(args, -1) + panic("unreachable") } }) - tmp4 := reflect.TypeOf("") - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_doall = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_doall.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // promise + // doseq { - tmp0 := sym_promise.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Returns a promise object that can be read with deref/@, and set,\n once only, with deliver. Calls to deref/@ prior to delivery will\n block, unless the variant of deref with timeout is used. All\n subsequent derefs will return the same delivered value without\n blocking. See also - realized?.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(7078), kw_end_DASH_line, int(7078))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - var tmp3 any - { // let - // let binding "d" - tmp4 := lang.Apply(nil, []any{int64(1)}) - var v5 any = tmp4 + tmp0 := sym_doseq.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_seq_DASH_exprs, sym__AMP_, sym_body)), kw_doc, "Repeatedly executes body (presumably for side-effects) with\n bindings and filtering as provided by \"for\". Does not retain\n the head of the sequence. Returns nil.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(11), kw_line, int(3209), kw_end_DASH_line, int(3209))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) _ = v5 - // let binding "v" - tmp6 := checkDerefVar(var_glojure_DOT_core_atom) - tmp7 := lang.Apply(tmp6, []any{v5}) - var v8 any = tmp7 - _ = v8 - tmp9 := reflect.TypeOf((*lang.IDeref)(nil)).Elem() - tmp10 := checkDerefVar(var_glojure_DOT_core_deref) - tmp11 := lang.NewVector(nil) - tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7091), kw_column, int(15), kw_end_DASH_line, int(7091), kw_end_DASH_column, int(17)) - tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp14, ok := lang.FieldOrMethod(v5, "await") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "await"))) - } - var tmp15 any - switch reflect.TypeOf(tmp14).Kind() { - case reflect.Func: - tmp15 = lang.Apply(tmp14, nil) - default: - tmp15 = tmp14 - } - tmp16 := checkDerefVar(var_glojure_DOT_core_deref) - tmp17 := lang.Apply(tmp16, []any{v8}) - tmp18 := lang.Apply(tmp10, []any{tmp13, tmp15, tmp17}) - tmp19 := reflect.TypeOf((*lang.IBlockingDeref)(nil)).Elem() - tmp20 := checkDerefVar(var_glojure_DOT_core_deref) - tmp21 := lang.NewVector(nil, nil, nil) - tmp22 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7094), kw_column, int(9), kw_end_DASH_line, int(7094), kw_end_DASH_column, int(34)) - tmp23, err := lang.WithMeta(tmp21, tmp22.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var tmp24 any - tmp25, _ := lang.FieldOrMethod(v5, "await") - if reflect.TypeOf(tmp25).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) - } - tmp26 := lang.Apply(tmp25, []any{nil, time10.Millisecond}) - if lang.IsTruthy(tmp26) { - tmp27 := checkDerefVar(var_glojure_DOT_core_deref) - tmp28 := lang.Apply(tmp27, []any{v8}) - tmp24 = tmp28 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v4}) + if lang.IsTruthy(tmp8) { } else { + tmp9 := checkDerefVar(var_glojure_DOT_core_str) + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp13 := checkDerefVar(var_glojure_DOT_core_meta) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(kw_line, []any{tmp14}) + tmp16 := lang.Apply(tmp9, []any{tmp11, " requires ", "a vector for its binding", " in ", tmp12, ":", tmp15}) + tmp17 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp16}) + panic(tmp17) } - tmp29 := lang.Apply(tmp20, []any{tmp23, tmp24}) - tmp30 := reflect.TypeOf((*lang.IPending)(nil)).Elem() - tmp31 := lang.NewVector(nil) - tmp32 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7099), kw_column, int(19), kw_end_DASH_line, int(7099), kw_end_DASH_column, int(24)) - tmp33, err := lang.WithMeta(tmp31, tmp32.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp34 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) - tmp35, ok := lang.FieldOrMethod(v5, "getCount") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "getCount"))) - } - var tmp36 any - switch reflect.TypeOf(tmp35).Kind() { - case reflect.Func: - tmp36 = lang.Apply(tmp35, nil) - default: - tmp36 = tmp35 - } - tmp37 := lang.Apply(tmp34, []any{tmp36}) - tmp38 := lang.Apply(nil, []any{tmp33, tmp37}) - tmp39 := lang.NewVector(nil, nil) - tmp40 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7103), kw_column, int(7), kw_end_DASH_line, int(7103), kw_end_DASH_column, int(14)) - tmp41, err := lang.WithMeta(tmp39, tmp40.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var tmp42 any - var tmp43 any + _ = tmp6 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_even_QMARK_) + tmp20 := checkDerefVar(var_glojure_DOT_core_count) + tmp21 := lang.Apply(tmp20, []any{v4}) + tmp22 := lang.Apply(tmp19, []any{tmp21}) + if lang.IsTruthy(tmp22) { + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp27 := checkDerefVar(var_glojure_DOT_core_meta) + tmp28 := lang.Apply(tmp27, []any{v2}) + tmp29 := lang.Apply(kw_line, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp25, " requires ", "an even number of forms in binding vector", " in ", tmp26, ":", tmp29}) + tmp31 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp31) + } + _ = tmp18 + var tmp32 any { // let - // let binding "and__0__auto__" - tmp44 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) - tmp45, ok := lang.FieldOrMethod(v5, "getCount") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "getCount"))) - } - var tmp46 any - switch reflect.TypeOf(tmp45).Kind() { - case reflect.Func: - tmp46 = lang.Apply(tmp45, nil) - default: - tmp46 = tmp45 + // let binding "step" + var tmp33 lang.FnFunc + { // function step + var v34 lang.FnFunc + tmp33 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v35 := args[0] + _ = v35 + v36 := args[1] + _ = v36 + var tmp37 any + tmp38 := checkDerefVar(var_glojure_DOT_core_not) + tmp39 := lang.Apply(tmp38, []any{v36}) + if lang.IsTruthy(tmp39) { + tmp40 := checkDerefVar(var_glojure_DOT_core_seq) + tmp41 := checkDerefVar(var_glojure_DOT_core_concat) + tmp42 := checkDerefVar(var_glojure_DOT_core_list) + tmp43 := lang.Apply(tmp42, []any{sym_do}) + tmp44 := lang.Apply(tmp41, []any{tmp43, v5}) + tmp45 := lang.Apply(tmp40, []any{tmp44}) + tmp46 := lang.NewVector(true, tmp45) + tmp47 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3220), kw_column, int(18), kw_end_DASH_line, int(3220), kw_end_DASH_column, int(36)) + tmp48, err := lang.WithMeta(tmp46, tmp47.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp37 = tmp48 + } else { + var tmp49 any + { // let + // let binding "k" + tmp50 := checkDerefVar(var_glojure_DOT_core_first) + tmp51 := lang.Apply(tmp50, []any{v36}) + var v52 any = tmp51 + _ = v52 + // let binding "v" + tmp53 := checkDerefVar(var_glojure_DOT_core_second) + tmp54 := lang.Apply(tmp53, []any{v36}) + var v55 any = tmp54 + _ = v55 + var tmp56 any + tmp57 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp58 := lang.Apply(tmp57, []any{v52}) + if lang.IsTruthy(tmp58) { + var tmp59 any + { // let + // let binding "steppair" + tmp60 := checkDerefVar(var_glojure_DOT_core_nnext) + tmp61 := lang.Apply(tmp60, []any{v36}) + tmp62 := lang.Apply(v34, []any{v35, tmp61}) + var v63 any = tmp62 + _ = v63 + // let binding "needrec" + tmp64 := lang.Apply(v63, []any{int64(0)}) + var v65 any = tmp64 + _ = v65 + // let binding "subform" + tmp66 := lang.Apply(v63, []any{int64(1)}) + var v67 any = tmp66 + _ = v67 + var tmp68 any + tmp69 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp70 := lang.Apply(tmp69, []any{v52, kw_let}) + if lang.IsTruthy(tmp70) { + tmp71 := checkDerefVar(var_glojure_DOT_core_seq) + tmp72 := checkDerefVar(var_glojure_DOT_core_concat) + tmp73 := checkDerefVar(var_glojure_DOT_core_list) + tmp74 := lang.Apply(tmp73, []any{sym_glojure_DOT_core_SLASH_let}) + tmp75 := checkDerefVar(var_glojure_DOT_core_list) + tmp76 := lang.Apply(tmp75, []any{v55}) + tmp77 := checkDerefVar(var_glojure_DOT_core_list) + tmp78 := lang.Apply(tmp77, []any{v67}) + tmp79 := lang.Apply(tmp72, []any{tmp74, tmp76, tmp78}) + tmp80 := lang.Apply(tmp71, []any{tmp79}) + tmp81 := lang.NewVector(v65, tmp80) + tmp82 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3228), kw_column, int(37), kw_end_DASH_line, int(3228), kw_end_DASH_column, int(64)) + tmp83, err := lang.WithMeta(tmp81, tmp82.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp68 = tmp83 + } else { + var tmp84 any + tmp85 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp86 := lang.Apply(tmp85, []any{v52, kw_while}) + if lang.IsTruthy(tmp86) { + tmp87 := checkDerefVar(var_glojure_DOT_core_seq) + tmp88 := checkDerefVar(var_glojure_DOT_core_concat) + tmp89 := checkDerefVar(var_glojure_DOT_core_list) + tmp90 := lang.Apply(tmp89, []any{sym_glojure_DOT_core_SLASH_when}) + tmp91 := checkDerefVar(var_glojure_DOT_core_list) + tmp92 := lang.Apply(tmp91, []any{v55}) + tmp93 := checkDerefVar(var_glojure_DOT_core_list) + tmp94 := lang.Apply(tmp93, []any{v67}) + var tmp95 any + if lang.IsTruthy(v65) { + tmp96 := lang.NewVector(v35) + tmp97 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3231), kw_column, int(65), kw_end_DASH_line, int(3231), kw_end_DASH_column, int(73)) + tmp98, err := lang.WithMeta(tmp96, tmp97.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp95 = tmp98 + } else { + } + tmp99 := lang.Apply(tmp88, []any{tmp90, tmp92, tmp94, tmp95}) + tmp100 := lang.Apply(tmp87, []any{tmp99}) + tmp101 := lang.NewVector(false, tmp100) + tmp102 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3229), kw_column, int(39), kw_end_DASH_line, int(3231), kw_end_DASH_column, int(76)) + tmp103, err := lang.WithMeta(tmp101, tmp102.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp84 = tmp103 + } else { + var tmp104 any + tmp105 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp106 := lang.Apply(tmp105, []any{v52, kw_when}) + if lang.IsTruthy(tmp106) { + tmp107 := checkDerefVar(var_glojure_DOT_core_seq) + tmp108 := checkDerefVar(var_glojure_DOT_core_concat) + tmp109 := checkDerefVar(var_glojure_DOT_core_list) + tmp110 := lang.Apply(tmp109, []any{sym_if}) + tmp111 := checkDerefVar(var_glojure_DOT_core_list) + tmp112 := lang.Apply(tmp111, []any{v55}) + tmp113 := checkDerefVar(var_glojure_DOT_core_list) + tmp114 := checkDerefVar(var_glojure_DOT_core_seq) + tmp115 := checkDerefVar(var_glojure_DOT_core_concat) + tmp116 := checkDerefVar(var_glojure_DOT_core_list) + tmp117 := lang.Apply(tmp116, []any{sym_do}) + tmp118 := checkDerefVar(var_glojure_DOT_core_list) + tmp119 := lang.Apply(tmp118, []any{v67}) + var tmp120 any + if lang.IsTruthy(v65) { + tmp121 := lang.NewVector(v35) + tmp122 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3235), kw_column, int(66), kw_end_DASH_line, int(3235), kw_end_DASH_column, int(74)) + tmp123, err := lang.WithMeta(tmp121, tmp122.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp120 = tmp123 + } else { + } + tmp124 := lang.Apply(tmp115, []any{tmp117, tmp119, tmp120}) + tmp125 := lang.Apply(tmp114, []any{tmp124}) + tmp126 := lang.Apply(tmp113, []any{tmp125}) + tmp127 := checkDerefVar(var_glojure_DOT_core_list) + tmp128 := lang.Apply(tmp127, []any{v35}) + tmp129 := lang.Apply(tmp108, []any{tmp110, tmp112, tmp126, tmp128}) + tmp130 := lang.Apply(tmp107, []any{tmp129}) + tmp131 := lang.NewVector(false, tmp130) + tmp132 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3232), kw_column, int(38), kw_end_DASH_line, int(3236), kw_end_DASH_column, int(57)) + tmp133, err := lang.WithMeta(tmp131, tmp132.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp104 = tmp133 + } else { + } + tmp84 = tmp104 + } + tmp68 = tmp84 + } + tmp59 = tmp68 + } // end let + tmp56 = tmp59 + } else { + var tmp60 any + { // let + // let binding "seq-" + tmp61 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp62 := lang.Apply(tmp61, []any{"seq_"}) + var v63 any = tmp62 + _ = v63 + // let binding "chunk-" + tmp64 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp65 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp66 := lang.Apply(tmp65, []any{"chunk_"}) + tmp67 := lang.NewMap(kw_tag, sym_glojure_DOT_lang_DOT_IChunk) + tmp68 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3239), kw_column, int(46), kw_end_DASH_line, int(3239), kw_end_DASH_column, int(72)) + tmp69, err := lang.WithMeta(tmp67, tmp68.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp70 := lang.Apply(tmp64, []any{tmp66, tmp69}) + var v71 any = tmp70 + _ = v71 + // let binding "count-" + tmp72 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp73 := lang.Apply(tmp72, []any{"count_"}) + var v74 any = tmp73 + _ = v74 + // let binding "i-" + tmp75 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp76 := lang.Apply(tmp75, []any{"i_"}) + var v77 any = tmp76 + _ = v77 + // let binding "recform" + tmp78 := checkDerefVar(var_glojure_DOT_core_seq) + tmp79 := checkDerefVar(var_glojure_DOT_core_concat) + tmp80 := checkDerefVar(var_glojure_DOT_core_list) + tmp81 := lang.Apply(tmp80, []any{sym_recur}) + tmp82 := checkDerefVar(var_glojure_DOT_core_list) + tmp83 := checkDerefVar(var_glojure_DOT_core_seq) + tmp84 := checkDerefVar(var_glojure_DOT_core_concat) + tmp85 := checkDerefVar(var_glojure_DOT_core_list) + tmp86 := lang.Apply(tmp85, []any{sym_glojure_DOT_core_SLASH_next}) + tmp87 := checkDerefVar(var_glojure_DOT_core_list) + tmp88 := lang.Apply(tmp87, []any{v63}) + tmp89 := lang.Apply(tmp84, []any{tmp86, tmp88}) + tmp90 := lang.Apply(tmp83, []any{tmp89}) + tmp91 := lang.Apply(tmp82, []any{tmp90}) + tmp92 := checkDerefVar(var_glojure_DOT_core_list) + tmp93 := lang.Apply(tmp92, []any{nil}) + tmp94 := checkDerefVar(var_glojure_DOT_core_list) + tmp95 := lang.Apply(tmp94, []any{int64(0)}) + tmp96 := checkDerefVar(var_glojure_DOT_core_list) + tmp97 := lang.Apply(tmp96, []any{int64(0)}) + tmp98 := lang.Apply(tmp79, []any{tmp81, tmp91, tmp93, tmp95, tmp97}) + tmp99 := lang.Apply(tmp78, []any{tmp98}) + var v100 any = tmp99 + _ = v100 + // let binding "steppair" + tmp101 := checkDerefVar(var_glojure_DOT_core_nnext) + tmp102 := lang.Apply(tmp101, []any{v36}) + tmp103 := lang.Apply(v34, []any{v100, tmp102}) + var v104 any = tmp103 + _ = v104 + // let binding "needrec" + tmp105 := lang.Apply(v104, []any{int64(0)}) + var v106 any = tmp105 + _ = v106 + // let binding "subform" + tmp107 := lang.Apply(v104, []any{int64(1)}) + var v108 any = tmp107 + _ = v108 + // let binding "recform-chunk" + tmp109 := checkDerefVar(var_glojure_DOT_core_seq) + tmp110 := checkDerefVar(var_glojure_DOT_core_concat) + tmp111 := checkDerefVar(var_glojure_DOT_core_list) + tmp112 := lang.Apply(tmp111, []any{sym_recur}) + tmp113 := checkDerefVar(var_glojure_DOT_core_list) + tmp114 := lang.Apply(tmp113, []any{v63}) + tmp115 := checkDerefVar(var_glojure_DOT_core_list) + tmp116 := lang.Apply(tmp115, []any{v71}) + tmp117 := checkDerefVar(var_glojure_DOT_core_list) + tmp118 := lang.Apply(tmp117, []any{v74}) + tmp119 := checkDerefVar(var_glojure_DOT_core_list) + tmp120 := checkDerefVar(var_glojure_DOT_core_seq) + tmp121 := checkDerefVar(var_glojure_DOT_core_concat) + tmp122 := checkDerefVar(var_glojure_DOT_core_list) + tmp123 := lang.Apply(tmp122, []any{sym_glojure_DOT_core_SLASH_unchecked_DASH_inc}) + tmp124 := checkDerefVar(var_glojure_DOT_core_list) + tmp125 := lang.Apply(tmp124, []any{v77}) + tmp126 := lang.Apply(tmp121, []any{tmp123, tmp125}) + tmp127 := lang.Apply(tmp120, []any{tmp126}) + tmp128 := lang.Apply(tmp119, []any{tmp127}) + tmp129 := lang.Apply(tmp110, []any{tmp112, tmp114, tmp116, tmp118, tmp128}) + tmp130 := lang.Apply(tmp109, []any{tmp129}) + var v131 any = tmp130 + _ = v131 + // let binding "steppair-chunk" + tmp132 := checkDerefVar(var_glojure_DOT_core_nnext) + tmp133 := lang.Apply(tmp132, []any{v36}) + tmp134 := lang.Apply(v34, []any{v131, tmp133}) + var v135 any = tmp134 + _ = v135 + // let binding "subform-chunk" + tmp136 := lang.Apply(v135, []any{int64(1)}) + var v137 any = tmp136 + _ = v137 + tmp138 := checkDerefVar(var_glojure_DOT_core_seq) + tmp139 := checkDerefVar(var_glojure_DOT_core_concat) + tmp140 := checkDerefVar(var_glojure_DOT_core_list) + tmp141 := lang.Apply(tmp140, []any{sym_glojure_DOT_core_SLASH_loop}) + tmp142 := checkDerefVar(var_glojure_DOT_core_list) + tmp143 := checkDerefVar(var_glojure_DOT_core_apply) + tmp144 := checkDerefVar(var_glojure_DOT_core_vector) + tmp145 := checkDerefVar(var_glojure_DOT_core_seq) + tmp146 := checkDerefVar(var_glojure_DOT_core_concat) + tmp147 := checkDerefVar(var_glojure_DOT_core_list) + tmp148 := lang.Apply(tmp147, []any{v63}) + tmp149 := checkDerefVar(var_glojure_DOT_core_list) + tmp150 := checkDerefVar(var_glojure_DOT_core_seq) + tmp151 := checkDerefVar(var_glojure_DOT_core_concat) + tmp152 := checkDerefVar(var_glojure_DOT_core_list) + tmp153 := lang.Apply(tmp152, []any{sym_glojure_DOT_core_SLASH_seq}) + tmp154 := checkDerefVar(var_glojure_DOT_core_list) + tmp155 := lang.Apply(tmp154, []any{v55}) + tmp156 := lang.Apply(tmp151, []any{tmp153, tmp155}) + tmp157 := lang.Apply(tmp150, []any{tmp156}) + tmp158 := lang.Apply(tmp149, []any{tmp157}) + tmp159 := checkDerefVar(var_glojure_DOT_core_list) + tmp160 := lang.Apply(tmp159, []any{v71}) + tmp161 := checkDerefVar(var_glojure_DOT_core_list) + tmp162 := lang.Apply(tmp161, []any{nil}) + tmp163 := checkDerefVar(var_glojure_DOT_core_list) + tmp164 := lang.Apply(tmp163, []any{v74}) + tmp165 := checkDerefVar(var_glojure_DOT_core_list) + tmp166 := lang.Apply(tmp165, []any{int64(0)}) + tmp167 := checkDerefVar(var_glojure_DOT_core_list) + tmp168 := lang.Apply(tmp167, []any{v77}) + tmp169 := checkDerefVar(var_glojure_DOT_core_list) + tmp170 := lang.Apply(tmp169, []any{int64(0)}) + tmp171 := lang.Apply(tmp146, []any{tmp148, tmp158, tmp160, tmp162, tmp164, tmp166, tmp168, tmp170}) + tmp172 := lang.Apply(tmp145, []any{tmp171}) + tmp173 := lang.Apply(tmp143, []any{tmp144, tmp172}) + tmp174 := lang.Apply(tmp142, []any{tmp173}) + tmp175 := checkDerefVar(var_glojure_DOT_core_list) + tmp176 := checkDerefVar(var_glojure_DOT_core_seq) + tmp177 := checkDerefVar(var_glojure_DOT_core_concat) + tmp178 := checkDerefVar(var_glojure_DOT_core_list) + tmp179 := lang.Apply(tmp178, []any{sym_if}) + tmp180 := checkDerefVar(var_glojure_DOT_core_list) + tmp181 := checkDerefVar(var_glojure_DOT_core_seq) + tmp182 := checkDerefVar(var_glojure_DOT_core_concat) + tmp183 := checkDerefVar(var_glojure_DOT_core_list) + tmp184 := lang.Apply(tmp183, []any{sym_glojure_DOT_core_SLASH__LT_}) + tmp185 := checkDerefVar(var_glojure_DOT_core_list) + tmp186 := lang.Apply(tmp185, []any{v77}) + tmp187 := checkDerefVar(var_glojure_DOT_core_list) + tmp188 := lang.Apply(tmp187, []any{v74}) + tmp189 := lang.Apply(tmp182, []any{tmp184, tmp186, tmp188}) + tmp190 := lang.Apply(tmp181, []any{tmp189}) + tmp191 := lang.Apply(tmp180, []any{tmp190}) + tmp192 := checkDerefVar(var_glojure_DOT_core_list) + tmp193 := checkDerefVar(var_glojure_DOT_core_seq) + tmp194 := checkDerefVar(var_glojure_DOT_core_concat) + tmp195 := checkDerefVar(var_glojure_DOT_core_list) + tmp196 := lang.Apply(tmp195, []any{sym_glojure_DOT_core_SLASH_let}) + tmp197 := checkDerefVar(var_glojure_DOT_core_list) + tmp198 := checkDerefVar(var_glojure_DOT_core_apply) + tmp199 := checkDerefVar(var_glojure_DOT_core_vector) + tmp200 := checkDerefVar(var_glojure_DOT_core_seq) + tmp201 := checkDerefVar(var_glojure_DOT_core_concat) + tmp202 := checkDerefVar(var_glojure_DOT_core_list) + tmp203 := lang.Apply(tmp202, []any{v52}) + tmp204 := checkDerefVar(var_glojure_DOT_core_list) + tmp205 := checkDerefVar(var_glojure_DOT_core_seq) + tmp206 := checkDerefVar(var_glojure_DOT_core_concat) + tmp207 := checkDerefVar(var_glojure_DOT_core_list) + tmp208 := lang.Apply(tmp207, []any{sym__DOT_nth}) + tmp209 := checkDerefVar(var_glojure_DOT_core_list) + tmp210 := lang.Apply(tmp209, []any{v71}) + tmp211 := checkDerefVar(var_glojure_DOT_core_list) + tmp212 := lang.Apply(tmp211, []any{v77}) + tmp213 := lang.Apply(tmp206, []any{tmp208, tmp210, tmp212}) + tmp214 := lang.Apply(tmp205, []any{tmp213}) + tmp215 := lang.Apply(tmp204, []any{tmp214}) + tmp216 := lang.Apply(tmp201, []any{tmp203, tmp215}) + tmp217 := lang.Apply(tmp200, []any{tmp216}) + tmp218 := lang.Apply(tmp198, []any{tmp199, tmp217}) + tmp219 := lang.Apply(tmp197, []any{tmp218}) + tmp220 := checkDerefVar(var_glojure_DOT_core_list) + tmp221 := lang.Apply(tmp220, []any{v137}) + var tmp222 any + if lang.IsTruthy(v106) { + tmp223 := lang.NewVector(v131) + tmp224 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3256), kw_column, int(48), kw_end_DASH_line, int(3256), kw_end_DASH_column, int(62)) + tmp225, err := lang.WithMeta(tmp223, tmp224.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp222 = tmp225 + } else { + } + tmp226 := lang.Apply(tmp194, []any{tmp196, tmp219, tmp221, tmp222}) + tmp227 := lang.Apply(tmp193, []any{tmp226}) + tmp228 := lang.Apply(tmp192, []any{tmp227}) + tmp229 := checkDerefVar(var_glojure_DOT_core_list) + tmp230 := checkDerefVar(var_glojure_DOT_core_seq) + tmp231 := checkDerefVar(var_glojure_DOT_core_concat) + tmp232 := checkDerefVar(var_glojure_DOT_core_list) + tmp233 := lang.Apply(tmp232, []any{sym_glojure_DOT_core_SLASH_when_DASH_let}) + tmp234 := checkDerefVar(var_glojure_DOT_core_list) + tmp235 := checkDerefVar(var_glojure_DOT_core_apply) + tmp236 := checkDerefVar(var_glojure_DOT_core_vector) + tmp237 := checkDerefVar(var_glojure_DOT_core_seq) + tmp238 := checkDerefVar(var_glojure_DOT_core_concat) + tmp239 := checkDerefVar(var_glojure_DOT_core_list) + tmp240 := lang.Apply(tmp239, []any{v63}) + tmp241 := checkDerefVar(var_glojure_DOT_core_list) + tmp242 := checkDerefVar(var_glojure_DOT_core_seq) + tmp243 := checkDerefVar(var_glojure_DOT_core_concat) + tmp244 := checkDerefVar(var_glojure_DOT_core_list) + tmp245 := lang.Apply(tmp244, []any{sym_glojure_DOT_core_SLASH_seq}) + tmp246 := checkDerefVar(var_glojure_DOT_core_list) + tmp247 := lang.Apply(tmp246, []any{v63}) + tmp248 := lang.Apply(tmp243, []any{tmp245, tmp247}) + tmp249 := lang.Apply(tmp242, []any{tmp248}) + tmp250 := lang.Apply(tmp241, []any{tmp249}) + tmp251 := lang.Apply(tmp238, []any{tmp240, tmp250}) + tmp252 := lang.Apply(tmp237, []any{tmp251}) + tmp253 := lang.Apply(tmp235, []any{tmp236, tmp252}) + tmp254 := lang.Apply(tmp234, []any{tmp253}) + tmp255 := checkDerefVar(var_glojure_DOT_core_list) + tmp256 := checkDerefVar(var_glojure_DOT_core_seq) + tmp257 := checkDerefVar(var_glojure_DOT_core_concat) + tmp258 := checkDerefVar(var_glojure_DOT_core_list) + tmp259 := lang.Apply(tmp258, []any{sym_if}) + tmp260 := checkDerefVar(var_glojure_DOT_core_list) + tmp261 := checkDerefVar(var_glojure_DOT_core_seq) + tmp262 := checkDerefVar(var_glojure_DOT_core_concat) + tmp263 := checkDerefVar(var_glojure_DOT_core_list) + tmp264 := lang.Apply(tmp263, []any{sym_glojure_DOT_core_SLASH_chunked_DASH_seq_QMARK_}) + tmp265 := checkDerefVar(var_glojure_DOT_core_list) + tmp266 := lang.Apply(tmp265, []any{v63}) + tmp267 := lang.Apply(tmp262, []any{tmp264, tmp266}) + tmp268 := lang.Apply(tmp261, []any{tmp267}) + tmp269 := lang.Apply(tmp260, []any{tmp268}) + tmp270 := checkDerefVar(var_glojure_DOT_core_list) + tmp271 := checkDerefVar(var_glojure_DOT_core_seq) + tmp272 := checkDerefVar(var_glojure_DOT_core_concat) + tmp273 := checkDerefVar(var_glojure_DOT_core_list) + tmp274 := lang.Apply(tmp273, []any{sym_glojure_DOT_core_SLASH_let}) + tmp275 := checkDerefVar(var_glojure_DOT_core_list) + tmp276 := checkDerefVar(var_glojure_DOT_core_apply) + tmp277 := checkDerefVar(var_glojure_DOT_core_vector) + tmp278 := checkDerefVar(var_glojure_DOT_core_seq) + tmp279 := checkDerefVar(var_glojure_DOT_core_concat) + tmp280 := checkDerefVar(var_glojure_DOT_core_list) + tmp281 := lang.Apply(tmp280, []any{sym_c__0__auto__}) + tmp282 := checkDerefVar(var_glojure_DOT_core_list) + tmp283 := checkDerefVar(var_glojure_DOT_core_seq) + tmp284 := checkDerefVar(var_glojure_DOT_core_concat) + tmp285 := checkDerefVar(var_glojure_DOT_core_list) + tmp286 := lang.Apply(tmp285, []any{sym_glojure_DOT_core_SLASH_chunk_DASH_first}) + tmp287 := checkDerefVar(var_glojure_DOT_core_list) + tmp288 := lang.Apply(tmp287, []any{v63}) + tmp289 := lang.Apply(tmp284, []any{tmp286, tmp288}) + tmp290 := lang.Apply(tmp283, []any{tmp289}) + tmp291 := lang.Apply(tmp282, []any{tmp290}) + tmp292 := lang.Apply(tmp279, []any{tmp281, tmp291}) + tmp293 := lang.Apply(tmp278, []any{tmp292}) + tmp294 := lang.Apply(tmp276, []any{tmp277, tmp293}) + tmp295 := lang.Apply(tmp275, []any{tmp294}) + tmp296 := checkDerefVar(var_glojure_DOT_core_list) + tmp297 := checkDerefVar(var_glojure_DOT_core_seq) + tmp298 := checkDerefVar(var_glojure_DOT_core_concat) + tmp299 := checkDerefVar(var_glojure_DOT_core_list) + tmp300 := lang.Apply(tmp299, []any{sym_recur}) + tmp301 := checkDerefVar(var_glojure_DOT_core_list) + tmp302 := checkDerefVar(var_glojure_DOT_core_seq) + tmp303 := checkDerefVar(var_glojure_DOT_core_concat) + tmp304 := checkDerefVar(var_glojure_DOT_core_list) + tmp305 := lang.Apply(tmp304, []any{sym_glojure_DOT_core_SLASH_chunk_DASH_rest}) + tmp306 := checkDerefVar(var_glojure_DOT_core_list) + tmp307 := lang.Apply(tmp306, []any{v63}) + tmp308 := lang.Apply(tmp303, []any{tmp305, tmp307}) + tmp309 := lang.Apply(tmp302, []any{tmp308}) + tmp310 := lang.Apply(tmp301, []any{tmp309}) + tmp311 := checkDerefVar(var_glojure_DOT_core_list) + tmp312 := lang.Apply(tmp311, []any{sym_c__0__auto__}) + tmp313 := checkDerefVar(var_glojure_DOT_core_list) + tmp314 := checkDerefVar(var_glojure_DOT_core_seq) + tmp315 := checkDerefVar(var_glojure_DOT_core_concat) + tmp316 := checkDerefVar(var_glojure_DOT_core_list) + tmp317 := lang.Apply(tmp316, []any{sym_glojure_DOT_core_SLASH_int}) + tmp318 := checkDerefVar(var_glojure_DOT_core_list) + tmp319 := checkDerefVar(var_glojure_DOT_core_seq) + tmp320 := checkDerefVar(var_glojure_DOT_core_concat) + tmp321 := checkDerefVar(var_glojure_DOT_core_list) + tmp322 := lang.Apply(tmp321, []any{sym_glojure_DOT_core_SLASH_count}) + tmp323 := checkDerefVar(var_glojure_DOT_core_list) + tmp324 := lang.Apply(tmp323, []any{sym_c__0__auto__}) + tmp325 := lang.Apply(tmp320, []any{tmp322, tmp324}) + tmp326 := lang.Apply(tmp319, []any{tmp325}) + tmp327 := lang.Apply(tmp318, []any{tmp326}) + tmp328 := lang.Apply(tmp315, []any{tmp317, tmp327}) + tmp329 := lang.Apply(tmp314, []any{tmp328}) + tmp330 := lang.Apply(tmp313, []any{tmp329}) + tmp331 := checkDerefVar(var_glojure_DOT_core_list) + tmp332 := checkDerefVar(var_glojure_DOT_core_seq) + tmp333 := checkDerefVar(var_glojure_DOT_core_concat) + tmp334 := checkDerefVar(var_glojure_DOT_core_list) + tmp335 := lang.Apply(tmp334, []any{sym_glojure_DOT_core_SLASH_int}) + tmp336 := checkDerefVar(var_glojure_DOT_core_list) + tmp337 := lang.Apply(tmp336, []any{int64(0)}) + tmp338 := lang.Apply(tmp333, []any{tmp335, tmp337}) + tmp339 := lang.Apply(tmp332, []any{tmp338}) + tmp340 := lang.Apply(tmp331, []any{tmp339}) + tmp341 := lang.Apply(tmp298, []any{tmp300, tmp310, tmp312, tmp330, tmp340}) + tmp342 := lang.Apply(tmp297, []any{tmp341}) + tmp343 := lang.Apply(tmp296, []any{tmp342}) + tmp344 := lang.Apply(tmp272, []any{tmp274, tmp295, tmp343}) + tmp345 := lang.Apply(tmp271, []any{tmp344}) + tmp346 := lang.Apply(tmp270, []any{tmp345}) + tmp347 := checkDerefVar(var_glojure_DOT_core_list) + tmp348 := checkDerefVar(var_glojure_DOT_core_seq) + tmp349 := checkDerefVar(var_glojure_DOT_core_concat) + tmp350 := checkDerefVar(var_glojure_DOT_core_list) + tmp351 := lang.Apply(tmp350, []any{sym_glojure_DOT_core_SLASH_let}) + tmp352 := checkDerefVar(var_glojure_DOT_core_list) + tmp353 := checkDerefVar(var_glojure_DOT_core_apply) + tmp354 := checkDerefVar(var_glojure_DOT_core_vector) + tmp355 := checkDerefVar(var_glojure_DOT_core_seq) + tmp356 := checkDerefVar(var_glojure_DOT_core_concat) + tmp357 := checkDerefVar(var_glojure_DOT_core_list) + tmp358 := lang.Apply(tmp357, []any{v52}) + tmp359 := checkDerefVar(var_glojure_DOT_core_list) + tmp360 := checkDerefVar(var_glojure_DOT_core_seq) + tmp361 := checkDerefVar(var_glojure_DOT_core_concat) + tmp362 := checkDerefVar(var_glojure_DOT_core_list) + tmp363 := lang.Apply(tmp362, []any{sym_glojure_DOT_core_SLASH_first}) + tmp364 := checkDerefVar(var_glojure_DOT_core_list) + tmp365 := lang.Apply(tmp364, []any{v63}) + tmp366 := lang.Apply(tmp361, []any{tmp363, tmp365}) + tmp367 := lang.Apply(tmp360, []any{tmp366}) + tmp368 := lang.Apply(tmp359, []any{tmp367}) + tmp369 := lang.Apply(tmp356, []any{tmp358, tmp368}) + tmp370 := lang.Apply(tmp355, []any{tmp369}) + tmp371 := lang.Apply(tmp353, []any{tmp354, tmp370}) + tmp372 := lang.Apply(tmp352, []any{tmp371}) + tmp373 := checkDerefVar(var_glojure_DOT_core_list) + tmp374 := lang.Apply(tmp373, []any{v108}) + var tmp375 any + if lang.IsTruthy(v106) { + tmp376 := lang.NewVector(v100) + tmp377 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3264), kw_column, int(52), kw_end_DASH_line, int(3264), kw_end_DASH_column, int(60)) + tmp378, err := lang.WithMeta(tmp376, tmp377.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp375 = tmp378 + } else { + } + tmp379 := lang.Apply(tmp349, []any{tmp351, tmp372, tmp374, tmp375}) + tmp380 := lang.Apply(tmp348, []any{tmp379}) + tmp381 := lang.Apply(tmp347, []any{tmp380}) + tmp382 := lang.Apply(tmp257, []any{tmp259, tmp269, tmp346, tmp381}) + tmp383 := lang.Apply(tmp256, []any{tmp382}) + tmp384 := lang.Apply(tmp255, []any{tmp383}) + tmp385 := lang.Apply(tmp231, []any{tmp233, tmp254, tmp384}) + tmp386 := lang.Apply(tmp230, []any{tmp385}) + tmp387 := lang.Apply(tmp229, []any{tmp386}) + tmp388 := lang.Apply(tmp177, []any{tmp179, tmp191, tmp228, tmp387}) + tmp389 := lang.Apply(tmp176, []any{tmp388}) + tmp390 := lang.Apply(tmp175, []any{tmp389}) + tmp391 := lang.Apply(tmp139, []any{tmp141, tmp174, tmp390}) + tmp392 := lang.Apply(tmp138, []any{tmp391}) + tmp393 := lang.NewVector(true, tmp392) + tmp394 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3250), kw_column, int(24), kw_end_DASH_line, int(3264), kw_end_DASH_column, int(67)) + tmp395, err := lang.WithMeta(tmp393, tmp394.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp60 = tmp395 + } // end let + tmp56 = tmp60 + } + tmp49 = tmp56 + } // end let + tmp37 = tmp49 + } + return tmp37 + }) + v34 = tmp33 + _ = v34 } - tmp47 := lang.Apply(tmp44, []any{tmp46}) - var v48 any = tmp47 - _ = v48 - var tmp49 any - if lang.IsTruthy(v48) { - tmp50 := checkDerefVar(var_glojure_DOT_core_compare_DASH_and_DASH_set_BANG_) - tmp51 := lang.Apply(tmp50, []any{v8, v5, nil}) - tmp49 = tmp51 - } else { - tmp49 = v48 + tmp34 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3218), kw_column, int(14), kw_end_DASH_line, int(3264), kw_end_DASH_column, int(72)) + tmp35, err := lang.WithMeta(tmp33, tmp34.(lang.IPersistentMap)) + if err != nil { + panic(err) } - tmp43 = tmp49 + var v36 any = tmp35 + _ = v36 + tmp37 := checkDerefVar(var_glojure_DOT_core_nth) + tmp38 := checkDerefVar(var_glojure_DOT_core_seq) + tmp39 := lang.Apply(tmp38, []any{v4}) + tmp40 := lang.Apply(v36, []any{nil, tmp39}) + tmp41 := lang.Apply(tmp37, []any{tmp40, int64(1)}) + tmp32 = tmp41 } // end let - if lang.IsTruthy(tmp43) { - tmp44, ok := lang.FieldOrMethod(v5, "countDown") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "countDown"))) - } - var tmp45 any - switch reflect.TypeOf(tmp44).Kind() { - case reflect.Func: - tmp45 = lang.Apply(tmp44, nil) - default: - tmp45 = tmp44 - } - _ = tmp45 - } else { - } - tmp46 := lang.Apply(nil, []any{tmp41, tmp42}) - tmp47 := lang.Apply(nil, []any{tmp9, tmp18, tmp19, tmp29, tmp30, tmp38, nil, tmp46}) - tmp3 = tmp47 - } // end let - return tmp3 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // protocol? - { - tmp0 := sym_protocol_QMARK_.WithMeta(lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(110), kw_column, int(8), kw_end_DASH_line, int(110), kw_end_DASH_column, int(16), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_maybe_DASH_p)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp6 := reflect.TypeOf((*lang.IAtom)(nil)).Elem() - tmp7 := lang.Apply(tmp5, []any{tmp6, v3}) - if lang.IsTruthy(tmp7) { - tmp8 := checkDerefVar(var_glojure_DOT_core_boolean) - tmp9 := checkDerefVar(var_glojure_DOT_core_deref) - tmp10 := lang.Apply(tmp9, []any{v3}) - tmp11 := lang.Apply(kw_on_DASH_interface, []any{tmp10}) - tmp12 := lang.Apply(tmp8, []any{tmp11}) - tmp4 = tmp12 - } else { - tmp4 = false + return tmp32 } - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // push-thread-bindings - { - tmp0 := sym_push_DASH_thread_DASH_bindings.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_bindings)), kw_doc, "WARNING: This is a low-level function. Prefer high-level macros like\n binding where ever possible.\n\n Takes a map of Var/value pairs. Binds each Var to the associated value for\n the current thread. Each call *MUST* be accompanied by a matching call to\n pop-thread-bindings wrapped in a try-finally!\n \n (push-thread-bindings bindings)\n (try\n ...\n (finally\n (pop-thread-bindings)))", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(26), kw_column, int(7), kw_line, int(1911), kw_end_DASH_line, int(1911))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := lang.Apply(lang.PushThreadBindings, []any{v3}) - return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_doseq = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_doseq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // pvalues + // doto { - tmp0 := sym_pvalues.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_exprs)), kw_doc, "Returns a lazy sequence of the values of the exprs, which are\n evaluated in parallel", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(7063), kw_end_DASH_line, int(7063))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_doto.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_x, sym__AMP_, sym_forms)), kw_doc, "Evaluates x then calls all of the methods and functions with the\n value of x supplied at the front of the given arguments. The forms\n are evaluated in order. Returns x.\n\n (doto (new java.util.HashMap) (.put \"a\" 1) (.put \"b\" 2))", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(11), kw_line, int(3853), kw_end_DASH_line, int(3853))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) - v3 := args[0] + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[2:]...) + var v5 any = lang.NewList(args[3:]...) _ = v5 - tmp6 := checkDerefVar(var_glojure_DOT_core_seq) - tmp7 := checkDerefVar(var_glojure_DOT_core_concat) - tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_pcalls}) - tmp10 := checkDerefVar(var_glojure_DOT_core_map) - var tmp11 lang.FnFunc - tmp11 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v12 := args[0] - _ = v12 - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.NewVector() - tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7069), kw_column, int(30), kw_end_DASH_line, int(7069), kw_end_DASH_column, int(31)) - tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) + var tmp6 any + { // let + // let binding "gx" + tmp7 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp8 := lang.Apply(tmp7, nil) + var v9 any = tmp8 + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_seq) + tmp11 := checkDerefVar(var_glojure_DOT_core_concat) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_glojure_DOT_core_SLASH_let}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_apply) + tmp16 := checkDerefVar(var_glojure_DOT_core_vector) + tmp17 := checkDerefVar(var_glojure_DOT_core_seq) + tmp18 := checkDerefVar(var_glojure_DOT_core_concat) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v9}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v4}) + tmp23 := lang.Apply(tmp18, []any{tmp20, tmp22}) + tmp24 := lang.Apply(tmp17, []any{tmp23}) + tmp25 := lang.Apply(tmp15, []any{tmp16, tmp24}) + tmp26 := lang.Apply(tmp14, []any{tmp25}) + tmp27 := checkDerefVar(var_glojure_DOT_core_map) + var tmp28 lang.FnFunc + tmp28 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v29 := args[0] + _ = v29 + tmp30 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + var tmp31 any + tmp32 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp33 := lang.Apply(tmp32, []any{v29}) + if lang.IsTruthy(tmp33) { + tmp34 := checkDerefVar(var_glojure_DOT_core_seq) + tmp35 := checkDerefVar(var_glojure_DOT_core_concat) + tmp36 := checkDerefVar(var_glojure_DOT_core_list) + tmp37 := checkDerefVar(var_glojure_DOT_core_first) + tmp38 := lang.Apply(tmp37, []any{v29}) + tmp39 := lang.Apply(tmp36, []any{tmp38}) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{v9}) + tmp42 := checkDerefVar(var_glojure_DOT_core_next) + tmp43 := lang.Apply(tmp42, []any{v29}) + tmp44 := lang.Apply(tmp35, []any{tmp39, tmp41, tmp43}) + tmp45 := lang.Apply(tmp34, []any{tmp44}) + tmp31 = tmp45 + } else { + tmp46 := checkDerefVar(var_glojure_DOT_core_seq) + tmp47 := checkDerefVar(var_glojure_DOT_core_concat) + tmp48 := checkDerefVar(var_glojure_DOT_core_list) + tmp49 := lang.Apply(tmp48, []any{v29}) + tmp50 := checkDerefVar(var_glojure_DOT_core_list) + tmp51 := lang.Apply(tmp50, []any{v9}) + tmp52 := lang.Apply(tmp47, []any{tmp49, tmp51}) + tmp53 := lang.Apply(tmp46, []any{tmp52}) + tmp31 = tmp53 + } + tmp54 := checkDerefVar(var_glojure_DOT_core_meta) + tmp55 := lang.Apply(tmp54, []any{v29}) + tmp56 := lang.Apply(tmp30, []any{tmp31, tmp55}) + return tmp56 + }) + tmp29 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3863), kw_column, int(17), kw_end_DASH_line, int(3868), kw_end_DASH_column, int(30)) + tmp30, err := lang.WithMeta(tmp28, tmp29.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp17 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_fn, tmp16, v12}) - return tmp17 - }) - tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7069), kw_column, int(19), kw_end_DASH_line, int(7069), kw_end_DASH_column, int(34)) - tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp14 := lang.Apply(tmp10, []any{tmp13, v5}) - tmp15 := lang.Apply(tmp7, []any{tmp9, tmp14}) - tmp16 := lang.Apply(tmp6, []any{tmp15}) - return tmp16 + tmp31 := lang.Apply(tmp27, []any{tmp30, v5}) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := lang.Apply(tmp32, []any{v9}) + tmp34 := lang.Apply(tmp11, []any{tmp13, tmp26, tmp31, tmp33}) + tmp35 := lang.Apply(tmp10, []any{tmp34}) + tmp6 = tmp35 + } // end let + return tmp6 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // qualified-ident? - { - tmp0 := sym_qualified_DASH_ident_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a symbol or keyword with a namespace", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(22), kw_column, int(7), kw_line, int(1618), kw_end_DASH_line, int(1618))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_boolean) - var tmp5 any - { // let - // let binding "and__0__auto__" - tmp6 := checkDerefVar(var_glojure_DOT_core_ident_QMARK_) - tmp7 := lang.Apply(tmp6, []any{v3}) - var v8 any = tmp7 - _ = v8 - var tmp9 any - if lang.IsTruthy(v8) { - var tmp10 any - { // let - // let binding "and__0__auto__" - tmp11 := checkDerefVar(var_glojure_DOT_core_namespace) - tmp12 := lang.Apply(tmp11, []any{v3}) - var v13 any = tmp12 - _ = v13 - var tmp14 any - if lang.IsTruthy(v13) { - tmp14 = true - } else { - tmp14 = v13 - } - tmp10 = tmp14 - } // end let - tmp9 = tmp10 - } else { - tmp9 = v8 - } - tmp5 = tmp9 - } // end let - tmp6 := lang.Apply(tmp4, []any{tmp5}) - return tmp6 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_doto = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_doto.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // qualified-keyword? + // drop-last { - tmp0 := sym_qualified_DASH_keyword_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a keyword with a namespace", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(24), kw_column, int(7), kw_line, int(1638), kw_end_DASH_line, int(1638))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_boolean) - var tmp5 any - { // let - // let binding "and__0__auto__" - tmp6 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) - tmp7 := lang.Apply(tmp6, []any{v3}) - var v8 any = tmp7 - _ = v8 - var tmp9 any - if lang.IsTruthy(v8) { - var tmp10 any - { // let - // let binding "and__0__auto__" - tmp11 := checkDerefVar(var_glojure_DOT_core_namespace) - tmp12 := lang.Apply(tmp11, []any{v3}) - var v13 any = tmp12 - _ = v13 - var tmp14 any - if lang.IsTruthy(v13) { - tmp14 = true - } else { - tmp14 = v13 - } - tmp10 = tmp14 - } // end let - tmp9 = tmp10 - } else { - tmp9 = v8 + tmp0 := sym_drop_DASH_last.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll), lang.NewVector(sym_n, sym_coll)), kw_doc, "Return a lazy sequence of all but the last n (default 1) items in coll", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(2932), kw_end_DASH_line, int(2932))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_drop_DASH_last) + tmp4 := lang.Apply(tmp3, []any{int64(1), v2}) + return tmp4 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_map) + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + return v6 + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2937), kw_column, int(18), kw_end_DASH_line, int(2937), kw_end_DASH_column, int(29)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) } - tmp5 = tmp9 - } // end let - tmp6 := lang.Apply(tmp4, []any{tmp5}) - return tmp6 + tmp8 := checkDerefVar(var_glojure_DOT_core_drop) + tmp9 := lang.Apply(tmp8, []any{v2, v3}) + tmp10 := lang.Apply(tmp4, []any{tmp7, v3, tmp9}) + return tmp10 + default: + checkArity(args, -1) + panic("unreachable") + } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_drop_DASH_last = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_drop_DASH_last.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // qualified-symbol? + // emit-extend-protocol { - tmp0 := sym_qualified_DASH_symbol_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a symbol with a namespace", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(7), kw_line, int(1628), kw_end_DASH_line, int(1628))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] + tmp0 := sym_emit_DASH_extend_DASH_protocol.WithMeta(lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(205), kw_column, int(8), kw_end_DASH_line, int(205), kw_end_DASH_column, int(27), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_p, sym_specs)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_boolean) - var tmp5 any + var tmp4 any { // let - // let binding "and__0__auto__" - tmp6 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) - tmp7 := lang.Apply(tmp6, []any{v3}) - var v8 any = tmp7 - _ = v8 - var tmp9 any - if lang.IsTruthy(v8) { - var tmp10 any + // let binding "impls" + tmp5 := checkDerefVar(var_glojure_DOT_core_parse_DASH_impls) + tmp6 := lang.Apply(tmp5, []any{v3}) + var v7 any = tmp6 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_do}) + tmp12 := checkDerefVar(var_glojure_DOT_core_map) + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v14 := args[0] + _ = v14 + var tmp15 any { // let - // let binding "and__0__auto__" - tmp11 := checkDerefVar(var_glojure_DOT_core_namespace) - tmp12 := lang.Apply(tmp11, []any{v3}) - var v13 any = tmp12 - _ = v13 - var tmp14 any - if lang.IsTruthy(v13) { - tmp14 = true - } else { - tmp14 = v13 - } - tmp10 = tmp14 + // let binding "vec__292" + var v16 any = v14 + _ = v16 + // let binding "t" + tmp17 := checkDerefVar(var_glojure_DOT_core_nth) + tmp18 := lang.Apply(tmp17, []any{v16, int64(0), nil}) + var v19 any = tmp18 + _ = v19 + // let binding "fs" + tmp20 := checkDerefVar(var_glojure_DOT_core_nth) + tmp21 := lang.Apply(tmp20, []any{v16, int64(1), nil}) + var v22 any = tmp21 + _ = v22 + tmp23 := checkDerefVar(var_glojure_DOT_core_seq) + tmp24 := checkDerefVar(var_glojure_DOT_core_concat) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := lang.Apply(tmp25, []any{sym_glojure_DOT_core_SLASH_extend_DASH_type}) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{v19}) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{v2}) + tmp31 := lang.Apply(tmp24, []any{tmp26, tmp28, tmp30, v22}) + tmp32 := lang.Apply(tmp23, []any{tmp31}) + tmp15 = tmp32 } // end let - tmp9 = tmp10 - } else { - tmp9 = v8 + return tmp15 + }) + tmp14 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(208), kw_column, int(15), kw_end_DASH_line, int(209), kw_end_DASH_column, int(42)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) } - tmp5 = tmp9 + tmp16 := lang.Apply(tmp12, []any{tmp15, v7}) + tmp17 := lang.Apply(tmp9, []any{tmp11, tmp16}) + tmp18 := lang.Apply(tmp8, []any{tmp17}) + tmp4 = tmp18 } // end let - tmp6 := lang.Apply(tmp4, []any{tmp5}) - return tmp6 + return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_emit_DASH_extend_DASH_protocol = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_emit_DASH_extend_DASH_protocol.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // quot + // emit-hinted-impl { + tmp0 := sym_emit_DASH_hinted_DASH_impl.WithMeta(lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(163), kw_column, int(8), kw_end_DASH_line, int(163), kw_end_DASH_column, int(23), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_c, lang.NewVector(sym_p, sym_fs))), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp1 lang.FnFunc - { // function quot__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_seq) - tmp6 := checkDerefVar(var_glojure_DOT_core_concat) - tmp7 := checkDerefVar(var_glojure_DOT_core_list) - tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) - tmp9 := checkDerefVar(var_glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp11 := checkDerefVar(var_glojure_DOT_core_list) - tmp12 := checkDerefVar(var_glojure_DOT_core_seq) - tmp13 := checkDerefVar(var_glojure_DOT_core_concat) - tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Quotient}) - tmp16 := checkDerefVar(var_glojure_DOT_core_list) - tmp17 := lang.Apply(tmp16, []any{v3}) - tmp18 := checkDerefVar(var_glojure_DOT_core_list) - tmp19 := lang.Apply(tmp18, []any{v4}) - tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) - tmp21 := lang.Apply(tmp12, []any{tmp20}) - tmp22 := lang.Apply(tmp11, []any{tmp21}) - tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) - tmp24 := lang.Apply(tmp5, []any{tmp23}) - return tmp24 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := sym_quot.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_num, sym_div)), kw_inline, tmp1, kw_doc, "quot[ient] of dividing numerator by denominator.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1266), kw_end_DASH_line, int(1266))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 2) - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Quotient") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Quotient is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "vec__281" + var v5 any = v3 + _ = v5 + // let binding "p" + tmp6 := checkDerefVar(var_glojure_DOT_core_nth) + tmp7 := lang.Apply(tmp6, []any{v5, int64(0), nil}) + var v8 any = tmp7 + _ = v8 + // let binding "fs" + tmp9 := checkDerefVar(var_glojure_DOT_core_nth) + tmp10 := lang.Apply(tmp9, []any{v5, int64(1), nil}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + { // let + // let binding "hint" + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v14 := args[0] + _ = v14 + var tmp15 any + { // let + // let binding "specs" + var tmp16 any + tmp17 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp18 := checkDerefVar(var_glojure_DOT_core_first) + tmp19 := lang.Apply(tmp18, []any{v14}) + tmp20 := lang.Apply(tmp17, []any{tmp19}) + if lang.IsTruthy(tmp20) { + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v14}) + tmp16 = tmp22 + } else { + tmp16 = v14 + } + var v23 any = tmp16 + _ = v23 + tmp24 := checkDerefVar(var_glojure_DOT_core_map) + var tmp25 lang.FnFunc + tmp25 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v26 := args[0] + _ = v26 + var tmp27 any + { // let + // let binding "vec__285" + var v28 any = v26 + _ = v28 + // let binding "seq__286" + tmp29 := checkDerefVar(var_glojure_DOT_core_seq) + tmp30 := lang.Apply(tmp29, []any{v28}) + var v31 any = tmp30 + _ = v31 + // let binding "first__287" + tmp32 := checkDerefVar(var_glojure_DOT_core_first) + tmp33 := lang.Apply(tmp32, []any{v31}) + var v34 any = tmp33 + _ = v34 + // let binding "seq__286" + tmp35 := checkDerefVar(var_glojure_DOT_core_next) + tmp36 := lang.Apply(tmp35, []any{v31}) + var v37 any = tmp36 + _ = v37 + // let binding "vec__288" + var v38 any = v34 + _ = v38 + // let binding "seq__289" + tmp39 := checkDerefVar(var_glojure_DOT_core_seq) + tmp40 := lang.Apply(tmp39, []any{v38}) + var v41 any = tmp40 + _ = v41 + // let binding "first__290" + tmp42 := checkDerefVar(var_glojure_DOT_core_first) + tmp43 := lang.Apply(tmp42, []any{v41}) + var v44 any = tmp43 + _ = v44 + // let binding "seq__289" + tmp45 := checkDerefVar(var_glojure_DOT_core_next) + tmp46 := lang.Apply(tmp45, []any{v41}) + var v47 any = tmp46 + _ = v47 + // let binding "target" + var v48 any = v44 + _ = v48 + // let binding "args" + var v49 any = v47 + _ = v49 + // let binding "body" + var v50 any = v37 + _ = v50 + tmp51 := checkDerefVar(var_glojure_DOT_core_cons) + tmp52 := checkDerefVar(var_glojure_DOT_core_apply) + tmp53 := checkDerefVar(var_glojure_DOT_core_vector) + tmp54 := checkDerefVar(var_glojure_DOT_core_vary_DASH_meta) + tmp55 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp56 := lang.Apply(tmp54, []any{v48, tmp55, kw_tag, v2}) + tmp57 := lang.Apply(tmp52, []any{tmp53, tmp56, v49}) + tmp58 := lang.Apply(tmp51, []any{tmp57, v50}) + tmp27 = tmp58 + } // end let + return tmp27 + }) + tmp26 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(168), kw_column, int(23), kw_end_DASH_line, int(170), kw_end_DASH_column, int(36)) + tmp27, err := lang.WithMeta(tmp25, tmp26.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp28 := lang.Apply(tmp24, []any{tmp27, v23}) + tmp15 = tmp28 + } // end let + return tmp15 + }) + tmp14 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(164), kw_column, int(14), kw_end_DASH_line, int(171), kw_end_DASH_column, int(30)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v16 any = tmp15 + _ = v16 + tmp17 := checkDerefVar(var_glojure_DOT_core_zipmap) + tmp18 := checkDerefVar(var_glojure_DOT_core_map) + var tmp19 lang.FnFunc + tmp19 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v20 := args[0] + _ = v20 + tmp21 := checkDerefVar(var_glojure_DOT_core_keyword) + tmp22 := checkDerefVar(var_glojure_DOT_core_name) + tmp23 := checkDerefVar(var_glojure_DOT_core_first) + tmp24 := lang.Apply(tmp23, []any{v20}) + tmp25 := lang.Apply(tmp22, []any{tmp24}) + tmp26 := lang.Apply(tmp21, []any{tmp25}) + return tmp26 + }) + tmp20 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(172), kw_column, int(21), kw_end_DASH_line, int(172), kw_end_DASH_column, int(46)) + tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp22 := lang.Apply(tmp18, []any{tmp21, v11}) + tmp23 := checkDerefVar(var_glojure_DOT_core_map) + var tmp24 lang.FnFunc + tmp24 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v25 := args[0] + _ = v25 + tmp26 := checkDerefVar(var_glojure_DOT_core_cons) + tmp27 := checkDerefVar(var_glojure_DOT_core_drop) + tmp28 := lang.Apply(tmp27, []any{int64(1), v25}) + tmp29 := lang.Apply(v16, []any{tmp28}) + tmp30 := lang.Apply(tmp26, []any{sym_glojure_DOT_core_SLASH_fn, tmp29}) + return tmp30 + }) + tmp25 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(173), kw_column, int(21), kw_end_DASH_line, int(173), kw_end_DASH_column, int(49)) + tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp27 := lang.Apply(tmp23, []any{tmp26, v11}) + tmp28 := lang.Apply(tmp17, []any{tmp22, tmp27}) + tmp29 := lang.NewVector(v8, tmp28) + tmp30 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(172), kw_column, int(5), kw_end_DASH_line, int(173), kw_end_DASH_column, int(55)) + tmp31, err := lang.WithMeta(tmp29, tmp30.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp12 = tmp31 + } // end let + tmp4 = tmp12 + } // end let + return tmp4 }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_emit_DASH_hinted_DASH_impl = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_emit_DASH_hinted_DASH_impl.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // rand + // extend-protocol { - tmp0 := sym_rand.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_n)), kw_doc, "Returns a random floating point number between 0 (inclusive) and\n n (default 1) (exclusive).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(4935), kw_end_DASH_line, int(4935))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_extend_DASH_protocol.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_p, sym__AMP_, sym_specs)), kw_doc, "Useful when you want to provide several implementations of the same\n protocol all at once. Takes a single protocol and the implementation\n of that protocol for one or more types.\n\n (extend-protocol Protocol\n AType\n (foo [x] ...)\n (bar [x y] ...)\n BType\n (foo [x] ...)\n (bar [x y] ...)\n AClass\n (foo [x] ...)\n (bar [x y] ...)\n nil\n (foo [x] ...)\n (bar [x y] ...))\n\n expands into:\n\n (do\n (clojure.core/extend-type AType Protocol \n (foo [x] ...) \n (bar [x y] ...))\n (clojure.core/extend-type BType Protocol \n (foo [x] ...) \n (bar [x y] ...))\n (clojure.core/extend-type AClass Protocol \n (foo [x] ...) \n (bar [x y] ...))\n (clojure.core/extend-type nil Protocol \n (foo [x] ...) \n (bar [x y] ...)))", kw_file, "glojure/core_deftype.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(25), kw_column, int(11), kw_line, int(212), kw_end_DASH_line, int(212))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 0: - tmp3 := lang.Apply(rand16.Float64, nil) - return tmp3 - case 1: - v3 := args[0] + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core__STAR_) - tmp5 := checkDerefVar(var_glojure_DOT_core_rand) - tmp6 := lang.Apply(tmp5, nil) - tmp7 := lang.Apply(tmp4, []any{v3, tmp6}) + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_emit_DASH_extend_DASH_protocol) + tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 - default: - checkArity(args, -1) - panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // rand-int - { - tmp0 := sym_rand_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_doc, "Returns a random integer between 0 (inclusive) and n (exclusive).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(4943), kw_end_DASH_line, int(4943))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_int) - tmp5 := checkDerefVar(var_glojure_DOT_core_rand) - tmp6 := lang.Apply(tmp5, []any{v3}) - tmp7 := lang.Apply(tmp4, []any{tmp6}) - return tmp7 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_extend_DASH_protocol = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_extend_DASH_protocol.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // rand-nth + // fits-table? { - tmp0 := sym_rand_DASH_nth.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Return a random element of the (sequential) collection. Will have\n the same performance characteristics as nth for the given\n collection.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(7213), kw_end_DASH_line, int(7213))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_fits_DASH_table_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ints)), kw_doc, "Returns true if the collection of ints can fit within the\n max-table-switch-size, false otherwise.", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(8), kw_line, int(6625), kw_end_DASH_line, int(6625), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_nth) - tmp5 := checkDerefVar(var_glojure_DOT_core_rand_DASH_int) - tmp6 := checkDerefVar(var_glojure_DOT_core_count) - tmp7 := lang.Apply(tmp6, []any{v3}) - tmp8 := lang.Apply(tmp5, []any{tmp7}) - tmp9 := lang.Apply(tmp4, []any{v3, tmp8}) - return tmp9 + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp4 := checkDerefVar(var_glojure_DOT_core__DASH_) + tmp5 := checkDerefVar(var_glojure_DOT_core_apply) + tmp6 := checkDerefVar(var_glojure_DOT_core_max) + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := lang.Apply(tmp7, []any{v2}) + tmp9 := lang.Apply(tmp5, []any{tmp6, tmp8}) + tmp10 := checkDerefVar(var_glojure_DOT_core_apply) + tmp11 := checkDerefVar(var_glojure_DOT_core_min) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := lang.Apply(tmp12, []any{v2}) + tmp14 := lang.Apply(tmp10, []any{tmp11, tmp13}) + tmp15 := lang.Apply(tmp4, []any{tmp9, tmp14}) + tmp16 := checkDerefVar(var_glojure_DOT_core_max_DASH_switch_DASH_table_DASH_size) + tmp17 := lang.Apply(tmp3, []any{tmp15, tmp16}) + return tmp17 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_fits_DASH_table_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_fits_DASH_table_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // random-sample + // fn { - tmp0 := sym_random_DASH_sample.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_prob), lang.NewVector(sym_prob, sym_coll)), kw_doc, "Returns items from coll with random probability of prob (0.0 -\n 1.0). Returns a transducer when no collection is provided.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(7699), kw_end_DASH_line, int(7699))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_fn.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_sigs)), kw_doc, "params => positional-params*, or positional-params* & rest-param\n positional-param => binding-form\n rest-param => binding-form\n binding-form => name, or destructuring-form\n\n Defines a function.\n\n See https://glojure.org/reference/special_forms#fn for more information", kw_forms, lang.NewVector(lang.NewList(sym_fn, sym_name_QMARK_, lang.NewVector(sym_params_STAR_), sym_exprs_STAR_), lang.NewList(sym_fn, sym_name_QMARK_, lang.NewList(lang.NewVector(sym_params_STAR_), sym_exprs_STAR_), sym__PLUS_)), kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(11), kw_line, int(4533), kw_end_DASH_line, int(4533), kw_special_DASH_form, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 1: - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_filter) - var tmp5 lang.FnFunc - tmp5 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v6 := args[0] - _ = v6 - tmp7 := checkDerefVar(var_glojure_DOT_core__LT_) - tmp8 := checkDerefVar(var_glojure_DOT_core_rand) - tmp9 := lang.Apply(tmp8, nil) - tmp10 := lang.Apply(tmp7, []any{tmp9, v3}) - return tmp10 - }) - tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7704), kw_column, int(14), kw_end_DASH_line, int(7704), kw_end_DASH_column, int(37)) - tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp8 := lang.Apply(tmp4, []any{tmp7}) - return tmp8 - case 2: - v3 := args[0] + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + var v4 any = lang.NewList(args[2:]...) _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_filter) - var tmp6 lang.FnFunc - tmp6 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v7 := args[0] - _ = v7 - tmp8 := checkDerefVar(var_glojure_DOT_core__LT_) - tmp9 := checkDerefVar(var_glojure_DOT_core_rand) - tmp10 := lang.Apply(tmp9, nil) - tmp11 := lang.Apply(tmp8, []any{tmp10, v3}) - return tmp11 - }) - tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7706), kw_column, int(14), kw_end_DASH_line, int(7706), kw_end_DASH_column, int(37)) - tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp9 := lang.Apply(tmp5, []any{tmp8, v4}) - return tmp9 - default: - checkArity(args, -1) - panic("unreachable") + var tmp5 any + { // let + // let binding "name" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp8 := checkDerefVar(var_glojure_DOT_core_first) + tmp9 := lang.Apply(tmp8, []any{v4}) + tmp10 := lang.Apply(tmp7, []any{tmp9}) + if lang.IsTruthy(tmp10) { + tmp11 := checkDerefVar(var_glojure_DOT_core_first) + tmp12 := lang.Apply(tmp11, []any{v4}) + tmp6 = tmp12 + } else { + } + var v13 any = tmp6 + _ = v13 + // let binding "sigs" + var tmp14 any + if lang.IsTruthy(v13) { + tmp15 := checkDerefVar(var_glojure_DOT_core_next) + tmp16 := lang.Apply(tmp15, []any{v4}) + tmp14 = tmp16 + } else { + tmp14 = v4 + } + var v17 any = tmp14 + _ = v17 + // let binding "sigs" + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp20 := checkDerefVar(var_glojure_DOT_core_first) + tmp21 := lang.Apply(tmp20, []any{v17}) + tmp22 := lang.Apply(tmp19, []any{tmp21}) + if lang.IsTruthy(tmp22) { + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := lang.Apply(tmp23, []any{v17}) + tmp18 = tmp24 + } else { + var tmp25 any + tmp26 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp27 := checkDerefVar(var_glojure_DOT_core_first) + tmp28 := lang.Apply(tmp27, []any{v17}) + tmp29 := lang.Apply(tmp26, []any{tmp28}) + if lang.IsTruthy(tmp29) { + tmp25 = v17 + } else { + var tmp30 any + tmp31 := checkDerefVar(var_glojure_DOT_core_seq) + tmp32 := lang.Apply(tmp31, []any{v17}) + if lang.IsTruthy(tmp32) { + tmp33 := checkDerefVar(var_glojure_DOT_core_str) + tmp34 := checkDerefVar(var_glojure_DOT_core_first) + tmp35 := lang.Apply(tmp34, []any{v17}) + tmp36 := lang.Apply(tmp33, []any{"Parameter declaration ", tmp35, " should be a vector"}) + tmp30 = tmp36 + } else { + tmp37 := checkDerefVar(var_glojure_DOT_core_str) + tmp38 := lang.Apply(tmp37, []any{"Parameter declaration missing"}) + tmp30 = tmp38 + } + tmp39 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp39) + } + tmp18 = tmp25 + } + var v40 any = tmp18 + _ = v40 + // let binding "psig" + var tmp41 lang.FnFunc + tmp41 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v42 := args[0] + _ = v42 + var tmp43 any + tmp44 := checkDerefVar(var_glojure_DOT_core_not) + tmp45 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp46 := lang.Apply(tmp45, []any{v42}) + tmp47 := lang.Apply(tmp44, []any{tmp46}) + if lang.IsTruthy(tmp47) { + tmp48 := checkDerefVar(var_glojure_DOT_core_str) + tmp49 := lang.Apply(tmp48, []any{"Invalid signature ", v42, " should be a list"}) + tmp50 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp49}) + panic(tmp50) + } else { + } + _ = tmp43 + var tmp51 any + { // let + // let binding "vec__13" + var v52 any = v42 + _ = v52 + // let binding "seq__14" + tmp53 := checkDerefVar(var_glojure_DOT_core_seq) + tmp54 := lang.Apply(tmp53, []any{v52}) + var v55 any = tmp54 + _ = v55 + // let binding "first__15" + tmp56 := checkDerefVar(var_glojure_DOT_core_first) + tmp57 := lang.Apply(tmp56, []any{v55}) + var v58 any = tmp57 + _ = v58 + // let binding "seq__14" + tmp59 := checkDerefVar(var_glojure_DOT_core_next) + tmp60 := lang.Apply(tmp59, []any{v55}) + var v61 any = tmp60 + _ = v61 + // let binding "params" + var v62 any = v58 + _ = v62 + // let binding "body" + var v63 any = v61 + _ = v63 + // let binding "_" + var tmp64 any + tmp65 := checkDerefVar(var_glojure_DOT_core_not) + tmp66 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp67 := lang.Apply(tmp66, []any{v62}) + tmp68 := lang.Apply(tmp65, []any{tmp67}) + if lang.IsTruthy(tmp68) { + var tmp69 any + tmp70 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp71 := checkDerefVar(var_glojure_DOT_core_first) + tmp72 := lang.Apply(tmp71, []any{v40}) + tmp73 := lang.Apply(tmp70, []any{tmp72}) + if lang.IsTruthy(tmp73) { + tmp74 := checkDerefVar(var_glojure_DOT_core_str) + tmp75 := lang.Apply(tmp74, []any{"Parameter declaration ", v62, " should be a vector"}) + tmp69 = tmp75 + } else { + tmp76 := checkDerefVar(var_glojure_DOT_core_str) + tmp77 := lang.Apply(tmp76, []any{"Invalid signature ", v42, " should be a list"}) + tmp69 = tmp77 + } + tmp78 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp69}) + panic(tmp78) + } else { + } + var v79 any = tmp64 + _ = v79 + // let binding "conds" + var tmp80 any + var tmp81 any + { // let + // let binding "and__0__auto__" + tmp82 := checkDerefVar(var_glojure_DOT_core_next) + tmp83 := lang.Apply(tmp82, []any{v63}) + var v84 any = tmp83 + _ = v84 + var tmp85 any + if lang.IsTruthy(v84) { + tmp86 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp87 := checkDerefVar(var_glojure_DOT_core_first) + tmp88 := lang.Apply(tmp87, []any{v63}) + tmp89 := lang.Apply(tmp86, []any{tmp88}) + tmp85 = tmp89 + } else { + tmp85 = v84 + } + tmp81 = tmp85 + } // end let + if lang.IsTruthy(tmp81) { + tmp82 := checkDerefVar(var_glojure_DOT_core_first) + tmp83 := lang.Apply(tmp82, []any{v63}) + tmp80 = tmp83 + } else { + } + var v84 any = tmp80 + _ = v84 + // let binding "body" + var tmp85 any + if lang.IsTruthy(v84) { + tmp86 := checkDerefVar(var_glojure_DOT_core_next) + tmp87 := lang.Apply(tmp86, []any{v63}) + tmp85 = tmp87 + } else { + tmp85 = v63 + } + var v88 any = tmp85 + _ = v88 + // let binding "conds" + var tmp89 any + { // let + // let binding "or__0__auto__" + var v90 any = v84 + _ = v90 + var tmp91 any + if lang.IsTruthy(v90) { + tmp91 = v90 + } else { + tmp92 := checkDerefVar(var_glojure_DOT_core_meta) + tmp93 := lang.Apply(tmp92, []any{v62}) + tmp91 = tmp93 + } + tmp89 = tmp91 + } // end let + var v90 any = tmp89 + _ = v90 + // let binding "pre" + tmp91 := lang.Apply(kw_pre, []any{v90}) + var v92 any = tmp91 + _ = v92 + // let binding "post" + tmp93 := lang.Apply(kw_post, []any{v90}) + var v94 any = tmp93 + _ = v94 + // let binding "body" + var tmp95 any + if lang.IsTruthy(v94) { + tmp96 := checkDerefVar(var_glojure_DOT_core_seq) + tmp97 := checkDerefVar(var_glojure_DOT_core_concat) + tmp98 := checkDerefVar(var_glojure_DOT_core_list) + tmp99 := checkDerefVar(var_glojure_DOT_core_seq) + tmp100 := checkDerefVar(var_glojure_DOT_core_concat) + tmp101 := checkDerefVar(var_glojure_DOT_core_list) + tmp102 := lang.Apply(tmp101, []any{sym_glojure_DOT_core_SLASH_let}) + tmp103 := checkDerefVar(var_glojure_DOT_core_list) + tmp104 := checkDerefVar(var_glojure_DOT_core_apply) + tmp105 := checkDerefVar(var_glojure_DOT_core_vector) + tmp106 := checkDerefVar(var_glojure_DOT_core_seq) + tmp107 := checkDerefVar(var_glojure_DOT_core_concat) + tmp108 := checkDerefVar(var_glojure_DOT_core_list) + tmp109 := lang.Apply(tmp108, []any{sym__PCT_}) + tmp110 := checkDerefVar(var_glojure_DOT_core_list) + var tmp111 any + tmp112 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp113 := checkDerefVar(var_glojure_DOT_core_count) + tmp114 := lang.Apply(tmp113, []any{v88}) + tmp115 := lang.Apply(tmp112, []any{int64(1), tmp114}) + if lang.IsTruthy(tmp115) { + tmp116 := checkDerefVar(var_glojure_DOT_core_seq) + tmp117 := checkDerefVar(var_glojure_DOT_core_concat) + tmp118 := checkDerefVar(var_glojure_DOT_core_list) + tmp119 := lang.Apply(tmp118, []any{sym_do}) + tmp120 := lang.Apply(tmp117, []any{tmp119, v88}) + tmp121 := lang.Apply(tmp116, []any{tmp120}) + tmp111 = tmp121 + } else { + tmp122 := checkDerefVar(var_glojure_DOT_core_first) + tmp123 := lang.Apply(tmp122, []any{v88}) + tmp111 = tmp123 + } + tmp124 := lang.Apply(tmp110, []any{tmp111}) + tmp125 := lang.Apply(tmp107, []any{tmp109, tmp124}) + tmp126 := lang.Apply(tmp106, []any{tmp125}) + tmp127 := lang.Apply(tmp104, []any{tmp105, tmp126}) + tmp128 := lang.Apply(tmp103, []any{tmp127}) + tmp129 := checkDerefVar(var_glojure_DOT_core_map) + var tmp130 lang.FnFunc + tmp130 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v131 := args[0] + _ = v131 + tmp132 := checkDerefVar(var_glojure_DOT_core_seq) + tmp133 := checkDerefVar(var_glojure_DOT_core_concat) + tmp134 := checkDerefVar(var_glojure_DOT_core_list) + tmp135 := lang.Apply(tmp134, []any{sym_glojure_DOT_core_SLASH_assert}) + tmp136 := checkDerefVar(var_glojure_DOT_core_list) + tmp137 := lang.Apply(tmp136, []any{v131}) + tmp138 := lang.Apply(tmp133, []any{tmp135, tmp137}) + tmp139 := lang.Apply(tmp132, []any{tmp138}) + return tmp139 + }) + tmp131 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4582), kw_column, int(41), kw_end_DASH_line, int(4582), kw_end_DASH_column, int(62)) + tmp132, err := lang.WithMeta(tmp130, tmp131.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp133 := lang.Apply(tmp129, []any{tmp132, v94}) + tmp134 := checkDerefVar(var_glojure_DOT_core_list) + tmp135 := lang.Apply(tmp134, []any{sym__PCT_}) + tmp136 := lang.Apply(tmp100, []any{tmp102, tmp128, tmp133, tmp135}) + tmp137 := lang.Apply(tmp99, []any{tmp136}) + tmp138 := lang.Apply(tmp98, []any{tmp137}) + tmp139 := lang.Apply(tmp97, []any{tmp138}) + tmp140 := lang.Apply(tmp96, []any{tmp139}) + tmp95 = tmp140 + } else { + tmp95 = v88 + } + var v141 any = tmp95 + _ = v141 + // let binding "body" + var tmp142 any + if lang.IsTruthy(v92) { + tmp143 := checkDerefVar(var_glojure_DOT_core_concat) + tmp144 := checkDerefVar(var_glojure_DOT_core_map) + var tmp145 lang.FnFunc + tmp145 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v146 := args[0] + _ = v146 + tmp147 := checkDerefVar(var_glojure_DOT_core_seq) + tmp148 := checkDerefVar(var_glojure_DOT_core_concat) + tmp149 := checkDerefVar(var_glojure_DOT_core_list) + tmp150 := lang.Apply(tmp149, []any{sym_glojure_DOT_core_SLASH_assert}) + tmp151 := checkDerefVar(var_glojure_DOT_core_list) + tmp152 := lang.Apply(tmp151, []any{v146}) + tmp153 := lang.Apply(tmp148, []any{tmp150, tmp152}) + tmp154 := lang.Apply(tmp147, []any{tmp153}) + return tmp154 + }) + tmp146 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4586), kw_column, int(44), kw_end_DASH_line, int(4586), kw_end_DASH_column, int(65)) + tmp147, err := lang.WithMeta(tmp145, tmp146.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp148 := lang.Apply(tmp144, []any{tmp147, v92}) + tmp149 := lang.Apply(tmp143, []any{tmp148, v141}) + tmp142 = tmp149 + } else { + tmp142 = v141 + } + var v150 any = tmp142 + _ = v150 + tmp151 := checkDerefVar(var_glojure_DOT_core_maybe_DASH_destructured) + tmp152 := lang.Apply(tmp151, []any{v62, v150}) + tmp51 = tmp152 + } // end let + return tmp51 + }) + tmp42 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4558), kw_column, int(16), kw_end_DASH_line, int(4589), kw_end_DASH_column, int(53)) + tmp43, err := lang.WithMeta(tmp41, tmp42.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v44 any = tmp43 + _ = v44 + // let binding "new-sigs" + tmp45 := checkDerefVar(var_glojure_DOT_core_map) + tmp46 := lang.Apply(tmp45, []any{v44, v40}) + var v47 any = tmp46 + _ = v47 + tmp48 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + var tmp49 any + if lang.IsTruthy(v13) { + tmp50 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp51 := lang.Apply(tmp50, []any{sym_fn_STAR_, v13, v47}) + tmp49 = tmp51 + } else { + tmp52 := checkDerefVar(var_glojure_DOT_core_cons) + tmp53 := lang.Apply(tmp52, []any{sym_fn_STAR_, v47}) + tmp49 = tmp53 + } + tmp54 := checkDerefVar(var_glojure_DOT_core_meta) + tmp55 := lang.Apply(tmp54, []any{v2}) + tmp56 := lang.Apply(tmp48, []any{tmp49, tmp55}) + tmp5 = tmp56 + } // end let + return tmp5 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // random-uuid - { - tmp0 := sym_random_DASH_uuid.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Returns a pseudo-randomly generated java.util.UUID instance (i.e. type 4).\n\n See: https://docs.oracle.com/javase/8/docs/api/java/util/UUID.html#randomUUID--", kw_file, "glojure/core.glj", kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(6852), kw_end_DASH_line, int(6852))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - tmp3 := lang.Apply(uuid13.NewV7, nil) - return tmp3 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_fn = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_fn.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // range + // import { - tmp0 := sym_range.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_end), lang.NewVector(sym_start, sym_end), lang.NewVector(sym_start, sym_end, sym_step)), kw_doc, "Returns a lazy seq of nums from start (inclusive) to end\n (exclusive), by step, where start defaults to 0, step to 1, and end to\n infinity. When step is equal to 0, returns an infinite sequence of\n start. When start is equal to end, returns empty list.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3018), kw_end_DASH_line, int(3018))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_import.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_import_DASH_symbols_DASH_or_DASH_lists)), kw_doc, "import-list => (package-symbol class-name-symbols*)\n\n For each name in class-name-symbols, adds a mapping from name to the\n class named by package.name to the current namespace. Use :import in the ns\n macro in preference to calling this directly.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(11), kw_line, int(3426), kw_end_DASH_line, int(3426))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 0: - tmp3 := checkDerefVar(var_glojure_DOT_core_iterate) - tmp4 := checkDerefVar(var_glojure_DOT_core_inc_TICK_) - tmp5 := lang.Apply(tmp3, []any{tmp4, int64(0)}) - return tmp5 - case 1: - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) - tmp6 := lang.Apply(tmp5, []any{v3}) - if lang.IsTruthy(tmp6) { - tmp7 := lang.Apply(lang.NewLongRange, []any{int64(0), v3, int64(1)}) - tmp4 = tmp7 - } else { - tmp8 := lang.Apply(lang.NewRange, []any{int64(0), v3, int64(1)}) - tmp4 = tmp8 - } - return tmp4 - case 2: - v3 := args[0] + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + var v4 any = lang.NewList(args[2:]...) _ = v4 var tmp5 any - var tmp6 any - { // let - // let binding "and__0__auto__" - tmp7 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) - tmp8 := lang.Apply(tmp7, []any{v3}) - var v9 any = tmp8 - _ = v9 - var tmp10 any - if lang.IsTruthy(v9) { - tmp11 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) - tmp12 := lang.Apply(tmp11, []any{v4}) - tmp10 = tmp12 - } else { - tmp10 = v9 - } - tmp6 = tmp10 - } // end let - if lang.IsTruthy(tmp6) { - tmp7 := lang.Apply(lang.NewLongRange, []any{v3, v4, int64(1)}) - tmp5 = tmp7 - } else { - tmp8 := lang.Apply(lang.NewRange, []any{v3, v4, int64(1)}) - tmp5 = tmp8 - } - return tmp5 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var tmp6 any - var tmp7 any { // let - // let binding "and__0__auto__" - tmp8 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) - tmp9 := lang.Apply(tmp8, []any{v3}) - var v10 any = tmp9 - _ = v10 - var tmp11 any - if lang.IsTruthy(v10) { - var tmp12 any + // let binding "specs" + tmp6 := checkDerefVar(var_glojure_DOT_core_map) + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v8 := args[0] + _ = v8 + var tmp9 any + var tmp10 any { // let // let binding "and__0__auto__" - tmp13 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) - tmp14 := lang.Apply(tmp13, []any{v4}) - var v15 any = tmp14 - _ = v15 - var tmp16 any - if lang.IsTruthy(v15) { - tmp17 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) - tmp18 := lang.Apply(tmp17, []any{v5}) - tmp16 = tmp18 + tmp11 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp12 := lang.Apply(tmp11, []any{v8}) + var v13 any = tmp12 + _ = v13 + var tmp14 any + if lang.IsTruthy(v13) { + tmp15 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp16 := checkDerefVar(var_glojure_DOT_core_first) + tmp17 := lang.Apply(tmp16, []any{v8}) + tmp18 := lang.Apply(tmp15, []any{sym_quote, tmp17}) + tmp14 = tmp18 } else { - tmp16 = v15 + tmp14 = v13 } - tmp12 = tmp16 + tmp10 = tmp14 } // end let - tmp11 = tmp12 - } else { - tmp11 = v10 + if lang.IsTruthy(tmp10) { + tmp11 := checkDerefVar(var_glojure_DOT_core_second) + tmp12 := lang.Apply(tmp11, []any{v8}) + tmp9 = tmp12 + } else { + tmp9 = v8 + } + return tmp9 + }) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3434), kw_column, int(20), kw_end_DASH_line, int(3434), kw_end_DASH_column, int(73)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) } - tmp7 = tmp11 + tmp10 := lang.Apply(tmp6, []any{tmp9, v4}) + var v11 any = tmp10 + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_do}) + tmp16 := checkDerefVar(var_glojure_DOT_core_map) + var tmp17 lang.FnFunc + tmp17 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v18 := args[0] + _ = v18 + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Import, v18}) + return tmp20 + }) + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3436), kw_column, int(17), kw_end_DASH_line, int(3436), kw_end_DASH_column, int(73)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp20 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp21 lang.FnFunc + tmp21 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v22 := args[0] + _ = v22 + v23 := args[1] + _ = v23 + var tmp24 any + tmp25 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp26 := lang.Apply(tmp25, []any{v23}) + if lang.IsTruthy(tmp26) { + tmp27 := checkDerefVar(var_glojure_DOT_core_conj) + tmp28 := checkDerefVar(var_glojure_DOT_core_name) + tmp29 := lang.Apply(tmp28, []any{v23}) + tmp30 := lang.Apply(tmp27, []any{v22, tmp29}) + tmp24 = tmp30 + } else { + var tmp31 any + { // let + // let binding "p" + tmp32 := checkDerefVar(var_glojure_DOT_core_first) + tmp33 := lang.Apply(tmp32, []any{v23}) + var v34 any = tmp33 + _ = v34 + // let binding "cs" + tmp35 := checkDerefVar(var_glojure_DOT_core_rest) + tmp36 := lang.Apply(tmp35, []any{v23}) + var v37 any = tmp36 + _ = v37 + tmp38 := checkDerefVar(var_glojure_DOT_core_into1) + tmp39 := checkDerefVar(var_glojure_DOT_core_map) + var tmp40 lang.FnFunc + tmp40 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v41 := args[0] + _ = v41 + tmp42 := checkDerefVar(var_glojure_DOT_core_str) + tmp43 := lang.Apply(tmp42, []any{v34, ".", v41}) + return tmp43 + }) + tmp41 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3441), kw_column, int(45), kw_end_DASH_line, int(3441), kw_end_DASH_column, int(58)) + tmp42, err := lang.WithMeta(tmp40, tmp41.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp43 := lang.Apply(tmp39, []any{tmp42, v37}) + tmp44 := lang.Apply(tmp38, []any{v22, tmp43}) + tmp31 = tmp44 + } // end let + tmp24 = tmp31 + } + return tmp24 + }) + tmp22 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3437), kw_column, int(26), kw_end_DASH_line, int(3441), kw_end_DASH_column, int(66)) + tmp23, err := lang.WithMeta(tmp21, tmp22.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp24 := lang.NewVector() + tmp25 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3442), kw_column, int(25), kw_end_DASH_line, int(3442), kw_end_DASH_column, int(26)) + tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp27 := lang.Apply(tmp20, []any{tmp23, tmp26, v11}) + tmp28 := lang.Apply(tmp16, []any{tmp19, tmp27}) + tmp29 := lang.Apply(tmp13, []any{tmp15, tmp28}) + tmp30 := lang.Apply(tmp12, []any{tmp29}) + tmp5 = tmp30 } // end let - if lang.IsTruthy(tmp7) { - tmp8 := lang.Apply(lang.NewLongRange, []any{v3, v4, v5}) - tmp6 = tmp8 - } else { - tmp9 := lang.Apply(lang.NewRange, []any{v3, v4, v5}) - tmp6 = tmp9 - } - return tmp6 - default: - checkArity(args, -1) - panic("unreachable") + return tmp5 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // ratio? - { - tmp0 := sym_ratio_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_doc, "Returns true if n is a Ratio", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(3577), kw_end_DASH_line, int(3577))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp5 := reflect.TypeOf((*lang.Ratio)(nil)) - tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) - return tmp6 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_import = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_import.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // rational? + // interleave { - tmp0 := sym_rational_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_doc, "Returns true if n is a rational number", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(3613), kw_end_DASH_line, int(3613))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "or__0__auto__" - tmp5 := checkDerefVar(var_glojure_DOT_core_integer_QMARK_) - tmp6 := lang.Apply(tmp5, []any{v3}) - var v7 any = tmp6 - _ = v7 - var tmp8 any - if lang.IsTruthy(v7) { - tmp8 = v7 - } else { - var tmp9 any + tmp0 := sym_interleave.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_c1), lang.NewVector(sym_c1, sym_c2), lang.NewVector(sym_c1, sym_c2, sym__AMP_, sym_colls)), kw_doc, "Returns a lazy seq of the first item in each coll, then the second etc.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4308), kw_end_DASH_line, int(4308))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return lang.NewList() + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + return v2 + }) + tmp4 := lang.Apply(lang.NewLazySeq, []any{tmp3}) + return tmp4 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp5 any { // let - // let binding "or__0__auto__" - tmp10 := checkDerefVar(var_glojure_DOT_core_ratio_QMARK_) - tmp11 := lang.Apply(tmp10, []any{v3}) + // let binding "s1" + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := lang.Apply(tmp6, []any{v2}) + var v8 any = tmp7 + _ = v8 + // let binding "s2" + tmp9 := checkDerefVar(var_glojure_DOT_core_seq) + tmp10 := lang.Apply(tmp9, []any{v3}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + var tmp13 any + { // let + // let binding "and__0__auto__" + var v14 any = v8 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + tmp15 = v11 + } else { + tmp15 = v14 + } + tmp13 = tmp15 + } // end let + if lang.IsTruthy(tmp13) { + tmp14 := checkDerefVar(var_glojure_DOT_core_cons) + tmp15 := checkDerefVar(var_glojure_DOT_core_first) + tmp16 := lang.Apply(tmp15, []any{v8}) + tmp17 := checkDerefVar(var_glojure_DOT_core_cons) + tmp18 := checkDerefVar(var_glojure_DOT_core_first) + tmp19 := lang.Apply(tmp18, []any{v11}) + tmp20 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp21 := checkDerefVar(var_glojure_DOT_core_rest) + tmp22 := lang.Apply(tmp21, []any{v8}) + tmp23 := checkDerefVar(var_glojure_DOT_core_rest) + tmp24 := lang.Apply(tmp23, []any{v11}) + tmp25 := lang.Apply(tmp20, []any{tmp22, tmp24}) + tmp26 := lang.Apply(tmp17, []any{tmp19, tmp25}) + tmp27 := lang.Apply(tmp14, []any{tmp16, tmp26}) + tmp12 = tmp27 + } else { + } + tmp5 = tmp12 + } // end let + return tmp5 + }) + tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) + return tmp5 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp6 any + { // let + // let binding "ss" + tmp7 := checkDerefVar(var_glojure_DOT_core_map) + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_conj) + tmp10 := lang.Apply(tmp9, []any{v4, v3, v2}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10}) var v12 any = tmp11 _ = v12 var tmp13 any - if lang.IsTruthy(v12) { - tmp13 = v12 + tmp14 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + tmp15 := checkDerefVar(var_glojure_DOT_core_identity) + tmp16 := lang.Apply(tmp14, []any{tmp15, v12}) + if lang.IsTruthy(tmp16) { + tmp17 := checkDerefVar(var_glojure_DOT_core_concat) + tmp18 := checkDerefVar(var_glojure_DOT_core_map) + tmp19 := checkDerefVar(var_glojure_DOT_core_first) + tmp20 := lang.Apply(tmp18, []any{tmp19, v12}) + tmp21 := checkDerefVar(var_glojure_DOT_core_apply) + tmp22 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp23 := checkDerefVar(var_glojure_DOT_core_map) + tmp24 := checkDerefVar(var_glojure_DOT_core_rest) + tmp25 := lang.Apply(tmp23, []any{tmp24, v12}) + tmp26 := lang.Apply(tmp21, []any{tmp22, tmp25}) + tmp27 := lang.Apply(tmp17, []any{tmp20, tmp26}) + tmp13 = tmp27 } else { - tmp14 := checkDerefVar(var_glojure_DOT_core_decimal_QMARK_) - tmp15 := lang.Apply(tmp14, []any{v3}) - tmp13 = tmp15 } - tmp9 = tmp13 + tmp6 = tmp13 } // end let - tmp8 = tmp9 - } - tmp4 = tmp8 - } // end let - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // rationalize - { - tmp0 := sym_rationalize.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_num)), kw_doc, "returns the rational value of num", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(1282), kw_end_DASH_line, int(1282))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Rationalize") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Rationalize is not a function"))) + return tmp6 + }) + tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) + return tmp6 } - tmp5 := lang.Apply(tmp4, []any{v3}) - return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_interleave = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_interleave.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // re-find + // interpose { - tmp0 := sym_re_DASH_find.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m), lang.NewVector(sym_re, sym_s)), kw_doc, "Returns the next regex match, if any, of string to pattern, using\n java.util.regex.Matcher.find(). Uses re-groups to return the\n groups.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4922), kw_end_DASH_line, int(4922))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_interpose.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_sep), lang.NewVector(sym_sep, sym_coll)), kw_doc, "Returns a lazy seq of the elements of coll separated by sep.\n Returns a stateful transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(5230), kw_end_DASH_line, int(5230))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: - v3 := args[0] - _ = v3 - var tmp4 any - tmp5, _ := lang.FieldOrMethod(v3, "find") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("find is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{}) - if lang.IsTruthy(tmp6) { - tmp7 := checkDerefVar(var_glojure_DOT_core_re_DASH_groups) - tmp8 := lang.Apply(tmp7, []any{v3}) - tmp4 = tmp8 - } else { - } - return tmp4 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - { // let - // let binding "m" - tmp6 := checkDerefVar(var_glojure_DOT_core_re_DASH_matcher) - tmp7 := lang.Apply(tmp6, []any{v3, v4}) - var v8 any = tmp7 - _ = v8 - tmp9 := checkDerefVar(var_glojure_DOT_core_re_DASH_find) - tmp10 := lang.Apply(tmp9, []any{v8}) - tmp5 = tmp10 - } // end let - return tmp5 - default: - checkArity(args, -1) - panic("unreachable") - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // re-groups - { - tmp0 := sym_re_DASH_groups.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m)), kw_doc, "Returns the groups from the most recent match/find. If there are no\n nested groups, returns a string of the entire match. If there are\n nested groups, returns a vector of the groups, the first element\n being the entire match.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(4882), kw_end_DASH_line, int(4882))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "gc" - tmp5, _ := lang.FieldOrMethod(v3, "groupCount") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("groupCount is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{}) - var v7 any = tmp6 - _ = v7 - var tmp8 any - tmp9 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) - tmp10 := lang.Apply(tmp9, []any{v7}) - if lang.IsTruthy(tmp10) { - tmp11, _ := lang.FieldOrMethod(v3, "group") - if reflect.TypeOf(tmp11).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("group is not a function"))) - } - tmp12 := lang.Apply(tmp11, []any{}) - tmp8 = tmp12 - } else { - var tmp13 any + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 any { // let - // let binding "ret" - tmp14 := lang.NewVector() - tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4893), kw_column, int(20), kw_end_DASH_line, int(4893), kw_end_DASH_column, int(21)) - tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v17 any = tmp16 - _ = v17 - // let binding "c" - var v18 any = int64(0) - _ = v18 - for { - var tmp19 any - tmp20 := checkDerefVar(var_glojure_DOT_core__LT__EQ_) - tmp21 := lang.Apply(tmp20, []any{v18, v7}) - if lang.IsTruthy(tmp21) { - tmp23 := checkDerefVar(var_glojure_DOT_core_conj) - tmp24, _ := lang.FieldOrMethod(v3, "groupInt") - if reflect.TypeOf(tmp24).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("groupInt is not a function"))) + // let binding "started" + tmp6 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) + tmp7 := lang.Apply(tmp6, []any{false}) + var v8 any = tmp7 + _ = v8 + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp10 := lang.Apply(v4, nil) + return tmp10 + case 1: + v10 := args[0] + _ = v10 + tmp11 := lang.Apply(v4, []any{v10}) + return tmp11 + case 2: + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + var tmp12 any + tmp13 := checkDerefVar(var_glojure_DOT_core_deref) + tmp14 := lang.Apply(tmp13, []any{v8}) + if lang.IsTruthy(tmp14) { + var tmp15 any + { // let + // let binding "sepr" + tmp16 := lang.Apply(v4, []any{v10, v2}) + var v17 any = tmp16 + _ = v17 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) + tmp20 := lang.Apply(tmp19, []any{v17}) + if lang.IsTruthy(tmp20) { + tmp18 = v17 + } else { + tmp21 := lang.Apply(v4, []any{v17, v11}) + tmp18 = tmp21 + } + tmp15 = tmp18 + } // end let + tmp12 = tmp15 + } else { + tmp16 := checkDerefVar(var_glojure_DOT_core_vreset_BANG_) + tmp17 := lang.Apply(tmp16, []any{v8, true}) + _ = tmp17 + tmp18 := lang.Apply(v4, []any{v10, v11}) + tmp12 = tmp18 } - tmp25 := lang.Apply(tmp24, []any{v18}) - tmp26 := lang.Apply(tmp23, []any{v17, tmp25}) - var tmp22 any = tmp26 - tmp28 := checkDerefVar(var_glojure_DOT_core_inc) - tmp29 := lang.Apply(tmp28, []any{v18}) - var tmp27 any = tmp29 - v17 = tmp22 - v18 = tmp27 - continue - } else { - tmp19 = v17 + return tmp12 + default: + checkArity(args, -1) + panic("unreachable") } - tmp13 = tmp19 - break - } - } // end let - tmp8 = tmp13 - } - tmp4 = tmp8 - } // end let - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // re-matcher - { - tmp1 := reflect.TypeOf((*lang.RegexpMatcher)(nil)) - tmp0 := sym_re_DASH_matcher.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_re, sym_s)), kw_doc, "Returns an instance of java.util.regex.Matcher, for use, e.g. in\n re-find.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4873), kw_end_DASH_line, int(4873))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6 := lang.Apply(lang.NewRegexpMatcher, []any{v4, v5}) - return tmp6 - }) - tmp4 := reflect.TypeOf((*lang.RegexpMatcher)(nil)) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // re-matches - { - tmp0 := sym_re_DASH_matches.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_re, sym_s)), kw_doc, "Returns the match, if any, of string to pattern, using\n java.util.regex.Matcher.matches(). Uses re-groups to return the\n groups.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4910), kw_end_DASH_line, int(4910))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - { // let - // let binding "m" - tmp6 := checkDerefVar(var_glojure_DOT_core_re_DASH_matcher) - tmp7 := lang.Apply(tmp6, []any{v3, v4}) - var v8 any = tmp7 - _ = v8 - var tmp9 any - tmp10, _ := lang.FieldOrMethod(v8, "matches") - if reflect.TypeOf(tmp10).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("matches is not a function"))) - } - tmp11 := lang.Apply(tmp10, []any{}) - if lang.IsTruthy(tmp11) { - tmp12 := checkDerefVar(var_glojure_DOT_core_re_DASH_groups) - tmp13 := lang.Apply(tmp12, []any{v8}) - tmp9 = tmp13 - } else { + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5238), kw_column, int(8), kw_end_DASH_line, int(5249), kw_end_DASH_column, int(35)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp5 = tmp11 + } // end let + return tmp5 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5236), kw_column, int(4), kw_end_DASH_line, int(5249), kw_end_DASH_column, int(37)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) } - tmp5 = tmp9 - } // end let - return tmp5 + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_drop) + tmp5 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp6 := checkDerefVar(var_glojure_DOT_core_repeat) + tmp7 := lang.Apply(tmp6, []any{v2}) + tmp8 := lang.Apply(tmp5, []any{tmp7, v3}) + tmp9 := lang.Apply(tmp4, []any{int64(1), tmp8}) + return tmp9 + default: + checkArity(args, -1) + panic("unreachable") + } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_interpose = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_interpose.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // re-pattern + // isa? { - tmp1 := reflect.TypeOf((*regexp15.Regexp)(nil)) - tmp0 := sym_re_DASH_pattern.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_doc, "Returns an instance of java.util.regex.Pattern, for use, e.g. in\n re-matcher.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4863), kw_end_DASH_line, int(4863))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - var tmp5 any - tmp6 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp7 := reflect.TypeOf((*regexp15.Regexp)(nil)) - tmp8 := lang.Apply(tmp6, []any{tmp7, v4}) - if lang.IsTruthy(tmp8) { - tmp5 = v4 - } else { - tmp9 := lang.Apply(regexp15.MustCompile, []any{v4}) - tmp5 = tmp9 + tmp0 := sym_isa_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_child, sym_parent), lang.NewVector(sym_h, sym_child, sym_parent)), kw_doc, "Returns true if (= child parent), or child is directly or indirectly derived from\n parent, either via a Java type inheritance relationship or a\n relationship established via derive. h must be a hierarchy obtained\n from make-hierarchy, if not supplied defaults to the global\n hierarchy", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(5543), kw_end_DASH_line, int(5543))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_isa_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_global_DASH_hierarchy) + tmp6 := lang.Apply(tmp4, []any{tmp5, v2, v3}) + return tmp6 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + { // let + // let binding "or__0__auto__" + tmp6 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp7 := lang.Apply(tmp6, []any{v3, v4}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + tmp9 = v8 + } else { + var tmp10 any + { // let + // let binding "or__0__auto__" + var tmp11 any + { // let + // let binding "and__0__auto__" + tmp12 := checkDerefVar(var_glojure_DOT_core_class_QMARK_) + tmp13 := lang.Apply(tmp12, []any{v4}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + var tmp16 any + { // let + // let binding "and__0__auto__" + tmp17 := checkDerefVar(var_glojure_DOT_core_class_QMARK_) + tmp18 := lang.Apply(tmp17, []any{v3}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + tmp21, _ := lang.FieldOrMethod(v3, "AssignableTo") + if reflect.TypeOf(tmp21).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("AssignableTo is not a function"))) + } + tmp22 := lang.Apply(tmp21, []any{v4}) + tmp20 = tmp22 + } else { + tmp20 = v19 + } + tmp16 = tmp20 + } // end let + tmp15 = tmp16 + } else { + tmp15 = v14 + } + tmp11 = tmp15 + } // end let + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + tmp13 = v12 + } else { + var tmp14 any + { // let + // let binding "or__0__auto__" + tmp15 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp16 := lang.Apply(kw_ancestors, []any{v2}) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := lang.Apply(tmp15, []any{tmp17, v4}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + tmp20 = v19 + } else { + var tmp21 any + { // let + // let binding "or__0__auto__" + var tmp22 any + { // let + // let binding "and__0__auto__" + tmp23 := checkDerefVar(var_glojure_DOT_core_class_QMARK_) + tmp24 := lang.Apply(tmp23, []any{v3}) + var v25 any = tmp24 + _ = v25 + var tmp26 any + if lang.IsTruthy(v25) { + tmp27 := checkDerefVar(var_glojure_DOT_core_some) + var tmp28 lang.FnFunc + tmp28 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v29 := args[0] + _ = v29 + tmp30 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp31 := lang.Apply(kw_ancestors, []any{v2}) + tmp32 := lang.Apply(tmp31, []any{v29}) + tmp33 := lang.Apply(tmp30, []any{tmp32, v4}) + return tmp33 + }) + tmp29 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5556), kw_column, int(34), kw_end_DASH_line, int(5556), kw_end_DASH_column, int(71)) + tmp30, err := lang.WithMeta(tmp28, tmp29.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp31 := checkDerefVar(var_glojure_DOT_core_supers) + tmp32 := lang.Apply(tmp31, []any{v3}) + tmp33 := lang.Apply(tmp27, []any{tmp30, tmp32}) + tmp26 = tmp33 + } else { + tmp26 = v25 + } + tmp22 = tmp26 + } // end let + var v23 any = tmp22 + _ = v23 + var tmp24 any + if lang.IsTruthy(v23) { + tmp24 = v23 + } else { + var tmp25 any + { // let + // let binding "and__0__auto__" + tmp26 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp27 := lang.Apply(tmp26, []any{v4}) + var v28 any = tmp27 + _ = v28 + var tmp29 any + if lang.IsTruthy(v28) { + var tmp30 any + { // let + // let binding "and__0__auto__" + tmp31 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp32 := lang.Apply(tmp31, []any{v3}) + var v33 any = tmp32 + _ = v33 + var tmp34 any + if lang.IsTruthy(v33) { + var tmp35 any + { // let + // let binding "and__0__auto__" + tmp36 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp37 := checkDerefVar(var_glojure_DOT_core_count) + tmp38 := lang.Apply(tmp37, []any{v4}) + tmp39 := checkDerefVar(var_glojure_DOT_core_count) + tmp40 := lang.Apply(tmp39, []any{v3}) + tmp41 := lang.Apply(tmp36, []any{tmp38, tmp40}) + var v42 any = tmp41 + _ = v42 + var tmp43 any + if lang.IsTruthy(v42) { + var tmp44 any + { // let + // let binding "ret" + var v45 any = true + _ = v45 + // let binding "i" + var v46 any = int64(0) + _ = v46 + for { + var tmp47 any + var tmp48 any + { // let + // let binding "or__0__auto__" + tmp49 := checkDerefVar(var_glojure_DOT_core_not) + tmp50 := lang.Apply(tmp49, []any{v45}) + var v51 any = tmp50 + _ = v51 + var tmp52 any + if lang.IsTruthy(v51) { + tmp52 = v51 + } else { + tmp53 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp54 := checkDerefVar(var_glojure_DOT_core_count) + tmp55 := lang.Apply(tmp54, []any{v4}) + tmp56 := lang.Apply(tmp53, []any{v46, tmp55}) + tmp52 = tmp56 + } + tmp48 = tmp52 + } // end let + if lang.IsTruthy(tmp48) { + tmp47 = v45 + } else { + tmp50 := checkDerefVar(var_glojure_DOT_core_isa_QMARK_) + tmp51 := lang.Apply(v3, []any{v46}) + tmp52 := lang.Apply(v4, []any{v46}) + tmp53 := lang.Apply(tmp50, []any{v2, tmp51, tmp52}) + var tmp49 any = tmp53 + tmp55 := checkDerefVar(var_glojure_DOT_core_inc) + tmp56 := lang.Apply(tmp55, []any{v46}) + var tmp54 any = tmp56 + v45 = tmp49 + v46 = tmp54 + continue + } + tmp44 = tmp47 + break + } + } // end let + tmp43 = tmp44 + } else { + tmp43 = v42 + } + tmp35 = tmp43 + } // end let + tmp34 = tmp35 + } else { + tmp34 = v33 + } + tmp30 = tmp34 + } // end let + tmp29 = tmp30 + } else { + tmp29 = v28 + } + tmp25 = tmp29 + } // end let + tmp24 = tmp25 + } + tmp21 = tmp24 + } // end let + tmp20 = tmp21 + } + tmp14 = tmp20 + } // end let + tmp13 = tmp14 + } + tmp10 = tmp13 + } // end let + tmp9 = tmp10 + } + tmp5 = tmp9 + } // end let + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") } - return tmp5 }) - tmp4 := reflect.TypeOf((*regexp15.Regexp)(nil)) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_isa_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_isa_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // re-seq + // lazy-cat { - tmp0 := sym_re_DASH_seq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_re, sym_s)), kw_doc, "Returns a lazy sequence of successive matches of pattern in string,\n using java.util.regex.Matcher.find(), each such match processed with\n re-groups.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(4898), kw_end_DASH_line, int(4898))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - { // let - // let binding "m" - tmp6 := checkDerefVar(var_glojure_DOT_core_re_DASH_matcher) - tmp7 := lang.Apply(tmp6, []any{v3, v4}) - var v8 any = tmp7 - _ = v8 - var tmp9 lang.FnFunc - { // function step - var v10 lang.FnFunc - tmp9 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - var tmp11 any - tmp12, _ := lang.FieldOrMethod(v8, "find") - if reflect.TypeOf(tmp12).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("find is not a function"))) - } - tmp13 := lang.Apply(tmp12, []any{}) - if lang.IsTruthy(tmp13) { - tmp14 := checkDerefVar(var_glojure_DOT_core_cons) - tmp15 := checkDerefVar(var_glojure_DOT_core_re_DASH_groups) - tmp16 := lang.Apply(tmp15, []any{v8}) - var tmp17 lang.FnFunc - tmp17 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - tmp18 := lang.Apply(v10, nil) - return tmp18 - }) - tmp18 := lang.Apply(lang.NewLazySeq, []any{tmp17}) - tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) - tmp11 = tmp19 - } else { - } - return tmp11 - }) - v10 = tmp9 - _ = v10 - } - tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4906), kw_column, int(6), kw_end_DASH_line, int(4908), kw_end_DASH_column, int(49)) - tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + tmp0 := sym_lazy_DASH_cat.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_colls)), kw_doc, "Expands to code which yields a lazy sequence of the concatenation\n of the supplied colls. Each coll expr is not evaluated until it is\n needed. \n\n (lazy-cat xs ys zs) === (concat (lazy-seq xs) (lazy-seq ys) (lazy-seq zs))", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(11), kw_line, int(4636), kw_end_DASH_line, int(4636))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym_glojure_DOT_core_SLASH_concat}) + tmp9 := checkDerefVar(var_glojure_DOT_core_map) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v11 := args[0] + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_glojure_DOT_core_SLASH_lazy_DASH_seq, v11}) + return tmp13 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4644), kw_column, int(19), kw_end_DASH_line, int(4644), kw_end_DASH_column, int(37)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp12 := lang.Apply(tmp11, nil) - tmp5 = tmp12 - } // end let - return tmp5 + tmp13 := lang.Apply(tmp9, []any{tmp12, v4}) + tmp14 := lang.Apply(tmp6, []any{tmp8, tmp13}) + tmp15 := lang.Apply(tmp5, []any{tmp14}) + return tmp15 + } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_lazy_DASH_cat = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_lazy_DASH_cat.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // read + // letfn { - tmp0 := sym_read.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_stream), lang.NewVector(sym_stream, sym_eof_DASH_error_QMARK_, sym_eof_DASH_value), lang.NewVector(sym_stream, sym_eof_DASH_error_QMARK_, sym_eof_DASH_value, sym_recursive_QMARK_), lang.NewVector(sym_opts, sym_stream)), kw_doc, "Reads the next object from stream, which must be an instance of\n java.io.PushbackReader or some derivee. stream defaults to the\n current value of *in*.\n\n Opts is a persistent map with valid keys:\n :read-cond - :allow to process reader conditionals, or\n :preserve to keep all branches\n :features - persistent set of feature keywords for reader conditionals\n :eof - on eof, return value unless :eofthrow, then throw.\n if not specified, will throw\n\n Note that read can execute code (controlled by *read-eval*),\n and as such should be used only with trusted sources.\n\n For data structure interop use glojure.edn/read", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3742), kw_end_DASH_line, int(3742))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_letfn.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_fnspecs, sym__AMP_, sym_body)), kw_doc, "fnspec ==> (fname [params*] exprs) or (fname ([params*] exprs)+)\n\n Takes a vector of function specs and a body, and generates a set of\n bindings of functions to their names. All of the names are available\n in all of the definitions of the functions, as well as the body.", kw_forms, lang.NewVector(lang.NewList(sym_letfn, lang.NewVector(sym_fnspecs_STAR_), sym_exprs_STAR_)), kw_url, nil, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(11), kw_line, int(6545), kw_end_DASH_line, int(6545), kw_special_DASH_form, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 0: - tmp3 := checkDerefVar(var_glojure_DOT_core_read) - tmp4 := checkDerefVar(var_glojure_DOT_core__STAR_in_STAR_) - tmp5 := lang.Apply(tmp3, []any{tmp4}) - return tmp5 - case 1: - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_read) - tmp5 := lang.Apply(tmp4, []any{v3, true, nil}) - return tmp5 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6 := checkDerefVar(var_glojure_DOT_core_read) - tmp7 := lang.Apply(tmp6, []any{v3, v4, v5, false}) - return tmp7 - case 4: - v3 := args[0] + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + v4 := args[2] _ = v4 - v5 := args[2] + var v5 any = lang.NewList(args[3:]...) _ = v5 - v6 := args[3] - _ = v6 - tmp7 := checkDerefVar(var_glojure_DOT_core_boolean) - tmp8 := lang.Apply(tmp7, []any{v4}) - tmp9, _ := lang.FieldOrMethod(nil, "read") - if reflect.TypeOf(tmp9).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("read is not a function"))) - } - tmp10 := lang.Apply(tmp9, []any{v3, tmp8, v5, v6}) - return tmp10 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5, _ := lang.FieldOrMethod(nil, "read") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("read is not a function"))) + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_letfn_STAR_}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_vec) + tmp12 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp13 := checkDerefVar(var_glojure_DOT_core_map) + tmp14 := checkDerefVar(var_glojure_DOT_core_first) + tmp15 := lang.Apply(tmp13, []any{tmp14, v4}) + tmp16 := checkDerefVar(var_glojure_DOT_core_map) + var tmp17 lang.FnFunc + tmp17 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v18 := args[0] + _ = v18 + tmp19 := checkDerefVar(var_glojure_DOT_core_cons) + tmp20 := lang.Apply(tmp19, []any{sym_glojure_DOT_core_SLASH_fn, v18}) + return tmp20 + }) + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6555), kw_column, int(35), kw_end_DASH_line, int(6555), kw_end_DASH_column, int(47)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) } - tmp6 := lang.Apply(tmp5, []any{v4, v3}) - return tmp6 - default: - checkArity(args, -1) - panic("unreachable") + tmp20 := lang.Apply(tmp16, []any{tmp19, v4}) + tmp21 := lang.Apply(tmp12, []any{tmp15, tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp10, []any{tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp9, tmp23, v5}) + tmp25 := lang.Apply(tmp6, []any{tmp24}) + return tmp25 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_letfn = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_letfn.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // read+string + // lift-ns { - tmp0 := sym_read_PLUS_string.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_stream), lang.NewVector(sym_stream, sym_eof_DASH_error_QMARK_, sym_eof_DASH_value), lang.NewVector(sym_stream, sym_eof_DASH_error_QMARK_, sym_eof_DASH_value, sym_recursive_QMARK_), lang.NewVector(sym_opts, sym_stream)), kw_doc, "Like read, and taking the same args. stream must be a LineNumberingPushbackReader.\n Returns a vector containing the object read and the (whitespace-trimmed) string read.", kw_file, "glojure/core.glj", kw_added, "1.10", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(3771), kw_end_DASH_line, int(3771))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp3 := checkDerefVar(var_glojure_DOT_core_read_PLUS_string) - tmp4 := checkDerefVar(var_glojure_DOT_core__STAR_in_STAR_) - tmp5 := lang.Apply(tmp3, []any{tmp4}) - return tmp5 - case 1: - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_read_PLUS_string) - tmp5 := lang.Apply(tmp4, []any{v3, true, nil}) - return tmp5 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6 := checkDerefVar(var_glojure_DOT_core_read_PLUS_string) - tmp7 := lang.Apply(tmp6, []any{v3, v4, v5, false}) - return tmp7 - case 4: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - var tmp7 any - func() { - defer func() { - if r := recover(); r != nil { - if lang.CatchMatches(r, lang.Throwable) { - v8 := r - _ = v8 - tmp9, ok := lang.FieldOrMethod(v3, "getString") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getString"))) - } - var tmp10 any - switch reflect.TypeOf(tmp9).Kind() { - case reflect.Func: - tmp10 = lang.Apply(tmp9, nil) - default: - tmp10 = tmp9 - } - _ = tmp10 - panic(v8) - } else { - panic(r) - } - } - }() - tmp8, ok := lang.FieldOrMethod(v3, "captureString") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "captureString"))) - } - var tmp9 any - switch reflect.TypeOf(tmp8).Kind() { - case reflect.Func: - tmp9 = lang.Apply(tmp8, nil) - default: - tmp9 = tmp8 + tmp0 := sym_lift_DASH_ns.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m)), kw_doc, "Returns [lifted-ns lifted-kvs] or nil if m can't be lifted.", kw_file, "glojure/core_print.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(8), kw_line, int(261), kw_end_DASH_line, int(261), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_namespace_DASH_maps_STAR_) + if lang.IsTruthy(tmp4) { + var tmp5 any + { // let + // let binding "ns" + var v6 any = nil + _ = v6 + // let binding "G__221" + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := lang.Apply(tmp7, []any{v2}) + var v9 any = tmp8 + _ = v9 + // let binding "vec__222" + var v10 any = v9 + _ = v10 + // let binding "seq__223" + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := lang.Apply(tmp11, []any{v10}) + var v13 any = tmp12 + _ = v13 + // let binding "first__224" + tmp14 := checkDerefVar(var_glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v13}) + var v16 any = tmp15 + _ = v16 + // let binding "seq__223" + tmp17 := checkDerefVar(var_glojure_DOT_core_next) + tmp18 := lang.Apply(tmp17, []any{v13}) + var v19 any = tmp18 + _ = v19 + // let binding "vec__225" + var v20 any = v16 + _ = v20 + // let binding "k" + tmp21 := checkDerefVar(var_glojure_DOT_core_nth) + tmp22 := lang.Apply(tmp21, []any{v20, int64(0), nil}) + var v23 any = tmp22 + _ = v23 + // let binding "v" + tmp24 := checkDerefVar(var_glojure_DOT_core_nth) + tmp25 := lang.Apply(tmp24, []any{v20, int64(1), nil}) + var v26 any = tmp25 + _ = v26 + // let binding "entry" + var v27 any = v20 + _ = v27 + // let binding "entries" + var v28 any = v19 + _ = v28 + // let binding "kvs" + tmp29 := lang.NewVector() + tmp30 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(267), kw_column, int(16), kw_end_DASH_line, int(267), kw_end_DASH_column, int(17)) + tmp31, err := lang.WithMeta(tmp29, tmp30.(lang.IPersistentMap)) + if err != nil { + panic(err) } - _ = tmp9 - var tmp10 any + var v32 any = tmp31 + _ = v32 + var tmp33 any { // let - // let binding "o" - tmp11 := checkDerefVar(var_glojure_DOT_core_read) - tmp12 := lang.Apply(tmp11, []any{v3, v4, v5, v6}) - var v13 any = tmp12 - _ = v13 - // let binding "s" - tmp14, ok := lang.FieldOrMethod(v3, "getString") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getString"))) - } - var tmp15 any - switch reflect.TypeOf(tmp14).Kind() { - case reflect.Func: - tmp15 = lang.Apply(tmp14, nil) - default: - tmp15 = tmp14 - } - tmp16, ok := lang.FieldOrMethod(tmp15, "trim") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp15, "trim"))) - } - var tmp17 any - switch reflect.TypeOf(tmp16).Kind() { - case reflect.Func: - tmp17 = lang.Apply(tmp16, nil) - default: - tmp17 = tmp16 - } - var v18 any = tmp17 - _ = v18 - tmp19 := lang.NewVector(v13, v18) - tmp20 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3783), kw_column, int(8), kw_end_DASH_line, int(3783), kw_end_DASH_column, int(12)) - tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp10 = tmp21 - } // end let - tmp7 = tmp10 - }() - return tmp7 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - func() { - defer func() { - if r := recover(); r != nil { - if lang.CatchMatches(r, lang.Throwable) { - v6 := r - _ = v6 - tmp7, ok := lang.FieldOrMethod(v4, "getString") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "getString"))) - } - var tmp8 any - switch reflect.TypeOf(tmp7).Kind() { - case reflect.Func: - tmp8 = lang.Apply(tmp7, nil) - default: - tmp8 = tmp7 + // let binding "ns" + var v34 any = v6 + _ = v34 + // let binding "G__221" + var v35 any = v9 + _ = v35 + // let binding "kvs" + var v36 any = v32 + _ = v36 + for { + var tmp37 any + { // let + // let binding "ns" + var v38 any = v34 + _ = v38 + // let binding "vec__228" + var v39 any = v35 + _ = v39 + // let binding "seq__229" + tmp40 := checkDerefVar(var_glojure_DOT_core_seq) + tmp41 := lang.Apply(tmp40, []any{v39}) + var v42 any = tmp41 + _ = v42 + // let binding "first__230" + tmp43 := checkDerefVar(var_glojure_DOT_core_first) + tmp44 := lang.Apply(tmp43, []any{v42}) + var v45 any = tmp44 + _ = v45 + // let binding "seq__229" + tmp46 := checkDerefVar(var_glojure_DOT_core_next) + tmp47 := lang.Apply(tmp46, []any{v42}) + var v48 any = tmp47 + _ = v48 + // let binding "vec__231" + var v49 any = v45 + _ = v49 + // let binding "k" + tmp50 := checkDerefVar(var_glojure_DOT_core_nth) + tmp51 := lang.Apply(tmp50, []any{v49, int64(0), nil}) + var v52 any = tmp51 + _ = v52 + // let binding "v" + tmp53 := checkDerefVar(var_glojure_DOT_core_nth) + tmp54 := lang.Apply(tmp53, []any{v49, int64(1), nil}) + var v55 any = tmp54 + _ = v55 + // let binding "entry" + var v56 any = v49 + _ = v56 + // let binding "entries" + var v57 any = v48 + _ = v57 + // let binding "kvs" + var v58 any = v36 + _ = v58 + var tmp59 any + if lang.IsTruthy(v56) { + var tmp60 any + tmp61 := checkDerefVar(var_glojure_DOT_core_qualified_DASH_ident_QMARK_) + tmp62 := lang.Apply(tmp61, []any{v52}) + if lang.IsTruthy(tmp62) { + var tmp63 any + if lang.IsTruthy(v38) { + var tmp64 any + tmp65 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp66 := checkDerefVar(var_glojure_DOT_core_namespace) + tmp67 := lang.Apply(tmp66, []any{v52}) + tmp68 := lang.Apply(tmp65, []any{v38, tmp67}) + if lang.IsTruthy(tmp68) { + var tmp69 any = v38 + var tmp70 any = v57 + tmp72 := checkDerefVar(var_glojure_DOT_core_conj) + tmp73 := checkDerefVar(var_glojure_DOT_core_strip_DASH_ns) + tmp74 := lang.Apply(tmp73, []any{v52}) + tmp75 := lang.NewVector(tmp74, v55) + tmp76 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(272), kw_column, int(43), kw_end_DASH_line, int(272), kw_end_DASH_column, int(58)) + tmp77, err := lang.WithMeta(tmp75, tmp76.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp78 := lang.Apply(tmp72, []any{v58, tmp77}) + var tmp71 any = tmp78 + v34 = tmp69 + v35 = tmp70 + v36 = tmp71 + continue + } else { + } + tmp63 = tmp64 + } else { + var tmp79 any + { // let + // let binding "temp__0__auto__" + tmp80 := checkDerefVar(var_glojure_DOT_core_namespace) + tmp81 := lang.Apply(tmp80, []any{v52}) + var v82 any = tmp81 + _ = v82 + var tmp83 any + if lang.IsTruthy(v82) { + var tmp84 any + { // let + // let binding "new-ns" + var v85 any = v82 + _ = v85 + var tmp86 any = v85 + var tmp87 any = v57 + tmp89 := checkDerefVar(var_glojure_DOT_core_conj) + tmp90 := checkDerefVar(var_glojure_DOT_core_strip_DASH_ns) + tmp91 := lang.Apply(tmp90, []any{v52}) + tmp92 := lang.NewVector(tmp91, v55) + tmp93 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(274), kw_column, int(47), kw_end_DASH_line, int(274), kw_end_DASH_column, int(62)) + tmp94, err := lang.WithMeta(tmp92, tmp93.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp95 := lang.Apply(tmp89, []any{v58, tmp94}) + var tmp88 any = tmp95 + v34 = tmp86 + v35 = tmp87 + v36 = tmp88 + continue + } // end let + tmp83 = tmp84 + } else { + } + tmp79 = tmp83 + } // end let + tmp63 = tmp79 + } + tmp60 = tmp63 + } else { + } + tmp59 = tmp60 + } else { + tmp80 := lang.NewVector(v38, v58) + tmp81 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(275), kw_column, int(9), kw_end_DASH_line, int(275), kw_end_DASH_column, int(16)) + tmp82, err := lang.WithMeta(tmp80, tmp81.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp59 = tmp82 } - _ = tmp8 - panic(v6) - } else { - panic(r) - } - } - }() - tmp6, ok := lang.FieldOrMethod(v4, "captureString") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "captureString"))) - } - var tmp7 any - switch reflect.TypeOf(tmp6).Kind() { - case reflect.Func: - tmp7 = lang.Apply(tmp6, nil) - default: - tmp7 = tmp6 - } - _ = tmp7 - var tmp8 any - { // let - // let binding "o" - tmp9 := checkDerefVar(var_glojure_DOT_core_read) - tmp10 := lang.Apply(tmp9, []any{v3, v4}) - var v11 any = tmp10 - _ = v11 - // let binding "s" - tmp12, ok := lang.FieldOrMethod(v4, "getString") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "getString"))) - } - var tmp13 any - switch reflect.TypeOf(tmp12).Kind() { - case reflect.Func: - tmp13 = lang.Apply(tmp12, nil) - default: - tmp13 = tmp12 - } - tmp14, ok := lang.FieldOrMethod(tmp13, "trim") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp13, "trim"))) - } - var tmp15 any - switch reflect.TypeOf(tmp14).Kind() { - case reflect.Func: - tmp15 = lang.Apply(tmp14, nil) - default: - tmp15 = tmp14 - } - var v16 any = tmp15 - _ = v16 - tmp17 := lang.NewVector(v11, v16) - tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3792), kw_column, int(8), kw_end_DASH_line, int(3792), kw_end_DASH_column, int(12)) - tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) - if err != nil { - panic(err) + tmp37 = tmp59 + } // end let + tmp33 = tmp37 + break } - tmp8 = tmp19 } // end let - tmp5 = tmp8 - }() - return tmp5 - default: - checkArity(args, -1) - panic("unreachable") - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // read-line - { - tmp0 := sym_read_DASH_line.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Reads the next line from stream that is the current value of *in* .", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(3797), kw_end_DASH_line, int(3797))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - var tmp3 any - tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_in_STAR_) - tmp6 := lang.Apply(tmp4, []any{nil, tmp5}) - if lang.IsTruthy(tmp6) { - tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_in_STAR_) - tmp8, ok := lang.FieldOrMethod(tmp7, "readLine") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp7, "readLine"))) - } - var tmp9 any - switch reflect.TypeOf(tmp8).Kind() { - case reflect.Func: - tmp9 = lang.Apply(tmp8, nil) - default: - tmp9 = tmp8 - } - tmp3 = tmp9 + tmp5 = tmp33 + } // end let + tmp3 = tmp5 } else { - tmp10 := checkDerefVar(var_glojure_DOT_core__STAR_in_STAR_) - tmp11, ok := lang.FieldOrMethod(tmp10, "readLine") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp10, "readLine"))) - } - var tmp12 any - switch reflect.TypeOf(tmp11).Kind() { - case reflect.Func: - tmp12 = lang.Apply(tmp11, nil) - default: - tmp12 = tmp11 - } - tmp3 = tmp12 } return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_lift_DASH_ns = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_lift_DASH_ns.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // read-string + // make-array { - tmp0 := sym_read_DASH_string.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s), lang.NewVector(sym_opts, sym_s)), kw_doc, "Reads one object from the string s. Optionally include reader\n options, as specified in read.\n\n Note that read-string can execute code (controlled by *read-eval*),\n and as such should be used only with trusted sources.\n\n For data structure interop use glojure.edn/read-string", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(3806), kw_end_DASH_line, int(3806))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_make_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_type, sym_len), lang.NewVector(sym_type, sym_dim, sym__AMP_, sym_more_DASH_dims)), kw_doc, "Creates and returns an array of instances of the specified class of\n the specified dimension(s). Note that a class object is required.\n Class objects can be obtained by using their imported or\n fully-qualified name. Class objects for the primitive types can be\n obtained using, e.g., Integer/TYPE.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(3985), kw_end_DASH_line, int(3985))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 1: - v3 := args[0] - _ = v3 - tmp4 := lang.Apply(runtime.RTReadString, []any{v3}) - return tmp4 case 2: - v3 := args[0] + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + tmp4 := checkDerefVar(var_glojure_DOT_core_int) + tmp5 := lang.Apply(tmp4, []any{v3}) + tmp6, _ := lang.FieldOrMethod(nil, "newInstance") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("newInstance is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v2, tmp5}) + return tmp7 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) _ = v4 - tmp5 := lang.Apply(runtime.RTReadString, []any{v4, v3}) + var tmp5 any + { // let + // let binding "dims" + tmp6 := checkDerefVar(var_glojure_DOT_core_cons) + tmp7 := lang.Apply(tmp6, []any{v3, v4}) + var v8 any = tmp7 + _ = v8 + // let binding "dimarray" + tmp9 := checkDerefVar(var_glojure_DOT_core_make_DASH_array) + tmp10, ok := lang.FieldOrMethod(nil, "TYPE") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "TYPE"))) + } + var tmp11 any + switch reflect.TypeOf(tmp10).Kind() { + case reflect.Func: + tmp11 = lang.Apply(tmp10, nil) + default: + tmp11 = tmp10 + } + tmp12 := checkDerefVar(var_glojure_DOT_core_count) + tmp13 := lang.Apply(tmp12, []any{v8}) + tmp14 := lang.Apply(tmp9, []any{tmp11, tmp13}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + { // let + // let binding "n__0__auto__" + tmp17 := checkDerefVar(var_glojure_DOT_core_long) + tmp18 := checkDerefVar(var_glojure_DOT_core_alength) + tmp19 := lang.Apply(tmp18, []any{v15}) + tmp20 := lang.Apply(tmp17, []any{tmp19}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + { // let + // let binding "i" + var v23 any = int64(0) + _ = v23 + for { + var tmp24 any + tmp25 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp26 := lang.Apply(tmp25, []any{v23, v21}) + if lang.IsTruthy(tmp26) { + tmp27 := checkDerefVar(var_glojure_DOT_core_aset_DASH_int) + tmp28 := checkDerefVar(var_glojure_DOT_core_nth) + tmp29 := lang.Apply(tmp28, []any{v8, v23}) + tmp30 := lang.Apply(tmp27, []any{v15, v23, tmp29}) + _ = tmp30 + tmp32 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp33 := lang.Apply(tmp32, []any{v23}) + var tmp31 any = tmp33 + v23 = tmp31 + continue + } else { + } + tmp22 = tmp24 + break + } + } // end let + tmp16 = tmp22 + } // end let + _ = tmp16 + tmp17, _ := lang.FieldOrMethod(nil, "newInstance") + if reflect.TypeOf(tmp17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("newInstance is not a function"))) + } + tmp18 := lang.Apply(tmp17, []any{v2, v15}) + tmp5 = tmp18 + } // end let return tmp5 - default: - checkArity(args, -1) - panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // reader-conditional - { - tmp0 := sym_reader_DASH_conditional.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_form, sym_splicing_QMARK_)), kw_doc, "Construct a data representation of a reader conditional.\n If true, splicing? indicates read-cond-splicing.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(24), kw_column, int(7), kw_line, int(7782), kw_end_DASH_line, int(7782))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.Apply(nil, []any{v3, v4}) - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // reader-conditional? - { - tmp0 := sym_reader_DASH_conditional_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_value)), kw_doc, "Return true if the value is the data representation of a reader conditional", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(25), kw_column, int(7), kw_line, int(7776), kw_end_DASH_line, int(7776))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp5 := lang.Apply(tmp4, []any{nil, v3}) - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_make_DASH_array = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_make_DASH_array.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // realized? + // maybe-min-hash { - tmp0 := sym_realized_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if a value has been produced for a promise, delay, future or lazy sequence.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(7559), kw_end_DASH_line, int(7559))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_maybe_DASH_min_DASH_hash.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_hashes)), kw_doc, "takes a collection of hashes and returns [shift mask] or nil if none found", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(8), kw_line, int(6604), kw_end_DASH_line, int(6604), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4, ok := lang.FieldOrMethod(v3, "isRealized") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "isRealized"))) - } - var tmp5 any - switch reflect.TypeOf(tmp4).Kind() { - case reflect.Func: - tmp5 = lang.Apply(tmp4, nil) - default: - tmp5 = tmp4 - } - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // reduce - { - tmp0 := sym_reduce.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_coll), lang.NewVector(sym_f, sym_val, sym_coll)), kw_doc, "f should be a function of 2 arguments. If val is not supplied,\n returns the result of applying f to the first 2 items in coll, then\n applying f to that result and the 3rd item, etc. If coll contains no\n items, f must accept no arguments as well, and reduce returns the\n result of calling f with no arguments. If coll has only 1 item, it\n is returned and f is not called. If val is supplied, returns the\n result of applying f to val and the first item in coll, then\n applying f to that result and the 2nd item, etc. If coll contains no\n items, returns val and f is not called.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(6860), kw_end_DASH_line, int(6860))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - tmp6 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp7 := reflect.TypeOf((*lang.IReduce)(nil)).Elem() - tmp8 := lang.Apply(tmp6, []any{tmp7, v4}) - if lang.IsTruthy(tmp8) { - tmp9, _ := lang.FieldOrMethod(v4, "Reduce") - if reflect.TypeOf(tmp9).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Reduce is not a function"))) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_first) + tmp4 := checkDerefVar(var_glojure_DOT_core_filter) + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v6 := args[0] + _ = v6 + var tmp7 any + { // let + // let binding "vec__151" + var v8 any = v6 + _ = v8 + // let binding "s" + tmp9 := checkDerefVar(var_glojure_DOT_core_nth) + tmp10 := lang.Apply(tmp9, []any{v8, int64(0), nil}) + var v11 any = tmp10 + _ = v11 + // let binding "m" + tmp12 := checkDerefVar(var_glojure_DOT_core_nth) + tmp13 := lang.Apply(tmp12, []any{v8, int64(1), nil}) + var v14 any = tmp13 + _ = v14 + tmp15 := checkDerefVar(var_glojure_DOT_core_apply) + tmp16 := checkDerefVar(var_glojure_DOT_core_distinct_QMARK_) + tmp17 := checkDerefVar(var_glojure_DOT_core_map) + var tmp18 lang.FnFunc + tmp18 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v19 := args[0] + _ = v19 + tmp20 := checkDerefVar(var_glojure_DOT_core_shift_DASH_mask) + tmp21 := lang.Apply(tmp20, []any{v11, v14, v19}) + return tmp21 + }) + tmp19 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6609), kw_column, int(37), kw_end_DASH_line, int(6609), kw_end_DASH_column, int(55)) + tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) + if err != nil { + panic(err) } - tmp10 := lang.Apply(tmp9, []any{v3}) - tmp5 = tmp10 - } else { - tmp11 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_coll_DASH_reduce) - tmp12 := lang.Apply(tmp11, []any{v4, v3}) - tmp5 = tmp12 + tmp21 := lang.Apply(tmp17, []any{tmp20, v2}) + tmp22 := lang.Apply(tmp15, []any{tmp16, tmp21}) + tmp7 = tmp22 + } // end let + return tmp7 + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6608), kw_column, int(13), kw_end_DASH_line, int(6609), kw_end_DASH_column, int(65)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var tmp8 any + { // let + // let binding "iter__0__auto__" + var tmp9 lang.FnFunc + { // function iter__154 + var v10 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v11 := args[0] + _ = v11 + var tmp12 lang.FnFunc + tmp12 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp13 any + { // let + // let binding "s__155" + var v14 any = v11 + _ = v14 + for { + var tmp15 any + { // let + // let binding "temp__0__auto__" + tmp16 := checkDerefVar(var_glojure_DOT_core_seq) + tmp17 := lang.Apply(tmp16, []any{v14}) + var v18 any = tmp17 + _ = v18 + var tmp19 any + if lang.IsTruthy(v18) { + var tmp20 any + { // let + // let binding "xs__0__auto__" + var v21 any = v18 + _ = v21 + var tmp22 any + { // let + // let binding "mask" + tmp23 := checkDerefVar(var_glojure_DOT_core_first) + tmp24 := lang.Apply(tmp23, []any{v21}) + var v25 any = tmp24 + _ = v25 + var tmp26 any + { // let + // let binding "iterys__0__auto__" + var tmp27 lang.FnFunc + { // function iter__156 + var v28 lang.FnFunc + tmp27 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v29 := args[0] + _ = v29 + var tmp30 lang.FnFunc + tmp30 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp31 any + { // let + // let binding "s__157" + var v32 any = v29 + _ = v32 + for { + var tmp33 any + { // let + // let binding "temp__0__auto__" + tmp34 := checkDerefVar(var_glojure_DOT_core_seq) + tmp35 := lang.Apply(tmp34, []any{v32}) + var v36 any = tmp35 + _ = v36 + var tmp37 any + if lang.IsTruthy(v36) { + var tmp38 any + { // let + // let binding "s__157" + var v39 any = v36 + _ = v39 + var tmp40 any + tmp41 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp42 := lang.Apply(tmp41, []any{v39}) + if lang.IsTruthy(tmp42) { + var tmp43 any + { // let + // let binding "c__0__auto__" + tmp44 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp45 := lang.Apply(tmp44, []any{v39}) + var v46 any = tmp45 + _ = v46 + // let binding "size__1__auto__" + tmp47 := checkDerefVar(var_glojure_DOT_core_int) + tmp48 := checkDerefVar(var_glojure_DOT_core_count) + tmp49 := lang.Apply(tmp48, []any{v46}) + tmp50 := lang.Apply(tmp47, []any{tmp49}) + var v51 any = tmp50 + _ = v51 + // let binding "b__159" + tmp52 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_buffer) + tmp53 := lang.Apply(tmp52, []any{v51}) + var v54 any = tmp53 + _ = v54 + var tmp55 any + var tmp56 any + { // let + // let binding "i__158" + tmp57 := checkDerefVar(var_glojure_DOT_core_int) + tmp58 := lang.Apply(tmp57, []any{int64(0)}) + var v59 any = tmp58 + _ = v59 + for { + var tmp60 any + tmp61 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp62 := lang.Apply(tmp61, []any{v59, v51}) + if lang.IsTruthy(tmp62) { + var tmp63 any + { // let + // let binding "shift" + tmp64, _ := lang.FieldOrMethod(v46, "nth") + if reflect.TypeOf(tmp64).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp65 := lang.Apply(tmp64, []any{v59}) + var v66 any = tmp65 + _ = v66 + tmp67 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_append) + tmp68 := lang.NewVector(v66, v25) + tmp69 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6612), kw_column, int(15), kw_end_DASH_line, int(6612), kw_end_DASH_column, int(26)) + tmp70, err := lang.WithMeta(tmp68, tmp69.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp71 := lang.Apply(tmp67, []any{v54, tmp70}) + _ = tmp71 + tmp73 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp74 := lang.Apply(tmp73, []any{v59}) + var tmp72 any = tmp74 + v59 = tmp72 + continue + } // end let + tmp60 = tmp63 + } else { + tmp60 = true + } + tmp56 = tmp60 + break + } + } // end let + if lang.IsTruthy(tmp56) { + tmp57 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_cons) + tmp58 := checkDerefVar(var_glojure_DOT_core_chunk) + tmp59 := lang.Apply(tmp58, []any{v54}) + tmp60 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp61 := lang.Apply(tmp60, []any{v39}) + tmp62 := lang.Apply(v28, []any{tmp61}) + tmp63 := lang.Apply(tmp57, []any{tmp59, tmp62}) + tmp55 = tmp63 + } else { + tmp64 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_cons) + tmp65 := checkDerefVar(var_glojure_DOT_core_chunk) + tmp66 := lang.Apply(tmp65, []any{v54}) + tmp67 := lang.Apply(tmp64, []any{tmp66, nil}) + tmp55 = tmp67 + } + tmp43 = tmp55 + } // end let + tmp40 = tmp43 + } else { + var tmp44 any + { // let + // let binding "shift" + tmp45 := checkDerefVar(var_glojure_DOT_core_first) + tmp46 := lang.Apply(tmp45, []any{v39}) + var v47 any = tmp46 + _ = v47 + tmp48 := checkDerefVar(var_glojure_DOT_core_cons) + tmp49 := lang.NewVector(v47, v25) + tmp50 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6612), kw_column, int(15), kw_end_DASH_line, int(6612), kw_end_DASH_column, int(26)) + tmp51, err := lang.WithMeta(tmp49, tmp50.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp52 := checkDerefVar(var_glojure_DOT_core_rest) + tmp53 := lang.Apply(tmp52, []any{v39}) + tmp54 := lang.Apply(v28, []any{tmp53}) + tmp55 := lang.Apply(tmp48, []any{tmp51, tmp54}) + tmp44 = tmp55 + } // end let + tmp40 = tmp44 + } + tmp38 = tmp40 + } // end let + tmp37 = tmp38 + } else { + } + tmp33 = tmp37 + } // end let + tmp31 = tmp33 + break + } + } // end let + return tmp31 + }) + tmp31 := lang.Apply(lang.NewLazySeq, []any{tmp30}) + return tmp31 + }) + v28 = tmp27 + _ = v28 + } + var v28 any = tmp27 + _ = v28 + // let binding "fs__1__auto__" + tmp29 := checkDerefVar(var_glojure_DOT_core_seq) + tmp30 := checkDerefVar(var_glojure_DOT_core_range) + tmp31 := lang.Apply(tmp30, []any{int64(0), int64(31)}) + tmp32 := lang.Apply(v28, []any{tmp31}) + tmp33 := lang.Apply(tmp29, []any{tmp32}) + var v34 any = tmp33 + _ = v34 + var tmp35 any + if lang.IsTruthy(v34) { + tmp36 := checkDerefVar(var_glojure_DOT_core_concat) + tmp37 := checkDerefVar(var_glojure_DOT_core_rest) + tmp38 := lang.Apply(tmp37, []any{v14}) + tmp39 := lang.Apply(v10, []any{tmp38}) + tmp40 := lang.Apply(tmp36, []any{v34, tmp39}) + tmp35 = tmp40 + } else { + tmp42 := checkDerefVar(var_glojure_DOT_core_rest) + tmp43 := lang.Apply(tmp42, []any{v14}) + var tmp41 any = tmp43 + v14 = tmp41 + continue + } + tmp26 = tmp35 + } // end let + tmp22 = tmp26 + } // end let + tmp20 = tmp22 + } // end let + tmp19 = tmp20 + } else { + } + tmp15 = tmp19 + } // end let + tmp13 = tmp15 + break + } + } // end let + return tmp13 + }) + tmp13 := lang.Apply(lang.NewLazySeq, []any{tmp12}) + return tmp13 + }) + v10 = tmp9 + _ = v10 } - return tmp5 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var tmp6 any - tmp7 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp8 := reflect.TypeOf((*lang.IReduceInit)(nil)).Elem() - tmp9 := lang.Apply(tmp7, []any{tmp8, v5}) - if lang.IsTruthy(tmp9) { - tmp10, _ := lang.FieldOrMethod(v5, "ReduceInit") - if reflect.TypeOf(tmp10).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) - } - tmp11 := lang.Apply(tmp10, []any{v3, v4}) - tmp6 = tmp11 - } else { - tmp12 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_coll_DASH_reduce) - tmp13 := lang.Apply(tmp12, []any{v5, v3, v4}) - tmp6 = tmp13 + var v10 any = tmp9 + _ = v10 + tmp11 := checkDerefVar(var_glojure_DOT_core_map) + var tmp12 lang.FnFunc + tmp12 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v13 := args[0] + _ = v13 + tmp14 := checkDerefVar(var_glojure_DOT_core_dec) + tmp15 := checkDerefVar(var_glojure_DOT_core_bit_DASH_shift_DASH_left) + tmp16 := lang.Apply(tmp15, []any{int64(1), v13}) + tmp17 := lang.Apply(tmp14, []any{tmp16}) + return tmp17 + }) + tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6610), kw_column, int(29), kw_end_DASH_line, int(6610), kw_end_DASH_column, int(55)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) + if err != nil { + panic(err) } - return tmp6 - default: - checkArity(args, -1) - panic("unreachable") - } + tmp15 := checkDerefVar(var_glojure_DOT_core_range) + tmp16 := checkDerefVar(var_glojure_DOT_core_inc) + tmp17 := checkDerefVar(var_glojure_DOT_core_max_DASH_mask_DASH_bits) + tmp18 := lang.Apply(tmp16, []any{tmp17}) + tmp19 := lang.Apply(tmp15, []any{int64(1), tmp18}) + tmp20 := lang.Apply(tmp11, []any{tmp14, tmp19}) + tmp21 := lang.Apply(v10, []any{tmp20}) + tmp8 = tmp21 + } // end let + tmp9 := lang.Apply(tmp4, []any{tmp7, tmp8}) + tmp10 := lang.Apply(tmp3, []any{tmp9}) + return tmp10 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_maybe_DASH_min_DASH_hash = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_maybe_DASH_min_DASH_hash.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // reduce-kv + // memoize { - tmp0 := sym_reduce_DASH_kv.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_init, sym_coll)), kw_doc, "Reduces an associative collection. f should be a function of 3\n arguments. Returns the result of applying f to init, the first key\n and the first value in coll, then applying f to that result and the\n 2nd key and value, etc. If coll contains no entries, returns init\n and f is not called. Note that reduce-kv is supported on vectors,\n where the keys will be the ordinals.", kw_file, "glojure/core.glj", kw_added, "1.4", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(6882), kw_end_DASH_line, int(6882))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 3) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_kv_DASH_reduce) - tmp7 := lang.Apply(tmp6, []any{v5, v3, v4}) - return tmp7 + tmp0 := sym_memoize.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f)), kw_doc, "Returns a memoized version of a referentially transparent function. The\n memoized version of the function keeps a cache of the mapping from arguments\n to results and, when calls with the same arguments are repeated often, has\n higher performance at the expense of higher memory use.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(6337), kw_end_DASH_line, int(6337))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "mem" + tmp4 := checkDerefVar(var_glojure_DOT_core_atom) + tmp5 := lang.NewMap() + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6345), kw_column, int(19), kw_end_DASH_line, int(6345), kw_end_DASH_column, int(20)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp8 := lang.Apply(tmp4, []any{tmp7}) + var v9 any = tmp8 + _ = v9 + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v11 any = lang.NewList(args[0:]...) + _ = v11 + var tmp12 any + { // let + // let binding "temp__0__auto__" + tmp13 := checkDerefVar(var_glojure_DOT_core_find) + tmp14 := checkDerefVar(var_glojure_DOT_core_deref) + tmp15 := lang.Apply(tmp14, []any{v9}) + tmp16 := lang.Apply(tmp13, []any{tmp15, v11}) + var v17 any = tmp16 + _ = v17 + var tmp18 any + if lang.IsTruthy(v17) { + var tmp19 any + { // let + // let binding "e" + var v20 any = v17 + _ = v20 + tmp21 := checkDerefVar(var_glojure_DOT_core_val) + tmp22 := lang.Apply(tmp21, []any{v20}) + tmp19 = tmp22 + } // end let + tmp18 = tmp19 + } else { + var tmp20 any + { // let + // let binding "ret" + tmp21 := checkDerefVar(var_glojure_DOT_core_apply) + tmp22 := lang.Apply(tmp21, []any{v2, v11}) + var v23 any = tmp22 + _ = v23 + tmp24 := checkDerefVar(var_glojure_DOT_core_swap_BANG_) + tmp25 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp26 := lang.Apply(tmp24, []any{v9, tmp25, v11, v23}) + _ = tmp26 + tmp20 = v23 + } // end let + tmp18 = tmp20 + } + tmp12 = tmp18 + } // end let + return tmp12 + } + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6346), kw_column, int(5), kw_end_DASH_line, int(6351), kw_end_DASH_column, int(16)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp3 = tmp12 + } // end let + return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_memoize = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_memoize.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // reduce1 + // ns { - tmp0 := sym_reduce1.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(923), kw_column, int(7), kw_end_DASH_line, int(924), kw_end_DASH_column, int(9), kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_coll), lang.NewVector(sym_f, sym_val, sym_coll)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_ns.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym_docstring_QMARK_, sym_attr_DASH_map_QMARK_, sym_references_STAR_)), kw_doc, "Sets *ns* to the namespace named by name (unevaluated), creating it\n if needed. references can be zero or more of: (:refer-glojure ...)\n (:require ...) (:use ...) (:import ...) (:load ...) (:gen-class)\n with the syntax of refer-glojure/require/use/import/load/gen-class\n respectively, except the arguments are unevaluated and need not be\n quoted. (:gen-class ...), when supplied, defaults to :name\n corresponding to the ns name, :main true, :impl-ns same as ns, and\n :init-impl-ns true. All options of gen-class are\n supported. The :gen-class directive is ignored when not\n compiling. If :gen-class is not supplied, when compiled only an\n nsname__init.class will be generated. If :refer-glojure is not used, a\n default (refer 'glojure.core) is used. Use of ns is preferred to\n individual calls to in-ns/require/use/import:\n\n (ns foo.bar\n (:refer-glojure :exclude [ancestors printf])\n (:require (glojure.contrib sql combinatorics))\n (:use (my.lib this that))\n (:import (java.util Date Timer Random)\n (java.sql Connection Statement)))", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(11), kw_line, int(5742), kw_end_DASH_line, int(5742))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - { // let - // let binding "s" - tmp6 := checkDerefVar(var_glojure_DOT_core_seq) - tmp7 := lang.Apply(tmp6, []any{v4}) - var v8 any = tmp7 - _ = v8 - var tmp9 any - if lang.IsTruthy(v8) { - tmp10 := checkDerefVar(var_glojure_DOT_core_reduce1) - tmp11 := checkDerefVar(var_glojure_DOT_core_first) - tmp12 := lang.Apply(tmp11, []any{v8}) - tmp13 := checkDerefVar(var_glojure_DOT_core_next) - tmp14 := lang.Apply(tmp13, []any{v8}) - tmp15 := lang.Apply(tmp10, []any{v3, tmp12, tmp14}) - tmp9 = tmp15 - } else { - tmp16 := lang.Apply(v3, nil) - tmp9 = tmp16 - } - tmp5 = tmp9 - } // end let - return tmp5 - case 3: - v3 := args[0] + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + v4 := args[2] _ = v4 - v5 := args[2] + var v5 any = lang.NewList(args[3:]...) _ = v5 - recur_loop_156: var tmp6 any { // let - // let binding "s" - tmp7 := checkDerefVar(var_glojure_DOT_core_seq) - tmp8 := lang.Apply(tmp7, []any{v5}) - var v9 any = tmp8 - _ = v9 - var tmp10 any - if lang.IsTruthy(v9) { - var tmp11 any - tmp12 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) - tmp13 := lang.Apply(tmp12, []any{v9}) - if lang.IsTruthy(tmp13) { - var tmp14 any = v3 - tmp16 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) - tmp17 := lang.Apply(tmp16, []any{v9}) - tmp18, _ := lang.FieldOrMethod(tmp17, "ReduceInit") - if reflect.TypeOf(tmp18).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) + // let binding "process-reference" + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v8 := args[0] + _ = v8 + var tmp9 any + { // let + // let binding "vec__107" + var v10 any = v8 + _ = v10 + // let binding "seq__108" + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := lang.Apply(tmp11, []any{v10}) + var v13 any = tmp12 + _ = v13 + // let binding "first__109" + tmp14 := checkDerefVar(var_glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v13}) + var v16 any = tmp15 + _ = v16 + // let binding "seq__108" + tmp17 := checkDerefVar(var_glojure_DOT_core_next) + tmp18 := lang.Apply(tmp17, []any{v13}) + var v19 any = tmp18 + _ = v19 + // let binding "kname" + var v20 any = v16 + _ = v20 + // let binding "args" + var v21 any = v19 + _ = v21 + tmp22 := checkDerefVar(var_glojure_DOT_core_seq) + tmp23 := checkDerefVar(var_glojure_DOT_core_concat) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := checkDerefVar(var_glojure_DOT_core_symbol) + tmp26 := checkDerefVar(var_glojure_DOT_core_name) + tmp27 := lang.Apply(tmp26, []any{v20}) + tmp28 := lang.Apply(tmp25, []any{"glojure.core", tmp27}) + tmp29 := lang.Apply(tmp24, []any{tmp28}) + tmp30 := checkDerefVar(var_glojure_DOT_core_map) + var tmp31 lang.FnFunc + tmp31 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v32 := args[0] + _ = v32 + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{sym_quote, v32}) + return tmp34 + }) + tmp32 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5769), kw_column, int(21), kw_end_DASH_line, int(5769), kw_end_DASH_column, int(36)) + tmp33, err := lang.WithMeta(tmp31, tmp32.(lang.IPersistentMap)) + if err != nil { + panic(err) } - tmp19 := lang.Apply(tmp18, []any{v3, v4}) - var tmp15 any = tmp19 - tmp21 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_next) - tmp22 := lang.Apply(tmp21, []any{v9}) - var tmp20 any = tmp22 - v3 = tmp14 - v4 = tmp15 - v5 = tmp20 - goto recur_loop_156 + tmp34 := lang.Apply(tmp30, []any{tmp33, v21}) + tmp35 := lang.Apply(tmp23, []any{tmp29, tmp34}) + tmp36 := lang.Apply(tmp22, []any{tmp35}) + tmp9 = tmp36 + } // end let + return tmp9 + }) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5767), kw_column, int(9), kw_end_DASH_line, int(5769), kw_end_DASH_column, int(44)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v10 any = tmp9 + _ = v10 + // let binding "docstring" + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp13 := checkDerefVar(var_glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v5}) + tmp15 := lang.Apply(tmp12, []any{tmp14}) + if lang.IsTruthy(tmp15) { + tmp16 := checkDerefVar(var_glojure_DOT_core_first) + tmp17 := lang.Apply(tmp16, []any{v5}) + tmp11 = tmp17 + } else { + } + var v18 any = tmp11 + _ = v18 + // let binding "references" + var tmp19 any + if lang.IsTruthy(v18) { + tmp20 := checkDerefVar(var_glojure_DOT_core_next) + tmp21 := lang.Apply(tmp20, []any{v5}) + tmp19 = tmp21 + } else { + tmp19 = v5 + } + var v22 any = tmp19 + _ = v22 + // let binding "name" + var tmp23 any + if lang.IsTruthy(v18) { + tmp24 := checkDerefVar(var_glojure_DOT_core_vary_DASH_meta) + tmp25 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp26 := lang.Apply(tmp24, []any{v4, tmp25, kw_doc, v18}) + tmp23 = tmp26 + } else { + tmp23 = v4 + } + var v27 any = tmp23 + _ = v27 + // let binding "metadata" + var tmp28 any + tmp29 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp30 := checkDerefVar(var_glojure_DOT_core_first) + tmp31 := lang.Apply(tmp30, []any{v22}) + tmp32 := lang.Apply(tmp29, []any{tmp31}) + if lang.IsTruthy(tmp32) { + tmp33 := checkDerefVar(var_glojure_DOT_core_first) + tmp34 := lang.Apply(tmp33, []any{v22}) + tmp28 = tmp34 + } else { + } + var v35 any = tmp28 + _ = v35 + // let binding "references" + var tmp36 any + if lang.IsTruthy(v35) { + tmp37 := checkDerefVar(var_glojure_DOT_core_next) + tmp38 := lang.Apply(tmp37, []any{v22}) + tmp36 = tmp38 + } else { + tmp36 = v22 + } + var v39 any = tmp36 + _ = v39 + // let binding "name" + var tmp40 any + if lang.IsTruthy(v35) { + tmp41 := checkDerefVar(var_glojure_DOT_core_vary_DASH_meta) + tmp42 := checkDerefVar(var_glojure_DOT_core_merge) + tmp43 := lang.Apply(tmp41, []any{v27, tmp42, v35}) + tmp40 = tmp43 + } else { + tmp40 = v27 + } + var v44 any = tmp40 + _ = v44 + // let binding "gen-class-clause" + tmp45 := checkDerefVar(var_glojure_DOT_core_first) + tmp46 := checkDerefVar(var_glojure_DOT_core_filter) + var tmp47 lang.FnFunc + tmp47 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v48 := args[0] + _ = v48 + tmp49 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp50 := checkDerefVar(var_glojure_DOT_core_first) + tmp51 := lang.Apply(tmp50, []any{v48}) + tmp52 := lang.Apply(tmp49, []any{kw_gen_DASH_class, tmp51}) + return tmp52 + }) + tmp48 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5780), kw_column, int(41), kw_end_DASH_line, int(5780), kw_end_DASH_column, int(65)) + tmp49, err := lang.WithMeta(tmp47, tmp48.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp50 := lang.Apply(tmp46, []any{tmp49, v39}) + tmp51 := lang.Apply(tmp45, []any{tmp50}) + var v52 any = tmp51 + _ = v52 + // let binding "gen-class-call" + var tmp53 any + if lang.IsTruthy(v52) { + tmp54 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp55 := checkDerefVar(var_glojure_DOT_core_str) + tmp56 := lang.Apply(tmp55, []any{v44}) + tmp57, _ := lang.FieldOrMethod(tmp56, "replace") + if reflect.TypeOf(tmp57).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("replace is not a function"))) + } + tmp58 := lang.Apply(tmp57, []any{lang.NewChar(45), lang.NewChar(95)}) + tmp59 := checkDerefVar(var_glojure_DOT_core_next) + tmp60 := lang.Apply(tmp59, []any{v52}) + tmp61 := lang.Apply(tmp54, []any{sym_glojure_DOT_core_SLASH_gen_DASH_class, kw_name, tmp58, kw_impl_DASH_ns, v44, kw_main, true, tmp60}) + tmp53 = tmp61 + } else { + } + var v62 any = tmp53 + _ = v62 + // let binding "references" + tmp63 := checkDerefVar(var_glojure_DOT_core_remove) + var tmp64 lang.FnFunc + tmp64 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v65 := args[0] + _ = v65 + tmp66 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp67 := checkDerefVar(var_glojure_DOT_core_first) + tmp68 := lang.Apply(tmp67, []any{v65}) + tmp69 := lang.Apply(tmp66, []any{kw_gen_DASH_class, tmp68}) + return tmp69 + }) + tmp65 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5784), kw_column, int(28), kw_end_DASH_line, int(5784), kw_end_DASH_column, int(52)) + tmp66, err := lang.WithMeta(tmp64, tmp65.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp67 := lang.Apply(tmp63, []any{tmp66, v39}) + var v68 any = tmp67 + _ = v68 + // let binding "name-metadata" + tmp69 := checkDerefVar(var_glojure_DOT_core_meta) + tmp70 := lang.Apply(tmp69, []any{v44}) + var v71 any = tmp70 + _ = v71 + tmp72 := checkDerefVar(var_glojure_DOT_core_seq) + tmp73 := checkDerefVar(var_glojure_DOT_core_concat) + tmp74 := checkDerefVar(var_glojure_DOT_core_list) + tmp75 := lang.Apply(tmp74, []any{sym_do}) + tmp76 := checkDerefVar(var_glojure_DOT_core_list) + tmp77 := checkDerefVar(var_glojure_DOT_core_seq) + tmp78 := checkDerefVar(var_glojure_DOT_core_concat) + tmp79 := checkDerefVar(var_glojure_DOT_core_list) + tmp80 := lang.Apply(tmp79, []any{sym_glojure_DOT_core_SLASH_in_DASH_ns}) + tmp81 := checkDerefVar(var_glojure_DOT_core_list) + tmp82 := checkDerefVar(var_glojure_DOT_core_seq) + tmp83 := checkDerefVar(var_glojure_DOT_core_concat) + tmp84 := checkDerefVar(var_glojure_DOT_core_list) + tmp85 := lang.Apply(tmp84, []any{sym_quote}) + tmp86 := checkDerefVar(var_glojure_DOT_core_list) + tmp87 := lang.Apply(tmp86, []any{v44}) + tmp88 := lang.Apply(tmp83, []any{tmp85, tmp87}) + tmp89 := lang.Apply(tmp82, []any{tmp88}) + tmp90 := lang.Apply(tmp81, []any{tmp89}) + tmp91 := lang.Apply(tmp78, []any{tmp80, tmp90}) + tmp92 := lang.Apply(tmp77, []any{tmp91}) + tmp93 := lang.Apply(tmp76, []any{tmp92}) + var tmp94 any + if lang.IsTruthy(v71) { + tmp95 := checkDerefVar(var_glojure_DOT_core_seq) + tmp96 := checkDerefVar(var_glojure_DOT_core_concat) + tmp97 := checkDerefVar(var_glojure_DOT_core_list) + tmp98 := checkDerefVar(var_glojure_DOT_core_seq) + tmp99 := checkDerefVar(var_glojure_DOT_core_concat) + tmp100 := checkDerefVar(var_glojure_DOT_core_list) + tmp101 := lang.Apply(tmp100, []any{sym__DOT_ResetMeta}) + tmp102 := checkDerefVar(var_glojure_DOT_core_list) + tmp103 := checkDerefVar(var_glojure_DOT_core_seq) + tmp104 := checkDerefVar(var_glojure_DOT_core_concat) + tmp105 := checkDerefVar(var_glojure_DOT_core_list) + tmp106 := lang.Apply(tmp105, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_FindNamespace}) + tmp107 := checkDerefVar(var_glojure_DOT_core_list) + tmp108 := checkDerefVar(var_glojure_DOT_core_seq) + tmp109 := checkDerefVar(var_glojure_DOT_core_concat) + tmp110 := checkDerefVar(var_glojure_DOT_core_list) + tmp111 := lang.Apply(tmp110, []any{sym_quote}) + tmp112 := checkDerefVar(var_glojure_DOT_core_list) + tmp113 := lang.Apply(tmp112, []any{v44}) + tmp114 := lang.Apply(tmp109, []any{tmp111, tmp113}) + tmp115 := lang.Apply(tmp108, []any{tmp114}) + tmp116 := lang.Apply(tmp107, []any{tmp115}) + tmp117 := lang.Apply(tmp104, []any{tmp106, tmp116}) + tmp118 := lang.Apply(tmp103, []any{tmp117}) + tmp119 := lang.Apply(tmp102, []any{tmp118}) + tmp120 := checkDerefVar(var_glojure_DOT_core_list) + tmp121 := lang.Apply(tmp120, []any{v71}) + tmp122 := lang.Apply(tmp99, []any{tmp101, tmp119, tmp121}) + tmp123 := lang.Apply(tmp98, []any{tmp122}) + tmp124 := lang.Apply(tmp97, []any{tmp123}) + tmp125 := lang.Apply(tmp96, []any{tmp124}) + tmp126 := lang.Apply(tmp95, []any{tmp125}) + tmp94 = tmp126 + } else { + } + tmp127 := checkDerefVar(var_glojure_DOT_core_list) + tmp128 := checkDerefVar(var_glojure_DOT_core_seq) + tmp129 := checkDerefVar(var_glojure_DOT_core_concat) + tmp130 := checkDerefVar(var_glojure_DOT_core_list) + tmp131 := lang.Apply(tmp130, []any{sym_glojure_DOT_core_SLASH_with_DASH_loading_DASH_context}) + var tmp132 any + if lang.IsTruthy(v62) { + tmp133 := checkDerefVar(var_glojure_DOT_core_list) + tmp134 := lang.Apply(tmp133, []any{v62}) + tmp132 = tmp134 + } else { + } + var tmp135 any + var tmp136 any + { // let + // let binding "and__0__auto__" + tmp137 := checkDerefVar(var_glojure_DOT_core_not_EQ_) + tmp138 := lang.Apply(tmp137, []any{v44, sym_glojure_DOT_core}) + var v139 any = tmp138 + _ = v139 + var tmp140 any + if lang.IsTruthy(v139) { + tmp141 := checkDerefVar(var_glojure_DOT_core_not_DASH_any_QMARK_) + var tmp142 lang.FnFunc + tmp142 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v143 := args[0] + _ = v143 + tmp144 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp145 := checkDerefVar(var_glojure_DOT_core_first) + tmp146 := lang.Apply(tmp145, []any{v143}) + tmp147 := lang.Apply(tmp144, []any{kw_refer_DASH_glojure, tmp146}) + return tmp147 + }) + tmp143 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5793), kw_column, int(58), kw_end_DASH_line, int(5793), kw_end_DASH_column, int(86)) + tmp144, err := lang.WithMeta(tmp142, tmp143.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp145 := lang.Apply(tmp141, []any{tmp144, v68}) + tmp140 = tmp145 } else { - var tmp23 any = v3 - tmp25 := checkDerefVar(var_glojure_DOT_core_first) - tmp26 := lang.Apply(tmp25, []any{v9}) - tmp27 := lang.Apply(v3, []any{v4, tmp26}) - var tmp24 any = tmp27 - tmp29 := checkDerefVar(var_glojure_DOT_core_next) - tmp30 := lang.Apply(tmp29, []any{v9}) - var tmp28 any = tmp30 - v3 = tmp23 - v4 = tmp24 - v5 = tmp28 - goto recur_loop_156 + tmp140 = v139 } - tmp10 = tmp11 + tmp136 = tmp140 + } // end let + if lang.IsTruthy(tmp136) { + tmp137 := checkDerefVar(var_glojure_DOT_core_seq) + tmp138 := checkDerefVar(var_glojure_DOT_core_concat) + tmp139 := checkDerefVar(var_glojure_DOT_core_list) + tmp140 := checkDerefVar(var_glojure_DOT_core_seq) + tmp141 := checkDerefVar(var_glojure_DOT_core_concat) + tmp142 := checkDerefVar(var_glojure_DOT_core_list) + tmp143 := lang.Apply(tmp142, []any{sym_glojure_DOT_core_SLASH_refer}) + tmp144 := checkDerefVar(var_glojure_DOT_core_list) + tmp145 := checkDerefVar(var_glojure_DOT_core_seq) + tmp146 := checkDerefVar(var_glojure_DOT_core_concat) + tmp147 := checkDerefVar(var_glojure_DOT_core_list) + tmp148 := lang.Apply(tmp147, []any{sym_quote}) + tmp149 := checkDerefVar(var_glojure_DOT_core_list) + tmp150 := lang.Apply(tmp149, []any{sym_glojure_DOT_core}) + tmp151 := lang.Apply(tmp146, []any{tmp148, tmp150}) + tmp152 := lang.Apply(tmp145, []any{tmp151}) + tmp153 := lang.Apply(tmp144, []any{tmp152}) + tmp154 := lang.Apply(tmp141, []any{tmp143, tmp153}) + tmp155 := lang.Apply(tmp140, []any{tmp154}) + tmp156 := lang.Apply(tmp139, []any{tmp155}) + tmp157 := lang.Apply(tmp138, []any{tmp156}) + tmp158 := lang.Apply(tmp137, []any{tmp157}) + tmp135 = tmp158 } else { - tmp10 = v4 } - tmp6 = tmp10 + tmp159 := checkDerefVar(var_glojure_DOT_core_map) + tmp160 := lang.Apply(tmp159, []any{v10, v68}) + tmp161 := lang.Apply(tmp129, []any{tmp131, tmp132, tmp135, tmp160}) + tmp162 := lang.Apply(tmp128, []any{tmp161}) + tmp163 := lang.Apply(tmp127, []any{tmp162}) + tmp164 := checkDerefVar(var_glojure_DOT_core_list) + tmp165 := checkDerefVar(var_glojure_DOT_core_seq) + tmp166 := checkDerefVar(var_glojure_DOT_core_concat) + tmp167 := checkDerefVar(var_glojure_DOT_core_list) + tmp168 := lang.Apply(tmp167, []any{sym_if}) + tmp169 := checkDerefVar(var_glojure_DOT_core_list) + tmp170 := checkDerefVar(var_glojure_DOT_core_seq) + tmp171 := checkDerefVar(var_glojure_DOT_core_concat) + tmp172 := checkDerefVar(var_glojure_DOT_core_list) + tmp173 := lang.Apply(tmp172, []any{sym__DOT_Equals}) + tmp174 := checkDerefVar(var_glojure_DOT_core_list) + tmp175 := checkDerefVar(var_glojure_DOT_core_seq) + tmp176 := checkDerefVar(var_glojure_DOT_core_concat) + tmp177 := checkDerefVar(var_glojure_DOT_core_list) + tmp178 := lang.Apply(tmp177, []any{sym_quote}) + tmp179 := checkDerefVar(var_glojure_DOT_core_list) + tmp180 := lang.Apply(tmp179, []any{v44}) + tmp181 := lang.Apply(tmp176, []any{tmp178, tmp180}) + tmp182 := lang.Apply(tmp175, []any{tmp181}) + tmp183 := lang.Apply(tmp174, []any{tmp182}) + tmp184 := checkDerefVar(var_glojure_DOT_core_list) + tmp185 := checkDerefVar(var_glojure_DOT_core_seq) + tmp186 := checkDerefVar(var_glojure_DOT_core_concat) + tmp187 := checkDerefVar(var_glojure_DOT_core_list) + tmp188 := lang.Apply(tmp187, []any{sym_quote}) + tmp189 := checkDerefVar(var_glojure_DOT_core_list) + tmp190 := lang.Apply(tmp189, []any{sym_glojure_DOT_core}) + tmp191 := lang.Apply(tmp186, []any{tmp188, tmp190}) + tmp192 := lang.Apply(tmp185, []any{tmp191}) + tmp193 := lang.Apply(tmp184, []any{tmp192}) + tmp194 := lang.Apply(tmp171, []any{tmp173, tmp183, tmp193}) + tmp195 := lang.Apply(tmp170, []any{tmp194}) + tmp196 := lang.Apply(tmp169, []any{tmp195}) + tmp197 := checkDerefVar(var_glojure_DOT_core_list) + tmp198 := lang.Apply(tmp197, []any{nil}) + tmp199 := checkDerefVar(var_glojure_DOT_core_list) + tmp200 := checkDerefVar(var_glojure_DOT_core_seq) + tmp201 := checkDerefVar(var_glojure_DOT_core_concat) + tmp202 := checkDerefVar(var_glojure_DOT_core_list) + tmp203 := lang.Apply(tmp202, []any{sym_do}) + tmp204 := checkDerefVar(var_glojure_DOT_core_list) + tmp205 := checkDerefVar(var_glojure_DOT_core_seq) + tmp206 := checkDerefVar(var_glojure_DOT_core_concat) + tmp207 := checkDerefVar(var_glojure_DOT_core_list) + tmp208 := lang.Apply(tmp207, []any{sym_glojure_DOT_core_SLASH_dosync}) + tmp209 := checkDerefVar(var_glojure_DOT_core_list) + tmp210 := checkDerefVar(var_glojure_DOT_core_seq) + tmp211 := checkDerefVar(var_glojure_DOT_core_concat) + tmp212 := checkDerefVar(var_glojure_DOT_core_list) + tmp213 := lang.Apply(tmp212, []any{sym_glojure_DOT_core_SLASH_commute}) + tmp214 := checkDerefVar(var_glojure_DOT_core_list) + tmp215 := checkDerefVar(var_glojure_DOT_core_seq) + tmp216 := checkDerefVar(var_glojure_DOT_core_concat) + tmp217 := checkDerefVar(var_glojure_DOT_core_list) + tmp218 := lang.Apply(tmp217, []any{sym_glojure_DOT_core_SLASH_deref}) + tmp219 := checkDerefVar(var_glojure_DOT_core_list) + tmp220 := checkDerefVar(var_glojure_DOT_core_seq) + tmp221 := checkDerefVar(var_glojure_DOT_core_concat) + tmp222 := checkDerefVar(var_glojure_DOT_core_list) + tmp223 := lang.Apply(tmp222, []any{sym_var}) + tmp224 := checkDerefVar(var_glojure_DOT_core_list) + tmp225 := lang.Apply(tmp224, []any{sym_glojure_DOT_core_SLASH__STAR_loaded_DASH_libs_STAR_}) + tmp226 := lang.Apply(tmp221, []any{tmp223, tmp225}) + tmp227 := lang.Apply(tmp220, []any{tmp226}) + tmp228 := lang.Apply(tmp219, []any{tmp227}) + tmp229 := lang.Apply(tmp216, []any{tmp218, tmp228}) + tmp230 := lang.Apply(tmp215, []any{tmp229}) + tmp231 := lang.Apply(tmp214, []any{tmp230}) + tmp232 := checkDerefVar(var_glojure_DOT_core_list) + tmp233 := lang.Apply(tmp232, []any{sym_glojure_DOT_core_SLASH_conj}) + tmp234 := checkDerefVar(var_glojure_DOT_core_list) + tmp235 := checkDerefVar(var_glojure_DOT_core_seq) + tmp236 := checkDerefVar(var_glojure_DOT_core_concat) + tmp237 := checkDerefVar(var_glojure_DOT_core_list) + tmp238 := lang.Apply(tmp237, []any{sym_quote}) + tmp239 := checkDerefVar(var_glojure_DOT_core_list) + tmp240 := lang.Apply(tmp239, []any{v44}) + tmp241 := lang.Apply(tmp236, []any{tmp238, tmp240}) + tmp242 := lang.Apply(tmp235, []any{tmp241}) + tmp243 := lang.Apply(tmp234, []any{tmp242}) + tmp244 := lang.Apply(tmp211, []any{tmp213, tmp231, tmp233, tmp243}) + tmp245 := lang.Apply(tmp210, []any{tmp244}) + tmp246 := lang.Apply(tmp209, []any{tmp245}) + tmp247 := lang.Apply(tmp206, []any{tmp208, tmp246}) + tmp248 := lang.Apply(tmp205, []any{tmp247}) + tmp249 := lang.Apply(tmp204, []any{tmp248}) + tmp250 := checkDerefVar(var_glojure_DOT_core_list) + tmp251 := lang.Apply(tmp250, []any{nil}) + tmp252 := lang.Apply(tmp201, []any{tmp203, tmp249, tmp251}) + tmp253 := lang.Apply(tmp200, []any{tmp252}) + tmp254 := lang.Apply(tmp199, []any{tmp253}) + tmp255 := lang.Apply(tmp166, []any{tmp168, tmp196, tmp198, tmp254}) + tmp256 := lang.Apply(tmp165, []any{tmp255}) + tmp257 := lang.Apply(tmp164, []any{tmp256}) + tmp258 := lang.Apply(tmp73, []any{tmp75, tmp93, tmp94, tmp163, tmp257}) + tmp259 := lang.Apply(tmp72, []any{tmp258}) + tmp6 = tmp259 } // end let return tmp6 - default: - checkArity(args, -1) - panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // reduced - { - tmp0 := sym_reduced.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Wraps x in a way such that a reduce will terminate with the value x", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(2828), kw_end_DASH_line, int(2828))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := lang.Apply(lang.NewReduced, []any{v3}) - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ns = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_ns.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // reduced? + // ns-imports { + tmp0 := sym_ns_DASH_imports.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns)), kw_doc, "Returns a map of the import mappings for the namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4199), kw_end_DASH_line, int(4199))).(*lang.Symbol) var tmp1 lang.FnFunc - { // function reduced?__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_seq) - tmp5 := checkDerefVar(var_glojure_DOT_core_concat) - tmp6 := checkDerefVar(var_glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_IsReduced}) - tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{v3}) - tmp10 := lang.Apply(tmp5, []any{tmp7, tmp9}) - tmp11 := lang.Apply(tmp4, []any{tmp10}) - return tmp11 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := sym_reduced_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns true if x is the result of a call to reduced", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1)})), kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(2834), kw_end_DASH_line, int(2834))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5 := lang.Apply(lang.IsReduced, []any{v4}) - return tmp5 + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_filter_DASH_key) + tmp4 := checkDerefVar(var_glojure_DOT_core_val) + tmp5 := checkDerefVar(var_glojure_DOT_core_partial) + tmp6 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp7 := reflect.TypeOf((*reflect.Type)(nil)).Elem() + tmp8 := lang.Apply(tmp5, []any{tmp6, tmp7}) + tmp9 := checkDerefVar(var_glojure_DOT_core_ns_DASH_map) + tmp10 := lang.Apply(tmp9, []any{v2}) + tmp11 := lang.Apply(tmp3, []any{tmp4, tmp8, tmp10}) + return tmp11 }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ns_DASH_imports = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_ns_DASH_imports.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // reductions + // partition { - tmp0 := sym_reductions.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_coll), lang.NewVector(sym_f, sym_init, sym_coll)), kw_doc, "Returns a lazy seq of the intermediate values of the reduction (as\n per reduce) of coll by f, starting with init.", kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(7196), kw_end_DASH_line, int(7196))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_partition.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n, sym_coll), lang.NewVector(sym_n, sym_step, sym_coll), lang.NewVector(sym_n, sym_step, sym_pad, sym_coll)), kw_doc, "Returns a lazy sequence of lists of n items each, at offsets step\n apart. If step is not supplied, defaults to n, i.e. the partitions\n do not overlap. If a pad collection is supplied, use its elements as\n necessary to complete last partition upto n items. In case there are\n not enough padding elements, return a partition with less than n items.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(3177), kw_end_DASH_line, int(3177))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 2: - v3 := args[0] + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + tmp4 := checkDerefVar(var_glojure_DOT_core_partition) + tmp5 := lang.Apply(tmp4, []any{v2, v2, v3}) + return tmp5 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] _ = v4 var tmp5 lang.FnFunc tmp5 = lang.NewFnFunc(func(args ...any) any { @@ -45437,20 +41213,36 @@ func LoadNS() { // let binding "s" var v12 any = v9 _ = v12 - tmp13 := checkDerefVar(var_glojure_DOT_core_reductions) - tmp14 := checkDerefVar(var_glojure_DOT_core_first) - tmp15 := lang.Apply(tmp14, []any{v12}) - tmp16 := checkDerefVar(var_glojure_DOT_core_rest) - tmp17 := lang.Apply(tmp16, []any{v12}) - tmp18 := lang.Apply(tmp13, []any{v3, tmp15, tmp17}) - tmp11 = tmp18 + var tmp13 any + { // let + // let binding "p" + tmp14 := checkDerefVar(var_glojure_DOT_core_doall) + tmp15 := checkDerefVar(var_glojure_DOT_core_take) + tmp16 := lang.Apply(tmp15, []any{v2, v12}) + tmp17 := lang.Apply(tmp14, []any{tmp16}) + var v18 any = tmp17 + _ = v18 + var tmp19 any + tmp20 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp21 := checkDerefVar(var_glojure_DOT_core_count) + tmp22 := lang.Apply(tmp21, []any{v18}) + tmp23 := lang.Apply(tmp20, []any{v2, tmp22}) + if lang.IsTruthy(tmp23) { + tmp24 := checkDerefVar(var_glojure_DOT_core_cons) + tmp25 := checkDerefVar(var_glojure_DOT_core_partition) + tmp26 := checkDerefVar(var_glojure_DOT_core_nthrest) + tmp27 := lang.Apply(tmp26, []any{v12, v3}) + tmp28 := lang.Apply(tmp25, []any{v2, v3, tmp27}) + tmp29 := lang.Apply(tmp24, []any{v18, tmp28}) + tmp19 = tmp29 + } else { + } + tmp13 = tmp19 + } // end let + tmp11 = tmp13 } // end let tmp10 = tmp11 } else { - tmp12 := checkDerefVar(var_glojure_DOT_core_list) - tmp13 := lang.Apply(v3, nil) - tmp14 := lang.Apply(tmp12, []any{tmp13}) - tmp10 = tmp14 } tmp6 = tmp10 } // end let @@ -45458,3364 +41250,4626 @@ func LoadNS() { }) tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) return tmp6 - case 3: - v3 := args[0] + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + v4 := args[2] _ = v4 - v5 := args[2] + v5 := args[3] _ = v5 - var tmp6 any - tmp7 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) - tmp8 := lang.Apply(tmp7, []any{v4}) - if lang.IsTruthy(tmp8) { - tmp9 := checkDerefVar(var_glojure_DOT_core_list) - tmp10 := checkDerefVar(var_glojure_DOT_core_deref) - tmp11 := lang.Apply(tmp10, []any{v4}) - tmp12 := lang.Apply(tmp9, []any{tmp11}) - tmp6 = tmp12 - } else { - tmp13 := checkDerefVar(var_glojure_DOT_core_cons) - var tmp14 lang.FnFunc - tmp14 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - var tmp15 any - { // let - // let binding "temp__0__auto__" - tmp16 := checkDerefVar(var_glojure_DOT_core_seq) - tmp17 := lang.Apply(tmp16, []any{v5}) - var v18 any = tmp17 - _ = v18 - var tmp19 any - if lang.IsTruthy(v18) { - var tmp20 any + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp7 any + { // let + // let binding "temp__0__auto__" + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := lang.Apply(tmp8, []any{v5}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + if lang.IsTruthy(v10) { + var tmp12 any + { // let + // let binding "s" + var v13 any = v10 + _ = v13 + var tmp14 any { // let - // let binding "s" - var v21 any = v18 - _ = v21 - tmp22 := checkDerefVar(var_glojure_DOT_core_reductions) - tmp23 := checkDerefVar(var_glojure_DOT_core_first) - tmp24 := lang.Apply(tmp23, []any{v21}) - tmp25 := lang.Apply(v3, []any{v4, tmp24}) - tmp26 := checkDerefVar(var_glojure_DOT_core_rest) - tmp27 := lang.Apply(tmp26, []any{v21}) - tmp28 := lang.Apply(tmp22, []any{v3, tmp25, tmp27}) - tmp20 = tmp28 - } // end let - tmp19 = tmp20 - } else { - } - tmp15 = tmp19 - } // end let - return tmp15 - }) - tmp15 := lang.Apply(lang.NewLazySeq, []any{tmp14}) - tmp16 := lang.Apply(tmp13, []any{v4, tmp15}) - tmp6 = tmp16 - } - return tmp6 - default: - checkArity(args, -1) - panic("unreachable") - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // ref - { - tmp0 := sym_ref.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym__AMP_, sym_options)), kw_doc, "Creates and returns a Ref with an initial value of x and zero or\n more options (in any order):\n\n :meta metadata-map\n\n :validator validate-fn\n\n :min-history (default 0)\n :max-history (default 10)\n\n If metadata-map is supplied, it will become the metadata on the\n ref. validate-fn must be nil or a side-effect-free fn of one\n argument, which will be passed the intended new state on any state\n change. If the new state is unacceptable, the validate-fn should\n return false or throw an exception. validate-fn will be called on\n transaction commit, when all refs have their final values.\n\n Normally refs accumulate history dynamically as needed to deal with\n read demands. If you know in advance you will need history you can\n set :min-history to ensure it will be available when first needed (instead\n of after a read fault). History is limited, and the limit can be set\n with :max-history.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(2260), kw_end_DASH_line, int(2260))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - tmp4 := lang.Apply(lang.NewRef, []any{v3}) - return tmp4 - default: - checkArity(args, 1) - v3 := args[0] - _ = v3 - var v4 any = lang.NewList(args[1:]...) - _ = v4 - var tmp5 any - { // let - // let binding "r" - tmp6 := checkDerefVar(var_glojure_DOT_core_setup_DASH_reference) - tmp7 := checkDerefVar(var_glojure_DOT_core_ref) - tmp8 := lang.Apply(tmp7, []any{v3}) - tmp9 := lang.Apply(tmp6, []any{tmp8, v4}) - var v10 any = tmp9 - _ = v10 - // let binding "opts" - tmp11 := checkDerefVar(var_glojure_DOT_core_apply) - tmp12 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) - tmp13 := lang.Apply(tmp11, []any{tmp12, v4}) - var v14 any = tmp13 - _ = v14 - var tmp15 any - tmp16 := lang.Apply(kw_max_DASH_history, []any{v14}) - if lang.IsTruthy(tmp16) { - tmp17 := lang.Apply(kw_max_DASH_history, []any{v14}) - tmp18, _ := lang.FieldOrMethod(v10, "setMaxHistory") - if reflect.TypeOf(tmp18).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMaxHistory is not a function"))) - } - tmp19 := lang.Apply(tmp18, []any{tmp17}) - tmp15 = tmp19 - } else { - } - _ = tmp15 - var tmp20 any - tmp21 := lang.Apply(kw_min_DASH_history, []any{v14}) - if lang.IsTruthy(tmp21) { - tmp22 := lang.Apply(kw_min_DASH_history, []any{v14}) - tmp23, _ := lang.FieldOrMethod(v10, "setMinHistory") - if reflect.TypeOf(tmp23).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMinHistory is not a function"))) - } - tmp24 := lang.Apply(tmp23, []any{tmp22}) - tmp20 = tmp24 - } else { - } - _ = tmp20 - tmp5 = v10 - } // end let - return tmp5 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // ref-history-count - { - tmp0 := sym_ref_DASH_history_DASH_count.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ref)), kw_doc, "Returns the history count of a ref", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(7), kw_line, int(2455), kw_end_DASH_line, int(2455))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4, ok := lang.FieldOrMethod(v3, "getHistoryCount") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getHistoryCount"))) - } - var tmp5 any - switch reflect.TypeOf(tmp4).Kind() { - case reflect.Func: - tmp5 = lang.Apply(tmp4, nil) - default: - tmp5 = tmp4 - } - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // ref-max-history - { - tmp0 := sym_ref_DASH_max_DASH_history.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ref), lang.NewVector(sym_ref, sym_n)), kw_doc, "Gets the max-history of a ref, or sets it and returns the ref", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(2471), kw_end_DASH_line, int(2471))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - tmp4, ok := lang.FieldOrMethod(v3, "getMaxHistory") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getMaxHistory"))) - } - var tmp5 any - switch reflect.TypeOf(tmp4).Kind() { - case reflect.Func: - tmp5 = lang.Apply(tmp4, nil) - default: - tmp5 = tmp4 - } - return tmp5 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5, _ := lang.FieldOrMethod(v3, "setMaxHistory") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMaxHistory is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - default: - checkArity(args, -1) - panic("unreachable") - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // ref-min-history - { - tmp0 := sym_ref_DASH_min_DASH_history.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ref), lang.NewVector(sym_ref, sym_n)), kw_doc, "Gets the min-history of a ref, or sets it and returns the ref", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(2462), kw_end_DASH_line, int(2462))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - tmp4, ok := lang.FieldOrMethod(v3, "getMinHistory") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getMinHistory"))) - } - var tmp5 any - switch reflect.TypeOf(tmp4).Kind() { - case reflect.Func: - tmp5 = lang.Apply(tmp4, nil) - default: - tmp5 = tmp4 - } - return tmp5 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5, _ := lang.FieldOrMethod(v3, "setMinHistory") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMinHistory is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 + // let binding "p" + tmp15 := checkDerefVar(var_glojure_DOT_core_doall) + tmp16 := checkDerefVar(var_glojure_DOT_core_take) + tmp17 := lang.Apply(tmp16, []any{v2, v13}) + tmp18 := lang.Apply(tmp15, []any{tmp17}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + tmp21 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp22 := checkDerefVar(var_glojure_DOT_core_count) + tmp23 := lang.Apply(tmp22, []any{v19}) + tmp24 := lang.Apply(tmp21, []any{v2, tmp23}) + if lang.IsTruthy(tmp24) { + tmp25 := checkDerefVar(var_glojure_DOT_core_cons) + tmp26 := checkDerefVar(var_glojure_DOT_core_partition) + tmp27 := checkDerefVar(var_glojure_DOT_core_nthrest) + tmp28 := lang.Apply(tmp27, []any{v13, v3}) + tmp29 := lang.Apply(tmp26, []any{v2, v3, v4, tmp28}) + tmp30 := lang.Apply(tmp25, []any{v19, tmp29}) + tmp20 = tmp30 + } else { + tmp31 := checkDerefVar(var_glojure_DOT_core_list) + tmp32 := checkDerefVar(var_glojure_DOT_core_take) + tmp33 := checkDerefVar(var_glojure_DOT_core_concat) + tmp34 := lang.Apply(tmp33, []any{v19, v4}) + tmp35 := lang.Apply(tmp32, []any{v2, tmp34}) + tmp36 := lang.Apply(tmp31, []any{tmp35}) + tmp20 = tmp36 + } + tmp14 = tmp20 + } // end let + tmp12 = tmp14 + } // end let + tmp11 = tmp12 + } else { + } + tmp7 = tmp11 + } // end let + return tmp7 + }) + tmp7 := lang.Apply(lang.NewLazySeq, []any{tmp6}) + return tmp7 default: checkArity(args, -1) panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // ref-set - { - tmp0 := sym_ref_DASH_set.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ref, sym_val)), kw_doc, "Must be called in a transaction. Sets the value of ref.\n Returns val.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(2447), kw_end_DASH_line, int(2447))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5, _ := lang.FieldOrMethod(v3, "set") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("set is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_partition = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_partition.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // refer + // partition-all { - tmp0 := sym_refer.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns_DASH_sym, sym__AMP_, sym_filters)), kw_doc, "refers to all public vars of ns, subject to filters.\n filters can include at most one each of:\n\n :exclude list-of-symbols\n :only list-of-symbols\n :rename map-of-fromsymbol-tosymbol\n\n For each public interned var in the namespace named by the symbol,\n adds a mapping from the name of the var to the var to the current\n namespace. Throws an exception if name is already mapped to\n something else in the current namespace. Filters can be used to\n select a subset, via inclusion or exclusion, or to provide a mapping\n to a symbol different from the var's name, in order to prevent\n clashes. Use :use in the ns macro in preference to calling this directly.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(4216), kw_end_DASH_line, int(4216))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_partition_DASH_all.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n), lang.NewVector(sym_n, sym_coll), lang.NewVector(sym_n, sym_step, sym_coll)), kw_doc, "Returns a lazy sequence of lists like partition, but may include\n partitions with fewer than n items at the end. Returns a stateful\n transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(7222), kw_end_DASH_line, int(7222))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - default: - checkArity(args, 1) - v3 := args[0] - _ = v3 - var v4 any = lang.NewList(args[1:]...) - _ = v4 - var tmp5 any - { // let - // let binding "ns" - var tmp6 any + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 any { // let - // let binding "or__0__auto__" - tmp7 := checkDerefVar(var_glojure_DOT_core_find_DASH_ns) - tmp8 := lang.Apply(tmp7, []any{v3}) + // let binding "a" + tmp6 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) + tmp7 := lang.Apply(tmp6, []any{v2}) + tmp8 := lang.Apply(lang.NewArrayList, []any{tmp7}) var v9 any = tmp8 _ = v9 - var tmp10 any - if lang.IsTruthy(v9) { - tmp10 = v9 - } else { - tmp11 := checkDerefVar(var_glojure_DOT_core_str) - tmp12 := lang.Apply(tmp11, []any{"No namespace: ", v3}) - tmp13 := lang.Apply(errors8.New, []any{tmp12}) - panic(tmp13) - } - tmp6 = tmp10 - } // end let - var v7 any = tmp6 - _ = v7 - // let binding "fs" - tmp8 := checkDerefVar(var_glojure_DOT_core_apply) - tmp9 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) - tmp10 := lang.Apply(tmp8, []any{tmp9, v4}) - var v11 any = tmp10 - _ = v11 - // let binding "nspublics" - tmp12 := checkDerefVar(var_glojure_DOT_core_ns_DASH_publics) - tmp13 := lang.Apply(tmp12, []any{v7}) - var v14 any = tmp13 - _ = v14 - // let binding "rename" - var tmp15 any - { // let - // let binding "or__0__auto__" - tmp16 := lang.Apply(kw_rename, []any{v11}) - var v17 any = tmp16 - _ = v17 - var tmp18 any - if lang.IsTruthy(v17) { - tmp18 = v17 - } else { - tmp19 := lang.NewMap() - tmp20 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4236), kw_column, int(35), kw_end_DASH_line, int(4236), kw_end_DASH_column, int(36)) - tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp18 = tmp21 - } - tmp15 = tmp18 - } // end let - var v16 any = tmp15 - _ = v16 - // let binding "exclude" - tmp17 := checkDerefVar(var_glojure_DOT_core_set) - tmp18 := lang.Apply(kw_exclude, []any{v11}) - tmp19 := lang.Apply(tmp17, []any{tmp18}) - var v20 any = tmp19 - _ = v20 - // let binding "to-do" - var tmp21 any - tmp22 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp23 := lang.Apply(kw_refer, []any{v11}) - tmp24 := lang.Apply(tmp22, []any{kw_all, tmp23}) - if lang.IsTruthy(tmp24) { - tmp25 := checkDerefVar(var_glojure_DOT_core_keys) - tmp26 := lang.Apply(tmp25, []any{v14}) - tmp21 = tmp26 - } else { - var tmp27 any - { // let - // let binding "or__0__auto__" - tmp28 := lang.Apply(kw_refer, []any{v11}) - var v29 any = tmp28 - _ = v29 - var tmp30 any - if lang.IsTruthy(v29) { - tmp30 = v29 - } else { - var tmp31 any + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp11 := lang.Apply(v4, nil) + return tmp11 + case 1: + v11 := args[0] + _ = v11 + var tmp12 any { // let - // let binding "or__0__auto__" - tmp32 := lang.Apply(kw_only, []any{v11}) - var v33 any = tmp32 - _ = v33 - var tmp34 any - if lang.IsTruthy(v33) { - tmp34 = v33 - } else { - tmp35 := checkDerefVar(var_glojure_DOT_core_keys) - tmp36 := lang.Apply(tmp35, []any{v14}) - tmp34 = tmp36 + // let binding "result" + var tmp13 any + tmp14, ok := lang.FieldOrMethod(v9, "isEmpty") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v9, "isEmpty"))) } - tmp31 = tmp34 - } // end let - tmp30 = tmp31 - } - tmp27 = tmp30 - } // end let - tmp21 = tmp27 - } - var v28 any = tmp21 - _ = v28 - var tmp29 any - var tmp30 any - { // let - // let binding "and__0__auto__" - var v31 any = v28 - _ = v31 - var tmp32 any - if lang.IsTruthy(v31) { - tmp33 := checkDerefVar(var_glojure_DOT_core_not) - tmp34 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp35 := reflect.TypeOf((*lang.Sequential)(nil)).Elem() - tmp36 := lang.Apply(tmp34, []any{tmp35, v28}) - tmp37 := lang.Apply(tmp33, []any{tmp36}) - tmp32 = tmp37 - } else { - tmp32 = v31 - } - tmp30 = tmp32 - } // end let - if lang.IsTruthy(tmp30) { - tmp31 := lang.Apply(errors8.New, []any{":only/:refer value must be a sequential collection of symbols"}) - panic(tmp31) - } else { - } - _ = tmp29 - var tmp32 any - { // let - // let binding "seq_9" - tmp33 := checkDerefVar(var_glojure_DOT_core_seq) - tmp34 := lang.Apply(tmp33, []any{v28}) - var v35 any = tmp34 - _ = v35 - // let binding "chunk_10" - var v36 any = nil - _ = v36 - // let binding "count_11" - var v37 any = int64(0) - _ = v37 - // let binding "i_12" - var v38 any = int64(0) - _ = v38 - for { - var tmp39 any - tmp40 := checkDerefVar(var_glojure_DOT_core__LT_) - tmp41 := lang.Apply(tmp40, []any{v38, v37}) - if lang.IsTruthy(tmp41) { - var tmp42 any - { // let - // let binding "sym" - tmp43, _ := lang.FieldOrMethod(v36, "nth") - if reflect.TypeOf(tmp43).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + var tmp15 any + switch reflect.TypeOf(tmp14).Kind() { + case reflect.Func: + tmp15 = lang.Apply(tmp14, nil) + default: + tmp15 = tmp14 } - tmp44 := lang.Apply(tmp43, []any{v38}) - var v45 any = tmp44 - _ = v45 - var tmp46 any - tmp47 := lang.Apply(v20, []any{v45}) - if lang.IsTruthy(tmp47) { + if lang.IsTruthy(tmp15) { + tmp13 = v11 } else { - var tmp48 any + var tmp16 any { // let // let binding "v" - tmp49 := lang.Apply(v14, []any{v45}) - var v50 any = tmp49 - _ = v50 - var tmp51 any - if lang.IsTruthy(v50) { - } else { - panic("unimplemented: new with non-constant class type") + tmp17 := checkDerefVar(var_glojure_DOT_core_vec) + tmp18, ok := lang.FieldOrMethod(v9, "toArray") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v9, "toArray"))) } - _ = tmp51 - tmp52 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) - var tmp53 any - { // let - // let binding "or__0__auto__" - tmp54 := lang.Apply(v16, []any{v45}) - var v55 any = tmp54 - _ = v55 - var tmp56 any - if lang.IsTruthy(v55) { - tmp56 = v55 - } else { - tmp56 = v45 - } - tmp53 = tmp56 - } // end let - tmp54, _ := lang.FieldOrMethod(tmp52, "Refer") - if reflect.TypeOf(tmp54).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Refer is not a function"))) + var tmp19 any + switch reflect.TypeOf(tmp18).Kind() { + case reflect.Func: + tmp19 = lang.Apply(tmp18, nil) + default: + tmp19 = tmp18 } - tmp55 := lang.Apply(tmp54, []any{tmp53, v50}) - tmp48 = tmp55 - } // end let - tmp46 = tmp48 - } - _ = tmp46 - var tmp49 any = v35 - var tmp50 any = v36 - var tmp51 any = v37 - tmp53 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) - tmp54 := lang.Apply(tmp53, []any{v38}) - var tmp52 any = tmp54 - v35 = tmp49 - v36 = tmp50 - v37 = tmp51 - v38 = tmp52 - continue - } // end let - tmp39 = tmp42 - } else { - var tmp43 any - { // let - // let binding "temp__0__auto__" - tmp44 := checkDerefVar(var_glojure_DOT_core_seq) - tmp45 := lang.Apply(tmp44, []any{v35}) - var v46 any = tmp45 - _ = v46 - var tmp47 any - if lang.IsTruthy(v46) { - var tmp48 any - { // let - // let binding "seq_9" - var v49 any = v46 - _ = v49 - var tmp50 any - tmp51 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) - tmp52 := lang.Apply(tmp51, []any{v49}) - if lang.IsTruthy(tmp52) { - var tmp53 any - { // let - // let binding "c__0__auto__" - tmp54 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) - tmp55 := lang.Apply(tmp54, []any{v49}) - var v56 any = tmp55 - _ = v56 - tmp58 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) - tmp59 := lang.Apply(tmp58, []any{v49}) - var tmp57 any = tmp59 - var tmp60 any = v56 - tmp62 := checkDerefVar(var_glojure_DOT_core_int) - tmp63 := checkDerefVar(var_glojure_DOT_core_count) - tmp64 := lang.Apply(tmp63, []any{v56}) - tmp65 := lang.Apply(tmp62, []any{tmp64}) - var tmp61 any = tmp65 - tmp67 := checkDerefVar(var_glojure_DOT_core_int) - tmp68 := lang.Apply(tmp67, []any{int64(0)}) - var tmp66 any = tmp68 - v35 = tmp57 - v36 = tmp60 - v37 = tmp61 - v38 = tmp66 - continue - } // end let - tmp50 = tmp53 - } else { - var tmp54 any - { // let - // let binding "sym" - tmp55 := checkDerefVar(var_glojure_DOT_core_first) - tmp56 := lang.Apply(tmp55, []any{v49}) - var v57 any = tmp56 - _ = v57 - var tmp58 any - tmp59 := lang.Apply(v20, []any{v57}) - if lang.IsTruthy(tmp59) { - } else { - var tmp60 any - { // let - // let binding "v" - tmp61 := lang.Apply(v14, []any{v57}) - var v62 any = tmp61 - _ = v62 - var tmp63 any - if lang.IsTruthy(v62) { - } else { - panic("unimplemented: new with non-constant class type") - } - _ = tmp63 - tmp64 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) - var tmp65 any - { // let - // let binding "or__0__auto__" - tmp66 := lang.Apply(v16, []any{v57}) - var v67 any = tmp66 - _ = v67 - var tmp68 any - if lang.IsTruthy(v67) { - tmp68 = v67 - } else { - tmp68 = v57 - } - tmp65 = tmp68 - } // end let - tmp66, _ := lang.FieldOrMethod(tmp64, "Refer") - if reflect.TypeOf(tmp66).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Refer is not a function"))) - } - tmp67 := lang.Apply(tmp66, []any{tmp65, v62}) - tmp60 = tmp67 - } // end let - tmp58 = tmp60 - } - _ = tmp58 - tmp62 := checkDerefVar(var_glojure_DOT_core_next) - tmp63 := lang.Apply(tmp62, []any{v49}) - var tmp61 any = tmp63 - var tmp64 any = nil - var tmp65 any = int64(0) - var tmp66 any = int64(0) - v35 = tmp61 - v36 = tmp64 - v37 = tmp65 - v38 = tmp66 - continue - } // end let - tmp50 = tmp54 + tmp20 := lang.Apply(tmp17, []any{tmp19}) + var v21 any = tmp20 + _ = v21 + tmp22, ok := lang.FieldOrMethod(v9, "clear") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v9, "clear"))) + } + var tmp23 any + switch reflect.TypeOf(tmp22).Kind() { + case reflect.Func: + tmp23 = lang.Apply(tmp22, nil) + default: + tmp23 = tmp22 } - tmp48 = tmp50 + _ = tmp23 + tmp24 := checkDerefVar(var_glojure_DOT_core_unreduced) + tmp25 := lang.Apply(v4, []any{v11, v21}) + tmp26 := lang.Apply(tmp24, []any{tmp25}) + tmp16 = tmp26 } // end let - tmp47 = tmp48 - } else { + tmp13 = tmp16 } - tmp43 = tmp47 + var v17 any = tmp13 + _ = v17 + tmp18 := lang.Apply(v4, []any{v17}) + tmp12 = tmp18 } // end let - tmp39 = tmp43 + return tmp12 + case 2: + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13, _ := lang.FieldOrMethod(v9, "add") + if reflect.TypeOf(tmp13).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) + } + tmp14 := lang.Apply(tmp13, []any{v12}) + _ = tmp14 + var tmp15 any + tmp16 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp17, ok := lang.FieldOrMethod(v9, "size") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v9, "size"))) + } + var tmp18 any + switch reflect.TypeOf(tmp17).Kind() { + case reflect.Func: + tmp18 = lang.Apply(tmp17, nil) + default: + tmp18 = tmp17 + } + tmp19 := lang.Apply(tmp16, []any{v2, tmp18}) + if lang.IsTruthy(tmp19) { + var tmp20 any + { // let + // let binding "v" + tmp21 := checkDerefVar(var_glojure_DOT_core_vec) + tmp22, ok := lang.FieldOrMethod(v9, "toArray") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v9, "toArray"))) + } + var tmp23 any + switch reflect.TypeOf(tmp22).Kind() { + case reflect.Func: + tmp23 = lang.Apply(tmp22, nil) + default: + tmp23 = tmp22 + } + tmp24 := lang.Apply(tmp21, []any{tmp23}) + var v25 any = tmp24 + _ = v25 + tmp26, ok := lang.FieldOrMethod(v9, "clear") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v9, "clear"))) + } + var tmp27 any + switch reflect.TypeOf(tmp26).Kind() { + case reflect.Func: + tmp27 = lang.Apply(tmp26, nil) + default: + tmp27 = tmp26 + } + _ = tmp27 + tmp28 := lang.Apply(v4, []any{v11, v25}) + tmp20 = tmp28 + } // end let + tmp15 = tmp20 + } else { + tmp15 = v11 + } + return tmp15 + default: + checkArity(args, -1) + panic("unreachable") } - tmp32 = tmp39 - break + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7231), kw_column, int(8), kw_end_DASH_line, int(7247), kw_end_DASH_column, int(23)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) } + tmp5 = tmp12 } // end let - tmp5 = tmp32 - } // end let + return tmp5 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7229), kw_column, int(4), kw_end_DASH_line, int(7247), kw_end_DASH_column, int(25)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } return tmp5 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // refer-glojure - { - tmp0 := sym_refer_DASH_glojure.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_filters)), kw_doc, "Same as (refer 'glojure.core )", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(11), kw_line, int(5800), kw_end_DASH_line, int(5800))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - tmp6 := checkDerefVar(var_glojure_DOT_core_seq) - tmp7 := checkDerefVar(var_glojure_DOT_core_concat) - tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_refer}) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := checkDerefVar(var_glojure_DOT_core_seq) - tmp12 := checkDerefVar(var_glojure_DOT_core_concat) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_quote}) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core}) - tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) - tmp18 := lang.Apply(tmp11, []any{tmp17}) - tmp19 := lang.Apply(tmp10, []any{tmp18}) - tmp20 := lang.Apply(tmp7, []any{tmp9, tmp19, v5}) - tmp21 := lang.Apply(tmp6, []any{tmp20}) - return tmp21 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // release-pending-sends - { - tmp0 := sym_release_DASH_pending_DASH_sends.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Normally, actions sent directly or indirectly during another action\n are held until the action completes (changes the agent's\n state). This function can be used to dispatch any pending sent\n actions immediately. This has no impact on actions sent during a\n transaction, which are still held until commit. If no action is\n occurring, does nothing. Returns the number of actions dispatched.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(27), kw_column, int(7), kw_line, int(2131), kw_end_DASH_line, int(2131))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - tmp3 := lang.Apply(nil, nil) - return tmp3 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // rem - { - var tmp1 lang.FnFunc - { // function rem__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_seq) - tmp6 := checkDerefVar(var_glojure_DOT_core_concat) - tmp7 := checkDerefVar(var_glojure_DOT_core_list) - tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) - tmp9 := checkDerefVar(var_glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp11 := checkDerefVar(var_glojure_DOT_core_list) - tmp12 := checkDerefVar(var_glojure_DOT_core_seq) - tmp13 := checkDerefVar(var_glojure_DOT_core_concat) - tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Remainder}) - tmp16 := checkDerefVar(var_glojure_DOT_core_list) - tmp17 := lang.Apply(tmp16, []any{v3}) - tmp18 := checkDerefVar(var_glojure_DOT_core_list) - tmp19 := lang.Apply(tmp18, []any{v4}) - tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) - tmp21 := lang.Apply(tmp12, []any{tmp20}) - tmp22 := lang.Apply(tmp11, []any{tmp21}) - tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) - tmp24 := lang.Apply(tmp5, []any{tmp23}) - return tmp24 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := sym_rem.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_num, sym_div)), kw_inline, tmp1, kw_doc, "remainder of dividing numerator by denominator.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(1274), kw_end_DASH_line, int(1274))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Remainder") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Remainder is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // remove - { - tmp0 := sym_remove.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred), lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns a lazy sequence of the items in coll for which\n (pred item) returns logical false. pred must be free of side-effects.\n Returns a transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(2818), kw_end_DASH_line, int(2818))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_filter) - tmp5 := checkDerefVar(var_glojure_DOT_core_complement) - tmp6 := lang.Apply(tmp5, []any{v3}) - tmp7 := lang.Apply(tmp4, []any{tmp6}) - return tmp7 case 2: - v3 := args[0] + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + tmp4 := checkDerefVar(var_glojure_DOT_core_partition_DASH_all) + tmp5 := lang.Apply(tmp4, []any{v2, v2, v3}) + return tmp5 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_filter) - tmp6 := checkDerefVar(var_glojure_DOT_core_complement) - tmp7 := lang.Apply(tmp6, []any{v3}) - tmp8 := lang.Apply(tmp5, []any{tmp7, v4}) - return tmp8 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp6 any + { // let + // let binding "temp__0__auto__" + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := lang.Apply(tmp7, []any{v4}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + var tmp11 any + { // let + // let binding "s" + var v12 any = v9 + _ = v12 + var tmp13 any + { // let + // let binding "seg" + tmp14 := checkDerefVar(var_glojure_DOT_core_doall) + tmp15 := checkDerefVar(var_glojure_DOT_core_take) + tmp16 := lang.Apply(tmp15, []any{v2, v12}) + tmp17 := lang.Apply(tmp14, []any{tmp16}) + var v18 any = tmp17 + _ = v18 + tmp19 := checkDerefVar(var_glojure_DOT_core_cons) + tmp20 := checkDerefVar(var_glojure_DOT_core_partition_DASH_all) + tmp21 := checkDerefVar(var_glojure_DOT_core_nthrest) + tmp22 := lang.Apply(tmp21, []any{v12, v3}) + tmp23 := lang.Apply(tmp20, []any{v2, v3, tmp22}) + tmp24 := lang.Apply(tmp19, []any{v18, tmp23}) + tmp13 = tmp24 + } // end let + tmp11 = tmp13 + } // end let + tmp10 = tmp11 + } else { + } + tmp6 = tmp10 + } // end let + return tmp6 + }) + tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) + return tmp6 default: checkArity(args, -1) panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_partition_DASH_all = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_partition_DASH_all.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // remove-all-methods + // pcalls { - tmp0 := sym_remove_DASH_all_DASH_methods.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_multifn)), kw_doc, "Removes all of the methods of multimethod.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(24), kw_column, int(7), kw_line, int(1787), kw_end_DASH_line, int(1787))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4, ok := lang.FieldOrMethod(v3, "reset") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "reset"))) - } - var tmp5 any - switch reflect.TypeOf(tmp4).Kind() { - case reflect.Func: - tmp5 = lang.Apply(tmp4, nil) + tmp0 := sym_pcalls.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_fns)), kw_doc, "Executes the no-arg fns in parallel, returning a lazy sequence of\n their values", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(7056), kw_end_DASH_line, int(7056))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { default: - tmp5 = tmp4 + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_pmap) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v5 := args[0] + _ = v5 + tmp6 := lang.Apply(v5, nil) + return tmp6 + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7061), kw_column, int(17), kw_end_DASH_line, int(7061), kw_end_DASH_column, int(20)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp7 := lang.Apply(tmp3, []any{tmp6, v2}) + return tmp7 } - return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_pcalls = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_pcalls.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // remove-method + // prep-ints { - tmp0 := sym_remove_DASH_method.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_multifn, sym_dispatch_DASH_val)), kw_doc, "Removes the method of multimethod associated with dispatch-value.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(1794), kw_end_DASH_line, int(1794))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_prep_DASH_ints.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_tests, sym_thens)), kw_doc, "Takes a sequence of int-sized test constants and a corresponding sequence of\n then expressions. Returns a tuple of [shift mask case-map switch-type] where\n case-map is a map of int case values to [test then] tuples, and switch-type\n is either :sparse or :compact.", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(8), kw_line, int(6631), kw_end_DASH_line, int(6631), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 2) - v3 := args[0] + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] - _ = v4 - tmp5, _ := lang.FieldOrMethod(v3, "removeMethod") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("removeMethod is not a function"))) + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_fits_DASH_table_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v2}) + if lang.IsTruthy(tmp6) { + tmp7 := checkDerefVar(var_glojure_DOT_core_case_DASH_map) + tmp8 := checkDerefVar(var_glojure_DOT_core_int) + tmp9 := checkDerefVar(var_glojure_DOT_core_int) + tmp10 := lang.Apply(tmp7, []any{tmp8, tmp9, v2, v3}) + tmp11 := lang.NewVector(int64(0), int64(0), tmp10, kw_compact) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6639), kw_column, int(5), kw_end_DASH_line, int(6639), kw_end_DASH_column, int(49)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp4 = tmp13 + } else { + var tmp14 any + { // let + // let binding "vec__160" + var tmp15 any + { // let + // let binding "or__0__auto__" + tmp16 := checkDerefVar(var_glojure_DOT_core_maybe_DASH_min_DASH_hash) + tmp17 := checkDerefVar(var_glojure_DOT_core_map) + tmp18 := checkDerefVar(var_glojure_DOT_core_int) + tmp19 := lang.Apply(tmp17, []any{tmp18, v2}) + tmp20 := lang.Apply(tmp16, []any{tmp19}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + if lang.IsTruthy(v21) { + tmp22 = v21 + } else { + tmp23 := lang.NewVector(int64(0), int64(0)) + tmp24 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6640), kw_column, int(61), kw_end_DASH_line, int(6640), kw_end_DASH_column, int(65)) + tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp22 = tmp25 + } + tmp15 = tmp22 + } // end let + var v16 any = tmp15 + _ = v16 + // let binding "shift" + tmp17 := checkDerefVar(var_glojure_DOT_core_nth) + tmp18 := lang.Apply(tmp17, []any{v16, int64(0), nil}) + var v19 any = tmp18 + _ = v19 + // let binding "mask" + tmp20 := checkDerefVar(var_glojure_DOT_core_nth) + tmp21 := lang.Apply(tmp20, []any{v16, int64(1), nil}) + var v22 any = tmp21 + _ = v22 + var tmp23 any + tmp24 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) + tmp25 := lang.Apply(tmp24, []any{v22}) + if lang.IsTruthy(tmp25) { + tmp26 := checkDerefVar(var_glojure_DOT_core_case_DASH_map) + tmp27 := checkDerefVar(var_glojure_DOT_core_int) + tmp28 := checkDerefVar(var_glojure_DOT_core_int) + tmp29 := lang.Apply(tmp26, []any{tmp27, tmp28, v2, v3}) + tmp30 := lang.NewVector(int64(0), int64(0), tmp29, kw_sparse) + tmp31 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6643), kw_column, int(9), kw_end_DASH_line, int(6643), kw_end_DASH_column, int(52)) + tmp32, err := lang.WithMeta(tmp30, tmp31.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp23 = tmp32 + } else { + tmp33 := checkDerefVar(var_glojure_DOT_core_case_DASH_map) + var tmp34 lang.FnFunc + tmp34 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v35 := args[0] + _ = v35 + tmp36 := checkDerefVar(var_glojure_DOT_core_shift_DASH_mask) + tmp37 := checkDerefVar(var_glojure_DOT_core_int) + tmp38 := lang.Apply(tmp37, []any{v35}) + tmp39 := lang.Apply(tmp36, []any{v19, v22, tmp38}) + return tmp39 + }) + tmp35 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6645), kw_column, int(31), kw_end_DASH_line, int(6645), kw_end_DASH_column, int(62)) + tmp36, err := lang.WithMeta(tmp34, tmp35.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp37 := checkDerefVar(var_glojure_DOT_core_int) + tmp38 := lang.Apply(tmp33, []any{tmp36, tmp37, v2, v3}) + tmp39 := lang.NewVector(v19, v22, tmp38, kw_compact) + tmp40 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6645), kw_column, int(9), kw_end_DASH_line, int(6645), kw_end_DASH_column, int(89)) + tmp41, err := lang.WithMeta(tmp39, tmp40.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp23 = tmp41 + } + tmp14 = tmp23 + } // end let + tmp4 = tmp14 } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 + return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_prep_DASH_ints = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_prep_DASH_ints.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // remove-ns + // print-prefix-map { - tmp0 := sym_remove_DASH_ns.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_sym)), kw_doc, "Removes the namespace named by the symbol. Use with caution.\n Cannot be used to remove the glojure namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(4139), kw_end_DASH_line, int(4139))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] + tmp0 := sym_print_DASH_prefix_DASH_map.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(243), kw_column, int(8), kw_end_DASH_line, int(243), kw_end_DASH_column, int(23), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_prefix, sym_kvs, sym_print_DASH_one, sym_w)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - tmp4 := lang.Apply(lang.RemoveNamespace, []any{v3}) - return tmp4 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_print_DASH_sequential) + tmp7 := checkDerefVar(var_glojure_DOT_core_str) + tmp8 := lang.Apply(tmp7, []any{v2, "{"}) + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + var tmp12 any + { // let + // let binding "vec__212" + var v13 any = v10 + _ = v13 + // let binding "k" + tmp14 := checkDerefVar(var_glojure_DOT_core_nth) + tmp15 := lang.Apply(tmp14, []any{v13, int64(0), nil}) + var v16 any = tmp15 + _ = v16 + // let binding "v" + tmp17 := checkDerefVar(var_glojure_DOT_core_nth) + tmp18 := lang.Apply(tmp17, []any{v13, int64(1), nil}) + var v19 any = tmp18 + _ = v19 + tmp20 := lang.Apply(v4, []any{v16, v11}) + _ = tmp20 + tmp21 := lang.Apply(lang.AppendWriter, []any{v11, lang.NewChar(32)}) + _ = tmp21 + tmp22 := lang.Apply(v4, []any{v19, v11}) + tmp12 = tmp22 + } // end let + return tmp12 + }) + tmp10 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(246), kw_column, int(5), kw_end_DASH_line, int(247), kw_end_DASH_column, int(107)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp12 := lang.Apply(tmp6, []any{tmp8, tmp11, ", ", "}", v3, v5}) + return tmp12 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_print_DASH_prefix_DASH_map = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_print_DASH_prefix_DASH_map.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // remove-tap + // promise { - tmp0 := sym_remove_DASH_tap.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f)), kw_doc, "Remove f from the tap set.", kw_file, "glojure/core.glj", kw_added, "1.10", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(7883), kw_end_DASH_line, int(7883))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_swap_BANG_) - tmp5 := checkDerefVar(var_glojure_DOT_core_tapset) - tmp6 := checkDerefVar(var_glojure_DOT_core_disj) - tmp7 := lang.Apply(tmp4, []any{tmp5, tmp6, v3}) - _ = tmp7 - return nil + tmp0 := sym_promise.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Returns a promise object that can be read with deref/@, and set,\n once only, with deliver. Calls to deref/@ prior to delivery will\n block, unless the variant of deref with timeout is used. All\n subsequent derefs will return the same delivered value without\n blocking. See also - realized?.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(7078), kw_end_DASH_line, int(7078))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp2 any + { // let + // let binding "d" + tmp3 := lang.Apply(nil, []any{int64(1)}) + var v4 any = tmp3 + _ = v4 + // let binding "v" + tmp5 := checkDerefVar(var_glojure_DOT_core_atom) + tmp6 := lang.Apply(tmp5, []any{v4}) + var v7 any = tmp6 + _ = v7 + tmp8 := reflect.TypeOf((*lang.IDeref)(nil)).Elem() + tmp9 := checkDerefVar(var_glojure_DOT_core_deref) + tmp10 := lang.NewVector(nil) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7091), kw_column, int(15), kw_end_DASH_line, int(7091), kw_end_DASH_column, int(17)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13, ok := lang.FieldOrMethod(v4, "await") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "await"))) + } + var tmp14 any + switch reflect.TypeOf(tmp13).Kind() { + case reflect.Func: + tmp14 = lang.Apply(tmp13, nil) + default: + tmp14 = tmp13 + } + tmp15 := checkDerefVar(var_glojure_DOT_core_deref) + tmp16 := lang.Apply(tmp15, []any{v7}) + tmp17 := lang.Apply(tmp9, []any{tmp12, tmp14, tmp16}) + tmp18 := reflect.TypeOf((*lang.IBlockingDeref)(nil)).Elem() + tmp19 := checkDerefVar(var_glojure_DOT_core_deref) + tmp20 := lang.NewVector(nil, nil, nil) + tmp21 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7094), kw_column, int(9), kw_end_DASH_line, int(7094), kw_end_DASH_column, int(34)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var tmp23 any + tmp24, _ := lang.FieldOrMethod(v4, "await") + if reflect.TypeOf(tmp24).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) + } + tmp25 := lang.Apply(tmp24, []any{nil, time10.Millisecond}) + if lang.IsTruthy(tmp25) { + tmp26 := checkDerefVar(var_glojure_DOT_core_deref) + tmp27 := lang.Apply(tmp26, []any{v7}) + tmp23 = tmp27 + } else { + } + tmp28 := lang.Apply(tmp19, []any{tmp22, tmp23}) + tmp29 := reflect.TypeOf((*lang.IPending)(nil)).Elem() + tmp30 := lang.NewVector(nil) + tmp31 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7099), kw_column, int(19), kw_end_DASH_line, int(7099), kw_end_DASH_column, int(24)) + tmp32, err := lang.WithMeta(tmp30, tmp31.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp33 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) + tmp34, ok := lang.FieldOrMethod(v4, "getCount") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "getCount"))) + } + var tmp35 any + switch reflect.TypeOf(tmp34).Kind() { + case reflect.Func: + tmp35 = lang.Apply(tmp34, nil) + default: + tmp35 = tmp34 + } + tmp36 := lang.Apply(tmp33, []any{tmp35}) + tmp37 := lang.Apply(nil, []any{tmp32, tmp36}) + tmp38 := lang.NewVector(nil, nil) + tmp39 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7103), kw_column, int(7), kw_end_DASH_line, int(7103), kw_end_DASH_column, int(14)) + tmp40, err := lang.WithMeta(tmp38, tmp39.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var tmp41 any + var tmp42 any + { // let + // let binding "and__0__auto__" + tmp43 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp44, ok := lang.FieldOrMethod(v4, "getCount") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "getCount"))) + } + var tmp45 any + switch reflect.TypeOf(tmp44).Kind() { + case reflect.Func: + tmp45 = lang.Apply(tmp44, nil) + default: + tmp45 = tmp44 + } + tmp46 := lang.Apply(tmp43, []any{tmp45}) + var v47 any = tmp46 + _ = v47 + var tmp48 any + if lang.IsTruthy(v47) { + tmp49 := checkDerefVar(var_glojure_DOT_core_compare_DASH_and_DASH_set_BANG_) + tmp50 := lang.Apply(tmp49, []any{v7, v4, nil}) + tmp48 = tmp50 + } else { + tmp48 = v47 + } + tmp42 = tmp48 + } // end let + if lang.IsTruthy(tmp42) { + tmp43, ok := lang.FieldOrMethod(v4, "countDown") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "countDown"))) + } + var tmp44 any + switch reflect.TypeOf(tmp43).Kind() { + case reflect.Func: + tmp44 = lang.Apply(tmp43, nil) + default: + tmp44 = tmp43 + } + _ = tmp44 + } else { + } + tmp45 := lang.Apply(nil, []any{tmp40, tmp41}) + tmp46 := lang.Apply(nil, []any{tmp8, tmp17, tmp18, tmp28, tmp29, tmp37, nil, tmp45}) + tmp2 = tmp46 + } // end let + return tmp2 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_promise = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_promise.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // remove-watch + // re-find { - tmp0 := sym_remove_DASH_watch.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_reference, sym_key)), kw_doc, "Removes a watch (set by add-watch) from a reference", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(2160), kw_end_DASH_line, int(2160))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5, _ := lang.FieldOrMethod(v3, "removeWatch") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("removeWatch is not a function"))) + tmp0 := sym_re_DASH_find.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m), lang.NewVector(sym_re, sym_s)), kw_doc, "Returns the next regex match, if any, of string to pattern, using\n java.util.regex.Matcher.find(). Uses re-groups to return the\n groups.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4922), kw_end_DASH_line, int(4922))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + tmp4, _ := lang.FieldOrMethod(v2, "find") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("find is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{}) + if lang.IsTruthy(tmp5) { + tmp6 := checkDerefVar(var_glojure_DOT_core_re_DASH_groups) + tmp7 := lang.Apply(tmp6, []any{v2}) + tmp3 = tmp7 + } else { + } + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "m" + tmp5 := checkDerefVar(var_glojure_DOT_core_re_DASH_matcher) + tmp6 := lang.Apply(tmp5, []any{v2, v3}) + var v7 any = tmp6 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_re_DASH_find) + tmp9 := lang.Apply(tmp8, []any{v7}) + tmp4 = tmp9 + } // end let + return tmp4 + default: + checkArity(args, -1) + panic("unreachable") } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_re_DASH_find = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_re_DASH_find.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // repeat + // ref { - tmp0 := sym_repeat.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_n, sym_x)), kw_doc, "Returns a lazy (infinite!, or length n if supplied) sequence of xs.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(2997), kw_end_DASH_line, int(2997))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_ref.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym__AMP_, sym_options)), kw_doc, "Creates and returns a Ref with an initial value of x and zero or\n more options (in any order):\n\n :meta metadata-map\n\n :validator validate-fn\n\n :min-history (default 0)\n :max-history (default 10)\n\n If metadata-map is supplied, it will become the metadata on the\n ref. validate-fn must be nil or a side-effect-free fn of one\n argument, which will be passed the intended new state on any state\n change. If the new state is unacceptable, the validate-fn should\n return false or throw an exception. validate-fn will be called on\n transaction commit, when all refs have their final values.\n\n Normally refs accumulate history dynamically as needed to deal with\n read demands. If you know in advance you will need history you can\n set :min-history to ensure it will be available when first needed (instead\n of after a read fault). History is limited, and the limit can be set\n with :max-history.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(2260), kw_end_DASH_line, int(2260))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: - v3 := args[0] + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(lang.NewRef, []any{v2}) + return tmp3 + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) _ = v3 - tmp4 := lang.Apply(lang.NewRepeat, []any{v3}) + var tmp4 any + { // let + // let binding "r" + tmp5 := checkDerefVar(var_glojure_DOT_core_setup_DASH_reference) + tmp6 := checkDerefVar(var_glojure_DOT_core_ref) + tmp7 := lang.Apply(tmp6, []any{v2}) + tmp8 := lang.Apply(tmp5, []any{tmp7, v3}) + var v9 any = tmp8 + _ = v9 + // let binding "opts" + tmp10 := checkDerefVar(var_glojure_DOT_core_apply) + tmp11 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp12 := lang.Apply(tmp10, []any{tmp11, v3}) + var v13 any = tmp12 + _ = v13 + var tmp14 any + tmp15 := lang.Apply(kw_max_DASH_history, []any{v13}) + if lang.IsTruthy(tmp15) { + tmp16 := lang.Apply(kw_max_DASH_history, []any{v13}) + tmp17, _ := lang.FieldOrMethod(v9, "setMaxHistory") + if reflect.TypeOf(tmp17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMaxHistory is not a function"))) + } + tmp18 := lang.Apply(tmp17, []any{tmp16}) + tmp14 = tmp18 + } else { + } + _ = tmp14 + var tmp19 any + tmp20 := lang.Apply(kw_min_DASH_history, []any{v13}) + if lang.IsTruthy(tmp20) { + tmp21 := lang.Apply(kw_min_DASH_history, []any{v13}) + tmp22, _ := lang.FieldOrMethod(v9, "setMinHistory") + if reflect.TypeOf(tmp22).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMinHistory is not a function"))) + } + tmp23 := lang.Apply(tmp22, []any{tmp21}) + tmp19 = tmp23 + } else { + } + _ = tmp19 + tmp4 = v9 + } // end let return tmp4 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.Apply(lang.NewRepeatN, []any{v3, v4}) - return tmp5 - default: - checkArity(args, -1) - panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ref = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_ref.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // repeatedly { tmp0 := sym_repeatedly.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_n, sym_f)), kw_doc, "Takes a function of no args, presumably with side effects, and\n returns an infinite (or length n if supplied) lazy sequence of calls\n to it", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(5167), kw_end_DASH_line, int(5167))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 1: - v3 := args[0] - _ = v3 - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 0) - tmp5 := checkDerefVar(var_glojure_DOT_core_cons) - tmp6 := lang.Apply(v3, nil) - tmp7 := checkDerefVar(var_glojure_DOT_core_repeatedly) - tmp8 := lang.Apply(tmp7, []any{v3}) - tmp9 := lang.Apply(tmp5, []any{tmp6, tmp8}) - return tmp9 + tmp4 := checkDerefVar(var_glojure_DOT_core_cons) + tmp5 := lang.Apply(v2, nil) + tmp6 := checkDerefVar(var_glojure_DOT_core_repeatedly) + tmp7 := lang.Apply(tmp6, []any{v2}) + tmp8 := lang.Apply(tmp4, []any{tmp5, tmp7}) + return tmp8 }) - tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) - return tmp5 + tmp4 := lang.Apply(lang.NewLazySeq, []any{tmp3}) + return tmp4 case 2: - v3 := args[0] + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_take) - tmp6 := checkDerefVar(var_glojure_DOT_core_repeatedly) - tmp7 := lang.Apply(tmp6, []any{v4}) - tmp8 := lang.Apply(tmp5, []any{v3, tmp7}) - return tmp8 + tmp4 := checkDerefVar(var_glojure_DOT_core_take) + tmp5 := checkDerefVar(var_glojure_DOT_core_repeatedly) + tmp6 := lang.Apply(tmp5, []any{v3}) + tmp7 := lang.Apply(tmp4, []any{v2, tmp6}) + return tmp7 default: checkArity(args, -1) panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_repeatedly = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_repeatedly.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // replace + // replicate { - tmp0 := sym_replace.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_smap), lang.NewVector(sym_smap, sym_coll)), kw_doc, "Given a map of replacement pairs and a vector/collection, returns a\n vector/seq with any elements = a key in smap replaced with the\n corresponding val in smap. Returns a transducer when no collection\n is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(5082), kw_end_DASH_line, int(5082))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_map) - var tmp5 lang.FnFunc - tmp5 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_replicate.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n, sym_x)), kw_doc, "DEPRECATED: Use 'repeat' instead.\n Returns a lazy seq of n xs.", kw_file, "glojure/core.glj", kw_deprecated, "1.3", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(3004), kw_end_DASH_line, int(3004))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_take) + tmp5 := checkDerefVar(var_glojure_DOT_core_repeat) + tmp6 := lang.Apply(tmp5, []any{v3}) + tmp7 := lang.Apply(tmp4, []any{v2, tmp6}) + return tmp7 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_replicate = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_replicate.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // resultset-seq + { + tmp0 := sym_resultset_DASH_seq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_rs)), kw_doc, "Creates and returns a lazy sequence of structmaps corresponding to\n the rows in the java.sql.ResultSet rs", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(5681), kw_end_DASH_line, int(5681))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "rsmeta" + tmp4, _ := lang.FieldOrMethod(v2, "getMetaData") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getMetaData is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{}) + var v6 any = tmp5 + _ = v6 + // let binding "idxs" + tmp7 := checkDerefVar(var_glojure_DOT_core_range) + tmp8 := checkDerefVar(var_glojure_DOT_core_inc) + tmp9, _ := lang.FieldOrMethod(v6, "getColumnCount") + if reflect.TypeOf(tmp9).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getColumnCount is not a function"))) + } + tmp10 := lang.Apply(tmp9, []any{}) + tmp11 := lang.Apply(tmp8, []any{tmp10}) + tmp12 := lang.Apply(tmp7, []any{int64(1), tmp11}) + var v13 any = tmp12 + _ = v13 + // let binding "keys" + tmp14 := checkDerefVar(var_glojure_DOT_core_map) + tmp15 := checkDerefVar(var_glojure_DOT_core_comp) + tmp16 := checkDerefVar(var_glojure_DOT_core_keyword) + var tmp17 lang.FnFunc + tmp17 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v6 := args[0] - _ = v6 - var tmp7 any - { // let - // let binding "temp__0__auto__" - tmp8 := checkDerefVar(var_glojure_DOT_core_find) - tmp9 := lang.Apply(tmp8, []any{v3, v6}) - var v10 any = tmp9 - _ = v10 - var tmp11 any - if lang.IsTruthy(v10) { - var tmp12 any - { // let - // let binding "e" - var v13 any = v10 - _ = v13 - tmp14 := checkDerefVar(var_glojure_DOT_core_val) - tmp15 := lang.Apply(tmp14, []any{v13}) - tmp12 = tmp15 - } // end let - tmp11 = tmp12 - } else { - tmp11 = v6 - } - tmp7 = tmp11 - } // end let - return tmp7 + v18 := args[0] + _ = v18 + tmp19, ok := lang.FieldOrMethod(v18, "toLowerCase") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v18, "toLowerCase"))) + } + var tmp20 any + switch reflect.TypeOf(tmp19).Kind() { + case reflect.Func: + tmp20 = lang.Apply(tmp19, nil) + default: + tmp20 = tmp19 + } + return tmp20 }) - tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5090), kw_column, int(11), kw_end_DASH_line, int(5090), kw_end_DASH_column, int(47)) - tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5688), kw_column, int(35), kw_end_DASH_line, int(5688), kw_end_DASH_column, int(62)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp8 := lang.Apply(tmp4, []any{tmp7}) - return tmp8 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - tmp6 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) - tmp7 := lang.Apply(tmp6, []any{v4}) - if lang.IsTruthy(tmp7) { - tmp8 := checkDerefVar(var_glojure_DOT_core_reduce1) - var tmp9 lang.FnFunc - tmp9 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v10 := args[0] - _ = v10 - v11 := args[1] - _ = v11 - var tmp12 any - { // let - // let binding "temp__0__auto__" - tmp13 := checkDerefVar(var_glojure_DOT_core_find) - tmp14 := checkDerefVar(var_glojure_DOT_core_nth) - tmp15 := lang.Apply(tmp14, []any{v10, v11}) - tmp16 := lang.Apply(tmp13, []any{v3, tmp15}) - var v17 any = tmp16 - _ = v17 - var tmp18 any - if lang.IsTruthy(v17) { - var tmp19 any - { // let - // let binding "e" - var v20 any = v17 - _ = v20 - tmp21 := checkDerefVar(var_glojure_DOT_core_assoc) - tmp22 := checkDerefVar(var_glojure_DOT_core_val) - tmp23 := lang.Apply(tmp22, []any{v20}) - tmp24 := lang.Apply(tmp21, []any{v10, v11, tmp23}) - tmp19 = tmp24 - } // end let - tmp18 = tmp19 - } else { - tmp18 = v10 - } - tmp12 = tmp18 - } // end let - return tmp12 - }) - tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5093), kw_column, int(17), kw_end_DASH_line, int(5096), kw_end_DASH_column, int(23)) - tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) - if err != nil { - panic(err) + tmp20 := lang.Apply(tmp15, []any{tmp16, tmp19}) + tmp21 := checkDerefVar(var_glojure_DOT_core_map) + var tmp22 lang.FnFunc + tmp22 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v23 := args[0] + _ = v23 + tmp24, _ := lang.FieldOrMethod(v6, "getColumnLabel") + if reflect.TypeOf(tmp24).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getColumnLabel is not a function"))) } - tmp12 := checkDerefVar(var_glojure_DOT_core_range) - tmp13 := checkDerefVar(var_glojure_DOT_core_count) - tmp14 := lang.Apply(tmp13, []any{v4}) - tmp15 := lang.Apply(tmp12, []any{tmp14}) - tmp16 := lang.Apply(tmp8, []any{tmp11, v4, tmp15}) - tmp5 = tmp16 - } else { - tmp17 := checkDerefVar(var_glojure_DOT_core_map) - var tmp18 lang.FnFunc - tmp18 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v19 := args[0] - _ = v19 - var tmp20 any - { // let - // let binding "temp__0__auto__" - tmp21 := checkDerefVar(var_glojure_DOT_core_find) - tmp22 := lang.Apply(tmp21, []any{v3, v19}) - var v23 any = tmp22 - _ = v23 - var tmp24 any - if lang.IsTruthy(v23) { - var tmp25 any - { // let - // let binding "e" - var v26 any = v23 - _ = v26 - tmp27 := checkDerefVar(var_glojure_DOT_core_val) - tmp28 := lang.Apply(tmp27, []any{v26}) - tmp25 = tmp28 - } // end let - tmp24 = tmp25 - } else { - tmp24 = v19 - } - tmp20 = tmp24 - } // end let - return tmp20 + tmp25 := lang.Apply(tmp24, []any{v23}) + return tmp25 + }) + tmp23 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5689), kw_column, int(26), kw_end_DASH_line, int(5689), kw_end_DASH_column, int(63)) + tmp24, err := lang.WithMeta(tmp22, tmp23.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp25 := lang.Apply(tmp21, []any{tmp24, v13}) + tmp26 := lang.Apply(tmp14, []any{tmp20, tmp25}) + var v27 any = tmp26 + _ = v27 + // let binding "check-keys" + var tmp28 any + { // let + // let binding "or__0__auto__" + tmp29 := checkDerefVar(var_glojure_DOT_core_apply) + tmp30 := checkDerefVar(var_glojure_DOT_core_distinct_QMARK_) + tmp31 := lang.Apply(tmp29, []any{tmp30, v27}) + var v32 any = tmp31 + _ = v32 + var tmp33 any + if lang.IsTruthy(v32) { + tmp33 = v32 + } else { + tmp34 := lang.Apply(lang.NewError, []any{"ResultSet must have unique column labels"}) + panic(tmp34) + } + tmp28 = tmp33 + } // end let + var v29 any = tmp28 + _ = v29 + // let binding "row-struct" + tmp30 := checkDerefVar(var_glojure_DOT_core_apply) + tmp31 := checkDerefVar(var_glojure_DOT_core_create_DASH_struct) + tmp32 := lang.Apply(tmp30, []any{tmp31, v27}) + var v33 any = tmp32 + _ = v33 + // let binding "row-values" + var tmp34 lang.FnFunc + tmp34 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp35 := checkDerefVar(var_glojure_DOT_core_map) + var tmp36 lang.FnFunc + tmp36 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v37 := args[0] + _ = v37 + tmp38, _ := lang.FieldOrMethod(v2, "getObject") + if reflect.TypeOf(tmp38).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getObject is not a function"))) + } + tmp39 := lang.Apply(tmp38, []any{v37}) + return tmp39 }) - tmp19 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5098), kw_column, int(13), kw_end_DASH_line, int(5098), kw_end_DASH_column, int(49)) - tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) + tmp37 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5694), kw_column, int(34), kw_end_DASH_line, int(5694), kw_end_DASH_column, int(71)) + tmp38, err := lang.WithMeta(tmp36, tmp37.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp21 := lang.Apply(tmp17, []any{tmp20, v4}) - tmp5 = tmp21 + tmp39 := lang.Apply(tmp35, []any{tmp38, v13}) + return tmp39 + }) + tmp35 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5694), kw_column, int(22), kw_end_DASH_line, int(5694), kw_end_DASH_column, int(78)) + tmp36, err := lang.WithMeta(tmp34, tmp35.(lang.IPersistentMap)) + if err != nil { + panic(err) } - return tmp5 - default: - checkArity(args, -1) - panic("unreachable") - } + var v37 any = tmp36 + _ = v37 + // let binding "rows" + var tmp38 lang.FnFunc + { // function thisfn + var v39 lang.FnFunc + tmp38 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp40 any + tmp41, _ := lang.FieldOrMethod(v2, "next") + if reflect.TypeOf(tmp41).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("next is not a function"))) + } + tmp42 := lang.Apply(tmp41, []any{}) + if lang.IsTruthy(tmp42) { + tmp43 := checkDerefVar(var_glojure_DOT_core_cons) + tmp44 := checkDerefVar(var_glojure_DOT_core_apply) + tmp45 := checkDerefVar(var_glojure_DOT_core_struct) + tmp46 := lang.Apply(v37, nil) + tmp47 := lang.Apply(tmp44, []any{tmp45, v33, tmp46}) + var tmp48 lang.FnFunc + tmp48 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp49 := lang.Apply(v39, nil) + return tmp49 + }) + tmp49 := lang.Apply(lang.NewLazySeq, []any{tmp48}) + tmp50 := lang.Apply(tmp43, []any{tmp47, tmp49}) + tmp40 = tmp50 + } else { + } + return tmp40 + }) + v39 = tmp38 + _ = v39 + } + tmp39 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5695), kw_column, int(16), kw_end_DASH_line, int(5697), kw_end_DASH_column, int(86)) + tmp40, err := lang.WithMeta(tmp38, tmp39.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v41 any = tmp40 + _ = v41 + tmp42 := lang.Apply(v41, nil) + tmp3 = tmp42 + } // end let + return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_resultset_DASH_seq = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_resultset_DASH_seq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // replicate + // send { - tmp0 := sym_replicate.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n, sym_x)), kw_doc, "DEPRECATED: Use 'repeat' instead.\n Returns a lazy seq of n xs.", kw_file, "glojure/core.glj", kw_deprecated, "1.3", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(3004), kw_end_DASH_line, int(3004))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_take) - tmp6 := checkDerefVar(var_glojure_DOT_core_repeat) - tmp7 := lang.Apply(tmp6, []any{v4}) - tmp8 := lang.Apply(tmp5, []any{v3, tmp7}) - return tmp8 + tmp0 := sym_send.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a, sym_f, sym__AMP_, sym_args)), kw_doc, "Dispatch an action to an agent. Returns the agent immediately.\n Subsequently, in a thread from a thread pool, the state of the agent\n will be set to the value of:\n\n (apply action-fn state-of-agent args)", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(2109), kw_end_DASH_line, int(2109))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_apply) + tmp6 := checkDerefVar(var_glojure_DOT_core_send_DASH_via) + tmp7 := lang.Apply(tmp5, []any{tmp6, nil, v2, v3, v4}) + return tmp7 + } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_send = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_send.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // require + // send-off { - tmp0 := sym_require.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_args)), kw_doc, "Loads libs, skipping any that are already loaded. Each argument is\n either a libspec that identifies a lib, a prefix list that identifies\n multiple libs whose names share a common prefix, or a flag that modifies\n how all the identified libs are loaded. Use :require in the ns macro\n in preference to calling this directly.\n\n Libs\n\n A 'lib' is a named set of resources in classpath whose contents define a\n library of Clojure code. Lib names are symbols and each lib is associated\n with a Clojure namespace and a Java package that share its name. A lib's\n name also locates its root directory within classpath using Java's\n package name to classpath-relative path mapping. All resources in a lib\n should be contained in the directory structure under its root directory.\n All definitions a lib makes should be in its associated namespace.\n\n 'require loads a lib by loading its root resource. The root resource path\n is derived from the lib name in the following manner:\n Consider a lib named by the symbol 'x.y.z; it has the root directory\n /x/y/, and its root resource is /x/y/z.clj, or\n /x/y/z.cljc if /x/y/z.clj does not exist. The\n root resource should contain code to create the lib's\n namespace (usually by using the ns macro) and load any additional\n lib resources.\n\n Libspecs\n\n A libspec is a lib name or a vector containing a lib name followed by\n options expressed as sequential keywords and arguments.\n\n Recognized options:\n :as takes a symbol as its argument and makes that symbol an alias to the\n lib's namespace in the current namespace.\n :as-alias takes a symbol as its argument and aliases like :as, however\n the lib will not be loaded. If the lib has not been loaded, a new\n empty namespace will be created (as with create-ns).\n :refer takes a list of symbols to refer from the namespace or the :all\n keyword to bring in all public vars.\n\n Prefix Lists\n\n It's common for Clojure code to depend on several libs whose names have\n the same prefix. When specifying libs, prefix lists can be used to reduce\n repetition. A prefix list contains the shared prefix followed by libspecs\n with the shared prefix removed from the lib names. After removing the\n prefix, the names that remain must not contain any periods.\n\n Flags\n\n A flag is a keyword.\n Recognized flags: :reload, :reload-all, :verbose\n :reload forces loading of all the identified libs even if they are\n already loaded (has no effect on libspecs using :as-alias)\n :reload-all implies :reload and also forces loading of all libs that the\n identified libs directly or indirectly load via require or use\n (has no effect on libspecs using :as-alias)\n :verbose triggers printing information about each load, alias, and refer\n\n Example:\n\n The following would load the libraries glojure.zip and glojure.set\n abbreviated as 's'.\n\n (require '(glojure zip [set :as s]))", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(5989), kw_end_DASH_line, int(5989))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_send_DASH_off.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a, sym_f, sym__AMP_, sym_args)), kw_doc, "Dispatch a potentially blocking action to an agent. Returns the\n agent immediately. Subsequently, in a separate thread, the state of\n the agent will be set to the value of:\n\n (apply action-fn state-of-agent args)", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(2120), kw_end_DASH_line, int(2120))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) - var v3 any = lang.NewList(args[0:]...) + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_apply) - tmp5 := checkDerefVar(var_glojure_DOT_core_load_DASH_libs) - tmp6 := lang.Apply(tmp4, []any{tmp5, kw_require, v3}) - return tmp6 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_apply) + tmp6 := checkDerefVar(var_glojure_DOT_core_send_DASH_via) + tmp7 := lang.Apply(tmp5, []any{tmp6, nil, v2, v3, v4}) + return tmp7 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_send_DASH_off = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_send_DASH_off.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // requiring-resolve + // seque { - tmp0 := sym_requiring_DASH_resolve.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_sym)), kw_doc, "Resolves namespace-qualified sym per 'resolve'. If initial resolve\nfails, attempts to require sym's namespace and retries.", kw_file, "glojure/core.glj", kw_added, "1.10", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(7), kw_line, int(6068), kw_end_DASH_line, int(6068))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := checkDerefVar(var_glojure_DOT_core_qualified_DASH_symbol_QMARK_) - tmp6 := lang.Apply(tmp5, []any{v3}) - if lang.IsTruthy(tmp6) { - var tmp7 any + tmp0 := sym_seque.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s), lang.NewVector(sym_n_DASH_or_DASH_q, sym_s)), kw_doc, "Creates a queued seq on another (presumably lazy) seq s. The queued\n seq will produce a concrete seq in the background, and can get up to\n n items ahead of the consumer. n-or-q can be an integer n buffer\n size, or an instance of java.util.concurrent BlockingQueue. Note\n that reading from a seque can block if the reader gets ahead of the\n producer.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(5419), kw_end_DASH_line, int(5419))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_seque) + tmp4 := lang.Apply(tmp3, []any{int64(100), v2}) + return tmp4 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any { // let - // let binding "or__0__auto__" - tmp8 := checkDerefVar(var_glojure_DOT_core_resolve) - tmp9 := lang.Apply(tmp8, []any{v3}) - var v10 any = tmp9 - _ = v10 - var tmp11 any - if lang.IsTruthy(v10) { - tmp11 = v10 + // let binding "q" + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp7 := lang.Apply(tmp6, []any{nil, v2}) + if lang.IsTruthy(tmp7) { + tmp5 = v2 } else { - tmp12 := checkDerefVar(var_glojure_DOT_core_serialized_DASH_require) - tmp13 := checkDerefVar(var_glojure_DOT_core_symbol) - tmp14 := checkDerefVar(var_glojure_DOT_core_namespace) - tmp15 := lang.Apply(tmp14, []any{v3}) - tmp16 := lang.Apply(tmp13, []any{tmp15}) - tmp17 := lang.Apply(tmp12, []any{tmp16}) - _ = tmp17 - tmp18 := checkDerefVar(var_glojure_DOT_core_resolve) - tmp19 := lang.Apply(tmp18, []any{v3}) - tmp11 = tmp19 + tmp8 := checkDerefVar(var_glojure_DOT_core_int) + tmp9 := lang.Apply(tmp8, []any{v2}) + tmp10 := lang.Apply(nil, []any{tmp9}) + tmp5 = tmp10 } - tmp7 = tmp11 + var v11 any = tmp5 + _ = v11 + // let binding "NIL" + tmp12 := lang.Apply(reflect.StructOf, []any{nil}) + tmp13 := lang.Apply(reflect.New, []any{tmp12}) + tmp14, ok := lang.FieldOrMethod(tmp13, "Interface") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp13, "Interface"))) + } + var tmp15 any + switch reflect.TypeOf(tmp14).Kind() { + case reflect.Func: + tmp15 = lang.Apply(tmp14, nil) + default: + tmp15 = tmp14 + } + var v16 any = tmp15 + _ = v16 + // let binding "agt" + tmp17 := checkDerefVar(var_glojure_DOT_core_agent) + var tmp18 lang.FnFunc + tmp18 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + return v3 + }) + tmp19 := lang.Apply(lang.NewLazySeq, []any{tmp18}) + tmp20 := lang.Apply(tmp17, []any{tmp19}) + var v21 any = tmp20 + _ = v21 + // let binding "log-error" + var tmp22 lang.FnFunc + tmp22 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v23 := args[0] + _ = v23 + v24 := args[1] + _ = v24 + var tmp25 any + tmp26, _ := lang.FieldOrMethod(v23, "offer") + if reflect.TypeOf(tmp26).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("offer is not a function"))) + } + tmp27 := lang.Apply(tmp26, []any{v23}) + if lang.IsTruthy(tmp27) { + panic(v24) + } else { + tmp25 = v24 + } + return tmp25 + }) + tmp23 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5435), kw_column, int(20), kw_end_DASH_line, int(5438), kw_end_DASH_column, int(26)) + tmp24, err := lang.WithMeta(tmp22, tmp23.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v25 any = tmp24 + _ = v25 + // let binding "fill" + var tmp26 lang.FnFunc + tmp26 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v27 := args[0] + _ = v27 + var tmp28 any + if lang.IsTruthy(v27) { + var tmp29 any + tmp30 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp31 := lang.Apply(tmp30, []any{nil, v27}) + if lang.IsTruthy(tmp31) { + tmp32 := lang.Apply(v25, []any{v11, v27}) + tmp29 = tmp32 + } else { + var tmp33 any + func() { + defer func() { + if r := recover(); r != nil { + if lang.CatchMatches(r, lang.Builtins["any"]) { + v34 := r + _ = v34 + tmp35 := lang.Apply(v25, []any{v11, v34}) + tmp33 = tmp35 + } else { + panic(r) + } + } + }() + var tmp34 any + { // let + // let binding "G__89" + tmp35 := checkDerefVar(var_glojure_DOT_core_seq) + tmp36 := lang.Apply(tmp35, []any{v27}) + var v37 any = tmp36 + _ = v37 + // let binding "vec__90" + var v38 any = v37 + _ = v38 + // let binding "seq__91" + tmp39 := checkDerefVar(var_glojure_DOT_core_seq) + tmp40 := lang.Apply(tmp39, []any{v38}) + var v41 any = tmp40 + _ = v41 + // let binding "first__92" + tmp42 := checkDerefVar(var_glojure_DOT_core_first) + tmp43 := lang.Apply(tmp42, []any{v41}) + var v44 any = tmp43 + _ = v44 + // let binding "seq__91" + tmp45 := checkDerefVar(var_glojure_DOT_core_next) + tmp46 := lang.Apply(tmp45, []any{v41}) + var v47 any = tmp46 + _ = v47 + // let binding "x" + var v48 any = v44 + _ = v48 + // let binding "xs" + var v49 any = v47 + _ = v49 + // let binding "s" + var v50 any = v38 + _ = v50 + var tmp51 any + { // let + // let binding "G__89" + var v52 any = v37 + _ = v52 + for { + var tmp53 any + { // let + // let binding "vec__93" + var v54 any = v52 + _ = v54 + // let binding "seq__94" + tmp55 := checkDerefVar(var_glojure_DOT_core_seq) + tmp56 := lang.Apply(tmp55, []any{v54}) + var v57 any = tmp56 + _ = v57 + // let binding "first__95" + tmp58 := checkDerefVar(var_glojure_DOT_core_first) + tmp59 := lang.Apply(tmp58, []any{v57}) + var v60 any = tmp59 + _ = v60 + // let binding "seq__94" + tmp61 := checkDerefVar(var_glojure_DOT_core_next) + tmp62 := lang.Apply(tmp61, []any{v57}) + var v63 any = tmp62 + _ = v63 + // let binding "x" + var v64 any = v60 + _ = v64 + // let binding "xs" + var v65 any = v63 + _ = v65 + // let binding "s" + var v66 any = v54 + _ = v66 + var tmp67 any + if lang.IsTruthy(v66) { + var tmp68 any + var tmp69 any + tmp70 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp71 := lang.Apply(tmp70, []any{v64}) + if lang.IsTruthy(tmp71) { + tmp69 = v16 + } else { + tmp69 = v64 + } + tmp72, _ := lang.FieldOrMethod(v11, "offer") + if reflect.TypeOf(tmp72).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("offer is not a function"))) + } + tmp73 := lang.Apply(tmp72, []any{tmp69}) + if lang.IsTruthy(tmp73) { + var tmp74 any = v65 + v52 = tmp74 + continue + } else { + tmp68 = v66 + } + tmp67 = tmp68 + } else { + var tmp75 any + tmp76, _ := lang.FieldOrMethod(v11, "offer") + if reflect.TypeOf(tmp76).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("offer is not a function"))) + } + tmp77 := lang.Apply(tmp76, []any{v11}) + if lang.IsTruthy(tmp77) { + } else { + tmp75 = lang.NewList() + } + tmp67 = tmp75 + } + tmp53 = tmp67 + } // end let + tmp51 = tmp53 + break + } + } // end let + tmp34 = tmp51 + } // end let + tmp33 = tmp34 + }() + tmp29 = tmp33 + } + tmp28 = tmp29 + } else { + } + return tmp28 + }) + tmp27 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5439), kw_column, int(15), kw_end_DASH_line, int(5452), kw_end_DASH_column, int(44)) + tmp28, err := lang.WithMeta(tmp26, tmp27.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v29 any = tmp28 + _ = v29 + // let binding "drain" + var tmp30 lang.FnFunc + { // function drain + var v31 lang.FnFunc + tmp30 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp32 lang.FnFunc + tmp32 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp33 any + { // let + // let binding "x" + tmp34, ok := lang.FieldOrMethod(v11, "take") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v11, "take"))) + } + var tmp35 any + switch reflect.TypeOf(tmp34).Kind() { + case reflect.Func: + tmp35 = lang.Apply(tmp34, nil) + default: + tmp35 = tmp34 + } + var v36 any = tmp35 + _ = v36 + var tmp37 any + tmp38 := checkDerefVar(var_glojure_DOT_core_identical_QMARK_) + tmp39 := lang.Apply(tmp38, []any{v36, v11}) + if lang.IsTruthy(tmp39) { + tmp40 := checkDerefVar(var_glojure_DOT_core_deref) + tmp41 := lang.Apply(tmp40, []any{v21}) + _ = tmp41 + } else { + tmp42 := checkDerefVar(var_glojure_DOT_core_send_DASH_off) + tmp43 := lang.Apply(tmp42, []any{v21, v29}) + _ = tmp43 + tmp44 := checkDerefVar(var_glojure_DOT_core_release_DASH_pending_DASH_sends) + tmp45 := lang.Apply(tmp44, nil) + _ = tmp45 + tmp46 := checkDerefVar(var_glojure_DOT_core_cons) + var tmp47 any + tmp48 := checkDerefVar(var_glojure_DOT_core_identical_QMARK_) + tmp49 := lang.Apply(tmp48, []any{v36, v16}) + if lang.IsTruthy(tmp49) { + } else { + tmp47 = v36 + } + tmp50 := lang.Apply(v31, nil) + tmp51 := lang.Apply(tmp46, []any{tmp47, tmp50}) + tmp37 = tmp51 + } + tmp33 = tmp37 + } // end let + return tmp33 + }) + tmp33 := lang.Apply(lang.NewLazySeq, []any{tmp32}) + return tmp33 + }) + v31 = tmp30 + _ = v31 + } + tmp31 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5453), kw_column, int(16), kw_end_DASH_line, int(5461), kw_end_DASH_column, int(73)) + tmp32, err := lang.WithMeta(tmp30, tmp31.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v33 any = tmp32 + _ = v33 + tmp34 := checkDerefVar(var_glojure_DOT_core_send_DASH_off) + tmp35 := lang.Apply(tmp34, []any{v21, v29}) + _ = tmp35 + tmp36 := lang.Apply(v33, nil) + tmp4 = tmp36 } // end let - tmp4 = tmp7 - } else { - tmp8 := checkDerefVar(var_glojure_DOT_core_str) - tmp9 := lang.Apply(tmp8, []any{"Not a qualified symbol: ", v3}) - tmp10 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp9}) - panic(tmp10) - } - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // reset! - { - tmp0 := sym_reset_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_atom, sym_newval)), kw_doc, "Sets the value of atom to newval without regard for the\n current value. Returns newval.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(2368), kw_end_DASH_line, int(2368))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5, _ := lang.FieldOrMethod(v3, "reset") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // reset-meta! - { - tmp0 := sym_reset_DASH_meta_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_iref, sym_metadata_DASH_map)), kw_doc, "Atomically resets the metadata for a namespace/var/ref/agent/atom", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(2408), kw_end_DASH_line, int(2408))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5, _ := lang.FieldOrMethod(v3, "ResetMeta") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ResetMeta is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // reset-vals! - { - tmp0 := sym_reset_DASH_vals_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_atom, sym_newval)), kw_doc, "Sets the value of atom to newval. Returns [old new], the value of the\n atom before and after the reset.", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(2375), kw_end_DASH_line, int(2375))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5, _ := lang.FieldOrMethod(v3, "resetVals") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("resetVals is not a function"))) + return tmp4 + default: + checkArity(args, -1) + panic("unreachable") } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_seque = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_seque.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // resolve + // sigs { - tmp0 := sym_resolve.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_sym), lang.NewVector(sym_env, sym_sym)), kw_doc, "same as (ns-resolve *ns* symbol) or (ns-resolve *ns* &env symbol)", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4371), kw_end_DASH_line, int(4371))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_ns_DASH_resolve) - tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) - tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) - return tmp6 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_ns_DASH_resolve) - tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) - tmp7 := lang.Apply(tmp5, []any{tmp6, v3, v4}) - return tmp7 - default: - checkArity(args, -1) - panic("unreachable") - } + tmp0 := sym_sigs.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(223), kw_column, int(2), kw_end_DASH_line, int(224), kw_end_DASH_column, int(5), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_assert_DASH_valid_DASH_fdecl) + tmp4 := lang.Apply(tmp3, []any{v2}) + _ = tmp4 + var tmp5 any + { // let + // let binding "asig" + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v7 := args[0] + _ = v7 + var tmp8 any + { // let + // let binding "arglist" + tmp9 := checkDerefVar(var_glojure_DOT_core_first) + tmp10 := lang.Apply(tmp9, []any{v7}) + var v11 any = tmp10 + _ = v11 + // let binding "arglist" + var tmp12 any + tmp13 := checkDerefVar(var_glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v11}) + tmp15 := lang.Apply(lang.Equals, []any{sym__AMP_form, tmp14}) + if lang.IsTruthy(tmp15) { + tmp16 := lang.Apply(lang.Count, []any{v11}) + tmp17 := lang.Apply(lang.Subvec, []any{v11, int64(2), tmp16}) + tmp12 = tmp17 + } else { + tmp12 = v11 + } + var v18 any = tmp12 + _ = v18 + // let binding "body" + tmp19 := checkDerefVar(var_glojure_DOT_core_next) + tmp20 := lang.Apply(tmp19, []any{v7}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + tmp23 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v21}) + tmp26 := lang.Apply(tmp23, []any{tmp25}) + if lang.IsTruthy(tmp26) { + var tmp27 any + tmp28 := checkDerefVar(var_glojure_DOT_core_next) + tmp29 := lang.Apply(tmp28, []any{v21}) + if lang.IsTruthy(tmp29) { + tmp30 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp31 := checkDerefVar(var_glojure_DOT_core_conj) + var tmp32 any + tmp33 := checkDerefVar(var_glojure_DOT_core_meta) + tmp34 := lang.Apply(tmp33, []any{v18}) + if lang.IsTruthy(tmp34) { + tmp35 := checkDerefVar(var_glojure_DOT_core_meta) + tmp36 := lang.Apply(tmp35, []any{v18}) + tmp32 = tmp36 + } else { + tmp37 := lang.NewMap() + tmp38 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(237), kw_column, int(77), kw_end_DASH_line, int(237), kw_end_DASH_column, int(78)) + tmp39, err := lang.WithMeta(tmp37, tmp38.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp32 = tmp39 + } + tmp40 := checkDerefVar(var_glojure_DOT_core_first) + tmp41 := lang.Apply(tmp40, []any{v21}) + tmp42 := lang.Apply(tmp31, []any{tmp32, tmp41}) + tmp43 := lang.Apply(tmp30, []any{v18, tmp42}) + tmp27 = tmp43 + } else { + tmp27 = v18 + } + tmp22 = tmp27 + } else { + tmp22 = v18 + } + tmp8 = tmp22 + } // end let + return tmp8 + }) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(228), kw_column, int(10), kw_end_DASH_line, int(239), kw_end_DASH_column, int(25)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v9 any = tmp8 + _ = v9 + // let binding "resolve-tag" + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v11 := args[0] + _ = v11 + var tmp12 any + { // let + // let binding "m" + tmp13 := checkDerefVar(var_glojure_DOT_core_meta) + tmp14 := lang.Apply(tmp13, []any{v11}) + var v15 any = tmp14 + _ = v15 + // let binding "tag" + tmp16 := lang.Apply(kw_tag, []any{v15}) + var v17 any = tmp16 + _ = v17 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp20 := reflect.TypeOf((*lang.Symbol)(nil)) + tmp21 := lang.Apply(tmp19, []any{tmp20, v17}) + if lang.IsTruthy(tmp21) { + var tmp22 any + tmp23, ok := lang.FieldOrMethod(v17, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v17, "Name"))) + } + var tmp24 any + switch reflect.TypeOf(tmp23).Kind() { + case reflect.Func: + tmp24 = lang.Apply(tmp23, nil) + default: + tmp24 = tmp23 + } + tmp25 := lang.Apply(strings11.Index, []any{tmp24, "."}) + tmp26 := lang.Apply(lang.Equiv, []any{tmp25, int64(-1)}) + if lang.IsTruthy(tmp26) { + var tmp27 any + tmp28 := lang.Apply(lang.Equals, []any{nil, nil}) + if lang.IsTruthy(tmp28) { + var tmp29 any + { // let + // let binding "c" + var v30 any = nil + _ = v30 + var tmp31 any + if lang.IsTruthy(v30) { + tmp32 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp33 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp34, ok := lang.FieldOrMethod(v30, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v30, "Name"))) + } + var tmp35 any + switch reflect.TypeOf(tmp34).Kind() { + case reflect.Func: + tmp35 = lang.Apply(tmp34, nil) + default: + tmp35 = tmp34 + } + tmp36 := lang.Apply(lang.NewSymbol, []any{tmp35}) + tmp37 := lang.Apply(tmp33, []any{v15, kw_tag, tmp36}) + tmp38 := lang.Apply(tmp32, []any{v11, tmp37}) + tmp31 = tmp38 + } else { + tmp31 = v11 + } + tmp29 = tmp31 + } // end let + tmp27 = tmp29 + } else { + tmp27 = v11 + } + tmp22 = tmp27 + } else { + tmp22 = v11 + } + tmp18 = tmp22 + } else { + tmp18 = v11 + } + tmp12 = tmp18 + } // end let + return tmp12 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(240), kw_column, int(22), kw_end_DASH_line, int(252), kw_end_DASH_column, int(37)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v13 any = tmp12 + _ = v13 + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp16 := checkDerefVar(var_glojure_DOT_core_first) + tmp17 := lang.Apply(tmp16, []any{v2}) + tmp18 := lang.Apply(tmp15, []any{tmp17}) + if lang.IsTruthy(tmp18) { + var tmp19 any + { // let + // let binding "ret" + tmp20 := lang.NewVector() + tmp21 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(254), kw_column, int(19), kw_end_DASH_line, int(254), kw_end_DASH_column, int(20)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v23 any = tmp22 + _ = v23 + // let binding "fdecls" + var v24 any = v2 + _ = v24 + for { + var tmp25 any + if lang.IsTruthy(v24) { + tmp27 := checkDerefVar(var_glojure_DOT_core_conj) + tmp28 := checkDerefVar(var_glojure_DOT_core_first) + tmp29 := lang.Apply(tmp28, []any{v24}) + tmp30 := lang.Apply(v9, []any{tmp29}) + tmp31 := lang.Apply(v13, []any{tmp30}) + tmp32 := lang.Apply(tmp27, []any{v23, tmp31}) + var tmp26 any = tmp32 + tmp34 := checkDerefVar(var_glojure_DOT_core_next) + tmp35 := lang.Apply(tmp34, []any{v24}) + var tmp33 any = tmp35 + v23 = tmp26 + v24 = tmp33 + continue + } else { + tmp36 := checkDerefVar(var_glojure_DOT_core_seq) + tmp37 := lang.Apply(tmp36, []any{v23}) + tmp25 = tmp37 + } + tmp19 = tmp25 + break + } + } // end let + tmp14 = tmp19 + } else { + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(v9, []any{v2}) + tmp22 := lang.Apply(v13, []any{tmp21}) + tmp23 := lang.Apply(tmp20, []any{tmp22}) + tmp14 = tmp23 + } + tmp5 = tmp14 + } // end let + return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // rest - { - tmp1 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() - tmp0 := sym_rest.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a possibly empty seq of the items after the first. Calls seq on its\n argument.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(5), kw_column, int(2), kw_line, int(64), kw_end_DASH_line, int(70))).(*lang.Symbol) - var tmp3 lang.FnFunc - { // function rest - var v4 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v5 := args[0] - _ = v5 - tmp6 := lang.Apply(lang.Rest, []any{v5}) - return tmp6 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(70), kw_column, int(7), kw_end_DASH_line, int(70), kw_end_DASH_column, int(77))).(lang.FnFunc) - v4 = tmp3 - _ = v4 - } - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(225), kw_column, int(2), kw_end_DASH_line, int(258), kw_end_DASH_column, int(43))).(lang.FnFunc) + var_glojure_DOT_core_sigs = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_sigs.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // restart-agent + // some-> { - tmp0 := sym_restart_DASH_agent.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a, sym_new_DASH_state, sym__AMP_, sym_options)), kw_doc, "When an agent is failed, changes the agent state to new-state and\n then un-fails the agent so that sends are allowed again. If\n a :clear-actions true option is given, any actions queued on the\n agent that were being held while it was failed will be discarded,\n otherwise those held actions will proceed. The new-state must pass\n the validator if any, or restart will throw an exception and the\n agent will remain failed with its old state and error. Watchers, if\n any, will NOT be notified of the new state. Throws an exception if\n the agent is not failed.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(2175), kw_end_DASH_line, int(2175))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_some_DASH__GT_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_expr, sym__AMP_, sym_forms)), kw_doc, "When expr is not nil, threads it into the first form (via ->),\n and when that result is not nil, through the next etc", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(11), kw_line, int(7610), kw_end_DASH_line, int(7610))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) - v3 := args[0] + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[2:]...) + var v5 any = lang.NewList(args[3:]...) _ = v5 var tmp6 any { // let - // let binding "opts" - tmp7 := checkDerefVar(var_glojure_DOT_core_apply) - tmp8 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) - tmp9 := lang.Apply(tmp7, []any{tmp8, v5}) - var v10 any = tmp9 - _ = v10 - var tmp11 any - tmp12 := lang.Apply(kw_clear_DASH_actions, []any{v10}) - if lang.IsTruthy(tmp12) { - tmp11 = true - } else { - tmp11 = false - } - tmp13, _ := lang.FieldOrMethod(v3, "restart") - if reflect.TypeOf(tmp13).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("restart is not a function"))) + // let binding "g" + tmp7 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp8 := lang.Apply(tmp7, nil) + var v9 any = tmp8 + _ = v9 + // let binding "steps" + tmp10 := checkDerefVar(var_glojure_DOT_core_map) + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v12 := args[0] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_if}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{sym_glojure_DOT_core_SLASH_nil_QMARK_}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v9}) + tmp24 := lang.Apply(tmp19, []any{tmp21, tmp23}) + tmp25 := lang.Apply(tmp18, []any{tmp24}) + tmp26 := lang.Apply(tmp17, []any{tmp25}) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{nil}) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := checkDerefVar(var_glojure_DOT_core_seq) + tmp31 := checkDerefVar(var_glojure_DOT_core_concat) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := lang.Apply(tmp32, []any{sym_glojure_DOT_core_SLASH__DASH__GT_}) + tmp34 := checkDerefVar(var_glojure_DOT_core_list) + tmp35 := lang.Apply(tmp34, []any{v9}) + tmp36 := checkDerefVar(var_glojure_DOT_core_list) + tmp37 := lang.Apply(tmp36, []any{v12}) + tmp38 := lang.Apply(tmp31, []any{tmp33, tmp35, tmp37}) + tmp39 := lang.Apply(tmp30, []any{tmp38}) + tmp40 := lang.Apply(tmp29, []any{tmp39}) + tmp41 := lang.Apply(tmp14, []any{tmp16, tmp26, tmp28, tmp40}) + tmp42 := lang.Apply(tmp13, []any{tmp41}) + return tmp42 + }) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7616), kw_column, int(20), kw_end_DASH_line, int(7616), kw_end_DASH_column, int(64)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) } - tmp14 := lang.Apply(tmp13, []any{v4, tmp11}) - tmp6 = tmp14 + tmp14 := lang.Apply(tmp10, []any{tmp13, v5}) + var v15 any = tmp14 + _ = v15 + tmp16 := checkDerefVar(var_glojure_DOT_core_seq) + tmp17 := checkDerefVar(var_glojure_DOT_core_concat) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{sym_glojure_DOT_core_SLASH_let}) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := checkDerefVar(var_glojure_DOT_core_apply) + tmp22 := checkDerefVar(var_glojure_DOT_core_vector) + tmp23 := checkDerefVar(var_glojure_DOT_core_seq) + tmp24 := checkDerefVar(var_glojure_DOT_core_concat) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := lang.Apply(tmp25, []any{v9}) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{v4}) + tmp29 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp30 := checkDerefVar(var_glojure_DOT_core_repeat) + tmp31 := lang.Apply(tmp30, []any{v9}) + tmp32 := checkDerefVar(var_glojure_DOT_core_butlast) + tmp33 := lang.Apply(tmp32, []any{v15}) + tmp34 := lang.Apply(tmp29, []any{tmp31, tmp33}) + tmp35 := lang.Apply(tmp24, []any{tmp26, tmp28, tmp34}) + tmp36 := lang.Apply(tmp23, []any{tmp35}) + tmp37 := lang.Apply(tmp21, []any{tmp22, tmp36}) + tmp38 := lang.Apply(tmp20, []any{tmp37}) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + var tmp40 any + tmp41 := checkDerefVar(var_glojure_DOT_core_empty_QMARK_) + tmp42 := lang.Apply(tmp41, []any{v15}) + if lang.IsTruthy(tmp42) { + tmp40 = v9 + } else { + tmp43 := checkDerefVar(var_glojure_DOT_core_last) + tmp44 := lang.Apply(tmp43, []any{v15}) + tmp40 = tmp44 + } + tmp45 := lang.Apply(tmp39, []any{tmp40}) + tmp46 := lang.Apply(tmp17, []any{tmp19, tmp38, tmp45}) + tmp47 := lang.Apply(tmp16, []any{tmp46}) + tmp6 = tmp47 } // end let return tmp6 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_some_DASH__GT_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_some_DASH__GT_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // resultset-seq + // some->> { - tmp0 := sym_resultset_DASH_seq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_rs)), kw_doc, "Creates and returns a lazy sequence of structmaps corresponding to\n the rows in the java.sql.ResultSet rs", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(5681), kw_end_DASH_line, int(5681))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "rsmeta" - tmp5, _ := lang.FieldOrMethod(v3, "getMetaData") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("getMetaData is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{}) - var v7 any = tmp6 - _ = v7 - // let binding "idxs" - tmp8 := checkDerefVar(var_glojure_DOT_core_range) - tmp9 := checkDerefVar(var_glojure_DOT_core_inc) - tmp10, _ := lang.FieldOrMethod(v7, "getColumnCount") - if reflect.TypeOf(tmp10).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("getColumnCount is not a function"))) - } - tmp11 := lang.Apply(tmp10, []any{}) - tmp12 := lang.Apply(tmp9, []any{tmp11}) - tmp13 := lang.Apply(tmp8, []any{int64(1), tmp12}) - var v14 any = tmp13 - _ = v14 - // let binding "keys" - tmp15 := checkDerefVar(var_glojure_DOT_core_map) - tmp16 := checkDerefVar(var_glojure_DOT_core_comp) - tmp17 := checkDerefVar(var_glojure_DOT_core_keyword) - var tmp18 lang.FnFunc - tmp18 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v19 := args[0] - _ = v19 - tmp20, ok := lang.FieldOrMethod(v19, "toLowerCase") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v19, "toLowerCase"))) - } - var tmp21 any - switch reflect.TypeOf(tmp20).Kind() { - case reflect.Func: - tmp21 = lang.Apply(tmp20, nil) - default: - tmp21 = tmp20 - } - return tmp21 - }) - tmp19 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5688), kw_column, int(35), kw_end_DASH_line, int(5688), kw_end_DASH_column, int(62)) - tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp21 := lang.Apply(tmp16, []any{tmp17, tmp20}) - tmp22 := checkDerefVar(var_glojure_DOT_core_map) - var tmp23 lang.FnFunc - tmp23 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v24 := args[0] - _ = v24 - tmp25, _ := lang.FieldOrMethod(v7, "getColumnLabel") - if reflect.TypeOf(tmp25).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("getColumnLabel is not a function"))) - } - tmp26 := lang.Apply(tmp25, []any{v24}) - return tmp26 - }) - tmp24 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5689), kw_column, int(26), kw_end_DASH_line, int(5689), kw_end_DASH_column, int(63)) - tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp26 := lang.Apply(tmp22, []any{tmp25, v14}) - tmp27 := lang.Apply(tmp15, []any{tmp21, tmp26}) - var v28 any = tmp27 - _ = v28 - // let binding "check-keys" - var tmp29 any + tmp0 := sym_some_DASH__GT__GT_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_expr, sym__AMP_, sym_forms)), kw_doc, "When expr is not nil, threads it into the first form (via ->>),\n and when that result is not nil, through the next etc", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(7624), kw_end_DASH_line, int(7624))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any { // let - // let binding "or__0__auto__" - tmp30 := checkDerefVar(var_glojure_DOT_core_apply) - tmp31 := checkDerefVar(var_glojure_DOT_core_distinct_QMARK_) - tmp32 := lang.Apply(tmp30, []any{tmp31, v28}) - var v33 any = tmp32 - _ = v33 - var tmp34 any - if lang.IsTruthy(v33) { - tmp34 = v33 - } else { - tmp35 := lang.Apply(lang.NewError, []any{"ResultSet must have unique column labels"}) - panic(tmp35) - } - tmp29 = tmp34 - } // end let - var v30 any = tmp29 - _ = v30 - // let binding "row-struct" - tmp31 := checkDerefVar(var_glojure_DOT_core_apply) - tmp32 := checkDerefVar(var_glojure_DOT_core_create_DASH_struct) - tmp33 := lang.Apply(tmp31, []any{tmp32, v28}) - var v34 any = tmp33 - _ = v34 - // let binding "row-values" - var tmp35 lang.FnFunc - tmp35 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - tmp36 := checkDerefVar(var_glojure_DOT_core_map) - var tmp37 lang.FnFunc - tmp37 = lang.NewFnFunc(func(args ...any) any { + // let binding "g" + tmp7 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp8 := lang.Apply(tmp7, nil) + var v9 any = tmp8 + _ = v9 + // let binding "steps" + tmp10 := checkDerefVar(var_glojure_DOT_core_map) + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v38 := args[0] - _ = v38 - tmp39, _ := lang.FieldOrMethod(v3, "getObject") - if reflect.TypeOf(tmp39).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("getObject is not a function"))) - } - tmp40 := lang.Apply(tmp39, []any{v38}) - return tmp40 + v12 := args[0] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_if}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{sym_glojure_DOT_core_SLASH_nil_QMARK_}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v9}) + tmp24 := lang.Apply(tmp19, []any{tmp21, tmp23}) + tmp25 := lang.Apply(tmp18, []any{tmp24}) + tmp26 := lang.Apply(tmp17, []any{tmp25}) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{nil}) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := checkDerefVar(var_glojure_DOT_core_seq) + tmp31 := checkDerefVar(var_glojure_DOT_core_concat) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := lang.Apply(tmp32, []any{sym_glojure_DOT_core_SLASH__DASH__GT__GT_}) + tmp34 := checkDerefVar(var_glojure_DOT_core_list) + tmp35 := lang.Apply(tmp34, []any{v9}) + tmp36 := checkDerefVar(var_glojure_DOT_core_list) + tmp37 := lang.Apply(tmp36, []any{v12}) + tmp38 := lang.Apply(tmp31, []any{tmp33, tmp35, tmp37}) + tmp39 := lang.Apply(tmp30, []any{tmp38}) + tmp40 := lang.Apply(tmp29, []any{tmp39}) + tmp41 := lang.Apply(tmp14, []any{tmp16, tmp26, tmp28, tmp40}) + tmp42 := lang.Apply(tmp13, []any{tmp41}) + return tmp42 }) - tmp38 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5694), kw_column, int(34), kw_end_DASH_line, int(5694), kw_end_DASH_column, int(71)) - tmp39, err := lang.WithMeta(tmp37, tmp38.(lang.IPersistentMap)) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7630), kw_column, int(20), kw_end_DASH_line, int(7630), kw_end_DASH_column, int(65)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp40 := lang.Apply(tmp36, []any{tmp39, v14}) - return tmp40 - }) - tmp36 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5694), kw_column, int(22), kw_end_DASH_line, int(5694), kw_end_DASH_column, int(78)) - tmp37, err := lang.WithMeta(tmp35, tmp36.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v38 any = tmp37 - _ = v38 - // let binding "rows" - var tmp39 lang.FnFunc - { // function thisfn - var v40 lang.FnFunc - tmp39 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - var tmp41 any - tmp42, _ := lang.FieldOrMethod(v3, "next") - if reflect.TypeOf(tmp42).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("next is not a function"))) - } - tmp43 := lang.Apply(tmp42, []any{}) - if lang.IsTruthy(tmp43) { - tmp44 := checkDerefVar(var_glojure_DOT_core_cons) - tmp45 := checkDerefVar(var_glojure_DOT_core_apply) - tmp46 := checkDerefVar(var_glojure_DOT_core_struct) - tmp47 := lang.Apply(v38, nil) - tmp48 := lang.Apply(tmp45, []any{tmp46, v34, tmp47}) - var tmp49 lang.FnFunc - tmp49 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - tmp50 := lang.Apply(v40, nil) - return tmp50 - }) - tmp50 := lang.Apply(lang.NewLazySeq, []any{tmp49}) - tmp51 := lang.Apply(tmp44, []any{tmp48, tmp50}) - tmp41 = tmp51 - } else { - } - return tmp41 - }) - v40 = tmp39 - _ = v40 - } - tmp40 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5695), kw_column, int(16), kw_end_DASH_line, int(5697), kw_end_DASH_column, int(86)) - tmp41, err := lang.WithMeta(tmp39, tmp40.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v42 any = tmp41 - _ = v42 - tmp43 := lang.Apply(v42, nil) - tmp4 = tmp43 - } // end let - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // reverse - { - tmp0 := sym_reverse.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a seq of the items in coll in reverse order. Not lazy.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(940), kw_end_DASH_line, int(940))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_reduce1) - tmp5 := checkDerefVar(var_glojure_DOT_core_conj) - tmp6 := lang.Apply(tmp4, []any{tmp5, lang.NewList(), v3}) - return tmp6 + tmp14 := lang.Apply(tmp10, []any{tmp13, v5}) + var v15 any = tmp14 + _ = v15 + tmp16 := checkDerefVar(var_glojure_DOT_core_seq) + tmp17 := checkDerefVar(var_glojure_DOT_core_concat) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{sym_glojure_DOT_core_SLASH_let}) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := checkDerefVar(var_glojure_DOT_core_apply) + tmp22 := checkDerefVar(var_glojure_DOT_core_vector) + tmp23 := checkDerefVar(var_glojure_DOT_core_seq) + tmp24 := checkDerefVar(var_glojure_DOT_core_concat) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := lang.Apply(tmp25, []any{v9}) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{v4}) + tmp29 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp30 := checkDerefVar(var_glojure_DOT_core_repeat) + tmp31 := lang.Apply(tmp30, []any{v9}) + tmp32 := checkDerefVar(var_glojure_DOT_core_butlast) + tmp33 := lang.Apply(tmp32, []any{v15}) + tmp34 := lang.Apply(tmp29, []any{tmp31, tmp33}) + tmp35 := lang.Apply(tmp24, []any{tmp26, tmp28, tmp34}) + tmp36 := lang.Apply(tmp23, []any{tmp35}) + tmp37 := lang.Apply(tmp21, []any{tmp22, tmp36}) + tmp38 := lang.Apply(tmp20, []any{tmp37}) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + var tmp40 any + tmp41 := checkDerefVar(var_glojure_DOT_core_empty_QMARK_) + tmp42 := lang.Apply(tmp41, []any{v15}) + if lang.IsTruthy(tmp42) { + tmp40 = v9 + } else { + tmp43 := checkDerefVar(var_glojure_DOT_core_last) + tmp44 := lang.Apply(tmp43, []any{v15}) + tmp40 = tmp44 + } + tmp45 := lang.Apply(tmp39, []any{tmp40}) + tmp46 := lang.Apply(tmp17, []any{tmp19, tmp38, tmp45}) + tmp47 := lang.Apply(tmp16, []any{tmp46}) + tmp6 = tmp47 + } // end let + return tmp6 + } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_some_DASH__GT__GT_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_some_DASH__GT__GT_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // reversible? + // split-at { - tmp0 := sym_reversible_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns true if coll implements Reversible", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(6257), kw_end_DASH_line, int(6257))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp5 := lang.Apply(tmp4, []any{nil, v3}) - return tmp5 + tmp0 := sym_split_DASH_at.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n, sym_coll)), kw_doc, "Returns a vector of [(take n coll) (drop n coll)]", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(2983), kw_end_DASH_line, int(2983))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_take) + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + tmp6 := checkDerefVar(var_glojure_DOT_core_drop) + tmp7 := lang.Apply(tmp6, []any{v2, v3}) + tmp8 := lang.NewVector(tmp5, tmp7) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2988), kw_column, int(5), kw_end_DASH_line, int(2988), kw_end_DASH_column, int(33)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp10 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_split_DASH_at = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_split_DASH_at.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // root-directory + // to-array-2d { - tmp0 := sym_root_DASH_directory.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_lib)), kw_doc, "Returns the root resource path for a lib", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(8), kw_line, int(5871), kw_end_DASH_line, int(5871), kw_private, true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_to_DASH_array_DASH_2d.WithMeta(lang.NewMap(kw_tag, "[[Ljava.lang.Object;", kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a (potentially-ragged) 2-dimensional array of Objects\n containing the contents of coll, which can be any Collection of any\n Collection.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(4002), kw_end_DASH_line, int(4002))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 any + v2 := args[0] + _ = v2 + var tmp3 any { // let - // let binding "d" - tmp5 := checkDerefVar(var_glojure_DOT_core_root_DASH_resource) - tmp6 := lang.Apply(tmp5, []any{v3}) - var v7 any = tmp6 - _ = v7 - tmp8 := checkDerefVar(var_glojure_DOT_core_subs) - tmp9 := lang.Apply(strings11.LastIndex, []any{v7, "/"}) - tmp10 := lang.Apply(tmp8, []any{v7, int64(0), tmp9}) - tmp4 = tmp10 + // let binding "ret" + tmp4 := checkDerefVar(var_glojure_DOT_core_make_DASH_array) + tmp5 := reflect.TypeOf((*reflect.Type)(nil)).Elem() + tmp6, _ := lang.FieldOrMethod(tmp5, "forName") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("forName is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{"[Ljava.lang.Object;"}) + tmp8, _ := lang.FieldOrMethod(v2, "size") + if reflect.TypeOf(tmp8).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("size is not a function"))) + } + tmp9 := lang.Apply(tmp8, []any{}) + tmp10 := lang.Apply(tmp4, []any{tmp7, tmp9}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + { // let + // let binding "i" + var v13 any = int64(0) + _ = v13 + // let binding "xs" + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := lang.Apply(tmp14, []any{v2}) + var v16 any = tmp15 + _ = v16 + for { + var tmp17 any + if lang.IsTruthy(v16) { + tmp18 := checkDerefVar(var_glojure_DOT_core_aset) + tmp19 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) + tmp20 := checkDerefVar(var_glojure_DOT_core_first) + tmp21 := lang.Apply(tmp20, []any{v16}) + tmp22 := lang.Apply(tmp19, []any{tmp21}) + tmp23 := lang.Apply(tmp18, []any{v11, v13, tmp22}) + _ = tmp23 + tmp25 := checkDerefVar(var_glojure_DOT_core_inc) + tmp26 := lang.Apply(tmp25, []any{v13}) + var tmp24 any = tmp26 + tmp28 := checkDerefVar(var_glojure_DOT_core_next) + tmp29 := lang.Apply(tmp28, []any{v16}) + var tmp27 any = tmp29 + v13 = tmp24 + v16 = tmp27 + continue + } else { + } + tmp12 = tmp17 + break + } + } // end let + _ = tmp12 + tmp3 = v11 } // end let - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // root-resource - { - tmp1 := reflect.TypeOf("") - tmp0 := sym_root_DASH_resource.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_lib)), kw_doc, "Returns the root directory path for a lib", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(8), kw_line, int(5864), kw_end_DASH_line, int(5864), kw_private, true)).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_str) - tmp6 := checkDerefVar(var_glojure_DOT_core_name) - tmp7 := lang.Apply(tmp6, []any{v4}) - tmp8 := lang.Apply(strings11.ReplaceAll, []any{tmp7, "-", "_"}) - tmp9 := lang.Apply(strings11.ReplaceAll, []any{tmp8, ".", "/"}) - tmp10 := lang.Apply(tmp5, []any{lang.NewChar(47), tmp9}) - return tmp10 - }) - tmp4 := reflect.TypeOf("") - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // rseq - { - tmp0 := sym_rseq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_rev)), kw_doc, "Returns, in constant time, a seq of the items in rev (which\n can be a vector or sorted-map), in reverse order. If rev is empty returns nil", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1577), kw_end_DASH_line, int(1577))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4, _ := lang.FieldOrMethod(v3, "rseq") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("rseq is not a function"))) - } - tmp5 := lang.Apply(tmp4, []any{}) - return tmp5 + return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, "[[Ljava.lang.Object;")).(lang.FnFunc) + var_glojure_DOT_core_to_DASH_array_DASH_2d = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_to_DASH_array_DASH_2d.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // rsubseq + // with-local-vars { - tmp0 := sym_rsubseq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_sc, sym_test, sym_key), lang.NewVector(sym_sc, sym_start_DASH_test, sym_start_DASH_key, sym_end_DASH_test, sym_end_DASH_key)), kw_doc, "sc must be a sorted collection, test(s) one of <, <=, > or\n >=. Returns a reverse seq of those entries with keys ek for\n which (test (.. sc comparator (compare ek key)) 0) is true", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(5150), kw_end_DASH_line, int(5150))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_with_DASH_local_DASH_vars.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name_DASH_vals_DASH_vec, sym__AMP_, sym_body)), kw_doc, "varbinding=> symbol init-expr\n\n Executes the exprs in a context in which the symbols are bound to\n vars with per-thread bindings to the init-exprs. The symbols refer\n to the var objects themselves, and must be accessed with var-get and\n var-set", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(25), kw_column, int(11), kw_line, int(4339), kw_end_DASH_line, int(4339))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 3: - v3 := args[0] + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + v4 := args[2] _ = v4 - v5 := args[2] + var v5 any = lang.NewList(args[3:]...) _ = v5 var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v4}) + if lang.IsTruthy(tmp8) { + } else { + tmp9 := checkDerefVar(var_glojure_DOT_core_str) + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp13 := checkDerefVar(var_glojure_DOT_core_meta) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(kw_line, []any{tmp14}) + tmp16 := lang.Apply(tmp9, []any{tmp11, " requires ", "a vector for its binding", " in ", tmp12, ":", tmp15}) + tmp17 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp16}) + panic(tmp17) + } + _ = tmp6 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_even_QMARK_) + tmp20 := checkDerefVar(var_glojure_DOT_core_count) + tmp21 := lang.Apply(tmp20, []any{v4}) + tmp22 := lang.Apply(tmp19, []any{tmp21}) + if lang.IsTruthy(tmp22) { + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp27 := checkDerefVar(var_glojure_DOT_core_meta) + tmp28 := lang.Apply(tmp27, []any{v2}) + tmp29 := lang.Apply(kw_line, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp25, " requires ", "an even number of forms in binding vector", " in ", tmp26, ":", tmp29}) + tmp31 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp31) + } + _ = tmp18 + tmp32 := checkDerefVar(var_glojure_DOT_core_seq) + tmp33 := checkDerefVar(var_glojure_DOT_core_concat) + tmp34 := checkDerefVar(var_glojure_DOT_core_list) + tmp35 := lang.Apply(tmp34, []any{sym_glojure_DOT_core_SLASH_let}) + tmp36 := checkDerefVar(var_glojure_DOT_core_list) + tmp37 := checkDerefVar(var_glojure_DOT_core_apply) + tmp38 := checkDerefVar(var_glojure_DOT_core_vector) + tmp39 := checkDerefVar(var_glojure_DOT_core_seq) + tmp40 := checkDerefVar(var_glojure_DOT_core_concat) + tmp41 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp42 := checkDerefVar(var_glojure_DOT_core_take_DASH_nth) + tmp43 := lang.Apply(tmp42, []any{int64(2), v4}) + tmp44 := checkDerefVar(var_glojure_DOT_core_repeat) + tmp45 := lang.Apply(tmp44, []any{lang.NewList(sym__DOT__DOT_, sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT__STAR_Var, sym_create, sym_setDynamic)}) + tmp46 := lang.Apply(tmp41, []any{tmp43, tmp45}) + tmp47 := lang.Apply(tmp40, []any{tmp46}) + tmp48 := lang.Apply(tmp39, []any{tmp47}) + tmp49 := lang.Apply(tmp37, []any{tmp38, tmp48}) + tmp50 := lang.Apply(tmp36, []any{tmp49}) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := checkDerefVar(var_glojure_DOT_core_seq) + tmp53 := checkDerefVar(var_glojure_DOT_core_concat) + tmp54 := checkDerefVar(var_glojure_DOT_core_list) + tmp55 := lang.Apply(tmp54, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_PushThreadBindings}) + tmp56 := checkDerefVar(var_glojure_DOT_core_list) + tmp57 := checkDerefVar(var_glojure_DOT_core_apply) + tmp58 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp59 := checkDerefVar(var_glojure_DOT_core_seq) + tmp60 := checkDerefVar(var_glojure_DOT_core_concat) + tmp61 := lang.Apply(tmp60, nil) + tmp62 := lang.Apply(tmp59, []any{tmp61}) + tmp63 := lang.Apply(tmp57, []any{tmp58, tmp62}) + tmp64 := lang.Apply(tmp56, []any{tmp63}) + tmp65 := lang.Apply(tmp53, []any{tmp55, tmp64}) + tmp66 := lang.Apply(tmp52, []any{tmp65}) + tmp67 := lang.Apply(tmp51, []any{tmp66}) + tmp68 := checkDerefVar(var_glojure_DOT_core_list) + tmp69 := checkDerefVar(var_glojure_DOT_core_seq) + tmp70 := checkDerefVar(var_glojure_DOT_core_concat) + tmp71 := checkDerefVar(var_glojure_DOT_core_list) + tmp72 := lang.Apply(tmp71, []any{sym_try}) + tmp73 := checkDerefVar(var_glojure_DOT_core_list) + tmp74 := checkDerefVar(var_glojure_DOT_core_seq) + tmp75 := checkDerefVar(var_glojure_DOT_core_concat) + tmp76 := checkDerefVar(var_glojure_DOT_core_list) + tmp77 := lang.Apply(tmp76, []any{sym_finally}) + tmp78 := checkDerefVar(var_glojure_DOT_core_list) + tmp79 := checkDerefVar(var_glojure_DOT_core_seq) + tmp80 := checkDerefVar(var_glojure_DOT_core_concat) + tmp81 := checkDerefVar(var_glojure_DOT_core_list) + tmp82 := lang.Apply(tmp81, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_PopThreadBindings}) + tmp83 := lang.Apply(tmp80, []any{tmp82}) + tmp84 := lang.Apply(tmp79, []any{tmp83}) + tmp85 := lang.Apply(tmp78, []any{tmp84}) + tmp86 := lang.Apply(tmp75, []any{tmp77, tmp85}) + tmp87 := lang.Apply(tmp74, []any{tmp86}) + tmp88 := lang.Apply(tmp73, []any{tmp87}) + tmp89 := lang.Apply(tmp70, []any{tmp72, v5, tmp88}) + tmp90 := lang.Apply(tmp69, []any{tmp89}) + tmp91 := lang.Apply(tmp68, []any{tmp90}) + tmp92 := lang.Apply(tmp33, []any{tmp35, tmp50, tmp67, tmp91}) + tmp93 := lang.Apply(tmp32, []any{tmp92}) + return tmp93 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_with_DASH_local_DASH_vars = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_with_DASH_local_DASH_vars.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // Throwable->map + { + tmp0 := sym_Throwable_DASH__GT_map.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_o)), kw_doc, "Constructs a data representation for a Throwable with keys:\n :cause - root cause message\n :phase - error phase\n :via - cause chain, with cause keys:\n :type - exception class symbol\n :message - exception message\n :data - ex-data\n :at - top stack element\n :trace - root cause stack elements", kw_file, "glojure/core_print.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(442), kw_end_DASH_line, int(442))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "base" + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v5 := args[0] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_merge) + tmp7 := checkDerefVar(var_glojure_DOT_core_symbol) + tmp8 := checkDerefVar(var_glojure_DOT_core_class) + tmp9 := lang.Apply(tmp8, []any{v5}) + tmp10, ok := lang.FieldOrMethod(tmp9, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp9, "Name"))) + } + var tmp11 any + switch reflect.TypeOf(tmp10).Kind() { + case reflect.Func: + tmp11 = lang.Apply(tmp10, nil) + default: + tmp11 = tmp10 + } + tmp12 := lang.Apply(tmp7, []any{tmp11}) + tmp13 := lang.NewMap(kw_type, tmp12) + tmp14 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(455), kw_column, int(23), kw_end_DASH_line, int(455), kw_end_DASH_column, int(56)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var tmp16 any + { // let + // let binding "temp__0__auto__" + tmp17, ok := lang.FieldOrMethod(v5, "getLocalizedMessage") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "getLocalizedMessage"))) + } + var tmp18 any + switch reflect.TypeOf(tmp17).Kind() { + case reflect.Func: + tmp18 = lang.Apply(tmp17, nil) + default: + tmp18 = tmp17 + } + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + var tmp21 any + { // let + // let binding "msg" + var v22 any = v19 + _ = v22 + tmp23 := lang.NewMap(kw_message, v22) + tmp24 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(457), kw_column, int(20), kw_end_DASH_line, int(457), kw_end_DASH_column, int(33)) + tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp21 = tmp25 + } // end let + tmp20 = tmp21 + } else { + } + tmp16 = tmp20 + } // end let + var tmp17 any + { // let + // let binding "temp__0__auto__" + tmp18 := checkDerefVar(var_glojure_DOT_core_ex_DASH_data) + tmp19 := lang.Apply(tmp18, []any{v5}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + var tmp22 any + { // let + // let binding "ed" + var v23 any = v20 + _ = v23 + tmp24 := lang.NewMap(kw_data, v23) + tmp25 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(459), kw_column, int(20), kw_end_DASH_line, int(459), kw_end_DASH_column, int(29)) + tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp22 = tmp26 + } // end let + tmp21 = tmp22 + } else { + } + tmp17 = tmp21 + } // end let + var tmp18 any + { // let + // let binding "st" + tmp19, ok := lang.FieldOrMethod(v5, "getStackTrace") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "getStackTrace"))) + } + var tmp20 any + switch reflect.TypeOf(tmp19).Kind() { + case reflect.Func: + tmp20 = lang.Apply(tmp19, nil) + default: + tmp20 = tmp19 + } + var v21 any = tmp20 + _ = v21 + var tmp22 any + tmp23 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp24 := checkDerefVar(var_glojure_DOT_core_alength) + tmp25 := lang.Apply(tmp24, []any{v21}) + tmp26 := lang.Apply(tmp23, []any{tmp25}) + if lang.IsTruthy(tmp26) { + tmp27 := checkDerefVar(var_glojure_DOT_core_StackTraceElement_DASH__GT_vec) + tmp28 := checkDerefVar(var_glojure_DOT_core_aget) + tmp29 := lang.Apply(tmp28, []any{v21, int64(0)}) + tmp30 := lang.Apply(tmp27, []any{tmp29}) + tmp31 := lang.NewMap(kw_at, tmp30) + tmp32 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(462), kw_column, int(22), kw_end_DASH_line, int(462), kw_end_DASH_column, int(63)) + tmp33, err := lang.WithMeta(tmp31, tmp32.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp22 = tmp33 + } else { + } + tmp18 = tmp22 + } // end let + tmp19 := lang.Apply(tmp6, []any{tmp15, tmp16, tmp17, tmp18}) + return tmp19 + }) + tmp5 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(454), kw_column, int(14), kw_end_DASH_line, int(462), kw_end_DASH_column, int(67)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v7 any = tmp6 + _ = v7 + // let binding "via" + var tmp8 any { // let - // let binding "include" - tmp7 := checkDerefVar(var_glojure_DOT_core_mk_DASH_bound_DASH_fn) - tmp8 := lang.Apply(tmp7, []any{v3, v4, v5}) - var v9 any = tmp8 - _ = v9 - var tmp10 any - tmp11 := checkDerefVar(var_glojure_DOT_core__LT_) - tmp12 := checkDerefVar(var_glojure_DOT_core__LT__EQ_) - tmp13 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{tmp11, tmp12})) - tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5158), kw_column, int(11), kw_end_DASH_line, int(5158), kw_end_DASH_column, int(17)) - tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + // let binding "via" + tmp9 := lang.NewVector() + tmp10 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(463), kw_column, int(24), kw_end_DASH_line, int(463), kw_end_DASH_column, int(25)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp16 := lang.Apply(tmp15, []any{v4}) - if lang.IsTruthy(tmp16) { - var tmp17 any - { // let - // let binding "temp__0__auto__" - tmp18, _ := lang.FieldOrMethod(v3, "seqFrom") - if reflect.TypeOf(tmp18).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("seqFrom is not a function"))) + var v12 any = tmp11 + _ = v12 + // let binding "t" + var v13 any = v2 + _ = v13 + for { + var tmp14 any + if lang.IsTruthy(v13) { + tmp16 := checkDerefVar(var_glojure_DOT_core_conj) + tmp17 := lang.Apply(tmp16, []any{v12, v13}) + var tmp15 any = tmp17 + tmp19, ok := lang.FieldOrMethod(v13, "getCause") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v13, "getCause"))) } - tmp19 := lang.Apply(tmp18, []any{v5, false}) - var v20 any = tmp19 - _ = v20 - var tmp21 any - if lang.IsTruthy(v20) { - var tmp22 any - { // let - // let binding "vec__74" - var v23 any = v20 - _ = v23 - // let binding "e" - tmp24 := checkDerefVar(var_glojure_DOT_core_nth) - tmp25 := lang.Apply(tmp24, []any{v23, int64(0), nil}) - var v26 any = tmp25 - _ = v26 - // let binding "s" - var v27 any = v23 - _ = v27 - var tmp28 any - tmp29 := lang.Apply(v9, []any{v26}) - if lang.IsTruthy(tmp29) { - tmp28 = v27 - } else { - tmp30 := checkDerefVar(var_glojure_DOT_core_next) - tmp31 := lang.Apply(tmp30, []any{v27}) - tmp28 = tmp31 - } - tmp22 = tmp28 - } // end let - tmp21 = tmp22 - } else { + var tmp20 any + switch reflect.TypeOf(tmp19).Kind() { + case reflect.Func: + tmp20 = lang.Apply(tmp19, nil) + default: + tmp20 = tmp19 } - tmp17 = tmp21 - } // end let - tmp10 = tmp17 - } else { - tmp18 := checkDerefVar(var_glojure_DOT_core_take_DASH_while) - tmp19, _ := lang.FieldOrMethod(v3, "seq") - if reflect.TypeOf(tmp19).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("seq is not a function"))) + var tmp18 any = tmp20 + v12 = tmp15 + v13 = tmp18 + continue + } else { + tmp14 = v12 } - tmp20 := lang.Apply(tmp19, []any{false}) - tmp21 := lang.Apply(tmp18, []any{v9, tmp20}) - tmp10 = tmp21 + tmp8 = tmp14 + break } - tmp6 = tmp10 } // end let - return tmp6 - case 5: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - v7 := args[4] - _ = v7 - var tmp8 any + var v9 any = tmp8 + _ = v9 + // let binding "root" + tmp10 := checkDerefVar(var_glojure_DOT_core_peek) + tmp11 := lang.Apply(tmp10, []any{v9}) + var v12 any = tmp11 + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_merge) + tmp14 := checkDerefVar(var_glojure_DOT_core_vec) + tmp15 := checkDerefVar(var_glojure_DOT_core_map) + tmp16 := lang.Apply(tmp15, []any{v7, v9}) + tmp17 := lang.Apply(tmp14, []any{tmp16}) + tmp18 := checkDerefVar(var_glojure_DOT_core_vec) + tmp19 := checkDerefVar(var_glojure_DOT_core_map) + tmp20 := checkDerefVar(var_glojure_DOT_core_StackTraceElement_DASH__GT_vec) + var tmp21 any + { // let + // let binding "or__0__auto__" + var v22 any = v12 + _ = v22 + var tmp23 any + if lang.IsTruthy(v22) { + tmp23 = v22 + } else { + tmp23 = v2 + } + tmp21 = tmp23 + } // end let + tmp22, ok := lang.FieldOrMethod(tmp21, "getStackTrace") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp21, "getStackTrace"))) + } + var tmp23 any + switch reflect.TypeOf(tmp22).Kind() { + case reflect.Func: + tmp23 = lang.Apply(tmp22, nil) + default: + tmp23 = tmp22 + } + tmp24 := lang.Apply(tmp19, []any{tmp20, tmp23}) + tmp25 := lang.Apply(tmp18, []any{tmp24}) + tmp26 := lang.NewMap(kw_via, tmp17, kw_trace, tmp25) + tmp27 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(468), kw_column, int(12), kw_end_DASH_line, int(470), kw_end_DASH_column, int(111)) + tmp28, err := lang.WithMeta(tmp26, tmp27.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var tmp29 any { // let // let binding "temp__0__auto__" - tmp9, _ := lang.FieldOrMethod(v3, "seqFrom") - if reflect.TypeOf(tmp9).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("seqFrom is not a function"))) + tmp30, ok := lang.FieldOrMethod(v12, "getLocalizedMessage") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v12, "getLocalizedMessage"))) } - tmp10 := lang.Apply(tmp9, []any{v7, false}) - var v11 any = tmp10 - _ = v11 - var tmp12 any - if lang.IsTruthy(v11) { - var tmp13 any + var tmp31 any + switch reflect.TypeOf(tmp30).Kind() { + case reflect.Func: + tmp31 = lang.Apply(tmp30, nil) + default: + tmp31 = tmp30 + } + var v32 any = tmp31 + _ = v32 + var tmp33 any + if lang.IsTruthy(v32) { + var tmp34 any { // let - // let binding "vec__77" - var v14 any = v11 - _ = v14 - // let binding "e" - tmp15 := checkDerefVar(var_glojure_DOT_core_nth) - tmp16 := lang.Apply(tmp15, []any{v14, int64(0), nil}) - var v17 any = tmp16 - _ = v17 - // let binding "s" - var v18 any = v14 - _ = v18 - tmp19 := checkDerefVar(var_glojure_DOT_core_take_DASH_while) - tmp20 := checkDerefVar(var_glojure_DOT_core_mk_DASH_bound_DASH_fn) - tmp21 := lang.Apply(tmp20, []any{v3, v4, v5}) - var tmp22 any - tmp23 := checkDerefVar(var_glojure_DOT_core_mk_DASH_bound_DASH_fn) - tmp24 := lang.Apply(tmp23, []any{v3, v6, v7}) - tmp25 := lang.Apply(tmp24, []any{v17}) - if lang.IsTruthy(tmp25) { - tmp22 = v18 - } else { - tmp26 := checkDerefVar(var_glojure_DOT_core_next) - tmp27 := lang.Apply(tmp26, []any{v18}) - tmp22 = tmp27 + // let binding "root-msg" + var v35 any = v32 + _ = v35 + tmp36 := lang.NewMap(kw_cause, v35) + tmp37 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(472), kw_column, int(9), kw_end_DASH_line, int(472), kw_end_DASH_column, int(25)) + tmp38, err := lang.WithMeta(tmp36, tmp37.(lang.IPersistentMap)) + if err != nil { + panic(err) } - tmp28 := lang.Apply(tmp19, []any{tmp21, tmp22}) - tmp13 = tmp28 + tmp34 = tmp38 } // end let - tmp12 = tmp13 + tmp33 = tmp34 } else { } - tmp8 = tmp12 + tmp29 = tmp33 } // end let - return tmp8 - default: - checkArity(args, -1) - panic("unreachable") - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // run! - { - tmp0 := sym_run_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_proc, sym_coll)), kw_doc, "Runs the supplied procedure (via reduce), for purposes of side\n effects, on successive items in the collection. Returns nil", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(7708), kw_end_DASH_line, int(7708))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_reduce) - var tmp6 lang.FnFunc - tmp6 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v7 := args[0] - _ = v7 - v8 := args[1] - _ = v8 - tmp9 := lang.Apply(v3, []any{v8}) - return tmp9 - }) - tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7713), kw_column, int(11), kw_end_DASH_line, int(7713), kw_end_DASH_column, int(20)) - tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp9 := lang.Apply(tmp5, []any{tmp8, nil, v4}) - _ = tmp9 - return nil - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // second - { - tmp0 := sym_second.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Same as (first (next x))", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(2), kw_line, int(91), kw_end_DASH_line, int(95))).(*lang.Symbol) - var tmp2 lang.FnFunc - { // function second - var v3 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_first) - tmp6 := checkDerefVar(var_glojure_DOT_core_next) - tmp7 := lang.Apply(tmp6, []any{v4}) - tmp8 := lang.Apply(tmp5, []any{tmp7}) - return tmp8 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(95), kw_column, int(9), kw_end_DASH_line, int(95), kw_end_DASH_column, int(49))).(lang.FnFunc) - v3 = tmp2 - _ = v3 - } - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // select-keys - { - tmp0 := sym_select_DASH_keys.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_map, sym_keyseq)), kw_doc, "Returns a map containing only those entries in map whose key is in keys", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(1536), kw_end_DASH_line, int(1536))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - { // let - // let binding "ret" - tmp6 := lang.NewMap() - tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(1541), kw_column, int(16), kw_end_DASH_line, int(1541), kw_end_DASH_column, int(17)) - tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v9 any = tmp8 - _ = v9 - // let binding "keys" - tmp10 := checkDerefVar(var_glojure_DOT_core_seq) - tmp11 := lang.Apply(tmp10, []any{v4}) - var v12 any = tmp11 - _ = v12 - for { - var tmp13 any - if lang.IsTruthy(v12) { - var tmp14 any + var tmp30 any + { // let + // let binding "temp__0__auto__" + tmp31 := checkDerefVar(var_glojure_DOT_core_ex_DASH_data) + tmp32 := lang.Apply(tmp31, []any{v12}) + var v33 any = tmp32 + _ = v33 + var tmp34 any + if lang.IsTruthy(v33) { + var tmp35 any { // let - // let binding "entry" - tmp15 := checkDerefVar(var_glojure_DOT_core_first) - tmp16 := lang.Apply(tmp15, []any{v12}) - tmp17, _ := lang.FieldOrMethod(runtime.RT, "Find") - if reflect.TypeOf(tmp17).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Find is not a function"))) + // let binding "data" + var v36 any = v33 + _ = v36 + tmp37 := lang.NewMap(kw_data, v36) + tmp38 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(474), kw_column, int(9), kw_end_DASH_line, int(474), kw_end_DASH_column, int(20)) + tmp39, err := lang.WithMeta(tmp37, tmp38.(lang.IPersistentMap)) + if err != nil { + panic(err) } - tmp18 := lang.Apply(tmp17, []any{v3, tmp16}) - var v19 any = tmp18 - _ = v19 - var tmp21 any - if lang.IsTruthy(v19) { - tmp22 := checkDerefVar(var_glojure_DOT_core_conj) - tmp23 := lang.Apply(tmp22, []any{v9, v19}) - tmp21 = tmp23 - } else { - tmp21 = v9 + tmp35 = tmp39 + } // end let + tmp34 = tmp35 + } else { + } + tmp30 = tmp34 + } // end let + var tmp31 any + { // let + // let binding "temp__0__auto__" + tmp32 := checkDerefVar(var_glojure_DOT_core_ex_DASH_data) + tmp33 := lang.Apply(tmp32, []any{v2}) + tmp34 := lang.Apply(kw_glojure_DOT_error_SLASH_phase, []any{tmp33}) + var v35 any = tmp34 + _ = v35 + var tmp36 any + if lang.IsTruthy(v35) { + var tmp37 any + { // let + // let binding "phase" + var v38 any = v35 + _ = v38 + tmp39 := lang.NewMap(kw_phase, v38) + tmp40 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(476), kw_column, int(9), kw_end_DASH_line, int(476), kw_end_DASH_column, int(22)) + tmp41, err := lang.WithMeta(tmp39, tmp40.(lang.IPersistentMap)) + if err != nil { + panic(err) } - var tmp20 any = tmp21 - tmp25 := checkDerefVar(var_glojure_DOT_core_next) - tmp26 := lang.Apply(tmp25, []any{v12}) - var tmp24 any = tmp26 - v9 = tmp20 - v12 = tmp24 - continue + tmp37 = tmp41 } // end let - tmp13 = tmp14 + tmp36 = tmp37 } else { - tmp15 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) - tmp16 := checkDerefVar(var_glojure_DOT_core_meta) - tmp17 := lang.Apply(tmp16, []any{v3}) - tmp18 := lang.Apply(tmp15, []any{v9, tmp17}) - tmp13 = tmp18 } - tmp5 = tmp13 - break - } + tmp31 = tmp36 + } // end let + tmp32 := lang.Apply(tmp13, []any{tmp28, tmp29, tmp30, tmp31}) + tmp3 = tmp32 } // end let - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // send - { - tmp0 := sym_send.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a, sym_f, sym__AMP_, sym_args)), kw_doc, "Dispatch an action to an agent. Returns the agent immediately.\n Subsequently, in a thread from a thread pool, the state of the agent\n will be set to the value of:\n\n (apply action-fn state-of-agent args)", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(2109), kw_end_DASH_line, int(2109))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - tmp6 := checkDerefVar(var_glojure_DOT_core_apply) - tmp7 := checkDerefVar(var_glojure_DOT_core_send_DASH_via) - tmp8 := lang.Apply(tmp6, []any{tmp7, nil, v3, v4, v5}) - return tmp8 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // send-off - { - tmp0 := sym_send_DASH_off.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a, sym_f, sym__AMP_, sym_args)), kw_doc, "Dispatch a potentially blocking action to an agent. Returns the\n agent immediately. Subsequently, in a separate thread, the state of\n the agent will be set to the value of:\n\n (apply action-fn state-of-agent args)", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(2120), kw_end_DASH_line, int(2120))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - tmp6 := checkDerefVar(var_glojure_DOT_core_apply) - tmp7 := checkDerefVar(var_glojure_DOT_core_send_DASH_via) - tmp8 := lang.Apply(tmp6, []any{tmp7, nil, v3, v4, v5}) - return tmp8 - } + return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_Throwable_DASH__GT_map = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_Throwable_DASH__GT_map.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // send-via + // as-> { - tmp0 := sym_send_DASH_via.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_executor, sym_a, sym_f, sym__AMP_, sym_args)), kw_doc, "Dispatch an action to an agent. Returns the agent immediately.\n Subsequently, in a thread supplied by executor, the state of the agent\n will be set to the value of:\n\n (apply action-fn state-of-agent args)", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(2099), kw_end_DASH_line, int(2099))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_as_DASH__GT_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_expr, sym_name, sym__AMP_, sym_forms)), kw_doc, "Binds name to expr, evaluates the first form in the lexical context\n of that binding, then binds name to that result, repeating for each\n successive form, returning the result of the last form.", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(11), kw_line, int(7598), kw_end_DASH_line, int(7598))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) - v3 := args[0] + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + v4 := args[2] _ = v4 - v5 := args[2] + v5 := args[3] _ = v5 - var v6 any = lang.NewList(args[3:]...) + var v6 any = lang.NewList(args[4:]...) _ = v6 - var tmp7 any - { // let - tmp8 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) - tmp9 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) - tmp10 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_agent_STAR_) - tmp11 := lang.Apply(tmp9, []any{tmp10, v4}) - tmp12 := lang.Apply(tmp8, []any{tmp11}) - _ = tmp12 - var tmp13 any - func() { - defer func() { - tmp14 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) - tmp15 := lang.Apply(tmp14, nil) - _ = tmp15 - }() - tmp16 := checkDerefVar(var_glojure_DOT_core_binding_DASH_conveyor_DASH_fn) - tmp17 := lang.Apply(tmp16, []any{v5}) - tmp13 = tmp17 - }() - tmp7 = tmp13 - } // end let - tmp8, _ := lang.FieldOrMethod(v4, "dispatch") - if reflect.TypeOf(tmp8).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("dispatch is not a function"))) + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_core_SLASH_let}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_apply) + tmp13 := checkDerefVar(var_glojure_DOT_core_vector) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v5}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp21 := checkDerefVar(var_glojure_DOT_core_repeat) + tmp22 := lang.Apply(tmp21, []any{v5}) + tmp23 := checkDerefVar(var_glojure_DOT_core_butlast) + tmp24 := lang.Apply(tmp23, []any{v6}) + tmp25 := lang.Apply(tmp20, []any{tmp22, tmp24}) + tmp26 := lang.Apply(tmp15, []any{tmp17, tmp19, tmp25}) + tmp27 := lang.Apply(tmp14, []any{tmp26}) + tmp28 := lang.Apply(tmp12, []any{tmp13, tmp27}) + tmp29 := lang.Apply(tmp11, []any{tmp28}) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + var tmp31 any + tmp32 := checkDerefVar(var_glojure_DOT_core_empty_QMARK_) + tmp33 := lang.Apply(tmp32, []any{v6}) + if lang.IsTruthy(tmp33) { + tmp31 = v5 + } else { + tmp34 := checkDerefVar(var_glojure_DOT_core_last) + tmp35 := lang.Apply(tmp34, []any{v6}) + tmp31 = tmp35 } - tmp9 := lang.Apply(tmp8, []any{tmp7, v6, v3}) - return tmp9 + tmp36 := lang.Apply(tmp30, []any{tmp31}) + tmp37 := lang.Apply(tmp8, []any{tmp10, tmp29, tmp36}) + tmp38 := lang.Apply(tmp7, []any{tmp37}) + return tmp38 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // seq - { - tmp1 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() - tmp0 := sym_seq.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a seq on the collection. If the collection is\n empty, returns nil. (seq nil) returns nil. seq also works on\n Strings, native Java arrays (of reference types) and any objects\n that implement Iterable. Note that seqs cache values, thus seq\n should not be used on any Iterable whose iterator repeatedly\n returns the same mutable object.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(4), kw_column, int(2), kw_line, int(126), kw_end_DASH_line, int(136))).(*lang.Symbol) - var tmp3 lang.FnFunc - { // function seq - var v4 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v5 := args[0] - _ = v5 - tmp6 := lang.Apply(lang.Seq, []any{v5}) - return tmp6 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(136), kw_column, int(6), kw_end_DASH_line, int(136), kw_end_DASH_column, int(126))).(lang.FnFunc) - v4 = tmp3 - _ = v4 - } - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_as_DASH__GT_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_as_DASH__GT_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // seq-to-map-for-destructuring + // await { - tmp0 := sym_seq_DASH_to_DASH_map_DASH_for_DASH_destructuring.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_doc, "Builds a map from a seq as described in\n https://glojure.org/reference/special_forms#keyword-arguments", kw_file, "glojure/core.glj", kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(34), kw_column, int(7), kw_line, int(4390), kw_end_DASH_line, int(4390))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := checkDerefVar(var_glojure_DOT_core_next) - tmp6 := lang.Apply(tmp5, []any{v3}) - if lang.IsTruthy(tmp6) { - tmp7 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) - tmp8 := lang.Apply(tmp7, []any{v3}) - tmp9 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{tmp8}) - tmp4 = tmp9 - } else { - var tmp10 any - tmp11 := checkDerefVar(var_glojure_DOT_core_seq) - tmp12 := lang.Apply(tmp11, []any{v3}) - if lang.IsTruthy(tmp12) { - tmp13 := checkDerefVar(var_glojure_DOT_core_first) - tmp14 := lang.Apply(tmp13, []any{v3}) - tmp10 = tmp14 + tmp0 := sym_await.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_agents)), kw_doc, "Blocks the current thread (indefinitely!) until all actions\n dispatched thus far, from this thread or agent, to the agent(s) have\n occurred. Will block on failed agents. Will never return if\n a failed agent is restarted with :clear-actions true or shutdown-agents was called.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3267), kw_end_DASH_line, int(3267))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + var tmp3 any + tmp4 := lang.Apply(nil, nil) + if lang.IsTruthy(tmp4) { + panic("unimplemented: new with non-constant class type") } else { + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_agent_STAR_) + if lang.IsTruthy(tmp6) { + tmp7 := lang.Apply(errors8.New, []any{"Can't await in agent action"}) + panic(tmp7) + } else { + } + _ = tmp5 + var tmp8 any + { // let + // let binding "latch" + var v9 any = "unimplemented: new with non-constant class type" + _ = v9 + // let binding "count-down" + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v11 := args[0] + _ = v11 + tmp12, _ := lang.FieldOrMethod(v9, "countDown") + if reflect.TypeOf(tmp12).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("countDown is not a function"))) + } + tmp13 := lang.Apply(tmp12, []any{}) + _ = tmp13 + return v11 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3279), kw_column, int(22), kw_end_DASH_line, int(3279), kw_end_DASH_column, int(61)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v13 any = tmp12 + _ = v13 + var tmp14 any + { // let + // let binding "seq_1" + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := lang.Apply(tmp15, []any{v2}) + var v17 any = tmp16 + _ = v17 + // let binding "chunk_2" + var v18 any = nil + _ = v18 + // let binding "count_3" + var v19 any = int64(0) + _ = v19 + // let binding "i_4" + var v20 any = int64(0) + _ = v20 + for { + var tmp21 any + tmp22 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp23 := lang.Apply(tmp22, []any{v20, v19}) + if lang.IsTruthy(tmp23) { + var tmp24 any + { // let + // let binding "agent" + tmp25, _ := lang.FieldOrMethod(v18, "nth") + if reflect.TypeOf(tmp25).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp26 := lang.Apply(tmp25, []any{v20}) + var v27 any = tmp26 + _ = v27 + tmp28 := checkDerefVar(var_glojure_DOT_core_send) + tmp29 := lang.Apply(tmp28, []any{v27, v13}) + _ = tmp29 + var tmp30 any = v17 + var tmp31 any = v18 + var tmp32 any = v19 + tmp34 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp35 := lang.Apply(tmp34, []any{v20}) + var tmp33 any = tmp35 + v17 = tmp30 + v18 = tmp31 + v19 = tmp32 + v20 = tmp33 + continue + } // end let + tmp21 = tmp24 + } else { + var tmp25 any + { // let + // let binding "temp__0__auto__" + tmp26 := checkDerefVar(var_glojure_DOT_core_seq) + tmp27 := lang.Apply(tmp26, []any{v17}) + var v28 any = tmp27 + _ = v28 + var tmp29 any + if lang.IsTruthy(v28) { + var tmp30 any + { // let + // let binding "seq_1" + var v31 any = v28 + _ = v31 + var tmp32 any + tmp33 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp34 := lang.Apply(tmp33, []any{v31}) + if lang.IsTruthy(tmp34) { + var tmp35 any + { // let + // let binding "c__0__auto__" + tmp36 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp37 := lang.Apply(tmp36, []any{v31}) + var v38 any = tmp37 + _ = v38 + tmp40 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp41 := lang.Apply(tmp40, []any{v31}) + var tmp39 any = tmp41 + var tmp42 any = v38 + tmp44 := checkDerefVar(var_glojure_DOT_core_int) + tmp45 := checkDerefVar(var_glojure_DOT_core_count) + tmp46 := lang.Apply(tmp45, []any{v38}) + tmp47 := lang.Apply(tmp44, []any{tmp46}) + var tmp43 any = tmp47 + tmp49 := checkDerefVar(var_glojure_DOT_core_int) + tmp50 := lang.Apply(tmp49, []any{int64(0)}) + var tmp48 any = tmp50 + v17 = tmp39 + v18 = tmp42 + v19 = tmp43 + v20 = tmp48 + continue + } // end let + tmp32 = tmp35 + } else { + var tmp36 any + { // let + // let binding "agent" + tmp37 := checkDerefVar(var_glojure_DOT_core_first) + tmp38 := lang.Apply(tmp37, []any{v31}) + var v39 any = tmp38 + _ = v39 + tmp40 := checkDerefVar(var_glojure_DOT_core_send) + tmp41 := lang.Apply(tmp40, []any{v39, v13}) + _ = tmp41 + tmp43 := checkDerefVar(var_glojure_DOT_core_next) + tmp44 := lang.Apply(tmp43, []any{v31}) + var tmp42 any = tmp44 + var tmp45 any = nil + var tmp46 any = int64(0) + var tmp47 any = int64(0) + v17 = tmp42 + v18 = tmp45 + v19 = tmp46 + v20 = tmp47 + continue + } // end let + tmp32 = tmp36 + } + tmp30 = tmp32 + } // end let + tmp29 = tmp30 + } else { + } + tmp25 = tmp29 + } // end let + tmp21 = tmp25 + } + tmp14 = tmp21 + break + } + } // end let + _ = tmp14 + tmp15, _ := lang.FieldOrMethod(v9, "await") + if reflect.TypeOf(tmp15).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) + } + tmp16 := lang.Apply(tmp15, []any{}) + tmp8 = tmp16 + } // end let + tmp3 = tmp8 } - tmp4 = tmp10 + return tmp3 } - return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // seq? - { - tmp0 := sym_seq_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x implements ISeq", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(5), kw_column, int(2), kw_line, int(146), kw_end_DASH_line, int(150))).(*lang.Symbol) - var tmp2 lang.FnFunc - { // function seq? - var v3 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp6 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() - tmp7 := lang.Apply(tmp5, []any{tmp6, v4}) - return tmp7 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(150), kw_column, int(7), kw_end_DASH_line, int(150), kw_end_DASH_column, int(87))).(lang.FnFunc) - v3 = tmp2 - _ = v3 - } - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_await = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_await.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // seqable? + // await1 { - tmp0 := sym_seqable_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if the seq function is supported for x", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(6204), kw_end_DASH_line, int(6204))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_await1.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(3284), kw_column, int(7), kw_end_DASH_line, int(3284), kw_end_DASH_column, int(21), kw_arglists, lang.NewList(lang.NewVector(sym_a)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := lang.Apply(nil, []any{v3}) - return tmp4 + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp5, ok := lang.FieldOrMethod(v2, "getQueueCount") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getQueueCount"))) + } + var tmp6 any + switch reflect.TypeOf(tmp5).Kind() { + case reflect.Func: + tmp6 = lang.Apply(tmp5, nil) + default: + tmp6 = tmp5 + } + tmp7 := lang.Apply(tmp4, []any{tmp6}) + if lang.IsTruthy(tmp7) { + tmp8 := checkDerefVar(var_glojure_DOT_core_await) + tmp9 := lang.Apply(tmp8, []any{v2}) + tmp3 = tmp9 + } else { + } + _ = tmp3 + return v2 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_await1 = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_await1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // seque + // await-for { - tmp0 := sym_seque.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s), lang.NewVector(sym_n_DASH_or_DASH_q, sym_s)), kw_doc, "Creates a queued seq on another (presumably lazy) seq s. The queued\n seq will produce a concrete seq in the background, and can get up to\n n items ahead of the consumer. n-or-q can be an integer n buffer\n size, or an instance of java.util.concurrent BlockingQueue. Note\n that reading from a seque can block if the reader gets ahead of the\n producer.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(5419), kw_end_DASH_line, int(5419))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_await_DASH_for.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_timeout_DASH_ms, sym__AMP_, sym_agents)), kw_doc, "Blocks the current thread until all actions dispatched thus\n far (from this thread or agent) to the agents have occurred, or the\n timeout (in milliseconds) has elapsed. Returns logical false if\n returning due to timeout, logical true otherwise.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(3289), kw_end_DASH_line, int(3289))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 1: - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_seque) - tmp5 := lang.Apply(tmp4, []any{int64(100), v3}) - return tmp5 - case 2: - v3 := args[0] + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - { // let - // let binding "q" + var tmp4 any + tmp5 := lang.Apply(nil, nil) + if lang.IsTruthy(tmp5) { + panic("unimplemented: new with non-constant class type") + } else { var tmp6 any - tmp7 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp8 := lang.Apply(tmp7, []any{nil, v3}) - if lang.IsTruthy(tmp8) { - tmp6 = v3 + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_agent_STAR_) + if lang.IsTruthy(tmp7) { + tmp8 := lang.Apply(errors8.New, []any{"Can't await in agent action"}) + panic(tmp8) } else { - tmp9 := checkDerefVar(var_glojure_DOT_core_int) - tmp10 := lang.Apply(tmp9, []any{v3}) - tmp11 := lang.Apply(nil, []any{tmp10}) - tmp6 = tmp11 - } - var v12 any = tmp6 - _ = v12 - // let binding "NIL" - tmp13 := lang.Apply(reflect.StructOf, []any{nil}) - tmp14 := lang.Apply(reflect.New, []any{tmp13}) - tmp15, ok := lang.FieldOrMethod(tmp14, "Interface") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp14, "Interface"))) - } - var tmp16 any - switch reflect.TypeOf(tmp15).Kind() { - case reflect.Func: - tmp16 = lang.Apply(tmp15, nil) - default: - tmp16 = tmp15 } - var v17 any = tmp16 - _ = v17 - // let binding "agt" - tmp18 := checkDerefVar(var_glojure_DOT_core_agent) - var tmp19 lang.FnFunc - tmp19 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - return v4 - }) - tmp20 := lang.Apply(lang.NewLazySeq, []any{tmp19}) - tmp21 := lang.Apply(tmp18, []any{tmp20}) - var v22 any = tmp21 - _ = v22 - // let binding "log-error" - var tmp23 lang.FnFunc - tmp23 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v24 := args[0] - _ = v24 - v25 := args[1] - _ = v25 - var tmp26 any - tmp27, _ := lang.FieldOrMethod(v24, "offer") - if reflect.TypeOf(tmp27).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("offer is not a function"))) - } - tmp28 := lang.Apply(tmp27, []any{v24}) - if lang.IsTruthy(tmp28) { - panic(v25) - } else { - tmp26 = v25 + _ = tmp6 + var tmp9 any + { // let + // let binding "latch" + var v10 any = "unimplemented: new with non-constant class type" + _ = v10 + // let binding "count-down" + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v12 := args[0] + _ = v12 + tmp13, _ := lang.FieldOrMethod(v10, "countDown") + if reflect.TypeOf(tmp13).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("countDown is not a function"))) + } + tmp14 := lang.Apply(tmp13, []any{}) + _ = tmp14 + return v12 + }) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3301), kw_column, int(23), kw_end_DASH_line, int(3301), kw_end_DASH_column, int(62)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) } - return tmp26 - }) - tmp24 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5435), kw_column, int(20), kw_end_DASH_line, int(5438), kw_end_DASH_column, int(26)) - tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v26 any = tmp25 - _ = v26 - // let binding "fill" - var tmp27 lang.FnFunc - tmp27 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v28 := args[0] - _ = v28 - var tmp29 any - if lang.IsTruthy(v28) { - var tmp30 any - tmp31 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp32 := lang.Apply(tmp31, []any{nil, v28}) - if lang.IsTruthy(tmp32) { - tmp33 := lang.Apply(v26, []any{v12, v28}) - tmp30 = tmp33 - } else { - var tmp34 any - func() { - defer func() { - if r := recover(); r != nil { - if lang.CatchMatches(r, lang.Builtins["any"]) { - v35 := r - _ = v35 - tmp36 := lang.Apply(v26, []any{v12, v35}) - tmp34 = tmp36 - } else { - panic(r) - } + var v14 any = tmp13 + _ = v14 + var tmp15 any + { // let + // let binding "seq_5" + tmp16 := checkDerefVar(var_glojure_DOT_core_seq) + tmp17 := lang.Apply(tmp16, []any{v3}) + var v18 any = tmp17 + _ = v18 + // let binding "chunk_6" + var v19 any = nil + _ = v19 + // let binding "count_7" + var v20 any = int64(0) + _ = v20 + // let binding "i_8" + var v21 any = int64(0) + _ = v21 + for { + var tmp22 any + tmp23 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp24 := lang.Apply(tmp23, []any{v21, v20}) + if lang.IsTruthy(tmp24) { + var tmp25 any + { // let + // let binding "agent" + tmp26, _ := lang.FieldOrMethod(v19, "nth") + if reflect.TypeOf(tmp26).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) } - }() - var tmp35 any + tmp27 := lang.Apply(tmp26, []any{v21}) + var v28 any = tmp27 + _ = v28 + tmp29 := checkDerefVar(var_glojure_DOT_core_send) + tmp30 := lang.Apply(tmp29, []any{v28, v14}) + _ = tmp30 + var tmp31 any = v18 + var tmp32 any = v19 + var tmp33 any = v20 + tmp35 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp36 := lang.Apply(tmp35, []any{v21}) + var tmp34 any = tmp36 + v18 = tmp31 + v19 = tmp32 + v20 = tmp33 + v21 = tmp34 + continue + } // end let + tmp22 = tmp25 + } else { + var tmp26 any { // let - // let binding "G__89" - tmp36 := checkDerefVar(var_glojure_DOT_core_seq) - tmp37 := lang.Apply(tmp36, []any{v28}) - var v38 any = tmp37 - _ = v38 - // let binding "vec__90" - var v39 any = v38 - _ = v39 - // let binding "seq__91" - tmp40 := checkDerefVar(var_glojure_DOT_core_seq) - tmp41 := lang.Apply(tmp40, []any{v39}) - var v42 any = tmp41 - _ = v42 - // let binding "first__92" - tmp43 := checkDerefVar(var_glojure_DOT_core_first) - tmp44 := lang.Apply(tmp43, []any{v42}) - var v45 any = tmp44 - _ = v45 - // let binding "seq__91" - tmp46 := checkDerefVar(var_glojure_DOT_core_next) - tmp47 := lang.Apply(tmp46, []any{v42}) - var v48 any = tmp47 - _ = v48 - // let binding "x" - var v49 any = v45 - _ = v49 - // let binding "xs" - var v50 any = v48 - _ = v50 - // let binding "s" - var v51 any = v39 - _ = v51 - var tmp52 any - { // let - // let binding "G__89" - var v53 any = v38 - _ = v53 - for { - var tmp54 any - { // let - // let binding "vec__93" - var v55 any = v53 - _ = v55 - // let binding "seq__94" - tmp56 := checkDerefVar(var_glojure_DOT_core_seq) - tmp57 := lang.Apply(tmp56, []any{v55}) - var v58 any = tmp57 - _ = v58 - // let binding "first__95" - tmp59 := checkDerefVar(var_glojure_DOT_core_first) - tmp60 := lang.Apply(tmp59, []any{v58}) - var v61 any = tmp60 - _ = v61 - // let binding "seq__94" - tmp62 := checkDerefVar(var_glojure_DOT_core_next) - tmp63 := lang.Apply(tmp62, []any{v58}) - var v64 any = tmp63 - _ = v64 - // let binding "x" - var v65 any = v61 - _ = v65 - // let binding "xs" - var v66 any = v64 - _ = v66 - // let binding "s" - var v67 any = v55 - _ = v67 - var tmp68 any - if lang.IsTruthy(v67) { - var tmp69 any - var tmp70 any - tmp71 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) - tmp72 := lang.Apply(tmp71, []any{v65}) - if lang.IsTruthy(tmp72) { - tmp70 = v17 - } else { - tmp70 = v65 - } - tmp73, _ := lang.FieldOrMethod(v12, "offer") - if reflect.TypeOf(tmp73).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("offer is not a function"))) - } - tmp74 := lang.Apply(tmp73, []any{tmp70}) - if lang.IsTruthy(tmp74) { - var tmp75 any = v66 - v53 = tmp75 - continue - } else { - tmp69 = v67 - } - tmp68 = tmp69 - } else { - var tmp76 any - tmp77, _ := lang.FieldOrMethod(v12, "offer") - if reflect.TypeOf(tmp77).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("offer is not a function"))) - } - tmp78 := lang.Apply(tmp77, []any{v12}) - if lang.IsTruthy(tmp78) { - } else { - tmp76 = lang.NewList() - } - tmp68 = tmp76 - } - tmp54 = tmp68 - } // end let - tmp52 = tmp54 - break - } - } // end let - tmp35 = tmp52 + // let binding "temp__0__auto__" + tmp27 := checkDerefVar(var_glojure_DOT_core_seq) + tmp28 := lang.Apply(tmp27, []any{v18}) + var v29 any = tmp28 + _ = v29 + var tmp30 any + if lang.IsTruthy(v29) { + var tmp31 any + { // let + // let binding "seq_5" + var v32 any = v29 + _ = v32 + var tmp33 any + tmp34 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp35 := lang.Apply(tmp34, []any{v32}) + if lang.IsTruthy(tmp35) { + var tmp36 any + { // let + // let binding "c__0__auto__" + tmp37 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp38 := lang.Apply(tmp37, []any{v32}) + var v39 any = tmp38 + _ = v39 + tmp41 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp42 := lang.Apply(tmp41, []any{v32}) + var tmp40 any = tmp42 + var tmp43 any = v39 + tmp45 := checkDerefVar(var_glojure_DOT_core_int) + tmp46 := checkDerefVar(var_glojure_DOT_core_count) + tmp47 := lang.Apply(tmp46, []any{v39}) + tmp48 := lang.Apply(tmp45, []any{tmp47}) + var tmp44 any = tmp48 + tmp50 := checkDerefVar(var_glojure_DOT_core_int) + tmp51 := lang.Apply(tmp50, []any{int64(0)}) + var tmp49 any = tmp51 + v18 = tmp40 + v19 = tmp43 + v20 = tmp44 + v21 = tmp49 + continue + } // end let + tmp33 = tmp36 + } else { + var tmp37 any + { // let + // let binding "agent" + tmp38 := checkDerefVar(var_glojure_DOT_core_first) + tmp39 := lang.Apply(tmp38, []any{v32}) + var v40 any = tmp39 + _ = v40 + tmp41 := checkDerefVar(var_glojure_DOT_core_send) + tmp42 := lang.Apply(tmp41, []any{v40, v14}) + _ = tmp42 + tmp44 := checkDerefVar(var_glojure_DOT_core_next) + tmp45 := lang.Apply(tmp44, []any{v32}) + var tmp43 any = tmp45 + var tmp46 any = nil + var tmp47 any = int64(0) + var tmp48 any = int64(0) + v18 = tmp43 + v19 = tmp46 + v20 = tmp47 + v21 = tmp48 + continue + } // end let + tmp33 = tmp37 + } + tmp31 = tmp33 + } // end let + tmp30 = tmp31 + } else { + } + tmp26 = tmp30 } // end let - tmp34 = tmp35 - }() - tmp30 = tmp34 + tmp22 = tmp26 + } + tmp15 = tmp22 + break } - tmp29 = tmp30 + } // end let + _ = tmp15 + tmp16, ok := lang.FieldOrMethod(nil, "MILLISECONDS") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "MILLISECONDS"))) + } + var tmp17 any + switch reflect.TypeOf(tmp16).Kind() { + case reflect.Func: + tmp17 = lang.Apply(tmp16, nil) + default: + tmp17 = tmp16 + } + tmp18, _ := lang.FieldOrMethod(v10, "await") + if reflect.TypeOf(tmp18).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) + } + tmp19 := lang.Apply(tmp18, []any{v2, tmp17}) + tmp9 = tmp19 + } // end let + tmp4 = tmp9 + } + return tmp4 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_await_DASH_for = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_await_DASH_for.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // check-cyclic-dependency + { + tmp0 := sym_check_DASH_cyclic_DASH_dependency.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_path)), kw_doc, "Detects and rejects non-trivial cyclic load dependencies. The\n exception message shows the dependency chain with the cycle\n highlighted. Ignores the trivial case of a file attempting to load\n itself because that can occur when a gen-class'd class loads its\n implementation.", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(30), kw_column, int(8), kw_line, int(5974), kw_end_DASH_line, int(5974), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_some) + tmp5 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{v2})) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5981), kw_column, int(15), kw_end_DASH_line, int(5981), kw_end_DASH_column, int(21)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp8 := checkDerefVar(var_glojure_DOT_core_rest) + tmp9 := checkDerefVar(var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_) + tmp10 := lang.Apply(tmp8, []any{tmp9}) + tmp11 := lang.Apply(tmp4, []any{tmp7, tmp10}) + if lang.IsTruthy(tmp11) { + var tmp12 any + { // let + // let binding "pending" + tmp13 := checkDerefVar(var_glojure_DOT_core_map) + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v15 := args[0] + _ = v15 + var tmp16 any + tmp17 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp18 := lang.Apply(tmp17, []any{v15, v2}) + if lang.IsTruthy(tmp18) { + tmp19 := checkDerefVar(var_glojure_DOT_core_str) + tmp20 := lang.Apply(tmp19, []any{"[ ", v15, " ]"}) + tmp16 = tmp20 } else { + tmp16 = v15 } - return tmp29 + return tmp16 }) - tmp28 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5439), kw_column, int(15), kw_end_DASH_line, int(5452), kw_end_DASH_column, int(44)) - tmp29, err := lang.WithMeta(tmp27, tmp28.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v30 any = tmp29 - _ = v30 - // let binding "drain" - var tmp31 lang.FnFunc - { // function drain - var v32 lang.FnFunc - tmp31 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - var tmp33 lang.FnFunc - tmp33 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - var tmp34 any - { // let - // let binding "x" - tmp35, ok := lang.FieldOrMethod(v12, "take") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v12, "take"))) - } - var tmp36 any - switch reflect.TypeOf(tmp35).Kind() { - case reflect.Func: - tmp36 = lang.Apply(tmp35, nil) - default: - tmp36 = tmp35 - } - var v37 any = tmp36 - _ = v37 - var tmp38 any - tmp39 := checkDerefVar(var_glojure_DOT_core_identical_QMARK_) - tmp40 := lang.Apply(tmp39, []any{v37, v12}) - if lang.IsTruthy(tmp40) { - tmp41 := checkDerefVar(var_glojure_DOT_core_deref) - tmp42 := lang.Apply(tmp41, []any{v22}) - _ = tmp42 - } else { - tmp43 := checkDerefVar(var_glojure_DOT_core_send_DASH_off) - tmp44 := lang.Apply(tmp43, []any{v22, v30}) - _ = tmp44 - tmp45 := checkDerefVar(var_glojure_DOT_core_release_DASH_pending_DASH_sends) - tmp46 := lang.Apply(tmp45, nil) - _ = tmp46 - tmp47 := checkDerefVar(var_glojure_DOT_core_cons) - var tmp48 any - tmp49 := checkDerefVar(var_glojure_DOT_core_identical_QMARK_) - tmp50 := lang.Apply(tmp49, []any{v37, v17}) - if lang.IsTruthy(tmp50) { - } else { - tmp48 = v37 - } - tmp51 := lang.Apply(v32, nil) - tmp52 := lang.Apply(tmp47, []any{tmp48, tmp51}) - tmp38 = tmp52 - } - tmp34 = tmp38 - } // end let - return tmp34 - }) - tmp34 := lang.Apply(lang.NewLazySeq, []any{tmp33}) - return tmp34 - }) - v32 = tmp31 - _ = v32 - } - tmp32 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5453), kw_column, int(16), kw_end_DASH_line, int(5461), kw_end_DASH_column, int(73)) - tmp33, err := lang.WithMeta(tmp31, tmp32.(lang.IPersistentMap)) + tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5982), kw_column, int(24), kw_end_DASH_line, int(5982), kw_end_DASH_column, int(59)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) if err != nil { panic(err) } - var v34 any = tmp33 - _ = v34 - tmp35 := checkDerefVar(var_glojure_DOT_core_send_DASH_off) - tmp36 := lang.Apply(tmp35, []any{v22, v30}) - _ = tmp36 - tmp37 := lang.Apply(v34, nil) - tmp5 = tmp37 + tmp17 := checkDerefVar(var_glojure_DOT_core_cons) + tmp18 := checkDerefVar(var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_) + tmp19 := lang.Apply(tmp17, []any{v2, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp16, tmp19}) + var v21 any = tmp20 + _ = v21 + // let binding "chain" + tmp22 := checkDerefVar(var_glojure_DOT_core_apply) + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_interpose) + tmp25 := lang.Apply(tmp24, []any{"->", v21}) + tmp26 := lang.Apply(tmp22, []any{tmp23, tmp25}) + var v27 any = tmp26 + _ = v27 + tmp28 := checkDerefVar(var_glojure_DOT_core_throw_DASH_if) + tmp29 := lang.Apply(tmp28, []any{true, "Cyclic load dependency: %s", v27}) + tmp12 = tmp29 } // end let - return tmp5 - default: - checkArity(args, -1) - panic("unreachable") + tmp3 = tmp12 + } else { } + return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_check_DASH_cyclic_DASH_dependency = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_check_DASH_cyclic_DASH_dependency.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // sequence + // cond-> { - tmp0 := sym_sequence.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll), lang.NewVector(sym_xform, sym_coll), lang.NewVector(sym_xform, sym_coll, sym__AMP_, sym_colls)), kw_doc, "Coerces coll to a (possibly empty) sequence, if it is not already\n one. Will not force a lazy seq. (sequence nil) yields (), When a\n transducer is supplied, returns a lazy sequence of applications of\n the transform to the items in coll(s), i.e. to the set of first\n items of each coll, followed by the set of second\n items in each coll, until any one of the colls is exhausted. Any\n remaining items in other colls are ignored. The transform should accept\n number-of-colls arguments", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(2639), kw_end_DASH_line, int(2639))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_cond_DASH__GT_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_expr, sym__AMP_, sym_clauses)), kw_doc, "Takes an expression and a set of test/form pairs. Threads expr (via ->)\n through each form for which the corresponding test\n expression is true. Note that, unlike cond branching, cond-> threading does\n not short circuit after the first true test expression.", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(11), kw_line, int(7564), kw_end_DASH_line, int(7564))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 1: - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) - tmp6 := lang.Apply(tmp5, []any{v3}) - if lang.IsTruthy(tmp6) { - tmp4 = v3 - } else { - var tmp7 any - { // let - // let binding "or__0__auto__" - tmp8 := checkDerefVar(var_glojure_DOT_core_seq) - tmp9 := lang.Apply(tmp8, []any{v3}) - var v10 any = tmp9 - _ = v10 - var tmp11 any - if lang.IsTruthy(v10) { - tmp11 = v10 - } else { - tmp11 = lang.NewList() - } - tmp7 = tmp11 - } // end let - tmp4 = tmp7 - } - return tmp4 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - { // let - // let binding "or__0__auto__" - tmp6 := lang.Apply(nil, []any{v4}) - tmp7 := lang.Apply(nil, []any{v3, tmp6}) - tmp8 := lang.Apply(nil, []any{tmp7}) - var v9 any = tmp8 - _ = v9 - var tmp10 any - if lang.IsTruthy(v9) { - tmp10 = v9 - } else { - tmp10 = lang.NewList() - } - tmp5 = tmp10 - } // end let - return tmp5 default: - checkArity(args, 2) - v3 := args[0] + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[2:]...) + var v5 any = lang.NewList(args[3:]...) _ = v5 var tmp6 any { // let - // let binding "or__0__auto__" - tmp7 := checkDerefVar(var_glojure_DOT_core_map) - var tmp8 lang.FnFunc - tmp8 = lang.NewFnFunc(func(args ...any) any { + // let binding "g" + tmp7 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp8 := lang.Apply(tmp7, nil) + var v9 any = tmp8 + _ = v9 + // let binding "steps" + tmp10 := checkDerefVar(var_glojure_DOT_core_map) + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v9 := args[0] - _ = v9 - tmp10 := lang.Apply(nil, []any{v9}) - return tmp10 + v12 := args[0] + _ = v12 + var tmp13 any + { // let + // let binding "vec__349" + var v14 any = v12 + _ = v14 + // let binding "test" + tmp15 := checkDerefVar(var_glojure_DOT_core_nth) + tmp16 := lang.Apply(tmp15, []any{v14, int64(0), nil}) + var v17 any = tmp16 + _ = v17 + // let binding "step" + tmp18 := checkDerefVar(var_glojure_DOT_core_nth) + tmp19 := lang.Apply(tmp18, []any{v14, int64(1), nil}) + var v20 any = tmp19 + _ = v20 + tmp21 := checkDerefVar(var_glojure_DOT_core_seq) + tmp22 := checkDerefVar(var_glojure_DOT_core_concat) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := lang.Apply(tmp23, []any{sym_if}) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := lang.Apply(tmp25, []any{v17}) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := checkDerefVar(var_glojure_DOT_core_seq) + tmp29 := checkDerefVar(var_glojure_DOT_core_concat) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := lang.Apply(tmp30, []any{sym_glojure_DOT_core_SLASH__DASH__GT_}) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := lang.Apply(tmp32, []any{v9}) + tmp34 := checkDerefVar(var_glojure_DOT_core_list) + tmp35 := lang.Apply(tmp34, []any{v20}) + tmp36 := lang.Apply(tmp29, []any{tmp31, tmp33, tmp35}) + tmp37 := lang.Apply(tmp28, []any{tmp36}) + tmp38 := lang.Apply(tmp27, []any{tmp37}) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := lang.Apply(tmp39, []any{v9}) + tmp41 := lang.Apply(tmp22, []any{tmp24, tmp26, tmp38, tmp40}) + tmp42 := lang.Apply(tmp21, []any{tmp41}) + tmp13 = tmp42 + } // end let + return tmp13 }) - tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2661), kw_column, int(17), kw_end_DASH_line, int(2661), kw_end_DASH_column, int(41)) - tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7573), kw_column, int(20), kw_end_DASH_line, int(7573), kw_end_DASH_column, int(66)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp11 := checkDerefVar(var_glojure_DOT_core_cons) - tmp12 := lang.Apply(tmp11, []any{v4, v5}) - tmp13 := lang.Apply(tmp7, []any{tmp10, tmp12}) - tmp14 := lang.Apply(nil, []any{v3, tmp13}) - tmp15 := lang.Apply(nil, []any{tmp14}) - var v16 any = tmp15 - _ = v16 - var tmp17 any - if lang.IsTruthy(v16) { - tmp17 = v16 + tmp14 := checkDerefVar(var_glojure_DOT_core_partition) + tmp15 := lang.Apply(tmp14, []any{int64(2), v5}) + tmp16 := lang.Apply(tmp10, []any{tmp13, tmp15}) + var v17 any = tmp16 + _ = v17 + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{sym_glojure_DOT_core_SLASH_let}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := checkDerefVar(var_glojure_DOT_core_apply) + tmp24 := checkDerefVar(var_glojure_DOT_core_vector) + tmp25 := checkDerefVar(var_glojure_DOT_core_seq) + tmp26 := checkDerefVar(var_glojure_DOT_core_concat) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{v9}) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{v4}) + tmp31 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp32 := checkDerefVar(var_glojure_DOT_core_repeat) + tmp33 := lang.Apply(tmp32, []any{v9}) + tmp34 := checkDerefVar(var_glojure_DOT_core_butlast) + tmp35 := lang.Apply(tmp34, []any{v17}) + tmp36 := lang.Apply(tmp31, []any{tmp33, tmp35}) + tmp37 := lang.Apply(tmp26, []any{tmp28, tmp30, tmp36}) + tmp38 := lang.Apply(tmp25, []any{tmp37}) + tmp39 := lang.Apply(tmp23, []any{tmp24, tmp38}) + tmp40 := lang.Apply(tmp22, []any{tmp39}) + tmp41 := checkDerefVar(var_glojure_DOT_core_list) + var tmp42 any + tmp43 := checkDerefVar(var_glojure_DOT_core_empty_QMARK_) + tmp44 := lang.Apply(tmp43, []any{v17}) + if lang.IsTruthy(tmp44) { + tmp42 = v9 } else { - tmp17 = lang.NewList() - } - tmp6 = tmp17 + tmp45 := checkDerefVar(var_glojure_DOT_core_last) + tmp46 := lang.Apply(tmp45, []any{v17}) + tmp42 = tmp46 + } + tmp47 := lang.Apply(tmp41, []any{tmp42}) + tmp48 := lang.Apply(tmp19, []any{tmp21, tmp40, tmp47}) + tmp49 := lang.Apply(tmp18, []any{tmp48}) + tmp6 = tmp49 } // end let return tmp6 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // sequential? - { - tmp0 := sym_sequential_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns true if coll implements Sequential", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(6229), kw_end_DASH_line, int(6229))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp5 := reflect.TypeOf((*lang.Sequential)(nil)).Elem() - tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) - return tmp6 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_cond_DASH__GT_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_cond_DASH__GT_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // serialized-require + // cond->> { - tmp0 := sym_serialized_DASH_require.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_args)), kw_doc, "Like 'require', but serializes loading.\n Interim function preferred over 'require' for known asynchronous loads.\n Future changes may make these equivalent.", kw_file, "glojure/core.glj", kw_added, "1.10", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(25), kw_column, int(8), kw_line, int(6059), kw_end_DASH_line, int(6059), kw_private, true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_cond_DASH__GT__GT_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_expr, sym__AMP_, sym_clauses)), kw_doc, "Takes an expression and a set of test/form pairs. Threads expr (via ->>)\n through each form for which the corresponding test expression\n is true. Note that, unlike cond branching, cond->> threading does not short circuit\n after the first true test expression.", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(7581), kw_end_DASH_line, int(7581))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) - var v3 any = lang.NewList(args[0:]...) + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - var tmp4 any + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any { // let - // let binding "lockee__0__auto__" - var v5 any = nil - _ = v5 - var tmp6 any - func() { - var tmp7 any + // let binding "g" + tmp7 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp8 := lang.Apply(tmp7, nil) + var v9 any = tmp8 + _ = v9 + // let binding "steps" + tmp10 := checkDerefVar(var_glojure_DOT_core_map) + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v12 := args[0] + _ = v12 + var tmp13 any { // let - // let binding "locklocal__1__auto__" - var v8 any = v5 - _ = v8 - tmp9 := lang.Apply(nil, []any{v8}) - _ = tmp9 - var tmp10 any - func() { - defer func() { - tmp11 := lang.Apply(nil, []any{v8}) - _ = tmp11 - }() - tmp12 := checkDerefVar(var_glojure_DOT_core_apply) - tmp13 := checkDerefVar(var_glojure_DOT_core_require) - tmp14 := lang.Apply(tmp12, []any{tmp13, v3}) - tmp10 = tmp14 - }() - tmp7 = tmp10 + // let binding "vec__353" + var v14 any = v12 + _ = v14 + // let binding "test" + tmp15 := checkDerefVar(var_glojure_DOT_core_nth) + tmp16 := lang.Apply(tmp15, []any{v14, int64(0), nil}) + var v17 any = tmp16 + _ = v17 + // let binding "step" + tmp18 := checkDerefVar(var_glojure_DOT_core_nth) + tmp19 := lang.Apply(tmp18, []any{v14, int64(1), nil}) + var v20 any = tmp19 + _ = v20 + tmp21 := checkDerefVar(var_glojure_DOT_core_seq) + tmp22 := checkDerefVar(var_glojure_DOT_core_concat) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := lang.Apply(tmp23, []any{sym_if}) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := lang.Apply(tmp25, []any{v17}) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := checkDerefVar(var_glojure_DOT_core_seq) + tmp29 := checkDerefVar(var_glojure_DOT_core_concat) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := lang.Apply(tmp30, []any{sym_glojure_DOT_core_SLASH__DASH__GT__GT_}) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := lang.Apply(tmp32, []any{v9}) + tmp34 := checkDerefVar(var_glojure_DOT_core_list) + tmp35 := lang.Apply(tmp34, []any{v20}) + tmp36 := lang.Apply(tmp29, []any{tmp31, tmp33, tmp35}) + tmp37 := lang.Apply(tmp28, []any{tmp36}) + tmp38 := lang.Apply(tmp27, []any{tmp37}) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := lang.Apply(tmp39, []any{v9}) + tmp41 := lang.Apply(tmp22, []any{tmp24, tmp26, tmp38, tmp40}) + tmp42 := lang.Apply(tmp21, []any{tmp41}) + tmp13 = tmp42 } // end let - tmp6 = tmp7 - }() - tmp4 = tmp6 - } // end let - return tmp4 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // set - { - tmp0 := sym_set.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a set of the distinct elements of coll.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(4104), kw_end_DASH_line, int(4104))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := checkDerefVar(var_glojure_DOT_core_set_QMARK_) - tmp6 := lang.Apply(tmp5, []any{v3}) - if lang.IsTruthy(tmp6) { - tmp7 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) - tmp8 := lang.Apply(tmp7, []any{v3, nil}) - tmp4 = tmp8 - } else { - var tmp9 any - tmp10 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp11 := reflect.TypeOf((*lang.IReduceInit)(nil)).Elem() - tmp12 := lang.Apply(tmp10, []any{tmp11, v3}) - if lang.IsTruthy(tmp12) { - tmp13 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) - tmp14 := checkDerefVar(var_glojure_DOT_core_conj_BANG_) - tmp15 := checkDerefVar(var_glojure_DOT_core_transient) - tmp16 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) - tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4112), kw_column, int(108), kw_end_DASH_line, int(4112), kw_end_DASH_column, int(110)) - tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp19 := lang.Apply(tmp15, []any{tmp18}) - tmp20, _ := lang.FieldOrMethod(v3, "ReduceInit") - if reflect.TypeOf(tmp20).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) - } - tmp21 := lang.Apply(tmp20, []any{tmp14, tmp19}) - tmp22 := lang.Apply(tmp13, []any{tmp21}) - tmp9 = tmp22 - } else { - tmp23 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) - tmp24 := checkDerefVar(var_glojure_DOT_core_reduce1) - tmp25 := checkDerefVar(var_glojure_DOT_core_conj_BANG_) - tmp26 := checkDerefVar(var_glojure_DOT_core_transient) - tmp27 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) - tmp28 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4113), kw_column, int(46), kw_end_DASH_line, int(4113), kw_end_DASH_column, int(48)) - tmp29, err := lang.WithMeta(tmp27, tmp28.(lang.IPersistentMap)) + return tmp13 + }) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7590), kw_column, int(20), kw_end_DASH_line, int(7590), kw_end_DASH_column, int(67)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp30 := lang.Apply(tmp26, []any{tmp29}) - tmp31 := lang.Apply(tmp24, []any{tmp25, tmp30, v3}) - tmp32 := lang.Apply(tmp23, []any{tmp31}) - tmp9 = tmp32 - } - tmp4 = tmp9 - } - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // set-agent-send-executor! - { - tmp0 := sym_set_DASH_agent_DASH_send_DASH_executor_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_executor)), kw_doc, "Sets the ExecutorService to be used by send", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(30), kw_column, int(7), kw_line, int(2087), kw_end_DASH_line, int(2087))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - return nil - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // set-agent-send-off-executor! - { - tmp0 := sym_set_DASH_agent_DASH_send_DASH_off_DASH_executor_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_executor)), kw_doc, "Sets the ExecutorService to be used by send-off", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(34), kw_column, int(7), kw_line, int(2093), kw_end_DASH_line, int(2093))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - return nil - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // set-error-handler! - { - tmp0 := sym_set_DASH_error_DASH_handler_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a, sym_handler_DASH_fn)), kw_doc, "Sets the error-handler of agent a to handler-fn. If an action\n being run by the agent throws an exception or doesn't pass the\n validator fn, handler-fn will be called with two arguments: the\n agent and the exception.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(24), kw_column, int(7), kw_line, int(2192), kw_end_DASH_line, int(2192))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5, _ := lang.FieldOrMethod(v3, "setErrorHandler") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorHandler is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // set-error-mode! - { - tmp0 := sym_set_DASH_error_DASH_mode_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a, sym_mode_DASH_keyword)), kw_doc, "Sets the error-mode of agent a to mode-keyword, which must be\n either :fail or :continue. If an action being run by the agent\n throws an exception or doesn't pass the validator fn, an\n error-handler may be called (see set-error-handler!), after which,\n if the mode is :continue, the agent will continue as if neither the\n action that caused the error nor the error itself ever happened.\n \n If the mode is :fail, the agent will become failed and will stop\n accepting new 'send' and 'send-off' actions, and any previously\n queued actions will be held until a 'restart-agent'. Deref will\n still work, returning the state of the agent before the error.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(2210), kw_end_DASH_line, int(2210))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5, _ := lang.FieldOrMethod(v3, "setErrorMode") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorMode is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // set-validator! - { - tmp0 := sym_set_DASH_validator_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_iref, sym_validator_DASH_fn)), kw_doc, "Sets the validator-fn for a var/ref/agent/atom. validator-fn must be nil or a\n side-effect-free fn of one argument, which will be passed the intended\n new state on any state change. If the new state is unacceptable, the\n validator-fn should return false or throw an exception. If the current state (root\n value if var) is not acceptable to the new validator, an exception\n will be thrown and the validator will not be changed.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(2381), kw_end_DASH_line, int(2381))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5, _ := lang.FieldOrMethod(v3, "setValidator") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setValidator is not a function"))) + tmp14 := checkDerefVar(var_glojure_DOT_core_partition) + tmp15 := lang.Apply(tmp14, []any{int64(2), v5}) + tmp16 := lang.Apply(tmp10, []any{tmp13, tmp15}) + var v17 any = tmp16 + _ = v17 + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{sym_glojure_DOT_core_SLASH_let}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := checkDerefVar(var_glojure_DOT_core_apply) + tmp24 := checkDerefVar(var_glojure_DOT_core_vector) + tmp25 := checkDerefVar(var_glojure_DOT_core_seq) + tmp26 := checkDerefVar(var_glojure_DOT_core_concat) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{v9}) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{v4}) + tmp31 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp32 := checkDerefVar(var_glojure_DOT_core_repeat) + tmp33 := lang.Apply(tmp32, []any{v9}) + tmp34 := checkDerefVar(var_glojure_DOT_core_butlast) + tmp35 := lang.Apply(tmp34, []any{v17}) + tmp36 := lang.Apply(tmp31, []any{tmp33, tmp35}) + tmp37 := lang.Apply(tmp26, []any{tmp28, tmp30, tmp36}) + tmp38 := lang.Apply(tmp25, []any{tmp37}) + tmp39 := lang.Apply(tmp23, []any{tmp24, tmp38}) + tmp40 := lang.Apply(tmp22, []any{tmp39}) + tmp41 := checkDerefVar(var_glojure_DOT_core_list) + var tmp42 any + tmp43 := checkDerefVar(var_glojure_DOT_core_empty_QMARK_) + tmp44 := lang.Apply(tmp43, []any{v17}) + if lang.IsTruthy(tmp44) { + tmp42 = v9 + } else { + tmp45 := checkDerefVar(var_glojure_DOT_core_last) + tmp46 := lang.Apply(tmp45, []any{v17}) + tmp42 = tmp46 + } + tmp47 := lang.Apply(tmp41, []any{tmp42}) + tmp48 := lang.Apply(tmp19, []any{tmp21, tmp40, tmp47}) + tmp49 := lang.Apply(tmp18, []any{tmp48}) + tmp6 = tmp49 + } // end let + return tmp6 } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // set? - { - tmp0 := sym_set_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x implements IPersistentSet", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(4098), kw_end_DASH_line, int(4098))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp5 := reflect.TypeOf((*lang.IPersistentSet)(nil)).Elem() - tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) - return tmp6 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // setup-reference - { - tmp0 := sym_setup_DASH_reference.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(2043), kw_column, int(7), kw_end_DASH_line, int(2044), kw_end_DASH_column, int(17), kw_arglists, lang.NewList(lang.NewVector(sym_r, sym_options)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - { // let - // let binding "opts" - tmp6 := checkDerefVar(var_glojure_DOT_core_apply) - tmp7 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) - tmp8 := lang.Apply(tmp6, []any{tmp7, v4}) - var v9 any = tmp8 - _ = v9 - var tmp10 any - tmp11 := lang.Apply(kw_meta, []any{v9}) - if lang.IsTruthy(tmp11) { - tmp12 := lang.Apply(kw_meta, []any{v9}) - tmp13, _ := lang.FieldOrMethod(v3, "ResetMeta") - if reflect.TypeOf(tmp13).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ResetMeta is not a function"))) - } - tmp14 := lang.Apply(tmp13, []any{tmp12}) - tmp10 = tmp14 - } else { - } - _ = tmp10 - var tmp15 any - tmp16 := lang.Apply(kw_validator, []any{v9}) - if lang.IsTruthy(tmp16) { - tmp17 := lang.Apply(kw_validator, []any{v9}) - tmp18, _ := lang.FieldOrMethod(v3, "setValidator") - if reflect.TypeOf(tmp18).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setValidator is not a function"))) - } - tmp19 := lang.Apply(tmp18, []any{tmp17}) - tmp15 = tmp19 - } else { - } - _ = tmp15 - tmp5 = v3 - } // end let - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // shift-mask - { - tmp0 := sym_shift_DASH_mask.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6598), kw_column, int(8), kw_end_DASH_line, int(6598), kw_end_DASH_column, int(17), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_shift, sym_mask, sym_x)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 3) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6 := checkDerefVar(var_glojure_DOT_core_bit_DASH_and) - tmp7 := checkDerefVar(var_glojure_DOT_core_bit_DASH_shift_DASH_right) - tmp8 := lang.Apply(tmp7, []any{v5, v3}) - tmp9 := lang.Apply(tmp6, []any{tmp8, v4}) - return tmp9 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // short - { - var tmp1 lang.FnFunc - { // function short__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_seq) - tmp5 := checkDerefVar(var_glojure_DOT_core_concat) - tmp6 := checkDerefVar(var_glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) - tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := checkDerefVar(var_glojure_DOT_core_seq) - tmp12 := checkDerefVar(var_glojure_DOT_core_concat) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - var tmp14 any - tmp15 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) - if lang.IsTruthy(tmp15) { - tmp14 = sym_uncheckedShortCast - } else { - tmp14 = sym_shortCast - } - tmp16 := lang.Apply(tmp13, []any{tmp14}) - tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{v3}) - tmp19 := lang.Apply(tmp12, []any{tmp16, tmp18}) - tmp20 := lang.Apply(tmp11, []any{tmp19}) - tmp21 := lang.Apply(tmp10, []any{tmp20}) - tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp21}) - tmp23 := lang.Apply(tmp4, []any{tmp22}) - return tmp23 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := sym_short.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to short", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3499), kw_end_DASH_line, int(3499))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5 := lang.Apply(lang.ShortCast, []any{v4}) - return tmp5 }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_cond_DASH__GT__GT_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_cond_DASH__GT__GT_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // short-array + // condp { + tmp0 := sym_condp.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_pred, sym_expr, sym__AMP_, sym_clauses)), kw_doc, "Takes a binary predicate, an expression, and a set of clauses.\n Each clause can take the form of either:\n\n test-expr result-expr\n\n test-expr :>> result-fn\n\n Note :>> is an ordinary keyword.\n\n For each clause, (pred test-expr expr) is evaluated. If it returns\n logical true, the clause is a match. If a binary clause matches, the\n result-expr is returned, if a ternary clause matches, its result-fn,\n which must be a unary function, is called with the result of the\n predicate as its argument, the result of that call being the return\n value of condp. A single default expression can follow the clauses,\n and its value will be returned if no clause matches. If no default\n expression is provided and no clause matches, an\n IllegalArgumentException is thrown.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(11), kw_line, int(6353), kw_end_DASH_line, int(6353))).(*lang.Symbol) var tmp1 lang.FnFunc - { // function short-array__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 0) - var v3 any = lang.NewList(args[0:]...) - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_seq) - tmp5 := checkDerefVar(var_glojure_DOT_core_concat) - tmp6 := checkDerefVar(var_glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) - tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_ShortArray}) - tmp12 := checkDerefVar(var_glojure_DOT_core_list) - tmp13 := checkDerefVar(var_glojure_DOT_core_seq) - tmp14 := checkDerefVar(var_glojure_DOT_core_concat) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_unquote_DASH_splicing}) - tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{sym_glojure_DOT_core_SLASH_args}) - tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) - tmp20 := lang.Apply(tmp13, []any{tmp19}) - tmp21 := lang.Apply(tmp12, []any{tmp20}) - tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp21}) - tmp23 := lang.Apply(tmp4, []any{tmp22}) - return tmp23 - } - }) - v2 = tmp1 - _ = v2 - } - tmp0 := sym_short_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_size_DASH_or_DASH_seq), lang.NewVector(sym_size, sym_init_DASH_val_DASH_or_DASH_seq)), kw_inline, tmp1, kw_doc, "Creates an array of shorts", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(5333), kw_end_DASH_line, int(5333))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 1: - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "ShortArray") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ShortArray is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - case 2: - v4 := args[0] + default: + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] _ = v4 - v5 := args[1] + v5 := args[3] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "ShortArrayInit") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ShortArrayInit is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) + var v6 any = lang.NewList(args[4:]...) + _ = v6 + var tmp7 any + { // let + // let binding "gpred" + tmp8 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp9 := lang.Apply(tmp8, []any{"pred__"}) + var v10 any = tmp9 + _ = v10 + // let binding "gexpr" + tmp11 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp12 := lang.Apply(tmp11, []any{"expr__"}) + var v13 any = tmp12 + _ = v13 + // let binding "emit" + var tmp14 lang.FnFunc + { // function emit + var v15 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v16 := args[0] + _ = v16 + v17 := args[1] + _ = v17 + v18 := args[2] + _ = v18 + var tmp19 any + { // let + // let binding "vec__144" + tmp20 := checkDerefVar(var_glojure_DOT_core_split_DASH_at) + var tmp21 any + tmp22 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp23 := checkDerefVar(var_glojure_DOT_core_second) + tmp24 := lang.Apply(tmp23, []any{v18}) + tmp25 := lang.Apply(tmp22, []any{kw__GT__GT_, tmp24}) + if lang.IsTruthy(tmp25) { + tmp21 = int64(3) + } else { + tmp21 = int64(2) + } + tmp26 := lang.Apply(tmp20, []any{tmp21, v18}) + var v27 any = tmp26 + _ = v27 + // let binding "vec__147" + tmp28 := checkDerefVar(var_glojure_DOT_core_nth) + tmp29 := lang.Apply(tmp28, []any{v27, int64(0), nil}) + var v30 any = tmp29 + _ = v30 + // let binding "a" + tmp31 := checkDerefVar(var_glojure_DOT_core_nth) + tmp32 := lang.Apply(tmp31, []any{v30, int64(0), nil}) + var v33 any = tmp32 + _ = v33 + // let binding "b" + tmp34 := checkDerefVar(var_glojure_DOT_core_nth) + tmp35 := lang.Apply(tmp34, []any{v30, int64(1), nil}) + var v36 any = tmp35 + _ = v36 + // let binding "c" + tmp37 := checkDerefVar(var_glojure_DOT_core_nth) + tmp38 := lang.Apply(tmp37, []any{v30, int64(2), nil}) + var v39 any = tmp38 + _ = v39 + // let binding "clause" + var v40 any = v30 + _ = v40 + // let binding "more" + tmp41 := checkDerefVar(var_glojure_DOT_core_nth) + tmp42 := lang.Apply(tmp41, []any{v27, int64(1), nil}) + var v43 any = tmp42 + _ = v43 + // let binding "n" + tmp44 := checkDerefVar(var_glojure_DOT_core_count) + tmp45 := lang.Apply(tmp44, []any{v40}) + var v46 any = tmp45 + _ = v46 + var tmp47 any + tmp48 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp49 := lang.Apply(tmp48, []any{int64(0), v46}) + if lang.IsTruthy(tmp49) { + tmp50 := checkDerefVar(var_glojure_DOT_core_seq) + tmp51 := checkDerefVar(var_glojure_DOT_core_concat) + tmp52 := checkDerefVar(var_glojure_DOT_core_list) + tmp53 := lang.Apply(tmp52, []any{sym_throw}) + tmp54 := checkDerefVar(var_glojure_DOT_core_list) + tmp55 := checkDerefVar(var_glojure_DOT_core_seq) + tmp56 := checkDerefVar(var_glojure_DOT_core_concat) + tmp57 := checkDerefVar(var_glojure_DOT_core_list) + tmp58 := lang.Apply(tmp57, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_NewIllegalArgumentError}) + tmp59 := checkDerefVar(var_glojure_DOT_core_list) + tmp60 := checkDerefVar(var_glojure_DOT_core_seq) + tmp61 := checkDerefVar(var_glojure_DOT_core_concat) + tmp62 := checkDerefVar(var_glojure_DOT_core_list) + tmp63 := lang.Apply(tmp62, []any{sym_glojure_DOT_core_SLASH_str}) + tmp64 := checkDerefVar(var_glojure_DOT_core_list) + tmp65 := lang.Apply(tmp64, []any{"No matching clause: "}) + tmp66 := checkDerefVar(var_glojure_DOT_core_list) + tmp67 := lang.Apply(tmp66, []any{v17}) + tmp68 := lang.Apply(tmp61, []any{tmp63, tmp65, tmp67}) + tmp69 := lang.Apply(tmp60, []any{tmp68}) + tmp70 := lang.Apply(tmp59, []any{tmp69}) + tmp71 := lang.Apply(tmp56, []any{tmp58, tmp70}) + tmp72 := lang.Apply(tmp55, []any{tmp71}) + tmp73 := lang.Apply(tmp54, []any{tmp72}) + tmp74 := lang.Apply(tmp51, []any{tmp53, tmp73}) + tmp75 := lang.Apply(tmp50, []any{tmp74}) + tmp47 = tmp75 + } else { + var tmp76 any + tmp77 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp78 := lang.Apply(tmp77, []any{int64(1), v46}) + if lang.IsTruthy(tmp78) { + tmp76 = v33 + } else { + var tmp79 any + tmp80 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp81 := lang.Apply(tmp80, []any{int64(2), v46}) + if lang.IsTruthy(tmp81) { + tmp82 := checkDerefVar(var_glojure_DOT_core_seq) + tmp83 := checkDerefVar(var_glojure_DOT_core_concat) + tmp84 := checkDerefVar(var_glojure_DOT_core_list) + tmp85 := lang.Apply(tmp84, []any{sym_if}) + tmp86 := checkDerefVar(var_glojure_DOT_core_list) + tmp87 := checkDerefVar(var_glojure_DOT_core_seq) + tmp88 := checkDerefVar(var_glojure_DOT_core_concat) + tmp89 := checkDerefVar(var_glojure_DOT_core_list) + tmp90 := lang.Apply(tmp89, []any{v16}) + tmp91 := checkDerefVar(var_glojure_DOT_core_list) + tmp92 := lang.Apply(tmp91, []any{v33}) + tmp93 := checkDerefVar(var_glojure_DOT_core_list) + tmp94 := lang.Apply(tmp93, []any{v17}) + tmp95 := lang.Apply(tmp88, []any{tmp90, tmp92, tmp94}) + tmp96 := lang.Apply(tmp87, []any{tmp95}) + tmp97 := lang.Apply(tmp86, []any{tmp96}) + tmp98 := checkDerefVar(var_glojure_DOT_core_list) + tmp99 := lang.Apply(tmp98, []any{v36}) + tmp100 := checkDerefVar(var_glojure_DOT_core_list) + tmp101 := lang.Apply(v15, []any{v16, v17, v43}) + tmp102 := lang.Apply(tmp100, []any{tmp101}) + tmp103 := lang.Apply(tmp83, []any{tmp85, tmp97, tmp99, tmp102}) + tmp104 := lang.Apply(tmp82, []any{tmp103}) + tmp79 = tmp104 + } else { + var tmp105 any + if lang.IsTruthy(kw_else) { + tmp106 := checkDerefVar(var_glojure_DOT_core_seq) + tmp107 := checkDerefVar(var_glojure_DOT_core_concat) + tmp108 := checkDerefVar(var_glojure_DOT_core_list) + tmp109 := lang.Apply(tmp108, []any{sym_glojure_DOT_core_SLASH_if_DASH_let}) + tmp110 := checkDerefVar(var_glojure_DOT_core_list) + tmp111 := checkDerefVar(var_glojure_DOT_core_apply) + tmp112 := checkDerefVar(var_glojure_DOT_core_vector) + tmp113 := checkDerefVar(var_glojure_DOT_core_seq) + tmp114 := checkDerefVar(var_glojure_DOT_core_concat) + tmp115 := checkDerefVar(var_glojure_DOT_core_list) + tmp116 := lang.Apply(tmp115, []any{sym_p__0__auto__}) + tmp117 := checkDerefVar(var_glojure_DOT_core_list) + tmp118 := checkDerefVar(var_glojure_DOT_core_seq) + tmp119 := checkDerefVar(var_glojure_DOT_core_concat) + tmp120 := checkDerefVar(var_glojure_DOT_core_list) + tmp121 := lang.Apply(tmp120, []any{v16}) + tmp122 := checkDerefVar(var_glojure_DOT_core_list) + tmp123 := lang.Apply(tmp122, []any{v33}) + tmp124 := checkDerefVar(var_glojure_DOT_core_list) + tmp125 := lang.Apply(tmp124, []any{v17}) + tmp126 := lang.Apply(tmp119, []any{tmp121, tmp123, tmp125}) + tmp127 := lang.Apply(tmp118, []any{tmp126}) + tmp128 := lang.Apply(tmp117, []any{tmp127}) + tmp129 := lang.Apply(tmp114, []any{tmp116, tmp128}) + tmp130 := lang.Apply(tmp113, []any{tmp129}) + tmp131 := lang.Apply(tmp111, []any{tmp112, tmp130}) + tmp132 := lang.Apply(tmp110, []any{tmp131}) + tmp133 := checkDerefVar(var_glojure_DOT_core_list) + tmp134 := checkDerefVar(var_glojure_DOT_core_seq) + tmp135 := checkDerefVar(var_glojure_DOT_core_concat) + tmp136 := checkDerefVar(var_glojure_DOT_core_list) + tmp137 := lang.Apply(tmp136, []any{v39}) + tmp138 := checkDerefVar(var_glojure_DOT_core_list) + tmp139 := lang.Apply(tmp138, []any{sym_p__0__auto__}) + tmp140 := lang.Apply(tmp135, []any{tmp137, tmp139}) + tmp141 := lang.Apply(tmp134, []any{tmp140}) + tmp142 := lang.Apply(tmp133, []any{tmp141}) + tmp143 := checkDerefVar(var_glojure_DOT_core_list) + tmp144 := lang.Apply(v15, []any{v16, v17, v43}) + tmp145 := lang.Apply(tmp143, []any{tmp144}) + tmp146 := lang.Apply(tmp107, []any{tmp109, tmp132, tmp142, tmp145}) + tmp147 := lang.Apply(tmp106, []any{tmp146}) + tmp105 = tmp147 + } else { + } + tmp79 = tmp105 + } + tmp76 = tmp79 + } + tmp47 = tmp76 + } + tmp19 = tmp47 + } // end let + return tmp19 + }) + v15 = tmp14 + _ = v15 + } + tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6377), kw_column, int(14), kw_end_DASH_line, int(6389), kw_end_DASH_column, int(53)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v17 any = tmp16 + _ = v17 + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{sym_glojure_DOT_core_SLASH_let}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := checkDerefVar(var_glojure_DOT_core_apply) + tmp24 := checkDerefVar(var_glojure_DOT_core_vector) + tmp25 := checkDerefVar(var_glojure_DOT_core_seq) + tmp26 := checkDerefVar(var_glojure_DOT_core_concat) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{v10}) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{v4}) + tmp31 := checkDerefVar(var_glojure_DOT_core_list) + tmp32 := lang.Apply(tmp31, []any{v13}) + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{v5}) + tmp35 := lang.Apply(tmp26, []any{tmp28, tmp30, tmp32, tmp34}) + tmp36 := lang.Apply(tmp25, []any{tmp35}) + tmp37 := lang.Apply(tmp23, []any{tmp24, tmp36}) + tmp38 := lang.Apply(tmp22, []any{tmp37}) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := lang.Apply(v17, []any{v10, v13, v6}) + tmp41 := lang.Apply(tmp39, []any{tmp40}) + tmp42 := lang.Apply(tmp19, []any{tmp21, tmp38, tmp41}) + tmp43 := lang.Apply(tmp18, []any{tmp42}) + tmp7 = tmp43 + } // end let return tmp7 - default: - checkArity(args, -1) - panic("unreachable") } }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_condp = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_condp.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // shorts + // defn { + tmp0 := sym_defn.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym_doc_DASH_string_QMARK_, sym_attr_DASH_map_QMARK_, lang.NewVector(sym_params_STAR_), sym_prepost_DASH_map_QMARK_, sym_body), lang.NewVector(sym_name, sym_doc_DASH_string_QMARK_, sym_attr_DASH_map_QMARK_, lang.NewList(lang.NewVector(sym_params_STAR_), sym_prepost_DASH_map_QMARK_, sym_body), sym__PLUS_, sym_attr_DASH_map_QMARK_)), kw_doc, "Same as (def name (fn [params* ] exprs*)) or (def\n name (fn ([params* ] exprs*)+)) with any doc-string or attrs added\n to the var metadata. prepost-map defines a map with optional keys\n :pre and :post that contain collections of pre or post conditions.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(5), kw_column, int(2), kw_line, int(284), kw_end_DASH_line, int(291))).(*lang.Symbol) var tmp1 lang.FnFunc - { // function shorts + { // function defn var v2 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_seq) - tmp5 := checkDerefVar(var_glojure_DOT_core_concat) - tmp6 := checkDerefVar(var_glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) - tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Shorts}) - tmp12 := checkDerefVar(var_glojure_DOT_core_list) - tmp13 := lang.Apply(tmp12, []any{v3}) - tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) - tmp15 := lang.Apply(tmp4, []any{tmp14}) - return tmp15 + switch len(args) { + default: + checkArity(args, 3) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp9 := reflect.TypeOf((*lang.Symbol)(nil)) + tmp10 := lang.Apply(tmp8, []any{tmp9, v5}) + if lang.IsTruthy(tmp10) { + } else { + tmp11 := lang.Apply(lang.NewIllegalArgumentError, []any{"First argument to defn must be a symbol"}) + panic(tmp11) + } + _ = tmp7 + var tmp12 any + { // let + // let binding "m" + var tmp13 any + tmp14 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp15 := checkDerefVar(var_glojure_DOT_core_first) + tmp16 := lang.Apply(tmp15, []any{v6}) + tmp17 := lang.Apply(tmp14, []any{tmp16}) + if lang.IsTruthy(tmp17) { + tmp18 := checkDerefVar(var_glojure_DOT_core_first) + tmp19 := lang.Apply(tmp18, []any{v6}) + tmp20 := lang.NewMap(kw_doc, tmp19) + tmp21 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(297), kw_column, int(19), kw_end_DASH_line, int(297), kw_end_DASH_column, int(38)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 = tmp22 + } else { + tmp23 := lang.NewMap() + tmp24 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(298), kw_column, int(19), kw_end_DASH_line, int(298), kw_end_DASH_column, int(20)) + tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 = tmp25 + } + var v26 any = tmp13 + _ = v26 + // let binding "fdecl" + var tmp27 any + tmp28 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp29 := checkDerefVar(var_glojure_DOT_core_first) + tmp30 := lang.Apply(tmp29, []any{v6}) + tmp31 := lang.Apply(tmp28, []any{tmp30}) + if lang.IsTruthy(tmp31) { + tmp32 := checkDerefVar(var_glojure_DOT_core_next) + tmp33 := lang.Apply(tmp32, []any{v6}) + tmp27 = tmp33 + } else { + tmp27 = v6 + } + var v34 any = tmp27 + _ = v34 + // let binding "m" + var tmp35 any + tmp36 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp37 := checkDerefVar(var_glojure_DOT_core_first) + tmp38 := lang.Apply(tmp37, []any{v34}) + tmp39 := lang.Apply(tmp36, []any{tmp38}) + if lang.IsTruthy(tmp39) { + tmp40 := checkDerefVar(var_glojure_DOT_core_conj) + tmp41 := checkDerefVar(var_glojure_DOT_core_first) + tmp42 := lang.Apply(tmp41, []any{v34}) + tmp43 := lang.Apply(tmp40, []any{v26, tmp42}) + tmp35 = tmp43 + } else { + tmp35 = v26 + } + var v44 any = tmp35 + _ = v44 + // let binding "fdecl" + var tmp45 any + tmp46 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp47 := checkDerefVar(var_glojure_DOT_core_first) + tmp48 := lang.Apply(tmp47, []any{v34}) + tmp49 := lang.Apply(tmp46, []any{tmp48}) + if lang.IsTruthy(tmp49) { + tmp50 := checkDerefVar(var_glojure_DOT_core_next) + tmp51 := lang.Apply(tmp50, []any{v34}) + tmp45 = tmp51 + } else { + tmp45 = v34 + } + var v52 any = tmp45 + _ = v52 + // let binding "fdecl" + var tmp53 any + tmp54 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp55 := checkDerefVar(var_glojure_DOT_core_first) + tmp56 := lang.Apply(tmp55, []any{v52}) + tmp57 := lang.Apply(tmp54, []any{tmp56}) + if lang.IsTruthy(tmp57) { + tmp58 := checkDerefVar(var_glojure_DOT_core_list) + tmp59 := lang.Apply(tmp58, []any{v52}) + tmp53 = tmp59 + } else { + tmp53 = v52 + } + var v60 any = tmp53 + _ = v60 + // let binding "m" + var tmp61 any + tmp62 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp63 := checkDerefVar(var_glojure_DOT_core_last) + tmp64 := lang.Apply(tmp63, []any{v60}) + tmp65 := lang.Apply(tmp62, []any{tmp64}) + if lang.IsTruthy(tmp65) { + tmp66 := checkDerefVar(var_glojure_DOT_core_conj) + tmp67 := checkDerefVar(var_glojure_DOT_core_last) + tmp68 := lang.Apply(tmp67, []any{v60}) + tmp69 := lang.Apply(tmp66, []any{v44, tmp68}) + tmp61 = tmp69 + } else { + tmp61 = v44 + } + var v70 any = tmp61 + _ = v70 + // let binding "fdecl" + var tmp71 any + tmp72 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp73 := checkDerefVar(var_glojure_DOT_core_last) + tmp74 := lang.Apply(tmp73, []any{v60}) + tmp75 := lang.Apply(tmp72, []any{tmp74}) + if lang.IsTruthy(tmp75) { + tmp76 := checkDerefVar(var_glojure_DOT_core_butlast) + tmp77 := lang.Apply(tmp76, []any{v60}) + tmp71 = tmp77 + } else { + tmp71 = v60 + } + var v78 any = tmp71 + _ = v78 + // let binding "m" + tmp79 := checkDerefVar(var_glojure_DOT_core_conj) + tmp80 := checkDerefVar(var_glojure_DOT_core_list) + tmp81 := checkDerefVar(var_glojure_DOT_core_sigs) + tmp82 := lang.Apply(tmp81, []any{v78}) + tmp83 := lang.Apply(tmp80, []any{sym_quote, tmp82}) + tmp84 := lang.NewMap(kw_arglists, tmp83) + tmp85 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(317), kw_column, int(23), kw_end_DASH_line, int(317), kw_end_DASH_column, int(60)) + tmp86, err := lang.WithMeta(tmp84, tmp85.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp87 := lang.Apply(tmp79, []any{tmp86, v70}) + var v88 any = tmp87 + _ = v88 + // let binding "m" + var tmp89 any + { // let + // let binding "inline" + tmp90 := lang.Apply(kw_inline, []any{v88}) + var v91 any = tmp90 + _ = v91 + // let binding "ifn" + tmp92 := checkDerefVar(var_glojure_DOT_core_first) + tmp93 := lang.Apply(tmp92, []any{v91}) + var v94 any = tmp93 + _ = v94 + // let binding "iname" + tmp95 := checkDerefVar(var_glojure_DOT_core_second) + tmp96 := lang.Apply(tmp95, []any{v91}) + var v97 any = tmp96 + _ = v97 + var tmp98 any + var tmp99 any + tmp100 := lang.Apply(lang.Equiv, []any{sym_fn, v94}) + if lang.IsTruthy(tmp100) { + var tmp101 any + tmp102 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp103 := reflect.TypeOf((*lang.Symbol)(nil)) + tmp104 := lang.Apply(tmp102, []any{tmp103, v97}) + if lang.IsTruthy(tmp104) { + tmp101 = false + } else { + tmp101 = true + } + tmp99 = tmp101 + } else { + } + if lang.IsTruthy(tmp99) { + tmp105 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp106 := checkDerefVar(var_glojure_DOT_core_cons) + tmp107 := checkDerefVar(var_glojure_DOT_core_cons) + tmp108, ok := lang.FieldOrMethod(v5, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "Name"))) + } + var tmp109 any + switch reflect.TypeOf(tmp108).Kind() { + case reflect.Func: + tmp109 = lang.Apply(tmp108, nil) + default: + tmp109 = tmp108 + } + tmp110 := lang.Apply(lang.ConcatStrings, []any{tmp109, "__inliner"}) + tmp111 := lang.Apply(lang.NewSymbol, []any{tmp110}) + tmp112 := checkDerefVar(var_glojure_DOT_core_next) + tmp113 := lang.Apply(tmp112, []any{v91}) + tmp114 := lang.Apply(tmp107, []any{tmp111, tmp113}) + tmp115 := lang.Apply(tmp106, []any{v94, tmp114}) + tmp116 := lang.Apply(tmp105, []any{v88, kw_inline, tmp115}) + tmp98 = tmp116 + } else { + tmp98 = v88 + } + tmp89 = tmp98 + } // end let + var v90 any = tmp89 + _ = v90 + // let binding "m" + tmp91 := checkDerefVar(var_glojure_DOT_core_conj) + var tmp92 any + tmp93 := checkDerefVar(var_glojure_DOT_core_meta) + tmp94 := lang.Apply(tmp93, []any{v5}) + if lang.IsTruthy(tmp94) { + tmp95 := checkDerefVar(var_glojure_DOT_core_meta) + tmp96 := lang.Apply(tmp95, []any{v5}) + tmp92 = tmp96 + } else { + tmp97 := lang.NewMap() + tmp98 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(328), kw_column, int(51), kw_end_DASH_line, int(328), kw_end_DASH_column, int(52)) + tmp99, err := lang.WithMeta(tmp97, tmp98.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp92 = tmp99 + } + tmp100 := lang.Apply(tmp91, []any{tmp92, v90}) + var v101 any = tmp100 + _ = v101 + tmp102 := checkDerefVar(var_glojure_DOT_core_list) + tmp103 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp104 := lang.Apply(tmp103, []any{v5, v101}) + tmp105 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp106 := checkDerefVar(var_glojure_DOT_core_cons) + tmp107 := lang.Apply(tmp106, []any{sym_glojure_DOT_core_SLASH_fn, v78}) + tmp108 := lang.Apply(kw_tag, []any{v101}) + tmp109 := lang.NewMap(kw_rettag, tmp108) + tmp110 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(333), kw_column, int(37), kw_end_DASH_line, int(333), kw_end_DASH_column, int(54)) + tmp111, err := lang.WithMeta(tmp109, tmp110.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp112 := lang.Apply(tmp105, []any{tmp107, tmp111}) + tmp113 := lang.Apply(tmp102, []any{sym_def, tmp104, tmp112}) + tmp12 = tmp113 + } // end let + return tmp12 + } }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(291), kw_column, int(7), kw_end_DASH_line, int(333), kw_end_DASH_column, int(58))).(lang.FnFunc) v2 = tmp1 _ = v2 } - tmp0 := sym_shorts.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xs)), kw_inline, tmp1, kw_doc, "Casts to shorts[]", kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(12), kw_line, int(5387), kw_end_DASH_line, int(5387))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Shorts") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Shorts is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // shuffle - { - tmp0 := sym_shuffle.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Return a random permutation of coll", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(7300), kw_end_DASH_line, int(7300))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "al" - tmp5 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) - tmp6 := lang.Apply(tmp5, []any{v3}) - tmp7 := lang.Apply(lang.NewArrayList, []any{tmp6}) - var v8 any = tmp7 - _ = v8 - tmp9 := lang.Apply(nil, []any{v8}) - _ = tmp9 - tmp10, ok := lang.FieldOrMethod(v8, "toArray") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "toArray"))) - } - var tmp11 any - switch reflect.TypeOf(tmp10).Kind() { - case reflect.Func: - tmp11 = lang.Apply(tmp10, nil) - default: - tmp11 = tmp10 - } - tmp12 := lang.Apply(nil, []any{tmp11}) - tmp4 = tmp12 - } // end let - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // shutdown-agents - { - tmp0 := sym_shutdown_DASH_agents.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Initiates a shutdown of the thread pools that back the agent\n system. Running actions will complete, but no new actions will be\n accepted", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(2252), kw_end_DASH_line, int(2252))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - tmp3 := lang.Apply(lang.ShutdownAgents, nil) - return tmp3 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + var_glojure_DOT_core_defn = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_defn.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // sigs + // destructure { - tmp0 := sym_sigs.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(223), kw_column, int(2), kw_end_DASH_line, int(224), kw_end_DASH_column, int(5), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_destructure.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4400), kw_column, int(7), kw_end_DASH_line, int(4400), kw_end_DASH_column, int(17), kw_arglists, lang.NewList(lang.NewVector(sym_bindings)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_assert_DASH_valid_DASH_fdecl) - tmp5 := lang.Apply(tmp4, []any{v3}) - _ = tmp5 - var tmp6 any + v2 := args[0] + _ = v2 + var tmp3 any { // let - // let binding "asig" + // let binding "bents" + tmp4 := checkDerefVar(var_glojure_DOT_core_partition) + tmp5 := lang.Apply(tmp4, []any{int64(2), v2}) + var v6 any = tmp5 + _ = v6 + // let binding "pb" var tmp7 lang.FnFunc - tmp7 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v8 := args[0] - _ = v8 - var tmp9 any - { // let - // let binding "arglist" - tmp10 := checkDerefVar(var_glojure_DOT_core_first) - tmp11 := lang.Apply(tmp10, []any{v8}) - var v12 any = tmp11 - _ = v12 - // let binding "arglist" - var tmp13 any - tmp14 := checkDerefVar(var_glojure_DOT_core_first) - tmp15 := lang.Apply(tmp14, []any{v12}) - tmp16 := lang.Apply(lang.Equals, []any{sym__AMP_form, tmp15}) - if lang.IsTruthy(tmp16) { - tmp17 := lang.Apply(lang.Count, []any{v12}) - tmp18 := lang.Apply(lang.Subvec, []any{v12, int64(2), tmp17}) - tmp13 = tmp18 - } else { - tmp13 = v12 - } - var v19 any = tmp13 - _ = v19 - // let binding "body" - tmp20 := checkDerefVar(var_glojure_DOT_core_next) - tmp21 := lang.Apply(tmp20, []any{v8}) - var v22 any = tmp21 - _ = v22 - var tmp23 any - tmp24 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) - tmp25 := checkDerefVar(var_glojure_DOT_core_first) - tmp26 := lang.Apply(tmp25, []any{v22}) - tmp27 := lang.Apply(tmp24, []any{tmp26}) - if lang.IsTruthy(tmp27) { - var tmp28 any - tmp29 := checkDerefVar(var_glojure_DOT_core_next) - tmp30 := lang.Apply(tmp29, []any{v22}) - if lang.IsTruthy(tmp30) { - tmp31 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) - tmp32 := checkDerefVar(var_glojure_DOT_core_conj) - var tmp33 any - tmp34 := checkDerefVar(var_glojure_DOT_core_meta) - tmp35 := lang.Apply(tmp34, []any{v19}) - if lang.IsTruthy(tmp35) { - tmp36 := checkDerefVar(var_glojure_DOT_core_meta) - tmp37 := lang.Apply(tmp36, []any{v19}) - tmp33 = tmp37 - } else { - tmp38 := lang.NewMap() - tmp39 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(237), kw_column, int(77), kw_end_DASH_line, int(237), kw_end_DASH_column, int(78)) - tmp40, err := lang.WithMeta(tmp38, tmp39.(lang.IPersistentMap)) + { // function pb + var v8 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v9 := args[0] + _ = v9 + v10 := args[1] + _ = v10 + v11 := args[2] + _ = v11 + var tmp12 any + { // let + // let binding "pvec" + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v14 := args[0] + _ = v14 + v15 := args[1] + _ = v15 + v16 := args[2] + _ = v16 + var tmp17 any + { // let + // let binding "gvec" + tmp18 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp19 := lang.Apply(tmp18, []any{"vec__"}) + var v20 any = tmp19 + _ = v20 + // let binding "gseq" + tmp21 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp22 := lang.Apply(tmp21, []any{"seq__"}) + var v23 any = tmp22 + _ = v23 + // let binding "gfirst" + tmp24 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp25 := lang.Apply(tmp24, []any{"first__"}) + var v26 any = tmp25 + _ = v26 + // let binding "has-rest" + tmp27 := checkDerefVar(var_glojure_DOT_core_some) + tmp28 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{sym__AMP_})) + tmp29 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4408), kw_column, int(43), kw_end_DASH_line, int(4408), kw_end_DASH_column, int(47)) + tmp30, err := lang.WithMeta(tmp28, tmp29.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp33 = tmp40 - } - tmp41 := checkDerefVar(var_glojure_DOT_core_first) - tmp42 := lang.Apply(tmp41, []any{v22}) - tmp43 := lang.Apply(tmp32, []any{tmp33, tmp42}) - tmp44 := lang.Apply(tmp31, []any{v19, tmp43}) - tmp28 = tmp44 - } else { - tmp28 = v19 - } - tmp23 = tmp28 - } else { - tmp23 = v19 - } - tmp9 = tmp23 - } // end let - return tmp9 - }) - tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(228), kw_column, int(10), kw_end_DASH_line, int(239), kw_end_DASH_column, int(25)) - tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v10 any = tmp9 - _ = v10 - // let binding "resolve-tag" - var tmp11 lang.FnFunc - tmp11 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v12 := args[0] - _ = v12 - var tmp13 any - { // let - // let binding "m" - tmp14 := checkDerefVar(var_glojure_DOT_core_meta) - tmp15 := lang.Apply(tmp14, []any{v12}) - var v16 any = tmp15 - _ = v16 - // let binding "tag" - tmp17 := lang.Apply(kw_tag, []any{v16}) - var v18 any = tmp17 - _ = v18 - var tmp19 any - tmp20 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp21 := reflect.TypeOf((*lang.Symbol)(nil)) - tmp22 := lang.Apply(tmp20, []any{tmp21, v18}) - if lang.IsTruthy(tmp22) { - var tmp23 any - tmp24, ok := lang.FieldOrMethod(v18, "Name") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v18, "Name"))) - } - var tmp25 any - switch reflect.TypeOf(tmp24).Kind() { - case reflect.Func: - tmp25 = lang.Apply(tmp24, nil) - default: - tmp25 = tmp24 - } - tmp26 := lang.Apply(strings11.Index, []any{tmp25, "."}) - tmp27 := lang.Apply(lang.Equiv, []any{tmp26, int64(-1)}) - if lang.IsTruthy(tmp27) { - var tmp28 any - tmp29 := lang.Apply(lang.Equals, []any{nil, nil}) - if lang.IsTruthy(tmp29) { - var tmp30 any + tmp31 := lang.Apply(tmp27, []any{tmp30, v15}) + var v32 any = tmp31 + _ = v32 + var tmp33 any { // let - // let binding "c" - var v31 any = nil - _ = v31 - var tmp32 any - if lang.IsTruthy(v31) { - tmp33 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) - tmp34 := checkDerefVar(var_glojure_DOT_core_assoc) - tmp35, ok := lang.FieldOrMethod(v31, "Name") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v31, "Name"))) + // let binding "ret" + var tmp34 any + { // let + // let binding "ret" + tmp35 := checkDerefVar(var_glojure_DOT_core_conj) + tmp36 := lang.Apply(tmp35, []any{v14, v20, v16}) + var v37 any = tmp36 + _ = v37 + var tmp38 any + if lang.IsTruthy(v32) { + tmp39 := checkDerefVar(var_glojure_DOT_core_conj) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{sym_glojure_DOT_core_SLASH_seq, v20}) + tmp42 := lang.Apply(tmp39, []any{v37, v23, tmp41}) + tmp38 = tmp42 + } else { + tmp38 = v37 + } + tmp34 = tmp38 + } // end let + var v35 any = tmp34 + _ = v35 + // let binding "n" + var v36 any = int64(0) + _ = v36 + // let binding "bs" + var v37 any = v15 + _ = v37 + // let binding "seen-rest?" + var v38 any = false + _ = v38 + for { + var tmp39 any + tmp40 := checkDerefVar(var_glojure_DOT_core_seq) + tmp41 := lang.Apply(tmp40, []any{v37}) + if lang.IsTruthy(tmp41) { + var tmp42 any + { // let + // let binding "firstb" + tmp43 := checkDerefVar(var_glojure_DOT_core_first) + tmp44 := lang.Apply(tmp43, []any{v37}) + var v45 any = tmp44 + _ = v45 + var tmp46 any + tmp47 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp48 := lang.Apply(tmp47, []any{v45, sym__AMP_}) + if lang.IsTruthy(tmp48) { + tmp50 := checkDerefVar(var_glojure_DOT_core_second) + tmp51 := lang.Apply(tmp50, []any{v37}) + tmp52 := lang.Apply(v8, []any{v35, tmp51, v23}) + var tmp49 any = tmp52 + var tmp53 any = v36 + tmp55 := checkDerefVar(var_glojure_DOT_core_nnext) + tmp56 := lang.Apply(tmp55, []any{v37}) + var tmp54 any = tmp56 + var tmp57 any = true + v35 = tmp49 + v36 = tmp53 + v37 = tmp54 + v38 = tmp57 + continue + } else { + var tmp58 any + tmp59 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp60 := lang.Apply(tmp59, []any{v45, kw_as}) + if lang.IsTruthy(tmp60) { + tmp61 := checkDerefVar(var_glojure_DOT_core_second) + tmp62 := lang.Apply(tmp61, []any{v37}) + tmp63 := lang.Apply(v8, []any{v35, tmp62, v20}) + tmp58 = tmp63 + } else { + var tmp64 any + if lang.IsTruthy(kw_else) { + var tmp65 any + if lang.IsTruthy(v38) { + tmp66 := lang.Apply(errors8.New, []any{"Unsupported binding form, only :as can follow & parameter"}) + panic(tmp66) + } else { + var tmp68 any + if lang.IsTruthy(v32) { + tmp69 := checkDerefVar(var_glojure_DOT_core_conj) + tmp70 := checkDerefVar(var_glojure_DOT_core_seq) + tmp71 := checkDerefVar(var_glojure_DOT_core_concat) + tmp72 := checkDerefVar(var_glojure_DOT_core_list) + tmp73 := lang.Apply(tmp72, []any{sym_glojure_DOT_core_SLASH_first}) + tmp74 := checkDerefVar(var_glojure_DOT_core_list) + tmp75 := lang.Apply(tmp74, []any{v23}) + tmp76 := lang.Apply(tmp71, []any{tmp73, tmp75}) + tmp77 := lang.Apply(tmp70, []any{tmp76}) + tmp78 := checkDerefVar(var_glojure_DOT_core_seq) + tmp79 := checkDerefVar(var_glojure_DOT_core_concat) + tmp80 := checkDerefVar(var_glojure_DOT_core_list) + tmp81 := lang.Apply(tmp80, []any{sym_glojure_DOT_core_SLASH_next}) + tmp82 := checkDerefVar(var_glojure_DOT_core_list) + tmp83 := lang.Apply(tmp82, []any{v23}) + tmp84 := lang.Apply(tmp79, []any{tmp81, tmp83}) + tmp85 := lang.Apply(tmp78, []any{tmp84}) + tmp86 := lang.Apply(tmp69, []any{v35, v26, tmp77, v23, tmp85}) + tmp68 = tmp86 + } else { + tmp68 = v35 + } + var tmp87 any + if lang.IsTruthy(v32) { + tmp87 = v26 + } else { + tmp88 := checkDerefVar(var_glojure_DOT_core_list) + tmp89 := lang.Apply(tmp88, []any{sym_glojure_DOT_core_SLASH_nth, v20, v36, nil}) + tmp87 = tmp89 + } + tmp90 := lang.Apply(v8, []any{tmp68, v45, tmp87}) + var tmp67 any = tmp90 + tmp92 := checkDerefVar(var_glojure_DOT_core_inc) + tmp93 := lang.Apply(tmp92, []any{v36}) + var tmp91 any = tmp93 + tmp95 := checkDerefVar(var_glojure_DOT_core_next) + tmp96 := lang.Apply(tmp95, []any{v37}) + var tmp94 any = tmp96 + var tmp97 any = v38 + v35 = tmp67 + v36 = tmp91 + v37 = tmp94 + v38 = tmp97 + continue + } + tmp64 = tmp65 + } else { + } + tmp58 = tmp64 + } + tmp46 = tmp58 + } + tmp42 = tmp46 + } // end let + tmp39 = tmp42 + } else { + tmp39 = v35 } + tmp33 = tmp39 + break + } + } // end let + tmp17 = tmp33 + } // end let + return tmp17 + }) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4404), kw_column, int(20), kw_end_DASH_line, int(4438), kw_end_DASH_column, int(34)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v16 any = tmp15 + _ = v16 + // let binding "pmap" + var tmp17 lang.FnFunc + tmp17 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v18 := args[0] + _ = v18 + v19 := args[1] + _ = v19 + v20 := args[2] + _ = v20 + var tmp21 any + { // let + // let binding "gmap" + tmp22 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp23 := lang.Apply(tmp22, []any{"map__"}) + var v24 any = tmp23 + _ = v24 + // let binding "gmapseq" + tmp25 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp26 := lang.NewMap(kw_tag, sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_ISeq) + tmp27 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4442), kw_column, int(52), kw_end_DASH_line, int(4442), kw_end_DASH_column, int(103)) + tmp28, err := lang.WithMeta(tmp26, tmp27.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp29 := lang.Apply(tmp25, []any{v24, tmp28}) + var v30 any = tmp29 + _ = v30 + // let binding "defaults" + tmp31 := lang.Apply(kw_or, []any{v19}) + var v32 any = tmp31 + _ = v32 + var tmp33 any + { // let + // let binding "ret" + var tmp34 lang.FnFunc + tmp34 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v35 := args[0] + _ = v35 var tmp36 any - switch reflect.TypeOf(tmp35).Kind() { - case reflect.Func: - tmp36 = lang.Apply(tmp35, nil) - default: - tmp36 = tmp35 + tmp37 := lang.Apply(kw_as, []any{v19}) + if lang.IsTruthy(tmp37) { + tmp38 := checkDerefVar(var_glojure_DOT_core_conj) + tmp39 := lang.Apply(kw_as, []any{v19}) + tmp40 := lang.Apply(tmp38, []any{v35, tmp39, v24}) + tmp36 = tmp40 + } else { + tmp36 = v35 + } + return tmp36 + }) + tmp35 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4450), kw_column, int(40), kw_end_DASH_line, int(4453), kw_end_DASH_column, int(48)) + tmp36, err := lang.WithMeta(tmp34, tmp35.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp37 := checkDerefVar(var_glojure_DOT_core_conj) + tmp38 := checkDerefVar(var_glojure_DOT_core_conj) + tmp39 := checkDerefVar(var_glojure_DOT_core_conj) + tmp40 := checkDerefVar(var_glojure_DOT_core_conj) + tmp41 := lang.Apply(tmp40, []any{v18, v24}) + tmp42 := lang.Apply(tmp39, []any{tmp41, v20}) + tmp43 := lang.Apply(tmp38, []any{tmp42, v24}) + tmp44 := checkDerefVar(var_glojure_DOT_core_seq) + tmp45 := checkDerefVar(var_glojure_DOT_core_concat) + tmp46 := checkDerefVar(var_glojure_DOT_core_list) + tmp47 := lang.Apply(tmp46, []any{sym_if}) + tmp48 := checkDerefVar(var_glojure_DOT_core_list) + tmp49 := checkDerefVar(var_glojure_DOT_core_seq) + tmp50 := checkDerefVar(var_glojure_DOT_core_concat) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := lang.Apply(tmp51, []any{sym_glojure_DOT_core_SLASH_seq_QMARK_}) + tmp53 := checkDerefVar(var_glojure_DOT_core_list) + tmp54 := lang.Apply(tmp53, []any{v24}) + tmp55 := lang.Apply(tmp50, []any{tmp52, tmp54}) + tmp56 := lang.Apply(tmp49, []any{tmp55}) + tmp57 := lang.Apply(tmp48, []any{tmp56}) + tmp58 := checkDerefVar(var_glojure_DOT_core_list) + tmp59 := checkDerefVar(var_glojure_DOT_core_seq) + tmp60 := checkDerefVar(var_glojure_DOT_core_concat) + tmp61 := checkDerefVar(var_glojure_DOT_core_list) + tmp62 := lang.Apply(tmp61, []any{sym_if}) + tmp63 := checkDerefVar(var_glojure_DOT_core_list) + tmp64 := checkDerefVar(var_glojure_DOT_core_seq) + tmp65 := checkDerefVar(var_glojure_DOT_core_concat) + tmp66 := checkDerefVar(var_glojure_DOT_core_list) + tmp67 := lang.Apply(tmp66, []any{sym_glojure_DOT_core_SLASH_next}) + tmp68 := checkDerefVar(var_glojure_DOT_core_list) + tmp69 := lang.Apply(tmp68, []any{v30}) + tmp70 := lang.Apply(tmp65, []any{tmp67, tmp69}) + tmp71 := lang.Apply(tmp64, []any{tmp70}) + tmp72 := lang.Apply(tmp63, []any{tmp71}) + tmp73 := checkDerefVar(var_glojure_DOT_core_list) + tmp74 := checkDerefVar(var_glojure_DOT_core_seq) + tmp75 := checkDerefVar(var_glojure_DOT_core_concat) + tmp76 := checkDerefVar(var_glojure_DOT_core_list) + tmp77 := lang.Apply(tmp76, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_NewPersistentArrayMapAsIfByAssoc}) + tmp78 := checkDerefVar(var_glojure_DOT_core_list) + tmp79 := checkDerefVar(var_glojure_DOT_core_seq) + tmp80 := checkDerefVar(var_glojure_DOT_core_concat) + tmp81 := checkDerefVar(var_glojure_DOT_core_list) + tmp82 := lang.Apply(tmp81, []any{sym_glojure_DOT_core_SLASH_to_DASH_array}) + tmp83 := checkDerefVar(var_glojure_DOT_core_list) + tmp84 := lang.Apply(tmp83, []any{v30}) + tmp85 := lang.Apply(tmp80, []any{tmp82, tmp84}) + tmp86 := lang.Apply(tmp79, []any{tmp85}) + tmp87 := lang.Apply(tmp78, []any{tmp86}) + tmp88 := lang.Apply(tmp75, []any{tmp77, tmp87}) + tmp89 := lang.Apply(tmp74, []any{tmp88}) + tmp90 := lang.Apply(tmp73, []any{tmp89}) + tmp91 := checkDerefVar(var_glojure_DOT_core_list) + tmp92 := checkDerefVar(var_glojure_DOT_core_seq) + tmp93 := checkDerefVar(var_glojure_DOT_core_concat) + tmp94 := checkDerefVar(var_glojure_DOT_core_list) + tmp95 := lang.Apply(tmp94, []any{sym_if}) + tmp96 := checkDerefVar(var_glojure_DOT_core_list) + tmp97 := checkDerefVar(var_glojure_DOT_core_seq) + tmp98 := checkDerefVar(var_glojure_DOT_core_concat) + tmp99 := checkDerefVar(var_glojure_DOT_core_list) + tmp100 := lang.Apply(tmp99, []any{sym_glojure_DOT_core_SLASH_seq}) + tmp101 := checkDerefVar(var_glojure_DOT_core_list) + tmp102 := lang.Apply(tmp101, []any{v30}) + tmp103 := lang.Apply(tmp98, []any{tmp100, tmp102}) + tmp104 := lang.Apply(tmp97, []any{tmp103}) + tmp105 := lang.Apply(tmp96, []any{tmp104}) + tmp106 := checkDerefVar(var_glojure_DOT_core_list) + tmp107 := checkDerefVar(var_glojure_DOT_core_seq) + tmp108 := checkDerefVar(var_glojure_DOT_core_concat) + tmp109 := checkDerefVar(var_glojure_DOT_core_list) + tmp110 := lang.Apply(tmp109, []any{sym_glojure_DOT_core_SLASH_first}) + tmp111 := checkDerefVar(var_glojure_DOT_core_list) + tmp112 := lang.Apply(tmp111, []any{v30}) + tmp113 := lang.Apply(tmp108, []any{tmp110, tmp112}) + tmp114 := lang.Apply(tmp107, []any{tmp113}) + tmp115 := lang.Apply(tmp106, []any{tmp114}) + tmp116 := checkDerefVar(var_glojure_DOT_core_list) + tmp117 := lang.Apply(tmp116, []any{sym_glojure_DOT_lang_DOT_PersistentArrayMap_SLASH_EMPTY}) + tmp118 := lang.Apply(tmp93, []any{tmp95, tmp105, tmp115, tmp117}) + tmp119 := lang.Apply(tmp92, []any{tmp118}) + tmp120 := lang.Apply(tmp91, []any{tmp119}) + tmp121 := lang.Apply(tmp60, []any{tmp62, tmp72, tmp90, tmp120}) + tmp122 := lang.Apply(tmp59, []any{tmp121}) + tmp123 := lang.Apply(tmp58, []any{tmp122}) + tmp124 := checkDerefVar(var_glojure_DOT_core_list) + tmp125 := lang.Apply(tmp124, []any{v24}) + tmp126 := lang.Apply(tmp45, []any{tmp47, tmp57, tmp123, tmp125}) + tmp127 := lang.Apply(tmp44, []any{tmp126}) + tmp128 := lang.Apply(tmp37, []any{tmp43, tmp127}) + tmp129 := lang.Apply(tmp36, []any{tmp128}) + var v130 any = tmp129 + _ = v130 + // let binding "bes" + var tmp131 any + { // let + // let binding "transforms" + tmp132 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp133 lang.FnFunc + tmp133 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v134 := args[0] + _ = v134 + v135 := args[1] + _ = v135 + var tmp136 any + tmp137 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp138 := lang.Apply(tmp137, []any{v135}) + if lang.IsTruthy(tmp138) { + var tmp139 any + { // let + // let binding "mkns" + tmp140 := checkDerefVar(var_glojure_DOT_core_namespace) + tmp141 := lang.Apply(tmp140, []any{v135}) + var v142 any = tmp141 + _ = v142 + // let binding "mkn" + tmp143 := checkDerefVar(var_glojure_DOT_core_name) + tmp144 := lang.Apply(tmp143, []any{v135}) + var v145 any = tmp144 + _ = v145 + var tmp146 any + tmp147 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp148 := lang.Apply(tmp147, []any{v145, "keys"}) + if lang.IsTruthy(tmp148) { + tmp149 := checkDerefVar(var_glojure_DOT_core_assoc) + var tmp150 lang.FnFunc + tmp150 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v151 := args[0] + _ = v151 + tmp152 := checkDerefVar(var_glojure_DOT_core_keyword) + var tmp153 any + { // let + // let binding "or__0__auto__" + var v154 any = v142 + _ = v154 + var tmp155 any + if lang.IsTruthy(v154) { + tmp155 = v154 + } else { + tmp156 := checkDerefVar(var_glojure_DOT_core_namespace) + tmp157 := lang.Apply(tmp156, []any{v151}) + tmp155 = tmp157 + } + tmp153 = tmp155 + } // end let + tmp154 := checkDerefVar(var_glojure_DOT_core_name) + tmp155 := lang.Apply(tmp154, []any{v151}) + tmp156 := lang.Apply(tmp152, []any{tmp153, tmp155}) + return tmp156 + }) + tmp151 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4460), kw_column, int(93), kw_end_DASH_line, int(4460), kw_end_DASH_column, int(135)) + tmp152, err := lang.WithMeta(tmp150, tmp151.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp153 := lang.Apply(tmp149, []any{v134, v135, tmp152}) + tmp146 = tmp153 + } else { + var tmp154 any + tmp155 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp156 := lang.Apply(tmp155, []any{v145, "syms"}) + if lang.IsTruthy(tmp156) { + tmp157 := checkDerefVar(var_glojure_DOT_core_assoc) + var tmp158 lang.FnFunc + tmp158 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v159 := args[0] + _ = v159 + tmp160 := checkDerefVar(var_glojure_DOT_core_list) + tmp161 := checkDerefVar(var_glojure_DOT_core_symbol) + var tmp162 any + { // let + // let binding "or__0__auto__" + var v163 any = v142 + _ = v163 + var tmp164 any + if lang.IsTruthy(v163) { + tmp164 = v163 + } else { + tmp165 := checkDerefVar(var_glojure_DOT_core_namespace) + tmp166 := lang.Apply(tmp165, []any{v159}) + tmp164 = tmp166 + } + tmp162 = tmp164 + } // end let + tmp163 := checkDerefVar(var_glojure_DOT_core_name) + tmp164 := lang.Apply(tmp163, []any{v159}) + tmp165 := lang.Apply(tmp161, []any{tmp162, tmp164}) + tmp166 := lang.Apply(tmp160, []any{sym_quote, tmp165}) + return tmp166 + }) + tmp159 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4461), kw_column, int(93), kw_end_DASH_line, int(4461), kw_end_DASH_column, int(148)) + tmp160, err := lang.WithMeta(tmp158, tmp159.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp161 := lang.Apply(tmp157, []any{v134, v135, tmp160}) + tmp154 = tmp161 + } else { + var tmp162 any + tmp163 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp164 := lang.Apply(tmp163, []any{v145, "strs"}) + if lang.IsTruthy(tmp164) { + tmp165 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp166 := checkDerefVar(var_glojure_DOT_core_str) + tmp167 := lang.Apply(tmp165, []any{v134, v135, tmp166}) + tmp162 = tmp167 + } else { + var tmp168 any + if lang.IsTruthy(kw_else) { + tmp168 = v134 + } else { + } + tmp162 = tmp168 + } + tmp154 = tmp162 + } + tmp146 = tmp154 + } + tmp139 = tmp146 + } // end let + tmp136 = tmp139 + } else { + tmp136 = v134 + } + return tmp136 + }) + tmp134 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4456), kw_column, int(45), kw_end_DASH_line, int(4464), kw_end_DASH_column, int(60)) + tmp135, err := lang.WithMeta(tmp133, tmp134.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp136 := lang.NewMap() + tmp137 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4465), kw_column, int(45), kw_end_DASH_line, int(4465), kw_end_DASH_column, int(46)) + tmp138, err := lang.WithMeta(tmp136, tmp137.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp139 := checkDerefVar(var_glojure_DOT_core_keys) + tmp140 := lang.Apply(tmp139, []any{v19}) + tmp141 := lang.Apply(tmp132, []any{tmp135, tmp138, tmp140}) + var v142 any = tmp141 + _ = v142 + tmp143 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp144 lang.FnFunc + tmp144 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v145 := args[0] + _ = v145 + v146 := args[1] + _ = v146 + tmp147 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp148 lang.FnFunc + tmp148 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v149 := args[0] + _ = v149 + v150 := args[1] + _ = v150 + tmp151 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp152 := checkDerefVar(var_glojure_DOT_core_val) + tmp153 := lang.Apply(tmp152, []any{v146}) + tmp154 := lang.Apply(tmp153, []any{v150}) + tmp155 := lang.Apply(tmp151, []any{v149, v150, tmp154}) + return tmp155 + }) + tmp149 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4469), kw_column, int(52), kw_end_DASH_line, int(4469), kw_end_DASH_column, int(82)) + tmp150, err := lang.WithMeta(tmp148, tmp149.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp151 := checkDerefVar(var_glojure_DOT_core_dissoc) + tmp152 := checkDerefVar(var_glojure_DOT_core_key) + tmp153 := lang.Apply(tmp152, []any{v146}) + tmp154 := lang.Apply(tmp151, []any{v145, tmp153}) + tmp155 := checkDerefVar(var_glojure_DOT_core_key) + tmp156 := lang.Apply(tmp155, []any{v146}) + tmp157 := lang.Apply(tmp156, []any{v145}) + tmp158 := lang.Apply(tmp147, []any{tmp150, tmp154, tmp157}) + return tmp158 + }) + tmp145 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4468), kw_column, int(41), kw_end_DASH_line, int(4471), kw_end_DASH_column, int(70)) + tmp146, err := lang.WithMeta(tmp144, tmp145.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp147 := checkDerefVar(var_glojure_DOT_core_dissoc) + tmp148 := lang.Apply(tmp147, []any{v19, kw_as, kw_or}) + tmp149 := lang.Apply(tmp143, []any{tmp146, tmp148, v142}) + tmp131 = tmp149 + } // end let + var v132 any = tmp131 + _ = v132 + for { + var tmp133 any + tmp134 := checkDerefVar(var_glojure_DOT_core_seq) + tmp135 := lang.Apply(tmp134, []any{v132}) + if lang.IsTruthy(tmp135) { + var tmp136 any + { // let + // let binding "bb" + tmp137 := checkDerefVar(var_glojure_DOT_core_key) + tmp138 := checkDerefVar(var_glojure_DOT_core_first) + tmp139 := lang.Apply(tmp138, []any{v132}) + tmp140 := lang.Apply(tmp137, []any{tmp139}) + var v141 any = tmp140 + _ = v141 + // let binding "bk" + tmp142 := checkDerefVar(var_glojure_DOT_core_val) + tmp143 := checkDerefVar(var_glojure_DOT_core_first) + tmp144 := lang.Apply(tmp143, []any{v132}) + tmp145 := lang.Apply(tmp142, []any{tmp144}) + var v146 any = tmp145 + _ = v146 + // let binding "local" + var tmp147 any + tmp148 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp149 := reflect.TypeOf((*lang.Named)(nil)).Elem() + tmp150 := lang.Apply(tmp148, []any{tmp149, v141}) + if lang.IsTruthy(tmp150) { + tmp151 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp152 := checkDerefVar(var_glojure_DOT_core_symbol) + tmp153 := checkDerefVar(var_glojure_DOT_core_name) + tmp154 := lang.Apply(tmp153, []any{v141}) + tmp155 := lang.Apply(tmp152, []any{nil, tmp154}) + tmp156 := checkDerefVar(var_glojure_DOT_core_meta) + tmp157 := lang.Apply(tmp156, []any{v141}) + tmp158 := lang.Apply(tmp151, []any{tmp155, tmp157}) + tmp147 = tmp158 + } else { + tmp147 = v141 + } + var v159 any = tmp147 + _ = v159 + // let binding "bv" + var tmp160 any + tmp161 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp162 := lang.Apply(tmp161, []any{v32, v159}) + if lang.IsTruthy(tmp162) { + tmp163 := checkDerefVar(var_glojure_DOT_core_list) + tmp164 := lang.Apply(v32, []any{v159}) + tmp165 := lang.Apply(tmp163, []any{sym_glojure_DOT_core_SLASH_get, v24, v146, tmp164}) + tmp160 = tmp165 + } else { + tmp166 := checkDerefVar(var_glojure_DOT_core_list) + tmp167 := lang.Apply(tmp166, []any{sym_glojure_DOT_core_SLASH_get, v24, v146}) + tmp160 = tmp167 + } + var v168 any = tmp160 + _ = v168 + var tmp170 any + tmp171 := checkDerefVar(var_glojure_DOT_core_ident_QMARK_) + tmp172 := lang.Apply(tmp171, []any{v141}) + if lang.IsTruthy(tmp172) { + tmp173 := checkDerefVar(var_glojure_DOT_core_conj) + tmp174 := lang.Apply(tmp173, []any{v130, v159, v168}) + tmp170 = tmp174 + } else { + tmp175 := lang.Apply(v8, []any{v130, v141, v168}) + tmp170 = tmp175 + } + var tmp169 any = tmp170 + tmp177 := checkDerefVar(var_glojure_DOT_core_next) + tmp178 := lang.Apply(tmp177, []any{v132}) + var tmp176 any = tmp178 + v130 = tmp169 + v132 = tmp176 + continue + } // end let + tmp133 = tmp136 + } else { + tmp133 = v130 } - tmp37 := lang.Apply(lang.NewSymbol, []any{tmp36}) - tmp38 := lang.Apply(tmp34, []any{v16, kw_tag, tmp37}) - tmp39 := lang.Apply(tmp33, []any{v12, tmp38}) - tmp32 = tmp39 + tmp33 = tmp133 + break + } + } // end let + tmp21 = tmp33 + } // end let + return tmp21 + }) + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4440), kw_column, int(20), kw_end_DASH_line, int(4485), kw_end_DASH_column, int(34)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v20 any = tmp19 + _ = v20 + var tmp21 any + tmp22 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp23 := lang.Apply(tmp22, []any{v10}) + if lang.IsTruthy(tmp23) { + tmp24 := checkDerefVar(var_glojure_DOT_core_conj) + tmp25 := checkDerefVar(var_glojure_DOT_core_conj) + tmp26 := lang.Apply(tmp25, []any{v9, v10}) + tmp27 := lang.Apply(tmp24, []any{tmp26, v11}) + tmp21 = tmp27 + } else { + var tmp28 any + tmp29 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp30 := lang.Apply(tmp29, []any{v10}) + if lang.IsTruthy(tmp30) { + tmp31 := lang.Apply(v16, []any{v9, v10, v11}) + tmp28 = tmp31 + } else { + var tmp32 any + tmp33 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp34 := lang.Apply(tmp33, []any{v10}) + if lang.IsTruthy(tmp34) { + tmp35 := lang.Apply(v20, []any{v9, v10, v11}) + tmp32 = tmp35 + } else { + var tmp36 any + if lang.IsTruthy(kw_else) { + tmp37 := checkDerefVar(var_glojure_DOT_core_str) + tmp38 := lang.Apply(tmp37, []any{"Unsupported binding form: ", v10}) + tmp39 := lang.Apply(errors8.New, []any{tmp38}) + panic(tmp39) } else { - tmp32 = v12 } - tmp30 = tmp32 - } // end let - tmp28 = tmp30 - } else { - tmp28 = v12 + tmp32 = tmp36 + } + tmp28 = tmp32 } - tmp23 = tmp28 - } else { - tmp23 = v12 + tmp21 = tmp28 } - tmp19 = tmp23 - } else { - tmp19 = v12 - } - tmp13 = tmp19 - } // end let - return tmp13 + tmp12 = tmp21 + } // end let + return tmp12 + }) + v8 = tmp7 + _ = v8 + } + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4402), kw_column, int(12), kw_end_DASH_line, int(4490), kw_end_DASH_column, int(82)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v10 any = tmp9 + _ = v10 + // let binding "process-entry" + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v12 := args[0] + _ = v12 + v13 := args[1] + _ = v13 + tmp14 := checkDerefVar(var_glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v13}) + tmp16 := checkDerefVar(var_glojure_DOT_core_second) + tmp17 := lang.Apply(tmp16, []any{v13}) + tmp18 := lang.Apply(v10, []any{v12, tmp15, tmp17}) + return tmp18 }) - tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(240), kw_column, int(22), kw_end_DASH_line, int(252), kw_end_DASH_column, int(37)) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4491), kw_column, int(23), kw_end_DASH_line, int(4491), kw_end_DASH_column, int(66)) tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) if err != nil { panic(err) @@ -48823,5826 +45877,8757 @@ func LoadNS() { var v14 any = tmp13 _ = v14 var tmp15 any - tmp16 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) - tmp17 := checkDerefVar(var_glojure_DOT_core_first) - tmp18 := lang.Apply(tmp17, []any{v3}) - tmp19 := lang.Apply(tmp16, []any{tmp18}) - if lang.IsTruthy(tmp19) { - var tmp20 any - { // let - // let binding "ret" - tmp21 := lang.NewVector() - tmp22 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(254), kw_column, int(19), kw_end_DASH_line, int(254), kw_end_DASH_column, int(20)) - tmp23, err := lang.WithMeta(tmp21, tmp22.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v24 any = tmp23 - _ = v24 - // let binding "fdecls" - var v25 any = v3 - _ = v25 - for { - var tmp26 any - if lang.IsTruthy(v25) { - tmp28 := checkDerefVar(var_glojure_DOT_core_conj) - tmp29 := checkDerefVar(var_glojure_DOT_core_first) - tmp30 := lang.Apply(tmp29, []any{v25}) - tmp31 := lang.Apply(v10, []any{tmp30}) - tmp32 := lang.Apply(v14, []any{tmp31}) - tmp33 := lang.Apply(tmp28, []any{v24, tmp32}) - var tmp27 any = tmp33 - tmp35 := checkDerefVar(var_glojure_DOT_core_next) - tmp36 := lang.Apply(tmp35, []any{v25}) - var tmp34 any = tmp36 - v24 = tmp27 - v25 = tmp34 - continue - } else { - tmp37 := checkDerefVar(var_glojure_DOT_core_seq) - tmp38 := lang.Apply(tmp37, []any{v24}) - tmp26 = tmp38 - } - tmp20 = tmp26 - break - } - } // end let - tmp15 = tmp20 - } else { - tmp21 := checkDerefVar(var_glojure_DOT_core_list) - tmp22 := lang.Apply(v10, []any{v3}) - tmp23 := lang.Apply(v14, []any{tmp22}) - tmp24 := lang.Apply(tmp21, []any{tmp23}) - tmp15 = tmp24 - } - tmp6 = tmp15 - } // end let - return tmp6 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(225), kw_column, int(2), kw_end_DASH_line, int(258), kw_end_DASH_column, int(43))).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // simple-ident? - { - tmp0 := sym_simple_DASH_ident_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a symbol or keyword without a namespace", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(1613), kw_end_DASH_line, int(1613))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "and__0__auto__" - tmp5 := checkDerefVar(var_glojure_DOT_core_ident_QMARK_) - tmp6 := lang.Apply(tmp5, []any{v3}) - var v7 any = tmp6 - _ = v7 - var tmp8 any - if lang.IsTruthy(v7) { - tmp9 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) - tmp10 := checkDerefVar(var_glojure_DOT_core_namespace) - tmp11 := lang.Apply(tmp10, []any{v3}) - tmp12 := lang.Apply(tmp9, []any{tmp11}) - tmp8 = tmp12 - } else { - tmp8 = v7 - } - tmp4 = tmp8 - } // end let - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // simple-keyword? - { - tmp0 := sym_simple_DASH_keyword_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a keyword without a namespace", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(1633), kw_end_DASH_line, int(1633))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "and__0__auto__" - tmp5 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) - tmp6 := lang.Apply(tmp5, []any{v3}) - var v7 any = tmp6 - _ = v7 - var tmp8 any - if lang.IsTruthy(v7) { - tmp9 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) - tmp10 := checkDerefVar(var_glojure_DOT_core_namespace) - tmp11 := lang.Apply(tmp10, []any{v3}) - tmp12 := lang.Apply(tmp9, []any{tmp11}) - tmp8 = tmp12 - } else { - tmp8 = v7 - } - tmp4 = tmp8 - } // end let - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // simple-symbol? - { - tmp0 := sym_simple_DASH_symbol_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a symbol without a namespace", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(1623), kw_end_DASH_line, int(1623))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "and__0__auto__" - tmp5 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) - tmp6 := lang.Apply(tmp5, []any{v3}) - var v7 any = tmp6 - _ = v7 - var tmp8 any - if lang.IsTruthy(v7) { - tmp9 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) - tmp10 := checkDerefVar(var_glojure_DOT_core_namespace) - tmp11 := lang.Apply(tmp10, []any{v3}) - tmp12 := lang.Apply(tmp9, []any{tmp11}) - tmp8 = tmp12 - } else { - tmp8 = v7 - } - tmp4 = tmp8 - } // end let - return tmp4 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // slurp - { - tmp1 := reflect.TypeOf("") - tmp0 := sym_slurp.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_f, sym__AMP_, sym_opts)), kw_doc, "Opens a reader on f and reads all its contents, returning a string.\n See glojure.java.io/reader for a complete list of supported arguments.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(6982), kw_end_DASH_line, int(6982))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 1) - v4 := args[0] - _ = v4 - var v5 any = lang.NewList(args[1:]...) - _ = v5 - var tmp6 any - { // let - // let binding "opts" - tmp7 := checkDerefVar(var_glojure_DOT_core_normalize_DASH_slurp_DASH_opts) - tmp8 := lang.Apply(tmp7, []any{v5}) - var v9 any = tmp8 - _ = v9 - // let binding "sw" - var v10 any = "unimplemented: new with non-constant class type" - _ = v10 - var tmp11 any - { // let - // let binding "r" - tmp12 := checkDerefVar(var_glojure_DOT_core_apply) - tmp13 := checkDerefVar(var_glojure_DOT_go_DOT_io_reader) - tmp14 := lang.Apply(tmp12, []any{tmp13, v4, v9}) - var v15 any = tmp14 - _ = v15 - var tmp16 any - func() { - defer func() { - tmp17, ok := lang.FieldOrMethod(v15, "close") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v15, "close"))) - } - var tmp18 any - switch reflect.TypeOf(tmp17).Kind() { - case reflect.Func: - tmp18 = lang.Apply(tmp17, nil) - default: - tmp18 = tmp17 - } - _ = tmp18 - }() - tmp19 := checkDerefVar(var_glojure_DOT_go_DOT_io_copy) - tmp20 := lang.Apply(tmp19, []any{v15, v10}) - _ = tmp20 - tmp21 := lang.Apply(lang.ToString, []any{v10}) - tmp16 = tmp21 - }() - tmp11 = tmp16 - } // end let - tmp6 = tmp11 - } // end let - return tmp6 - } - }) - tmp4 := reflect.TypeOf("") - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // some - { - tmp0 := sym_some.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns the first logical true value of (pred x) for any x in coll,\n else nil. One common idiom is to use a set as pred, for example\n this will return :fred if :fred is in the sequence, otherwise nil:\n (some #{:fred} coll)", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(2684), kw_end_DASH_line, int(2684))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - recur_loop_481: - var tmp5 any - { // let - // let binding "temp__0__auto__" - tmp6 := checkDerefVar(var_glojure_DOT_core_seq) - tmp7 := lang.Apply(tmp6, []any{v4}) - var v8 any = tmp7 - _ = v8 - var tmp9 any - if lang.IsTruthy(v8) { - var tmp10 any - { // let - // let binding "s" - var v11 any = v8 - _ = v11 - var tmp12 any - { // let - // let binding "or__0__auto__" - tmp13 := checkDerefVar(var_glojure_DOT_core_first) - tmp14 := lang.Apply(tmp13, []any{v11}) - tmp15 := lang.Apply(v3, []any{tmp14}) - var v16 any = tmp15 - _ = v16 - var tmp17 any - if lang.IsTruthy(v16) { - tmp17 = v16 - } else { - var tmp18 any = v3 - tmp20 := checkDerefVar(var_glojure_DOT_core_next) - tmp21 := lang.Apply(tmp20, []any{v11}) - var tmp19 any = tmp21 - v3 = tmp18 - v4 = tmp19 - goto recur_loop_481 - } - tmp12 = tmp17 - } // end let - tmp10 = tmp12 - } // end let - tmp9 = tmp10 + tmp16 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + tmp17 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp18 := checkDerefVar(var_glojure_DOT_core_map) + tmp19 := checkDerefVar(var_glojure_DOT_core_first) + tmp20 := lang.Apply(tmp18, []any{tmp19, v6}) + tmp21 := lang.Apply(tmp16, []any{tmp17, tmp20}) + if lang.IsTruthy(tmp21) { + tmp15 = v2 } else { - } - tmp5 = tmp9 - } // end let - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // some-> - { - tmp0 := sym_some_DASH__GT_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_expr, sym__AMP_, sym_forms)), kw_doc, "When expr is not nil, threads it into the first form (via ->),\n and when that result is not nil, through the next etc", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(11), kw_line, int(7610), kw_end_DASH_line, int(7610))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 3) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any - { // let - // let binding "g" - tmp8 := checkDerefVar(var_glojure_DOT_core_gensym) - tmp9 := lang.Apply(tmp8, nil) - var v10 any = tmp9 - _ = v10 - // let binding "steps" - tmp11 := checkDerefVar(var_glojure_DOT_core_map) - var tmp12 lang.FnFunc - tmp12 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v13 := args[0] - _ = v13 - tmp14 := checkDerefVar(var_glojure_DOT_core_seq) - tmp15 := checkDerefVar(var_glojure_DOT_core_concat) - tmp16 := checkDerefVar(var_glojure_DOT_core_list) - tmp17 := lang.Apply(tmp16, []any{sym_if}) - tmp18 := checkDerefVar(var_glojure_DOT_core_list) - tmp19 := checkDerefVar(var_glojure_DOT_core_seq) - tmp20 := checkDerefVar(var_glojure_DOT_core_concat) - tmp21 := checkDerefVar(var_glojure_DOT_core_list) - tmp22 := lang.Apply(tmp21, []any{sym_glojure_DOT_core_SLASH_nil_QMARK_}) - tmp23 := checkDerefVar(var_glojure_DOT_core_list) - tmp24 := lang.Apply(tmp23, []any{v10}) - tmp25 := lang.Apply(tmp20, []any{tmp22, tmp24}) - tmp26 := lang.Apply(tmp19, []any{tmp25}) - tmp27 := lang.Apply(tmp18, []any{tmp26}) - tmp28 := checkDerefVar(var_glojure_DOT_core_list) - tmp29 := lang.Apply(tmp28, []any{nil}) - tmp30 := checkDerefVar(var_glojure_DOT_core_list) - tmp31 := checkDerefVar(var_glojure_DOT_core_seq) - tmp32 := checkDerefVar(var_glojure_DOT_core_concat) - tmp33 := checkDerefVar(var_glojure_DOT_core_list) - tmp34 := lang.Apply(tmp33, []any{sym_glojure_DOT_core_SLASH__DASH__GT_}) - tmp35 := checkDerefVar(var_glojure_DOT_core_list) - tmp36 := lang.Apply(tmp35, []any{v10}) - tmp37 := checkDerefVar(var_glojure_DOT_core_list) - tmp38 := lang.Apply(tmp37, []any{v13}) - tmp39 := lang.Apply(tmp32, []any{tmp34, tmp36, tmp38}) - tmp40 := lang.Apply(tmp31, []any{tmp39}) - tmp41 := lang.Apply(tmp30, []any{tmp40}) - tmp42 := lang.Apply(tmp15, []any{tmp17, tmp27, tmp29, tmp41}) - tmp43 := lang.Apply(tmp14, []any{tmp42}) - return tmp43 - }) - tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7616), kw_column, int(20), kw_end_DASH_line, int(7616), kw_end_DASH_column, int(64)) - tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) + tmp22 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp23 := lang.NewVector() + tmp24 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4494), kw_column, int(30), kw_end_DASH_line, int(4494), kw_end_DASH_column, int(31)) + tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp15 := lang.Apply(tmp11, []any{tmp14, v6}) - var v16 any = tmp15 - _ = v16 - tmp17 := checkDerefVar(var_glojure_DOT_core_seq) - tmp18 := checkDerefVar(var_glojure_DOT_core_concat) - tmp19 := checkDerefVar(var_glojure_DOT_core_list) - tmp20 := lang.Apply(tmp19, []any{sym_glojure_DOT_core_SLASH_let}) - tmp21 := checkDerefVar(var_glojure_DOT_core_list) - tmp22 := checkDerefVar(var_glojure_DOT_core_apply) - tmp23 := checkDerefVar(var_glojure_DOT_core_vector) - tmp24 := checkDerefVar(var_glojure_DOT_core_seq) - tmp25 := checkDerefVar(var_glojure_DOT_core_concat) - tmp26 := checkDerefVar(var_glojure_DOT_core_list) - tmp27 := lang.Apply(tmp26, []any{v10}) - tmp28 := checkDerefVar(var_glojure_DOT_core_list) - tmp29 := lang.Apply(tmp28, []any{v5}) - tmp30 := checkDerefVar(var_glojure_DOT_core_interleave) - tmp31 := checkDerefVar(var_glojure_DOT_core_repeat) - tmp32 := lang.Apply(tmp31, []any{v10}) - tmp33 := checkDerefVar(var_glojure_DOT_core_butlast) - tmp34 := lang.Apply(tmp33, []any{v16}) - tmp35 := lang.Apply(tmp30, []any{tmp32, tmp34}) - tmp36 := lang.Apply(tmp25, []any{tmp27, tmp29, tmp35}) - tmp37 := lang.Apply(tmp24, []any{tmp36}) - tmp38 := lang.Apply(tmp22, []any{tmp23, tmp37}) - tmp39 := lang.Apply(tmp21, []any{tmp38}) - tmp40 := checkDerefVar(var_glojure_DOT_core_list) - var tmp41 any - tmp42 := checkDerefVar(var_glojure_DOT_core_empty_QMARK_) - tmp43 := lang.Apply(tmp42, []any{v16}) - if lang.IsTruthy(tmp43) { - tmp41 = v10 - } else { - tmp44 := checkDerefVar(var_glojure_DOT_core_last) - tmp45 := lang.Apply(tmp44, []any{v16}) - tmp41 = tmp45 - } - tmp46 := lang.Apply(tmp40, []any{tmp41}) - tmp47 := lang.Apply(tmp18, []any{tmp20, tmp39, tmp46}) - tmp48 := lang.Apply(tmp17, []any{tmp47}) - tmp7 = tmp48 - } // end let - return tmp7 - } + tmp26 := lang.Apply(tmp22, []any{v14, tmp25, v6}) + tmp15 = tmp26 + } + tmp3 = tmp15 + } // end let + return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_destructure = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_destructure.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // some->> + // extend { - tmp0 := sym_some_DASH__GT__GT_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_expr, sym__AMP_, sym_forms)), kw_doc, "When expr is not nil, threads it into the first form (via ->>),\n and when that result is not nil, through the next etc", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(7624), kw_end_DASH_line, int(7624))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_extend.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_atype, sym__AMP_, sym_proto_PLUS_mmaps)), kw_doc, "Implementations of protocol methods can be provided using the extend construct:\n\n (extend AType\n AProtocol\n {:foo an-existing-fn\n :bar (fn [a b] ...)\n :baz (fn ([a]...) ([a b] ...)...)}\n BProtocol \n {...} \n ...)\n \n extend takes a type/class (or interface, see below), and one or more\n protocol + method map pairs. It will extend the polymorphism of the\n protocol's methods to call the supplied methods when an AType is\n provided as the first argument. \n\n Method maps are maps of the keyword-ized method names to ordinary\n fns. This facilitates easy reuse of existing fns and fn maps, for\n code reuse/mixins without derivation or composition. You can extend\n an interface to a protocol. This is primarily to facilitate interop\n with the host (e.g. Java) but opens the door to incidental multiple\n inheritance of implementation since a class can inherit from more\n than one interface, both of which extend the protocol. It is TBD how\n to specify which impl to use. You can extend a protocol on nil.\n\n If you are supplying the definitions explicitly (i.e. not reusing\n exsting functions or mixin maps), you may find it more convenient to\n use the extend-type or extend-protocol macros.\n\n Note that multiple independent extend clauses can exist for the same\n type, not all protocols need be defined in a single extend call.\n\n See also:\n extends?, satisfies?, extenders", kw_file, "glojure/core_deftype.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(116), kw_end_DASH_line, int(116))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) - v3 := args[0] + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any + var tmp4 any { // let - // let binding "g" - tmp8 := checkDerefVar(var_glojure_DOT_core_gensym) - tmp9 := lang.Apply(tmp8, nil) - var v10 any = tmp9 - _ = v10 - // let binding "steps" - tmp11 := checkDerefVar(var_glojure_DOT_core_map) - var tmp12 lang.FnFunc - tmp12 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v13 := args[0] - _ = v13 - tmp14 := checkDerefVar(var_glojure_DOT_core_seq) - tmp15 := checkDerefVar(var_glojure_DOT_core_concat) - tmp16 := checkDerefVar(var_glojure_DOT_core_list) - tmp17 := lang.Apply(tmp16, []any{sym_if}) - tmp18 := checkDerefVar(var_glojure_DOT_core_list) - tmp19 := checkDerefVar(var_glojure_DOT_core_seq) - tmp20 := checkDerefVar(var_glojure_DOT_core_concat) - tmp21 := checkDerefVar(var_glojure_DOT_core_list) - tmp22 := lang.Apply(tmp21, []any{sym_glojure_DOT_core_SLASH_nil_QMARK_}) - tmp23 := checkDerefVar(var_glojure_DOT_core_list) - tmp24 := lang.Apply(tmp23, []any{v10}) - tmp25 := lang.Apply(tmp20, []any{tmp22, tmp24}) - tmp26 := lang.Apply(tmp19, []any{tmp25}) - tmp27 := lang.Apply(tmp18, []any{tmp26}) - tmp28 := checkDerefVar(var_glojure_DOT_core_list) - tmp29 := lang.Apply(tmp28, []any{nil}) - tmp30 := checkDerefVar(var_glojure_DOT_core_list) - tmp31 := checkDerefVar(var_glojure_DOT_core_seq) - tmp32 := checkDerefVar(var_glojure_DOT_core_concat) - tmp33 := checkDerefVar(var_glojure_DOT_core_list) - tmp34 := lang.Apply(tmp33, []any{sym_glojure_DOT_core_SLASH__DASH__GT__GT_}) - tmp35 := checkDerefVar(var_glojure_DOT_core_list) - tmp36 := lang.Apply(tmp35, []any{v10}) - tmp37 := checkDerefVar(var_glojure_DOT_core_list) - tmp38 := lang.Apply(tmp37, []any{v13}) - tmp39 := lang.Apply(tmp32, []any{tmp34, tmp36, tmp38}) - tmp40 := lang.Apply(tmp31, []any{tmp39}) - tmp41 := lang.Apply(tmp30, []any{tmp40}) - tmp42 := lang.Apply(tmp15, []any{tmp17, tmp27, tmp29, tmp41}) - tmp43 := lang.Apply(tmp14, []any{tmp42}) - return tmp43 - }) - tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7630), kw_column, int(20), kw_end_DASH_line, int(7630), kw_end_DASH_column, int(65)) - tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp15 := lang.Apply(tmp11, []any{tmp14, v6}) - var v16 any = tmp15 - _ = v16 - tmp17 := checkDerefVar(var_glojure_DOT_core_seq) - tmp18 := checkDerefVar(var_glojure_DOT_core_concat) - tmp19 := checkDerefVar(var_glojure_DOT_core_list) - tmp20 := lang.Apply(tmp19, []any{sym_glojure_DOT_core_SLASH_let}) - tmp21 := checkDerefVar(var_glojure_DOT_core_list) - tmp22 := checkDerefVar(var_glojure_DOT_core_apply) - tmp23 := checkDerefVar(var_glojure_DOT_core_vector) - tmp24 := checkDerefVar(var_glojure_DOT_core_seq) - tmp25 := checkDerefVar(var_glojure_DOT_core_concat) - tmp26 := checkDerefVar(var_glojure_DOT_core_list) - tmp27 := lang.Apply(tmp26, []any{v10}) - tmp28 := checkDerefVar(var_glojure_DOT_core_list) - tmp29 := lang.Apply(tmp28, []any{v5}) - tmp30 := checkDerefVar(var_glojure_DOT_core_interleave) - tmp31 := checkDerefVar(var_glojure_DOT_core_repeat) - tmp32 := lang.Apply(tmp31, []any{v10}) - tmp33 := checkDerefVar(var_glojure_DOT_core_butlast) - tmp34 := lang.Apply(tmp33, []any{v16}) - tmp35 := lang.Apply(tmp30, []any{tmp32, tmp34}) - tmp36 := lang.Apply(tmp25, []any{tmp27, tmp29, tmp35}) - tmp37 := lang.Apply(tmp24, []any{tmp36}) - tmp38 := lang.Apply(tmp22, []any{tmp23, tmp37}) - tmp39 := lang.Apply(tmp21, []any{tmp38}) - tmp40 := checkDerefVar(var_glojure_DOT_core_list) - var tmp41 any - tmp42 := checkDerefVar(var_glojure_DOT_core_empty_QMARK_) - tmp43 := lang.Apply(tmp42, []any{v16}) - if lang.IsTruthy(tmp43) { - tmp41 = v10 - } else { - tmp44 := checkDerefVar(var_glojure_DOT_core_last) - tmp45 := lang.Apply(tmp44, []any{v16}) - tmp41 = tmp45 - } - tmp46 := lang.Apply(tmp40, []any{tmp41}) - tmp47 := lang.Apply(tmp18, []any{tmp20, tmp39, tmp46}) - tmp48 := lang.Apply(tmp17, []any{tmp47}) - tmp7 = tmp48 - } // end let - return tmp7 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // some-fn - { - tmp0 := sym_some_DASH_fn.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_p), lang.NewVector(sym_p1, sym_p2), lang.NewVector(sym_p1, sym_p2, sym_p3), lang.NewVector(sym_p1, sym_p2, sym_p3, sym__AMP_, sym_ps)), kw_doc, "Takes a set of predicates and returns a function f that returns the first logical true value\n returned by one of its composing predicates against any of its arguments, else it returns\n logical false. Note that f is short-circuiting in that it will stop execution on the first\n argument that triggers a logical true result against the original predicates.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(7462), kw_end_DASH_line, int(7462))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - var tmp4 lang.FnFunc - { // function sp1 - var v5 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - return nil - case 1: - v6 := args[0] - _ = v6 - tmp7 := lang.Apply(v3, []any{v6}) - return tmp7 - case 2: - v6 := args[0] - _ = v6 - v7 := args[1] - _ = v7 - var tmp8 any - { // let - // let binding "or__0__auto__" - tmp9 := lang.Apply(v3, []any{v6}) - var v10 any = tmp9 - _ = v10 - var tmp11 any - if lang.IsTruthy(v10) { - tmp11 = v10 - } else { - tmp12 := lang.Apply(v3, []any{v7}) - tmp11 = tmp12 - } - tmp8 = tmp11 - } // end let - return tmp8 - case 3: - v6 := args[0] - _ = v6 - v7 := args[1] - _ = v7 - v8 := args[2] - _ = v8 - var tmp9 any - { // let - // let binding "or__0__auto__" - tmp10 := lang.Apply(v3, []any{v6}) - var v11 any = tmp10 - _ = v11 - var tmp12 any - if lang.IsTruthy(v11) { - tmp12 = v11 - } else { - var tmp13 any - { // let - // let binding "or__0__auto__" - tmp14 := lang.Apply(v3, []any{v7}) - var v15 any = tmp14 - _ = v15 - var tmp16 any - if lang.IsTruthy(v15) { - tmp16 = v15 - } else { - tmp17 := lang.Apply(v3, []any{v8}) - tmp16 = tmp17 - } - tmp13 = tmp16 - } // end let - tmp12 = tmp13 - } - tmp9 = tmp12 - } // end let - return tmp9 - default: - checkArity(args, 3) - v6 := args[0] - _ = v6 - v7 := args[1] - _ = v7 - v8 := args[2] - _ = v8 - var v9 any = lang.NewList(args[3:]...) - _ = v9 - var tmp10 any - { // let - // let binding "or__0__auto__" - tmp11 := lang.Apply(v5, []any{v6, v7, v8}) - var v12 any = tmp11 - _ = v12 - var tmp13 any - if lang.IsTruthy(v12) { - tmp13 = v12 - } else { - tmp14 := checkDerefVar(var_glojure_DOT_core_some) - tmp15 := lang.Apply(tmp14, []any{v3, v9}) - tmp13 = tmp15 - } - tmp10 = tmp13 - } // end let - return tmp10 - } - }) - v5 = tmp4 - _ = v5 - } - tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7469), kw_column, int(6), kw_end_DASH_line, int(7475), kw_end_DASH_column, int(43)) - tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp6 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 lang.FnFunc - { // function sp2 - var v6 lang.FnFunc - tmp5 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - return nil - case 1: - v7 := args[0] - _ = v7 - var tmp8 any + // let binding "seq_262" + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_partition) + tmp7 := lang.Apply(tmp6, []any{int64(2), v3}) + tmp8 := lang.Apply(tmp5, []any{tmp7}) + var v9 any = tmp8 + _ = v9 + // let binding "chunk_263" + var v10 any = nil + _ = v10 + // let binding "count_264" + var v11 any = int64(0) + _ = v11 + // let binding "i_265" + var v12 any = int64(0) + _ = v12 + for { + var tmp13 any + tmp14 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp15 := lang.Apply(tmp14, []any{v12, v11}) + if lang.IsTruthy(tmp15) { + var tmp16 any { // let - // let binding "or__0__auto__" - tmp9 := lang.Apply(v3, []any{v7}) - var v10 any = tmp9 - _ = v10 - var tmp11 any - if lang.IsTruthy(v10) { - tmp11 = v10 - } else { - tmp12 := lang.Apply(v4, []any{v7}) - tmp11 = tmp12 + // let binding "vec__266" + tmp17, _ := lang.FieldOrMethod(v10, "nth") + if reflect.TypeOf(tmp17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) } - tmp8 = tmp11 - } // end let - return tmp8 - case 2: - v7 := args[0] - _ = v7 - v8 := args[1] - _ = v8 - var tmp9 any - { // let - // let binding "or__0__auto__" - tmp10 := lang.Apply(v3, []any{v7}) - var v11 any = tmp10 - _ = v11 - var tmp12 any - if lang.IsTruthy(v11) { - tmp12 = v11 + tmp18 := lang.Apply(tmp17, []any{v12}) + var v19 any = tmp18 + _ = v19 + // let binding "proto" + tmp20 := checkDerefVar(var_glojure_DOT_core_nth) + tmp21 := lang.Apply(tmp20, []any{v19, int64(0), nil}) + var v22 any = tmp21 + _ = v22 + // let binding "mmap" + tmp23 := checkDerefVar(var_glojure_DOT_core_nth) + tmp24 := lang.Apply(tmp23, []any{v19, int64(1), nil}) + var v25 any = tmp24 + _ = v25 + var tmp26 any + tmp27 := checkDerefVar(var_glojure_DOT_core_protocol_QMARK_) + tmp28 := lang.Apply(tmp27, []any{v22}) + if lang.IsTruthy(tmp28) { } else { - var tmp13 any + tmp29 := checkDerefVar(var_glojure_DOT_core_str) + tmp30 := lang.Apply(tmp29, []any{v22, " is not a protocol"}) + tmp31 := lang.Apply(errors8.New, []any{tmp30}) + panic(tmp31) + } + _ = tmp26 + tmp32 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp33 lang.FnFunc + tmp33 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v34 := args[0] + _ = v34 + v35 := args[1] + _ = v35 + var tmp36 any { // let - // let binding "or__0__auto__" - tmp14 := lang.Apply(v3, []any{v8}) - var v15 any = tmp14 - _ = v15 - var tmp16 any - if lang.IsTruthy(v15) { - tmp16 = v15 - } else { - var tmp17 any - { // let - // let binding "or__0__auto__" - tmp18 := lang.Apply(v4, []any{v7}) - var v19 any = tmp18 - _ = v19 - var tmp20 any - if lang.IsTruthy(v19) { - tmp20 = v19 - } else { - tmp21 := lang.Apply(v4, []any{v8}) - tmp20 = tmp21 - } - tmp17 = tmp20 - } // end let - tmp16 = tmp17 + // let binding "vec__270" + var v37 any = v35 + _ = v37 + // let binding "k" + tmp38 := checkDerefVar(var_glojure_DOT_core_nth) + tmp39 := lang.Apply(tmp38, []any{v37, int64(0), nil}) + var v40 any = tmp39 + _ = v40 + // let binding "v" + tmp41 := checkDerefVar(var_glojure_DOT_core_nth) + tmp42 := lang.Apply(tmp41, []any{v37, int64(1), nil}) + var v43 any = tmp42 + _ = v43 + tmp44 := checkDerefVar(var_glojure_DOT_core_get_DASH_in) + tmp45 := checkDerefVar(var_glojure_DOT_core_deref) + tmp46 := lang.Apply(tmp45, []any{v22}) + tmp47 := lang.NewVector(kw_multis, v40) + tmp48 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(158), kw_column, int(33), kw_end_DASH_line, int(158), kw_end_DASH_column, int(43)) + tmp49, err := lang.WithMeta(tmp47, tmp48.(lang.IPersistentMap)) + if err != nil { + panic(err) } - tmp13 = tmp16 + tmp50 := lang.Apply(tmp44, []any{tmp46, tmp49}) + var tmp51 lang.FnFunc + tmp51 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v52 := args[0] + _ = v52 + var v53 any = lang.NewList(args[1:]...) + _ = v53 + tmp54 := checkDerefVar(var_glojure_DOT_core_apply) + tmp55 := checkDerefVar(var_glojure_DOT_core_cons) + tmp56 := lang.Apply(tmp55, []any{v52, v53}) + tmp57 := lang.Apply(tmp54, []any{v43, tmp56}) + return tmp57 + } + }) + tmp52, _ := lang.FieldOrMethod(tmp50, "AddMethod") + if reflect.TypeOf(tmp52).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("AddMethod is not a function"))) + } + tmp53 := lang.Apply(tmp52, []any{v2, tmp51}) + tmp36 = tmp53 } // end let - tmp12 = tmp13 + return tmp36 + }) + tmp34 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(156), kw_column, int(14), kw_end_DASH_line, int(160), kw_end_DASH_column, int(45)) + tmp35, err := lang.WithMeta(tmp33, tmp34.(lang.IPersistentMap)) + if err != nil { + panic(err) } - tmp9 = tmp12 + tmp36 := lang.Apply(tmp32, []any{tmp35, nil, v25}) + _ = tmp36 + var tmp37 any = v9 + var tmp38 any = v10 + var tmp39 any = v11 + tmp41 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp42 := lang.Apply(tmp41, []any{v12}) + var tmp40 any = tmp42 + v9 = tmp37 + v10 = tmp38 + v11 = tmp39 + v12 = tmp40 + continue } // end let - return tmp9 - case 3: - v7 := args[0] - _ = v7 - v8 := args[1] - _ = v8 - v9 := args[2] - _ = v9 - var tmp10 any + tmp13 = tmp16 + } else { + var tmp17 any { // let - // let binding "or__0__auto__" - tmp11 := lang.Apply(v3, []any{v7}) - var v12 any = tmp11 - _ = v12 - var tmp13 any - if lang.IsTruthy(v12) { - tmp13 = v12 - } else { - var tmp14 any + // let binding "temp__0__auto__" + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := lang.Apply(tmp18, []any{v9}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + var tmp22 any { // let - // let binding "or__0__auto__" - tmp15 := lang.Apply(v3, []any{v8}) - var v16 any = tmp15 - _ = v16 - var tmp17 any - if lang.IsTruthy(v16) { - tmp17 = v16 + // let binding "seq_262" + var v23 any = v20 + _ = v23 + var tmp24 any + tmp25 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp26 := lang.Apply(tmp25, []any{v23}) + if lang.IsTruthy(tmp26) { + var tmp27 any + { // let + // let binding "c__0__auto__" + tmp28 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp29 := lang.Apply(tmp28, []any{v23}) + var v30 any = tmp29 + _ = v30 + tmp32 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp33 := lang.Apply(tmp32, []any{v23}) + var tmp31 any = tmp33 + var tmp34 any = v30 + tmp36 := checkDerefVar(var_glojure_DOT_core_int) + tmp37 := checkDerefVar(var_glojure_DOT_core_count) + tmp38 := lang.Apply(tmp37, []any{v30}) + tmp39 := lang.Apply(tmp36, []any{tmp38}) + var tmp35 any = tmp39 + tmp41 := checkDerefVar(var_glojure_DOT_core_int) + tmp42 := lang.Apply(tmp41, []any{int64(0)}) + var tmp40 any = tmp42 + v9 = tmp31 + v10 = tmp34 + v11 = tmp35 + v12 = tmp40 + continue + } // end let + tmp24 = tmp27 } else { - var tmp18 any + var tmp28 any { // let - // let binding "or__0__auto__" - tmp19 := lang.Apply(v3, []any{v9}) - var v20 any = tmp19 - _ = v20 - var tmp21 any - if lang.IsTruthy(v20) { - tmp21 = v20 + // let binding "vec__273" + tmp29 := checkDerefVar(var_glojure_DOT_core_first) + tmp30 := lang.Apply(tmp29, []any{v23}) + var v31 any = tmp30 + _ = v31 + // let binding "proto" + tmp32 := checkDerefVar(var_glojure_DOT_core_nth) + tmp33 := lang.Apply(tmp32, []any{v31, int64(0), nil}) + var v34 any = tmp33 + _ = v34 + // let binding "mmap" + tmp35 := checkDerefVar(var_glojure_DOT_core_nth) + tmp36 := lang.Apply(tmp35, []any{v31, int64(1), nil}) + var v37 any = tmp36 + _ = v37 + var tmp38 any + tmp39 := checkDerefVar(var_glojure_DOT_core_protocol_QMARK_) + tmp40 := lang.Apply(tmp39, []any{v34}) + if lang.IsTruthy(tmp40) { } else { - var tmp22 any + tmp41 := checkDerefVar(var_glojure_DOT_core_str) + tmp42 := lang.Apply(tmp41, []any{v34, " is not a protocol"}) + tmp43 := lang.Apply(errors8.New, []any{tmp42}) + panic(tmp43) + } + _ = tmp38 + tmp44 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp45 lang.FnFunc + tmp45 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v46 := args[0] + _ = v46 + v47 := args[1] + _ = v47 + var tmp48 any { // let - // let binding "or__0__auto__" - tmp23 := lang.Apply(v4, []any{v7}) - var v24 any = tmp23 - _ = v24 - var tmp25 any - if lang.IsTruthy(v24) { - tmp25 = v24 - } else { - var tmp26 any - { // let - // let binding "or__0__auto__" - tmp27 := lang.Apply(v4, []any{v8}) - var v28 any = tmp27 - _ = v28 - var tmp29 any - if lang.IsTruthy(v28) { - tmp29 = v28 - } else { - tmp30 := lang.Apply(v4, []any{v9}) - tmp29 = tmp30 - } - tmp26 = tmp29 - } // end let - tmp25 = tmp26 + // let binding "vec__277" + var v49 any = v47 + _ = v49 + // let binding "k" + tmp50 := checkDerefVar(var_glojure_DOT_core_nth) + tmp51 := lang.Apply(tmp50, []any{v49, int64(0), nil}) + var v52 any = tmp51 + _ = v52 + // let binding "v" + tmp53 := checkDerefVar(var_glojure_DOT_core_nth) + tmp54 := lang.Apply(tmp53, []any{v49, int64(1), nil}) + var v55 any = tmp54 + _ = v55 + tmp56 := checkDerefVar(var_glojure_DOT_core_get_DASH_in) + tmp57 := checkDerefVar(var_glojure_DOT_core_deref) + tmp58 := lang.Apply(tmp57, []any{v34}) + tmp59 := lang.NewVector(kw_multis, v52) + tmp60 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(158), kw_column, int(33), kw_end_DASH_line, int(158), kw_end_DASH_column, int(43)) + tmp61, err := lang.WithMeta(tmp59, tmp60.(lang.IPersistentMap)) + if err != nil { + panic(err) } - tmp22 = tmp25 + tmp62 := lang.Apply(tmp56, []any{tmp58, tmp61}) + var tmp63 lang.FnFunc + tmp63 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v64 := args[0] + _ = v64 + var v65 any = lang.NewList(args[1:]...) + _ = v65 + tmp66 := checkDerefVar(var_glojure_DOT_core_apply) + tmp67 := checkDerefVar(var_glojure_DOT_core_cons) + tmp68 := lang.Apply(tmp67, []any{v64, v65}) + tmp69 := lang.Apply(tmp66, []any{v55, tmp68}) + return tmp69 + } + }) + tmp64, _ := lang.FieldOrMethod(tmp62, "AddMethod") + if reflect.TypeOf(tmp64).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("AddMethod is not a function"))) + } + tmp65 := lang.Apply(tmp64, []any{v2, tmp63}) + tmp48 = tmp65 } // end let - tmp21 = tmp22 + return tmp48 + }) + tmp46 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(156), kw_column, int(14), kw_end_DASH_line, int(160), kw_end_DASH_column, int(45)) + tmp47, err := lang.WithMeta(tmp45, tmp46.(lang.IPersistentMap)) + if err != nil { + panic(err) } - tmp18 = tmp21 + tmp48 := lang.Apply(tmp44, []any{tmp47, nil, v37}) + _ = tmp48 + tmp50 := checkDerefVar(var_glojure_DOT_core_next) + tmp51 := lang.Apply(tmp50, []any{v23}) + var tmp49 any = tmp51 + var tmp52 any = nil + var tmp53 any = int64(0) + var tmp54 any = int64(0) + v9 = tmp49 + v10 = tmp52 + v11 = tmp53 + v12 = tmp54 + continue } // end let - tmp17 = tmp18 + tmp24 = tmp28 } - tmp14 = tmp17 + tmp22 = tmp24 } // end let - tmp13 = tmp14 - } - tmp10 = tmp13 - } // end let - return tmp10 - default: - checkArity(args, 3) - v7 := args[0] - _ = v7 - v8 := args[1] - _ = v8 - v9 := args[2] - _ = v9 - var v10 any = lang.NewList(args[3:]...) - _ = v10 - var tmp11 any - { // let - // let binding "or__0__auto__" - tmp12 := lang.Apply(v6, []any{v7, v8, v9}) - var v13 any = tmp12 - _ = v13 - var tmp14 any - if lang.IsTruthy(v13) { - tmp14 = v13 + tmp21 = tmp22 } else { - tmp15 := checkDerefVar(var_glojure_DOT_core_some) - var tmp16 lang.FnFunc - tmp16 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v17 := args[0] - _ = v17 - var tmp18 any - { // let - // let binding "or__0__auto__" - tmp19 := lang.Apply(v3, []any{v17}) - var v20 any = tmp19 - _ = v20 - var tmp21 any - if lang.IsTruthy(v20) { - tmp21 = v20 - } else { - tmp22 := lang.Apply(v4, []any{v17}) - tmp21 = tmp22 - } - tmp18 = tmp21 - } // end let - return tmp18 - }) - tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7483), kw_column, int(34), kw_end_DASH_line, int(7483), kw_end_DASH_column, int(52)) - tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp19 := lang.Apply(tmp15, []any{tmp18, v10}) - tmp14 = tmp19 } - tmp11 = tmp14 + tmp17 = tmp21 } // end let - return tmp11 + tmp13 = tmp17 } + tmp4 = tmp13 + break + } + } // end let + return tmp4 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_extend = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_extend.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // for + { + tmp0 := sym_for.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_seq_DASH_exprs, sym_body_DASH_expr)), kw_doc, "List comprehension. Takes a vector of one or more\n binding-form/collection-expr pairs, each followed by zero or more\n modifiers, and yields a lazy sequence of evaluations of expr.\n Collections are iterated in a nested fashion, rightmost fastest,\n and nested coll-exprs can refer to bindings created in prior\n binding-forms. Supported modifiers are: :let [binding-form expr ...],\n :while test, :when test.\n\n (take 100 (for [x (range 100000000) y (range 1000000) :while (< y x)] [x y]))", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(11), kw_line, int(4646), kw_end_DASH_line, int(4646))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v4}) + if lang.IsTruthy(tmp8) { + } else { + tmp9 := checkDerefVar(var_glojure_DOT_core_str) + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp13 := checkDerefVar(var_glojure_DOT_core_meta) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(kw_line, []any{tmp14}) + tmp16 := lang.Apply(tmp9, []any{tmp11, " requires ", "a vector for its binding", " in ", tmp12, ":", tmp15}) + tmp17 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp16}) + panic(tmp17) + } + _ = tmp6 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_even_QMARK_) + tmp20 := checkDerefVar(var_glojure_DOT_core_count) + tmp21 := lang.Apply(tmp20, []any{v4}) + tmp22 := lang.Apply(tmp19, []any{tmp21}) + if lang.IsTruthy(tmp22) { + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp27 := checkDerefVar(var_glojure_DOT_core_meta) + tmp28 := lang.Apply(tmp27, []any{v2}) + tmp29 := lang.Apply(kw_line, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp25, " requires ", "an even number of forms in binding vector", " in ", tmp26, ":", tmp29}) + tmp31 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp31) + } + _ = tmp18 + var tmp32 any + { // let + // let binding "to-groups" + var tmp33 lang.FnFunc + tmp33 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v34 := args[0] + _ = v34 + tmp35 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp36 lang.FnFunc + tmp36 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v37 := args[0] + _ = v37 + v38 := args[1] + _ = v38 + var tmp39 any + { // let + // let binding "vec__24" + var v40 any = v38 + _ = v40 + // let binding "k" + tmp41 := checkDerefVar(var_glojure_DOT_core_nth) + tmp42 := lang.Apply(tmp41, []any{v40, int64(0), nil}) + var v43 any = tmp42 + _ = v43 + // let binding "v" + tmp44 := checkDerefVar(var_glojure_DOT_core_nth) + tmp45 := lang.Apply(tmp44, []any{v40, int64(1), nil}) + var v46 any = tmp45 + _ = v46 + var tmp47 any + tmp48 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp49 := lang.Apply(tmp48, []any{v43}) + if lang.IsTruthy(tmp49) { + tmp50 := checkDerefVar(var_glojure_DOT_core_conj) + tmp51 := checkDerefVar(var_glojure_DOT_core_pop) + tmp52 := lang.Apply(tmp51, []any{v37}) + tmp53 := checkDerefVar(var_glojure_DOT_core_conj) + tmp54 := checkDerefVar(var_glojure_DOT_core_peek) + tmp55 := lang.Apply(tmp54, []any{v37}) + tmp56 := lang.NewVector(v43, v46) + tmp57 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4664), kw_column, int(72), kw_end_DASH_line, int(4664), kw_end_DASH_column, int(76)) + tmp58, err := lang.WithMeta(tmp56, tmp57.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp59 := lang.Apply(tmp53, []any{tmp55, tmp58}) + tmp60 := lang.Apply(tmp50, []any{tmp52, tmp59}) + tmp47 = tmp60 + } else { + tmp61 := checkDerefVar(var_glojure_DOT_core_conj) + tmp62 := lang.NewVector(v43, v46) + tmp63 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4665), kw_column, int(46), kw_end_DASH_line, int(4665), kw_end_DASH_column, int(50)) + tmp64, err := lang.WithMeta(tmp62, tmp63.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp65 := lang.Apply(tmp61, []any{v37, tmp64}) + tmp47 = tmp65 + } + tmp39 = tmp47 + } // end let + return tmp39 }) - v6 = tmp5 - _ = v6 + tmp37 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4662), kw_column, int(30), kw_end_DASH_line, int(4665), kw_end_DASH_column, int(53)) + tmp38, err := lang.WithMeta(tmp36, tmp37.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp39 := lang.NewVector() + tmp40 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4666), kw_column, int(29), kw_end_DASH_line, int(4666), kw_end_DASH_column, int(30)) + tmp41, err := lang.WithMeta(tmp39, tmp40.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp42 := checkDerefVar(var_glojure_DOT_core_partition) + tmp43 := lang.Apply(tmp42, []any{int64(2), v34}) + tmp44 := lang.Apply(tmp35, []any{tmp38, tmp41, tmp43}) + return tmp44 + }) + tmp34 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4661), kw_column, int(19), kw_end_DASH_line, int(4666), kw_end_DASH_column, int(56)) + tmp35, err := lang.WithMeta(tmp33, tmp34.(lang.IPersistentMap)) + if err != nil { + panic(err) } - tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7477), kw_column, int(6), kw_end_DASH_line, int(7483), kw_end_DASH_column, int(61)) - tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + var v36 any = tmp35 + _ = v36 + // let binding "err" + var tmp37 lang.FnFunc + tmp37 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v38 any = lang.NewList(args[0:]...) + _ = v38 + tmp39 := checkDerefVar(var_glojure_DOT_core_apply) + tmp40 := checkDerefVar(var_glojure_DOT_core_str) + tmp41 := lang.Apply(tmp39, []any{tmp40, v38}) + tmp42 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp41}) + panic(tmp42) + } + }) + tmp38 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4667), kw_column, int(13), kw_end_DASH_line, int(4667), kw_end_DASH_column, int(125)) + tmp39, err := lang.WithMeta(tmp37, tmp38.(lang.IPersistentMap)) if err != nil { panic(err) } - return tmp7 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var tmp6 lang.FnFunc - { // function sp3 - var v7 lang.FnFunc - tmp6 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - return nil - case 1: - v8 := args[0] - _ = v8 - var tmp9 any + var v40 any = tmp39 + _ = v40 + // let binding "emit-bind" + var tmp41 lang.FnFunc + { // function emit-bind + var v42 lang.FnFunc + tmp41 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v43 := args[0] + _ = v43 + var tmp44 any + { // let + // let binding "vec__28" + var v45 any = v43 + _ = v45 + // let binding "seq__29" + tmp46 := checkDerefVar(var_glojure_DOT_core_seq) + tmp47 := lang.Apply(tmp46, []any{v45}) + var v48 any = tmp47 + _ = v48 + // let binding "first__30" + tmp49 := checkDerefVar(var_glojure_DOT_core_first) + tmp50 := lang.Apply(tmp49, []any{v48}) + var v51 any = tmp50 + _ = v51 + // let binding "seq__29" + tmp52 := checkDerefVar(var_glojure_DOT_core_next) + tmp53 := lang.Apply(tmp52, []any{v48}) + var v54 any = tmp53 + _ = v54 + // let binding "vec__31" + var v55 any = v51 + _ = v55 + // let binding "seq__32" + tmp56 := checkDerefVar(var_glojure_DOT_core_seq) + tmp57 := lang.Apply(tmp56, []any{v55}) + var v58 any = tmp57 + _ = v58 + // let binding "first__33" + tmp59 := checkDerefVar(var_glojure_DOT_core_first) + tmp60 := lang.Apply(tmp59, []any{v58}) + var v61 any = tmp60 + _ = v61 + // let binding "seq__32" + tmp62 := checkDerefVar(var_glojure_DOT_core_next) + tmp63 := lang.Apply(tmp62, []any{v58}) + var v64 any = tmp63 + _ = v64 + // let binding "bind" + var v65 any = v61 + _ = v65 + // let binding "first__33" + tmp66 := checkDerefVar(var_glojure_DOT_core_first) + tmp67 := lang.Apply(tmp66, []any{v64}) + var v68 any = tmp67 + _ = v68 + // let binding "seq__32" + tmp69 := checkDerefVar(var_glojure_DOT_core_next) + tmp70 := lang.Apply(tmp69, []any{v64}) + var v71 any = tmp70 + _ = v71 + // let binding "expr" + var v72 any = v68 + _ = v72 + // let binding "mod-pairs" + var v73 any = v71 + _ = v73 + // let binding "vec__34" + var v74 any = v54 + _ = v74 + // let binding "vec__37" + tmp75 := checkDerefVar(var_glojure_DOT_core_nth) + tmp76 := lang.Apply(tmp75, []any{v74, int64(0), nil}) + var v77 any = tmp76 + _ = v77 + // let binding "_" + tmp78 := checkDerefVar(var_glojure_DOT_core_nth) + tmp79 := lang.Apply(tmp78, []any{v77, int64(0), nil}) + var v80 any = tmp79 + _ = v80 + // let binding "next-expr" + tmp81 := checkDerefVar(var_glojure_DOT_core_nth) + tmp82 := lang.Apply(tmp81, []any{v77, int64(1), nil}) + var v83 any = tmp82 + _ = v83 + // let binding "next-groups" + var v84 any = v74 + _ = v84 + var tmp85 any { // let - // let binding "or__0__auto__" - tmp10 := lang.Apply(v3, []any{v8}) - var v11 any = tmp10 - _ = v11 - var tmp12 any - if lang.IsTruthy(v11) { - tmp12 = v11 - } else { - var tmp13 any - { // let - // let binding "or__0__auto__" - tmp14 := lang.Apply(v4, []any{v8}) - var v15 any = tmp14 - _ = v15 - var tmp16 any - if lang.IsTruthy(v15) { - tmp16 = v15 - } else { - tmp17 := lang.Apply(v5, []any{v8}) - tmp16 = tmp17 - } - tmp13 = tmp16 - } // end let - tmp12 = tmp13 + // let binding "giter" + tmp86 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp87 := lang.Apply(tmp86, []any{"iter__"}) + var v88 any = tmp87 + _ = v88 + // let binding "gxs" + tmp89 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp90 := lang.Apply(tmp89, []any{"s__"}) + var v91 any = tmp90 + _ = v91 + // let binding "do-mod" + var tmp92 lang.FnFunc + { // function do-mod + var v93 lang.FnFunc + tmp92 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v94 := args[0] + _ = v94 + var tmp95 any + { // let + // let binding "vec__41" + var v96 any = v94 + _ = v96 + // let binding "seq__42" + tmp97 := checkDerefVar(var_glojure_DOT_core_seq) + tmp98 := lang.Apply(tmp97, []any{v96}) + var v99 any = tmp98 + _ = v99 + // let binding "first__43" + tmp100 := checkDerefVar(var_glojure_DOT_core_first) + tmp101 := lang.Apply(tmp100, []any{v99}) + var v102 any = tmp101 + _ = v102 + // let binding "seq__42" + tmp103 := checkDerefVar(var_glojure_DOT_core_next) + tmp104 := lang.Apply(tmp103, []any{v99}) + var v105 any = tmp104 + _ = v105 + // let binding "vec__44" + var v106 any = v102 + _ = v106 + // let binding "k" + tmp107 := checkDerefVar(var_glojure_DOT_core_nth) + tmp108 := lang.Apply(tmp107, []any{v106, int64(0), nil}) + var v109 any = tmp108 + _ = v109 + // let binding "v" + tmp110 := checkDerefVar(var_glojure_DOT_core_nth) + tmp111 := lang.Apply(tmp110, []any{v106, int64(1), nil}) + var v112 any = tmp111 + _ = v112 + // let binding "pair" + var v113 any = v106 + _ = v113 + // let binding "etc" + var v114 any = v105 + _ = v114 + var tmp115 any + tmp116 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp117 := lang.Apply(tmp116, []any{v109, kw_let}) + if lang.IsTruthy(tmp117) { + tmp118 := checkDerefVar(var_glojure_DOT_core_seq) + tmp119 := checkDerefVar(var_glojure_DOT_core_concat) + tmp120 := checkDerefVar(var_glojure_DOT_core_list) + tmp121 := lang.Apply(tmp120, []any{sym_glojure_DOT_core_SLASH_let}) + tmp122 := checkDerefVar(var_glojure_DOT_core_list) + tmp123 := lang.Apply(tmp122, []any{v112}) + tmp124 := checkDerefVar(var_glojure_DOT_core_list) + tmp125 := lang.Apply(v93, []any{v114}) + tmp126 := lang.Apply(tmp124, []any{tmp125}) + tmp127 := lang.Apply(tmp119, []any{tmp121, tmp123, tmp126}) + tmp128 := lang.Apply(tmp118, []any{tmp127}) + tmp115 = tmp128 + } else { + var tmp129 any + tmp130 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp131 := lang.Apply(tmp130, []any{v109, kw_while}) + if lang.IsTruthy(tmp131) { + tmp132 := checkDerefVar(var_glojure_DOT_core_seq) + tmp133 := checkDerefVar(var_glojure_DOT_core_concat) + tmp134 := checkDerefVar(var_glojure_DOT_core_list) + tmp135 := lang.Apply(tmp134, []any{sym_glojure_DOT_core_SLASH_when}) + tmp136 := checkDerefVar(var_glojure_DOT_core_list) + tmp137 := lang.Apply(tmp136, []any{v112}) + tmp138 := checkDerefVar(var_glojure_DOT_core_list) + tmp139 := lang.Apply(v93, []any{v114}) + tmp140 := lang.Apply(tmp138, []any{tmp139}) + tmp141 := lang.Apply(tmp133, []any{tmp135, tmp137, tmp140}) + tmp142 := lang.Apply(tmp132, []any{tmp141}) + tmp129 = tmp142 + } else { + var tmp143 any + tmp144 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp145 := lang.Apply(tmp144, []any{v109, kw_when}) + if lang.IsTruthy(tmp145) { + tmp146 := checkDerefVar(var_glojure_DOT_core_seq) + tmp147 := checkDerefVar(var_glojure_DOT_core_concat) + tmp148 := checkDerefVar(var_glojure_DOT_core_list) + tmp149 := lang.Apply(tmp148, []any{sym_if}) + tmp150 := checkDerefVar(var_glojure_DOT_core_list) + tmp151 := lang.Apply(tmp150, []any{v112}) + tmp152 := checkDerefVar(var_glojure_DOT_core_list) + tmp153 := lang.Apply(v93, []any{v114}) + tmp154 := lang.Apply(tmp152, []any{tmp153}) + tmp155 := checkDerefVar(var_glojure_DOT_core_list) + tmp156 := checkDerefVar(var_glojure_DOT_core_seq) + tmp157 := checkDerefVar(var_glojure_DOT_core_concat) + tmp158 := checkDerefVar(var_glojure_DOT_core_list) + tmp159 := lang.Apply(tmp158, []any{sym_recur}) + tmp160 := checkDerefVar(var_glojure_DOT_core_list) + tmp161 := checkDerefVar(var_glojure_DOT_core_seq) + tmp162 := checkDerefVar(var_glojure_DOT_core_concat) + tmp163 := checkDerefVar(var_glojure_DOT_core_list) + tmp164 := lang.Apply(tmp163, []any{sym_glojure_DOT_core_SLASH_rest}) + tmp165 := checkDerefVar(var_glojure_DOT_core_list) + tmp166 := lang.Apply(tmp165, []any{v91}) + tmp167 := lang.Apply(tmp162, []any{tmp164, tmp166}) + tmp168 := lang.Apply(tmp161, []any{tmp167}) + tmp169 := lang.Apply(tmp160, []any{tmp168}) + tmp170 := lang.Apply(tmp157, []any{tmp159, tmp169}) + tmp171 := lang.Apply(tmp156, []any{tmp170}) + tmp172 := lang.Apply(tmp155, []any{tmp171}) + tmp173 := lang.Apply(tmp147, []any{tmp149, tmp151, tmp154, tmp172}) + tmp174 := lang.Apply(tmp146, []any{tmp173}) + tmp143 = tmp174 + } else { + var tmp175 any + tmp176 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp177 := lang.Apply(tmp176, []any{v109}) + if lang.IsTruthy(tmp177) { + tmp178 := lang.Apply(v40, []any{"Invalid 'for' keyword ", v109}) + tmp175 = tmp178 + } else { + var tmp179 any + if lang.IsTruthy(v84) { + tmp180 := checkDerefVar(var_glojure_DOT_core_seq) + tmp181 := checkDerefVar(var_glojure_DOT_core_concat) + tmp182 := checkDerefVar(var_glojure_DOT_core_list) + tmp183 := lang.Apply(tmp182, []any{sym_glojure_DOT_core_SLASH_let}) + tmp184 := checkDerefVar(var_glojure_DOT_core_list) + tmp185 := checkDerefVar(var_glojure_DOT_core_apply) + tmp186 := checkDerefVar(var_glojure_DOT_core_vector) + tmp187 := checkDerefVar(var_glojure_DOT_core_seq) + tmp188 := checkDerefVar(var_glojure_DOT_core_concat) + tmp189 := checkDerefVar(var_glojure_DOT_core_list) + tmp190 := lang.Apply(tmp189, []any{sym_iterys__0__auto__}) + tmp191 := checkDerefVar(var_glojure_DOT_core_list) + tmp192 := lang.Apply(v42, []any{v84}) + tmp193 := lang.Apply(tmp191, []any{tmp192}) + tmp194 := checkDerefVar(var_glojure_DOT_core_list) + tmp195 := lang.Apply(tmp194, []any{sym_fs__1__auto__}) + tmp196 := checkDerefVar(var_glojure_DOT_core_list) + tmp197 := checkDerefVar(var_glojure_DOT_core_seq) + tmp198 := checkDerefVar(var_glojure_DOT_core_concat) + tmp199 := checkDerefVar(var_glojure_DOT_core_list) + tmp200 := lang.Apply(tmp199, []any{sym_glojure_DOT_core_SLASH_seq}) + tmp201 := checkDerefVar(var_glojure_DOT_core_list) + tmp202 := checkDerefVar(var_glojure_DOT_core_seq) + tmp203 := checkDerefVar(var_glojure_DOT_core_concat) + tmp204 := checkDerefVar(var_glojure_DOT_core_list) + tmp205 := lang.Apply(tmp204, []any{sym_iterys__0__auto__}) + tmp206 := checkDerefVar(var_glojure_DOT_core_list) + tmp207 := lang.Apply(tmp206, []any{v83}) + tmp208 := lang.Apply(tmp203, []any{tmp205, tmp207}) + tmp209 := lang.Apply(tmp202, []any{tmp208}) + tmp210 := lang.Apply(tmp201, []any{tmp209}) + tmp211 := lang.Apply(tmp198, []any{tmp200, tmp210}) + tmp212 := lang.Apply(tmp197, []any{tmp211}) + tmp213 := lang.Apply(tmp196, []any{tmp212}) + tmp214 := lang.Apply(tmp188, []any{tmp190, tmp193, tmp195, tmp213}) + tmp215 := lang.Apply(tmp187, []any{tmp214}) + tmp216 := lang.Apply(tmp185, []any{tmp186, tmp215}) + tmp217 := lang.Apply(tmp184, []any{tmp216}) + tmp218 := checkDerefVar(var_glojure_DOT_core_list) + tmp219 := checkDerefVar(var_glojure_DOT_core_seq) + tmp220 := checkDerefVar(var_glojure_DOT_core_concat) + tmp221 := checkDerefVar(var_glojure_DOT_core_list) + tmp222 := lang.Apply(tmp221, []any{sym_if}) + tmp223 := checkDerefVar(var_glojure_DOT_core_list) + tmp224 := lang.Apply(tmp223, []any{sym_fs__1__auto__}) + tmp225 := checkDerefVar(var_glojure_DOT_core_list) + tmp226 := checkDerefVar(var_glojure_DOT_core_seq) + tmp227 := checkDerefVar(var_glojure_DOT_core_concat) + tmp228 := checkDerefVar(var_glojure_DOT_core_list) + tmp229 := lang.Apply(tmp228, []any{sym_glojure_DOT_core_SLASH_concat}) + tmp230 := checkDerefVar(var_glojure_DOT_core_list) + tmp231 := lang.Apply(tmp230, []any{sym_fs__1__auto__}) + tmp232 := checkDerefVar(var_glojure_DOT_core_list) + tmp233 := checkDerefVar(var_glojure_DOT_core_seq) + tmp234 := checkDerefVar(var_glojure_DOT_core_concat) + tmp235 := checkDerefVar(var_glojure_DOT_core_list) + tmp236 := lang.Apply(tmp235, []any{v88}) + tmp237 := checkDerefVar(var_glojure_DOT_core_list) + tmp238 := checkDerefVar(var_glojure_DOT_core_seq) + tmp239 := checkDerefVar(var_glojure_DOT_core_concat) + tmp240 := checkDerefVar(var_glojure_DOT_core_list) + tmp241 := lang.Apply(tmp240, []any{sym_glojure_DOT_core_SLASH_rest}) + tmp242 := checkDerefVar(var_glojure_DOT_core_list) + tmp243 := lang.Apply(tmp242, []any{v91}) + tmp244 := lang.Apply(tmp239, []any{tmp241, tmp243}) + tmp245 := lang.Apply(tmp238, []any{tmp244}) + tmp246 := lang.Apply(tmp237, []any{tmp245}) + tmp247 := lang.Apply(tmp234, []any{tmp236, tmp246}) + tmp248 := lang.Apply(tmp233, []any{tmp247}) + tmp249 := lang.Apply(tmp232, []any{tmp248}) + tmp250 := lang.Apply(tmp227, []any{tmp229, tmp231, tmp249}) + tmp251 := lang.Apply(tmp226, []any{tmp250}) + tmp252 := lang.Apply(tmp225, []any{tmp251}) + tmp253 := checkDerefVar(var_glojure_DOT_core_list) + tmp254 := checkDerefVar(var_glojure_DOT_core_seq) + tmp255 := checkDerefVar(var_glojure_DOT_core_concat) + tmp256 := checkDerefVar(var_glojure_DOT_core_list) + tmp257 := lang.Apply(tmp256, []any{sym_recur}) + tmp258 := checkDerefVar(var_glojure_DOT_core_list) + tmp259 := checkDerefVar(var_glojure_DOT_core_seq) + tmp260 := checkDerefVar(var_glojure_DOT_core_concat) + tmp261 := checkDerefVar(var_glojure_DOT_core_list) + tmp262 := lang.Apply(tmp261, []any{sym_glojure_DOT_core_SLASH_rest}) + tmp263 := checkDerefVar(var_glojure_DOT_core_list) + tmp264 := lang.Apply(tmp263, []any{v91}) + tmp265 := lang.Apply(tmp260, []any{tmp262, tmp264}) + tmp266 := lang.Apply(tmp259, []any{tmp265}) + tmp267 := lang.Apply(tmp258, []any{tmp266}) + tmp268 := lang.Apply(tmp255, []any{tmp257, tmp267}) + tmp269 := lang.Apply(tmp254, []any{tmp268}) + tmp270 := lang.Apply(tmp253, []any{tmp269}) + tmp271 := lang.Apply(tmp220, []any{tmp222, tmp224, tmp252, tmp270}) + tmp272 := lang.Apply(tmp219, []any{tmp271}) + tmp273 := lang.Apply(tmp218, []any{tmp272}) + tmp274 := lang.Apply(tmp181, []any{tmp183, tmp217, tmp273}) + tmp275 := lang.Apply(tmp180, []any{tmp274}) + tmp179 = tmp275 + } else { + var tmp276 any + if lang.IsTruthy(kw_else) { + tmp277 := checkDerefVar(var_glojure_DOT_core_seq) + tmp278 := checkDerefVar(var_glojure_DOT_core_concat) + tmp279 := checkDerefVar(var_glojure_DOT_core_list) + tmp280 := lang.Apply(tmp279, []any{sym_glojure_DOT_core_SLASH_cons}) + tmp281 := checkDerefVar(var_glojure_DOT_core_list) + tmp282 := lang.Apply(tmp281, []any{v5}) + tmp283 := checkDerefVar(var_glojure_DOT_core_list) + tmp284 := checkDerefVar(var_glojure_DOT_core_seq) + tmp285 := checkDerefVar(var_glojure_DOT_core_concat) + tmp286 := checkDerefVar(var_glojure_DOT_core_list) + tmp287 := lang.Apply(tmp286, []any{v88}) + tmp288 := checkDerefVar(var_glojure_DOT_core_list) + tmp289 := checkDerefVar(var_glojure_DOT_core_seq) + tmp290 := checkDerefVar(var_glojure_DOT_core_concat) + tmp291 := checkDerefVar(var_glojure_DOT_core_list) + tmp292 := lang.Apply(tmp291, []any{sym_glojure_DOT_core_SLASH_rest}) + tmp293 := checkDerefVar(var_glojure_DOT_core_list) + tmp294 := lang.Apply(tmp293, []any{v91}) + tmp295 := lang.Apply(tmp290, []any{tmp292, tmp294}) + tmp296 := lang.Apply(tmp289, []any{tmp295}) + tmp297 := lang.Apply(tmp288, []any{tmp296}) + tmp298 := lang.Apply(tmp285, []any{tmp287, tmp297}) + tmp299 := lang.Apply(tmp284, []any{tmp298}) + tmp300 := lang.Apply(tmp283, []any{tmp299}) + tmp301 := lang.Apply(tmp278, []any{tmp280, tmp282, tmp300}) + tmp302 := lang.Apply(tmp277, []any{tmp301}) + tmp276 = tmp302 + } else { + } + tmp179 = tmp276 + } + tmp175 = tmp179 + } + tmp143 = tmp175 + } + tmp129 = tmp143 + } + tmp115 = tmp129 + } + tmp95 = tmp115 + } // end let + return tmp95 + }) + v93 = tmp92 + _ = v93 } - tmp9 = tmp12 - } // end let - return tmp9 - case 2: - v8 := args[0] - _ = v8 - v9 := args[1] - _ = v9 - var tmp10 any - { // let - // let binding "or__0__auto__" - tmp11 := lang.Apply(v3, []any{v8}) - var v12 any = tmp11 - _ = v12 - var tmp13 any - if lang.IsTruthy(v12) { - tmp13 = v12 + tmp93 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4672), kw_column, int(34), kw_end_DASH_line, int(4687), kw_end_DASH_column, int(73)) + tmp94, err := lang.WithMeta(tmp92, tmp93.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v95 any = tmp94 + _ = v95 + var tmp96 any + if lang.IsTruthy(v84) { + tmp97 := checkDerefVar(var_glojure_DOT_core_seq) + tmp98 := checkDerefVar(var_glojure_DOT_core_concat) + tmp99 := checkDerefVar(var_glojure_DOT_core_list) + tmp100 := lang.Apply(tmp99, []any{sym_glojure_DOT_core_SLASH_fn}) + tmp101 := checkDerefVar(var_glojure_DOT_core_list) + tmp102 := lang.Apply(tmp101, []any{v88}) + tmp103 := checkDerefVar(var_glojure_DOT_core_list) + tmp104 := checkDerefVar(var_glojure_DOT_core_apply) + tmp105 := checkDerefVar(var_glojure_DOT_core_vector) + tmp106 := checkDerefVar(var_glojure_DOT_core_seq) + tmp107 := checkDerefVar(var_glojure_DOT_core_concat) + tmp108 := checkDerefVar(var_glojure_DOT_core_list) + tmp109 := lang.Apply(tmp108, []any{v91}) + tmp110 := lang.Apply(tmp107, []any{tmp109}) + tmp111 := lang.Apply(tmp106, []any{tmp110}) + tmp112 := lang.Apply(tmp104, []any{tmp105, tmp111}) + tmp113 := lang.Apply(tmp103, []any{tmp112}) + tmp114 := checkDerefVar(var_glojure_DOT_core_list) + tmp115 := checkDerefVar(var_glojure_DOT_core_seq) + tmp116 := checkDerefVar(var_glojure_DOT_core_concat) + tmp117 := checkDerefVar(var_glojure_DOT_core_list) + tmp118 := lang.Apply(tmp117, []any{sym_glojure_DOT_core_SLASH_lazy_DASH_seq}) + tmp119 := checkDerefVar(var_glojure_DOT_core_list) + tmp120 := checkDerefVar(var_glojure_DOT_core_seq) + tmp121 := checkDerefVar(var_glojure_DOT_core_concat) + tmp122 := checkDerefVar(var_glojure_DOT_core_list) + tmp123 := lang.Apply(tmp122, []any{sym_glojure_DOT_core_SLASH_loop}) + tmp124 := checkDerefVar(var_glojure_DOT_core_list) + tmp125 := checkDerefVar(var_glojure_DOT_core_apply) + tmp126 := checkDerefVar(var_glojure_DOT_core_vector) + tmp127 := checkDerefVar(var_glojure_DOT_core_seq) + tmp128 := checkDerefVar(var_glojure_DOT_core_concat) + tmp129 := checkDerefVar(var_glojure_DOT_core_list) + tmp130 := lang.Apply(tmp129, []any{v91}) + tmp131 := checkDerefVar(var_glojure_DOT_core_list) + tmp132 := lang.Apply(tmp131, []any{v91}) + tmp133 := lang.Apply(tmp128, []any{tmp130, tmp132}) + tmp134 := lang.Apply(tmp127, []any{tmp133}) + tmp135 := lang.Apply(tmp125, []any{tmp126, tmp134}) + tmp136 := lang.Apply(tmp124, []any{tmp135}) + tmp137 := checkDerefVar(var_glojure_DOT_core_list) + tmp138 := checkDerefVar(var_glojure_DOT_core_seq) + tmp139 := checkDerefVar(var_glojure_DOT_core_concat) + tmp140 := checkDerefVar(var_glojure_DOT_core_list) + tmp141 := lang.Apply(tmp140, []any{sym_glojure_DOT_core_SLASH_when_DASH_first}) + tmp142 := checkDerefVar(var_glojure_DOT_core_list) + tmp143 := checkDerefVar(var_glojure_DOT_core_apply) + tmp144 := checkDerefVar(var_glojure_DOT_core_vector) + tmp145 := checkDerefVar(var_glojure_DOT_core_seq) + tmp146 := checkDerefVar(var_glojure_DOT_core_concat) + tmp147 := checkDerefVar(var_glojure_DOT_core_list) + tmp148 := lang.Apply(tmp147, []any{v65}) + tmp149 := checkDerefVar(var_glojure_DOT_core_list) + tmp150 := lang.Apply(tmp149, []any{v91}) + tmp151 := lang.Apply(tmp146, []any{tmp148, tmp150}) + tmp152 := lang.Apply(tmp145, []any{tmp151}) + tmp153 := lang.Apply(tmp143, []any{tmp144, tmp152}) + tmp154 := lang.Apply(tmp142, []any{tmp153}) + tmp155 := checkDerefVar(var_glojure_DOT_core_list) + tmp156 := lang.Apply(v95, []any{v73}) + tmp157 := lang.Apply(tmp155, []any{tmp156}) + tmp158 := lang.Apply(tmp139, []any{tmp141, tmp154, tmp157}) + tmp159 := lang.Apply(tmp138, []any{tmp158}) + tmp160 := lang.Apply(tmp137, []any{tmp159}) + tmp161 := lang.Apply(tmp121, []any{tmp123, tmp136, tmp160}) + tmp162 := lang.Apply(tmp120, []any{tmp161}) + tmp163 := lang.Apply(tmp119, []any{tmp162}) + tmp164 := lang.Apply(tmp116, []any{tmp118, tmp163}) + tmp165 := lang.Apply(tmp115, []any{tmp164}) + tmp166 := lang.Apply(tmp114, []any{tmp165}) + tmp167 := lang.Apply(tmp98, []any{tmp100, tmp102, tmp113, tmp166}) + tmp168 := lang.Apply(tmp97, []any{tmp167}) + tmp96 = tmp168 } else { - var tmp14 any + var tmp169 any { // let - // let binding "or__0__auto__" - tmp15 := lang.Apply(v3, []any{v9}) - var v16 any = tmp15 - _ = v16 - var tmp17 any - if lang.IsTruthy(v16) { - tmp17 = v16 - } else { - var tmp18 any - { // let - // let binding "or__0__auto__" - tmp19 := lang.Apply(v4, []any{v8}) - var v20 any = tmp19 - _ = v20 - var tmp21 any - if lang.IsTruthy(v20) { - tmp21 = v20 - } else { - var tmp22 any - { // let - // let binding "or__0__auto__" - tmp23 := lang.Apply(v4, []any{v9}) - var v24 any = tmp23 - _ = v24 - var tmp25 any - if lang.IsTruthy(v24) { - tmp25 = v24 + // let binding "gi" + tmp170 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp171 := lang.Apply(tmp170, []any{"i__"}) + var v172 any = tmp171 + _ = v172 + // let binding "gb" + tmp173 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp174 := lang.Apply(tmp173, []any{"b__"}) + var v175 any = tmp174 + _ = v175 + // let binding "do-cmod" + var tmp176 lang.FnFunc + { // function do-cmod + var v177 lang.FnFunc + tmp176 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v178 := args[0] + _ = v178 + var tmp179 any + { // let + // let binding "vec__48" + var v180 any = v178 + _ = v180 + // let binding "seq__49" + tmp181 := checkDerefVar(var_glojure_DOT_core_seq) + tmp182 := lang.Apply(tmp181, []any{v180}) + var v183 any = tmp182 + _ = v183 + // let binding "first__50" + tmp184 := checkDerefVar(var_glojure_DOT_core_first) + tmp185 := lang.Apply(tmp184, []any{v183}) + var v186 any = tmp185 + _ = v186 + // let binding "seq__49" + tmp187 := checkDerefVar(var_glojure_DOT_core_next) + tmp188 := lang.Apply(tmp187, []any{v183}) + var v189 any = tmp188 + _ = v189 + // let binding "vec__51" + var v190 any = v186 + _ = v190 + // let binding "k" + tmp191 := checkDerefVar(var_glojure_DOT_core_nth) + tmp192 := lang.Apply(tmp191, []any{v190, int64(0), nil}) + var v193 any = tmp192 + _ = v193 + // let binding "v" + tmp194 := checkDerefVar(var_glojure_DOT_core_nth) + tmp195 := lang.Apply(tmp194, []any{v190, int64(1), nil}) + var v196 any = tmp195 + _ = v196 + // let binding "pair" + var v197 any = v190 + _ = v197 + // let binding "etc" + var v198 any = v189 + _ = v198 + var tmp199 any + tmp200 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp201 := lang.Apply(tmp200, []any{v193, kw_let}) + if lang.IsTruthy(tmp201) { + tmp202 := checkDerefVar(var_glojure_DOT_core_seq) + tmp203 := checkDerefVar(var_glojure_DOT_core_concat) + tmp204 := checkDerefVar(var_glojure_DOT_core_list) + tmp205 := lang.Apply(tmp204, []any{sym_glojure_DOT_core_SLASH_let}) + tmp206 := checkDerefVar(var_glojure_DOT_core_list) + tmp207 := lang.Apply(tmp206, []any{v196}) + tmp208 := checkDerefVar(var_glojure_DOT_core_list) + tmp209 := lang.Apply(v177, []any{v198}) + tmp210 := lang.Apply(tmp208, []any{tmp209}) + tmp211 := lang.Apply(tmp203, []any{tmp205, tmp207, tmp210}) + tmp212 := lang.Apply(tmp202, []any{tmp211}) + tmp199 = tmp212 + } else { + var tmp213 any + tmp214 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp215 := lang.Apply(tmp214, []any{v193, kw_while}) + if lang.IsTruthy(tmp215) { + tmp216 := checkDerefVar(var_glojure_DOT_core_seq) + tmp217 := checkDerefVar(var_glojure_DOT_core_concat) + tmp218 := checkDerefVar(var_glojure_DOT_core_list) + tmp219 := lang.Apply(tmp218, []any{sym_glojure_DOT_core_SLASH_when}) + tmp220 := checkDerefVar(var_glojure_DOT_core_list) + tmp221 := lang.Apply(tmp220, []any{v196}) + tmp222 := checkDerefVar(var_glojure_DOT_core_list) + tmp223 := lang.Apply(v177, []any{v198}) + tmp224 := lang.Apply(tmp222, []any{tmp223}) + tmp225 := lang.Apply(tmp217, []any{tmp219, tmp221, tmp224}) + tmp226 := lang.Apply(tmp216, []any{tmp225}) + tmp213 = tmp226 } else { - var tmp26 any - { // let - // let binding "or__0__auto__" - tmp27 := lang.Apply(v5, []any{v8}) - var v28 any = tmp27 - _ = v28 - var tmp29 any - if lang.IsTruthy(v28) { - tmp29 = v28 + var tmp227 any + tmp228 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp229 := lang.Apply(tmp228, []any{v193, kw_when}) + if lang.IsTruthy(tmp229) { + tmp230 := checkDerefVar(var_glojure_DOT_core_seq) + tmp231 := checkDerefVar(var_glojure_DOT_core_concat) + tmp232 := checkDerefVar(var_glojure_DOT_core_list) + tmp233 := lang.Apply(tmp232, []any{sym_if}) + tmp234 := checkDerefVar(var_glojure_DOT_core_list) + tmp235 := lang.Apply(tmp234, []any{v196}) + tmp236 := checkDerefVar(var_glojure_DOT_core_list) + tmp237 := lang.Apply(v177, []any{v198}) + tmp238 := lang.Apply(tmp236, []any{tmp237}) + tmp239 := checkDerefVar(var_glojure_DOT_core_list) + tmp240 := checkDerefVar(var_glojure_DOT_core_seq) + tmp241 := checkDerefVar(var_glojure_DOT_core_concat) + tmp242 := checkDerefVar(var_glojure_DOT_core_list) + tmp243 := lang.Apply(tmp242, []any{sym_recur}) + tmp244 := checkDerefVar(var_glojure_DOT_core_list) + tmp245 := checkDerefVar(var_glojure_DOT_core_seq) + tmp246 := checkDerefVar(var_glojure_DOT_core_concat) + tmp247 := checkDerefVar(var_glojure_DOT_core_list) + tmp248 := lang.Apply(tmp247, []any{sym_glojure_DOT_core_SLASH_unchecked_DASH_inc}) + tmp249 := checkDerefVar(var_glojure_DOT_core_list) + tmp250 := lang.Apply(tmp249, []any{v172}) + tmp251 := lang.Apply(tmp246, []any{tmp248, tmp250}) + tmp252 := lang.Apply(tmp245, []any{tmp251}) + tmp253 := lang.Apply(tmp244, []any{tmp252}) + tmp254 := lang.Apply(tmp241, []any{tmp243, tmp253}) + tmp255 := lang.Apply(tmp240, []any{tmp254}) + tmp256 := lang.Apply(tmp239, []any{tmp255}) + tmp257 := lang.Apply(tmp231, []any{tmp233, tmp235, tmp238, tmp256}) + tmp258 := lang.Apply(tmp230, []any{tmp257}) + tmp227 = tmp258 + } else { + var tmp259 any + tmp260 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp261 := lang.Apply(tmp260, []any{v193}) + if lang.IsTruthy(tmp261) { + tmp262 := lang.Apply(v40, []any{"Invalid 'for' keyword ", v193}) + tmp259 = tmp262 } else { - tmp30 := lang.Apply(v5, []any{v9}) - tmp29 = tmp30 + var tmp263 any + if lang.IsTruthy(kw_else) { + tmp264 := checkDerefVar(var_glojure_DOT_core_seq) + tmp265 := checkDerefVar(var_glojure_DOT_core_concat) + tmp266 := checkDerefVar(var_glojure_DOT_core_list) + tmp267 := lang.Apply(tmp266, []any{sym_do}) + tmp268 := checkDerefVar(var_glojure_DOT_core_list) + tmp269 := checkDerefVar(var_glojure_DOT_core_seq) + tmp270 := checkDerefVar(var_glojure_DOT_core_concat) + tmp271 := checkDerefVar(var_glojure_DOT_core_list) + tmp272 := lang.Apply(tmp271, []any{sym_glojure_DOT_core_SLASH_chunk_DASH_append}) + tmp273 := checkDerefVar(var_glojure_DOT_core_list) + tmp274 := lang.Apply(tmp273, []any{v175}) + tmp275 := checkDerefVar(var_glojure_DOT_core_list) + tmp276 := lang.Apply(tmp275, []any{v5}) + tmp277 := lang.Apply(tmp270, []any{tmp272, tmp274, tmp276}) + tmp278 := lang.Apply(tmp269, []any{tmp277}) + tmp279 := lang.Apply(tmp268, []any{tmp278}) + tmp280 := checkDerefVar(var_glojure_DOT_core_list) + tmp281 := checkDerefVar(var_glojure_DOT_core_seq) + tmp282 := checkDerefVar(var_glojure_DOT_core_concat) + tmp283 := checkDerefVar(var_glojure_DOT_core_list) + tmp284 := lang.Apply(tmp283, []any{sym_recur}) + tmp285 := checkDerefVar(var_glojure_DOT_core_list) + tmp286 := checkDerefVar(var_glojure_DOT_core_seq) + tmp287 := checkDerefVar(var_glojure_DOT_core_concat) + tmp288 := checkDerefVar(var_glojure_DOT_core_list) + tmp289 := lang.Apply(tmp288, []any{sym_glojure_DOT_core_SLASH_unchecked_DASH_inc}) + tmp290 := checkDerefVar(var_glojure_DOT_core_list) + tmp291 := lang.Apply(tmp290, []any{v172}) + tmp292 := lang.Apply(tmp287, []any{tmp289, tmp291}) + tmp293 := lang.Apply(tmp286, []any{tmp292}) + tmp294 := lang.Apply(tmp285, []any{tmp293}) + tmp295 := lang.Apply(tmp282, []any{tmp284, tmp294}) + tmp296 := lang.Apply(tmp281, []any{tmp295}) + tmp297 := lang.Apply(tmp280, []any{tmp296}) + tmp298 := lang.Apply(tmp265, []any{tmp267, tmp279, tmp297}) + tmp299 := lang.Apply(tmp264, []any{tmp298}) + tmp263 = tmp299 + } else { + } + tmp259 = tmp263 } - tmp26 = tmp29 - } // end let - tmp25 = tmp26 + tmp227 = tmp259 + } + tmp213 = tmp227 } - tmp22 = tmp25 - } // end let - tmp21 = tmp22 - } - tmp18 = tmp21 - } // end let - tmp17 = tmp18 + tmp199 = tmp213 + } + tmp179 = tmp199 + } // end let + return tmp179 + }) + v177 = tmp176 + _ = v177 } - tmp14 = tmp17 + tmp177 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4698), kw_column, int(39), kw_end_DASH_line, int(4710), kw_end_DASH_column, int(79)) + tmp178, err := lang.WithMeta(tmp176, tmp177.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v179 any = tmp178 + _ = v179 + tmp180 := checkDerefVar(var_glojure_DOT_core_seq) + tmp181 := checkDerefVar(var_glojure_DOT_core_concat) + tmp182 := checkDerefVar(var_glojure_DOT_core_list) + tmp183 := lang.Apply(tmp182, []any{sym_glojure_DOT_core_SLASH_fn}) + tmp184 := checkDerefVar(var_glojure_DOT_core_list) + tmp185 := lang.Apply(tmp184, []any{v88}) + tmp186 := checkDerefVar(var_glojure_DOT_core_list) + tmp187 := checkDerefVar(var_glojure_DOT_core_apply) + tmp188 := checkDerefVar(var_glojure_DOT_core_vector) + tmp189 := checkDerefVar(var_glojure_DOT_core_seq) + tmp190 := checkDerefVar(var_glojure_DOT_core_concat) + tmp191 := checkDerefVar(var_glojure_DOT_core_list) + tmp192 := lang.Apply(tmp191, []any{v91}) + tmp193 := lang.Apply(tmp190, []any{tmp192}) + tmp194 := lang.Apply(tmp189, []any{tmp193}) + tmp195 := lang.Apply(tmp187, []any{tmp188, tmp194}) + tmp196 := lang.Apply(tmp186, []any{tmp195}) + tmp197 := checkDerefVar(var_glojure_DOT_core_list) + tmp198 := checkDerefVar(var_glojure_DOT_core_seq) + tmp199 := checkDerefVar(var_glojure_DOT_core_concat) + tmp200 := checkDerefVar(var_glojure_DOT_core_list) + tmp201 := lang.Apply(tmp200, []any{sym_glojure_DOT_core_SLASH_lazy_DASH_seq}) + tmp202 := checkDerefVar(var_glojure_DOT_core_list) + tmp203 := checkDerefVar(var_glojure_DOT_core_seq) + tmp204 := checkDerefVar(var_glojure_DOT_core_concat) + tmp205 := checkDerefVar(var_glojure_DOT_core_list) + tmp206 := lang.Apply(tmp205, []any{sym_glojure_DOT_core_SLASH_loop}) + tmp207 := checkDerefVar(var_glojure_DOT_core_list) + tmp208 := checkDerefVar(var_glojure_DOT_core_apply) + tmp209 := checkDerefVar(var_glojure_DOT_core_vector) + tmp210 := checkDerefVar(var_glojure_DOT_core_seq) + tmp211 := checkDerefVar(var_glojure_DOT_core_concat) + tmp212 := checkDerefVar(var_glojure_DOT_core_list) + tmp213 := lang.Apply(tmp212, []any{v91}) + tmp214 := checkDerefVar(var_glojure_DOT_core_list) + tmp215 := lang.Apply(tmp214, []any{v91}) + tmp216 := lang.Apply(tmp211, []any{tmp213, tmp215}) + tmp217 := lang.Apply(tmp210, []any{tmp216}) + tmp218 := lang.Apply(tmp208, []any{tmp209, tmp217}) + tmp219 := lang.Apply(tmp207, []any{tmp218}) + tmp220 := checkDerefVar(var_glojure_DOT_core_list) + tmp221 := checkDerefVar(var_glojure_DOT_core_seq) + tmp222 := checkDerefVar(var_glojure_DOT_core_concat) + tmp223 := checkDerefVar(var_glojure_DOT_core_list) + tmp224 := lang.Apply(tmp223, []any{sym_glojure_DOT_core_SLASH_when_DASH_let}) + tmp225 := checkDerefVar(var_glojure_DOT_core_list) + tmp226 := checkDerefVar(var_glojure_DOT_core_apply) + tmp227 := checkDerefVar(var_glojure_DOT_core_vector) + tmp228 := checkDerefVar(var_glojure_DOT_core_seq) + tmp229 := checkDerefVar(var_glojure_DOT_core_concat) + tmp230 := checkDerefVar(var_glojure_DOT_core_list) + tmp231 := lang.Apply(tmp230, []any{v91}) + tmp232 := checkDerefVar(var_glojure_DOT_core_list) + tmp233 := checkDerefVar(var_glojure_DOT_core_seq) + tmp234 := checkDerefVar(var_glojure_DOT_core_concat) + tmp235 := checkDerefVar(var_glojure_DOT_core_list) + tmp236 := lang.Apply(tmp235, []any{sym_glojure_DOT_core_SLASH_seq}) + tmp237 := checkDerefVar(var_glojure_DOT_core_list) + tmp238 := lang.Apply(tmp237, []any{v91}) + tmp239 := lang.Apply(tmp234, []any{tmp236, tmp238}) + tmp240 := lang.Apply(tmp233, []any{tmp239}) + tmp241 := lang.Apply(tmp232, []any{tmp240}) + tmp242 := lang.Apply(tmp229, []any{tmp231, tmp241}) + tmp243 := lang.Apply(tmp228, []any{tmp242}) + tmp244 := lang.Apply(tmp226, []any{tmp227, tmp243}) + tmp245 := lang.Apply(tmp225, []any{tmp244}) + tmp246 := checkDerefVar(var_glojure_DOT_core_list) + tmp247 := checkDerefVar(var_glojure_DOT_core_seq) + tmp248 := checkDerefVar(var_glojure_DOT_core_concat) + tmp249 := checkDerefVar(var_glojure_DOT_core_list) + tmp250 := lang.Apply(tmp249, []any{sym_if}) + tmp251 := checkDerefVar(var_glojure_DOT_core_list) + tmp252 := checkDerefVar(var_glojure_DOT_core_seq) + tmp253 := checkDerefVar(var_glojure_DOT_core_concat) + tmp254 := checkDerefVar(var_glojure_DOT_core_list) + tmp255 := lang.Apply(tmp254, []any{sym_glojure_DOT_core_SLASH_chunked_DASH_seq_QMARK_}) + tmp256 := checkDerefVar(var_glojure_DOT_core_list) + tmp257 := lang.Apply(tmp256, []any{v91}) + tmp258 := lang.Apply(tmp253, []any{tmp255, tmp257}) + tmp259 := lang.Apply(tmp252, []any{tmp258}) + tmp260 := lang.Apply(tmp251, []any{tmp259}) + tmp261 := checkDerefVar(var_glojure_DOT_core_list) + tmp262 := checkDerefVar(var_glojure_DOT_core_seq) + tmp263 := checkDerefVar(var_glojure_DOT_core_concat) + tmp264 := checkDerefVar(var_glojure_DOT_core_list) + tmp265 := lang.Apply(tmp264, []any{sym_glojure_DOT_core_SLASH_let}) + tmp266 := checkDerefVar(var_glojure_DOT_core_list) + tmp267 := checkDerefVar(var_glojure_DOT_core_apply) + tmp268 := checkDerefVar(var_glojure_DOT_core_vector) + tmp269 := checkDerefVar(var_glojure_DOT_core_seq) + tmp270 := checkDerefVar(var_glojure_DOT_core_concat) + tmp271 := checkDerefVar(var_glojure_DOT_core_list) + tmp272 := lang.Apply(tmp271, []any{sym_c__0__auto__}) + tmp273 := checkDerefVar(var_glojure_DOT_core_list) + tmp274 := checkDerefVar(var_glojure_DOT_core_seq) + tmp275 := checkDerefVar(var_glojure_DOT_core_concat) + tmp276 := checkDerefVar(var_glojure_DOT_core_list) + tmp277 := lang.Apply(tmp276, []any{sym_glojure_DOT_core_SLASH_chunk_DASH_first}) + tmp278 := checkDerefVar(var_glojure_DOT_core_list) + tmp279 := lang.Apply(tmp278, []any{v91}) + tmp280 := lang.Apply(tmp275, []any{tmp277, tmp279}) + tmp281 := lang.Apply(tmp274, []any{tmp280}) + tmp282 := lang.Apply(tmp273, []any{tmp281}) + tmp283 := checkDerefVar(var_glojure_DOT_core_list) + tmp284 := lang.Apply(tmp283, []any{sym_size__1__auto__}) + tmp285 := checkDerefVar(var_glojure_DOT_core_list) + tmp286 := checkDerefVar(var_glojure_DOT_core_seq) + tmp287 := checkDerefVar(var_glojure_DOT_core_concat) + tmp288 := checkDerefVar(var_glojure_DOT_core_list) + tmp289 := lang.Apply(tmp288, []any{sym_glojure_DOT_core_SLASH_int}) + tmp290 := checkDerefVar(var_glojure_DOT_core_list) + tmp291 := checkDerefVar(var_glojure_DOT_core_seq) + tmp292 := checkDerefVar(var_glojure_DOT_core_concat) + tmp293 := checkDerefVar(var_glojure_DOT_core_list) + tmp294 := lang.Apply(tmp293, []any{sym_glojure_DOT_core_SLASH_count}) + tmp295 := checkDerefVar(var_glojure_DOT_core_list) + tmp296 := lang.Apply(tmp295, []any{sym_c__0__auto__}) + tmp297 := lang.Apply(tmp292, []any{tmp294, tmp296}) + tmp298 := lang.Apply(tmp291, []any{tmp297}) + tmp299 := lang.Apply(tmp290, []any{tmp298}) + tmp300 := lang.Apply(tmp287, []any{tmp289, tmp299}) + tmp301 := lang.Apply(tmp286, []any{tmp300}) + tmp302 := lang.Apply(tmp285, []any{tmp301}) + tmp303 := checkDerefVar(var_glojure_DOT_core_list) + tmp304 := lang.Apply(tmp303, []any{v175}) + tmp305 := checkDerefVar(var_glojure_DOT_core_list) + tmp306 := checkDerefVar(var_glojure_DOT_core_seq) + tmp307 := checkDerefVar(var_glojure_DOT_core_concat) + tmp308 := checkDerefVar(var_glojure_DOT_core_list) + tmp309 := lang.Apply(tmp308, []any{sym_glojure_DOT_core_SLASH_chunk_DASH_buffer}) + tmp310 := checkDerefVar(var_glojure_DOT_core_list) + tmp311 := lang.Apply(tmp310, []any{sym_size__1__auto__}) + tmp312 := lang.Apply(tmp307, []any{tmp309, tmp311}) + tmp313 := lang.Apply(tmp306, []any{tmp312}) + tmp314 := lang.Apply(tmp305, []any{tmp313}) + tmp315 := lang.Apply(tmp270, []any{tmp272, tmp282, tmp284, tmp302, tmp304, tmp314}) + tmp316 := lang.Apply(tmp269, []any{tmp315}) + tmp317 := lang.Apply(tmp267, []any{tmp268, tmp316}) + tmp318 := lang.Apply(tmp266, []any{tmp317}) + tmp319 := checkDerefVar(var_glojure_DOT_core_list) + tmp320 := checkDerefVar(var_glojure_DOT_core_seq) + tmp321 := checkDerefVar(var_glojure_DOT_core_concat) + tmp322 := checkDerefVar(var_glojure_DOT_core_list) + tmp323 := lang.Apply(tmp322, []any{sym_if}) + tmp324 := checkDerefVar(var_glojure_DOT_core_list) + tmp325 := checkDerefVar(var_glojure_DOT_core_seq) + tmp326 := checkDerefVar(var_glojure_DOT_core_concat) + tmp327 := checkDerefVar(var_glojure_DOT_core_list) + tmp328 := lang.Apply(tmp327, []any{sym_glojure_DOT_core_SLASH_loop}) + tmp329 := checkDerefVar(var_glojure_DOT_core_list) + tmp330 := checkDerefVar(var_glojure_DOT_core_apply) + tmp331 := checkDerefVar(var_glojure_DOT_core_vector) + tmp332 := checkDerefVar(var_glojure_DOT_core_seq) + tmp333 := checkDerefVar(var_glojure_DOT_core_concat) + tmp334 := checkDerefVar(var_glojure_DOT_core_list) + tmp335 := lang.Apply(tmp334, []any{v172}) + tmp336 := checkDerefVar(var_glojure_DOT_core_list) + tmp337 := checkDerefVar(var_glojure_DOT_core_seq) + tmp338 := checkDerefVar(var_glojure_DOT_core_concat) + tmp339 := checkDerefVar(var_glojure_DOT_core_list) + tmp340 := lang.Apply(tmp339, []any{sym_glojure_DOT_core_SLASH_int}) + tmp341 := checkDerefVar(var_glojure_DOT_core_list) + tmp342 := lang.Apply(tmp341, []any{int64(0)}) + tmp343 := lang.Apply(tmp338, []any{tmp340, tmp342}) + tmp344 := lang.Apply(tmp337, []any{tmp343}) + tmp345 := lang.Apply(tmp336, []any{tmp344}) + tmp346 := lang.Apply(tmp333, []any{tmp335, tmp345}) + tmp347 := lang.Apply(tmp332, []any{tmp346}) + tmp348 := lang.Apply(tmp330, []any{tmp331, tmp347}) + tmp349 := lang.Apply(tmp329, []any{tmp348}) + tmp350 := checkDerefVar(var_glojure_DOT_core_list) + tmp351 := checkDerefVar(var_glojure_DOT_core_seq) + tmp352 := checkDerefVar(var_glojure_DOT_core_concat) + tmp353 := checkDerefVar(var_glojure_DOT_core_list) + tmp354 := lang.Apply(tmp353, []any{sym_if}) + tmp355 := checkDerefVar(var_glojure_DOT_core_list) + tmp356 := checkDerefVar(var_glojure_DOT_core_seq) + tmp357 := checkDerefVar(var_glojure_DOT_core_concat) + tmp358 := checkDerefVar(var_glojure_DOT_core_list) + tmp359 := lang.Apply(tmp358, []any{sym_glojure_DOT_core_SLASH__LT_}) + tmp360 := checkDerefVar(var_glojure_DOT_core_list) + tmp361 := lang.Apply(tmp360, []any{v172}) + tmp362 := checkDerefVar(var_glojure_DOT_core_list) + tmp363 := lang.Apply(tmp362, []any{sym_size__1__auto__}) + tmp364 := lang.Apply(tmp357, []any{tmp359, tmp361, tmp363}) + tmp365 := lang.Apply(tmp356, []any{tmp364}) + tmp366 := lang.Apply(tmp355, []any{tmp365}) + tmp367 := checkDerefVar(var_glojure_DOT_core_list) + tmp368 := checkDerefVar(var_glojure_DOT_core_seq) + tmp369 := checkDerefVar(var_glojure_DOT_core_concat) + tmp370 := checkDerefVar(var_glojure_DOT_core_list) + tmp371 := lang.Apply(tmp370, []any{sym_glojure_DOT_core_SLASH_let}) + tmp372 := checkDerefVar(var_glojure_DOT_core_list) + tmp373 := checkDerefVar(var_glojure_DOT_core_apply) + tmp374 := checkDerefVar(var_glojure_DOT_core_vector) + tmp375 := checkDerefVar(var_glojure_DOT_core_seq) + tmp376 := checkDerefVar(var_glojure_DOT_core_concat) + tmp377 := checkDerefVar(var_glojure_DOT_core_list) + tmp378 := lang.Apply(tmp377, []any{v65}) + tmp379 := checkDerefVar(var_glojure_DOT_core_list) + tmp380 := checkDerefVar(var_glojure_DOT_core_seq) + tmp381 := checkDerefVar(var_glojure_DOT_core_concat) + tmp382 := checkDerefVar(var_glojure_DOT_core_list) + tmp383 := lang.Apply(tmp382, []any{sym__DOT_nth}) + tmp384 := checkDerefVar(var_glojure_DOT_core_list) + tmp385 := lang.Apply(tmp384, []any{sym_c__0__auto__}) + tmp386 := checkDerefVar(var_glojure_DOT_core_list) + tmp387 := lang.Apply(tmp386, []any{v172}) + tmp388 := lang.Apply(tmp381, []any{tmp383, tmp385, tmp387}) + tmp389 := lang.Apply(tmp380, []any{tmp388}) + tmp390 := lang.Apply(tmp379, []any{tmp389}) + tmp391 := lang.Apply(tmp376, []any{tmp378, tmp390}) + tmp392 := lang.Apply(tmp375, []any{tmp391}) + tmp393 := lang.Apply(tmp373, []any{tmp374, tmp392}) + tmp394 := lang.Apply(tmp372, []any{tmp393}) + tmp395 := checkDerefVar(var_glojure_DOT_core_list) + tmp396 := lang.Apply(v179, []any{v73}) + tmp397 := lang.Apply(tmp395, []any{tmp396}) + tmp398 := lang.Apply(tmp369, []any{tmp371, tmp394, tmp397}) + tmp399 := lang.Apply(tmp368, []any{tmp398}) + tmp400 := lang.Apply(tmp367, []any{tmp399}) + tmp401 := checkDerefVar(var_glojure_DOT_core_list) + tmp402 := lang.Apply(tmp401, []any{true}) + tmp403 := lang.Apply(tmp352, []any{tmp354, tmp366, tmp400, tmp402}) + tmp404 := lang.Apply(tmp351, []any{tmp403}) + tmp405 := lang.Apply(tmp350, []any{tmp404}) + tmp406 := lang.Apply(tmp326, []any{tmp328, tmp349, tmp405}) + tmp407 := lang.Apply(tmp325, []any{tmp406}) + tmp408 := lang.Apply(tmp324, []any{tmp407}) + tmp409 := checkDerefVar(var_glojure_DOT_core_list) + tmp410 := checkDerefVar(var_glojure_DOT_core_seq) + tmp411 := checkDerefVar(var_glojure_DOT_core_concat) + tmp412 := checkDerefVar(var_glojure_DOT_core_list) + tmp413 := lang.Apply(tmp412, []any{sym_glojure_DOT_core_SLASH_chunk_DASH_cons}) + tmp414 := checkDerefVar(var_glojure_DOT_core_list) + tmp415 := checkDerefVar(var_glojure_DOT_core_seq) + tmp416 := checkDerefVar(var_glojure_DOT_core_concat) + tmp417 := checkDerefVar(var_glojure_DOT_core_list) + tmp418 := lang.Apply(tmp417, []any{sym_glojure_DOT_core_SLASH_chunk}) + tmp419 := checkDerefVar(var_glojure_DOT_core_list) + tmp420 := lang.Apply(tmp419, []any{v175}) + tmp421 := lang.Apply(tmp416, []any{tmp418, tmp420}) + tmp422 := lang.Apply(tmp415, []any{tmp421}) + tmp423 := lang.Apply(tmp414, []any{tmp422}) + tmp424 := checkDerefVar(var_glojure_DOT_core_list) + tmp425 := checkDerefVar(var_glojure_DOT_core_seq) + tmp426 := checkDerefVar(var_glojure_DOT_core_concat) + tmp427 := checkDerefVar(var_glojure_DOT_core_list) + tmp428 := lang.Apply(tmp427, []any{v88}) + tmp429 := checkDerefVar(var_glojure_DOT_core_list) + tmp430 := checkDerefVar(var_glojure_DOT_core_seq) + tmp431 := checkDerefVar(var_glojure_DOT_core_concat) + tmp432 := checkDerefVar(var_glojure_DOT_core_list) + tmp433 := lang.Apply(tmp432, []any{sym_glojure_DOT_core_SLASH_chunk_DASH_rest}) + tmp434 := checkDerefVar(var_glojure_DOT_core_list) + tmp435 := lang.Apply(tmp434, []any{v91}) + tmp436 := lang.Apply(tmp431, []any{tmp433, tmp435}) + tmp437 := lang.Apply(tmp430, []any{tmp436}) + tmp438 := lang.Apply(tmp429, []any{tmp437}) + tmp439 := lang.Apply(tmp426, []any{tmp428, tmp438}) + tmp440 := lang.Apply(tmp425, []any{tmp439}) + tmp441 := lang.Apply(tmp424, []any{tmp440}) + tmp442 := lang.Apply(tmp411, []any{tmp413, tmp423, tmp441}) + tmp443 := lang.Apply(tmp410, []any{tmp442}) + tmp444 := lang.Apply(tmp409, []any{tmp443}) + tmp445 := checkDerefVar(var_glojure_DOT_core_list) + tmp446 := checkDerefVar(var_glojure_DOT_core_seq) + tmp447 := checkDerefVar(var_glojure_DOT_core_concat) + tmp448 := checkDerefVar(var_glojure_DOT_core_list) + tmp449 := lang.Apply(tmp448, []any{sym_glojure_DOT_core_SLASH_chunk_DASH_cons}) + tmp450 := checkDerefVar(var_glojure_DOT_core_list) + tmp451 := checkDerefVar(var_glojure_DOT_core_seq) + tmp452 := checkDerefVar(var_glojure_DOT_core_concat) + tmp453 := checkDerefVar(var_glojure_DOT_core_list) + tmp454 := lang.Apply(tmp453, []any{sym_glojure_DOT_core_SLASH_chunk}) + tmp455 := checkDerefVar(var_glojure_DOT_core_list) + tmp456 := lang.Apply(tmp455, []any{v175}) + tmp457 := lang.Apply(tmp452, []any{tmp454, tmp456}) + tmp458 := lang.Apply(tmp451, []any{tmp457}) + tmp459 := lang.Apply(tmp450, []any{tmp458}) + tmp460 := checkDerefVar(var_glojure_DOT_core_list) + tmp461 := lang.Apply(tmp460, []any{nil}) + tmp462 := lang.Apply(tmp447, []any{tmp449, tmp459, tmp461}) + tmp463 := lang.Apply(tmp446, []any{tmp462}) + tmp464 := lang.Apply(tmp445, []any{tmp463}) + tmp465 := lang.Apply(tmp321, []any{tmp323, tmp408, tmp444, tmp464}) + tmp466 := lang.Apply(tmp320, []any{tmp465}) + tmp467 := lang.Apply(tmp319, []any{tmp466}) + tmp468 := lang.Apply(tmp263, []any{tmp265, tmp318, tmp467}) + tmp469 := lang.Apply(tmp262, []any{tmp468}) + tmp470 := lang.Apply(tmp261, []any{tmp469}) + tmp471 := checkDerefVar(var_glojure_DOT_core_list) + tmp472 := checkDerefVar(var_glojure_DOT_core_seq) + tmp473 := checkDerefVar(var_glojure_DOT_core_concat) + tmp474 := checkDerefVar(var_glojure_DOT_core_list) + tmp475 := lang.Apply(tmp474, []any{sym_glojure_DOT_core_SLASH_let}) + tmp476 := checkDerefVar(var_glojure_DOT_core_list) + tmp477 := checkDerefVar(var_glojure_DOT_core_apply) + tmp478 := checkDerefVar(var_glojure_DOT_core_vector) + tmp479 := checkDerefVar(var_glojure_DOT_core_seq) + tmp480 := checkDerefVar(var_glojure_DOT_core_concat) + tmp481 := checkDerefVar(var_glojure_DOT_core_list) + tmp482 := lang.Apply(tmp481, []any{v65}) + tmp483 := checkDerefVar(var_glojure_DOT_core_list) + tmp484 := checkDerefVar(var_glojure_DOT_core_seq) + tmp485 := checkDerefVar(var_glojure_DOT_core_concat) + tmp486 := checkDerefVar(var_glojure_DOT_core_list) + tmp487 := lang.Apply(tmp486, []any{sym_glojure_DOT_core_SLASH_first}) + tmp488 := checkDerefVar(var_glojure_DOT_core_list) + tmp489 := lang.Apply(tmp488, []any{v91}) + tmp490 := lang.Apply(tmp485, []any{tmp487, tmp489}) + tmp491 := lang.Apply(tmp484, []any{tmp490}) + tmp492 := lang.Apply(tmp483, []any{tmp491}) + tmp493 := lang.Apply(tmp480, []any{tmp482, tmp492}) + tmp494 := lang.Apply(tmp479, []any{tmp493}) + tmp495 := lang.Apply(tmp477, []any{tmp478, tmp494}) + tmp496 := lang.Apply(tmp476, []any{tmp495}) + tmp497 := checkDerefVar(var_glojure_DOT_core_list) + tmp498 := lang.Apply(v95, []any{v73}) + tmp499 := lang.Apply(tmp497, []any{tmp498}) + tmp500 := lang.Apply(tmp473, []any{tmp475, tmp496, tmp499}) + tmp501 := lang.Apply(tmp472, []any{tmp500}) + tmp502 := lang.Apply(tmp471, []any{tmp501}) + tmp503 := lang.Apply(tmp248, []any{tmp250, tmp260, tmp470, tmp502}) + tmp504 := lang.Apply(tmp247, []any{tmp503}) + tmp505 := lang.Apply(tmp246, []any{tmp504}) + tmp506 := lang.Apply(tmp222, []any{tmp224, tmp245, tmp505}) + tmp507 := lang.Apply(tmp221, []any{tmp506}) + tmp508 := lang.Apply(tmp220, []any{tmp507}) + tmp509 := lang.Apply(tmp204, []any{tmp206, tmp219, tmp508}) + tmp510 := lang.Apply(tmp203, []any{tmp509}) + tmp511 := lang.Apply(tmp202, []any{tmp510}) + tmp512 := lang.Apply(tmp199, []any{tmp201, tmp511}) + tmp513 := lang.Apply(tmp198, []any{tmp512}) + tmp514 := lang.Apply(tmp197, []any{tmp513}) + tmp515 := lang.Apply(tmp181, []any{tmp183, tmp185, tmp196, tmp514}) + tmp516 := lang.Apply(tmp180, []any{tmp515}) + tmp169 = tmp516 } // end let - tmp13 = tmp14 + tmp96 = tmp169 } - tmp10 = tmp13 + tmp85 = tmp96 } // end let - return tmp10 - case 3: - v8 := args[0] - _ = v8 - v9 := args[1] - _ = v9 - v10 := args[2] - _ = v10 - var tmp11 any + tmp44 = tmp85 + } // end let + return tmp44 + }) + v42 = tmp41 + _ = v42 + } + tmp42 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4668), kw_column, int(19), kw_end_DASH_line, int(4729), kw_end_DASH_column, int(68)) + tmp43, err := lang.WithMeta(tmp41, tmp42.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v44 any = tmp43 + _ = v44 + tmp45 := checkDerefVar(var_glojure_DOT_core_seq) + tmp46 := checkDerefVar(var_glojure_DOT_core_concat) + tmp47 := checkDerefVar(var_glojure_DOT_core_list) + tmp48 := lang.Apply(tmp47, []any{sym_glojure_DOT_core_SLASH_let}) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) + tmp50 := checkDerefVar(var_glojure_DOT_core_apply) + tmp51 := checkDerefVar(var_glojure_DOT_core_vector) + tmp52 := checkDerefVar(var_glojure_DOT_core_seq) + tmp53 := checkDerefVar(var_glojure_DOT_core_concat) + tmp54 := checkDerefVar(var_glojure_DOT_core_list) + tmp55 := lang.Apply(tmp54, []any{sym_iter__0__auto__}) + tmp56 := checkDerefVar(var_glojure_DOT_core_list) + tmp57 := lang.Apply(v36, []any{v4}) + tmp58 := lang.Apply(v44, []any{tmp57}) + tmp59 := lang.Apply(tmp56, []any{tmp58}) + tmp60 := lang.Apply(tmp53, []any{tmp55, tmp59}) + tmp61 := lang.Apply(tmp52, []any{tmp60}) + tmp62 := lang.Apply(tmp50, []any{tmp51, tmp61}) + tmp63 := lang.Apply(tmp49, []any{tmp62}) + tmp64 := checkDerefVar(var_glojure_DOT_core_list) + tmp65 := checkDerefVar(var_glojure_DOT_core_seq) + tmp66 := checkDerefVar(var_glojure_DOT_core_concat) + tmp67 := checkDerefVar(var_glojure_DOT_core_list) + tmp68 := lang.Apply(tmp67, []any{sym_iter__0__auto__}) + tmp69 := checkDerefVar(var_glojure_DOT_core_list) + tmp70 := checkDerefVar(var_glojure_DOT_core_second) + tmp71 := lang.Apply(tmp70, []any{v4}) + tmp72 := lang.Apply(tmp69, []any{tmp71}) + tmp73 := lang.Apply(tmp66, []any{tmp68, tmp72}) + tmp74 := lang.Apply(tmp65, []any{tmp73}) + tmp75 := lang.Apply(tmp64, []any{tmp74}) + tmp76 := lang.Apply(tmp46, []any{tmp48, tmp63, tmp75}) + tmp77 := lang.Apply(tmp45, []any{tmp76}) + tmp32 = tmp77 + } // end let + return tmp32 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_for = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_for.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // let + { + tmp0 := sym_let.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "binding => binding-form init-expr\n binding-form => name, or destructuring-form\n destructuring-form => map-destructure-form, or seq-destructure-form\n\n Evaluates the exprs in a lexical context in which the symbols in\n the binding-forms are bound to their respective init-exprs or parts\n therein.\n\n See https://glojure.org/reference/special_forms#binding-forms for\n more information about destructuring.", kw_forms, lang.NewVector(lang.NewList(sym_let, lang.NewVector(sym_bindings_STAR_), sym_exprs_STAR_)), kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(11), kw_line, int(4496), kw_end_DASH_line, int(4496), kw_special_DASH_form, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v4}) + if lang.IsTruthy(tmp8) { + } else { + tmp9 := checkDerefVar(var_glojure_DOT_core_str) + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp13 := checkDerefVar(var_glojure_DOT_core_meta) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(kw_line, []any{tmp14}) + tmp16 := lang.Apply(tmp9, []any{tmp11, " requires ", "a vector for its binding", " in ", tmp12, ":", tmp15}) + tmp17 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp16}) + panic(tmp17) + } + _ = tmp6 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_even_QMARK_) + tmp20 := checkDerefVar(var_glojure_DOT_core_count) + tmp21 := lang.Apply(tmp20, []any{v4}) + tmp22 := lang.Apply(tmp19, []any{tmp21}) + if lang.IsTruthy(tmp22) { + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp27 := checkDerefVar(var_glojure_DOT_core_meta) + tmp28 := lang.Apply(tmp27, []any{v2}) + tmp29 := lang.Apply(kw_line, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp25, " requires ", "an even number of forms in binding vector", " in ", tmp26, ":", tmp29}) + tmp31 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp31) + } + _ = tmp18 + tmp32 := checkDerefVar(var_glojure_DOT_core_seq) + tmp33 := checkDerefVar(var_glojure_DOT_core_concat) + tmp34 := checkDerefVar(var_glojure_DOT_core_list) + tmp35 := lang.Apply(tmp34, []any{sym_let_STAR_}) + tmp36 := checkDerefVar(var_glojure_DOT_core_list) + tmp37 := checkDerefVar(var_glojure_DOT_core_destructure) + tmp38 := lang.Apply(tmp37, []any{v4}) + tmp39 := lang.Apply(tmp36, []any{tmp38}) + tmp40 := lang.Apply(tmp33, []any{tmp35, tmp39, v5}) + tmp41 := lang.Apply(tmp32, []any{tmp40}) + return tmp41 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_let = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_let.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // loop + { + tmp0 := sym_loop.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "Evaluates the exprs in a lexical context in which the symbols in\n the binding-forms are bound to their respective init-exprs or parts\n therein. Acts as a recur target.", kw_forms, lang.NewVector(lang.NewList(sym_loop, lang.NewVector(sym_bindings_STAR_), sym_exprs_STAR_)), kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(11), kw_line, int(4597), kw_end_DASH_line, int(4597), kw_special_DASH_form, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v4}) + if lang.IsTruthy(tmp8) { + } else { + tmp9 := checkDerefVar(var_glojure_DOT_core_str) + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp13 := checkDerefVar(var_glojure_DOT_core_meta) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(kw_line, []any{tmp14}) + tmp16 := lang.Apply(tmp9, []any{tmp11, " requires ", "a vector for its binding", " in ", tmp12, ":", tmp15}) + tmp17 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp16}) + panic(tmp17) + } + _ = tmp6 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_even_QMARK_) + tmp20 := checkDerefVar(var_glojure_DOT_core_count) + tmp21 := lang.Apply(tmp20, []any{v4}) + tmp22 := lang.Apply(tmp19, []any{tmp21}) + if lang.IsTruthy(tmp22) { + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp27 := checkDerefVar(var_glojure_DOT_core_meta) + tmp28 := lang.Apply(tmp27, []any{v2}) + tmp29 := lang.Apply(kw_line, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp25, " requires ", "an even number of forms in binding vector", " in ", tmp26, ":", tmp29}) + tmp31 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp31) + } + _ = tmp18 + var tmp32 any + { // let + // let binding "db" + tmp33 := checkDerefVar(var_glojure_DOT_core_destructure) + tmp34 := lang.Apply(tmp33, []any{v4}) + var v35 any = tmp34 + _ = v35 + var tmp36 any + tmp37 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp38 := lang.Apply(tmp37, []any{v35, v4}) + if lang.IsTruthy(tmp38) { + tmp39 := checkDerefVar(var_glojure_DOT_core_seq) + tmp40 := checkDerefVar(var_glojure_DOT_core_concat) + tmp41 := checkDerefVar(var_glojure_DOT_core_list) + tmp42 := lang.Apply(tmp41, []any{sym_loop_STAR_}) + tmp43 := checkDerefVar(var_glojure_DOT_core_list) + tmp44 := lang.Apply(tmp43, []any{v4}) + tmp45 := lang.Apply(tmp40, []any{tmp42, tmp44, v5}) + tmp46 := lang.Apply(tmp39, []any{tmp45}) + tmp36 = tmp46 + } else { + var tmp47 any + { // let + // let binding "vs" + tmp48 := checkDerefVar(var_glojure_DOT_core_take_DASH_nth) + tmp49 := checkDerefVar(var_glojure_DOT_core_drop) + tmp50 := lang.Apply(tmp49, []any{int64(1), v4}) + tmp51 := lang.Apply(tmp48, []any{int64(2), tmp50}) + var v52 any = tmp51 + _ = v52 + // let binding "bs" + tmp53 := checkDerefVar(var_glojure_DOT_core_take_DASH_nth) + tmp54 := lang.Apply(tmp53, []any{int64(2), v4}) + var v55 any = tmp54 + _ = v55 + // let binding "gs" + tmp56 := checkDerefVar(var_glojure_DOT_core_map) + var tmp57 lang.FnFunc + tmp57 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v58 := args[0] + _ = v58 + var tmp59 any + tmp60 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp61 := lang.Apply(tmp60, []any{v58}) + if lang.IsTruthy(tmp61) { + tmp59 = v58 + } else { + tmp62 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp63 := lang.Apply(tmp62, nil) + tmp59 = tmp63 + } + return tmp59 + }) + tmp58 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4611), kw_column, int(23), kw_end_DASH_line, int(4611), kw_end_DASH_column, int(58)) + tmp59, err := lang.WithMeta(tmp57, tmp58.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp60 := lang.Apply(tmp56, []any{tmp59, v55}) + var v61 any = tmp60 + _ = v61 + // let binding "bfs" + tmp62 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp63 lang.FnFunc + tmp63 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v64 := args[0] + _ = v64 + v65 := args[1] + _ = v65 + var tmp66 any + { // let + // let binding "vec__17" + var v67 any = v65 + _ = v67 + // let binding "b" + tmp68 := checkDerefVar(var_glojure_DOT_core_nth) + tmp69 := lang.Apply(tmp68, []any{v67, int64(0), nil}) + var v70 any = tmp69 + _ = v70 + // let binding "v" + tmp71 := checkDerefVar(var_glojure_DOT_core_nth) + tmp72 := lang.Apply(tmp71, []any{v67, int64(1), nil}) + var v73 any = tmp72 + _ = v73 + // let binding "g" + tmp74 := checkDerefVar(var_glojure_DOT_core_nth) + tmp75 := lang.Apply(tmp74, []any{v67, int64(2), nil}) + var v76 any = tmp75 + _ = v76 + var tmp77 any + tmp78 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp79 := lang.Apply(tmp78, []any{v70}) + if lang.IsTruthy(tmp79) { + tmp80 := checkDerefVar(var_glojure_DOT_core_conj) + tmp81 := lang.Apply(tmp80, []any{v64, v76, v73}) + tmp77 = tmp81 + } else { + tmp82 := checkDerefVar(var_glojure_DOT_core_conj) + tmp83 := lang.Apply(tmp82, []any{v64, v76, v73, v70, v76}) + tmp77 = tmp83 + } + tmp66 = tmp77 + } // end let + return tmp66 + }) + tmp64 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4612), kw_column, int(28), kw_end_DASH_line, int(4615), kw_end_DASH_column, int(50)) + tmp65, err := lang.WithMeta(tmp63, tmp64.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp66 := lang.NewVector() + tmp67 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4616), kw_column, int(27), kw_end_DASH_line, int(4616), kw_end_DASH_column, int(28)) + tmp68, err := lang.WithMeta(tmp66, tmp67.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp69 := checkDerefVar(var_glojure_DOT_core_map) + tmp70 := checkDerefVar(var_glojure_DOT_core_vector) + tmp71 := lang.Apply(tmp69, []any{tmp70, v55, v52, v61}) + tmp72 := lang.Apply(tmp62, []any{tmp65, tmp68, tmp71}) + var v73 any = tmp72 + _ = v73 + tmp74 := checkDerefVar(var_glojure_DOT_core_seq) + tmp75 := checkDerefVar(var_glojure_DOT_core_concat) + tmp76 := checkDerefVar(var_glojure_DOT_core_list) + tmp77 := lang.Apply(tmp76, []any{sym_glojure_DOT_core_SLASH_let}) + tmp78 := checkDerefVar(var_glojure_DOT_core_list) + tmp79 := lang.Apply(tmp78, []any{v73}) + tmp80 := checkDerefVar(var_glojure_DOT_core_list) + tmp81 := checkDerefVar(var_glojure_DOT_core_seq) + tmp82 := checkDerefVar(var_glojure_DOT_core_concat) + tmp83 := checkDerefVar(var_glojure_DOT_core_list) + tmp84 := lang.Apply(tmp83, []any{sym_loop_STAR_}) + tmp85 := checkDerefVar(var_glojure_DOT_core_list) + tmp86 := checkDerefVar(var_glojure_DOT_core_vec) + tmp87 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp88 := lang.Apply(tmp87, []any{v61, v61}) + tmp89 := lang.Apply(tmp86, []any{tmp88}) + tmp90 := lang.Apply(tmp85, []any{tmp89}) + tmp91 := checkDerefVar(var_glojure_DOT_core_list) + tmp92 := checkDerefVar(var_glojure_DOT_core_seq) + tmp93 := checkDerefVar(var_glojure_DOT_core_concat) + tmp94 := checkDerefVar(var_glojure_DOT_core_list) + tmp95 := lang.Apply(tmp94, []any{sym_glojure_DOT_core_SLASH_let}) + tmp96 := checkDerefVar(var_glojure_DOT_core_list) + tmp97 := checkDerefVar(var_glojure_DOT_core_vec) + tmp98 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp99 := lang.Apply(tmp98, []any{v55, v61}) + tmp100 := lang.Apply(tmp97, []any{tmp99}) + tmp101 := lang.Apply(tmp96, []any{tmp100}) + tmp102 := lang.Apply(tmp93, []any{tmp95, tmp101, v5}) + tmp103 := lang.Apply(tmp92, []any{tmp102}) + tmp104 := lang.Apply(tmp91, []any{tmp103}) + tmp105 := lang.Apply(tmp82, []any{tmp84, tmp90, tmp104}) + tmp106 := lang.Apply(tmp81, []any{tmp105}) + tmp107 := lang.Apply(tmp80, []any{tmp106}) + tmp108 := lang.Apply(tmp75, []any{tmp77, tmp79, tmp107}) + tmp109 := lang.Apply(tmp74, []any{tmp108}) + tmp47 = tmp109 + } // end let + tmp36 = tmp47 + } + tmp32 = tmp36 + } // end let + return tmp32 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_loop = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_loop.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print-map + { + tmp0 := sym_print_DASH_map.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(252), kw_column, int(8), kw_end_DASH_line, int(252), kw_end_DASH_column, int(16), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_m, sym_print_DASH_one, sym_w)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_print_DASH_prefix_DASH_map) + tmp6 := lang.Apply(tmp5, []any{nil, v2, v3, v4}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_print_DASH_map = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_print_DASH_map.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + var closed11 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_seq_DASH_reduce) + tmp4 := lang.Apply(tmp3, []any{v1, v2}) + return tmp4 + case 3: + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + v3 := args[2] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_seq_DASH_reduce) + tmp5 := lang.Apply(tmp4, []any{v1, v2, v3}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + closed11 = tmp0 + } + var closed12 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_seq_DASH_reduce) + tmp4 := lang.Apply(tmp3, []any{v1, v2}) + return tmp4 + case 3: + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + v3 := args[2] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_seq_DASH_reduce) + tmp5 := lang.Apply(tmp4, []any{v1, v2, v3}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + closed12 = tmp0 + } + var closed14 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + v3 := args[2] + _ = v3 + recur_loop_1275: + var tmp4 any + { // let + // let binding "temp__0__auto__" + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := lang.Apply(tmp5, []any{v1}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + if lang.IsTruthy(v7) { + var tmp9 any + { // let + // let binding "s" + var v10 any = v7 + _ = v10 + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp13 := lang.Apply(tmp12, []any{v10}) + if lang.IsTruthy(tmp13) { + var tmp14 any { // let - // let binding "or__0__auto__" - tmp12 := lang.Apply(v3, []any{v8}) - var v13 any = tmp12 - _ = v13 - var tmp14 any - if lang.IsTruthy(v13) { - tmp14 = v13 + // let binding "ret" + tmp15 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp16 := lang.Apply(tmp15, []any{v10}) + tmp17, _ := lang.FieldOrMethod(tmp16, "ReduceInit") + if reflect.TypeOf(tmp17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) + } + tmp18 := lang.Apply(tmp17, []any{v2, v3}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + tmp21 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) + tmp22 := lang.Apply(tmp21, []any{v19}) + if lang.IsTruthy(tmp22) { + tmp23 := checkDerefVar(var_glojure_DOT_core_deref) + tmp24 := lang.Apply(tmp23, []any{v19}) + tmp20 = tmp24 } else { - var tmp15 any + tmp26 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_next) + tmp27 := lang.Apply(tmp26, []any{v10}) + var tmp25 any = tmp27 + var tmp28 any = v2 + var tmp29 any = v19 + v1 = tmp25 + v2 = tmp28 + v3 = tmp29 + goto recur_loop_1275 + } + tmp14 = tmp20 + } // end let + tmp11 = tmp14 + } else { + tmp15 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_interface_DASH_or_DASH_naive_DASH_reduce) + tmp16 := lang.Apply(tmp15, []any{v10, v2, v3}) + tmp11 = tmp16 + } + tmp9 = tmp11 + } // end let + tmp8 = tmp9 + } else { + tmp8 = v3 + } + tmp4 = tmp8 + } // end let + return tmp4 + }) + closed14 = tmp0 + } + var closed15 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + v3 := args[2] + _ = v3 + var tmp4 any + { // let + // let binding "cls" + tmp5 := checkDerefVar(var_glojure_DOT_core_class) + tmp6 := lang.Apply(tmp5, []any{v1}) + var v7 any = tmp6 + _ = v7 + // let binding "s" + var v8 any = v1 + _ = v8 + // let binding "f" + var v9 any = v2 + _ = v9 + // let binding "val" + var v10 any = v3 + _ = v10 + for { + var tmp11 any + { // let + // let binding "temp__0__auto__" + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := lang.Apply(tmp12, []any{v8}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + var tmp16 any + { // let + // let binding "s" + var v17 any = v14 + _ = v17 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_identical_QMARK_) + tmp20 := checkDerefVar(var_glojure_DOT_core_class) + tmp21 := lang.Apply(tmp20, []any{v17}) + tmp22 := lang.Apply(tmp19, []any{tmp21, v7}) + if lang.IsTruthy(tmp22) { + var tmp23 any { // let - // let binding "or__0__auto__" - tmp16 := lang.Apply(v3, []any{v9}) - var v17 any = tmp16 - _ = v17 - var tmp18 any - if lang.IsTruthy(v17) { - tmp18 = v17 + // let binding "ret" + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v17}) + tmp26 := lang.Apply(v9, []any{v10, tmp25}) + var v27 any = tmp26 + _ = v27 + var tmp28 any + tmp29 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) + tmp30 := lang.Apply(tmp29, []any{v27}) + if lang.IsTruthy(tmp30) { + tmp31 := checkDerefVar(var_glojure_DOT_core_deref) + tmp32 := lang.Apply(tmp31, []any{v27}) + tmp28 = tmp32 } else { - var tmp19 any - { // let - // let binding "or__0__auto__" - tmp20 := lang.Apply(v3, []any{v10}) - var v21 any = tmp20 - _ = v21 - var tmp22 any - if lang.IsTruthy(v21) { - tmp22 = v21 - } else { - var tmp23 any - { // let - // let binding "or__0__auto__" - tmp24 := lang.Apply(v4, []any{v8}) - var v25 any = tmp24 - _ = v25 - var tmp26 any - if lang.IsTruthy(v25) { - tmp26 = v25 - } else { - var tmp27 any - { // let - // let binding "or__0__auto__" - tmp28 := lang.Apply(v4, []any{v9}) - var v29 any = tmp28 - _ = v29 - var tmp30 any - if lang.IsTruthy(v29) { - tmp30 = v29 - } else { - var tmp31 any - { // let - // let binding "or__0__auto__" - tmp32 := lang.Apply(v4, []any{v10}) - var v33 any = tmp32 - _ = v33 - var tmp34 any - if lang.IsTruthy(v33) { - tmp34 = v33 - } else { - var tmp35 any - { // let - // let binding "or__0__auto__" - tmp36 := lang.Apply(v5, []any{v8}) - var v37 any = tmp36 - _ = v37 - var tmp38 any - if lang.IsTruthy(v37) { - tmp38 = v37 - } else { - var tmp39 any - { // let - // let binding "or__0__auto__" - tmp40 := lang.Apply(v5, []any{v9}) - var v41 any = tmp40 - _ = v41 - var tmp42 any - if lang.IsTruthy(v41) { - tmp42 = v41 - } else { - tmp43 := lang.Apply(v5, []any{v10}) - tmp42 = tmp43 - } - tmp39 = tmp42 - } // end let - tmp38 = tmp39 - } - tmp35 = tmp38 - } // end let - tmp34 = tmp35 - } - tmp31 = tmp34 - } // end let - tmp30 = tmp31 - } - tmp27 = tmp30 - } // end let - tmp26 = tmp27 - } - tmp23 = tmp26 - } // end let - tmp22 = tmp23 - } - tmp19 = tmp22 - } // end let - tmp18 = tmp19 + var tmp33 any = v7 + tmp35 := checkDerefVar(var_glojure_DOT_core_next) + tmp36 := lang.Apply(tmp35, []any{v17}) + var tmp34 any = tmp36 + var tmp37 any = v9 + var tmp38 any = v27 + v7 = tmp33 + v8 = tmp34 + v9 = tmp37 + v10 = tmp38 + continue } - tmp15 = tmp18 + tmp23 = tmp28 } // end let - tmp14 = tmp15 - } - tmp11 = tmp14 - } // end let - return tmp11 - default: - checkArity(args, 3) - v8 := args[0] - _ = v8 - v9 := args[1] - _ = v9 - v10 := args[2] - _ = v10 - var v11 any = lang.NewList(args[3:]...) - _ = v11 - var tmp12 any - { // let - // let binding "or__0__auto__" - tmp13 := lang.Apply(v7, []any{v8, v9, v10}) - var v14 any = tmp13 - _ = v14 - var tmp15 any - if lang.IsTruthy(v14) { - tmp15 = v14 + tmp18 = tmp23 } else { - tmp16 := checkDerefVar(var_glojure_DOT_core_some) - var tmp17 lang.FnFunc - tmp17 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v18 := args[0] - _ = v18 - var tmp19 any - { // let - // let binding "or__0__auto__" - tmp20 := lang.Apply(v3, []any{v18}) - var v21 any = tmp20 - _ = v21 - var tmp22 any - if lang.IsTruthy(v21) { - tmp22 = v21 - } else { - var tmp23 any - { // let - // let binding "or__0__auto__" - tmp24 := lang.Apply(v4, []any{v18}) - var v25 any = tmp24 - _ = v25 - var tmp26 any - if lang.IsTruthy(v25) { - tmp26 = v25 - } else { - tmp27 := lang.Apply(v5, []any{v18}) - tmp26 = tmp27 - } - tmp23 = tmp26 - } // end let - tmp22 = tmp23 - } - tmp19 = tmp22 - } // end let - return tmp19 - }) - tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7491), kw_column, int(34), kw_end_DASH_line, int(7491), kw_end_DASH_column, int(59)) - tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp20 := lang.Apply(tmp16, []any{tmp19, v11}) - tmp15 = tmp20 + tmp24 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_interface_DASH_or_DASH_naive_DASH_reduce) + tmp25 := lang.Apply(tmp24, []any{v17, v9, v10}) + tmp18 = tmp25 } - tmp12 = tmp15 + tmp16 = tmp18 } // end let - return tmp12 + tmp15 = tmp16 + } else { + tmp15 = v10 } - }) - v7 = tmp6 - _ = v7 - } - tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7485), kw_column, int(6), kw_end_DASH_line, int(7491), kw_end_DASH_column, int(68)) - tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) - if err != nil { - panic(err) + tmp11 = tmp15 + } // end let + tmp4 = tmp11 + break } - return tmp8 + } // end let + return tmp4 + }) + closed15 = tmp0 + } + var closed18 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_go_DOT_io_make_DASH_input_DASH_stream) + tmp4 := lang.Apply(tmp3, []any{v1, v2}) + return tmp4 + }) + tmp0 = tmp0.WithMeta(lang.NewMap(kw_file, "glojure/go/io.glj", kw_line, int(167), kw_column, int(17), kw_end_DASH_line, int(167), kw_end_DASH_column, int(56))).(lang.FnFunc) + closed18 = tmp0 + } + var closed19 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_go_DOT_io_make_DASH_writer) + tmp4 := checkDerefVar(var_glojure_DOT_go_DOT_io_make_DASH_output_DASH_stream) + tmp5 := lang.Apply(tmp4, []any{v1, v2}) + tmp6 := lang.Apply(tmp3, []any{tmp5, v2}) + return tmp6 + }) + tmp0 = tmp0.WithMeta(lang.NewMap(kw_file, "glojure/go/io.glj", kw_line, int(168), kw_column, int(17), kw_end_DASH_line, int(168), kw_end_DASH_column, int(76))).(lang.FnFunc) + closed19 = tmp0 + } + var closed22 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_go_DOT_io_make_DASH_input_DASH_stream) + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp6, ok := lang.FieldOrMethod(v1, "scheme") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v1, "scheme"))) + } + var tmp7 any + switch reflect.TypeOf(tmp6).Kind() { + case reflect.Func: + tmp7 = lang.Apply(tmp6, nil) default: - checkArity(args, 3) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any + tmp7 = tmp6 + } + tmp8 := lang.Apply(tmp5, []any{"file", tmp7}) + if lang.IsTruthy(tmp8) { + tmp9 := lang.Apply(nil, []any{v1}) + tmp4 = tmp9 + } else { + var tmp10 any { // let - // let binding "ps" - tmp8 := checkDerefVar(var_glojure_DOT_core_list_STAR_) - tmp9 := lang.Apply(tmp8, []any{v3, v4, v5, v6}) - var v10 any = tmp9 - _ = v10 - var tmp11 lang.FnFunc - { // function spn - var v12 lang.FnFunc - tmp11 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - return nil - case 1: - v13 := args[0] - _ = v13 - tmp14 := checkDerefVar(var_glojure_DOT_core_some) - var tmp15 lang.FnFunc - tmp15 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v16 := args[0] - _ = v16 - tmp17 := lang.Apply(v16, []any{v13}) - return tmp17 - }) - tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7496), kw_column, int(21), kw_end_DASH_line, int(7496), kw_end_DASH_column, int(26)) - tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp18 := lang.Apply(tmp14, []any{tmp17, v10}) - return tmp18 - case 2: - v13 := args[0] - _ = v13 - v14 := args[1] - _ = v14 - tmp15 := checkDerefVar(var_glojure_DOT_core_some) - var tmp16 lang.FnFunc - tmp16 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v17 := args[0] - _ = v17 - var tmp18 any - { // let - // let binding "or__0__auto__" - tmp19 := lang.Apply(v17, []any{v13}) - var v20 any = tmp19 - _ = v20 - var tmp21 any - if lang.IsTruthy(v20) { - tmp21 = v20 - } else { - tmp22 := lang.Apply(v17, []any{v14}) - tmp21 = tmp22 - } - tmp18 = tmp21 - } // end let - return tmp18 - }) - tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7497), kw_column, int(23), kw_end_DASH_line, int(7497), kw_end_DASH_column, int(39)) - tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp19 := lang.Apply(tmp15, []any{tmp18, v10}) - return tmp19 - case 3: - v13 := args[0] - _ = v13 - v14 := args[1] - _ = v14 - v15 := args[2] - _ = v15 - tmp16 := checkDerefVar(var_glojure_DOT_core_some) - var tmp17 lang.FnFunc - tmp17 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v18 := args[0] - _ = v18 - var tmp19 any - { // let - // let binding "or__0__auto__" - tmp20 := lang.Apply(v18, []any{v13}) - var v21 any = tmp20 - _ = v21 - var tmp22 any - if lang.IsTruthy(v21) { - tmp22 = v21 - } else { - var tmp23 any - { // let - // let binding "or__0__auto__" - tmp24 := lang.Apply(v18, []any{v14}) - var v25 any = tmp24 - _ = v25 - var tmp26 any - if lang.IsTruthy(v25) { - tmp26 = v25 - } else { - tmp27 := lang.Apply(v18, []any{v15}) - tmp26 = tmp27 - } - tmp23 = tmp26 - } // end let - tmp22 = tmp23 - } - tmp19 = tmp22 - } // end let - return tmp19 - }) - tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7498), kw_column, int(25), kw_end_DASH_line, int(7498), kw_end_DASH_column, int(47)) - tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp20 := lang.Apply(tmp16, []any{tmp19, v10}) - return tmp20 - default: - checkArity(args, 3) - v13 := args[0] - _ = v13 - v14 := args[1] - _ = v14 - v15 := args[2] - _ = v15 - var v16 any = lang.NewList(args[3:]...) - _ = v16 - var tmp17 any - { // let - // let binding "or__0__auto__" - tmp18 := lang.Apply(v12, []any{v13, v14, v15}) - var v19 any = tmp18 - _ = v19 - var tmp20 any - if lang.IsTruthy(v19) { - tmp20 = v19 - } else { - tmp21 := checkDerefVar(var_glojure_DOT_core_some) - var tmp22 lang.FnFunc - tmp22 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v23 := args[0] - _ = v23 - tmp24 := checkDerefVar(var_glojure_DOT_core_some) - tmp25 := lang.Apply(tmp24, []any{v23, v16}) - return tmp25 - }) - tmp23 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7500), kw_column, int(36), kw_end_DASH_line, int(7500), kw_end_DASH_column, int(49)) - tmp24, err := lang.WithMeta(tmp22, tmp23.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp25 := lang.Apply(tmp21, []any{tmp24, v10}) - tmp20 = tmp25 - } - tmp17 = tmp20 - } // end let - return tmp17 + // let binding "req" + var tmp11 any + { // let + // let binding "res__0__auto__" + tmp12, ok := lang.FieldOrMethod(v1, "String") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v1, "String"))) + } + var tmp13 any + switch reflect.TypeOf(tmp12).Kind() { + case reflect.Func: + tmp13 = lang.Apply(tmp12, nil) + default: + tmp13 = tmp12 + } + tmp14 := lang.Apply(http17.NewRequest, []any{http17.MethodGet, tmp13, nil}) + var v15 any = tmp14 + _ = v15 + // let binding "vec__295" + var tmp16 any + tmp17 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp18 := lang.Apply(tmp17, []any{v15}) + if lang.IsTruthy(tmp18) { + tmp19 := checkDerefVar(var_glojure_DOT_core_pop) + tmp20 := lang.Apply(tmp19, []any{v15}) + tmp21 := checkDerefVar(var_glojure_DOT_core_last) + tmp22 := lang.Apply(tmp21, []any{v15}) + tmp23 := lang.NewVector(tmp20, tmp22) + tmp24 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(358), kw_column, int(10), kw_end_DASH_line, int(358), kw_end_DASH_column, int(14)) + tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) + if err != nil { + panic(err) } - }) - v12 = tmp11 - _ = v12 + tmp16 = tmp25 + } else { + tmp26 := lang.NewVector(nil, v15) + tmp27 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(358), kw_column, int(10), kw_end_DASH_line, int(358), kw_end_DASH_column, int(14)) + tmp28, err := lang.WithMeta(tmp26, tmp27.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp16 = tmp28 + } + var v29 any = tmp16 + _ = v29 + // let binding "vec__298" + tmp30 := checkDerefVar(var_glojure_DOT_core_nth) + tmp31 := lang.Apply(tmp30, []any{v29, int64(0), nil}) + var v32 any = tmp31 + _ = v32 + // let binding "seq__299" + tmp33 := checkDerefVar(var_glojure_DOT_core_seq) + tmp34 := lang.Apply(tmp33, []any{v32}) + var v35 any = tmp34 + _ = v35 + // let binding "first__300" + tmp36 := checkDerefVar(var_glojure_DOT_core_first) + tmp37 := lang.Apply(tmp36, []any{v35}) + var v38 any = tmp37 + _ = v38 + // let binding "seq__299" + tmp39 := checkDerefVar(var_glojure_DOT_core_next) + tmp40 := lang.Apply(tmp39, []any{v35}) + var v41 any = tmp40 + _ = v41 + // let binding "fst__1__auto__" + var v42 any = v38 + _ = v42 + // let binding "rst__2__auto__" + var v43 any = v41 + _ = v43 + // let binding "res__0__auto__" + var v44 any = v32 + _ = v44 + // let binding "err__3__auto__" + tmp45 := checkDerefVar(var_glojure_DOT_core_nth) + tmp46 := lang.Apply(tmp45, []any{v29, int64(1), nil}) + var v47 any = tmp46 + _ = v47 + // let binding "res__0__auto__" + var tmp48 any + tmp49 := checkDerefVar(var_glojure_DOT_core_not_DASH_empty) + tmp50 := lang.Apply(tmp49, []any{v43}) + if lang.IsTruthy(tmp50) { + tmp48 = v44 + } else { + tmp48 = v42 + } + var v51 any = tmp48 + _ = v51 + var tmp52 any + if lang.IsTruthy(v47) { + panic(v47) + } else { + } + _ = tmp52 + tmp11 = v51 + } // end let + var v12 any = tmp11 + _ = v12 + // let binding "res" + var tmp13 any + { // let + // let binding "res__0__auto__" + tmp14, _ := lang.FieldOrMethod(http17.DefaultClient, "Do") + if reflect.TypeOf(tmp14).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Do is not a function"))) + } + tmp15 := lang.Apply(tmp14, []any{v12}) + var v16 any = tmp15 + _ = v16 + // let binding "vec__301" + var tmp17 any + tmp18 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp19 := lang.Apply(tmp18, []any{v16}) + if lang.IsTruthy(tmp19) { + tmp20 := checkDerefVar(var_glojure_DOT_core_pop) + tmp21 := lang.Apply(tmp20, []any{v16}) + tmp22 := checkDerefVar(var_glojure_DOT_core_last) + tmp23 := lang.Apply(tmp22, []any{v16}) + tmp24 := lang.NewVector(tmp21, tmp23) + tmp25 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(358), kw_column, int(10), kw_end_DASH_line, int(358), kw_end_DASH_column, int(14)) + tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp17 = tmp26 + } else { + tmp27 := lang.NewVector(nil, v16) + tmp28 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(358), kw_column, int(10), kw_end_DASH_line, int(358), kw_end_DASH_column, int(14)) + tmp29, err := lang.WithMeta(tmp27, tmp28.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp17 = tmp29 + } + var v30 any = tmp17 + _ = v30 + // let binding "vec__304" + tmp31 := checkDerefVar(var_glojure_DOT_core_nth) + tmp32 := lang.Apply(tmp31, []any{v30, int64(0), nil}) + var v33 any = tmp32 + _ = v33 + // let binding "seq__305" + tmp34 := checkDerefVar(var_glojure_DOT_core_seq) + tmp35 := lang.Apply(tmp34, []any{v33}) + var v36 any = tmp35 + _ = v36 + // let binding "first__306" + tmp37 := checkDerefVar(var_glojure_DOT_core_first) + tmp38 := lang.Apply(tmp37, []any{v36}) + var v39 any = tmp38 + _ = v39 + // let binding "seq__305" + tmp40 := checkDerefVar(var_glojure_DOT_core_next) + tmp41 := lang.Apply(tmp40, []any{v36}) + var v42 any = tmp41 + _ = v42 + // let binding "fst__1__auto__" + var v43 any = v39 + _ = v43 + // let binding "rst__2__auto__" + var v44 any = v42 + _ = v44 + // let binding "res__0__auto__" + var v45 any = v33 + _ = v45 + // let binding "err__3__auto__" + tmp46 := checkDerefVar(var_glojure_DOT_core_nth) + tmp47 := lang.Apply(tmp46, []any{v30, int64(1), nil}) + var v48 any = tmp47 + _ = v48 + // let binding "res__0__auto__" + var tmp49 any + tmp50 := checkDerefVar(var_glojure_DOT_core_not_DASH_empty) + tmp51 := lang.Apply(tmp50, []any{v44}) + if lang.IsTruthy(tmp51) { + tmp49 = v45 + } else { + tmp49 = v43 + } + var v52 any = tmp49 + _ = v52 + var tmp53 any + if lang.IsTruthy(v48) { + panic(v48) + } else { + } + _ = tmp53 + tmp13 = v52 + } // end let + var v14 any = tmp13 + _ = v14 + // let binding "status" + tmp15, ok := lang.FieldOrMethod(v14, "StatusCode") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v14, "StatusCode"))) } - tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7494), kw_column, int(8), kw_end_DASH_line, int(7500), kw_end_DASH_column, int(56)) - tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) - if err != nil { - panic(err) + var tmp16 any + switch reflect.TypeOf(tmp15).Kind() { + case reflect.Func: + tmp16 = lang.Apply(tmp15, nil) + default: + tmp16 = tmp15 + } + var v17 any = tmp16 + _ = v17 + // let binding "body" + tmp18, ok := lang.FieldOrMethod(v14, "Body") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v14, "Body"))) + } + var tmp19 any + switch reflect.TypeOf(tmp18).Kind() { + case reflect.Func: + tmp19 = lang.Apply(tmp18, nil) + default: + tmp19 = tmp18 + } + var v20 any = tmp19 + _ = v20 + var tmp21 any + tmp22 := checkDerefVar(var_glojure_DOT_core_not_EQ_) + tmp23 := lang.Apply(tmp22, []any{int64(200), v17}) + if lang.IsTruthy(tmp23) { + tmp24, ok := lang.FieldOrMethod(v20, "Close") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v20, "Close"))) + } + var tmp25 any + switch reflect.TypeOf(tmp24).Kind() { + case reflect.Func: + tmp25 = lang.Apply(tmp24, nil) + default: + tmp25 = tmp24 + } + _ = tmp25 + tmp26 := lang.Apply(fmt.Errorf, []any{"http error: %s", v17}) + panic(tmp26) + } else { } - tmp7 = tmp13 + _ = tmp21 + tmp10 = v20 } // end let - return tmp7 + tmp4 = tmp10 } + tmp11 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp11 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // some? - { - tmp1 := reflect.TypeOf(false) - tmp0 := sym_some_QMARK_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x is not nil, false otherwise.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.6", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(530), kw_end_DASH_line, int(530))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_not) - tmp6 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) - tmp7 := lang.Apply(tmp6, []any{v4}) - tmp8 := lang.Apply(tmp5, []any{tmp7}) - return tmp8 - }) - tmp4 := reflect.TypeOf(false) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } + tmp0 = tmp0.WithMeta(lang.NewMap(kw_file, "glojure/go/io.glj", kw_line, int(232), kw_column, int(24), kw_end_DASH_line, int(244), kw_end_DASH_column, int(32))).(lang.FnFunc) + closed22 = tmp0 } - // sort + var closed23 any { - tmp0 := sym_sort.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll), lang.NewVector(sym_comp, sym_coll)), kw_doc, "Returns a sorted sequence of the items in coll. If no comparator is\n supplied, uses compare. comparator must implement\n java.util.Comparator. Guaranteed to be stable: equal elements will\n not be reordered. If coll is a Java array, it will be modified. To\n avoid this, sort a copy of the array.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3085), kw_end_DASH_line, int(3085))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_sort) - tmp5 := checkDerefVar(var_glojure_DOT_core_compare) - tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) - return tmp6 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - tmp6 := checkDerefVar(var_glojure_DOT_core_seq) - tmp7 := lang.Apply(tmp6, []any{v4}) - if lang.IsTruthy(tmp7) { - var tmp8 any + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + var tmp3 any + { // let + // let binding "vec__307" + tmp4 := lang.Apply(url5.ParseRequestURI, []any{v1}) + var v5 any = tmp4 + _ = v5 + // let binding "url" + tmp6 := checkDerefVar(var_glojure_DOT_core_nth) + tmp7 := lang.Apply(tmp6, []any{v5, int64(0), nil}) + var v8 any = tmp7 + _ = v8 + // let binding "err" + tmp9 := checkDerefVar(var_glojure_DOT_core_nth) + tmp10 := lang.Apply(tmp9, []any{v5, int64(1), nil}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + tmp13 := checkDerefVar(var_glojure_DOT_go_DOT_io_make_DASH_input_DASH_stream) + var tmp14 any { // let - // let binding "a" - tmp9 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) - tmp10 := lang.Apply(tmp9, []any{v4}) - var v11 any = tmp10 - _ = v11 - tmp12 := lang.Apply(lang.SortSlice, []any{v11, v3}) - _ = tmp12 - tmp13 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) - tmp14 := checkDerefVar(var_glojure_DOT_core_seq) - tmp15 := lang.Apply(tmp14, []any{v11}) - tmp16 := checkDerefVar(var_glojure_DOT_core_meta) - tmp17 := lang.Apply(tmp16, []any{v4}) - tmp18 := lang.Apply(tmp13, []any{tmp15, tmp17}) - tmp8 = tmp18 + // let binding "res__0__auto__" + tmp15 := lang.Apply(os6.Open, []any{v1}) + var v16 any = tmp15 + _ = v16 + // let binding "vec__310" + var tmp17 any + tmp18 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp19 := lang.Apply(tmp18, []any{v16}) + if lang.IsTruthy(tmp19) { + tmp20 := checkDerefVar(var_glojure_DOT_core_pop) + tmp21 := lang.Apply(tmp20, []any{v16}) + tmp22 := checkDerefVar(var_glojure_DOT_core_last) + tmp23 := lang.Apply(tmp22, []any{v16}) + tmp24 := lang.NewVector(tmp21, tmp23) + tmp25 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(358), kw_column, int(10), kw_end_DASH_line, int(358), kw_end_DASH_column, int(14)) + tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp17 = tmp26 + } else { + tmp27 := lang.NewVector(nil, v16) + tmp28 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(358), kw_column, int(10), kw_end_DASH_line, int(358), kw_end_DASH_column, int(14)) + tmp29, err := lang.WithMeta(tmp27, tmp28.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp17 = tmp29 + } + var v30 any = tmp17 + _ = v30 + // let binding "vec__313" + tmp31 := checkDerefVar(var_glojure_DOT_core_nth) + tmp32 := lang.Apply(tmp31, []any{v30, int64(0), nil}) + var v33 any = tmp32 + _ = v33 + // let binding "seq__314" + tmp34 := checkDerefVar(var_glojure_DOT_core_seq) + tmp35 := lang.Apply(tmp34, []any{v33}) + var v36 any = tmp35 + _ = v36 + // let binding "first__315" + tmp37 := checkDerefVar(var_glojure_DOT_core_first) + tmp38 := lang.Apply(tmp37, []any{v36}) + var v39 any = tmp38 + _ = v39 + // let binding "seq__314" + tmp40 := checkDerefVar(var_glojure_DOT_core_next) + tmp41 := lang.Apply(tmp40, []any{v36}) + var v42 any = tmp41 + _ = v42 + // let binding "fst__1__auto__" + var v43 any = v39 + _ = v43 + // let binding "rst__2__auto__" + var v44 any = v42 + _ = v44 + // let binding "res__0__auto__" + var v45 any = v33 + _ = v45 + // let binding "err__3__auto__" + tmp46 := checkDerefVar(var_glojure_DOT_core_nth) + tmp47 := lang.Apply(tmp46, []any{v30, int64(1), nil}) + var v48 any = tmp47 + _ = v48 + // let binding "res__0__auto__" + var tmp49 any + tmp50 := checkDerefVar(var_glojure_DOT_core_not_DASH_empty) + tmp51 := lang.Apply(tmp50, []any{v44}) + if lang.IsTruthy(tmp51) { + tmp49 = v45 + } else { + tmp49 = v43 + } + var v52 any = tmp49 + _ = v52 + var tmp53 any + if lang.IsTruthy(v48) { + panic(v48) + } else { + } + _ = tmp53 + tmp14 = v52 } // end let - tmp5 = tmp8 + tmp15 := lang.Apply(tmp13, []any{tmp14, v2}) + tmp12 = tmp15 } else { - tmp5 = lang.NewList() + tmp16 := checkDerefVar(var_glojure_DOT_go_DOT_io_make_DASH_input_DASH_stream) + tmp17 := lang.Apply(tmp16, []any{v8, v2}) + tmp12 = tmp17 } - return tmp5 - default: - checkArity(args, -1) - panic("unreachable") - } + tmp3 = tmp12 + } // end let + return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } + tmp0 = tmp0.WithMeta(lang.NewMap(kw_file, "glojure/go/io.glj", kw_line, int(259), kw_column, int(24), kw_end_DASH_line, int(263), kw_end_DASH_column, int(60))).(lang.FnFunc) + closed23 = tmp0 } - // sort-by + var closed24 any { - tmp0 := sym_sort_DASH_by.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_keyfn, sym_coll), lang.NewVector(sym_keyfn, sym_comp, sym_coll)), kw_doc, "Returns a sorted sequence of the items in coll, where the sort\n order is determined by comparing (keyfn item). If no comparator is\n supplied, uses compare. comparator must implement\n java.util.Comparator. Guaranteed to be stable: equal elements will\n not be reordered. If coll is a Java array, it will be modified. To\n avoid this, sort a copy of the array.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(3102), kw_end_DASH_line, int(3102))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_sort_DASH_by) - tmp6 := checkDerefVar(var_glojure_DOT_core_compare) - tmp7 := lang.Apply(tmp5, []any{v3, tmp6, v4}) - return tmp7 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6 := checkDerefVar(var_glojure_DOT_core_sort) - var tmp7 lang.FnFunc - tmp7 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v8 := args[0] - _ = v8 - v9 := args[1] - _ = v9 - tmp10 := lang.Apply(v3, []any{v8}) - tmp11 := lang.Apply(v3, []any{v9}) - tmp12 := lang.Apply(v4, []any{tmp10, tmp11}) - return tmp12 - }) - tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3114), kw_column, int(10), kw_end_DASH_line, int(3114), kw_end_DASH_column, int(46)) - tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp10 := lang.Apply(tmp6, []any{tmp9, v5}) - return tmp10 - default: - checkArity(args, -1) - panic("unreachable") - } + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_str) + tmp4 := checkDerefVar(var_glojure_DOT_core_pr_DASH_str) + tmp5 := lang.Apply(tmp4, []any{v1}) + tmp6 := lang.Apply(tmp3, []any{"Cannot open <", tmp5, "> as an OutputStream."}) + tmp7 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp6}) + panic(tmp7) }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } + tmp0 = tmp0.WithMeta(lang.NewMap(kw_file, "glojure/go/io.glj", kw_line, int(172), kw_column, int(24), kw_end_DASH_line, int(174), kw_end_DASH_column, int(92))).(lang.FnFunc) + closed24 = tmp0 } - // sorted-map + var closed26 any { - tmp0 := sym_sorted_DASH_map.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_keyvals)), kw_doc, "keyval => key val\n Returns a new sorted map with supplied mappings. If any keys are\n equal, they are handled as if by repeated uses of assoc.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(397), kw_end_DASH_line, int(397))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp5, ok := lang.FieldOrMethod(v1, "scheme") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v1, "scheme"))) + } + var tmp6 any + switch reflect.TypeOf(tmp5).Kind() { + case reflect.Func: + tmp6 = lang.Apply(tmp5, nil) default: - checkArity(args, 0) - var v3 any = lang.NewList(args[0:]...) - _ = v3 - tmp4 := lang.Apply(lang.CreatePersistentTreeMap, []any{v3}) - return tmp4 + tmp6 = tmp5 + } + tmp7 := lang.Apply(tmp4, []any{"file", tmp6}) + if lang.IsTruthy(tmp7) { + tmp8 := checkDerefVar(var_glojure_DOT_go_DOT_io_make_DASH_output_DASH_stream) + tmp9 := lang.Apply(nil, []any{v1}) + tmp10 := lang.Apply(tmp8, []any{tmp9, v2}) + tmp3 = tmp10 + } else { + tmp11 := checkDerefVar(var_glojure_DOT_core_str) + tmp12 := lang.Apply(tmp11, []any{"Can not write to non-file URL <", v1, ">"}) + tmp13 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp12}) + panic(tmp13) } + return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } + tmp0 = tmp0.WithMeta(lang.NewMap(kw_file, "glojure/go/io.glj", kw_line, int(245), kw_column, int(25), kw_end_DASH_line, int(248), kw_end_DASH_column, int(149))).(lang.FnFunc) + closed26 = tmp0 } - // sorted-map-by + var closed27 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + var tmp3 any + func() { + defer func() { + if r := recover(); r != nil { + if lang.CatchMatches(r, lang.Builtins["any"]) { + v4 := r + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_go_DOT_io_make_DASH_output_DASH_stream) + var tmp6 any + { // let + // let binding "res__0__auto__" + tmp7 := lang.Apply(os6.Open, []any{v1}) + tmp8 := lang.Apply(tmp7, nil) + var v9 any = tmp8 + _ = v9 + // let binding "vec__322" + var tmp10 any + tmp11 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp12 := lang.Apply(tmp11, []any{v9}) + if lang.IsTruthy(tmp12) { + tmp13 := checkDerefVar(var_glojure_DOT_core_pop) + tmp14 := lang.Apply(tmp13, []any{v9}) + tmp15 := checkDerefVar(var_glojure_DOT_core_last) + tmp16 := lang.Apply(tmp15, []any{v9}) + tmp17 := lang.NewVector(tmp14, tmp16) + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(358), kw_column, int(10), kw_end_DASH_line, int(358), kw_end_DASH_column, int(14)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp10 = tmp19 + } else { + tmp20 := lang.NewVector(nil, v9) + tmp21 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(358), kw_column, int(10), kw_end_DASH_line, int(358), kw_end_DASH_column, int(14)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp10 = tmp22 + } + var v23 any = tmp10 + _ = v23 + // let binding "vec__325" + tmp24 := checkDerefVar(var_glojure_DOT_core_nth) + tmp25 := lang.Apply(tmp24, []any{v23, int64(0), nil}) + var v26 any = tmp25 + _ = v26 + // let binding "seq__326" + tmp27 := checkDerefVar(var_glojure_DOT_core_seq) + tmp28 := lang.Apply(tmp27, []any{v26}) + var v29 any = tmp28 + _ = v29 + // let binding "first__327" + tmp30 := checkDerefVar(var_glojure_DOT_core_first) + tmp31 := lang.Apply(tmp30, []any{v29}) + var v32 any = tmp31 + _ = v32 + // let binding "seq__326" + tmp33 := checkDerefVar(var_glojure_DOT_core_next) + tmp34 := lang.Apply(tmp33, []any{v29}) + var v35 any = tmp34 + _ = v35 + // let binding "fst__1__auto__" + var v36 any = v32 + _ = v36 + // let binding "rst__2__auto__" + var v37 any = v35 + _ = v37 + // let binding "res__0__auto__" + var v38 any = v26 + _ = v38 + // let binding "err__3__auto__" + tmp39 := checkDerefVar(var_glojure_DOT_core_nth) + tmp40 := lang.Apply(tmp39, []any{v23, int64(1), nil}) + var v41 any = tmp40 + _ = v41 + // let binding "res__0__auto__" + var tmp42 any + tmp43 := checkDerefVar(var_glojure_DOT_core_not_DASH_empty) + tmp44 := lang.Apply(tmp43, []any{v37}) + if lang.IsTruthy(tmp44) { + tmp42 = v38 + } else { + tmp42 = v36 + } + var v45 any = tmp42 + _ = v45 + var tmp46 any + if lang.IsTruthy(v41) { + panic(v41) + } else { + } + _ = tmp46 + tmp6 = v45 + } // end let + tmp7 := lang.Apply(tmp5, []any{tmp6, v2}) + tmp3 = tmp7 + } else { + panic(r) + } + } + }() + tmp4 := checkDerefVar(var_glojure_DOT_go_DOT_io_make_DASH_output_DASH_stream) + var tmp5 any + { // let + // let binding "res__0__auto__" + tmp6 := lang.Apply(url5.Parse, []any{v1}) + tmp7 := lang.Apply(tmp6, nil) + var v8 any = tmp7 + _ = v8 + // let binding "vec__316" + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp11 := lang.Apply(tmp10, []any{v8}) + if lang.IsTruthy(tmp11) { + tmp12 := checkDerefVar(var_glojure_DOT_core_pop) + tmp13 := lang.Apply(tmp12, []any{v8}) + tmp14 := checkDerefVar(var_glojure_DOT_core_last) + tmp15 := lang.Apply(tmp14, []any{v8}) + tmp16 := lang.NewVector(tmp13, tmp15) + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(358), kw_column, int(10), kw_end_DASH_line, int(358), kw_end_DASH_column, int(14)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp9 = tmp18 + } else { + tmp19 := lang.NewVector(nil, v8) + tmp20 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(358), kw_column, int(10), kw_end_DASH_line, int(358), kw_end_DASH_column, int(14)) + tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp9 = tmp21 + } + var v22 any = tmp9 + _ = v22 + // let binding "vec__319" + tmp23 := checkDerefVar(var_glojure_DOT_core_nth) + tmp24 := lang.Apply(tmp23, []any{v22, int64(0), nil}) + var v25 any = tmp24 + _ = v25 + // let binding "seq__320" + tmp26 := checkDerefVar(var_glojure_DOT_core_seq) + tmp27 := lang.Apply(tmp26, []any{v25}) + var v28 any = tmp27 + _ = v28 + // let binding "first__321" + tmp29 := checkDerefVar(var_glojure_DOT_core_first) + tmp30 := lang.Apply(tmp29, []any{v28}) + var v31 any = tmp30 + _ = v31 + // let binding "seq__320" + tmp32 := checkDerefVar(var_glojure_DOT_core_next) + tmp33 := lang.Apply(tmp32, []any{v28}) + var v34 any = tmp33 + _ = v34 + // let binding "fst__1__auto__" + var v35 any = v31 + _ = v35 + // let binding "rst__2__auto__" + var v36 any = v34 + _ = v36 + // let binding "res__0__auto__" + var v37 any = v25 + _ = v37 + // let binding "err__3__auto__" + tmp38 := checkDerefVar(var_glojure_DOT_core_nth) + tmp39 := lang.Apply(tmp38, []any{v22, int64(1), nil}) + var v40 any = tmp39 + _ = v40 + // let binding "res__0__auto__" + var tmp41 any + tmp42 := checkDerefVar(var_glojure_DOT_core_not_DASH_empty) + tmp43 := lang.Apply(tmp42, []any{v36}) + if lang.IsTruthy(tmp43) { + tmp41 = v37 + } else { + tmp41 = v35 + } + var v44 any = tmp41 + _ = v44 + var tmp45 any + if lang.IsTruthy(v40) { + panic(v40) + } else { + } + _ = tmp45 + tmp5 = v44 + } // end let + tmp6 := lang.Apply(tmp4, []any{tmp5, v2}) + tmp3 = tmp6 + }() + return tmp3 + }) + tmp0 = tmp0.WithMeta(lang.NewMap(kw_file, "glojure/go/io.glj", kw_line, int(264), kw_column, int(25), kw_end_DASH_line, int(268), kw_end_DASH_column, int(79))).(lang.FnFunc) + closed27 = tmp0 + } + // -protocols { - tmp0 := sym_sorted_DASH_map_DASH_by.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_comparator, sym__AMP_, sym_keyvals)), kw_doc, "keyval => key val\n Returns a new sorted map with supplied mappings, using the supplied\n comparator. If any keys are equal, they are handled as if by\n repeated uses of assoc.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(406), kw_end_DASH_line, int(406))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym__DASH_protocols.WithMeta(lang.NewMap(kw_private, true, kw_doc, "Private store of protocols. Go's reflection capabilities\n don't yet support a native interface-based implementation, so\n protocols are implemented in Glojure as maps from type to protocol\n method implementations.", kw_file, "glojure/core_deftype.glj", kw_line, int(21), kw_column, int(3), kw_end_DASH_line, int(26), kw_end_DASH_column, int(12), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: checkArity(args, 1) - v3 := args[0] - _ = v3 - var v4 any = lang.NewList(args[1:]...) - _ = v4 - tmp5 := lang.Apply(nil, []any{v3, v4}) - return tmp5 + v5 := args[0] + _ = v5 + var v6 any = lang.NewList(args[1:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_class) + tmp8 := lang.Apply(tmp7, []any{v5}) + return tmp8 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // sorted-set - { - tmp0 := sym_sorted_DASH_set.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_keys)), kw_doc, "Returns a new sorted set with supplied keys. Any equal keys are\n handled as if by repeated uses of conj.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(416), kw_end_DASH_line, int(416))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp3 := lang.NewMultiFn("coll-reduce", tmp4, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) - var v3 any = lang.NewList(args[0:]...) - _ = v3 - tmp4 := lang.Apply(lang.CreatePersistentTreeSet, []any{v3}) - return tmp4 + checkArity(args, 1) + v6 := args[0] + _ = v6 + var v7 any = lang.NewList(args[1:]...) + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_apply) + tmp9 := checkDerefVar(var_glojure_DOT_core_cons) + tmp10 := lang.Apply(tmp9, []any{v6, v7}) + tmp11 := lang.Apply(tmp8, []any{closed9, tmp10}) + return tmp11 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // sorted-set-by - { - tmp0 := sym_sorted_DASH_set_DASH_by.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_comparator, sym__AMP_, sym_keys)), kw_doc, "Returns a new sorted set with supplied keys, using the supplied\n comparator. Any equal keys are handled as if by repeated uses of\n conj.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(424), kw_end_DASH_line, int(424))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp3.AddMethod(nil, tmp5) + tmp6 := reflect.TypeOf((*lang.IReduceInit)(nil)).Elem() + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: checkArity(args, 1) - v3 := args[0] - _ = v3 - var v4 any = lang.NewList(args[1:]...) - _ = v4 - tmp5 := lang.Apply(lang.CreatePersistentTreeSetWithComparator, []any{v3, v4}) - return tmp5 + v8 := args[0] + _ = v8 + var v9 any = lang.NewList(args[1:]...) + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_apply) + tmp11 := checkDerefVar(var_glojure_DOT_core_cons) + tmp12 := lang.Apply(tmp11, []any{v8, v9}) + tmp13 := lang.Apply(tmp10, []any{closed10, tmp12}) + return tmp13 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // sorted? - { - tmp0 := sym_sorted_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns true if coll implements Sorted", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(6235), kw_end_DASH_line, int(6235))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp5 := lang.Apply(tmp4, []any{nil, v3}) - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // special-symbol? - { - tmp0 := sym_special_DASH_symbol_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_doc, "Returns true if s names a special form", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(4992), kw_end_DASH_line, int(4992))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) - tmp5, ok := lang.FieldOrMethod(runtime.Compiler, "specials") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", runtime.Compiler, "specials"))) - } - var tmp6 any - switch reflect.TypeOf(tmp5).Kind() { - case reflect.Func: - tmp6 = lang.Apply(tmp5, nil) + tmp3.AddMethod(tmp6, tmp7) + tmp8 := reflect.TypeOf((*lang.LazySeq)(nil)) + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { default: - tmp6 = tmp5 + checkArity(args, 1) + v10 := args[0] + _ = v10 + var v11 any = lang.NewList(args[1:]...) + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_apply) + tmp13 := checkDerefVar(var_glojure_DOT_core_cons) + tmp14 := lang.Apply(tmp13, []any{v10, v11}) + tmp15 := lang.Apply(tmp12, []any{closed11, tmp14}) + return tmp15 } - tmp7 := lang.Apply(tmp4, []any{tmp6, v3}) - return tmp7 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // spit - { - tmp0 := sym_spit.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_content, sym__AMP_, sym_options)), kw_doc, "Opposite of slurp. Opens f with writer, writes content, then\n closes f. Options passed to glojure.java.io/writer.", kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(6994), kw_end_DASH_line, int(6994))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp3.AddMethod(tmp8, tmp9) + tmp10 := reflect.TypeOf((*lang.Vector)(nil)) + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - var tmp6 any - { // let - // let binding "w" - tmp7 := checkDerefVar(var_glojure_DOT_core_apply) - tmp8 := lang.Apply(tmp7, []any{nil, v3, v5}) - var v9 any = tmp8 - _ = v9 - var tmp10 any - func() { - defer func() { - tmp11, ok := lang.FieldOrMethod(v9, "close") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v9, "close"))) - } - var tmp12 any - switch reflect.TypeOf(tmp11).Kind() { - case reflect.Func: - tmp12 = lang.Apply(tmp11, nil) - default: - tmp12 = tmp11 - } - _ = tmp12 - }() - tmp13 := checkDerefVar(var_glojure_DOT_core_str) - tmp14 := lang.Apply(tmp13, []any{v4}) - tmp15 := lang.Apply(lang.WriteWriter, []any{v9, tmp14}) - tmp10 = tmp15 - }() - tmp6 = tmp10 - } // end let - return tmp6 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // split-at - { - tmp0 := sym_split_DASH_at.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n, sym_coll)), kw_doc, "Returns a vector of [(take n coll) (drop n coll)]", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(2983), kw_end_DASH_line, int(2983))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_take) - tmp6 := lang.Apply(tmp5, []any{v3, v4}) - tmp7 := checkDerefVar(var_glojure_DOT_core_drop) - tmp8 := lang.Apply(tmp7, []any{v3, v4}) - tmp9 := lang.NewVector(tmp6, tmp8) - tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2988), kw_column, int(5), kw_end_DASH_line, int(2988), kw_end_DASH_column, int(33)) - tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) - if err != nil { - panic(err) + checkArity(args, 1) + v12 := args[0] + _ = v12 + var v13 any = lang.NewList(args[1:]...) + _ = v13 + tmp14 := checkDerefVar(var_glojure_DOT_core_apply) + tmp15 := checkDerefVar(var_glojure_DOT_core_cons) + tmp16 := lang.Apply(tmp15, []any{v12, v13}) + tmp17 := lang.Apply(tmp14, []any{closed12, tmp16}) + return tmp17 } - return tmp11 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // split-with - { - tmp0 := sym_split_DASH_with.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns a vector of [(take-while pred coll) (drop-while pred coll)]", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(2990), kw_end_DASH_line, int(2990))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_take_DASH_while) - tmp6 := lang.Apply(tmp5, []any{v3, v4}) - tmp7 := checkDerefVar(var_glojure_DOT_core_drop_DASH_while) - tmp8 := lang.Apply(tmp7, []any{v3, v4}) - tmp9 := lang.NewVector(tmp6, tmp8) - tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2995), kw_column, int(5), kw_end_DASH_line, int(2995), kw_end_DASH_column, int(51)) - tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) - if err != nil { - panic(err) + tmp3.AddMethod(tmp10, tmp11) + tmp2 := lang.NewAtom(lang.NewMap(kw_multis, lang.NewMap(kw_coll_DASH_reduce, tmp3), kw_on_DASH_interface, true, kw_sigs, lang.NewList(lang.NewList(sym_coll_DASH_reduce, lang.NewVector(sym_coll, sym_f), lang.NewVector(sym_coll, sym_f, sym_val))))) + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v15 := args[0] + _ = v15 + var v16 any = lang.NewList(args[1:]...) + _ = v16 + tmp17 := checkDerefVar(var_glojure_DOT_core_class) + tmp18 := lang.Apply(tmp17, []any{v15}) + return tmp18 } - return tmp11 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // splitv-at - { - tmp0 := sym_splitv_DASH_at.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n, sym_coll)), kw_doc, "Returns a vector of [(into [] (take n) coll) (drop n coll)]", kw_file, "glojure/core.glj", kw_added, "1.12", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(7256), kw_end_DASH_line, int(7256))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_into) - tmp6 := lang.NewVector() - tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7260), kw_column, int(10), kw_end_DASH_line, int(7260), kw_end_DASH_column, int(11)) - tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp9 := checkDerefVar(var_glojure_DOT_core_take) - tmp10 := lang.Apply(tmp9, []any{v3}) - tmp11 := lang.Apply(tmp5, []any{tmp8, tmp10, v4}) - tmp12 := checkDerefVar(var_glojure_DOT_core_drop) - tmp13 := lang.Apply(tmp12, []any{v3, v4}) - tmp14 := lang.NewVector(tmp11, tmp13) - tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7260), kw_column, int(3), kw_end_DASH_line, int(7260), kw_end_DASH_column, int(41)) - tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) - if err != nil { - panic(err) + tmp13 := lang.NewMultiFn("internal-reduce", tmp14, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) + var tmp15 lang.FnFunc + tmp15 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v16 := args[0] + _ = v16 + var v17 any = lang.NewList(args[1:]...) + _ = v17 + tmp18 := checkDerefVar(var_glojure_DOT_core_apply) + tmp19 := checkDerefVar(var_glojure_DOT_core_cons) + tmp20 := lang.Apply(tmp19, []any{v16, v17}) + tmp21 := lang.Apply(tmp18, []any{closed13, tmp20}) + return tmp21 } - return tmp16 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // spread - { - tmp0 := sym_spread.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_arglist)), kw_static, true, kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(632), kw_end_DASH_line, int(632), kw_private, true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) - tmp6 := lang.Apply(tmp5, []any{v3}) - if lang.IsTruthy(tmp6) { - } else { - var tmp7 any - tmp8 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) - tmp9 := checkDerefVar(var_glojure_DOT_core_next) - tmp10 := lang.Apply(tmp9, []any{v3}) - tmp11 := lang.Apply(tmp8, []any{tmp10}) - if lang.IsTruthy(tmp11) { - tmp12 := checkDerefVar(var_glojure_DOT_core_seq) - tmp13 := checkDerefVar(var_glojure_DOT_core_first) - tmp14 := lang.Apply(tmp13, []any{v3}) - tmp15 := lang.Apply(tmp12, []any{tmp14}) - tmp7 = tmp15 - } else { - var tmp16 any - if lang.IsTruthy(kw_else) { - tmp17 := checkDerefVar(var_glojure_DOT_core_cons) - tmp18 := checkDerefVar(var_glojure_DOT_core_first) - tmp19 := lang.Apply(tmp18, []any{v3}) - tmp20 := checkDerefVar(var_glojure_DOT_core_spread) - tmp21 := checkDerefVar(var_glojure_DOT_core_next) - tmp22 := lang.Apply(tmp21, []any{v3}) - tmp23 := lang.Apply(tmp20, []any{tmp22}) - tmp24 := lang.Apply(tmp17, []any{tmp19, tmp23}) - tmp16 = tmp24 - } else { - } - tmp7 = tmp16 - } - tmp4 = tmp7 + tmp13.AddMethod(nil, tmp15) + tmp16 := reflect.TypeOf((*lang.IChunkedSeq)(nil)).Elem() + var tmp17 lang.FnFunc + tmp17 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v18 := args[0] + _ = v18 + var v19 any = lang.NewList(args[1:]...) + _ = v19 + tmp20 := checkDerefVar(var_glojure_DOT_core_apply) + tmp21 := checkDerefVar(var_glojure_DOT_core_cons) + tmp22 := lang.Apply(tmp21, []any{v18, v19}) + tmp23 := lang.Apply(tmp20, []any{closed14, tmp22}) + return tmp23 } - return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // str - { - tmp1 := reflect.TypeOf("") - tmp0 := sym_str.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_x), lang.NewVector(sym_x, sym__AMP_, sym_ys)), kw_doc, "With no args, returns the empty string. With one arg x, returns\n x.toString(). (str nil) returns the empty string. With more than\n one arg, returns the concatenation of the str values of the args.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(543), kw_end_DASH_line, int(543))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { + tmp13.AddMethod(tmp16, tmp17) + tmp18 := reflect.TypeOf((*lang.Object)(nil)).Elem() + var tmp19 lang.FnFunc + tmp19 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 0: - return "" - case 1: - v4 := args[0] - _ = v4 - var tmp5 any - tmp6 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) - tmp7 := lang.Apply(tmp6, []any{v4}) - if lang.IsTruthy(tmp7) { - tmp5 = "" - } else { - tmp8 := lang.Apply(lang.ToString, []any{v4}) - tmp5 = tmp8 - } - return tmp5 default: checkArity(args, 1) - v4 := args[0] - _ = v4 - var v5 any = lang.NewList(args[1:]...) - _ = v5 - var tmp6 lang.FnFunc - tmp6 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v7 := args[0] - _ = v7 - v8 := args[1] - _ = v8 - recur_loop_74: - var tmp9 any - if lang.IsTruthy(v8) { - tmp11 := checkDerefVar(var_glojure_DOT_core_str) - tmp12 := checkDerefVar(var_glojure_DOT_core_first) - tmp13 := lang.Apply(tmp12, []any{v8}) - tmp14 := lang.Apply(tmp11, []any{tmp13}) - tmp15, _ := lang.FieldOrMethod(v7, "WriteString") - if reflect.TypeOf(tmp15).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("WriteString is not a function"))) - } - tmp16 := lang.Apply(tmp15, []any{tmp14}) - _ = tmp16 - var tmp10 any = v7 - tmp18 := checkDerefVar(var_glojure_DOT_core_next) - tmp19 := lang.Apply(tmp18, []any{v8}) - var tmp17 any = tmp19 - v7 = tmp10 - v8 = tmp17 - goto recur_loop_74 - } else { - tmp20, ok := lang.FieldOrMethod(v7, "String") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "String"))) - } - var tmp21 any - switch reflect.TypeOf(tmp20).Kind() { - case reflect.Func: - tmp21 = lang.Apply(tmp20, nil) - default: - tmp21 = tmp20 - } - tmp9 = tmp21 - } - return tmp9 - }) - tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(554), kw_column, int(7), kw_end_DASH_line, int(554), kw_end_DASH_column, int(127)) - tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp9 := checkDerefVar(var_glojure_DOT_core_cons) - tmp10 := lang.Apply(tmp9, []any{v4, v5}) - tmp11 := lang.Apply(tmp8, []any{"unimplemented: new with non-constant class type", tmp10}) - return tmp11 + v20 := args[0] + _ = v20 + var v21 any = lang.NewList(args[1:]...) + _ = v21 + tmp22 := checkDerefVar(var_glojure_DOT_core_apply) + tmp23 := checkDerefVar(var_glojure_DOT_core_cons) + tmp24 := lang.Apply(tmp23, []any{v20, v21}) + tmp25 := lang.Apply(tmp22, []any{closed15, tmp24}) + return tmp25 } }) - tmp4 := reflect.TypeOf("") - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // stream-into! - { - tmp0 := sym_stream_DASH_into_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_to, sym_stream), lang.NewVector(sym_to, sym_xform, sym_stream)), kw_doc, "Returns a new coll consisting of coll with all of the items of the\n stream conjoined. This is a terminal operation on the stream.", kw_file, "glojure/core.glj", kw_added, "1.12", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(6810), kw_end_DASH_line, int(6810))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp13.AddMethod(tmp18, tmp19) + tmp12 := lang.NewAtom(lang.NewMap(kw_multis, lang.NewMap(kw_internal_DASH_reduce, tmp13), kw_on_DASH_interface, true, kw_sigs, lang.NewList(lang.NewList(sym_internal_DASH_reduce, lang.NewVector(sym_seq, sym_f, sym_start))))) + var tmp22 lang.FnFunc + tmp22 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - tmp6 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp7 := reflect.TypeOf((*lang.IEditableCollection)(nil)).Elem() - tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) - if lang.IsTruthy(tmp8) { - tmp9 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) - tmp10 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) - tmp11 := checkDerefVar(var_glojure_DOT_core_stream_DASH_reduce_BANG_) - tmp12 := checkDerefVar(var_glojure_DOT_core_conj_BANG_) - tmp13 := checkDerefVar(var_glojure_DOT_core_transient) - tmp14 := lang.Apply(tmp13, []any{v3}) - tmp15 := lang.Apply(tmp11, []any{tmp12, tmp14, v4}) - tmp16 := lang.Apply(tmp10, []any{tmp15}) - tmp17 := checkDerefVar(var_glojure_DOT_core_meta) - tmp18 := lang.Apply(tmp17, []any{v3}) - tmp19 := lang.Apply(tmp9, []any{tmp16, tmp18}) - tmp5 = tmp19 - } else { - tmp20 := checkDerefVar(var_glojure_DOT_core_stream_DASH_reduce_BANG_) - tmp21 := checkDerefVar(var_glojure_DOT_core_conj) - tmp22 := lang.Apply(tmp20, []any{tmp21, v3, v4}) - tmp5 = tmp22 - } - return tmp5 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var tmp6 any - tmp7 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp8 := reflect.TypeOf((*lang.IEditableCollection)(nil)).Elem() - tmp9 := lang.Apply(tmp7, []any{tmp8, v3}) - if lang.IsTruthy(tmp9) { - tmp10 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) - tmp11 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) - tmp12 := checkDerefVar(var_glojure_DOT_core_stream_DASH_transduce_BANG_) - tmp13 := checkDerefVar(var_glojure_DOT_core_conj_BANG_) - tmp14 := checkDerefVar(var_glojure_DOT_core_transient) - tmp15 := lang.Apply(tmp14, []any{v3}) - tmp16 := lang.Apply(tmp12, []any{v4, tmp13, tmp15, v5}) - tmp17 := lang.Apply(tmp11, []any{tmp16}) - tmp18 := checkDerefVar(var_glojure_DOT_core_meta) - tmp19 := lang.Apply(tmp18, []any{v3}) - tmp20 := lang.Apply(tmp10, []any{tmp17, tmp19}) - tmp6 = tmp20 - } else { - tmp21 := checkDerefVar(var_glojure_DOT_core_stream_DASH_transduce_BANG_) - tmp22 := checkDerefVar(var_glojure_DOT_core_conj) - tmp23 := lang.Apply(tmp21, []any{v4, tmp22, v3, v5}) - tmp6 = tmp23 - } - return tmp6 default: - checkArity(args, -1) - panic("unreachable") + checkArity(args, 1) + v23 := args[0] + _ = v23 + var v24 any = lang.NewList(args[1:]...) + _ = v24 + tmp25 := checkDerefVar(var_glojure_DOT_core_class) + tmp26 := lang.Apply(tmp25, []any{v23}) + return tmp26 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // stream-reduce! - { - tmp0 := sym_stream_DASH_reduce_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_s), lang.NewVector(sym_f, sym_init, sym_s)), kw_doc, "Works like reduce but takes a java.util.stream.BaseStream as its source.\n Honors 'reduced', is a terminal operation on the stream", kw_file, "glojure/core.glj", kw_added, "1.12", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(6784), kw_end_DASH_line, int(6784))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp21 := lang.NewMultiFn("kv-reduce", tmp22, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) + tmp20 := lang.NewAtom(lang.NewMap(kw_multis, lang.NewMap(kw_kv_DASH_reduce, tmp21), kw_on_DASH_interface, true, kw_sigs, lang.NewList(lang.NewList(sym_kv_DASH_reduce, lang.NewVector(sym_amap, sym_f, sym_init))))) + var tmp25 lang.FnFunc + tmp25 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5, ok := lang.FieldOrMethod(v4, "iterator") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "iterator"))) - } - var tmp6 any - switch reflect.TypeOf(tmp5).Kind() { - case reflect.Func: - tmp6 = lang.Apply(tmp5, nil) - default: - tmp6 = tmp5 - } - tmp7 := lang.Apply(nil, []any{tmp6, v3}) - return tmp7 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6, ok := lang.FieldOrMethod(v5, "iterator") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "iterator"))) - } - var tmp7 any - switch reflect.TypeOf(tmp6).Kind() { - case reflect.Func: - tmp7 = lang.Apply(tmp6, nil) - default: - tmp7 = tmp6 - } - tmp8 := lang.Apply(nil, []any{tmp7, v3, v4}) - return tmp8 default: - checkArity(args, -1) - panic("unreachable") + checkArity(args, 1) + v26 := args[0] + _ = v26 + var v27 any = lang.NewList(args[1:]...) + _ = v27 + tmp28 := checkDerefVar(var_glojure_DOT_core_class) + tmp29 := lang.Apply(tmp28, []any{v26}) + return tmp29 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // stream-seq! - { - tmp0 := sym_stream_DASH_seq_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_stream)), kw_doc, "Takes a java.util.stream.BaseStream instance s and returns a seq of its\n contents. This is a terminal operation on the stream.", kw_file, "glojure/core.glj", kw_added, "1.12", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(6793), kw_end_DASH_line, int(6793))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_iterator_DASH_seq) - tmp5, ok := lang.FieldOrMethod(v3, "iterator") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "iterator"))) - } - var tmp6 any - switch reflect.TypeOf(tmp5).Kind() { - case reflect.Func: - tmp6 = lang.Apply(tmp5, nil) + tmp24 := lang.NewMultiFn("datafy", tmp25, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) + var tmp26 lang.FnFunc + tmp26 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { default: - tmp6 = tmp5 + checkArity(args, 1) + v27 := args[0] + _ = v27 + var v28 any = lang.NewList(args[1:]...) + _ = v28 + tmp29 := checkDerefVar(var_glojure_DOT_core_apply) + tmp30 := checkDerefVar(var_glojure_DOT_core_cons) + tmp31 := lang.Apply(tmp30, []any{v27, v28}) + tmp32 := lang.Apply(tmp29, []any{closed16, tmp31}) + return tmp32 } - tmp7 := lang.Apply(tmp4, []any{tmp6}) - return tmp7 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // stream-transduce! - { - tmp0 := sym_stream_DASH_transduce_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xform, sym_f, sym_stream), lang.NewVector(sym_xform, sym_f, sym_init, sym_stream)), kw_doc, "Works like transduce but takes a java.util.stream.BaseStream as its source.\n This is a terminal operation on the stream.", kw_file, "glojure/core.glj", kw_added, "1.12", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(7), kw_line, int(6800), kw_end_DASH_line, int(6800))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp24.AddMethod(nil, tmp26) + tmp23 := lang.NewAtom(lang.NewMap(kw_multis, lang.NewMap(kw_datafy, tmp24), kw_on_DASH_interface, true, kw_sigs, lang.NewList(lang.NewList(sym_datafy, lang.NewVector(sym_o), "return a representation of o as data (default identity)")))) + var tmp29 lang.FnFunc + tmp29 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v30 := args[0] + _ = v30 + var v31 any = lang.NewList(args[1:]...) + _ = v31 + tmp32 := checkDerefVar(var_glojure_DOT_core_class) + tmp33 := lang.Apply(tmp32, []any{v30}) + return tmp33 + } + }) + tmp28 := lang.NewMultiFn("nav", tmp29, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) + tmp27 := lang.NewAtom(lang.NewMap(kw_multis, lang.NewMap(kw_nav, tmp28), kw_on_DASH_interface, true, kw_sigs, lang.NewList(lang.NewList(sym_nav, lang.NewVector(sym_coll, sym_k, sym_v), "return (possibly transformed) v in the context of coll and k (a key/index or nil),\ndefaults to returning v.")))) + var tmp32 lang.FnFunc + tmp32 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6 := checkDerefVar(var_glojure_DOT_core_stream_DASH_transduce_BANG_) - tmp7 := lang.Apply(v4, nil) - tmp8 := lang.Apply(tmp6, []any{v3, v4, tmp7, v5}) - return tmp8 - case 4: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - var tmp7 any - { // let - // let binding "f" - tmp8 := lang.Apply(v3, []any{v4}) - var v9 any = tmp8 - _ = v9 - // let binding "ret" - tmp10 := checkDerefVar(var_glojure_DOT_core_stream_DASH_reduce_BANG_) - tmp11 := lang.Apply(tmp10, []any{v9, v5, v6}) - var v12 any = tmp11 - _ = v12 - tmp13 := lang.Apply(v9, []any{v12}) - tmp7 = tmp13 - } // end let - return tmp7 default: - checkArity(args, -1) - panic("unreachable") + checkArity(args, 1) + v33 := args[0] + _ = v33 + var v34 any = lang.NewList(args[1:]...) + _ = v34 + tmp35 := checkDerefVar(var_glojure_DOT_core_class) + tmp36 := lang.Apply(tmp35, []any{v33}) + return tmp36 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // string? - { - tmp0 := sym_string_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a String", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(2), kw_line, int(160), kw_end_DASH_line, int(164))).(*lang.Symbol) - var tmp2 lang.FnFunc - { // function string? - var v3 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp31 := lang.NewMultiFn("make-reader", tmp32, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) + tmp33 := reflect.TypeOf((*io4.Reader)(nil)).Elem() + var tmp34 lang.FnFunc + tmp34 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp6 := lang.Apply(tmp5, []any{lang.Builtins["string"], v4}) - return tmp6 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(164), kw_column, int(10), kw_end_DASH_line, int(164), kw_end_DASH_column, int(58))).(lang.FnFunc) - v3 = tmp2 - _ = v3 - } - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // strip-ns - { - tmp0 := sym_strip_DASH_ns.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(255), kw_column, int(8), kw_end_DASH_line, int(255), kw_end_DASH_column, int(15), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_named)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) - tmp6 := lang.Apply(tmp5, []any{v3}) - if lang.IsTruthy(tmp6) { - tmp7 := checkDerefVar(var_glojure_DOT_core_symbol) - tmp8 := checkDerefVar(var_glojure_DOT_core_name) - tmp9 := lang.Apply(tmp8, []any{v3}) - tmp10 := lang.Apply(tmp7, []any{nil, tmp9}) - tmp4 = tmp10 - } else { - tmp11 := checkDerefVar(var_glojure_DOT_core_keyword) - tmp12 := checkDerefVar(var_glojure_DOT_core_name) - tmp13 := lang.Apply(tmp12, []any{v3}) - tmp14 := lang.Apply(tmp11, []any{nil, tmp13}) - tmp4 = tmp14 + v35 := args[0] + _ = v35 + var v36 any = lang.NewList(args[1:]...) + _ = v36 + tmp37 := checkDerefVar(var_glojure_DOT_core_apply) + tmp38 := checkDerefVar(var_glojure_DOT_core_cons) + tmp39 := lang.Apply(tmp38, []any{v35, v36}) + tmp40 := lang.Apply(tmp37, []any{closed17, tmp39}) + return tmp40 } - return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // struct - { - tmp0 := sym_struct.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s, sym__AMP_, sym_vals)), kw_doc, "Returns a new structmap instance with the keys of the\n structure-basis. vals must be supplied for basis keys in order -\n where values are not supplied they will default to nil.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(4061), kw_end_DASH_line, int(4061))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp31.AddMethod(tmp33, tmp34) + tmp35 := reflect.TypeOf((*url5.URL)(nil)) + var tmp36 lang.FnFunc + tmp36 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: checkArity(args, 1) - v3 := args[0] - _ = v3 - var v4 any = lang.NewList(args[1:]...) - _ = v4 - tmp5 := lang.Apply(lang.ConstructPersistentStructMap, []any{v3, v4}) - return tmp5 + v37 := args[0] + _ = v37 + var v38 any = lang.NewList(args[1:]...) + _ = v38 + tmp39 := checkDerefVar(var_glojure_DOT_core_apply) + tmp40 := checkDerefVar(var_glojure_DOT_core_cons) + tmp41 := lang.Apply(tmp40, []any{v37, v38}) + tmp42 := lang.Apply(tmp39, []any{closed18, tmp41}) + return tmp42 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // struct-map - { - tmp0 := sym_struct_DASH_map.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s, sym__AMP_, sym_inits)), kw_doc, "Returns a new structmap instance with the keys of the\n structure-basis. keyvals may contain all, some or none of the basis\n keys - where values are not supplied they will default to nil.\n keyvals can also contain keys not in the basis.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4051), kw_end_DASH_line, int(4051))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp31.AddMethod(tmp35, tmp36) + tmp37 := reflect.TypeOf("") + var tmp38 lang.FnFunc + tmp38 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: checkArity(args, 1) - v3 := args[0] - _ = v3 - var v4 any = lang.NewList(args[1:]...) - _ = v4 - tmp5 := lang.Apply(lang.CreatePersistentStructMap, []any{v3, v4}) - return tmp5 + v39 := args[0] + _ = v39 + var v40 any = lang.NewList(args[1:]...) + _ = v40 + tmp41 := checkDerefVar(var_glojure_DOT_core_apply) + tmp42 := checkDerefVar(var_glojure_DOT_core_cons) + tmp43 := lang.Apply(tmp42, []any{v39, v40}) + tmp44 := lang.Apply(tmp41, []any{closed18, tmp43}) + return tmp44 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // subs - { - tmp0 := sym_subs.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s, sym_start), lang.NewVector(sym_s, sym_start, sym_end)), kw_doc, "Returns the substring of s beginning at start inclusive, and ending\n at end (defaults to length of string), exclusive.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(5005), kw_end_DASH_line, int(5005))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp31.AddMethod(tmp37, tmp38) + var tmp40 lang.FnFunc + tmp40 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.Apply(lang.Builtins["slice"], []any{v3, v4}) - return tmp5 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6 := lang.Apply(lang.Builtins["slice"], []any{v3, v4, v5}) - return tmp6 default: - checkArity(args, -1) - panic("unreachable") + checkArity(args, 1) + v41 := args[0] + _ = v41 + var v42 any = lang.NewList(args[1:]...) + _ = v42 + tmp43 := checkDerefVar(var_glojure_DOT_core_class) + tmp44 := lang.Apply(tmp43, []any{v41}) + return tmp44 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // subseq - { - tmp0 := sym_subseq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_sc, sym_test, sym_key), lang.NewVector(sym_sc, sym_start_DASH_test, sym_start_DASH_key, sym_end_DASH_test, sym_end_DASH_key)), kw_doc, "sc must be a sorted collection, test(s) one of <, <=, > or\n >=. Returns a seq of those entries with keys ek for\n which (test (.. sc comparator (compare ek key)) 0) is true", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(5133), kw_end_DASH_line, int(5133))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp39 := lang.NewMultiFn("make-writer", tmp40, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) + tmp41 := reflect.TypeOf((*io4.Reader)(nil)).Elem() + var tmp42 lang.FnFunc + tmp42 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var tmp6 any - { // let - // let binding "include" - tmp7 := checkDerefVar(var_glojure_DOT_core_mk_DASH_bound_DASH_fn) - tmp8 := lang.Apply(tmp7, []any{v3, v4, v5}) - var v9 any = tmp8 - _ = v9 - var tmp10 any - tmp11 := checkDerefVar(var_glojure_DOT_core__GT_) - tmp12 := checkDerefVar(var_glojure_DOT_core__GT__EQ_) - tmp13 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{tmp11, tmp12})) - tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5141), kw_column, int(11), kw_end_DASH_line, int(5141), kw_end_DASH_column, int(17)) - tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp16 := lang.Apply(tmp15, []any{v4}) - if lang.IsTruthy(tmp16) { - var tmp17 any - { // let - // let binding "temp__0__auto__" - tmp18, _ := lang.FieldOrMethod(v3, "seqFrom") - if reflect.TypeOf(tmp18).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("seqFrom is not a function"))) - } - tmp19 := lang.Apply(tmp18, []any{v5, true}) - var v20 any = tmp19 - _ = v20 - var tmp21 any - if lang.IsTruthy(v20) { - var tmp22 any - { // let - // let binding "vec__68" - var v23 any = v20 - _ = v23 - // let binding "e" - tmp24 := checkDerefVar(var_glojure_DOT_core_nth) - tmp25 := lang.Apply(tmp24, []any{v23, int64(0), nil}) - var v26 any = tmp25 - _ = v26 - // let binding "s" - var v27 any = v23 - _ = v27 - var tmp28 any - tmp29 := lang.Apply(v9, []any{v26}) - if lang.IsTruthy(tmp29) { - tmp28 = v27 - } else { - tmp30 := checkDerefVar(var_glojure_DOT_core_next) - tmp31 := lang.Apply(tmp30, []any{v27}) - tmp28 = tmp31 - } - tmp22 = tmp28 - } // end let - tmp21 = tmp22 - } else { - } - tmp17 = tmp21 - } // end let - tmp10 = tmp17 - } else { - tmp18 := checkDerefVar(var_glojure_DOT_core_take_DASH_while) - tmp19, _ := lang.FieldOrMethod(v3, "seq") - if reflect.TypeOf(tmp19).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("seq is not a function"))) - } - tmp20 := lang.Apply(tmp19, []any{true}) - tmp21 := lang.Apply(tmp18, []any{v9, tmp20}) - tmp10 = tmp21 - } - tmp6 = tmp10 - } // end let - return tmp6 - case 5: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - v7 := args[4] - _ = v7 - var tmp8 any - { // let - // let binding "temp__0__auto__" - tmp9, _ := lang.FieldOrMethod(v3, "seqFrom") - if reflect.TypeOf(tmp9).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("seqFrom is not a function"))) - } - tmp10 := lang.Apply(tmp9, []any{v5, true}) - var v11 any = tmp10 - _ = v11 - var tmp12 any - if lang.IsTruthy(v11) { - var tmp13 any - { // let - // let binding "vec__71" - var v14 any = v11 - _ = v14 - // let binding "e" - tmp15 := checkDerefVar(var_glojure_DOT_core_nth) - tmp16 := lang.Apply(tmp15, []any{v14, int64(0), nil}) - var v17 any = tmp16 - _ = v17 - // let binding "s" - var v18 any = v14 - _ = v18 - tmp19 := checkDerefVar(var_glojure_DOT_core_take_DASH_while) - tmp20 := checkDerefVar(var_glojure_DOT_core_mk_DASH_bound_DASH_fn) - tmp21 := lang.Apply(tmp20, []any{v3, v6, v7}) - var tmp22 any - tmp23 := checkDerefVar(var_glojure_DOT_core_mk_DASH_bound_DASH_fn) - tmp24 := lang.Apply(tmp23, []any{v3, v4, v5}) - tmp25 := lang.Apply(tmp24, []any{v17}) - if lang.IsTruthy(tmp25) { - tmp22 = v18 - } else { - tmp26 := checkDerefVar(var_glojure_DOT_core_next) - tmp27 := lang.Apply(tmp26, []any{v18}) - tmp22 = tmp27 - } - tmp28 := lang.Apply(tmp19, []any{tmp21, tmp22}) - tmp13 = tmp28 - } // end let - tmp12 = tmp13 - } else { - } - tmp8 = tmp12 - } // end let - return tmp8 default: - checkArity(args, -1) - panic("unreachable") + checkArity(args, 1) + v43 := args[0] + _ = v43 + var v44 any = lang.NewList(args[1:]...) + _ = v44 + tmp45 := checkDerefVar(var_glojure_DOT_core_apply) + tmp46 := checkDerefVar(var_glojure_DOT_core_cons) + tmp47 := lang.Apply(tmp46, []any{v43, v44}) + tmp48 := lang.Apply(tmp45, []any{closed19, tmp47}) + return tmp48 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // subvec - { - tmp0 := sym_subvec.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_v, sym_start), lang.NewVector(sym_v, sym_start, sym_end)), kw_doc, "Returns a persistent vector of the items in vector from\n start (inclusive) to end (exclusive). If end is not supplied,\n defaults to (count vector). This operation is O(1) and very fast, as\n the resulting vector shares structure with the original and no\n trimming is done.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(3819), kw_end_DASH_line, int(3819))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp39.AddMethod(tmp41, tmp42) + tmp43 := reflect.TypeOf((*url5.URL)(nil)) + var tmp44 lang.FnFunc + tmp44 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_subvec) - tmp6 := checkDerefVar(var_glojure_DOT_core_count) - tmp7 := lang.Apply(tmp6, []any{v3}) - tmp8 := lang.Apply(tmp5, []any{v3, v4, tmp7}) - return tmp8 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6, _ := lang.FieldOrMethod(runtime.RT, "Subvec") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Subvec is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v3, v4, v5}) - return tmp7 default: - checkArity(args, -1) - panic("unreachable") + checkArity(args, 1) + v45 := args[0] + _ = v45 + var v46 any = lang.NewList(args[1:]...) + _ = v46 + tmp47 := checkDerefVar(var_glojure_DOT_core_apply) + tmp48 := checkDerefVar(var_glojure_DOT_core_cons) + tmp49 := lang.Apply(tmp48, []any{v45, v46}) + tmp50 := lang.Apply(tmp47, []any{closed19, tmp49}) + return tmp50 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // supers - { - tmp0 := sym_supers.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_class)), kw_doc, "Returns the immediate and indirect superclasses and interfaces of c, if any", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(5532), kw_end_DASH_line, int(5532))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "ret" - tmp5 := checkDerefVar(var_glojure_DOT_core_set) - tmp6 := checkDerefVar(var_glojure_DOT_core_bases) - tmp7 := lang.Apply(tmp6, []any{v3}) - tmp8 := lang.Apply(tmp5, []any{tmp7}) - var v9 any = tmp8 - _ = v9 - // let binding "cs" - var v10 any = v9 - _ = v10 - for { - var tmp11 any - tmp12 := checkDerefVar(var_glojure_DOT_core_seq) - tmp13 := lang.Apply(tmp12, []any{v10}) - if lang.IsTruthy(tmp13) { - var tmp14 any - { // let - // let binding "c" - tmp15 := checkDerefVar(var_glojure_DOT_core_first) - tmp16 := lang.Apply(tmp15, []any{v10}) - var v17 any = tmp16 - _ = v17 - // let binding "bs" - tmp18 := checkDerefVar(var_glojure_DOT_core_bases) - tmp19 := lang.Apply(tmp18, []any{v17}) - var v20 any = tmp19 - _ = v20 - tmp22 := checkDerefVar(var_glojure_DOT_core_into1) - tmp23 := lang.Apply(tmp22, []any{v9, v20}) - var tmp21 any = tmp23 - tmp25 := checkDerefVar(var_glojure_DOT_core_into1) - tmp26 := checkDerefVar(var_glojure_DOT_core_disj) - tmp27 := lang.Apply(tmp26, []any{v10, v17}) - tmp28 := lang.Apply(tmp25, []any{tmp27, v20}) - var tmp24 any = tmp28 - v9 = tmp21 - v10 = tmp24 - continue - } // end let - tmp11 = tmp14 - } else { - tmp15 := checkDerefVar(var_glojure_DOT_core_not_DASH_empty) - tmp16 := lang.Apply(tmp15, []any{v9}) - tmp11 = tmp16 - } - tmp4 = tmp11 - break - } - } // end let - return tmp4 + tmp39.AddMethod(tmp43, tmp44) + tmp45 := reflect.TypeOf("") + var tmp46 lang.FnFunc + tmp46 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v47 := args[0] + _ = v47 + var v48 any = lang.NewList(args[1:]...) + _ = v48 + tmp49 := checkDerefVar(var_glojure_DOT_core_apply) + tmp50 := checkDerefVar(var_glojure_DOT_core_cons) + tmp51 := lang.Apply(tmp50, []any{v47, v48}) + tmp52 := lang.Apply(tmp49, []any{closed19, tmp51}) + return tmp52 + } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // swap! - { - tmp0 := sym_swap_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_atom, sym_f, sym__AMP_, sym_args)), kw_doc, "Atomically swaps the value of atom to be:\n (apply f current-value-of-atom args). Note that f may be called\n multiple times, and thus should be free of side effects. Returns\n the value that was swapped in.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(2343), kw_end_DASH_line, int(2343))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp39.AddMethod(tmp45, tmp46) + var tmp48 lang.FnFunc + tmp48 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - tmp6, _ := lang.FieldOrMethod(v3, "swap") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("swap is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 + checkArity(args, 1) + v49 := args[0] + _ = v49 + var v50 any = lang.NewList(args[1:]...) + _ = v50 + tmp51 := checkDerefVar(var_glojure_DOT_core_class) + tmp52 := lang.Apply(tmp51, []any{v49}) + return tmp52 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // swap-vals! - { - tmp0 := sym_swap_DASH_vals_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_atom, sym_f, sym__AMP_, sym_args)), kw_doc, "Atomically swaps the value of atom to be:\n (apply f current-value-of-atom args). Note that f may be called\n multiple times, and thus should be free of side effects.\n Returns [old new], the value of the atom before and after the swap.", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(2352), kw_end_DASH_line, int(2352))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp47 := lang.NewMultiFn("make-input-stream", tmp48, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) + tmp49 := reflect.TypeOf((*io4.Reader)(nil)).Elem() + var tmp50 lang.FnFunc + tmp50 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - tmp6, _ := lang.FieldOrMethod(v3, "swapVals") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("swapVals is not a function"))) - } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 + checkArity(args, 1) + v51 := args[0] + _ = v51 + var v52 any = lang.NewList(args[1:]...) + _ = v52 + tmp53 := checkDerefVar(var_glojure_DOT_core_apply) + tmp54 := checkDerefVar(var_glojure_DOT_core_cons) + tmp55 := lang.Apply(tmp54, []any{v51, v52}) + tmp56 := lang.Apply(tmp53, []any{closed20, tmp55}) + return tmp56 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // symbol - { - tmp1 := reflect.TypeOf((*lang.Symbol)(nil)) - tmp0 := sym_symbol.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_name), lang.NewVector(sym_ns, sym_name)), kw_doc, "Returns a Symbol with the given namespace and name. Arity-1 works\n on strings, keywords, and vars.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(584), kw_end_DASH_line, int(584))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { + tmp47.AddMethod(tmp49, tmp50) + tmp51 := reflect.TypeOf((*os6.File)(nil)) + var tmp52 lang.FnFunc + tmp52 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 1: - v4 := args[0] - _ = v4 - var tmp5 any - tmp6 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) - tmp7 := lang.Apply(tmp6, []any{v4}) - if lang.IsTruthy(tmp7) { - tmp5 = v4 - } else { - var tmp8 any - tmp9 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp10 := lang.Apply(tmp9, []any{lang.Builtins["string"], v4}) - if lang.IsTruthy(tmp10) { - tmp11 := lang.Apply(lang.NewSymbol, []any{v4}) - tmp8 = tmp11 - } else { - var tmp12 any - tmp13 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp14 := reflect.TypeOf((*lang.Var)(nil)) - tmp15 := lang.Apply(tmp13, []any{tmp14, v4}) - if lang.IsTruthy(tmp15) { - tmp16, ok := lang.FieldOrMethod(v4, "toSymbol") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "toSymbol"))) - } - var tmp17 any - switch reflect.TypeOf(tmp16).Kind() { - case reflect.Func: - tmp17 = lang.Apply(tmp16, nil) - default: - tmp17 = tmp16 - } - tmp12 = tmp17 - } else { - var tmp18 any - tmp19 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp20 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() - tmp21 := lang.Apply(tmp19, []any{tmp20, v4}) - if lang.IsTruthy(tmp21) { - tmp22, ok := lang.FieldOrMethod(v4, "sym") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "sym"))) - } - var tmp23 any - switch reflect.TypeOf(tmp22).Kind() { - case reflect.Func: - tmp23 = lang.Apply(tmp22, nil) - default: - tmp23 = tmp22 - } - tmp18 = tmp23 - } else { - var tmp24 any - if lang.IsTruthy(kw_else) { - tmp25 := lang.Apply(lang.NewIllegalArgumentError, []any{"no conversion to symbol"}) - panic(tmp25) - } else { - } - tmp18 = tmp24 - } - tmp12 = tmp18 - } - tmp8 = tmp12 - } - tmp5 = tmp8 - } - return tmp5 - case 2: - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6 := lang.Apply(lang.InternSymbol, []any{v4, v5}) - return tmp6 default: - checkArity(args, -1) - panic("unreachable") + checkArity(args, 1) + v53 := args[0] + _ = v53 + var v54 any = lang.NewList(args[1:]...) + _ = v54 + tmp55 := checkDerefVar(var_glojure_DOT_core_apply) + tmp56 := checkDerefVar(var_glojure_DOT_core_cons) + tmp57 := lang.Apply(tmp56, []any{v53, v54}) + tmp58 := lang.Apply(tmp55, []any{closed21, tmp57}) + return tmp58 } }) - tmp4 := reflect.TypeOf((*lang.Symbol)(nil)) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // symbol? - { - tmp0 := sym_symbol_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a Symbol", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(557), kw_end_DASH_line, int(557))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp5 := reflect.TypeOf((*lang.Symbol)(nil)) - tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) - return tmp6 + tmp47.AddMethod(tmp51, tmp52) + tmp53 := reflect.TypeOf((*url5.URL)(nil)) + var tmp54 lang.FnFunc + tmp54 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v55 := args[0] + _ = v55 + var v56 any = lang.NewList(args[1:]...) + _ = v56 + tmp57 := checkDerefVar(var_glojure_DOT_core_apply) + tmp58 := checkDerefVar(var_glojure_DOT_core_cons) + tmp59 := lang.Apply(tmp58, []any{v55, v56}) + tmp60 := lang.Apply(tmp57, []any{closed22, tmp59}) + return tmp60 + } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // sync - { - tmp0 := sym_sync.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_flags_DASH_ignored_DASH_for_DASH_now, sym__AMP_, sym_body)), kw_doc, "transaction-flags => TBD, pass nil for now\n\n Runs the exprs (in an implicit do) in a transaction that encompasses\n exprs and any nested calls. Starts a transaction if none is already\n running on this thread. Any uncaught exception will abort the\n transaction and flow out of sync. The exprs may be run more than\n once, but any effects on Refs will be atomic.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(11), kw_line, int(2490), kw_end_DASH_line, int(2490))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp47.AddMethod(tmp53, tmp54) + tmp55 := reflect.TypeOf("") + var tmp56 lang.FnFunc + tmp56 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - tmp7 := checkDerefVar(var_glojure_DOT_core_seq) - tmp8 := checkDerefVar(var_glojure_DOT_core_concat) - tmp9 := checkDerefVar(var_glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) - tmp11 := checkDerefVar(var_glojure_DOT_core_list) - tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_LockingTransaction}) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := checkDerefVar(var_glojure_DOT_core_seq) - tmp15 := checkDerefVar(var_glojure_DOT_core_concat) - tmp16 := checkDerefVar(var_glojure_DOT_core_list) - tmp17 := lang.Apply(tmp16, []any{sym_glojure_DOT_core_SLASH_RunInTransaction}) - tmp18 := checkDerefVar(var_glojure_DOT_core_list) - tmp19 := checkDerefVar(var_glojure_DOT_core_seq) - tmp20 := checkDerefVar(var_glojure_DOT_core_concat) - tmp21 := checkDerefVar(var_glojure_DOT_core_list) - tmp22 := lang.Apply(tmp21, []any{sym_glojure_DOT_core_SLASH_fn}) - tmp23 := checkDerefVar(var_glojure_DOT_core_list) - tmp24 := checkDerefVar(var_glojure_DOT_core_apply) - tmp25 := checkDerefVar(var_glojure_DOT_core_vector) - tmp26 := checkDerefVar(var_glojure_DOT_core_seq) - tmp27 := checkDerefVar(var_glojure_DOT_core_concat) - tmp28 := lang.Apply(tmp27, nil) - tmp29 := lang.Apply(tmp26, []any{tmp28}) - tmp30 := lang.Apply(tmp24, []any{tmp25, tmp29}) - tmp31 := lang.Apply(tmp23, []any{tmp30}) - tmp32 := lang.Apply(tmp20, []any{tmp22, tmp31, v6}) - tmp33 := lang.Apply(tmp19, []any{tmp32}) - tmp34 := lang.Apply(tmp18, []any{tmp33}) - tmp35 := lang.Apply(tmp15, []any{tmp17, tmp34}) - tmp36 := lang.Apply(tmp14, []any{tmp35}) - tmp37 := lang.Apply(tmp13, []any{tmp36}) - tmp38 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp37}) - tmp39 := lang.Apply(tmp7, []any{tmp38}) - return tmp39 + checkArity(args, 1) + v57 := args[0] + _ = v57 + var v58 any = lang.NewList(args[1:]...) + _ = v58 + tmp59 := checkDerefVar(var_glojure_DOT_core_apply) + tmp60 := checkDerefVar(var_glojure_DOT_core_cons) + tmp61 := lang.Apply(tmp60, []any{v57, v58}) + tmp62 := lang.Apply(tmp59, []any{closed23, tmp61}) + return tmp62 + } + }) + tmp47.AddMethod(tmp55, tmp56) + var tmp58 lang.FnFunc + tmp58 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v59 := args[0] + _ = v59 + var v60 any = lang.NewList(args[1:]...) + _ = v60 + tmp61 := checkDerefVar(var_glojure_DOT_core_class) + tmp62 := lang.Apply(tmp61, []any{v59}) + return tmp62 + } + }) + tmp57 := lang.NewMultiFn("make-output-stream", tmp58, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) + tmp59 := reflect.TypeOf((*io4.Reader)(nil)).Elem() + var tmp60 lang.FnFunc + tmp60 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v61 := args[0] + _ = v61 + var v62 any = lang.NewList(args[1:]...) + _ = v62 + tmp63 := checkDerefVar(var_glojure_DOT_core_apply) + tmp64 := checkDerefVar(var_glojure_DOT_core_cons) + tmp65 := lang.Apply(tmp64, []any{v61, v62}) + tmp66 := lang.Apply(tmp63, []any{closed24, tmp65}) + return tmp66 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // system-newline - { - tmp0 := sym_system_DASH_newline.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(3695), kw_column, int(6), kw_end_DASH_line, int(3695), kw_end_DASH_column, int(40), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, "\n", true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // tagged-literal - { - tmp0 := sym_tagged_DASH_literal.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_tag, sym_form)), kw_doc, "Construct a data representation of a tagged literal from a\n tag symbol and a form.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(7769), kw_end_DASH_line, int(7769))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.Apply(nil, []any{v3, v4}) - return tmp5 + tmp57.AddMethod(tmp59, tmp60) + tmp61 := reflect.TypeOf((*os6.File)(nil)) + var tmp62 lang.FnFunc + tmp62 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v63 := args[0] + _ = v63 + var v64 any = lang.NewList(args[1:]...) + _ = v64 + tmp65 := checkDerefVar(var_glojure_DOT_core_apply) + tmp66 := checkDerefVar(var_glojure_DOT_core_cons) + tmp67 := lang.Apply(tmp66, []any{v63, v64}) + tmp68 := lang.Apply(tmp65, []any{closed25, tmp67}) + return tmp68 + } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp57.AddMethod(tmp61, tmp62) + tmp63 := reflect.TypeOf((*url5.URL)(nil)) + var tmp64 lang.FnFunc + tmp64 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v65 := args[0] + _ = v65 + var v66 any = lang.NewList(args[1:]...) + _ = v66 + tmp67 := checkDerefVar(var_glojure_DOT_core_apply) + tmp68 := checkDerefVar(var_glojure_DOT_core_cons) + tmp69 := lang.Apply(tmp68, []any{v65, v66}) + tmp70 := lang.Apply(tmp67, []any{closed26, tmp69}) + return tmp70 + } + }) + tmp57.AddMethod(tmp63, tmp64) + tmp65 := reflect.TypeOf("") + var tmp66 lang.FnFunc + tmp66 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v67 := args[0] + _ = v67 + var v68 any = lang.NewList(args[1:]...) + _ = v68 + tmp69 := checkDerefVar(var_glojure_DOT_core_apply) + tmp70 := checkDerefVar(var_glojure_DOT_core_cons) + tmp71 := lang.Apply(tmp70, []any{v67, v68}) + tmp72 := lang.Apply(tmp69, []any{closed27, tmp71}) + return tmp72 + } + }) + tmp57.AddMethod(tmp65, tmp66) + tmp30 := lang.NewAtom(lang.NewMap(kw_multis, lang.NewMap(kw_make_DASH_reader, tmp31, kw_make_DASH_writer, tmp39, kw_make_DASH_input_DASH_stream, tmp47, kw_make_DASH_output_DASH_stream, tmp57), kw_on_DASH_interface, true, kw_sigs, lang.NewList(lang.NewList(sym_make_DASH_reader, lang.NewVector(sym_x, sym_opts), "Creates an io.Reader. See also IOFactory docs."), lang.NewList(sym_make_DASH_writer, lang.NewVector(sym_x, sym_opts), "Creates an io.Reader. See also IOFactory docs."), lang.NewList(sym_make_DASH_input_DASH_stream, lang.NewVector(sym_x, sym_opts), "Creates a BufferedInputStream. See also IOFactory docs."), lang.NewList(sym_make_DASH_output_DASH_stream, lang.NewVector(sym_x, sym_opts), "Creates a BufferedOutputStream. See also IOFactory docs.")))) + tmp1 := lang.NewAtom(lang.NewMap(sym_CollReduce, tmp2, sym_InternalReduce, tmp12, sym_IKVReduce, tmp20, sym_Datafiable, tmp23, sym_Navigable, tmp27, sym_IOFactory, tmp30)) + var_glojure_DOT_core__DASH_protocols = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core__DASH_protocols.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // tagged-literal? + // add-classpath { - tmp0 := sym_tagged_DASH_literal_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_value)), kw_doc, "Return true if the value is the data representation of a tagged literal", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(7763), kw_end_DASH_line, int(7763))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_add_DASH_classpath.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_url)), kw_doc, "DEPRECATED \n\n Adds the url (String or URL object) to the classpath per\n URLClassLoader.addURL", kw_file, "glojure/core.glj", kw_deprecated, "1.1", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(5176), kw_end_DASH_line, int(5176))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp5 := lang.Apply(tmp4, []any{nil, v3}) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_println) + tmp4 := lang.Apply(tmp3, []any{"WARNING: add-classpath is deprecated"}) + _ = tmp4 + tmp5 := lang.Apply(nil, []any{v2}) return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_add_DASH_classpath = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_add_DASH_classpath.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // take + // case { - tmp0 := sym_take.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n), lang.NewVector(sym_n, sym_coll)), kw_doc, "Returns a lazy sequence of the first n items in coll, or all items if\n there are fewer than n. Returns a stateful transducer when\n no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(2853), kw_end_DASH_line, int(2853))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_case.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_e, sym__AMP_, sym_clauses)), kw_doc, "Takes an expression, and a set of clauses.\n\n Each clause can take the form of either:\n\n test-constant result-expr\n\n (test-constant1 ... test-constantN) result-expr\n\n The test-constants are not evaluated. They must be compile-time\n literals, and need not be quoted. If the expression is equal to a\n test-constant, the corresponding result-expr is returned. A single\n default expression can follow the clauses, and its value will be\n returned if no clause matches. If no default expression is provided\n and no clause matches, an IllegalArgumentException is thrown.\n\n Unlike cond and condp, case does a constant-time dispatch, the\n clauses are not considered sequentially. All manner of constant\n expressions are acceptable in case, including numbers, strings,\n symbols, keywords, and (Clojure) composites thereof. Note that since\n lists are used to group multiple constants that map to the same\n expression, a vector can be used to match a list if needed. The\n test-constants need not be all of the same type.", kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(11), kw_line, int(6712), kw_end_DASH_line, int(6712))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 1: - v3 := args[0] + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v5 := args[0] - _ = v5 - var tmp6 any - { // let - // let binding "nv" - tmp7 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) - tmp8 := lang.Apply(tmp7, []any{v3}) - var v9 any = tmp8 - _ = v9 - var tmp10 lang.FnFunc - tmp10 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp11 := lang.Apply(v5, nil) - return tmp11 - case 1: - v11 := args[0] - _ = v11 - tmp12 := lang.Apply(v5, []any{v11}) - return tmp12 - case 2: - v11 := args[0] - _ = v11 - v12 := args[1] - _ = v12 - var tmp13 any - { // let - // let binding "n" - tmp14 := checkDerefVar(var_glojure_DOT_core_deref) - tmp15 := lang.Apply(tmp14, []any{v9}) - var v16 any = tmp15 - _ = v16 - // let binding "nn" - tmp17 := checkDerefVar(var_glojure_DOT_core_dec) - tmp18, ok := lang.FieldOrMethod(v9, "Deref") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v9, "Deref"))) - } - var tmp19 any - switch reflect.TypeOf(tmp18).Kind() { - case reflect.Func: - tmp19 = lang.Apply(tmp18, nil) - default: - tmp19 = tmp18 - } - tmp20 := lang.Apply(tmp17, []any{tmp19}) - tmp21, _ := lang.FieldOrMethod(v9, "reset") - if reflect.TypeOf(tmp21).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) - } - tmp22 := lang.Apply(tmp21, []any{tmp20}) - var v23 any = tmp22 - _ = v23 - // let binding "result" - var tmp24 any - tmp25 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) - tmp26 := lang.Apply(tmp25, []any{v16}) - if lang.IsTruthy(tmp26) { - tmp27 := lang.Apply(v5, []any{v11, v12}) - tmp24 = tmp27 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "ge" + tmp7 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp8 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp9 := lang.Apply(tmp8, nil) + tmp10 := reflect.TypeOf((*lang.Object)(nil)).Elem() + tmp11 := lang.NewMap(kw_tag, tmp10) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6738), kw_column, int(32), kw_end_DASH_line, int(6738), kw_end_DASH_column, int(84)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp14 := lang.Apply(tmp7, []any{tmp9, tmp13}) + var v15 any = tmp14 + _ = v15 + // let binding "default" + var tmp16 any + tmp17 := checkDerefVar(var_glojure_DOT_core_odd_QMARK_) + tmp18 := checkDerefVar(var_glojure_DOT_core_count) + tmp19 := lang.Apply(tmp18, []any{v5}) + tmp20 := lang.Apply(tmp17, []any{tmp19}) + if lang.IsTruthy(tmp20) { + tmp21 := checkDerefVar(var_glojure_DOT_core_last) + tmp22 := lang.Apply(tmp21, []any{v5}) + tmp16 = tmp22 + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_seq) + tmp24 := checkDerefVar(var_glojure_DOT_core_concat) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := lang.Apply(tmp25, []any{sym_throw}) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := checkDerefVar(var_glojure_DOT_core_seq) + tmp29 := checkDerefVar(var_glojure_DOT_core_concat) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := lang.Apply(tmp30, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_NewIllegalArgumentError}) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := checkDerefVar(var_glojure_DOT_core_seq) + tmp34 := checkDerefVar(var_glojure_DOT_core_concat) + tmp35 := checkDerefVar(var_glojure_DOT_core_list) + tmp36 := lang.Apply(tmp35, []any{sym_glojure_DOT_core_SLASH_str}) + tmp37 := checkDerefVar(var_glojure_DOT_core_list) + tmp38 := lang.Apply(tmp37, []any{"No matching clause: "}) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := lang.Apply(tmp39, []any{v15}) + tmp41 := lang.Apply(tmp34, []any{tmp36, tmp38, tmp40}) + tmp42 := lang.Apply(tmp33, []any{tmp41}) + tmp43 := lang.Apply(tmp32, []any{tmp42}) + tmp44 := lang.Apply(tmp29, []any{tmp31, tmp43}) + tmp45 := lang.Apply(tmp28, []any{tmp44}) + tmp46 := lang.Apply(tmp27, []any{tmp45}) + tmp47 := lang.Apply(tmp24, []any{tmp26, tmp46}) + tmp48 := lang.Apply(tmp23, []any{tmp47}) + tmp16 = tmp48 + } + var v49 any = tmp16 + _ = v49 + var tmp50 any + tmp51 := checkDerefVar(var_glojure_DOT_core__GT_) + tmp52 := checkDerefVar(var_glojure_DOT_core_count) + tmp53 := lang.Apply(tmp52, []any{v5}) + tmp54 := lang.Apply(tmp51, []any{int64(2), tmp53}) + if lang.IsTruthy(tmp54) { + tmp55 := checkDerefVar(var_glojure_DOT_core_seq) + tmp56 := checkDerefVar(var_glojure_DOT_core_concat) + tmp57 := checkDerefVar(var_glojure_DOT_core_list) + tmp58 := lang.Apply(tmp57, []any{sym_glojure_DOT_core_SLASH_let}) + tmp59 := checkDerefVar(var_glojure_DOT_core_list) + tmp60 := checkDerefVar(var_glojure_DOT_core_apply) + tmp61 := checkDerefVar(var_glojure_DOT_core_vector) + tmp62 := checkDerefVar(var_glojure_DOT_core_seq) + tmp63 := checkDerefVar(var_glojure_DOT_core_concat) + tmp64 := checkDerefVar(var_glojure_DOT_core_list) + tmp65 := lang.Apply(tmp64, []any{v15}) + tmp66 := checkDerefVar(var_glojure_DOT_core_list) + tmp67 := lang.Apply(tmp66, []any{v4}) + tmp68 := lang.Apply(tmp63, []any{tmp65, tmp67}) + tmp69 := lang.Apply(tmp62, []any{tmp68}) + tmp70 := lang.Apply(tmp60, []any{tmp61, tmp69}) + tmp71 := lang.Apply(tmp59, []any{tmp70}) + tmp72 := checkDerefVar(var_glojure_DOT_core_list) + tmp73 := lang.Apply(tmp72, []any{v49}) + tmp74 := lang.Apply(tmp56, []any{tmp58, tmp71, tmp73}) + tmp75 := lang.Apply(tmp55, []any{tmp74}) + tmp50 = tmp75 + } else { + var tmp76 any + { // let + // let binding "pairs" + tmp77 := checkDerefVar(var_glojure_DOT_core_partition) + tmp78 := lang.Apply(tmp77, []any{int64(2), v5}) + var v79 any = tmp78 + _ = v79 + // let binding "assoc-test" + var tmp80 lang.FnFunc + { // function assoc-test + var v81 lang.FnFunc + tmp80 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v82 := args[0] + _ = v82 + v83 := args[1] + _ = v83 + v84 := args[2] + _ = v84 + var tmp85 any + tmp86 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp87 := lang.Apply(tmp86, []any{v82, v83}) + if lang.IsTruthy(tmp87) { + tmp88 := checkDerefVar(var_glojure_DOT_core_str) + tmp89 := lang.Apply(tmp88, []any{"Duplicate case test constant: ", v83}) + tmp90 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp89}) + panic(tmp90) } else { - tmp24 = v11 + tmp91 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp92 := lang.Apply(tmp91, []any{v82, v83, v84}) + tmp85 = tmp92 } - var v28 any = tmp24 - _ = v28 - var tmp29 any - tmp30 := checkDerefVar(var_glojure_DOT_core_not) - tmp31 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) - tmp32 := lang.Apply(tmp31, []any{v23}) - tmp33 := lang.Apply(tmp30, []any{tmp32}) - if lang.IsTruthy(tmp33) { - tmp34 := checkDerefVar(var_glojure_DOT_core_ensure_DASH_reduced) - tmp35 := lang.Apply(tmp34, []any{v28}) - tmp29 = tmp35 + return tmp85 + }) + v81 = tmp80 + _ = v81 + } + tmp81 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6745), kw_column, int(24), kw_end_DASH_line, int(6748), kw_end_DASH_column, int(48)) + tmp82, err := lang.WithMeta(tmp80, tmp81.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v83 any = tmp82 + _ = v83 + // let binding "pairs" + tmp84 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp85 lang.FnFunc + tmp85 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v86 := args[0] + _ = v86 + v87 := args[1] + _ = v87 + var tmp88 any + { // let + // let binding "vec__177" + var v89 any = v87 + _ = v89 + // let binding "test" + tmp90 := checkDerefVar(var_glojure_DOT_core_nth) + tmp91 := lang.Apply(tmp90, []any{v89, int64(0), nil}) + var v92 any = tmp91 + _ = v92 + // let binding "expr" + tmp93 := checkDerefVar(var_glojure_DOT_core_nth) + tmp94 := lang.Apply(tmp93, []any{v89, int64(1), nil}) + var v95 any = tmp94 + _ = v95 + var tmp96 any + tmp97 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp98 := lang.Apply(tmp97, []any{v92}) + if lang.IsTruthy(tmp98) { + tmp99 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp100 lang.FnFunc + tmp100 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v101 := args[0] + _ = v101 + v102 := args[1] + _ = v102 + tmp103 := lang.Apply(v83, []any{v101, v102, v95}) + return tmp103 + }) + tmp101 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6752), kw_column, int(37), kw_end_DASH_line, int(6752), kw_end_DASH_column, int(60)) + tmp102, err := lang.WithMeta(tmp100, tmp101.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp103 := lang.Apply(tmp99, []any{tmp102, v86, v92}) + tmp96 = tmp103 } else { - tmp29 = v28 + tmp104 := lang.Apply(v83, []any{v86, v92, v95}) + tmp96 = tmp104 } - tmp13 = tmp29 + tmp88 = tmp96 } // end let - return tmp13 - default: - checkArity(args, -1) - panic("unreachable") + return tmp88 + }) + tmp86 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6750), kw_column, int(24), kw_end_DASH_line, int(6753), kw_end_DASH_column, int(53)) + tmp87, err := lang.WithMeta(tmp85, tmp86.(lang.IPersistentMap)) + if err != nil { + panic(err) } - }) - tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2862), kw_column, int(10), kw_end_DASH_line, int(2873), kw_end_DASH_column, int(28)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp6 = tmp12 - } // end let - return tmp6 - }) - tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2860), kw_column, int(6), kw_end_DASH_line, int(2873), kw_end_DASH_column, int(30)) - tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp6 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 lang.FnFunc - tmp5 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - var tmp6 any - tmp7 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) - tmp8 := lang.Apply(tmp7, []any{v3}) - if lang.IsTruthy(tmp8) { - var tmp9 any - { // let - // let binding "temp__0__auto__" - tmp10 := checkDerefVar(var_glojure_DOT_core_seq) - tmp11 := lang.Apply(tmp10, []any{v4}) - var v12 any = tmp11 - _ = v12 - var tmp13 any - if lang.IsTruthy(v12) { - var tmp14 any - { // let - // let binding "s" - var v15 any = v12 - _ = v15 - tmp16 := checkDerefVar(var_glojure_DOT_core_cons) - tmp17 := checkDerefVar(var_glojure_DOT_core_first) - tmp18 := lang.Apply(tmp17, []any{v15}) - tmp19 := checkDerefVar(var_glojure_DOT_core_take) - tmp20 := checkDerefVar(var_glojure_DOT_core_dec) - tmp21 := lang.Apply(tmp20, []any{v3}) - tmp22 := checkDerefVar(var_glojure_DOT_core_rest) - tmp23 := lang.Apply(tmp22, []any{v15}) - tmp24 := lang.Apply(tmp19, []any{tmp21, tmp23}) - tmp25 := lang.Apply(tmp16, []any{tmp18, tmp24}) - tmp14 = tmp25 - } // end let - tmp13 = tmp14 - } else { + tmp88 := lang.NewMap() + tmp89 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6754), kw_column, int(24), kw_end_DASH_line, int(6754), kw_end_DASH_column, int(25)) + tmp90, err := lang.WithMeta(tmp88, tmp89.(lang.IPersistentMap)) + if err != nil { + panic(err) } - tmp9 = tmp13 - } // end let - tmp6 = tmp9 - } else { - } - return tmp6 - }) - tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) - return tmp6 - default: - checkArity(args, -1) - panic("unreachable") - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // take-last - { - tmp0 := sym_take_DASH_last.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n, sym_coll)), kw_doc, "Returns a seq of the last n items in coll. Depending on the type\n of coll may be no better than linear time. For vectors, see also subvec.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(2939), kw_end_DASH_line, int(2939))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - { // let - // let binding "s" - tmp6 := checkDerefVar(var_glojure_DOT_core_seq) - tmp7 := lang.Apply(tmp6, []any{v4}) - var v8 any = tmp7 - _ = v8 - // let binding "lead" - tmp9 := checkDerefVar(var_glojure_DOT_core_seq) - tmp10 := checkDerefVar(var_glojure_DOT_core_drop) - tmp11 := lang.Apply(tmp10, []any{v3, v4}) - tmp12 := lang.Apply(tmp9, []any{tmp11}) - var v13 any = tmp12 - _ = v13 - for { - var tmp14 any - if lang.IsTruthy(v13) { - tmp16 := checkDerefVar(var_glojure_DOT_core_next) - tmp17 := lang.Apply(tmp16, []any{v8}) - var tmp15 any = tmp17 - tmp19 := checkDerefVar(var_glojure_DOT_core_next) - tmp20 := lang.Apply(tmp19, []any{v13}) - var tmp18 any = tmp20 - v8 = tmp15 - v13 = tmp18 - continue - } else { - tmp14 = v8 - } - tmp5 = tmp14 - break - } - } // end let - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // take-nth - { - tmp0 := sym_take_DASH_nth.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n), lang.NewVector(sym_n, sym_coll)), kw_doc, "Returns a lazy seq of every nth item in coll. Returns a stateful\n transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(4287), kw_end_DASH_line, int(4287))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v5 := args[0] - _ = v5 - var tmp6 any - { // let - // let binding "iv" - tmp7 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) - tmp8 := lang.Apply(tmp7, []any{int64(-1)}) - var v9 any = tmp8 - _ = v9 - var tmp10 lang.FnFunc - tmp10 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp11 := lang.Apply(v5, nil) - return tmp11 - case 1: - v11 := args[0] - _ = v11 - tmp12 := lang.Apply(v5, []any{v11}) - return tmp12 - case 2: - v11 := args[0] - _ = v11 - v12 := args[1] - _ = v12 - var tmp13 any + tmp91 := lang.Apply(tmp84, []any{tmp87, tmp90, v79}) + var v92 any = tmp91 + _ = v92 + // let binding "tests" + tmp93 := checkDerefVar(var_glojure_DOT_core_keys) + tmp94 := lang.Apply(tmp93, []any{v92}) + var v95 any = tmp94 + _ = v95 + // let binding "thens" + tmp96 := checkDerefVar(var_glojure_DOT_core_vals) + tmp97 := lang.Apply(tmp96, []any{v92}) + var v98 any = tmp97 + _ = v98 + // let binding "mode" + var tmp99 any + tmp100 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + var tmp101 lang.FnFunc + tmp101 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v102 := args[0] + _ = v102 + var tmp103 any { // let - // let binding "i" - tmp14 := checkDerefVar(var_glojure_DOT_core_inc) - tmp15, ok := lang.FieldOrMethod(v9, "Deref") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v9, "Deref"))) - } - var tmp16 any - switch reflect.TypeOf(tmp15).Kind() { - case reflect.Func: - tmp16 = lang.Apply(tmp15, nil) - default: - tmp16 = tmp15 - } - tmp17 := lang.Apply(tmp14, []any{tmp16}) - tmp18, _ := lang.FieldOrMethod(v9, "reset") - if reflect.TypeOf(tmp18).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) - } - tmp19 := lang.Apply(tmp18, []any{tmp17}) - var v20 any = tmp19 - _ = v20 - var tmp21 any - tmp22 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) - tmp23 := checkDerefVar(var_glojure_DOT_core_rem) - tmp24 := lang.Apply(tmp23, []any{v20, v3}) - tmp25 := lang.Apply(tmp22, []any{tmp24}) - if lang.IsTruthy(tmp25) { - tmp26 := lang.Apply(v5, []any{v11, v12}) - tmp21 = tmp26 + // let binding "and__0__auto__" + tmp104 := checkDerefVar(var_glojure_DOT_core_integer_QMARK_) + tmp105 := lang.Apply(tmp104, []any{v102}) + var v106 any = tmp105 + _ = v106 + var tmp107 any + if lang.IsTruthy(v106) { + tmp108 := checkDerefVar(var_glojure_DOT_core__LT__EQ_) + tmp109 := lang.Apply(tmp108, []any{math7.MinInt, v102, math7.MaxInt}) + tmp107 = tmp109 } else { - tmp21 = v11 + tmp107 = v106 } - tmp13 = tmp21 + tmp103 = tmp107 } // end let - return tmp13 - default: - checkArity(args, -1) - panic("unreachable") + return tmp103 + }) + tmp102 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6758), kw_column, int(28), kw_end_DASH_line, int(6758), kw_end_DASH_column, int(77)) + tmp103, err := lang.WithMeta(tmp101, tmp102.(lang.IPersistentMap)) + if err != nil { + panic(err) } - }) - tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4295), kw_column, int(10), kw_end_DASH_line, int(4302), kw_end_DASH_column, int(28)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp6 = tmp12 - } // end let - return tmp6 - }) - tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4293), kw_column, int(6), kw_end_DASH_line, int(4302), kw_end_DASH_column, int(30)) - tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp6 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 lang.FnFunc - tmp5 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - var tmp6 any - { // let - // let binding "temp__0__auto__" - tmp7 := checkDerefVar(var_glojure_DOT_core_seq) - tmp8 := lang.Apply(tmp7, []any{v4}) - var v9 any = tmp8 - _ = v9 - var tmp10 any - if lang.IsTruthy(v9) { - var tmp11 any - { // let - // let binding "s" - var v12 any = v9 - _ = v12 - tmp13 := checkDerefVar(var_glojure_DOT_core_cons) - tmp14 := checkDerefVar(var_glojure_DOT_core_first) - tmp15 := lang.Apply(tmp14, []any{v12}) - tmp16 := checkDerefVar(var_glojure_DOT_core_take_DASH_nth) - tmp17 := checkDerefVar(var_glojure_DOT_core_drop) - tmp18 := lang.Apply(tmp17, []any{v3, v12}) - tmp19 := lang.Apply(tmp16, []any{v3, tmp18}) - tmp20 := lang.Apply(tmp13, []any{tmp15, tmp19}) - tmp11 = tmp20 - } // end let - tmp10 = tmp11 - } else { - } - tmp6 = tmp10 - } // end let - return tmp6 - }) - tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) - return tmp6 - default: - checkArity(args, -1) - panic("unreachable") - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // take-while - { - tmp0 := sym_take_DASH_while.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred), lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns a lazy sequence of successive items from coll while\n (pred item) returns logical true. pred must be free of side-effects.\n Returns a transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(2880), kw_end_DASH_line, int(2880))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v3 := args[0] - _ = v3 - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v5 := args[0] - _ = v5 - var tmp6 lang.FnFunc - tmp6 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp7 := lang.Apply(v5, nil) - return tmp7 - case 1: - v7 := args[0] - _ = v7 - tmp8 := lang.Apply(v5, []any{v7}) - return tmp8 - case 2: - v7 := args[0] - _ = v7 - v8 := args[1] - _ = v8 - var tmp9 any - tmp10 := lang.Apply(v3, []any{v8}) - if lang.IsTruthy(tmp10) { - tmp11 := lang.Apply(v5, []any{v7, v8}) - tmp9 = tmp11 + tmp104 := lang.Apply(tmp100, []any{tmp103, v95}) + if lang.IsTruthy(tmp104) { + tmp99 = kw_ints } else { - tmp12 := checkDerefVar(var_glojure_DOT_core_reduced) - tmp13 := lang.Apply(tmp12, []any{v7}) - tmp9 = tmp13 - } - return tmp9 - default: - checkArity(args, -1) - panic("unreachable") - } - }) - tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2888), kw_column, int(8), kw_end_DASH_line, int(2894), kw_end_DASH_column, int(33)) - tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp8 - }) - tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2887), kw_column, int(6), kw_end_DASH_line, int(2894), kw_end_DASH_column, int(34)) - tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp6 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 lang.FnFunc - tmp5 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - var tmp6 any - { // let - // let binding "temp__0__auto__" - tmp7 := checkDerefVar(var_glojure_DOT_core_seq) - tmp8 := lang.Apply(tmp7, []any{v4}) - var v9 any = tmp8 - _ = v9 - var tmp10 any - if lang.IsTruthy(v9) { - var tmp11 any - { // let - // let binding "s" - var v12 any = v9 - _ = v12 - var tmp13 any - tmp14 := checkDerefVar(var_glojure_DOT_core_first) - tmp15 := lang.Apply(tmp14, []any{v12}) - tmp16 := lang.Apply(v3, []any{tmp15}) - if lang.IsTruthy(tmp16) { - tmp17 := checkDerefVar(var_glojure_DOT_core_cons) - tmp18 := checkDerefVar(var_glojure_DOT_core_first) - tmp19 := lang.Apply(tmp18, []any{v12}) - tmp20 := checkDerefVar(var_glojure_DOT_core_take_DASH_while) - tmp21 := checkDerefVar(var_glojure_DOT_core_rest) - tmp22 := lang.Apply(tmp21, []any{v12}) - tmp23 := lang.Apply(tmp20, []any{v3, tmp22}) - tmp24 := lang.Apply(tmp17, []any{tmp19, tmp23}) - tmp13 = tmp24 + var tmp105 any + tmp106 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + tmp107 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp108 := lang.Apply(tmp106, []any{tmp107, v95}) + if lang.IsTruthy(tmp108) { + tmp105 = kw_identity } else { + var tmp109 any + if lang.IsTruthy(kw_else) { + tmp109 = kw_hashes + } else { + } + tmp105 = tmp109 } - tmp11 = tmp13 + tmp99 = tmp105 + } + var v110 any = tmp99 + _ = v110 + var tmp111 any + { // let + // let binding "pred__180" + tmp112 := checkDerefVar(var_glojure_DOT_core__EQ_) + var v113 any = tmp112 + _ = v113 + // let binding "expr__181" + var v114 any = v110 + _ = v114 + var tmp115 any + tmp116 := lang.Apply(v113, []any{kw_ints, v114}) + if lang.IsTruthy(tmp116) { + var tmp117 any + { // let + // let binding "vec__182" + tmp118 := checkDerefVar(var_glojure_DOT_core_prep_DASH_ints) + tmp119 := lang.Apply(tmp118, []any{v95, v98}) + var v120 any = tmp119 + _ = v120 + // let binding "shift" + tmp121 := checkDerefVar(var_glojure_DOT_core_nth) + tmp122 := lang.Apply(tmp121, []any{v120, int64(0), nil}) + var v123 any = tmp122 + _ = v123 + // let binding "mask" + tmp124 := checkDerefVar(var_glojure_DOT_core_nth) + tmp125 := lang.Apply(tmp124, []any{v120, int64(1), nil}) + var v126 any = tmp125 + _ = v126 + // let binding "imap" + tmp127 := checkDerefVar(var_glojure_DOT_core_nth) + tmp128 := lang.Apply(tmp127, []any{v120, int64(2), nil}) + var v129 any = tmp128 + _ = v129 + // let binding "switch-type" + tmp130 := checkDerefVar(var_glojure_DOT_core_nth) + tmp131 := lang.Apply(tmp130, []any{v120, int64(3), nil}) + var v132 any = tmp131 + _ = v132 + tmp133 := checkDerefVar(var_glojure_DOT_core_seq) + tmp134 := checkDerefVar(var_glojure_DOT_core_concat) + tmp135 := checkDerefVar(var_glojure_DOT_core_list) + tmp136 := lang.Apply(tmp135, []any{sym_glojure_DOT_core_SLASH_let}) + tmp137 := checkDerefVar(var_glojure_DOT_core_list) + tmp138 := checkDerefVar(var_glojure_DOT_core_apply) + tmp139 := checkDerefVar(var_glojure_DOT_core_vector) + tmp140 := checkDerefVar(var_glojure_DOT_core_seq) + tmp141 := checkDerefVar(var_glojure_DOT_core_concat) + tmp142 := checkDerefVar(var_glojure_DOT_core_list) + tmp143 := lang.Apply(tmp142, []any{v15}) + tmp144 := checkDerefVar(var_glojure_DOT_core_list) + tmp145 := lang.Apply(tmp144, []any{v4}) + tmp146 := lang.Apply(tmp141, []any{tmp143, tmp145}) + tmp147 := lang.Apply(tmp140, []any{tmp146}) + tmp148 := lang.Apply(tmp138, []any{tmp139, tmp147}) + tmp149 := lang.Apply(tmp137, []any{tmp148}) + tmp150 := checkDerefVar(var_glojure_DOT_core_list) + tmp151 := checkDerefVar(var_glojure_DOT_core_seq) + tmp152 := checkDerefVar(var_glojure_DOT_core_concat) + tmp153 := checkDerefVar(var_glojure_DOT_core_list) + tmp154 := lang.Apply(tmp153, []any{sym_case_STAR_}) + tmp155 := checkDerefVar(var_glojure_DOT_core_list) + tmp156 := lang.Apply(tmp155, []any{v15}) + tmp157 := checkDerefVar(var_glojure_DOT_core_list) + tmp158 := lang.Apply(tmp157, []any{v123}) + tmp159 := checkDerefVar(var_glojure_DOT_core_list) + tmp160 := lang.Apply(tmp159, []any{v126}) + tmp161 := checkDerefVar(var_glojure_DOT_core_list) + tmp162 := lang.Apply(tmp161, []any{v49}) + tmp163 := checkDerefVar(var_glojure_DOT_core_list) + tmp164 := lang.Apply(tmp163, []any{v129}) + tmp165 := checkDerefVar(var_glojure_DOT_core_list) + tmp166 := lang.Apply(tmp165, []any{v132}) + tmp167 := checkDerefVar(var_glojure_DOT_core_list) + tmp168 := lang.Apply(tmp167, []any{kw_int}) + tmp169 := lang.Apply(tmp152, []any{tmp154, tmp156, tmp158, tmp160, tmp162, tmp164, tmp166, tmp168}) + tmp170 := lang.Apply(tmp151, []any{tmp169}) + tmp171 := lang.Apply(tmp150, []any{tmp170}) + tmp172 := lang.Apply(tmp134, []any{tmp136, tmp149, tmp171}) + tmp173 := lang.Apply(tmp133, []any{tmp172}) + tmp117 = tmp173 + } // end let + tmp115 = tmp117 + } else { + var tmp118 any + tmp119 := lang.Apply(v113, []any{kw_hashes, v114}) + if lang.IsTruthy(tmp119) { + var tmp120 any + { // let + // let binding "vec__185" + tmp121 := checkDerefVar(var_glojure_DOT_core_prep_DASH_hashes) + tmp122 := lang.Apply(tmp121, []any{v15, v49, v95, v98}) + var v123 any = tmp122 + _ = v123 + // let binding "shift" + tmp124 := checkDerefVar(var_glojure_DOT_core_nth) + tmp125 := lang.Apply(tmp124, []any{v123, int64(0), nil}) + var v126 any = tmp125 + _ = v126 + // let binding "mask" + tmp127 := checkDerefVar(var_glojure_DOT_core_nth) + tmp128 := lang.Apply(tmp127, []any{v123, int64(1), nil}) + var v129 any = tmp128 + _ = v129 + // let binding "imap" + tmp130 := checkDerefVar(var_glojure_DOT_core_nth) + tmp131 := lang.Apply(tmp130, []any{v123, int64(2), nil}) + var v132 any = tmp131 + _ = v132 + // let binding "switch-type" + tmp133 := checkDerefVar(var_glojure_DOT_core_nth) + tmp134 := lang.Apply(tmp133, []any{v123, int64(3), nil}) + var v135 any = tmp134 + _ = v135 + // let binding "skip-check" + tmp136 := checkDerefVar(var_glojure_DOT_core_nth) + tmp137 := lang.Apply(tmp136, []any{v123, int64(4), nil}) + var v138 any = tmp137 + _ = v138 + tmp139 := checkDerefVar(var_glojure_DOT_core_seq) + tmp140 := checkDerefVar(var_glojure_DOT_core_concat) + tmp141 := checkDerefVar(var_glojure_DOT_core_list) + tmp142 := lang.Apply(tmp141, []any{sym_glojure_DOT_core_SLASH_let}) + tmp143 := checkDerefVar(var_glojure_DOT_core_list) + tmp144 := checkDerefVar(var_glojure_DOT_core_apply) + tmp145 := checkDerefVar(var_glojure_DOT_core_vector) + tmp146 := checkDerefVar(var_glojure_DOT_core_seq) + tmp147 := checkDerefVar(var_glojure_DOT_core_concat) + tmp148 := checkDerefVar(var_glojure_DOT_core_list) + tmp149 := lang.Apply(tmp148, []any{v15}) + tmp150 := checkDerefVar(var_glojure_DOT_core_list) + tmp151 := lang.Apply(tmp150, []any{v4}) + tmp152 := lang.Apply(tmp147, []any{tmp149, tmp151}) + tmp153 := lang.Apply(tmp146, []any{tmp152}) + tmp154 := lang.Apply(tmp144, []any{tmp145, tmp153}) + tmp155 := lang.Apply(tmp143, []any{tmp154}) + tmp156 := checkDerefVar(var_glojure_DOT_core_list) + tmp157 := checkDerefVar(var_glojure_DOT_core_seq) + tmp158 := checkDerefVar(var_glojure_DOT_core_concat) + tmp159 := checkDerefVar(var_glojure_DOT_core_list) + tmp160 := lang.Apply(tmp159, []any{sym_case_STAR_}) + tmp161 := checkDerefVar(var_glojure_DOT_core_list) + tmp162 := lang.Apply(tmp161, []any{v15}) + tmp163 := checkDerefVar(var_glojure_DOT_core_list) + tmp164 := lang.Apply(tmp163, []any{v126}) + tmp165 := checkDerefVar(var_glojure_DOT_core_list) + tmp166 := lang.Apply(tmp165, []any{v129}) + tmp167 := checkDerefVar(var_glojure_DOT_core_list) + tmp168 := lang.Apply(tmp167, []any{v49}) + tmp169 := checkDerefVar(var_glojure_DOT_core_list) + tmp170 := lang.Apply(tmp169, []any{v132}) + tmp171 := checkDerefVar(var_glojure_DOT_core_list) + tmp172 := lang.Apply(tmp171, []any{v135}) + tmp173 := checkDerefVar(var_glojure_DOT_core_list) + tmp174 := lang.Apply(tmp173, []any{kw_hash_DASH_equiv}) + tmp175 := checkDerefVar(var_glojure_DOT_core_list) + tmp176 := lang.Apply(tmp175, []any{v138}) + tmp177 := lang.Apply(tmp158, []any{tmp160, tmp162, tmp164, tmp166, tmp168, tmp170, tmp172, tmp174, tmp176}) + tmp178 := lang.Apply(tmp157, []any{tmp177}) + tmp179 := lang.Apply(tmp156, []any{tmp178}) + tmp180 := lang.Apply(tmp140, []any{tmp142, tmp155, tmp179}) + tmp181 := lang.Apply(tmp139, []any{tmp180}) + tmp120 = tmp181 + } // end let + tmp118 = tmp120 + } else { + var tmp121 any + tmp122 := lang.Apply(v113, []any{kw_identity, v114}) + if lang.IsTruthy(tmp122) { + var tmp123 any + { // let + // let binding "vec__188" + tmp124 := checkDerefVar(var_glojure_DOT_core_prep_DASH_hashes) + tmp125 := lang.Apply(tmp124, []any{v15, v49, v95, v98}) + var v126 any = tmp125 + _ = v126 + // let binding "shift" + tmp127 := checkDerefVar(var_glojure_DOT_core_nth) + tmp128 := lang.Apply(tmp127, []any{v126, int64(0), nil}) + var v129 any = tmp128 + _ = v129 + // let binding "mask" + tmp130 := checkDerefVar(var_glojure_DOT_core_nth) + tmp131 := lang.Apply(tmp130, []any{v126, int64(1), nil}) + var v132 any = tmp131 + _ = v132 + // let binding "imap" + tmp133 := checkDerefVar(var_glojure_DOT_core_nth) + tmp134 := lang.Apply(tmp133, []any{v126, int64(2), nil}) + var v135 any = tmp134 + _ = v135 + // let binding "switch-type" + tmp136 := checkDerefVar(var_glojure_DOT_core_nth) + tmp137 := lang.Apply(tmp136, []any{v126, int64(3), nil}) + var v138 any = tmp137 + _ = v138 + // let binding "skip-check" + tmp139 := checkDerefVar(var_glojure_DOT_core_nth) + tmp140 := lang.Apply(tmp139, []any{v126, int64(4), nil}) + var v141 any = tmp140 + _ = v141 + tmp142 := checkDerefVar(var_glojure_DOT_core_seq) + tmp143 := checkDerefVar(var_glojure_DOT_core_concat) + tmp144 := checkDerefVar(var_glojure_DOT_core_list) + tmp145 := lang.Apply(tmp144, []any{sym_glojure_DOT_core_SLASH_let}) + tmp146 := checkDerefVar(var_glojure_DOT_core_list) + tmp147 := checkDerefVar(var_glojure_DOT_core_apply) + tmp148 := checkDerefVar(var_glojure_DOT_core_vector) + tmp149 := checkDerefVar(var_glojure_DOT_core_seq) + tmp150 := checkDerefVar(var_glojure_DOT_core_concat) + tmp151 := checkDerefVar(var_glojure_DOT_core_list) + tmp152 := lang.Apply(tmp151, []any{v15}) + tmp153 := checkDerefVar(var_glojure_DOT_core_list) + tmp154 := lang.Apply(tmp153, []any{v4}) + tmp155 := lang.Apply(tmp150, []any{tmp152, tmp154}) + tmp156 := lang.Apply(tmp149, []any{tmp155}) + tmp157 := lang.Apply(tmp147, []any{tmp148, tmp156}) + tmp158 := lang.Apply(tmp146, []any{tmp157}) + tmp159 := checkDerefVar(var_glojure_DOT_core_list) + tmp160 := checkDerefVar(var_glojure_DOT_core_seq) + tmp161 := checkDerefVar(var_glojure_DOT_core_concat) + tmp162 := checkDerefVar(var_glojure_DOT_core_list) + tmp163 := lang.Apply(tmp162, []any{sym_case_STAR_}) + tmp164 := checkDerefVar(var_glojure_DOT_core_list) + tmp165 := lang.Apply(tmp164, []any{v15}) + tmp166 := checkDerefVar(var_glojure_DOT_core_list) + tmp167 := lang.Apply(tmp166, []any{v129}) + tmp168 := checkDerefVar(var_glojure_DOT_core_list) + tmp169 := lang.Apply(tmp168, []any{v132}) + tmp170 := checkDerefVar(var_glojure_DOT_core_list) + tmp171 := lang.Apply(tmp170, []any{v49}) + tmp172 := checkDerefVar(var_glojure_DOT_core_list) + tmp173 := lang.Apply(tmp172, []any{v135}) + tmp174 := checkDerefVar(var_glojure_DOT_core_list) + tmp175 := lang.Apply(tmp174, []any{v138}) + tmp176 := checkDerefVar(var_glojure_DOT_core_list) + tmp177 := lang.Apply(tmp176, []any{kw_hash_DASH_identity}) + tmp178 := checkDerefVar(var_glojure_DOT_core_list) + tmp179 := lang.Apply(tmp178, []any{v141}) + tmp180 := lang.Apply(tmp161, []any{tmp163, tmp165, tmp167, tmp169, tmp171, tmp173, tmp175, tmp177, tmp179}) + tmp181 := lang.Apply(tmp160, []any{tmp180}) + tmp182 := lang.Apply(tmp159, []any{tmp181}) + tmp183 := lang.Apply(tmp143, []any{tmp145, tmp158, tmp182}) + tmp184 := lang.Apply(tmp142, []any{tmp183}) + tmp123 = tmp184 + } // end let + tmp121 = tmp123 + } else { + tmp124 := checkDerefVar(var_glojure_DOT_core_str) + tmp125 := lang.Apply(tmp124, []any{"No matching clause: ", v114}) + tmp126 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp125}) + panic(tmp126) + } + tmp118 = tmp121 + } + tmp115 = tmp118 + } + tmp111 = tmp115 } // end let - tmp10 = tmp11 - } else { - } - tmp6 = tmp10 - } // end let - return tmp6 - }) - tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) + tmp76 = tmp111 + } // end let + tmp50 = tmp76 + } + tmp6 = tmp50 + } // end let return tmp6 - default: - checkArity(args, -1) - panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // tapset - { - tmp0 := sym_tapset.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(7882), kw_column, int(10), kw_end_DASH_line, int(7882), kw_end_DASH_column, int(25), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - tmp2 := lang.NewAtom(lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{}))) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_case = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_case.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // test + // cat { - tmp0 := sym_test.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_v)), kw_doc, "test [v] finds fn at key :test in var metadata and calls it,\n presuming failure will throw exception", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(4853), kw_end_DASH_line, int(4853))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_cat.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_rf)), kw_doc, "A transducer which concatenates the contents of each input, which must be a\n collection, into the reduction.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(7645), kw_end_DASH_line, int(7645))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 any + v2 := args[0] + _ = v2 + var tmp3 any { // let - // let binding "f" - tmp5 := checkDerefVar(var_glojure_DOT_core_meta) - tmp6 := lang.Apply(tmp5, []any{v3}) - tmp7 := lang.Apply(kw_test, []any{tmp6}) - var v8 any = tmp7 - _ = v8 - var tmp9 any - if lang.IsTruthy(v8) { - tmp10 := lang.Apply(v8, nil) - _ = tmp10 - tmp9 = kw_ok - } else { - tmp9 = kw_no_DASH_test + // let binding "rrf" + tmp4 := checkDerefVar(var_glojure_DOT_core_preserving_DASH_reduced) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp8 := lang.Apply(v2, nil) + return tmp8 + case 1: + v8 := args[0] + _ = v8 + tmp9 := lang.Apply(v2, []any{v8}) + return tmp9 + case 2: + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_reduce) + tmp11 := lang.Apply(tmp10, []any{v6, v8, v9}) + return tmp11 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7651), kw_column, int(5), kw_end_DASH_line, int(7655), kw_end_DASH_column, int(36)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) } - tmp4 = tmp9 + tmp3 = tmp9 } // end let - return tmp4 + return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_cat = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_cat.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // the-ns + // mapcat { - tmp0 := sym_the_DASH_ns.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "If passed a namespace, returns it. Else, when passed a symbol,\n returns the namespace named by it, throwing an exception if not\n found.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(4152), kw_end_DASH_line, int(4152))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp6 := reflect.TypeOf((*lang.Namespace)(nil)) - tmp7 := lang.Apply(tmp5, []any{tmp6, v3}) - if lang.IsTruthy(tmp7) { - tmp4 = v3 - } else { - var tmp8 any - { // let - // let binding "or__0__auto__" - tmp9 := checkDerefVar(var_glojure_DOT_core_find_DASH_ns) - tmp10 := lang.Apply(tmp9, []any{v3}) - var v11 any = tmp10 - _ = v11 - var tmp12 any - if lang.IsTruthy(v11) { - tmp12 = v11 - } else { - tmp13 := checkDerefVar(var_glojure_DOT_core_str) - tmp14 := lang.Apply(tmp13, []any{"No namespace: ", v3, " found"}) - tmp15 := lang.Apply(lang.NewError, []any{tmp14}) - panic(tmp15) - } - tmp8 = tmp12 - } // end let - tmp4 = tmp8 + tmp0 := sym_mapcat.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym__AMP_, sym_colls)), kw_doc, "Returns the result of applying concat to the result of applying map\n to f and colls. Thus function f should return a collection. Returns\n a transducer when no collections are provided", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(2775), kw_end_DASH_line, int(2775))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_comp) + tmp4 := checkDerefVar(var_glojure_DOT_core_map) + tmp5 := lang.Apply(tmp4, []any{v2}) + tmp6 := checkDerefVar(var_glojure_DOT_core_cat) + tmp7 := lang.Apply(tmp3, []any{tmp5, tmp6}) + return tmp7 + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_apply) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_map) + tmp8 := lang.Apply(tmp6, []any{tmp7, v2, v3}) + tmp9 := lang.Apply(tmp4, []any{tmp5, tmp8}) + return tmp9 } - return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_mapcat = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_mapcat.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // thread-bound? + // merge-hash-collisions { - tmp0 := sym_thread_DASH_bound_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_vars)), kw_doc, "Returns true if all of the vars provided as arguments have thread-local bindings.\n Implies that set!'ing the provided vars will succeed. Returns true if no vars are provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(5499), kw_end_DASH_line, int(5499))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 0) - var v3 any = lang.NewList(args[0:]...) - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) - var tmp5 lang.FnFunc - tmp5 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v6 := args[0] - _ = v6 - tmp7, ok := lang.FieldOrMethod(v6, "getThreadBinding") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "getThreadBinding"))) + tmp0 := sym_merge_DASH_hash_DASH_collisions.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_expr_DASH_sym, sym_default, sym_tests, sym_thens)), kw_doc, "Takes a case expression, default expression, and a sequence of test constants\n and a corresponding sequence of then expressions. Returns a tuple of\n [tests thens skip-check-set] where no tests have the same hash. Each set of\n input test constants with the same hash is replaced with a single test\n constant (the case int), and their respective thens are combined into:\n (condp = expr\n test-1 then-1\n ...\n test-n then-n\n default).\n The skip-check is a set of case ints for which post-switch equivalence\n checking must not be done (the cases holding the above condp thens).", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(28), kw_column, int(8), kw_line, int(6647), kw_end_DASH_line, int(6647), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var tmp6 any + { // let + // let binding "buckets" + var tmp7 any + { // let + // let binding "m" + tmp8 := lang.NewMap() + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6661), kw_column, int(26), kw_end_DASH_line, int(6661), kw_end_DASH_column, int(27)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) } - var tmp8 any - switch reflect.TypeOf(tmp7).Kind() { - case reflect.Func: - tmp8 = lang.Apply(tmp7, nil) - default: - tmp8 = tmp7 + var v11 any = tmp10 + _ = v11 + // let binding "ks" + var v12 any = v4 + _ = v12 + // let binding "vs" + var v13 any = v5 + _ = v13 + for { + var tmp14 any + var tmp15 any + { // let + // let binding "and__0__auto__" + var v16 any = v12 + _ = v16 + var tmp17 any + if lang.IsTruthy(v16) { + tmp17 = v13 + } else { + tmp17 = v16 + } + tmp15 = tmp17 + } // end let + if lang.IsTruthy(tmp15) { + tmp17 := checkDerefVar(var_glojure_DOT_core_update) + tmp18 := checkDerefVar(var_glojure_DOT_core_first) + tmp19 := lang.Apply(tmp18, []any{v12}) + tmp20 := lang.Apply(lang.Hash, []any{tmp19}) + tmp21 := checkDerefVar(var_glojure_DOT_core_fnil) + tmp22 := checkDerefVar(var_glojure_DOT_core_conj) + tmp23 := lang.NewVector() + tmp24 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6664), kw_column, int(102), kw_end_DASH_line, int(6664), kw_end_DASH_column, int(103)) + tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp26 := lang.Apply(tmp21, []any{tmp22, tmp25}) + tmp27 := checkDerefVar(var_glojure_DOT_core_first) + tmp28 := lang.Apply(tmp27, []any{v12}) + tmp29 := checkDerefVar(var_glojure_DOT_core_first) + tmp30 := lang.Apply(tmp29, []any{v13}) + tmp31 := lang.NewVector(tmp28, tmp30) + tmp32 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6664), kw_column, int(106), kw_end_DASH_line, int(6664), kw_end_DASH_column, int(128)) + tmp33, err := lang.WithMeta(tmp31, tmp32.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp34 := lang.Apply(tmp17, []any{v11, tmp20, tmp26, tmp33}) + var tmp16 any = tmp34 + tmp36 := checkDerefVar(var_glojure_DOT_core_next) + tmp37 := lang.Apply(tmp36, []any{v12}) + var tmp35 any = tmp37 + tmp39 := checkDerefVar(var_glojure_DOT_core_next) + tmp40 := lang.Apply(tmp39, []any{v13}) + var tmp38 any = tmp40 + v11 = tmp16 + v12 = tmp35 + v13 = tmp38 + continue + } else { + tmp14 = v11 + } + tmp7 = tmp14 + break } - return tmp8 + } // end let + var v8 any = tmp7 + _ = v8 + // let binding "assoc-multi" + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + v12 := args[2] + _ = v12 + var tmp13 any + { // let + // let binding "testexprs" + tmp14 := checkDerefVar(var_glojure_DOT_core_mapcat) + var tmp15 lang.FnFunc + tmp15 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v16 := args[0] + _ = v16 + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_first) + tmp19 := lang.Apply(tmp18, []any{v16}) + tmp20 := lang.Apply(tmp17, []any{sym_quote, tmp19}) + tmp21 := checkDerefVar(var_glojure_DOT_core_second) + tmp22 := lang.Apply(tmp21, []any{v16}) + tmp23 := lang.NewVector(tmp20, tmp22) + tmp24 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6668), kw_column, int(56), kw_end_DASH_line, int(6668), kw_end_DASH_column, int(93)) + tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp25 + }) + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6668), kw_column, int(47), kw_end_DASH_line, int(6668), kw_end_DASH_column, int(94)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp18 := lang.Apply(tmp14, []any{tmp17, v12}) + var v19 any = tmp18 + _ = v19 + // let binding "expr" + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{sym_glojure_DOT_core_SLASH_condp}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{sym_glojure_DOT_core_SLASH__EQ_}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v2}) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := lang.Apply(tmp28, []any{v3}) + tmp30 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27, v19, tmp29}) + tmp31 := lang.Apply(tmp20, []any{tmp30}) + var v32 any = tmp31 + _ = v32 + tmp33 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp34 := lang.Apply(tmp33, []any{v10, v11, v32}) + tmp13 = tmp34 + } // end let + return tmp13 }) - tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5505), kw_column, int(11), kw_end_DASH_line, int(5505), kw_end_DASH_column, int(78)) - tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6667), kw_column, int(21), kw_end_DASH_line, int(6670), kw_end_DASH_column, int(42)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp8 := lang.Apply(tmp4, []any{tmp7, v3}) - return tmp8 - } + var v12 any = tmp11 + _ = v12 + // let binding "hmap" + tmp13 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v15 := args[0] + _ = v15 + v16 := args[1] + _ = v16 + var tmp17 any + { // let + // let binding "vec__164" + var v18 any = v16 + _ = v18 + // let binding "h" + tmp19 := checkDerefVar(var_glojure_DOT_core_nth) + tmp20 := lang.Apply(tmp19, []any{v18, int64(0), nil}) + var v21 any = tmp20 + _ = v21 + // let binding "bucket" + tmp22 := checkDerefVar(var_glojure_DOT_core_nth) + tmp23 := lang.Apply(tmp22, []any{v18, int64(1), nil}) + var v24 any = tmp23 + _ = v24 + var tmp25 any + tmp26 := checkDerefVar(var_glojure_DOT_core__EQ__EQ_) + tmp27 := checkDerefVar(var_glojure_DOT_core_count) + tmp28 := lang.Apply(tmp27, []any{v24}) + tmp29 := lang.Apply(tmp26, []any{int64(1), tmp28}) + if lang.IsTruthy(tmp29) { + tmp30 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp31 := checkDerefVar(var_glojure_DOT_core_ffirst) + tmp32 := lang.Apply(tmp31, []any{v24}) + tmp33 := checkDerefVar(var_glojure_DOT_core_second) + tmp34 := checkDerefVar(var_glojure_DOT_core_first) + tmp35 := lang.Apply(tmp34, []any{v24}) + tmp36 := lang.Apply(tmp33, []any{tmp35}) + tmp37 := lang.Apply(tmp30, []any{v15, tmp32, tmp36}) + tmp25 = tmp37 + } else { + tmp38 := lang.Apply(v12, []any{v15, v21, v24}) + tmp25 = tmp38 + } + tmp17 = tmp25 + } // end let + return tmp17 + }) + tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6672), kw_column, int(16), kw_end_DASH_line, int(6675), kw_end_DASH_column, int(45)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp17 := lang.NewMap() + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6676), kw_column, int(16), kw_end_DASH_line, int(6676), kw_end_DASH_column, int(17)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp20 := lang.Apply(tmp13, []any{tmp16, tmp19, v8}) + var v21 any = tmp20 + _ = v21 + // let binding "skip-check" + tmp22 := checkDerefVar(var_glojure_DOT_core_into1) + tmp23 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp24 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6680), kw_column, int(29), kw_end_DASH_line, int(6680), kw_end_DASH_column, int(31)) + tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp26 := checkDerefVar(var_glojure_DOT_core_map) + tmp27 := checkDerefVar(var_glojure_DOT_core_first) + tmp28 := checkDerefVar(var_glojure_DOT_core_filter) + var tmp29 lang.FnFunc + tmp29 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v30 := args[0] + _ = v30 + tmp31 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp32 := checkDerefVar(var_glojure_DOT_core_count) + tmp33 := checkDerefVar(var_glojure_DOT_core_second) + tmp34 := lang.Apply(tmp33, []any{v30}) + tmp35 := lang.Apply(tmp32, []any{tmp34}) + tmp36 := lang.Apply(tmp31, []any{int64(1), tmp35}) + return tmp36 + }) + tmp30 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6678), kw_column, int(30), kw_end_DASH_line, int(6678), kw_end_DASH_column, int(54)) + tmp31, err := lang.WithMeta(tmp29, tmp30.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp32 := lang.Apply(tmp28, []any{tmp31, v8}) + tmp33 := lang.Apply(tmp26, []any{tmp27, tmp32}) + tmp34 := lang.Apply(tmp22, []any{tmp25, tmp33}) + var v35 any = tmp34 + _ = v35 + tmp36 := checkDerefVar(var_glojure_DOT_core_keys) + tmp37 := lang.Apply(tmp36, []any{v21}) + tmp38 := checkDerefVar(var_glojure_DOT_core_vals) + tmp39 := lang.Apply(tmp38, []any{v21}) + tmp40 := lang.NewVector(tmp37, tmp39, v35) + tmp41 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6681), kw_column, int(5), kw_end_DASH_line, int(6681), kw_end_DASH_column, int(40)) + tmp42, err := lang.WithMeta(tmp40, tmp41.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp6 = tmp42 + } // end let + return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_merge_DASH_hash_DASH_collisions = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_merge_DASH_hash_DASH_collisions.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // throw-if + // prep-hashes { - tmp0 := sym_throw_DASH_if.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred, sym_fmt, sym__AMP_, sym_args)), kw_doc, "Throws a CompilerException with a message if pred is true", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(8), kw_line, int(5832), kw_end_DASH_line, int(5832), kw_private, true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - var tmp6 any - if lang.IsTruthy(v3) { - var tmp7 any - { // let - // let binding "message" - tmp8 := checkDerefVar(var_glojure_DOT_core_apply) - tmp9 := checkDerefVar(var_glojure_DOT_core_format) - tmp10 := lang.Apply(tmp8, []any{tmp9, v4, v5}) - var v11 any = tmp10 - _ = v11 - // let binding "exception" - tmp12 := lang.Apply(lang.NewError, []any{v11}) - var v13 any = tmp12 - _ = v13 - // let binding "raw-trace" - tmp14, ok := lang.FieldOrMethod(v13, "getStackTrace") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v13, "getStackTrace"))) - } - var tmp15 any - switch reflect.TypeOf(tmp14).Kind() { - case reflect.Func: - tmp15 = lang.Apply(tmp14, nil) - default: - tmp15 = tmp14 + tmp0 := sym_prep_DASH_hashes.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_expr_DASH_sym, sym_default, sym_tests, sym_thens)), kw_doc, "Takes a sequence of test constants and a corresponding sequence of then\n expressions. Returns a tuple of [shift mask case-map switch-type skip-check]\n where case-map is a map of int case values to [test then] tuples, switch-type\n is either :sparse or :compact, and skip-check is a set of case ints for which\n post-switch equivalence checking must not be done (occurs with hash\n collisions).", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(8), kw_line, int(6683), kw_end_DASH_line, int(6683), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var tmp6 any + { // let + // let binding "hashcode" + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v8 := args[0] + _ = v8 + tmp9 := lang.Apply(lang.Hash, []any{v8}) + return tmp9 + }) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6691), kw_column, int(18), kw_end_DASH_line, int(6691), kw_end_DASH_column, int(66)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v10 any = tmp9 + _ = v10 + // let binding "hashes" + tmp11 := checkDerefVar(var_glojure_DOT_core_into1) + tmp12 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6692), kw_column, int(23), kw_end_DASH_line, int(6692), kw_end_DASH_column, int(25)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp15 := checkDerefVar(var_glojure_DOT_core_map) + tmp16 := lang.Apply(tmp15, []any{v10, v4}) + tmp17 := lang.Apply(tmp11, []any{tmp14, tmp16}) + var v18 any = tmp17 + _ = v18 + var tmp19 any + tmp20 := checkDerefVar(var_glojure_DOT_core__EQ__EQ_) + tmp21 := checkDerefVar(var_glojure_DOT_core_count) + tmp22 := lang.Apply(tmp21, []any{v4}) + tmp23 := checkDerefVar(var_glojure_DOT_core_count) + tmp24 := lang.Apply(tmp23, []any{v18}) + tmp25 := lang.Apply(tmp20, []any{tmp22, tmp24}) + if lang.IsTruthy(tmp25) { + var tmp26 any + tmp27 := checkDerefVar(var_glojure_DOT_core_fits_DASH_table_QMARK_) + tmp28 := lang.Apply(tmp27, []any{v18}) + if lang.IsTruthy(tmp28) { + tmp29 := checkDerefVar(var_glojure_DOT_core_case_DASH_map) + tmp30 := checkDerefVar(var_glojure_DOT_core_identity) + tmp31 := lang.Apply(tmp29, []any{v10, tmp30, v4, v5}) + tmp32 := lang.NewVector(int64(0), int64(0), tmp31, kw_compact) + tmp33 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6696), kw_column, int(9), kw_end_DASH_line, int(6696), kw_end_DASH_column, int(63)) + tmp34, err := lang.WithMeta(tmp32, tmp33.(lang.IPersistentMap)) + if err != nil { + panic(err) } - var v16 any = tmp15 - _ = v16 - // let binding "boring?" - var tmp17 lang.FnFunc - tmp17 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v18 := args[0] - _ = v18 - tmp19 := checkDerefVar(var_glojure_DOT_core_not_EQ_) - tmp20, ok := lang.FieldOrMethod(v18, "getMethodName") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v18, "getMethodName"))) + tmp26 = tmp34 + } else { + var tmp35 any + { // let + // let binding "vec__167" + var tmp36 any + { // let + // let binding "or__0__auto__" + tmp37 := checkDerefVar(var_glojure_DOT_core_maybe_DASH_min_DASH_hash) + tmp38 := lang.Apply(tmp37, []any{v18}) + var v39 any = tmp38 + _ = v39 + var tmp40 any + if lang.IsTruthy(v39) { + tmp40 = v39 + } else { + tmp41 := lang.NewVector(int64(0), int64(0)) + tmp42 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6697), kw_column, int(56), kw_end_DASH_line, int(6697), kw_end_DASH_column, int(60)) + tmp43, err := lang.WithMeta(tmp41, tmp42.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp40 = tmp43 + } + tmp36 = tmp40 + } // end let + var v37 any = tmp36 + _ = v37 + // let binding "shift" + tmp38 := checkDerefVar(var_glojure_DOT_core_nth) + tmp39 := lang.Apply(tmp38, []any{v37, int64(0), nil}) + var v40 any = tmp39 + _ = v40 + // let binding "mask" + tmp41 := checkDerefVar(var_glojure_DOT_core_nth) + tmp42 := lang.Apply(tmp41, []any{v37, int64(1), nil}) + var v43 any = tmp42 + _ = v43 + var tmp44 any + tmp45 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) + tmp46 := lang.Apply(tmp45, []any{v43}) + if lang.IsTruthy(tmp46) { + tmp47 := checkDerefVar(var_glojure_DOT_core_case_DASH_map) + tmp48 := checkDerefVar(var_glojure_DOT_core_identity) + tmp49 := lang.Apply(tmp47, []any{v10, tmp48, v4, v5}) + tmp50 := lang.NewVector(int64(0), int64(0), tmp49, kw_sparse) + tmp51 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6700), kw_column, int(13), kw_end_DASH_line, int(6700), kw_end_DASH_column, int(66)) + tmp52, err := lang.WithMeta(tmp50, tmp51.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp44 = tmp52 + } else { + tmp53 := checkDerefVar(var_glojure_DOT_core_case_DASH_map) + var tmp54 lang.FnFunc + tmp54 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v55 := args[0] + _ = v55 + tmp56 := checkDerefVar(var_glojure_DOT_core_shift_DASH_mask) + tmp57 := lang.Apply(v10, []any{v55}) + tmp58 := lang.Apply(tmp56, []any{v40, v43, tmp57}) + return tmp58 + }) + tmp55 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6702), kw_column, int(35), kw_end_DASH_line, int(6702), kw_end_DASH_column, int(71)) + tmp56, err := lang.WithMeta(tmp54, tmp55.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp57 := checkDerefVar(var_glojure_DOT_core_identity) + tmp58 := lang.Apply(tmp53, []any{tmp56, tmp57, v4, v5}) + tmp59 := lang.NewVector(v40, v43, tmp58, kw_compact) + tmp60 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6702), kw_column, int(13), kw_end_DASH_line, int(6702), kw_end_DASH_column, int(103)) + tmp61, err := lang.WithMeta(tmp59, tmp60.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp44 = tmp61 } - var tmp21 any - switch reflect.TypeOf(tmp20).Kind() { - case reflect.Func: - tmp21 = lang.Apply(tmp20, nil) - default: - tmp21 = tmp20 + tmp35 = tmp44 + } // end let + tmp26 = tmp35 + } + tmp19 = tmp26 + } else { + var tmp36 any + { // let + // let binding "vec__170" + tmp37 := checkDerefVar(var_glojure_DOT_core_merge_DASH_hash_DASH_collisions) + tmp38 := lang.Apply(tmp37, []any{v2, v3, v4, v5}) + var v39 any = tmp38 + _ = v39 + // let binding "tests" + tmp40 := checkDerefVar(var_glojure_DOT_core_nth) + tmp41 := lang.Apply(tmp40, []any{v39, int64(0), nil}) + var v42 any = tmp41 + _ = v42 + // let binding "thens" + tmp43 := checkDerefVar(var_glojure_DOT_core_nth) + tmp44 := lang.Apply(tmp43, []any{v39, int64(1), nil}) + var v45 any = tmp44 + _ = v45 + // let binding "skip-check" + tmp46 := checkDerefVar(var_glojure_DOT_core_nth) + tmp47 := lang.Apply(tmp46, []any{v39, int64(2), nil}) + var v48 any = tmp47 + _ = v48 + // let binding "vec__173" + tmp49 := checkDerefVar(var_glojure_DOT_core_prep_DASH_hashes) + tmp50 := lang.Apply(tmp49, []any{v2, v3, v42, v45}) + var v51 any = tmp50 + _ = v51 + // let binding "shift" + tmp52 := checkDerefVar(var_glojure_DOT_core_nth) + tmp53 := lang.Apply(tmp52, []any{v51, int64(0), nil}) + var v54 any = tmp53 + _ = v54 + // let binding "mask" + tmp55 := checkDerefVar(var_glojure_DOT_core_nth) + tmp56 := lang.Apply(tmp55, []any{v51, int64(1), nil}) + var v57 any = tmp56 + _ = v57 + // let binding "case-map" + tmp58 := checkDerefVar(var_glojure_DOT_core_nth) + tmp59 := lang.Apply(tmp58, []any{v51, int64(2), nil}) + var v60 any = tmp59 + _ = v60 + // let binding "switch-type" + tmp61 := checkDerefVar(var_glojure_DOT_core_nth) + tmp62 := lang.Apply(tmp61, []any{v51, int64(3), nil}) + var v63 any = tmp62 + _ = v63 + // let binding "skip-check" + var tmp64 any + tmp65 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) + tmp66 := lang.Apply(tmp65, []any{v57}) + if lang.IsTruthy(tmp66) { + tmp64 = v48 + } else { + tmp67 := checkDerefVar(var_glojure_DOT_core_into1) + tmp68 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp69 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6708), kw_column, int(33), kw_end_DASH_line, int(6708), kw_end_DASH_column, int(35)) + tmp70, err := lang.WithMeta(tmp68, tmp69.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp71 := checkDerefVar(var_glojure_DOT_core_map) + var tmp72 lang.FnFunc + tmp72 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v73 := args[0] + _ = v73 + tmp74 := checkDerefVar(var_glojure_DOT_core_shift_DASH_mask) + tmp75 := lang.Apply(tmp74, []any{v54, v57, v73}) + return tmp75 + }) + tmp73 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6708), kw_column, int(42), kw_end_DASH_line, int(6708), kw_end_DASH_column, int(67)) + tmp74, err := lang.WithMeta(tmp72, tmp73.(lang.IPersistentMap)) + if err != nil { + panic(err) } - tmp22 := lang.Apply(tmp19, []any{tmp21, "doInvoke"}) - return tmp22 - }) - tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5839), kw_column, int(19), kw_end_DASH_line, int(5839), kw_end_DASH_column, int(74)) - tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + tmp75 := lang.Apply(tmp71, []any{tmp74, v48}) + tmp76 := lang.Apply(tmp67, []any{tmp70, tmp75}) + tmp64 = tmp76 + } + var v77 any = tmp64 + _ = v77 + tmp78 := lang.NewVector(v54, v57, v60, v63, v77) + tmp79 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6709), kw_column, int(9), kw_end_DASH_line, int(6709), kw_end_DASH_column, int(52)) + tmp80, err := lang.WithMeta(tmp78, tmp79.(lang.IPersistentMap)) if err != nil { panic(err) } - var v20 any = tmp19 - _ = v20 - // let binding "trace" - tmp21 := checkDerefVar(var_glojure_DOT_core_into_DASH_array) - tmp22 := checkDerefVar(var_glojure_DOT_core_drop) - tmp23 := checkDerefVar(var_glojure_DOT_core_drop_DASH_while) - tmp24 := lang.Apply(tmp23, []any{v20, v16}) - tmp25 := lang.Apply(tmp22, []any{int64(2), tmp24}) - tmp26 := lang.Apply(tmp21, []any{nil, tmp25}) - var v27 any = tmp26 - _ = v27 - tmp28, _ := lang.FieldOrMethod(v13, "setStackTrace") - if reflect.TypeOf(tmp28).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("setStackTrace is not a function"))) - } - tmp29 := lang.Apply(tmp28, []any{v27}) - _ = tmp29 - tmp30 := checkDerefVar(var_glojure_DOT_core__STAR_file_STAR_) - tmp31, ok := lang.FieldOrMethod(nil, "Deref") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "Deref"))) - } - var tmp32 any - switch reflect.TypeOf(tmp31).Kind() { - case reflect.Func: - tmp32 = lang.Apply(tmp31, nil) - default: - tmp32 = tmp31 - } - tmp33, ok := lang.FieldOrMethod(nil, "Deref") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "Deref"))) - } - var tmp34 any - switch reflect.TypeOf(tmp33).Kind() { - case reflect.Func: - tmp34 = lang.Apply(tmp33, nil) - default: - tmp34 = tmp33 - } - tmp35 := lang.Apply(lang.NewCompilerError, []any{tmp30, tmp32, tmp34, v13}) - panic(tmp35) + tmp36 = tmp80 } // end let - tmp6 = tmp7 - } else { + tmp19 = tmp36 } - return tmp6 - } + tmp6 = tmp19 + } // end let + return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_prep_DASH_hashes = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_prep_DASH_hashes.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // time + // tree-seq { - tmp0 := sym_time.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_expr)), kw_doc, "Evaluates expr and prints the time it took. Returns the value of\n expr.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(11), kw_line, int(3885), kw_end_DASH_line, int(3885))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_tree_DASH_seq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_branch_QMARK_, sym_children, sym_root)), kw_doc, "Returns a lazy sequence of the nodes in a tree, via a depth-first walk.\n branch? must be a fn of one arg that returns true if passed a node\n that can have children (but may not). children must be a fn of one\n arg that returns a sequence of the children. Will only be called on\n nodes for which branch? returns true. Root is the root node of the\n tree.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(4955), kw_end_DASH_line, int(4955))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 3) - v3 := args[0] + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + v4 := args[2] _ = v4 - v5 := args[2] - _ = v5 - tmp6 := checkDerefVar(var_glojure_DOT_core_seq) - tmp7 := checkDerefVar(var_glojure_DOT_core_concat) - tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_let}) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := checkDerefVar(var_glojure_DOT_core_apply) - tmp12 := checkDerefVar(var_glojure_DOT_core_vector) - tmp13 := checkDerefVar(var_glojure_DOT_core_seq) - tmp14 := checkDerefVar(var_glojure_DOT_core_concat) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{sym_start__0__auto__}) - tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := checkDerefVar(var_glojure_DOT_core_seq) - tmp19 := checkDerefVar(var_glojure_DOT_core_concat) - tmp20 := checkDerefVar(var_glojure_DOT_core_list) - tmp21 := lang.Apply(tmp20, []any{sym__DOT_UnixNano}) - tmp22 := checkDerefVar(var_glojure_DOT_core_list) - tmp23 := checkDerefVar(var_glojure_DOT_core_seq) - tmp24 := checkDerefVar(var_glojure_DOT_core_concat) - tmp25 := checkDerefVar(var_glojure_DOT_core_list) - tmp26 := lang.Apply(tmp25, []any{sym_time_DOT_Now}) - tmp27 := lang.Apply(tmp24, []any{tmp26}) - tmp28 := lang.Apply(tmp23, []any{tmp27}) - tmp29 := lang.Apply(tmp22, []any{tmp28}) - tmp30 := lang.Apply(tmp19, []any{tmp21, tmp29}) - tmp31 := lang.Apply(tmp18, []any{tmp30}) - tmp32 := lang.Apply(tmp17, []any{tmp31}) - tmp33 := checkDerefVar(var_glojure_DOT_core_list) - tmp34 := lang.Apply(tmp33, []any{sym_ret__1__auto__}) - tmp35 := checkDerefVar(var_glojure_DOT_core_list) - tmp36 := lang.Apply(tmp35, []any{v5}) - tmp37 := lang.Apply(tmp14, []any{tmp16, tmp32, tmp34, tmp36}) - tmp38 := lang.Apply(tmp13, []any{tmp37}) - tmp39 := lang.Apply(tmp11, []any{tmp12, tmp38}) - tmp40 := lang.Apply(tmp10, []any{tmp39}) - tmp41 := checkDerefVar(var_glojure_DOT_core_list) - tmp42 := checkDerefVar(var_glojure_DOT_core_seq) - tmp43 := checkDerefVar(var_glojure_DOT_core_concat) - tmp44 := checkDerefVar(var_glojure_DOT_core_list) - tmp45 := lang.Apply(tmp44, []any{sym_glojure_DOT_core_SLASH_prn}) - tmp46 := checkDerefVar(var_glojure_DOT_core_list) - tmp47 := checkDerefVar(var_glojure_DOT_core_seq) - tmp48 := checkDerefVar(var_glojure_DOT_core_concat) - tmp49 := checkDerefVar(var_glojure_DOT_core_list) - tmp50 := lang.Apply(tmp49, []any{sym_glojure_DOT_core_SLASH_str}) - tmp51 := checkDerefVar(var_glojure_DOT_core_list) - tmp52 := lang.Apply(tmp51, []any{"Elapsed time: "}) - tmp53 := checkDerefVar(var_glojure_DOT_core_list) - tmp54 := checkDerefVar(var_glojure_DOT_core_seq) - tmp55 := checkDerefVar(var_glojure_DOT_core_concat) - tmp56 := checkDerefVar(var_glojure_DOT_core_list) - tmp57 := lang.Apply(tmp56, []any{sym_glojure_DOT_core_SLASH__SLASH_}) - tmp58 := checkDerefVar(var_glojure_DOT_core_list) - tmp59 := checkDerefVar(var_glojure_DOT_core_seq) - tmp60 := checkDerefVar(var_glojure_DOT_core_concat) - tmp61 := checkDerefVar(var_glojure_DOT_core_list) - tmp62 := lang.Apply(tmp61, []any{sym_glojure_DOT_core_SLASH_double}) - tmp63 := checkDerefVar(var_glojure_DOT_core_list) - tmp64 := checkDerefVar(var_glojure_DOT_core_seq) - tmp65 := checkDerefVar(var_glojure_DOT_core_concat) - tmp66 := checkDerefVar(var_glojure_DOT_core_list) - tmp67 := lang.Apply(tmp66, []any{sym_glojure_DOT_core_SLASH__DASH_}) - tmp68 := checkDerefVar(var_glojure_DOT_core_list) - tmp69 := checkDerefVar(var_glojure_DOT_core_seq) - tmp70 := checkDerefVar(var_glojure_DOT_core_concat) - tmp71 := checkDerefVar(var_glojure_DOT_core_list) - tmp72 := lang.Apply(tmp71, []any{sym__DOT_UnixNano}) - tmp73 := checkDerefVar(var_glojure_DOT_core_list) - tmp74 := checkDerefVar(var_glojure_DOT_core_seq) - tmp75 := checkDerefVar(var_glojure_DOT_core_concat) - tmp76 := checkDerefVar(var_glojure_DOT_core_list) - tmp77 := lang.Apply(tmp76, []any{sym_time_DOT_Now}) - tmp78 := lang.Apply(tmp75, []any{tmp77}) - tmp79 := lang.Apply(tmp74, []any{tmp78}) - tmp80 := lang.Apply(tmp73, []any{tmp79}) - tmp81 := lang.Apply(tmp70, []any{tmp72, tmp80}) - tmp82 := lang.Apply(tmp69, []any{tmp81}) - tmp83 := lang.Apply(tmp68, []any{tmp82}) - tmp84 := checkDerefVar(var_glojure_DOT_core_list) - tmp85 := lang.Apply(tmp84, []any{sym_start__0__auto__}) - tmp86 := lang.Apply(tmp65, []any{tmp67, tmp83, tmp85}) - tmp87 := lang.Apply(tmp64, []any{tmp86}) - tmp88 := lang.Apply(tmp63, []any{tmp87}) - tmp89 := lang.Apply(tmp60, []any{tmp62, tmp88}) - tmp90 := lang.Apply(tmp59, []any{tmp89}) - tmp91 := lang.Apply(tmp58, []any{tmp90}) - tmp92 := checkDerefVar(var_glojure_DOT_core_list) - tmp93 := lang.Apply(tmp92, []any{float64(1e+06)}) - tmp94 := lang.Apply(tmp55, []any{tmp57, tmp91, tmp93}) - tmp95 := lang.Apply(tmp54, []any{tmp94}) - tmp96 := lang.Apply(tmp53, []any{tmp95}) - tmp97 := checkDerefVar(var_glojure_DOT_core_list) - tmp98 := lang.Apply(tmp97, []any{" msecs"}) - tmp99 := lang.Apply(tmp48, []any{tmp50, tmp52, tmp96, tmp98}) - tmp100 := lang.Apply(tmp47, []any{tmp99}) - tmp101 := lang.Apply(tmp46, []any{tmp100}) - tmp102 := lang.Apply(tmp43, []any{tmp45, tmp101}) - tmp103 := lang.Apply(tmp42, []any{tmp102}) - tmp104 := lang.Apply(tmp41, []any{tmp103}) - tmp105 := checkDerefVar(var_glojure_DOT_core_list) - tmp106 := lang.Apply(tmp105, []any{sym_ret__1__auto__}) - tmp107 := lang.Apply(tmp7, []any{tmp9, tmp40, tmp104, tmp106}) - tmp108 := lang.Apply(tmp6, []any{tmp107}) - return tmp108 + var tmp5 any + { // let + // let binding "walk" + var tmp6 lang.FnFunc + { // function walk + var v7 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v8 := args[0] + _ = v8 + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp10 := checkDerefVar(var_glojure_DOT_core_cons) + var tmp11 any + tmp12 := lang.Apply(v2, []any{v8}) + if lang.IsTruthy(tmp12) { + tmp13 := checkDerefVar(var_glojure_DOT_core_mapcat) + tmp14 := lang.Apply(v3, []any{v8}) + tmp15 := lang.Apply(tmp13, []any{v7, tmp14}) + tmp11 = tmp15 + } else { + } + tmp16 := lang.Apply(tmp10, []any{v8, tmp11}) + return tmp16 + }) + tmp10 := lang.Apply(lang.NewLazySeq, []any{tmp9}) + return tmp10 + }) + v7 = tmp6 + _ = v7 + } + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4965), kw_column, int(15), kw_end_DASH_line, int(4969), kw_end_DASH_column, int(53)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v9 any = tmp8 + _ = v9 + tmp10 := lang.Apply(v9, []any{v4}) + tmp5 = tmp10 + } // end let + return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_tree_DASH_seq = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_tree_DASH_seq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // to-array + // xml-seq { - tmp0 := sym_to_DASH_array.WithMeta(lang.NewMap(kw_tag, "[Ljava.lang.Object;", kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns an array of Objects containing the contents of coll, which\n can be any Collection. Maps to java.util.Collection.toArray().", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(337), kw_end_DASH_line, int(337))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_xml_DASH_seq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_root)), kw_doc, "A tree seq on the xml elements as per xml/parse", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4982), kw_end_DASH_line, int(4982))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4, _ := lang.FieldOrMethod(runtime.RT, "ToArray") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ToArray is not a function"))) - } - tmp5 := lang.Apply(tmp4, []any{v3}) - return tmp5 + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_tree_DASH_seq) + tmp4 := checkDerefVar(var_glojure_DOT_core_complement) + tmp5 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp6 := lang.Apply(tmp4, []any{tmp5}) + tmp7 := checkDerefVar(var_glojure_DOT_core_comp) + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := lang.Apply(tmp7, []any{tmp8, kw_content}) + tmp10 := lang.Apply(tmp3, []any{tmp6, tmp9, v2}) + return tmp10 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, "[Ljava.lang.Object;")).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_xml_DASH_seq = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_xml_DASH_seq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // to-array-2d + // emit-extend-type { - tmp0 := sym_to_DASH_array_DASH_2d.WithMeta(lang.NewMap(kw_tag, "[[Ljava.lang.Object;", kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a (potentially-ragged) 2-dimensional array of Objects\n containing the contents of coll, which can be any Collection of any\n Collection.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(4002), kw_end_DASH_line, int(4002))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] + tmp0 := sym_emit_DASH_extend_DASH_type.WithMeta(lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(175), kw_column, int(8), kw_end_DASH_line, int(175), kw_end_DASH_column, int(23), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_c, sym_specs)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 var tmp4 any { // let - // let binding "ret" - tmp5 := checkDerefVar(var_glojure_DOT_core_make_DASH_array) - tmp6 := reflect.TypeOf((*reflect.Type)(nil)).Elem() - tmp7, _ := lang.FieldOrMethod(tmp6, "forName") - if reflect.TypeOf(tmp7).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("forName is not a function"))) - } - tmp8 := lang.Apply(tmp7, []any{"[Ljava.lang.Object;"}) - tmp9, _ := lang.FieldOrMethod(v3, "size") - if reflect.TypeOf(tmp9).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("size is not a function"))) - } - tmp10 := lang.Apply(tmp9, []any{}) - tmp11 := lang.Apply(tmp5, []any{tmp8, tmp10}) - var v12 any = tmp11 - _ = v12 - var tmp13 any - { // let - // let binding "i" - var v14 any = int64(0) - _ = v14 - // let binding "xs" - tmp15 := checkDerefVar(var_glojure_DOT_core_seq) - tmp16 := lang.Apply(tmp15, []any{v3}) - var v17 any = tmp16 - _ = v17 - for { - var tmp18 any - if lang.IsTruthy(v17) { - tmp19 := checkDerefVar(var_glojure_DOT_core_aset) - tmp20 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) - tmp21 := checkDerefVar(var_glojure_DOT_core_first) - tmp22 := lang.Apply(tmp21, []any{v17}) - tmp23 := lang.Apply(tmp20, []any{tmp22}) - tmp24 := lang.Apply(tmp19, []any{v12, v14, tmp23}) - _ = tmp24 - tmp26 := checkDerefVar(var_glojure_DOT_core_inc) - tmp27 := lang.Apply(tmp26, []any{v14}) - var tmp25 any = tmp27 - tmp29 := checkDerefVar(var_glojure_DOT_core_next) - tmp30 := lang.Apply(tmp29, []any{v17}) - var tmp28 any = tmp30 - v14 = tmp25 - v17 = tmp28 - continue - } else { - } - tmp13 = tmp18 - break - } - } // end let - _ = tmp13 - tmp4 = v12 + // let binding "impls" + tmp5 := checkDerefVar(var_glojure_DOT_core_parse_DASH_impls) + tmp6 := lang.Apply(tmp5, []any{v3}) + var v7 any = tmp6 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_extend}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v2}) + tmp14 := checkDerefVar(var_glojure_DOT_core_mapcat) + tmp15 := checkDerefVar(var_glojure_DOT_core_partial) + tmp16 := checkDerefVar(var_glojure_DOT_core_emit_DASH_hinted_DASH_impl) + tmp17 := lang.Apply(tmp15, []any{tmp16, v2}) + tmp18 := lang.Apply(tmp14, []any{tmp17, v7}) + tmp19 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp18}) + tmp20 := lang.Apply(tmp8, []any{tmp19}) + tmp4 = tmp20 } // end let return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, "[[Ljava.lang.Object;")).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_emit_DASH_extend_DASH_type = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_emit_DASH_extend_DASH_type.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // trampoline + // extend-type { - tmp0 := sym_trampoline.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym__AMP_, sym_args)), kw_doc, "trampoline can be used to convert algorithms requiring mutual\n recursion without stack consumption. Calls f with supplied args, if\n any. If f returns a fn, calls that fn with no arguments, and\n continues to repeat, until the return value is not a fn, then\n returns that non-fn value. Note that if you want to return a fn as a\n final value, you must wrap it in some data structure and unpack it\n after trampoline returns.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(6293), kw_end_DASH_line, int(6293))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_extend_DASH_type.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_t, sym__AMP_, sym_specs)), kw_doc, "A macro that expands into an extend call. Useful when you are\n supplying the definitions explicitly inline, extend-type\n automatically creates the maps required by extend. Propagates the\n class as a type hint on the first argument of all fns.\n\n (extend-type MyType \n Countable\n (cnt [c] ...)\n Foo\n (bar [x y] ...)\n (baz ([x] ...) ([x y & zs] ...)))\n\n expands into:\n\n (extend MyType\n Countable\n {:cnt (fn [c] ...)}\n Foo\n {:baz (fn ([x] ...) ([x y & zs] ...))\n :bar (fn [x y] ...)})", kw_file, "glojure/core_deftype.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(11), kw_line, int(180), kw_end_DASH_line, int(180))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 1: - v3 := args[0] - _ = v3 - recur_loop_1073: - var tmp4 any - { // let - // let binding "ret" - tmp5 := lang.Apply(v3, nil) - var v6 any = tmp5 - _ = v6 - var tmp7 any - tmp8 := checkDerefVar(var_glojure_DOT_core_fn_QMARK_) - tmp9 := lang.Apply(tmp8, []any{v6}) - if lang.IsTruthy(tmp9) { - var tmp10 any = v6 - v3 = tmp10 - goto recur_loop_1073 - } else { - tmp7 = v6 - } - tmp4 = tmp7 - } // end let - return tmp4 default: - checkArity(args, 1) - v3 := args[0] - _ = v3 - var v4 any = lang.NewList(args[1:]...) - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_trampoline) - var tmp6 lang.FnFunc - tmp6 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - tmp7 := checkDerefVar(var_glojure_DOT_core_apply) - tmp8 := lang.Apply(tmp7, []any{v3, v4}) - return tmp8 - }) - tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6309), kw_column, int(18), kw_end_DASH_line, int(6309), kw_end_DASH_column, int(32)) - tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp9 := lang.Apply(tmp5, []any{tmp8}) - return tmp9 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // transduce - { - tmp0 := sym_transduce.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xform, sym_f, sym_coll), lang.NewVector(sym_xform, sym_f, sym_init, sym_coll)), kw_doc, "reduce with a transformation of f (xf). If init is not\n supplied, (f) will be called to produce it. f should be a reducing\n step function that accepts both 1 and 2 arguments, if it accepts\n only 2 you can add the arity-1 with 'completing'. Returns the result\n of applying (the transformed) xf to init and the first item in coll,\n then applying xf to that result and the 2nd item, etc. If coll\n contains no items, returns init and f is not called. Note that\n certain transforms may inject or skip items.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(6905), kw_end_DASH_line, int(6905))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6 := checkDerefVar(var_glojure_DOT_core_transduce) - tmp7 := lang.Apply(v4, nil) - tmp8 := lang.Apply(tmp6, []any{v3, v4, tmp7, v5}) - return tmp8 - case 4: - v3 := args[0] + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + v4 := args[2] _ = v4 - v5 := args[2] + var v5 any = lang.NewList(args[3:]...) _ = v5 - v6 := args[3] - _ = v6 - var tmp7 any - { // let - // let binding "f" - tmp8 := lang.Apply(v3, []any{v4}) - var v9 any = tmp8 - _ = v9 - // let binding "ret" - var tmp10 any - tmp11 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp12 := reflect.TypeOf((*lang.IReduceInit)(nil)).Elem() - tmp13 := lang.Apply(tmp11, []any{tmp12, v6}) - if lang.IsTruthy(tmp13) { - tmp14, _ := lang.FieldOrMethod(v6, "ReduceInit") - if reflect.TypeOf(tmp14).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) - } - tmp15 := lang.Apply(tmp14, []any{v9, v5}) - tmp10 = tmp15 - } else { - tmp16 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_coll_DASH_reduce) - tmp17 := lang.Apply(tmp16, []any{v6, v9, v5}) - tmp10 = tmp17 - } - var v18 any = tmp10 - _ = v18 - tmp19 := lang.Apply(v9, []any{v18}) - tmp7 = tmp19 - } // end let + tmp6 := checkDerefVar(var_glojure_DOT_core_emit_DASH_extend_DASH_type) + tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 - default: - checkArity(args, -1) - panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_extend_DASH_type = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_extend_DASH_type.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // transient + // file-seq { - tmp0 := sym_transient.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a new, transient version of the collection, in constant time.\n\n Transients support a parallel set of 'changing' operations, with similar names\n followed by ! - assoc!, conj! etc. These do the same things as their persistent\n counterparts except the return values are themselves transient.\n\n Note in particular that transients are not designed to be bashed in-place. You\n must capture and use the return value in the next call. In this way, they support\n the same code structure as the functional persistent code they replace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(3335), kw_end_DASH_line, int(3335))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_file_DASH_seq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_dir)), kw_doc, "A tree seq on java.io.Files", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(4972), kw_end_DASH_line, int(4972))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4, ok := lang.FieldOrMethod(v3, "AsTransient") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "AsTransient"))) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_tree_DASH_seq) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v5 := args[0] + _ = v5 + tmp6, _ := lang.FieldOrMethod(v5, "isDirectory") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("isDirectory is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{}) + return tmp7 + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4978), kw_column, int(6), kw_end_DASH_line, int(4978), kw_end_DASH_column, int(47)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) } - var tmp5 any - switch reflect.TypeOf(tmp4).Kind() { - case reflect.Func: - tmp5 = lang.Apply(tmp4, nil) - default: - tmp5 = tmp4 + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v8 := args[0] + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_seq) + tmp10, _ := lang.FieldOrMethod(v8, "listFiles") + if reflect.TypeOf(tmp10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("listFiles is not a function"))) + } + tmp11 := lang.Apply(tmp10, []any{}) + tmp12 := lang.Apply(tmp9, []any{tmp11}) + return tmp12 + }) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4979), kw_column, int(6), kw_end_DASH_line, int(4979), kw_end_DASH_column, int(51)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) } - return tmp5 + tmp10 := lang.Apply(tmp3, []any{tmp6, tmp9, v2}) + return tmp10 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_file_DASH_seq = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_file_DASH_seq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // tree-seq + // flatten { - tmp0 := sym_tree_DASH_seq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_branch_QMARK_, sym_children, sym_root)), kw_doc, "Returns a lazy sequence of the nodes in a tree, via a depth-first walk.\n branch? must be a fn of one arg that returns true if passed a node\n that can have children (but may not). children must be a fn of one\n arg that returns a sequence of the children. Will only be called on\n nodes for which branch? returns true. Root is the root node of the\n tree.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(4955), kw_end_DASH_line, int(4955))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 3) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var tmp6 any - { // let - // let binding "walk" - var tmp7 lang.FnFunc - { // function walk - var v8 lang.FnFunc - tmp7 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v9 := args[0] - _ = v9 - var tmp10 lang.FnFunc - tmp10 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - tmp11 := checkDerefVar(var_glojure_DOT_core_cons) - var tmp12 any - tmp13 := lang.Apply(v3, []any{v9}) - if lang.IsTruthy(tmp13) { - tmp14 := checkDerefVar(var_glojure_DOT_core_mapcat) - tmp15 := lang.Apply(v4, []any{v9}) - tmp16 := lang.Apply(tmp14, []any{v8, tmp15}) - tmp12 = tmp16 - } else { - } - tmp17 := lang.Apply(tmp11, []any{v9, tmp12}) - return tmp17 - }) - tmp11 := lang.Apply(lang.NewLazySeq, []any{tmp10}) - return tmp11 - }) - v8 = tmp7 - _ = v8 - } - tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4965), kw_column, int(15), kw_end_DASH_line, int(4969), kw_end_DASH_column, int(53)) - tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v10 any = tmp9 - _ = v10 - tmp11 := lang.Apply(v10, []any{v5}) - tmp6 = tmp11 - } // end let - return tmp6 + tmp0 := sym_flatten.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Takes any nested combination of sequential things (lists, vectors,\n etc.) and returns their contents as a single, flat lazy sequence.\n (flatten nil) returns an empty sequence.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(7118), kw_end_DASH_line, int(7118))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_filter) + tmp4 := checkDerefVar(var_glojure_DOT_core_complement) + tmp5 := checkDerefVar(var_glojure_DOT_core_sequential_QMARK_) + tmp6 := lang.Apply(tmp4, []any{tmp5}) + tmp7 := checkDerefVar(var_glojure_DOT_core_rest) + tmp8 := checkDerefVar(var_glojure_DOT_core_tree_DASH_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_sequential_QMARK_) + tmp10 := checkDerefVar(var_glojure_DOT_core_seq) + tmp11 := lang.Apply(tmp8, []any{tmp9, tmp10, v2}) + tmp12 := lang.Apply(tmp7, []any{tmp11}) + tmp13 := lang.Apply(tmp3, []any{tmp6, tmp12}) + return tmp13 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_flatten = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_flatten.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // true? + // compile { - tmp1 := reflect.TypeOf(false) - tmp0 := sym_true_QMARK_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x is the value true, false otherwise.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(511), kw_end_DASH_line, int(511))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_compile.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_lib)), kw_doc, "Compiles the namespace named by the symbol lib into a set of\n classfiles. The source for the lib must be in a proper\n classpath-relative directory. The output files will go into the\n directory specified by *compile-path*, and that directory too must\n be in the classpath.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(6114), kw_end_DASH_line, int(6114))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5 := lang.Apply(lang.Identical, []any{v4, true}) - return tmp5 + v2 := args[0] + _ = v2 + var tmp3 any + { // let + tmp4 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp5 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp6 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_compile_DASH_files_STAR_) + tmp7 := lang.Apply(tmp5, []any{tmp6, true}) + tmp8 := lang.Apply(tmp4, []any{tmp7}) + _ = tmp8 + var tmp9 any + func() { + defer func() { + tmp10 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp11 := lang.Apply(tmp10, nil) + _ = tmp11 + }() + tmp12 := checkDerefVar(var_glojure_DOT_core_load_DASH_one) + tmp13 := lang.Apply(tmp12, []any{v2, true, true}) + tmp9 = tmp13 + }() + tmp3 = tmp9 + } // end let + _ = tmp3 + return v2 }) - tmp4 := reflect.TypeOf(false) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_compile = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_compile.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // type + // derive { - tmp0 := sym_type.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns the :type metadata of x, or its Class if none", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3467), kw_end_DASH_line, int(3467))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 any - { // let - // let binding "or__0__auto__" - tmp5 := checkDerefVar(var_glojure_DOT_core_get) - tmp6 := checkDerefVar(var_glojure_DOT_core_meta) - tmp7 := lang.Apply(tmp6, []any{v3}) - tmp8 := lang.Apply(tmp5, []any{tmp7, kw_type}) - var v9 any = tmp8 - _ = v9 - var tmp10 any - if lang.IsTruthy(v9) { - tmp10 = v9 - } else { - tmp11 := checkDerefVar(var_glojure_DOT_core_class) - tmp12 := lang.Apply(tmp11, []any{v3}) - tmp10 = tmp12 - } - tmp4 = tmp10 - } // end let - return tmp4 + tmp0 := sym_derive.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_tag, sym_parent), lang.NewVector(sym_h, sym_tag, sym_parent)), kw_doc, "Establishes a parent/child relationship between parent and\n tag. Parent must be a namespace-qualified symbol or keyword and\n child can be either a namespace-qualified symbol or keyword or a\n class. h must be a hierarchy obtained from make-hierarchy, if not\n supplied defaults to, and modifies, the global hierarchy.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(5605), kw_end_DASH_line, int(5605))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_alter_DASH_var_DASH_root) + tmp5 := lang.InternVarName(sym_glojure_DOT_core, sym_global_DASH_hierarchy) + tmp6 := checkDerefVar(var_glojure_DOT_core_derive) + tmp7 := lang.Apply(tmp4, []any{tmp5, tmp6, v2, v3}) + _ = tmp7 + return nil + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + { // let + // let binding "tp" + tmp6 := lang.Apply(kw_parents, []any{v2}) + var v7 any = tmp6 + _ = v7 + // let binding "td" + tmp8 := lang.Apply(kw_descendants, []any{v2}) + var v9 any = tmp8 + _ = v9 + // let binding "ta" + tmp10 := lang.Apply(kw_ancestors, []any{v2}) + var v11 any = tmp10 + _ = v11 + // let binding "tf" + var tmp12 lang.FnFunc + tmp12 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 5) + v13 := args[0] + _ = v13 + v14 := args[1] + _ = v14 + v15 := args[2] + _ = v15 + v16 := args[3] + _ = v16 + v17 := args[4] + _ = v17 + tmp18 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp19 lang.FnFunc + tmp19 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v20 := args[0] + _ = v20 + v21 := args[1] + _ = v21 + tmp22 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp23 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp24 := checkDerefVar(var_glojure_DOT_core_conj) + tmp25 := checkDerefVar(var_glojure_DOT_core_get) + tmp26 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp27 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5628), kw_column, int(61), kw_end_DASH_line, int(5628), kw_end_DASH_column, int(63)) + tmp28, err := lang.WithMeta(tmp26, tmp27.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp29 := lang.Apply(tmp25, []any{v17, v21, tmp28}) + tmp30 := checkDerefVar(var_glojure_DOT_core_cons) + tmp31 := lang.Apply(v17, []any{v16}) + tmp32 := lang.Apply(tmp30, []any{v16, tmp31}) + tmp33 := lang.Apply(tmp23, []any{tmp24, tmp29, tmp32}) + tmp34 := lang.Apply(tmp22, []any{v20, v21, tmp33}) + return tmp34 + }) + tmp20 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5626), kw_column, int(24), kw_end_DASH_line, int(5628), kw_end_DASH_column, int(98)) + tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp22 := checkDerefVar(var_glojure_DOT_core_cons) + tmp23 := lang.Apply(v15, []any{v14}) + tmp24 := lang.Apply(tmp22, []any{v14, tmp23}) + tmp25 := lang.Apply(tmp18, []any{tmp21, v13, tmp24}) + return tmp25 + }) + tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5625), kw_column, int(13), kw_end_DASH_line, int(5629), kw_end_DASH_column, int(56)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v15 any = tmp14 + _ = v15 + var tmp16 any + { // let + // let binding "or__0__auto__" + var tmp17 any + tmp18 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp19 := lang.Apply(v7, []any{v3}) + tmp20 := lang.Apply(tmp18, []any{tmp19, v4}) + if lang.IsTruthy(tmp20) { + } else { + var tmp21 any + tmp22 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp23 := lang.Apply(v11, []any{v3}) + tmp24 := lang.Apply(tmp22, []any{tmp23, v4}) + if lang.IsTruthy(tmp24) { + tmp25 := checkDerefVar(var_glojure_DOT_core_print_DASH_str) + tmp26 := lang.Apply(tmp25, []any{v3, "already has", v4, "as ancestor"}) + tmp27 := lang.Apply(lang.NewError, []any{tmp26}) + panic(tmp27) + } else { + } + _ = tmp21 + var tmp28 any + tmp29 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp30 := lang.Apply(v11, []any{v4}) + tmp31 := lang.Apply(tmp29, []any{tmp30, v3}) + if lang.IsTruthy(tmp31) { + tmp32 := checkDerefVar(var_glojure_DOT_core_print_DASH_str) + tmp33 := lang.Apply(tmp32, []any{"Cyclic derivation:", v4, "has", v3, "as ancestor"}) + tmp34 := lang.Apply(lang.NewError, []any{tmp33}) + panic(tmp34) + } else { + } + _ = tmp28 + tmp35 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp36 := lang.Apply(kw_parents, []any{v2}) + tmp37 := checkDerefVar(var_glojure_DOT_core_conj) + tmp38 := checkDerefVar(var_glojure_DOT_core_get) + tmp39 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp40 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5636), kw_column, int(61), kw_end_DASH_line, int(5636), kw_end_DASH_column, int(63)) + tmp41, err := lang.WithMeta(tmp39, tmp40.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp42 := lang.Apply(tmp38, []any{v7, v3, tmp41}) + tmp43 := lang.Apply(tmp37, []any{tmp42, v4}) + tmp44 := lang.Apply(tmp35, []any{tmp36, v3, tmp43}) + tmp45 := lang.Apply(kw_ancestors, []any{v2}) + tmp46 := lang.Apply(v15, []any{tmp45, v3, v9, v4, v11}) + tmp47 := lang.Apply(kw_descendants, []any{v2}) + tmp48 := lang.Apply(v15, []any{tmp47, v4, v11, v3, v9}) + tmp49 := lang.NewMap(kw_parents, tmp44, kw_ancestors, tmp46, kw_descendants, tmp48) + tmp50 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5636), kw_column, int(9), kw_end_DASH_line, int(5638), kw_end_DASH_column, int(61)) + tmp51, err := lang.WithMeta(tmp49, tmp50.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp17 = tmp51 + } + var v52 any = tmp17 + _ = v52 + var tmp53 any + if lang.IsTruthy(v52) { + tmp53 = v52 + } else { + tmp53 = v2 + } + tmp16 = tmp53 + } // end let + tmp5 = tmp16 + } // end let + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_derive = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_derive.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // unchecked-add + // underive { + tmp0 := sym_underive.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_tag, sym_parent), lang.NewVector(sym_h, sym_tag, sym_parent)), kw_doc, "Removes a parent/child relationship between parent and\n tag. h must be a hierarchy obtained from make-hierarchy, if not\n supplied defaults to, and modifies, the global hierarchy.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(5643), kw_end_DASH_line, int(5643))).(*lang.Symbol) var tmp1 lang.FnFunc - { // function unchecked-add__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + tmp4 := checkDerefVar(var_glojure_DOT_core_alter_DASH_var_DASH_root) + tmp5 := lang.InternVarName(sym_glojure_DOT_core, sym_global_DASH_hierarchy) + tmp6 := checkDerefVar(var_glojure_DOT_core_underive) + tmp7 := lang.Apply(tmp4, []any{tmp5, tmp6, v2, v3}) + _ = tmp7 + return nil + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_seq) - tmp6 := checkDerefVar(var_glojure_DOT_core_concat) - tmp7 := checkDerefVar(var_glojure_DOT_core_list) - tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) - tmp9 := checkDerefVar(var_glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp11 := checkDerefVar(var_glojure_DOT_core_list) - tmp12 := checkDerefVar(var_glojure_DOT_core_seq) - tmp13 := checkDerefVar(var_glojure_DOT_core_concat) - tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_UncheckedAdd}) - tmp16 := checkDerefVar(var_glojure_DOT_core_list) - tmp17 := lang.Apply(tmp16, []any{v3}) - tmp18 := checkDerefVar(var_glojure_DOT_core_list) - tmp19 := lang.Apply(tmp18, []any{v4}) - tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) - tmp21 := lang.Apply(tmp12, []any{tmp20}) - tmp22 := lang.Apply(tmp11, []any{tmp21}) - tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) - tmp24 := lang.Apply(tmp5, []any{tmp23}) - return tmp24 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := sym_unchecked_DASH_add.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Returns the sum of x and y, both long.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(1203), kw_end_DASH_line, int(1203))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedAdd") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedAdd is not a function"))) + var tmp5 any + { // let + // let binding "parentMap" + tmp6 := lang.Apply(kw_parents, []any{v2}) + var v7 any = tmp6 + _ = v7 + // let binding "childsParents" + var tmp8 any + tmp9 := lang.Apply(v7, []any{v3}) + if lang.IsTruthy(tmp9) { + tmp10 := checkDerefVar(var_glojure_DOT_core_disj) + tmp11 := lang.Apply(v7, []any{v3}) + tmp12 := lang.Apply(tmp10, []any{tmp11, v4}) + tmp8 = tmp12 + } else { + tmp13 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5652), kw_column, int(36), kw_end_DASH_line, int(5652), kw_end_DASH_column, int(38)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp8 = tmp15 + } + var v16 any = tmp8 + _ = v16 + // let binding "newParents" + var tmp17 any + tmp18 := checkDerefVar(var_glojure_DOT_core_not_DASH_empty) + tmp19 := lang.Apply(tmp18, []any{v16}) + if lang.IsTruthy(tmp19) { + tmp20 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp21 := lang.Apply(tmp20, []any{v7, v3, v16}) + tmp17 = tmp21 + } else { + tmp22 := checkDerefVar(var_glojure_DOT_core_dissoc) + tmp23 := lang.Apply(tmp22, []any{v7, v3}) + tmp17 = tmp23 + } + var v24 any = tmp17 + _ = v24 + // let binding "deriv-seq" + tmp25 := checkDerefVar(var_glojure_DOT_core_flatten) + tmp26 := checkDerefVar(var_glojure_DOT_core_map) + var tmp27 lang.FnFunc + tmp27 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v28 := args[0] + _ = v28 + tmp29 := checkDerefVar(var_glojure_DOT_core_cons) + tmp30 := checkDerefVar(var_glojure_DOT_core_key) + tmp31 := lang.Apply(tmp30, []any{v28}) + tmp32 := checkDerefVar(var_glojure_DOT_core_interpose) + tmp33 := checkDerefVar(var_glojure_DOT_core_key) + tmp34 := lang.Apply(tmp33, []any{v28}) + tmp35 := checkDerefVar(var_glojure_DOT_core_val) + tmp36 := lang.Apply(tmp35, []any{v28}) + tmp37 := lang.Apply(tmp32, []any{tmp34, tmp36}) + tmp38 := lang.Apply(tmp29, []any{tmp31, tmp37}) + return tmp38 + }) + tmp28 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5656), kw_column, int(28), kw_end_DASH_line, int(5656), kw_end_DASH_column, int(70)) + tmp29, err := lang.WithMeta(tmp27, tmp28.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp30 := checkDerefVar(var_glojure_DOT_core_seq) + tmp31 := lang.Apply(tmp30, []any{v24}) + tmp32 := lang.Apply(tmp26, []any{tmp29, tmp31}) + tmp33 := lang.Apply(tmp25, []any{tmp32}) + var v34 any = tmp33 + _ = v34 + var tmp35 any + tmp36 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp37 := lang.Apply(v7, []any{v3}) + tmp38 := lang.Apply(tmp36, []any{tmp37, v4}) + if lang.IsTruthy(tmp38) { + tmp39 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp40 lang.FnFunc + tmp40 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v41 := args[0] + _ = v41 + v42 := args[1] + _ = v42 + tmp43 := checkDerefVar(var_glojure_DOT_core_apply) + tmp44 := checkDerefVar(var_glojure_DOT_core_derive) + tmp45 := lang.Apply(tmp43, []any{tmp44, v41, v42}) + return tmp45 + }) + tmp41 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5659), kw_column, int(11), kw_end_DASH_line, int(5659), kw_end_DASH_column, int(31)) + tmp42, err := lang.WithMeta(tmp40, tmp41.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp43 := checkDerefVar(var_glojure_DOT_core_make_DASH_hierarchy) + tmp44 := lang.Apply(tmp43, nil) + tmp45 := checkDerefVar(var_glojure_DOT_core_partition) + tmp46 := lang.Apply(tmp45, []any{int64(2), v34}) + tmp47 := lang.Apply(tmp39, []any{tmp42, tmp44, tmp46}) + tmp35 = tmp47 + } else { + tmp35 = v2 + } + tmp5 = tmp35 + } // end let + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_underive = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_underive.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // unchecked-add-int + // filterv { + tmp0 := sym_filterv.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns a vector of the items in coll for which\n (pred item) returns logical true. pred must be free of side-effects.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.4", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(6961), kw_end_DASH_line, int(6961))).(*lang.Symbol) var tmp1 lang.FnFunc - { // function unchecked-add-int__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp5 := checkDerefVar(var_glojure_DOT_core_reduce) + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_seq) - tmp6 := checkDerefVar(var_glojure_DOT_core_concat) - tmp7 := checkDerefVar(var_glojure_DOT_core_list) - tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) - tmp9 := checkDerefVar(var_glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp11 := checkDerefVar(var_glojure_DOT_core_list) - tmp12 := checkDerefVar(var_glojure_DOT_core_seq) - tmp13 := checkDerefVar(var_glojure_DOT_core_concat) - tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_add}) - tmp16 := checkDerefVar(var_glojure_DOT_core_list) - tmp17 := lang.Apply(tmp16, []any{v3}) - tmp18 := checkDerefVar(var_glojure_DOT_core_list) - tmp19 := lang.Apply(tmp18, []any{v4}) - tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) - tmp21 := lang.Apply(tmp12, []any{tmp20}) - tmp22 := lang.Apply(tmp11, []any{tmp21}) - tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) - tmp24 := lang.Apply(tmp5, []any{tmp23}) - return tmp24 + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + var tmp9 any + tmp10 := lang.Apply(v2, []any{v8}) + if lang.IsTruthy(tmp10) { + tmp11 := checkDerefVar(var_glojure_DOT_core_conj_BANG_) + tmp12 := lang.Apply(tmp11, []any{v7, v8}) + tmp9 = tmp12 + } else { + tmp9 = v7 + } + return tmp9 }) - v2 = tmp1 - _ = v2 - } - tmp0 := sym_unchecked_DASH_add_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Returns the sum of x and y, both int.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(7), kw_line, int(1196), kw_end_DASH_line, int(1196))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_add") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_add is not a function"))) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6967), kw_column, int(15), kw_end_DASH_line, int(6967), kw_end_DASH_column, int(52)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // unchecked-byte - { - var tmp1 lang.FnFunc - { // function unchecked-byte__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_seq) - tmp5 := checkDerefVar(var_glojure_DOT_core_concat) - tmp6 := checkDerefVar(var_glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) - tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := checkDerefVar(var_glojure_DOT_core_seq) - tmp12 := checkDerefVar(var_glojure_DOT_core_concat) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedByteCast}) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{v3}) - tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) - tmp18 := lang.Apply(tmp11, []any{tmp17}) - tmp19 := lang.Apply(tmp10, []any{tmp18}) - tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) - tmp21 := lang.Apply(tmp4, []any{tmp20}) - return tmp21 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := sym_unchecked_DASH_byte.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to byte. Subject to rounding or truncation.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(3517), kw_end_DASH_line, int(3517))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5 := lang.Apply(lang.UncheckedByteCast, []any{v4}) - return tmp5 + tmp9 := checkDerefVar(var_glojure_DOT_core_transient) + tmp10 := lang.NewVector() + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6968), kw_column, int(26), kw_end_DASH_line, int(6968), kw_end_DASH_column, int(27)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := lang.Apply(tmp9, []any{tmp12}) + tmp14 := lang.Apply(tmp5, []any{tmp8, tmp13, v3}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_filterv = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_filterv.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // unchecked-char + // flush { + tmp0 := sym_flush.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Flushes the output stream that is the current value of\n *out*", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3706), kw_end_DASH_line, int(3706))).(*lang.Symbol) var tmp1 lang.FnFunc - { // function unchecked-char__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_seq) - tmp5 := checkDerefVar(var_glojure_DOT_core_concat) - tmp6 := checkDerefVar(var_glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) - tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := checkDerefVar(var_glojure_DOT_core_seq) - tmp12 := checkDerefVar(var_glojure_DOT_core_concat) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedCharCast}) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{v3}) - tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) - tmp18 := lang.Apply(tmp11, []any{tmp17}) - tmp19 := lang.Apply(tmp10, []any{tmp18}) - tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) - tmp21 := lang.Apply(tmp4, []any{tmp20}) - return tmp21 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := sym_unchecked_DASH_char.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to char. Subject to rounding or truncation.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(3529), kw_end_DASH_line, int(3529))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(runtime.RT, "UncheckedCharCast") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedCharCast is not a function"))) + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp2 := checkDerefVar(var_glojure_DOT_core__STAR_out_STAR_) + tmp3, _ := lang.FieldOrMethod(tmp2, "Sync") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Sync is not a function"))) } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 + tmp4 := lang.Apply(tmp3, []any{}) + _ = tmp4 + return nil }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_flush = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_flush.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // unchecked-dec + // frequencies { + tmp0 := sym_frequencies.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a map from distinct items in coll to the number of times\n they appear.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(7185), kw_end_DASH_line, int(7185))).(*lang.Symbol) var tmp1 lang.FnFunc - { // function unchecked-dec__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_seq) - tmp5 := checkDerefVar(var_glojure_DOT_core_concat) - tmp6 := checkDerefVar(var_glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) - tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := checkDerefVar(var_glojure_DOT_core_seq) - tmp12 := checkDerefVar(var_glojure_DOT_core_concat) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedDec}) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{v3}) - tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) - tmp18 := lang.Apply(tmp11, []any{tmp17}) - tmp19 := lang.Apply(tmp10, []any{tmp18}) - tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) - tmp21 := lang.Apply(tmp4, []any{tmp20}) - return tmp21 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := sym_unchecked_DASH_dec.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns a number one less than x, a long.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(1175), kw_end_DASH_line, int(1175))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedDec") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedDec is not a function"))) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp4 := checkDerefVar(var_glojure_DOT_core_reduce) + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_assoc_BANG_) + tmp9 := checkDerefVar(var_glojure_DOT_core_inc) + tmp10 := checkDerefVar(var_glojure_DOT_core_get) + tmp11 := lang.Apply(tmp10, []any{v6, v7, int64(0)}) + tmp12 := lang.Apply(tmp9, []any{tmp11}) + tmp13 := lang.Apply(tmp8, []any{v6, v7, tmp12}) + return tmp13 + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7192), kw_column, int(12), kw_end_DASH_line, int(7193), kw_end_DASH_column, int(54)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 + tmp8 := checkDerefVar(var_glojure_DOT_core_transient) + tmp9 := lang.NewMap() + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7194), kw_column, int(23), kw_end_DASH_line, int(7194), kw_end_DASH_column, int(24)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp12 := lang.Apply(tmp8, []any{tmp11}) + tmp13 := lang.Apply(tmp4, []any{tmp7, tmp12, v2}) + tmp14 := lang.Apply(tmp3, []any{tmp13}) + return tmp14 }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_frequencies = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_frequencies.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // unchecked-dec-int + // group-by { + tmp0 := sym_group_DASH_by.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_coll)), kw_doc, "Returns a map of the elements of coll keyed by the result of\n f on each element. The value at each key will be a vector of the\n corresponding elements, in the order they appeared in coll.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(7128), kw_end_DASH_line, int(7128))).(*lang.Symbol) var tmp1 lang.FnFunc - { // function unchecked-dec-int__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_seq) - tmp5 := checkDerefVar(var_glojure_DOT_core_concat) - tmp6 := checkDerefVar(var_glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) - tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := checkDerefVar(var_glojure_DOT_core_seq) - tmp12 := checkDerefVar(var_glojure_DOT_core_concat) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_dec}) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{v3}) - tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) - tmp18 := lang.Apply(tmp11, []any{tmp17}) - tmp19 := lang.Apply(tmp10, []any{tmp18}) - tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) - tmp21 := lang.Apply(tmp4, []any{tmp20}) - return tmp21 - }) - v2 = tmp1 + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] _ = v2 - } - tmp0 := sym_unchecked_DASH_dec_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns a number one less than x, an int.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(7), kw_line, int(1168), kw_end_DASH_line, int(1168))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_dec") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_dec is not a function"))) + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp5 := checkDerefVar(var_glojure_DOT_core_reduce) + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + var tmp9 any + { // let + // let binding "k" + tmp10 := lang.Apply(v2, []any{v8}) + var v11 any = tmp10 + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_assoc_BANG_) + tmp13 := checkDerefVar(var_glojure_DOT_core_conj) + tmp14 := checkDerefVar(var_glojure_DOT_core_get) + tmp15 := lang.NewVector() + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7139), kw_column, int(40), kw_end_DASH_line, int(7139), kw_end_DASH_column, int(41)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp18 := lang.Apply(tmp14, []any{v7, v11, tmp17}) + tmp19 := lang.Apply(tmp13, []any{tmp18, v8}) + tmp20 := lang.Apply(tmp12, []any{v7, v11, tmp19}) + tmp9 = tmp20 + } // end let + return tmp9 + }) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7137), kw_column, int(5), kw_end_DASH_line, int(7139), kw_end_DASH_column, int(48)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 + tmp9 := checkDerefVar(var_glojure_DOT_core_transient) + tmp10 := lang.NewMap() + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7140), kw_column, int(16), kw_end_DASH_line, int(7140), kw_end_DASH_column, int(17)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := lang.Apply(tmp9, []any{tmp12}) + tmp14 := lang.Apply(tmp5, []any{tmp8, tmp13, v3}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_group_DASH_by = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_group_DASH_by.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // unchecked-divide-int + // into { + tmp0 := sym_into.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_to), lang.NewVector(sym_to, sym_from), lang.NewVector(sym_to, sym_xform, sym_from)), kw_doc, "Returns a new coll consisting of to with all of the items of\n from conjoined. A transducer may be supplied.\n (into x) returns x. (into) returns [].", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(6922), kw_end_DASH_line, int(6922))).(*lang.Symbol) var tmp1 lang.FnFunc - { // function unchecked-divide-int__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp2 := lang.NewVector() + tmp3 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6928), kw_column, int(7), kw_end_DASH_line, int(6928), kw_end_DASH_column, int(8)) + tmp4, err := lang.WithMeta(tmp2, tmp3.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp4 + case 1: + v2 := args[0] + _ = v2 + return v2 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp6 := reflect.TypeOf((*lang.IEditableCollection)(nil)).Elem() + tmp7 := lang.Apply(tmp5, []any{tmp6, v2}) + if lang.IsTruthy(tmp7) { + tmp8 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp9 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp10 := checkDerefVar(var_glojure_DOT_core_reduce) + tmp11 := checkDerefVar(var_glojure_DOT_core_conj_BANG_) + tmp12 := checkDerefVar(var_glojure_DOT_core_transient) + tmp13 := lang.Apply(tmp12, []any{v2}) + tmp14 := lang.Apply(tmp10, []any{tmp11, tmp13, v3}) + tmp15 := lang.Apply(tmp9, []any{tmp14}) + tmp16 := checkDerefVar(var_glojure_DOT_core_meta) + tmp17 := lang.Apply(tmp16, []any{v2}) + tmp18 := lang.Apply(tmp8, []any{tmp15, tmp17}) + tmp4 = tmp18 + } else { + tmp19 := checkDerefVar(var_glojure_DOT_core_reduce) + tmp20 := checkDerefVar(var_glojure_DOT_core_conj) + tmp21 := lang.Apply(tmp19, []any{tmp20, v2, v3}) + tmp4 = tmp21 + } + return tmp4 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_seq) - tmp6 := checkDerefVar(var_glojure_DOT_core_concat) - tmp7 := checkDerefVar(var_glojure_DOT_core_list) - tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) - tmp9 := checkDerefVar(var_glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp11 := checkDerefVar(var_glojure_DOT_core_list) - tmp12 := checkDerefVar(var_glojure_DOT_core_seq) - tmp13 := checkDerefVar(var_glojure_DOT_core_concat) - tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_UncheckedIntDivide}) - tmp16 := checkDerefVar(var_glojure_DOT_core_list) - tmp17 := lang.Apply(tmp16, []any{v3}) - tmp18 := checkDerefVar(var_glojure_DOT_core_list) - tmp19 := lang.Apply(tmp18, []any{v4}) - tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) - tmp21 := lang.Apply(tmp12, []any{tmp20}) - tmp22 := lang.Apply(tmp11, []any{tmp21}) - tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) - tmp24 := lang.Apply(tmp5, []any{tmp23}) - return tmp24 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := sym_unchecked_DASH_divide_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Returns the division of x by y, both int.\n Note - uses a primitive operator subject to truncation.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(26), kw_column, int(7), kw_line, int(1238), kw_end_DASH_line, int(1238))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedIntDivide") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedIntDivide is not a function"))) + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp7 := reflect.TypeOf((*lang.IEditableCollection)(nil)).Elem() + tmp8 := lang.Apply(tmp6, []any{tmp7, v2}) + if lang.IsTruthy(tmp8) { + var tmp9 any + { // let + // let binding "tm" + tmp10 := checkDerefVar(var_glojure_DOT_core_meta) + tmp11 := lang.Apply(tmp10, []any{v2}) + var v12 any = tmp11 + _ = v12 + // let binding "rf" + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v14 := args[0] + _ = v14 + tmp15 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp16 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp17 := lang.Apply(tmp16, []any{v14}) + tmp18 := lang.Apply(tmp15, []any{tmp17, v12}) + return tmp18 + case 2: + v14 := args[0] + _ = v14 + v15 := args[1] + _ = v15 + tmp16 := checkDerefVar(var_glojure_DOT_core_conj_BANG_) + tmp17 := lang.Apply(tmp16, []any{v14, v15}) + return tmp17 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6937), kw_column, int(17), kw_end_DASH_line, int(6939), kw_end_DASH_column, int(44)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v16 any = tmp15 + _ = v16 + tmp17 := checkDerefVar(var_glojure_DOT_core_transduce) + tmp18 := checkDerefVar(var_glojure_DOT_core_transient) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp17, []any{v3, v16, tmp19, v4}) + tmp9 = tmp20 + } // end let + tmp5 = tmp9 + } else { + tmp10 := checkDerefVar(var_glojure_DOT_core_transduce) + tmp11 := checkDerefVar(var_glojure_DOT_core_conj) + tmp12 := lang.Apply(tmp10, []any{v3, tmp11, v2, v4}) + tmp5 = tmp12 + } + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_into = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_into.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // unchecked-double + // partitionv { + tmp0 := sym_partitionv.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n, sym_coll), lang.NewVector(sym_n, sym_step, sym_coll), lang.NewVector(sym_n, sym_step, sym_pad, sym_coll)), kw_doc, "Returns a lazy sequence of vectors of n items each, at offsets step\n apart. If step is not supplied, defaults to n, i.e. the partitions\n do not overlap. If a pad collection is supplied, use its elements as\n necessary to complete last partition upto n items. In case there are\n not enough padding elements, return a partition with less than n items.", kw_file, "glojure/core.glj", kw_added, "1.12", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(7262), kw_end_DASH_line, int(7262))).(*lang.Symbol) var tmp1 lang.FnFunc - { // function unchecked-double__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_seq) - tmp5 := checkDerefVar(var_glojure_DOT_core_concat) - tmp6 := checkDerefVar(var_glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) - tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := checkDerefVar(var_glojure_DOT_core_seq) - tmp12 := checkDerefVar(var_glojure_DOT_core_concat) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedDoubleCast}) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{v3}) - tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) - tmp18 := lang.Apply(tmp11, []any{tmp17}) - tmp19 := lang.Apply(tmp10, []any{tmp18}) - tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) - tmp21 := lang.Apply(tmp4, []any{tmp20}) - return tmp21 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := sym_unchecked_DASH_double.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to double. Subject to rounding.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(22), kw_column, int(7), kw_line, int(3553), kw_end_DASH_line, int(3553))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5 := lang.Apply(lang.AsFloat64, []any{v4}) - return tmp5 - }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // unchecked-float - { - var tmp1 lang.FnFunc - { // function unchecked-float__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] + tmp4 := checkDerefVar(var_glojure_DOT_core_partitionv) + tmp5 := lang.Apply(tmp4, []any{v2, v2, v3}) + return tmp5 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_seq) - tmp5 := checkDerefVar(var_glojure_DOT_core_concat) - tmp6 := checkDerefVar(var_glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) - tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := checkDerefVar(var_glojure_DOT_core_seq) - tmp12 := checkDerefVar(var_glojure_DOT_core_concat) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedFloatCast}) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{v3}) - tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) - tmp18 := lang.Apply(tmp11, []any{tmp17}) - tmp19 := lang.Apply(tmp10, []any{tmp18}) - tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) - tmp21 := lang.Apply(tmp4, []any{tmp20}) - return tmp21 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := sym_unchecked_DASH_float.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to float. Subject to rounding.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(3547), kw_end_DASH_line, int(3547))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5 := lang.Apply(lang.UncheckedFloatCast, []any{v4}) - return tmp5 + v4 := args[2] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp6 any + { // let + // let binding "temp__0__auto__" + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := lang.Apply(tmp7, []any{v4}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + var tmp11 any + { // let + // let binding "s" + var v12 any = v9 + _ = v12 + var tmp13 any + { // let + // let binding "p" + tmp14 := checkDerefVar(var_glojure_DOT_core_into) + tmp15 := lang.NewVector() + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7274), kw_column, int(22), kw_end_DASH_line, int(7274), kw_end_DASH_column, int(23)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp18 := checkDerefVar(var_glojure_DOT_core_take) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp14, []any{tmp17, tmp19, v12}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + tmp23 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp24 := checkDerefVar(var_glojure_DOT_core_count) + tmp25 := lang.Apply(tmp24, []any{v21}) + tmp26 := lang.Apply(tmp23, []any{v2, tmp25}) + if lang.IsTruthy(tmp26) { + tmp27 := checkDerefVar(var_glojure_DOT_core_cons) + tmp28 := checkDerefVar(var_glojure_DOT_core_partitionv) + tmp29 := checkDerefVar(var_glojure_DOT_core_nthrest) + tmp30 := lang.Apply(tmp29, []any{v12, v3}) + tmp31 := lang.Apply(tmp28, []any{v2, v3, tmp30}) + tmp32 := lang.Apply(tmp27, []any{v21, tmp31}) + tmp22 = tmp32 + } else { + } + tmp13 = tmp22 + } // end let + tmp11 = tmp13 + } // end let + tmp10 = tmp11 + } else { + } + tmp6 = tmp10 + } // end let + return tmp6 + }) + tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) + return tmp6 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp7 any + { // let + // let binding "temp__0__auto__" + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := lang.Apply(tmp8, []any{v5}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + if lang.IsTruthy(v10) { + var tmp12 any + { // let + // let binding "s" + var v13 any = v10 + _ = v13 + var tmp14 any + { // let + // let binding "p" + tmp15 := checkDerefVar(var_glojure_DOT_core_into) + tmp16 := lang.NewVector() + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7280), kw_column, int(22), kw_end_DASH_line, int(7280), kw_end_DASH_column, int(23)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp19 := checkDerefVar(var_glojure_DOT_core_take) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := lang.Apply(tmp15, []any{tmp18, tmp20, v13}) + var v22 any = tmp21 + _ = v22 + var tmp23 any + tmp24 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp25 := checkDerefVar(var_glojure_DOT_core_count) + tmp26 := lang.Apply(tmp25, []any{v22}) + tmp27 := lang.Apply(tmp24, []any{v2, tmp26}) + if lang.IsTruthy(tmp27) { + tmp28 := checkDerefVar(var_glojure_DOT_core_cons) + tmp29 := checkDerefVar(var_glojure_DOT_core_partitionv) + tmp30 := checkDerefVar(var_glojure_DOT_core_nthrest) + tmp31 := lang.Apply(tmp30, []any{v13, v3}) + tmp32 := lang.Apply(tmp29, []any{v2, v3, v4, tmp31}) + tmp33 := lang.Apply(tmp28, []any{v22, tmp32}) + tmp23 = tmp33 + } else { + tmp34 := checkDerefVar(var_glojure_DOT_core_list) + tmp35 := checkDerefVar(var_glojure_DOT_core_into) + tmp36 := lang.NewVector() + tmp37 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7283), kw_column, int(24), kw_end_DASH_line, int(7283), kw_end_DASH_column, int(25)) + tmp38, err := lang.WithMeta(tmp36, tmp37.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp39 := checkDerefVar(var_glojure_DOT_core_take) + tmp40 := lang.Apply(tmp39, []any{v2}) + tmp41 := checkDerefVar(var_glojure_DOT_core_concat) + tmp42 := lang.Apply(tmp41, []any{v22, v4}) + tmp43 := lang.Apply(tmp35, []any{tmp38, tmp40, tmp42}) + tmp44 := lang.Apply(tmp34, []any{tmp43}) + tmp23 = tmp44 + } + tmp14 = tmp23 + } // end let + tmp12 = tmp14 + } // end let + tmp11 = tmp12 + } else { + } + tmp7 = tmp11 + } // end let + return tmp7 + }) + tmp7 := lang.Apply(lang.NewLazySeq, []any{tmp6}) + return tmp7 + default: + checkArity(args, -1) + panic("unreachable") + } }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_partitionv = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_partitionv.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // unchecked-inc + // partitionv-all { + tmp0 := sym_partitionv_DASH_all.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n), lang.NewVector(sym_n, sym_coll), lang.NewVector(sym_n, sym_step, sym_coll)), kw_doc, "Returns a lazy sequence of vector partitions, but may include\n partitions with fewer than n items at the end.\n Returns a stateful transducer when no collection is provided.", kw_file, "glojure/core.glj", kw_added, "1.12", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(7285), kw_end_DASH_line, int(7285))).(*lang.Symbol) var tmp1 lang.FnFunc - { // function unchecked-inc__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_partition_DASH_all) + tmp4 := lang.Apply(tmp3, []any{v2}) + return tmp4 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_seq) - tmp5 := checkDerefVar(var_glojure_DOT_core_concat) - tmp6 := checkDerefVar(var_glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) - tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := checkDerefVar(var_glojure_DOT_core_seq) - tmp12 := checkDerefVar(var_glojure_DOT_core_concat) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Unchecked_inc}) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{v3}) - tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) - tmp18 := lang.Apply(tmp11, []any{tmp17}) - tmp19 := lang.Apply(tmp10, []any{tmp18}) - tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) - tmp21 := lang.Apply(tmp4, []any{tmp20}) - return tmp21 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := sym_unchecked_DASH_inc.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns a number one greater than x, a long.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(1161), kw_end_DASH_line, int(1161))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_inc") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_inc is not a function"))) + tmp4 := checkDerefVar(var_glojure_DOT_core_partitionv_DASH_all) + tmp5 := lang.Apply(tmp4, []any{v2, v2, v3}) + return tmp5 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp6 any + { // let + // let binding "temp__0__auto__" + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := lang.Apply(tmp7, []any{v4}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + var tmp11 any + { // let + // let binding "s" + var v12 any = v9 + _ = v12 + var tmp13 any + { // let + // let binding "seg" + tmp14 := checkDerefVar(var_glojure_DOT_core_into) + tmp15 := lang.NewVector() + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7297), kw_column, int(24), kw_end_DASH_line, int(7297), kw_end_DASH_column, int(25)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp18 := checkDerefVar(var_glojure_DOT_core_take) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp14, []any{tmp17, tmp19, v4}) + var v21 any = tmp20 + _ = v21 + tmp22 := checkDerefVar(var_glojure_DOT_core_cons) + tmp23 := checkDerefVar(var_glojure_DOT_core_partitionv_DASH_all) + tmp24 := checkDerefVar(var_glojure_DOT_core_drop) + tmp25 := lang.Apply(tmp24, []any{v3, v12}) + tmp26 := lang.Apply(tmp23, []any{v2, v3, tmp25}) + tmp27 := lang.Apply(tmp22, []any{v21, tmp26}) + tmp13 = tmp27 + } // end let + tmp11 = tmp13 + } // end let + tmp10 = tmp11 + } else { + } + tmp6 = tmp10 + } // end let + return tmp6 + }) + tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_partitionv_DASH_all = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_partitionv_DASH_all.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // unchecked-inc-int + // splitv-at { + tmp0 := sym_splitv_DASH_at.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n, sym_coll)), kw_doc, "Returns a vector of [(into [] (take n) coll) (drop n coll)]", kw_file, "glojure/core.glj", kw_added, "1.12", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(7256), kw_end_DASH_line, int(7256))).(*lang.Symbol) var tmp1 lang.FnFunc - { // function unchecked-inc-int__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_seq) - tmp5 := checkDerefVar(var_glojure_DOT_core_concat) - tmp6 := checkDerefVar(var_glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) - tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := checkDerefVar(var_glojure_DOT_core_seq) - tmp12 := checkDerefVar(var_glojure_DOT_core_concat) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_inc}) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{v3}) - tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) - tmp18 := lang.Apply(tmp11, []any{tmp17}) - tmp19 := lang.Apply(tmp10, []any{tmp18}) - tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) - tmp21 := lang.Apply(tmp4, []any{tmp20}) - return tmp21 - }) - v2 = tmp1 + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] _ = v2 - } - tmp0 := sym_unchecked_DASH_inc_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns a number one greater than x, an int.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(7), kw_line, int(1154), kw_end_DASH_line, int(1154))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_inc") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_inc is not a function"))) + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_into) + tmp5 := lang.NewVector() + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7260), kw_column, int(10), kw_end_DASH_line, int(7260), kw_end_DASH_column, int(11)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 + tmp8 := checkDerefVar(var_glojure_DOT_core_take) + tmp9 := lang.Apply(tmp8, []any{v2}) + tmp10 := lang.Apply(tmp4, []any{tmp7, tmp9, v3}) + tmp11 := checkDerefVar(var_glojure_DOT_core_drop) + tmp12 := lang.Apply(tmp11, []any{v2, v3}) + tmp13 := lang.NewVector(tmp10, tmp12) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7260), kw_column, int(3), kw_end_DASH_line, int(7260), kw_end_DASH_column, int(41)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp15 }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_splitv_DASH_at = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_splitv_DASH_at.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // unchecked-int + // iteration { + tmp0 := sym_iteration.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_step, sym__AMP_, lang.NewMap(kw_keys, lang.NewVector(sym_somef, sym_vf, sym_kf, sym_initk), kw_or, lang.NewMap(sym_vf, sym_identity, sym_kf, sym_identity, sym_somef, sym_some_QMARK_, sym_initk, nil)))), kw_doc, "Creates a seqable/reducible via repeated calls to step,\n a function of some (continuation token) 'k'. The first call to step\n will be passed initk, returning 'ret'. Iff (somef ret) is true,\n (vf ret) will be included in the iteration, else iteration will\n terminate and vf/kf will not be called. If (kf ret) is non-nil it\n will be passed to the next step call, else iteration will terminate.\n\n This can be used e.g. to consume APIs that return paginated or batched data.\n\n step - (possibly impure) fn of 'k' -> 'ret'\n\n :somef - fn of 'ret' -> logical true/false, default 'some?'\n :vf - fn of 'ret' -> 'v', a value produced by the iteration, default 'identity'\n :kf - fn of 'ret' -> 'next-k' or nil (signaling 'do not continue'), default 'identity'\n :initk - the first value passed to step, default 'nil'\n\n It is presumed that step with non-initk is unreproducible/non-idempotent.\n If step with initk is unreproducible it is on the consumer to not consume twice.", kw_file, "glojure/core.glj", kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(7716), kw_end_DASH_line, int(7716))).(*lang.Symbol) var tmp1 lang.FnFunc - { // function unchecked-int__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: checkArity(args, 1) - v3 := args[0] + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_seq) - tmp5 := checkDerefVar(var_glojure_DOT_core_concat) - tmp6 := checkDerefVar(var_glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) - tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := checkDerefVar(var_glojure_DOT_core_seq) - tmp12 := checkDerefVar(var_glojure_DOT_core_concat) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedIntCast}) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{v3}) - tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) - tmp18 := lang.Apply(tmp11, []any{tmp17}) - tmp19 := lang.Apply(tmp10, []any{tmp18}) - tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) - tmp21 := lang.Apply(tmp4, []any{tmp20}) - return tmp21 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := sym_unchecked_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to int. Subject to rounding or truncation.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(3535), kw_end_DASH_line, int(3535))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5 := lang.Apply(lang.UncheckedIntCast, []any{v4}) - return tmp5 + var tmp4 any + { // let + // let binding "map__357" + var v5 any = v3 + _ = v5 + // let binding "map__357" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v5}) + if lang.IsTruthy(tmp8) { + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_next) + tmp11 := lang.Apply(tmp10, []any{v5}) + if lang.IsTruthy(tmp11) { + tmp12 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) + tmp13 := lang.Apply(tmp12, []any{v5}) + tmp14 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{tmp13}) + tmp9 = tmp14 + } else { + var tmp15 any + tmp16 := checkDerefVar(var_glojure_DOT_core_seq) + tmp17 := lang.Apply(tmp16, []any{v5}) + if lang.IsTruthy(tmp17) { + tmp18 := checkDerefVar(var_glojure_DOT_core_first) + tmp19 := lang.Apply(tmp18, []any{v5}) + tmp15 = tmp19 + } else { + } + tmp9 = tmp15 + } + tmp6 = tmp9 + } else { + tmp6 = v5 + } + var v20 any = tmp6 + _ = v20 + // let binding "somef" + tmp21 := checkDerefVar(var_glojure_DOT_core_get) + tmp22 := checkDerefVar(var_glojure_DOT_core_some_QMARK_) + tmp23 := lang.Apply(tmp21, []any{v20, kw_somef, tmp22}) + var v24 any = tmp23 + _ = v24 + // let binding "vf" + tmp25 := checkDerefVar(var_glojure_DOT_core_get) + tmp26 := checkDerefVar(var_glojure_DOT_core_identity) + tmp27 := lang.Apply(tmp25, []any{v20, kw_vf, tmp26}) + var v28 any = tmp27 + _ = v28 + // let binding "kf" + tmp29 := checkDerefVar(var_glojure_DOT_core_get) + tmp30 := checkDerefVar(var_glojure_DOT_core_identity) + tmp31 := lang.Apply(tmp29, []any{v20, kw_kf, tmp30}) + var v32 any = tmp31 + _ = v32 + // let binding "initk" + tmp33 := checkDerefVar(var_glojure_DOT_core_get) + tmp34 := lang.Apply(tmp33, []any{v20, kw_initk, nil}) + var v35 any = tmp34 + _ = v35 + tmp36 := checkDerefVar(var_glojure_DOT_core_seq) + tmp37 := lang.NewVector(nil) + tmp38 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7743), kw_column, int(9), kw_end_DASH_line, int(7743), kw_end_DASH_column, int(11)) + tmp39, err := lang.WithMeta(tmp37, tmp38.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var tmp40 lang.FnFunc + { // function next + var v41 lang.FnFunc + tmp40 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v42 := args[0] + _ = v42 + var tmp43 any + tmp44 := lang.Apply(v24, []any{v42}) + if lang.IsTruthy(tmp44) { + tmp45 := checkDerefVar(var_glojure_DOT_core_cons) + tmp46 := lang.Apply(v28, []any{v42}) + var tmp47 any + { // let + // let binding "temp__0__auto__" + tmp48 := lang.Apply(v32, []any{v42}) + var v49 any = tmp48 + _ = v49 + var tmp50 any + tmp51 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp52 := lang.Apply(tmp51, []any{v49}) + if lang.IsTruthy(tmp52) { + } else { + var tmp53 any + { // let + // let binding "k" + var v54 any = v49 + _ = v54 + var tmp55 lang.FnFunc + tmp55 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp56 := lang.Apply(v2, []any{v54}) + tmp57 := lang.Apply(v41, []any{tmp56}) + return tmp57 + }) + tmp56 := lang.Apply(lang.NewLazySeq, []any{tmp55}) + tmp53 = tmp56 + } // end let + tmp50 = tmp53 + } + tmp47 = tmp50 + } // end let + tmp48 := lang.Apply(tmp45, []any{tmp46, tmp47}) + tmp43 = tmp48 + } else { + } + return tmp43 + }) + v41 = tmp40 + _ = v41 + } + tmp41 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7744), kw_column, int(10), kw_end_DASH_line, int(7748), kw_end_DASH_column, int(51)) + tmp42, err := lang.WithMeta(tmp40, tmp41.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp43 := lang.Apply(v2, []any{v35}) + tmp44 := lang.Apply(tmp42, []any{tmp43}) + tmp45 := lang.Apply(tmp36, []any{tmp39, tmp44}) + tmp46 := reflect.TypeOf((*lang.IReduceInit)(nil)).Elem() + tmp47 := checkDerefVar(var_glojure_DOT_core_reduce) + tmp48 := lang.NewVector(nil, nil, nil) + tmp49 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7751), kw_column, int(12), kw_end_DASH_line, int(7751), kw_end_DASH_column, int(22)) + tmp50, err := lang.WithMeta(tmp48, tmp49.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var tmp51 any + { // let + // let binding "acc" + var v52 any = nil + _ = v52 + // let binding "ret" + tmp53 := lang.Apply(v2, []any{v35}) + var v54 any = tmp53 + _ = v54 + for { + var tmp55 any + tmp56 := lang.Apply(v24, []any{v54}) + if lang.IsTruthy(tmp56) { + var tmp57 any + { // let + // let binding "acc" + tmp58 := lang.Apply(v28, []any{v54}) + tmp59 := lang.Apply(nil, []any{v52, tmp58}) + var v60 any = tmp59 + _ = v60 + var tmp61 any + tmp62 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) + tmp63 := lang.Apply(tmp62, []any{v60}) + if lang.IsTruthy(tmp63) { + tmp64 := checkDerefVar(var_glojure_DOT_core_deref) + tmp65 := lang.Apply(tmp64, []any{v60}) + tmp61 = tmp65 + } else { + var tmp66 any + { // let + // let binding "temp__0__auto__" + tmp67 := lang.Apply(v32, []any{v54}) + var v68 any = tmp67 + _ = v68 + var tmp69 any + tmp70 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp71 := lang.Apply(tmp70, []any{v68}) + if lang.IsTruthy(tmp71) { + tmp69 = v60 + } else { + var tmp72 any + { // let + // let binding "k" + var v73 any = v68 + _ = v73 + var tmp74 any = v60 + tmp76 := lang.Apply(v2, []any{v73}) + var tmp75 any = tmp76 + v52 = tmp74 + v54 = tmp75 + continue + } // end let + tmp69 = tmp72 + } + tmp66 = tmp69 + } // end let + tmp61 = tmp66 + } + tmp57 = tmp61 + } // end let + tmp55 = tmp57 + } else { + tmp55 = v52 + } + tmp51 = tmp55 + break + } + } // end let + tmp52 := lang.Apply(tmp47, []any{tmp50, tmp51}) + tmp53 := lang.Apply(nil, []any{nil, tmp45, tmp46, tmp52}) + tmp4 = tmp53 + } // end let + return tmp4 + } }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_iteration = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_iteration.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // unchecked-long + // load { + tmp0 := sym_load.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_paths)), kw_doc, "Loads Clojure code from resources in classpath. A path is interpreted as\n classpath-relative if it begins with a slash or relative to the root\n directory for the current namespace otherwise.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_redef, true, kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(6095), kw_end_DASH_line, int(6095))).(*lang.Symbol) var tmp1 lang.FnFunc - { // function unchecked-long__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_seq) - tmp5 := checkDerefVar(var_glojure_DOT_core_concat) - tmp6 := checkDerefVar(var_glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) - tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := checkDerefVar(var_glojure_DOT_core_seq) - tmp12 := checkDerefVar(var_glojure_DOT_core_concat) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedLongCast}) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{v3}) - tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) - tmp18 := lang.Apply(tmp11, []any{tmp17}) - tmp19 := lang.Apply(tmp10, []any{tmp18}) - tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) - tmp21 := lang.Apply(tmp4, []any{tmp20}) - return tmp21 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := sym_unchecked_DASH_long.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to long. Subject to rounding or truncation.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(3541), kw_end_DASH_line, int(3541))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5 := lang.Apply(lang.UncheckedLongCast, []any{v4}) - return tmp5 + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + var tmp3 any + { // let + // let binding "seq_133" + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + // let binding "chunk_134" + var v7 any = nil + _ = v7 + // let binding "count_135" + var v8 any = int64(0) + _ = v8 + // let binding "i_136" + var v9 any = int64(0) + _ = v9 + for { + var tmp10 any + tmp11 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp12 := lang.Apply(tmp11, []any{v9, v8}) + if lang.IsTruthy(tmp12) { + var tmp13 any + { // let + // let binding "path" + tmp14, _ := lang.FieldOrMethod(v7, "nth") + if reflect.TypeOf(tmp14).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp15 := lang.Apply(tmp14, []any{v9}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + { // let + // let binding "path" + var tmp18 any + tmp19 := lang.Apply(strings11.HasPrefix, []any{v16, "/"}) + if lang.IsTruthy(tmp19) { + tmp18 = v16 + } else { + tmp20 := checkDerefVar(var_glojure_DOT_core_str) + tmp21 := checkDerefVar(var_glojure_DOT_core_root_DASH_directory) + tmp22 := checkDerefVar(var_glojure_DOT_core_ns_DASH_name) + tmp23 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp24 := lang.Apply(tmp22, []any{tmp23}) + tmp25 := lang.Apply(tmp21, []any{tmp24}) + tmp26 := lang.Apply(tmp20, []any{tmp25, lang.NewChar(47), v16}) + tmp18 = tmp26 + } + var v27 any = tmp18 + _ = v27 + var tmp28 any + tmp29 := checkDerefVar(var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_) + if lang.IsTruthy(tmp29) { + tmp30 := checkDerefVar(var_glojure_DOT_core_printf) + tmp31 := lang.Apply(tmp30, []any{"(glojure.core/load \"%s\")\n", v27}) + _ = tmp31 + tmp32 := checkDerefVar(var_glojure_DOT_core_flush) + tmp33 := lang.Apply(tmp32, nil) + tmp28 = tmp33 + } else { + } + _ = tmp28 + tmp34 := checkDerefVar(var_glojure_DOT_core_check_DASH_cyclic_DASH_dependency) + tmp35 := lang.Apply(tmp34, []any{v27}) + _ = tmp35 + var tmp36 any + tmp37 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp38 := checkDerefVar(var_glojure_DOT_core_first) + tmp39 := checkDerefVar(var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_) + tmp40 := lang.Apply(tmp38, []any{tmp39}) + tmp41 := lang.Apply(tmp37, []any{v27, tmp40}) + if lang.IsTruthy(tmp41) { + } else { + var tmp42 any + { // let + tmp43 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp44 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp45 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_pending_DASH_paths_STAR_) + tmp46 := checkDerefVar(var_glojure_DOT_core_conj) + tmp47 := checkDerefVar(var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_) + tmp48 := lang.Apply(tmp46, []any{tmp47, v27}) + tmp49 := lang.Apply(tmp44, []any{tmp45, tmp48}) + tmp50 := lang.Apply(tmp43, []any{tmp49}) + _ = tmp50 + var tmp51 any + func() { + defer func() { + tmp52 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp53 := lang.Apply(tmp52, nil) + _ = tmp53 + }() + tmp54 := lang.Apply(strings11.TrimPrefix, []any{v27, "/"}) + tmp55, _ := lang.FieldOrMethod(runtime.RT, "Load") + if reflect.TypeOf(tmp55).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Load is not a function"))) + } + tmp56 := lang.Apply(tmp55, []any{tmp54}) + tmp51 = tmp56 + }() + tmp42 = tmp51 + } // end let + tmp36 = tmp42 + } + tmp17 = tmp36 + } // end let + _ = tmp17 + var tmp18 any = v6 + var tmp19 any = v7 + var tmp20 any = v8 + tmp22 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp23 := lang.Apply(tmp22, []any{v9}) + var tmp21 any = tmp23 + v6 = tmp18 + v7 = tmp19 + v8 = tmp20 + v9 = tmp21 + continue + } // end let + tmp10 = tmp13 + } else { + var tmp14 any + { // let + // let binding "temp__0__auto__" + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := lang.Apply(tmp15, []any{v6}) + var v17 any = tmp16 + _ = v17 + var tmp18 any + if lang.IsTruthy(v17) { + var tmp19 any + { // let + // let binding "seq_133" + var v20 any = v17 + _ = v20 + var tmp21 any + tmp22 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp23 := lang.Apply(tmp22, []any{v20}) + if lang.IsTruthy(tmp23) { + var tmp24 any + { // let + // let binding "c__0__auto__" + tmp25 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp26 := lang.Apply(tmp25, []any{v20}) + var v27 any = tmp26 + _ = v27 + tmp29 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp30 := lang.Apply(tmp29, []any{v20}) + var tmp28 any = tmp30 + var tmp31 any = v27 + tmp33 := checkDerefVar(var_glojure_DOT_core_int) + tmp34 := checkDerefVar(var_glojure_DOT_core_count) + tmp35 := lang.Apply(tmp34, []any{v27}) + tmp36 := lang.Apply(tmp33, []any{tmp35}) + var tmp32 any = tmp36 + tmp38 := checkDerefVar(var_glojure_DOT_core_int) + tmp39 := lang.Apply(tmp38, []any{int64(0)}) + var tmp37 any = tmp39 + v6 = tmp28 + v7 = tmp31 + v8 = tmp32 + v9 = tmp37 + continue + } // end let + tmp21 = tmp24 + } else { + var tmp25 any + { // let + // let binding "path" + tmp26 := checkDerefVar(var_glojure_DOT_core_first) + tmp27 := lang.Apply(tmp26, []any{v20}) + var v28 any = tmp27 + _ = v28 + var tmp29 any + { // let + // let binding "path" + var tmp30 any + tmp31 := lang.Apply(strings11.HasPrefix, []any{v28, "/"}) + if lang.IsTruthy(tmp31) { + tmp30 = v28 + } else { + tmp32 := checkDerefVar(var_glojure_DOT_core_str) + tmp33 := checkDerefVar(var_glojure_DOT_core_root_DASH_directory) + tmp34 := checkDerefVar(var_glojure_DOT_core_ns_DASH_name) + tmp35 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp36 := lang.Apply(tmp34, []any{tmp35}) + tmp37 := lang.Apply(tmp33, []any{tmp36}) + tmp38 := lang.Apply(tmp32, []any{tmp37, lang.NewChar(47), v28}) + tmp30 = tmp38 + } + var v39 any = tmp30 + _ = v39 + var tmp40 any + tmp41 := checkDerefVar(var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_) + if lang.IsTruthy(tmp41) { + tmp42 := checkDerefVar(var_glojure_DOT_core_printf) + tmp43 := lang.Apply(tmp42, []any{"(glojure.core/load \"%s\")\n", v39}) + _ = tmp43 + tmp44 := checkDerefVar(var_glojure_DOT_core_flush) + tmp45 := lang.Apply(tmp44, nil) + tmp40 = tmp45 + } else { + } + _ = tmp40 + tmp46 := checkDerefVar(var_glojure_DOT_core_check_DASH_cyclic_DASH_dependency) + tmp47 := lang.Apply(tmp46, []any{v39}) + _ = tmp47 + var tmp48 any + tmp49 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp50 := checkDerefVar(var_glojure_DOT_core_first) + tmp51 := checkDerefVar(var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_) + tmp52 := lang.Apply(tmp50, []any{tmp51}) + tmp53 := lang.Apply(tmp49, []any{v39, tmp52}) + if lang.IsTruthy(tmp53) { + } else { + var tmp54 any + { // let + tmp55 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp56 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp57 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_pending_DASH_paths_STAR_) + tmp58 := checkDerefVar(var_glojure_DOT_core_conj) + tmp59 := checkDerefVar(var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_) + tmp60 := lang.Apply(tmp58, []any{tmp59, v39}) + tmp61 := lang.Apply(tmp56, []any{tmp57, tmp60}) + tmp62 := lang.Apply(tmp55, []any{tmp61}) + _ = tmp62 + var tmp63 any + func() { + defer func() { + tmp64 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp65 := lang.Apply(tmp64, nil) + _ = tmp65 + }() + tmp66 := lang.Apply(strings11.TrimPrefix, []any{v39, "/"}) + tmp67, _ := lang.FieldOrMethod(runtime.RT, "Load") + if reflect.TypeOf(tmp67).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Load is not a function"))) + } + tmp68 := lang.Apply(tmp67, []any{tmp66}) + tmp63 = tmp68 + }() + tmp54 = tmp63 + } // end let + tmp48 = tmp54 + } + tmp29 = tmp48 + } // end let + _ = tmp29 + tmp31 := checkDerefVar(var_glojure_DOT_core_next) + tmp32 := lang.Apply(tmp31, []any{v20}) + var tmp30 any = tmp32 + var tmp33 any = nil + var tmp34 any = int64(0) + var tmp35 any = int64(0) + v6 = tmp30 + v7 = tmp33 + v8 = tmp34 + v9 = tmp35 + continue + } // end let + tmp21 = tmp25 + } + tmp19 = tmp21 + } // end let + tmp18 = tmp19 + } else { + } + tmp14 = tmp18 + } // end let + tmp10 = tmp14 + } + tmp3 = tmp10 + break + } + } // end let + return tmp3 + } }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_load = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_load.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // unchecked-multiply + // load-one { + tmp0 := sym_load_DASH_one.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_lib, sym_need_DASH_ns, sym_require)), kw_doc, "Loads a lib given its name. If need-ns, ensures that the associated\n namespace exists after loading. If require, records the load so any\n duplicate loads can be skipped.", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(8), kw_line, int(5879), kw_end_DASH_line, int(5879), kw_private, true)).(*lang.Symbol) var tmp1 lang.FnFunc - { // function unchecked-multiply__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_seq) - tmp6 := checkDerefVar(var_glojure_DOT_core_concat) - tmp7 := checkDerefVar(var_glojure_DOT_core_list) - tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) - tmp9 := checkDerefVar(var_glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp11 := checkDerefVar(var_glojure_DOT_core_list) - tmp12 := checkDerefVar(var_glojure_DOT_core_seq) - tmp13 := checkDerefVar(var_glojure_DOT_core_concat) - tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_multiply}) - tmp16 := checkDerefVar(var_glojure_DOT_core_list) - tmp17 := lang.Apply(tmp16, []any{v3}) - tmp18 := checkDerefVar(var_glojure_DOT_core_list) - tmp19 := lang.Apply(tmp18, []any{v4}) - tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) - tmp21 := lang.Apply(tmp12, []any{tmp20}) - tmp22 := lang.Apply(tmp11, []any{tmp21}) - tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) - tmp24 := lang.Apply(tmp5, []any{tmp23}) - return tmp24 - }) - v2 = tmp1 + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] _ = v2 - } - tmp0 := sym_unchecked_DASH_multiply.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Returns the product of x and y, both long.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(24), kw_column, int(7), kw_line, int(1231), kw_end_DASH_line, int(1231))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v4 := args[0] + v3 := args[1] + _ = v3 + v4 := args[2] _ = v4 - v5 := args[1] - _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_multiply") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_multiply is not a function"))) + tmp5 := checkDerefVar(var_glojure_DOT_core_load) + tmp6 := checkDerefVar(var_glojure_DOT_core_root_DASH_resource) + tmp7 := lang.Apply(tmp6, []any{v2}) + tmp8 := lang.Apply(tmp5, []any{tmp7}) + _ = tmp8 + tmp9 := checkDerefVar(var_glojure_DOT_core_throw_DASH_if) + var tmp10 any + { // let + // let binding "and__0__auto__" + var v11 any = v3 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + tmp13 := checkDerefVar(var_glojure_DOT_core_not) + tmp14 := checkDerefVar(var_glojure_DOT_core_find_DASH_ns) + tmp15 := lang.Apply(tmp14, []any{v2}) + tmp16 := lang.Apply(tmp13, []any{tmp15}) + tmp12 = tmp16 + } else { + tmp12 = v11 + } + tmp10 = tmp12 + } // end let + tmp11 := checkDerefVar(var_glojure_DOT_core_root_DASH_resource) + tmp12 := lang.Apply(tmp11, []any{v2}) + tmp13 := lang.Apply(tmp9, []any{tmp10, "namespace '%s' not found after loading '%s'", v2, tmp12}) + _ = tmp13 + var tmp14 any + if lang.IsTruthy(v4) { + var tmp15 lang.FnFunc + tmp15 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp16 := checkDerefVar(var_glojure_DOT_core_commute) + tmp17 := checkDerefVar(var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_) + tmp18 := checkDerefVar(var_glojure_DOT_core_conj) + tmp19 := lang.Apply(tmp16, []any{tmp17, tmp18, v2}) + return tmp19 + }) + tmp16, _ := lang.FieldOrMethod(lang.LockingTransaction, "RunInTransaction") + if reflect.TypeOf(tmp16).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("RunInTransaction is not a function"))) + } + tmp17 := lang.Apply(tmp16, []any{tmp15}) + tmp14 = tmp17 + } else { } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 + return tmp14 }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_load_DASH_one = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_load_DASH_one.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // unchecked-multiply-int + // load-all { + tmp0 := sym_load_DASH_all.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_lib, sym_need_DASH_ns, sym_require)), kw_doc, "Loads a lib given its name and forces a load of any libs it directly or\n indirectly loads. If need-ns, ensures that the associated namespace\n exists after loading. If require, records the load so any duplicate loads\n can be skipped.", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(8), kw_line, int(5892), kw_end_DASH_line, int(5892), kw_private, true)).(*lang.Symbol) var tmp1 lang.FnFunc - { // function unchecked-multiply-int__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_seq) - tmp6 := checkDerefVar(var_glojure_DOT_core_concat) - tmp7 := checkDerefVar(var_glojure_DOT_core_list) - tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) - tmp9 := checkDerefVar(var_glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp11 := checkDerefVar(var_glojure_DOT_core_list) - tmp12 := checkDerefVar(var_glojure_DOT_core_seq) - tmp13 := checkDerefVar(var_glojure_DOT_core_concat) - tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_multiply}) - tmp16 := checkDerefVar(var_glojure_DOT_core_list) - tmp17 := lang.Apply(tmp16, []any{v3}) - tmp18 := checkDerefVar(var_glojure_DOT_core_list) - tmp19 := lang.Apply(tmp18, []any{v4}) - tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) - tmp21 := lang.Apply(tmp12, []any{tmp20}) - tmp22 := lang.Apply(tmp11, []any{tmp21}) - tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) - tmp24 := lang.Apply(tmp5, []any{tmp23}) - return tmp24 - }) - v2 = tmp1 + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] _ = v2 - } - tmp0 := sym_unchecked_DASH_multiply_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Returns the product of x and y, both int.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(28), kw_column, int(7), kw_line, int(1224), kw_end_DASH_line, int(1224))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v4 := args[0] + v3 := args[1] + _ = v3 + v4 := args[2] _ = v4 - v5 := args[1] - _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_multiply") + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp6 := checkDerefVar(var_glojure_DOT_core_commute) + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_) + var tmp8 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v9 := args[0] + _ = v9 + v10 := args[1] + _ = v10 + tmp11 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp12 := checkDerefVar(var_glojure_DOT_core_conj) + tmp13 := lang.Apply(tmp11, []any{tmp12, v9, v10}) + return tmp13 + }) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5899), kw_column, int(27), kw_end_DASH_line, int(5899), kw_end_DASH_column, int(47)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var tmp11 any + { // let + tmp12 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp13 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp14 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_loaded_DASH_libs_STAR_) + tmp15 := checkDerefVar(var_glojure_DOT_core_ref) + tmp16 := checkDerefVar(var_glojure_DOT_core_sorted_DASH_set) + tmp17 := lang.Apply(tmp16, nil) + tmp18 := lang.Apply(tmp15, []any{tmp17}) + tmp19 := lang.Apply(tmp13, []any{tmp14, tmp18}) + tmp20 := lang.Apply(tmp12, []any{tmp19}) + _ = tmp20 + var tmp21 any + func() { + defer func() { + tmp22 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp23 := lang.Apply(tmp22, nil) + _ = tmp23 + }() + tmp24 := checkDerefVar(var_glojure_DOT_core_load_DASH_one) + tmp25 := lang.Apply(tmp24, []any{v2, v3, v4}) + _ = tmp25 + tmp26 := checkDerefVar(var_glojure_DOT_core_deref) + tmp27 := checkDerefVar(var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_) + tmp28 := lang.Apply(tmp26, []any{tmp27}) + tmp21 = tmp28 + }() + tmp11 = tmp21 + } // end let + tmp12 := lang.Apply(tmp6, []any{tmp7, tmp10, tmp11}) + return tmp12 + }) + tmp6, _ := lang.FieldOrMethod(lang.LockingTransaction, "RunInTransaction") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_multiply is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("RunInTransaction is not a function"))) } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) + tmp7 := lang.Apply(tmp6, []any{tmp5}) return tmp7 }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_load_DASH_all = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_load_DASH_all.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // unchecked-negate + // load-data-reader-file { + tmp0 := sym_load_DASH_data_DASH_reader_DASH_file.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7836), kw_column, int(8), kw_end_DASH_line, int(7836), kw_end_DASH_column, int(28), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_mappings, sym_url)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp1 lang.FnFunc - { // function unchecked-negate__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_seq) - tmp5 := checkDerefVar(var_glojure_DOT_core_concat) - tmp6 := checkDerefVar(var_glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) - tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := checkDerefVar(var_glojure_DOT_core_seq) - tmp12 := checkDerefVar(var_glojure_DOT_core_concat) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Unchecked_minus}) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{v3}) - tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) - tmp18 := lang.Apply(tmp11, []any{tmp17}) - tmp19 := lang.Apply(tmp10, []any{tmp18}) - tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) - tmp21 := lang.Apply(tmp4, []any{tmp20}) - return tmp21 - }) - v2 = tmp1 + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "rdr" + tmp5, ok := lang.FieldOrMethod(v3, "openStream") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "openStream"))) + } + var tmp6 any + switch reflect.TypeOf(tmp5).Kind() { + case reflect.Func: + tmp6 = lang.Apply(tmp5, nil) + default: + tmp6 = tmp5 + } + tmp7 := lang.Apply(nil, []any{tmp6, "UTF-8"}) + tmp8 := lang.Apply(nil, []any{tmp7}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + func() { + defer func() { + tmp11, ok := lang.FieldOrMethod(v9, "close") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v9, "close"))) + } + var tmp12 any + switch reflect.TypeOf(tmp11).Kind() { + case reflect.Func: + tmp12 = lang.Apply(tmp11, nil) + default: + tmp12 = tmp11 + } + _ = tmp12 + }() + var tmp13 any + { // let + tmp14 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp15 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp16 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_file_STAR_) + tmp17, ok := lang.FieldOrMethod(v3, "getFile") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getFile"))) + } + var tmp18 any + switch reflect.TypeOf(tmp17).Kind() { + case reflect.Func: + tmp18 = lang.Apply(tmp17, nil) + default: + tmp18 = tmp17 + } + tmp19 := lang.Apply(tmp15, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp14, []any{tmp19}) + _ = tmp20 + var tmp21 any + func() { + defer func() { + tmp22 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp23 := lang.Apply(tmp22, nil) + _ = tmp23 + }() + var tmp24 any + { // let + // let binding "read-opts" + var tmp25 any + tmp26, ok := lang.FieldOrMethod(v3, "getPath") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getPath"))) + } + var tmp27 any + switch reflect.TypeOf(tmp26).Kind() { + case reflect.Func: + tmp27 = lang.Apply(tmp26, nil) + default: + tmp27 = tmp26 + } + tmp28, _ := lang.FieldOrMethod(tmp27, "endsWith") + if reflect.TypeOf(tmp28).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("endsWith is not a function"))) + } + tmp29 := lang.Apply(tmp28, []any{"cljc"}) + if lang.IsTruthy(tmp29) { + tmp30 := lang.NewMap(kw_eof, nil, kw_read_DASH_cond, kw_allow) + tmp31 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7842), kw_column, int(25), kw_end_DASH_line, int(7842), kw_end_DASH_column, int(52)) + tmp32, err := lang.WithMeta(tmp30, tmp31.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp25 = tmp32 + } else { + tmp33 := lang.NewMap(kw_eof, nil) + tmp34 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7843), kw_column, int(25), kw_end_DASH_line, int(7843), kw_end_DASH_column, int(34)) + tmp35, err := lang.WithMeta(tmp33, tmp34.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp25 = tmp35 + } + var v36 any = tmp25 + _ = v36 + // let binding "new-mappings" + tmp37 := checkDerefVar(var_glojure_DOT_core_read) + tmp38 := lang.Apply(tmp37, []any{v36, v9}) + var v39 any = tmp38 + _ = v39 + var tmp40 any + tmp41 := checkDerefVar(var_glojure_DOT_core_not) + tmp42 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp43 := lang.Apply(tmp42, []any{v39}) + tmp44 := lang.Apply(tmp41, []any{tmp43}) + if lang.IsTruthy(tmp44) { + tmp45 := checkDerefVar(var_glojure_DOT_core_ex_DASH_info) + tmp46 := checkDerefVar(var_glojure_DOT_core_str) + tmp47 := lang.Apply(tmp46, []any{"Not a valid data-reader map"}) + tmp48 := lang.NewMap(kw_url, v3) + tmp49 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7847), kw_column, int(27), kw_end_DASH_line, int(7847), kw_end_DASH_column, int(36)) + tmp50, err := lang.WithMeta(tmp48, tmp49.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp51 := lang.Apply(tmp45, []any{tmp47, tmp50}) + panic(tmp51) + } else { + } + _ = tmp40 + tmp52 := checkDerefVar(var_glojure_DOT_core_reduce) + var tmp53 lang.FnFunc + tmp53 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v54 := args[0] + _ = v54 + v55 := args[1] + _ = v55 + var tmp56 any + { // let + // let binding "vec__359" + var v57 any = v55 + _ = v57 + // let binding "k" + tmp58 := checkDerefVar(var_glojure_DOT_core_nth) + tmp59 := lang.Apply(tmp58, []any{v57, int64(0), nil}) + var v60 any = tmp59 + _ = v60 + // let binding "v" + tmp61 := checkDerefVar(var_glojure_DOT_core_nth) + tmp62 := lang.Apply(tmp61, []any{v57, int64(1), nil}) + var v63 any = tmp62 + _ = v63 + var tmp64 any + tmp65 := checkDerefVar(var_glojure_DOT_core_not) + tmp66 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp67 := lang.Apply(tmp66, []any{v60}) + tmp68 := lang.Apply(tmp65, []any{tmp67}) + if lang.IsTruthy(tmp68) { + tmp69 := checkDerefVar(var_glojure_DOT_core_ex_DASH_info) + tmp70 := checkDerefVar(var_glojure_DOT_core_str) + tmp71 := lang.Apply(tmp70, []any{"Invalid form in data-reader file"}) + tmp72 := lang.NewMap(kw_url, v3, kw_form, v60) + tmp73 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7852), kw_column, int(30), kw_end_DASH_line, int(7853), kw_end_DASH_column, int(38)) + tmp74, err := lang.WithMeta(tmp72, tmp73.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp75 := lang.Apply(tmp69, []any{tmp71, tmp74}) + panic(tmp75) + } else { + } + _ = tmp64 + var tmp76 any + { // let + // let binding "v-var" + tmp77 := checkDerefVar(var_glojure_DOT_core_data_DASH_reader_DASH_var) + tmp78 := lang.Apply(tmp77, []any{v63}) + var v79 any = tmp78 + _ = v79 + var tmp80 any + var tmp81 any + { // let + // let binding "and__0__auto__" + tmp82 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp83 := lang.Apply(tmp82, []any{v2, v60}) + var v84 any = tmp83 + _ = v84 + var tmp85 any + if lang.IsTruthy(v84) { + tmp86 := checkDerefVar(var_glojure_DOT_core_not_EQ_) + tmp87 := lang.Apply(v2, []any{v60}) + tmp88 := lang.Apply(tmp86, []any{tmp87, v79}) + tmp85 = tmp88 + } else { + tmp85 = v84 + } + tmp81 = tmp85 + } // end let + if lang.IsTruthy(tmp81) { + tmp82 := checkDerefVar(var_glojure_DOT_core_ex_DASH_info) + tmp83 := lang.NewMap(kw_url, v3, kw_conflict, v60, kw_mappings, v54) + tmp84 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7858), kw_column, int(32), kw_end_DASH_line, int(7860), kw_end_DASH_column, int(44)) + tmp85, err := lang.WithMeta(tmp83, tmp84.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp86 := lang.Apply(tmp82, []any{"Conflicting data-reader mapping", tmp85}) + panic(tmp86) + } else { + } + _ = tmp80 + tmp87 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp88 := lang.Apply(tmp87, []any{v54, v60, v79}) + tmp76 = tmp88 + } // end let + tmp56 = tmp76 + } // end let + return tmp56 + }) + tmp54 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7849), kw_column, int(10), kw_end_DASH_line, int(7861), kw_end_DASH_column, int(32)) + tmp55, err := lang.WithMeta(tmp53, tmp54.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp56 := lang.Apply(tmp52, []any{tmp55, v2, v39}) + tmp24 = tmp56 + } // end let + tmp21 = tmp24 + }() + tmp13 = tmp21 + } // end let + tmp10 = tmp13 + }() + tmp4 = tmp10 + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_load_DASH_data_DASH_reader_DASH_file = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_load_DASH_data_DASH_reader_DASH_file.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } - tmp0 := sym_unchecked_DASH_negate.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns the negation of x, a long.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(22), kw_column, int(7), kw_line, int(1189), kw_end_DASH_line, int(1189))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_negate") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_negate is not a function"))) + } + // load-data-readers + { + tmp0 := sym_load_DASH_data_DASH_readers.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7865), kw_column, int(8), kw_end_DASH_line, int(7865), kw_end_DASH_column, int(24), kw_private, true, kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp2 := checkDerefVar(var_glojure_DOT_core_alter_DASH_var_DASH_root) + tmp3 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_data_DASH_readers_STAR_) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v5 := args[0] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_reduce) + tmp7 := checkDerefVar(var_glojure_DOT_core_load_DASH_data_DASH_reader_DASH_file) + tmp8 := checkDerefVar(var_glojure_DOT_core_data_DASH_reader_DASH_urls) + tmp9 := lang.Apply(tmp8, nil) + tmp10 := lang.Apply(tmp6, []any{tmp7, v5, tmp9}) + return tmp10 + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7867), kw_column, int(19), kw_end_DASH_line, int(7869), kw_end_DASH_column, int(57)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 + tmp7 := lang.Apply(tmp2, []any{tmp3, tmp6}) + return tmp7 }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_load_DASH_data_DASH_readers = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_load_DASH_data_DASH_readers.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // unchecked-negate-int + // load-lib { + tmp0 := sym_load_DASH_lib.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_prefix, sym_lib, sym__AMP_, sym_options)), kw_doc, "Loads a lib with options", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(8), kw_line, int(5904), kw_end_DASH_line, int(5904), kw_private, true)).(*lang.Symbol) var tmp1 lang.FnFunc - { // function unchecked-negate-int__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_seq) - tmp5 := checkDerefVar(var_glojure_DOT_core_concat) - tmp6 := checkDerefVar(var_glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) - tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := checkDerefVar(var_glojure_DOT_core_seq) - tmp12 := checkDerefVar(var_glojure_DOT_core_concat) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_negate}) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{v3}) - tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) - tmp18 := lang.Apply(tmp11, []any{tmp17}) - tmp19 := lang.Apply(tmp10, []any{tmp18}) - tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) - tmp21 := lang.Apply(tmp4, []any{tmp20}) - return tmp21 - }) - v2 = tmp1 - _ = v2 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_throw_DASH_if) + var tmp6 any + { // let + // let binding "and__0__auto__" + var v7 any = v2 + _ = v7 + var tmp8 any + if lang.IsTruthy(v7) { + tmp9 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp10 := checkDerefVar(var_glojure_DOT_core_name) + tmp11 := lang.Apply(tmp10, []any{v3}) + tmp12 := checkDerefVar(var_glojure_DOT_core_int) + tmp13 := lang.Apply(tmp12, []any{lang.NewChar(46)}) + tmp14 := lang.Apply(strings11.Index, []any{tmp11, tmp13}) + tmp15 := lang.Apply(tmp9, []any{tmp14}) + tmp8 = tmp15 + } else { + tmp8 = v7 + } + tmp6 = tmp8 + } // end let + tmp7 := checkDerefVar(var_glojure_DOT_core_name) + tmp8 := lang.Apply(tmp7, []any{v3}) + tmp9 := lang.Apply(tmp5, []any{tmp6, "Found lib name '%s' containing period with prefix '%s'. lib names inside prefix lists must not contain periods", tmp8, v2}) + _ = tmp9 + var tmp10 any + { // let + // let binding "lib" + var tmp11 any + if lang.IsTruthy(v2) { + tmp12 := checkDerefVar(var_glojure_DOT_core_symbol) + tmp13 := checkDerefVar(var_glojure_DOT_core_str) + tmp14 := lang.Apply(tmp13, []any{v2, lang.NewChar(46), v3}) + tmp15 := lang.Apply(tmp12, []any{tmp14}) + tmp11 = tmp15 + } else { + tmp11 = v3 + } + var v16 any = tmp11 + _ = v16 + // let binding "opts" + tmp17 := checkDerefVar(var_glojure_DOT_core_apply) + tmp18 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp19 := lang.Apply(tmp17, []any{tmp18, v4}) + var v20 any = tmp19 + _ = v20 + // let binding "map__110" + var v21 any = v20 + _ = v21 + // let binding "map__110" + var tmp22 any + tmp23 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp24 := lang.Apply(tmp23, []any{v21}) + if lang.IsTruthy(tmp24) { + var tmp25 any + tmp26 := checkDerefVar(var_glojure_DOT_core_next) + tmp27 := lang.Apply(tmp26, []any{v21}) + if lang.IsTruthy(tmp27) { + tmp28 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) + tmp29 := lang.Apply(tmp28, []any{v21}) + tmp30 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{tmp29}) + tmp25 = tmp30 + } else { + var tmp31 any + tmp32 := checkDerefVar(var_glojure_DOT_core_seq) + tmp33 := lang.Apply(tmp32, []any{v21}) + if lang.IsTruthy(tmp33) { + tmp34 := checkDerefVar(var_glojure_DOT_core_first) + tmp35 := lang.Apply(tmp34, []any{v21}) + tmp31 = tmp35 + } else { + } + tmp25 = tmp31 + } + tmp22 = tmp25 + } else { + tmp22 = v21 + } + var v36 any = tmp22 + _ = v36 + // let binding "as" + tmp37 := checkDerefVar(var_glojure_DOT_core_get) + tmp38 := lang.Apply(tmp37, []any{v36, kw_as}) + var v39 any = tmp38 + _ = v39 + // let binding "reload" + tmp40 := checkDerefVar(var_glojure_DOT_core_get) + tmp41 := lang.Apply(tmp40, []any{v36, kw_reload}) + var v42 any = tmp41 + _ = v42 + // let binding "reload-all" + tmp43 := checkDerefVar(var_glojure_DOT_core_get) + tmp44 := lang.Apply(tmp43, []any{v36, kw_reload_DASH_all}) + var v45 any = tmp44 + _ = v45 + // let binding "require" + tmp46 := checkDerefVar(var_glojure_DOT_core_get) + tmp47 := lang.Apply(tmp46, []any{v36, kw_require}) + var v48 any = tmp47 + _ = v48 + // let binding "use" + tmp49 := checkDerefVar(var_glojure_DOT_core_get) + tmp50 := lang.Apply(tmp49, []any{v36, kw_use}) + var v51 any = tmp50 + _ = v51 + // let binding "verbose" + tmp52 := checkDerefVar(var_glojure_DOT_core_get) + tmp53 := lang.Apply(tmp52, []any{v36, kw_verbose}) + var v54 any = tmp53 + _ = v54 + // let binding "as-alias" + tmp55 := checkDerefVar(var_glojure_DOT_core_get) + tmp56 := lang.Apply(tmp55, []any{v36, kw_as_DASH_alias}) + var v57 any = tmp56 + _ = v57 + // let binding "loaded" + tmp58 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp59 := checkDerefVar(var_glojure_DOT_core_deref) + tmp60 := checkDerefVar(var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_) + tmp61 := lang.Apply(tmp59, []any{tmp60}) + tmp62 := lang.Apply(tmp58, []any{tmp61, v16}) + var v63 any = tmp62 + _ = v63 + // let binding "need-ns" + var tmp64 any + { // let + // let binding "or__0__auto__" + var v65 any = v39 + _ = v65 + var tmp66 any + if lang.IsTruthy(v65) { + tmp66 = v65 + } else { + tmp66 = v51 + } + tmp64 = tmp66 + } // end let + var v65 any = tmp64 + _ = v65 + // let binding "load" + var tmp66 any + if lang.IsTruthy(v45) { + tmp67 := checkDerefVar(var_glojure_DOT_core_load_DASH_all) + tmp66 = tmp67 + } else { + var tmp68 any + if lang.IsTruthy(v42) { + tmp69 := checkDerefVar(var_glojure_DOT_core_load_DASH_one) + tmp68 = tmp69 + } else { + var tmp70 any + tmp71 := checkDerefVar(var_glojure_DOT_core_not) + tmp72 := lang.Apply(tmp71, []any{v63}) + if lang.IsTruthy(tmp72) { + var tmp73 any + if lang.IsTruthy(v65) { + tmp74 := checkDerefVar(var_glojure_DOT_core_load_DASH_one) + tmp73 = tmp74 + } else { + var tmp75 any + if lang.IsTruthy(v57) { + var tmp76 lang.FnFunc + tmp76 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v77 := args[0] + _ = v77 + v78 := args[1] + _ = v78 + v79 := args[2] + _ = v79 + tmp80 := checkDerefVar(var_glojure_DOT_core_create_DASH_ns) + tmp81 := lang.Apply(tmp80, []any{v77}) + return tmp81 + }) + tmp77 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5918), kw_column, int(48), kw_end_DASH_line, int(5918), kw_end_DASH_column, int(88)) + tmp78, err := lang.WithMeta(tmp76, tmp77.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp75 = tmp78 + } else { + var tmp79 any + if lang.IsTruthy(kw_else) { + tmp80 := checkDerefVar(var_glojure_DOT_core_load_DASH_one) + tmp79 = tmp80 + } else { + } + tmp75 = tmp79 + } + tmp73 = tmp75 + } + tmp70 = tmp73 + } else { + } + tmp68 = tmp70 + } + tmp66 = tmp68 + } + var v81 any = tmp66 + _ = v81 + // let binding "filter-opts" + tmp82 := checkDerefVar(var_glojure_DOT_core_select_DASH_keys) + tmp83 := lang.Apply(tmp82, []any{v20, lang.NewList(kw_exclude, kw_only, kw_rename, kw_refer)}) + var v84 any = tmp83 + _ = v84 + // let binding "undefined-on-entry" + tmp85 := checkDerefVar(var_glojure_DOT_core_not) + tmp86 := checkDerefVar(var_glojure_DOT_core_find_DASH_ns) + tmp87 := lang.Apply(tmp86, []any{v16}) + tmp88 := lang.Apply(tmp85, []any{tmp87}) + var v89 any = tmp88 + _ = v89 + var tmp90 any + { // let + tmp91 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp92 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp93 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_loading_DASH_verbosely_STAR_) + var tmp94 any + { // let + // let binding "or__0__auto__" + tmp95 := checkDerefVar(var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_) + var v96 any = tmp95 + _ = v96 + var tmp97 any + if lang.IsTruthy(v96) { + tmp97 = v96 + } else { + tmp97 = v54 + } + tmp94 = tmp97 + } // end let + tmp95 := lang.Apply(tmp92, []any{tmp93, tmp94}) + tmp96 := lang.Apply(tmp91, []any{tmp95}) + _ = tmp96 + var tmp97 any + func() { + defer func() { + tmp98 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp99 := lang.Apply(tmp98, nil) + _ = tmp99 + }() + var tmp100 any + if lang.IsTruthy(v81) { + var tmp101 any + func() { + defer func() { + if r := recover(); r != nil { + if lang.CatchMatches(r, lang.Builtins["any"]) { + v102 := r + _ = v102 + var tmp103 any + if lang.IsTruthy(v89) { + tmp104 := checkDerefVar(var_glojure_DOT_core_remove_DASH_ns) + tmp105 := lang.Apply(tmp104, []any{v16}) + tmp103 = tmp105 + } else { + } + _ = tmp103 + panic(v102) + } else { + panic(r) + } + } + }() + tmp102 := lang.Apply(v81, []any{v16, v65, v48}) + tmp101 = tmp102 + }() + tmp100 = tmp101 + } else { + tmp103 := checkDerefVar(var_glojure_DOT_core_throw_DASH_if) + var tmp104 any + { // let + // let binding "and__0__auto__" + var v105 any = v65 + _ = v105 + var tmp106 any + if lang.IsTruthy(v105) { + tmp107 := checkDerefVar(var_glojure_DOT_core_not) + tmp108 := checkDerefVar(var_glojure_DOT_core_find_DASH_ns) + tmp109 := lang.Apply(tmp108, []any{v16}) + tmp110 := lang.Apply(tmp107, []any{tmp109}) + tmp106 = tmp110 + } else { + tmp106 = v105 + } + tmp104 = tmp106 + } // end let + tmp105 := lang.Apply(tmp103, []any{tmp104, "namespace '%s' not found", v16}) + tmp100 = tmp105 + } + _ = tmp100 + var tmp106 any + var tmp107 any + { // let + // let binding "and__0__auto__" + var v108 any = v65 + _ = v108 + var tmp109 any + if lang.IsTruthy(v108) { + tmp110 := checkDerefVar(var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_) + tmp109 = tmp110 + } else { + tmp109 = v108 + } + tmp107 = tmp109 + } // end let + if lang.IsTruthy(tmp107) { + tmp108 := checkDerefVar(var_glojure_DOT_core_printf) + tmp109 := checkDerefVar(var_glojure_DOT_core_ns_DASH_name) + tmp110 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp111 := lang.Apply(tmp109, []any{tmp110}) + tmp112 := lang.Apply(tmp108, []any{"(glojure.core/in-ns '%s)\n", tmp111}) + tmp106 = tmp112 + } else { + } + _ = tmp106 + var tmp113 any + if lang.IsTruthy(v39) { + var tmp114 any + tmp115 := checkDerefVar(var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_) + if lang.IsTruthy(tmp115) { + tmp116 := checkDerefVar(var_glojure_DOT_core_printf) + tmp117 := lang.Apply(tmp116, []any{"(glojure.core/alias '%s '%s)\n", v39, v16}) + tmp114 = tmp117 + } else { + } + _ = tmp114 + tmp118 := checkDerefVar(var_glojure_DOT_core_alias) + tmp119 := lang.Apply(tmp118, []any{v39, v16}) + tmp113 = tmp119 + } else { + } + _ = tmp113 + var tmp120 any + if lang.IsTruthy(v57) { + var tmp121 any + tmp122 := checkDerefVar(var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_) + if lang.IsTruthy(tmp122) { + tmp123 := checkDerefVar(var_glojure_DOT_core_printf) + tmp124 := lang.Apply(tmp123, []any{"(glojure.core/alias '%s '%s)\n", v57, v16}) + tmp121 = tmp124 + } else { + } + _ = tmp121 + tmp125 := checkDerefVar(var_glojure_DOT_core_alias) + tmp126 := lang.Apply(tmp125, []any{v57, v16}) + tmp120 = tmp126 + } else { + } + _ = tmp120 + var tmp127 any + var tmp128 any + { // let + // let binding "or__0__auto__" + var v129 any = v51 + _ = v129 + var tmp130 any + if lang.IsTruthy(v129) { + tmp130 = v129 + } else { + tmp131 := lang.Apply(kw_refer, []any{v84}) + tmp130 = tmp131 + } + tmp128 = tmp130 + } // end let + if lang.IsTruthy(tmp128) { + var tmp129 any + tmp130 := checkDerefVar(var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_) + if lang.IsTruthy(tmp130) { + tmp131 := checkDerefVar(var_glojure_DOT_core_printf) + tmp132 := lang.Apply(tmp131, []any{"(glojure.core/refer '%s", v16}) + _ = tmp132 + var tmp133 any + { // let + // let binding "seq_111" + tmp134 := checkDerefVar(var_glojure_DOT_core_seq) + tmp135 := lang.Apply(tmp134, []any{v84}) + var v136 any = tmp135 + _ = v136 + // let binding "chunk_112" + var v137 any = nil + _ = v137 + // let binding "count_113" + var v138 any = int64(0) + _ = v138 + // let binding "i_114" + var v139 any = int64(0) + _ = v139 + for { + var tmp140 any + tmp141 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp142 := lang.Apply(tmp141, []any{v139, v138}) + if lang.IsTruthy(tmp142) { + var tmp143 any + { // let + // let binding "opt" + tmp144, _ := lang.FieldOrMethod(v137, "nth") + if reflect.TypeOf(tmp144).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp145 := lang.Apply(tmp144, []any{v139}) + var v146 any = tmp145 + _ = v146 + tmp147 := checkDerefVar(var_glojure_DOT_core_printf) + tmp148 := checkDerefVar(var_glojure_DOT_core_key) + tmp149 := lang.Apply(tmp148, []any{v146}) + tmp150 := checkDerefVar(var_glojure_DOT_core_print_DASH_str) + tmp151 := checkDerefVar(var_glojure_DOT_core_val) + tmp152 := lang.Apply(tmp151, []any{v146}) + tmp153 := lang.Apply(tmp150, []any{tmp152}) + tmp154 := lang.Apply(tmp147, []any{" %s '%s", tmp149, tmp153}) + _ = tmp154 + var tmp155 any = v136 + var tmp156 any = v137 + var tmp157 any = v138 + tmp159 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp160 := lang.Apply(tmp159, []any{v139}) + var tmp158 any = tmp160 + v136 = tmp155 + v137 = tmp156 + v138 = tmp157 + v139 = tmp158 + continue + } // end let + tmp140 = tmp143 + } else { + var tmp144 any + { // let + // let binding "temp__0__auto__" + tmp145 := checkDerefVar(var_glojure_DOT_core_seq) + tmp146 := lang.Apply(tmp145, []any{v136}) + var v147 any = tmp146 + _ = v147 + var tmp148 any + if lang.IsTruthy(v147) { + var tmp149 any + { // let + // let binding "seq_111" + var v150 any = v147 + _ = v150 + var tmp151 any + tmp152 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp153 := lang.Apply(tmp152, []any{v150}) + if lang.IsTruthy(tmp153) { + var tmp154 any + { // let + // let binding "c__0__auto__" + tmp155 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp156 := lang.Apply(tmp155, []any{v150}) + var v157 any = tmp156 + _ = v157 + tmp159 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp160 := lang.Apply(tmp159, []any{v150}) + var tmp158 any = tmp160 + var tmp161 any = v157 + tmp163 := checkDerefVar(var_glojure_DOT_core_int) + tmp164 := checkDerefVar(var_glojure_DOT_core_count) + tmp165 := lang.Apply(tmp164, []any{v157}) + tmp166 := lang.Apply(tmp163, []any{tmp165}) + var tmp162 any = tmp166 + tmp168 := checkDerefVar(var_glojure_DOT_core_int) + tmp169 := lang.Apply(tmp168, []any{int64(0)}) + var tmp167 any = tmp169 + v136 = tmp158 + v137 = tmp161 + v138 = tmp162 + v139 = tmp167 + continue + } // end let + tmp151 = tmp154 + } else { + var tmp155 any + { // let + // let binding "opt" + tmp156 := checkDerefVar(var_glojure_DOT_core_first) + tmp157 := lang.Apply(tmp156, []any{v150}) + var v158 any = tmp157 + _ = v158 + tmp159 := checkDerefVar(var_glojure_DOT_core_printf) + tmp160 := checkDerefVar(var_glojure_DOT_core_key) + tmp161 := lang.Apply(tmp160, []any{v158}) + tmp162 := checkDerefVar(var_glojure_DOT_core_print_DASH_str) + tmp163 := checkDerefVar(var_glojure_DOT_core_val) + tmp164 := lang.Apply(tmp163, []any{v158}) + tmp165 := lang.Apply(tmp162, []any{tmp164}) + tmp166 := lang.Apply(tmp159, []any{" %s '%s", tmp161, tmp165}) + _ = tmp166 + tmp168 := checkDerefVar(var_glojure_DOT_core_next) + tmp169 := lang.Apply(tmp168, []any{v150}) + var tmp167 any = tmp169 + var tmp170 any = nil + var tmp171 any = int64(0) + var tmp172 any = int64(0) + v136 = tmp167 + v137 = tmp170 + v138 = tmp171 + v139 = tmp172 + continue + } // end let + tmp151 = tmp155 + } + tmp149 = tmp151 + } // end let + tmp148 = tmp149 + } else { + } + tmp144 = tmp148 + } // end let + tmp140 = tmp144 + } + tmp133 = tmp140 + break + } + } // end let + _ = tmp133 + tmp134 := checkDerefVar(var_glojure_DOT_core_printf) + tmp135 := lang.Apply(tmp134, []any{")\n"}) + tmp129 = tmp135 + } else { + } + _ = tmp129 + tmp136 := checkDerefVar(var_glojure_DOT_core_apply) + tmp137 := checkDerefVar(var_glojure_DOT_core_refer) + tmp138 := checkDerefVar(var_glojure_DOT_core_mapcat) + tmp139 := checkDerefVar(var_glojure_DOT_core_seq) + tmp140 := lang.Apply(tmp138, []any{tmp139, v84}) + tmp141 := lang.Apply(tmp136, []any{tmp137, v16, tmp140}) + tmp127 = tmp141 + } else { + } + tmp97 = tmp127 + }() + tmp90 = tmp97 + } // end let + tmp10 = tmp90 + } // end let + return tmp10 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_load_DASH_lib = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_load_DASH_lib.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } - tmp0 := sym_unchecked_DASH_negate_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns the negation of x, an int.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(26), kw_column, int(7), kw_line, int(1182), kw_end_DASH_line, int(1182))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_negate") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_negate is not a function"))) + } + // load-libs + { + tmp0 := sym_load_DASH_libs.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_args)), kw_doc, "Loads libs, interpreting libspecs, prefix lists, and flags for\n forwarding to load-lib", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(8), kw_line, int(5951), kw_end_DASH_line, int(5951), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + var tmp3 any + { // let + // let binding "flags" + tmp4 := checkDerefVar(var_glojure_DOT_core_filter) + tmp5 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp6 := lang.Apply(tmp4, []any{tmp5, v2}) + var v7 any = tmp6 + _ = v7 + // let binding "opts" + tmp8 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp9 := checkDerefVar(var_glojure_DOT_core_repeat) + tmp10 := lang.Apply(tmp9, []any{true}) + tmp11 := lang.Apply(tmp8, []any{v7, tmp10}) + var v12 any = tmp11 + _ = v12 + // let binding "args" + tmp13 := checkDerefVar(var_glojure_DOT_core_filter) + tmp14 := checkDerefVar(var_glojure_DOT_core_complement) + tmp15 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp16 := lang.Apply(tmp14, []any{tmp15}) + tmp17 := lang.Apply(tmp13, []any{tmp16, v2}) + var v18 any = tmp17 + _ = v18 + var tmp19 any + { // let + // let binding "supported" + tmp20 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{kw_as, kw_reload, kw_reload_DASH_all, kw_require, kw_use, kw_verbose, kw_refer, kw_as_DASH_alias})) + tmp21 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5959), kw_column, int(21), kw_end_DASH_line, int(5959), kw_end_DASH_column, int(86)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v23 any = tmp22 + _ = v23 + // let binding "unsupported" + tmp24 := checkDerefVar(var_glojure_DOT_core_seq) + tmp25 := checkDerefVar(var_glojure_DOT_core_remove) + tmp26 := lang.Apply(tmp25, []any{v23, v7}) + tmp27 := lang.Apply(tmp24, []any{tmp26}) + var v28 any = tmp27 + _ = v28 + tmp29 := checkDerefVar(var_glojure_DOT_core_throw_DASH_if) + tmp30 := checkDerefVar(var_glojure_DOT_core_apply) + tmp31 := checkDerefVar(var_glojure_DOT_core_str) + tmp32 := checkDerefVar(var_glojure_DOT_core_interpose) + tmp33 := lang.Apply(tmp32, []any{lang.NewChar(44), v28}) + tmp34 := lang.Apply(tmp30, []any{tmp31, "Unsupported option(s) supplied: ", tmp33}) + tmp35 := lang.Apply(tmp29, []any{v28, tmp34}) + tmp19 = tmp35 + } // end let + _ = tmp19 + tmp20 := checkDerefVar(var_glojure_DOT_core_throw_DASH_if) + tmp21 := checkDerefVar(var_glojure_DOT_core_not) + tmp22 := checkDerefVar(var_glojure_DOT_core_seq) + tmp23 := lang.Apply(tmp22, []any{v18}) + tmp24 := lang.Apply(tmp21, []any{tmp23}) + tmp25 := lang.Apply(tmp20, []any{tmp24, "Nothing specified to load"}) + _ = tmp25 + var tmp26 any + { // let + // let binding "seq_115" + tmp27 := checkDerefVar(var_glojure_DOT_core_seq) + tmp28 := lang.Apply(tmp27, []any{v18}) + var v29 any = tmp28 + _ = v29 + // let binding "chunk_116" + var v30 any = nil + _ = v30 + // let binding "count_117" + var v31 any = int64(0) + _ = v31 + // let binding "i_118" + var v32 any = int64(0) + _ = v32 + for { + var tmp33 any + tmp34 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp35 := lang.Apply(tmp34, []any{v32, v31}) + if lang.IsTruthy(tmp35) { + var tmp36 any + { // let + // let binding "arg" + tmp37, _ := lang.FieldOrMethod(v30, "nth") + if reflect.TypeOf(tmp37).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp38 := lang.Apply(tmp37, []any{v32}) + var v39 any = tmp38 + _ = v39 + var tmp40 any + tmp41 := checkDerefVar(var_glojure_DOT_core_libspec_QMARK_) + tmp42 := lang.Apply(tmp41, []any{v39}) + if lang.IsTruthy(tmp42) { + tmp43 := checkDerefVar(var_glojure_DOT_core_apply) + tmp44 := checkDerefVar(var_glojure_DOT_core_load_DASH_lib) + tmp45 := checkDerefVar(var_glojure_DOT_core_prependss) + tmp46 := lang.Apply(tmp45, []any{v39, v12}) + tmp47 := lang.Apply(tmp43, []any{tmp44, nil, tmp46}) + tmp40 = tmp47 + } else { + var tmp48 any + { // let + // let binding "vec__119" + var v49 any = v39 + _ = v49 + // let binding "seq__120" + tmp50 := checkDerefVar(var_glojure_DOT_core_seq) + tmp51 := lang.Apply(tmp50, []any{v49}) + var v52 any = tmp51 + _ = v52 + // let binding "first__121" + tmp53 := checkDerefVar(var_glojure_DOT_core_first) + tmp54 := lang.Apply(tmp53, []any{v52}) + var v55 any = tmp54 + _ = v55 + // let binding "seq__120" + tmp56 := checkDerefVar(var_glojure_DOT_core_next) + tmp57 := lang.Apply(tmp56, []any{v52}) + var v58 any = tmp57 + _ = v58 + // let binding "prefix" + var v59 any = v55 + _ = v59 + // let binding "args" + var v60 any = v58 + _ = v60 + tmp61 := checkDerefVar(var_glojure_DOT_core_throw_DASH_if) + tmp62 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp63 := lang.Apply(tmp62, []any{v59}) + tmp64 := lang.Apply(tmp61, []any{tmp63, "prefix cannot be nil"}) + _ = tmp64 + var tmp65 any + { // let + // let binding "seq_122" + tmp66 := checkDerefVar(var_glojure_DOT_core_seq) + tmp67 := lang.Apply(tmp66, []any{v60}) + var v68 any = tmp67 + _ = v68 + // let binding "chunk_123" + var v69 any = nil + _ = v69 + // let binding "count_124" + var v70 any = int64(0) + _ = v70 + // let binding "i_125" + var v71 any = int64(0) + _ = v71 + for { + var tmp72 any + tmp73 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp74 := lang.Apply(tmp73, []any{v71, v70}) + if lang.IsTruthy(tmp74) { + var tmp75 any + { // let + // let binding "arg" + tmp76, _ := lang.FieldOrMethod(v69, "nth") + if reflect.TypeOf(tmp76).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp77 := lang.Apply(tmp76, []any{v71}) + var v78 any = tmp77 + _ = v78 + tmp79 := checkDerefVar(var_glojure_DOT_core_apply) + tmp80 := checkDerefVar(var_glojure_DOT_core_load_DASH_lib) + tmp81 := checkDerefVar(var_glojure_DOT_core_prependss) + tmp82 := lang.Apply(tmp81, []any{v78, v12}) + tmp83 := lang.Apply(tmp79, []any{tmp80, v59, tmp82}) + _ = tmp83 + var tmp84 any = v68 + var tmp85 any = v69 + var tmp86 any = v70 + tmp88 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp89 := lang.Apply(tmp88, []any{v71}) + var tmp87 any = tmp89 + v68 = tmp84 + v69 = tmp85 + v70 = tmp86 + v71 = tmp87 + continue + } // end let + tmp72 = tmp75 + } else { + var tmp76 any + { // let + // let binding "temp__0__auto__" + tmp77 := checkDerefVar(var_glojure_DOT_core_seq) + tmp78 := lang.Apply(tmp77, []any{v68}) + var v79 any = tmp78 + _ = v79 + var tmp80 any + if lang.IsTruthy(v79) { + var tmp81 any + { // let + // let binding "seq_122" + var v82 any = v79 + _ = v82 + var tmp83 any + tmp84 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp85 := lang.Apply(tmp84, []any{v82}) + if lang.IsTruthy(tmp85) { + var tmp86 any + { // let + // let binding "c__0__auto__" + tmp87 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp88 := lang.Apply(tmp87, []any{v82}) + var v89 any = tmp88 + _ = v89 + tmp91 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp92 := lang.Apply(tmp91, []any{v82}) + var tmp90 any = tmp92 + var tmp93 any = v89 + tmp95 := checkDerefVar(var_glojure_DOT_core_int) + tmp96 := checkDerefVar(var_glojure_DOT_core_count) + tmp97 := lang.Apply(tmp96, []any{v89}) + tmp98 := lang.Apply(tmp95, []any{tmp97}) + var tmp94 any = tmp98 + tmp100 := checkDerefVar(var_glojure_DOT_core_int) + tmp101 := lang.Apply(tmp100, []any{int64(0)}) + var tmp99 any = tmp101 + v68 = tmp90 + v69 = tmp93 + v70 = tmp94 + v71 = tmp99 + continue + } // end let + tmp83 = tmp86 + } else { + var tmp87 any + { // let + // let binding "arg" + tmp88 := checkDerefVar(var_glojure_DOT_core_first) + tmp89 := lang.Apply(tmp88, []any{v82}) + var v90 any = tmp89 + _ = v90 + tmp91 := checkDerefVar(var_glojure_DOT_core_apply) + tmp92 := checkDerefVar(var_glojure_DOT_core_load_DASH_lib) + tmp93 := checkDerefVar(var_glojure_DOT_core_prependss) + tmp94 := lang.Apply(tmp93, []any{v90, v12}) + tmp95 := lang.Apply(tmp91, []any{tmp92, v59, tmp94}) + _ = tmp95 + tmp97 := checkDerefVar(var_glojure_DOT_core_next) + tmp98 := lang.Apply(tmp97, []any{v82}) + var tmp96 any = tmp98 + var tmp99 any = nil + var tmp100 any = int64(0) + var tmp101 any = int64(0) + v68 = tmp96 + v69 = tmp99 + v70 = tmp100 + v71 = tmp101 + continue + } // end let + tmp83 = tmp87 + } + tmp81 = tmp83 + } // end let + tmp80 = tmp81 + } else { + } + tmp76 = tmp80 + } // end let + tmp72 = tmp76 + } + tmp65 = tmp72 + break + } + } // end let + tmp48 = tmp65 + } // end let + tmp40 = tmp48 + } + _ = tmp40 + var tmp49 any = v29 + var tmp50 any = v30 + var tmp51 any = v31 + tmp53 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp54 := lang.Apply(tmp53, []any{v32}) + var tmp52 any = tmp54 + v29 = tmp49 + v30 = tmp50 + v31 = tmp51 + v32 = tmp52 + continue + } // end let + tmp33 = tmp36 + } else { + var tmp37 any + { // let + // let binding "temp__0__auto__" + tmp38 := checkDerefVar(var_glojure_DOT_core_seq) + tmp39 := lang.Apply(tmp38, []any{v29}) + var v40 any = tmp39 + _ = v40 + var tmp41 any + if lang.IsTruthy(v40) { + var tmp42 any + { // let + // let binding "seq_115" + var v43 any = v40 + _ = v43 + var tmp44 any + tmp45 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp46 := lang.Apply(tmp45, []any{v43}) + if lang.IsTruthy(tmp46) { + var tmp47 any + { // let + // let binding "c__0__auto__" + tmp48 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp49 := lang.Apply(tmp48, []any{v43}) + var v50 any = tmp49 + _ = v50 + tmp52 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp53 := lang.Apply(tmp52, []any{v43}) + var tmp51 any = tmp53 + var tmp54 any = v50 + tmp56 := checkDerefVar(var_glojure_DOT_core_int) + tmp57 := checkDerefVar(var_glojure_DOT_core_count) + tmp58 := lang.Apply(tmp57, []any{v50}) + tmp59 := lang.Apply(tmp56, []any{tmp58}) + var tmp55 any = tmp59 + tmp61 := checkDerefVar(var_glojure_DOT_core_int) + tmp62 := lang.Apply(tmp61, []any{int64(0)}) + var tmp60 any = tmp62 + v29 = tmp51 + v30 = tmp54 + v31 = tmp55 + v32 = tmp60 + continue + } // end let + tmp44 = tmp47 + } else { + var tmp48 any + { // let + // let binding "arg" + tmp49 := checkDerefVar(var_glojure_DOT_core_first) + tmp50 := lang.Apply(tmp49, []any{v43}) + var v51 any = tmp50 + _ = v51 + var tmp52 any + tmp53 := checkDerefVar(var_glojure_DOT_core_libspec_QMARK_) + tmp54 := lang.Apply(tmp53, []any{v51}) + if lang.IsTruthy(tmp54) { + tmp55 := checkDerefVar(var_glojure_DOT_core_apply) + tmp56 := checkDerefVar(var_glojure_DOT_core_load_DASH_lib) + tmp57 := checkDerefVar(var_glojure_DOT_core_prependss) + tmp58 := lang.Apply(tmp57, []any{v51, v12}) + tmp59 := lang.Apply(tmp55, []any{tmp56, nil, tmp58}) + tmp52 = tmp59 + } else { + var tmp60 any + { // let + // let binding "vec__126" + var v61 any = v51 + _ = v61 + // let binding "seq__127" + tmp62 := checkDerefVar(var_glojure_DOT_core_seq) + tmp63 := lang.Apply(tmp62, []any{v61}) + var v64 any = tmp63 + _ = v64 + // let binding "first__128" + tmp65 := checkDerefVar(var_glojure_DOT_core_first) + tmp66 := lang.Apply(tmp65, []any{v64}) + var v67 any = tmp66 + _ = v67 + // let binding "seq__127" + tmp68 := checkDerefVar(var_glojure_DOT_core_next) + tmp69 := lang.Apply(tmp68, []any{v64}) + var v70 any = tmp69 + _ = v70 + // let binding "prefix" + var v71 any = v67 + _ = v71 + // let binding "args" + var v72 any = v70 + _ = v72 + tmp73 := checkDerefVar(var_glojure_DOT_core_throw_DASH_if) + tmp74 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp75 := lang.Apply(tmp74, []any{v71}) + tmp76 := lang.Apply(tmp73, []any{tmp75, "prefix cannot be nil"}) + _ = tmp76 + var tmp77 any + { // let + // let binding "seq_129" + tmp78 := checkDerefVar(var_glojure_DOT_core_seq) + tmp79 := lang.Apply(tmp78, []any{v72}) + var v80 any = tmp79 + _ = v80 + // let binding "chunk_130" + var v81 any = nil + _ = v81 + // let binding "count_131" + var v82 any = int64(0) + _ = v82 + // let binding "i_132" + var v83 any = int64(0) + _ = v83 + for { + var tmp84 any + tmp85 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp86 := lang.Apply(tmp85, []any{v83, v82}) + if lang.IsTruthy(tmp86) { + var tmp87 any + { // let + // let binding "arg" + tmp88, _ := lang.FieldOrMethod(v81, "nth") + if reflect.TypeOf(tmp88).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp89 := lang.Apply(tmp88, []any{v83}) + var v90 any = tmp89 + _ = v90 + tmp91 := checkDerefVar(var_glojure_DOT_core_apply) + tmp92 := checkDerefVar(var_glojure_DOT_core_load_DASH_lib) + tmp93 := checkDerefVar(var_glojure_DOT_core_prependss) + tmp94 := lang.Apply(tmp93, []any{v90, v12}) + tmp95 := lang.Apply(tmp91, []any{tmp92, v71, tmp94}) + _ = tmp95 + var tmp96 any = v80 + var tmp97 any = v81 + var tmp98 any = v82 + tmp100 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp101 := lang.Apply(tmp100, []any{v83}) + var tmp99 any = tmp101 + v80 = tmp96 + v81 = tmp97 + v82 = tmp98 + v83 = tmp99 + continue + } // end let + tmp84 = tmp87 + } else { + var tmp88 any + { // let + // let binding "temp__0__auto__" + tmp89 := checkDerefVar(var_glojure_DOT_core_seq) + tmp90 := lang.Apply(tmp89, []any{v80}) + var v91 any = tmp90 + _ = v91 + var tmp92 any + if lang.IsTruthy(v91) { + var tmp93 any + { // let + // let binding "seq_129" + var v94 any = v91 + _ = v94 + var tmp95 any + tmp96 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp97 := lang.Apply(tmp96, []any{v94}) + if lang.IsTruthy(tmp97) { + var tmp98 any + { // let + // let binding "c__0__auto__" + tmp99 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp100 := lang.Apply(tmp99, []any{v94}) + var v101 any = tmp100 + _ = v101 + tmp103 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp104 := lang.Apply(tmp103, []any{v94}) + var tmp102 any = tmp104 + var tmp105 any = v101 + tmp107 := checkDerefVar(var_glojure_DOT_core_int) + tmp108 := checkDerefVar(var_glojure_DOT_core_count) + tmp109 := lang.Apply(tmp108, []any{v101}) + tmp110 := lang.Apply(tmp107, []any{tmp109}) + var tmp106 any = tmp110 + tmp112 := checkDerefVar(var_glojure_DOT_core_int) + tmp113 := lang.Apply(tmp112, []any{int64(0)}) + var tmp111 any = tmp113 + v80 = tmp102 + v81 = tmp105 + v82 = tmp106 + v83 = tmp111 + continue + } // end let + tmp95 = tmp98 + } else { + var tmp99 any + { // let + // let binding "arg" + tmp100 := checkDerefVar(var_glojure_DOT_core_first) + tmp101 := lang.Apply(tmp100, []any{v94}) + var v102 any = tmp101 + _ = v102 + tmp103 := checkDerefVar(var_glojure_DOT_core_apply) + tmp104 := checkDerefVar(var_glojure_DOT_core_load_DASH_lib) + tmp105 := checkDerefVar(var_glojure_DOT_core_prependss) + tmp106 := lang.Apply(tmp105, []any{v102, v12}) + tmp107 := lang.Apply(tmp103, []any{tmp104, v71, tmp106}) + _ = tmp107 + tmp109 := checkDerefVar(var_glojure_DOT_core_next) + tmp110 := lang.Apply(tmp109, []any{v94}) + var tmp108 any = tmp110 + var tmp111 any = nil + var tmp112 any = int64(0) + var tmp113 any = int64(0) + v80 = tmp108 + v81 = tmp111 + v82 = tmp112 + v83 = tmp113 + continue + } // end let + tmp95 = tmp99 + } + tmp93 = tmp95 + } // end let + tmp92 = tmp93 + } else { + } + tmp88 = tmp92 + } // end let + tmp84 = tmp88 + } + tmp77 = tmp84 + break + } + } // end let + tmp60 = tmp77 + } // end let + tmp52 = tmp60 + } + _ = tmp52 + tmp62 := checkDerefVar(var_glojure_DOT_core_next) + tmp63 := lang.Apply(tmp62, []any{v43}) + var tmp61 any = tmp63 + var tmp64 any = nil + var tmp65 any = int64(0) + var tmp66 any = int64(0) + v29 = tmp61 + v30 = tmp64 + v31 = tmp65 + v32 = tmp66 + continue + } // end let + tmp44 = tmp48 + } + tmp42 = tmp44 + } // end let + tmp41 = tmp42 + } else { + } + tmp37 = tmp41 + } // end let + tmp33 = tmp37 + } + tmp26 = tmp33 + break + } + } // end let + tmp3 = tmp26 + } // end let + return tmp3 } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_load_DASH_libs = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_load_DASH_libs.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // unchecked-remainder-int + // require { + tmp0 := sym_require.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_args)), kw_doc, "Loads libs, skipping any that are already loaded. Each argument is\n either a libspec that identifies a lib, a prefix list that identifies\n multiple libs whose names share a common prefix, or a flag that modifies\n how all the identified libs are loaded. Use :require in the ns macro\n in preference to calling this directly.\n\n Libs\n\n A 'lib' is a named set of resources in classpath whose contents define a\n library of Clojure code. Lib names are symbols and each lib is associated\n with a Clojure namespace and a Java package that share its name. A lib's\n name also locates its root directory within classpath using Java's\n package name to classpath-relative path mapping. All resources in a lib\n should be contained in the directory structure under its root directory.\n All definitions a lib makes should be in its associated namespace.\n\n 'require loads a lib by loading its root resource. The root resource path\n is derived from the lib name in the following manner:\n Consider a lib named by the symbol 'x.y.z; it has the root directory\n /x/y/, and its root resource is /x/y/z.clj, or\n /x/y/z.cljc if /x/y/z.clj does not exist. The\n root resource should contain code to create the lib's\n namespace (usually by using the ns macro) and load any additional\n lib resources.\n\n Libspecs\n\n A libspec is a lib name or a vector containing a lib name followed by\n options expressed as sequential keywords and arguments.\n\n Recognized options:\n :as takes a symbol as its argument and makes that symbol an alias to the\n lib's namespace in the current namespace.\n :as-alias takes a symbol as its argument and aliases like :as, however\n the lib will not be loaded. If the lib has not been loaded, a new\n empty namespace will be created (as with create-ns).\n :refer takes a list of symbols to refer from the namespace or the :all\n keyword to bring in all public vars.\n\n Prefix Lists\n\n It's common for Clojure code to depend on several libs whose names have\n the same prefix. When specifying libs, prefix lists can be used to reduce\n repetition. A prefix list contains the shared prefix followed by libspecs\n with the shared prefix removed from the lib names. After removing the\n prefix, the names that remain must not contain any periods.\n\n Flags\n\n A flag is a keyword.\n Recognized flags: :reload, :reload-all, :verbose\n :reload forces loading of all the identified libs even if they are\n already loaded (has no effect on libspecs using :as-alias)\n :reload-all implies :reload and also forces loading of all libs that the\n identified libs directly or indirectly load via require or use\n (has no effect on libspecs using :as-alias)\n :verbose triggers printing information about each load, alias, and refer\n\n Example:\n\n The following would load the libraries glojure.zip and glojure.set\n abbreviated as 's'.\n\n (require '(glojure zip [set :as s]))", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(5989), kw_end_DASH_line, int(5989))).(*lang.Symbol) var tmp1 lang.FnFunc - { // function unchecked-remainder-int__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_seq) - tmp6 := checkDerefVar(var_glojure_DOT_core_concat) - tmp7 := checkDerefVar(var_glojure_DOT_core_list) - tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) - tmp9 := checkDerefVar(var_glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp11 := checkDerefVar(var_glojure_DOT_core_list) - tmp12 := checkDerefVar(var_glojure_DOT_core_seq) - tmp13 := checkDerefVar(var_glojure_DOT_core_concat) - tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_remainder}) - tmp16 := checkDerefVar(var_glojure_DOT_core_list) - tmp17 := lang.Apply(tmp16, []any{v3}) - tmp18 := checkDerefVar(var_glojure_DOT_core_list) - tmp19 := lang.Apply(tmp18, []any{v4}) - tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) - tmp21 := lang.Apply(tmp12, []any{tmp20}) - tmp22 := lang.Apply(tmp11, []any{tmp21}) - tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) - tmp24 := lang.Apply(tmp5, []any{tmp23}) - return tmp24 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := sym_unchecked_DASH_remainder_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Returns the remainder of division of x by y, both int.\n Note - uses a primitive operator subject to truncation.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(29), kw_column, int(7), kw_line, int(1245), kw_end_DASH_line, int(1245))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_remainder") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_remainder is not a function"))) + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_apply) + tmp4 := checkDerefVar(var_glojure_DOT_core_load_DASH_libs) + tmp5 := lang.Apply(tmp3, []any{tmp4, kw_require, v2}) + return tmp5 } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_require = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_require.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // unchecked-short + // serialized-require { + tmp0 := sym_serialized_DASH_require.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_args)), kw_doc, "Like 'require', but serializes loading.\n Interim function preferred over 'require' for known asynchronous loads.\n Future changes may make these equivalent.", kw_file, "glojure/core.glj", kw_added, "1.10", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(25), kw_column, int(8), kw_line, int(6059), kw_end_DASH_line, int(6059), kw_private, true)).(*lang.Symbol) var tmp1 lang.FnFunc - { // function unchecked-short__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_seq) - tmp5 := checkDerefVar(var_glojure_DOT_core_concat) - tmp6 := checkDerefVar(var_glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) - tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := checkDerefVar(var_glojure_DOT_core_seq) - tmp12 := checkDerefVar(var_glojure_DOT_core_concat) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedShortCast}) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{v3}) - tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) - tmp18 := lang.Apply(tmp11, []any{tmp17}) - tmp19 := lang.Apply(tmp10, []any{tmp18}) - tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) - tmp21 := lang.Apply(tmp4, []any{tmp20}) - return tmp21 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := sym_unchecked_DASH_short.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to short. Subject to rounding or truncation.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(3523), kw_end_DASH_line, int(3523))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5 := lang.Apply(lang.UncheckedShortCast, []any{v4}) - return tmp5 + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + var tmp3 any + { // let + // let binding "lockee__0__auto__" + var v4 any = nil + _ = v4 + var tmp5 any + func() { + var tmp6 any + { // let + // let binding "locklocal__1__auto__" + var v7 any = v4 + _ = v7 + tmp8 := lang.Apply(nil, []any{v7}) + _ = tmp8 + var tmp9 any + func() { + defer func() { + tmp10 := lang.Apply(nil, []any{v7}) + _ = tmp10 + }() + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + tmp12 := checkDerefVar(var_glojure_DOT_core_require) + tmp13 := lang.Apply(tmp11, []any{tmp12, v2}) + tmp9 = tmp13 + }() + tmp6 = tmp9 + } // end let + tmp5 = tmp6 + }() + tmp3 = tmp5 + } // end let + return tmp3 + } }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_serialized_DASH_require = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_serialized_DASH_require.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // unchecked-subtract + // use { + tmp0 := sym_use.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_args)), kw_doc, "Like 'require, but also refers to each lib's namespace using\n glojure.core/refer. Use :use in the ns macro in preference to calling\n this directly.\n\n 'use accepts additional options in libspecs: :exclude, :only, :rename.\n The arguments and semantics for :exclude, :only, and :rename are the same\n as those documented for glojure.core/refer.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(6079), kw_end_DASH_line, int(6079))).(*lang.Symbol) var tmp1 lang.FnFunc - { // function unchecked-subtract__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_seq) - tmp6 := checkDerefVar(var_glojure_DOT_core_concat) - tmp7 := checkDerefVar(var_glojure_DOT_core_list) - tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) - tmp9 := checkDerefVar(var_glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp11 := checkDerefVar(var_glojure_DOT_core_list) - tmp12 := checkDerefVar(var_glojure_DOT_core_seq) - tmp13 := checkDerefVar(var_glojure_DOT_core_concat) - tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_minus}) - tmp16 := checkDerefVar(var_glojure_DOT_core_list) - tmp17 := lang.Apply(tmp16, []any{v3}) - tmp18 := checkDerefVar(var_glojure_DOT_core_list) - tmp19 := lang.Apply(tmp18, []any{v4}) - tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) - tmp21 := lang.Apply(tmp12, []any{tmp20}) - tmp22 := lang.Apply(tmp11, []any{tmp21}) - tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) - tmp24 := lang.Apply(tmp5, []any{tmp23}) - return tmp24 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := sym_unchecked_DASH_subtract.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Returns the difference of x and y, both long.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(24), kw_column, int(7), kw_line, int(1217), kw_end_DASH_line, int(1217))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_minus") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_minus is not a function"))) + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_apply) + tmp4 := checkDerefVar(var_glojure_DOT_core_load_DASH_libs) + tmp5 := lang.Apply(tmp3, []any{tmp4, kw_require, kw_use, v2}) + return tmp5 } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_use = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_use.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // unchecked-subtract-int + // requiring-resolve { + tmp0 := sym_requiring_DASH_resolve.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_sym)), kw_doc, "Resolves namespace-qualified sym per 'resolve'. If initial resolve\nfails, attempts to require sym's namespace and retries.", kw_file, "glojure/core.glj", kw_added, "1.10", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(7), kw_line, int(6068), kw_end_DASH_line, int(6068))).(*lang.Symbol) var tmp1 lang.FnFunc - { // function unchecked-subtract-int__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_seq) - tmp6 := checkDerefVar(var_glojure_DOT_core_concat) - tmp7 := checkDerefVar(var_glojure_DOT_core_list) - tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) - tmp9 := checkDerefVar(var_glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp11 := checkDerefVar(var_glojure_DOT_core_list) - tmp12 := checkDerefVar(var_glojure_DOT_core_seq) - tmp13 := checkDerefVar(var_glojure_DOT_core_concat) - tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_subtract}) - tmp16 := checkDerefVar(var_glojure_DOT_core_list) - tmp17 := lang.Apply(tmp16, []any{v3}) - tmp18 := checkDerefVar(var_glojure_DOT_core_list) - tmp19 := lang.Apply(tmp18, []any{v4}) - tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) - tmp21 := lang.Apply(tmp12, []any{tmp20}) - tmp22 := lang.Apply(tmp11, []any{tmp21}) - tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) - tmp24 := lang.Apply(tmp5, []any{tmp23}) - return tmp24 - }) - v2 = tmp1 + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] _ = v2 - } - tmp0 := sym_unchecked_DASH_subtract_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Returns the difference of x and y, both int.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(28), kw_column, int(7), kw_line, int(1210), kw_end_DASH_line, int(1210))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_subtract") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_subtract is not a function"))) + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_qualified_DASH_symbol_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + var tmp6 any + { // let + // let binding "or__0__auto__" + tmp7 := checkDerefVar(var_glojure_DOT_core_resolve) + tmp8 := lang.Apply(tmp7, []any{v2}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + tmp10 = v9 + } else { + tmp11 := checkDerefVar(var_glojure_DOT_core_serialized_DASH_require) + tmp12 := checkDerefVar(var_glojure_DOT_core_symbol) + tmp13 := checkDerefVar(var_glojure_DOT_core_namespace) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(tmp12, []any{tmp14}) + tmp16 := lang.Apply(tmp11, []any{tmp15}) + _ = tmp16 + tmp17 := checkDerefVar(var_glojure_DOT_core_resolve) + tmp18 := lang.Apply(tmp17, []any{v2}) + tmp10 = tmp18 + } + tmp6 = tmp10 + } // end let + tmp3 = tmp6 + } else { + tmp7 := checkDerefVar(var_glojure_DOT_core_str) + tmp8 := lang.Apply(tmp7, []any{"Not a qualified symbol: ", v2}) + tmp9 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp8}) + panic(tmp9) } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 + return tmp3 }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_requiring_DASH_resolve = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_requiring_DASH_resolve.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // underive + // mapv { - tmp0 := sym_underive.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_tag, sym_parent), lang.NewVector(sym_h, sym_tag, sym_parent)), kw_doc, "Removes a parent/child relationship between parent and\n tag. h must be a hierarchy obtained from make-hierarchy, if not\n supplied defaults to, and modifies, the global hierarchy.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(5643), kw_end_DASH_line, int(5643))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_mapv.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_coll), lang.NewVector(sym_f, sym_c1, sym_c2), lang.NewVector(sym_f, sym_c1, sym_c2, sym_c3), lang.NewVector(sym_f, sym_c1, sym_c2, sym_c3, sym__AMP_, sym_colls)), kw_doc, "Returns a vector consisting of the result of applying f to the\n set of first items of each coll, followed by applying f to the set\n of second items in each coll, until any one of the colls is\n exhausted. Any remaining items in other colls are ignored. Function\n f should accept number-of-colls arguments.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.4", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(6943), kw_end_DASH_line, int(6943))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 2: - v3 := args[0] + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_alter_DASH_var_DASH_root) - tmp6 := lang.InternVarName(sym_glojure_DOT_core, sym_global_DASH_hierarchy) - tmp7 := checkDerefVar(var_glojure_DOT_core_underive) - tmp8 := lang.Apply(tmp5, []any{tmp6, tmp7, v3, v4}) - _ = tmp8 - return nil + tmp4 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp5 := checkDerefVar(var_glojure_DOT_core_reduce) + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_conj_BANG_) + tmp10 := lang.Apply(v2, []any{v8}) + tmp11 := lang.Apply(tmp9, []any{v7, tmp10}) + return tmp11 + }) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6952), kw_column, int(18), kw_end_DASH_line, int(6952), kw_end_DASH_column, int(43)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp9 := checkDerefVar(var_glojure_DOT_core_transient) + tmp10 := lang.NewVector() + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6952), kw_column, int(56), kw_end_DASH_line, int(6952), kw_end_DASH_column, int(57)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := lang.Apply(tmp9, []any{tmp12}) + tmp14 := lang.Apply(tmp5, []any{tmp8, tmp13, v3}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 case 3: - v3 := args[0] + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + v4 := args[2] _ = v4 - v5 := args[2] + tmp5 := checkDerefVar(var_glojure_DOT_core_into) + tmp6 := lang.NewVector() + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6955), kw_column, int(12), kw_end_DASH_line, int(6955), kw_end_DASH_column, int(13)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp9 := checkDerefVar(var_glojure_DOT_core_map) + tmp10 := lang.Apply(tmp9, []any{v2, v3, v4}) + tmp11 := lang.Apply(tmp5, []any{tmp8, tmp10}) + return tmp11 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] _ = v5 - var tmp6 any - { // let - // let binding "parentMap" - tmp7 := lang.Apply(kw_parents, []any{v3}) - var v8 any = tmp7 - _ = v8 - // let binding "childsParents" - var tmp9 any - tmp10 := lang.Apply(v8, []any{v4}) - if lang.IsTruthy(tmp10) { - tmp11 := checkDerefVar(var_glojure_DOT_core_disj) - tmp12 := lang.Apply(v8, []any{v4}) - tmp13 := lang.Apply(tmp11, []any{tmp12, v5}) - tmp9 = tmp13 - } else { - tmp14 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) - tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5652), kw_column, int(36), kw_end_DASH_line, int(5652), kw_end_DASH_column, int(38)) - tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp9 = tmp16 - } - var v17 any = tmp9 - _ = v17 - // let binding "newParents" - var tmp18 any - tmp19 := checkDerefVar(var_glojure_DOT_core_not_DASH_empty) - tmp20 := lang.Apply(tmp19, []any{v17}) - if lang.IsTruthy(tmp20) { - tmp21 := checkDerefVar(var_glojure_DOT_core_assoc) - tmp22 := lang.Apply(tmp21, []any{v8, v4, v17}) - tmp18 = tmp22 - } else { - tmp23 := checkDerefVar(var_glojure_DOT_core_dissoc) - tmp24 := lang.Apply(tmp23, []any{v8, v4}) - tmp18 = tmp24 - } - var v25 any = tmp18 - _ = v25 - // let binding "deriv-seq" - tmp26 := checkDerefVar(var_glojure_DOT_core_flatten) - tmp27 := checkDerefVar(var_glojure_DOT_core_map) - var tmp28 lang.FnFunc - tmp28 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v29 := args[0] - _ = v29 - tmp30 := checkDerefVar(var_glojure_DOT_core_cons) - tmp31 := checkDerefVar(var_glojure_DOT_core_key) - tmp32 := lang.Apply(tmp31, []any{v29}) - tmp33 := checkDerefVar(var_glojure_DOT_core_interpose) - tmp34 := checkDerefVar(var_glojure_DOT_core_key) - tmp35 := lang.Apply(tmp34, []any{v29}) - tmp36 := checkDerefVar(var_glojure_DOT_core_val) - tmp37 := lang.Apply(tmp36, []any{v29}) - tmp38 := lang.Apply(tmp33, []any{tmp35, tmp37}) - tmp39 := lang.Apply(tmp30, []any{tmp32, tmp38}) - return tmp39 - }) - tmp29 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5656), kw_column, int(28), kw_end_DASH_line, int(5656), kw_end_DASH_column, int(70)) - tmp30, err := lang.WithMeta(tmp28, tmp29.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp31 := checkDerefVar(var_glojure_DOT_core_seq) - tmp32 := lang.Apply(tmp31, []any{v25}) - tmp33 := lang.Apply(tmp27, []any{tmp30, tmp32}) - tmp34 := lang.Apply(tmp26, []any{tmp33}) - var v35 any = tmp34 - _ = v35 - var tmp36 any - tmp37 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) - tmp38 := lang.Apply(v8, []any{v4}) - tmp39 := lang.Apply(tmp37, []any{tmp38, v5}) - if lang.IsTruthy(tmp39) { - tmp40 := checkDerefVar(var_glojure_DOT_core_reduce1) - var tmp41 lang.FnFunc - tmp41 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v42 := args[0] - _ = v42 - v43 := args[1] - _ = v43 - tmp44 := checkDerefVar(var_glojure_DOT_core_apply) - tmp45 := checkDerefVar(var_glojure_DOT_core_derive) - tmp46 := lang.Apply(tmp44, []any{tmp45, v42, v43}) - return tmp46 - }) - tmp42 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5659), kw_column, int(11), kw_end_DASH_line, int(5659), kw_end_DASH_column, int(31)) - tmp43, err := lang.WithMeta(tmp41, tmp42.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp44 := checkDerefVar(var_glojure_DOT_core_make_DASH_hierarchy) - tmp45 := lang.Apply(tmp44, nil) - tmp46 := checkDerefVar(var_glojure_DOT_core_partition) - tmp47 := lang.Apply(tmp46, []any{int64(2), v35}) - tmp48 := lang.Apply(tmp40, []any{tmp43, tmp45, tmp47}) - tmp36 = tmp48 - } else { - tmp36 = v3 - } - tmp6 = tmp36 - } // end let - return tmp6 + tmp6 := checkDerefVar(var_glojure_DOT_core_into) + tmp7 := lang.NewVector() + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6957), kw_column, int(12), kw_end_DASH_line, int(6957), kw_end_DASH_column, int(13)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp10 := checkDerefVar(var_glojure_DOT_core_map) + tmp11 := lang.Apply(tmp10, []any{v2, v3, v4, v5}) + tmp12 := lang.Apply(tmp6, []any{tmp9, tmp11}) + return tmp12 default: - checkArity(args, -1) - panic("unreachable") + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var v6 any = lang.NewList(args[4:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_into) + tmp8 := lang.NewVector() + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6959), kw_column, int(12), kw_end_DASH_line, int(6959), kw_end_DASH_column, int(13)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + tmp12 := checkDerefVar(var_glojure_DOT_core_map) + tmp13 := lang.Apply(tmp11, []any{tmp12, v2, v3, v4, v5, v6}) + tmp14 := lang.Apply(tmp7, []any{tmp10, tmp13}) + return tmp14 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_mapv = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_mapv.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // unquote + // newline { - tmp0 := sym_unquote.WithMeta(lang.NewMap()).(*lang.Symbol) - tmp1 := ns.Intern(tmp0) + tmp0 := sym_newline.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Writes a platform-specific newline to *out*", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(3698), kw_end_DASH_line, int(3698))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp2 := checkDerefVar(var_glojure_DOT_core__STAR_out_STAR_) + tmp3 := checkDerefVar(var_glojure_DOT_core_system_DASH_newline) + tmp4 := lang.Apply(lang.AppendWriter, []any{tmp2, tmp3}) + _ = tmp4 + return nil + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_newline = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_newline.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // unquote-splicing + // normalize-slurp-opts { - tmp0 := sym_unquote_DASH_splicing.WithMeta(lang.NewMap()).(*lang.Symbol) - tmp1 := ns.Intern(tmp0) + tmp0 := sym_normalize_DASH_slurp_DASH_opts.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6974), kw_column, int(8), kw_end_DASH_line, int(6974), kw_end_DASH_column, int(27), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_opts)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_first) + tmp6 := lang.Apply(tmp5, []any{v2}) + tmp7 := lang.Apply(tmp4, []any{tmp6}) + if lang.IsTruthy(tmp7) { + tmp8 := checkDerefVar(var_glojure_DOT_core_println) + tmp9 := lang.Apply(tmp8, []any{"WARNING: (slurp f enc) is deprecated, use (slurp f :encoding enc)."}) + _ = tmp9 + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := lang.NewVector(kw_encoding, tmp11) + tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6979), kw_column, int(7), kw_end_DASH_line, int(6979), kw_end_DASH_column, int(30)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp3 = tmp14 + } else { + tmp3 = v2 + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_normalize_DASH_slurp_DASH_opts = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_normalize_DASH_slurp_DASH_opts.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // unreduced + // pr { - tmp0 := sym_unreduced.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "If x is reduced?, returns (deref x), else returns x", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(2847), kw_end_DASH_line, int(2847))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) - tmp6 := lang.Apply(tmp5, []any{v3}) - if lang.IsTruthy(tmp6) { - tmp7 := checkDerefVar(var_glojure_DOT_core_deref) - tmp8 := lang.Apply(tmp7, []any{v3}) - tmp4 = tmp8 - } else { - tmp4 = v3 + tmp0 := sym_pr.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_x), lang.NewVector(sym_x, sym__AMP_, sym_more)), kw_doc, "Prints the object(s) to the output stream that is the current value\n of *out*. Prints the object(s), separated by spaces if there is\n more than one. By default, pr and prn print in a way that objects\n can be read by the reader", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(7), kw_line, int(3678), kw_end_DASH_line, int(3678), kw_dynamic, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return nil + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) + tmp4 := checkDerefVar(var_glojure_DOT_core__STAR_out_STAR_) + tmp5 := lang.Apply(tmp3, []any{v2, tmp4}) + return tmp5 + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + recur_loop_671: + tmp4 := checkDerefVar(var_glojure_DOT_core_pr) + tmp5 := lang.Apply(tmp4, []any{v2}) + _ = tmp5 + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_out_STAR_) + tmp7 := lang.Apply(lang.AppendWriter, []any{tmp6, lang.NewChar(32)}) + _ = tmp7 + var tmp8 any + { // let + // let binding "temp__0__auto__" + tmp9 := checkDerefVar(var_glojure_DOT_core_next) + tmp10 := lang.Apply(tmp9, []any{v3}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + var tmp13 any + { // let + // let binding "nmore" + var v14 any = v11 + _ = v14 + tmp16 := checkDerefVar(var_glojure_DOT_core_first) + tmp17 := lang.Apply(tmp16, []any{v3}) + var tmp15 any = tmp17 + var tmp18 any = v14 + v2 = tmp15 + v3 = tmp18 + goto recur_loop_671 + } // end let + tmp12 = tmp13 + } else { + tmp14 := checkDerefVar(var_glojure_DOT_core_apply) + tmp15 := checkDerefVar(var_glojure_DOT_core_pr) + tmp16 := lang.Apply(tmp14, []any{tmp15, v3}) + tmp12 = tmp16 + } + tmp8 = tmp12 + } // end let + return tmp8 } - return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_pr = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_pr.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // unsigned-bit-shift-right + // pr-str { - var tmp1 lang.FnFunc - { // function unsigned-bit-shift-right__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] + tmp1 := reflect.TypeOf("") + tmp0 := sym_pr_DASH_str.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_xs)), kw_doc, "pr to a string, returning it", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(4758), kw_end_DASH_line, int(4758))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v3 any = lang.NewList(args[0:]...) _ = v3 - v4 := args[1] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_seq) - tmp6 := checkDerefVar(var_glojure_DOT_core_concat) - tmp7 := checkDerefVar(var_glojure_DOT_core_list) - tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) - tmp9 := checkDerefVar(var_glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp11 := checkDerefVar(var_glojure_DOT_core_list) - tmp12 := checkDerefVar(var_glojure_DOT_core_seq) - tmp13 := checkDerefVar(var_glojure_DOT_core_concat) - tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_UnsignedShiftRight}) - tmp16 := checkDerefVar(var_glojure_DOT_core_list) - tmp17 := lang.Apply(tmp16, []any{v3}) - tmp18 := checkDerefVar(var_glojure_DOT_core_list) - tmp19 := lang.Apply(tmp18, []any{v4}) - tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) - tmp21 := lang.Apply(tmp12, []any{tmp20}) - tmp22 := lang.Apply(tmp11, []any{tmp21}) - tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) - tmp24 := lang.Apply(tmp5, []any{tmp23}) - return tmp24 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := sym_unsigned_DASH_bit_DASH_shift_DASH_right.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_n)), kw_inline, tmp1, kw_doc, "Bitwise shift right, without sign-extension.", kw_file, "glojure/core.glj", kw_added, "1.6", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(30), kw_column, int(7), kw_line, int(1373), kw_end_DASH_line, int(1373))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "UnsignedShiftRight") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("UnsignedShiftRight is not a function"))) + var tmp4 any + { // let + // let binding "s__0__auto__" + var v5 any = "unimplemented: new with non-constant class type" + _ = v5 + var tmp6 any + { // let + tmp7 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp8 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp9 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) + tmp10 := lang.Apply(tmp8, []any{tmp9, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp10}) + _ = tmp11 + var tmp12 any + func() { + defer func() { + tmp13 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp14 := lang.Apply(tmp13, nil) + _ = tmp14 + }() + tmp15 := checkDerefVar(var_glojure_DOT_core_apply) + tmp16 := checkDerefVar(var_glojure_DOT_core_pr) + tmp17 := lang.Apply(tmp15, []any{tmp16, v3}) + _ = tmp17 + tmp18 := checkDerefVar(var_glojure_DOT_core_str) + tmp19 := lang.Apply(tmp18, []any{v5}) + tmp12 = tmp19 + }() + tmp6 = tmp12 + } // end let + tmp4 = tmp6 + } // end let + return tmp4 } - tmp7 := lang.Apply(tmp6, []any{v4, v5}) - return tmp7 }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp3 := reflect.TypeOf("") + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_pr_DASH_str = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_pr_DASH_str.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // update + // print { - tmp0 := sym_update.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m, sym_k, sym_f), lang.NewVector(sym_m, sym_k, sym_f, sym_x), lang.NewVector(sym_m, sym_k, sym_f, sym_x, sym_y), lang.NewVector(sym_m, sym_k, sym_f, sym_x, sym_y, sym_z), lang.NewVector(sym_m, sym_k, sym_f, sym_x, sym_y, sym_z, sym__AMP_, sym_more)), kw_doc, "'Updates' a value in an associative structure, where k is a\n key and f is a function that will take the old value\n and any supplied args and return the new value, and returns a new\n structure. If the key does not exist, nil is passed as the old value.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(6174), kw_end_DASH_line, int(6174))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_print.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_more)), kw_doc, "Prints the object(s) to the output stream that is the current value\n of *out*. print and println produce output for human consumption.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3725), kw_end_DASH_line, int(3725))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6 := checkDerefVar(var_glojure_DOT_core_assoc) - tmp7 := checkDerefVar(var_glojure_DOT_core_get) - tmp8 := lang.Apply(tmp7, []any{v3, v4}) - tmp9 := lang.Apply(v5, []any{tmp8}) - tmp10 := lang.Apply(tmp6, []any{v3, v4, tmp9}) - return tmp10 - case 4: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - tmp7 := checkDerefVar(var_glojure_DOT_core_assoc) - tmp8 := checkDerefVar(var_glojure_DOT_core_get) - tmp9 := lang.Apply(tmp8, []any{v3, v4}) - tmp10 := lang.Apply(v5, []any{tmp9, v6}) - tmp11 := lang.Apply(tmp7, []any{v3, v4, tmp10}) - return tmp11 - case 5: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - v7 := args[4] - _ = v7 - tmp8 := checkDerefVar(var_glojure_DOT_core_assoc) - tmp9 := checkDerefVar(var_glojure_DOT_core_get) - tmp10 := lang.Apply(tmp9, []any{v3, v4}) - tmp11 := lang.Apply(v5, []any{tmp10, v6, v7}) - tmp12 := lang.Apply(tmp8, []any{v3, v4, tmp11}) - return tmp12 - case 6: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - v7 := args[4] - _ = v7 - v8 := args[5] - _ = v8 - tmp9 := checkDerefVar(var_glojure_DOT_core_assoc) - tmp10 := checkDerefVar(var_glojure_DOT_core_get) - tmp11 := lang.Apply(tmp10, []any{v3, v4}) - tmp12 := lang.Apply(v5, []any{tmp11, v6, v7, v8}) - tmp13 := lang.Apply(tmp9, []any{v3, v4, tmp12}) - return tmp13 default: - checkArity(args, 6) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - v7 := args[4] - _ = v7 - v8 := args[5] - _ = v8 - var v9 any = lang.NewList(args[6:]...) - _ = v9 - tmp10 := checkDerefVar(var_glojure_DOT_core_assoc) - tmp11 := checkDerefVar(var_glojure_DOT_core_apply) - tmp12 := checkDerefVar(var_glojure_DOT_core_get) - tmp13 := lang.Apply(tmp12, []any{v3, v4}) - tmp14 := lang.Apply(tmp11, []any{v5, tmp13, v6, v7, v8, v9}) - tmp15 := lang.Apply(tmp10, []any{v3, v4, tmp14}) - return tmp15 + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + var tmp3 any + { // let + tmp4 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp5 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp6 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_print_DASH_readably_STAR_) + tmp7 := lang.Apply(tmp5, []any{tmp6, nil}) + tmp8 := lang.Apply(tmp4, []any{tmp7}) + _ = tmp8 + var tmp9 any + func() { + defer func() { + tmp10 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp11 := lang.Apply(tmp10, nil) + _ = tmp11 + }() + tmp12 := checkDerefVar(var_glojure_DOT_core_apply) + tmp13 := checkDerefVar(var_glojure_DOT_core_pr) + tmp14 := lang.Apply(tmp12, []any{tmp13, v2}) + tmp9 = tmp14 + }() + tmp3 = tmp9 + } // end let + return tmp3 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_print = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_print.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // update-in + // print-str { - tmp0 := sym_update_DASH_in.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m, sym_ks, sym_f, sym__AMP_, sym_args)), kw_doc, "'Updates' a value in a nested associative structure, where ks is a\n sequence of keys and f is a function that will take the old value\n and any supplied args and return the new value, and returns a new\n nested structure. If any levels do not exist, hash-maps will be\n created.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(6158), kw_end_DASH_line, int(6158))).(*lang.Symbol) + tmp1 := reflect.TypeOf("") + tmp0 := sym_print_DASH_str.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_xs)), kw_doc, "print to a string, returning it", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(4776), kw_end_DASH_line, int(4776))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) - v3 := args[0] + checkArity(args, 0) + var v3 any = lang.NewList(args[0:]...) _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any + var tmp4 any { // let - // let binding "up" - var tmp8 lang.FnFunc - { // function up - var v9 lang.FnFunc - tmp8 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 4) - v10 := args[0] - _ = v10 - v11 := args[1] - _ = v11 - v12 := args[2] - _ = v12 - v13 := args[3] - _ = v13 - var tmp14 any - { // let - // let binding "vec__141" - var v15 any = v11 - _ = v15 - // let binding "seq__142" - tmp16 := checkDerefVar(var_glojure_DOT_core_seq) - tmp17 := lang.Apply(tmp16, []any{v15}) - var v18 any = tmp17 - _ = v18 - // let binding "first__143" - tmp19 := checkDerefVar(var_glojure_DOT_core_first) - tmp20 := lang.Apply(tmp19, []any{v18}) - var v21 any = tmp20 - _ = v21 - // let binding "seq__142" - tmp22 := checkDerefVar(var_glojure_DOT_core_next) - tmp23 := lang.Apply(tmp22, []any{v18}) - var v24 any = tmp23 - _ = v24 - // let binding "k" - var v25 any = v21 - _ = v25 - // let binding "ks" - var v26 any = v24 - _ = v26 - var tmp27 any - if lang.IsTruthy(v26) { - tmp28 := checkDerefVar(var_glojure_DOT_core_assoc) - tmp29 := checkDerefVar(var_glojure_DOT_core_get) - tmp30 := lang.Apply(tmp29, []any{v10, v25}) - tmp31 := lang.Apply(v9, []any{tmp30, v26, v12, v13}) - tmp32 := lang.Apply(tmp28, []any{v10, v25, tmp31}) - tmp27 = tmp32 - } else { - tmp33 := checkDerefVar(var_glojure_DOT_core_assoc) - tmp34 := checkDerefVar(var_glojure_DOT_core_apply) - tmp35 := checkDerefVar(var_glojure_DOT_core_get) - tmp36 := lang.Apply(tmp35, []any{v10, v25}) - tmp37 := lang.Apply(tmp34, []any{v12, tmp36, v13}) - tmp38 := lang.Apply(tmp33, []any{v10, v25, tmp37}) - tmp27 = tmp38 - } - tmp14 = tmp27 - } // end let - return tmp14 - }) - v9 = tmp8 - _ = v9 - } - tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6167), kw_column, int(15), kw_end_DASH_line, int(6171), kw_end_DASH_column, int(59)) - tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v11 any = tmp10 - _ = v11 - tmp12 := lang.Apply(v11, []any{v3, v4, v5, v6}) - tmp7 = tmp12 + // let binding "s__0__auto__" + var v5 any = "unimplemented: new with non-constant class type" + _ = v5 + var tmp6 any + { // let + tmp7 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp8 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp9 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) + tmp10 := lang.Apply(tmp8, []any{tmp9, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp10}) + _ = tmp11 + var tmp12 any + func() { + defer func() { + tmp13 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp14 := lang.Apply(tmp13, nil) + _ = tmp14 + }() + tmp15 := checkDerefVar(var_glojure_DOT_core_apply) + tmp16 := checkDerefVar(var_glojure_DOT_core_print) + tmp17 := lang.Apply(tmp15, []any{tmp16, v3}) + _ = tmp17 + tmp18 := checkDerefVar(var_glojure_DOT_core_str) + tmp19 := lang.Apply(tmp18, []any{v5}) + tmp12 = tmp19 + }() + tmp6 = tmp12 + } // end let + tmp4 = tmp6 } // end let - return tmp7 + return tmp4 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp3 := reflect.TypeOf("") + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_print_DASH_str = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_print_DASH_str.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // update-keys + // printf { - tmp0 := sym_update_DASH_keys.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m, sym_f)), kw_doc, "m f => {(f k) v ...}\n\n Given a map m and a function f of 1-argument, returns a new map whose\n keys are the result of applying f to the keys of m, mapped to the\n corresponding values of m.\n f must return a unique key for each key of m, else the behavior is undefined.", kw_file, "glojure/core.glj", kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(7906), kw_end_DASH_line, int(7906))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - { // let - // let binding "ret" - tmp6 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) - tmp7 := checkDerefVar(var_glojure_DOT_core_reduce_DASH_kv) - var tmp8 lang.FnFunc - tmp8 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 3) - v9 := args[0] - _ = v9 - v10 := args[1] - _ = v10 - v11 := args[2] - _ = v11 - tmp12 := checkDerefVar(var_glojure_DOT_core_assoc_BANG_) - tmp13 := lang.Apply(v4, []any{v10}) - tmp14 := lang.Apply(tmp12, []any{v9, tmp13, v11}) - return tmp14 - }) - tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7916), kw_column, int(25), kw_end_DASH_line, int(7916), kw_end_DASH_column, int(59)) - tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp11 := checkDerefVar(var_glojure_DOT_core_transient) - tmp12 := lang.NewMap() - tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7917), kw_column, int(36), kw_end_DASH_line, int(7917), kw_end_DASH_column, int(37)) - tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp15 := lang.Apply(tmp11, []any{tmp14}) - tmp16 := lang.Apply(tmp7, []any{tmp10, tmp15, v3}) - tmp17 := lang.Apply(tmp6, []any{tmp16}) - var v18 any = tmp17 - _ = v18 - tmp19 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) - tmp20 := checkDerefVar(var_glojure_DOT_core_meta) - tmp21 := lang.Apply(tmp20, []any{v3}) - tmp22 := lang.Apply(tmp19, []any{v18, tmp21}) - tmp5 = tmp22 - } // end let - return tmp5 + tmp0 := sym_printf.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_fmt, sym__AMP_, sym_args)), kw_doc, "Prints formatted output, as per format", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(5725), kw_end_DASH_line, int(5725))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_print) + tmp5 := checkDerefVar(var_glojure_DOT_core_apply) + tmp6 := checkDerefVar(var_glojure_DOT_core_format) + tmp7 := lang.Apply(tmp5, []any{tmp6, v2, v3}) + tmp8 := lang.Apply(tmp4, []any{tmp7}) + return tmp8 + } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_printf = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_printf.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // update-vals + // prn { - tmp0 := sym_update_DASH_vals.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m, sym_f)), kw_doc, "m f => {k (f v) ...}\n\n Given a map m and a function f of 1-argument, returns a new map where the keys of m\n are mapped to result of applying f to the corresponding values of m.", kw_file, "glojure/core.glj", kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(7890), kw_end_DASH_line, int(7890))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) - tmp6 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) - tmp7 := checkDerefVar(var_glojure_DOT_core_reduce_DASH_kv) - var tmp8 lang.FnFunc - tmp8 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 3) - v9 := args[0] - _ = v9 - v10 := args[1] - _ = v10 - v11 := args[2] - _ = v11 - tmp12 := checkDerefVar(var_glojure_DOT_core_assoc_BANG_) - tmp13 := lang.Apply(v4, []any{v11}) - tmp14 := lang.Apply(tmp12, []any{v9, v10, tmp13}) - return tmp14 - }) - tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7899), kw_column, int(17), kw_end_DASH_line, int(7899), kw_end_DASH_column, int(51)) - tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var tmp11 any - tmp12 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp13 := reflect.TypeOf((*lang.IEditableCollection)(nil)).Elem() - tmp14 := lang.Apply(tmp12, []any{tmp13, v3}) - if lang.IsTruthy(tmp14) { - tmp15 := checkDerefVar(var_glojure_DOT_core_transient) - tmp16 := lang.Apply(tmp15, []any{v3}) - tmp11 = tmp16 - } else { - tmp17 := checkDerefVar(var_glojure_DOT_core_transient) - tmp18 := lang.NewMap() - tmp19 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7902), kw_column, int(30), kw_end_DASH_line, int(7902), kw_end_DASH_column, int(31)) - tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) - if err != nil { - panic(err) + tmp0 := sym_prn.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_more)), kw_doc, "Same as pr followed by (newline). Observes *flush-on-newline*", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(3715), kw_end_DASH_line, int(3715))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_apply) + tmp4 := checkDerefVar(var_glojure_DOT_core_pr) + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + _ = tmp5 + tmp6 := checkDerefVar(var_glojure_DOT_core_newline) + tmp7 := lang.Apply(tmp6, nil) + _ = tmp7 + var tmp8 any + tmp9 := checkDerefVar(var_glojure_DOT_core__STAR_flush_DASH_on_DASH_newline_STAR_) + if lang.IsTruthy(tmp9) { + tmp10 := checkDerefVar(var_glojure_DOT_core_flush) + tmp11 := lang.Apply(tmp10, nil) + tmp8 = tmp11 + } else { } - tmp21 := lang.Apply(tmp17, []any{tmp20}) - tmp11 = tmp21 + return tmp8 } - tmp22 := lang.Apply(tmp7, []any{tmp10, tmp11, v3}) - tmp23 := lang.Apply(tmp6, []any{tmp22}) - tmp24 := checkDerefVar(var_glojure_DOT_core_meta) - tmp25 := lang.Apply(tmp24, []any{v3}) - tmp26 := lang.Apply(tmp5, []any{tmp23, tmp25}) - return tmp26 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_prn = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_prn.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // uri? + // prn-str { - tmp0 := sym_uri_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a java.net.URI", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(7877), kw_end_DASH_line, int(7877))).(*lang.Symbol) + tmp1 := reflect.TypeOf("") + tmp0 := sym_prn_DASH_str.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_xs)), kw_doc, "prn to a string, returning it", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4767), kw_end_DASH_line, int(4767))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp5 := reflect.TypeOf((*url5.URL)(nil)).Elem() - tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) - return tmp6 + switch len(args) { + default: + checkArity(args, 0) + var v3 any = lang.NewList(args[0:]...) + _ = v3 + var tmp4 any + { // let + // let binding "s__0__auto__" + var v5 any = "unimplemented: new with non-constant class type" + _ = v5 + var tmp6 any + { // let + tmp7 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp8 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp9 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) + tmp10 := lang.Apply(tmp8, []any{tmp9, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp10}) + _ = tmp11 + var tmp12 any + func() { + defer func() { + tmp13 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp14 := lang.Apply(tmp13, nil) + _ = tmp14 + }() + tmp15 := checkDerefVar(var_glojure_DOT_core_apply) + tmp16 := checkDerefVar(var_glojure_DOT_core_prn) + tmp17 := lang.Apply(tmp15, []any{tmp16, v3}) + _ = tmp17 + tmp18 := checkDerefVar(var_glojure_DOT_core_str) + tmp19 := lang.Apply(tmp18, []any{v5}) + tmp12 = tmp19 + }() + tmp6 = tmp12 + } // end let + tmp4 = tmp6 + } // end let + return tmp4 + } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp3 := reflect.TypeOf("") + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_prn_DASH_str = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_prn_DASH_str.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // use + // println { - tmp0 := sym_use.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_args)), kw_doc, "Like 'require, but also refers to each lib's namespace using\n glojure.core/refer. Use :use in the ns macro in preference to calling\n this directly.\n\n 'use accepts additional options in libspecs: :exclude, :only, :rename.\n The arguments and semantics for :exclude, :only, and :rename are the same\n as those documented for glojure.core/refer.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(6079), kw_end_DASH_line, int(6079))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_println.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_more)), kw_doc, "Same as print followed by (newline)", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(3734), kw_end_DASH_line, int(3734))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: checkArity(args, 0) - var v3 any = lang.NewList(args[0:]...) - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_apply) - tmp5 := checkDerefVar(var_glojure_DOT_core_load_DASH_libs) - tmp6 := lang.Apply(tmp4, []any{tmp5, kw_require, kw_use, v3}) - return tmp6 + var v2 any = lang.NewList(args[0:]...) + _ = v2 + var tmp3 any + { // let + tmp4 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp5 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp6 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_print_DASH_readably_STAR_) + tmp7 := lang.Apply(tmp5, []any{tmp6, nil}) + tmp8 := lang.Apply(tmp4, []any{tmp7}) + _ = tmp8 + var tmp9 any + func() { + defer func() { + tmp10 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp11 := lang.Apply(tmp10, nil) + _ = tmp11 + }() + tmp12 := checkDerefVar(var_glojure_DOT_core_apply) + tmp13 := checkDerefVar(var_glojure_DOT_core_prn) + tmp14 := lang.Apply(tmp12, []any{tmp13, v2}) + tmp9 = tmp14 + }() + tmp3 = tmp9 + } // end let + return tmp3 } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_println = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_println.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // uuid? + // println-str { - tmp0 := sym_uuid_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a java.util.UUID", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(6847), kw_end_DASH_line, int(6847))).(*lang.Symbol) + tmp1 := reflect.TypeOf("") + tmp0 := sym_println_DASH_str.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_xs)), kw_doc, "println to a string, returning it", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(4785), kw_end_DASH_line, int(4785))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp5 := reflect.TypeOf([16]uint8{}) - tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) - return tmp6 + switch len(args) { + default: + checkArity(args, 0) + var v3 any = lang.NewList(args[0:]...) + _ = v3 + var tmp4 any + { // let + // let binding "s__0__auto__" + var v5 any = "unimplemented: new with non-constant class type" + _ = v5 + var tmp6 any + { // let + tmp7 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp8 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp9 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) + tmp10 := lang.Apply(tmp8, []any{tmp9, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp10}) + _ = tmp11 + var tmp12 any + func() { + defer func() { + tmp13 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp14 := lang.Apply(tmp13, nil) + _ = tmp14 + }() + tmp15 := checkDerefVar(var_glojure_DOT_core_apply) + tmp16 := checkDerefVar(var_glojure_DOT_core_println) + tmp17 := lang.Apply(tmp15, []any{tmp16, v3}) + _ = tmp17 + tmp18 := checkDerefVar(var_glojure_DOT_core_str) + tmp19 := lang.Apply(tmp18, []any{v5}) + tmp12 = tmp19 + }() + tmp6 = tmp12 + } // end let + tmp4 = tmp6 + } // end let + return tmp4 + } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp3 := reflect.TypeOf("") + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_println_DASH_str = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_println_DASH_str.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // val + // pr-on { - tmp0 := sym_val.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_e)), kw_doc, "Returns the value in the map entry.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(1570), kw_end_DASH_line, int(1570))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] + tmp0 := sym_pr_DASH_on.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_w)), kw_static, true, kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3669), kw_end_DASH_line, int(3669), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - tmp4, _ := lang.FieldOrMethod(v3, "GetValue") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("GetValue is not a function"))) + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_dup_STAR_) + if lang.IsTruthy(tmp5) { + tmp6 := checkDerefVar(var_glojure_DOT_core_print_DASH_dup) + tmp7 := lang.Apply(tmp6, []any{v2, v3}) + tmp4 = tmp7 + } else { + tmp8 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp9 := lang.Apply(tmp8, []any{v2, v3}) + tmp4 = tmp9 } - tmp5 := lang.Apply(tmp4, []any{}) - return tmp5 + _ = tmp4 + return nil }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_pr_DASH_on = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_pr_DASH_on.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // vals + // print-meta { - tmp0 := sym_vals.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_map)), kw_doc, "Returns a sequence of the map's values, in the same order as (seq map).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1557), kw_end_DASH_line, int(1557))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] + tmp0 := sym_print_DASH_meta.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(70), kw_column, int(8), kw_end_DASH_line, int(70), kw_end_DASH_column, int(17), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_o, sym_w)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - tmp4 := lang.Apply(lang.Vals, []any{v3}) + var tmp4 any + { // let + // let binding "temp__0__auto__" + tmp5 := checkDerefVar(var_glojure_DOT_core_meta) + tmp6 := lang.Apply(tmp5, []any{v2}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + if lang.IsTruthy(v7) { + var tmp9 any + { // let + // let binding "m" + var v10 any = v7 + _ = v10 + var tmp11 any + var tmp12 any + { // let + // let binding "and__0__auto__" + tmp13 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp14 := checkDerefVar(var_glojure_DOT_core_count) + tmp15 := lang.Apply(tmp14, []any{v10}) + tmp16 := lang.Apply(tmp13, []any{tmp15}) + var v17 any = tmp16 + _ = v17 + var tmp18 any + if lang.IsTruthy(v17) { + var tmp19 any + { // let + // let binding "or__0__auto__" + tmp20 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_dup_STAR_) + var v21 any = tmp20 + _ = v21 + var tmp22 any + if lang.IsTruthy(v21) { + tmp22 = v21 + } else { + var tmp23 any + { // let + // let binding "and__0__auto__" + tmp24 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_meta_STAR_) + var v25 any = tmp24 + _ = v25 + var tmp26 any + if lang.IsTruthy(v25) { + tmp27 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_readably_STAR_) + tmp26 = tmp27 + } else { + tmp26 = v25 + } + tmp23 = tmp26 + } // end let + tmp22 = tmp23 + } + tmp19 = tmp22 + } // end let + tmp18 = tmp19 + } else { + tmp18 = v17 + } + tmp12 = tmp18 + } // end let + if lang.IsTruthy(tmp12) { + tmp13 := lang.Apply(lang.WriteWriter, []any{v3, "^"}) + _ = tmp13 + var tmp14 any + var tmp15 any + { // let + // let binding "and__0__auto__" + tmp16 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp17 := checkDerefVar(var_glojure_DOT_core_count) + tmp18 := lang.Apply(tmp17, []any{v10}) + tmp19 := lang.Apply(tmp16, []any{tmp18, int64(1)}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + tmp22 := lang.Apply(kw_tag, []any{v10}) + tmp21 = tmp22 + } else { + tmp21 = v20 + } + tmp15 = tmp21 + } // end let + if lang.IsTruthy(tmp15) { + tmp16 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) + tmp17 := lang.Apply(kw_tag, []any{v10}) + tmp18 := lang.Apply(tmp16, []any{tmp17, v3}) + tmp14 = tmp18 + } else { + tmp19 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) + tmp20 := lang.Apply(tmp19, []any{v10, v3}) + tmp14 = tmp20 + } + _ = tmp14 + tmp21 := lang.Apply(lang.WriteWriter, []any{v3, " "}) + tmp11 = tmp21 + } else { + } + tmp9 = tmp11 + } // end let + tmp8 = tmp9 + } else { + } + tmp4 = tmp8 + } // end let return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_print_DASH_meta = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_print_DASH_meta.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // var-get + // print-simple { - tmp0 := sym_var_DASH_get.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Gets the value in the var object", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4326), kw_end_DASH_line, int(4326))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] + tmp0 := sym_print_DASH_simple.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(81), kw_column, int(7), kw_end_DASH_line, int(81), kw_end_DASH_column, int(18), kw_arglists, lang.NewList(lang.NewVector(sym_o, sym_w)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - tmp4, _ := lang.FieldOrMethod(v3, "Get") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Get is not a function"))) - } - tmp5 := lang.Apply(tmp4, []any{}) - return tmp5 + tmp4 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + _ = tmp5 + tmp6 := checkDerefVar(var_glojure_DOT_core_str) + tmp7 := lang.Apply(tmp6, []any{v2}) + tmp8 := lang.Apply(lang.WriteWriter, []any{v3, tmp7}) + return tmp8 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_print_DASH_simple = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_print_DASH_simple.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // var-set + // print-dup { - tmp0 := sym_var_DASH_set.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_val)), kw_doc, "Sets the value in the var object to val. The var must be\n thread-locally bound.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4332), kw_end_DASH_line, int(4332))).(*lang.Symbol) + tmp0 := sym_print_DASH_dup.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3667), kw_column, int(11), kw_end_DASH_line, int(3667), kw_end_DASH_column, int(19), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 2) @@ -54650,311 +54635,476 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(v3, "Set") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Set is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) + tmp5 := checkDerefVar(var_glojure_DOT_core_class) + tmp6 := lang.Apply(tmp5, []any{v3}) return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // var? - { - tmp0 := sym_var_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_v)), kw_doc, "Returns true if v is of type glojure.lang.Var", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(4999), kw_end_DASH_line, int(4999))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp5 := reflect.TypeOf((*lang.Var)(nil)) - tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) - return tmp6 + tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3667), kw_column, int(21), kw_end_DASH_line, int(3667), kw_end_DASH_column, int(45))).(lang.FnFunc) + tmp1 := lang.NewMultiFn("print-dup", tmp2, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // vary-meta - { - tmp0 := sym_vary_DASH_meta.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_obj, sym_f, sym__AMP_, sym_args)), kw_doc, "Returns an object of the same type and value as obj, with\n (apply f (meta obj) args) as its metadata.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(668), kw_end_DASH_line, int(668))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { + tmp1.AddMethod(nil, tmp3) + tmp4 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp9 := lang.Apply(tmp8, []any{v6, v7}) + return tmp9 + }) + tmp1.AddMethod(tmp4, tmp5) + tmp6 := reflect.TypeOf((*lang.IPersistentList)(nil)).Elem() + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp11 := lang.Apply(tmp10, []any{v8, v9}) + return tmp11 + }) + tmp1.AddMethod(tmp6, tmp7) + tmp8 := reflect.TypeOf((*lang.Symbol)(nil)) + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp13 := lang.Apply(tmp12, []any{v10, v11}) + return tmp13 + }) + tmp1.AddMethod(tmp8, tmp9) + tmp10 := reflect.TypeOf((*lang.IRecord)(nil)).Elem() + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v12 := args[0] + _ = v12 + v13 := args[1] + _ = v13 + tmp14 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) + tmp15 := lang.Apply(tmp14, []any{v12, v13}) + _ = tmp15 + tmp16 := lang.Apply(lang.WriteWriter, []any{v13, "#"}) + _ = tmp16 + tmp17 := checkDerefVar(var_glojure_DOT_core_class) + tmp18 := lang.Apply(tmp17, []any{v12}) + tmp19, ok := lang.FieldOrMethod(tmp18, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp18, "Name"))) + } + var tmp20 any + switch reflect.TypeOf(tmp19).Kind() { + case reflect.Func: + tmp20 = lang.Apply(tmp19, nil) default: - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - tmp6 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) - tmp7 := checkDerefVar(var_glojure_DOT_core_apply) - tmp8 := checkDerefVar(var_glojure_DOT_core_meta) - tmp9 := lang.Apply(tmp8, []any{v3}) - tmp10 := lang.Apply(tmp7, []any{v4, tmp9, v5}) - tmp11 := lang.Apply(tmp6, []any{v3, tmp10}) - return tmp11 + tmp20 = tmp19 } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // vec - { - tmp0 := sym_vec.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Creates a new vector containing the contents of coll. Java arrays\n will be aliased and should not be modified.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(366), kw_end_DASH_line, int(366))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 any - tmp5 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) - tmp6 := lang.Apply(tmp5, []any{v3}) - if lang.IsTruthy(tmp6) { - var tmp7 any - tmp8 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp9 := reflect.TypeOf((*lang.IObj)(nil)).Elem() - tmp10 := lang.Apply(tmp8, []any{tmp9, v3}) - if lang.IsTruthy(tmp10) { - tmp11 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) - tmp12 := lang.Apply(tmp11, []any{v3, nil}) - tmp7 = tmp12 - } else { - tmp13 := lang.Apply(lang.CreateLazilyPersistentVector, []any{v3}) - tmp7 = tmp13 - } - tmp4 = tmp7 + tmp21 := lang.Apply(lang.WriteWriter, []any{v13, tmp20}) + _ = tmp21 + var tmp22 any + tmp23 := checkDerefVar(var_glojure_DOT_core__STAR_verbose_DASH_defrecords_STAR_) + if lang.IsTruthy(tmp23) { + tmp24 := checkDerefVar(var_glojure_DOT_core_print_DASH_map) + tmp25 := checkDerefVar(var_glojure_DOT_core_print_DASH_dup) + tmp26 := lang.Apply(tmp24, []any{v12, tmp25, v13}) + tmp22 = tmp26 } else { - tmp14 := lang.Apply(lang.CreateLazilyPersistentVector, []any{v3}) - tmp4 = tmp14 + tmp27 := checkDerefVar(var_glojure_DOT_core_print_DASH_sequential) + tmp28 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) + tmp29 := checkDerefVar(var_glojure_DOT_core_vals) + tmp30 := lang.Apply(tmp29, []any{v12}) + tmp31 := lang.Apply(tmp27, []any{"[", tmp28, ", ", "]", tmp30, v13}) + tmp22 = tmp31 } - return tmp4 + return tmp22 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // vector - { - tmp0 := sym_vector.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_a), lang.NewVector(sym_a, sym_b), lang.NewVector(sym_a, sym_b, sym_c), lang.NewVector(sym_a, sym_b, sym_c, sym_d), lang.NewVector(sym_a, sym_b, sym_c, sym_d, sym_e), lang.NewVector(sym_a, sym_b, sym_c, sym_d, sym_e, sym_f), lang.NewVector(sym_a, sym_b, sym_c, sym_d, sym_e, sym_f, sym__AMP_, sym_args)), kw_doc, "Creates a new vector containing the args.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(352), kw_end_DASH_line, int(352))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp3 := lang.NewVector() - tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(356), kw_column, int(7), kw_end_DASH_line, int(356), kw_end_DASH_column, int(8)) - tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp5 - case 1: - v3 := args[0] - _ = v3 - tmp4 := lang.NewVector(v3) - tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(357), kw_column, int(8), kw_end_DASH_line, int(357), kw_end_DASH_column, int(10)) - tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp6 - case 2: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - tmp5 := lang.NewVector(v3, v4) - tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(358), kw_column, int(10), kw_end_DASH_line, int(358), kw_end_DASH_column, int(14)) - tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp7 - case 3: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - tmp6 := lang.NewVector(v3, v4, v5) - tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(359), kw_column, int(12), kw_end_DASH_line, int(359), kw_end_DASH_column, int(18)) - tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp8 - case 4: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - tmp7 := lang.NewVector(v3, v4, v5, v6) - tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(360), kw_column, int(14), kw_end_DASH_line, int(360), kw_end_DASH_column, int(22)) - tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp9 - case 5: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - v7 := args[4] - _ = v7 - tmp8 := lang.NewVector(v3, v4, v5, v6, v7) - tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(361), kw_column, int(15), kw_end_DASH_line, int(361), kw_end_DASH_column, int(25)) - tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp10 - case 6: - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - v7 := args[4] - _ = v7 - v8 := args[5] - _ = v8 - tmp9 := lang.NewVector(v3, v4, v5, v6, v7, v8) - tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(362), kw_column, int(17), kw_end_DASH_line, int(362), kw_end_DASH_column, int(29)) - tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp11 + tmp1.AddMethod(tmp10, tmp11) + tmp12 := reflect.TypeOf((*lang.Set)(nil)) + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v14 := args[0] + _ = v14 + v15 := args[1] + _ = v15 + tmp16 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp17 := lang.Apply(tmp16, []any{v14, v15}) + return tmp17 + }) + tmp1.AddMethod(tmp12, tmp13) + tmp14 := reflect.TypeOf((*lang.PersistentHashMap)(nil)) + var tmp15 lang.FnFunc + tmp15 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v16 := args[0] + _ = v16 + v17 := args[1] + _ = v17 + tmp18 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp19 := lang.Apply(tmp18, []any{v16, v17}) + return tmp19 + }) + tmp1.AddMethod(tmp14, tmp15) + tmp16 := reflect.TypeOf(int64(0)) + var tmp17 lang.FnFunc + tmp17 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v18 := args[0] + _ = v18 + v19 := args[1] + _ = v19 + tmp20 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp21 := lang.Apply(tmp20, []any{v18, v19}) + return tmp21 + }) + tmp1.AddMethod(tmp16, tmp17) + tmp18 := reflect.TypeOf((*lang.Vector)(nil)) + var tmp19 lang.FnFunc + tmp19 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v20 := args[0] + _ = v20 + v21 := args[1] + _ = v21 + tmp22 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp23 := lang.Apply(tmp22, []any{v20, v21}) + return tmp23 + }) + tmp1.AddMethod(tmp18, tmp19) + tmp20 := reflect.TypeOf(float64(0)) + var tmp21 lang.FnFunc + tmp21 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v22 := args[0] + _ = v22 + v23 := args[1] + _ = v23 + tmp24 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp25 := lang.Apply(tmp24, []any{v22, v23}) + return tmp25 + }) + tmp1.AddMethod(tmp20, tmp21) + tmp22 := reflect.TypeOf("") + var tmp23 lang.FnFunc + tmp23 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v24 := args[0] + _ = v24 + v25 := args[1] + _ = v25 + tmp26 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp27 := lang.Apply(tmp26, []any{v24, v25}) + return tmp27 + }) + tmp1.AddMethod(tmp22, tmp23) + tmp24 := reflect.TypeOf((*lang.IPersistentCollection)(nil)).Elem() + var tmp25 lang.FnFunc + tmp25 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v26 := args[0] + _ = v26 + v27 := args[1] + _ = v27 + tmp28 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) + tmp29 := lang.Apply(tmp28, []any{v26, v27}) + _ = tmp29 + tmp30 := lang.Apply(lang.WriteWriter, []any{v27, "#=("}) + _ = tmp30 + tmp31 := checkDerefVar(var_glojure_DOT_core_class) + tmp32 := lang.Apply(tmp31, []any{v26}) + tmp33, ok := lang.FieldOrMethod(tmp32, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp32, "Name"))) + } + var tmp34 any + switch reflect.TypeOf(tmp33).Kind() { + case reflect.Func: + tmp34 = lang.Apply(tmp33, nil) default: - checkArity(args, 6) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - v7 := args[4] - _ = v7 - v8 := args[5] - _ = v8 - var v9 any = lang.NewList(args[6:]...) - _ = v9 - tmp10 := checkDerefVar(var_glojure_DOT_core_cons) - tmp11 := checkDerefVar(var_glojure_DOT_core_cons) - tmp12 := checkDerefVar(var_glojure_DOT_core_cons) - tmp13 := checkDerefVar(var_glojure_DOT_core_cons) - tmp14 := checkDerefVar(var_glojure_DOT_core_cons) - tmp15 := checkDerefVar(var_glojure_DOT_core_cons) - tmp16 := lang.Apply(tmp15, []any{v8, v9}) - tmp17 := lang.Apply(tmp14, []any{v7, tmp16}) - tmp18 := lang.Apply(tmp13, []any{v6, tmp17}) - tmp19 := lang.Apply(tmp12, []any{v5, tmp18}) - tmp20 := lang.Apply(tmp11, []any{v4, tmp19}) - tmp21 := lang.Apply(tmp10, []any{v3, tmp20}) - tmp22 := lang.Apply(lang.CreateLazilyPersistentVector, []any{tmp21}) - return tmp22 + tmp34 = tmp33 + } + tmp35 := lang.Apply(lang.WriteWriter, []any{v27, tmp34}) + _ = tmp35 + tmp36 := lang.Apply(lang.WriteWriter, []any{v27, "/create "}) + _ = tmp36 + tmp37 := checkDerefVar(var_glojure_DOT_core_print_DASH_sequential) + tmp38 := checkDerefVar(var_glojure_DOT_core_print_DASH_dup) + tmp39 := lang.Apply(tmp37, []any{"[", tmp38, " ", "]", v26, v27}) + _ = tmp39 + tmp40 := lang.Apply(lang.WriteWriter, []any{v27, ")"}) + return tmp40 + }) + tmp1.AddMethod(tmp24, tmp25) + tmp26 := reflect.TypeOf(int32(0)) + var tmp27 lang.FnFunc + tmp27 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v28 := args[0] + _ = v28 + v29 := args[1] + _ = v29 + tmp30 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp31 := lang.Apply(tmp30, []any{v28, v29}) + return tmp31 + }) + tmp1.AddMethod(tmp26, tmp27) + tmp28 := reflect.TypeOf((*lang.IPersistentMap)(nil)).Elem() + var tmp29 lang.FnFunc + tmp29 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v30 := args[0] + _ = v30 + v31 := args[1] + _ = v31 + tmp32 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) + tmp33 := lang.Apply(tmp32, []any{v30, v31}) + _ = tmp33 + tmp34 := lang.Apply(lang.WriteWriter, []any{v31, "#=("}) + _ = tmp34 + tmp35 := checkDerefVar(var_glojure_DOT_core_class) + tmp36 := lang.Apply(tmp35, []any{v30}) + tmp37, ok := lang.FieldOrMethod(tmp36, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp36, "Name"))) + } + var tmp38 any + switch reflect.TypeOf(tmp37).Kind() { + case reflect.Func: + tmp38 = lang.Apply(tmp37, nil) + default: + tmp38 = tmp37 } + tmp39 := lang.Apply(lang.WriteWriter, []any{v31, tmp38}) + _ = tmp39 + tmp40 := lang.Apply(lang.WriteWriter, []any{v31, "/create "}) + _ = tmp40 + tmp41 := checkDerefVar(var_glojure_DOT_core_print_DASH_map) + tmp42 := checkDerefVar(var_glojure_DOT_core_print_DASH_dup) + tmp43 := lang.Apply(tmp41, []any{v30, tmp42, v31}) + _ = tmp43 + tmp44 := lang.Apply(lang.WriteWriter, []any{v31, ")"}) + return tmp44 + }) + tmp1.AddMethod(tmp28, tmp29) + tmp30 := reflect.TypeOf((*lang.Namespace)(nil)) + var tmp31 lang.FnFunc + tmp31 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v32 := args[0] + _ = v32 + v33 := args[1] + _ = v33 + tmp34 := lang.Apply(lang.WriteWriter, []any{v33, "#=(find-ns "}) + _ = tmp34 + tmp35 := checkDerefVar(var_glojure_DOT_core_print_DASH_dup) + tmp36, ok := lang.FieldOrMethod(v32, "name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v32, "name"))) + } + var tmp37 any + switch reflect.TypeOf(tmp36).Kind() { + case reflect.Func: + tmp37 = lang.Apply(tmp36, nil) + default: + tmp37 = tmp36 + } + tmp38 := lang.Apply(tmp35, []any{tmp37, v33}) + _ = tmp38 + tmp39 := lang.Apply(lang.WriteWriter, []any{v33, ")"}) + return tmp39 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // vector? - { - tmp0 := sym_vector_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x implements IPersistentVector", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(2), kw_line, int(174), kw_end_DASH_line, int(178))).(*lang.Symbol) - var tmp2 lang.FnFunc - { // function vector? - var v3 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp6 := reflect.TypeOf((*lang.IPersistentVector)(nil)).Elem() - tmp7 := lang.Apply(tmp5, []any{tmp6, v4}) - return tmp7 + tmp1.AddMethod(tmp30, tmp31) + tmp32 := reflect.TypeOf(false) + var tmp33 lang.FnFunc + tmp33 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v34 := args[0] + _ = v34 + v35 := args[1] + _ = v35 + tmp36 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp37 := lang.Apply(tmp36, []any{v34, v35}) + return tmp37 + }) + tmp1.AddMethod(tmp32, tmp33) + tmp34 := reflect.TypeOf((*regexp15.Regexp)(nil)) + var tmp35 lang.FnFunc + tmp35 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v36 := args[0] + _ = v36 + v37 := args[1] + _ = v37 + tmp38 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp39 := lang.Apply(tmp38, []any{v36, v37}) + return tmp39 + }) + tmp1.AddMethod(tmp34, tmp35) + tmp36 := reflect.TypeOf((*lang.Ratio)(nil)) + var tmp37 lang.FnFunc + tmp37 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v38 := args[0] + _ = v38 + v39 := args[1] + _ = v39 + tmp40 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp41 := lang.Apply(tmp40, []any{v38, v39}) + return tmp41 + }) + tmp1.AddMethod(tmp36, tmp37) + tmp38 := reflect.TypeOf((*lang.Var)(nil)) + var tmp39 lang.FnFunc + tmp39 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v40 := args[0] + _ = v40 + v41 := args[1] + _ = v41 + tmp42 := checkDerefVar(var_glojure_DOT_core_str) + tmp43, ok := lang.FieldOrMethod(v40, "Namespace") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v40, "Namespace"))) + } + var tmp44 any + switch reflect.TypeOf(tmp43).Kind() { + case reflect.Func: + tmp44 = lang.Apply(tmp43, nil) + default: + tmp44 = tmp43 + } + tmp45, ok := lang.FieldOrMethod(tmp44, "name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp44, "name"))) + } + var tmp46 any + switch reflect.TypeOf(tmp45).Kind() { + case reflect.Func: + tmp46 = lang.Apply(tmp45, nil) + default: + tmp46 = tmp45 + } + tmp47, ok := lang.FieldOrMethod(v40, "sym") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v40, "sym"))) + } + var tmp48 any + switch reflect.TypeOf(tmp47).Kind() { + case reflect.Func: + tmp48 = lang.Apply(tmp47, nil) + default: + tmp48 = tmp47 + } + tmp49 := lang.Apply(tmp42, []any{"#=(var ", tmp46, "/", tmp48, ")"}) + tmp50 := lang.Apply(lang.WriteWriter, []any{v41, tmp49}) + return tmp50 + }) + tmp1.AddMethod(tmp38, tmp39) + tmp40 := reflect.TypeOf((*lang.BigDecimal)(nil)) + var tmp41 lang.FnFunc + tmp41 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v42 := args[0] + _ = v42 + v43 := args[1] + _ = v43 + tmp44 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp45 := lang.Apply(tmp44, []any{v42, v43}) + return tmp45 + }) + tmp1.AddMethod(tmp40, tmp41) + tmp42 := reflect.TypeOf((*lang.BigInt)(nil)) + var tmp43 lang.FnFunc + tmp43 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v44 := args[0] + _ = v44 + v45 := args[1] + _ = v45 + tmp46 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp47 := lang.Apply(tmp46, []any{v44, v45}) + return tmp47 + }) + tmp1.AddMethod(tmp42, tmp43) + tmp44 := reflect.TypeOf((*runtime.Fn)(nil)) + var tmp45 lang.FnFunc + tmp45 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v46 := args[0] + _ = v46 + v47 := args[1] + _ = v47 + tmp48 := checkDerefVar(var_glojure_DOT_core_print_DASH_ctor) + var tmp49 lang.FnFunc + tmp49 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v50 := args[0] + _ = v50 + v51 := args[1] + _ = v51 + return nil }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(178), kw_column, int(10), kw_end_DASH_line, int(178), kw_end_DASH_column, int(106))).(lang.FnFunc) - v3 = tmp2 - _ = v3 - } - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // volatile! - { - tmp1 := reflect.TypeOf((*lang.Volatile)(nil)).Elem() - tmp0 := sym_volatile_BANG_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_val)), kw_doc, "Creates and returns a Volatile with an initial value of val.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(2517), kw_end_DASH_line, int(2517))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5 := lang.Apply(lang.NewVolatile, []any{v4}) - return tmp5 + tmp50 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(167), kw_column, int(17), kw_end_DASH_line, int(167), kw_end_DASH_column, int(26)) + tmp51, err := lang.WithMeta(tmp49, tmp50.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp52 := lang.Apply(tmp48, []any{v46, tmp51, v47}) + return tmp52 }) - tmp4 := reflect.TypeOf((*lang.Volatile)(nil)).Elem() - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) - if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // volatile? - { - tmp0 := sym_volatile_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x is a volatile.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(2540), kw_end_DASH_line, int(2540))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] - _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp5 := reflect.TypeOf((*lang.Volatile)(nil)).Elem() - tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) - return tmp6 + tmp1.AddMethod(tmp44, tmp45) + tmp46 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() + var tmp47 lang.FnFunc + tmp47 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v48 := args[0] + _ = v48 + v49 := args[1] + _ = v49 + tmp50 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp51 := lang.Apply(tmp50, []any{v48, v49}) + return tmp51 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1.AddMethod(tmp46, tmp47) + tmp48 := reflect.TypeOf((*lang.IPersistentCollection)(nil)).Elem() + tmp49 := reflect.TypeOf((*runtime.Fn)(nil)) + tmp1.PreferMethod(tmp48, tmp49) + tmp50 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() + tmp51 := reflect.TypeOf((*lang.IPersistentCollection)(nil)).Elem() + tmp1.PreferMethod(tmp50, tmp51) + tmp52 := reflect.TypeOf((*lang.IRecord)(nil)).Elem() + tmp53 := reflect.TypeOf((*lang.IPersistentMap)(nil)).Elem() + tmp1.PreferMethod(tmp52, tmp53) + tmp54 := reflect.TypeOf((*lang.IRecord)(nil)).Elem() + tmp55 := reflect.TypeOf((*lang.IPersistentCollection)(nil)).Elem() + tmp1.PreferMethod(tmp54, tmp55) + var_glojure_DOT_core_print_DASH_dup = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_print_DASH_dup.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // vreset! + // print-method { - tmp0 := sym_vreset_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_vol, sym_newval)), kw_doc, "Sets the value of volatile to newval without regard for the\n current value. Returns newval.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(2524), kw_end_DASH_line, int(2524))).(*lang.Symbol) + tmp0 := sym_print_DASH_method.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3664), kw_column, int(11), kw_end_DASH_line, int(3664), kw_end_DASH_column, int(22), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp2 lang.FnFunc tmp2 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 2) @@ -54962,1806 +55112,2304 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(v3, "reset") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) - } - tmp6 := lang.Apply(tmp5, []any{v4}) + var tmp5 any + { // let + // let binding "t" + tmp6 := checkDerefVar(var_glojure_DOT_core_get) + tmp7 := checkDerefVar(var_glojure_DOT_core_meta) + tmp8 := lang.Apply(tmp7, []any{v3}) + tmp9 := lang.Apply(tmp6, []any{tmp8, kw_type}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp13 := lang.Apply(tmp12, []any{v10}) + if lang.IsTruthy(tmp13) { + tmp11 = v10 + } else { + tmp14 := checkDerefVar(var_glojure_DOT_core_class) + tmp15 := lang.Apply(tmp14, []any{v3}) + tmp11 = tmp15 + } + tmp5 = tmp11 + } // end let + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3664), kw_column, int(24), kw_end_DASH_line, int(3666), kw_end_DASH_column, int(58))).(lang.FnFunc) + tmp1 := lang.NewMultiFn("print-method", tmp2, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6 := lang.Apply(lang.WriteWriter, []any{v5, "nil"}) return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // vswap! - { - tmp0 := sym_vswap_BANG_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_vol, sym_f, sym__AMP_, sym_args)), kw_doc, "Non-atomically swaps the value of the volatile as if:\n (apply f current-value-of-vol args). Returns the value that\n was swapped in.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(11), kw_line, int(2531), kw_end_DASH_line, int(2531))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { + tmp1.AddMethod(nil, tmp3) + tmp4 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_str) + tmp9 := lang.Apply(tmp8, []any{v6}) + tmp10 := lang.Apply(lang.WriteWriter, []any{v7, tmp9}) + return tmp10 + }) + tmp1.AddMethod(tmp4, tmp5) + tmp6 := reflect.TypeOf(uint32(0)) + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_str) + tmp11 := lang.Apply(tmp10, []any{v8}) + tmp12, _ := lang.FieldOrMethod(v9, "write") + if reflect.TypeOf(tmp12).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + } + tmp13 := lang.Apply(tmp12, []any{tmp11}) + return tmp13 + }) + tmp1.AddMethod(tmp6, tmp7) + tmp8 := reflect.TypeOf((*lang.Symbol)(nil)) + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_print_DASH_simple) + tmp13 := lang.Apply(tmp12, []any{v10, v11}) + return tmp13 + }) + tmp1.AddMethod(tmp8, tmp9) + tmp10 := reflect.TypeOf((*lang.IRecord)(nil)).Elem() + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v12 := args[0] + _ = v12 + v13 := args[1] + _ = v13 + tmp14 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) + tmp15 := lang.Apply(tmp14, []any{v12, v13}) + _ = tmp15 + tmp16 := lang.Apply(lang.WriteWriter, []any{v13, "#"}) + _ = tmp16 + tmp17 := checkDerefVar(var_glojure_DOT_core_class) + tmp18 := lang.Apply(tmp17, []any{v12}) + tmp19, ok := lang.FieldOrMethod(tmp18, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp18, "Name"))) + } + var tmp20 any + switch reflect.TypeOf(tmp19).Kind() { + case reflect.Func: + tmp20 = lang.Apply(tmp19, nil) default: - checkArity(args, 4) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - v6 := args[3] - _ = v6 - var v7 any = lang.NewList(args[4:]...) - _ = v7 - var tmp8 any - { // let - // let binding "v" - tmp9 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) - tmp10 := lang.NewMap(kw_tag, sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Volatile) - tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2537), kw_column, int(26), kw_end_DASH_line, int(2537), kw_end_DASH_column, int(81)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) - if err != nil { - panic(err) + tmp20 = tmp19 + } + tmp21 := lang.Apply(lang.WriteWriter, []any{v13, tmp20}) + _ = tmp21 + tmp22 := checkDerefVar(var_glojure_DOT_core_print_DASH_map) + tmp23 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) + tmp24 := lang.Apply(tmp22, []any{v12, tmp23, v13}) + return tmp24 + }) + tmp1.AddMethod(tmp10, tmp11) + tmp12 := reflect.TypeOf(uint(0)) + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v14 := args[0] + _ = v14 + v15 := args[1] + _ = v15 + tmp16 := checkDerefVar(var_glojure_DOT_core_str) + tmp17 := lang.Apply(tmp16, []any{v14}) + tmp18, _ := lang.FieldOrMethod(v15, "write") + if reflect.TypeOf(tmp18).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + } + tmp19 := lang.Apply(tmp18, []any{tmp17}) + return tmp19 + }) + tmp1.AddMethod(tmp12, tmp13) + tmp14 := reflect.TypeOf(int64(0)) + var tmp15 lang.FnFunc + tmp15 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v16 := args[0] + _ = v16 + v17 := args[1] + _ = v17 + tmp18 := checkDerefVar(var_glojure_DOT_core_str) + tmp19 := lang.Apply(tmp18, []any{v16}) + tmp20, _ := lang.FieldOrMethod(v17, "write") + if reflect.TypeOf(tmp20).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + } + tmp21 := lang.Apply(tmp20, []any{tmp19}) + return tmp21 + }) + tmp1.AddMethod(tmp14, tmp15) + var tmp16 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v17 := args[0] + _ = v17 + v18 := args[1] + _ = v18 + var tmp19 any + tmp20 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp21 := reflect.TypeOf((*lang.IObj)(nil)).Elem() + tmp22 := lang.Apply(tmp20, []any{tmp21, v17}) + if lang.IsTruthy(tmp22) { + tmp23 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp24 := checkDerefVar(var_glojure_DOT_core_vary_DASH_meta) + var tmp25 lang.FnFunc + tmp25 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v26 := args[0] + _ = v26 + tmp27 := checkDerefVar(var_glojure_DOT_core_dissoc) + tmp28 := lang.Apply(tmp27, []any{v26, kw_type}) + return tmp28 + }) + tmp26 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(87), kw_column, int(32), kw_end_DASH_line, int(87), kw_end_DASH_column, int(48)) + tmp27, err := lang.WithMeta(tmp25, tmp26.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp28 := lang.Apply(tmp24, []any{v17, tmp27}) + tmp29 := lang.Apply(tmp23, []any{tmp28, v18}) + tmp19 = tmp29 + } else { + tmp30 := checkDerefVar(var_glojure_DOT_core_print_DASH_simple) + tmp31 := lang.Apply(tmp30, []any{v17, v18}) + tmp19 = tmp31 + } + return tmp19 + }) + tmp1.AddMethod(kw_default, tmp16) + tmp17 := reflect.TypeOf(float64(0)) + var tmp18 lang.FnFunc + tmp18 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v19 := args[0] + _ = v19 + v20 := args[1] + _ = v20 + var tmp21 any + tmp22 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp23 := lang.Apply(math7.Inf, []any{int64(1)}) + tmp24 := lang.Apply(tmp22, []any{tmp23, v19}) + if lang.IsTruthy(tmp24) { + tmp25 := lang.Apply(lang.WriteWriter, []any{v20, "##Inf"}) + tmp21 = tmp25 + } else { + var tmp26 any + tmp27 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp28 := lang.Apply(math7.Inf, []any{int64(-1)}) + tmp29 := lang.Apply(tmp27, []any{tmp28, v19}) + if lang.IsTruthy(tmp29) { + tmp30 := lang.Apply(lang.WriteWriter, []any{v20, "##-Inf"}) + tmp26 = tmp30 + } else { + var tmp31 any + tmp32 := lang.Apply(math7.IsNaN, []any{v19}) + if lang.IsTruthy(tmp32) { + tmp33 := lang.Apply(lang.WriteWriter, []any{v20, "##NaN"}) + tmp31 = tmp33 + } else { + var tmp34 any + if lang.IsTruthy(kw_else) { + tmp35 := checkDerefVar(var_glojure_DOT_core_str) + tmp36 := lang.Apply(tmp35, []any{v19}) + tmp37 := lang.Apply(lang.WriteWriter, []any{v20, tmp36}) + tmp34 = tmp37 + } else { + } + tmp31 = tmp34 } - tmp13 := lang.Apply(tmp9, []any{v5, tmp12}) - var v14 any = tmp13 - _ = v14 - tmp15 := checkDerefVar(var_glojure_DOT_core_seq) - tmp16 := checkDerefVar(var_glojure_DOT_core_concat) - tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := lang.Apply(tmp17, []any{sym__DOT_reset}) - tmp19 := checkDerefVar(var_glojure_DOT_core_list) - tmp20 := lang.Apply(tmp19, []any{v14}) - tmp21 := checkDerefVar(var_glojure_DOT_core_list) - tmp22 := checkDerefVar(var_glojure_DOT_core_seq) - tmp23 := checkDerefVar(var_glojure_DOT_core_concat) - tmp24 := checkDerefVar(var_glojure_DOT_core_list) - tmp25 := lang.Apply(tmp24, []any{v6}) - tmp26 := checkDerefVar(var_glojure_DOT_core_list) - tmp27 := checkDerefVar(var_glojure_DOT_core_seq) - tmp28 := checkDerefVar(var_glojure_DOT_core_concat) - tmp29 := checkDerefVar(var_glojure_DOT_core_list) - tmp30 := lang.Apply(tmp29, []any{sym__DOT_Deref}) - tmp31 := checkDerefVar(var_glojure_DOT_core_list) - tmp32 := lang.Apply(tmp31, []any{v14}) - tmp33 := lang.Apply(tmp28, []any{tmp30, tmp32}) - tmp34 := lang.Apply(tmp27, []any{tmp33}) - tmp35 := lang.Apply(tmp26, []any{tmp34}) - tmp36 := lang.Apply(tmp23, []any{tmp25, tmp35, v7}) - tmp37 := lang.Apply(tmp22, []any{tmp36}) - tmp38 := lang.Apply(tmp21, []any{tmp37}) - tmp39 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp38}) - tmp40 := lang.Apply(tmp15, []any{tmp39}) - tmp8 = tmp40 - } // end let - return tmp8 + tmp26 = tmp31 + } + tmp21 = tmp26 } + return tmp21 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // when - { - tmp0 := sym_when.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_test, sym__AMP_, sym_body)), kw_doc, "Evaluates test. If logical true, evaluates body in an implicit do.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(11), kw_line, int(492), kw_end_DASH_line, int(492))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 3) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - tmp7 := checkDerefVar(var_glojure_DOT_core_list) - tmp8 := checkDerefVar(var_glojure_DOT_core_cons) - tmp9 := lang.Apply(tmp8, []any{sym_do, v6}) - tmp10 := lang.Apply(tmp7, []any{sym_if, v5, tmp9}) - return tmp10 + tmp1.AddMethod(tmp17, tmp18) + tmp19 := reflect.TypeOf("") + var tmp20 lang.FnFunc + tmp20 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v21 := args[0] + _ = v21 + v22 := args[1] + _ = v22 + var tmp23 any + var tmp24 any + { // let + // let binding "or__0__auto__" + tmp25 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_dup_STAR_) + var v26 any = tmp25 + _ = v26 + var tmp27 any + if lang.IsTruthy(v26) { + tmp27 = v26 + } else { + tmp28 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_readably_STAR_) + tmp27 = tmp28 + } + tmp24 = tmp27 + } // end let + if lang.IsTruthy(tmp24) { + tmp25 := lang.Apply(lang.AppendWriter, []any{v22, lang.NewChar(34)}) + _ = tmp25 + var tmp26 any + { // let + // let binding "n__0__auto__" + tmp27 := checkDerefVar(var_glojure_DOT_core_long) + tmp28 := checkDerefVar(var_glojure_DOT_core_count) + tmp29 := lang.Apply(tmp28, []any{v21}) + tmp30 := lang.Apply(tmp27, []any{tmp29}) + var v31 any = tmp30 + _ = v31 + var tmp32 any + { // let + // let binding "n" + var v33 any = int64(0) + _ = v33 + for { + var tmp34 any + tmp35 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp36 := lang.Apply(tmp35, []any{v33, v31}) + if lang.IsTruthy(tmp36) { + var tmp37 any + { // let + // let binding "c" + tmp38 := lang.Apply(lang.CharAt, []any{v21, v33}) + var v39 any = tmp38 + _ = v39 + // let binding "e" + tmp40 := checkDerefVar(var_glojure_DOT_core_char_DASH_escape_DASH_string) + tmp41 := lang.Apply(tmp40, []any{v39}) + var v42 any = tmp41 + _ = v42 + var tmp43 any + if lang.IsTruthy(v42) { + tmp44 := lang.Apply(lang.WriteWriter, []any{v22, v42}) + tmp43 = tmp44 + } else { + tmp45 := lang.Apply(lang.AppendWriter, []any{v22, v39}) + tmp43 = tmp45 + } + tmp37 = tmp43 + } // end let + _ = tmp37 + tmp39 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp40 := lang.Apply(tmp39, []any{v33}) + var tmp38 any = tmp40 + v33 = tmp38 + continue + } else { + } + tmp32 = tmp34 + break + } + } // end let + tmp26 = tmp32 + } // end let + _ = tmp26 + tmp27 := lang.Apply(lang.AppendWriter, []any{v22, lang.NewChar(34)}) + tmp23 = tmp27 + } else { + tmp28 := lang.Apply(lang.WriteWriter, []any{v22, v21}) + tmp23 = tmp28 } + _ = tmp23 + return nil }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // when-first - { - tmp0 := sym_when_DASH_first.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "bindings => x xs\n\n Roughly the same as (when (seq xs) (let [x (first xs)] body)) but xs is evaluated only once", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(11), kw_line, int(4622), kw_end_DASH_line, int(4622))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 3) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any - tmp8 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) - tmp9 := lang.Apply(tmp8, []any{v5}) - if lang.IsTruthy(tmp9) { + tmp1.AddMethod(tmp19, tmp20) + tmp21 := reflect.TypeOf(int32(0)) + var tmp22 lang.FnFunc + tmp22 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v23 := args[0] + _ = v23 + v24 := args[1] + _ = v24 + var tmp25 any + var tmp26 any + { // let + // let binding "or__0__auto__" + tmp27 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_dup_STAR_) + var v28 any = tmp27 + _ = v28 + var tmp29 any + if lang.IsTruthy(v28) { + tmp29 = v28 } else { - tmp10 := checkDerefVar(var_glojure_DOT_core_str) - tmp11 := checkDerefVar(var_glojure_DOT_core_first) - tmp12 := lang.Apply(tmp11, []any{v3}) - tmp13 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) - tmp14 := checkDerefVar(var_glojure_DOT_core_meta) - tmp15 := lang.Apply(tmp14, []any{v3}) - tmp16 := lang.Apply(kw_line, []any{tmp15}) - tmp17 := lang.Apply(tmp10, []any{tmp12, " requires ", "a vector for its binding", " in ", tmp13, ":", tmp16}) - tmp18 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp17}) - panic(tmp18) + tmp30 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_readably_STAR_) + tmp29 = tmp30 } - _ = tmp7 - var tmp19 any - tmp20 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp21 := checkDerefVar(var_glojure_DOT_core_count) - tmp22 := lang.Apply(tmp21, []any{v5}) - tmp23 := lang.Apply(tmp20, []any{int64(2), tmp22}) - if lang.IsTruthy(tmp23) { + tmp26 = tmp29 + } // end let + if lang.IsTruthy(tmp26) { + tmp27 := lang.Apply(lang.AppendWriter, []any{v24, lang.NewChar(92)}) + _ = tmp27 + var tmp28 any + { // let + // let binding "n" + tmp29 := checkDerefVar(var_glojure_DOT_core_char_DASH_name_DASH_string) + tmp30 := lang.Apply(tmp29, []any{v23}) + var v31 any = tmp30 + _ = v31 + var tmp32 any + if lang.IsTruthy(v31) { + tmp33 := lang.Apply(lang.WriteWriter, []any{v24, v31}) + tmp32 = tmp33 + } else { + tmp34 := lang.Apply(lang.AppendWriter, []any{v24, v23}) + tmp32 = tmp34 + } + tmp28 = tmp32 + } // end let + tmp25 = tmp28 + } else { + tmp29 := lang.Apply(lang.AppendWriter, []any{v24, v23}) + tmp25 = tmp29 + } + _ = tmp25 + return nil + }) + tmp1.AddMethod(tmp21, tmp22) + tmp23 := reflect.TypeOf((*lang.IPersistentMap)(nil)).Elem() + var tmp24 lang.FnFunc + tmp24 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v25 := args[0] + _ = v25 + v26 := args[1] + _ = v26 + tmp27 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) + tmp28 := lang.Apply(tmp27, []any{v25, v26}) + _ = tmp28 + var tmp29 any + { // let + // let binding "vec__234" + tmp30 := checkDerefVar(var_glojure_DOT_core_lift_DASH_ns) + tmp31 := lang.Apply(tmp30, []any{v25}) + var v32 any = tmp31 + _ = v32 + // let binding "ns" + tmp33 := checkDerefVar(var_glojure_DOT_core_nth) + tmp34 := lang.Apply(tmp33, []any{v32, int64(0), nil}) + var v35 any = tmp34 + _ = v35 + // let binding "lift-kvs" + tmp36 := checkDerefVar(var_glojure_DOT_core_nth) + tmp37 := lang.Apply(tmp36, []any{v32, int64(1), nil}) + var v38 any = tmp37 + _ = v38 + var tmp39 any + if lang.IsTruthy(v35) { + tmp40 := checkDerefVar(var_glojure_DOT_core_print_DASH_prefix_DASH_map) + tmp41 := checkDerefVar(var_glojure_DOT_core_str) + tmp42 := lang.Apply(tmp41, []any{"#:", v35}) + tmp43 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) + tmp44 := lang.Apply(tmp40, []any{tmp42, v38, tmp43, v26}) + tmp39 = tmp44 } else { - tmp24 := checkDerefVar(var_glojure_DOT_core_str) - tmp25 := checkDerefVar(var_glojure_DOT_core_first) - tmp26 := lang.Apply(tmp25, []any{v3}) - tmp27 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) - tmp28 := checkDerefVar(var_glojure_DOT_core_meta) - tmp29 := lang.Apply(tmp28, []any{v3}) - tmp30 := lang.Apply(kw_line, []any{tmp29}) - tmp31 := lang.Apply(tmp24, []any{tmp26, " requires ", "exactly 2 forms in binding vector", " in ", tmp27, ":", tmp30}) - tmp32 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp31}) - panic(tmp32) - } - _ = tmp19 - var tmp33 any + tmp45 := checkDerefVar(var_glojure_DOT_core_print_DASH_map) + tmp46 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) + tmp47 := lang.Apply(tmp45, []any{v25, tmp46, v26}) + tmp39 = tmp47 + } + tmp29 = tmp39 + } // end let + return tmp29 + }) + tmp1.AddMethod(tmp23, tmp24) + tmp25 := reflect.TypeOf((*lang.IPersistentVector)(nil)).Elem() + var tmp26 lang.FnFunc + tmp26 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v27 := args[0] + _ = v27 + v28 := args[1] + _ = v28 + tmp29 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) + tmp30 := lang.Apply(tmp29, []any{v27, v28}) + _ = tmp30 + tmp31 := checkDerefVar(var_glojure_DOT_core_print_DASH_sequential) + tmp32 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) + tmp33 := lang.Apply(tmp31, []any{"[", tmp32, " ", "]", v27, v28}) + return tmp33 + }) + tmp1.AddMethod(tmp25, tmp26) + tmp27 := reflect.TypeOf((*lang.IPersistentSet)(nil)).Elem() + var tmp28 lang.FnFunc + tmp28 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v29 := args[0] + _ = v29 + v30 := args[1] + _ = v30 + tmp31 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) + tmp32 := lang.Apply(tmp31, []any{v29, v30}) + _ = tmp32 + tmp33 := checkDerefVar(var_glojure_DOT_core_print_DASH_sequential) + tmp34 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) + tmp35 := checkDerefVar(var_glojure_DOT_core_seq) + tmp36 := lang.Apply(tmp35, []any{v29}) + tmp37 := lang.Apply(tmp33, []any{"#{", tmp34, " ", "}", tmp36, v30}) + return tmp37 + }) + tmp1.AddMethod(tmp27, tmp28) + tmp29 := reflect.TypeOf(uint8(0)) + var tmp30 lang.FnFunc + tmp30 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v31 := args[0] + _ = v31 + v32 := args[1] + _ = v32 + tmp33 := checkDerefVar(var_glojure_DOT_core_str) + tmp34 := lang.Apply(tmp33, []any{v31}) + tmp35, _ := lang.FieldOrMethod(v32, "write") + if reflect.TypeOf(tmp35).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + } + tmp36 := lang.Apply(tmp35, []any{tmp34}) + return tmp36 + }) + tmp1.AddMethod(tmp29, tmp30) + tmp31 := reflect.TypeOf((*lang.IDeref)(nil)).Elem() + var tmp32 lang.FnFunc + tmp32 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v33 := args[0] + _ = v33 + v34 := args[1] + _ = v34 + tmp35 := checkDerefVar(var_glojure_DOT_core_print_DASH_tagged_DASH_object) + tmp36 := checkDerefVar(var_glojure_DOT_core_deref_DASH_as_DASH_map) + tmp37 := lang.Apply(tmp36, []any{v33}) + tmp38 := lang.Apply(tmp35, []any{v33, tmp37, v34}) + return tmp38 + }) + tmp1.AddMethod(tmp31, tmp32) + tmp33 := reflect.TypeOf(false) + var tmp34 lang.FnFunc + tmp34 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v35 := args[0] + _ = v35 + v36 := args[1] + _ = v36 + tmp37 := checkDerefVar(var_glojure_DOT_core_str) + tmp38 := lang.Apply(tmp37, []any{v35}) + tmp39 := lang.Apply(lang.WriteWriter, []any{v36, tmp38}) + return tmp39 + }) + tmp1.AddMethod(tmp33, tmp34) + tmp35 := reflect.TypeOf((*lang.Object)(nil)).Elem() + var tmp36 lang.FnFunc + tmp36 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v37 := args[0] + _ = v37 + v38 := args[1] + _ = v38 + tmp39 := checkDerefVar(var_glojure_DOT_core_print_DASH_object) + tmp40 := lang.Apply(tmp39, []any{v37, v38}) + return tmp40 + }) + tmp1.AddMethod(tmp35, tmp36) + tmp37 := reflect.TypeOf(int(0)) + var tmp38 lang.FnFunc + tmp38 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v39 := args[0] + _ = v39 + v40 := args[1] + _ = v40 + tmp41 := checkDerefVar(var_glojure_DOT_core_str) + tmp42 := lang.Apply(tmp41, []any{v39}) + tmp43, _ := lang.FieldOrMethod(v40, "write") + if reflect.TypeOf(tmp43).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + } + tmp44 := lang.Apply(tmp43, []any{tmp42}) + return tmp44 + }) + tmp1.AddMethod(tmp37, tmp38) + tmp39 := reflect.TypeOf((*regexp15.Regexp)(nil)) + var tmp40 lang.FnFunc + tmp40 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v41 := args[0] + _ = v41 + v42 := args[1] + _ = v42 + tmp43 := lang.Apply(lang.WriteWriter, []any{v42, "#\""}) + _ = tmp43 + var tmp44 any + { // let + // let binding "G__240" + tmp45 := checkDerefVar(var_glojure_DOT_core_seq) + tmp46, ok := lang.FieldOrMethod(v41, "String") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v41, "String"))) + } + var tmp47 any + switch reflect.TypeOf(tmp46).Kind() { + case reflect.Func: + tmp47 = lang.Apply(tmp46, nil) + default: + tmp47 = tmp46 + } + tmp48 := lang.Apply(tmp45, []any{tmp47}) + var v49 any = tmp48 + _ = v49 + // let binding "vec__241" + var v50 any = v49 + _ = v50 + // let binding "seq__242" + tmp51 := checkDerefVar(var_glojure_DOT_core_seq) + tmp52 := lang.Apply(tmp51, []any{v50}) + var v53 any = tmp52 + _ = v53 + // let binding "first__243" + tmp54 := checkDerefVar(var_glojure_DOT_core_first) + tmp55 := lang.Apply(tmp54, []any{v53}) + var v56 any = tmp55 + _ = v56 + // let binding "seq__242" + tmp57 := checkDerefVar(var_glojure_DOT_core_next) + tmp58 := lang.Apply(tmp57, []any{v53}) + var v59 any = tmp58 + _ = v59 + // let binding "c" + var v60 any = v56 + _ = v60 + // let binding "r" + var v61 any = v59 + _ = v61 + // let binding "s" + var v62 any = v50 + _ = v62 + // let binding "qmode" + var v63 any = false + _ = v63 + var tmp64 any { // let - // let binding "vec__20" - var v34 any = v5 - _ = v34 - // let binding "x" - tmp35 := checkDerefVar(var_glojure_DOT_core_nth) - tmp36 := lang.Apply(tmp35, []any{v34, int64(0), nil}) - var v37 any = tmp36 - _ = v37 - // let binding "xs" - tmp38 := checkDerefVar(var_glojure_DOT_core_nth) - tmp39 := lang.Apply(tmp38, []any{v34, int64(1), nil}) - var v40 any = tmp39 - _ = v40 - tmp41 := checkDerefVar(var_glojure_DOT_core_seq) - tmp42 := checkDerefVar(var_glojure_DOT_core_concat) - tmp43 := checkDerefVar(var_glojure_DOT_core_list) - tmp44 := lang.Apply(tmp43, []any{sym_glojure_DOT_core_SLASH_when_DASH_let}) - tmp45 := checkDerefVar(var_glojure_DOT_core_list) - tmp46 := checkDerefVar(var_glojure_DOT_core_apply) - tmp47 := checkDerefVar(var_glojure_DOT_core_vector) - tmp48 := checkDerefVar(var_glojure_DOT_core_seq) - tmp49 := checkDerefVar(var_glojure_DOT_core_concat) - tmp50 := checkDerefVar(var_glojure_DOT_core_list) - tmp51 := lang.Apply(tmp50, []any{sym_xs__0__auto__}) - tmp52 := checkDerefVar(var_glojure_DOT_core_list) - tmp53 := checkDerefVar(var_glojure_DOT_core_seq) - tmp54 := checkDerefVar(var_glojure_DOT_core_concat) - tmp55 := checkDerefVar(var_glojure_DOT_core_list) - tmp56 := lang.Apply(tmp55, []any{sym_glojure_DOT_core_SLASH_seq}) - tmp57 := checkDerefVar(var_glojure_DOT_core_list) - tmp58 := lang.Apply(tmp57, []any{v40}) - tmp59 := lang.Apply(tmp54, []any{tmp56, tmp58}) - tmp60 := lang.Apply(tmp53, []any{tmp59}) - tmp61 := lang.Apply(tmp52, []any{tmp60}) - tmp62 := lang.Apply(tmp49, []any{tmp51, tmp61}) - tmp63 := lang.Apply(tmp48, []any{tmp62}) - tmp64 := lang.Apply(tmp46, []any{tmp47, tmp63}) - tmp65 := lang.Apply(tmp45, []any{tmp64}) - tmp66 := checkDerefVar(var_glojure_DOT_core_list) - tmp67 := checkDerefVar(var_glojure_DOT_core_seq) - tmp68 := checkDerefVar(var_glojure_DOT_core_concat) - tmp69 := checkDerefVar(var_glojure_DOT_core_list) - tmp70 := lang.Apply(tmp69, []any{sym_glojure_DOT_core_SLASH_let}) - tmp71 := checkDerefVar(var_glojure_DOT_core_list) - tmp72 := checkDerefVar(var_glojure_DOT_core_apply) - tmp73 := checkDerefVar(var_glojure_DOT_core_vector) - tmp74 := checkDerefVar(var_glojure_DOT_core_seq) - tmp75 := checkDerefVar(var_glojure_DOT_core_concat) - tmp76 := checkDerefVar(var_glojure_DOT_core_list) - tmp77 := lang.Apply(tmp76, []any{v37}) - tmp78 := checkDerefVar(var_glojure_DOT_core_list) - tmp79 := checkDerefVar(var_glojure_DOT_core_seq) - tmp80 := checkDerefVar(var_glojure_DOT_core_concat) - tmp81 := checkDerefVar(var_glojure_DOT_core_list) - tmp82 := lang.Apply(tmp81, []any{sym_glojure_DOT_core_SLASH_first}) - tmp83 := checkDerefVar(var_glojure_DOT_core_list) - tmp84 := lang.Apply(tmp83, []any{sym_xs__0__auto__}) - tmp85 := lang.Apply(tmp80, []any{tmp82, tmp84}) - tmp86 := lang.Apply(tmp79, []any{tmp85}) - tmp87 := lang.Apply(tmp78, []any{tmp86}) - tmp88 := lang.Apply(tmp75, []any{tmp77, tmp87}) - tmp89 := lang.Apply(tmp74, []any{tmp88}) - tmp90 := lang.Apply(tmp72, []any{tmp73, tmp89}) - tmp91 := lang.Apply(tmp71, []any{tmp90}) - tmp92 := lang.Apply(tmp68, []any{tmp70, tmp91, v6}) - tmp93 := lang.Apply(tmp67, []any{tmp92}) - tmp94 := lang.Apply(tmp66, []any{tmp93}) - tmp95 := lang.Apply(tmp42, []any{tmp44, tmp65, tmp94}) - tmp96 := lang.Apply(tmp41, []any{tmp95}) - tmp33 = tmp96 + // let binding "G__240" + var v65 any = v49 + _ = v65 + // let binding "qmode" + var v66 any = v63 + _ = v66 + for { + var tmp67 any + { // let + // let binding "vec__244" + var v68 any = v65 + _ = v68 + // let binding "seq__245" + tmp69 := checkDerefVar(var_glojure_DOT_core_seq) + tmp70 := lang.Apply(tmp69, []any{v68}) + var v71 any = tmp70 + _ = v71 + // let binding "first__246" + tmp72 := checkDerefVar(var_glojure_DOT_core_first) + tmp73 := lang.Apply(tmp72, []any{v71}) + var v74 any = tmp73 + _ = v74 + // let binding "seq__245" + tmp75 := checkDerefVar(var_glojure_DOT_core_next) + tmp76 := lang.Apply(tmp75, []any{v71}) + var v77 any = tmp76 + _ = v77 + // let binding "c" + var v78 any = v74 + _ = v78 + // let binding "r" + var v79 any = v77 + _ = v79 + // let binding "s" + var v80 any = v68 + _ = v80 + // let binding "qmode" + var v81 any = v66 + _ = v81 + var tmp82 any + if lang.IsTruthy(v80) { + var tmp83 any + tmp84 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp85 := lang.Apply(tmp84, []any{v78, lang.NewChar(92)}) + if lang.IsTruthy(tmp85) { + var tmp86 any + { // let + // let binding "vec__247" + var v87 any = v79 + _ = v87 + // let binding "seq__248" + tmp88 := checkDerefVar(var_glojure_DOT_core_seq) + tmp89 := lang.Apply(tmp88, []any{v87}) + var v90 any = tmp89 + _ = v90 + // let binding "first__249" + tmp91 := checkDerefVar(var_glojure_DOT_core_first) + tmp92 := lang.Apply(tmp91, []any{v90}) + var v93 any = tmp92 + _ = v93 + // let binding "seq__248" + tmp94 := checkDerefVar(var_glojure_DOT_core_next) + tmp95 := lang.Apply(tmp94, []any{v90}) + var v96 any = tmp95 + _ = v96 + // let binding "c2" + var v97 any = v93 + _ = v97 + // let binding "r2" + var v98 any = v96 + _ = v98 + tmp99 := lang.Apply(lang.AppendWriter, []any{v42, lang.NewChar(92)}) + _ = tmp99 + tmp100 := lang.Apply(lang.AppendWriter, []any{v42, v97}) + _ = tmp100 + var tmp101 any + if lang.IsTruthy(v81) { + var tmp102 any = v98 + tmp104 := checkDerefVar(var_glojure_DOT_core_not_EQ_) + tmp105 := lang.Apply(tmp104, []any{v97, lang.NewChar(69)}) + var tmp103 any = tmp105 + v65 = tmp102 + v66 = tmp103 + continue + } else { + var tmp106 any = v98 + tmp108 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp109 := lang.Apply(tmp108, []any{v97, lang.NewChar(81)}) + var tmp107 any = tmp109 + v65 = tmp106 + v66 = tmp107 + continue + } + tmp86 = tmp101 + } // end let + tmp83 = tmp86 + } else { + var tmp87 any + tmp88 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp89 := lang.Apply(tmp88, []any{v78, lang.NewChar(34)}) + if lang.IsTruthy(tmp89) { + var tmp90 any + if lang.IsTruthy(v81) { + tmp91 := lang.Apply(lang.WriteWriter, []any{v42, "\\E\\\"\\Q"}) + tmp90 = tmp91 + } else { + tmp92 := lang.Apply(lang.WriteWriter, []any{v42, "\\\""}) + tmp90 = tmp92 + } + _ = tmp90 + var tmp93 any = v79 + var tmp94 any = v81 + v65 = tmp93 + v66 = tmp94 + continue + } else { + var tmp95 any + if lang.IsTruthy(kw_else) { + tmp96 := lang.Apply(lang.AppendWriter, []any{v42, v78}) + _ = tmp96 + var tmp97 any = v79 + var tmp98 any = v81 + v65 = tmp97 + v66 = tmp98 + continue + } else { + } + tmp87 = tmp95 + } + tmp83 = tmp87 + } + tmp82 = tmp83 + } else { + } + tmp67 = tmp82 + } // end let + tmp64 = tmp67 + break + } } // end let - return tmp33 + tmp44 = tmp64 + } // end let + _ = tmp44 + tmp45 := lang.Apply(lang.AppendWriter, []any{v42, lang.NewChar(34)}) + return tmp45 + }) + tmp1.AddMethod(tmp39, tmp40) + tmp41 := reflect.TypeOf(int32(0)) + var tmp42 lang.FnFunc + tmp42 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v43 := args[0] + _ = v43 + v44 := args[1] + _ = v44 + tmp45 := checkDerefVar(var_glojure_DOT_core_str) + tmp46 := lang.Apply(tmp45, []any{v43}) + tmp47, _ := lang.FieldOrMethod(v44, "write") + if reflect.TypeOf(tmp47).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + } + tmp48 := lang.Apply(tmp47, []any{tmp46}) + return tmp48 + }) + tmp1.AddMethod(tmp41, tmp42) + tmp43 := reflect.TypeOf((*lang.Ratio)(nil)) + var tmp44 lang.FnFunc + tmp44 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v45 := args[0] + _ = v45 + v46 := args[1] + _ = v46 + tmp47 := checkDerefVar(var_glojure_DOT_core_str) + tmp48 := lang.Apply(tmp47, []any{v45}) + tmp49, _ := lang.FieldOrMethod(v46, "write") + if reflect.TypeOf(tmp49).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) } + tmp50 := lang.Apply(tmp49, []any{tmp48}) + return tmp50 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // when-let - { - tmp0 := sym_when_DASH_let.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "bindings => binding-form test\n\n When test is true, evaluates body with binding-form bound to the value of test", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(11), kw_line, int(1859), kw_end_DASH_line, int(1859))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 3) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any - tmp8 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) - tmp9 := lang.Apply(tmp8, []any{v5}) - if lang.IsTruthy(tmp9) { + tmp1.AddMethod(tmp43, tmp44) + tmp45 := reflect.TypeOf(float32(0)) + var tmp46 lang.FnFunc + tmp46 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v47 := args[0] + _ = v47 + v48 := args[1] + _ = v48 + var tmp49 any + tmp50 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp51 := lang.Apply(math7.Inf, []any{int64(1)}) + tmp52 := lang.Apply(lang.Builtins["float32"], []any{tmp51}) + tmp53 := lang.Apply(tmp50, []any{tmp52, v47}) + if lang.IsTruthy(tmp53) { + tmp54 := lang.Apply(lang.WriteWriter, []any{v48, "##Inf"}) + tmp49 = tmp54 + } else { + var tmp55 any + tmp56 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp57 := lang.Apply(math7.Inf, []any{int64(-1)}) + tmp58 := lang.Apply(lang.Builtins["float32"], []any{tmp57}) + tmp59 := lang.Apply(tmp56, []any{tmp58, v47}) + if lang.IsTruthy(tmp59) { + tmp60 := lang.Apply(lang.WriteWriter, []any{v48, "##-Inf"}) + tmp55 = tmp60 } else { - tmp10 := checkDerefVar(var_glojure_DOT_core_str) - tmp11 := checkDerefVar(var_glojure_DOT_core_first) - tmp12 := lang.Apply(tmp11, []any{v3}) - tmp13 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) - tmp14 := checkDerefVar(var_glojure_DOT_core_meta) - tmp15 := lang.Apply(tmp14, []any{v3}) - tmp16 := lang.Apply(kw_line, []any{tmp15}) - tmp17 := lang.Apply(tmp10, []any{tmp12, " requires ", "a vector for its binding", " in ", tmp13, ":", tmp16}) - tmp18 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp17}) - panic(tmp18) + var tmp61 any + tmp62 := lang.Apply(math7.IsNaN, []any{v47}) + if lang.IsTruthy(tmp62) { + tmp63 := lang.Apply(lang.WriteWriter, []any{v48, "##NaN"}) + tmp61 = tmp63 + } else { + var tmp64 any + if lang.IsTruthy(kw_else) { + tmp65 := checkDerefVar(var_glojure_DOT_core_str) + tmp66 := lang.Apply(tmp65, []any{v47}) + tmp67 := lang.Apply(lang.WriteWriter, []any{v48, tmp66}) + tmp64 = tmp67 + } else { + } + tmp61 = tmp64 + } + tmp55 = tmp61 } - _ = tmp7 - var tmp19 any - tmp20 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp21 := checkDerefVar(var_glojure_DOT_core_count) - tmp22 := lang.Apply(tmp21, []any{v5}) - tmp23 := lang.Apply(tmp20, []any{int64(2), tmp22}) - if lang.IsTruthy(tmp23) { - } else { - tmp24 := checkDerefVar(var_glojure_DOT_core_str) - tmp25 := checkDerefVar(var_glojure_DOT_core_first) - tmp26 := lang.Apply(tmp25, []any{v3}) - tmp27 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) - tmp28 := checkDerefVar(var_glojure_DOT_core_meta) - tmp29 := lang.Apply(tmp28, []any{v3}) - tmp30 := lang.Apply(kw_line, []any{tmp29}) - tmp31 := lang.Apply(tmp24, []any{tmp26, " requires ", "exactly 2 forms in binding vector", " in ", tmp27, ":", tmp30}) - tmp32 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp31}) - panic(tmp32) - } - _ = tmp19 - var tmp33 any - { // let - // let binding "form" - tmp34 := lang.Apply(v5, []any{int64(0)}) - var v35 any = tmp34 - _ = v35 - // let binding "tst" - tmp36 := lang.Apply(v5, []any{int64(1)}) - var v37 any = tmp36 - _ = v37 - tmp38 := checkDerefVar(var_glojure_DOT_core_seq) - tmp39 := checkDerefVar(var_glojure_DOT_core_concat) - tmp40 := checkDerefVar(var_glojure_DOT_core_list) - tmp41 := lang.Apply(tmp40, []any{sym_glojure_DOT_core_SLASH_let}) - tmp42 := checkDerefVar(var_glojure_DOT_core_list) - tmp43 := checkDerefVar(var_glojure_DOT_core_apply) - tmp44 := checkDerefVar(var_glojure_DOT_core_vector) - tmp45 := checkDerefVar(var_glojure_DOT_core_seq) - tmp46 := checkDerefVar(var_glojure_DOT_core_concat) - tmp47 := checkDerefVar(var_glojure_DOT_core_list) - tmp48 := lang.Apply(tmp47, []any{sym_temp__0__auto__}) - tmp49 := checkDerefVar(var_glojure_DOT_core_list) - tmp50 := lang.Apply(tmp49, []any{v37}) - tmp51 := lang.Apply(tmp46, []any{tmp48, tmp50}) - tmp52 := lang.Apply(tmp45, []any{tmp51}) - tmp53 := lang.Apply(tmp43, []any{tmp44, tmp52}) - tmp54 := lang.Apply(tmp42, []any{tmp53}) - tmp55 := checkDerefVar(var_glojure_DOT_core_list) - tmp56 := checkDerefVar(var_glojure_DOT_core_seq) - tmp57 := checkDerefVar(var_glojure_DOT_core_concat) - tmp58 := checkDerefVar(var_glojure_DOT_core_list) - tmp59 := lang.Apply(tmp58, []any{sym_glojure_DOT_core_SLASH_when}) - tmp60 := checkDerefVar(var_glojure_DOT_core_list) - tmp61 := lang.Apply(tmp60, []any{sym_temp__0__auto__}) - tmp62 := checkDerefVar(var_glojure_DOT_core_list) - tmp63 := checkDerefVar(var_glojure_DOT_core_seq) - tmp64 := checkDerefVar(var_glojure_DOT_core_concat) - tmp65 := checkDerefVar(var_glojure_DOT_core_list) - tmp66 := lang.Apply(tmp65, []any{sym_glojure_DOT_core_SLASH_let}) - tmp67 := checkDerefVar(var_glojure_DOT_core_list) - tmp68 := checkDerefVar(var_glojure_DOT_core_apply) - tmp69 := checkDerefVar(var_glojure_DOT_core_vector) - tmp70 := checkDerefVar(var_glojure_DOT_core_seq) - tmp71 := checkDerefVar(var_glojure_DOT_core_concat) - tmp72 := checkDerefVar(var_glojure_DOT_core_list) - tmp73 := lang.Apply(tmp72, []any{v35}) - tmp74 := checkDerefVar(var_glojure_DOT_core_list) - tmp75 := lang.Apply(tmp74, []any{sym_temp__0__auto__}) - tmp76 := lang.Apply(tmp71, []any{tmp73, tmp75}) - tmp77 := lang.Apply(tmp70, []any{tmp76}) - tmp78 := lang.Apply(tmp68, []any{tmp69, tmp77}) - tmp79 := lang.Apply(tmp67, []any{tmp78}) - tmp80 := lang.Apply(tmp64, []any{tmp66, tmp79, v6}) - tmp81 := lang.Apply(tmp63, []any{tmp80}) - tmp82 := lang.Apply(tmp62, []any{tmp81}) - tmp83 := lang.Apply(tmp57, []any{tmp59, tmp61, tmp82}) - tmp84 := lang.Apply(tmp56, []any{tmp83}) - tmp85 := lang.Apply(tmp55, []any{tmp84}) - tmp86 := lang.Apply(tmp39, []any{tmp41, tmp54, tmp85}) - tmp87 := lang.Apply(tmp38, []any{tmp86}) - tmp33 = tmp87 - } // end let - return tmp33 + tmp49 = tmp55 } + return tmp49 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // when-not - { - tmp0 := sym_when_DASH_not.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_test, sym__AMP_, sym_body)), kw_doc, "Evaluates test. If logical false, evaluates body in an implicit do.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(11), kw_line, int(498), kw_end_DASH_line, int(498))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 3) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - tmp7 := checkDerefVar(var_glojure_DOT_core_list) - tmp8 := checkDerefVar(var_glojure_DOT_core_cons) - tmp9 := lang.Apply(tmp8, []any{sym_do, v6}) - tmp10 := lang.Apply(tmp7, []any{sym_if, v5, nil, tmp9}) - return tmp10 + tmp1.AddMethod(tmp45, tmp46) + tmp47 := reflect.TypeOf(int16(0)) + var tmp48 lang.FnFunc + tmp48 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v49 := args[0] + _ = v49 + v50 := args[1] + _ = v50 + tmp51 := checkDerefVar(var_glojure_DOT_core_str) + tmp52 := lang.Apply(tmp51, []any{v49}) + tmp53, _ := lang.FieldOrMethod(v50, "write") + if reflect.TypeOf(tmp53).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) } + tmp54 := lang.Apply(tmp53, []any{tmp52}) + return tmp54 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // when-some - { - tmp0 := sym_when_DASH_some.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "bindings => binding-form test\n\n When test is not nil, evaluates body with binding-form bound to the\n value of test", kw_file, "glojure/core.glj", kw_added, "1.6", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(11), kw_line, int(1894), kw_end_DASH_line, int(1894))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 3) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any - tmp8 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) - tmp9 := lang.Apply(tmp8, []any{v5}) - if lang.IsTruthy(tmp9) { - } else { - tmp10 := checkDerefVar(var_glojure_DOT_core_str) - tmp11 := checkDerefVar(var_glojure_DOT_core_first) - tmp12 := lang.Apply(tmp11, []any{v3}) - tmp13 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) - tmp14 := checkDerefVar(var_glojure_DOT_core_meta) - tmp15 := lang.Apply(tmp14, []any{v3}) - tmp16 := lang.Apply(kw_line, []any{tmp15}) - tmp17 := lang.Apply(tmp10, []any{tmp12, " requires ", "a vector for its binding", " in ", tmp13, ":", tmp16}) - tmp18 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp17}) - panic(tmp18) - } - _ = tmp7 - var tmp19 any - tmp20 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp21 := checkDerefVar(var_glojure_DOT_core_count) - tmp22 := lang.Apply(tmp21, []any{v5}) - tmp23 := lang.Apply(tmp20, []any{int64(2), tmp22}) - if lang.IsTruthy(tmp23) { - } else { - tmp24 := checkDerefVar(var_glojure_DOT_core_str) - tmp25 := checkDerefVar(var_glojure_DOT_core_first) - tmp26 := lang.Apply(tmp25, []any{v3}) - tmp27 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) - tmp28 := checkDerefVar(var_glojure_DOT_core_meta) - tmp29 := lang.Apply(tmp28, []any{v3}) - tmp30 := lang.Apply(kw_line, []any{tmp29}) - tmp31 := lang.Apply(tmp24, []any{tmp26, " requires ", "exactly 2 forms in binding vector", " in ", tmp27, ":", tmp30}) - tmp32 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp31}) - panic(tmp32) - } - _ = tmp19 - var tmp33 any - { // let - // let binding "form" - tmp34 := lang.Apply(v5, []any{int64(0)}) - var v35 any = tmp34 - _ = v35 - // let binding "tst" - tmp36 := lang.Apply(v5, []any{int64(1)}) - var v37 any = tmp36 - _ = v37 - tmp38 := checkDerefVar(var_glojure_DOT_core_seq) - tmp39 := checkDerefVar(var_glojure_DOT_core_concat) - tmp40 := checkDerefVar(var_glojure_DOT_core_list) - tmp41 := lang.Apply(tmp40, []any{sym_glojure_DOT_core_SLASH_let}) - tmp42 := checkDerefVar(var_glojure_DOT_core_list) - tmp43 := checkDerefVar(var_glojure_DOT_core_apply) - tmp44 := checkDerefVar(var_glojure_DOT_core_vector) - tmp45 := checkDerefVar(var_glojure_DOT_core_seq) - tmp46 := checkDerefVar(var_glojure_DOT_core_concat) - tmp47 := checkDerefVar(var_glojure_DOT_core_list) - tmp48 := lang.Apply(tmp47, []any{sym_temp__0__auto__}) - tmp49 := checkDerefVar(var_glojure_DOT_core_list) - tmp50 := lang.Apply(tmp49, []any{v37}) - tmp51 := lang.Apply(tmp46, []any{tmp48, tmp50}) - tmp52 := lang.Apply(tmp45, []any{tmp51}) - tmp53 := lang.Apply(tmp43, []any{tmp44, tmp52}) - tmp54 := lang.Apply(tmp42, []any{tmp53}) - tmp55 := checkDerefVar(var_glojure_DOT_core_list) - tmp56 := checkDerefVar(var_glojure_DOT_core_seq) - tmp57 := checkDerefVar(var_glojure_DOT_core_concat) - tmp58 := checkDerefVar(var_glojure_DOT_core_list) - tmp59 := lang.Apply(tmp58, []any{sym_if}) - tmp60 := checkDerefVar(var_glojure_DOT_core_list) - tmp61 := checkDerefVar(var_glojure_DOT_core_seq) - tmp62 := checkDerefVar(var_glojure_DOT_core_concat) - tmp63 := checkDerefVar(var_glojure_DOT_core_list) - tmp64 := lang.Apply(tmp63, []any{sym_glojure_DOT_core_SLASH_nil_QMARK_}) - tmp65 := checkDerefVar(var_glojure_DOT_core_list) - tmp66 := lang.Apply(tmp65, []any{sym_temp__0__auto__}) - tmp67 := lang.Apply(tmp62, []any{tmp64, tmp66}) - tmp68 := lang.Apply(tmp61, []any{tmp67}) - tmp69 := lang.Apply(tmp60, []any{tmp68}) - tmp70 := checkDerefVar(var_glojure_DOT_core_list) - tmp71 := lang.Apply(tmp70, []any{nil}) - tmp72 := checkDerefVar(var_glojure_DOT_core_list) - tmp73 := checkDerefVar(var_glojure_DOT_core_seq) - tmp74 := checkDerefVar(var_glojure_DOT_core_concat) - tmp75 := checkDerefVar(var_glojure_DOT_core_list) - tmp76 := lang.Apply(tmp75, []any{sym_glojure_DOT_core_SLASH_let}) - tmp77 := checkDerefVar(var_glojure_DOT_core_list) - tmp78 := checkDerefVar(var_glojure_DOT_core_apply) - tmp79 := checkDerefVar(var_glojure_DOT_core_vector) - tmp80 := checkDerefVar(var_glojure_DOT_core_seq) - tmp81 := checkDerefVar(var_glojure_DOT_core_concat) - tmp82 := checkDerefVar(var_glojure_DOT_core_list) - tmp83 := lang.Apply(tmp82, []any{v35}) - tmp84 := checkDerefVar(var_glojure_DOT_core_list) - tmp85 := lang.Apply(tmp84, []any{sym_temp__0__auto__}) - tmp86 := lang.Apply(tmp81, []any{tmp83, tmp85}) - tmp87 := lang.Apply(tmp80, []any{tmp86}) - tmp88 := lang.Apply(tmp78, []any{tmp79, tmp87}) - tmp89 := lang.Apply(tmp77, []any{tmp88}) - tmp90 := lang.Apply(tmp74, []any{tmp76, tmp89, v6}) - tmp91 := lang.Apply(tmp73, []any{tmp90}) - tmp92 := lang.Apply(tmp72, []any{tmp91}) - tmp93 := lang.Apply(tmp57, []any{tmp59, tmp69, tmp71, tmp92}) - tmp94 := lang.Apply(tmp56, []any{tmp93}) - tmp95 := lang.Apply(tmp55, []any{tmp94}) - tmp96 := lang.Apply(tmp39, []any{tmp41, tmp54, tmp95}) - tmp97 := lang.Apply(tmp38, []any{tmp96}) - tmp33 = tmp97 - } // end let - return tmp33 + tmp1.AddMethod(tmp47, tmp48) + tmp49 := reflect.TypeOf((*lang.Var)(nil)) + var tmp50 lang.FnFunc + tmp50 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v51 := args[0] + _ = v51 + v52 := args[1] + _ = v52 + tmp53 := checkDerefVar(var_glojure_DOT_core_print_DASH_simple) + tmp54 := lang.Apply(tmp53, []any{v51, v52}) + return tmp54 + }) + tmp1.AddMethod(tmp49, tmp50) + tmp51 := reflect.TypeOf(int8(0)) + var tmp52 lang.FnFunc + tmp52 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v53 := args[0] + _ = v53 + v54 := args[1] + _ = v54 + tmp55 := checkDerefVar(var_glojure_DOT_core_str) + tmp56 := lang.Apply(tmp55, []any{v53}) + tmp57, _ := lang.FieldOrMethod(v54, "write") + if reflect.TypeOf(tmp57).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) } + tmp58 := lang.Apply(tmp57, []any{tmp56}) + return tmp58 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1.AddMethod(tmp51, tmp52) + tmp53 := reflect.TypeOf(uint16(0)) + var tmp54 lang.FnFunc + tmp54 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v55 := args[0] + _ = v55 + v56 := args[1] + _ = v56 + tmp57 := checkDerefVar(var_glojure_DOT_core_str) + tmp58 := lang.Apply(tmp57, []any{v55}) + tmp59, _ := lang.FieldOrMethod(v56, "write") + if reflect.TypeOf(tmp59).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + } + tmp60 := lang.Apply(tmp59, []any{tmp58}) + return tmp60 + }) + tmp1.AddMethod(tmp53, tmp54) + tmp55 := reflect.TypeOf(uint64(0)) + var tmp56 lang.FnFunc + tmp56 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v57 := args[0] + _ = v57 + v58 := args[1] + _ = v58 + tmp59 := checkDerefVar(var_glojure_DOT_core_str) + tmp60 := lang.Apply(tmp59, []any{v57}) + tmp61, _ := lang.FieldOrMethod(v58, "write") + if reflect.TypeOf(tmp61).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + } + tmp62 := lang.Apply(tmp61, []any{tmp60}) + return tmp62 + }) + tmp1.AddMethod(tmp55, tmp56) + tmp57 := reflect.TypeOf((*lang.BigDecimal)(nil)) + var tmp58 lang.FnFunc + tmp58 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v59 := args[0] + _ = v59 + v60 := args[1] + _ = v60 + tmp61 := checkDerefVar(var_glojure_DOT_core_str) + tmp62 := lang.Apply(tmp61, []any{v59}) + tmp63 := lang.Apply(lang.WriteWriter, []any{v60, tmp62}) + _ = tmp63 + tmp64 := lang.Apply(lang.WriteWriter, []any{v60, "M"}) + return tmp64 + }) + tmp1.AddMethod(tmp57, tmp58) + tmp59 := reflect.TypeOf((*lang.BigInt)(nil)) + var tmp60 lang.FnFunc + tmp60 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v61 := args[0] + _ = v61 + v62 := args[1] + _ = v62 + tmp63 := checkDerefVar(var_glojure_DOT_core_str) + tmp64 := lang.Apply(tmp63, []any{v61}) + tmp65 := lang.Apply(lang.WriteWriter, []any{v62, tmp64}) + _ = tmp65 + tmp66 := lang.Apply(lang.WriteWriter, []any{v62, "N"}) + return tmp66 + }) + tmp1.AddMethod(tmp59, tmp60) + tmp61 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() + var tmp62 lang.FnFunc + tmp62 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v63 := args[0] + _ = v63 + v64 := args[1] + _ = v64 + tmp65 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) + tmp66 := lang.Apply(tmp65, []any{v63, v64}) + _ = tmp66 + tmp67 := checkDerefVar(var_glojure_DOT_core_print_DASH_sequential) + tmp68 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) + tmp69 := lang.Apply(tmp67, []any{"(", tmp68, " ", ")", v63, v64}) + return tmp69 + }) + tmp1.AddMethod(tmp61, tmp62) + tmp63 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() + tmp64 := reflect.TypeOf((*lang.IPersistentCollection)(nil)).Elem() + tmp1.PreferMethod(tmp63, tmp64) + tmp65 := reflect.TypeOf((*lang.IRecord)(nil)).Elem() + tmp66 := reflect.TypeOf((*lang.IPersistentMap)(nil)).Elem() + tmp1.PreferMethod(tmp65, tmp66) + var_glojure_DOT_core_print_DASH_method = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_print_DASH_method.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // while + // print-tagged-object { - tmp0 := sym_while.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_test, sym__AMP_, sym_body)), kw_doc, "Repeatedly executes body while test expression is true. Presumes\n some side-effect will cause test to become false/nil. Returns nil", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(11), kw_line, int(6327), kw_end_DASH_line, int(6327))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 3) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - tmp7 := checkDerefVar(var_glojure_DOT_core_seq) - tmp8 := checkDerefVar(var_glojure_DOT_core_concat) - tmp9 := checkDerefVar(var_glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_core_SLASH_loop}) - tmp11 := checkDerefVar(var_glojure_DOT_core_list) - tmp12 := checkDerefVar(var_glojure_DOT_core_apply) - tmp13 := checkDerefVar(var_glojure_DOT_core_vector) - tmp14 := checkDerefVar(var_glojure_DOT_core_seq) - tmp15 := checkDerefVar(var_glojure_DOT_core_concat) - tmp16 := lang.Apply(tmp15, nil) - tmp17 := lang.Apply(tmp14, []any{tmp16}) - tmp18 := lang.Apply(tmp12, []any{tmp13, tmp17}) - tmp19 := lang.Apply(tmp11, []any{tmp18}) - tmp20 := checkDerefVar(var_glojure_DOT_core_list) - tmp21 := checkDerefVar(var_glojure_DOT_core_seq) - tmp22 := checkDerefVar(var_glojure_DOT_core_concat) - tmp23 := checkDerefVar(var_glojure_DOT_core_list) - tmp24 := lang.Apply(tmp23, []any{sym_glojure_DOT_core_SLASH_when}) - tmp25 := checkDerefVar(var_glojure_DOT_core_list) - tmp26 := lang.Apply(tmp25, []any{v5}) - tmp27 := checkDerefVar(var_glojure_DOT_core_list) - tmp28 := checkDerefVar(var_glojure_DOT_core_seq) - tmp29 := checkDerefVar(var_glojure_DOT_core_concat) - tmp30 := checkDerefVar(var_glojure_DOT_core_list) - tmp31 := lang.Apply(tmp30, []any{sym_recur}) - tmp32 := lang.Apply(tmp29, []any{tmp31}) - tmp33 := lang.Apply(tmp28, []any{tmp32}) - tmp34 := lang.Apply(tmp27, []any{tmp33}) - tmp35 := lang.Apply(tmp22, []any{tmp24, tmp26, v6, tmp34}) - tmp36 := lang.Apply(tmp21, []any{tmp35}) - tmp37 := lang.Apply(tmp20, []any{tmp36}) - tmp38 := lang.Apply(tmp8, []any{tmp10, tmp19, tmp37}) - tmp39 := lang.Apply(tmp7, []any{tmp38}) - return tmp39 + tmp0 := sym_print_DASH_tagged_DASH_object.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(102), kw_column, int(8), kw_end_DASH_line, int(102), kw_end_DASH_column, int(26), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_o, sym_rep, sym_w)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp7 := reflect.TypeOf((*lang.IMeta)(nil)).Elem() + tmp8 := lang.Apply(tmp6, []any{tmp7, v2}) + if lang.IsTruthy(tmp8) { + tmp9 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) + tmp10 := lang.Apply(tmp9, []any{v2, v4}) + tmp5 = tmp10 + } else { } + _ = tmp5 + tmp11 := lang.Apply(lang.WriteWriter, []any{v4, "#object["}) + _ = tmp11 + var tmp12 any + { // let + // let binding "c" + tmp13 := checkDerefVar(var_glojure_DOT_core_class) + tmp14 := lang.Apply(tmp13, []any{v2}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + if lang.IsTruthy(false) { + tmp17 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp18, ok := lang.FieldOrMethod(v15, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v15, "Name"))) + } + var tmp19 any + switch reflect.TypeOf(tmp18).Kind() { + case reflect.Func: + tmp19 = lang.Apply(tmp18, nil) + default: + tmp19 = tmp18 + } + tmp20 := lang.Apply(tmp17, []any{tmp19, v4}) + tmp16 = tmp20 + } else { + tmp21, ok := lang.FieldOrMethod(v15, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v15, "Name"))) + } + var tmp22 any + switch reflect.TypeOf(tmp21).Kind() { + case reflect.Func: + tmp22 = lang.Apply(tmp21, nil) + default: + tmp22 = tmp21 + } + tmp23 := lang.Apply(lang.WriteWriter, []any{v4, tmp22}) + tmp16 = tmp23 + } + tmp12 = tmp16 + } // end let + _ = tmp12 + tmp13 := lang.Apply(lang.WriteWriter, []any{v4, " "}) + _ = tmp13 + tmp14 := checkDerefVar(var_glojure_DOT_core_format) + tmp15 := lang.Apply(lang.IdentityHash, []any{v2}) + tmp16 := lang.Apply(tmp14, []any{"0x%x ", tmp15}) + tmp17 := lang.Apply(lang.WriteWriter, []any{v4, tmp16}) + _ = tmp17 + tmp18 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp19 := lang.Apply(tmp18, []any{v3, v4}) + _ = tmp19 + tmp20 := lang.Apply(lang.WriteWriter, []any{v4, "]"}) + return tmp20 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_print_DASH_tagged_DASH_object = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_print_DASH_tagged_DASH_object.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // with-bindings + // print-throwable { - tmp0 := sym_with_DASH_bindings.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_binding_DASH_map, sym__AMP_, sym_body)), kw_doc, "Takes a map of Var/value pairs. Installs for the given Vars the associated\n values as thread-local bindings. Then executes body. Pops the installed\n bindings after body was evaluated. Returns the value of body.", kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(11), kw_line, int(1984), kw_end_DASH_line, int(1984))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 3) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - tmp7 := checkDerefVar(var_glojure_DOT_core_seq) - tmp8 := checkDerefVar(var_glojure_DOT_core_concat) - tmp9 := checkDerefVar(var_glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_core_SLASH_with_DASH_bindings_STAR_}) - tmp11 := checkDerefVar(var_glojure_DOT_core_list) - tmp12 := lang.Apply(tmp11, []any{v5}) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := checkDerefVar(var_glojure_DOT_core_seq) - tmp15 := checkDerefVar(var_glojure_DOT_core_concat) - tmp16 := checkDerefVar(var_glojure_DOT_core_list) - tmp17 := lang.Apply(tmp16, []any{sym_glojure_DOT_core_SLASH_fn}) - tmp18 := checkDerefVar(var_glojure_DOT_core_list) - tmp19 := checkDerefVar(var_glojure_DOT_core_apply) - tmp20 := checkDerefVar(var_glojure_DOT_core_vector) - tmp21 := checkDerefVar(var_glojure_DOT_core_seq) - tmp22 := checkDerefVar(var_glojure_DOT_core_concat) - tmp23 := lang.Apply(tmp22, nil) - tmp24 := lang.Apply(tmp21, []any{tmp23}) - tmp25 := lang.Apply(tmp19, []any{tmp20, tmp24}) - tmp26 := lang.Apply(tmp18, []any{tmp25}) - tmp27 := lang.Apply(tmp15, []any{tmp17, tmp26, v6}) - tmp28 := lang.Apply(tmp14, []any{tmp27}) - tmp29 := lang.Apply(tmp13, []any{tmp28}) - tmp30 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp29}) - tmp31 := lang.Apply(tmp7, []any{tmp30}) - return tmp31 - } + tmp0 := sym_print_DASH_throwable.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(478), kw_column, int(8), kw_end_DASH_line, int(478), kw_end_DASH_column, int(22), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_o, sym_w)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := lang.Apply(lang.WriteWriter, []any{v3, "#error {\n :cause "}) + _ = tmp4 + var tmp5 any + { // let + // let binding "map__253" + tmp6 := checkDerefVar(var_glojure_DOT_core_Throwable_DASH__GT_map) + tmp7 := lang.Apply(tmp6, []any{v2}) + var v8 any = tmp7 + _ = v8 + // let binding "map__253" + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp11 := lang.Apply(tmp10, []any{v8}) + if lang.IsTruthy(tmp11) { + var tmp12 any + tmp13 := checkDerefVar(var_glojure_DOT_core_next) + tmp14 := lang.Apply(tmp13, []any{v8}) + if lang.IsTruthy(tmp14) { + tmp15 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) + tmp16 := lang.Apply(tmp15, []any{v8}) + tmp17 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{tmp16}) + tmp12 = tmp17 + } else { + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_seq) + tmp20 := lang.Apply(tmp19, []any{v8}) + if lang.IsTruthy(tmp20) { + tmp21 := checkDerefVar(var_glojure_DOT_core_first) + tmp22 := lang.Apply(tmp21, []any{v8}) + tmp18 = tmp22 + } else { + } + tmp12 = tmp18 + } + tmp9 = tmp12 + } else { + tmp9 = v8 + } + var v23 any = tmp9 + _ = v23 + // let binding "cause" + tmp24 := checkDerefVar(var_glojure_DOT_core_get) + tmp25 := lang.Apply(tmp24, []any{v23, kw_cause}) + var v26 any = tmp25 + _ = v26 + // let binding "data" + tmp27 := checkDerefVar(var_glojure_DOT_core_get) + tmp28 := lang.Apply(tmp27, []any{v23, kw_data}) + var v29 any = tmp28 + _ = v29 + // let binding "via" + tmp30 := checkDerefVar(var_glojure_DOT_core_get) + tmp31 := lang.Apply(tmp30, []any{v23, kw_via}) + var v32 any = tmp31 + _ = v32 + // let binding "trace" + tmp33 := checkDerefVar(var_glojure_DOT_core_get) + tmp34 := lang.Apply(tmp33, []any{v23, kw_trace}) + var v35 any = tmp34 + _ = v35 + // let binding "print-via" + var tmp36 lang.FnFunc + tmp36 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v37 := args[0] + _ = v37 + tmp38 := lang.Apply(lang.WriteWriter, []any{v3, "{:type "}) + _ = tmp38 + tmp39 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp40 := lang.Apply(kw_type, []any{v37}) + tmp41 := lang.Apply(tmp39, []any{tmp40, v3}) + _ = tmp41 + tmp42 := lang.Apply(lang.WriteWriter, []any{v3, "\n :message "}) + _ = tmp42 + tmp43 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp44 := lang.Apply(kw_message, []any{v37}) + tmp45 := lang.Apply(tmp43, []any{tmp44, v3}) + _ = tmp45 + var tmp46 any + { // let + // let binding "temp__0__auto__" + tmp47 := lang.Apply(kw_data, []any{v37}) + var v48 any = tmp47 + _ = v48 + var tmp49 any + if lang.IsTruthy(v48) { + var tmp50 any + { // let + // let binding "data" + var v51 any = v48 + _ = v51 + tmp52 := lang.Apply(lang.WriteWriter, []any{v3, "\n :data "}) + _ = tmp52 + tmp53 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp54 := lang.Apply(tmp53, []any{v51, v3}) + tmp50 = tmp54 + } // end let + tmp49 = tmp50 + } else { + } + tmp46 = tmp49 + } // end let + _ = tmp46 + var tmp47 any + { // let + // let binding "temp__0__auto__" + tmp48 := lang.Apply(kw_at, []any{v37}) + var v49 any = tmp48 + _ = v49 + var tmp50 any + if lang.IsTruthy(v49) { + var tmp51 any + { // let + // let binding "at" + var v52 any = v49 + _ = v52 + tmp53 := lang.Apply(lang.WriteWriter, []any{v3, "\n :at "}) + _ = tmp53 + tmp54 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp55 := lang.Apply(kw_at, []any{v37}) + tmp56 := lang.Apply(tmp54, []any{tmp55, v3}) + tmp51 = tmp56 + } // end let + tmp50 = tmp51 + } else { + } + tmp47 = tmp50 + } // end let + _ = tmp47 + tmp48 := lang.Apply(lang.WriteWriter, []any{v3, "}"}) + return tmp48 + }) + tmp37 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(481), kw_column, int(19), kw_end_DASH_line, int(491), kw_end_DASH_column, int(73)) + tmp38, err := lang.WithMeta(tmp36, tmp37.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v39 any = tmp38 + _ = v39 + tmp40 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp41 := lang.Apply(tmp40, []any{v26, v3}) + _ = tmp41 + var tmp42 any + if lang.IsTruthy(v29) { + tmp43 := lang.Apply(lang.WriteWriter, []any{v3, "\n :data "}) + _ = tmp43 + tmp44 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp45 := lang.Apply(tmp44, []any{v29, v3}) + tmp42 = tmp45 + } else { + } + _ = tmp42 + var tmp46 any + if lang.IsTruthy(v32) { + tmp47 := lang.Apply(lang.WriteWriter, []any{v3, "\n :via\n ["}) + _ = tmp47 + var tmp48 any + { // let + // let binding "temp__0__auto__" + tmp49 := checkDerefVar(var_glojure_DOT_core_first) + tmp50 := lang.Apply(tmp49, []any{v32}) + var v51 any = tmp50 + _ = v51 + var tmp52 any + if lang.IsTruthy(v51) { + var tmp53 any + { // let + // let binding "fv" + var v54 any = v51 + _ = v54 + tmp55 := lang.Apply(v39, []any{v54}) + _ = tmp55 + var tmp56 any + { // let + // let binding "seq_254" + tmp57 := checkDerefVar(var_glojure_DOT_core_seq) + tmp58 := checkDerefVar(var_glojure_DOT_core_rest) + tmp59 := lang.Apply(tmp58, []any{v32}) + tmp60 := lang.Apply(tmp57, []any{tmp59}) + var v61 any = tmp60 + _ = v61 + // let binding "chunk_255" + var v62 any = nil + _ = v62 + // let binding "count_256" + var v63 any = int64(0) + _ = v63 + // let binding "i_257" + var v64 any = int64(0) + _ = v64 + for { + var tmp65 any + tmp66 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp67 := lang.Apply(tmp66, []any{v64, v63}) + if lang.IsTruthy(tmp67) { + var tmp68 any + { // let + // let binding "v" + tmp69, _ := lang.FieldOrMethod(v62, "nth") + if reflect.TypeOf(tmp69).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp70 := lang.Apply(tmp69, []any{v64}) + var v71 any = tmp70 + _ = v71 + tmp72 := lang.Apply(lang.WriteWriter, []any{v3, "\n "}) + _ = tmp72 + tmp73 := lang.Apply(v39, []any{v71}) + _ = tmp73 + var tmp74 any = v61 + var tmp75 any = v62 + var tmp76 any = v63 + tmp78 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp79 := lang.Apply(tmp78, []any{v64}) + var tmp77 any = tmp79 + v61 = tmp74 + v62 = tmp75 + v63 = tmp76 + v64 = tmp77 + continue + } // end let + tmp65 = tmp68 + } else { + var tmp69 any + { // let + // let binding "temp__0__auto__" + tmp70 := checkDerefVar(var_glojure_DOT_core_seq) + tmp71 := lang.Apply(tmp70, []any{v61}) + var v72 any = tmp71 + _ = v72 + var tmp73 any + if lang.IsTruthy(v72) { + var tmp74 any + { // let + // let binding "seq_254" + var v75 any = v72 + _ = v75 + var tmp76 any + tmp77 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp78 := lang.Apply(tmp77, []any{v75}) + if lang.IsTruthy(tmp78) { + var tmp79 any + { // let + // let binding "c__0__auto__" + tmp80 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp81 := lang.Apply(tmp80, []any{v75}) + var v82 any = tmp81 + _ = v82 + tmp84 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp85 := lang.Apply(tmp84, []any{v75}) + var tmp83 any = tmp85 + var tmp86 any = v82 + tmp88 := checkDerefVar(var_glojure_DOT_core_int) + tmp89 := checkDerefVar(var_glojure_DOT_core_count) + tmp90 := lang.Apply(tmp89, []any{v82}) + tmp91 := lang.Apply(tmp88, []any{tmp90}) + var tmp87 any = tmp91 + tmp93 := checkDerefVar(var_glojure_DOT_core_int) + tmp94 := lang.Apply(tmp93, []any{int64(0)}) + var tmp92 any = tmp94 + v61 = tmp83 + v62 = tmp86 + v63 = tmp87 + v64 = tmp92 + continue + } // end let + tmp76 = tmp79 + } else { + var tmp80 any + { // let + // let binding "v" + tmp81 := checkDerefVar(var_glojure_DOT_core_first) + tmp82 := lang.Apply(tmp81, []any{v75}) + var v83 any = tmp82 + _ = v83 + tmp84 := lang.Apply(lang.WriteWriter, []any{v3, "\n "}) + _ = tmp84 + tmp85 := lang.Apply(v39, []any{v83}) + _ = tmp85 + tmp87 := checkDerefVar(var_glojure_DOT_core_next) + tmp88 := lang.Apply(tmp87, []any{v75}) + var tmp86 any = tmp88 + var tmp89 any = nil + var tmp90 any = int64(0) + var tmp91 any = int64(0) + v61 = tmp86 + v62 = tmp89 + v63 = tmp90 + v64 = tmp91 + continue + } // end let + tmp76 = tmp80 + } + tmp74 = tmp76 + } // end let + tmp73 = tmp74 + } else { + } + tmp69 = tmp73 + } // end let + tmp65 = tmp69 + } + tmp56 = tmp65 + break + } + } // end let + tmp53 = tmp56 + } // end let + tmp52 = tmp53 + } else { + } + tmp48 = tmp52 + } // end let + _ = tmp48 + tmp49 := lang.Apply(lang.WriteWriter, []any{v3, "]"}) + tmp46 = tmp49 + } else { + } + _ = tmp46 + var tmp50 any + if lang.IsTruthy(v35) { + tmp51 := lang.Apply(lang.WriteWriter, []any{v3, "\n :trace\n ["}) + _ = tmp51 + var tmp52 any + { // let + // let binding "temp__0__auto__" + tmp53 := checkDerefVar(var_glojure_DOT_core_first) + tmp54 := lang.Apply(tmp53, []any{v35}) + var v55 any = tmp54 + _ = v55 + var tmp56 any + if lang.IsTruthy(v55) { + var tmp57 any + { // let + // let binding "ft" + var v58 any = v55 + _ = v58 + tmp59 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp60 := lang.Apply(tmp59, []any{v58, v3}) + _ = tmp60 + var tmp61 any + { // let + // let binding "seq_258" + tmp62 := checkDerefVar(var_glojure_DOT_core_seq) + tmp63 := checkDerefVar(var_glojure_DOT_core_rest) + tmp64 := lang.Apply(tmp63, []any{v35}) + tmp65 := lang.Apply(tmp62, []any{tmp64}) + var v66 any = tmp65 + _ = v66 + // let binding "chunk_259" + var v67 any = nil + _ = v67 + // let binding "count_260" + var v68 any = int64(0) + _ = v68 + // let binding "i_261" + var v69 any = int64(0) + _ = v69 + for { + var tmp70 any + tmp71 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp72 := lang.Apply(tmp71, []any{v69, v68}) + if lang.IsTruthy(tmp72) { + var tmp73 any + { // let + // let binding "t" + tmp74, _ := lang.FieldOrMethod(v67, "nth") + if reflect.TypeOf(tmp74).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp75 := lang.Apply(tmp74, []any{v69}) + var v76 any = tmp75 + _ = v76 + tmp77 := lang.Apply(lang.WriteWriter, []any{v3, "\n "}) + _ = tmp77 + tmp78 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp79 := lang.Apply(tmp78, []any{v76, v3}) + _ = tmp79 + var tmp80 any = v66 + var tmp81 any = v67 + var tmp82 any = v68 + tmp84 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp85 := lang.Apply(tmp84, []any{v69}) + var tmp83 any = tmp85 + v66 = tmp80 + v67 = tmp81 + v68 = tmp82 + v69 = tmp83 + continue + } // end let + tmp70 = tmp73 + } else { + var tmp74 any + { // let + // let binding "temp__0__auto__" + tmp75 := checkDerefVar(var_glojure_DOT_core_seq) + tmp76 := lang.Apply(tmp75, []any{v66}) + var v77 any = tmp76 + _ = v77 + var tmp78 any + if lang.IsTruthy(v77) { + var tmp79 any + { // let + // let binding "seq_258" + var v80 any = v77 + _ = v80 + var tmp81 any + tmp82 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp83 := lang.Apply(tmp82, []any{v80}) + if lang.IsTruthy(tmp83) { + var tmp84 any + { // let + // let binding "c__0__auto__" + tmp85 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp86 := lang.Apply(tmp85, []any{v80}) + var v87 any = tmp86 + _ = v87 + tmp89 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp90 := lang.Apply(tmp89, []any{v80}) + var tmp88 any = tmp90 + var tmp91 any = v87 + tmp93 := checkDerefVar(var_glojure_DOT_core_int) + tmp94 := checkDerefVar(var_glojure_DOT_core_count) + tmp95 := lang.Apply(tmp94, []any{v87}) + tmp96 := lang.Apply(tmp93, []any{tmp95}) + var tmp92 any = tmp96 + tmp98 := checkDerefVar(var_glojure_DOT_core_int) + tmp99 := lang.Apply(tmp98, []any{int64(0)}) + var tmp97 any = tmp99 + v66 = tmp88 + v67 = tmp91 + v68 = tmp92 + v69 = tmp97 + continue + } // end let + tmp81 = tmp84 + } else { + var tmp85 any + { // let + // let binding "t" + tmp86 := checkDerefVar(var_glojure_DOT_core_first) + tmp87 := lang.Apply(tmp86, []any{v80}) + var v88 any = tmp87 + _ = v88 + tmp89 := lang.Apply(lang.WriteWriter, []any{v3, "\n "}) + _ = tmp89 + tmp90 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp91 := lang.Apply(tmp90, []any{v88, v3}) + _ = tmp91 + tmp93 := checkDerefVar(var_glojure_DOT_core_next) + tmp94 := lang.Apply(tmp93, []any{v80}) + var tmp92 any = tmp94 + var tmp95 any = nil + var tmp96 any = int64(0) + var tmp97 any = int64(0) + v66 = tmp92 + v67 = tmp95 + v68 = tmp96 + v69 = tmp97 + continue + } // end let + tmp81 = tmp85 + } + tmp79 = tmp81 + } // end let + tmp78 = tmp79 + } else { + } + tmp74 = tmp78 + } // end let + tmp70 = tmp74 + } + tmp61 = tmp70 + break + } + } // end let + tmp57 = tmp61 + } // end let + tmp56 = tmp57 + } else { + } + tmp52 = tmp56 + } // end let + _ = tmp52 + tmp53 := lang.Apply(lang.WriteWriter, []any{v3, "]"}) + tmp50 = tmp53 + } else { + } + tmp5 = tmp50 + } // end let + _ = tmp5 + tmp6 := lang.Apply(lang.WriteWriter, []any{v3, "}"}) + return tmp6 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_print_DASH_throwable = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_print_DASH_throwable.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // with-bindings* + // print-object { - tmp0 := sym_with_DASH_bindings_STAR_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_binding_DASH_map, sym_f, sym__AMP_, sym_args)), kw_doc, "Takes a map of Var/value pairs. Installs for the given Vars the associated\n values as thread-local bindings. Then calls f with the supplied arguments.\n Pops the installed bindings after f returned. Returns whatever f returns.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(1971), kw_end_DASH_line, int(1971))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - tmp6 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) - tmp7 := lang.Apply(tmp6, []any{v3}) - _ = tmp7 - var tmp8 any - func() { - defer func() { - tmp9 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) - tmp10 := lang.Apply(tmp9, nil) - _ = tmp10 - }() - tmp11 := checkDerefVar(var_glojure_DOT_core_apply) - tmp12 := lang.Apply(tmp11, []any{v4, v5}) - tmp8 = tmp12 - }() - return tmp8 - } + tmp0 := sym_print_DASH_object.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(115), kw_column, int(8), kw_end_DASH_line, int(115), kw_end_DASH_column, int(19), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_o, sym_w)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_print_DASH_tagged_DASH_object) + tmp5 := checkDerefVar(var_glojure_DOT_core_str) + tmp6 := lang.Apply(tmp5, []any{v2}) + tmp7 := lang.Apply(tmp4, []any{v2, tmp6, v3}) + return tmp7 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_print_DASH_object = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_print_DASH_object.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // with-in-str + // read { - tmp0 := sym_with_DASH_in_DASH_str.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_s, sym__AMP_, sym_body)), kw_doc, "Evaluates body in a context in which *in* is bound to a fresh\n StringReader initialized with the string s.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(11), kw_line, int(4749), kw_end_DASH_line, int(4749))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_read.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_stream), lang.NewVector(sym_stream, sym_eof_DASH_error_QMARK_, sym_eof_DASH_value), lang.NewVector(sym_stream, sym_eof_DASH_error_QMARK_, sym_eof_DASH_value, sym_recursive_QMARK_), lang.NewVector(sym_opts, sym_stream)), kw_doc, "Reads the next object from stream, which must be an instance of\n java.io.PushbackReader or some derivee. stream defaults to the\n current value of *in*.\n\n Opts is a persistent map with valid keys:\n :read-cond - :allow to process reader conditionals, or\n :preserve to keep all branches\n :features - persistent set of feature keywords for reader conditionals\n :eof - on eof, return value unless :eofthrow, then throw.\n if not specified, will throw\n\n Note that read can execute code (controlled by *read-eval*),\n and as such should be used only with trusted sources.\n\n For data structure interop use glojure.edn/read", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3742), kw_end_DASH_line, int(3742))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - default: - checkArity(args, 3) - v3 := args[0] + case 0: + tmp2 := checkDerefVar(var_glojure_DOT_core_read) + tmp3 := checkDerefVar(var_glojure_DOT_core__STAR_in_STAR_) + tmp4 := lang.Apply(tmp2, []any{tmp3}) + return tmp4 + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_read) + tmp4 := lang.Apply(tmp3, []any{v2, true, nil}) + return tmp4 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + v4 := args[2] _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - tmp7 := checkDerefVar(var_glojure_DOT_core_seq) - tmp8 := checkDerefVar(var_glojure_DOT_core_concat) - tmp9 := checkDerefVar(var_glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_core_SLASH_with_DASH_open}) - tmp11 := checkDerefVar(var_glojure_DOT_core_list) - tmp12 := checkDerefVar(var_glojure_DOT_core_apply) - tmp13 := checkDerefVar(var_glojure_DOT_core_vector) - tmp14 := checkDerefVar(var_glojure_DOT_core_seq) - tmp15 := checkDerefVar(var_glojure_DOT_core_concat) - tmp16 := checkDerefVar(var_glojure_DOT_core_list) - tmp17 := lang.Apply(tmp16, []any{sym_s__0__auto__}) - tmp18 := checkDerefVar(var_glojure_DOT_core_list) - tmp19 := checkDerefVar(var_glojure_DOT_core_seq) - tmp20 := checkDerefVar(var_glojure_DOT_core_concat) - tmp21 := checkDerefVar(var_glojure_DOT_core_list) - tmp22 := lang.Apply(tmp21, []any{sym_glojure_DOT_core_SLASH__DASH__GT_}) - tmp23 := checkDerefVar(var_glojure_DOT_core_list) - tmp24 := checkDerefVar(var_glojure_DOT_core_seq) - tmp25 := checkDerefVar(var_glojure_DOT_core_concat) - tmp26 := checkDerefVar(var_glojure_DOT_core_list) - tmp27 := lang.Apply(tmp26, []any{sym_java_DOT_io_DOT_StringReader_DOT_}) - tmp28 := checkDerefVar(var_glojure_DOT_core_list) - tmp29 := lang.Apply(tmp28, []any{v5}) - tmp30 := lang.Apply(tmp25, []any{tmp27, tmp29}) - tmp31 := lang.Apply(tmp24, []any{tmp30}) - tmp32 := lang.Apply(tmp23, []any{tmp31}) - tmp33 := checkDerefVar(var_glojure_DOT_core_list) - tmp34 := lang.Apply(tmp33, []any{sym_glojure_DOT_lang_DOT_LineNumberingPushbackReader_DOT_}) - tmp35 := lang.Apply(tmp20, []any{tmp22, tmp32, tmp34}) - tmp36 := lang.Apply(tmp19, []any{tmp35}) - tmp37 := lang.Apply(tmp18, []any{tmp36}) - tmp38 := lang.Apply(tmp15, []any{tmp17, tmp37}) - tmp39 := lang.Apply(tmp14, []any{tmp38}) - tmp40 := lang.Apply(tmp12, []any{tmp13, tmp39}) - tmp41 := lang.Apply(tmp11, []any{tmp40}) - tmp42 := checkDerefVar(var_glojure_DOT_core_list) - tmp43 := checkDerefVar(var_glojure_DOT_core_seq) - tmp44 := checkDerefVar(var_glojure_DOT_core_concat) - tmp45 := checkDerefVar(var_glojure_DOT_core_list) - tmp46 := lang.Apply(tmp45, []any{sym_glojure_DOT_core_SLASH_binding}) - tmp47 := checkDerefVar(var_glojure_DOT_core_list) - tmp48 := checkDerefVar(var_glojure_DOT_core_apply) - tmp49 := checkDerefVar(var_glojure_DOT_core_vector) - tmp50 := checkDerefVar(var_glojure_DOT_core_seq) - tmp51 := checkDerefVar(var_glojure_DOT_core_concat) - tmp52 := checkDerefVar(var_glojure_DOT_core_list) - tmp53 := lang.Apply(tmp52, []any{sym_glojure_DOT_core_SLASH__STAR_in_STAR_}) - tmp54 := checkDerefVar(var_glojure_DOT_core_list) - tmp55 := lang.Apply(tmp54, []any{sym_s__0__auto__}) - tmp56 := lang.Apply(tmp51, []any{tmp53, tmp55}) - tmp57 := lang.Apply(tmp50, []any{tmp56}) - tmp58 := lang.Apply(tmp48, []any{tmp49, tmp57}) - tmp59 := lang.Apply(tmp47, []any{tmp58}) - tmp60 := lang.Apply(tmp44, []any{tmp46, tmp59, v6}) - tmp61 := lang.Apply(tmp43, []any{tmp60}) - tmp62 := lang.Apply(tmp42, []any{tmp61}) - tmp63 := lang.Apply(tmp8, []any{tmp10, tmp41, tmp62}) - tmp64 := lang.Apply(tmp7, []any{tmp63}) - return tmp64 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // with-loading-context - { - tmp0 := sym_with_DASH_loading_DASH_context.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5734), kw_column, int(11), kw_end_DASH_line, int(5734), kw_end_DASH_column, int(30), kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_body)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_macro, true)).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 2) - v3 := args[0] + tmp5 := checkDerefVar(var_glojure_DOT_core_read) + tmp6 := lang.Apply(tmp5, []any{v2, v3, v4, false}) + return tmp6 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[2:]...) + v5 := args[3] _ = v5 - tmp6 := checkDerefVar(var_glojure_DOT_core_seq) - tmp7 := checkDerefVar(var_glojure_DOT_core_concat) - tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := checkDerefVar(var_glojure_DOT_core_seq) - tmp10 := checkDerefVar(var_glojure_DOT_core_concat) - tmp11 := checkDerefVar(var_glojure_DOT_core_list) - tmp12 := lang.Apply(tmp11, []any{sym_glojure_DOT_core_SLASH_fn}) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_loading__0__auto__}) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := checkDerefVar(var_glojure_DOT_core_apply) - tmp17 := checkDerefVar(var_glojure_DOT_core_vector) - tmp18 := checkDerefVar(var_glojure_DOT_core_seq) - tmp19 := checkDerefVar(var_glojure_DOT_core_concat) - tmp20 := lang.Apply(tmp19, nil) - tmp21 := lang.Apply(tmp18, []any{tmp20}) - tmp22 := lang.Apply(tmp16, []any{tmp17, tmp21}) - tmp23 := lang.Apply(tmp15, []any{tmp22}) - tmp24 := checkDerefVar(var_glojure_DOT_core_list) - tmp25 := checkDerefVar(var_glojure_DOT_core_seq) - tmp26 := checkDerefVar(var_glojure_DOT_core_concat) - tmp27 := checkDerefVar(var_glojure_DOT_core_list) - tmp28 := lang.Apply(tmp27, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_PushThreadBindings}) - tmp29 := checkDerefVar(var_glojure_DOT_core_list) - tmp30 := checkDerefVar(var_glojure_DOT_core_apply) - tmp31 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) - tmp32 := checkDerefVar(var_glojure_DOT_core_seq) - tmp33 := checkDerefVar(var_glojure_DOT_core_concat) - tmp34 := lang.Apply(tmp33, nil) - tmp35 := lang.Apply(tmp32, []any{tmp34}) - tmp36 := lang.Apply(tmp30, []any{tmp31, tmp35}) - tmp37 := lang.Apply(tmp29, []any{tmp36}) - tmp38 := lang.Apply(tmp26, []any{tmp28, tmp37}) - tmp39 := lang.Apply(tmp25, []any{tmp38}) - tmp40 := lang.Apply(tmp24, []any{tmp39}) - tmp41 := checkDerefVar(var_glojure_DOT_core_list) - tmp42 := checkDerefVar(var_glojure_DOT_core_seq) - tmp43 := checkDerefVar(var_glojure_DOT_core_concat) - tmp44 := checkDerefVar(var_glojure_DOT_core_list) - tmp45 := lang.Apply(tmp44, []any{sym_try}) - tmp46 := checkDerefVar(var_glojure_DOT_core_list) - tmp47 := checkDerefVar(var_glojure_DOT_core_seq) - tmp48 := checkDerefVar(var_glojure_DOT_core_concat) - tmp49 := checkDerefVar(var_glojure_DOT_core_list) - tmp50 := lang.Apply(tmp49, []any{sym_finally}) - tmp51 := checkDerefVar(var_glojure_DOT_core_list) - tmp52 := checkDerefVar(var_glojure_DOT_core_seq) - tmp53 := checkDerefVar(var_glojure_DOT_core_concat) - tmp54 := checkDerefVar(var_glojure_DOT_core_list) - tmp55 := lang.Apply(tmp54, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_PopThreadBindings}) - tmp56 := lang.Apply(tmp53, []any{tmp55}) - tmp57 := lang.Apply(tmp52, []any{tmp56}) - tmp58 := lang.Apply(tmp51, []any{tmp57}) - tmp59 := lang.Apply(tmp48, []any{tmp50, tmp58}) - tmp60 := lang.Apply(tmp47, []any{tmp59}) - tmp61 := lang.Apply(tmp46, []any{tmp60}) - tmp62 := lang.Apply(tmp43, []any{tmp45, v5, tmp61}) - tmp63 := lang.Apply(tmp42, []any{tmp62}) - tmp64 := lang.Apply(tmp41, []any{tmp63}) - tmp65 := lang.Apply(tmp10, []any{tmp12, tmp14, tmp23, tmp40, tmp64}) - tmp66 := lang.Apply(tmp9, []any{tmp65}) - tmp67 := lang.Apply(tmp8, []any{tmp66}) - tmp68 := lang.Apply(tmp7, []any{tmp67}) - tmp69 := lang.Apply(tmp6, []any{tmp68}) - return tmp69 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // with-local-vars - { - tmp0 := sym_with_DASH_local_DASH_vars.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name_DASH_vals_DASH_vec, sym__AMP_, sym_body)), kw_doc, "varbinding=> symbol init-expr\n\n Executes the exprs in a context in which the symbols are bound to\n vars with per-thread bindings to the init-exprs. The symbols refer\n to the var objects themselves, and must be accessed with var-get and\n var-set", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(25), kw_column, int(11), kw_line, int(4339), kw_end_DASH_line, int(4339))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 3) - v3 := args[0] + tmp6 := checkDerefVar(var_glojure_DOT_core_boolean) + tmp7 := lang.Apply(tmp6, []any{v3}) + tmp8, _ := lang.FieldOrMethod(nil, "read") + if reflect.TypeOf(tmp8).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("read is not a function"))) + } + tmp9 := lang.Apply(tmp8, []any{v2, tmp7, v4, v5}) + return tmp9 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any - tmp8 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) - tmp9 := lang.Apply(tmp8, []any{v5}) - if lang.IsTruthy(tmp9) { - } else { - tmp10 := checkDerefVar(var_glojure_DOT_core_str) - tmp11 := checkDerefVar(var_glojure_DOT_core_first) - tmp12 := lang.Apply(tmp11, []any{v3}) - tmp13 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) - tmp14 := checkDerefVar(var_glojure_DOT_core_meta) - tmp15 := lang.Apply(tmp14, []any{v3}) - tmp16 := lang.Apply(kw_line, []any{tmp15}) - tmp17 := lang.Apply(tmp10, []any{tmp12, " requires ", "a vector for its binding", " in ", tmp13, ":", tmp16}) - tmp18 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp17}) - panic(tmp18) + tmp4, _ := lang.FieldOrMethod(nil, "read") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("read is not a function"))) } - _ = tmp7 - var tmp19 any - tmp20 := checkDerefVar(var_glojure_DOT_core_even_QMARK_) - tmp21 := checkDerefVar(var_glojure_DOT_core_count) - tmp22 := lang.Apply(tmp21, []any{v5}) - tmp23 := lang.Apply(tmp20, []any{tmp22}) - if lang.IsTruthy(tmp23) { - } else { - tmp24 := checkDerefVar(var_glojure_DOT_core_str) - tmp25 := checkDerefVar(var_glojure_DOT_core_first) - tmp26 := lang.Apply(tmp25, []any{v3}) - tmp27 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) - tmp28 := checkDerefVar(var_glojure_DOT_core_meta) - tmp29 := lang.Apply(tmp28, []any{v3}) - tmp30 := lang.Apply(kw_line, []any{tmp29}) - tmp31 := lang.Apply(tmp24, []any{tmp26, " requires ", "an even number of forms in binding vector", " in ", tmp27, ":", tmp30}) - tmp32 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp31}) - panic(tmp32) - } - _ = tmp19 - tmp33 := checkDerefVar(var_glojure_DOT_core_seq) - tmp34 := checkDerefVar(var_glojure_DOT_core_concat) - tmp35 := checkDerefVar(var_glojure_DOT_core_list) - tmp36 := lang.Apply(tmp35, []any{sym_glojure_DOT_core_SLASH_let}) - tmp37 := checkDerefVar(var_glojure_DOT_core_list) - tmp38 := checkDerefVar(var_glojure_DOT_core_apply) - tmp39 := checkDerefVar(var_glojure_DOT_core_vector) - tmp40 := checkDerefVar(var_glojure_DOT_core_seq) - tmp41 := checkDerefVar(var_glojure_DOT_core_concat) - tmp42 := checkDerefVar(var_glojure_DOT_core_interleave) - tmp43 := checkDerefVar(var_glojure_DOT_core_take_DASH_nth) - tmp44 := lang.Apply(tmp43, []any{int64(2), v5}) - tmp45 := checkDerefVar(var_glojure_DOT_core_repeat) - tmp46 := lang.Apply(tmp45, []any{lang.NewList(sym__DOT__DOT_, sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT__STAR_Var, sym_create, sym_setDynamic)}) - tmp47 := lang.Apply(tmp42, []any{tmp44, tmp46}) - tmp48 := lang.Apply(tmp41, []any{tmp47}) - tmp49 := lang.Apply(tmp40, []any{tmp48}) - tmp50 := lang.Apply(tmp38, []any{tmp39, tmp49}) - tmp51 := lang.Apply(tmp37, []any{tmp50}) - tmp52 := checkDerefVar(var_glojure_DOT_core_list) - tmp53 := checkDerefVar(var_glojure_DOT_core_seq) - tmp54 := checkDerefVar(var_glojure_DOT_core_concat) - tmp55 := checkDerefVar(var_glojure_DOT_core_list) - tmp56 := lang.Apply(tmp55, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_PushThreadBindings}) - tmp57 := checkDerefVar(var_glojure_DOT_core_list) - tmp58 := checkDerefVar(var_glojure_DOT_core_apply) - tmp59 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) - tmp60 := checkDerefVar(var_glojure_DOT_core_seq) - tmp61 := checkDerefVar(var_glojure_DOT_core_concat) - tmp62 := lang.Apply(tmp61, nil) - tmp63 := lang.Apply(tmp60, []any{tmp62}) - tmp64 := lang.Apply(tmp58, []any{tmp59, tmp63}) - tmp65 := lang.Apply(tmp57, []any{tmp64}) - tmp66 := lang.Apply(tmp54, []any{tmp56, tmp65}) - tmp67 := lang.Apply(tmp53, []any{tmp66}) - tmp68 := lang.Apply(tmp52, []any{tmp67}) - tmp69 := checkDerefVar(var_glojure_DOT_core_list) - tmp70 := checkDerefVar(var_glojure_DOT_core_seq) - tmp71 := checkDerefVar(var_glojure_DOT_core_concat) - tmp72 := checkDerefVar(var_glojure_DOT_core_list) - tmp73 := lang.Apply(tmp72, []any{sym_try}) - tmp74 := checkDerefVar(var_glojure_DOT_core_list) - tmp75 := checkDerefVar(var_glojure_DOT_core_seq) - tmp76 := checkDerefVar(var_glojure_DOT_core_concat) - tmp77 := checkDerefVar(var_glojure_DOT_core_list) - tmp78 := lang.Apply(tmp77, []any{sym_finally}) - tmp79 := checkDerefVar(var_glojure_DOT_core_list) - tmp80 := checkDerefVar(var_glojure_DOT_core_seq) - tmp81 := checkDerefVar(var_glojure_DOT_core_concat) - tmp82 := checkDerefVar(var_glojure_DOT_core_list) - tmp83 := lang.Apply(tmp82, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_PopThreadBindings}) - tmp84 := lang.Apply(tmp81, []any{tmp83}) - tmp85 := lang.Apply(tmp80, []any{tmp84}) - tmp86 := lang.Apply(tmp79, []any{tmp85}) - tmp87 := lang.Apply(tmp76, []any{tmp78, tmp86}) - tmp88 := lang.Apply(tmp75, []any{tmp87}) - tmp89 := lang.Apply(tmp74, []any{tmp88}) - tmp90 := lang.Apply(tmp71, []any{tmp73, v6, tmp89}) - tmp91 := lang.Apply(tmp70, []any{tmp90}) - tmp92 := lang.Apply(tmp69, []any{tmp91}) - tmp93 := lang.Apply(tmp34, []any{tmp36, tmp51, tmp68, tmp92}) - tmp94 := lang.Apply(tmp33, []any{tmp93}) - return tmp94 + tmp5 := lang.Apply(tmp4, []any{v3, v2}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_read = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_read.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // with-meta + // read-line { - tmp0 := sym_with_DASH_meta.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_obj, sym_m)), kw_doc, "Returns an object of the same type and value as obj, with\n map m as its metadata.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(2), kw_line, int(211), kw_end_DASH_line, int(216))).(*lang.Symbol) - var tmp2 lang.FnFunc - { // function with-meta - var v3 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v4 := args[0] - _ = v4 - v5 := args[1] - _ = v5 - tmp6, _ := lang.FieldOrMethod(v4, "WithMeta") - if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("WithMeta is not a function"))) + tmp0 := sym_read_DASH_line.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Reads the next line from stream that is the current value of *in* .", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(3797), kw_end_DASH_line, int(3797))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp2 any + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := checkDerefVar(var_glojure_DOT_core__STAR_in_STAR_) + tmp5 := lang.Apply(tmp3, []any{nil, tmp4}) + if lang.IsTruthy(tmp5) { + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_in_STAR_) + tmp7, ok := lang.FieldOrMethod(tmp6, "readLine") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp6, "readLine"))) } - tmp7 := lang.Apply(tmp6, []any{v5}) - return tmp7 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(216), kw_column, int(12), kw_end_DASH_line, int(217), kw_end_DASH_column, int(32))).(lang.FnFunc) - v3 = tmp2 - _ = v3 - } - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // with-open - { - tmp0 := sym_with_DASH_open.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "bindings => [name init ...]\n\n Evaluates body in a try expression with names bound to the values\n of the inits, and a finally clause that calls (.close name) on each\n name in reverse order.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(11), kw_line, int(3832), kw_end_DASH_line, int(3832))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 3) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any - tmp8 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) - tmp9 := lang.Apply(tmp8, []any{v5}) - if lang.IsTruthy(tmp9) { - } else { - tmp10 := checkDerefVar(var_glojure_DOT_core_str) - tmp11 := checkDerefVar(var_glojure_DOT_core_first) - tmp12 := lang.Apply(tmp11, []any{v3}) - tmp13 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) - tmp14 := checkDerefVar(var_glojure_DOT_core_meta) - tmp15 := lang.Apply(tmp14, []any{v3}) - tmp16 := lang.Apply(kw_line, []any{tmp15}) - tmp17 := lang.Apply(tmp10, []any{tmp12, " requires ", "a vector for its binding", " in ", tmp13, ":", tmp16}) - tmp18 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp17}) - panic(tmp18) + var tmp8 any + switch reflect.TypeOf(tmp7).Kind() { + case reflect.Func: + tmp8 = lang.Apply(tmp7, nil) + default: + tmp8 = tmp7 } - _ = tmp7 - var tmp19 any - tmp20 := checkDerefVar(var_glojure_DOT_core_even_QMARK_) - tmp21 := checkDerefVar(var_glojure_DOT_core_count) - tmp22 := lang.Apply(tmp21, []any{v5}) - tmp23 := lang.Apply(tmp20, []any{tmp22}) - if lang.IsTruthy(tmp23) { - } else { - tmp24 := checkDerefVar(var_glojure_DOT_core_str) - tmp25 := checkDerefVar(var_glojure_DOT_core_first) - tmp26 := lang.Apply(tmp25, []any{v3}) - tmp27 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) - tmp28 := checkDerefVar(var_glojure_DOT_core_meta) - tmp29 := lang.Apply(tmp28, []any{v3}) - tmp30 := lang.Apply(kw_line, []any{tmp29}) - tmp31 := lang.Apply(tmp24, []any{tmp26, " requires ", "an even number of forms in binding vector", " in ", tmp27, ":", tmp30}) - tmp32 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp31}) - panic(tmp32) - } - _ = tmp19 - var tmp33 any - tmp34 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp35 := checkDerefVar(var_glojure_DOT_core_count) - tmp36 := lang.Apply(tmp35, []any{v5}) - tmp37 := lang.Apply(tmp34, []any{tmp36, int64(0)}) - if lang.IsTruthy(tmp37) { - tmp38 := checkDerefVar(var_glojure_DOT_core_seq) - tmp39 := checkDerefVar(var_glojure_DOT_core_concat) - tmp40 := checkDerefVar(var_glojure_DOT_core_list) - tmp41 := lang.Apply(tmp40, []any{sym_do}) - tmp42 := lang.Apply(tmp39, []any{tmp41, v6}) - tmp43 := lang.Apply(tmp38, []any{tmp42}) - tmp33 = tmp43 - } else { - var tmp44 any - tmp45 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) - tmp46 := lang.Apply(v5, []any{int64(0)}) - tmp47 := lang.Apply(tmp45, []any{tmp46}) - if lang.IsTruthy(tmp47) { - tmp48 := checkDerefVar(var_glojure_DOT_core_seq) - tmp49 := checkDerefVar(var_glojure_DOT_core_concat) - tmp50 := checkDerefVar(var_glojure_DOT_core_list) - tmp51 := lang.Apply(tmp50, []any{sym_glojure_DOT_core_SLASH_let}) - tmp52 := checkDerefVar(var_glojure_DOT_core_list) - tmp53 := checkDerefVar(var_glojure_DOT_core_subvec) - tmp54 := lang.Apply(tmp53, []any{v5, int64(0), int64(2)}) - tmp55 := lang.Apply(tmp52, []any{tmp54}) - tmp56 := checkDerefVar(var_glojure_DOT_core_list) - tmp57 := checkDerefVar(var_glojure_DOT_core_seq) - tmp58 := checkDerefVar(var_glojure_DOT_core_concat) - tmp59 := checkDerefVar(var_glojure_DOT_core_list) - tmp60 := lang.Apply(tmp59, []any{sym_try}) - tmp61 := checkDerefVar(var_glojure_DOT_core_list) - tmp62 := checkDerefVar(var_glojure_DOT_core_seq) - tmp63 := checkDerefVar(var_glojure_DOT_core_concat) - tmp64 := checkDerefVar(var_glojure_DOT_core_list) - tmp65 := lang.Apply(tmp64, []any{sym_glojure_DOT_core_SLASH_with_DASH_open}) - tmp66 := checkDerefVar(var_glojure_DOT_core_list) - tmp67 := checkDerefVar(var_glojure_DOT_core_subvec) - tmp68 := lang.Apply(tmp67, []any{v5, int64(2)}) - tmp69 := lang.Apply(tmp66, []any{tmp68}) - tmp70 := lang.Apply(tmp63, []any{tmp65, tmp69, v6}) - tmp71 := lang.Apply(tmp62, []any{tmp70}) - tmp72 := lang.Apply(tmp61, []any{tmp71}) - tmp73 := checkDerefVar(var_glojure_DOT_core_list) - tmp74 := checkDerefVar(var_glojure_DOT_core_seq) - tmp75 := checkDerefVar(var_glojure_DOT_core_concat) - tmp76 := checkDerefVar(var_glojure_DOT_core_list) - tmp77 := lang.Apply(tmp76, []any{sym_finally}) - tmp78 := checkDerefVar(var_glojure_DOT_core_list) - tmp79 := checkDerefVar(var_glojure_DOT_core_seq) - tmp80 := checkDerefVar(var_glojure_DOT_core_concat) - tmp81 := checkDerefVar(var_glojure_DOT_core_list) - tmp82 := lang.Apply(tmp81, []any{sym__DOT_}) - tmp83 := checkDerefVar(var_glojure_DOT_core_list) - tmp84 := lang.Apply(v5, []any{int64(0)}) - tmp85 := lang.Apply(tmp83, []any{tmp84}) - tmp86 := checkDerefVar(var_glojure_DOT_core_list) - tmp87 := lang.Apply(tmp86, []any{sym_close}) - tmp88 := lang.Apply(tmp80, []any{tmp82, tmp85, tmp87}) - tmp89 := lang.Apply(tmp79, []any{tmp88}) - tmp90 := lang.Apply(tmp78, []any{tmp89}) - tmp91 := lang.Apply(tmp75, []any{tmp77, tmp90}) - tmp92 := lang.Apply(tmp74, []any{tmp91}) - tmp93 := lang.Apply(tmp73, []any{tmp92}) - tmp94 := lang.Apply(tmp58, []any{tmp60, tmp72, tmp93}) - tmp95 := lang.Apply(tmp57, []any{tmp94}) - tmp96 := lang.Apply(tmp56, []any{tmp95}) - tmp97 := lang.Apply(tmp49, []any{tmp51, tmp55, tmp96}) - tmp98 := lang.Apply(tmp48, []any{tmp97}) - tmp44 = tmp98 - } else { - var tmp99 any - if lang.IsTruthy(kw_else) { - tmp100 := lang.Apply(lang.NewIllegalArgumentError, []any{"with-open only allows Symbols in bindings"}) - panic(tmp100) - } else { - } - tmp44 = tmp99 - } - tmp33 = tmp44 + tmp2 = tmp8 + } else { + tmp9 := checkDerefVar(var_glojure_DOT_core__STAR_in_STAR_) + tmp10, ok := lang.FieldOrMethod(tmp9, "readLine") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp9, "readLine"))) } - return tmp33 + var tmp11 any + switch reflect.TypeOf(tmp10).Kind() { + case reflect.Func: + tmp11 = lang.Apply(tmp10, nil) + default: + tmp11 = tmp10 + } + tmp2 = tmp11 } + return tmp2 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_read_DASH_line = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_read_DASH_line.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // with-out-str + // read+string { - tmp0 := sym_with_DASH_out_DASH_str.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_body)), kw_doc, "Evaluates exprs in a context in which *out* is bound to a fresh\n StringWriter. Returns the string created by any nested printing\n calls.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(22), kw_column, int(11), kw_line, int(4738), kw_end_DASH_line, int(4738))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_read_PLUS_string.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_stream), lang.NewVector(sym_stream, sym_eof_DASH_error_QMARK_, sym_eof_DASH_value), lang.NewVector(sym_stream, sym_eof_DASH_error_QMARK_, sym_eof_DASH_value, sym_recursive_QMARK_), lang.NewVector(sym_opts, sym_stream)), kw_doc, "Like read, and taking the same args. stream must be a LineNumberingPushbackReader.\n Returns a vector containing the object read and the (whitespace-trimmed) string read.", kw_file, "glojure/core.glj", kw_added, "1.10", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(3771), kw_end_DASH_line, int(3771))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - default: - checkArity(args, 2) - v3 := args[0] + case 0: + tmp2 := checkDerefVar(var_glojure_DOT_core_read_PLUS_string) + tmp3 := checkDerefVar(var_glojure_DOT_core__STAR_in_STAR_) + tmp4 := lang.Apply(tmp2, []any{tmp3}) + return tmp4 + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_read_PLUS_string) + tmp4 := lang.Apply(tmp3, []any{v2, true, nil}) + return tmp4 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[2:]...) - _ = v5 - tmp6 := checkDerefVar(var_glojure_DOT_core_seq) - tmp7 := checkDerefVar(var_glojure_DOT_core_concat) - tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_let}) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := checkDerefVar(var_glojure_DOT_core_apply) - tmp12 := checkDerefVar(var_glojure_DOT_core_vector) - tmp13 := checkDerefVar(var_glojure_DOT_core_seq) - tmp14 := checkDerefVar(var_glojure_DOT_core_concat) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{sym_s__0__auto__}) - tmp17 := checkDerefVar(var_glojure_DOT_core_list) - tmp18 := checkDerefVar(var_glojure_DOT_core_seq) - tmp19 := checkDerefVar(var_glojure_DOT_core_concat) - tmp20 := checkDerefVar(var_glojure_DOT_core_list) - tmp21 := lang.Apply(tmp20, []any{sym_new}) - tmp22 := checkDerefVar(var_glojure_DOT_core_list) - tmp23 := lang.Apply(tmp22, []any{sym_strings_DOT_Builder}) - tmp24 := lang.Apply(tmp19, []any{tmp21, tmp23}) - tmp25 := lang.Apply(tmp18, []any{tmp24}) - tmp26 := lang.Apply(tmp17, []any{tmp25}) - tmp27 := lang.Apply(tmp14, []any{tmp16, tmp26}) - tmp28 := lang.Apply(tmp13, []any{tmp27}) - tmp29 := lang.Apply(tmp11, []any{tmp12, tmp28}) - tmp30 := lang.Apply(tmp10, []any{tmp29}) - tmp31 := checkDerefVar(var_glojure_DOT_core_list) - tmp32 := checkDerefVar(var_glojure_DOT_core_seq) - tmp33 := checkDerefVar(var_glojure_DOT_core_concat) - tmp34 := checkDerefVar(var_glojure_DOT_core_list) - tmp35 := lang.Apply(tmp34, []any{sym_glojure_DOT_core_SLASH_binding}) - tmp36 := checkDerefVar(var_glojure_DOT_core_list) - tmp37 := checkDerefVar(var_glojure_DOT_core_apply) - tmp38 := checkDerefVar(var_glojure_DOT_core_vector) - tmp39 := checkDerefVar(var_glojure_DOT_core_seq) - tmp40 := checkDerefVar(var_glojure_DOT_core_concat) - tmp41 := checkDerefVar(var_glojure_DOT_core_list) - tmp42 := lang.Apply(tmp41, []any{sym_glojure_DOT_core_SLASH__STAR_out_STAR_}) - tmp43 := checkDerefVar(var_glojure_DOT_core_list) - tmp44 := lang.Apply(tmp43, []any{sym_s__0__auto__}) - tmp45 := lang.Apply(tmp40, []any{tmp42, tmp44}) - tmp46 := lang.Apply(tmp39, []any{tmp45}) - tmp47 := lang.Apply(tmp37, []any{tmp38, tmp46}) - tmp48 := lang.Apply(tmp36, []any{tmp47}) - tmp49 := checkDerefVar(var_glojure_DOT_core_list) - tmp50 := checkDerefVar(var_glojure_DOT_core_seq) - tmp51 := checkDerefVar(var_glojure_DOT_core_concat) - tmp52 := checkDerefVar(var_glojure_DOT_core_list) - tmp53 := lang.Apply(tmp52, []any{sym_glojure_DOT_core_SLASH_str}) - tmp54 := checkDerefVar(var_glojure_DOT_core_list) - tmp55 := lang.Apply(tmp54, []any{sym_s__0__auto__}) - tmp56 := lang.Apply(tmp51, []any{tmp53, tmp55}) - tmp57 := lang.Apply(tmp50, []any{tmp56}) - tmp58 := lang.Apply(tmp49, []any{tmp57}) - tmp59 := lang.Apply(tmp33, []any{tmp35, tmp48, v5, tmp58}) - tmp60 := lang.Apply(tmp32, []any{tmp59}) - tmp61 := lang.Apply(tmp31, []any{tmp60}) - tmp62 := lang.Apply(tmp7, []any{tmp9, tmp30, tmp61}) - tmp63 := lang.Apply(tmp6, []any{tmp62}) - return tmp63 - } - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // with-precision - { - tmp0 := sym_with_DASH_precision.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_precision, sym__AMP_, sym_exprs)), kw_doc, "Sets the precision and rounding mode to be used for BigDecimal operations.\n\n Usage: (with-precision 10 (/ 1M 3))\n or: (with-precision 10 :rounding HALF_DOWN (/ 1M 3))\n\n The rounding mode is one of CEILING, FLOOR, HALF_UP, HALF_DOWN,\n HALF_EVEN, UP, DOWN and UNNECESSARY; it defaults to HALF_UP.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(24), kw_column, int(11), kw_line, int(5110), kw_end_DASH_line, int(5110))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArity(args, 3) - v3 := args[0] + tmp5 := checkDerefVar(var_glojure_DOT_core_read_PLUS_string) + tmp6 := lang.Apply(tmp5, []any{v2, v3, v4, false}) + return tmp6 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + v4 := args[2] _ = v4 - v5 := args[2] + v5 := args[3] _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - var tmp7 any - { // let - // let binding "vec__65" + var tmp6 any + func() { + defer func() { + if r := recover(); r != nil { + if lang.CatchMatches(r, lang.Throwable) { + v7 := r + _ = v7 + tmp8, ok := lang.FieldOrMethod(v2, "getString") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getString"))) + } + var tmp9 any + switch reflect.TypeOf(tmp8).Kind() { + case reflect.Func: + tmp9 = lang.Apply(tmp8, nil) + default: + tmp9 = tmp8 + } + _ = tmp9 + panic(v7) + } else { + panic(r) + } + } + }() + tmp7, ok := lang.FieldOrMethod(v2, "captureString") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "captureString"))) + } var tmp8 any - tmp9 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp10 := checkDerefVar(var_glojure_DOT_core_first) - tmp11 := lang.Apply(tmp10, []any{v6}) - tmp12 := lang.Apply(tmp9, []any{tmp11, kw_rounding}) - if lang.IsTruthy(tmp12) { - tmp13 := checkDerefVar(var_glojure_DOT_core_next) - tmp14 := checkDerefVar(var_glojure_DOT_core_next) - tmp15 := lang.Apply(tmp14, []any{v6}) - tmp16 := lang.Apply(tmp13, []any{tmp15}) - tmp17 := checkDerefVar(var_glojure_DOT_core_seq) - tmp18 := checkDerefVar(var_glojure_DOT_core_concat) - tmp19 := checkDerefVar(var_glojure_DOT_core_list) - tmp20 := checkDerefVar(var_glojure_DOT_core_seq) - tmp21 := checkDerefVar(var_glojure_DOT_core_concat) - tmp22 := checkDerefVar(var_glojure_DOT_core_list) - tmp23 := lang.Apply(tmp22, []any{sym__DOT_}) - tmp24 := checkDerefVar(var_glojure_DOT_core_list) - tmp25 := lang.Apply(tmp24, []any{sym_java_DOT_math_DOT_RoundingMode}) - tmp26 := checkDerefVar(var_glojure_DOT_core_list) - tmp27 := checkDerefVar(var_glojure_DOT_core_second) - tmp28 := lang.Apply(tmp27, []any{v6}) - tmp29 := lang.Apply(tmp26, []any{tmp28}) - tmp30 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp29}) - tmp31 := lang.Apply(tmp20, []any{tmp30}) - tmp32 := lang.Apply(tmp19, []any{tmp31}) - tmp33 := lang.Apply(tmp18, []any{tmp32}) - tmp34 := lang.Apply(tmp17, []any{tmp33}) - tmp35 := lang.NewVector(tmp16, tmp34) - tmp36 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5121), kw_column, int(23), kw_end_DASH_line, int(5122), kw_end_DASH_column, int(69)) - tmp37, err := lang.WithMeta(tmp35, tmp36.(lang.IPersistentMap)) + switch reflect.TypeOf(tmp7).Kind() { + case reflect.Func: + tmp8 = lang.Apply(tmp7, nil) + default: + tmp8 = tmp7 + } + _ = tmp8 + var tmp9 any + { // let + // let binding "o" + tmp10 := checkDerefVar(var_glojure_DOT_core_read) + tmp11 := lang.Apply(tmp10, []any{v2, v3, v4, v5}) + var v12 any = tmp11 + _ = v12 + // let binding "s" + tmp13, ok := lang.FieldOrMethod(v2, "getString") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getString"))) + } + var tmp14 any + switch reflect.TypeOf(tmp13).Kind() { + case reflect.Func: + tmp14 = lang.Apply(tmp13, nil) + default: + tmp14 = tmp13 + } + tmp15, ok := lang.FieldOrMethod(tmp14, "trim") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp14, "trim"))) + } + var tmp16 any + switch reflect.TypeOf(tmp15).Kind() { + case reflect.Func: + tmp16 = lang.Apply(tmp15, nil) + default: + tmp16 = tmp15 + } + var v17 any = tmp16 + _ = v17 + tmp18 := lang.NewVector(v12, v17) + tmp19 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3783), kw_column, int(8), kw_end_DASH_line, int(3783), kw_end_DASH_column, int(12)) + tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp8 = tmp37 - } else { - tmp38 := lang.NewVector(v6, nil) - tmp39 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5123), kw_column, int(23), kw_end_DASH_line, int(5123), kw_end_DASH_column, int(33)) - tmp40, err := lang.WithMeta(tmp38, tmp39.(lang.IPersistentMap)) + tmp9 = tmp20 + } // end let + tmp6 = tmp9 + }() + return tmp6 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + func() { + defer func() { + if r := recover(); r != nil { + if lang.CatchMatches(r, lang.Throwable) { + v5 := r + _ = v5 + tmp6, ok := lang.FieldOrMethod(v3, "getString") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getString"))) + } + var tmp7 any + switch reflect.TypeOf(tmp6).Kind() { + case reflect.Func: + tmp7 = lang.Apply(tmp6, nil) + default: + tmp7 = tmp6 + } + _ = tmp7 + panic(v5) + } else { + panic(r) + } + } + }() + tmp5, ok := lang.FieldOrMethod(v3, "captureString") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "captureString"))) + } + var tmp6 any + switch reflect.TypeOf(tmp5).Kind() { + case reflect.Func: + tmp6 = lang.Apply(tmp5, nil) + default: + tmp6 = tmp5 + } + _ = tmp6 + var tmp7 any + { // let + // let binding "o" + tmp8 := checkDerefVar(var_glojure_DOT_core_read) + tmp9 := lang.Apply(tmp8, []any{v2, v3}) + var v10 any = tmp9 + _ = v10 + // let binding "s" + tmp11, ok := lang.FieldOrMethod(v3, "getString") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getString"))) + } + var tmp12 any + switch reflect.TypeOf(tmp11).Kind() { + case reflect.Func: + tmp12 = lang.Apply(tmp11, nil) + default: + tmp12 = tmp11 + } + tmp13, ok := lang.FieldOrMethod(tmp12, "trim") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp12, "trim"))) + } + var tmp14 any + switch reflect.TypeOf(tmp13).Kind() { + case reflect.Func: + tmp14 = lang.Apply(tmp13, nil) + default: + tmp14 = tmp13 + } + var v15 any = tmp14 + _ = v15 + tmp16 := lang.NewVector(v10, v15) + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3792), kw_column, int(8), kw_end_DASH_line, int(3792), kw_end_DASH_column, int(12)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp8 = tmp40 - } - var v41 any = tmp8 - _ = v41 - // let binding "body" - tmp42 := checkDerefVar(var_glojure_DOT_core_nth) - tmp43 := lang.Apply(tmp42, []any{v41, int64(0), nil}) - var v44 any = tmp43 - _ = v44 - // let binding "rm" - tmp45 := checkDerefVar(var_glojure_DOT_core_nth) - tmp46 := lang.Apply(tmp45, []any{v41, int64(1), nil}) - var v47 any = tmp46 - _ = v47 - tmp48 := checkDerefVar(var_glojure_DOT_core_seq) - tmp49 := checkDerefVar(var_glojure_DOT_core_concat) - tmp50 := checkDerefVar(var_glojure_DOT_core_list) - tmp51 := lang.Apply(tmp50, []any{sym_glojure_DOT_core_SLASH_binding}) - tmp52 := checkDerefVar(var_glojure_DOT_core_list) - tmp53 := checkDerefVar(var_glojure_DOT_core_apply) - tmp54 := checkDerefVar(var_glojure_DOT_core_vector) - tmp55 := checkDerefVar(var_glojure_DOT_core_seq) - tmp56 := checkDerefVar(var_glojure_DOT_core_concat) - tmp57 := checkDerefVar(var_glojure_DOT_core_list) - tmp58 := lang.Apply(tmp57, []any{sym_glojure_DOT_core_SLASH__STAR_math_DASH_context_STAR_}) - tmp59 := checkDerefVar(var_glojure_DOT_core_list) - tmp60 := checkDerefVar(var_glojure_DOT_core_seq) - tmp61 := checkDerefVar(var_glojure_DOT_core_concat) - tmp62 := checkDerefVar(var_glojure_DOT_core_list) - tmp63 := lang.Apply(tmp62, []any{sym_java_DOT_math_DOT_MathContext_DOT_}) - tmp64 := checkDerefVar(var_glojure_DOT_core_list) - tmp65 := lang.Apply(tmp64, []any{v5}) - tmp66 := lang.Apply(tmp61, []any{tmp63, tmp65, v47}) - tmp67 := lang.Apply(tmp60, []any{tmp66}) - tmp68 := lang.Apply(tmp59, []any{tmp67}) - tmp69 := lang.Apply(tmp56, []any{tmp58, tmp68}) - tmp70 := lang.Apply(tmp55, []any{tmp69}) - tmp71 := lang.Apply(tmp53, []any{tmp54, tmp70}) - tmp72 := lang.Apply(tmp52, []any{tmp71}) - tmp73 := lang.Apply(tmp49, []any{tmp51, tmp72, v44}) - tmp74 := lang.Apply(tmp48, []any{tmp73}) - tmp7 = tmp74 - } // end let - return tmp7 + tmp7 = tmp18 + } // end let + tmp4 = tmp7 + }() + return tmp4 + default: + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_read_PLUS_string = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_read_PLUS_string.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // with-redefs + // reduce { - tmp0 := sym_with_DASH_redefs.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "binding => var-symbol temp-value-expr\n\n Temporarily redefines Vars while executing the body. The\n temp-value-exprs will be evaluated and each resulting value will\n replace in parallel the root value of its Var. After the body is\n executed, the root values of all the Vars will be set back to their\n old values. These temporary changes will be visible in all threads.\n Useful for mocking out functions during testing.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(11), kw_line, int(7544), kw_end_DASH_line, int(7544))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_reduce.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_coll), lang.NewVector(sym_f, sym_val, sym_coll)), kw_doc, "f should be a function of 2 arguments. If val is not supplied,\n returns the result of applying f to the first 2 items in coll, then\n applying f to that result and the 3rd item, etc. If coll contains no\n items, f must accept no arguments as well, and reduce returns the\n result of calling f with no arguments. If coll has only 1 item, it\n is returned and f is not called. If val is supplied, returns the\n result of applying f to val and the first item in coll, then\n applying f to that result and the 2nd item, etc. If coll contains no\n items, returns val and f is not called.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(6860), kw_end_DASH_line, int(6860))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - default: - checkArity(args, 3) - v3 := args[0] + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp6 := reflect.TypeOf((*lang.IReduce)(nil)).Elem() + tmp7 := lang.Apply(tmp5, []any{tmp6, v3}) + if lang.IsTruthy(tmp7) { + tmp8, _ := lang.FieldOrMethod(v3, "Reduce") + if reflect.TypeOf(tmp8).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Reduce is not a function"))) + } + tmp9 := lang.Apply(tmp8, []any{v2}) + tmp4 = tmp9 + } else { + tmp10 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_coll_DASH_reduce) + tmp11 := lang.Apply(tmp10, []any{v3, v2}) + tmp4 = tmp11 + } + return tmp4 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] _ = v4 - v5 := args[2] - _ = v5 - var v6 any = lang.NewList(args[3:]...) - _ = v6 - tmp7 := checkDerefVar(var_glojure_DOT_core_seq) - tmp8 := checkDerefVar(var_glojure_DOT_core_concat) - tmp9 := checkDerefVar(var_glojure_DOT_core_list) - tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_core_SLASH_with_DASH_redefs_DASH_fn}) - tmp11 := checkDerefVar(var_glojure_DOT_core_list) - tmp12 := checkDerefVar(var_glojure_DOT_core_zipmap) - tmp13 := checkDerefVar(var_glojure_DOT_core_map) - var tmp14 lang.FnFunc - tmp14 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v15 := args[0] - _ = v15 - tmp16 := checkDerefVar(var_glojure_DOT_core_list) - tmp17 := lang.Apply(tmp16, []any{sym_var, v15}) - return tmp17 - }) - tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7555), kw_column, int(34), kw_end_DASH_line, int(7555), kw_end_DASH_column, int(47)) - tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) - if err != nil { - panic(err) + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp7 := reflect.TypeOf((*lang.IReduceInit)(nil)).Elem() + tmp8 := lang.Apply(tmp6, []any{tmp7, v4}) + if lang.IsTruthy(tmp8) { + tmp9, _ := lang.FieldOrMethod(v4, "ReduceInit") + if reflect.TypeOf(tmp9).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) + } + tmp10 := lang.Apply(tmp9, []any{v2, v3}) + tmp5 = tmp10 + } else { + tmp11 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_coll_DASH_reduce) + tmp12 := lang.Apply(tmp11, []any{v4, v2, v3}) + tmp5 = tmp12 } - tmp17 := checkDerefVar(var_glojure_DOT_core_take_DASH_nth) - tmp18 := lang.Apply(tmp17, []any{int64(2), v5}) - tmp19 := lang.Apply(tmp13, []any{tmp16, tmp18}) - tmp20 := checkDerefVar(var_glojure_DOT_core_take_DASH_nth) - tmp21 := checkDerefVar(var_glojure_DOT_core_next) - tmp22 := lang.Apply(tmp21, []any{v5}) - tmp23 := lang.Apply(tmp20, []any{int64(2), tmp22}) - tmp24 := lang.Apply(tmp12, []any{tmp19, tmp23}) - tmp25 := lang.Apply(tmp11, []any{tmp24}) - tmp26 := checkDerefVar(var_glojure_DOT_core_list) - tmp27 := checkDerefVar(var_glojure_DOT_core_seq) - tmp28 := checkDerefVar(var_glojure_DOT_core_concat) - tmp29 := checkDerefVar(var_glojure_DOT_core_list) - tmp30 := lang.Apply(tmp29, []any{sym_glojure_DOT_core_SLASH_fn}) - tmp31 := checkDerefVar(var_glojure_DOT_core_list) - tmp32 := checkDerefVar(var_glojure_DOT_core_apply) - tmp33 := checkDerefVar(var_glojure_DOT_core_vector) - tmp34 := checkDerefVar(var_glojure_DOT_core_seq) - tmp35 := checkDerefVar(var_glojure_DOT_core_concat) - tmp36 := lang.Apply(tmp35, nil) - tmp37 := lang.Apply(tmp34, []any{tmp36}) - tmp38 := lang.Apply(tmp32, []any{tmp33, tmp37}) - tmp39 := lang.Apply(tmp31, []any{tmp38}) - tmp40 := lang.Apply(tmp28, []any{tmp30, tmp39, v6}) - tmp41 := lang.Apply(tmp27, []any{tmp40}) - tmp42 := lang.Apply(tmp26, []any{tmp41}) - tmp43 := lang.Apply(tmp8, []any{tmp10, tmp25, tmp42}) - tmp44 := lang.Apply(tmp7, []any{tmp43}) - return tmp44 + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_reduce = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_reduce.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // with-redefs-fn + // run! { - tmp0 := sym_with_DASH_redefs_DASH_fn.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_binding_DASH_map, sym_func)), kw_doc, "Temporarily redefines Vars during a call to func. Each val of\n binding-map will replace the root value of its key which must be\n a Var. After func is called with no args, the root values of all\n the Vars will be set back to their old values. These temporary\n changes will be visible in all threads. Useful for mocking out\n functions during testing.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(7524), kw_end_DASH_line, int(7524))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + tmp0 := sym_run_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_proc, sym_coll)), kw_doc, "Runs the supplied procedure (via reduce), for purposes of side\n effects, on successive items in the collection. Returns nil", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(7708), kw_end_DASH_line, int(7708))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 2) - v3 := args[0] + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - v4 := args[1] + tmp4 := checkDerefVar(var_glojure_DOT_core_reduce) + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + tmp8 := lang.Apply(v2, []any{v7}) + return tmp8 + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7713), kw_column, int(11), kw_end_DASH_line, int(7713), kw_end_DASH_column, int(20)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp8 := lang.Apply(tmp4, []any{tmp7, nil, v3}) + _ = tmp8 + return nil + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_run_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_run_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reduce-kv + { + tmp0 := sym_reduce_DASH_kv.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_init, sym_coll)), kw_doc, "Reduces an associative collection. f should be a function of 3\n arguments. Returns the result of applying f to init, the first key\n and the first value in coll, then applying f to that result and the\n 2nd key and value, etc. If coll contains no entries, returns init\n and f is not called. Note that reduce-kv is supported on vectors,\n where the keys will be the ordinals.", kw_file, "glojure/core.glj", kw_added, "1.4", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(6882), kw_end_DASH_line, int(6882))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] _ = v4 - var tmp5 any + tmp5 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_kv_DASH_reduce) + tmp6 := lang.Apply(tmp5, []any{v4, v2, v3}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_reduce_DASH_kv = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_reduce_DASH_kv.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // update-keys + { + tmp0 := sym_update_DASH_keys.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m, sym_f)), kw_doc, "m f => {(f k) v ...}\n\n Given a map m and a function f of 1-argument, returns a new map whose\n keys are the result of applying f to the keys of m, mapped to the\n corresponding values of m.\n f must return a unique key for each key of m, else the behavior is undefined.", kw_file, "glojure/core.glj", kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(7906), kw_end_DASH_line, int(7906))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any { // let - // let binding "root-bind" - var tmp6 lang.FnFunc - tmp6 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v7 := args[0] - _ = v7 - var tmp8 any - { // let - // let binding "seq_338" - tmp9 := checkDerefVar(var_glojure_DOT_core_seq) - tmp10 := lang.Apply(tmp9, []any{v7}) - var v11 any = tmp10 - _ = v11 - // let binding "chunk_339" - var v12 any = nil - _ = v12 - // let binding "count_340" - var v13 any = int64(0) - _ = v13 - // let binding "i_341" - var v14 any = int64(0) - _ = v14 - for { - var tmp15 any - tmp16 := checkDerefVar(var_glojure_DOT_core__LT_) - tmp17 := lang.Apply(tmp16, []any{v14, v13}) - if lang.IsTruthy(tmp17) { - var tmp18 any - { // let - // let binding "vec__342" - tmp19, _ := lang.FieldOrMethod(v12, "nth") - if reflect.TypeOf(tmp19).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) - } - tmp20 := lang.Apply(tmp19, []any{v14}) - var v21 any = tmp20 - _ = v21 - // let binding "a-var" - tmp22 := checkDerefVar(var_glojure_DOT_core_nth) - tmp23 := lang.Apply(tmp22, []any{v21, int64(0), nil}) - var v24 any = tmp23 - _ = v24 - // let binding "a-val" - tmp25 := checkDerefVar(var_glojure_DOT_core_nth) - tmp26 := lang.Apply(tmp25, []any{v21, int64(1), nil}) - var v27 any = tmp26 - _ = v27 - tmp28, _ := lang.FieldOrMethod(v24, "bindRoot") - if reflect.TypeOf(tmp28).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("bindRoot is not a function"))) - } - tmp29 := lang.Apply(tmp28, []any{v27}) - _ = tmp29 - var tmp30 any = v11 - var tmp31 any = v12 - var tmp32 any = v13 - tmp34 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) - tmp35 := lang.Apply(tmp34, []any{v14}) - var tmp33 any = tmp35 - v11 = tmp30 - v12 = tmp31 - v13 = tmp32 - v14 = tmp33 - continue - } // end let - tmp15 = tmp18 - } else { - var tmp19 any - { // let - // let binding "temp__0__auto__" - tmp20 := checkDerefVar(var_glojure_DOT_core_seq) - tmp21 := lang.Apply(tmp20, []any{v11}) - var v22 any = tmp21 - _ = v22 - var tmp23 any - if lang.IsTruthy(v22) { - var tmp24 any - { // let - // let binding "seq_338" - var v25 any = v22 - _ = v25 - var tmp26 any - tmp27 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) - tmp28 := lang.Apply(tmp27, []any{v25}) - if lang.IsTruthy(tmp28) { - var tmp29 any - { // let - // let binding "c__0__auto__" - tmp30 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) - tmp31 := lang.Apply(tmp30, []any{v25}) - var v32 any = tmp31 - _ = v32 - tmp34 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) - tmp35 := lang.Apply(tmp34, []any{v25}) - var tmp33 any = tmp35 - var tmp36 any = v32 - tmp38 := checkDerefVar(var_glojure_DOT_core_int) - tmp39 := checkDerefVar(var_glojure_DOT_core_count) - tmp40 := lang.Apply(tmp39, []any{v32}) - tmp41 := lang.Apply(tmp38, []any{tmp40}) - var tmp37 any = tmp41 - tmp43 := checkDerefVar(var_glojure_DOT_core_int) - tmp44 := lang.Apply(tmp43, []any{int64(0)}) - var tmp42 any = tmp44 - v11 = tmp33 - v12 = tmp36 - v13 = tmp37 - v14 = tmp42 - continue - } // end let - tmp26 = tmp29 - } else { - var tmp30 any - { // let - // let binding "vec__345" - tmp31 := checkDerefVar(var_glojure_DOT_core_first) - tmp32 := lang.Apply(tmp31, []any{v25}) - var v33 any = tmp32 - _ = v33 - // let binding "a-var" - tmp34 := checkDerefVar(var_glojure_DOT_core_nth) - tmp35 := lang.Apply(tmp34, []any{v33, int64(0), nil}) - var v36 any = tmp35 - _ = v36 - // let binding "a-val" - tmp37 := checkDerefVar(var_glojure_DOT_core_nth) - tmp38 := lang.Apply(tmp37, []any{v33, int64(1), nil}) - var v39 any = tmp38 - _ = v39 - tmp40, _ := lang.FieldOrMethod(v36, "bindRoot") - if reflect.TypeOf(tmp40).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("bindRoot is not a function"))) - } - tmp41 := lang.Apply(tmp40, []any{v39}) - _ = tmp41 - tmp43 := checkDerefVar(var_glojure_DOT_core_next) - tmp44 := lang.Apply(tmp43, []any{v25}) - var tmp42 any = tmp44 - var tmp45 any = nil - var tmp46 any = int64(0) - var tmp47 any = int64(0) - v11 = tmp42 - v12 = tmp45 - v13 = tmp46 - v14 = tmp47 - continue - } // end let - tmp26 = tmp30 - } - tmp24 = tmp26 - } // end let - tmp23 = tmp24 - } else { - } - tmp19 = tmp23 - } // end let - tmp15 = tmp19 - } - tmp8 = tmp15 - break - } - } // end let - return tmp8 + // let binding "ret" + tmp5 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp6 := checkDerefVar(var_glojure_DOT_core_reduce_DASH_kv) + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + v10 := args[2] + _ = v10 + tmp11 := checkDerefVar(var_glojure_DOT_core_assoc_BANG_) + tmp12 := lang.Apply(v3, []any{v9}) + tmp13 := lang.Apply(tmp11, []any{v8, tmp12, v10}) + return tmp13 }) - tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7533), kw_column, int(19), kw_end_DASH_line, int(7535), kw_end_DASH_column, int(93)) - tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7916), kw_column, int(25), kw_end_DASH_line, int(7916), kw_end_DASH_column, int(59)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) if err != nil { panic(err) } - var v9 any = tmp8 - _ = v9 - // let binding "old-vals" - tmp10 := checkDerefVar(var_glojure_DOT_core_zipmap) - tmp11 := checkDerefVar(var_glojure_DOT_core_keys) - tmp12 := lang.Apply(tmp11, []any{v3}) - tmp13 := checkDerefVar(var_glojure_DOT_core_map) - var tmp14 lang.FnFunc - tmp14 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v15 := args[0] - _ = v15 - tmp16, ok := lang.FieldOrMethod(v15, "getRawRoot") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v15, "getRawRoot"))) - } - var tmp17 any - switch reflect.TypeOf(tmp16).Kind() { - case reflect.Func: - tmp17 = lang.Apply(tmp16, nil) - default: - tmp17 = tmp16 - } - return tmp17 - }) - tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7537), kw_column, int(31), kw_end_DASH_line, int(7537), kw_end_DASH_column, int(92)) - tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) + tmp10 := checkDerefVar(var_glojure_DOT_core_transient) + tmp11 := lang.NewMap() + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7917), kw_column, int(36), kw_end_DASH_line, int(7917), kw_end_DASH_column, int(37)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp17 := checkDerefVar(var_glojure_DOT_core_keys) - tmp18 := lang.Apply(tmp17, []any{v3}) - tmp19 := lang.Apply(tmp13, []any{tmp16, tmp18}) - tmp20 := lang.Apply(tmp10, []any{tmp12, tmp19}) - var v21 any = tmp20 - _ = v21 - var tmp22 any - func() { - defer func() { - tmp23 := lang.Apply(v9, []any{v21}) - _ = tmp23 - }() - tmp24 := lang.Apply(v9, []any{v3}) - _ = tmp24 - tmp25 := lang.Apply(v4, nil) - tmp22 = tmp25 - }() - tmp5 = tmp22 + tmp14 := lang.Apply(tmp10, []any{tmp13}) + tmp15 := lang.Apply(tmp6, []any{tmp9, tmp14, v2}) + tmp16 := lang.Apply(tmp5, []any{tmp15}) + var v17 any = tmp16 + _ = v17 + tmp18 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp19 := checkDerefVar(var_glojure_DOT_core_meta) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := lang.Apply(tmp18, []any{v17, tmp20}) + tmp4 = tmp21 } // end let - return tmp5 + return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_update_DASH_keys = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_update_DASH_keys.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // xml-seq + // update-vals { - tmp0 := sym_xml_DASH_seq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_root)), kw_doc, "A tree seq on the xml elements as per xml/parse", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4982), kw_end_DASH_line, int(4982))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v3 := args[0] + tmp0 := sym_update_DASH_vals.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m, sym_f)), kw_doc, "m f => {k (f v) ...}\n\n Given a map m and a function f of 1-argument, returns a new map where the keys of m\n are mapped to result of applying f to the corresponding values of m.", kw_file, "glojure/core.glj", kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(7890), kw_end_DASH_line, int(7890))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_tree_DASH_seq) - tmp5 := checkDerefVar(var_glojure_DOT_core_complement) - tmp6 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) - tmp7 := lang.Apply(tmp5, []any{tmp6}) - tmp8 := checkDerefVar(var_glojure_DOT_core_comp) - tmp9 := checkDerefVar(var_glojure_DOT_core_seq) - tmp10 := lang.Apply(tmp8, []any{tmp9, kw_content}) - tmp11 := lang.Apply(tmp4, []any{tmp7, tmp10, v3}) - return tmp11 + tmp4 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp5 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp6 := checkDerefVar(var_glojure_DOT_core_reduce_DASH_kv) + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + v10 := args[2] + _ = v10 + tmp11 := checkDerefVar(var_glojure_DOT_core_assoc_BANG_) + tmp12 := lang.Apply(v3, []any{v10}) + tmp13 := lang.Apply(tmp11, []any{v8, v9, tmp12}) + return tmp13 + }) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7899), kw_column, int(17), kw_end_DASH_line, int(7899), kw_end_DASH_column, int(51)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var tmp10 any + tmp11 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp12 := reflect.TypeOf((*lang.IEditableCollection)(nil)).Elem() + tmp13 := lang.Apply(tmp11, []any{tmp12, v2}) + if lang.IsTruthy(tmp13) { + tmp14 := checkDerefVar(var_glojure_DOT_core_transient) + tmp15 := lang.Apply(tmp14, []any{v2}) + tmp10 = tmp15 + } else { + tmp16 := checkDerefVar(var_glojure_DOT_core_transient) + tmp17 := lang.NewMap() + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7902), kw_column, int(30), kw_end_DASH_line, int(7902), kw_end_DASH_column, int(31)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp20 := lang.Apply(tmp16, []any{tmp19}) + tmp10 = tmp20 + } + tmp21 := lang.Apply(tmp6, []any{tmp9, tmp10, v2}) + tmp22 := lang.Apply(tmp5, []any{tmp21}) + tmp23 := checkDerefVar(var_glojure_DOT_core_meta) + tmp24 := lang.Apply(tmp23, []any{v2}) + tmp25 := lang.Apply(tmp4, []any{tmp22, tmp24}) + return tmp25 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_update_DASH_vals = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_update_DASH_vals.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // zero? + // slurp { - var tmp1 lang.FnFunc - { // function zero?__inliner - var v2 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { + tmp1 := reflect.TypeOf("") + tmp0 := sym_slurp.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_f, sym__AMP_, sym_opts)), kw_doc, "Opens a reader on f and reads all its contents, returning a string.\n See glojure.java.io/reader for a complete list of supported arguments.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(6982), kw_end_DASH_line, int(6982))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: checkArity(args, 1) v3 := args[0] _ = v3 - tmp4 := checkDerefVar(var_glojure_DOT_core_seq) - tmp5 := checkDerefVar(var_glojure_DOT_core_concat) - tmp6 := checkDerefVar(var_glojure_DOT_core_list) - tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) - tmp8 := checkDerefVar(var_glojure_DOT_core_list) - tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) - tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := checkDerefVar(var_glojure_DOT_core_seq) - tmp12 := checkDerefVar(var_glojure_DOT_core_concat) - tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_IsZero}) - tmp15 := checkDerefVar(var_glojure_DOT_core_list) - tmp16 := lang.Apply(tmp15, []any{v3}) - tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) - tmp18 := lang.Apply(tmp11, []any{tmp17}) - tmp19 := lang.Apply(tmp10, []any{tmp18}) - tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) - tmp21 := lang.Apply(tmp4, []any{tmp20}) - return tmp21 - }) - v2 = tmp1 - _ = v2 - } - tmp0 := sym_zero_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_num)), kw_inline, tmp1, kw_doc, "Returns true if num is zero, else false", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(860), kw_end_DASH_line, int(860))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "IsZero") - if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("IsZero is not a function"))) + var v4 any = lang.NewList(args[1:]...) + _ = v4 + var tmp5 any + { // let + // let binding "opts" + tmp6 := checkDerefVar(var_glojure_DOT_core_normalize_DASH_slurp_DASH_opts) + tmp7 := lang.Apply(tmp6, []any{v4}) + var v8 any = tmp7 + _ = v8 + // let binding "sw" + var v9 any = "unimplemented: new with non-constant class type" + _ = v9 + var tmp10 any + { // let + // let binding "r" + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + tmp12 := checkDerefVar(var_glojure_DOT_go_DOT_io_reader) + tmp13 := lang.Apply(tmp11, []any{tmp12, v3, v8}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + func() { + defer func() { + tmp16, ok := lang.FieldOrMethod(v14, "close") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v14, "close"))) + } + var tmp17 any + switch reflect.TypeOf(tmp16).Kind() { + case reflect.Func: + tmp17 = lang.Apply(tmp16, nil) + default: + tmp17 = tmp16 + } + _ = tmp17 + }() + tmp18 := checkDerefVar(var_glojure_DOT_go_DOT_io_copy) + tmp19 := lang.Apply(tmp18, []any{v14, v9}) + _ = tmp19 + tmp20 := lang.Apply(lang.ToString, []any{v9}) + tmp15 = tmp20 + }() + tmp10 = tmp15 + } // end let + tmp5 = tmp10 + } // end let + return tmp5 } - tmp6 := lang.Apply(tmp5, []any{v4}) - return tmp6 }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp2 := ns.InternWithValue(tmp0, tmp3, true) + tmp3 := reflect.TypeOf("") + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_slurp = ns.InternWithValue(tmp0, tmp2, true) if tmp0.Meta() != nil { - tmp2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_slurp.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // zipmap + // transduce { - tmp0 := sym_zipmap.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_keys, sym_vals)), kw_doc, "Returns a map with the keys mapped to the corresponding vals.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(6583), kw_end_DASH_line, int(6583))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v3 := args[0] - _ = v3 - v4 := args[1] - _ = v4 - var tmp5 any - { // let - // let binding "map" - tmp6 := checkDerefVar(var_glojure_DOT_core_transient) - tmp7 := lang.NewMap() - tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6588), kw_column, int(27), kw_end_DASH_line, int(6588), kw_end_DASH_column, int(28)) - tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp10 := lang.Apply(tmp6, []any{tmp9}) - var v11 any = tmp10 - _ = v11 - // let binding "ks" - tmp12 := checkDerefVar(var_glojure_DOT_core_seq) - tmp13 := lang.Apply(tmp12, []any{v3}) - var v14 any = tmp13 - _ = v14 - // let binding "vs" - tmp15 := checkDerefVar(var_glojure_DOT_core_seq) - tmp16 := lang.Apply(tmp15, []any{v4}) - var v17 any = tmp16 - _ = v17 - for { - var tmp18 any - var tmp19 any - { // let - // let binding "and__0__auto__" - var v20 any = v14 - _ = v20 - var tmp21 any - if lang.IsTruthy(v20) { - tmp21 = v17 - } else { - tmp21 = v20 + tmp0 := sym_transduce.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xform, sym_f, sym_coll), lang.NewVector(sym_xform, sym_f, sym_init, sym_coll)), kw_doc, "reduce with a transformation of f (xf). If init is not\n supplied, (f) will be called to produce it. f should be a reducing\n step function that accepts both 1 and 2 arguments, if it accepts\n only 2 you can add the arity-1 with 'completing'. Returns the result\n of applying (the transformed) xf to init and the first item in coll,\n then applying xf to that result and the 2nd item, etc. If coll\n contains no items, returns init and f is not called. Note that\n certain transforms may inject or skip items.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(6905), kw_end_DASH_line, int(6905))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_transduce) + tmp6 := lang.Apply(v3, nil) + tmp7 := lang.Apply(tmp5, []any{v2, v3, tmp6, v4}) + return tmp7 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var tmp6 any + { // let + // let binding "f" + tmp7 := lang.Apply(v2, []any{v3}) + var v8 any = tmp7 + _ = v8 + // let binding "ret" + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp11 := reflect.TypeOf((*lang.IReduceInit)(nil)).Elem() + tmp12 := lang.Apply(tmp10, []any{tmp11, v5}) + if lang.IsTruthy(tmp12) { + tmp13, _ := lang.FieldOrMethod(v5, "ReduceInit") + if reflect.TypeOf(tmp13).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) } - tmp19 = tmp21 - } // end let - if lang.IsTruthy(tmp19) { - tmp21 := checkDerefVar(var_glojure_DOT_core_assoc_BANG_) - tmp22 := checkDerefVar(var_glojure_DOT_core_first) - tmp23 := lang.Apply(tmp22, []any{v14}) - tmp24 := checkDerefVar(var_glojure_DOT_core_first) - tmp25 := lang.Apply(tmp24, []any{v17}) - tmp26 := lang.Apply(tmp21, []any{v11, tmp23, tmp25}) - var tmp20 any = tmp26 - tmp28 := checkDerefVar(var_glojure_DOT_core_next) - tmp29 := lang.Apply(tmp28, []any{v14}) - var tmp27 any = tmp29 - tmp31 := checkDerefVar(var_glojure_DOT_core_next) - tmp32 := lang.Apply(tmp31, []any{v17}) - var tmp30 any = tmp32 - v11 = tmp20 - v14 = tmp27 - v17 = tmp30 - continue + tmp14 := lang.Apply(tmp13, []any{v8, v4}) + tmp9 = tmp14 } else { - tmp33 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) - tmp34 := lang.Apply(tmp33, []any{v11}) - tmp18 = tmp34 + tmp15 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_coll_DASH_reduce) + tmp16 := lang.Apply(tmp15, []any{v5, v8, v4}) + tmp9 = tmp16 } - tmp5 = tmp18 - break - } - } // end let - return tmp5 + var v17 any = tmp9 + _ = v17 + tmp18 := lang.Apply(v8, []any{v17}) + tmp6 = tmp18 + } // end let + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_transduce = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_glojure_DOT_core_transduce.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } } diff --git a/pkg/runtime/testdata/codegen/test/def_simple/load.go.out b/pkg/runtime/testdata/codegen/test/def_simple/load.go.out index 2fa585b6..0e2b3b43 100644 --- a/pkg/runtime/testdata/codegen/test/def_simple/load.go.out +++ b/pkg/runtime/testdata/codegen/test/def_simple/load.go.out @@ -6,10 +6,11 @@ import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" runtime "github.com/glojurelang/glojure/pkg/runtime" + reflect "reflect" ) func init() { - runtime.RegisterNSLoader("codegen.test.def-simple", LoadNS) + runtime.RegisterNSLoader("codegen/test/def_simple", LoadNS) } func checkDerefVar(v *lang.Var) any { @@ -29,16 +30,20 @@ func checkArity(args []any, expected int) { func LoadNS() { sym_codegen_DOT_test_DOT_def_DASH_simple := lang.NewSymbol("codegen.test.def-simple") sym_foo := lang.NewSymbol("foo") + // var codegen.test.def-simple/foo + var_codegen_DOT_test_DOT_def_DASH_simple_foo := lang.InternVarName(sym_codegen_DOT_test_DOT_def_DASH_simple, sym_foo) // reference fmt to avoid unused import error _ = fmt.Printf + // reference reflect to avoid unused import error + _ = reflect.TypeOf ns := lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_def_DASH_simple) _ = ns // foo { tmp0 := sym_foo.WithMeta(lang.NewMap()).(*lang.Symbol) - tmp1 := ns.Intern(tmp0) + var_codegen_DOT_test_DOT_def_DASH_simple_foo = ns.Intern(tmp0) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_codegen_DOT_test_DOT_def_DASH_simple_foo.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } } diff --git a/pkg/runtime/testdata/codegen/test/fn_closure/load.go.out b/pkg/runtime/testdata/codegen/test/fn_closure/load.go.out index ce8d7148..fdfbe948 100644 --- a/pkg/runtime/testdata/codegen/test/fn_closure/load.go.out +++ b/pkg/runtime/testdata/codegen/test/fn_closure/load.go.out @@ -6,10 +6,11 @@ import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" runtime "github.com/glojurelang/glojure/pkg/runtime" + reflect "reflect" ) func init() { - runtime.RegisterNSLoader("codegen.test.fn-closure", LoadNS) + runtime.RegisterNSLoader("codegen/test/fn_closure", LoadNS) } func checkDerefVar(v *lang.Var) any { @@ -47,8 +48,12 @@ func LoadNS() { kw_line := lang.NewKeyword("line") kw_ns := lang.NewKeyword("ns") kw_rettag := lang.NewKeyword("rettag") + // var codegen.test.fn-closure/-main + var_codegen_DOT_test_DOT_fn_DASH_closure__DASH_main := lang.InternVarName(sym_codegen_DOT_test_DOT_fn_DASH_closure, sym__DASH_main) // var codegen.test.fn-closure/closed var_codegen_DOT_test_DOT_fn_DASH_closure_closed := lang.InternVarName(sym_codegen_DOT_test_DOT_fn_DASH_closure, sym_closed) + // var codegen.test.fn-closure/gen-closure + var_codegen_DOT_test_DOT_fn_DASH_closure_gen_DASH_closure := lang.InternVarName(sym_codegen_DOT_test_DOT_fn_DASH_closure, sym_gen_DASH_closure) // var codegen.test.fn-closure/get-atom var_codegen_DOT_test_DOT_fn_DASH_closure_get_DASH_atom := lang.InternVarName(sym_codegen_DOT_test_DOT_fn_DASH_closure, sym_get_DASH_atom) // var codegen.test.fn-closure/inc-atom @@ -59,7 +64,12 @@ func LoadNS() { var_glojure_DOT_core_inc := lang.InternVarName(sym_glojure_DOT_core, sym_inc) // var glojure.core/swap! var_glojure_DOT_core_swap_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_swap_BANG_) - // //////////////////////////////////////////////////////////////////////////////// Closed-over values + // reference fmt to avoid unused import error + _ = fmt.Printf + // reference reflect to avoid unused import error + _ = reflect.TypeOf + ns := lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_fn_DASH_closure) + _ = ns var closed0 any { closed0 = int64(42) @@ -69,109 +79,104 @@ func LoadNS() { tmp0 := lang.NewAtom(int64(0)) closed1 = tmp0 } - - // reference fmt to avoid unused import error - _ = fmt.Printf - ns := lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_fn_DASH_closure) - _ = ns - // -main - { - tmp0 := sym__DASH_main.WithMeta(lang.NewMap(kw_expected_DASH_output, lang.NewVector(int64(42), int64(1)), kw_file, "codegen/test/fn_closure.glj", kw_line, int(13), kw_column, int(7), kw_end_DASH_line, int(13), kw_end_DASH_column, int(38), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_fn_DASH_closure))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - tmp3 := checkDerefVar(var_codegen_DOT_test_DOT_fn_DASH_closure_inc_DASH_atom) - tmp4 := lang.Apply(tmp3, nil) - _ = tmp4 - tmp5 := checkDerefVar(var_codegen_DOT_test_DOT_fn_DASH_closure_closed) - tmp6 := lang.Apply(tmp5, nil) - tmp7 := checkDerefVar(var_codegen_DOT_test_DOT_fn_DASH_closure_get_DASH_atom) - tmp8 := lang.Apply(tmp7, nil) - tmp9 := lang.NewVector(tmp6, tmp8) - tmp10 := lang.NewMap(kw_file, "codegen/test/fn_closure.glj", kw_line, int(15), kw_column, int(3), kw_end_DASH_line, int(16), kw_end_DASH_column, int(14)) - tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp11 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } // closed { tmp0 := sym_closed.WithMeta(lang.NewMap(kw_file, "codegen/test/fn_closure.glj", kw_line, int(5), kw_column, int(6), kw_end_DASH_line, int(5), kw_end_DASH_column, int(11), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_fn_DASH_closure))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 0) return closed0 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "codegen/test/fn_closure.glj", kw_line, int(3), kw_column, int(32), kw_end_DASH_line, int(3), kw_end_DASH_column, int(49))).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "codegen/test/fn_closure.glj", kw_line, int(3), kw_column, int(32), kw_end_DASH_line, int(3), kw_end_DASH_column, int(49))).(lang.FnFunc) + var_codegen_DOT_test_DOT_fn_DASH_closure_closed = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_codegen_DOT_test_DOT_fn_DASH_closure_closed.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // gen-closure { tmp0 := sym_gen_DASH_closure.WithMeta(lang.NewMap(kw_file, "codegen/test/fn_closure.glj", kw_line, int(3), kw_column, int(7), kw_end_DASH_line, int(3), kw_end_DASH_column, int(17), kw_arglists, lang.NewList(lang.NewVector(sym_the_DASH_result)), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_fn_DASH_closure))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 0) - return v3 + return v2 }) - tmp5 := lang.NewMap(kw_file, "codegen/test/fn_closure.glj", kw_line, int(3), kw_column, int(32), kw_end_DASH_line, int(3), kw_end_DASH_column, int(49)) - tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + tmp4 := lang.NewMap(kw_file, "codegen/test/fn_closure.glj", kw_line, int(3), kw_column, int(32), kw_end_DASH_line, int(3), kw_end_DASH_column, int(49)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) if err != nil { panic(err) } - return tmp6 + return tmp5 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_codegen_DOT_test_DOT_fn_DASH_closure_gen_DASH_closure = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_codegen_DOT_test_DOT_fn_DASH_closure_gen_DASH_closure.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // -main + { + tmp0 := sym__DASH_main.WithMeta(lang.NewMap(kw_expected_DASH_output, lang.NewVector(int64(42), int64(1)), kw_file, "codegen/test/fn_closure.glj", kw_line, int(13), kw_column, int(7), kw_end_DASH_line, int(13), kw_end_DASH_column, int(38), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_fn_DASH_closure))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp2 := checkDerefVar(var_codegen_DOT_test_DOT_fn_DASH_closure_inc_DASH_atom) + tmp3 := lang.Apply(tmp2, nil) + _ = tmp3 + tmp4 := checkDerefVar(var_codegen_DOT_test_DOT_fn_DASH_closure_closed) + tmp5 := lang.Apply(tmp4, nil) + tmp6 := checkDerefVar(var_codegen_DOT_test_DOT_fn_DASH_closure_get_DASH_atom) + tmp7 := lang.Apply(tmp6, nil) + tmp8 := lang.NewVector(tmp5, tmp7) + tmp9 := lang.NewMap(kw_file, "codegen/test/fn_closure.glj", kw_line, int(15), kw_column, int(3), kw_end_DASH_line, int(16), kw_end_DASH_column, int(14)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp10 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_codegen_DOT_test_DOT_fn_DASH_closure__DASH_main = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_codegen_DOT_test_DOT_fn_DASH_closure__DASH_main.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // get-atom { tmp0 := sym_get_DASH_atom.WithMeta(lang.NewMap(kw_file, "codegen/test/fn_closure.glj", kw_line, int(10), kw_column, int(9), kw_end_DASH_line, int(10), kw_end_DASH_column, int(16), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_fn_DASH_closure))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 0) - tmp3 := checkDerefVar(var_glojure_DOT_core_deref) - tmp4 := lang.Apply(tmp3, []any{closed1}) - return tmp4 + tmp2 := checkDerefVar(var_glojure_DOT_core_deref) + tmp3 := lang.Apply(tmp2, []any{closed1}) + return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_codegen_DOT_test_DOT_fn_DASH_closure_get_DASH_atom = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_codegen_DOT_test_DOT_fn_DASH_closure_get_DASH_atom.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // inc-atom { tmp0 := sym_inc_DASH_atom.WithMeta(lang.NewMap(kw_file, "codegen/test/fn_closure.glj", kw_line, int(8), kw_column, int(9), kw_end_DASH_line, int(8), kw_end_DASH_column, int(16), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_fn_DASH_closure))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 0) - tmp3 := checkDerefVar(var_glojure_DOT_core_swap_BANG_) - tmp4 := checkDerefVar(var_glojure_DOT_core_inc) - tmp5 := lang.Apply(tmp3, []any{closed1, tmp4}) - return tmp5 + tmp2 := checkDerefVar(var_glojure_DOT_core_swap_BANG_) + tmp3 := checkDerefVar(var_glojure_DOT_core_inc) + tmp4 := lang.Apply(tmp2, []any{closed1, tmp3}) + return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_codegen_DOT_test_DOT_fn_DASH_closure_inc_DASH_atom = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_codegen_DOT_test_DOT_fn_DASH_closure_inc_DASH_atom.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } } diff --git a/pkg/runtime/testdata/codegen/test/fn_recur/load.go.out b/pkg/runtime/testdata/codegen/test/fn_recur/load.go.out index a0645e30..41c58d54 100644 --- a/pkg/runtime/testdata/codegen/test/fn_recur/load.go.out +++ b/pkg/runtime/testdata/codegen/test/fn_recur/load.go.out @@ -6,10 +6,11 @@ import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" runtime "github.com/glojurelang/glojure/pkg/runtime" + reflect "reflect" ) func init() { - runtime.RegisterNSLoader("codegen.test.fn-recur", LoadNS) + runtime.RegisterNSLoader("codegen/test/fn_recur", LoadNS) } func checkDerefVar(v *lang.Var) any { @@ -45,6 +46,8 @@ func LoadNS() { kw_line := lang.NewKeyword("line") kw_ns := lang.NewKeyword("ns") kw_rettag := lang.NewKeyword("rettag") + // var codegen.test.fn-recur/-main + var_codegen_DOT_test_DOT_fn_DASH_recur__DASH_main := lang.InternVarName(sym_codegen_DOT_test_DOT_fn_DASH_recur, sym__DASH_main) // var codegen.test.fn-recur/fib var_codegen_DOT_test_DOT_fn_DASH_recur_fib := lang.InternVarName(sym_codegen_DOT_test_DOT_fn_DASH_recur, sym_fib) // var glojure.core/= @@ -55,86 +58,88 @@ func LoadNS() { var_glojure_DOT_core_inc := lang.InternVarName(sym_glojure_DOT_core, sym_inc) // reference fmt to avoid unused import error _ = fmt.Printf + // reference reflect to avoid unused import error + _ = reflect.TypeOf ns := lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_fn_DASH_recur) _ = ns // -main { tmp0 := sym__DASH_main.WithMeta(lang.NewMap(kw_expected_DASH_output, int64(55), kw_file, "codegen/test/fn_recur.glj", kw_line, int(12), kw_column, int(7), kw_end_DASH_line, int(12), kw_end_DASH_column, int(34), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_fn_DASH_recur))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 0) - tmp3 := checkDerefVar(var_codegen_DOT_test_DOT_fn_DASH_recur_fib) - tmp4 := lang.Apply(tmp3, []any{int64(10)}) - return tmp4 + tmp2 := checkDerefVar(var_codegen_DOT_test_DOT_fn_DASH_recur_fib) + tmp3 := lang.Apply(tmp2, []any{int64(10)}) + return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_codegen_DOT_test_DOT_fn_DASH_recur__DASH_main = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_codegen_DOT_test_DOT_fn_DASH_recur__DASH_main.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // fib { tmp0 := sym_fib.WithMeta(lang.NewMap(kw_file, "codegen/test/fn_recur.glj", kw_line, int(3), kw_column, int(7), kw_end_DASH_line, int(3), kw_end_DASH_column, int(9), kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_doc, "Calculates the nth Fibonacci number using iteration with recur.", kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_fn_DASH_recur))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) - v3 := args[0] - _ = v3 - var tmp4 any + v2 := args[0] + _ = v2 + var tmp3 any { // let // let binding "fib-helper" - var tmp5 lang.FnFunc + var tmp4 lang.FnFunc { // function fib-helper - var v6 lang.FnFunc - tmp5 = lang.NewFnFunc(func(args ...any) any { + var v5 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 3) - v7 := args[0] + v6 := args[0] + _ = v6 + v7 := args[1] _ = v7 - v8 := args[1] + v8 := args[2] _ = v8 - v9 := args[2] - _ = v9 recur_loop_1612: - var tmp10 any - tmp11 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp12 := lang.Apply(tmp11, []any{v9, v3}) - if lang.IsTruthy(tmp12) { - tmp10 = v7 + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp11 := lang.Apply(tmp10, []any{v8, v2}) + if lang.IsTruthy(tmp11) { + tmp9 = v6 } else { - var tmp13 any = v8 - tmp15 := checkDerefVar(var_glojure_DOT_core__PLUS_) - tmp16 := lang.Apply(tmp15, []any{v7, v8}) - var tmp14 any = tmp16 - tmp18 := checkDerefVar(var_glojure_DOT_core_inc) - tmp19 := lang.Apply(tmp18, []any{v9}) - var tmp17 any = tmp19 + var tmp12 any = v7 + tmp14 := checkDerefVar(var_glojure_DOT_core__PLUS_) + tmp15 := lang.Apply(tmp14, []any{v6, v7}) + var tmp13 any = tmp15 + tmp17 := checkDerefVar(var_glojure_DOT_core_inc) + tmp18 := lang.Apply(tmp17, []any{v8}) + var tmp16 any = tmp18 + v6 = tmp12 v7 = tmp13 - v8 = tmp14 - v9 = tmp17 + v8 = tmp16 goto recur_loop_1612 } - return tmp10 + return tmp9 }) - v6 = tmp5 - _ = v6 + v5 = tmp4 + _ = v5 } - tmp6 := lang.NewMap(kw_file, "codegen/test/fn_recur.glj", kw_line, int(6), kw_column, int(20), kw_end_DASH_line, int(9), kw_end_DASH_column, int(50)) - tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + tmp5 := lang.NewMap(kw_file, "codegen/test/fn_recur.glj", kw_line, int(6), kw_column, int(20), kw_end_DASH_line, int(9), kw_end_DASH_column, int(50)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) if err != nil { panic(err) } - var v8 any = tmp7 - _ = v8 - tmp9 := lang.Apply(v8, []any{int64(0), int64(1), int64(0)}) - tmp4 = tmp9 + var v7 any = tmp6 + _ = v7 + tmp8 := lang.Apply(v7, []any{int64(0), int64(1), int64(0)}) + tmp3 = tmp8 } // end let - return tmp4 + return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_codegen_DOT_test_DOT_fn_DASH_recur_fib = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_codegen_DOT_test_DOT_fn_DASH_recur_fib.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } } diff --git a/pkg/runtime/testdata/codegen/test/loop_simple/load.go.out b/pkg/runtime/testdata/codegen/test/loop_simple/load.go.out index 1c9eb548..2f3bfea2 100644 --- a/pkg/runtime/testdata/codegen/test/loop_simple/load.go.out +++ b/pkg/runtime/testdata/codegen/test/loop_simple/load.go.out @@ -6,10 +6,11 @@ import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" runtime "github.com/glojurelang/glojure/pkg/runtime" + reflect "reflect" ) func init() { - runtime.RegisterNSLoader("codegen.test.loop-simple", LoadNS) + runtime.RegisterNSLoader("codegen/test/loop_simple", LoadNS) } func checkDerefVar(v *lang.Var) any { @@ -42,6 +43,8 @@ func LoadNS() { kw_line := lang.NewKeyword("line") kw_ns := lang.NewKeyword("ns") kw_rettag := lang.NewKeyword("rettag") + // var codegen.test.loop-simple/-main + var_codegen_DOT_test_DOT_loop_DASH_simple__DASH_main := lang.InternVarName(sym_codegen_DOT_test_DOT_loop_DASH_simple, sym__DASH_main) // var codegen.test.loop-simple/simple-loop var_codegen_DOT_test_DOT_loop_DASH_simple_simple_DASH_loop := lang.InternVarName(sym_codegen_DOT_test_DOT_loop_DASH_simple, sym_simple_DASH_loop) // var glojure.core/< @@ -50,58 +53,60 @@ func LoadNS() { var_glojure_DOT_core_inc := lang.InternVarName(sym_glojure_DOT_core, sym_inc) // reference fmt to avoid unused import error _ = fmt.Printf + // reference reflect to avoid unused import error + _ = reflect.TypeOf ns := lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_loop_DASH_simple) _ = ns // -main { tmp0 := sym__DASH_main.WithMeta(lang.NewMap(kw_expected_DASH_output, int64(10), kw_file, "codegen/test/loop_simple.glj", kw_line, int(9), kw_column, int(7), kw_end_DASH_line, int(10), kw_end_DASH_column, int(7), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_loop_DASH_simple))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 0) - tmp3 := checkDerefVar(var_codegen_DOT_test_DOT_loop_DASH_simple_simple_DASH_loop) - tmp4 := lang.Apply(tmp3, nil) - return tmp4 + tmp2 := checkDerefVar(var_codegen_DOT_test_DOT_loop_DASH_simple_simple_DASH_loop) + tmp3 := lang.Apply(tmp2, nil) + return tmp3 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_codegen_DOT_test_DOT_loop_DASH_simple__DASH_main = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_codegen_DOT_test_DOT_loop_DASH_simple__DASH_main.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // simple-loop { tmp0 := sym_simple_DASH_loop.WithMeta(lang.NewMap(kw_file, "codegen/test/loop_simple.glj", kw_line, int(3), kw_column, int(7), kw_end_DASH_line, int(3), kw_end_DASH_column, int(17), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_loop_DASH_simple))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 0) - var tmp3 any + var tmp2 any { // let // let binding "i" - var v4 any = int64(0) - _ = v4 + var v3 any = int64(0) + _ = v3 for { - var tmp5 any - tmp6 := checkDerefVar(var_glojure_DOT_core__LT_) - tmp7 := lang.Apply(tmp6, []any{v4, int64(10)}) - if lang.IsTruthy(tmp7) { - tmp9 := checkDerefVar(var_glojure_DOT_core_inc) - tmp10 := lang.Apply(tmp9, []any{v4}) - var tmp8 any = tmp10 - v4 = tmp8 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp6 := lang.Apply(tmp5, []any{v3, int64(10)}) + if lang.IsTruthy(tmp6) { + tmp8 := checkDerefVar(var_glojure_DOT_core_inc) + tmp9 := lang.Apply(tmp8, []any{v3}) + var tmp7 any = tmp9 + v3 = tmp7 continue } else { - tmp5 = v4 + tmp4 = v3 } - tmp3 = tmp5 + tmp2 = tmp4 break } } // end let - return tmp3 + return tmp2 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_codegen_DOT_test_DOT_loop_DASH_simple_simple_DASH_loop = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_codegen_DOT_test_DOT_loop_DASH_simple_simple_DASH_loop.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } } diff --git a/pkg/runtime/testdata/codegen/test/maybe_class/load.go.out b/pkg/runtime/testdata/codegen/test/maybe_class/load.go.out index 5dd79382..ecaeebb8 100644 --- a/pkg/runtime/testdata/codegen/test/maybe_class/load.go.out +++ b/pkg/runtime/testdata/codegen/test/maybe_class/load.go.out @@ -6,11 +6,12 @@ import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" runtime "github.com/glojurelang/glojure/pkg/runtime" - strings3 "strings" + reflect "reflect" + strings4 "strings" ) func init() { - runtime.RegisterNSLoader("codegen.test.maybe-class", LoadNS) + runtime.RegisterNSLoader("codegen/test/maybe_class", LoadNS) } func checkDerefVar(v *lang.Var) any { @@ -41,27 +42,31 @@ func LoadNS() { kw_line := lang.NewKeyword("line") kw_ns := lang.NewKeyword("ns") kw_rettag := lang.NewKeyword("rettag") + // var codegen.test.maybe-class/-main + var_codegen_DOT_test_DOT_maybe_DASH_class__DASH_main := lang.InternVarName(sym_codegen_DOT_test_DOT_maybe_DASH_class, sym__DASH_main) // var glojure.core/vec var_glojure_DOT_core_vec := lang.InternVarName(sym_glojure_DOT_core, sym_vec) // reference fmt to avoid unused import error _ = fmt.Printf + // reference reflect to avoid unused import error + _ = reflect.TypeOf ns := lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_maybe_DASH_class) _ = ns // -main { tmp0 := sym__DASH_main.WithMeta(lang.NewMap(kw_expected_DASH_output, lang.NewVector("1", "2", "3"), kw_file, "codegen/test/maybe_class.glj", kw_line, int(3), kw_column, int(7), kw_end_DASH_line, int(3), kw_end_DASH_column, int(45), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_maybe_DASH_class))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 0) - tmp3 := checkDerefVar(var_glojure_DOT_core_vec) - tmp4 := lang.Apply(strings3.Split, []any{"1,2,3", ","}) - tmp5 := lang.Apply(tmp3, []any{tmp4}) - return tmp5 + tmp2 := checkDerefVar(var_glojure_DOT_core_vec) + tmp3 := lang.Apply(strings4.Split, []any{"1,2,3", ","}) + tmp4 := lang.Apply(tmp2, []any{tmp3}) + return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_codegen_DOT_test_DOT_maybe_DASH_class__DASH_main = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_codegen_DOT_test_DOT_maybe_DASH_class__DASH_main.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } } diff --git a/pkg/runtime/testdata/codegen/test/multifn/load.go.out b/pkg/runtime/testdata/codegen/test/multifn/load.go.out index 814d7f57..b35ab5ad 100644 --- a/pkg/runtime/testdata/codegen/test/multifn/load.go.out +++ b/pkg/runtime/testdata/codegen/test/multifn/load.go.out @@ -10,7 +10,7 @@ import ( ) func init() { - runtime.RegisterNSLoader("codegen.test.multifn", LoadNS) + runtime.RegisterNSLoader("codegen/test/multifn", LoadNS) } func checkDerefVar(v *lang.Var) any { @@ -47,6 +47,8 @@ func LoadNS() { kw_line := lang.NewKeyword("line") kw_ns := lang.NewKeyword("ns") kw_rettag := lang.NewKeyword("rettag") + // var codegen.test.multifn/-main + var_codegen_DOT_test_DOT_multifn__DASH_main := lang.InternVarName(sym_codegen_DOT_test_DOT_multifn, sym__DASH_main) // var codegen.test.multifn/add var_codegen_DOT_test_DOT_multifn_add := lang.InternVarName(sym_codegen_DOT_test_DOT_multifn, sym_add) // var glojure.core/+ @@ -57,62 +59,78 @@ func LoadNS() { var_glojure_DOT_core_type := lang.InternVarName(sym_glojure_DOT_core, sym_type) // reference fmt to avoid unused import error _ = fmt.Printf + // reference reflect to avoid unused import error + _ = reflect.TypeOf ns := lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_multifn) _ = ns // -main { tmp0 := sym__DASH_main.WithMeta(lang.NewMap(kw_expected_DASH_output, "int64: 7 float64: 8.0 default: 3 4", kw_file, "codegen/test/multifn.glj", kw_line, int(8), kw_column, int(7), kw_end_DASH_line, int(8), kw_end_DASH_column, int(68), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_multifn))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 0) - tmp3 := checkDerefVar(var_glojure_DOT_core_str) - tmp4 := checkDerefVar(var_codegen_DOT_test_DOT_multifn_add) - tmp5 := lang.Apply(tmp4, []any{int64(3), int64(4)}) - tmp6 := checkDerefVar(var_codegen_DOT_test_DOT_multifn_add) - tmp7 := lang.Apply(tmp6, []any{float64(3.5), float64(4.5)}) - tmp8 := checkDerefVar(var_codegen_DOT_test_DOT_multifn_add) - tmp9 := lang.Apply(tmp8, []any{"3", "4"}) - tmp10 := lang.Apply(tmp3, []any{tmp5, " ", tmp7, " ", tmp9}) - return tmp10 + tmp2 := checkDerefVar(var_glojure_DOT_core_str) + tmp3 := checkDerefVar(var_codegen_DOT_test_DOT_multifn_add) + tmp4 := lang.Apply(tmp3, []any{int64(3), int64(4)}) + tmp5 := checkDerefVar(var_codegen_DOT_test_DOT_multifn_add) + tmp6 := lang.Apply(tmp5, []any{float64(3.5), float64(4.5)}) + tmp7 := checkDerefVar(var_codegen_DOT_test_DOT_multifn_add) + tmp8 := lang.Apply(tmp7, []any{"3", "4"}) + tmp9 := lang.Apply(tmp2, []any{tmp4, " ", tmp6, " ", tmp8}) + return tmp9 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_codegen_DOT_test_DOT_multifn__DASH_main = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_codegen_DOT_test_DOT_multifn__DASH_main.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // add { tmp0 := sym_add.WithMeta(lang.NewMap(kw_file, "codegen/test/multifn.glj", kw_line, int(3), kw_column, int(11), kw_end_DASH_line, int(3), kw_end_DASH_column, int(13), kw_doc, "a multimethod for addition", kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_multifn))).(*lang.Symbol) - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 2) - v4 := args[0] + v3 := args[0] + _ = v3 + v4 := args[1] _ = v4 - v5 := args[1] - _ = v5 - tmp6 := checkDerefVar(var_glojure_DOT_core_type) - tmp7 := lang.Apply(tmp6, []any{v4}) - return tmp7 + tmp5 := checkDerefVar(var_glojure_DOT_core_type) + tmp6 := lang.Apply(tmp5, []any{v3}) + return tmp6 }) - tmp3 = tmp3.WithMeta(lang.NewMap(kw_file, "codegen/test/multifn.glj", kw_line, int(3), kw_column, int(44), kw_end_DASH_line, int(3), kw_end_DASH_column, int(62))).(lang.FnFunc) - tmp2 := lang.NewMultiFn("add", tmp3, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) - tmp4 := reflect.TypeOf(int64(0)) - var tmp5 lang.FnFunc - tmp5 = lang.NewFnFunc(func(args ...any) any { + tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "codegen/test/multifn.glj", kw_line, int(3), kw_column, int(44), kw_end_DASH_line, int(3), kw_end_DASH_column, int(62))).(lang.FnFunc) + tmp1 := lang.NewMultiFn("add", tmp2, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) + tmp3 := reflect.TypeOf(int64(0)) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 2) - v6 := args[0] + v5 := args[0] + _ = v5 + v6 := args[1] _ = v6 - v7 := args[1] + tmp7 := checkDerefVar(var_glojure_DOT_core_str) + tmp8 := checkDerefVar(var_glojure_DOT_core__PLUS_) + tmp9 := lang.Apply(tmp8, []any{v5, v6}) + tmp10 := lang.Apply(tmp7, []any{"int64: ", tmp9}) + return tmp10 + }) + tmp1.AddMethod(tmp3, tmp4) + tmp5 := reflect.TypeOf(float64(0)) + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v7 := args[0] _ = v7 - tmp8 := checkDerefVar(var_glojure_DOT_core_str) - tmp9 := checkDerefVar(var_glojure_DOT_core__PLUS_) - tmp10 := lang.Apply(tmp9, []any{v6, v7}) - tmp11 := lang.Apply(tmp8, []any{"int64: ", tmp10}) - return tmp11 + v8 := args[1] + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_str) + tmp10 := checkDerefVar(var_glojure_DOT_core__PLUS_) + tmp11 := lang.Apply(tmp10, []any{v7, v8}) + tmp12 := lang.Apply(tmp9, []any{"float64: ", tmp11}) + return tmp12 }) - tmp2.AddMethod(tmp4, tmp5) - tmp6 := reflect.TypeOf(float64(0)) + tmp1.AddMethod(tmp5, tmp6) var tmp7 lang.FnFunc tmp7 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 2) @@ -121,27 +139,13 @@ func LoadNS() { v9 := args[1] _ = v9 tmp10 := checkDerefVar(var_glojure_DOT_core_str) - tmp11 := checkDerefVar(var_glojure_DOT_core__PLUS_) - tmp12 := lang.Apply(tmp11, []any{v8, v9}) - tmp13 := lang.Apply(tmp10, []any{"float64: ", tmp12}) - return tmp13 - }) - tmp2.AddMethod(tmp6, tmp7) - var tmp8 lang.FnFunc - tmp8 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 2) - v9 := args[0] - _ = v9 - v10 := args[1] - _ = v10 - tmp11 := checkDerefVar(var_glojure_DOT_core_str) - tmp12 := lang.Apply(tmp11, []any{"default: ", v9, " ", v10}) - return tmp12 + tmp11 := lang.Apply(tmp10, []any{"default: ", v8, " ", v9}) + return tmp11 }) - tmp2.AddMethod(kw_default, tmp8) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1.AddMethod(kw_default, tmp7) + var_codegen_DOT_test_DOT_multifn_add = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_codegen_DOT_test_DOT_multifn_add.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } } diff --git a/pkg/runtime/testdata/codegen/test/ns_skip/load.go.out b/pkg/runtime/testdata/codegen/test/ns_skip/load.go.out index fa21ce77..1a3cc8f4 100644 --- a/pkg/runtime/testdata/codegen/test/ns_skip/load.go.out +++ b/pkg/runtime/testdata/codegen/test/ns_skip/load.go.out @@ -6,10 +6,11 @@ import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" runtime "github.com/glojurelang/glojure/pkg/runtime" + reflect "reflect" ) func init() { - runtime.RegisterNSLoader("codegen.test.ns-skip", LoadNS) + runtime.RegisterNSLoader("codegen/test/ns_skip", LoadNS) } func checkDerefVar(v *lang.Var) any { @@ -30,6 +31,8 @@ func LoadNS() { sym_codegen_DOT_test_DOT_ns_DASH_skip := lang.NewSymbol("codegen.test.ns-skip") // reference fmt to avoid unused import error _ = fmt.Printf + // reference reflect to avoid unused import error + _ = reflect.TypeOf ns := lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_ns_DASH_skip) _ = ns } diff --git a/pkg/runtime/testdata/codegen/test/quote_simple/load.go.out b/pkg/runtime/testdata/codegen/test/quote_simple/load.go.out index 7fb7baa7..8d74972f 100644 --- a/pkg/runtime/testdata/codegen/test/quote_simple/load.go.out +++ b/pkg/runtime/testdata/codegen/test/quote_simple/load.go.out @@ -6,10 +6,11 @@ import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" runtime "github.com/glojurelang/glojure/pkg/runtime" + reflect "reflect" ) func init() { - runtime.RegisterNSLoader("codegen.test.quote-simple", LoadNS) + runtime.RegisterNSLoader("codegen/test/quote_simple", LoadNS) } func checkDerefVar(v *lang.Var) any { @@ -38,22 +39,26 @@ func LoadNS() { kw_line := lang.NewKeyword("line") kw_ns := lang.NewKeyword("ns") kw_rettag := lang.NewKeyword("rettag") + // var codegen.test.quote-simple/-main + var_codegen_DOT_test_DOT_quote_DASH_simple__DASH_main := lang.InternVarName(sym_codegen_DOT_test_DOT_quote_DASH_simple, sym__DASH_main) // reference fmt to avoid unused import error _ = fmt.Printf + // reference reflect to avoid unused import error + _ = reflect.TypeOf ns := lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_quote_DASH_simple) _ = ns // -main { tmp0 := sym__DASH_main.WithMeta(lang.NewMap(kw_expected_DASH_output, lang.NewList(int64(1), int64(2), int64(3)), kw_file, "codegen/test/quote_simple.glj", kw_line, int(3), kw_column, int(7), kw_end_DASH_line, int(3), kw_end_DASH_column, int(44), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_quote_DASH_simple))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 0) return lang.NewList(int64(1), int64(2), int64(3)) }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_codegen_DOT_test_DOT_quote_DASH_simple__DASH_main = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_codegen_DOT_test_DOT_quote_DASH_simple__DASH_main.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } } diff --git a/pkg/runtime/testdata/codegen/test/ref/load.go.out b/pkg/runtime/testdata/codegen/test/ref/load.go.out index d7cae9f4..1a8e8e99 100644 --- a/pkg/runtime/testdata/codegen/test/ref/load.go.out +++ b/pkg/runtime/testdata/codegen/test/ref/load.go.out @@ -6,10 +6,11 @@ import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" runtime "github.com/glojurelang/glojure/pkg/runtime" + reflect "reflect" ) func init() { - runtime.RegisterNSLoader("codegen.test.ref", LoadNS) + runtime.RegisterNSLoader("codegen/test/ref", LoadNS) } func checkDerefVar(v *lang.Var) any { @@ -42,38 +43,42 @@ func LoadNS() { kw_line := lang.NewKeyword("line") kw_ns := lang.NewKeyword("ns") kw_rettag := lang.NewKeyword("rettag") + // var codegen.test.ref/-main + var_codegen_DOT_test_DOT_ref__DASH_main := lang.InternVarName(sym_codegen_DOT_test_DOT_ref, sym__DASH_main) // var codegen.test.ref/test-ref var_codegen_DOT_test_DOT_ref_test_DASH_ref := lang.InternVarName(sym_codegen_DOT_test_DOT_ref, sym_test_DASH_ref) // var glojure.core/deref var_glojure_DOT_core_deref := lang.InternVarName(sym_glojure_DOT_core, sym_deref) // reference fmt to avoid unused import error _ = fmt.Printf + // reference reflect to avoid unused import error + _ = reflect.TypeOf ns := lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_ref) _ = ns - // -main + // test-ref { - tmp0 := sym__DASH_main.WithMeta(lang.NewMap(kw_expected_DASH_output, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2), int64(3)})), kw_file, "codegen/test/ref.glj", kw_line, int(8), kw_column, int(3), kw_end_DASH_line, int(9), kw_end_DASH_column, int(7), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_ref))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - tmp3 := checkDerefVar(var_glojure_DOT_core_deref) - tmp4 := checkDerefVar(var_codegen_DOT_test_DOT_ref_test_DASH_ref) - tmp5 := lang.Apply(tmp3, []any{tmp4}) - return tmp5 - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp0 := sym_test_DASH_ref.WithMeta(lang.NewMap(kw_file, "codegen/test/ref.glj", kw_line, int(3), kw_column, int(6), kw_end_DASH_line, int(3), kw_end_DASH_column, int(13), kw_doc, "A reference to a set.", kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_ref))).(*lang.Symbol) + tmp1 := lang.NewRef(lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2), int64(3)}))) + var_codegen_DOT_test_DOT_ref_test_DASH_ref = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_codegen_DOT_test_DOT_ref_test_DASH_ref.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // test-ref + // -main { - tmp0 := sym_test_DASH_ref.WithMeta(lang.NewMap(kw_file, "codegen/test/ref.glj", kw_line, int(3), kw_column, int(6), kw_end_DASH_line, int(3), kw_end_DASH_column, int(13), kw_doc, "A reference to a set.", kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_ref))).(*lang.Symbol) - tmp2 := lang.NewRef(lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2), int64(3)}))) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp0 := sym__DASH_main.WithMeta(lang.NewMap(kw_expected_DASH_output, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2), int64(3)})), kw_file, "codegen/test/ref.glj", kw_line, int(8), kw_column, int(3), kw_end_DASH_line, int(9), kw_end_DASH_column, int(7), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_ref))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp2 := checkDerefVar(var_glojure_DOT_core_deref) + tmp3 := checkDerefVar(var_codegen_DOT_test_DOT_ref_test_DASH_ref) + tmp4 := lang.Apply(tmp2, []any{tmp3}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_codegen_DOT_test_DOT_ref__DASH_main = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_codegen_DOT_test_DOT_ref__DASH_main.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } } diff --git a/pkg/runtime/testdata/codegen/test/the_var/load.go.out b/pkg/runtime/testdata/codegen/test/the_var/load.go.out index 260b5d56..1cfaf7ac 100644 --- a/pkg/runtime/testdata/codegen/test/the_var/load.go.out +++ b/pkg/runtime/testdata/codegen/test/the_var/load.go.out @@ -10,7 +10,7 @@ import ( ) func init() { - runtime.RegisterNSLoader("codegen.test.the-var", LoadNS) + runtime.RegisterNSLoader("codegen/test/the_var", LoadNS) } func checkDerefVar(v *lang.Var) any { @@ -40,42 +40,48 @@ func LoadNS() { kw_line := lang.NewKeyword("line") kw_ns := lang.NewKeyword("ns") kw_rettag := lang.NewKeyword("rettag") + // var codegen.test.the-var/-main + var_codegen_DOT_test_DOT_the_DASH_var__DASH_main := lang.InternVarName(sym_codegen_DOT_test_DOT_the_DASH_var, sym__DASH_main) + // var codegen.test.the-var/foo + var_codegen_DOT_test_DOT_the_DASH_var_foo := lang.InternVarName(sym_codegen_DOT_test_DOT_the_DASH_var, sym_foo) // reference fmt to avoid unused import error _ = fmt.Printf + // reference reflect to avoid unused import error + _ = reflect.TypeOf ns := lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_the_DASH_var) _ = ns // -main { tmp0 := sym__DASH_main.WithMeta(lang.NewMap(kw_expected_DASH_output, int64(42), kw_file, "codegen/test/the_var.glj", kw_line, int(5), kw_column, int(7), kw_end_DASH_line, int(5), kw_end_DASH_column, int(34), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_the_DASH_var))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 0) - tmp3 := lang.InternVarName(sym_codegen_DOT_test_DOT_the_DASH_var, sym_foo) - tmp4, ok := lang.FieldOrMethod(tmp3, "get") + tmp2 := lang.InternVarName(sym_codegen_DOT_test_DOT_the_DASH_var, sym_foo) + tmp3, ok := lang.FieldOrMethod(tmp2, "get") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp3, "get"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp2, "get"))) } - var tmp5 any - switch reflect.TypeOf(tmp4).Kind() { + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { case reflect.Func: - tmp5 = lang.Apply(tmp4, nil) + tmp4 = lang.Apply(tmp3, nil) default: - tmp5 = tmp4 + tmp4 = tmp3 } - return tmp5 + return tmp4 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_codegen_DOT_test_DOT_the_DASH_var__DASH_main = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_codegen_DOT_test_DOT_the_DASH_var__DASH_main.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // foo { tmp0 := sym_foo.WithMeta(lang.NewMap(kw_file, "codegen/test/the_var.glj", kw_line, int(3), kw_column, int(6), kw_end_DASH_line, int(3), kw_end_DASH_column, int(8), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_the_DASH_var))).(*lang.Symbol) - tmp1 := ns.InternWithValue(tmp0, int64(42), true) + var_codegen_DOT_test_DOT_the_DASH_var_foo = ns.InternWithValue(tmp0, int64(42), true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_codegen_DOT_test_DOT_the_DASH_var_foo.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } } diff --git a/pkg/runtime/testdata/codegen/test/throw_simple/load.go.out b/pkg/runtime/testdata/codegen/test/throw_simple/load.go.out index 49aad441..89f1811a 100644 --- a/pkg/runtime/testdata/codegen/test/throw_simple/load.go.out +++ b/pkg/runtime/testdata/codegen/test/throw_simple/load.go.out @@ -6,10 +6,11 @@ import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" runtime "github.com/glojurelang/glojure/pkg/runtime" + reflect "reflect" ) func init() { - runtime.RegisterNSLoader("codegen.test.throw-simple", LoadNS) + runtime.RegisterNSLoader("codegen/test/throw_simple", LoadNS) } func checkDerefVar(v *lang.Var) any { @@ -38,22 +39,26 @@ func LoadNS() { kw_line := lang.NewKeyword("line") kw_ns := lang.NewKeyword("ns") kw_rettag := lang.NewKeyword("rettag") + // var codegen.test.throw-simple/-main + var_codegen_DOT_test_DOT_throw_DASH_simple__DASH_main := lang.InternVarName(sym_codegen_DOT_test_DOT_throw_DASH_simple, sym__DASH_main) // reference fmt to avoid unused import error _ = fmt.Printf + // reference reflect to avoid unused import error + _ = reflect.TypeOf ns := lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_throw_DASH_simple) _ = ns // -main { tmp0 := sym__DASH_main.WithMeta(lang.NewMap(kw_expected_DASH_throw, "uncaught error", kw_file, "codegen/test/throw_simple.glj", kw_line, int(3), kw_column, int(7), kw_end_DASH_line, int(3), kw_end_DASH_column, int(47), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_throw_DASH_simple))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 0) panic("uncaught error") }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_codegen_DOT_test_DOT_throw_DASH_simple__DASH_main = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_codegen_DOT_test_DOT_throw_DASH_simple__DASH_main.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } } diff --git a/pkg/runtime/testdata/codegen/test/try_advanced/load.go.out b/pkg/runtime/testdata/codegen/test/try_advanced/load.go.out index cd0f9153..a8843df5 100644 --- a/pkg/runtime/testdata/codegen/test/try_advanced/load.go.out +++ b/pkg/runtime/testdata/codegen/test/try_advanced/load.go.out @@ -6,10 +6,11 @@ import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" runtime "github.com/glojurelang/glojure/pkg/runtime" + reflect "reflect" ) func init() { - runtime.RegisterNSLoader("codegen.test.try-advanced", LoadNS) + runtime.RegisterNSLoader("codegen/test/try_advanced", LoadNS) } func checkDerefVar(v *lang.Var) any { @@ -44,6 +45,8 @@ func LoadNS() { kw_line := lang.NewKeyword("line") kw_ns := lang.NewKeyword("ns") kw_rettag := lang.NewKeyword("rettag") + // var codegen.test.try-advanced/-main + var_codegen_DOT_test_DOT_try_DASH_advanced__DASH_main := lang.InternVarName(sym_codegen_DOT_test_DOT_try_DASH_advanced, sym__DASH_main) // var codegen.test.try-advanced/catch-binding-scope var_codegen_DOT_test_DOT_try_DASH_advanced_catch_DASH_binding_DASH_scope := lang.InternVarName(sym_codegen_DOT_test_DOT_try_DASH_advanced, sym_catch_DASH_binding_DASH_scope) // var codegen.test.try-advanced/catch-binding-scope-2 @@ -56,81 +59,29 @@ func LoadNS() { var_glojure_DOT_core__EQ_ := lang.InternVarName(sym_glojure_DOT_core, sym__EQ_) // reference fmt to avoid unused import error _ = fmt.Printf + // reference reflect to avoid unused import error + _ = reflect.TypeOf ns := lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_try_DASH_advanced) _ = ns - // -main - { - tmp0 := sym__DASH_main.WithMeta(lang.NewMap(kw_expected_DASH_output, "advanced tests passed", kw_file, "codegen/test/try_advanced.glj", kw_line, int(30), kw_column, int(7), kw_end_DASH_line, int(30), kw_end_DASH_column, int(55), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_try_DASH_advanced))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - var tmp3 any - tmp4 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp5 := checkDerefVar(var_codegen_DOT_test_DOT_try_DASH_advanced_try_DASH_custom_DASH_value) - tmp6 := lang.Apply(tmp5, nil) - tmp7 := lang.Apply(tmp4, []any{tmp6, "custom error"}) - if lang.IsTruthy(tmp7) { - } else { - panic("try-custom-value failed") - } - _ = tmp3 - var tmp8 any - tmp9 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp10 := checkDerefVar(var_codegen_DOT_test_DOT_try_DASH_advanced_catch_DASH_binding_DASH_scope) - tmp11 := lang.Apply(tmp10, nil) - tmp12 := lang.Apply(tmp9, []any{tmp11, "test"}) - if lang.IsTruthy(tmp12) { - } else { - panic("catch-binding-scope failed") - } - _ = tmp8 - var tmp13 any - tmp14 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp15 := checkDerefVar(var_codegen_DOT_test_DOT_try_DASH_advanced_catch_DASH_binding_DASH_scope_DASH_2) - tmp16 := lang.Apply(tmp15, nil) - tmp17 := lang.Apply(tmp14, []any{tmp16, "outer"}) - if lang.IsTruthy(tmp17) { - } else { - panic("catch-binding-scope-2 failed") - } - _ = tmp13 - var tmp18 any - tmp19 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp20 := checkDerefVar(var_codegen_DOT_test_DOT_try_DASH_advanced_finally_DASH_with_DASH_return) - tmp21 := lang.Apply(tmp20, nil) - tmp22 := lang.Apply(tmp19, []any{tmp21, int64(42)}) - if lang.IsTruthy(tmp22) { - } else { - panic("finally-with-return failed") - } - _ = tmp18 - return "advanced tests passed" - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } // catch-binding-scope { tmp0 := sym_catch_DASH_binding_DASH_scope.WithMeta(lang.NewMap(kw_file, "codegen/test/try_advanced.glj", kw_line, int(9), kw_column, int(7), kw_end_DASH_line, int(9), kw_end_DASH_column, int(25), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_try_DASH_advanced))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 0) - var tmp3 any + var tmp2 any { // let // let binding "e" - var v4 any = "outer" - _ = v4 - var tmp5 any + var v3 any = "outer" + _ = v3 + var tmp4 any func() { defer func() { if r := recover(); r != nil { if lang.CatchMatches(r, lang.Builtins["any"]) { - v6 := r - _ = v6 - tmp5 = v6 + v5 := r + _ = v5 + tmp4 = v5 } else { panic(r) } @@ -138,35 +89,35 @@ func LoadNS() { }() panic("test") }() - tmp3 = tmp5 + tmp2 = tmp4 } // end let - return tmp3 + return tmp2 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_codegen_DOT_test_DOT_try_DASH_advanced_catch_DASH_binding_DASH_scope = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_codegen_DOT_test_DOT_try_DASH_advanced_catch_DASH_binding_DASH_scope.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // catch-binding-scope-2 { tmp0 := sym_catch_DASH_binding_DASH_scope_DASH_2.WithMeta(lang.NewMap(kw_file, "codegen/test/try_advanced.glj", kw_line, int(16), kw_column, int(7), kw_end_DASH_line, int(16), kw_end_DASH_column, int(27), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_try_DASH_advanced))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 0) - var tmp3 any + var tmp2 any { // let // let binding "e" - var v4 any = "outer" - _ = v4 - var tmp5 any + var v3 any = "outer" + _ = v3 + var tmp4 any func() { defer func() { if r := recover(); r != nil { if lang.CatchMatches(r, lang.Builtins["any"]) { - v6 := r - _ = v6 - tmp5 = v6 + v5 := r + _ = v5 + tmp4 = v5 } else { panic(r) } @@ -174,52 +125,52 @@ func LoadNS() { }() panic("test") }() - _ = tmp5 - tmp3 = v4 + _ = tmp4 + tmp2 = v3 } // end let - return tmp3 + return tmp2 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_codegen_DOT_test_DOT_try_DASH_advanced_catch_DASH_binding_DASH_scope_DASH_2 = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_codegen_DOT_test_DOT_try_DASH_advanced_catch_DASH_binding_DASH_scope_DASH_2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // finally-with-return { tmp0 := sym_finally_DASH_with_DASH_return.WithMeta(lang.NewMap(kw_file, "codegen/test/try_advanced.glj", kw_line, int(24), kw_column, int(7), kw_end_DASH_line, int(24), kw_end_DASH_column, int(25), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_try_DASH_advanced))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 0) - var tmp3 any + var tmp2 any func() { defer func() { _ = int64(100) }() - tmp3 = int64(42) + tmp2 = int64(42) }() - return tmp3 + return tmp2 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_codegen_DOT_test_DOT_try_DASH_advanced_finally_DASH_with_DASH_return = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_codegen_DOT_test_DOT_try_DASH_advanced_finally_DASH_with_DASH_return.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // try-custom-value { tmp0 := sym_try_DASH_custom_DASH_value.WithMeta(lang.NewMap(kw_file, "codegen/test/try_advanced.glj", kw_line, int(3), kw_column, int(7), kw_end_DASH_line, int(3), kw_end_DASH_column, int(22), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_try_DASH_advanced))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 0) - var tmp3 any + var tmp2 any func() { defer func() { if r := recover(); r != nil { if lang.CatchMatches(r, lang.Builtins["any"]) { - v4 := r - _ = v4 - tmp3 = v4 + v3 := r + _ = v3 + tmp2 = v3 } else { panic(r) } @@ -227,12 +178,66 @@ func LoadNS() { }() panic("custom error") }() - return tmp3 + return tmp2 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_codegen_DOT_test_DOT_try_DASH_advanced_try_DASH_custom_DASH_value = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_codegen_DOT_test_DOT_try_DASH_advanced_try_DASH_custom_DASH_value.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // -main + { + tmp0 := sym__DASH_main.WithMeta(lang.NewMap(kw_expected_DASH_output, "advanced tests passed", kw_file, "codegen/test/try_advanced.glj", kw_line, int(30), kw_column, int(7), kw_end_DASH_line, int(30), kw_end_DASH_column, int(55), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_try_DASH_advanced))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp2 any + tmp3 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp4 := checkDerefVar(var_codegen_DOT_test_DOT_try_DASH_advanced_try_DASH_custom_DASH_value) + tmp5 := lang.Apply(tmp4, nil) + tmp6 := lang.Apply(tmp3, []any{tmp5, "custom error"}) + if lang.IsTruthy(tmp6) { + } else { + panic("try-custom-value failed") + } + _ = tmp2 + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp9 := checkDerefVar(var_codegen_DOT_test_DOT_try_DASH_advanced_catch_DASH_binding_DASH_scope) + tmp10 := lang.Apply(tmp9, nil) + tmp11 := lang.Apply(tmp8, []any{tmp10, "test"}) + if lang.IsTruthy(tmp11) { + } else { + panic("catch-binding-scope failed") + } + _ = tmp7 + var tmp12 any + tmp13 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp14 := checkDerefVar(var_codegen_DOT_test_DOT_try_DASH_advanced_catch_DASH_binding_DASH_scope_DASH_2) + tmp15 := lang.Apply(tmp14, nil) + tmp16 := lang.Apply(tmp13, []any{tmp15, "outer"}) + if lang.IsTruthy(tmp16) { + } else { + panic("catch-binding-scope-2 failed") + } + _ = tmp12 + var tmp17 any + tmp18 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp19 := checkDerefVar(var_codegen_DOT_test_DOT_try_DASH_advanced_finally_DASH_with_DASH_return) + tmp20 := lang.Apply(tmp19, nil) + tmp21 := lang.Apply(tmp18, []any{tmp20, int64(42)}) + if lang.IsTruthy(tmp21) { + } else { + panic("finally-with-return failed") + } + _ = tmp17 + return "advanced tests passed" }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_codegen_DOT_test_DOT_try_DASH_advanced__DASH_main = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_codegen_DOT_test_DOT_try_DASH_advanced__DASH_main.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } } diff --git a/pkg/runtime/testdata/codegen/test/try_basic/load.go.out b/pkg/runtime/testdata/codegen/test/try_basic/load.go.out index 90f3c141..9fe7d228 100644 --- a/pkg/runtime/testdata/codegen/test/try_basic/load.go.out +++ b/pkg/runtime/testdata/codegen/test/try_basic/load.go.out @@ -6,10 +6,11 @@ import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" runtime "github.com/glojurelang/glojure/pkg/runtime" + reflect "reflect" ) func init() { - runtime.RegisterNSLoader("codegen.test.try-basic", LoadNS) + runtime.RegisterNSLoader("codegen/test/try_basic", LoadNS) } func checkDerefVar(v *lang.Var) any { @@ -46,6 +47,8 @@ func LoadNS() { kw_line := lang.NewKeyword("line") kw_ns := lang.NewKeyword("ns") kw_rettag := lang.NewKeyword("rettag") + // var codegen.test.try-basic/-main + var_codegen_DOT_test_DOT_try_DASH_basic__DASH_main := lang.InternVarName(sym_codegen_DOT_test_DOT_try_DASH_basic, sym__DASH_main) // var codegen.test.try-basic/basic-try var_codegen_DOT_test_DOT_try_DASH_basic_basic_DASH_try := lang.InternVarName(sym_codegen_DOT_test_DOT_try_DASH_basic, sym_basic_DASH_try) // var codegen.test.try-basic/nested-try @@ -62,138 +65,66 @@ func LoadNS() { var_glojure_DOT_core__EQ_ := lang.InternVarName(sym_glojure_DOT_core, sym__EQ_) // reference fmt to avoid unused import error _ = fmt.Printf + // reference reflect to avoid unused import error + _ = reflect.TypeOf ns := lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_try_DASH_basic) _ = ns - // -main - { - tmp0 := sym__DASH_main.WithMeta(lang.NewMap(kw_expected_DASH_output, "all tests passed", kw_file, "codegen/test/try_basic.glj", kw_line, int(43), kw_column, int(7), kw_end_DASH_line, int(43), kw_end_DASH_column, int(50), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_try_DASH_basic))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - var tmp3 any - tmp4 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp5 := checkDerefVar(var_codegen_DOT_test_DOT_try_DASH_basic_basic_DASH_try) - tmp6 := lang.Apply(tmp5, nil) - tmp7 := lang.Apply(tmp4, []any{tmp6, "success"}) - if lang.IsTruthy(tmp7) { - } else { - panic("basic-try failed") - } - _ = tmp3 - var tmp8 any - tmp9 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp10 := checkDerefVar(var_codegen_DOT_test_DOT_try_DASH_basic_try_DASH_with_DASH_throw) - tmp11 := lang.Apply(tmp10, nil) - tmp12 := lang.Apply(tmp9, []any{tmp11, "caught exception"}) - if lang.IsTruthy(tmp12) { - } else { - panic("try-with-throw failed") - } - _ = tmp8 - var tmp13 any - tmp14 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp15 := checkDerefVar(var_codegen_DOT_test_DOT_try_DASH_basic_try_DASH_no_DASH_catch) - tmp16 := lang.Apply(tmp15, nil) - tmp17 := lang.Apply(tmp14, []any{tmp16, "just body"}) - if lang.IsTruthy(tmp17) { - } else { - panic("try-no-catch failed") - } - _ = tmp13 - var tmp18 any - tmp19 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp20 := checkDerefVar(var_codegen_DOT_test_DOT_try_DASH_basic_try_DASH_finally_DASH_only) - tmp21 := lang.Apply(tmp20, nil) - tmp22 := lang.Apply(tmp19, []any{tmp21, "body"}) - if lang.IsTruthy(tmp22) { - } else { - panic("try-finally-only failed") - } - _ = tmp18 - var tmp23 any - tmp24 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp25 := checkDerefVar(var_codegen_DOT_test_DOT_try_DASH_basic_try_DASH_catch_DASH_finally) - tmp26 := lang.Apply(tmp25, nil) - tmp27 := lang.Apply(tmp24, []any{tmp26, "caught"}) - if lang.IsTruthy(tmp27) { - } else { - panic("try-catch-finally failed") - } - _ = tmp23 - var tmp28 any - tmp29 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp30 := checkDerefVar(var_codegen_DOT_test_DOT_try_DASH_basic_nested_DASH_try) - tmp31 := lang.Apply(tmp30, nil) - tmp32 := lang.Apply(tmp29, []any{tmp31, "inner caught"}) - if lang.IsTruthy(tmp32) { - } else { - panic("nested-try failed") - } - _ = tmp28 - return "all tests passed" - }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } // basic-try { tmp0 := sym_basic_DASH_try.WithMeta(lang.NewMap(kw_file, "codegen/test/try_basic.glj", kw_line, int(3), kw_column, int(7), kw_end_DASH_line, int(3), kw_end_DASH_column, int(15), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_try_DASH_basic))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 0) - var tmp3 any + var tmp2 any func() { defer func() { if r := recover(); r != nil { if lang.CatchMatches(r, lang.Builtins["any"]) { - v4 := r - _ = v4 - tmp3 = "caught" + v3 := r + _ = v3 + tmp2 = "caught" } else { panic(r) } } }() - tmp3 = "success" + tmp2 = "success" }() - return tmp3 + return tmp2 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_codegen_DOT_test_DOT_try_DASH_basic_basic_DASH_try = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_codegen_DOT_test_DOT_try_DASH_basic_basic_DASH_try.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // nested-try { tmp0 := sym_nested_DASH_try.WithMeta(lang.NewMap(kw_file, "codegen/test/try_basic.glj", kw_line, int(34), kw_column, int(7), kw_end_DASH_line, int(34), kw_end_DASH_column, int(16), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_try_DASH_basic))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 0) - var tmp3 any + var tmp2 any func() { defer func() { if r := recover(); r != nil { if lang.CatchMatches(r, lang.Builtins["any"]) { - v4 := r - _ = v4 - tmp3 = "outer caught" + v3 := r + _ = v3 + tmp2 = "outer caught" } else { panic(r) } } }() - var tmp4 any + var tmp3 any func() { defer func() { if r := recover(); r != nil { if lang.CatchMatches(r, lang.Builtins["any"]) { - v5 := r - _ = v5 - tmp4 = "inner caught" + v4 := r + _ = v4 + tmp3 = "inner caught" } else { panic(r) } @@ -201,32 +132,32 @@ func LoadNS() { }() panic("inner") }() - tmp3 = tmp4 + tmp2 = tmp3 }() - return tmp3 + return tmp2 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_codegen_DOT_test_DOT_try_DASH_basic_nested_DASH_try = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_codegen_DOT_test_DOT_try_DASH_basic_nested_DASH_try.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // try-catch-finally { tmp0 := sym_try_DASH_catch_DASH_finally.WithMeta(lang.NewMap(kw_file, "codegen/test/try_basic.glj", kw_line, int(26), kw_column, int(7), kw_end_DASH_line, int(26), kw_end_DASH_column, int(23), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_try_DASH_basic))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 0) - var tmp3 any + var tmp2 any func() { defer func() { }() defer func() { if r := recover(); r != nil { if lang.CatchMatches(r, lang.Builtins["any"]) { - v4 := r - _ = v4 - tmp3 = "caught" + v3 := r + _ = v3 + tmp2 = "caught" } else { panic(r) } @@ -234,80 +165,154 @@ func LoadNS() { }() panic("error") }() - return tmp3 + return tmp2 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_codegen_DOT_test_DOT_try_DASH_basic_try_DASH_catch_DASH_finally = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_codegen_DOT_test_DOT_try_DASH_basic_try_DASH_catch_DASH_finally.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // try-finally-only { tmp0 := sym_try_DASH_finally_DASH_only.WithMeta(lang.NewMap(kw_file, "codegen/test/try_basic.glj", kw_line, int(20), kw_column, int(7), kw_end_DASH_line, int(20), kw_end_DASH_column, int(22), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_try_DASH_basic))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 0) - var tmp3 any + var tmp2 any func() { defer func() { }() - tmp3 = "body" + tmp2 = "body" }() - return tmp3 + return tmp2 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_codegen_DOT_test_DOT_try_DASH_basic_try_DASH_finally_DASH_only = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_codegen_DOT_test_DOT_try_DASH_basic_try_DASH_finally_DASH_only.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // try-no-catch { tmp0 := sym_try_DASH_no_DASH_catch.WithMeta(lang.NewMap(kw_file, "codegen/test/try_basic.glj", kw_line, int(16), kw_column, int(7), kw_end_DASH_line, int(16), kw_end_DASH_column, int(18), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_try_DASH_basic))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 0) - var tmp3 any + var tmp2 any func() { - tmp3 = "just body" + tmp2 = "just body" }() - return tmp3 + return tmp2 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_codegen_DOT_test_DOT_try_DASH_basic_try_DASH_no_DASH_catch = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_codegen_DOT_test_DOT_try_DASH_basic_try_DASH_no_DASH_catch.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } // try-with-throw { tmp0 := sym_try_DASH_with_DASH_throw.WithMeta(lang.NewMap(kw_file, "codegen/test/try_basic.glj", kw_line, int(9), kw_column, int(7), kw_end_DASH_line, int(9), kw_end_DASH_column, int(20), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_try_DASH_basic))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 0) - var tmp3 any + var tmp2 any func() { defer func() { if r := recover(); r != nil { if lang.CatchMatches(r, lang.Builtins["any"]) { - v4 := r - _ = v4 - tmp3 = "caught exception" + v3 := r + _ = v3 + tmp2 = "caught exception" } else { panic(r) } } }() panic("test error") - tmp3 = "not reached" + tmp2 = "not reached" }() - return tmp3 + return tmp2 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_codegen_DOT_test_DOT_try_DASH_basic_try_DASH_with_DASH_throw = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_codegen_DOT_test_DOT_try_DASH_basic_try_DASH_with_DASH_throw.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // -main + { + tmp0 := sym__DASH_main.WithMeta(lang.NewMap(kw_expected_DASH_output, "all tests passed", kw_file, "codegen/test/try_basic.glj", kw_line, int(43), kw_column, int(7), kw_end_DASH_line, int(43), kw_end_DASH_column, int(50), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_try_DASH_basic))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp2 any + tmp3 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp4 := checkDerefVar(var_codegen_DOT_test_DOT_try_DASH_basic_basic_DASH_try) + tmp5 := lang.Apply(tmp4, nil) + tmp6 := lang.Apply(tmp3, []any{tmp5, "success"}) + if lang.IsTruthy(tmp6) { + } else { + panic("basic-try failed") + } + _ = tmp2 + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp9 := checkDerefVar(var_codegen_DOT_test_DOT_try_DASH_basic_try_DASH_with_DASH_throw) + tmp10 := lang.Apply(tmp9, nil) + tmp11 := lang.Apply(tmp8, []any{tmp10, "caught exception"}) + if lang.IsTruthy(tmp11) { + } else { + panic("try-with-throw failed") + } + _ = tmp7 + var tmp12 any + tmp13 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp14 := checkDerefVar(var_codegen_DOT_test_DOT_try_DASH_basic_try_DASH_no_DASH_catch) + tmp15 := lang.Apply(tmp14, nil) + tmp16 := lang.Apply(tmp13, []any{tmp15, "just body"}) + if lang.IsTruthy(tmp16) { + } else { + panic("try-no-catch failed") + } + _ = tmp12 + var tmp17 any + tmp18 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp19 := checkDerefVar(var_codegen_DOT_test_DOT_try_DASH_basic_try_DASH_finally_DASH_only) + tmp20 := lang.Apply(tmp19, nil) + tmp21 := lang.Apply(tmp18, []any{tmp20, "body"}) + if lang.IsTruthy(tmp21) { + } else { + panic("try-finally-only failed") + } + _ = tmp17 + var tmp22 any + tmp23 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp24 := checkDerefVar(var_codegen_DOT_test_DOT_try_DASH_basic_try_DASH_catch_DASH_finally) + tmp25 := lang.Apply(tmp24, nil) + tmp26 := lang.Apply(tmp23, []any{tmp25, "caught"}) + if lang.IsTruthy(tmp26) { + } else { + panic("try-catch-finally failed") + } + _ = tmp22 + var tmp27 any + tmp28 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp29 := checkDerefVar(var_codegen_DOT_test_DOT_try_DASH_basic_nested_DASH_try) + tmp30 := lang.Apply(tmp29, nil) + tmp31 := lang.Apply(tmp28, []any{tmp30, "inner caught"}) + if lang.IsTruthy(tmp31) { + } else { + panic("nested-try failed") + } + _ = tmp27 + return "all tests passed" }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_codegen_DOT_test_DOT_try_DASH_basic__DASH_main = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_codegen_DOT_test_DOT_try_DASH_basic__DASH_main.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } } diff --git a/pkg/runtime/testdata/codegen/test/values/load.go.out b/pkg/runtime/testdata/codegen/test/values/load.go.out index fdc1acff..d2f460e7 100644 --- a/pkg/runtime/testdata/codegen/test/values/load.go.out +++ b/pkg/runtime/testdata/codegen/test/values/load.go.out @@ -3,16 +3,16 @@ package values import ( - hex3 "encoding/hex" + hex4 "encoding/hex" fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" runtime "github.com/glojurelang/glojure/pkg/runtime" - big4 "math/big" + big5 "math/big" reflect "reflect" ) func init() { - runtime.RegisterNSLoader("codegen.test.values", LoadNS) + runtime.RegisterNSLoader("codegen/test/values", LoadNS) } func checkDerefVar(v *lang.Var) any { @@ -43,68 +43,72 @@ func LoadNS() { kw_line := lang.NewKeyword("line") kw_ns := lang.NewKeyword("ns") kw_rettag := lang.NewKeyword("rettag") + // var codegen.test.values/-main + var_codegen_DOT_test_DOT_values__DASH_main := lang.InternVarName(sym_codegen_DOT_test_DOT_values, sym__DASH_main) // var codegen.test.values/big-decimal var_codegen_DOT_test_DOT_values_big_DASH_decimal := lang.InternVarName(sym_codegen_DOT_test_DOT_values, sym_big_DASH_decimal) // var codegen.test.values/big-decimal-type var_codegen_DOT_test_DOT_values_big_DASH_decimal_DASH_type := lang.InternVarName(sym_codegen_DOT_test_DOT_values, sym_big_DASH_decimal_DASH_type) // reference fmt to avoid unused import error _ = fmt.Printf + // reference reflect to avoid unused import error + _ = reflect.TypeOf ns := lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_values) _ = ns - // -main + // big-decimal { - tmp1 := lang.NewBigDecimalFromBigFloat((func() *big4.Float { - var z big4.Float - b, _ := hex3.DecodeString("010a0000004000000004a000000000000000") + tmp0 := sym_big_DASH_decimal.WithMeta(lang.NewMap(kw_file, "codegen/test/values.glj", kw_line, int(3), kw_column, int(6), kw_end_DASH_line, int(3), kw_end_DASH_column, int(16), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_values))).(*lang.Symbol) + tmp1 := lang.NewBigDecimalFromBigFloat((func() *big5.Float { + var z big5.Float + b, _ := hex4.DecodeString("010a0000004000000004a000000000000000") if err := z.GobDecode(b); err != nil { panic(err) } return &z })()) - tmp2 := reflect.TypeOf((*lang.BigDecimal)(nil)) - tmp0 := sym__DASH_main.WithMeta(lang.NewMap(kw_expected_DASH_output, lang.NewVector(tmp1, tmp2), kw_file, "codegen/test/values.glj", kw_line, int(6), kw_column, int(7), kw_end_DASH_line, int(6), kw_end_DASH_column, int(56), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_values))).(*lang.Symbol) - var tmp4 lang.FnFunc - tmp4 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 0) - tmp5 := checkDerefVar(var_codegen_DOT_test_DOT_values_big_DASH_decimal) - tmp6 := checkDerefVar(var_codegen_DOT_test_DOT_values_big_DASH_decimal_DASH_type) - tmp7 := lang.NewVector(tmp5, tmp6) - tmp8 := lang.NewMap(kw_file, "codegen/test/values.glj", kw_line, int(7), kw_column, int(3), kw_end_DASH_line, int(7), kw_end_DASH_column, int(32)) - tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp9 - }) - tmp4 = tmp4.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp3 := ns.InternWithValue(tmp0, tmp4, true) + var_codegen_DOT_test_DOT_values_big_DASH_decimal = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_codegen_DOT_test_DOT_values_big_DASH_decimal.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // big-decimal + // big-decimal-type { - tmp0 := sym_big_DASH_decimal.WithMeta(lang.NewMap(kw_file, "codegen/test/values.glj", kw_line, int(3), kw_column, int(6), kw_end_DASH_line, int(3), kw_end_DASH_column, int(16), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_values))).(*lang.Symbol) - tmp2 := lang.NewBigDecimalFromBigFloat((func() *big4.Float { - var z big4.Float - b, _ := hex3.DecodeString("010a0000004000000004a000000000000000") + tmp0 := sym_big_DASH_decimal_DASH_type.WithMeta(lang.NewMap(kw_file, "codegen/test/values.glj", kw_line, int(4), kw_column, int(6), kw_end_DASH_line, int(4), kw_end_DASH_column, int(21), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_values))).(*lang.Symbol) + tmp1 := reflect.TypeOf((*lang.BigDecimal)(nil)) + var_codegen_DOT_test_DOT_values_big_DASH_decimal_DASH_type = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_codegen_DOT_test_DOT_values_big_DASH_decimal_DASH_type.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // -main + { + tmp1 := lang.NewBigDecimalFromBigFloat((func() *big5.Float { + var z big5.Float + b, _ := hex4.DecodeString("010a0000004000000004a000000000000000") if err := z.GobDecode(b); err != nil { panic(err) } return &z })()) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) - if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // big-decimal-type - { - tmp0 := sym_big_DASH_decimal_DASH_type.WithMeta(lang.NewMap(kw_file, "codegen/test/values.glj", kw_line, int(4), kw_column, int(6), kw_end_DASH_line, int(4), kw_end_DASH_column, int(21), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_values))).(*lang.Symbol) tmp2 := reflect.TypeOf((*lang.BigDecimal)(nil)) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp0 := sym__DASH_main.WithMeta(lang.NewMap(kw_expected_DASH_output, lang.NewVector(tmp1, tmp2), kw_file, "codegen/test/values.glj", kw_line, int(6), kw_column, int(7), kw_end_DASH_line, int(6), kw_end_DASH_column, int(56), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_values))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp4 := checkDerefVar(var_codegen_DOT_test_DOT_values_big_DASH_decimal) + tmp5 := checkDerefVar(var_codegen_DOT_test_DOT_values_big_DASH_decimal_DASH_type) + tmp6 := lang.NewVector(tmp4, tmp5) + tmp7 := lang.NewMap(kw_file, "codegen/test/values.glj", kw_line, int(7), kw_column, int(3), kw_end_DASH_line, int(7), kw_end_DASH_column, int(32)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp8 + }) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_codegen_DOT_test_DOT_values__DASH_main = ns.InternWithValue(tmp0, tmp3, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_codegen_DOT_test_DOT_values__DASH_main.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } } diff --git a/pkg/runtime/testdata/codegen/test/with_meta/load.go.out b/pkg/runtime/testdata/codegen/test/with_meta/load.go.out index 09deacdc..49d92d10 100644 --- a/pkg/runtime/testdata/codegen/test/with_meta/load.go.out +++ b/pkg/runtime/testdata/codegen/test/with_meta/load.go.out @@ -6,10 +6,11 @@ import ( fmt "fmt" lang "github.com/glojurelang/glojure/pkg/lang" runtime "github.com/glojurelang/glojure/pkg/runtime" + reflect "reflect" ) func init() { - runtime.RegisterNSLoader("codegen.test.with-meta", LoadNS) + runtime.RegisterNSLoader("codegen/test/with_meta", LoadNS) } func checkDerefVar(v *lang.Var) any { @@ -42,38 +43,42 @@ func LoadNS() { kw_line := lang.NewKeyword("line") kw_ns := lang.NewKeyword("ns") kw_rettag := lang.NewKeyword("rettag") + // var codegen.test.with-meta/-main + var_codegen_DOT_test_DOT_with_DASH_meta__DASH_main := lang.InternVarName(sym_codegen_DOT_test_DOT_with_DASH_meta, sym__DASH_main) // var glojure.core/meta var_glojure_DOT_core_meta := lang.InternVarName(sym_glojure_DOT_core, sym_meta) // reference fmt to avoid unused import error _ = fmt.Printf + // reference reflect to avoid unused import error + _ = reflect.TypeOf ns := lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_with_DASH_meta) _ = ns // -main { tmp0 := sym__DASH_main.WithMeta(lang.NewMap(kw_expected_DASH_output, kw_bar, kw_file, "codegen/test/with_meta.glj", kw_line, int(3), kw_column, int(7), kw_end_DASH_line, int(3), kw_end_DASH_column, int(36), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_with_DASH_meta))).(*lang.Symbol) - var tmp2 lang.FnFunc - tmp2 = lang.NewFnFunc(func(args ...any) any { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 0) - tmp3 := checkDerefVar(var_glojure_DOT_core_meta) - tmp4 := lang.NewVector() - tmp5 := lang.NewMap(kw_foo, kw_bar, kw_file, "codegen/test/with_meta.glj", kw_line, int(4), kw_column, int(15), kw_end_DASH_line, int(4), kw_end_DASH_column, int(28)) - tmp6 := lang.NewMap(kw_file, "codegen/test/with_meta.glj", kw_line, int(4), kw_column, int(16), kw_end_DASH_line, int(4), kw_end_DASH_column, int(26)) - tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + tmp2 := checkDerefVar(var_glojure_DOT_core_meta) + tmp3 := lang.NewVector() + tmp4 := lang.NewMap(kw_foo, kw_bar, kw_file, "codegen/test/with_meta.glj", kw_line, int(4), kw_column, int(15), kw_end_DASH_line, int(4), kw_end_DASH_column, int(28)) + tmp5 := lang.NewMap(kw_file, "codegen/test/with_meta.glj", kw_line, int(4), kw_column, int(16), kw_end_DASH_line, int(4), kw_end_DASH_column, int(26)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp8, err := lang.WithMeta(tmp4, tmp7.(lang.IPersistentMap)) + tmp7, err := lang.WithMeta(tmp3, tmp6.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp9 := lang.Apply(tmp3, []any{tmp8}) - tmp10 := lang.Apply(kw_foo, []any{tmp9}) - return tmp10 + tmp8 := lang.Apply(tmp2, []any{tmp7}) + tmp9 := lang.Apply(kw_foo, []any{tmp8}) + return tmp9 }) - tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - tmp1 := ns.InternWithValue(tmp0, tmp2, true) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_codegen_DOT_test_DOT_with_DASH_meta__DASH_main = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - tmp1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_codegen_DOT_test_DOT_with_DASH_meta__DASH_main.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } } diff --git a/pkg/stdlib/glojure/core/async/loader.go b/pkg/stdlib/glojure/core/async/loader.go new file mode 100644 index 00000000..c8ecc31f --- /dev/null +++ b/pkg/stdlib/glojure/core/async/loader.go @@ -0,0 +1,2053 @@ +// Code generated by glojure codegen. DO NOT EDIT. + +package async + +import ( + fmt "fmt" + lang "github.com/glojurelang/glojure/pkg/lang" + runtime "github.com/glojurelang/glojure/pkg/runtime" + reflect "reflect" + time4 "time" +) + +func init() { + runtime.RegisterNSLoader("glojure/core/async", LoadNS) +} + +func checkDerefVar(v *lang.Var) any { + if v.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) + } + return v.Get() +} + +func checkArity(args []any, expected int) { + if len(args) != expected { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + +// LoadNS initializes the namespace "glojure.core.async" +func LoadNS() { + sym__AMP_ := lang.NewSymbol("&") + sym__STAR_ := lang.NewSymbol("*") + sym__LT__BANG_ := lang.NewSymbol("!") + sym__GT__BANG__BANG_ := lang.NewSymbol(">!!") + sym_alt_BANG_ := lang.NewSymbol("alt!") + sym_alt_BANG__BANG_ := lang.NewSymbol("alt!!") + sym_alts := lang.NewSymbol("alts") + sym_alts_BANG_ := lang.NewSymbol("alts!") + sym_alts_BANG__BANG_ := lang.NewSymbol("alts!!") + sym_apply := lang.NewSymbol("apply") + sym_args := lang.NewSymbol("args") + sym_bindings := lang.NewSymbol("bindings") + sym_body := lang.NewSymbol("body") + sym_buf_DASH_or_DASH_n := lang.NewSymbol("buf-or-n") + sym_c__0__auto__ := lang.NewSymbol("c__0__auto__") + sym_chan := lang.NewSymbol("chan") + sym_check_DASH_unique_DASH_ports_BANG_ := lang.NewSymbol("check-unique-ports!") + sym_clauses := lang.NewSymbol("clauses") + sym_close_BANG_ := lang.NewSymbol("close!") + sym_close_QMARK_ := lang.NewSymbol("close?") + sym_concat := lang.NewSymbol("concat") + sym_conj := lang.NewSymbol("conj") + sym_contains_QMARK_ := lang.NewSymbol("contains?") + sym_count := lang.NewSymbol("count") + sym_default_DASH_case := lang.NewSymbol("default-case") + sym_do := lang.NewSymbol("do") + sym_do_DASH_alt := lang.NewSymbol("do-alt") + sym_do_DASH_alts := lang.NewSymbol("do-alts") + sym_ex_DASH_handler := lang.NewSymbol("ex-handler") + sym_f__1__auto__ := lang.NewSymbol("f__1__auto__") + sym_filter := lang.NewSymbol("filter") + sym_first := lang.NewSymbol("first") + sym_from := lang.NewSymbol("from") + sym_gensym := lang.NewSymbol("gensym") + sym_get := lang.NewSymbol("get") + sym_glojure_DOT_core := lang.NewSymbol("glojure.core") + sym_glojure_DOT_core_DOT_async := lang.NewSymbol("glojure.core.async") + sym_glojure_DOT_core_DOT_async_SLASH__GT__BANG_ := lang.NewSymbol("glojure.core.async/>!") + sym_glojure_DOT_core_DOT_async_SLASH_alt_BANG_ := lang.NewSymbol("glojure.core.async/alt!") + sym_glojure_DOT_core_DOT_async_SLASH_alts_BANG_ := lang.NewSymbol("glojure.core.async/alts!") + sym_glojure_DOT_core_DOT_async_SLASH_chan := lang.NewSymbol("glojure.core.async/chan") + sym_glojure_DOT_core_DOT_async_SLASH_go := lang.NewSymbol("glojure.core.async/go") + sym_glojure_DOT_core_SLASH__EQ_ := lang.NewSymbol("glojure.core/=") + sym_glojure_DOT_core_SLASH_cond := lang.NewSymbol("glojure.core/cond") + sym_glojure_DOT_core_SLASH_fn := lang.NewSymbol("glojure.core/fn") + sym_glojure_DOT_core_SLASH_let := lang.NewSymbol("glojure.core/let") + sym_glojure_DOT_core_SLASH_loop := lang.NewSymbol("glojure.core/loop") + sym_glojure_DOT_core_SLASH_or := lang.NewSymbol("glojure.core/or") + sym_go := lang.NewSymbol("go") + sym_go_DASH_loop := lang.NewSymbol("go-loop") + sym_go_SLASH__LT__DASH_chan_DASH_of := lang.NewSymbol("go/<-chan-of") + sym_go_SLASH_any := lang.NewSymbol("go/any") + sym_go_SLASH_go := lang.NewSymbol("go/go") + sym_identity := lang.NewSymbol("identity") + sym_keyword_QMARK_ := lang.NewSymbol("keyword?") + sym_list := lang.NewSymbol("list") + sym_map := lang.NewSymbol("map") + sym_mapcat := lang.NewSymbol("mapcat") + sym_msecs := lang.NewSymbol("msecs") + sym_next := lang.NewSymbol("next") + sym_nil_QMARK_ := lang.NewSymbol("nil?") + sym_not_EQ_ := lang.NewSymbol("not=") + sym_nth := lang.NewSymbol("nth") + sym_offer_BANG_ := lang.NewSymbol("offer!") + sym_opts := lang.NewSymbol("opts") + sym_partition := lang.NewSymbol("partition") + sym_pipe := lang.NewSymbol("pipe") + sym_poll_BANG_ := lang.NewSymbol("poll!") + sym_port := lang.NewSymbol("port") + sym_port_DASH_case := lang.NewSymbol("port-case") + sym_port_DASH_or_DASH_put := lang.NewSymbol("port-or-put") + sym_ports := lang.NewSymbol("ports") + sym_reduce := lang.NewSymbol("reduce") + sym_remove := lang.NewSymbol("remove") + sym_res__2__auto__ := lang.NewSymbol("res__2__auto__") + sym_rest := lang.NewSymbol("rest") + sym_seq := lang.NewSymbol("seq") + sym_seq_QMARK_ := lang.NewSymbol("seq?") + sym_set := lang.NewSymbol("set") + sym_timeout := lang.NewSymbol("timeout") + sym_to := lang.NewSymbol("to") + sym_to_DASH_array := lang.NewSymbol("to-array") + sym_try_DASH_put := lang.NewSymbol("try-put") + sym_try_DASH_take := lang.NewSymbol("try-take") + sym_val := lang.NewSymbol("val") + sym_val__0__auto__ := lang.NewSymbol("val__0__auto__") + sym_vec := lang.NewSymbol("vec") + sym_vector := lang.NewSymbol("vector") + sym_vector_QMARK_ := lang.NewSymbol("vector?") + sym_xform := lang.NewSymbol("xform") + kw_arglists := lang.NewKeyword("arglists") + kw_as := lang.NewKeyword("as") + kw_column := lang.NewKeyword("column") + kw_default := lang.NewKeyword("default") + kw_doc := lang.NewKeyword("doc") + kw_else := lang.NewKeyword("else") + kw_end_DASH_column := lang.NewKeyword("end-column") + kw_end_DASH_line := lang.NewKeyword("end-line") + kw_file := lang.NewKeyword("file") + kw_line := lang.NewKeyword("line") + kw_macro := lang.NewKeyword("macro") + kw_ns := lang.NewKeyword("ns") + kw_priority := lang.NewKeyword("priority") + kw_private := lang.NewKeyword("private") + kw_rettag := lang.NewKeyword("rettag") + // var glojure.core.async/>! + var_glojure_DOT_core_DOT_async__GT__BANG_ := lang.InternVarName(sym_glojure_DOT_core_DOT_async, sym__GT__BANG_) + // var glojure.core.async/>!! + var_glojure_DOT_core_DOT_async__GT__BANG__BANG_ := lang.InternVarName(sym_glojure_DOT_core_DOT_async, sym__GT__BANG__BANG_) + // var glojure.core.async/! + { + tmp0 := sym__GT__BANG_.WithMeta(lang.NewMap(kw_file, "glojure/core/async.glj", kw_line, int(44), kw_column, int(7), kw_end_DASH_line, int(44), kw_end_DASH_column, int(8), kw_arglists, lang.NewList(lang.NewVector(sym_port, sym_val)), kw_doc, "puts a val into port. nil values are not allowed. Will park if no buffer space is available.\n Returns true, or throws if port is already closed.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core_DOT_async))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := lang.Apply(lang.Builtins["send"], []any{v2, v3}) + _ = tmp4 + return true + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_DOT_async__GT__BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_DOT_async__GT__BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // >!! + { + tmp0 := sym__GT__BANG__BANG_.WithMeta(lang.NewMap(kw_file, "glojure/core/async.glj", kw_line, int(51), kw_column, int(6), kw_end_DASH_line, int(51), kw_end_DASH_column, int(8), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core_DOT_async))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := lang.Apply(lang.Builtins["send"], []any{v2, v3}) + _ = tmp4 + return true + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_DOT_async__GT__BANG__BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_DOT_async__GT__BANG__BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // chan + { + tmp0 := sym_chan.WithMeta(lang.NewMap(kw_file, "glojure/core/async.glj", kw_line, int(18), kw_column, int(7), kw_end_DASH_line, int(18), kw_end_DASH_column, int(10), kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_buf_DASH_or_DASH_n), lang.NewVector(sym_buf_DASH_or_DASH_n, sym_xform), lang.NewVector(sym_buf_DASH_or_DASH_n, sym_xform, sym_ex_DASH_handler)), kw_doc, "Creates a channel with an optional buffer, an optional transducer\n (like (map f), (filter p) etc or a composition thereof), and an\n optional exception-handler. If buf-or-n is a number, will create\n and use a fixed buffer of that size. If a transducer is supplied a\n buffer must be specified. ex-handler must be a fn of one argument -\n if an exception occurs during transformation it will be called with\n the Throwable as an argument, and any non-nil return value will be\n placed in the channel.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core_DOT_async))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp2 := checkDerefVar(var_glojure_DOT_core_DOT_async_chan) + tmp3 := lang.Apply(tmp2, []any{nil}) + return tmp3 + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_DOT_async_chan) + tmp4 := lang.Apply(tmp3, []any{v2, nil}) + return tmp4 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_DOT_async_chan) + tmp5 := lang.Apply(tmp4, []any{v2, v3, nil}) + return tmp5 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + if lang.IsTruthy(v3) { + } else { + } + _ = tmp5 + var tmp6 any + if lang.IsTruthy(v3) { + tmp7 := lang.Apply(fmt.Errorf, []any{"xform and ex-handler not yet supported"}) + panic(tmp7) + } else { + } + _ = tmp6 + tmp8 := lang.Apply(lang.Builtins["chan-of"], []any{lang.Builtins["any"]}) + var tmp9 any + { // let + // let binding "or__0__auto__" + var v10 any = v2 + _ = v10 + var tmp11 any + if lang.IsTruthy(v10) { + tmp11 = v10 + } else { + tmp11 = int64(0) + } + tmp9 = tmp11 + } // end let + tmp10 := lang.Apply(lang.Builtins["make"], []any{tmp8, tmp9}) + return tmp10 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_DOT_async_chan = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_DOT_async_chan.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // close! + { + tmp0 := sym_close_BANG_.WithMeta(lang.NewMap(kw_file, "glojure/core/async.glj", kw_line, int(53), kw_column, int(7), kw_end_DASH_line, int(53), kw_end_DASH_column, int(12), kw_arglists, lang.NewList(lang.NewVector(sym_chan)), kw_doc, "Closes a channel. The channel will no longer accept any puts (they\n will be ignored). Data in the channel remains available for taking,\n until exhausted, after which takes will return nil. If there are any\n pending takes, they will be dispatched with nil. Closing a closed\n channel will throw an exception.\n\n Logically closing happens after all puts have been\n delivered. Therefore, any blocked or parked puts will remain\n blocked/parked until a taker releases them.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core_DOT_async))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(lang.Builtins["close"], []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_DOT_async_close_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_DOT_async_close_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // default-case + { + tmp0 := sym_default_DASH_case.WithMeta(lang.NewMap(kw_file, "glojure/core/async.glj", kw_line, int(100), kw_column, int(8), kw_end_DASH_line, int(100), kw_end_DASH_column, int(19), kw_private, true, kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core_DOT_async))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp2 any + { // let + // let binding "def" + var v3 any = "unimplemented: new with non-constant class type" + _ = v3 + tmp2 = v3 + } // end let + return tmp2 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_DOT_async_default_DASH_case = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_DOT_async_default_DASH_case.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // !. Unless the :priority option is true, if more than one\n port operation is ready a non-deterministic choice will be made. If\n no operation is ready and a :default value is\n supplied, [default-val :default] will be returned, otherwise alts!\n will park until the first operation to become ready\n completes. Returns [val port] of the completed operation, where val\n is the value taken for takes, and true for puts.\n\n opts are passed as :key val ... Supported options:\n\n :default val - the value to use if none of the operations are immediately ready\n :priority true - (default nil) when true, the operations will be tried in order.\n\n Note: there is no guarantee that the port exps or val exprs will be\n used, nor in what order should they be, so they should not be\n depended upon for side effects.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core_DOT_async))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + var tmp4 any + { // let + // let binding "map__708" + var v5 any = v3 + _ = v5 + // let binding "map__708" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v5}) + if lang.IsTruthy(tmp8) { + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_next) + tmp11 := lang.Apply(tmp10, []any{v5}) + if lang.IsTruthy(tmp11) { + tmp12 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) + tmp13 := lang.Apply(tmp12, []any{v5}) + tmp14 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{tmp13}) + tmp9 = tmp14 + } else { + var tmp15 any + tmp16 := checkDerefVar(var_glojure_DOT_core_seq) + tmp17 := lang.Apply(tmp16, []any{v5}) + if lang.IsTruthy(tmp17) { + tmp18 := checkDerefVar(var_glojure_DOT_core_first) + tmp19 := lang.Apply(tmp18, []any{v5}) + tmp15 = tmp19 + } else { + } + tmp9 = tmp15 + } + tmp6 = tmp9 + } else { + tmp6 = v5 + } + var v20 any = tmp6 + _ = v20 + // let binding "opts" + var v21 any = v20 + _ = v21 + tmp22 := checkDerefVar(var_glojure_DOT_core_DOT_async_do_DASH_alts) + tmp23 := lang.Apply(tmp22, []any{v2, v21}) + tmp4 = tmp23 + } // end let + return tmp4 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_DOT_async_alts_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_DOT_async_alts_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // alts!! + { + tmp0 := sym_alts_BANG__BANG_.WithMeta(lang.NewMap(kw_file, "glojure/core/async.glj", kw_line, int(210), kw_column, int(6), kw_end_DASH_line, int(210), kw_end_DASH_column, int(11), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core_DOT_async))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + var tmp4 any + { // let + // let binding "map__708" + var v5 any = v3 + _ = v5 + // let binding "map__708" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v5}) + if lang.IsTruthy(tmp8) { + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_next) + tmp11 := lang.Apply(tmp10, []any{v5}) + if lang.IsTruthy(tmp11) { + tmp12 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) + tmp13 := lang.Apply(tmp12, []any{v5}) + tmp14 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{tmp13}) + tmp9 = tmp14 + } else { + var tmp15 any + tmp16 := checkDerefVar(var_glojure_DOT_core_seq) + tmp17 := lang.Apply(tmp16, []any{v5}) + if lang.IsTruthy(tmp17) { + tmp18 := checkDerefVar(var_glojure_DOT_core_first) + tmp19 := lang.Apply(tmp18, []any{v5}) + tmp15 = tmp19 + } else { + } + tmp9 = tmp15 + } + tmp6 = tmp9 + } else { + tmp6 = v5 + } + var v20 any = tmp6 + _ = v20 + // let binding "opts" + var v21 any = v20 + _ = v21 + tmp22 := checkDerefVar(var_glojure_DOT_core_DOT_async_do_DASH_alts) + tmp23 := lang.Apply(tmp22, []any{v2, v21}) + tmp4 = tmp23 + } // end let + return tmp4 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_DOT_async_alts_BANG__BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_DOT_async_alts_BANG__BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // check-unique-ports! + { + tmp0 := sym_check_DASH_unique_DASH_ports_BANG_.WithMeta(lang.NewMap(kw_file, "glojure/core/async.glj", kw_line, int(158), kw_column, int(8), kw_end_DASH_line, int(158), kw_end_DASH_column, int(26), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_ports)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core_DOT_async))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "chans" + tmp4 := checkDerefVar(var_glojure_DOT_core_map) + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v6 := args[0] + _ = v6 + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp9 := lang.Apply(tmp8, []any{v6}) + if lang.IsTruthy(tmp9) { + tmp10 := lang.Apply(v6, []any{int64(0)}) + tmp7 = tmp10 + } else { + tmp7 = v6 + } + return tmp7 + }) + tmp6 := lang.NewMap(kw_file, "glojure/core/async.glj", kw_line, int(160), kw_column, int(20), kw_end_DASH_line, int(160), kw_end_DASH_column, int(44)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp8 := lang.Apply(tmp4, []any{tmp7, v2}) + var v9 any = tmp8 + _ = v9 + // let binding "s" + tmp10 := checkDerefVar(var_glojure_DOT_core_set) + tmp11 := lang.Apply(tmp10, []any{v9}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + tmp14 := checkDerefVar(var_glojure_DOT_core_not_EQ_) + tmp15 := checkDerefVar(var_glojure_DOT_core_count) + tmp16 := lang.Apply(tmp15, []any{v12}) + tmp17 := checkDerefVar(var_glojure_DOT_core_count) + tmp18 := lang.Apply(tmp17, []any{v2}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + if lang.IsTruthy(tmp19) { + tmp20 := lang.Apply(fmt.Errorf, []any{"duplicate ports found in alt(s)! operation"}) + panic(tmp20) + } else { + } + tmp3 = tmp13 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_DOT_async_check_DASH_unique_DASH_ports_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_DOT_async_check_DASH_unique_DASH_ports_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // do-alt + { + tmp0 := sym_do_DASH_alt.WithMeta(lang.NewMap(kw_file, "glojure/core/async.glj", kw_line, int(212), kw_column, int(7), kw_end_DASH_line, int(212), kw_end_DASH_column, int(12), kw_arglists, lang.NewList(lang.NewVector(sym_alts, sym_clauses)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core_DOT_async))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "clauses" + tmp5 := checkDerefVar(var_glojure_DOT_core_partition) + tmp6 := lang.Apply(tmp5, []any{int64(2), v3}) + var v7 any = tmp6 + _ = v7 + // let binding "opt?" + var tmp8 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v9 := args[0] + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp11 := checkDerefVar(var_glojure_DOT_core_first) + tmp12 := lang.Apply(tmp11, []any{v9}) + tmp13 := lang.Apply(tmp10, []any{tmp12}) + return tmp13 + }) + tmp9 := lang.NewMap(kw_file, "glojure/core/async.glj", kw_line, int(215), kw_column, int(14), kw_end_DASH_line, int(215), kw_end_DASH_column, int(34)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v11 any = tmp10 + _ = v11 + // let binding "opts" + tmp12 := checkDerefVar(var_glojure_DOT_core_filter) + tmp13 := lang.Apply(tmp12, []any{v11, v7}) + var v14 any = tmp13 + _ = v14 + // let binding "clauses" + tmp15 := checkDerefVar(var_glojure_DOT_core_remove) + tmp16 := lang.Apply(tmp15, []any{v11, v7}) + var v17 any = tmp16 + _ = v17 + // let binding "vec__709" + tmp18 := checkDerefVar(var_glojure_DOT_core_reduce) + var tmp19 lang.FnFunc + tmp19 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v20 := args[0] + _ = v20 + v21 := args[1] + _ = v21 + var tmp22 any + { // let + // let binding "vec__714" + var v23 any = v20 + _ = v23 + // let binding "clauses" + tmp24 := checkDerefVar(var_glojure_DOT_core_nth) + tmp25 := lang.Apply(tmp24, []any{v23, int64(0), nil}) + var v26 any = tmp25 + _ = v26 + // let binding "bindings" + tmp27 := checkDerefVar(var_glojure_DOT_core_nth) + tmp28 := lang.Apply(tmp27, []any{v23, int64(1), nil}) + var v29 any = tmp28 + _ = v29 + // let binding "vec__717" + var v30 any = v21 + _ = v30 + // let binding "ports" + tmp31 := checkDerefVar(var_glojure_DOT_core_nth) + tmp32 := lang.Apply(tmp31, []any{v30, int64(0), nil}) + var v33 any = tmp32 + _ = v33 + // let binding "expr" + tmp34 := checkDerefVar(var_glojure_DOT_core_nth) + tmp35 := lang.Apply(tmp34, []any{v30, int64(1), nil}) + var v36 any = tmp35 + _ = v36 + var tmp37 any + { // let + // let binding "ports" + var tmp38 any + tmp39 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp40 := lang.Apply(tmp39, []any{v33}) + if lang.IsTruthy(tmp40) { + tmp38 = v33 + } else { + tmp41 := lang.NewVector(v33) + tmp42 := lang.NewMap(kw_file, "glojure/core/async.glj", kw_line, int(221), kw_column, int(50), kw_end_DASH_line, int(221), kw_end_DASH_column, int(56)) + tmp43, err := lang.WithMeta(tmp41, tmp42.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp38 = tmp43 + } + var v44 any = tmp38 + _ = v44 + // let binding "vec__720" + tmp45 := checkDerefVar(var_glojure_DOT_core_reduce) + var tmp46 lang.FnFunc + tmp46 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v47 := args[0] + _ = v47 + v48 := args[1] + _ = v48 + var tmp49 any + { // let + // let binding "vec__724" + var v50 any = v47 + _ = v50 + // let binding "ports" + tmp51 := checkDerefVar(var_glojure_DOT_core_nth) + tmp52 := lang.Apply(tmp51, []any{v50, int64(0), nil}) + var v53 any = tmp52 + _ = v53 + // let binding "bindings" + tmp54 := checkDerefVar(var_glojure_DOT_core_nth) + tmp55 := lang.Apply(tmp54, []any{v50, int64(1), nil}) + var v56 any = tmp55 + _ = v56 + var tmp57 any + tmp58 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp59 := lang.Apply(tmp58, []any{v48}) + if lang.IsTruthy(tmp59) { + var tmp60 any + { // let + // let binding "vec__727" + var v61 any = v48 + _ = v61 + // let binding "port" + tmp62 := checkDerefVar(var_glojure_DOT_core_nth) + tmp63 := lang.Apply(tmp62, []any{v61, int64(0), nil}) + var v64 any = tmp63 + _ = v64 + // let binding "val" + tmp65 := checkDerefVar(var_glojure_DOT_core_nth) + tmp66 := lang.Apply(tmp65, []any{v61, int64(1), nil}) + var v67 any = tmp66 + _ = v67 + // let binding "gp" + tmp68 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp69 := lang.Apply(tmp68, nil) + var v70 any = tmp69 + _ = v70 + // let binding "gv" + tmp71 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp72 := lang.Apply(tmp71, nil) + var v73 any = tmp72 + _ = v73 + tmp74 := checkDerefVar(var_glojure_DOT_core_conj) + tmp75 := lang.NewVector(v70, v73) + tmp76 := lang.NewMap(kw_file, "glojure/core/async.glj", kw_line, int(229), kw_column, int(38), kw_end_DASH_line, int(229), kw_end_DASH_column, int(44)) + tmp77, err := lang.WithMeta(tmp75, tmp76.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp78 := lang.Apply(tmp74, []any{v53, tmp77}) + tmp79 := checkDerefVar(var_glojure_DOT_core_conj) + tmp80 := lang.NewVector(v70, v64) + tmp81 := lang.NewMap(kw_file, "glojure/core/async.glj", kw_line, int(229), kw_column, int(62), kw_end_DASH_line, int(229), kw_end_DASH_column, int(70)) + tmp82, err := lang.WithMeta(tmp80, tmp81.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp83 := lang.NewVector(v73, v67) + tmp84 := lang.NewMap(kw_file, "glojure/core/async.glj", kw_line, int(229), kw_column, int(72), kw_end_DASH_line, int(229), kw_end_DASH_column, int(79)) + tmp85, err := lang.WithMeta(tmp83, tmp84.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp86 := lang.Apply(tmp79, []any{v56, tmp82, tmp85}) + tmp87 := lang.NewVector(tmp78, tmp86) + tmp88 := lang.NewMap(kw_file, "glojure/core/async.glj", kw_line, int(229), kw_column, int(25), kw_end_DASH_line, int(229), kw_end_DASH_column, int(81)) + tmp89, err := lang.WithMeta(tmp87, tmp88.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp60 = tmp89 + } // end let + tmp57 = tmp60 + } else { + var tmp61 any + { // let + // let binding "gp" + tmp62 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp63 := lang.Apply(tmp62, nil) + var v64 any = tmp63 + _ = v64 + tmp65 := checkDerefVar(var_glojure_DOT_core_conj) + tmp66 := lang.Apply(tmp65, []any{v53, v64}) + tmp67 := checkDerefVar(var_glojure_DOT_core_conj) + tmp68 := lang.NewVector(v64, v48) + tmp69 := lang.NewMap(kw_file, "glojure/core/async.glj", kw_line, int(231), kw_column, int(57), kw_end_DASH_line, int(231), kw_end_DASH_column, int(65)) + tmp70, err := lang.WithMeta(tmp68, tmp69.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp71 := lang.Apply(tmp67, []any{v56, tmp70}) + tmp72 := lang.NewVector(tmp66, tmp71) + tmp73 := lang.NewMap(kw_file, "glojure/core/async.glj", kw_line, int(231), kw_column, int(25), kw_end_DASH_line, int(231), kw_end_DASH_column, int(67)) + tmp74, err := lang.WithMeta(tmp72, tmp73.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp61 = tmp74 + } // end let + tmp57 = tmp61 + } + tmp49 = tmp57 + } // end let + return tmp49 + }) + tmp47 := lang.NewMap(kw_file, "glojure/core/async.glj", kw_line, int(224), kw_column, int(19), kw_end_DASH_line, int(231), kw_end_DASH_column, int(70)) + tmp48, err := lang.WithMeta(tmp46, tmp47.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp49 := lang.NewVector() + tmp50 := lang.NewMap(kw_file, "glojure/core/async.glj", kw_line, int(232), kw_column, int(20), kw_end_DASH_line, int(232), kw_end_DASH_column, int(21)) + tmp51, err := lang.WithMeta(tmp49, tmp50.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp52 := lang.NewVector(tmp51, v29) + tmp53 := lang.NewMap(kw_file, "glojure/core/async.glj", kw_line, int(232), kw_column, int(19), kw_end_DASH_line, int(232), kw_end_DASH_column, int(31)) + tmp54, err := lang.WithMeta(tmp52, tmp53.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp55 := lang.Apply(tmp45, []any{tmp48, tmp54, v44}) + var v56 any = tmp55 + _ = v56 + // let binding "ports" + tmp57 := checkDerefVar(var_glojure_DOT_core_nth) + tmp58 := lang.Apply(tmp57, []any{v56, int64(0), nil}) + var v59 any = tmp58 + _ = v59 + // let binding "bindings" + tmp60 := checkDerefVar(var_glojure_DOT_core_nth) + tmp61 := lang.Apply(tmp60, []any{v56, int64(1), nil}) + var v62 any = tmp61 + _ = v62 + tmp63 := checkDerefVar(var_glojure_DOT_core_conj) + tmp64 := lang.NewVector(v59, v36) + tmp65 := lang.NewMap(kw_file, "glojure/core/async.glj", kw_line, int(233), kw_column, int(29), kw_end_DASH_line, int(233), kw_end_DASH_column, int(40)) + tmp66, err := lang.WithMeta(tmp64, tmp65.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp67 := lang.Apply(tmp63, []any{v26, tmp66}) + tmp68 := lang.NewVector(tmp67, v62) + tmp69 := lang.NewMap(kw_file, "glojure/core/async.glj", kw_line, int(233), kw_column, int(14), kw_end_DASH_line, int(233), kw_end_DASH_column, int(51)) + tmp70, err := lang.WithMeta(tmp68, tmp69.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp37 = tmp70 + } // end let + tmp22 = tmp37 + } // end let + return tmp22 + }) + tmp20 := lang.NewMap(kw_file, "glojure/core/async.glj", kw_line, int(220), kw_column, int(10), kw_end_DASH_line, int(233), kw_end_DASH_column, int(53)) + tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp22 := lang.NewVector() + tmp23 := lang.NewMap(kw_file, "glojure/core/async.glj", kw_line, int(234), kw_column, int(11), kw_end_DASH_line, int(234), kw_end_DASH_column, int(12)) + tmp24, err := lang.WithMeta(tmp22, tmp23.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp25 := lang.NewVector() + tmp26 := lang.NewMap(kw_file, "glojure/core/async.glj", kw_line, int(234), kw_column, int(14), kw_end_DASH_line, int(234), kw_end_DASH_column, int(15)) + tmp27, err := lang.WithMeta(tmp25, tmp26.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp28 := lang.NewVector(tmp24, tmp27) + tmp29 := lang.NewMap(kw_file, "glojure/core/async.glj", kw_line, int(234), kw_column, int(10), kw_end_DASH_line, int(234), kw_end_DASH_column, int(16)) + tmp30, err := lang.WithMeta(tmp28, tmp29.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp31 := lang.Apply(tmp18, []any{tmp21, tmp30, v17}) + var v32 any = tmp31 + _ = v32 + // let binding "clauses" + tmp33 := checkDerefVar(var_glojure_DOT_core_nth) + tmp34 := lang.Apply(tmp33, []any{v32, int64(0), nil}) + var v35 any = tmp34 + _ = v35 + // let binding "bindings" + tmp36 := checkDerefVar(var_glojure_DOT_core_nth) + tmp37 := lang.Apply(tmp36, []any{v32, int64(1), nil}) + var v38 any = tmp37 + _ = v38 + // let binding "gch" + tmp39 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp40 := lang.Apply(tmp39, []any{"ch"}) + var v41 any = tmp40 + _ = v41 + // let binding "gret" + tmp42 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp43 := lang.Apply(tmp42, []any{"ret"}) + var v44 any = tmp43 + _ = v44 + tmp45 := checkDerefVar(var_glojure_DOT_core_seq) + tmp46 := checkDerefVar(var_glojure_DOT_core_concat) + tmp47 := checkDerefVar(var_glojure_DOT_core_list) + tmp48 := lang.Apply(tmp47, []any{sym_glojure_DOT_core_SLASH_let}) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) + tmp50 := checkDerefVar(var_glojure_DOT_core_apply) + tmp51 := checkDerefVar(var_glojure_DOT_core_vector) + tmp52 := checkDerefVar(var_glojure_DOT_core_seq) + tmp53 := checkDerefVar(var_glojure_DOT_core_concat) + tmp54 := checkDerefVar(var_glojure_DOT_core_mapcat) + tmp55 := checkDerefVar(var_glojure_DOT_core_identity) + tmp56 := lang.Apply(tmp54, []any{tmp55, v38}) + tmp57 := checkDerefVar(var_glojure_DOT_core_list) + tmp58 := checkDerefVar(var_glojure_DOT_core_apply) + tmp59 := checkDerefVar(var_glojure_DOT_core_vector) + tmp60 := checkDerefVar(var_glojure_DOT_core_seq) + tmp61 := checkDerefVar(var_glojure_DOT_core_concat) + tmp62 := checkDerefVar(var_glojure_DOT_core_list) + tmp63 := lang.Apply(tmp62, []any{sym_val__0__auto__}) + tmp64 := checkDerefVar(var_glojure_DOT_core_list) + tmp65 := lang.Apply(tmp64, []any{v41}) + tmp66 := checkDerefVar(var_glojure_DOT_core_list) + tmp67 := lang.Apply(tmp66, []any{kw_as}) + tmp68 := checkDerefVar(var_glojure_DOT_core_list) + tmp69 := lang.Apply(tmp68, []any{v44}) + tmp70 := lang.Apply(tmp61, []any{tmp63, tmp65, tmp67, tmp69}) + tmp71 := lang.Apply(tmp60, []any{tmp70}) + tmp72 := lang.Apply(tmp58, []any{tmp59, tmp71}) + tmp73 := lang.Apply(tmp57, []any{tmp72}) + tmp74 := checkDerefVar(var_glojure_DOT_core_list) + tmp75 := checkDerefVar(var_glojure_DOT_core_seq) + tmp76 := checkDerefVar(var_glojure_DOT_core_concat) + tmp77 := checkDerefVar(var_glojure_DOT_core_list) + tmp78 := lang.Apply(tmp77, []any{v2}) + tmp79 := checkDerefVar(var_glojure_DOT_core_list) + tmp80 := checkDerefVar(var_glojure_DOT_core_apply) + tmp81 := checkDerefVar(var_glojure_DOT_core_vector) + tmp82 := checkDerefVar(var_glojure_DOT_core_seq) + tmp83 := checkDerefVar(var_glojure_DOT_core_concat) + tmp84 := checkDerefVar(var_glojure_DOT_core_apply) + tmp85 := checkDerefVar(var_glojure_DOT_core_concat) + tmp86 := checkDerefVar(var_glojure_DOT_core_map) + tmp87 := checkDerefVar(var_glojure_DOT_core_first) + tmp88 := lang.Apply(tmp86, []any{tmp87, v35}) + tmp89 := lang.Apply(tmp84, []any{tmp85, tmp88}) + tmp90 := lang.Apply(tmp83, []any{tmp89}) + tmp91 := lang.Apply(tmp82, []any{tmp90}) + tmp92 := lang.Apply(tmp80, []any{tmp81, tmp91}) + tmp93 := lang.Apply(tmp79, []any{tmp92}) + tmp94 := checkDerefVar(var_glojure_DOT_core_apply) + tmp95 := checkDerefVar(var_glojure_DOT_core_concat) + tmp96 := lang.Apply(tmp94, []any{tmp95, v14}) + tmp97 := lang.Apply(tmp76, []any{tmp78, tmp93, tmp96}) + tmp98 := lang.Apply(tmp75, []any{tmp97}) + tmp99 := lang.Apply(tmp74, []any{tmp98}) + tmp100 := lang.Apply(tmp53, []any{tmp56, tmp73, tmp99}) + tmp101 := lang.Apply(tmp52, []any{tmp100}) + tmp102 := lang.Apply(tmp50, []any{tmp51, tmp101}) + tmp103 := lang.Apply(tmp49, []any{tmp102}) + tmp104 := checkDerefVar(var_glojure_DOT_core_list) + tmp105 := checkDerefVar(var_glojure_DOT_core_seq) + tmp106 := checkDerefVar(var_glojure_DOT_core_concat) + tmp107 := checkDerefVar(var_glojure_DOT_core_list) + tmp108 := lang.Apply(tmp107, []any{sym_glojure_DOT_core_SLASH_cond}) + tmp109 := checkDerefVar(var_glojure_DOT_core_mapcat) + var tmp110 lang.FnFunc + tmp110 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v111 := args[0] + _ = v111 + var tmp112 any + { // let + // let binding "vec__731" + var v113 any = v111 + _ = v113 + // let binding "ports" + tmp114 := checkDerefVar(var_glojure_DOT_core_nth) + tmp115 := lang.Apply(tmp114, []any{v113, int64(0), nil}) + var v116 any = tmp115 + _ = v116 + // let binding "expr" + tmp117 := checkDerefVar(var_glojure_DOT_core_nth) + tmp118 := lang.Apply(tmp117, []any{v113, int64(1), nil}) + var v119 any = tmp118 + _ = v119 + tmp120 := checkDerefVar(var_glojure_DOT_core_seq) + tmp121 := checkDerefVar(var_glojure_DOT_core_concat) + tmp122 := checkDerefVar(var_glojure_DOT_core_list) + tmp123 := lang.Apply(tmp122, []any{sym_glojure_DOT_core_SLASH_or}) + tmp124 := checkDerefVar(var_glojure_DOT_core_map) + var tmp125 lang.FnFunc + tmp125 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v126 := args[0] + _ = v126 + tmp127 := checkDerefVar(var_glojure_DOT_core_seq) + tmp128 := checkDerefVar(var_glojure_DOT_core_concat) + tmp129 := checkDerefVar(var_glojure_DOT_core_list) + tmp130 := lang.Apply(tmp129, []any{sym_glojure_DOT_core_SLASH__EQ_}) + tmp131 := checkDerefVar(var_glojure_DOT_core_list) + tmp132 := lang.Apply(tmp131, []any{v41}) + tmp133 := checkDerefVar(var_glojure_DOT_core_list) + var tmp134 any + tmp135 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp136 := lang.Apply(tmp135, []any{v126}) + if lang.IsTruthy(tmp136) { + tmp137 := checkDerefVar(var_glojure_DOT_core_first) + tmp138 := lang.Apply(tmp137, []any{v126}) + tmp134 = tmp138 + } else { + tmp134 = v126 + } + tmp139 := lang.Apply(tmp133, []any{tmp134}) + tmp140 := lang.Apply(tmp128, []any{tmp130, tmp132, tmp139}) + tmp141 := lang.Apply(tmp127, []any{tmp140}) + return tmp141 + }) + tmp126 := lang.NewMap(kw_file, "glojure/core/async.glj", kw_line, int(241), kw_column, int(39), kw_end_DASH_line, int(242), kw_end_DASH_column, int(84)) + tmp127, err := lang.WithMeta(tmp125, tmp126.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp128 := lang.Apply(tmp124, []any{tmp127, v116}) + tmp129 := lang.Apply(tmp121, []any{tmp123, tmp128}) + tmp130 := lang.Apply(tmp120, []any{tmp129}) + var tmp131 any + var tmp132 any + { // let + // let binding "and__0__auto__" + tmp133 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp134 := lang.Apply(tmp133, []any{v119}) + var v135 any = tmp134 + _ = v135 + var tmp136 any + if lang.IsTruthy(v135) { + tmp137 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp138 := checkDerefVar(var_glojure_DOT_core_first) + tmp139 := lang.Apply(tmp138, []any{v119}) + tmp140 := lang.Apply(tmp137, []any{tmp139}) + tmp136 = tmp140 + } else { + tmp136 = v135 + } + tmp132 = tmp136 + } // end let + if lang.IsTruthy(tmp132) { + tmp133 := checkDerefVar(var_glojure_DOT_core_seq) + tmp134 := checkDerefVar(var_glojure_DOT_core_concat) + tmp135 := checkDerefVar(var_glojure_DOT_core_list) + tmp136 := lang.Apply(tmp135, []any{sym_glojure_DOT_core_SLASH_let}) + tmp137 := checkDerefVar(var_glojure_DOT_core_list) + tmp138 := checkDerefVar(var_glojure_DOT_core_apply) + tmp139 := checkDerefVar(var_glojure_DOT_core_vector) + tmp140 := checkDerefVar(var_glojure_DOT_core_seq) + tmp141 := checkDerefVar(var_glojure_DOT_core_concat) + tmp142 := checkDerefVar(var_glojure_DOT_core_list) + tmp143 := checkDerefVar(var_glojure_DOT_core_first) + tmp144 := lang.Apply(tmp143, []any{v119}) + tmp145 := lang.Apply(tmp142, []any{tmp144}) + tmp146 := checkDerefVar(var_glojure_DOT_core_list) + tmp147 := lang.Apply(tmp146, []any{v44}) + tmp148 := lang.Apply(tmp141, []any{tmp145, tmp147}) + tmp149 := lang.Apply(tmp140, []any{tmp148}) + tmp150 := lang.Apply(tmp138, []any{tmp139, tmp149}) + tmp151 := lang.Apply(tmp137, []any{tmp150}) + tmp152 := checkDerefVar(var_glojure_DOT_core_rest) + tmp153 := lang.Apply(tmp152, []any{v119}) + tmp154 := lang.Apply(tmp134, []any{tmp136, tmp151, tmp153}) + tmp155 := lang.Apply(tmp133, []any{tmp154}) + tmp131 = tmp155 + } else { + tmp131 = v119 + } + tmp156 := lang.NewVector(tmp130, tmp131) + tmp157 := lang.NewMap(kw_file, "glojure/core/async.glj", kw_line, int(241), kw_column, int(21), kw_end_DASH_line, int(246), kw_end_DASH_column, int(29)) + tmp158, err := lang.WithMeta(tmp156, tmp157.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp112 = tmp158 + } // end let + return tmp112 + }) + tmp111 := lang.NewMap(kw_file, "glojure/core/async.glj", kw_line, int(240), kw_column, int(19), kw_end_DASH_line, int(246), kw_end_DASH_column, int(30)) + tmp112, err := lang.WithMeta(tmp110, tmp111.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp113 := lang.Apply(tmp109, []any{tmp112, v35}) + tmp114 := checkDerefVar(var_glojure_DOT_core_list) + tmp115 := checkDerefVar(var_glojure_DOT_core_seq) + tmp116 := checkDerefVar(var_glojure_DOT_core_concat) + tmp117 := checkDerefVar(var_glojure_DOT_core_list) + tmp118 := lang.Apply(tmp117, []any{sym_glojure_DOT_core_SLASH__EQ_}) + tmp119 := checkDerefVar(var_glojure_DOT_core_list) + tmp120 := lang.Apply(tmp119, []any{v41}) + tmp121 := checkDerefVar(var_glojure_DOT_core_list) + tmp122 := lang.Apply(tmp121, []any{kw_default}) + tmp123 := lang.Apply(tmp116, []any{tmp118, tmp120, tmp122}) + tmp124 := lang.Apply(tmp115, []any{tmp123}) + tmp125 := lang.Apply(tmp114, []any{tmp124}) + tmp126 := checkDerefVar(var_glojure_DOT_core_list) + tmp127 := lang.Apply(tmp126, []any{sym_val__0__auto__}) + tmp128 := lang.Apply(tmp106, []any{tmp108, tmp113, tmp125, tmp127}) + tmp129 := lang.Apply(tmp105, []any{tmp128}) + tmp130 := lang.Apply(tmp104, []any{tmp129}) + tmp131 := lang.Apply(tmp46, []any{tmp48, tmp103, tmp130}) + tmp132 := lang.Apply(tmp45, []any{tmp131}) + tmp4 = tmp132 + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_DOT_async_do_DASH_alt = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_DOT_async_do_DASH_alt.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // do-alts + { + tmp0 := sym_do_DASH_alts.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ports, sym_opts)), kw_doc, "returns derefable [val port] if immediate, nil if enqueued", kw_file, "glojure/core/async.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core_DOT_async), kw_end_DASH_column, int(14), kw_column, int(8), kw_line, int(165), kw_end_DASH_line, int(165), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_DOT_async_check_DASH_unique_DASH_ports_BANG_) + tmp5 := lang.Apply(tmp4, []any{v2}) + _ = tmp5 + var tmp6 any + { // let + // let binding "ports" + tmp7 := checkDerefVar(var_glojure_DOT_core_vec) + tmp8 := lang.Apply(tmp7, []any{v2}) + var v9 any = tmp8 + _ = v9 + // let binding "n" + tmp10 := checkDerefVar(var_glojure_DOT_core_count) + tmp11 := lang.Apply(tmp10, []any{v9}) + var v12 any = tmp11 + _ = v12 + // let binding "priority" + tmp13 := lang.Apply(kw_priority, []any{v3}) + var v14 any = tmp13 + _ = v14 + // let binding "selects" + tmp15 := checkDerefVar(var_glojure_DOT_core_map) + tmp16 := checkDerefVar(var_glojure_DOT_core_DOT_async_port_DASH_case) + tmp17 := lang.Apply(tmp15, []any{tmp16, v9}) + var v18 any = tmp17 + _ = v18 + // let binding "selects" + var tmp19 any + tmp20 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp21 := lang.Apply(tmp20, []any{v3, kw_default}) + if lang.IsTruthy(tmp21) { + tmp22 := checkDerefVar(var_glojure_DOT_core_conj) + tmp23 := checkDerefVar(var_glojure_DOT_core_vec) + tmp24 := lang.Apply(tmp23, []any{v18}) + tmp25 := checkDerefVar(var_glojure_DOT_core_DOT_async_default_DASH_case) + tmp26 := lang.Apply(tmp25, nil) + tmp27 := lang.Apply(tmp22, []any{tmp24, tmp26}) + tmp19 = tmp27 + } else { + tmp19 = v18 + } + var v28 any = tmp19 + _ = v28 + // let binding "def" + tmp29 := checkDerefVar(var_glojure_DOT_core_DOT_async_default_DASH_case) + tmp30 := lang.Apply(tmp29, nil) + var v31 any = tmp30 + _ = v31 + // let binding "vec__704" + tmp32 := checkDerefVar(var_glojure_DOT_core_map) + tmp33 := lang.Apply(tmp32, []any{lang.Builtins["deref"], v28}) + tmp34 := lang.Apply(reflect.Select, []any{tmp33}) + var v35 any = tmp34 + _ = v35 + // let binding "chosen-idx" + tmp36 := checkDerefVar(var_glojure_DOT_core_nth) + tmp37 := lang.Apply(tmp36, []any{v35, int64(0), nil}) + var v38 any = tmp37 + _ = v38 + // let binding "val" + tmp39 := checkDerefVar(var_glojure_DOT_core_nth) + tmp40 := lang.Apply(tmp39, []any{v35, int64(1), nil}) + var v41 any = tmp40 + _ = v41 + // let binding "ok" + tmp42 := checkDerefVar(var_glojure_DOT_core_nth) + tmp43 := lang.Apply(tmp42, []any{v35, int64(2), nil}) + var v44 any = tmp43 + _ = v44 + // let binding "chosen" + tmp45 := checkDerefVar(var_glojure_DOT_core_get) + tmp46 := lang.Apply(tmp45, []any{v9, v38}) + var v47 any = tmp46 + _ = v47 + var tmp48 any + tmp49 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp50 := lang.Apply(tmp49, []any{v47}) + if lang.IsTruthy(tmp50) { + tmp51 := lang.Apply(v47, []any{int64(0)}) + tmp52 := lang.NewVector(true, tmp51) + tmp53 := lang.NewMap(kw_file, "glojure/core/async.glj", kw_line, int(181), kw_column, int(24), kw_end_DASH_line, int(181), kw_end_DASH_column, int(40)) + tmp54, err := lang.WithMeta(tmp52, tmp53.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp48 = tmp54 + } else { + var tmp55 any + tmp56 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp57 := lang.Apply(tmp56, []any{v12, v38}) + if lang.IsTruthy(tmp57) { + tmp58 := lang.Apply(kw_default, []any{v3}) + tmp59 := lang.NewVector(tmp58, kw_default) + tmp60 := lang.NewMap(kw_file, "glojure/core/async.glj", kw_line, int(182), kw_column, int(24), kw_end_DASH_line, int(182), kw_end_DASH_column, int(49)) + tmp61, err := lang.WithMeta(tmp59, tmp60.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp55 = tmp61 + } else { + var tmp62 any + if lang.IsTruthy(kw_else) { + var tmp63 any + if lang.IsTruthy(v44) { + tmp64, ok := lang.FieldOrMethod(v41, "Interface") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v41, "Interface"))) + } + var tmp65 any + switch reflect.TypeOf(tmp64).Kind() { + case reflect.Func: + tmp65 = lang.Apply(tmp64, nil) + default: + tmp65 = tmp64 + } + tmp63 = tmp65 + } else { + } + tmp66 := lang.NewVector(tmp63, v47) + tmp67 := lang.NewMap(kw_file, "glojure/core/async.glj", kw_line, int(183), kw_column, int(13), kw_end_DASH_line, int(183), kw_end_DASH_column, int(47)) + tmp68, err := lang.WithMeta(tmp66, tmp67.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp62 = tmp68 + } else { + } + tmp55 = tmp62 + } + tmp48 = tmp55 + } + tmp6 = tmp48 + } // end let + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_DOT_async_do_DASH_alts = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_DOT_async_do_DASH_alts.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // go + { + tmp0 := sym_go.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_body)), kw_doc, "Asynchronously executes the body, returning immediately to the\n calling thread. Additionally, any visible calls to ! and alt!/alts!\n channel operations within the body will block (if necessary) by\n 'parking' the calling thread rather than tying up an OS thread (or\n the only JS thread when in ClojureScript). Upon completion of the\n operation, the body will be resumed.\n\n Unlike in Clojure or ClojureScript, go blocks may (either directly\n or indirectly) perform operations that may block indefinitely, as go\n blocks are run on goroutines, which relinquish the thread of control\n when parked.\n\n Returns a channel which will receive the result of the body when\n completed", kw_file, "glojure/core/async.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core_DOT_async), kw_end_DASH_column, int(12), kw_column, int(11), kw_line, int(67), kw_end_DASH_line, int(67))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym_glojure_DOT_core_SLASH_let}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := checkDerefVar(var_glojure_DOT_core_apply) + tmp11 := checkDerefVar(var_glojure_DOT_core_vector) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_c__0__auto__}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := checkDerefVar(var_glojure_DOT_core_seq) + tmp18 := checkDerefVar(var_glojure_DOT_core_concat) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{sym_glojure_DOT_core_DOT_async_SLASH_chan}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{int64(1)}) + tmp23 := lang.Apply(tmp18, []any{tmp20, tmp22}) + tmp24 := lang.Apply(tmp17, []any{tmp23}) + tmp25 := lang.Apply(tmp16, []any{tmp24}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{sym_f__1__auto__}) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := checkDerefVar(var_glojure_DOT_core_seq) + tmp30 := checkDerefVar(var_glojure_DOT_core_concat) + tmp31 := checkDerefVar(var_glojure_DOT_core_list) + tmp32 := lang.Apply(tmp31, []any{sym_glojure_DOT_core_SLASH_fn}) + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := checkDerefVar(var_glojure_DOT_core_apply) + tmp35 := checkDerefVar(var_glojure_DOT_core_vector) + tmp36 := checkDerefVar(var_glojure_DOT_core_seq) + tmp37 := checkDerefVar(var_glojure_DOT_core_concat) + tmp38 := lang.Apply(tmp37, nil) + tmp39 := lang.Apply(tmp36, []any{tmp38}) + tmp40 := lang.Apply(tmp34, []any{tmp35, tmp39}) + tmp41 := lang.Apply(tmp33, []any{tmp40}) + tmp42 := checkDerefVar(var_glojure_DOT_core_list) + tmp43 := checkDerefVar(var_glojure_DOT_core_seq) + tmp44 := checkDerefVar(var_glojure_DOT_core_concat) + tmp45 := checkDerefVar(var_glojure_DOT_core_list) + tmp46 := lang.Apply(tmp45, []any{sym_glojure_DOT_core_SLASH_let}) + tmp47 := checkDerefVar(var_glojure_DOT_core_list) + tmp48 := checkDerefVar(var_glojure_DOT_core_apply) + tmp49 := checkDerefVar(var_glojure_DOT_core_vector) + tmp50 := checkDerefVar(var_glojure_DOT_core_seq) + tmp51 := checkDerefVar(var_glojure_DOT_core_concat) + tmp52 := checkDerefVar(var_glojure_DOT_core_list) + tmp53 := lang.Apply(tmp52, []any{sym_res__2__auto__}) + tmp54 := checkDerefVar(var_glojure_DOT_core_list) + tmp55 := checkDerefVar(var_glojure_DOT_core_seq) + tmp56 := checkDerefVar(var_glojure_DOT_core_concat) + tmp57 := checkDerefVar(var_glojure_DOT_core_list) + tmp58 := lang.Apply(tmp57, []any{sym_do}) + tmp59 := lang.Apply(tmp56, []any{tmp58, v4}) + tmp60 := lang.Apply(tmp55, []any{tmp59}) + tmp61 := lang.Apply(tmp54, []any{tmp60}) + tmp62 := lang.Apply(tmp51, []any{tmp53, tmp61}) + tmp63 := lang.Apply(tmp50, []any{tmp62}) + tmp64 := lang.Apply(tmp48, []any{tmp49, tmp63}) + tmp65 := lang.Apply(tmp47, []any{tmp64}) + tmp66 := checkDerefVar(var_glojure_DOT_core_list) + tmp67 := checkDerefVar(var_glojure_DOT_core_seq) + tmp68 := checkDerefVar(var_glojure_DOT_core_concat) + tmp69 := checkDerefVar(var_glojure_DOT_core_list) + tmp70 := lang.Apply(tmp69, []any{sym_glojure_DOT_core_DOT_async_SLASH__GT__BANG_}) + tmp71 := checkDerefVar(var_glojure_DOT_core_list) + tmp72 := lang.Apply(tmp71, []any{sym_c__0__auto__}) + tmp73 := checkDerefVar(var_glojure_DOT_core_list) + tmp74 := lang.Apply(tmp73, []any{sym_res__2__auto__}) + tmp75 := lang.Apply(tmp68, []any{tmp70, tmp72, tmp74}) + tmp76 := lang.Apply(tmp67, []any{tmp75}) + tmp77 := lang.Apply(tmp66, []any{tmp76}) + tmp78 := lang.Apply(tmp44, []any{tmp46, tmp65, tmp77}) + tmp79 := lang.Apply(tmp43, []any{tmp78}) + tmp80 := lang.Apply(tmp42, []any{tmp79}) + tmp81 := lang.Apply(tmp30, []any{tmp32, tmp41, tmp80}) + tmp82 := lang.Apply(tmp29, []any{tmp81}) + tmp83 := lang.Apply(tmp28, []any{tmp82}) + tmp84 := lang.Apply(tmp13, []any{tmp15, tmp25, tmp27, tmp83}) + tmp85 := lang.Apply(tmp12, []any{tmp84}) + tmp86 := lang.Apply(tmp10, []any{tmp11, tmp85}) + tmp87 := lang.Apply(tmp9, []any{tmp86}) + tmp88 := checkDerefVar(var_glojure_DOT_core_list) + tmp89 := checkDerefVar(var_glojure_DOT_core_seq) + tmp90 := checkDerefVar(var_glojure_DOT_core_concat) + tmp91 := checkDerefVar(var_glojure_DOT_core_list) + tmp92 := lang.Apply(tmp91, []any{sym_go_SLASH_go}) + tmp93 := checkDerefVar(var_glojure_DOT_core_list) + tmp94 := checkDerefVar(var_glojure_DOT_core_seq) + tmp95 := checkDerefVar(var_glojure_DOT_core_concat) + tmp96 := checkDerefVar(var_glojure_DOT_core_list) + tmp97 := lang.Apply(tmp96, []any{sym_f__1__auto__}) + tmp98 := lang.Apply(tmp95, []any{tmp97}) + tmp99 := lang.Apply(tmp94, []any{tmp98}) + tmp100 := lang.Apply(tmp93, []any{tmp99}) + tmp101 := lang.Apply(tmp90, []any{tmp92, tmp100}) + tmp102 := lang.Apply(tmp89, []any{tmp101}) + tmp103 := lang.Apply(tmp88, []any{tmp102}) + tmp104 := checkDerefVar(var_glojure_DOT_core_list) + tmp105 := checkDerefVar(var_glojure_DOT_core_seq) + tmp106 := checkDerefVar(var_glojure_DOT_core_concat) + tmp107 := checkDerefVar(var_glojure_DOT_core_list) + tmp108 := checkDerefVar(var_glojure_DOT_core_seq) + tmp109 := checkDerefVar(var_glojure_DOT_core_concat) + tmp110 := checkDerefVar(var_glojure_DOT_core_list) + tmp111 := lang.Apply(tmp110, []any{sym_go_SLASH__LT__DASH_chan_DASH_of}) + tmp112 := checkDerefVar(var_glojure_DOT_core_list) + tmp113 := lang.Apply(tmp112, []any{sym_go_SLASH_any}) + tmp114 := lang.Apply(tmp109, []any{tmp111, tmp113}) + tmp115 := lang.Apply(tmp108, []any{tmp114}) + tmp116 := lang.Apply(tmp107, []any{tmp115}) + tmp117 := checkDerefVar(var_glojure_DOT_core_list) + tmp118 := lang.Apply(tmp117, []any{sym_c__0__auto__}) + tmp119 := lang.Apply(tmp106, []any{tmp116, tmp118}) + tmp120 := lang.Apply(tmp105, []any{tmp119}) + tmp121 := lang.Apply(tmp104, []any{tmp120}) + tmp122 := lang.Apply(tmp6, []any{tmp8, tmp87, tmp103, tmp121}) + tmp123 := lang.Apply(tmp5, []any{tmp122}) + return tmp123 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_DOT_async_go = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_DOT_async_go.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // go-loop + { + tmp0 := sym_go_DASH_loop.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "Like (go (loop ...))", kw_file, "glojure/core/async.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core_DOT_async), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(287), kw_end_DASH_line, int(287))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_DOT_async_SLASH_go}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_loop}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v4}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16, v5}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp7, []any{tmp9, tmp19}) + tmp21 := lang.Apply(tmp6, []any{tmp20}) + return tmp21 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_DOT_async_go_DASH_loop = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_DOT_async_go_DASH_loop.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // offer! + { + tmp0 := sym_offer_BANG_.WithMeta(lang.NewMap(kw_file, "glojure/core/async.glj", kw_line, int(143), kw_column, int(7), kw_end_DASH_line, int(143), kw_end_DASH_column, int(12), kw_arglists, lang.NewList(lang.NewVector(sym_port, sym_val)), kw_doc, "Puts a val into port if it's possible to do so immediately.\n nil values are not allowed. Never blocks. Returns true if offer succeeds.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core_DOT_async))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "ret" + tmp5 := checkDerefVar(var_glojure_DOT_core_DOT_async_try_DASH_put) + tmp6 := lang.Apply(tmp5, []any{v2, v3}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + if lang.IsTruthy(v7) { + tmp8 = v7 + } else { + } + tmp4 = tmp8 + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_DOT_async_offer_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_DOT_async_offer_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // pipe + { + tmp0 := sym_pipe.WithMeta(lang.NewMap(kw_file, "glojure/core/async.glj", kw_line, int(292), kw_column, int(7), kw_end_DASH_line, int(292), kw_end_DASH_column, int(10), kw_arglists, lang.NewList(lang.NewVector(sym_from, sym_to), lang.NewVector(sym_from, sym_to, sym_close_QMARK_)), kw_doc, "Takes elements from the from channel and supplies them to the to\n channel. By default, the to channel will be closed when the from\n channel closes, but can be determined by the close? parameter. Will\n stop consuming the from channel if the to channel closes", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core_DOT_async))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_DOT_async_pipe) + tmp5 := lang.Apply(tmp4, []any{v2, v3, true}) + return tmp5 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + { // let + // let binding "c__0__auto__" + tmp6 := checkDerefVar(var_glojure_DOT_core_DOT_async_chan) + tmp7 := lang.Apply(tmp6, []any{int64(1)}) + var v8 any = tmp7 + _ = v8 + // let binding "f__1__auto__" + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp10 any + { // let + // let binding "res__2__auto__" + var tmp11 any + { // let + for { + var tmp12 any + { // let + // let binding "v" + tmp13 := checkDerefVar(var_glojure_DOT_core_DOT_async__LT__BANG_) + tmp14 := lang.Apply(tmp13, []any{v2}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + tmp17 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp18 := lang.Apply(tmp17, []any{v15}) + if lang.IsTruthy(tmp18) { + var tmp19 any + if lang.IsTruthy(v4) { + tmp20 := checkDerefVar(var_glojure_DOT_core_DOT_async_close_BANG_) + tmp21 := lang.Apply(tmp20, []any{v3}) + tmp19 = tmp21 + } else { + } + tmp16 = tmp19 + } else { + var tmp22 any + tmp23 := checkDerefVar(var_glojure_DOT_core_DOT_async__GT__BANG_) + tmp24 := lang.Apply(tmp23, []any{v3, v15}) + if lang.IsTruthy(tmp24) { + continue + } else { + } + tmp16 = tmp22 + } + tmp12 = tmp16 + } // end let + tmp11 = tmp12 + break + } + } // end let + var v12 any = tmp11 + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_DOT_async__GT__BANG_) + tmp14 := lang.Apply(tmp13, []any{v8, v12}) + tmp10 = tmp14 + } // end let + return tmp10 + }) + var v10 any = tmp9 + _ = v10 + tmp11 := lang.Apply(lang.Builtins["<-chan-of"], []any{lang.Builtins["any"]}) + tmp12 := lang.Apply(tmp11, []any{v8}) + tmp5 = tmp12 + } // end let + _ = tmp5 + return v3 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_DOT_async_pipe = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_DOT_async_pipe.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // poll! + { + tmp0 := sym_poll_BANG_.WithMeta(lang.NewMap(kw_file, "glojure/core/async.glj", kw_line, int(150), kw_column, int(7), kw_end_DASH_line, int(150), kw_end_DASH_column, int(11), kw_arglists, lang.NewList(lang.NewVector(sym_port)), kw_doc, "Takes a val from port if it's possible to do so immediately.\n Never blocks. Returns value if successful, nil otherwise.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core_DOT_async))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "res" + tmp4 := checkDerefVar(var_glojure_DOT_core_DOT_async_try_DASH_take) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + // let binding "vec__701" + var v7 any = v6 + _ = v7 + // let binding "val" + tmp8 := checkDerefVar(var_glojure_DOT_core_nth) + tmp9 := lang.Apply(tmp8, []any{v7, int64(0), nil}) + var v10 any = tmp9 + _ = v10 + // let binding "ok" + tmp11 := checkDerefVar(var_glojure_DOT_core_nth) + tmp12 := lang.Apply(tmp11, []any{v7, int64(1), nil}) + var v13 any = tmp12 + _ = v13 + var tmp14 any + if lang.IsTruthy(v13) { + tmp14 = v10 + } else { + } + tmp3 = tmp14 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_DOT_async_poll_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_DOT_async_poll_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // port-case + { + tmp0 := sym_port_DASH_case.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_port_DASH_or_DASH_put)), kw_doc, "Returns a *reflect.SelectCase for the given channel operation.", kw_file, "glojure/core/async.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core_DOT_async), kw_end_DASH_column, int(16), kw_column, int(8), kw_line, int(106), kw_end_DASH_line, int(106), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "wport" + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v2}) + if lang.IsTruthy(tmp6) { + tmp7 := lang.Apply(v2, []any{int64(0)}) + tmp4 = tmp7 + } else { + } + var v8 any = tmp4 + _ = v8 + // let binding "port" + var tmp9 any + { // let + // let binding "or__0__auto__" + var v10 any = v8 + _ = v10 + var tmp11 any + if lang.IsTruthy(v10) { + tmp11 = v10 + } else { + tmp11 = v2 + } + tmp9 = tmp11 + } // end let + var v10 any = tmp9 + _ = v10 + // let binding "val" + var tmp11 any + if lang.IsTruthy(v8) { + tmp12 := lang.Apply(v2, []any{int64(1)}) + tmp13 := lang.Apply(reflect.ValueOf, []any{tmp12}) + tmp11 = tmp13 + } else { + } + var v14 any = tmp11 + _ = v14 + // let binding "select-case" + var v15 any = "unimplemented: new with non-constant class type" + _ = v15 + var tmp16 any + if lang.IsTruthy(v8) { + } else { + } + _ = tmp16 + tmp3 = v15 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_DOT_async_port_DASH_case = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_DOT_async_port_DASH_case.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // timeout + { + tmp0 := sym_timeout.WithMeta(lang.NewMap(kw_file, "glojure/core/async.glj", kw_line, int(91), kw_column, int(7), kw_end_DASH_line, int(91), kw_end_DASH_column, int(13), kw_arglists, lang.NewList(lang.NewVector(sym_msecs)), kw_doc, "Returns a channel that will close after msecs", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core_DOT_async))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "ret" + tmp4 := checkDerefVar(var_glojure_DOT_core_DOT_async_chan) + tmp5 := lang.Apply(tmp4, nil) + var v6 any = tmp5 + _ = v6 + // let binding "after" + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_) + tmp8 := lang.Apply(lang.Builtins["int64"], []any{time4.Millisecond}) + tmp9 := lang.Apply(tmp7, []any{v2, tmp8}) + tmp10 := lang.Apply(time4.After, []any{tmp9}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + { // let + // let binding "c__0__auto__" + tmp13 := checkDerefVar(var_glojure_DOT_core_DOT_async_chan) + tmp14 := lang.Apply(tmp13, []any{int64(1)}) + var v15 any = tmp14 + _ = v15 + // let binding "f__1__auto__" + var tmp16 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp17 any + { // let + // let binding "res__2__auto__" + tmp18 := checkDerefVar(var_glojure_DOT_core_DOT_async__LT__BANG_) + tmp19 := lang.Apply(tmp18, []any{v11}) + _ = tmp19 + tmp20 := checkDerefVar(var_glojure_DOT_core_DOT_async_close_BANG_) + tmp21 := lang.Apply(tmp20, []any{v6}) + var v22 any = tmp21 + _ = v22 + tmp23 := checkDerefVar(var_glojure_DOT_core_DOT_async__GT__BANG_) + tmp24 := lang.Apply(tmp23, []any{v15, v22}) + tmp17 = tmp24 + } // end let + return tmp17 + }) + var v17 any = tmp16 + _ = v17 + tmp18 := lang.Apply(lang.Builtins["<-chan-of"], []any{lang.Builtins["any"]}) + tmp19 := lang.Apply(tmp18, []any{v15}) + tmp12 = tmp19 + } // end let + _ = tmp12 + tmp3 = v6 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_DOT_async_timeout = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_DOT_async_timeout.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // try-put + { + tmp0 := sym_try_DASH_put.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_port, sym_val)), kw_doc, "Returns true if val was sent on the port, false if sending would\n block", kw_file, "glojure/core/async.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core_DOT_async), kw_end_DASH_column, int(14), kw_column, int(8), kw_line, int(118), kw_end_DASH_line, int(118), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "sc" + tmp5 := checkDerefVar(var_glojure_DOT_core_DOT_async_port_DASH_case) + tmp6 := lang.NewVector(v2, v3) + tmp7 := lang.NewMap(kw_file, "glojure/core/async.glj", kw_line, int(122), kw_column, int(23), kw_end_DASH_line, int(122), kw_end_DASH_column, int(32)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp9 := lang.Apply(tmp5, []any{tmp8}) + var v10 any = tmp9 + _ = v10 + // let binding "def" + tmp11 := checkDerefVar(var_glojure_DOT_core_DOT_async_default_DASH_case) + tmp12 := lang.Apply(tmp11, nil) + var v13 any = tmp12 + _ = v13 + // let binding "vec__695" + tmp14 := checkDerefVar(var_glojure_DOT_core_map) + tmp15 := lang.NewVector(v10, v13) + tmp16 := lang.NewMap(kw_file, "glojure/core/async.glj", kw_line, int(124), kw_column, int(55), kw_end_DASH_line, int(124), kw_end_DASH_column, int(62)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp18 := lang.Apply(tmp14, []any{lang.Builtins["deref"], tmp17}) + tmp19 := lang.Apply(reflect.Select, []any{tmp18}) + var v20 any = tmp19 + _ = v20 + // let binding "chosen" + tmp21 := checkDerefVar(var_glojure_DOT_core_nth) + tmp22 := lang.Apply(tmp21, []any{v20, int64(0), nil}) + var v23 any = tmp22 + _ = v23 + // let binding "val" + tmp24 := checkDerefVar(var_glojure_DOT_core_nth) + tmp25 := lang.Apply(tmp24, []any{v20, int64(1), nil}) + var v26 any = tmp25 + _ = v26 + // let binding "ok" + tmp27 := checkDerefVar(var_glojure_DOT_core_nth) + tmp28 := lang.Apply(tmp27, []any{v20, int64(2), nil}) + var v29 any = tmp28 + _ = v29 + tmp30 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp31 := lang.Apply(tmp30, []any{int64(0), v23}) + tmp4 = tmp31 + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_DOT_async_try_DASH_put = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_DOT_async_try_DASH_put.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // try-take + { + tmp0 := sym_try_DASH_take.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_port)), kw_doc, "Returns [val true] if val was received from the port, [nil false] if the channel was closed,\n and nil if receiving would block.", kw_file, "glojure/core/async.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core_DOT_async), kw_end_DASH_column, int(15), kw_column, int(8), kw_line, int(127), kw_end_DASH_line, int(127), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "sc" + var v4 any = "unimplemented: new with non-constant class type" + _ = v4 + // let binding "_" + var v5 any = nil + _ = v5 + // let binding "def" + var v6 any = "unimplemented: new with non-constant class type" + _ = v6 + // let binding "_" + var v7 any = nil + _ = v7 + // let binding "vec__698" + tmp8 := checkDerefVar(var_glojure_DOT_core_map) + tmp9 := lang.NewVector(v4, v6) + tmp10 := lang.NewMap(kw_file, "glojure/core/async.glj", kw_line, int(138), kw_column, int(55), kw_end_DASH_line, int(138), kw_end_DASH_column, int(62)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp12 := lang.Apply(tmp8, []any{lang.Builtins["deref"], tmp11}) + tmp13 := lang.Apply(reflect.Select, []any{tmp12}) + var v14 any = tmp13 + _ = v14 + // let binding "chosen" + tmp15 := checkDerefVar(var_glojure_DOT_core_nth) + tmp16 := lang.Apply(tmp15, []any{v14, int64(0), nil}) + var v17 any = tmp16 + _ = v17 + // let binding "val" + tmp18 := checkDerefVar(var_glojure_DOT_core_nth) + tmp19 := lang.Apply(tmp18, []any{v14, int64(1), nil}) + var v20 any = tmp19 + _ = v20 + // let binding "ok" + tmp21 := checkDerefVar(var_glojure_DOT_core_nth) + tmp22 := lang.Apply(tmp21, []any{v14, int64(2), nil}) + var v23 any = tmp22 + _ = v23 + var tmp24 any + tmp25 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp26 := lang.Apply(tmp25, []any{int64(1), v17}) + if lang.IsTruthy(tmp26) { + } else { + var tmp27 any + if lang.IsTruthy(v23) { + tmp28, ok := lang.FieldOrMethod(v20, "Interface") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v20, "Interface"))) + } + var tmp29 any + switch reflect.TypeOf(tmp28).Kind() { + case reflect.Func: + tmp29 = lang.Apply(tmp28, nil) + default: + tmp29 = tmp28 + } + tmp30 := lang.NewVector(tmp29, true) + tmp31 := lang.NewMap(kw_file, "glojure/core/async.glj", kw_line, int(140), kw_column, int(14), kw_end_DASH_line, int(140), kw_end_DASH_column, int(36)) + tmp32, err := lang.WithMeta(tmp30, tmp31.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp27 = tmp32 + } else { + var tmp33 any + if lang.IsTruthy(kw_else) { + tmp34 := lang.NewVector(nil, false) + tmp35 := lang.NewMap(kw_file, "glojure/core/async.glj", kw_line, int(141), kw_column, int(17), kw_end_DASH_line, int(141), kw_end_DASH_column, int(27)) + tmp36, err := lang.WithMeta(tmp34, tmp35.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp33 = tmp36 + } else { + } + tmp27 = tmp33 + } + tmp24 = tmp27 + } + tmp3 = tmp24 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_DOT_async_try_DASH_take = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_DOT_async_try_DASH_take.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } +} diff --git a/pkg/stdlib/glojure/core/loader.go b/pkg/stdlib/glojure/core/loader.go new file mode 100644 index 00000000..680d3ca4 --- /dev/null +++ b/pkg/stdlib/glojure/core/loader.go @@ -0,0 +1,56320 @@ +// Code generated by glojure codegen. DO NOT EDIT. + +package core + +import ( + errors5 "errors" + fmt "fmt" + lang "github.com/glojurelang/glojure/pkg/lang" + runtime "github.com/glojurelang/glojure/pkg/runtime" + uuid10 "github.com/google/uuid" + math4 "math" + big6 "math/big" + rand13 "math/rand" + url14 "net/url" + reflect "reflect" + regexp12 "regexp" + runtime11 "runtime" + strconv9 "strconv" + strings8 "strings" + time7 "time" +) + +func init() { + runtime.RegisterNSLoader("glojure/core", LoadNS) +} + +func checkDerefVar(v *lang.Var) any { + if v.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) + } + return v.Get() +} + +func checkArity(args []any, expected int) { + if len(args) != expected { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + +// LoadNS initializes the namespace "glojure.core" +func LoadNS() { + sym__PCT_ := lang.NewSymbol("%") + sym__AMP_ := lang.NewSymbol("&") + sym__AMP_env := lang.NewSymbol("&env") + sym__AMP_form := lang.NewSymbol("&form") + sym__STAR_ := lang.NewSymbol("*") + sym__STAR__TICK_ := lang.NewSymbol("*'") + sym__STAR_1 := lang.NewSymbol("*1") + sym__STAR_2 := lang.NewSymbol("*2") + sym__STAR_3 := lang.NewSymbol("*3") + sym__STAR_agent_STAR_ := lang.NewSymbol("*agent*") + sym__STAR_assert_STAR_ := lang.NewSymbol("*assert*") + sym__STAR_command_DASH_line_DASH_args_STAR_ := lang.NewSymbol("*command-line-args*") + sym__STAR_compile_DASH_files_STAR_ := lang.NewSymbol("*compile-files*") + sym__STAR_compile_DASH_path_STAR_ := lang.NewSymbol("*compile-path*") + sym__STAR_compiler_DASH_options_STAR_ := lang.NewSymbol("*compiler-options*") + sym__STAR_data_DASH_readers_STAR_ := lang.NewSymbol("*data-readers*") + sym__STAR_default_DASH_data_DASH_reader_DASH_fn_STAR_ := lang.NewSymbol("*default-data-reader-fn*") + sym__STAR_e := lang.NewSymbol("*e") + sym__STAR_err_STAR_ := lang.NewSymbol("*err*") + sym__STAR_file_STAR_ := lang.NewSymbol("*file*") + sym__STAR_flush_DASH_on_DASH_newline_STAR_ := lang.NewSymbol("*flush-on-newline*") + sym__STAR_in_STAR_ := lang.NewSymbol("*in*") + sym__STAR_loaded_DASH_libs_STAR_ := lang.NewSymbol("*loaded-libs*") + sym__STAR_loading_DASH_verbosely_STAR_ := lang.NewSymbol("*loading-verbosely*") + sym__STAR_ns_STAR_ := lang.NewSymbol("*ns*") + sym__STAR_out_STAR_ := lang.NewSymbol("*out*") + sym__STAR_pending_DASH_paths_STAR_ := lang.NewSymbol("*pending-paths*") + sym__STAR_print_DASH_dup_STAR_ := lang.NewSymbol("*print-dup*") + sym__STAR_print_DASH_length_STAR_ := lang.NewSymbol("*print-length*") + sym__STAR_print_DASH_level_STAR_ := lang.NewSymbol("*print-level*") + sym__STAR_print_DASH_meta_STAR_ := lang.NewSymbol("*print-meta*") + sym__STAR_print_DASH_namespace_DASH_maps_STAR_ := lang.NewSymbol("*print-namespace-maps*") + sym__STAR_print_DASH_readably_STAR_ := lang.NewSymbol("*print-readably*") + sym__STAR_read_DASH_eval_STAR_ := lang.NewSymbol("*read-eval*") + sym__STAR_repl_STAR_ := lang.NewSymbol("*repl*") + sym__STAR_unchecked_DASH_math_STAR_ := lang.NewSymbol("*unchecked-math*") + sym__STAR_verbose_DASH_defrecords_STAR_ := lang.NewSymbol("*verbose-defrecords*") + sym__STAR_warn_DASH_on_DASH_reflection_STAR_ := lang.NewSymbol("*warn-on-reflection*") + sym__PLUS_ := lang.NewSymbol("+") + sym__PLUS__TICK_ := lang.NewSymbol("+'") + sym__DASH_ := lang.NewSymbol("-") + sym__DASH__TICK_ := lang.NewSymbol("-'") + sym__DASH__GT_ := lang.NewSymbol("->") + sym__DASH__GT__GT_ := lang.NewSymbol("->>") + sym__DASH_protocols := lang.NewSymbol("-protocols") + sym__DOT_ := lang.NewSymbol(".") + sym__DOT__DOT_ := lang.NewSymbol("..") + sym__DOT_Deref := lang.NewSymbol(".Deref") + sym__DOT_Equals := lang.NewSymbol(".Equals") + sym__DOT_HasRoot := lang.NewSymbol(".HasRoot") + sym__DOT_ResetMeta := lang.NewSymbol(".ResetMeta") + sym__DOT_UnixNano := lang.NewSymbol(".UnixNano") + sym__DOT_nth := lang.NewSymbol(".nth") + sym__DOT_reset := lang.NewSymbol(".reset") + sym__SLASH_ := lang.NewSymbol("/") + sym__LT_ := lang.NewSymbol("<") + sym__LT__EQ_ := lang.NewSymbol("<=") + sym__EQ_ := lang.NewSymbol("=") + sym__EQ__EQ_ := lang.NewSymbol("==") + sym__GT_ := lang.NewSymbol(">") + sym__GT_0_QMARK_ := lang.NewSymbol(">0?") + sym__GT_1_QMARK_ := lang.NewSymbol(">1?") + sym__GT__EQ_ := lang.NewSymbol(">=") + sym_CollReduce := lang.NewSymbol("CollReduce") + sym_Datafiable := lang.NewSymbol("Datafiable") + sym_Double_SLASH_isInfinite := lang.NewSymbol("Double/isInfinite") + sym_IKVReduce := lang.NewSymbol("IKVReduce") + sym_InternalReduce := lang.NewSymbol("InternalReduce") + sym_NaN_QMARK_ := lang.NewSymbol("NaN?") + sym_Navigable := lang.NewSymbol("Navigable") + sym_SetMacro := lang.NewSymbol("SetMacro") + sym_StackTraceElement_DASH__GT_vec := lang.NewSymbol("StackTraceElement->vec") + sym_Throwable_DASH__GT_map := lang.NewSymbol("Throwable->map") + sym_a := lang.NewSymbol("a") + sym_a__0__auto__ := lang.NewSymbol("a__0__auto__") + sym_abs := lang.NewSymbol("abs") + sym_accessor := lang.NewSymbol("accessor") + sym_aclone := lang.NewSymbol("aclone") + sym_add := lang.NewSymbol("add") + sym_add_DASH_classpath := lang.NewSymbol("add-classpath") + sym_add_DASH_doc_DASH_and_DASH_meta := lang.NewSymbol("add-doc-and-meta") + sym_add_DASH_watch := lang.NewSymbol("add-watch") + sym_addP := lang.NewSymbol("addP") + sym_agent := lang.NewSymbol("agent") + sym_agent_DASH_error := lang.NewSymbol("agent-error") + sym_agent_DASH_errors := lang.NewSymbol("agent-errors") + sym_agents := lang.NewSymbol("agents") + sym_aget := lang.NewSymbol("aget") + sym_alength := lang.NewSymbol("alength") + sym_alias := lang.NewSymbol("alias") + sym_all_DASH_ns := lang.NewSymbol("all-ns") + sym_alter := lang.NewSymbol("alter") + sym_alter_DASH_meta_BANG_ := lang.NewSymbol("alter-meta!") + sym_alter_DASH_var_DASH_root := lang.NewSymbol("alter-var-root") + sym_amap := lang.NewSymbol("amap") + sym_ancestors := lang.NewSymbol("ancestors") + sym_and := lang.NewSymbol("and") + sym_andNot := lang.NewSymbol("andNot") + sym_and__0__auto__ := lang.NewSymbol("and__0__auto__") + sym_any_QMARK_ := lang.NewSymbol("any?") + sym_apply := lang.NewSymbol("apply") + sym_areduce := lang.NewSymbol("areduce") + sym_arg1 := lang.NewSymbol("arg1") + sym_arg2 := lang.NewSymbol("arg2") + sym_arg3 := lang.NewSymbol("arg3") + sym_arglist := lang.NewSymbol("arglist") + sym_args := lang.NewSymbol("args") + sym_array := lang.NewSymbol("array") + sym_array_DASH_map := lang.NewSymbol("array-map") + sym_array__0__auto__ := lang.NewSymbol("array__0__auto__") + sym_as_DASH__GT_ := lang.NewSymbol("as->") + sym_aseq := lang.NewSymbol("aseq") + sym_aset := lang.NewSymbol("aset") + sym_aset_DASH_boolean := lang.NewSymbol("aset-boolean") + sym_aset_DASH_byte := lang.NewSymbol("aset-byte") + sym_aset_DASH_char := lang.NewSymbol("aset-char") + sym_aset_DASH_double := lang.NewSymbol("aset-double") + sym_aset_DASH_float := lang.NewSymbol("aset-float") + sym_aset_DASH_int := lang.NewSymbol("aset-int") + sym_aset_DASH_long := lang.NewSymbol("aset-long") + sym_aset_DASH_short := lang.NewSymbol("aset-short") + sym_assert := lang.NewSymbol("assert") + sym_assert_DASH_args := lang.NewSymbol("assert-args") + sym_assert_DASH_valid_DASH_fdecl := lang.NewSymbol("assert-valid-fdecl") + sym_assoc := lang.NewSymbol("assoc") + sym_assoc_BANG_ := lang.NewSymbol("assoc!") + sym_assoc_DASH_in := lang.NewSymbol("assoc-in") + sym_associative_QMARK_ := lang.NewSymbol("associative?") + sym_atom := lang.NewSymbol("atom") + sym_attr_DASH_map_QMARK_ := lang.NewSymbol("attr-map?") + sym_atype := lang.NewSymbol("atype") + sym_await := lang.NewSymbol("await") + sym_await_DASH_for := lang.NewSymbol("await-for") + sym_await1 := lang.NewSymbol("await1") + sym_b := lang.NewSymbol("b") + sym_bases := lang.NewSymbol("bases") + sym_begin := lang.NewSymbol("begin") + sym_bigdec := lang.NewSymbol("bigdec") + sym_bigint := lang.NewSymbol("bigint") + sym_biginteger := lang.NewSymbol("biginteger") + sym_binding := lang.NewSymbol("binding") + sym_binding_DASH_conveyor_DASH_fn := lang.NewSymbol("binding-conveyor-fn") + sym_binding_DASH_map := lang.NewSymbol("binding-map") + sym_bindings := lang.NewSymbol("bindings") + sym_bindings_STAR_ := lang.NewSymbol("bindings*") + sym_bit_DASH_and := lang.NewSymbol("bit-and") + sym_bit_DASH_and_DASH_not := lang.NewSymbol("bit-and-not") + sym_bit_DASH_clear := lang.NewSymbol("bit-clear") + sym_bit_DASH_flip := lang.NewSymbol("bit-flip") + sym_bit_DASH_not := lang.NewSymbol("bit-not") + sym_bit_DASH_or := lang.NewSymbol("bit-or") + sym_bit_DASH_set := lang.NewSymbol("bit-set") + sym_bit_DASH_shift_DASH_left := lang.NewSymbol("bit-shift-left") + sym_bit_DASH_shift_DASH_right := lang.NewSymbol("bit-shift-right") + sym_bit_DASH_test := lang.NewSymbol("bit-test") + sym_bit_DASH_xor := lang.NewSymbol("bit-xor") + sym_body := lang.NewSymbol("body") + sym_body_DASH_expr := lang.NewSymbol("body-expr") + sym_boolean := lang.NewSymbol("boolean") + sym_boolean_DASH_array := lang.NewSymbol("boolean-array") + sym_boolean_QMARK_ := lang.NewSymbol("boolean?") + sym_booleans := lang.NewSymbol("booleans") + sym_bound_DASH_fn := lang.NewSymbol("bound-fn") + sym_bound_DASH_fn_STAR_ := lang.NewSymbol("bound-fn*") + sym_bound_QMARK_ := lang.NewSymbol("bound?") + sym_bounded_DASH_count := lang.NewSymbol("bounded-count") + sym_branch_QMARK_ := lang.NewSymbol("branch?") + sym_butlast := lang.NewSymbol("butlast") + sym_byte := lang.NewSymbol("byte") + sym_byte_DASH_array := lang.NewSymbol("byte-array") + sym_byteCast := lang.NewSymbol("byteCast") + sym_bytes := lang.NewSymbol("bytes") + sym_bytes_QMARK_ := lang.NewSymbol("bytes?") + sym_c := lang.NewSymbol("c") + sym_c1 := lang.NewSymbol("c1") + sym_c2 := lang.NewSymbol("c2") + sym_c3 := lang.NewSymbol("c3") + sym_c__0__auto__ := lang.NewSymbol("c__0__auto__") + sym_capacity := lang.NewSymbol("capacity") + sym_case := lang.NewSymbol("case") + sym_case_STAR_ := lang.NewSymbol("case*") + sym_case_DASH_f := lang.NewSymbol("case-f") + sym_case_DASH_map := lang.NewSymbol("case-map") + sym_cast := lang.NewSymbol("cast") + sym_cat := lang.NewSymbol("cat") + sym_cause := lang.NewSymbol("cause") + sym_cf := lang.NewSymbol("cf") + sym_char := lang.NewSymbol("char") + sym_char_DASH_array := lang.NewSymbol("char-array") + sym_char_DASH_escape_DASH_string := lang.NewSymbol("char-escape-string") + sym_char_DASH_name_DASH_string := lang.NewSymbol("char-name-string") + sym_char_QMARK_ := lang.NewSymbol("char?") + sym_charCast := lang.NewSymbol("charCast") + sym_chars := lang.NewSymbol("chars") + sym_check_DASH_cyclic_DASH_dependency := lang.NewSymbol("check-cyclic-dependency") + sym_check_DASH_valid_DASH_options := lang.NewSymbol("check-valid-options") + sym_child := lang.NewSymbol("child") + sym_children := lang.NewSymbol("children") + sym_chunk := lang.NewSymbol("chunk") + sym_chunk_DASH_append := lang.NewSymbol("chunk-append") + sym_chunk_DASH_buffer := lang.NewSymbol("chunk-buffer") + sym_chunk_DASH_cons := lang.NewSymbol("chunk-cons") + sym_chunk_DASH_first := lang.NewSymbol("chunk-first") + sym_chunk_DASH_next := lang.NewSymbol("chunk-next") + sym_chunk_DASH_rest := lang.NewSymbol("chunk-rest") + sym_chunked_DASH_seq_QMARK_ := lang.NewSymbol("chunked-seq?") + sym_class := lang.NewSymbol("class") + sym_class_DASH_name := lang.NewSymbol("class-name") + sym_class_QMARK_ := lang.NewSymbol("class?") + sym_clauses := lang.NewSymbol("clauses") + sym_clear_DASH_agent_DASH_errors := lang.NewSymbol("clear-agent-errors") + sym_close := lang.NewSymbol("close") + sym_coerce := lang.NewSymbol("coerce") + sym_coll := lang.NewSymbol("coll") + sym_coll_DASH_reduce := lang.NewSymbol("coll-reduce") + sym_coll_QMARK_ := lang.NewSymbol("coll?") + sym_colls := lang.NewSymbol("colls") + sym_comment := lang.NewSymbol("comment") + sym_commute := lang.NewSymbol("commute") + sym_comp := lang.NewSymbol("comp") + sym_comparator := lang.NewSymbol("comparator") + sym_compare := lang.NewSymbol("compare") + sym_compare_DASH_and_DASH_set_BANG_ := lang.NewSymbol("compare-and-set!") + sym_compile := lang.NewSymbol("compile") + sym_complement := lang.NewSymbol("complement") + sym_completing := lang.NewSymbol("completing") + sym_concat := lang.NewSymbol("concat") + sym_cond := lang.NewSymbol("cond") + sym_cond_DASH__GT_ := lang.NewSymbol("cond->") + sym_cond_DASH__GT__GT_ := lang.NewSymbol("cond->>") + sym_condp := lang.NewSymbol("condp") + sym_conj := lang.NewSymbol("conj") + sym_conj_BANG_ := lang.NewSymbol("conj!") + sym_cons := lang.NewSymbol("cons") + sym_constantly := lang.NewSymbol("constantly") + sym_contains_QMARK_ := lang.NewSymbol("contains?") + sym_content := lang.NewSymbol("content") + sym_copy := lang.NewSymbol("copy") + sym_count := lang.NewSymbol("count") + sym_counted_QMARK_ := lang.NewSymbol("counted?") + sym_create := lang.NewSymbol("create") + sym_create_DASH_ns := lang.NewSymbol("create-ns") + sym_create_DASH_struct := lang.NewSymbol("create-struct") + sym_cycle := lang.NewSymbol("cycle") + sym_d := lang.NewSymbol("d") + sym_data_DASH_reader_DASH_urls := lang.NewSymbol("data-reader-urls") + sym_data_DASH_reader_DASH_var := lang.NewSymbol("data-reader-var") + sym_datafy := lang.NewSymbol("datafy") + sym_dec := lang.NewSymbol("dec") + sym_dec_TICK_ := lang.NewSymbol("dec'") + sym_decimal_QMARK_ := lang.NewSymbol("decimal?") + sym_decl := lang.NewSymbol("decl") + sym_declare := lang.NewSymbol("declare") + sym_decls := lang.NewSymbol("decls") + sym_dedupe := lang.NewSymbol("dedupe") + sym_def := lang.NewSymbol("def") + sym_def_DASH_aset := lang.NewSymbol("def-aset") + sym_default := lang.NewSymbol("default") + sym_definline := lang.NewSymbol("definline") + sym_defmacro := lang.NewSymbol("defmacro") + sym_defmethod := lang.NewSymbol("defmethod") + sym_defmulti := lang.NewSymbol("defmulti") + sym_defn := lang.NewSymbol("defn") + sym_defn_DASH_ := lang.NewSymbol("defn-") + sym_defonce := lang.NewSymbol("defonce") + sym_defprotocol := lang.NewSymbol("defprotocol") + sym_defstruct := lang.NewSymbol("defstruct") + sym_delay := lang.NewSymbol("delay") + sym_delay_QMARK_ := lang.NewSymbol("delay?") + sym_deliver := lang.NewSymbol("deliver") + sym_denominator := lang.NewSymbol("denominator") + sym_deref := lang.NewSymbol("deref") + sym_deref_DASH_as_DASH_map := lang.NewSymbol("deref-as-map") + sym_deref_DASH_future := lang.NewSymbol("deref-future") + sym_derive := lang.NewSymbol("derive") + sym_descendants := lang.NewSymbol("descendants") + sym_destructure := lang.NewSymbol("destructure") + sym_dim := lang.NewSymbol("dim") + sym_dir := lang.NewSymbol("dir") + sym_disj := lang.NewSymbol("disj") + sym_disj_BANG_ := lang.NewSymbol("disj!") + sym_dispatch_DASH_fn := lang.NewSymbol("dispatch-fn") + sym_dispatch_DASH_val := lang.NewSymbol("dispatch-val") + sym_dispatch_DASH_val_DASH_x := lang.NewSymbol("dispatch-val-x") + sym_dispatch_DASH_val_DASH_y := lang.NewSymbol("dispatch-val-y") + sym_dissoc := lang.NewSymbol("dissoc") + sym_dissoc_BANG_ := lang.NewSymbol("dissoc!") + sym_distinct := lang.NewSymbol("distinct") + sym_distinct_QMARK_ := lang.NewSymbol("distinct?") + sym_div := lang.NewSymbol("div") + sym_divide := lang.NewSymbol("divide") + sym_do := lang.NewSymbol("do") + sym_doall := lang.NewSymbol("doall") + sym_doc_DASH_string_QMARK_ := lang.NewSymbol("doc-string?") + sym_docstring := lang.NewSymbol("docstring") + sym_docstring_QMARK_ := lang.NewSymbol("docstring?") + sym_dorun := lang.NewSymbol("dorun") + sym_doseq := lang.NewSymbol("doseq") + sym_dosync := lang.NewSymbol("dosync") + sym_dotimes := lang.NewSymbol("dotimes") + sym_doto := lang.NewSymbol("doto") + sym_double := lang.NewSymbol("double") + sym_double_DASH_array := lang.NewSymbol("double-array") + sym_double_QMARK_ := lang.NewSymbol("double?") + sym_doubles := lang.NewSymbol("doubles") + sym_drop := lang.NewSymbol("drop") + sym_drop_DASH_last := lang.NewSymbol("drop-last") + sym_drop_DASH_while := lang.NewSymbol("drop-while") + sym_e := lang.NewSymbol("e") + sym_elide_DASH_top_DASH_frames := lang.NewSymbol("elide-top-frames") + sym_else := lang.NewSymbol("else") + sym_emit_DASH_extend_DASH_protocol := lang.NewSymbol("emit-extend-protocol") + sym_emit_DASH_extend_DASH_type := lang.NewSymbol("emit-extend-type") + sym_emit_DASH_hinted_DASH_impl := lang.NewSymbol("emit-hinted-impl") + sym_empty := lang.NewSymbol("empty") + sym_empty_QMARK_ := lang.NewSymbol("empty?") + sym_end := lang.NewSymbol("end") + sym_end_DASH_key := lang.NewSymbol("end-key") + sym_end_DASH_test := lang.NewSymbol("end-test") + sym_ensure := lang.NewSymbol("ensure") + sym_ensure_DASH_reduced := lang.NewSymbol("ensure-reduced") + sym_enumeration_DASH_seq := lang.NewSymbol("enumeration-seq") + sym_env := lang.NewSymbol("env") + sym_eof_DASH_error_QMARK_ := lang.NewSymbol("eof-error?") + sym_eof_DASH_value := lang.NewSymbol("eof-value") + sym_error_DASH_handler := lang.NewSymbol("error-handler") + sym_error_DASH_mode := lang.NewSymbol("error-mode") + sym_eval := lang.NewSymbol("eval") + sym_even_QMARK_ := lang.NewSymbol("even?") + sym_every_DASH_pred := lang.NewSymbol("every-pred") + sym_every_QMARK_ := lang.NewSymbol("every?") + sym_ex := lang.NewSymbol("ex") + sym_ex_DASH_cause := lang.NewSymbol("ex-cause") + sym_ex_DASH_data := lang.NewSymbol("ex-data") + sym_ex_DASH_info := lang.NewSymbol("ex-info") + sym_ex_DASH_message := lang.NewSymbol("ex-message") + sym_executor := lang.NewSymbol("executor") + sym_expr := lang.NewSymbol("expr") + sym_expr_DASH_sym := lang.NewSymbol("expr-sym") + sym_exprs := lang.NewSymbol("exprs") + sym_exprs_STAR_ := lang.NewSymbol("exprs*") + sym_extend := lang.NewSymbol("extend") + sym_extend_DASH_protocol := lang.NewSymbol("extend-protocol") + sym_extend_DASH_type := lang.NewSymbol("extend-type") + sym_f := lang.NewSymbol("f") + sym_false_QMARK_ := lang.NewSymbol("false?") + sym_fdecl := lang.NewSymbol("fdecl") + sym_ffirst := lang.NewSymbol("ffirst") + sym_file_DASH_seq := lang.NewSymbol("file-seq") + sym_filter := lang.NewSymbol("filter") + sym_filter_DASH_key := lang.NewSymbol("filter-key") + sym_filters := lang.NewSymbol("filters") + sym_filterv := lang.NewSymbol("filterv") + sym_finally := lang.NewSymbol("finally") + sym_find := lang.NewSymbol("find") + sym_find_DASH_keyword := lang.NewSymbol("find-keyword") + sym_find_DASH_ns := lang.NewSymbol("find-ns") + sym_find_DASH_var := lang.NewSymbol("find-var") + sym_first := lang.NewSymbol("first") + sym_fits_DASH_table_QMARK_ := lang.NewSymbol("fits-table?") + sym_flags_DASH_ignored_DASH_for_DASH_now := lang.NewSymbol("flags-ignored-for-now") + sym_flatten := lang.NewSymbol("flatten") + sym_float := lang.NewSymbol("float") + sym_float_DASH_array := lang.NewSymbol("float-array") + sym_float_QMARK_ := lang.NewSymbol("float?") + sym_floatCast := lang.NewSymbol("floatCast") + sym_floats := lang.NewSymbol("floats") + sym_flush := lang.NewSymbol("flush") + sym_fmt := lang.NewSymbol("fmt") + sym_fn := lang.NewSymbol("fn") + sym_fn_STAR_ := lang.NewSymbol("fn*") + sym_fn_DASH_tail := lang.NewSymbol("fn-tail") + sym_fn_QMARK_ := lang.NewSymbol("fn?") + sym_fnext := lang.NewSymbol("fnext") + sym_fnil := lang.NewSymbol("fnil") + sym_fns := lang.NewSymbol("fns") + sym_fnspecs := lang.NewSymbol("fnspecs") + sym_fnspecs_STAR_ := lang.NewSymbol("fnspecs*") + sym_fntail := lang.NewSymbol("fntail") + sym_for := lang.NewSymbol("for") + sym_force := lang.NewSymbol("force") + sym_form := lang.NewSymbol("form") + sym_format := lang.NewSymbol("format") + sym_forms := lang.NewSymbol("forms") + sym_frequencies := lang.NewSymbol("frequencies") + sym_from := lang.NewSymbol("from") + sym_fs := lang.NewSymbol("fs") + sym_fs__1__auto__ := lang.NewSymbol("fs__1__auto__") + sym_fun := lang.NewSymbol("fun") + sym_func := lang.NewSymbol("func") + sym_fut := lang.NewSymbol("fut") + sym_future := lang.NewSymbol("future") + sym_future_DASH_call := lang.NewSymbol("future-call") + sym_future_DASH_cancel := lang.NewSymbol("future-cancel") + sym_future_DASH_cancelled_QMARK_ := lang.NewSymbol("future-cancelled?") + sym_future_DASH_done_QMARK_ := lang.NewSymbol("future-done?") + sym_future_QMARK_ := lang.NewSymbol("future?") + sym_g := lang.NewSymbol("g") + sym_gen_DASH_class := lang.NewSymbol("gen-class") + sym_gensym := lang.NewSymbol("gensym") + sym_get := lang.NewSymbol("get") + sym_get_DASH_in := lang.NewSymbol("get-in") + sym_get_DASH_method := lang.NewSymbol("get-method") + sym_get_DASH_thread_DASH_bindings := lang.NewSymbol("get-thread-bindings") + sym_get_DASH_validator := lang.NewSymbol("get-validator") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT__STAR_MultiFn := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.*MultiFn") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT__STAR_Var := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.*Var") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Abs := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Abs") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_FindNamespace := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.FindNamespace") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_ISeq := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.ISeq") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Identical := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Identical") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Import := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Import") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_IsReduced := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.IsReduced") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_LockingTransaction := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.LockingTransaction") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_NewIllegalArgumentError := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewIllegalArgumentError") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_NewLazySeq := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewLazySeq") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_NewMultiFn := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewMultiFn") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_NewPersistentArrayMapAsIfByAssoc := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewPersistentArrayMapAsIfByAssoc") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_PopThreadBindings := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.PopThreadBindings") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_PushThreadBindings := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.PushThreadBindings") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Volatile := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Volatile") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT := lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT") + sym_global_DASH_hierarchy := lang.NewSymbol("global-hierarchy") + sym_glojure_DOT_core := lang.NewSymbol("glojure.core") + sym_glojure_DOT_core_DOT_protocols := lang.NewSymbol("glojure.core.protocols") + sym_glojure_DOT_core_SLASH__STAR_in_STAR_ := lang.NewSymbol("glojure.core/*in*") + sym_glojure_DOT_core_SLASH__STAR_loaded_DASH_libs_STAR_ := lang.NewSymbol("glojure.core/*loaded-libs*") + sym_glojure_DOT_core_SLASH__STAR_math_DASH_context_STAR_ := lang.NewSymbol("glojure.core/*math-context*") + sym_glojure_DOT_core_SLASH__STAR_out_STAR_ := lang.NewSymbol("glojure.core/*out*") + sym_glojure_DOT_core_SLASH__DASH_ := lang.NewSymbol("glojure.core/-") + sym_glojure_DOT_core_SLASH__DASH__GT_ := lang.NewSymbol("glojure.core/->") + sym_glojure_DOT_core_SLASH__DASH__GT__GT_ := lang.NewSymbol("glojure.core/->>") + sym_glojure_DOT_core_SLASH__DASH_protocols := lang.NewSymbol("glojure.core/-protocols") + sym_glojure_DOT_core_SLASH__SLASH_ := lang.NewSymbol("glojure.core//") + sym_glojure_DOT_core_SLASH__LT_ := lang.NewSymbol("glojure.core/<") + sym_glojure_DOT_core_SLASH__EQ_ := lang.NewSymbol("glojure.core/=") + sym_glojure_DOT_core_SLASH_Aclone := lang.NewSymbol("glojure.core/Aclone") + sym_glojure_DOT_core_SLASH_AddMethod := lang.NewSymbol("glojure.core/AddMethod") + sym_glojure_DOT_core_SLASH_Aget := lang.NewSymbol("glojure.core/Aget") + sym_glojure_DOT_core_SLASH_Alength := lang.NewSymbol("glojure.core/Alength") + sym_glojure_DOT_core_SLASH_Array := lang.NewSymbol("glojure.core/Array") + sym_glojure_DOT_core_SLASH_Aset := lang.NewSymbol("glojure.core/Aset") + sym_glojure_DOT_core_SLASH_AssertionError := lang.NewSymbol("glojure.core/AssertionError") + sym_glojure_DOT_core_SLASH_BooleanArray := lang.NewSymbol("glojure.core/BooleanArray") + sym_glojure_DOT_core_SLASH_BooleanCast := lang.NewSymbol("glojure.core/BooleanCast") + sym_glojure_DOT_core_SLASH_Booleans := lang.NewSymbol("glojure.core/Booleans") + sym_glojure_DOT_core_SLASH_ByteArray := lang.NewSymbol("glojure.core/ByteArray") + sym_glojure_DOT_core_SLASH_Bytes := lang.NewSymbol("glojure.core/Bytes") + sym_glojure_DOT_core_SLASH_CharArray := lang.NewSymbol("glojure.core/CharArray") + sym_glojure_DOT_core_SLASH_Chars := lang.NewSymbol("glojure.core/Chars") + sym_glojure_DOT_core_SLASH_Count := lang.NewSymbol("glojure.core/Count") + sym_glojure_DOT_core_SLASH_DecP := lang.NewSymbol("glojure.core/DecP") + sym_glojure_DOT_core_SLASH_DoubleArray := lang.NewSymbol("glojure.core/DoubleArray") + sym_glojure_DOT_core_SLASH_DoubleCast := lang.NewSymbol("glojure.core/DoubleCast") + sym_glojure_DOT_core_SLASH_Doubles := lang.NewSymbol("glojure.core/Doubles") + sym_glojure_DOT_core_SLASH_Equiv := lang.NewSymbol("glojure.core/Equiv") + sym_glojure_DOT_core_SLASH_FloatArray := lang.NewSymbol("glojure.core/FloatArray") + sym_glojure_DOT_core_SLASH_Floats := lang.NewSymbol("glojure.core/Floats") + sym_glojure_DOT_core_SLASH_Get := lang.NewSymbol("glojure.core/Get") + sym_glojure_DOT_core_SLASH_Gt := lang.NewSymbol("glojure.core/Gt") + sym_glojure_DOT_core_SLASH_Gte := lang.NewSymbol("glojure.core/Gte") + sym_glojure_DOT_core_SLASH_IllegalStateException := lang.NewSymbol("glojure.core/IllegalStateException") + sym_glojure_DOT_core_SLASH_IncP := lang.NewSymbol("glojure.core/IncP") + sym_glojure_DOT_core_SLASH_IntArray := lang.NewSymbol("glojure.core/IntArray") + sym_glojure_DOT_core_SLASH_Ints := lang.NewSymbol("glojure.core/Ints") + sym_glojure_DOT_core_SLASH_IsNeg := lang.NewSymbol("glojure.core/IsNeg") + sym_glojure_DOT_core_SLASH_IsPos := lang.NewSymbol("glojure.core/IsPos") + sym_glojure_DOT_core_SLASH_IsZero := lang.NewSymbol("glojure.core/IsZero") + sym_glojure_DOT_core_SLASH_LongArray := lang.NewSymbol("glojure.core/LongArray") + sym_glojure_DOT_core_SLASH_LongCast := lang.NewSymbol("glojure.core/LongCast") + sym_glojure_DOT_core_SLASH_Longs := lang.NewSymbol("glojure.core/Longs") + sym_glojure_DOT_core_SLASH_Lt := lang.NewSymbol("glojure.core/Lt") + sym_glojure_DOT_core_SLASH_Lte := lang.NewSymbol("glojure.core/Lte") + sym_glojure_DOT_core_SLASH_Not := lang.NewSymbol("glojure.core/Not") + sym_glojure_DOT_core_SLASH_Nth := lang.NewSymbol("glojure.core/Nth") + sym_glojure_DOT_core_SLASH_Num := lang.NewSymbol("glojure.core/Num") + sym_glojure_DOT_core_SLASH_Object_array := lang.NewSymbol("glojure.core/Object_array") + sym_glojure_DOT_core_SLASH_Quotient := lang.NewSymbol("glojure.core/Quotient") + sym_glojure_DOT_core_SLASH_Remainder := lang.NewSymbol("glojure.core/Remainder") + sym_glojure_DOT_core_SLASH_RunInTransaction := lang.NewSymbol("glojure.core/RunInTransaction") + sym_glojure_DOT_core_SLASH_ShiftLeft := lang.NewSymbol("glojure.core/ShiftLeft") + sym_glojure_DOT_core_SLASH_ShiftRight := lang.NewSymbol("glojure.core/ShiftRight") + sym_glojure_DOT_core_SLASH_ShortArray := lang.NewSymbol("glojure.core/ShortArray") + sym_glojure_DOT_core_SLASH_Shorts := lang.NewSymbol("glojure.core/Shorts") + sym_glojure_DOT_core_SLASH_UncheckedAdd := lang.NewSymbol("glojure.core/UncheckedAdd") + sym_glojure_DOT_core_SLASH_UncheckedByteCast := lang.NewSymbol("glojure.core/UncheckedByteCast") + sym_glojure_DOT_core_SLASH_UncheckedCharCast := lang.NewSymbol("glojure.core/UncheckedCharCast") + sym_glojure_DOT_core_SLASH_UncheckedDec := lang.NewSymbol("glojure.core/UncheckedDec") + sym_glojure_DOT_core_SLASH_UncheckedDoubleCast := lang.NewSymbol("glojure.core/UncheckedDoubleCast") + sym_glojure_DOT_core_SLASH_UncheckedFloatCast := lang.NewSymbol("glojure.core/UncheckedFloatCast") + sym_glojure_DOT_core_SLASH_UncheckedIntCast := lang.NewSymbol("glojure.core/UncheckedIntCast") + sym_glojure_DOT_core_SLASH_UncheckedIntDivide := lang.NewSymbol("glojure.core/UncheckedIntDivide") + sym_glojure_DOT_core_SLASH_UncheckedLongCast := lang.NewSymbol("glojure.core/UncheckedLongCast") + sym_glojure_DOT_core_SLASH_UncheckedShortCast := lang.NewSymbol("glojure.core/UncheckedShortCast") + sym_glojure_DOT_core_SLASH_Unchecked_inc := lang.NewSymbol("glojure.core/Unchecked_inc") + sym_glojure_DOT_core_SLASH_Unchecked_int_add := lang.NewSymbol("glojure.core/Unchecked_int_add") + sym_glojure_DOT_core_SLASH_Unchecked_int_dec := lang.NewSymbol("glojure.core/Unchecked_int_dec") + sym_glojure_DOT_core_SLASH_Unchecked_int_inc := lang.NewSymbol("glojure.core/Unchecked_int_inc") + sym_glojure_DOT_core_SLASH_Unchecked_int_multiply := lang.NewSymbol("glojure.core/Unchecked_int_multiply") + sym_glojure_DOT_core_SLASH_Unchecked_int_negate := lang.NewSymbol("glojure.core/Unchecked_int_negate") + sym_glojure_DOT_core_SLASH_Unchecked_int_remainder := lang.NewSymbol("glojure.core/Unchecked_int_remainder") + sym_glojure_DOT_core_SLASH_Unchecked_int_subtract := lang.NewSymbol("glojure.core/Unchecked_int_subtract") + sym_glojure_DOT_core_SLASH_Unchecked_minus := lang.NewSymbol("glojure.core/Unchecked_minus") + sym_glojure_DOT_core_SLASH_Unchecked_multiply := lang.NewSymbol("glojure.core/Unchecked_multiply") + sym_glojure_DOT_core_SLASH_UnsignedShiftRight := lang.NewSymbol("glojure.core/UnsignedShiftRight") + sym_glojure_DOT_core_SLASH_aclone := lang.NewSymbol("glojure.core/aclone") + sym_glojure_DOT_core_SLASH_aget := lang.NewSymbol("glojure.core/aget") + sym_glojure_DOT_core_SLASH_alength := lang.NewSymbol("glojure.core/alength") + sym_glojure_DOT_core_SLASH_alter_DASH_meta_BANG_ := lang.NewSymbol("glojure.core/alter-meta!") + sym_glojure_DOT_core_SLASH_and := lang.NewSymbol("glojure.core/and") + sym_glojure_DOT_core_SLASH_apply := lang.NewSymbol("glojure.core/apply") + sym_glojure_DOT_core_SLASH_args := lang.NewSymbol("glojure.core/args") + sym_glojure_DOT_core_SLASH_aset := lang.NewSymbol("glojure.core/aset") + sym_glojure_DOT_core_SLASH_assert := lang.NewSymbol("glojure.core/assert") + sym_glojure_DOT_core_SLASH_assert_DASH_args := lang.NewSymbol("glojure.core/assert-args") + sym_glojure_DOT_core_SLASH_assoc := lang.NewSymbol("glojure.core/assoc") + sym_glojure_DOT_core_SLASH_assoc_DASH_in := lang.NewSymbol("glojure.core/assoc-in") + sym_glojure_DOT_core_SLASH_atom := lang.NewSymbol("glojure.core/atom") + sym_glojure_DOT_core_SLASH_binding := lang.NewSymbol("glojure.core/binding") + sym_glojure_DOT_core_SLASH_bound_DASH_fn_STAR_ := lang.NewSymbol("glojure.core/bound-fn*") + sym_glojure_DOT_core_SLASH_c := lang.NewSymbol("glojure.core/c") + sym_glojure_DOT_core_SLASH_chunk := lang.NewSymbol("glojure.core/chunk") + sym_glojure_DOT_core_SLASH_chunk_DASH_append := lang.NewSymbol("glojure.core/chunk-append") + sym_glojure_DOT_core_SLASH_chunk_DASH_buffer := lang.NewSymbol("glojure.core/chunk-buffer") + sym_glojure_DOT_core_SLASH_chunk_DASH_cons := lang.NewSymbol("glojure.core/chunk-cons") + sym_glojure_DOT_core_SLASH_chunk_DASH_first := lang.NewSymbol("glojure.core/chunk-first") + sym_glojure_DOT_core_SLASH_chunk_DASH_rest := lang.NewSymbol("glojure.core/chunk-rest") + sym_glojure_DOT_core_SLASH_chunked_DASH_seq_QMARK_ := lang.NewSymbol("glojure.core/chunked-seq?") + sym_glojure_DOT_core_SLASH_class := lang.NewSymbol("glojure.core/class") + sym_glojure_DOT_core_SLASH_commute := lang.NewSymbol("glojure.core/commute") + sym_glojure_DOT_core_SLASH_compare := lang.NewSymbol("glojure.core/compare") + sym_glojure_DOT_core_SLASH_concat := lang.NewSymbol("glojure.core/concat") + sym_glojure_DOT_core_SLASH_cond := lang.NewSymbol("glojure.core/cond") + sym_glojure_DOT_core_SLASH_condp := lang.NewSymbol("glojure.core/condp") + sym_glojure_DOT_core_SLASH_conj := lang.NewSymbol("glojure.core/conj") + sym_glojure_DOT_core_SLASH_cons := lang.NewSymbol("glojure.core/cons") + sym_glojure_DOT_core_SLASH_count := lang.NewSymbol("glojure.core/count") + sym_glojure_DOT_core_SLASH_create_DASH_struct := lang.NewSymbol("glojure.core/create-struct") + sym_glojure_DOT_core_SLASH_defmulti := lang.NewSymbol("glojure.core/defmulti") + sym_glojure_DOT_core_SLASH_defn := lang.NewSymbol("glojure.core/defn") + sym_glojure_DOT_core_SLASH_deref := lang.NewSymbol("glojure.core/deref") + sym_glojure_DOT_core_SLASH_dosync := lang.NewSymbol("glojure.core/dosync") + sym_glojure_DOT_core_SLASH_double := lang.NewSymbol("glojure.core/double") + sym_glojure_DOT_core_SLASH_equiv := lang.NewSymbol("glojure.core/equiv") + sym_glojure_DOT_core_SLASH_extend := lang.NewSymbol("glojure.core/extend") + sym_glojure_DOT_core_SLASH_extend_DASH_type := lang.NewSymbol("glojure.core/extend-type") + sym_glojure_DOT_core_SLASH_first := lang.NewSymbol("glojure.core/first") + sym_glojure_DOT_core_SLASH_fn := lang.NewSymbol("glojure.core/fn") + sym_glojure_DOT_core_SLASH_future_DASH_call := lang.NewSymbol("glojure.core/future-call") + sym_glojure_DOT_core_SLASH_gen_DASH_class := lang.NewSymbol("glojure.core/gen-class") + sym_glojure_DOT_core_SLASH_get := lang.NewSymbol("glojure.core/get") + sym_glojure_DOT_core_SLASH_hash_DASH_map := lang.NewSymbol("glojure.core/hash-map") + sym_glojure_DOT_core_SLASH_i := lang.NewSymbol("glojure.core/i") + sym_glojure_DOT_core_SLASH_identical := lang.NewSymbol("glojure.core/identical") + sym_glojure_DOT_core_SLASH_if_DASH_let := lang.NewSymbol("glojure.core/if-let") + sym_glojure_DOT_core_SLASH_if_DASH_not := lang.NewSymbol("glojure.core/if-not") + sym_glojure_DOT_core_SLASH_if_DASH_some := lang.NewSymbol("glojure.core/if-some") + sym_glojure_DOT_core_SLASH_in_DASH_ns := lang.NewSymbol("glojure.core/in-ns") + sym_glojure_DOT_core_SLASH_instance_QMARK_ := lang.NewSymbol("glojure.core/instance?") + sym_glojure_DOT_core_SLASH_int := lang.NewSymbol("glojure.core/int") + sym_glojure_DOT_core_SLASH_keyword := lang.NewSymbol("glojure.core/keyword") + sym_glojure_DOT_core_SLASH_lazy_DASH_seq := lang.NewSymbol("glojure.core/lazy-seq") + sym_glojure_DOT_core_SLASH_let := lang.NewSymbol("glojure.core/let") + sym_glojure_DOT_core_SLASH_long := lang.NewSymbol("glojure.core/long") + sym_glojure_DOT_core_SLASH_loop := lang.NewSymbol("glojure.core/loop") + sym_glojure_DOT_core_SLASH_merge := lang.NewSymbol("glojure.core/merge") + sym_glojure_DOT_core_SLASH_meta := lang.NewSymbol("glojure.core/meta") + sym_glojure_DOT_core_SLASH_next := lang.NewSymbol("glojure.core/next") + sym_glojure_DOT_core_SLASH_nf := lang.NewSymbol("glojure.core/nf") + sym_glojure_DOT_core_SLASH_nil_QMARK_ := lang.NewSymbol("glojure.core/nil?") + sym_glojure_DOT_core_SLASH_not := lang.NewSymbol("glojure.core/not") + sym_glojure_DOT_core_SLASH_nth := lang.NewSymbol("glojure.core/nth") + sym_glojure_DOT_core_SLASH_or := lang.NewSymbol("glojure.core/or") + sym_glojure_DOT_core_SLASH_pcalls := lang.NewSymbol("glojure.core/pcalls") + sym_glojure_DOT_core_SLASH_pop_DASH_thread_DASH_bindings := lang.NewSymbol("glojure.core/pop-thread-bindings") + sym_glojure_DOT_core_SLASH_pr_DASH_str := lang.NewSymbol("glojure.core/pr-str") + sym_glojure_DOT_core_SLASH_prn := lang.NewSymbol("glojure.core/prn") + sym_glojure_DOT_core_SLASH_push_DASH_thread_DASH_bindings := lang.NewSymbol("glojure.core/push-thread-bindings") + sym_glojure_DOT_core_SLASH_refer := lang.NewSymbol("glojure.core/refer") + sym_glojure_DOT_core_SLASH_rest := lang.NewSymbol("glojure.core/rest") + sym_glojure_DOT_core_SLASH_seq := lang.NewSymbol("glojure.core/seq") + sym_glojure_DOT_core_SLASH_seq_QMARK_ := lang.NewSymbol("glojure.core/seq?") + sym_glojure_DOT_core_SLASH_str := lang.NewSymbol("glojure.core/str") + sym_glojure_DOT_core_SLASH_swap_BANG_ := lang.NewSymbol("glojure.core/swap!") + sym_glojure_DOT_core_SLASH_sync := lang.NewSymbol("glojure.core/sync") + sym_glojure_DOT_core_SLASH_to_DASH_array := lang.NewSymbol("glojure.core/to-array") + sym_glojure_DOT_core_SLASH_unchecked_DASH_inc := lang.NewSymbol("glojure.core/unchecked-inc") + sym_glojure_DOT_core_SLASH_unchecked_DASH_inc_DASH_int := lang.NewSymbol("glojure.core/unchecked-inc-int") + sym_glojure_DOT_core_SLASH_unquote := lang.NewSymbol("glojure.core/unquote") + sym_glojure_DOT_core_SLASH_unquote_DASH_splicing := lang.NewSymbol("glojure.core/unquote-splicing") + sym_glojure_DOT_core_SLASH_when := lang.NewSymbol("glojure.core/when") + sym_glojure_DOT_core_SLASH_when_DASH_first := lang.NewSymbol("glojure.core/when-first") + sym_glojure_DOT_core_SLASH_when_DASH_let := lang.NewSymbol("glojure.core/when-let") + sym_glojure_DOT_core_SLASH_when_DASH_not := lang.NewSymbol("glojure.core/when-not") + sym_glojure_DOT_core_SLASH_with_DASH_bindings_STAR_ := lang.NewSymbol("glojure.core/with-bindings*") + sym_glojure_DOT_core_SLASH_with_DASH_loading_DASH_context := lang.NewSymbol("glojure.core/with-loading-context") + sym_glojure_DOT_core_SLASH_with_DASH_open := lang.NewSymbol("glojure.core/with-open") + sym_glojure_DOT_core_SLASH_with_DASH_redefs_DASH_fn := lang.NewSymbol("glojure.core/with-redefs-fn") + sym_glojure_DOT_go_DOT_io := lang.NewSymbol("glojure.go.io") + sym_glojure_DOT_lang_DOT_Delay := lang.NewSymbol("glojure.lang.Delay") + sym_glojure_DOT_lang_DOT_IChunk := lang.NewSymbol("glojure.lang.IChunk") + sym_glojure_DOT_lang_DOT_LineNumberingPushbackReader_DOT_ := lang.NewSymbol("glojure.lang.LineNumberingPushbackReader.") + sym_glojure_DOT_lang_DOT_LockingTransaction_SLASH_isRunning := lang.NewSymbol("glojure.lang.LockingTransaction/isRunning") + sym_glojure_DOT_lang_DOT_PersistentArrayMap_SLASH_EMPTY := lang.NewSymbol("glojure.lang.PersistentArrayMap/EMPTY") + sym_glojure_DOT_lang_DOT_Util := lang.NewSymbol("glojure.lang.Util") + sym_glojure_DOT_string := lang.NewSymbol("glojure.string") + sym_group_DASH_by := lang.NewSymbol("group-by") + sym_h := lang.NewSymbol("h") + sym_halt_DASH_when := lang.NewSymbol("halt-when") + sym_handler_DASH_fn := lang.NewSymbol("handler-fn") + sym_hash := lang.NewSymbol("hash") + sym_hash_DASH_basis := lang.NewSymbol("hash-basis") + sym_hash_DASH_map := lang.NewSymbol("hash-map") + sym_hash_DASH_ordered_DASH_coll := lang.NewSymbol("hash-ordered-coll") + sym_hash_DASH_set := lang.NewSymbol("hash-set") + sym_hash_DASH_unordered_DASH_coll := lang.NewSymbol("hash-unordered-coll") + sym_hashes := lang.NewSymbol("hashes") + sym_ident_QMARK_ := lang.NewSymbol("ident?") + sym_identical_QMARK_ := lang.NewSymbol("identical?") + sym_identity := lang.NewSymbol("identity") + sym_idx := lang.NewSymbol("idx") + sym_idx2 := lang.NewSymbol("idx2") + sym_idx2__3__auto__ := lang.NewSymbol("idx2__3__auto__") + sym_idx__1__auto__ := lang.NewSymbol("idx__1__auto__") + sym_idxs := lang.NewSymbol("idxs") + sym_idxv := lang.NewSymbol("idxv") + sym_idxv__4__auto__ := lang.NewSymbol("idxv__4__auto__") + sym_if := lang.NewSymbol("if") + sym_if_DASH_let := lang.NewSymbol("if-let") + sym_if_DASH_not := lang.NewSymbol("if-not") + sym_if_DASH_some := lang.NewSymbol("if-some") + sym_ifn_QMARK_ := lang.NewSymbol("ifn?") + sym_import := lang.NewSymbol("import") + sym_import_DASH_symbols_DASH_or_DASH_lists := lang.NewSymbol("import-symbols-or-lists") + sym_inc := lang.NewSymbol("inc") + sym_inc_TICK_ := lang.NewSymbol("inc'") + sym_index := lang.NewSymbol("index") + sym_indexed_QMARK_ := lang.NewSymbol("indexed?") + sym_infinite_QMARK_ := lang.NewSymbol("infinite?") + sym_init := lang.NewSymbol("init") + sym_init_DASH_val_DASH_or_DASH_seq := lang.NewSymbol("init-val-or-seq") + sym_initk := lang.NewSymbol("initk") + sym_inits := lang.NewSymbol("inits") + sym_inst := lang.NewSymbol("inst") + sym_inst_DASH_ms := lang.NewSymbol("inst-ms") + sym_inst_QMARK_ := lang.NewSymbol("inst?") + sym_instance_QMARK_ := lang.NewSymbol("instance?") + sym_int := lang.NewSymbol("int") + sym_int_DASH_array := lang.NewSymbol("int-array") + sym_int_QMARK_ := lang.NewSymbol("int?") + sym_intCast := lang.NewSymbol("intCast") + sym_integer_QMARK_ := lang.NewSymbol("integer?") + sym_interface_DASH_or_DASH_naive_DASH_reduce := lang.NewSymbol("interface-or-naive-reduce") + sym_interleave := lang.NewSymbol("interleave") + sym_intern := lang.NewSymbol("intern") + sym_internal_DASH_reduce := lang.NewSymbol("internal-reduce") + sym_interpose := lang.NewSymbol("interpose") + sym_into := lang.NewSymbol("into") + sym_into_DASH_array := lang.NewSymbol("into-array") + sym_into1 := lang.NewSymbol("into1") + sym_ints := lang.NewSymbol("ints") + sym_io_BANG_ := lang.NewSymbol("io!") + sym_iref := lang.NewSymbol("iref") + sym_isa_QMARK_ := lang.NewSymbol("isa?") + sym_items := lang.NewSymbol("items") + sym_iter := lang.NewSymbol("iter") + sym_iter__0__auto__ := lang.NewSymbol("iter__0__auto__") + sym_iterate := lang.NewSymbol("iterate") + sym_iteration := lang.NewSymbol("iteration") + sym_iterator_DASH_seq := lang.NewSymbol("iterator-seq") + sym_iterys__0__auto__ := lang.NewSymbol("iterys__0__auto__") + sym_java_DOT_io_DOT_StringReader_DOT_ := lang.NewSymbol("java.io.StringReader.") + sym_java_DOT_math_DOT_MathContext_DOT_ := lang.NewSymbol("java.math.MathContext.") + sym_java_DOT_math_DOT_RoundingMode := lang.NewSymbol("java.math.RoundingMode") + sym_juxt := lang.NewSymbol("juxt") + sym_k := lang.NewSymbol("k") + sym_keep := lang.NewSymbol("keep") + sym_keep_DASH_indexed := lang.NewSymbol("keep-indexed") + sym_key := lang.NewSymbol("key") + sym_keyfn := lang.NewSymbol("keyfn") + sym_keys := lang.NewSymbol("keys") + sym_keyseq := lang.NewSymbol("keyseq") + sym_keyvals := lang.NewSymbol("keyvals") + sym_keyword := lang.NewSymbol("keyword") + sym_keyword_QMARK_ := lang.NewSymbol("keyword?") + sym_kf := lang.NewSymbol("kf") + sym_ks := lang.NewSymbol("ks") + sym_kv_DASH_reduce := lang.NewSymbol("kv-reduce") + sym_kvs := lang.NewSymbol("kvs") + sym_l__1__auto__ := lang.NewSymbol("l__1__auto__") + sym_last := lang.NewSymbol("last") + sym_lazy_DASH_cat := lang.NewSymbol("lazy-cat") + sym_lazy_DASH_seq := lang.NewSymbol("lazy-seq") + sym_len := lang.NewSymbol("len") + sym_let := lang.NewSymbol("let") + sym_let_STAR_ := lang.NewSymbol("let*") + sym_letfn := lang.NewSymbol("letfn") + sym_letfn_STAR_ := lang.NewSymbol("letfn*") + sym_lib := lang.NewSymbol("lib") + sym_libspec_QMARK_ := lang.NewSymbol("libspec?") + sym_lift_DASH_ns := lang.NewSymbol("lift-ns") + sym_line_DASH_seq := lang.NewSymbol("line-seq") + sym_list := lang.NewSymbol("list") + sym_list_STAR_ := lang.NewSymbol("list*") + sym_list_QMARK_ := lang.NewSymbol("list?") + sym_load := lang.NewSymbol("load") + sym_load_DASH_all := lang.NewSymbol("load-all") + sym_load_DASH_data_DASH_reader_DASH_file := lang.NewSymbol("load-data-reader-file") + sym_load_DASH_data_DASH_readers := lang.NewSymbol("load-data-readers") + sym_load_DASH_file := lang.NewSymbol("load-file") + sym_load_DASH_lib := lang.NewSymbol("load-lib") + sym_load_DASH_libs := lang.NewSymbol("load-libs") + sym_load_DASH_one := lang.NewSymbol("load-one") + sym_load_DASH_reader := lang.NewSymbol("load-reader") + sym_load_DASH_string := lang.NewSymbol("load-string") + sym_loaded_DASH_libs := lang.NewSymbol("loaded-libs") + sym_loading__0__auto__ := lang.NewSymbol("loading__0__auto__") + sym_lockee__0__auto__ := lang.NewSymbol("lockee__0__auto__") + sym_locking := lang.NewSymbol("locking") + sym_locklocal__1__auto__ := lang.NewSymbol("locklocal__1__auto__") + sym_long := lang.NewSymbol("long") + sym_long_DASH_array := lang.NewSymbol("long-array") + sym_longs := lang.NewSymbol("longs") + sym_loop := lang.NewSymbol("loop") + sym_loop_STAR_ := lang.NewSymbol("loop*") + sym_m := lang.NewSymbol("m") + sym_macroexpand := lang.NewSymbol("macroexpand") + sym_macroexpand_DASH_1 := lang.NewSymbol("macroexpand-1") + sym_make_DASH_array := lang.NewSymbol("make-array") + sym_make_DASH_hierarchy := lang.NewSymbol("make-hierarchy") + sym_map := lang.NewSymbol("map") + sym_map_DASH_entry_QMARK_ := lang.NewSymbol("map-entry?") + sym_map_DASH_indexed := lang.NewSymbol("map-indexed") + sym_map_QMARK_ := lang.NewSymbol("map?") + sym_mapcat := lang.NewSymbol("mapcat") + sym_mappings := lang.NewSymbol("mappings") + sym_maps := lang.NewSymbol("maps") + sym_mapv := lang.NewSymbol("mapv") + sym_mask := lang.NewSymbol("mask") + sym_math_DOT_IsNaN := lang.NewSymbol("math.IsNaN") + sym_max := lang.NewSymbol("max") + sym_max_DASH_key := lang.NewSymbol("max-key") + sym_max_DASH_mask_DASH_bits := lang.NewSymbol("max-mask-bits") + sym_max_DASH_switch_DASH_table_DASH_size := lang.NewSymbol("max-switch-table-size") + sym_maybe_DASH_destructured := lang.NewSymbol("maybe-destructured") + sym_maybe_DASH_min_DASH_hash := lang.NewSymbol("maybe-min-hash") + sym_maybe_DASH_p := lang.NewSymbol("maybe-p") + sym_memfn := lang.NewSymbol("memfn") + sym_memoize := lang.NewSymbol("memoize") + sym_merge := lang.NewSymbol("merge") + sym_merge_DASH_hash_DASH_collisions := lang.NewSymbol("merge-hash-collisions") + sym_merge_DASH_with := lang.NewSymbol("merge-with") + sym_message := lang.NewSymbol("message") + sym_meta := lang.NewSymbol("meta") + sym_metadata_DASH_map := lang.NewSymbol("metadata-map") + sym_method := lang.NewSymbol("method") + sym_methods := lang.NewSymbol("methods") + sym_min := lang.NewSymbol("min") + sym_min_DASH_key := lang.NewSymbol("min-key") + sym_minus := lang.NewSymbol("minus") + sym_minusP := lang.NewSymbol("minusP") + sym_mix_DASH_collection_DASH_hash := lang.NewSymbol("mix-collection-hash") + sym_mk_DASH_bound_DASH_fn := lang.NewSymbol("mk-bound-fn") + sym_mod := lang.NewSymbol("mod") + sym_mode_DASH_keyword := lang.NewSymbol("mode-keyword") + sym_monitor_DASH_enter := lang.NewSymbol("monitor-enter") + sym_monitor_DASH_exit := lang.NewSymbol("monitor-exit") + sym_more := lang.NewSymbol("more") + sym_more_DASH_dims := lang.NewSymbol("more-dims") + sym_msg := lang.NewSymbol("msg") + sym_multifn := lang.NewSymbol("multifn") + sym_multiply := lang.NewSymbol("multiply") + sym_multiplyP := lang.NewSymbol("multiplyP") + sym_n := lang.NewSymbol("n") + sym_n_DASH_or_DASH_q := lang.NewSymbol("n-or-q") + sym_n__0__auto__ := lang.NewSymbol("n__0__auto__") + sym_name := lang.NewSymbol("name") + sym_name_DASH_vals_DASH_vec := lang.NewSymbol("name-vals-vec") + sym_name_QMARK_ := lang.NewSymbol("name?") + sym_named := lang.NewSymbol("named") + sym_names := lang.NewSymbol("names") + sym_namespace := lang.NewSymbol("namespace") + sym_namespace_DASH_sym := lang.NewSymbol("namespace-sym") + sym_nary_DASH_inline := lang.NewSymbol("nary-inline") + sym_nat_DASH_int_QMARK_ := lang.NewSymbol("nat-int?") + sym_nav := lang.NewSymbol("nav") + sym_need_DASH_ns := lang.NewSymbol("need-ns") + sym_neg_DASH_int_QMARK_ := lang.NewSymbol("neg-int?") + sym_neg_QMARK_ := lang.NewSymbol("neg?") + sym_new := lang.NewSymbol("new") + sym_new_DASH_state := lang.NewSymbol("new-state") + sym_newline := lang.NewSymbol("newline") + sym_newval := lang.NewSymbol("newval") + sym_next := lang.NewSymbol("next") + sym_nfirst := lang.NewSymbol("nfirst") + sym_nil_QMARK_ := lang.NewSymbol("nil?") + sym_nnext := lang.NewSymbol("nnext") + sym_normalize_DASH_slurp_DASH_opts := lang.NewSymbol("normalize-slurp-opts") + sym_not := lang.NewSymbol("not") + sym_not_DASH_any_QMARK_ := lang.NewSymbol("not-any?") + sym_not_DASH_empty := lang.NewSymbol("not-empty") + sym_not_DASH_every_QMARK_ := lang.NewSymbol("not-every?") + sym_not_DASH_found := lang.NewSymbol("not-found") + sym_not_EQ_ := lang.NewSymbol("not=") + sym_ns := lang.NewSymbol("ns") + sym_ns_DASH_aliases := lang.NewSymbol("ns-aliases") + sym_ns_DASH_imports := lang.NewSymbol("ns-imports") + sym_ns_DASH_interns := lang.NewSymbol("ns-interns") + sym_ns_DASH_map := lang.NewSymbol("ns-map") + sym_ns_DASH_name := lang.NewSymbol("ns-name") + sym_ns_DASH_publics := lang.NewSymbol("ns-publics") + sym_ns_DASH_refers := lang.NewSymbol("ns-refers") + sym_ns_DASH_resolve := lang.NewSymbol("ns-resolve") + sym_ns_DASH_sym := lang.NewSymbol("ns-sym") + sym_ns_DASH_unalias := lang.NewSymbol("ns-unalias") + sym_ns_DASH_unmap := lang.NewSymbol("ns-unmap") + sym_nth := lang.NewSymbol("nth") + sym_nthnext := lang.NewSymbol("nthnext") + sym_nthrest := lang.NewSymbol("nthrest") + sym_num := lang.NewSymbol("num") + sym_number_QMARK_ := lang.NewSymbol("number?") + sym_numerator := lang.NewSymbol("numerator") + sym_o := lang.NewSymbol("o") + sym_obj := lang.NewSymbol("obj") + sym_object_DASH_array := lang.NewSymbol("object-array") + sym_odd_QMARK_ := lang.NewSymbol("odd?") + sym_oldform := lang.NewSymbol("oldform") + sym_oldval := lang.NewSymbol("oldval") + sym_op := lang.NewSymbol("op") + sym_options := lang.NewSymbol("options") + sym_opts := lang.NewSymbol("opts") + sym_opts_PLUS_sigs := lang.NewSymbol("opts+sigs") + sym_or := lang.NewSymbol("or") + sym_or__0__auto__ := lang.NewSymbol("or__0__auto__") + sym_p := lang.NewSymbol("p") + sym_p1 := lang.NewSymbol("p1") + sym_p2 := lang.NewSymbol("p2") + sym_p3 := lang.NewSymbol("p3") + sym_p__0__auto__ := lang.NewSymbol("p__0__auto__") + sym_pad := lang.NewSymbol("pad") + sym_pairs := lang.NewSymbol("pairs") + sym_params := lang.NewSymbol("params") + sym_params_STAR_ := lang.NewSymbol("params*") + sym_parent := lang.NewSymbol("parent") + sym_parents := lang.NewSymbol("parents") + sym_parse_DASH_boolean := lang.NewSymbol("parse-boolean") + sym_parse_DASH_double := lang.NewSymbol("parse-double") + sym_parse_DASH_impls := lang.NewSymbol("parse-impls") + sym_parse_DASH_long := lang.NewSymbol("parse-long") + sym_parse_DASH_uuid := lang.NewSymbol("parse-uuid") + sym_parsing_DASH_err := lang.NewSymbol("parsing-err") + sym_partial := lang.NewSymbol("partial") + sym_partition := lang.NewSymbol("partition") + sym_partition_DASH_all := lang.NewSymbol("partition-all") + sym_partition_DASH_by := lang.NewSymbol("partition-by") + sym_partitionv := lang.NewSymbol("partitionv") + sym_partitionv_DASH_all := lang.NewSymbol("partitionv-all") + sym_path := lang.NewSymbol("path") + sym_paths := lang.NewSymbol("paths") + sym_pcalls := lang.NewSymbol("pcalls") + sym_peek := lang.NewSymbol("peek") + sym_persistent_BANG_ := lang.NewSymbol("persistent!") + sym_pmap := lang.NewSymbol("pmap") + sym_pop := lang.NewSymbol("pop") + sym_pop_BANG_ := lang.NewSymbol("pop!") + sym_pop_DASH_thread_DASH_bindings := lang.NewSymbol("pop-thread-bindings") + sym_pos_DASH_int_QMARK_ := lang.NewSymbol("pos-int?") + sym_pos_QMARK_ := lang.NewSymbol("pos?") + sym_pr := lang.NewSymbol("pr") + sym_pr_DASH_on := lang.NewSymbol("pr-on") + sym_pr_DASH_str := lang.NewSymbol("pr-str") + sym_precision := lang.NewSymbol("precision") + sym_pred := lang.NewSymbol("pred") + sym_prefer_DASH_method := lang.NewSymbol("prefer-method") + sym_prefers := lang.NewSymbol("prefers") + sym_prefix := lang.NewSymbol("prefix") + sym_prefix_DASH_string := lang.NewSymbol("prefix-string") + sym_prep_DASH_hashes := lang.NewSymbol("prep-hashes") + sym_prep_DASH_ints := lang.NewSymbol("prep-ints") + sym_prependss := lang.NewSymbol("prependss") + sym_prepost_DASH_map_QMARK_ := lang.NewSymbol("prepost-map?") + sym_preserving_DASH_reduced := lang.NewSymbol("preserving-reduced") + sym_print := lang.NewSymbol("print") + sym_print_DASH_args := lang.NewSymbol("print-args") + sym_print_DASH_ctor := lang.NewSymbol("print-ctor") + sym_print_DASH_dup := lang.NewSymbol("print-dup") + sym_print_DASH_initialized := lang.NewSymbol("print-initialized") + sym_print_DASH_map := lang.NewSymbol("print-map") + sym_print_DASH_meta := lang.NewSymbol("print-meta") + sym_print_DASH_method := lang.NewSymbol("print-method") + sym_print_DASH_object := lang.NewSymbol("print-object") + sym_print_DASH_one := lang.NewSymbol("print-one") + sym_print_DASH_prefix_DASH_map := lang.NewSymbol("print-prefix-map") + sym_print_DASH_sequential := lang.NewSymbol("print-sequential") + sym_print_DASH_simple := lang.NewSymbol("print-simple") + sym_print_DASH_str := lang.NewSymbol("print-str") + sym_print_DASH_tagged_DASH_object := lang.NewSymbol("print-tagged-object") + sym_print_DASH_throwable := lang.NewSymbol("print-throwable") + sym_printf := lang.NewSymbol("printf") + sym_println := lang.NewSymbol("println") + sym_println_DASH_str := lang.NewSymbol("println-str") + sym_prn := lang.NewSymbol("prn") + sym_prn_DASH_str := lang.NewSymbol("prn-str") + sym_prob := lang.NewSymbol("prob") + sym_proc := lang.NewSymbol("proc") + sym_promise := lang.NewSymbol("promise") + sym_proto_PLUS_mmaps := lang.NewSymbol("proto+mmaps") + sym_protocol_QMARK_ := lang.NewSymbol("protocol?") + sym_ps := lang.NewSymbol("ps") + sym_push_DASH_thread_DASH_bindings := lang.NewSymbol("push-thread-bindings") + sym_pvalues := lang.NewSymbol("pvalues") + sym_qualified_DASH_ident_QMARK_ := lang.NewSymbol("qualified-ident?") + sym_qualified_DASH_keyword_QMARK_ := lang.NewSymbol("qualified-keyword?") + sym_qualified_DASH_symbol_QMARK_ := lang.NewSymbol("qualified-symbol?") + sym_quot := lang.NewSymbol("quot") + sym_quote := lang.NewSymbol("quote") + sym_r := lang.NewSymbol("r") + sym_rand := lang.NewSymbol("rand") + sym_rand_DASH_int := lang.NewSymbol("rand-int") + sym_rand_DASH_nth := lang.NewSymbol("rand-nth") + sym_random_DASH_sample := lang.NewSymbol("random-sample") + sym_random_DASH_uuid := lang.NewSymbol("random-uuid") + sym_range := lang.NewSymbol("range") + sym_ratio_QMARK_ := lang.NewSymbol("ratio?") + sym_rational_QMARK_ := lang.NewSymbol("rational?") + sym_rationalize := lang.NewSymbol("rationalize") + sym_rdr := lang.NewSymbol("rdr") + sym_re := lang.NewSymbol("re") + sym_re_DASH_find := lang.NewSymbol("re-find") + sym_re_DASH_groups := lang.NewSymbol("re-groups") + sym_re_DASH_matcher := lang.NewSymbol("re-matcher") + sym_re_DASH_matches := lang.NewSymbol("re-matches") + sym_re_DASH_pattern := lang.NewSymbol("re-pattern") + sym_re_DASH_seq := lang.NewSymbol("re-seq") + sym_read := lang.NewSymbol("read") + sym_read_PLUS_string := lang.NewSymbol("read+string") + sym_read_DASH_line := lang.NewSymbol("read-line") + sym_read_DASH_string := lang.NewSymbol("read-string") + sym_reader := lang.NewSymbol("reader") + sym_reader_DASH_conditional := lang.NewSymbol("reader-conditional") + sym_reader_DASH_conditional_QMARK_ := lang.NewSymbol("reader-conditional?") + sym_realized_QMARK_ := lang.NewSymbol("realized?") + sym_recur := lang.NewSymbol("recur") + sym_recursive_QMARK_ := lang.NewSymbol("recursive?") + sym_reduce := lang.NewSymbol("reduce") + sym_reduce_DASH_kv := lang.NewSymbol("reduce-kv") + sym_reduce1 := lang.NewSymbol("reduce1") + sym_reduced := lang.NewSymbol("reduced") + sym_reduced_QMARK_ := lang.NewSymbol("reduced?") + sym_reductions := lang.NewSymbol("reductions") + sym_ref := lang.NewSymbol("ref") + sym_ref_DASH_history_DASH_count := lang.NewSymbol("ref-history-count") + sym_ref_DASH_max_DASH_history := lang.NewSymbol("ref-max-history") + sym_ref_DASH_min_DASH_history := lang.NewSymbol("ref-min-history") + sym_ref_DASH_set := lang.NewSymbol("ref-set") + sym_refer := lang.NewSymbol("refer") + sym_refer_DASH_glojure := lang.NewSymbol("refer-glojure") + sym_reference := lang.NewSymbol("reference") + sym_references_STAR_ := lang.NewSymbol("references*") + sym_release_DASH_pending_DASH_sends := lang.NewSymbol("release-pending-sends") + sym_rem := lang.NewSymbol("rem") + sym_remove := lang.NewSymbol("remove") + sym_remove_DASH_all_DASH_methods := lang.NewSymbol("remove-all-methods") + sym_remove_DASH_method := lang.NewSymbol("remove-method") + sym_remove_DASH_ns := lang.NewSymbol("remove-ns") + sym_remove_DASH_tap := lang.NewSymbol("remove-tap") + sym_remove_DASH_watch := lang.NewSymbol("remove-watch") + sym_rep := lang.NewSymbol("rep") + sym_repeat := lang.NewSymbol("repeat") + sym_repeatedly := lang.NewSymbol("repeatedly") + sym_replace := lang.NewSymbol("replace") + sym_replicate := lang.NewSymbol("replicate") + sym_require := lang.NewSymbol("require") + sym_requiring_DASH_resolve := lang.NewSymbol("requiring-resolve") + sym_reset_BANG_ := lang.NewSymbol("reset!") + sym_reset_DASH_meta_BANG_ := lang.NewSymbol("reset-meta!") + sym_reset_DASH_vals_BANG_ := lang.NewSymbol("reset-vals!") + sym_resolve := lang.NewSymbol("resolve") + sym_rest := lang.NewSymbol("rest") + sym_restart_DASH_agent := lang.NewSymbol("restart-agent") + sym_resultset_DASH_seq := lang.NewSymbol("resultset-seq") + sym_ret := lang.NewSymbol("ret") + sym_ret__1__auto__ := lang.NewSymbol("ret__1__auto__") + sym_retf := lang.NewSymbol("retf") + sym_rev := lang.NewSymbol("rev") + sym_reverse := lang.NewSymbol("reverse") + sym_reversible_QMARK_ := lang.NewSymbol("reversible?") + sym_rf := lang.NewSymbol("rf") + sym_root := lang.NewSymbol("root") + sym_root_DASH_directory := lang.NewSymbol("root-directory") + sym_root_DASH_resource := lang.NewSymbol("root-resource") + sym_rs := lang.NewSymbol("rs") + sym_rseq := lang.NewSymbol("rseq") + sym_rsubseq := lang.NewSymbol("rsubseq") + sym_run_BANG_ := lang.NewSymbol("run!") + sym_s := lang.NewSymbol("s") + sym_s__0__auto__ := lang.NewSymbol("s__0__auto__") + sym_sc := lang.NewSymbol("sc") + sym_second := lang.NewSymbol("second") + sym_select_DASH_keys := lang.NewSymbol("select-keys") + sym_send := lang.NewSymbol("send") + sym_send_DASH_off := lang.NewSymbol("send-off") + sym_send_DASH_via := lang.NewSymbol("send-via") + sym_sep := lang.NewSymbol("sep") + sym_seq := lang.NewSymbol("seq") + sym_seq_DASH_exprs := lang.NewSymbol("seq-exprs") + sym_seq_DASH_reduce := lang.NewSymbol("seq-reduce") + sym_seq_DASH_to_DASH_map_DASH_for_DASH_destructuring := lang.NewSymbol("seq-to-map-for-destructuring") + sym_seq_QMARK_ := lang.NewSymbol("seq?") + sym_seqable_QMARK_ := lang.NewSymbol("seqable?") + sym_seque := lang.NewSymbol("seque") + sym_sequence := lang.NewSymbol("sequence") + sym_sequential_QMARK_ := lang.NewSymbol("sequential?") + sym_serialized_DASH_require := lang.NewSymbol("serialized-require") + sym_set := lang.NewSymbol("set") + sym_set_DASH_agent_DASH_send_DASH_executor_BANG_ := lang.NewSymbol("set-agent-send-executor!") + sym_set_DASH_agent_DASH_send_DASH_off_DASH_executor_BANG_ := lang.NewSymbol("set-agent-send-off-executor!") + sym_set_DASH_error_DASH_handler_BANG_ := lang.NewSymbol("set-error-handler!") + sym_set_DASH_error_DASH_mode_BANG_ := lang.NewSymbol("set-error-mode!") + sym_set_DASH_validator_BANG_ := lang.NewSymbol("set-validator!") + sym_set_QMARK_ := lang.NewSymbol("set?") + sym_setDynamic := lang.NewSymbol("setDynamic") + sym_setup_DASH_reference := lang.NewSymbol("setup-reference") + sym_shift := lang.NewSymbol("shift") + sym_shift_DASH_mask := lang.NewSymbol("shift-mask") + sym_short := lang.NewSymbol("short") + sym_short_DASH_array := lang.NewSymbol("short-array") + sym_shortCast := lang.NewSymbol("shortCast") + sym_shorts := lang.NewSymbol("shorts") + sym_shuffle := lang.NewSymbol("shuffle") + sym_shutdown_DASH_agents := lang.NewSymbol("shutdown-agents") + sym_sigs := lang.NewSymbol("sigs") + sym_simple_DASH_ident_QMARK_ := lang.NewSymbol("simple-ident?") + sym_simple_DASH_keyword_QMARK_ := lang.NewSymbol("simple-keyword?") + sym_simple_DASH_symbol_QMARK_ := lang.NewSymbol("simple-symbol?") + sym_size := lang.NewSymbol("size") + sym_size_DASH_or_DASH_seq := lang.NewSymbol("size-or-seq") + sym_size__1__auto__ := lang.NewSymbol("size__1__auto__") + sym_slurp := lang.NewSymbol("slurp") + sym_smap := lang.NewSymbol("smap") + sym_some := lang.NewSymbol("some") + sym_some_DASH__GT_ := lang.NewSymbol("some->") + sym_some_DASH__GT__GT_ := lang.NewSymbol("some->>") + sym_some_DASH_fn := lang.NewSymbol("some-fn") + sym_some_QMARK_ := lang.NewSymbol("some?") + sym_somef := lang.NewSymbol("somef") + sym_sort := lang.NewSymbol("sort") + sym_sort_DASH_by := lang.NewSymbol("sort-by") + sym_sorted_DASH_map := lang.NewSymbol("sorted-map") + sym_sorted_DASH_map_DASH_by := lang.NewSymbol("sorted-map-by") + sym_sorted_DASH_set := lang.NewSymbol("sorted-set") + sym_sorted_DASH_set_DASH_by := lang.NewSymbol("sorted-set-by") + sym_sorted_QMARK_ := lang.NewSymbol("sorted?") + sym_special_DASH_symbol_QMARK_ := lang.NewSymbol("special-symbol?") + sym_specs := lang.NewSymbol("specs") + sym_spit := lang.NewSymbol("spit") + sym_splicing_QMARK_ := lang.NewSymbol("splicing?") + sym_split_DASH_at := lang.NewSymbol("split-at") + sym_split_DASH_with := lang.NewSymbol("split-with") + sym_splitv_DASH_at := lang.NewSymbol("splitv-at") + sym_spread := lang.NewSymbol("spread") + sym_start := lang.NewSymbol("start") + sym_start_DASH_key := lang.NewSymbol("start-key") + sym_start_DASH_test := lang.NewSymbol("start-test") + sym_start__0__auto__ := lang.NewSymbol("start__0__auto__") + sym_state := lang.NewSymbol("state") + sym_step := lang.NewSymbol("step") + sym_str := lang.NewSymbol("str") + sym_stream := lang.NewSymbol("stream") + sym_stream_DASH_into_BANG_ := lang.NewSymbol("stream-into!") + sym_stream_DASH_reduce_BANG_ := lang.NewSymbol("stream-reduce!") + sym_stream_DASH_seq_BANG_ := lang.NewSymbol("stream-seq!") + sym_stream_DASH_transduce_BANG_ := lang.NewSymbol("stream-transduce!") + sym_string_QMARK_ := lang.NewSymbol("string?") + sym_strings_DOT_Builder := lang.NewSymbol("strings.Builder") + sym_strip_DASH_ns := lang.NewSymbol("strip-ns") + sym_struct := lang.NewSymbol("struct") + sym_struct_DASH_map := lang.NewSymbol("struct-map") + sym_subs := lang.NewSymbol("subs") + sym_subseq := lang.NewSymbol("subseq") + sym_subvec := lang.NewSymbol("subvec") + sym_supers := lang.NewSymbol("supers") + sym_swap_BANG_ := lang.NewSymbol("swap!") + sym_swap_DASH_vals_BANG_ := lang.NewSymbol("swap-vals!") + sym_sym := lang.NewSymbol("sym") + sym_symbol := lang.NewSymbol("symbol") + sym_symbol_QMARK_ := lang.NewSymbol("symbol?") + sym_sync := lang.NewSymbol("sync") + sym_system_DASH_newline := lang.NewSymbol("system-newline") + sym_t := lang.NewSymbol("t") + sym_tag := lang.NewSymbol("tag") + sym_tagged_DASH_literal := lang.NewSymbol("tagged-literal") + sym_tagged_DASH_literal_QMARK_ := lang.NewSymbol("tagged-literal?") + sym_take := lang.NewSymbol("take") + sym_take_DASH_last := lang.NewSymbol("take-last") + sym_take_DASH_nth := lang.NewSymbol("take-nth") + sym_take_DASH_while := lang.NewSymbol("take-while") + sym_tapset := lang.NewSymbol("tapset") + sym_temp__0__auto__ := lang.NewSymbol("temp__0__auto__") + sym_test := lang.NewSymbol("test") + sym_test_DASH_f := lang.NewSymbol("test-f") + sym_tests := lang.NewSymbol("tests") + sym_the_DASH_ns := lang.NewSymbol("the-ns") + sym_then := lang.NewSymbol("then") + sym_thens := lang.NewSymbol("thens") + sym_this := lang.NewSymbol("this") + sym_thread_DASH_bound_QMARK_ := lang.NewSymbol("thread-bound?") + sym_throw := lang.NewSymbol("throw") + sym_throw_DASH_if := lang.NewSymbol("throw-if") + sym_time := lang.NewSymbol("time") + sym_time_DOT_Now := lang.NewSymbol("time.Now") + sym_timeout_DASH_ms := lang.NewSymbol("timeout-ms") + sym_timeout_DASH_val := lang.NewSymbol("timeout-val") + sym_to := lang.NewSymbol("to") + sym_to_DASH_array := lang.NewSymbol("to-array") + sym_to_DASH_array_DASH_2d := lang.NewSymbol("to-array-2d") + sym_trampoline := lang.NewSymbol("trampoline") + sym_transduce := lang.NewSymbol("transduce") + sym_transient := lang.NewSymbol("transient") + sym_tree_DASH_seq := lang.NewSymbol("tree-seq") + sym_true_QMARK_ := lang.NewSymbol("true?") + sym_try := lang.NewSymbol("try") + sym_type := lang.NewSymbol("type") + sym_unchecked_DASH_add := lang.NewSymbol("unchecked-add") + sym_unchecked_DASH_add_DASH_int := lang.NewSymbol("unchecked-add-int") + sym_unchecked_DASH_byte := lang.NewSymbol("unchecked-byte") + sym_unchecked_DASH_char := lang.NewSymbol("unchecked-char") + sym_unchecked_DASH_dec := lang.NewSymbol("unchecked-dec") + sym_unchecked_DASH_dec_DASH_int := lang.NewSymbol("unchecked-dec-int") + sym_unchecked_DASH_divide_DASH_int := lang.NewSymbol("unchecked-divide-int") + sym_unchecked_DASH_double := lang.NewSymbol("unchecked-double") + sym_unchecked_DASH_float := lang.NewSymbol("unchecked-float") + sym_unchecked_DASH_inc := lang.NewSymbol("unchecked-inc") + sym_unchecked_DASH_inc_DASH_int := lang.NewSymbol("unchecked-inc-int") + sym_unchecked_DASH_int := lang.NewSymbol("unchecked-int") + sym_unchecked_DASH_long := lang.NewSymbol("unchecked-long") + sym_unchecked_DASH_multiply := lang.NewSymbol("unchecked-multiply") + sym_unchecked_DASH_multiply_DASH_int := lang.NewSymbol("unchecked-multiply-int") + sym_unchecked_DASH_negate := lang.NewSymbol("unchecked-negate") + sym_unchecked_DASH_negate_DASH_int := lang.NewSymbol("unchecked-negate-int") + sym_unchecked_DASH_op := lang.NewSymbol("unchecked-op") + sym_unchecked_DASH_remainder_DASH_int := lang.NewSymbol("unchecked-remainder-int") + sym_unchecked_DASH_short := lang.NewSymbol("unchecked-short") + sym_unchecked_DASH_subtract := lang.NewSymbol("unchecked-subtract") + sym_unchecked_DASH_subtract_DASH_int := lang.NewSymbol("unchecked-subtract-int") + sym_uncheckedByteCast := lang.NewSymbol("uncheckedByteCast") + sym_uncheckedCharCast := lang.NewSymbol("uncheckedCharCast") + sym_uncheckedFloatCast := lang.NewSymbol("uncheckedFloatCast") + sym_uncheckedIntCast := lang.NewSymbol("uncheckedIntCast") + sym_uncheckedShortCast := lang.NewSymbol("uncheckedShortCast") + sym_unchecked_add := lang.NewSymbol("unchecked_add") + sym_unchecked_dec := lang.NewSymbol("unchecked_dec") + sym_unchecked_inc := lang.NewSymbol("unchecked_inc") + sym_unchecked_minus := lang.NewSymbol("unchecked_minus") + sym_unchecked_multiply := lang.NewSymbol("unchecked_multiply") + sym_underive := lang.NewSymbol("underive") + sym_unquote := lang.NewSymbol("unquote") + sym_unquote_DASH_splicing := lang.NewSymbol("unquote-splicing") + sym_unreduced := lang.NewSymbol("unreduced") + sym_unsigned_DASH_bit_DASH_shift_DASH_right := lang.NewSymbol("unsigned-bit-shift-right") + sym_update := lang.NewSymbol("update") + sym_update_DASH_in := lang.NewSymbol("update-in") + sym_update_DASH_keys := lang.NewSymbol("update-keys") + sym_update_DASH_vals := lang.NewSymbol("update-vals") + sym_uri_QMARK_ := lang.NewSymbol("uri?") + sym_url := lang.NewSymbol("url") + sym_use := lang.NewSymbol("use") + sym_user := lang.NewSymbol("user") + sym_uuid_QMARK_ := lang.NewSymbol("uuid?") + sym_v := lang.NewSymbol("v") + sym_v__0__auto__ := lang.NewSymbol("v__0__auto__") + sym_val := lang.NewSymbol("val") + sym_val__2__auto__ := lang.NewSymbol("val__2__auto__") + sym_valid_DASH_keys := lang.NewSymbol("valid-keys") + sym_validator_DASH_fn := lang.NewSymbol("validator-fn") + sym_vals := lang.NewSymbol("vals") + sym_value := lang.NewSymbol("value") + sym_var := lang.NewSymbol("var") + sym_var_DASH_get := lang.NewSymbol("var-get") + sym_var_DASH_set := lang.NewSymbol("var-set") + sym_var_QMARK_ := lang.NewSymbol("var?") + sym_vars := lang.NewSymbol("vars") + sym_vary_DASH_meta := lang.NewSymbol("vary-meta") + sym_vec := lang.NewSymbol("vec") + sym_vector := lang.NewSymbol("vector") + sym_vector_QMARK_ := lang.NewSymbol("vector?") + sym_vf := lang.NewSymbol("vf") + sym_vol := lang.NewSymbol("vol") + sym_volatile_BANG_ := lang.NewSymbol("volatile!") + sym_volatile_QMARK_ := lang.NewSymbol("volatile?") + sym_vreset_BANG_ := lang.NewSymbol("vreset!") + sym_vswap_BANG_ := lang.NewSymbol("vswap!") + sym_w := lang.NewSymbol("w") + sym_when := lang.NewSymbol("when") + sym_when_DASH_first := lang.NewSymbol("when-first") + sym_when_DASH_let := lang.NewSymbol("when-let") + sym_when_DASH_not := lang.NewSymbol("when-not") + sym_when_DASH_some := lang.NewSymbol("when-some") + sym_while := lang.NewSymbol("while") + sym_with_DASH_bindings := lang.NewSymbol("with-bindings") + sym_with_DASH_bindings_STAR_ := lang.NewSymbol("with-bindings*") + sym_with_DASH_in_DASH_str := lang.NewSymbol("with-in-str") + sym_with_DASH_loading_DASH_context := lang.NewSymbol("with-loading-context") + sym_with_DASH_local_DASH_vars := lang.NewSymbol("with-local-vars") + sym_with_DASH_meta := lang.NewSymbol("with-meta") + sym_with_DASH_open := lang.NewSymbol("with-open") + sym_with_DASH_out_DASH_str := lang.NewSymbol("with-out-str") + sym_with_DASH_precision := lang.NewSymbol("with-precision") + sym_with_DASH_redefs := lang.NewSymbol("with-redefs") + sym_with_DASH_redefs_DASH_fn := lang.NewSymbol("with-redefs-fn") + sym_x := lang.NewSymbol("x") + sym_xform := lang.NewSymbol("xform") + sym_xml_DASH_seq := lang.NewSymbol("xml-seq") + sym_xor := lang.NewSymbol("xor") + sym_xs := lang.NewSymbol("xs") + sym_xs__0__auto__ := lang.NewSymbol("xs__0__auto__") + sym_y := lang.NewSymbol("y") + sym_ys := lang.NewSymbol("ys") + sym_z := lang.NewSymbol("z") + sym_zero_QMARK_ := lang.NewSymbol("zero?") + sym_zipmap := lang.NewSymbol("zipmap") + sym_zs := lang.NewSymbol("zs") + kw__GT__GT_ := lang.NewKeyword(">>") + kw_added := lang.NewKeyword("added") + kw_all := lang.NewKeyword("all") + kw_allow := lang.NewKeyword("allow") + kw_ancestors := lang.NewKeyword("ancestors") + kw_arglists := lang.NewKeyword("arglists") + kw_as := lang.NewKeyword("as") + kw_as_DASH_alias := lang.NewKeyword("as-alias") + kw_at := lang.NewKeyword("at") + kw_cause := lang.NewKeyword("cause") + kw_clear_DASH_actions := lang.NewKeyword("clear-actions") + kw_coll_DASH_reduce := lang.NewKeyword("coll-reduce") + kw_column := lang.NewKeyword("column") + kw_compact := lang.NewKeyword("compact") + kw_conflict := lang.NewKeyword("conflict") + kw_content := lang.NewKeyword("content") + kw_continue := lang.NewKeyword("continue") + kw_data := lang.NewKeyword("data") + kw_datafy := lang.NewKeyword("datafy") + kw_declared := lang.NewKeyword("declared") + kw_default := lang.NewKeyword("default") + kw_deprecated := lang.NewKeyword("deprecated") + kw_descendants := lang.NewKeyword("descendants") + kw_doc := lang.NewKeyword("doc") + kw_dynamic := lang.NewKeyword("dynamic") + kw_else := lang.NewKeyword("else") + kw_encoding := lang.NewKeyword("encoding") + kw_end_DASH_column := lang.NewKeyword("end-column") + kw_end_DASH_line := lang.NewKeyword("end-line") + kw_eof := lang.NewKeyword("eof") + kw_error_DASH_handler := lang.NewKeyword("error-handler") + kw_error_DASH_mode := lang.NewKeyword("error-mode") + kw_exclude := lang.NewKeyword("exclude") + kw_fail := lang.NewKeyword("fail") + kw_failed := lang.NewKeyword("failed") + kw_file := lang.NewKeyword("file") + kw_form := lang.NewKeyword("form") + kw_forms := lang.NewKeyword("forms") + kw_gen_DASH_class := lang.NewKeyword("gen-class") + kw_glojure_DOT_core_SLASH_halt := lang.NewKeyword("glojure.core/halt") + kw_glojure_DOT_core_SLASH_none := lang.NewKeyword("glojure.core/none") + kw_glojure_DOT_error_SLASH_phase := lang.NewKeyword("glojure.error/phase") + kw_hash_DASH_equiv := lang.NewKeyword("hash-equiv") + kw_hash_DASH_identity := lang.NewKeyword("hash-identity") + kw_hashes := lang.NewKeyword("hashes") + kw_hierarchy := lang.NewKeyword("hierarchy") + kw_identity := lang.NewKeyword("identity") + kw_impl_DASH_ns := lang.NewKeyword("impl-ns") + kw_initk := lang.NewKeyword("initk") + kw_inline := lang.NewKeyword("inline") + kw_inline_DASH_arities := lang.NewKeyword("inline-arities") + kw_int := lang.NewKeyword("int") + kw_internal_DASH_reduce := lang.NewKeyword("internal-reduce") + kw_ints := lang.NewKeyword("ints") + kw_keys := lang.NewKeyword("keys") + kw_kf := lang.NewKeyword("kf") + kw_kv_DASH_reduce := lang.NewKeyword("kv-reduce") + kw_let := lang.NewKeyword("let") + kw_line := lang.NewKeyword("line") + kw_macro := lang.NewKeyword("macro") + kw_main := lang.NewKeyword("main") + kw_mappings := lang.NewKeyword("mappings") + kw_max_DASH_history := lang.NewKeyword("max-history") + kw_message := lang.NewKeyword("message") + kw_meta := lang.NewKeyword("meta") + kw_min_DASH_history := lang.NewKeyword("min-history") + kw_multis := lang.NewKeyword("multis") + kw_name := lang.NewKeyword("name") + kw_nav := lang.NewKeyword("nav") + kw_no_DASH_test := lang.NewKeyword("no-test") + kw_ns := lang.NewKeyword("ns") + kw_ok := lang.NewKeyword("ok") + kw_on_DASH_interface := lang.NewKeyword("on-interface") + kw_only := lang.NewKeyword("only") + kw_or := lang.NewKeyword("or") + kw_parents := lang.NewKeyword("parents") + kw_pending := lang.NewKeyword("pending") + kw_phase := lang.NewKeyword("phase") + kw_post := lang.NewKeyword("post") + kw_pre := lang.NewKeyword("pre") + kw_private := lang.NewKeyword("private") + kw_read_DASH_cond := lang.NewKeyword("read-cond") + kw_ready := lang.NewKeyword("ready") + kw_redef := lang.NewKeyword("redef") + kw_refer := lang.NewKeyword("refer") + kw_refer_DASH_glojure := lang.NewKeyword("refer-glojure") + kw_reload := lang.NewKeyword("reload") + kw_reload_DASH_all := lang.NewKeyword("reload-all") + kw_rename := lang.NewKeyword("rename") + kw_require := lang.NewKeyword("require") + kw_rettag := lang.NewKeyword("rettag") + kw_rounding := lang.NewKeyword("rounding") + kw_sigs := lang.NewKeyword("sigs") + kw_somef := lang.NewKeyword("somef") + kw_sparse := lang.NewKeyword("sparse") + kw_special_DASH_form := lang.NewKeyword("special-form") + kw_static := lang.NewKeyword("static") + kw_status := lang.NewKeyword("status") + kw_tag := lang.NewKeyword("tag") + kw_test := lang.NewKeyword("test") + kw_trace := lang.NewKeyword("trace") + kw_type := lang.NewKeyword("type") + kw_url := lang.NewKeyword("url") + kw_use := lang.NewKeyword("use") + kw_val := lang.NewKeyword("val") + kw_validator := lang.NewKeyword("validator") + kw_verbose := lang.NewKeyword("verbose") + kw_vf := lang.NewKeyword("vf") + kw_via := lang.NewKeyword("via") + kw_when := lang.NewKeyword("when") + kw_while := lang.NewKeyword("while") + // var glojure.core.protocols/coll-reduce + var_glojure_DOT_core_DOT_protocols_coll_DASH_reduce := lang.InternVarName(sym_glojure_DOT_core_DOT_protocols, sym_coll_DASH_reduce) + // var glojure.core.protocols/interface-or-naive-reduce + var_glojure_DOT_core_DOT_protocols_interface_DASH_or_DASH_naive_DASH_reduce := lang.InternVarName(sym_glojure_DOT_core_DOT_protocols, sym_interface_DASH_or_DASH_naive_DASH_reduce) + // var glojure.core.protocols/kv-reduce + var_glojure_DOT_core_DOT_protocols_kv_DASH_reduce := lang.InternVarName(sym_glojure_DOT_core_DOT_protocols, sym_kv_DASH_reduce) + // var glojure.core.protocols/seq-reduce + var_glojure_DOT_core_DOT_protocols_seq_DASH_reduce := lang.InternVarName(sym_glojure_DOT_core_DOT_protocols, sym_seq_DASH_reduce) + // var glojure.core/NaN? + var_glojure_DOT_core_NaN_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_NaN_QMARK_) + // var glojure.core/StackTraceElement->vec + var_glojure_DOT_core_StackTraceElement_DASH__GT_vec := lang.InternVarName(sym_glojure_DOT_core, sym_StackTraceElement_DASH__GT_vec) + // var glojure.core/Throwable->map + var_glojure_DOT_core_Throwable_DASH__GT_map := lang.InternVarName(sym_glojure_DOT_core, sym_Throwable_DASH__GT_map) + // var glojure.core/- + var_glojure_DOT_core__DASH_ := lang.InternVarName(sym_glojure_DOT_core, sym__DASH_) + // var glojure.core/-> + var_glojure_DOT_core__DASH__GT_ := lang.InternVarName(sym_glojure_DOT_core, sym__DASH__GT_) + // var glojure.core/->> + var_glojure_DOT_core__DASH__GT__GT_ := lang.InternVarName(sym_glojure_DOT_core, sym__DASH__GT__GT_) + // var glojure.core/-' + var_glojure_DOT_core__DASH__TICK_ := lang.InternVarName(sym_glojure_DOT_core, sym__DASH__TICK_) + // var glojure.core/-protocols + var_glojure_DOT_core__DASH_protocols := lang.InternVarName(sym_glojure_DOT_core, sym__DASH_protocols) + // var glojure.core/.. + var_glojure_DOT_core__DOT__DOT_ := lang.InternVarName(sym_glojure_DOT_core, sym__DOT__DOT_) + // var glojure.core/= + var_glojure_DOT_core__EQ_ := lang.InternVarName(sym_glojure_DOT_core, sym__EQ_) + // var glojure.core/== + var_glojure_DOT_core__EQ__EQ_ := lang.InternVarName(sym_glojure_DOT_core, sym__EQ__EQ_) + // var glojure.core/> + var_glojure_DOT_core__GT_ := lang.InternVarName(sym_glojure_DOT_core, sym__GT_) + // var glojure.core/>0? + var_glojure_DOT_core__GT_0_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym__GT_0_QMARK_) + // var glojure.core/>1? + var_glojure_DOT_core__GT_1_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym__GT_1_QMARK_) + // var glojure.core/>= + var_glojure_DOT_core__GT__EQ_ := lang.InternVarName(sym_glojure_DOT_core, sym__GT__EQ_) + // var glojure.core/< + var_glojure_DOT_core__LT_ := lang.InternVarName(sym_glojure_DOT_core, sym__LT_) + // var glojure.core/<= + var_glojure_DOT_core__LT__EQ_ := lang.InternVarName(sym_glojure_DOT_core, sym__LT__EQ_) + // var glojure.core/+ + var_glojure_DOT_core__PLUS_ := lang.InternVarName(sym_glojure_DOT_core, sym__PLUS_) + // var glojure.core/+' + var_glojure_DOT_core__PLUS__TICK_ := lang.InternVarName(sym_glojure_DOT_core, sym__PLUS__TICK_) + // var glojure.core// + var_glojure_DOT_core__SLASH_ := lang.InternVarName(sym_glojure_DOT_core, sym__SLASH_) + // var glojure.core/* + var_glojure_DOT_core__STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_) + // var glojure.core/*1 + var_glojure_DOT_core__STAR_1 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_1) + // var glojure.core/*2 + var_glojure_DOT_core__STAR_2 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_2) + // var glojure.core/*3 + var_glojure_DOT_core__STAR_3 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_3) + // var glojure.core/*' + var_glojure_DOT_core__STAR__TICK_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR__TICK_) + // var glojure.core/*agent* + var_glojure_DOT_core__STAR_agent_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_agent_STAR_) + // var glojure.core/*assert* + var_glojure_DOT_core__STAR_assert_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_assert_STAR_) + // var glojure.core/*command-line-args* + var_glojure_DOT_core__STAR_command_DASH_line_DASH_args_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_command_DASH_line_DASH_args_STAR_) + // var glojure.core/*compile-files* + var_glojure_DOT_core__STAR_compile_DASH_files_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_compile_DASH_files_STAR_) + // var glojure.core/*compile-path* + var_glojure_DOT_core__STAR_compile_DASH_path_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_compile_DASH_path_STAR_) + // var glojure.core/*compiler-options* + var_glojure_DOT_core__STAR_compiler_DASH_options_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_compiler_DASH_options_STAR_) + // var glojure.core/*data-readers* + var_glojure_DOT_core__STAR_data_DASH_readers_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_data_DASH_readers_STAR_) + // var glojure.core/*default-data-reader-fn* + var_glojure_DOT_core__STAR_default_DASH_data_DASH_reader_DASH_fn_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_default_DASH_data_DASH_reader_DASH_fn_STAR_) + // var glojure.core/*e + var_glojure_DOT_core__STAR_e := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_e) + // var glojure.core/*err* + var_glojure_DOT_core__STAR_err_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_err_STAR_) + // var glojure.core/*file* + var_glojure_DOT_core__STAR_file_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_file_STAR_) + // var glojure.core/*flush-on-newline* + var_glojure_DOT_core__STAR_flush_DASH_on_DASH_newline_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_flush_DASH_on_DASH_newline_STAR_) + // var glojure.core/*in* + var_glojure_DOT_core__STAR_in_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_in_STAR_) + // var glojure.core/*loaded-libs* + var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_loaded_DASH_libs_STAR_) + // var glojure.core/*loading-verbosely* + var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_loading_DASH_verbosely_STAR_) + // var glojure.core/*ns* + var_glojure_DOT_core__STAR_ns_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_ns_STAR_) + // var glojure.core/*out* + var_glojure_DOT_core__STAR_out_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) + // var glojure.core/*pending-paths* + var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_pending_DASH_paths_STAR_) + // var glojure.core/*print-dup* + var_glojure_DOT_core__STAR_print_DASH_dup_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_print_DASH_dup_STAR_) + // var glojure.core/*print-length* + var_glojure_DOT_core__STAR_print_DASH_length_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_print_DASH_length_STAR_) + // var glojure.core/*print-level* + var_glojure_DOT_core__STAR_print_DASH_level_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_print_DASH_level_STAR_) + // var glojure.core/*print-meta* + var_glojure_DOT_core__STAR_print_DASH_meta_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_print_DASH_meta_STAR_) + // var glojure.core/*print-namespace-maps* + var_glojure_DOT_core__STAR_print_DASH_namespace_DASH_maps_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_print_DASH_namespace_DASH_maps_STAR_) + // var glojure.core/*print-readably* + var_glojure_DOT_core__STAR_print_DASH_readably_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_print_DASH_readably_STAR_) + // var glojure.core/*read-eval* + var_glojure_DOT_core__STAR_read_DASH_eval_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_read_DASH_eval_STAR_) + // var glojure.core/*repl* + var_glojure_DOT_core__STAR_repl_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_repl_STAR_) + // var glojure.core/*unchecked-math* + var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_unchecked_DASH_math_STAR_) + // var glojure.core/*verbose-defrecords* + var_glojure_DOT_core__STAR_verbose_DASH_defrecords_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_verbose_DASH_defrecords_STAR_) + // var glojure.core/*warn-on-reflection* + var_glojure_DOT_core__STAR_warn_DASH_on_DASH_reflection_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_warn_DASH_on_DASH_reflection_STAR_) + // var glojure.core/abs + var_glojure_DOT_core_abs := lang.InternVarName(sym_glojure_DOT_core, sym_abs) + // var glojure.core/accessor + var_glojure_DOT_core_accessor := lang.InternVarName(sym_glojure_DOT_core, sym_accessor) + // var glojure.core/aclone + var_glojure_DOT_core_aclone := lang.InternVarName(sym_glojure_DOT_core, sym_aclone) + // var glojure.core/add-classpath + var_glojure_DOT_core_add_DASH_classpath := lang.InternVarName(sym_glojure_DOT_core, sym_add_DASH_classpath) + // var glojure.core/add-doc-and-meta + var_glojure_DOT_core_add_DASH_doc_DASH_and_DASH_meta := lang.InternVarName(sym_glojure_DOT_core, sym_add_DASH_doc_DASH_and_DASH_meta) + // var glojure.core/add-watch + var_glojure_DOT_core_add_DASH_watch := lang.InternVarName(sym_glojure_DOT_core, sym_add_DASH_watch) + // var glojure.core/agent + var_glojure_DOT_core_agent := lang.InternVarName(sym_glojure_DOT_core, sym_agent) + // var glojure.core/agent-error + var_glojure_DOT_core_agent_DASH_error := lang.InternVarName(sym_glojure_DOT_core, sym_agent_DASH_error) + // var glojure.core/agent-errors + var_glojure_DOT_core_agent_DASH_errors := lang.InternVarName(sym_glojure_DOT_core, sym_agent_DASH_errors) + // var glojure.core/aget + var_glojure_DOT_core_aget := lang.InternVarName(sym_glojure_DOT_core, sym_aget) + // var glojure.core/alength + var_glojure_DOT_core_alength := lang.InternVarName(sym_glojure_DOT_core, sym_alength) + // var glojure.core/alias + var_glojure_DOT_core_alias := lang.InternVarName(sym_glojure_DOT_core, sym_alias) + // var glojure.core/all-ns + var_glojure_DOT_core_all_DASH_ns := lang.InternVarName(sym_glojure_DOT_core, sym_all_DASH_ns) + // var glojure.core/alter + var_glojure_DOT_core_alter := lang.InternVarName(sym_glojure_DOT_core, sym_alter) + // var glojure.core/alter-meta! + var_glojure_DOT_core_alter_DASH_meta_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_alter_DASH_meta_BANG_) + // var glojure.core/alter-var-root + var_glojure_DOT_core_alter_DASH_var_DASH_root := lang.InternVarName(sym_glojure_DOT_core, sym_alter_DASH_var_DASH_root) + // var glojure.core/amap + var_glojure_DOT_core_amap := lang.InternVarName(sym_glojure_DOT_core, sym_amap) + // var glojure.core/ancestors + var_glojure_DOT_core_ancestors := lang.InternVarName(sym_glojure_DOT_core, sym_ancestors) + // var glojure.core/and + var_glojure_DOT_core_and := lang.InternVarName(sym_glojure_DOT_core, sym_and) + // var glojure.core/any? + var_glojure_DOT_core_any_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_any_QMARK_) + // var glojure.core/apply + var_glojure_DOT_core_apply := lang.InternVarName(sym_glojure_DOT_core, sym_apply) + // var glojure.core/areduce + var_glojure_DOT_core_areduce := lang.InternVarName(sym_glojure_DOT_core, sym_areduce) + // var glojure.core/array + var_glojure_DOT_core_array := lang.InternVarName(sym_glojure_DOT_core, sym_array) + // var glojure.core/array-map + var_glojure_DOT_core_array_DASH_map := lang.InternVarName(sym_glojure_DOT_core, sym_array_DASH_map) + // var glojure.core/as-> + var_glojure_DOT_core_as_DASH__GT_ := lang.InternVarName(sym_glojure_DOT_core, sym_as_DASH__GT_) + // var glojure.core/aset + var_glojure_DOT_core_aset := lang.InternVarName(sym_glojure_DOT_core, sym_aset) + // var glojure.core/aset-boolean + var_glojure_DOT_core_aset_DASH_boolean := lang.InternVarName(sym_glojure_DOT_core, sym_aset_DASH_boolean) + // var glojure.core/aset-byte + var_glojure_DOT_core_aset_DASH_byte := lang.InternVarName(sym_glojure_DOT_core, sym_aset_DASH_byte) + // var glojure.core/aset-char + var_glojure_DOT_core_aset_DASH_char := lang.InternVarName(sym_glojure_DOT_core, sym_aset_DASH_char) + // var glojure.core/aset-double + var_glojure_DOT_core_aset_DASH_double := lang.InternVarName(sym_glojure_DOT_core, sym_aset_DASH_double) + // var glojure.core/aset-float + var_glojure_DOT_core_aset_DASH_float := lang.InternVarName(sym_glojure_DOT_core, sym_aset_DASH_float) + // var glojure.core/aset-int + var_glojure_DOT_core_aset_DASH_int := lang.InternVarName(sym_glojure_DOT_core, sym_aset_DASH_int) + // var glojure.core/aset-long + var_glojure_DOT_core_aset_DASH_long := lang.InternVarName(sym_glojure_DOT_core, sym_aset_DASH_long) + // var glojure.core/aset-short + var_glojure_DOT_core_aset_DASH_short := lang.InternVarName(sym_glojure_DOT_core, sym_aset_DASH_short) + // var glojure.core/assert + var_glojure_DOT_core_assert := lang.InternVarName(sym_glojure_DOT_core, sym_assert) + // var glojure.core/assert-args + var_glojure_DOT_core_assert_DASH_args := lang.InternVarName(sym_glojure_DOT_core, sym_assert_DASH_args) + // var glojure.core/assert-valid-fdecl + var_glojure_DOT_core_assert_DASH_valid_DASH_fdecl := lang.InternVarName(sym_glojure_DOT_core, sym_assert_DASH_valid_DASH_fdecl) + // var glojure.core/assoc + var_glojure_DOT_core_assoc := lang.InternVarName(sym_glojure_DOT_core, sym_assoc) + // var glojure.core/assoc! + var_glojure_DOT_core_assoc_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_assoc_BANG_) + // var glojure.core/assoc-in + var_glojure_DOT_core_assoc_DASH_in := lang.InternVarName(sym_glojure_DOT_core, sym_assoc_DASH_in) + // var glojure.core/associative? + var_glojure_DOT_core_associative_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_associative_QMARK_) + // var glojure.core/atom + var_glojure_DOT_core_atom := lang.InternVarName(sym_glojure_DOT_core, sym_atom) + // var glojure.core/await + var_glojure_DOT_core_await := lang.InternVarName(sym_glojure_DOT_core, sym_await) + // var glojure.core/await1 + var_glojure_DOT_core_await1 := lang.InternVarName(sym_glojure_DOT_core, sym_await1) + // var glojure.core/await-for + var_glojure_DOT_core_await_DASH_for := lang.InternVarName(sym_glojure_DOT_core, sym_await_DASH_for) + // var glojure.core/bases + var_glojure_DOT_core_bases := lang.InternVarName(sym_glojure_DOT_core, sym_bases) + // var glojure.core/bigdec + var_glojure_DOT_core_bigdec := lang.InternVarName(sym_glojure_DOT_core, sym_bigdec) + // var glojure.core/bigint + var_glojure_DOT_core_bigint := lang.InternVarName(sym_glojure_DOT_core, sym_bigint) + // var glojure.core/biginteger + var_glojure_DOT_core_biginteger := lang.InternVarName(sym_glojure_DOT_core, sym_biginteger) + // var glojure.core/binding + var_glojure_DOT_core_binding := lang.InternVarName(sym_glojure_DOT_core, sym_binding) + // var glojure.core/binding-conveyor-fn + var_glojure_DOT_core_binding_DASH_conveyor_DASH_fn := lang.InternVarName(sym_glojure_DOT_core, sym_binding_DASH_conveyor_DASH_fn) + // var glojure.core/bit-and + var_glojure_DOT_core_bit_DASH_and := lang.InternVarName(sym_glojure_DOT_core, sym_bit_DASH_and) + // var glojure.core/bit-and-not + var_glojure_DOT_core_bit_DASH_and_DASH_not := lang.InternVarName(sym_glojure_DOT_core, sym_bit_DASH_and_DASH_not) + // var glojure.core/bit-clear + var_glojure_DOT_core_bit_DASH_clear := lang.InternVarName(sym_glojure_DOT_core, sym_bit_DASH_clear) + // var glojure.core/bit-flip + var_glojure_DOT_core_bit_DASH_flip := lang.InternVarName(sym_glojure_DOT_core, sym_bit_DASH_flip) + // var glojure.core/bit-not + var_glojure_DOT_core_bit_DASH_not := lang.InternVarName(sym_glojure_DOT_core, sym_bit_DASH_not) + // var glojure.core/bit-or + var_glojure_DOT_core_bit_DASH_or := lang.InternVarName(sym_glojure_DOT_core, sym_bit_DASH_or) + // var glojure.core/bit-set + var_glojure_DOT_core_bit_DASH_set := lang.InternVarName(sym_glojure_DOT_core, sym_bit_DASH_set) + // var glojure.core/bit-shift-left + var_glojure_DOT_core_bit_DASH_shift_DASH_left := lang.InternVarName(sym_glojure_DOT_core, sym_bit_DASH_shift_DASH_left) + // var glojure.core/bit-shift-right + var_glojure_DOT_core_bit_DASH_shift_DASH_right := lang.InternVarName(sym_glojure_DOT_core, sym_bit_DASH_shift_DASH_right) + // var glojure.core/bit-test + var_glojure_DOT_core_bit_DASH_test := lang.InternVarName(sym_glojure_DOT_core, sym_bit_DASH_test) + // var glojure.core/bit-xor + var_glojure_DOT_core_bit_DASH_xor := lang.InternVarName(sym_glojure_DOT_core, sym_bit_DASH_xor) + // var glojure.core/boolean + var_glojure_DOT_core_boolean := lang.InternVarName(sym_glojure_DOT_core, sym_boolean) + // var glojure.core/boolean-array + var_glojure_DOT_core_boolean_DASH_array := lang.InternVarName(sym_glojure_DOT_core, sym_boolean_DASH_array) + // var glojure.core/boolean? + var_glojure_DOT_core_boolean_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_boolean_QMARK_) + // var glojure.core/booleans + var_glojure_DOT_core_booleans := lang.InternVarName(sym_glojure_DOT_core, sym_booleans) + // var glojure.core/bound-fn + var_glojure_DOT_core_bound_DASH_fn := lang.InternVarName(sym_glojure_DOT_core, sym_bound_DASH_fn) + // var glojure.core/bound-fn* + var_glojure_DOT_core_bound_DASH_fn_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym_bound_DASH_fn_STAR_) + // var glojure.core/bound? + var_glojure_DOT_core_bound_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_bound_QMARK_) + // var glojure.core/bounded-count + var_glojure_DOT_core_bounded_DASH_count := lang.InternVarName(sym_glojure_DOT_core, sym_bounded_DASH_count) + // var glojure.core/butlast + var_glojure_DOT_core_butlast := lang.InternVarName(sym_glojure_DOT_core, sym_butlast) + // var glojure.core/byte + var_glojure_DOT_core_byte := lang.InternVarName(sym_glojure_DOT_core, sym_byte) + // var glojure.core/byte-array + var_glojure_DOT_core_byte_DASH_array := lang.InternVarName(sym_glojure_DOT_core, sym_byte_DASH_array) + // var glojure.core/bytes + var_glojure_DOT_core_bytes := lang.InternVarName(sym_glojure_DOT_core, sym_bytes) + // var glojure.core/bytes? + var_glojure_DOT_core_bytes_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_bytes_QMARK_) + // var glojure.core/case + var_glojure_DOT_core_case := lang.InternVarName(sym_glojure_DOT_core, sym_case) + // var glojure.core/case-map + var_glojure_DOT_core_case_DASH_map := lang.InternVarName(sym_glojure_DOT_core, sym_case_DASH_map) + // var glojure.core/cast + var_glojure_DOT_core_cast := lang.InternVarName(sym_glojure_DOT_core, sym_cast) + // var glojure.core/cat + var_glojure_DOT_core_cat := lang.InternVarName(sym_glojure_DOT_core, sym_cat) + // var glojure.core/char + var_glojure_DOT_core_char := lang.InternVarName(sym_glojure_DOT_core, sym_char) + // var glojure.core/char-array + var_glojure_DOT_core_char_DASH_array := lang.InternVarName(sym_glojure_DOT_core, sym_char_DASH_array) + // var glojure.core/char-escape-string + var_glojure_DOT_core_char_DASH_escape_DASH_string := lang.InternVarName(sym_glojure_DOT_core, sym_char_DASH_escape_DASH_string) + // var glojure.core/char-name-string + var_glojure_DOT_core_char_DASH_name_DASH_string := lang.InternVarName(sym_glojure_DOT_core, sym_char_DASH_name_DASH_string) + // var glojure.core/char? + var_glojure_DOT_core_char_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_char_QMARK_) + // var glojure.core/chars + var_glojure_DOT_core_chars := lang.InternVarName(sym_glojure_DOT_core, sym_chars) + // var glojure.core/check-cyclic-dependency + var_glojure_DOT_core_check_DASH_cyclic_DASH_dependency := lang.InternVarName(sym_glojure_DOT_core, sym_check_DASH_cyclic_DASH_dependency) + // var glojure.core/check-valid-options + var_glojure_DOT_core_check_DASH_valid_DASH_options := lang.InternVarName(sym_glojure_DOT_core, sym_check_DASH_valid_DASH_options) + // var glojure.core/chunk + var_glojure_DOT_core_chunk := lang.InternVarName(sym_glojure_DOT_core, sym_chunk) + // var glojure.core/chunk-append + var_glojure_DOT_core_chunk_DASH_append := lang.InternVarName(sym_glojure_DOT_core, sym_chunk_DASH_append) + // var glojure.core/chunk-buffer + var_glojure_DOT_core_chunk_DASH_buffer := lang.InternVarName(sym_glojure_DOT_core, sym_chunk_DASH_buffer) + // var glojure.core/chunk-cons + var_glojure_DOT_core_chunk_DASH_cons := lang.InternVarName(sym_glojure_DOT_core, sym_chunk_DASH_cons) + // var glojure.core/chunk-first + var_glojure_DOT_core_chunk_DASH_first := lang.InternVarName(sym_glojure_DOT_core, sym_chunk_DASH_first) + // var glojure.core/chunk-next + var_glojure_DOT_core_chunk_DASH_next := lang.InternVarName(sym_glojure_DOT_core, sym_chunk_DASH_next) + // var glojure.core/chunk-rest + var_glojure_DOT_core_chunk_DASH_rest := lang.InternVarName(sym_glojure_DOT_core, sym_chunk_DASH_rest) + // var glojure.core/chunked-seq? + var_glojure_DOT_core_chunked_DASH_seq_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_chunked_DASH_seq_QMARK_) + // var glojure.core/class + var_glojure_DOT_core_class := lang.InternVarName(sym_glojure_DOT_core, sym_class) + // var glojure.core/class? + var_glojure_DOT_core_class_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_class_QMARK_) + // var glojure.core/clear-agent-errors + var_glojure_DOT_core_clear_DASH_agent_DASH_errors := lang.InternVarName(sym_glojure_DOT_core, sym_clear_DASH_agent_DASH_errors) + // var glojure.core/coll? + var_glojure_DOT_core_coll_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_coll_QMARK_) + // var glojure.core/comment + var_glojure_DOT_core_comment := lang.InternVarName(sym_glojure_DOT_core, sym_comment) + // var glojure.core/commute + var_glojure_DOT_core_commute := lang.InternVarName(sym_glojure_DOT_core, sym_commute) + // var glojure.core/comp + var_glojure_DOT_core_comp := lang.InternVarName(sym_glojure_DOT_core, sym_comp) + // var glojure.core/comparator + var_glojure_DOT_core_comparator := lang.InternVarName(sym_glojure_DOT_core, sym_comparator) + // var glojure.core/compare + var_glojure_DOT_core_compare := lang.InternVarName(sym_glojure_DOT_core, sym_compare) + // var glojure.core/compare-and-set! + var_glojure_DOT_core_compare_DASH_and_DASH_set_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_compare_DASH_and_DASH_set_BANG_) + // var glojure.core/compile + var_glojure_DOT_core_compile := lang.InternVarName(sym_glojure_DOT_core, sym_compile) + // var glojure.core/complement + var_glojure_DOT_core_complement := lang.InternVarName(sym_glojure_DOT_core, sym_complement) + // var glojure.core/completing + var_glojure_DOT_core_completing := lang.InternVarName(sym_glojure_DOT_core, sym_completing) + // var glojure.core/concat + var_glojure_DOT_core_concat := lang.InternVarName(sym_glojure_DOT_core, sym_concat) + // var glojure.core/cond + var_glojure_DOT_core_cond := lang.InternVarName(sym_glojure_DOT_core, sym_cond) + // var glojure.core/cond-> + var_glojure_DOT_core_cond_DASH__GT_ := lang.InternVarName(sym_glojure_DOT_core, sym_cond_DASH__GT_) + // var glojure.core/cond->> + var_glojure_DOT_core_cond_DASH__GT__GT_ := lang.InternVarName(sym_glojure_DOT_core, sym_cond_DASH__GT__GT_) + // var glojure.core/condp + var_glojure_DOT_core_condp := lang.InternVarName(sym_glojure_DOT_core, sym_condp) + // var glojure.core/conj + var_glojure_DOT_core_conj := lang.InternVarName(sym_glojure_DOT_core, sym_conj) + // var glojure.core/conj! + var_glojure_DOT_core_conj_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_conj_BANG_) + // var glojure.core/cons + var_glojure_DOT_core_cons := lang.InternVarName(sym_glojure_DOT_core, sym_cons) + // var glojure.core/constantly + var_glojure_DOT_core_constantly := lang.InternVarName(sym_glojure_DOT_core, sym_constantly) + // var glojure.core/contains? + var_glojure_DOT_core_contains_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_contains_QMARK_) + // var glojure.core/count + var_glojure_DOT_core_count := lang.InternVarName(sym_glojure_DOT_core, sym_count) + // var glojure.core/counted? + var_glojure_DOT_core_counted_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_counted_QMARK_) + // var glojure.core/create-ns + var_glojure_DOT_core_create_DASH_ns := lang.InternVarName(sym_glojure_DOT_core, sym_create_DASH_ns) + // var glojure.core/create-struct + var_glojure_DOT_core_create_DASH_struct := lang.InternVarName(sym_glojure_DOT_core, sym_create_DASH_struct) + // var glojure.core/cycle + var_glojure_DOT_core_cycle := lang.InternVarName(sym_glojure_DOT_core, sym_cycle) + // var glojure.core/data-reader-urls + var_glojure_DOT_core_data_DASH_reader_DASH_urls := lang.InternVarName(sym_glojure_DOT_core, sym_data_DASH_reader_DASH_urls) + // var glojure.core/data-reader-var + var_glojure_DOT_core_data_DASH_reader_DASH_var := lang.InternVarName(sym_glojure_DOT_core, sym_data_DASH_reader_DASH_var) + // var glojure.core/dec + var_glojure_DOT_core_dec := lang.InternVarName(sym_glojure_DOT_core, sym_dec) + // var glojure.core/dec' + var_glojure_DOT_core_dec_TICK_ := lang.InternVarName(sym_glojure_DOT_core, sym_dec_TICK_) + // var glojure.core/decimal? + var_glojure_DOT_core_decimal_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_decimal_QMARK_) + // var glojure.core/declare + var_glojure_DOT_core_declare := lang.InternVarName(sym_glojure_DOT_core, sym_declare) + // var glojure.core/dedupe + var_glojure_DOT_core_dedupe := lang.InternVarName(sym_glojure_DOT_core, sym_dedupe) + // var glojure.core/def-aset + var_glojure_DOT_core_def_DASH_aset := lang.InternVarName(sym_glojure_DOT_core, sym_def_DASH_aset) + // var glojure.core/definline + var_glojure_DOT_core_definline := lang.InternVarName(sym_glojure_DOT_core, sym_definline) + // var glojure.core/defmacro + var_glojure_DOT_core_defmacro := lang.InternVarName(sym_glojure_DOT_core, sym_defmacro) + // var glojure.core/defmethod + var_glojure_DOT_core_defmethod := lang.InternVarName(sym_glojure_DOT_core, sym_defmethod) + // var glojure.core/defmulti + var_glojure_DOT_core_defmulti := lang.InternVarName(sym_glojure_DOT_core, sym_defmulti) + // var glojure.core/defn + var_glojure_DOT_core_defn := lang.InternVarName(sym_glojure_DOT_core, sym_defn) + // var glojure.core/defn- + var_glojure_DOT_core_defn_DASH_ := lang.InternVarName(sym_glojure_DOT_core, sym_defn_DASH_) + // var glojure.core/defonce + var_glojure_DOT_core_defonce := lang.InternVarName(sym_glojure_DOT_core, sym_defonce) + // var glojure.core/defprotocol + var_glojure_DOT_core_defprotocol := lang.InternVarName(sym_glojure_DOT_core, sym_defprotocol) + // var glojure.core/defstruct + var_glojure_DOT_core_defstruct := lang.InternVarName(sym_glojure_DOT_core, sym_defstruct) + // var glojure.core/delay + var_glojure_DOT_core_delay := lang.InternVarName(sym_glojure_DOT_core, sym_delay) + // var glojure.core/delay? + var_glojure_DOT_core_delay_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_delay_QMARK_) + // var glojure.core/deliver + var_glojure_DOT_core_deliver := lang.InternVarName(sym_glojure_DOT_core, sym_deliver) + // var glojure.core/denominator + var_glojure_DOT_core_denominator := lang.InternVarName(sym_glojure_DOT_core, sym_denominator) + // var glojure.core/deref + var_glojure_DOT_core_deref := lang.InternVarName(sym_glojure_DOT_core, sym_deref) + // var glojure.core/deref-as-map + var_glojure_DOT_core_deref_DASH_as_DASH_map := lang.InternVarName(sym_glojure_DOT_core, sym_deref_DASH_as_DASH_map) + // var glojure.core/deref-future + var_glojure_DOT_core_deref_DASH_future := lang.InternVarName(sym_glojure_DOT_core, sym_deref_DASH_future) + // var glojure.core/derive + var_glojure_DOT_core_derive := lang.InternVarName(sym_glojure_DOT_core, sym_derive) + // var glojure.core/descendants + var_glojure_DOT_core_descendants := lang.InternVarName(sym_glojure_DOT_core, sym_descendants) + // var glojure.core/destructure + var_glojure_DOT_core_destructure := lang.InternVarName(sym_glojure_DOT_core, sym_destructure) + // var glojure.core/disj + var_glojure_DOT_core_disj := lang.InternVarName(sym_glojure_DOT_core, sym_disj) + // var glojure.core/disj! + var_glojure_DOT_core_disj_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_disj_BANG_) + // var glojure.core/dissoc + var_glojure_DOT_core_dissoc := lang.InternVarName(sym_glojure_DOT_core, sym_dissoc) + // var glojure.core/dissoc! + var_glojure_DOT_core_dissoc_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_dissoc_BANG_) + // var glojure.core/distinct + var_glojure_DOT_core_distinct := lang.InternVarName(sym_glojure_DOT_core, sym_distinct) + // var glojure.core/distinct? + var_glojure_DOT_core_distinct_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_distinct_QMARK_) + // var glojure.core/doall + var_glojure_DOT_core_doall := lang.InternVarName(sym_glojure_DOT_core, sym_doall) + // var glojure.core/dorun + var_glojure_DOT_core_dorun := lang.InternVarName(sym_glojure_DOT_core, sym_dorun) + // var glojure.core/doseq + var_glojure_DOT_core_doseq := lang.InternVarName(sym_glojure_DOT_core, sym_doseq) + // var glojure.core/dosync + var_glojure_DOT_core_dosync := lang.InternVarName(sym_glojure_DOT_core, sym_dosync) + // var glojure.core/dotimes + var_glojure_DOT_core_dotimes := lang.InternVarName(sym_glojure_DOT_core, sym_dotimes) + // var glojure.core/doto + var_glojure_DOT_core_doto := lang.InternVarName(sym_glojure_DOT_core, sym_doto) + // var glojure.core/double + var_glojure_DOT_core_double := lang.InternVarName(sym_glojure_DOT_core, sym_double) + // var glojure.core/double-array + var_glojure_DOT_core_double_DASH_array := lang.InternVarName(sym_glojure_DOT_core, sym_double_DASH_array) + // var glojure.core/double? + var_glojure_DOT_core_double_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_double_QMARK_) + // var glojure.core/doubles + var_glojure_DOT_core_doubles := lang.InternVarName(sym_glojure_DOT_core, sym_doubles) + // var glojure.core/drop + var_glojure_DOT_core_drop := lang.InternVarName(sym_glojure_DOT_core, sym_drop) + // var glojure.core/drop-last + var_glojure_DOT_core_drop_DASH_last := lang.InternVarName(sym_glojure_DOT_core, sym_drop_DASH_last) + // var glojure.core/drop-while + var_glojure_DOT_core_drop_DASH_while := lang.InternVarName(sym_glojure_DOT_core, sym_drop_DASH_while) + // var glojure.core/elide-top-frames + var_glojure_DOT_core_elide_DASH_top_DASH_frames := lang.InternVarName(sym_glojure_DOT_core, sym_elide_DASH_top_DASH_frames) + // var glojure.core/emit-extend-protocol + var_glojure_DOT_core_emit_DASH_extend_DASH_protocol := lang.InternVarName(sym_glojure_DOT_core, sym_emit_DASH_extend_DASH_protocol) + // var glojure.core/emit-extend-type + var_glojure_DOT_core_emit_DASH_extend_DASH_type := lang.InternVarName(sym_glojure_DOT_core, sym_emit_DASH_extend_DASH_type) + // var glojure.core/emit-hinted-impl + var_glojure_DOT_core_emit_DASH_hinted_DASH_impl := lang.InternVarName(sym_glojure_DOT_core, sym_emit_DASH_hinted_DASH_impl) + // var glojure.core/empty + var_glojure_DOT_core_empty := lang.InternVarName(sym_glojure_DOT_core, sym_empty) + // var glojure.core/empty? + var_glojure_DOT_core_empty_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_empty_QMARK_) + // var glojure.core/ensure + var_glojure_DOT_core_ensure := lang.InternVarName(sym_glojure_DOT_core, sym_ensure) + // var glojure.core/ensure-reduced + var_glojure_DOT_core_ensure_DASH_reduced := lang.InternVarName(sym_glojure_DOT_core, sym_ensure_DASH_reduced) + // var glojure.core/enumeration-seq + var_glojure_DOT_core_enumeration_DASH_seq := lang.InternVarName(sym_glojure_DOT_core, sym_enumeration_DASH_seq) + // var glojure.core/error-handler + var_glojure_DOT_core_error_DASH_handler := lang.InternVarName(sym_glojure_DOT_core, sym_error_DASH_handler) + // var glojure.core/error-mode + var_glojure_DOT_core_error_DASH_mode := lang.InternVarName(sym_glojure_DOT_core, sym_error_DASH_mode) + // var glojure.core/eval + var_glojure_DOT_core_eval := lang.InternVarName(sym_glojure_DOT_core, sym_eval) + // var glojure.core/even? + var_glojure_DOT_core_even_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_even_QMARK_) + // var glojure.core/every-pred + var_glojure_DOT_core_every_DASH_pred := lang.InternVarName(sym_glojure_DOT_core, sym_every_DASH_pred) + // var glojure.core/every? + var_glojure_DOT_core_every_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_every_QMARK_) + // var glojure.core/ex-cause + var_glojure_DOT_core_ex_DASH_cause := lang.InternVarName(sym_glojure_DOT_core, sym_ex_DASH_cause) + // var glojure.core/ex-data + var_glojure_DOT_core_ex_DASH_data := lang.InternVarName(sym_glojure_DOT_core, sym_ex_DASH_data) + // var glojure.core/ex-info + var_glojure_DOT_core_ex_DASH_info := lang.InternVarName(sym_glojure_DOT_core, sym_ex_DASH_info) + // var glojure.core/ex-message + var_glojure_DOT_core_ex_DASH_message := lang.InternVarName(sym_glojure_DOT_core, sym_ex_DASH_message) + // var glojure.core/extend + var_glojure_DOT_core_extend := lang.InternVarName(sym_glojure_DOT_core, sym_extend) + // var glojure.core/extend-protocol + var_glojure_DOT_core_extend_DASH_protocol := lang.InternVarName(sym_glojure_DOT_core, sym_extend_DASH_protocol) + // var glojure.core/extend-type + var_glojure_DOT_core_extend_DASH_type := lang.InternVarName(sym_glojure_DOT_core, sym_extend_DASH_type) + // var glojure.core/false? + var_glojure_DOT_core_false_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_false_QMARK_) + // var glojure.core/ffirst + var_glojure_DOT_core_ffirst := lang.InternVarName(sym_glojure_DOT_core, sym_ffirst) + // var glojure.core/file-seq + var_glojure_DOT_core_file_DASH_seq := lang.InternVarName(sym_glojure_DOT_core, sym_file_DASH_seq) + // var glojure.core/filter + var_glojure_DOT_core_filter := lang.InternVarName(sym_glojure_DOT_core, sym_filter) + // var glojure.core/filter-key + var_glojure_DOT_core_filter_DASH_key := lang.InternVarName(sym_glojure_DOT_core, sym_filter_DASH_key) + // var glojure.core/filterv + var_glojure_DOT_core_filterv := lang.InternVarName(sym_glojure_DOT_core, sym_filterv) + // var glojure.core/find + var_glojure_DOT_core_find := lang.InternVarName(sym_glojure_DOT_core, sym_find) + // var glojure.core/find-keyword + var_glojure_DOT_core_find_DASH_keyword := lang.InternVarName(sym_glojure_DOT_core, sym_find_DASH_keyword) + // var glojure.core/find-ns + var_glojure_DOT_core_find_DASH_ns := lang.InternVarName(sym_glojure_DOT_core, sym_find_DASH_ns) + // var glojure.core/find-var + var_glojure_DOT_core_find_DASH_var := lang.InternVarName(sym_glojure_DOT_core, sym_find_DASH_var) + // var glojure.core/first + var_glojure_DOT_core_first := lang.InternVarName(sym_glojure_DOT_core, sym_first) + // var glojure.core/fits-table? + var_glojure_DOT_core_fits_DASH_table_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_fits_DASH_table_QMARK_) + // var glojure.core/flatten + var_glojure_DOT_core_flatten := lang.InternVarName(sym_glojure_DOT_core, sym_flatten) + // var glojure.core/float + var_glojure_DOT_core_float := lang.InternVarName(sym_glojure_DOT_core, sym_float) + // var glojure.core/float-array + var_glojure_DOT_core_float_DASH_array := lang.InternVarName(sym_glojure_DOT_core, sym_float_DASH_array) + // var glojure.core/float? + var_glojure_DOT_core_float_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_float_QMARK_) + // var glojure.core/floats + var_glojure_DOT_core_floats := lang.InternVarName(sym_glojure_DOT_core, sym_floats) + // var glojure.core/flush + var_glojure_DOT_core_flush := lang.InternVarName(sym_glojure_DOT_core, sym_flush) + // var glojure.core/fn + var_glojure_DOT_core_fn := lang.InternVarName(sym_glojure_DOT_core, sym_fn) + // var glojure.core/fn? + var_glojure_DOT_core_fn_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_fn_QMARK_) + // var glojure.core/fnext + var_glojure_DOT_core_fnext := lang.InternVarName(sym_glojure_DOT_core, sym_fnext) + // var glojure.core/fnil + var_glojure_DOT_core_fnil := lang.InternVarName(sym_glojure_DOT_core, sym_fnil) + // var glojure.core/for + var_glojure_DOT_core_for := lang.InternVarName(sym_glojure_DOT_core, sym_for) + // var glojure.core/force + var_glojure_DOT_core_force := lang.InternVarName(sym_glojure_DOT_core, sym_force) + // var glojure.core/format + var_glojure_DOT_core_format := lang.InternVarName(sym_glojure_DOT_core, sym_format) + // var glojure.core/frequencies + var_glojure_DOT_core_frequencies := lang.InternVarName(sym_glojure_DOT_core, sym_frequencies) + // var glojure.core/future + var_glojure_DOT_core_future := lang.InternVarName(sym_glojure_DOT_core, sym_future) + // var glojure.core/future-call + var_glojure_DOT_core_future_DASH_call := lang.InternVarName(sym_glojure_DOT_core, sym_future_DASH_call) + // var glojure.core/future-cancel + var_glojure_DOT_core_future_DASH_cancel := lang.InternVarName(sym_glojure_DOT_core, sym_future_DASH_cancel) + // var glojure.core/future-cancelled? + var_glojure_DOT_core_future_DASH_cancelled_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_future_DASH_cancelled_QMARK_) + // var glojure.core/future-done? + var_glojure_DOT_core_future_DASH_done_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_future_DASH_done_QMARK_) + // var glojure.core/future? + var_glojure_DOT_core_future_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_future_QMARK_) + // var glojure.core/gen-class + var_glojure_DOT_core_gen_DASH_class := lang.InternVarName(sym_glojure_DOT_core, sym_gen_DASH_class) + // var glojure.core/gensym + var_glojure_DOT_core_gensym := lang.InternVarName(sym_glojure_DOT_core, sym_gensym) + // var glojure.core/get + var_glojure_DOT_core_get := lang.InternVarName(sym_glojure_DOT_core, sym_get) + // var glojure.core/get-in + var_glojure_DOT_core_get_DASH_in := lang.InternVarName(sym_glojure_DOT_core, sym_get_DASH_in) + // var glojure.core/get-method + var_glojure_DOT_core_get_DASH_method := lang.InternVarName(sym_glojure_DOT_core, sym_get_DASH_method) + // var glojure.core/get-thread-bindings + var_glojure_DOT_core_get_DASH_thread_DASH_bindings := lang.InternVarName(sym_glojure_DOT_core, sym_get_DASH_thread_DASH_bindings) + // var glojure.core/get-validator + var_glojure_DOT_core_get_DASH_validator := lang.InternVarName(sym_glojure_DOT_core, sym_get_DASH_validator) + // var glojure.core/global-hierarchy + var_glojure_DOT_core_global_DASH_hierarchy := lang.InternVarName(sym_glojure_DOT_core, sym_global_DASH_hierarchy) + // var glojure.core/group-by + var_glojure_DOT_core_group_DASH_by := lang.InternVarName(sym_glojure_DOT_core, sym_group_DASH_by) + // var glojure.core/halt-when + var_glojure_DOT_core_halt_DASH_when := lang.InternVarName(sym_glojure_DOT_core, sym_halt_DASH_when) + // var glojure.core/hash + var_glojure_DOT_core_hash := lang.InternVarName(sym_glojure_DOT_core, sym_hash) + // var glojure.core/hash-map + var_glojure_DOT_core_hash_DASH_map := lang.InternVarName(sym_glojure_DOT_core, sym_hash_DASH_map) + // var glojure.core/hash-ordered-coll + var_glojure_DOT_core_hash_DASH_ordered_DASH_coll := lang.InternVarName(sym_glojure_DOT_core, sym_hash_DASH_ordered_DASH_coll) + // var glojure.core/hash-set + var_glojure_DOT_core_hash_DASH_set := lang.InternVarName(sym_glojure_DOT_core, sym_hash_DASH_set) + // var glojure.core/hash-unordered-coll + var_glojure_DOT_core_hash_DASH_unordered_DASH_coll := lang.InternVarName(sym_glojure_DOT_core, sym_hash_DASH_unordered_DASH_coll) + // var glojure.core/ident? + var_glojure_DOT_core_ident_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_ident_QMARK_) + // var glojure.core/identical? + var_glojure_DOT_core_identical_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_identical_QMARK_) + // var glojure.core/identity + var_glojure_DOT_core_identity := lang.InternVarName(sym_glojure_DOT_core, sym_identity) + // var glojure.core/if-let + var_glojure_DOT_core_if_DASH_let := lang.InternVarName(sym_glojure_DOT_core, sym_if_DASH_let) + // var glojure.core/if-not + var_glojure_DOT_core_if_DASH_not := lang.InternVarName(sym_glojure_DOT_core, sym_if_DASH_not) + // var glojure.core/if-some + var_glojure_DOT_core_if_DASH_some := lang.InternVarName(sym_glojure_DOT_core, sym_if_DASH_some) + // var glojure.core/ifn? + var_glojure_DOT_core_ifn_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_ifn_QMARK_) + // var glojure.core/import + var_glojure_DOT_core_import := lang.InternVarName(sym_glojure_DOT_core, sym_import) + // var glojure.core/inc + var_glojure_DOT_core_inc := lang.InternVarName(sym_glojure_DOT_core, sym_inc) + // var glojure.core/inc' + var_glojure_DOT_core_inc_TICK_ := lang.InternVarName(sym_glojure_DOT_core, sym_inc_TICK_) + // var glojure.core/indexed? + var_glojure_DOT_core_indexed_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_indexed_QMARK_) + // var glojure.core/infinite? + var_glojure_DOT_core_infinite_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_infinite_QMARK_) + // var glojure.core/inst-ms + var_glojure_DOT_core_inst_DASH_ms := lang.InternVarName(sym_glojure_DOT_core, sym_inst_DASH_ms) + // var glojure.core/inst? + var_glojure_DOT_core_inst_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_inst_QMARK_) + // var glojure.core/instance? + var_glojure_DOT_core_instance_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_instance_QMARK_) + // var glojure.core/int + var_glojure_DOT_core_int := lang.InternVarName(sym_glojure_DOT_core, sym_int) + // var glojure.core/int-array + var_glojure_DOT_core_int_DASH_array := lang.InternVarName(sym_glojure_DOT_core, sym_int_DASH_array) + // var glojure.core/int? + var_glojure_DOT_core_int_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_int_QMARK_) + // var glojure.core/integer? + var_glojure_DOT_core_integer_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_integer_QMARK_) + // var glojure.core/interleave + var_glojure_DOT_core_interleave := lang.InternVarName(sym_glojure_DOT_core, sym_interleave) + // var glojure.core/intern + var_glojure_DOT_core_intern := lang.InternVarName(sym_glojure_DOT_core, sym_intern) + // var glojure.core/interpose + var_glojure_DOT_core_interpose := lang.InternVarName(sym_glojure_DOT_core, sym_interpose) + // var glojure.core/into + var_glojure_DOT_core_into := lang.InternVarName(sym_glojure_DOT_core, sym_into) + // var glojure.core/into1 + var_glojure_DOT_core_into1 := lang.InternVarName(sym_glojure_DOT_core, sym_into1) + // var glojure.core/into-array + var_glojure_DOT_core_into_DASH_array := lang.InternVarName(sym_glojure_DOT_core, sym_into_DASH_array) + // var glojure.core/ints + var_glojure_DOT_core_ints := lang.InternVarName(sym_glojure_DOT_core, sym_ints) + // var glojure.core/io! + var_glojure_DOT_core_io_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_io_BANG_) + // var glojure.core/isa? + var_glojure_DOT_core_isa_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_isa_QMARK_) + // var glojure.core/iterate + var_glojure_DOT_core_iterate := lang.InternVarName(sym_glojure_DOT_core, sym_iterate) + // var glojure.core/iteration + var_glojure_DOT_core_iteration := lang.InternVarName(sym_glojure_DOT_core, sym_iteration) + // var glojure.core/iterator-seq + var_glojure_DOT_core_iterator_DASH_seq := lang.InternVarName(sym_glojure_DOT_core, sym_iterator_DASH_seq) + // var glojure.core/juxt + var_glojure_DOT_core_juxt := lang.InternVarName(sym_glojure_DOT_core, sym_juxt) + // var glojure.core/keep + var_glojure_DOT_core_keep := lang.InternVarName(sym_glojure_DOT_core, sym_keep) + // var glojure.core/keep-indexed + var_glojure_DOT_core_keep_DASH_indexed := lang.InternVarName(sym_glojure_DOT_core, sym_keep_DASH_indexed) + // var glojure.core/key + var_glojure_DOT_core_key := lang.InternVarName(sym_glojure_DOT_core, sym_key) + // var glojure.core/keys + var_glojure_DOT_core_keys := lang.InternVarName(sym_glojure_DOT_core, sym_keys) + // var glojure.core/keyword + var_glojure_DOT_core_keyword := lang.InternVarName(sym_glojure_DOT_core, sym_keyword) + // var glojure.core/keyword? + var_glojure_DOT_core_keyword_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_keyword_QMARK_) + // var glojure.core/last + var_glojure_DOT_core_last := lang.InternVarName(sym_glojure_DOT_core, sym_last) + // var glojure.core/lazy-cat + var_glojure_DOT_core_lazy_DASH_cat := lang.InternVarName(sym_glojure_DOT_core, sym_lazy_DASH_cat) + // var glojure.core/lazy-seq + var_glojure_DOT_core_lazy_DASH_seq := lang.InternVarName(sym_glojure_DOT_core, sym_lazy_DASH_seq) + // var glojure.core/let + var_glojure_DOT_core_let := lang.InternVarName(sym_glojure_DOT_core, sym_let) + // var glojure.core/letfn + var_glojure_DOT_core_letfn := lang.InternVarName(sym_glojure_DOT_core, sym_letfn) + // var glojure.core/libspec? + var_glojure_DOT_core_libspec_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_libspec_QMARK_) + // var glojure.core/lift-ns + var_glojure_DOT_core_lift_DASH_ns := lang.InternVarName(sym_glojure_DOT_core, sym_lift_DASH_ns) + // var glojure.core/line-seq + var_glojure_DOT_core_line_DASH_seq := lang.InternVarName(sym_glojure_DOT_core, sym_line_DASH_seq) + // var glojure.core/list + var_glojure_DOT_core_list := lang.InternVarName(sym_glojure_DOT_core, sym_list) + // var glojure.core/list? + var_glojure_DOT_core_list_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_list_QMARK_) + // var glojure.core/list* + var_glojure_DOT_core_list_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym_list_STAR_) + // var glojure.core/load + var_glojure_DOT_core_load := lang.InternVarName(sym_glojure_DOT_core, sym_load) + // var glojure.core/load-all + var_glojure_DOT_core_load_DASH_all := lang.InternVarName(sym_glojure_DOT_core, sym_load_DASH_all) + // var glojure.core/load-data-reader-file + var_glojure_DOT_core_load_DASH_data_DASH_reader_DASH_file := lang.InternVarName(sym_glojure_DOT_core, sym_load_DASH_data_DASH_reader_DASH_file) + // var glojure.core/load-data-readers + var_glojure_DOT_core_load_DASH_data_DASH_readers := lang.InternVarName(sym_glojure_DOT_core, sym_load_DASH_data_DASH_readers) + // var glojure.core/load-file + var_glojure_DOT_core_load_DASH_file := lang.InternVarName(sym_glojure_DOT_core, sym_load_DASH_file) + // var glojure.core/load-lib + var_glojure_DOT_core_load_DASH_lib := lang.InternVarName(sym_glojure_DOT_core, sym_load_DASH_lib) + // var glojure.core/load-libs + var_glojure_DOT_core_load_DASH_libs := lang.InternVarName(sym_glojure_DOT_core, sym_load_DASH_libs) + // var glojure.core/load-one + var_glojure_DOT_core_load_DASH_one := lang.InternVarName(sym_glojure_DOT_core, sym_load_DASH_one) + // var glojure.core/load-reader + var_glojure_DOT_core_load_DASH_reader := lang.InternVarName(sym_glojure_DOT_core, sym_load_DASH_reader) + // var glojure.core/load-string + var_glojure_DOT_core_load_DASH_string := lang.InternVarName(sym_glojure_DOT_core, sym_load_DASH_string) + // var glojure.core/loaded-libs + var_glojure_DOT_core_loaded_DASH_libs := lang.InternVarName(sym_glojure_DOT_core, sym_loaded_DASH_libs) + // var glojure.core/locking + var_glojure_DOT_core_locking := lang.InternVarName(sym_glojure_DOT_core, sym_locking) + // var glojure.core/long + var_glojure_DOT_core_long := lang.InternVarName(sym_glojure_DOT_core, sym_long) + // var glojure.core/long-array + var_glojure_DOT_core_long_DASH_array := lang.InternVarName(sym_glojure_DOT_core, sym_long_DASH_array) + // var glojure.core/longs + var_glojure_DOT_core_longs := lang.InternVarName(sym_glojure_DOT_core, sym_longs) + // var glojure.core/loop + var_glojure_DOT_core_loop := lang.InternVarName(sym_glojure_DOT_core, sym_loop) + // var glojure.core/macroexpand + var_glojure_DOT_core_macroexpand := lang.InternVarName(sym_glojure_DOT_core, sym_macroexpand) + // var glojure.core/macroexpand-1 + var_glojure_DOT_core_macroexpand_DASH_1 := lang.InternVarName(sym_glojure_DOT_core, sym_macroexpand_DASH_1) + // var glojure.core/make-array + var_glojure_DOT_core_make_DASH_array := lang.InternVarName(sym_glojure_DOT_core, sym_make_DASH_array) + // var glojure.core/make-hierarchy + var_glojure_DOT_core_make_DASH_hierarchy := lang.InternVarName(sym_glojure_DOT_core, sym_make_DASH_hierarchy) + // var glojure.core/map + var_glojure_DOT_core_map := lang.InternVarName(sym_glojure_DOT_core, sym_map) + // var glojure.core/map-entry? + var_glojure_DOT_core_map_DASH_entry_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_map_DASH_entry_QMARK_) + // var glojure.core/map-indexed + var_glojure_DOT_core_map_DASH_indexed := lang.InternVarName(sym_glojure_DOT_core, sym_map_DASH_indexed) + // var glojure.core/map? + var_glojure_DOT_core_map_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_map_QMARK_) + // var glojure.core/mapcat + var_glojure_DOT_core_mapcat := lang.InternVarName(sym_glojure_DOT_core, sym_mapcat) + // var glojure.core/mapv + var_glojure_DOT_core_mapv := lang.InternVarName(sym_glojure_DOT_core, sym_mapv) + // var glojure.core/max + var_glojure_DOT_core_max := lang.InternVarName(sym_glojure_DOT_core, sym_max) + // var glojure.core/max-key + var_glojure_DOT_core_max_DASH_key := lang.InternVarName(sym_glojure_DOT_core, sym_max_DASH_key) + // var glojure.core/max-mask-bits + var_glojure_DOT_core_max_DASH_mask_DASH_bits := lang.InternVarName(sym_glojure_DOT_core, sym_max_DASH_mask_DASH_bits) + // var glojure.core/max-switch-table-size + var_glojure_DOT_core_max_DASH_switch_DASH_table_DASH_size := lang.InternVarName(sym_glojure_DOT_core, sym_max_DASH_switch_DASH_table_DASH_size) + // var glojure.core/maybe-destructured + var_glojure_DOT_core_maybe_DASH_destructured := lang.InternVarName(sym_glojure_DOT_core, sym_maybe_DASH_destructured) + // var glojure.core/maybe-min-hash + var_glojure_DOT_core_maybe_DASH_min_DASH_hash := lang.InternVarName(sym_glojure_DOT_core, sym_maybe_DASH_min_DASH_hash) + // var glojure.core/memfn + var_glojure_DOT_core_memfn := lang.InternVarName(sym_glojure_DOT_core, sym_memfn) + // var glojure.core/memoize + var_glojure_DOT_core_memoize := lang.InternVarName(sym_glojure_DOT_core, sym_memoize) + // var glojure.core/merge + var_glojure_DOT_core_merge := lang.InternVarName(sym_glojure_DOT_core, sym_merge) + // var glojure.core/merge-hash-collisions + var_glojure_DOT_core_merge_DASH_hash_DASH_collisions := lang.InternVarName(sym_glojure_DOT_core, sym_merge_DASH_hash_DASH_collisions) + // var glojure.core/merge-with + var_glojure_DOT_core_merge_DASH_with := lang.InternVarName(sym_glojure_DOT_core, sym_merge_DASH_with) + // var glojure.core/meta + var_glojure_DOT_core_meta := lang.InternVarName(sym_glojure_DOT_core, sym_meta) + // var glojure.core/methods + var_glojure_DOT_core_methods := lang.InternVarName(sym_glojure_DOT_core, sym_methods) + // var glojure.core/min + var_glojure_DOT_core_min := lang.InternVarName(sym_glojure_DOT_core, sym_min) + // var glojure.core/min-key + var_glojure_DOT_core_min_DASH_key := lang.InternVarName(sym_glojure_DOT_core, sym_min_DASH_key) + // var glojure.core/mix-collection-hash + var_glojure_DOT_core_mix_DASH_collection_DASH_hash := lang.InternVarName(sym_glojure_DOT_core, sym_mix_DASH_collection_DASH_hash) + // var glojure.core/mk-bound-fn + var_glojure_DOT_core_mk_DASH_bound_DASH_fn := lang.InternVarName(sym_glojure_DOT_core, sym_mk_DASH_bound_DASH_fn) + // var glojure.core/mod + var_glojure_DOT_core_mod := lang.InternVarName(sym_glojure_DOT_core, sym_mod) + // var glojure.core/name + var_glojure_DOT_core_name := lang.InternVarName(sym_glojure_DOT_core, sym_name) + // var glojure.core/namespace + var_glojure_DOT_core_namespace := lang.InternVarName(sym_glojure_DOT_core, sym_namespace) + // var glojure.core/nary-inline + var_glojure_DOT_core_nary_DASH_inline := lang.InternVarName(sym_glojure_DOT_core, sym_nary_DASH_inline) + // var glojure.core/nat-int? + var_glojure_DOT_core_nat_DASH_int_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_nat_DASH_int_QMARK_) + // var glojure.core/neg-int? + var_glojure_DOT_core_neg_DASH_int_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_neg_DASH_int_QMARK_) + // var glojure.core/neg? + var_glojure_DOT_core_neg_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_neg_QMARK_) + // var glojure.core/newline + var_glojure_DOT_core_newline := lang.InternVarName(sym_glojure_DOT_core, sym_newline) + // var glojure.core/next + var_glojure_DOT_core_next := lang.InternVarName(sym_glojure_DOT_core, sym_next) + // var glojure.core/nfirst + var_glojure_DOT_core_nfirst := lang.InternVarName(sym_glojure_DOT_core, sym_nfirst) + // var glojure.core/nil? + var_glojure_DOT_core_nil_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_nil_QMARK_) + // var glojure.core/nnext + var_glojure_DOT_core_nnext := lang.InternVarName(sym_glojure_DOT_core, sym_nnext) + // var glojure.core/normalize-slurp-opts + var_glojure_DOT_core_normalize_DASH_slurp_DASH_opts := lang.InternVarName(sym_glojure_DOT_core, sym_normalize_DASH_slurp_DASH_opts) + // var glojure.core/not + var_glojure_DOT_core_not := lang.InternVarName(sym_glojure_DOT_core, sym_not) + // var glojure.core/not-any? + var_glojure_DOT_core_not_DASH_any_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_not_DASH_any_QMARK_) + // var glojure.core/not-empty + var_glojure_DOT_core_not_DASH_empty := lang.InternVarName(sym_glojure_DOT_core, sym_not_DASH_empty) + // var glojure.core/not-every? + var_glojure_DOT_core_not_DASH_every_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_not_DASH_every_QMARK_) + // var glojure.core/not= + var_glojure_DOT_core_not_EQ_ := lang.InternVarName(sym_glojure_DOT_core, sym_not_EQ_) + // var glojure.core/ns + var_glojure_DOT_core_ns := lang.InternVarName(sym_glojure_DOT_core, sym_ns) + // var glojure.core/ns-aliases + var_glojure_DOT_core_ns_DASH_aliases := lang.InternVarName(sym_glojure_DOT_core, sym_ns_DASH_aliases) + // var glojure.core/ns-imports + var_glojure_DOT_core_ns_DASH_imports := lang.InternVarName(sym_glojure_DOT_core, sym_ns_DASH_imports) + // var glojure.core/ns-interns + var_glojure_DOT_core_ns_DASH_interns := lang.InternVarName(sym_glojure_DOT_core, sym_ns_DASH_interns) + // var glojure.core/ns-map + var_glojure_DOT_core_ns_DASH_map := lang.InternVarName(sym_glojure_DOT_core, sym_ns_DASH_map) + // var glojure.core/ns-name + var_glojure_DOT_core_ns_DASH_name := lang.InternVarName(sym_glojure_DOT_core, sym_ns_DASH_name) + // var glojure.core/ns-publics + var_glojure_DOT_core_ns_DASH_publics := lang.InternVarName(sym_glojure_DOT_core, sym_ns_DASH_publics) + // var glojure.core/ns-refers + var_glojure_DOT_core_ns_DASH_refers := lang.InternVarName(sym_glojure_DOT_core, sym_ns_DASH_refers) + // var glojure.core/ns-resolve + var_glojure_DOT_core_ns_DASH_resolve := lang.InternVarName(sym_glojure_DOT_core, sym_ns_DASH_resolve) + // var glojure.core/ns-unalias + var_glojure_DOT_core_ns_DASH_unalias := lang.InternVarName(sym_glojure_DOT_core, sym_ns_DASH_unalias) + // var glojure.core/ns-unmap + var_glojure_DOT_core_ns_DASH_unmap := lang.InternVarName(sym_glojure_DOT_core, sym_ns_DASH_unmap) + // var glojure.core/nth + var_glojure_DOT_core_nth := lang.InternVarName(sym_glojure_DOT_core, sym_nth) + // var glojure.core/nthnext + var_glojure_DOT_core_nthnext := lang.InternVarName(sym_glojure_DOT_core, sym_nthnext) + // var glojure.core/nthrest + var_glojure_DOT_core_nthrest := lang.InternVarName(sym_glojure_DOT_core, sym_nthrest) + // var glojure.core/num + var_glojure_DOT_core_num := lang.InternVarName(sym_glojure_DOT_core, sym_num) + // var glojure.core/number? + var_glojure_DOT_core_number_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_number_QMARK_) + // var glojure.core/numerator + var_glojure_DOT_core_numerator := lang.InternVarName(sym_glojure_DOT_core, sym_numerator) + // var glojure.core/object-array + var_glojure_DOT_core_object_DASH_array := lang.InternVarName(sym_glojure_DOT_core, sym_object_DASH_array) + // var glojure.core/odd? + var_glojure_DOT_core_odd_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_odd_QMARK_) + // var glojure.core/or + var_glojure_DOT_core_or := lang.InternVarName(sym_glojure_DOT_core, sym_or) + // var glojure.core/parents + var_glojure_DOT_core_parents := lang.InternVarName(sym_glojure_DOT_core, sym_parents) + // var glojure.core/parse-boolean + var_glojure_DOT_core_parse_DASH_boolean := lang.InternVarName(sym_glojure_DOT_core, sym_parse_DASH_boolean) + // var glojure.core/parse-double + var_glojure_DOT_core_parse_DASH_double := lang.InternVarName(sym_glojure_DOT_core, sym_parse_DASH_double) + // var glojure.core/parse-impls + var_glojure_DOT_core_parse_DASH_impls := lang.InternVarName(sym_glojure_DOT_core, sym_parse_DASH_impls) + // var glojure.core/parse-long + var_glojure_DOT_core_parse_DASH_long := lang.InternVarName(sym_glojure_DOT_core, sym_parse_DASH_long) + // var glojure.core/parse-uuid + var_glojure_DOT_core_parse_DASH_uuid := lang.InternVarName(sym_glojure_DOT_core, sym_parse_DASH_uuid) + // var glojure.core/parsing-err + var_glojure_DOT_core_parsing_DASH_err := lang.InternVarName(sym_glojure_DOT_core, sym_parsing_DASH_err) + // var glojure.core/partial + var_glojure_DOT_core_partial := lang.InternVarName(sym_glojure_DOT_core, sym_partial) + // var glojure.core/partition + var_glojure_DOT_core_partition := lang.InternVarName(sym_glojure_DOT_core, sym_partition) + // var glojure.core/partition-all + var_glojure_DOT_core_partition_DASH_all := lang.InternVarName(sym_glojure_DOT_core, sym_partition_DASH_all) + // var glojure.core/partition-by + var_glojure_DOT_core_partition_DASH_by := lang.InternVarName(sym_glojure_DOT_core, sym_partition_DASH_by) + // var glojure.core/partitionv + var_glojure_DOT_core_partitionv := lang.InternVarName(sym_glojure_DOT_core, sym_partitionv) + // var glojure.core/partitionv-all + var_glojure_DOT_core_partitionv_DASH_all := lang.InternVarName(sym_glojure_DOT_core, sym_partitionv_DASH_all) + // var glojure.core/pcalls + var_glojure_DOT_core_pcalls := lang.InternVarName(sym_glojure_DOT_core, sym_pcalls) + // var glojure.core/peek + var_glojure_DOT_core_peek := lang.InternVarName(sym_glojure_DOT_core, sym_peek) + // var glojure.core/persistent! + var_glojure_DOT_core_persistent_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_persistent_BANG_) + // var glojure.core/pmap + var_glojure_DOT_core_pmap := lang.InternVarName(sym_glojure_DOT_core, sym_pmap) + // var glojure.core/pop + var_glojure_DOT_core_pop := lang.InternVarName(sym_glojure_DOT_core, sym_pop) + // var glojure.core/pop! + var_glojure_DOT_core_pop_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_pop_BANG_) + // var glojure.core/pop-thread-bindings + var_glojure_DOT_core_pop_DASH_thread_DASH_bindings := lang.InternVarName(sym_glojure_DOT_core, sym_pop_DASH_thread_DASH_bindings) + // var glojure.core/pos-int? + var_glojure_DOT_core_pos_DASH_int_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_pos_DASH_int_QMARK_) + // var glojure.core/pos? + var_glojure_DOT_core_pos_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_pos_QMARK_) + // var glojure.core/pr + var_glojure_DOT_core_pr := lang.InternVarName(sym_glojure_DOT_core, sym_pr) + // var glojure.core/pr-on + var_glojure_DOT_core_pr_DASH_on := lang.InternVarName(sym_glojure_DOT_core, sym_pr_DASH_on) + // var glojure.core/pr-str + var_glojure_DOT_core_pr_DASH_str := lang.InternVarName(sym_glojure_DOT_core, sym_pr_DASH_str) + // var glojure.core/prefer-method + var_glojure_DOT_core_prefer_DASH_method := lang.InternVarName(sym_glojure_DOT_core, sym_prefer_DASH_method) + // var glojure.core/prefers + var_glojure_DOT_core_prefers := lang.InternVarName(sym_glojure_DOT_core, sym_prefers) + // var glojure.core/prep-hashes + var_glojure_DOT_core_prep_DASH_hashes := lang.InternVarName(sym_glojure_DOT_core, sym_prep_DASH_hashes) + // var glojure.core/prep-ints + var_glojure_DOT_core_prep_DASH_ints := lang.InternVarName(sym_glojure_DOT_core, sym_prep_DASH_ints) + // var glojure.core/prependss + var_glojure_DOT_core_prependss := lang.InternVarName(sym_glojure_DOT_core, sym_prependss) + // var glojure.core/preserving-reduced + var_glojure_DOT_core_preserving_DASH_reduced := lang.InternVarName(sym_glojure_DOT_core, sym_preserving_DASH_reduced) + // var glojure.core/print + var_glojure_DOT_core_print := lang.InternVarName(sym_glojure_DOT_core, sym_print) + // var glojure.core/print-ctor + var_glojure_DOT_core_print_DASH_ctor := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_ctor) + // var glojure.core/print-dup + var_glojure_DOT_core_print_DASH_dup := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_dup) + // var glojure.core/print-initialized + var_glojure_DOT_core_print_DASH_initialized := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_initialized) + // var glojure.core/print-map + var_glojure_DOT_core_print_DASH_map := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_map) + // var glojure.core/print-meta + var_glojure_DOT_core_print_DASH_meta := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_meta) + // var glojure.core/print-method + var_glojure_DOT_core_print_DASH_method := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_method) + // var glojure.core/print-object + var_glojure_DOT_core_print_DASH_object := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_object) + // var glojure.core/print-prefix-map + var_glojure_DOT_core_print_DASH_prefix_DASH_map := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_prefix_DASH_map) + // var glojure.core/print-sequential + var_glojure_DOT_core_print_DASH_sequential := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_sequential) + // var glojure.core/print-simple + var_glojure_DOT_core_print_DASH_simple := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_simple) + // var glojure.core/print-str + var_glojure_DOT_core_print_DASH_str := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_str) + // var glojure.core/print-tagged-object + var_glojure_DOT_core_print_DASH_tagged_DASH_object := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_tagged_DASH_object) + // var glojure.core/print-throwable + var_glojure_DOT_core_print_DASH_throwable := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_throwable) + // var glojure.core/printf + var_glojure_DOT_core_printf := lang.InternVarName(sym_glojure_DOT_core, sym_printf) + // var glojure.core/println + var_glojure_DOT_core_println := lang.InternVarName(sym_glojure_DOT_core, sym_println) + // var glojure.core/println-str + var_glojure_DOT_core_println_DASH_str := lang.InternVarName(sym_glojure_DOT_core, sym_println_DASH_str) + // var glojure.core/prn + var_glojure_DOT_core_prn := lang.InternVarName(sym_glojure_DOT_core, sym_prn) + // var glojure.core/prn-str + var_glojure_DOT_core_prn_DASH_str := lang.InternVarName(sym_glojure_DOT_core, sym_prn_DASH_str) + // var glojure.core/promise + var_glojure_DOT_core_promise := lang.InternVarName(sym_glojure_DOT_core, sym_promise) + // var glojure.core/protocol? + var_glojure_DOT_core_protocol_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_protocol_QMARK_) + // var glojure.core/push-thread-bindings + var_glojure_DOT_core_push_DASH_thread_DASH_bindings := lang.InternVarName(sym_glojure_DOT_core, sym_push_DASH_thread_DASH_bindings) + // var glojure.core/pvalues + var_glojure_DOT_core_pvalues := lang.InternVarName(sym_glojure_DOT_core, sym_pvalues) + // var glojure.core/qualified-ident? + var_glojure_DOT_core_qualified_DASH_ident_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_qualified_DASH_ident_QMARK_) + // var glojure.core/qualified-keyword? + var_glojure_DOT_core_qualified_DASH_keyword_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_qualified_DASH_keyword_QMARK_) + // var glojure.core/qualified-symbol? + var_glojure_DOT_core_qualified_DASH_symbol_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_qualified_DASH_symbol_QMARK_) + // var glojure.core/quot + var_glojure_DOT_core_quot := lang.InternVarName(sym_glojure_DOT_core, sym_quot) + // var glojure.core/rand + var_glojure_DOT_core_rand := lang.InternVarName(sym_glojure_DOT_core, sym_rand) + // var glojure.core/rand-int + var_glojure_DOT_core_rand_DASH_int := lang.InternVarName(sym_glojure_DOT_core, sym_rand_DASH_int) + // var glojure.core/rand-nth + var_glojure_DOT_core_rand_DASH_nth := lang.InternVarName(sym_glojure_DOT_core, sym_rand_DASH_nth) + // var glojure.core/random-sample + var_glojure_DOT_core_random_DASH_sample := lang.InternVarName(sym_glojure_DOT_core, sym_random_DASH_sample) + // var glojure.core/random-uuid + var_glojure_DOT_core_random_DASH_uuid := lang.InternVarName(sym_glojure_DOT_core, sym_random_DASH_uuid) + // var glojure.core/range + var_glojure_DOT_core_range := lang.InternVarName(sym_glojure_DOT_core, sym_range) + // var glojure.core/ratio? + var_glojure_DOT_core_ratio_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_ratio_QMARK_) + // var glojure.core/rational? + var_glojure_DOT_core_rational_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_rational_QMARK_) + // var glojure.core/rationalize + var_glojure_DOT_core_rationalize := lang.InternVarName(sym_glojure_DOT_core, sym_rationalize) + // var glojure.core/re-find + var_glojure_DOT_core_re_DASH_find := lang.InternVarName(sym_glojure_DOT_core, sym_re_DASH_find) + // var glojure.core/re-groups + var_glojure_DOT_core_re_DASH_groups := lang.InternVarName(sym_glojure_DOT_core, sym_re_DASH_groups) + // var glojure.core/re-matcher + var_glojure_DOT_core_re_DASH_matcher := lang.InternVarName(sym_glojure_DOT_core, sym_re_DASH_matcher) + // var glojure.core/re-matches + var_glojure_DOT_core_re_DASH_matches := lang.InternVarName(sym_glojure_DOT_core, sym_re_DASH_matches) + // var glojure.core/re-pattern + var_glojure_DOT_core_re_DASH_pattern := lang.InternVarName(sym_glojure_DOT_core, sym_re_DASH_pattern) + // var glojure.core/re-seq + var_glojure_DOT_core_re_DASH_seq := lang.InternVarName(sym_glojure_DOT_core, sym_re_DASH_seq) + // var glojure.core/read + var_glojure_DOT_core_read := lang.InternVarName(sym_glojure_DOT_core, sym_read) + // var glojure.core/read-line + var_glojure_DOT_core_read_DASH_line := lang.InternVarName(sym_glojure_DOT_core, sym_read_DASH_line) + // var glojure.core/read-string + var_glojure_DOT_core_read_DASH_string := lang.InternVarName(sym_glojure_DOT_core, sym_read_DASH_string) + // var glojure.core/read+string + var_glojure_DOT_core_read_PLUS_string := lang.InternVarName(sym_glojure_DOT_core, sym_read_PLUS_string) + // var glojure.core/reader-conditional + var_glojure_DOT_core_reader_DASH_conditional := lang.InternVarName(sym_glojure_DOT_core, sym_reader_DASH_conditional) + // var glojure.core/reader-conditional? + var_glojure_DOT_core_reader_DASH_conditional_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_reader_DASH_conditional_QMARK_) + // var glojure.core/realized? + var_glojure_DOT_core_realized_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_realized_QMARK_) + // var glojure.core/reduce + var_glojure_DOT_core_reduce := lang.InternVarName(sym_glojure_DOT_core, sym_reduce) + // var glojure.core/reduce1 + var_glojure_DOT_core_reduce1 := lang.InternVarName(sym_glojure_DOT_core, sym_reduce1) + // var glojure.core/reduce-kv + var_glojure_DOT_core_reduce_DASH_kv := lang.InternVarName(sym_glojure_DOT_core, sym_reduce_DASH_kv) + // var glojure.core/reduced + var_glojure_DOT_core_reduced := lang.InternVarName(sym_glojure_DOT_core, sym_reduced) + // var glojure.core/reduced? + var_glojure_DOT_core_reduced_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_reduced_QMARK_) + // var glojure.core/reductions + var_glojure_DOT_core_reductions := lang.InternVarName(sym_glojure_DOT_core, sym_reductions) + // var glojure.core/ref + var_glojure_DOT_core_ref := lang.InternVarName(sym_glojure_DOT_core, sym_ref) + // var glojure.core/ref-history-count + var_glojure_DOT_core_ref_DASH_history_DASH_count := lang.InternVarName(sym_glojure_DOT_core, sym_ref_DASH_history_DASH_count) + // var glojure.core/ref-max-history + var_glojure_DOT_core_ref_DASH_max_DASH_history := lang.InternVarName(sym_glojure_DOT_core, sym_ref_DASH_max_DASH_history) + // var glojure.core/ref-min-history + var_glojure_DOT_core_ref_DASH_min_DASH_history := lang.InternVarName(sym_glojure_DOT_core, sym_ref_DASH_min_DASH_history) + // var glojure.core/ref-set + var_glojure_DOT_core_ref_DASH_set := lang.InternVarName(sym_glojure_DOT_core, sym_ref_DASH_set) + // var glojure.core/refer + var_glojure_DOT_core_refer := lang.InternVarName(sym_glojure_DOT_core, sym_refer) + // var glojure.core/refer-glojure + var_glojure_DOT_core_refer_DASH_glojure := lang.InternVarName(sym_glojure_DOT_core, sym_refer_DASH_glojure) + // var glojure.core/release-pending-sends + var_glojure_DOT_core_release_DASH_pending_DASH_sends := lang.InternVarName(sym_glojure_DOT_core, sym_release_DASH_pending_DASH_sends) + // var glojure.core/rem + var_glojure_DOT_core_rem := lang.InternVarName(sym_glojure_DOT_core, sym_rem) + // var glojure.core/remove + var_glojure_DOT_core_remove := lang.InternVarName(sym_glojure_DOT_core, sym_remove) + // var glojure.core/remove-all-methods + var_glojure_DOT_core_remove_DASH_all_DASH_methods := lang.InternVarName(sym_glojure_DOT_core, sym_remove_DASH_all_DASH_methods) + // var glojure.core/remove-method + var_glojure_DOT_core_remove_DASH_method := lang.InternVarName(sym_glojure_DOT_core, sym_remove_DASH_method) + // var glojure.core/remove-ns + var_glojure_DOT_core_remove_DASH_ns := lang.InternVarName(sym_glojure_DOT_core, sym_remove_DASH_ns) + // var glojure.core/remove-tap + var_glojure_DOT_core_remove_DASH_tap := lang.InternVarName(sym_glojure_DOT_core, sym_remove_DASH_tap) + // var glojure.core/remove-watch + var_glojure_DOT_core_remove_DASH_watch := lang.InternVarName(sym_glojure_DOT_core, sym_remove_DASH_watch) + // var glojure.core/repeat + var_glojure_DOT_core_repeat := lang.InternVarName(sym_glojure_DOT_core, sym_repeat) + // var glojure.core/repeatedly + var_glojure_DOT_core_repeatedly := lang.InternVarName(sym_glojure_DOT_core, sym_repeatedly) + // var glojure.core/replace + var_glojure_DOT_core_replace := lang.InternVarName(sym_glojure_DOT_core, sym_replace) + // var glojure.core/replicate + var_glojure_DOT_core_replicate := lang.InternVarName(sym_glojure_DOT_core, sym_replicate) + // var glojure.core/require + var_glojure_DOT_core_require := lang.InternVarName(sym_glojure_DOT_core, sym_require) + // var glojure.core/requiring-resolve + var_glojure_DOT_core_requiring_DASH_resolve := lang.InternVarName(sym_glojure_DOT_core, sym_requiring_DASH_resolve) + // var glojure.core/reset! + var_glojure_DOT_core_reset_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_reset_BANG_) + // var glojure.core/reset-meta! + var_glojure_DOT_core_reset_DASH_meta_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_reset_DASH_meta_BANG_) + // var glojure.core/reset-vals! + var_glojure_DOT_core_reset_DASH_vals_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_reset_DASH_vals_BANG_) + // var glojure.core/resolve + var_glojure_DOT_core_resolve := lang.InternVarName(sym_glojure_DOT_core, sym_resolve) + // var glojure.core/rest + var_glojure_DOT_core_rest := lang.InternVarName(sym_glojure_DOT_core, sym_rest) + // var glojure.core/restart-agent + var_glojure_DOT_core_restart_DASH_agent := lang.InternVarName(sym_glojure_DOT_core, sym_restart_DASH_agent) + // var glojure.core/resultset-seq + var_glojure_DOT_core_resultset_DASH_seq := lang.InternVarName(sym_glojure_DOT_core, sym_resultset_DASH_seq) + // var glojure.core/reverse + var_glojure_DOT_core_reverse := lang.InternVarName(sym_glojure_DOT_core, sym_reverse) + // var glojure.core/reversible? + var_glojure_DOT_core_reversible_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_reversible_QMARK_) + // var glojure.core/root-directory + var_glojure_DOT_core_root_DASH_directory := lang.InternVarName(sym_glojure_DOT_core, sym_root_DASH_directory) + // var glojure.core/root-resource + var_glojure_DOT_core_root_DASH_resource := lang.InternVarName(sym_glojure_DOT_core, sym_root_DASH_resource) + // var glojure.core/rseq + var_glojure_DOT_core_rseq := lang.InternVarName(sym_glojure_DOT_core, sym_rseq) + // var glojure.core/rsubseq + var_glojure_DOT_core_rsubseq := lang.InternVarName(sym_glojure_DOT_core, sym_rsubseq) + // var glojure.core/run! + var_glojure_DOT_core_run_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_run_BANG_) + // var glojure.core/second + var_glojure_DOT_core_second := lang.InternVarName(sym_glojure_DOT_core, sym_second) + // var glojure.core/select-keys + var_glojure_DOT_core_select_DASH_keys := lang.InternVarName(sym_glojure_DOT_core, sym_select_DASH_keys) + // var glojure.core/send + var_glojure_DOT_core_send := lang.InternVarName(sym_glojure_DOT_core, sym_send) + // var glojure.core/send-off + var_glojure_DOT_core_send_DASH_off := lang.InternVarName(sym_glojure_DOT_core, sym_send_DASH_off) + // var glojure.core/send-via + var_glojure_DOT_core_send_DASH_via := lang.InternVarName(sym_glojure_DOT_core, sym_send_DASH_via) + // var glojure.core/seq + var_glojure_DOT_core_seq := lang.InternVarName(sym_glojure_DOT_core, sym_seq) + // var glojure.core/seq-to-map-for-destructuring + var_glojure_DOT_core_seq_DASH_to_DASH_map_DASH_for_DASH_destructuring := lang.InternVarName(sym_glojure_DOT_core, sym_seq_DASH_to_DASH_map_DASH_for_DASH_destructuring) + // var glojure.core/seq? + var_glojure_DOT_core_seq_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_seq_QMARK_) + // var glojure.core/seqable? + var_glojure_DOT_core_seqable_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_seqable_QMARK_) + // var glojure.core/seque + var_glojure_DOT_core_seque := lang.InternVarName(sym_glojure_DOT_core, sym_seque) + // var glojure.core/sequence + var_glojure_DOT_core_sequence := lang.InternVarName(sym_glojure_DOT_core, sym_sequence) + // var glojure.core/sequential? + var_glojure_DOT_core_sequential_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_sequential_QMARK_) + // var glojure.core/serialized-require + var_glojure_DOT_core_serialized_DASH_require := lang.InternVarName(sym_glojure_DOT_core, sym_serialized_DASH_require) + // var glojure.core/set + var_glojure_DOT_core_set := lang.InternVarName(sym_glojure_DOT_core, sym_set) + // var glojure.core/set-agent-send-executor! + var_glojure_DOT_core_set_DASH_agent_DASH_send_DASH_executor_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_set_DASH_agent_DASH_send_DASH_executor_BANG_) + // var glojure.core/set-agent-send-off-executor! + var_glojure_DOT_core_set_DASH_agent_DASH_send_DASH_off_DASH_executor_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_set_DASH_agent_DASH_send_DASH_off_DASH_executor_BANG_) + // var glojure.core/set-error-handler! + var_glojure_DOT_core_set_DASH_error_DASH_handler_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_set_DASH_error_DASH_handler_BANG_) + // var glojure.core/set-error-mode! + var_glojure_DOT_core_set_DASH_error_DASH_mode_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_set_DASH_error_DASH_mode_BANG_) + // var glojure.core/set-validator! + var_glojure_DOT_core_set_DASH_validator_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_set_DASH_validator_BANG_) + // var glojure.core/set? + var_glojure_DOT_core_set_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_set_QMARK_) + // var glojure.core/setup-reference + var_glojure_DOT_core_setup_DASH_reference := lang.InternVarName(sym_glojure_DOT_core, sym_setup_DASH_reference) + // var glojure.core/shift-mask + var_glojure_DOT_core_shift_DASH_mask := lang.InternVarName(sym_glojure_DOT_core, sym_shift_DASH_mask) + // var glojure.core/short + var_glojure_DOT_core_short := lang.InternVarName(sym_glojure_DOT_core, sym_short) + // var glojure.core/short-array + var_glojure_DOT_core_short_DASH_array := lang.InternVarName(sym_glojure_DOT_core, sym_short_DASH_array) + // var glojure.core/shorts + var_glojure_DOT_core_shorts := lang.InternVarName(sym_glojure_DOT_core, sym_shorts) + // var glojure.core/shuffle + var_glojure_DOT_core_shuffle := lang.InternVarName(sym_glojure_DOT_core, sym_shuffle) + // var glojure.core/shutdown-agents + var_glojure_DOT_core_shutdown_DASH_agents := lang.InternVarName(sym_glojure_DOT_core, sym_shutdown_DASH_agents) + // var glojure.core/sigs + var_glojure_DOT_core_sigs := lang.InternVarName(sym_glojure_DOT_core, sym_sigs) + // var glojure.core/simple-ident? + var_glojure_DOT_core_simple_DASH_ident_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_simple_DASH_ident_QMARK_) + // var glojure.core/simple-keyword? + var_glojure_DOT_core_simple_DASH_keyword_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_simple_DASH_keyword_QMARK_) + // var glojure.core/simple-symbol? + var_glojure_DOT_core_simple_DASH_symbol_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_simple_DASH_symbol_QMARK_) + // var glojure.core/slurp + var_glojure_DOT_core_slurp := lang.InternVarName(sym_glojure_DOT_core, sym_slurp) + // var glojure.core/some + var_glojure_DOT_core_some := lang.InternVarName(sym_glojure_DOT_core, sym_some) + // var glojure.core/some-> + var_glojure_DOT_core_some_DASH__GT_ := lang.InternVarName(sym_glojure_DOT_core, sym_some_DASH__GT_) + // var glojure.core/some->> + var_glojure_DOT_core_some_DASH__GT__GT_ := lang.InternVarName(sym_glojure_DOT_core, sym_some_DASH__GT__GT_) + // var glojure.core/some-fn + var_glojure_DOT_core_some_DASH_fn := lang.InternVarName(sym_glojure_DOT_core, sym_some_DASH_fn) + // var glojure.core/some? + var_glojure_DOT_core_some_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_some_QMARK_) + // var glojure.core/sort + var_glojure_DOT_core_sort := lang.InternVarName(sym_glojure_DOT_core, sym_sort) + // var glojure.core/sort-by + var_glojure_DOT_core_sort_DASH_by := lang.InternVarName(sym_glojure_DOT_core, sym_sort_DASH_by) + // var glojure.core/sorted-map + var_glojure_DOT_core_sorted_DASH_map := lang.InternVarName(sym_glojure_DOT_core, sym_sorted_DASH_map) + // var glojure.core/sorted-map-by + var_glojure_DOT_core_sorted_DASH_map_DASH_by := lang.InternVarName(sym_glojure_DOT_core, sym_sorted_DASH_map_DASH_by) + // var glojure.core/sorted-set + var_glojure_DOT_core_sorted_DASH_set := lang.InternVarName(sym_glojure_DOT_core, sym_sorted_DASH_set) + // var glojure.core/sorted-set-by + var_glojure_DOT_core_sorted_DASH_set_DASH_by := lang.InternVarName(sym_glojure_DOT_core, sym_sorted_DASH_set_DASH_by) + // var glojure.core/sorted? + var_glojure_DOT_core_sorted_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_sorted_QMARK_) + // var glojure.core/special-symbol? + var_glojure_DOT_core_special_DASH_symbol_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_special_DASH_symbol_QMARK_) + // var glojure.core/spit + var_glojure_DOT_core_spit := lang.InternVarName(sym_glojure_DOT_core, sym_spit) + // var glojure.core/split-at + var_glojure_DOT_core_split_DASH_at := lang.InternVarName(sym_glojure_DOT_core, sym_split_DASH_at) + // var glojure.core/split-with + var_glojure_DOT_core_split_DASH_with := lang.InternVarName(sym_glojure_DOT_core, sym_split_DASH_with) + // var glojure.core/splitv-at + var_glojure_DOT_core_splitv_DASH_at := lang.InternVarName(sym_glojure_DOT_core, sym_splitv_DASH_at) + // var glojure.core/spread + var_glojure_DOT_core_spread := lang.InternVarName(sym_glojure_DOT_core, sym_spread) + // var glojure.core/str + var_glojure_DOT_core_str := lang.InternVarName(sym_glojure_DOT_core, sym_str) + // var glojure.core/stream-into! + var_glojure_DOT_core_stream_DASH_into_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_stream_DASH_into_BANG_) + // var glojure.core/stream-reduce! + var_glojure_DOT_core_stream_DASH_reduce_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_stream_DASH_reduce_BANG_) + // var glojure.core/stream-seq! + var_glojure_DOT_core_stream_DASH_seq_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_stream_DASH_seq_BANG_) + // var glojure.core/stream-transduce! + var_glojure_DOT_core_stream_DASH_transduce_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_stream_DASH_transduce_BANG_) + // var glojure.core/string? + var_glojure_DOT_core_string_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_string_QMARK_) + // var glojure.core/strip-ns + var_glojure_DOT_core_strip_DASH_ns := lang.InternVarName(sym_glojure_DOT_core, sym_strip_DASH_ns) + // var glojure.core/struct + var_glojure_DOT_core_struct := lang.InternVarName(sym_glojure_DOT_core, sym_struct) + // var glojure.core/struct-map + var_glojure_DOT_core_struct_DASH_map := lang.InternVarName(sym_glojure_DOT_core, sym_struct_DASH_map) + // var glojure.core/subs + var_glojure_DOT_core_subs := lang.InternVarName(sym_glojure_DOT_core, sym_subs) + // var glojure.core/subseq + var_glojure_DOT_core_subseq := lang.InternVarName(sym_glojure_DOT_core, sym_subseq) + // var glojure.core/subvec + var_glojure_DOT_core_subvec := lang.InternVarName(sym_glojure_DOT_core, sym_subvec) + // var glojure.core/supers + var_glojure_DOT_core_supers := lang.InternVarName(sym_glojure_DOT_core, sym_supers) + // var glojure.core/swap! + var_glojure_DOT_core_swap_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_swap_BANG_) + // var glojure.core/swap-vals! + var_glojure_DOT_core_swap_DASH_vals_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_swap_DASH_vals_BANG_) + // var glojure.core/symbol + var_glojure_DOT_core_symbol := lang.InternVarName(sym_glojure_DOT_core, sym_symbol) + // var glojure.core/symbol? + var_glojure_DOT_core_symbol_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_symbol_QMARK_) + // var glojure.core/sync + var_glojure_DOT_core_sync := lang.InternVarName(sym_glojure_DOT_core, sym_sync) + // var glojure.core/system-newline + var_glojure_DOT_core_system_DASH_newline := lang.InternVarName(sym_glojure_DOT_core, sym_system_DASH_newline) + // var glojure.core/tagged-literal + var_glojure_DOT_core_tagged_DASH_literal := lang.InternVarName(sym_glojure_DOT_core, sym_tagged_DASH_literal) + // var glojure.core/tagged-literal? + var_glojure_DOT_core_tagged_DASH_literal_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_tagged_DASH_literal_QMARK_) + // var glojure.core/take + var_glojure_DOT_core_take := lang.InternVarName(sym_glojure_DOT_core, sym_take) + // var glojure.core/take-last + var_glojure_DOT_core_take_DASH_last := lang.InternVarName(sym_glojure_DOT_core, sym_take_DASH_last) + // var glojure.core/take-nth + var_glojure_DOT_core_take_DASH_nth := lang.InternVarName(sym_glojure_DOT_core, sym_take_DASH_nth) + // var glojure.core/take-while + var_glojure_DOT_core_take_DASH_while := lang.InternVarName(sym_glojure_DOT_core, sym_take_DASH_while) + // var glojure.core/tapset + var_glojure_DOT_core_tapset := lang.InternVarName(sym_glojure_DOT_core, sym_tapset) + // var glojure.core/test + var_glojure_DOT_core_test := lang.InternVarName(sym_glojure_DOT_core, sym_test) + // var glojure.core/the-ns + var_glojure_DOT_core_the_DASH_ns := lang.InternVarName(sym_glojure_DOT_core, sym_the_DASH_ns) + // var glojure.core/thread-bound? + var_glojure_DOT_core_thread_DASH_bound_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_thread_DASH_bound_QMARK_) + // var glojure.core/throw-if + var_glojure_DOT_core_throw_DASH_if := lang.InternVarName(sym_glojure_DOT_core, sym_throw_DASH_if) + // var glojure.core/time + var_glojure_DOT_core_time := lang.InternVarName(sym_glojure_DOT_core, sym_time) + // var glojure.core/to-array + var_glojure_DOT_core_to_DASH_array := lang.InternVarName(sym_glojure_DOT_core, sym_to_DASH_array) + // var glojure.core/to-array-2d + var_glojure_DOT_core_to_DASH_array_DASH_2d := lang.InternVarName(sym_glojure_DOT_core, sym_to_DASH_array_DASH_2d) + // var glojure.core/trampoline + var_glojure_DOT_core_trampoline := lang.InternVarName(sym_glojure_DOT_core, sym_trampoline) + // var glojure.core/transduce + var_glojure_DOT_core_transduce := lang.InternVarName(sym_glojure_DOT_core, sym_transduce) + // var glojure.core/transient + var_glojure_DOT_core_transient := lang.InternVarName(sym_glojure_DOT_core, sym_transient) + // var glojure.core/tree-seq + var_glojure_DOT_core_tree_DASH_seq := lang.InternVarName(sym_glojure_DOT_core, sym_tree_DASH_seq) + // var glojure.core/true? + var_glojure_DOT_core_true_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_true_QMARK_) + // var glojure.core/type + var_glojure_DOT_core_type := lang.InternVarName(sym_glojure_DOT_core, sym_type) + // var glojure.core/unchecked-add + var_glojure_DOT_core_unchecked_DASH_add := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_add) + // var glojure.core/unchecked-add-int + var_glojure_DOT_core_unchecked_DASH_add_DASH_int := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_add_DASH_int) + // var glojure.core/unchecked-byte + var_glojure_DOT_core_unchecked_DASH_byte := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_byte) + // var glojure.core/unchecked-char + var_glojure_DOT_core_unchecked_DASH_char := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_char) + // var glojure.core/unchecked-dec + var_glojure_DOT_core_unchecked_DASH_dec := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_dec) + // var glojure.core/unchecked-dec-int + var_glojure_DOT_core_unchecked_DASH_dec_DASH_int := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_dec_DASH_int) + // var glojure.core/unchecked-divide-int + var_glojure_DOT_core_unchecked_DASH_divide_DASH_int := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_divide_DASH_int) + // var glojure.core/unchecked-double + var_glojure_DOT_core_unchecked_DASH_double := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_double) + // var glojure.core/unchecked-float + var_glojure_DOT_core_unchecked_DASH_float := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_float) + // var glojure.core/unchecked-inc + var_glojure_DOT_core_unchecked_DASH_inc := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_inc) + // var glojure.core/unchecked-inc-int + var_glojure_DOT_core_unchecked_DASH_inc_DASH_int := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_inc_DASH_int) + // var glojure.core/unchecked-int + var_glojure_DOT_core_unchecked_DASH_int := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_int) + // var glojure.core/unchecked-long + var_glojure_DOT_core_unchecked_DASH_long := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_long) + // var glojure.core/unchecked-multiply + var_glojure_DOT_core_unchecked_DASH_multiply := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_multiply) + // var glojure.core/unchecked-multiply-int + var_glojure_DOT_core_unchecked_DASH_multiply_DASH_int := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_multiply_DASH_int) + // var glojure.core/unchecked-negate + var_glojure_DOT_core_unchecked_DASH_negate := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_negate) + // var glojure.core/unchecked-negate-int + var_glojure_DOT_core_unchecked_DASH_negate_DASH_int := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_negate_DASH_int) + // var glojure.core/unchecked-remainder-int + var_glojure_DOT_core_unchecked_DASH_remainder_DASH_int := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_remainder_DASH_int) + // var glojure.core/unchecked-short + var_glojure_DOT_core_unchecked_DASH_short := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_short) + // var glojure.core/unchecked-subtract + var_glojure_DOT_core_unchecked_DASH_subtract := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_subtract) + // var glojure.core/unchecked-subtract-int + var_glojure_DOT_core_unchecked_DASH_subtract_DASH_int := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_subtract_DASH_int) + // var glojure.core/underive + var_glojure_DOT_core_underive := lang.InternVarName(sym_glojure_DOT_core, sym_underive) + // var glojure.core/unquote + var_glojure_DOT_core_unquote := lang.InternVarName(sym_glojure_DOT_core, sym_unquote) + // var glojure.core/unquote-splicing + var_glojure_DOT_core_unquote_DASH_splicing := lang.InternVarName(sym_glojure_DOT_core, sym_unquote_DASH_splicing) + // var glojure.core/unreduced + var_glojure_DOT_core_unreduced := lang.InternVarName(sym_glojure_DOT_core, sym_unreduced) + // var glojure.core/unsigned-bit-shift-right + var_glojure_DOT_core_unsigned_DASH_bit_DASH_shift_DASH_right := lang.InternVarName(sym_glojure_DOT_core, sym_unsigned_DASH_bit_DASH_shift_DASH_right) + // var glojure.core/update + var_glojure_DOT_core_update := lang.InternVarName(sym_glojure_DOT_core, sym_update) + // var glojure.core/update-in + var_glojure_DOT_core_update_DASH_in := lang.InternVarName(sym_glojure_DOT_core, sym_update_DASH_in) + // var glojure.core/update-keys + var_glojure_DOT_core_update_DASH_keys := lang.InternVarName(sym_glojure_DOT_core, sym_update_DASH_keys) + // var glojure.core/update-vals + var_glojure_DOT_core_update_DASH_vals := lang.InternVarName(sym_glojure_DOT_core, sym_update_DASH_vals) + // var glojure.core/uri? + var_glojure_DOT_core_uri_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_uri_QMARK_) + // var glojure.core/use + var_glojure_DOT_core_use := lang.InternVarName(sym_glojure_DOT_core, sym_use) + // var glojure.core/uuid? + var_glojure_DOT_core_uuid_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_uuid_QMARK_) + // var glojure.core/val + var_glojure_DOT_core_val := lang.InternVarName(sym_glojure_DOT_core, sym_val) + // var glojure.core/vals + var_glojure_DOT_core_vals := lang.InternVarName(sym_glojure_DOT_core, sym_vals) + // var glojure.core/var-get + var_glojure_DOT_core_var_DASH_get := lang.InternVarName(sym_glojure_DOT_core, sym_var_DASH_get) + // var glojure.core/var-set + var_glojure_DOT_core_var_DASH_set := lang.InternVarName(sym_glojure_DOT_core, sym_var_DASH_set) + // var glojure.core/var? + var_glojure_DOT_core_var_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_var_QMARK_) + // var glojure.core/vary-meta + var_glojure_DOT_core_vary_DASH_meta := lang.InternVarName(sym_glojure_DOT_core, sym_vary_DASH_meta) + // var glojure.core/vec + var_glojure_DOT_core_vec := lang.InternVarName(sym_glojure_DOT_core, sym_vec) + // var glojure.core/vector + var_glojure_DOT_core_vector := lang.InternVarName(sym_glojure_DOT_core, sym_vector) + // var glojure.core/vector? + var_glojure_DOT_core_vector_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_vector_QMARK_) + // var glojure.core/volatile! + var_glojure_DOT_core_volatile_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_volatile_BANG_) + // var glojure.core/volatile? + var_glojure_DOT_core_volatile_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_volatile_QMARK_) + // var glojure.core/vreset! + var_glojure_DOT_core_vreset_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_vreset_BANG_) + // var glojure.core/vswap! + var_glojure_DOT_core_vswap_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_vswap_BANG_) + // var glojure.core/when + var_glojure_DOT_core_when := lang.InternVarName(sym_glojure_DOT_core, sym_when) + // var glojure.core/when-first + var_glojure_DOT_core_when_DASH_first := lang.InternVarName(sym_glojure_DOT_core, sym_when_DASH_first) + // var glojure.core/when-let + var_glojure_DOT_core_when_DASH_let := lang.InternVarName(sym_glojure_DOT_core, sym_when_DASH_let) + // var glojure.core/when-not + var_glojure_DOT_core_when_DASH_not := lang.InternVarName(sym_glojure_DOT_core, sym_when_DASH_not) + // var glojure.core/when-some + var_glojure_DOT_core_when_DASH_some := lang.InternVarName(sym_glojure_DOT_core, sym_when_DASH_some) + // var glojure.core/while + var_glojure_DOT_core_while := lang.InternVarName(sym_glojure_DOT_core, sym_while) + // var glojure.core/with-bindings + var_glojure_DOT_core_with_DASH_bindings := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_bindings) + // var glojure.core/with-bindings* + var_glojure_DOT_core_with_DASH_bindings_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_bindings_STAR_) + // var glojure.core/with-in-str + var_glojure_DOT_core_with_DASH_in_DASH_str := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_in_DASH_str) + // var glojure.core/with-loading-context + var_glojure_DOT_core_with_DASH_loading_DASH_context := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_loading_DASH_context) + // var glojure.core/with-local-vars + var_glojure_DOT_core_with_DASH_local_DASH_vars := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_local_DASH_vars) + // var glojure.core/with-meta + var_glojure_DOT_core_with_DASH_meta := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_meta) + // var glojure.core/with-open + var_glojure_DOT_core_with_DASH_open := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_open) + // var glojure.core/with-out-str + var_glojure_DOT_core_with_DASH_out_DASH_str := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_out_DASH_str) + // var glojure.core/with-precision + var_glojure_DOT_core_with_DASH_precision := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_precision) + // var glojure.core/with-redefs + var_glojure_DOT_core_with_DASH_redefs := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_redefs) + // var glojure.core/with-redefs-fn + var_glojure_DOT_core_with_DASH_redefs_DASH_fn := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_redefs_DASH_fn) + // var glojure.core/xml-seq + var_glojure_DOT_core_xml_DASH_seq := lang.InternVarName(sym_glojure_DOT_core, sym_xml_DASH_seq) + // var glojure.core/zero? + var_glojure_DOT_core_zero_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_zero_QMARK_) + // var glojure.core/zipmap + var_glojure_DOT_core_zipmap := lang.InternVarName(sym_glojure_DOT_core, sym_zipmap) + // var glojure.go.io/copy + var_glojure_DOT_go_DOT_io_copy := lang.InternVarName(sym_glojure_DOT_go_DOT_io, sym_copy) + // var glojure.go.io/reader + var_glojure_DOT_go_DOT_io_reader := lang.InternVarName(sym_glojure_DOT_go_DOT_io, sym_reader) + // reference fmt to avoid unused import error + _ = fmt.Printf + // reference reflect to avoid unused import error + _ = reflect.TypeOf + ns := lang.FindOrCreateNamespace(sym_glojure_DOT_core) + _ = ns + var closed0 any + { + closed0 = sym_unchecked_multiply + } + var closed1 any + { + closed1 = sym_multiply + } + var closed10 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + tmp3, _ := lang.FieldOrMethod(v1, "Reduce") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Reduce is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{v2}) + return tmp4 + case 3: + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + v3 := args[2] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v1, "ReduceInit") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + closed10 = tmp0 + } + var closed13 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + v3 := args[2] + _ = v3 + return v3 + }) + closed13 = tmp0 + } + var closed16 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v1 := args[0] + _ = v1 + return nil + }) + closed16 = tmp0 + } + var closed17 any + { + closed17 = sym_divide + } + var closed18 any + { + closed18 = sym_and + } + var closed19 any + { + closed19 = sym_andNot + } + var closed2 any + { + closed2 = sym_multiplyP + } + var closed20 any + { + closed20 = sym_or + } + var closed21 any + { + closed21 = sym_xor + } + var closed22 any + { + closed22 = sym_max + } + var closed23 any + { + closed23 = sym_min + } + var closed24 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v1 := args[0] + _ = v1 + var tmp2 any + if lang.IsTruthy(v1) { + tmp2 = false + } else { + tmp2 = true + } + return tmp2 + }) + tmp1 := reflect.TypeOf(false) + tmp0 = tmp0.WithMeta(lang.NewMap(kw_rettag, tmp1)).(lang.FnFunc) + closed24 = tmp0 + } + var closed3 any + { + closed3 = sym_unchecked_add + } + var closed4 any + { + closed4 = sym_add + } + var closed5 any + { + closed5 = sym_addP + } + var closed6 any + { + closed6 = sym_unchecked_minus + } + var closed7 any + { + closed7 = sym_minus + } + var closed8 any + { + closed8 = sym_minusP + } + var closed9 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + tmp3 := lang.Apply(v2, nil) + return tmp3 + case 3: + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + v3 := args[2] + _ = v3 + return v3 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + closed9 = tmp0 + } + // >0? + { + tmp0 := sym__GT_0_QMARK_.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(963), kw_column, int(7), kw_end_DASH_line, int(963), kw_end_DASH_column, int(19), kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{nil, int64(0)}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__GT_0_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__GT_0_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // >1? + { + tmp0 := sym__GT_1_QMARK_.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(962), kw_column, int(7), kw_end_DASH_line, int(962), kw_end_DASH_column, int(19), kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{nil, int64(1)}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__GT_1_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__GT_1_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *1 + { + tmp0 := sym__STAR_1.WithMeta(lang.NewMap()).(*lang.Symbol) + var_glojure_DOT_core__STAR_1 = ns.Intern(tmp0) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *2 + { + tmp0 := sym__STAR_2.WithMeta(lang.NewMap()).(*lang.Symbol) + var_glojure_DOT_core__STAR_2 = ns.Intern(tmp0) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *3 + { + tmp0 := sym__STAR_3.WithMeta(lang.NewMap()).(*lang.Symbol) + var_glojure_DOT_core__STAR_3 = ns.Intern(tmp0) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *agent* + { + tmp0 := sym__STAR_agent_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_agent_STAR_ = ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_agent_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *assert* + { + tmp0 := sym__STAR_assert_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "When set to logical false, 'assert' will omit assertion checks in\n compiled code. Defaults to true.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_assert_STAR_ = ns.InternWithValue(tmp0, false, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_assert_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *command-line-args* + { + tmp0 := sym__STAR_command_DASH_line_DASH_args_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "A sequence of the supplied command line arguments, or nil if\n none were supplied", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_command_DASH_line_DASH_args_STAR_ = ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_command_DASH_line_DASH_args_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *compile-files* + { + tmp0 := sym__STAR_compile_DASH_files_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "Set to true when compiling files, false otherwise.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_compile_DASH_files_STAR_ = ns.InternWithValue(tmp0, true, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_compile_DASH_files_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *compile-path* + { + tmp0 := sym__STAR_compile_DASH_path_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "Specifies the directory where 'compile' will write out .class\n files. This directory must be in the classpath for 'compile' to\n work.\n\n Defaults to \"classes\"", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_compile_DASH_path_STAR_ = ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_compile_DASH_path_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *compiler-options* + { + tmp0 := sym__STAR_compiler_DASH_options_STAR_.WithMeta(lang.NewMap(kw_added, "1.4", kw_doc, "A map of keys to options.\n Note, when binding dynamically make sure to merge with previous value.\n Supported options:\n :elide-meta - a collection of metadata keys to elide during compilation.\n :disable-locals-clearing - set to true to disable clearing, useful for using a debugger\n :direct-linking - set to true to use direct static invocation of functions, rather than vars\n Note that call sites compiled with direct linking will not be affected by var redefinition.\n Use ^:redef (or ^:dynamic) on a var to prevent direct linking and allow redefinition.\n See https://glojure.org/reference/compilation for more information.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_compiler_DASH_options_STAR_ = ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_compiler_DASH_options_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *data-readers* + { + tmp0 := sym__STAR_data_DASH_readers_STAR_.WithMeta(lang.NewMap(kw_doc, "Map from reader tag symbols to data reader Vars.\n\n When Clojure starts, it searches for files named 'data_readers.clj'\n and 'data_readers.cljc' at the root of the classpath. Each such file\n must contain a literal map of symbols, like this:\n\n {foo/bar my.project.foo/bar\n foo/baz my.project/baz}\n\n The first symbol in each pair is a tag that will be recognized by\n the Clojure reader. The second symbol in the pair is the\n fully-qualified name of a Var which will be invoked by the reader to\n parse the form following the tag. For example, given the\n data_readers.clj file above, the Clojure reader would parse this\n form:\n\n #foo/bar [1 2 3]\n\n by invoking the Var #'my.project.foo/bar on the vector [1 2 3]. The\n data reader function is invoked on the form AFTER it has been read\n as a normal Clojure data structure by the reader.\n\n Reader tags without namespace qualifiers are reserved for\n Clojure. Default reader tags are defined in\n glojure.core/default-data-readers but may be overridden in\n data_readers.clj, data_readers.cljc, or by rebinding this Var.", kw_file, "glojure/core.glj", kw_added, "1.4", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(49), kw_column, int(6), kw_line, int(7794), kw_end_DASH_line, int(7794), kw_dynamic, true)).(*lang.Symbol) + var_glojure_DOT_core__STAR_data_DASH_readers_STAR_ = ns.InternWithValue(tmp0, lang.NewMap(), true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_data_DASH_readers_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *default-data-reader-fn* + { + tmp0 := sym__STAR_default_DASH_data_DASH_reader_DASH_fn_STAR_.WithMeta(lang.NewMap(kw_doc, "When no data reader is found for a tag and *default-data-reader-fn*\n is non-nil, it will be called with two arguments,\n the tag and the value. If *default-data-reader-fn* is nil (the\n default), an exception will be thrown for the unknown tag.", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(59), kw_column, int(6), kw_line, int(7823), kw_end_DASH_line, int(7823), kw_dynamic, true)).(*lang.Symbol) + var_glojure_DOT_core__STAR_default_DASH_data_DASH_reader_DASH_fn_STAR_ = ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_default_DASH_data_DASH_reader_DASH_fn_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *e + { + tmp0 := sym__STAR_e.WithMeta(lang.NewMap()).(*lang.Symbol) + var_glojure_DOT_core__STAR_e = ns.Intern(tmp0) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_e.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *err* + { + tmp0 := sym__STAR_err_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "A java.io.Writer object representing standard error for print operations.\n\n Defaults to System/err, wrapped in a PrintWriter", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_err_STAR_ = ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_err_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *file* + { + tmp0 := sym__STAR_file_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "The path of the file being evaluated, as a String.\n\n When there is no file, e.g. in the REPL, the value is not defined.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_file_STAR_ = ns.InternWithValue(tmp0, "NO_SOURCE_FILE", true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_file_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *flush-on-newline* + { + tmp0 := sym__STAR_flush_DASH_on_DASH_newline_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "When set to true, output will be flushed whenever a newline is printed.\n\n Defaults to true.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_flush_DASH_on_DASH_newline_STAR_ = ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_flush_DASH_on_DASH_newline_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *loaded-libs* + { + tmp0 := sym__STAR_loaded_DASH_libs_STAR_.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core.glj", kw_line, int(5817), kw_column, int(10), kw_end_DASH_line, int(5820), kw_end_DASH_column, int(15), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + tmp1 := lang.NewRef(lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{sym_glojure_DOT_core_DOT_protocols, sym_glojure_DOT_string, sym_glojure_DOT_go_DOT_io, sym_user}))) + var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *loading-verbosely* + { + tmp0 := sym__STAR_loading_DASH_verbosely_STAR_.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core.glj", kw_line, int(5827), kw_column, int(10), kw_end_DASH_line, int(5830), kw_end_DASH_column, int(21), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_ = ns.InternWithValue(tmp0, false, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *ns* + { + tmp0 := sym__STAR_ns_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "A glojure.lang.Namespace object representing the current namespace.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_ns_STAR_ = ns.InternWithValue(tmp0, lang.FindOrCreateNamespace(sym_glojure_DOT_core), true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_ns_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *pending-paths* + { + tmp0 := sym__STAR_pending_DASH_paths_STAR_.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core.glj", kw_line, int(5822), kw_column, int(10), kw_end_DASH_line, int(5825), kw_end_DASH_column, int(17), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_ = ns.InternWithValue(tmp0, lang.NewList("/glojure/core"), true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *print-dup* + { + tmp0 := sym__STAR_print_DASH_dup_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "When set to logical true, objects will be printed in a way that preserves\n their type when read in later.\n\n Defaults to false.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_print_DASH_dup_STAR_ = ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_print_DASH_dup_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *print-length* + { + tmp0 := sym__STAR_print_DASH_length_STAR_.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core_print.glj", kw_line, int(14), kw_column, int(6), kw_end_DASH_line, int(23), kw_end_DASH_column, int(15), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_print_DASH_length_STAR_ = ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_print_DASH_length_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *print-level* + { + tmp0 := sym__STAR_print_DASH_level_STAR_.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core_print.glj", kw_line, int(25), kw_column, int(6), kw_end_DASH_line, int(35), kw_end_DASH_column, int(14), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_print_DASH_level_STAR_ = ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_print_DASH_level_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *print-meta* + { + tmp0 := sym__STAR_print_DASH_meta_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "If set to logical true, when printing an object, its metadata will also\n be printed in a form that can be read back by the reader.\n\n Defaults to false.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_print_DASH_meta_STAR_ = ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_print_DASH_meta_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *print-namespace-maps* + { + tmp0 := sym__STAR_print_DASH_namespace_DASH_maps_STAR_.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core_print.glj", kw_line, int(39), kw_column, int(6), kw_end_DASH_line, int(44), kw_end_DASH_column, int(23), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_print_DASH_namespace_DASH_maps_STAR_ = ns.InternWithValue(tmp0, false, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_print_DASH_namespace_DASH_maps_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *print-readably* + { + tmp0 := sym__STAR_print_DASH_readably_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "When set to logical false, strings and characters will be printed with\n non-alphanumeric characters converted to the appropriate escape sequences.\n\n Defaults to true", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_print_DASH_readably_STAR_ = ns.InternWithValue(tmp0, true, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_print_DASH_readably_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *read-eval* + { + tmp0 := sym__STAR_read_DASH_eval_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "Defaults to true (or value specified by system property, see below)\n ***This setting implies that the full power of the reader is in play,\n including syntax that can cause code to execute. It should never be\n used with untrusted sources. See also: glojure.edn/read.***\n\n When set to logical false in the thread-local binding,\n the eval reader (#=) and record/type literal syntax are disabled in read/load.\n Example (will fail): (binding [*read-eval* false] (read-string \"#=(* 2 21)\"))\n\n The default binding can be controlled by the system property\n 'glojure.read.eval' System properties can be set on the command line\n like this:\n\n java -Dglojure.read.eval=false ...\n\n The system property can also be set to 'unknown' via\n -Dglojure.read.eval=unknown, in which case the default binding\n is :unknown and all reads will fail in contexts where *read-eval*\n has not been explicitly bound to either true or false. This setting\n can be a useful diagnostic tool to ensure that all of your reads\n occur in considered contexts. You can also accomplish this in a\n particular scope by binding *read-eval* to :unknown\n ", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_read_DASH_eval_STAR_ = ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_read_DASH_eval_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *repl* + { + tmp0 := sym__STAR_repl_STAR_.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core.glj", kw_line, int(6288), kw_column, int(6), kw_end_DASH_line, int(6291), kw_end_DASH_column, int(8), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_repl_STAR_ = ns.InternWithValue(tmp0, false, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_repl_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *unchecked-math* + { + tmp0 := sym__STAR_unchecked_DASH_math_STAR_.WithMeta(lang.NewMap(kw_added, "1.3", kw_doc, "While bound to true, compilations of +, -, *, inc, dec and the\n coercions will be done without overflow checks. While bound\n to :warn-on-boxed, same behavior as true, and a warning is emitted\n when compilation uses boxed math. Default: false.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_ = ns.InternWithValue(tmp0, false, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *verbose-defrecords* + { + tmp0 := sym__STAR_verbose_DASH_defrecords_STAR_.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core_print.glj", kw_line, int(37), kw_column, int(6), kw_end_DASH_line, int(37), kw_end_DASH_column, int(35), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_verbose_DASH_defrecords_STAR_ = ns.InternWithValue(tmp0, false, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_verbose_DASH_defrecords_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *warn-on-reflection* + { + tmp0 := sym__STAR_warn_DASH_on_DASH_reflection_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "When set to true, the compiler will emit warnings when reflection is\n needed to resolve Java method calls or field accesses.\n\n Defaults to false.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_warn_DASH_on_DASH_reflection_STAR_ = ns.InternWithValue(tmp0, false, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_warn_DASH_on_DASH_reflection_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // accessor + { + tmp0 := sym_accessor.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s, sym_key)), kw_doc, "Returns a fn that, given an instance of a structmap with the basis,\n returns the value at the key. The key must be in the basis. The\n returned function should be (slightly) more efficient than using\n get, but such use of accessors should be limited to known\n performance-critical areas.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(4070), kw_end_DASH_line, int(4070))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(nil, "getAccessor") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getAccessor is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_accessor = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_accessor.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // add-watch + { + tmp0 := sym_add_DASH_watch.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_reference, sym_key, sym_fn)), kw_doc, "Adds a watch function to an agent/atom/var/ref reference. The watch\n fn must be a fn of 4 args: a key, the reference, its old-state, its\n new-state. Whenever the reference's state might have been changed,\n any registered watches will have their functions called. The watch fn\n will be called synchronously, on the agent's thread if an agent,\n before any pending sends if agent or ref. Note that an atom's or\n ref's state may have changed again prior to the fn call, so use\n old/new-state rather than derefing the reference. Note also that watch\n fns may be called from multiple threads simultaneously. Var watchers\n are triggered only by root binding changes, not thread-local\n set!s. Keys must be unique per reference, and can be used to remove\n the watch with remove-watch, but are otherwise considered opaque by\n the watch mechanism.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(2142), kw_end_DASH_line, int(2142))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5, _ := lang.FieldOrMethod(v2, "addWatch") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("addWatch is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_add_DASH_watch = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_add_DASH_watch.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // agent-error + { + tmp0 := sym_agent_DASH_error.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a)), kw_doc, "Returns the exception thrown during an asynchronous action of the\n agent if the agent is failed. Returns nil if the agent is not\n failed.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(2167), kw_end_DASH_line, int(2167))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "getError") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getError"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_agent_DASH_error = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_agent_DASH_error.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // all-ns + { + tmp0 := sym_all_DASH_ns.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Returns a sequence of all namespaces.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(4146), kw_end_DASH_line, int(4146))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp2 := lang.Apply(nil, nil) + return tmp2 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_all_DASH_ns = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_all_DASH_ns.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // alter + { + tmp0 := sym_alter.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ref, sym_fun, sym__AMP_, sym_args)), kw_doc, "Must be called in a transaction. Sets the in-transaction-value of\n ref to:\n\n (apply fun in-transaction-value-of-ref args)\n\n and returns the in-transaction-value of ref.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(2435), kw_end_DASH_line, int(2435))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5, _ := lang.FieldOrMethod(v2, "alter") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("alter is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_alter = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_alter.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // alter-meta! + { + tmp0 := sym_alter_DASH_meta_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_iref, sym_f, sym__AMP_, sym_args)), kw_doc, "Atomically sets the metadata for a namespace/var/ref/agent/atom to be:\n\n (apply f its-current-meta args)\n\n f must be free of side-effects", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(2398), kw_end_DASH_line, int(2398))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5, _ := lang.FieldOrMethod(v2, "AlterMeta") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("AlterMeta is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_alter_DASH_meta_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_alter_DASH_meta_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // alter-var-root + { + tmp0 := sym_alter_DASH_var_DASH_root.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_v, sym_f, sym__AMP_, sym_args)), kw_doc, "Atomically alters the root binding of var v by applying f to its\n current value plus any args", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(5484), kw_end_DASH_line, int(5484))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5, _ := lang.FieldOrMethod(v2, "alterRoot") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("alterRoot is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_alter_DASH_var_DASH_root = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_alter_DASH_var_DASH_root.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // any? + { + tmp1 := reflect.TypeOf(false) + tmp0 := sym_any_QMARK_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true given any argument.", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(537), kw_end_DASH_line, int(537))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + return true + }) + tmp3 := reflect.TypeOf(false) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_any_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_any_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bit-clear + { + tmp0 := sym_bit_DASH_clear.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_n)), kw_doc, "Clear bit at index n", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(1336), kw_end_DASH_line, int(1336))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "ClearBit") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ClearBit is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bit_DASH_clear = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bit_DASH_clear.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bit-flip + { + tmp0 := sym_bit_DASH_flip.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_n)), kw_doc, "Flip bit at index n", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(1348), kw_end_DASH_line, int(1348))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "FlipBit") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("FlipBit is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bit_DASH_flip = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bit_DASH_flip.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bit-set + { + tmp0 := sym_bit_DASH_set.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_n)), kw_doc, "Set bit at index n", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(1342), kw_end_DASH_line, int(1342))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "SetBit") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("SetBit is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bit_DASH_set = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bit_DASH_set.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bit-test + { + tmp0 := sym_bit_DASH_test.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_n)), kw_doc, "Test bit at index n", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(1354), kw_end_DASH_line, int(1354))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "TestBit") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("TestBit is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bit_DASH_test = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bit_DASH_test.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // cast + { + tmp0 := sym_cast.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_c, sym_x)), kw_doc, "Throws a ClassCastException if x is not a c, else returns x.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(345), kw_end_DASH_line, int(345))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "cast") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("cast is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_cast = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_cast.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // char-escape-string + { + tmp1 := reflect.TypeOf("") + tmp0 := sym_char_DASH_escape_DASH_string.WithMeta(lang.NewMap(kw_tag, tmp1, kw_doc, "Returns escape string for char or nil if none", kw_file, "glojure/core_print.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(6), kw_line, int(214), kw_end_DASH_line, int(217))).(*lang.Symbol) + var_glojure_DOT_core_char_DASH_escape_DASH_string = ns.InternWithValue(tmp0, lang.NewMap(lang.NewChar(10), "\\n", lang.NewChar(9), "\\t", lang.NewChar(13), "\\r", lang.NewChar(34), "\\\"", lang.NewChar(92), "\\\\", lang.NewChar(12), "\\f", lang.NewChar(8), "\\b"), true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_char_DASH_escape_DASH_string.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // char-name-string + { + tmp1 := reflect.TypeOf("") + tmp0 := sym_char_DASH_name_DASH_string.WithMeta(lang.NewMap(kw_tag, tmp1, kw_doc, "Returns name string for char or nil if none", kw_file, "glojure/core_print.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(6), kw_line, int(335), kw_end_DASH_line, int(338))).(*lang.Symbol) + var_glojure_DOT_core_char_DASH_name_DASH_string = ns.InternWithValue(tmp0, lang.NewMap(lang.NewChar(10), "newline", lang.NewChar(9), "tab", lang.NewChar(32), "space", lang.NewChar(8), "backspace", lang.NewChar(12), "formfeed", lang.NewChar(13), "return"), true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_char_DASH_name_DASH_string.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // chunk + { + tmp0 := sym_chunk.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(691), kw_column, int(7), kw_end_DASH_line, int(691), kw_end_DASH_column, int(41), kw_arglists, lang.NewList(lang.NewVector(sym_b)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "chunk") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "chunk"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_chunk = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_chunk.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // chunk-append + { + tmp0 := sym_chunk_DASH_append.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(688), kw_column, int(7), kw_end_DASH_line, int(688), kw_end_DASH_column, int(27), kw_arglists, lang.NewList(lang.NewVector(sym_b, sym_x)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "add") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_chunk_DASH_append = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_chunk_DASH_append.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // chunk-buffer + { + tmp0 := sym_chunk_DASH_buffer.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(685), kw_column, int(7), kw_end_DASH_line, int(685), kw_end_DASH_column, int(53), kw_arglists, lang.NewList(lang.NewVector(sym_capacity)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(lang.NewChunkBuffer, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_chunk_DASH_buffer = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_chunk_DASH_buffer.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // chunk-cons + { + tmp0 := sym_chunk_DASH_cons.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(703), kw_column, int(7), kw_end_DASH_line, int(703), kw_end_DASH_column, int(25), kw_arglists, lang.NewList(lang.NewVector(sym_chunk, sym_rest)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + tmp5 := lang.Apply(lang.Count, []any{v2}) + tmp6 := lang.Apply(lang.IsZero, []any{tmp5}) + if lang.IsTruthy(tmp6) { + tmp4 = v3 + } else { + tmp7 := lang.Apply(lang.NewChunkedCons, []any{v2, v3}) + tmp4 = tmp7 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_chunk_DASH_cons = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_chunk_DASH_cons.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // chunk-first + { + tmp0 := sym_chunk_DASH_first.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(694), kw_column, int(7), kw_end_DASH_line, int(694), kw_end_DASH_column, int(48), kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "chunkedFirst") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "chunkedFirst"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_chunk_DASH_first = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_chunk_DASH_first.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // chunk-next + { + tmp0 := sym_chunk_DASH_next.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(700), kw_column, int(7), kw_end_DASH_line, int(700), kw_end_DASH_column, int(71), kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "chunkedNext") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "chunkedNext"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_chunk_DASH_next = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_chunk_DASH_next.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // chunk-rest + { + tmp0 := sym_chunk_DASH_rest.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(697), kw_column, int(7), kw_end_DASH_line, int(697), kw_end_DASH_column, int(71), kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "chunkedMore") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "chunkedMore"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_chunk_DASH_rest = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_chunk_DASH_rest.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // comment + { + tmp0 := sym_comment.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_body)), kw_doc, "Ignores body, yields nil", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(4733), kw_end_DASH_line, int(4733))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + return nil + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_comment = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_comment.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // commute + { + tmp0 := sym_commute.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ref, sym_fun, sym__AMP_, sym_args)), kw_doc, "Must be called in a transaction. Sets the in-transaction-value of\n ref to:\n\n (apply fun in-transaction-value-of-ref args)\n\n and returns the in-transaction-value of ref.\n\n At the commit point of the transaction, sets the value of ref to be:\n\n (apply fun most-recently-committed-value-of-ref args)\n\n Thus fun should be commutative, or, failing that, you must accept\n last-one-in-wins behavior. commute allows for more concurrency than\n ref-set.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(2414), kw_end_DASH_line, int(2414))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5, _ := lang.FieldOrMethod(v2, "Commute") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Commute is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_commute = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_commute.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // comparator + { + tmp0 := sym_comparator.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred)), kw_doc, "Returns an implementation of java.util.Comparator based upon pred.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(3077), kw_end_DASH_line, int(3077))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var tmp6 any + tmp7 := lang.Apply(v2, []any{v4, v5}) + if lang.IsTruthy(tmp7) { + tmp6 = int64(-1) + } else { + var tmp8 any + tmp9 := lang.Apply(v2, []any{v5, v4}) + if lang.IsTruthy(tmp9) { + tmp8 = int64(1) + } else { + var tmp10 any + if lang.IsTruthy(kw_else) { + tmp10 = int64(0) + } else { + } + tmp8 = tmp10 + } + tmp6 = tmp8 + } + return tmp6 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3082), kw_column, int(5), kw_end_DASH_line, int(3083), kw_end_DASH_column, int(48)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_comparator = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_comparator.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // compare-and-set! + { + tmp0 := sym_compare_DASH_and_DASH_set_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_atom, sym_oldval, sym_newval)), kw_doc, "Atomically sets the value of atom to newval if and only if the\n current value of the atom is identical to oldval. Returns true if\n set happened, else false", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(22), kw_column, int(7), kw_line, int(2360), kw_end_DASH_line, int(2360))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5, _ := lang.FieldOrMethod(v2, "compareAndSet") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("compareAndSet is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_compare_DASH_and_DASH_set_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_compare_DASH_and_DASH_set_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // cons + { + tmp0 := sym_cons.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_seq)), kw_doc, "Returns a new seq where x is the first element and seq is\n the rest.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(5), kw_column, int(2), kw_line, int(21), kw_end_DASH_line, int(27))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function cons + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(lang.NewCons, []any{v3, v4}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(27), kw_column, int(7), kw_end_DASH_line, int(27), kw_end_DASH_column, int(89))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_cons = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_cons.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // constantly + { + tmp0 := sym_constantly.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns a function that takes any number of arguments and returns x.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(1440), kw_end_DASH_line, int(1440))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v4 any = lang.NewList(args[0:]...) + _ = v4 + return v2 + } + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(1444), kw_column, int(7), kw_end_DASH_line, int(1444), kw_end_DASH_column, int(21)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_constantly = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_constantly.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // contains? + { + tmp0 := sym_contains_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll, sym_key)), kw_doc, "Returns true if key is present in the given collection, otherwise\n returns false. Note that for numerically indexed collections like\n vectors and Java arrays, this tests if the numeric key is within the\n range of indexes. 'contains?' operates constant or logarithmic time;\n it will not perform a linear search for a value. See also 'some'.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(1479), kw_end_DASH_line, int(1479))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(runtime.RT, "Contains") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Contains is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_contains_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_contains_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // create-ns + { + tmp0 := sym_create_DASH_ns.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_sym)), kw_doc, "Create a new namespace named by the symbol if one doesn't already\n exist, returns it or the already-existing namespace of the same\n name.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(4131), kw_end_DASH_line, int(4131))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(nil, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_create_DASH_ns = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_create_DASH_ns.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // create-struct + { + tmp0 := sym_create_DASH_struct.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_keys)), kw_doc, "Returns a structure basis object.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(4037), kw_end_DASH_line, int(4037))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + tmp3 := lang.Apply(lang.CreatePersistentStructMapSlotMap, []any{v2}) + return tmp3 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_create_DASH_struct = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_create_DASH_struct.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // data-reader-urls + { + tmp0 := sym_data_DASH_reader_DASH_urls.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7830), kw_column, int(8), kw_end_DASH_line, int(7830), kw_end_DASH_column, int(23), kw_private, true, kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + return lang.NewList() + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_data_DASH_reader_DASH_urls = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_data_DASH_reader_DASH_urls.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // deliver + { + tmp0 := sym_deliver.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_promise, sym_val)), kw_doc, "Delivers the supplied value to the promise, releasing any pending\n derefs. A subsequent call to deliver on a promise will have no effect.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(7109), kw_end_DASH_line, int(7109))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := lang.Apply(v2, []any{v3}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_deliver = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_deliver.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // denominator + { + tmp1 := reflect.TypeOf((*big6.Int)(nil)) + tmp0 := sym_denominator.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_r)), kw_doc, "Returns the denominator part of a Ratio.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(3591), kw_end_DASH_line, int(3591))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, ok := lang.FieldOrMethod(v3, "denominator") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "denominator"))) + } + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { + case reflect.Func: + tmp5 = lang.Apply(tmp4, nil) + default: + tmp5 = tmp4 + } + return tmp5 + }) + tmp3 := reflect.TypeOf((*big6.Int)(nil)) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_denominator = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_denominator.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // deref-future + { + tmp0 := sym_deref_DASH_future.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(2296), kw_column, int(7), kw_end_DASH_line, int(2296), kw_end_DASH_column, int(28), kw_arglists, lang.NewList(lang.NewVector(sym_fut), lang.NewVector(sym_fut, sym_timeout_DASH_ms, sym_timeout_DASH_val)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "Get") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "Get"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + func() { + defer func() { + if r := recover(); r != nil { + tmp6 := reflect.TypeOf((*lang.TimeoutError)(nil)).Elem() + if lang.CatchMatches(r, tmp6) { + v7 := r + _ = v7 + tmp5 = v4 + } else { + panic(r) + } + } + }() + tmp7, _ := lang.FieldOrMethod(v2, "Get") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Get is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v3, time7.Millisecond}) + tmp5 = tmp8 + }() + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_deref_DASH_future = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_deref_DASH_future.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ensure + { + tmp0 := sym_ensure.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ref)), kw_doc, "Must be called in a transaction. Protects the ref from modification\n by other transactions. Returns the in-transaction-value of\n ref. Allows for more concurrency than (ref-set ref @ref)", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(2480), kw_end_DASH_line, int(2480))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(v2, "touch") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("touch is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{}) + _ = tmp4 + tmp5, _ := lang.FieldOrMethod(v2, "deref") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("deref is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ensure = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ensure.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // enumeration-seq + { + tmp0 := sym_enumeration_DASH_seq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_e)), kw_doc, "Returns a seq on a java.util.Enumeration", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(5710), kw_end_DASH_line, int(5710))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(nil, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_enumeration_DASH_seq = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_enumeration_DASH_seq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // error-handler + { + tmp0 := sym_error_DASH_handler.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a)), kw_doc, "Returns the error-handler of agent a, or nil if there is none.\n See set-error-handler!", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(2202), kw_end_DASH_line, int(2202))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "getErrorHandler") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getErrorHandler"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_error_DASH_handler = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_error_DASH_handler.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // error-mode + { + tmp0 := sym_error_DASH_mode.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a)), kw_doc, "Returns the error-mode of agent a. See set-error-mode!", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(2227), kw_end_DASH_line, int(2227))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "getErrorMode") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getErrorMode"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_error_DASH_mode = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_error_DASH_mode.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // eval + { + tmp0 := sym_eval.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_form)), kw_doc, "Evaluates the form data structure (not text!) and returns the result.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3203), kw_end_DASH_line, int(3203))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(runtime.Compiler, "Eval") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Eval is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_eval = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_eval.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // false? + { + tmp1 := reflect.TypeOf(false) + tmp0 := sym_false_QMARK_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x is the value false, false otherwise.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(504), kw_end_DASH_line, int(504))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.Identical, []any{v3, false}) + return tmp4 + }) + tmp3 := reflect.TypeOf(false) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_false_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_false_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // find + { + tmp0 := sym_find.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_map, sym_key)), kw_doc, "Returns the map entry for key, or nil if key not present.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1530), kw_end_DASH_line, int(1530))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(runtime.RT, "Find") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Find is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_find = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_find.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // find-ns + { + tmp0 := sym_find_DASH_ns.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_sym)), kw_doc, "Returns the namespace named by the symbol or nil if it doesn't exist.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4125), kw_end_DASH_line, int(4125))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(lang.FindNamespace, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_find_DASH_ns = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_find_DASH_ns.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // find-var + { + tmp0 := sym_find_DASH_var.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_sym)), kw_doc, "Returns the global var named by the namespace-qualified symbol, or\n nil if no var with that name.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(2013), kw_end_DASH_line, int(2013))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(runtime.RT, "FindVar") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("FindVar is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_find_DASH_var = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_find_DASH_var.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // first + { + tmp0 := sym_first.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns the first item in the collection. Calls seq on its\n argument. If coll is nil, returns nil.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(6), kw_column, int(2), kw_line, int(47), kw_end_DASH_line, int(52))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function first + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.First, []any{v3}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(52), kw_column, int(8), kw_end_DASH_line, int(52), kw_end_DASH_column, int(86))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_first = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_first.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // force + { + tmp0 := sym_force.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "If x is a Delay, returns the (possibly cached) value of its expression, else returns x", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(754), kw_end_DASH_line, int(754))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(nil, "force") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("force is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_force = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_force.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // future-cancel + { + tmp0 := sym_future_DASH_cancel.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f)), kw_doc, "Cancels the future, if possible.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(7019), kw_end_DASH_line, int(7019))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(v2, "cancel") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("cancel is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{true}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_future_DASH_cancel = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_future_DASH_cancel.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // future-cancelled? + { + tmp0 := sym_future_DASH_cancelled_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f)), kw_doc, "Returns true if future f is cancelled", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(7), kw_line, int(7025), kw_end_DASH_line, int(7025))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "isCancelled") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "isCancelled"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_future_DASH_cancelled_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_future_DASH_cancelled_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // future-done? + { + tmp0 := sym_future_DASH_done_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f)), kw_doc, "Returns true if future f is done", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(6538), kw_end_DASH_line, int(6538))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "isDone") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "isDone"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_future_DASH_done_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_future_DASH_done_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // gen-class + { + tmp0 := sym_gen_DASH_class.WithMeta(lang.NewMap()).(*lang.Symbol) + var_glojure_DOT_core_gen_DASH_class = ns.Intern(tmp0) + if tmp0.Meta() != nil { + var_glojure_DOT_core_gen_DASH_class.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // get-method + { + tmp0 := sym_get_DASH_method.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_multifn, sym_dispatch_DASH_val)), kw_doc, "Given a multimethod and a dispatch value, returns the dispatch fn\n that would apply to that value, or nil if none apply and no default", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(1815), kw_end_DASH_line, int(1815))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "getMethod") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getMethod is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_get_DASH_method = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_get_DASH_method.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // get-thread-bindings + { + tmp0 := sym_get_DASH_thread_DASH_bindings.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Get a map with the Var/value pairs which is currently in effect for the\n current thread.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(25), kw_column, int(7), kw_line, int(1937), kw_end_DASH_line, int(1937))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp2 := lang.Apply(nil, nil) + return tmp2 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_get_DASH_thread_DASH_bindings = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_get_DASH_thread_DASH_bindings.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // get-validator + { + tmp0 := sym_get_DASH_validator.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_iref)), kw_doc, "Gets the validator-fn for a var/ref/agent/atom.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(2392), kw_end_DASH_line, int(2392))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(v2, "getValidator") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getValidator is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_get_DASH_validator = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_get_DASH_validator.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // global-hierarchy + { + tmp0 := sym_global_DASH_hierarchy.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(5513), kw_column, int(6), kw_end_DASH_line, int(5514), kw_end_DASH_column, int(21), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core_global_DASH_hierarchy = ns.InternWithValue(tmp0, lang.NewMap(kw_parents, lang.NewMap(), kw_descendants, lang.NewMap(), kw_ancestors, lang.NewMap()), true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_global_DASH_hierarchy.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // hash + { + tmp0 := sym_hash.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns the hash code of its argument. Note this is the hash code\n consistent with =, and thus is different than .hashCode for Integer,\n Short, Byte and Clojure collections.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(5189), kw_end_DASH_line, int(5189))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(lang.HashEq, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_hash = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_hash.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // hash-map + { + tmp0 := sym_hash_DASH_map.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym__AMP_, sym_keyvals)), kw_doc, "keyval => key val\n Returns a new hash map with supplied mappings. If any keys are\n equal, they are handled as if by repeated uses of assoc.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(378), kw_end_DASH_line, int(378))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp2 := lang.NewMap() + tmp3 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(384), kw_column, int(7), kw_end_DASH_line, int(384), kw_end_DASH_column, int(8)) + tmp4, err := lang.WithMeta(tmp2, tmp3.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp4 + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + tmp3 := lang.Apply(lang.CreatePersistentHashMap, []any{v2}) + return tmp3 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_hash_DASH_map = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_hash_DASH_map.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // hash-ordered-coll + { + tmp0 := sym_hash_DASH_ordered_DASH_coll.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns the hash code, consistent with =, for an external ordered\n collection implementing Iterable.\n See http://glojure.org/data_structures#hash for full algorithms.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.6", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(7), kw_line, int(5210), kw_end_DASH_line, int(5210))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(nil, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_hash_DASH_ordered_DASH_coll = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_hash_DASH_ordered_DASH_coll.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // hash-set + { + tmp0 := sym_hash_DASH_set.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym__AMP_, sym_keys)), kw_doc, "Returns a new hash set with supplied keys. Any equal keys are\n handled as if by repeated uses of conj.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(388), kw_end_DASH_line, int(388))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp2 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp3 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(393), kw_column, int(7), kw_end_DASH_line, int(393), kw_end_DASH_column, int(9)) + tmp4, err := lang.WithMeta(tmp2, tmp3.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp4 + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + tmp3 := lang.Apply(nil, []any{v2}) + return tmp3 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_hash_DASH_set = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_hash_DASH_set.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // hash-unordered-coll + { + tmp0 := sym_hash_DASH_unordered_DASH_coll.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns the hash code, consistent with =, for an external unordered\n collection implementing Iterable. For maps, the iterator should\n return map entries whose hash is computed as\n (hash-ordered-coll [k v]).\n See http://glojure.org/data_structures#hash for full algorithms.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.6", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(25), kw_column, int(7), kw_line, int(5219), kw_end_DASH_line, int(5219))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(nil, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_hash_DASH_unordered_DASH_coll = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_hash_DASH_unordered_DASH_coll.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // identity + { + tmp0 := sym_identity.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns its argument.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(1446), kw_end_DASH_line, int(1446))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + return v2 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_identity = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_identity.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // inst-ms + { + tmp0 := sym_inst_DASH_ms.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_inst)), kw_doc, "Return the number of milliseconds since January 1, 1970, 00:00:00 GMT", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(6831), kw_end_DASH_line, int(6831))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(nil, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_inst_DASH_ms = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_inst_DASH_ms.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // inst? + { + tmp0 := sym_inst_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x satisfies Inst", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(6837), kw_end_DASH_line, int(6837))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + return nil + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_inst_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_inst_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // instance? + { + tmp0 := sym_instance_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_c, sym_x)), kw_doc, "Evaluates x and tests if it is an instance of the type\n t. Returns true or false", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(2), kw_line, int(139), kw_end_DASH_line, int(143))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function instance? + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(lang.HasType, []any{v3, v4}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(143), kw_column, int(12), kw_end_DASH_line, int(143), kw_end_DASH_column, int(85))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_instance_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_instance_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // int? + { + tmp0 := sym_int_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a fixed precision integer", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1395), kw_end_DASH_line, int(1395))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "or__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := lang.Apply(tmp4, []any{lang.Builtins["int64"], v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + tmp7 = v6 + } else { + var tmp8 any + { // let + // let binding "or__0__auto__" + tmp9 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp10 := lang.Apply(tmp9, []any{nil, v2}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + tmp12 = v11 + } else { + var tmp13 any + { // let + // let binding "or__0__auto__" + tmp14 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp15 := lang.Apply(tmp14, []any{nil, v2}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + if lang.IsTruthy(v16) { + tmp17 = v16 + } else { + tmp18 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp19 := lang.Apply(tmp18, []any{nil, v2}) + tmp17 = tmp19 + } + tmp13 = tmp17 + } // end let + tmp12 = tmp13 + } + tmp8 = tmp12 + } // end let + tmp7 = tmp8 + } + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_int_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_int_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // integer? + { + tmp0 := sym_integer_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_doc, "Returns true if n is an integer", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(1379), kw_end_DASH_line, int(1379))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(lang.IsInteger, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_integer_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_integer_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // iterate + { + tmp0 := sym_iterate.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_x)), kw_doc, "Returns a lazy (infinite!) sequence of x, (f x), (f (f x)) etc.\n f must be free of side-effects", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(3011), kw_end_DASH_line, int(3011))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := lang.Apply(nil, []any{v2, v3}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_iterate = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_iterate.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // iterator-seq + { + tmp0 := sym_iterator_DASH_seq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_iter)), kw_doc, "Returns a seq on a java.util.Iterator. Note that most collections\n providing iterators implement Iterable and thus support seq directly.\n Seqs cache values, thus iterator-seq should not be used on any\n iterator that repeatedly returns the same mutable object.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(5700), kw_end_DASH_line, int(5700))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(nil, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_iterator_DASH_seq = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_iterator_DASH_seq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // key + { + tmp0 := sym_key.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_e)), kw_doc, "Returns the key of the map entry.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(1563), kw_end_DASH_line, int(1563))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(v2, "GetKey") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("GetKey is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_key = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_key.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // keys + { + tmp0 := sym_keys.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_map)), kw_doc, "Returns a sequence of the map's keys, in the same order as (seq map).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1551), kw_end_DASH_line, int(1551))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(lang.Keys, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_keys = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_keys.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // keyword? + { + tmp0 := sym_keyword_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a Keyword", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(563), kw_end_DASH_line, int(563))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_keyword_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_keyword_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // line-seq + { + tmp0 := sym_line_DASH_seq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_rdr)), kw_doc, "Returns the lines of text from rdr as a lazy sequence of strings.\n rdr must implement java.io.BufferedReader.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(3068), kw_end_DASH_line, int(3068))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "temp__0__auto__" + tmp4, ok := lang.FieldOrMethod(v2, "readLine") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "readLine"))) + } + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { + case reflect.Func: + tmp5 = lang.Apply(tmp4, nil) + default: + tmp5 = tmp4 + } + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + var tmp8 any + { // let + // let binding "line" + var v9 any = v6 + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_cons) + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp12 := checkDerefVar(var_glojure_DOT_core_line_DASH_seq) + tmp13 := lang.Apply(tmp12, []any{v2}) + return tmp13 + }) + tmp12 := lang.Apply(lang.NewLazySeq, []any{tmp11}) + tmp13 := lang.Apply(tmp10, []any{v9, tmp12}) + tmp8 = tmp13 + } // end let + tmp7 = tmp8 + } else { + } + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_line_DASH_seq = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_line_DASH_seq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // list + { + tmp0 := sym_list.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_items)), kw_doc, "Creates a new list containing the items.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(6), kw_column, int(2), kw_line, int(15), kw_end_DASH_line, int(18))).(*lang.Symbol) + var_glojure_DOT_core_list = ns.InternWithValue(tmp0, lang.NewList, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_list.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // list? + { + tmp0 := sym_list_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x implements IPersistentList", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(6198), kw_end_DASH_line, int(6198))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*lang.IPersistentList)(nil)).Elem() + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_list_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_list_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // load-file + { + tmp0 := sym_load_DASH_file.WithMeta(lang.NewMap(kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core_load_DASH_file = ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_load_DASH_file.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // load-reader + { + tmp0 := sym_load_DASH_reader.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_rdr)), kw_doc, "Sequentially read and evaluate the set of forms contained in the\n stream/file", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(4081), kw_end_DASH_line, int(4081))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(runtime.Compiler, "load") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("load is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_load_DASH_reader = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_load_DASH_reader.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // load-string + { + tmp0 := sym_load_DASH_string.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_doc, "Sequentially read and evaluate the set of forms contained in the\n string", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(4088), kw_end_DASH_line, int(4088))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "rdr" + tmp4 := lang.Apply(nil, []any{v2}) + tmp5 := lang.Apply(nil, []any{tmp4}) + var v6 any = tmp5 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_load_DASH_reader) + tmp8 := lang.Apply(tmp7, []any{v6}) + tmp3 = tmp8 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_load_DASH_string = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_load_DASH_string.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // macroexpand-1 + { + tmp0 := sym_macroexpand_DASH_1.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_form)), kw_doc, "If form represents a macro form, returns its expansion,\n else returns form.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(4017), kw_end_DASH_line, int(4017))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(runtime.Compiler, "macroexpand1") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("macroexpand1 is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_macroexpand_DASH_1 = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_macroexpand_DASH_1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // make-hierarchy + { + tmp0 := sym_make_DASH_hierarchy.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Creates a hierarchy object for use with derive, isa? etc.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(5507), kw_end_DASH_line, int(5507))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp2 := lang.NewMap() + tmp3 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5511), kw_column, int(16), kw_end_DASH_line, int(5511), kw_end_DASH_column, int(17)) + tmp4, err := lang.WithMeta(tmp2, tmp3.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp5 := lang.NewMap() + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5511), kw_column, int(32), kw_end_DASH_line, int(5511), kw_end_DASH_column, int(33)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp8 := lang.NewMap() + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5511), kw_column, int(46), kw_end_DASH_line, int(5511), kw_end_DASH_column, int(47)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp11 := lang.NewMap(kw_parents, tmp4, kw_descendants, tmp7, kw_ancestors, tmp10) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5511), kw_column, int(6), kw_end_DASH_line, int(5511), kw_end_DASH_column, int(48)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp13 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_make_DASH_hierarchy = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_make_DASH_hierarchy.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // map-entry? + { + tmp0 := sym_map_DASH_entry_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a map entry", kw_file, "glojure/core.glj", kw_added, "1.8", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(1473), kw_end_DASH_line, int(1473))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*lang.MapEntry)(nil)).Elem() + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_map_DASH_entry_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_map_DASH_entry_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // map? + { + tmp0 := sym_map_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x implements IPersistentMap", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(5), kw_column, int(2), kw_line, int(167), kw_end_DASH_line, int(171))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function map? + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := reflect.TypeOf((*lang.IPersistentMap)(nil)).Elem() + tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(171), kw_column, int(7), kw_end_DASH_line, int(171), kw_end_DASH_column, int(97))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_map_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_map_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // max-mask-bits + { + tmp0 := sym_max_DASH_mask_DASH_bits.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(6601), kw_column, int(6), kw_end_DASH_line, int(6601), kw_end_DASH_column, int(28), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core_max_DASH_mask_DASH_bits = ns.InternWithValue(tmp0, int64(13), true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_max_DASH_mask_DASH_bits.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // max-switch-table-size + { + tmp0 := sym_max_DASH_switch_DASH_table_DASH_size.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(6602), kw_column, int(6), kw_end_DASH_line, int(6602), kw_end_DASH_column, int(36), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core_max_DASH_switch_DASH_table_DASH_size = ns.InternWithValue(tmp0, int64(8192), true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_max_DASH_switch_DASH_table_DASH_size.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // meta + { + tmp0 := sym_meta.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_obj)), kw_doc, "Returns the metadata of obj, returns nil if there is no metadata.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(5), kw_column, int(2), kw_line, int(202), kw_end_DASH_line, int(206))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function meta + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp6 := reflect.TypeOf((*lang.IMeta)(nil)).Elem() + tmp7 := lang.Apply(tmp5, []any{tmp6, v3}) + if lang.IsTruthy(tmp7) { + tmp8, ok := lang.FieldOrMethod(v3, "Meta") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "Meta"))) + } + var tmp9 any + switch reflect.TypeOf(tmp8).Kind() { + case reflect.Func: + tmp9 = lang.Apply(tmp8, nil) + default: + tmp9 = tmp8 + } + tmp4 = tmp9 + } else { + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(206), kw_column, int(7), kw_end_DASH_line, int(208), kw_end_DASH_column, int(21))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_meta = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_meta.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // methods + { + tmp0 := sym_methods.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_multifn)), kw_doc, "Given a multimethod, returns a map of dispatch values -> dispatch fns", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(1809), kw_end_DASH_line, int(1809))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "getMethodTable") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getMethodTable"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_methods = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_methods.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // mix-collection-hash + { + tmp0 := sym_mix_DASH_collection_DASH_hash.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_hash_DASH_basis, sym_count)), kw_doc, "Mix final collection hash for ordered or unordered collections.\n hash-basis is the combined collection hash, count is the number\n of elements included in the basis. Note this is the hash code\n consistent with =, different from .hashCode.\n See http://glojure.org/data_structures#hash for full algorithms.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.6", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(25), kw_column, int(7), kw_line, int(5199), kw_end_DASH_line, int(5199))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := lang.Apply(nil, []any{v2, v3}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_mix_DASH_collection_DASH_hash = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_mix_DASH_collection_DASH_hash.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // mk-bound-fn + { + tmp0 := sym_mk_DASH_bound_DASH_fn.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5127), kw_column, int(7), kw_end_DASH_line, int(5127), kw_end_DASH_column, int(17), kw_arglists, lang.NewList(lang.NewVector(sym_sc, sym_test, sym_key)), kw_private, true, kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v6 := args[0] + _ = v6 + tmp7, ok := lang.FieldOrMethod(v2, "comparator") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "comparator"))) + } + var tmp8 any + switch reflect.TypeOf(tmp7).Kind() { + case reflect.Func: + tmp8 = lang.Apply(tmp7, nil) + default: + tmp8 = tmp7 + } + tmp9, _ := lang.FieldOrMethod(v2, "entryKey") + if reflect.TypeOf(tmp9).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("entryKey is not a function"))) + } + tmp10 := lang.Apply(tmp9, []any{v6}) + tmp11, _ := lang.FieldOrMethod(tmp8, "compare") + if reflect.TypeOf(tmp11).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("compare is not a function"))) + } + tmp12 := lang.Apply(tmp11, []any{tmp10, v4}) + tmp13 := lang.Apply(v3, []any{tmp12, int64(0)}) + return tmp13 + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5130), kw_column, int(3), kw_end_DASH_line, int(5131), kw_end_DASH_column, int(64)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp7 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_mk_DASH_bound_DASH_fn = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_mk_DASH_bound_DASH_fn.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // namespace + { + tmp1 := reflect.TypeOf("") + tmp0 := sym_namespace.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns the namespace String of a symbol or keyword, or nil if not present.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(1593), kw_end_DASH_line, int(1593))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v3, "Namespace") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Namespace is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{}) + return tmp5 + }) + tmp3 := reflect.TypeOf("") + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_namespace = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_namespace.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // next + { + tmp1 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() + tmp0 := sym_next.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a seq of the items after the first. Calls seq on its\n argument. If there are no more items, returns nil.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(5), kw_column, int(2), kw_line, int(55), kw_end_DASH_line, int(61))).(*lang.Symbol) + var tmp2 lang.FnFunc + { // function next + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + tmp5 := lang.Apply(lang.Next, []any{v4}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(61), kw_column, int(7), kw_end_DASH_line, int(61), kw_end_DASH_column, int(77))).(lang.FnFunc) + v3 = tmp2 + _ = v3 + } + var_glojure_DOT_core_next = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_next.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // nfirst + { + tmp0 := sym_nfirst.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Same as (next (first x))", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(2), kw_line, int(105), kw_end_DASH_line, int(109))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function nfirst + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_next) + tmp5 := checkDerefVar(var_glojure_DOT_core_first) + tmp6 := lang.Apply(tmp5, []any{v3}) + tmp7 := lang.Apply(tmp4, []any{tmp6}) + return tmp7 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(109), kw_column, int(9), kw_end_DASH_line, int(109), kw_end_DASH_column, int(49))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_nfirst = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_nfirst.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // nil? + { + tmp1 := reflect.TypeOf(false) + var tmp2 lang.FnFunc + { // function nil?__inliner + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_list) + tmp6 := lang.Apply(tmp5, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Identical, v4, nil}) + return tmp6 + }) + v3 = tmp2 + _ = v3 + } + tmp0 := sym_nil_QMARK_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp2, kw_doc, "Returns true if x is nil, false otherwise.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(435), kw_end_DASH_line, int(435))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + tmp5 := lang.Apply(lang.IsNil, []any{v4}) + return tmp5 + }) + tmp4 := reflect.TypeOf(false) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) + var_glojure_DOT_core_nil_QMARK_ = ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_nil_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // nnext + { + tmp0 := sym_nnext.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Same as (next (next x))", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(6), kw_column, int(2), kw_line, int(119), kw_end_DASH_line, int(123))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function nnext + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_next) + tmp5 := checkDerefVar(var_glojure_DOT_core_next) + tmp6 := lang.Apply(tmp5, []any{v3}) + tmp7 := lang.Apply(tmp4, []any{tmp6}) + return tmp7 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(123), kw_column, int(8), kw_end_DASH_line, int(123), kw_end_DASH_column, int(46))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_nnext = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_nnext.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // not + { + tmp1 := reflect.TypeOf(false) + tmp0 := sym_not.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x is logical false, false otherwise.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(523), kw_end_DASH_line, int(523))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + var tmp4 any + if lang.IsTruthy(v3) { + tmp4 = false + } else { + tmp4 = true + } + return tmp4 + }) + tmp3 := reflect.TypeOf(false) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_not = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_not.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // number? + { + tmp0 := sym_number_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x is a Number", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(3560), kw_end_DASH_line, int(3560))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(lang.IsNumber, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_number_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_number_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // numerator + { + tmp1 := reflect.TypeOf((*big6.Int)(nil)) + tmp0 := sym_numerator.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_r)), kw_doc, "Returns the numerator part of a Ratio.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(3583), kw_end_DASH_line, int(3583))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, ok := lang.FieldOrMethod(v3, "numerator") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "numerator"))) + } + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { + case reflect.Func: + tmp5 = lang.Apply(tmp4, nil) + default: + tmp5 = tmp4 + } + return tmp5 + }) + tmp3 := reflect.TypeOf((*big6.Int)(nil)) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_numerator = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_numerator.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // peek + { + tmp0 := sym_peek.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "For a list or queue, same as first, for a vector, same as, but much\n more efficient than, last. If the collection is empty, returns nil.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1455), kw_end_DASH_line, int(1455))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(runtime.RT, "Peek") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Peek is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_peek = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_peek.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // persistent! + { + tmp0 := sym_persistent_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a new, persistent version of the transient collection, in\n constant time. The transient collection cannot be used after this\n call, any such use will throw an exception.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(3350), kw_end_DASH_line, int(3350))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "Persistent") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "Persistent"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_persistent_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_persistent_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // pop + { + tmp0 := sym_pop.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "For a list or queue, returns a new list/queue without the first\n item, for a vector, returns a new vector without the last item. If\n the collection is empty, throws an exception. Note - not the same\n as next/butlast.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(1462), kw_end_DASH_line, int(1462))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(runtime.RT, "Pop") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Pop is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_pop = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_pop.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // pop! + { + tmp0 := sym_pop_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Removes the last item from a transient vector. If\n the collection is empty, throws an exception. Returns coll", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3393), kw_end_DASH_line, int(3393))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "pop") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "pop"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_pop_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_pop_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // pop-thread-bindings + { + tmp0 := sym_pop_DASH_thread_DASH_bindings.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Pop one set of bindings pushed with push-binding before. It is an error to\n pop bindings without pushing before.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(25), kw_column, int(7), kw_line, int(1929), kw_end_DASH_line, int(1929))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp2 := lang.Apply(lang.PopThreadBindings, nil) + return tmp2 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_pop_DASH_thread_DASH_bindings = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_pop_DASH_thread_DASH_bindings.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // prefer-method + { + tmp0 := sym_prefer_DASH_method.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_multifn, sym_dispatch_DASH_val_DASH_x, sym_dispatch_DASH_val_DASH_y)), kw_doc, "Causes the multimethod to prefer matches of dispatch-val-x over dispatch-val-y \n when there is a conflict", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(1801), kw_end_DASH_line, int(1801))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5, _ := lang.FieldOrMethod(v2, "PreferMethod") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("PreferMethod is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_prefer_DASH_method = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_prefer_DASH_method.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // prefers + { + tmp0 := sym_prefers.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_multifn)), kw_doc, "Given a multimethod, returns a map of preferred value -> set of other values", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(1822), kw_end_DASH_line, int(1822))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "getPreferTable") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getPreferTable"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_prefers = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_prefers.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print-initialized + { + tmp0 := sym_print_DASH_initialized.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core_print.glj", kw_line, int(520), kw_column, int(6), kw_end_DASH_line, int(520), kw_end_DASH_column, int(39), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core_print_DASH_initialized = ns.InternWithValue(tmp0, true, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_print_DASH_initialized.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // push-thread-bindings + { + tmp0 := sym_push_DASH_thread_DASH_bindings.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_bindings)), kw_doc, "WARNING: This is a low-level function. Prefer high-level macros like\n binding where ever possible.\n\n Takes a map of Var/value pairs. Binds each Var to the associated value for\n the current thread. Each call *MUST* be accompanied by a matching call to\n pop-thread-bindings wrapped in a try-finally!\n \n (push-thread-bindings bindings)\n (try\n ...\n (finally\n (pop-thread-bindings)))", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(26), kw_column, int(7), kw_line, int(1911), kw_end_DASH_line, int(1911))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(lang.PushThreadBindings, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_push_DASH_thread_DASH_bindings = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_push_DASH_thread_DASH_bindings.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // random-uuid + { + tmp0 := sym_random_DASH_uuid.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Returns a pseudo-randomly generated java.util.UUID instance (i.e. type 4).\n\n See: https://docs.oracle.com/javase/8/docs/api/java/util/UUID.html#randomUUID--", kw_file, "glojure/core.glj", kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(6852), kw_end_DASH_line, int(6852))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp2 := lang.Apply(uuid10.NewV7, nil) + return tmp2 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_random_DASH_uuid = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_random_DASH_uuid.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ratio? + { + tmp0 := sym_ratio_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_doc, "Returns true if n is a Ratio", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(3577), kw_end_DASH_line, int(3577))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*lang.Ratio)(nil)) + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ratio_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ratio_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // rationalize + { + tmp0 := sym_rationalize.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_num)), kw_doc, "returns the rational value of num", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(1282), kw_end_DASH_line, int(1282))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(lang.Numbers, "Rationalize") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Rationalize is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_rationalize = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_rationalize.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // re-matcher + { + tmp1 := reflect.TypeOf((*lang.RegexpMatcher)(nil)) + tmp0 := sym_re_DASH_matcher.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_re, sym_s)), kw_doc, "Returns an instance of java.util.regex.Matcher, for use, e.g. in\n re-find.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4873), kw_end_DASH_line, int(4873))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(lang.NewRegexpMatcher, []any{v3, v4}) + return tmp5 + }) + tmp3 := reflect.TypeOf((*lang.RegexpMatcher)(nil)) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_re_DASH_matcher = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_re_DASH_matcher.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // re-pattern + { + tmp1 := reflect.TypeOf((*regexp12.Regexp)(nil)) + tmp0 := sym_re_DASH_pattern.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_doc, "Returns an instance of java.util.regex.Pattern, for use, e.g. in\n re-matcher.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4863), kw_end_DASH_line, int(4863))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp6 := reflect.TypeOf((*regexp12.Regexp)(nil)) + tmp7 := lang.Apply(tmp5, []any{tmp6, v3}) + if lang.IsTruthy(tmp7) { + tmp4 = v3 + } else { + tmp8 := lang.Apply(regexp12.MustCompile, []any{v3}) + tmp4 = tmp8 + } + return tmp4 + }) + tmp3 := reflect.TypeOf((*regexp12.Regexp)(nil)) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_re_DASH_pattern = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_re_DASH_pattern.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // read-string + { + tmp0 := sym_read_DASH_string.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s), lang.NewVector(sym_opts, sym_s)), kw_doc, "Reads one object from the string s. Optionally include reader\n options, as specified in read.\n\n Note that read-string can execute code (controlled by *read-eval*),\n and as such should be used only with trusted sources.\n\n For data structure interop use glojure.edn/read-string", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(3806), kw_end_DASH_line, int(3806))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(runtime.RTReadString, []any{v2}) + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := lang.Apply(runtime.RTReadString, []any{v3, v2}) + return tmp4 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_read_DASH_string = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_read_DASH_string.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reader-conditional + { + tmp0 := sym_reader_DASH_conditional.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_form, sym_splicing_QMARK_)), kw_doc, "Construct a data representation of a reader conditional.\n If true, splicing? indicates read-cond-splicing.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(24), kw_column, int(7), kw_line, int(7782), kw_end_DASH_line, int(7782))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := lang.Apply(nil, []any{v2, v3}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_reader_DASH_conditional = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_reader_DASH_conditional.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reader-conditional? + { + tmp0 := sym_reader_DASH_conditional_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_value)), kw_doc, "Return true if the value is the data representation of a reader conditional", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(25), kw_column, int(7), kw_line, int(7776), kw_end_DASH_line, int(7776))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := lang.Apply(tmp3, []any{nil, v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_reader_DASH_conditional_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_reader_DASH_conditional_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // realized? + { + tmp0 := sym_realized_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if a value has been produced for a promise, delay, future or lazy sequence.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(7559), kw_end_DASH_line, int(7559))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "isRealized") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "isRealized"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_realized_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_realized_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reduced + { + tmp0 := sym_reduced.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Wraps x in a way such that a reduce will terminate with the value x", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(2828), kw_end_DASH_line, int(2828))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(lang.NewReduced, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_reduced = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_reduced.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ref-history-count + { + tmp0 := sym_ref_DASH_history_DASH_count.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ref)), kw_doc, "Returns the history count of a ref", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(7), kw_line, int(2455), kw_end_DASH_line, int(2455))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "getHistoryCount") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getHistoryCount"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ref_DASH_history_DASH_count = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ref_DASH_history_DASH_count.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ref-max-history + { + tmp0 := sym_ref_DASH_max_DASH_history.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ref), lang.NewVector(sym_ref, sym_n)), kw_doc, "Gets the max-history of a ref, or sets it and returns the ref", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(2471), kw_end_DASH_line, int(2471))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "getMaxHistory") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getMaxHistory"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "setMaxHistory") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMaxHistory is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ref_DASH_max_DASH_history = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ref_DASH_max_DASH_history.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ref-min-history + { + tmp0 := sym_ref_DASH_min_DASH_history.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ref), lang.NewVector(sym_ref, sym_n)), kw_doc, "Gets the min-history of a ref, or sets it and returns the ref", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(2462), kw_end_DASH_line, int(2462))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "getMinHistory") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getMinHistory"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "setMinHistory") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMinHistory is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ref_DASH_min_DASH_history = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ref_DASH_min_DASH_history.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ref-set + { + tmp0 := sym_ref_DASH_set.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ref, sym_val)), kw_doc, "Must be called in a transaction. Sets the value of ref.\n Returns val.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(2447), kw_end_DASH_line, int(2447))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "set") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("set is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ref_DASH_set = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ref_DASH_set.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // release-pending-sends + { + tmp0 := sym_release_DASH_pending_DASH_sends.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Normally, actions sent directly or indirectly during another action\n are held until the action completes (changes the agent's\n state). This function can be used to dispatch any pending sent\n actions immediately. This has no impact on actions sent during a\n transaction, which are still held until commit. If no action is\n occurring, does nothing. Returns the number of actions dispatched.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(27), kw_column, int(7), kw_line, int(2131), kw_end_DASH_line, int(2131))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp2 := lang.Apply(nil, nil) + return tmp2 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_release_DASH_pending_DASH_sends = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_release_DASH_pending_DASH_sends.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // remove-all-methods + { + tmp0 := sym_remove_DASH_all_DASH_methods.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_multifn)), kw_doc, "Removes all of the methods of multimethod.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(24), kw_column, int(7), kw_line, int(1787), kw_end_DASH_line, int(1787))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "reset") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "reset"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_remove_DASH_all_DASH_methods = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_remove_DASH_all_DASH_methods.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // remove-method + { + tmp0 := sym_remove_DASH_method.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_multifn, sym_dispatch_DASH_val)), kw_doc, "Removes the method of multimethod associated with dispatch-value.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(1794), kw_end_DASH_line, int(1794))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "removeMethod") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("removeMethod is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_remove_DASH_method = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_remove_DASH_method.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // remove-ns + { + tmp0 := sym_remove_DASH_ns.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_sym)), kw_doc, "Removes the namespace named by the symbol. Use with caution.\n Cannot be used to remove the glojure namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(4139), kw_end_DASH_line, int(4139))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(lang.RemoveNamespace, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_remove_DASH_ns = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_remove_DASH_ns.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // remove-watch + { + tmp0 := sym_remove_DASH_watch.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_reference, sym_key)), kw_doc, "Removes a watch (set by add-watch) from a reference", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(2160), kw_end_DASH_line, int(2160))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "removeWatch") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("removeWatch is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_remove_DASH_watch = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_remove_DASH_watch.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // repeat + { + tmp0 := sym_repeat.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_n, sym_x)), kw_doc, "Returns a lazy (infinite!, or length n if supplied) sequence of xs.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(2997), kw_end_DASH_line, int(2997))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(lang.NewRepeat, []any{v2}) + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := lang.Apply(lang.NewRepeatN, []any{v2, v3}) + return tmp4 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_repeat = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_repeat.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reset! + { + tmp0 := sym_reset_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_atom, sym_newval)), kw_doc, "Sets the value of atom to newval without regard for the\n current value. Returns newval.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(2368), kw_end_DASH_line, int(2368))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "reset") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_reset_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_reset_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reset-meta! + { + tmp0 := sym_reset_DASH_meta_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_iref, sym_metadata_DASH_map)), kw_doc, "Atomically resets the metadata for a namespace/var/ref/agent/atom", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(2408), kw_end_DASH_line, int(2408))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "ResetMeta") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ResetMeta is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_reset_DASH_meta_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_reset_DASH_meta_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reset-vals! + { + tmp0 := sym_reset_DASH_vals_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_atom, sym_newval)), kw_doc, "Sets the value of atom to newval. Returns [old new], the value of the\n atom before and after the reset.", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(2375), kw_end_DASH_line, int(2375))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "resetVals") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("resetVals is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_reset_DASH_vals_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_reset_DASH_vals_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // rest + { + tmp1 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() + tmp0 := sym_rest.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a possibly empty seq of the items after the first. Calls seq on its\n argument.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(5), kw_column, int(2), kw_line, int(64), kw_end_DASH_line, int(70))).(*lang.Symbol) + var tmp2 lang.FnFunc + { // function rest + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + tmp5 := lang.Apply(lang.Rest, []any{v4}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(70), kw_column, int(7), kw_end_DASH_line, int(70), kw_end_DASH_column, int(77))).(lang.FnFunc) + v3 = tmp2 + _ = v3 + } + var_glojure_DOT_core_rest = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_rest.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reversible? + { + tmp0 := sym_reversible_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns true if coll implements Reversible", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(6257), kw_end_DASH_line, int(6257))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := lang.Apply(tmp3, []any{nil, v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_reversible_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_reversible_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // rseq + { + tmp0 := sym_rseq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_rev)), kw_doc, "Returns, in constant time, a seq of the items in rev (which\n can be a vector or sorted-map), in reverse order. If rev is empty returns nil", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1577), kw_end_DASH_line, int(1577))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(v2, "rseq") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("rseq is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_rseq = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_rseq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // second + { + tmp0 := sym_second.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Same as (first (next x))", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(2), kw_line, int(91), kw_end_DASH_line, int(95))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function second + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_first) + tmp5 := checkDerefVar(var_glojure_DOT_core_next) + tmp6 := lang.Apply(tmp5, []any{v3}) + tmp7 := lang.Apply(tmp4, []any{tmp6}) + return tmp7 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(95), kw_column, int(9), kw_end_DASH_line, int(95), kw_end_DASH_column, int(49))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_second = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_second.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // seq + { + tmp1 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() + tmp0 := sym_seq.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a seq on the collection. If the collection is\n empty, returns nil. (seq nil) returns nil. seq also works on\n Strings, native Java arrays (of reference types) and any objects\n that implement Iterable. Note that seqs cache values, thus seq\n should not be used on any Iterable whose iterator repeatedly\n returns the same mutable object.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(4), kw_column, int(2), kw_line, int(126), kw_end_DASH_line, int(136))).(*lang.Symbol) + var tmp2 lang.FnFunc + { // function seq + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + tmp5 := lang.Apply(lang.Seq, []any{v4}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(136), kw_column, int(6), kw_end_DASH_line, int(136), kw_end_DASH_column, int(126))).(lang.FnFunc) + v3 = tmp2 + _ = v3 + } + var_glojure_DOT_core_seq = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_seq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // seq? + { + tmp0 := sym_seq_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x implements ISeq", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(5), kw_column, int(2), kw_line, int(146), kw_end_DASH_line, int(150))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function seq? + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() + tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(150), kw_column, int(7), kw_end_DASH_line, int(150), kw_end_DASH_column, int(87))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_seq_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_seq_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // seqable? + { + tmp0 := sym_seqable_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if the seq function is supported for x", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(6204), kw_end_DASH_line, int(6204))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(nil, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_seqable_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_seqable_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // sequential? + { + tmp0 := sym_sequential_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns true if coll implements Sequential", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(6229), kw_end_DASH_line, int(6229))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*lang.Sequential)(nil)).Elem() + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_sequential_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_sequential_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // set-agent-send-executor! + { + tmp0 := sym_set_DASH_agent_DASH_send_DASH_executor_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_executor)), kw_doc, "Sets the ExecutorService to be used by send", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(30), kw_column, int(7), kw_line, int(2087), kw_end_DASH_line, int(2087))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + return nil + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_set_DASH_agent_DASH_send_DASH_executor_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_set_DASH_agent_DASH_send_DASH_executor_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // set-agent-send-off-executor! + { + tmp0 := sym_set_DASH_agent_DASH_send_DASH_off_DASH_executor_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_executor)), kw_doc, "Sets the ExecutorService to be used by send-off", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(34), kw_column, int(7), kw_line, int(2093), kw_end_DASH_line, int(2093))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + return nil + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_set_DASH_agent_DASH_send_DASH_off_DASH_executor_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_set_DASH_agent_DASH_send_DASH_off_DASH_executor_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // set-error-handler! + { + tmp0 := sym_set_DASH_error_DASH_handler_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a, sym_handler_DASH_fn)), kw_doc, "Sets the error-handler of agent a to handler-fn. If an action\n being run by the agent throws an exception or doesn't pass the\n validator fn, handler-fn will be called with two arguments: the\n agent and the exception.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(24), kw_column, int(7), kw_line, int(2192), kw_end_DASH_line, int(2192))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "setErrorHandler") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorHandler is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_set_DASH_error_DASH_handler_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_set_DASH_error_DASH_handler_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // set-error-mode! + { + tmp0 := sym_set_DASH_error_DASH_mode_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a, sym_mode_DASH_keyword)), kw_doc, "Sets the error-mode of agent a to mode-keyword, which must be\n either :fail or :continue. If an action being run by the agent\n throws an exception or doesn't pass the validator fn, an\n error-handler may be called (see set-error-handler!), after which,\n if the mode is :continue, the agent will continue as if neither the\n action that caused the error nor the error itself ever happened.\n \n If the mode is :fail, the agent will become failed and will stop\n accepting new 'send' and 'send-off' actions, and any previously\n queued actions will be held until a 'restart-agent'. Deref will\n still work, returning the state of the agent before the error.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(2210), kw_end_DASH_line, int(2210))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "setErrorMode") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorMode is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_set_DASH_error_DASH_mode_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_set_DASH_error_DASH_mode_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // set-validator! + { + tmp0 := sym_set_DASH_validator_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_iref, sym_validator_DASH_fn)), kw_doc, "Sets the validator-fn for a var/ref/agent/atom. validator-fn must be nil or a\n side-effect-free fn of one argument, which will be passed the intended\n new state on any state change. If the new state is unacceptable, the\n validator-fn should return false or throw an exception. If the current state (root\n value if var) is not acceptable to the new validator, an exception\n will be thrown and the validator will not be changed.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(2381), kw_end_DASH_line, int(2381))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "setValidator") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setValidator is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_set_DASH_validator_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_set_DASH_validator_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // set? + { + tmp0 := sym_set_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x implements IPersistentSet", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(4098), kw_end_DASH_line, int(4098))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*lang.IPersistentSet)(nil)).Elem() + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_set_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_set_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // shutdown-agents + { + tmp0 := sym_shutdown_DASH_agents.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Initiates a shutdown of the thread pools that back the agent\n system. Running actions will complete, but no new actions will be\n accepted", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(2252), kw_end_DASH_line, int(2252))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp2 := lang.Apply(lang.ShutdownAgents, nil) + return tmp2 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_shutdown_DASH_agents = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_shutdown_DASH_agents.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // simple-keyword? + { + tmp0 := sym_simple_DASH_keyword_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a keyword without a namespace", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(1633), kw_end_DASH_line, int(1633))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "and__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + tmp8 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp9 := checkDerefVar(var_glojure_DOT_core_namespace) + tmp10 := lang.Apply(tmp9, []any{v2}) + tmp11 := lang.Apply(tmp8, []any{tmp10}) + tmp7 = tmp11 + } else { + tmp7 = v6 + } + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_simple_DASH_keyword_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_simple_DASH_keyword_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // some + { + tmp0 := sym_some.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns the first logical true value of (pred x) for any x in coll,\n else nil. One common idiom is to use a set as pred, for example\n this will return :fred if :fred is in the sequence, otherwise nil:\n (some #{:fred} coll)", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(2684), kw_end_DASH_line, int(2684))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + recur_loop_2021: + var tmp4 any + { // let + // let binding "temp__0__auto__" + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := lang.Apply(tmp5, []any{v3}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + if lang.IsTruthy(v7) { + var tmp9 any + { // let + // let binding "s" + var v10 any = v7 + _ = v10 + var tmp11 any + { // let + // let binding "or__0__auto__" + tmp12 := checkDerefVar(var_glojure_DOT_core_first) + tmp13 := lang.Apply(tmp12, []any{v10}) + tmp14 := lang.Apply(v2, []any{tmp13}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + if lang.IsTruthy(v15) { + tmp16 = v15 + } else { + var tmp17 any = v2 + tmp19 := checkDerefVar(var_glojure_DOT_core_next) + tmp20 := lang.Apply(tmp19, []any{v10}) + var tmp18 any = tmp20 + v2 = tmp17 + v3 = tmp18 + goto recur_loop_2021 + } + tmp11 = tmp16 + } // end let + tmp9 = tmp11 + } // end let + tmp8 = tmp9 + } else { + } + tmp4 = tmp8 + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_some = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_some.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // some? + { + tmp1 := reflect.TypeOf(false) + tmp0 := sym_some_QMARK_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x is not nil, false otherwise.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.6", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(530), kw_end_DASH_line, int(530))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_not) + tmp5 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + tmp7 := lang.Apply(tmp4, []any{tmp6}) + return tmp7 + }) + tmp3 := reflect.TypeOf(false) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_some_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_some_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // sorted-map + { + tmp0 := sym_sorted_DASH_map.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_keyvals)), kw_doc, "keyval => key val\n Returns a new sorted map with supplied mappings. If any keys are\n equal, they are handled as if by repeated uses of assoc.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(397), kw_end_DASH_line, int(397))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + tmp3 := lang.Apply(lang.CreatePersistentTreeMap, []any{v2}) + return tmp3 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_sorted_DASH_map = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_sorted_DASH_map.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // sorted-map-by + { + tmp0 := sym_sorted_DASH_map_DASH_by.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_comparator, sym__AMP_, sym_keyvals)), kw_doc, "keyval => key val\n Returns a new sorted map with supplied mappings, using the supplied\n comparator. If any keys are equal, they are handled as if by\n repeated uses of assoc.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(406), kw_end_DASH_line, int(406))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + tmp4 := lang.Apply(nil, []any{v2, v3}) + return tmp4 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_sorted_DASH_map_DASH_by = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_sorted_DASH_map_DASH_by.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // sorted-set + { + tmp0 := sym_sorted_DASH_set.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_keys)), kw_doc, "Returns a new sorted set with supplied keys. Any equal keys are\n handled as if by repeated uses of conj.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(416), kw_end_DASH_line, int(416))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + tmp3 := lang.Apply(lang.CreatePersistentTreeSet, []any{v2}) + return tmp3 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_sorted_DASH_set = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_sorted_DASH_set.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // sorted-set-by + { + tmp0 := sym_sorted_DASH_set_DASH_by.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_comparator, sym__AMP_, sym_keys)), kw_doc, "Returns a new sorted set with supplied keys, using the supplied\n comparator. Any equal keys are handled as if by repeated uses of\n conj.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(424), kw_end_DASH_line, int(424))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + tmp4 := lang.Apply(lang.CreatePersistentTreeSetWithComparator, []any{v2, v3}) + return tmp4 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_sorted_DASH_set_DASH_by = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_sorted_DASH_set_DASH_by.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // sorted? + { + tmp0 := sym_sorted_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns true if coll implements Sorted", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(6235), kw_end_DASH_line, int(6235))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := lang.Apply(tmp3, []any{nil, v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_sorted_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_sorted_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // special-symbol? + { + tmp0 := sym_special_DASH_symbol_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_doc, "Returns true if s names a special form", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(4992), kw_end_DASH_line, int(4992))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp4, ok := lang.FieldOrMethod(runtime.Compiler, "specials") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", runtime.Compiler, "specials"))) + } + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { + case reflect.Func: + tmp5 = lang.Apply(tmp4, nil) + default: + tmp5 = tmp4 + } + tmp6 := lang.Apply(tmp3, []any{tmp5, v2}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_special_DASH_symbol_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_special_DASH_symbol_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // spread + { + tmp0 := sym_spread.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_arglist)), kw_static, true, kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(632), kw_end_DASH_line, int(632), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + } else { + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp8 := checkDerefVar(var_glojure_DOT_core_next) + tmp9 := lang.Apply(tmp8, []any{v2}) + tmp10 := lang.Apply(tmp7, []any{tmp9}) + if lang.IsTruthy(tmp10) { + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_first) + tmp13 := lang.Apply(tmp12, []any{v2}) + tmp14 := lang.Apply(tmp11, []any{tmp13}) + tmp6 = tmp14 + } else { + var tmp15 any + if lang.IsTruthy(kw_else) { + tmp16 := checkDerefVar(var_glojure_DOT_core_cons) + tmp17 := checkDerefVar(var_glojure_DOT_core_first) + tmp18 := lang.Apply(tmp17, []any{v2}) + tmp19 := checkDerefVar(var_glojure_DOT_core_spread) + tmp20 := checkDerefVar(var_glojure_DOT_core_next) + tmp21 := lang.Apply(tmp20, []any{v2}) + tmp22 := lang.Apply(tmp19, []any{tmp21}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp22}) + tmp15 = tmp23 + } else { + } + tmp6 = tmp15 + } + tmp3 = tmp6 + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_spread = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_spread.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // str + { + tmp1 := reflect.TypeOf("") + tmp0 := sym_str.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_x), lang.NewVector(sym_x, sym__AMP_, sym_ys)), kw_doc, "With no args, returns the empty string. With one arg x, returns\n x.toString(). (str nil) returns the empty string. With more than\n one arg, returns the concatenation of the str values of the args.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(543), kw_end_DASH_line, int(543))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return "" + case 1: + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + tmp4 = "" + } else { + tmp7 := lang.Apply(lang.ToString, []any{v3}) + tmp4 = tmp7 + } + return tmp4 + default: + checkArity(args, 1) + v3 := args[0] + _ = v3 + var v4 any = lang.NewList(args[1:]...) + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + recur_loop_1614: + var tmp8 any + if lang.IsTruthy(v7) { + tmp10 := checkDerefVar(var_glojure_DOT_core_str) + tmp11 := checkDerefVar(var_glojure_DOT_core_first) + tmp12 := lang.Apply(tmp11, []any{v7}) + tmp13 := lang.Apply(tmp10, []any{tmp12}) + tmp14, _ := lang.FieldOrMethod(v6, "WriteString") + if reflect.TypeOf(tmp14).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("WriteString is not a function"))) + } + tmp15 := lang.Apply(tmp14, []any{tmp13}) + _ = tmp15 + var tmp9 any = v6 + tmp17 := checkDerefVar(var_glojure_DOT_core_next) + tmp18 := lang.Apply(tmp17, []any{v7}) + var tmp16 any = tmp18 + v6 = tmp9 + v7 = tmp16 + goto recur_loop_1614 + } else { + tmp19, ok := lang.FieldOrMethod(v6, "String") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "String"))) + } + var tmp20 any + switch reflect.TypeOf(tmp19).Kind() { + case reflect.Func: + tmp20 = lang.Apply(tmp19, nil) + default: + tmp20 = tmp19 + } + tmp8 = tmp20 + } + return tmp8 + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(554), kw_column, int(7), kw_end_DASH_line, int(554), kw_end_DASH_column, int(127)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp8 := checkDerefVar(var_glojure_DOT_core_cons) + tmp9 := lang.Apply(tmp8, []any{v3, v4}) + tmp10 := lang.Apply(tmp7, []any{"unimplemented: new with non-constant class type", tmp9}) + return tmp10 + } + }) + tmp3 := reflect.TypeOf("") + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_str = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_str.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // stream-reduce! + { + tmp0 := sym_stream_DASH_reduce_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_s), lang.NewVector(sym_f, sym_init, sym_s)), kw_doc, "Works like reduce but takes a java.util.stream.BaseStream as its source.\n Honors 'reduced', is a terminal operation on the stream", kw_file, "glojure/core.glj", kw_added, "1.12", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(6784), kw_end_DASH_line, int(6784))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, ok := lang.FieldOrMethod(v3, "iterator") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "iterator"))) + } + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { + case reflect.Func: + tmp5 = lang.Apply(tmp4, nil) + default: + tmp5 = tmp4 + } + tmp6 := lang.Apply(nil, []any{tmp5, v2}) + return tmp6 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5, ok := lang.FieldOrMethod(v4, "iterator") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "iterator"))) + } + var tmp6 any + switch reflect.TypeOf(tmp5).Kind() { + case reflect.Func: + tmp6 = lang.Apply(tmp5, nil) + default: + tmp6 = tmp5 + } + tmp7 := lang.Apply(nil, []any{tmp6, v2, v3}) + return tmp7 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_stream_DASH_reduce_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_stream_DASH_reduce_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // stream-seq! + { + tmp0 := sym_stream_DASH_seq_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_stream)), kw_doc, "Takes a java.util.stream.BaseStream instance s and returns a seq of its\n contents. This is a terminal operation on the stream.", kw_file, "glojure/core.glj", kw_added, "1.12", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(6793), kw_end_DASH_line, int(6793))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_iterator_DASH_seq) + tmp4, ok := lang.FieldOrMethod(v2, "iterator") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "iterator"))) + } + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { + case reflect.Func: + tmp5 = lang.Apply(tmp4, nil) + default: + tmp5 = tmp4 + } + tmp6 := lang.Apply(tmp3, []any{tmp5}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_stream_DASH_seq_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_stream_DASH_seq_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // stream-transduce! + { + tmp0 := sym_stream_DASH_transduce_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xform, sym_f, sym_stream), lang.NewVector(sym_xform, sym_f, sym_init, sym_stream)), kw_doc, "Works like transduce but takes a java.util.stream.BaseStream as its source.\n This is a terminal operation on the stream.", kw_file, "glojure/core.glj", kw_added, "1.12", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(7), kw_line, int(6800), kw_end_DASH_line, int(6800))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_stream_DASH_transduce_BANG_) + tmp6 := lang.Apply(v3, nil) + tmp7 := lang.Apply(tmp5, []any{v2, v3, tmp6, v4}) + return tmp7 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var tmp6 any + { // let + // let binding "f" + tmp7 := lang.Apply(v2, []any{v3}) + var v8 any = tmp7 + _ = v8 + // let binding "ret" + tmp9 := checkDerefVar(var_glojure_DOT_core_stream_DASH_reduce_BANG_) + tmp10 := lang.Apply(tmp9, []any{v8, v4, v5}) + var v11 any = tmp10 + _ = v11 + tmp12 := lang.Apply(v8, []any{v11}) + tmp6 = tmp12 + } // end let + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_stream_DASH_transduce_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_stream_DASH_transduce_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // string? + { + tmp0 := sym_string_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a String", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(2), kw_line, int(160), kw_end_DASH_line, int(164))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function string? + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := lang.Apply(tmp4, []any{lang.Builtins["string"], v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(164), kw_column, int(10), kw_end_DASH_line, int(164), kw_end_DASH_column, int(58))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_string_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_string_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // struct + { + tmp0 := sym_struct.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s, sym__AMP_, sym_vals)), kw_doc, "Returns a new structmap instance with the keys of the\n structure-basis. vals must be supplied for basis keys in order -\n where values are not supplied they will default to nil.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(4061), kw_end_DASH_line, int(4061))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + tmp4 := lang.Apply(lang.ConstructPersistentStructMap, []any{v2, v3}) + return tmp4 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_struct = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_struct.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // struct-map + { + tmp0 := sym_struct_DASH_map.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s, sym__AMP_, sym_inits)), kw_doc, "Returns a new structmap instance with the keys of the\n structure-basis. keyvals may contain all, some or none of the basis\n keys - where values are not supplied they will default to nil.\n keyvals can also contain keys not in the basis.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4051), kw_end_DASH_line, int(4051))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + tmp4 := lang.Apply(lang.CreatePersistentStructMap, []any{v2, v3}) + return tmp4 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_struct_DASH_map = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_struct_DASH_map.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // subs + { + tmp0 := sym_subs.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s, sym_start), lang.NewVector(sym_s, sym_start, sym_end)), kw_doc, "Returns the substring of s beginning at start inclusive, and ending\n at end (defaults to length of string), exclusive.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(5005), kw_end_DASH_line, int(5005))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := lang.Apply(lang.Builtins["slice"], []any{v2, v3}) + return tmp4 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := lang.Apply(lang.Builtins["slice"], []any{v2, v3, v4}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_subs = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_subs.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // swap! + { + tmp0 := sym_swap_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_atom, sym_f, sym__AMP_, sym_args)), kw_doc, "Atomically swaps the value of atom to be:\n (apply f current-value-of-atom args). Note that f may be called\n multiple times, and thus should be free of side effects. Returns\n the value that was swapped in.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(2343), kw_end_DASH_line, int(2343))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5, _ := lang.FieldOrMethod(v2, "swap") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("swap is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_swap_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_swap_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // swap-vals! + { + tmp0 := sym_swap_DASH_vals_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_atom, sym_f, sym__AMP_, sym_args)), kw_doc, "Atomically swaps the value of atom to be:\n (apply f current-value-of-atom args). Note that f may be called\n multiple times, and thus should be free of side effects.\n Returns [old new], the value of the atom before and after the swap.", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(2352), kw_end_DASH_line, int(2352))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5, _ := lang.FieldOrMethod(v2, "swapVals") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("swapVals is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_swap_DASH_vals_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_swap_DASH_vals_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // symbol? + { + tmp0 := sym_symbol_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a Symbol", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(557), kw_end_DASH_line, int(557))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*lang.Symbol)(nil)) + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_symbol_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_symbol_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // system-newline + { + tmp0 := sym_system_DASH_newline.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(3695), kw_column, int(6), kw_end_DASH_line, int(3695), kw_end_DASH_column, int(40), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core_system_DASH_newline = ns.InternWithValue(tmp0, "\n", true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_system_DASH_newline.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // tagged-literal + { + tmp0 := sym_tagged_DASH_literal.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_tag, sym_form)), kw_doc, "Construct a data representation of a tagged literal from a\n tag symbol and a form.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(7769), kw_end_DASH_line, int(7769))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := lang.Apply(nil, []any{v2, v3}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_tagged_DASH_literal = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_tagged_DASH_literal.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // tagged-literal? + { + tmp0 := sym_tagged_DASH_literal_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_value)), kw_doc, "Return true if the value is the data representation of a tagged literal", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(7763), kw_end_DASH_line, int(7763))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := lang.Apply(tmp3, []any{nil, v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_tagged_DASH_literal_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_tagged_DASH_literal_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // take-while + { + tmp0 := sym_take_DASH_while.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred), lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns a lazy sequence of successive items from coll while\n (pred item) returns logical true. pred must be free of side-effects.\n Returns a transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(2880), kw_end_DASH_line, int(2880))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp6 := lang.Apply(v4, nil) + return tmp6 + case 1: + v6 := args[0] + _ = v6 + tmp7 := lang.Apply(v4, []any{v6}) + return tmp7 + case 2: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + var tmp8 any + tmp9 := lang.Apply(v2, []any{v7}) + if lang.IsTruthy(tmp9) { + tmp10 := lang.Apply(v4, []any{v6, v7}) + tmp8 = tmp10 + } else { + tmp11 := checkDerefVar(var_glojure_DOT_core_reduced) + tmp12 := lang.Apply(tmp11, []any{v6}) + tmp8 = tmp12 + } + return tmp8 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2888), kw_column, int(8), kw_end_DASH_line, int(2894), kw_end_DASH_column, int(33)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp7 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2887), kw_column, int(6), kw_end_DASH_line, int(2894), kw_end_DASH_column, int(34)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp5 any + { // let + // let binding "temp__0__auto__" + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := lang.Apply(tmp6, []any{v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + var tmp10 any + { // let + // let binding "s" + var v11 any = v8 + _ = v11 + var tmp12 any + tmp13 := checkDerefVar(var_glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v11}) + tmp15 := lang.Apply(v2, []any{tmp14}) + if lang.IsTruthy(tmp15) { + tmp16 := checkDerefVar(var_glojure_DOT_core_cons) + tmp17 := checkDerefVar(var_glojure_DOT_core_first) + tmp18 := lang.Apply(tmp17, []any{v11}) + tmp19 := checkDerefVar(var_glojure_DOT_core_take_DASH_while) + tmp20 := checkDerefVar(var_glojure_DOT_core_rest) + tmp21 := lang.Apply(tmp20, []any{v11}) + tmp22 := lang.Apply(tmp19, []any{v2, tmp21}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp22}) + tmp12 = tmp23 + } else { + } + tmp10 = tmp12 + } // end let + tmp9 = tmp10 + } else { + } + tmp5 = tmp9 + } // end let + return tmp5 + }) + tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_take_DASH_while = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_take_DASH_while.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // tapset + { + tmp0 := sym_tapset.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(7882), kw_column, int(10), kw_end_DASH_line, int(7882), kw_end_DASH_column, int(25), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + tmp1 := lang.NewAtom(lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{}))) + var_glojure_DOT_core_tapset = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_tapset.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // test + { + tmp0 := sym_test.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_v)), kw_doc, "test [v] finds fn at key :test in var metadata and calls it,\n presuming failure will throw exception", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(4853), kw_end_DASH_line, int(4853))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "f" + tmp4 := checkDerefVar(var_glojure_DOT_core_meta) + tmp5 := lang.Apply(tmp4, []any{v2}) + tmp6 := lang.Apply(kw_test, []any{tmp5}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + if lang.IsTruthy(v7) { + tmp9 := lang.Apply(v7, nil) + _ = tmp9 + tmp8 = kw_ok + } else { + tmp8 = kw_no_DASH_test + } + tmp3 = tmp8 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_test = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_test.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // the-ns + { + tmp0 := sym_the_DASH_ns.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "If passed a namespace, returns it. Else, when passed a symbol,\n returns the namespace named by it, throwing an exception if not\n found.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(4152), kw_end_DASH_line, int(4152))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := reflect.TypeOf((*lang.Namespace)(nil)) + tmp6 := lang.Apply(tmp4, []any{tmp5, v2}) + if lang.IsTruthy(tmp6) { + tmp3 = v2 + } else { + var tmp7 any + { // let + // let binding "or__0__auto__" + tmp8 := checkDerefVar(var_glojure_DOT_core_find_DASH_ns) + tmp9 := lang.Apply(tmp8, []any{v2}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + if lang.IsTruthy(v10) { + tmp11 = v10 + } else { + tmp12 := checkDerefVar(var_glojure_DOT_core_str) + tmp13 := lang.Apply(tmp12, []any{"No namespace: ", v2, " found"}) + tmp14 := lang.Apply(lang.NewError, []any{tmp13}) + panic(tmp14) + } + tmp7 = tmp11 + } // end let + tmp3 = tmp7 + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_the_DASH_ns = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_the_DASH_ns.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // to-array + { + tmp0 := sym_to_DASH_array.WithMeta(lang.NewMap(kw_tag, "[Ljava.lang.Object;", kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns an array of Objects containing the contents of coll, which\n can be any Collection. Maps to java.util.Collection.toArray().", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(337), kw_end_DASH_line, int(337))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(runtime.RT, "ToArray") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ToArray is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, "[Ljava.lang.Object;")).(lang.FnFunc) + var_glojure_DOT_core_to_DASH_array = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_to_DASH_array.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // transient + { + tmp0 := sym_transient.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a new, transient version of the collection, in constant time.\n\n Transients support a parallel set of 'changing' operations, with similar names\n followed by ! - assoc!, conj! etc. These do the same things as their persistent\n counterparts except the return values are themselves transient.\n\n Note in particular that transients are not designed to be bashed in-place. You\n must capture and use the return value in the next call. In this way, they support\n the same code structure as the functional persistent code they replace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(3335), kw_end_DASH_line, int(3335))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "AsTransient") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "AsTransient"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_transient = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_transient.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // true? + { + tmp1 := reflect.TypeOf(false) + tmp0 := sym_true_QMARK_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x is the value true, false otherwise.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(511), kw_end_DASH_line, int(511))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.Identical, []any{v3, true}) + return tmp4 + }) + tmp3 := reflect.TypeOf(false) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_true_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_true_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unquote + { + tmp0 := sym_unquote.WithMeta(lang.NewMap()).(*lang.Symbol) + var_glojure_DOT_core_unquote = ns.Intern(tmp0) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unquote.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unquote-splicing + { + tmp0 := sym_unquote_DASH_splicing.WithMeta(lang.NewMap()).(*lang.Symbol) + var_glojure_DOT_core_unquote_DASH_splicing = ns.Intern(tmp0) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unquote_DASH_splicing.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // uri? + { + tmp0 := sym_uri_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a java.net.URI", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(7877), kw_end_DASH_line, int(7877))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*url14.URL)(nil)).Elem() + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_uri_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_uri_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // uuid? + { + tmp0 := sym_uuid_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a java.util.UUID", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(6847), kw_end_DASH_line, int(6847))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf([16]uint8{}) + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_uuid_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_uuid_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // val + { + tmp0 := sym_val.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_e)), kw_doc, "Returns the value in the map entry.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(1570), kw_end_DASH_line, int(1570))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(v2, "GetValue") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("GetValue is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_val = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_val.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // vals + { + tmp0 := sym_vals.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_map)), kw_doc, "Returns a sequence of the map's values, in the same order as (seq map).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1557), kw_end_DASH_line, int(1557))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(lang.Vals, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_vals = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_vals.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // var-get + { + tmp0 := sym_var_DASH_get.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Gets the value in the var object", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4326), kw_end_DASH_line, int(4326))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(v2, "Get") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Get is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_var_DASH_get = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_var_DASH_get.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // var-set + { + tmp0 := sym_var_DASH_set.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_val)), kw_doc, "Sets the value in the var object to val. The var must be\n thread-locally bound.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4332), kw_end_DASH_line, int(4332))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "Set") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Set is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_var_DASH_set = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_var_DASH_set.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // var? + { + tmp0 := sym_var_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_v)), kw_doc, "Returns true if v is of type glojure.lang.Var", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(4999), kw_end_DASH_line, int(4999))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*lang.Var)(nil)) + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_var_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_var_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // vector + { + tmp0 := sym_vector.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_a), lang.NewVector(sym_a, sym_b), lang.NewVector(sym_a, sym_b, sym_c), lang.NewVector(sym_a, sym_b, sym_c, sym_d), lang.NewVector(sym_a, sym_b, sym_c, sym_d, sym_e), lang.NewVector(sym_a, sym_b, sym_c, sym_d, sym_e, sym_f), lang.NewVector(sym_a, sym_b, sym_c, sym_d, sym_e, sym_f, sym__AMP_, sym_args)), kw_doc, "Creates a new vector containing the args.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(352), kw_end_DASH_line, int(352))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp2 := lang.NewVector() + tmp3 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(356), kw_column, int(7), kw_end_DASH_line, int(356), kw_end_DASH_column, int(8)) + tmp4, err := lang.WithMeta(tmp2, tmp3.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp4 + case 1: + v2 := args[0] + _ = v2 + tmp3 := lang.NewVector(v2) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(357), kw_column, int(8), kw_end_DASH_line, int(357), kw_end_DASH_column, int(10)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := lang.NewVector(v2, v3) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(358), kw_column, int(10), kw_end_DASH_line, int(358), kw_end_DASH_column, int(14)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := lang.NewVector(v2, v3, v4) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(359), kw_column, int(12), kw_end_DASH_line, int(359), kw_end_DASH_column, int(18)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp7 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + tmp6 := lang.NewVector(v2, v3, v4, v5) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(360), kw_column, int(14), kw_end_DASH_line, int(360), kw_end_DASH_column, int(22)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp8 + case 5: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + tmp7 := lang.NewVector(v2, v3, v4, v5, v6) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(361), kw_column, int(15), kw_end_DASH_line, int(361), kw_end_DASH_column, int(25)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp9 + case 6: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + v7 := args[5] + _ = v7 + tmp8 := lang.NewVector(v2, v3, v4, v5, v6, v7) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(362), kw_column, int(17), kw_end_DASH_line, int(362), kw_end_DASH_column, int(29)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp10 + default: + checkArity(args, 6) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + v7 := args[5] + _ = v7 + var v8 any = lang.NewList(args[6:]...) + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_cons) + tmp10 := checkDerefVar(var_glojure_DOT_core_cons) + tmp11 := checkDerefVar(var_glojure_DOT_core_cons) + tmp12 := checkDerefVar(var_glojure_DOT_core_cons) + tmp13 := checkDerefVar(var_glojure_DOT_core_cons) + tmp14 := checkDerefVar(var_glojure_DOT_core_cons) + tmp15 := lang.Apply(tmp14, []any{v7, v8}) + tmp16 := lang.Apply(tmp13, []any{v6, tmp15}) + tmp17 := lang.Apply(tmp12, []any{v5, tmp16}) + tmp18 := lang.Apply(tmp11, []any{v4, tmp17}) + tmp19 := lang.Apply(tmp10, []any{v3, tmp18}) + tmp20 := lang.Apply(tmp9, []any{v2, tmp19}) + tmp21 := lang.Apply(lang.CreateLazilyPersistentVector, []any{tmp20}) + return tmp21 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_vector = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_vector.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // vector? + { + tmp0 := sym_vector_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x implements IPersistentVector", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(2), kw_line, int(174), kw_end_DASH_line, int(178))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function vector? + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := reflect.TypeOf((*lang.IPersistentVector)(nil)).Elem() + tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(178), kw_column, int(10), kw_end_DASH_line, int(178), kw_end_DASH_column, int(106))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_vector_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_vector_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // volatile! + { + tmp1 := reflect.TypeOf((*lang.Volatile)(nil)).Elem() + tmp0 := sym_volatile_BANG_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_val)), kw_doc, "Creates and returns a Volatile with an initial value of val.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(2517), kw_end_DASH_line, int(2517))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.NewVolatile, []any{v3}) + return tmp4 + }) + tmp3 := reflect.TypeOf((*lang.Volatile)(nil)).Elem() + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_volatile_BANG_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_volatile_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // volatile? + { + tmp0 := sym_volatile_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x is a volatile.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(2540), kw_end_DASH_line, int(2540))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*lang.Volatile)(nil)).Elem() + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_volatile_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_volatile_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // vreset! + { + tmp0 := sym_vreset_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_vol, sym_newval)), kw_doc, "Sets the value of volatile to newval without regard for the\n current value. Returns newval.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(2524), kw_end_DASH_line, int(2524))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "reset") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_vreset_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_vreset_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // when + { + tmp0 := sym_when.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_test, sym__AMP_, sym_body)), kw_doc, "Evaluates test. If logical true, evaluates body in an implicit do.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(11), kw_line, int(492), kw_end_DASH_line, int(492))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := checkDerefVar(var_glojure_DOT_core_cons) + tmp8 := lang.Apply(tmp7, []any{sym_do, v5}) + tmp9 := lang.Apply(tmp6, []any{sym_if, v4, tmp8}) + return tmp9 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_when = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_when.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // when-not + { + tmp0 := sym_when_DASH_not.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_test, sym__AMP_, sym_body)), kw_doc, "Evaluates test. If logical false, evaluates body in an implicit do.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(11), kw_line, int(498), kw_end_DASH_line, int(498))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := checkDerefVar(var_glojure_DOT_core_cons) + tmp8 := lang.Apply(tmp7, []any{sym_do, v5}) + tmp9 := lang.Apply(tmp6, []any{sym_if, v4, nil, tmp8}) + return tmp9 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_when_DASH_not = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_when_DASH_not.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // with-meta + { + tmp0 := sym_with_DASH_meta.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_obj, sym_m)), kw_doc, "Returns an object of the same type and value as obj, with\n map m as its metadata.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(2), kw_line, int(211), kw_end_DASH_line, int(216))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function with-meta + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(v3, "WithMeta") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("WithMeta is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(216), kw_column, int(12), kw_end_DASH_line, int(217), kw_end_DASH_column, int(32))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_with_DASH_meta = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_with_DASH_meta.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + var closed25 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + recur_loop_2021: + var tmp3 any + { // let + // let binding "temp__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + var tmp8 any + { // let + // let binding "s" + var v9 any = v6 + _ = v9 + var tmp10 any + { // let + // let binding "or__0__auto__" + tmp11 := checkDerefVar(var_glojure_DOT_core_first) + tmp12 := lang.Apply(tmp11, []any{v9}) + tmp13 := lang.Apply(v1, []any{tmp12}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + tmp15 = v14 + } else { + var tmp16 any = v1 + tmp18 := checkDerefVar(var_glojure_DOT_core_next) + tmp19 := lang.Apply(tmp18, []any{v9}) + var tmp17 any = tmp19 + v1 = tmp16 + v2 = tmp17 + goto recur_loop_2021 + } + tmp10 = tmp15 + } // end let + tmp8 = tmp10 + } // end let + tmp7 = tmp8 + } else { + } + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp0 = tmp0.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + closed25 = tmp0 + } + var closed26 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + recur_loop_2020: + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := lang.Apply(tmp5, []any{v2}) + tmp7 := lang.Apply(tmp4, []any{tmp6}) + if lang.IsTruthy(tmp7) { + tmp3 = true + } else { + var tmp8 any + tmp9 := checkDerefVar(var_glojure_DOT_core_first) + tmp10 := lang.Apply(tmp9, []any{v2}) + tmp11 := lang.Apply(v1, []any{tmp10}) + if lang.IsTruthy(tmp11) { + var tmp12 any = v1 + tmp14 := checkDerefVar(var_glojure_DOT_core_next) + tmp15 := lang.Apply(tmp14, []any{v2}) + var tmp13 any = tmp15 + v1 = tmp12 + v2 = tmp13 + goto recur_loop_2020 + } else { + var tmp16 any + if lang.IsTruthy(kw_else) { + tmp16 = false + } else { + } + tmp8 = tmp16 + } + tmp3 = tmp8 + } + return tmp3 + }) + tmp1 := reflect.TypeOf(false) + tmp0 = tmp0.WithMeta(lang.NewMap(kw_rettag, tmp1)).(lang.FnFunc) + closed26 = tmp0 + } + // agent-errors + { + tmp0 := sym_agent_DASH_errors.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a)), kw_doc, "DEPRECATED: Use 'agent-error' instead.\n Returns a sequence of the exceptions thrown during asynchronous\n actions of the agent.", kw_file, "glojure/core.glj", kw_deprecated, "1.2", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(2234), kw_end_DASH_line, int(2234))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "temp__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_agent_DASH_error) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + var tmp8 any + { // let + // let binding "e" + var v9 any = v6 + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{v9}) + tmp8 = tmp11 + } // end let + tmp7 = tmp8 + } else { + } + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_agent_DASH_errors = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_agent_DASH_errors.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // alias + { + tmp0 := sym_alias.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_alias, sym_namespace_DASH_sym)), kw_doc, "Add an alias in the current namespace to another\n namespace. Arguments are two symbols: the alias to be used, and\n the symbolic name of the target namespace. Use :as in the ns macro in preference\n to calling this directly.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(4263), kw_end_DASH_line, int(4263))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp5 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) + tmp6 := lang.Apply(tmp5, []any{v3}) + tmp7, _ := lang.FieldOrMethod(tmp4, "AddAlias") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("AddAlias is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v2, tmp6}) + return tmp8 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_alias = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_alias.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // assoc + { + tmp0 := sym_assoc.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_map, sym_key, sym_val), lang.NewVector(sym_map, sym_key, sym_val, sym__AMP_, sym_kvs)), kw_doc, "assoc[iate]. When applied to a map, returns a new map of the\n same (hashed/sorted) type, that contains the mapping of key(s) to\n val(s). When applied to a vector, returns a new vector that\n contains val at index. Note - index must be <= (count vector).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(6), kw_column, int(2), kw_line, int(181), kw_end_DASH_line, int(188))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function assoc + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6 := lang.Apply(lang.Assoc, []any{v3, v4, v5}) + return tmp6 + default: + checkArity(args, 3) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + recur_loop_1564: + var tmp7 any + { // let + // let binding "ret" + tmp8 := lang.Apply(lang.Assoc, []any{v3, v4, v5}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v6) { + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core_next) + tmp13 := lang.Apply(tmp12, []any{v6}) + if lang.IsTruthy(tmp13) { + var tmp14 any = v9 + tmp16 := checkDerefVar(var_glojure_DOT_core_first) + tmp17 := lang.Apply(tmp16, []any{v6}) + var tmp15 any = tmp17 + tmp19 := checkDerefVar(var_glojure_DOT_core_second) + tmp20 := lang.Apply(tmp19, []any{v6}) + var tmp18 any = tmp20 + tmp22 := checkDerefVar(var_glojure_DOT_core_nnext) + tmp23 := lang.Apply(tmp22, []any{v6}) + var tmp21 any = tmp23 + v3 = tmp14 + v4 = tmp15 + v5 = tmp18 + v6 = tmp21 + goto recur_loop_1564 + } else { + tmp24 := lang.Apply(lang.NewIllegalArgumentError, []any{"assoc expects even number of arguments after map/vector, found odd number"}) + panic(tmp24) + } + tmp10 = tmp11 + } else { + tmp10 = v9 + } + tmp7 = tmp10 + } // end let + return tmp7 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(189), kw_column, int(2), kw_end_DASH_line, int(198), kw_end_DASH_column, int(15))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_assoc = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_assoc.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // assoc! + { + tmp0 := sym_assoc_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll, sym_key, sym_val), lang.NewVector(sym_coll, sym_key, sym_val, sym__AMP_, sym_kvs)), kw_doc, "When applied to a transient map, adds mapping of key(s) to\n val(s). When applied to a transient vector, sets the val at index.\n Note - index must be <= (count vector). Returns coll.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(3369), kw_end_DASH_line, int(3369))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5, _ := lang.FieldOrMethod(v2, "Assoc") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Assoc is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + recur_loop_2149: + var tmp6 any + { // let + // let binding "ret" + tmp7, _ := lang.FieldOrMethod(v2, "Assoc") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Assoc is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v3, v4}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v5) { + var tmp11 any = v9 + tmp13 := checkDerefVar(var_glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v5}) + var tmp12 any = tmp14 + tmp16 := checkDerefVar(var_glojure_DOT_core_second) + tmp17 := lang.Apply(tmp16, []any{v5}) + var tmp15 any = tmp17 + tmp19 := checkDerefVar(var_glojure_DOT_core_nnext) + tmp20 := lang.Apply(tmp19, []any{v5}) + var tmp18 any = tmp20 + v2 = tmp11 + v3 = tmp12 + v4 = tmp15 + v5 = tmp18 + goto recur_loop_2149 + } else { + tmp10 = v9 + } + tmp6 = tmp10 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_assoc_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_assoc_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // associative? + { + tmp0 := sym_associative_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns true if coll implements Associative", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(6223), kw_end_DASH_line, int(6223))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := lang.Apply(tmp3, []any{nil, v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_associative_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_associative_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bases + { + tmp0 := sym_bases.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_c)), kw_doc, "Returns the immediate superclass and direct interfaces of c, if any", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(5522), kw_end_DASH_line, int(5522))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + if lang.IsTruthy(v2) { + var tmp4 any + { // let + // let binding "i" + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := lang.Apply(tmp5, []any{nil}) + var v7 any = tmp6 + _ = v7 + // let binding "s" + var v8 any = nil + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + tmp10 := checkDerefVar(var_glojure_DOT_core_cons) + tmp11 := lang.Apply(tmp10, []any{v8, v7}) + tmp9 = tmp11 + } else { + tmp9 = v7 + } + tmp4 = tmp9 + } // end let + tmp3 = tmp4 + } else { + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bases = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bases.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // boolean? + { + tmp0 := sym_boolean_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a Boolean", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(518), kw_end_DASH_line, int(518))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := lang.Apply(tmp3, []any{lang.Builtins["bool"], v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_boolean_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_boolean_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // char? + { + tmp0 := sym_char_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a Character", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(6), kw_column, int(2), kw_line, int(153), kw_end_DASH_line, int(157))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function char? + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := reflect.TypeOf(int32(0)) + tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(157), kw_column, int(8), kw_end_DASH_line, int(157), kw_end_DASH_column, int(89))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_char_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_char_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // chunked-seq? + { + tmp0 := sym_chunked_DASH_seq_QMARK_.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(708), kw_column, int(7), kw_end_DASH_line, int(708), kw_end_DASH_column, int(27), kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*lang.IChunkedSeq)(nil)).Elem() + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_chunked_DASH_seq_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_chunked_DASH_seq_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // class + { + tmp0 := sym_class.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns the Class of x", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3461), kw_end_DASH_line, int(3461))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + tmp3 = v2 + } else { + tmp6 := lang.Apply(lang.TypeOf, []any{v2}) + tmp3 = tmp6 + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_class = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_class.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // class? + { + tmp0 := sym_class_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x is an instance of Class", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(5465), kw_end_DASH_line, int(5465))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*reflect.Type)(nil)).Elem() + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_class_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_class_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // coll? + { + tmp0 := sym_coll_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x implements IPersistentCollection", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(6192), kw_end_DASH_line, int(6192))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*lang.IPersistentCollection)(nil)).Elem() + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_coll_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_coll_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // completing + { + tmp0 := sym_completing.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_cf)), kw_doc, "Takes a reducing function f of 2 args and returns a fn suitable for\n transduce by adding an arity-1 signature that calls cf (default -\n identity) on the result argument.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(6893), kw_end_DASH_line, int(6893))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_completing) + tmp4 := checkDerefVar(var_glojure_DOT_core_identity) + tmp5 := lang.Apply(tmp3, []any{v2, tmp4}) + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp5 := lang.Apply(v2, nil) + return tmp5 + case 1: + v5 := args[0] + _ = v5 + tmp6 := lang.Apply(v3, []any{v5}) + return tmp6 + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + tmp7 := lang.Apply(v2, []any{v5, v6}) + return tmp7 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6900), kw_column, int(6), kw_end_DASH_line, int(6903), kw_end_DASH_column, int(23)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_completing = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_completing.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // concat + { + tmp0 := sym_concat.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_zs)), kw_doc, "Returns a lazy seq representing the concatenation of the elements in the supplied colls.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(711), kw_end_DASH_line, int(711))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + return nil + }) + tmp3 := lang.Apply(lang.NewLazySeq, []any{tmp2}) + return tmp3 + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + return v2 + }) + tmp4 := lang.Apply(lang.NewLazySeq, []any{tmp3}) + return tmp4 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp5 any + { // let + // let binding "s" + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := lang.Apply(tmp6, []any{v2}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + var tmp10 any + tmp11 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp12 := lang.Apply(tmp11, []any{v8}) + if lang.IsTruthy(tmp12) { + tmp13 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_cons) + tmp14 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp15 := lang.Apply(tmp14, []any{v8}) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp18 := lang.Apply(tmp17, []any{v8}) + tmp19 := lang.Apply(tmp16, []any{tmp18, v3}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp19}) + tmp10 = tmp20 + } else { + tmp21 := checkDerefVar(var_glojure_DOT_core_cons) + tmp22 := checkDerefVar(var_glojure_DOT_core_first) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_concat) + tmp25 := checkDerefVar(var_glojure_DOT_core_rest) + tmp26 := lang.Apply(tmp25, []any{v8}) + tmp27 := lang.Apply(tmp24, []any{tmp26, v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp27}) + tmp10 = tmp28 + } + tmp9 = tmp10 + } else { + tmp9 = v3 + } + tmp5 = tmp9 + } // end let + return tmp5 + }) + tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) + return tmp5 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "cat" + var tmp6 lang.FnFunc + { // function cat + var v7 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp11 any + { // let + // let binding "xys" + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := lang.Apply(tmp12, []any{v8}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + var tmp16 any + tmp17 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp18 := lang.Apply(tmp17, []any{v14}) + if lang.IsTruthy(tmp18) { + tmp19 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_cons) + tmp20 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp21 := lang.Apply(tmp20, []any{v14}) + tmp22 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp23 := lang.Apply(tmp22, []any{v14}) + tmp24 := lang.Apply(v7, []any{tmp23, v9}) + tmp25 := lang.Apply(tmp19, []any{tmp21, tmp24}) + tmp16 = tmp25 + } else { + tmp26 := checkDerefVar(var_glojure_DOT_core_cons) + tmp27 := checkDerefVar(var_glojure_DOT_core_first) + tmp28 := lang.Apply(tmp27, []any{v14}) + tmp29 := checkDerefVar(var_glojure_DOT_core_rest) + tmp30 := lang.Apply(tmp29, []any{v14}) + tmp31 := lang.Apply(v7, []any{tmp30, v9}) + tmp32 := lang.Apply(tmp26, []any{tmp28, tmp31}) + tmp16 = tmp32 + } + tmp15 = tmp16 + } else { + var tmp33 any + if lang.IsTruthy(v9) { + tmp34 := checkDerefVar(var_glojure_DOT_core_first) + tmp35 := lang.Apply(tmp34, []any{v9}) + tmp36 := checkDerefVar(var_glojure_DOT_core_next) + tmp37 := lang.Apply(tmp36, []any{v9}) + tmp38 := lang.Apply(v7, []any{tmp35, tmp37}) + tmp33 = tmp38 + } else { + } + tmp15 = tmp33 + } + tmp11 = tmp15 + } // end let + return tmp11 + }) + tmp11 := lang.Apply(lang.NewLazySeq, []any{tmp10}) + return tmp11 + }) + v7 = tmp6 + _ = v7 + } + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(726), kw_column, int(16), kw_end_DASH_line, int(735), kw_end_DASH_column, int(56)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v9 any = tmp8 + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_concat) + tmp11 := lang.Apply(tmp10, []any{v2, v3}) + tmp12 := lang.Apply(v9, []any{tmp11, v4}) + tmp5 = tmp12 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_concat = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_concat.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // cond + { + tmp0 := sym_cond.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_clauses)), kw_doc, "Takes a set of test/expr pairs. It evaluates each test one at a\n time. If a test returns logical true, cond evaluates and returns\n the value of the corresponding expr and doesn't evaluate any of the\n other tests or exprs. (cond) returns nil.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(11), kw_line, int(569), kw_end_DASH_line, int(569))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + if lang.IsTruthy(v4) { + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := checkDerefVar(var_glojure_DOT_core_first) + tmp8 := lang.Apply(tmp7, []any{v4}) + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_next) + tmp11 := lang.Apply(tmp10, []any{v4}) + if lang.IsTruthy(tmp11) { + tmp12 := checkDerefVar(var_glojure_DOT_core_second) + tmp13 := lang.Apply(tmp12, []any{v4}) + tmp9 = tmp13 + } else { + tmp14 := lang.Apply(lang.NewIllegalArgumentError, []any{"cond requires an even number of forms"}) + panic(tmp14) + } + tmp15 := checkDerefVar(var_glojure_DOT_core_cons) + tmp16 := checkDerefVar(var_glojure_DOT_core_next) + tmp17 := checkDerefVar(var_glojure_DOT_core_next) + tmp18 := lang.Apply(tmp17, []any{v4}) + tmp19 := lang.Apply(tmp16, []any{tmp18}) + tmp20 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_cond, tmp19}) + tmp21 := lang.Apply(tmp6, []any{sym_if, tmp8, tmp9, tmp20}) + tmp5 = tmp21 + } else { + } + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_cond = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_cond.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // conj + { + tmp0 := sym_conj.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_coll), lang.NewVector(sym_coll, sym_x), lang.NewVector(sym_coll, sym_x, sym__AMP_, sym_xs)), kw_doc, "conj[oin]. Returns a new collection with the xs\n 'added'. (conj nil item) returns (item).\n (conj coll) returns coll. (conj) returns [].\n The 'addition' may happen at different 'places' depending\n on the concrete type.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(5), kw_column, int(2), kw_line, int(73), kw_end_DASH_line, int(81))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function conj + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp3 := lang.NewVector() + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(82), kw_column, int(13), kw_end_DASH_line, int(82), kw_end_DASH_column, int(14)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 1: + v3 := args[0] + _ = v3 + return v3 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(lang.Conj, []any{v3, v4}) + return tmp5 + default: + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + recur_loop_1550: + var tmp6 any + if lang.IsTruthy(v5) { + tmp8 := lang.Apply(lang.Conj, []any{v3, v4}) + var tmp7 any = tmp8 + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v5}) + var tmp9 any = tmp11 + tmp13 := checkDerefVar(var_glojure_DOT_core_next) + tmp14 := lang.Apply(tmp13, []any{v5}) + var tmp12 any = tmp14 + v3 = tmp7 + v4 = tmp9 + v5 = tmp12 + goto recur_loop_1550 + } else { + tmp15 := lang.Apply(lang.Conj, []any{v3, v4}) + tmp6 = tmp15 + } + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(81), kw_column, int(7), kw_end_DASH_line, int(88), kw_end_DASH_column, int(67))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_conj = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_conj.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // conj! + { + tmp0 := sym_conj_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_coll), lang.NewVector(sym_coll, sym_x)), kw_doc, "Adds x to the transient collection, and return coll. The 'addition'\n may happen at different 'places' depending on the concrete type.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3359), kw_end_DASH_line, int(3359))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp2 := checkDerefVar(var_glojure_DOT_core_transient) + tmp3 := lang.NewVector() + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3364), kw_column, int(18), kw_end_DASH_line, int(3364), kw_end_DASH_column, int(19)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp6 := lang.Apply(tmp2, []any{tmp5}) + return tmp6 + case 1: + v2 := args[0] + _ = v2 + return v2 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "Conj") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Conj is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_conj_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_conj_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // count + { + var tmp1 lang.FnFunc + { // function count__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Count}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_count.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_inline, tmp1, kw_doc, "Returns the number of items in the collection. (count nil) returns\n 0. Also works on strings, arrays, and Java Collections and Maps", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(867), kw_end_DASH_line, int(867))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.Count, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_count = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_count.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // counted? + { + tmp0 := sym_counted_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns true if coll implements count in constant time", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(6241), kw_end_DASH_line, int(6241))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*lang.Counted)(nil)).Elem() + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_counted_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_counted_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // cycle + { + tmp0 := sym_cycle.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a lazy (infinite!) sequence of repetitions of the items in coll.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(2977), kw_end_DASH_line, int(2977))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_seq) + tmp4 := lang.Apply(tmp3, []any{v2}) + tmp5 := lang.Apply(lang.NewCycle, []any{tmp4}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_cycle = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_cycle.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // dec + { + var tmp1 lang.FnFunc + { // function dec__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp15) { + tmp14 = sym_unchecked_dec + } else { + tmp14 = sym_dec + } + tmp16 := lang.Apply(tmp13, []any{tmp14}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := lang.Apply(tmp12, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp11, []any{tmp19}) + tmp21 := lang.Apply(tmp10, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_dec.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns a number one less than num. Does not auto-promote\n longs, will throw on overflow. See also: dec'", kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(1147), kw_end_DASH_line, int(1147))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Dec") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Dec is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_dec = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_dec.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // dec' + { + var tmp1 lang.FnFunc + { // function dec'__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_DecP}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_dec_TICK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns a number one less than num. Supports arbitrary precision.\n See also: dec", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1140), kw_end_DASH_line, int(1140))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "DecP") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("DecP is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_dec_TICK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_dec_TICK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // decimal? + { + tmp0 := sym_decimal_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_doc, "Returns true if n is a BigDecimal", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(3599), kw_end_DASH_line, int(3599))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*lang.BigDecimal)(nil)) + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_decimal_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_decimal_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // defmethod + { + tmp0 := sym_defmethod.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_multifn, sym_dispatch_DASH_val, sym__AMP_, sym_fn_DASH_tail)), kw_doc, "Creates and installs a new method of multimethod associated with dispatch-value. ", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(11), kw_line, int(1781), kw_end_DASH_line, int(1781))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var v6 any = lang.NewList(args[4:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp13 := lang.NewMap(kw_tag, sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT__STAR_MultiFn) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(1785), kw_column, int(27), kw_end_DASH_line, int(1785), kw_end_DASH_column, int(82)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp16 := lang.Apply(tmp12, []any{v4, tmp15}) + tmp17 := lang.Apply(tmp11, []any{tmp16}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{sym_glojure_DOT_core_SLASH_AddMethod}) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{v5}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := checkDerefVar(var_glojure_DOT_core_seq) + tmp24 := checkDerefVar(var_glojure_DOT_core_concat) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := lang.Apply(tmp25, []any{sym_glojure_DOT_core_SLASH_fn}) + tmp27 := lang.Apply(tmp24, []any{tmp26, v6}) + tmp28 := lang.Apply(tmp23, []any{tmp27}) + tmp29 := lang.Apply(tmp22, []any{tmp28}) + tmp30 := lang.Apply(tmp8, []any{tmp10, tmp17, tmp19, tmp21, tmp29}) + tmp31 := lang.Apply(tmp7, []any{tmp30}) + return tmp31 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_defmethod = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_defmethod.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // defstruct + { + tmp0 := sym_defstruct.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym__AMP_, sym_keys)), kw_doc, "Same as (def name (create-struct keys...))", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(11), kw_line, int(4044), kw_end_DASH_line, int(4044))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_def}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{v4}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_create_DASH_struct}) + tmp17 := lang.Apply(tmp14, []any{tmp16, v5}) + tmp18 := lang.Apply(tmp13, []any{tmp17}) + tmp19 := lang.Apply(tmp12, []any{tmp18}) + tmp20 := lang.Apply(tmp7, []any{tmp9, tmp11, tmp19}) + tmp21 := lang.Apply(tmp6, []any{tmp20}) + return tmp21 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_defstruct = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_defstruct.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // delay? + { + tmp0 := sym_delay_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "returns true if x is a Delay created with delay", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(748), kw_end_DASH_line, int(748))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := lang.Apply(tmp3, []any{nil, v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_delay_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_delay_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // deref + { + tmp0 := sym_deref.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ref), lang.NewVector(sym_ref, sym_timeout_DASH_ms, sym_timeout_DASH_val)), kw_doc, "Also reader macro: @ref/@agent/@var/@atom/@delay/@future/@promise. Within a transaction,\n returns the in-transaction-value of ref, else returns the\n most-recently-committed value of ref. When applied to a var, agent\n or atom, returns its current state. When applied to a delay, forces\n it if not already forced. When applied to a future, will block if\n computation not complete. When applied to a promise, will block\n until a value is delivered. The variant taking a timeout can be\n used for blocking references (futures and promises), and will return\n timeout-val if the timeout (in milliseconds) is reached before a\n value is available. See also - realized?.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(2304), kw_end_DASH_line, int(2304))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := reflect.TypeOf((*lang.IDeref)(nil)).Elem() + tmp6 := lang.Apply(tmp4, []any{tmp5, v2}) + if lang.IsTruthy(tmp6) { + tmp7, ok := lang.FieldOrMethod(v2, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "Deref"))) + } + var tmp8 any + switch reflect.TypeOf(tmp7).Kind() { + case reflect.Func: + tmp8 = lang.Apply(tmp7, nil) + default: + tmp8 = tmp7 + } + tmp3 = tmp8 + } else { + tmp9 := checkDerefVar(var_glojure_DOT_core_deref_DASH_future) + tmp10 := lang.Apply(tmp9, []any{v2}) + tmp3 = tmp10 + } + return tmp3 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp7 := reflect.TypeOf((*lang.IBlockingDeref)(nil)).Elem() + tmp8 := lang.Apply(tmp6, []any{tmp7, v2}) + if lang.IsTruthy(tmp8) { + tmp9, _ := lang.FieldOrMethod(v2, "DerefWithTimeout") + if reflect.TypeOf(tmp9).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("DerefWithTimeout is not a function"))) + } + tmp10 := lang.Apply(tmp9, []any{v3, v4}) + tmp5 = tmp10 + } else { + tmp11 := checkDerefVar(var_glojure_DOT_core_deref_DASH_future) + tmp12 := lang.Apply(tmp11, []any{v2, v3, v4}) + tmp5 = tmp12 + } + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_deref = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_deref.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // disj + { + tmp0 := sym_disj.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_set), lang.NewVector(sym_set, sym_key), lang.NewVector(sym_set, sym_key, sym__AMP_, sym_ks)), kw_doc, "disj[oin]. Returns a new set of the same (hashed/sorted) type, that\n does not contain key(s).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1514), kw_end_DASH_line, int(1514))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + return v2 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + if lang.IsTruthy(v2) { + tmp5, _ := lang.FieldOrMethod(v2, "Disjoin") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Disjoin is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3}) + tmp4 = tmp6 + } else { + } + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + recur_loop_1844: + var tmp5 any + if lang.IsTruthy(v2) { + var tmp6 any + { // let + // let binding "ret" + tmp7 := checkDerefVar(var_glojure_DOT_core_disj) + tmp8 := lang.Apply(tmp7, []any{v2, v3}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v4) { + var tmp11 any = v9 + tmp13 := checkDerefVar(var_glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v4}) + var tmp12 any = tmp14 + tmp16 := checkDerefVar(var_glojure_DOT_core_next) + tmp17 := lang.Apply(tmp16, []any{v4}) + var tmp15 any = tmp17 + v2 = tmp11 + v3 = tmp12 + v4 = tmp15 + goto recur_loop_1844 + } else { + tmp10 = v9 + } + tmp6 = tmp10 + } // end let + tmp5 = tmp6 + } else { + } + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_disj = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_disj.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // disj! + { + tmp0 := sym_disj_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_set), lang.NewVector(sym_set, sym_key), lang.NewVector(sym_set, sym_key, sym__AMP_, sym_ks)), kw_doc, "disj[oin]. Returns a transient set of the same (hashed/sorted) type, that\n does not contain key(s).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3401), kw_end_DASH_line, int(3401))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + return v2 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "Disjoin") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Disjoin is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + recur_loop_2155: + var tmp5 any + { // let + // let binding "ret" + tmp6, _ := lang.FieldOrMethod(v2, "Disjoin") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Disjoin is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v4) { + var tmp10 any = v8 + tmp12 := checkDerefVar(var_glojure_DOT_core_first) + tmp13 := lang.Apply(tmp12, []any{v4}) + var tmp11 any = tmp13 + tmp15 := checkDerefVar(var_glojure_DOT_core_next) + tmp16 := lang.Apply(tmp15, []any{v4}) + var tmp14 any = tmp16 + v2 = tmp10 + v3 = tmp11 + v4 = tmp14 + goto recur_loop_2155 + } else { + tmp9 = v8 + } + tmp5 = tmp9 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_disj_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_disj_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // dissoc + { + tmp0 := sym_dissoc.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_map), lang.NewVector(sym_map, sym_key), lang.NewVector(sym_map, sym_key, sym__AMP_, sym_ks)), kw_doc, "dissoc[iate]. Returns a new map of the same (hashed/sorted) type,\n that does not contain a mapping for key(s).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(1500), kw_end_DASH_line, int(1500))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + return v2 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(runtime.RT, "Dissoc") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Dissoc is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + return tmp5 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + recur_loop_1841: + var tmp5 any + { // let + // let binding "ret" + tmp6 := checkDerefVar(var_glojure_DOT_core_dissoc) + tmp7 := lang.Apply(tmp6, []any{v2, v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v4) { + var tmp10 any = v8 + tmp12 := checkDerefVar(var_glojure_DOT_core_first) + tmp13 := lang.Apply(tmp12, []any{v4}) + var tmp11 any = tmp13 + tmp15 := checkDerefVar(var_glojure_DOT_core_next) + tmp16 := lang.Apply(tmp15, []any{v4}) + var tmp14 any = tmp16 + v2 = tmp10 + v3 = tmp11 + v4 = tmp14 + goto recur_loop_1841 + } else { + tmp9 = v8 + } + tmp5 = tmp9 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_dissoc = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_dissoc.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // dissoc! + { + tmp0 := sym_dissoc_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_map, sym_key), lang.NewVector(sym_map, sym_key, sym__AMP_, sym_ks)), kw_doc, "Returns a transient map that doesn't contain a mapping for key(s).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(3382), kw_end_DASH_line, int(3382))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "without") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("without is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + recur_loop_2151: + var tmp5 any + { // let + // let binding "ret" + tmp6, _ := lang.FieldOrMethod(v2, "without") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("without is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v4) { + var tmp10 any = v8 + tmp12 := checkDerefVar(var_glojure_DOT_core_first) + tmp13 := lang.Apply(tmp12, []any{v4}) + var tmp11 any = tmp13 + tmp15 := checkDerefVar(var_glojure_DOT_core_next) + tmp16 := lang.Apply(tmp15, []any{v4}) + var tmp14 any = tmp16 + v2 = tmp10 + v3 = tmp11 + v4 = tmp14 + goto recur_loop_2151 + } else { + tmp9 = v8 + } + tmp5 = tmp9 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_dissoc_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_dissoc_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // dosync + { + tmp0 := sym_dosync.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_exprs)), kw_doc, "Runs the exprs (in an implicit do) in a transaction that encompasses\n exprs and any nested calls. Starts a transaction if none is already\n running on this thread. Any uncaught exception will abort the\n transaction and flow out of dosync. The exprs may be run more than\n once, but any effects on Refs will be atomic.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(11), kw_line, int(5100), kw_end_DASH_line, int(5100))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym_glojure_DOT_core_SLASH_sync}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{nil}) + tmp11 := lang.Apply(tmp6, []any{tmp8, tmp10, v4}) + tmp12 := lang.Apply(tmp5, []any{tmp11}) + return tmp12 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_dosync = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_dosync.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // double + { + var tmp1 lang.FnFunc + { // function double__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_DoubleCast}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_double.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to double", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(3493), kw_end_DASH_line, int(3493))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.AsFloat64, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_double = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_double.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // double-array + { + var tmp1 lang.FnFunc + { // function double-array__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_DoubleArray}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_unquote_DASH_splicing}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_glojure_DOT_core_SLASH_args}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + } + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_double_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_size_DASH_or_DASH_seq), lang.NewVector(sym_size, sym_init_DASH_val_DASH_or_DASH_seq)), kw_inline, tmp1, kw_doc, "Creates an array of doubles", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(5341), kw_end_DASH_line, int(5341))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "DoubleArray") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("DoubleArray is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "DoubleArrayInit") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("DoubleArrayInit is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_double_DASH_array = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_double_DASH_array.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // double? + { + tmp0 := sym_double_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a Double", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(1421), kw_end_DASH_line, int(1421))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := lang.Apply(tmp3, []any{lang.Builtins["float64"], v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_double_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_double_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // doubles + { + var tmp1 lang.FnFunc + { // function doubles + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Doubles}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_doubles.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xs)), kw_inline, tmp1, kw_doc, "Casts to double[]", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(12), kw_line, int(5402), kw_end_DASH_line, int(5402))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Doubles") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Doubles is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_doubles = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_doubles.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // drop-while + { + tmp0 := sym_drop_DASH_while.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred), lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns a lazy sequence of the items in coll starting from the\n first item for which (pred item) returns logical false. Returns a\n stateful transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(2950), kw_end_DASH_line, int(2950))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 any + { // let + // let binding "dv" + tmp6 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) + tmp7 := lang.Apply(tmp6, []any{true}) + var v8 any = tmp7 + _ = v8 + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp10 := lang.Apply(v4, nil) + return tmp10 + case 1: + v10 := args[0] + _ = v10 + tmp11 := lang.Apply(v4, []any{v10}) + return tmp11 + case 2: + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + var tmp12 any + { // let + // let binding "drop?" + tmp13 := checkDerefVar(var_glojure_DOT_core_deref) + tmp14 := lang.Apply(tmp13, []any{v8}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + var tmp17 any + { // let + // let binding "and__0__auto__" + var v18 any = v15 + _ = v18 + var tmp19 any + if lang.IsTruthy(v18) { + tmp20 := lang.Apply(v2, []any{v11}) + tmp19 = tmp20 + } else { + tmp19 = v18 + } + tmp17 = tmp19 + } // end let + if lang.IsTruthy(tmp17) { + tmp16 = v10 + } else { + tmp18 := checkDerefVar(var_glojure_DOT_core_vreset_BANG_) + tmp19 := lang.Apply(tmp18, []any{v8, nil}) + _ = tmp19 + tmp20 := lang.Apply(v4, []any{v10, v11}) + tmp16 = tmp20 + } + tmp12 = tmp16 + } // end let + return tmp12 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2959), kw_column, int(10), kw_end_DASH_line, int(2968), kw_end_DASH_column, int(42)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp5 = tmp11 + } // end let + return tmp5 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2957), kw_column, int(6), kw_end_DASH_line, int(2968), kw_end_DASH_column, int(44)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "step" + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + recur_loop_2092: + var tmp8 any + { // let + // let binding "s" + tmp9 := checkDerefVar(var_glojure_DOT_core_seq) + tmp10 := lang.Apply(tmp9, []any{v7}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + var tmp13 any + { // let + // let binding "and__0__auto__" + var v14 any = v11 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + tmp16 := checkDerefVar(var_glojure_DOT_core_first) + tmp17 := lang.Apply(tmp16, []any{v11}) + tmp18 := lang.Apply(v6, []any{tmp17}) + tmp15 = tmp18 + } else { + tmp15 = v14 + } + tmp13 = tmp15 + } // end let + if lang.IsTruthy(tmp13) { + var tmp14 any = v6 + tmp16 := checkDerefVar(var_glojure_DOT_core_rest) + tmp17 := lang.Apply(tmp16, []any{v11}) + var tmp15 any = tmp17 + v6 = tmp14 + v7 = tmp15 + goto recur_loop_2092 + } else { + tmp12 = v11 + } + tmp8 = tmp12 + } // end let + return tmp8 + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2970), kw_column, int(17), kw_end_DASH_line, int(2974), kw_end_DASH_column, int(26)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v8 any = tmp7 + _ = v8 + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp10 := lang.Apply(v8, []any{v2, v3}) + return tmp10 + }) + tmp10 := lang.Apply(lang.NewLazySeq, []any{tmp9}) + tmp4 = tmp10 + } // end let + return tmp4 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_drop_DASH_while = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_drop_DASH_while.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // empty + { + tmp0 := sym_empty.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns an empty collection of the same category as coll, or nil", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(5265), kw_end_DASH_line, int(5265))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := reflect.TypeOf((*lang.IPersistentCollection)(nil)).Elem() + tmp6 := lang.Apply(tmp4, []any{tmp5, v2}) + if lang.IsTruthy(tmp6) { + tmp7, ok := lang.FieldOrMethod(v2, "empty") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "empty"))) + } + var tmp8 any + switch reflect.TypeOf(tmp7).Kind() { + case reflect.Func: + tmp8 = lang.Apply(tmp7, nil) + default: + tmp8 = tmp7 + } + tmp3 = tmp8 + } else { + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_empty = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_empty.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // every? + { + tmp1 := reflect.TypeOf(false) + tmp0 := sym_every_QMARK_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns true if (pred x) is logical true for every x in coll, else\n false.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(2664), kw_end_DASH_line, int(2664))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + recur_loop_2020: + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := lang.Apply(tmp7, []any{v4}) + tmp9 := lang.Apply(tmp6, []any{tmp8}) + if lang.IsTruthy(tmp9) { + tmp5 = true + } else { + var tmp10 any + tmp11 := checkDerefVar(var_glojure_DOT_core_first) + tmp12 := lang.Apply(tmp11, []any{v4}) + tmp13 := lang.Apply(v3, []any{tmp12}) + if lang.IsTruthy(tmp13) { + var tmp14 any = v3 + tmp16 := checkDerefVar(var_glojure_DOT_core_next) + tmp17 := lang.Apply(tmp16, []any{v4}) + var tmp15 any = tmp17 + v3 = tmp14 + v4 = tmp15 + goto recur_loop_2020 + } else { + var tmp18 any + if lang.IsTruthy(kw_else) { + tmp18 = false + } else { + } + tmp10 = tmp18 + } + tmp5 = tmp10 + } + return tmp5 + }) + tmp3 := reflect.TypeOf(false) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_every_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_every_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ex-cause + { + tmp0 := sym_ex_DASH_cause.WithMeta(lang.NewMap(kw_tag, nil, kw_arglists, lang.NewList(lang.NewVector(sym_ex)), kw_doc, "Returns the cause of ex if ex is a Throwable.\n Otherwise returns nil.", kw_file, "glojure/core.glj", kw_added, "1.10", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(4828), kw_end_DASH_line, int(4828))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := lang.Apply(tmp4, []any{lang.Throwable, v2}) + if lang.IsTruthy(tmp5) { + tmp6, ok := lang.FieldOrMethod(v2, "getCause") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getCause"))) + } + var tmp7 any + switch reflect.TypeOf(tmp6).Kind() { + case reflect.Func: + tmp7 = lang.Apply(tmp6, nil) + default: + tmp7 = tmp6 + } + tmp3 = tmp7 + } else { + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ex_DASH_cause = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ex_DASH_cause.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ex-data + { + tmp0 := sym_ex_DASH_data.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ex)), kw_doc, "Returns exception data (a map) if ex is an IExceptionInfo.\n Otherwise returns nil.", kw_file, "glojure/core.glj", kw_added, "1.4", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4812), kw_end_DASH_line, int(4812))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := lang.Apply(tmp4, []any{nil, v2}) + if lang.IsTruthy(tmp5) { + tmp6, ok := lang.FieldOrMethod(v2, "getData") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getData"))) + } + var tmp7 any + switch reflect.TypeOf(tmp6).Kind() { + case reflect.Func: + tmp7 = lang.Apply(tmp6, nil) + default: + tmp7 = tmp6 + } + tmp3 = tmp7 + } else { + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ex_DASH_data = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ex_DASH_data.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ex-message + { + tmp0 := sym_ex_DASH_message.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ex)), kw_doc, "Returns the message attached to ex if ex is a Throwable.\n Otherwise returns nil.", kw_file, "glojure/core.glj", kw_added, "1.10", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4820), kw_end_DASH_line, int(4820))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := lang.Apply(tmp4, []any{lang.Throwable, v2}) + if lang.IsTruthy(tmp5) { + tmp6, ok := lang.FieldOrMethod(v2, "getMessage") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getMessage"))) + } + var tmp7 any + switch reflect.TypeOf(tmp6).Kind() { + case reflect.Func: + tmp7 = lang.Apply(tmp6, nil) + default: + tmp7 = tmp6 + } + tmp3 = tmp7 + } else { + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ex_DASH_message = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ex_DASH_message.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ffirst + { + tmp0 := sym_ffirst.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Same as (first (first x))", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(2), kw_line, int(98), kw_end_DASH_line, int(102))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function ffirst + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_first) + tmp5 := checkDerefVar(var_glojure_DOT_core_first) + tmp6 := lang.Apply(tmp5, []any{v3}) + tmp7 := lang.Apply(tmp4, []any{tmp6}) + return tmp7 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(102), kw_column, int(9), kw_end_DASH_line, int(102), kw_end_DASH_column, int(50))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_ffirst = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ffirst.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // filter-key + { + tmp0 := sym_filter_DASH_key.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_keyfn, sym_pred, sym_amap)), kw_static, true, kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(4115), kw_end_DASH_line, int(4117), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + { // let + // let binding "ret" + tmp6 := lang.NewMap() + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4118), kw_column, int(16), kw_end_DASH_line, int(4118), kw_end_DASH_column, int(17)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v9 any = tmp8 + _ = v9 + // let binding "es" + tmp10 := checkDerefVar(var_glojure_DOT_core_seq) + tmp11 := lang.Apply(tmp10, []any{v4}) + var v12 any = tmp11 + _ = v12 + for { + var tmp13 any + if lang.IsTruthy(v12) { + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core_first) + tmp16 := lang.Apply(tmp15, []any{v12}) + tmp17 := lang.Apply(v2, []any{tmp16}) + tmp18 := lang.Apply(v3, []any{tmp17}) + if lang.IsTruthy(tmp18) { + tmp20 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp21 := checkDerefVar(var_glojure_DOT_core_key) + tmp22 := checkDerefVar(var_glojure_DOT_core_first) + tmp23 := lang.Apply(tmp22, []any{v12}) + tmp24 := lang.Apply(tmp21, []any{tmp23}) + tmp25 := checkDerefVar(var_glojure_DOT_core_val) + tmp26 := checkDerefVar(var_glojure_DOT_core_first) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp25, []any{tmp27}) + tmp29 := lang.Apply(tmp20, []any{v9, tmp24, tmp28}) + var tmp19 any = tmp29 + tmp31 := checkDerefVar(var_glojure_DOT_core_next) + tmp32 := lang.Apply(tmp31, []any{v12}) + var tmp30 any = tmp32 + v9 = tmp19 + v12 = tmp30 + continue + } else { + var tmp33 any = v9 + tmp35 := checkDerefVar(var_glojure_DOT_core_next) + tmp36 := lang.Apply(tmp35, []any{v12}) + var tmp34 any = tmp36 + v9 = tmp33 + v12 = tmp34 + continue + } + tmp13 = tmp14 + } else { + tmp13 = v9 + } + tmp5 = tmp13 + break + } + } // end let + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_filter_DASH_key = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_filter_DASH_key.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // find-keyword + { + tmp1 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() + tmp0 := sym_find_DASH_keyword.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_name), lang.NewVector(sym_ns, sym_name)), kw_doc, "Returns a Keyword with the given namespace and name if one already\n exists. This function will not intern a new keyword. If the keyword\n has not already been interned, it will return nil. Do not use :\n in the keyword strings, it will be added automatically.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(618), kw_end_DASH_line, int(618))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + tmp4 = v3 + } else { + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp9 := lang.Apply(tmp8, []any{v3}) + if lang.IsTruthy(tmp9) { + tmp10 := lang.Apply(nil, []any{v3}) + tmp7 = tmp10 + } else { + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp13 := lang.Apply(tmp12, []any{v3}) + if lang.IsTruthy(tmp13) { + tmp14 := lang.Apply(nil, []any{v3}) + tmp11 = tmp14 + } else { + } + tmp7 = tmp11 + } + tmp4 = tmp7 + } + return tmp4 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(nil, []any{v3, v4}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp3 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_find_DASH_keyword = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_find_DASH_keyword.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // float + { + var tmp1 lang.FnFunc + { // function float__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp15) { + tmp14 = sym_uncheckedFloatCast + } else { + tmp14 = sym_floatCast + } + tmp16 := lang.Apply(tmp13, []any{tmp14}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := lang.Apply(tmp12, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp11, []any{tmp19}) + tmp21 := lang.Apply(tmp10, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_float.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to float", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3487), kw_end_DASH_line, int(3487))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.FloatCast, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_float = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_float.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // float-array + { + var tmp1 lang.FnFunc + { // function float-array__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_FloatArray}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_unquote_DASH_splicing}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_glojure_DOT_core_SLASH_args}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + } + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_float_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_size_DASH_or_DASH_seq), lang.NewVector(sym_size, sym_init_DASH_val_DASH_or_DASH_seq)), kw_inline, tmp1, kw_doc, "Creates an array of floats", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(5301), kw_end_DASH_line, int(5301))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "FloatArray") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("FloatArray is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "FloatArrayInit") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("FloatArrayInit is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_float_DASH_array = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_float_DASH_array.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // float? + { + tmp0 := sym_float_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_doc, "Returns true if n is a floating point number", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(3605), kw_end_DASH_line, int(3605))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "or__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := lang.Apply(tmp4, []any{lang.Builtins["float64"], v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + tmp7 = v6 + } else { + tmp8 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp9 := lang.Apply(tmp8, []any{lang.Builtins["float32"], v2}) + tmp7 = tmp9 + } + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_float_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_float_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // floats + { + var tmp1 lang.FnFunc + { // function floats + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Floats}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_floats.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xs)), kw_inline, tmp1, kw_doc, "Casts to float[]", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(12), kw_line, int(5392), kw_end_DASH_line, int(5392))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Floats") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Floats is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_floats = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_floats.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // fn? + { + tmp0 := sym_fn_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x implements Fn, i.e. is an object created via fn.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(6216), kw_end_DASH_line, int(6216))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*runtime.Fn)(nil)) + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_fn_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_fn_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // fnext + { + tmp0 := sym_fnext.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Same as (first (next x))", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(6), kw_column, int(2), kw_line, int(112), kw_end_DASH_line, int(116))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function fnext + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_first) + tmp5 := checkDerefVar(var_glojure_DOT_core_next) + tmp6 := lang.Apply(tmp5, []any{v3}) + tmp7 := lang.Apply(tmp4, []any{tmp6}) + return tmp7 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(116), kw_column, int(8), kw_end_DASH_line, int(116), kw_end_DASH_column, int(47))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_fnext = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_fnext.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // future? + { + tmp0 := sym_future_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x is a future", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(6532), kw_end_DASH_line, int(6532))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := lang.Apply(tmp3, []any{nil, v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_future_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_future_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // gensym + { + tmp0 := sym_gensym.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_prefix_DASH_string)), kw_doc, "Returns a new symbol with a unique name. If a prefix string is\n supplied, the name is prefix# where # is some unique number. If\n prefix is not supplied, the prefix is 'G__'.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(599), kw_end_DASH_line, int(599))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp2 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp3 := lang.Apply(tmp2, []any{"G__"}) + return tmp3 + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_str) + tmp4 := checkDerefVar(var_glojure_DOT_core_str) + tmp5, _ := lang.FieldOrMethod(runtime.RT, "NextID") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("NextID is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{}) + tmp7 := lang.Apply(tmp4, []any{tmp6}) + tmp8 := lang.Apply(tmp3, []any{v2, tmp7}) + tmp9 := lang.Apply(lang.NewSymbol, []any{tmp8}) + return tmp9 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_gensym = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_gensym.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // get + { + var tmp1 lang.FnFunc + { // function get__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym__DOT_}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_Get}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v4}) + tmp21 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp20, v5}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp12, []any{tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp9, tmp11, tmp23}) + tmp25 := lang.Apply(tmp6, []any{tmp24}) + return tmp25 + } + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_get.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_map, sym_key), lang.NewVector(sym_map, sym_key, sym_not_DASH_found)), kw_inline, tmp1, kw_doc, "Returns the value mapped to key, not-found or nil if key not present\n in associative collection, set, string, array, or ILookup instance.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2), int64(3)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(1489), kw_end_DASH_line, int(1489))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(lang.Get, []any{v3, v4}) + return tmp5 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6 := lang.Apply(lang.GetDefault, []any{v3, v4, v5}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_get = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_get.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // halt-when + { + tmp0 := sym_halt_DASH_when.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred), lang.NewVector(sym_pred, sym_retf)), kw_doc, "Returns a transducer that ends transduction when pred returns true\n for an input. When retf is supplied it must be a fn of 2 arguments -\n it will be passed the (completed) result so far and the input that\n triggered the predicate, and its return value (if it does not throw\n an exception) will be the return value of the transducer. If retf\n is not supplied, the input that triggered the predicate will be\n returned. If the predicate never returns true the transduction is\n unaffected.", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(7657), kw_end_DASH_line, int(7657))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_halt_DASH_when) + tmp4 := lang.Apply(tmp3, []any{v2, nil}) + return tmp4 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v5 := args[0] + _ = v5 + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp7 := lang.Apply(v5, nil) + return tmp7 + case 1: + v7 := args[0] + _ = v7 + var tmp8 any + var tmp9 any + { // let + // let binding "and__0__auto__" + tmp10 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp11 := lang.Apply(tmp10, []any{v7}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + tmp14 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp15 := lang.Apply(tmp14, []any{v7, kw_glojure_DOT_core_SLASH_halt}) + tmp13 = tmp15 + } else { + tmp13 = v12 + } + tmp9 = tmp13 + } // end let + if lang.IsTruthy(tmp9) { + tmp10 := lang.Apply(kw_glojure_DOT_core_SLASH_halt, []any{v7}) + tmp8 = tmp10 + } else { + tmp11 := lang.Apply(v5, []any{v7}) + tmp8 = tmp11 + } + return tmp8 + case 2: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + var tmp9 any + tmp10 := lang.Apply(v2, []any{v8}) + if lang.IsTruthy(tmp10) { + tmp11 := checkDerefVar(var_glojure_DOT_core_reduced) + var tmp12 any + if lang.IsTruthy(v3) { + tmp13 := lang.Apply(v5, []any{v7}) + tmp14 := lang.Apply(v3, []any{tmp13, v8}) + tmp12 = tmp14 + } else { + tmp12 = v8 + } + tmp15 := lang.NewMap(kw_glojure_DOT_core_SLASH_halt, tmp12) + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7678), kw_column, int(24), kw_end_DASH_line, int(7678), kw_end_DASH_column, int(72)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp9 = tmp18 + } else { + tmp19 := lang.Apply(v5, []any{v7, v8}) + tmp9 = tmp19 + } + return tmp9 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7670), kw_column, int(8), kw_end_DASH_line, int(7679), kw_end_DASH_column, int(34)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp8 + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7669), kw_column, int(6), kw_end_DASH_line, int(7679), kw_end_DASH_column, int(35)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_halt_DASH_when = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_halt_DASH_when.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ident? + { + tmp0 := sym_ident_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a symbol or keyword", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(1608), kw_end_DASH_line, int(1608))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "or__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + tmp7 = v6 + } else { + tmp8 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp9 := lang.Apply(tmp8, []any{v2}) + tmp7 = tmp9 + } + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ident_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ident_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // identical? + { + var tmp1 lang.FnFunc + { // function identical?__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_lang_DOT_Util}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_glojure_DOT_core_SLASH_identical}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{v3}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v4}) + tmp17 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp12, tmp14, tmp16}) + tmp18 := lang.Apply(tmp5, []any{tmp17}) + return tmp18 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_identical_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Tests if 2 arguments are the same object", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(768), kw_end_DASH_line, int(768))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(lang.Identical, []any{v3, v4}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_identical_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_identical_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // if-not + { + tmp0 := sym_if_DASH_not.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_test, sym_then), lang.NewVector(sym_test, sym_then, sym_else)), kw_doc, "Evaluates test. If logical false, evaluates and returns then expr, \n otherwise else expr, if supplied, else nil.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(11), kw_line, int(760), kw_end_DASH_line, int(760))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_if_DASH_not}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{v4}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v5}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{nil}) + tmp16 := lang.Apply(tmp7, []any{tmp9, tmp11, tmp13, tmp15}) + tmp17 := lang.Apply(tmp6, []any{tmp16}) + return tmp17 + case 5: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_if}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_not}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v4}) + tmp18 := lang.Apply(tmp13, []any{tmp15, tmp17}) + tmp19 := lang.Apply(tmp12, []any{tmp18}) + tmp20 := lang.Apply(tmp11, []any{tmp19}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v5}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := lang.Apply(tmp23, []any{v6}) + tmp25 := lang.Apply(tmp8, []any{tmp10, tmp20, tmp22, tmp24}) + tmp26 := lang.Apply(tmp7, []any{tmp25}) + return tmp26 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_if_DASH_not = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_if_DASH_not.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ifn? + { + tmp0 := sym_ifn_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x implements IFn. Note that many data structures\n (e.g. sets and maps) implement IFn", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(6209), kw_end_DASH_line, int(6209))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := lang.Apply(tmp3, []any{nil, v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ifn_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ifn_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // inc + { + var tmp1 lang.FnFunc + { // function inc__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp15) { + tmp14 = sym_unchecked_inc + } else { + tmp14 = sym_inc + } + tmp16 := lang.Apply(tmp13, []any{tmp14}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := lang.Apply(tmp12, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp11, []any{tmp19}) + tmp21 := lang.Apply(tmp10, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_inc.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns a number one greater than num. Does not auto-promote\n longs, will throw on overflow. See also: inc'", kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(915), kw_end_DASH_line, int(915))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Inc") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Inc is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_inc = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_inc.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // inc' + { + var tmp1 lang.FnFunc + { // function inc'__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_IncP}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_inc_TICK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns a number one greater than num. Supports arbitrary precision.\n See also: inc", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(908), kw_end_DASH_line, int(908))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "IncP") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("IncP is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_inc_TICK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_inc_TICK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // indexed? + { + tmp0 := sym_indexed_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Return true if coll implements Indexed, indicating efficient lookup by index", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(6263), kw_end_DASH_line, int(6263))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := lang.Apply(tmp3, []any{nil, v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_indexed_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_indexed_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // infinite? + { + var tmp1 lang.FnFunc + { // function infinite?__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym_Double_SLASH_isInfinite}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{v3}) + tmp10 := lang.Apply(tmp5, []any{tmp7, tmp9}) + tmp11 := lang.Apply(tmp4, []any{tmp10}) + return tmp11 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_infinite_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_num)), kw_inline, tmp1, kw_doc, "Returns true if num is negative or positive infinity, else false", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1)})), kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(7977), kw_end_DASH_line, int(7977))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(nil, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_infinite_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_infinite_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // int + { + var tmp1 lang.FnFunc + { // function int__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp15) { + tmp14 = sym_uncheckedIntCast + } else { + tmp14 = sym_intCast + } + tmp16 := lang.Apply(tmp13, []any{tmp14}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := lang.Apply(tmp12, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp11, []any{tmp19}) + tmp21 := lang.Apply(tmp10, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to int", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(875), kw_end_DASH_line, int(875))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(runtime.RT, "IntCast") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("IntCast is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_int = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_int.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // int-array + { + var tmp1 lang.FnFunc + { // function int-array__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_IntArray}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_unquote_DASH_splicing}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_glojure_DOT_core_SLASH_args}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + } + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_int_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_size_DASH_or_DASH_seq), lang.NewVector(sym_size, sym_init_DASH_val_DASH_or_DASH_seq)), kw_inline, tmp1, kw_doc, "Creates an array of ints", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(5356), kw_end_DASH_line, int(5356))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "IntArray") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("IntArray is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "IntArrayInit") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("IntArrayInit is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_int_DASH_array = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_int_DASH_array.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // intern + { + tmp0 := sym_intern.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns, sym_name), lang.NewVector(sym_ns, sym_name, sym_val)), kw_doc, "Finds or creates a var named by the symbol name in the namespace\n ns (which can be a symbol or a namespace), setting its root binding\n to val if supplied. The namespace must exist. The var will adopt any\n metadata from the name symbol. Returns the var.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(6311), kw_end_DASH_line, int(6311))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "v" + tmp5 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) + tmp6 := lang.Apply(tmp5, []any{v2}) + tmp7 := lang.Apply(nil, []any{tmp6, v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_meta) + tmp11 := lang.Apply(tmp10, []any{v3}) + if lang.IsTruthy(tmp11) { + tmp12 := checkDerefVar(var_glojure_DOT_core_meta) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14, _ := lang.FieldOrMethod(v8, "setMeta") + if reflect.TypeOf(tmp14).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMeta is not a function"))) + } + tmp15 := lang.Apply(tmp14, []any{tmp13}) + tmp9 = tmp15 + } else { + } + _ = tmp9 + tmp4 = v8 + } // end let + return tmp4 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + { // let + // let binding "v" + tmp6 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) + tmp7 := lang.Apply(tmp6, []any{v2}) + tmp8 := lang.Apply(nil, []any{tmp7, v3, v4}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + tmp11 := checkDerefVar(var_glojure_DOT_core_meta) + tmp12 := lang.Apply(tmp11, []any{v3}) + if lang.IsTruthy(tmp12) { + tmp13 := checkDerefVar(var_glojure_DOT_core_meta) + tmp14 := lang.Apply(tmp13, []any{v3}) + tmp15, _ := lang.FieldOrMethod(v9, "setMeta") + if reflect.TypeOf(tmp15).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMeta is not a function"))) + } + tmp16 := lang.Apply(tmp15, []any{tmp14}) + tmp10 = tmp16 + } else { + } + _ = tmp10 + tmp5 = v9 + } // end let + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_intern = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_intern.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // into-array + { + tmp0 := sym_into_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_aseq), lang.NewVector(sym_type, sym_aseq)), kw_doc, "Returns an array with components set to the values in aseq. The array's\n component type is type if provided, or the type of the first value in\n aseq if present, or Object. All values in aseq must be compatible with\n the component type. Class objects for the primitive types can be obtained\n using, e.g., Integer/TYPE.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(3444), kw_end_DASH_line, int(3444))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_seq) + tmp4 := lang.Apply(tmp3, []any{v2}) + tmp5 := lang.Apply(nil, []any{tmp4}) + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := lang.Apply(tmp4, []any{v3}) + tmp6 := lang.Apply(nil, []any{v2, tmp5}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_into_DASH_array = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_into_DASH_array.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ints + { + var tmp1 lang.FnFunc + { // function ints + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Ints}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_ints.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xs)), kw_inline, tmp1, kw_doc, "Casts to int[]", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(12), kw_line, int(5397), kw_end_DASH_line, int(5397))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Ints") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Ints is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ints = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ints.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // io! + { + tmp0 := sym_io_BANG_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_body)), kw_doc, "If an io! block occurs in a transaction, throws an\n IllegalStateException, else runs body in an implicit do. If the\n first expression in body is a literal string, will use that as the\n exception message.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(11), kw_line, int(2504), kw_end_DASH_line, int(2504))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "message" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp8 := checkDerefVar(var_glojure_DOT_core_first) + tmp9 := lang.Apply(tmp8, []any{v4}) + tmp10 := lang.Apply(tmp7, []any{tmp9}) + if lang.IsTruthy(tmp10) { + tmp11 := checkDerefVar(var_glojure_DOT_core_first) + tmp12 := lang.Apply(tmp11, []any{v4}) + tmp6 = tmp12 + } else { + } + var v13 any = tmp6 + _ = v13 + // let binding "body" + var tmp14 any + if lang.IsTruthy(v13) { + tmp15 := checkDerefVar(var_glojure_DOT_core_next) + tmp16 := lang.Apply(tmp15, []any{v4}) + tmp14 = tmp16 + } else { + tmp14 = v4 + } + var v17 any = tmp14 + _ = v17 + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{sym_if}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := checkDerefVar(var_glojure_DOT_core_seq) + tmp24 := checkDerefVar(var_glojure_DOT_core_concat) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := lang.Apply(tmp25, []any{sym_glojure_DOT_lang_DOT_LockingTransaction_SLASH_isRunning}) + tmp27 := lang.Apply(tmp24, []any{tmp26}) + tmp28 := lang.Apply(tmp23, []any{tmp27}) + tmp29 := lang.Apply(tmp22, []any{tmp28}) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := checkDerefVar(var_glojure_DOT_core_seq) + tmp32 := checkDerefVar(var_glojure_DOT_core_concat) + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{sym_throw}) + tmp35 := checkDerefVar(var_glojure_DOT_core_list) + tmp36 := checkDerefVar(var_glojure_DOT_core_seq) + tmp37 := checkDerefVar(var_glojure_DOT_core_concat) + tmp38 := checkDerefVar(var_glojure_DOT_core_list) + tmp39 := lang.Apply(tmp38, []any{sym_new}) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{sym_glojure_DOT_core_SLASH_IllegalStateException}) + tmp42 := checkDerefVar(var_glojure_DOT_core_list) + var tmp43 any + { // let + // let binding "or__0__auto__" + var v44 any = v13 + _ = v44 + var tmp45 any + if lang.IsTruthy(v44) { + tmp45 = v44 + } else { + tmp45 = "I/O in transaction" + } + tmp43 = tmp45 + } // end let + tmp44 := lang.Apply(tmp42, []any{tmp43}) + tmp45 := lang.Apply(tmp37, []any{tmp39, tmp41, tmp44}) + tmp46 := lang.Apply(tmp36, []any{tmp45}) + tmp47 := lang.Apply(tmp35, []any{tmp46}) + tmp48 := lang.Apply(tmp32, []any{tmp34, tmp47}) + tmp49 := lang.Apply(tmp31, []any{tmp48}) + tmp50 := lang.Apply(tmp30, []any{tmp49}) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := checkDerefVar(var_glojure_DOT_core_seq) + tmp53 := checkDerefVar(var_glojure_DOT_core_concat) + tmp54 := checkDerefVar(var_glojure_DOT_core_list) + tmp55 := lang.Apply(tmp54, []any{sym_do}) + tmp56 := lang.Apply(tmp53, []any{tmp55, v17}) + tmp57 := lang.Apply(tmp52, []any{tmp56}) + tmp58 := lang.Apply(tmp51, []any{tmp57}) + tmp59 := lang.Apply(tmp19, []any{tmp21, tmp29, tmp50, tmp58}) + tmp60 := lang.Apply(tmp18, []any{tmp59}) + tmp5 = tmp60 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_io_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_io_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // keep-indexed + { + tmp0 := sym_keep_DASH_indexed.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_coll)), kw_doc, "Returns a lazy sequence of the non-nil results of (f index item). Note,\n this means false return values will be included. f must be free of\n side-effects. Returns a stateful transducer when no collection is\n provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(7372), kw_end_DASH_line, int(7372))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 any + { // let + // let binding "iv" + tmp6 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) + tmp7 := lang.Apply(tmp6, []any{int64(-1)}) + var v8 any = tmp7 + _ = v8 + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp10 := lang.Apply(v4, nil) + return tmp10 + case 1: + v10 := args[0] + _ = v10 + tmp11 := lang.Apply(v4, []any{v10}) + return tmp11 + case 2: + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + var tmp12 any + { // let + // let binding "i" + tmp13 := checkDerefVar(var_glojure_DOT_core_inc) + tmp14, ok := lang.FieldOrMethod(v8, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "Deref"))) + } + var tmp15 any + switch reflect.TypeOf(tmp14).Kind() { + case reflect.Func: + tmp15 = lang.Apply(tmp14, nil) + default: + tmp15 = tmp14 + } + tmp16 := lang.Apply(tmp13, []any{tmp15}) + tmp17, _ := lang.FieldOrMethod(v8, "reset") + if reflect.TypeOf(tmp17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) + } + tmp18 := lang.Apply(tmp17, []any{tmp16}) + var v19 any = tmp18 + _ = v19 + // let binding "v" + tmp20 := lang.Apply(v2, []any{v19, v11}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + tmp23 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp24 := lang.Apply(tmp23, []any{v21}) + if lang.IsTruthy(tmp24) { + tmp22 = v10 + } else { + tmp25 := lang.Apply(v4, []any{v10, v21}) + tmp22 = tmp25 + } + tmp12 = tmp22 + } // end let + return tmp12 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7382), kw_column, int(8), kw_end_DASH_line, int(7390), kw_end_DASH_column, int(33)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp5 = tmp11 + } // end let + return tmp5 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7380), kw_column, int(4), kw_end_DASH_line, int(7390), kw_end_DASH_column, int(35)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + return nil + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_keep_DASH_indexed = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_keep_DASH_indexed.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // keyword + { + tmp1 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() + tmp0 := sym_keyword.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_name), lang.NewVector(sym_ns, sym_name)), kw_doc, "Returns a Keyword with the given namespace and name. Do not use :\n in the keyword strings, it will be added automatically.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(609), kw_end_DASH_line, int(609))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + tmp4 = v3 + } else { + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp9 := lang.Apply(tmp8, []any{v3}) + if lang.IsTruthy(tmp9) { + tmp10 := lang.Apply(lang.InternKeywordSymbol, []any{v3}) + tmp7 = tmp10 + } else { + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp13 := lang.Apply(tmp12, []any{v3}) + if lang.IsTruthy(tmp13) { + tmp14 := lang.Apply(lang.InternKeywordString, []any{v3}) + tmp11 = tmp14 + } else { + } + tmp7 = tmp11 + } + tmp4 = tmp7 + } + return tmp4 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(lang.InternKeyword, []any{v3, v4}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp3 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_keyword = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_keyword.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // last + { + tmp0 := sym_last.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Return the last item in coll, in linear time", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(5), kw_column, int(2), kw_line, int(262), kw_end_DASH_line, int(266))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function last + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + recur_loop_1572: + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_next) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + tmp8 := checkDerefVar(var_glojure_DOT_core_next) + tmp9 := lang.Apply(tmp8, []any{v3}) + var tmp7 any = tmp9 + v3 = tmp7 + goto recur_loop_1572 + } else { + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v3}) + tmp4 = tmp11 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(266), kw_column, int(7), kw_end_DASH_line, int(269), kw_end_DASH_column, int(21))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_last = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_last.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // libspec? + { + tmp0 := sym_libspec_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x is a libspec", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(8), kw_line, int(5848), kw_end_DASH_line, int(5848), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "or__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + tmp7 = v6 + } else { + var tmp8 any + { // let + // let binding "and__0__auto__" + tmp9 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp10 := lang.Apply(tmp9, []any{v2}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + var tmp13 any + { // let + // let binding "or__0__auto__" + tmp14 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp15 := checkDerefVar(var_glojure_DOT_core_second) + tmp16 := lang.Apply(tmp15, []any{v2}) + tmp17 := lang.Apply(tmp14, []any{tmp16}) + var v18 any = tmp17 + _ = v18 + var tmp19 any + if lang.IsTruthy(v18) { + tmp19 = v18 + } else { + tmp20 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp21 := checkDerefVar(var_glojure_DOT_core_second) + tmp22 := lang.Apply(tmp21, []any{v2}) + tmp23 := lang.Apply(tmp20, []any{tmp22}) + tmp19 = tmp23 + } + tmp13 = tmp19 + } // end let + tmp12 = tmp13 + } else { + tmp12 = v11 + } + tmp8 = tmp12 + } // end let + tmp7 = tmp8 + } + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_libspec_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_libspec_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // list* + { + tmp0 := sym_list_STAR_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_args), lang.NewVector(sym_a, sym_args), lang.NewVector(sym_a, sym_b, sym_args), lang.NewVector(sym_a, sym_b, sym_c, sym_args), lang.NewVector(sym_a, sym_b, sym_c, sym_d, sym__AMP_, sym_more)), kw_doc, "Creates a new seq containing the items prepended to the rest, the\n last of which will be treated as a sequence.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(641), kw_end_DASH_line, int(641))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_seq) + tmp4 := lang.Apply(tmp3, []any{v2}) + return tmp4 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_cons) + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + return tmp5 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_cons) + tmp6 := checkDerefVar(var_glojure_DOT_core_cons) + tmp7 := lang.Apply(tmp6, []any{v3, v4}) + tmp8 := lang.Apply(tmp5, []any{v2, tmp7}) + return tmp8 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_cons) + tmp7 := checkDerefVar(var_glojure_DOT_core_cons) + tmp8 := checkDerefVar(var_glojure_DOT_core_cons) + tmp9 := lang.Apply(tmp8, []any{v4, v5}) + tmp10 := lang.Apply(tmp7, []any{v3, tmp9}) + tmp11 := lang.Apply(tmp6, []any{v2, tmp10}) + return tmp11 + default: + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var v6 any = lang.NewList(args[4:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_cons) + tmp8 := checkDerefVar(var_glojure_DOT_core_cons) + tmp9 := checkDerefVar(var_glojure_DOT_core_cons) + tmp10 := checkDerefVar(var_glojure_DOT_core_cons) + tmp11 := checkDerefVar(var_glojure_DOT_core_spread) + tmp12 := lang.Apply(tmp11, []any{v6}) + tmp13 := lang.Apply(tmp10, []any{v5, tmp12}) + tmp14 := lang.Apply(tmp9, []any{v4, tmp13}) + tmp15 := lang.Apply(tmp8, []any{v3, tmp14}) + tmp16 := lang.Apply(tmp7, []any{v2, tmp15}) + return tmp16 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_list_STAR_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_list_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // loaded-libs + { + tmp0 := sym_loaded_DASH_libs.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Returns a sorted set of symbols naming the currently loaded libs", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(6090), kw_end_DASH_line, int(6090))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp2 := checkDerefVar(var_glojure_DOT_core_deref) + tmp3 := checkDerefVar(var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_) + tmp4 := lang.Apply(tmp2, []any{tmp3}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_loaded_DASH_libs = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_loaded_DASH_libs.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // long + { + var tmp1 lang.FnFunc + { // function long__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_LongCast}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_long.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to long", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3481), kw_end_DASH_line, int(3481))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.LongCast, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_long = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_long.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // long-array + { + var tmp1 lang.FnFunc + { // function long-array__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_LongArray}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_unquote_DASH_splicing}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_glojure_DOT_core_SLASH_args}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + } + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_long_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_size_DASH_or_DASH_seq), lang.NewVector(sym_size, sym_init_DASH_val_DASH_or_DASH_seq)), kw_inline, tmp1, kw_doc, "Creates an array of longs", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(5364), kw_end_DASH_line, int(5364))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "LongArray") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("LongArray is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "LongArrayInit") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("LongArrayInit is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_long_DASH_array = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_long_DASH_array.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // longs + { + var tmp1 lang.FnFunc + { // function longs + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Longs}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_longs.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xs)), kw_inline, tmp1, kw_doc, "Casts to long[]", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(12), kw_line, int(5407), kw_end_DASH_line, int(5407))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Longs") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Longs is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_longs = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_longs.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // macroexpand + { + tmp0 := sym_macroexpand.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_form)), kw_doc, "Repeatedly calls macroexpand-1 on form until it no longer\n represents a macro form, then returns it. Note neither\n macroexpand-1 nor macroexpand expand macros in subforms.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(4025), kw_end_DASH_line, int(4025))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "ex" + tmp4 := checkDerefVar(var_glojure_DOT_core_macroexpand_DASH_1) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core_identical_QMARK_) + tmp9 := lang.Apply(tmp8, []any{v6, v2}) + if lang.IsTruthy(tmp9) { + tmp7 = v2 + } else { + tmp10 := checkDerefVar(var_glojure_DOT_core_macroexpand) + tmp11 := lang.Apply(tmp10, []any{v6}) + tmp7 = tmp11 + } + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_macroexpand = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_macroexpand.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // map-indexed + { + tmp0 := sym_map_DASH_indexed.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_coll)), kw_doc, "Returns a lazy sequence consisting of the result of applying f to 0\n and the first item of coll, followed by applying f to 1 and the second\n item in coll, etc, until coll is exhausted. Thus function f should\n accept 2 arguments, index and item. Returns a stateful transducer when\n no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(7309), kw_end_DASH_line, int(7309))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 any + { // let + // let binding "i" + tmp6 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) + tmp7 := lang.Apply(tmp6, []any{int64(-1)}) + var v8 any = tmp7 + _ = v8 + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp10 := lang.Apply(v4, nil) + return tmp10 + case 1: + v10 := args[0] + _ = v10 + tmp11 := lang.Apply(v4, []any{v10}) + return tmp11 + case 2: + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_inc) + tmp13, ok := lang.FieldOrMethod(v8, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "Deref"))) + } + var tmp14 any + switch reflect.TypeOf(tmp13).Kind() { + case reflect.Func: + tmp14 = lang.Apply(tmp13, nil) + default: + tmp14 = tmp13 + } + tmp15 := lang.Apply(tmp12, []any{tmp14}) + tmp16, _ := lang.FieldOrMethod(v8, "reset") + if reflect.TypeOf(tmp16).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) + } + tmp17 := lang.Apply(tmp16, []any{tmp15}) + tmp18 := lang.Apply(v2, []any{tmp17, v11}) + tmp19 := lang.Apply(v4, []any{v10, tmp18}) + return tmp19 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7320), kw_column, int(8), kw_end_DASH_line, int(7324), kw_end_DASH_column, int(48)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp5 = tmp11 + } // end let + return tmp5 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7318), kw_column, int(4), kw_end_DASH_line, int(7324), kw_end_DASH_column, int(50)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + return nil + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_map_DASH_indexed = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_map_DASH_indexed.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // maybe-destructured + { + tmp0 := sym_maybe_DASH_destructured.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(4514), kw_column, int(7), kw_end_DASH_line, int(4515), kw_end_DASH_column, int(20), kw_arglists, lang.NewList(lang.NewVector(sym_params, sym_body)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + tmp6 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp7 := lang.Apply(tmp5, []any{tmp6, v2}) + if lang.IsTruthy(tmp7) { + tmp8 := checkDerefVar(var_glojure_DOT_core_cons) + tmp9 := lang.Apply(tmp8, []any{v2, v3}) + tmp4 = tmp9 + } else { + var tmp10 any + { // let + // let binding "params" + var v11 any = v2 + _ = v11 + // let binding "new-params" + tmp12 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp13 := lang.NewVector() + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4520), kw_column, int(34), kw_end_DASH_line, int(4520), kw_end_DASH_column, int(35)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp16 := checkDerefVar(var_glojure_DOT_core_meta) + tmp17 := lang.Apply(tmp16, []any{v11}) + tmp18 := lang.Apply(tmp12, []any{tmp15, tmp17}) + var v19 any = tmp18 + _ = v19 + // let binding "lets" + tmp20 := lang.NewVector() + tmp21 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4521), kw_column, int(17), kw_end_DASH_line, int(4521), kw_end_DASH_column, int(18)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v23 any = tmp22 + _ = v23 + for { + var tmp24 any + if lang.IsTruthy(v11) { + var tmp25 any + tmp26 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp27 := checkDerefVar(var_glojure_DOT_core_first) + tmp28 := lang.Apply(tmp27, []any{v11}) + tmp29 := lang.Apply(tmp26, []any{tmp28}) + if lang.IsTruthy(tmp29) { + tmp31 := checkDerefVar(var_glojure_DOT_core_next) + tmp32 := lang.Apply(tmp31, []any{v11}) + var tmp30 any = tmp32 + tmp34 := checkDerefVar(var_glojure_DOT_core_conj) + tmp35 := checkDerefVar(var_glojure_DOT_core_first) + tmp36 := lang.Apply(tmp35, []any{v11}) + tmp37 := lang.Apply(tmp34, []any{v19, tmp36}) + var tmp33 any = tmp37 + var tmp38 any = v23 + v11 = tmp30 + v19 = tmp33 + v23 = tmp38 + continue + } else { + var tmp39 any + { // let + // let binding "gparam" + tmp40 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp41 := lang.Apply(tmp40, []any{"p__"}) + var v42 any = tmp41 + _ = v42 + tmp44 := checkDerefVar(var_glojure_DOT_core_next) + tmp45 := lang.Apply(tmp44, []any{v11}) + var tmp43 any = tmp45 + tmp47 := checkDerefVar(var_glojure_DOT_core_conj) + tmp48 := lang.Apply(tmp47, []any{v19, v42}) + var tmp46 any = tmp48 + tmp50 := checkDerefVar(var_glojure_DOT_core_conj) + tmp51 := checkDerefVar(var_glojure_DOT_core_conj) + tmp52 := checkDerefVar(var_glojure_DOT_core_first) + tmp53 := lang.Apply(tmp52, []any{v11}) + tmp54 := lang.Apply(tmp51, []any{v23, tmp53}) + tmp55 := lang.Apply(tmp50, []any{tmp54, v42}) + var tmp49 any = tmp55 + v11 = tmp43 + v19 = tmp46 + v23 = tmp49 + continue + } // end let + tmp25 = tmp39 + } + tmp24 = tmp25 + } else { + tmp40 := checkDerefVar(var_glojure_DOT_core_seq) + tmp41 := checkDerefVar(var_glojure_DOT_core_concat) + tmp42 := checkDerefVar(var_glojure_DOT_core_list) + tmp43 := lang.Apply(tmp42, []any{v19}) + tmp44 := checkDerefVar(var_glojure_DOT_core_list) + tmp45 := checkDerefVar(var_glojure_DOT_core_seq) + tmp46 := checkDerefVar(var_glojure_DOT_core_concat) + tmp47 := checkDerefVar(var_glojure_DOT_core_list) + tmp48 := lang.Apply(tmp47, []any{sym_glojure_DOT_core_SLASH_let}) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) + tmp50 := lang.Apply(tmp49, []any{v23}) + tmp51 := lang.Apply(tmp46, []any{tmp48, tmp50, v3}) + tmp52 := lang.Apply(tmp45, []any{tmp51}) + tmp53 := lang.Apply(tmp44, []any{tmp52}) + tmp54 := lang.Apply(tmp41, []any{tmp43, tmp53}) + tmp55 := lang.Apply(tmp40, []any{tmp54}) + tmp24 = tmp55 + } + tmp10 = tmp24 + break + } + } // end let + tmp4 = tmp10 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_maybe_DASH_destructured = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_maybe_DASH_destructured.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // name + { + tmp1 := reflect.TypeOf("") + tmp0 := sym_name.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns the name String of a string, symbol or keyword.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1585), kw_end_DASH_line, int(1585))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + tmp4 = v3 + } else { + tmp7, _ := lang.FieldOrMethod(v3, "Name") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Name is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{}) + tmp4 = tmp8 + } + return tmp4 + }) + tmp3 := reflect.TypeOf("") + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_name = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_name.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // neg? + { + var tmp1 lang.FnFunc + { // function neg?__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_IsNeg}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_neg_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_num)), kw_inline, tmp1, kw_doc, "Returns true if num is less than zero, else false", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1259), kw_end_DASH_line, int(1259))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "IsNeg") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("IsNeg is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_neg_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_neg_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // not-empty + { + tmp0 := sym_not_DASH_empty.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "If coll is empty, returns nil, else coll", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(5516), kw_end_DASH_line, int(5516))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + tmp3 = v2 + } else { + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_not_DASH_empty = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_not_DASH_empty.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ns-aliases + { + tmp0 := sym_ns_DASH_aliases.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns)), kw_doc, "Returns a map of the aliases for the namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4273), kw_end_DASH_line, int(4273))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) + tmp4 := lang.Apply(tmp3, []any{v2}) + tmp5, ok := lang.FieldOrMethod(tmp4, "getAliases") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp4, "getAliases"))) + } + var tmp6 any + switch reflect.TypeOf(tmp5).Kind() { + case reflect.Func: + tmp6 = lang.Apply(tmp5, nil) + default: + tmp6 = tmp5 + } + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ns_DASH_aliases = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ns_DASH_aliases.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ns-map + { + tmp0 := sym_ns_DASH_map.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns)), kw_doc, "Returns a map of all the mappings for the namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(4170), kw_end_DASH_line, int(4170))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) + tmp4 := lang.Apply(tmp3, []any{v2}) + tmp5, ok := lang.FieldOrMethod(tmp4, "Mappings") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp4, "Mappings"))) + } + var tmp6 any + switch reflect.TypeOf(tmp5).Kind() { + case reflect.Func: + tmp6 = lang.Apply(tmp5, nil) + default: + tmp6 = tmp5 + } + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ns_DASH_map = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ns_DASH_map.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ns-name + { + tmp0 := sym_ns_DASH_name.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns)), kw_doc, "Returns the name of the namespace, a symbol.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4163), kw_end_DASH_line, int(4163))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) + tmp4 := lang.Apply(tmp3, []any{v2}) + tmp5, ok := lang.FieldOrMethod(tmp4, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp4, "Name"))) + } + var tmp6 any + switch reflect.TypeOf(tmp5).Kind() { + case reflect.Func: + tmp6 = lang.Apply(tmp5, nil) + default: + tmp6 = tmp5 + } + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ns_DASH_name = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ns_DASH_name.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ns-resolve + { + tmp0 := sym_ns_DASH_resolve.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns, sym_sym), lang.NewVector(sym_ns, sym_env, sym_sym)), kw_doc, "Returns the var or Class to which a symbol will be resolved in the\n namespace (unless found in the environment), else nil. Note that\n if the symbol is fully qualified, the var/Class to which it resolves\n need not be present in the namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4358), kw_end_DASH_line, int(4358))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_ns_DASH_resolve) + tmp5 := lang.Apply(tmp4, []any{v2, nil, v3}) + return tmp5 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp7 := lang.Apply(tmp6, []any{v3, v4}) + if lang.IsTruthy(tmp7) { + } else { + tmp8 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) + tmp9 := lang.Apply(tmp8, []any{v2}) + tmp10, _ := lang.FieldOrMethod(runtime.Compiler, "maybeResolveIn") + if reflect.TypeOf(tmp10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("maybeResolveIn is not a function"))) + } + tmp11 := lang.Apply(tmp10, []any{tmp9, v4}) + tmp5 = tmp11 + } + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ns_DASH_resolve = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ns_DASH_resolve.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ns-unalias + { + tmp0 := sym_ns_DASH_unalias.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns, sym_sym)), kw_doc, "Removes the alias for the symbol from the namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4280), kw_end_DASH_line, int(4280))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) + tmp5 := lang.Apply(tmp4, []any{v2}) + tmp6, _ := lang.FieldOrMethod(tmp5, "removeAlias") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("removeAlias is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v3}) + return tmp7 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ns_DASH_unalias = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ns_DASH_unalias.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ns-unmap + { + tmp0 := sym_ns_DASH_unmap.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns, sym_sym)), kw_doc, "Removes the mappings for the symbol from the namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(4177), kw_end_DASH_line, int(4177))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) + tmp5 := lang.Apply(tmp4, []any{v2}) + tmp6, _ := lang.FieldOrMethod(tmp5, "unmap") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unmap is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v3}) + return tmp7 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ns_DASH_unmap = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ns_DASH_unmap.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // nth + { + var tmp1 lang.FnFunc + { // function nth__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym__DOT_}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_Nth}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{sym_glojure_DOT_core_SLASH_unquote}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{sym_glojure_DOT_core_SLASH_c}) + tmp24 := lang.Apply(tmp19, []any{tmp21, tmp23}) + tmp25 := lang.Apply(tmp18, []any{tmp24}) + tmp26 := lang.Apply(tmp17, []any{tmp25}) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := checkDerefVar(var_glojure_DOT_core_seq) + tmp29 := checkDerefVar(var_glojure_DOT_core_concat) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := lang.Apply(tmp30, []any{sym_glojure_DOT_core_SLASH_unquote}) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := lang.Apply(tmp32, []any{sym_glojure_DOT_core_SLASH_i}) + tmp34 := lang.Apply(tmp29, []any{tmp31, tmp33}) + tmp35 := lang.Apply(tmp28, []any{tmp34}) + tmp36 := lang.Apply(tmp27, []any{tmp35}) + tmp37 := checkDerefVar(var_glojure_DOT_core_list) + tmp38 := checkDerefVar(var_glojure_DOT_core_seq) + tmp39 := checkDerefVar(var_glojure_DOT_core_concat) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{sym_glojure_DOT_core_SLASH_unquote_DASH_splicing}) + tmp42 := checkDerefVar(var_glojure_DOT_core_list) + tmp43 := lang.Apply(tmp42, []any{sym_glojure_DOT_core_SLASH_nf}) + tmp44 := lang.Apply(tmp39, []any{tmp41, tmp43}) + tmp45 := lang.Apply(tmp38, []any{tmp44}) + tmp46 := lang.Apply(tmp37, []any{tmp45}) + tmp47 := lang.Apply(tmp14, []any{tmp16, tmp26, tmp36, tmp46}) + tmp48 := lang.Apply(tmp13, []any{tmp47}) + tmp49 := lang.Apply(tmp12, []any{tmp48}) + tmp50 := lang.Apply(tmp7, []any{tmp9, tmp11, tmp49}) + tmp51 := lang.Apply(tmp6, []any{tmp50}) + return tmp51 + } + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_nth.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll, sym_index), lang.NewVector(sym_coll, sym_index, sym_not_DASH_found)), kw_inline, tmp1, kw_doc, "Returns the value at the index. get returns nil if index out of\n bounds, nth throws an exception unless not-found is supplied. nth\n also works for strings, Java arrays, regex Matchers and Lists, and,\n in O(n) time, for sequences.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2), int64(3)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(882), kw_end_DASH_line, int(882))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(runtime.RT, "Nth") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Nth is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6, _ := lang.FieldOrMethod(runtime.RT, "NthDefault") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("NthDefault is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v3, v4, v5}) + return tmp7 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_nth = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_nth.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // num + { + var tmp1 lang.FnFunc + { // function num__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Num}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_num.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to Number", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(3474), kw_end_DASH_line, int(3474))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Num") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Num is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_num = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_num.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // object-array + { + var tmp1 lang.FnFunc + { // function object-array__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Object_array}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_object_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_size_DASH_or_DASH_seq)), kw_inline, tmp1, kw_doc, "Creates an array of objects", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1)})), kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(5349), kw_end_DASH_line, int(5349))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(runtime.RT, "Object_array") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Object_array is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_object_DASH_array = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_object_DASH_array.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // parse-impls + { + tmp0 := sym_parse_DASH_impls.WithMeta(lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(13), kw_column, int(8), kw_end_DASH_line, int(13), kw_end_DASH_column, int(18), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_specs)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "ret" + tmp4 := lang.NewMap() + tmp5 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(14), kw_column, int(14), kw_end_DASH_line, int(14), kw_end_DASH_column, int(15)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v7 any = tmp6 + _ = v7 + // let binding "s" + var v8 any = v2 + _ = v8 + for { + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_seq) + tmp11 := lang.Apply(tmp10, []any{v8}) + if lang.IsTruthy(tmp11) { + tmp13 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp14 := checkDerefVar(var_glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v8}) + tmp16 := checkDerefVar(var_glojure_DOT_core_take_DASH_while) + tmp17 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp18 := checkDerefVar(var_glojure_DOT_core_next) + tmp19 := lang.Apply(tmp18, []any{v8}) + tmp20 := lang.Apply(tmp16, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp13, []any{v7, tmp15, tmp20}) + var tmp12 any = tmp21 + tmp23 := checkDerefVar(var_glojure_DOT_core_drop_DASH_while) + tmp24 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp25 := checkDerefVar(var_glojure_DOT_core_next) + tmp26 := lang.Apply(tmp25, []any{v8}) + tmp27 := lang.Apply(tmp23, []any{tmp24, tmp26}) + var tmp22 any = tmp27 + v7 = tmp12 + v8 = tmp22 + continue + } else { + tmp9 = v7 + } + tmp3 = tmp9 + break + } + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_parse_DASH_impls = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_parse_DASH_impls.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // parse-uuid + { + tmp0 := sym_parse_DASH_uuid.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_doc, "Parse a string representing a UUID and return a java.util.UUID instance,\n or nil if parse fails.\n\n Grammar: https://docs.oracle.com/javase/8/docs/api/java/util/UUID.html#toString--", kw_file, "glojure/core.glj", kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(7946), kw_end_DASH_line, int(7946))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + func() { + defer func() { + if r := recover(); r != nil { + tmp4 := reflect.TypeOf((*lang.IllegalArgumentError)(nil)) + if lang.CatchMatches(r, tmp4) { + v5 := r + _ = v5 + } else { + panic(r) + } + } + }() + var tmp5 any + { // let + // let binding "vec__1014" + tmp6 := lang.Apply(uuid10.Parse, []any{v2}) + var v7 any = tmp6 + _ = v7 + // let binding "uuid" + tmp8 := checkDerefVar(var_glojure_DOT_core_nth) + tmp9 := lang.Apply(tmp8, []any{v7, int64(0), nil}) + var v10 any = tmp9 + _ = v10 + // let binding "err" + tmp11 := checkDerefVar(var_glojure_DOT_core_nth) + tmp12 := lang.Apply(tmp11, []any{v7, int64(1), nil}) + var v13 any = tmp12 + _ = v13 + var tmp14 any + if lang.IsTruthy(v13) { + tmp15 := checkDerefVar(var_glojure_DOT_core_str) + tmp16 := lang.Apply(tmp15, []any{"Error parsing UUID: ", v13}) + tmp17 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp16}) + panic(tmp17) + } else { + tmp14 = v10 + } + tmp5 = tmp14 + } // end let + tmp3 = tmp5 + }() + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_parse_DASH_uuid = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_parse_DASH_uuid.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // parsing-err + { + tmp0 := sym_parsing_DASH_err.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_val)), kw_doc, "Construct message for parsing for non-string parsing error", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(8), kw_line, int(7921), kw_end_DASH_line, int(7921), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_str) + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v2}) + if lang.IsTruthy(tmp6) { + tmp4 = "nil" + } else { + tmp7 := checkDerefVar(var_glojure_DOT_core_class) + tmp8 := lang.Apply(tmp7, []any{v2}) + tmp9, ok := lang.FieldOrMethod(tmp8, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp8, "Name"))) + } + var tmp10 any + switch reflect.TypeOf(tmp9).Kind() { + case reflect.Func: + tmp10 = lang.Apply(tmp9, nil) + default: + tmp10 = tmp9 + } + tmp4 = tmp10 + } + tmp11 := lang.Apply(tmp3, []any{"Expected string, got ", tmp4}) + return tmp11 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_parsing_DASH_err = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_parsing_DASH_err.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // pos? + { + var tmp1 lang.FnFunc + { // function pos?__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_IsPos}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_pos_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_num)), kw_inline, tmp1, kw_doc, "Returns true if num is greater than zero, else false", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1252), kw_end_DASH_line, int(1252))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "IsPos") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("IsPos is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_pos_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_pos_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // prependss + { + tmp0 := sym_prependss.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_coll)), kw_doc, "Prepends a symbol or a seq to coll", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(8), kw_line, int(5857), kw_end_DASH_line, int(5857), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v2}) + if lang.IsTruthy(tmp6) { + tmp7 := checkDerefVar(var_glojure_DOT_core_cons) + tmp8 := lang.Apply(tmp7, []any{v2, v3}) + tmp4 = tmp8 + } else { + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := lang.Apply(tmp9, []any{v2, v3}) + tmp4 = tmp10 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_prependss = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_prependss.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print-ctor + { + tmp0 := sym_print_DASH_ctor.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(95), kw_column, int(7), kw_end_DASH_line, int(95), kw_end_DASH_column, int(16), kw_arglists, lang.NewList(lang.NewVector(sym_o, sym_print_DASH_args, sym_w)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := lang.Apply(lang.WriteWriter, []any{v4, "#=("}) + _ = tmp5 + tmp6 := checkDerefVar(var_glojure_DOT_core_class) + tmp7 := lang.Apply(tmp6, []any{v2}) + tmp8, ok := lang.FieldOrMethod(tmp7, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp7, "Name"))) + } + var tmp9 any + switch reflect.TypeOf(tmp8).Kind() { + case reflect.Func: + tmp9 = lang.Apply(tmp8, nil) + default: + tmp9 = tmp8 + } + tmp10 := lang.Apply(lang.WriteWriter, []any{v4, tmp9}) + _ = tmp10 + tmp11 := lang.Apply(lang.WriteWriter, []any{v4, ". "}) + _ = tmp11 + tmp12 := lang.Apply(v3, []any{v2, v4}) + _ = tmp12 + tmp13 := lang.Apply(lang.WriteWriter, []any{v4, ")"}) + return tmp13 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_print_DASH_ctor = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_print_DASH_ctor.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // quot + { + var tmp1 lang.FnFunc + { // function quot__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Quotient}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_quot.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_num, sym_div)), kw_inline, tmp1, kw_doc, "quot[ient] of dividing numerator by denominator.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1266), kw_end_DASH_line, int(1266))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Quotient") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Quotient is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_quot = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_quot.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // range + { + tmp0 := sym_range.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_end), lang.NewVector(sym_start, sym_end), lang.NewVector(sym_start, sym_end, sym_step)), kw_doc, "Returns a lazy seq of nums from start (inclusive) to end\n (exclusive), by step, where start defaults to 0, step to 1, and end to\n infinity. When step is equal to 0, returns an infinite sequence of\n start. When start is equal to end, returns empty list.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3018), kw_end_DASH_line, int(3018))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp2 := checkDerefVar(var_glojure_DOT_core_iterate) + tmp3 := checkDerefVar(var_glojure_DOT_core_inc_TICK_) + tmp4 := lang.Apply(tmp2, []any{tmp3, int64(0)}) + return tmp4 + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + tmp6 := lang.Apply(lang.NewLongRange, []any{int64(0), v2, int64(1)}) + tmp3 = tmp6 + } else { + tmp7 := lang.Apply(lang.NewRange, []any{int64(0), v2, int64(1)}) + tmp3 = tmp7 + } + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + var tmp5 any + { // let + // let binding "and__0__auto__" + tmp6 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) + tmp7 := lang.Apply(tmp6, []any{v2}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + tmp10 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) + tmp11 := lang.Apply(tmp10, []any{v3}) + tmp9 = tmp11 + } else { + tmp9 = v8 + } + tmp5 = tmp9 + } // end let + if lang.IsTruthy(tmp5) { + tmp6 := lang.Apply(lang.NewLongRange, []any{v2, v3, int64(1)}) + tmp4 = tmp6 + } else { + tmp7 := lang.Apply(lang.NewRange, []any{v2, v3, int64(1)}) + tmp4 = tmp7 + } + return tmp4 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + var tmp6 any + { // let + // let binding "and__0__auto__" + tmp7 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v2}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + var tmp11 any + { // let + // let binding "and__0__auto__" + tmp12 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) + tmp13 := lang.Apply(tmp12, []any{v3}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + tmp16 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) + tmp17 := lang.Apply(tmp16, []any{v4}) + tmp15 = tmp17 + } else { + tmp15 = v14 + } + tmp11 = tmp15 + } // end let + tmp10 = tmp11 + } else { + tmp10 = v9 + } + tmp6 = tmp10 + } // end let + if lang.IsTruthy(tmp6) { + tmp7 := lang.Apply(lang.NewLongRange, []any{v2, v3, v4}) + tmp5 = tmp7 + } else { + tmp8 := lang.Apply(lang.NewRange, []any{v2, v3, v4}) + tmp5 = tmp8 + } + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_range = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_range.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // rational? + { + tmp0 := sym_rational_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_doc, "Returns true if n is a rational number", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(3613), kw_end_DASH_line, int(3613))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "or__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_integer_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + tmp7 = v6 + } else { + var tmp8 any + { // let + // let binding "or__0__auto__" + tmp9 := checkDerefVar(var_glojure_DOT_core_ratio_QMARK_) + tmp10 := lang.Apply(tmp9, []any{v2}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + tmp12 = v11 + } else { + tmp13 := checkDerefVar(var_glojure_DOT_core_decimal_QMARK_) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp12 = tmp14 + } + tmp8 = tmp12 + } // end let + tmp7 = tmp8 + } + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_rational_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_rational_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reduce1 + { + tmp0 := sym_reduce1.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(923), kw_column, int(7), kw_end_DASH_line, int(924), kw_end_DASH_column, int(9), kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_coll), lang.NewVector(sym_f, sym_val, sym_coll)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "s" + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := lang.Apply(tmp5, []any{v3}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + if lang.IsTruthy(v7) { + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v7}) + tmp12 := checkDerefVar(var_glojure_DOT_core_next) + tmp13 := lang.Apply(tmp12, []any{v7}) + tmp14 := lang.Apply(tmp9, []any{v2, tmp11, tmp13}) + tmp8 = tmp14 + } else { + tmp15 := lang.Apply(v2, nil) + tmp8 = tmp15 + } + tmp4 = tmp8 + } // end let + return tmp4 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + recur_loop_1696: + var tmp5 any + { // let + // let binding "s" + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := lang.Apply(tmp6, []any{v4}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + var tmp10 any + tmp11 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp12 := lang.Apply(tmp11, []any{v8}) + if lang.IsTruthy(tmp12) { + var tmp13 any = v2 + tmp15 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp16 := lang.Apply(tmp15, []any{v8}) + tmp17, _ := lang.FieldOrMethod(tmp16, "ReduceInit") + if reflect.TypeOf(tmp17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) + } + tmp18 := lang.Apply(tmp17, []any{v2, v3}) + var tmp14 any = tmp18 + tmp20 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_next) + tmp21 := lang.Apply(tmp20, []any{v8}) + var tmp19 any = tmp21 + v2 = tmp13 + v3 = tmp14 + v4 = tmp19 + goto recur_loop_1696 + } else { + var tmp22 any = v2 + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v8}) + tmp26 := lang.Apply(v2, []any{v3, tmp25}) + var tmp23 any = tmp26 + tmp28 := checkDerefVar(var_glojure_DOT_core_next) + tmp29 := lang.Apply(tmp28, []any{v8}) + var tmp27 any = tmp29 + v2 = tmp22 + v3 = tmp23 + v4 = tmp27 + goto recur_loop_1696 + } + tmp9 = tmp10 + } else { + tmp9 = v3 + } + tmp5 = tmp9 + } // end let + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_reduce1 = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_reduce1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reduced? + { + var tmp1 lang.FnFunc + { // function reduced?__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_IsReduced}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{v3}) + tmp10 := lang.Apply(tmp5, []any{tmp7, tmp9}) + tmp11 := lang.Apply(tmp4, []any{tmp10}) + return tmp11 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_reduced_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns true if x is the result of a call to reduced", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1)})), kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(2834), kw_end_DASH_line, int(2834))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.IsReduced, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_reduced_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_reduced_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reductions + { + tmp0 := sym_reductions.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_coll), lang.NewVector(sym_f, sym_init, sym_coll)), kw_doc, "Returns a lazy seq of the intermediate values of the reduction (as\n per reduce) of coll by f, starting with init.", kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(7196), kw_end_DASH_line, int(7196))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp5 any + { // let + // let binding "temp__0__auto__" + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := lang.Apply(tmp6, []any{v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + var tmp10 any + { // let + // let binding "s" + var v11 any = v8 + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_reductions) + tmp13 := checkDerefVar(var_glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v11}) + tmp15 := checkDerefVar(var_glojure_DOT_core_rest) + tmp16 := lang.Apply(tmp15, []any{v11}) + tmp17 := lang.Apply(tmp12, []any{v2, tmp14, tmp16}) + tmp10 = tmp17 + } // end let + tmp9 = tmp10 + } else { + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(v2, nil) + tmp13 := lang.Apply(tmp11, []any{tmp12}) + tmp9 = tmp13 + } + tmp5 = tmp9 + } // end let + return tmp5 + }) + tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) + return tmp5 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) + tmp7 := lang.Apply(tmp6, []any{v3}) + if lang.IsTruthy(tmp7) { + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := checkDerefVar(var_glojure_DOT_core_deref) + tmp10 := lang.Apply(tmp9, []any{v3}) + tmp11 := lang.Apply(tmp8, []any{tmp10}) + tmp5 = tmp11 + } else { + tmp12 := checkDerefVar(var_glojure_DOT_core_cons) + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp14 any + { // let + // let binding "temp__0__auto__" + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := lang.Apply(tmp15, []any{v4}) + var v17 any = tmp16 + _ = v17 + var tmp18 any + if lang.IsTruthy(v17) { + var tmp19 any + { // let + // let binding "s" + var v20 any = v17 + _ = v20 + tmp21 := checkDerefVar(var_glojure_DOT_core_reductions) + tmp22 := checkDerefVar(var_glojure_DOT_core_first) + tmp23 := lang.Apply(tmp22, []any{v20}) + tmp24 := lang.Apply(v2, []any{v3, tmp23}) + tmp25 := checkDerefVar(var_glojure_DOT_core_rest) + tmp26 := lang.Apply(tmp25, []any{v20}) + tmp27 := lang.Apply(tmp21, []any{v2, tmp24, tmp26}) + tmp19 = tmp27 + } // end let + tmp18 = tmp19 + } else { + } + tmp14 = tmp18 + } // end let + return tmp14 + }) + tmp14 := lang.Apply(lang.NewLazySeq, []any{tmp13}) + tmp15 := lang.Apply(tmp12, []any{v3, tmp14}) + tmp5 = tmp15 + } + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_reductions = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_reductions.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // refer-glojure + { + tmp0 := sym_refer_DASH_glojure.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_filters)), kw_doc, "Same as (refer 'glojure.core )", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(11), kw_line, int(5800), kw_end_DASH_line, int(5800))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym_glojure_DOT_core_SLASH_refer}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := checkDerefVar(var_glojure_DOT_core_seq) + tmp11 := checkDerefVar(var_glojure_DOT_core_concat) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_quote}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core}) + tmp16 := lang.Apply(tmp11, []any{tmp13, tmp15}) + tmp17 := lang.Apply(tmp10, []any{tmp16}) + tmp18 := lang.Apply(tmp9, []any{tmp17}) + tmp19 := lang.Apply(tmp6, []any{tmp8, tmp18, v4}) + tmp20 := lang.Apply(tmp5, []any{tmp19}) + return tmp20 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_refer_DASH_glojure = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_refer_DASH_glojure.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // rem + { + var tmp1 lang.FnFunc + { // function rem__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Remainder}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_rem.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_num, sym_div)), kw_inline, tmp1, kw_doc, "remainder of dividing numerator by denominator.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(1274), kw_end_DASH_line, int(1274))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Remainder") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Remainder is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_rem = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_rem.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // remove-tap + { + tmp0 := sym_remove_DASH_tap.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f)), kw_doc, "Remove f from the tap set.", kw_file, "glojure/core.glj", kw_added, "1.10", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(7883), kw_end_DASH_line, int(7883))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_swap_BANG_) + tmp4 := checkDerefVar(var_glojure_DOT_core_tapset) + tmp5 := checkDerefVar(var_glojure_DOT_core_disj) + tmp6 := lang.Apply(tmp3, []any{tmp4, tmp5, v2}) + _ = tmp6 + return nil + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_remove_DASH_tap = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_remove_DASH_tap.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // resolve + { + tmp0 := sym_resolve.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_sym), lang.NewVector(sym_env, sym_sym)), kw_doc, "same as (ns-resolve *ns* symbol) or (ns-resolve *ns* &env symbol)", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4371), kw_end_DASH_line, int(4371))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_ns_DASH_resolve) + tmp4 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_ns_DASH_resolve) + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp6 := lang.Apply(tmp4, []any{tmp5, v2, v3}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_resolve = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_resolve.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reverse + { + tmp0 := sym_reverse.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a seq of the items in coll in reverse order. Not lazy.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(940), kw_end_DASH_line, int(940))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp4 := checkDerefVar(var_glojure_DOT_core_conj) + tmp5 := lang.Apply(tmp3, []any{tmp4, lang.NewList(), v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_reverse = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_reverse.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // root-resource + { + tmp1 := reflect.TypeOf("") + tmp0 := sym_root_DASH_resource.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_lib)), kw_doc, "Returns the root directory path for a lib", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(8), kw_line, int(5864), kw_end_DASH_line, int(5864), kw_private, true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_str) + tmp5 := checkDerefVar(var_glojure_DOT_core_name) + tmp6 := lang.Apply(tmp5, []any{v3}) + tmp7 := lang.Apply(strings8.ReplaceAll, []any{tmp6, "-", "_"}) + tmp8 := lang.Apply(strings8.ReplaceAll, []any{tmp7, ".", "/"}) + tmp9 := lang.Apply(tmp4, []any{lang.NewChar(47), tmp8}) + return tmp9 + }) + tmp3 := reflect.TypeOf("") + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_root_DASH_resource = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_root_DASH_resource.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // select-keys + { + tmp0 := sym_select_DASH_keys.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_map, sym_keyseq)), kw_doc, "Returns a map containing only those entries in map whose key is in keys", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(1536), kw_end_DASH_line, int(1536))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "ret" + tmp5 := lang.NewMap() + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(1541), kw_column, int(16), kw_end_DASH_line, int(1541), kw_end_DASH_column, int(17)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v8 any = tmp7 + _ = v8 + // let binding "keys" + tmp9 := checkDerefVar(var_glojure_DOT_core_seq) + tmp10 := lang.Apply(tmp9, []any{v3}) + var v11 any = tmp10 + _ = v11 + for { + var tmp12 any + if lang.IsTruthy(v11) { + var tmp13 any + { // let + // let binding "entry" + tmp14 := checkDerefVar(var_glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v11}) + tmp16, _ := lang.FieldOrMethod(runtime.RT, "Find") + if reflect.TypeOf(tmp16).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Find is not a function"))) + } + tmp17 := lang.Apply(tmp16, []any{v2, tmp15}) + var v18 any = tmp17 + _ = v18 + var tmp20 any + if lang.IsTruthy(v18) { + tmp21 := checkDerefVar(var_glojure_DOT_core_conj) + tmp22 := lang.Apply(tmp21, []any{v8, v18}) + tmp20 = tmp22 + } else { + tmp20 = v8 + } + var tmp19 any = tmp20 + tmp24 := checkDerefVar(var_glojure_DOT_core_next) + tmp25 := lang.Apply(tmp24, []any{v11}) + var tmp23 any = tmp25 + v8 = tmp19 + v11 = tmp23 + continue + } // end let + tmp12 = tmp13 + } else { + tmp14 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp15 := checkDerefVar(var_glojure_DOT_core_meta) + tmp16 := lang.Apply(tmp15, []any{v2}) + tmp17 := lang.Apply(tmp14, []any{v8, tmp16}) + tmp12 = tmp17 + } + tmp4 = tmp12 + break + } + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_select_DASH_keys = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_select_DASH_keys.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // seq-to-map-for-destructuring + { + tmp0 := sym_seq_DASH_to_DASH_map_DASH_for_DASH_destructuring.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_doc, "Builds a map from a seq as described in\n https://glojure.org/reference/special_forms#keyword-arguments", kw_file, "glojure/core.glj", kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(34), kw_column, int(7), kw_line, int(4390), kw_end_DASH_line, int(4390))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_next) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + tmp6 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) + tmp7 := lang.Apply(tmp6, []any{v2}) + tmp8 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{tmp7}) + tmp3 = tmp8 + } else { + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_seq) + tmp11 := lang.Apply(tmp10, []any{v2}) + if lang.IsTruthy(tmp11) { + tmp12 := checkDerefVar(var_glojure_DOT_core_first) + tmp13 := lang.Apply(tmp12, []any{v2}) + tmp9 = tmp13 + } else { + } + tmp3 = tmp9 + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_seq_DASH_to_DASH_map_DASH_for_DASH_destructuring = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_seq_DASH_to_DASH_map_DASH_for_DASH_destructuring.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // set + { + tmp0 := sym_set.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a set of the distinct elements of coll.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(4104), kw_end_DASH_line, int(4104))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_set_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + tmp6 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp7 := lang.Apply(tmp6, []any{v2, nil}) + tmp3 = tmp7 + } else { + var tmp8 any + tmp9 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp10 := reflect.TypeOf((*lang.IReduceInit)(nil)).Elem() + tmp11 := lang.Apply(tmp9, []any{tmp10, v2}) + if lang.IsTruthy(tmp11) { + tmp12 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp13 := checkDerefVar(var_glojure_DOT_core_conj_BANG_) + tmp14 := checkDerefVar(var_glojure_DOT_core_transient) + tmp15 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4112), kw_column, int(108), kw_end_DASH_line, int(4112), kw_end_DASH_column, int(110)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp18 := lang.Apply(tmp14, []any{tmp17}) + tmp19, _ := lang.FieldOrMethod(v2, "ReduceInit") + if reflect.TypeOf(tmp19).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) + } + tmp20 := lang.Apply(tmp19, []any{tmp13, tmp18}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp8 = tmp21 + } else { + tmp22 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp23 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp24 := checkDerefVar(var_glojure_DOT_core_conj_BANG_) + tmp25 := checkDerefVar(var_glojure_DOT_core_transient) + tmp26 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp27 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4113), kw_column, int(46), kw_end_DASH_line, int(4113), kw_end_DASH_column, int(48)) + tmp28, err := lang.WithMeta(tmp26, tmp27.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp29 := lang.Apply(tmp25, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp24, tmp29, v2}) + tmp31 := lang.Apply(tmp22, []any{tmp30}) + tmp8 = tmp31 + } + tmp3 = tmp8 + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_set = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_set.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // short + { + var tmp1 lang.FnFunc + { // function short__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp15) { + tmp14 = sym_uncheckedShortCast + } else { + tmp14 = sym_shortCast + } + tmp16 := lang.Apply(tmp13, []any{tmp14}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := lang.Apply(tmp12, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp11, []any{tmp19}) + tmp21 := lang.Apply(tmp10, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_short.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to short", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3499), kw_end_DASH_line, int(3499))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.ShortCast, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_short = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_short.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // short-array + { + var tmp1 lang.FnFunc + { // function short-array__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_ShortArray}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_unquote_DASH_splicing}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_glojure_DOT_core_SLASH_args}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + } + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_short_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_size_DASH_or_DASH_seq), lang.NewVector(sym_size, sym_init_DASH_val_DASH_or_DASH_seq)), kw_inline, tmp1, kw_doc, "Creates an array of shorts", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(5333), kw_end_DASH_line, int(5333))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "ShortArray") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ShortArray is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "ShortArrayInit") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ShortArrayInit is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_short_DASH_array = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_short_DASH_array.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // shorts + { + var tmp1 lang.FnFunc + { // function shorts + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Shorts}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_shorts.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xs)), kw_inline, tmp1, kw_doc, "Casts to shorts[]", kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(12), kw_line, int(5387), kw_end_DASH_line, int(5387))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Shorts") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Shorts is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_shorts = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_shorts.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // shuffle + { + tmp0 := sym_shuffle.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Return a random permutation of coll", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(7300), kw_end_DASH_line, int(7300))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "al" + tmp4 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) + tmp5 := lang.Apply(tmp4, []any{v2}) + tmp6 := lang.Apply(lang.NewArrayList, []any{tmp5}) + var v7 any = tmp6 + _ = v7 + tmp8 := lang.Apply(nil, []any{v7}) + _ = tmp8 + tmp9, ok := lang.FieldOrMethod(v7, "toArray") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "toArray"))) + } + var tmp10 any + switch reflect.TypeOf(tmp9).Kind() { + case reflect.Func: + tmp10 = lang.Apply(tmp9, nil) + default: + tmp10 = tmp9 + } + tmp11 := lang.Apply(nil, []any{tmp10}) + tmp3 = tmp11 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_shuffle = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_shuffle.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // simple-ident? + { + tmp0 := sym_simple_DASH_ident_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a symbol or keyword without a namespace", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(1613), kw_end_DASH_line, int(1613))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "and__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_ident_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + tmp8 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp9 := checkDerefVar(var_glojure_DOT_core_namespace) + tmp10 := lang.Apply(tmp9, []any{v2}) + tmp11 := lang.Apply(tmp8, []any{tmp10}) + tmp7 = tmp11 + } else { + tmp7 = v6 + } + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_simple_DASH_ident_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_simple_DASH_ident_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // simple-symbol? + { + tmp0 := sym_simple_DASH_symbol_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a symbol without a namespace", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(1623), kw_end_DASH_line, int(1623))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "and__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + tmp8 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp9 := checkDerefVar(var_glojure_DOT_core_namespace) + tmp10 := lang.Apply(tmp9, []any{v2}) + tmp11 := lang.Apply(tmp8, []any{tmp10}) + tmp7 = tmp11 + } else { + tmp7 = v6 + } + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_simple_DASH_symbol_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_simple_DASH_symbol_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // some-fn + { + tmp0 := sym_some_DASH_fn.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_p), lang.NewVector(sym_p1, sym_p2), lang.NewVector(sym_p1, sym_p2, sym_p3), lang.NewVector(sym_p1, sym_p2, sym_p3, sym__AMP_, sym_ps)), kw_doc, "Takes a set of predicates and returns a function f that returns the first logical true value\n returned by one of its composing predicates against any of its arguments, else it returns\n logical false. Note that f is short-circuiting in that it will stop execution on the first\n argument that triggers a logical true result against the original predicates.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(7462), kw_end_DASH_line, int(7462))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + { // function sp1 + var v4 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return nil + case 1: + v5 := args[0] + _ = v5 + tmp6 := lang.Apply(v2, []any{v5}) + return tmp6 + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + var tmp7 any + { // let + // let binding "or__0__auto__" + tmp8 := lang.Apply(v2, []any{v5}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + tmp10 = v9 + } else { + tmp11 := lang.Apply(v2, []any{v6}) + tmp10 = tmp11 + } + tmp7 = tmp10 + } // end let + return tmp7 + case 3: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := args[2] + _ = v7 + var tmp8 any + { // let + // let binding "or__0__auto__" + tmp9 := lang.Apply(v2, []any{v5}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + if lang.IsTruthy(v10) { + tmp11 = v10 + } else { + var tmp12 any + { // let + // let binding "or__0__auto__" + tmp13 := lang.Apply(v2, []any{v6}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + tmp15 = v14 + } else { + tmp16 := lang.Apply(v2, []any{v7}) + tmp15 = tmp16 + } + tmp12 = tmp15 + } // end let + tmp11 = tmp12 + } + tmp8 = tmp11 + } // end let + return tmp8 + default: + checkArity(args, 3) + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := args[2] + _ = v7 + var v8 any = lang.NewList(args[3:]...) + _ = v8 + var tmp9 any + { // let + // let binding "or__0__auto__" + tmp10 := lang.Apply(v4, []any{v5, v6, v7}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + tmp12 = v11 + } else { + tmp13 := checkDerefVar(var_glojure_DOT_core_some) + tmp14 := lang.Apply(tmp13, []any{v2, v8}) + tmp12 = tmp14 + } + tmp9 = tmp12 + } // end let + return tmp9 + } + }) + v4 = tmp3 + _ = v4 + } + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7469), kw_column, int(6), kw_end_DASH_line, int(7475), kw_end_DASH_column, int(43)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + { // function sp2 + var v5 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return nil + case 1: + v6 := args[0] + _ = v6 + var tmp7 any + { // let + // let binding "or__0__auto__" + tmp8 := lang.Apply(v2, []any{v6}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + tmp10 = v9 + } else { + tmp11 := lang.Apply(v3, []any{v6}) + tmp10 = tmp11 + } + tmp7 = tmp10 + } // end let + return tmp7 + case 2: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + var tmp8 any + { // let + // let binding "or__0__auto__" + tmp9 := lang.Apply(v2, []any{v6}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + if lang.IsTruthy(v10) { + tmp11 = v10 + } else { + var tmp12 any + { // let + // let binding "or__0__auto__" + tmp13 := lang.Apply(v2, []any{v7}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + tmp15 = v14 + } else { + var tmp16 any + { // let + // let binding "or__0__auto__" + tmp17 := lang.Apply(v3, []any{v6}) + var v18 any = tmp17 + _ = v18 + var tmp19 any + if lang.IsTruthy(v18) { + tmp19 = v18 + } else { + tmp20 := lang.Apply(v3, []any{v7}) + tmp19 = tmp20 + } + tmp16 = tmp19 + } // end let + tmp15 = tmp16 + } + tmp12 = tmp15 + } // end let + tmp11 = tmp12 + } + tmp8 = tmp11 + } // end let + return tmp8 + case 3: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + var tmp9 any + { // let + // let binding "or__0__auto__" + tmp10 := lang.Apply(v2, []any{v6}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + tmp12 = v11 + } else { + var tmp13 any + { // let + // let binding "or__0__auto__" + tmp14 := lang.Apply(v2, []any{v7}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + if lang.IsTruthy(v15) { + tmp16 = v15 + } else { + var tmp17 any + { // let + // let binding "or__0__auto__" + tmp18 := lang.Apply(v2, []any{v8}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + tmp20 = v19 + } else { + var tmp21 any + { // let + // let binding "or__0__auto__" + tmp22 := lang.Apply(v3, []any{v6}) + var v23 any = tmp22 + _ = v23 + var tmp24 any + if lang.IsTruthy(v23) { + tmp24 = v23 + } else { + var tmp25 any + { // let + // let binding "or__0__auto__" + tmp26 := lang.Apply(v3, []any{v7}) + var v27 any = tmp26 + _ = v27 + var tmp28 any + if lang.IsTruthy(v27) { + tmp28 = v27 + } else { + tmp29 := lang.Apply(v3, []any{v8}) + tmp28 = tmp29 + } + tmp25 = tmp28 + } // end let + tmp24 = tmp25 + } + tmp21 = tmp24 + } // end let + tmp20 = tmp21 + } + tmp17 = tmp20 + } // end let + tmp16 = tmp17 + } + tmp13 = tmp16 + } // end let + tmp12 = tmp13 + } + tmp9 = tmp12 + } // end let + return tmp9 + default: + checkArity(args, 3) + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + var v9 any = lang.NewList(args[3:]...) + _ = v9 + var tmp10 any + { // let + // let binding "or__0__auto__" + tmp11 := lang.Apply(v5, []any{v6, v7, v8}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + tmp13 = v12 + } else { + tmp14 := checkDerefVar(var_glojure_DOT_core_some) + var tmp15 lang.FnFunc + tmp15 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v16 := args[0] + _ = v16 + var tmp17 any + { // let + // let binding "or__0__auto__" + tmp18 := lang.Apply(v2, []any{v16}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + tmp20 = v19 + } else { + tmp21 := lang.Apply(v3, []any{v16}) + tmp20 = tmp21 + } + tmp17 = tmp20 + } // end let + return tmp17 + }) + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7483), kw_column, int(34), kw_end_DASH_line, int(7483), kw_end_DASH_column, int(52)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp18 := lang.Apply(tmp14, []any{tmp17, v9}) + tmp13 = tmp18 + } + tmp10 = tmp13 + } // end let + return tmp10 + } + }) + v5 = tmp4 + _ = v5 + } + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7477), kw_column, int(6), kw_end_DASH_line, int(7483), kw_end_DASH_column, int(61)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 lang.FnFunc + { // function sp3 + var v6 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return nil + case 1: + v7 := args[0] + _ = v7 + var tmp8 any + { // let + // let binding "or__0__auto__" + tmp9 := lang.Apply(v2, []any{v7}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + if lang.IsTruthy(v10) { + tmp11 = v10 + } else { + var tmp12 any + { // let + // let binding "or__0__auto__" + tmp13 := lang.Apply(v3, []any{v7}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + tmp15 = v14 + } else { + tmp16 := lang.Apply(v4, []any{v7}) + tmp15 = tmp16 + } + tmp12 = tmp15 + } // end let + tmp11 = tmp12 + } + tmp8 = tmp11 + } // end let + return tmp8 + case 2: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + var tmp9 any + { // let + // let binding "or__0__auto__" + tmp10 := lang.Apply(v2, []any{v7}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + tmp12 = v11 + } else { + var tmp13 any + { // let + // let binding "or__0__auto__" + tmp14 := lang.Apply(v2, []any{v8}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + if lang.IsTruthy(v15) { + tmp16 = v15 + } else { + var tmp17 any + { // let + // let binding "or__0__auto__" + tmp18 := lang.Apply(v3, []any{v7}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + tmp20 = v19 + } else { + var tmp21 any + { // let + // let binding "or__0__auto__" + tmp22 := lang.Apply(v3, []any{v8}) + var v23 any = tmp22 + _ = v23 + var tmp24 any + if lang.IsTruthy(v23) { + tmp24 = v23 + } else { + var tmp25 any + { // let + // let binding "or__0__auto__" + tmp26 := lang.Apply(v4, []any{v7}) + var v27 any = tmp26 + _ = v27 + var tmp28 any + if lang.IsTruthy(v27) { + tmp28 = v27 + } else { + tmp29 := lang.Apply(v4, []any{v8}) + tmp28 = tmp29 + } + tmp25 = tmp28 + } // end let + tmp24 = tmp25 + } + tmp21 = tmp24 + } // end let + tmp20 = tmp21 + } + tmp17 = tmp20 + } // end let + tmp16 = tmp17 + } + tmp13 = tmp16 + } // end let + tmp12 = tmp13 + } + tmp9 = tmp12 + } // end let + return tmp9 + case 3: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + var tmp10 any + { // let + // let binding "or__0__auto__" + tmp11 := lang.Apply(v2, []any{v7}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + tmp13 = v12 + } else { + var tmp14 any + { // let + // let binding "or__0__auto__" + tmp15 := lang.Apply(v2, []any{v8}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + if lang.IsTruthy(v16) { + tmp17 = v16 + } else { + var tmp18 any + { // let + // let binding "or__0__auto__" + tmp19 := lang.Apply(v2, []any{v9}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + tmp21 = v20 + } else { + var tmp22 any + { // let + // let binding "or__0__auto__" + tmp23 := lang.Apply(v3, []any{v7}) + var v24 any = tmp23 + _ = v24 + var tmp25 any + if lang.IsTruthy(v24) { + tmp25 = v24 + } else { + var tmp26 any + { // let + // let binding "or__0__auto__" + tmp27 := lang.Apply(v3, []any{v8}) + var v28 any = tmp27 + _ = v28 + var tmp29 any + if lang.IsTruthy(v28) { + tmp29 = v28 + } else { + var tmp30 any + { // let + // let binding "or__0__auto__" + tmp31 := lang.Apply(v3, []any{v9}) + var v32 any = tmp31 + _ = v32 + var tmp33 any + if lang.IsTruthy(v32) { + tmp33 = v32 + } else { + var tmp34 any + { // let + // let binding "or__0__auto__" + tmp35 := lang.Apply(v4, []any{v7}) + var v36 any = tmp35 + _ = v36 + var tmp37 any + if lang.IsTruthy(v36) { + tmp37 = v36 + } else { + var tmp38 any + { // let + // let binding "or__0__auto__" + tmp39 := lang.Apply(v4, []any{v8}) + var v40 any = tmp39 + _ = v40 + var tmp41 any + if lang.IsTruthy(v40) { + tmp41 = v40 + } else { + tmp42 := lang.Apply(v4, []any{v9}) + tmp41 = tmp42 + } + tmp38 = tmp41 + } // end let + tmp37 = tmp38 + } + tmp34 = tmp37 + } // end let + tmp33 = tmp34 + } + tmp30 = tmp33 + } // end let + tmp29 = tmp30 + } + tmp26 = tmp29 + } // end let + tmp25 = tmp26 + } + tmp22 = tmp25 + } // end let + tmp21 = tmp22 + } + tmp18 = tmp21 + } // end let + tmp17 = tmp18 + } + tmp14 = tmp17 + } // end let + tmp13 = tmp14 + } + tmp10 = tmp13 + } // end let + return tmp10 + default: + checkArity(args, 3) + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + var v10 any = lang.NewList(args[3:]...) + _ = v10 + var tmp11 any + { // let + // let binding "or__0__auto__" + tmp12 := lang.Apply(v6, []any{v7, v8, v9}) + var v13 any = tmp12 + _ = v13 + var tmp14 any + if lang.IsTruthy(v13) { + tmp14 = v13 + } else { + tmp15 := checkDerefVar(var_glojure_DOT_core_some) + var tmp16 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v17 := args[0] + _ = v17 + var tmp18 any + { // let + // let binding "or__0__auto__" + tmp19 := lang.Apply(v2, []any{v17}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + tmp21 = v20 + } else { + var tmp22 any + { // let + // let binding "or__0__auto__" + tmp23 := lang.Apply(v3, []any{v17}) + var v24 any = tmp23 + _ = v24 + var tmp25 any + if lang.IsTruthy(v24) { + tmp25 = v24 + } else { + tmp26 := lang.Apply(v4, []any{v17}) + tmp25 = tmp26 + } + tmp22 = tmp25 + } // end let + tmp21 = tmp22 + } + tmp18 = tmp21 + } // end let + return tmp18 + }) + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7491), kw_column, int(34), kw_end_DASH_line, int(7491), kw_end_DASH_column, int(59)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp19 := lang.Apply(tmp15, []any{tmp18, v10}) + tmp14 = tmp19 + } + tmp11 = tmp14 + } // end let + return tmp11 + } + }) + v6 = tmp5 + _ = v6 + } + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7485), kw_column, int(6), kw_end_DASH_line, int(7491), kw_end_DASH_column, int(68)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp7 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "ps" + tmp7 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp8 := lang.Apply(tmp7, []any{v2, v3, v4, v5}) + var v9 any = tmp8 + _ = v9 + var tmp10 lang.FnFunc + { // function spn + var v11 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return nil + case 1: + v12 := args[0] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_some) + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v15 := args[0] + _ = v15 + tmp16 := lang.Apply(v15, []any{v12}) + return tmp16 + }) + tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7496), kw_column, int(21), kw_end_DASH_line, int(7496), kw_end_DASH_column, int(26)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp17 := lang.Apply(tmp13, []any{tmp16, v9}) + return tmp17 + case 2: + v12 := args[0] + _ = v12 + v13 := args[1] + _ = v13 + tmp14 := checkDerefVar(var_glojure_DOT_core_some) + var tmp15 lang.FnFunc + tmp15 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v16 := args[0] + _ = v16 + var tmp17 any + { // let + // let binding "or__0__auto__" + tmp18 := lang.Apply(v16, []any{v12}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + tmp20 = v19 + } else { + tmp21 := lang.Apply(v16, []any{v13}) + tmp20 = tmp21 + } + tmp17 = tmp20 + } // end let + return tmp17 + }) + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7497), kw_column, int(23), kw_end_DASH_line, int(7497), kw_end_DASH_column, int(39)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp18 := lang.Apply(tmp14, []any{tmp17, v9}) + return tmp18 + case 3: + v12 := args[0] + _ = v12 + v13 := args[1] + _ = v13 + v14 := args[2] + _ = v14 + tmp15 := checkDerefVar(var_glojure_DOT_core_some) + var tmp16 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v17 := args[0] + _ = v17 + var tmp18 any + { // let + // let binding "or__0__auto__" + tmp19 := lang.Apply(v17, []any{v12}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + tmp21 = v20 + } else { + var tmp22 any + { // let + // let binding "or__0__auto__" + tmp23 := lang.Apply(v17, []any{v13}) + var v24 any = tmp23 + _ = v24 + var tmp25 any + if lang.IsTruthy(v24) { + tmp25 = v24 + } else { + tmp26 := lang.Apply(v17, []any{v14}) + tmp25 = tmp26 + } + tmp22 = tmp25 + } // end let + tmp21 = tmp22 + } + tmp18 = tmp21 + } // end let + return tmp18 + }) + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7498), kw_column, int(25), kw_end_DASH_line, int(7498), kw_end_DASH_column, int(47)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp19 := lang.Apply(tmp15, []any{tmp18, v9}) + return tmp19 + default: + checkArity(args, 3) + v12 := args[0] + _ = v12 + v13 := args[1] + _ = v13 + v14 := args[2] + _ = v14 + var v15 any = lang.NewList(args[3:]...) + _ = v15 + var tmp16 any + { // let + // let binding "or__0__auto__" + tmp17 := lang.Apply(v11, []any{v12, v13, v14}) + var v18 any = tmp17 + _ = v18 + var tmp19 any + if lang.IsTruthy(v18) { + tmp19 = v18 + } else { + tmp20 := checkDerefVar(var_glojure_DOT_core_some) + var tmp21 lang.FnFunc + tmp21 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v22 := args[0] + _ = v22 + tmp23 := checkDerefVar(var_glojure_DOT_core_some) + tmp24 := lang.Apply(tmp23, []any{v22, v15}) + return tmp24 + }) + tmp22 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7500), kw_column, int(36), kw_end_DASH_line, int(7500), kw_end_DASH_column, int(49)) + tmp23, err := lang.WithMeta(tmp21, tmp22.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp24 := lang.Apply(tmp20, []any{tmp23, v9}) + tmp19 = tmp24 + } + tmp16 = tmp19 + } // end let + return tmp16 + } + }) + v11 = tmp10 + _ = v11 + } + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7494), kw_column, int(8), kw_end_DASH_line, int(7500), kw_end_DASH_column, int(56)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp6 = tmp12 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_some_DASH_fn = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_some_DASH_fn.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // split-with + { + tmp0 := sym_split_DASH_with.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns a vector of [(take-while pred coll) (drop-while pred coll)]", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(2990), kw_end_DASH_line, int(2990))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_take_DASH_while) + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + tmp6 := checkDerefVar(var_glojure_DOT_core_drop_DASH_while) + tmp7 := lang.Apply(tmp6, []any{v2, v3}) + tmp8 := lang.NewVector(tmp5, tmp7) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2995), kw_column, int(5), kw_end_DASH_line, int(2995), kw_end_DASH_column, int(51)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp10 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_split_DASH_with = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_split_DASH_with.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // stream-into! + { + tmp0 := sym_stream_DASH_into_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_to, sym_stream), lang.NewVector(sym_to, sym_xform, sym_stream)), kw_doc, "Returns a new coll consisting of coll with all of the items of the\n stream conjoined. This is a terminal operation on the stream.", kw_file, "glojure/core.glj", kw_added, "1.12", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(6810), kw_end_DASH_line, int(6810))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp6 := reflect.TypeOf((*lang.IEditableCollection)(nil)).Elem() + tmp7 := lang.Apply(tmp5, []any{tmp6, v2}) + if lang.IsTruthy(tmp7) { + tmp8 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp9 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp10 := checkDerefVar(var_glojure_DOT_core_stream_DASH_reduce_BANG_) + tmp11 := checkDerefVar(var_glojure_DOT_core_conj_BANG_) + tmp12 := checkDerefVar(var_glojure_DOT_core_transient) + tmp13 := lang.Apply(tmp12, []any{v2}) + tmp14 := lang.Apply(tmp10, []any{tmp11, tmp13, v3}) + tmp15 := lang.Apply(tmp9, []any{tmp14}) + tmp16 := checkDerefVar(var_glojure_DOT_core_meta) + tmp17 := lang.Apply(tmp16, []any{v2}) + tmp18 := lang.Apply(tmp8, []any{tmp15, tmp17}) + tmp4 = tmp18 + } else { + tmp19 := checkDerefVar(var_glojure_DOT_core_stream_DASH_reduce_BANG_) + tmp20 := checkDerefVar(var_glojure_DOT_core_conj) + tmp21 := lang.Apply(tmp19, []any{tmp20, v2, v3}) + tmp4 = tmp21 + } + return tmp4 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp7 := reflect.TypeOf((*lang.IEditableCollection)(nil)).Elem() + tmp8 := lang.Apply(tmp6, []any{tmp7, v2}) + if lang.IsTruthy(tmp8) { + tmp9 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp10 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp11 := checkDerefVar(var_glojure_DOT_core_stream_DASH_transduce_BANG_) + tmp12 := checkDerefVar(var_glojure_DOT_core_conj_BANG_) + tmp13 := checkDerefVar(var_glojure_DOT_core_transient) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(tmp11, []any{v3, tmp12, tmp14, v4}) + tmp16 := lang.Apply(tmp10, []any{tmp15}) + tmp17 := checkDerefVar(var_glojure_DOT_core_meta) + tmp18 := lang.Apply(tmp17, []any{v2}) + tmp19 := lang.Apply(tmp9, []any{tmp16, tmp18}) + tmp5 = tmp19 + } else { + tmp20 := checkDerefVar(var_glojure_DOT_core_stream_DASH_transduce_BANG_) + tmp21 := checkDerefVar(var_glojure_DOT_core_conj) + tmp22 := lang.Apply(tmp20, []any{v3, tmp21, v2, v4}) + tmp5 = tmp22 + } + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_stream_DASH_into_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_stream_DASH_into_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // subvec + { + tmp0 := sym_subvec.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_v, sym_start), lang.NewVector(sym_v, sym_start, sym_end)), kw_doc, "Returns a persistent vector of the items in vector from\n start (inclusive) to end (exclusive). If end is not supplied,\n defaults to (count vector). This operation is O(1) and very fast, as\n the resulting vector shares structure with the original and no\n trimming is done.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(3819), kw_end_DASH_line, int(3819))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_subvec) + tmp5 := checkDerefVar(var_glojure_DOT_core_count) + tmp6 := lang.Apply(tmp5, []any{v2}) + tmp7 := lang.Apply(tmp4, []any{v2, v3, tmp6}) + return tmp7 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5, _ := lang.FieldOrMethod(runtime.RT, "Subvec") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Subvec is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v2, v3, v4}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_subvec = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_subvec.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // symbol + { + tmp1 := reflect.TypeOf((*lang.Symbol)(nil)) + tmp0 := sym_symbol.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_name), lang.NewVector(sym_ns, sym_name)), kw_doc, "Returns a Symbol with the given namespace and name. Arity-1 works\n on strings, keywords, and vars.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(584), kw_end_DASH_line, int(584))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + tmp4 = v3 + } else { + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp9 := lang.Apply(tmp8, []any{lang.Builtins["string"], v3}) + if lang.IsTruthy(tmp9) { + tmp10 := lang.Apply(lang.NewSymbol, []any{v3}) + tmp7 = tmp10 + } else { + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp13 := reflect.TypeOf((*lang.Var)(nil)) + tmp14 := lang.Apply(tmp12, []any{tmp13, v3}) + if lang.IsTruthy(tmp14) { + tmp15, ok := lang.FieldOrMethod(v3, "toSymbol") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "toSymbol"))) + } + var tmp16 any + switch reflect.TypeOf(tmp15).Kind() { + case reflect.Func: + tmp16 = lang.Apply(tmp15, nil) + default: + tmp16 = tmp15 + } + tmp11 = tmp16 + } else { + var tmp17 any + tmp18 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp19 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() + tmp20 := lang.Apply(tmp18, []any{tmp19, v3}) + if lang.IsTruthy(tmp20) { + tmp21, ok := lang.FieldOrMethod(v3, "sym") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "sym"))) + } + var tmp22 any + switch reflect.TypeOf(tmp21).Kind() { + case reflect.Func: + tmp22 = lang.Apply(tmp21, nil) + default: + tmp22 = tmp21 + } + tmp17 = tmp22 + } else { + var tmp23 any + if lang.IsTruthy(kw_else) { + tmp24 := lang.Apply(lang.NewIllegalArgumentError, []any{"no conversion to symbol"}) + panic(tmp24) + } else { + } + tmp17 = tmp23 + } + tmp11 = tmp17 + } + tmp7 = tmp11 + } + tmp4 = tmp7 + } + return tmp4 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(lang.InternSymbol, []any{v3, v4}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp3 := reflect.TypeOf((*lang.Symbol)(nil)) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_symbol = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_symbol.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // thread-bound? + { + tmp0 := sym_thread_DASH_bound_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_vars)), kw_doc, "Returns true if all of the vars provided as arguments have thread-local bindings.\n Implies that set!'ing the provided vars will succeed. Returns true if no vars are provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(5499), kw_end_DASH_line, int(5499))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v5 := args[0] + _ = v5 + tmp6, ok := lang.FieldOrMethod(v5, "getThreadBinding") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "getThreadBinding"))) + } + var tmp7 any + switch reflect.TypeOf(tmp6).Kind() { + case reflect.Func: + tmp7 = lang.Apply(tmp6, nil) + default: + tmp7 = tmp6 + } + return tmp7 + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5505), kw_column, int(11), kw_end_DASH_line, int(5505), kw_end_DASH_column, int(78)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp7 := lang.Apply(tmp3, []any{tmp6, v2}) + return tmp7 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_thread_DASH_bound_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_thread_DASH_bound_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // type + { + tmp0 := sym_type.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns the :type metadata of x, or its Class if none", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3467), kw_end_DASH_line, int(3467))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "or__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_get) + tmp5 := checkDerefVar(var_glojure_DOT_core_meta) + tmp6 := lang.Apply(tmp5, []any{v2}) + tmp7 := lang.Apply(tmp4, []any{tmp6, kw_type}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + tmp9 = v8 + } else { + tmp10 := checkDerefVar(var_glojure_DOT_core_class) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp9 = tmp11 + } + tmp3 = tmp9 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_type = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_type.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-add + { + var tmp1 lang.FnFunc + { // function unchecked-add__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_UncheckedAdd}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_add.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Returns the sum of x and y, both long.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(1203), kw_end_DASH_line, int(1203))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedAdd") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedAdd is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_add = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_add.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-add-int + { + var tmp1 lang.FnFunc + { // function unchecked-add-int__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_add}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_add_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Returns the sum of x and y, both int.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(7), kw_line, int(1196), kw_end_DASH_line, int(1196))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_add") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_add is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_add_DASH_int = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_add_DASH_int.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-byte + { + var tmp1 lang.FnFunc + { // function unchecked-byte__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedByteCast}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_byte.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to byte. Subject to rounding or truncation.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(3517), kw_end_DASH_line, int(3517))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.UncheckedByteCast, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_byte = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_byte.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-char + { + var tmp1 lang.FnFunc + { // function unchecked-char__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedCharCast}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_char.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to char. Subject to rounding or truncation.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(3529), kw_end_DASH_line, int(3529))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(runtime.RT, "UncheckedCharCast") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedCharCast is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_char = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_char.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-dec + { + var tmp1 lang.FnFunc + { // function unchecked-dec__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedDec}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_dec.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns a number one less than x, a long.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(1175), kw_end_DASH_line, int(1175))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedDec") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedDec is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_dec = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_dec.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-dec-int + { + var tmp1 lang.FnFunc + { // function unchecked-dec-int__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_dec}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_dec_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns a number one less than x, an int.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(7), kw_line, int(1168), kw_end_DASH_line, int(1168))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_dec") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_dec is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_dec_DASH_int = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_dec_DASH_int.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-divide-int + { + var tmp1 lang.FnFunc + { // function unchecked-divide-int__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_UncheckedIntDivide}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_divide_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Returns the division of x by y, both int.\n Note - uses a primitive operator subject to truncation.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(26), kw_column, int(7), kw_line, int(1238), kw_end_DASH_line, int(1238))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedIntDivide") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedIntDivide is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_divide_DASH_int = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_divide_DASH_int.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-double + { + var tmp1 lang.FnFunc + { // function unchecked-double__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedDoubleCast}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_double.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to double. Subject to rounding.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(22), kw_column, int(7), kw_line, int(3553), kw_end_DASH_line, int(3553))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.AsFloat64, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_double = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_double.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-float + { + var tmp1 lang.FnFunc + { // function unchecked-float__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedFloatCast}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_float.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to float. Subject to rounding.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(3547), kw_end_DASH_line, int(3547))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.UncheckedFloatCast, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_float = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_float.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-inc + { + var tmp1 lang.FnFunc + { // function unchecked-inc__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Unchecked_inc}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_inc.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns a number one greater than x, a long.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(1161), kw_end_DASH_line, int(1161))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_inc") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_inc is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_inc = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_inc.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-inc-int + { + var tmp1 lang.FnFunc + { // function unchecked-inc-int__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_inc}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_inc_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns a number one greater than x, an int.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(7), kw_line, int(1154), kw_end_DASH_line, int(1154))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_inc") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_inc is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_inc_DASH_int = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_inc_DASH_int.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-int + { + var tmp1 lang.FnFunc + { // function unchecked-int__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedIntCast}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to int. Subject to rounding or truncation.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(3535), kw_end_DASH_line, int(3535))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.UncheckedIntCast, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_int = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_int.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-long + { + var tmp1 lang.FnFunc + { // function unchecked-long__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedLongCast}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_long.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to long. Subject to rounding or truncation.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(3541), kw_end_DASH_line, int(3541))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.UncheckedLongCast, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_long = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_long.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-multiply + { + var tmp1 lang.FnFunc + { // function unchecked-multiply__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_multiply}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_multiply.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Returns the product of x and y, both long.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(24), kw_column, int(7), kw_line, int(1231), kw_end_DASH_line, int(1231))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_multiply") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_multiply is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_multiply = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_multiply.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-multiply-int + { + var tmp1 lang.FnFunc + { // function unchecked-multiply-int__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_multiply}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_multiply_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Returns the product of x and y, both int.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(28), kw_column, int(7), kw_line, int(1224), kw_end_DASH_line, int(1224))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_multiply") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_multiply is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_multiply_DASH_int = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_multiply_DASH_int.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-negate + { + var tmp1 lang.FnFunc + { // function unchecked-negate__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Unchecked_minus}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_negate.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns the negation of x, a long.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(22), kw_column, int(7), kw_line, int(1189), kw_end_DASH_line, int(1189))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_negate") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_negate is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_negate = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_negate.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-negate-int + { + var tmp1 lang.FnFunc + { // function unchecked-negate-int__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_negate}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_negate_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns the negation of x, an int.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(26), kw_column, int(7), kw_line, int(1182), kw_end_DASH_line, int(1182))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_negate") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_negate is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_negate_DASH_int = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_negate_DASH_int.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-remainder-int + { + var tmp1 lang.FnFunc + { // function unchecked-remainder-int__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_remainder}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_remainder_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Returns the remainder of division of x by y, both int.\n Note - uses a primitive operator subject to truncation.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(29), kw_column, int(7), kw_line, int(1245), kw_end_DASH_line, int(1245))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_remainder") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_remainder is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_remainder_DASH_int = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_remainder_DASH_int.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-short + { + var tmp1 lang.FnFunc + { // function unchecked-short__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedShortCast}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_short.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to short. Subject to rounding or truncation.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(3523), kw_end_DASH_line, int(3523))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.UncheckedShortCast, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_short = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_short.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-subtract + { + var tmp1 lang.FnFunc + { // function unchecked-subtract__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_minus}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_subtract.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Returns the difference of x and y, both long.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(24), kw_column, int(7), kw_line, int(1217), kw_end_DASH_line, int(1217))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_minus") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_minus is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_subtract = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_subtract.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-subtract-int + { + var tmp1 lang.FnFunc + { // function unchecked-subtract-int__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_subtract}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_subtract_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Returns the difference of x and y, both int.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(28), kw_column, int(7), kw_line, int(1210), kw_end_DASH_line, int(1210))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_subtract") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_subtract is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_subtract_DASH_int = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_subtract_DASH_int.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unreduced + { + tmp0 := sym_unreduced.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "If x is reduced?, returns (deref x), else returns x", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(2847), kw_end_DASH_line, int(2847))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + tmp6 := checkDerefVar(var_glojure_DOT_core_deref) + tmp7 := lang.Apply(tmp6, []any{v2}) + tmp3 = tmp7 + } else { + tmp3 = v2 + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unreduced = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unreduced.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unsigned-bit-shift-right + { + var tmp1 lang.FnFunc + { // function unsigned-bit-shift-right__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_UnsignedShiftRight}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unsigned_DASH_bit_DASH_shift_DASH_right.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_n)), kw_inline, tmp1, kw_doc, "Bitwise shift right, without sign-extension.", kw_file, "glojure/core.glj", kw_added, "1.6", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(30), kw_column, int(7), kw_line, int(1373), kw_end_DASH_line, int(1373))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "UnsignedShiftRight") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("UnsignedShiftRight is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unsigned_DASH_bit_DASH_shift_DASH_right = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unsigned_DASH_bit_DASH_shift_DASH_right.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // vec + { + tmp0 := sym_vec.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Creates a new vector containing the contents of coll. Java arrays\n will be aliased and should not be modified.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(366), kw_end_DASH_line, int(366))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp8 := reflect.TypeOf((*lang.IObj)(nil)).Elem() + tmp9 := lang.Apply(tmp7, []any{tmp8, v2}) + if lang.IsTruthy(tmp9) { + tmp10 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp11 := lang.Apply(tmp10, []any{v2, nil}) + tmp6 = tmp11 + } else { + tmp12 := lang.Apply(lang.CreateLazilyPersistentVector, []any{v2}) + tmp6 = tmp12 + } + tmp3 = tmp6 + } else { + tmp13 := lang.Apply(lang.CreateLazilyPersistentVector, []any{v2}) + tmp3 = tmp13 + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_vec = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_vec.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // vswap! + { + tmp0 := sym_vswap_BANG_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_vol, sym_f, sym__AMP_, sym_args)), kw_doc, "Non-atomically swaps the value of the volatile as if:\n (apply f current-value-of-vol args). Returns the value that\n was swapped in.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(11), kw_line, int(2531), kw_end_DASH_line, int(2531))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var v6 any = lang.NewList(args[4:]...) + _ = v6 + var tmp7 any + { // let + // let binding "v" + tmp8 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp9 := lang.NewMap(kw_tag, sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Volatile) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2537), kw_column, int(26), kw_end_DASH_line, int(2537), kw_end_DASH_column, int(81)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp12 := lang.Apply(tmp8, []any{v4, tmp11}) + var v13 any = tmp12 + _ = v13 + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{sym__DOT_reset}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v13}) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := checkDerefVar(var_glojure_DOT_core_seq) + tmp22 := checkDerefVar(var_glojure_DOT_core_concat) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := lang.Apply(tmp23, []any{v5}) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := checkDerefVar(var_glojure_DOT_core_seq) + tmp27 := checkDerefVar(var_glojure_DOT_core_concat) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := lang.Apply(tmp28, []any{sym__DOT_Deref}) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := lang.Apply(tmp30, []any{v13}) + tmp32 := lang.Apply(tmp27, []any{tmp29, tmp31}) + tmp33 := lang.Apply(tmp26, []any{tmp32}) + tmp34 := lang.Apply(tmp25, []any{tmp33}) + tmp35 := lang.Apply(tmp22, []any{tmp24, tmp34, v6}) + tmp36 := lang.Apply(tmp21, []any{tmp35}) + tmp37 := lang.Apply(tmp20, []any{tmp36}) + tmp38 := lang.Apply(tmp15, []any{tmp17, tmp19, tmp37}) + tmp39 := lang.Apply(tmp14, []any{tmp38}) + tmp7 = tmp39 + } // end let + return tmp7 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_vswap_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_vswap_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // zero? + { + var tmp1 lang.FnFunc + { // function zero?__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_IsZero}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_zero_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_num)), kw_inline, tmp1, kw_doc, "Returns true if num is zero, else false", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(860), kw_end_DASH_line, int(860))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "IsZero") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("IsZero is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_zero_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_zero_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // zipmap + { + tmp0 := sym_zipmap.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_keys, sym_vals)), kw_doc, "Returns a map with the keys mapped to the corresponding vals.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(6583), kw_end_DASH_line, int(6583))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "map" + tmp5 := checkDerefVar(var_glojure_DOT_core_transient) + tmp6 := lang.NewMap() + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6588), kw_column, int(27), kw_end_DASH_line, int(6588), kw_end_DASH_column, int(28)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp9 := lang.Apply(tmp5, []any{tmp8}) + var v10 any = tmp9 + _ = v10 + // let binding "ks" + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := lang.Apply(tmp11, []any{v2}) + var v13 any = tmp12 + _ = v13 + // let binding "vs" + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := lang.Apply(tmp14, []any{v3}) + var v16 any = tmp15 + _ = v16 + for { + var tmp17 any + var tmp18 any + { // let + // let binding "and__0__auto__" + var v19 any = v13 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + tmp20 = v16 + } else { + tmp20 = v19 + } + tmp18 = tmp20 + } // end let + if lang.IsTruthy(tmp18) { + tmp20 := checkDerefVar(var_glojure_DOT_core_assoc_BANG_) + tmp21 := checkDerefVar(var_glojure_DOT_core_first) + tmp22 := lang.Apply(tmp21, []any{v13}) + tmp23 := checkDerefVar(var_glojure_DOT_core_first) + tmp24 := lang.Apply(tmp23, []any{v16}) + tmp25 := lang.Apply(tmp20, []any{v10, tmp22, tmp24}) + var tmp19 any = tmp25 + tmp27 := checkDerefVar(var_glojure_DOT_core_next) + tmp28 := lang.Apply(tmp27, []any{v13}) + var tmp26 any = tmp28 + tmp30 := checkDerefVar(var_glojure_DOT_core_next) + tmp31 := lang.Apply(tmp30, []any{v16}) + var tmp29 any = tmp31 + v10 = tmp19 + v13 = tmp26 + v16 = tmp29 + continue + } else { + tmp32 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp33 := lang.Apply(tmp32, []any{v10}) + tmp17 = tmp33 + } + tmp4 = tmp17 + break + } + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_zipmap = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_zipmap.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // NaN? + { + var tmp1 lang.FnFunc + { // function NaN?__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym_math_DOT_IsNaN}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{v3}) + tmp10 := lang.Apply(tmp5, []any{tmp7, tmp9}) + tmp11 := lang.Apply(tmp4, []any{tmp10}) + return tmp11 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_NaN_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_num)), kw_inline, tmp1, kw_doc, "Returns true if num is NaN, else false", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1)})), kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(7968), kw_end_DASH_line, int(7968))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(math4.IsNaN, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_NaN_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_NaN_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // StackTraceElement->vec + { + tmp0 := sym_StackTraceElement_DASH__GT_vec.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_o)), kw_doc, "Constructs a data representation for a StackTraceElement: [class method file line]", kw_file, "glojure/core_print.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(28), kw_column, int(7), kw_line, int(436), kw_end_DASH_line, int(436))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_symbol) + tmp4, ok := lang.FieldOrMethod(v2, "getClassName") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getClassName"))) + } + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { + case reflect.Func: + tmp5 = lang.Apply(tmp4, nil) + default: + tmp5 = tmp4 + } + tmp6 := lang.Apply(tmp3, []any{tmp5}) + tmp7 := checkDerefVar(var_glojure_DOT_core_symbol) + tmp8, ok := lang.FieldOrMethod(v2, "getMethodName") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getMethodName"))) + } + var tmp9 any + switch reflect.TypeOf(tmp8).Kind() { + case reflect.Func: + tmp9 = lang.Apply(tmp8, nil) + default: + tmp9 = tmp8 + } + tmp10 := lang.Apply(tmp7, []any{tmp9}) + tmp11, ok := lang.FieldOrMethod(v2, "getFileName") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getFileName"))) + } + var tmp12 any + switch reflect.TypeOf(tmp11).Kind() { + case reflect.Func: + tmp12 = lang.Apply(tmp11, nil) + default: + tmp12 = tmp11 + } + tmp13, ok := lang.FieldOrMethod(v2, "getLineNumber") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getLineNumber"))) + } + var tmp14 any + switch reflect.TypeOf(tmp13).Kind() { + case reflect.Func: + tmp14 = lang.Apply(tmp13, nil) + default: + tmp14 = tmp13 + } + tmp15 := lang.NewVector(tmp6, tmp10, tmp12, tmp14) + tmp16 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(440), kw_column, int(3), kw_end_DASH_line, int(440), kw_end_DASH_column, int(94)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp17 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_StackTraceElement_DASH__GT_vec = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_StackTraceElement_DASH__GT_vec.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // -> + { + tmp0 := sym__DASH__GT_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_x, sym__AMP_, sym_forms)), kw_doc, "Threads the expr through the forms. Inserts x as the\n second item in the first form, making a list of it if it is not a\n list already. If there are more forms, inserts the first form as the\n second item in second form, etc.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(11), kw_line, int(1675), kw_end_DASH_line, int(1675))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "x" + var v7 any = v4 + _ = v7 + // let binding "forms" + var v8 any = v5 + _ = v8 + for { + var tmp9 any + if lang.IsTruthy(v8) { + var tmp10 any + { // let + // let binding "form" + tmp11 := checkDerefVar(var_glojure_DOT_core_first) + tmp12 := lang.Apply(tmp11, []any{v8}) + var v13 any = tmp12 + _ = v13 + // let binding "threaded" + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp16 := lang.Apply(tmp15, []any{v13}) + if lang.IsTruthy(tmp16) { + tmp17 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := checkDerefVar(var_glojure_DOT_core_first) + tmp22 := lang.Apply(tmp21, []any{v13}) + tmp23 := lang.Apply(tmp20, []any{tmp22}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v7}) + tmp26 := checkDerefVar(var_glojure_DOT_core_next) + tmp27 := lang.Apply(tmp26, []any{v13}) + tmp28 := lang.Apply(tmp19, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp18, []any{tmp28}) + tmp30 := checkDerefVar(var_glojure_DOT_core_meta) + tmp31 := lang.Apply(tmp30, []any{v13}) + tmp32 := lang.Apply(tmp17, []any{tmp29, tmp31}) + tmp14 = tmp32 + } else { + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{v13, v7}) + tmp14 = tmp34 + } + var v35 any = tmp14 + _ = v35 + var tmp36 any = v35 + tmp38 := checkDerefVar(var_glojure_DOT_core_next) + tmp39 := lang.Apply(tmp38, []any{v8}) + var tmp37 any = tmp39 + v7 = tmp36 + v8 = tmp37 + continue + } // end let + tmp9 = tmp10 + } else { + tmp9 = v7 + } + tmp6 = tmp9 + break + } + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__DASH__GT_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__DASH__GT_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ->> + { + tmp0 := sym__DASH__GT__GT_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_x, sym__AMP_, sym_forms)), kw_doc, "Threads the expr through the forms. Inserts x as the\n last item in the first form, making a list of it if it is not a\n list already. If there are more forms, inserts the first form as the\n last item in second form, etc.", kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(11), kw_line, int(1691), kw_end_DASH_line, int(1691))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "x" + var v7 any = v4 + _ = v7 + // let binding "forms" + var v8 any = v5 + _ = v8 + for { + var tmp9 any + if lang.IsTruthy(v8) { + var tmp10 any + { // let + // let binding "form" + tmp11 := checkDerefVar(var_glojure_DOT_core_first) + tmp12 := lang.Apply(tmp11, []any{v8}) + var v13 any = tmp12 + _ = v13 + // let binding "threaded" + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp16 := lang.Apply(tmp15, []any{v13}) + if lang.IsTruthy(tmp16) { + tmp17 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := checkDerefVar(var_glojure_DOT_core_first) + tmp22 := lang.Apply(tmp21, []any{v13}) + tmp23 := lang.Apply(tmp20, []any{tmp22}) + tmp24 := checkDerefVar(var_glojure_DOT_core_next) + tmp25 := lang.Apply(tmp24, []any{v13}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v7}) + tmp28 := lang.Apply(tmp19, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp18, []any{tmp28}) + tmp30 := checkDerefVar(var_glojure_DOT_core_meta) + tmp31 := lang.Apply(tmp30, []any{v13}) + tmp32 := lang.Apply(tmp17, []any{tmp29, tmp31}) + tmp14 = tmp32 + } else { + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{v13, v7}) + tmp14 = tmp34 + } + var v35 any = tmp14 + _ = v35 + var tmp36 any = v35 + tmp38 := checkDerefVar(var_glojure_DOT_core_next) + tmp39 := lang.Apply(tmp38, []any{v8}) + var tmp37 any = tmp39 + v7 = tmp36 + v8 = tmp37 + continue + } // end let + tmp9 = tmp10 + } else { + tmp9 = v7 + } + tmp6 = tmp9 + break + } + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__DASH__GT__GT_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__DASH__GT__GT_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // .. + { + tmp0 := sym__DOT__DOT_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_form), lang.NewVector(sym_x, sym_form, sym__AMP_, sym_more)), kw_doc, "form => fieldName-symbol or (instanceMethodName-symbol args*)\n\n Expands into a member access (.) of the first member on the first\n argument, followed by the next member on the result, etc. For\n instance:\n\n (.. System (getProperties) (get \"os.name\"))\n\n expands to:\n\n (. (. System (getProperties)) (get \"os.name\"))\n\n but is easier to write, read, and understand.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(11), kw_line, int(1657), kw_end_DASH_line, int(1657))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym__DOT_}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{v4}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v5}) + tmp14 := lang.Apply(tmp7, []any{tmp9, tmp11, tmp13}) + tmp15 := lang.Apply(tmp6, []any{tmp14}) + return tmp15 + default: + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var v6 any = lang.NewList(args[4:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym__DOT_}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v4}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v5}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp22, v6}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + return tmp24 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__DOT__DOT_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__DOT__DOT_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // = + { + var tmp1 lang.FnFunc + { // function =__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_lang_DOT_Util}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_glojure_DOT_core_SLASH_equiv}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{v3}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v4}) + tmp17 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp12, tmp14, tmp16}) + tmp18 := lang.Apply(tmp5, []any{tmp17}) + return tmp18 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym__EQ_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Equality. Returns true if x equals y, false if not. Same as\n Java x.equals(y) except it also works for nil, and compares\n numbers and collections in a type-independent manner. Clojure's immutable data\n structures define equals() (and thus =) as a value, not an identity,\n comparison.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(7), kw_line, int(776), kw_end_DASH_line, int(776))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + return true + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(lang.Equiv, []any{v3, v4}) + return tmp5 + default: + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + recur_loop_1666: + var tmp6 any + tmp7 := lang.Apply(lang.Equiv, []any{v3, v4}) + if lang.IsTruthy(tmp7) { + var tmp8 any + tmp9 := checkDerefVar(var_glojure_DOT_core_next) + tmp10 := lang.Apply(tmp9, []any{v5}) + if lang.IsTruthy(tmp10) { + var tmp11 any = v4 + tmp13 := checkDerefVar(var_glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v5}) + var tmp12 any = tmp14 + tmp16 := checkDerefVar(var_glojure_DOT_core_next) + tmp17 := lang.Apply(tmp16, []any{v5}) + var tmp15 any = tmp17 + v3 = tmp11 + v4 = tmp12 + v5 = tmp15 + goto recur_loop_1666 + } else { + tmp18 := checkDerefVar(var_glojure_DOT_core_first) + tmp19 := lang.Apply(tmp18, []any{v5}) + tmp20 := lang.Apply(lang.Equiv, []any{v4, tmp19}) + tmp8 = tmp20 + } + tmp6 = tmp8 + } else { + tmp6 = false + } + return tmp6 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__EQ_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__EQ_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // == + { + var tmp1 lang.FnFunc + { // function ==__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Equiv}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym__EQ__EQ_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns non-nil if nums all have the equivalent\n value (type-independent), otherwise false", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(7), kw_line, int(1093), kw_end_DASH_line, int(1093))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + return true + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Equiv") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Equiv is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + default: + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + recur_loop_1746: + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__EQ__EQ_) + tmp8 := lang.Apply(tmp7, []any{v3, v4}) + if lang.IsTruthy(tmp8) { + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_next) + tmp11 := lang.Apply(tmp10, []any{v5}) + if lang.IsTruthy(tmp11) { + var tmp12 any = v4 + tmp14 := checkDerefVar(var_glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v5}) + var tmp13 any = tmp15 + tmp17 := checkDerefVar(var_glojure_DOT_core_next) + tmp18 := lang.Apply(tmp17, []any{v5}) + var tmp16 any = tmp18 + v3 = tmp12 + v4 = tmp13 + v5 = tmp16 + goto recur_loop_1746 + } else { + tmp19 := checkDerefVar(var_glojure_DOT_core__EQ__EQ_) + tmp20 := checkDerefVar(var_glojure_DOT_core_first) + tmp21 := lang.Apply(tmp20, []any{v5}) + tmp22 := lang.Apply(tmp19, []any{v4, tmp21}) + tmp9 = tmp22 + } + tmp6 = tmp9 + } else { + tmp6 = false + } + return tmp6 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__EQ__EQ_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__EQ__EQ_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // > + { + var tmp1 lang.FnFunc + { // function >__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Gt}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym__GT_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns non-nil if nums are in monotonically decreasing order,\n otherwise false.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(7), kw_line, int(1063), kw_end_DASH_line, int(1063))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + return true + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + default: + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + recur_loop_1738: + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__GT_) + tmp8 := lang.Apply(tmp7, []any{v3, v4}) + if lang.IsTruthy(tmp8) { + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_next) + tmp11 := lang.Apply(tmp10, []any{v5}) + if lang.IsTruthy(tmp11) { + var tmp12 any = v4 + tmp14 := checkDerefVar(var_glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v5}) + var tmp13 any = tmp15 + tmp17 := checkDerefVar(var_glojure_DOT_core_next) + tmp18 := lang.Apply(tmp17, []any{v5}) + var tmp16 any = tmp18 + v3 = tmp12 + v4 = tmp13 + v5 = tmp16 + goto recur_loop_1738 + } else { + tmp19 := checkDerefVar(var_glojure_DOT_core__GT_) + tmp20 := checkDerefVar(var_glojure_DOT_core_first) + tmp21 := lang.Apply(tmp20, []any{v5}) + tmp22 := lang.Apply(tmp19, []any{v4, tmp21}) + tmp9 = tmp22 + } + tmp6 = tmp9 + } else { + tmp6 = false + } + return tmp6 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__GT_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__GT_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // >= + { + var tmp1 lang.FnFunc + { // function >=__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Gte}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym__GT__EQ_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns non-nil if nums are in monotonically non-increasing order,\n otherwise false.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(7), kw_line, int(1078), kw_end_DASH_line, int(1078))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + return true + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Gte") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gte is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + default: + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + recur_loop_1742: + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__GT__EQ_) + tmp8 := lang.Apply(tmp7, []any{v3, v4}) + if lang.IsTruthy(tmp8) { + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_next) + tmp11 := lang.Apply(tmp10, []any{v5}) + if lang.IsTruthy(tmp11) { + var tmp12 any = v4 + tmp14 := checkDerefVar(var_glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v5}) + var tmp13 any = tmp15 + tmp17 := checkDerefVar(var_glojure_DOT_core_next) + tmp18 := lang.Apply(tmp17, []any{v5}) + var tmp16 any = tmp18 + v3 = tmp12 + v4 = tmp13 + v5 = tmp16 + goto recur_loop_1742 + } else { + tmp19 := checkDerefVar(var_glojure_DOT_core__GT__EQ_) + tmp20 := checkDerefVar(var_glojure_DOT_core_first) + tmp21 := lang.Apply(tmp20, []any{v5}) + tmp22 := lang.Apply(tmp19, []any{v4, tmp21}) + tmp9 = tmp22 + } + tmp6 = tmp9 + } else { + tmp6 = false + } + return tmp6 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__GT__EQ_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__GT__EQ_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // < + { + var tmp1 lang.FnFunc + { // function <__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Lt}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym__LT_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns non-nil if nums are in monotonically increasing order,\n otherwise false.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(7), kw_line, int(893), kw_end_DASH_line, int(893))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + return true + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Lt") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Lt is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + default: + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + recur_loop_1690: + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp8 := lang.Apply(tmp7, []any{v3, v4}) + if lang.IsTruthy(tmp8) { + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_next) + tmp11 := lang.Apply(tmp10, []any{v5}) + if lang.IsTruthy(tmp11) { + var tmp12 any = v4 + tmp14 := checkDerefVar(var_glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v5}) + var tmp13 any = tmp15 + tmp17 := checkDerefVar(var_glojure_DOT_core_next) + tmp18 := lang.Apply(tmp17, []any{v5}) + var tmp16 any = tmp18 + v3 = tmp12 + v4 = tmp13 + v5 = tmp16 + goto recur_loop_1690 + } else { + tmp19 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp20 := checkDerefVar(var_glojure_DOT_core_first) + tmp21 := lang.Apply(tmp20, []any{v5}) + tmp22 := lang.Apply(tmp19, []any{v4, tmp21}) + tmp9 = tmp22 + } + tmp6 = tmp9 + } else { + tmp6 = false + } + return tmp6 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__LT_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__LT_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // <= + { + var tmp1 lang.FnFunc + { // function <=__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Lte}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym__LT__EQ_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns non-nil if nums are in monotonically non-decreasing order,\n otherwise false.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(7), kw_line, int(1048), kw_end_DASH_line, int(1048))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + return true + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Lte") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Lte is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + default: + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + recur_loop_1734: + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__LT__EQ_) + tmp8 := lang.Apply(tmp7, []any{v3, v4}) + if lang.IsTruthy(tmp8) { + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_next) + tmp11 := lang.Apply(tmp10, []any{v5}) + if lang.IsTruthy(tmp11) { + var tmp12 any = v4 + tmp14 := checkDerefVar(var_glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v5}) + var tmp13 any = tmp15 + tmp17 := checkDerefVar(var_glojure_DOT_core_next) + tmp18 := lang.Apply(tmp17, []any{v5}) + var tmp16 any = tmp18 + v3 = tmp12 + v4 = tmp13 + v5 = tmp16 + goto recur_loop_1734 + } else { + tmp19 := checkDerefVar(var_glojure_DOT_core__LT__EQ_) + tmp20 := checkDerefVar(var_glojure_DOT_core_first) + tmp21 := lang.Apply(tmp20, []any{v5}) + tmp22 := lang.Apply(tmp19, []any{v4, tmp21}) + tmp9 = tmp22 + } + tmp6 = tmp9 + } else { + tmp6 = false + } + return tmp6 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__LT__EQ_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__LT__EQ_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // + + { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed3 + } else { + tmp4 = closed4 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed3 + } else { + tmp5 = closed4 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed3 + } else { + tmp6 = closed4 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym__PLUS_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns the sum of nums. (+) returns 0. Does not auto-promote\n longs, will throw on overflow. See also: +'", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(7), kw_line, int(977), kw_end_DASH_line, int(977))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return int64(0) + case 1: + v4 := args[0] + _ = v4 + tmp5 := lang.Apply(lang.MustAsNumber, []any{v4}) + return tmp5 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Add") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Add is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp8 := checkDerefVar(var_glojure_DOT_core__PLUS_) + tmp9 := checkDerefVar(var_glojure_DOT_core__PLUS_) + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) + return tmp11 + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__PLUS_ = ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__PLUS_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // +' + { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed5 + } else { + tmp4 = closed5 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed5 + } else { + tmp5 = closed5 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed5 + } else { + tmp6 = closed5 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym__PLUS__TICK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns the sum of nums. (+') returns 0. Supports arbitrary precision.\n See also: +", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(7), kw_line, int(965), kw_end_DASH_line, int(965))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return int64(0) + case 1: + v4 := args[0] + _ = v4 + tmp5 := lang.Apply(lang.MustAsNumber, []any{v4}) + return tmp5 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "AddP") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("AddP is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp8 := checkDerefVar(var_glojure_DOT_core__PLUS__TICK_) + tmp9 := checkDerefVar(var_glojure_DOT_core__PLUS__TICK_) + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) + return tmp11 + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__PLUS__TICK_ = ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__PLUS__TICK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // / + { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed17 + } else { + tmp4 = closed17 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed17 + } else { + tmp5 = closed17 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed17 + } else { + tmp6 = closed17 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym__SLASH_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "If no denominators are supplied, returns 1/numerator,\n else returns numerator divided by all of the denominators.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(7), kw_line, int(1013), kw_end_DASH_line, int(1013))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core__SLASH_) + tmp6 := lang.Apply(tmp5, []any{int64(1), v4}) + return tmp6 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Divide") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Divide is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp8 := checkDerefVar(var_glojure_DOT_core__SLASH_) + tmp9 := checkDerefVar(var_glojure_DOT_core__SLASH_) + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) + return tmp11 + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__SLASH_ = ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__SLASH_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // * + { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed0 + } else { + tmp4 = closed1 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed0 + } else { + tmp5 = closed1 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed0 + } else { + tmp6 = closed1 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym__STAR_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns the product of nums. (*) returns 1. Does not auto-promote\n longs, will throw on overflow. See also: *'", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(7), kw_line, int(1001), kw_end_DASH_line, int(1001))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return int64(1) + case 1: + v4 := args[0] + _ = v4 + tmp5 := lang.Apply(lang.MustAsNumber, []any{v4}) + return tmp5 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Multiply") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Multiply is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp8 := checkDerefVar(var_glojure_DOT_core__STAR_) + tmp9 := checkDerefVar(var_glojure_DOT_core__STAR_) + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) + return tmp11 + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__STAR_ = ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *' + { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed2 + } else { + tmp4 = closed2 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed2 + } else { + tmp5 = closed2 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed2 + } else { + tmp6 = closed2 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym__STAR__TICK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns the product of nums. (*') returns 1. Supports arbitrary precision.\n See also: *", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(7), kw_line, int(989), kw_end_DASH_line, int(989))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return int64(1) + case 1: + v4 := args[0] + _ = v4 + tmp5 := lang.Apply(lang.MustAsNumber, []any{v4}) + return tmp5 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "MultiplyP") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("MultiplyP is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp8 := checkDerefVar(var_glojure_DOT_core__STAR__TICK_) + tmp9 := checkDerefVar(var_glojure_DOT_core__STAR__TICK_) + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) + return tmp11 + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__STAR__TICK_ = ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR__TICK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // abs + { + var tmp1 lang.FnFunc + { // function abs__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Abs}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{v3}) + tmp10 := lang.Apply(tmp5, []any{tmp7, tmp9}) + tmp11 := lang.Apply(tmp4, []any{tmp10}) + return tmp11 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_abs.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a)), kw_inline, tmp1, kw_doc, "Returns the absolute value of a.\n If a is Long/MIN_VALUE => Long/MIN_VALUE\n If a is a double and zero => +0.0\n If a is a double and ##Inf or ##-Inf => ##Inf\n If a is a double and ##NaN => ##NaN", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1)})), kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(1128), kw_end_DASH_line, int(1128))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.Abs, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_abs = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_abs.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // aclone + { + var tmp1 lang.FnFunc + { // function aclone__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Aclone}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_aclone.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array)), kw_inline, tmp1, kw_doc, "Returns a clone of the Java array. Works on arrays of known\n types.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(3904), kw_end_DASH_line, int(3904))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(runtime.RT, "Aclone") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Aclone is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_aclone = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_aclone.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // add-doc-and-meta + { + tmp0 := sym_add_DASH_doc_DASH_and_DASH_meta.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym_docstring, sym_meta)), kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(26), kw_column, int(11), kw_line, int(6400), kw_end_DASH_line, int(6400), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 5) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_core_SLASH_alter_DASH_meta_BANG_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_var}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v4}) + tmp18 := lang.Apply(tmp13, []any{tmp15, tmp17}) + tmp19 := lang.Apply(tmp12, []any{tmp18}) + tmp20 := lang.Apply(tmp11, []any{tmp19}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{sym_glojure_DOT_core_SLASH_merge}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_seq) + tmp25 := checkDerefVar(var_glojure_DOT_core_concat) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{sym_glojure_DOT_core_SLASH_assoc}) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := lang.Apply(tmp28, []any{v6}) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := lang.Apply(tmp30, []any{kw_doc}) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := lang.Apply(tmp32, []any{v5}) + tmp34 := lang.Apply(tmp25, []any{tmp27, tmp29, tmp31, tmp33}) + tmp35 := lang.Apply(tmp24, []any{tmp34}) + tmp36 := lang.Apply(tmp23, []any{tmp35}) + tmp37 := lang.Apply(tmp8, []any{tmp10, tmp20, tmp22, tmp36}) + tmp38 := lang.Apply(tmp7, []any{tmp37}) + return tmp38 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_add_DASH_doc_DASH_and_DASH_meta = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_add_DASH_doc_DASH_and_DASH_meta.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // alength + { + var tmp1 lang.FnFunc + { // function alength__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Alength}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_alength.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array)), kw_inline, tmp1, kw_doc, "Returns the length of the Java array. Works on arrays of all\n types.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(3897), kw_end_DASH_line, int(3897))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(runtime.RT, "Alength") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Alength is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_alength = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_alength.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // apply + { + tmp0 := sym_apply.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_args), lang.NewVector(sym_f, sym_x, sym_args), lang.NewVector(sym_f, sym_x, sym_y, sym_args), lang.NewVector(sym_f, sym_x, sym_y, sym_z, sym_args), lang.NewVector(sym_f, sym_a, sym_b, sym_c, sym_d, sym__AMP_, sym_args)), kw_doc, "Applies fn f to the argument list formed by prepending intervening arguments to args.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(653), kw_end_DASH_line, int(653))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := lang.Apply(tmp4, []any{v3}) + tmp6 := lang.Apply(lang.Apply, []any{v2, tmp5}) + return tmp6 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + tmp7 := lang.Apply(lang.Apply, []any{v2, tmp6}) + return tmp7 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp7 := lang.Apply(tmp6, []any{v3, v4, v5}) + tmp8 := lang.Apply(lang.Apply, []any{v2, tmp7}) + return tmp8 + case 5: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp8 := lang.Apply(tmp7, []any{v3, v4, v5, v6}) + tmp9 := lang.Apply(lang.Apply, []any{v2, tmp8}) + return tmp9 + default: + checkArity(args, 5) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + var v7 any = lang.NewList(args[5:]...) + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_cons) + tmp9 := checkDerefVar(var_glojure_DOT_core_cons) + tmp10 := checkDerefVar(var_glojure_DOT_core_cons) + tmp11 := checkDerefVar(var_glojure_DOT_core_cons) + tmp12 := checkDerefVar(var_glojure_DOT_core_spread) + tmp13 := lang.Apply(tmp12, []any{v7}) + tmp14 := lang.Apply(tmp11, []any{v6, tmp13}) + tmp15 := lang.Apply(tmp10, []any{v5, tmp14}) + tmp16 := lang.Apply(tmp9, []any{v4, tmp15}) + tmp17 := lang.Apply(tmp8, []any{v3, tmp16}) + tmp18 := lang.Apply(lang.Apply, []any{v2, tmp17}) + return tmp18 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_apply = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_apply.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // areduce + { + tmp0 := sym_areduce.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_a, sym_idx, sym_ret, sym_init, sym_expr)), kw_doc, "Reduces an expression across an array a, using an index named idx,\n and return value named ret, initialized to init, setting ret to the \n evaluation of expr at each step, returning ret.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(5289), kw_end_DASH_line, int(5289))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 7) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + v7 := args[5] + _ = v7 + v8 := args[6] + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_seq) + tmp10 := checkDerefVar(var_glojure_DOT_core_concat) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_glojure_DOT_core_SLASH_let}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_apply) + tmp15 := checkDerefVar(var_glojure_DOT_core_vector) + tmp16 := checkDerefVar(var_glojure_DOT_core_seq) + tmp17 := checkDerefVar(var_glojure_DOT_core_concat) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{sym_a__0__auto__}) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{v4}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{sym_l__1__auto__}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := checkDerefVar(var_glojure_DOT_core_seq) + tmp26 := checkDerefVar(var_glojure_DOT_core_concat) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{sym_glojure_DOT_core_SLASH_alength}) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{sym_a__0__auto__}) + tmp31 := lang.Apply(tmp26, []any{tmp28, tmp30}) + tmp32 := lang.Apply(tmp25, []any{tmp31}) + tmp33 := lang.Apply(tmp24, []any{tmp32}) + tmp34 := lang.Apply(tmp17, []any{tmp19, tmp21, tmp23, tmp33}) + tmp35 := lang.Apply(tmp16, []any{tmp34}) + tmp36 := lang.Apply(tmp14, []any{tmp15, tmp35}) + tmp37 := lang.Apply(tmp13, []any{tmp36}) + tmp38 := checkDerefVar(var_glojure_DOT_core_list) + tmp39 := checkDerefVar(var_glojure_DOT_core_seq) + tmp40 := checkDerefVar(var_glojure_DOT_core_concat) + tmp41 := checkDerefVar(var_glojure_DOT_core_list) + tmp42 := lang.Apply(tmp41, []any{sym_glojure_DOT_core_SLASH_loop}) + tmp43 := checkDerefVar(var_glojure_DOT_core_list) + tmp44 := checkDerefVar(var_glojure_DOT_core_apply) + tmp45 := checkDerefVar(var_glojure_DOT_core_vector) + tmp46 := checkDerefVar(var_glojure_DOT_core_seq) + tmp47 := checkDerefVar(var_glojure_DOT_core_concat) + tmp48 := checkDerefVar(var_glojure_DOT_core_list) + tmp49 := lang.Apply(tmp48, []any{v5}) + tmp50 := checkDerefVar(var_glojure_DOT_core_list) + tmp51 := lang.Apply(tmp50, []any{int64(0)}) + tmp52 := checkDerefVar(var_glojure_DOT_core_list) + tmp53 := lang.Apply(tmp52, []any{v6}) + tmp54 := checkDerefVar(var_glojure_DOT_core_list) + tmp55 := lang.Apply(tmp54, []any{v7}) + tmp56 := lang.Apply(tmp47, []any{tmp49, tmp51, tmp53, tmp55}) + tmp57 := lang.Apply(tmp46, []any{tmp56}) + tmp58 := lang.Apply(tmp44, []any{tmp45, tmp57}) + tmp59 := lang.Apply(tmp43, []any{tmp58}) + tmp60 := checkDerefVar(var_glojure_DOT_core_list) + tmp61 := checkDerefVar(var_glojure_DOT_core_seq) + tmp62 := checkDerefVar(var_glojure_DOT_core_concat) + tmp63 := checkDerefVar(var_glojure_DOT_core_list) + tmp64 := lang.Apply(tmp63, []any{sym_if}) + tmp65 := checkDerefVar(var_glojure_DOT_core_list) + tmp66 := checkDerefVar(var_glojure_DOT_core_seq) + tmp67 := checkDerefVar(var_glojure_DOT_core_concat) + tmp68 := checkDerefVar(var_glojure_DOT_core_list) + tmp69 := lang.Apply(tmp68, []any{sym_glojure_DOT_core_SLASH__LT_}) + tmp70 := checkDerefVar(var_glojure_DOT_core_list) + tmp71 := lang.Apply(tmp70, []any{v5}) + tmp72 := checkDerefVar(var_glojure_DOT_core_list) + tmp73 := lang.Apply(tmp72, []any{sym_l__1__auto__}) + tmp74 := lang.Apply(tmp67, []any{tmp69, tmp71, tmp73}) + tmp75 := lang.Apply(tmp66, []any{tmp74}) + tmp76 := lang.Apply(tmp65, []any{tmp75}) + tmp77 := checkDerefVar(var_glojure_DOT_core_list) + tmp78 := checkDerefVar(var_glojure_DOT_core_seq) + tmp79 := checkDerefVar(var_glojure_DOT_core_concat) + tmp80 := checkDerefVar(var_glojure_DOT_core_list) + tmp81 := lang.Apply(tmp80, []any{sym_recur}) + tmp82 := checkDerefVar(var_glojure_DOT_core_list) + tmp83 := checkDerefVar(var_glojure_DOT_core_seq) + tmp84 := checkDerefVar(var_glojure_DOT_core_concat) + tmp85 := checkDerefVar(var_glojure_DOT_core_list) + tmp86 := lang.Apply(tmp85, []any{sym_glojure_DOT_core_SLASH_unchecked_DASH_inc_DASH_int}) + tmp87 := checkDerefVar(var_glojure_DOT_core_list) + tmp88 := lang.Apply(tmp87, []any{v5}) + tmp89 := lang.Apply(tmp84, []any{tmp86, tmp88}) + tmp90 := lang.Apply(tmp83, []any{tmp89}) + tmp91 := lang.Apply(tmp82, []any{tmp90}) + tmp92 := checkDerefVar(var_glojure_DOT_core_list) + tmp93 := lang.Apply(tmp92, []any{v8}) + tmp94 := lang.Apply(tmp79, []any{tmp81, tmp91, tmp93}) + tmp95 := lang.Apply(tmp78, []any{tmp94}) + tmp96 := lang.Apply(tmp77, []any{tmp95}) + tmp97 := checkDerefVar(var_glojure_DOT_core_list) + tmp98 := lang.Apply(tmp97, []any{v6}) + tmp99 := lang.Apply(tmp62, []any{tmp64, tmp76, tmp96, tmp98}) + tmp100 := lang.Apply(tmp61, []any{tmp99}) + tmp101 := lang.Apply(tmp60, []any{tmp100}) + tmp102 := lang.Apply(tmp40, []any{tmp42, tmp59, tmp101}) + tmp103 := lang.Apply(tmp39, []any{tmp102}) + tmp104 := lang.Apply(tmp38, []any{tmp103}) + tmp105 := lang.Apply(tmp10, []any{tmp12, tmp37, tmp104}) + tmp106 := lang.Apply(tmp9, []any{tmp105}) + return tmp106 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_areduce = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_areduce.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // array + { + tmp0 := sym_array.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(3457), kw_column, int(7), kw_end_DASH_line, int(3458), kw_end_DASH_column, int(7), kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_items)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_into_DASH_array) + tmp4 := lang.Apply(tmp3, []any{v2}) + return tmp4 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_array = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_array.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // assert + { + tmp0 := sym_assert.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_message)), kw_doc, "Evaluates expression x and throws an AssertionError with optional\n message if x does not evaluate to logical true.\n\n Assertion checks are omitted from compiled code if '*assert*' is\n false.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(11), kw_line, int(4837), kw_end_DASH_line, int(4837))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_assert_STAR_) + if lang.IsTruthy(tmp6) { + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_core_SLASH_when_DASH_not}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{v4}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{sym_throw}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := checkDerefVar(var_glojure_DOT_core_seq) + tmp20 := checkDerefVar(var_glojure_DOT_core_concat) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{sym_new}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := lang.Apply(tmp23, []any{sym_glojure_DOT_core_SLASH_AssertionError}) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := checkDerefVar(var_glojure_DOT_core_seq) + tmp27 := checkDerefVar(var_glojure_DOT_core_concat) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := lang.Apply(tmp28, []any{sym_glojure_DOT_core_SLASH_str}) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := lang.Apply(tmp30, []any{"Assert failed: "}) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := checkDerefVar(var_glojure_DOT_core_seq) + tmp34 := checkDerefVar(var_glojure_DOT_core_concat) + tmp35 := checkDerefVar(var_glojure_DOT_core_list) + tmp36 := lang.Apply(tmp35, []any{sym_glojure_DOT_core_SLASH_pr_DASH_str}) + tmp37 := checkDerefVar(var_glojure_DOT_core_list) + tmp38 := checkDerefVar(var_glojure_DOT_core_seq) + tmp39 := checkDerefVar(var_glojure_DOT_core_concat) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{sym_quote}) + tmp42 := checkDerefVar(var_glojure_DOT_core_list) + tmp43 := lang.Apply(tmp42, []any{v4}) + tmp44 := lang.Apply(tmp39, []any{tmp41, tmp43}) + tmp45 := lang.Apply(tmp38, []any{tmp44}) + tmp46 := lang.Apply(tmp37, []any{tmp45}) + tmp47 := lang.Apply(tmp34, []any{tmp36, tmp46}) + tmp48 := lang.Apply(tmp33, []any{tmp47}) + tmp49 := lang.Apply(tmp32, []any{tmp48}) + tmp50 := lang.Apply(tmp27, []any{tmp29, tmp31, tmp49}) + tmp51 := lang.Apply(tmp26, []any{tmp50}) + tmp52 := lang.Apply(tmp25, []any{tmp51}) + tmp53 := lang.Apply(tmp20, []any{tmp22, tmp24, tmp52}) + tmp54 := lang.Apply(tmp19, []any{tmp53}) + tmp55 := lang.Apply(tmp18, []any{tmp54}) + tmp56 := lang.Apply(tmp15, []any{tmp17, tmp55}) + tmp57 := lang.Apply(tmp14, []any{tmp56}) + tmp58 := lang.Apply(tmp13, []any{tmp57}) + tmp59 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp58}) + tmp60 := lang.Apply(tmp7, []any{tmp59}) + tmp5 = tmp60 + } else { + } + return tmp5 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_assert_STAR_) + if lang.IsTruthy(tmp7) { + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_when_DASH_not}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v4}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_throw}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{sym_new}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{sym_glojure_DOT_core_SLASH_AssertionError}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := checkDerefVar(var_glojure_DOT_core_seq) + tmp28 := checkDerefVar(var_glojure_DOT_core_concat) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{sym_glojure_DOT_core_SLASH_str}) + tmp31 := checkDerefVar(var_glojure_DOT_core_list) + tmp32 := lang.Apply(tmp31, []any{"Assert failed: "}) + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{v5}) + tmp35 := checkDerefVar(var_glojure_DOT_core_list) + tmp36 := lang.Apply(tmp35, []any{"\n"}) + tmp37 := checkDerefVar(var_glojure_DOT_core_list) + tmp38 := checkDerefVar(var_glojure_DOT_core_seq) + tmp39 := checkDerefVar(var_glojure_DOT_core_concat) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{sym_glojure_DOT_core_SLASH_pr_DASH_str}) + tmp42 := checkDerefVar(var_glojure_DOT_core_list) + tmp43 := checkDerefVar(var_glojure_DOT_core_seq) + tmp44 := checkDerefVar(var_glojure_DOT_core_concat) + tmp45 := checkDerefVar(var_glojure_DOT_core_list) + tmp46 := lang.Apply(tmp45, []any{sym_quote}) + tmp47 := checkDerefVar(var_glojure_DOT_core_list) + tmp48 := lang.Apply(tmp47, []any{v4}) + tmp49 := lang.Apply(tmp44, []any{tmp46, tmp48}) + tmp50 := lang.Apply(tmp43, []any{tmp49}) + tmp51 := lang.Apply(tmp42, []any{tmp50}) + tmp52 := lang.Apply(tmp39, []any{tmp41, tmp51}) + tmp53 := lang.Apply(tmp38, []any{tmp52}) + tmp54 := lang.Apply(tmp37, []any{tmp53}) + tmp55 := lang.Apply(tmp28, []any{tmp30, tmp32, tmp34, tmp36, tmp54}) + tmp56 := lang.Apply(tmp27, []any{tmp55}) + tmp57 := lang.Apply(tmp26, []any{tmp56}) + tmp58 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp57}) + tmp59 := lang.Apply(tmp20, []any{tmp58}) + tmp60 := lang.Apply(tmp19, []any{tmp59}) + tmp61 := lang.Apply(tmp16, []any{tmp18, tmp60}) + tmp62 := lang.Apply(tmp15, []any{tmp61}) + tmp63 := lang.Apply(tmp14, []any{tmp62}) + tmp64 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp63}) + tmp65 := lang.Apply(tmp8, []any{tmp64}) + tmp6 = tmp65 + } else { + } + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_assert = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_assert.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // assert-args + { + tmp0 := sym_assert_DASH_args.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_pairs)), kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(38), kw_column, int(11), kw_line, int(1830), kw_end_DASH_line, int(1830), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym_do}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := checkDerefVar(var_glojure_DOT_core_seq) + tmp11 := checkDerefVar(var_glojure_DOT_core_concat) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_glojure_DOT_core_SLASH_when_DASH_not}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_first) + tmp16 := lang.Apply(tmp15, []any{v4}) + tmp17 := lang.Apply(tmp14, []any{tmp16}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := checkDerefVar(var_glojure_DOT_core_seq) + tmp20 := checkDerefVar(var_glojure_DOT_core_concat) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{sym_throw}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_seq) + tmp25 := checkDerefVar(var_glojure_DOT_core_concat) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_NewIllegalArgumentError}) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := checkDerefVar(var_glojure_DOT_core_seq) + tmp30 := checkDerefVar(var_glojure_DOT_core_concat) + tmp31 := checkDerefVar(var_glojure_DOT_core_list) + tmp32 := lang.Apply(tmp31, []any{sym_glojure_DOT_core_SLASH_str}) + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := checkDerefVar(var_glojure_DOT_core_seq) + tmp35 := checkDerefVar(var_glojure_DOT_core_concat) + tmp36 := checkDerefVar(var_glojure_DOT_core_list) + tmp37 := lang.Apply(tmp36, []any{sym_glojure_DOT_core_SLASH_first}) + tmp38 := checkDerefVar(var_glojure_DOT_core_list) + tmp39 := lang.Apply(tmp38, []any{sym__AMP_form}) + tmp40 := lang.Apply(tmp35, []any{tmp37, tmp39}) + tmp41 := lang.Apply(tmp34, []any{tmp40}) + tmp42 := lang.Apply(tmp33, []any{tmp41}) + tmp43 := checkDerefVar(var_glojure_DOT_core_list) + tmp44 := lang.Apply(tmp43, []any{" requires "}) + tmp45 := checkDerefVar(var_glojure_DOT_core_list) + tmp46 := checkDerefVar(var_glojure_DOT_core_second) + tmp47 := lang.Apply(tmp46, []any{v4}) + tmp48 := lang.Apply(tmp45, []any{tmp47}) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) + tmp50 := lang.Apply(tmp49, []any{" in "}) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := lang.Apply(tmp51, []any{sym__STAR_ns_STAR_}) + tmp53 := checkDerefVar(var_glojure_DOT_core_list) + tmp54 := lang.Apply(tmp53, []any{":"}) + tmp55 := checkDerefVar(var_glojure_DOT_core_list) + tmp56 := checkDerefVar(var_glojure_DOT_core_seq) + tmp57 := checkDerefVar(var_glojure_DOT_core_concat) + tmp58 := checkDerefVar(var_glojure_DOT_core_list) + tmp59 := lang.Apply(tmp58, []any{kw_line}) + tmp60 := checkDerefVar(var_glojure_DOT_core_list) + tmp61 := checkDerefVar(var_glojure_DOT_core_seq) + tmp62 := checkDerefVar(var_glojure_DOT_core_concat) + tmp63 := checkDerefVar(var_glojure_DOT_core_list) + tmp64 := lang.Apply(tmp63, []any{sym_glojure_DOT_core_SLASH_meta}) + tmp65 := checkDerefVar(var_glojure_DOT_core_list) + tmp66 := lang.Apply(tmp65, []any{sym__AMP_form}) + tmp67 := lang.Apply(tmp62, []any{tmp64, tmp66}) + tmp68 := lang.Apply(tmp61, []any{tmp67}) + tmp69 := lang.Apply(tmp60, []any{tmp68}) + tmp70 := lang.Apply(tmp57, []any{tmp59, tmp69}) + tmp71 := lang.Apply(tmp56, []any{tmp70}) + tmp72 := lang.Apply(tmp55, []any{tmp71}) + tmp73 := lang.Apply(tmp30, []any{tmp32, tmp42, tmp44, tmp48, tmp50, tmp52, tmp54, tmp72}) + tmp74 := lang.Apply(tmp29, []any{tmp73}) + tmp75 := lang.Apply(tmp28, []any{tmp74}) + tmp76 := lang.Apply(tmp25, []any{tmp27, tmp75}) + tmp77 := lang.Apply(tmp24, []any{tmp76}) + tmp78 := lang.Apply(tmp23, []any{tmp77}) + tmp79 := lang.Apply(tmp20, []any{tmp22, tmp78}) + tmp80 := lang.Apply(tmp19, []any{tmp79}) + tmp81 := lang.Apply(tmp18, []any{tmp80}) + tmp82 := lang.Apply(tmp11, []any{tmp13, tmp17, tmp81}) + tmp83 := lang.Apply(tmp10, []any{tmp82}) + tmp84 := lang.Apply(tmp9, []any{tmp83}) + tmp85 := checkDerefVar(var_glojure_DOT_core_list) + var tmp86 any + { // let + // let binding "more" + tmp87 := checkDerefVar(var_glojure_DOT_core_nnext) + tmp88 := lang.Apply(tmp87, []any{v4}) + var v89 any = tmp88 + _ = v89 + var tmp90 any + if lang.IsTruthy(v89) { + tmp91 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp92 := lang.Apply(tmp91, []any{sym_glojure_DOT_core_SLASH_assert_DASH_args, v89}) + tmp90 = tmp92 + } else { + } + tmp86 = tmp90 + } // end let + tmp87 := lang.Apply(tmp85, []any{tmp86}) + tmp88 := lang.Apply(tmp6, []any{tmp8, tmp84, tmp87}) + tmp89 := lang.Apply(tmp5, []any{tmp88}) + return tmp89 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_assert_DASH_args = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_assert_DASH_args.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // assoc-in + { + tmp0 := sym_assoc_DASH_in.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m, lang.NewVector(sym_k, sym__AMP_, sym_ks), sym_v)), kw_doc, "Associates a value in a nested associative structure, where ks is a\n sequence of keys and v is the new value and returns a new nested structure.\n If any levels do not exist, hash-maps will be created.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(6147), kw_end_DASH_line, int(6147))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + { // let + // let binding "vec__829" + var v6 any = v3 + _ = v6 + // let binding "seq__830" + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := lang.Apply(tmp7, []any{v6}) + var v9 any = tmp8 + _ = v9 + // let binding "first__831" + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v9}) + var v12 any = tmp11 + _ = v12 + // let binding "seq__830" + tmp13 := checkDerefVar(var_glojure_DOT_core_next) + tmp14 := lang.Apply(tmp13, []any{v9}) + var v15 any = tmp14 + _ = v15 + // let binding "k" + var v16 any = v12 + _ = v16 + // let binding "ks" + var v17 any = v15 + _ = v17 + var tmp18 any + if lang.IsTruthy(v17) { + tmp19 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp20 := checkDerefVar(var_glojure_DOT_core_assoc_DASH_in) + tmp21 := checkDerefVar(var_glojure_DOT_core_get) + tmp22 := lang.Apply(tmp21, []any{v2, v16}) + tmp23 := lang.Apply(tmp20, []any{tmp22, v17, v4}) + tmp24 := lang.Apply(tmp19, []any{v2, v16, tmp23}) + tmp18 = tmp24 + } else { + tmp25 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp26 := lang.Apply(tmp25, []any{v2, v16, v4}) + tmp18 = tmp26 + } + tmp5 = tmp18 + } // end let + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_assoc_DASH_in = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_assoc_DASH_in.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bigdec + { + tmp1 := reflect.TypeOf((*lang.BigDecimal)(nil)) + tmp0 := sym_bigdec.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Coerce to BigDecimal", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(3648), kw_end_DASH_line, int(3648))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_decimal_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + tmp4 = v3 + } else { + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core_float_QMARK_) + tmp9 := lang.Apply(tmp8, []any{v3}) + if lang.IsTruthy(tmp9) { + tmp10 := checkDerefVar(var_glojure_DOT_core_double) + tmp11 := lang.Apply(tmp10, []any{v3}) + tmp12 := lang.Apply(lang.NewBigDecimalFromFloat64, []any{tmp11}) + tmp7 = tmp12 + } else { + var tmp13 any + tmp14 := checkDerefVar(var_glojure_DOT_core_ratio_QMARK_) + tmp15 := lang.Apply(tmp14, []any{v3}) + if lang.IsTruthy(tmp15) { + tmp16 := checkDerefVar(var_glojure_DOT_core__SLASH_) + tmp17 := lang.Apply(lang.NewBigDecimalFromRatio, []any{v3}) + tmp18, ok := lang.FieldOrMethod(v3, "denominator") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "denominator"))) + } + var tmp19 any + switch reflect.TypeOf(tmp18).Kind() { + case reflect.Func: + tmp19 = lang.Apply(tmp18, nil) + default: + tmp19 = tmp18 + } + tmp20 := lang.Apply(tmp16, []any{tmp17, tmp19}) + tmp13 = tmp20 + } else { + var tmp21 any + tmp22 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp23 := reflect.TypeOf((*lang.BigInt)(nil)) + tmp24 := lang.Apply(tmp22, []any{tmp23, v3}) + if lang.IsTruthy(tmp24) { + tmp25, ok := lang.FieldOrMethod(v3, "toBigDecimal") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "toBigDecimal"))) + } + var tmp26 any + switch reflect.TypeOf(tmp25).Kind() { + case reflect.Func: + tmp26 = lang.Apply(tmp25, nil) + default: + tmp26 = tmp25 + } + tmp21 = tmp26 + } else { + var tmp27 any + tmp28 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp29 := reflect.TypeOf((*big6.Int)(nil)) + tmp30 := lang.Apply(tmp28, []any{tmp29, v3}) + if lang.IsTruthy(tmp30) { + tmp31 := lang.Apply(lang.NewBigDecimal, []any{v3}) + tmp27 = tmp31 + } else { + var tmp32 any + tmp33 := checkDerefVar(var_glojure_DOT_core_number_QMARK_) + tmp34 := lang.Apply(tmp33, []any{v3}) + if lang.IsTruthy(tmp34) { + tmp35 := checkDerefVar(var_glojure_DOT_core_long) + tmp36 := lang.Apply(tmp35, []any{v3}) + tmp37 := lang.Apply(lang.NewBigDecimalFromInt64, []any{tmp36}) + tmp32 = tmp37 + } else { + var tmp38 any + if lang.IsTruthy(kw_else) { + tmp39 := lang.Apply(lang.NewBigDecimal, []any{v3}) + tmp38 = tmp39 + } else { + } + tmp32 = tmp38 + } + tmp27 = tmp32 + } + tmp21 = tmp27 + } + tmp13 = tmp21 + } + tmp7 = tmp13 + } + tmp4 = tmp7 + } + return tmp4 + }) + tmp3 := reflect.TypeOf((*lang.BigDecimal)(nil)) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_bigdec = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bigdec.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bigint + { + tmp1 := reflect.TypeOf((*lang.BigInt)(nil)) + tmp0 := sym_bigint.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Coerce to BigInt", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(3620), kw_end_DASH_line, int(3620))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp6 := reflect.TypeOf((*lang.BigInt)(nil)) + tmp7 := lang.Apply(tmp5, []any{tmp6, v3}) + if lang.IsTruthy(tmp7) { + tmp4 = v3 + } else { + var tmp8 any + tmp9 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp10 := reflect.TypeOf((*big6.Int)(nil)) + tmp11 := lang.Apply(tmp9, []any{tmp10, v3}) + if lang.IsTruthy(tmp11) { + tmp12 := lang.Apply(lang.NewBigIntFromGoBigInt, []any{v3}) + tmp8 = tmp12 + } else { + var tmp13 any + tmp14 := checkDerefVar(var_glojure_DOT_core_decimal_QMARK_) + tmp15 := lang.Apply(tmp14, []any{v3}) + if lang.IsTruthy(tmp15) { + tmp16 := checkDerefVar(var_glojure_DOT_core_bigint) + tmp17, ok := lang.FieldOrMethod(v3, "toBigInteger") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "toBigInteger"))) + } + var tmp18 any + switch reflect.TypeOf(tmp17).Kind() { + case reflect.Func: + tmp18 = lang.Apply(tmp17, nil) + default: + tmp18 = tmp17 + } + tmp19 := lang.Apply(tmp16, []any{tmp18}) + tmp13 = tmp19 + } else { + var tmp20 any + tmp21 := checkDerefVar(var_glojure_DOT_core_float_QMARK_) + tmp22 := lang.Apply(tmp21, []any{v3}) + if lang.IsTruthy(tmp22) { + tmp23 := checkDerefVar(var_glojure_DOT_core_bigint) + tmp24 := checkDerefVar(var_glojure_DOT_core_double) + tmp25 := lang.Apply(tmp24, []any{v3}) + tmp26 := lang.Apply(lang.NewBigDecimalFromFloat64, []any{tmp25}) + tmp27 := lang.Apply(tmp23, []any{tmp26}) + tmp20 = tmp27 + } else { + var tmp28 any + tmp29 := checkDerefVar(var_glojure_DOT_core_ratio_QMARK_) + tmp30 := lang.Apply(tmp29, []any{v3}) + if lang.IsTruthy(tmp30) { + tmp31 := checkDerefVar(var_glojure_DOT_core_bigint) + tmp32, ok := lang.FieldOrMethod(v3, "bigIntegerValue") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "bigIntegerValue"))) + } + var tmp33 any + switch reflect.TypeOf(tmp32).Kind() { + case reflect.Func: + tmp33 = lang.Apply(tmp32, nil) + default: + tmp33 = tmp32 + } + tmp34 := lang.Apply(tmp31, []any{tmp33}) + tmp28 = tmp34 + } else { + var tmp35 any + tmp36 := checkDerefVar(var_glojure_DOT_core_number_QMARK_) + tmp37 := lang.Apply(tmp36, []any{v3}) + if lang.IsTruthy(tmp37) { + tmp38 := checkDerefVar(var_glojure_DOT_core_long) + tmp39 := lang.Apply(tmp38, []any{v3}) + tmp40 := lang.Apply(lang.NewBigIntFromInt64, []any{tmp39}) + tmp35 = tmp40 + } else { + var tmp41 any + if lang.IsTruthy(kw_else) { + tmp42 := checkDerefVar(var_glojure_DOT_core_bigint) + tmp43 := lang.Apply(lang.NewBigInt, []any{v3}) + tmp44 := lang.Apply(tmp42, []any{tmp43}) + tmp41 = tmp44 + } else { + } + tmp35 = tmp41 + } + tmp28 = tmp35 + } + tmp20 = tmp28 + } + tmp13 = tmp20 + } + tmp8 = tmp13 + } + tmp4 = tmp8 + } + return tmp4 + }) + tmp3 := reflect.TypeOf((*lang.BigInt)(nil)) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_bigint = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bigint.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // biginteger + { + tmp1 := reflect.TypeOf((*big6.Int)(nil)) + tmp0 := sym_biginteger.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Coerce to BigInteger", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(3634), kw_end_DASH_line, int(3634))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp6 := reflect.TypeOf((*big6.Int)(nil)) + tmp7 := lang.Apply(tmp5, []any{tmp6, v3}) + if lang.IsTruthy(tmp7) { + tmp4 = v3 + } else { + var tmp8 any + tmp9 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp10 := reflect.TypeOf((*lang.BigInt)(nil)) + tmp11 := lang.Apply(tmp9, []any{tmp10, v3}) + if lang.IsTruthy(tmp11) { + tmp12, ok := lang.FieldOrMethod(v3, "toBigInteger") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "toBigInteger"))) + } + var tmp13 any + switch reflect.TypeOf(tmp12).Kind() { + case reflect.Func: + tmp13 = lang.Apply(tmp12, nil) + default: + tmp13 = tmp12 + } + tmp8 = tmp13 + } else { + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core_decimal_QMARK_) + tmp16 := lang.Apply(tmp15, []any{v3}) + if lang.IsTruthy(tmp16) { + tmp17, ok := lang.FieldOrMethod(v3, "toBigInteger") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "toBigInteger"))) + } + var tmp18 any + switch reflect.TypeOf(tmp17).Kind() { + case reflect.Func: + tmp18 = lang.Apply(tmp17, nil) + default: + tmp18 = tmp17 + } + tmp14 = tmp18 + } else { + var tmp19 any + tmp20 := checkDerefVar(var_glojure_DOT_core_float_QMARK_) + tmp21 := lang.Apply(tmp20, []any{v3}) + if lang.IsTruthy(tmp21) { + tmp22 := checkDerefVar(var_glojure_DOT_core_double) + tmp23 := lang.Apply(tmp22, []any{v3}) + tmp24 := lang.Apply(lang.NewBigDecimalFromFloat64, []any{tmp23}) + tmp25, ok := lang.FieldOrMethod(tmp24, "toBigInteger") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp24, "toBigInteger"))) + } + var tmp26 any + switch reflect.TypeOf(tmp25).Kind() { + case reflect.Func: + tmp26 = lang.Apply(tmp25, nil) + default: + tmp26 = tmp25 + } + tmp19 = tmp26 + } else { + var tmp27 any + tmp28 := checkDerefVar(var_glojure_DOT_core_ratio_QMARK_) + tmp29 := lang.Apply(tmp28, []any{v3}) + if lang.IsTruthy(tmp29) { + tmp30, ok := lang.FieldOrMethod(v3, "bigIntegerValue") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "bigIntegerValue"))) + } + var tmp31 any + switch reflect.TypeOf(tmp30).Kind() { + case reflect.Func: + tmp31 = lang.Apply(tmp30, nil) + default: + tmp31 = tmp30 + } + tmp27 = tmp31 + } else { + var tmp32 any + tmp33 := checkDerefVar(var_glojure_DOT_core_number_QMARK_) + tmp34 := lang.Apply(tmp33, []any{v3}) + if lang.IsTruthy(tmp34) { + tmp35 := checkDerefVar(var_glojure_DOT_core_long) + tmp36 := lang.Apply(tmp35, []any{v3}) + tmp37 := lang.Apply(big6.NewInt, []any{tmp36}) + tmp32 = tmp37 + } else { + var tmp38 any + if lang.IsTruthy(kw_else) { + tmp39 := lang.Apply(lang.NewBigInt, []any{v3}) + tmp38 = tmp39 + } else { + } + tmp32 = tmp38 + } + tmp27 = tmp32 + } + tmp19 = tmp27 + } + tmp14 = tmp19 + } + tmp8 = tmp14 + } + tmp4 = tmp8 + } + return tmp4 + }) + tmp3 := reflect.TypeOf((*big6.Int)(nil)) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_biginteger = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_biginteger.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // binding-conveyor-fn + { + tmp0 := sym_binding_DASH_conveyor_DASH_fn.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f)), kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(25), kw_column, int(7), kw_line, int(2020), kw_end_DASH_line, int(2020), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "frame" + tmp4 := lang.Apply(lang.CloneThreadBindingFrame, nil) + var v5 any = tmp4 + _ = v5 + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp7 := lang.Apply(lang.ResetThreadBindingFrame, []any{v5}) + _ = tmp7 + tmp8 := lang.Apply(v2, nil) + return tmp8 + case 1: + v7 := args[0] + _ = v7 + tmp8 := lang.Apply(lang.ResetThreadBindingFrame, []any{v5}) + _ = tmp8 + tmp9 := lang.Apply(v2, []any{v7}) + return tmp9 + case 2: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + tmp9 := lang.Apply(lang.ResetThreadBindingFrame, []any{v5}) + _ = tmp9 + tmp10 := lang.Apply(v2, []any{v7, v8}) + return tmp10 + case 3: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + tmp10 := lang.Apply(lang.ResetThreadBindingFrame, []any{v5}) + _ = tmp10 + tmp11 := lang.Apply(v2, []any{v7, v8, v9}) + return tmp11 + default: + checkArity(args, 3) + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + var v10 any = lang.NewList(args[3:]...) + _ = v10 + tmp11 := lang.Apply(lang.ResetThreadBindingFrame, []any{v5}) + _ = tmp11 + tmp12 := checkDerefVar(var_glojure_DOT_core_apply) + tmp13 := lang.Apply(tmp12, []any{v2, v7, v8, v9, v10}) + return tmp13 + } + }) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2025), kw_column, int(5), kw_end_DASH_line, int(2040), kw_end_DASH_column, int(31)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp3 = tmp8 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_binding_DASH_conveyor_DASH_fn = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_binding_DASH_conveyor_DASH_fn.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bit-and + { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed18 + } else { + tmp4 = closed18 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed18 + } else { + tmp5 = closed18 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed18 + } else { + tmp6 = closed18 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym_bit_DASH_and.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Bitwise and", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(1298), kw_end_DASH_line, int(1298))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "And") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("And is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp8 := checkDerefVar(var_glojure_DOT_core_bit_DASH_and) + tmp9 := checkDerefVar(var_glojure_DOT_core_bit_DASH_and) + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) + return tmp11 + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bit_DASH_and = ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bit_DASH_and.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bit-and-not + { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed19 + } else { + tmp4 = closed19 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed19 + } else { + tmp5 = closed19 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed19 + } else { + tmp6 = closed19 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym_bit_DASH_and_DASH_not.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Bitwise and with complement", kw_static, true, kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(1325), kw_end_DASH_line, int(1325))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "AndNot") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("AndNot is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp8 := checkDerefVar(var_glojure_DOT_core_bit_DASH_and_DASH_not) + tmp9 := checkDerefVar(var_glojure_DOT_core_bit_DASH_and_DASH_not) + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) + return tmp11 + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bit_DASH_and_DASH_not = ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bit_DASH_and_DASH_not.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bit-not + { + var tmp1 lang.FnFunc + { // function bit-not__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Not}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_bit_DASH_not.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Bitwise complement", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(1291), kw_end_DASH_line, int(1291))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Not") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Not is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bit_DASH_not = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bit_DASH_not.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bit-or + { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed20 + } else { + tmp4 = closed20 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed20 + } else { + tmp5 = closed20 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed20 + } else { + tmp6 = closed20 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym_bit_DASH_or.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Bitwise or", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(1307), kw_end_DASH_line, int(1307))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Or") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Or is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp8 := checkDerefVar(var_glojure_DOT_core_bit_DASH_or) + tmp9 := checkDerefVar(var_glojure_DOT_core_bit_DASH_or) + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) + return tmp11 + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bit_DASH_or = ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bit_DASH_or.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bit-shift-left + { + var tmp1 lang.FnFunc + { // function bit-shift-left__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_ShiftLeft}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_bit_DASH_shift_DASH_left.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_n)), kw_inline, tmp1, kw_doc, "Bitwise shift left", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(1361), kw_end_DASH_line, int(1361))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "ShiftLeft") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ShiftLeft is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bit_DASH_shift_DASH_left = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bit_DASH_shift_DASH_left.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bit-shift-right + { + var tmp1 lang.FnFunc + { // function bit-shift-right__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_ShiftRight}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_bit_DASH_shift_DASH_right.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_n)), kw_inline, tmp1, kw_doc, "Bitwise shift right", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(1367), kw_end_DASH_line, int(1367))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "ShiftRight") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ShiftRight is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bit_DASH_shift_DASH_right = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bit_DASH_shift_DASH_right.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bit-xor + { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed21 + } else { + tmp4 = closed21 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed21 + } else { + tmp5 = closed21 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed21 + } else { + tmp6 = closed21 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym_bit_DASH_xor.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Bitwise exclusive or", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(1316), kw_end_DASH_line, int(1316))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Xor") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Xor is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp8 := checkDerefVar(var_glojure_DOT_core_bit_DASH_xor) + tmp9 := checkDerefVar(var_glojure_DOT_core_bit_DASH_xor) + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) + return tmp11 + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bit_DASH_xor = ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bit_DASH_xor.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // boolean + { + var tmp1 lang.FnFunc + { // function boolean__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_BooleanCast}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_boolean.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to boolean", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(1601), kw_end_DASH_line, int(1601))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(runtime.RT, "BooleanCast") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("BooleanCast is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_boolean = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_boolean.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // boolean-array + { + var tmp1 lang.FnFunc + { // function boolean-array__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_BooleanArray}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_unquote_DASH_splicing}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_glojure_DOT_core_SLASH_args}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + } + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_boolean_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_size_DASH_or_DASH_seq), lang.NewVector(sym_size, sym_init_DASH_val_DASH_or_DASH_seq)), kw_inline, tmp1, kw_doc, "Creates an array of booleans", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(5309), kw_end_DASH_line, int(5309))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "BooleanArray") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("BooleanArray is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "BooleanArrayInit") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("BooleanArrayInit is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_boolean_DASH_array = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_boolean_DASH_array.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // booleans + { + var tmp1 lang.FnFunc + { // function booleans + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Booleans}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_booleans.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xs)), kw_inline, tmp1, kw_doc, "Casts to boolean[]", kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(12), kw_line, int(5372), kw_end_DASH_line, int(5372))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Booleans") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Booleans is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_booleans = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_booleans.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bound-fn + { + tmp0 := sym_bound_DASH_fn.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_fntail)), kw_doc, "Returns a function defined by the given fntail, which will install the\n same bindings in effect as in the thread at the time bound-fn was called.\n This may be used to define a helper function which runs on a different\n thread, but needs the same bindings in place.", kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(11), kw_line, int(2004), kw_end_DASH_line, int(2004))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym_glojure_DOT_core_SLASH_bound_DASH_fn_STAR_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := checkDerefVar(var_glojure_DOT_core_seq) + tmp11 := checkDerefVar(var_glojure_DOT_core_concat) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_glojure_DOT_core_SLASH_fn}) + tmp14 := lang.Apply(tmp11, []any{tmp13, v4}) + tmp15 := lang.Apply(tmp10, []any{tmp14}) + tmp16 := lang.Apply(tmp9, []any{tmp15}) + tmp17 := lang.Apply(tmp6, []any{tmp8, tmp16}) + tmp18 := lang.Apply(tmp5, []any{tmp17}) + return tmp18 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bound_DASH_fn = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bound_DASH_fn.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bound? + { + tmp0 := sym_bound_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_vars)), kw_doc, "Returns true if all of the vars provided as arguments have any bound value, root or thread-local.\n Implies that deref'ing the provided vars will succeed. Returns true if no vars are provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(5491), kw_end_DASH_line, int(5491))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v5 := args[0] + _ = v5 + tmp6, ok := lang.FieldOrMethod(v5, "isBound") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "isBound"))) + } + var tmp7 any + switch reflect.TypeOf(tmp6).Kind() { + case reflect.Func: + tmp7 = lang.Apply(tmp6, nil) + default: + tmp7 = tmp6 + } + return tmp7 + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5497), kw_column, int(11), kw_end_DASH_line, int(5497), kw_end_DASH_column, int(69)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp7 := lang.Apply(tmp3, []any{tmp6, v2}) + return tmp7 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bound_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bound_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bounded-count + { + tmp0 := sym_bounded_DASH_count.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n, sym_coll)), kw_doc, "If coll is counted? returns its count, else will count at most the first n\n elements of coll using its seq", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(7410), kw_end_DASH_line, int(7410))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_counted_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + tmp7 := checkDerefVar(var_glojure_DOT_core_count) + tmp8 := lang.Apply(tmp7, []any{v3}) + tmp4 = tmp8 + } else { + var tmp9 any + { // let + // let binding "i" + var v10 any = int64(0) + _ = v10 + // let binding "s" + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := lang.Apply(tmp11, []any{v3}) + var v13 any = tmp12 + _ = v13 + for { + var tmp14 any + var tmp15 any + { // let + // let binding "and__0__auto__" + var v16 any = v13 + _ = v16 + var tmp17 any + if lang.IsTruthy(v16) { + tmp18 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp19 := lang.Apply(tmp18, []any{v10, v2}) + tmp17 = tmp19 + } else { + tmp17 = v16 + } + tmp15 = tmp17 + } // end let + if lang.IsTruthy(tmp15) { + tmp17 := checkDerefVar(var_glojure_DOT_core_inc) + tmp18 := lang.Apply(tmp17, []any{v10}) + var tmp16 any = tmp18 + tmp20 := checkDerefVar(var_glojure_DOT_core_next) + tmp21 := lang.Apply(tmp20, []any{v13}) + var tmp19 any = tmp21 + v10 = tmp16 + v13 = tmp19 + continue + } else { + tmp14 = v10 + } + tmp9 = tmp14 + break + } + } // end let + tmp4 = tmp9 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bounded_DASH_count = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bounded_DASH_count.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // butlast + { + tmp0 := sym_butlast.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Return a seq of all but the last item in coll, in linear time", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(2), kw_line, int(272), kw_end_DASH_line, int(276))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function butlast + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + var tmp4 any + { // let + // let binding "ret" + tmp5 := lang.NewVector() + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(277), kw_column, int(23), kw_end_DASH_line, int(277), kw_end_DASH_column, int(24)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v8 any = tmp7 + _ = v8 + // let binding "s" + var v9 any = v3 + _ = v9 + for { + var tmp10 any + tmp11 := checkDerefVar(var_glojure_DOT_core_next) + tmp12 := lang.Apply(tmp11, []any{v9}) + if lang.IsTruthy(tmp12) { + tmp14 := checkDerefVar(var_glojure_DOT_core_conj) + tmp15 := checkDerefVar(var_glojure_DOT_core_first) + tmp16 := lang.Apply(tmp15, []any{v9}) + tmp17 := lang.Apply(tmp14, []any{v8, tmp16}) + var tmp13 any = tmp17 + tmp19 := checkDerefVar(var_glojure_DOT_core_next) + tmp20 := lang.Apply(tmp19, []any{v9}) + var tmp18 any = tmp20 + v8 = tmp13 + v9 = tmp18 + continue + } else { + tmp21 := checkDerefVar(var_glojure_DOT_core_seq) + tmp22 := lang.Apply(tmp21, []any{v8}) + tmp10 = tmp22 + } + tmp4 = tmp10 + break + } + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(276), kw_column, int(10), kw_end_DASH_line, int(280), kw_end_DASH_column, int(27))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_butlast = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_butlast.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // byte + { + var tmp1 lang.FnFunc + { // function byte__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp15) { + tmp14 = sym_uncheckedByteCast + } else { + tmp14 = sym_byteCast + } + tmp16 := lang.Apply(tmp13, []any{tmp14}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := lang.Apply(tmp12, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp11, []any{tmp19}) + tmp21 := lang.Apply(tmp10, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_byte.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to byte", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3505), kw_end_DASH_line, int(3505))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.ByteCast, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_byte = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_byte.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // byte-array + { + var tmp1 lang.FnFunc + { // function byte-array__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_ByteArray}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_unquote_DASH_splicing}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_glojure_DOT_core_SLASH_args}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + } + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_byte_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_size_DASH_or_DASH_seq), lang.NewVector(sym_size, sym_init_DASH_val_DASH_or_DASH_seq)), kw_inline, tmp1, kw_doc, "Creates an array of bytes", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(5317), kw_end_DASH_line, int(5317))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "ByteArray") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ByteArray is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "ByteArrayInit") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ByteArrayInit is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_byte_DASH_array = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_byte_DASH_array.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bytes + { + var tmp1 lang.FnFunc + { // function bytes + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Bytes}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_bytes.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xs)), kw_inline, tmp1, kw_doc, "Casts to bytes[]", kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(12), kw_line, int(5377), kw_end_DASH_line, int(5377))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Bytes") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Bytes is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bytes = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bytes.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bytes? + { + tmp0 := sym_bytes_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a byte array", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(5412), kw_end_DASH_line, int(5412))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + tmp3 = false + } else { + tmp6 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp7 := checkDerefVar(var_glojure_DOT_core_class) + tmp8 := lang.Apply(tmp7, []any{v2}) + tmp9, ok := lang.FieldOrMethod(tmp8, "getComponentType") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp8, "getComponentType"))) + } + var tmp10 any + switch reflect.TypeOf(tmp9).Kind() { + case reflect.Func: + tmp10 = lang.Apply(tmp9, nil) + default: + tmp10 = tmp9 + } + tmp11 := lang.Apply(tmp6, []any{tmp10, nil}) + tmp3 = tmp11 + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bytes_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bytes_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // char + { + var tmp1 lang.FnFunc + { // function char__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp15) { + tmp14 = sym_uncheckedCharCast + } else { + tmp14 = sym_charCast + } + tmp16 := lang.Apply(tmp13, []any{tmp14}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := lang.Apply(tmp12, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp11, []any{tmp19}) + tmp21 := lang.Apply(tmp10, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_char.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to char", kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3511), kw_end_DASH_line, int(3511))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(runtime.RT, "CharCast") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("CharCast is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_char = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_char.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // char-array + { + var tmp1 lang.FnFunc + { // function char-array__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_CharArray}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_unquote_DASH_splicing}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_glojure_DOT_core_SLASH_args}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + } + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_char_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_size_DASH_or_DASH_seq), lang.NewVector(sym_size, sym_init_DASH_val_DASH_or_DASH_seq)), kw_inline, tmp1, kw_doc, "Creates an array of chars", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(5325), kw_end_DASH_line, int(5325))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "CharArray") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("CharArray is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "CharArrayInit") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("CharArrayInit is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_char_DASH_array = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_char_DASH_array.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // chars + { + var tmp1 lang.FnFunc + { // function chars + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Chars}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_chars.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xs)), kw_inline, tmp1, kw_doc, "Casts to chars[]", kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(12), kw_line, int(5382), kw_end_DASH_line, int(5382))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Chars") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Chars is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_chars = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_chars.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // comp + { + tmp0 := sym_comp.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_f), lang.NewVector(sym_f, sym_g), lang.NewVector(sym_f, sym_g, sym__AMP_, sym_fs)), kw_doc, "Takes a set of functions and returns a fn that is the composition\n of those fns. The returned fn takes a variable number of args,\n applies the rightmost of fns to the args, the next\n fn (right-to-left) to the result, etc.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(2549), kw_end_DASH_line, int(2549))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp2 := checkDerefVar(var_glojure_DOT_core_identity) + return tmp2 + case 1: + v2 := args[0] + _ = v2 + return v2 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp5 := lang.Apply(v3, nil) + tmp6 := lang.Apply(v2, []any{tmp5}) + return tmp6 + case 1: + v5 := args[0] + _ = v5 + tmp6 := lang.Apply(v3, []any{v5}) + tmp7 := lang.Apply(v2, []any{tmp6}) + return tmp7 + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + tmp7 := lang.Apply(v3, []any{v5, v6}) + tmp8 := lang.Apply(v2, []any{tmp7}) + return tmp8 + case 3: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := args[2] + _ = v7 + tmp8 := lang.Apply(v3, []any{v5, v6, v7}) + tmp9 := lang.Apply(v2, []any{tmp8}) + return tmp9 + default: + checkArity(args, 3) + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := args[2] + _ = v7 + var v8 any = lang.NewList(args[3:]...) + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_apply) + tmp10 := lang.Apply(tmp9, []any{v3, v5, v6, v7, v8}) + tmp11 := lang.Apply(v2, []any{tmp10}) + return tmp11 + } + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2559), kw_column, int(6), kw_end_DASH_line, int(2564), kw_end_DASH_column, int(49)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp6 := checkDerefVar(var_glojure_DOT_core_comp) + tmp7 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp8 := lang.Apply(tmp7, []any{v2, v3, v4}) + tmp9 := lang.Apply(tmp5, []any{tmp6, tmp8}) + return tmp9 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_comp = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_comp.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // compare + { + var tmp1 lang.FnFunc + { // function compare__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_lang_DOT_Util}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_glojure_DOT_core_SLASH_compare}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{v3}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v4}) + tmp17 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp12, tmp14, tmp16}) + tmp18 := lang.Apply(tmp5, []any{tmp17}) + return tmp18 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_compare.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Comparator. Returns a negative number, zero, or a positive number\n when x is logically 'less than', 'equal to', or 'greater than'\n y. Same as Java x.compareTo(y) except it also works for nil, and\n compares numbers and collections in a type-independent manner. x\n must implement Comparable", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(824), kw_end_DASH_line, int(824))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(lang.Compare, []any{v3, v4}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_compare = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_compare.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // complement + { + tmp0 := sym_complement.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f)), kw_doc, "Takes a fn f and returns a fn that takes the same arguments as f,\n has the same effects, if any, and returns the opposite truth value.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(1428), kw_end_DASH_line, int(1428))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp4 := checkDerefVar(var_glojure_DOT_core_not) + tmp5 := lang.Apply(v2, nil) + tmp6 := lang.Apply(tmp4, []any{tmp5}) + return tmp6 + case 1: + v4 := args[0] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_not) + tmp6 := lang.Apply(v2, []any{v4}) + tmp7 := lang.Apply(tmp5, []any{tmp6}) + return tmp7 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_not) + tmp7 := lang.Apply(v2, []any{v4, v5}) + tmp8 := lang.Apply(tmp6, []any{tmp7}) + return tmp8 + default: + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_not) + tmp8 := checkDerefVar(var_glojure_DOT_core_apply) + tmp9 := lang.Apply(tmp8, []any{v2, v4, v5, v6}) + tmp10 := lang.Apply(tmp7, []any{tmp9}) + return tmp10 + } + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(1434), kw_column, int(3), kw_end_DASH_line, int(1438), kw_end_DASH_column, int(40)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_complement = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_complement.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // data-reader-var + { + tmp0 := sym_data_DASH_reader_DASH_var.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7832), kw_column, int(8), kw_end_DASH_line, int(7832), kw_end_DASH_column, int(22), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_sym)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_intern) + tmp4 := checkDerefVar(var_glojure_DOT_core_create_DASH_ns) + tmp5 := checkDerefVar(var_glojure_DOT_core_symbol) + tmp6 := checkDerefVar(var_glojure_DOT_core_namespace) + tmp7 := lang.Apply(tmp6, []any{v2}) + tmp8 := lang.Apply(tmp5, []any{tmp7}) + tmp9 := lang.Apply(tmp4, []any{tmp8}) + tmp10 := checkDerefVar(var_glojure_DOT_core_symbol) + tmp11 := checkDerefVar(var_glojure_DOT_core_name) + tmp12 := lang.Apply(tmp11, []any{v2}) + tmp13 := lang.Apply(tmp10, []any{tmp12}) + tmp14 := lang.Apply(tmp3, []any{tmp9, tmp13}) + return tmp14 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_data_DASH_reader_DASH_var = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_data_DASH_reader_DASH_var.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // def-aset + { + tmp0 := sym_def_DASH_aset.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym_method, sym_coerce)), kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(3), kw_line, int(3935), kw_end_DASH_line, int(3936), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 5) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_core_SLASH_defn}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{v4}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_apply) + tmp15 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp16 := checkDerefVar(var_glojure_DOT_core_seq) + tmp17 := checkDerefVar(var_glojure_DOT_core_concat) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{kw_arglists}) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := checkDerefVar(var_glojure_DOT_core_seq) + tmp22 := checkDerefVar(var_glojure_DOT_core_concat) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := lang.Apply(tmp23, []any{sym_quote}) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := checkDerefVar(var_glojure_DOT_core_seq) + tmp27 := checkDerefVar(var_glojure_DOT_core_concat) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := checkDerefVar(var_glojure_DOT_core_apply) + tmp30 := checkDerefVar(var_glojure_DOT_core_vector) + tmp31 := checkDerefVar(var_glojure_DOT_core_seq) + tmp32 := checkDerefVar(var_glojure_DOT_core_concat) + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{sym_array}) + tmp35 := checkDerefVar(var_glojure_DOT_core_list) + tmp36 := lang.Apply(tmp35, []any{sym_idx}) + tmp37 := checkDerefVar(var_glojure_DOT_core_list) + tmp38 := lang.Apply(tmp37, []any{sym_val}) + tmp39 := lang.Apply(tmp32, []any{tmp34, tmp36, tmp38}) + tmp40 := lang.Apply(tmp31, []any{tmp39}) + tmp41 := lang.Apply(tmp29, []any{tmp30, tmp40}) + tmp42 := lang.Apply(tmp28, []any{tmp41}) + tmp43 := checkDerefVar(var_glojure_DOT_core_list) + tmp44 := checkDerefVar(var_glojure_DOT_core_apply) + tmp45 := checkDerefVar(var_glojure_DOT_core_vector) + tmp46 := checkDerefVar(var_glojure_DOT_core_seq) + tmp47 := checkDerefVar(var_glojure_DOT_core_concat) + tmp48 := checkDerefVar(var_glojure_DOT_core_list) + tmp49 := lang.Apply(tmp48, []any{sym_array}) + tmp50 := checkDerefVar(var_glojure_DOT_core_list) + tmp51 := lang.Apply(tmp50, []any{sym_idx}) + tmp52 := checkDerefVar(var_glojure_DOT_core_list) + tmp53 := lang.Apply(tmp52, []any{sym_idx2}) + tmp54 := checkDerefVar(var_glojure_DOT_core_list) + tmp55 := lang.Apply(tmp54, []any{sym__AMP_}) + tmp56 := checkDerefVar(var_glojure_DOT_core_list) + tmp57 := lang.Apply(tmp56, []any{sym_idxv}) + tmp58 := lang.Apply(tmp47, []any{tmp49, tmp51, tmp53, tmp55, tmp57}) + tmp59 := lang.Apply(tmp46, []any{tmp58}) + tmp60 := lang.Apply(tmp44, []any{tmp45, tmp59}) + tmp61 := lang.Apply(tmp43, []any{tmp60}) + tmp62 := lang.Apply(tmp27, []any{tmp42, tmp61}) + tmp63 := lang.Apply(tmp26, []any{tmp62}) + tmp64 := lang.Apply(tmp25, []any{tmp63}) + tmp65 := lang.Apply(tmp22, []any{tmp24, tmp64}) + tmp66 := lang.Apply(tmp21, []any{tmp65}) + tmp67 := lang.Apply(tmp20, []any{tmp66}) + tmp68 := lang.Apply(tmp17, []any{tmp19, tmp67}) + tmp69 := lang.Apply(tmp16, []any{tmp68}) + tmp70 := lang.Apply(tmp14, []any{tmp15, tmp69}) + tmp71 := lang.Apply(tmp13, []any{tmp70}) + tmp72 := checkDerefVar(var_glojure_DOT_core_list) + tmp73 := checkDerefVar(var_glojure_DOT_core_seq) + tmp74 := checkDerefVar(var_glojure_DOT_core_concat) + tmp75 := checkDerefVar(var_glojure_DOT_core_list) + tmp76 := checkDerefVar(var_glojure_DOT_core_apply) + tmp77 := checkDerefVar(var_glojure_DOT_core_vector) + tmp78 := checkDerefVar(var_glojure_DOT_core_seq) + tmp79 := checkDerefVar(var_glojure_DOT_core_concat) + tmp80 := checkDerefVar(var_glojure_DOT_core_list) + tmp81 := lang.Apply(tmp80, []any{sym_array__0__auto__}) + tmp82 := checkDerefVar(var_glojure_DOT_core_list) + tmp83 := lang.Apply(tmp82, []any{sym_idx__1__auto__}) + tmp84 := checkDerefVar(var_glojure_DOT_core_list) + tmp85 := lang.Apply(tmp84, []any{sym_val__2__auto__}) + tmp86 := lang.Apply(tmp79, []any{tmp81, tmp83, tmp85}) + tmp87 := lang.Apply(tmp78, []any{tmp86}) + tmp88 := lang.Apply(tmp76, []any{tmp77, tmp87}) + tmp89 := lang.Apply(tmp75, []any{tmp88}) + tmp90 := checkDerefVar(var_glojure_DOT_core_list) + tmp91 := checkDerefVar(var_glojure_DOT_core_seq) + tmp92 := checkDerefVar(var_glojure_DOT_core_concat) + tmp93 := checkDerefVar(var_glojure_DOT_core_list) + tmp94 := lang.Apply(tmp93, []any{sym__DOT_}) + tmp95 := checkDerefVar(var_glojure_DOT_core_list) + tmp96 := lang.Apply(tmp95, []any{sym_glojure_DOT_core_SLASH_Array}) + tmp97 := checkDerefVar(var_glojure_DOT_core_list) + tmp98 := checkDerefVar(var_glojure_DOT_core_seq) + tmp99 := checkDerefVar(var_glojure_DOT_core_concat) + tmp100 := checkDerefVar(var_glojure_DOT_core_list) + tmp101 := lang.Apply(tmp100, []any{v5}) + tmp102 := checkDerefVar(var_glojure_DOT_core_list) + tmp103 := lang.Apply(tmp102, []any{sym_array__0__auto__}) + tmp104 := checkDerefVar(var_glojure_DOT_core_list) + tmp105 := lang.Apply(tmp104, []any{sym_idx__1__auto__}) + tmp106 := checkDerefVar(var_glojure_DOT_core_list) + tmp107 := checkDerefVar(var_glojure_DOT_core_seq) + tmp108 := checkDerefVar(var_glojure_DOT_core_concat) + tmp109 := checkDerefVar(var_glojure_DOT_core_list) + tmp110 := lang.Apply(tmp109, []any{v6}) + tmp111 := checkDerefVar(var_glojure_DOT_core_list) + tmp112 := lang.Apply(tmp111, []any{sym_val__2__auto__}) + tmp113 := lang.Apply(tmp108, []any{tmp110, tmp112}) + tmp114 := lang.Apply(tmp107, []any{tmp113}) + tmp115 := lang.Apply(tmp106, []any{tmp114}) + tmp116 := lang.Apply(tmp99, []any{tmp101, tmp103, tmp105, tmp115}) + tmp117 := lang.Apply(tmp98, []any{tmp116}) + tmp118 := lang.Apply(tmp97, []any{tmp117}) + tmp119 := lang.Apply(tmp92, []any{tmp94, tmp96, tmp118}) + tmp120 := lang.Apply(tmp91, []any{tmp119}) + tmp121 := lang.Apply(tmp90, []any{tmp120}) + tmp122 := checkDerefVar(var_glojure_DOT_core_list) + tmp123 := lang.Apply(tmp122, []any{sym_val__2__auto__}) + tmp124 := lang.Apply(tmp74, []any{tmp89, tmp121, tmp123}) + tmp125 := lang.Apply(tmp73, []any{tmp124}) + tmp126 := lang.Apply(tmp72, []any{tmp125}) + tmp127 := checkDerefVar(var_glojure_DOT_core_list) + tmp128 := checkDerefVar(var_glojure_DOT_core_seq) + tmp129 := checkDerefVar(var_glojure_DOT_core_concat) + tmp130 := checkDerefVar(var_glojure_DOT_core_list) + tmp131 := checkDerefVar(var_glojure_DOT_core_apply) + tmp132 := checkDerefVar(var_glojure_DOT_core_vector) + tmp133 := checkDerefVar(var_glojure_DOT_core_seq) + tmp134 := checkDerefVar(var_glojure_DOT_core_concat) + tmp135 := checkDerefVar(var_glojure_DOT_core_list) + tmp136 := lang.Apply(tmp135, []any{sym_array__0__auto__}) + tmp137 := checkDerefVar(var_glojure_DOT_core_list) + tmp138 := lang.Apply(tmp137, []any{sym_idx__1__auto__}) + tmp139 := checkDerefVar(var_glojure_DOT_core_list) + tmp140 := lang.Apply(tmp139, []any{sym_idx2__3__auto__}) + tmp141 := checkDerefVar(var_glojure_DOT_core_list) + tmp142 := lang.Apply(tmp141, []any{sym__AMP_}) + tmp143 := checkDerefVar(var_glojure_DOT_core_list) + tmp144 := lang.Apply(tmp143, []any{sym_idxv__4__auto__}) + tmp145 := lang.Apply(tmp134, []any{tmp136, tmp138, tmp140, tmp142, tmp144}) + tmp146 := lang.Apply(tmp133, []any{tmp145}) + tmp147 := lang.Apply(tmp131, []any{tmp132, tmp146}) + tmp148 := lang.Apply(tmp130, []any{tmp147}) + tmp149 := checkDerefVar(var_glojure_DOT_core_list) + tmp150 := checkDerefVar(var_glojure_DOT_core_seq) + tmp151 := checkDerefVar(var_glojure_DOT_core_concat) + tmp152 := checkDerefVar(var_glojure_DOT_core_list) + tmp153 := lang.Apply(tmp152, []any{sym_glojure_DOT_core_SLASH_apply}) + tmp154 := checkDerefVar(var_glojure_DOT_core_list) + tmp155 := lang.Apply(tmp154, []any{v4}) + tmp156 := checkDerefVar(var_glojure_DOT_core_list) + tmp157 := checkDerefVar(var_glojure_DOT_core_seq) + tmp158 := checkDerefVar(var_glojure_DOT_core_concat) + tmp159 := checkDerefVar(var_glojure_DOT_core_list) + tmp160 := lang.Apply(tmp159, []any{sym_glojure_DOT_core_SLASH_aget}) + tmp161 := checkDerefVar(var_glojure_DOT_core_list) + tmp162 := lang.Apply(tmp161, []any{sym_array__0__auto__}) + tmp163 := checkDerefVar(var_glojure_DOT_core_list) + tmp164 := lang.Apply(tmp163, []any{sym_idx__1__auto__}) + tmp165 := lang.Apply(tmp158, []any{tmp160, tmp162, tmp164}) + tmp166 := lang.Apply(tmp157, []any{tmp165}) + tmp167 := lang.Apply(tmp156, []any{tmp166}) + tmp168 := checkDerefVar(var_glojure_DOT_core_list) + tmp169 := lang.Apply(tmp168, []any{sym_idx2__3__auto__}) + tmp170 := checkDerefVar(var_glojure_DOT_core_list) + tmp171 := lang.Apply(tmp170, []any{sym_idxv__4__auto__}) + tmp172 := lang.Apply(tmp151, []any{tmp153, tmp155, tmp167, tmp169, tmp171}) + tmp173 := lang.Apply(tmp150, []any{tmp172}) + tmp174 := lang.Apply(tmp149, []any{tmp173}) + tmp175 := lang.Apply(tmp129, []any{tmp148, tmp174}) + tmp176 := lang.Apply(tmp128, []any{tmp175}) + tmp177 := lang.Apply(tmp127, []any{tmp176}) + tmp178 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp71, tmp126, tmp177}) + tmp179 := lang.Apply(tmp7, []any{tmp178}) + return tmp179 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_def_DASH_aset = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_def_DASH_aset.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // definline + { + tmp0 := sym_definline.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym__AMP_, sym_decl)), kw_doc, "Experimental - like defmacro, except defines a named function whose\n body is the expansion, calls to which may be expanded inline as if\n it were a macro. Cannot be used with variadic (&) args.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(11), kw_line, int(5253), kw_end_DASH_line, int(5253))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "vec__771" + tmp7 := checkDerefVar(var_glojure_DOT_core_split_DASH_with) + tmp8 := checkDerefVar(var_glojure_DOT_core_comp) + tmp9 := checkDerefVar(var_glojure_DOT_core_not) + tmp10 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp11 := lang.Apply(tmp8, []any{tmp9, tmp10}) + tmp12 := lang.Apply(tmp7, []any{tmp11, v5}) + var v13 any = tmp12 + _ = v13 + // let binding "pre-args" + tmp14 := checkDerefVar(var_glojure_DOT_core_nth) + tmp15 := lang.Apply(tmp14, []any{v13, int64(0), nil}) + var v16 any = tmp15 + _ = v16 + // let binding "vec__774" + tmp17 := checkDerefVar(var_glojure_DOT_core_nth) + tmp18 := lang.Apply(tmp17, []any{v13, int64(1), nil}) + var v19 any = tmp18 + _ = v19 + // let binding "args" + tmp20 := checkDerefVar(var_glojure_DOT_core_nth) + tmp21 := lang.Apply(tmp20, []any{v19, int64(0), nil}) + var v22 any = tmp21 + _ = v22 + // let binding "expr" + tmp23 := checkDerefVar(var_glojure_DOT_core_nth) + tmp24 := lang.Apply(tmp23, []any{v19, int64(1), nil}) + var v25 any = tmp24 + _ = v25 + tmp26 := checkDerefVar(var_glojure_DOT_core_seq) + tmp27 := checkDerefVar(var_glojure_DOT_core_concat) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := lang.Apply(tmp28, []any{sym_do}) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := checkDerefVar(var_glojure_DOT_core_seq) + tmp32 := checkDerefVar(var_glojure_DOT_core_concat) + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{sym_glojure_DOT_core_SLASH_defn}) + tmp35 := checkDerefVar(var_glojure_DOT_core_list) + tmp36 := lang.Apply(tmp35, []any{v4}) + tmp37 := checkDerefVar(var_glojure_DOT_core_list) + tmp38 := lang.Apply(tmp37, []any{v22}) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := checkDerefVar(var_glojure_DOT_core_apply) + tmp41 := checkDerefVar(var_glojure_DOT_core_eval) + tmp42 := checkDerefVar(var_glojure_DOT_core_list) + tmp43 := lang.Apply(tmp42, []any{sym_glojure_DOT_core_SLASH_fn, v22, v25}) + tmp44 := lang.Apply(tmp41, []any{tmp43}) + tmp45 := lang.Apply(tmp40, []any{tmp44, v22}) + tmp46 := lang.Apply(tmp39, []any{tmp45}) + tmp47 := lang.Apply(tmp32, []any{tmp34, tmp36, v16, tmp38, tmp46}) + tmp48 := lang.Apply(tmp31, []any{tmp47}) + tmp49 := lang.Apply(tmp30, []any{tmp48}) + tmp50 := checkDerefVar(var_glojure_DOT_core_list) + tmp51 := checkDerefVar(var_glojure_DOT_core_seq) + tmp52 := checkDerefVar(var_glojure_DOT_core_concat) + tmp53 := checkDerefVar(var_glojure_DOT_core_list) + tmp54 := lang.Apply(tmp53, []any{sym_glojure_DOT_core_SLASH_alter_DASH_meta_BANG_}) + tmp55 := checkDerefVar(var_glojure_DOT_core_list) + tmp56 := checkDerefVar(var_glojure_DOT_core_seq) + tmp57 := checkDerefVar(var_glojure_DOT_core_concat) + tmp58 := checkDerefVar(var_glojure_DOT_core_list) + tmp59 := lang.Apply(tmp58, []any{sym_var}) + tmp60 := checkDerefVar(var_glojure_DOT_core_list) + tmp61 := lang.Apply(tmp60, []any{v4}) + tmp62 := lang.Apply(tmp57, []any{tmp59, tmp61}) + tmp63 := lang.Apply(tmp56, []any{tmp62}) + tmp64 := lang.Apply(tmp55, []any{tmp63}) + tmp65 := checkDerefVar(var_glojure_DOT_core_list) + tmp66 := lang.Apply(tmp65, []any{sym_glojure_DOT_core_SLASH_assoc}) + tmp67 := checkDerefVar(var_glojure_DOT_core_list) + tmp68 := lang.Apply(tmp67, []any{kw_inline}) + tmp69 := checkDerefVar(var_glojure_DOT_core_list) + tmp70 := checkDerefVar(var_glojure_DOT_core_seq) + tmp71 := checkDerefVar(var_glojure_DOT_core_concat) + tmp72 := checkDerefVar(var_glojure_DOT_core_list) + tmp73 := lang.Apply(tmp72, []any{sym_glojure_DOT_core_SLASH_fn}) + tmp74 := checkDerefVar(var_glojure_DOT_core_list) + tmp75 := lang.Apply(tmp74, []any{v4}) + tmp76 := checkDerefVar(var_glojure_DOT_core_list) + tmp77 := lang.Apply(tmp76, []any{v22}) + tmp78 := checkDerefVar(var_glojure_DOT_core_list) + tmp79 := lang.Apply(tmp78, []any{v25}) + tmp80 := lang.Apply(tmp71, []any{tmp73, tmp75, tmp77, tmp79}) + tmp81 := lang.Apply(tmp70, []any{tmp80}) + tmp82 := lang.Apply(tmp69, []any{tmp81}) + tmp83 := lang.Apply(tmp52, []any{tmp54, tmp64, tmp66, tmp68, tmp82}) + tmp84 := lang.Apply(tmp51, []any{tmp83}) + tmp85 := lang.Apply(tmp50, []any{tmp84}) + tmp86 := checkDerefVar(var_glojure_DOT_core_list) + tmp87 := checkDerefVar(var_glojure_DOT_core_seq) + tmp88 := checkDerefVar(var_glojure_DOT_core_concat) + tmp89 := checkDerefVar(var_glojure_DOT_core_list) + tmp90 := lang.Apply(tmp89, []any{sym_var}) + tmp91 := checkDerefVar(var_glojure_DOT_core_list) + tmp92 := lang.Apply(tmp91, []any{v4}) + tmp93 := lang.Apply(tmp88, []any{tmp90, tmp92}) + tmp94 := lang.Apply(tmp87, []any{tmp93}) + tmp95 := lang.Apply(tmp86, []any{tmp94}) + tmp96 := lang.Apply(tmp27, []any{tmp29, tmp49, tmp85, tmp95}) + tmp97 := lang.Apply(tmp26, []any{tmp96}) + tmp6 = tmp97 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_definline = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_definline.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // defmacro + { + tmp0 := sym_defmacro.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym_doc_DASH_string_QMARK_, sym_attr_DASH_map_QMARK_, lang.NewVector(sym_params_STAR_), sym_body), lang.NewVector(sym_name, sym_doc_DASH_string_QMARK_, sym_attr_DASH_map_QMARK_, lang.NewList(lang.NewVector(sym_params_STAR_), sym_body), sym__PLUS_, sym_attr_DASH_map_QMARK_)), kw_doc, "Like defn, but the resulting function name is declared as a\n macro and will be used as a macro by the compiler when it is\n called.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(2), kw_line, int(445), kw_end_DASH_line, int(451))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "prefix" + var tmp7 any + { // let + // let binding "p" + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{v4}) + var v10 any = tmp9 + _ = v10 + // let binding "args" + var v11 any = v5 + _ = v11 + for { + var tmp12 any + { // let + // let binding "f" + tmp13 := checkDerefVar(var_glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v11}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + tmp17 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp18 := lang.Apply(tmp17, []any{v15}) + if lang.IsTruthy(tmp18) { + tmp20 := checkDerefVar(var_glojure_DOT_core_cons) + tmp21 := lang.Apply(tmp20, []any{v15, v10}) + var tmp19 any = tmp21 + tmp23 := checkDerefVar(var_glojure_DOT_core_next) + tmp24 := lang.Apply(tmp23, []any{v11}) + var tmp22 any = tmp24 + v10 = tmp19 + v11 = tmp22 + continue + } else { + var tmp25 any + tmp26 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp27 := lang.Apply(tmp26, []any{v15}) + if lang.IsTruthy(tmp27) { + tmp29 := checkDerefVar(var_glojure_DOT_core_cons) + tmp30 := lang.Apply(tmp29, []any{v15, v10}) + var tmp28 any = tmp30 + tmp32 := checkDerefVar(var_glojure_DOT_core_next) + tmp33 := lang.Apply(tmp32, []any{v11}) + var tmp31 any = tmp33 + v10 = tmp28 + v11 = tmp31 + continue + } else { + tmp25 = v10 + } + tmp16 = tmp25 + } + tmp12 = tmp16 + } // end let + tmp7 = tmp12 + break + } + } // end let + var v8 any = tmp7 + _ = v8 + // let binding "fdecl" + var tmp9 any + { // let + // let binding "fd" + var v10 any = v5 + _ = v10 + for { + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp13 := checkDerefVar(var_glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v10}) + tmp15 := lang.Apply(tmp12, []any{tmp14}) + if lang.IsTruthy(tmp15) { + tmp17 := checkDerefVar(var_glojure_DOT_core_next) + tmp18 := lang.Apply(tmp17, []any{v10}) + var tmp16 any = tmp18 + v10 = tmp16 + continue + } else { + var tmp19 any + tmp20 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp21 := checkDerefVar(var_glojure_DOT_core_first) + tmp22 := lang.Apply(tmp21, []any{v10}) + tmp23 := lang.Apply(tmp20, []any{tmp22}) + if lang.IsTruthy(tmp23) { + tmp25 := checkDerefVar(var_glojure_DOT_core_next) + tmp26 := lang.Apply(tmp25, []any{v10}) + var tmp24 any = tmp26 + v10 = tmp24 + continue + } else { + tmp19 = v10 + } + tmp11 = tmp19 + } + tmp9 = tmp11 + break + } + } // end let + var v10 any = tmp9 + _ = v10 + // let binding "fdecl" + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp13 := checkDerefVar(var_glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v10}) + tmp15 := lang.Apply(tmp12, []any{tmp14}) + if lang.IsTruthy(tmp15) { + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v10}) + tmp11 = tmp17 + } else { + tmp11 = v10 + } + var v18 any = tmp11 + _ = v18 + // let binding "add-implicit-args" + var tmp19 lang.FnFunc + tmp19 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v20 := args[0] + _ = v20 + var tmp21 any + { // let + // let binding "args" + tmp22 := checkDerefVar(var_glojure_DOT_core_first) + tmp23 := lang.Apply(tmp22, []any{v20}) + var v24 any = tmp23 + _ = v24 + tmp25 := checkDerefVar(var_glojure_DOT_core_cons) + tmp26 := checkDerefVar(var_glojure_DOT_core_vec) + tmp27 := checkDerefVar(var_glojure_DOT_core_cons) + tmp28 := checkDerefVar(var_glojure_DOT_core_cons) + tmp29 := lang.Apply(tmp28, []any{sym__AMP_env, v24}) + tmp30 := lang.Apply(tmp27, []any{sym__AMP_form, tmp29}) + tmp31 := lang.Apply(tmp26, []any{tmp30}) + tmp32 := checkDerefVar(var_glojure_DOT_core_next) + tmp33 := lang.Apply(tmp32, []any{v20}) + tmp34 := lang.Apply(tmp25, []any{tmp31, tmp33}) + tmp21 = tmp34 + } // end let + return tmp21 + }) + tmp20 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(469), kw_column, int(38), kw_end_DASH_line, int(471), kw_end_DASH_column, int(87)) + tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v22 any = tmp21 + _ = v22 + // let binding "add-args" + var tmp23 lang.FnFunc + tmp23 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v24 := args[0] + _ = v24 + v25 := args[1] + _ = v25 + recur_loop_1601: + var tmp26 any + tmp27 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp28 := lang.Apply(tmp27, []any{v25}) + if lang.IsTruthy(tmp28) { + tmp26 = v24 + } else { + var tmp29 any + { // let + // let binding "d" + tmp30 := checkDerefVar(var_glojure_DOT_core_first) + tmp31 := lang.Apply(tmp30, []any{v25}) + var v32 any = tmp31 + _ = v32 + var tmp33 any + tmp34 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp35 := lang.Apply(tmp34, []any{v32}) + if lang.IsTruthy(tmp35) { + tmp36 := checkDerefVar(var_glojure_DOT_core_conj) + tmp37 := lang.Apply(tmp36, []any{v24, v32}) + tmp33 = tmp37 + } else { + tmp39 := checkDerefVar(var_glojure_DOT_core_conj) + tmp40 := lang.Apply(v22, []any{v32}) + tmp41 := lang.Apply(tmp39, []any{v24, tmp40}) + var tmp38 any = tmp41 + tmp43 := checkDerefVar(var_glojure_DOT_core_next) + tmp44 := lang.Apply(tmp43, []any{v25}) + var tmp42 any = tmp44 + v24 = tmp38 + v25 = tmp42 + goto recur_loop_1601 + } + tmp29 = tmp33 + } // end let + tmp26 = tmp29 + } + return tmp26 + }) + tmp24 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(472), kw_column, int(29), kw_end_DASH_line, int(478), kw_end_DASH_column, int(90)) + tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v26 any = tmp25 + _ = v26 + // let binding "fdecl" + tmp27 := checkDerefVar(var_glojure_DOT_core_seq) + tmp28 := lang.NewVector() + tmp29 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(479), kw_column, int(41), kw_end_DASH_line, int(479), kw_end_DASH_column, int(42)) + tmp30, err := lang.WithMeta(tmp28, tmp29.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp31 := lang.Apply(v26, []any{tmp30, v18}) + tmp32 := lang.Apply(tmp27, []any{tmp31}) + var v33 any = tmp32 + _ = v33 + // let binding "decl" + var tmp34 any + { // let + // let binding "p" + var v35 any = v8 + _ = v35 + // let binding "d" + var v36 any = v33 + _ = v36 + for { + var tmp37 any + if lang.IsTruthy(v35) { + tmp39 := checkDerefVar(var_glojure_DOT_core_next) + tmp40 := lang.Apply(tmp39, []any{v35}) + var tmp38 any = tmp40 + tmp42 := checkDerefVar(var_glojure_DOT_core_cons) + tmp43 := checkDerefVar(var_glojure_DOT_core_first) + tmp44 := lang.Apply(tmp43, []any{v35}) + tmp45 := lang.Apply(tmp42, []any{tmp44, v36}) + var tmp41 any = tmp45 + v35 = tmp38 + v36 = tmp41 + continue + } else { + tmp37 = v36 + } + tmp34 = tmp37 + break + } + } // end let + var v35 any = tmp34 + _ = v35 + tmp36 := checkDerefVar(var_glojure_DOT_core_list) + tmp37 := checkDerefVar(var_glojure_DOT_core_cons) + tmp38 := lang.Apply(tmp37, []any{sym_glojure_DOT_core_SLASH_defn, v35}) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{sym_var, v4}) + tmp42 := lang.Apply(tmp39, []any{sym__DOT_, tmp41, lang.NewList(sym_SetMacro)}) + tmp43 := checkDerefVar(var_glojure_DOT_core_list) + tmp44 := lang.Apply(tmp43, []any{sym_var, v4}) + tmp45 := lang.Apply(tmp36, []any{sym_do, tmp38, tmp42, tmp44}) + tmp6 = tmp45 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(451), kw_column, int(11), kw_end_DASH_line, int(487), kw_end_DASH_column, int(40))).(lang.FnFunc) + var_glojure_DOT_core_defmacro = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_defmacro.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // defn- + { + tmp0 := sym_defn_DASH_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym__AMP_, sym_decls)), kw_doc, "same as defn, yielding non-public def", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(11), kw_line, int(4949), kw_end_DASH_line, int(4949))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp7 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp8 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp9 := checkDerefVar(var_glojure_DOT_core_meta) + tmp10 := lang.Apply(tmp9, []any{v4}) + tmp11 := lang.Apply(tmp8, []any{tmp10, kw_private, true}) + tmp12 := lang.Apply(tmp7, []any{v4, tmp11}) + tmp13 := lang.Apply(tmp6, []any{sym_glojure_DOT_core_SLASH_defn, tmp12, v5}) + return tmp13 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_defn_DASH_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_defn_DASH_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // defonce + { + tmp0 := sym_defonce.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym_expr)), kw_doc, "defs name to have the root value of the expr iff the named var has no root value,\n else expr is unevaluated", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(5806), kw_end_DASH_line, int(5806))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_let}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + tmp12 := checkDerefVar(var_glojure_DOT_core_vector) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_v__0__auto__}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{sym_def}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v4}) + tmp24 := lang.Apply(tmp19, []any{tmp21, tmp23}) + tmp25 := lang.Apply(tmp18, []any{tmp24}) + tmp26 := lang.Apply(tmp17, []any{tmp25}) + tmp27 := lang.Apply(tmp14, []any{tmp16, tmp26}) + tmp28 := lang.Apply(tmp13, []any{tmp27}) + tmp29 := lang.Apply(tmp11, []any{tmp12, tmp28}) + tmp30 := lang.Apply(tmp10, []any{tmp29}) + tmp31 := checkDerefVar(var_glojure_DOT_core_list) + tmp32 := checkDerefVar(var_glojure_DOT_core_seq) + tmp33 := checkDerefVar(var_glojure_DOT_core_concat) + tmp34 := checkDerefVar(var_glojure_DOT_core_list) + tmp35 := lang.Apply(tmp34, []any{sym_glojure_DOT_core_SLASH_when_DASH_not}) + tmp36 := checkDerefVar(var_glojure_DOT_core_list) + tmp37 := checkDerefVar(var_glojure_DOT_core_seq) + tmp38 := checkDerefVar(var_glojure_DOT_core_concat) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := lang.Apply(tmp39, []any{sym__DOT_HasRoot}) + tmp41 := checkDerefVar(var_glojure_DOT_core_list) + tmp42 := lang.Apply(tmp41, []any{sym_v__0__auto__}) + tmp43 := lang.Apply(tmp38, []any{tmp40, tmp42}) + tmp44 := lang.Apply(tmp37, []any{tmp43}) + tmp45 := lang.Apply(tmp36, []any{tmp44}) + tmp46 := checkDerefVar(var_glojure_DOT_core_list) + tmp47 := checkDerefVar(var_glojure_DOT_core_seq) + tmp48 := checkDerefVar(var_glojure_DOT_core_concat) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) + tmp50 := lang.Apply(tmp49, []any{sym_def}) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := lang.Apply(tmp51, []any{v4}) + tmp53 := checkDerefVar(var_glojure_DOT_core_list) + tmp54 := lang.Apply(tmp53, []any{v5}) + tmp55 := lang.Apply(tmp48, []any{tmp50, tmp52, tmp54}) + tmp56 := lang.Apply(tmp47, []any{tmp55}) + tmp57 := lang.Apply(tmp46, []any{tmp56}) + tmp58 := lang.Apply(tmp33, []any{tmp35, tmp45, tmp57}) + tmp59 := lang.Apply(tmp32, []any{tmp58}) + tmp60 := lang.Apply(tmp31, []any{tmp59}) + tmp61 := lang.Apply(tmp7, []any{tmp9, tmp30, tmp60}) + tmp62 := lang.Apply(tmp6, []any{tmp61}) + return tmp62 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_defonce = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_defonce.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // delay + { + tmp0 := sym_delay.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_body)), kw_doc, "Takes a body of expressions and yields a Delay object that will\n invoke the body only the first time it is forced (with force or deref/@), and\n will cache the result and return it on all subsequent force\n calls. See also - realized?", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(11), kw_line, int(739), kw_end_DASH_line, int(739))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_list) + tmp6 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp7 := lang.NewVector() + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(746), kw_column, int(62), kw_end_DASH_line, int(746), kw_end_DASH_column, int(63)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp10 := lang.Apply(tmp6, []any{sym_fn_STAR_, tmp9, v4}) + tmp11 := lang.Apply(tmp5, []any{sym_new, sym_glojure_DOT_lang_DOT_Delay, tmp10}) + return tmp11 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_delay = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_delay.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // deref-as-map + { + tmp0 := sym_deref_DASH_as_DASH_map.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(408), kw_column, int(8), kw_end_DASH_line, int(408), kw_end_DASH_column, int(19), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_o)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "pending" + var tmp4 any + { // let + // let binding "and__0__auto__" + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp6 := reflect.TypeOf((*lang.IPending)(nil)).Elem() + tmp7 := lang.Apply(tmp5, []any{tmp6, v2}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + tmp10 := checkDerefVar(var_glojure_DOT_core_not) + tmp11, ok := lang.FieldOrMethod(v2, "isRealized") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "isRealized"))) + } + var tmp12 any + switch reflect.TypeOf(tmp11).Kind() { + case reflect.Func: + tmp12 = lang.Apply(tmp11, nil) + default: + tmp12 = tmp11 + } + tmp13 := lang.Apply(tmp10, []any{tmp12}) + tmp9 = tmp13 + } else { + tmp9 = v8 + } + tmp4 = tmp9 + } // end let + var v5 any = tmp4 + _ = v5 + // let binding "vec__941" + var tmp6 any + if lang.IsTruthy(v5) { + } else { + var tmp7 any + func() { + defer func() { + if r := recover(); r != nil { + if lang.CatchMatches(r, lang.Throwable) { + v8 := r + _ = v8 + tmp9 := lang.NewVector(true, v8) + tmp10 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(415), kw_column, int(18), kw_end_DASH_line, int(415), kw_end_DASH_column, int(25)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp7 = tmp11 + } else { + panic(r) + } + } + }() + tmp8 := checkDerefVar(var_glojure_DOT_core_deref) + tmp9 := lang.Apply(tmp8, []any{v2}) + tmp10 := lang.NewVector(false, tmp9) + tmp11 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(413), kw_column, int(16), kw_end_DASH_line, int(413), kw_end_DASH_column, int(32)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp7 = tmp12 + }() + tmp6 = tmp7 + } + var v13 any = tmp6 + _ = v13 + // let binding "ex" + tmp14 := checkDerefVar(var_glojure_DOT_core_nth) + tmp15 := lang.Apply(tmp14, []any{v13, int64(0), nil}) + var v16 any = tmp15 + _ = v16 + // let binding "val" + tmp17 := checkDerefVar(var_glojure_DOT_core_nth) + tmp18 := lang.Apply(tmp17, []any{v13, int64(1), nil}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + var tmp21 any + { // let + // let binding "or__0__auto__" + var v22 any = v16 + _ = v22 + var tmp23 any + if lang.IsTruthy(v22) { + tmp23 = v22 + } else { + var tmp24 any + { // let + // let binding "and__0__auto__" + tmp25 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp26 := reflect.TypeOf((*lang.Agent)(nil)) + tmp27 := lang.Apply(tmp25, []any{tmp26, v2}) + var v28 any = tmp27 + _ = v28 + var tmp29 any + if lang.IsTruthy(v28) { + tmp30 := checkDerefVar(var_glojure_DOT_core_agent_DASH_error) + tmp31 := lang.Apply(tmp30, []any{v2}) + tmp29 = tmp31 + } else { + tmp29 = v28 + } + tmp24 = tmp29 + } // end let + tmp23 = tmp24 + } + tmp21 = tmp23 + } // end let + if lang.IsTruthy(tmp21) { + tmp20 = kw_failed + } else { + var tmp22 any + if lang.IsTruthy(v5) { + tmp22 = kw_pending + } else { + var tmp23 any + if lang.IsTruthy(kw_else) { + tmp23 = kw_ready + } else { + } + tmp22 = tmp23 + } + tmp20 = tmp22 + } + tmp24 := lang.NewMap(kw_status, tmp20, kw_val, v19) + tmp25 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(416), kw_column, int(5), kw_end_DASH_line, int(429), kw_end_DASH_column, int(14)) + tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp3 = tmp26 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_deref_DASH_as_DASH_map = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_deref_DASH_as_DASH_map.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // descendants + { + tmp0 := sym_descendants.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_tag), lang.NewVector(sym_h, sym_tag)), kw_doc, "Returns the immediate and indirect children of tag, through a\n relationship established via derive. h must be a hierarchy obtained\n from make-hierarchy, if not supplied defaults to the global\n hierarchy. Note: does not work on Java type inheritance\n relationships.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(5593), kw_end_DASH_line, int(5593))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_descendants) + tmp4 := checkDerefVar(var_glojure_DOT_core_global_DASH_hierarchy) + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_class_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + tmp7 := lang.Apply(lang.NewUnsupportedOperationError, []any{"Can't get descendants of classes"}) + panic(tmp7) + } else { + tmp8 := checkDerefVar(var_glojure_DOT_core_not_DASH_empty) + tmp9 := checkDerefVar(var_glojure_DOT_core_get) + tmp10 := lang.Apply(kw_descendants, []any{v2}) + tmp11 := lang.Apply(tmp9, []any{tmp10, v3}) + tmp12 := lang.Apply(tmp8, []any{tmp11}) + tmp4 = tmp12 + } + return tmp4 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_descendants = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_descendants.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // distinct + { + tmp0 := sym_distinct.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_coll)), kw_doc, "Returns a lazy sequence of the elements of coll with duplicates removed.\n Returns a stateful transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(5053), kw_end_DASH_line, int(5053))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + var tmp4 any + { // let + // let binding "seen" + tmp5 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) + tmp6 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5060), kw_column, int(28), kw_end_DASH_line, int(5060), kw_end_DASH_column, int(30)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp9 := lang.Apply(tmp5, []any{tmp8}) + var v10 any = tmp9 + _ = v10 + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp12 := lang.Apply(v3, nil) + return tmp12 + case 1: + v12 := args[0] + _ = v12 + tmp13 := lang.Apply(v3, []any{v12}) + return tmp13 + case 2: + v12 := args[0] + _ = v12 + v13 := args[1] + _ = v13 + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp16 := checkDerefVar(var_glojure_DOT_core_deref) + tmp17 := lang.Apply(tmp16, []any{v10}) + tmp18 := lang.Apply(tmp15, []any{tmp17, v13}) + if lang.IsTruthy(tmp18) { + tmp14 = v12 + } else { + tmp19 := checkDerefVar(var_glojure_DOT_core_conj) + tmp20, ok := lang.FieldOrMethod(v10, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v10, "Deref"))) + } + var tmp21 any + switch reflect.TypeOf(tmp20).Kind() { + case reflect.Func: + tmp21 = lang.Apply(tmp20, nil) + default: + tmp21 = tmp20 + } + tmp22 := lang.Apply(tmp19, []any{tmp21, v13}) + tmp23, _ := lang.FieldOrMethod(v10, "reset") + if reflect.TypeOf(tmp23).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) + } + tmp24 := lang.Apply(tmp23, []any{tmp22}) + _ = tmp24 + tmp25 := lang.Apply(v3, []any{v12, v13}) + tmp14 = tmp25 + } + return tmp14 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5061), kw_column, int(8), kw_end_DASH_line, int(5068), kw_end_DASH_column, int(37)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp4 = tmp13 + } // end let + return tmp4 + }) + tmp3 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5059), kw_column, int(4), kw_end_DASH_line, int(5068), kw_end_DASH_column, int(39)) + tmp4, err := lang.WithMeta(tmp2, tmp3.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp4 + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "step" + var tmp4 lang.FnFunc + { // function step + var v5 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + var tmp8 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + recur_loop_2417: + var tmp12 any + { // let + // let binding "vec__753" + var v13 any = v10 + _ = v13 + // let binding "f" + tmp14 := checkDerefVar(var_glojure_DOT_core_nth) + tmp15 := lang.Apply(tmp14, []any{v13, int64(0), nil}) + var v16 any = tmp15 + _ = v16 + // let binding "xs" + var v17 any = v13 + _ = v17 + var tmp18 any + { // let + // let binding "temp__0__auto__" + tmp19 := checkDerefVar(var_glojure_DOT_core_seq) + tmp20 := lang.Apply(tmp19, []any{v17}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + if lang.IsTruthy(v21) { + var tmp23 any + { // let + // let binding "s" + var v24 any = v21 + _ = v24 + var tmp25 any + tmp26 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp27 := lang.Apply(tmp26, []any{v11, v16}) + if lang.IsTruthy(tmp27) { + tmp29 := checkDerefVar(var_glojure_DOT_core_rest) + tmp30 := lang.Apply(tmp29, []any{v24}) + var tmp28 any = tmp30 + var tmp31 any = v11 + v10 = tmp28 + v11 = tmp31 + goto recur_loop_2417 + } else { + tmp32 := checkDerefVar(var_glojure_DOT_core_cons) + tmp33 := checkDerefVar(var_glojure_DOT_core_rest) + tmp34 := lang.Apply(tmp33, []any{v24}) + tmp35 := checkDerefVar(var_glojure_DOT_core_conj) + tmp36 := lang.Apply(tmp35, []any{v11, v16}) + tmp37 := lang.Apply(v5, []any{tmp34, tmp36}) + tmp38 := lang.Apply(tmp32, []any{v16, tmp37}) + tmp25 = tmp38 + } + tmp23 = tmp25 + } // end let + tmp22 = tmp23 + } else { + } + tmp18 = tmp22 + } // end let + tmp12 = tmp18 + } // end let + return tmp12 + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5072), kw_column, int(20), kw_end_DASH_line, int(5076), kw_end_DASH_column, int(66)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp12 := lang.Apply(tmp11, []any{v6, v7}) + return tmp12 + }) + tmp9 := lang.Apply(lang.NewLazySeq, []any{tmp8}) + return tmp9 + }) + v5 = tmp4 + _ = v5 + } + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5070), kw_column, int(15), kw_end_DASH_line, int(5077), kw_end_DASH_column, int(29)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v7 any = tmp6 + _ = v7 + tmp8 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5078), kw_column, int(17), kw_end_DASH_line, int(5078), kw_end_DASH_column, int(19)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp11 := lang.Apply(v7, []any{v2, tmp10}) + tmp3 = tmp11 + } // end let + return tmp3 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_distinct = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_distinct.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // dorun + { + tmp0 := sym_dorun.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll), lang.NewVector(sym_n, sym_coll)), kw_doc, "When lazy sequences are produced via functions that have side\n effects, any effects other than those needed to produce the first\n element in the seq do not occur until the seq is consumed. dorun can\n be used to force any effects. Walks through the successive nexts of\n the seq, does not retain the head and returns nil.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3116), kw_end_DASH_line, int(3116))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + recur_loop_2119: + var tmp3 any + { // let + // let binding "temp__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + var tmp8 any + { // let + // let binding "s" + var v9 any = v6 + _ = v9 + tmp11 := checkDerefVar(var_glojure_DOT_core_next) + tmp12 := lang.Apply(tmp11, []any{v9}) + var tmp10 any = tmp12 + v2 = tmp10 + goto recur_loop_2119 + } // end let + tmp7 = tmp8 + } else { + } + tmp3 = tmp7 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + recur_loop_2120: + var tmp4 any + var tmp5 any + { // let + // let binding "and__0__auto__" + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := lang.Apply(tmp6, []any{v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + tmp10 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp9 = tmp11 + } else { + tmp9 = v8 + } + tmp5 = tmp9 + } // end let + if lang.IsTruthy(tmp5) { + tmp7 := checkDerefVar(var_glojure_DOT_core_dec) + tmp8 := lang.Apply(tmp7, []any{v2}) + var tmp6 any = tmp8 + tmp10 := checkDerefVar(var_glojure_DOT_core_next) + tmp11 := lang.Apply(tmp10, []any{v3}) + var tmp9 any = tmp11 + v2 = tmp6 + v3 = tmp9 + goto recur_loop_2120 + } else { + } + return tmp4 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_dorun = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_dorun.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // dotimes + { + tmp0 := sym_dotimes.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "bindings => name n\n\n Repeatedly executes body (presumably for side-effects) with name\n bound to integers from 0 through n-1.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(3306), kw_end_DASH_line, int(3306))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v4}) + if lang.IsTruthy(tmp8) { + } else { + tmp9 := checkDerefVar(var_glojure_DOT_core_str) + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp13 := checkDerefVar(var_glojure_DOT_core_meta) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(kw_line, []any{tmp14}) + tmp16 := lang.Apply(tmp9, []any{tmp11, " requires ", "a vector for its binding", " in ", tmp12, ":", tmp15}) + tmp17 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp16}) + panic(tmp17) + } + _ = tmp6 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp20 := checkDerefVar(var_glojure_DOT_core_count) + tmp21 := lang.Apply(tmp20, []any{v4}) + tmp22 := lang.Apply(tmp19, []any{int64(2), tmp21}) + if lang.IsTruthy(tmp22) { + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp27 := checkDerefVar(var_glojure_DOT_core_meta) + tmp28 := lang.Apply(tmp27, []any{v2}) + tmp29 := lang.Apply(kw_line, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp25, " requires ", "exactly 2 forms in binding vector", " in ", tmp26, ":", tmp29}) + tmp31 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp31) + } + _ = tmp18 + var tmp32 any + { // let + // let binding "i" + tmp33 := checkDerefVar(var_glojure_DOT_core_first) + tmp34 := lang.Apply(tmp33, []any{v4}) + var v35 any = tmp34 + _ = v35 + // let binding "n" + tmp36 := checkDerefVar(var_glojure_DOT_core_second) + tmp37 := lang.Apply(tmp36, []any{v4}) + var v38 any = tmp37 + _ = v38 + tmp39 := checkDerefVar(var_glojure_DOT_core_seq) + tmp40 := checkDerefVar(var_glojure_DOT_core_concat) + tmp41 := checkDerefVar(var_glojure_DOT_core_list) + tmp42 := lang.Apply(tmp41, []any{sym_glojure_DOT_core_SLASH_let}) + tmp43 := checkDerefVar(var_glojure_DOT_core_list) + tmp44 := checkDerefVar(var_glojure_DOT_core_apply) + tmp45 := checkDerefVar(var_glojure_DOT_core_vector) + tmp46 := checkDerefVar(var_glojure_DOT_core_seq) + tmp47 := checkDerefVar(var_glojure_DOT_core_concat) + tmp48 := checkDerefVar(var_glojure_DOT_core_list) + tmp49 := lang.Apply(tmp48, []any{sym_n__0__auto__}) + tmp50 := checkDerefVar(var_glojure_DOT_core_list) + tmp51 := checkDerefVar(var_glojure_DOT_core_seq) + tmp52 := checkDerefVar(var_glojure_DOT_core_concat) + tmp53 := checkDerefVar(var_glojure_DOT_core_list) + tmp54 := lang.Apply(tmp53, []any{sym_glojure_DOT_core_SLASH_long}) + tmp55 := checkDerefVar(var_glojure_DOT_core_list) + tmp56 := lang.Apply(tmp55, []any{v38}) + tmp57 := lang.Apply(tmp52, []any{tmp54, tmp56}) + tmp58 := lang.Apply(tmp51, []any{tmp57}) + tmp59 := lang.Apply(tmp50, []any{tmp58}) + tmp60 := lang.Apply(tmp47, []any{tmp49, tmp59}) + tmp61 := lang.Apply(tmp46, []any{tmp60}) + tmp62 := lang.Apply(tmp44, []any{tmp45, tmp61}) + tmp63 := lang.Apply(tmp43, []any{tmp62}) + tmp64 := checkDerefVar(var_glojure_DOT_core_list) + tmp65 := checkDerefVar(var_glojure_DOT_core_seq) + tmp66 := checkDerefVar(var_glojure_DOT_core_concat) + tmp67 := checkDerefVar(var_glojure_DOT_core_list) + tmp68 := lang.Apply(tmp67, []any{sym_glojure_DOT_core_SLASH_loop}) + tmp69 := checkDerefVar(var_glojure_DOT_core_list) + tmp70 := checkDerefVar(var_glojure_DOT_core_apply) + tmp71 := checkDerefVar(var_glojure_DOT_core_vector) + tmp72 := checkDerefVar(var_glojure_DOT_core_seq) + tmp73 := checkDerefVar(var_glojure_DOT_core_concat) + tmp74 := checkDerefVar(var_glojure_DOT_core_list) + tmp75 := lang.Apply(tmp74, []any{v35}) + tmp76 := checkDerefVar(var_glojure_DOT_core_list) + tmp77 := lang.Apply(tmp76, []any{int64(0)}) + tmp78 := lang.Apply(tmp73, []any{tmp75, tmp77}) + tmp79 := lang.Apply(tmp72, []any{tmp78}) + tmp80 := lang.Apply(tmp70, []any{tmp71, tmp79}) + tmp81 := lang.Apply(tmp69, []any{tmp80}) + tmp82 := checkDerefVar(var_glojure_DOT_core_list) + tmp83 := checkDerefVar(var_glojure_DOT_core_seq) + tmp84 := checkDerefVar(var_glojure_DOT_core_concat) + tmp85 := checkDerefVar(var_glojure_DOT_core_list) + tmp86 := lang.Apply(tmp85, []any{sym_glojure_DOT_core_SLASH_when}) + tmp87 := checkDerefVar(var_glojure_DOT_core_list) + tmp88 := checkDerefVar(var_glojure_DOT_core_seq) + tmp89 := checkDerefVar(var_glojure_DOT_core_concat) + tmp90 := checkDerefVar(var_glojure_DOT_core_list) + tmp91 := lang.Apply(tmp90, []any{sym_glojure_DOT_core_SLASH__LT_}) + tmp92 := checkDerefVar(var_glojure_DOT_core_list) + tmp93 := lang.Apply(tmp92, []any{v35}) + tmp94 := checkDerefVar(var_glojure_DOT_core_list) + tmp95 := lang.Apply(tmp94, []any{sym_n__0__auto__}) + tmp96 := lang.Apply(tmp89, []any{tmp91, tmp93, tmp95}) + tmp97 := lang.Apply(tmp88, []any{tmp96}) + tmp98 := lang.Apply(tmp87, []any{tmp97}) + tmp99 := checkDerefVar(var_glojure_DOT_core_list) + tmp100 := checkDerefVar(var_glojure_DOT_core_seq) + tmp101 := checkDerefVar(var_glojure_DOT_core_concat) + tmp102 := checkDerefVar(var_glojure_DOT_core_list) + tmp103 := lang.Apply(tmp102, []any{sym_recur}) + tmp104 := checkDerefVar(var_glojure_DOT_core_list) + tmp105 := checkDerefVar(var_glojure_DOT_core_seq) + tmp106 := checkDerefVar(var_glojure_DOT_core_concat) + tmp107 := checkDerefVar(var_glojure_DOT_core_list) + tmp108 := lang.Apply(tmp107, []any{sym_glojure_DOT_core_SLASH_unchecked_DASH_inc}) + tmp109 := checkDerefVar(var_glojure_DOT_core_list) + tmp110 := lang.Apply(tmp109, []any{v35}) + tmp111 := lang.Apply(tmp106, []any{tmp108, tmp110}) + tmp112 := lang.Apply(tmp105, []any{tmp111}) + tmp113 := lang.Apply(tmp104, []any{tmp112}) + tmp114 := lang.Apply(tmp101, []any{tmp103, tmp113}) + tmp115 := lang.Apply(tmp100, []any{tmp114}) + tmp116 := lang.Apply(tmp99, []any{tmp115}) + tmp117 := lang.Apply(tmp84, []any{tmp86, tmp98, v5, tmp116}) + tmp118 := lang.Apply(tmp83, []any{tmp117}) + tmp119 := lang.Apply(tmp82, []any{tmp118}) + tmp120 := lang.Apply(tmp66, []any{tmp68, tmp81, tmp119}) + tmp121 := lang.Apply(tmp65, []any{tmp120}) + tmp122 := lang.Apply(tmp64, []any{tmp121}) + tmp123 := lang.Apply(tmp40, []any{tmp42, tmp63, tmp122}) + tmp124 := lang.Apply(tmp39, []any{tmp123}) + tmp32 = tmp124 + } // end let + return tmp32 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_dotimes = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_dotimes.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // drop + { + tmp0 := sym_drop.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n), lang.NewVector(sym_n, sym_coll)), kw_doc, "Returns a laziness-preserving sequence of all but the first n items in coll.\n Returns a stateful transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(2901), kw_end_DASH_line, int(2901))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 any + { // let + // let binding "nv" + tmp6 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) + tmp7 := lang.Apply(tmp6, []any{v2}) + var v8 any = tmp7 + _ = v8 + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp10 := lang.Apply(v4, nil) + return tmp10 + case 1: + v10 := args[0] + _ = v10 + tmp11 := lang.Apply(v4, []any{v10}) + return tmp11 + case 2: + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + var tmp12 any + { // let + // let binding "n" + tmp13 := checkDerefVar(var_glojure_DOT_core_deref) + tmp14 := lang.Apply(tmp13, []any{v8}) + var v15 any = tmp14 + _ = v15 + tmp16 := checkDerefVar(var_glojure_DOT_core_dec) + tmp17, ok := lang.FieldOrMethod(v8, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "Deref"))) + } + var tmp18 any + switch reflect.TypeOf(tmp17).Kind() { + case reflect.Func: + tmp18 = lang.Apply(tmp17, nil) + default: + tmp18 = tmp17 + } + tmp19 := lang.Apply(tmp16, []any{tmp18}) + tmp20, _ := lang.FieldOrMethod(v8, "reset") + if reflect.TypeOf(tmp20).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) + } + tmp21 := lang.Apply(tmp20, []any{tmp19}) + _ = tmp21 + var tmp22 any + tmp23 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp24 := lang.Apply(tmp23, []any{v15}) + if lang.IsTruthy(tmp24) { + tmp22 = v10 + } else { + tmp25 := lang.Apply(v4, []any{v10, v11}) + tmp22 = tmp25 + } + tmp12 = tmp22 + } // end let + return tmp12 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2909), kw_column, int(10), kw_end_DASH_line, int(2917), kw_end_DASH_column, int(39)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp5 = tmp11 + } // end let + return tmp5 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2907), kw_column, int(6), kw_end_DASH_line, int(2917), kw_end_DASH_column, int(41)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp6 := reflect.TypeOf((*lang.IDrop)(nil)).Elem() + tmp7 := lang.Apply(tmp5, []any{tmp6, v3}) + if lang.IsTruthy(tmp7) { + var tmp8 any + { // let + // let binding "or__0__auto__" + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp11 := lang.Apply(tmp10, []any{v2}) + if lang.IsTruthy(tmp11) { + var tmp12 any + tmp13 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) + tmp14 := lang.Apply(tmp13, []any{v2}) + if lang.IsTruthy(tmp14) { + tmp12 = v2 + } else { + tmp15 := lang.Apply(nil, []any{v2}) + tmp12 = tmp15 + } + tmp16, _ := lang.FieldOrMethod(v3, "drop") + if reflect.TypeOf(tmp16).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("drop is not a function"))) + } + tmp17 := lang.Apply(tmp16, []any{tmp12}) + tmp9 = tmp17 + } else { + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := lang.Apply(tmp18, []any{v3}) + tmp9 = tmp19 + } + var v20 any = tmp9 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + tmp21 = v20 + } else { + tmp21 = lang.NewList() + } + tmp8 = tmp21 + } // end let + tmp4 = tmp8 + } else { + var tmp9 any + { // let + // let binding "step" + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + recur_loop_2079: + var tmp13 any + { // let + // let binding "s" + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := lang.Apply(tmp14, []any{v12}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + var tmp18 any + { // let + // let binding "and__0__auto__" + tmp19 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp20 := lang.Apply(tmp19, []any{v11}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + if lang.IsTruthy(v21) { + tmp22 = v16 + } else { + tmp22 = v21 + } + tmp18 = tmp22 + } // end let + if lang.IsTruthy(tmp18) { + tmp20 := checkDerefVar(var_glojure_DOT_core_dec) + tmp21 := lang.Apply(tmp20, []any{v11}) + var tmp19 any = tmp21 + tmp23 := checkDerefVar(var_glojure_DOT_core_rest) + tmp24 := lang.Apply(tmp23, []any{v16}) + var tmp22 any = tmp24 + v11 = tmp19 + v12 = tmp22 + goto recur_loop_2079 + } else { + tmp17 = v16 + } + tmp13 = tmp17 + } // end let + return tmp13 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2925), kw_column, int(19), kw_end_DASH_line, int(2929), kw_end_DASH_column, int(28)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v13 any = tmp12 + _ = v13 + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp15 := lang.Apply(v13, []any{v2, v3}) + return tmp15 + }) + tmp15 := lang.Apply(lang.NewLazySeq, []any{tmp14}) + tmp9 = tmp15 + } // end let + tmp4 = tmp9 + } + return tmp4 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_drop = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_drop.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // elide-top-frames + { + tmp0 := sym_elide_DASH_top_DASH_frames.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(4794), kw_column, int(7), kw_end_DASH_line, int(4794), kw_end_DASH_column, int(32), kw_arglists, lang.NewList(lang.NewVector(sym_ex, sym_class_DASH_name)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "tr" + tmp5, ok := lang.FieldOrMethod(v2, "getStackTrace") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getStackTrace"))) + } + var tmp6 any + switch reflect.TypeOf(tmp5).Kind() { + case reflect.Func: + tmp6 = lang.Apply(tmp5, nil) + default: + tmp6 = tmp5 + } + var v7 any = tmp6 + _ = v7 + var tmp8 any + { // let + // let binding "G__745" + var v9 any = v2 + _ = v9 + var tmp10 any + if lang.IsTruthy(v7) { + tmp11 := checkDerefVar(var_glojure_DOT_core_into_DASH_array) + tmp12 := checkDerefVar(var_glojure_DOT_core_drop_DASH_while) + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v14 := args[0] + _ = v14 + tmp15 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp16, ok := lang.FieldOrMethod(v14, "getClassName") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v14, "getClassName"))) + } + var tmp17 any + switch reflect.TypeOf(tmp16).Kind() { + case reflect.Func: + tmp17 = lang.Apply(tmp16, nil) + default: + tmp17 = tmp16 + } + tmp18 := lang.Apply(tmp15, []any{v3, tmp17}) + return tmp18 + }) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4801), kw_column, int(25), kw_end_DASH_line, int(4801), kw_end_DASH_column, int(77)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp16 := lang.Apply(tmp12, []any{tmp15, v7}) + tmp17 := lang.Apply(tmp11, []any{nil, tmp16}) + tmp10 = tmp17 + } else { + } + tmp18, _ := lang.FieldOrMethod(v9, "setStackTrace") + if reflect.TypeOf(tmp18).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setStackTrace is not a function"))) + } + tmp19 := lang.Apply(tmp18, []any{tmp10}) + _ = tmp19 + tmp8 = v9 + } // end let + tmp4 = tmp8 + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_elide_DASH_top_DASH_frames = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_elide_DASH_top_DASH_frames.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // empty? + { + tmp0 := sym_empty_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns true if coll has no items. To check the emptiness of a seq,\n please use the idiom (seq x) rather than (not (empty? x))", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(6247), kw_end_DASH_line, int(6247))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_counted_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + tmp6 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) + tmp7 := checkDerefVar(var_glojure_DOT_core_count) + tmp8 := lang.Apply(tmp7, []any{v2}) + tmp9 := lang.Apply(tmp6, []any{tmp8}) + tmp3 = tmp9 + } else { + tmp10 := checkDerefVar(var_glojure_DOT_core_not) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := lang.Apply(tmp11, []any{v2}) + tmp13 := lang.Apply(tmp10, []any{tmp12}) + tmp3 = tmp13 + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_empty_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_empty_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ensure-reduced + { + tmp0 := sym_ensure_DASH_reduced.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "If x is already reduced?, returns it, else returns (reduced x)", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(2841), kw_end_DASH_line, int(2841))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + tmp3 = v2 + } else { + tmp6 := checkDerefVar(var_glojure_DOT_core_reduced) + tmp7 := lang.Apply(tmp6, []any{v2}) + tmp3 = tmp7 + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ensure_DASH_reduced = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ensure_DASH_reduced.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // even? + { + tmp0 := sym_even_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_doc, "Returns true if n is even, throws an exception if n is not an integer", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(1381), kw_end_DASH_line, int(1381))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_integer_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + tmp6 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) + tmp7 := checkDerefVar(var_glojure_DOT_core_bit_DASH_and) + tmp8 := lang.Apply(lang.UncheckedLongCast, []any{v2}) + tmp9 := lang.Apply(tmp7, []any{tmp8, int64(1)}) + tmp10 := lang.Apply(tmp6, []any{tmp9}) + tmp3 = tmp10 + } else { + tmp11 := checkDerefVar(var_glojure_DOT_core_str) + tmp12 := lang.Apply(tmp11, []any{"Argument must be an integer: ", v2}) + tmp13 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp12}) + panic(tmp13) + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_even_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_even_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // every-pred + { + tmp0 := sym_every_DASH_pred.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_p), lang.NewVector(sym_p1, sym_p2), lang.NewVector(sym_p1, sym_p2, sym_p3), lang.NewVector(sym_p1, sym_p2, sym_p3, sym__AMP_, sym_ps)), kw_doc, "Takes a set of predicates and returns a function f that returns true if all of its\n composing predicates return a logical true value against all of its arguments, else it returns\n false. Note that f is short-circuiting in that it will stop execution on the first\n argument that triggers a logical false result against the original predicates.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(7422), kw_end_DASH_line, int(7422))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + { // function ep1 + var v4 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return true + case 1: + v5 := args[0] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_boolean) + tmp7 := lang.Apply(v2, []any{v5}) + tmp8 := lang.Apply(tmp6, []any{tmp7}) + return tmp8 + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp8 any + { // let + // let binding "and__0__auto__" + tmp9 := lang.Apply(v2, []any{v5}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + if lang.IsTruthy(v10) { + tmp12 := lang.Apply(v2, []any{v6}) + tmp11 = tmp12 + } else { + tmp11 = v10 + } + tmp8 = tmp11 + } // end let + tmp9 := lang.Apply(tmp7, []any{tmp8}) + return tmp9 + case 3: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := args[2] + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp9 any + { // let + // let binding "and__0__auto__" + tmp10 := lang.Apply(v2, []any{v5}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + var tmp13 any + { // let + // let binding "and__0__auto__" + tmp14 := lang.Apply(v2, []any{v6}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + if lang.IsTruthy(v15) { + tmp17 := lang.Apply(v2, []any{v7}) + tmp16 = tmp17 + } else { + tmp16 = v15 + } + tmp13 = tmp16 + } // end let + tmp12 = tmp13 + } else { + tmp12 = v11 + } + tmp9 = tmp12 + } // end let + tmp10 := lang.Apply(tmp8, []any{tmp9}) + return tmp10 + default: + checkArity(args, 3) + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := args[2] + _ = v7 + var v8 any = lang.NewList(args[3:]...) + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp10 any + { // let + // let binding "and__0__auto__" + tmp11 := lang.Apply(v4, []any{v5, v6, v7}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + tmp14 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + tmp15 := lang.Apply(tmp14, []any{v2, v8}) + tmp13 = tmp15 + } else { + tmp13 = v12 + } + tmp10 = tmp13 + } // end let + tmp11 := lang.Apply(tmp9, []any{tmp10}) + return tmp11 + } + }) + v4 = tmp3 + _ = v4 + } + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7429), kw_column, int(6), kw_end_DASH_line, int(7435), kw_end_DASH_column, int(56)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + { // function ep2 + var v5 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return true + case 1: + v6 := args[0] + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp8 any + { // let + // let binding "and__0__auto__" + tmp9 := lang.Apply(v2, []any{v6}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + if lang.IsTruthy(v10) { + tmp12 := lang.Apply(v3, []any{v6}) + tmp11 = tmp12 + } else { + tmp11 = v10 + } + tmp8 = tmp11 + } // end let + tmp9 := lang.Apply(tmp7, []any{tmp8}) + return tmp9 + case 2: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp9 any + { // let + // let binding "and__0__auto__" + tmp10 := lang.Apply(v2, []any{v6}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + var tmp13 any + { // let + // let binding "and__0__auto__" + tmp14 := lang.Apply(v2, []any{v7}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + if lang.IsTruthy(v15) { + var tmp17 any + { // let + // let binding "and__0__auto__" + tmp18 := lang.Apply(v3, []any{v6}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + tmp21 := lang.Apply(v3, []any{v7}) + tmp20 = tmp21 + } else { + tmp20 = v19 + } + tmp17 = tmp20 + } // end let + tmp16 = tmp17 + } else { + tmp16 = v15 + } + tmp13 = tmp16 + } // end let + tmp12 = tmp13 + } else { + tmp12 = v11 + } + tmp9 = tmp12 + } // end let + tmp10 := lang.Apply(tmp8, []any{tmp9}) + return tmp10 + case 3: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp10 any + { // let + // let binding "and__0__auto__" + tmp11 := lang.Apply(v2, []any{v6}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + var tmp14 any + { // let + // let binding "and__0__auto__" + tmp15 := lang.Apply(v2, []any{v7}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + if lang.IsTruthy(v16) { + var tmp18 any + { // let + // let binding "and__0__auto__" + tmp19 := lang.Apply(v2, []any{v8}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + var tmp22 any + { // let + // let binding "and__0__auto__" + tmp23 := lang.Apply(v3, []any{v6}) + var v24 any = tmp23 + _ = v24 + var tmp25 any + if lang.IsTruthy(v24) { + var tmp26 any + { // let + // let binding "and__0__auto__" + tmp27 := lang.Apply(v3, []any{v7}) + var v28 any = tmp27 + _ = v28 + var tmp29 any + if lang.IsTruthy(v28) { + tmp30 := lang.Apply(v3, []any{v8}) + tmp29 = tmp30 + } else { + tmp29 = v28 + } + tmp26 = tmp29 + } // end let + tmp25 = tmp26 + } else { + tmp25 = v24 + } + tmp22 = tmp25 + } // end let + tmp21 = tmp22 + } else { + tmp21 = v20 + } + tmp18 = tmp21 + } // end let + tmp17 = tmp18 + } else { + tmp17 = v16 + } + tmp14 = tmp17 + } // end let + tmp13 = tmp14 + } else { + tmp13 = v12 + } + tmp10 = tmp13 + } // end let + tmp11 := lang.Apply(tmp9, []any{tmp10}) + return tmp11 + default: + checkArity(args, 3) + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + var v9 any = lang.NewList(args[3:]...) + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp11 any + { // let + // let binding "and__0__auto__" + tmp12 := lang.Apply(v5, []any{v6, v7, v8}) + var v13 any = tmp12 + _ = v13 + var tmp14 any + if lang.IsTruthy(v13) { + tmp15 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + var tmp16 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v17 := args[0] + _ = v17 + var tmp18 any + { // let + // let binding "and__0__auto__" + tmp19 := lang.Apply(v2, []any{v17}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + tmp22 := lang.Apply(v3, []any{v17}) + tmp21 = tmp22 + } else { + tmp21 = v20 + } + tmp18 = tmp21 + } // end let + return tmp18 + }) + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7443), kw_column, int(46), kw_end_DASH_line, int(7443), kw_end_DASH_column, int(65)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp19 := lang.Apply(tmp15, []any{tmp18, v9}) + tmp14 = tmp19 + } else { + tmp14 = v13 + } + tmp11 = tmp14 + } // end let + tmp12 := lang.Apply(tmp10, []any{tmp11}) + return tmp12 + } + }) + v5 = tmp4 + _ = v5 + } + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7437), kw_column, int(6), kw_end_DASH_line, int(7443), kw_end_DASH_column, int(75)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 lang.FnFunc + { // function ep3 + var v6 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return true + case 1: + v7 := args[0] + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp9 any + { // let + // let binding "and__0__auto__" + tmp10 := lang.Apply(v2, []any{v7}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + var tmp13 any + { // let + // let binding "and__0__auto__" + tmp14 := lang.Apply(v3, []any{v7}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + if lang.IsTruthy(v15) { + tmp17 := lang.Apply(v4, []any{v7}) + tmp16 = tmp17 + } else { + tmp16 = v15 + } + tmp13 = tmp16 + } // end let + tmp12 = tmp13 + } else { + tmp12 = v11 + } + tmp9 = tmp12 + } // end let + tmp10 := lang.Apply(tmp8, []any{tmp9}) + return tmp10 + case 2: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp10 any + { // let + // let binding "and__0__auto__" + tmp11 := lang.Apply(v2, []any{v7}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + var tmp14 any + { // let + // let binding "and__0__auto__" + tmp15 := lang.Apply(v2, []any{v8}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + if lang.IsTruthy(v16) { + var tmp18 any + { // let + // let binding "and__0__auto__" + tmp19 := lang.Apply(v3, []any{v7}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + var tmp22 any + { // let + // let binding "and__0__auto__" + tmp23 := lang.Apply(v3, []any{v8}) + var v24 any = tmp23 + _ = v24 + var tmp25 any + if lang.IsTruthy(v24) { + var tmp26 any + { // let + // let binding "and__0__auto__" + tmp27 := lang.Apply(v4, []any{v7}) + var v28 any = tmp27 + _ = v28 + var tmp29 any + if lang.IsTruthy(v28) { + tmp30 := lang.Apply(v4, []any{v8}) + tmp29 = tmp30 + } else { + tmp29 = v28 + } + tmp26 = tmp29 + } // end let + tmp25 = tmp26 + } else { + tmp25 = v24 + } + tmp22 = tmp25 + } // end let + tmp21 = tmp22 + } else { + tmp21 = v20 + } + tmp18 = tmp21 + } // end let + tmp17 = tmp18 + } else { + tmp17 = v16 + } + tmp14 = tmp17 + } // end let + tmp13 = tmp14 + } else { + tmp13 = v12 + } + tmp10 = tmp13 + } // end let + tmp11 := lang.Apply(tmp9, []any{tmp10}) + return tmp11 + case 3: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp11 any + { // let + // let binding "and__0__auto__" + tmp12 := lang.Apply(v2, []any{v7}) + var v13 any = tmp12 + _ = v13 + var tmp14 any + if lang.IsTruthy(v13) { + var tmp15 any + { // let + // let binding "and__0__auto__" + tmp16 := lang.Apply(v2, []any{v8}) + var v17 any = tmp16 + _ = v17 + var tmp18 any + if lang.IsTruthy(v17) { + var tmp19 any + { // let + // let binding "and__0__auto__" + tmp20 := lang.Apply(v2, []any{v9}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + if lang.IsTruthy(v21) { + var tmp23 any + { // let + // let binding "and__0__auto__" + tmp24 := lang.Apply(v3, []any{v7}) + var v25 any = tmp24 + _ = v25 + var tmp26 any + if lang.IsTruthy(v25) { + var tmp27 any + { // let + // let binding "and__0__auto__" + tmp28 := lang.Apply(v3, []any{v8}) + var v29 any = tmp28 + _ = v29 + var tmp30 any + if lang.IsTruthy(v29) { + var tmp31 any + { // let + // let binding "and__0__auto__" + tmp32 := lang.Apply(v3, []any{v9}) + var v33 any = tmp32 + _ = v33 + var tmp34 any + if lang.IsTruthy(v33) { + var tmp35 any + { // let + // let binding "and__0__auto__" + tmp36 := lang.Apply(v4, []any{v7}) + var v37 any = tmp36 + _ = v37 + var tmp38 any + if lang.IsTruthy(v37) { + var tmp39 any + { // let + // let binding "and__0__auto__" + tmp40 := lang.Apply(v4, []any{v8}) + var v41 any = tmp40 + _ = v41 + var tmp42 any + if lang.IsTruthy(v41) { + tmp43 := lang.Apply(v4, []any{v9}) + tmp42 = tmp43 + } else { + tmp42 = v41 + } + tmp39 = tmp42 + } // end let + tmp38 = tmp39 + } else { + tmp38 = v37 + } + tmp35 = tmp38 + } // end let + tmp34 = tmp35 + } else { + tmp34 = v33 + } + tmp31 = tmp34 + } // end let + tmp30 = tmp31 + } else { + tmp30 = v29 + } + tmp27 = tmp30 + } // end let + tmp26 = tmp27 + } else { + tmp26 = v25 + } + tmp23 = tmp26 + } // end let + tmp22 = tmp23 + } else { + tmp22 = v21 + } + tmp19 = tmp22 + } // end let + tmp18 = tmp19 + } else { + tmp18 = v17 + } + tmp15 = tmp18 + } // end let + tmp14 = tmp15 + } else { + tmp14 = v13 + } + tmp11 = tmp14 + } // end let + tmp12 := lang.Apply(tmp10, []any{tmp11}) + return tmp12 + default: + checkArity(args, 3) + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + var v10 any = lang.NewList(args[3:]...) + _ = v10 + tmp11 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp12 any + { // let + // let binding "and__0__auto__" + tmp13 := lang.Apply(v6, []any{v7, v8, v9}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + tmp16 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + var tmp17 lang.FnFunc + tmp17 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v18 := args[0] + _ = v18 + var tmp19 any + { // let + // let binding "and__0__auto__" + tmp20 := lang.Apply(v2, []any{v18}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + if lang.IsTruthy(v21) { + var tmp23 any + { // let + // let binding "and__0__auto__" + tmp24 := lang.Apply(v3, []any{v18}) + var v25 any = tmp24 + _ = v25 + var tmp26 any + if lang.IsTruthy(v25) { + tmp27 := lang.Apply(v4, []any{v18}) + tmp26 = tmp27 + } else { + tmp26 = v25 + } + tmp23 = tmp26 + } // end let + tmp22 = tmp23 + } else { + tmp22 = v21 + } + tmp19 = tmp22 + } // end let + return tmp19 + }) + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7451), kw_column, int(46), kw_end_DASH_line, int(7451), kw_end_DASH_column, int(72)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp20 := lang.Apply(tmp16, []any{tmp19, v10}) + tmp15 = tmp20 + } else { + tmp15 = v14 + } + tmp12 = tmp15 + } // end let + tmp13 := lang.Apply(tmp11, []any{tmp12}) + return tmp13 + } + }) + v6 = tmp5 + _ = v6 + } + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7445), kw_column, int(6), kw_end_DASH_line, int(7451), kw_end_DASH_column, int(82)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp7 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "ps" + tmp7 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp8 := lang.Apply(tmp7, []any{v2, v3, v4, v5}) + var v9 any = tmp8 + _ = v9 + var tmp10 lang.FnFunc + { // function epn + var v11 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return true + case 1: + v12 := args[0] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v15 := args[0] + _ = v15 + tmp16 := lang.Apply(v15, []any{v12}) + return tmp16 + }) + tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7456), kw_column, int(23), kw_end_DASH_line, int(7456), kw_end_DASH_column, int(28)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp17 := lang.Apply(tmp13, []any{tmp16, v9}) + return tmp17 + case 2: + v12 := args[0] + _ = v12 + v13 := args[1] + _ = v13 + tmp14 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + var tmp15 lang.FnFunc + tmp15 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v16 := args[0] + _ = v16 + var tmp17 any + { // let + // let binding "and__0__auto__" + tmp18 := lang.Apply(v16, []any{v12}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + tmp21 := lang.Apply(v16, []any{v13}) + tmp20 = tmp21 + } else { + tmp20 = v19 + } + tmp17 = tmp20 + } // end let + return tmp17 + }) + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7457), kw_column, int(25), kw_end_DASH_line, int(7457), kw_end_DASH_column, int(42)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp18 := lang.Apply(tmp14, []any{tmp17, v9}) + return tmp18 + case 3: + v12 := args[0] + _ = v12 + v13 := args[1] + _ = v13 + v14 := args[2] + _ = v14 + tmp15 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + var tmp16 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v17 := args[0] + _ = v17 + var tmp18 any + { // let + // let binding "and__0__auto__" + tmp19 := lang.Apply(v17, []any{v12}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + var tmp22 any + { // let + // let binding "and__0__auto__" + tmp23 := lang.Apply(v17, []any{v13}) + var v24 any = tmp23 + _ = v24 + var tmp25 any + if lang.IsTruthy(v24) { + tmp26 := lang.Apply(v17, []any{v14}) + tmp25 = tmp26 + } else { + tmp25 = v24 + } + tmp22 = tmp25 + } // end let + tmp21 = tmp22 + } else { + tmp21 = v20 + } + tmp18 = tmp21 + } // end let + return tmp18 + }) + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7458), kw_column, int(27), kw_end_DASH_line, int(7458), kw_end_DASH_column, int(50)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp19 := lang.Apply(tmp15, []any{tmp18, v9}) + return tmp19 + default: + checkArity(args, 3) + v12 := args[0] + _ = v12 + v13 := args[1] + _ = v13 + v14 := args[2] + _ = v14 + var v15 any = lang.NewList(args[3:]...) + _ = v15 + tmp16 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp17 any + { // let + // let binding "and__0__auto__" + tmp18 := lang.Apply(v11, []any{v12, v13, v14}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + tmp21 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + var tmp22 lang.FnFunc + tmp22 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v23 := args[0] + _ = v23 + tmp24 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + tmp25 := lang.Apply(tmp24, []any{v23, v15}) + return tmp25 + }) + tmp23 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7460), kw_column, int(48), kw_end_DASH_line, int(7460), kw_end_DASH_column, int(63)) + tmp24, err := lang.WithMeta(tmp22, tmp23.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp25 := lang.Apply(tmp21, []any{tmp24, v9}) + tmp20 = tmp25 + } else { + tmp20 = v19 + } + tmp17 = tmp20 + } // end let + tmp18 := lang.Apply(tmp16, []any{tmp17}) + return tmp18 + } + }) + v11 = tmp10 + _ = v11 + } + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7454), kw_column, int(8), kw_end_DASH_line, int(7460), kw_end_DASH_column, int(71)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp6 = tmp12 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_every_DASH_pred = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_every_DASH_pred.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ex-info + { + tmp0 := sym_ex_DASH_info.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_msg, sym_map), lang.NewVector(sym_msg, sym_map, sym_cause)), kw_doc, "Create an instance of ExceptionInfo, a RuntimeException subclass\n that carries a map of additional data.", kw_file, "glojure/core.glj", kw_added, "1.4", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4803), kw_end_DASH_line, int(4803))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_elide_DASH_top_DASH_frames) + tmp5 := lang.Apply(nil, []any{v2, v3}) + tmp6 := lang.Apply(tmp4, []any{tmp5, "glojure.core$ex_info"}) + return tmp6 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_elide_DASH_top_DASH_frames) + tmp6 := lang.Apply(nil, []any{v2, v3, v4}) + tmp7 := lang.Apply(tmp5, []any{tmp6, "glojure.core$ex_info"}) + return tmp7 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ex_DASH_info = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ex_DASH_info.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // filter + { + tmp0 := sym_filter.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred), lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns a lazy sequence of the items in coll for which\n (pred item) returns logical true. pred must be free of side-effects.\n Returns a transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(2785), kw_end_DASH_line, int(2785))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp6 := lang.Apply(v4, nil) + return tmp6 + case 1: + v6 := args[0] + _ = v6 + tmp7 := lang.Apply(v4, []any{v6}) + return tmp7 + case 2: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + var tmp8 any + tmp9 := lang.Apply(v2, []any{v7}) + if lang.IsTruthy(tmp9) { + tmp10 := lang.Apply(v4, []any{v6, v7}) + tmp8 = tmp10 + } else { + tmp8 = v6 + } + return tmp8 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2793), kw_column, int(7), kw_end_DASH_line, int(2799), kw_end_DASH_column, int(22)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp7 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2792), kw_column, int(5), kw_end_DASH_line, int(2799), kw_end_DASH_column, int(23)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp5 any + { // let + // let binding "temp__0__auto__" + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := lang.Apply(tmp6, []any{v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + var tmp10 any + { // let + // let binding "s" + var v11 any = v8 + _ = v11 + var tmp12 any + tmp13 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp14 := lang.Apply(tmp13, []any{v11}) + if lang.IsTruthy(tmp14) { + var tmp15 any + { // let + // let binding "c" + tmp16 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp17 := lang.Apply(tmp16, []any{v11}) + var v18 any = tmp17 + _ = v18 + // let binding "size" + tmp19 := checkDerefVar(var_glojure_DOT_core_count) + tmp20 := lang.Apply(tmp19, []any{v18}) + var v21 any = tmp20 + _ = v21 + // let binding "b" + tmp22 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_buffer) + tmp23 := lang.Apply(tmp22, []any{v21}) + var v24 any = tmp23 + _ = v24 + var tmp25 any + { // let + // let binding "n__0__auto__" + tmp26 := lang.Apply(lang.LongCast, []any{v21}) + var v27 any = tmp26 + _ = v27 + var tmp28 any + { // let + // let binding "i" + var v29 any = int64(0) + _ = v29 + for { + var tmp30 any + tmp31 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp32 := lang.Apply(tmp31, []any{v29, v27}) + if lang.IsTruthy(tmp32) { + var tmp33 any + { // let + // let binding "v" + tmp34, _ := lang.FieldOrMethod(v18, "nth") + if reflect.TypeOf(tmp34).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp35 := lang.Apply(tmp34, []any{v29}) + var v36 any = tmp35 + _ = v36 + var tmp37 any + tmp38 := lang.Apply(v2, []any{v36}) + if lang.IsTruthy(tmp38) { + tmp39 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_append) + tmp40 := lang.Apply(tmp39, []any{v24, v36}) + tmp37 = tmp40 + } else { + } + tmp33 = tmp37 + } // end let + _ = tmp33 + tmp35 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp36 := lang.Apply(tmp35, []any{v29}) + var tmp34 any = tmp36 + v29 = tmp34 + continue + } else { + } + tmp28 = tmp30 + break + } + } // end let + tmp25 = tmp28 + } // end let + _ = tmp25 + tmp26 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_cons) + tmp27 := checkDerefVar(var_glojure_DOT_core_chunk) + tmp28 := lang.Apply(tmp27, []any{v24}) + tmp29 := checkDerefVar(var_glojure_DOT_core_filter) + tmp30 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp31 := lang.Apply(tmp30, []any{v11}) + tmp32 := lang.Apply(tmp29, []any{v2, tmp31}) + tmp33 := lang.Apply(tmp26, []any{tmp28, tmp32}) + tmp15 = tmp33 + } // end let + tmp12 = tmp15 + } else { + var tmp16 any + { // let + // let binding "f" + tmp17 := checkDerefVar(var_glojure_DOT_core_first) + tmp18 := lang.Apply(tmp17, []any{v11}) + var v19 any = tmp18 + _ = v19 + // let binding "r" + tmp20 := checkDerefVar(var_glojure_DOT_core_rest) + tmp21 := lang.Apply(tmp20, []any{v11}) + var v22 any = tmp21 + _ = v22 + var tmp23 any + tmp24 := lang.Apply(v2, []any{v19}) + if lang.IsTruthy(tmp24) { + tmp25 := checkDerefVar(var_glojure_DOT_core_cons) + tmp26 := checkDerefVar(var_glojure_DOT_core_filter) + tmp27 := lang.Apply(tmp26, []any{v2, v22}) + tmp28 := lang.Apply(tmp25, []any{v19, tmp27}) + tmp23 = tmp28 + } else { + tmp29 := checkDerefVar(var_glojure_DOT_core_filter) + tmp30 := lang.Apply(tmp29, []any{v2, v22}) + tmp23 = tmp30 + } + tmp16 = tmp23 + } // end let + tmp12 = tmp16 + } + tmp10 = tmp12 + } // end let + tmp9 = tmp10 + } else { + } + tmp5 = tmp9 + } // end let + return tmp5 + }) + tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_filter = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_filter.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // fnil + { + tmp0 := sym_fnil.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_x), lang.NewVector(sym_f, sym_x, sym_y), lang.NewVector(sym_f, sym_x, sym_y, sym_z)), kw_doc, "Takes a function f, and returns a function that calls f, replacing\n a nil first argument to f with the supplied value x. Higher arity\n versions can replace arguments in the second and third\n positions (y, z). Note that the function f can take any number of\n arguments, not just the one(s) being nil-patched.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(6558), kw_end_DASH_line, int(6558))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v5 := args[0] + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v5}) + if lang.IsTruthy(tmp8) { + tmp6 = v3 + } else { + tmp6 = v5 + } + tmp9 := lang.Apply(v2, []any{tmp6}) + return tmp9 + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp9 := lang.Apply(tmp8, []any{v5}) + if lang.IsTruthy(tmp9) { + tmp7 = v3 + } else { + tmp7 = v5 + } + tmp10 := lang.Apply(v2, []any{tmp7, v6}) + return tmp10 + case 3: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := args[2] + _ = v7 + var tmp8 any + tmp9 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp10 := lang.Apply(tmp9, []any{v5}) + if lang.IsTruthy(tmp10) { + tmp8 = v3 + } else { + tmp8 = v5 + } + tmp11 := lang.Apply(v2, []any{tmp8, v6, v7}) + return tmp11 + default: + checkArity(args, 3) + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := args[2] + _ = v7 + var v8 any = lang.NewList(args[3:]...) + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_apply) + var tmp10 any + tmp11 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp12 := lang.Apply(tmp11, []any{v5}) + if lang.IsTruthy(tmp12) { + tmp10 = v3 + } else { + tmp10 = v5 + } + tmp13 := lang.Apply(tmp9, []any{v2, tmp10, v6, v7, v8}) + return tmp13 + } + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6567), kw_column, int(4), kw_end_DASH_line, int(6571), kw_end_DASH_column, int(55)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + var tmp8 any + tmp9 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp10 := lang.Apply(tmp9, []any{v6}) + if lang.IsTruthy(tmp10) { + tmp8 = v3 + } else { + tmp8 = v6 + } + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp13 := lang.Apply(tmp12, []any{v7}) + if lang.IsTruthy(tmp13) { + tmp11 = v4 + } else { + tmp11 = v7 + } + tmp14 := lang.Apply(v2, []any{tmp8, tmp11}) + return tmp14 + case 3: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp11 := lang.Apply(tmp10, []any{v6}) + if lang.IsTruthy(tmp11) { + tmp9 = v3 + } else { + tmp9 = v6 + } + var tmp12 any + tmp13 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp14 := lang.Apply(tmp13, []any{v7}) + if lang.IsTruthy(tmp14) { + tmp12 = v4 + } else { + tmp12 = v7 + } + tmp15 := lang.Apply(v2, []any{tmp9, tmp12, v8}) + return tmp15 + default: + checkArity(args, 3) + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + var v9 any = lang.NewList(args[3:]...) + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_apply) + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp13 := lang.Apply(tmp12, []any{v6}) + if lang.IsTruthy(tmp13) { + tmp11 = v3 + } else { + tmp11 = v6 + } + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp16 := lang.Apply(tmp15, []any{v7}) + if lang.IsTruthy(tmp16) { + tmp14 = v4 + } else { + tmp14 = v7 + } + tmp17 := lang.Apply(tmp10, []any{v2, tmp11, tmp14, v8, v9}) + return tmp17 + } + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6573), kw_column, int(4), kw_end_DASH_line, int(6576), kw_end_DASH_column, int(71)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp7 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp11 := lang.Apply(tmp10, []any{v7}) + if lang.IsTruthy(tmp11) { + tmp9 = v3 + } else { + tmp9 = v7 + } + var tmp12 any + tmp13 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp14 := lang.Apply(tmp13, []any{v8}) + if lang.IsTruthy(tmp14) { + tmp12 = v4 + } else { + tmp12 = v8 + } + tmp15 := lang.Apply(v2, []any{tmp9, tmp12}) + return tmp15 + case 3: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + var tmp10 any + tmp11 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp12 := lang.Apply(tmp11, []any{v7}) + if lang.IsTruthy(tmp12) { + tmp10 = v3 + } else { + tmp10 = v7 + } + var tmp13 any + tmp14 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp15 := lang.Apply(tmp14, []any{v8}) + if lang.IsTruthy(tmp15) { + tmp13 = v4 + } else { + tmp13 = v8 + } + var tmp16 any + tmp17 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp18 := lang.Apply(tmp17, []any{v9}) + if lang.IsTruthy(tmp18) { + tmp16 = v5 + } else { + tmp16 = v9 + } + tmp19 := lang.Apply(v2, []any{tmp10, tmp13, tmp16}) + return tmp19 + default: + checkArity(args, 3) + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + var v10 any = lang.NewList(args[3:]...) + _ = v10 + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + var tmp12 any + tmp13 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp14 := lang.Apply(tmp13, []any{v7}) + if lang.IsTruthy(tmp14) { + tmp12 = v3 + } else { + tmp12 = v7 + } + var tmp15 any + tmp16 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp17 := lang.Apply(tmp16, []any{v8}) + if lang.IsTruthy(tmp17) { + tmp15 = v4 + } else { + tmp15 = v8 + } + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp20 := lang.Apply(tmp19, []any{v9}) + if lang.IsTruthy(tmp20) { + tmp18 = v5 + } else { + tmp18 = v9 + } + tmp21 := lang.Apply(tmp11, []any{v2, tmp12, tmp15, tmp18, v10}) + return tmp21 + } + }) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6578), kw_column, int(4), kw_end_DASH_line, int(6581), kw_end_DASH_column, int(87)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp8 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_fnil = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_fnil.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // format + { + tmp0 := sym_format.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_fmt, sym__AMP_, sym_args)), kw_doc, "Formats a string using java.lang.String.format, see java.util.Formatter for format\n string syntax", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(5717), kw_end_DASH_line, int(5717))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_apply) + tmp5 := lang.Apply(tmp4, []any{fmt.Sprintf, v2, v3}) + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_format = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_format.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // future + { + tmp0 := sym_future.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_body)), kw_doc, "Takes a body of expressions and yields a future object that will\n invoke the body in another thread, and will cache the result and\n return it on all subsequent calls to deref/@. If the computation has\n not yet finished, calls to deref/@ will block, unless the variant of\n deref with timeout is used. See also - realized?.", kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(11), kw_line, int(7009), kw_end_DASH_line, int(7009))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym_glojure_DOT_core_SLASH_future_DASH_call}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := checkDerefVar(var_glojure_DOT_core_seq) + tmp11 := checkDerefVar(var_glojure_DOT_core_concat) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_fn_STAR_}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_apply) + tmp16 := checkDerefVar(var_glojure_DOT_core_vector) + tmp17 := checkDerefVar(var_glojure_DOT_core_seq) + tmp18 := checkDerefVar(var_glojure_DOT_core_concat) + tmp19 := lang.Apply(tmp18, nil) + tmp20 := lang.Apply(tmp17, []any{tmp19}) + tmp21 := lang.Apply(tmp15, []any{tmp16, tmp20}) + tmp22 := lang.Apply(tmp14, []any{tmp21}) + tmp23 := lang.Apply(tmp11, []any{tmp13, tmp22, v4}) + tmp24 := lang.Apply(tmp10, []any{tmp23}) + tmp25 := lang.Apply(tmp9, []any{tmp24}) + tmp26 := lang.Apply(tmp6, []any{tmp8, tmp25}) + tmp27 := lang.Apply(tmp5, []any{tmp26}) + return tmp27 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_future = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_future.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // future-call + { + tmp0 := sym_future_DASH_call.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f)), kw_doc, "Takes a function of no args and yields a future object that will\n invoke the function in another thread, and will cache the result and\n return it on all subsequent calls to deref/@. If the computation has\n not yet finished, calls to deref/@ will block, unless the variant\n of deref with timeout is used. See also - realized?.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(7003), kw_end_DASH_line, int(7003))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "f" + tmp4 := checkDerefVar(var_glojure_DOT_core_binding_DASH_conveyor_DASH_fn) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + // let binding "fut" + tmp7 := lang.Apply(lang.AgentSubmit, []any{v6}) + var v8 any = tmp7 + _ = v8 + tmp3 = v8 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_future_DASH_call = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_future_DASH_call.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // get-in + { + tmp0 := sym_get_DASH_in.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m, sym_ks), lang.NewVector(sym_m, sym_ks, sym_not_DASH_found)), kw_doc, "Returns the value in a nested associative structure,\n where ks is a sequence of keys. Returns nil if the key\n is not present, or the not-found value if supplied.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(6128), kw_end_DASH_line, int(6128))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp5 := checkDerefVar(var_glojure_DOT_core_get) + tmp6 := lang.Apply(tmp4, []any{tmp5, v2, v3}) + return tmp6 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + { // let + // let binding "sentinel" + tmp6 := lang.Apply(reflect.StructOf, []any{nil}) + tmp7 := lang.Apply(reflect.New, []any{tmp6}) + tmp8, ok := lang.FieldOrMethod(tmp7, "Interface") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp7, "Interface"))) + } + var tmp9 any + switch reflect.TypeOf(tmp8).Kind() { + case reflect.Func: + tmp9 = lang.Apply(tmp8, nil) + default: + tmp9 = tmp8 + } + var v10 any = tmp9 + _ = v10 + // let binding "m" + var v11 any = v2 + _ = v11 + // let binding "ks" + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := lang.Apply(tmp12, []any{v3}) + var v14 any = tmp13 + _ = v14 + for { + var tmp15 any + if lang.IsTruthy(v14) { + var tmp16 any + { // let + // let binding "m" + tmp17 := checkDerefVar(var_glojure_DOT_core_get) + tmp18 := checkDerefVar(var_glojure_DOT_core_first) + tmp19 := lang.Apply(tmp18, []any{v14}) + tmp20 := lang.Apply(tmp17, []any{v11, tmp19, v10}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + tmp23 := checkDerefVar(var_glojure_DOT_core_identical_QMARK_) + tmp24 := lang.Apply(tmp23, []any{v10, v21}) + if lang.IsTruthy(tmp24) { + tmp22 = v4 + } else { + var tmp25 any = v10 + var tmp26 any = v21 + tmp28 := checkDerefVar(var_glojure_DOT_core_next) + tmp29 := lang.Apply(tmp28, []any{v14}) + var tmp27 any = tmp29 + v10 = tmp25 + v11 = tmp26 + v14 = tmp27 + continue + } + tmp16 = tmp22 + } // end let + tmp15 = tmp16 + } else { + tmp15 = v11 + } + tmp5 = tmp15 + break + } + } // end let + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_get_DASH_in = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_get_DASH_in.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // if-let + { + tmp0 := sym_if_DASH_let.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym_then), lang.NewVector(sym_bindings, sym_then, sym_else, sym__AMP_, sym_oldform)), kw_doc, "bindings => binding-form test\n\n If test is true, evaluates then with binding-form bound to the value of \n test, if not, yields else", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(11), kw_line, int(1839), kw_end_DASH_line, int(1839))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_if_DASH_let}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{v4}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v5}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{nil}) + tmp16 := lang.Apply(tmp7, []any{tmp9, tmp11, tmp13, tmp15}) + tmp17 := lang.Apply(tmp6, []any{tmp16}) + return tmp17 + default: + checkArity(args, 5) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + var v7 any = lang.NewList(args[5:]...) + _ = v7 + var tmp8 any + tmp9 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp10 := lang.Apply(tmp9, []any{v4}) + if lang.IsTruthy(tmp10) { + } else { + tmp11 := checkDerefVar(var_glojure_DOT_core_str) + tmp12 := checkDerefVar(var_glojure_DOT_core_first) + tmp13 := lang.Apply(tmp12, []any{v2}) + tmp14 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp15 := checkDerefVar(var_glojure_DOT_core_meta) + tmp16 := lang.Apply(tmp15, []any{v2}) + tmp17 := lang.Apply(kw_line, []any{tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp13, " requires ", "a vector for its binding", " in ", tmp14, ":", tmp17}) + tmp19 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp18}) + panic(tmp19) + } + _ = tmp8 + var tmp20 any + tmp21 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp22 := lang.Apply(tmp21, []any{v7}) + if lang.IsTruthy(tmp22) { + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp27 := checkDerefVar(var_glojure_DOT_core_meta) + tmp28 := lang.Apply(tmp27, []any{v2}) + tmp29 := lang.Apply(kw_line, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp25, " requires ", "1 or 2 forms after binding vector", " in ", tmp26, ":", tmp29}) + tmp31 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp31) + } + _ = tmp20 + var tmp32 any + tmp33 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp34 := checkDerefVar(var_glojure_DOT_core_count) + tmp35 := lang.Apply(tmp34, []any{v4}) + tmp36 := lang.Apply(tmp33, []any{int64(2), tmp35}) + if lang.IsTruthy(tmp36) { + } else { + tmp37 := checkDerefVar(var_glojure_DOT_core_str) + tmp38 := checkDerefVar(var_glojure_DOT_core_first) + tmp39 := lang.Apply(tmp38, []any{v2}) + tmp40 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp41 := checkDerefVar(var_glojure_DOT_core_meta) + tmp42 := lang.Apply(tmp41, []any{v2}) + tmp43 := lang.Apply(kw_line, []any{tmp42}) + tmp44 := lang.Apply(tmp37, []any{tmp39, " requires ", "exactly 2 forms in binding vector", " in ", tmp40, ":", tmp43}) + tmp45 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp44}) + panic(tmp45) + } + _ = tmp32 + var tmp46 any + { // let + // let binding "form" + tmp47 := lang.Apply(v4, []any{int64(0)}) + var v48 any = tmp47 + _ = v48 + // let binding "tst" + tmp49 := lang.Apply(v4, []any{int64(1)}) + var v50 any = tmp49 + _ = v50 + tmp51 := checkDerefVar(var_glojure_DOT_core_seq) + tmp52 := checkDerefVar(var_glojure_DOT_core_concat) + tmp53 := checkDerefVar(var_glojure_DOT_core_list) + tmp54 := lang.Apply(tmp53, []any{sym_glojure_DOT_core_SLASH_let}) + tmp55 := checkDerefVar(var_glojure_DOT_core_list) + tmp56 := checkDerefVar(var_glojure_DOT_core_apply) + tmp57 := checkDerefVar(var_glojure_DOT_core_vector) + tmp58 := checkDerefVar(var_glojure_DOT_core_seq) + tmp59 := checkDerefVar(var_glojure_DOT_core_concat) + tmp60 := checkDerefVar(var_glojure_DOT_core_list) + tmp61 := lang.Apply(tmp60, []any{sym_temp__0__auto__}) + tmp62 := checkDerefVar(var_glojure_DOT_core_list) + tmp63 := lang.Apply(tmp62, []any{v50}) + tmp64 := lang.Apply(tmp59, []any{tmp61, tmp63}) + tmp65 := lang.Apply(tmp58, []any{tmp64}) + tmp66 := lang.Apply(tmp56, []any{tmp57, tmp65}) + tmp67 := lang.Apply(tmp55, []any{tmp66}) + tmp68 := checkDerefVar(var_glojure_DOT_core_list) + tmp69 := checkDerefVar(var_glojure_DOT_core_seq) + tmp70 := checkDerefVar(var_glojure_DOT_core_concat) + tmp71 := checkDerefVar(var_glojure_DOT_core_list) + tmp72 := lang.Apply(tmp71, []any{sym_if}) + tmp73 := checkDerefVar(var_glojure_DOT_core_list) + tmp74 := lang.Apply(tmp73, []any{sym_temp__0__auto__}) + tmp75 := checkDerefVar(var_glojure_DOT_core_list) + tmp76 := checkDerefVar(var_glojure_DOT_core_seq) + tmp77 := checkDerefVar(var_glojure_DOT_core_concat) + tmp78 := checkDerefVar(var_glojure_DOT_core_list) + tmp79 := lang.Apply(tmp78, []any{sym_glojure_DOT_core_SLASH_let}) + tmp80 := checkDerefVar(var_glojure_DOT_core_list) + tmp81 := checkDerefVar(var_glojure_DOT_core_apply) + tmp82 := checkDerefVar(var_glojure_DOT_core_vector) + tmp83 := checkDerefVar(var_glojure_DOT_core_seq) + tmp84 := checkDerefVar(var_glojure_DOT_core_concat) + tmp85 := checkDerefVar(var_glojure_DOT_core_list) + tmp86 := lang.Apply(tmp85, []any{v48}) + tmp87 := checkDerefVar(var_glojure_DOT_core_list) + tmp88 := lang.Apply(tmp87, []any{sym_temp__0__auto__}) + tmp89 := lang.Apply(tmp84, []any{tmp86, tmp88}) + tmp90 := lang.Apply(tmp83, []any{tmp89}) + tmp91 := lang.Apply(tmp81, []any{tmp82, tmp90}) + tmp92 := lang.Apply(tmp80, []any{tmp91}) + tmp93 := checkDerefVar(var_glojure_DOT_core_list) + tmp94 := lang.Apply(tmp93, []any{v5}) + tmp95 := lang.Apply(tmp77, []any{tmp79, tmp92, tmp94}) + tmp96 := lang.Apply(tmp76, []any{tmp95}) + tmp97 := lang.Apply(tmp75, []any{tmp96}) + tmp98 := checkDerefVar(var_glojure_DOT_core_list) + tmp99 := lang.Apply(tmp98, []any{v6}) + tmp100 := lang.Apply(tmp70, []any{tmp72, tmp74, tmp97, tmp99}) + tmp101 := lang.Apply(tmp69, []any{tmp100}) + tmp102 := lang.Apply(tmp68, []any{tmp101}) + tmp103 := lang.Apply(tmp52, []any{tmp54, tmp67, tmp102}) + tmp104 := lang.Apply(tmp51, []any{tmp103}) + tmp46 = tmp104 + } // end let + return tmp46 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_if_DASH_let = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_if_DASH_let.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // if-some + { + tmp0 := sym_if_DASH_some.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym_then), lang.NewVector(sym_bindings, sym_then, sym_else, sym__AMP_, sym_oldform)), kw_doc, "bindings => binding-form test\n\n If test is not nil, evaluates then with binding-form bound to the\n value of test, if not, yields else", kw_file, "glojure/core.glj", kw_added, "1.6", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(1874), kw_end_DASH_line, int(1874))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_if_DASH_some}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{v4}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v5}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{nil}) + tmp16 := lang.Apply(tmp7, []any{tmp9, tmp11, tmp13, tmp15}) + tmp17 := lang.Apply(tmp6, []any{tmp16}) + return tmp17 + default: + checkArity(args, 5) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + var v7 any = lang.NewList(args[5:]...) + _ = v7 + var tmp8 any + tmp9 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp10 := lang.Apply(tmp9, []any{v4}) + if lang.IsTruthy(tmp10) { + } else { + tmp11 := checkDerefVar(var_glojure_DOT_core_str) + tmp12 := checkDerefVar(var_glojure_DOT_core_first) + tmp13 := lang.Apply(tmp12, []any{v2}) + tmp14 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp15 := checkDerefVar(var_glojure_DOT_core_meta) + tmp16 := lang.Apply(tmp15, []any{v2}) + tmp17 := lang.Apply(kw_line, []any{tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp13, " requires ", "a vector for its binding", " in ", tmp14, ":", tmp17}) + tmp19 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp18}) + panic(tmp19) + } + _ = tmp8 + var tmp20 any + tmp21 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp22 := lang.Apply(tmp21, []any{v7}) + if lang.IsTruthy(tmp22) { + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp27 := checkDerefVar(var_glojure_DOT_core_meta) + tmp28 := lang.Apply(tmp27, []any{v2}) + tmp29 := lang.Apply(kw_line, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp25, " requires ", "1 or 2 forms after binding vector", " in ", tmp26, ":", tmp29}) + tmp31 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp31) + } + _ = tmp20 + var tmp32 any + tmp33 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp34 := checkDerefVar(var_glojure_DOT_core_count) + tmp35 := lang.Apply(tmp34, []any{v4}) + tmp36 := lang.Apply(tmp33, []any{int64(2), tmp35}) + if lang.IsTruthy(tmp36) { + } else { + tmp37 := checkDerefVar(var_glojure_DOT_core_str) + tmp38 := checkDerefVar(var_glojure_DOT_core_first) + tmp39 := lang.Apply(tmp38, []any{v2}) + tmp40 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp41 := checkDerefVar(var_glojure_DOT_core_meta) + tmp42 := lang.Apply(tmp41, []any{v2}) + tmp43 := lang.Apply(kw_line, []any{tmp42}) + tmp44 := lang.Apply(tmp37, []any{tmp39, " requires ", "exactly 2 forms in binding vector", " in ", tmp40, ":", tmp43}) + tmp45 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp44}) + panic(tmp45) + } + _ = tmp32 + var tmp46 any + { // let + // let binding "form" + tmp47 := lang.Apply(v4, []any{int64(0)}) + var v48 any = tmp47 + _ = v48 + // let binding "tst" + tmp49 := lang.Apply(v4, []any{int64(1)}) + var v50 any = tmp49 + _ = v50 + tmp51 := checkDerefVar(var_glojure_DOT_core_seq) + tmp52 := checkDerefVar(var_glojure_DOT_core_concat) + tmp53 := checkDerefVar(var_glojure_DOT_core_list) + tmp54 := lang.Apply(tmp53, []any{sym_glojure_DOT_core_SLASH_let}) + tmp55 := checkDerefVar(var_glojure_DOT_core_list) + tmp56 := checkDerefVar(var_glojure_DOT_core_apply) + tmp57 := checkDerefVar(var_glojure_DOT_core_vector) + tmp58 := checkDerefVar(var_glojure_DOT_core_seq) + tmp59 := checkDerefVar(var_glojure_DOT_core_concat) + tmp60 := checkDerefVar(var_glojure_DOT_core_list) + tmp61 := lang.Apply(tmp60, []any{sym_temp__0__auto__}) + tmp62 := checkDerefVar(var_glojure_DOT_core_list) + tmp63 := lang.Apply(tmp62, []any{v50}) + tmp64 := lang.Apply(tmp59, []any{tmp61, tmp63}) + tmp65 := lang.Apply(tmp58, []any{tmp64}) + tmp66 := lang.Apply(tmp56, []any{tmp57, tmp65}) + tmp67 := lang.Apply(tmp55, []any{tmp66}) + tmp68 := checkDerefVar(var_glojure_DOT_core_list) + tmp69 := checkDerefVar(var_glojure_DOT_core_seq) + tmp70 := checkDerefVar(var_glojure_DOT_core_concat) + tmp71 := checkDerefVar(var_glojure_DOT_core_list) + tmp72 := lang.Apply(tmp71, []any{sym_if}) + tmp73 := checkDerefVar(var_glojure_DOT_core_list) + tmp74 := checkDerefVar(var_glojure_DOT_core_seq) + tmp75 := checkDerefVar(var_glojure_DOT_core_concat) + tmp76 := checkDerefVar(var_glojure_DOT_core_list) + tmp77 := lang.Apply(tmp76, []any{sym_glojure_DOT_core_SLASH_nil_QMARK_}) + tmp78 := checkDerefVar(var_glojure_DOT_core_list) + tmp79 := lang.Apply(tmp78, []any{sym_temp__0__auto__}) + tmp80 := lang.Apply(tmp75, []any{tmp77, tmp79}) + tmp81 := lang.Apply(tmp74, []any{tmp80}) + tmp82 := lang.Apply(tmp73, []any{tmp81}) + tmp83 := checkDerefVar(var_glojure_DOT_core_list) + tmp84 := lang.Apply(tmp83, []any{v6}) + tmp85 := checkDerefVar(var_glojure_DOT_core_list) + tmp86 := checkDerefVar(var_glojure_DOT_core_seq) + tmp87 := checkDerefVar(var_glojure_DOT_core_concat) + tmp88 := checkDerefVar(var_glojure_DOT_core_list) + tmp89 := lang.Apply(tmp88, []any{sym_glojure_DOT_core_SLASH_let}) + tmp90 := checkDerefVar(var_glojure_DOT_core_list) + tmp91 := checkDerefVar(var_glojure_DOT_core_apply) + tmp92 := checkDerefVar(var_glojure_DOT_core_vector) + tmp93 := checkDerefVar(var_glojure_DOT_core_seq) + tmp94 := checkDerefVar(var_glojure_DOT_core_concat) + tmp95 := checkDerefVar(var_glojure_DOT_core_list) + tmp96 := lang.Apply(tmp95, []any{v48}) + tmp97 := checkDerefVar(var_glojure_DOT_core_list) + tmp98 := lang.Apply(tmp97, []any{sym_temp__0__auto__}) + tmp99 := lang.Apply(tmp94, []any{tmp96, tmp98}) + tmp100 := lang.Apply(tmp93, []any{tmp99}) + tmp101 := lang.Apply(tmp91, []any{tmp92, tmp100}) + tmp102 := lang.Apply(tmp90, []any{tmp101}) + tmp103 := checkDerefVar(var_glojure_DOT_core_list) + tmp104 := lang.Apply(tmp103, []any{v5}) + tmp105 := lang.Apply(tmp87, []any{tmp89, tmp102, tmp104}) + tmp106 := lang.Apply(tmp86, []any{tmp105}) + tmp107 := lang.Apply(tmp85, []any{tmp106}) + tmp108 := lang.Apply(tmp70, []any{tmp72, tmp82, tmp84, tmp107}) + tmp109 := lang.Apply(tmp69, []any{tmp108}) + tmp110 := lang.Apply(tmp68, []any{tmp109}) + tmp111 := lang.Apply(tmp52, []any{tmp54, tmp67, tmp110}) + tmp112 := lang.Apply(tmp51, []any{tmp111}) + tmp46 = tmp112 + } // end let + return tmp46 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_if_DASH_some = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_if_DASH_some.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // into1 + { + tmp0 := sym_into1.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_to, sym_from)), kw_doc, "Returns a new coll consisting of to-coll with all of the items of\n from-coll conjoined.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(3416), kw_end_DASH_line, int(3416), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp6 := reflect.TypeOf((*lang.IEditableCollection)(nil)).Elem() + tmp7 := lang.Apply(tmp5, []any{tmp6, v2}) + if lang.IsTruthy(tmp7) { + tmp8 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp10 := checkDerefVar(var_glojure_DOT_core_conj_BANG_) + tmp11 := checkDerefVar(var_glojure_DOT_core_transient) + tmp12 := lang.Apply(tmp11, []any{v2}) + tmp13 := lang.Apply(tmp9, []any{tmp10, tmp12, v3}) + tmp14 := lang.Apply(tmp8, []any{tmp13}) + tmp4 = tmp14 + } else { + tmp15 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp16 := checkDerefVar(var_glojure_DOT_core_conj) + tmp17 := lang.Apply(tmp15, []any{tmp16, v2, v3}) + tmp4 = tmp17 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_into1 = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_into1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // juxt + { + tmp0 := sym_juxt.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_g), lang.NewVector(sym_f, sym_g, sym_h), lang.NewVector(sym_f, sym_g, sym_h, sym__AMP_, sym_fs)), kw_doc, "Takes a set of functions and returns a fn that is the juxtaposition\n of those fns. The returned fn takes a variable number of args, and\n returns a vector containing the result of applying each fn to the\n args (left-to-right).\n ((juxt a b c) x) => [(a x) (b x) (c x)]", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(2568), kw_end_DASH_line, int(2568))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp4 := lang.Apply(v2, nil) + tmp5 := lang.NewVector(tmp4) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2578), kw_column, int(12), kw_end_DASH_line, int(2578), kw_end_DASH_column, int(16)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp7 + case 1: + v4 := args[0] + _ = v4 + tmp5 := lang.Apply(v2, []any{v4}) + tmp6 := lang.NewVector(tmp5) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2579), kw_column, int(13), kw_end_DASH_line, int(2579), kw_end_DASH_column, int(19)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp8 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6 := lang.Apply(v2, []any{v4, v5}) + tmp7 := lang.NewVector(tmp6) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2580), kw_column, int(15), kw_end_DASH_line, int(2580), kw_end_DASH_column, int(23)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp9 + case 3: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := args[2] + _ = v6 + tmp7 := lang.Apply(v2, []any{v4, v5, v6}) + tmp8 := lang.NewVector(tmp7) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2581), kw_column, int(17), kw_end_DASH_line, int(2581), kw_end_DASH_column, int(27)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp10 + default: + checkArity(args, 3) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := args[2] + _ = v6 + var v7 any = lang.NewList(args[3:]...) + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_apply) + tmp9 := lang.Apply(tmp8, []any{v2, v4, v5, v6, v7}) + tmp10 := lang.NewVector(tmp9) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2582), kw_column, int(24), kw_end_DASH_line, int(2582), kw_end_DASH_column, int(45)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp12 + } + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2577), kw_column, int(6), kw_end_DASH_line, int(2582), kw_end_DASH_column, int(47)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp5 := lang.Apply(v2, nil) + tmp6 := lang.Apply(v3, nil) + tmp7 := lang.NewVector(tmp5, tmp6) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2585), kw_column, int(12), kw_end_DASH_line, int(2585), kw_end_DASH_column, int(20)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp9 + case 1: + v5 := args[0] + _ = v5 + tmp6 := lang.Apply(v2, []any{v5}) + tmp7 := lang.Apply(v3, []any{v5}) + tmp8 := lang.NewVector(tmp6, tmp7) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2586), kw_column, int(13), kw_end_DASH_line, int(2586), kw_end_DASH_column, int(25)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp10 + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + tmp7 := lang.Apply(v2, []any{v5, v6}) + tmp8 := lang.Apply(v3, []any{v5, v6}) + tmp9 := lang.NewVector(tmp7, tmp8) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2587), kw_column, int(15), kw_end_DASH_line, int(2587), kw_end_DASH_column, int(31)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp11 + case 3: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := args[2] + _ = v7 + tmp8 := lang.Apply(v2, []any{v5, v6, v7}) + tmp9 := lang.Apply(v3, []any{v5, v6, v7}) + tmp10 := lang.NewVector(tmp8, tmp9) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2588), kw_column, int(17), kw_end_DASH_line, int(2588), kw_end_DASH_column, int(37)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp12 + default: + checkArity(args, 3) + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := args[2] + _ = v7 + var v8 any = lang.NewList(args[3:]...) + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_apply) + tmp10 := lang.Apply(tmp9, []any{v2, v5, v6, v7, v8}) + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + tmp12 := lang.Apply(tmp11, []any{v3, v5, v6, v7, v8}) + tmp13 := lang.NewVector(tmp10, tmp12) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2589), kw_column, int(24), kw_end_DASH_line, int(2589), kw_end_DASH_column, int(66)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp15 + } + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2584), kw_column, int(6), kw_end_DASH_line, int(2589), kw_end_DASH_column, int(68)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp6 := lang.Apply(v2, nil) + tmp7 := lang.Apply(v3, nil) + tmp8 := lang.Apply(v4, nil) + tmp9 := lang.NewVector(tmp6, tmp7, tmp8) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2592), kw_column, int(12), kw_end_DASH_line, int(2592), kw_end_DASH_column, int(24)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp11 + case 1: + v6 := args[0] + _ = v6 + tmp7 := lang.Apply(v2, []any{v6}) + tmp8 := lang.Apply(v3, []any{v6}) + tmp9 := lang.Apply(v4, []any{v6}) + tmp10 := lang.NewVector(tmp7, tmp8, tmp9) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2593), kw_column, int(13), kw_end_DASH_line, int(2593), kw_end_DASH_column, int(31)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp12 + case 2: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + tmp8 := lang.Apply(v2, []any{v6, v7}) + tmp9 := lang.Apply(v3, []any{v6, v7}) + tmp10 := lang.Apply(v4, []any{v6, v7}) + tmp11 := lang.NewVector(tmp8, tmp9, tmp10) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2594), kw_column, int(15), kw_end_DASH_line, int(2594), kw_end_DASH_column, int(39)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp13 + case 3: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + tmp9 := lang.Apply(v2, []any{v6, v7, v8}) + tmp10 := lang.Apply(v3, []any{v6, v7, v8}) + tmp11 := lang.Apply(v4, []any{v6, v7, v8}) + tmp12 := lang.NewVector(tmp9, tmp10, tmp11) + tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2595), kw_column, int(17), kw_end_DASH_line, int(2595), kw_end_DASH_column, int(47)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp14 + default: + checkArity(args, 3) + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + var v9 any = lang.NewList(args[3:]...) + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_apply) + tmp11 := lang.Apply(tmp10, []any{v2, v6, v7, v8, v9}) + tmp12 := checkDerefVar(var_glojure_DOT_core_apply) + tmp13 := lang.Apply(tmp12, []any{v3, v6, v7, v8, v9}) + tmp14 := checkDerefVar(var_glojure_DOT_core_apply) + tmp15 := lang.Apply(tmp14, []any{v4, v6, v7, v8, v9}) + tmp16 := lang.NewVector(tmp11, tmp13, tmp15) + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2596), kw_column, int(24), kw_end_DASH_line, int(2596), kw_end_DASH_column, int(87)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp18 + } + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2591), kw_column, int(6), kw_end_DASH_line, int(2596), kw_end_DASH_column, int(89)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp7 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "fs" + tmp7 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp8 := lang.Apply(tmp7, []any{v2, v3, v4, v5}) + var v9 any = tmp8 + _ = v9 + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp11 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp12 lang.FnFunc + tmp12 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v13 := args[0] + _ = v13 + v14 := args[1] + _ = v14 + tmp15 := checkDerefVar(var_glojure_DOT_core_conj) + tmp16 := lang.Apply(v14, nil) + tmp17 := lang.Apply(tmp15, []any{v13, tmp16}) + return tmp17 + }) + tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2600), kw_column, int(23), kw_end_DASH_line, int(2600), kw_end_DASH_column, int(37)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp15 := lang.NewVector() + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2600), kw_column, int(39), kw_end_DASH_line, int(2600), kw_end_DASH_column, int(40)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp18 := lang.Apply(tmp11, []any{tmp14, tmp17, v9}) + return tmp18 + case 1: + v11 := args[0] + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v14 := args[0] + _ = v14 + v15 := args[1] + _ = v15 + tmp16 := checkDerefVar(var_glojure_DOT_core_conj) + tmp17 := lang.Apply(v15, []any{v11}) + tmp18 := lang.Apply(tmp16, []any{v14, tmp17}) + return tmp18 + }) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2601), kw_column, int(24), kw_end_DASH_line, int(2601), kw_end_DASH_column, int(40)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp16 := lang.NewVector() + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2601), kw_column, int(42), kw_end_DASH_line, int(2601), kw_end_DASH_column, int(43)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp19 := lang.Apply(tmp12, []any{tmp15, tmp18, v9}) + return tmp19 + case 2: + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v15 := args[0] + _ = v15 + v16 := args[1] + _ = v16 + tmp17 := checkDerefVar(var_glojure_DOT_core_conj) + tmp18 := lang.Apply(v16, []any{v11, v12}) + tmp19 := lang.Apply(tmp17, []any{v15, tmp18}) + return tmp19 + }) + tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2602), kw_column, int(26), kw_end_DASH_line, int(2602), kw_end_DASH_column, int(44)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp17 := lang.NewVector() + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2602), kw_column, int(46), kw_end_DASH_line, int(2602), kw_end_DASH_column, int(47)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp20 := lang.Apply(tmp13, []any{tmp16, tmp19, v9}) + return tmp20 + case 3: + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + v13 := args[2] + _ = v13 + tmp14 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp15 lang.FnFunc + tmp15 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v16 := args[0] + _ = v16 + v17 := args[1] + _ = v17 + tmp18 := checkDerefVar(var_glojure_DOT_core_conj) + tmp19 := lang.Apply(v17, []any{v11, v12, v13}) + tmp20 := lang.Apply(tmp18, []any{v16, tmp19}) + return tmp20 + }) + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2603), kw_column, int(28), kw_end_DASH_line, int(2603), kw_end_DASH_column, int(48)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp18 := lang.NewVector() + tmp19 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2603), kw_column, int(50), kw_end_DASH_line, int(2603), kw_end_DASH_column, int(51)) + tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp21 := lang.Apply(tmp14, []any{tmp17, tmp20, v9}) + return tmp21 + default: + checkArity(args, 3) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + v13 := args[2] + _ = v13 + var v14 any = lang.NewList(args[3:]...) + _ = v14 + tmp15 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp16 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v17 := args[0] + _ = v17 + v18 := args[1] + _ = v18 + tmp19 := checkDerefVar(var_glojure_DOT_core_conj) + tmp20 := checkDerefVar(var_glojure_DOT_core_apply) + tmp21 := lang.Apply(tmp20, []any{v18, v11, v12, v13, v14}) + tmp22 := lang.Apply(tmp19, []any{v17, tmp21}) + return tmp22 + }) + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2604), kw_column, int(35), kw_end_DASH_line, int(2604), kw_end_DASH_column, int(66)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp19 := lang.NewVector() + tmp20 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2604), kw_column, int(68), kw_end_DASH_line, int(2604), kw_end_DASH_column, int(69)) + tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp22 := lang.Apply(tmp15, []any{tmp18, tmp21, v9}) + return tmp22 + } + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2599), kw_column, int(8), kw_end_DASH_line, int(2604), kw_end_DASH_column, int(75)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp6 = tmp12 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_juxt = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_juxt.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // keep + { + tmp0 := sym_keep.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_coll)), kw_doc, "Returns a lazy sequence of the non-nil results of (f item). Note,\n this means false return values will be included. f must be free of\n side-effects. Returns a transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(7339), kw_end_DASH_line, int(7339))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp6 := lang.Apply(v4, nil) + return tmp6 + case 1: + v6 := args[0] + _ = v6 + tmp7 := lang.Apply(v4, []any{v6}) + return tmp7 + case 2: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + var tmp8 any + { // let + // let binding "v" + tmp9 := lang.Apply(v2, []any{v7}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp13 := lang.Apply(tmp12, []any{v10}) + if lang.IsTruthy(tmp13) { + tmp11 = v6 + } else { + tmp14 := lang.Apply(v4, []any{v6, v10}) + tmp11 = tmp14 + } + tmp8 = tmp11 + } // end let + return tmp8 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7347), kw_column, int(6), kw_end_DASH_line, int(7354), kw_end_DASH_column, int(31)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp7 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7346), kw_column, int(4), kw_end_DASH_line, int(7354), kw_end_DASH_column, int(32)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp5 any + { // let + // let binding "temp__0__auto__" + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := lang.Apply(tmp6, []any{v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + var tmp10 any + { // let + // let binding "s" + var v11 any = v8 + _ = v11 + var tmp12 any + tmp13 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp14 := lang.Apply(tmp13, []any{v11}) + if lang.IsTruthy(tmp14) { + var tmp15 any + { // let + // let binding "c" + tmp16 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp17 := lang.Apply(tmp16, []any{v11}) + var v18 any = tmp17 + _ = v18 + // let binding "size" + tmp19 := checkDerefVar(var_glojure_DOT_core_count) + tmp20 := lang.Apply(tmp19, []any{v18}) + var v21 any = tmp20 + _ = v21 + // let binding "b" + tmp22 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_buffer) + tmp23 := lang.Apply(tmp22, []any{v21}) + var v24 any = tmp23 + _ = v24 + var tmp25 any + { // let + // let binding "n__0__auto__" + tmp26 := checkDerefVar(var_glojure_DOT_core_long) + tmp27 := lang.Apply(tmp26, []any{v21}) + var v28 any = tmp27 + _ = v28 + var tmp29 any + { // let + // let binding "i" + var v30 any = int64(0) + _ = v30 + for { + var tmp31 any + tmp32 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp33 := lang.Apply(tmp32, []any{v30, v28}) + if lang.IsTruthy(tmp33) { + var tmp34 any + { // let + // let binding "x" + tmp35, _ := lang.FieldOrMethod(v18, "nth") + if reflect.TypeOf(tmp35).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp36 := lang.Apply(tmp35, []any{v30}) + tmp37 := lang.Apply(v2, []any{tmp36}) + var v38 any = tmp37 + _ = v38 + var tmp39 any + tmp40 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp41 := lang.Apply(tmp40, []any{v38}) + if lang.IsTruthy(tmp41) { + } else { + tmp42 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_append) + tmp43 := lang.Apply(tmp42, []any{v24, v38}) + tmp39 = tmp43 + } + tmp34 = tmp39 + } // end let + _ = tmp34 + tmp36 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp37 := lang.Apply(tmp36, []any{v30}) + var tmp35 any = tmp37 + v30 = tmp35 + continue + } else { + } + tmp29 = tmp31 + break + } + } // end let + tmp25 = tmp29 + } // end let + _ = tmp25 + tmp26 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_cons) + tmp27 := checkDerefVar(var_glojure_DOT_core_chunk) + tmp28 := lang.Apply(tmp27, []any{v24}) + tmp29 := checkDerefVar(var_glojure_DOT_core_keep) + tmp30 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp31 := lang.Apply(tmp30, []any{v11}) + tmp32 := lang.Apply(tmp29, []any{v2, tmp31}) + tmp33 := lang.Apply(tmp26, []any{tmp28, tmp32}) + tmp15 = tmp33 + } // end let + tmp12 = tmp15 + } else { + var tmp16 any + { // let + // let binding "x" + tmp17 := checkDerefVar(var_glojure_DOT_core_first) + tmp18 := lang.Apply(tmp17, []any{v11}) + tmp19 := lang.Apply(v2, []any{tmp18}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + tmp22 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp23 := lang.Apply(tmp22, []any{v20}) + if lang.IsTruthy(tmp23) { + tmp24 := checkDerefVar(var_glojure_DOT_core_keep) + tmp25 := checkDerefVar(var_glojure_DOT_core_rest) + tmp26 := lang.Apply(tmp25, []any{v11}) + tmp27 := lang.Apply(tmp24, []any{v2, tmp26}) + tmp21 = tmp27 + } else { + tmp28 := checkDerefVar(var_glojure_DOT_core_cons) + tmp29 := checkDerefVar(var_glojure_DOT_core_keep) + tmp30 := checkDerefVar(var_glojure_DOT_core_rest) + tmp31 := lang.Apply(tmp30, []any{v11}) + tmp32 := lang.Apply(tmp29, []any{v2, tmp31}) + tmp33 := lang.Apply(tmp28, []any{v20, tmp32}) + tmp21 = tmp33 + } + tmp16 = tmp21 + } // end let + tmp12 = tmp16 + } + tmp10 = tmp12 + } // end let + tmp9 = tmp10 + } else { + } + tmp5 = tmp9 + } // end let + return tmp5 + }) + tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_keep = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_keep.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // lazy-seq + { + tmp0 := sym_lazy_DASH_seq.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_body)), kw_doc, "Takes a body of expressions that returns an ISeq or nil, and yields\n a Seqable object that will invoke the body only the first time seq\n is called, and will cache the result and return it on all subsequent\n seq calls. See also - realized?", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(11), kw_line, int(676), kw_end_DASH_line, int(676))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_list) + tmp6 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp7 := lang.NewVector() + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(683), kw_column, int(101), kw_end_DASH_line, int(683), kw_end_DASH_column, int(102)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp10 := lang.Apply(tmp6, []any{sym_fn_STAR_, tmp9, v4}) + tmp11 := lang.Apply(tmp5, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_NewLazySeq, tmp10}) + return tmp11 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_lazy_DASH_seq = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_lazy_DASH_seq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // locking + { + tmp0 := sym_locking.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_x, sym__AMP_, sym_body)), kw_doc, "Executes exprs in an implicit do, while holding the monitor of x.\n Will release the monitor of x in all circumstances.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(1643), kw_end_DASH_line, int(1643))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_let}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + tmp12 := checkDerefVar(var_glojure_DOT_core_vector) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_lockee__0__auto__}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v4}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp19}) + tmp21 := lang.Apply(tmp11, []any{tmp12, tmp20}) + tmp22 := lang.Apply(tmp10, []any{tmp21}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_seq) + tmp25 := checkDerefVar(var_glojure_DOT_core_concat) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{sym_try}) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := checkDerefVar(var_glojure_DOT_core_seq) + tmp30 := checkDerefVar(var_glojure_DOT_core_concat) + tmp31 := checkDerefVar(var_glojure_DOT_core_list) + tmp32 := lang.Apply(tmp31, []any{sym_glojure_DOT_core_SLASH_let}) + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := checkDerefVar(var_glojure_DOT_core_apply) + tmp35 := checkDerefVar(var_glojure_DOT_core_vector) + tmp36 := checkDerefVar(var_glojure_DOT_core_seq) + tmp37 := checkDerefVar(var_glojure_DOT_core_concat) + tmp38 := checkDerefVar(var_glojure_DOT_core_list) + tmp39 := lang.Apply(tmp38, []any{sym_locklocal__1__auto__}) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{sym_lockee__0__auto__}) + tmp42 := lang.Apply(tmp37, []any{tmp39, tmp41}) + tmp43 := lang.Apply(tmp36, []any{tmp42}) + tmp44 := lang.Apply(tmp34, []any{tmp35, tmp43}) + tmp45 := lang.Apply(tmp33, []any{tmp44}) + tmp46 := checkDerefVar(var_glojure_DOT_core_list) + tmp47 := checkDerefVar(var_glojure_DOT_core_seq) + tmp48 := checkDerefVar(var_glojure_DOT_core_concat) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) + tmp50 := lang.Apply(tmp49, []any{sym_monitor_DASH_enter}) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := lang.Apply(tmp51, []any{sym_locklocal__1__auto__}) + tmp53 := lang.Apply(tmp48, []any{tmp50, tmp52}) + tmp54 := lang.Apply(tmp47, []any{tmp53}) + tmp55 := lang.Apply(tmp46, []any{tmp54}) + tmp56 := checkDerefVar(var_glojure_DOT_core_list) + tmp57 := checkDerefVar(var_glojure_DOT_core_seq) + tmp58 := checkDerefVar(var_glojure_DOT_core_concat) + tmp59 := checkDerefVar(var_glojure_DOT_core_list) + tmp60 := lang.Apply(tmp59, []any{sym_try}) + tmp61 := checkDerefVar(var_glojure_DOT_core_list) + tmp62 := checkDerefVar(var_glojure_DOT_core_seq) + tmp63 := checkDerefVar(var_glojure_DOT_core_concat) + tmp64 := checkDerefVar(var_glojure_DOT_core_list) + tmp65 := lang.Apply(tmp64, []any{sym_finally}) + tmp66 := checkDerefVar(var_glojure_DOT_core_list) + tmp67 := checkDerefVar(var_glojure_DOT_core_seq) + tmp68 := checkDerefVar(var_glojure_DOT_core_concat) + tmp69 := checkDerefVar(var_glojure_DOT_core_list) + tmp70 := lang.Apply(tmp69, []any{sym_monitor_DASH_exit}) + tmp71 := checkDerefVar(var_glojure_DOT_core_list) + tmp72 := lang.Apply(tmp71, []any{sym_locklocal__1__auto__}) + tmp73 := lang.Apply(tmp68, []any{tmp70, tmp72}) + tmp74 := lang.Apply(tmp67, []any{tmp73}) + tmp75 := lang.Apply(tmp66, []any{tmp74}) + tmp76 := lang.Apply(tmp63, []any{tmp65, tmp75}) + tmp77 := lang.Apply(tmp62, []any{tmp76}) + tmp78 := lang.Apply(tmp61, []any{tmp77}) + tmp79 := lang.Apply(tmp58, []any{tmp60, v5, tmp78}) + tmp80 := lang.Apply(tmp57, []any{tmp79}) + tmp81 := lang.Apply(tmp56, []any{tmp80}) + tmp82 := lang.Apply(tmp30, []any{tmp32, tmp45, tmp55, tmp81}) + tmp83 := lang.Apply(tmp29, []any{tmp82}) + tmp84 := lang.Apply(tmp28, []any{tmp83}) + tmp85 := lang.Apply(tmp25, []any{tmp27, tmp84}) + tmp86 := lang.Apply(tmp24, []any{tmp85}) + tmp87 := lang.Apply(tmp23, []any{tmp86}) + tmp88 := lang.Apply(tmp7, []any{tmp9, tmp22, tmp87}) + tmp89 := lang.Apply(tmp6, []any{tmp88}) + return tmp89 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_locking = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_locking.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // map + { + tmp0 := sym_map.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_coll), lang.NewVector(sym_f, sym_c1, sym_c2), lang.NewVector(sym_f, sym_c1, sym_c2, sym_c3), lang.NewVector(sym_f, sym_c1, sym_c2, sym_c3, sym__AMP_, sym_colls)), kw_doc, "Returns a lazy sequence consisting of the result of applying f to\n the set of first items of each coll, followed by applying f to the\n set of second items in each coll, until any one of the colls is\n exhausted. Any remaining items in other colls are ignored. Function\n f should accept number-of-colls arguments. Returns a transducer when\n no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(2719), kw_end_DASH_line, int(2719))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp6 := lang.Apply(v4, nil) + return tmp6 + case 1: + v6 := args[0] + _ = v6 + tmp7 := lang.Apply(v4, []any{v6}) + return tmp7 + case 2: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + tmp8 := lang.Apply(v2, []any{v7}) + tmp9 := lang.Apply(v4, []any{v6, tmp8}) + return tmp9 + default: + checkArity(args, 2) + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + var v8 any = lang.NewList(args[2:]...) + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_apply) + tmp10 := lang.Apply(tmp9, []any{v2, v7, v8}) + tmp11 := lang.Apply(v4, []any{v6, tmp10}) + return tmp11 + } + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2730), kw_column, int(7), kw_end_DASH_line, int(2736), kw_end_DASH_column, int(47)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp7 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2729), kw_column, int(5), kw_end_DASH_line, int(2736), kw_end_DASH_column, int(48)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp5 any + { // let + // let binding "temp__0__auto__" + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := lang.Apply(tmp6, []any{v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + var tmp10 any + { // let + // let binding "s" + var v11 any = v8 + _ = v11 + var tmp12 any + tmp13 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp14 := lang.Apply(tmp13, []any{v11}) + if lang.IsTruthy(tmp14) { + var tmp15 any + { // let + // let binding "c" + tmp16 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp17 := lang.Apply(tmp16, []any{v11}) + var v18 any = tmp17 + _ = v18 + // let binding "size" + tmp19 := checkDerefVar(var_glojure_DOT_core_int) + tmp20 := checkDerefVar(var_glojure_DOT_core_count) + tmp21 := lang.Apply(tmp20, []any{v18}) + tmp22 := lang.Apply(tmp19, []any{tmp21}) + var v23 any = tmp22 + _ = v23 + // let binding "b" + tmp24 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_buffer) + tmp25 := lang.Apply(tmp24, []any{v23}) + var v26 any = tmp25 + _ = v26 + var tmp27 any + { // let + // let binding "n__0__auto__" + tmp28 := lang.Apply(lang.LongCast, []any{v23}) + var v29 any = tmp28 + _ = v29 + var tmp30 any + { // let + // let binding "i" + var v31 any = int64(0) + _ = v31 + for { + var tmp32 any + tmp33 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp34 := lang.Apply(tmp33, []any{v31, v29}) + if lang.IsTruthy(tmp34) { + tmp35 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_append) + tmp36, _ := lang.FieldOrMethod(v18, "nth") + if reflect.TypeOf(tmp36).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp37 := lang.Apply(tmp36, []any{v31}) + tmp38 := lang.Apply(v2, []any{tmp37}) + tmp39 := lang.Apply(tmp35, []any{v26, tmp38}) + _ = tmp39 + tmp41 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp42 := lang.Apply(tmp41, []any{v31}) + var tmp40 any = tmp42 + v31 = tmp40 + continue + } else { + } + tmp30 = tmp32 + break + } + } // end let + tmp27 = tmp30 + } // end let + _ = tmp27 + tmp28 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_cons) + tmp29 := checkDerefVar(var_glojure_DOT_core_chunk) + tmp30 := lang.Apply(tmp29, []any{v26}) + tmp31 := checkDerefVar(var_glojure_DOT_core_map) + tmp32 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp33 := lang.Apply(tmp32, []any{v11}) + tmp34 := lang.Apply(tmp31, []any{v2, tmp33}) + tmp35 := lang.Apply(tmp28, []any{tmp30, tmp34}) + tmp15 = tmp35 + } // end let + tmp12 = tmp15 + } else { + tmp16 := checkDerefVar(var_glojure_DOT_core_cons) + tmp17 := checkDerefVar(var_glojure_DOT_core_first) + tmp18 := lang.Apply(tmp17, []any{v11}) + tmp19 := lang.Apply(v2, []any{tmp18}) + tmp20 := checkDerefVar(var_glojure_DOT_core_map) + tmp21 := checkDerefVar(var_glojure_DOT_core_rest) + tmp22 := lang.Apply(tmp21, []any{v11}) + tmp23 := lang.Apply(tmp20, []any{v2, tmp22}) + tmp24 := lang.Apply(tmp16, []any{tmp19, tmp23}) + tmp12 = tmp24 + } + tmp10 = tmp12 + } // end let + tmp9 = tmp10 + } else { + } + tmp5 = tmp9 + } // end let + return tmp5 + }) + tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) + return tmp5 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp6 any + { // let + // let binding "s1" + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := lang.Apply(tmp7, []any{v3}) + var v9 any = tmp8 + _ = v9 + // let binding "s2" + tmp10 := checkDerefVar(var_glojure_DOT_core_seq) + tmp11 := lang.Apply(tmp10, []any{v4}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + var tmp14 any + { // let + // let binding "and__0__auto__" + var v15 any = v9 + _ = v15 + var tmp16 any + if lang.IsTruthy(v15) { + tmp16 = v12 + } else { + tmp16 = v15 + } + tmp14 = tmp16 + } // end let + if lang.IsTruthy(tmp14) { + tmp15 := checkDerefVar(var_glojure_DOT_core_cons) + tmp16 := checkDerefVar(var_glojure_DOT_core_first) + tmp17 := lang.Apply(tmp16, []any{v9}) + tmp18 := checkDerefVar(var_glojure_DOT_core_first) + tmp19 := lang.Apply(tmp18, []any{v12}) + tmp20 := lang.Apply(v2, []any{tmp17, tmp19}) + tmp21 := checkDerefVar(var_glojure_DOT_core_map) + tmp22 := checkDerefVar(var_glojure_DOT_core_rest) + tmp23 := lang.Apply(tmp22, []any{v9}) + tmp24 := checkDerefVar(var_glojure_DOT_core_rest) + tmp25 := lang.Apply(tmp24, []any{v12}) + tmp26 := lang.Apply(tmp21, []any{v2, tmp23, tmp25}) + tmp27 := lang.Apply(tmp15, []any{tmp20, tmp26}) + tmp13 = tmp27 + } else { + } + tmp6 = tmp13 + } // end let + return tmp6 + }) + tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) + return tmp6 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp7 any + { // let + // let binding "s1" + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := lang.Apply(tmp8, []any{v3}) + var v10 any = tmp9 + _ = v10 + // let binding "s2" + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := lang.Apply(tmp11, []any{v4}) + var v13 any = tmp12 + _ = v13 + // let binding "s3" + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := lang.Apply(tmp14, []any{v5}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + var tmp18 any + { // let + // let binding "and__0__auto__" + var v19 any = v10 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + var tmp21 any + { // let + // let binding "and__0__auto__" + var v22 any = v13 + _ = v22 + var tmp23 any + if lang.IsTruthy(v22) { + tmp23 = v16 + } else { + tmp23 = v22 + } + tmp21 = tmp23 + } // end let + tmp20 = tmp21 + } else { + tmp20 = v19 + } + tmp18 = tmp20 + } // end let + if lang.IsTruthy(tmp18) { + tmp19 := checkDerefVar(var_glojure_DOT_core_cons) + tmp20 := checkDerefVar(var_glojure_DOT_core_first) + tmp21 := lang.Apply(tmp20, []any{v10}) + tmp22 := checkDerefVar(var_glojure_DOT_core_first) + tmp23 := lang.Apply(tmp22, []any{v13}) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v16}) + tmp26 := lang.Apply(v2, []any{tmp21, tmp23, tmp25}) + tmp27 := checkDerefVar(var_glojure_DOT_core_map) + tmp28 := checkDerefVar(var_glojure_DOT_core_rest) + tmp29 := lang.Apply(tmp28, []any{v10}) + tmp30 := checkDerefVar(var_glojure_DOT_core_rest) + tmp31 := lang.Apply(tmp30, []any{v13}) + tmp32 := checkDerefVar(var_glojure_DOT_core_rest) + tmp33 := lang.Apply(tmp32, []any{v16}) + tmp34 := lang.Apply(tmp27, []any{v2, tmp29, tmp31, tmp33}) + tmp35 := lang.Apply(tmp19, []any{tmp26, tmp34}) + tmp17 = tmp35 + } else { + } + tmp7 = tmp17 + } // end let + return tmp7 + }) + tmp7 := lang.Apply(lang.NewLazySeq, []any{tmp6}) + return tmp7 + default: + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var v6 any = lang.NewList(args[4:]...) + _ = v6 + var tmp7 any + { // let + // let binding "step" + var tmp8 lang.FnFunc + { // function step + var v9 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v10 := args[0] + _ = v10 + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp12 any + { // let + // let binding "ss" + tmp13 := checkDerefVar(var_glojure_DOT_core_map) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := lang.Apply(tmp13, []any{tmp14, v10}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + tmp18 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + tmp19 := checkDerefVar(var_glojure_DOT_core_identity) + tmp20 := lang.Apply(tmp18, []any{tmp19, v16}) + if lang.IsTruthy(tmp20) { + tmp21 := checkDerefVar(var_glojure_DOT_core_cons) + tmp22 := checkDerefVar(var_glojure_DOT_core_map) + tmp23 := checkDerefVar(var_glojure_DOT_core_first) + tmp24 := lang.Apply(tmp22, []any{tmp23, v16}) + tmp25 := checkDerefVar(var_glojure_DOT_core_map) + tmp26 := checkDerefVar(var_glojure_DOT_core_rest) + tmp27 := lang.Apply(tmp25, []any{tmp26, v16}) + tmp28 := lang.Apply(v9, []any{tmp27}) + tmp29 := lang.Apply(tmp21, []any{tmp24, tmp28}) + tmp17 = tmp29 + } else { + } + tmp12 = tmp17 + } // end let + return tmp12 + }) + tmp12 := lang.Apply(lang.NewLazySeq, []any{tmp11}) + return tmp12 + }) + v9 = tmp8 + _ = v9 + } + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2761), kw_column, int(15), kw_end_DASH_line, int(2765), kw_end_DASH_column, int(68)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v11 any = tmp10 + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_map) + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v14 := args[0] + _ = v14 + tmp15 := checkDerefVar(var_glojure_DOT_core_apply) + tmp16 := lang.Apply(tmp15, []any{v2, v14}) + return tmp16 + }) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2766), kw_column, int(11), kw_end_DASH_line, int(2766), kw_end_DASH_column, int(22)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp16 := checkDerefVar(var_glojure_DOT_core_conj) + tmp17 := lang.Apply(tmp16, []any{v6, v5, v4, v3}) + tmp18 := lang.Apply(v11, []any{tmp17}) + tmp19 := lang.Apply(tmp12, []any{tmp15, tmp18}) + tmp7 = tmp19 + } // end let + return tmp7 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_map = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_map.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // max + { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed22 + } else { + tmp4 = closed22 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed22 + } else { + tmp5 = closed22 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed22 + } else { + tmp6 = closed22 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym_max.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns the greatest of the nums.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(1108), kw_end_DASH_line, int(1108))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + return v4 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Max") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Max is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp8 := checkDerefVar(var_glojure_DOT_core_max) + tmp9 := checkDerefVar(var_glojure_DOT_core_max) + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) + return tmp11 + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_max = ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_max.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // max-key + { + tmp0 := sym_max_DASH_key.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_k, sym_x), lang.NewVector(sym_k, sym_x, sym_y), lang.NewVector(sym_k, sym_x, sym_y, sym__AMP_, sym_more)), kw_doc, "Returns the x for which (k x), a number, is greatest.\n\n If there are multiple such xs, the last one is returned.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(5013), kw_end_DASH_line, int(5013))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + return v3 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__GT_) + tmp7 := lang.Apply(v2, []any{v3}) + tmp8 := lang.Apply(v2, []any{v4}) + tmp9 := lang.Apply(tmp6, []any{tmp7, tmp8}) + if lang.IsTruthy(tmp9) { + tmp5 = v3 + } else { + tmp5 = v4 + } + return tmp5 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "kx" + tmp7 := lang.Apply(v2, []any{v3}) + var v8 any = tmp7 + _ = v8 + // let binding "ky" + tmp9 := lang.Apply(v2, []any{v4}) + var v10 any = tmp9 + _ = v10 + // let binding "vec__746" + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core__GT_) + tmp13 := lang.Apply(tmp12, []any{v8, v10}) + if lang.IsTruthy(tmp13) { + tmp14 := lang.NewVector(v3, v8) + tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5023), kw_column, int(31), kw_end_DASH_line, int(5023), kw_end_DASH_column, int(36)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp11 = tmp16 + } else { + tmp17 := lang.NewVector(v4, v10) + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5023), kw_column, int(38), kw_end_DASH_line, int(5023), kw_end_DASH_column, int(43)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp11 = tmp19 + } + var v20 any = tmp11 + _ = v20 + // let binding "v" + tmp21 := checkDerefVar(var_glojure_DOT_core_nth) + tmp22 := lang.Apply(tmp21, []any{v20, int64(0), nil}) + var v23 any = tmp22 + _ = v23 + // let binding "kv" + tmp24 := checkDerefVar(var_glojure_DOT_core_nth) + tmp25 := lang.Apply(tmp24, []any{v20, int64(1), nil}) + var v26 any = tmp25 + _ = v26 + var tmp27 any + { // let + // let binding "v" + var v28 any = v23 + _ = v28 + // let binding "kv" + var v29 any = v26 + _ = v29 + // let binding "more" + var v30 any = v5 + _ = v30 + for { + var tmp31 any + if lang.IsTruthy(v30) { + var tmp32 any + { // let + // let binding "w" + tmp33 := checkDerefVar(var_glojure_DOT_core_first) + tmp34 := lang.Apply(tmp33, []any{v30}) + var v35 any = tmp34 + _ = v35 + // let binding "kw" + tmp36 := lang.Apply(v2, []any{v35}) + var v37 any = tmp36 + _ = v37 + var tmp38 any + tmp39 := checkDerefVar(var_glojure_DOT_core__GT__EQ_) + tmp40 := lang.Apply(tmp39, []any{v37, v29}) + if lang.IsTruthy(tmp40) { + var tmp41 any = v35 + var tmp42 any = v37 + tmp44 := checkDerefVar(var_glojure_DOT_core_next) + tmp45 := lang.Apply(tmp44, []any{v30}) + var tmp43 any = tmp45 + v28 = tmp41 + v29 = tmp42 + v30 = tmp43 + continue + } else { + var tmp46 any = v28 + var tmp47 any = v29 + tmp49 := checkDerefVar(var_glojure_DOT_core_next) + tmp50 := lang.Apply(tmp49, []any{v30}) + var tmp48 any = tmp50 + v28 = tmp46 + v29 = tmp47 + v30 = tmp48 + continue + } + tmp32 = tmp38 + } // end let + tmp31 = tmp32 + } else { + tmp31 = v28 + } + tmp27 = tmp31 + break + } + } // end let + tmp6 = tmp27 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_max_DASH_key = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_max_DASH_key.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // memfn + { + tmp0 := sym_memfn.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym__AMP_, sym_args)), kw_doc, "Expands into code that creates a fn that expects to be passed an\n object and any args and calls the named instance method on the\n object passing the args. Use when you want to treat a Java method as\n a first-class fn. name may be type-hinted with the method receiver's\n type in order to avoid reflective calls.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(11), kw_line, int(3872), kw_end_DASH_line, int(3872))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "t" + tmp7 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp8 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp9 := lang.Apply(tmp8, []any{"target"}) + tmp10 := checkDerefVar(var_glojure_DOT_core_meta) + tmp11 := lang.Apply(tmp10, []any{v4}) + tmp12 := lang.Apply(tmp7, []any{tmp9, tmp11}) + var v13 any = tmp12 + _ = v13 + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{sym_glojure_DOT_core_SLASH_fn}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := checkDerefVar(var_glojure_DOT_core_apply) + tmp20 := checkDerefVar(var_glojure_DOT_core_vector) + tmp21 := checkDerefVar(var_glojure_DOT_core_seq) + tmp22 := checkDerefVar(var_glojure_DOT_core_concat) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := lang.Apply(tmp23, []any{v13}) + tmp25 := lang.Apply(tmp22, []any{tmp24, v5}) + tmp26 := lang.Apply(tmp21, []any{tmp25}) + tmp27 := lang.Apply(tmp19, []any{tmp20, tmp26}) + tmp28 := lang.Apply(tmp18, []any{tmp27}) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := checkDerefVar(var_glojure_DOT_core_seq) + tmp31 := checkDerefVar(var_glojure_DOT_core_concat) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := lang.Apply(tmp32, []any{sym__DOT_}) + tmp34 := checkDerefVar(var_glojure_DOT_core_list) + tmp35 := lang.Apply(tmp34, []any{v13}) + tmp36 := checkDerefVar(var_glojure_DOT_core_list) + tmp37 := checkDerefVar(var_glojure_DOT_core_seq) + tmp38 := checkDerefVar(var_glojure_DOT_core_concat) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := lang.Apply(tmp39, []any{v4}) + tmp41 := lang.Apply(tmp38, []any{tmp40, v5}) + tmp42 := lang.Apply(tmp37, []any{tmp41}) + tmp43 := lang.Apply(tmp36, []any{tmp42}) + tmp44 := lang.Apply(tmp31, []any{tmp33, tmp35, tmp43}) + tmp45 := lang.Apply(tmp30, []any{tmp44}) + tmp46 := lang.Apply(tmp29, []any{tmp45}) + tmp47 := lang.Apply(tmp15, []any{tmp17, tmp28, tmp46}) + tmp48 := lang.Apply(tmp14, []any{tmp47}) + tmp6 = tmp48 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_memfn = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_memfn.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // merge + { + tmp0 := sym_merge.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_maps)), kw_doc, "Returns a map that consists of the rest of the maps conj-ed onto\n the first. If a key occurs in more than one map, the mapping from\n the latter (left-to-right) will be the mapping in the result.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3040), kw_end_DASH_line, int(3040))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_some) + tmp5 := checkDerefVar(var_glojure_DOT_core_identity) + tmp6 := lang.Apply(tmp4, []any{tmp5, v2}) + if lang.IsTruthy(tmp6) { + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp8 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v9 := args[0] + _ = v9 + v10 := args[1] + _ = v10 + tmp11 := checkDerefVar(var_glojure_DOT_core_conj) + var tmp12 any + { // let + // let binding "or__0__auto__" + var v13 any = v9 + _ = v13 + var tmp14 any + if lang.IsTruthy(v13) { + tmp14 = v13 + } else { + tmp15 := lang.NewMap() + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3048), kw_column, int(28), kw_end_DASH_line, int(3048), kw_end_DASH_column, int(29)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp14 = tmp17 + } + tmp12 = tmp14 + } // end let + tmp13 := lang.Apply(tmp11, []any{tmp12, v10}) + return tmp13 + }) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3048), kw_column, int(14), kw_end_DASH_line, int(3048), kw_end_DASH_column, int(34)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp11 := lang.Apply(tmp7, []any{tmp10, v2}) + tmp3 = tmp11 + } else { + } + return tmp3 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_merge = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_merge.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // merge-with + { + tmp0 := sym_merge_DASH_with.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym__AMP_, sym_maps)), kw_doc, "Returns a map that consists of the rest of the maps conj-ed onto\n the first. If a key occurs in more than one map, the mapping(s)\n from the latter (left-to-right) will be combined with the mapping in\n the result by calling (f val-in-result val-in-latter).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(3050), kw_end_DASH_line, int(3050))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_some) + tmp6 := checkDerefVar(var_glojure_DOT_core_identity) + tmp7 := lang.Apply(tmp5, []any{tmp6, v3}) + if lang.IsTruthy(tmp7) { + var tmp8 any + { // let + // let binding "merge-entry" + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + var tmp12 any + { // let + // let binding "k" + tmp13 := checkDerefVar(var_glojure_DOT_core_key) + tmp14 := lang.Apply(tmp13, []any{v11}) + var v15 any = tmp14 + _ = v15 + // let binding "v" + tmp16 := checkDerefVar(var_glojure_DOT_core_val) + tmp17 := lang.Apply(tmp16, []any{v11}) + var v18 any = tmp17 + _ = v18 + var tmp19 any + tmp20 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp21 := lang.Apply(tmp20, []any{v10, v15}) + if lang.IsTruthy(tmp21) { + tmp22 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp23 := checkDerefVar(var_glojure_DOT_core_get) + tmp24 := lang.Apply(tmp23, []any{v10, v15}) + tmp25 := lang.Apply(v2, []any{tmp24, v18}) + tmp26 := lang.Apply(tmp22, []any{v10, v15, tmp25}) + tmp19 = tmp26 + } else { + tmp27 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp28 := lang.Apply(tmp27, []any{v10, v15, v18}) + tmp19 = tmp28 + } + tmp12 = tmp19 + } // end let + return tmp12 + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3059), kw_column, int(23), kw_end_DASH_line, int(3063), kw_end_DASH_column, int(23)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v12 any = tmp11 + _ = v12 + // let binding "merge2" + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v14 := args[0] + _ = v14 + v15 := args[1] + _ = v15 + tmp16 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp17 any + { // let + // let binding "or__0__auto__" + var v18 any = v14 + _ = v18 + var tmp19 any + if lang.IsTruthy(v18) { + tmp19 = v18 + } else { + tmp20 := lang.NewMap() + tmp21 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3065), kw_column, int(34), kw_end_DASH_line, int(3065), kw_end_DASH_column, int(35)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp19 = tmp22 + } + tmp17 = tmp19 + } // end let + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := lang.Apply(tmp18, []any{v15}) + tmp20 := lang.Apply(tmp16, []any{v12, tmp17, tmp19}) + return tmp20 + }) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3064), kw_column, int(18), kw_end_DASH_line, int(3065), kw_end_DASH_column, int(47)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v16 any = tmp15 + _ = v16 + tmp17 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp18 := lang.Apply(tmp17, []any{v16, v3}) + tmp8 = tmp18 + } // end let + tmp4 = tmp8 + } else { + } + return tmp4 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_merge_DASH_with = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_merge_DASH_with.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // min + { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed23 + } else { + tmp4 = closed23 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed23 + } else { + tmp5 = closed23 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed23 + } else { + tmp6 = closed23 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym_min.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns the least of the nums.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(1118), kw_end_DASH_line, int(1118))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + return v4 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Min") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Min is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp8 := checkDerefVar(var_glojure_DOT_core_min) + tmp9 := checkDerefVar(var_glojure_DOT_core_min) + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) + return tmp11 + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_min = ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_min.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // min-key + { + tmp0 := sym_min_DASH_key.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_k, sym_x), lang.NewVector(sym_k, sym_x, sym_y), lang.NewVector(sym_k, sym_x, sym_y, sym__AMP_, sym_more)), kw_doc, "Returns the x for which (k x), a number, is least.\n\n If there are multiple such xs, the last one is returned.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(5033), kw_end_DASH_line, int(5033))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + return v3 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp7 := lang.Apply(v2, []any{v3}) + tmp8 := lang.Apply(v2, []any{v4}) + tmp9 := lang.Apply(tmp6, []any{tmp7, tmp8}) + if lang.IsTruthy(tmp9) { + tmp5 = v3 + } else { + tmp5 = v4 + } + return tmp5 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "kx" + tmp7 := lang.Apply(v2, []any{v3}) + var v8 any = tmp7 + _ = v8 + // let binding "ky" + tmp9 := lang.Apply(v2, []any{v4}) + var v10 any = tmp9 + _ = v10 + // let binding "vec__749" + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp13 := lang.Apply(tmp12, []any{v8, v10}) + if lang.IsTruthy(tmp13) { + tmp14 := lang.NewVector(v3, v8) + tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5043), kw_column, int(31), kw_end_DASH_line, int(5043), kw_end_DASH_column, int(36)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp11 = tmp16 + } else { + tmp17 := lang.NewVector(v4, v10) + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5043), kw_column, int(38), kw_end_DASH_line, int(5043), kw_end_DASH_column, int(43)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp11 = tmp19 + } + var v20 any = tmp11 + _ = v20 + // let binding "v" + tmp21 := checkDerefVar(var_glojure_DOT_core_nth) + tmp22 := lang.Apply(tmp21, []any{v20, int64(0), nil}) + var v23 any = tmp22 + _ = v23 + // let binding "kv" + tmp24 := checkDerefVar(var_glojure_DOT_core_nth) + tmp25 := lang.Apply(tmp24, []any{v20, int64(1), nil}) + var v26 any = tmp25 + _ = v26 + var tmp27 any + { // let + // let binding "v" + var v28 any = v23 + _ = v28 + // let binding "kv" + var v29 any = v26 + _ = v29 + // let binding "more" + var v30 any = v5 + _ = v30 + for { + var tmp31 any + if lang.IsTruthy(v30) { + var tmp32 any + { // let + // let binding "w" + tmp33 := checkDerefVar(var_glojure_DOT_core_first) + tmp34 := lang.Apply(tmp33, []any{v30}) + var v35 any = tmp34 + _ = v35 + // let binding "kw" + tmp36 := lang.Apply(v2, []any{v35}) + var v37 any = tmp36 + _ = v37 + var tmp38 any + tmp39 := checkDerefVar(var_glojure_DOT_core__LT__EQ_) + tmp40 := lang.Apply(tmp39, []any{v37, v29}) + if lang.IsTruthy(tmp40) { + var tmp41 any = v35 + var tmp42 any = v37 + tmp44 := checkDerefVar(var_glojure_DOT_core_next) + tmp45 := lang.Apply(tmp44, []any{v30}) + var tmp43 any = tmp45 + v28 = tmp41 + v29 = tmp42 + v30 = tmp43 + continue + } else { + var tmp46 any = v28 + var tmp47 any = v29 + tmp49 := checkDerefVar(var_glojure_DOT_core_next) + tmp50 := lang.Apply(tmp49, []any{v30}) + var tmp48 any = tmp50 + v28 = tmp46 + v29 = tmp47 + v30 = tmp48 + continue + } + tmp32 = tmp38 + } // end let + tmp31 = tmp32 + } else { + tmp31 = v28 + } + tmp27 = tmp31 + break + } + } // end let + tmp6 = tmp27 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_min_DASH_key = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_min_DASH_key.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // mod + { + tmp0 := sym_mod.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_num, sym_div)), kw_doc, "Modulus of num and div. Truncates toward negative infinity.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(3567), kw_end_DASH_line, int(3567))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "m" + tmp5 := checkDerefVar(var_glojure_DOT_core_rem) + tmp6 := lang.Apply(tmp5, []any{v2, v3}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + var tmp9 any + { // let + // let binding "or__0__auto__" + tmp10 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) + tmp11 := lang.Apply(tmp10, []any{v7}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + tmp13 = v12 + } else { + tmp14 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp15 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp16 := lang.Apply(tmp15, []any{v2}) + tmp17 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp13 = tmp19 + } + tmp9 = tmp13 + } // end let + if lang.IsTruthy(tmp9) { + tmp8 = v7 + } else { + tmp10 := checkDerefVar(var_glojure_DOT_core__PLUS_) + tmp11 := lang.Apply(tmp10, []any{v7, v3}) + tmp8 = tmp11 + } + tmp4 = tmp8 + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_mod = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_mod.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // nary-inline + { + tmp0 := sym_nary_DASH_inline.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(948), kw_column, int(7), kw_end_DASH_line, int(948), kw_end_DASH_column, int(27), kw_arglists, lang.NewList(lang.NewVector(sym_op), lang.NewVector(sym_op, sym_unchecked_DASH_op)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_nary_DASH_inline) + tmp4 := lang.Apply(tmp3, []any{v2, v2}) + return tmp4 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v5 := args[0] + _ = v5 + var tmp6 any + { // let + // let binding "op" + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp8) { + tmp7 = v3 + } else { + tmp7 = v2 + } + var v9 any = tmp7 + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_seq) + tmp11 := checkDerefVar(var_glojure_DOT_core_concat) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym__DOT_}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := checkDerefVar(var_glojure_DOT_core_seq) + tmp18 := checkDerefVar(var_glojure_DOT_core_concat) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v9}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v5}) + tmp23 := lang.Apply(tmp18, []any{tmp20, tmp22}) + tmp24 := lang.Apply(tmp17, []any{tmp23}) + tmp25 := lang.Apply(tmp16, []any{tmp24}) + tmp26 := lang.Apply(tmp11, []any{tmp13, tmp15, tmp25}) + tmp27 := lang.Apply(tmp10, []any{tmp26}) + tmp6 = tmp27 + } // end let + return tmp6 + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + var tmp7 any + { // let + // let binding "op" + var tmp8 any + tmp9 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp9) { + tmp8 = v3 + } else { + tmp8 = v2 + } + var v10 any = tmp8 + _ = v10 + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym__DOT_}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{v10}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v5}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v6}) + tmp26 := lang.Apply(tmp19, []any{tmp21, tmp23, tmp25}) + tmp27 := lang.Apply(tmp18, []any{tmp26}) + tmp28 := lang.Apply(tmp17, []any{tmp27}) + tmp29 := lang.Apply(tmp12, []any{tmp14, tmp16, tmp28}) + tmp30 := lang.Apply(tmp11, []any{tmp29}) + tmp7 = tmp30 + } // end let + return tmp7 + default: + checkArity(args, 2) + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + var v7 any = lang.NewList(args[2:]...) + _ = v7 + var tmp8 any + { // let + // let binding "op" + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp10) { + tmp9 = v3 + } else { + tmp9 = v2 + } + var v11 any = tmp9 + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v14 := args[0] + _ = v14 + v15 := args[1] + _ = v15 + tmp16 := checkDerefVar(var_glojure_DOT_core_seq) + tmp17 := checkDerefVar(var_glojure_DOT_core_concat) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{sym__DOT_}) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := checkDerefVar(var_glojure_DOT_core_seq) + tmp24 := checkDerefVar(var_glojure_DOT_core_concat) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := lang.Apply(tmp25, []any{v11}) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{v14}) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{v15}) + tmp31 := lang.Apply(tmp24, []any{tmp26, tmp28, tmp30}) + tmp32 := lang.Apply(tmp23, []any{tmp31}) + tmp33 := lang.Apply(tmp22, []any{tmp32}) + tmp34 := lang.Apply(tmp17, []any{tmp19, tmp21, tmp33}) + tmp35 := lang.Apply(tmp16, []any{tmp34}) + return tmp35 + }) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp16 := checkDerefVar(var_glojure_DOT_core_seq) + tmp17 := checkDerefVar(var_glojure_DOT_core_concat) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{sym__DOT_}) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := checkDerefVar(var_glojure_DOT_core_seq) + tmp24 := checkDerefVar(var_glojure_DOT_core_concat) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := lang.Apply(tmp25, []any{v11}) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{v5}) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{v6}) + tmp31 := lang.Apply(tmp24, []any{tmp26, tmp28, tmp30}) + tmp32 := lang.Apply(tmp23, []any{tmp31}) + tmp33 := lang.Apply(tmp22, []any{tmp32}) + tmp34 := lang.Apply(tmp17, []any{tmp19, tmp21, tmp33}) + tmp35 := lang.Apply(tmp16, []any{tmp34}) + tmp36 := lang.Apply(tmp12, []any{tmp15, tmp35, v7}) + tmp8 = tmp36 + } // end let + return tmp8 + } + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_nary_DASH_inline = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_nary_DASH_inline.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // nat-int? + { + tmp0 := sym_nat_DASH_int_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a non-negative fixed precision integer", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(1415), kw_end_DASH_line, int(1415))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "and__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + tmp8 := checkDerefVar(var_glojure_DOT_core_not) + tmp9 := checkDerefVar(var_glojure_DOT_core_neg_QMARK_) + tmp10 := lang.Apply(tmp9, []any{v2}) + tmp11 := lang.Apply(tmp8, []any{tmp10}) + tmp7 = tmp11 + } else { + tmp7 = v6 + } + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_nat_DASH_int_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_nat_DASH_int_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // neg-int? + { + tmp0 := sym_neg_DASH_int_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a negative fixed precision integer", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(1409), kw_end_DASH_line, int(1409))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "and__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + tmp8 := checkDerefVar(var_glojure_DOT_core_neg_QMARK_) + tmp9 := lang.Apply(tmp8, []any{v2}) + tmp7 = tmp9 + } else { + tmp7 = v6 + } + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_neg_DASH_int_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_neg_DASH_int_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // not-any? + { + tmp1 := reflect.TypeOf(false) + tmp0 := sym_not_DASH_any_QMARK_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns false if (pred x) is logical true for any x in coll,\n else true.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(2), kw_line, int(2696), kw_end_DASH_line, int(2701))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp3 := lang.Apply(closed25, nil) + tmp4 := lang.Apply(closed24, []any{tmp3}) + return tmp4 + case 1: + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(closed25, []any{v3}) + tmp5 := lang.Apply(closed24, []any{tmp4}) + return tmp5 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(closed25, []any{v3, v4}) + tmp6 := lang.Apply(closed24, []any{tmp5}) + return tmp6 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6 := lang.Apply(closed25, []any{v3, v4, v5}) + tmp7 := lang.Apply(closed24, []any{tmp6}) + return tmp7 + default: + checkArity(args, 3) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_apply) + tmp8 := lang.Apply(tmp7, []any{closed25, v3, v4, v5, v6}) + tmp9 := lang.Apply(closed24, []any{tmp8}) + return tmp9 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2559), kw_column, int(6), kw_end_DASH_line, int(2564), kw_end_DASH_column, int(49))).(lang.FnFunc) + var_glojure_DOT_core_not_DASH_any_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_not_DASH_any_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // not-every? + { + tmp1 := reflect.TypeOf(false) + tmp0 := sym_not_DASH_every_QMARK_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns false if (pred x) is logical true for every x in\n coll, else true.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(2), kw_line, int(2677), kw_end_DASH_line, int(2682))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp3 := lang.Apply(closed26, nil) + tmp4 := lang.Apply(closed24, []any{tmp3}) + return tmp4 + case 1: + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(closed26, []any{v3}) + tmp5 := lang.Apply(closed24, []any{tmp4}) + return tmp5 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(closed26, []any{v3, v4}) + tmp6 := lang.Apply(closed24, []any{tmp5}) + return tmp6 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6 := lang.Apply(closed26, []any{v3, v4, v5}) + tmp7 := lang.Apply(closed24, []any{tmp6}) + return tmp7 + default: + checkArity(args, 3) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_apply) + tmp8 := lang.Apply(tmp7, []any{closed26, v3, v4, v5, v6}) + tmp9 := lang.Apply(closed24, []any{tmp8}) + return tmp9 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2559), kw_column, int(6), kw_end_DASH_line, int(2564), kw_end_DASH_column, int(49))).(lang.FnFunc) + var_glojure_DOT_core_not_DASH_every_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_not_DASH_every_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // not= + { + tmp1 := reflect.TypeOf(false) + tmp0 := sym_not_EQ_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_doc, "Same as (not (= obj1 obj2))", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(812), kw_end_DASH_line, int(812))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + return false + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_not) + tmp6 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp7 := lang.Apply(tmp6, []any{v3, v4}) + tmp8 := lang.Apply(tmp5, []any{tmp7}) + return tmp8 + default: + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_not) + tmp7 := checkDerefVar(var_glojure_DOT_core_apply) + tmp8 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp9 := lang.Apply(tmp7, []any{tmp8, v3, v4, v5}) + tmp10 := lang.Apply(tmp6, []any{tmp9}) + return tmp10 + } + }) + tmp3 := reflect.TypeOf(false) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_not_EQ_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_not_EQ_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ns-interns + { + tmp0 := sym_ns_DASH_interns.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns)), kw_doc, "Returns a map of the intern mappings for the namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4206), kw_end_DASH_line, int(4206))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "ns" + tmp4 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_filter_DASH_key) + tmp8 := checkDerefVar(var_glojure_DOT_core_val) + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v10 := args[0] + _ = v10 + var tmp11 any + { // let + // let binding "and__0__auto__" + tmp12 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp13 := reflect.TypeOf((*lang.Var)(nil)) + tmp14 := lang.Apply(tmp12, []any{tmp13, v10}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + if lang.IsTruthy(v15) { + tmp17 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp18, ok := lang.FieldOrMethod(v10, "Namespace") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v10, "Namespace"))) + } + var tmp19 any + switch reflect.TypeOf(tmp18).Kind() { + case reflect.Func: + tmp19 = lang.Apply(tmp18, nil) + default: + tmp19 = tmp18 + } + tmp20 := lang.Apply(tmp17, []any{v6, tmp19}) + tmp16 = tmp20 + } else { + tmp16 = v15 + } + tmp11 = tmp16 + } // end let + return tmp11 + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4212), kw_column, int(21), kw_end_DASH_line, int(4213), kw_end_DASH_column, int(56)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp12 := checkDerefVar(var_glojure_DOT_core_ns_DASH_map) + tmp13 := lang.Apply(tmp12, []any{v6}) + tmp14 := lang.Apply(tmp7, []any{tmp8, tmp11, tmp13}) + tmp3 = tmp14 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ns_DASH_interns = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ns_DASH_interns.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ns-publics + { + tmp0 := sym_ns_DASH_publics.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns)), kw_doc, "Returns a map of the public intern mappings for the namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4188), kw_end_DASH_line, int(4188))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "ns" + tmp4 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_filter_DASH_key) + tmp8 := checkDerefVar(var_glojure_DOT_core_val) + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v10 := args[0] + _ = v10 + var tmp11 any + { // let + // let binding "and__0__auto__" + tmp12 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp13 := reflect.TypeOf((*lang.Var)(nil)) + tmp14 := lang.Apply(tmp12, []any{tmp13, v10}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + if lang.IsTruthy(v15) { + var tmp17 any + { // let + // let binding "and__0__auto__" + tmp18 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp19, ok := lang.FieldOrMethod(v10, "Namespace") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v10, "Namespace"))) + } + var tmp20 any + switch reflect.TypeOf(tmp19).Kind() { + case reflect.Func: + tmp20 = lang.Apply(tmp19, nil) + default: + tmp20 = tmp19 + } + tmp21 := lang.Apply(tmp18, []any{v6, tmp20}) + var v22 any = tmp21 + _ = v22 + var tmp23 any + if lang.IsTruthy(v22) { + tmp24, ok := lang.FieldOrMethod(v10, "IsPublic") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v10, "IsPublic"))) + } + var tmp25 any + switch reflect.TypeOf(tmp24).Kind() { + case reflect.Func: + tmp25 = lang.Apply(tmp24, nil) + default: + tmp25 = tmp24 + } + tmp23 = tmp25 + } else { + tmp23 = v22 + } + tmp17 = tmp23 + } // end let + tmp16 = tmp17 + } else { + tmp16 = v15 + } + tmp11 = tmp16 + } // end let + return tmp11 + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4194), kw_column, int(21), kw_end_DASH_line, int(4196), kw_end_DASH_column, int(48)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp12 := checkDerefVar(var_glojure_DOT_core_ns_DASH_map) + tmp13 := lang.Apply(tmp12, []any{v6}) + tmp14 := lang.Apply(tmp7, []any{tmp8, tmp11, tmp13}) + tmp3 = tmp14 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ns_DASH_publics = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ns_DASH_publics.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ns-refers + { + tmp0 := sym_ns_DASH_refers.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns)), kw_doc, "Returns a map of the refer mappings for the namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(4253), kw_end_DASH_line, int(4253))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "ns" + tmp4 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_filter_DASH_key) + tmp8 := checkDerefVar(var_glojure_DOT_core_val) + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v10 := args[0] + _ = v10 + var tmp11 any + { // let + // let binding "and__0__auto__" + tmp12 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp13 := reflect.TypeOf((*lang.Var)(nil)) + tmp14 := lang.Apply(tmp12, []any{tmp13, v10}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + if lang.IsTruthy(v15) { + tmp17 := checkDerefVar(var_glojure_DOT_core_not_EQ_) + tmp18, ok := lang.FieldOrMethod(v10, "Namespace") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v10, "Namespace"))) + } + var tmp19 any + switch reflect.TypeOf(tmp18).Kind() { + case reflect.Func: + tmp19 = lang.Apply(tmp18, nil) + default: + tmp19 = tmp18 + } + tmp20 := lang.Apply(tmp17, []any{v6, tmp19}) + tmp16 = tmp20 + } else { + tmp16 = v15 + } + tmp11 = tmp16 + } // end let + return tmp11 + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4259), kw_column, int(21), kw_end_DASH_line, int(4260), kw_end_DASH_column, int(59)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp12 := checkDerefVar(var_glojure_DOT_core_ns_DASH_map) + tmp13 := lang.Apply(tmp12, []any{v6}) + tmp14 := lang.Apply(tmp7, []any{tmp8, tmp11, tmp13}) + tmp3 = tmp14 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ns_DASH_refers = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ns_DASH_refers.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // nthnext + { + tmp0 := sym_nthnext.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll, sym_n)), kw_doc, "Returns the nth next of coll, (seq coll) when n is 0.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(3147), kw_end_DASH_line, int(3147))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp6 := reflect.TypeOf((*lang.IDrop)(nil)).Elem() + tmp7 := lang.Apply(tmp5, []any{tmp6, v2}) + if lang.IsTruthy(tmp7) { + var tmp8 any + tmp9 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp10 := lang.Apply(tmp9, []any{v3}) + if lang.IsTruthy(tmp10) { + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) + tmp13 := lang.Apply(tmp12, []any{v3}) + if lang.IsTruthy(tmp13) { + tmp11 = v3 + } else { + tmp14 := lang.Apply(nil, []any{v3}) + tmp11 = tmp14 + } + tmp15, _ := lang.FieldOrMethod(v2, "drop") + if reflect.TypeOf(tmp15).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("drop is not a function"))) + } + tmp16 := lang.Apply(tmp15, []any{tmp11}) + tmp8 = tmp16 + } else { + tmp17 := checkDerefVar(var_glojure_DOT_core_seq) + tmp18 := lang.Apply(tmp17, []any{v2}) + tmp8 = tmp18 + } + tmp4 = tmp8 + } else { + var tmp19 any + { // let + // let binding "n" + var v20 any = v3 + _ = v20 + // let binding "xs" + tmp21 := checkDerefVar(var_glojure_DOT_core_seq) + tmp22 := lang.Apply(tmp21, []any{v2}) + var v23 any = tmp22 + _ = v23 + for { + var tmp24 any + var tmp25 any + { // let + // let binding "and__0__auto__" + var v26 any = v23 + _ = v26 + var tmp27 any + if lang.IsTruthy(v26) { + tmp28 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp29 := lang.Apply(tmp28, []any{v20}) + tmp27 = tmp29 + } else { + tmp27 = v26 + } + tmp25 = tmp27 + } // end let + if lang.IsTruthy(tmp25) { + tmp27 := checkDerefVar(var_glojure_DOT_core_dec) + tmp28 := lang.Apply(tmp27, []any{v20}) + var tmp26 any = tmp28 + tmp30 := checkDerefVar(var_glojure_DOT_core_next) + tmp31 := lang.Apply(tmp30, []any{v23}) + var tmp29 any = tmp31 + v20 = tmp26 + v23 = tmp29 + continue + } else { + tmp24 = v23 + } + tmp19 = tmp24 + break + } + } // end let + tmp4 = tmp19 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_nthnext = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_nthnext.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // nthrest + { + tmp0 := sym_nthrest.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll, sym_n)), kw_doc, "Returns the nth rest of coll, coll when n is 0.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(3161), kw_end_DASH_line, int(3161))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + var tmp7 any + { // let + // let binding "or__0__auto__" + var tmp8 any + tmp9 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp10 := reflect.TypeOf((*lang.IDrop)(nil)).Elem() + tmp11 := lang.Apply(tmp9, []any{tmp10, v2}) + if lang.IsTruthy(tmp11) { + var tmp12 any + tmp13 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) + tmp14 := lang.Apply(tmp13, []any{v3}) + if lang.IsTruthy(tmp14) { + tmp12 = v3 + } else { + tmp15 := lang.Apply(nil, []any{v3}) + tmp12 = tmp15 + } + tmp16, _ := lang.FieldOrMethod(v2, "drop") + if reflect.TypeOf(tmp16).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("drop is not a function"))) + } + tmp17 := lang.Apply(tmp16, []any{tmp12}) + tmp8 = tmp17 + } else { + var tmp18 any + { // let + // let binding "n" + var v19 any = v3 + _ = v19 + // let binding "xs" + var v20 any = v2 + _ = v20 + for { + var tmp21 any + { // let + // let binding "temp__0__auto__" + var tmp22 any + { // let + // let binding "and__0__auto__" + tmp23 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp24 := lang.Apply(tmp23, []any{v19}) + var v25 any = tmp24 + _ = v25 + var tmp26 any + if lang.IsTruthy(v25) { + tmp27 := checkDerefVar(var_glojure_DOT_core_seq) + tmp28 := lang.Apply(tmp27, []any{v20}) + tmp26 = tmp28 + } else { + tmp26 = v25 + } + tmp22 = tmp26 + } // end let + var v23 any = tmp22 + _ = v23 + var tmp24 any + if lang.IsTruthy(v23) { + var tmp25 any + { // let + // let binding "xs" + var v26 any = v23 + _ = v26 + tmp28 := checkDerefVar(var_glojure_DOT_core_dec) + tmp29 := lang.Apply(tmp28, []any{v19}) + var tmp27 any = tmp29 + tmp31 := checkDerefVar(var_glojure_DOT_core_rest) + tmp32 := lang.Apply(tmp31, []any{v26}) + var tmp30 any = tmp32 + v19 = tmp27 + v20 = tmp30 + continue + } // end let + tmp24 = tmp25 + } else { + tmp26 := checkDerefVar(var_glojure_DOT_core_seq) + tmp27 := lang.Apply(tmp26, []any{v20}) + tmp24 = tmp27 + } + tmp21 = tmp24 + } // end let + tmp18 = tmp21 + break + } + } // end let + tmp8 = tmp18 + } + var v19 any = tmp8 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + tmp20 = v19 + } else { + tmp20 = lang.NewList() + } + tmp7 = tmp20 + } // end let + tmp4 = tmp7 + } else { + tmp4 = v2 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_nthrest = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_nthrest.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // odd? + { + tmp0 := sym_odd_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_doc, "Returns true if n is odd, throws an exception if n is not an integer", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1389), kw_end_DASH_line, int(1389))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_not) + tmp4 := checkDerefVar(var_glojure_DOT_core_even_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + tmp6 := lang.Apply(tmp3, []any{tmp5}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_odd_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_odd_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // or + { + tmp0 := sym_or.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_x), lang.NewVector(sym_x, sym__AMP_, sym_next)), kw_doc, "Evaluates exprs one at a time, from left to right. If a form\n returns a logical true value, or returns that value and doesn't\n evaluate any of the other expressions, otherwise it returns the\n value of the last expression. (or) returns nil.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(11), kw_line, int(847), kw_end_DASH_line, int(847))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + return nil + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + return v4 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_let}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + tmp12 := checkDerefVar(var_glojure_DOT_core_vector) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_or__0__auto__}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v4}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp19}) + tmp21 := lang.Apply(tmp11, []any{tmp12, tmp20}) + tmp22 := lang.Apply(tmp10, []any{tmp21}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_seq) + tmp25 := checkDerefVar(var_glojure_DOT_core_concat) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{sym_if}) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := lang.Apply(tmp28, []any{sym_or__0__auto__}) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := lang.Apply(tmp30, []any{sym_or__0__auto__}) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := checkDerefVar(var_glojure_DOT_core_seq) + tmp34 := checkDerefVar(var_glojure_DOT_core_concat) + tmp35 := checkDerefVar(var_glojure_DOT_core_list) + tmp36 := lang.Apply(tmp35, []any{sym_glojure_DOT_core_SLASH_or}) + tmp37 := lang.Apply(tmp34, []any{tmp36, v5}) + tmp38 := lang.Apply(tmp33, []any{tmp37}) + tmp39 := lang.Apply(tmp32, []any{tmp38}) + tmp40 := lang.Apply(tmp25, []any{tmp27, tmp29, tmp31, tmp39}) + tmp41 := lang.Apply(tmp24, []any{tmp40}) + tmp42 := lang.Apply(tmp23, []any{tmp41}) + tmp43 := lang.Apply(tmp7, []any{tmp9, tmp22, tmp42}) + tmp44 := lang.Apply(tmp6, []any{tmp43}) + return tmp44 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_or = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_or.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // parents + { + tmp0 := sym_parents.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_tag), lang.NewVector(sym_h, sym_tag)), kw_doc, "Returns the immediate parents of tag, either via a Java type\n inheritance relationship or a relationship established via derive. h\n must be a hierarchy obtained from make-hierarchy, if not supplied\n defaults to the global hierarchy", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(5564), kw_end_DASH_line, int(5564))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_parents) + tmp4 := checkDerefVar(var_glojure_DOT_core_global_DASH_hierarchy) + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_not_DASH_empty) + var tmp5 any + { // let + // let binding "tp" + tmp6 := checkDerefVar(var_glojure_DOT_core_get) + tmp7 := lang.Apply(kw_parents, []any{v2}) + tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + tmp11 := checkDerefVar(var_glojure_DOT_core_class_QMARK_) + tmp12 := lang.Apply(tmp11, []any{v3}) + if lang.IsTruthy(tmp12) { + tmp13 := checkDerefVar(var_glojure_DOT_core_into1) + tmp14 := checkDerefVar(var_glojure_DOT_core_set) + tmp15 := checkDerefVar(var_glojure_DOT_core_bases) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp14, []any{tmp16}) + tmp18 := lang.Apply(tmp13, []any{tmp17, v9}) + tmp10 = tmp18 + } else { + tmp10 = v9 + } + tmp5 = tmp10 + } // end let + tmp6 := lang.Apply(tmp4, []any{tmp5}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_parents = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_parents.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // parse-boolean + { + tmp0 := sym_parse_DASH_boolean.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_doc, "Parse strings \"true\" or \"false\" and return a boolean, or nil if invalid", kw_file, "glojure/core.glj", kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(7957), kw_end_DASH_line, int(7957))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + var tmp6 any + { // let + // let binding "G__1017" + var v7 any = v2 + _ = v7 + } // end let + tmp3 = tmp6 + } else { + tmp7 := checkDerefVar(var_glojure_DOT_core_parsing_DASH_err) + tmp8 := lang.Apply(tmp7, []any{v2}) + tmp9 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp8}) + panic(tmp9) + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_parse_DASH_boolean = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_parse_DASH_boolean.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // parse-double + { + tmp0 := sym_parse_DASH_double.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_doc, "Parse string with floating point components and return a Double value,\n or nil if parse fails.\n\n Grammar: https://docs.oracle.com/javase/8/docs/api/java/lang/Double.html#valueOf-java.lang.String-", kw_file, "glojure/core.glj", kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(7935), kw_end_DASH_line, int(7935))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + var tmp6 any + { // let + // let binding "result__3649__auto__" + tmp7 := lang.Apply(strconv9.ParseFloat, []any{v2, int64(64)}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + tmp10 := lang.Apply(v8, []any{int64(1)}) + if lang.IsTruthy(tmp10) { + } else { + tmp11 := lang.Apply(v8, []any{int64(0)}) + tmp9 = tmp11 + } + tmp6 = tmp9 + } // end let + tmp3 = tmp6 + } else { + tmp7 := checkDerefVar(var_glojure_DOT_core_parsing_DASH_err) + tmp8 := lang.Apply(tmp7, []any{v2}) + tmp9 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp8}) + panic(tmp9) + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_parse_DASH_double = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_parse_DASH_double.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // parse-long + { + tmp0 := sym_parse_DASH_long.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_doc, "Parse string of decimal digits with optional leading -/+ and return a\n Long value, or nil if parse fails", kw_file, "glojure/core.glj", kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(7926), kw_end_DASH_line, int(7926))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + var tmp6 any + { // let + // let binding "result__3648__auto__" + tmp7 := lang.Apply(strconv9.ParseInt, []any{v2, int64(10), int64(64)}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + tmp10 := lang.Apply(v8, []any{int64(1)}) + if lang.IsTruthy(tmp10) { + } else { + tmp11 := lang.Apply(v8, []any{int64(0)}) + tmp9 = tmp11 + } + tmp6 = tmp9 + } // end let + tmp3 = tmp6 + } else { + tmp7 := checkDerefVar(var_glojure_DOT_core_parsing_DASH_err) + tmp8 := lang.Apply(tmp7, []any{v2}) + tmp9 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp8}) + panic(tmp9) + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_parse_DASH_long = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_parse_DASH_long.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // partial + { + tmp0 := sym_partial.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_arg1), lang.NewVector(sym_f, sym_arg1, sym_arg2), lang.NewVector(sym_f, sym_arg1, sym_arg2, sym_arg3), lang.NewVector(sym_f, sym_arg1, sym_arg2, sym_arg3, sym__AMP_, sym_more)), kw_doc, "Takes a function f and fewer than the normal arguments to f, and\n returns a fn that takes a variable number of additional args. When\n called, the returned function calls f with args + additional args.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(2606), kw_end_DASH_line, int(2606))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + return v2 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp5 := lang.Apply(v2, []any{v3}) + return tmp5 + case 1: + v5 := args[0] + _ = v5 + tmp6 := lang.Apply(v2, []any{v3, v5}) + return tmp6 + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + tmp7 := lang.Apply(v2, []any{v3, v5, v6}) + return tmp7 + case 3: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := args[2] + _ = v7 + tmp8 := lang.Apply(v2, []any{v3, v5, v6, v7}) + return tmp8 + default: + checkArity(args, 3) + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := args[2] + _ = v7 + var v8 any = lang.NewList(args[3:]...) + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_apply) + tmp10 := lang.Apply(tmp9, []any{v2, v3, v5, v6, v7, v8}) + return tmp10 + } + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2614), kw_column, int(4), kw_end_DASH_line, int(2619), kw_end_DASH_column, int(48)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp6 := lang.Apply(v2, []any{v3, v4}) + return tmp6 + case 1: + v6 := args[0] + _ = v6 + tmp7 := lang.Apply(v2, []any{v3, v4, v6}) + return tmp7 + case 2: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + tmp8 := lang.Apply(v2, []any{v3, v4, v6, v7}) + return tmp8 + case 3: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + tmp9 := lang.Apply(v2, []any{v3, v4, v6, v7, v8}) + return tmp9 + default: + checkArity(args, 3) + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + var v9 any = lang.NewList(args[3:]...) + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_apply) + tmp11 := lang.Apply(tmp10, []any{v2, v3, v4, v6, v7, v8, v9}) + return tmp11 + } + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2621), kw_column, int(4), kw_end_DASH_line, int(2626), kw_end_DASH_column, int(53)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp7 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp7 := lang.Apply(v2, []any{v3, v4, v5}) + return tmp7 + case 1: + v7 := args[0] + _ = v7 + tmp8 := lang.Apply(v2, []any{v3, v4, v5, v7}) + return tmp8 + case 2: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + tmp9 := lang.Apply(v2, []any{v3, v4, v5, v7, v8}) + return tmp9 + case 3: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + tmp10 := lang.Apply(v2, []any{v3, v4, v5, v7, v8, v9}) + return tmp10 + default: + checkArity(args, 3) + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + var v10 any = lang.NewList(args[3:]...) + _ = v10 + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + tmp12 := lang.Apply(tmp11, []any{v2, v3, v4, v5, v7, v8, v9, v10}) + return tmp12 + } + }) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2628), kw_column, int(4), kw_end_DASH_line, int(2633), kw_end_DASH_column, int(58)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp8 + default: + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var v6 any = lang.NewList(args[4:]...) + _ = v6 + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v8 any = lang.NewList(args[0:]...) + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_apply) + tmp10 := checkDerefVar(var_glojure_DOT_core_concat) + tmp11 := lang.Apply(tmp10, []any{v6, v8}) + tmp12 := lang.Apply(tmp9, []any{v2, v3, v4, v5, tmp11}) + return tmp12 + } + }) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2635), kw_column, int(4), kw_end_DASH_line, int(2635), kw_end_DASH_column, int(60)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp9 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_partial = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_partial.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // partition-by + { + tmp0 := sym_partition_DASH_by.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_coll)), kw_doc, "Applies f to each value in coll, splitting it each time f returns a\n new value. Returns a lazy seq of partitions. Returns a stateful\n transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(7142), kw_end_DASH_line, int(7142))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 any + { // let + // let binding "a" + var v6 any = "unimplemented: new with non-constant class type" + _ = v6 + // let binding "pv" + tmp7 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) + tmp8 := lang.Apply(tmp7, []any{kw_glojure_DOT_core_SLASH_none}) + var v9 any = tmp8 + _ = v9 + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp11 := lang.Apply(v4, nil) + return tmp11 + case 1: + v11 := args[0] + _ = v11 + var tmp12 any + { // let + // let binding "result" + var tmp13 any + tmp14, ok := lang.FieldOrMethod(v6, "isEmpty") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "isEmpty"))) + } + var tmp15 any + switch reflect.TypeOf(tmp14).Kind() { + case reflect.Func: + tmp15 = lang.Apply(tmp14, nil) + default: + tmp15 = tmp14 + } + if lang.IsTruthy(tmp15) { + tmp13 = v11 + } else { + var tmp16 any + { // let + // let binding "v" + tmp17 := checkDerefVar(var_glojure_DOT_core_vec) + tmp18, ok := lang.FieldOrMethod(v6, "toArray") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "toArray"))) + } + var tmp19 any + switch reflect.TypeOf(tmp18).Kind() { + case reflect.Func: + tmp19 = lang.Apply(tmp18, nil) + default: + tmp19 = tmp18 + } + tmp20 := lang.Apply(tmp17, []any{tmp19}) + var v21 any = tmp20 + _ = v21 + tmp22, ok := lang.FieldOrMethod(v6, "clear") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "clear"))) + } + var tmp23 any + switch reflect.TypeOf(tmp22).Kind() { + case reflect.Func: + tmp23 = lang.Apply(tmp22, nil) + default: + tmp23 = tmp22 + } + _ = tmp23 + tmp24 := checkDerefVar(var_glojure_DOT_core_unreduced) + tmp25 := lang.Apply(v4, []any{v11, v21}) + tmp26 := lang.Apply(tmp24, []any{tmp25}) + tmp16 = tmp26 + } // end let + tmp13 = tmp16 + } + var v17 any = tmp13 + _ = v17 + tmp18 := lang.Apply(v4, []any{v17}) + tmp12 = tmp18 + } // end let + return tmp12 + case 2: + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + var tmp13 any + { // let + // let binding "pval" + tmp14 := checkDerefVar(var_glojure_DOT_core_deref) + tmp15 := lang.Apply(tmp14, []any{v9}) + var v16 any = tmp15 + _ = v16 + // let binding "val" + tmp17 := lang.Apply(v2, []any{v12}) + var v18 any = tmp17 + _ = v18 + tmp19 := checkDerefVar(var_glojure_DOT_core_vreset_BANG_) + tmp20 := lang.Apply(tmp19, []any{v9, v18}) + _ = tmp20 + var tmp21 any + var tmp22 any + { // let + // let binding "or__0__auto__" + tmp23 := checkDerefVar(var_glojure_DOT_core_identical_QMARK_) + tmp24 := lang.Apply(tmp23, []any{v16, kw_glojure_DOT_core_SLASH_none}) + var v25 any = tmp24 + _ = v25 + var tmp26 any + if lang.IsTruthy(v25) { + tmp26 = v25 + } else { + tmp27 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp28 := lang.Apply(tmp27, []any{v18, v16}) + tmp26 = tmp28 + } + tmp22 = tmp26 + } // end let + if lang.IsTruthy(tmp22) { + tmp23, _ := lang.FieldOrMethod(v6, "add") + if reflect.TypeOf(tmp23).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) + } + tmp24 := lang.Apply(tmp23, []any{v12}) + _ = tmp24 + tmp21 = v11 + } else { + var tmp25 any + { // let + // let binding "v" + tmp26 := checkDerefVar(var_glojure_DOT_core_vec) + tmp27, ok := lang.FieldOrMethod(v6, "toArray") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "toArray"))) + } + var tmp28 any + switch reflect.TypeOf(tmp27).Kind() { + case reflect.Func: + tmp28 = lang.Apply(tmp27, nil) + default: + tmp28 = tmp27 + } + tmp29 := lang.Apply(tmp26, []any{tmp28}) + var v30 any = tmp29 + _ = v30 + tmp31, ok := lang.FieldOrMethod(v6, "clear") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "clear"))) + } + var tmp32 any + switch reflect.TypeOf(tmp31).Kind() { + case reflect.Func: + tmp32 = lang.Apply(tmp31, nil) + default: + tmp32 = tmp31 + } + _ = tmp32 + var tmp33 any + { // let + // let binding "ret" + tmp34 := lang.Apply(v4, []any{v11, v30}) + var v35 any = tmp34 + _ = v35 + var tmp36 any + tmp37 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) + tmp38 := lang.Apply(tmp37, []any{v35}) + if lang.IsTruthy(tmp38) { + } else { + tmp39, _ := lang.FieldOrMethod(v6, "add") + if reflect.TypeOf(tmp39).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) + } + tmp40 := lang.Apply(tmp39, []any{v12}) + tmp36 = tmp40 + } + _ = tmp36 + tmp33 = v35 + } // end let + tmp25 = tmp33 + } // end let + tmp21 = tmp25 + } + tmp13 = tmp21 + } // end let + return tmp13 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7152), kw_column, int(7), kw_end_DASH_line, int(7176), kw_end_DASH_column, int(28)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp5 = tmp12 + } // end let + return tmp5 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7149), kw_column, int(3), kw_end_DASH_line, int(7176), kw_end_DASH_column, int(30)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp5 any + { // let + // let binding "temp__0__auto__" + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := lang.Apply(tmp6, []any{v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + var tmp10 any + { // let + // let binding "s" + var v11 any = v8 + _ = v11 + var tmp12 any + { // let + // let binding "fst" + tmp13 := checkDerefVar(var_glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v11}) + var v15 any = tmp14 + _ = v15 + // let binding "fv" + tmp16 := lang.Apply(v2, []any{v15}) + var v17 any = tmp16 + _ = v17 + // let binding "run" + tmp18 := checkDerefVar(var_glojure_DOT_core_cons) + tmp19 := checkDerefVar(var_glojure_DOT_core_take_DASH_while) + var tmp20 lang.FnFunc + tmp20 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v21 := args[0] + _ = v21 + tmp22 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp23 := lang.Apply(v2, []any{v21}) + tmp24 := lang.Apply(tmp22, []any{v17, tmp23}) + return tmp24 + }) + tmp21 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7182), kw_column, int(41), kw_end_DASH_line, int(7182), kw_end_DASH_column, int(53)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp23 := checkDerefVar(var_glojure_DOT_core_next) + tmp24 := lang.Apply(tmp23, []any{v11}) + tmp25 := lang.Apply(tmp19, []any{tmp22, tmp24}) + tmp26 := lang.Apply(tmp18, []any{v15, tmp25}) + var v27 any = tmp26 + _ = v27 + tmp28 := checkDerefVar(var_glojure_DOT_core_cons) + tmp29 := checkDerefVar(var_glojure_DOT_core_partition_DASH_by) + var tmp30 lang.FnFunc + tmp30 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp31 := checkDerefVar(var_glojure_DOT_core_drop) + tmp32 := checkDerefVar(var_glojure_DOT_core_count) + tmp33 := lang.Apply(tmp32, []any{v27}) + tmp34 := lang.Apply(tmp31, []any{tmp33, v11}) + return tmp34 + }) + tmp31 := lang.Apply(lang.NewLazySeq, []any{tmp30}) + tmp32 := lang.Apply(tmp29, []any{v2, tmp31}) + tmp33 := lang.Apply(tmp28, []any{v27, tmp32}) + tmp12 = tmp33 + } // end let + tmp10 = tmp12 + } // end let + tmp9 = tmp10 + } else { + } + tmp5 = tmp9 + } // end let + return tmp5 + }) + tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_partition_DASH_by = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_partition_DASH_by.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // pmap + { + tmp0 := sym_pmap.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_coll), lang.NewVector(sym_f, sym_coll, sym__AMP_, sym_colls)), kw_doc, "Like map, except f is applied in parallel. Semi-lazy in that the\n parallel computation stays ahead of the consumption, but doesn't\n realize the entire result unless required. Only useful for\n computationally intensive functions where the time of f dominates\n the coordination overhead.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(7031), kw_end_DASH_line, int(7031))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "n" + tmp5 := checkDerefVar(var_glojure_DOT_core__PLUS_) + tmp6 := lang.Apply(runtime11.NumCPU, nil) + tmp7 := lang.Apply(tmp5, []any{int64(2), tmp6}) + var v8 any = tmp7 + _ = v8 + // let binding "rets" + tmp9 := checkDerefVar(var_glojure_DOT_core_map) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v11 := args[0] + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_future_DASH_call) + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp14 := lang.Apply(v2, []any{v11}) + return tmp14 + }) + tmp14 := lang.Apply(tmp12, []any{tmp13}) + return tmp14 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7041), kw_column, int(20), kw_end_DASH_line, int(7041), kw_end_DASH_column, int(34)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := lang.Apply(tmp9, []any{tmp12, v3}) + var v14 any = tmp13 + _ = v14 + // let binding "step" + var tmp15 lang.FnFunc + { // function step + var v16 lang.FnFunc + tmp15 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v17 := args[0] + _ = v17 + v18 := args[1] + _ = v18 + var tmp19 any + { // let + // let binding "vec__987" + var v20 any = v17 + _ = v20 + // let binding "seq__988" + tmp21 := checkDerefVar(var_glojure_DOT_core_seq) + tmp22 := lang.Apply(tmp21, []any{v20}) + var v23 any = tmp22 + _ = v23 + // let binding "first__989" + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v23}) + var v26 any = tmp25 + _ = v26 + // let binding "seq__988" + tmp27 := checkDerefVar(var_glojure_DOT_core_next) + tmp28 := lang.Apply(tmp27, []any{v23}) + var v29 any = tmp28 + _ = v29 + // let binding "x" + var v30 any = v26 + _ = v30 + // let binding "xs" + var v31 any = v29 + _ = v31 + // let binding "vs" + var v32 any = v20 + _ = v32 + var tmp33 lang.FnFunc + tmp33 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp34 any + { // let + // let binding "temp__0__auto__" + tmp35 := checkDerefVar(var_glojure_DOT_core_seq) + tmp36 := lang.Apply(tmp35, []any{v18}) + var v37 any = tmp36 + _ = v37 + var tmp38 any + if lang.IsTruthy(v37) { + var tmp39 any + { // let + // let binding "s" + var v40 any = v37 + _ = v40 + tmp41 := checkDerefVar(var_glojure_DOT_core_cons) + tmp42 := checkDerefVar(var_glojure_DOT_core_deref) + tmp43 := lang.Apply(tmp42, []any{v30}) + tmp44 := checkDerefVar(var_glojure_DOT_core_rest) + tmp45 := lang.Apply(tmp44, []any{v40}) + tmp46 := lang.Apply(v16, []any{v31, tmp45}) + tmp47 := lang.Apply(tmp41, []any{tmp43, tmp46}) + tmp39 = tmp47 + } // end let + tmp38 = tmp39 + } else { + tmp40 := checkDerefVar(var_glojure_DOT_core_map) + tmp41 := checkDerefVar(var_glojure_DOT_core_deref) + tmp42 := lang.Apply(tmp40, []any{tmp41, v32}) + tmp38 = tmp42 + } + tmp34 = tmp38 + } // end let + return tmp34 + }) + tmp34 := lang.Apply(lang.NewLazySeq, []any{tmp33}) + tmp19 = tmp34 + } // end let + return tmp19 + }) + v16 = tmp15 + _ = v16 + } + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7042), kw_column, int(15), kw_end_DASH_line, int(7046), kw_end_DASH_column, int(36)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v18 any = tmp17 + _ = v18 + tmp19 := checkDerefVar(var_glojure_DOT_core_drop) + tmp20 := lang.Apply(tmp19, []any{v8, v14}) + tmp21 := lang.Apply(v18, []any{v14, tmp20}) + tmp4 = tmp21 + } // end let + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "step" + var tmp6 lang.FnFunc + { // function step + var v7 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v8 := args[0] + _ = v8 + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp10 any + { // let + // let binding "ss" + tmp11 := checkDerefVar(var_glojure_DOT_core_map) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := lang.Apply(tmp11, []any{tmp12, v8}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + tmp16 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + tmp17 := checkDerefVar(var_glojure_DOT_core_identity) + tmp18 := lang.Apply(tmp16, []any{tmp17, v14}) + if lang.IsTruthy(tmp18) { + tmp19 := checkDerefVar(var_glojure_DOT_core_cons) + tmp20 := checkDerefVar(var_glojure_DOT_core_map) + tmp21 := checkDerefVar(var_glojure_DOT_core_first) + tmp22 := lang.Apply(tmp20, []any{tmp21, v14}) + tmp23 := checkDerefVar(var_glojure_DOT_core_map) + tmp24 := checkDerefVar(var_glojure_DOT_core_rest) + tmp25 := lang.Apply(tmp23, []any{tmp24, v14}) + tmp26 := lang.Apply(v7, []any{tmp25}) + tmp27 := lang.Apply(tmp19, []any{tmp22, tmp26}) + tmp15 = tmp27 + } else { + } + tmp10 = tmp15 + } // end let + return tmp10 + }) + tmp10 := lang.Apply(lang.NewLazySeq, []any{tmp9}) + return tmp10 + }) + v7 = tmp6 + _ = v7 + } + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7049), kw_column, int(15), kw_end_DASH_line, int(7053), kw_end_DASH_column, int(67)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v9 any = tmp8 + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_pmap) + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v12 := args[0] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_apply) + tmp14 := lang.Apply(tmp13, []any{v2, v12}) + return tmp14 + }) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7054), kw_column, int(12), kw_end_DASH_line, int(7054), kw_end_DASH_column, int(23)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp14 := checkDerefVar(var_glojure_DOT_core_cons) + tmp15 := lang.Apply(tmp14, []any{v3, v4}) + tmp16 := lang.Apply(v9, []any{tmp15}) + tmp17 := lang.Apply(tmp10, []any{tmp13, tmp16}) + tmp5 = tmp17 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_pmap = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_pmap.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // pos-int? + { + tmp0 := sym_pos_DASH_int_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a positive fixed precision integer", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(1403), kw_end_DASH_line, int(1403))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "and__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + tmp8 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp9 := lang.Apply(tmp8, []any{v2}) + tmp7 = tmp9 + } else { + tmp7 = v6 + } + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_pos_DASH_int_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_pos_DASH_int_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // preserving-reduced + { + tmp0 := sym_preserving_DASH_reduced.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(7638), kw_column, int(7), kw_end_DASH_line, int(7638), kw_end_DASH_column, int(34), kw_arglists, lang.NewList(lang.NewVector(sym_rf)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var tmp6 any + { // let + // let binding "ret" + tmp7 := lang.Apply(v2, []any{v4, v5}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) + tmp11 := lang.Apply(tmp10, []any{v8}) + if lang.IsTruthy(tmp11) { + tmp12 := checkDerefVar(var_glojure_DOT_core_reduced) + tmp13 := lang.Apply(tmp12, []any{v8}) + tmp9 = tmp13 + } else { + tmp9 = v8 + } + tmp6 = tmp9 + } // end let + return tmp6 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7640), kw_column, int(3), kw_end_DASH_line, int(7643), kw_end_DASH_column, int(12)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_preserving_DASH_reduced = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_preserving_DASH_reduced.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print-sequential + { + tmp0 := sym_print_DASH_sequential.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(46), kw_column, int(8), kw_end_DASH_line, int(46), kw_end_DASH_column, int(23), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_begin, sym_print_DASH_one, sym_sep, sym_end, sym_sequence, sym_w)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 6) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + v7 := args[5] + _ = v7 + var tmp8 any + { // let + tmp9 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp10 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp11 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_print_DASH_level_STAR_) + var tmp12 any + { // let + // let binding "and__0__auto__" + tmp13 := checkDerefVar(var_glojure_DOT_core_not) + tmp14 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_dup_STAR_) + tmp15 := lang.Apply(tmp13, []any{tmp14}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + if lang.IsTruthy(v16) { + var tmp18 any + { // let + // let binding "and__0__auto__" + tmp19 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_level_STAR_) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + tmp22 := checkDerefVar(var_glojure_DOT_core_dec) + tmp23 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_level_STAR_) + tmp24 := lang.Apply(tmp22, []any{tmp23}) + tmp21 = tmp24 + } else { + tmp21 = v20 + } + tmp18 = tmp21 + } // end let + tmp17 = tmp18 + } else { + tmp17 = v16 + } + tmp12 = tmp17 + } // end let + tmp13 := lang.Apply(tmp10, []any{tmp11, tmp12}) + tmp14 := lang.Apply(tmp9, []any{tmp13}) + _ = tmp14 + var tmp15 any + func() { + defer func() { + tmp16 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp17 := lang.Apply(tmp16, nil) + _ = tmp17 + }() + var tmp18 any + var tmp19 any + { // let + // let binding "and__0__auto__" + tmp20 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_level_STAR_) + var v21 any = tmp20 + _ = v21 + var tmp22 any + if lang.IsTruthy(v21) { + tmp23 := checkDerefVar(var_glojure_DOT_core_neg_QMARK_) + tmp24 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_level_STAR_) + tmp25 := lang.Apply(tmp23, []any{tmp24}) + tmp22 = tmp25 + } else { + tmp22 = v21 + } + tmp19 = tmp22 + } // end let + if lang.IsTruthy(tmp19) { + tmp20 := lang.Apply(lang.WriteWriter, []any{v7, "#"}) + tmp18 = tmp20 + } else { + tmp21 := lang.Apply(lang.WriteWriter, []any{v7, v2}) + _ = tmp21 + var tmp22 any + { // let + // let binding "temp__0__auto__" + tmp23 := checkDerefVar(var_glojure_DOT_core_seq) + tmp24 := lang.Apply(tmp23, []any{v6}) + var v25 any = tmp24 + _ = v25 + var tmp26 any + if lang.IsTruthy(v25) { + var tmp27 any + { // let + // let binding "xs" + var v28 any = v25 + _ = v28 + var tmp29 any + var tmp30 any + { // let + // let binding "and__0__auto__" + tmp31 := checkDerefVar(var_glojure_DOT_core_not) + tmp32 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_dup_STAR_) + tmp33 := lang.Apply(tmp31, []any{tmp32}) + var v34 any = tmp33 + _ = v34 + var tmp35 any + if lang.IsTruthy(v34) { + tmp36 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_length_STAR_) + tmp35 = tmp36 + } else { + tmp35 = v34 + } + tmp30 = tmp35 + } // end let + if lang.IsTruthy(tmp30) { + var tmp31 any + { // let + // let binding "G__885" + var v32 any = v28 + _ = v32 + // let binding "vec__886" + var v33 any = v32 + _ = v33 + // let binding "seq__887" + tmp34 := checkDerefVar(var_glojure_DOT_core_seq) + tmp35 := lang.Apply(tmp34, []any{v33}) + var v36 any = tmp35 + _ = v36 + // let binding "first__888" + tmp37 := checkDerefVar(var_glojure_DOT_core_first) + tmp38 := lang.Apply(tmp37, []any{v36}) + var v39 any = tmp38 + _ = v39 + // let binding "seq__887" + tmp40 := checkDerefVar(var_glojure_DOT_core_next) + tmp41 := lang.Apply(tmp40, []any{v36}) + var v42 any = tmp41 + _ = v42 + // let binding "x" + var v43 any = v39 + _ = v43 + // let binding "xs" + var v44 any = v42 + _ = v44 + // let binding "print-length" + tmp45 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_length_STAR_) + var v46 any = tmp45 + _ = v46 + var tmp47 any + { // let + // let binding "G__885" + var v48 any = v32 + _ = v48 + // let binding "print-length" + var v49 any = v46 + _ = v49 + for { + var tmp50 any + { // let + // let binding "vec__889" + var v51 any = v48 + _ = v51 + // let binding "seq__890" + tmp52 := checkDerefVar(var_glojure_DOT_core_seq) + tmp53 := lang.Apply(tmp52, []any{v51}) + var v54 any = tmp53 + _ = v54 + // let binding "first__891" + tmp55 := checkDerefVar(var_glojure_DOT_core_first) + tmp56 := lang.Apply(tmp55, []any{v54}) + var v57 any = tmp56 + _ = v57 + // let binding "seq__890" + tmp58 := checkDerefVar(var_glojure_DOT_core_next) + tmp59 := lang.Apply(tmp58, []any{v54}) + var v60 any = tmp59 + _ = v60 + // let binding "x" + var v61 any = v57 + _ = v61 + // let binding "xs" + var v62 any = v60 + _ = v62 + // let binding "print-length" + var v63 any = v49 + _ = v63 + var tmp64 any + tmp65 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) + tmp66 := lang.Apply(tmp65, []any{v63}) + if lang.IsTruthy(tmp66) { + tmp67 := lang.Apply(lang.WriteWriter, []any{v7, "..."}) + tmp64 = tmp67 + } else { + tmp68 := lang.Apply(v3, []any{v61, v7}) + _ = tmp68 + var tmp69 any + if lang.IsTruthy(v62) { + tmp70 := lang.Apply(lang.WriteWriter, []any{v7, v4}) + _ = tmp70 + var tmp71 any = v62 + tmp73 := checkDerefVar(var_glojure_DOT_core_dec) + tmp74 := lang.Apply(tmp73, []any{v63}) + var tmp72 any = tmp74 + v48 = tmp71 + v49 = tmp72 + continue + } else { + } + tmp64 = tmp69 + } + tmp50 = tmp64 + } // end let + tmp47 = tmp50 + break + } + } // end let + tmp31 = tmp47 + } // end let + tmp29 = tmp31 + } else { + var tmp32 any + { // let + // let binding "G__895" + var v33 any = v28 + _ = v33 + // let binding "vec__896" + var v34 any = v33 + _ = v34 + // let binding "seq__897" + tmp35 := checkDerefVar(var_glojure_DOT_core_seq) + tmp36 := lang.Apply(tmp35, []any{v34}) + var v37 any = tmp36 + _ = v37 + // let binding "first__898" + tmp38 := checkDerefVar(var_glojure_DOT_core_first) + tmp39 := lang.Apply(tmp38, []any{v37}) + var v40 any = tmp39 + _ = v40 + // let binding "seq__897" + tmp41 := checkDerefVar(var_glojure_DOT_core_next) + tmp42 := lang.Apply(tmp41, []any{v37}) + var v43 any = tmp42 + _ = v43 + // let binding "x" + var v44 any = v40 + _ = v44 + // let binding "xs" + var v45 any = v43 + _ = v45 + var tmp46 any + { // let + // let binding "G__895" + var v47 any = v33 + _ = v47 + for { + var tmp48 any + { // let + // let binding "vec__899" + var v49 any = v47 + _ = v49 + // let binding "seq__900" + tmp50 := checkDerefVar(var_glojure_DOT_core_seq) + tmp51 := lang.Apply(tmp50, []any{v49}) + var v52 any = tmp51 + _ = v52 + // let binding "first__901" + tmp53 := checkDerefVar(var_glojure_DOT_core_first) + tmp54 := lang.Apply(tmp53, []any{v52}) + var v55 any = tmp54 + _ = v55 + // let binding "seq__900" + tmp56 := checkDerefVar(var_glojure_DOT_core_next) + tmp57 := lang.Apply(tmp56, []any{v52}) + var v58 any = tmp57 + _ = v58 + // let binding "x" + var v59 any = v55 + _ = v59 + // let binding "xs" + var v60 any = v58 + _ = v60 + tmp61 := lang.Apply(v3, []any{v59, v7}) + _ = tmp61 + var tmp62 any + if lang.IsTruthy(v60) { + tmp63 := lang.Apply(lang.WriteWriter, []any{v7, v4}) + _ = tmp63 + var tmp64 any = v60 + v47 = tmp64 + continue + } else { + } + tmp48 = tmp62 + } // end let + tmp46 = tmp48 + break + } + } // end let + tmp32 = tmp46 + } // end let + tmp29 = tmp32 + } + tmp27 = tmp29 + } // end let + tmp26 = tmp27 + } else { + } + tmp22 = tmp26 + } // end let + _ = tmp22 + tmp23 := lang.Apply(lang.WriteWriter, []any{v7, v5}) + tmp18 = tmp23 + } + tmp15 = tmp18 + }() + tmp8 = tmp15 + } // end let + return tmp8 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_print_DASH_sequential = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_print_DASH_sequential.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // protocol? + { + tmp0 := sym_protocol_QMARK_.WithMeta(lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(110), kw_column, int(8), kw_end_DASH_line, int(110), kw_end_DASH_column, int(16), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_maybe_DASH_p)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := reflect.TypeOf((*lang.IAtom)(nil)).Elem() + tmp6 := lang.Apply(tmp4, []any{tmp5, v2}) + if lang.IsTruthy(tmp6) { + tmp7 := checkDerefVar(var_glojure_DOT_core_boolean) + tmp8 := checkDerefVar(var_glojure_DOT_core_deref) + tmp9 := lang.Apply(tmp8, []any{v2}) + tmp10 := lang.Apply(kw_on_DASH_interface, []any{tmp9}) + tmp11 := lang.Apply(tmp7, []any{tmp10}) + tmp3 = tmp11 + } else { + tmp3 = false + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_protocol_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_protocol_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // pvalues + { + tmp0 := sym_pvalues.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_exprs)), kw_doc, "Returns a lazy sequence of the values of the exprs, which are\n evaluated in parallel", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(7063), kw_end_DASH_line, int(7063))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym_glojure_DOT_core_SLASH_pcalls}) + tmp9 := checkDerefVar(var_glojure_DOT_core_map) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v11 := args[0] + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.NewVector() + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7069), kw_column, int(30), kw_end_DASH_line, int(7069), kw_end_DASH_column, int(31)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp16 := lang.Apply(tmp12, []any{sym_glojure_DOT_core_SLASH_fn, tmp15, v11}) + return tmp16 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7069), kw_column, int(19), kw_end_DASH_line, int(7069), kw_end_DASH_column, int(34)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := lang.Apply(tmp9, []any{tmp12, v4}) + tmp14 := lang.Apply(tmp6, []any{tmp8, tmp13}) + tmp15 := lang.Apply(tmp5, []any{tmp14}) + return tmp15 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_pvalues = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_pvalues.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // qualified-ident? + { + tmp0 := sym_qualified_DASH_ident_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a symbol or keyword with a namespace", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(22), kw_column, int(7), kw_line, int(1618), kw_end_DASH_line, int(1618))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp4 any + { // let + // let binding "and__0__auto__" + tmp5 := checkDerefVar(var_glojure_DOT_core_ident_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v2}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + if lang.IsTruthy(v7) { + var tmp9 any + { // let + // let binding "and__0__auto__" + tmp10 := checkDerefVar(var_glojure_DOT_core_namespace) + tmp11 := lang.Apply(tmp10, []any{v2}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + tmp13 = true + } else { + tmp13 = v12 + } + tmp9 = tmp13 + } // end let + tmp8 = tmp9 + } else { + tmp8 = v7 + } + tmp4 = tmp8 + } // end let + tmp5 := lang.Apply(tmp3, []any{tmp4}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_qualified_DASH_ident_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_qualified_DASH_ident_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // qualified-keyword? + { + tmp0 := sym_qualified_DASH_keyword_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a keyword with a namespace", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(24), kw_column, int(7), kw_line, int(1638), kw_end_DASH_line, int(1638))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp4 any + { // let + // let binding "and__0__auto__" + tmp5 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v2}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + if lang.IsTruthy(v7) { + var tmp9 any + { // let + // let binding "and__0__auto__" + tmp10 := checkDerefVar(var_glojure_DOT_core_namespace) + tmp11 := lang.Apply(tmp10, []any{v2}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + tmp13 = true + } else { + tmp13 = v12 + } + tmp9 = tmp13 + } // end let + tmp8 = tmp9 + } else { + tmp8 = v7 + } + tmp4 = tmp8 + } // end let + tmp5 := lang.Apply(tmp3, []any{tmp4}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_qualified_DASH_keyword_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_qualified_DASH_keyword_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // qualified-symbol? + { + tmp0 := sym_qualified_DASH_symbol_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a symbol with a namespace", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(7), kw_line, int(1628), kw_end_DASH_line, int(1628))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp4 any + { // let + // let binding "and__0__auto__" + tmp5 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v2}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + if lang.IsTruthy(v7) { + var tmp9 any + { // let + // let binding "and__0__auto__" + tmp10 := checkDerefVar(var_glojure_DOT_core_namespace) + tmp11 := lang.Apply(tmp10, []any{v2}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + tmp13 = true + } else { + tmp13 = v12 + } + tmp9 = tmp13 + } // end let + tmp8 = tmp9 + } else { + tmp8 = v7 + } + tmp4 = tmp8 + } // end let + tmp5 := lang.Apply(tmp3, []any{tmp4}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_qualified_DASH_symbol_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_qualified_DASH_symbol_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // rand + { + tmp0 := sym_rand.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_n)), kw_doc, "Returns a random floating point number between 0 (inclusive) and\n n (default 1) (exclusive).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(4935), kw_end_DASH_line, int(4935))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp2 := lang.Apply(rand13.Float64, nil) + return tmp2 + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core__STAR_) + tmp4 := checkDerefVar(var_glojure_DOT_core_rand) + tmp5 := lang.Apply(tmp4, nil) + tmp6 := lang.Apply(tmp3, []any{v2, tmp5}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_rand = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_rand.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // rand-int + { + tmp0 := sym_rand_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_doc, "Returns a random integer between 0 (inclusive) and n (exclusive).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(4943), kw_end_DASH_line, int(4943))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_int) + tmp4 := checkDerefVar(var_glojure_DOT_core_rand) + tmp5 := lang.Apply(tmp4, []any{v2}) + tmp6 := lang.Apply(tmp3, []any{tmp5}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_rand_DASH_int = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_rand_DASH_int.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // rand-nth + { + tmp0 := sym_rand_DASH_nth.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Return a random element of the (sequential) collection. Will have\n the same performance characteristics as nth for the given\n collection.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(7213), kw_end_DASH_line, int(7213))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_nth) + tmp4 := checkDerefVar(var_glojure_DOT_core_rand_DASH_int) + tmp5 := checkDerefVar(var_glojure_DOT_core_count) + tmp6 := lang.Apply(tmp5, []any{v2}) + tmp7 := lang.Apply(tmp4, []any{tmp6}) + tmp8 := lang.Apply(tmp3, []any{v2, tmp7}) + return tmp8 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_rand_DASH_nth = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_rand_DASH_nth.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // random-sample + { + tmp0 := sym_random_DASH_sample.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_prob), lang.NewVector(sym_prob, sym_coll)), kw_doc, "Returns items from coll with random probability of prob (0.0 -\n 1.0). Returns a transducer when no collection is provided.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(7699), kw_end_DASH_line, int(7699))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_filter) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v5 := args[0] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp7 := checkDerefVar(var_glojure_DOT_core_rand) + tmp8 := lang.Apply(tmp7, nil) + tmp9 := lang.Apply(tmp6, []any{tmp8, v2}) + return tmp9 + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7704), kw_column, int(14), kw_end_DASH_line, int(7704), kw_end_DASH_column, int(37)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp7 := lang.Apply(tmp3, []any{tmp6}) + return tmp7 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_filter) + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v6 := args[0] + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp8 := checkDerefVar(var_glojure_DOT_core_rand) + tmp9 := lang.Apply(tmp8, nil) + tmp10 := lang.Apply(tmp7, []any{tmp9, v2}) + return tmp10 + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7706), kw_column, int(14), kw_end_DASH_line, int(7706), kw_end_DASH_column, int(37)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp8 := lang.Apply(tmp4, []any{tmp7, v3}) + return tmp8 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_random_DASH_sample = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_random_DASH_sample.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // re-groups + { + tmp0 := sym_re_DASH_groups.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m)), kw_doc, "Returns the groups from the most recent match/find. If there are no\n nested groups, returns a string of the entire match. If there are\n nested groups, returns a vector of the groups, the first element\n being the entire match.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(4882), kw_end_DASH_line, int(4882))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "gc" + tmp4, _ := lang.FieldOrMethod(v2, "groupCount") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("groupCount is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) + tmp9 := lang.Apply(tmp8, []any{v6}) + if lang.IsTruthy(tmp9) { + tmp10, _ := lang.FieldOrMethod(v2, "group") + if reflect.TypeOf(tmp10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("group is not a function"))) + } + tmp11 := lang.Apply(tmp10, []any{}) + tmp7 = tmp11 + } else { + var tmp12 any + { // let + // let binding "ret" + tmp13 := lang.NewVector() + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4893), kw_column, int(20), kw_end_DASH_line, int(4893), kw_end_DASH_column, int(21)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v16 any = tmp15 + _ = v16 + // let binding "c" + var v17 any = int64(0) + _ = v17 + for { + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core__LT__EQ_) + tmp20 := lang.Apply(tmp19, []any{v17, v6}) + if lang.IsTruthy(tmp20) { + tmp22 := checkDerefVar(var_glojure_DOT_core_conj) + tmp23, _ := lang.FieldOrMethod(v2, "groupInt") + if reflect.TypeOf(tmp23).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("groupInt is not a function"))) + } + tmp24 := lang.Apply(tmp23, []any{v17}) + tmp25 := lang.Apply(tmp22, []any{v16, tmp24}) + var tmp21 any = tmp25 + tmp27 := checkDerefVar(var_glojure_DOT_core_inc) + tmp28 := lang.Apply(tmp27, []any{v17}) + var tmp26 any = tmp28 + v16 = tmp21 + v17 = tmp26 + continue + } else { + tmp18 = v16 + } + tmp12 = tmp18 + break + } + } // end let + tmp7 = tmp12 + } + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_re_DASH_groups = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_re_DASH_groups.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // re-matches + { + tmp0 := sym_re_DASH_matches.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_re, sym_s)), kw_doc, "Returns the match, if any, of string to pattern, using\n java.util.regex.Matcher.matches(). Uses re-groups to return the\n groups.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4910), kw_end_DASH_line, int(4910))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "m" + tmp5 := checkDerefVar(var_glojure_DOT_core_re_DASH_matcher) + tmp6 := lang.Apply(tmp5, []any{v2, v3}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + tmp9, _ := lang.FieldOrMethod(v7, "matches") + if reflect.TypeOf(tmp9).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("matches is not a function"))) + } + tmp10 := lang.Apply(tmp9, []any{}) + if lang.IsTruthy(tmp10) { + tmp11 := checkDerefVar(var_glojure_DOT_core_re_DASH_groups) + tmp12 := lang.Apply(tmp11, []any{v7}) + tmp8 = tmp12 + } else { + } + tmp4 = tmp8 + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_re_DASH_matches = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_re_DASH_matches.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // re-seq + { + tmp0 := sym_re_DASH_seq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_re, sym_s)), kw_doc, "Returns a lazy sequence of successive matches of pattern in string,\n using java.util.regex.Matcher.find(), each such match processed with\n re-groups.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(4898), kw_end_DASH_line, int(4898))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "m" + tmp5 := checkDerefVar(var_glojure_DOT_core_re_DASH_matcher) + tmp6 := lang.Apply(tmp5, []any{v2, v3}) + var v7 any = tmp6 + _ = v7 + var tmp8 lang.FnFunc + { // function step + var v9 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp10 any + tmp11, _ := lang.FieldOrMethod(v7, "find") + if reflect.TypeOf(tmp11).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("find is not a function"))) + } + tmp12 := lang.Apply(tmp11, []any{}) + if lang.IsTruthy(tmp12) { + tmp13 := checkDerefVar(var_glojure_DOT_core_cons) + tmp14 := checkDerefVar(var_glojure_DOT_core_re_DASH_groups) + tmp15 := lang.Apply(tmp14, []any{v7}) + var tmp16 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp17 := lang.Apply(v9, nil) + return tmp17 + }) + tmp17 := lang.Apply(lang.NewLazySeq, []any{tmp16}) + tmp18 := lang.Apply(tmp13, []any{tmp15, tmp17}) + tmp10 = tmp18 + } else { + } + return tmp10 + }) + v9 = tmp8 + _ = v9 + } + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4906), kw_column, int(6), kw_end_DASH_line, int(4908), kw_end_DASH_column, int(49)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp11 := lang.Apply(tmp10, nil) + tmp4 = tmp11 + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_re_DASH_seq = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_re_DASH_seq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // refer + { + tmp0 := sym_refer.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns_DASH_sym, sym__AMP_, sym_filters)), kw_doc, "refers to all public vars of ns, subject to filters.\n filters can include at most one each of:\n\n :exclude list-of-symbols\n :only list-of-symbols\n :rename map-of-fromsymbol-tosymbol\n\n For each public interned var in the namespace named by the symbol,\n adds a mapping from the name of the var to the var to the current\n namespace. Throws an exception if name is already mapped to\n something else in the current namespace. Filters can be used to\n select a subset, via inclusion or exclusion, or to provide a mapping\n to a symbol different from the var's name, in order to prevent\n clashes. Use :use in the ns macro in preference to calling this directly.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(4216), kw_end_DASH_line, int(4216))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + var tmp4 any + { // let + // let binding "ns" + var tmp5 any + { // let + // let binding "or__0__auto__" + tmp6 := checkDerefVar(var_glojure_DOT_core_find_DASH_ns) + tmp7 := lang.Apply(tmp6, []any{v2}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + tmp9 = v8 + } else { + tmp10 := checkDerefVar(var_glojure_DOT_core_str) + tmp11 := lang.Apply(tmp10, []any{"No namespace: ", v2}) + tmp12 := lang.Apply(errors5.New, []any{tmp11}) + panic(tmp12) + } + tmp5 = tmp9 + } // end let + var v6 any = tmp5 + _ = v6 + // let binding "fs" + tmp7 := checkDerefVar(var_glojure_DOT_core_apply) + tmp8 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp9 := lang.Apply(tmp7, []any{tmp8, v3}) + var v10 any = tmp9 + _ = v10 + // let binding "nspublics" + tmp11 := checkDerefVar(var_glojure_DOT_core_ns_DASH_publics) + tmp12 := lang.Apply(tmp11, []any{v6}) + var v13 any = tmp12 + _ = v13 + // let binding "rename" + var tmp14 any + { // let + // let binding "or__0__auto__" + tmp15 := lang.Apply(kw_rename, []any{v10}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + if lang.IsTruthy(v16) { + tmp17 = v16 + } else { + tmp18 := lang.NewMap() + tmp19 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4236), kw_column, int(35), kw_end_DASH_line, int(4236), kw_end_DASH_column, int(36)) + tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp17 = tmp20 + } + tmp14 = tmp17 + } // end let + var v15 any = tmp14 + _ = v15 + // let binding "exclude" + tmp16 := checkDerefVar(var_glojure_DOT_core_set) + tmp17 := lang.Apply(kw_exclude, []any{v10}) + tmp18 := lang.Apply(tmp16, []any{tmp17}) + var v19 any = tmp18 + _ = v19 + // let binding "to-do" + var tmp20 any + tmp21 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp22 := lang.Apply(kw_refer, []any{v10}) + tmp23 := lang.Apply(tmp21, []any{kw_all, tmp22}) + if lang.IsTruthy(tmp23) { + tmp24 := checkDerefVar(var_glojure_DOT_core_keys) + tmp25 := lang.Apply(tmp24, []any{v13}) + tmp20 = tmp25 + } else { + var tmp26 any + { // let + // let binding "or__0__auto__" + tmp27 := lang.Apply(kw_refer, []any{v10}) + var v28 any = tmp27 + _ = v28 + var tmp29 any + if lang.IsTruthy(v28) { + tmp29 = v28 + } else { + var tmp30 any + { // let + // let binding "or__0__auto__" + tmp31 := lang.Apply(kw_only, []any{v10}) + var v32 any = tmp31 + _ = v32 + var tmp33 any + if lang.IsTruthy(v32) { + tmp33 = v32 + } else { + tmp34 := checkDerefVar(var_glojure_DOT_core_keys) + tmp35 := lang.Apply(tmp34, []any{v13}) + tmp33 = tmp35 + } + tmp30 = tmp33 + } // end let + tmp29 = tmp30 + } + tmp26 = tmp29 + } // end let + tmp20 = tmp26 + } + var v27 any = tmp20 + _ = v27 + var tmp28 any + var tmp29 any + { // let + // let binding "and__0__auto__" + var v30 any = v27 + _ = v30 + var tmp31 any + if lang.IsTruthy(v30) { + tmp32 := checkDerefVar(var_glojure_DOT_core_not) + tmp33 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp34 := reflect.TypeOf((*lang.Sequential)(nil)).Elem() + tmp35 := lang.Apply(tmp33, []any{tmp34, v27}) + tmp36 := lang.Apply(tmp32, []any{tmp35}) + tmp31 = tmp36 + } else { + tmp31 = v30 + } + tmp29 = tmp31 + } // end let + if lang.IsTruthy(tmp29) { + tmp30 := lang.Apply(errors5.New, []any{":only/:refer value must be a sequential collection of symbols"}) + panic(tmp30) + } else { + } + _ = tmp28 + var tmp31 any + { // let + // let binding "seq_700" + tmp32 := checkDerefVar(var_glojure_DOT_core_seq) + tmp33 := lang.Apply(tmp32, []any{v27}) + var v34 any = tmp33 + _ = v34 + // let binding "chunk_701" + var v35 any = nil + _ = v35 + // let binding "count_702" + var v36 any = int64(0) + _ = v36 + // let binding "i_703" + var v37 any = int64(0) + _ = v37 + for { + var tmp38 any + tmp39 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp40 := lang.Apply(tmp39, []any{v37, v36}) + if lang.IsTruthy(tmp40) { + var tmp41 any + { // let + // let binding "sym" + tmp42, _ := lang.FieldOrMethod(v35, "nth") + if reflect.TypeOf(tmp42).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp43 := lang.Apply(tmp42, []any{v37}) + var v44 any = tmp43 + _ = v44 + var tmp45 any + tmp46 := lang.Apply(v19, []any{v44}) + if lang.IsTruthy(tmp46) { + } else { + var tmp47 any + { // let + // let binding "v" + tmp48 := lang.Apply(v13, []any{v44}) + var v49 any = tmp48 + _ = v49 + var tmp50 any + if lang.IsTruthy(v49) { + } else { + panic("unimplemented: new with non-constant class type") + } + _ = tmp50 + tmp51 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + var tmp52 any + { // let + // let binding "or__0__auto__" + tmp53 := lang.Apply(v15, []any{v44}) + var v54 any = tmp53 + _ = v54 + var tmp55 any + if lang.IsTruthy(v54) { + tmp55 = v54 + } else { + tmp55 = v44 + } + tmp52 = tmp55 + } // end let + tmp53, _ := lang.FieldOrMethod(tmp51, "Refer") + if reflect.TypeOf(tmp53).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Refer is not a function"))) + } + tmp54 := lang.Apply(tmp53, []any{tmp52, v49}) + tmp47 = tmp54 + } // end let + tmp45 = tmp47 + } + _ = tmp45 + var tmp48 any = v34 + var tmp49 any = v35 + var tmp50 any = v36 + tmp52 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp53 := lang.Apply(tmp52, []any{v37}) + var tmp51 any = tmp53 + v34 = tmp48 + v35 = tmp49 + v36 = tmp50 + v37 = tmp51 + continue + } // end let + tmp38 = tmp41 + } else { + var tmp42 any + { // let + // let binding "temp__0__auto__" + tmp43 := checkDerefVar(var_glojure_DOT_core_seq) + tmp44 := lang.Apply(tmp43, []any{v34}) + var v45 any = tmp44 + _ = v45 + var tmp46 any + if lang.IsTruthy(v45) { + var tmp47 any + { // let + // let binding "seq_700" + var v48 any = v45 + _ = v48 + var tmp49 any + tmp50 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp51 := lang.Apply(tmp50, []any{v48}) + if lang.IsTruthy(tmp51) { + var tmp52 any + { // let + // let binding "c__0__auto__" + tmp53 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp54 := lang.Apply(tmp53, []any{v48}) + var v55 any = tmp54 + _ = v55 + tmp57 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp58 := lang.Apply(tmp57, []any{v48}) + var tmp56 any = tmp58 + var tmp59 any = v55 + tmp61 := checkDerefVar(var_glojure_DOT_core_int) + tmp62 := checkDerefVar(var_glojure_DOT_core_count) + tmp63 := lang.Apply(tmp62, []any{v55}) + tmp64 := lang.Apply(tmp61, []any{tmp63}) + var tmp60 any = tmp64 + tmp66 := checkDerefVar(var_glojure_DOT_core_int) + tmp67 := lang.Apply(tmp66, []any{int64(0)}) + var tmp65 any = tmp67 + v34 = tmp56 + v35 = tmp59 + v36 = tmp60 + v37 = tmp65 + continue + } // end let + tmp49 = tmp52 + } else { + var tmp53 any + { // let + // let binding "sym" + tmp54 := checkDerefVar(var_glojure_DOT_core_first) + tmp55 := lang.Apply(tmp54, []any{v48}) + var v56 any = tmp55 + _ = v56 + var tmp57 any + tmp58 := lang.Apply(v19, []any{v56}) + if lang.IsTruthy(tmp58) { + } else { + var tmp59 any + { // let + // let binding "v" + tmp60 := lang.Apply(v13, []any{v56}) + var v61 any = tmp60 + _ = v61 + var tmp62 any + if lang.IsTruthy(v61) { + } else { + panic("unimplemented: new with non-constant class type") + } + _ = tmp62 + tmp63 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + var tmp64 any + { // let + // let binding "or__0__auto__" + tmp65 := lang.Apply(v15, []any{v56}) + var v66 any = tmp65 + _ = v66 + var tmp67 any + if lang.IsTruthy(v66) { + tmp67 = v66 + } else { + tmp67 = v56 + } + tmp64 = tmp67 + } // end let + tmp65, _ := lang.FieldOrMethod(tmp63, "Refer") + if reflect.TypeOf(tmp65).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Refer is not a function"))) + } + tmp66 := lang.Apply(tmp65, []any{tmp64, v61}) + tmp59 = tmp66 + } // end let + tmp57 = tmp59 + } + _ = tmp57 + tmp61 := checkDerefVar(var_glojure_DOT_core_next) + tmp62 := lang.Apply(tmp61, []any{v48}) + var tmp60 any = tmp62 + var tmp63 any = nil + var tmp64 any = int64(0) + var tmp65 any = int64(0) + v34 = tmp60 + v35 = tmp63 + v36 = tmp64 + v37 = tmp65 + continue + } // end let + tmp49 = tmp53 + } + tmp47 = tmp49 + } // end let + tmp46 = tmp47 + } else { + } + tmp42 = tmp46 + } // end let + tmp38 = tmp42 + } + tmp31 = tmp38 + break + } + } // end let + tmp4 = tmp31 + } // end let + return tmp4 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_refer = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_refer.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // remove + { + tmp0 := sym_remove.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred), lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns a lazy sequence of the items in coll for which\n (pred item) returns logical false. pred must be free of side-effects.\n Returns a transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(2818), kw_end_DASH_line, int(2818))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_filter) + tmp4 := checkDerefVar(var_glojure_DOT_core_complement) + tmp5 := lang.Apply(tmp4, []any{v2}) + tmp6 := lang.Apply(tmp3, []any{tmp5}) + return tmp6 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_filter) + tmp5 := checkDerefVar(var_glojure_DOT_core_complement) + tmp6 := lang.Apply(tmp5, []any{v2}) + tmp7 := lang.Apply(tmp4, []any{tmp6, v3}) + return tmp7 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_remove = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_remove.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // replace + { + tmp0 := sym_replace.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_smap), lang.NewVector(sym_smap, sym_coll)), kw_doc, "Given a map of replacement pairs and a vector/collection, returns a\n vector/seq with any elements = a key in smap replaced with the\n corresponding val in smap. Returns a transducer when no collection\n is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(5082), kw_end_DASH_line, int(5082))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_map) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v5 := args[0] + _ = v5 + var tmp6 any + { // let + // let binding "temp__0__auto__" + tmp7 := checkDerefVar(var_glojure_DOT_core_find) + tmp8 := lang.Apply(tmp7, []any{v2, v5}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + var tmp11 any + { // let + // let binding "e" + var v12 any = v9 + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_val) + tmp14 := lang.Apply(tmp13, []any{v12}) + tmp11 = tmp14 + } // end let + tmp10 = tmp11 + } else { + tmp10 = v5 + } + tmp6 = tmp10 + } // end let + return tmp6 + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5090), kw_column, int(11), kw_end_DASH_line, int(5090), kw_end_DASH_column, int(47)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp7 := lang.Apply(tmp3, []any{tmp6}) + return tmp7 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp8 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v9 := args[0] + _ = v9 + v10 := args[1] + _ = v10 + var tmp11 any + { // let + // let binding "temp__0__auto__" + tmp12 := checkDerefVar(var_glojure_DOT_core_find) + tmp13 := checkDerefVar(var_glojure_DOT_core_nth) + tmp14 := lang.Apply(tmp13, []any{v9, v10}) + tmp15 := lang.Apply(tmp12, []any{v2, tmp14}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + if lang.IsTruthy(v16) { + var tmp18 any + { // let + // let binding "e" + var v19 any = v16 + _ = v19 + tmp20 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp21 := checkDerefVar(var_glojure_DOT_core_val) + tmp22 := lang.Apply(tmp21, []any{v19}) + tmp23 := lang.Apply(tmp20, []any{v9, v10, tmp22}) + tmp18 = tmp23 + } // end let + tmp17 = tmp18 + } else { + tmp17 = v9 + } + tmp11 = tmp17 + } // end let + return tmp11 + }) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5093), kw_column, int(17), kw_end_DASH_line, int(5096), kw_end_DASH_column, int(23)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp11 := checkDerefVar(var_glojure_DOT_core_range) + tmp12 := checkDerefVar(var_glojure_DOT_core_count) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(tmp11, []any{tmp13}) + tmp15 := lang.Apply(tmp7, []any{tmp10, v3, tmp14}) + tmp4 = tmp15 + } else { + tmp16 := checkDerefVar(var_glojure_DOT_core_map) + var tmp17 lang.FnFunc + tmp17 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v18 := args[0] + _ = v18 + var tmp19 any + { // let + // let binding "temp__0__auto__" + tmp20 := checkDerefVar(var_glojure_DOT_core_find) + tmp21 := lang.Apply(tmp20, []any{v2, v18}) + var v22 any = tmp21 + _ = v22 + var tmp23 any + if lang.IsTruthy(v22) { + var tmp24 any + { // let + // let binding "e" + var v25 any = v22 + _ = v25 + tmp26 := checkDerefVar(var_glojure_DOT_core_val) + tmp27 := lang.Apply(tmp26, []any{v25}) + tmp24 = tmp27 + } // end let + tmp23 = tmp24 + } else { + tmp23 = v18 + } + tmp19 = tmp23 + } // end let + return tmp19 + }) + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5098), kw_column, int(13), kw_end_DASH_line, int(5098), kw_end_DASH_column, int(49)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp20 := lang.Apply(tmp16, []any{tmp19, v3}) + tmp4 = tmp20 + } + return tmp4 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_replace = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_replace.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // restart-agent + { + tmp0 := sym_restart_DASH_agent.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a, sym_new_DASH_state, sym__AMP_, sym_options)), kw_doc, "When an agent is failed, changes the agent state to new-state and\n then un-fails the agent so that sends are allowed again. If\n a :clear-actions true option is given, any actions queued on the\n agent that were being held while it was failed will be discarded,\n otherwise those held actions will proceed. The new-state must pass\n the validator if any, or restart will throw an exception and the\n agent will remain failed with its old state and error. Watchers, if\n any, will NOT be notified of the new state. Throws an exception if\n the agent is not failed.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(2175), kw_end_DASH_line, int(2175))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "opts" + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp8 := lang.Apply(tmp6, []any{tmp7, v4}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + tmp11 := lang.Apply(kw_clear_DASH_actions, []any{v9}) + if lang.IsTruthy(tmp11) { + tmp10 = true + } else { + tmp10 = false + } + tmp12, _ := lang.FieldOrMethod(v2, "restart") + if reflect.TypeOf(tmp12).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("restart is not a function"))) + } + tmp13 := lang.Apply(tmp12, []any{v3, tmp10}) + tmp5 = tmp13 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_restart_DASH_agent = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_restart_DASH_agent.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // root-directory + { + tmp0 := sym_root_DASH_directory.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_lib)), kw_doc, "Returns the root resource path for a lib", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(8), kw_line, int(5871), kw_end_DASH_line, int(5871), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "d" + tmp4 := checkDerefVar(var_glojure_DOT_core_root_DASH_resource) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_subs) + tmp8 := lang.Apply(strings8.LastIndex, []any{v6, "/"}) + tmp9 := lang.Apply(tmp7, []any{v6, int64(0), tmp8}) + tmp3 = tmp9 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_root_DASH_directory = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_root_DASH_directory.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // rsubseq + { + tmp0 := sym_rsubseq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_sc, sym_test, sym_key), lang.NewVector(sym_sc, sym_start_DASH_test, sym_start_DASH_key, sym_end_DASH_test, sym_end_DASH_key)), kw_doc, "sc must be a sorted collection, test(s) one of <, <=, > or\n >=. Returns a reverse seq of those entries with keys ek for\n which (test (.. sc comparator (compare ek key)) 0) is true", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(5150), kw_end_DASH_line, int(5150))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + { // let + // let binding "include" + tmp6 := checkDerefVar(var_glojure_DOT_core_mk_DASH_bound_DASH_fn) + tmp7 := lang.Apply(tmp6, []any{v2, v3, v4}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp11 := checkDerefVar(var_glojure_DOT_core__LT__EQ_) + tmp12 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{tmp10, tmp11})) + tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5158), kw_column, int(11), kw_end_DASH_line, int(5158), kw_end_DASH_column, int(17)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp15 := lang.Apply(tmp14, []any{v3}) + if lang.IsTruthy(tmp15) { + var tmp16 any + { // let + // let binding "temp__0__auto__" + tmp17, _ := lang.FieldOrMethod(v2, "seqFrom") + if reflect.TypeOf(tmp17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("seqFrom is not a function"))) + } + tmp18 := lang.Apply(tmp17, []any{v4, false}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + var tmp21 any + { // let + // let binding "vec__765" + var v22 any = v19 + _ = v22 + // let binding "e" + tmp23 := checkDerefVar(var_glojure_DOT_core_nth) + tmp24 := lang.Apply(tmp23, []any{v22, int64(0), nil}) + var v25 any = tmp24 + _ = v25 + // let binding "s" + var v26 any = v22 + _ = v26 + var tmp27 any + tmp28 := lang.Apply(v8, []any{v25}) + if lang.IsTruthy(tmp28) { + tmp27 = v26 + } else { + tmp29 := checkDerefVar(var_glojure_DOT_core_next) + tmp30 := lang.Apply(tmp29, []any{v26}) + tmp27 = tmp30 + } + tmp21 = tmp27 + } // end let + tmp20 = tmp21 + } else { + } + tmp16 = tmp20 + } // end let + tmp9 = tmp16 + } else { + tmp17 := checkDerefVar(var_glojure_DOT_core_take_DASH_while) + tmp18, _ := lang.FieldOrMethod(v2, "seq") + if reflect.TypeOf(tmp18).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("seq is not a function"))) + } + tmp19 := lang.Apply(tmp18, []any{false}) + tmp20 := lang.Apply(tmp17, []any{v8, tmp19}) + tmp9 = tmp20 + } + tmp5 = tmp9 + } // end let + return tmp5 + case 5: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + var tmp7 any + { // let + // let binding "temp__0__auto__" + tmp8, _ := lang.FieldOrMethod(v2, "seqFrom") + if reflect.TypeOf(tmp8).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("seqFrom is not a function"))) + } + tmp9 := lang.Apply(tmp8, []any{v6, false}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + if lang.IsTruthy(v10) { + var tmp12 any + { // let + // let binding "vec__768" + var v13 any = v10 + _ = v13 + // let binding "e" + tmp14 := checkDerefVar(var_glojure_DOT_core_nth) + tmp15 := lang.Apply(tmp14, []any{v13, int64(0), nil}) + var v16 any = tmp15 + _ = v16 + // let binding "s" + var v17 any = v13 + _ = v17 + tmp18 := checkDerefVar(var_glojure_DOT_core_take_DASH_while) + tmp19 := checkDerefVar(var_glojure_DOT_core_mk_DASH_bound_DASH_fn) + tmp20 := lang.Apply(tmp19, []any{v2, v3, v4}) + var tmp21 any + tmp22 := checkDerefVar(var_glojure_DOT_core_mk_DASH_bound_DASH_fn) + tmp23 := lang.Apply(tmp22, []any{v2, v5, v6}) + tmp24 := lang.Apply(tmp23, []any{v16}) + if lang.IsTruthy(tmp24) { + tmp21 = v17 + } else { + tmp25 := checkDerefVar(var_glojure_DOT_core_next) + tmp26 := lang.Apply(tmp25, []any{v17}) + tmp21 = tmp26 + } + tmp27 := lang.Apply(tmp18, []any{tmp20, tmp21}) + tmp12 = tmp27 + } // end let + tmp11 = tmp12 + } else { + } + tmp7 = tmp11 + } // end let + return tmp7 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_rsubseq = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_rsubseq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // send-via + { + tmp0 := sym_send_DASH_via.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_executor, sym_a, sym_f, sym__AMP_, sym_args)), kw_doc, "Dispatch an action to an agent. Returns the agent immediately.\n Subsequently, in a thread supplied by executor, the state of the agent\n will be set to the value of:\n\n (apply action-fn state-of-agent args)", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(2099), kw_end_DASH_line, int(2099))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + tmp7 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp8 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp9 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_agent_STAR_) + tmp10 := lang.Apply(tmp8, []any{tmp9, v3}) + tmp11 := lang.Apply(tmp7, []any{tmp10}) + _ = tmp11 + var tmp12 any + func() { + defer func() { + tmp13 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp14 := lang.Apply(tmp13, nil) + _ = tmp14 + }() + tmp15 := checkDerefVar(var_glojure_DOT_core_binding_DASH_conveyor_DASH_fn) + tmp16 := lang.Apply(tmp15, []any{v4}) + tmp12 = tmp16 + }() + tmp6 = tmp12 + } // end let + tmp7, _ := lang.FieldOrMethod(v3, "dispatch") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("dispatch is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{tmp6, v5, v2}) + return tmp8 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_send_DASH_via = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_send_DASH_via.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // sequence + { + tmp0 := sym_sequence.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll), lang.NewVector(sym_xform, sym_coll), lang.NewVector(sym_xform, sym_coll, sym__AMP_, sym_colls)), kw_doc, "Coerces coll to a (possibly empty) sequence, if it is not already\n one. Will not force a lazy seq. (sequence nil) yields (), When a\n transducer is supplied, returns a lazy sequence of applications of\n the transform to the items in coll(s), i.e. to the set of first\n items of each coll, followed by the set of second\n items in each coll, until any one of the colls is exhausted. Any\n remaining items in other colls are ignored. The transform should accept\n number-of-colls arguments", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(2639), kw_end_DASH_line, int(2639))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + tmp3 = v2 + } else { + var tmp6 any + { // let + // let binding "or__0__auto__" + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := lang.Apply(tmp7, []any{v2}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + tmp10 = v9 + } else { + tmp10 = lang.NewList() + } + tmp6 = tmp10 + } // end let + tmp3 = tmp6 + } + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "or__0__auto__" + tmp5 := lang.Apply(nil, []any{v3}) + tmp6 := lang.Apply(nil, []any{v2, tmp5}) + tmp7 := lang.Apply(nil, []any{tmp6}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + tmp9 = v8 + } else { + tmp9 = lang.NewList() + } + tmp4 = tmp9 + } // end let + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "or__0__auto__" + tmp6 := checkDerefVar(var_glojure_DOT_core_map) + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v8 := args[0] + _ = v8 + tmp9 := lang.Apply(nil, []any{v8}) + return tmp9 + }) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2661), kw_column, int(17), kw_end_DASH_line, int(2661), kw_end_DASH_column, int(41)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp10 := checkDerefVar(var_glojure_DOT_core_cons) + tmp11 := lang.Apply(tmp10, []any{v3, v4}) + tmp12 := lang.Apply(tmp6, []any{tmp9, tmp11}) + tmp13 := lang.Apply(nil, []any{v2, tmp12}) + tmp14 := lang.Apply(nil, []any{tmp13}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + if lang.IsTruthy(v15) { + tmp16 = v15 + } else { + tmp16 = lang.NewList() + } + tmp5 = tmp16 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_sequence = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_sequence.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // setup-reference + { + tmp0 := sym_setup_DASH_reference.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(2043), kw_column, int(7), kw_end_DASH_line, int(2044), kw_end_DASH_column, int(17), kw_arglists, lang.NewList(lang.NewVector(sym_r, sym_options)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "opts" + tmp5 := checkDerefVar(var_glojure_DOT_core_apply) + tmp6 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp7 := lang.Apply(tmp5, []any{tmp6, v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + tmp10 := lang.Apply(kw_meta, []any{v8}) + if lang.IsTruthy(tmp10) { + tmp11 := lang.Apply(kw_meta, []any{v8}) + tmp12, _ := lang.FieldOrMethod(v2, "ResetMeta") + if reflect.TypeOf(tmp12).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ResetMeta is not a function"))) + } + tmp13 := lang.Apply(tmp12, []any{tmp11}) + tmp9 = tmp13 + } else { + } + _ = tmp9 + var tmp14 any + tmp15 := lang.Apply(kw_validator, []any{v8}) + if lang.IsTruthy(tmp15) { + tmp16 := lang.Apply(kw_validator, []any{v8}) + tmp17, _ := lang.FieldOrMethod(v2, "setValidator") + if reflect.TypeOf(tmp17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setValidator is not a function"))) + } + tmp18 := lang.Apply(tmp17, []any{tmp16}) + tmp14 = tmp18 + } else { + } + _ = tmp14 + tmp4 = v2 + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_setup_DASH_reference = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_setup_DASH_reference.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // shift-mask + { + tmp0 := sym_shift_DASH_mask.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6598), kw_column, int(8), kw_end_DASH_line, int(6598), kw_end_DASH_column, int(17), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_shift, sym_mask, sym_x)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_bit_DASH_and) + tmp6 := checkDerefVar(var_glojure_DOT_core_bit_DASH_shift_DASH_right) + tmp7 := lang.Apply(tmp6, []any{v4, v2}) + tmp8 := lang.Apply(tmp5, []any{tmp7, v3}) + return tmp8 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_shift_DASH_mask = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_shift_DASH_mask.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // sort + { + tmp0 := sym_sort.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll), lang.NewVector(sym_comp, sym_coll)), kw_doc, "Returns a sorted sequence of the items in coll. If no comparator is\n supplied, uses compare. comparator must implement\n java.util.Comparator. Guaranteed to be stable: equal elements will\n not be reordered. If coll is a Java array, it will be modified. To\n avoid this, sort a copy of the array.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3085), kw_end_DASH_line, int(3085))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_sort) + tmp4 := checkDerefVar(var_glojure_DOT_core_compare) + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + var tmp7 any + { // let + // let binding "a" + tmp8 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) + tmp9 := lang.Apply(tmp8, []any{v3}) + var v10 any = tmp9 + _ = v10 + tmp11 := lang.Apply(lang.SortSlice, []any{v10, v2}) + _ = tmp11 + tmp12 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := lang.Apply(tmp13, []any{v10}) + tmp15 := checkDerefVar(var_glojure_DOT_core_meta) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp7 = tmp17 + } // end let + tmp4 = tmp7 + } else { + tmp4 = lang.NewList() + } + return tmp4 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_sort = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_sort.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // sort-by + { + tmp0 := sym_sort_DASH_by.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_keyfn, sym_coll), lang.NewVector(sym_keyfn, sym_comp, sym_coll)), kw_doc, "Returns a sorted sequence of the items in coll, where the sort\n order is determined by comparing (keyfn item). If no comparator is\n supplied, uses compare. comparator must implement\n java.util.Comparator. Guaranteed to be stable: equal elements will\n not be reordered. If coll is a Java array, it will be modified. To\n avoid this, sort a copy of the array.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(3102), kw_end_DASH_line, int(3102))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_sort_DASH_by) + tmp5 := checkDerefVar(var_glojure_DOT_core_compare) + tmp6 := lang.Apply(tmp4, []any{v2, tmp5, v3}) + return tmp6 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_sort) + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + tmp9 := lang.Apply(v2, []any{v7}) + tmp10 := lang.Apply(v2, []any{v8}) + tmp11 := lang.Apply(v3, []any{tmp9, tmp10}) + return tmp11 + }) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3114), kw_column, int(10), kw_end_DASH_line, int(3114), kw_end_DASH_column, int(46)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp9 := lang.Apply(tmp5, []any{tmp8, v4}) + return tmp9 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_sort_DASH_by = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_sort_DASH_by.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // spit + { + tmp0 := sym_spit.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_content, sym__AMP_, sym_options)), kw_doc, "Opposite of slurp. Opens f with writer, writes content, then\n closes f. Options passed to glojure.java.io/writer.", kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(6994), kw_end_DASH_line, int(6994))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "w" + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := lang.Apply(tmp6, []any{nil, v2, v4}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + func() { + defer func() { + tmp10, ok := lang.FieldOrMethod(v8, "close") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "close"))) + } + var tmp11 any + switch reflect.TypeOf(tmp10).Kind() { + case reflect.Func: + tmp11 = lang.Apply(tmp10, nil) + default: + tmp11 = tmp10 + } + _ = tmp11 + }() + tmp12 := checkDerefVar(var_glojure_DOT_core_str) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(lang.WriteWriter, []any{v8, tmp13}) + tmp9 = tmp14 + }() + tmp5 = tmp9 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_spit = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_spit.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // strip-ns + { + tmp0 := sym_strip_DASH_ns.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(255), kw_column, int(8), kw_end_DASH_line, int(255), kw_end_DASH_column, int(15), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_named)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + tmp6 := checkDerefVar(var_glojure_DOT_core_symbol) + tmp7 := checkDerefVar(var_glojure_DOT_core_name) + tmp8 := lang.Apply(tmp7, []any{v2}) + tmp9 := lang.Apply(tmp6, []any{nil, tmp8}) + tmp3 = tmp9 + } else { + tmp10 := checkDerefVar(var_glojure_DOT_core_keyword) + tmp11 := checkDerefVar(var_glojure_DOT_core_name) + tmp12 := lang.Apply(tmp11, []any{v2}) + tmp13 := lang.Apply(tmp10, []any{nil, tmp12}) + tmp3 = tmp13 + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_strip_DASH_ns = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_strip_DASH_ns.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // subseq + { + tmp0 := sym_subseq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_sc, sym_test, sym_key), lang.NewVector(sym_sc, sym_start_DASH_test, sym_start_DASH_key, sym_end_DASH_test, sym_end_DASH_key)), kw_doc, "sc must be a sorted collection, test(s) one of <, <=, > or\n >=. Returns a seq of those entries with keys ek for\n which (test (.. sc comparator (compare ek key)) 0) is true", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(5133), kw_end_DASH_line, int(5133))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + { // let + // let binding "include" + tmp6 := checkDerefVar(var_glojure_DOT_core_mk_DASH_bound_DASH_fn) + tmp7 := lang.Apply(tmp6, []any{v2, v3, v4}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core__GT_) + tmp11 := checkDerefVar(var_glojure_DOT_core__GT__EQ_) + tmp12 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{tmp10, tmp11})) + tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5141), kw_column, int(11), kw_end_DASH_line, int(5141), kw_end_DASH_column, int(17)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp15 := lang.Apply(tmp14, []any{v3}) + if lang.IsTruthy(tmp15) { + var tmp16 any + { // let + // let binding "temp__0__auto__" + tmp17, _ := lang.FieldOrMethod(v2, "seqFrom") + if reflect.TypeOf(tmp17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("seqFrom is not a function"))) + } + tmp18 := lang.Apply(tmp17, []any{v4, true}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + var tmp21 any + { // let + // let binding "vec__759" + var v22 any = v19 + _ = v22 + // let binding "e" + tmp23 := checkDerefVar(var_glojure_DOT_core_nth) + tmp24 := lang.Apply(tmp23, []any{v22, int64(0), nil}) + var v25 any = tmp24 + _ = v25 + // let binding "s" + var v26 any = v22 + _ = v26 + var tmp27 any + tmp28 := lang.Apply(v8, []any{v25}) + if lang.IsTruthy(tmp28) { + tmp27 = v26 + } else { + tmp29 := checkDerefVar(var_glojure_DOT_core_next) + tmp30 := lang.Apply(tmp29, []any{v26}) + tmp27 = tmp30 + } + tmp21 = tmp27 + } // end let + tmp20 = tmp21 + } else { + } + tmp16 = tmp20 + } // end let + tmp9 = tmp16 + } else { + tmp17 := checkDerefVar(var_glojure_DOT_core_take_DASH_while) + tmp18, _ := lang.FieldOrMethod(v2, "seq") + if reflect.TypeOf(tmp18).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("seq is not a function"))) + } + tmp19 := lang.Apply(tmp18, []any{true}) + tmp20 := lang.Apply(tmp17, []any{v8, tmp19}) + tmp9 = tmp20 + } + tmp5 = tmp9 + } // end let + return tmp5 + case 5: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + var tmp7 any + { // let + // let binding "temp__0__auto__" + tmp8, _ := lang.FieldOrMethod(v2, "seqFrom") + if reflect.TypeOf(tmp8).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("seqFrom is not a function"))) + } + tmp9 := lang.Apply(tmp8, []any{v4, true}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + if lang.IsTruthy(v10) { + var tmp12 any + { // let + // let binding "vec__762" + var v13 any = v10 + _ = v13 + // let binding "e" + tmp14 := checkDerefVar(var_glojure_DOT_core_nth) + tmp15 := lang.Apply(tmp14, []any{v13, int64(0), nil}) + var v16 any = tmp15 + _ = v16 + // let binding "s" + var v17 any = v13 + _ = v17 + tmp18 := checkDerefVar(var_glojure_DOT_core_take_DASH_while) + tmp19 := checkDerefVar(var_glojure_DOT_core_mk_DASH_bound_DASH_fn) + tmp20 := lang.Apply(tmp19, []any{v2, v5, v6}) + var tmp21 any + tmp22 := checkDerefVar(var_glojure_DOT_core_mk_DASH_bound_DASH_fn) + tmp23 := lang.Apply(tmp22, []any{v2, v3, v4}) + tmp24 := lang.Apply(tmp23, []any{v16}) + if lang.IsTruthy(tmp24) { + tmp21 = v17 + } else { + tmp25 := checkDerefVar(var_glojure_DOT_core_next) + tmp26 := lang.Apply(tmp25, []any{v17}) + tmp21 = tmp26 + } + tmp27 := lang.Apply(tmp18, []any{tmp20, tmp21}) + tmp12 = tmp27 + } // end let + tmp11 = tmp12 + } else { + } + tmp7 = tmp11 + } // end let + return tmp7 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_subseq = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_subseq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // supers + { + tmp0 := sym_supers.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_class)), kw_doc, "Returns the immediate and indirect superclasses and interfaces of c, if any", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(5532), kw_end_DASH_line, int(5532))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "ret" + tmp4 := checkDerefVar(var_glojure_DOT_core_set) + tmp5 := checkDerefVar(var_glojure_DOT_core_bases) + tmp6 := lang.Apply(tmp5, []any{v2}) + tmp7 := lang.Apply(tmp4, []any{tmp6}) + var v8 any = tmp7 + _ = v8 + // let binding "cs" + var v9 any = v8 + _ = v9 + for { + var tmp10 any + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := lang.Apply(tmp11, []any{v9}) + if lang.IsTruthy(tmp12) { + var tmp13 any + { // let + // let binding "c" + tmp14 := checkDerefVar(var_glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v9}) + var v16 any = tmp15 + _ = v16 + // let binding "bs" + tmp17 := checkDerefVar(var_glojure_DOT_core_bases) + tmp18 := lang.Apply(tmp17, []any{v16}) + var v19 any = tmp18 + _ = v19 + tmp21 := checkDerefVar(var_glojure_DOT_core_into1) + tmp22 := lang.Apply(tmp21, []any{v8, v19}) + var tmp20 any = tmp22 + tmp24 := checkDerefVar(var_glojure_DOT_core_into1) + tmp25 := checkDerefVar(var_glojure_DOT_core_disj) + tmp26 := lang.Apply(tmp25, []any{v9, v16}) + tmp27 := lang.Apply(tmp24, []any{tmp26, v19}) + var tmp23 any = tmp27 + v8 = tmp20 + v9 = tmp23 + continue + } // end let + tmp10 = tmp13 + } else { + tmp14 := checkDerefVar(var_glojure_DOT_core_not_DASH_empty) + tmp15 := lang.Apply(tmp14, []any{v8}) + tmp10 = tmp15 + } + tmp3 = tmp10 + break + } + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_supers = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_supers.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // sync + { + tmp0 := sym_sync.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_flags_DASH_ignored_DASH_for_DASH_now, sym__AMP_, sym_body)), kw_doc, "transaction-flags => TBD, pass nil for now\n\n Runs the exprs (in an implicit do) in a transaction that encompasses\n exprs and any nested calls. Starts a transaction if none is already\n running on this thread. Any uncaught exception will abort the\n transaction and flow out of sync. The exprs may be run more than\n once, but any effects on Refs will be atomic.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(11), kw_line, int(2490), kw_end_DASH_line, int(2490))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym__DOT_}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_LockingTransaction}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_RunInTransaction}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{sym_glojure_DOT_core_SLASH_fn}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := checkDerefVar(var_glojure_DOT_core_apply) + tmp24 := checkDerefVar(var_glojure_DOT_core_vector) + tmp25 := checkDerefVar(var_glojure_DOT_core_seq) + tmp26 := checkDerefVar(var_glojure_DOT_core_concat) + tmp27 := lang.Apply(tmp26, nil) + tmp28 := lang.Apply(tmp25, []any{tmp27}) + tmp29 := lang.Apply(tmp23, []any{tmp24, tmp28}) + tmp30 := lang.Apply(tmp22, []any{tmp29}) + tmp31 := lang.Apply(tmp19, []any{tmp21, tmp30, v5}) + tmp32 := lang.Apply(tmp18, []any{tmp31}) + tmp33 := lang.Apply(tmp17, []any{tmp32}) + tmp34 := lang.Apply(tmp14, []any{tmp16, tmp33}) + tmp35 := lang.Apply(tmp13, []any{tmp34}) + tmp36 := lang.Apply(tmp12, []any{tmp35}) + tmp37 := lang.Apply(tmp7, []any{tmp9, tmp11, tmp36}) + tmp38 := lang.Apply(tmp6, []any{tmp37}) + return tmp38 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_sync = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_sync.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // take + { + tmp0 := sym_take.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n), lang.NewVector(sym_n, sym_coll)), kw_doc, "Returns a lazy sequence of the first n items in coll, or all items if\n there are fewer than n. Returns a stateful transducer when\n no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(2853), kw_end_DASH_line, int(2853))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 any + { // let + // let binding "nv" + tmp6 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) + tmp7 := lang.Apply(tmp6, []any{v2}) + var v8 any = tmp7 + _ = v8 + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp10 := lang.Apply(v4, nil) + return tmp10 + case 1: + v10 := args[0] + _ = v10 + tmp11 := lang.Apply(v4, []any{v10}) + return tmp11 + case 2: + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + var tmp12 any + { // let + // let binding "n" + tmp13 := checkDerefVar(var_glojure_DOT_core_deref) + tmp14 := lang.Apply(tmp13, []any{v8}) + var v15 any = tmp14 + _ = v15 + // let binding "nn" + tmp16 := checkDerefVar(var_glojure_DOT_core_dec) + tmp17, ok := lang.FieldOrMethod(v8, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "Deref"))) + } + var tmp18 any + switch reflect.TypeOf(tmp17).Kind() { + case reflect.Func: + tmp18 = lang.Apply(tmp17, nil) + default: + tmp18 = tmp17 + } + tmp19 := lang.Apply(tmp16, []any{tmp18}) + tmp20, _ := lang.FieldOrMethod(v8, "reset") + if reflect.TypeOf(tmp20).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) + } + tmp21 := lang.Apply(tmp20, []any{tmp19}) + var v22 any = tmp21 + _ = v22 + // let binding "result" + var tmp23 any + tmp24 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp25 := lang.Apply(tmp24, []any{v15}) + if lang.IsTruthy(tmp25) { + tmp26 := lang.Apply(v4, []any{v10, v11}) + tmp23 = tmp26 + } else { + tmp23 = v10 + } + var v27 any = tmp23 + _ = v27 + var tmp28 any + tmp29 := checkDerefVar(var_glojure_DOT_core_not) + tmp30 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp31 := lang.Apply(tmp30, []any{v22}) + tmp32 := lang.Apply(tmp29, []any{tmp31}) + if lang.IsTruthy(tmp32) { + tmp33 := checkDerefVar(var_glojure_DOT_core_ensure_DASH_reduced) + tmp34 := lang.Apply(tmp33, []any{v27}) + tmp28 = tmp34 + } else { + tmp28 = v27 + } + tmp12 = tmp28 + } // end let + return tmp12 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2862), kw_column, int(10), kw_end_DASH_line, int(2873), kw_end_DASH_column, int(28)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp5 = tmp11 + } // end let + return tmp5 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2860), kw_column, int(6), kw_end_DASH_line, int(2873), kw_end_DASH_column, int(30)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp7 := lang.Apply(tmp6, []any{v2}) + if lang.IsTruthy(tmp7) { + var tmp8 any + { // let + // let binding "temp__0__auto__" + tmp9 := checkDerefVar(var_glojure_DOT_core_seq) + tmp10 := lang.Apply(tmp9, []any{v3}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + var tmp13 any + { // let + // let binding "s" + var v14 any = v11 + _ = v14 + tmp15 := checkDerefVar(var_glojure_DOT_core_cons) + tmp16 := checkDerefVar(var_glojure_DOT_core_first) + tmp17 := lang.Apply(tmp16, []any{v14}) + tmp18 := checkDerefVar(var_glojure_DOT_core_take) + tmp19 := checkDerefVar(var_glojure_DOT_core_dec) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(var_glojure_DOT_core_rest) + tmp22 := lang.Apply(tmp21, []any{v14}) + tmp23 := lang.Apply(tmp18, []any{tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp17, tmp23}) + tmp13 = tmp24 + } // end let + tmp12 = tmp13 + } else { + } + tmp8 = tmp12 + } // end let + tmp5 = tmp8 + } else { + } + return tmp5 + }) + tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_take = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_take.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // take-last + { + tmp0 := sym_take_DASH_last.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n, sym_coll)), kw_doc, "Returns a seq of the last n items in coll. Depending on the type\n of coll may be no better than linear time. For vectors, see also subvec.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(2939), kw_end_DASH_line, int(2939))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "s" + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := lang.Apply(tmp5, []any{v3}) + var v7 any = tmp6 + _ = v7 + // let binding "lead" + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_drop) + tmp10 := lang.Apply(tmp9, []any{v2, v3}) + tmp11 := lang.Apply(tmp8, []any{tmp10}) + var v12 any = tmp11 + _ = v12 + for { + var tmp13 any + if lang.IsTruthy(v12) { + tmp15 := checkDerefVar(var_glojure_DOT_core_next) + tmp16 := lang.Apply(tmp15, []any{v7}) + var tmp14 any = tmp16 + tmp18 := checkDerefVar(var_glojure_DOT_core_next) + tmp19 := lang.Apply(tmp18, []any{v12}) + var tmp17 any = tmp19 + v7 = tmp14 + v12 = tmp17 + continue + } else { + tmp13 = v7 + } + tmp4 = tmp13 + break + } + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_take_DASH_last = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_take_DASH_last.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // take-nth + { + tmp0 := sym_take_DASH_nth.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n), lang.NewVector(sym_n, sym_coll)), kw_doc, "Returns a lazy seq of every nth item in coll. Returns a stateful\n transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(4287), kw_end_DASH_line, int(4287))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 any + { // let + // let binding "iv" + tmp6 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) + tmp7 := lang.Apply(tmp6, []any{int64(-1)}) + var v8 any = tmp7 + _ = v8 + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp10 := lang.Apply(v4, nil) + return tmp10 + case 1: + v10 := args[0] + _ = v10 + tmp11 := lang.Apply(v4, []any{v10}) + return tmp11 + case 2: + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + var tmp12 any + { // let + // let binding "i" + tmp13 := checkDerefVar(var_glojure_DOT_core_inc) + tmp14, ok := lang.FieldOrMethod(v8, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "Deref"))) + } + var tmp15 any + switch reflect.TypeOf(tmp14).Kind() { + case reflect.Func: + tmp15 = lang.Apply(tmp14, nil) + default: + tmp15 = tmp14 + } + tmp16 := lang.Apply(tmp13, []any{tmp15}) + tmp17, _ := lang.FieldOrMethod(v8, "reset") + if reflect.TypeOf(tmp17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) + } + tmp18 := lang.Apply(tmp17, []any{tmp16}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + tmp21 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) + tmp22 := checkDerefVar(var_glojure_DOT_core_rem) + tmp23 := lang.Apply(tmp22, []any{v19, v2}) + tmp24 := lang.Apply(tmp21, []any{tmp23}) + if lang.IsTruthy(tmp24) { + tmp25 := lang.Apply(v4, []any{v10, v11}) + tmp20 = tmp25 + } else { + tmp20 = v10 + } + tmp12 = tmp20 + } // end let + return tmp12 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4295), kw_column, int(10), kw_end_DASH_line, int(4302), kw_end_DASH_column, int(28)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp5 = tmp11 + } // end let + return tmp5 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4293), kw_column, int(6), kw_end_DASH_line, int(4302), kw_end_DASH_column, int(30)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp5 any + { // let + // let binding "temp__0__auto__" + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := lang.Apply(tmp6, []any{v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + var tmp10 any + { // let + // let binding "s" + var v11 any = v8 + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_cons) + tmp13 := checkDerefVar(var_glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v11}) + tmp15 := checkDerefVar(var_glojure_DOT_core_take_DASH_nth) + tmp16 := checkDerefVar(var_glojure_DOT_core_drop) + tmp17 := lang.Apply(tmp16, []any{v2, v11}) + tmp18 := lang.Apply(tmp15, []any{v2, tmp17}) + tmp19 := lang.Apply(tmp12, []any{tmp14, tmp18}) + tmp10 = tmp19 + } // end let + tmp9 = tmp10 + } else { + } + tmp5 = tmp9 + } // end let + return tmp5 + }) + tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_take_DASH_nth = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_take_DASH_nth.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // throw-if + { + tmp0 := sym_throw_DASH_if.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred, sym_fmt, sym__AMP_, sym_args)), kw_doc, "Throws a CompilerException with a message if pred is true", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(8), kw_line, int(5832), kw_end_DASH_line, int(5832), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + if lang.IsTruthy(v2) { + var tmp6 any + { // let + // let binding "message" + tmp7 := checkDerefVar(var_glojure_DOT_core_apply) + tmp8 := checkDerefVar(var_glojure_DOT_core_format) + tmp9 := lang.Apply(tmp7, []any{tmp8, v3, v4}) + var v10 any = tmp9 + _ = v10 + // let binding "exception" + tmp11 := lang.Apply(lang.NewError, []any{v10}) + var v12 any = tmp11 + _ = v12 + // let binding "raw-trace" + tmp13, ok := lang.FieldOrMethod(v12, "getStackTrace") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v12, "getStackTrace"))) + } + var tmp14 any + switch reflect.TypeOf(tmp13).Kind() { + case reflect.Func: + tmp14 = lang.Apply(tmp13, nil) + default: + tmp14 = tmp13 + } + var v15 any = tmp14 + _ = v15 + // let binding "boring?" + var tmp16 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v17 := args[0] + _ = v17 + tmp18 := checkDerefVar(var_glojure_DOT_core_not_EQ_) + tmp19, ok := lang.FieldOrMethod(v17, "getMethodName") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v17, "getMethodName"))) + } + var tmp20 any + switch reflect.TypeOf(tmp19).Kind() { + case reflect.Func: + tmp20 = lang.Apply(tmp19, nil) + default: + tmp20 = tmp19 + } + tmp21 := lang.Apply(tmp18, []any{tmp20, "doInvoke"}) + return tmp21 + }) + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5839), kw_column, int(19), kw_end_DASH_line, int(5839), kw_end_DASH_column, int(74)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v19 any = tmp18 + _ = v19 + // let binding "trace" + tmp20 := checkDerefVar(var_glojure_DOT_core_into_DASH_array) + tmp21 := checkDerefVar(var_glojure_DOT_core_drop) + tmp22 := checkDerefVar(var_glojure_DOT_core_drop_DASH_while) + tmp23 := lang.Apply(tmp22, []any{v19, v15}) + tmp24 := lang.Apply(tmp21, []any{int64(2), tmp23}) + tmp25 := lang.Apply(tmp20, []any{nil, tmp24}) + var v26 any = tmp25 + _ = v26 + tmp27, _ := lang.FieldOrMethod(v12, "setStackTrace") + if reflect.TypeOf(tmp27).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setStackTrace is not a function"))) + } + tmp28 := lang.Apply(tmp27, []any{v26}) + _ = tmp28 + tmp29 := checkDerefVar(var_glojure_DOT_core__STAR_file_STAR_) + tmp30, ok := lang.FieldOrMethod(nil, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "Deref"))) + } + var tmp31 any + switch reflect.TypeOf(tmp30).Kind() { + case reflect.Func: + tmp31 = lang.Apply(tmp30, nil) + default: + tmp31 = tmp30 + } + tmp32, ok := lang.FieldOrMethod(nil, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "Deref"))) + } + var tmp33 any + switch reflect.TypeOf(tmp32).Kind() { + case reflect.Func: + tmp33 = lang.Apply(tmp32, nil) + default: + tmp33 = tmp32 + } + tmp34 := lang.Apply(lang.NewCompilerError, []any{tmp29, tmp31, tmp33, v12}) + panic(tmp34) + } // end let + tmp5 = tmp6 + } else { + } + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_throw_DASH_if = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_throw_DASH_if.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // time + { + tmp0 := sym_time.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_expr)), kw_doc, "Evaluates expr and prints the time it took. Returns the value of\n expr.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(11), kw_line, int(3885), kw_end_DASH_line, int(3885))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym_glojure_DOT_core_SLASH_let}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := checkDerefVar(var_glojure_DOT_core_apply) + tmp11 := checkDerefVar(var_glojure_DOT_core_vector) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_start__0__auto__}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := checkDerefVar(var_glojure_DOT_core_seq) + tmp18 := checkDerefVar(var_glojure_DOT_core_concat) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{sym__DOT_UnixNano}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := checkDerefVar(var_glojure_DOT_core_seq) + tmp23 := checkDerefVar(var_glojure_DOT_core_concat) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{sym_time_DOT_Now}) + tmp26 := lang.Apply(tmp23, []any{tmp25}) + tmp27 := lang.Apply(tmp22, []any{tmp26}) + tmp28 := lang.Apply(tmp21, []any{tmp27}) + tmp29 := lang.Apply(tmp18, []any{tmp20, tmp28}) + tmp30 := lang.Apply(tmp17, []any{tmp29}) + tmp31 := lang.Apply(tmp16, []any{tmp30}) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := lang.Apply(tmp32, []any{sym_ret__1__auto__}) + tmp34 := checkDerefVar(var_glojure_DOT_core_list) + tmp35 := lang.Apply(tmp34, []any{v4}) + tmp36 := lang.Apply(tmp13, []any{tmp15, tmp31, tmp33, tmp35}) + tmp37 := lang.Apply(tmp12, []any{tmp36}) + tmp38 := lang.Apply(tmp10, []any{tmp11, tmp37}) + tmp39 := lang.Apply(tmp9, []any{tmp38}) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := checkDerefVar(var_glojure_DOT_core_seq) + tmp42 := checkDerefVar(var_glojure_DOT_core_concat) + tmp43 := checkDerefVar(var_glojure_DOT_core_list) + tmp44 := lang.Apply(tmp43, []any{sym_glojure_DOT_core_SLASH_prn}) + tmp45 := checkDerefVar(var_glojure_DOT_core_list) + tmp46 := checkDerefVar(var_glojure_DOT_core_seq) + tmp47 := checkDerefVar(var_glojure_DOT_core_concat) + tmp48 := checkDerefVar(var_glojure_DOT_core_list) + tmp49 := lang.Apply(tmp48, []any{sym_glojure_DOT_core_SLASH_str}) + tmp50 := checkDerefVar(var_glojure_DOT_core_list) + tmp51 := lang.Apply(tmp50, []any{"Elapsed time: "}) + tmp52 := checkDerefVar(var_glojure_DOT_core_list) + tmp53 := checkDerefVar(var_glojure_DOT_core_seq) + tmp54 := checkDerefVar(var_glojure_DOT_core_concat) + tmp55 := checkDerefVar(var_glojure_DOT_core_list) + tmp56 := lang.Apply(tmp55, []any{sym_glojure_DOT_core_SLASH__SLASH_}) + tmp57 := checkDerefVar(var_glojure_DOT_core_list) + tmp58 := checkDerefVar(var_glojure_DOT_core_seq) + tmp59 := checkDerefVar(var_glojure_DOT_core_concat) + tmp60 := checkDerefVar(var_glojure_DOT_core_list) + tmp61 := lang.Apply(tmp60, []any{sym_glojure_DOT_core_SLASH_double}) + tmp62 := checkDerefVar(var_glojure_DOT_core_list) + tmp63 := checkDerefVar(var_glojure_DOT_core_seq) + tmp64 := checkDerefVar(var_glojure_DOT_core_concat) + tmp65 := checkDerefVar(var_glojure_DOT_core_list) + tmp66 := lang.Apply(tmp65, []any{sym_glojure_DOT_core_SLASH__DASH_}) + tmp67 := checkDerefVar(var_glojure_DOT_core_list) + tmp68 := checkDerefVar(var_glojure_DOT_core_seq) + tmp69 := checkDerefVar(var_glojure_DOT_core_concat) + tmp70 := checkDerefVar(var_glojure_DOT_core_list) + tmp71 := lang.Apply(tmp70, []any{sym__DOT_UnixNano}) + tmp72 := checkDerefVar(var_glojure_DOT_core_list) + tmp73 := checkDerefVar(var_glojure_DOT_core_seq) + tmp74 := checkDerefVar(var_glojure_DOT_core_concat) + tmp75 := checkDerefVar(var_glojure_DOT_core_list) + tmp76 := lang.Apply(tmp75, []any{sym_time_DOT_Now}) + tmp77 := lang.Apply(tmp74, []any{tmp76}) + tmp78 := lang.Apply(tmp73, []any{tmp77}) + tmp79 := lang.Apply(tmp72, []any{tmp78}) + tmp80 := lang.Apply(tmp69, []any{tmp71, tmp79}) + tmp81 := lang.Apply(tmp68, []any{tmp80}) + tmp82 := lang.Apply(tmp67, []any{tmp81}) + tmp83 := checkDerefVar(var_glojure_DOT_core_list) + tmp84 := lang.Apply(tmp83, []any{sym_start__0__auto__}) + tmp85 := lang.Apply(tmp64, []any{tmp66, tmp82, tmp84}) + tmp86 := lang.Apply(tmp63, []any{tmp85}) + tmp87 := lang.Apply(tmp62, []any{tmp86}) + tmp88 := lang.Apply(tmp59, []any{tmp61, tmp87}) + tmp89 := lang.Apply(tmp58, []any{tmp88}) + tmp90 := lang.Apply(tmp57, []any{tmp89}) + tmp91 := checkDerefVar(var_glojure_DOT_core_list) + tmp92 := lang.Apply(tmp91, []any{float64(1e+06)}) + tmp93 := lang.Apply(tmp54, []any{tmp56, tmp90, tmp92}) + tmp94 := lang.Apply(tmp53, []any{tmp93}) + tmp95 := lang.Apply(tmp52, []any{tmp94}) + tmp96 := checkDerefVar(var_glojure_DOT_core_list) + tmp97 := lang.Apply(tmp96, []any{" msecs"}) + tmp98 := lang.Apply(tmp47, []any{tmp49, tmp51, tmp95, tmp97}) + tmp99 := lang.Apply(tmp46, []any{tmp98}) + tmp100 := lang.Apply(tmp45, []any{tmp99}) + tmp101 := lang.Apply(tmp42, []any{tmp44, tmp100}) + tmp102 := lang.Apply(tmp41, []any{tmp101}) + tmp103 := lang.Apply(tmp40, []any{tmp102}) + tmp104 := checkDerefVar(var_glojure_DOT_core_list) + tmp105 := lang.Apply(tmp104, []any{sym_ret__1__auto__}) + tmp106 := lang.Apply(tmp6, []any{tmp8, tmp39, tmp103, tmp105}) + tmp107 := lang.Apply(tmp5, []any{tmp106}) + return tmp107 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_time = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_time.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // trampoline + { + tmp0 := sym_trampoline.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym__AMP_, sym_args)), kw_doc, "trampoline can be used to convert algorithms requiring mutual\n recursion without stack consumption. Calls f with supplied args, if\n any. If f returns a fn, calls that fn with no arguments, and\n continues to repeat, until the return value is not a fn, then\n returns that non-fn value. Note that if you want to return a fn as a\n final value, you must wrap it in some data structure and unpack it\n after trampoline returns.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(6293), kw_end_DASH_line, int(6293))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + recur_loop_2613: + var tmp3 any + { // let + // let binding "ret" + tmp4 := lang.Apply(v2, nil) + var v5 any = tmp4 + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_fn_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v5}) + if lang.IsTruthy(tmp8) { + var tmp9 any = v5 + v2 = tmp9 + goto recur_loop_2613 + } else { + tmp6 = v5 + } + tmp3 = tmp6 + } // end let + return tmp3 + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_trampoline) + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := lang.Apply(tmp6, []any{v2, v3}) + return tmp7 + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6309), kw_column, int(18), kw_end_DASH_line, int(6309), kw_end_DASH_column, int(32)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp8 := lang.Apply(tmp4, []any{tmp7}) + return tmp8 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_trampoline = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_trampoline.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // update + { + tmp0 := sym_update.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m, sym_k, sym_f), lang.NewVector(sym_m, sym_k, sym_f, sym_x), lang.NewVector(sym_m, sym_k, sym_f, sym_x, sym_y), lang.NewVector(sym_m, sym_k, sym_f, sym_x, sym_y, sym_z), lang.NewVector(sym_m, sym_k, sym_f, sym_x, sym_y, sym_z, sym__AMP_, sym_more)), kw_doc, "'Updates' a value in an associative structure, where k is a\n key and f is a function that will take the old value\n and any supplied args and return the new value, and returns a new\n structure. If the key does not exist, nil is passed as the old value.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(6174), kw_end_DASH_line, int(6174))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp6 := checkDerefVar(var_glojure_DOT_core_get) + tmp7 := lang.Apply(tmp6, []any{v2, v3}) + tmp8 := lang.Apply(v4, []any{tmp7}) + tmp9 := lang.Apply(tmp5, []any{v2, v3, tmp8}) + return tmp9 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp7 := checkDerefVar(var_glojure_DOT_core_get) + tmp8 := lang.Apply(tmp7, []any{v2, v3}) + tmp9 := lang.Apply(v4, []any{tmp8, v5}) + tmp10 := lang.Apply(tmp6, []any{v2, v3, tmp9}) + return tmp10 + case 5: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp8 := checkDerefVar(var_glojure_DOT_core_get) + tmp9 := lang.Apply(tmp8, []any{v2, v3}) + tmp10 := lang.Apply(v4, []any{tmp9, v5, v6}) + tmp11 := lang.Apply(tmp7, []any{v2, v3, tmp10}) + return tmp11 + case 6: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + v7 := args[5] + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp9 := checkDerefVar(var_glojure_DOT_core_get) + tmp10 := lang.Apply(tmp9, []any{v2, v3}) + tmp11 := lang.Apply(v4, []any{tmp10, v5, v6, v7}) + tmp12 := lang.Apply(tmp8, []any{v2, v3, tmp11}) + return tmp12 + default: + checkArity(args, 6) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + v7 := args[5] + _ = v7 + var v8 any = lang.NewList(args[6:]...) + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp10 := checkDerefVar(var_glojure_DOT_core_apply) + tmp11 := checkDerefVar(var_glojure_DOT_core_get) + tmp12 := lang.Apply(tmp11, []any{v2, v3}) + tmp13 := lang.Apply(tmp10, []any{v4, tmp12, v5, v6, v7, v8}) + tmp14 := lang.Apply(tmp9, []any{v2, v3, tmp13}) + return tmp14 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_update = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_update.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // update-in + { + tmp0 := sym_update_DASH_in.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m, sym_ks, sym_f, sym__AMP_, sym_args)), kw_doc, "'Updates' a value in a nested associative structure, where ks is a\n sequence of keys and f is a function that will take the old value\n and any supplied args and return the new value, and returns a new\n nested structure. If any levels do not exist, hash-maps will be\n created.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(6158), kw_end_DASH_line, int(6158))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "up" + var tmp7 lang.FnFunc + { // function up + var v8 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 4) + v9 := args[0] + _ = v9 + v10 := args[1] + _ = v10 + v11 := args[2] + _ = v11 + v12 := args[3] + _ = v12 + var tmp13 any + { // let + // let binding "vec__832" + var v14 any = v10 + _ = v14 + // let binding "seq__833" + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := lang.Apply(tmp15, []any{v14}) + var v17 any = tmp16 + _ = v17 + // let binding "first__834" + tmp18 := checkDerefVar(var_glojure_DOT_core_first) + tmp19 := lang.Apply(tmp18, []any{v17}) + var v20 any = tmp19 + _ = v20 + // let binding "seq__833" + tmp21 := checkDerefVar(var_glojure_DOT_core_next) + tmp22 := lang.Apply(tmp21, []any{v17}) + var v23 any = tmp22 + _ = v23 + // let binding "k" + var v24 any = v20 + _ = v24 + // let binding "ks" + var v25 any = v23 + _ = v25 + var tmp26 any + if lang.IsTruthy(v25) { + tmp27 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp28 := checkDerefVar(var_glojure_DOT_core_get) + tmp29 := lang.Apply(tmp28, []any{v9, v24}) + tmp30 := lang.Apply(v8, []any{tmp29, v25, v11, v12}) + tmp31 := lang.Apply(tmp27, []any{v9, v24, tmp30}) + tmp26 = tmp31 + } else { + tmp32 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp33 := checkDerefVar(var_glojure_DOT_core_apply) + tmp34 := checkDerefVar(var_glojure_DOT_core_get) + tmp35 := lang.Apply(tmp34, []any{v9, v24}) + tmp36 := lang.Apply(tmp33, []any{v11, tmp35, v12}) + tmp37 := lang.Apply(tmp32, []any{v9, v24, tmp36}) + tmp26 = tmp37 + } + tmp13 = tmp26 + } // end let + return tmp13 + }) + v8 = tmp7 + _ = v8 + } + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6167), kw_column, int(15), kw_end_DASH_line, int(6171), kw_end_DASH_column, int(59)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v10 any = tmp9 + _ = v10 + tmp11 := lang.Apply(v10, []any{v2, v3, v4, v5}) + tmp6 = tmp11 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_update_DASH_in = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_update_DASH_in.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // vary-meta + { + tmp0 := sym_vary_DASH_meta.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_obj, sym_f, sym__AMP_, sym_args)), kw_doc, "Returns an object of the same type and value as obj, with\n (apply f (meta obj) args) as its metadata.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(668), kw_end_DASH_line, int(668))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_meta) + tmp8 := lang.Apply(tmp7, []any{v2}) + tmp9 := lang.Apply(tmp6, []any{v3, tmp8, v4}) + tmp10 := lang.Apply(tmp5, []any{v2, tmp9}) + return tmp10 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_vary_DASH_meta = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_vary_DASH_meta.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // when-first + { + tmp0 := sym_when_DASH_first.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "bindings => x xs\n\n Roughly the same as (when (seq xs) (let [x (first xs)] body)) but xs is evaluated only once", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(11), kw_line, int(4622), kw_end_DASH_line, int(4622))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v4}) + if lang.IsTruthy(tmp8) { + } else { + tmp9 := checkDerefVar(var_glojure_DOT_core_str) + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp13 := checkDerefVar(var_glojure_DOT_core_meta) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(kw_line, []any{tmp14}) + tmp16 := lang.Apply(tmp9, []any{tmp11, " requires ", "a vector for its binding", " in ", tmp12, ":", tmp15}) + tmp17 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp16}) + panic(tmp17) + } + _ = tmp6 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp20 := checkDerefVar(var_glojure_DOT_core_count) + tmp21 := lang.Apply(tmp20, []any{v4}) + tmp22 := lang.Apply(tmp19, []any{int64(2), tmp21}) + if lang.IsTruthy(tmp22) { + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp27 := checkDerefVar(var_glojure_DOT_core_meta) + tmp28 := lang.Apply(tmp27, []any{v2}) + tmp29 := lang.Apply(kw_line, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp25, " requires ", "exactly 2 forms in binding vector", " in ", tmp26, ":", tmp29}) + tmp31 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp31) + } + _ = tmp18 + var tmp32 any + { // let + // let binding "vec__711" + var v33 any = v4 + _ = v33 + // let binding "x" + tmp34 := checkDerefVar(var_glojure_DOT_core_nth) + tmp35 := lang.Apply(tmp34, []any{v33, int64(0), nil}) + var v36 any = tmp35 + _ = v36 + // let binding "xs" + tmp37 := checkDerefVar(var_glojure_DOT_core_nth) + tmp38 := lang.Apply(tmp37, []any{v33, int64(1), nil}) + var v39 any = tmp38 + _ = v39 + tmp40 := checkDerefVar(var_glojure_DOT_core_seq) + tmp41 := checkDerefVar(var_glojure_DOT_core_concat) + tmp42 := checkDerefVar(var_glojure_DOT_core_list) + tmp43 := lang.Apply(tmp42, []any{sym_glojure_DOT_core_SLASH_when_DASH_let}) + tmp44 := checkDerefVar(var_glojure_DOT_core_list) + tmp45 := checkDerefVar(var_glojure_DOT_core_apply) + tmp46 := checkDerefVar(var_glojure_DOT_core_vector) + tmp47 := checkDerefVar(var_glojure_DOT_core_seq) + tmp48 := checkDerefVar(var_glojure_DOT_core_concat) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) + tmp50 := lang.Apply(tmp49, []any{sym_xs__0__auto__}) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := checkDerefVar(var_glojure_DOT_core_seq) + tmp53 := checkDerefVar(var_glojure_DOT_core_concat) + tmp54 := checkDerefVar(var_glojure_DOT_core_list) + tmp55 := lang.Apply(tmp54, []any{sym_glojure_DOT_core_SLASH_seq}) + tmp56 := checkDerefVar(var_glojure_DOT_core_list) + tmp57 := lang.Apply(tmp56, []any{v39}) + tmp58 := lang.Apply(tmp53, []any{tmp55, tmp57}) + tmp59 := lang.Apply(tmp52, []any{tmp58}) + tmp60 := lang.Apply(tmp51, []any{tmp59}) + tmp61 := lang.Apply(tmp48, []any{tmp50, tmp60}) + tmp62 := lang.Apply(tmp47, []any{tmp61}) + tmp63 := lang.Apply(tmp45, []any{tmp46, tmp62}) + tmp64 := lang.Apply(tmp44, []any{tmp63}) + tmp65 := checkDerefVar(var_glojure_DOT_core_list) + tmp66 := checkDerefVar(var_glojure_DOT_core_seq) + tmp67 := checkDerefVar(var_glojure_DOT_core_concat) + tmp68 := checkDerefVar(var_glojure_DOT_core_list) + tmp69 := lang.Apply(tmp68, []any{sym_glojure_DOT_core_SLASH_let}) + tmp70 := checkDerefVar(var_glojure_DOT_core_list) + tmp71 := checkDerefVar(var_glojure_DOT_core_apply) + tmp72 := checkDerefVar(var_glojure_DOT_core_vector) + tmp73 := checkDerefVar(var_glojure_DOT_core_seq) + tmp74 := checkDerefVar(var_glojure_DOT_core_concat) + tmp75 := checkDerefVar(var_glojure_DOT_core_list) + tmp76 := lang.Apply(tmp75, []any{v36}) + tmp77 := checkDerefVar(var_glojure_DOT_core_list) + tmp78 := checkDerefVar(var_glojure_DOT_core_seq) + tmp79 := checkDerefVar(var_glojure_DOT_core_concat) + tmp80 := checkDerefVar(var_glojure_DOT_core_list) + tmp81 := lang.Apply(tmp80, []any{sym_glojure_DOT_core_SLASH_first}) + tmp82 := checkDerefVar(var_glojure_DOT_core_list) + tmp83 := lang.Apply(tmp82, []any{sym_xs__0__auto__}) + tmp84 := lang.Apply(tmp79, []any{tmp81, tmp83}) + tmp85 := lang.Apply(tmp78, []any{tmp84}) + tmp86 := lang.Apply(tmp77, []any{tmp85}) + tmp87 := lang.Apply(tmp74, []any{tmp76, tmp86}) + tmp88 := lang.Apply(tmp73, []any{tmp87}) + tmp89 := lang.Apply(tmp71, []any{tmp72, tmp88}) + tmp90 := lang.Apply(tmp70, []any{tmp89}) + tmp91 := lang.Apply(tmp67, []any{tmp69, tmp90, v5}) + tmp92 := lang.Apply(tmp66, []any{tmp91}) + tmp93 := lang.Apply(tmp65, []any{tmp92}) + tmp94 := lang.Apply(tmp41, []any{tmp43, tmp64, tmp93}) + tmp95 := lang.Apply(tmp40, []any{tmp94}) + tmp32 = tmp95 + } // end let + return tmp32 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_when_DASH_first = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_when_DASH_first.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // when-let + { + tmp0 := sym_when_DASH_let.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "bindings => binding-form test\n\n When test is true, evaluates body with binding-form bound to the value of test", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(11), kw_line, int(1859), kw_end_DASH_line, int(1859))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v4}) + if lang.IsTruthy(tmp8) { + } else { + tmp9 := checkDerefVar(var_glojure_DOT_core_str) + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp13 := checkDerefVar(var_glojure_DOT_core_meta) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(kw_line, []any{tmp14}) + tmp16 := lang.Apply(tmp9, []any{tmp11, " requires ", "a vector for its binding", " in ", tmp12, ":", tmp15}) + tmp17 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp16}) + panic(tmp17) + } + _ = tmp6 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp20 := checkDerefVar(var_glojure_DOT_core_count) + tmp21 := lang.Apply(tmp20, []any{v4}) + tmp22 := lang.Apply(tmp19, []any{int64(2), tmp21}) + if lang.IsTruthy(tmp22) { + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp27 := checkDerefVar(var_glojure_DOT_core_meta) + tmp28 := lang.Apply(tmp27, []any{v2}) + tmp29 := lang.Apply(kw_line, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp25, " requires ", "exactly 2 forms in binding vector", " in ", tmp26, ":", tmp29}) + tmp31 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp31) + } + _ = tmp18 + var tmp32 any + { // let + // let binding "form" + tmp33 := lang.Apply(v4, []any{int64(0)}) + var v34 any = tmp33 + _ = v34 + // let binding "tst" + tmp35 := lang.Apply(v4, []any{int64(1)}) + var v36 any = tmp35 + _ = v36 + tmp37 := checkDerefVar(var_glojure_DOT_core_seq) + tmp38 := checkDerefVar(var_glojure_DOT_core_concat) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := lang.Apply(tmp39, []any{sym_glojure_DOT_core_SLASH_let}) + tmp41 := checkDerefVar(var_glojure_DOT_core_list) + tmp42 := checkDerefVar(var_glojure_DOT_core_apply) + tmp43 := checkDerefVar(var_glojure_DOT_core_vector) + tmp44 := checkDerefVar(var_glojure_DOT_core_seq) + tmp45 := checkDerefVar(var_glojure_DOT_core_concat) + tmp46 := checkDerefVar(var_glojure_DOT_core_list) + tmp47 := lang.Apply(tmp46, []any{sym_temp__0__auto__}) + tmp48 := checkDerefVar(var_glojure_DOT_core_list) + tmp49 := lang.Apply(tmp48, []any{v36}) + tmp50 := lang.Apply(tmp45, []any{tmp47, tmp49}) + tmp51 := lang.Apply(tmp44, []any{tmp50}) + tmp52 := lang.Apply(tmp42, []any{tmp43, tmp51}) + tmp53 := lang.Apply(tmp41, []any{tmp52}) + tmp54 := checkDerefVar(var_glojure_DOT_core_list) + tmp55 := checkDerefVar(var_glojure_DOT_core_seq) + tmp56 := checkDerefVar(var_glojure_DOT_core_concat) + tmp57 := checkDerefVar(var_glojure_DOT_core_list) + tmp58 := lang.Apply(tmp57, []any{sym_glojure_DOT_core_SLASH_when}) + tmp59 := checkDerefVar(var_glojure_DOT_core_list) + tmp60 := lang.Apply(tmp59, []any{sym_temp__0__auto__}) + tmp61 := checkDerefVar(var_glojure_DOT_core_list) + tmp62 := checkDerefVar(var_glojure_DOT_core_seq) + tmp63 := checkDerefVar(var_glojure_DOT_core_concat) + tmp64 := checkDerefVar(var_glojure_DOT_core_list) + tmp65 := lang.Apply(tmp64, []any{sym_glojure_DOT_core_SLASH_let}) + tmp66 := checkDerefVar(var_glojure_DOT_core_list) + tmp67 := checkDerefVar(var_glojure_DOT_core_apply) + tmp68 := checkDerefVar(var_glojure_DOT_core_vector) + tmp69 := checkDerefVar(var_glojure_DOT_core_seq) + tmp70 := checkDerefVar(var_glojure_DOT_core_concat) + tmp71 := checkDerefVar(var_glojure_DOT_core_list) + tmp72 := lang.Apply(tmp71, []any{v34}) + tmp73 := checkDerefVar(var_glojure_DOT_core_list) + tmp74 := lang.Apply(tmp73, []any{sym_temp__0__auto__}) + tmp75 := lang.Apply(tmp70, []any{tmp72, tmp74}) + tmp76 := lang.Apply(tmp69, []any{tmp75}) + tmp77 := lang.Apply(tmp67, []any{tmp68, tmp76}) + tmp78 := lang.Apply(tmp66, []any{tmp77}) + tmp79 := lang.Apply(tmp63, []any{tmp65, tmp78, v5}) + tmp80 := lang.Apply(tmp62, []any{tmp79}) + tmp81 := lang.Apply(tmp61, []any{tmp80}) + tmp82 := lang.Apply(tmp56, []any{tmp58, tmp60, tmp81}) + tmp83 := lang.Apply(tmp55, []any{tmp82}) + tmp84 := lang.Apply(tmp54, []any{tmp83}) + tmp85 := lang.Apply(tmp38, []any{tmp40, tmp53, tmp84}) + tmp86 := lang.Apply(tmp37, []any{tmp85}) + tmp32 = tmp86 + } // end let + return tmp32 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_when_DASH_let = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_when_DASH_let.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // when-some + { + tmp0 := sym_when_DASH_some.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "bindings => binding-form test\n\n When test is not nil, evaluates body with binding-form bound to the\n value of test", kw_file, "glojure/core.glj", kw_added, "1.6", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(11), kw_line, int(1894), kw_end_DASH_line, int(1894))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v4}) + if lang.IsTruthy(tmp8) { + } else { + tmp9 := checkDerefVar(var_glojure_DOT_core_str) + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp13 := checkDerefVar(var_glojure_DOT_core_meta) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(kw_line, []any{tmp14}) + tmp16 := lang.Apply(tmp9, []any{tmp11, " requires ", "a vector for its binding", " in ", tmp12, ":", tmp15}) + tmp17 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp16}) + panic(tmp17) + } + _ = tmp6 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp20 := checkDerefVar(var_glojure_DOT_core_count) + tmp21 := lang.Apply(tmp20, []any{v4}) + tmp22 := lang.Apply(tmp19, []any{int64(2), tmp21}) + if lang.IsTruthy(tmp22) { + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp27 := checkDerefVar(var_glojure_DOT_core_meta) + tmp28 := lang.Apply(tmp27, []any{v2}) + tmp29 := lang.Apply(kw_line, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp25, " requires ", "exactly 2 forms in binding vector", " in ", tmp26, ":", tmp29}) + tmp31 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp31) + } + _ = tmp18 + var tmp32 any + { // let + // let binding "form" + tmp33 := lang.Apply(v4, []any{int64(0)}) + var v34 any = tmp33 + _ = v34 + // let binding "tst" + tmp35 := lang.Apply(v4, []any{int64(1)}) + var v36 any = tmp35 + _ = v36 + tmp37 := checkDerefVar(var_glojure_DOT_core_seq) + tmp38 := checkDerefVar(var_glojure_DOT_core_concat) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := lang.Apply(tmp39, []any{sym_glojure_DOT_core_SLASH_let}) + tmp41 := checkDerefVar(var_glojure_DOT_core_list) + tmp42 := checkDerefVar(var_glojure_DOT_core_apply) + tmp43 := checkDerefVar(var_glojure_DOT_core_vector) + tmp44 := checkDerefVar(var_glojure_DOT_core_seq) + tmp45 := checkDerefVar(var_glojure_DOT_core_concat) + tmp46 := checkDerefVar(var_glojure_DOT_core_list) + tmp47 := lang.Apply(tmp46, []any{sym_temp__0__auto__}) + tmp48 := checkDerefVar(var_glojure_DOT_core_list) + tmp49 := lang.Apply(tmp48, []any{v36}) + tmp50 := lang.Apply(tmp45, []any{tmp47, tmp49}) + tmp51 := lang.Apply(tmp44, []any{tmp50}) + tmp52 := lang.Apply(tmp42, []any{tmp43, tmp51}) + tmp53 := lang.Apply(tmp41, []any{tmp52}) + tmp54 := checkDerefVar(var_glojure_DOT_core_list) + tmp55 := checkDerefVar(var_glojure_DOT_core_seq) + tmp56 := checkDerefVar(var_glojure_DOT_core_concat) + tmp57 := checkDerefVar(var_glojure_DOT_core_list) + tmp58 := lang.Apply(tmp57, []any{sym_if}) + tmp59 := checkDerefVar(var_glojure_DOT_core_list) + tmp60 := checkDerefVar(var_glojure_DOT_core_seq) + tmp61 := checkDerefVar(var_glojure_DOT_core_concat) + tmp62 := checkDerefVar(var_glojure_DOT_core_list) + tmp63 := lang.Apply(tmp62, []any{sym_glojure_DOT_core_SLASH_nil_QMARK_}) + tmp64 := checkDerefVar(var_glojure_DOT_core_list) + tmp65 := lang.Apply(tmp64, []any{sym_temp__0__auto__}) + tmp66 := lang.Apply(tmp61, []any{tmp63, tmp65}) + tmp67 := lang.Apply(tmp60, []any{tmp66}) + tmp68 := lang.Apply(tmp59, []any{tmp67}) + tmp69 := checkDerefVar(var_glojure_DOT_core_list) + tmp70 := lang.Apply(tmp69, []any{nil}) + tmp71 := checkDerefVar(var_glojure_DOT_core_list) + tmp72 := checkDerefVar(var_glojure_DOT_core_seq) + tmp73 := checkDerefVar(var_glojure_DOT_core_concat) + tmp74 := checkDerefVar(var_glojure_DOT_core_list) + tmp75 := lang.Apply(tmp74, []any{sym_glojure_DOT_core_SLASH_let}) + tmp76 := checkDerefVar(var_glojure_DOT_core_list) + tmp77 := checkDerefVar(var_glojure_DOT_core_apply) + tmp78 := checkDerefVar(var_glojure_DOT_core_vector) + tmp79 := checkDerefVar(var_glojure_DOT_core_seq) + tmp80 := checkDerefVar(var_glojure_DOT_core_concat) + tmp81 := checkDerefVar(var_glojure_DOT_core_list) + tmp82 := lang.Apply(tmp81, []any{v34}) + tmp83 := checkDerefVar(var_glojure_DOT_core_list) + tmp84 := lang.Apply(tmp83, []any{sym_temp__0__auto__}) + tmp85 := lang.Apply(tmp80, []any{tmp82, tmp84}) + tmp86 := lang.Apply(tmp79, []any{tmp85}) + tmp87 := lang.Apply(tmp77, []any{tmp78, tmp86}) + tmp88 := lang.Apply(tmp76, []any{tmp87}) + tmp89 := lang.Apply(tmp73, []any{tmp75, tmp88, v5}) + tmp90 := lang.Apply(tmp72, []any{tmp89}) + tmp91 := lang.Apply(tmp71, []any{tmp90}) + tmp92 := lang.Apply(tmp56, []any{tmp58, tmp68, tmp70, tmp91}) + tmp93 := lang.Apply(tmp55, []any{tmp92}) + tmp94 := lang.Apply(tmp54, []any{tmp93}) + tmp95 := lang.Apply(tmp38, []any{tmp40, tmp53, tmp94}) + tmp96 := lang.Apply(tmp37, []any{tmp95}) + tmp32 = tmp96 + } // end let + return tmp32 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_when_DASH_some = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_when_DASH_some.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // while + { + tmp0 := sym_while.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_test, sym__AMP_, sym_body)), kw_doc, "Repeatedly executes body while test expression is true. Presumes\n some side-effect will cause test to become false/nil. Returns nil", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(11), kw_line, int(6327), kw_end_DASH_line, int(6327))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_loop}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + tmp12 := checkDerefVar(var_glojure_DOT_core_vector) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := lang.Apply(tmp14, nil) + tmp16 := lang.Apply(tmp13, []any{tmp15}) + tmp17 := lang.Apply(tmp11, []any{tmp12, tmp16}) + tmp18 := lang.Apply(tmp10, []any{tmp17}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{sym_glojure_DOT_core_SLASH_when}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v4}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := checkDerefVar(var_glojure_DOT_core_seq) + tmp28 := checkDerefVar(var_glojure_DOT_core_concat) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{sym_recur}) + tmp31 := lang.Apply(tmp28, []any{tmp30}) + tmp32 := lang.Apply(tmp27, []any{tmp31}) + tmp33 := lang.Apply(tmp26, []any{tmp32}) + tmp34 := lang.Apply(tmp21, []any{tmp23, tmp25, v5, tmp33}) + tmp35 := lang.Apply(tmp20, []any{tmp34}) + tmp36 := lang.Apply(tmp19, []any{tmp35}) + tmp37 := lang.Apply(tmp7, []any{tmp9, tmp18, tmp36}) + tmp38 := lang.Apply(tmp6, []any{tmp37}) + return tmp38 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_while = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_while.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // with-bindings + { + tmp0 := sym_with_DASH_bindings.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_binding_DASH_map, sym__AMP_, sym_body)), kw_doc, "Takes a map of Var/value pairs. Installs for the given Vars the associated\n values as thread-local bindings. Then executes body. Pops the installed\n bindings after body was evaluated. Returns the value of body.", kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(11), kw_line, int(1984), kw_end_DASH_line, int(1984))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_with_DASH_bindings_STAR_}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{v4}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_fn}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_apply) + tmp19 := checkDerefVar(var_glojure_DOT_core_vector) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := lang.Apply(tmp21, nil) + tmp23 := lang.Apply(tmp20, []any{tmp22}) + tmp24 := lang.Apply(tmp18, []any{tmp19, tmp23}) + tmp25 := lang.Apply(tmp17, []any{tmp24}) + tmp26 := lang.Apply(tmp14, []any{tmp16, tmp25, v5}) + tmp27 := lang.Apply(tmp13, []any{tmp26}) + tmp28 := lang.Apply(tmp12, []any{tmp27}) + tmp29 := lang.Apply(tmp7, []any{tmp9, tmp11, tmp28}) + tmp30 := lang.Apply(tmp6, []any{tmp29}) + return tmp30 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_with_DASH_bindings = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_with_DASH_bindings.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // with-bindings* + { + tmp0 := sym_with_DASH_bindings_STAR_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_binding_DASH_map, sym_f, sym__AMP_, sym_args)), kw_doc, "Takes a map of Var/value pairs. Installs for the given Vars the associated\n values as thread-local bindings. Then calls f with the supplied arguments.\n Pops the installed bindings after f returned. Returns whatever f returns.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(1971), kw_end_DASH_line, int(1971))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp6 := lang.Apply(tmp5, []any{v2}) + _ = tmp6 + var tmp7 any + func() { + defer func() { + tmp8 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp9 := lang.Apply(tmp8, nil) + _ = tmp9 + }() + tmp10 := checkDerefVar(var_glojure_DOT_core_apply) + tmp11 := lang.Apply(tmp10, []any{v3, v4}) + tmp7 = tmp11 + }() + return tmp7 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_with_DASH_bindings_STAR_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_with_DASH_bindings_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // with-in-str + { + tmp0 := sym_with_DASH_in_DASH_str.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_s, sym__AMP_, sym_body)), kw_doc, "Evaluates body in a context in which *in* is bound to a fresh\n StringReader initialized with the string s.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(11), kw_line, int(4749), kw_end_DASH_line, int(4749))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_with_DASH_open}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + tmp12 := checkDerefVar(var_glojure_DOT_core_vector) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_s__0__auto__}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{sym_glojure_DOT_core_SLASH__DASH__GT_}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := checkDerefVar(var_glojure_DOT_core_seq) + tmp24 := checkDerefVar(var_glojure_DOT_core_concat) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := lang.Apply(tmp25, []any{sym_java_DOT_io_DOT_StringReader_DOT_}) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{v4}) + tmp29 := lang.Apply(tmp24, []any{tmp26, tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp29}) + tmp31 := lang.Apply(tmp22, []any{tmp30}) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := lang.Apply(tmp32, []any{sym_glojure_DOT_lang_DOT_LineNumberingPushbackReader_DOT_}) + tmp34 := lang.Apply(tmp19, []any{tmp21, tmp31, tmp33}) + tmp35 := lang.Apply(tmp18, []any{tmp34}) + tmp36 := lang.Apply(tmp17, []any{tmp35}) + tmp37 := lang.Apply(tmp14, []any{tmp16, tmp36}) + tmp38 := lang.Apply(tmp13, []any{tmp37}) + tmp39 := lang.Apply(tmp11, []any{tmp12, tmp38}) + tmp40 := lang.Apply(tmp10, []any{tmp39}) + tmp41 := checkDerefVar(var_glojure_DOT_core_list) + tmp42 := checkDerefVar(var_glojure_DOT_core_seq) + tmp43 := checkDerefVar(var_glojure_DOT_core_concat) + tmp44 := checkDerefVar(var_glojure_DOT_core_list) + tmp45 := lang.Apply(tmp44, []any{sym_glojure_DOT_core_SLASH_binding}) + tmp46 := checkDerefVar(var_glojure_DOT_core_list) + tmp47 := checkDerefVar(var_glojure_DOT_core_apply) + tmp48 := checkDerefVar(var_glojure_DOT_core_vector) + tmp49 := checkDerefVar(var_glojure_DOT_core_seq) + tmp50 := checkDerefVar(var_glojure_DOT_core_concat) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := lang.Apply(tmp51, []any{sym_glojure_DOT_core_SLASH__STAR_in_STAR_}) + tmp53 := checkDerefVar(var_glojure_DOT_core_list) + tmp54 := lang.Apply(tmp53, []any{sym_s__0__auto__}) + tmp55 := lang.Apply(tmp50, []any{tmp52, tmp54}) + tmp56 := lang.Apply(tmp49, []any{tmp55}) + tmp57 := lang.Apply(tmp47, []any{tmp48, tmp56}) + tmp58 := lang.Apply(tmp46, []any{tmp57}) + tmp59 := lang.Apply(tmp43, []any{tmp45, tmp58, v5}) + tmp60 := lang.Apply(tmp42, []any{tmp59}) + tmp61 := lang.Apply(tmp41, []any{tmp60}) + tmp62 := lang.Apply(tmp7, []any{tmp9, tmp40, tmp61}) + tmp63 := lang.Apply(tmp6, []any{tmp62}) + return tmp63 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_with_DASH_in_DASH_str = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_with_DASH_in_DASH_str.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // with-loading-context + { + tmp0 := sym_with_DASH_loading_DASH_context.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5734), kw_column, int(11), kw_end_DASH_line, int(5734), kw_end_DASH_column, int(30), kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_body)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_macro, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_fn}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_loading__0__auto__}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_apply) + tmp16 := checkDerefVar(var_glojure_DOT_core_vector) + tmp17 := checkDerefVar(var_glojure_DOT_core_seq) + tmp18 := checkDerefVar(var_glojure_DOT_core_concat) + tmp19 := lang.Apply(tmp18, nil) + tmp20 := lang.Apply(tmp17, []any{tmp19}) + tmp21 := lang.Apply(tmp15, []any{tmp16, tmp20}) + tmp22 := lang.Apply(tmp14, []any{tmp21}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_seq) + tmp25 := checkDerefVar(var_glojure_DOT_core_concat) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_PushThreadBindings}) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := checkDerefVar(var_glojure_DOT_core_apply) + tmp30 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp31 := checkDerefVar(var_glojure_DOT_core_seq) + tmp32 := checkDerefVar(var_glojure_DOT_core_concat) + tmp33 := lang.Apply(tmp32, nil) + tmp34 := lang.Apply(tmp31, []any{tmp33}) + tmp35 := lang.Apply(tmp29, []any{tmp30, tmp34}) + tmp36 := lang.Apply(tmp28, []any{tmp35}) + tmp37 := lang.Apply(tmp25, []any{tmp27, tmp36}) + tmp38 := lang.Apply(tmp24, []any{tmp37}) + tmp39 := lang.Apply(tmp23, []any{tmp38}) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := checkDerefVar(var_glojure_DOT_core_seq) + tmp42 := checkDerefVar(var_glojure_DOT_core_concat) + tmp43 := checkDerefVar(var_glojure_DOT_core_list) + tmp44 := lang.Apply(tmp43, []any{sym_try}) + tmp45 := checkDerefVar(var_glojure_DOT_core_list) + tmp46 := checkDerefVar(var_glojure_DOT_core_seq) + tmp47 := checkDerefVar(var_glojure_DOT_core_concat) + tmp48 := checkDerefVar(var_glojure_DOT_core_list) + tmp49 := lang.Apply(tmp48, []any{sym_finally}) + tmp50 := checkDerefVar(var_glojure_DOT_core_list) + tmp51 := checkDerefVar(var_glojure_DOT_core_seq) + tmp52 := checkDerefVar(var_glojure_DOT_core_concat) + tmp53 := checkDerefVar(var_glojure_DOT_core_list) + tmp54 := lang.Apply(tmp53, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_PopThreadBindings}) + tmp55 := lang.Apply(tmp52, []any{tmp54}) + tmp56 := lang.Apply(tmp51, []any{tmp55}) + tmp57 := lang.Apply(tmp50, []any{tmp56}) + tmp58 := lang.Apply(tmp47, []any{tmp49, tmp57}) + tmp59 := lang.Apply(tmp46, []any{tmp58}) + tmp60 := lang.Apply(tmp45, []any{tmp59}) + tmp61 := lang.Apply(tmp42, []any{tmp44, v4, tmp60}) + tmp62 := lang.Apply(tmp41, []any{tmp61}) + tmp63 := lang.Apply(tmp40, []any{tmp62}) + tmp64 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp22, tmp39, tmp63}) + tmp65 := lang.Apply(tmp8, []any{tmp64}) + tmp66 := lang.Apply(tmp7, []any{tmp65}) + tmp67 := lang.Apply(tmp6, []any{tmp66}) + tmp68 := lang.Apply(tmp5, []any{tmp67}) + return tmp68 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_with_DASH_loading_DASH_context = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_with_DASH_loading_DASH_context.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // with-open + { + tmp0 := sym_with_DASH_open.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "bindings => [name init ...]\n\n Evaluates body in a try expression with names bound to the values\n of the inits, and a finally clause that calls (.close name) on each\n name in reverse order.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(11), kw_line, int(3832), kw_end_DASH_line, int(3832))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v4}) + if lang.IsTruthy(tmp8) { + } else { + tmp9 := checkDerefVar(var_glojure_DOT_core_str) + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp13 := checkDerefVar(var_glojure_DOT_core_meta) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(kw_line, []any{tmp14}) + tmp16 := lang.Apply(tmp9, []any{tmp11, " requires ", "a vector for its binding", " in ", tmp12, ":", tmp15}) + tmp17 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp16}) + panic(tmp17) + } + _ = tmp6 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_even_QMARK_) + tmp20 := checkDerefVar(var_glojure_DOT_core_count) + tmp21 := lang.Apply(tmp20, []any{v4}) + tmp22 := lang.Apply(tmp19, []any{tmp21}) + if lang.IsTruthy(tmp22) { + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp27 := checkDerefVar(var_glojure_DOT_core_meta) + tmp28 := lang.Apply(tmp27, []any{v2}) + tmp29 := lang.Apply(kw_line, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp25, " requires ", "an even number of forms in binding vector", " in ", tmp26, ":", tmp29}) + tmp31 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp31) + } + _ = tmp18 + var tmp32 any + tmp33 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp34 := checkDerefVar(var_glojure_DOT_core_count) + tmp35 := lang.Apply(tmp34, []any{v4}) + tmp36 := lang.Apply(tmp33, []any{tmp35, int64(0)}) + if lang.IsTruthy(tmp36) { + tmp37 := checkDerefVar(var_glojure_DOT_core_seq) + tmp38 := checkDerefVar(var_glojure_DOT_core_concat) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := lang.Apply(tmp39, []any{sym_do}) + tmp41 := lang.Apply(tmp38, []any{tmp40, v5}) + tmp42 := lang.Apply(tmp37, []any{tmp41}) + tmp32 = tmp42 + } else { + var tmp43 any + tmp44 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp45 := lang.Apply(v4, []any{int64(0)}) + tmp46 := lang.Apply(tmp44, []any{tmp45}) + if lang.IsTruthy(tmp46) { + tmp47 := checkDerefVar(var_glojure_DOT_core_seq) + tmp48 := checkDerefVar(var_glojure_DOT_core_concat) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) + tmp50 := lang.Apply(tmp49, []any{sym_glojure_DOT_core_SLASH_let}) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := checkDerefVar(var_glojure_DOT_core_subvec) + tmp53 := lang.Apply(tmp52, []any{v4, int64(0), int64(2)}) + tmp54 := lang.Apply(tmp51, []any{tmp53}) + tmp55 := checkDerefVar(var_glojure_DOT_core_list) + tmp56 := checkDerefVar(var_glojure_DOT_core_seq) + tmp57 := checkDerefVar(var_glojure_DOT_core_concat) + tmp58 := checkDerefVar(var_glojure_DOT_core_list) + tmp59 := lang.Apply(tmp58, []any{sym_try}) + tmp60 := checkDerefVar(var_glojure_DOT_core_list) + tmp61 := checkDerefVar(var_glojure_DOT_core_seq) + tmp62 := checkDerefVar(var_glojure_DOT_core_concat) + tmp63 := checkDerefVar(var_glojure_DOT_core_list) + tmp64 := lang.Apply(tmp63, []any{sym_glojure_DOT_core_SLASH_with_DASH_open}) + tmp65 := checkDerefVar(var_glojure_DOT_core_list) + tmp66 := checkDerefVar(var_glojure_DOT_core_subvec) + tmp67 := lang.Apply(tmp66, []any{v4, int64(2)}) + tmp68 := lang.Apply(tmp65, []any{tmp67}) + tmp69 := lang.Apply(tmp62, []any{tmp64, tmp68, v5}) + tmp70 := lang.Apply(tmp61, []any{tmp69}) + tmp71 := lang.Apply(tmp60, []any{tmp70}) + tmp72 := checkDerefVar(var_glojure_DOT_core_list) + tmp73 := checkDerefVar(var_glojure_DOT_core_seq) + tmp74 := checkDerefVar(var_glojure_DOT_core_concat) + tmp75 := checkDerefVar(var_glojure_DOT_core_list) + tmp76 := lang.Apply(tmp75, []any{sym_finally}) + tmp77 := checkDerefVar(var_glojure_DOT_core_list) + tmp78 := checkDerefVar(var_glojure_DOT_core_seq) + tmp79 := checkDerefVar(var_glojure_DOT_core_concat) + tmp80 := checkDerefVar(var_glojure_DOT_core_list) + tmp81 := lang.Apply(tmp80, []any{sym__DOT_}) + tmp82 := checkDerefVar(var_glojure_DOT_core_list) + tmp83 := lang.Apply(v4, []any{int64(0)}) + tmp84 := lang.Apply(tmp82, []any{tmp83}) + tmp85 := checkDerefVar(var_glojure_DOT_core_list) + tmp86 := lang.Apply(tmp85, []any{sym_close}) + tmp87 := lang.Apply(tmp79, []any{tmp81, tmp84, tmp86}) + tmp88 := lang.Apply(tmp78, []any{tmp87}) + tmp89 := lang.Apply(tmp77, []any{tmp88}) + tmp90 := lang.Apply(tmp74, []any{tmp76, tmp89}) + tmp91 := lang.Apply(tmp73, []any{tmp90}) + tmp92 := lang.Apply(tmp72, []any{tmp91}) + tmp93 := lang.Apply(tmp57, []any{tmp59, tmp71, tmp92}) + tmp94 := lang.Apply(tmp56, []any{tmp93}) + tmp95 := lang.Apply(tmp55, []any{tmp94}) + tmp96 := lang.Apply(tmp48, []any{tmp50, tmp54, tmp95}) + tmp97 := lang.Apply(tmp47, []any{tmp96}) + tmp43 = tmp97 + } else { + var tmp98 any + if lang.IsTruthy(kw_else) { + tmp99 := lang.Apply(lang.NewIllegalArgumentError, []any{"with-open only allows Symbols in bindings"}) + panic(tmp99) + } else { + } + tmp43 = tmp98 + } + tmp32 = tmp43 + } + return tmp32 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_with_DASH_open = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_with_DASH_open.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // with-out-str + { + tmp0 := sym_with_DASH_out_DASH_str.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_body)), kw_doc, "Evaluates exprs in a context in which *out* is bound to a fresh\n StringWriter. Returns the string created by any nested printing\n calls.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(22), kw_column, int(11), kw_line, int(4738), kw_end_DASH_line, int(4738))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym_glojure_DOT_core_SLASH_let}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := checkDerefVar(var_glojure_DOT_core_apply) + tmp11 := checkDerefVar(var_glojure_DOT_core_vector) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_s__0__auto__}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := checkDerefVar(var_glojure_DOT_core_seq) + tmp18 := checkDerefVar(var_glojure_DOT_core_concat) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{sym_new}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{sym_strings_DOT_Builder}) + tmp23 := lang.Apply(tmp18, []any{tmp20, tmp22}) + tmp24 := lang.Apply(tmp17, []any{tmp23}) + tmp25 := lang.Apply(tmp16, []any{tmp24}) + tmp26 := lang.Apply(tmp13, []any{tmp15, tmp25}) + tmp27 := lang.Apply(tmp12, []any{tmp26}) + tmp28 := lang.Apply(tmp10, []any{tmp11, tmp27}) + tmp29 := lang.Apply(tmp9, []any{tmp28}) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := checkDerefVar(var_glojure_DOT_core_seq) + tmp32 := checkDerefVar(var_glojure_DOT_core_concat) + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{sym_glojure_DOT_core_SLASH_binding}) + tmp35 := checkDerefVar(var_glojure_DOT_core_list) + tmp36 := checkDerefVar(var_glojure_DOT_core_apply) + tmp37 := checkDerefVar(var_glojure_DOT_core_vector) + tmp38 := checkDerefVar(var_glojure_DOT_core_seq) + tmp39 := checkDerefVar(var_glojure_DOT_core_concat) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{sym_glojure_DOT_core_SLASH__STAR_out_STAR_}) + tmp42 := checkDerefVar(var_glojure_DOT_core_list) + tmp43 := lang.Apply(tmp42, []any{sym_s__0__auto__}) + tmp44 := lang.Apply(tmp39, []any{tmp41, tmp43}) + tmp45 := lang.Apply(tmp38, []any{tmp44}) + tmp46 := lang.Apply(tmp36, []any{tmp37, tmp45}) + tmp47 := lang.Apply(tmp35, []any{tmp46}) + tmp48 := checkDerefVar(var_glojure_DOT_core_list) + tmp49 := checkDerefVar(var_glojure_DOT_core_seq) + tmp50 := checkDerefVar(var_glojure_DOT_core_concat) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := lang.Apply(tmp51, []any{sym_glojure_DOT_core_SLASH_str}) + tmp53 := checkDerefVar(var_glojure_DOT_core_list) + tmp54 := lang.Apply(tmp53, []any{sym_s__0__auto__}) + tmp55 := lang.Apply(tmp50, []any{tmp52, tmp54}) + tmp56 := lang.Apply(tmp49, []any{tmp55}) + tmp57 := lang.Apply(tmp48, []any{tmp56}) + tmp58 := lang.Apply(tmp32, []any{tmp34, tmp47, v4, tmp57}) + tmp59 := lang.Apply(tmp31, []any{tmp58}) + tmp60 := lang.Apply(tmp30, []any{tmp59}) + tmp61 := lang.Apply(tmp6, []any{tmp8, tmp29, tmp60}) + tmp62 := lang.Apply(tmp5, []any{tmp61}) + return tmp62 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_with_DASH_out_DASH_str = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_with_DASH_out_DASH_str.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // with-precision + { + tmp0 := sym_with_DASH_precision.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_precision, sym__AMP_, sym_exprs)), kw_doc, "Sets the precision and rounding mode to be used for BigDecimal operations.\n\n Usage: (with-precision 10 (/ 1M 3))\n or: (with-precision 10 :rounding HALF_DOWN (/ 1M 3))\n\n The rounding mode is one of CEILING, FLOOR, HALF_UP, HALF_DOWN,\n HALF_EVEN, UP, DOWN and UNNECESSARY; it defaults to HALF_UP.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(24), kw_column, int(11), kw_line, int(5110), kw_end_DASH_line, int(5110))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "vec__756" + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp9 := checkDerefVar(var_glojure_DOT_core_first) + tmp10 := lang.Apply(tmp9, []any{v5}) + tmp11 := lang.Apply(tmp8, []any{tmp10, kw_rounding}) + if lang.IsTruthy(tmp11) { + tmp12 := checkDerefVar(var_glojure_DOT_core_next) + tmp13 := checkDerefVar(var_glojure_DOT_core_next) + tmp14 := lang.Apply(tmp13, []any{v5}) + tmp15 := lang.Apply(tmp12, []any{tmp14}) + tmp16 := checkDerefVar(var_glojure_DOT_core_seq) + tmp17 := checkDerefVar(var_glojure_DOT_core_concat) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := checkDerefVar(var_glojure_DOT_core_seq) + tmp20 := checkDerefVar(var_glojure_DOT_core_concat) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{sym__DOT_}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := lang.Apply(tmp23, []any{sym_java_DOT_math_DOT_RoundingMode}) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := checkDerefVar(var_glojure_DOT_core_second) + tmp27 := lang.Apply(tmp26, []any{v5}) + tmp28 := lang.Apply(tmp25, []any{tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp22, tmp24, tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp18, []any{tmp30}) + tmp32 := lang.Apply(tmp17, []any{tmp31}) + tmp33 := lang.Apply(tmp16, []any{tmp32}) + tmp34 := lang.NewVector(tmp15, tmp33) + tmp35 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5121), kw_column, int(23), kw_end_DASH_line, int(5122), kw_end_DASH_column, int(69)) + tmp36, err := lang.WithMeta(tmp34, tmp35.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp7 = tmp36 + } else { + tmp37 := lang.NewVector(v5, nil) + tmp38 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5123), kw_column, int(23), kw_end_DASH_line, int(5123), kw_end_DASH_column, int(33)) + tmp39, err := lang.WithMeta(tmp37, tmp38.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp7 = tmp39 + } + var v40 any = tmp7 + _ = v40 + // let binding "body" + tmp41 := checkDerefVar(var_glojure_DOT_core_nth) + tmp42 := lang.Apply(tmp41, []any{v40, int64(0), nil}) + var v43 any = tmp42 + _ = v43 + // let binding "rm" + tmp44 := checkDerefVar(var_glojure_DOT_core_nth) + tmp45 := lang.Apply(tmp44, []any{v40, int64(1), nil}) + var v46 any = tmp45 + _ = v46 + tmp47 := checkDerefVar(var_glojure_DOT_core_seq) + tmp48 := checkDerefVar(var_glojure_DOT_core_concat) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) + tmp50 := lang.Apply(tmp49, []any{sym_glojure_DOT_core_SLASH_binding}) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := checkDerefVar(var_glojure_DOT_core_apply) + tmp53 := checkDerefVar(var_glojure_DOT_core_vector) + tmp54 := checkDerefVar(var_glojure_DOT_core_seq) + tmp55 := checkDerefVar(var_glojure_DOT_core_concat) + tmp56 := checkDerefVar(var_glojure_DOT_core_list) + tmp57 := lang.Apply(tmp56, []any{sym_glojure_DOT_core_SLASH__STAR_math_DASH_context_STAR_}) + tmp58 := checkDerefVar(var_glojure_DOT_core_list) + tmp59 := checkDerefVar(var_glojure_DOT_core_seq) + tmp60 := checkDerefVar(var_glojure_DOT_core_concat) + tmp61 := checkDerefVar(var_glojure_DOT_core_list) + tmp62 := lang.Apply(tmp61, []any{sym_java_DOT_math_DOT_MathContext_DOT_}) + tmp63 := checkDerefVar(var_glojure_DOT_core_list) + tmp64 := lang.Apply(tmp63, []any{v4}) + tmp65 := lang.Apply(tmp60, []any{tmp62, tmp64, v46}) + tmp66 := lang.Apply(tmp59, []any{tmp65}) + tmp67 := lang.Apply(tmp58, []any{tmp66}) + tmp68 := lang.Apply(tmp55, []any{tmp57, tmp67}) + tmp69 := lang.Apply(tmp54, []any{tmp68}) + tmp70 := lang.Apply(tmp52, []any{tmp53, tmp69}) + tmp71 := lang.Apply(tmp51, []any{tmp70}) + tmp72 := lang.Apply(tmp48, []any{tmp50, tmp71, v43}) + tmp73 := lang.Apply(tmp47, []any{tmp72}) + tmp6 = tmp73 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_with_DASH_precision = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_with_DASH_precision.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // with-redefs + { + tmp0 := sym_with_DASH_redefs.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "binding => var-symbol temp-value-expr\n\n Temporarily redefines Vars while executing the body. The\n temp-value-exprs will be evaluated and each resulting value will\n replace in parallel the root value of its Var. After the body is\n executed, the root values of all the Vars will be set back to their\n old values. These temporary changes will be visible in all threads.\n Useful for mocking out functions during testing.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(11), kw_line, int(7544), kw_end_DASH_line, int(7544))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_with_DASH_redefs_DASH_fn}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_zipmap) + tmp12 := checkDerefVar(var_glojure_DOT_core_map) + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v14 := args[0] + _ = v14 + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_var, v14}) + return tmp16 + }) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7555), kw_column, int(34), kw_end_DASH_line, int(7555), kw_end_DASH_column, int(47)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp16 := checkDerefVar(var_glojure_DOT_core_take_DASH_nth) + tmp17 := lang.Apply(tmp16, []any{int64(2), v4}) + tmp18 := lang.Apply(tmp12, []any{tmp15, tmp17}) + tmp19 := checkDerefVar(var_glojure_DOT_core_take_DASH_nth) + tmp20 := checkDerefVar(var_glojure_DOT_core_next) + tmp21 := lang.Apply(tmp20, []any{v4}) + tmp22 := lang.Apply(tmp19, []any{int64(2), tmp21}) + tmp23 := lang.Apply(tmp11, []any{tmp18, tmp22}) + tmp24 := lang.Apply(tmp10, []any{tmp23}) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := checkDerefVar(var_glojure_DOT_core_seq) + tmp27 := checkDerefVar(var_glojure_DOT_core_concat) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := lang.Apply(tmp28, []any{sym_glojure_DOT_core_SLASH_fn}) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := checkDerefVar(var_glojure_DOT_core_apply) + tmp32 := checkDerefVar(var_glojure_DOT_core_vector) + tmp33 := checkDerefVar(var_glojure_DOT_core_seq) + tmp34 := checkDerefVar(var_glojure_DOT_core_concat) + tmp35 := lang.Apply(tmp34, nil) + tmp36 := lang.Apply(tmp33, []any{tmp35}) + tmp37 := lang.Apply(tmp31, []any{tmp32, tmp36}) + tmp38 := lang.Apply(tmp30, []any{tmp37}) + tmp39 := lang.Apply(tmp27, []any{tmp29, tmp38, v5}) + tmp40 := lang.Apply(tmp26, []any{tmp39}) + tmp41 := lang.Apply(tmp25, []any{tmp40}) + tmp42 := lang.Apply(tmp7, []any{tmp9, tmp24, tmp41}) + tmp43 := lang.Apply(tmp6, []any{tmp42}) + return tmp43 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_with_DASH_redefs = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_with_DASH_redefs.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // with-redefs-fn + { + tmp0 := sym_with_DASH_redefs_DASH_fn.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_binding_DASH_map, sym_func)), kw_doc, "Temporarily redefines Vars during a call to func. Each val of\n binding-map will replace the root value of its key which must be\n a Var. After func is called with no args, the root values of all\n the Vars will be set back to their old values. These temporary\n changes will be visible in all threads. Useful for mocking out\n functions during testing.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(7524), kw_end_DASH_line, int(7524))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "root-bind" + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v6 := args[0] + _ = v6 + var tmp7 any + { // let + // let binding "seq_990" + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := lang.Apply(tmp8, []any{v6}) + var v10 any = tmp9 + _ = v10 + // let binding "chunk_991" + var v11 any = nil + _ = v11 + // let binding "count_992" + var v12 any = int64(0) + _ = v12 + // let binding "i_993" + var v13 any = int64(0) + _ = v13 + for { + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp16 := lang.Apply(tmp15, []any{v13, v12}) + if lang.IsTruthy(tmp16) { + var tmp17 any + { // let + // let binding "vec__994" + tmp18, _ := lang.FieldOrMethod(v11, "nth") + if reflect.TypeOf(tmp18).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp19 := lang.Apply(tmp18, []any{v13}) + var v20 any = tmp19 + _ = v20 + // let binding "a-var" + tmp21 := checkDerefVar(var_glojure_DOT_core_nth) + tmp22 := lang.Apply(tmp21, []any{v20, int64(0), nil}) + var v23 any = tmp22 + _ = v23 + // let binding "a-val" + tmp24 := checkDerefVar(var_glojure_DOT_core_nth) + tmp25 := lang.Apply(tmp24, []any{v20, int64(1), nil}) + var v26 any = tmp25 + _ = v26 + tmp27, _ := lang.FieldOrMethod(v23, "bindRoot") + if reflect.TypeOf(tmp27).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("bindRoot is not a function"))) + } + tmp28 := lang.Apply(tmp27, []any{v26}) + _ = tmp28 + var tmp29 any = v10 + var tmp30 any = v11 + var tmp31 any = v12 + tmp33 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp34 := lang.Apply(tmp33, []any{v13}) + var tmp32 any = tmp34 + v10 = tmp29 + v11 = tmp30 + v12 = tmp31 + v13 = tmp32 + continue + } // end let + tmp14 = tmp17 + } else { + var tmp18 any + { // let + // let binding "temp__0__auto__" + tmp19 := checkDerefVar(var_glojure_DOT_core_seq) + tmp20 := lang.Apply(tmp19, []any{v10}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + if lang.IsTruthy(v21) { + var tmp23 any + { // let + // let binding "seq_990" + var v24 any = v21 + _ = v24 + var tmp25 any + tmp26 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp27 := lang.Apply(tmp26, []any{v24}) + if lang.IsTruthy(tmp27) { + var tmp28 any + { // let + // let binding "c__0__auto__" + tmp29 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp30 := lang.Apply(tmp29, []any{v24}) + var v31 any = tmp30 + _ = v31 + tmp33 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp34 := lang.Apply(tmp33, []any{v24}) + var tmp32 any = tmp34 + var tmp35 any = v31 + tmp37 := checkDerefVar(var_glojure_DOT_core_int) + tmp38 := checkDerefVar(var_glojure_DOT_core_count) + tmp39 := lang.Apply(tmp38, []any{v31}) + tmp40 := lang.Apply(tmp37, []any{tmp39}) + var tmp36 any = tmp40 + tmp42 := checkDerefVar(var_glojure_DOT_core_int) + tmp43 := lang.Apply(tmp42, []any{int64(0)}) + var tmp41 any = tmp43 + v10 = tmp32 + v11 = tmp35 + v12 = tmp36 + v13 = tmp41 + continue + } // end let + tmp25 = tmp28 + } else { + var tmp29 any + { // let + // let binding "vec__997" + tmp30 := checkDerefVar(var_glojure_DOT_core_first) + tmp31 := lang.Apply(tmp30, []any{v24}) + var v32 any = tmp31 + _ = v32 + // let binding "a-var" + tmp33 := checkDerefVar(var_glojure_DOT_core_nth) + tmp34 := lang.Apply(tmp33, []any{v32, int64(0), nil}) + var v35 any = tmp34 + _ = v35 + // let binding "a-val" + tmp36 := checkDerefVar(var_glojure_DOT_core_nth) + tmp37 := lang.Apply(tmp36, []any{v32, int64(1), nil}) + var v38 any = tmp37 + _ = v38 + tmp39, _ := lang.FieldOrMethod(v35, "bindRoot") + if reflect.TypeOf(tmp39).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("bindRoot is not a function"))) + } + tmp40 := lang.Apply(tmp39, []any{v38}) + _ = tmp40 + tmp42 := checkDerefVar(var_glojure_DOT_core_next) + tmp43 := lang.Apply(tmp42, []any{v24}) + var tmp41 any = tmp43 + var tmp44 any = nil + var tmp45 any = int64(0) + var tmp46 any = int64(0) + v10 = tmp41 + v11 = tmp44 + v12 = tmp45 + v13 = tmp46 + continue + } // end let + tmp25 = tmp29 + } + tmp23 = tmp25 + } // end let + tmp22 = tmp23 + } else { + } + tmp18 = tmp22 + } // end let + tmp14 = tmp18 + } + tmp7 = tmp14 + break + } + } // end let + return tmp7 + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7533), kw_column, int(19), kw_end_DASH_line, int(7535), kw_end_DASH_column, int(93)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v8 any = tmp7 + _ = v8 + // let binding "old-vals" + tmp9 := checkDerefVar(var_glojure_DOT_core_zipmap) + tmp10 := checkDerefVar(var_glojure_DOT_core_keys) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := checkDerefVar(var_glojure_DOT_core_map) + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v14 := args[0] + _ = v14 + tmp15, ok := lang.FieldOrMethod(v14, "getRawRoot") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v14, "getRawRoot"))) + } + var tmp16 any + switch reflect.TypeOf(tmp15).Kind() { + case reflect.Func: + tmp16 = lang.Apply(tmp15, nil) + default: + tmp16 = tmp15 + } + return tmp16 + }) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7537), kw_column, int(31), kw_end_DASH_line, int(7537), kw_end_DASH_column, int(92)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp16 := checkDerefVar(var_glojure_DOT_core_keys) + tmp17 := lang.Apply(tmp16, []any{v2}) + tmp18 := lang.Apply(tmp12, []any{tmp15, tmp17}) + tmp19 := lang.Apply(tmp9, []any{tmp11, tmp18}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + func() { + defer func() { + tmp22 := lang.Apply(v8, []any{v20}) + _ = tmp22 + }() + tmp23 := lang.Apply(v8, []any{v2}) + _ = tmp23 + tmp24 := lang.Apply(v3, nil) + tmp21 = tmp24 + }() + tmp4 = tmp21 + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_with_DASH_redefs_DASH_fn = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_with_DASH_redefs_DASH_fn.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // - + { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed6 + } else { + tmp4 = closed7 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed6 + } else { + tmp5 = closed7 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed6 + } else { + tmp6 = closed7 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(0)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym__DASH_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "If no ys are supplied, returns the negation of x, else subtracts\n the ys from x and returns the result. Does not auto-promote\n longs, will throw on overflow. See also: -'", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(7), kw_line, int(1036), kw_end_DASH_line, int(1036))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_) + tmp6 := lang.Apply(tmp5, []any{int64(-1), v4}) + return tmp6 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Minus") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Minus is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp8 := checkDerefVar(var_glojure_DOT_core__DASH_) + tmp9 := checkDerefVar(var_glojure_DOT_core__DASH_) + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) + return tmp11 + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__DASH_ = ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__DASH_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // -' + { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed8 + } else { + tmp4 = closed8 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed8 + } else { + tmp5 = closed8 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed8 + } else { + tmp6 = closed8 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(0)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym__DASH__TICK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "If no ys are supplied, returns the negation of x, else subtracts\n the ys from x and returns the result. Supports arbitrary precision.\n See also: -", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(7), kw_line, int(1024), kw_end_DASH_line, int(1024))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR__TICK_) + tmp6 := lang.Apply(tmp5, []any{int64(-1), v4}) + return tmp6 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "MinusP") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("MinusP is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp8 := checkDerefVar(var_glojure_DOT_core__DASH__TICK_) + tmp9 := checkDerefVar(var_glojure_DOT_core__DASH__TICK_) + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) + return tmp11 + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__DASH__TICK_ = ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__DASH__TICK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // agent + { + tmp0 := sym_agent.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_state, sym__AMP_, sym_options)), kw_doc, "Creates and returns an agent with an initial value of state and\n zero or more options (in any order):\n\n :meta metadata-map\n\n :validator validate-fn\n\n :error-handler handler-fn\n\n :error-mode mode-keyword\n\n If metadata-map is supplied, it will become the metadata on the\n agent. validate-fn must be nil or a side-effect-free fn of one\n argument, which will be passed the intended new state on any state\n change. If the new state is unacceptable, the validate-fn should\n return false or throw an exception. handler-fn is called if an\n action throws an exception or if validate-fn rejects a new state --\n see set-error-handler! for details. The mode-keyword may be either\n :continue (the default if an error-handler is given) or :fail (the\n default if no error-handler is given) -- see set-error-mode! for\n details.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(2052), kw_end_DASH_line, int(2052))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + var tmp4 any + { // let + // let binding "a" + var v5 any = "unimplemented: new with non-constant class type" + _ = v5 + // let binding "opts" + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) + var v9 any = tmp8 + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_setup_DASH_reference) + tmp11 := lang.Apply(tmp10, []any{v5, v3}) + _ = tmp11 + var tmp12 any + tmp13 := lang.Apply(kw_error_DASH_handler, []any{v9}) + if lang.IsTruthy(tmp13) { + tmp14 := lang.Apply(kw_error_DASH_handler, []any{v9}) + tmp15, _ := lang.FieldOrMethod(v5, "setErrorHandler") + if reflect.TypeOf(tmp15).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorHandler is not a function"))) + } + tmp16 := lang.Apply(tmp15, []any{tmp14}) + tmp12 = tmp16 + } else { + } + _ = tmp12 + var tmp17 any + { // let + // let binding "or__0__auto__" + tmp18 := lang.Apply(kw_error_DASH_mode, []any{v9}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + tmp20 = v19 + } else { + var tmp21 any + tmp22 := lang.Apply(kw_error_DASH_handler, []any{v9}) + if lang.IsTruthy(tmp22) { + tmp21 = kw_continue + } else { + tmp21 = kw_fail + } + tmp20 = tmp21 + } + tmp17 = tmp20 + } // end let + tmp18, _ := lang.FieldOrMethod(v5, "setErrorMode") + if reflect.TypeOf(tmp18).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorMode is not a function"))) + } + tmp19 := lang.Apply(tmp18, []any{tmp17}) + _ = tmp19 + tmp4 = v5 + } // end let + return tmp4 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_agent = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_agent.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // aget + { + var tmp1 lang.FnFunc + { // function aget__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Aget}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := checkDerefVar(var_glojure_DOT_core_seq) + tmp20 := checkDerefVar(var_glojure_DOT_core_concat) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{sym_glojure_DOT_core_SLASH_int}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := lang.Apply(tmp23, []any{v4}) + tmp25 := lang.Apply(tmp20, []any{tmp22, tmp24}) + tmp26 := lang.Apply(tmp19, []any{tmp25}) + tmp27 := lang.Apply(tmp18, []any{tmp26}) + tmp28 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp27}) + tmp29 := lang.Apply(tmp12, []any{tmp28}) + tmp30 := lang.Apply(tmp11, []any{tmp29}) + tmp31 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp30}) + tmp32 := lang.Apply(tmp5, []any{tmp31}) + return tmp32 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_aget.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx), lang.NewVector(sym_array, sym_idx, sym__AMP_, sym_idxs)), kw_inline, tmp1, kw_doc, "Returns the value at the index/indices. Works on Java arrays of all\n types.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3911), kw_end_DASH_line, int(3911))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(lang.Get, []any{v3, v4}) + return tmp5 + default: + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_aget) + tmp8 := checkDerefVar(var_glojure_DOT_core_aget) + tmp9 := lang.Apply(tmp8, []any{v3, v4}) + tmp10 := lang.Apply(tmp6, []any{tmp7, tmp9, v5}) + return tmp10 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_aget = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_aget.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // amap + { + tmp0 := sym_amap.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_a, sym_idx, sym_ret, sym_expr)), kw_doc, "Maps an expression across an array a, using an index named idx, and\n return value named ret, initialized to a clone of a, then setting \n each element of ret to the evaluation of expr, returning the new \n array ret.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(11), kw_line, int(5273), kw_end_DASH_line, int(5273))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 6) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + v7 := args[5] + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_let}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_apply) + tmp14 := checkDerefVar(var_glojure_DOT_core_vector) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_a__0__auto__}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v4}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{sym_l__1__auto__}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_seq) + tmp25 := checkDerefVar(var_glojure_DOT_core_concat) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{sym_glojure_DOT_core_SLASH_alength}) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := lang.Apply(tmp28, []any{sym_a__0__auto__}) + tmp30 := lang.Apply(tmp25, []any{tmp27, tmp29}) + tmp31 := lang.Apply(tmp24, []any{tmp30}) + tmp32 := lang.Apply(tmp23, []any{tmp31}) + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{v6}) + tmp35 := checkDerefVar(var_glojure_DOT_core_list) + tmp36 := checkDerefVar(var_glojure_DOT_core_seq) + tmp37 := checkDerefVar(var_glojure_DOT_core_concat) + tmp38 := checkDerefVar(var_glojure_DOT_core_list) + tmp39 := lang.Apply(tmp38, []any{sym_glojure_DOT_core_SLASH_aclone}) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{sym_a__0__auto__}) + tmp42 := lang.Apply(tmp37, []any{tmp39, tmp41}) + tmp43 := lang.Apply(tmp36, []any{tmp42}) + tmp44 := lang.Apply(tmp35, []any{tmp43}) + tmp45 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22, tmp32, tmp34, tmp44}) + tmp46 := lang.Apply(tmp15, []any{tmp45}) + tmp47 := lang.Apply(tmp13, []any{tmp14, tmp46}) + tmp48 := lang.Apply(tmp12, []any{tmp47}) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) + tmp50 := checkDerefVar(var_glojure_DOT_core_seq) + tmp51 := checkDerefVar(var_glojure_DOT_core_concat) + tmp52 := checkDerefVar(var_glojure_DOT_core_list) + tmp53 := lang.Apply(tmp52, []any{sym_glojure_DOT_core_SLASH_loop}) + tmp54 := checkDerefVar(var_glojure_DOT_core_list) + tmp55 := checkDerefVar(var_glojure_DOT_core_apply) + tmp56 := checkDerefVar(var_glojure_DOT_core_vector) + tmp57 := checkDerefVar(var_glojure_DOT_core_seq) + tmp58 := checkDerefVar(var_glojure_DOT_core_concat) + tmp59 := checkDerefVar(var_glojure_DOT_core_list) + tmp60 := lang.Apply(tmp59, []any{v5}) + tmp61 := checkDerefVar(var_glojure_DOT_core_list) + tmp62 := lang.Apply(tmp61, []any{int64(0)}) + tmp63 := lang.Apply(tmp58, []any{tmp60, tmp62}) + tmp64 := lang.Apply(tmp57, []any{tmp63}) + tmp65 := lang.Apply(tmp55, []any{tmp56, tmp64}) + tmp66 := lang.Apply(tmp54, []any{tmp65}) + tmp67 := checkDerefVar(var_glojure_DOT_core_list) + tmp68 := checkDerefVar(var_glojure_DOT_core_seq) + tmp69 := checkDerefVar(var_glojure_DOT_core_concat) + tmp70 := checkDerefVar(var_glojure_DOT_core_list) + tmp71 := lang.Apply(tmp70, []any{sym_if}) + tmp72 := checkDerefVar(var_glojure_DOT_core_list) + tmp73 := checkDerefVar(var_glojure_DOT_core_seq) + tmp74 := checkDerefVar(var_glojure_DOT_core_concat) + tmp75 := checkDerefVar(var_glojure_DOT_core_list) + tmp76 := lang.Apply(tmp75, []any{sym_glojure_DOT_core_SLASH__LT_}) + tmp77 := checkDerefVar(var_glojure_DOT_core_list) + tmp78 := lang.Apply(tmp77, []any{v5}) + tmp79 := checkDerefVar(var_glojure_DOT_core_list) + tmp80 := lang.Apply(tmp79, []any{sym_l__1__auto__}) + tmp81 := lang.Apply(tmp74, []any{tmp76, tmp78, tmp80}) + tmp82 := lang.Apply(tmp73, []any{tmp81}) + tmp83 := lang.Apply(tmp72, []any{tmp82}) + tmp84 := checkDerefVar(var_glojure_DOT_core_list) + tmp85 := checkDerefVar(var_glojure_DOT_core_seq) + tmp86 := checkDerefVar(var_glojure_DOT_core_concat) + tmp87 := checkDerefVar(var_glojure_DOT_core_list) + tmp88 := lang.Apply(tmp87, []any{sym_do}) + tmp89 := checkDerefVar(var_glojure_DOT_core_list) + tmp90 := checkDerefVar(var_glojure_DOT_core_seq) + tmp91 := checkDerefVar(var_glojure_DOT_core_concat) + tmp92 := checkDerefVar(var_glojure_DOT_core_list) + tmp93 := lang.Apply(tmp92, []any{sym_glojure_DOT_core_SLASH_aset}) + tmp94 := checkDerefVar(var_glojure_DOT_core_list) + tmp95 := lang.Apply(tmp94, []any{v6}) + tmp96 := checkDerefVar(var_glojure_DOT_core_list) + tmp97 := lang.Apply(tmp96, []any{v5}) + tmp98 := checkDerefVar(var_glojure_DOT_core_list) + tmp99 := lang.Apply(tmp98, []any{v7}) + tmp100 := lang.Apply(tmp91, []any{tmp93, tmp95, tmp97, tmp99}) + tmp101 := lang.Apply(tmp90, []any{tmp100}) + tmp102 := lang.Apply(tmp89, []any{tmp101}) + tmp103 := checkDerefVar(var_glojure_DOT_core_list) + tmp104 := checkDerefVar(var_glojure_DOT_core_seq) + tmp105 := checkDerefVar(var_glojure_DOT_core_concat) + tmp106 := checkDerefVar(var_glojure_DOT_core_list) + tmp107 := lang.Apply(tmp106, []any{sym_recur}) + tmp108 := checkDerefVar(var_glojure_DOT_core_list) + tmp109 := checkDerefVar(var_glojure_DOT_core_seq) + tmp110 := checkDerefVar(var_glojure_DOT_core_concat) + tmp111 := checkDerefVar(var_glojure_DOT_core_list) + tmp112 := lang.Apply(tmp111, []any{sym_glojure_DOT_core_SLASH_unchecked_DASH_inc}) + tmp113 := checkDerefVar(var_glojure_DOT_core_list) + tmp114 := lang.Apply(tmp113, []any{v5}) + tmp115 := lang.Apply(tmp110, []any{tmp112, tmp114}) + tmp116 := lang.Apply(tmp109, []any{tmp115}) + tmp117 := lang.Apply(tmp108, []any{tmp116}) + tmp118 := lang.Apply(tmp105, []any{tmp107, tmp117}) + tmp119 := lang.Apply(tmp104, []any{tmp118}) + tmp120 := lang.Apply(tmp103, []any{tmp119}) + tmp121 := lang.Apply(tmp86, []any{tmp88, tmp102, tmp120}) + tmp122 := lang.Apply(tmp85, []any{tmp121}) + tmp123 := lang.Apply(tmp84, []any{tmp122}) + tmp124 := checkDerefVar(var_glojure_DOT_core_list) + tmp125 := lang.Apply(tmp124, []any{v6}) + tmp126 := lang.Apply(tmp69, []any{tmp71, tmp83, tmp123, tmp125}) + tmp127 := lang.Apply(tmp68, []any{tmp126}) + tmp128 := lang.Apply(tmp67, []any{tmp127}) + tmp129 := lang.Apply(tmp51, []any{tmp53, tmp66, tmp128}) + tmp130 := lang.Apply(tmp50, []any{tmp129}) + tmp131 := lang.Apply(tmp49, []any{tmp130}) + tmp132 := lang.Apply(tmp9, []any{tmp11, tmp48, tmp131}) + tmp133 := lang.Apply(tmp8, []any{tmp132}) + return tmp133 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_amap = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_amap.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ancestors + { + tmp0 := sym_ancestors.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_tag), lang.NewVector(sym_h, sym_tag)), kw_doc, "Returns the immediate and indirect parents of tag, either via a Java type\n inheritance relationship or a relationship established via derive. h\n must be a hierarchy obtained from make-hierarchy, if not supplied\n defaults to the global hierarchy", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(5577), kw_end_DASH_line, int(5577))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_ancestors) + tmp4 := checkDerefVar(var_glojure_DOT_core_global_DASH_hierarchy) + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_not_DASH_empty) + var tmp5 any + { // let + // let binding "ta" + tmp6 := checkDerefVar(var_glojure_DOT_core_get) + tmp7 := lang.Apply(kw_ancestors, []any{v2}) + tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + tmp11 := checkDerefVar(var_glojure_DOT_core_class_QMARK_) + tmp12 := lang.Apply(tmp11, []any{v3}) + if lang.IsTruthy(tmp12) { + var tmp13 any + { // let + // let binding "superclasses" + tmp14 := checkDerefVar(var_glojure_DOT_core_set) + tmp15 := checkDerefVar(var_glojure_DOT_core_supers) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp14, []any{tmp16}) + var v18 any = tmp17 + _ = v18 + tmp19 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp20 := checkDerefVar(var_glojure_DOT_core_into1) + tmp21 := checkDerefVar(var_glojure_DOT_core_cons) + tmp22 := checkDerefVar(var_glojure_DOT_core_map) + var tmp23 lang.FnFunc + tmp23 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v24 := args[0] + _ = v24 + tmp25 := checkDerefVar(var_glojure_DOT_core_get) + tmp26 := lang.Apply(kw_ancestors, []any{v2}) + tmp27 := lang.Apply(tmp25, []any{tmp26, v24}) + return tmp27 + }) + tmp24 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5590), kw_column, int(32), kw_end_DASH_line, int(5590), kw_end_DASH_column, int(54)) + tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp26 := lang.Apply(tmp22, []any{tmp25, v18}) + tmp27 := lang.Apply(tmp21, []any{v9, tmp26}) + tmp28 := lang.Apply(tmp19, []any{tmp20, v18, tmp27}) + tmp13 = tmp28 + } // end let + tmp10 = tmp13 + } else { + tmp10 = v9 + } + tmp5 = tmp10 + } // end let + tmp6 := lang.Apply(tmp4, []any{tmp5}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ancestors = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ancestors.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // and + { + tmp0 := sym_and.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_x), lang.NewVector(sym_x, sym__AMP_, sym_next)), kw_doc, "Evaluates exprs one at a time, from left to right. If a form\n returns logical false (nil or false), and returns that value and\n doesn't evaluate any of the other expressions, otherwise it returns\n the value of the last expr. (and) returns true.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(11), kw_line, int(835), kw_end_DASH_line, int(835))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + return true + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + return v4 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_let}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + tmp12 := checkDerefVar(var_glojure_DOT_core_vector) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_and__0__auto__}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v4}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp19}) + tmp21 := lang.Apply(tmp11, []any{tmp12, tmp20}) + tmp22 := lang.Apply(tmp10, []any{tmp21}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_seq) + tmp25 := checkDerefVar(var_glojure_DOT_core_concat) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{sym_if}) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := lang.Apply(tmp28, []any{sym_and__0__auto__}) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := checkDerefVar(var_glojure_DOT_core_seq) + tmp32 := checkDerefVar(var_glojure_DOT_core_concat) + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{sym_glojure_DOT_core_SLASH_and}) + tmp35 := lang.Apply(tmp32, []any{tmp34, v5}) + tmp36 := lang.Apply(tmp31, []any{tmp35}) + tmp37 := lang.Apply(tmp30, []any{tmp36}) + tmp38 := checkDerefVar(var_glojure_DOT_core_list) + tmp39 := lang.Apply(tmp38, []any{sym_and__0__auto__}) + tmp40 := lang.Apply(tmp25, []any{tmp27, tmp29, tmp37, tmp39}) + tmp41 := lang.Apply(tmp24, []any{tmp40}) + tmp42 := lang.Apply(tmp23, []any{tmp41}) + tmp43 := lang.Apply(tmp7, []any{tmp9, tmp22, tmp42}) + tmp44 := lang.Apply(tmp6, []any{tmp43}) + return tmp44 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_and = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_and.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // array-map + { + tmp0 := sym_array_DASH_map.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym__AMP_, sym_keyvals)), kw_doc, "Constructs an array-map. If any keys are equal, they are handled as\n if by repeated uses of assoc.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(4378), kw_end_DASH_line, int(4378))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp2, ok := lang.FieldOrMethod(nil, "EMPTY") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "EMPTY"))) + } + var tmp3 any + switch reflect.TypeOf(tmp2).Kind() { + case reflect.Func: + tmp3 = lang.Apply(tmp2, nil) + default: + tmp3 = tmp2 + } + return tmp3 + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + var tmp3 any + { // let + // let binding "ary" + tmp4 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core_odd_QMARK_) + tmp9 := checkDerefVar(var_glojure_DOT_core_alength) + tmp10 := lang.Apply(tmp9, []any{v6}) + tmp11 := lang.Apply(tmp8, []any{tmp10}) + if lang.IsTruthy(tmp11) { + tmp12 := checkDerefVar(var_glojure_DOT_core_str) + tmp13 := checkDerefVar(var_glojure_DOT_core_last) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(tmp12, []any{"No value supplied for key: ", tmp14}) + tmp16 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp15}) + panic(tmp16) + } else { + tmp17 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{v6}) + tmp7 = tmp17 + } + tmp3 = tmp7 + } // end let + return tmp3 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_array_DASH_map = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_array_DASH_map.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // aset + { + var tmp1 lang.FnFunc + { // function aset__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym__DOT_}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_Aset}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{sym_glojure_DOT_core_SLASH_int}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v4}) + tmp26 := lang.Apply(tmp21, []any{tmp23, tmp25}) + tmp27 := lang.Apply(tmp20, []any{tmp26}) + tmp28 := lang.Apply(tmp19, []any{tmp27}) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{v5}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp28, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp12, []any{tmp32}) + tmp34 := lang.Apply(tmp7, []any{tmp9, tmp11, tmp33}) + tmp35 := lang.Apply(tmp6, []any{tmp34}) + return tmp35 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_aset.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx, sym_val), lang.NewVector(sym_array, sym_idx, sym_idx2, sym__AMP_, sym_idxv)), kw_inline, tmp1, kw_doc, "Sets the value at the index/indices. Works on Java arrays of\n reference types. Returns val.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(3)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3922), kw_end_DASH_line, int(3922))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6 := lang.Apply(lang.SliceSet, []any{v3, v4, v5}) + _ = tmp6 + return v5 + default: + checkArity(args, 3) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_apply) + tmp8 := checkDerefVar(var_glojure_DOT_core_aset) + tmp9 := checkDerefVar(var_glojure_DOT_core_aget) + tmp10 := lang.Apply(tmp9, []any{v3, v4}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v5, v6}) + return tmp11 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_aset = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_aset.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // aset-boolean + { + tmp0 := sym_aset_DASH_boolean.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx, sym_val), lang.NewVector(sym_array, sym_idx, sym_idx2, sym__AMP_, sym_idxv)), kw_doc, "Sets the value at the index/indices. Works on arrays of boolean. Returns val.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(3), kw_line, int(3956), kw_end_DASH_line, int(3958))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_boolean) + tmp6 := lang.Apply(tmp5, []any{v4}) + tmp7, _ := lang.FieldOrMethod(nil, "setBoolean") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setBoolean is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v2, v3, tmp6}) + _ = tmp8 + return v4 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_boolean) + tmp8 := checkDerefVar(var_glojure_DOT_core_aget) + tmp9 := lang.Apply(tmp8, []any{v2, v3}) + tmp10 := lang.Apply(tmp6, []any{tmp7, tmp9, v4, v5}) + return tmp10 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_aset_DASH_boolean = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_aset_DASH_boolean.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // aset-byte + { + tmp0 := sym_aset_DASH_byte.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx, sym_val), lang.NewVector(sym_array, sym_idx, sym_idx2, sym__AMP_, sym_idxv)), kw_doc, "Sets the value at the index/indices. Works on arrays of byte. Returns val.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(3), kw_line, int(3976), kw_end_DASH_line, int(3978))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_byte) + tmp6 := lang.Apply(tmp5, []any{v4}) + tmp7, _ := lang.FieldOrMethod(nil, "setByte") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setByte is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v2, v3, tmp6}) + _ = tmp8 + return v4 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_byte) + tmp8 := checkDerefVar(var_glojure_DOT_core_aget) + tmp9 := lang.Apply(tmp8, []any{v2, v3}) + tmp10 := lang.Apply(tmp6, []any{tmp7, tmp9, v4, v5}) + return tmp10 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_aset_DASH_byte = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_aset_DASH_byte.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // aset-char + { + tmp0 := sym_aset_DASH_char.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx, sym_val), lang.NewVector(sym_array, sym_idx, sym_idx2, sym__AMP_, sym_idxv)), kw_doc, "Sets the value at the index/indices. Works on arrays of char. Returns val.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(3), kw_line, int(3981), kw_end_DASH_line, int(3983))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_char) + tmp6 := lang.Apply(tmp5, []any{v4}) + tmp7, _ := lang.FieldOrMethod(nil, "setChar") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setChar is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v2, v3, tmp6}) + _ = tmp8 + return v4 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_char) + tmp8 := checkDerefVar(var_glojure_DOT_core_aget) + tmp9 := lang.Apply(tmp8, []any{v2, v3}) + tmp10 := lang.Apply(tmp6, []any{tmp7, tmp9, v4, v5}) + return tmp10 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_aset_DASH_char = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_aset_DASH_char.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // aset-double + { + tmp0 := sym_aset_DASH_double.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx, sym_val), lang.NewVector(sym_array, sym_idx, sym_idx2, sym__AMP_, sym_idxv)), kw_doc, "Sets the value at the index/indices. Works on arrays of double. Returns val.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(3), kw_line, int(3966), kw_end_DASH_line, int(3968))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_double) + tmp6 := lang.Apply(tmp5, []any{v4}) + tmp7, _ := lang.FieldOrMethod(nil, "setDouble") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setDouble is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v2, v3, tmp6}) + _ = tmp8 + return v4 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_double) + tmp8 := checkDerefVar(var_glojure_DOT_core_aget) + tmp9 := lang.Apply(tmp8, []any{v2, v3}) + tmp10 := lang.Apply(tmp6, []any{tmp7, tmp9, v4, v5}) + return tmp10 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_aset_DASH_double = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_aset_DASH_double.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // aset-float + { + tmp0 := sym_aset_DASH_float.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx, sym_val), lang.NewVector(sym_array, sym_idx, sym_idx2, sym__AMP_, sym_idxv)), kw_doc, "Sets the value at the index/indices. Works on arrays of float. Returns val.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(3), kw_line, int(3961), kw_end_DASH_line, int(3963))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_float) + tmp6 := lang.Apply(tmp5, []any{v4}) + tmp7, _ := lang.FieldOrMethod(nil, "setFloat") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setFloat is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v2, v3, tmp6}) + _ = tmp8 + return v4 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_float) + tmp8 := checkDerefVar(var_glojure_DOT_core_aget) + tmp9 := lang.Apply(tmp8, []any{v2, v3}) + tmp10 := lang.Apply(tmp6, []any{tmp7, tmp9, v4, v5}) + return tmp10 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_aset_DASH_float = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_aset_DASH_float.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // aset-int + { + tmp0 := sym_aset_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx, sym_val), lang.NewVector(sym_array, sym_idx, sym_idx2, sym__AMP_, sym_idxv)), kw_doc, "Sets the value at the index/indices. Works on arrays of int. Returns val.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(3), kw_line, int(3946), kw_end_DASH_line, int(3948))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_int) + tmp6 := lang.Apply(tmp5, []any{v4}) + tmp7, _ := lang.FieldOrMethod(nil, "setInt") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setInt is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v2, v3, tmp6}) + _ = tmp8 + return v4 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_int) + tmp8 := checkDerefVar(var_glojure_DOT_core_aget) + tmp9 := lang.Apply(tmp8, []any{v2, v3}) + tmp10 := lang.Apply(tmp6, []any{tmp7, tmp9, v4, v5}) + return tmp10 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_aset_DASH_int = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_aset_DASH_int.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // aset-long + { + tmp0 := sym_aset_DASH_long.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx, sym_val), lang.NewVector(sym_array, sym_idx, sym_idx2, sym__AMP_, sym_idxv)), kw_doc, "Sets the value at the index/indices. Works on arrays of long. Returns val.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(3), kw_line, int(3951), kw_end_DASH_line, int(3953))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_long) + tmp6 := lang.Apply(tmp5, []any{v4}) + tmp7, _ := lang.FieldOrMethod(nil, "setLong") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setLong is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v2, v3, tmp6}) + _ = tmp8 + return v4 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_long) + tmp8 := checkDerefVar(var_glojure_DOT_core_aget) + tmp9 := lang.Apply(tmp8, []any{v2, v3}) + tmp10 := lang.Apply(tmp6, []any{tmp7, tmp9, v4, v5}) + return tmp10 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_aset_DASH_long = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_aset_DASH_long.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // aset-short + { + tmp0 := sym_aset_DASH_short.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx, sym_val), lang.NewVector(sym_array, sym_idx, sym_idx2, sym__AMP_, sym_idxv)), kw_doc, "Sets the value at the index/indices. Works on arrays of short. Returns val.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(3), kw_line, int(3971), kw_end_DASH_line, int(3973))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_short) + tmp6 := lang.Apply(tmp5, []any{v4}) + tmp7, _ := lang.FieldOrMethod(nil, "setShort") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setShort is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v2, v3, tmp6}) + _ = tmp8 + return v4 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_short) + tmp8 := checkDerefVar(var_glojure_DOT_core_aget) + tmp9 := lang.Apply(tmp8, []any{v2, v3}) + tmp10 := lang.Apply(tmp6, []any{tmp7, tmp9, v4, v5}) + return tmp10 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_aset_DASH_short = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_aset_DASH_short.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // assert-valid-fdecl + { + tmp0 := sym_assert_DASH_valid_DASH_fdecl.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_fdecl)), kw_doc, "A good fdecl looks like (([a] ...) ([a b] ...)) near the end of defn.", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(42), kw_column, int(8), kw_line, int(7502), kw_end_DASH_line, int(7502), kw_private, true, kw_dynamic, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_empty_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + tmp6 := lang.Apply(lang.NewIllegalArgumentError, []any{"Parameter declaration missing"}) + panic(tmp6) + } else { + } + _ = tmp3 + var tmp7 any + { // let + // let binding "argdecls" + tmp8 := checkDerefVar(var_glojure_DOT_core_map) + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v10 := args[0] + _ = v10 + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp13 := lang.Apply(tmp12, []any{v10}) + if lang.IsTruthy(tmp13) { + tmp14 := checkDerefVar(var_glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v10}) + tmp11 = tmp15 + } else { + var tmp16 any + tmp17 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp18 := checkDerefVar(var_glojure_DOT_core_first) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp17, []any{tmp19}) + if lang.IsTruthy(tmp20) { + tmp21 := checkDerefVar(var_glojure_DOT_core_str) + tmp22 := lang.Apply(tmp21, []any{"Invalid signature \"", v10, "\" should be a list"}) + tmp16 = tmp22 + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := lang.Apply(tmp23, []any{"Parameter declaration \"", v10, "\" should be a vector"}) + tmp16 = tmp24 + } + tmp25 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp16}) + panic(tmp25) + } + return tmp11 + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7508), kw_column, int(20), kw_end_DASH_line, int(7517), kw_end_DASH_column, int(59)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp12 := lang.Apply(tmp8, []any{tmp11, v2}) + var v13 any = tmp12 + _ = v13 + // let binding "bad-args" + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_remove) + var tmp16 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v17 := args[0] + _ = v17 + tmp18 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp19 := lang.Apply(tmp18, []any{v17}) + return tmp19 + }) + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7519), kw_column, int(31), kw_end_DASH_line, int(7519), kw_end_DASH_column, int(42)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp19 := lang.Apply(tmp15, []any{tmp18, v13}) + tmp20 := lang.Apply(tmp14, []any{tmp19}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + if lang.IsTruthy(v21) { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v21}) + tmp26 := lang.Apply(tmp23, []any{"Parameter declaration \"", tmp25, "\" should be a vector"}) + tmp27 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp26}) + panic(tmp27) + } else { + } + tmp7 = tmp22 + } // end let + return tmp7 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_assert_DASH_valid_DASH_fdecl = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_assert_DASH_valid_DASH_fdecl.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // atom + { + tmp0 := sym_atom.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym__AMP_, sym_options)), kw_doc, "Creates and returns an Atom with an initial value of x and zero or\n more options (in any order):\n\n :meta metadata-map\n\n :validator validate-fn\n\n If metadata-map is supplied, it will become the metadata on the\n atom. validate-fn must be nil or a side-effect-free fn of one\n argument, which will be passed the intended new state on any state\n change. If the new state is unacceptable, the validate-fn should\n return false or throw an exception.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(2325), kw_end_DASH_line, int(2325))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(lang.NewAtom, []any{v2}) + return tmp3 + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_setup_DASH_reference) + tmp5 := checkDerefVar(var_glojure_DOT_core_atom) + tmp6 := lang.Apply(tmp5, []any{v2}) + tmp7 := lang.Apply(tmp4, []any{tmp6, v3}) + return tmp7 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_atom = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_atom.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // binding + { + tmp0 := sym_binding.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "binding => var-symbol init-expr\n\n Creates new bindings for the (already-existing) vars, with the\n supplied initial values, executes the exprs in an implicit do, then\n re-establishes the bindings that existed before. The new bindings\n are made in parallel (unlike let); all init-exprs are evaluated\n before the vars are bound to their new values.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(1945), kw_end_DASH_line, int(1945))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v4}) + if lang.IsTruthy(tmp8) { + } else { + tmp9 := checkDerefVar(var_glojure_DOT_core_str) + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp13 := checkDerefVar(var_glojure_DOT_core_meta) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(kw_line, []any{tmp14}) + tmp16 := lang.Apply(tmp9, []any{tmp11, " requires ", "a vector for its binding", " in ", tmp12, ":", tmp15}) + tmp17 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp16}) + panic(tmp17) + } + _ = tmp6 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_even_QMARK_) + tmp20 := checkDerefVar(var_glojure_DOT_core_count) + tmp21 := lang.Apply(tmp20, []any{v4}) + tmp22 := lang.Apply(tmp19, []any{tmp21}) + if lang.IsTruthy(tmp22) { + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp27 := checkDerefVar(var_glojure_DOT_core_meta) + tmp28 := lang.Apply(tmp27, []any{v2}) + tmp29 := lang.Apply(kw_line, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp25, " requires ", "an even number of forms in binding vector", " in ", tmp26, ":", tmp29}) + tmp31 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp31) + } + _ = tmp18 + var tmp32 any + { // let + // let binding "var-ize" + var tmp33 lang.FnFunc + tmp33 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v34 := args[0] + _ = v34 + var tmp35 any + { // let + // let binding "ret" + tmp36 := lang.NewVector() + tmp37 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(1959), kw_column, int(30), kw_end_DASH_line, int(1959), kw_end_DASH_column, int(31)) + tmp38, err := lang.WithMeta(tmp36, tmp37.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v39 any = tmp38 + _ = v39 + // let binding "vvs" + tmp40 := checkDerefVar(var_glojure_DOT_core_seq) + tmp41 := lang.Apply(tmp40, []any{v34}) + var v42 any = tmp41 + _ = v42 + for { + var tmp43 any + if lang.IsTruthy(v42) { + tmp45 := checkDerefVar(var_glojure_DOT_core_conj) + tmp46 := checkDerefVar(var_glojure_DOT_core_conj) + tmp47 := checkDerefVar(var_glojure_DOT_core_seq) + tmp48 := checkDerefVar(var_glojure_DOT_core_concat) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) + tmp50 := lang.Apply(tmp49, []any{sym_var}) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := checkDerefVar(var_glojure_DOT_core_first) + tmp53 := lang.Apply(tmp52, []any{v42}) + tmp54 := lang.Apply(tmp51, []any{tmp53}) + tmp55 := lang.Apply(tmp48, []any{tmp50, tmp54}) + tmp56 := lang.Apply(tmp47, []any{tmp55}) + tmp57 := lang.Apply(tmp46, []any{v39, tmp56}) + tmp58 := checkDerefVar(var_glojure_DOT_core_second) + tmp59 := lang.Apply(tmp58, []any{v42}) + tmp60 := lang.Apply(tmp45, []any{tmp57, tmp59}) + var tmp44 any = tmp60 + tmp62 := checkDerefVar(var_glojure_DOT_core_next) + tmp63 := checkDerefVar(var_glojure_DOT_core_next) + tmp64 := lang.Apply(tmp63, []any{v42}) + tmp65 := lang.Apply(tmp62, []any{tmp64}) + var tmp61 any = tmp65 + v39 = tmp44 + v42 = tmp61 + continue + } else { + tmp66 := checkDerefVar(var_glojure_DOT_core_seq) + tmp67 := lang.Apply(tmp66, []any{v39}) + tmp43 = tmp67 + } + tmp35 = tmp43 + break + } + } // end let + return tmp35 + }) + tmp34 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(1958), kw_column, int(17), kw_end_DASH_line, int(1963), kw_end_DASH_column, int(34)) + tmp35, err := lang.WithMeta(tmp33, tmp34.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v36 any = tmp35 + _ = v36 + tmp37 := checkDerefVar(var_glojure_DOT_core_seq) + tmp38 := checkDerefVar(var_glojure_DOT_core_concat) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := lang.Apply(tmp39, []any{sym_glojure_DOT_core_SLASH_let}) + tmp41 := checkDerefVar(var_glojure_DOT_core_list) + tmp42 := checkDerefVar(var_glojure_DOT_core_apply) + tmp43 := checkDerefVar(var_glojure_DOT_core_vector) + tmp44 := checkDerefVar(var_glojure_DOT_core_seq) + tmp45 := checkDerefVar(var_glojure_DOT_core_concat) + tmp46 := lang.Apply(tmp45, nil) + tmp47 := lang.Apply(tmp44, []any{tmp46}) + tmp48 := lang.Apply(tmp42, []any{tmp43, tmp47}) + tmp49 := lang.Apply(tmp41, []any{tmp48}) + tmp50 := checkDerefVar(var_glojure_DOT_core_list) + tmp51 := checkDerefVar(var_glojure_DOT_core_seq) + tmp52 := checkDerefVar(var_glojure_DOT_core_concat) + tmp53 := checkDerefVar(var_glojure_DOT_core_list) + tmp54 := lang.Apply(tmp53, []any{sym_glojure_DOT_core_SLASH_push_DASH_thread_DASH_bindings}) + tmp55 := checkDerefVar(var_glojure_DOT_core_list) + tmp56 := checkDerefVar(var_glojure_DOT_core_seq) + tmp57 := checkDerefVar(var_glojure_DOT_core_concat) + tmp58 := checkDerefVar(var_glojure_DOT_core_list) + tmp59 := lang.Apply(tmp58, []any{sym_glojure_DOT_core_SLASH_hash_DASH_map}) + tmp60 := lang.Apply(v36, []any{v4}) + tmp61 := lang.Apply(tmp57, []any{tmp59, tmp60}) + tmp62 := lang.Apply(tmp56, []any{tmp61}) + tmp63 := lang.Apply(tmp55, []any{tmp62}) + tmp64 := lang.Apply(tmp52, []any{tmp54, tmp63}) + tmp65 := lang.Apply(tmp51, []any{tmp64}) + tmp66 := lang.Apply(tmp50, []any{tmp65}) + tmp67 := checkDerefVar(var_glojure_DOT_core_list) + tmp68 := checkDerefVar(var_glojure_DOT_core_seq) + tmp69 := checkDerefVar(var_glojure_DOT_core_concat) + tmp70 := checkDerefVar(var_glojure_DOT_core_list) + tmp71 := lang.Apply(tmp70, []any{sym_try}) + tmp72 := checkDerefVar(var_glojure_DOT_core_list) + tmp73 := checkDerefVar(var_glojure_DOT_core_seq) + tmp74 := checkDerefVar(var_glojure_DOT_core_concat) + tmp75 := checkDerefVar(var_glojure_DOT_core_list) + tmp76 := lang.Apply(tmp75, []any{sym_finally}) + tmp77 := checkDerefVar(var_glojure_DOT_core_list) + tmp78 := checkDerefVar(var_glojure_DOT_core_seq) + tmp79 := checkDerefVar(var_glojure_DOT_core_concat) + tmp80 := checkDerefVar(var_glojure_DOT_core_list) + tmp81 := lang.Apply(tmp80, []any{sym_glojure_DOT_core_SLASH_pop_DASH_thread_DASH_bindings}) + tmp82 := lang.Apply(tmp79, []any{tmp81}) + tmp83 := lang.Apply(tmp78, []any{tmp82}) + tmp84 := lang.Apply(tmp77, []any{tmp83}) + tmp85 := lang.Apply(tmp74, []any{tmp76, tmp84}) + tmp86 := lang.Apply(tmp73, []any{tmp85}) + tmp87 := lang.Apply(tmp72, []any{tmp86}) + tmp88 := lang.Apply(tmp69, []any{tmp71, v5, tmp87}) + tmp89 := lang.Apply(tmp68, []any{tmp88}) + tmp90 := lang.Apply(tmp67, []any{tmp89}) + tmp91 := lang.Apply(tmp38, []any{tmp40, tmp49, tmp66, tmp90}) + tmp92 := lang.Apply(tmp37, []any{tmp91}) + tmp32 = tmp92 + } // end let + return tmp32 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_binding = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_binding.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bound-fn* + { + tmp0 := sym_bound_DASH_fn_STAR_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f)), kw_doc, "Returns a function, which will install the same bindings in effect as in\n the thread at the time bound-fn* was called and then call f with any given\n arguments. This may be used to define a helper function which runs on a\n different thread, but needs the same bindings in place.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(1992), kw_end_DASH_line, int(1992))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "bindings" + tmp4 := checkDerefVar(var_glojure_DOT_core_get_DASH_thread_DASH_bindings) + tmp5 := lang.Apply(tmp4, nil) + var v6 any = tmp5 + _ = v6 + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v8 any = lang.NewList(args[0:]...) + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_apply) + tmp10 := checkDerefVar(var_glojure_DOT_core_with_DASH_bindings_STAR_) + tmp11 := lang.Apply(tmp9, []any{tmp10, v6, v2, v8}) + return tmp11 + } + }) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2001), kw_column, int(5), kw_end_DASH_line, int(2002), kw_end_DASH_column, int(45)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp3 = tmp9 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bound_DASH_fn_STAR_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bound_DASH_fn_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // case-map + { + tmp0 := sym_case_DASH_map.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_case_DASH_f, sym_test_DASH_f, sym_tests, sym_thens)), kw_doc, "Transforms a sequence of test constants and a corresponding sequence of then\n expressions into a sorted map to be consumed by case*. The form of the map\n entries are {(case-f test) [(test-f test) then]}.", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(8), kw_line, int(6614), kw_end_DASH_line, int(6614), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_into1) + tmp7 := checkDerefVar(var_glojure_DOT_core_sorted_DASH_map) + tmp8 := lang.Apply(tmp7, nil) + tmp9 := checkDerefVar(var_glojure_DOT_core_zipmap) + tmp10 := checkDerefVar(var_glojure_DOT_core_map) + tmp11 := lang.Apply(tmp10, []any{v2, v4}) + tmp12 := checkDerefVar(var_glojure_DOT_core_map) + tmp13 := checkDerefVar(var_glojure_DOT_core_vector) + tmp14 := checkDerefVar(var_glojure_DOT_core_map) + tmp15 := lang.Apply(tmp14, []any{v3, v4}) + tmp16 := lang.Apply(tmp12, []any{tmp13, tmp15, v5}) + tmp17 := lang.Apply(tmp9, []any{tmp11, tmp16}) + tmp18 := lang.Apply(tmp6, []any{tmp8, tmp17}) + return tmp18 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_case_DASH_map = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_case_DASH_map.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // check-valid-options + { + tmp0 := sym_check_DASH_valid_DASH_options.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_options, sym__AMP_, sym_valid_DASH_keys)), kw_doc, "Throws an exception if the given option map contains keys not listed\n as valid, else returns nil.", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(35), kw_column, int(7), kw_line, int(1709), kw_end_DASH_line, int(1709), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_disj) + tmp8 := checkDerefVar(var_glojure_DOT_core_apply) + tmp9 := checkDerefVar(var_glojure_DOT_core_hash_DASH_set) + tmp10 := checkDerefVar(var_glojure_DOT_core_keys) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := lang.Apply(tmp8, []any{tmp9, tmp11}) + tmp13 := lang.Apply(tmp6, []any{tmp7, tmp12, v3}) + tmp14 := lang.Apply(tmp5, []any{tmp13}) + if lang.IsTruthy(tmp14) { + tmp15 := checkDerefVar(var_glojure_DOT_core_apply) + tmp16 := checkDerefVar(var_glojure_DOT_core_str) + tmp17 := checkDerefVar(var_glojure_DOT_core_first) + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := checkDerefVar(var_glojure_DOT_core_map) + var tmp20 lang.FnFunc + tmp20 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v21 := args[0] + _ = v21 + tmp22 := checkDerefVar(var_glojure_DOT_core_str) + tmp23 := lang.Apply(tmp22, []any{", ", v21}) + return tmp23 + }) + tmp21 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(1718), kw_column, int(16), kw_end_DASH_line, int(1718), kw_end_DASH_column, int(28)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp23 := checkDerefVar(var_glojure_DOT_core_rest) + tmp24 := lang.Apply(tmp23, []any{v3}) + tmp25 := lang.Apply(tmp19, []any{tmp22, tmp24}) + tmp26 := lang.Apply(tmp15, []any{tmp16, "Only these options are valid: ", tmp18, tmp25}) + tmp27 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp26}) + panic(tmp27) + } else { + } + return tmp4 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_check_DASH_valid_DASH_options = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_check_DASH_valid_DASH_options.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // clear-agent-errors + { + tmp0 := sym_clear_DASH_agent_DASH_errors.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a)), kw_doc, "DEPRECATED: Use 'restart-agent' instead.\n Clears any exceptions thrown during asynchronous actions of the\n agent, allowing subsequent actions to occur.", kw_file, "glojure/core.glj", kw_deprecated, "1.2", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(24), kw_column, int(7), kw_line, int(2244), kw_end_DASH_line, int(2244))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_restart_DASH_agent) + tmp4, ok := lang.FieldOrMethod(v2, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "Deref"))) + } + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { + case reflect.Func: + tmp5 = lang.Apply(tmp4, nil) + default: + tmp5 = tmp4 + } + tmp6 := lang.Apply(tmp3, []any{v2, tmp5}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_clear_DASH_agent_DASH_errors = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_clear_DASH_agent_DASH_errors.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // declare + { + tmp0 := sym_declare.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_names)), kw_doc, "defs the supplied var names with no bindings, useful for making forward declarations.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(2768), kw_end_DASH_line, int(2768))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym_do}) + tmp9 := checkDerefVar(var_glojure_DOT_core_map) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v11 := args[0] + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_vary_DASH_meta) + tmp14 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp15 := lang.Apply(tmp13, []any{v11, tmp14, kw_declared, true}) + tmp16 := lang.Apply(tmp12, []any{sym_def, tmp15}) + return tmp16 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2771), kw_column, int(25), kw_end_DASH_line, int(2771), kw_end_DASH_column, int(71)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := lang.Apply(tmp9, []any{tmp12, v4}) + tmp14 := lang.Apply(tmp6, []any{tmp8, tmp13}) + tmp15 := lang.Apply(tmp5, []any{tmp14}) + return tmp15 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_declare = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_declare.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // dedupe + { + tmp0 := sym_dedupe.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_coll)), kw_doc, "Returns a lazy sequence removing consecutive duplicates in coll.\n Returns a transducer when no collection is provided.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(7681), kw_end_DASH_line, int(7681))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + var tmp4 any + { // let + // let binding "pv" + tmp5 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) + tmp6 := lang.Apply(tmp5, []any{kw_glojure_DOT_core_SLASH_none}) + var v7 any = tmp6 + _ = v7 + var tmp8 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp9 := lang.Apply(v3, nil) + return tmp9 + case 1: + v9 := args[0] + _ = v9 + tmp10 := lang.Apply(v3, []any{v9}) + return tmp10 + case 2: + v9 := args[0] + _ = v9 + v10 := args[1] + _ = v10 + var tmp11 any + { // let + // let binding "prior" + tmp12 := checkDerefVar(var_glojure_DOT_core_deref) + tmp13 := lang.Apply(tmp12, []any{v7}) + var v14 any = tmp13 + _ = v14 + tmp15 := checkDerefVar(var_glojure_DOT_core_vreset_BANG_) + tmp16 := lang.Apply(tmp15, []any{v7, v10}) + _ = tmp16 + var tmp17 any + tmp18 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp19 := lang.Apply(tmp18, []any{v14, v10}) + if lang.IsTruthy(tmp19) { + tmp17 = v9 + } else { + tmp20 := lang.Apply(v3, []any{v9, v10}) + tmp17 = tmp20 + } + tmp11 = tmp17 + } // end let + return tmp11 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7688), kw_column, int(8), kw_end_DASH_line, int(7696), kw_end_DASH_column, int(37)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp4 = tmp10 + } // end let + return tmp4 + }) + tmp3 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7686), kw_column, int(4), kw_end_DASH_line, int(7696), kw_end_DASH_column, int(39)) + tmp4, err := lang.WithMeta(tmp2, tmp3.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp4 + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_sequence) + tmp4 := checkDerefVar(var_glojure_DOT_core_dedupe) + tmp5 := lang.Apply(tmp4, nil) + tmp6 := lang.Apply(tmp3, []any{tmp5, v2}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_dedupe = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_dedupe.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // defmulti + { + tmp0 := sym_defmulti.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym_docstring_QMARK_, sym_attr_DASH_map_QMARK_, sym_dispatch_DASH_fn, sym__AMP_, sym_options)), kw_doc, "Creates a new multimethod with the associated dispatch function.\n The docstring and attr-map are optional.\n\n Options are key-value pairs and may be one of:\n\n :default\n\n The default dispatch value, defaults to :default\n\n :hierarchy\n\n The value used for hierarchical dispatch (e.g. ::square is-a ::shape)\n\n Hierarchies are type-like relationships that do not depend upon type\n inheritance. By default Clojure's multimethods dispatch off of a\n global hierarchy map. However, a hierarchy relationship can be\n created with the derive function used to augment the root ancestor\n created with make-hierarchy.\n\n Multimethods expect the value of the hierarchy option to be supplied as\n a reference type e.g. a var (i.e. via the Var-quote dispatch macro #'\n or the var special form).", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(11), kw_line, int(1723), kw_end_DASH_line, int(1723))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "docstring" + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp9 := checkDerefVar(var_glojure_DOT_core_first) + tmp10 := lang.Apply(tmp9, []any{v5}) + tmp11 := lang.Apply(tmp8, []any{tmp10}) + if lang.IsTruthy(tmp11) { + tmp12 := checkDerefVar(var_glojure_DOT_core_first) + tmp13 := lang.Apply(tmp12, []any{v5}) + tmp7 = tmp13 + } else { + } + var v14 any = tmp7 + _ = v14 + // let binding "options" + var tmp15 any + tmp16 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp17 := checkDerefVar(var_glojure_DOT_core_first) + tmp18 := lang.Apply(tmp17, []any{v5}) + tmp19 := lang.Apply(tmp16, []any{tmp18}) + if lang.IsTruthy(tmp19) { + tmp20 := checkDerefVar(var_glojure_DOT_core_next) + tmp21 := lang.Apply(tmp20, []any{v5}) + tmp15 = tmp21 + } else { + tmp15 = v5 + } + var v22 any = tmp15 + _ = v22 + // let binding "m" + var tmp23 any + tmp24 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp25 := checkDerefVar(var_glojure_DOT_core_first) + tmp26 := lang.Apply(tmp25, []any{v22}) + tmp27 := lang.Apply(tmp24, []any{tmp26}) + if lang.IsTruthy(tmp27) { + tmp28 := checkDerefVar(var_glojure_DOT_core_first) + tmp29 := lang.Apply(tmp28, []any{v22}) + tmp23 = tmp29 + } else { + tmp30 := lang.NewMap() + tmp31 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(1757), kw_column, int(23), kw_end_DASH_line, int(1757), kw_end_DASH_column, int(24)) + tmp32, err := lang.WithMeta(tmp30, tmp31.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp23 = tmp32 + } + var v33 any = tmp23 + _ = v33 + // let binding "options" + var tmp34 any + tmp35 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp36 := checkDerefVar(var_glojure_DOT_core_first) + tmp37 := lang.Apply(tmp36, []any{v22}) + tmp38 := lang.Apply(tmp35, []any{tmp37}) + if lang.IsTruthy(tmp38) { + tmp39 := checkDerefVar(var_glojure_DOT_core_next) + tmp40 := lang.Apply(tmp39, []any{v22}) + tmp34 = tmp40 + } else { + tmp34 = v22 + } + var v41 any = tmp34 + _ = v41 + // let binding "dispatch-fn" + tmp42 := checkDerefVar(var_glojure_DOT_core_first) + tmp43 := lang.Apply(tmp42, []any{v41}) + var v44 any = tmp43 + _ = v44 + // let binding "options" + tmp45 := checkDerefVar(var_glojure_DOT_core_next) + tmp46 := lang.Apply(tmp45, []any{v41}) + var v47 any = tmp46 + _ = v47 + // let binding "m" + var tmp48 any + if lang.IsTruthy(v14) { + tmp49 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp50 := lang.Apply(tmp49, []any{v33, kw_doc, v14}) + tmp48 = tmp50 + } else { + tmp48 = v33 + } + var v51 any = tmp48 + _ = v51 + // let binding "m" + var tmp52 any + tmp53 := checkDerefVar(var_glojure_DOT_core_meta) + tmp54 := lang.Apply(tmp53, []any{v4}) + if lang.IsTruthy(tmp54) { + tmp55 := checkDerefVar(var_glojure_DOT_core_conj) + tmp56 := checkDerefVar(var_glojure_DOT_core_meta) + tmp57 := lang.Apply(tmp56, []any{v4}) + tmp58 := lang.Apply(tmp55, []any{tmp57, v51}) + tmp52 = tmp58 + } else { + tmp52 = v51 + } + var v59 any = tmp52 + _ = v59 + // let binding "mm-name" + tmp60 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp61 := lang.Apply(tmp60, []any{v4, v59}) + var v62 any = tmp61 + _ = v62 + var tmp63 any + tmp64 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp65 := checkDerefVar(var_glojure_DOT_core_count) + tmp66 := lang.Apply(tmp65, []any{v47}) + tmp67 := lang.Apply(tmp64, []any{tmp66, int64(1)}) + if lang.IsTruthy(tmp67) { + tmp68 := lang.Apply(lang.NewError, []any{"The syntax for defmulti has changed. Example: (defmulti name dispatch-fn :default dispatch-value)"}) + panic(tmp68) + } else { + } + _ = tmp63 + var tmp69 any + { // let + // let binding "options" + tmp70 := checkDerefVar(var_glojure_DOT_core_apply) + tmp71 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp72 := lang.Apply(tmp70, []any{tmp71, v47}) + var v73 any = tmp72 + _ = v73 + // let binding "default" + tmp74 := checkDerefVar(var_glojure_DOT_core_get) + tmp75 := lang.Apply(tmp74, []any{v73, kw_default, kw_default}) + var v76 any = tmp75 + _ = v76 + // let binding "hierarchy" + tmp77 := checkDerefVar(var_glojure_DOT_core_get) + tmp78 := lang.InternVarName(sym_glojure_DOT_core, sym_global_DASH_hierarchy) + tmp79 := lang.Apply(tmp77, []any{v73, kw_hierarchy, tmp78}) + var v80 any = tmp79 + _ = v80 + tmp81 := checkDerefVar(var_glojure_DOT_core_check_DASH_valid_DASH_options) + tmp82 := lang.Apply(tmp81, []any{v73, kw_default, kw_hierarchy}) + _ = tmp82 + tmp83 := checkDerefVar(var_glojure_DOT_core_seq) + tmp84 := checkDerefVar(var_glojure_DOT_core_concat) + tmp85 := checkDerefVar(var_glojure_DOT_core_list) + tmp86 := lang.Apply(tmp85, []any{sym_glojure_DOT_core_SLASH_let}) + tmp87 := checkDerefVar(var_glojure_DOT_core_list) + tmp88 := checkDerefVar(var_glojure_DOT_core_apply) + tmp89 := checkDerefVar(var_glojure_DOT_core_vector) + tmp90 := checkDerefVar(var_glojure_DOT_core_seq) + tmp91 := checkDerefVar(var_glojure_DOT_core_concat) + tmp92 := checkDerefVar(var_glojure_DOT_core_list) + tmp93 := lang.Apply(tmp92, []any{sym_v__0__auto__}) + tmp94 := checkDerefVar(var_glojure_DOT_core_list) + tmp95 := checkDerefVar(var_glojure_DOT_core_seq) + tmp96 := checkDerefVar(var_glojure_DOT_core_concat) + tmp97 := checkDerefVar(var_glojure_DOT_core_list) + tmp98 := lang.Apply(tmp97, []any{sym_def}) + tmp99 := checkDerefVar(var_glojure_DOT_core_list) + tmp100 := lang.Apply(tmp99, []any{v62}) + tmp101 := lang.Apply(tmp96, []any{tmp98, tmp100}) + tmp102 := lang.Apply(tmp95, []any{tmp101}) + tmp103 := lang.Apply(tmp94, []any{tmp102}) + tmp104 := lang.Apply(tmp91, []any{tmp93, tmp103}) + tmp105 := lang.Apply(tmp90, []any{tmp104}) + tmp106 := lang.Apply(tmp88, []any{tmp89, tmp105}) + tmp107 := lang.Apply(tmp87, []any{tmp106}) + tmp108 := checkDerefVar(var_glojure_DOT_core_list) + tmp109 := checkDerefVar(var_glojure_DOT_core_seq) + tmp110 := checkDerefVar(var_glojure_DOT_core_concat) + tmp111 := checkDerefVar(var_glojure_DOT_core_list) + tmp112 := lang.Apply(tmp111, []any{sym_glojure_DOT_core_SLASH_when_DASH_not}) + tmp113 := checkDerefVar(var_glojure_DOT_core_list) + tmp114 := checkDerefVar(var_glojure_DOT_core_seq) + tmp115 := checkDerefVar(var_glojure_DOT_core_concat) + tmp116 := checkDerefVar(var_glojure_DOT_core_list) + tmp117 := lang.Apply(tmp116, []any{sym_glojure_DOT_core_SLASH_and}) + tmp118 := checkDerefVar(var_glojure_DOT_core_list) + tmp119 := checkDerefVar(var_glojure_DOT_core_seq) + tmp120 := checkDerefVar(var_glojure_DOT_core_concat) + tmp121 := checkDerefVar(var_glojure_DOT_core_list) + tmp122 := lang.Apply(tmp121, []any{sym__DOT_HasRoot}) + tmp123 := checkDerefVar(var_glojure_DOT_core_list) + tmp124 := lang.Apply(tmp123, []any{sym_v__0__auto__}) + tmp125 := lang.Apply(tmp120, []any{tmp122, tmp124}) + tmp126 := lang.Apply(tmp119, []any{tmp125}) + tmp127 := lang.Apply(tmp118, []any{tmp126}) + tmp128 := checkDerefVar(var_glojure_DOT_core_list) + tmp129 := checkDerefVar(var_glojure_DOT_core_seq) + tmp130 := checkDerefVar(var_glojure_DOT_core_concat) + tmp131 := checkDerefVar(var_glojure_DOT_core_list) + tmp132 := lang.Apply(tmp131, []any{sym_glojure_DOT_core_SLASH_instance_QMARK_}) + tmp133 := checkDerefVar(var_glojure_DOT_core_list) + tmp134 := lang.Apply(tmp133, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT__STAR_MultiFn}) + tmp135 := checkDerefVar(var_glojure_DOT_core_list) + tmp136 := checkDerefVar(var_glojure_DOT_core_seq) + tmp137 := checkDerefVar(var_glojure_DOT_core_concat) + tmp138 := checkDerefVar(var_glojure_DOT_core_list) + tmp139 := lang.Apply(tmp138, []any{sym_glojure_DOT_core_SLASH_deref}) + tmp140 := checkDerefVar(var_glojure_DOT_core_list) + tmp141 := lang.Apply(tmp140, []any{sym_v__0__auto__}) + tmp142 := lang.Apply(tmp137, []any{tmp139, tmp141}) + tmp143 := lang.Apply(tmp136, []any{tmp142}) + tmp144 := lang.Apply(tmp135, []any{tmp143}) + tmp145 := lang.Apply(tmp130, []any{tmp132, tmp134, tmp144}) + tmp146 := lang.Apply(tmp129, []any{tmp145}) + tmp147 := lang.Apply(tmp128, []any{tmp146}) + tmp148 := lang.Apply(tmp115, []any{tmp117, tmp127, tmp147}) + tmp149 := lang.Apply(tmp114, []any{tmp148}) + tmp150 := lang.Apply(tmp113, []any{tmp149}) + tmp151 := checkDerefVar(var_glojure_DOT_core_list) + tmp152 := checkDerefVar(var_glojure_DOT_core_seq) + tmp153 := checkDerefVar(var_glojure_DOT_core_concat) + tmp154 := checkDerefVar(var_glojure_DOT_core_list) + tmp155 := lang.Apply(tmp154, []any{sym_def}) + tmp156 := checkDerefVar(var_glojure_DOT_core_list) + tmp157 := lang.Apply(tmp156, []any{v62}) + tmp158 := checkDerefVar(var_glojure_DOT_core_list) + tmp159 := checkDerefVar(var_glojure_DOT_core_seq) + tmp160 := checkDerefVar(var_glojure_DOT_core_concat) + tmp161 := checkDerefVar(var_glojure_DOT_core_list) + tmp162 := lang.Apply(tmp161, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_NewMultiFn}) + tmp163 := checkDerefVar(var_glojure_DOT_core_list) + tmp164 := checkDerefVar(var_glojure_DOT_core_name) + tmp165 := lang.Apply(tmp164, []any{v62}) + tmp166 := lang.Apply(tmp163, []any{tmp165}) + tmp167 := checkDerefVar(var_glojure_DOT_core_list) + tmp168 := lang.Apply(tmp167, []any{v44}) + tmp169 := checkDerefVar(var_glojure_DOT_core_list) + tmp170 := lang.Apply(tmp169, []any{v76}) + tmp171 := checkDerefVar(var_glojure_DOT_core_list) + tmp172 := lang.Apply(tmp171, []any{v80}) + tmp173 := lang.Apply(tmp160, []any{tmp162, tmp166, tmp168, tmp170, tmp172}) + tmp174 := lang.Apply(tmp159, []any{tmp173}) + tmp175 := lang.Apply(tmp158, []any{tmp174}) + tmp176 := lang.Apply(tmp153, []any{tmp155, tmp157, tmp175}) + tmp177 := lang.Apply(tmp152, []any{tmp176}) + tmp178 := lang.Apply(tmp151, []any{tmp177}) + tmp179 := lang.Apply(tmp110, []any{tmp112, tmp150, tmp178}) + tmp180 := lang.Apply(tmp109, []any{tmp179}) + tmp181 := lang.Apply(tmp108, []any{tmp180}) + tmp182 := lang.Apply(tmp84, []any{tmp86, tmp107, tmp181}) + tmp183 := lang.Apply(tmp83, []any{tmp182}) + tmp69 = tmp183 + } // end let + tmp6 = tmp69 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_defmulti = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_defmulti.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // defprotocol + { + tmp0 := sym_defprotocol.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym__AMP_, sym_opts_PLUS_sigs)), kw_doc, "A protocol is a named set of named methods and their signatures:\n (defprotocol AProtocolName\n\n ;optional doc string\n \"A doc string for AProtocol abstraction\"\n\n ;options\n :extend-via-metadata true\n\n ;method signatures\n (bar [this a b] \"bar docs\")\n (baz [this a] [this a b] [this a b c] \"baz docs\"))\n\n No implementations are provided. Docs can be specified for the\n protocol overall and for each method. The above yields a set of\n polymorphic functions and a protocol object. All are\n namespace-qualified by the ns enclosing the definition The resulting\n functions dispatch on the type of their first argument, which is\n required and corresponds to the implicit target object ('this' in \n Java parlance). defprotocol is dynamic, has no special compile-time \n effect, and defines no new types or classes. Implementations of \n the protocol methods can be provided using extend.\n\n When :extend-via-metadata is true, values can extend protocols by\n adding metadata where keys are fully-qualified protocol function\n symbols and values are function implementations. Protocol\n implementations are checked first for direct definitions (defrecord,\n deftype, reify), then metadata definitions, then external\n extensions (extend, extend-type, extend-protocol)\n\n defprotocol will automatically generate a corresponding interface,\n with the same name as the protocol, i.e. given a protocol:\n my.ns/Protocol, an interface: my.ns.Protocol. The interface will\n have methods corresponding to the protocol functions, and the\n protocol will automatically work with instances of the interface.\n\n Note that you should not use this interface with deftype or\n reify, as they support the protocol directly:\n\n (defprotocol P \n (foo [this]) \n (bar-me [this] [this y]))\n\n (deftype Foo [a b c] \n P\n (foo [this] a)\n (bar-me [this] b)\n (bar-me [this y] (+ c y)))\n \n (bar-me (Foo. 1 2 3) 42)\n => 45\n\n (foo \n (let [x 42]\n (reify P \n (foo [this] 17)\n (bar-me [this] x)\n (bar-me [this y] x))))\n => 17", kw_file, "glojure/core_deftype.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(11), kw_line, int(28), kw_end_DASH_line, int(28))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "doc" + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp9 := checkDerefVar(var_glojure_DOT_core_first) + tmp10 := lang.Apply(tmp9, []any{v5}) + tmp11 := lang.Apply(tmp8, []any{tmp10}) + if lang.IsTruthy(tmp11) { + tmp12 := checkDerefVar(var_glojure_DOT_core_first) + tmp13 := lang.Apply(tmp12, []any{v5}) + tmp7 = tmp13 + } else { + } + var v14 any = tmp7 + _ = v14 + // let binding "opts+sigs" + var tmp15 any + if lang.IsTruthy(v14) { + tmp16 := checkDerefVar(var_glojure_DOT_core_rest) + tmp17 := lang.Apply(tmp16, []any{v5}) + tmp15 = tmp17 + } else { + tmp15 = v5 + } + var v18 any = tmp15 + _ = v18 + // let binding "opts" + tmp19 := checkDerefVar(var_glojure_DOT_core_take_DASH_while) + var tmp20 lang.FnFunc + tmp20 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v21 := args[0] + _ = v21 + tmp22 := checkDerefVar(var_glojure_DOT_core_not) + tmp23 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp24 := lang.Apply(tmp23, []any{v21}) + tmp25 := lang.Apply(tmp22, []any{tmp24}) + return tmp25 + }) + tmp21 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(92), kw_column, int(26), kw_end_DASH_line, int(92), kw_end_DASH_column, int(40)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp23 := lang.Apply(tmp19, []any{tmp22, v18}) + var v24 any = tmp23 + _ = v24 + // let binding "sigs" + tmp25 := checkDerefVar(var_glojure_DOT_core_drop_DASH_while) + var tmp26 lang.FnFunc + tmp26 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v27 := args[0] + _ = v27 + tmp28 := checkDerefVar(var_glojure_DOT_core_not) + tmp29 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp30 := lang.Apply(tmp29, []any{v27}) + tmp31 := lang.Apply(tmp28, []any{tmp30}) + return tmp31 + }) + tmp27 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(93), kw_column, int(26), kw_end_DASH_line, int(93), kw_end_DASH_column, int(40)) + tmp28, err := lang.WithMeta(tmp26, tmp27.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp29 := lang.Apply(tmp25, []any{tmp28, v18}) + var v30 any = tmp29 + _ = v30 + // let binding "opts" + var tmp31 any + tmp32 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp33 := lang.Apply(tmp32, []any{v30, v24}) + if lang.IsTruthy(tmp33) { + } else { + tmp31 = v24 + } + var v34 any = tmp31 + _ = v34 + tmp35 := checkDerefVar(var_glojure_DOT_core_seq) + tmp36 := checkDerefVar(var_glojure_DOT_core_concat) + tmp37 := checkDerefVar(var_glojure_DOT_core_list) + tmp38 := lang.Apply(tmp37, []any{sym_do}) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := checkDerefVar(var_glojure_DOT_core_seq) + tmp41 := checkDerefVar(var_glojure_DOT_core_concat) + tmp42 := checkDerefVar(var_glojure_DOT_core_list) + tmp43 := lang.Apply(tmp42, []any{sym_def}) + tmp44 := checkDerefVar(var_glojure_DOT_core_list) + tmp45 := lang.Apply(tmp44, []any{v4}) + tmp46 := checkDerefVar(var_glojure_DOT_core_list) + tmp47 := checkDerefVar(var_glojure_DOT_core_seq) + tmp48 := checkDerefVar(var_glojure_DOT_core_concat) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) + tmp50 := lang.Apply(tmp49, []any{sym_glojure_DOT_core_SLASH_atom}) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := checkDerefVar(var_glojure_DOT_core_apply) + tmp53 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp54 := checkDerefVar(var_glojure_DOT_core_seq) + tmp55 := checkDerefVar(var_glojure_DOT_core_concat) + tmp56 := checkDerefVar(var_glojure_DOT_core_list) + tmp57 := lang.Apply(tmp56, []any{kw_on_DASH_interface}) + tmp58 := checkDerefVar(var_glojure_DOT_core_list) + tmp59 := lang.Apply(tmp58, []any{true}) + tmp60 := checkDerefVar(var_glojure_DOT_core_list) + tmp61 := lang.Apply(tmp60, []any{kw_sigs}) + tmp62 := checkDerefVar(var_glojure_DOT_core_list) + tmp63 := checkDerefVar(var_glojure_DOT_core_seq) + tmp64 := checkDerefVar(var_glojure_DOT_core_concat) + tmp65 := checkDerefVar(var_glojure_DOT_core_list) + tmp66 := lang.Apply(tmp65, []any{sym_quote}) + tmp67 := checkDerefVar(var_glojure_DOT_core_list) + tmp68 := lang.Apply(tmp67, []any{v30}) + tmp69 := lang.Apply(tmp64, []any{tmp66, tmp68}) + tmp70 := lang.Apply(tmp63, []any{tmp69}) + tmp71 := lang.Apply(tmp62, []any{tmp70}) + tmp72 := checkDerefVar(var_glojure_DOT_core_list) + tmp73 := lang.Apply(tmp72, []any{kw_multis}) + tmp74 := checkDerefVar(var_glojure_DOT_core_list) + tmp75 := checkDerefVar(var_glojure_DOT_core_apply) + tmp76 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp77 := checkDerefVar(var_glojure_DOT_core_seq) + tmp78 := checkDerefVar(var_glojure_DOT_core_concat) + tmp79 := lang.Apply(tmp78, nil) + tmp80 := lang.Apply(tmp77, []any{tmp79}) + tmp81 := lang.Apply(tmp75, []any{tmp76, tmp80}) + tmp82 := lang.Apply(tmp74, []any{tmp81}) + tmp83 := lang.Apply(tmp55, []any{tmp57, tmp59, tmp61, tmp71, tmp73, tmp82}) + tmp84 := lang.Apply(tmp54, []any{tmp83}) + tmp85 := lang.Apply(tmp52, []any{tmp53, tmp84}) + tmp86 := lang.Apply(tmp51, []any{tmp85}) + tmp87 := lang.Apply(tmp48, []any{tmp50, tmp86}) + tmp88 := lang.Apply(tmp47, []any{tmp87}) + tmp89 := lang.Apply(tmp46, []any{tmp88}) + tmp90 := lang.Apply(tmp41, []any{tmp43, tmp45, tmp89}) + tmp91 := lang.Apply(tmp40, []any{tmp90}) + tmp92 := lang.Apply(tmp39, []any{tmp91}) + tmp93 := checkDerefVar(var_glojure_DOT_core_list) + tmp94 := checkDerefVar(var_glojure_DOT_core_seq) + tmp95 := checkDerefVar(var_glojure_DOT_core_concat) + tmp96 := checkDerefVar(var_glojure_DOT_core_list) + tmp97 := lang.Apply(tmp96, []any{sym_glojure_DOT_core_SLASH_swap_BANG_}) + tmp98 := checkDerefVar(var_glojure_DOT_core_list) + tmp99 := lang.Apply(tmp98, []any{sym_glojure_DOT_core_SLASH__DASH_protocols}) + tmp100 := checkDerefVar(var_glojure_DOT_core_list) + tmp101 := lang.Apply(tmp100, []any{sym_glojure_DOT_core_SLASH_assoc}) + tmp102 := checkDerefVar(var_glojure_DOT_core_list) + tmp103 := checkDerefVar(var_glojure_DOT_core_seq) + tmp104 := checkDerefVar(var_glojure_DOT_core_concat) + tmp105 := checkDerefVar(var_glojure_DOT_core_list) + tmp106 := lang.Apply(tmp105, []any{sym_quote}) + tmp107 := checkDerefVar(var_glojure_DOT_core_list) + tmp108 := lang.Apply(tmp107, []any{v4}) + tmp109 := lang.Apply(tmp104, []any{tmp106, tmp108}) + tmp110 := lang.Apply(tmp103, []any{tmp109}) + tmp111 := lang.Apply(tmp102, []any{tmp110}) + tmp112 := checkDerefVar(var_glojure_DOT_core_list) + tmp113 := lang.Apply(tmp112, []any{v4}) + tmp114 := lang.Apply(tmp95, []any{tmp97, tmp99, tmp101, tmp111, tmp113}) + tmp115 := lang.Apply(tmp94, []any{tmp114}) + tmp116 := lang.Apply(tmp93, []any{tmp115}) + tmp117 := checkDerefVar(var_glojure_DOT_core_map) + var tmp118 lang.FnFunc + tmp118 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v119 := args[0] + _ = v119 + tmp120 := checkDerefVar(var_glojure_DOT_core_seq) + tmp121 := checkDerefVar(var_glojure_DOT_core_concat) + tmp122 := checkDerefVar(var_glojure_DOT_core_list) + tmp123 := lang.Apply(tmp122, []any{sym_do}) + tmp124 := checkDerefVar(var_glojure_DOT_core_list) + tmp125 := checkDerefVar(var_glojure_DOT_core_seq) + tmp126 := checkDerefVar(var_glojure_DOT_core_concat) + tmp127 := checkDerefVar(var_glojure_DOT_core_list) + tmp128 := lang.Apply(tmp127, []any{sym_glojure_DOT_core_SLASH_defmulti}) + tmp129 := checkDerefVar(var_glojure_DOT_core_list) + tmp130 := checkDerefVar(var_glojure_DOT_core_first) + tmp131 := lang.Apply(tmp130, []any{v119}) + tmp132 := lang.Apply(tmp129, []any{tmp131}) + tmp133 := checkDerefVar(var_glojure_DOT_core_list) + tmp134 := checkDerefVar(var_glojure_DOT_core_seq) + tmp135 := checkDerefVar(var_glojure_DOT_core_concat) + tmp136 := checkDerefVar(var_glojure_DOT_core_list) + tmp137 := lang.Apply(tmp136, []any{sym_glojure_DOT_core_SLASH_fn}) + tmp138 := checkDerefVar(var_glojure_DOT_core_list) + tmp139 := checkDerefVar(var_glojure_DOT_core_apply) + tmp140 := checkDerefVar(var_glojure_DOT_core_vector) + tmp141 := checkDerefVar(var_glojure_DOT_core_seq) + tmp142 := checkDerefVar(var_glojure_DOT_core_concat) + tmp143 := checkDerefVar(var_glojure_DOT_core_list) + tmp144 := lang.Apply(tmp143, []any{sym_this}) + tmp145 := checkDerefVar(var_glojure_DOT_core_list) + tmp146 := lang.Apply(tmp145, []any{sym__AMP_}) + tmp147 := checkDerefVar(var_glojure_DOT_core_list) + tmp148 := lang.Apply(tmp147, []any{sym_args}) + tmp149 := lang.Apply(tmp142, []any{tmp144, tmp146, tmp148}) + tmp150 := lang.Apply(tmp141, []any{tmp149}) + tmp151 := lang.Apply(tmp139, []any{tmp140, tmp150}) + tmp152 := lang.Apply(tmp138, []any{tmp151}) + tmp153 := checkDerefVar(var_glojure_DOT_core_list) + tmp154 := checkDerefVar(var_glojure_DOT_core_seq) + tmp155 := checkDerefVar(var_glojure_DOT_core_concat) + tmp156 := checkDerefVar(var_glojure_DOT_core_list) + tmp157 := lang.Apply(tmp156, []any{sym_glojure_DOT_core_SLASH_class}) + tmp158 := checkDerefVar(var_glojure_DOT_core_list) + tmp159 := lang.Apply(tmp158, []any{sym_this}) + tmp160 := lang.Apply(tmp155, []any{tmp157, tmp159}) + tmp161 := lang.Apply(tmp154, []any{tmp160}) + tmp162 := lang.Apply(tmp153, []any{tmp161}) + tmp163 := lang.Apply(tmp135, []any{tmp137, tmp152, tmp162}) + tmp164 := lang.Apply(tmp134, []any{tmp163}) + tmp165 := lang.Apply(tmp133, []any{tmp164}) + tmp166 := lang.Apply(tmp126, []any{tmp128, tmp132, tmp165}) + tmp167 := lang.Apply(tmp125, []any{tmp166}) + tmp168 := lang.Apply(tmp124, []any{tmp167}) + tmp169 := checkDerefVar(var_glojure_DOT_core_list) + tmp170 := checkDerefVar(var_glojure_DOT_core_seq) + tmp171 := checkDerefVar(var_glojure_DOT_core_concat) + tmp172 := checkDerefVar(var_glojure_DOT_core_list) + tmp173 := lang.Apply(tmp172, []any{sym_glojure_DOT_core_SLASH_swap_BANG_}) + tmp174 := checkDerefVar(var_glojure_DOT_core_list) + tmp175 := lang.Apply(tmp174, []any{v4}) + tmp176 := checkDerefVar(var_glojure_DOT_core_list) + tmp177 := lang.Apply(tmp176, []any{sym_glojure_DOT_core_SLASH_assoc_DASH_in}) + tmp178 := checkDerefVar(var_glojure_DOT_core_list) + tmp179 := checkDerefVar(var_glojure_DOT_core_apply) + tmp180 := checkDerefVar(var_glojure_DOT_core_vector) + tmp181 := checkDerefVar(var_glojure_DOT_core_seq) + tmp182 := checkDerefVar(var_glojure_DOT_core_concat) + tmp183 := checkDerefVar(var_glojure_DOT_core_list) + tmp184 := lang.Apply(tmp183, []any{kw_multis}) + tmp185 := checkDerefVar(var_glojure_DOT_core_list) + tmp186 := checkDerefVar(var_glojure_DOT_core_seq) + tmp187 := checkDerefVar(var_glojure_DOT_core_concat) + tmp188 := checkDerefVar(var_glojure_DOT_core_list) + tmp189 := lang.Apply(tmp188, []any{sym_glojure_DOT_core_SLASH_keyword}) + tmp190 := checkDerefVar(var_glojure_DOT_core_list) + tmp191 := checkDerefVar(var_glojure_DOT_core_seq) + tmp192 := checkDerefVar(var_glojure_DOT_core_concat) + tmp193 := checkDerefVar(var_glojure_DOT_core_list) + tmp194 := lang.Apply(tmp193, []any{sym_quote}) + tmp195 := checkDerefVar(var_glojure_DOT_core_list) + tmp196 := checkDerefVar(var_glojure_DOT_core_first) + tmp197 := lang.Apply(tmp196, []any{v119}) + tmp198 := lang.Apply(tmp195, []any{tmp197}) + tmp199 := lang.Apply(tmp192, []any{tmp194, tmp198}) + tmp200 := lang.Apply(tmp191, []any{tmp199}) + tmp201 := lang.Apply(tmp190, []any{tmp200}) + tmp202 := lang.Apply(tmp187, []any{tmp189, tmp201}) + tmp203 := lang.Apply(tmp186, []any{tmp202}) + tmp204 := lang.Apply(tmp185, []any{tmp203}) + tmp205 := lang.Apply(tmp182, []any{tmp184, tmp204}) + tmp206 := lang.Apply(tmp181, []any{tmp205}) + tmp207 := lang.Apply(tmp179, []any{tmp180, tmp206}) + tmp208 := lang.Apply(tmp178, []any{tmp207}) + tmp209 := checkDerefVar(var_glojure_DOT_core_list) + tmp210 := checkDerefVar(var_glojure_DOT_core_first) + tmp211 := lang.Apply(tmp210, []any{v119}) + tmp212 := lang.Apply(tmp209, []any{tmp211}) + tmp213 := lang.Apply(tmp171, []any{tmp173, tmp175, tmp177, tmp208, tmp212}) + tmp214 := lang.Apply(tmp170, []any{tmp213}) + tmp215 := lang.Apply(tmp169, []any{tmp214}) + tmp216 := lang.Apply(tmp121, []any{tmp123, tmp168, tmp215}) + tmp217 := lang.Apply(tmp120, []any{tmp216}) + return tmp217 + }) + tmp119 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(102), kw_column, int(13), kw_end_DASH_line, int(104), kw_end_DASH_column, int(90)) + tmp120, err := lang.WithMeta(tmp118, tmp119.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp121 := lang.Apply(tmp117, []any{tmp120, v30}) + tmp122 := checkDerefVar(var_glojure_DOT_core_list) + tmp123 := checkDerefVar(var_glojure_DOT_core_seq) + tmp124 := checkDerefVar(var_glojure_DOT_core_concat) + tmp125 := checkDerefVar(var_glojure_DOT_core_list) + tmp126 := lang.Apply(tmp125, []any{sym_var}) + tmp127 := checkDerefVar(var_glojure_DOT_core_list) + tmp128 := lang.Apply(tmp127, []any{v4}) + tmp129 := lang.Apply(tmp124, []any{tmp126, tmp128}) + tmp130 := lang.Apply(tmp123, []any{tmp129}) + tmp131 := lang.Apply(tmp122, []any{tmp130}) + tmp132 := lang.Apply(tmp36, []any{tmp38, tmp92, tmp116, tmp121, tmp131}) + tmp133 := lang.Apply(tmp35, []any{tmp132}) + tmp6 = tmp133 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_defprotocol = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_defprotocol.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // distinct? + { + tmp1 := reflect.TypeOf(false) + tmp0 := sym_distinct_QMARK_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_doc, "Returns true if no two of the arguments are =", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(5664), kw_end_DASH_line, int(5664))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + return true + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_not) + tmp6 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp7 := lang.Apply(tmp6, []any{v3, v4}) + tmp8 := lang.Apply(tmp5, []any{tmp7}) + return tmp8 + default: + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_not_EQ_) + tmp8 := lang.Apply(tmp7, []any{v3, v4}) + if lang.IsTruthy(tmp8) { + var tmp9 any + { // let + // let binding "s" + tmp10 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{v3, v4})) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5673), kw_column, int(15), kw_end_DASH_line, int(5673), kw_end_DASH_column, int(20)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v13 any = tmp12 + _ = v13 + // let binding "G__790" + var v14 any = v5 + _ = v14 + // let binding "vec__791" + var v15 any = v14 + _ = v15 + // let binding "seq__792" + tmp16 := checkDerefVar(var_glojure_DOT_core_seq) + tmp17 := lang.Apply(tmp16, []any{v15}) + var v18 any = tmp17 + _ = v18 + // let binding "first__793" + tmp19 := checkDerefVar(var_glojure_DOT_core_first) + tmp20 := lang.Apply(tmp19, []any{v18}) + var v21 any = tmp20 + _ = v21 + // let binding "seq__792" + tmp22 := checkDerefVar(var_glojure_DOT_core_next) + tmp23 := lang.Apply(tmp22, []any{v18}) + var v24 any = tmp23 + _ = v24 + // let binding "x" + var v25 any = v21 + _ = v25 + // let binding "etc" + var v26 any = v24 + _ = v26 + // let binding "xs" + var v27 any = v15 + _ = v27 + var tmp28 any + { // let + // let binding "s" + var v29 any = v13 + _ = v29 + // let binding "G__790" + var v30 any = v14 + _ = v30 + for { + var tmp31 any + { // let + // let binding "s" + var v32 any = v29 + _ = v32 + // let binding "vec__794" + var v33 any = v30 + _ = v33 + // let binding "seq__795" + tmp34 := checkDerefVar(var_glojure_DOT_core_seq) + tmp35 := lang.Apply(tmp34, []any{v33}) + var v36 any = tmp35 + _ = v36 + // let binding "first__796" + tmp37 := checkDerefVar(var_glojure_DOT_core_first) + tmp38 := lang.Apply(tmp37, []any{v36}) + var v39 any = tmp38 + _ = v39 + // let binding "seq__795" + tmp40 := checkDerefVar(var_glojure_DOT_core_next) + tmp41 := lang.Apply(tmp40, []any{v36}) + var v42 any = tmp41 + _ = v42 + // let binding "x" + var v43 any = v39 + _ = v43 + // let binding "etc" + var v44 any = v42 + _ = v44 + // let binding "xs" + var v45 any = v33 + _ = v45 + var tmp46 any + if lang.IsTruthy(v45) { + var tmp47 any + tmp48 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp49 := lang.Apply(tmp48, []any{v32, v43}) + if lang.IsTruthy(tmp49) { + tmp47 = false + } else { + tmp51 := checkDerefVar(var_glojure_DOT_core_conj) + tmp52 := lang.Apply(tmp51, []any{v32, v43}) + var tmp50 any = tmp52 + var tmp53 any = v44 + v29 = tmp50 + v30 = tmp53 + continue + } + tmp46 = tmp47 + } else { + tmp46 = true + } + tmp31 = tmp46 + } // end let + tmp28 = tmp31 + break + } + } // end let + tmp9 = tmp28 + } // end let + tmp6 = tmp9 + } else { + tmp6 = false + } + return tmp6 + } + }) + tmp3 := reflect.TypeOf(false) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_distinct_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_distinct_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // doall + { + tmp0 := sym_doall.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll), lang.NewVector(sym_n, sym_coll)), kw_doc, "When lazy sequences are produced via functions that have side\n effects, any effects other than those needed to produce the first\n element in the seq do not occur until the seq is consumed. doall can\n be used to force any effects. Walks through the successive nexts of\n the seq, retains the head and returns it, thus causing the entire\n seq to reside in memory at one time.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3131), kw_end_DASH_line, int(3131))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_dorun) + tmp4 := lang.Apply(tmp3, []any{v2}) + _ = tmp4 + return v2 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_dorun) + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + _ = tmp5 + return v3 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_doall = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_doall.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // doseq + { + tmp0 := sym_doseq.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_seq_DASH_exprs, sym__AMP_, sym_body)), kw_doc, "Repeatedly executes body (presumably for side-effects) with\n bindings and filtering as provided by \"for\". Does not retain\n the head of the sequence. Returns nil.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(11), kw_line, int(3209), kw_end_DASH_line, int(3209))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v4}) + if lang.IsTruthy(tmp8) { + } else { + tmp9 := checkDerefVar(var_glojure_DOT_core_str) + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp13 := checkDerefVar(var_glojure_DOT_core_meta) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(kw_line, []any{tmp14}) + tmp16 := lang.Apply(tmp9, []any{tmp11, " requires ", "a vector for its binding", " in ", tmp12, ":", tmp15}) + tmp17 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp16}) + panic(tmp17) + } + _ = tmp6 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_even_QMARK_) + tmp20 := checkDerefVar(var_glojure_DOT_core_count) + tmp21 := lang.Apply(tmp20, []any{v4}) + tmp22 := lang.Apply(tmp19, []any{tmp21}) + if lang.IsTruthy(tmp22) { + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp27 := checkDerefVar(var_glojure_DOT_core_meta) + tmp28 := lang.Apply(tmp27, []any{v2}) + tmp29 := lang.Apply(kw_line, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp25, " requires ", "an even number of forms in binding vector", " in ", tmp26, ":", tmp29}) + tmp31 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp31) + } + _ = tmp18 + var tmp32 any + { // let + // let binding "step" + var tmp33 lang.FnFunc + { // function step + var v34 lang.FnFunc + tmp33 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v35 := args[0] + _ = v35 + v36 := args[1] + _ = v36 + var tmp37 any + tmp38 := checkDerefVar(var_glojure_DOT_core_not) + tmp39 := lang.Apply(tmp38, []any{v36}) + if lang.IsTruthy(tmp39) { + tmp40 := checkDerefVar(var_glojure_DOT_core_seq) + tmp41 := checkDerefVar(var_glojure_DOT_core_concat) + tmp42 := checkDerefVar(var_glojure_DOT_core_list) + tmp43 := lang.Apply(tmp42, []any{sym_do}) + tmp44 := lang.Apply(tmp41, []any{tmp43, v5}) + tmp45 := lang.Apply(tmp40, []any{tmp44}) + tmp46 := lang.NewVector(true, tmp45) + tmp47 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3220), kw_column, int(18), kw_end_DASH_line, int(3220), kw_end_DASH_column, int(36)) + tmp48, err := lang.WithMeta(tmp46, tmp47.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp37 = tmp48 + } else { + var tmp49 any + { // let + // let binding "k" + tmp50 := checkDerefVar(var_glojure_DOT_core_first) + tmp51 := lang.Apply(tmp50, []any{v36}) + var v52 any = tmp51 + _ = v52 + // let binding "v" + tmp53 := checkDerefVar(var_glojure_DOT_core_second) + tmp54 := lang.Apply(tmp53, []any{v36}) + var v55 any = tmp54 + _ = v55 + var tmp56 any + tmp57 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp58 := lang.Apply(tmp57, []any{v52}) + if lang.IsTruthy(tmp58) { + var tmp59 any + { // let + // let binding "steppair" + tmp60 := checkDerefVar(var_glojure_DOT_core_nnext) + tmp61 := lang.Apply(tmp60, []any{v36}) + tmp62 := lang.Apply(v34, []any{v35, tmp61}) + var v63 any = tmp62 + _ = v63 + // let binding "needrec" + tmp64 := lang.Apply(v63, []any{int64(0)}) + var v65 any = tmp64 + _ = v65 + // let binding "subform" + tmp66 := lang.Apply(v63, []any{int64(1)}) + var v67 any = tmp66 + _ = v67 + var tmp68 any + tmp69 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp70 := lang.Apply(tmp69, []any{v52, kw_let}) + if lang.IsTruthy(tmp70) { + tmp71 := checkDerefVar(var_glojure_DOT_core_seq) + tmp72 := checkDerefVar(var_glojure_DOT_core_concat) + tmp73 := checkDerefVar(var_glojure_DOT_core_list) + tmp74 := lang.Apply(tmp73, []any{sym_glojure_DOT_core_SLASH_let}) + tmp75 := checkDerefVar(var_glojure_DOT_core_list) + tmp76 := lang.Apply(tmp75, []any{v55}) + tmp77 := checkDerefVar(var_glojure_DOT_core_list) + tmp78 := lang.Apply(tmp77, []any{v67}) + tmp79 := lang.Apply(tmp72, []any{tmp74, tmp76, tmp78}) + tmp80 := lang.Apply(tmp71, []any{tmp79}) + tmp81 := lang.NewVector(v65, tmp80) + tmp82 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3228), kw_column, int(37), kw_end_DASH_line, int(3228), kw_end_DASH_column, int(64)) + tmp83, err := lang.WithMeta(tmp81, tmp82.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp68 = tmp83 + } else { + var tmp84 any + tmp85 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp86 := lang.Apply(tmp85, []any{v52, kw_while}) + if lang.IsTruthy(tmp86) { + tmp87 := checkDerefVar(var_glojure_DOT_core_seq) + tmp88 := checkDerefVar(var_glojure_DOT_core_concat) + tmp89 := checkDerefVar(var_glojure_DOT_core_list) + tmp90 := lang.Apply(tmp89, []any{sym_glojure_DOT_core_SLASH_when}) + tmp91 := checkDerefVar(var_glojure_DOT_core_list) + tmp92 := lang.Apply(tmp91, []any{v55}) + tmp93 := checkDerefVar(var_glojure_DOT_core_list) + tmp94 := lang.Apply(tmp93, []any{v67}) + var tmp95 any + if lang.IsTruthy(v65) { + tmp96 := lang.NewVector(v35) + tmp97 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3231), kw_column, int(65), kw_end_DASH_line, int(3231), kw_end_DASH_column, int(73)) + tmp98, err := lang.WithMeta(tmp96, tmp97.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp95 = tmp98 + } else { + } + tmp99 := lang.Apply(tmp88, []any{tmp90, tmp92, tmp94, tmp95}) + tmp100 := lang.Apply(tmp87, []any{tmp99}) + tmp101 := lang.NewVector(false, tmp100) + tmp102 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3229), kw_column, int(39), kw_end_DASH_line, int(3231), kw_end_DASH_column, int(76)) + tmp103, err := lang.WithMeta(tmp101, tmp102.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp84 = tmp103 + } else { + var tmp104 any + tmp105 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp106 := lang.Apply(tmp105, []any{v52, kw_when}) + if lang.IsTruthy(tmp106) { + tmp107 := checkDerefVar(var_glojure_DOT_core_seq) + tmp108 := checkDerefVar(var_glojure_DOT_core_concat) + tmp109 := checkDerefVar(var_glojure_DOT_core_list) + tmp110 := lang.Apply(tmp109, []any{sym_if}) + tmp111 := checkDerefVar(var_glojure_DOT_core_list) + tmp112 := lang.Apply(tmp111, []any{v55}) + tmp113 := checkDerefVar(var_glojure_DOT_core_list) + tmp114 := checkDerefVar(var_glojure_DOT_core_seq) + tmp115 := checkDerefVar(var_glojure_DOT_core_concat) + tmp116 := checkDerefVar(var_glojure_DOT_core_list) + tmp117 := lang.Apply(tmp116, []any{sym_do}) + tmp118 := checkDerefVar(var_glojure_DOT_core_list) + tmp119 := lang.Apply(tmp118, []any{v67}) + var tmp120 any + if lang.IsTruthy(v65) { + tmp121 := lang.NewVector(v35) + tmp122 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3235), kw_column, int(66), kw_end_DASH_line, int(3235), kw_end_DASH_column, int(74)) + tmp123, err := lang.WithMeta(tmp121, tmp122.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp120 = tmp123 + } else { + } + tmp124 := lang.Apply(tmp115, []any{tmp117, tmp119, tmp120}) + tmp125 := lang.Apply(tmp114, []any{tmp124}) + tmp126 := lang.Apply(tmp113, []any{tmp125}) + tmp127 := checkDerefVar(var_glojure_DOT_core_list) + tmp128 := lang.Apply(tmp127, []any{v35}) + tmp129 := lang.Apply(tmp108, []any{tmp110, tmp112, tmp126, tmp128}) + tmp130 := lang.Apply(tmp107, []any{tmp129}) + tmp131 := lang.NewVector(false, tmp130) + tmp132 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3232), kw_column, int(38), kw_end_DASH_line, int(3236), kw_end_DASH_column, int(57)) + tmp133, err := lang.WithMeta(tmp131, tmp132.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp104 = tmp133 + } else { + } + tmp84 = tmp104 + } + tmp68 = tmp84 + } + tmp59 = tmp68 + } // end let + tmp56 = tmp59 + } else { + var tmp60 any + { // let + // let binding "seq-" + tmp61 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp62 := lang.Apply(tmp61, []any{"seq_"}) + var v63 any = tmp62 + _ = v63 + // let binding "chunk-" + tmp64 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp65 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp66 := lang.Apply(tmp65, []any{"chunk_"}) + tmp67 := lang.NewMap(kw_tag, sym_glojure_DOT_lang_DOT_IChunk) + tmp68 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3239), kw_column, int(46), kw_end_DASH_line, int(3239), kw_end_DASH_column, int(72)) + tmp69, err := lang.WithMeta(tmp67, tmp68.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp70 := lang.Apply(tmp64, []any{tmp66, tmp69}) + var v71 any = tmp70 + _ = v71 + // let binding "count-" + tmp72 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp73 := lang.Apply(tmp72, []any{"count_"}) + var v74 any = tmp73 + _ = v74 + // let binding "i-" + tmp75 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp76 := lang.Apply(tmp75, []any{"i_"}) + var v77 any = tmp76 + _ = v77 + // let binding "recform" + tmp78 := checkDerefVar(var_glojure_DOT_core_seq) + tmp79 := checkDerefVar(var_glojure_DOT_core_concat) + tmp80 := checkDerefVar(var_glojure_DOT_core_list) + tmp81 := lang.Apply(tmp80, []any{sym_recur}) + tmp82 := checkDerefVar(var_glojure_DOT_core_list) + tmp83 := checkDerefVar(var_glojure_DOT_core_seq) + tmp84 := checkDerefVar(var_glojure_DOT_core_concat) + tmp85 := checkDerefVar(var_glojure_DOT_core_list) + tmp86 := lang.Apply(tmp85, []any{sym_glojure_DOT_core_SLASH_next}) + tmp87 := checkDerefVar(var_glojure_DOT_core_list) + tmp88 := lang.Apply(tmp87, []any{v63}) + tmp89 := lang.Apply(tmp84, []any{tmp86, tmp88}) + tmp90 := lang.Apply(tmp83, []any{tmp89}) + tmp91 := lang.Apply(tmp82, []any{tmp90}) + tmp92 := checkDerefVar(var_glojure_DOT_core_list) + tmp93 := lang.Apply(tmp92, []any{nil}) + tmp94 := checkDerefVar(var_glojure_DOT_core_list) + tmp95 := lang.Apply(tmp94, []any{int64(0)}) + tmp96 := checkDerefVar(var_glojure_DOT_core_list) + tmp97 := lang.Apply(tmp96, []any{int64(0)}) + tmp98 := lang.Apply(tmp79, []any{tmp81, tmp91, tmp93, tmp95, tmp97}) + tmp99 := lang.Apply(tmp78, []any{tmp98}) + var v100 any = tmp99 + _ = v100 + // let binding "steppair" + tmp101 := checkDerefVar(var_glojure_DOT_core_nnext) + tmp102 := lang.Apply(tmp101, []any{v36}) + tmp103 := lang.Apply(v34, []any{v100, tmp102}) + var v104 any = tmp103 + _ = v104 + // let binding "needrec" + tmp105 := lang.Apply(v104, []any{int64(0)}) + var v106 any = tmp105 + _ = v106 + // let binding "subform" + tmp107 := lang.Apply(v104, []any{int64(1)}) + var v108 any = tmp107 + _ = v108 + // let binding "recform-chunk" + tmp109 := checkDerefVar(var_glojure_DOT_core_seq) + tmp110 := checkDerefVar(var_glojure_DOT_core_concat) + tmp111 := checkDerefVar(var_glojure_DOT_core_list) + tmp112 := lang.Apply(tmp111, []any{sym_recur}) + tmp113 := checkDerefVar(var_glojure_DOT_core_list) + tmp114 := lang.Apply(tmp113, []any{v63}) + tmp115 := checkDerefVar(var_glojure_DOT_core_list) + tmp116 := lang.Apply(tmp115, []any{v71}) + tmp117 := checkDerefVar(var_glojure_DOT_core_list) + tmp118 := lang.Apply(tmp117, []any{v74}) + tmp119 := checkDerefVar(var_glojure_DOT_core_list) + tmp120 := checkDerefVar(var_glojure_DOT_core_seq) + tmp121 := checkDerefVar(var_glojure_DOT_core_concat) + tmp122 := checkDerefVar(var_glojure_DOT_core_list) + tmp123 := lang.Apply(tmp122, []any{sym_glojure_DOT_core_SLASH_unchecked_DASH_inc}) + tmp124 := checkDerefVar(var_glojure_DOT_core_list) + tmp125 := lang.Apply(tmp124, []any{v77}) + tmp126 := lang.Apply(tmp121, []any{tmp123, tmp125}) + tmp127 := lang.Apply(tmp120, []any{tmp126}) + tmp128 := lang.Apply(tmp119, []any{tmp127}) + tmp129 := lang.Apply(tmp110, []any{tmp112, tmp114, tmp116, tmp118, tmp128}) + tmp130 := lang.Apply(tmp109, []any{tmp129}) + var v131 any = tmp130 + _ = v131 + // let binding "steppair-chunk" + tmp132 := checkDerefVar(var_glojure_DOT_core_nnext) + tmp133 := lang.Apply(tmp132, []any{v36}) + tmp134 := lang.Apply(v34, []any{v131, tmp133}) + var v135 any = tmp134 + _ = v135 + // let binding "subform-chunk" + tmp136 := lang.Apply(v135, []any{int64(1)}) + var v137 any = tmp136 + _ = v137 + tmp138 := checkDerefVar(var_glojure_DOT_core_seq) + tmp139 := checkDerefVar(var_glojure_DOT_core_concat) + tmp140 := checkDerefVar(var_glojure_DOT_core_list) + tmp141 := lang.Apply(tmp140, []any{sym_glojure_DOT_core_SLASH_loop}) + tmp142 := checkDerefVar(var_glojure_DOT_core_list) + tmp143 := checkDerefVar(var_glojure_DOT_core_apply) + tmp144 := checkDerefVar(var_glojure_DOT_core_vector) + tmp145 := checkDerefVar(var_glojure_DOT_core_seq) + tmp146 := checkDerefVar(var_glojure_DOT_core_concat) + tmp147 := checkDerefVar(var_glojure_DOT_core_list) + tmp148 := lang.Apply(tmp147, []any{v63}) + tmp149 := checkDerefVar(var_glojure_DOT_core_list) + tmp150 := checkDerefVar(var_glojure_DOT_core_seq) + tmp151 := checkDerefVar(var_glojure_DOT_core_concat) + tmp152 := checkDerefVar(var_glojure_DOT_core_list) + tmp153 := lang.Apply(tmp152, []any{sym_glojure_DOT_core_SLASH_seq}) + tmp154 := checkDerefVar(var_glojure_DOT_core_list) + tmp155 := lang.Apply(tmp154, []any{v55}) + tmp156 := lang.Apply(tmp151, []any{tmp153, tmp155}) + tmp157 := lang.Apply(tmp150, []any{tmp156}) + tmp158 := lang.Apply(tmp149, []any{tmp157}) + tmp159 := checkDerefVar(var_glojure_DOT_core_list) + tmp160 := lang.Apply(tmp159, []any{v71}) + tmp161 := checkDerefVar(var_glojure_DOT_core_list) + tmp162 := lang.Apply(tmp161, []any{nil}) + tmp163 := checkDerefVar(var_glojure_DOT_core_list) + tmp164 := lang.Apply(tmp163, []any{v74}) + tmp165 := checkDerefVar(var_glojure_DOT_core_list) + tmp166 := lang.Apply(tmp165, []any{int64(0)}) + tmp167 := checkDerefVar(var_glojure_DOT_core_list) + tmp168 := lang.Apply(tmp167, []any{v77}) + tmp169 := checkDerefVar(var_glojure_DOT_core_list) + tmp170 := lang.Apply(tmp169, []any{int64(0)}) + tmp171 := lang.Apply(tmp146, []any{tmp148, tmp158, tmp160, tmp162, tmp164, tmp166, tmp168, tmp170}) + tmp172 := lang.Apply(tmp145, []any{tmp171}) + tmp173 := lang.Apply(tmp143, []any{tmp144, tmp172}) + tmp174 := lang.Apply(tmp142, []any{tmp173}) + tmp175 := checkDerefVar(var_glojure_DOT_core_list) + tmp176 := checkDerefVar(var_glojure_DOT_core_seq) + tmp177 := checkDerefVar(var_glojure_DOT_core_concat) + tmp178 := checkDerefVar(var_glojure_DOT_core_list) + tmp179 := lang.Apply(tmp178, []any{sym_if}) + tmp180 := checkDerefVar(var_glojure_DOT_core_list) + tmp181 := checkDerefVar(var_glojure_DOT_core_seq) + tmp182 := checkDerefVar(var_glojure_DOT_core_concat) + tmp183 := checkDerefVar(var_glojure_DOT_core_list) + tmp184 := lang.Apply(tmp183, []any{sym_glojure_DOT_core_SLASH__LT_}) + tmp185 := checkDerefVar(var_glojure_DOT_core_list) + tmp186 := lang.Apply(tmp185, []any{v77}) + tmp187 := checkDerefVar(var_glojure_DOT_core_list) + tmp188 := lang.Apply(tmp187, []any{v74}) + tmp189 := lang.Apply(tmp182, []any{tmp184, tmp186, tmp188}) + tmp190 := lang.Apply(tmp181, []any{tmp189}) + tmp191 := lang.Apply(tmp180, []any{tmp190}) + tmp192 := checkDerefVar(var_glojure_DOT_core_list) + tmp193 := checkDerefVar(var_glojure_DOT_core_seq) + tmp194 := checkDerefVar(var_glojure_DOT_core_concat) + tmp195 := checkDerefVar(var_glojure_DOT_core_list) + tmp196 := lang.Apply(tmp195, []any{sym_glojure_DOT_core_SLASH_let}) + tmp197 := checkDerefVar(var_glojure_DOT_core_list) + tmp198 := checkDerefVar(var_glojure_DOT_core_apply) + tmp199 := checkDerefVar(var_glojure_DOT_core_vector) + tmp200 := checkDerefVar(var_glojure_DOT_core_seq) + tmp201 := checkDerefVar(var_glojure_DOT_core_concat) + tmp202 := checkDerefVar(var_glojure_DOT_core_list) + tmp203 := lang.Apply(tmp202, []any{v52}) + tmp204 := checkDerefVar(var_glojure_DOT_core_list) + tmp205 := checkDerefVar(var_glojure_DOT_core_seq) + tmp206 := checkDerefVar(var_glojure_DOT_core_concat) + tmp207 := checkDerefVar(var_glojure_DOT_core_list) + tmp208 := lang.Apply(tmp207, []any{sym__DOT_nth}) + tmp209 := checkDerefVar(var_glojure_DOT_core_list) + tmp210 := lang.Apply(tmp209, []any{v71}) + tmp211 := checkDerefVar(var_glojure_DOT_core_list) + tmp212 := lang.Apply(tmp211, []any{v77}) + tmp213 := lang.Apply(tmp206, []any{tmp208, tmp210, tmp212}) + tmp214 := lang.Apply(tmp205, []any{tmp213}) + tmp215 := lang.Apply(tmp204, []any{tmp214}) + tmp216 := lang.Apply(tmp201, []any{tmp203, tmp215}) + tmp217 := lang.Apply(tmp200, []any{tmp216}) + tmp218 := lang.Apply(tmp198, []any{tmp199, tmp217}) + tmp219 := lang.Apply(tmp197, []any{tmp218}) + tmp220 := checkDerefVar(var_glojure_DOT_core_list) + tmp221 := lang.Apply(tmp220, []any{v137}) + var tmp222 any + if lang.IsTruthy(v106) { + tmp223 := lang.NewVector(v131) + tmp224 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3256), kw_column, int(48), kw_end_DASH_line, int(3256), kw_end_DASH_column, int(62)) + tmp225, err := lang.WithMeta(tmp223, tmp224.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp222 = tmp225 + } else { + } + tmp226 := lang.Apply(tmp194, []any{tmp196, tmp219, tmp221, tmp222}) + tmp227 := lang.Apply(tmp193, []any{tmp226}) + tmp228 := lang.Apply(tmp192, []any{tmp227}) + tmp229 := checkDerefVar(var_glojure_DOT_core_list) + tmp230 := checkDerefVar(var_glojure_DOT_core_seq) + tmp231 := checkDerefVar(var_glojure_DOT_core_concat) + tmp232 := checkDerefVar(var_glojure_DOT_core_list) + tmp233 := lang.Apply(tmp232, []any{sym_glojure_DOT_core_SLASH_when_DASH_let}) + tmp234 := checkDerefVar(var_glojure_DOT_core_list) + tmp235 := checkDerefVar(var_glojure_DOT_core_apply) + tmp236 := checkDerefVar(var_glojure_DOT_core_vector) + tmp237 := checkDerefVar(var_glojure_DOT_core_seq) + tmp238 := checkDerefVar(var_glojure_DOT_core_concat) + tmp239 := checkDerefVar(var_glojure_DOT_core_list) + tmp240 := lang.Apply(tmp239, []any{v63}) + tmp241 := checkDerefVar(var_glojure_DOT_core_list) + tmp242 := checkDerefVar(var_glojure_DOT_core_seq) + tmp243 := checkDerefVar(var_glojure_DOT_core_concat) + tmp244 := checkDerefVar(var_glojure_DOT_core_list) + tmp245 := lang.Apply(tmp244, []any{sym_glojure_DOT_core_SLASH_seq}) + tmp246 := checkDerefVar(var_glojure_DOT_core_list) + tmp247 := lang.Apply(tmp246, []any{v63}) + tmp248 := lang.Apply(tmp243, []any{tmp245, tmp247}) + tmp249 := lang.Apply(tmp242, []any{tmp248}) + tmp250 := lang.Apply(tmp241, []any{tmp249}) + tmp251 := lang.Apply(tmp238, []any{tmp240, tmp250}) + tmp252 := lang.Apply(tmp237, []any{tmp251}) + tmp253 := lang.Apply(tmp235, []any{tmp236, tmp252}) + tmp254 := lang.Apply(tmp234, []any{tmp253}) + tmp255 := checkDerefVar(var_glojure_DOT_core_list) + tmp256 := checkDerefVar(var_glojure_DOT_core_seq) + tmp257 := checkDerefVar(var_glojure_DOT_core_concat) + tmp258 := checkDerefVar(var_glojure_DOT_core_list) + tmp259 := lang.Apply(tmp258, []any{sym_if}) + tmp260 := checkDerefVar(var_glojure_DOT_core_list) + tmp261 := checkDerefVar(var_glojure_DOT_core_seq) + tmp262 := checkDerefVar(var_glojure_DOT_core_concat) + tmp263 := checkDerefVar(var_glojure_DOT_core_list) + tmp264 := lang.Apply(tmp263, []any{sym_glojure_DOT_core_SLASH_chunked_DASH_seq_QMARK_}) + tmp265 := checkDerefVar(var_glojure_DOT_core_list) + tmp266 := lang.Apply(tmp265, []any{v63}) + tmp267 := lang.Apply(tmp262, []any{tmp264, tmp266}) + tmp268 := lang.Apply(tmp261, []any{tmp267}) + tmp269 := lang.Apply(tmp260, []any{tmp268}) + tmp270 := checkDerefVar(var_glojure_DOT_core_list) + tmp271 := checkDerefVar(var_glojure_DOT_core_seq) + tmp272 := checkDerefVar(var_glojure_DOT_core_concat) + tmp273 := checkDerefVar(var_glojure_DOT_core_list) + tmp274 := lang.Apply(tmp273, []any{sym_glojure_DOT_core_SLASH_let}) + tmp275 := checkDerefVar(var_glojure_DOT_core_list) + tmp276 := checkDerefVar(var_glojure_DOT_core_apply) + tmp277 := checkDerefVar(var_glojure_DOT_core_vector) + tmp278 := checkDerefVar(var_glojure_DOT_core_seq) + tmp279 := checkDerefVar(var_glojure_DOT_core_concat) + tmp280 := checkDerefVar(var_glojure_DOT_core_list) + tmp281 := lang.Apply(tmp280, []any{sym_c__0__auto__}) + tmp282 := checkDerefVar(var_glojure_DOT_core_list) + tmp283 := checkDerefVar(var_glojure_DOT_core_seq) + tmp284 := checkDerefVar(var_glojure_DOT_core_concat) + tmp285 := checkDerefVar(var_glojure_DOT_core_list) + tmp286 := lang.Apply(tmp285, []any{sym_glojure_DOT_core_SLASH_chunk_DASH_first}) + tmp287 := checkDerefVar(var_glojure_DOT_core_list) + tmp288 := lang.Apply(tmp287, []any{v63}) + tmp289 := lang.Apply(tmp284, []any{tmp286, tmp288}) + tmp290 := lang.Apply(tmp283, []any{tmp289}) + tmp291 := lang.Apply(tmp282, []any{tmp290}) + tmp292 := lang.Apply(tmp279, []any{tmp281, tmp291}) + tmp293 := lang.Apply(tmp278, []any{tmp292}) + tmp294 := lang.Apply(tmp276, []any{tmp277, tmp293}) + tmp295 := lang.Apply(tmp275, []any{tmp294}) + tmp296 := checkDerefVar(var_glojure_DOT_core_list) + tmp297 := checkDerefVar(var_glojure_DOT_core_seq) + tmp298 := checkDerefVar(var_glojure_DOT_core_concat) + tmp299 := checkDerefVar(var_glojure_DOT_core_list) + tmp300 := lang.Apply(tmp299, []any{sym_recur}) + tmp301 := checkDerefVar(var_glojure_DOT_core_list) + tmp302 := checkDerefVar(var_glojure_DOT_core_seq) + tmp303 := checkDerefVar(var_glojure_DOT_core_concat) + tmp304 := checkDerefVar(var_glojure_DOT_core_list) + tmp305 := lang.Apply(tmp304, []any{sym_glojure_DOT_core_SLASH_chunk_DASH_rest}) + tmp306 := checkDerefVar(var_glojure_DOT_core_list) + tmp307 := lang.Apply(tmp306, []any{v63}) + tmp308 := lang.Apply(tmp303, []any{tmp305, tmp307}) + tmp309 := lang.Apply(tmp302, []any{tmp308}) + tmp310 := lang.Apply(tmp301, []any{tmp309}) + tmp311 := checkDerefVar(var_glojure_DOT_core_list) + tmp312 := lang.Apply(tmp311, []any{sym_c__0__auto__}) + tmp313 := checkDerefVar(var_glojure_DOT_core_list) + tmp314 := checkDerefVar(var_glojure_DOT_core_seq) + tmp315 := checkDerefVar(var_glojure_DOT_core_concat) + tmp316 := checkDerefVar(var_glojure_DOT_core_list) + tmp317 := lang.Apply(tmp316, []any{sym_glojure_DOT_core_SLASH_int}) + tmp318 := checkDerefVar(var_glojure_DOT_core_list) + tmp319 := checkDerefVar(var_glojure_DOT_core_seq) + tmp320 := checkDerefVar(var_glojure_DOT_core_concat) + tmp321 := checkDerefVar(var_glojure_DOT_core_list) + tmp322 := lang.Apply(tmp321, []any{sym_glojure_DOT_core_SLASH_count}) + tmp323 := checkDerefVar(var_glojure_DOT_core_list) + tmp324 := lang.Apply(tmp323, []any{sym_c__0__auto__}) + tmp325 := lang.Apply(tmp320, []any{tmp322, tmp324}) + tmp326 := lang.Apply(tmp319, []any{tmp325}) + tmp327 := lang.Apply(tmp318, []any{tmp326}) + tmp328 := lang.Apply(tmp315, []any{tmp317, tmp327}) + tmp329 := lang.Apply(tmp314, []any{tmp328}) + tmp330 := lang.Apply(tmp313, []any{tmp329}) + tmp331 := checkDerefVar(var_glojure_DOT_core_list) + tmp332 := checkDerefVar(var_glojure_DOT_core_seq) + tmp333 := checkDerefVar(var_glojure_DOT_core_concat) + tmp334 := checkDerefVar(var_glojure_DOT_core_list) + tmp335 := lang.Apply(tmp334, []any{sym_glojure_DOT_core_SLASH_int}) + tmp336 := checkDerefVar(var_glojure_DOT_core_list) + tmp337 := lang.Apply(tmp336, []any{int64(0)}) + tmp338 := lang.Apply(tmp333, []any{tmp335, tmp337}) + tmp339 := lang.Apply(tmp332, []any{tmp338}) + tmp340 := lang.Apply(tmp331, []any{tmp339}) + tmp341 := lang.Apply(tmp298, []any{tmp300, tmp310, tmp312, tmp330, tmp340}) + tmp342 := lang.Apply(tmp297, []any{tmp341}) + tmp343 := lang.Apply(tmp296, []any{tmp342}) + tmp344 := lang.Apply(tmp272, []any{tmp274, tmp295, tmp343}) + tmp345 := lang.Apply(tmp271, []any{tmp344}) + tmp346 := lang.Apply(tmp270, []any{tmp345}) + tmp347 := checkDerefVar(var_glojure_DOT_core_list) + tmp348 := checkDerefVar(var_glojure_DOT_core_seq) + tmp349 := checkDerefVar(var_glojure_DOT_core_concat) + tmp350 := checkDerefVar(var_glojure_DOT_core_list) + tmp351 := lang.Apply(tmp350, []any{sym_glojure_DOT_core_SLASH_let}) + tmp352 := checkDerefVar(var_glojure_DOT_core_list) + tmp353 := checkDerefVar(var_glojure_DOT_core_apply) + tmp354 := checkDerefVar(var_glojure_DOT_core_vector) + tmp355 := checkDerefVar(var_glojure_DOT_core_seq) + tmp356 := checkDerefVar(var_glojure_DOT_core_concat) + tmp357 := checkDerefVar(var_glojure_DOT_core_list) + tmp358 := lang.Apply(tmp357, []any{v52}) + tmp359 := checkDerefVar(var_glojure_DOT_core_list) + tmp360 := checkDerefVar(var_glojure_DOT_core_seq) + tmp361 := checkDerefVar(var_glojure_DOT_core_concat) + tmp362 := checkDerefVar(var_glojure_DOT_core_list) + tmp363 := lang.Apply(tmp362, []any{sym_glojure_DOT_core_SLASH_first}) + tmp364 := checkDerefVar(var_glojure_DOT_core_list) + tmp365 := lang.Apply(tmp364, []any{v63}) + tmp366 := lang.Apply(tmp361, []any{tmp363, tmp365}) + tmp367 := lang.Apply(tmp360, []any{tmp366}) + tmp368 := lang.Apply(tmp359, []any{tmp367}) + tmp369 := lang.Apply(tmp356, []any{tmp358, tmp368}) + tmp370 := lang.Apply(tmp355, []any{tmp369}) + tmp371 := lang.Apply(tmp353, []any{tmp354, tmp370}) + tmp372 := lang.Apply(tmp352, []any{tmp371}) + tmp373 := checkDerefVar(var_glojure_DOT_core_list) + tmp374 := lang.Apply(tmp373, []any{v108}) + var tmp375 any + if lang.IsTruthy(v106) { + tmp376 := lang.NewVector(v100) + tmp377 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3264), kw_column, int(52), kw_end_DASH_line, int(3264), kw_end_DASH_column, int(60)) + tmp378, err := lang.WithMeta(tmp376, tmp377.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp375 = tmp378 + } else { + } + tmp379 := lang.Apply(tmp349, []any{tmp351, tmp372, tmp374, tmp375}) + tmp380 := lang.Apply(tmp348, []any{tmp379}) + tmp381 := lang.Apply(tmp347, []any{tmp380}) + tmp382 := lang.Apply(tmp257, []any{tmp259, tmp269, tmp346, tmp381}) + tmp383 := lang.Apply(tmp256, []any{tmp382}) + tmp384 := lang.Apply(tmp255, []any{tmp383}) + tmp385 := lang.Apply(tmp231, []any{tmp233, tmp254, tmp384}) + tmp386 := lang.Apply(tmp230, []any{tmp385}) + tmp387 := lang.Apply(tmp229, []any{tmp386}) + tmp388 := lang.Apply(tmp177, []any{tmp179, tmp191, tmp228, tmp387}) + tmp389 := lang.Apply(tmp176, []any{tmp388}) + tmp390 := lang.Apply(tmp175, []any{tmp389}) + tmp391 := lang.Apply(tmp139, []any{tmp141, tmp174, tmp390}) + tmp392 := lang.Apply(tmp138, []any{tmp391}) + tmp393 := lang.NewVector(true, tmp392) + tmp394 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3250), kw_column, int(24), kw_end_DASH_line, int(3264), kw_end_DASH_column, int(67)) + tmp395, err := lang.WithMeta(tmp393, tmp394.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp60 = tmp395 + } // end let + tmp56 = tmp60 + } + tmp49 = tmp56 + } // end let + tmp37 = tmp49 + } + return tmp37 + }) + v34 = tmp33 + _ = v34 + } + tmp34 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3218), kw_column, int(14), kw_end_DASH_line, int(3264), kw_end_DASH_column, int(72)) + tmp35, err := lang.WithMeta(tmp33, tmp34.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v36 any = tmp35 + _ = v36 + tmp37 := checkDerefVar(var_glojure_DOT_core_nth) + tmp38 := checkDerefVar(var_glojure_DOT_core_seq) + tmp39 := lang.Apply(tmp38, []any{v4}) + tmp40 := lang.Apply(v36, []any{nil, tmp39}) + tmp41 := lang.Apply(tmp37, []any{tmp40, int64(1)}) + tmp32 = tmp41 + } // end let + return tmp32 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_doseq = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_doseq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // doto + { + tmp0 := sym_doto.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_x, sym__AMP_, sym_forms)), kw_doc, "Evaluates x then calls all of the methods and functions with the\n value of x supplied at the front of the given arguments. The forms\n are evaluated in order. Returns x.\n\n (doto (new java.util.HashMap) (.put \"a\" 1) (.put \"b\" 2))", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(11), kw_line, int(3853), kw_end_DASH_line, int(3853))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "gx" + tmp7 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp8 := lang.Apply(tmp7, nil) + var v9 any = tmp8 + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_seq) + tmp11 := checkDerefVar(var_glojure_DOT_core_concat) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_glojure_DOT_core_SLASH_let}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_apply) + tmp16 := checkDerefVar(var_glojure_DOT_core_vector) + tmp17 := checkDerefVar(var_glojure_DOT_core_seq) + tmp18 := checkDerefVar(var_glojure_DOT_core_concat) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v9}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v4}) + tmp23 := lang.Apply(tmp18, []any{tmp20, tmp22}) + tmp24 := lang.Apply(tmp17, []any{tmp23}) + tmp25 := lang.Apply(tmp15, []any{tmp16, tmp24}) + tmp26 := lang.Apply(tmp14, []any{tmp25}) + tmp27 := checkDerefVar(var_glojure_DOT_core_map) + var tmp28 lang.FnFunc + tmp28 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v29 := args[0] + _ = v29 + tmp30 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + var tmp31 any + tmp32 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp33 := lang.Apply(tmp32, []any{v29}) + if lang.IsTruthy(tmp33) { + tmp34 := checkDerefVar(var_glojure_DOT_core_seq) + tmp35 := checkDerefVar(var_glojure_DOT_core_concat) + tmp36 := checkDerefVar(var_glojure_DOT_core_list) + tmp37 := checkDerefVar(var_glojure_DOT_core_first) + tmp38 := lang.Apply(tmp37, []any{v29}) + tmp39 := lang.Apply(tmp36, []any{tmp38}) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{v9}) + tmp42 := checkDerefVar(var_glojure_DOT_core_next) + tmp43 := lang.Apply(tmp42, []any{v29}) + tmp44 := lang.Apply(tmp35, []any{tmp39, tmp41, tmp43}) + tmp45 := lang.Apply(tmp34, []any{tmp44}) + tmp31 = tmp45 + } else { + tmp46 := checkDerefVar(var_glojure_DOT_core_seq) + tmp47 := checkDerefVar(var_glojure_DOT_core_concat) + tmp48 := checkDerefVar(var_glojure_DOT_core_list) + tmp49 := lang.Apply(tmp48, []any{v29}) + tmp50 := checkDerefVar(var_glojure_DOT_core_list) + tmp51 := lang.Apply(tmp50, []any{v9}) + tmp52 := lang.Apply(tmp47, []any{tmp49, tmp51}) + tmp53 := lang.Apply(tmp46, []any{tmp52}) + tmp31 = tmp53 + } + tmp54 := checkDerefVar(var_glojure_DOT_core_meta) + tmp55 := lang.Apply(tmp54, []any{v29}) + tmp56 := lang.Apply(tmp30, []any{tmp31, tmp55}) + return tmp56 + }) + tmp29 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3863), kw_column, int(17), kw_end_DASH_line, int(3868), kw_end_DASH_column, int(30)) + tmp30, err := lang.WithMeta(tmp28, tmp29.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp31 := lang.Apply(tmp27, []any{tmp30, v5}) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := lang.Apply(tmp32, []any{v9}) + tmp34 := lang.Apply(tmp11, []any{tmp13, tmp26, tmp31, tmp33}) + tmp35 := lang.Apply(tmp10, []any{tmp34}) + tmp6 = tmp35 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_doto = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_doto.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // drop-last + { + tmp0 := sym_drop_DASH_last.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll), lang.NewVector(sym_n, sym_coll)), kw_doc, "Return a lazy sequence of all but the last n (default 1) items in coll", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(2932), kw_end_DASH_line, int(2932))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_drop_DASH_last) + tmp4 := lang.Apply(tmp3, []any{int64(1), v2}) + return tmp4 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_map) + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + return v6 + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2937), kw_column, int(18), kw_end_DASH_line, int(2937), kw_end_DASH_column, int(29)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp8 := checkDerefVar(var_glojure_DOT_core_drop) + tmp9 := lang.Apply(tmp8, []any{v2, v3}) + tmp10 := lang.Apply(tmp4, []any{tmp7, v3, tmp9}) + return tmp10 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_drop_DASH_last = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_drop_DASH_last.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // emit-extend-protocol + { + tmp0 := sym_emit_DASH_extend_DASH_protocol.WithMeta(lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(205), kw_column, int(8), kw_end_DASH_line, int(205), kw_end_DASH_column, int(27), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_p, sym_specs)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "impls" + tmp5 := checkDerefVar(var_glojure_DOT_core_parse_DASH_impls) + tmp6 := lang.Apply(tmp5, []any{v3}) + var v7 any = tmp6 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_do}) + tmp12 := checkDerefVar(var_glojure_DOT_core_map) + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v14 := args[0] + _ = v14 + var tmp15 any + { // let + // let binding "vec__983" + var v16 any = v14 + _ = v16 + // let binding "t" + tmp17 := checkDerefVar(var_glojure_DOT_core_nth) + tmp18 := lang.Apply(tmp17, []any{v16, int64(0), nil}) + var v19 any = tmp18 + _ = v19 + // let binding "fs" + tmp20 := checkDerefVar(var_glojure_DOT_core_nth) + tmp21 := lang.Apply(tmp20, []any{v16, int64(1), nil}) + var v22 any = tmp21 + _ = v22 + tmp23 := checkDerefVar(var_glojure_DOT_core_seq) + tmp24 := checkDerefVar(var_glojure_DOT_core_concat) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := lang.Apply(tmp25, []any{sym_glojure_DOT_core_SLASH_extend_DASH_type}) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{v19}) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{v2}) + tmp31 := lang.Apply(tmp24, []any{tmp26, tmp28, tmp30, v22}) + tmp32 := lang.Apply(tmp23, []any{tmp31}) + tmp15 = tmp32 + } // end let + return tmp15 + }) + tmp14 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(208), kw_column, int(15), kw_end_DASH_line, int(209), kw_end_DASH_column, int(42)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp16 := lang.Apply(tmp12, []any{tmp15, v7}) + tmp17 := lang.Apply(tmp9, []any{tmp11, tmp16}) + tmp18 := lang.Apply(tmp8, []any{tmp17}) + tmp4 = tmp18 + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_emit_DASH_extend_DASH_protocol = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_emit_DASH_extend_DASH_protocol.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // emit-hinted-impl + { + tmp0 := sym_emit_DASH_hinted_DASH_impl.WithMeta(lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(163), kw_column, int(8), kw_end_DASH_line, int(163), kw_end_DASH_column, int(23), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_c, lang.NewVector(sym_p, sym_fs))), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "vec__972" + var v5 any = v3 + _ = v5 + // let binding "p" + tmp6 := checkDerefVar(var_glojure_DOT_core_nth) + tmp7 := lang.Apply(tmp6, []any{v5, int64(0), nil}) + var v8 any = tmp7 + _ = v8 + // let binding "fs" + tmp9 := checkDerefVar(var_glojure_DOT_core_nth) + tmp10 := lang.Apply(tmp9, []any{v5, int64(1), nil}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + { // let + // let binding "hint" + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v14 := args[0] + _ = v14 + var tmp15 any + { // let + // let binding "specs" + var tmp16 any + tmp17 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp18 := checkDerefVar(var_glojure_DOT_core_first) + tmp19 := lang.Apply(tmp18, []any{v14}) + tmp20 := lang.Apply(tmp17, []any{tmp19}) + if lang.IsTruthy(tmp20) { + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v14}) + tmp16 = tmp22 + } else { + tmp16 = v14 + } + var v23 any = tmp16 + _ = v23 + tmp24 := checkDerefVar(var_glojure_DOT_core_map) + var tmp25 lang.FnFunc + tmp25 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v26 := args[0] + _ = v26 + var tmp27 any + { // let + // let binding "vec__976" + var v28 any = v26 + _ = v28 + // let binding "seq__977" + tmp29 := checkDerefVar(var_glojure_DOT_core_seq) + tmp30 := lang.Apply(tmp29, []any{v28}) + var v31 any = tmp30 + _ = v31 + // let binding "first__978" + tmp32 := checkDerefVar(var_glojure_DOT_core_first) + tmp33 := lang.Apply(tmp32, []any{v31}) + var v34 any = tmp33 + _ = v34 + // let binding "seq__977" + tmp35 := checkDerefVar(var_glojure_DOT_core_next) + tmp36 := lang.Apply(tmp35, []any{v31}) + var v37 any = tmp36 + _ = v37 + // let binding "vec__979" + var v38 any = v34 + _ = v38 + // let binding "seq__980" + tmp39 := checkDerefVar(var_glojure_DOT_core_seq) + tmp40 := lang.Apply(tmp39, []any{v38}) + var v41 any = tmp40 + _ = v41 + // let binding "first__981" + tmp42 := checkDerefVar(var_glojure_DOT_core_first) + tmp43 := lang.Apply(tmp42, []any{v41}) + var v44 any = tmp43 + _ = v44 + // let binding "seq__980" + tmp45 := checkDerefVar(var_glojure_DOT_core_next) + tmp46 := lang.Apply(tmp45, []any{v41}) + var v47 any = tmp46 + _ = v47 + // let binding "target" + var v48 any = v44 + _ = v48 + // let binding "args" + var v49 any = v47 + _ = v49 + // let binding "body" + var v50 any = v37 + _ = v50 + tmp51 := checkDerefVar(var_glojure_DOT_core_cons) + tmp52 := checkDerefVar(var_glojure_DOT_core_apply) + tmp53 := checkDerefVar(var_glojure_DOT_core_vector) + tmp54 := checkDerefVar(var_glojure_DOT_core_vary_DASH_meta) + tmp55 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp56 := lang.Apply(tmp54, []any{v48, tmp55, kw_tag, v2}) + tmp57 := lang.Apply(tmp52, []any{tmp53, tmp56, v49}) + tmp58 := lang.Apply(tmp51, []any{tmp57, v50}) + tmp27 = tmp58 + } // end let + return tmp27 + }) + tmp26 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(168), kw_column, int(23), kw_end_DASH_line, int(170), kw_end_DASH_column, int(36)) + tmp27, err := lang.WithMeta(tmp25, tmp26.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp28 := lang.Apply(tmp24, []any{tmp27, v23}) + tmp15 = tmp28 + } // end let + return tmp15 + }) + tmp14 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(164), kw_column, int(14), kw_end_DASH_line, int(171), kw_end_DASH_column, int(30)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v16 any = tmp15 + _ = v16 + tmp17 := checkDerefVar(var_glojure_DOT_core_zipmap) + tmp18 := checkDerefVar(var_glojure_DOT_core_map) + var tmp19 lang.FnFunc + tmp19 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v20 := args[0] + _ = v20 + tmp21 := checkDerefVar(var_glojure_DOT_core_keyword) + tmp22 := checkDerefVar(var_glojure_DOT_core_name) + tmp23 := checkDerefVar(var_glojure_DOT_core_first) + tmp24 := lang.Apply(tmp23, []any{v20}) + tmp25 := lang.Apply(tmp22, []any{tmp24}) + tmp26 := lang.Apply(tmp21, []any{tmp25}) + return tmp26 + }) + tmp20 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(172), kw_column, int(21), kw_end_DASH_line, int(172), kw_end_DASH_column, int(46)) + tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp22 := lang.Apply(tmp18, []any{tmp21, v11}) + tmp23 := checkDerefVar(var_glojure_DOT_core_map) + var tmp24 lang.FnFunc + tmp24 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v25 := args[0] + _ = v25 + tmp26 := checkDerefVar(var_glojure_DOT_core_cons) + tmp27 := checkDerefVar(var_glojure_DOT_core_drop) + tmp28 := lang.Apply(tmp27, []any{int64(1), v25}) + tmp29 := lang.Apply(v16, []any{tmp28}) + tmp30 := lang.Apply(tmp26, []any{sym_glojure_DOT_core_SLASH_fn, tmp29}) + return tmp30 + }) + tmp25 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(173), kw_column, int(21), kw_end_DASH_line, int(173), kw_end_DASH_column, int(49)) + tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp27 := lang.Apply(tmp23, []any{tmp26, v11}) + tmp28 := lang.Apply(tmp17, []any{tmp22, tmp27}) + tmp29 := lang.NewVector(v8, tmp28) + tmp30 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(172), kw_column, int(5), kw_end_DASH_line, int(173), kw_end_DASH_column, int(55)) + tmp31, err := lang.WithMeta(tmp29, tmp30.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp12 = tmp31 + } // end let + tmp4 = tmp12 + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_emit_DASH_hinted_DASH_impl = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_emit_DASH_hinted_DASH_impl.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // extend-protocol + { + tmp0 := sym_extend_DASH_protocol.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_p, sym__AMP_, sym_specs)), kw_doc, "Useful when you want to provide several implementations of the same\n protocol all at once. Takes a single protocol and the implementation\n of that protocol for one or more types.\n\n (extend-protocol Protocol\n AType\n (foo [x] ...)\n (bar [x y] ...)\n BType\n (foo [x] ...)\n (bar [x y] ...)\n AClass\n (foo [x] ...)\n (bar [x y] ...)\n nil\n (foo [x] ...)\n (bar [x y] ...))\n\n expands into:\n\n (do\n (clojure.core/extend-type AType Protocol \n (foo [x] ...) \n (bar [x y] ...))\n (clojure.core/extend-type BType Protocol \n (foo [x] ...) \n (bar [x y] ...))\n (clojure.core/extend-type AClass Protocol \n (foo [x] ...) \n (bar [x y] ...))\n (clojure.core/extend-type nil Protocol \n (foo [x] ...) \n (bar [x y] ...)))", kw_file, "glojure/core_deftype.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(25), kw_column, int(11), kw_line, int(212), kw_end_DASH_line, int(212))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_emit_DASH_extend_DASH_protocol) + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_extend_DASH_protocol = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_extend_DASH_protocol.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // fits-table? + { + tmp0 := sym_fits_DASH_table_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ints)), kw_doc, "Returns true if the collection of ints can fit within the\n max-table-switch-size, false otherwise.", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(8), kw_line, int(6625), kw_end_DASH_line, int(6625), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp4 := checkDerefVar(var_glojure_DOT_core__DASH_) + tmp5 := checkDerefVar(var_glojure_DOT_core_apply) + tmp6 := checkDerefVar(var_glojure_DOT_core_max) + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := lang.Apply(tmp7, []any{v2}) + tmp9 := lang.Apply(tmp5, []any{tmp6, tmp8}) + tmp10 := checkDerefVar(var_glojure_DOT_core_apply) + tmp11 := checkDerefVar(var_glojure_DOT_core_min) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := lang.Apply(tmp12, []any{v2}) + tmp14 := lang.Apply(tmp10, []any{tmp11, tmp13}) + tmp15 := lang.Apply(tmp4, []any{tmp9, tmp14}) + tmp16 := checkDerefVar(var_glojure_DOT_core_max_DASH_switch_DASH_table_DASH_size) + tmp17 := lang.Apply(tmp3, []any{tmp15, tmp16}) + return tmp17 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_fits_DASH_table_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_fits_DASH_table_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // fn + { + tmp0 := sym_fn.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_sigs)), kw_doc, "params => positional-params*, or positional-params* & rest-param\n positional-param => binding-form\n rest-param => binding-form\n binding-form => name, or destructuring-form\n\n Defines a function.\n\n See https://glojure.org/reference/special_forms#fn for more information", kw_forms, lang.NewVector(lang.NewList(sym_fn, sym_name_QMARK_, lang.NewVector(sym_params_STAR_), sym_exprs_STAR_), lang.NewList(sym_fn, sym_name_QMARK_, lang.NewList(lang.NewVector(sym_params_STAR_), sym_exprs_STAR_), sym__PLUS_)), kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(11), kw_line, int(4533), kw_end_DASH_line, int(4533), kw_special_DASH_form, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "name" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp8 := checkDerefVar(var_glojure_DOT_core_first) + tmp9 := lang.Apply(tmp8, []any{v4}) + tmp10 := lang.Apply(tmp7, []any{tmp9}) + if lang.IsTruthy(tmp10) { + tmp11 := checkDerefVar(var_glojure_DOT_core_first) + tmp12 := lang.Apply(tmp11, []any{v4}) + tmp6 = tmp12 + } else { + } + var v13 any = tmp6 + _ = v13 + // let binding "sigs" + var tmp14 any + if lang.IsTruthy(v13) { + tmp15 := checkDerefVar(var_glojure_DOT_core_next) + tmp16 := lang.Apply(tmp15, []any{v4}) + tmp14 = tmp16 + } else { + tmp14 = v4 + } + var v17 any = tmp14 + _ = v17 + // let binding "sigs" + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp20 := checkDerefVar(var_glojure_DOT_core_first) + tmp21 := lang.Apply(tmp20, []any{v17}) + tmp22 := lang.Apply(tmp19, []any{tmp21}) + if lang.IsTruthy(tmp22) { + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := lang.Apply(tmp23, []any{v17}) + tmp18 = tmp24 + } else { + var tmp25 any + tmp26 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp27 := checkDerefVar(var_glojure_DOT_core_first) + tmp28 := lang.Apply(tmp27, []any{v17}) + tmp29 := lang.Apply(tmp26, []any{tmp28}) + if lang.IsTruthy(tmp29) { + tmp25 = v17 + } else { + var tmp30 any + tmp31 := checkDerefVar(var_glojure_DOT_core_seq) + tmp32 := lang.Apply(tmp31, []any{v17}) + if lang.IsTruthy(tmp32) { + tmp33 := checkDerefVar(var_glojure_DOT_core_str) + tmp34 := checkDerefVar(var_glojure_DOT_core_first) + tmp35 := lang.Apply(tmp34, []any{v17}) + tmp36 := lang.Apply(tmp33, []any{"Parameter declaration ", tmp35, " should be a vector"}) + tmp30 = tmp36 + } else { + tmp37 := checkDerefVar(var_glojure_DOT_core_str) + tmp38 := lang.Apply(tmp37, []any{"Parameter declaration missing"}) + tmp30 = tmp38 + } + tmp39 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp39) + } + tmp18 = tmp25 + } + var v40 any = tmp18 + _ = v40 + // let binding "psig" + var tmp41 lang.FnFunc + tmp41 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v42 := args[0] + _ = v42 + var tmp43 any + tmp44 := checkDerefVar(var_glojure_DOT_core_not) + tmp45 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp46 := lang.Apply(tmp45, []any{v42}) + tmp47 := lang.Apply(tmp44, []any{tmp46}) + if lang.IsTruthy(tmp47) { + tmp48 := checkDerefVar(var_glojure_DOT_core_str) + tmp49 := lang.Apply(tmp48, []any{"Invalid signature ", v42, " should be a list"}) + tmp50 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp49}) + panic(tmp50) + } else { + } + _ = tmp43 + var tmp51 any + { // let + // let binding "vec__704" + var v52 any = v42 + _ = v52 + // let binding "seq__705" + tmp53 := checkDerefVar(var_glojure_DOT_core_seq) + tmp54 := lang.Apply(tmp53, []any{v52}) + var v55 any = tmp54 + _ = v55 + // let binding "first__706" + tmp56 := checkDerefVar(var_glojure_DOT_core_first) + tmp57 := lang.Apply(tmp56, []any{v55}) + var v58 any = tmp57 + _ = v58 + // let binding "seq__705" + tmp59 := checkDerefVar(var_glojure_DOT_core_next) + tmp60 := lang.Apply(tmp59, []any{v55}) + var v61 any = tmp60 + _ = v61 + // let binding "params" + var v62 any = v58 + _ = v62 + // let binding "body" + var v63 any = v61 + _ = v63 + // let binding "_" + var tmp64 any + tmp65 := checkDerefVar(var_glojure_DOT_core_not) + tmp66 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp67 := lang.Apply(tmp66, []any{v62}) + tmp68 := lang.Apply(tmp65, []any{tmp67}) + if lang.IsTruthy(tmp68) { + var tmp69 any + tmp70 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp71 := checkDerefVar(var_glojure_DOT_core_first) + tmp72 := lang.Apply(tmp71, []any{v40}) + tmp73 := lang.Apply(tmp70, []any{tmp72}) + if lang.IsTruthy(tmp73) { + tmp74 := checkDerefVar(var_glojure_DOT_core_str) + tmp75 := lang.Apply(tmp74, []any{"Parameter declaration ", v62, " should be a vector"}) + tmp69 = tmp75 + } else { + tmp76 := checkDerefVar(var_glojure_DOT_core_str) + tmp77 := lang.Apply(tmp76, []any{"Invalid signature ", v42, " should be a list"}) + tmp69 = tmp77 + } + tmp78 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp69}) + panic(tmp78) + } else { + } + var v79 any = tmp64 + _ = v79 + // let binding "conds" + var tmp80 any + var tmp81 any + { // let + // let binding "and__0__auto__" + tmp82 := checkDerefVar(var_glojure_DOT_core_next) + tmp83 := lang.Apply(tmp82, []any{v63}) + var v84 any = tmp83 + _ = v84 + var tmp85 any + if lang.IsTruthy(v84) { + tmp86 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp87 := checkDerefVar(var_glojure_DOT_core_first) + tmp88 := lang.Apply(tmp87, []any{v63}) + tmp89 := lang.Apply(tmp86, []any{tmp88}) + tmp85 = tmp89 + } else { + tmp85 = v84 + } + tmp81 = tmp85 + } // end let + if lang.IsTruthy(tmp81) { + tmp82 := checkDerefVar(var_glojure_DOT_core_first) + tmp83 := lang.Apply(tmp82, []any{v63}) + tmp80 = tmp83 + } else { + } + var v84 any = tmp80 + _ = v84 + // let binding "body" + var tmp85 any + if lang.IsTruthy(v84) { + tmp86 := checkDerefVar(var_glojure_DOT_core_next) + tmp87 := lang.Apply(tmp86, []any{v63}) + tmp85 = tmp87 + } else { + tmp85 = v63 + } + var v88 any = tmp85 + _ = v88 + // let binding "conds" + var tmp89 any + { // let + // let binding "or__0__auto__" + var v90 any = v84 + _ = v90 + var tmp91 any + if lang.IsTruthy(v90) { + tmp91 = v90 + } else { + tmp92 := checkDerefVar(var_glojure_DOT_core_meta) + tmp93 := lang.Apply(tmp92, []any{v62}) + tmp91 = tmp93 + } + tmp89 = tmp91 + } // end let + var v90 any = tmp89 + _ = v90 + // let binding "pre" + tmp91 := lang.Apply(kw_pre, []any{v90}) + var v92 any = tmp91 + _ = v92 + // let binding "post" + tmp93 := lang.Apply(kw_post, []any{v90}) + var v94 any = tmp93 + _ = v94 + // let binding "body" + var tmp95 any + if lang.IsTruthy(v94) { + tmp96 := checkDerefVar(var_glojure_DOT_core_seq) + tmp97 := checkDerefVar(var_glojure_DOT_core_concat) + tmp98 := checkDerefVar(var_glojure_DOT_core_list) + tmp99 := checkDerefVar(var_glojure_DOT_core_seq) + tmp100 := checkDerefVar(var_glojure_DOT_core_concat) + tmp101 := checkDerefVar(var_glojure_DOT_core_list) + tmp102 := lang.Apply(tmp101, []any{sym_glojure_DOT_core_SLASH_let}) + tmp103 := checkDerefVar(var_glojure_DOT_core_list) + tmp104 := checkDerefVar(var_glojure_DOT_core_apply) + tmp105 := checkDerefVar(var_glojure_DOT_core_vector) + tmp106 := checkDerefVar(var_glojure_DOT_core_seq) + tmp107 := checkDerefVar(var_glojure_DOT_core_concat) + tmp108 := checkDerefVar(var_glojure_DOT_core_list) + tmp109 := lang.Apply(tmp108, []any{sym__PCT_}) + tmp110 := checkDerefVar(var_glojure_DOT_core_list) + var tmp111 any + tmp112 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp113 := checkDerefVar(var_glojure_DOT_core_count) + tmp114 := lang.Apply(tmp113, []any{v88}) + tmp115 := lang.Apply(tmp112, []any{int64(1), tmp114}) + if lang.IsTruthy(tmp115) { + tmp116 := checkDerefVar(var_glojure_DOT_core_seq) + tmp117 := checkDerefVar(var_glojure_DOT_core_concat) + tmp118 := checkDerefVar(var_glojure_DOT_core_list) + tmp119 := lang.Apply(tmp118, []any{sym_do}) + tmp120 := lang.Apply(tmp117, []any{tmp119, v88}) + tmp121 := lang.Apply(tmp116, []any{tmp120}) + tmp111 = tmp121 + } else { + tmp122 := checkDerefVar(var_glojure_DOT_core_first) + tmp123 := lang.Apply(tmp122, []any{v88}) + tmp111 = tmp123 + } + tmp124 := lang.Apply(tmp110, []any{tmp111}) + tmp125 := lang.Apply(tmp107, []any{tmp109, tmp124}) + tmp126 := lang.Apply(tmp106, []any{tmp125}) + tmp127 := lang.Apply(tmp104, []any{tmp105, tmp126}) + tmp128 := lang.Apply(tmp103, []any{tmp127}) + tmp129 := checkDerefVar(var_glojure_DOT_core_map) + var tmp130 lang.FnFunc + tmp130 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v131 := args[0] + _ = v131 + tmp132 := checkDerefVar(var_glojure_DOT_core_seq) + tmp133 := checkDerefVar(var_glojure_DOT_core_concat) + tmp134 := checkDerefVar(var_glojure_DOT_core_list) + tmp135 := lang.Apply(tmp134, []any{sym_glojure_DOT_core_SLASH_assert}) + tmp136 := checkDerefVar(var_glojure_DOT_core_list) + tmp137 := lang.Apply(tmp136, []any{v131}) + tmp138 := lang.Apply(tmp133, []any{tmp135, tmp137}) + tmp139 := lang.Apply(tmp132, []any{tmp138}) + return tmp139 + }) + tmp131 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4582), kw_column, int(41), kw_end_DASH_line, int(4582), kw_end_DASH_column, int(62)) + tmp132, err := lang.WithMeta(tmp130, tmp131.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp133 := lang.Apply(tmp129, []any{tmp132, v94}) + tmp134 := checkDerefVar(var_glojure_DOT_core_list) + tmp135 := lang.Apply(tmp134, []any{sym__PCT_}) + tmp136 := lang.Apply(tmp100, []any{tmp102, tmp128, tmp133, tmp135}) + tmp137 := lang.Apply(tmp99, []any{tmp136}) + tmp138 := lang.Apply(tmp98, []any{tmp137}) + tmp139 := lang.Apply(tmp97, []any{tmp138}) + tmp140 := lang.Apply(tmp96, []any{tmp139}) + tmp95 = tmp140 + } else { + tmp95 = v88 + } + var v141 any = tmp95 + _ = v141 + // let binding "body" + var tmp142 any + if lang.IsTruthy(v92) { + tmp143 := checkDerefVar(var_glojure_DOT_core_concat) + tmp144 := checkDerefVar(var_glojure_DOT_core_map) + var tmp145 lang.FnFunc + tmp145 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v146 := args[0] + _ = v146 + tmp147 := checkDerefVar(var_glojure_DOT_core_seq) + tmp148 := checkDerefVar(var_glojure_DOT_core_concat) + tmp149 := checkDerefVar(var_glojure_DOT_core_list) + tmp150 := lang.Apply(tmp149, []any{sym_glojure_DOT_core_SLASH_assert}) + tmp151 := checkDerefVar(var_glojure_DOT_core_list) + tmp152 := lang.Apply(tmp151, []any{v146}) + tmp153 := lang.Apply(tmp148, []any{tmp150, tmp152}) + tmp154 := lang.Apply(tmp147, []any{tmp153}) + return tmp154 + }) + tmp146 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4586), kw_column, int(44), kw_end_DASH_line, int(4586), kw_end_DASH_column, int(65)) + tmp147, err := lang.WithMeta(tmp145, tmp146.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp148 := lang.Apply(tmp144, []any{tmp147, v92}) + tmp149 := lang.Apply(tmp143, []any{tmp148, v141}) + tmp142 = tmp149 + } else { + tmp142 = v141 + } + var v150 any = tmp142 + _ = v150 + tmp151 := checkDerefVar(var_glojure_DOT_core_maybe_DASH_destructured) + tmp152 := lang.Apply(tmp151, []any{v62, v150}) + tmp51 = tmp152 + } // end let + return tmp51 + }) + tmp42 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4558), kw_column, int(16), kw_end_DASH_line, int(4589), kw_end_DASH_column, int(53)) + tmp43, err := lang.WithMeta(tmp41, tmp42.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v44 any = tmp43 + _ = v44 + // let binding "new-sigs" + tmp45 := checkDerefVar(var_glojure_DOT_core_map) + tmp46 := lang.Apply(tmp45, []any{v44, v40}) + var v47 any = tmp46 + _ = v47 + tmp48 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + var tmp49 any + if lang.IsTruthy(v13) { + tmp50 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp51 := lang.Apply(tmp50, []any{sym_fn_STAR_, v13, v47}) + tmp49 = tmp51 + } else { + tmp52 := checkDerefVar(var_glojure_DOT_core_cons) + tmp53 := lang.Apply(tmp52, []any{sym_fn_STAR_, v47}) + tmp49 = tmp53 + } + tmp54 := checkDerefVar(var_glojure_DOT_core_meta) + tmp55 := lang.Apply(tmp54, []any{v2}) + tmp56 := lang.Apply(tmp48, []any{tmp49, tmp55}) + tmp5 = tmp56 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_fn = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_fn.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // import + { + tmp0 := sym_import.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_import_DASH_symbols_DASH_or_DASH_lists)), kw_doc, "import-list => (package-symbol class-name-symbols*)\n\n For each name in class-name-symbols, adds a mapping from name to the\n class named by package.name to the current namespace. Use :import in the ns\n macro in preference to calling this directly.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(11), kw_line, int(3426), kw_end_DASH_line, int(3426))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "specs" + tmp6 := checkDerefVar(var_glojure_DOT_core_map) + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v8 := args[0] + _ = v8 + var tmp9 any + var tmp10 any + { // let + // let binding "and__0__auto__" + tmp11 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp12 := lang.Apply(tmp11, []any{v8}) + var v13 any = tmp12 + _ = v13 + var tmp14 any + if lang.IsTruthy(v13) { + tmp15 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp16 := checkDerefVar(var_glojure_DOT_core_first) + tmp17 := lang.Apply(tmp16, []any{v8}) + tmp18 := lang.Apply(tmp15, []any{sym_quote, tmp17}) + tmp14 = tmp18 + } else { + tmp14 = v13 + } + tmp10 = tmp14 + } // end let + if lang.IsTruthy(tmp10) { + tmp11 := checkDerefVar(var_glojure_DOT_core_second) + tmp12 := lang.Apply(tmp11, []any{v8}) + tmp9 = tmp12 + } else { + tmp9 = v8 + } + return tmp9 + }) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3434), kw_column, int(20), kw_end_DASH_line, int(3434), kw_end_DASH_column, int(73)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp10 := lang.Apply(tmp6, []any{tmp9, v4}) + var v11 any = tmp10 + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_do}) + tmp16 := checkDerefVar(var_glojure_DOT_core_map) + var tmp17 lang.FnFunc + tmp17 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v18 := args[0] + _ = v18 + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Import, v18}) + return tmp20 + }) + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3436), kw_column, int(17), kw_end_DASH_line, int(3436), kw_end_DASH_column, int(73)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp20 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp21 lang.FnFunc + tmp21 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v22 := args[0] + _ = v22 + v23 := args[1] + _ = v23 + var tmp24 any + tmp25 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp26 := lang.Apply(tmp25, []any{v23}) + if lang.IsTruthy(tmp26) { + tmp27 := checkDerefVar(var_glojure_DOT_core_conj) + tmp28 := checkDerefVar(var_glojure_DOT_core_name) + tmp29 := lang.Apply(tmp28, []any{v23}) + tmp30 := lang.Apply(tmp27, []any{v22, tmp29}) + tmp24 = tmp30 + } else { + var tmp31 any + { // let + // let binding "p" + tmp32 := checkDerefVar(var_glojure_DOT_core_first) + tmp33 := lang.Apply(tmp32, []any{v23}) + var v34 any = tmp33 + _ = v34 + // let binding "cs" + tmp35 := checkDerefVar(var_glojure_DOT_core_rest) + tmp36 := lang.Apply(tmp35, []any{v23}) + var v37 any = tmp36 + _ = v37 + tmp38 := checkDerefVar(var_glojure_DOT_core_into1) + tmp39 := checkDerefVar(var_glojure_DOT_core_map) + var tmp40 lang.FnFunc + tmp40 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v41 := args[0] + _ = v41 + tmp42 := checkDerefVar(var_glojure_DOT_core_str) + tmp43 := lang.Apply(tmp42, []any{v34, ".", v41}) + return tmp43 + }) + tmp41 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3441), kw_column, int(45), kw_end_DASH_line, int(3441), kw_end_DASH_column, int(58)) + tmp42, err := lang.WithMeta(tmp40, tmp41.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp43 := lang.Apply(tmp39, []any{tmp42, v37}) + tmp44 := lang.Apply(tmp38, []any{v22, tmp43}) + tmp31 = tmp44 + } // end let + tmp24 = tmp31 + } + return tmp24 + }) + tmp22 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3437), kw_column, int(26), kw_end_DASH_line, int(3441), kw_end_DASH_column, int(66)) + tmp23, err := lang.WithMeta(tmp21, tmp22.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp24 := lang.NewVector() + tmp25 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3442), kw_column, int(25), kw_end_DASH_line, int(3442), kw_end_DASH_column, int(26)) + tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp27 := lang.Apply(tmp20, []any{tmp23, tmp26, v11}) + tmp28 := lang.Apply(tmp16, []any{tmp19, tmp27}) + tmp29 := lang.Apply(tmp13, []any{tmp15, tmp28}) + tmp30 := lang.Apply(tmp12, []any{tmp29}) + tmp5 = tmp30 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_import = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_import.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // interleave + { + tmp0 := sym_interleave.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_c1), lang.NewVector(sym_c1, sym_c2), lang.NewVector(sym_c1, sym_c2, sym__AMP_, sym_colls)), kw_doc, "Returns a lazy seq of the first item in each coll, then the second etc.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4308), kw_end_DASH_line, int(4308))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return lang.NewList() + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + return v2 + }) + tmp4 := lang.Apply(lang.NewLazySeq, []any{tmp3}) + return tmp4 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp5 any + { // let + // let binding "s1" + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := lang.Apply(tmp6, []any{v2}) + var v8 any = tmp7 + _ = v8 + // let binding "s2" + tmp9 := checkDerefVar(var_glojure_DOT_core_seq) + tmp10 := lang.Apply(tmp9, []any{v3}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + var tmp13 any + { // let + // let binding "and__0__auto__" + var v14 any = v8 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + tmp15 = v11 + } else { + tmp15 = v14 + } + tmp13 = tmp15 + } // end let + if lang.IsTruthy(tmp13) { + tmp14 := checkDerefVar(var_glojure_DOT_core_cons) + tmp15 := checkDerefVar(var_glojure_DOT_core_first) + tmp16 := lang.Apply(tmp15, []any{v8}) + tmp17 := checkDerefVar(var_glojure_DOT_core_cons) + tmp18 := checkDerefVar(var_glojure_DOT_core_first) + tmp19 := lang.Apply(tmp18, []any{v11}) + tmp20 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp21 := checkDerefVar(var_glojure_DOT_core_rest) + tmp22 := lang.Apply(tmp21, []any{v8}) + tmp23 := checkDerefVar(var_glojure_DOT_core_rest) + tmp24 := lang.Apply(tmp23, []any{v11}) + tmp25 := lang.Apply(tmp20, []any{tmp22, tmp24}) + tmp26 := lang.Apply(tmp17, []any{tmp19, tmp25}) + tmp27 := lang.Apply(tmp14, []any{tmp16, tmp26}) + tmp12 = tmp27 + } else { + } + tmp5 = tmp12 + } // end let + return tmp5 + }) + tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) + return tmp5 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp6 any + { // let + // let binding "ss" + tmp7 := checkDerefVar(var_glojure_DOT_core_map) + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_conj) + tmp10 := lang.Apply(tmp9, []any{v4, v3, v2}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + tmp14 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + tmp15 := checkDerefVar(var_glojure_DOT_core_identity) + tmp16 := lang.Apply(tmp14, []any{tmp15, v12}) + if lang.IsTruthy(tmp16) { + tmp17 := checkDerefVar(var_glojure_DOT_core_concat) + tmp18 := checkDerefVar(var_glojure_DOT_core_map) + tmp19 := checkDerefVar(var_glojure_DOT_core_first) + tmp20 := lang.Apply(tmp18, []any{tmp19, v12}) + tmp21 := checkDerefVar(var_glojure_DOT_core_apply) + tmp22 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp23 := checkDerefVar(var_glojure_DOT_core_map) + tmp24 := checkDerefVar(var_glojure_DOT_core_rest) + tmp25 := lang.Apply(tmp23, []any{tmp24, v12}) + tmp26 := lang.Apply(tmp21, []any{tmp22, tmp25}) + tmp27 := lang.Apply(tmp17, []any{tmp20, tmp26}) + tmp13 = tmp27 + } else { + } + tmp6 = tmp13 + } // end let + return tmp6 + }) + tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_interleave = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_interleave.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // interpose + { + tmp0 := sym_interpose.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_sep), lang.NewVector(sym_sep, sym_coll)), kw_doc, "Returns a lazy seq of the elements of coll separated by sep.\n Returns a stateful transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(5230), kw_end_DASH_line, int(5230))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 any + { // let + // let binding "started" + tmp6 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) + tmp7 := lang.Apply(tmp6, []any{false}) + var v8 any = tmp7 + _ = v8 + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp10 := lang.Apply(v4, nil) + return tmp10 + case 1: + v10 := args[0] + _ = v10 + tmp11 := lang.Apply(v4, []any{v10}) + return tmp11 + case 2: + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + var tmp12 any + tmp13 := checkDerefVar(var_glojure_DOT_core_deref) + tmp14 := lang.Apply(tmp13, []any{v8}) + if lang.IsTruthy(tmp14) { + var tmp15 any + { // let + // let binding "sepr" + tmp16 := lang.Apply(v4, []any{v10, v2}) + var v17 any = tmp16 + _ = v17 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) + tmp20 := lang.Apply(tmp19, []any{v17}) + if lang.IsTruthy(tmp20) { + tmp18 = v17 + } else { + tmp21 := lang.Apply(v4, []any{v17, v11}) + tmp18 = tmp21 + } + tmp15 = tmp18 + } // end let + tmp12 = tmp15 + } else { + tmp16 := checkDerefVar(var_glojure_DOT_core_vreset_BANG_) + tmp17 := lang.Apply(tmp16, []any{v8, true}) + _ = tmp17 + tmp18 := lang.Apply(v4, []any{v10, v11}) + tmp12 = tmp18 + } + return tmp12 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5238), kw_column, int(8), kw_end_DASH_line, int(5249), kw_end_DASH_column, int(35)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp5 = tmp11 + } // end let + return tmp5 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5236), kw_column, int(4), kw_end_DASH_line, int(5249), kw_end_DASH_column, int(37)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_drop) + tmp5 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp6 := checkDerefVar(var_glojure_DOT_core_repeat) + tmp7 := lang.Apply(tmp6, []any{v2}) + tmp8 := lang.Apply(tmp5, []any{tmp7, v3}) + tmp9 := lang.Apply(tmp4, []any{int64(1), tmp8}) + return tmp9 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_interpose = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_interpose.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // isa? + { + tmp0 := sym_isa_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_child, sym_parent), lang.NewVector(sym_h, sym_child, sym_parent)), kw_doc, "Returns true if (= child parent), or child is directly or indirectly derived from\n parent, either via a Java type inheritance relationship or a\n relationship established via derive. h must be a hierarchy obtained\n from make-hierarchy, if not supplied defaults to the global\n hierarchy", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(5543), kw_end_DASH_line, int(5543))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_isa_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_global_DASH_hierarchy) + tmp6 := lang.Apply(tmp4, []any{tmp5, v2, v3}) + return tmp6 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + { // let + // let binding "or__0__auto__" + tmp6 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp7 := lang.Apply(tmp6, []any{v3, v4}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + tmp9 = v8 + } else { + var tmp10 any + { // let + // let binding "or__0__auto__" + var tmp11 any + { // let + // let binding "and__0__auto__" + tmp12 := checkDerefVar(var_glojure_DOT_core_class_QMARK_) + tmp13 := lang.Apply(tmp12, []any{v4}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + var tmp16 any + { // let + // let binding "and__0__auto__" + tmp17 := checkDerefVar(var_glojure_DOT_core_class_QMARK_) + tmp18 := lang.Apply(tmp17, []any{v3}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + tmp21, _ := lang.FieldOrMethod(v3, "AssignableTo") + if reflect.TypeOf(tmp21).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("AssignableTo is not a function"))) + } + tmp22 := lang.Apply(tmp21, []any{v4}) + tmp20 = tmp22 + } else { + tmp20 = v19 + } + tmp16 = tmp20 + } // end let + tmp15 = tmp16 + } else { + tmp15 = v14 + } + tmp11 = tmp15 + } // end let + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + tmp13 = v12 + } else { + var tmp14 any + { // let + // let binding "or__0__auto__" + tmp15 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp16 := lang.Apply(kw_ancestors, []any{v2}) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := lang.Apply(tmp15, []any{tmp17, v4}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + tmp20 = v19 + } else { + var tmp21 any + { // let + // let binding "or__0__auto__" + var tmp22 any + { // let + // let binding "and__0__auto__" + tmp23 := checkDerefVar(var_glojure_DOT_core_class_QMARK_) + tmp24 := lang.Apply(tmp23, []any{v3}) + var v25 any = tmp24 + _ = v25 + var tmp26 any + if lang.IsTruthy(v25) { + tmp27 := checkDerefVar(var_glojure_DOT_core_some) + var tmp28 lang.FnFunc + tmp28 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v29 := args[0] + _ = v29 + tmp30 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp31 := lang.Apply(kw_ancestors, []any{v2}) + tmp32 := lang.Apply(tmp31, []any{v29}) + tmp33 := lang.Apply(tmp30, []any{tmp32, v4}) + return tmp33 + }) + tmp29 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5556), kw_column, int(34), kw_end_DASH_line, int(5556), kw_end_DASH_column, int(71)) + tmp30, err := lang.WithMeta(tmp28, tmp29.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp31 := checkDerefVar(var_glojure_DOT_core_supers) + tmp32 := lang.Apply(tmp31, []any{v3}) + tmp33 := lang.Apply(tmp27, []any{tmp30, tmp32}) + tmp26 = tmp33 + } else { + tmp26 = v25 + } + tmp22 = tmp26 + } // end let + var v23 any = tmp22 + _ = v23 + var tmp24 any + if lang.IsTruthy(v23) { + tmp24 = v23 + } else { + var tmp25 any + { // let + // let binding "and__0__auto__" + tmp26 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp27 := lang.Apply(tmp26, []any{v4}) + var v28 any = tmp27 + _ = v28 + var tmp29 any + if lang.IsTruthy(v28) { + var tmp30 any + { // let + // let binding "and__0__auto__" + tmp31 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp32 := lang.Apply(tmp31, []any{v3}) + var v33 any = tmp32 + _ = v33 + var tmp34 any + if lang.IsTruthy(v33) { + var tmp35 any + { // let + // let binding "and__0__auto__" + tmp36 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp37 := checkDerefVar(var_glojure_DOT_core_count) + tmp38 := lang.Apply(tmp37, []any{v4}) + tmp39 := checkDerefVar(var_glojure_DOT_core_count) + tmp40 := lang.Apply(tmp39, []any{v3}) + tmp41 := lang.Apply(tmp36, []any{tmp38, tmp40}) + var v42 any = tmp41 + _ = v42 + var tmp43 any + if lang.IsTruthy(v42) { + var tmp44 any + { // let + // let binding "ret" + var v45 any = true + _ = v45 + // let binding "i" + var v46 any = int64(0) + _ = v46 + for { + var tmp47 any + var tmp48 any + { // let + // let binding "or__0__auto__" + tmp49 := checkDerefVar(var_glojure_DOT_core_not) + tmp50 := lang.Apply(tmp49, []any{v45}) + var v51 any = tmp50 + _ = v51 + var tmp52 any + if lang.IsTruthy(v51) { + tmp52 = v51 + } else { + tmp53 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp54 := checkDerefVar(var_glojure_DOT_core_count) + tmp55 := lang.Apply(tmp54, []any{v4}) + tmp56 := lang.Apply(tmp53, []any{v46, tmp55}) + tmp52 = tmp56 + } + tmp48 = tmp52 + } // end let + if lang.IsTruthy(tmp48) { + tmp47 = v45 + } else { + tmp50 := checkDerefVar(var_glojure_DOT_core_isa_QMARK_) + tmp51 := lang.Apply(v3, []any{v46}) + tmp52 := lang.Apply(v4, []any{v46}) + tmp53 := lang.Apply(tmp50, []any{v2, tmp51, tmp52}) + var tmp49 any = tmp53 + tmp55 := checkDerefVar(var_glojure_DOT_core_inc) + tmp56 := lang.Apply(tmp55, []any{v46}) + var tmp54 any = tmp56 + v45 = tmp49 + v46 = tmp54 + continue + } + tmp44 = tmp47 + break + } + } // end let + tmp43 = tmp44 + } else { + tmp43 = v42 + } + tmp35 = tmp43 + } // end let + tmp34 = tmp35 + } else { + tmp34 = v33 + } + tmp30 = tmp34 + } // end let + tmp29 = tmp30 + } else { + tmp29 = v28 + } + tmp25 = tmp29 + } // end let + tmp24 = tmp25 + } + tmp21 = tmp24 + } // end let + tmp20 = tmp21 + } + tmp14 = tmp20 + } // end let + tmp13 = tmp14 + } + tmp10 = tmp13 + } // end let + tmp9 = tmp10 + } + tmp5 = tmp9 + } // end let + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_isa_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_isa_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // lazy-cat + { + tmp0 := sym_lazy_DASH_cat.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_colls)), kw_doc, "Expands to code which yields a lazy sequence of the concatenation\n of the supplied colls. Each coll expr is not evaluated until it is\n needed. \n\n (lazy-cat xs ys zs) === (concat (lazy-seq xs) (lazy-seq ys) (lazy-seq zs))", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(11), kw_line, int(4636), kw_end_DASH_line, int(4636))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym_glojure_DOT_core_SLASH_concat}) + tmp9 := checkDerefVar(var_glojure_DOT_core_map) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v11 := args[0] + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_glojure_DOT_core_SLASH_lazy_DASH_seq, v11}) + return tmp13 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4644), kw_column, int(19), kw_end_DASH_line, int(4644), kw_end_DASH_column, int(37)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := lang.Apply(tmp9, []any{tmp12, v4}) + tmp14 := lang.Apply(tmp6, []any{tmp8, tmp13}) + tmp15 := lang.Apply(tmp5, []any{tmp14}) + return tmp15 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_lazy_DASH_cat = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_lazy_DASH_cat.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // letfn + { + tmp0 := sym_letfn.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_fnspecs, sym__AMP_, sym_body)), kw_doc, "fnspec ==> (fname [params*] exprs) or (fname ([params*] exprs)+)\n\n Takes a vector of function specs and a body, and generates a set of\n bindings of functions to their names. All of the names are available\n in all of the definitions of the functions, as well as the body.", kw_forms, lang.NewVector(lang.NewList(sym_letfn, lang.NewVector(sym_fnspecs_STAR_), sym_exprs_STAR_)), kw_url, nil, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(11), kw_line, int(6545), kw_end_DASH_line, int(6545), kw_special_DASH_form, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_letfn_STAR_}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_vec) + tmp12 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp13 := checkDerefVar(var_glojure_DOT_core_map) + tmp14 := checkDerefVar(var_glojure_DOT_core_first) + tmp15 := lang.Apply(tmp13, []any{tmp14, v4}) + tmp16 := checkDerefVar(var_glojure_DOT_core_map) + var tmp17 lang.FnFunc + tmp17 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v18 := args[0] + _ = v18 + tmp19 := checkDerefVar(var_glojure_DOT_core_cons) + tmp20 := lang.Apply(tmp19, []any{sym_glojure_DOT_core_SLASH_fn, v18}) + return tmp20 + }) + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6555), kw_column, int(35), kw_end_DASH_line, int(6555), kw_end_DASH_column, int(47)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp20 := lang.Apply(tmp16, []any{tmp19, v4}) + tmp21 := lang.Apply(tmp12, []any{tmp15, tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp10, []any{tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp9, tmp23, v5}) + tmp25 := lang.Apply(tmp6, []any{tmp24}) + return tmp25 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_letfn = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_letfn.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // lift-ns + { + tmp0 := sym_lift_DASH_ns.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m)), kw_doc, "Returns [lifted-ns lifted-kvs] or nil if m can't be lifted.", kw_file, "glojure/core_print.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(8), kw_line, int(261), kw_end_DASH_line, int(261), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_namespace_DASH_maps_STAR_) + if lang.IsTruthy(tmp4) { + var tmp5 any + { // let + // let binding "ns" + var v6 any = nil + _ = v6 + // let binding "G__912" + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := lang.Apply(tmp7, []any{v2}) + var v9 any = tmp8 + _ = v9 + // let binding "vec__913" + var v10 any = v9 + _ = v10 + // let binding "seq__914" + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := lang.Apply(tmp11, []any{v10}) + var v13 any = tmp12 + _ = v13 + // let binding "first__915" + tmp14 := checkDerefVar(var_glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v13}) + var v16 any = tmp15 + _ = v16 + // let binding "seq__914" + tmp17 := checkDerefVar(var_glojure_DOT_core_next) + tmp18 := lang.Apply(tmp17, []any{v13}) + var v19 any = tmp18 + _ = v19 + // let binding "vec__916" + var v20 any = v16 + _ = v20 + // let binding "k" + tmp21 := checkDerefVar(var_glojure_DOT_core_nth) + tmp22 := lang.Apply(tmp21, []any{v20, int64(0), nil}) + var v23 any = tmp22 + _ = v23 + // let binding "v" + tmp24 := checkDerefVar(var_glojure_DOT_core_nth) + tmp25 := lang.Apply(tmp24, []any{v20, int64(1), nil}) + var v26 any = tmp25 + _ = v26 + // let binding "entry" + var v27 any = v20 + _ = v27 + // let binding "entries" + var v28 any = v19 + _ = v28 + // let binding "kvs" + tmp29 := lang.NewVector() + tmp30 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(267), kw_column, int(16), kw_end_DASH_line, int(267), kw_end_DASH_column, int(17)) + tmp31, err := lang.WithMeta(tmp29, tmp30.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v32 any = tmp31 + _ = v32 + var tmp33 any + { // let + // let binding "ns" + var v34 any = v6 + _ = v34 + // let binding "G__912" + var v35 any = v9 + _ = v35 + // let binding "kvs" + var v36 any = v32 + _ = v36 + for { + var tmp37 any + { // let + // let binding "ns" + var v38 any = v34 + _ = v38 + // let binding "vec__919" + var v39 any = v35 + _ = v39 + // let binding "seq__920" + tmp40 := checkDerefVar(var_glojure_DOT_core_seq) + tmp41 := lang.Apply(tmp40, []any{v39}) + var v42 any = tmp41 + _ = v42 + // let binding "first__921" + tmp43 := checkDerefVar(var_glojure_DOT_core_first) + tmp44 := lang.Apply(tmp43, []any{v42}) + var v45 any = tmp44 + _ = v45 + // let binding "seq__920" + tmp46 := checkDerefVar(var_glojure_DOT_core_next) + tmp47 := lang.Apply(tmp46, []any{v42}) + var v48 any = tmp47 + _ = v48 + // let binding "vec__922" + var v49 any = v45 + _ = v49 + // let binding "k" + tmp50 := checkDerefVar(var_glojure_DOT_core_nth) + tmp51 := lang.Apply(tmp50, []any{v49, int64(0), nil}) + var v52 any = tmp51 + _ = v52 + // let binding "v" + tmp53 := checkDerefVar(var_glojure_DOT_core_nth) + tmp54 := lang.Apply(tmp53, []any{v49, int64(1), nil}) + var v55 any = tmp54 + _ = v55 + // let binding "entry" + var v56 any = v49 + _ = v56 + // let binding "entries" + var v57 any = v48 + _ = v57 + // let binding "kvs" + var v58 any = v36 + _ = v58 + var tmp59 any + if lang.IsTruthy(v56) { + var tmp60 any + tmp61 := checkDerefVar(var_glojure_DOT_core_qualified_DASH_ident_QMARK_) + tmp62 := lang.Apply(tmp61, []any{v52}) + if lang.IsTruthy(tmp62) { + var tmp63 any + if lang.IsTruthy(v38) { + var tmp64 any + tmp65 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp66 := checkDerefVar(var_glojure_DOT_core_namespace) + tmp67 := lang.Apply(tmp66, []any{v52}) + tmp68 := lang.Apply(tmp65, []any{v38, tmp67}) + if lang.IsTruthy(tmp68) { + var tmp69 any = v38 + var tmp70 any = v57 + tmp72 := checkDerefVar(var_glojure_DOT_core_conj) + tmp73 := checkDerefVar(var_glojure_DOT_core_strip_DASH_ns) + tmp74 := lang.Apply(tmp73, []any{v52}) + tmp75 := lang.NewVector(tmp74, v55) + tmp76 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(272), kw_column, int(43), kw_end_DASH_line, int(272), kw_end_DASH_column, int(58)) + tmp77, err := lang.WithMeta(tmp75, tmp76.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp78 := lang.Apply(tmp72, []any{v58, tmp77}) + var tmp71 any = tmp78 + v34 = tmp69 + v35 = tmp70 + v36 = tmp71 + continue + } else { + } + tmp63 = tmp64 + } else { + var tmp79 any + { // let + // let binding "temp__0__auto__" + tmp80 := checkDerefVar(var_glojure_DOT_core_namespace) + tmp81 := lang.Apply(tmp80, []any{v52}) + var v82 any = tmp81 + _ = v82 + var tmp83 any + if lang.IsTruthy(v82) { + var tmp84 any + { // let + // let binding "new-ns" + var v85 any = v82 + _ = v85 + var tmp86 any = v85 + var tmp87 any = v57 + tmp89 := checkDerefVar(var_glojure_DOT_core_conj) + tmp90 := checkDerefVar(var_glojure_DOT_core_strip_DASH_ns) + tmp91 := lang.Apply(tmp90, []any{v52}) + tmp92 := lang.NewVector(tmp91, v55) + tmp93 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(274), kw_column, int(47), kw_end_DASH_line, int(274), kw_end_DASH_column, int(62)) + tmp94, err := lang.WithMeta(tmp92, tmp93.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp95 := lang.Apply(tmp89, []any{v58, tmp94}) + var tmp88 any = tmp95 + v34 = tmp86 + v35 = tmp87 + v36 = tmp88 + continue + } // end let + tmp83 = tmp84 + } else { + } + tmp79 = tmp83 + } // end let + tmp63 = tmp79 + } + tmp60 = tmp63 + } else { + } + tmp59 = tmp60 + } else { + tmp80 := lang.NewVector(v38, v58) + tmp81 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(275), kw_column, int(9), kw_end_DASH_line, int(275), kw_end_DASH_column, int(16)) + tmp82, err := lang.WithMeta(tmp80, tmp81.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp59 = tmp82 + } + tmp37 = tmp59 + } // end let + tmp33 = tmp37 + break + } + } // end let + tmp5 = tmp33 + } // end let + tmp3 = tmp5 + } else { + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_lift_DASH_ns = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_lift_DASH_ns.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // make-array + { + tmp0 := sym_make_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_type, sym_len), lang.NewVector(sym_type, sym_dim, sym__AMP_, sym_more_DASH_dims)), kw_doc, "Creates and returns an array of instances of the specified class of\n the specified dimension(s). Note that a class object is required.\n Class objects can be obtained by using their imported or\n fully-qualified name. Class objects for the primitive types can be\n obtained using, e.g., Integer/TYPE.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(3985), kw_end_DASH_line, int(3985))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_int) + tmp5 := lang.Apply(tmp4, []any{v3}) + tmp6, _ := lang.FieldOrMethod(nil, "newInstance") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("newInstance is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v2, tmp5}) + return tmp7 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "dims" + tmp6 := checkDerefVar(var_glojure_DOT_core_cons) + tmp7 := lang.Apply(tmp6, []any{v3, v4}) + var v8 any = tmp7 + _ = v8 + // let binding "dimarray" + tmp9 := checkDerefVar(var_glojure_DOT_core_make_DASH_array) + tmp10, ok := lang.FieldOrMethod(nil, "TYPE") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "TYPE"))) + } + var tmp11 any + switch reflect.TypeOf(tmp10).Kind() { + case reflect.Func: + tmp11 = lang.Apply(tmp10, nil) + default: + tmp11 = tmp10 + } + tmp12 := checkDerefVar(var_glojure_DOT_core_count) + tmp13 := lang.Apply(tmp12, []any{v8}) + tmp14 := lang.Apply(tmp9, []any{tmp11, tmp13}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + { // let + // let binding "n__0__auto__" + tmp17 := checkDerefVar(var_glojure_DOT_core_long) + tmp18 := checkDerefVar(var_glojure_DOT_core_alength) + tmp19 := lang.Apply(tmp18, []any{v15}) + tmp20 := lang.Apply(tmp17, []any{tmp19}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + { // let + // let binding "i" + var v23 any = int64(0) + _ = v23 + for { + var tmp24 any + tmp25 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp26 := lang.Apply(tmp25, []any{v23, v21}) + if lang.IsTruthy(tmp26) { + tmp27 := checkDerefVar(var_glojure_DOT_core_aset_DASH_int) + tmp28 := checkDerefVar(var_glojure_DOT_core_nth) + tmp29 := lang.Apply(tmp28, []any{v8, v23}) + tmp30 := lang.Apply(tmp27, []any{v15, v23, tmp29}) + _ = tmp30 + tmp32 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp33 := lang.Apply(tmp32, []any{v23}) + var tmp31 any = tmp33 + v23 = tmp31 + continue + } else { + } + tmp22 = tmp24 + break + } + } // end let + tmp16 = tmp22 + } // end let + _ = tmp16 + tmp17, _ := lang.FieldOrMethod(nil, "newInstance") + if reflect.TypeOf(tmp17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("newInstance is not a function"))) + } + tmp18 := lang.Apply(tmp17, []any{v2, v15}) + tmp5 = tmp18 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_make_DASH_array = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_make_DASH_array.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // maybe-min-hash + { + tmp0 := sym_maybe_DASH_min_DASH_hash.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_hashes)), kw_doc, "takes a collection of hashes and returns [shift mask] or nil if none found", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(8), kw_line, int(6604), kw_end_DASH_line, int(6604), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_first) + tmp4 := checkDerefVar(var_glojure_DOT_core_filter) + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v6 := args[0] + _ = v6 + var tmp7 any + { // let + // let binding "vec__842" + var v8 any = v6 + _ = v8 + // let binding "s" + tmp9 := checkDerefVar(var_glojure_DOT_core_nth) + tmp10 := lang.Apply(tmp9, []any{v8, int64(0), nil}) + var v11 any = tmp10 + _ = v11 + // let binding "m" + tmp12 := checkDerefVar(var_glojure_DOT_core_nth) + tmp13 := lang.Apply(tmp12, []any{v8, int64(1), nil}) + var v14 any = tmp13 + _ = v14 + tmp15 := checkDerefVar(var_glojure_DOT_core_apply) + tmp16 := checkDerefVar(var_glojure_DOT_core_distinct_QMARK_) + tmp17 := checkDerefVar(var_glojure_DOT_core_map) + var tmp18 lang.FnFunc + tmp18 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v19 := args[0] + _ = v19 + tmp20 := checkDerefVar(var_glojure_DOT_core_shift_DASH_mask) + tmp21 := lang.Apply(tmp20, []any{v11, v14, v19}) + return tmp21 + }) + tmp19 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6609), kw_column, int(37), kw_end_DASH_line, int(6609), kw_end_DASH_column, int(55)) + tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp21 := lang.Apply(tmp17, []any{tmp20, v2}) + tmp22 := lang.Apply(tmp15, []any{tmp16, tmp21}) + tmp7 = tmp22 + } // end let + return tmp7 + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6608), kw_column, int(13), kw_end_DASH_line, int(6609), kw_end_DASH_column, int(65)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var tmp8 any + { // let + // let binding "iter__0__auto__" + var tmp9 lang.FnFunc + { // function iter__845 + var v10 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v11 := args[0] + _ = v11 + var tmp12 lang.FnFunc + tmp12 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp13 any + { // let + // let binding "s__846" + var v14 any = v11 + _ = v14 + for { + var tmp15 any + { // let + // let binding "temp__0__auto__" + tmp16 := checkDerefVar(var_glojure_DOT_core_seq) + tmp17 := lang.Apply(tmp16, []any{v14}) + var v18 any = tmp17 + _ = v18 + var tmp19 any + if lang.IsTruthy(v18) { + var tmp20 any + { // let + // let binding "xs__0__auto__" + var v21 any = v18 + _ = v21 + var tmp22 any + { // let + // let binding "mask" + tmp23 := checkDerefVar(var_glojure_DOT_core_first) + tmp24 := lang.Apply(tmp23, []any{v21}) + var v25 any = tmp24 + _ = v25 + var tmp26 any + { // let + // let binding "iterys__0__auto__" + var tmp27 lang.FnFunc + { // function iter__847 + var v28 lang.FnFunc + tmp27 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v29 := args[0] + _ = v29 + var tmp30 lang.FnFunc + tmp30 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp31 any + { // let + // let binding "s__848" + var v32 any = v29 + _ = v32 + for { + var tmp33 any + { // let + // let binding "temp__0__auto__" + tmp34 := checkDerefVar(var_glojure_DOT_core_seq) + tmp35 := lang.Apply(tmp34, []any{v32}) + var v36 any = tmp35 + _ = v36 + var tmp37 any + if lang.IsTruthy(v36) { + var tmp38 any + { // let + // let binding "s__848" + var v39 any = v36 + _ = v39 + var tmp40 any + tmp41 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp42 := lang.Apply(tmp41, []any{v39}) + if lang.IsTruthy(tmp42) { + var tmp43 any + { // let + // let binding "c__0__auto__" + tmp44 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp45 := lang.Apply(tmp44, []any{v39}) + var v46 any = tmp45 + _ = v46 + // let binding "size__1__auto__" + tmp47 := checkDerefVar(var_glojure_DOT_core_int) + tmp48 := checkDerefVar(var_glojure_DOT_core_count) + tmp49 := lang.Apply(tmp48, []any{v46}) + tmp50 := lang.Apply(tmp47, []any{tmp49}) + var v51 any = tmp50 + _ = v51 + // let binding "b__850" + tmp52 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_buffer) + tmp53 := lang.Apply(tmp52, []any{v51}) + var v54 any = tmp53 + _ = v54 + var tmp55 any + var tmp56 any + { // let + // let binding "i__849" + tmp57 := checkDerefVar(var_glojure_DOT_core_int) + tmp58 := lang.Apply(tmp57, []any{int64(0)}) + var v59 any = tmp58 + _ = v59 + for { + var tmp60 any + tmp61 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp62 := lang.Apply(tmp61, []any{v59, v51}) + if lang.IsTruthy(tmp62) { + var tmp63 any + { // let + // let binding "shift" + tmp64, _ := lang.FieldOrMethod(v46, "nth") + if reflect.TypeOf(tmp64).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp65 := lang.Apply(tmp64, []any{v59}) + var v66 any = tmp65 + _ = v66 + tmp67 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_append) + tmp68 := lang.NewVector(v66, v25) + tmp69 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6612), kw_column, int(15), kw_end_DASH_line, int(6612), kw_end_DASH_column, int(26)) + tmp70, err := lang.WithMeta(tmp68, tmp69.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp71 := lang.Apply(tmp67, []any{v54, tmp70}) + _ = tmp71 + tmp73 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp74 := lang.Apply(tmp73, []any{v59}) + var tmp72 any = tmp74 + v59 = tmp72 + continue + } // end let + tmp60 = tmp63 + } else { + tmp60 = true + } + tmp56 = tmp60 + break + } + } // end let + if lang.IsTruthy(tmp56) { + tmp57 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_cons) + tmp58 := checkDerefVar(var_glojure_DOT_core_chunk) + tmp59 := lang.Apply(tmp58, []any{v54}) + tmp60 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp61 := lang.Apply(tmp60, []any{v39}) + tmp62 := lang.Apply(v28, []any{tmp61}) + tmp63 := lang.Apply(tmp57, []any{tmp59, tmp62}) + tmp55 = tmp63 + } else { + tmp64 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_cons) + tmp65 := checkDerefVar(var_glojure_DOT_core_chunk) + tmp66 := lang.Apply(tmp65, []any{v54}) + tmp67 := lang.Apply(tmp64, []any{tmp66, nil}) + tmp55 = tmp67 + } + tmp43 = tmp55 + } // end let + tmp40 = tmp43 + } else { + var tmp44 any + { // let + // let binding "shift" + tmp45 := checkDerefVar(var_glojure_DOT_core_first) + tmp46 := lang.Apply(tmp45, []any{v39}) + var v47 any = tmp46 + _ = v47 + tmp48 := checkDerefVar(var_glojure_DOT_core_cons) + tmp49 := lang.NewVector(v47, v25) + tmp50 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6612), kw_column, int(15), kw_end_DASH_line, int(6612), kw_end_DASH_column, int(26)) + tmp51, err := lang.WithMeta(tmp49, tmp50.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp52 := checkDerefVar(var_glojure_DOT_core_rest) + tmp53 := lang.Apply(tmp52, []any{v39}) + tmp54 := lang.Apply(v28, []any{tmp53}) + tmp55 := lang.Apply(tmp48, []any{tmp51, tmp54}) + tmp44 = tmp55 + } // end let + tmp40 = tmp44 + } + tmp38 = tmp40 + } // end let + tmp37 = tmp38 + } else { + } + tmp33 = tmp37 + } // end let + tmp31 = tmp33 + break + } + } // end let + return tmp31 + }) + tmp31 := lang.Apply(lang.NewLazySeq, []any{tmp30}) + return tmp31 + }) + v28 = tmp27 + _ = v28 + } + var v28 any = tmp27 + _ = v28 + // let binding "fs__1__auto__" + tmp29 := checkDerefVar(var_glojure_DOT_core_seq) + tmp30 := checkDerefVar(var_glojure_DOT_core_range) + tmp31 := lang.Apply(tmp30, []any{int64(0), int64(31)}) + tmp32 := lang.Apply(v28, []any{tmp31}) + tmp33 := lang.Apply(tmp29, []any{tmp32}) + var v34 any = tmp33 + _ = v34 + var tmp35 any + if lang.IsTruthy(v34) { + tmp36 := checkDerefVar(var_glojure_DOT_core_concat) + tmp37 := checkDerefVar(var_glojure_DOT_core_rest) + tmp38 := lang.Apply(tmp37, []any{v14}) + tmp39 := lang.Apply(v10, []any{tmp38}) + tmp40 := lang.Apply(tmp36, []any{v34, tmp39}) + tmp35 = tmp40 + } else { + tmp42 := checkDerefVar(var_glojure_DOT_core_rest) + tmp43 := lang.Apply(tmp42, []any{v14}) + var tmp41 any = tmp43 + v14 = tmp41 + continue + } + tmp26 = tmp35 + } // end let + tmp22 = tmp26 + } // end let + tmp20 = tmp22 + } // end let + tmp19 = tmp20 + } else { + } + tmp15 = tmp19 + } // end let + tmp13 = tmp15 + break + } + } // end let + return tmp13 + }) + tmp13 := lang.Apply(lang.NewLazySeq, []any{tmp12}) + return tmp13 + }) + v10 = tmp9 + _ = v10 + } + var v10 any = tmp9 + _ = v10 + tmp11 := checkDerefVar(var_glojure_DOT_core_map) + var tmp12 lang.FnFunc + tmp12 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v13 := args[0] + _ = v13 + tmp14 := checkDerefVar(var_glojure_DOT_core_dec) + tmp15 := checkDerefVar(var_glojure_DOT_core_bit_DASH_shift_DASH_left) + tmp16 := lang.Apply(tmp15, []any{int64(1), v13}) + tmp17 := lang.Apply(tmp14, []any{tmp16}) + return tmp17 + }) + tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6610), kw_column, int(29), kw_end_DASH_line, int(6610), kw_end_DASH_column, int(55)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp15 := checkDerefVar(var_glojure_DOT_core_range) + tmp16 := checkDerefVar(var_glojure_DOT_core_inc) + tmp17 := checkDerefVar(var_glojure_DOT_core_max_DASH_mask_DASH_bits) + tmp18 := lang.Apply(tmp16, []any{tmp17}) + tmp19 := lang.Apply(tmp15, []any{int64(1), tmp18}) + tmp20 := lang.Apply(tmp11, []any{tmp14, tmp19}) + tmp21 := lang.Apply(v10, []any{tmp20}) + tmp8 = tmp21 + } // end let + tmp9 := lang.Apply(tmp4, []any{tmp7, tmp8}) + tmp10 := lang.Apply(tmp3, []any{tmp9}) + return tmp10 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_maybe_DASH_min_DASH_hash = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_maybe_DASH_min_DASH_hash.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // memoize + { + tmp0 := sym_memoize.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f)), kw_doc, "Returns a memoized version of a referentially transparent function. The\n memoized version of the function keeps a cache of the mapping from arguments\n to results and, when calls with the same arguments are repeated often, has\n higher performance at the expense of higher memory use.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(6337), kw_end_DASH_line, int(6337))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "mem" + tmp4 := checkDerefVar(var_glojure_DOT_core_atom) + tmp5 := lang.NewMap() + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6345), kw_column, int(19), kw_end_DASH_line, int(6345), kw_end_DASH_column, int(20)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp8 := lang.Apply(tmp4, []any{tmp7}) + var v9 any = tmp8 + _ = v9 + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v11 any = lang.NewList(args[0:]...) + _ = v11 + var tmp12 any + { // let + // let binding "temp__0__auto__" + tmp13 := checkDerefVar(var_glojure_DOT_core_find) + tmp14 := checkDerefVar(var_glojure_DOT_core_deref) + tmp15 := lang.Apply(tmp14, []any{v9}) + tmp16 := lang.Apply(tmp13, []any{tmp15, v11}) + var v17 any = tmp16 + _ = v17 + var tmp18 any + if lang.IsTruthy(v17) { + var tmp19 any + { // let + // let binding "e" + var v20 any = v17 + _ = v20 + tmp21 := checkDerefVar(var_glojure_DOT_core_val) + tmp22 := lang.Apply(tmp21, []any{v20}) + tmp19 = tmp22 + } // end let + tmp18 = tmp19 + } else { + var tmp20 any + { // let + // let binding "ret" + tmp21 := checkDerefVar(var_glojure_DOT_core_apply) + tmp22 := lang.Apply(tmp21, []any{v2, v11}) + var v23 any = tmp22 + _ = v23 + tmp24 := checkDerefVar(var_glojure_DOT_core_swap_BANG_) + tmp25 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp26 := lang.Apply(tmp24, []any{v9, tmp25, v11, v23}) + _ = tmp26 + tmp20 = v23 + } // end let + tmp18 = tmp20 + } + tmp12 = tmp18 + } // end let + return tmp12 + } + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6346), kw_column, int(5), kw_end_DASH_line, int(6351), kw_end_DASH_column, int(16)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp3 = tmp12 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_memoize = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_memoize.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ns + { + tmp0 := sym_ns.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym_docstring_QMARK_, sym_attr_DASH_map_QMARK_, sym_references_STAR_)), kw_doc, "Sets *ns* to the namespace named by name (unevaluated), creating it\n if needed. references can be zero or more of: (:refer-glojure ...)\n (:require ...) (:use ...) (:import ...) (:load ...) (:gen-class)\n with the syntax of refer-glojure/require/use/import/load/gen-class\n respectively, except the arguments are unevaluated and need not be\n quoted. (:gen-class ...), when supplied, defaults to :name\n corresponding to the ns name, :main true, :impl-ns same as ns, and\n :init-impl-ns true. All options of gen-class are\n supported. The :gen-class directive is ignored when not\n compiling. If :gen-class is not supplied, when compiled only an\n nsname__init.class will be generated. If :refer-glojure is not used, a\n default (refer 'glojure.core) is used. Use of ns is preferred to\n individual calls to in-ns/require/use/import:\n\n (ns foo.bar\n (:refer-glojure :exclude [ancestors printf])\n (:require (glojure.contrib sql combinatorics))\n (:use (my.lib this that))\n (:import (java.util Date Timer Random)\n (java.sql Connection Statement)))", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(11), kw_line, int(5742), kw_end_DASH_line, int(5742))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "process-reference" + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v8 := args[0] + _ = v8 + var tmp9 any + { // let + // let binding "vec__798" + var v10 any = v8 + _ = v10 + // let binding "seq__799" + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := lang.Apply(tmp11, []any{v10}) + var v13 any = tmp12 + _ = v13 + // let binding "first__800" + tmp14 := checkDerefVar(var_glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v13}) + var v16 any = tmp15 + _ = v16 + // let binding "seq__799" + tmp17 := checkDerefVar(var_glojure_DOT_core_next) + tmp18 := lang.Apply(tmp17, []any{v13}) + var v19 any = tmp18 + _ = v19 + // let binding "kname" + var v20 any = v16 + _ = v20 + // let binding "args" + var v21 any = v19 + _ = v21 + tmp22 := checkDerefVar(var_glojure_DOT_core_seq) + tmp23 := checkDerefVar(var_glojure_DOT_core_concat) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := checkDerefVar(var_glojure_DOT_core_symbol) + tmp26 := checkDerefVar(var_glojure_DOT_core_name) + tmp27 := lang.Apply(tmp26, []any{v20}) + tmp28 := lang.Apply(tmp25, []any{"glojure.core", tmp27}) + tmp29 := lang.Apply(tmp24, []any{tmp28}) + tmp30 := checkDerefVar(var_glojure_DOT_core_map) + var tmp31 lang.FnFunc + tmp31 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v32 := args[0] + _ = v32 + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{sym_quote, v32}) + return tmp34 + }) + tmp32 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5769), kw_column, int(21), kw_end_DASH_line, int(5769), kw_end_DASH_column, int(36)) + tmp33, err := lang.WithMeta(tmp31, tmp32.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp34 := lang.Apply(tmp30, []any{tmp33, v21}) + tmp35 := lang.Apply(tmp23, []any{tmp29, tmp34}) + tmp36 := lang.Apply(tmp22, []any{tmp35}) + tmp9 = tmp36 + } // end let + return tmp9 + }) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5767), kw_column, int(9), kw_end_DASH_line, int(5769), kw_end_DASH_column, int(44)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v10 any = tmp9 + _ = v10 + // let binding "docstring" + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp13 := checkDerefVar(var_glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v5}) + tmp15 := lang.Apply(tmp12, []any{tmp14}) + if lang.IsTruthy(tmp15) { + tmp16 := checkDerefVar(var_glojure_DOT_core_first) + tmp17 := lang.Apply(tmp16, []any{v5}) + tmp11 = tmp17 + } else { + } + var v18 any = tmp11 + _ = v18 + // let binding "references" + var tmp19 any + if lang.IsTruthy(v18) { + tmp20 := checkDerefVar(var_glojure_DOT_core_next) + tmp21 := lang.Apply(tmp20, []any{v5}) + tmp19 = tmp21 + } else { + tmp19 = v5 + } + var v22 any = tmp19 + _ = v22 + // let binding "name" + var tmp23 any + if lang.IsTruthy(v18) { + tmp24 := checkDerefVar(var_glojure_DOT_core_vary_DASH_meta) + tmp25 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp26 := lang.Apply(tmp24, []any{v4, tmp25, kw_doc, v18}) + tmp23 = tmp26 + } else { + tmp23 = v4 + } + var v27 any = tmp23 + _ = v27 + // let binding "metadata" + var tmp28 any + tmp29 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp30 := checkDerefVar(var_glojure_DOT_core_first) + tmp31 := lang.Apply(tmp30, []any{v22}) + tmp32 := lang.Apply(tmp29, []any{tmp31}) + if lang.IsTruthy(tmp32) { + tmp33 := checkDerefVar(var_glojure_DOT_core_first) + tmp34 := lang.Apply(tmp33, []any{v22}) + tmp28 = tmp34 + } else { + } + var v35 any = tmp28 + _ = v35 + // let binding "references" + var tmp36 any + if lang.IsTruthy(v35) { + tmp37 := checkDerefVar(var_glojure_DOT_core_next) + tmp38 := lang.Apply(tmp37, []any{v22}) + tmp36 = tmp38 + } else { + tmp36 = v22 + } + var v39 any = tmp36 + _ = v39 + // let binding "name" + var tmp40 any + if lang.IsTruthy(v35) { + tmp41 := checkDerefVar(var_glojure_DOT_core_vary_DASH_meta) + tmp42 := checkDerefVar(var_glojure_DOT_core_merge) + tmp43 := lang.Apply(tmp41, []any{v27, tmp42, v35}) + tmp40 = tmp43 + } else { + tmp40 = v27 + } + var v44 any = tmp40 + _ = v44 + // let binding "gen-class-clause" + tmp45 := checkDerefVar(var_glojure_DOT_core_first) + tmp46 := checkDerefVar(var_glojure_DOT_core_filter) + var tmp47 lang.FnFunc + tmp47 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v48 := args[0] + _ = v48 + tmp49 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp50 := checkDerefVar(var_glojure_DOT_core_first) + tmp51 := lang.Apply(tmp50, []any{v48}) + tmp52 := lang.Apply(tmp49, []any{kw_gen_DASH_class, tmp51}) + return tmp52 + }) + tmp48 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5780), kw_column, int(41), kw_end_DASH_line, int(5780), kw_end_DASH_column, int(65)) + tmp49, err := lang.WithMeta(tmp47, tmp48.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp50 := lang.Apply(tmp46, []any{tmp49, v39}) + tmp51 := lang.Apply(tmp45, []any{tmp50}) + var v52 any = tmp51 + _ = v52 + // let binding "gen-class-call" + var tmp53 any + if lang.IsTruthy(v52) { + tmp54 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp55 := checkDerefVar(var_glojure_DOT_core_str) + tmp56 := lang.Apply(tmp55, []any{v44}) + tmp57, _ := lang.FieldOrMethod(tmp56, "replace") + if reflect.TypeOf(tmp57).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("replace is not a function"))) + } + tmp58 := lang.Apply(tmp57, []any{lang.NewChar(45), lang.NewChar(95)}) + tmp59 := checkDerefVar(var_glojure_DOT_core_next) + tmp60 := lang.Apply(tmp59, []any{v52}) + tmp61 := lang.Apply(tmp54, []any{sym_glojure_DOT_core_SLASH_gen_DASH_class, kw_name, tmp58, kw_impl_DASH_ns, v44, kw_main, true, tmp60}) + tmp53 = tmp61 + } else { + } + var v62 any = tmp53 + _ = v62 + // let binding "references" + tmp63 := checkDerefVar(var_glojure_DOT_core_remove) + var tmp64 lang.FnFunc + tmp64 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v65 := args[0] + _ = v65 + tmp66 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp67 := checkDerefVar(var_glojure_DOT_core_first) + tmp68 := lang.Apply(tmp67, []any{v65}) + tmp69 := lang.Apply(tmp66, []any{kw_gen_DASH_class, tmp68}) + return tmp69 + }) + tmp65 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5784), kw_column, int(28), kw_end_DASH_line, int(5784), kw_end_DASH_column, int(52)) + tmp66, err := lang.WithMeta(tmp64, tmp65.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp67 := lang.Apply(tmp63, []any{tmp66, v39}) + var v68 any = tmp67 + _ = v68 + // let binding "name-metadata" + tmp69 := checkDerefVar(var_glojure_DOT_core_meta) + tmp70 := lang.Apply(tmp69, []any{v44}) + var v71 any = tmp70 + _ = v71 + tmp72 := checkDerefVar(var_glojure_DOT_core_seq) + tmp73 := checkDerefVar(var_glojure_DOT_core_concat) + tmp74 := checkDerefVar(var_glojure_DOT_core_list) + tmp75 := lang.Apply(tmp74, []any{sym_do}) + tmp76 := checkDerefVar(var_glojure_DOT_core_list) + tmp77 := checkDerefVar(var_glojure_DOT_core_seq) + tmp78 := checkDerefVar(var_glojure_DOT_core_concat) + tmp79 := checkDerefVar(var_glojure_DOT_core_list) + tmp80 := lang.Apply(tmp79, []any{sym_glojure_DOT_core_SLASH_in_DASH_ns}) + tmp81 := checkDerefVar(var_glojure_DOT_core_list) + tmp82 := checkDerefVar(var_glojure_DOT_core_seq) + tmp83 := checkDerefVar(var_glojure_DOT_core_concat) + tmp84 := checkDerefVar(var_glojure_DOT_core_list) + tmp85 := lang.Apply(tmp84, []any{sym_quote}) + tmp86 := checkDerefVar(var_glojure_DOT_core_list) + tmp87 := lang.Apply(tmp86, []any{v44}) + tmp88 := lang.Apply(tmp83, []any{tmp85, tmp87}) + tmp89 := lang.Apply(tmp82, []any{tmp88}) + tmp90 := lang.Apply(tmp81, []any{tmp89}) + tmp91 := lang.Apply(tmp78, []any{tmp80, tmp90}) + tmp92 := lang.Apply(tmp77, []any{tmp91}) + tmp93 := lang.Apply(tmp76, []any{tmp92}) + var tmp94 any + if lang.IsTruthy(v71) { + tmp95 := checkDerefVar(var_glojure_DOT_core_seq) + tmp96 := checkDerefVar(var_glojure_DOT_core_concat) + tmp97 := checkDerefVar(var_glojure_DOT_core_list) + tmp98 := checkDerefVar(var_glojure_DOT_core_seq) + tmp99 := checkDerefVar(var_glojure_DOT_core_concat) + tmp100 := checkDerefVar(var_glojure_DOT_core_list) + tmp101 := lang.Apply(tmp100, []any{sym__DOT_ResetMeta}) + tmp102 := checkDerefVar(var_glojure_DOT_core_list) + tmp103 := checkDerefVar(var_glojure_DOT_core_seq) + tmp104 := checkDerefVar(var_glojure_DOT_core_concat) + tmp105 := checkDerefVar(var_glojure_DOT_core_list) + tmp106 := lang.Apply(tmp105, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_FindNamespace}) + tmp107 := checkDerefVar(var_glojure_DOT_core_list) + tmp108 := checkDerefVar(var_glojure_DOT_core_seq) + tmp109 := checkDerefVar(var_glojure_DOT_core_concat) + tmp110 := checkDerefVar(var_glojure_DOT_core_list) + tmp111 := lang.Apply(tmp110, []any{sym_quote}) + tmp112 := checkDerefVar(var_glojure_DOT_core_list) + tmp113 := lang.Apply(tmp112, []any{v44}) + tmp114 := lang.Apply(tmp109, []any{tmp111, tmp113}) + tmp115 := lang.Apply(tmp108, []any{tmp114}) + tmp116 := lang.Apply(tmp107, []any{tmp115}) + tmp117 := lang.Apply(tmp104, []any{tmp106, tmp116}) + tmp118 := lang.Apply(tmp103, []any{tmp117}) + tmp119 := lang.Apply(tmp102, []any{tmp118}) + tmp120 := checkDerefVar(var_glojure_DOT_core_list) + tmp121 := lang.Apply(tmp120, []any{v71}) + tmp122 := lang.Apply(tmp99, []any{tmp101, tmp119, tmp121}) + tmp123 := lang.Apply(tmp98, []any{tmp122}) + tmp124 := lang.Apply(tmp97, []any{tmp123}) + tmp125 := lang.Apply(tmp96, []any{tmp124}) + tmp126 := lang.Apply(tmp95, []any{tmp125}) + tmp94 = tmp126 + } else { + } + tmp127 := checkDerefVar(var_glojure_DOT_core_list) + tmp128 := checkDerefVar(var_glojure_DOT_core_seq) + tmp129 := checkDerefVar(var_glojure_DOT_core_concat) + tmp130 := checkDerefVar(var_glojure_DOT_core_list) + tmp131 := lang.Apply(tmp130, []any{sym_glojure_DOT_core_SLASH_with_DASH_loading_DASH_context}) + var tmp132 any + if lang.IsTruthy(v62) { + tmp133 := checkDerefVar(var_glojure_DOT_core_list) + tmp134 := lang.Apply(tmp133, []any{v62}) + tmp132 = tmp134 + } else { + } + var tmp135 any + var tmp136 any + { // let + // let binding "and__0__auto__" + tmp137 := checkDerefVar(var_glojure_DOT_core_not_EQ_) + tmp138 := lang.Apply(tmp137, []any{v44, sym_glojure_DOT_core}) + var v139 any = tmp138 + _ = v139 + var tmp140 any + if lang.IsTruthy(v139) { + tmp141 := checkDerefVar(var_glojure_DOT_core_not_DASH_any_QMARK_) + var tmp142 lang.FnFunc + tmp142 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v143 := args[0] + _ = v143 + tmp144 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp145 := checkDerefVar(var_glojure_DOT_core_first) + tmp146 := lang.Apply(tmp145, []any{v143}) + tmp147 := lang.Apply(tmp144, []any{kw_refer_DASH_glojure, tmp146}) + return tmp147 + }) + tmp143 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5793), kw_column, int(58), kw_end_DASH_line, int(5793), kw_end_DASH_column, int(86)) + tmp144, err := lang.WithMeta(tmp142, tmp143.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp145 := lang.Apply(tmp141, []any{tmp144, v68}) + tmp140 = tmp145 + } else { + tmp140 = v139 + } + tmp136 = tmp140 + } // end let + if lang.IsTruthy(tmp136) { + tmp137 := checkDerefVar(var_glojure_DOT_core_seq) + tmp138 := checkDerefVar(var_glojure_DOT_core_concat) + tmp139 := checkDerefVar(var_glojure_DOT_core_list) + tmp140 := checkDerefVar(var_glojure_DOT_core_seq) + tmp141 := checkDerefVar(var_glojure_DOT_core_concat) + tmp142 := checkDerefVar(var_glojure_DOT_core_list) + tmp143 := lang.Apply(tmp142, []any{sym_glojure_DOT_core_SLASH_refer}) + tmp144 := checkDerefVar(var_glojure_DOT_core_list) + tmp145 := checkDerefVar(var_glojure_DOT_core_seq) + tmp146 := checkDerefVar(var_glojure_DOT_core_concat) + tmp147 := checkDerefVar(var_glojure_DOT_core_list) + tmp148 := lang.Apply(tmp147, []any{sym_quote}) + tmp149 := checkDerefVar(var_glojure_DOT_core_list) + tmp150 := lang.Apply(tmp149, []any{sym_glojure_DOT_core}) + tmp151 := lang.Apply(tmp146, []any{tmp148, tmp150}) + tmp152 := lang.Apply(tmp145, []any{tmp151}) + tmp153 := lang.Apply(tmp144, []any{tmp152}) + tmp154 := lang.Apply(tmp141, []any{tmp143, tmp153}) + tmp155 := lang.Apply(tmp140, []any{tmp154}) + tmp156 := lang.Apply(tmp139, []any{tmp155}) + tmp157 := lang.Apply(tmp138, []any{tmp156}) + tmp158 := lang.Apply(tmp137, []any{tmp157}) + tmp135 = tmp158 + } else { + } + tmp159 := checkDerefVar(var_glojure_DOT_core_map) + tmp160 := lang.Apply(tmp159, []any{v10, v68}) + tmp161 := lang.Apply(tmp129, []any{tmp131, tmp132, tmp135, tmp160}) + tmp162 := lang.Apply(tmp128, []any{tmp161}) + tmp163 := lang.Apply(tmp127, []any{tmp162}) + tmp164 := checkDerefVar(var_glojure_DOT_core_list) + tmp165 := checkDerefVar(var_glojure_DOT_core_seq) + tmp166 := checkDerefVar(var_glojure_DOT_core_concat) + tmp167 := checkDerefVar(var_glojure_DOT_core_list) + tmp168 := lang.Apply(tmp167, []any{sym_if}) + tmp169 := checkDerefVar(var_glojure_DOT_core_list) + tmp170 := checkDerefVar(var_glojure_DOT_core_seq) + tmp171 := checkDerefVar(var_glojure_DOT_core_concat) + tmp172 := checkDerefVar(var_glojure_DOT_core_list) + tmp173 := lang.Apply(tmp172, []any{sym__DOT_Equals}) + tmp174 := checkDerefVar(var_glojure_DOT_core_list) + tmp175 := checkDerefVar(var_glojure_DOT_core_seq) + tmp176 := checkDerefVar(var_glojure_DOT_core_concat) + tmp177 := checkDerefVar(var_glojure_DOT_core_list) + tmp178 := lang.Apply(tmp177, []any{sym_quote}) + tmp179 := checkDerefVar(var_glojure_DOT_core_list) + tmp180 := lang.Apply(tmp179, []any{v44}) + tmp181 := lang.Apply(tmp176, []any{tmp178, tmp180}) + tmp182 := lang.Apply(tmp175, []any{tmp181}) + tmp183 := lang.Apply(tmp174, []any{tmp182}) + tmp184 := checkDerefVar(var_glojure_DOT_core_list) + tmp185 := checkDerefVar(var_glojure_DOT_core_seq) + tmp186 := checkDerefVar(var_glojure_DOT_core_concat) + tmp187 := checkDerefVar(var_glojure_DOT_core_list) + tmp188 := lang.Apply(tmp187, []any{sym_quote}) + tmp189 := checkDerefVar(var_glojure_DOT_core_list) + tmp190 := lang.Apply(tmp189, []any{sym_glojure_DOT_core}) + tmp191 := lang.Apply(tmp186, []any{tmp188, tmp190}) + tmp192 := lang.Apply(tmp185, []any{tmp191}) + tmp193 := lang.Apply(tmp184, []any{tmp192}) + tmp194 := lang.Apply(tmp171, []any{tmp173, tmp183, tmp193}) + tmp195 := lang.Apply(tmp170, []any{tmp194}) + tmp196 := lang.Apply(tmp169, []any{tmp195}) + tmp197 := checkDerefVar(var_glojure_DOT_core_list) + tmp198 := lang.Apply(tmp197, []any{nil}) + tmp199 := checkDerefVar(var_glojure_DOT_core_list) + tmp200 := checkDerefVar(var_glojure_DOT_core_seq) + tmp201 := checkDerefVar(var_glojure_DOT_core_concat) + tmp202 := checkDerefVar(var_glojure_DOT_core_list) + tmp203 := lang.Apply(tmp202, []any{sym_do}) + tmp204 := checkDerefVar(var_glojure_DOT_core_list) + tmp205 := checkDerefVar(var_glojure_DOT_core_seq) + tmp206 := checkDerefVar(var_glojure_DOT_core_concat) + tmp207 := checkDerefVar(var_glojure_DOT_core_list) + tmp208 := lang.Apply(tmp207, []any{sym_glojure_DOT_core_SLASH_dosync}) + tmp209 := checkDerefVar(var_glojure_DOT_core_list) + tmp210 := checkDerefVar(var_glojure_DOT_core_seq) + tmp211 := checkDerefVar(var_glojure_DOT_core_concat) + tmp212 := checkDerefVar(var_glojure_DOT_core_list) + tmp213 := lang.Apply(tmp212, []any{sym_glojure_DOT_core_SLASH_commute}) + tmp214 := checkDerefVar(var_glojure_DOT_core_list) + tmp215 := checkDerefVar(var_glojure_DOT_core_seq) + tmp216 := checkDerefVar(var_glojure_DOT_core_concat) + tmp217 := checkDerefVar(var_glojure_DOT_core_list) + tmp218 := lang.Apply(tmp217, []any{sym_glojure_DOT_core_SLASH_deref}) + tmp219 := checkDerefVar(var_glojure_DOT_core_list) + tmp220 := checkDerefVar(var_glojure_DOT_core_seq) + tmp221 := checkDerefVar(var_glojure_DOT_core_concat) + tmp222 := checkDerefVar(var_glojure_DOT_core_list) + tmp223 := lang.Apply(tmp222, []any{sym_var}) + tmp224 := checkDerefVar(var_glojure_DOT_core_list) + tmp225 := lang.Apply(tmp224, []any{sym_glojure_DOT_core_SLASH__STAR_loaded_DASH_libs_STAR_}) + tmp226 := lang.Apply(tmp221, []any{tmp223, tmp225}) + tmp227 := lang.Apply(tmp220, []any{tmp226}) + tmp228 := lang.Apply(tmp219, []any{tmp227}) + tmp229 := lang.Apply(tmp216, []any{tmp218, tmp228}) + tmp230 := lang.Apply(tmp215, []any{tmp229}) + tmp231 := lang.Apply(tmp214, []any{tmp230}) + tmp232 := checkDerefVar(var_glojure_DOT_core_list) + tmp233 := lang.Apply(tmp232, []any{sym_glojure_DOT_core_SLASH_conj}) + tmp234 := checkDerefVar(var_glojure_DOT_core_list) + tmp235 := checkDerefVar(var_glojure_DOT_core_seq) + tmp236 := checkDerefVar(var_glojure_DOT_core_concat) + tmp237 := checkDerefVar(var_glojure_DOT_core_list) + tmp238 := lang.Apply(tmp237, []any{sym_quote}) + tmp239 := checkDerefVar(var_glojure_DOT_core_list) + tmp240 := lang.Apply(tmp239, []any{v44}) + tmp241 := lang.Apply(tmp236, []any{tmp238, tmp240}) + tmp242 := lang.Apply(tmp235, []any{tmp241}) + tmp243 := lang.Apply(tmp234, []any{tmp242}) + tmp244 := lang.Apply(tmp211, []any{tmp213, tmp231, tmp233, tmp243}) + tmp245 := lang.Apply(tmp210, []any{tmp244}) + tmp246 := lang.Apply(tmp209, []any{tmp245}) + tmp247 := lang.Apply(tmp206, []any{tmp208, tmp246}) + tmp248 := lang.Apply(tmp205, []any{tmp247}) + tmp249 := lang.Apply(tmp204, []any{tmp248}) + tmp250 := checkDerefVar(var_glojure_DOT_core_list) + tmp251 := lang.Apply(tmp250, []any{nil}) + tmp252 := lang.Apply(tmp201, []any{tmp203, tmp249, tmp251}) + tmp253 := lang.Apply(tmp200, []any{tmp252}) + tmp254 := lang.Apply(tmp199, []any{tmp253}) + tmp255 := lang.Apply(tmp166, []any{tmp168, tmp196, tmp198, tmp254}) + tmp256 := lang.Apply(tmp165, []any{tmp255}) + tmp257 := lang.Apply(tmp164, []any{tmp256}) + tmp258 := lang.Apply(tmp73, []any{tmp75, tmp93, tmp94, tmp163, tmp257}) + tmp259 := lang.Apply(tmp72, []any{tmp258}) + tmp6 = tmp259 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ns = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ns.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ns-imports + { + tmp0 := sym_ns_DASH_imports.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns)), kw_doc, "Returns a map of the import mappings for the namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4199), kw_end_DASH_line, int(4199))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_filter_DASH_key) + tmp4 := checkDerefVar(var_glojure_DOT_core_val) + tmp5 := checkDerefVar(var_glojure_DOT_core_partial) + tmp6 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp7 := reflect.TypeOf((*reflect.Type)(nil)).Elem() + tmp8 := lang.Apply(tmp5, []any{tmp6, tmp7}) + tmp9 := checkDerefVar(var_glojure_DOT_core_ns_DASH_map) + tmp10 := lang.Apply(tmp9, []any{v2}) + tmp11 := lang.Apply(tmp3, []any{tmp4, tmp8, tmp10}) + return tmp11 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ns_DASH_imports = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ns_DASH_imports.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // partition + { + tmp0 := sym_partition.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n, sym_coll), lang.NewVector(sym_n, sym_step, sym_coll), lang.NewVector(sym_n, sym_step, sym_pad, sym_coll)), kw_doc, "Returns a lazy sequence of lists of n items each, at offsets step\n apart. If step is not supplied, defaults to n, i.e. the partitions\n do not overlap. If a pad collection is supplied, use its elements as\n necessary to complete last partition upto n items. In case there are\n not enough padding elements, return a partition with less than n items.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(3177), kw_end_DASH_line, int(3177))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_partition) + tmp5 := lang.Apply(tmp4, []any{v2, v2, v3}) + return tmp5 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp6 any + { // let + // let binding "temp__0__auto__" + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := lang.Apply(tmp7, []any{v4}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + var tmp11 any + { // let + // let binding "s" + var v12 any = v9 + _ = v12 + var tmp13 any + { // let + // let binding "p" + tmp14 := checkDerefVar(var_glojure_DOT_core_doall) + tmp15 := checkDerefVar(var_glojure_DOT_core_take) + tmp16 := lang.Apply(tmp15, []any{v2, v12}) + tmp17 := lang.Apply(tmp14, []any{tmp16}) + var v18 any = tmp17 + _ = v18 + var tmp19 any + tmp20 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp21 := checkDerefVar(var_glojure_DOT_core_count) + tmp22 := lang.Apply(tmp21, []any{v18}) + tmp23 := lang.Apply(tmp20, []any{v2, tmp22}) + if lang.IsTruthy(tmp23) { + tmp24 := checkDerefVar(var_glojure_DOT_core_cons) + tmp25 := checkDerefVar(var_glojure_DOT_core_partition) + tmp26 := checkDerefVar(var_glojure_DOT_core_nthrest) + tmp27 := lang.Apply(tmp26, []any{v12, v3}) + tmp28 := lang.Apply(tmp25, []any{v2, v3, tmp27}) + tmp29 := lang.Apply(tmp24, []any{v18, tmp28}) + tmp19 = tmp29 + } else { + } + tmp13 = tmp19 + } // end let + tmp11 = tmp13 + } // end let + tmp10 = tmp11 + } else { + } + tmp6 = tmp10 + } // end let + return tmp6 + }) + tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) + return tmp6 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp7 any + { // let + // let binding "temp__0__auto__" + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := lang.Apply(tmp8, []any{v5}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + if lang.IsTruthy(v10) { + var tmp12 any + { // let + // let binding "s" + var v13 any = v10 + _ = v13 + var tmp14 any + { // let + // let binding "p" + tmp15 := checkDerefVar(var_glojure_DOT_core_doall) + tmp16 := checkDerefVar(var_glojure_DOT_core_take) + tmp17 := lang.Apply(tmp16, []any{v2, v13}) + tmp18 := lang.Apply(tmp15, []any{tmp17}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + tmp21 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp22 := checkDerefVar(var_glojure_DOT_core_count) + tmp23 := lang.Apply(tmp22, []any{v19}) + tmp24 := lang.Apply(tmp21, []any{v2, tmp23}) + if lang.IsTruthy(tmp24) { + tmp25 := checkDerefVar(var_glojure_DOT_core_cons) + tmp26 := checkDerefVar(var_glojure_DOT_core_partition) + tmp27 := checkDerefVar(var_glojure_DOT_core_nthrest) + tmp28 := lang.Apply(tmp27, []any{v13, v3}) + tmp29 := lang.Apply(tmp26, []any{v2, v3, v4, tmp28}) + tmp30 := lang.Apply(tmp25, []any{v19, tmp29}) + tmp20 = tmp30 + } else { + tmp31 := checkDerefVar(var_glojure_DOT_core_list) + tmp32 := checkDerefVar(var_glojure_DOT_core_take) + tmp33 := checkDerefVar(var_glojure_DOT_core_concat) + tmp34 := lang.Apply(tmp33, []any{v19, v4}) + tmp35 := lang.Apply(tmp32, []any{v2, tmp34}) + tmp36 := lang.Apply(tmp31, []any{tmp35}) + tmp20 = tmp36 + } + tmp14 = tmp20 + } // end let + tmp12 = tmp14 + } // end let + tmp11 = tmp12 + } else { + } + tmp7 = tmp11 + } // end let + return tmp7 + }) + tmp7 := lang.Apply(lang.NewLazySeq, []any{tmp6}) + return tmp7 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_partition = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_partition.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // partition-all + { + tmp0 := sym_partition_DASH_all.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n), lang.NewVector(sym_n, sym_coll), lang.NewVector(sym_n, sym_step, sym_coll)), kw_doc, "Returns a lazy sequence of lists like partition, but may include\n partitions with fewer than n items at the end. Returns a stateful\n transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(7222), kw_end_DASH_line, int(7222))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 any + { // let + // let binding "a" + tmp6 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) + tmp7 := lang.Apply(tmp6, []any{v2}) + tmp8 := lang.Apply(lang.NewArrayList, []any{tmp7}) + var v9 any = tmp8 + _ = v9 + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp11 := lang.Apply(v4, nil) + return tmp11 + case 1: + v11 := args[0] + _ = v11 + var tmp12 any + { // let + // let binding "result" + var tmp13 any + tmp14, ok := lang.FieldOrMethod(v9, "isEmpty") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v9, "isEmpty"))) + } + var tmp15 any + switch reflect.TypeOf(tmp14).Kind() { + case reflect.Func: + tmp15 = lang.Apply(tmp14, nil) + default: + tmp15 = tmp14 + } + if lang.IsTruthy(tmp15) { + tmp13 = v11 + } else { + var tmp16 any + { // let + // let binding "v" + tmp17 := checkDerefVar(var_glojure_DOT_core_vec) + tmp18, ok := lang.FieldOrMethod(v9, "toArray") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v9, "toArray"))) + } + var tmp19 any + switch reflect.TypeOf(tmp18).Kind() { + case reflect.Func: + tmp19 = lang.Apply(tmp18, nil) + default: + tmp19 = tmp18 + } + tmp20 := lang.Apply(tmp17, []any{tmp19}) + var v21 any = tmp20 + _ = v21 + tmp22, ok := lang.FieldOrMethod(v9, "clear") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v9, "clear"))) + } + var tmp23 any + switch reflect.TypeOf(tmp22).Kind() { + case reflect.Func: + tmp23 = lang.Apply(tmp22, nil) + default: + tmp23 = tmp22 + } + _ = tmp23 + tmp24 := checkDerefVar(var_glojure_DOT_core_unreduced) + tmp25 := lang.Apply(v4, []any{v11, v21}) + tmp26 := lang.Apply(tmp24, []any{tmp25}) + tmp16 = tmp26 + } // end let + tmp13 = tmp16 + } + var v17 any = tmp13 + _ = v17 + tmp18 := lang.Apply(v4, []any{v17}) + tmp12 = tmp18 + } // end let + return tmp12 + case 2: + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13, _ := lang.FieldOrMethod(v9, "add") + if reflect.TypeOf(tmp13).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) + } + tmp14 := lang.Apply(tmp13, []any{v12}) + _ = tmp14 + var tmp15 any + tmp16 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp17, ok := lang.FieldOrMethod(v9, "size") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v9, "size"))) + } + var tmp18 any + switch reflect.TypeOf(tmp17).Kind() { + case reflect.Func: + tmp18 = lang.Apply(tmp17, nil) + default: + tmp18 = tmp17 + } + tmp19 := lang.Apply(tmp16, []any{v2, tmp18}) + if lang.IsTruthy(tmp19) { + var tmp20 any + { // let + // let binding "v" + tmp21 := checkDerefVar(var_glojure_DOT_core_vec) + tmp22, ok := lang.FieldOrMethod(v9, "toArray") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v9, "toArray"))) + } + var tmp23 any + switch reflect.TypeOf(tmp22).Kind() { + case reflect.Func: + tmp23 = lang.Apply(tmp22, nil) + default: + tmp23 = tmp22 + } + tmp24 := lang.Apply(tmp21, []any{tmp23}) + var v25 any = tmp24 + _ = v25 + tmp26, ok := lang.FieldOrMethod(v9, "clear") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v9, "clear"))) + } + var tmp27 any + switch reflect.TypeOf(tmp26).Kind() { + case reflect.Func: + tmp27 = lang.Apply(tmp26, nil) + default: + tmp27 = tmp26 + } + _ = tmp27 + tmp28 := lang.Apply(v4, []any{v11, v25}) + tmp20 = tmp28 + } // end let + tmp15 = tmp20 + } else { + tmp15 = v11 + } + return tmp15 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7231), kw_column, int(8), kw_end_DASH_line, int(7247), kw_end_DASH_column, int(23)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp5 = tmp12 + } // end let + return tmp5 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7229), kw_column, int(4), kw_end_DASH_line, int(7247), kw_end_DASH_column, int(25)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_partition_DASH_all) + tmp5 := lang.Apply(tmp4, []any{v2, v2, v3}) + return tmp5 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp6 any + { // let + // let binding "temp__0__auto__" + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := lang.Apply(tmp7, []any{v4}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + var tmp11 any + { // let + // let binding "s" + var v12 any = v9 + _ = v12 + var tmp13 any + { // let + // let binding "seg" + tmp14 := checkDerefVar(var_glojure_DOT_core_doall) + tmp15 := checkDerefVar(var_glojure_DOT_core_take) + tmp16 := lang.Apply(tmp15, []any{v2, v12}) + tmp17 := lang.Apply(tmp14, []any{tmp16}) + var v18 any = tmp17 + _ = v18 + tmp19 := checkDerefVar(var_glojure_DOT_core_cons) + tmp20 := checkDerefVar(var_glojure_DOT_core_partition_DASH_all) + tmp21 := checkDerefVar(var_glojure_DOT_core_nthrest) + tmp22 := lang.Apply(tmp21, []any{v12, v3}) + tmp23 := lang.Apply(tmp20, []any{v2, v3, tmp22}) + tmp24 := lang.Apply(tmp19, []any{v18, tmp23}) + tmp13 = tmp24 + } // end let + tmp11 = tmp13 + } // end let + tmp10 = tmp11 + } else { + } + tmp6 = tmp10 + } // end let + return tmp6 + }) + tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_partition_DASH_all = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_partition_DASH_all.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // pcalls + { + tmp0 := sym_pcalls.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_fns)), kw_doc, "Executes the no-arg fns in parallel, returning a lazy sequence of\n their values", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(7056), kw_end_DASH_line, int(7056))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_pmap) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v5 := args[0] + _ = v5 + tmp6 := lang.Apply(v5, nil) + return tmp6 + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7061), kw_column, int(17), kw_end_DASH_line, int(7061), kw_end_DASH_column, int(20)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp7 := lang.Apply(tmp3, []any{tmp6, v2}) + return tmp7 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_pcalls = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_pcalls.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // prep-ints + { + tmp0 := sym_prep_DASH_ints.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_tests, sym_thens)), kw_doc, "Takes a sequence of int-sized test constants and a corresponding sequence of\n then expressions. Returns a tuple of [shift mask case-map switch-type] where\n case-map is a map of int case values to [test then] tuples, and switch-type\n is either :sparse or :compact.", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(8), kw_line, int(6631), kw_end_DASH_line, int(6631), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_fits_DASH_table_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v2}) + if lang.IsTruthy(tmp6) { + tmp7 := checkDerefVar(var_glojure_DOT_core_case_DASH_map) + tmp8 := checkDerefVar(var_glojure_DOT_core_int) + tmp9 := checkDerefVar(var_glojure_DOT_core_int) + tmp10 := lang.Apply(tmp7, []any{tmp8, tmp9, v2, v3}) + tmp11 := lang.NewVector(int64(0), int64(0), tmp10, kw_compact) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6639), kw_column, int(5), kw_end_DASH_line, int(6639), kw_end_DASH_column, int(49)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp4 = tmp13 + } else { + var tmp14 any + { // let + // let binding "vec__851" + var tmp15 any + { // let + // let binding "or__0__auto__" + tmp16 := checkDerefVar(var_glojure_DOT_core_maybe_DASH_min_DASH_hash) + tmp17 := checkDerefVar(var_glojure_DOT_core_map) + tmp18 := checkDerefVar(var_glojure_DOT_core_int) + tmp19 := lang.Apply(tmp17, []any{tmp18, v2}) + tmp20 := lang.Apply(tmp16, []any{tmp19}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + if lang.IsTruthy(v21) { + tmp22 = v21 + } else { + tmp23 := lang.NewVector(int64(0), int64(0)) + tmp24 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6640), kw_column, int(61), kw_end_DASH_line, int(6640), kw_end_DASH_column, int(65)) + tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp22 = tmp25 + } + tmp15 = tmp22 + } // end let + var v16 any = tmp15 + _ = v16 + // let binding "shift" + tmp17 := checkDerefVar(var_glojure_DOT_core_nth) + tmp18 := lang.Apply(tmp17, []any{v16, int64(0), nil}) + var v19 any = tmp18 + _ = v19 + // let binding "mask" + tmp20 := checkDerefVar(var_glojure_DOT_core_nth) + tmp21 := lang.Apply(tmp20, []any{v16, int64(1), nil}) + var v22 any = tmp21 + _ = v22 + var tmp23 any + tmp24 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) + tmp25 := lang.Apply(tmp24, []any{v22}) + if lang.IsTruthy(tmp25) { + tmp26 := checkDerefVar(var_glojure_DOT_core_case_DASH_map) + tmp27 := checkDerefVar(var_glojure_DOT_core_int) + tmp28 := checkDerefVar(var_glojure_DOT_core_int) + tmp29 := lang.Apply(tmp26, []any{tmp27, tmp28, v2, v3}) + tmp30 := lang.NewVector(int64(0), int64(0), tmp29, kw_sparse) + tmp31 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6643), kw_column, int(9), kw_end_DASH_line, int(6643), kw_end_DASH_column, int(52)) + tmp32, err := lang.WithMeta(tmp30, tmp31.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp23 = tmp32 + } else { + tmp33 := checkDerefVar(var_glojure_DOT_core_case_DASH_map) + var tmp34 lang.FnFunc + tmp34 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v35 := args[0] + _ = v35 + tmp36 := checkDerefVar(var_glojure_DOT_core_shift_DASH_mask) + tmp37 := checkDerefVar(var_glojure_DOT_core_int) + tmp38 := lang.Apply(tmp37, []any{v35}) + tmp39 := lang.Apply(tmp36, []any{v19, v22, tmp38}) + return tmp39 + }) + tmp35 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6645), kw_column, int(31), kw_end_DASH_line, int(6645), kw_end_DASH_column, int(62)) + tmp36, err := lang.WithMeta(tmp34, tmp35.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp37 := checkDerefVar(var_glojure_DOT_core_int) + tmp38 := lang.Apply(tmp33, []any{tmp36, tmp37, v2, v3}) + tmp39 := lang.NewVector(v19, v22, tmp38, kw_compact) + tmp40 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6645), kw_column, int(9), kw_end_DASH_line, int(6645), kw_end_DASH_column, int(89)) + tmp41, err := lang.WithMeta(tmp39, tmp40.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp23 = tmp41 + } + tmp14 = tmp23 + } // end let + tmp4 = tmp14 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_prep_DASH_ints = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_prep_DASH_ints.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print-prefix-map + { + tmp0 := sym_print_DASH_prefix_DASH_map.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(243), kw_column, int(8), kw_end_DASH_line, int(243), kw_end_DASH_column, int(23), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_prefix, sym_kvs, sym_print_DASH_one, sym_w)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_print_DASH_sequential) + tmp7 := checkDerefVar(var_glojure_DOT_core_str) + tmp8 := lang.Apply(tmp7, []any{v2, "{"}) + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + var tmp12 any + { // let + // let binding "vec__903" + var v13 any = v10 + _ = v13 + // let binding "k" + tmp14 := checkDerefVar(var_glojure_DOT_core_nth) + tmp15 := lang.Apply(tmp14, []any{v13, int64(0), nil}) + var v16 any = tmp15 + _ = v16 + // let binding "v" + tmp17 := checkDerefVar(var_glojure_DOT_core_nth) + tmp18 := lang.Apply(tmp17, []any{v13, int64(1), nil}) + var v19 any = tmp18 + _ = v19 + tmp20 := lang.Apply(v4, []any{v16, v11}) + _ = tmp20 + tmp21 := lang.Apply(lang.AppendWriter, []any{v11, lang.NewChar(32)}) + _ = tmp21 + tmp22 := lang.Apply(v4, []any{v19, v11}) + tmp12 = tmp22 + } // end let + return tmp12 + }) + tmp10 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(246), kw_column, int(5), kw_end_DASH_line, int(247), kw_end_DASH_column, int(107)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp12 := lang.Apply(tmp6, []any{tmp8, tmp11, ", ", "}", v3, v5}) + return tmp12 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_print_DASH_prefix_DASH_map = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_print_DASH_prefix_DASH_map.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // promise + { + tmp0 := sym_promise.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Returns a promise object that can be read with deref/@, and set,\n once only, with deliver. Calls to deref/@ prior to delivery will\n block, unless the variant of deref with timeout is used. All\n subsequent derefs will return the same delivered value without\n blocking. See also - realized?.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(7078), kw_end_DASH_line, int(7078))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp2 any + { // let + // let binding "d" + tmp3 := lang.Apply(nil, []any{int64(1)}) + var v4 any = tmp3 + _ = v4 + // let binding "v" + tmp5 := checkDerefVar(var_glojure_DOT_core_atom) + tmp6 := lang.Apply(tmp5, []any{v4}) + var v7 any = tmp6 + _ = v7 + tmp8 := reflect.TypeOf((*lang.IDeref)(nil)).Elem() + tmp9 := checkDerefVar(var_glojure_DOT_core_deref) + tmp10 := lang.NewVector(nil) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7091), kw_column, int(15), kw_end_DASH_line, int(7091), kw_end_DASH_column, int(17)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13, ok := lang.FieldOrMethod(v4, "await") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "await"))) + } + var tmp14 any + switch reflect.TypeOf(tmp13).Kind() { + case reflect.Func: + tmp14 = lang.Apply(tmp13, nil) + default: + tmp14 = tmp13 + } + tmp15 := checkDerefVar(var_glojure_DOT_core_deref) + tmp16 := lang.Apply(tmp15, []any{v7}) + tmp17 := lang.Apply(tmp9, []any{tmp12, tmp14, tmp16}) + tmp18 := reflect.TypeOf((*lang.IBlockingDeref)(nil)).Elem() + tmp19 := checkDerefVar(var_glojure_DOT_core_deref) + tmp20 := lang.NewVector(nil, nil, nil) + tmp21 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7094), kw_column, int(9), kw_end_DASH_line, int(7094), kw_end_DASH_column, int(34)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var tmp23 any + tmp24, _ := lang.FieldOrMethod(v4, "await") + if reflect.TypeOf(tmp24).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) + } + tmp25 := lang.Apply(tmp24, []any{nil, time7.Millisecond}) + if lang.IsTruthy(tmp25) { + tmp26 := checkDerefVar(var_glojure_DOT_core_deref) + tmp27 := lang.Apply(tmp26, []any{v7}) + tmp23 = tmp27 + } else { + } + tmp28 := lang.Apply(tmp19, []any{tmp22, tmp23}) + tmp29 := reflect.TypeOf((*lang.IPending)(nil)).Elem() + tmp30 := lang.NewVector(nil) + tmp31 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7099), kw_column, int(19), kw_end_DASH_line, int(7099), kw_end_DASH_column, int(24)) + tmp32, err := lang.WithMeta(tmp30, tmp31.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp33 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) + tmp34, ok := lang.FieldOrMethod(v4, "getCount") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "getCount"))) + } + var tmp35 any + switch reflect.TypeOf(tmp34).Kind() { + case reflect.Func: + tmp35 = lang.Apply(tmp34, nil) + default: + tmp35 = tmp34 + } + tmp36 := lang.Apply(tmp33, []any{tmp35}) + tmp37 := lang.Apply(nil, []any{tmp32, tmp36}) + tmp38 := lang.NewVector(nil, nil) + tmp39 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7103), kw_column, int(7), kw_end_DASH_line, int(7103), kw_end_DASH_column, int(14)) + tmp40, err := lang.WithMeta(tmp38, tmp39.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var tmp41 any + var tmp42 any + { // let + // let binding "and__0__auto__" + tmp43 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp44, ok := lang.FieldOrMethod(v4, "getCount") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "getCount"))) + } + var tmp45 any + switch reflect.TypeOf(tmp44).Kind() { + case reflect.Func: + tmp45 = lang.Apply(tmp44, nil) + default: + tmp45 = tmp44 + } + tmp46 := lang.Apply(tmp43, []any{tmp45}) + var v47 any = tmp46 + _ = v47 + var tmp48 any + if lang.IsTruthy(v47) { + tmp49 := checkDerefVar(var_glojure_DOT_core_compare_DASH_and_DASH_set_BANG_) + tmp50 := lang.Apply(tmp49, []any{v7, v4, nil}) + tmp48 = tmp50 + } else { + tmp48 = v47 + } + tmp42 = tmp48 + } // end let + if lang.IsTruthy(tmp42) { + tmp43, ok := lang.FieldOrMethod(v4, "countDown") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "countDown"))) + } + var tmp44 any + switch reflect.TypeOf(tmp43).Kind() { + case reflect.Func: + tmp44 = lang.Apply(tmp43, nil) + default: + tmp44 = tmp43 + } + _ = tmp44 + } else { + } + tmp45 := lang.Apply(nil, []any{tmp40, tmp41}) + tmp46 := lang.Apply(nil, []any{tmp8, tmp17, tmp18, tmp28, tmp29, tmp37, nil, tmp45}) + tmp2 = tmp46 + } // end let + return tmp2 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_promise = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_promise.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // re-find + { + tmp0 := sym_re_DASH_find.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m), lang.NewVector(sym_re, sym_s)), kw_doc, "Returns the next regex match, if any, of string to pattern, using\n java.util.regex.Matcher.find(). Uses re-groups to return the\n groups.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4922), kw_end_DASH_line, int(4922))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + tmp4, _ := lang.FieldOrMethod(v2, "find") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("find is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{}) + if lang.IsTruthy(tmp5) { + tmp6 := checkDerefVar(var_glojure_DOT_core_re_DASH_groups) + tmp7 := lang.Apply(tmp6, []any{v2}) + tmp3 = tmp7 + } else { + } + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "m" + tmp5 := checkDerefVar(var_glojure_DOT_core_re_DASH_matcher) + tmp6 := lang.Apply(tmp5, []any{v2, v3}) + var v7 any = tmp6 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_re_DASH_find) + tmp9 := lang.Apply(tmp8, []any{v7}) + tmp4 = tmp9 + } // end let + return tmp4 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_re_DASH_find = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_re_DASH_find.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ref + { + tmp0 := sym_ref.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym__AMP_, sym_options)), kw_doc, "Creates and returns a Ref with an initial value of x and zero or\n more options (in any order):\n\n :meta metadata-map\n\n :validator validate-fn\n\n :min-history (default 0)\n :max-history (default 10)\n\n If metadata-map is supplied, it will become the metadata on the\n ref. validate-fn must be nil or a side-effect-free fn of one\n argument, which will be passed the intended new state on any state\n change. If the new state is unacceptable, the validate-fn should\n return false or throw an exception. validate-fn will be called on\n transaction commit, when all refs have their final values.\n\n Normally refs accumulate history dynamically as needed to deal with\n read demands. If you know in advance you will need history you can\n set :min-history to ensure it will be available when first needed (instead\n of after a read fault). History is limited, and the limit can be set\n with :max-history.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(2260), kw_end_DASH_line, int(2260))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(lang.NewRef, []any{v2}) + return tmp3 + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + var tmp4 any + { // let + // let binding "r" + tmp5 := checkDerefVar(var_glojure_DOT_core_setup_DASH_reference) + tmp6 := checkDerefVar(var_glojure_DOT_core_ref) + tmp7 := lang.Apply(tmp6, []any{v2}) + tmp8 := lang.Apply(tmp5, []any{tmp7, v3}) + var v9 any = tmp8 + _ = v9 + // let binding "opts" + tmp10 := checkDerefVar(var_glojure_DOT_core_apply) + tmp11 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp12 := lang.Apply(tmp10, []any{tmp11, v3}) + var v13 any = tmp12 + _ = v13 + var tmp14 any + tmp15 := lang.Apply(kw_max_DASH_history, []any{v13}) + if lang.IsTruthy(tmp15) { + tmp16 := lang.Apply(kw_max_DASH_history, []any{v13}) + tmp17, _ := lang.FieldOrMethod(v9, "setMaxHistory") + if reflect.TypeOf(tmp17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMaxHistory is not a function"))) + } + tmp18 := lang.Apply(tmp17, []any{tmp16}) + tmp14 = tmp18 + } else { + } + _ = tmp14 + var tmp19 any + tmp20 := lang.Apply(kw_min_DASH_history, []any{v13}) + if lang.IsTruthy(tmp20) { + tmp21 := lang.Apply(kw_min_DASH_history, []any{v13}) + tmp22, _ := lang.FieldOrMethod(v9, "setMinHistory") + if reflect.TypeOf(tmp22).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMinHistory is not a function"))) + } + tmp23 := lang.Apply(tmp22, []any{tmp21}) + tmp19 = tmp23 + } else { + } + _ = tmp19 + tmp4 = v9 + } // end let + return tmp4 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ref = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ref.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // repeatedly + { + tmp0 := sym_repeatedly.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_n, sym_f)), kw_doc, "Takes a function of no args, presumably with side effects, and\n returns an infinite (or length n if supplied) lazy sequence of calls\n to it", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(5167), kw_end_DASH_line, int(5167))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp4 := checkDerefVar(var_glojure_DOT_core_cons) + tmp5 := lang.Apply(v2, nil) + tmp6 := checkDerefVar(var_glojure_DOT_core_repeatedly) + tmp7 := lang.Apply(tmp6, []any{v2}) + tmp8 := lang.Apply(tmp4, []any{tmp5, tmp7}) + return tmp8 + }) + tmp4 := lang.Apply(lang.NewLazySeq, []any{tmp3}) + return tmp4 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_take) + tmp5 := checkDerefVar(var_glojure_DOT_core_repeatedly) + tmp6 := lang.Apply(tmp5, []any{v3}) + tmp7 := lang.Apply(tmp4, []any{v2, tmp6}) + return tmp7 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_repeatedly = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_repeatedly.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // replicate + { + tmp0 := sym_replicate.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n, sym_x)), kw_doc, "DEPRECATED: Use 'repeat' instead.\n Returns a lazy seq of n xs.", kw_file, "glojure/core.glj", kw_deprecated, "1.3", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(3004), kw_end_DASH_line, int(3004))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_take) + tmp5 := checkDerefVar(var_glojure_DOT_core_repeat) + tmp6 := lang.Apply(tmp5, []any{v3}) + tmp7 := lang.Apply(tmp4, []any{v2, tmp6}) + return tmp7 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_replicate = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_replicate.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // resultset-seq + { + tmp0 := sym_resultset_DASH_seq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_rs)), kw_doc, "Creates and returns a lazy sequence of structmaps corresponding to\n the rows in the java.sql.ResultSet rs", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(5681), kw_end_DASH_line, int(5681))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "rsmeta" + tmp4, _ := lang.FieldOrMethod(v2, "getMetaData") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getMetaData is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{}) + var v6 any = tmp5 + _ = v6 + // let binding "idxs" + tmp7 := checkDerefVar(var_glojure_DOT_core_range) + tmp8 := checkDerefVar(var_glojure_DOT_core_inc) + tmp9, _ := lang.FieldOrMethod(v6, "getColumnCount") + if reflect.TypeOf(tmp9).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getColumnCount is not a function"))) + } + tmp10 := lang.Apply(tmp9, []any{}) + tmp11 := lang.Apply(tmp8, []any{tmp10}) + tmp12 := lang.Apply(tmp7, []any{int64(1), tmp11}) + var v13 any = tmp12 + _ = v13 + // let binding "keys" + tmp14 := checkDerefVar(var_glojure_DOT_core_map) + tmp15 := checkDerefVar(var_glojure_DOT_core_comp) + tmp16 := checkDerefVar(var_glojure_DOT_core_keyword) + var tmp17 lang.FnFunc + tmp17 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v18 := args[0] + _ = v18 + tmp19, ok := lang.FieldOrMethod(v18, "toLowerCase") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v18, "toLowerCase"))) + } + var tmp20 any + switch reflect.TypeOf(tmp19).Kind() { + case reflect.Func: + tmp20 = lang.Apply(tmp19, nil) + default: + tmp20 = tmp19 + } + return tmp20 + }) + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5688), kw_column, int(35), kw_end_DASH_line, int(5688), kw_end_DASH_column, int(62)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp20 := lang.Apply(tmp15, []any{tmp16, tmp19}) + tmp21 := checkDerefVar(var_glojure_DOT_core_map) + var tmp22 lang.FnFunc + tmp22 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v23 := args[0] + _ = v23 + tmp24, _ := lang.FieldOrMethod(v6, "getColumnLabel") + if reflect.TypeOf(tmp24).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getColumnLabel is not a function"))) + } + tmp25 := lang.Apply(tmp24, []any{v23}) + return tmp25 + }) + tmp23 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5689), kw_column, int(26), kw_end_DASH_line, int(5689), kw_end_DASH_column, int(63)) + tmp24, err := lang.WithMeta(tmp22, tmp23.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp25 := lang.Apply(tmp21, []any{tmp24, v13}) + tmp26 := lang.Apply(tmp14, []any{tmp20, tmp25}) + var v27 any = tmp26 + _ = v27 + // let binding "check-keys" + var tmp28 any + { // let + // let binding "or__0__auto__" + tmp29 := checkDerefVar(var_glojure_DOT_core_apply) + tmp30 := checkDerefVar(var_glojure_DOT_core_distinct_QMARK_) + tmp31 := lang.Apply(tmp29, []any{tmp30, v27}) + var v32 any = tmp31 + _ = v32 + var tmp33 any + if lang.IsTruthy(v32) { + tmp33 = v32 + } else { + tmp34 := lang.Apply(lang.NewError, []any{"ResultSet must have unique column labels"}) + panic(tmp34) + } + tmp28 = tmp33 + } // end let + var v29 any = tmp28 + _ = v29 + // let binding "row-struct" + tmp30 := checkDerefVar(var_glojure_DOT_core_apply) + tmp31 := checkDerefVar(var_glojure_DOT_core_create_DASH_struct) + tmp32 := lang.Apply(tmp30, []any{tmp31, v27}) + var v33 any = tmp32 + _ = v33 + // let binding "row-values" + var tmp34 lang.FnFunc + tmp34 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp35 := checkDerefVar(var_glojure_DOT_core_map) + var tmp36 lang.FnFunc + tmp36 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v37 := args[0] + _ = v37 + tmp38, _ := lang.FieldOrMethod(v2, "getObject") + if reflect.TypeOf(tmp38).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getObject is not a function"))) + } + tmp39 := lang.Apply(tmp38, []any{v37}) + return tmp39 + }) + tmp37 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5694), kw_column, int(34), kw_end_DASH_line, int(5694), kw_end_DASH_column, int(71)) + tmp38, err := lang.WithMeta(tmp36, tmp37.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp39 := lang.Apply(tmp35, []any{tmp38, v13}) + return tmp39 + }) + tmp35 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5694), kw_column, int(22), kw_end_DASH_line, int(5694), kw_end_DASH_column, int(78)) + tmp36, err := lang.WithMeta(tmp34, tmp35.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v37 any = tmp36 + _ = v37 + // let binding "rows" + var tmp38 lang.FnFunc + { // function thisfn + var v39 lang.FnFunc + tmp38 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp40 any + tmp41, _ := lang.FieldOrMethod(v2, "next") + if reflect.TypeOf(tmp41).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("next is not a function"))) + } + tmp42 := lang.Apply(tmp41, []any{}) + if lang.IsTruthy(tmp42) { + tmp43 := checkDerefVar(var_glojure_DOT_core_cons) + tmp44 := checkDerefVar(var_glojure_DOT_core_apply) + tmp45 := checkDerefVar(var_glojure_DOT_core_struct) + tmp46 := lang.Apply(v37, nil) + tmp47 := lang.Apply(tmp44, []any{tmp45, v33, tmp46}) + var tmp48 lang.FnFunc + tmp48 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp49 := lang.Apply(v39, nil) + return tmp49 + }) + tmp49 := lang.Apply(lang.NewLazySeq, []any{tmp48}) + tmp50 := lang.Apply(tmp43, []any{tmp47, tmp49}) + tmp40 = tmp50 + } else { + } + return tmp40 + }) + v39 = tmp38 + _ = v39 + } + tmp39 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5695), kw_column, int(16), kw_end_DASH_line, int(5697), kw_end_DASH_column, int(86)) + tmp40, err := lang.WithMeta(tmp38, tmp39.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v41 any = tmp40 + _ = v41 + tmp42 := lang.Apply(v41, nil) + tmp3 = tmp42 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_resultset_DASH_seq = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_resultset_DASH_seq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // send + { + tmp0 := sym_send.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a, sym_f, sym__AMP_, sym_args)), kw_doc, "Dispatch an action to an agent. Returns the agent immediately.\n Subsequently, in a thread from a thread pool, the state of the agent\n will be set to the value of:\n\n (apply action-fn state-of-agent args)", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(2109), kw_end_DASH_line, int(2109))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_apply) + tmp6 := checkDerefVar(var_glojure_DOT_core_send_DASH_via) + tmp7 := lang.Apply(tmp5, []any{tmp6, nil, v2, v3, v4}) + return tmp7 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_send = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_send.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // send-off + { + tmp0 := sym_send_DASH_off.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a, sym_f, sym__AMP_, sym_args)), kw_doc, "Dispatch a potentially blocking action to an agent. Returns the\n agent immediately. Subsequently, in a separate thread, the state of\n the agent will be set to the value of:\n\n (apply action-fn state-of-agent args)", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(2120), kw_end_DASH_line, int(2120))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_apply) + tmp6 := checkDerefVar(var_glojure_DOT_core_send_DASH_via) + tmp7 := lang.Apply(tmp5, []any{tmp6, nil, v2, v3, v4}) + return tmp7 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_send_DASH_off = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_send_DASH_off.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // seque + { + tmp0 := sym_seque.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s), lang.NewVector(sym_n_DASH_or_DASH_q, sym_s)), kw_doc, "Creates a queued seq on another (presumably lazy) seq s. The queued\n seq will produce a concrete seq in the background, and can get up to\n n items ahead of the consumer. n-or-q can be an integer n buffer\n size, or an instance of java.util.concurrent BlockingQueue. Note\n that reading from a seque can block if the reader gets ahead of the\n producer.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(5419), kw_end_DASH_line, int(5419))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_seque) + tmp4 := lang.Apply(tmp3, []any{int64(100), v2}) + return tmp4 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "q" + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp7 := lang.Apply(tmp6, []any{nil, v2}) + if lang.IsTruthy(tmp7) { + tmp5 = v2 + } else { + tmp8 := checkDerefVar(var_glojure_DOT_core_int) + tmp9 := lang.Apply(tmp8, []any{v2}) + tmp10 := lang.Apply(nil, []any{tmp9}) + tmp5 = tmp10 + } + var v11 any = tmp5 + _ = v11 + // let binding "NIL" + tmp12 := lang.Apply(reflect.StructOf, []any{nil}) + tmp13 := lang.Apply(reflect.New, []any{tmp12}) + tmp14, ok := lang.FieldOrMethod(tmp13, "Interface") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp13, "Interface"))) + } + var tmp15 any + switch reflect.TypeOf(tmp14).Kind() { + case reflect.Func: + tmp15 = lang.Apply(tmp14, nil) + default: + tmp15 = tmp14 + } + var v16 any = tmp15 + _ = v16 + // let binding "agt" + tmp17 := checkDerefVar(var_glojure_DOT_core_agent) + var tmp18 lang.FnFunc + tmp18 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + return v3 + }) + tmp19 := lang.Apply(lang.NewLazySeq, []any{tmp18}) + tmp20 := lang.Apply(tmp17, []any{tmp19}) + var v21 any = tmp20 + _ = v21 + // let binding "log-error" + var tmp22 lang.FnFunc + tmp22 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v23 := args[0] + _ = v23 + v24 := args[1] + _ = v24 + var tmp25 any + tmp26, _ := lang.FieldOrMethod(v23, "offer") + if reflect.TypeOf(tmp26).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("offer is not a function"))) + } + tmp27 := lang.Apply(tmp26, []any{v23}) + if lang.IsTruthy(tmp27) { + panic(v24) + } else { + tmp25 = v24 + } + return tmp25 + }) + tmp23 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5435), kw_column, int(20), kw_end_DASH_line, int(5438), kw_end_DASH_column, int(26)) + tmp24, err := lang.WithMeta(tmp22, tmp23.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v25 any = tmp24 + _ = v25 + // let binding "fill" + var tmp26 lang.FnFunc + tmp26 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v27 := args[0] + _ = v27 + var tmp28 any + if lang.IsTruthy(v27) { + var tmp29 any + tmp30 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp31 := lang.Apply(tmp30, []any{nil, v27}) + if lang.IsTruthy(tmp31) { + tmp32 := lang.Apply(v25, []any{v11, v27}) + tmp29 = tmp32 + } else { + var tmp33 any + func() { + defer func() { + if r := recover(); r != nil { + if lang.CatchMatches(r, lang.Builtins["any"]) { + v34 := r + _ = v34 + tmp35 := lang.Apply(v25, []any{v11, v34}) + tmp33 = tmp35 + } else { + panic(r) + } + } + }() + var tmp34 any + { // let + // let binding "G__780" + tmp35 := checkDerefVar(var_glojure_DOT_core_seq) + tmp36 := lang.Apply(tmp35, []any{v27}) + var v37 any = tmp36 + _ = v37 + // let binding "vec__781" + var v38 any = v37 + _ = v38 + // let binding "seq__782" + tmp39 := checkDerefVar(var_glojure_DOT_core_seq) + tmp40 := lang.Apply(tmp39, []any{v38}) + var v41 any = tmp40 + _ = v41 + // let binding "first__783" + tmp42 := checkDerefVar(var_glojure_DOT_core_first) + tmp43 := lang.Apply(tmp42, []any{v41}) + var v44 any = tmp43 + _ = v44 + // let binding "seq__782" + tmp45 := checkDerefVar(var_glojure_DOT_core_next) + tmp46 := lang.Apply(tmp45, []any{v41}) + var v47 any = tmp46 + _ = v47 + // let binding "x" + var v48 any = v44 + _ = v48 + // let binding "xs" + var v49 any = v47 + _ = v49 + // let binding "s" + var v50 any = v38 + _ = v50 + var tmp51 any + { // let + // let binding "G__780" + var v52 any = v37 + _ = v52 + for { + var tmp53 any + { // let + // let binding "vec__784" + var v54 any = v52 + _ = v54 + // let binding "seq__785" + tmp55 := checkDerefVar(var_glojure_DOT_core_seq) + tmp56 := lang.Apply(tmp55, []any{v54}) + var v57 any = tmp56 + _ = v57 + // let binding "first__786" + tmp58 := checkDerefVar(var_glojure_DOT_core_first) + tmp59 := lang.Apply(tmp58, []any{v57}) + var v60 any = tmp59 + _ = v60 + // let binding "seq__785" + tmp61 := checkDerefVar(var_glojure_DOT_core_next) + tmp62 := lang.Apply(tmp61, []any{v57}) + var v63 any = tmp62 + _ = v63 + // let binding "x" + var v64 any = v60 + _ = v64 + // let binding "xs" + var v65 any = v63 + _ = v65 + // let binding "s" + var v66 any = v54 + _ = v66 + var tmp67 any + if lang.IsTruthy(v66) { + var tmp68 any + var tmp69 any + tmp70 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp71 := lang.Apply(tmp70, []any{v64}) + if lang.IsTruthy(tmp71) { + tmp69 = v16 + } else { + tmp69 = v64 + } + tmp72, _ := lang.FieldOrMethod(v11, "offer") + if reflect.TypeOf(tmp72).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("offer is not a function"))) + } + tmp73 := lang.Apply(tmp72, []any{tmp69}) + if lang.IsTruthy(tmp73) { + var tmp74 any = v65 + v52 = tmp74 + continue + } else { + tmp68 = v66 + } + tmp67 = tmp68 + } else { + var tmp75 any + tmp76, _ := lang.FieldOrMethod(v11, "offer") + if reflect.TypeOf(tmp76).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("offer is not a function"))) + } + tmp77 := lang.Apply(tmp76, []any{v11}) + if lang.IsTruthy(tmp77) { + } else { + tmp75 = lang.NewList() + } + tmp67 = tmp75 + } + tmp53 = tmp67 + } // end let + tmp51 = tmp53 + break + } + } // end let + tmp34 = tmp51 + } // end let + tmp33 = tmp34 + }() + tmp29 = tmp33 + } + tmp28 = tmp29 + } else { + } + return tmp28 + }) + tmp27 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5439), kw_column, int(15), kw_end_DASH_line, int(5452), kw_end_DASH_column, int(44)) + tmp28, err := lang.WithMeta(tmp26, tmp27.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v29 any = tmp28 + _ = v29 + // let binding "drain" + var tmp30 lang.FnFunc + { // function drain + var v31 lang.FnFunc + tmp30 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp32 lang.FnFunc + tmp32 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp33 any + { // let + // let binding "x" + tmp34, ok := lang.FieldOrMethod(v11, "take") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v11, "take"))) + } + var tmp35 any + switch reflect.TypeOf(tmp34).Kind() { + case reflect.Func: + tmp35 = lang.Apply(tmp34, nil) + default: + tmp35 = tmp34 + } + var v36 any = tmp35 + _ = v36 + var tmp37 any + tmp38 := checkDerefVar(var_glojure_DOT_core_identical_QMARK_) + tmp39 := lang.Apply(tmp38, []any{v36, v11}) + if lang.IsTruthy(tmp39) { + tmp40 := checkDerefVar(var_glojure_DOT_core_deref) + tmp41 := lang.Apply(tmp40, []any{v21}) + _ = tmp41 + } else { + tmp42 := checkDerefVar(var_glojure_DOT_core_send_DASH_off) + tmp43 := lang.Apply(tmp42, []any{v21, v29}) + _ = tmp43 + tmp44 := checkDerefVar(var_glojure_DOT_core_release_DASH_pending_DASH_sends) + tmp45 := lang.Apply(tmp44, nil) + _ = tmp45 + tmp46 := checkDerefVar(var_glojure_DOT_core_cons) + var tmp47 any + tmp48 := checkDerefVar(var_glojure_DOT_core_identical_QMARK_) + tmp49 := lang.Apply(tmp48, []any{v36, v16}) + if lang.IsTruthy(tmp49) { + } else { + tmp47 = v36 + } + tmp50 := lang.Apply(v31, nil) + tmp51 := lang.Apply(tmp46, []any{tmp47, tmp50}) + tmp37 = tmp51 + } + tmp33 = tmp37 + } // end let + return tmp33 + }) + tmp33 := lang.Apply(lang.NewLazySeq, []any{tmp32}) + return tmp33 + }) + v31 = tmp30 + _ = v31 + } + tmp31 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5453), kw_column, int(16), kw_end_DASH_line, int(5461), kw_end_DASH_column, int(73)) + tmp32, err := lang.WithMeta(tmp30, tmp31.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v33 any = tmp32 + _ = v33 + tmp34 := checkDerefVar(var_glojure_DOT_core_send_DASH_off) + tmp35 := lang.Apply(tmp34, []any{v21, v29}) + _ = tmp35 + tmp36 := lang.Apply(v33, nil) + tmp4 = tmp36 + } // end let + return tmp4 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_seque = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_seque.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // sigs + { + tmp0 := sym_sigs.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(223), kw_column, int(2), kw_end_DASH_line, int(224), kw_end_DASH_column, int(5), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_assert_DASH_valid_DASH_fdecl) + tmp4 := lang.Apply(tmp3, []any{v2}) + _ = tmp4 + var tmp5 any + { // let + // let binding "asig" + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v7 := args[0] + _ = v7 + var tmp8 any + { // let + // let binding "arglist" + tmp9 := checkDerefVar(var_glojure_DOT_core_first) + tmp10 := lang.Apply(tmp9, []any{v7}) + var v11 any = tmp10 + _ = v11 + // let binding "arglist" + var tmp12 any + tmp13 := checkDerefVar(var_glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v11}) + tmp15 := lang.Apply(lang.Equals, []any{sym__AMP_form, tmp14}) + if lang.IsTruthy(tmp15) { + tmp16 := lang.Apply(lang.Count, []any{v11}) + tmp17 := lang.Apply(lang.Subvec, []any{v11, int64(2), tmp16}) + tmp12 = tmp17 + } else { + tmp12 = v11 + } + var v18 any = tmp12 + _ = v18 + // let binding "body" + tmp19 := checkDerefVar(var_glojure_DOT_core_next) + tmp20 := lang.Apply(tmp19, []any{v7}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + tmp23 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v21}) + tmp26 := lang.Apply(tmp23, []any{tmp25}) + if lang.IsTruthy(tmp26) { + var tmp27 any + tmp28 := checkDerefVar(var_glojure_DOT_core_next) + tmp29 := lang.Apply(tmp28, []any{v21}) + if lang.IsTruthy(tmp29) { + tmp30 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp31 := checkDerefVar(var_glojure_DOT_core_conj) + var tmp32 any + tmp33 := checkDerefVar(var_glojure_DOT_core_meta) + tmp34 := lang.Apply(tmp33, []any{v18}) + if lang.IsTruthy(tmp34) { + tmp35 := checkDerefVar(var_glojure_DOT_core_meta) + tmp36 := lang.Apply(tmp35, []any{v18}) + tmp32 = tmp36 + } else { + tmp37 := lang.NewMap() + tmp38 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(237), kw_column, int(77), kw_end_DASH_line, int(237), kw_end_DASH_column, int(78)) + tmp39, err := lang.WithMeta(tmp37, tmp38.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp32 = tmp39 + } + tmp40 := checkDerefVar(var_glojure_DOT_core_first) + tmp41 := lang.Apply(tmp40, []any{v21}) + tmp42 := lang.Apply(tmp31, []any{tmp32, tmp41}) + tmp43 := lang.Apply(tmp30, []any{v18, tmp42}) + tmp27 = tmp43 + } else { + tmp27 = v18 + } + tmp22 = tmp27 + } else { + tmp22 = v18 + } + tmp8 = tmp22 + } // end let + return tmp8 + }) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(228), kw_column, int(10), kw_end_DASH_line, int(239), kw_end_DASH_column, int(25)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v9 any = tmp8 + _ = v9 + // let binding "resolve-tag" + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v11 := args[0] + _ = v11 + var tmp12 any + { // let + // let binding "m" + tmp13 := checkDerefVar(var_glojure_DOT_core_meta) + tmp14 := lang.Apply(tmp13, []any{v11}) + var v15 any = tmp14 + _ = v15 + // let binding "tag" + tmp16 := lang.Apply(kw_tag, []any{v15}) + var v17 any = tmp16 + _ = v17 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp20 := reflect.TypeOf((*lang.Symbol)(nil)) + tmp21 := lang.Apply(tmp19, []any{tmp20, v17}) + if lang.IsTruthy(tmp21) { + var tmp22 any + tmp23, ok := lang.FieldOrMethod(v17, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v17, "Name"))) + } + var tmp24 any + switch reflect.TypeOf(tmp23).Kind() { + case reflect.Func: + tmp24 = lang.Apply(tmp23, nil) + default: + tmp24 = tmp23 + } + tmp25 := lang.Apply(strings8.Index, []any{tmp24, "."}) + tmp26 := lang.Apply(lang.Equiv, []any{tmp25, int64(-1)}) + if lang.IsTruthy(tmp26) { + var tmp27 any + tmp28 := lang.Apply(lang.Equals, []any{nil, nil}) + if lang.IsTruthy(tmp28) { + var tmp29 any + { // let + // let binding "c" + var v30 any = nil + _ = v30 + var tmp31 any + if lang.IsTruthy(v30) { + tmp32 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp33 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp34, ok := lang.FieldOrMethod(v30, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v30, "Name"))) + } + var tmp35 any + switch reflect.TypeOf(tmp34).Kind() { + case reflect.Func: + tmp35 = lang.Apply(tmp34, nil) + default: + tmp35 = tmp34 + } + tmp36 := lang.Apply(lang.NewSymbol, []any{tmp35}) + tmp37 := lang.Apply(tmp33, []any{v15, kw_tag, tmp36}) + tmp38 := lang.Apply(tmp32, []any{v11, tmp37}) + tmp31 = tmp38 + } else { + tmp31 = v11 + } + tmp29 = tmp31 + } // end let + tmp27 = tmp29 + } else { + tmp27 = v11 + } + tmp22 = tmp27 + } else { + tmp22 = v11 + } + tmp18 = tmp22 + } else { + tmp18 = v11 + } + tmp12 = tmp18 + } // end let + return tmp12 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(240), kw_column, int(22), kw_end_DASH_line, int(252), kw_end_DASH_column, int(37)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v13 any = tmp12 + _ = v13 + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp16 := checkDerefVar(var_glojure_DOT_core_first) + tmp17 := lang.Apply(tmp16, []any{v2}) + tmp18 := lang.Apply(tmp15, []any{tmp17}) + if lang.IsTruthy(tmp18) { + var tmp19 any + { // let + // let binding "ret" + tmp20 := lang.NewVector() + tmp21 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(254), kw_column, int(19), kw_end_DASH_line, int(254), kw_end_DASH_column, int(20)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v23 any = tmp22 + _ = v23 + // let binding "fdecls" + var v24 any = v2 + _ = v24 + for { + var tmp25 any + if lang.IsTruthy(v24) { + tmp27 := checkDerefVar(var_glojure_DOT_core_conj) + tmp28 := checkDerefVar(var_glojure_DOT_core_first) + tmp29 := lang.Apply(tmp28, []any{v24}) + tmp30 := lang.Apply(v9, []any{tmp29}) + tmp31 := lang.Apply(v13, []any{tmp30}) + tmp32 := lang.Apply(tmp27, []any{v23, tmp31}) + var tmp26 any = tmp32 + tmp34 := checkDerefVar(var_glojure_DOT_core_next) + tmp35 := lang.Apply(tmp34, []any{v24}) + var tmp33 any = tmp35 + v23 = tmp26 + v24 = tmp33 + continue + } else { + tmp36 := checkDerefVar(var_glojure_DOT_core_seq) + tmp37 := lang.Apply(tmp36, []any{v23}) + tmp25 = tmp37 + } + tmp19 = tmp25 + break + } + } // end let + tmp14 = tmp19 + } else { + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(v9, []any{v2}) + tmp22 := lang.Apply(v13, []any{tmp21}) + tmp23 := lang.Apply(tmp20, []any{tmp22}) + tmp14 = tmp23 + } + tmp5 = tmp14 + } // end let + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(225), kw_column, int(2), kw_end_DASH_line, int(258), kw_end_DASH_column, int(43))).(lang.FnFunc) + var_glojure_DOT_core_sigs = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_sigs.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // some-> + { + tmp0 := sym_some_DASH__GT_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_expr, sym__AMP_, sym_forms)), kw_doc, "When expr is not nil, threads it into the first form (via ->),\n and when that result is not nil, through the next etc", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(11), kw_line, int(7610), kw_end_DASH_line, int(7610))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "g" + tmp7 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp8 := lang.Apply(tmp7, nil) + var v9 any = tmp8 + _ = v9 + // let binding "steps" + tmp10 := checkDerefVar(var_glojure_DOT_core_map) + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v12 := args[0] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_if}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{sym_glojure_DOT_core_SLASH_nil_QMARK_}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v9}) + tmp24 := lang.Apply(tmp19, []any{tmp21, tmp23}) + tmp25 := lang.Apply(tmp18, []any{tmp24}) + tmp26 := lang.Apply(tmp17, []any{tmp25}) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{nil}) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := checkDerefVar(var_glojure_DOT_core_seq) + tmp31 := checkDerefVar(var_glojure_DOT_core_concat) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := lang.Apply(tmp32, []any{sym_glojure_DOT_core_SLASH__DASH__GT_}) + tmp34 := checkDerefVar(var_glojure_DOT_core_list) + tmp35 := lang.Apply(tmp34, []any{v9}) + tmp36 := checkDerefVar(var_glojure_DOT_core_list) + tmp37 := lang.Apply(tmp36, []any{v12}) + tmp38 := lang.Apply(tmp31, []any{tmp33, tmp35, tmp37}) + tmp39 := lang.Apply(tmp30, []any{tmp38}) + tmp40 := lang.Apply(tmp29, []any{tmp39}) + tmp41 := lang.Apply(tmp14, []any{tmp16, tmp26, tmp28, tmp40}) + tmp42 := lang.Apply(tmp13, []any{tmp41}) + return tmp42 + }) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7616), kw_column, int(20), kw_end_DASH_line, int(7616), kw_end_DASH_column, int(64)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp14 := lang.Apply(tmp10, []any{tmp13, v5}) + var v15 any = tmp14 + _ = v15 + tmp16 := checkDerefVar(var_glojure_DOT_core_seq) + tmp17 := checkDerefVar(var_glojure_DOT_core_concat) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{sym_glojure_DOT_core_SLASH_let}) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := checkDerefVar(var_glojure_DOT_core_apply) + tmp22 := checkDerefVar(var_glojure_DOT_core_vector) + tmp23 := checkDerefVar(var_glojure_DOT_core_seq) + tmp24 := checkDerefVar(var_glojure_DOT_core_concat) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := lang.Apply(tmp25, []any{v9}) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{v4}) + tmp29 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp30 := checkDerefVar(var_glojure_DOT_core_repeat) + tmp31 := lang.Apply(tmp30, []any{v9}) + tmp32 := checkDerefVar(var_glojure_DOT_core_butlast) + tmp33 := lang.Apply(tmp32, []any{v15}) + tmp34 := lang.Apply(tmp29, []any{tmp31, tmp33}) + tmp35 := lang.Apply(tmp24, []any{tmp26, tmp28, tmp34}) + tmp36 := lang.Apply(tmp23, []any{tmp35}) + tmp37 := lang.Apply(tmp21, []any{tmp22, tmp36}) + tmp38 := lang.Apply(tmp20, []any{tmp37}) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + var tmp40 any + tmp41 := checkDerefVar(var_glojure_DOT_core_empty_QMARK_) + tmp42 := lang.Apply(tmp41, []any{v15}) + if lang.IsTruthy(tmp42) { + tmp40 = v9 + } else { + tmp43 := checkDerefVar(var_glojure_DOT_core_last) + tmp44 := lang.Apply(tmp43, []any{v15}) + tmp40 = tmp44 + } + tmp45 := lang.Apply(tmp39, []any{tmp40}) + tmp46 := lang.Apply(tmp17, []any{tmp19, tmp38, tmp45}) + tmp47 := lang.Apply(tmp16, []any{tmp46}) + tmp6 = tmp47 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_some_DASH__GT_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_some_DASH__GT_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // some->> + { + tmp0 := sym_some_DASH__GT__GT_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_expr, sym__AMP_, sym_forms)), kw_doc, "When expr is not nil, threads it into the first form (via ->>),\n and when that result is not nil, through the next etc", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(7624), kw_end_DASH_line, int(7624))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "g" + tmp7 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp8 := lang.Apply(tmp7, nil) + var v9 any = tmp8 + _ = v9 + // let binding "steps" + tmp10 := checkDerefVar(var_glojure_DOT_core_map) + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v12 := args[0] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_if}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{sym_glojure_DOT_core_SLASH_nil_QMARK_}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v9}) + tmp24 := lang.Apply(tmp19, []any{tmp21, tmp23}) + tmp25 := lang.Apply(tmp18, []any{tmp24}) + tmp26 := lang.Apply(tmp17, []any{tmp25}) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{nil}) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := checkDerefVar(var_glojure_DOT_core_seq) + tmp31 := checkDerefVar(var_glojure_DOT_core_concat) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := lang.Apply(tmp32, []any{sym_glojure_DOT_core_SLASH__DASH__GT__GT_}) + tmp34 := checkDerefVar(var_glojure_DOT_core_list) + tmp35 := lang.Apply(tmp34, []any{v9}) + tmp36 := checkDerefVar(var_glojure_DOT_core_list) + tmp37 := lang.Apply(tmp36, []any{v12}) + tmp38 := lang.Apply(tmp31, []any{tmp33, tmp35, tmp37}) + tmp39 := lang.Apply(tmp30, []any{tmp38}) + tmp40 := lang.Apply(tmp29, []any{tmp39}) + tmp41 := lang.Apply(tmp14, []any{tmp16, tmp26, tmp28, tmp40}) + tmp42 := lang.Apply(tmp13, []any{tmp41}) + return tmp42 + }) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7630), kw_column, int(20), kw_end_DASH_line, int(7630), kw_end_DASH_column, int(65)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp14 := lang.Apply(tmp10, []any{tmp13, v5}) + var v15 any = tmp14 + _ = v15 + tmp16 := checkDerefVar(var_glojure_DOT_core_seq) + tmp17 := checkDerefVar(var_glojure_DOT_core_concat) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{sym_glojure_DOT_core_SLASH_let}) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := checkDerefVar(var_glojure_DOT_core_apply) + tmp22 := checkDerefVar(var_glojure_DOT_core_vector) + tmp23 := checkDerefVar(var_glojure_DOT_core_seq) + tmp24 := checkDerefVar(var_glojure_DOT_core_concat) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := lang.Apply(tmp25, []any{v9}) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{v4}) + tmp29 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp30 := checkDerefVar(var_glojure_DOT_core_repeat) + tmp31 := lang.Apply(tmp30, []any{v9}) + tmp32 := checkDerefVar(var_glojure_DOT_core_butlast) + tmp33 := lang.Apply(tmp32, []any{v15}) + tmp34 := lang.Apply(tmp29, []any{tmp31, tmp33}) + tmp35 := lang.Apply(tmp24, []any{tmp26, tmp28, tmp34}) + tmp36 := lang.Apply(tmp23, []any{tmp35}) + tmp37 := lang.Apply(tmp21, []any{tmp22, tmp36}) + tmp38 := lang.Apply(tmp20, []any{tmp37}) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + var tmp40 any + tmp41 := checkDerefVar(var_glojure_DOT_core_empty_QMARK_) + tmp42 := lang.Apply(tmp41, []any{v15}) + if lang.IsTruthy(tmp42) { + tmp40 = v9 + } else { + tmp43 := checkDerefVar(var_glojure_DOT_core_last) + tmp44 := lang.Apply(tmp43, []any{v15}) + tmp40 = tmp44 + } + tmp45 := lang.Apply(tmp39, []any{tmp40}) + tmp46 := lang.Apply(tmp17, []any{tmp19, tmp38, tmp45}) + tmp47 := lang.Apply(tmp16, []any{tmp46}) + tmp6 = tmp47 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_some_DASH__GT__GT_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_some_DASH__GT__GT_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // split-at + { + tmp0 := sym_split_DASH_at.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n, sym_coll)), kw_doc, "Returns a vector of [(take n coll) (drop n coll)]", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(2983), kw_end_DASH_line, int(2983))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_take) + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + tmp6 := checkDerefVar(var_glojure_DOT_core_drop) + tmp7 := lang.Apply(tmp6, []any{v2, v3}) + tmp8 := lang.NewVector(tmp5, tmp7) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2988), kw_column, int(5), kw_end_DASH_line, int(2988), kw_end_DASH_column, int(33)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp10 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_split_DASH_at = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_split_DASH_at.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // to-array-2d + { + tmp0 := sym_to_DASH_array_DASH_2d.WithMeta(lang.NewMap(kw_tag, "[[Ljava.lang.Object;", kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a (potentially-ragged) 2-dimensional array of Objects\n containing the contents of coll, which can be any Collection of any\n Collection.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(4002), kw_end_DASH_line, int(4002))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "ret" + tmp4 := checkDerefVar(var_glojure_DOT_core_make_DASH_array) + tmp5 := reflect.TypeOf((*reflect.Type)(nil)).Elem() + tmp6, _ := lang.FieldOrMethod(tmp5, "forName") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("forName is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{"[Ljava.lang.Object;"}) + tmp8, _ := lang.FieldOrMethod(v2, "size") + if reflect.TypeOf(tmp8).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("size is not a function"))) + } + tmp9 := lang.Apply(tmp8, []any{}) + tmp10 := lang.Apply(tmp4, []any{tmp7, tmp9}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + { // let + // let binding "i" + var v13 any = int64(0) + _ = v13 + // let binding "xs" + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := lang.Apply(tmp14, []any{v2}) + var v16 any = tmp15 + _ = v16 + for { + var tmp17 any + if lang.IsTruthy(v16) { + tmp18 := checkDerefVar(var_glojure_DOT_core_aset) + tmp19 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) + tmp20 := checkDerefVar(var_glojure_DOT_core_first) + tmp21 := lang.Apply(tmp20, []any{v16}) + tmp22 := lang.Apply(tmp19, []any{tmp21}) + tmp23 := lang.Apply(tmp18, []any{v11, v13, tmp22}) + _ = tmp23 + tmp25 := checkDerefVar(var_glojure_DOT_core_inc) + tmp26 := lang.Apply(tmp25, []any{v13}) + var tmp24 any = tmp26 + tmp28 := checkDerefVar(var_glojure_DOT_core_next) + tmp29 := lang.Apply(tmp28, []any{v16}) + var tmp27 any = tmp29 + v13 = tmp24 + v16 = tmp27 + continue + } else { + } + tmp12 = tmp17 + break + } + } // end let + _ = tmp12 + tmp3 = v11 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, "[[Ljava.lang.Object;")).(lang.FnFunc) + var_glojure_DOT_core_to_DASH_array_DASH_2d = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_to_DASH_array_DASH_2d.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // with-local-vars + { + tmp0 := sym_with_DASH_local_DASH_vars.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name_DASH_vals_DASH_vec, sym__AMP_, sym_body)), kw_doc, "varbinding=> symbol init-expr\n\n Executes the exprs in a context in which the symbols are bound to\n vars with per-thread bindings to the init-exprs. The symbols refer\n to the var objects themselves, and must be accessed with var-get and\n var-set", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(25), kw_column, int(11), kw_line, int(4339), kw_end_DASH_line, int(4339))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v4}) + if lang.IsTruthy(tmp8) { + } else { + tmp9 := checkDerefVar(var_glojure_DOT_core_str) + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp13 := checkDerefVar(var_glojure_DOT_core_meta) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(kw_line, []any{tmp14}) + tmp16 := lang.Apply(tmp9, []any{tmp11, " requires ", "a vector for its binding", " in ", tmp12, ":", tmp15}) + tmp17 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp16}) + panic(tmp17) + } + _ = tmp6 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_even_QMARK_) + tmp20 := checkDerefVar(var_glojure_DOT_core_count) + tmp21 := lang.Apply(tmp20, []any{v4}) + tmp22 := lang.Apply(tmp19, []any{tmp21}) + if lang.IsTruthy(tmp22) { + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp27 := checkDerefVar(var_glojure_DOT_core_meta) + tmp28 := lang.Apply(tmp27, []any{v2}) + tmp29 := lang.Apply(kw_line, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp25, " requires ", "an even number of forms in binding vector", " in ", tmp26, ":", tmp29}) + tmp31 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp31) + } + _ = tmp18 + tmp32 := checkDerefVar(var_glojure_DOT_core_seq) + tmp33 := checkDerefVar(var_glojure_DOT_core_concat) + tmp34 := checkDerefVar(var_glojure_DOT_core_list) + tmp35 := lang.Apply(tmp34, []any{sym_glojure_DOT_core_SLASH_let}) + tmp36 := checkDerefVar(var_glojure_DOT_core_list) + tmp37 := checkDerefVar(var_glojure_DOT_core_apply) + tmp38 := checkDerefVar(var_glojure_DOT_core_vector) + tmp39 := checkDerefVar(var_glojure_DOT_core_seq) + tmp40 := checkDerefVar(var_glojure_DOT_core_concat) + tmp41 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp42 := checkDerefVar(var_glojure_DOT_core_take_DASH_nth) + tmp43 := lang.Apply(tmp42, []any{int64(2), v4}) + tmp44 := checkDerefVar(var_glojure_DOT_core_repeat) + tmp45 := lang.Apply(tmp44, []any{lang.NewList(sym__DOT__DOT_, sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT__STAR_Var, sym_create, sym_setDynamic)}) + tmp46 := lang.Apply(tmp41, []any{tmp43, tmp45}) + tmp47 := lang.Apply(tmp40, []any{tmp46}) + tmp48 := lang.Apply(tmp39, []any{tmp47}) + tmp49 := lang.Apply(tmp37, []any{tmp38, tmp48}) + tmp50 := lang.Apply(tmp36, []any{tmp49}) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := checkDerefVar(var_glojure_DOT_core_seq) + tmp53 := checkDerefVar(var_glojure_DOT_core_concat) + tmp54 := checkDerefVar(var_glojure_DOT_core_list) + tmp55 := lang.Apply(tmp54, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_PushThreadBindings}) + tmp56 := checkDerefVar(var_glojure_DOT_core_list) + tmp57 := checkDerefVar(var_glojure_DOT_core_apply) + tmp58 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp59 := checkDerefVar(var_glojure_DOT_core_seq) + tmp60 := checkDerefVar(var_glojure_DOT_core_concat) + tmp61 := lang.Apply(tmp60, nil) + tmp62 := lang.Apply(tmp59, []any{tmp61}) + tmp63 := lang.Apply(tmp57, []any{tmp58, tmp62}) + tmp64 := lang.Apply(tmp56, []any{tmp63}) + tmp65 := lang.Apply(tmp53, []any{tmp55, tmp64}) + tmp66 := lang.Apply(tmp52, []any{tmp65}) + tmp67 := lang.Apply(tmp51, []any{tmp66}) + tmp68 := checkDerefVar(var_glojure_DOT_core_list) + tmp69 := checkDerefVar(var_glojure_DOT_core_seq) + tmp70 := checkDerefVar(var_glojure_DOT_core_concat) + tmp71 := checkDerefVar(var_glojure_DOT_core_list) + tmp72 := lang.Apply(tmp71, []any{sym_try}) + tmp73 := checkDerefVar(var_glojure_DOT_core_list) + tmp74 := checkDerefVar(var_glojure_DOT_core_seq) + tmp75 := checkDerefVar(var_glojure_DOT_core_concat) + tmp76 := checkDerefVar(var_glojure_DOT_core_list) + tmp77 := lang.Apply(tmp76, []any{sym_finally}) + tmp78 := checkDerefVar(var_glojure_DOT_core_list) + tmp79 := checkDerefVar(var_glojure_DOT_core_seq) + tmp80 := checkDerefVar(var_glojure_DOT_core_concat) + tmp81 := checkDerefVar(var_glojure_DOT_core_list) + tmp82 := lang.Apply(tmp81, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_PopThreadBindings}) + tmp83 := lang.Apply(tmp80, []any{tmp82}) + tmp84 := lang.Apply(tmp79, []any{tmp83}) + tmp85 := lang.Apply(tmp78, []any{tmp84}) + tmp86 := lang.Apply(tmp75, []any{tmp77, tmp85}) + tmp87 := lang.Apply(tmp74, []any{tmp86}) + tmp88 := lang.Apply(tmp73, []any{tmp87}) + tmp89 := lang.Apply(tmp70, []any{tmp72, v5, tmp88}) + tmp90 := lang.Apply(tmp69, []any{tmp89}) + tmp91 := lang.Apply(tmp68, []any{tmp90}) + tmp92 := lang.Apply(tmp33, []any{tmp35, tmp50, tmp67, tmp91}) + tmp93 := lang.Apply(tmp32, []any{tmp92}) + return tmp93 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_with_DASH_local_DASH_vars = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_with_DASH_local_DASH_vars.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // Throwable->map + { + tmp0 := sym_Throwable_DASH__GT_map.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_o)), kw_doc, "Constructs a data representation for a Throwable with keys:\n :cause - root cause message\n :phase - error phase\n :via - cause chain, with cause keys:\n :type - exception class symbol\n :message - exception message\n :data - ex-data\n :at - top stack element\n :trace - root cause stack elements", kw_file, "glojure/core_print.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(442), kw_end_DASH_line, int(442))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "base" + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v5 := args[0] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_merge) + tmp7 := checkDerefVar(var_glojure_DOT_core_symbol) + tmp8 := checkDerefVar(var_glojure_DOT_core_class) + tmp9 := lang.Apply(tmp8, []any{v5}) + tmp10, ok := lang.FieldOrMethod(tmp9, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp9, "Name"))) + } + var tmp11 any + switch reflect.TypeOf(tmp10).Kind() { + case reflect.Func: + tmp11 = lang.Apply(tmp10, nil) + default: + tmp11 = tmp10 + } + tmp12 := lang.Apply(tmp7, []any{tmp11}) + tmp13 := lang.NewMap(kw_type, tmp12) + tmp14 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(455), kw_column, int(23), kw_end_DASH_line, int(455), kw_end_DASH_column, int(56)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var tmp16 any + { // let + // let binding "temp__0__auto__" + tmp17, ok := lang.FieldOrMethod(v5, "getLocalizedMessage") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "getLocalizedMessage"))) + } + var tmp18 any + switch reflect.TypeOf(tmp17).Kind() { + case reflect.Func: + tmp18 = lang.Apply(tmp17, nil) + default: + tmp18 = tmp17 + } + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + var tmp21 any + { // let + // let binding "msg" + var v22 any = v19 + _ = v22 + tmp23 := lang.NewMap(kw_message, v22) + tmp24 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(457), kw_column, int(20), kw_end_DASH_line, int(457), kw_end_DASH_column, int(33)) + tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp21 = tmp25 + } // end let + tmp20 = tmp21 + } else { + } + tmp16 = tmp20 + } // end let + var tmp17 any + { // let + // let binding "temp__0__auto__" + tmp18 := checkDerefVar(var_glojure_DOT_core_ex_DASH_data) + tmp19 := lang.Apply(tmp18, []any{v5}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + var tmp22 any + { // let + // let binding "ed" + var v23 any = v20 + _ = v23 + tmp24 := lang.NewMap(kw_data, v23) + tmp25 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(459), kw_column, int(20), kw_end_DASH_line, int(459), kw_end_DASH_column, int(29)) + tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp22 = tmp26 + } // end let + tmp21 = tmp22 + } else { + } + tmp17 = tmp21 + } // end let + var tmp18 any + { // let + // let binding "st" + tmp19, ok := lang.FieldOrMethod(v5, "getStackTrace") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "getStackTrace"))) + } + var tmp20 any + switch reflect.TypeOf(tmp19).Kind() { + case reflect.Func: + tmp20 = lang.Apply(tmp19, nil) + default: + tmp20 = tmp19 + } + var v21 any = tmp20 + _ = v21 + var tmp22 any + tmp23 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp24 := checkDerefVar(var_glojure_DOT_core_alength) + tmp25 := lang.Apply(tmp24, []any{v21}) + tmp26 := lang.Apply(tmp23, []any{tmp25}) + if lang.IsTruthy(tmp26) { + tmp27 := checkDerefVar(var_glojure_DOT_core_StackTraceElement_DASH__GT_vec) + tmp28 := checkDerefVar(var_glojure_DOT_core_aget) + tmp29 := lang.Apply(tmp28, []any{v21, int64(0)}) + tmp30 := lang.Apply(tmp27, []any{tmp29}) + tmp31 := lang.NewMap(kw_at, tmp30) + tmp32 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(462), kw_column, int(22), kw_end_DASH_line, int(462), kw_end_DASH_column, int(63)) + tmp33, err := lang.WithMeta(tmp31, tmp32.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp22 = tmp33 + } else { + } + tmp18 = tmp22 + } // end let + tmp19 := lang.Apply(tmp6, []any{tmp15, tmp16, tmp17, tmp18}) + return tmp19 + }) + tmp5 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(454), kw_column, int(14), kw_end_DASH_line, int(462), kw_end_DASH_column, int(67)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v7 any = tmp6 + _ = v7 + // let binding "via" + var tmp8 any + { // let + // let binding "via" + tmp9 := lang.NewVector() + tmp10 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(463), kw_column, int(24), kw_end_DASH_line, int(463), kw_end_DASH_column, int(25)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v12 any = tmp11 + _ = v12 + // let binding "t" + var v13 any = v2 + _ = v13 + for { + var tmp14 any + if lang.IsTruthy(v13) { + tmp16 := checkDerefVar(var_glojure_DOT_core_conj) + tmp17 := lang.Apply(tmp16, []any{v12, v13}) + var tmp15 any = tmp17 + tmp19, ok := lang.FieldOrMethod(v13, "getCause") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v13, "getCause"))) + } + var tmp20 any + switch reflect.TypeOf(tmp19).Kind() { + case reflect.Func: + tmp20 = lang.Apply(tmp19, nil) + default: + tmp20 = tmp19 + } + var tmp18 any = tmp20 + v12 = tmp15 + v13 = tmp18 + continue + } else { + tmp14 = v12 + } + tmp8 = tmp14 + break + } + } // end let + var v9 any = tmp8 + _ = v9 + // let binding "root" + tmp10 := checkDerefVar(var_glojure_DOT_core_peek) + tmp11 := lang.Apply(tmp10, []any{v9}) + var v12 any = tmp11 + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_merge) + tmp14 := checkDerefVar(var_glojure_DOT_core_vec) + tmp15 := checkDerefVar(var_glojure_DOT_core_map) + tmp16 := lang.Apply(tmp15, []any{v7, v9}) + tmp17 := lang.Apply(tmp14, []any{tmp16}) + tmp18 := checkDerefVar(var_glojure_DOT_core_vec) + tmp19 := checkDerefVar(var_glojure_DOT_core_map) + tmp20 := checkDerefVar(var_glojure_DOT_core_StackTraceElement_DASH__GT_vec) + var tmp21 any + { // let + // let binding "or__0__auto__" + var v22 any = v12 + _ = v22 + var tmp23 any + if lang.IsTruthy(v22) { + tmp23 = v22 + } else { + tmp23 = v2 + } + tmp21 = tmp23 + } // end let + tmp22, ok := lang.FieldOrMethod(tmp21, "getStackTrace") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp21, "getStackTrace"))) + } + var tmp23 any + switch reflect.TypeOf(tmp22).Kind() { + case reflect.Func: + tmp23 = lang.Apply(tmp22, nil) + default: + tmp23 = tmp22 + } + tmp24 := lang.Apply(tmp19, []any{tmp20, tmp23}) + tmp25 := lang.Apply(tmp18, []any{tmp24}) + tmp26 := lang.NewMap(kw_via, tmp17, kw_trace, tmp25) + tmp27 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(468), kw_column, int(12), kw_end_DASH_line, int(470), kw_end_DASH_column, int(111)) + tmp28, err := lang.WithMeta(tmp26, tmp27.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var tmp29 any + { // let + // let binding "temp__0__auto__" + tmp30, ok := lang.FieldOrMethod(v12, "getLocalizedMessage") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v12, "getLocalizedMessage"))) + } + var tmp31 any + switch reflect.TypeOf(tmp30).Kind() { + case reflect.Func: + tmp31 = lang.Apply(tmp30, nil) + default: + tmp31 = tmp30 + } + var v32 any = tmp31 + _ = v32 + var tmp33 any + if lang.IsTruthy(v32) { + var tmp34 any + { // let + // let binding "root-msg" + var v35 any = v32 + _ = v35 + tmp36 := lang.NewMap(kw_cause, v35) + tmp37 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(472), kw_column, int(9), kw_end_DASH_line, int(472), kw_end_DASH_column, int(25)) + tmp38, err := lang.WithMeta(tmp36, tmp37.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp34 = tmp38 + } // end let + tmp33 = tmp34 + } else { + } + tmp29 = tmp33 + } // end let + var tmp30 any + { // let + // let binding "temp__0__auto__" + tmp31 := checkDerefVar(var_glojure_DOT_core_ex_DASH_data) + tmp32 := lang.Apply(tmp31, []any{v12}) + var v33 any = tmp32 + _ = v33 + var tmp34 any + if lang.IsTruthy(v33) { + var tmp35 any + { // let + // let binding "data" + var v36 any = v33 + _ = v36 + tmp37 := lang.NewMap(kw_data, v36) + tmp38 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(474), kw_column, int(9), kw_end_DASH_line, int(474), kw_end_DASH_column, int(20)) + tmp39, err := lang.WithMeta(tmp37, tmp38.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp35 = tmp39 + } // end let + tmp34 = tmp35 + } else { + } + tmp30 = tmp34 + } // end let + var tmp31 any + { // let + // let binding "temp__0__auto__" + tmp32 := checkDerefVar(var_glojure_DOT_core_ex_DASH_data) + tmp33 := lang.Apply(tmp32, []any{v2}) + tmp34 := lang.Apply(kw_glojure_DOT_error_SLASH_phase, []any{tmp33}) + var v35 any = tmp34 + _ = v35 + var tmp36 any + if lang.IsTruthy(v35) { + var tmp37 any + { // let + // let binding "phase" + var v38 any = v35 + _ = v38 + tmp39 := lang.NewMap(kw_phase, v38) + tmp40 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(476), kw_column, int(9), kw_end_DASH_line, int(476), kw_end_DASH_column, int(22)) + tmp41, err := lang.WithMeta(tmp39, tmp40.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp37 = tmp41 + } // end let + tmp36 = tmp37 + } else { + } + tmp31 = tmp36 + } // end let + tmp32 := lang.Apply(tmp13, []any{tmp28, tmp29, tmp30, tmp31}) + tmp3 = tmp32 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_Throwable_DASH__GT_map = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_Throwable_DASH__GT_map.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // as-> + { + tmp0 := sym_as_DASH__GT_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_expr, sym_name, sym__AMP_, sym_forms)), kw_doc, "Binds name to expr, evaluates the first form in the lexical context\n of that binding, then binds name to that result, repeating for each\n successive form, returning the result of the last form.", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(11), kw_line, int(7598), kw_end_DASH_line, int(7598))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var v6 any = lang.NewList(args[4:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_core_SLASH_let}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_apply) + tmp13 := checkDerefVar(var_glojure_DOT_core_vector) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v5}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp21 := checkDerefVar(var_glojure_DOT_core_repeat) + tmp22 := lang.Apply(tmp21, []any{v5}) + tmp23 := checkDerefVar(var_glojure_DOT_core_butlast) + tmp24 := lang.Apply(tmp23, []any{v6}) + tmp25 := lang.Apply(tmp20, []any{tmp22, tmp24}) + tmp26 := lang.Apply(tmp15, []any{tmp17, tmp19, tmp25}) + tmp27 := lang.Apply(tmp14, []any{tmp26}) + tmp28 := lang.Apply(tmp12, []any{tmp13, tmp27}) + tmp29 := lang.Apply(tmp11, []any{tmp28}) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + var tmp31 any + tmp32 := checkDerefVar(var_glojure_DOT_core_empty_QMARK_) + tmp33 := lang.Apply(tmp32, []any{v6}) + if lang.IsTruthy(tmp33) { + tmp31 = v5 + } else { + tmp34 := checkDerefVar(var_glojure_DOT_core_last) + tmp35 := lang.Apply(tmp34, []any{v6}) + tmp31 = tmp35 + } + tmp36 := lang.Apply(tmp30, []any{tmp31}) + tmp37 := lang.Apply(tmp8, []any{tmp10, tmp29, tmp36}) + tmp38 := lang.Apply(tmp7, []any{tmp37}) + return tmp38 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_as_DASH__GT_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_as_DASH__GT_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // await + { + tmp0 := sym_await.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_agents)), kw_doc, "Blocks the current thread (indefinitely!) until all actions\n dispatched thus far, from this thread or agent, to the agent(s) have\n occurred. Will block on failed agents. Will never return if\n a failed agent is restarted with :clear-actions true or shutdown-agents was called.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3267), kw_end_DASH_line, int(3267))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + var tmp3 any + tmp4 := lang.Apply(nil, nil) + if lang.IsTruthy(tmp4) { + panic("unimplemented: new with non-constant class type") + } else { + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_agent_STAR_) + if lang.IsTruthy(tmp6) { + tmp7 := lang.Apply(errors5.New, []any{"Can't await in agent action"}) + panic(tmp7) + } else { + } + _ = tmp5 + var tmp8 any + { // let + // let binding "latch" + var v9 any = "unimplemented: new with non-constant class type" + _ = v9 + // let binding "count-down" + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v11 := args[0] + _ = v11 + tmp12, _ := lang.FieldOrMethod(v9, "countDown") + if reflect.TypeOf(tmp12).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("countDown is not a function"))) + } + tmp13 := lang.Apply(tmp12, []any{}) + _ = tmp13 + return v11 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3279), kw_column, int(22), kw_end_DASH_line, int(3279), kw_end_DASH_column, int(61)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v13 any = tmp12 + _ = v13 + var tmp14 any + { // let + // let binding "seq_692" + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := lang.Apply(tmp15, []any{v2}) + var v17 any = tmp16 + _ = v17 + // let binding "chunk_693" + var v18 any = nil + _ = v18 + // let binding "count_694" + var v19 any = int64(0) + _ = v19 + // let binding "i_695" + var v20 any = int64(0) + _ = v20 + for { + var tmp21 any + tmp22 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp23 := lang.Apply(tmp22, []any{v20, v19}) + if lang.IsTruthy(tmp23) { + var tmp24 any + { // let + // let binding "agent" + tmp25, _ := lang.FieldOrMethod(v18, "nth") + if reflect.TypeOf(tmp25).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp26 := lang.Apply(tmp25, []any{v20}) + var v27 any = tmp26 + _ = v27 + tmp28 := checkDerefVar(var_glojure_DOT_core_send) + tmp29 := lang.Apply(tmp28, []any{v27, v13}) + _ = tmp29 + var tmp30 any = v17 + var tmp31 any = v18 + var tmp32 any = v19 + tmp34 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp35 := lang.Apply(tmp34, []any{v20}) + var tmp33 any = tmp35 + v17 = tmp30 + v18 = tmp31 + v19 = tmp32 + v20 = tmp33 + continue + } // end let + tmp21 = tmp24 + } else { + var tmp25 any + { // let + // let binding "temp__0__auto__" + tmp26 := checkDerefVar(var_glojure_DOT_core_seq) + tmp27 := lang.Apply(tmp26, []any{v17}) + var v28 any = tmp27 + _ = v28 + var tmp29 any + if lang.IsTruthy(v28) { + var tmp30 any + { // let + // let binding "seq_692" + var v31 any = v28 + _ = v31 + var tmp32 any + tmp33 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp34 := lang.Apply(tmp33, []any{v31}) + if lang.IsTruthy(tmp34) { + var tmp35 any + { // let + // let binding "c__0__auto__" + tmp36 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp37 := lang.Apply(tmp36, []any{v31}) + var v38 any = tmp37 + _ = v38 + tmp40 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp41 := lang.Apply(tmp40, []any{v31}) + var tmp39 any = tmp41 + var tmp42 any = v38 + tmp44 := checkDerefVar(var_glojure_DOT_core_int) + tmp45 := checkDerefVar(var_glojure_DOT_core_count) + tmp46 := lang.Apply(tmp45, []any{v38}) + tmp47 := lang.Apply(tmp44, []any{tmp46}) + var tmp43 any = tmp47 + tmp49 := checkDerefVar(var_glojure_DOT_core_int) + tmp50 := lang.Apply(tmp49, []any{int64(0)}) + var tmp48 any = tmp50 + v17 = tmp39 + v18 = tmp42 + v19 = tmp43 + v20 = tmp48 + continue + } // end let + tmp32 = tmp35 + } else { + var tmp36 any + { // let + // let binding "agent" + tmp37 := checkDerefVar(var_glojure_DOT_core_first) + tmp38 := lang.Apply(tmp37, []any{v31}) + var v39 any = tmp38 + _ = v39 + tmp40 := checkDerefVar(var_glojure_DOT_core_send) + tmp41 := lang.Apply(tmp40, []any{v39, v13}) + _ = tmp41 + tmp43 := checkDerefVar(var_glojure_DOT_core_next) + tmp44 := lang.Apply(tmp43, []any{v31}) + var tmp42 any = tmp44 + var tmp45 any = nil + var tmp46 any = int64(0) + var tmp47 any = int64(0) + v17 = tmp42 + v18 = tmp45 + v19 = tmp46 + v20 = tmp47 + continue + } // end let + tmp32 = tmp36 + } + tmp30 = tmp32 + } // end let + tmp29 = tmp30 + } else { + } + tmp25 = tmp29 + } // end let + tmp21 = tmp25 + } + tmp14 = tmp21 + break + } + } // end let + _ = tmp14 + tmp15, _ := lang.FieldOrMethod(v9, "await") + if reflect.TypeOf(tmp15).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) + } + tmp16 := lang.Apply(tmp15, []any{}) + tmp8 = tmp16 + } // end let + tmp3 = tmp8 + } + return tmp3 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_await = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_await.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // await1 + { + tmp0 := sym_await1.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(3284), kw_column, int(7), kw_end_DASH_line, int(3284), kw_end_DASH_column, int(21), kw_arglists, lang.NewList(lang.NewVector(sym_a)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp5, ok := lang.FieldOrMethod(v2, "getQueueCount") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getQueueCount"))) + } + var tmp6 any + switch reflect.TypeOf(tmp5).Kind() { + case reflect.Func: + tmp6 = lang.Apply(tmp5, nil) + default: + tmp6 = tmp5 + } + tmp7 := lang.Apply(tmp4, []any{tmp6}) + if lang.IsTruthy(tmp7) { + tmp8 := checkDerefVar(var_glojure_DOT_core_await) + tmp9 := lang.Apply(tmp8, []any{v2}) + tmp3 = tmp9 + } else { + } + _ = tmp3 + return v2 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_await1 = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_await1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // await-for + { + tmp0 := sym_await_DASH_for.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_timeout_DASH_ms, sym__AMP_, sym_agents)), kw_doc, "Blocks the current thread until all actions dispatched thus\n far (from this thread or agent) to the agents have occurred, or the\n timeout (in milliseconds) has elapsed. Returns logical false if\n returning due to timeout, logical true otherwise.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(3289), kw_end_DASH_line, int(3289))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + var tmp4 any + tmp5 := lang.Apply(nil, nil) + if lang.IsTruthy(tmp5) { + panic("unimplemented: new with non-constant class type") + } else { + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_agent_STAR_) + if lang.IsTruthy(tmp7) { + tmp8 := lang.Apply(errors5.New, []any{"Can't await in agent action"}) + panic(tmp8) + } else { + } + _ = tmp6 + var tmp9 any + { // let + // let binding "latch" + var v10 any = "unimplemented: new with non-constant class type" + _ = v10 + // let binding "count-down" + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v12 := args[0] + _ = v12 + tmp13, _ := lang.FieldOrMethod(v10, "countDown") + if reflect.TypeOf(tmp13).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("countDown is not a function"))) + } + tmp14 := lang.Apply(tmp13, []any{}) + _ = tmp14 + return v12 + }) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3301), kw_column, int(23), kw_end_DASH_line, int(3301), kw_end_DASH_column, int(62)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v14 any = tmp13 + _ = v14 + var tmp15 any + { // let + // let binding "seq_696" + tmp16 := checkDerefVar(var_glojure_DOT_core_seq) + tmp17 := lang.Apply(tmp16, []any{v3}) + var v18 any = tmp17 + _ = v18 + // let binding "chunk_697" + var v19 any = nil + _ = v19 + // let binding "count_698" + var v20 any = int64(0) + _ = v20 + // let binding "i_699" + var v21 any = int64(0) + _ = v21 + for { + var tmp22 any + tmp23 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp24 := lang.Apply(tmp23, []any{v21, v20}) + if lang.IsTruthy(tmp24) { + var tmp25 any + { // let + // let binding "agent" + tmp26, _ := lang.FieldOrMethod(v19, "nth") + if reflect.TypeOf(tmp26).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp27 := lang.Apply(tmp26, []any{v21}) + var v28 any = tmp27 + _ = v28 + tmp29 := checkDerefVar(var_glojure_DOT_core_send) + tmp30 := lang.Apply(tmp29, []any{v28, v14}) + _ = tmp30 + var tmp31 any = v18 + var tmp32 any = v19 + var tmp33 any = v20 + tmp35 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp36 := lang.Apply(tmp35, []any{v21}) + var tmp34 any = tmp36 + v18 = tmp31 + v19 = tmp32 + v20 = tmp33 + v21 = tmp34 + continue + } // end let + tmp22 = tmp25 + } else { + var tmp26 any + { // let + // let binding "temp__0__auto__" + tmp27 := checkDerefVar(var_glojure_DOT_core_seq) + tmp28 := lang.Apply(tmp27, []any{v18}) + var v29 any = tmp28 + _ = v29 + var tmp30 any + if lang.IsTruthy(v29) { + var tmp31 any + { // let + // let binding "seq_696" + var v32 any = v29 + _ = v32 + var tmp33 any + tmp34 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp35 := lang.Apply(tmp34, []any{v32}) + if lang.IsTruthy(tmp35) { + var tmp36 any + { // let + // let binding "c__0__auto__" + tmp37 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp38 := lang.Apply(tmp37, []any{v32}) + var v39 any = tmp38 + _ = v39 + tmp41 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp42 := lang.Apply(tmp41, []any{v32}) + var tmp40 any = tmp42 + var tmp43 any = v39 + tmp45 := checkDerefVar(var_glojure_DOT_core_int) + tmp46 := checkDerefVar(var_glojure_DOT_core_count) + tmp47 := lang.Apply(tmp46, []any{v39}) + tmp48 := lang.Apply(tmp45, []any{tmp47}) + var tmp44 any = tmp48 + tmp50 := checkDerefVar(var_glojure_DOT_core_int) + tmp51 := lang.Apply(tmp50, []any{int64(0)}) + var tmp49 any = tmp51 + v18 = tmp40 + v19 = tmp43 + v20 = tmp44 + v21 = tmp49 + continue + } // end let + tmp33 = tmp36 + } else { + var tmp37 any + { // let + // let binding "agent" + tmp38 := checkDerefVar(var_glojure_DOT_core_first) + tmp39 := lang.Apply(tmp38, []any{v32}) + var v40 any = tmp39 + _ = v40 + tmp41 := checkDerefVar(var_glojure_DOT_core_send) + tmp42 := lang.Apply(tmp41, []any{v40, v14}) + _ = tmp42 + tmp44 := checkDerefVar(var_glojure_DOT_core_next) + tmp45 := lang.Apply(tmp44, []any{v32}) + var tmp43 any = tmp45 + var tmp46 any = nil + var tmp47 any = int64(0) + var tmp48 any = int64(0) + v18 = tmp43 + v19 = tmp46 + v20 = tmp47 + v21 = tmp48 + continue + } // end let + tmp33 = tmp37 + } + tmp31 = tmp33 + } // end let + tmp30 = tmp31 + } else { + } + tmp26 = tmp30 + } // end let + tmp22 = tmp26 + } + tmp15 = tmp22 + break + } + } // end let + _ = tmp15 + tmp16, ok := lang.FieldOrMethod(nil, "MILLISECONDS") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "MILLISECONDS"))) + } + var tmp17 any + switch reflect.TypeOf(tmp16).Kind() { + case reflect.Func: + tmp17 = lang.Apply(tmp16, nil) + default: + tmp17 = tmp16 + } + tmp18, _ := lang.FieldOrMethod(v10, "await") + if reflect.TypeOf(tmp18).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) + } + tmp19 := lang.Apply(tmp18, []any{v2, tmp17}) + tmp9 = tmp19 + } // end let + tmp4 = tmp9 + } + return tmp4 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_await_DASH_for = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_await_DASH_for.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // check-cyclic-dependency + { + tmp0 := sym_check_DASH_cyclic_DASH_dependency.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_path)), kw_doc, "Detects and rejects non-trivial cyclic load dependencies. The\n exception message shows the dependency chain with the cycle\n highlighted. Ignores the trivial case of a file attempting to load\n itself because that can occur when a gen-class'd class loads its\n implementation.", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(30), kw_column, int(8), kw_line, int(5974), kw_end_DASH_line, int(5974), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_some) + tmp5 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{v2})) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5981), kw_column, int(15), kw_end_DASH_line, int(5981), kw_end_DASH_column, int(21)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp8 := checkDerefVar(var_glojure_DOT_core_rest) + tmp9 := checkDerefVar(var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_) + tmp10 := lang.Apply(tmp8, []any{tmp9}) + tmp11 := lang.Apply(tmp4, []any{tmp7, tmp10}) + if lang.IsTruthy(tmp11) { + var tmp12 any + { // let + // let binding "pending" + tmp13 := checkDerefVar(var_glojure_DOT_core_map) + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v15 := args[0] + _ = v15 + var tmp16 any + tmp17 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp18 := lang.Apply(tmp17, []any{v15, v2}) + if lang.IsTruthy(tmp18) { + tmp19 := checkDerefVar(var_glojure_DOT_core_str) + tmp20 := lang.Apply(tmp19, []any{"[ ", v15, " ]"}) + tmp16 = tmp20 + } else { + tmp16 = v15 + } + return tmp16 + }) + tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5982), kw_column, int(24), kw_end_DASH_line, int(5982), kw_end_DASH_column, int(59)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp17 := checkDerefVar(var_glojure_DOT_core_cons) + tmp18 := checkDerefVar(var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_) + tmp19 := lang.Apply(tmp17, []any{v2, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp16, tmp19}) + var v21 any = tmp20 + _ = v21 + // let binding "chain" + tmp22 := checkDerefVar(var_glojure_DOT_core_apply) + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_interpose) + tmp25 := lang.Apply(tmp24, []any{"->", v21}) + tmp26 := lang.Apply(tmp22, []any{tmp23, tmp25}) + var v27 any = tmp26 + _ = v27 + tmp28 := checkDerefVar(var_glojure_DOT_core_throw_DASH_if) + tmp29 := lang.Apply(tmp28, []any{true, "Cyclic load dependency: %s", v27}) + tmp12 = tmp29 + } // end let + tmp3 = tmp12 + } else { + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_check_DASH_cyclic_DASH_dependency = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_check_DASH_cyclic_DASH_dependency.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // cond-> + { + tmp0 := sym_cond_DASH__GT_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_expr, sym__AMP_, sym_clauses)), kw_doc, "Takes an expression and a set of test/form pairs. Threads expr (via ->)\n through each form for which the corresponding test\n expression is true. Note that, unlike cond branching, cond-> threading does\n not short circuit after the first true test expression.", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(11), kw_line, int(7564), kw_end_DASH_line, int(7564))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "g" + tmp7 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp8 := lang.Apply(tmp7, nil) + var v9 any = tmp8 + _ = v9 + // let binding "steps" + tmp10 := checkDerefVar(var_glojure_DOT_core_map) + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v12 := args[0] + _ = v12 + var tmp13 any + { // let + // let binding "vec__1001" + var v14 any = v12 + _ = v14 + // let binding "test" + tmp15 := checkDerefVar(var_glojure_DOT_core_nth) + tmp16 := lang.Apply(tmp15, []any{v14, int64(0), nil}) + var v17 any = tmp16 + _ = v17 + // let binding "step" + tmp18 := checkDerefVar(var_glojure_DOT_core_nth) + tmp19 := lang.Apply(tmp18, []any{v14, int64(1), nil}) + var v20 any = tmp19 + _ = v20 + tmp21 := checkDerefVar(var_glojure_DOT_core_seq) + tmp22 := checkDerefVar(var_glojure_DOT_core_concat) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := lang.Apply(tmp23, []any{sym_if}) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := lang.Apply(tmp25, []any{v17}) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := checkDerefVar(var_glojure_DOT_core_seq) + tmp29 := checkDerefVar(var_glojure_DOT_core_concat) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := lang.Apply(tmp30, []any{sym_glojure_DOT_core_SLASH__DASH__GT_}) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := lang.Apply(tmp32, []any{v9}) + tmp34 := checkDerefVar(var_glojure_DOT_core_list) + tmp35 := lang.Apply(tmp34, []any{v20}) + tmp36 := lang.Apply(tmp29, []any{tmp31, tmp33, tmp35}) + tmp37 := lang.Apply(tmp28, []any{tmp36}) + tmp38 := lang.Apply(tmp27, []any{tmp37}) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := lang.Apply(tmp39, []any{v9}) + tmp41 := lang.Apply(tmp22, []any{tmp24, tmp26, tmp38, tmp40}) + tmp42 := lang.Apply(tmp21, []any{tmp41}) + tmp13 = tmp42 + } // end let + return tmp13 + }) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7573), kw_column, int(20), kw_end_DASH_line, int(7573), kw_end_DASH_column, int(66)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp14 := checkDerefVar(var_glojure_DOT_core_partition) + tmp15 := lang.Apply(tmp14, []any{int64(2), v5}) + tmp16 := lang.Apply(tmp10, []any{tmp13, tmp15}) + var v17 any = tmp16 + _ = v17 + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{sym_glojure_DOT_core_SLASH_let}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := checkDerefVar(var_glojure_DOT_core_apply) + tmp24 := checkDerefVar(var_glojure_DOT_core_vector) + tmp25 := checkDerefVar(var_glojure_DOT_core_seq) + tmp26 := checkDerefVar(var_glojure_DOT_core_concat) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{v9}) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{v4}) + tmp31 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp32 := checkDerefVar(var_glojure_DOT_core_repeat) + tmp33 := lang.Apply(tmp32, []any{v9}) + tmp34 := checkDerefVar(var_glojure_DOT_core_butlast) + tmp35 := lang.Apply(tmp34, []any{v17}) + tmp36 := lang.Apply(tmp31, []any{tmp33, tmp35}) + tmp37 := lang.Apply(tmp26, []any{tmp28, tmp30, tmp36}) + tmp38 := lang.Apply(tmp25, []any{tmp37}) + tmp39 := lang.Apply(tmp23, []any{tmp24, tmp38}) + tmp40 := lang.Apply(tmp22, []any{tmp39}) + tmp41 := checkDerefVar(var_glojure_DOT_core_list) + var tmp42 any + tmp43 := checkDerefVar(var_glojure_DOT_core_empty_QMARK_) + tmp44 := lang.Apply(tmp43, []any{v17}) + if lang.IsTruthy(tmp44) { + tmp42 = v9 + } else { + tmp45 := checkDerefVar(var_glojure_DOT_core_last) + tmp46 := lang.Apply(tmp45, []any{v17}) + tmp42 = tmp46 + } + tmp47 := lang.Apply(tmp41, []any{tmp42}) + tmp48 := lang.Apply(tmp19, []any{tmp21, tmp40, tmp47}) + tmp49 := lang.Apply(tmp18, []any{tmp48}) + tmp6 = tmp49 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_cond_DASH__GT_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_cond_DASH__GT_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // cond->> + { + tmp0 := sym_cond_DASH__GT__GT_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_expr, sym__AMP_, sym_clauses)), kw_doc, "Takes an expression and a set of test/form pairs. Threads expr (via ->>)\n through each form for which the corresponding test expression\n is true. Note that, unlike cond branching, cond->> threading does not short circuit\n after the first true test expression.", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(7581), kw_end_DASH_line, int(7581))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "g" + tmp7 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp8 := lang.Apply(tmp7, nil) + var v9 any = tmp8 + _ = v9 + // let binding "steps" + tmp10 := checkDerefVar(var_glojure_DOT_core_map) + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v12 := args[0] + _ = v12 + var tmp13 any + { // let + // let binding "vec__1005" + var v14 any = v12 + _ = v14 + // let binding "test" + tmp15 := checkDerefVar(var_glojure_DOT_core_nth) + tmp16 := lang.Apply(tmp15, []any{v14, int64(0), nil}) + var v17 any = tmp16 + _ = v17 + // let binding "step" + tmp18 := checkDerefVar(var_glojure_DOT_core_nth) + tmp19 := lang.Apply(tmp18, []any{v14, int64(1), nil}) + var v20 any = tmp19 + _ = v20 + tmp21 := checkDerefVar(var_glojure_DOT_core_seq) + tmp22 := checkDerefVar(var_glojure_DOT_core_concat) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := lang.Apply(tmp23, []any{sym_if}) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := lang.Apply(tmp25, []any{v17}) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := checkDerefVar(var_glojure_DOT_core_seq) + tmp29 := checkDerefVar(var_glojure_DOT_core_concat) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := lang.Apply(tmp30, []any{sym_glojure_DOT_core_SLASH__DASH__GT__GT_}) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := lang.Apply(tmp32, []any{v9}) + tmp34 := checkDerefVar(var_glojure_DOT_core_list) + tmp35 := lang.Apply(tmp34, []any{v20}) + tmp36 := lang.Apply(tmp29, []any{tmp31, tmp33, tmp35}) + tmp37 := lang.Apply(tmp28, []any{tmp36}) + tmp38 := lang.Apply(tmp27, []any{tmp37}) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := lang.Apply(tmp39, []any{v9}) + tmp41 := lang.Apply(tmp22, []any{tmp24, tmp26, tmp38, tmp40}) + tmp42 := lang.Apply(tmp21, []any{tmp41}) + tmp13 = tmp42 + } // end let + return tmp13 + }) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7590), kw_column, int(20), kw_end_DASH_line, int(7590), kw_end_DASH_column, int(67)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp14 := checkDerefVar(var_glojure_DOT_core_partition) + tmp15 := lang.Apply(tmp14, []any{int64(2), v5}) + tmp16 := lang.Apply(tmp10, []any{tmp13, tmp15}) + var v17 any = tmp16 + _ = v17 + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{sym_glojure_DOT_core_SLASH_let}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := checkDerefVar(var_glojure_DOT_core_apply) + tmp24 := checkDerefVar(var_glojure_DOT_core_vector) + tmp25 := checkDerefVar(var_glojure_DOT_core_seq) + tmp26 := checkDerefVar(var_glojure_DOT_core_concat) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{v9}) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{v4}) + tmp31 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp32 := checkDerefVar(var_glojure_DOT_core_repeat) + tmp33 := lang.Apply(tmp32, []any{v9}) + tmp34 := checkDerefVar(var_glojure_DOT_core_butlast) + tmp35 := lang.Apply(tmp34, []any{v17}) + tmp36 := lang.Apply(tmp31, []any{tmp33, tmp35}) + tmp37 := lang.Apply(tmp26, []any{tmp28, tmp30, tmp36}) + tmp38 := lang.Apply(tmp25, []any{tmp37}) + tmp39 := lang.Apply(tmp23, []any{tmp24, tmp38}) + tmp40 := lang.Apply(tmp22, []any{tmp39}) + tmp41 := checkDerefVar(var_glojure_DOT_core_list) + var tmp42 any + tmp43 := checkDerefVar(var_glojure_DOT_core_empty_QMARK_) + tmp44 := lang.Apply(tmp43, []any{v17}) + if lang.IsTruthy(tmp44) { + tmp42 = v9 + } else { + tmp45 := checkDerefVar(var_glojure_DOT_core_last) + tmp46 := lang.Apply(tmp45, []any{v17}) + tmp42 = tmp46 + } + tmp47 := lang.Apply(tmp41, []any{tmp42}) + tmp48 := lang.Apply(tmp19, []any{tmp21, tmp40, tmp47}) + tmp49 := lang.Apply(tmp18, []any{tmp48}) + tmp6 = tmp49 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_cond_DASH__GT__GT_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_cond_DASH__GT__GT_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // condp + { + tmp0 := sym_condp.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_pred, sym_expr, sym__AMP_, sym_clauses)), kw_doc, "Takes a binary predicate, an expression, and a set of clauses.\n Each clause can take the form of either:\n\n test-expr result-expr\n\n test-expr :>> result-fn\n\n Note :>> is an ordinary keyword.\n\n For each clause, (pred test-expr expr) is evaluated. If it returns\n logical true, the clause is a match. If a binary clause matches, the\n result-expr is returned, if a ternary clause matches, its result-fn,\n which must be a unary function, is called with the result of the\n predicate as its argument, the result of that call being the return\n value of condp. A single default expression can follow the clauses,\n and its value will be returned if no clause matches. If no default\n expression is provided and no clause matches, an\n IllegalArgumentException is thrown.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(11), kw_line, int(6353), kw_end_DASH_line, int(6353))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var v6 any = lang.NewList(args[4:]...) + _ = v6 + var tmp7 any + { // let + // let binding "gpred" + tmp8 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp9 := lang.Apply(tmp8, []any{"pred__"}) + var v10 any = tmp9 + _ = v10 + // let binding "gexpr" + tmp11 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp12 := lang.Apply(tmp11, []any{"expr__"}) + var v13 any = tmp12 + _ = v13 + // let binding "emit" + var tmp14 lang.FnFunc + { // function emit + var v15 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v16 := args[0] + _ = v16 + v17 := args[1] + _ = v17 + v18 := args[2] + _ = v18 + var tmp19 any + { // let + // let binding "vec__835" + tmp20 := checkDerefVar(var_glojure_DOT_core_split_DASH_at) + var tmp21 any + tmp22 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp23 := checkDerefVar(var_glojure_DOT_core_second) + tmp24 := lang.Apply(tmp23, []any{v18}) + tmp25 := lang.Apply(tmp22, []any{kw__GT__GT_, tmp24}) + if lang.IsTruthy(tmp25) { + tmp21 = int64(3) + } else { + tmp21 = int64(2) + } + tmp26 := lang.Apply(tmp20, []any{tmp21, v18}) + var v27 any = tmp26 + _ = v27 + // let binding "vec__838" + tmp28 := checkDerefVar(var_glojure_DOT_core_nth) + tmp29 := lang.Apply(tmp28, []any{v27, int64(0), nil}) + var v30 any = tmp29 + _ = v30 + // let binding "a" + tmp31 := checkDerefVar(var_glojure_DOT_core_nth) + tmp32 := lang.Apply(tmp31, []any{v30, int64(0), nil}) + var v33 any = tmp32 + _ = v33 + // let binding "b" + tmp34 := checkDerefVar(var_glojure_DOT_core_nth) + tmp35 := lang.Apply(tmp34, []any{v30, int64(1), nil}) + var v36 any = tmp35 + _ = v36 + // let binding "c" + tmp37 := checkDerefVar(var_glojure_DOT_core_nth) + tmp38 := lang.Apply(tmp37, []any{v30, int64(2), nil}) + var v39 any = tmp38 + _ = v39 + // let binding "clause" + var v40 any = v30 + _ = v40 + // let binding "more" + tmp41 := checkDerefVar(var_glojure_DOT_core_nth) + tmp42 := lang.Apply(tmp41, []any{v27, int64(1), nil}) + var v43 any = tmp42 + _ = v43 + // let binding "n" + tmp44 := checkDerefVar(var_glojure_DOT_core_count) + tmp45 := lang.Apply(tmp44, []any{v40}) + var v46 any = tmp45 + _ = v46 + var tmp47 any + tmp48 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp49 := lang.Apply(tmp48, []any{int64(0), v46}) + if lang.IsTruthy(tmp49) { + tmp50 := checkDerefVar(var_glojure_DOT_core_seq) + tmp51 := checkDerefVar(var_glojure_DOT_core_concat) + tmp52 := checkDerefVar(var_glojure_DOT_core_list) + tmp53 := lang.Apply(tmp52, []any{sym_throw}) + tmp54 := checkDerefVar(var_glojure_DOT_core_list) + tmp55 := checkDerefVar(var_glojure_DOT_core_seq) + tmp56 := checkDerefVar(var_glojure_DOT_core_concat) + tmp57 := checkDerefVar(var_glojure_DOT_core_list) + tmp58 := lang.Apply(tmp57, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_NewIllegalArgumentError}) + tmp59 := checkDerefVar(var_glojure_DOT_core_list) + tmp60 := checkDerefVar(var_glojure_DOT_core_seq) + tmp61 := checkDerefVar(var_glojure_DOT_core_concat) + tmp62 := checkDerefVar(var_glojure_DOT_core_list) + tmp63 := lang.Apply(tmp62, []any{sym_glojure_DOT_core_SLASH_str}) + tmp64 := checkDerefVar(var_glojure_DOT_core_list) + tmp65 := lang.Apply(tmp64, []any{"No matching clause: "}) + tmp66 := checkDerefVar(var_glojure_DOT_core_list) + tmp67 := lang.Apply(tmp66, []any{v17}) + tmp68 := lang.Apply(tmp61, []any{tmp63, tmp65, tmp67}) + tmp69 := lang.Apply(tmp60, []any{tmp68}) + tmp70 := lang.Apply(tmp59, []any{tmp69}) + tmp71 := lang.Apply(tmp56, []any{tmp58, tmp70}) + tmp72 := lang.Apply(tmp55, []any{tmp71}) + tmp73 := lang.Apply(tmp54, []any{tmp72}) + tmp74 := lang.Apply(tmp51, []any{tmp53, tmp73}) + tmp75 := lang.Apply(tmp50, []any{tmp74}) + tmp47 = tmp75 + } else { + var tmp76 any + tmp77 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp78 := lang.Apply(tmp77, []any{int64(1), v46}) + if lang.IsTruthy(tmp78) { + tmp76 = v33 + } else { + var tmp79 any + tmp80 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp81 := lang.Apply(tmp80, []any{int64(2), v46}) + if lang.IsTruthy(tmp81) { + tmp82 := checkDerefVar(var_glojure_DOT_core_seq) + tmp83 := checkDerefVar(var_glojure_DOT_core_concat) + tmp84 := checkDerefVar(var_glojure_DOT_core_list) + tmp85 := lang.Apply(tmp84, []any{sym_if}) + tmp86 := checkDerefVar(var_glojure_DOT_core_list) + tmp87 := checkDerefVar(var_glojure_DOT_core_seq) + tmp88 := checkDerefVar(var_glojure_DOT_core_concat) + tmp89 := checkDerefVar(var_glojure_DOT_core_list) + tmp90 := lang.Apply(tmp89, []any{v16}) + tmp91 := checkDerefVar(var_glojure_DOT_core_list) + tmp92 := lang.Apply(tmp91, []any{v33}) + tmp93 := checkDerefVar(var_glojure_DOT_core_list) + tmp94 := lang.Apply(tmp93, []any{v17}) + tmp95 := lang.Apply(tmp88, []any{tmp90, tmp92, tmp94}) + tmp96 := lang.Apply(tmp87, []any{tmp95}) + tmp97 := lang.Apply(tmp86, []any{tmp96}) + tmp98 := checkDerefVar(var_glojure_DOT_core_list) + tmp99 := lang.Apply(tmp98, []any{v36}) + tmp100 := checkDerefVar(var_glojure_DOT_core_list) + tmp101 := lang.Apply(v15, []any{v16, v17, v43}) + tmp102 := lang.Apply(tmp100, []any{tmp101}) + tmp103 := lang.Apply(tmp83, []any{tmp85, tmp97, tmp99, tmp102}) + tmp104 := lang.Apply(tmp82, []any{tmp103}) + tmp79 = tmp104 + } else { + var tmp105 any + if lang.IsTruthy(kw_else) { + tmp106 := checkDerefVar(var_glojure_DOT_core_seq) + tmp107 := checkDerefVar(var_glojure_DOT_core_concat) + tmp108 := checkDerefVar(var_glojure_DOT_core_list) + tmp109 := lang.Apply(tmp108, []any{sym_glojure_DOT_core_SLASH_if_DASH_let}) + tmp110 := checkDerefVar(var_glojure_DOT_core_list) + tmp111 := checkDerefVar(var_glojure_DOT_core_apply) + tmp112 := checkDerefVar(var_glojure_DOT_core_vector) + tmp113 := checkDerefVar(var_glojure_DOT_core_seq) + tmp114 := checkDerefVar(var_glojure_DOT_core_concat) + tmp115 := checkDerefVar(var_glojure_DOT_core_list) + tmp116 := lang.Apply(tmp115, []any{sym_p__0__auto__}) + tmp117 := checkDerefVar(var_glojure_DOT_core_list) + tmp118 := checkDerefVar(var_glojure_DOT_core_seq) + tmp119 := checkDerefVar(var_glojure_DOT_core_concat) + tmp120 := checkDerefVar(var_glojure_DOT_core_list) + tmp121 := lang.Apply(tmp120, []any{v16}) + tmp122 := checkDerefVar(var_glojure_DOT_core_list) + tmp123 := lang.Apply(tmp122, []any{v33}) + tmp124 := checkDerefVar(var_glojure_DOT_core_list) + tmp125 := lang.Apply(tmp124, []any{v17}) + tmp126 := lang.Apply(tmp119, []any{tmp121, tmp123, tmp125}) + tmp127 := lang.Apply(tmp118, []any{tmp126}) + tmp128 := lang.Apply(tmp117, []any{tmp127}) + tmp129 := lang.Apply(tmp114, []any{tmp116, tmp128}) + tmp130 := lang.Apply(tmp113, []any{tmp129}) + tmp131 := lang.Apply(tmp111, []any{tmp112, tmp130}) + tmp132 := lang.Apply(tmp110, []any{tmp131}) + tmp133 := checkDerefVar(var_glojure_DOT_core_list) + tmp134 := checkDerefVar(var_glojure_DOT_core_seq) + tmp135 := checkDerefVar(var_glojure_DOT_core_concat) + tmp136 := checkDerefVar(var_glojure_DOT_core_list) + tmp137 := lang.Apply(tmp136, []any{v39}) + tmp138 := checkDerefVar(var_glojure_DOT_core_list) + tmp139 := lang.Apply(tmp138, []any{sym_p__0__auto__}) + tmp140 := lang.Apply(tmp135, []any{tmp137, tmp139}) + tmp141 := lang.Apply(tmp134, []any{tmp140}) + tmp142 := lang.Apply(tmp133, []any{tmp141}) + tmp143 := checkDerefVar(var_glojure_DOT_core_list) + tmp144 := lang.Apply(v15, []any{v16, v17, v43}) + tmp145 := lang.Apply(tmp143, []any{tmp144}) + tmp146 := lang.Apply(tmp107, []any{tmp109, tmp132, tmp142, tmp145}) + tmp147 := lang.Apply(tmp106, []any{tmp146}) + tmp105 = tmp147 + } else { + } + tmp79 = tmp105 + } + tmp76 = tmp79 + } + tmp47 = tmp76 + } + tmp19 = tmp47 + } // end let + return tmp19 + }) + v15 = tmp14 + _ = v15 + } + tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6377), kw_column, int(14), kw_end_DASH_line, int(6389), kw_end_DASH_column, int(53)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v17 any = tmp16 + _ = v17 + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{sym_glojure_DOT_core_SLASH_let}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := checkDerefVar(var_glojure_DOT_core_apply) + tmp24 := checkDerefVar(var_glojure_DOT_core_vector) + tmp25 := checkDerefVar(var_glojure_DOT_core_seq) + tmp26 := checkDerefVar(var_glojure_DOT_core_concat) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{v10}) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{v4}) + tmp31 := checkDerefVar(var_glojure_DOT_core_list) + tmp32 := lang.Apply(tmp31, []any{v13}) + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{v5}) + tmp35 := lang.Apply(tmp26, []any{tmp28, tmp30, tmp32, tmp34}) + tmp36 := lang.Apply(tmp25, []any{tmp35}) + tmp37 := lang.Apply(tmp23, []any{tmp24, tmp36}) + tmp38 := lang.Apply(tmp22, []any{tmp37}) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := lang.Apply(v17, []any{v10, v13, v6}) + tmp41 := lang.Apply(tmp39, []any{tmp40}) + tmp42 := lang.Apply(tmp19, []any{tmp21, tmp38, tmp41}) + tmp43 := lang.Apply(tmp18, []any{tmp42}) + tmp7 = tmp43 + } // end let + return tmp7 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_condp = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_condp.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // defn + { + tmp0 := sym_defn.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym_doc_DASH_string_QMARK_, sym_attr_DASH_map_QMARK_, lang.NewVector(sym_params_STAR_), sym_prepost_DASH_map_QMARK_, sym_body), lang.NewVector(sym_name, sym_doc_DASH_string_QMARK_, sym_attr_DASH_map_QMARK_, lang.NewList(lang.NewVector(sym_params_STAR_), sym_prepost_DASH_map_QMARK_, sym_body), sym__PLUS_, sym_attr_DASH_map_QMARK_)), kw_doc, "Same as (def name (fn [params* ] exprs*)) or (def\n name (fn ([params* ] exprs*)+)) with any doc-string or attrs added\n to the var metadata. prepost-map defines a map with optional keys\n :pre and :post that contain collections of pre or post conditions.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(5), kw_column, int(2), kw_line, int(284), kw_end_DASH_line, int(291))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function defn + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp9 := reflect.TypeOf((*lang.Symbol)(nil)) + tmp10 := lang.Apply(tmp8, []any{tmp9, v5}) + if lang.IsTruthy(tmp10) { + } else { + tmp11 := lang.Apply(lang.NewIllegalArgumentError, []any{"First argument to defn must be a symbol"}) + panic(tmp11) + } + _ = tmp7 + var tmp12 any + { // let + // let binding "m" + var tmp13 any + tmp14 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp15 := checkDerefVar(var_glojure_DOT_core_first) + tmp16 := lang.Apply(tmp15, []any{v6}) + tmp17 := lang.Apply(tmp14, []any{tmp16}) + if lang.IsTruthy(tmp17) { + tmp18 := checkDerefVar(var_glojure_DOT_core_first) + tmp19 := lang.Apply(tmp18, []any{v6}) + tmp20 := lang.NewMap(kw_doc, tmp19) + tmp21 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(297), kw_column, int(19), kw_end_DASH_line, int(297), kw_end_DASH_column, int(38)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 = tmp22 + } else { + tmp23 := lang.NewMap() + tmp24 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(298), kw_column, int(19), kw_end_DASH_line, int(298), kw_end_DASH_column, int(20)) + tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 = tmp25 + } + var v26 any = tmp13 + _ = v26 + // let binding "fdecl" + var tmp27 any + tmp28 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp29 := checkDerefVar(var_glojure_DOT_core_first) + tmp30 := lang.Apply(tmp29, []any{v6}) + tmp31 := lang.Apply(tmp28, []any{tmp30}) + if lang.IsTruthy(tmp31) { + tmp32 := checkDerefVar(var_glojure_DOT_core_next) + tmp33 := lang.Apply(tmp32, []any{v6}) + tmp27 = tmp33 + } else { + tmp27 = v6 + } + var v34 any = tmp27 + _ = v34 + // let binding "m" + var tmp35 any + tmp36 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp37 := checkDerefVar(var_glojure_DOT_core_first) + tmp38 := lang.Apply(tmp37, []any{v34}) + tmp39 := lang.Apply(tmp36, []any{tmp38}) + if lang.IsTruthy(tmp39) { + tmp40 := checkDerefVar(var_glojure_DOT_core_conj) + tmp41 := checkDerefVar(var_glojure_DOT_core_first) + tmp42 := lang.Apply(tmp41, []any{v34}) + tmp43 := lang.Apply(tmp40, []any{v26, tmp42}) + tmp35 = tmp43 + } else { + tmp35 = v26 + } + var v44 any = tmp35 + _ = v44 + // let binding "fdecl" + var tmp45 any + tmp46 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp47 := checkDerefVar(var_glojure_DOT_core_first) + tmp48 := lang.Apply(tmp47, []any{v34}) + tmp49 := lang.Apply(tmp46, []any{tmp48}) + if lang.IsTruthy(tmp49) { + tmp50 := checkDerefVar(var_glojure_DOT_core_next) + tmp51 := lang.Apply(tmp50, []any{v34}) + tmp45 = tmp51 + } else { + tmp45 = v34 + } + var v52 any = tmp45 + _ = v52 + // let binding "fdecl" + var tmp53 any + tmp54 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp55 := checkDerefVar(var_glojure_DOT_core_first) + tmp56 := lang.Apply(tmp55, []any{v52}) + tmp57 := lang.Apply(tmp54, []any{tmp56}) + if lang.IsTruthy(tmp57) { + tmp58 := checkDerefVar(var_glojure_DOT_core_list) + tmp59 := lang.Apply(tmp58, []any{v52}) + tmp53 = tmp59 + } else { + tmp53 = v52 + } + var v60 any = tmp53 + _ = v60 + // let binding "m" + var tmp61 any + tmp62 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp63 := checkDerefVar(var_glojure_DOT_core_last) + tmp64 := lang.Apply(tmp63, []any{v60}) + tmp65 := lang.Apply(tmp62, []any{tmp64}) + if lang.IsTruthy(tmp65) { + tmp66 := checkDerefVar(var_glojure_DOT_core_conj) + tmp67 := checkDerefVar(var_glojure_DOT_core_last) + tmp68 := lang.Apply(tmp67, []any{v60}) + tmp69 := lang.Apply(tmp66, []any{v44, tmp68}) + tmp61 = tmp69 + } else { + tmp61 = v44 + } + var v70 any = tmp61 + _ = v70 + // let binding "fdecl" + var tmp71 any + tmp72 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp73 := checkDerefVar(var_glojure_DOT_core_last) + tmp74 := lang.Apply(tmp73, []any{v60}) + tmp75 := lang.Apply(tmp72, []any{tmp74}) + if lang.IsTruthy(tmp75) { + tmp76 := checkDerefVar(var_glojure_DOT_core_butlast) + tmp77 := lang.Apply(tmp76, []any{v60}) + tmp71 = tmp77 + } else { + tmp71 = v60 + } + var v78 any = tmp71 + _ = v78 + // let binding "m" + tmp79 := checkDerefVar(var_glojure_DOT_core_conj) + tmp80 := checkDerefVar(var_glojure_DOT_core_list) + tmp81 := checkDerefVar(var_glojure_DOT_core_sigs) + tmp82 := lang.Apply(tmp81, []any{v78}) + tmp83 := lang.Apply(tmp80, []any{sym_quote, tmp82}) + tmp84 := lang.NewMap(kw_arglists, tmp83) + tmp85 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(317), kw_column, int(23), kw_end_DASH_line, int(317), kw_end_DASH_column, int(60)) + tmp86, err := lang.WithMeta(tmp84, tmp85.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp87 := lang.Apply(tmp79, []any{tmp86, v70}) + var v88 any = tmp87 + _ = v88 + // let binding "m" + var tmp89 any + { // let + // let binding "inline" + tmp90 := lang.Apply(kw_inline, []any{v88}) + var v91 any = tmp90 + _ = v91 + // let binding "ifn" + tmp92 := checkDerefVar(var_glojure_DOT_core_first) + tmp93 := lang.Apply(tmp92, []any{v91}) + var v94 any = tmp93 + _ = v94 + // let binding "iname" + tmp95 := checkDerefVar(var_glojure_DOT_core_second) + tmp96 := lang.Apply(tmp95, []any{v91}) + var v97 any = tmp96 + _ = v97 + var tmp98 any + var tmp99 any + tmp100 := lang.Apply(lang.Equiv, []any{sym_fn, v94}) + if lang.IsTruthy(tmp100) { + var tmp101 any + tmp102 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp103 := reflect.TypeOf((*lang.Symbol)(nil)) + tmp104 := lang.Apply(tmp102, []any{tmp103, v97}) + if lang.IsTruthy(tmp104) { + tmp101 = false + } else { + tmp101 = true + } + tmp99 = tmp101 + } else { + } + if lang.IsTruthy(tmp99) { + tmp105 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp106 := checkDerefVar(var_glojure_DOT_core_cons) + tmp107 := checkDerefVar(var_glojure_DOT_core_cons) + tmp108, ok := lang.FieldOrMethod(v5, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "Name"))) + } + var tmp109 any + switch reflect.TypeOf(tmp108).Kind() { + case reflect.Func: + tmp109 = lang.Apply(tmp108, nil) + default: + tmp109 = tmp108 + } + tmp110 := lang.Apply(lang.ConcatStrings, []any{tmp109, "__inliner"}) + tmp111 := lang.Apply(lang.NewSymbol, []any{tmp110}) + tmp112 := checkDerefVar(var_glojure_DOT_core_next) + tmp113 := lang.Apply(tmp112, []any{v91}) + tmp114 := lang.Apply(tmp107, []any{tmp111, tmp113}) + tmp115 := lang.Apply(tmp106, []any{v94, tmp114}) + tmp116 := lang.Apply(tmp105, []any{v88, kw_inline, tmp115}) + tmp98 = tmp116 + } else { + tmp98 = v88 + } + tmp89 = tmp98 + } // end let + var v90 any = tmp89 + _ = v90 + // let binding "m" + tmp91 := checkDerefVar(var_glojure_DOT_core_conj) + var tmp92 any + tmp93 := checkDerefVar(var_glojure_DOT_core_meta) + tmp94 := lang.Apply(tmp93, []any{v5}) + if lang.IsTruthy(tmp94) { + tmp95 := checkDerefVar(var_glojure_DOT_core_meta) + tmp96 := lang.Apply(tmp95, []any{v5}) + tmp92 = tmp96 + } else { + tmp97 := lang.NewMap() + tmp98 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(328), kw_column, int(51), kw_end_DASH_line, int(328), kw_end_DASH_column, int(52)) + tmp99, err := lang.WithMeta(tmp97, tmp98.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp92 = tmp99 + } + tmp100 := lang.Apply(tmp91, []any{tmp92, v90}) + var v101 any = tmp100 + _ = v101 + tmp102 := checkDerefVar(var_glojure_DOT_core_list) + tmp103 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp104 := lang.Apply(tmp103, []any{v5, v101}) + tmp105 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp106 := checkDerefVar(var_glojure_DOT_core_cons) + tmp107 := lang.Apply(tmp106, []any{sym_glojure_DOT_core_SLASH_fn, v78}) + tmp108 := lang.Apply(kw_tag, []any{v101}) + tmp109 := lang.NewMap(kw_rettag, tmp108) + tmp110 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(333), kw_column, int(37), kw_end_DASH_line, int(333), kw_end_DASH_column, int(54)) + tmp111, err := lang.WithMeta(tmp109, tmp110.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp112 := lang.Apply(tmp105, []any{tmp107, tmp111}) + tmp113 := lang.Apply(tmp102, []any{sym_def, tmp104, tmp112}) + tmp12 = tmp113 + } // end let + return tmp12 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(291), kw_column, int(7), kw_end_DASH_line, int(333), kw_end_DASH_column, int(58))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_defn = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_defn.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // destructure + { + tmp0 := sym_destructure.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4400), kw_column, int(7), kw_end_DASH_line, int(4400), kw_end_DASH_column, int(17), kw_arglists, lang.NewList(lang.NewVector(sym_bindings)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "bents" + tmp4 := checkDerefVar(var_glojure_DOT_core_partition) + tmp5 := lang.Apply(tmp4, []any{int64(2), v2}) + var v6 any = tmp5 + _ = v6 + // let binding "pb" + var tmp7 lang.FnFunc + { // function pb + var v8 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v9 := args[0] + _ = v9 + v10 := args[1] + _ = v10 + v11 := args[2] + _ = v11 + var tmp12 any + { // let + // let binding "pvec" + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v14 := args[0] + _ = v14 + v15 := args[1] + _ = v15 + v16 := args[2] + _ = v16 + var tmp17 any + { // let + // let binding "gvec" + tmp18 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp19 := lang.Apply(tmp18, []any{"vec__"}) + var v20 any = tmp19 + _ = v20 + // let binding "gseq" + tmp21 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp22 := lang.Apply(tmp21, []any{"seq__"}) + var v23 any = tmp22 + _ = v23 + // let binding "gfirst" + tmp24 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp25 := lang.Apply(tmp24, []any{"first__"}) + var v26 any = tmp25 + _ = v26 + // let binding "has-rest" + tmp27 := checkDerefVar(var_glojure_DOT_core_some) + tmp28 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{sym__AMP_})) + tmp29 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4408), kw_column, int(43), kw_end_DASH_line, int(4408), kw_end_DASH_column, int(47)) + tmp30, err := lang.WithMeta(tmp28, tmp29.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp31 := lang.Apply(tmp27, []any{tmp30, v15}) + var v32 any = tmp31 + _ = v32 + var tmp33 any + { // let + // let binding "ret" + var tmp34 any + { // let + // let binding "ret" + tmp35 := checkDerefVar(var_glojure_DOT_core_conj) + tmp36 := lang.Apply(tmp35, []any{v14, v20, v16}) + var v37 any = tmp36 + _ = v37 + var tmp38 any + if lang.IsTruthy(v32) { + tmp39 := checkDerefVar(var_glojure_DOT_core_conj) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{sym_glojure_DOT_core_SLASH_seq, v20}) + tmp42 := lang.Apply(tmp39, []any{v37, v23, tmp41}) + tmp38 = tmp42 + } else { + tmp38 = v37 + } + tmp34 = tmp38 + } // end let + var v35 any = tmp34 + _ = v35 + // let binding "n" + var v36 any = int64(0) + _ = v36 + // let binding "bs" + var v37 any = v15 + _ = v37 + // let binding "seen-rest?" + var v38 any = false + _ = v38 + for { + var tmp39 any + tmp40 := checkDerefVar(var_glojure_DOT_core_seq) + tmp41 := lang.Apply(tmp40, []any{v37}) + if lang.IsTruthy(tmp41) { + var tmp42 any + { // let + // let binding "firstb" + tmp43 := checkDerefVar(var_glojure_DOT_core_first) + tmp44 := lang.Apply(tmp43, []any{v37}) + var v45 any = tmp44 + _ = v45 + var tmp46 any + tmp47 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp48 := lang.Apply(tmp47, []any{v45, sym__AMP_}) + if lang.IsTruthy(tmp48) { + tmp50 := checkDerefVar(var_glojure_DOT_core_second) + tmp51 := lang.Apply(tmp50, []any{v37}) + tmp52 := lang.Apply(v8, []any{v35, tmp51, v23}) + var tmp49 any = tmp52 + var tmp53 any = v36 + tmp55 := checkDerefVar(var_glojure_DOT_core_nnext) + tmp56 := lang.Apply(tmp55, []any{v37}) + var tmp54 any = tmp56 + var tmp57 any = true + v35 = tmp49 + v36 = tmp53 + v37 = tmp54 + v38 = tmp57 + continue + } else { + var tmp58 any + tmp59 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp60 := lang.Apply(tmp59, []any{v45, kw_as}) + if lang.IsTruthy(tmp60) { + tmp61 := checkDerefVar(var_glojure_DOT_core_second) + tmp62 := lang.Apply(tmp61, []any{v37}) + tmp63 := lang.Apply(v8, []any{v35, tmp62, v20}) + tmp58 = tmp63 + } else { + var tmp64 any + if lang.IsTruthy(kw_else) { + var tmp65 any + if lang.IsTruthy(v38) { + tmp66 := lang.Apply(errors5.New, []any{"Unsupported binding form, only :as can follow & parameter"}) + panic(tmp66) + } else { + var tmp68 any + if lang.IsTruthy(v32) { + tmp69 := checkDerefVar(var_glojure_DOT_core_conj) + tmp70 := checkDerefVar(var_glojure_DOT_core_seq) + tmp71 := checkDerefVar(var_glojure_DOT_core_concat) + tmp72 := checkDerefVar(var_glojure_DOT_core_list) + tmp73 := lang.Apply(tmp72, []any{sym_glojure_DOT_core_SLASH_first}) + tmp74 := checkDerefVar(var_glojure_DOT_core_list) + tmp75 := lang.Apply(tmp74, []any{v23}) + tmp76 := lang.Apply(tmp71, []any{tmp73, tmp75}) + tmp77 := lang.Apply(tmp70, []any{tmp76}) + tmp78 := checkDerefVar(var_glojure_DOT_core_seq) + tmp79 := checkDerefVar(var_glojure_DOT_core_concat) + tmp80 := checkDerefVar(var_glojure_DOT_core_list) + tmp81 := lang.Apply(tmp80, []any{sym_glojure_DOT_core_SLASH_next}) + tmp82 := checkDerefVar(var_glojure_DOT_core_list) + tmp83 := lang.Apply(tmp82, []any{v23}) + tmp84 := lang.Apply(tmp79, []any{tmp81, tmp83}) + tmp85 := lang.Apply(tmp78, []any{tmp84}) + tmp86 := lang.Apply(tmp69, []any{v35, v26, tmp77, v23, tmp85}) + tmp68 = tmp86 + } else { + tmp68 = v35 + } + var tmp87 any + if lang.IsTruthy(v32) { + tmp87 = v26 + } else { + tmp88 := checkDerefVar(var_glojure_DOT_core_list) + tmp89 := lang.Apply(tmp88, []any{sym_glojure_DOT_core_SLASH_nth, v20, v36, nil}) + tmp87 = tmp89 + } + tmp90 := lang.Apply(v8, []any{tmp68, v45, tmp87}) + var tmp67 any = tmp90 + tmp92 := checkDerefVar(var_glojure_DOT_core_inc) + tmp93 := lang.Apply(tmp92, []any{v36}) + var tmp91 any = tmp93 + tmp95 := checkDerefVar(var_glojure_DOT_core_next) + tmp96 := lang.Apply(tmp95, []any{v37}) + var tmp94 any = tmp96 + var tmp97 any = v38 + v35 = tmp67 + v36 = tmp91 + v37 = tmp94 + v38 = tmp97 + continue + } + tmp64 = tmp65 + } else { + } + tmp58 = tmp64 + } + tmp46 = tmp58 + } + tmp42 = tmp46 + } // end let + tmp39 = tmp42 + } else { + tmp39 = v35 + } + tmp33 = tmp39 + break + } + } // end let + tmp17 = tmp33 + } // end let + return tmp17 + }) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4404), kw_column, int(20), kw_end_DASH_line, int(4438), kw_end_DASH_column, int(34)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v16 any = tmp15 + _ = v16 + // let binding "pmap" + var tmp17 lang.FnFunc + tmp17 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v18 := args[0] + _ = v18 + v19 := args[1] + _ = v19 + v20 := args[2] + _ = v20 + var tmp21 any + { // let + // let binding "gmap" + tmp22 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp23 := lang.Apply(tmp22, []any{"map__"}) + var v24 any = tmp23 + _ = v24 + // let binding "gmapseq" + tmp25 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp26 := lang.NewMap(kw_tag, sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_ISeq) + tmp27 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4442), kw_column, int(52), kw_end_DASH_line, int(4442), kw_end_DASH_column, int(103)) + tmp28, err := lang.WithMeta(tmp26, tmp27.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp29 := lang.Apply(tmp25, []any{v24, tmp28}) + var v30 any = tmp29 + _ = v30 + // let binding "defaults" + tmp31 := lang.Apply(kw_or, []any{v19}) + var v32 any = tmp31 + _ = v32 + var tmp33 any + { // let + // let binding "ret" + var tmp34 lang.FnFunc + tmp34 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v35 := args[0] + _ = v35 + var tmp36 any + tmp37 := lang.Apply(kw_as, []any{v19}) + if lang.IsTruthy(tmp37) { + tmp38 := checkDerefVar(var_glojure_DOT_core_conj) + tmp39 := lang.Apply(kw_as, []any{v19}) + tmp40 := lang.Apply(tmp38, []any{v35, tmp39, v24}) + tmp36 = tmp40 + } else { + tmp36 = v35 + } + return tmp36 + }) + tmp35 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4450), kw_column, int(40), kw_end_DASH_line, int(4453), kw_end_DASH_column, int(48)) + tmp36, err := lang.WithMeta(tmp34, tmp35.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp37 := checkDerefVar(var_glojure_DOT_core_conj) + tmp38 := checkDerefVar(var_glojure_DOT_core_conj) + tmp39 := checkDerefVar(var_glojure_DOT_core_conj) + tmp40 := checkDerefVar(var_glojure_DOT_core_conj) + tmp41 := lang.Apply(tmp40, []any{v18, v24}) + tmp42 := lang.Apply(tmp39, []any{tmp41, v20}) + tmp43 := lang.Apply(tmp38, []any{tmp42, v24}) + tmp44 := checkDerefVar(var_glojure_DOT_core_seq) + tmp45 := checkDerefVar(var_glojure_DOT_core_concat) + tmp46 := checkDerefVar(var_glojure_DOT_core_list) + tmp47 := lang.Apply(tmp46, []any{sym_if}) + tmp48 := checkDerefVar(var_glojure_DOT_core_list) + tmp49 := checkDerefVar(var_glojure_DOT_core_seq) + tmp50 := checkDerefVar(var_glojure_DOT_core_concat) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := lang.Apply(tmp51, []any{sym_glojure_DOT_core_SLASH_seq_QMARK_}) + tmp53 := checkDerefVar(var_glojure_DOT_core_list) + tmp54 := lang.Apply(tmp53, []any{v24}) + tmp55 := lang.Apply(tmp50, []any{tmp52, tmp54}) + tmp56 := lang.Apply(tmp49, []any{tmp55}) + tmp57 := lang.Apply(tmp48, []any{tmp56}) + tmp58 := checkDerefVar(var_glojure_DOT_core_list) + tmp59 := checkDerefVar(var_glojure_DOT_core_seq) + tmp60 := checkDerefVar(var_glojure_DOT_core_concat) + tmp61 := checkDerefVar(var_glojure_DOT_core_list) + tmp62 := lang.Apply(tmp61, []any{sym_if}) + tmp63 := checkDerefVar(var_glojure_DOT_core_list) + tmp64 := checkDerefVar(var_glojure_DOT_core_seq) + tmp65 := checkDerefVar(var_glojure_DOT_core_concat) + tmp66 := checkDerefVar(var_glojure_DOT_core_list) + tmp67 := lang.Apply(tmp66, []any{sym_glojure_DOT_core_SLASH_next}) + tmp68 := checkDerefVar(var_glojure_DOT_core_list) + tmp69 := lang.Apply(tmp68, []any{v30}) + tmp70 := lang.Apply(tmp65, []any{tmp67, tmp69}) + tmp71 := lang.Apply(tmp64, []any{tmp70}) + tmp72 := lang.Apply(tmp63, []any{tmp71}) + tmp73 := checkDerefVar(var_glojure_DOT_core_list) + tmp74 := checkDerefVar(var_glojure_DOT_core_seq) + tmp75 := checkDerefVar(var_glojure_DOT_core_concat) + tmp76 := checkDerefVar(var_glojure_DOT_core_list) + tmp77 := lang.Apply(tmp76, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_NewPersistentArrayMapAsIfByAssoc}) + tmp78 := checkDerefVar(var_glojure_DOT_core_list) + tmp79 := checkDerefVar(var_glojure_DOT_core_seq) + tmp80 := checkDerefVar(var_glojure_DOT_core_concat) + tmp81 := checkDerefVar(var_glojure_DOT_core_list) + tmp82 := lang.Apply(tmp81, []any{sym_glojure_DOT_core_SLASH_to_DASH_array}) + tmp83 := checkDerefVar(var_glojure_DOT_core_list) + tmp84 := lang.Apply(tmp83, []any{v30}) + tmp85 := lang.Apply(tmp80, []any{tmp82, tmp84}) + tmp86 := lang.Apply(tmp79, []any{tmp85}) + tmp87 := lang.Apply(tmp78, []any{tmp86}) + tmp88 := lang.Apply(tmp75, []any{tmp77, tmp87}) + tmp89 := lang.Apply(tmp74, []any{tmp88}) + tmp90 := lang.Apply(tmp73, []any{tmp89}) + tmp91 := checkDerefVar(var_glojure_DOT_core_list) + tmp92 := checkDerefVar(var_glojure_DOT_core_seq) + tmp93 := checkDerefVar(var_glojure_DOT_core_concat) + tmp94 := checkDerefVar(var_glojure_DOT_core_list) + tmp95 := lang.Apply(tmp94, []any{sym_if}) + tmp96 := checkDerefVar(var_glojure_DOT_core_list) + tmp97 := checkDerefVar(var_glojure_DOT_core_seq) + tmp98 := checkDerefVar(var_glojure_DOT_core_concat) + tmp99 := checkDerefVar(var_glojure_DOT_core_list) + tmp100 := lang.Apply(tmp99, []any{sym_glojure_DOT_core_SLASH_seq}) + tmp101 := checkDerefVar(var_glojure_DOT_core_list) + tmp102 := lang.Apply(tmp101, []any{v30}) + tmp103 := lang.Apply(tmp98, []any{tmp100, tmp102}) + tmp104 := lang.Apply(tmp97, []any{tmp103}) + tmp105 := lang.Apply(tmp96, []any{tmp104}) + tmp106 := checkDerefVar(var_glojure_DOT_core_list) + tmp107 := checkDerefVar(var_glojure_DOT_core_seq) + tmp108 := checkDerefVar(var_glojure_DOT_core_concat) + tmp109 := checkDerefVar(var_glojure_DOT_core_list) + tmp110 := lang.Apply(tmp109, []any{sym_glojure_DOT_core_SLASH_first}) + tmp111 := checkDerefVar(var_glojure_DOT_core_list) + tmp112 := lang.Apply(tmp111, []any{v30}) + tmp113 := lang.Apply(tmp108, []any{tmp110, tmp112}) + tmp114 := lang.Apply(tmp107, []any{tmp113}) + tmp115 := lang.Apply(tmp106, []any{tmp114}) + tmp116 := checkDerefVar(var_glojure_DOT_core_list) + tmp117 := lang.Apply(tmp116, []any{sym_glojure_DOT_lang_DOT_PersistentArrayMap_SLASH_EMPTY}) + tmp118 := lang.Apply(tmp93, []any{tmp95, tmp105, tmp115, tmp117}) + tmp119 := lang.Apply(tmp92, []any{tmp118}) + tmp120 := lang.Apply(tmp91, []any{tmp119}) + tmp121 := lang.Apply(tmp60, []any{tmp62, tmp72, tmp90, tmp120}) + tmp122 := lang.Apply(tmp59, []any{tmp121}) + tmp123 := lang.Apply(tmp58, []any{tmp122}) + tmp124 := checkDerefVar(var_glojure_DOT_core_list) + tmp125 := lang.Apply(tmp124, []any{v24}) + tmp126 := lang.Apply(tmp45, []any{tmp47, tmp57, tmp123, tmp125}) + tmp127 := lang.Apply(tmp44, []any{tmp126}) + tmp128 := lang.Apply(tmp37, []any{tmp43, tmp127}) + tmp129 := lang.Apply(tmp36, []any{tmp128}) + var v130 any = tmp129 + _ = v130 + // let binding "bes" + var tmp131 any + { // let + // let binding "transforms" + tmp132 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp133 lang.FnFunc + tmp133 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v134 := args[0] + _ = v134 + v135 := args[1] + _ = v135 + var tmp136 any + tmp137 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp138 := lang.Apply(tmp137, []any{v135}) + if lang.IsTruthy(tmp138) { + var tmp139 any + { // let + // let binding "mkns" + tmp140 := checkDerefVar(var_glojure_DOT_core_namespace) + tmp141 := lang.Apply(tmp140, []any{v135}) + var v142 any = tmp141 + _ = v142 + // let binding "mkn" + tmp143 := checkDerefVar(var_glojure_DOT_core_name) + tmp144 := lang.Apply(tmp143, []any{v135}) + var v145 any = tmp144 + _ = v145 + var tmp146 any + tmp147 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp148 := lang.Apply(tmp147, []any{v145, "keys"}) + if lang.IsTruthy(tmp148) { + tmp149 := checkDerefVar(var_glojure_DOT_core_assoc) + var tmp150 lang.FnFunc + tmp150 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v151 := args[0] + _ = v151 + tmp152 := checkDerefVar(var_glojure_DOT_core_keyword) + var tmp153 any + { // let + // let binding "or__0__auto__" + var v154 any = v142 + _ = v154 + var tmp155 any + if lang.IsTruthy(v154) { + tmp155 = v154 + } else { + tmp156 := checkDerefVar(var_glojure_DOT_core_namespace) + tmp157 := lang.Apply(tmp156, []any{v151}) + tmp155 = tmp157 + } + tmp153 = tmp155 + } // end let + tmp154 := checkDerefVar(var_glojure_DOT_core_name) + tmp155 := lang.Apply(tmp154, []any{v151}) + tmp156 := lang.Apply(tmp152, []any{tmp153, tmp155}) + return tmp156 + }) + tmp151 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4460), kw_column, int(93), kw_end_DASH_line, int(4460), kw_end_DASH_column, int(135)) + tmp152, err := lang.WithMeta(tmp150, tmp151.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp153 := lang.Apply(tmp149, []any{v134, v135, tmp152}) + tmp146 = tmp153 + } else { + var tmp154 any + tmp155 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp156 := lang.Apply(tmp155, []any{v145, "syms"}) + if lang.IsTruthy(tmp156) { + tmp157 := checkDerefVar(var_glojure_DOT_core_assoc) + var tmp158 lang.FnFunc + tmp158 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v159 := args[0] + _ = v159 + tmp160 := checkDerefVar(var_glojure_DOT_core_list) + tmp161 := checkDerefVar(var_glojure_DOT_core_symbol) + var tmp162 any + { // let + // let binding "or__0__auto__" + var v163 any = v142 + _ = v163 + var tmp164 any + if lang.IsTruthy(v163) { + tmp164 = v163 + } else { + tmp165 := checkDerefVar(var_glojure_DOT_core_namespace) + tmp166 := lang.Apply(tmp165, []any{v159}) + tmp164 = tmp166 + } + tmp162 = tmp164 + } // end let + tmp163 := checkDerefVar(var_glojure_DOT_core_name) + tmp164 := lang.Apply(tmp163, []any{v159}) + tmp165 := lang.Apply(tmp161, []any{tmp162, tmp164}) + tmp166 := lang.Apply(tmp160, []any{sym_quote, tmp165}) + return tmp166 + }) + tmp159 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4461), kw_column, int(93), kw_end_DASH_line, int(4461), kw_end_DASH_column, int(148)) + tmp160, err := lang.WithMeta(tmp158, tmp159.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp161 := lang.Apply(tmp157, []any{v134, v135, tmp160}) + tmp154 = tmp161 + } else { + var tmp162 any + tmp163 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp164 := lang.Apply(tmp163, []any{v145, "strs"}) + if lang.IsTruthy(tmp164) { + tmp165 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp166 := checkDerefVar(var_glojure_DOT_core_str) + tmp167 := lang.Apply(tmp165, []any{v134, v135, tmp166}) + tmp162 = tmp167 + } else { + var tmp168 any + if lang.IsTruthy(kw_else) { + tmp168 = v134 + } else { + } + tmp162 = tmp168 + } + tmp154 = tmp162 + } + tmp146 = tmp154 + } + tmp139 = tmp146 + } // end let + tmp136 = tmp139 + } else { + tmp136 = v134 + } + return tmp136 + }) + tmp134 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4456), kw_column, int(45), kw_end_DASH_line, int(4464), kw_end_DASH_column, int(60)) + tmp135, err := lang.WithMeta(tmp133, tmp134.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp136 := lang.NewMap() + tmp137 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4465), kw_column, int(45), kw_end_DASH_line, int(4465), kw_end_DASH_column, int(46)) + tmp138, err := lang.WithMeta(tmp136, tmp137.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp139 := checkDerefVar(var_glojure_DOT_core_keys) + tmp140 := lang.Apply(tmp139, []any{v19}) + tmp141 := lang.Apply(tmp132, []any{tmp135, tmp138, tmp140}) + var v142 any = tmp141 + _ = v142 + tmp143 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp144 lang.FnFunc + tmp144 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v145 := args[0] + _ = v145 + v146 := args[1] + _ = v146 + tmp147 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp148 lang.FnFunc + tmp148 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v149 := args[0] + _ = v149 + v150 := args[1] + _ = v150 + tmp151 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp152 := checkDerefVar(var_glojure_DOT_core_val) + tmp153 := lang.Apply(tmp152, []any{v146}) + tmp154 := lang.Apply(tmp153, []any{v150}) + tmp155 := lang.Apply(tmp151, []any{v149, v150, tmp154}) + return tmp155 + }) + tmp149 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4469), kw_column, int(52), kw_end_DASH_line, int(4469), kw_end_DASH_column, int(82)) + tmp150, err := lang.WithMeta(tmp148, tmp149.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp151 := checkDerefVar(var_glojure_DOT_core_dissoc) + tmp152 := checkDerefVar(var_glojure_DOT_core_key) + tmp153 := lang.Apply(tmp152, []any{v146}) + tmp154 := lang.Apply(tmp151, []any{v145, tmp153}) + tmp155 := checkDerefVar(var_glojure_DOT_core_key) + tmp156 := lang.Apply(tmp155, []any{v146}) + tmp157 := lang.Apply(tmp156, []any{v145}) + tmp158 := lang.Apply(tmp147, []any{tmp150, tmp154, tmp157}) + return tmp158 + }) + tmp145 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4468), kw_column, int(41), kw_end_DASH_line, int(4471), kw_end_DASH_column, int(70)) + tmp146, err := lang.WithMeta(tmp144, tmp145.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp147 := checkDerefVar(var_glojure_DOT_core_dissoc) + tmp148 := lang.Apply(tmp147, []any{v19, kw_as, kw_or}) + tmp149 := lang.Apply(tmp143, []any{tmp146, tmp148, v142}) + tmp131 = tmp149 + } // end let + var v132 any = tmp131 + _ = v132 + for { + var tmp133 any + tmp134 := checkDerefVar(var_glojure_DOT_core_seq) + tmp135 := lang.Apply(tmp134, []any{v132}) + if lang.IsTruthy(tmp135) { + var tmp136 any + { // let + // let binding "bb" + tmp137 := checkDerefVar(var_glojure_DOT_core_key) + tmp138 := checkDerefVar(var_glojure_DOT_core_first) + tmp139 := lang.Apply(tmp138, []any{v132}) + tmp140 := lang.Apply(tmp137, []any{tmp139}) + var v141 any = tmp140 + _ = v141 + // let binding "bk" + tmp142 := checkDerefVar(var_glojure_DOT_core_val) + tmp143 := checkDerefVar(var_glojure_DOT_core_first) + tmp144 := lang.Apply(tmp143, []any{v132}) + tmp145 := lang.Apply(tmp142, []any{tmp144}) + var v146 any = tmp145 + _ = v146 + // let binding "local" + var tmp147 any + tmp148 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp149 := reflect.TypeOf((*lang.Named)(nil)).Elem() + tmp150 := lang.Apply(tmp148, []any{tmp149, v141}) + if lang.IsTruthy(tmp150) { + tmp151 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp152 := checkDerefVar(var_glojure_DOT_core_symbol) + tmp153 := checkDerefVar(var_glojure_DOT_core_name) + tmp154 := lang.Apply(tmp153, []any{v141}) + tmp155 := lang.Apply(tmp152, []any{nil, tmp154}) + tmp156 := checkDerefVar(var_glojure_DOT_core_meta) + tmp157 := lang.Apply(tmp156, []any{v141}) + tmp158 := lang.Apply(tmp151, []any{tmp155, tmp157}) + tmp147 = tmp158 + } else { + tmp147 = v141 + } + var v159 any = tmp147 + _ = v159 + // let binding "bv" + var tmp160 any + tmp161 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp162 := lang.Apply(tmp161, []any{v32, v159}) + if lang.IsTruthy(tmp162) { + tmp163 := checkDerefVar(var_glojure_DOT_core_list) + tmp164 := lang.Apply(v32, []any{v159}) + tmp165 := lang.Apply(tmp163, []any{sym_glojure_DOT_core_SLASH_get, v24, v146, tmp164}) + tmp160 = tmp165 + } else { + tmp166 := checkDerefVar(var_glojure_DOT_core_list) + tmp167 := lang.Apply(tmp166, []any{sym_glojure_DOT_core_SLASH_get, v24, v146}) + tmp160 = tmp167 + } + var v168 any = tmp160 + _ = v168 + var tmp170 any + tmp171 := checkDerefVar(var_glojure_DOT_core_ident_QMARK_) + tmp172 := lang.Apply(tmp171, []any{v141}) + if lang.IsTruthy(tmp172) { + tmp173 := checkDerefVar(var_glojure_DOT_core_conj) + tmp174 := lang.Apply(tmp173, []any{v130, v159, v168}) + tmp170 = tmp174 + } else { + tmp175 := lang.Apply(v8, []any{v130, v141, v168}) + tmp170 = tmp175 + } + var tmp169 any = tmp170 + tmp177 := checkDerefVar(var_glojure_DOT_core_next) + tmp178 := lang.Apply(tmp177, []any{v132}) + var tmp176 any = tmp178 + v130 = tmp169 + v132 = tmp176 + continue + } // end let + tmp133 = tmp136 + } else { + tmp133 = v130 + } + tmp33 = tmp133 + break + } + } // end let + tmp21 = tmp33 + } // end let + return tmp21 + }) + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4440), kw_column, int(20), kw_end_DASH_line, int(4485), kw_end_DASH_column, int(34)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v20 any = tmp19 + _ = v20 + var tmp21 any + tmp22 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp23 := lang.Apply(tmp22, []any{v10}) + if lang.IsTruthy(tmp23) { + tmp24 := checkDerefVar(var_glojure_DOT_core_conj) + tmp25 := checkDerefVar(var_glojure_DOT_core_conj) + tmp26 := lang.Apply(tmp25, []any{v9, v10}) + tmp27 := lang.Apply(tmp24, []any{tmp26, v11}) + tmp21 = tmp27 + } else { + var tmp28 any + tmp29 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp30 := lang.Apply(tmp29, []any{v10}) + if lang.IsTruthy(tmp30) { + tmp31 := lang.Apply(v16, []any{v9, v10, v11}) + tmp28 = tmp31 + } else { + var tmp32 any + tmp33 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp34 := lang.Apply(tmp33, []any{v10}) + if lang.IsTruthy(tmp34) { + tmp35 := lang.Apply(v20, []any{v9, v10, v11}) + tmp32 = tmp35 + } else { + var tmp36 any + if lang.IsTruthy(kw_else) { + tmp37 := checkDerefVar(var_glojure_DOT_core_str) + tmp38 := lang.Apply(tmp37, []any{"Unsupported binding form: ", v10}) + tmp39 := lang.Apply(errors5.New, []any{tmp38}) + panic(tmp39) + } else { + } + tmp32 = tmp36 + } + tmp28 = tmp32 + } + tmp21 = tmp28 + } + tmp12 = tmp21 + } // end let + return tmp12 + }) + v8 = tmp7 + _ = v8 + } + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4402), kw_column, int(12), kw_end_DASH_line, int(4490), kw_end_DASH_column, int(82)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v10 any = tmp9 + _ = v10 + // let binding "process-entry" + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v12 := args[0] + _ = v12 + v13 := args[1] + _ = v13 + tmp14 := checkDerefVar(var_glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v13}) + tmp16 := checkDerefVar(var_glojure_DOT_core_second) + tmp17 := lang.Apply(tmp16, []any{v13}) + tmp18 := lang.Apply(v10, []any{v12, tmp15, tmp17}) + return tmp18 + }) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4491), kw_column, int(23), kw_end_DASH_line, int(4491), kw_end_DASH_column, int(66)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v14 any = tmp13 + _ = v14 + var tmp15 any + tmp16 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + tmp17 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp18 := checkDerefVar(var_glojure_DOT_core_map) + tmp19 := checkDerefVar(var_glojure_DOT_core_first) + tmp20 := lang.Apply(tmp18, []any{tmp19, v6}) + tmp21 := lang.Apply(tmp16, []any{tmp17, tmp20}) + if lang.IsTruthy(tmp21) { + tmp15 = v2 + } else { + tmp22 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp23 := lang.NewVector() + tmp24 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4494), kw_column, int(30), kw_end_DASH_line, int(4494), kw_end_DASH_column, int(31)) + tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp26 := lang.Apply(tmp22, []any{v14, tmp25, v6}) + tmp15 = tmp26 + } + tmp3 = tmp15 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_destructure = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_destructure.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // extend + { + tmp0 := sym_extend.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_atype, sym__AMP_, sym_proto_PLUS_mmaps)), kw_doc, "Implementations of protocol methods can be provided using the extend construct:\n\n (extend AType\n AProtocol\n {:foo an-existing-fn\n :bar (fn [a b] ...)\n :baz (fn ([a]...) ([a b] ...)...)}\n BProtocol \n {...} \n ...)\n \n extend takes a type/class (or interface, see below), and one or more\n protocol + method map pairs. It will extend the polymorphism of the\n protocol's methods to call the supplied methods when an AType is\n provided as the first argument. \n\n Method maps are maps of the keyword-ized method names to ordinary\n fns. This facilitates easy reuse of existing fns and fn maps, for\n code reuse/mixins without derivation or composition. You can extend\n an interface to a protocol. This is primarily to facilitate interop\n with the host (e.g. Java) but opens the door to incidental multiple\n inheritance of implementation since a class can inherit from more\n than one interface, both of which extend the protocol. It is TBD how\n to specify which impl to use. You can extend a protocol on nil.\n\n If you are supplying the definitions explicitly (i.e. not reusing\n exsting functions or mixin maps), you may find it more convenient to\n use the extend-type or extend-protocol macros.\n\n Note that multiple independent extend clauses can exist for the same\n type, not all protocols need be defined in a single extend call.\n\n See also:\n extends?, satisfies?, extenders", kw_file, "glojure/core_deftype.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(116), kw_end_DASH_line, int(116))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + var tmp4 any + { // let + // let binding "seq_953" + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_partition) + tmp7 := lang.Apply(tmp6, []any{int64(2), v3}) + tmp8 := lang.Apply(tmp5, []any{tmp7}) + var v9 any = tmp8 + _ = v9 + // let binding "chunk_954" + var v10 any = nil + _ = v10 + // let binding "count_955" + var v11 any = int64(0) + _ = v11 + // let binding "i_956" + var v12 any = int64(0) + _ = v12 + for { + var tmp13 any + tmp14 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp15 := lang.Apply(tmp14, []any{v12, v11}) + if lang.IsTruthy(tmp15) { + var tmp16 any + { // let + // let binding "vec__957" + tmp17, _ := lang.FieldOrMethod(v10, "nth") + if reflect.TypeOf(tmp17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp18 := lang.Apply(tmp17, []any{v12}) + var v19 any = tmp18 + _ = v19 + // let binding "proto" + tmp20 := checkDerefVar(var_glojure_DOT_core_nth) + tmp21 := lang.Apply(tmp20, []any{v19, int64(0), nil}) + var v22 any = tmp21 + _ = v22 + // let binding "mmap" + tmp23 := checkDerefVar(var_glojure_DOT_core_nth) + tmp24 := lang.Apply(tmp23, []any{v19, int64(1), nil}) + var v25 any = tmp24 + _ = v25 + var tmp26 any + tmp27 := checkDerefVar(var_glojure_DOT_core_protocol_QMARK_) + tmp28 := lang.Apply(tmp27, []any{v22}) + if lang.IsTruthy(tmp28) { + } else { + tmp29 := checkDerefVar(var_glojure_DOT_core_str) + tmp30 := lang.Apply(tmp29, []any{v22, " is not a protocol"}) + tmp31 := lang.Apply(errors5.New, []any{tmp30}) + panic(tmp31) + } + _ = tmp26 + tmp32 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp33 lang.FnFunc + tmp33 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v34 := args[0] + _ = v34 + v35 := args[1] + _ = v35 + var tmp36 any + { // let + // let binding "vec__961" + var v37 any = v35 + _ = v37 + // let binding "k" + tmp38 := checkDerefVar(var_glojure_DOT_core_nth) + tmp39 := lang.Apply(tmp38, []any{v37, int64(0), nil}) + var v40 any = tmp39 + _ = v40 + // let binding "v" + tmp41 := checkDerefVar(var_glojure_DOT_core_nth) + tmp42 := lang.Apply(tmp41, []any{v37, int64(1), nil}) + var v43 any = tmp42 + _ = v43 + tmp44 := checkDerefVar(var_glojure_DOT_core_get_DASH_in) + tmp45 := checkDerefVar(var_glojure_DOT_core_deref) + tmp46 := lang.Apply(tmp45, []any{v22}) + tmp47 := lang.NewVector(kw_multis, v40) + tmp48 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(158), kw_column, int(33), kw_end_DASH_line, int(158), kw_end_DASH_column, int(43)) + tmp49, err := lang.WithMeta(tmp47, tmp48.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp50 := lang.Apply(tmp44, []any{tmp46, tmp49}) + var tmp51 lang.FnFunc + tmp51 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v52 := args[0] + _ = v52 + var v53 any = lang.NewList(args[1:]...) + _ = v53 + tmp54 := checkDerefVar(var_glojure_DOT_core_apply) + tmp55 := checkDerefVar(var_glojure_DOT_core_cons) + tmp56 := lang.Apply(tmp55, []any{v52, v53}) + tmp57 := lang.Apply(tmp54, []any{v43, tmp56}) + return tmp57 + } + }) + tmp52, _ := lang.FieldOrMethod(tmp50, "AddMethod") + if reflect.TypeOf(tmp52).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("AddMethod is not a function"))) + } + tmp53 := lang.Apply(tmp52, []any{v2, tmp51}) + tmp36 = tmp53 + } // end let + return tmp36 + }) + tmp34 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(156), kw_column, int(14), kw_end_DASH_line, int(160), kw_end_DASH_column, int(45)) + tmp35, err := lang.WithMeta(tmp33, tmp34.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp36 := lang.Apply(tmp32, []any{tmp35, nil, v25}) + _ = tmp36 + var tmp37 any = v9 + var tmp38 any = v10 + var tmp39 any = v11 + tmp41 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp42 := lang.Apply(tmp41, []any{v12}) + var tmp40 any = tmp42 + v9 = tmp37 + v10 = tmp38 + v11 = tmp39 + v12 = tmp40 + continue + } // end let + tmp13 = tmp16 + } else { + var tmp17 any + { // let + // let binding "temp__0__auto__" + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := lang.Apply(tmp18, []any{v9}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + var tmp22 any + { // let + // let binding "seq_953" + var v23 any = v20 + _ = v23 + var tmp24 any + tmp25 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp26 := lang.Apply(tmp25, []any{v23}) + if lang.IsTruthy(tmp26) { + var tmp27 any + { // let + // let binding "c__0__auto__" + tmp28 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp29 := lang.Apply(tmp28, []any{v23}) + var v30 any = tmp29 + _ = v30 + tmp32 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp33 := lang.Apply(tmp32, []any{v23}) + var tmp31 any = tmp33 + var tmp34 any = v30 + tmp36 := checkDerefVar(var_glojure_DOT_core_int) + tmp37 := checkDerefVar(var_glojure_DOT_core_count) + tmp38 := lang.Apply(tmp37, []any{v30}) + tmp39 := lang.Apply(tmp36, []any{tmp38}) + var tmp35 any = tmp39 + tmp41 := checkDerefVar(var_glojure_DOT_core_int) + tmp42 := lang.Apply(tmp41, []any{int64(0)}) + var tmp40 any = tmp42 + v9 = tmp31 + v10 = tmp34 + v11 = tmp35 + v12 = tmp40 + continue + } // end let + tmp24 = tmp27 + } else { + var tmp28 any + { // let + // let binding "vec__964" + tmp29 := checkDerefVar(var_glojure_DOT_core_first) + tmp30 := lang.Apply(tmp29, []any{v23}) + var v31 any = tmp30 + _ = v31 + // let binding "proto" + tmp32 := checkDerefVar(var_glojure_DOT_core_nth) + tmp33 := lang.Apply(tmp32, []any{v31, int64(0), nil}) + var v34 any = tmp33 + _ = v34 + // let binding "mmap" + tmp35 := checkDerefVar(var_glojure_DOT_core_nth) + tmp36 := lang.Apply(tmp35, []any{v31, int64(1), nil}) + var v37 any = tmp36 + _ = v37 + var tmp38 any + tmp39 := checkDerefVar(var_glojure_DOT_core_protocol_QMARK_) + tmp40 := lang.Apply(tmp39, []any{v34}) + if lang.IsTruthy(tmp40) { + } else { + tmp41 := checkDerefVar(var_glojure_DOT_core_str) + tmp42 := lang.Apply(tmp41, []any{v34, " is not a protocol"}) + tmp43 := lang.Apply(errors5.New, []any{tmp42}) + panic(tmp43) + } + _ = tmp38 + tmp44 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp45 lang.FnFunc + tmp45 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v46 := args[0] + _ = v46 + v47 := args[1] + _ = v47 + var tmp48 any + { // let + // let binding "vec__968" + var v49 any = v47 + _ = v49 + // let binding "k" + tmp50 := checkDerefVar(var_glojure_DOT_core_nth) + tmp51 := lang.Apply(tmp50, []any{v49, int64(0), nil}) + var v52 any = tmp51 + _ = v52 + // let binding "v" + tmp53 := checkDerefVar(var_glojure_DOT_core_nth) + tmp54 := lang.Apply(tmp53, []any{v49, int64(1), nil}) + var v55 any = tmp54 + _ = v55 + tmp56 := checkDerefVar(var_glojure_DOT_core_get_DASH_in) + tmp57 := checkDerefVar(var_glojure_DOT_core_deref) + tmp58 := lang.Apply(tmp57, []any{v34}) + tmp59 := lang.NewVector(kw_multis, v52) + tmp60 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(158), kw_column, int(33), kw_end_DASH_line, int(158), kw_end_DASH_column, int(43)) + tmp61, err := lang.WithMeta(tmp59, tmp60.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp62 := lang.Apply(tmp56, []any{tmp58, tmp61}) + var tmp63 lang.FnFunc + tmp63 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v64 := args[0] + _ = v64 + var v65 any = lang.NewList(args[1:]...) + _ = v65 + tmp66 := checkDerefVar(var_glojure_DOT_core_apply) + tmp67 := checkDerefVar(var_glojure_DOT_core_cons) + tmp68 := lang.Apply(tmp67, []any{v64, v65}) + tmp69 := lang.Apply(tmp66, []any{v55, tmp68}) + return tmp69 + } + }) + tmp64, _ := lang.FieldOrMethod(tmp62, "AddMethod") + if reflect.TypeOf(tmp64).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("AddMethod is not a function"))) + } + tmp65 := lang.Apply(tmp64, []any{v2, tmp63}) + tmp48 = tmp65 + } // end let + return tmp48 + }) + tmp46 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(156), kw_column, int(14), kw_end_DASH_line, int(160), kw_end_DASH_column, int(45)) + tmp47, err := lang.WithMeta(tmp45, tmp46.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp48 := lang.Apply(tmp44, []any{tmp47, nil, v37}) + _ = tmp48 + tmp50 := checkDerefVar(var_glojure_DOT_core_next) + tmp51 := lang.Apply(tmp50, []any{v23}) + var tmp49 any = tmp51 + var tmp52 any = nil + var tmp53 any = int64(0) + var tmp54 any = int64(0) + v9 = tmp49 + v10 = tmp52 + v11 = tmp53 + v12 = tmp54 + continue + } // end let + tmp24 = tmp28 + } + tmp22 = tmp24 + } // end let + tmp21 = tmp22 + } else { + } + tmp17 = tmp21 + } // end let + tmp13 = tmp17 + } + tmp4 = tmp13 + break + } + } // end let + return tmp4 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_extend = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_extend.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // for + { + tmp0 := sym_for.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_seq_DASH_exprs, sym_body_DASH_expr)), kw_doc, "List comprehension. Takes a vector of one or more\n binding-form/collection-expr pairs, each followed by zero or more\n modifiers, and yields a lazy sequence of evaluations of expr.\n Collections are iterated in a nested fashion, rightmost fastest,\n and nested coll-exprs can refer to bindings created in prior\n binding-forms. Supported modifiers are: :let [binding-form expr ...],\n :while test, :when test.\n\n (take 100 (for [x (range 100000000) y (range 1000000) :while (< y x)] [x y]))", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(11), kw_line, int(4646), kw_end_DASH_line, int(4646))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v4}) + if lang.IsTruthy(tmp8) { + } else { + tmp9 := checkDerefVar(var_glojure_DOT_core_str) + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp13 := checkDerefVar(var_glojure_DOT_core_meta) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(kw_line, []any{tmp14}) + tmp16 := lang.Apply(tmp9, []any{tmp11, " requires ", "a vector for its binding", " in ", tmp12, ":", tmp15}) + tmp17 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp16}) + panic(tmp17) + } + _ = tmp6 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_even_QMARK_) + tmp20 := checkDerefVar(var_glojure_DOT_core_count) + tmp21 := lang.Apply(tmp20, []any{v4}) + tmp22 := lang.Apply(tmp19, []any{tmp21}) + if lang.IsTruthy(tmp22) { + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp27 := checkDerefVar(var_glojure_DOT_core_meta) + tmp28 := lang.Apply(tmp27, []any{v2}) + tmp29 := lang.Apply(kw_line, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp25, " requires ", "an even number of forms in binding vector", " in ", tmp26, ":", tmp29}) + tmp31 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp31) + } + _ = tmp18 + var tmp32 any + { // let + // let binding "to-groups" + var tmp33 lang.FnFunc + tmp33 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v34 := args[0] + _ = v34 + tmp35 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp36 lang.FnFunc + tmp36 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v37 := args[0] + _ = v37 + v38 := args[1] + _ = v38 + var tmp39 any + { // let + // let binding "vec__715" + var v40 any = v38 + _ = v40 + // let binding "k" + tmp41 := checkDerefVar(var_glojure_DOT_core_nth) + tmp42 := lang.Apply(tmp41, []any{v40, int64(0), nil}) + var v43 any = tmp42 + _ = v43 + // let binding "v" + tmp44 := checkDerefVar(var_glojure_DOT_core_nth) + tmp45 := lang.Apply(tmp44, []any{v40, int64(1), nil}) + var v46 any = tmp45 + _ = v46 + var tmp47 any + tmp48 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp49 := lang.Apply(tmp48, []any{v43}) + if lang.IsTruthy(tmp49) { + tmp50 := checkDerefVar(var_glojure_DOT_core_conj) + tmp51 := checkDerefVar(var_glojure_DOT_core_pop) + tmp52 := lang.Apply(tmp51, []any{v37}) + tmp53 := checkDerefVar(var_glojure_DOT_core_conj) + tmp54 := checkDerefVar(var_glojure_DOT_core_peek) + tmp55 := lang.Apply(tmp54, []any{v37}) + tmp56 := lang.NewVector(v43, v46) + tmp57 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4664), kw_column, int(72), kw_end_DASH_line, int(4664), kw_end_DASH_column, int(76)) + tmp58, err := lang.WithMeta(tmp56, tmp57.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp59 := lang.Apply(tmp53, []any{tmp55, tmp58}) + tmp60 := lang.Apply(tmp50, []any{tmp52, tmp59}) + tmp47 = tmp60 + } else { + tmp61 := checkDerefVar(var_glojure_DOT_core_conj) + tmp62 := lang.NewVector(v43, v46) + tmp63 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4665), kw_column, int(46), kw_end_DASH_line, int(4665), kw_end_DASH_column, int(50)) + tmp64, err := lang.WithMeta(tmp62, tmp63.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp65 := lang.Apply(tmp61, []any{v37, tmp64}) + tmp47 = tmp65 + } + tmp39 = tmp47 + } // end let + return tmp39 + }) + tmp37 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4662), kw_column, int(30), kw_end_DASH_line, int(4665), kw_end_DASH_column, int(53)) + tmp38, err := lang.WithMeta(tmp36, tmp37.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp39 := lang.NewVector() + tmp40 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4666), kw_column, int(29), kw_end_DASH_line, int(4666), kw_end_DASH_column, int(30)) + tmp41, err := lang.WithMeta(tmp39, tmp40.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp42 := checkDerefVar(var_glojure_DOT_core_partition) + tmp43 := lang.Apply(tmp42, []any{int64(2), v34}) + tmp44 := lang.Apply(tmp35, []any{tmp38, tmp41, tmp43}) + return tmp44 + }) + tmp34 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4661), kw_column, int(19), kw_end_DASH_line, int(4666), kw_end_DASH_column, int(56)) + tmp35, err := lang.WithMeta(tmp33, tmp34.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v36 any = tmp35 + _ = v36 + // let binding "err" + var tmp37 lang.FnFunc + tmp37 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v38 any = lang.NewList(args[0:]...) + _ = v38 + tmp39 := checkDerefVar(var_glojure_DOT_core_apply) + tmp40 := checkDerefVar(var_glojure_DOT_core_str) + tmp41 := lang.Apply(tmp39, []any{tmp40, v38}) + tmp42 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp41}) + panic(tmp42) + } + }) + tmp38 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4667), kw_column, int(13), kw_end_DASH_line, int(4667), kw_end_DASH_column, int(125)) + tmp39, err := lang.WithMeta(tmp37, tmp38.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v40 any = tmp39 + _ = v40 + // let binding "emit-bind" + var tmp41 lang.FnFunc + { // function emit-bind + var v42 lang.FnFunc + tmp41 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v43 := args[0] + _ = v43 + var tmp44 any + { // let + // let binding "vec__719" + var v45 any = v43 + _ = v45 + // let binding "seq__720" + tmp46 := checkDerefVar(var_glojure_DOT_core_seq) + tmp47 := lang.Apply(tmp46, []any{v45}) + var v48 any = tmp47 + _ = v48 + // let binding "first__721" + tmp49 := checkDerefVar(var_glojure_DOT_core_first) + tmp50 := lang.Apply(tmp49, []any{v48}) + var v51 any = tmp50 + _ = v51 + // let binding "seq__720" + tmp52 := checkDerefVar(var_glojure_DOT_core_next) + tmp53 := lang.Apply(tmp52, []any{v48}) + var v54 any = tmp53 + _ = v54 + // let binding "vec__722" + var v55 any = v51 + _ = v55 + // let binding "seq__723" + tmp56 := checkDerefVar(var_glojure_DOT_core_seq) + tmp57 := lang.Apply(tmp56, []any{v55}) + var v58 any = tmp57 + _ = v58 + // let binding "first__724" + tmp59 := checkDerefVar(var_glojure_DOT_core_first) + tmp60 := lang.Apply(tmp59, []any{v58}) + var v61 any = tmp60 + _ = v61 + // let binding "seq__723" + tmp62 := checkDerefVar(var_glojure_DOT_core_next) + tmp63 := lang.Apply(tmp62, []any{v58}) + var v64 any = tmp63 + _ = v64 + // let binding "bind" + var v65 any = v61 + _ = v65 + // let binding "first__724" + tmp66 := checkDerefVar(var_glojure_DOT_core_first) + tmp67 := lang.Apply(tmp66, []any{v64}) + var v68 any = tmp67 + _ = v68 + // let binding "seq__723" + tmp69 := checkDerefVar(var_glojure_DOT_core_next) + tmp70 := lang.Apply(tmp69, []any{v64}) + var v71 any = tmp70 + _ = v71 + // let binding "expr" + var v72 any = v68 + _ = v72 + // let binding "mod-pairs" + var v73 any = v71 + _ = v73 + // let binding "vec__725" + var v74 any = v54 + _ = v74 + // let binding "vec__728" + tmp75 := checkDerefVar(var_glojure_DOT_core_nth) + tmp76 := lang.Apply(tmp75, []any{v74, int64(0), nil}) + var v77 any = tmp76 + _ = v77 + // let binding "_" + tmp78 := checkDerefVar(var_glojure_DOT_core_nth) + tmp79 := lang.Apply(tmp78, []any{v77, int64(0), nil}) + var v80 any = tmp79 + _ = v80 + // let binding "next-expr" + tmp81 := checkDerefVar(var_glojure_DOT_core_nth) + tmp82 := lang.Apply(tmp81, []any{v77, int64(1), nil}) + var v83 any = tmp82 + _ = v83 + // let binding "next-groups" + var v84 any = v74 + _ = v84 + var tmp85 any + { // let + // let binding "giter" + tmp86 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp87 := lang.Apply(tmp86, []any{"iter__"}) + var v88 any = tmp87 + _ = v88 + // let binding "gxs" + tmp89 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp90 := lang.Apply(tmp89, []any{"s__"}) + var v91 any = tmp90 + _ = v91 + // let binding "do-mod" + var tmp92 lang.FnFunc + { // function do-mod + var v93 lang.FnFunc + tmp92 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v94 := args[0] + _ = v94 + var tmp95 any + { // let + // let binding "vec__732" + var v96 any = v94 + _ = v96 + // let binding "seq__733" + tmp97 := checkDerefVar(var_glojure_DOT_core_seq) + tmp98 := lang.Apply(tmp97, []any{v96}) + var v99 any = tmp98 + _ = v99 + // let binding "first__734" + tmp100 := checkDerefVar(var_glojure_DOT_core_first) + tmp101 := lang.Apply(tmp100, []any{v99}) + var v102 any = tmp101 + _ = v102 + // let binding "seq__733" + tmp103 := checkDerefVar(var_glojure_DOT_core_next) + tmp104 := lang.Apply(tmp103, []any{v99}) + var v105 any = tmp104 + _ = v105 + // let binding "vec__735" + var v106 any = v102 + _ = v106 + // let binding "k" + tmp107 := checkDerefVar(var_glojure_DOT_core_nth) + tmp108 := lang.Apply(tmp107, []any{v106, int64(0), nil}) + var v109 any = tmp108 + _ = v109 + // let binding "v" + tmp110 := checkDerefVar(var_glojure_DOT_core_nth) + tmp111 := lang.Apply(tmp110, []any{v106, int64(1), nil}) + var v112 any = tmp111 + _ = v112 + // let binding "pair" + var v113 any = v106 + _ = v113 + // let binding "etc" + var v114 any = v105 + _ = v114 + var tmp115 any + tmp116 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp117 := lang.Apply(tmp116, []any{v109, kw_let}) + if lang.IsTruthy(tmp117) { + tmp118 := checkDerefVar(var_glojure_DOT_core_seq) + tmp119 := checkDerefVar(var_glojure_DOT_core_concat) + tmp120 := checkDerefVar(var_glojure_DOT_core_list) + tmp121 := lang.Apply(tmp120, []any{sym_glojure_DOT_core_SLASH_let}) + tmp122 := checkDerefVar(var_glojure_DOT_core_list) + tmp123 := lang.Apply(tmp122, []any{v112}) + tmp124 := checkDerefVar(var_glojure_DOT_core_list) + tmp125 := lang.Apply(v93, []any{v114}) + tmp126 := lang.Apply(tmp124, []any{tmp125}) + tmp127 := lang.Apply(tmp119, []any{tmp121, tmp123, tmp126}) + tmp128 := lang.Apply(tmp118, []any{tmp127}) + tmp115 = tmp128 + } else { + var tmp129 any + tmp130 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp131 := lang.Apply(tmp130, []any{v109, kw_while}) + if lang.IsTruthy(tmp131) { + tmp132 := checkDerefVar(var_glojure_DOT_core_seq) + tmp133 := checkDerefVar(var_glojure_DOT_core_concat) + tmp134 := checkDerefVar(var_glojure_DOT_core_list) + tmp135 := lang.Apply(tmp134, []any{sym_glojure_DOT_core_SLASH_when}) + tmp136 := checkDerefVar(var_glojure_DOT_core_list) + tmp137 := lang.Apply(tmp136, []any{v112}) + tmp138 := checkDerefVar(var_glojure_DOT_core_list) + tmp139 := lang.Apply(v93, []any{v114}) + tmp140 := lang.Apply(tmp138, []any{tmp139}) + tmp141 := lang.Apply(tmp133, []any{tmp135, tmp137, tmp140}) + tmp142 := lang.Apply(tmp132, []any{tmp141}) + tmp129 = tmp142 + } else { + var tmp143 any + tmp144 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp145 := lang.Apply(tmp144, []any{v109, kw_when}) + if lang.IsTruthy(tmp145) { + tmp146 := checkDerefVar(var_glojure_DOT_core_seq) + tmp147 := checkDerefVar(var_glojure_DOT_core_concat) + tmp148 := checkDerefVar(var_glojure_DOT_core_list) + tmp149 := lang.Apply(tmp148, []any{sym_if}) + tmp150 := checkDerefVar(var_glojure_DOT_core_list) + tmp151 := lang.Apply(tmp150, []any{v112}) + tmp152 := checkDerefVar(var_glojure_DOT_core_list) + tmp153 := lang.Apply(v93, []any{v114}) + tmp154 := lang.Apply(tmp152, []any{tmp153}) + tmp155 := checkDerefVar(var_glojure_DOT_core_list) + tmp156 := checkDerefVar(var_glojure_DOT_core_seq) + tmp157 := checkDerefVar(var_glojure_DOT_core_concat) + tmp158 := checkDerefVar(var_glojure_DOT_core_list) + tmp159 := lang.Apply(tmp158, []any{sym_recur}) + tmp160 := checkDerefVar(var_glojure_DOT_core_list) + tmp161 := checkDerefVar(var_glojure_DOT_core_seq) + tmp162 := checkDerefVar(var_glojure_DOT_core_concat) + tmp163 := checkDerefVar(var_glojure_DOT_core_list) + tmp164 := lang.Apply(tmp163, []any{sym_glojure_DOT_core_SLASH_rest}) + tmp165 := checkDerefVar(var_glojure_DOT_core_list) + tmp166 := lang.Apply(tmp165, []any{v91}) + tmp167 := lang.Apply(tmp162, []any{tmp164, tmp166}) + tmp168 := lang.Apply(tmp161, []any{tmp167}) + tmp169 := lang.Apply(tmp160, []any{tmp168}) + tmp170 := lang.Apply(tmp157, []any{tmp159, tmp169}) + tmp171 := lang.Apply(tmp156, []any{tmp170}) + tmp172 := lang.Apply(tmp155, []any{tmp171}) + tmp173 := lang.Apply(tmp147, []any{tmp149, tmp151, tmp154, tmp172}) + tmp174 := lang.Apply(tmp146, []any{tmp173}) + tmp143 = tmp174 + } else { + var tmp175 any + tmp176 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp177 := lang.Apply(tmp176, []any{v109}) + if lang.IsTruthy(tmp177) { + tmp178 := lang.Apply(v40, []any{"Invalid 'for' keyword ", v109}) + tmp175 = tmp178 + } else { + var tmp179 any + if lang.IsTruthy(v84) { + tmp180 := checkDerefVar(var_glojure_DOT_core_seq) + tmp181 := checkDerefVar(var_glojure_DOT_core_concat) + tmp182 := checkDerefVar(var_glojure_DOT_core_list) + tmp183 := lang.Apply(tmp182, []any{sym_glojure_DOT_core_SLASH_let}) + tmp184 := checkDerefVar(var_glojure_DOT_core_list) + tmp185 := checkDerefVar(var_glojure_DOT_core_apply) + tmp186 := checkDerefVar(var_glojure_DOT_core_vector) + tmp187 := checkDerefVar(var_glojure_DOT_core_seq) + tmp188 := checkDerefVar(var_glojure_DOT_core_concat) + tmp189 := checkDerefVar(var_glojure_DOT_core_list) + tmp190 := lang.Apply(tmp189, []any{sym_iterys__0__auto__}) + tmp191 := checkDerefVar(var_glojure_DOT_core_list) + tmp192 := lang.Apply(v42, []any{v84}) + tmp193 := lang.Apply(tmp191, []any{tmp192}) + tmp194 := checkDerefVar(var_glojure_DOT_core_list) + tmp195 := lang.Apply(tmp194, []any{sym_fs__1__auto__}) + tmp196 := checkDerefVar(var_glojure_DOT_core_list) + tmp197 := checkDerefVar(var_glojure_DOT_core_seq) + tmp198 := checkDerefVar(var_glojure_DOT_core_concat) + tmp199 := checkDerefVar(var_glojure_DOT_core_list) + tmp200 := lang.Apply(tmp199, []any{sym_glojure_DOT_core_SLASH_seq}) + tmp201 := checkDerefVar(var_glojure_DOT_core_list) + tmp202 := checkDerefVar(var_glojure_DOT_core_seq) + tmp203 := checkDerefVar(var_glojure_DOT_core_concat) + tmp204 := checkDerefVar(var_glojure_DOT_core_list) + tmp205 := lang.Apply(tmp204, []any{sym_iterys__0__auto__}) + tmp206 := checkDerefVar(var_glojure_DOT_core_list) + tmp207 := lang.Apply(tmp206, []any{v83}) + tmp208 := lang.Apply(tmp203, []any{tmp205, tmp207}) + tmp209 := lang.Apply(tmp202, []any{tmp208}) + tmp210 := lang.Apply(tmp201, []any{tmp209}) + tmp211 := lang.Apply(tmp198, []any{tmp200, tmp210}) + tmp212 := lang.Apply(tmp197, []any{tmp211}) + tmp213 := lang.Apply(tmp196, []any{tmp212}) + tmp214 := lang.Apply(tmp188, []any{tmp190, tmp193, tmp195, tmp213}) + tmp215 := lang.Apply(tmp187, []any{tmp214}) + tmp216 := lang.Apply(tmp185, []any{tmp186, tmp215}) + tmp217 := lang.Apply(tmp184, []any{tmp216}) + tmp218 := checkDerefVar(var_glojure_DOT_core_list) + tmp219 := checkDerefVar(var_glojure_DOT_core_seq) + tmp220 := checkDerefVar(var_glojure_DOT_core_concat) + tmp221 := checkDerefVar(var_glojure_DOT_core_list) + tmp222 := lang.Apply(tmp221, []any{sym_if}) + tmp223 := checkDerefVar(var_glojure_DOT_core_list) + tmp224 := lang.Apply(tmp223, []any{sym_fs__1__auto__}) + tmp225 := checkDerefVar(var_glojure_DOT_core_list) + tmp226 := checkDerefVar(var_glojure_DOT_core_seq) + tmp227 := checkDerefVar(var_glojure_DOT_core_concat) + tmp228 := checkDerefVar(var_glojure_DOT_core_list) + tmp229 := lang.Apply(tmp228, []any{sym_glojure_DOT_core_SLASH_concat}) + tmp230 := checkDerefVar(var_glojure_DOT_core_list) + tmp231 := lang.Apply(tmp230, []any{sym_fs__1__auto__}) + tmp232 := checkDerefVar(var_glojure_DOT_core_list) + tmp233 := checkDerefVar(var_glojure_DOT_core_seq) + tmp234 := checkDerefVar(var_glojure_DOT_core_concat) + tmp235 := checkDerefVar(var_glojure_DOT_core_list) + tmp236 := lang.Apply(tmp235, []any{v88}) + tmp237 := checkDerefVar(var_glojure_DOT_core_list) + tmp238 := checkDerefVar(var_glojure_DOT_core_seq) + tmp239 := checkDerefVar(var_glojure_DOT_core_concat) + tmp240 := checkDerefVar(var_glojure_DOT_core_list) + tmp241 := lang.Apply(tmp240, []any{sym_glojure_DOT_core_SLASH_rest}) + tmp242 := checkDerefVar(var_glojure_DOT_core_list) + tmp243 := lang.Apply(tmp242, []any{v91}) + tmp244 := lang.Apply(tmp239, []any{tmp241, tmp243}) + tmp245 := lang.Apply(tmp238, []any{tmp244}) + tmp246 := lang.Apply(tmp237, []any{tmp245}) + tmp247 := lang.Apply(tmp234, []any{tmp236, tmp246}) + tmp248 := lang.Apply(tmp233, []any{tmp247}) + tmp249 := lang.Apply(tmp232, []any{tmp248}) + tmp250 := lang.Apply(tmp227, []any{tmp229, tmp231, tmp249}) + tmp251 := lang.Apply(tmp226, []any{tmp250}) + tmp252 := lang.Apply(tmp225, []any{tmp251}) + tmp253 := checkDerefVar(var_glojure_DOT_core_list) + tmp254 := checkDerefVar(var_glojure_DOT_core_seq) + tmp255 := checkDerefVar(var_glojure_DOT_core_concat) + tmp256 := checkDerefVar(var_glojure_DOT_core_list) + tmp257 := lang.Apply(tmp256, []any{sym_recur}) + tmp258 := checkDerefVar(var_glojure_DOT_core_list) + tmp259 := checkDerefVar(var_glojure_DOT_core_seq) + tmp260 := checkDerefVar(var_glojure_DOT_core_concat) + tmp261 := checkDerefVar(var_glojure_DOT_core_list) + tmp262 := lang.Apply(tmp261, []any{sym_glojure_DOT_core_SLASH_rest}) + tmp263 := checkDerefVar(var_glojure_DOT_core_list) + tmp264 := lang.Apply(tmp263, []any{v91}) + tmp265 := lang.Apply(tmp260, []any{tmp262, tmp264}) + tmp266 := lang.Apply(tmp259, []any{tmp265}) + tmp267 := lang.Apply(tmp258, []any{tmp266}) + tmp268 := lang.Apply(tmp255, []any{tmp257, tmp267}) + tmp269 := lang.Apply(tmp254, []any{tmp268}) + tmp270 := lang.Apply(tmp253, []any{tmp269}) + tmp271 := lang.Apply(tmp220, []any{tmp222, tmp224, tmp252, tmp270}) + tmp272 := lang.Apply(tmp219, []any{tmp271}) + tmp273 := lang.Apply(tmp218, []any{tmp272}) + tmp274 := lang.Apply(tmp181, []any{tmp183, tmp217, tmp273}) + tmp275 := lang.Apply(tmp180, []any{tmp274}) + tmp179 = tmp275 + } else { + var tmp276 any + if lang.IsTruthy(kw_else) { + tmp277 := checkDerefVar(var_glojure_DOT_core_seq) + tmp278 := checkDerefVar(var_glojure_DOT_core_concat) + tmp279 := checkDerefVar(var_glojure_DOT_core_list) + tmp280 := lang.Apply(tmp279, []any{sym_glojure_DOT_core_SLASH_cons}) + tmp281 := checkDerefVar(var_glojure_DOT_core_list) + tmp282 := lang.Apply(tmp281, []any{v5}) + tmp283 := checkDerefVar(var_glojure_DOT_core_list) + tmp284 := checkDerefVar(var_glojure_DOT_core_seq) + tmp285 := checkDerefVar(var_glojure_DOT_core_concat) + tmp286 := checkDerefVar(var_glojure_DOT_core_list) + tmp287 := lang.Apply(tmp286, []any{v88}) + tmp288 := checkDerefVar(var_glojure_DOT_core_list) + tmp289 := checkDerefVar(var_glojure_DOT_core_seq) + tmp290 := checkDerefVar(var_glojure_DOT_core_concat) + tmp291 := checkDerefVar(var_glojure_DOT_core_list) + tmp292 := lang.Apply(tmp291, []any{sym_glojure_DOT_core_SLASH_rest}) + tmp293 := checkDerefVar(var_glojure_DOT_core_list) + tmp294 := lang.Apply(tmp293, []any{v91}) + tmp295 := lang.Apply(tmp290, []any{tmp292, tmp294}) + tmp296 := lang.Apply(tmp289, []any{tmp295}) + tmp297 := lang.Apply(tmp288, []any{tmp296}) + tmp298 := lang.Apply(tmp285, []any{tmp287, tmp297}) + tmp299 := lang.Apply(tmp284, []any{tmp298}) + tmp300 := lang.Apply(tmp283, []any{tmp299}) + tmp301 := lang.Apply(tmp278, []any{tmp280, tmp282, tmp300}) + tmp302 := lang.Apply(tmp277, []any{tmp301}) + tmp276 = tmp302 + } else { + } + tmp179 = tmp276 + } + tmp175 = tmp179 + } + tmp143 = tmp175 + } + tmp129 = tmp143 + } + tmp115 = tmp129 + } + tmp95 = tmp115 + } // end let + return tmp95 + }) + v93 = tmp92 + _ = v93 + } + tmp93 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4672), kw_column, int(34), kw_end_DASH_line, int(4687), kw_end_DASH_column, int(73)) + tmp94, err := lang.WithMeta(tmp92, tmp93.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v95 any = tmp94 + _ = v95 + var tmp96 any + if lang.IsTruthy(v84) { + tmp97 := checkDerefVar(var_glojure_DOT_core_seq) + tmp98 := checkDerefVar(var_glojure_DOT_core_concat) + tmp99 := checkDerefVar(var_glojure_DOT_core_list) + tmp100 := lang.Apply(tmp99, []any{sym_glojure_DOT_core_SLASH_fn}) + tmp101 := checkDerefVar(var_glojure_DOT_core_list) + tmp102 := lang.Apply(tmp101, []any{v88}) + tmp103 := checkDerefVar(var_glojure_DOT_core_list) + tmp104 := checkDerefVar(var_glojure_DOT_core_apply) + tmp105 := checkDerefVar(var_glojure_DOT_core_vector) + tmp106 := checkDerefVar(var_glojure_DOT_core_seq) + tmp107 := checkDerefVar(var_glojure_DOT_core_concat) + tmp108 := checkDerefVar(var_glojure_DOT_core_list) + tmp109 := lang.Apply(tmp108, []any{v91}) + tmp110 := lang.Apply(tmp107, []any{tmp109}) + tmp111 := lang.Apply(tmp106, []any{tmp110}) + tmp112 := lang.Apply(tmp104, []any{tmp105, tmp111}) + tmp113 := lang.Apply(tmp103, []any{tmp112}) + tmp114 := checkDerefVar(var_glojure_DOT_core_list) + tmp115 := checkDerefVar(var_glojure_DOT_core_seq) + tmp116 := checkDerefVar(var_glojure_DOT_core_concat) + tmp117 := checkDerefVar(var_glojure_DOT_core_list) + tmp118 := lang.Apply(tmp117, []any{sym_glojure_DOT_core_SLASH_lazy_DASH_seq}) + tmp119 := checkDerefVar(var_glojure_DOT_core_list) + tmp120 := checkDerefVar(var_glojure_DOT_core_seq) + tmp121 := checkDerefVar(var_glojure_DOT_core_concat) + tmp122 := checkDerefVar(var_glojure_DOT_core_list) + tmp123 := lang.Apply(tmp122, []any{sym_glojure_DOT_core_SLASH_loop}) + tmp124 := checkDerefVar(var_glojure_DOT_core_list) + tmp125 := checkDerefVar(var_glojure_DOT_core_apply) + tmp126 := checkDerefVar(var_glojure_DOT_core_vector) + tmp127 := checkDerefVar(var_glojure_DOT_core_seq) + tmp128 := checkDerefVar(var_glojure_DOT_core_concat) + tmp129 := checkDerefVar(var_glojure_DOT_core_list) + tmp130 := lang.Apply(tmp129, []any{v91}) + tmp131 := checkDerefVar(var_glojure_DOT_core_list) + tmp132 := lang.Apply(tmp131, []any{v91}) + tmp133 := lang.Apply(tmp128, []any{tmp130, tmp132}) + tmp134 := lang.Apply(tmp127, []any{tmp133}) + tmp135 := lang.Apply(tmp125, []any{tmp126, tmp134}) + tmp136 := lang.Apply(tmp124, []any{tmp135}) + tmp137 := checkDerefVar(var_glojure_DOT_core_list) + tmp138 := checkDerefVar(var_glojure_DOT_core_seq) + tmp139 := checkDerefVar(var_glojure_DOT_core_concat) + tmp140 := checkDerefVar(var_glojure_DOT_core_list) + tmp141 := lang.Apply(tmp140, []any{sym_glojure_DOT_core_SLASH_when_DASH_first}) + tmp142 := checkDerefVar(var_glojure_DOT_core_list) + tmp143 := checkDerefVar(var_glojure_DOT_core_apply) + tmp144 := checkDerefVar(var_glojure_DOT_core_vector) + tmp145 := checkDerefVar(var_glojure_DOT_core_seq) + tmp146 := checkDerefVar(var_glojure_DOT_core_concat) + tmp147 := checkDerefVar(var_glojure_DOT_core_list) + tmp148 := lang.Apply(tmp147, []any{v65}) + tmp149 := checkDerefVar(var_glojure_DOT_core_list) + tmp150 := lang.Apply(tmp149, []any{v91}) + tmp151 := lang.Apply(tmp146, []any{tmp148, tmp150}) + tmp152 := lang.Apply(tmp145, []any{tmp151}) + tmp153 := lang.Apply(tmp143, []any{tmp144, tmp152}) + tmp154 := lang.Apply(tmp142, []any{tmp153}) + tmp155 := checkDerefVar(var_glojure_DOT_core_list) + tmp156 := lang.Apply(v95, []any{v73}) + tmp157 := lang.Apply(tmp155, []any{tmp156}) + tmp158 := lang.Apply(tmp139, []any{tmp141, tmp154, tmp157}) + tmp159 := lang.Apply(tmp138, []any{tmp158}) + tmp160 := lang.Apply(tmp137, []any{tmp159}) + tmp161 := lang.Apply(tmp121, []any{tmp123, tmp136, tmp160}) + tmp162 := lang.Apply(tmp120, []any{tmp161}) + tmp163 := lang.Apply(tmp119, []any{tmp162}) + tmp164 := lang.Apply(tmp116, []any{tmp118, tmp163}) + tmp165 := lang.Apply(tmp115, []any{tmp164}) + tmp166 := lang.Apply(tmp114, []any{tmp165}) + tmp167 := lang.Apply(tmp98, []any{tmp100, tmp102, tmp113, tmp166}) + tmp168 := lang.Apply(tmp97, []any{tmp167}) + tmp96 = tmp168 + } else { + var tmp169 any + { // let + // let binding "gi" + tmp170 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp171 := lang.Apply(tmp170, []any{"i__"}) + var v172 any = tmp171 + _ = v172 + // let binding "gb" + tmp173 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp174 := lang.Apply(tmp173, []any{"b__"}) + var v175 any = tmp174 + _ = v175 + // let binding "do-cmod" + var tmp176 lang.FnFunc + { // function do-cmod + var v177 lang.FnFunc + tmp176 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v178 := args[0] + _ = v178 + var tmp179 any + { // let + // let binding "vec__739" + var v180 any = v178 + _ = v180 + // let binding "seq__740" + tmp181 := checkDerefVar(var_glojure_DOT_core_seq) + tmp182 := lang.Apply(tmp181, []any{v180}) + var v183 any = tmp182 + _ = v183 + // let binding "first__741" + tmp184 := checkDerefVar(var_glojure_DOT_core_first) + tmp185 := lang.Apply(tmp184, []any{v183}) + var v186 any = tmp185 + _ = v186 + // let binding "seq__740" + tmp187 := checkDerefVar(var_glojure_DOT_core_next) + tmp188 := lang.Apply(tmp187, []any{v183}) + var v189 any = tmp188 + _ = v189 + // let binding "vec__742" + var v190 any = v186 + _ = v190 + // let binding "k" + tmp191 := checkDerefVar(var_glojure_DOT_core_nth) + tmp192 := lang.Apply(tmp191, []any{v190, int64(0), nil}) + var v193 any = tmp192 + _ = v193 + // let binding "v" + tmp194 := checkDerefVar(var_glojure_DOT_core_nth) + tmp195 := lang.Apply(tmp194, []any{v190, int64(1), nil}) + var v196 any = tmp195 + _ = v196 + // let binding "pair" + var v197 any = v190 + _ = v197 + // let binding "etc" + var v198 any = v189 + _ = v198 + var tmp199 any + tmp200 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp201 := lang.Apply(tmp200, []any{v193, kw_let}) + if lang.IsTruthy(tmp201) { + tmp202 := checkDerefVar(var_glojure_DOT_core_seq) + tmp203 := checkDerefVar(var_glojure_DOT_core_concat) + tmp204 := checkDerefVar(var_glojure_DOT_core_list) + tmp205 := lang.Apply(tmp204, []any{sym_glojure_DOT_core_SLASH_let}) + tmp206 := checkDerefVar(var_glojure_DOT_core_list) + tmp207 := lang.Apply(tmp206, []any{v196}) + tmp208 := checkDerefVar(var_glojure_DOT_core_list) + tmp209 := lang.Apply(v177, []any{v198}) + tmp210 := lang.Apply(tmp208, []any{tmp209}) + tmp211 := lang.Apply(tmp203, []any{tmp205, tmp207, tmp210}) + tmp212 := lang.Apply(tmp202, []any{tmp211}) + tmp199 = tmp212 + } else { + var tmp213 any + tmp214 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp215 := lang.Apply(tmp214, []any{v193, kw_while}) + if lang.IsTruthy(tmp215) { + tmp216 := checkDerefVar(var_glojure_DOT_core_seq) + tmp217 := checkDerefVar(var_glojure_DOT_core_concat) + tmp218 := checkDerefVar(var_glojure_DOT_core_list) + tmp219 := lang.Apply(tmp218, []any{sym_glojure_DOT_core_SLASH_when}) + tmp220 := checkDerefVar(var_glojure_DOT_core_list) + tmp221 := lang.Apply(tmp220, []any{v196}) + tmp222 := checkDerefVar(var_glojure_DOT_core_list) + tmp223 := lang.Apply(v177, []any{v198}) + tmp224 := lang.Apply(tmp222, []any{tmp223}) + tmp225 := lang.Apply(tmp217, []any{tmp219, tmp221, tmp224}) + tmp226 := lang.Apply(tmp216, []any{tmp225}) + tmp213 = tmp226 + } else { + var tmp227 any + tmp228 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp229 := lang.Apply(tmp228, []any{v193, kw_when}) + if lang.IsTruthy(tmp229) { + tmp230 := checkDerefVar(var_glojure_DOT_core_seq) + tmp231 := checkDerefVar(var_glojure_DOT_core_concat) + tmp232 := checkDerefVar(var_glojure_DOT_core_list) + tmp233 := lang.Apply(tmp232, []any{sym_if}) + tmp234 := checkDerefVar(var_glojure_DOT_core_list) + tmp235 := lang.Apply(tmp234, []any{v196}) + tmp236 := checkDerefVar(var_glojure_DOT_core_list) + tmp237 := lang.Apply(v177, []any{v198}) + tmp238 := lang.Apply(tmp236, []any{tmp237}) + tmp239 := checkDerefVar(var_glojure_DOT_core_list) + tmp240 := checkDerefVar(var_glojure_DOT_core_seq) + tmp241 := checkDerefVar(var_glojure_DOT_core_concat) + tmp242 := checkDerefVar(var_glojure_DOT_core_list) + tmp243 := lang.Apply(tmp242, []any{sym_recur}) + tmp244 := checkDerefVar(var_glojure_DOT_core_list) + tmp245 := checkDerefVar(var_glojure_DOT_core_seq) + tmp246 := checkDerefVar(var_glojure_DOT_core_concat) + tmp247 := checkDerefVar(var_glojure_DOT_core_list) + tmp248 := lang.Apply(tmp247, []any{sym_glojure_DOT_core_SLASH_unchecked_DASH_inc}) + tmp249 := checkDerefVar(var_glojure_DOT_core_list) + tmp250 := lang.Apply(tmp249, []any{v172}) + tmp251 := lang.Apply(tmp246, []any{tmp248, tmp250}) + tmp252 := lang.Apply(tmp245, []any{tmp251}) + tmp253 := lang.Apply(tmp244, []any{tmp252}) + tmp254 := lang.Apply(tmp241, []any{tmp243, tmp253}) + tmp255 := lang.Apply(tmp240, []any{tmp254}) + tmp256 := lang.Apply(tmp239, []any{tmp255}) + tmp257 := lang.Apply(tmp231, []any{tmp233, tmp235, tmp238, tmp256}) + tmp258 := lang.Apply(tmp230, []any{tmp257}) + tmp227 = tmp258 + } else { + var tmp259 any + tmp260 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp261 := lang.Apply(tmp260, []any{v193}) + if lang.IsTruthy(tmp261) { + tmp262 := lang.Apply(v40, []any{"Invalid 'for' keyword ", v193}) + tmp259 = tmp262 + } else { + var tmp263 any + if lang.IsTruthy(kw_else) { + tmp264 := checkDerefVar(var_glojure_DOT_core_seq) + tmp265 := checkDerefVar(var_glojure_DOT_core_concat) + tmp266 := checkDerefVar(var_glojure_DOT_core_list) + tmp267 := lang.Apply(tmp266, []any{sym_do}) + tmp268 := checkDerefVar(var_glojure_DOT_core_list) + tmp269 := checkDerefVar(var_glojure_DOT_core_seq) + tmp270 := checkDerefVar(var_glojure_DOT_core_concat) + tmp271 := checkDerefVar(var_glojure_DOT_core_list) + tmp272 := lang.Apply(tmp271, []any{sym_glojure_DOT_core_SLASH_chunk_DASH_append}) + tmp273 := checkDerefVar(var_glojure_DOT_core_list) + tmp274 := lang.Apply(tmp273, []any{v175}) + tmp275 := checkDerefVar(var_glojure_DOT_core_list) + tmp276 := lang.Apply(tmp275, []any{v5}) + tmp277 := lang.Apply(tmp270, []any{tmp272, tmp274, tmp276}) + tmp278 := lang.Apply(tmp269, []any{tmp277}) + tmp279 := lang.Apply(tmp268, []any{tmp278}) + tmp280 := checkDerefVar(var_glojure_DOT_core_list) + tmp281 := checkDerefVar(var_glojure_DOT_core_seq) + tmp282 := checkDerefVar(var_glojure_DOT_core_concat) + tmp283 := checkDerefVar(var_glojure_DOT_core_list) + tmp284 := lang.Apply(tmp283, []any{sym_recur}) + tmp285 := checkDerefVar(var_glojure_DOT_core_list) + tmp286 := checkDerefVar(var_glojure_DOT_core_seq) + tmp287 := checkDerefVar(var_glojure_DOT_core_concat) + tmp288 := checkDerefVar(var_glojure_DOT_core_list) + tmp289 := lang.Apply(tmp288, []any{sym_glojure_DOT_core_SLASH_unchecked_DASH_inc}) + tmp290 := checkDerefVar(var_glojure_DOT_core_list) + tmp291 := lang.Apply(tmp290, []any{v172}) + tmp292 := lang.Apply(tmp287, []any{tmp289, tmp291}) + tmp293 := lang.Apply(tmp286, []any{tmp292}) + tmp294 := lang.Apply(tmp285, []any{tmp293}) + tmp295 := lang.Apply(tmp282, []any{tmp284, tmp294}) + tmp296 := lang.Apply(tmp281, []any{tmp295}) + tmp297 := lang.Apply(tmp280, []any{tmp296}) + tmp298 := lang.Apply(tmp265, []any{tmp267, tmp279, tmp297}) + tmp299 := lang.Apply(tmp264, []any{tmp298}) + tmp263 = tmp299 + } else { + } + tmp259 = tmp263 + } + tmp227 = tmp259 + } + tmp213 = tmp227 + } + tmp199 = tmp213 + } + tmp179 = tmp199 + } // end let + return tmp179 + }) + v177 = tmp176 + _ = v177 + } + tmp177 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4698), kw_column, int(39), kw_end_DASH_line, int(4710), kw_end_DASH_column, int(79)) + tmp178, err := lang.WithMeta(tmp176, tmp177.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v179 any = tmp178 + _ = v179 + tmp180 := checkDerefVar(var_glojure_DOT_core_seq) + tmp181 := checkDerefVar(var_glojure_DOT_core_concat) + tmp182 := checkDerefVar(var_glojure_DOT_core_list) + tmp183 := lang.Apply(tmp182, []any{sym_glojure_DOT_core_SLASH_fn}) + tmp184 := checkDerefVar(var_glojure_DOT_core_list) + tmp185 := lang.Apply(tmp184, []any{v88}) + tmp186 := checkDerefVar(var_glojure_DOT_core_list) + tmp187 := checkDerefVar(var_glojure_DOT_core_apply) + tmp188 := checkDerefVar(var_glojure_DOT_core_vector) + tmp189 := checkDerefVar(var_glojure_DOT_core_seq) + tmp190 := checkDerefVar(var_glojure_DOT_core_concat) + tmp191 := checkDerefVar(var_glojure_DOT_core_list) + tmp192 := lang.Apply(tmp191, []any{v91}) + tmp193 := lang.Apply(tmp190, []any{tmp192}) + tmp194 := lang.Apply(tmp189, []any{tmp193}) + tmp195 := lang.Apply(tmp187, []any{tmp188, tmp194}) + tmp196 := lang.Apply(tmp186, []any{tmp195}) + tmp197 := checkDerefVar(var_glojure_DOT_core_list) + tmp198 := checkDerefVar(var_glojure_DOT_core_seq) + tmp199 := checkDerefVar(var_glojure_DOT_core_concat) + tmp200 := checkDerefVar(var_glojure_DOT_core_list) + tmp201 := lang.Apply(tmp200, []any{sym_glojure_DOT_core_SLASH_lazy_DASH_seq}) + tmp202 := checkDerefVar(var_glojure_DOT_core_list) + tmp203 := checkDerefVar(var_glojure_DOT_core_seq) + tmp204 := checkDerefVar(var_glojure_DOT_core_concat) + tmp205 := checkDerefVar(var_glojure_DOT_core_list) + tmp206 := lang.Apply(tmp205, []any{sym_glojure_DOT_core_SLASH_loop}) + tmp207 := checkDerefVar(var_glojure_DOT_core_list) + tmp208 := checkDerefVar(var_glojure_DOT_core_apply) + tmp209 := checkDerefVar(var_glojure_DOT_core_vector) + tmp210 := checkDerefVar(var_glojure_DOT_core_seq) + tmp211 := checkDerefVar(var_glojure_DOT_core_concat) + tmp212 := checkDerefVar(var_glojure_DOT_core_list) + tmp213 := lang.Apply(tmp212, []any{v91}) + tmp214 := checkDerefVar(var_glojure_DOT_core_list) + tmp215 := lang.Apply(tmp214, []any{v91}) + tmp216 := lang.Apply(tmp211, []any{tmp213, tmp215}) + tmp217 := lang.Apply(tmp210, []any{tmp216}) + tmp218 := lang.Apply(tmp208, []any{tmp209, tmp217}) + tmp219 := lang.Apply(tmp207, []any{tmp218}) + tmp220 := checkDerefVar(var_glojure_DOT_core_list) + tmp221 := checkDerefVar(var_glojure_DOT_core_seq) + tmp222 := checkDerefVar(var_glojure_DOT_core_concat) + tmp223 := checkDerefVar(var_glojure_DOT_core_list) + tmp224 := lang.Apply(tmp223, []any{sym_glojure_DOT_core_SLASH_when_DASH_let}) + tmp225 := checkDerefVar(var_glojure_DOT_core_list) + tmp226 := checkDerefVar(var_glojure_DOT_core_apply) + tmp227 := checkDerefVar(var_glojure_DOT_core_vector) + tmp228 := checkDerefVar(var_glojure_DOT_core_seq) + tmp229 := checkDerefVar(var_glojure_DOT_core_concat) + tmp230 := checkDerefVar(var_glojure_DOT_core_list) + tmp231 := lang.Apply(tmp230, []any{v91}) + tmp232 := checkDerefVar(var_glojure_DOT_core_list) + tmp233 := checkDerefVar(var_glojure_DOT_core_seq) + tmp234 := checkDerefVar(var_glojure_DOT_core_concat) + tmp235 := checkDerefVar(var_glojure_DOT_core_list) + tmp236 := lang.Apply(tmp235, []any{sym_glojure_DOT_core_SLASH_seq}) + tmp237 := checkDerefVar(var_glojure_DOT_core_list) + tmp238 := lang.Apply(tmp237, []any{v91}) + tmp239 := lang.Apply(tmp234, []any{tmp236, tmp238}) + tmp240 := lang.Apply(tmp233, []any{tmp239}) + tmp241 := lang.Apply(tmp232, []any{tmp240}) + tmp242 := lang.Apply(tmp229, []any{tmp231, tmp241}) + tmp243 := lang.Apply(tmp228, []any{tmp242}) + tmp244 := lang.Apply(tmp226, []any{tmp227, tmp243}) + tmp245 := lang.Apply(tmp225, []any{tmp244}) + tmp246 := checkDerefVar(var_glojure_DOT_core_list) + tmp247 := checkDerefVar(var_glojure_DOT_core_seq) + tmp248 := checkDerefVar(var_glojure_DOT_core_concat) + tmp249 := checkDerefVar(var_glojure_DOT_core_list) + tmp250 := lang.Apply(tmp249, []any{sym_if}) + tmp251 := checkDerefVar(var_glojure_DOT_core_list) + tmp252 := checkDerefVar(var_glojure_DOT_core_seq) + tmp253 := checkDerefVar(var_glojure_DOT_core_concat) + tmp254 := checkDerefVar(var_glojure_DOT_core_list) + tmp255 := lang.Apply(tmp254, []any{sym_glojure_DOT_core_SLASH_chunked_DASH_seq_QMARK_}) + tmp256 := checkDerefVar(var_glojure_DOT_core_list) + tmp257 := lang.Apply(tmp256, []any{v91}) + tmp258 := lang.Apply(tmp253, []any{tmp255, tmp257}) + tmp259 := lang.Apply(tmp252, []any{tmp258}) + tmp260 := lang.Apply(tmp251, []any{tmp259}) + tmp261 := checkDerefVar(var_glojure_DOT_core_list) + tmp262 := checkDerefVar(var_glojure_DOT_core_seq) + tmp263 := checkDerefVar(var_glojure_DOT_core_concat) + tmp264 := checkDerefVar(var_glojure_DOT_core_list) + tmp265 := lang.Apply(tmp264, []any{sym_glojure_DOT_core_SLASH_let}) + tmp266 := checkDerefVar(var_glojure_DOT_core_list) + tmp267 := checkDerefVar(var_glojure_DOT_core_apply) + tmp268 := checkDerefVar(var_glojure_DOT_core_vector) + tmp269 := checkDerefVar(var_glojure_DOT_core_seq) + tmp270 := checkDerefVar(var_glojure_DOT_core_concat) + tmp271 := checkDerefVar(var_glojure_DOT_core_list) + tmp272 := lang.Apply(tmp271, []any{sym_c__0__auto__}) + tmp273 := checkDerefVar(var_glojure_DOT_core_list) + tmp274 := checkDerefVar(var_glojure_DOT_core_seq) + tmp275 := checkDerefVar(var_glojure_DOT_core_concat) + tmp276 := checkDerefVar(var_glojure_DOT_core_list) + tmp277 := lang.Apply(tmp276, []any{sym_glojure_DOT_core_SLASH_chunk_DASH_first}) + tmp278 := checkDerefVar(var_glojure_DOT_core_list) + tmp279 := lang.Apply(tmp278, []any{v91}) + tmp280 := lang.Apply(tmp275, []any{tmp277, tmp279}) + tmp281 := lang.Apply(tmp274, []any{tmp280}) + tmp282 := lang.Apply(tmp273, []any{tmp281}) + tmp283 := checkDerefVar(var_glojure_DOT_core_list) + tmp284 := lang.Apply(tmp283, []any{sym_size__1__auto__}) + tmp285 := checkDerefVar(var_glojure_DOT_core_list) + tmp286 := checkDerefVar(var_glojure_DOT_core_seq) + tmp287 := checkDerefVar(var_glojure_DOT_core_concat) + tmp288 := checkDerefVar(var_glojure_DOT_core_list) + tmp289 := lang.Apply(tmp288, []any{sym_glojure_DOT_core_SLASH_int}) + tmp290 := checkDerefVar(var_glojure_DOT_core_list) + tmp291 := checkDerefVar(var_glojure_DOT_core_seq) + tmp292 := checkDerefVar(var_glojure_DOT_core_concat) + tmp293 := checkDerefVar(var_glojure_DOT_core_list) + tmp294 := lang.Apply(tmp293, []any{sym_glojure_DOT_core_SLASH_count}) + tmp295 := checkDerefVar(var_glojure_DOT_core_list) + tmp296 := lang.Apply(tmp295, []any{sym_c__0__auto__}) + tmp297 := lang.Apply(tmp292, []any{tmp294, tmp296}) + tmp298 := lang.Apply(tmp291, []any{tmp297}) + tmp299 := lang.Apply(tmp290, []any{tmp298}) + tmp300 := lang.Apply(tmp287, []any{tmp289, tmp299}) + tmp301 := lang.Apply(tmp286, []any{tmp300}) + tmp302 := lang.Apply(tmp285, []any{tmp301}) + tmp303 := checkDerefVar(var_glojure_DOT_core_list) + tmp304 := lang.Apply(tmp303, []any{v175}) + tmp305 := checkDerefVar(var_glojure_DOT_core_list) + tmp306 := checkDerefVar(var_glojure_DOT_core_seq) + tmp307 := checkDerefVar(var_glojure_DOT_core_concat) + tmp308 := checkDerefVar(var_glojure_DOT_core_list) + tmp309 := lang.Apply(tmp308, []any{sym_glojure_DOT_core_SLASH_chunk_DASH_buffer}) + tmp310 := checkDerefVar(var_glojure_DOT_core_list) + tmp311 := lang.Apply(tmp310, []any{sym_size__1__auto__}) + tmp312 := lang.Apply(tmp307, []any{tmp309, tmp311}) + tmp313 := lang.Apply(tmp306, []any{tmp312}) + tmp314 := lang.Apply(tmp305, []any{tmp313}) + tmp315 := lang.Apply(tmp270, []any{tmp272, tmp282, tmp284, tmp302, tmp304, tmp314}) + tmp316 := lang.Apply(tmp269, []any{tmp315}) + tmp317 := lang.Apply(tmp267, []any{tmp268, tmp316}) + tmp318 := lang.Apply(tmp266, []any{tmp317}) + tmp319 := checkDerefVar(var_glojure_DOT_core_list) + tmp320 := checkDerefVar(var_glojure_DOT_core_seq) + tmp321 := checkDerefVar(var_glojure_DOT_core_concat) + tmp322 := checkDerefVar(var_glojure_DOT_core_list) + tmp323 := lang.Apply(tmp322, []any{sym_if}) + tmp324 := checkDerefVar(var_glojure_DOT_core_list) + tmp325 := checkDerefVar(var_glojure_DOT_core_seq) + tmp326 := checkDerefVar(var_glojure_DOT_core_concat) + tmp327 := checkDerefVar(var_glojure_DOT_core_list) + tmp328 := lang.Apply(tmp327, []any{sym_glojure_DOT_core_SLASH_loop}) + tmp329 := checkDerefVar(var_glojure_DOT_core_list) + tmp330 := checkDerefVar(var_glojure_DOT_core_apply) + tmp331 := checkDerefVar(var_glojure_DOT_core_vector) + tmp332 := checkDerefVar(var_glojure_DOT_core_seq) + tmp333 := checkDerefVar(var_glojure_DOT_core_concat) + tmp334 := checkDerefVar(var_glojure_DOT_core_list) + tmp335 := lang.Apply(tmp334, []any{v172}) + tmp336 := checkDerefVar(var_glojure_DOT_core_list) + tmp337 := checkDerefVar(var_glojure_DOT_core_seq) + tmp338 := checkDerefVar(var_glojure_DOT_core_concat) + tmp339 := checkDerefVar(var_glojure_DOT_core_list) + tmp340 := lang.Apply(tmp339, []any{sym_glojure_DOT_core_SLASH_int}) + tmp341 := checkDerefVar(var_glojure_DOT_core_list) + tmp342 := lang.Apply(tmp341, []any{int64(0)}) + tmp343 := lang.Apply(tmp338, []any{tmp340, tmp342}) + tmp344 := lang.Apply(tmp337, []any{tmp343}) + tmp345 := lang.Apply(tmp336, []any{tmp344}) + tmp346 := lang.Apply(tmp333, []any{tmp335, tmp345}) + tmp347 := lang.Apply(tmp332, []any{tmp346}) + tmp348 := lang.Apply(tmp330, []any{tmp331, tmp347}) + tmp349 := lang.Apply(tmp329, []any{tmp348}) + tmp350 := checkDerefVar(var_glojure_DOT_core_list) + tmp351 := checkDerefVar(var_glojure_DOT_core_seq) + tmp352 := checkDerefVar(var_glojure_DOT_core_concat) + tmp353 := checkDerefVar(var_glojure_DOT_core_list) + tmp354 := lang.Apply(tmp353, []any{sym_if}) + tmp355 := checkDerefVar(var_glojure_DOT_core_list) + tmp356 := checkDerefVar(var_glojure_DOT_core_seq) + tmp357 := checkDerefVar(var_glojure_DOT_core_concat) + tmp358 := checkDerefVar(var_glojure_DOT_core_list) + tmp359 := lang.Apply(tmp358, []any{sym_glojure_DOT_core_SLASH__LT_}) + tmp360 := checkDerefVar(var_glojure_DOT_core_list) + tmp361 := lang.Apply(tmp360, []any{v172}) + tmp362 := checkDerefVar(var_glojure_DOT_core_list) + tmp363 := lang.Apply(tmp362, []any{sym_size__1__auto__}) + tmp364 := lang.Apply(tmp357, []any{tmp359, tmp361, tmp363}) + tmp365 := lang.Apply(tmp356, []any{tmp364}) + tmp366 := lang.Apply(tmp355, []any{tmp365}) + tmp367 := checkDerefVar(var_glojure_DOT_core_list) + tmp368 := checkDerefVar(var_glojure_DOT_core_seq) + tmp369 := checkDerefVar(var_glojure_DOT_core_concat) + tmp370 := checkDerefVar(var_glojure_DOT_core_list) + tmp371 := lang.Apply(tmp370, []any{sym_glojure_DOT_core_SLASH_let}) + tmp372 := checkDerefVar(var_glojure_DOT_core_list) + tmp373 := checkDerefVar(var_glojure_DOT_core_apply) + tmp374 := checkDerefVar(var_glojure_DOT_core_vector) + tmp375 := checkDerefVar(var_glojure_DOT_core_seq) + tmp376 := checkDerefVar(var_glojure_DOT_core_concat) + tmp377 := checkDerefVar(var_glojure_DOT_core_list) + tmp378 := lang.Apply(tmp377, []any{v65}) + tmp379 := checkDerefVar(var_glojure_DOT_core_list) + tmp380 := checkDerefVar(var_glojure_DOT_core_seq) + tmp381 := checkDerefVar(var_glojure_DOT_core_concat) + tmp382 := checkDerefVar(var_glojure_DOT_core_list) + tmp383 := lang.Apply(tmp382, []any{sym__DOT_nth}) + tmp384 := checkDerefVar(var_glojure_DOT_core_list) + tmp385 := lang.Apply(tmp384, []any{sym_c__0__auto__}) + tmp386 := checkDerefVar(var_glojure_DOT_core_list) + tmp387 := lang.Apply(tmp386, []any{v172}) + tmp388 := lang.Apply(tmp381, []any{tmp383, tmp385, tmp387}) + tmp389 := lang.Apply(tmp380, []any{tmp388}) + tmp390 := lang.Apply(tmp379, []any{tmp389}) + tmp391 := lang.Apply(tmp376, []any{tmp378, tmp390}) + tmp392 := lang.Apply(tmp375, []any{tmp391}) + tmp393 := lang.Apply(tmp373, []any{tmp374, tmp392}) + tmp394 := lang.Apply(tmp372, []any{tmp393}) + tmp395 := checkDerefVar(var_glojure_DOT_core_list) + tmp396 := lang.Apply(v179, []any{v73}) + tmp397 := lang.Apply(tmp395, []any{tmp396}) + tmp398 := lang.Apply(tmp369, []any{tmp371, tmp394, tmp397}) + tmp399 := lang.Apply(tmp368, []any{tmp398}) + tmp400 := lang.Apply(tmp367, []any{tmp399}) + tmp401 := checkDerefVar(var_glojure_DOT_core_list) + tmp402 := lang.Apply(tmp401, []any{true}) + tmp403 := lang.Apply(tmp352, []any{tmp354, tmp366, tmp400, tmp402}) + tmp404 := lang.Apply(tmp351, []any{tmp403}) + tmp405 := lang.Apply(tmp350, []any{tmp404}) + tmp406 := lang.Apply(tmp326, []any{tmp328, tmp349, tmp405}) + tmp407 := lang.Apply(tmp325, []any{tmp406}) + tmp408 := lang.Apply(tmp324, []any{tmp407}) + tmp409 := checkDerefVar(var_glojure_DOT_core_list) + tmp410 := checkDerefVar(var_glojure_DOT_core_seq) + tmp411 := checkDerefVar(var_glojure_DOT_core_concat) + tmp412 := checkDerefVar(var_glojure_DOT_core_list) + tmp413 := lang.Apply(tmp412, []any{sym_glojure_DOT_core_SLASH_chunk_DASH_cons}) + tmp414 := checkDerefVar(var_glojure_DOT_core_list) + tmp415 := checkDerefVar(var_glojure_DOT_core_seq) + tmp416 := checkDerefVar(var_glojure_DOT_core_concat) + tmp417 := checkDerefVar(var_glojure_DOT_core_list) + tmp418 := lang.Apply(tmp417, []any{sym_glojure_DOT_core_SLASH_chunk}) + tmp419 := checkDerefVar(var_glojure_DOT_core_list) + tmp420 := lang.Apply(tmp419, []any{v175}) + tmp421 := lang.Apply(tmp416, []any{tmp418, tmp420}) + tmp422 := lang.Apply(tmp415, []any{tmp421}) + tmp423 := lang.Apply(tmp414, []any{tmp422}) + tmp424 := checkDerefVar(var_glojure_DOT_core_list) + tmp425 := checkDerefVar(var_glojure_DOT_core_seq) + tmp426 := checkDerefVar(var_glojure_DOT_core_concat) + tmp427 := checkDerefVar(var_glojure_DOT_core_list) + tmp428 := lang.Apply(tmp427, []any{v88}) + tmp429 := checkDerefVar(var_glojure_DOT_core_list) + tmp430 := checkDerefVar(var_glojure_DOT_core_seq) + tmp431 := checkDerefVar(var_glojure_DOT_core_concat) + tmp432 := checkDerefVar(var_glojure_DOT_core_list) + tmp433 := lang.Apply(tmp432, []any{sym_glojure_DOT_core_SLASH_chunk_DASH_rest}) + tmp434 := checkDerefVar(var_glojure_DOT_core_list) + tmp435 := lang.Apply(tmp434, []any{v91}) + tmp436 := lang.Apply(tmp431, []any{tmp433, tmp435}) + tmp437 := lang.Apply(tmp430, []any{tmp436}) + tmp438 := lang.Apply(tmp429, []any{tmp437}) + tmp439 := lang.Apply(tmp426, []any{tmp428, tmp438}) + tmp440 := lang.Apply(tmp425, []any{tmp439}) + tmp441 := lang.Apply(tmp424, []any{tmp440}) + tmp442 := lang.Apply(tmp411, []any{tmp413, tmp423, tmp441}) + tmp443 := lang.Apply(tmp410, []any{tmp442}) + tmp444 := lang.Apply(tmp409, []any{tmp443}) + tmp445 := checkDerefVar(var_glojure_DOT_core_list) + tmp446 := checkDerefVar(var_glojure_DOT_core_seq) + tmp447 := checkDerefVar(var_glojure_DOT_core_concat) + tmp448 := checkDerefVar(var_glojure_DOT_core_list) + tmp449 := lang.Apply(tmp448, []any{sym_glojure_DOT_core_SLASH_chunk_DASH_cons}) + tmp450 := checkDerefVar(var_glojure_DOT_core_list) + tmp451 := checkDerefVar(var_glojure_DOT_core_seq) + tmp452 := checkDerefVar(var_glojure_DOT_core_concat) + tmp453 := checkDerefVar(var_glojure_DOT_core_list) + tmp454 := lang.Apply(tmp453, []any{sym_glojure_DOT_core_SLASH_chunk}) + tmp455 := checkDerefVar(var_glojure_DOT_core_list) + tmp456 := lang.Apply(tmp455, []any{v175}) + tmp457 := lang.Apply(tmp452, []any{tmp454, tmp456}) + tmp458 := lang.Apply(tmp451, []any{tmp457}) + tmp459 := lang.Apply(tmp450, []any{tmp458}) + tmp460 := checkDerefVar(var_glojure_DOT_core_list) + tmp461 := lang.Apply(tmp460, []any{nil}) + tmp462 := lang.Apply(tmp447, []any{tmp449, tmp459, tmp461}) + tmp463 := lang.Apply(tmp446, []any{tmp462}) + tmp464 := lang.Apply(tmp445, []any{tmp463}) + tmp465 := lang.Apply(tmp321, []any{tmp323, tmp408, tmp444, tmp464}) + tmp466 := lang.Apply(tmp320, []any{tmp465}) + tmp467 := lang.Apply(tmp319, []any{tmp466}) + tmp468 := lang.Apply(tmp263, []any{tmp265, tmp318, tmp467}) + tmp469 := lang.Apply(tmp262, []any{tmp468}) + tmp470 := lang.Apply(tmp261, []any{tmp469}) + tmp471 := checkDerefVar(var_glojure_DOT_core_list) + tmp472 := checkDerefVar(var_glojure_DOT_core_seq) + tmp473 := checkDerefVar(var_glojure_DOT_core_concat) + tmp474 := checkDerefVar(var_glojure_DOT_core_list) + tmp475 := lang.Apply(tmp474, []any{sym_glojure_DOT_core_SLASH_let}) + tmp476 := checkDerefVar(var_glojure_DOT_core_list) + tmp477 := checkDerefVar(var_glojure_DOT_core_apply) + tmp478 := checkDerefVar(var_glojure_DOT_core_vector) + tmp479 := checkDerefVar(var_glojure_DOT_core_seq) + tmp480 := checkDerefVar(var_glojure_DOT_core_concat) + tmp481 := checkDerefVar(var_glojure_DOT_core_list) + tmp482 := lang.Apply(tmp481, []any{v65}) + tmp483 := checkDerefVar(var_glojure_DOT_core_list) + tmp484 := checkDerefVar(var_glojure_DOT_core_seq) + tmp485 := checkDerefVar(var_glojure_DOT_core_concat) + tmp486 := checkDerefVar(var_glojure_DOT_core_list) + tmp487 := lang.Apply(tmp486, []any{sym_glojure_DOT_core_SLASH_first}) + tmp488 := checkDerefVar(var_glojure_DOT_core_list) + tmp489 := lang.Apply(tmp488, []any{v91}) + tmp490 := lang.Apply(tmp485, []any{tmp487, tmp489}) + tmp491 := lang.Apply(tmp484, []any{tmp490}) + tmp492 := lang.Apply(tmp483, []any{tmp491}) + tmp493 := lang.Apply(tmp480, []any{tmp482, tmp492}) + tmp494 := lang.Apply(tmp479, []any{tmp493}) + tmp495 := lang.Apply(tmp477, []any{tmp478, tmp494}) + tmp496 := lang.Apply(tmp476, []any{tmp495}) + tmp497 := checkDerefVar(var_glojure_DOT_core_list) + tmp498 := lang.Apply(v95, []any{v73}) + tmp499 := lang.Apply(tmp497, []any{tmp498}) + tmp500 := lang.Apply(tmp473, []any{tmp475, tmp496, tmp499}) + tmp501 := lang.Apply(tmp472, []any{tmp500}) + tmp502 := lang.Apply(tmp471, []any{tmp501}) + tmp503 := lang.Apply(tmp248, []any{tmp250, tmp260, tmp470, tmp502}) + tmp504 := lang.Apply(tmp247, []any{tmp503}) + tmp505 := lang.Apply(tmp246, []any{tmp504}) + tmp506 := lang.Apply(tmp222, []any{tmp224, tmp245, tmp505}) + tmp507 := lang.Apply(tmp221, []any{tmp506}) + tmp508 := lang.Apply(tmp220, []any{tmp507}) + tmp509 := lang.Apply(tmp204, []any{tmp206, tmp219, tmp508}) + tmp510 := lang.Apply(tmp203, []any{tmp509}) + tmp511 := lang.Apply(tmp202, []any{tmp510}) + tmp512 := lang.Apply(tmp199, []any{tmp201, tmp511}) + tmp513 := lang.Apply(tmp198, []any{tmp512}) + tmp514 := lang.Apply(tmp197, []any{tmp513}) + tmp515 := lang.Apply(tmp181, []any{tmp183, tmp185, tmp196, tmp514}) + tmp516 := lang.Apply(tmp180, []any{tmp515}) + tmp169 = tmp516 + } // end let + tmp96 = tmp169 + } + tmp85 = tmp96 + } // end let + tmp44 = tmp85 + } // end let + return tmp44 + }) + v42 = tmp41 + _ = v42 + } + tmp42 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4668), kw_column, int(19), kw_end_DASH_line, int(4729), kw_end_DASH_column, int(68)) + tmp43, err := lang.WithMeta(tmp41, tmp42.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v44 any = tmp43 + _ = v44 + tmp45 := checkDerefVar(var_glojure_DOT_core_seq) + tmp46 := checkDerefVar(var_glojure_DOT_core_concat) + tmp47 := checkDerefVar(var_glojure_DOT_core_list) + tmp48 := lang.Apply(tmp47, []any{sym_glojure_DOT_core_SLASH_let}) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) + tmp50 := checkDerefVar(var_glojure_DOT_core_apply) + tmp51 := checkDerefVar(var_glojure_DOT_core_vector) + tmp52 := checkDerefVar(var_glojure_DOT_core_seq) + tmp53 := checkDerefVar(var_glojure_DOT_core_concat) + tmp54 := checkDerefVar(var_glojure_DOT_core_list) + tmp55 := lang.Apply(tmp54, []any{sym_iter__0__auto__}) + tmp56 := checkDerefVar(var_glojure_DOT_core_list) + tmp57 := lang.Apply(v36, []any{v4}) + tmp58 := lang.Apply(v44, []any{tmp57}) + tmp59 := lang.Apply(tmp56, []any{tmp58}) + tmp60 := lang.Apply(tmp53, []any{tmp55, tmp59}) + tmp61 := lang.Apply(tmp52, []any{tmp60}) + tmp62 := lang.Apply(tmp50, []any{tmp51, tmp61}) + tmp63 := lang.Apply(tmp49, []any{tmp62}) + tmp64 := checkDerefVar(var_glojure_DOT_core_list) + tmp65 := checkDerefVar(var_glojure_DOT_core_seq) + tmp66 := checkDerefVar(var_glojure_DOT_core_concat) + tmp67 := checkDerefVar(var_glojure_DOT_core_list) + tmp68 := lang.Apply(tmp67, []any{sym_iter__0__auto__}) + tmp69 := checkDerefVar(var_glojure_DOT_core_list) + tmp70 := checkDerefVar(var_glojure_DOT_core_second) + tmp71 := lang.Apply(tmp70, []any{v4}) + tmp72 := lang.Apply(tmp69, []any{tmp71}) + tmp73 := lang.Apply(tmp66, []any{tmp68, tmp72}) + tmp74 := lang.Apply(tmp65, []any{tmp73}) + tmp75 := lang.Apply(tmp64, []any{tmp74}) + tmp76 := lang.Apply(tmp46, []any{tmp48, tmp63, tmp75}) + tmp77 := lang.Apply(tmp45, []any{tmp76}) + tmp32 = tmp77 + } // end let + return tmp32 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_for = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_for.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // let + { + tmp0 := sym_let.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "binding => binding-form init-expr\n binding-form => name, or destructuring-form\n destructuring-form => map-destructure-form, or seq-destructure-form\n\n Evaluates the exprs in a lexical context in which the symbols in\n the binding-forms are bound to their respective init-exprs or parts\n therein.\n\n See https://glojure.org/reference/special_forms#binding-forms for\n more information about destructuring.", kw_forms, lang.NewVector(lang.NewList(sym_let, lang.NewVector(sym_bindings_STAR_), sym_exprs_STAR_)), kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(11), kw_line, int(4496), kw_end_DASH_line, int(4496), kw_special_DASH_form, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v4}) + if lang.IsTruthy(tmp8) { + } else { + tmp9 := checkDerefVar(var_glojure_DOT_core_str) + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp13 := checkDerefVar(var_glojure_DOT_core_meta) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(kw_line, []any{tmp14}) + tmp16 := lang.Apply(tmp9, []any{tmp11, " requires ", "a vector for its binding", " in ", tmp12, ":", tmp15}) + tmp17 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp16}) + panic(tmp17) + } + _ = tmp6 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_even_QMARK_) + tmp20 := checkDerefVar(var_glojure_DOT_core_count) + tmp21 := lang.Apply(tmp20, []any{v4}) + tmp22 := lang.Apply(tmp19, []any{tmp21}) + if lang.IsTruthy(tmp22) { + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp27 := checkDerefVar(var_glojure_DOT_core_meta) + tmp28 := lang.Apply(tmp27, []any{v2}) + tmp29 := lang.Apply(kw_line, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp25, " requires ", "an even number of forms in binding vector", " in ", tmp26, ":", tmp29}) + tmp31 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp31) + } + _ = tmp18 + tmp32 := checkDerefVar(var_glojure_DOT_core_seq) + tmp33 := checkDerefVar(var_glojure_DOT_core_concat) + tmp34 := checkDerefVar(var_glojure_DOT_core_list) + tmp35 := lang.Apply(tmp34, []any{sym_let_STAR_}) + tmp36 := checkDerefVar(var_glojure_DOT_core_list) + tmp37 := checkDerefVar(var_glojure_DOT_core_destructure) + tmp38 := lang.Apply(tmp37, []any{v4}) + tmp39 := lang.Apply(tmp36, []any{tmp38}) + tmp40 := lang.Apply(tmp33, []any{tmp35, tmp39, v5}) + tmp41 := lang.Apply(tmp32, []any{tmp40}) + return tmp41 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_let = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_let.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // loop + { + tmp0 := sym_loop.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "Evaluates the exprs in a lexical context in which the symbols in\n the binding-forms are bound to their respective init-exprs or parts\n therein. Acts as a recur target.", kw_forms, lang.NewVector(lang.NewList(sym_loop, lang.NewVector(sym_bindings_STAR_), sym_exprs_STAR_)), kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(11), kw_line, int(4597), kw_end_DASH_line, int(4597), kw_special_DASH_form, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v4}) + if lang.IsTruthy(tmp8) { + } else { + tmp9 := checkDerefVar(var_glojure_DOT_core_str) + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp13 := checkDerefVar(var_glojure_DOT_core_meta) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(kw_line, []any{tmp14}) + tmp16 := lang.Apply(tmp9, []any{tmp11, " requires ", "a vector for its binding", " in ", tmp12, ":", tmp15}) + tmp17 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp16}) + panic(tmp17) + } + _ = tmp6 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_even_QMARK_) + tmp20 := checkDerefVar(var_glojure_DOT_core_count) + tmp21 := lang.Apply(tmp20, []any{v4}) + tmp22 := lang.Apply(tmp19, []any{tmp21}) + if lang.IsTruthy(tmp22) { + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp27 := checkDerefVar(var_glojure_DOT_core_meta) + tmp28 := lang.Apply(tmp27, []any{v2}) + tmp29 := lang.Apply(kw_line, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp25, " requires ", "an even number of forms in binding vector", " in ", tmp26, ":", tmp29}) + tmp31 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp31) + } + _ = tmp18 + var tmp32 any + { // let + // let binding "db" + tmp33 := checkDerefVar(var_glojure_DOT_core_destructure) + tmp34 := lang.Apply(tmp33, []any{v4}) + var v35 any = tmp34 + _ = v35 + var tmp36 any + tmp37 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp38 := lang.Apply(tmp37, []any{v35, v4}) + if lang.IsTruthy(tmp38) { + tmp39 := checkDerefVar(var_glojure_DOT_core_seq) + tmp40 := checkDerefVar(var_glojure_DOT_core_concat) + tmp41 := checkDerefVar(var_glojure_DOT_core_list) + tmp42 := lang.Apply(tmp41, []any{sym_loop_STAR_}) + tmp43 := checkDerefVar(var_glojure_DOT_core_list) + tmp44 := lang.Apply(tmp43, []any{v4}) + tmp45 := lang.Apply(tmp40, []any{tmp42, tmp44, v5}) + tmp46 := lang.Apply(tmp39, []any{tmp45}) + tmp36 = tmp46 + } else { + var tmp47 any + { // let + // let binding "vs" + tmp48 := checkDerefVar(var_glojure_DOT_core_take_DASH_nth) + tmp49 := checkDerefVar(var_glojure_DOT_core_drop) + tmp50 := lang.Apply(tmp49, []any{int64(1), v4}) + tmp51 := lang.Apply(tmp48, []any{int64(2), tmp50}) + var v52 any = tmp51 + _ = v52 + // let binding "bs" + tmp53 := checkDerefVar(var_glojure_DOT_core_take_DASH_nth) + tmp54 := lang.Apply(tmp53, []any{int64(2), v4}) + var v55 any = tmp54 + _ = v55 + // let binding "gs" + tmp56 := checkDerefVar(var_glojure_DOT_core_map) + var tmp57 lang.FnFunc + tmp57 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v58 := args[0] + _ = v58 + var tmp59 any + tmp60 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp61 := lang.Apply(tmp60, []any{v58}) + if lang.IsTruthy(tmp61) { + tmp59 = v58 + } else { + tmp62 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp63 := lang.Apply(tmp62, nil) + tmp59 = tmp63 + } + return tmp59 + }) + tmp58 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4611), kw_column, int(23), kw_end_DASH_line, int(4611), kw_end_DASH_column, int(58)) + tmp59, err := lang.WithMeta(tmp57, tmp58.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp60 := lang.Apply(tmp56, []any{tmp59, v55}) + var v61 any = tmp60 + _ = v61 + // let binding "bfs" + tmp62 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp63 lang.FnFunc + tmp63 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v64 := args[0] + _ = v64 + v65 := args[1] + _ = v65 + var tmp66 any + { // let + // let binding "vec__708" + var v67 any = v65 + _ = v67 + // let binding "b" + tmp68 := checkDerefVar(var_glojure_DOT_core_nth) + tmp69 := lang.Apply(tmp68, []any{v67, int64(0), nil}) + var v70 any = tmp69 + _ = v70 + // let binding "v" + tmp71 := checkDerefVar(var_glojure_DOT_core_nth) + tmp72 := lang.Apply(tmp71, []any{v67, int64(1), nil}) + var v73 any = tmp72 + _ = v73 + // let binding "g" + tmp74 := checkDerefVar(var_glojure_DOT_core_nth) + tmp75 := lang.Apply(tmp74, []any{v67, int64(2), nil}) + var v76 any = tmp75 + _ = v76 + var tmp77 any + tmp78 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp79 := lang.Apply(tmp78, []any{v70}) + if lang.IsTruthy(tmp79) { + tmp80 := checkDerefVar(var_glojure_DOT_core_conj) + tmp81 := lang.Apply(tmp80, []any{v64, v76, v73}) + tmp77 = tmp81 + } else { + tmp82 := checkDerefVar(var_glojure_DOT_core_conj) + tmp83 := lang.Apply(tmp82, []any{v64, v76, v73, v70, v76}) + tmp77 = tmp83 + } + tmp66 = tmp77 + } // end let + return tmp66 + }) + tmp64 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4612), kw_column, int(28), kw_end_DASH_line, int(4615), kw_end_DASH_column, int(50)) + tmp65, err := lang.WithMeta(tmp63, tmp64.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp66 := lang.NewVector() + tmp67 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4616), kw_column, int(27), kw_end_DASH_line, int(4616), kw_end_DASH_column, int(28)) + tmp68, err := lang.WithMeta(tmp66, tmp67.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp69 := checkDerefVar(var_glojure_DOT_core_map) + tmp70 := checkDerefVar(var_glojure_DOT_core_vector) + tmp71 := lang.Apply(tmp69, []any{tmp70, v55, v52, v61}) + tmp72 := lang.Apply(tmp62, []any{tmp65, tmp68, tmp71}) + var v73 any = tmp72 + _ = v73 + tmp74 := checkDerefVar(var_glojure_DOT_core_seq) + tmp75 := checkDerefVar(var_glojure_DOT_core_concat) + tmp76 := checkDerefVar(var_glojure_DOT_core_list) + tmp77 := lang.Apply(tmp76, []any{sym_glojure_DOT_core_SLASH_let}) + tmp78 := checkDerefVar(var_glojure_DOT_core_list) + tmp79 := lang.Apply(tmp78, []any{v73}) + tmp80 := checkDerefVar(var_glojure_DOT_core_list) + tmp81 := checkDerefVar(var_glojure_DOT_core_seq) + tmp82 := checkDerefVar(var_glojure_DOT_core_concat) + tmp83 := checkDerefVar(var_glojure_DOT_core_list) + tmp84 := lang.Apply(tmp83, []any{sym_loop_STAR_}) + tmp85 := checkDerefVar(var_glojure_DOT_core_list) + tmp86 := checkDerefVar(var_glojure_DOT_core_vec) + tmp87 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp88 := lang.Apply(tmp87, []any{v61, v61}) + tmp89 := lang.Apply(tmp86, []any{tmp88}) + tmp90 := lang.Apply(tmp85, []any{tmp89}) + tmp91 := checkDerefVar(var_glojure_DOT_core_list) + tmp92 := checkDerefVar(var_glojure_DOT_core_seq) + tmp93 := checkDerefVar(var_glojure_DOT_core_concat) + tmp94 := checkDerefVar(var_glojure_DOT_core_list) + tmp95 := lang.Apply(tmp94, []any{sym_glojure_DOT_core_SLASH_let}) + tmp96 := checkDerefVar(var_glojure_DOT_core_list) + tmp97 := checkDerefVar(var_glojure_DOT_core_vec) + tmp98 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp99 := lang.Apply(tmp98, []any{v55, v61}) + tmp100 := lang.Apply(tmp97, []any{tmp99}) + tmp101 := lang.Apply(tmp96, []any{tmp100}) + tmp102 := lang.Apply(tmp93, []any{tmp95, tmp101, v5}) + tmp103 := lang.Apply(tmp92, []any{tmp102}) + tmp104 := lang.Apply(tmp91, []any{tmp103}) + tmp105 := lang.Apply(tmp82, []any{tmp84, tmp90, tmp104}) + tmp106 := lang.Apply(tmp81, []any{tmp105}) + tmp107 := lang.Apply(tmp80, []any{tmp106}) + tmp108 := lang.Apply(tmp75, []any{tmp77, tmp79, tmp107}) + tmp109 := lang.Apply(tmp74, []any{tmp108}) + tmp47 = tmp109 + } // end let + tmp36 = tmp47 + } + tmp32 = tmp36 + } // end let + return tmp32 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_loop = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_loop.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print-map + { + tmp0 := sym_print_DASH_map.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(252), kw_column, int(8), kw_end_DASH_line, int(252), kw_end_DASH_column, int(16), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_m, sym_print_DASH_one, sym_w)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_print_DASH_prefix_DASH_map) + tmp6 := lang.Apply(tmp5, []any{nil, v2, v3, v4}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_print_DASH_map = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_print_DASH_map.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + var closed11 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_seq_DASH_reduce) + tmp4 := lang.Apply(tmp3, []any{v1, v2}) + return tmp4 + case 3: + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + v3 := args[2] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_seq_DASH_reduce) + tmp5 := lang.Apply(tmp4, []any{v1, v2, v3}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + closed11 = tmp0 + } + var closed12 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_seq_DASH_reduce) + tmp4 := lang.Apply(tmp3, []any{v1, v2}) + return tmp4 + case 3: + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + v3 := args[2] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_seq_DASH_reduce) + tmp5 := lang.Apply(tmp4, []any{v1, v2, v3}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + closed12 = tmp0 + } + var closed14 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + v3 := args[2] + _ = v3 + recur_loop_2815: + var tmp4 any + { // let + // let binding "temp__0__auto__" + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := lang.Apply(tmp5, []any{v1}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + if lang.IsTruthy(v7) { + var tmp9 any + { // let + // let binding "s" + var v10 any = v7 + _ = v10 + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp13 := lang.Apply(tmp12, []any{v10}) + if lang.IsTruthy(tmp13) { + var tmp14 any + { // let + // let binding "ret" + tmp15 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp16 := lang.Apply(tmp15, []any{v10}) + tmp17, _ := lang.FieldOrMethod(tmp16, "ReduceInit") + if reflect.TypeOf(tmp17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) + } + tmp18 := lang.Apply(tmp17, []any{v2, v3}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + tmp21 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) + tmp22 := lang.Apply(tmp21, []any{v19}) + if lang.IsTruthy(tmp22) { + tmp23 := checkDerefVar(var_glojure_DOT_core_deref) + tmp24 := lang.Apply(tmp23, []any{v19}) + tmp20 = tmp24 + } else { + tmp26 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_next) + tmp27 := lang.Apply(tmp26, []any{v10}) + var tmp25 any = tmp27 + var tmp28 any = v2 + var tmp29 any = v19 + v1 = tmp25 + v2 = tmp28 + v3 = tmp29 + goto recur_loop_2815 + } + tmp14 = tmp20 + } // end let + tmp11 = tmp14 + } else { + tmp15 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_interface_DASH_or_DASH_naive_DASH_reduce) + tmp16 := lang.Apply(tmp15, []any{v10, v2, v3}) + tmp11 = tmp16 + } + tmp9 = tmp11 + } // end let + tmp8 = tmp9 + } else { + tmp8 = v3 + } + tmp4 = tmp8 + } // end let + return tmp4 + }) + closed14 = tmp0 + } + var closed15 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + v3 := args[2] + _ = v3 + var tmp4 any + { // let + // let binding "cls" + tmp5 := checkDerefVar(var_glojure_DOT_core_class) + tmp6 := lang.Apply(tmp5, []any{v1}) + var v7 any = tmp6 + _ = v7 + // let binding "s" + var v8 any = v1 + _ = v8 + // let binding "f" + var v9 any = v2 + _ = v9 + // let binding "val" + var v10 any = v3 + _ = v10 + for { + var tmp11 any + { // let + // let binding "temp__0__auto__" + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := lang.Apply(tmp12, []any{v8}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + var tmp16 any + { // let + // let binding "s" + var v17 any = v14 + _ = v17 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_identical_QMARK_) + tmp20 := checkDerefVar(var_glojure_DOT_core_class) + tmp21 := lang.Apply(tmp20, []any{v17}) + tmp22 := lang.Apply(tmp19, []any{tmp21, v7}) + if lang.IsTruthy(tmp22) { + var tmp23 any + { // let + // let binding "ret" + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v17}) + tmp26 := lang.Apply(v9, []any{v10, tmp25}) + var v27 any = tmp26 + _ = v27 + var tmp28 any + tmp29 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) + tmp30 := lang.Apply(tmp29, []any{v27}) + if lang.IsTruthy(tmp30) { + tmp31 := checkDerefVar(var_glojure_DOT_core_deref) + tmp32 := lang.Apply(tmp31, []any{v27}) + tmp28 = tmp32 + } else { + var tmp33 any = v7 + tmp35 := checkDerefVar(var_glojure_DOT_core_next) + tmp36 := lang.Apply(tmp35, []any{v17}) + var tmp34 any = tmp36 + var tmp37 any = v9 + var tmp38 any = v27 + v7 = tmp33 + v8 = tmp34 + v9 = tmp37 + v10 = tmp38 + continue + } + tmp23 = tmp28 + } // end let + tmp18 = tmp23 + } else { + tmp24 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_interface_DASH_or_DASH_naive_DASH_reduce) + tmp25 := lang.Apply(tmp24, []any{v17, v9, v10}) + tmp18 = tmp25 + } + tmp16 = tmp18 + } // end let + tmp15 = tmp16 + } else { + tmp15 = v10 + } + tmp11 = tmp15 + } // end let + tmp4 = tmp11 + break + } + } // end let + return tmp4 + }) + closed15 = tmp0 + } + // -protocols + { + tmp0 := sym__DASH_protocols.WithMeta(lang.NewMap(kw_private, true, kw_doc, "Private store of protocols. Go's reflection capabilities\n don't yet support a native interface-based implementation, so\n protocols are implemented in Glojure as maps from type to protocol\n method implementations.", kw_file, "glojure/core_deftype.glj", kw_line, int(21), kw_column, int(3), kw_end_DASH_line, int(26), kw_end_DASH_column, int(12), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v5 := args[0] + _ = v5 + var v6 any = lang.NewList(args[1:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_class) + tmp8 := lang.Apply(tmp7, []any{v5}) + return tmp8 + } + }) + tmp3 := lang.NewMultiFn("coll-reduce", tmp4, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v6 := args[0] + _ = v6 + var v7 any = lang.NewList(args[1:]...) + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_apply) + tmp9 := checkDerefVar(var_glojure_DOT_core_cons) + tmp10 := lang.Apply(tmp9, []any{v6, v7}) + tmp11 := lang.Apply(tmp8, []any{closed9, tmp10}) + return tmp11 + } + }) + tmp3.AddMethod(nil, tmp5) + tmp6 := reflect.TypeOf((*lang.IReduceInit)(nil)).Elem() + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v8 := args[0] + _ = v8 + var v9 any = lang.NewList(args[1:]...) + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_apply) + tmp11 := checkDerefVar(var_glojure_DOT_core_cons) + tmp12 := lang.Apply(tmp11, []any{v8, v9}) + tmp13 := lang.Apply(tmp10, []any{closed10, tmp12}) + return tmp13 + } + }) + tmp3.AddMethod(tmp6, tmp7) + tmp8 := reflect.TypeOf((*lang.LazySeq)(nil)) + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v10 := args[0] + _ = v10 + var v11 any = lang.NewList(args[1:]...) + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_apply) + tmp13 := checkDerefVar(var_glojure_DOT_core_cons) + tmp14 := lang.Apply(tmp13, []any{v10, v11}) + tmp15 := lang.Apply(tmp12, []any{closed11, tmp14}) + return tmp15 + } + }) + tmp3.AddMethod(tmp8, tmp9) + tmp10 := reflect.TypeOf((*lang.Vector)(nil)) + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v12 := args[0] + _ = v12 + var v13 any = lang.NewList(args[1:]...) + _ = v13 + tmp14 := checkDerefVar(var_glojure_DOT_core_apply) + tmp15 := checkDerefVar(var_glojure_DOT_core_cons) + tmp16 := lang.Apply(tmp15, []any{v12, v13}) + tmp17 := lang.Apply(tmp14, []any{closed12, tmp16}) + return tmp17 + } + }) + tmp3.AddMethod(tmp10, tmp11) + tmp2 := lang.NewAtom(lang.NewMap(kw_multis, lang.NewMap(kw_coll_DASH_reduce, tmp3), kw_on_DASH_interface, true, kw_sigs, lang.NewList(lang.NewList(sym_coll_DASH_reduce, lang.NewVector(sym_coll, sym_f), lang.NewVector(sym_coll, sym_f, sym_val))))) + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v15 := args[0] + _ = v15 + var v16 any = lang.NewList(args[1:]...) + _ = v16 + tmp17 := checkDerefVar(var_glojure_DOT_core_class) + tmp18 := lang.Apply(tmp17, []any{v15}) + return tmp18 + } + }) + tmp13 := lang.NewMultiFn("internal-reduce", tmp14, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) + var tmp15 lang.FnFunc + tmp15 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v16 := args[0] + _ = v16 + var v17 any = lang.NewList(args[1:]...) + _ = v17 + tmp18 := checkDerefVar(var_glojure_DOT_core_apply) + tmp19 := checkDerefVar(var_glojure_DOT_core_cons) + tmp20 := lang.Apply(tmp19, []any{v16, v17}) + tmp21 := lang.Apply(tmp18, []any{closed13, tmp20}) + return tmp21 + } + }) + tmp13.AddMethod(nil, tmp15) + tmp16 := reflect.TypeOf((*lang.IChunkedSeq)(nil)).Elem() + var tmp17 lang.FnFunc + tmp17 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v18 := args[0] + _ = v18 + var v19 any = lang.NewList(args[1:]...) + _ = v19 + tmp20 := checkDerefVar(var_glojure_DOT_core_apply) + tmp21 := checkDerefVar(var_glojure_DOT_core_cons) + tmp22 := lang.Apply(tmp21, []any{v18, v19}) + tmp23 := lang.Apply(tmp20, []any{closed14, tmp22}) + return tmp23 + } + }) + tmp13.AddMethod(tmp16, tmp17) + tmp18 := reflect.TypeOf((*lang.Object)(nil)).Elem() + var tmp19 lang.FnFunc + tmp19 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v20 := args[0] + _ = v20 + var v21 any = lang.NewList(args[1:]...) + _ = v21 + tmp22 := checkDerefVar(var_glojure_DOT_core_apply) + tmp23 := checkDerefVar(var_glojure_DOT_core_cons) + tmp24 := lang.Apply(tmp23, []any{v20, v21}) + tmp25 := lang.Apply(tmp22, []any{closed15, tmp24}) + return tmp25 + } + }) + tmp13.AddMethod(tmp18, tmp19) + tmp12 := lang.NewAtom(lang.NewMap(kw_multis, lang.NewMap(kw_internal_DASH_reduce, tmp13), kw_on_DASH_interface, true, kw_sigs, lang.NewList(lang.NewList(sym_internal_DASH_reduce, lang.NewVector(sym_seq, sym_f, sym_start))))) + var tmp22 lang.FnFunc + tmp22 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v23 := args[0] + _ = v23 + var v24 any = lang.NewList(args[1:]...) + _ = v24 + tmp25 := checkDerefVar(var_glojure_DOT_core_class) + tmp26 := lang.Apply(tmp25, []any{v23}) + return tmp26 + } + }) + tmp21 := lang.NewMultiFn("kv-reduce", tmp22, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) + tmp20 := lang.NewAtom(lang.NewMap(kw_multis, lang.NewMap(kw_kv_DASH_reduce, tmp21), kw_on_DASH_interface, true, kw_sigs, lang.NewList(lang.NewList(sym_kv_DASH_reduce, lang.NewVector(sym_amap, sym_f, sym_init))))) + var tmp25 lang.FnFunc + tmp25 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v26 := args[0] + _ = v26 + var v27 any = lang.NewList(args[1:]...) + _ = v27 + tmp28 := checkDerefVar(var_glojure_DOT_core_class) + tmp29 := lang.Apply(tmp28, []any{v26}) + return tmp29 + } + }) + tmp24 := lang.NewMultiFn("datafy", tmp25, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) + var tmp26 lang.FnFunc + tmp26 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v27 := args[0] + _ = v27 + var v28 any = lang.NewList(args[1:]...) + _ = v28 + tmp29 := checkDerefVar(var_glojure_DOT_core_apply) + tmp30 := checkDerefVar(var_glojure_DOT_core_cons) + tmp31 := lang.Apply(tmp30, []any{v27, v28}) + tmp32 := lang.Apply(tmp29, []any{closed16, tmp31}) + return tmp32 + } + }) + tmp24.AddMethod(nil, tmp26) + tmp23 := lang.NewAtom(lang.NewMap(kw_multis, lang.NewMap(kw_datafy, tmp24), kw_on_DASH_interface, true, kw_sigs, lang.NewList(lang.NewList(sym_datafy, lang.NewVector(sym_o), "return a representation of o as data (default identity)")))) + var tmp29 lang.FnFunc + tmp29 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v30 := args[0] + _ = v30 + var v31 any = lang.NewList(args[1:]...) + _ = v31 + tmp32 := checkDerefVar(var_glojure_DOT_core_class) + tmp33 := lang.Apply(tmp32, []any{v30}) + return tmp33 + } + }) + tmp28 := lang.NewMultiFn("nav", tmp29, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) + tmp27 := lang.NewAtom(lang.NewMap(kw_multis, lang.NewMap(kw_nav, tmp28), kw_on_DASH_interface, true, kw_sigs, lang.NewList(lang.NewList(sym_nav, lang.NewVector(sym_coll, sym_k, sym_v), "return (possibly transformed) v in the context of coll and k (a key/index or nil),\ndefaults to returning v.")))) + tmp1 := lang.NewAtom(lang.NewMap(sym_CollReduce, tmp2, sym_InternalReduce, tmp12, sym_IKVReduce, tmp20, sym_Datafiable, tmp23, sym_Navigable, tmp27)) + var_glojure_DOT_core__DASH_protocols = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__DASH_protocols.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // add-classpath + { + tmp0 := sym_add_DASH_classpath.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_url)), kw_doc, "DEPRECATED \n\n Adds the url (String or URL object) to the classpath per\n URLClassLoader.addURL", kw_file, "glojure/core.glj", kw_deprecated, "1.1", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(5176), kw_end_DASH_line, int(5176))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_println) + tmp4 := lang.Apply(tmp3, []any{"WARNING: add-classpath is deprecated"}) + _ = tmp4 + tmp5 := lang.Apply(nil, []any{v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_add_DASH_classpath = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_add_DASH_classpath.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // case + { + tmp0 := sym_case.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_e, sym__AMP_, sym_clauses)), kw_doc, "Takes an expression, and a set of clauses.\n\n Each clause can take the form of either:\n\n test-constant result-expr\n\n (test-constant1 ... test-constantN) result-expr\n\n The test-constants are not evaluated. They must be compile-time\n literals, and need not be quoted. If the expression is equal to a\n test-constant, the corresponding result-expr is returned. A single\n default expression can follow the clauses, and its value will be\n returned if no clause matches. If no default expression is provided\n and no clause matches, an IllegalArgumentException is thrown.\n\n Unlike cond and condp, case does a constant-time dispatch, the\n clauses are not considered sequentially. All manner of constant\n expressions are acceptable in case, including numbers, strings,\n symbols, keywords, and (Clojure) composites thereof. Note that since\n lists are used to group multiple constants that map to the same\n expression, a vector can be used to match a list if needed. The\n test-constants need not be all of the same type.", kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(11), kw_line, int(6712), kw_end_DASH_line, int(6712))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "ge" + tmp7 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp8 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp9 := lang.Apply(tmp8, nil) + tmp10 := reflect.TypeOf((*lang.Object)(nil)).Elem() + tmp11 := lang.NewMap(kw_tag, tmp10) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6738), kw_column, int(32), kw_end_DASH_line, int(6738), kw_end_DASH_column, int(84)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp14 := lang.Apply(tmp7, []any{tmp9, tmp13}) + var v15 any = tmp14 + _ = v15 + // let binding "default" + var tmp16 any + tmp17 := checkDerefVar(var_glojure_DOT_core_odd_QMARK_) + tmp18 := checkDerefVar(var_glojure_DOT_core_count) + tmp19 := lang.Apply(tmp18, []any{v5}) + tmp20 := lang.Apply(tmp17, []any{tmp19}) + if lang.IsTruthy(tmp20) { + tmp21 := checkDerefVar(var_glojure_DOT_core_last) + tmp22 := lang.Apply(tmp21, []any{v5}) + tmp16 = tmp22 + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_seq) + tmp24 := checkDerefVar(var_glojure_DOT_core_concat) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := lang.Apply(tmp25, []any{sym_throw}) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := checkDerefVar(var_glojure_DOT_core_seq) + tmp29 := checkDerefVar(var_glojure_DOT_core_concat) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := lang.Apply(tmp30, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_NewIllegalArgumentError}) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := checkDerefVar(var_glojure_DOT_core_seq) + tmp34 := checkDerefVar(var_glojure_DOT_core_concat) + tmp35 := checkDerefVar(var_glojure_DOT_core_list) + tmp36 := lang.Apply(tmp35, []any{sym_glojure_DOT_core_SLASH_str}) + tmp37 := checkDerefVar(var_glojure_DOT_core_list) + tmp38 := lang.Apply(tmp37, []any{"No matching clause: "}) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := lang.Apply(tmp39, []any{v15}) + tmp41 := lang.Apply(tmp34, []any{tmp36, tmp38, tmp40}) + tmp42 := lang.Apply(tmp33, []any{tmp41}) + tmp43 := lang.Apply(tmp32, []any{tmp42}) + tmp44 := lang.Apply(tmp29, []any{tmp31, tmp43}) + tmp45 := lang.Apply(tmp28, []any{tmp44}) + tmp46 := lang.Apply(tmp27, []any{tmp45}) + tmp47 := lang.Apply(tmp24, []any{tmp26, tmp46}) + tmp48 := lang.Apply(tmp23, []any{tmp47}) + tmp16 = tmp48 + } + var v49 any = tmp16 + _ = v49 + var tmp50 any + tmp51 := checkDerefVar(var_glojure_DOT_core__GT_) + tmp52 := checkDerefVar(var_glojure_DOT_core_count) + tmp53 := lang.Apply(tmp52, []any{v5}) + tmp54 := lang.Apply(tmp51, []any{int64(2), tmp53}) + if lang.IsTruthy(tmp54) { + tmp55 := checkDerefVar(var_glojure_DOT_core_seq) + tmp56 := checkDerefVar(var_glojure_DOT_core_concat) + tmp57 := checkDerefVar(var_glojure_DOT_core_list) + tmp58 := lang.Apply(tmp57, []any{sym_glojure_DOT_core_SLASH_let}) + tmp59 := checkDerefVar(var_glojure_DOT_core_list) + tmp60 := checkDerefVar(var_glojure_DOT_core_apply) + tmp61 := checkDerefVar(var_glojure_DOT_core_vector) + tmp62 := checkDerefVar(var_glojure_DOT_core_seq) + tmp63 := checkDerefVar(var_glojure_DOT_core_concat) + tmp64 := checkDerefVar(var_glojure_DOT_core_list) + tmp65 := lang.Apply(tmp64, []any{v15}) + tmp66 := checkDerefVar(var_glojure_DOT_core_list) + tmp67 := lang.Apply(tmp66, []any{v4}) + tmp68 := lang.Apply(tmp63, []any{tmp65, tmp67}) + tmp69 := lang.Apply(tmp62, []any{tmp68}) + tmp70 := lang.Apply(tmp60, []any{tmp61, tmp69}) + tmp71 := lang.Apply(tmp59, []any{tmp70}) + tmp72 := checkDerefVar(var_glojure_DOT_core_list) + tmp73 := lang.Apply(tmp72, []any{v49}) + tmp74 := lang.Apply(tmp56, []any{tmp58, tmp71, tmp73}) + tmp75 := lang.Apply(tmp55, []any{tmp74}) + tmp50 = tmp75 + } else { + var tmp76 any + { // let + // let binding "pairs" + tmp77 := checkDerefVar(var_glojure_DOT_core_partition) + tmp78 := lang.Apply(tmp77, []any{int64(2), v5}) + var v79 any = tmp78 + _ = v79 + // let binding "assoc-test" + var tmp80 lang.FnFunc + { // function assoc-test + var v81 lang.FnFunc + tmp80 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v82 := args[0] + _ = v82 + v83 := args[1] + _ = v83 + v84 := args[2] + _ = v84 + var tmp85 any + tmp86 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp87 := lang.Apply(tmp86, []any{v82, v83}) + if lang.IsTruthy(tmp87) { + tmp88 := checkDerefVar(var_glojure_DOT_core_str) + tmp89 := lang.Apply(tmp88, []any{"Duplicate case test constant: ", v83}) + tmp90 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp89}) + panic(tmp90) + } else { + tmp91 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp92 := lang.Apply(tmp91, []any{v82, v83, v84}) + tmp85 = tmp92 + } + return tmp85 + }) + v81 = tmp80 + _ = v81 + } + tmp81 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6745), kw_column, int(24), kw_end_DASH_line, int(6748), kw_end_DASH_column, int(48)) + tmp82, err := lang.WithMeta(tmp80, tmp81.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v83 any = tmp82 + _ = v83 + // let binding "pairs" + tmp84 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp85 lang.FnFunc + tmp85 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v86 := args[0] + _ = v86 + v87 := args[1] + _ = v87 + var tmp88 any + { // let + // let binding "vec__868" + var v89 any = v87 + _ = v89 + // let binding "test" + tmp90 := checkDerefVar(var_glojure_DOT_core_nth) + tmp91 := lang.Apply(tmp90, []any{v89, int64(0), nil}) + var v92 any = tmp91 + _ = v92 + // let binding "expr" + tmp93 := checkDerefVar(var_glojure_DOT_core_nth) + tmp94 := lang.Apply(tmp93, []any{v89, int64(1), nil}) + var v95 any = tmp94 + _ = v95 + var tmp96 any + tmp97 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp98 := lang.Apply(tmp97, []any{v92}) + if lang.IsTruthy(tmp98) { + tmp99 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp100 lang.FnFunc + tmp100 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v101 := args[0] + _ = v101 + v102 := args[1] + _ = v102 + tmp103 := lang.Apply(v83, []any{v101, v102, v95}) + return tmp103 + }) + tmp101 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6752), kw_column, int(37), kw_end_DASH_line, int(6752), kw_end_DASH_column, int(60)) + tmp102, err := lang.WithMeta(tmp100, tmp101.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp103 := lang.Apply(tmp99, []any{tmp102, v86, v92}) + tmp96 = tmp103 + } else { + tmp104 := lang.Apply(v83, []any{v86, v92, v95}) + tmp96 = tmp104 + } + tmp88 = tmp96 + } // end let + return tmp88 + }) + tmp86 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6750), kw_column, int(24), kw_end_DASH_line, int(6753), kw_end_DASH_column, int(53)) + tmp87, err := lang.WithMeta(tmp85, tmp86.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp88 := lang.NewMap() + tmp89 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6754), kw_column, int(24), kw_end_DASH_line, int(6754), kw_end_DASH_column, int(25)) + tmp90, err := lang.WithMeta(tmp88, tmp89.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp91 := lang.Apply(tmp84, []any{tmp87, tmp90, v79}) + var v92 any = tmp91 + _ = v92 + // let binding "tests" + tmp93 := checkDerefVar(var_glojure_DOT_core_keys) + tmp94 := lang.Apply(tmp93, []any{v92}) + var v95 any = tmp94 + _ = v95 + // let binding "thens" + tmp96 := checkDerefVar(var_glojure_DOT_core_vals) + tmp97 := lang.Apply(tmp96, []any{v92}) + var v98 any = tmp97 + _ = v98 + // let binding "mode" + var tmp99 any + tmp100 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + var tmp101 lang.FnFunc + tmp101 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v102 := args[0] + _ = v102 + var tmp103 any + { // let + // let binding "and__0__auto__" + tmp104 := checkDerefVar(var_glojure_DOT_core_integer_QMARK_) + tmp105 := lang.Apply(tmp104, []any{v102}) + var v106 any = tmp105 + _ = v106 + var tmp107 any + if lang.IsTruthy(v106) { + tmp108 := checkDerefVar(var_glojure_DOT_core__LT__EQ_) + tmp109 := lang.Apply(tmp108, []any{math4.MinInt, v102, math4.MaxInt}) + tmp107 = tmp109 + } else { + tmp107 = v106 + } + tmp103 = tmp107 + } // end let + return tmp103 + }) + tmp102 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6758), kw_column, int(28), kw_end_DASH_line, int(6758), kw_end_DASH_column, int(77)) + tmp103, err := lang.WithMeta(tmp101, tmp102.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp104 := lang.Apply(tmp100, []any{tmp103, v95}) + if lang.IsTruthy(tmp104) { + tmp99 = kw_ints + } else { + var tmp105 any + tmp106 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + tmp107 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp108 := lang.Apply(tmp106, []any{tmp107, v95}) + if lang.IsTruthy(tmp108) { + tmp105 = kw_identity + } else { + var tmp109 any + if lang.IsTruthy(kw_else) { + tmp109 = kw_hashes + } else { + } + tmp105 = tmp109 + } + tmp99 = tmp105 + } + var v110 any = tmp99 + _ = v110 + var tmp111 any + { // let + // let binding "pred__871" + tmp112 := checkDerefVar(var_glojure_DOT_core__EQ_) + var v113 any = tmp112 + _ = v113 + // let binding "expr__872" + var v114 any = v110 + _ = v114 + var tmp115 any + tmp116 := lang.Apply(v113, []any{kw_ints, v114}) + if lang.IsTruthy(tmp116) { + var tmp117 any + { // let + // let binding "vec__873" + tmp118 := checkDerefVar(var_glojure_DOT_core_prep_DASH_ints) + tmp119 := lang.Apply(tmp118, []any{v95, v98}) + var v120 any = tmp119 + _ = v120 + // let binding "shift" + tmp121 := checkDerefVar(var_glojure_DOT_core_nth) + tmp122 := lang.Apply(tmp121, []any{v120, int64(0), nil}) + var v123 any = tmp122 + _ = v123 + // let binding "mask" + tmp124 := checkDerefVar(var_glojure_DOT_core_nth) + tmp125 := lang.Apply(tmp124, []any{v120, int64(1), nil}) + var v126 any = tmp125 + _ = v126 + // let binding "imap" + tmp127 := checkDerefVar(var_glojure_DOT_core_nth) + tmp128 := lang.Apply(tmp127, []any{v120, int64(2), nil}) + var v129 any = tmp128 + _ = v129 + // let binding "switch-type" + tmp130 := checkDerefVar(var_glojure_DOT_core_nth) + tmp131 := lang.Apply(tmp130, []any{v120, int64(3), nil}) + var v132 any = tmp131 + _ = v132 + tmp133 := checkDerefVar(var_glojure_DOT_core_seq) + tmp134 := checkDerefVar(var_glojure_DOT_core_concat) + tmp135 := checkDerefVar(var_glojure_DOT_core_list) + tmp136 := lang.Apply(tmp135, []any{sym_glojure_DOT_core_SLASH_let}) + tmp137 := checkDerefVar(var_glojure_DOT_core_list) + tmp138 := checkDerefVar(var_glojure_DOT_core_apply) + tmp139 := checkDerefVar(var_glojure_DOT_core_vector) + tmp140 := checkDerefVar(var_glojure_DOT_core_seq) + tmp141 := checkDerefVar(var_glojure_DOT_core_concat) + tmp142 := checkDerefVar(var_glojure_DOT_core_list) + tmp143 := lang.Apply(tmp142, []any{v15}) + tmp144 := checkDerefVar(var_glojure_DOT_core_list) + tmp145 := lang.Apply(tmp144, []any{v4}) + tmp146 := lang.Apply(tmp141, []any{tmp143, tmp145}) + tmp147 := lang.Apply(tmp140, []any{tmp146}) + tmp148 := lang.Apply(tmp138, []any{tmp139, tmp147}) + tmp149 := lang.Apply(tmp137, []any{tmp148}) + tmp150 := checkDerefVar(var_glojure_DOT_core_list) + tmp151 := checkDerefVar(var_glojure_DOT_core_seq) + tmp152 := checkDerefVar(var_glojure_DOT_core_concat) + tmp153 := checkDerefVar(var_glojure_DOT_core_list) + tmp154 := lang.Apply(tmp153, []any{sym_case_STAR_}) + tmp155 := checkDerefVar(var_glojure_DOT_core_list) + tmp156 := lang.Apply(tmp155, []any{v15}) + tmp157 := checkDerefVar(var_glojure_DOT_core_list) + tmp158 := lang.Apply(tmp157, []any{v123}) + tmp159 := checkDerefVar(var_glojure_DOT_core_list) + tmp160 := lang.Apply(tmp159, []any{v126}) + tmp161 := checkDerefVar(var_glojure_DOT_core_list) + tmp162 := lang.Apply(tmp161, []any{v49}) + tmp163 := checkDerefVar(var_glojure_DOT_core_list) + tmp164 := lang.Apply(tmp163, []any{v129}) + tmp165 := checkDerefVar(var_glojure_DOT_core_list) + tmp166 := lang.Apply(tmp165, []any{v132}) + tmp167 := checkDerefVar(var_glojure_DOT_core_list) + tmp168 := lang.Apply(tmp167, []any{kw_int}) + tmp169 := lang.Apply(tmp152, []any{tmp154, tmp156, tmp158, tmp160, tmp162, tmp164, tmp166, tmp168}) + tmp170 := lang.Apply(tmp151, []any{tmp169}) + tmp171 := lang.Apply(tmp150, []any{tmp170}) + tmp172 := lang.Apply(tmp134, []any{tmp136, tmp149, tmp171}) + tmp173 := lang.Apply(tmp133, []any{tmp172}) + tmp117 = tmp173 + } // end let + tmp115 = tmp117 + } else { + var tmp118 any + tmp119 := lang.Apply(v113, []any{kw_hashes, v114}) + if lang.IsTruthy(tmp119) { + var tmp120 any + { // let + // let binding "vec__876" + tmp121 := checkDerefVar(var_glojure_DOT_core_prep_DASH_hashes) + tmp122 := lang.Apply(tmp121, []any{v15, v49, v95, v98}) + var v123 any = tmp122 + _ = v123 + // let binding "shift" + tmp124 := checkDerefVar(var_glojure_DOT_core_nth) + tmp125 := lang.Apply(tmp124, []any{v123, int64(0), nil}) + var v126 any = tmp125 + _ = v126 + // let binding "mask" + tmp127 := checkDerefVar(var_glojure_DOT_core_nth) + tmp128 := lang.Apply(tmp127, []any{v123, int64(1), nil}) + var v129 any = tmp128 + _ = v129 + // let binding "imap" + tmp130 := checkDerefVar(var_glojure_DOT_core_nth) + tmp131 := lang.Apply(tmp130, []any{v123, int64(2), nil}) + var v132 any = tmp131 + _ = v132 + // let binding "switch-type" + tmp133 := checkDerefVar(var_glojure_DOT_core_nth) + tmp134 := lang.Apply(tmp133, []any{v123, int64(3), nil}) + var v135 any = tmp134 + _ = v135 + // let binding "skip-check" + tmp136 := checkDerefVar(var_glojure_DOT_core_nth) + tmp137 := lang.Apply(tmp136, []any{v123, int64(4), nil}) + var v138 any = tmp137 + _ = v138 + tmp139 := checkDerefVar(var_glojure_DOT_core_seq) + tmp140 := checkDerefVar(var_glojure_DOT_core_concat) + tmp141 := checkDerefVar(var_glojure_DOT_core_list) + tmp142 := lang.Apply(tmp141, []any{sym_glojure_DOT_core_SLASH_let}) + tmp143 := checkDerefVar(var_glojure_DOT_core_list) + tmp144 := checkDerefVar(var_glojure_DOT_core_apply) + tmp145 := checkDerefVar(var_glojure_DOT_core_vector) + tmp146 := checkDerefVar(var_glojure_DOT_core_seq) + tmp147 := checkDerefVar(var_glojure_DOT_core_concat) + tmp148 := checkDerefVar(var_glojure_DOT_core_list) + tmp149 := lang.Apply(tmp148, []any{v15}) + tmp150 := checkDerefVar(var_glojure_DOT_core_list) + tmp151 := lang.Apply(tmp150, []any{v4}) + tmp152 := lang.Apply(tmp147, []any{tmp149, tmp151}) + tmp153 := lang.Apply(tmp146, []any{tmp152}) + tmp154 := lang.Apply(tmp144, []any{tmp145, tmp153}) + tmp155 := lang.Apply(tmp143, []any{tmp154}) + tmp156 := checkDerefVar(var_glojure_DOT_core_list) + tmp157 := checkDerefVar(var_glojure_DOT_core_seq) + tmp158 := checkDerefVar(var_glojure_DOT_core_concat) + tmp159 := checkDerefVar(var_glojure_DOT_core_list) + tmp160 := lang.Apply(tmp159, []any{sym_case_STAR_}) + tmp161 := checkDerefVar(var_glojure_DOT_core_list) + tmp162 := lang.Apply(tmp161, []any{v15}) + tmp163 := checkDerefVar(var_glojure_DOT_core_list) + tmp164 := lang.Apply(tmp163, []any{v126}) + tmp165 := checkDerefVar(var_glojure_DOT_core_list) + tmp166 := lang.Apply(tmp165, []any{v129}) + tmp167 := checkDerefVar(var_glojure_DOT_core_list) + tmp168 := lang.Apply(tmp167, []any{v49}) + tmp169 := checkDerefVar(var_glojure_DOT_core_list) + tmp170 := lang.Apply(tmp169, []any{v132}) + tmp171 := checkDerefVar(var_glojure_DOT_core_list) + tmp172 := lang.Apply(tmp171, []any{v135}) + tmp173 := checkDerefVar(var_glojure_DOT_core_list) + tmp174 := lang.Apply(tmp173, []any{kw_hash_DASH_equiv}) + tmp175 := checkDerefVar(var_glojure_DOT_core_list) + tmp176 := lang.Apply(tmp175, []any{v138}) + tmp177 := lang.Apply(tmp158, []any{tmp160, tmp162, tmp164, tmp166, tmp168, tmp170, tmp172, tmp174, tmp176}) + tmp178 := lang.Apply(tmp157, []any{tmp177}) + tmp179 := lang.Apply(tmp156, []any{tmp178}) + tmp180 := lang.Apply(tmp140, []any{tmp142, tmp155, tmp179}) + tmp181 := lang.Apply(tmp139, []any{tmp180}) + tmp120 = tmp181 + } // end let + tmp118 = tmp120 + } else { + var tmp121 any + tmp122 := lang.Apply(v113, []any{kw_identity, v114}) + if lang.IsTruthy(tmp122) { + var tmp123 any + { // let + // let binding "vec__879" + tmp124 := checkDerefVar(var_glojure_DOT_core_prep_DASH_hashes) + tmp125 := lang.Apply(tmp124, []any{v15, v49, v95, v98}) + var v126 any = tmp125 + _ = v126 + // let binding "shift" + tmp127 := checkDerefVar(var_glojure_DOT_core_nth) + tmp128 := lang.Apply(tmp127, []any{v126, int64(0), nil}) + var v129 any = tmp128 + _ = v129 + // let binding "mask" + tmp130 := checkDerefVar(var_glojure_DOT_core_nth) + tmp131 := lang.Apply(tmp130, []any{v126, int64(1), nil}) + var v132 any = tmp131 + _ = v132 + // let binding "imap" + tmp133 := checkDerefVar(var_glojure_DOT_core_nth) + tmp134 := lang.Apply(tmp133, []any{v126, int64(2), nil}) + var v135 any = tmp134 + _ = v135 + // let binding "switch-type" + tmp136 := checkDerefVar(var_glojure_DOT_core_nth) + tmp137 := lang.Apply(tmp136, []any{v126, int64(3), nil}) + var v138 any = tmp137 + _ = v138 + // let binding "skip-check" + tmp139 := checkDerefVar(var_glojure_DOT_core_nth) + tmp140 := lang.Apply(tmp139, []any{v126, int64(4), nil}) + var v141 any = tmp140 + _ = v141 + tmp142 := checkDerefVar(var_glojure_DOT_core_seq) + tmp143 := checkDerefVar(var_glojure_DOT_core_concat) + tmp144 := checkDerefVar(var_glojure_DOT_core_list) + tmp145 := lang.Apply(tmp144, []any{sym_glojure_DOT_core_SLASH_let}) + tmp146 := checkDerefVar(var_glojure_DOT_core_list) + tmp147 := checkDerefVar(var_glojure_DOT_core_apply) + tmp148 := checkDerefVar(var_glojure_DOT_core_vector) + tmp149 := checkDerefVar(var_glojure_DOT_core_seq) + tmp150 := checkDerefVar(var_glojure_DOT_core_concat) + tmp151 := checkDerefVar(var_glojure_DOT_core_list) + tmp152 := lang.Apply(tmp151, []any{v15}) + tmp153 := checkDerefVar(var_glojure_DOT_core_list) + tmp154 := lang.Apply(tmp153, []any{v4}) + tmp155 := lang.Apply(tmp150, []any{tmp152, tmp154}) + tmp156 := lang.Apply(tmp149, []any{tmp155}) + tmp157 := lang.Apply(tmp147, []any{tmp148, tmp156}) + tmp158 := lang.Apply(tmp146, []any{tmp157}) + tmp159 := checkDerefVar(var_glojure_DOT_core_list) + tmp160 := checkDerefVar(var_glojure_DOT_core_seq) + tmp161 := checkDerefVar(var_glojure_DOT_core_concat) + tmp162 := checkDerefVar(var_glojure_DOT_core_list) + tmp163 := lang.Apply(tmp162, []any{sym_case_STAR_}) + tmp164 := checkDerefVar(var_glojure_DOT_core_list) + tmp165 := lang.Apply(tmp164, []any{v15}) + tmp166 := checkDerefVar(var_glojure_DOT_core_list) + tmp167 := lang.Apply(tmp166, []any{v129}) + tmp168 := checkDerefVar(var_glojure_DOT_core_list) + tmp169 := lang.Apply(tmp168, []any{v132}) + tmp170 := checkDerefVar(var_glojure_DOT_core_list) + tmp171 := lang.Apply(tmp170, []any{v49}) + tmp172 := checkDerefVar(var_glojure_DOT_core_list) + tmp173 := lang.Apply(tmp172, []any{v135}) + tmp174 := checkDerefVar(var_glojure_DOT_core_list) + tmp175 := lang.Apply(tmp174, []any{v138}) + tmp176 := checkDerefVar(var_glojure_DOT_core_list) + tmp177 := lang.Apply(tmp176, []any{kw_hash_DASH_identity}) + tmp178 := checkDerefVar(var_glojure_DOT_core_list) + tmp179 := lang.Apply(tmp178, []any{v141}) + tmp180 := lang.Apply(tmp161, []any{tmp163, tmp165, tmp167, tmp169, tmp171, tmp173, tmp175, tmp177, tmp179}) + tmp181 := lang.Apply(tmp160, []any{tmp180}) + tmp182 := lang.Apply(tmp159, []any{tmp181}) + tmp183 := lang.Apply(tmp143, []any{tmp145, tmp158, tmp182}) + tmp184 := lang.Apply(tmp142, []any{tmp183}) + tmp123 = tmp184 + } // end let + tmp121 = tmp123 + } else { + tmp124 := checkDerefVar(var_glojure_DOT_core_str) + tmp125 := lang.Apply(tmp124, []any{"No matching clause: ", v114}) + tmp126 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp125}) + panic(tmp126) + } + tmp118 = tmp121 + } + tmp115 = tmp118 + } + tmp111 = tmp115 + } // end let + tmp76 = tmp111 + } // end let + tmp50 = tmp76 + } + tmp6 = tmp50 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_case = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_case.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // cat + { + tmp0 := sym_cat.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_rf)), kw_doc, "A transducer which concatenates the contents of each input, which must be a\n collection, into the reduction.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(7645), kw_end_DASH_line, int(7645))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "rrf" + tmp4 := checkDerefVar(var_glojure_DOT_core_preserving_DASH_reduced) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp8 := lang.Apply(v2, nil) + return tmp8 + case 1: + v8 := args[0] + _ = v8 + tmp9 := lang.Apply(v2, []any{v8}) + return tmp9 + case 2: + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_reduce) + tmp11 := lang.Apply(tmp10, []any{v6, v8, v9}) + return tmp11 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7651), kw_column, int(5), kw_end_DASH_line, int(7655), kw_end_DASH_column, int(36)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp3 = tmp9 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_cat = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_cat.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // mapcat + { + tmp0 := sym_mapcat.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym__AMP_, sym_colls)), kw_doc, "Returns the result of applying concat to the result of applying map\n to f and colls. Thus function f should return a collection. Returns\n a transducer when no collections are provided", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(2775), kw_end_DASH_line, int(2775))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_comp) + tmp4 := checkDerefVar(var_glojure_DOT_core_map) + tmp5 := lang.Apply(tmp4, []any{v2}) + tmp6 := checkDerefVar(var_glojure_DOT_core_cat) + tmp7 := lang.Apply(tmp3, []any{tmp5, tmp6}) + return tmp7 + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_apply) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_map) + tmp8 := lang.Apply(tmp6, []any{tmp7, v2, v3}) + tmp9 := lang.Apply(tmp4, []any{tmp5, tmp8}) + return tmp9 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_mapcat = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_mapcat.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // merge-hash-collisions + { + tmp0 := sym_merge_DASH_hash_DASH_collisions.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_expr_DASH_sym, sym_default, sym_tests, sym_thens)), kw_doc, "Takes a case expression, default expression, and a sequence of test constants\n and a corresponding sequence of then expressions. Returns a tuple of\n [tests thens skip-check-set] where no tests have the same hash. Each set of\n input test constants with the same hash is replaced with a single test\n constant (the case int), and their respective thens are combined into:\n (condp = expr\n test-1 then-1\n ...\n test-n then-n\n default).\n The skip-check is a set of case ints for which post-switch equivalence\n checking must not be done (the cases holding the above condp thens).", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(28), kw_column, int(8), kw_line, int(6647), kw_end_DASH_line, int(6647), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var tmp6 any + { // let + // let binding "buckets" + var tmp7 any + { // let + // let binding "m" + tmp8 := lang.NewMap() + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6661), kw_column, int(26), kw_end_DASH_line, int(6661), kw_end_DASH_column, int(27)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v11 any = tmp10 + _ = v11 + // let binding "ks" + var v12 any = v4 + _ = v12 + // let binding "vs" + var v13 any = v5 + _ = v13 + for { + var tmp14 any + var tmp15 any + { // let + // let binding "and__0__auto__" + var v16 any = v12 + _ = v16 + var tmp17 any + if lang.IsTruthy(v16) { + tmp17 = v13 + } else { + tmp17 = v16 + } + tmp15 = tmp17 + } // end let + if lang.IsTruthy(tmp15) { + tmp17 := checkDerefVar(var_glojure_DOT_core_update) + tmp18 := checkDerefVar(var_glojure_DOT_core_first) + tmp19 := lang.Apply(tmp18, []any{v12}) + tmp20 := lang.Apply(lang.Hash, []any{tmp19}) + tmp21 := checkDerefVar(var_glojure_DOT_core_fnil) + tmp22 := checkDerefVar(var_glojure_DOT_core_conj) + tmp23 := lang.NewVector() + tmp24 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6664), kw_column, int(102), kw_end_DASH_line, int(6664), kw_end_DASH_column, int(103)) + tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp26 := lang.Apply(tmp21, []any{tmp22, tmp25}) + tmp27 := checkDerefVar(var_glojure_DOT_core_first) + tmp28 := lang.Apply(tmp27, []any{v12}) + tmp29 := checkDerefVar(var_glojure_DOT_core_first) + tmp30 := lang.Apply(tmp29, []any{v13}) + tmp31 := lang.NewVector(tmp28, tmp30) + tmp32 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6664), kw_column, int(106), kw_end_DASH_line, int(6664), kw_end_DASH_column, int(128)) + tmp33, err := lang.WithMeta(tmp31, tmp32.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp34 := lang.Apply(tmp17, []any{v11, tmp20, tmp26, tmp33}) + var tmp16 any = tmp34 + tmp36 := checkDerefVar(var_glojure_DOT_core_next) + tmp37 := lang.Apply(tmp36, []any{v12}) + var tmp35 any = tmp37 + tmp39 := checkDerefVar(var_glojure_DOT_core_next) + tmp40 := lang.Apply(tmp39, []any{v13}) + var tmp38 any = tmp40 + v11 = tmp16 + v12 = tmp35 + v13 = tmp38 + continue + } else { + tmp14 = v11 + } + tmp7 = tmp14 + break + } + } // end let + var v8 any = tmp7 + _ = v8 + // let binding "assoc-multi" + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + v12 := args[2] + _ = v12 + var tmp13 any + { // let + // let binding "testexprs" + tmp14 := checkDerefVar(var_glojure_DOT_core_mapcat) + var tmp15 lang.FnFunc + tmp15 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v16 := args[0] + _ = v16 + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_first) + tmp19 := lang.Apply(tmp18, []any{v16}) + tmp20 := lang.Apply(tmp17, []any{sym_quote, tmp19}) + tmp21 := checkDerefVar(var_glojure_DOT_core_second) + tmp22 := lang.Apply(tmp21, []any{v16}) + tmp23 := lang.NewVector(tmp20, tmp22) + tmp24 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6668), kw_column, int(56), kw_end_DASH_line, int(6668), kw_end_DASH_column, int(93)) + tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp25 + }) + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6668), kw_column, int(47), kw_end_DASH_line, int(6668), kw_end_DASH_column, int(94)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp18 := lang.Apply(tmp14, []any{tmp17, v12}) + var v19 any = tmp18 + _ = v19 + // let binding "expr" + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{sym_glojure_DOT_core_SLASH_condp}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{sym_glojure_DOT_core_SLASH__EQ_}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v2}) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := lang.Apply(tmp28, []any{v3}) + tmp30 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27, v19, tmp29}) + tmp31 := lang.Apply(tmp20, []any{tmp30}) + var v32 any = tmp31 + _ = v32 + tmp33 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp34 := lang.Apply(tmp33, []any{v10, v11, v32}) + tmp13 = tmp34 + } // end let + return tmp13 + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6667), kw_column, int(21), kw_end_DASH_line, int(6670), kw_end_DASH_column, int(42)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v12 any = tmp11 + _ = v12 + // let binding "hmap" + tmp13 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v15 := args[0] + _ = v15 + v16 := args[1] + _ = v16 + var tmp17 any + { // let + // let binding "vec__855" + var v18 any = v16 + _ = v18 + // let binding "h" + tmp19 := checkDerefVar(var_glojure_DOT_core_nth) + tmp20 := lang.Apply(tmp19, []any{v18, int64(0), nil}) + var v21 any = tmp20 + _ = v21 + // let binding "bucket" + tmp22 := checkDerefVar(var_glojure_DOT_core_nth) + tmp23 := lang.Apply(tmp22, []any{v18, int64(1), nil}) + var v24 any = tmp23 + _ = v24 + var tmp25 any + tmp26 := checkDerefVar(var_glojure_DOT_core__EQ__EQ_) + tmp27 := checkDerefVar(var_glojure_DOT_core_count) + tmp28 := lang.Apply(tmp27, []any{v24}) + tmp29 := lang.Apply(tmp26, []any{int64(1), tmp28}) + if lang.IsTruthy(tmp29) { + tmp30 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp31 := checkDerefVar(var_glojure_DOT_core_ffirst) + tmp32 := lang.Apply(tmp31, []any{v24}) + tmp33 := checkDerefVar(var_glojure_DOT_core_second) + tmp34 := checkDerefVar(var_glojure_DOT_core_first) + tmp35 := lang.Apply(tmp34, []any{v24}) + tmp36 := lang.Apply(tmp33, []any{tmp35}) + tmp37 := lang.Apply(tmp30, []any{v15, tmp32, tmp36}) + tmp25 = tmp37 + } else { + tmp38 := lang.Apply(v12, []any{v15, v21, v24}) + tmp25 = tmp38 + } + tmp17 = tmp25 + } // end let + return tmp17 + }) + tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6672), kw_column, int(16), kw_end_DASH_line, int(6675), kw_end_DASH_column, int(45)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp17 := lang.NewMap() + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6676), kw_column, int(16), kw_end_DASH_line, int(6676), kw_end_DASH_column, int(17)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp20 := lang.Apply(tmp13, []any{tmp16, tmp19, v8}) + var v21 any = tmp20 + _ = v21 + // let binding "skip-check" + tmp22 := checkDerefVar(var_glojure_DOT_core_into1) + tmp23 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp24 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6680), kw_column, int(29), kw_end_DASH_line, int(6680), kw_end_DASH_column, int(31)) + tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp26 := checkDerefVar(var_glojure_DOT_core_map) + tmp27 := checkDerefVar(var_glojure_DOT_core_first) + tmp28 := checkDerefVar(var_glojure_DOT_core_filter) + var tmp29 lang.FnFunc + tmp29 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v30 := args[0] + _ = v30 + tmp31 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp32 := checkDerefVar(var_glojure_DOT_core_count) + tmp33 := checkDerefVar(var_glojure_DOT_core_second) + tmp34 := lang.Apply(tmp33, []any{v30}) + tmp35 := lang.Apply(tmp32, []any{tmp34}) + tmp36 := lang.Apply(tmp31, []any{int64(1), tmp35}) + return tmp36 + }) + tmp30 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6678), kw_column, int(30), kw_end_DASH_line, int(6678), kw_end_DASH_column, int(54)) + tmp31, err := lang.WithMeta(tmp29, tmp30.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp32 := lang.Apply(tmp28, []any{tmp31, v8}) + tmp33 := lang.Apply(tmp26, []any{tmp27, tmp32}) + tmp34 := lang.Apply(tmp22, []any{tmp25, tmp33}) + var v35 any = tmp34 + _ = v35 + tmp36 := checkDerefVar(var_glojure_DOT_core_keys) + tmp37 := lang.Apply(tmp36, []any{v21}) + tmp38 := checkDerefVar(var_glojure_DOT_core_vals) + tmp39 := lang.Apply(tmp38, []any{v21}) + tmp40 := lang.NewVector(tmp37, tmp39, v35) + tmp41 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6681), kw_column, int(5), kw_end_DASH_line, int(6681), kw_end_DASH_column, int(40)) + tmp42, err := lang.WithMeta(tmp40, tmp41.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp6 = tmp42 + } // end let + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_merge_DASH_hash_DASH_collisions = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_merge_DASH_hash_DASH_collisions.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // prep-hashes + { + tmp0 := sym_prep_DASH_hashes.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_expr_DASH_sym, sym_default, sym_tests, sym_thens)), kw_doc, "Takes a sequence of test constants and a corresponding sequence of then\n expressions. Returns a tuple of [shift mask case-map switch-type skip-check]\n where case-map is a map of int case values to [test then] tuples, switch-type\n is either :sparse or :compact, and skip-check is a set of case ints for which\n post-switch equivalence checking must not be done (occurs with hash\n collisions).", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(8), kw_line, int(6683), kw_end_DASH_line, int(6683), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var tmp6 any + { // let + // let binding "hashcode" + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v8 := args[0] + _ = v8 + tmp9 := lang.Apply(lang.Hash, []any{v8}) + return tmp9 + }) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6691), kw_column, int(18), kw_end_DASH_line, int(6691), kw_end_DASH_column, int(66)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v10 any = tmp9 + _ = v10 + // let binding "hashes" + tmp11 := checkDerefVar(var_glojure_DOT_core_into1) + tmp12 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6692), kw_column, int(23), kw_end_DASH_line, int(6692), kw_end_DASH_column, int(25)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp15 := checkDerefVar(var_glojure_DOT_core_map) + tmp16 := lang.Apply(tmp15, []any{v10, v4}) + tmp17 := lang.Apply(tmp11, []any{tmp14, tmp16}) + var v18 any = tmp17 + _ = v18 + var tmp19 any + tmp20 := checkDerefVar(var_glojure_DOT_core__EQ__EQ_) + tmp21 := checkDerefVar(var_glojure_DOT_core_count) + tmp22 := lang.Apply(tmp21, []any{v4}) + tmp23 := checkDerefVar(var_glojure_DOT_core_count) + tmp24 := lang.Apply(tmp23, []any{v18}) + tmp25 := lang.Apply(tmp20, []any{tmp22, tmp24}) + if lang.IsTruthy(tmp25) { + var tmp26 any + tmp27 := checkDerefVar(var_glojure_DOT_core_fits_DASH_table_QMARK_) + tmp28 := lang.Apply(tmp27, []any{v18}) + if lang.IsTruthy(tmp28) { + tmp29 := checkDerefVar(var_glojure_DOT_core_case_DASH_map) + tmp30 := checkDerefVar(var_glojure_DOT_core_identity) + tmp31 := lang.Apply(tmp29, []any{v10, tmp30, v4, v5}) + tmp32 := lang.NewVector(int64(0), int64(0), tmp31, kw_compact) + tmp33 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6696), kw_column, int(9), kw_end_DASH_line, int(6696), kw_end_DASH_column, int(63)) + tmp34, err := lang.WithMeta(tmp32, tmp33.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp26 = tmp34 + } else { + var tmp35 any + { // let + // let binding "vec__858" + var tmp36 any + { // let + // let binding "or__0__auto__" + tmp37 := checkDerefVar(var_glojure_DOT_core_maybe_DASH_min_DASH_hash) + tmp38 := lang.Apply(tmp37, []any{v18}) + var v39 any = tmp38 + _ = v39 + var tmp40 any + if lang.IsTruthy(v39) { + tmp40 = v39 + } else { + tmp41 := lang.NewVector(int64(0), int64(0)) + tmp42 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6697), kw_column, int(56), kw_end_DASH_line, int(6697), kw_end_DASH_column, int(60)) + tmp43, err := lang.WithMeta(tmp41, tmp42.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp40 = tmp43 + } + tmp36 = tmp40 + } // end let + var v37 any = tmp36 + _ = v37 + // let binding "shift" + tmp38 := checkDerefVar(var_glojure_DOT_core_nth) + tmp39 := lang.Apply(tmp38, []any{v37, int64(0), nil}) + var v40 any = tmp39 + _ = v40 + // let binding "mask" + tmp41 := checkDerefVar(var_glojure_DOT_core_nth) + tmp42 := lang.Apply(tmp41, []any{v37, int64(1), nil}) + var v43 any = tmp42 + _ = v43 + var tmp44 any + tmp45 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) + tmp46 := lang.Apply(tmp45, []any{v43}) + if lang.IsTruthy(tmp46) { + tmp47 := checkDerefVar(var_glojure_DOT_core_case_DASH_map) + tmp48 := checkDerefVar(var_glojure_DOT_core_identity) + tmp49 := lang.Apply(tmp47, []any{v10, tmp48, v4, v5}) + tmp50 := lang.NewVector(int64(0), int64(0), tmp49, kw_sparse) + tmp51 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6700), kw_column, int(13), kw_end_DASH_line, int(6700), kw_end_DASH_column, int(66)) + tmp52, err := lang.WithMeta(tmp50, tmp51.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp44 = tmp52 + } else { + tmp53 := checkDerefVar(var_glojure_DOT_core_case_DASH_map) + var tmp54 lang.FnFunc + tmp54 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v55 := args[0] + _ = v55 + tmp56 := checkDerefVar(var_glojure_DOT_core_shift_DASH_mask) + tmp57 := lang.Apply(v10, []any{v55}) + tmp58 := lang.Apply(tmp56, []any{v40, v43, tmp57}) + return tmp58 + }) + tmp55 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6702), kw_column, int(35), kw_end_DASH_line, int(6702), kw_end_DASH_column, int(71)) + tmp56, err := lang.WithMeta(tmp54, tmp55.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp57 := checkDerefVar(var_glojure_DOT_core_identity) + tmp58 := lang.Apply(tmp53, []any{tmp56, tmp57, v4, v5}) + tmp59 := lang.NewVector(v40, v43, tmp58, kw_compact) + tmp60 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6702), kw_column, int(13), kw_end_DASH_line, int(6702), kw_end_DASH_column, int(103)) + tmp61, err := lang.WithMeta(tmp59, tmp60.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp44 = tmp61 + } + tmp35 = tmp44 + } // end let + tmp26 = tmp35 + } + tmp19 = tmp26 + } else { + var tmp36 any + { // let + // let binding "vec__861" + tmp37 := checkDerefVar(var_glojure_DOT_core_merge_DASH_hash_DASH_collisions) + tmp38 := lang.Apply(tmp37, []any{v2, v3, v4, v5}) + var v39 any = tmp38 + _ = v39 + // let binding "tests" + tmp40 := checkDerefVar(var_glojure_DOT_core_nth) + tmp41 := lang.Apply(tmp40, []any{v39, int64(0), nil}) + var v42 any = tmp41 + _ = v42 + // let binding "thens" + tmp43 := checkDerefVar(var_glojure_DOT_core_nth) + tmp44 := lang.Apply(tmp43, []any{v39, int64(1), nil}) + var v45 any = tmp44 + _ = v45 + // let binding "skip-check" + tmp46 := checkDerefVar(var_glojure_DOT_core_nth) + tmp47 := lang.Apply(tmp46, []any{v39, int64(2), nil}) + var v48 any = tmp47 + _ = v48 + // let binding "vec__864" + tmp49 := checkDerefVar(var_glojure_DOT_core_prep_DASH_hashes) + tmp50 := lang.Apply(tmp49, []any{v2, v3, v42, v45}) + var v51 any = tmp50 + _ = v51 + // let binding "shift" + tmp52 := checkDerefVar(var_glojure_DOT_core_nth) + tmp53 := lang.Apply(tmp52, []any{v51, int64(0), nil}) + var v54 any = tmp53 + _ = v54 + // let binding "mask" + tmp55 := checkDerefVar(var_glojure_DOT_core_nth) + tmp56 := lang.Apply(tmp55, []any{v51, int64(1), nil}) + var v57 any = tmp56 + _ = v57 + // let binding "case-map" + tmp58 := checkDerefVar(var_glojure_DOT_core_nth) + tmp59 := lang.Apply(tmp58, []any{v51, int64(2), nil}) + var v60 any = tmp59 + _ = v60 + // let binding "switch-type" + tmp61 := checkDerefVar(var_glojure_DOT_core_nth) + tmp62 := lang.Apply(tmp61, []any{v51, int64(3), nil}) + var v63 any = tmp62 + _ = v63 + // let binding "skip-check" + var tmp64 any + tmp65 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) + tmp66 := lang.Apply(tmp65, []any{v57}) + if lang.IsTruthy(tmp66) { + tmp64 = v48 + } else { + tmp67 := checkDerefVar(var_glojure_DOT_core_into1) + tmp68 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp69 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6708), kw_column, int(33), kw_end_DASH_line, int(6708), kw_end_DASH_column, int(35)) + tmp70, err := lang.WithMeta(tmp68, tmp69.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp71 := checkDerefVar(var_glojure_DOT_core_map) + var tmp72 lang.FnFunc + tmp72 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v73 := args[0] + _ = v73 + tmp74 := checkDerefVar(var_glojure_DOT_core_shift_DASH_mask) + tmp75 := lang.Apply(tmp74, []any{v54, v57, v73}) + return tmp75 + }) + tmp73 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6708), kw_column, int(42), kw_end_DASH_line, int(6708), kw_end_DASH_column, int(67)) + tmp74, err := lang.WithMeta(tmp72, tmp73.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp75 := lang.Apply(tmp71, []any{tmp74, v48}) + tmp76 := lang.Apply(tmp67, []any{tmp70, tmp75}) + tmp64 = tmp76 + } + var v77 any = tmp64 + _ = v77 + tmp78 := lang.NewVector(v54, v57, v60, v63, v77) + tmp79 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6709), kw_column, int(9), kw_end_DASH_line, int(6709), kw_end_DASH_column, int(52)) + tmp80, err := lang.WithMeta(tmp78, tmp79.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp36 = tmp80 + } // end let + tmp19 = tmp36 + } + tmp6 = tmp19 + } // end let + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_prep_DASH_hashes = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_prep_DASH_hashes.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // tree-seq + { + tmp0 := sym_tree_DASH_seq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_branch_QMARK_, sym_children, sym_root)), kw_doc, "Returns a lazy sequence of the nodes in a tree, via a depth-first walk.\n branch? must be a fn of one arg that returns true if passed a node\n that can have children (but may not). children must be a fn of one\n arg that returns a sequence of the children. Will only be called on\n nodes for which branch? returns true. Root is the root node of the\n tree.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(4955), kw_end_DASH_line, int(4955))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + { // let + // let binding "walk" + var tmp6 lang.FnFunc + { // function walk + var v7 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v8 := args[0] + _ = v8 + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp10 := checkDerefVar(var_glojure_DOT_core_cons) + var tmp11 any + tmp12 := lang.Apply(v2, []any{v8}) + if lang.IsTruthy(tmp12) { + tmp13 := checkDerefVar(var_glojure_DOT_core_mapcat) + tmp14 := lang.Apply(v3, []any{v8}) + tmp15 := lang.Apply(tmp13, []any{v7, tmp14}) + tmp11 = tmp15 + } else { + } + tmp16 := lang.Apply(tmp10, []any{v8, tmp11}) + return tmp16 + }) + tmp10 := lang.Apply(lang.NewLazySeq, []any{tmp9}) + return tmp10 + }) + v7 = tmp6 + _ = v7 + } + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4965), kw_column, int(15), kw_end_DASH_line, int(4969), kw_end_DASH_column, int(53)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v9 any = tmp8 + _ = v9 + tmp10 := lang.Apply(v9, []any{v4}) + tmp5 = tmp10 + } // end let + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_tree_DASH_seq = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_tree_DASH_seq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // xml-seq + { + tmp0 := sym_xml_DASH_seq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_root)), kw_doc, "A tree seq on the xml elements as per xml/parse", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4982), kw_end_DASH_line, int(4982))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_tree_DASH_seq) + tmp4 := checkDerefVar(var_glojure_DOT_core_complement) + tmp5 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp6 := lang.Apply(tmp4, []any{tmp5}) + tmp7 := checkDerefVar(var_glojure_DOT_core_comp) + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := lang.Apply(tmp7, []any{tmp8, kw_content}) + tmp10 := lang.Apply(tmp3, []any{tmp6, tmp9, v2}) + return tmp10 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_xml_DASH_seq = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_xml_DASH_seq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // emit-extend-type + { + tmp0 := sym_emit_DASH_extend_DASH_type.WithMeta(lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(175), kw_column, int(8), kw_end_DASH_line, int(175), kw_end_DASH_column, int(23), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_c, sym_specs)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "impls" + tmp5 := checkDerefVar(var_glojure_DOT_core_parse_DASH_impls) + tmp6 := lang.Apply(tmp5, []any{v3}) + var v7 any = tmp6 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_extend}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v2}) + tmp14 := checkDerefVar(var_glojure_DOT_core_mapcat) + tmp15 := checkDerefVar(var_glojure_DOT_core_partial) + tmp16 := checkDerefVar(var_glojure_DOT_core_emit_DASH_hinted_DASH_impl) + tmp17 := lang.Apply(tmp15, []any{tmp16, v2}) + tmp18 := lang.Apply(tmp14, []any{tmp17, v7}) + tmp19 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp18}) + tmp20 := lang.Apply(tmp8, []any{tmp19}) + tmp4 = tmp20 + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_emit_DASH_extend_DASH_type = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_emit_DASH_extend_DASH_type.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // extend-type + { + tmp0 := sym_extend_DASH_type.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_t, sym__AMP_, sym_specs)), kw_doc, "A macro that expands into an extend call. Useful when you are\n supplying the definitions explicitly inline, extend-type\n automatically creates the maps required by extend. Propagates the\n class as a type hint on the first argument of all fns.\n\n (extend-type MyType \n Countable\n (cnt [c] ...)\n Foo\n (bar [x y] ...)\n (baz ([x] ...) ([x y & zs] ...)))\n\n expands into:\n\n (extend MyType\n Countable\n {:cnt (fn [c] ...)}\n Foo\n {:baz (fn ([x] ...) ([x y & zs] ...))\n :bar (fn [x y] ...)})", kw_file, "glojure/core_deftype.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(11), kw_line, int(180), kw_end_DASH_line, int(180))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_emit_DASH_extend_DASH_type) + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_extend_DASH_type = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_extend_DASH_type.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // file-seq + { + tmp0 := sym_file_DASH_seq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_dir)), kw_doc, "A tree seq on java.io.Files", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(4972), kw_end_DASH_line, int(4972))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_tree_DASH_seq) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v5 := args[0] + _ = v5 + tmp6, _ := lang.FieldOrMethod(v5, "isDirectory") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("isDirectory is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{}) + return tmp7 + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4978), kw_column, int(6), kw_end_DASH_line, int(4978), kw_end_DASH_column, int(47)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v8 := args[0] + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_seq) + tmp10, _ := lang.FieldOrMethod(v8, "listFiles") + if reflect.TypeOf(tmp10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("listFiles is not a function"))) + } + tmp11 := lang.Apply(tmp10, []any{}) + tmp12 := lang.Apply(tmp9, []any{tmp11}) + return tmp12 + }) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4979), kw_column, int(6), kw_end_DASH_line, int(4979), kw_end_DASH_column, int(51)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp10 := lang.Apply(tmp3, []any{tmp6, tmp9, v2}) + return tmp10 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_file_DASH_seq = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_file_DASH_seq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // flatten + { + tmp0 := sym_flatten.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Takes any nested combination of sequential things (lists, vectors,\n etc.) and returns their contents as a single, flat lazy sequence.\n (flatten nil) returns an empty sequence.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(7118), kw_end_DASH_line, int(7118))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_filter) + tmp4 := checkDerefVar(var_glojure_DOT_core_complement) + tmp5 := checkDerefVar(var_glojure_DOT_core_sequential_QMARK_) + tmp6 := lang.Apply(tmp4, []any{tmp5}) + tmp7 := checkDerefVar(var_glojure_DOT_core_rest) + tmp8 := checkDerefVar(var_glojure_DOT_core_tree_DASH_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_sequential_QMARK_) + tmp10 := checkDerefVar(var_glojure_DOT_core_seq) + tmp11 := lang.Apply(tmp8, []any{tmp9, tmp10, v2}) + tmp12 := lang.Apply(tmp7, []any{tmp11}) + tmp13 := lang.Apply(tmp3, []any{tmp6, tmp12}) + return tmp13 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_flatten = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_flatten.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // compile + { + tmp0 := sym_compile.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_lib)), kw_doc, "Compiles the namespace named by the symbol lib into a set of\n classfiles. The source for the lib must be in a proper\n classpath-relative directory. The output files will go into the\n directory specified by *compile-path*, and that directory too must\n be in the classpath.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(6114), kw_end_DASH_line, int(6114))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + tmp4 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp5 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp6 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_compile_DASH_files_STAR_) + tmp7 := lang.Apply(tmp5, []any{tmp6, true}) + tmp8 := lang.Apply(tmp4, []any{tmp7}) + _ = tmp8 + var tmp9 any + func() { + defer func() { + tmp10 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp11 := lang.Apply(tmp10, nil) + _ = tmp11 + }() + tmp12 := checkDerefVar(var_glojure_DOT_core_load_DASH_one) + tmp13 := lang.Apply(tmp12, []any{v2, true, true}) + tmp9 = tmp13 + }() + tmp3 = tmp9 + } // end let + _ = tmp3 + return v2 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_compile = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_compile.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // derive + { + tmp0 := sym_derive.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_tag, sym_parent), lang.NewVector(sym_h, sym_tag, sym_parent)), kw_doc, "Establishes a parent/child relationship between parent and\n tag. Parent must be a namespace-qualified symbol or keyword and\n child can be either a namespace-qualified symbol or keyword or a\n class. h must be a hierarchy obtained from make-hierarchy, if not\n supplied defaults to, and modifies, the global hierarchy.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(5605), kw_end_DASH_line, int(5605))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_alter_DASH_var_DASH_root) + tmp5 := lang.InternVarName(sym_glojure_DOT_core, sym_global_DASH_hierarchy) + tmp6 := checkDerefVar(var_glojure_DOT_core_derive) + tmp7 := lang.Apply(tmp4, []any{tmp5, tmp6, v2, v3}) + _ = tmp7 + return nil + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + { // let + // let binding "tp" + tmp6 := lang.Apply(kw_parents, []any{v2}) + var v7 any = tmp6 + _ = v7 + // let binding "td" + tmp8 := lang.Apply(kw_descendants, []any{v2}) + var v9 any = tmp8 + _ = v9 + // let binding "ta" + tmp10 := lang.Apply(kw_ancestors, []any{v2}) + var v11 any = tmp10 + _ = v11 + // let binding "tf" + var tmp12 lang.FnFunc + tmp12 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 5) + v13 := args[0] + _ = v13 + v14 := args[1] + _ = v14 + v15 := args[2] + _ = v15 + v16 := args[3] + _ = v16 + v17 := args[4] + _ = v17 + tmp18 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp19 lang.FnFunc + tmp19 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v20 := args[0] + _ = v20 + v21 := args[1] + _ = v21 + tmp22 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp23 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp24 := checkDerefVar(var_glojure_DOT_core_conj) + tmp25 := checkDerefVar(var_glojure_DOT_core_get) + tmp26 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp27 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5628), kw_column, int(61), kw_end_DASH_line, int(5628), kw_end_DASH_column, int(63)) + tmp28, err := lang.WithMeta(tmp26, tmp27.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp29 := lang.Apply(tmp25, []any{v17, v21, tmp28}) + tmp30 := checkDerefVar(var_glojure_DOT_core_cons) + tmp31 := lang.Apply(v17, []any{v16}) + tmp32 := lang.Apply(tmp30, []any{v16, tmp31}) + tmp33 := lang.Apply(tmp23, []any{tmp24, tmp29, tmp32}) + tmp34 := lang.Apply(tmp22, []any{v20, v21, tmp33}) + return tmp34 + }) + tmp20 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5626), kw_column, int(24), kw_end_DASH_line, int(5628), kw_end_DASH_column, int(98)) + tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp22 := checkDerefVar(var_glojure_DOT_core_cons) + tmp23 := lang.Apply(v15, []any{v14}) + tmp24 := lang.Apply(tmp22, []any{v14, tmp23}) + tmp25 := lang.Apply(tmp18, []any{tmp21, v13, tmp24}) + return tmp25 + }) + tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5625), kw_column, int(13), kw_end_DASH_line, int(5629), kw_end_DASH_column, int(56)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v15 any = tmp14 + _ = v15 + var tmp16 any + { // let + // let binding "or__0__auto__" + var tmp17 any + tmp18 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp19 := lang.Apply(v7, []any{v3}) + tmp20 := lang.Apply(tmp18, []any{tmp19, v4}) + if lang.IsTruthy(tmp20) { + } else { + var tmp21 any + tmp22 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp23 := lang.Apply(v11, []any{v3}) + tmp24 := lang.Apply(tmp22, []any{tmp23, v4}) + if lang.IsTruthy(tmp24) { + tmp25 := checkDerefVar(var_glojure_DOT_core_print_DASH_str) + tmp26 := lang.Apply(tmp25, []any{v3, "already has", v4, "as ancestor"}) + tmp27 := lang.Apply(lang.NewError, []any{tmp26}) + panic(tmp27) + } else { + } + _ = tmp21 + var tmp28 any + tmp29 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp30 := lang.Apply(v11, []any{v4}) + tmp31 := lang.Apply(tmp29, []any{tmp30, v3}) + if lang.IsTruthy(tmp31) { + tmp32 := checkDerefVar(var_glojure_DOT_core_print_DASH_str) + tmp33 := lang.Apply(tmp32, []any{"Cyclic derivation:", v4, "has", v3, "as ancestor"}) + tmp34 := lang.Apply(lang.NewError, []any{tmp33}) + panic(tmp34) + } else { + } + _ = tmp28 + tmp35 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp36 := lang.Apply(kw_parents, []any{v2}) + tmp37 := checkDerefVar(var_glojure_DOT_core_conj) + tmp38 := checkDerefVar(var_glojure_DOT_core_get) + tmp39 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp40 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5636), kw_column, int(61), kw_end_DASH_line, int(5636), kw_end_DASH_column, int(63)) + tmp41, err := lang.WithMeta(tmp39, tmp40.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp42 := lang.Apply(tmp38, []any{v7, v3, tmp41}) + tmp43 := lang.Apply(tmp37, []any{tmp42, v4}) + tmp44 := lang.Apply(tmp35, []any{tmp36, v3, tmp43}) + tmp45 := lang.Apply(kw_ancestors, []any{v2}) + tmp46 := lang.Apply(v15, []any{tmp45, v3, v9, v4, v11}) + tmp47 := lang.Apply(kw_descendants, []any{v2}) + tmp48 := lang.Apply(v15, []any{tmp47, v4, v11, v3, v9}) + tmp49 := lang.NewMap(kw_parents, tmp44, kw_ancestors, tmp46, kw_descendants, tmp48) + tmp50 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5636), kw_column, int(9), kw_end_DASH_line, int(5638), kw_end_DASH_column, int(61)) + tmp51, err := lang.WithMeta(tmp49, tmp50.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp17 = tmp51 + } + var v52 any = tmp17 + _ = v52 + var tmp53 any + if lang.IsTruthy(v52) { + tmp53 = v52 + } else { + tmp53 = v2 + } + tmp16 = tmp53 + } // end let + tmp5 = tmp16 + } // end let + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_derive = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_derive.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // underive + { + tmp0 := sym_underive.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_tag, sym_parent), lang.NewVector(sym_h, sym_tag, sym_parent)), kw_doc, "Removes a parent/child relationship between parent and\n tag. h must be a hierarchy obtained from make-hierarchy, if not\n supplied defaults to, and modifies, the global hierarchy.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(5643), kw_end_DASH_line, int(5643))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_alter_DASH_var_DASH_root) + tmp5 := lang.InternVarName(sym_glojure_DOT_core, sym_global_DASH_hierarchy) + tmp6 := checkDerefVar(var_glojure_DOT_core_underive) + tmp7 := lang.Apply(tmp4, []any{tmp5, tmp6, v2, v3}) + _ = tmp7 + return nil + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + { // let + // let binding "parentMap" + tmp6 := lang.Apply(kw_parents, []any{v2}) + var v7 any = tmp6 + _ = v7 + // let binding "childsParents" + var tmp8 any + tmp9 := lang.Apply(v7, []any{v3}) + if lang.IsTruthy(tmp9) { + tmp10 := checkDerefVar(var_glojure_DOT_core_disj) + tmp11 := lang.Apply(v7, []any{v3}) + tmp12 := lang.Apply(tmp10, []any{tmp11, v4}) + tmp8 = tmp12 + } else { + tmp13 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5652), kw_column, int(36), kw_end_DASH_line, int(5652), kw_end_DASH_column, int(38)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp8 = tmp15 + } + var v16 any = tmp8 + _ = v16 + // let binding "newParents" + var tmp17 any + tmp18 := checkDerefVar(var_glojure_DOT_core_not_DASH_empty) + tmp19 := lang.Apply(tmp18, []any{v16}) + if lang.IsTruthy(tmp19) { + tmp20 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp21 := lang.Apply(tmp20, []any{v7, v3, v16}) + tmp17 = tmp21 + } else { + tmp22 := checkDerefVar(var_glojure_DOT_core_dissoc) + tmp23 := lang.Apply(tmp22, []any{v7, v3}) + tmp17 = tmp23 + } + var v24 any = tmp17 + _ = v24 + // let binding "deriv-seq" + tmp25 := checkDerefVar(var_glojure_DOT_core_flatten) + tmp26 := checkDerefVar(var_glojure_DOT_core_map) + var tmp27 lang.FnFunc + tmp27 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v28 := args[0] + _ = v28 + tmp29 := checkDerefVar(var_glojure_DOT_core_cons) + tmp30 := checkDerefVar(var_glojure_DOT_core_key) + tmp31 := lang.Apply(tmp30, []any{v28}) + tmp32 := checkDerefVar(var_glojure_DOT_core_interpose) + tmp33 := checkDerefVar(var_glojure_DOT_core_key) + tmp34 := lang.Apply(tmp33, []any{v28}) + tmp35 := checkDerefVar(var_glojure_DOT_core_val) + tmp36 := lang.Apply(tmp35, []any{v28}) + tmp37 := lang.Apply(tmp32, []any{tmp34, tmp36}) + tmp38 := lang.Apply(tmp29, []any{tmp31, tmp37}) + return tmp38 + }) + tmp28 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5656), kw_column, int(28), kw_end_DASH_line, int(5656), kw_end_DASH_column, int(70)) + tmp29, err := lang.WithMeta(tmp27, tmp28.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp30 := checkDerefVar(var_glojure_DOT_core_seq) + tmp31 := lang.Apply(tmp30, []any{v24}) + tmp32 := lang.Apply(tmp26, []any{tmp29, tmp31}) + tmp33 := lang.Apply(tmp25, []any{tmp32}) + var v34 any = tmp33 + _ = v34 + var tmp35 any + tmp36 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp37 := lang.Apply(v7, []any{v3}) + tmp38 := lang.Apply(tmp36, []any{tmp37, v4}) + if lang.IsTruthy(tmp38) { + tmp39 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp40 lang.FnFunc + tmp40 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v41 := args[0] + _ = v41 + v42 := args[1] + _ = v42 + tmp43 := checkDerefVar(var_glojure_DOT_core_apply) + tmp44 := checkDerefVar(var_glojure_DOT_core_derive) + tmp45 := lang.Apply(tmp43, []any{tmp44, v41, v42}) + return tmp45 + }) + tmp41 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5659), kw_column, int(11), kw_end_DASH_line, int(5659), kw_end_DASH_column, int(31)) + tmp42, err := lang.WithMeta(tmp40, tmp41.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp43 := checkDerefVar(var_glojure_DOT_core_make_DASH_hierarchy) + tmp44 := lang.Apply(tmp43, nil) + tmp45 := checkDerefVar(var_glojure_DOT_core_partition) + tmp46 := lang.Apply(tmp45, []any{int64(2), v34}) + tmp47 := lang.Apply(tmp39, []any{tmp42, tmp44, tmp46}) + tmp35 = tmp47 + } else { + tmp35 = v2 + } + tmp5 = tmp35 + } // end let + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_underive = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_underive.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // filterv + { + tmp0 := sym_filterv.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns a vector of the items in coll for which\n (pred item) returns logical true. pred must be free of side-effects.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.4", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(6961), kw_end_DASH_line, int(6961))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp5 := checkDerefVar(var_glojure_DOT_core_reduce) + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + var tmp9 any + tmp10 := lang.Apply(v2, []any{v8}) + if lang.IsTruthy(tmp10) { + tmp11 := checkDerefVar(var_glojure_DOT_core_conj_BANG_) + tmp12 := lang.Apply(tmp11, []any{v7, v8}) + tmp9 = tmp12 + } else { + tmp9 = v7 + } + return tmp9 + }) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6967), kw_column, int(15), kw_end_DASH_line, int(6967), kw_end_DASH_column, int(52)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp9 := checkDerefVar(var_glojure_DOT_core_transient) + tmp10 := lang.NewVector() + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6968), kw_column, int(26), kw_end_DASH_line, int(6968), kw_end_DASH_column, int(27)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := lang.Apply(tmp9, []any{tmp12}) + tmp14 := lang.Apply(tmp5, []any{tmp8, tmp13, v3}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_filterv = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_filterv.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // flush + { + tmp0 := sym_flush.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Flushes the output stream that is the current value of\n *out*", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3706), kw_end_DASH_line, int(3706))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp2 := checkDerefVar(var_glojure_DOT_core__STAR_out_STAR_) + tmp3, _ := lang.FieldOrMethod(tmp2, "Sync") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Sync is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{}) + _ = tmp4 + return nil + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_flush = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_flush.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // frequencies + { + tmp0 := sym_frequencies.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a map from distinct items in coll to the number of times\n they appear.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(7185), kw_end_DASH_line, int(7185))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp4 := checkDerefVar(var_glojure_DOT_core_reduce) + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_assoc_BANG_) + tmp9 := checkDerefVar(var_glojure_DOT_core_inc) + tmp10 := checkDerefVar(var_glojure_DOT_core_get) + tmp11 := lang.Apply(tmp10, []any{v6, v7, int64(0)}) + tmp12 := lang.Apply(tmp9, []any{tmp11}) + tmp13 := lang.Apply(tmp8, []any{v6, v7, tmp12}) + return tmp13 + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7192), kw_column, int(12), kw_end_DASH_line, int(7193), kw_end_DASH_column, int(54)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp8 := checkDerefVar(var_glojure_DOT_core_transient) + tmp9 := lang.NewMap() + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7194), kw_column, int(23), kw_end_DASH_line, int(7194), kw_end_DASH_column, int(24)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp12 := lang.Apply(tmp8, []any{tmp11}) + tmp13 := lang.Apply(tmp4, []any{tmp7, tmp12, v2}) + tmp14 := lang.Apply(tmp3, []any{tmp13}) + return tmp14 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_frequencies = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_frequencies.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // group-by + { + tmp0 := sym_group_DASH_by.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_coll)), kw_doc, "Returns a map of the elements of coll keyed by the result of\n f on each element. The value at each key will be a vector of the\n corresponding elements, in the order they appeared in coll.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(7128), kw_end_DASH_line, int(7128))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp5 := checkDerefVar(var_glojure_DOT_core_reduce) + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + var tmp9 any + { // let + // let binding "k" + tmp10 := lang.Apply(v2, []any{v8}) + var v11 any = tmp10 + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_assoc_BANG_) + tmp13 := checkDerefVar(var_glojure_DOT_core_conj) + tmp14 := checkDerefVar(var_glojure_DOT_core_get) + tmp15 := lang.NewVector() + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7139), kw_column, int(40), kw_end_DASH_line, int(7139), kw_end_DASH_column, int(41)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp18 := lang.Apply(tmp14, []any{v7, v11, tmp17}) + tmp19 := lang.Apply(tmp13, []any{tmp18, v8}) + tmp20 := lang.Apply(tmp12, []any{v7, v11, tmp19}) + tmp9 = tmp20 + } // end let + return tmp9 + }) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7137), kw_column, int(5), kw_end_DASH_line, int(7139), kw_end_DASH_column, int(48)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp9 := checkDerefVar(var_glojure_DOT_core_transient) + tmp10 := lang.NewMap() + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7140), kw_column, int(16), kw_end_DASH_line, int(7140), kw_end_DASH_column, int(17)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := lang.Apply(tmp9, []any{tmp12}) + tmp14 := lang.Apply(tmp5, []any{tmp8, tmp13, v3}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_group_DASH_by = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_group_DASH_by.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // into + { + tmp0 := sym_into.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_to), lang.NewVector(sym_to, sym_from), lang.NewVector(sym_to, sym_xform, sym_from)), kw_doc, "Returns a new coll consisting of to with all of the items of\n from conjoined. A transducer may be supplied.\n (into x) returns x. (into) returns [].", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(6922), kw_end_DASH_line, int(6922))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp2 := lang.NewVector() + tmp3 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6928), kw_column, int(7), kw_end_DASH_line, int(6928), kw_end_DASH_column, int(8)) + tmp4, err := lang.WithMeta(tmp2, tmp3.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp4 + case 1: + v2 := args[0] + _ = v2 + return v2 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp6 := reflect.TypeOf((*lang.IEditableCollection)(nil)).Elem() + tmp7 := lang.Apply(tmp5, []any{tmp6, v2}) + if lang.IsTruthy(tmp7) { + tmp8 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp9 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp10 := checkDerefVar(var_glojure_DOT_core_reduce) + tmp11 := checkDerefVar(var_glojure_DOT_core_conj_BANG_) + tmp12 := checkDerefVar(var_glojure_DOT_core_transient) + tmp13 := lang.Apply(tmp12, []any{v2}) + tmp14 := lang.Apply(tmp10, []any{tmp11, tmp13, v3}) + tmp15 := lang.Apply(tmp9, []any{tmp14}) + tmp16 := checkDerefVar(var_glojure_DOT_core_meta) + tmp17 := lang.Apply(tmp16, []any{v2}) + tmp18 := lang.Apply(tmp8, []any{tmp15, tmp17}) + tmp4 = tmp18 + } else { + tmp19 := checkDerefVar(var_glojure_DOT_core_reduce) + tmp20 := checkDerefVar(var_glojure_DOT_core_conj) + tmp21 := lang.Apply(tmp19, []any{tmp20, v2, v3}) + tmp4 = tmp21 + } + return tmp4 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp7 := reflect.TypeOf((*lang.IEditableCollection)(nil)).Elem() + tmp8 := lang.Apply(tmp6, []any{tmp7, v2}) + if lang.IsTruthy(tmp8) { + var tmp9 any + { // let + // let binding "tm" + tmp10 := checkDerefVar(var_glojure_DOT_core_meta) + tmp11 := lang.Apply(tmp10, []any{v2}) + var v12 any = tmp11 + _ = v12 + // let binding "rf" + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v14 := args[0] + _ = v14 + tmp15 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp16 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp17 := lang.Apply(tmp16, []any{v14}) + tmp18 := lang.Apply(tmp15, []any{tmp17, v12}) + return tmp18 + case 2: + v14 := args[0] + _ = v14 + v15 := args[1] + _ = v15 + tmp16 := checkDerefVar(var_glojure_DOT_core_conj_BANG_) + tmp17 := lang.Apply(tmp16, []any{v14, v15}) + return tmp17 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6937), kw_column, int(17), kw_end_DASH_line, int(6939), kw_end_DASH_column, int(44)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v16 any = tmp15 + _ = v16 + tmp17 := checkDerefVar(var_glojure_DOT_core_transduce) + tmp18 := checkDerefVar(var_glojure_DOT_core_transient) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp17, []any{v3, v16, tmp19, v4}) + tmp9 = tmp20 + } // end let + tmp5 = tmp9 + } else { + tmp10 := checkDerefVar(var_glojure_DOT_core_transduce) + tmp11 := checkDerefVar(var_glojure_DOT_core_conj) + tmp12 := lang.Apply(tmp10, []any{v3, tmp11, v2, v4}) + tmp5 = tmp12 + } + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_into = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_into.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // partitionv + { + tmp0 := sym_partitionv.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n, sym_coll), lang.NewVector(sym_n, sym_step, sym_coll), lang.NewVector(sym_n, sym_step, sym_pad, sym_coll)), kw_doc, "Returns a lazy sequence of vectors of n items each, at offsets step\n apart. If step is not supplied, defaults to n, i.e. the partitions\n do not overlap. If a pad collection is supplied, use its elements as\n necessary to complete last partition upto n items. In case there are\n not enough padding elements, return a partition with less than n items.", kw_file, "glojure/core.glj", kw_added, "1.12", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(7262), kw_end_DASH_line, int(7262))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_partitionv) + tmp5 := lang.Apply(tmp4, []any{v2, v2, v3}) + return tmp5 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp6 any + { // let + // let binding "temp__0__auto__" + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := lang.Apply(tmp7, []any{v4}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + var tmp11 any + { // let + // let binding "s" + var v12 any = v9 + _ = v12 + var tmp13 any + { // let + // let binding "p" + tmp14 := checkDerefVar(var_glojure_DOT_core_into) + tmp15 := lang.NewVector() + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7274), kw_column, int(22), kw_end_DASH_line, int(7274), kw_end_DASH_column, int(23)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp18 := checkDerefVar(var_glojure_DOT_core_take) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp14, []any{tmp17, tmp19, v12}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + tmp23 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp24 := checkDerefVar(var_glojure_DOT_core_count) + tmp25 := lang.Apply(tmp24, []any{v21}) + tmp26 := lang.Apply(tmp23, []any{v2, tmp25}) + if lang.IsTruthy(tmp26) { + tmp27 := checkDerefVar(var_glojure_DOT_core_cons) + tmp28 := checkDerefVar(var_glojure_DOT_core_partitionv) + tmp29 := checkDerefVar(var_glojure_DOT_core_nthrest) + tmp30 := lang.Apply(tmp29, []any{v12, v3}) + tmp31 := lang.Apply(tmp28, []any{v2, v3, tmp30}) + tmp32 := lang.Apply(tmp27, []any{v21, tmp31}) + tmp22 = tmp32 + } else { + } + tmp13 = tmp22 + } // end let + tmp11 = tmp13 + } // end let + tmp10 = tmp11 + } else { + } + tmp6 = tmp10 + } // end let + return tmp6 + }) + tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) + return tmp6 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp7 any + { // let + // let binding "temp__0__auto__" + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := lang.Apply(tmp8, []any{v5}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + if lang.IsTruthy(v10) { + var tmp12 any + { // let + // let binding "s" + var v13 any = v10 + _ = v13 + var tmp14 any + { // let + // let binding "p" + tmp15 := checkDerefVar(var_glojure_DOT_core_into) + tmp16 := lang.NewVector() + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7280), kw_column, int(22), kw_end_DASH_line, int(7280), kw_end_DASH_column, int(23)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp19 := checkDerefVar(var_glojure_DOT_core_take) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := lang.Apply(tmp15, []any{tmp18, tmp20, v13}) + var v22 any = tmp21 + _ = v22 + var tmp23 any + tmp24 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp25 := checkDerefVar(var_glojure_DOT_core_count) + tmp26 := lang.Apply(tmp25, []any{v22}) + tmp27 := lang.Apply(tmp24, []any{v2, tmp26}) + if lang.IsTruthy(tmp27) { + tmp28 := checkDerefVar(var_glojure_DOT_core_cons) + tmp29 := checkDerefVar(var_glojure_DOT_core_partitionv) + tmp30 := checkDerefVar(var_glojure_DOT_core_nthrest) + tmp31 := lang.Apply(tmp30, []any{v13, v3}) + tmp32 := lang.Apply(tmp29, []any{v2, v3, v4, tmp31}) + tmp33 := lang.Apply(tmp28, []any{v22, tmp32}) + tmp23 = tmp33 + } else { + tmp34 := checkDerefVar(var_glojure_DOT_core_list) + tmp35 := checkDerefVar(var_glojure_DOT_core_into) + tmp36 := lang.NewVector() + tmp37 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7283), kw_column, int(24), kw_end_DASH_line, int(7283), kw_end_DASH_column, int(25)) + tmp38, err := lang.WithMeta(tmp36, tmp37.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp39 := checkDerefVar(var_glojure_DOT_core_take) + tmp40 := lang.Apply(tmp39, []any{v2}) + tmp41 := checkDerefVar(var_glojure_DOT_core_concat) + tmp42 := lang.Apply(tmp41, []any{v22, v4}) + tmp43 := lang.Apply(tmp35, []any{tmp38, tmp40, tmp42}) + tmp44 := lang.Apply(tmp34, []any{tmp43}) + tmp23 = tmp44 + } + tmp14 = tmp23 + } // end let + tmp12 = tmp14 + } // end let + tmp11 = tmp12 + } else { + } + tmp7 = tmp11 + } // end let + return tmp7 + }) + tmp7 := lang.Apply(lang.NewLazySeq, []any{tmp6}) + return tmp7 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_partitionv = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_partitionv.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // partitionv-all + { + tmp0 := sym_partitionv_DASH_all.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n), lang.NewVector(sym_n, sym_coll), lang.NewVector(sym_n, sym_step, sym_coll)), kw_doc, "Returns a lazy sequence of vector partitions, but may include\n partitions with fewer than n items at the end.\n Returns a stateful transducer when no collection is provided.", kw_file, "glojure/core.glj", kw_added, "1.12", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(7285), kw_end_DASH_line, int(7285))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_partition_DASH_all) + tmp4 := lang.Apply(tmp3, []any{v2}) + return tmp4 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_partitionv_DASH_all) + tmp5 := lang.Apply(tmp4, []any{v2, v2, v3}) + return tmp5 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp6 any + { // let + // let binding "temp__0__auto__" + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := lang.Apply(tmp7, []any{v4}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + var tmp11 any + { // let + // let binding "s" + var v12 any = v9 + _ = v12 + var tmp13 any + { // let + // let binding "seg" + tmp14 := checkDerefVar(var_glojure_DOT_core_into) + tmp15 := lang.NewVector() + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7297), kw_column, int(24), kw_end_DASH_line, int(7297), kw_end_DASH_column, int(25)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp18 := checkDerefVar(var_glojure_DOT_core_take) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp14, []any{tmp17, tmp19, v4}) + var v21 any = tmp20 + _ = v21 + tmp22 := checkDerefVar(var_glojure_DOT_core_cons) + tmp23 := checkDerefVar(var_glojure_DOT_core_partitionv_DASH_all) + tmp24 := checkDerefVar(var_glojure_DOT_core_drop) + tmp25 := lang.Apply(tmp24, []any{v3, v12}) + tmp26 := lang.Apply(tmp23, []any{v2, v3, tmp25}) + tmp27 := lang.Apply(tmp22, []any{v21, tmp26}) + tmp13 = tmp27 + } // end let + tmp11 = tmp13 + } // end let + tmp10 = tmp11 + } else { + } + tmp6 = tmp10 + } // end let + return tmp6 + }) + tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_partitionv_DASH_all = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_partitionv_DASH_all.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // splitv-at + { + tmp0 := sym_splitv_DASH_at.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n, sym_coll)), kw_doc, "Returns a vector of [(into [] (take n) coll) (drop n coll)]", kw_file, "glojure/core.glj", kw_added, "1.12", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(7256), kw_end_DASH_line, int(7256))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_into) + tmp5 := lang.NewVector() + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7260), kw_column, int(10), kw_end_DASH_line, int(7260), kw_end_DASH_column, int(11)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp8 := checkDerefVar(var_glojure_DOT_core_take) + tmp9 := lang.Apply(tmp8, []any{v2}) + tmp10 := lang.Apply(tmp4, []any{tmp7, tmp9, v3}) + tmp11 := checkDerefVar(var_glojure_DOT_core_drop) + tmp12 := lang.Apply(tmp11, []any{v2, v3}) + tmp13 := lang.NewVector(tmp10, tmp12) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7260), kw_column, int(3), kw_end_DASH_line, int(7260), kw_end_DASH_column, int(41)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp15 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_splitv_DASH_at = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_splitv_DASH_at.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // iteration + { + tmp0 := sym_iteration.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_step, sym__AMP_, lang.NewMap(kw_keys, lang.NewVector(sym_somef, sym_vf, sym_kf, sym_initk), kw_or, lang.NewMap(sym_vf, sym_identity, sym_kf, sym_identity, sym_somef, sym_some_QMARK_, sym_initk, nil)))), kw_doc, "Creates a seqable/reducible via repeated calls to step,\n a function of some (continuation token) 'k'. The first call to step\n will be passed initk, returning 'ret'. Iff (somef ret) is true,\n (vf ret) will be included in the iteration, else iteration will\n terminate and vf/kf will not be called. If (kf ret) is non-nil it\n will be passed to the next step call, else iteration will terminate.\n\n This can be used e.g. to consume APIs that return paginated or batched data.\n\n step - (possibly impure) fn of 'k' -> 'ret'\n\n :somef - fn of 'ret' -> logical true/false, default 'some?'\n :vf - fn of 'ret' -> 'v', a value produced by the iteration, default 'identity'\n :kf - fn of 'ret' -> 'next-k' or nil (signaling 'do not continue'), default 'identity'\n :initk - the first value passed to step, default 'nil'\n\n It is presumed that step with non-initk is unreproducible/non-idempotent.\n If step with initk is unreproducible it is on the consumer to not consume twice.", kw_file, "glojure/core.glj", kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(7716), kw_end_DASH_line, int(7716))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + var tmp4 any + { // let + // let binding "map__1009" + var v5 any = v3 + _ = v5 + // let binding "map__1009" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v5}) + if lang.IsTruthy(tmp8) { + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_next) + tmp11 := lang.Apply(tmp10, []any{v5}) + if lang.IsTruthy(tmp11) { + tmp12 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) + tmp13 := lang.Apply(tmp12, []any{v5}) + tmp14 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{tmp13}) + tmp9 = tmp14 + } else { + var tmp15 any + tmp16 := checkDerefVar(var_glojure_DOT_core_seq) + tmp17 := lang.Apply(tmp16, []any{v5}) + if lang.IsTruthy(tmp17) { + tmp18 := checkDerefVar(var_glojure_DOT_core_first) + tmp19 := lang.Apply(tmp18, []any{v5}) + tmp15 = tmp19 + } else { + } + tmp9 = tmp15 + } + tmp6 = tmp9 + } else { + tmp6 = v5 + } + var v20 any = tmp6 + _ = v20 + // let binding "somef" + tmp21 := checkDerefVar(var_glojure_DOT_core_get) + tmp22 := checkDerefVar(var_glojure_DOT_core_some_QMARK_) + tmp23 := lang.Apply(tmp21, []any{v20, kw_somef, tmp22}) + var v24 any = tmp23 + _ = v24 + // let binding "vf" + tmp25 := checkDerefVar(var_glojure_DOT_core_get) + tmp26 := checkDerefVar(var_glojure_DOT_core_identity) + tmp27 := lang.Apply(tmp25, []any{v20, kw_vf, tmp26}) + var v28 any = tmp27 + _ = v28 + // let binding "kf" + tmp29 := checkDerefVar(var_glojure_DOT_core_get) + tmp30 := checkDerefVar(var_glojure_DOT_core_identity) + tmp31 := lang.Apply(tmp29, []any{v20, kw_kf, tmp30}) + var v32 any = tmp31 + _ = v32 + // let binding "initk" + tmp33 := checkDerefVar(var_glojure_DOT_core_get) + tmp34 := lang.Apply(tmp33, []any{v20, kw_initk, nil}) + var v35 any = tmp34 + _ = v35 + tmp36 := checkDerefVar(var_glojure_DOT_core_seq) + tmp37 := lang.NewVector(nil) + tmp38 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7743), kw_column, int(9), kw_end_DASH_line, int(7743), kw_end_DASH_column, int(11)) + tmp39, err := lang.WithMeta(tmp37, tmp38.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var tmp40 lang.FnFunc + { // function next + var v41 lang.FnFunc + tmp40 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v42 := args[0] + _ = v42 + var tmp43 any + tmp44 := lang.Apply(v24, []any{v42}) + if lang.IsTruthy(tmp44) { + tmp45 := checkDerefVar(var_glojure_DOT_core_cons) + tmp46 := lang.Apply(v28, []any{v42}) + var tmp47 any + { // let + // let binding "temp__0__auto__" + tmp48 := lang.Apply(v32, []any{v42}) + var v49 any = tmp48 + _ = v49 + var tmp50 any + tmp51 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp52 := lang.Apply(tmp51, []any{v49}) + if lang.IsTruthy(tmp52) { + } else { + var tmp53 any + { // let + // let binding "k" + var v54 any = v49 + _ = v54 + var tmp55 lang.FnFunc + tmp55 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp56 := lang.Apply(v2, []any{v54}) + tmp57 := lang.Apply(v41, []any{tmp56}) + return tmp57 + }) + tmp56 := lang.Apply(lang.NewLazySeq, []any{tmp55}) + tmp53 = tmp56 + } // end let + tmp50 = tmp53 + } + tmp47 = tmp50 + } // end let + tmp48 := lang.Apply(tmp45, []any{tmp46, tmp47}) + tmp43 = tmp48 + } else { + } + return tmp43 + }) + v41 = tmp40 + _ = v41 + } + tmp41 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7744), kw_column, int(10), kw_end_DASH_line, int(7748), kw_end_DASH_column, int(51)) + tmp42, err := lang.WithMeta(tmp40, tmp41.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp43 := lang.Apply(v2, []any{v35}) + tmp44 := lang.Apply(tmp42, []any{tmp43}) + tmp45 := lang.Apply(tmp36, []any{tmp39, tmp44}) + tmp46 := reflect.TypeOf((*lang.IReduceInit)(nil)).Elem() + tmp47 := checkDerefVar(var_glojure_DOT_core_reduce) + tmp48 := lang.NewVector(nil, nil, nil) + tmp49 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7751), kw_column, int(12), kw_end_DASH_line, int(7751), kw_end_DASH_column, int(22)) + tmp50, err := lang.WithMeta(tmp48, tmp49.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var tmp51 any + { // let + // let binding "acc" + var v52 any = nil + _ = v52 + // let binding "ret" + tmp53 := lang.Apply(v2, []any{v35}) + var v54 any = tmp53 + _ = v54 + for { + var tmp55 any + tmp56 := lang.Apply(v24, []any{v54}) + if lang.IsTruthy(tmp56) { + var tmp57 any + { // let + // let binding "acc" + tmp58 := lang.Apply(v28, []any{v54}) + tmp59 := lang.Apply(nil, []any{v52, tmp58}) + var v60 any = tmp59 + _ = v60 + var tmp61 any + tmp62 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) + tmp63 := lang.Apply(tmp62, []any{v60}) + if lang.IsTruthy(tmp63) { + tmp64 := checkDerefVar(var_glojure_DOT_core_deref) + tmp65 := lang.Apply(tmp64, []any{v60}) + tmp61 = tmp65 + } else { + var tmp66 any + { // let + // let binding "temp__0__auto__" + tmp67 := lang.Apply(v32, []any{v54}) + var v68 any = tmp67 + _ = v68 + var tmp69 any + tmp70 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp71 := lang.Apply(tmp70, []any{v68}) + if lang.IsTruthy(tmp71) { + tmp69 = v60 + } else { + var tmp72 any + { // let + // let binding "k" + var v73 any = v68 + _ = v73 + var tmp74 any = v60 + tmp76 := lang.Apply(v2, []any{v73}) + var tmp75 any = tmp76 + v52 = tmp74 + v54 = tmp75 + continue + } // end let + tmp69 = tmp72 + } + tmp66 = tmp69 + } // end let + tmp61 = tmp66 + } + tmp57 = tmp61 + } // end let + tmp55 = tmp57 + } else { + tmp55 = v52 + } + tmp51 = tmp55 + break + } + } // end let + tmp52 := lang.Apply(tmp47, []any{tmp50, tmp51}) + tmp53 := lang.Apply(nil, []any{nil, tmp45, tmp46, tmp52}) + tmp4 = tmp53 + } // end let + return tmp4 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_iteration = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_iteration.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // load + { + tmp0 := sym_load.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_paths)), kw_doc, "Loads Clojure code from resources in classpath. A path is interpreted as\n classpath-relative if it begins with a slash or relative to the root\n directory for the current namespace otherwise.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_redef, true, kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(6095), kw_end_DASH_line, int(6095))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + var tmp3 any + { // let + // let binding "seq_824" + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + // let binding "chunk_825" + var v7 any = nil + _ = v7 + // let binding "count_826" + var v8 any = int64(0) + _ = v8 + // let binding "i_827" + var v9 any = int64(0) + _ = v9 + for { + var tmp10 any + tmp11 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp12 := lang.Apply(tmp11, []any{v9, v8}) + if lang.IsTruthy(tmp12) { + var tmp13 any + { // let + // let binding "path" + tmp14, _ := lang.FieldOrMethod(v7, "nth") + if reflect.TypeOf(tmp14).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp15 := lang.Apply(tmp14, []any{v9}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + { // let + // let binding "path" + var tmp18 any + tmp19 := lang.Apply(strings8.HasPrefix, []any{v16, "/"}) + if lang.IsTruthy(tmp19) { + tmp18 = v16 + } else { + tmp20 := checkDerefVar(var_glojure_DOT_core_str) + tmp21 := checkDerefVar(var_glojure_DOT_core_root_DASH_directory) + tmp22 := checkDerefVar(var_glojure_DOT_core_ns_DASH_name) + tmp23 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp24 := lang.Apply(tmp22, []any{tmp23}) + tmp25 := lang.Apply(tmp21, []any{tmp24}) + tmp26 := lang.Apply(tmp20, []any{tmp25, lang.NewChar(47), v16}) + tmp18 = tmp26 + } + var v27 any = tmp18 + _ = v27 + var tmp28 any + tmp29 := checkDerefVar(var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_) + if lang.IsTruthy(tmp29) { + tmp30 := checkDerefVar(var_glojure_DOT_core_printf) + tmp31 := lang.Apply(tmp30, []any{"(glojure.core/load \"%s\")\n", v27}) + _ = tmp31 + tmp32 := checkDerefVar(var_glojure_DOT_core_flush) + tmp33 := lang.Apply(tmp32, nil) + tmp28 = tmp33 + } else { + } + _ = tmp28 + tmp34 := checkDerefVar(var_glojure_DOT_core_check_DASH_cyclic_DASH_dependency) + tmp35 := lang.Apply(tmp34, []any{v27}) + _ = tmp35 + var tmp36 any + tmp37 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp38 := checkDerefVar(var_glojure_DOT_core_first) + tmp39 := checkDerefVar(var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_) + tmp40 := lang.Apply(tmp38, []any{tmp39}) + tmp41 := lang.Apply(tmp37, []any{v27, tmp40}) + if lang.IsTruthy(tmp41) { + } else { + var tmp42 any + { // let + tmp43 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp44 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp45 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_pending_DASH_paths_STAR_) + tmp46 := checkDerefVar(var_glojure_DOT_core_conj) + tmp47 := checkDerefVar(var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_) + tmp48 := lang.Apply(tmp46, []any{tmp47, v27}) + tmp49 := lang.Apply(tmp44, []any{tmp45, tmp48}) + tmp50 := lang.Apply(tmp43, []any{tmp49}) + _ = tmp50 + var tmp51 any + func() { + defer func() { + tmp52 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp53 := lang.Apply(tmp52, nil) + _ = tmp53 + }() + tmp54 := lang.Apply(strings8.TrimPrefix, []any{v27, "/"}) + tmp55, _ := lang.FieldOrMethod(runtime.RT, "Load") + if reflect.TypeOf(tmp55).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Load is not a function"))) + } + tmp56 := lang.Apply(tmp55, []any{tmp54}) + tmp51 = tmp56 + }() + tmp42 = tmp51 + } // end let + tmp36 = tmp42 + } + tmp17 = tmp36 + } // end let + _ = tmp17 + var tmp18 any = v6 + var tmp19 any = v7 + var tmp20 any = v8 + tmp22 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp23 := lang.Apply(tmp22, []any{v9}) + var tmp21 any = tmp23 + v6 = tmp18 + v7 = tmp19 + v8 = tmp20 + v9 = tmp21 + continue + } // end let + tmp10 = tmp13 + } else { + var tmp14 any + { // let + // let binding "temp__0__auto__" + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := lang.Apply(tmp15, []any{v6}) + var v17 any = tmp16 + _ = v17 + var tmp18 any + if lang.IsTruthy(v17) { + var tmp19 any + { // let + // let binding "seq_824" + var v20 any = v17 + _ = v20 + var tmp21 any + tmp22 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp23 := lang.Apply(tmp22, []any{v20}) + if lang.IsTruthy(tmp23) { + var tmp24 any + { // let + // let binding "c__0__auto__" + tmp25 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp26 := lang.Apply(tmp25, []any{v20}) + var v27 any = tmp26 + _ = v27 + tmp29 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp30 := lang.Apply(tmp29, []any{v20}) + var tmp28 any = tmp30 + var tmp31 any = v27 + tmp33 := checkDerefVar(var_glojure_DOT_core_int) + tmp34 := checkDerefVar(var_glojure_DOT_core_count) + tmp35 := lang.Apply(tmp34, []any{v27}) + tmp36 := lang.Apply(tmp33, []any{tmp35}) + var tmp32 any = tmp36 + tmp38 := checkDerefVar(var_glojure_DOT_core_int) + tmp39 := lang.Apply(tmp38, []any{int64(0)}) + var tmp37 any = tmp39 + v6 = tmp28 + v7 = tmp31 + v8 = tmp32 + v9 = tmp37 + continue + } // end let + tmp21 = tmp24 + } else { + var tmp25 any + { // let + // let binding "path" + tmp26 := checkDerefVar(var_glojure_DOT_core_first) + tmp27 := lang.Apply(tmp26, []any{v20}) + var v28 any = tmp27 + _ = v28 + var tmp29 any + { // let + // let binding "path" + var tmp30 any + tmp31 := lang.Apply(strings8.HasPrefix, []any{v28, "/"}) + if lang.IsTruthy(tmp31) { + tmp30 = v28 + } else { + tmp32 := checkDerefVar(var_glojure_DOT_core_str) + tmp33 := checkDerefVar(var_glojure_DOT_core_root_DASH_directory) + tmp34 := checkDerefVar(var_glojure_DOT_core_ns_DASH_name) + tmp35 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp36 := lang.Apply(tmp34, []any{tmp35}) + tmp37 := lang.Apply(tmp33, []any{tmp36}) + tmp38 := lang.Apply(tmp32, []any{tmp37, lang.NewChar(47), v28}) + tmp30 = tmp38 + } + var v39 any = tmp30 + _ = v39 + var tmp40 any + tmp41 := checkDerefVar(var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_) + if lang.IsTruthy(tmp41) { + tmp42 := checkDerefVar(var_glojure_DOT_core_printf) + tmp43 := lang.Apply(tmp42, []any{"(glojure.core/load \"%s\")\n", v39}) + _ = tmp43 + tmp44 := checkDerefVar(var_glojure_DOT_core_flush) + tmp45 := lang.Apply(tmp44, nil) + tmp40 = tmp45 + } else { + } + _ = tmp40 + tmp46 := checkDerefVar(var_glojure_DOT_core_check_DASH_cyclic_DASH_dependency) + tmp47 := lang.Apply(tmp46, []any{v39}) + _ = tmp47 + var tmp48 any + tmp49 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp50 := checkDerefVar(var_glojure_DOT_core_first) + tmp51 := checkDerefVar(var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_) + tmp52 := lang.Apply(tmp50, []any{tmp51}) + tmp53 := lang.Apply(tmp49, []any{v39, tmp52}) + if lang.IsTruthy(tmp53) { + } else { + var tmp54 any + { // let + tmp55 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp56 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp57 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_pending_DASH_paths_STAR_) + tmp58 := checkDerefVar(var_glojure_DOT_core_conj) + tmp59 := checkDerefVar(var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_) + tmp60 := lang.Apply(tmp58, []any{tmp59, v39}) + tmp61 := lang.Apply(tmp56, []any{tmp57, tmp60}) + tmp62 := lang.Apply(tmp55, []any{tmp61}) + _ = tmp62 + var tmp63 any + func() { + defer func() { + tmp64 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp65 := lang.Apply(tmp64, nil) + _ = tmp65 + }() + tmp66 := lang.Apply(strings8.TrimPrefix, []any{v39, "/"}) + tmp67, _ := lang.FieldOrMethod(runtime.RT, "Load") + if reflect.TypeOf(tmp67).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Load is not a function"))) + } + tmp68 := lang.Apply(tmp67, []any{tmp66}) + tmp63 = tmp68 + }() + tmp54 = tmp63 + } // end let + tmp48 = tmp54 + } + tmp29 = tmp48 + } // end let + _ = tmp29 + tmp31 := checkDerefVar(var_glojure_DOT_core_next) + tmp32 := lang.Apply(tmp31, []any{v20}) + var tmp30 any = tmp32 + var tmp33 any = nil + var tmp34 any = int64(0) + var tmp35 any = int64(0) + v6 = tmp30 + v7 = tmp33 + v8 = tmp34 + v9 = tmp35 + continue + } // end let + tmp21 = tmp25 + } + tmp19 = tmp21 + } // end let + tmp18 = tmp19 + } else { + } + tmp14 = tmp18 + } // end let + tmp10 = tmp14 + } + tmp3 = tmp10 + break + } + } // end let + return tmp3 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_load = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_load.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // load-one + { + tmp0 := sym_load_DASH_one.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_lib, sym_need_DASH_ns, sym_require)), kw_doc, "Loads a lib given its name. If need-ns, ensures that the associated\n namespace exists after loading. If require, records the load so any\n duplicate loads can be skipped.", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(8), kw_line, int(5879), kw_end_DASH_line, int(5879), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_load) + tmp6 := checkDerefVar(var_glojure_DOT_core_root_DASH_resource) + tmp7 := lang.Apply(tmp6, []any{v2}) + tmp8 := lang.Apply(tmp5, []any{tmp7}) + _ = tmp8 + tmp9 := checkDerefVar(var_glojure_DOT_core_throw_DASH_if) + var tmp10 any + { // let + // let binding "and__0__auto__" + var v11 any = v3 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + tmp13 := checkDerefVar(var_glojure_DOT_core_not) + tmp14 := checkDerefVar(var_glojure_DOT_core_find_DASH_ns) + tmp15 := lang.Apply(tmp14, []any{v2}) + tmp16 := lang.Apply(tmp13, []any{tmp15}) + tmp12 = tmp16 + } else { + tmp12 = v11 + } + tmp10 = tmp12 + } // end let + tmp11 := checkDerefVar(var_glojure_DOT_core_root_DASH_resource) + tmp12 := lang.Apply(tmp11, []any{v2}) + tmp13 := lang.Apply(tmp9, []any{tmp10, "namespace '%s' not found after loading '%s'", v2, tmp12}) + _ = tmp13 + var tmp14 any + if lang.IsTruthy(v4) { + var tmp15 lang.FnFunc + tmp15 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp16 := checkDerefVar(var_glojure_DOT_core_commute) + tmp17 := checkDerefVar(var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_) + tmp18 := checkDerefVar(var_glojure_DOT_core_conj) + tmp19 := lang.Apply(tmp16, []any{tmp17, tmp18, v2}) + return tmp19 + }) + tmp16, _ := lang.FieldOrMethod(lang.LockingTransaction, "RunInTransaction") + if reflect.TypeOf(tmp16).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("RunInTransaction is not a function"))) + } + tmp17 := lang.Apply(tmp16, []any{tmp15}) + tmp14 = tmp17 + } else { + } + return tmp14 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_load_DASH_one = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_load_DASH_one.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // load-all + { + tmp0 := sym_load_DASH_all.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_lib, sym_need_DASH_ns, sym_require)), kw_doc, "Loads a lib given its name and forces a load of any libs it directly or\n indirectly loads. If need-ns, ensures that the associated namespace\n exists after loading. If require, records the load so any duplicate loads\n can be skipped.", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(8), kw_line, int(5892), kw_end_DASH_line, int(5892), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp6 := checkDerefVar(var_glojure_DOT_core_commute) + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_) + var tmp8 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v9 := args[0] + _ = v9 + v10 := args[1] + _ = v10 + tmp11 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp12 := checkDerefVar(var_glojure_DOT_core_conj) + tmp13 := lang.Apply(tmp11, []any{tmp12, v9, v10}) + return tmp13 + }) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5899), kw_column, int(27), kw_end_DASH_line, int(5899), kw_end_DASH_column, int(47)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var tmp11 any + { // let + tmp12 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp13 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp14 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_loaded_DASH_libs_STAR_) + tmp15 := checkDerefVar(var_glojure_DOT_core_ref) + tmp16 := checkDerefVar(var_glojure_DOT_core_sorted_DASH_set) + tmp17 := lang.Apply(tmp16, nil) + tmp18 := lang.Apply(tmp15, []any{tmp17}) + tmp19 := lang.Apply(tmp13, []any{tmp14, tmp18}) + tmp20 := lang.Apply(tmp12, []any{tmp19}) + _ = tmp20 + var tmp21 any + func() { + defer func() { + tmp22 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp23 := lang.Apply(tmp22, nil) + _ = tmp23 + }() + tmp24 := checkDerefVar(var_glojure_DOT_core_load_DASH_one) + tmp25 := lang.Apply(tmp24, []any{v2, v3, v4}) + _ = tmp25 + tmp26 := checkDerefVar(var_glojure_DOT_core_deref) + tmp27 := checkDerefVar(var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_) + tmp28 := lang.Apply(tmp26, []any{tmp27}) + tmp21 = tmp28 + }() + tmp11 = tmp21 + } // end let + tmp12 := lang.Apply(tmp6, []any{tmp7, tmp10, tmp11}) + return tmp12 + }) + tmp6, _ := lang.FieldOrMethod(lang.LockingTransaction, "RunInTransaction") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("RunInTransaction is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{tmp5}) + return tmp7 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_load_DASH_all = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_load_DASH_all.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // load-data-reader-file + { + tmp0 := sym_load_DASH_data_DASH_reader_DASH_file.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7836), kw_column, int(8), kw_end_DASH_line, int(7836), kw_end_DASH_column, int(28), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_mappings, sym_url)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "rdr" + tmp5, ok := lang.FieldOrMethod(v3, "openStream") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "openStream"))) + } + var tmp6 any + switch reflect.TypeOf(tmp5).Kind() { + case reflect.Func: + tmp6 = lang.Apply(tmp5, nil) + default: + tmp6 = tmp5 + } + tmp7 := lang.Apply(nil, []any{tmp6, "UTF-8"}) + tmp8 := lang.Apply(nil, []any{tmp7}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + func() { + defer func() { + tmp11, ok := lang.FieldOrMethod(v9, "close") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v9, "close"))) + } + var tmp12 any + switch reflect.TypeOf(tmp11).Kind() { + case reflect.Func: + tmp12 = lang.Apply(tmp11, nil) + default: + tmp12 = tmp11 + } + _ = tmp12 + }() + var tmp13 any + { // let + tmp14 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp15 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp16 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_file_STAR_) + tmp17, ok := lang.FieldOrMethod(v3, "getFile") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getFile"))) + } + var tmp18 any + switch reflect.TypeOf(tmp17).Kind() { + case reflect.Func: + tmp18 = lang.Apply(tmp17, nil) + default: + tmp18 = tmp17 + } + tmp19 := lang.Apply(tmp15, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp14, []any{tmp19}) + _ = tmp20 + var tmp21 any + func() { + defer func() { + tmp22 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp23 := lang.Apply(tmp22, nil) + _ = tmp23 + }() + var tmp24 any + { // let + // let binding "read-opts" + var tmp25 any + tmp26, ok := lang.FieldOrMethod(v3, "getPath") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getPath"))) + } + var tmp27 any + switch reflect.TypeOf(tmp26).Kind() { + case reflect.Func: + tmp27 = lang.Apply(tmp26, nil) + default: + tmp27 = tmp26 + } + tmp28, _ := lang.FieldOrMethod(tmp27, "endsWith") + if reflect.TypeOf(tmp28).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("endsWith is not a function"))) + } + tmp29 := lang.Apply(tmp28, []any{"cljc"}) + if lang.IsTruthy(tmp29) { + tmp30 := lang.NewMap(kw_eof, nil, kw_read_DASH_cond, kw_allow) + tmp31 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7842), kw_column, int(25), kw_end_DASH_line, int(7842), kw_end_DASH_column, int(52)) + tmp32, err := lang.WithMeta(tmp30, tmp31.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp25 = tmp32 + } else { + tmp33 := lang.NewMap(kw_eof, nil) + tmp34 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7843), kw_column, int(25), kw_end_DASH_line, int(7843), kw_end_DASH_column, int(34)) + tmp35, err := lang.WithMeta(tmp33, tmp34.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp25 = tmp35 + } + var v36 any = tmp25 + _ = v36 + // let binding "new-mappings" + tmp37 := checkDerefVar(var_glojure_DOT_core_read) + tmp38 := lang.Apply(tmp37, []any{v36, v9}) + var v39 any = tmp38 + _ = v39 + var tmp40 any + tmp41 := checkDerefVar(var_glojure_DOT_core_not) + tmp42 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp43 := lang.Apply(tmp42, []any{v39}) + tmp44 := lang.Apply(tmp41, []any{tmp43}) + if lang.IsTruthy(tmp44) { + tmp45 := checkDerefVar(var_glojure_DOT_core_ex_DASH_info) + tmp46 := checkDerefVar(var_glojure_DOT_core_str) + tmp47 := lang.Apply(tmp46, []any{"Not a valid data-reader map"}) + tmp48 := lang.NewMap(kw_url, v3) + tmp49 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7847), kw_column, int(27), kw_end_DASH_line, int(7847), kw_end_DASH_column, int(36)) + tmp50, err := lang.WithMeta(tmp48, tmp49.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp51 := lang.Apply(tmp45, []any{tmp47, tmp50}) + panic(tmp51) + } else { + } + _ = tmp40 + tmp52 := checkDerefVar(var_glojure_DOT_core_reduce) + var tmp53 lang.FnFunc + tmp53 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v54 := args[0] + _ = v54 + v55 := args[1] + _ = v55 + var tmp56 any + { // let + // let binding "vec__1011" + var v57 any = v55 + _ = v57 + // let binding "k" + tmp58 := checkDerefVar(var_glojure_DOT_core_nth) + tmp59 := lang.Apply(tmp58, []any{v57, int64(0), nil}) + var v60 any = tmp59 + _ = v60 + // let binding "v" + tmp61 := checkDerefVar(var_glojure_DOT_core_nth) + tmp62 := lang.Apply(tmp61, []any{v57, int64(1), nil}) + var v63 any = tmp62 + _ = v63 + var tmp64 any + tmp65 := checkDerefVar(var_glojure_DOT_core_not) + tmp66 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp67 := lang.Apply(tmp66, []any{v60}) + tmp68 := lang.Apply(tmp65, []any{tmp67}) + if lang.IsTruthy(tmp68) { + tmp69 := checkDerefVar(var_glojure_DOT_core_ex_DASH_info) + tmp70 := checkDerefVar(var_glojure_DOT_core_str) + tmp71 := lang.Apply(tmp70, []any{"Invalid form in data-reader file"}) + tmp72 := lang.NewMap(kw_url, v3, kw_form, v60) + tmp73 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7852), kw_column, int(30), kw_end_DASH_line, int(7853), kw_end_DASH_column, int(38)) + tmp74, err := lang.WithMeta(tmp72, tmp73.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp75 := lang.Apply(tmp69, []any{tmp71, tmp74}) + panic(tmp75) + } else { + } + _ = tmp64 + var tmp76 any + { // let + // let binding "v-var" + tmp77 := checkDerefVar(var_glojure_DOT_core_data_DASH_reader_DASH_var) + tmp78 := lang.Apply(tmp77, []any{v63}) + var v79 any = tmp78 + _ = v79 + var tmp80 any + var tmp81 any + { // let + // let binding "and__0__auto__" + tmp82 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp83 := lang.Apply(tmp82, []any{v2, v60}) + var v84 any = tmp83 + _ = v84 + var tmp85 any + if lang.IsTruthy(v84) { + tmp86 := checkDerefVar(var_glojure_DOT_core_not_EQ_) + tmp87 := lang.Apply(v2, []any{v60}) + tmp88 := lang.Apply(tmp86, []any{tmp87, v79}) + tmp85 = tmp88 + } else { + tmp85 = v84 + } + tmp81 = tmp85 + } // end let + if lang.IsTruthy(tmp81) { + tmp82 := checkDerefVar(var_glojure_DOT_core_ex_DASH_info) + tmp83 := lang.NewMap(kw_url, v3, kw_conflict, v60, kw_mappings, v54) + tmp84 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7858), kw_column, int(32), kw_end_DASH_line, int(7860), kw_end_DASH_column, int(44)) + tmp85, err := lang.WithMeta(tmp83, tmp84.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp86 := lang.Apply(tmp82, []any{"Conflicting data-reader mapping", tmp85}) + panic(tmp86) + } else { + } + _ = tmp80 + tmp87 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp88 := lang.Apply(tmp87, []any{v54, v60, v79}) + tmp76 = tmp88 + } // end let + tmp56 = tmp76 + } // end let + return tmp56 + }) + tmp54 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7849), kw_column, int(10), kw_end_DASH_line, int(7861), kw_end_DASH_column, int(32)) + tmp55, err := lang.WithMeta(tmp53, tmp54.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp56 := lang.Apply(tmp52, []any{tmp55, v2, v39}) + tmp24 = tmp56 + } // end let + tmp21 = tmp24 + }() + tmp13 = tmp21 + } // end let + tmp10 = tmp13 + }() + tmp4 = tmp10 + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_load_DASH_data_DASH_reader_DASH_file = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_load_DASH_data_DASH_reader_DASH_file.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // load-data-readers + { + tmp0 := sym_load_DASH_data_DASH_readers.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7865), kw_column, int(8), kw_end_DASH_line, int(7865), kw_end_DASH_column, int(24), kw_private, true, kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp2 := checkDerefVar(var_glojure_DOT_core_alter_DASH_var_DASH_root) + tmp3 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_data_DASH_readers_STAR_) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v5 := args[0] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_reduce) + tmp7 := checkDerefVar(var_glojure_DOT_core_load_DASH_data_DASH_reader_DASH_file) + tmp8 := checkDerefVar(var_glojure_DOT_core_data_DASH_reader_DASH_urls) + tmp9 := lang.Apply(tmp8, nil) + tmp10 := lang.Apply(tmp6, []any{tmp7, v5, tmp9}) + return tmp10 + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7867), kw_column, int(19), kw_end_DASH_line, int(7869), kw_end_DASH_column, int(57)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp7 := lang.Apply(tmp2, []any{tmp3, tmp6}) + return tmp7 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_load_DASH_data_DASH_readers = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_load_DASH_data_DASH_readers.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // load-lib + { + tmp0 := sym_load_DASH_lib.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_prefix, sym_lib, sym__AMP_, sym_options)), kw_doc, "Loads a lib with options", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(8), kw_line, int(5904), kw_end_DASH_line, int(5904), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_throw_DASH_if) + var tmp6 any + { // let + // let binding "and__0__auto__" + var v7 any = v2 + _ = v7 + var tmp8 any + if lang.IsTruthy(v7) { + tmp9 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp10 := checkDerefVar(var_glojure_DOT_core_name) + tmp11 := lang.Apply(tmp10, []any{v3}) + tmp12 := checkDerefVar(var_glojure_DOT_core_int) + tmp13 := lang.Apply(tmp12, []any{lang.NewChar(46)}) + tmp14 := lang.Apply(strings8.Index, []any{tmp11, tmp13}) + tmp15 := lang.Apply(tmp9, []any{tmp14}) + tmp8 = tmp15 + } else { + tmp8 = v7 + } + tmp6 = tmp8 + } // end let + tmp7 := checkDerefVar(var_glojure_DOT_core_name) + tmp8 := lang.Apply(tmp7, []any{v3}) + tmp9 := lang.Apply(tmp5, []any{tmp6, "Found lib name '%s' containing period with prefix '%s'. lib names inside prefix lists must not contain periods", tmp8, v2}) + _ = tmp9 + var tmp10 any + { // let + // let binding "lib" + var tmp11 any + if lang.IsTruthy(v2) { + tmp12 := checkDerefVar(var_glojure_DOT_core_symbol) + tmp13 := checkDerefVar(var_glojure_DOT_core_str) + tmp14 := lang.Apply(tmp13, []any{v2, lang.NewChar(46), v3}) + tmp15 := lang.Apply(tmp12, []any{tmp14}) + tmp11 = tmp15 + } else { + tmp11 = v3 + } + var v16 any = tmp11 + _ = v16 + // let binding "opts" + tmp17 := checkDerefVar(var_glojure_DOT_core_apply) + tmp18 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp19 := lang.Apply(tmp17, []any{tmp18, v4}) + var v20 any = tmp19 + _ = v20 + // let binding "map__801" + var v21 any = v20 + _ = v21 + // let binding "map__801" + var tmp22 any + tmp23 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp24 := lang.Apply(tmp23, []any{v21}) + if lang.IsTruthy(tmp24) { + var tmp25 any + tmp26 := checkDerefVar(var_glojure_DOT_core_next) + tmp27 := lang.Apply(tmp26, []any{v21}) + if lang.IsTruthy(tmp27) { + tmp28 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) + tmp29 := lang.Apply(tmp28, []any{v21}) + tmp30 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{tmp29}) + tmp25 = tmp30 + } else { + var tmp31 any + tmp32 := checkDerefVar(var_glojure_DOT_core_seq) + tmp33 := lang.Apply(tmp32, []any{v21}) + if lang.IsTruthy(tmp33) { + tmp34 := checkDerefVar(var_glojure_DOT_core_first) + tmp35 := lang.Apply(tmp34, []any{v21}) + tmp31 = tmp35 + } else { + } + tmp25 = tmp31 + } + tmp22 = tmp25 + } else { + tmp22 = v21 + } + var v36 any = tmp22 + _ = v36 + // let binding "as" + tmp37 := checkDerefVar(var_glojure_DOT_core_get) + tmp38 := lang.Apply(tmp37, []any{v36, kw_as}) + var v39 any = tmp38 + _ = v39 + // let binding "reload" + tmp40 := checkDerefVar(var_glojure_DOT_core_get) + tmp41 := lang.Apply(tmp40, []any{v36, kw_reload}) + var v42 any = tmp41 + _ = v42 + // let binding "reload-all" + tmp43 := checkDerefVar(var_glojure_DOT_core_get) + tmp44 := lang.Apply(tmp43, []any{v36, kw_reload_DASH_all}) + var v45 any = tmp44 + _ = v45 + // let binding "require" + tmp46 := checkDerefVar(var_glojure_DOT_core_get) + tmp47 := lang.Apply(tmp46, []any{v36, kw_require}) + var v48 any = tmp47 + _ = v48 + // let binding "use" + tmp49 := checkDerefVar(var_glojure_DOT_core_get) + tmp50 := lang.Apply(tmp49, []any{v36, kw_use}) + var v51 any = tmp50 + _ = v51 + // let binding "verbose" + tmp52 := checkDerefVar(var_glojure_DOT_core_get) + tmp53 := lang.Apply(tmp52, []any{v36, kw_verbose}) + var v54 any = tmp53 + _ = v54 + // let binding "as-alias" + tmp55 := checkDerefVar(var_glojure_DOT_core_get) + tmp56 := lang.Apply(tmp55, []any{v36, kw_as_DASH_alias}) + var v57 any = tmp56 + _ = v57 + // let binding "loaded" + tmp58 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp59 := checkDerefVar(var_glojure_DOT_core_deref) + tmp60 := checkDerefVar(var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_) + tmp61 := lang.Apply(tmp59, []any{tmp60}) + tmp62 := lang.Apply(tmp58, []any{tmp61, v16}) + var v63 any = tmp62 + _ = v63 + // let binding "need-ns" + var tmp64 any + { // let + // let binding "or__0__auto__" + var v65 any = v39 + _ = v65 + var tmp66 any + if lang.IsTruthy(v65) { + tmp66 = v65 + } else { + tmp66 = v51 + } + tmp64 = tmp66 + } // end let + var v65 any = tmp64 + _ = v65 + // let binding "load" + var tmp66 any + if lang.IsTruthy(v45) { + tmp67 := checkDerefVar(var_glojure_DOT_core_load_DASH_all) + tmp66 = tmp67 + } else { + var tmp68 any + if lang.IsTruthy(v42) { + tmp69 := checkDerefVar(var_glojure_DOT_core_load_DASH_one) + tmp68 = tmp69 + } else { + var tmp70 any + tmp71 := checkDerefVar(var_glojure_DOT_core_not) + tmp72 := lang.Apply(tmp71, []any{v63}) + if lang.IsTruthy(tmp72) { + var tmp73 any + if lang.IsTruthy(v65) { + tmp74 := checkDerefVar(var_glojure_DOT_core_load_DASH_one) + tmp73 = tmp74 + } else { + var tmp75 any + if lang.IsTruthy(v57) { + var tmp76 lang.FnFunc + tmp76 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v77 := args[0] + _ = v77 + v78 := args[1] + _ = v78 + v79 := args[2] + _ = v79 + tmp80 := checkDerefVar(var_glojure_DOT_core_create_DASH_ns) + tmp81 := lang.Apply(tmp80, []any{v77}) + return tmp81 + }) + tmp77 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5918), kw_column, int(48), kw_end_DASH_line, int(5918), kw_end_DASH_column, int(88)) + tmp78, err := lang.WithMeta(tmp76, tmp77.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp75 = tmp78 + } else { + var tmp79 any + if lang.IsTruthy(kw_else) { + tmp80 := checkDerefVar(var_glojure_DOT_core_load_DASH_one) + tmp79 = tmp80 + } else { + } + tmp75 = tmp79 + } + tmp73 = tmp75 + } + tmp70 = tmp73 + } else { + } + tmp68 = tmp70 + } + tmp66 = tmp68 + } + var v81 any = tmp66 + _ = v81 + // let binding "filter-opts" + tmp82 := checkDerefVar(var_glojure_DOT_core_select_DASH_keys) + tmp83 := lang.Apply(tmp82, []any{v20, lang.NewList(kw_exclude, kw_only, kw_rename, kw_refer)}) + var v84 any = tmp83 + _ = v84 + // let binding "undefined-on-entry" + tmp85 := checkDerefVar(var_glojure_DOT_core_not) + tmp86 := checkDerefVar(var_glojure_DOT_core_find_DASH_ns) + tmp87 := lang.Apply(tmp86, []any{v16}) + tmp88 := lang.Apply(tmp85, []any{tmp87}) + var v89 any = tmp88 + _ = v89 + var tmp90 any + { // let + tmp91 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp92 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp93 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_loading_DASH_verbosely_STAR_) + var tmp94 any + { // let + // let binding "or__0__auto__" + tmp95 := checkDerefVar(var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_) + var v96 any = tmp95 + _ = v96 + var tmp97 any + if lang.IsTruthy(v96) { + tmp97 = v96 + } else { + tmp97 = v54 + } + tmp94 = tmp97 + } // end let + tmp95 := lang.Apply(tmp92, []any{tmp93, tmp94}) + tmp96 := lang.Apply(tmp91, []any{tmp95}) + _ = tmp96 + var tmp97 any + func() { + defer func() { + tmp98 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp99 := lang.Apply(tmp98, nil) + _ = tmp99 + }() + var tmp100 any + if lang.IsTruthy(v81) { + var tmp101 any + func() { + defer func() { + if r := recover(); r != nil { + if lang.CatchMatches(r, lang.Builtins["any"]) { + v102 := r + _ = v102 + var tmp103 any + if lang.IsTruthy(v89) { + tmp104 := checkDerefVar(var_glojure_DOT_core_remove_DASH_ns) + tmp105 := lang.Apply(tmp104, []any{v16}) + tmp103 = tmp105 + } else { + } + _ = tmp103 + panic(v102) + } else { + panic(r) + } + } + }() + tmp102 := lang.Apply(v81, []any{v16, v65, v48}) + tmp101 = tmp102 + }() + tmp100 = tmp101 + } else { + tmp103 := checkDerefVar(var_glojure_DOT_core_throw_DASH_if) + var tmp104 any + { // let + // let binding "and__0__auto__" + var v105 any = v65 + _ = v105 + var tmp106 any + if lang.IsTruthy(v105) { + tmp107 := checkDerefVar(var_glojure_DOT_core_not) + tmp108 := checkDerefVar(var_glojure_DOT_core_find_DASH_ns) + tmp109 := lang.Apply(tmp108, []any{v16}) + tmp110 := lang.Apply(tmp107, []any{tmp109}) + tmp106 = tmp110 + } else { + tmp106 = v105 + } + tmp104 = tmp106 + } // end let + tmp105 := lang.Apply(tmp103, []any{tmp104, "namespace '%s' not found", v16}) + tmp100 = tmp105 + } + _ = tmp100 + var tmp106 any + var tmp107 any + { // let + // let binding "and__0__auto__" + var v108 any = v65 + _ = v108 + var tmp109 any + if lang.IsTruthy(v108) { + tmp110 := checkDerefVar(var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_) + tmp109 = tmp110 + } else { + tmp109 = v108 + } + tmp107 = tmp109 + } // end let + if lang.IsTruthy(tmp107) { + tmp108 := checkDerefVar(var_glojure_DOT_core_printf) + tmp109 := checkDerefVar(var_glojure_DOT_core_ns_DASH_name) + tmp110 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp111 := lang.Apply(tmp109, []any{tmp110}) + tmp112 := lang.Apply(tmp108, []any{"(glojure.core/in-ns '%s)\n", tmp111}) + tmp106 = tmp112 + } else { + } + _ = tmp106 + var tmp113 any + if lang.IsTruthy(v39) { + var tmp114 any + tmp115 := checkDerefVar(var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_) + if lang.IsTruthy(tmp115) { + tmp116 := checkDerefVar(var_glojure_DOT_core_printf) + tmp117 := lang.Apply(tmp116, []any{"(glojure.core/alias '%s '%s)\n", v39, v16}) + tmp114 = tmp117 + } else { + } + _ = tmp114 + tmp118 := checkDerefVar(var_glojure_DOT_core_alias) + tmp119 := lang.Apply(tmp118, []any{v39, v16}) + tmp113 = tmp119 + } else { + } + _ = tmp113 + var tmp120 any + if lang.IsTruthy(v57) { + var tmp121 any + tmp122 := checkDerefVar(var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_) + if lang.IsTruthy(tmp122) { + tmp123 := checkDerefVar(var_glojure_DOT_core_printf) + tmp124 := lang.Apply(tmp123, []any{"(glojure.core/alias '%s '%s)\n", v57, v16}) + tmp121 = tmp124 + } else { + } + _ = tmp121 + tmp125 := checkDerefVar(var_glojure_DOT_core_alias) + tmp126 := lang.Apply(tmp125, []any{v57, v16}) + tmp120 = tmp126 + } else { + } + _ = tmp120 + var tmp127 any + var tmp128 any + { // let + // let binding "or__0__auto__" + var v129 any = v51 + _ = v129 + var tmp130 any + if lang.IsTruthy(v129) { + tmp130 = v129 + } else { + tmp131 := lang.Apply(kw_refer, []any{v84}) + tmp130 = tmp131 + } + tmp128 = tmp130 + } // end let + if lang.IsTruthy(tmp128) { + var tmp129 any + tmp130 := checkDerefVar(var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_) + if lang.IsTruthy(tmp130) { + tmp131 := checkDerefVar(var_glojure_DOT_core_printf) + tmp132 := lang.Apply(tmp131, []any{"(glojure.core/refer '%s", v16}) + _ = tmp132 + var tmp133 any + { // let + // let binding "seq_802" + tmp134 := checkDerefVar(var_glojure_DOT_core_seq) + tmp135 := lang.Apply(tmp134, []any{v84}) + var v136 any = tmp135 + _ = v136 + // let binding "chunk_803" + var v137 any = nil + _ = v137 + // let binding "count_804" + var v138 any = int64(0) + _ = v138 + // let binding "i_805" + var v139 any = int64(0) + _ = v139 + for { + var tmp140 any + tmp141 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp142 := lang.Apply(tmp141, []any{v139, v138}) + if lang.IsTruthy(tmp142) { + var tmp143 any + { // let + // let binding "opt" + tmp144, _ := lang.FieldOrMethod(v137, "nth") + if reflect.TypeOf(tmp144).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp145 := lang.Apply(tmp144, []any{v139}) + var v146 any = tmp145 + _ = v146 + tmp147 := checkDerefVar(var_glojure_DOT_core_printf) + tmp148 := checkDerefVar(var_glojure_DOT_core_key) + tmp149 := lang.Apply(tmp148, []any{v146}) + tmp150 := checkDerefVar(var_glojure_DOT_core_print_DASH_str) + tmp151 := checkDerefVar(var_glojure_DOT_core_val) + tmp152 := lang.Apply(tmp151, []any{v146}) + tmp153 := lang.Apply(tmp150, []any{tmp152}) + tmp154 := lang.Apply(tmp147, []any{" %s '%s", tmp149, tmp153}) + _ = tmp154 + var tmp155 any = v136 + var tmp156 any = v137 + var tmp157 any = v138 + tmp159 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp160 := lang.Apply(tmp159, []any{v139}) + var tmp158 any = tmp160 + v136 = tmp155 + v137 = tmp156 + v138 = tmp157 + v139 = tmp158 + continue + } // end let + tmp140 = tmp143 + } else { + var tmp144 any + { // let + // let binding "temp__0__auto__" + tmp145 := checkDerefVar(var_glojure_DOT_core_seq) + tmp146 := lang.Apply(tmp145, []any{v136}) + var v147 any = tmp146 + _ = v147 + var tmp148 any + if lang.IsTruthy(v147) { + var tmp149 any + { // let + // let binding "seq_802" + var v150 any = v147 + _ = v150 + var tmp151 any + tmp152 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp153 := lang.Apply(tmp152, []any{v150}) + if lang.IsTruthy(tmp153) { + var tmp154 any + { // let + // let binding "c__0__auto__" + tmp155 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp156 := lang.Apply(tmp155, []any{v150}) + var v157 any = tmp156 + _ = v157 + tmp159 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp160 := lang.Apply(tmp159, []any{v150}) + var tmp158 any = tmp160 + var tmp161 any = v157 + tmp163 := checkDerefVar(var_glojure_DOT_core_int) + tmp164 := checkDerefVar(var_glojure_DOT_core_count) + tmp165 := lang.Apply(tmp164, []any{v157}) + tmp166 := lang.Apply(tmp163, []any{tmp165}) + var tmp162 any = tmp166 + tmp168 := checkDerefVar(var_glojure_DOT_core_int) + tmp169 := lang.Apply(tmp168, []any{int64(0)}) + var tmp167 any = tmp169 + v136 = tmp158 + v137 = tmp161 + v138 = tmp162 + v139 = tmp167 + continue + } // end let + tmp151 = tmp154 + } else { + var tmp155 any + { // let + // let binding "opt" + tmp156 := checkDerefVar(var_glojure_DOT_core_first) + tmp157 := lang.Apply(tmp156, []any{v150}) + var v158 any = tmp157 + _ = v158 + tmp159 := checkDerefVar(var_glojure_DOT_core_printf) + tmp160 := checkDerefVar(var_glojure_DOT_core_key) + tmp161 := lang.Apply(tmp160, []any{v158}) + tmp162 := checkDerefVar(var_glojure_DOT_core_print_DASH_str) + tmp163 := checkDerefVar(var_glojure_DOT_core_val) + tmp164 := lang.Apply(tmp163, []any{v158}) + tmp165 := lang.Apply(tmp162, []any{tmp164}) + tmp166 := lang.Apply(tmp159, []any{" %s '%s", tmp161, tmp165}) + _ = tmp166 + tmp168 := checkDerefVar(var_glojure_DOT_core_next) + tmp169 := lang.Apply(tmp168, []any{v150}) + var tmp167 any = tmp169 + var tmp170 any = nil + var tmp171 any = int64(0) + var tmp172 any = int64(0) + v136 = tmp167 + v137 = tmp170 + v138 = tmp171 + v139 = tmp172 + continue + } // end let + tmp151 = tmp155 + } + tmp149 = tmp151 + } // end let + tmp148 = tmp149 + } else { + } + tmp144 = tmp148 + } // end let + tmp140 = tmp144 + } + tmp133 = tmp140 + break + } + } // end let + _ = tmp133 + tmp134 := checkDerefVar(var_glojure_DOT_core_printf) + tmp135 := lang.Apply(tmp134, []any{")\n"}) + tmp129 = tmp135 + } else { + } + _ = tmp129 + tmp136 := checkDerefVar(var_glojure_DOT_core_apply) + tmp137 := checkDerefVar(var_glojure_DOT_core_refer) + tmp138 := checkDerefVar(var_glojure_DOT_core_mapcat) + tmp139 := checkDerefVar(var_glojure_DOT_core_seq) + tmp140 := lang.Apply(tmp138, []any{tmp139, v84}) + tmp141 := lang.Apply(tmp136, []any{tmp137, v16, tmp140}) + tmp127 = tmp141 + } else { + } + tmp97 = tmp127 + }() + tmp90 = tmp97 + } // end let + tmp10 = tmp90 + } // end let + return tmp10 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_load_DASH_lib = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_load_DASH_lib.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // load-libs + { + tmp0 := sym_load_DASH_libs.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_args)), kw_doc, "Loads libs, interpreting libspecs, prefix lists, and flags for\n forwarding to load-lib", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(8), kw_line, int(5951), kw_end_DASH_line, int(5951), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + var tmp3 any + { // let + // let binding "flags" + tmp4 := checkDerefVar(var_glojure_DOT_core_filter) + tmp5 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp6 := lang.Apply(tmp4, []any{tmp5, v2}) + var v7 any = tmp6 + _ = v7 + // let binding "opts" + tmp8 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp9 := checkDerefVar(var_glojure_DOT_core_repeat) + tmp10 := lang.Apply(tmp9, []any{true}) + tmp11 := lang.Apply(tmp8, []any{v7, tmp10}) + var v12 any = tmp11 + _ = v12 + // let binding "args" + tmp13 := checkDerefVar(var_glojure_DOT_core_filter) + tmp14 := checkDerefVar(var_glojure_DOT_core_complement) + tmp15 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp16 := lang.Apply(tmp14, []any{tmp15}) + tmp17 := lang.Apply(tmp13, []any{tmp16, v2}) + var v18 any = tmp17 + _ = v18 + var tmp19 any + { // let + // let binding "supported" + tmp20 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{kw_as, kw_reload, kw_reload_DASH_all, kw_require, kw_use, kw_verbose, kw_refer, kw_as_DASH_alias})) + tmp21 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5959), kw_column, int(21), kw_end_DASH_line, int(5959), kw_end_DASH_column, int(86)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v23 any = tmp22 + _ = v23 + // let binding "unsupported" + tmp24 := checkDerefVar(var_glojure_DOT_core_seq) + tmp25 := checkDerefVar(var_glojure_DOT_core_remove) + tmp26 := lang.Apply(tmp25, []any{v23, v7}) + tmp27 := lang.Apply(tmp24, []any{tmp26}) + var v28 any = tmp27 + _ = v28 + tmp29 := checkDerefVar(var_glojure_DOT_core_throw_DASH_if) + tmp30 := checkDerefVar(var_glojure_DOT_core_apply) + tmp31 := checkDerefVar(var_glojure_DOT_core_str) + tmp32 := checkDerefVar(var_glojure_DOT_core_interpose) + tmp33 := lang.Apply(tmp32, []any{lang.NewChar(44), v28}) + tmp34 := lang.Apply(tmp30, []any{tmp31, "Unsupported option(s) supplied: ", tmp33}) + tmp35 := lang.Apply(tmp29, []any{v28, tmp34}) + tmp19 = tmp35 + } // end let + _ = tmp19 + tmp20 := checkDerefVar(var_glojure_DOT_core_throw_DASH_if) + tmp21 := checkDerefVar(var_glojure_DOT_core_not) + tmp22 := checkDerefVar(var_glojure_DOT_core_seq) + tmp23 := lang.Apply(tmp22, []any{v18}) + tmp24 := lang.Apply(tmp21, []any{tmp23}) + tmp25 := lang.Apply(tmp20, []any{tmp24, "Nothing specified to load"}) + _ = tmp25 + var tmp26 any + { // let + // let binding "seq_806" + tmp27 := checkDerefVar(var_glojure_DOT_core_seq) + tmp28 := lang.Apply(tmp27, []any{v18}) + var v29 any = tmp28 + _ = v29 + // let binding "chunk_807" + var v30 any = nil + _ = v30 + // let binding "count_808" + var v31 any = int64(0) + _ = v31 + // let binding "i_809" + var v32 any = int64(0) + _ = v32 + for { + var tmp33 any + tmp34 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp35 := lang.Apply(tmp34, []any{v32, v31}) + if lang.IsTruthy(tmp35) { + var tmp36 any + { // let + // let binding "arg" + tmp37, _ := lang.FieldOrMethod(v30, "nth") + if reflect.TypeOf(tmp37).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp38 := lang.Apply(tmp37, []any{v32}) + var v39 any = tmp38 + _ = v39 + var tmp40 any + tmp41 := checkDerefVar(var_glojure_DOT_core_libspec_QMARK_) + tmp42 := lang.Apply(tmp41, []any{v39}) + if lang.IsTruthy(tmp42) { + tmp43 := checkDerefVar(var_glojure_DOT_core_apply) + tmp44 := checkDerefVar(var_glojure_DOT_core_load_DASH_lib) + tmp45 := checkDerefVar(var_glojure_DOT_core_prependss) + tmp46 := lang.Apply(tmp45, []any{v39, v12}) + tmp47 := lang.Apply(tmp43, []any{tmp44, nil, tmp46}) + tmp40 = tmp47 + } else { + var tmp48 any + { // let + // let binding "vec__810" + var v49 any = v39 + _ = v49 + // let binding "seq__811" + tmp50 := checkDerefVar(var_glojure_DOT_core_seq) + tmp51 := lang.Apply(tmp50, []any{v49}) + var v52 any = tmp51 + _ = v52 + // let binding "first__812" + tmp53 := checkDerefVar(var_glojure_DOT_core_first) + tmp54 := lang.Apply(tmp53, []any{v52}) + var v55 any = tmp54 + _ = v55 + // let binding "seq__811" + tmp56 := checkDerefVar(var_glojure_DOT_core_next) + tmp57 := lang.Apply(tmp56, []any{v52}) + var v58 any = tmp57 + _ = v58 + // let binding "prefix" + var v59 any = v55 + _ = v59 + // let binding "args" + var v60 any = v58 + _ = v60 + tmp61 := checkDerefVar(var_glojure_DOT_core_throw_DASH_if) + tmp62 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp63 := lang.Apply(tmp62, []any{v59}) + tmp64 := lang.Apply(tmp61, []any{tmp63, "prefix cannot be nil"}) + _ = tmp64 + var tmp65 any + { // let + // let binding "seq_813" + tmp66 := checkDerefVar(var_glojure_DOT_core_seq) + tmp67 := lang.Apply(tmp66, []any{v60}) + var v68 any = tmp67 + _ = v68 + // let binding "chunk_814" + var v69 any = nil + _ = v69 + // let binding "count_815" + var v70 any = int64(0) + _ = v70 + // let binding "i_816" + var v71 any = int64(0) + _ = v71 + for { + var tmp72 any + tmp73 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp74 := lang.Apply(tmp73, []any{v71, v70}) + if lang.IsTruthy(tmp74) { + var tmp75 any + { // let + // let binding "arg" + tmp76, _ := lang.FieldOrMethod(v69, "nth") + if reflect.TypeOf(tmp76).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp77 := lang.Apply(tmp76, []any{v71}) + var v78 any = tmp77 + _ = v78 + tmp79 := checkDerefVar(var_glojure_DOT_core_apply) + tmp80 := checkDerefVar(var_glojure_DOT_core_load_DASH_lib) + tmp81 := checkDerefVar(var_glojure_DOT_core_prependss) + tmp82 := lang.Apply(tmp81, []any{v78, v12}) + tmp83 := lang.Apply(tmp79, []any{tmp80, v59, tmp82}) + _ = tmp83 + var tmp84 any = v68 + var tmp85 any = v69 + var tmp86 any = v70 + tmp88 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp89 := lang.Apply(tmp88, []any{v71}) + var tmp87 any = tmp89 + v68 = tmp84 + v69 = tmp85 + v70 = tmp86 + v71 = tmp87 + continue + } // end let + tmp72 = tmp75 + } else { + var tmp76 any + { // let + // let binding "temp__0__auto__" + tmp77 := checkDerefVar(var_glojure_DOT_core_seq) + tmp78 := lang.Apply(tmp77, []any{v68}) + var v79 any = tmp78 + _ = v79 + var tmp80 any + if lang.IsTruthy(v79) { + var tmp81 any + { // let + // let binding "seq_813" + var v82 any = v79 + _ = v82 + var tmp83 any + tmp84 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp85 := lang.Apply(tmp84, []any{v82}) + if lang.IsTruthy(tmp85) { + var tmp86 any + { // let + // let binding "c__0__auto__" + tmp87 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp88 := lang.Apply(tmp87, []any{v82}) + var v89 any = tmp88 + _ = v89 + tmp91 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp92 := lang.Apply(tmp91, []any{v82}) + var tmp90 any = tmp92 + var tmp93 any = v89 + tmp95 := checkDerefVar(var_glojure_DOT_core_int) + tmp96 := checkDerefVar(var_glojure_DOT_core_count) + tmp97 := lang.Apply(tmp96, []any{v89}) + tmp98 := lang.Apply(tmp95, []any{tmp97}) + var tmp94 any = tmp98 + tmp100 := checkDerefVar(var_glojure_DOT_core_int) + tmp101 := lang.Apply(tmp100, []any{int64(0)}) + var tmp99 any = tmp101 + v68 = tmp90 + v69 = tmp93 + v70 = tmp94 + v71 = tmp99 + continue + } // end let + tmp83 = tmp86 + } else { + var tmp87 any + { // let + // let binding "arg" + tmp88 := checkDerefVar(var_glojure_DOT_core_first) + tmp89 := lang.Apply(tmp88, []any{v82}) + var v90 any = tmp89 + _ = v90 + tmp91 := checkDerefVar(var_glojure_DOT_core_apply) + tmp92 := checkDerefVar(var_glojure_DOT_core_load_DASH_lib) + tmp93 := checkDerefVar(var_glojure_DOT_core_prependss) + tmp94 := lang.Apply(tmp93, []any{v90, v12}) + tmp95 := lang.Apply(tmp91, []any{tmp92, v59, tmp94}) + _ = tmp95 + tmp97 := checkDerefVar(var_glojure_DOT_core_next) + tmp98 := lang.Apply(tmp97, []any{v82}) + var tmp96 any = tmp98 + var tmp99 any = nil + var tmp100 any = int64(0) + var tmp101 any = int64(0) + v68 = tmp96 + v69 = tmp99 + v70 = tmp100 + v71 = tmp101 + continue + } // end let + tmp83 = tmp87 + } + tmp81 = tmp83 + } // end let + tmp80 = tmp81 + } else { + } + tmp76 = tmp80 + } // end let + tmp72 = tmp76 + } + tmp65 = tmp72 + break + } + } // end let + tmp48 = tmp65 + } // end let + tmp40 = tmp48 + } + _ = tmp40 + var tmp49 any = v29 + var tmp50 any = v30 + var tmp51 any = v31 + tmp53 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp54 := lang.Apply(tmp53, []any{v32}) + var tmp52 any = tmp54 + v29 = tmp49 + v30 = tmp50 + v31 = tmp51 + v32 = tmp52 + continue + } // end let + tmp33 = tmp36 + } else { + var tmp37 any + { // let + // let binding "temp__0__auto__" + tmp38 := checkDerefVar(var_glojure_DOT_core_seq) + tmp39 := lang.Apply(tmp38, []any{v29}) + var v40 any = tmp39 + _ = v40 + var tmp41 any + if lang.IsTruthy(v40) { + var tmp42 any + { // let + // let binding "seq_806" + var v43 any = v40 + _ = v43 + var tmp44 any + tmp45 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp46 := lang.Apply(tmp45, []any{v43}) + if lang.IsTruthy(tmp46) { + var tmp47 any + { // let + // let binding "c__0__auto__" + tmp48 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp49 := lang.Apply(tmp48, []any{v43}) + var v50 any = tmp49 + _ = v50 + tmp52 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp53 := lang.Apply(tmp52, []any{v43}) + var tmp51 any = tmp53 + var tmp54 any = v50 + tmp56 := checkDerefVar(var_glojure_DOT_core_int) + tmp57 := checkDerefVar(var_glojure_DOT_core_count) + tmp58 := lang.Apply(tmp57, []any{v50}) + tmp59 := lang.Apply(tmp56, []any{tmp58}) + var tmp55 any = tmp59 + tmp61 := checkDerefVar(var_glojure_DOT_core_int) + tmp62 := lang.Apply(tmp61, []any{int64(0)}) + var tmp60 any = tmp62 + v29 = tmp51 + v30 = tmp54 + v31 = tmp55 + v32 = tmp60 + continue + } // end let + tmp44 = tmp47 + } else { + var tmp48 any + { // let + // let binding "arg" + tmp49 := checkDerefVar(var_glojure_DOT_core_first) + tmp50 := lang.Apply(tmp49, []any{v43}) + var v51 any = tmp50 + _ = v51 + var tmp52 any + tmp53 := checkDerefVar(var_glojure_DOT_core_libspec_QMARK_) + tmp54 := lang.Apply(tmp53, []any{v51}) + if lang.IsTruthy(tmp54) { + tmp55 := checkDerefVar(var_glojure_DOT_core_apply) + tmp56 := checkDerefVar(var_glojure_DOT_core_load_DASH_lib) + tmp57 := checkDerefVar(var_glojure_DOT_core_prependss) + tmp58 := lang.Apply(tmp57, []any{v51, v12}) + tmp59 := lang.Apply(tmp55, []any{tmp56, nil, tmp58}) + tmp52 = tmp59 + } else { + var tmp60 any + { // let + // let binding "vec__817" + var v61 any = v51 + _ = v61 + // let binding "seq__818" + tmp62 := checkDerefVar(var_glojure_DOT_core_seq) + tmp63 := lang.Apply(tmp62, []any{v61}) + var v64 any = tmp63 + _ = v64 + // let binding "first__819" + tmp65 := checkDerefVar(var_glojure_DOT_core_first) + tmp66 := lang.Apply(tmp65, []any{v64}) + var v67 any = tmp66 + _ = v67 + // let binding "seq__818" + tmp68 := checkDerefVar(var_glojure_DOT_core_next) + tmp69 := lang.Apply(tmp68, []any{v64}) + var v70 any = tmp69 + _ = v70 + // let binding "prefix" + var v71 any = v67 + _ = v71 + // let binding "args" + var v72 any = v70 + _ = v72 + tmp73 := checkDerefVar(var_glojure_DOT_core_throw_DASH_if) + tmp74 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp75 := lang.Apply(tmp74, []any{v71}) + tmp76 := lang.Apply(tmp73, []any{tmp75, "prefix cannot be nil"}) + _ = tmp76 + var tmp77 any + { // let + // let binding "seq_820" + tmp78 := checkDerefVar(var_glojure_DOT_core_seq) + tmp79 := lang.Apply(tmp78, []any{v72}) + var v80 any = tmp79 + _ = v80 + // let binding "chunk_821" + var v81 any = nil + _ = v81 + // let binding "count_822" + var v82 any = int64(0) + _ = v82 + // let binding "i_823" + var v83 any = int64(0) + _ = v83 + for { + var tmp84 any + tmp85 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp86 := lang.Apply(tmp85, []any{v83, v82}) + if lang.IsTruthy(tmp86) { + var tmp87 any + { // let + // let binding "arg" + tmp88, _ := lang.FieldOrMethod(v81, "nth") + if reflect.TypeOf(tmp88).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp89 := lang.Apply(tmp88, []any{v83}) + var v90 any = tmp89 + _ = v90 + tmp91 := checkDerefVar(var_glojure_DOT_core_apply) + tmp92 := checkDerefVar(var_glojure_DOT_core_load_DASH_lib) + tmp93 := checkDerefVar(var_glojure_DOT_core_prependss) + tmp94 := lang.Apply(tmp93, []any{v90, v12}) + tmp95 := lang.Apply(tmp91, []any{tmp92, v71, tmp94}) + _ = tmp95 + var tmp96 any = v80 + var tmp97 any = v81 + var tmp98 any = v82 + tmp100 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp101 := lang.Apply(tmp100, []any{v83}) + var tmp99 any = tmp101 + v80 = tmp96 + v81 = tmp97 + v82 = tmp98 + v83 = tmp99 + continue + } // end let + tmp84 = tmp87 + } else { + var tmp88 any + { // let + // let binding "temp__0__auto__" + tmp89 := checkDerefVar(var_glojure_DOT_core_seq) + tmp90 := lang.Apply(tmp89, []any{v80}) + var v91 any = tmp90 + _ = v91 + var tmp92 any + if lang.IsTruthy(v91) { + var tmp93 any + { // let + // let binding "seq_820" + var v94 any = v91 + _ = v94 + var tmp95 any + tmp96 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp97 := lang.Apply(tmp96, []any{v94}) + if lang.IsTruthy(tmp97) { + var tmp98 any + { // let + // let binding "c__0__auto__" + tmp99 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp100 := lang.Apply(tmp99, []any{v94}) + var v101 any = tmp100 + _ = v101 + tmp103 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp104 := lang.Apply(tmp103, []any{v94}) + var tmp102 any = tmp104 + var tmp105 any = v101 + tmp107 := checkDerefVar(var_glojure_DOT_core_int) + tmp108 := checkDerefVar(var_glojure_DOT_core_count) + tmp109 := lang.Apply(tmp108, []any{v101}) + tmp110 := lang.Apply(tmp107, []any{tmp109}) + var tmp106 any = tmp110 + tmp112 := checkDerefVar(var_glojure_DOT_core_int) + tmp113 := lang.Apply(tmp112, []any{int64(0)}) + var tmp111 any = tmp113 + v80 = tmp102 + v81 = tmp105 + v82 = tmp106 + v83 = tmp111 + continue + } // end let + tmp95 = tmp98 + } else { + var tmp99 any + { // let + // let binding "arg" + tmp100 := checkDerefVar(var_glojure_DOT_core_first) + tmp101 := lang.Apply(tmp100, []any{v94}) + var v102 any = tmp101 + _ = v102 + tmp103 := checkDerefVar(var_glojure_DOT_core_apply) + tmp104 := checkDerefVar(var_glojure_DOT_core_load_DASH_lib) + tmp105 := checkDerefVar(var_glojure_DOT_core_prependss) + tmp106 := lang.Apply(tmp105, []any{v102, v12}) + tmp107 := lang.Apply(tmp103, []any{tmp104, v71, tmp106}) + _ = tmp107 + tmp109 := checkDerefVar(var_glojure_DOT_core_next) + tmp110 := lang.Apply(tmp109, []any{v94}) + var tmp108 any = tmp110 + var tmp111 any = nil + var tmp112 any = int64(0) + var tmp113 any = int64(0) + v80 = tmp108 + v81 = tmp111 + v82 = tmp112 + v83 = tmp113 + continue + } // end let + tmp95 = tmp99 + } + tmp93 = tmp95 + } // end let + tmp92 = tmp93 + } else { + } + tmp88 = tmp92 + } // end let + tmp84 = tmp88 + } + tmp77 = tmp84 + break + } + } // end let + tmp60 = tmp77 + } // end let + tmp52 = tmp60 + } + _ = tmp52 + tmp62 := checkDerefVar(var_glojure_DOT_core_next) + tmp63 := lang.Apply(tmp62, []any{v43}) + var tmp61 any = tmp63 + var tmp64 any = nil + var tmp65 any = int64(0) + var tmp66 any = int64(0) + v29 = tmp61 + v30 = tmp64 + v31 = tmp65 + v32 = tmp66 + continue + } // end let + tmp44 = tmp48 + } + tmp42 = tmp44 + } // end let + tmp41 = tmp42 + } else { + } + tmp37 = tmp41 + } // end let + tmp33 = tmp37 + } + tmp26 = tmp33 + break + } + } // end let + tmp3 = tmp26 + } // end let + return tmp3 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_load_DASH_libs = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_load_DASH_libs.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // require + { + tmp0 := sym_require.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_args)), kw_doc, "Loads libs, skipping any that are already loaded. Each argument is\n either a libspec that identifies a lib, a prefix list that identifies\n multiple libs whose names share a common prefix, or a flag that modifies\n how all the identified libs are loaded. Use :require in the ns macro\n in preference to calling this directly.\n\n Libs\n\n A 'lib' is a named set of resources in classpath whose contents define a\n library of Clojure code. Lib names are symbols and each lib is associated\n with a Clojure namespace and a Java package that share its name. A lib's\n name also locates its root directory within classpath using Java's\n package name to classpath-relative path mapping. All resources in a lib\n should be contained in the directory structure under its root directory.\n All definitions a lib makes should be in its associated namespace.\n\n 'require loads a lib by loading its root resource. The root resource path\n is derived from the lib name in the following manner:\n Consider a lib named by the symbol 'x.y.z; it has the root directory\n /x/y/, and its root resource is /x/y/z.clj, or\n /x/y/z.cljc if /x/y/z.clj does not exist. The\n root resource should contain code to create the lib's\n namespace (usually by using the ns macro) and load any additional\n lib resources.\n\n Libspecs\n\n A libspec is a lib name or a vector containing a lib name followed by\n options expressed as sequential keywords and arguments.\n\n Recognized options:\n :as takes a symbol as its argument and makes that symbol an alias to the\n lib's namespace in the current namespace.\n :as-alias takes a symbol as its argument and aliases like :as, however\n the lib will not be loaded. If the lib has not been loaded, a new\n empty namespace will be created (as with create-ns).\n :refer takes a list of symbols to refer from the namespace or the :all\n keyword to bring in all public vars.\n\n Prefix Lists\n\n It's common for Clojure code to depend on several libs whose names have\n the same prefix. When specifying libs, prefix lists can be used to reduce\n repetition. A prefix list contains the shared prefix followed by libspecs\n with the shared prefix removed from the lib names. After removing the\n prefix, the names that remain must not contain any periods.\n\n Flags\n\n A flag is a keyword.\n Recognized flags: :reload, :reload-all, :verbose\n :reload forces loading of all the identified libs even if they are\n already loaded (has no effect on libspecs using :as-alias)\n :reload-all implies :reload and also forces loading of all libs that the\n identified libs directly or indirectly load via require or use\n (has no effect on libspecs using :as-alias)\n :verbose triggers printing information about each load, alias, and refer\n\n Example:\n\n The following would load the libraries glojure.zip and glojure.set\n abbreviated as 's'.\n\n (require '(glojure zip [set :as s]))", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(5989), kw_end_DASH_line, int(5989))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_apply) + tmp4 := checkDerefVar(var_glojure_DOT_core_load_DASH_libs) + tmp5 := lang.Apply(tmp3, []any{tmp4, kw_require, v2}) + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_require = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_require.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // serialized-require + { + tmp0 := sym_serialized_DASH_require.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_args)), kw_doc, "Like 'require', but serializes loading.\n Interim function preferred over 'require' for known asynchronous loads.\n Future changes may make these equivalent.", kw_file, "glojure/core.glj", kw_added, "1.10", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(25), kw_column, int(8), kw_line, int(6059), kw_end_DASH_line, int(6059), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + var tmp3 any + { // let + // let binding "lockee__0__auto__" + var v4 any = nil + _ = v4 + var tmp5 any + func() { + var tmp6 any + { // let + // let binding "locklocal__1__auto__" + var v7 any = v4 + _ = v7 + tmp8 := lang.Apply(nil, []any{v7}) + _ = tmp8 + var tmp9 any + func() { + defer func() { + tmp10 := lang.Apply(nil, []any{v7}) + _ = tmp10 + }() + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + tmp12 := checkDerefVar(var_glojure_DOT_core_require) + tmp13 := lang.Apply(tmp11, []any{tmp12, v2}) + tmp9 = tmp13 + }() + tmp6 = tmp9 + } // end let + tmp5 = tmp6 + }() + tmp3 = tmp5 + } // end let + return tmp3 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_serialized_DASH_require = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_serialized_DASH_require.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // use + { + tmp0 := sym_use.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_args)), kw_doc, "Like 'require, but also refers to each lib's namespace using\n glojure.core/refer. Use :use in the ns macro in preference to calling\n this directly.\n\n 'use accepts additional options in libspecs: :exclude, :only, :rename.\n The arguments and semantics for :exclude, :only, and :rename are the same\n as those documented for glojure.core/refer.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(6079), kw_end_DASH_line, int(6079))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_apply) + tmp4 := checkDerefVar(var_glojure_DOT_core_load_DASH_libs) + tmp5 := lang.Apply(tmp3, []any{tmp4, kw_require, kw_use, v2}) + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_use = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_use.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // requiring-resolve + { + tmp0 := sym_requiring_DASH_resolve.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_sym)), kw_doc, "Resolves namespace-qualified sym per 'resolve'. If initial resolve\nfails, attempts to require sym's namespace and retries.", kw_file, "glojure/core.glj", kw_added, "1.10", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(7), kw_line, int(6068), kw_end_DASH_line, int(6068))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_qualified_DASH_symbol_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + var tmp6 any + { // let + // let binding "or__0__auto__" + tmp7 := checkDerefVar(var_glojure_DOT_core_resolve) + tmp8 := lang.Apply(tmp7, []any{v2}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + tmp10 = v9 + } else { + tmp11 := checkDerefVar(var_glojure_DOT_core_serialized_DASH_require) + tmp12 := checkDerefVar(var_glojure_DOT_core_symbol) + tmp13 := checkDerefVar(var_glojure_DOT_core_namespace) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(tmp12, []any{tmp14}) + tmp16 := lang.Apply(tmp11, []any{tmp15}) + _ = tmp16 + tmp17 := checkDerefVar(var_glojure_DOT_core_resolve) + tmp18 := lang.Apply(tmp17, []any{v2}) + tmp10 = tmp18 + } + tmp6 = tmp10 + } // end let + tmp3 = tmp6 + } else { + tmp7 := checkDerefVar(var_glojure_DOT_core_str) + tmp8 := lang.Apply(tmp7, []any{"Not a qualified symbol: ", v2}) + tmp9 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp8}) + panic(tmp9) + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_requiring_DASH_resolve = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_requiring_DASH_resolve.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // mapv + { + tmp0 := sym_mapv.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_coll), lang.NewVector(sym_f, sym_c1, sym_c2), lang.NewVector(sym_f, sym_c1, sym_c2, sym_c3), lang.NewVector(sym_f, sym_c1, sym_c2, sym_c3, sym__AMP_, sym_colls)), kw_doc, "Returns a vector consisting of the result of applying f to the\n set of first items of each coll, followed by applying f to the set\n of second items in each coll, until any one of the colls is\n exhausted. Any remaining items in other colls are ignored. Function\n f should accept number-of-colls arguments.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.4", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(6943), kw_end_DASH_line, int(6943))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp5 := checkDerefVar(var_glojure_DOT_core_reduce) + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_conj_BANG_) + tmp10 := lang.Apply(v2, []any{v8}) + tmp11 := lang.Apply(tmp9, []any{v7, tmp10}) + return tmp11 + }) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6952), kw_column, int(18), kw_end_DASH_line, int(6952), kw_end_DASH_column, int(43)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp9 := checkDerefVar(var_glojure_DOT_core_transient) + tmp10 := lang.NewVector() + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6952), kw_column, int(56), kw_end_DASH_line, int(6952), kw_end_DASH_column, int(57)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := lang.Apply(tmp9, []any{tmp12}) + tmp14 := lang.Apply(tmp5, []any{tmp8, tmp13, v3}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_into) + tmp6 := lang.NewVector() + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6955), kw_column, int(12), kw_end_DASH_line, int(6955), kw_end_DASH_column, int(13)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp9 := checkDerefVar(var_glojure_DOT_core_map) + tmp10 := lang.Apply(tmp9, []any{v2, v3, v4}) + tmp11 := lang.Apply(tmp5, []any{tmp8, tmp10}) + return tmp11 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_into) + tmp7 := lang.NewVector() + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6957), kw_column, int(12), kw_end_DASH_line, int(6957), kw_end_DASH_column, int(13)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp10 := checkDerefVar(var_glojure_DOT_core_map) + tmp11 := lang.Apply(tmp10, []any{v2, v3, v4, v5}) + tmp12 := lang.Apply(tmp6, []any{tmp9, tmp11}) + return tmp12 + default: + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var v6 any = lang.NewList(args[4:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_into) + tmp8 := lang.NewVector() + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6959), kw_column, int(12), kw_end_DASH_line, int(6959), kw_end_DASH_column, int(13)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + tmp12 := checkDerefVar(var_glojure_DOT_core_map) + tmp13 := lang.Apply(tmp11, []any{tmp12, v2, v3, v4, v5, v6}) + tmp14 := lang.Apply(tmp7, []any{tmp10, tmp13}) + return tmp14 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_mapv = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_mapv.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // newline + { + tmp0 := sym_newline.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Writes a platform-specific newline to *out*", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(3698), kw_end_DASH_line, int(3698))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp2 := checkDerefVar(var_glojure_DOT_core__STAR_out_STAR_) + tmp3 := checkDerefVar(var_glojure_DOT_core_system_DASH_newline) + tmp4 := lang.Apply(lang.AppendWriter, []any{tmp2, tmp3}) + _ = tmp4 + return nil + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_newline = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_newline.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // normalize-slurp-opts + { + tmp0 := sym_normalize_DASH_slurp_DASH_opts.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6974), kw_column, int(8), kw_end_DASH_line, int(6974), kw_end_DASH_column, int(27), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_opts)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_first) + tmp6 := lang.Apply(tmp5, []any{v2}) + tmp7 := lang.Apply(tmp4, []any{tmp6}) + if lang.IsTruthy(tmp7) { + tmp8 := checkDerefVar(var_glojure_DOT_core_println) + tmp9 := lang.Apply(tmp8, []any{"WARNING: (slurp f enc) is deprecated, use (slurp f :encoding enc)."}) + _ = tmp9 + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := lang.NewVector(kw_encoding, tmp11) + tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6979), kw_column, int(7), kw_end_DASH_line, int(6979), kw_end_DASH_column, int(30)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp3 = tmp14 + } else { + tmp3 = v2 + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_normalize_DASH_slurp_DASH_opts = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_normalize_DASH_slurp_DASH_opts.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // pr + { + tmp0 := sym_pr.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_x), lang.NewVector(sym_x, sym__AMP_, sym_more)), kw_doc, "Prints the object(s) to the output stream that is the current value\n of *out*. Prints the object(s), separated by spaces if there is\n more than one. By default, pr and prn print in a way that objects\n can be read by the reader", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(7), kw_line, int(3678), kw_end_DASH_line, int(3678), kw_dynamic, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return nil + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) + tmp4 := checkDerefVar(var_glojure_DOT_core__STAR_out_STAR_) + tmp5 := lang.Apply(tmp3, []any{v2, tmp4}) + return tmp5 + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + recur_loop_2211: + tmp4 := checkDerefVar(var_glojure_DOT_core_pr) + tmp5 := lang.Apply(tmp4, []any{v2}) + _ = tmp5 + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_out_STAR_) + tmp7 := lang.Apply(lang.AppendWriter, []any{tmp6, lang.NewChar(32)}) + _ = tmp7 + var tmp8 any + { // let + // let binding "temp__0__auto__" + tmp9 := checkDerefVar(var_glojure_DOT_core_next) + tmp10 := lang.Apply(tmp9, []any{v3}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + var tmp13 any + { // let + // let binding "nmore" + var v14 any = v11 + _ = v14 + tmp16 := checkDerefVar(var_glojure_DOT_core_first) + tmp17 := lang.Apply(tmp16, []any{v3}) + var tmp15 any = tmp17 + var tmp18 any = v14 + v2 = tmp15 + v3 = tmp18 + goto recur_loop_2211 + } // end let + tmp12 = tmp13 + } else { + tmp14 := checkDerefVar(var_glojure_DOT_core_apply) + tmp15 := checkDerefVar(var_glojure_DOT_core_pr) + tmp16 := lang.Apply(tmp14, []any{tmp15, v3}) + tmp12 = tmp16 + } + tmp8 = tmp12 + } // end let + return tmp8 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_pr = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_pr.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // pr-str + { + tmp1 := reflect.TypeOf("") + tmp0 := sym_pr_DASH_str.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_xs)), kw_doc, "pr to a string, returning it", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(4758), kw_end_DASH_line, int(4758))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v3 any = lang.NewList(args[0:]...) + _ = v3 + var tmp4 any + { // let + // let binding "s__0__auto__" + var v5 any = "unimplemented: new with non-constant class type" + _ = v5 + var tmp6 any + { // let + tmp7 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp8 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp9 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) + tmp10 := lang.Apply(tmp8, []any{tmp9, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp10}) + _ = tmp11 + var tmp12 any + func() { + defer func() { + tmp13 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp14 := lang.Apply(tmp13, nil) + _ = tmp14 + }() + tmp15 := checkDerefVar(var_glojure_DOT_core_apply) + tmp16 := checkDerefVar(var_glojure_DOT_core_pr) + tmp17 := lang.Apply(tmp15, []any{tmp16, v3}) + _ = tmp17 + tmp18 := checkDerefVar(var_glojure_DOT_core_str) + tmp19 := lang.Apply(tmp18, []any{v5}) + tmp12 = tmp19 + }() + tmp6 = tmp12 + } // end let + tmp4 = tmp6 + } // end let + return tmp4 + } + }) + tmp3 := reflect.TypeOf("") + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_pr_DASH_str = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_pr_DASH_str.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print + { + tmp0 := sym_print.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_more)), kw_doc, "Prints the object(s) to the output stream that is the current value\n of *out*. print and println produce output for human consumption.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3725), kw_end_DASH_line, int(3725))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + var tmp3 any + { // let + tmp4 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp5 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp6 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_print_DASH_readably_STAR_) + tmp7 := lang.Apply(tmp5, []any{tmp6, nil}) + tmp8 := lang.Apply(tmp4, []any{tmp7}) + _ = tmp8 + var tmp9 any + func() { + defer func() { + tmp10 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp11 := lang.Apply(tmp10, nil) + _ = tmp11 + }() + tmp12 := checkDerefVar(var_glojure_DOT_core_apply) + tmp13 := checkDerefVar(var_glojure_DOT_core_pr) + tmp14 := lang.Apply(tmp12, []any{tmp13, v2}) + tmp9 = tmp14 + }() + tmp3 = tmp9 + } // end let + return tmp3 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_print = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_print.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print-str + { + tmp1 := reflect.TypeOf("") + tmp0 := sym_print_DASH_str.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_xs)), kw_doc, "print to a string, returning it", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(4776), kw_end_DASH_line, int(4776))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v3 any = lang.NewList(args[0:]...) + _ = v3 + var tmp4 any + { // let + // let binding "s__0__auto__" + var v5 any = "unimplemented: new with non-constant class type" + _ = v5 + var tmp6 any + { // let + tmp7 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp8 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp9 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) + tmp10 := lang.Apply(tmp8, []any{tmp9, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp10}) + _ = tmp11 + var tmp12 any + func() { + defer func() { + tmp13 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp14 := lang.Apply(tmp13, nil) + _ = tmp14 + }() + tmp15 := checkDerefVar(var_glojure_DOT_core_apply) + tmp16 := checkDerefVar(var_glojure_DOT_core_print) + tmp17 := lang.Apply(tmp15, []any{tmp16, v3}) + _ = tmp17 + tmp18 := checkDerefVar(var_glojure_DOT_core_str) + tmp19 := lang.Apply(tmp18, []any{v5}) + tmp12 = tmp19 + }() + tmp6 = tmp12 + } // end let + tmp4 = tmp6 + } // end let + return tmp4 + } + }) + tmp3 := reflect.TypeOf("") + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_print_DASH_str = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_print_DASH_str.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // printf + { + tmp0 := sym_printf.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_fmt, sym__AMP_, sym_args)), kw_doc, "Prints formatted output, as per format", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(5725), kw_end_DASH_line, int(5725))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_print) + tmp5 := checkDerefVar(var_glojure_DOT_core_apply) + tmp6 := checkDerefVar(var_glojure_DOT_core_format) + tmp7 := lang.Apply(tmp5, []any{tmp6, v2, v3}) + tmp8 := lang.Apply(tmp4, []any{tmp7}) + return tmp8 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_printf = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_printf.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // prn + { + tmp0 := sym_prn.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_more)), kw_doc, "Same as pr followed by (newline). Observes *flush-on-newline*", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(3715), kw_end_DASH_line, int(3715))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_apply) + tmp4 := checkDerefVar(var_glojure_DOT_core_pr) + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + _ = tmp5 + tmp6 := checkDerefVar(var_glojure_DOT_core_newline) + tmp7 := lang.Apply(tmp6, nil) + _ = tmp7 + var tmp8 any + tmp9 := checkDerefVar(var_glojure_DOT_core__STAR_flush_DASH_on_DASH_newline_STAR_) + if lang.IsTruthy(tmp9) { + tmp10 := checkDerefVar(var_glojure_DOT_core_flush) + tmp11 := lang.Apply(tmp10, nil) + tmp8 = tmp11 + } else { + } + return tmp8 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_prn = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_prn.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // prn-str + { + tmp1 := reflect.TypeOf("") + tmp0 := sym_prn_DASH_str.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_xs)), kw_doc, "prn to a string, returning it", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4767), kw_end_DASH_line, int(4767))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v3 any = lang.NewList(args[0:]...) + _ = v3 + var tmp4 any + { // let + // let binding "s__0__auto__" + var v5 any = "unimplemented: new with non-constant class type" + _ = v5 + var tmp6 any + { // let + tmp7 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp8 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp9 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) + tmp10 := lang.Apply(tmp8, []any{tmp9, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp10}) + _ = tmp11 + var tmp12 any + func() { + defer func() { + tmp13 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp14 := lang.Apply(tmp13, nil) + _ = tmp14 + }() + tmp15 := checkDerefVar(var_glojure_DOT_core_apply) + tmp16 := checkDerefVar(var_glojure_DOT_core_prn) + tmp17 := lang.Apply(tmp15, []any{tmp16, v3}) + _ = tmp17 + tmp18 := checkDerefVar(var_glojure_DOT_core_str) + tmp19 := lang.Apply(tmp18, []any{v5}) + tmp12 = tmp19 + }() + tmp6 = tmp12 + } // end let + tmp4 = tmp6 + } // end let + return tmp4 + } + }) + tmp3 := reflect.TypeOf("") + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_prn_DASH_str = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_prn_DASH_str.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // println + { + tmp0 := sym_println.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_more)), kw_doc, "Same as print followed by (newline)", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(3734), kw_end_DASH_line, int(3734))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + var tmp3 any + { // let + tmp4 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp5 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp6 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_print_DASH_readably_STAR_) + tmp7 := lang.Apply(tmp5, []any{tmp6, nil}) + tmp8 := lang.Apply(tmp4, []any{tmp7}) + _ = tmp8 + var tmp9 any + func() { + defer func() { + tmp10 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp11 := lang.Apply(tmp10, nil) + _ = tmp11 + }() + tmp12 := checkDerefVar(var_glojure_DOT_core_apply) + tmp13 := checkDerefVar(var_glojure_DOT_core_prn) + tmp14 := lang.Apply(tmp12, []any{tmp13, v2}) + tmp9 = tmp14 + }() + tmp3 = tmp9 + } // end let + return tmp3 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_println = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_println.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // println-str + { + tmp1 := reflect.TypeOf("") + tmp0 := sym_println_DASH_str.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_xs)), kw_doc, "println to a string, returning it", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(4785), kw_end_DASH_line, int(4785))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v3 any = lang.NewList(args[0:]...) + _ = v3 + var tmp4 any + { // let + // let binding "s__0__auto__" + var v5 any = "unimplemented: new with non-constant class type" + _ = v5 + var tmp6 any + { // let + tmp7 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp8 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp9 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) + tmp10 := lang.Apply(tmp8, []any{tmp9, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp10}) + _ = tmp11 + var tmp12 any + func() { + defer func() { + tmp13 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp14 := lang.Apply(tmp13, nil) + _ = tmp14 + }() + tmp15 := checkDerefVar(var_glojure_DOT_core_apply) + tmp16 := checkDerefVar(var_glojure_DOT_core_println) + tmp17 := lang.Apply(tmp15, []any{tmp16, v3}) + _ = tmp17 + tmp18 := checkDerefVar(var_glojure_DOT_core_str) + tmp19 := lang.Apply(tmp18, []any{v5}) + tmp12 = tmp19 + }() + tmp6 = tmp12 + } // end let + tmp4 = tmp6 + } // end let + return tmp4 + } + }) + tmp3 := reflect.TypeOf("") + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_println_DASH_str = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_println_DASH_str.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // pr-on + { + tmp0 := sym_pr_DASH_on.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_w)), kw_static, true, kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3669), kw_end_DASH_line, int(3669), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_dup_STAR_) + if lang.IsTruthy(tmp5) { + tmp6 := checkDerefVar(var_glojure_DOT_core_print_DASH_dup) + tmp7 := lang.Apply(tmp6, []any{v2, v3}) + tmp4 = tmp7 + } else { + tmp8 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp9 := lang.Apply(tmp8, []any{v2, v3}) + tmp4 = tmp9 + } + _ = tmp4 + return nil + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_pr_DASH_on = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_pr_DASH_on.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print-meta + { + tmp0 := sym_print_DASH_meta.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(70), kw_column, int(8), kw_end_DASH_line, int(70), kw_end_DASH_column, int(17), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_o, sym_w)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "temp__0__auto__" + tmp5 := checkDerefVar(var_glojure_DOT_core_meta) + tmp6 := lang.Apply(tmp5, []any{v2}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + if lang.IsTruthy(v7) { + var tmp9 any + { // let + // let binding "m" + var v10 any = v7 + _ = v10 + var tmp11 any + var tmp12 any + { // let + // let binding "and__0__auto__" + tmp13 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp14 := checkDerefVar(var_glojure_DOT_core_count) + tmp15 := lang.Apply(tmp14, []any{v10}) + tmp16 := lang.Apply(tmp13, []any{tmp15}) + var v17 any = tmp16 + _ = v17 + var tmp18 any + if lang.IsTruthy(v17) { + var tmp19 any + { // let + // let binding "or__0__auto__" + tmp20 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_dup_STAR_) + var v21 any = tmp20 + _ = v21 + var tmp22 any + if lang.IsTruthy(v21) { + tmp22 = v21 + } else { + var tmp23 any + { // let + // let binding "and__0__auto__" + tmp24 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_meta_STAR_) + var v25 any = tmp24 + _ = v25 + var tmp26 any + if lang.IsTruthy(v25) { + tmp27 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_readably_STAR_) + tmp26 = tmp27 + } else { + tmp26 = v25 + } + tmp23 = tmp26 + } // end let + tmp22 = tmp23 + } + tmp19 = tmp22 + } // end let + tmp18 = tmp19 + } else { + tmp18 = v17 + } + tmp12 = tmp18 + } // end let + if lang.IsTruthy(tmp12) { + tmp13 := lang.Apply(lang.WriteWriter, []any{v3, "^"}) + _ = tmp13 + var tmp14 any + var tmp15 any + { // let + // let binding "and__0__auto__" + tmp16 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp17 := checkDerefVar(var_glojure_DOT_core_count) + tmp18 := lang.Apply(tmp17, []any{v10}) + tmp19 := lang.Apply(tmp16, []any{tmp18, int64(1)}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + tmp22 := lang.Apply(kw_tag, []any{v10}) + tmp21 = tmp22 + } else { + tmp21 = v20 + } + tmp15 = tmp21 + } // end let + if lang.IsTruthy(tmp15) { + tmp16 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) + tmp17 := lang.Apply(kw_tag, []any{v10}) + tmp18 := lang.Apply(tmp16, []any{tmp17, v3}) + tmp14 = tmp18 + } else { + tmp19 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) + tmp20 := lang.Apply(tmp19, []any{v10, v3}) + tmp14 = tmp20 + } + _ = tmp14 + tmp21 := lang.Apply(lang.WriteWriter, []any{v3, " "}) + tmp11 = tmp21 + } else { + } + tmp9 = tmp11 + } // end let + tmp8 = tmp9 + } else { + } + tmp4 = tmp8 + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_print_DASH_meta = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_print_DASH_meta.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print-simple + { + tmp0 := sym_print_DASH_simple.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(81), kw_column, int(7), kw_end_DASH_line, int(81), kw_end_DASH_column, int(18), kw_arglists, lang.NewList(lang.NewVector(sym_o, sym_w)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + _ = tmp5 + tmp6 := checkDerefVar(var_glojure_DOT_core_str) + tmp7 := lang.Apply(tmp6, []any{v2}) + tmp8 := lang.Apply(lang.WriteWriter, []any{v3, tmp7}) + return tmp8 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_print_DASH_simple = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_print_DASH_simple.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print-dup + { + tmp0 := sym_print_DASH_dup.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3667), kw_column, int(11), kw_end_DASH_line, int(3667), kw_end_DASH_column, int(19), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_class) + tmp6 := lang.Apply(tmp5, []any{v3}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3667), kw_column, int(21), kw_end_DASH_line, int(3667), kw_end_DASH_column, int(45))).(lang.FnFunc) + tmp1 := lang.NewMultiFn("print-dup", tmp2, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + }) + tmp1.AddMethod(nil, tmp3) + tmp4 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp9 := lang.Apply(tmp8, []any{v6, v7}) + return tmp9 + }) + tmp1.AddMethod(tmp4, tmp5) + tmp6 := reflect.TypeOf((*lang.IPersistentList)(nil)).Elem() + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp11 := lang.Apply(tmp10, []any{v8, v9}) + return tmp11 + }) + tmp1.AddMethod(tmp6, tmp7) + tmp8 := reflect.TypeOf((*lang.Symbol)(nil)) + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp13 := lang.Apply(tmp12, []any{v10, v11}) + return tmp13 + }) + tmp1.AddMethod(tmp8, tmp9) + tmp10 := reflect.TypeOf((*lang.IRecord)(nil)).Elem() + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v12 := args[0] + _ = v12 + v13 := args[1] + _ = v13 + tmp14 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) + tmp15 := lang.Apply(tmp14, []any{v12, v13}) + _ = tmp15 + tmp16 := lang.Apply(lang.WriteWriter, []any{v13, "#"}) + _ = tmp16 + tmp17 := checkDerefVar(var_glojure_DOT_core_class) + tmp18 := lang.Apply(tmp17, []any{v12}) + tmp19, ok := lang.FieldOrMethod(tmp18, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp18, "Name"))) + } + var tmp20 any + switch reflect.TypeOf(tmp19).Kind() { + case reflect.Func: + tmp20 = lang.Apply(tmp19, nil) + default: + tmp20 = tmp19 + } + tmp21 := lang.Apply(lang.WriteWriter, []any{v13, tmp20}) + _ = tmp21 + var tmp22 any + tmp23 := checkDerefVar(var_glojure_DOT_core__STAR_verbose_DASH_defrecords_STAR_) + if lang.IsTruthy(tmp23) { + tmp24 := checkDerefVar(var_glojure_DOT_core_print_DASH_map) + tmp25 := checkDerefVar(var_glojure_DOT_core_print_DASH_dup) + tmp26 := lang.Apply(tmp24, []any{v12, tmp25, v13}) + tmp22 = tmp26 + } else { + tmp27 := checkDerefVar(var_glojure_DOT_core_print_DASH_sequential) + tmp28 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) + tmp29 := checkDerefVar(var_glojure_DOT_core_vals) + tmp30 := lang.Apply(tmp29, []any{v12}) + tmp31 := lang.Apply(tmp27, []any{"[", tmp28, ", ", "]", tmp30, v13}) + tmp22 = tmp31 + } + return tmp22 + }) + tmp1.AddMethod(tmp10, tmp11) + tmp12 := reflect.TypeOf((*lang.Set)(nil)) + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v14 := args[0] + _ = v14 + v15 := args[1] + _ = v15 + tmp16 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp17 := lang.Apply(tmp16, []any{v14, v15}) + return tmp17 + }) + tmp1.AddMethod(tmp12, tmp13) + tmp14 := reflect.TypeOf((*lang.PersistentHashMap)(nil)) + var tmp15 lang.FnFunc + tmp15 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v16 := args[0] + _ = v16 + v17 := args[1] + _ = v17 + tmp18 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp19 := lang.Apply(tmp18, []any{v16, v17}) + return tmp19 + }) + tmp1.AddMethod(tmp14, tmp15) + tmp16 := reflect.TypeOf(int64(0)) + var tmp17 lang.FnFunc + tmp17 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v18 := args[0] + _ = v18 + v19 := args[1] + _ = v19 + tmp20 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp21 := lang.Apply(tmp20, []any{v18, v19}) + return tmp21 + }) + tmp1.AddMethod(tmp16, tmp17) + tmp18 := reflect.TypeOf((*lang.Vector)(nil)) + var tmp19 lang.FnFunc + tmp19 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v20 := args[0] + _ = v20 + v21 := args[1] + _ = v21 + tmp22 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp23 := lang.Apply(tmp22, []any{v20, v21}) + return tmp23 + }) + tmp1.AddMethod(tmp18, tmp19) + tmp20 := reflect.TypeOf(float64(0)) + var tmp21 lang.FnFunc + tmp21 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v22 := args[0] + _ = v22 + v23 := args[1] + _ = v23 + tmp24 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp25 := lang.Apply(tmp24, []any{v22, v23}) + return tmp25 + }) + tmp1.AddMethod(tmp20, tmp21) + tmp22 := reflect.TypeOf("") + var tmp23 lang.FnFunc + tmp23 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v24 := args[0] + _ = v24 + v25 := args[1] + _ = v25 + tmp26 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp27 := lang.Apply(tmp26, []any{v24, v25}) + return tmp27 + }) + tmp1.AddMethod(tmp22, tmp23) + tmp24 := reflect.TypeOf((*lang.IPersistentCollection)(nil)).Elem() + var tmp25 lang.FnFunc + tmp25 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v26 := args[0] + _ = v26 + v27 := args[1] + _ = v27 + tmp28 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) + tmp29 := lang.Apply(tmp28, []any{v26, v27}) + _ = tmp29 + tmp30 := lang.Apply(lang.WriteWriter, []any{v27, "#=("}) + _ = tmp30 + tmp31 := checkDerefVar(var_glojure_DOT_core_class) + tmp32 := lang.Apply(tmp31, []any{v26}) + tmp33, ok := lang.FieldOrMethod(tmp32, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp32, "Name"))) + } + var tmp34 any + switch reflect.TypeOf(tmp33).Kind() { + case reflect.Func: + tmp34 = lang.Apply(tmp33, nil) + default: + tmp34 = tmp33 + } + tmp35 := lang.Apply(lang.WriteWriter, []any{v27, tmp34}) + _ = tmp35 + tmp36 := lang.Apply(lang.WriteWriter, []any{v27, "/create "}) + _ = tmp36 + tmp37 := checkDerefVar(var_glojure_DOT_core_print_DASH_sequential) + tmp38 := checkDerefVar(var_glojure_DOT_core_print_DASH_dup) + tmp39 := lang.Apply(tmp37, []any{"[", tmp38, " ", "]", v26, v27}) + _ = tmp39 + tmp40 := lang.Apply(lang.WriteWriter, []any{v27, ")"}) + return tmp40 + }) + tmp1.AddMethod(tmp24, tmp25) + tmp26 := reflect.TypeOf(int32(0)) + var tmp27 lang.FnFunc + tmp27 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v28 := args[0] + _ = v28 + v29 := args[1] + _ = v29 + tmp30 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp31 := lang.Apply(tmp30, []any{v28, v29}) + return tmp31 + }) + tmp1.AddMethod(tmp26, tmp27) + tmp28 := reflect.TypeOf((*lang.IPersistentMap)(nil)).Elem() + var tmp29 lang.FnFunc + tmp29 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v30 := args[0] + _ = v30 + v31 := args[1] + _ = v31 + tmp32 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) + tmp33 := lang.Apply(tmp32, []any{v30, v31}) + _ = tmp33 + tmp34 := lang.Apply(lang.WriteWriter, []any{v31, "#=("}) + _ = tmp34 + tmp35 := checkDerefVar(var_glojure_DOT_core_class) + tmp36 := lang.Apply(tmp35, []any{v30}) + tmp37, ok := lang.FieldOrMethod(tmp36, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp36, "Name"))) + } + var tmp38 any + switch reflect.TypeOf(tmp37).Kind() { + case reflect.Func: + tmp38 = lang.Apply(tmp37, nil) + default: + tmp38 = tmp37 + } + tmp39 := lang.Apply(lang.WriteWriter, []any{v31, tmp38}) + _ = tmp39 + tmp40 := lang.Apply(lang.WriteWriter, []any{v31, "/create "}) + _ = tmp40 + tmp41 := checkDerefVar(var_glojure_DOT_core_print_DASH_map) + tmp42 := checkDerefVar(var_glojure_DOT_core_print_DASH_dup) + tmp43 := lang.Apply(tmp41, []any{v30, tmp42, v31}) + _ = tmp43 + tmp44 := lang.Apply(lang.WriteWriter, []any{v31, ")"}) + return tmp44 + }) + tmp1.AddMethod(tmp28, tmp29) + tmp30 := reflect.TypeOf((*lang.Namespace)(nil)) + var tmp31 lang.FnFunc + tmp31 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v32 := args[0] + _ = v32 + v33 := args[1] + _ = v33 + tmp34 := lang.Apply(lang.WriteWriter, []any{v33, "#=(find-ns "}) + _ = tmp34 + tmp35 := checkDerefVar(var_glojure_DOT_core_print_DASH_dup) + tmp36, ok := lang.FieldOrMethod(v32, "name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v32, "name"))) + } + var tmp37 any + switch reflect.TypeOf(tmp36).Kind() { + case reflect.Func: + tmp37 = lang.Apply(tmp36, nil) + default: + tmp37 = tmp36 + } + tmp38 := lang.Apply(tmp35, []any{tmp37, v33}) + _ = tmp38 + tmp39 := lang.Apply(lang.WriteWriter, []any{v33, ")"}) + return tmp39 + }) + tmp1.AddMethod(tmp30, tmp31) + tmp32 := reflect.TypeOf(false) + var tmp33 lang.FnFunc + tmp33 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v34 := args[0] + _ = v34 + v35 := args[1] + _ = v35 + tmp36 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp37 := lang.Apply(tmp36, []any{v34, v35}) + return tmp37 + }) + tmp1.AddMethod(tmp32, tmp33) + tmp34 := reflect.TypeOf((*regexp12.Regexp)(nil)) + var tmp35 lang.FnFunc + tmp35 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v36 := args[0] + _ = v36 + v37 := args[1] + _ = v37 + tmp38 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp39 := lang.Apply(tmp38, []any{v36, v37}) + return tmp39 + }) + tmp1.AddMethod(tmp34, tmp35) + tmp36 := reflect.TypeOf((*lang.Ratio)(nil)) + var tmp37 lang.FnFunc + tmp37 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v38 := args[0] + _ = v38 + v39 := args[1] + _ = v39 + tmp40 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp41 := lang.Apply(tmp40, []any{v38, v39}) + return tmp41 + }) + tmp1.AddMethod(tmp36, tmp37) + tmp38 := reflect.TypeOf((*lang.Var)(nil)) + var tmp39 lang.FnFunc + tmp39 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v40 := args[0] + _ = v40 + v41 := args[1] + _ = v41 + tmp42 := checkDerefVar(var_glojure_DOT_core_str) + tmp43, ok := lang.FieldOrMethod(v40, "Namespace") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v40, "Namespace"))) + } + var tmp44 any + switch reflect.TypeOf(tmp43).Kind() { + case reflect.Func: + tmp44 = lang.Apply(tmp43, nil) + default: + tmp44 = tmp43 + } + tmp45, ok := lang.FieldOrMethod(tmp44, "name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp44, "name"))) + } + var tmp46 any + switch reflect.TypeOf(tmp45).Kind() { + case reflect.Func: + tmp46 = lang.Apply(tmp45, nil) + default: + tmp46 = tmp45 + } + tmp47, ok := lang.FieldOrMethod(v40, "sym") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v40, "sym"))) + } + var tmp48 any + switch reflect.TypeOf(tmp47).Kind() { + case reflect.Func: + tmp48 = lang.Apply(tmp47, nil) + default: + tmp48 = tmp47 + } + tmp49 := lang.Apply(tmp42, []any{"#=(var ", tmp46, "/", tmp48, ")"}) + tmp50 := lang.Apply(lang.WriteWriter, []any{v41, tmp49}) + return tmp50 + }) + tmp1.AddMethod(tmp38, tmp39) + tmp40 := reflect.TypeOf((*lang.BigDecimal)(nil)) + var tmp41 lang.FnFunc + tmp41 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v42 := args[0] + _ = v42 + v43 := args[1] + _ = v43 + tmp44 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp45 := lang.Apply(tmp44, []any{v42, v43}) + return tmp45 + }) + tmp1.AddMethod(tmp40, tmp41) + tmp42 := reflect.TypeOf((*lang.BigInt)(nil)) + var tmp43 lang.FnFunc + tmp43 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v44 := args[0] + _ = v44 + v45 := args[1] + _ = v45 + tmp46 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp47 := lang.Apply(tmp46, []any{v44, v45}) + return tmp47 + }) + tmp1.AddMethod(tmp42, tmp43) + tmp44 := reflect.TypeOf((*runtime.Fn)(nil)) + var tmp45 lang.FnFunc + tmp45 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v46 := args[0] + _ = v46 + v47 := args[1] + _ = v47 + tmp48 := checkDerefVar(var_glojure_DOT_core_print_DASH_ctor) + var tmp49 lang.FnFunc + tmp49 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v50 := args[0] + _ = v50 + v51 := args[1] + _ = v51 + return nil + }) + tmp50 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(167), kw_column, int(17), kw_end_DASH_line, int(167), kw_end_DASH_column, int(26)) + tmp51, err := lang.WithMeta(tmp49, tmp50.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp52 := lang.Apply(tmp48, []any{v46, tmp51, v47}) + return tmp52 + }) + tmp1.AddMethod(tmp44, tmp45) + tmp46 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() + var tmp47 lang.FnFunc + tmp47 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v48 := args[0] + _ = v48 + v49 := args[1] + _ = v49 + tmp50 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp51 := lang.Apply(tmp50, []any{v48, v49}) + return tmp51 + }) + tmp1.AddMethod(tmp46, tmp47) + tmp48 := reflect.TypeOf((*lang.IPersistentCollection)(nil)).Elem() + tmp49 := reflect.TypeOf((*runtime.Fn)(nil)) + tmp1.PreferMethod(tmp48, tmp49) + tmp50 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() + tmp51 := reflect.TypeOf((*lang.IPersistentCollection)(nil)).Elem() + tmp1.PreferMethod(tmp50, tmp51) + tmp52 := reflect.TypeOf((*lang.IRecord)(nil)).Elem() + tmp53 := reflect.TypeOf((*lang.IPersistentMap)(nil)).Elem() + tmp1.PreferMethod(tmp52, tmp53) + tmp54 := reflect.TypeOf((*lang.IRecord)(nil)).Elem() + tmp55 := reflect.TypeOf((*lang.IPersistentCollection)(nil)).Elem() + tmp1.PreferMethod(tmp54, tmp55) + var_glojure_DOT_core_print_DASH_dup = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_print_DASH_dup.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print-method + { + tmp0 := sym_print_DASH_method.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3664), kw_column, int(11), kw_end_DASH_line, int(3664), kw_end_DASH_column, int(22), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 any + { // let + // let binding "t" + tmp6 := checkDerefVar(var_glojure_DOT_core_get) + tmp7 := checkDerefVar(var_glojure_DOT_core_meta) + tmp8 := lang.Apply(tmp7, []any{v3}) + tmp9 := lang.Apply(tmp6, []any{tmp8, kw_type}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp13 := lang.Apply(tmp12, []any{v10}) + if lang.IsTruthy(tmp13) { + tmp11 = v10 + } else { + tmp14 := checkDerefVar(var_glojure_DOT_core_class) + tmp15 := lang.Apply(tmp14, []any{v3}) + tmp11 = tmp15 + } + tmp5 = tmp11 + } // end let + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3664), kw_column, int(24), kw_end_DASH_line, int(3666), kw_end_DASH_column, int(58))).(lang.FnFunc) + tmp1 := lang.NewMultiFn("print-method", tmp2, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6 := lang.Apply(lang.WriteWriter, []any{v5, "nil"}) + return tmp6 + }) + tmp1.AddMethod(nil, tmp3) + tmp4 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_str) + tmp9 := lang.Apply(tmp8, []any{v6}) + tmp10 := lang.Apply(lang.WriteWriter, []any{v7, tmp9}) + return tmp10 + }) + tmp1.AddMethod(tmp4, tmp5) + tmp6 := reflect.TypeOf(uint32(0)) + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_str) + tmp11 := lang.Apply(tmp10, []any{v8}) + tmp12, _ := lang.FieldOrMethod(v9, "write") + if reflect.TypeOf(tmp12).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + } + tmp13 := lang.Apply(tmp12, []any{tmp11}) + return tmp13 + }) + tmp1.AddMethod(tmp6, tmp7) + tmp8 := reflect.TypeOf((*lang.Symbol)(nil)) + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_print_DASH_simple) + tmp13 := lang.Apply(tmp12, []any{v10, v11}) + return tmp13 + }) + tmp1.AddMethod(tmp8, tmp9) + tmp10 := reflect.TypeOf((*lang.IRecord)(nil)).Elem() + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v12 := args[0] + _ = v12 + v13 := args[1] + _ = v13 + tmp14 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) + tmp15 := lang.Apply(tmp14, []any{v12, v13}) + _ = tmp15 + tmp16 := lang.Apply(lang.WriteWriter, []any{v13, "#"}) + _ = tmp16 + tmp17 := checkDerefVar(var_glojure_DOT_core_class) + tmp18 := lang.Apply(tmp17, []any{v12}) + tmp19, ok := lang.FieldOrMethod(tmp18, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp18, "Name"))) + } + var tmp20 any + switch reflect.TypeOf(tmp19).Kind() { + case reflect.Func: + tmp20 = lang.Apply(tmp19, nil) + default: + tmp20 = tmp19 + } + tmp21 := lang.Apply(lang.WriteWriter, []any{v13, tmp20}) + _ = tmp21 + tmp22 := checkDerefVar(var_glojure_DOT_core_print_DASH_map) + tmp23 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) + tmp24 := lang.Apply(tmp22, []any{v12, tmp23, v13}) + return tmp24 + }) + tmp1.AddMethod(tmp10, tmp11) + tmp12 := reflect.TypeOf(uint(0)) + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v14 := args[0] + _ = v14 + v15 := args[1] + _ = v15 + tmp16 := checkDerefVar(var_glojure_DOT_core_str) + tmp17 := lang.Apply(tmp16, []any{v14}) + tmp18, _ := lang.FieldOrMethod(v15, "write") + if reflect.TypeOf(tmp18).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + } + tmp19 := lang.Apply(tmp18, []any{tmp17}) + return tmp19 + }) + tmp1.AddMethod(tmp12, tmp13) + tmp14 := reflect.TypeOf(int64(0)) + var tmp15 lang.FnFunc + tmp15 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v16 := args[0] + _ = v16 + v17 := args[1] + _ = v17 + tmp18 := checkDerefVar(var_glojure_DOT_core_str) + tmp19 := lang.Apply(tmp18, []any{v16}) + tmp20, _ := lang.FieldOrMethod(v17, "write") + if reflect.TypeOf(tmp20).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + } + tmp21 := lang.Apply(tmp20, []any{tmp19}) + return tmp21 + }) + tmp1.AddMethod(tmp14, tmp15) + var tmp16 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v17 := args[0] + _ = v17 + v18 := args[1] + _ = v18 + var tmp19 any + tmp20 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp21 := reflect.TypeOf((*lang.IObj)(nil)).Elem() + tmp22 := lang.Apply(tmp20, []any{tmp21, v17}) + if lang.IsTruthy(tmp22) { + tmp23 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp24 := checkDerefVar(var_glojure_DOT_core_vary_DASH_meta) + var tmp25 lang.FnFunc + tmp25 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v26 := args[0] + _ = v26 + tmp27 := checkDerefVar(var_glojure_DOT_core_dissoc) + tmp28 := lang.Apply(tmp27, []any{v26, kw_type}) + return tmp28 + }) + tmp26 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(87), kw_column, int(32), kw_end_DASH_line, int(87), kw_end_DASH_column, int(48)) + tmp27, err := lang.WithMeta(tmp25, tmp26.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp28 := lang.Apply(tmp24, []any{v17, tmp27}) + tmp29 := lang.Apply(tmp23, []any{tmp28, v18}) + tmp19 = tmp29 + } else { + tmp30 := checkDerefVar(var_glojure_DOT_core_print_DASH_simple) + tmp31 := lang.Apply(tmp30, []any{v17, v18}) + tmp19 = tmp31 + } + return tmp19 + }) + tmp1.AddMethod(kw_default, tmp16) + tmp17 := reflect.TypeOf(float64(0)) + var tmp18 lang.FnFunc + tmp18 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v19 := args[0] + _ = v19 + v20 := args[1] + _ = v20 + var tmp21 any + tmp22 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp23 := lang.Apply(math4.Inf, []any{int64(1)}) + tmp24 := lang.Apply(tmp22, []any{tmp23, v19}) + if lang.IsTruthy(tmp24) { + tmp25 := lang.Apply(lang.WriteWriter, []any{v20, "##Inf"}) + tmp21 = tmp25 + } else { + var tmp26 any + tmp27 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp28 := lang.Apply(math4.Inf, []any{int64(-1)}) + tmp29 := lang.Apply(tmp27, []any{tmp28, v19}) + if lang.IsTruthy(tmp29) { + tmp30 := lang.Apply(lang.WriteWriter, []any{v20, "##-Inf"}) + tmp26 = tmp30 + } else { + var tmp31 any + tmp32 := lang.Apply(math4.IsNaN, []any{v19}) + if lang.IsTruthy(tmp32) { + tmp33 := lang.Apply(lang.WriteWriter, []any{v20, "##NaN"}) + tmp31 = tmp33 + } else { + var tmp34 any + if lang.IsTruthy(kw_else) { + tmp35 := checkDerefVar(var_glojure_DOT_core_str) + tmp36 := lang.Apply(tmp35, []any{v19}) + tmp37 := lang.Apply(lang.WriteWriter, []any{v20, tmp36}) + tmp34 = tmp37 + } else { + } + tmp31 = tmp34 + } + tmp26 = tmp31 + } + tmp21 = tmp26 + } + return tmp21 + }) + tmp1.AddMethod(tmp17, tmp18) + tmp19 := reflect.TypeOf("") + var tmp20 lang.FnFunc + tmp20 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v21 := args[0] + _ = v21 + v22 := args[1] + _ = v22 + var tmp23 any + var tmp24 any + { // let + // let binding "or__0__auto__" + tmp25 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_dup_STAR_) + var v26 any = tmp25 + _ = v26 + var tmp27 any + if lang.IsTruthy(v26) { + tmp27 = v26 + } else { + tmp28 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_readably_STAR_) + tmp27 = tmp28 + } + tmp24 = tmp27 + } // end let + if lang.IsTruthy(tmp24) { + tmp25 := lang.Apply(lang.AppendWriter, []any{v22, lang.NewChar(34)}) + _ = tmp25 + var tmp26 any + { // let + // let binding "n__0__auto__" + tmp27 := checkDerefVar(var_glojure_DOT_core_long) + tmp28 := checkDerefVar(var_glojure_DOT_core_count) + tmp29 := lang.Apply(tmp28, []any{v21}) + tmp30 := lang.Apply(tmp27, []any{tmp29}) + var v31 any = tmp30 + _ = v31 + var tmp32 any + { // let + // let binding "n" + var v33 any = int64(0) + _ = v33 + for { + var tmp34 any + tmp35 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp36 := lang.Apply(tmp35, []any{v33, v31}) + if lang.IsTruthy(tmp36) { + var tmp37 any + { // let + // let binding "c" + tmp38 := lang.Apply(lang.CharAt, []any{v21, v33}) + var v39 any = tmp38 + _ = v39 + // let binding "e" + tmp40 := checkDerefVar(var_glojure_DOT_core_char_DASH_escape_DASH_string) + tmp41 := lang.Apply(tmp40, []any{v39}) + var v42 any = tmp41 + _ = v42 + var tmp43 any + if lang.IsTruthy(v42) { + tmp44 := lang.Apply(lang.WriteWriter, []any{v22, v42}) + tmp43 = tmp44 + } else { + tmp45 := lang.Apply(lang.AppendWriter, []any{v22, v39}) + tmp43 = tmp45 + } + tmp37 = tmp43 + } // end let + _ = tmp37 + tmp39 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp40 := lang.Apply(tmp39, []any{v33}) + var tmp38 any = tmp40 + v33 = tmp38 + continue + } else { + } + tmp32 = tmp34 + break + } + } // end let + tmp26 = tmp32 + } // end let + _ = tmp26 + tmp27 := lang.Apply(lang.AppendWriter, []any{v22, lang.NewChar(34)}) + tmp23 = tmp27 + } else { + tmp28 := lang.Apply(lang.WriteWriter, []any{v22, v21}) + tmp23 = tmp28 + } + _ = tmp23 + return nil + }) + tmp1.AddMethod(tmp19, tmp20) + tmp21 := reflect.TypeOf(int32(0)) + var tmp22 lang.FnFunc + tmp22 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v23 := args[0] + _ = v23 + v24 := args[1] + _ = v24 + var tmp25 any + var tmp26 any + { // let + // let binding "or__0__auto__" + tmp27 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_dup_STAR_) + var v28 any = tmp27 + _ = v28 + var tmp29 any + if lang.IsTruthy(v28) { + tmp29 = v28 + } else { + tmp30 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_readably_STAR_) + tmp29 = tmp30 + } + tmp26 = tmp29 + } // end let + if lang.IsTruthy(tmp26) { + tmp27 := lang.Apply(lang.AppendWriter, []any{v24, lang.NewChar(92)}) + _ = tmp27 + var tmp28 any + { // let + // let binding "n" + tmp29 := checkDerefVar(var_glojure_DOT_core_char_DASH_name_DASH_string) + tmp30 := lang.Apply(tmp29, []any{v23}) + var v31 any = tmp30 + _ = v31 + var tmp32 any + if lang.IsTruthy(v31) { + tmp33 := lang.Apply(lang.WriteWriter, []any{v24, v31}) + tmp32 = tmp33 + } else { + tmp34 := lang.Apply(lang.AppendWriter, []any{v24, v23}) + tmp32 = tmp34 + } + tmp28 = tmp32 + } // end let + tmp25 = tmp28 + } else { + tmp29 := lang.Apply(lang.AppendWriter, []any{v24, v23}) + tmp25 = tmp29 + } + _ = tmp25 + return nil + }) + tmp1.AddMethod(tmp21, tmp22) + tmp23 := reflect.TypeOf((*lang.IPersistentMap)(nil)).Elem() + var tmp24 lang.FnFunc + tmp24 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v25 := args[0] + _ = v25 + v26 := args[1] + _ = v26 + tmp27 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) + tmp28 := lang.Apply(tmp27, []any{v25, v26}) + _ = tmp28 + var tmp29 any + { // let + // let binding "vec__925" + tmp30 := checkDerefVar(var_glojure_DOT_core_lift_DASH_ns) + tmp31 := lang.Apply(tmp30, []any{v25}) + var v32 any = tmp31 + _ = v32 + // let binding "ns" + tmp33 := checkDerefVar(var_glojure_DOT_core_nth) + tmp34 := lang.Apply(tmp33, []any{v32, int64(0), nil}) + var v35 any = tmp34 + _ = v35 + // let binding "lift-kvs" + tmp36 := checkDerefVar(var_glojure_DOT_core_nth) + tmp37 := lang.Apply(tmp36, []any{v32, int64(1), nil}) + var v38 any = tmp37 + _ = v38 + var tmp39 any + if lang.IsTruthy(v35) { + tmp40 := checkDerefVar(var_glojure_DOT_core_print_DASH_prefix_DASH_map) + tmp41 := checkDerefVar(var_glojure_DOT_core_str) + tmp42 := lang.Apply(tmp41, []any{"#:", v35}) + tmp43 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) + tmp44 := lang.Apply(tmp40, []any{tmp42, v38, tmp43, v26}) + tmp39 = tmp44 + } else { + tmp45 := checkDerefVar(var_glojure_DOT_core_print_DASH_map) + tmp46 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) + tmp47 := lang.Apply(tmp45, []any{v25, tmp46, v26}) + tmp39 = tmp47 + } + tmp29 = tmp39 + } // end let + return tmp29 + }) + tmp1.AddMethod(tmp23, tmp24) + tmp25 := reflect.TypeOf((*lang.IPersistentVector)(nil)).Elem() + var tmp26 lang.FnFunc + tmp26 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v27 := args[0] + _ = v27 + v28 := args[1] + _ = v28 + tmp29 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) + tmp30 := lang.Apply(tmp29, []any{v27, v28}) + _ = tmp30 + tmp31 := checkDerefVar(var_glojure_DOT_core_print_DASH_sequential) + tmp32 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) + tmp33 := lang.Apply(tmp31, []any{"[", tmp32, " ", "]", v27, v28}) + return tmp33 + }) + tmp1.AddMethod(tmp25, tmp26) + tmp27 := reflect.TypeOf((*lang.IPersistentSet)(nil)).Elem() + var tmp28 lang.FnFunc + tmp28 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v29 := args[0] + _ = v29 + v30 := args[1] + _ = v30 + tmp31 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) + tmp32 := lang.Apply(tmp31, []any{v29, v30}) + _ = tmp32 + tmp33 := checkDerefVar(var_glojure_DOT_core_print_DASH_sequential) + tmp34 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) + tmp35 := checkDerefVar(var_glojure_DOT_core_seq) + tmp36 := lang.Apply(tmp35, []any{v29}) + tmp37 := lang.Apply(tmp33, []any{"#{", tmp34, " ", "}", tmp36, v30}) + return tmp37 + }) + tmp1.AddMethod(tmp27, tmp28) + tmp29 := reflect.TypeOf(uint8(0)) + var tmp30 lang.FnFunc + tmp30 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v31 := args[0] + _ = v31 + v32 := args[1] + _ = v32 + tmp33 := checkDerefVar(var_glojure_DOT_core_str) + tmp34 := lang.Apply(tmp33, []any{v31}) + tmp35, _ := lang.FieldOrMethod(v32, "write") + if reflect.TypeOf(tmp35).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + } + tmp36 := lang.Apply(tmp35, []any{tmp34}) + return tmp36 + }) + tmp1.AddMethod(tmp29, tmp30) + tmp31 := reflect.TypeOf((*lang.IDeref)(nil)).Elem() + var tmp32 lang.FnFunc + tmp32 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v33 := args[0] + _ = v33 + v34 := args[1] + _ = v34 + tmp35 := checkDerefVar(var_glojure_DOT_core_print_DASH_tagged_DASH_object) + tmp36 := checkDerefVar(var_glojure_DOT_core_deref_DASH_as_DASH_map) + tmp37 := lang.Apply(tmp36, []any{v33}) + tmp38 := lang.Apply(tmp35, []any{v33, tmp37, v34}) + return tmp38 + }) + tmp1.AddMethod(tmp31, tmp32) + tmp33 := reflect.TypeOf(false) + var tmp34 lang.FnFunc + tmp34 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v35 := args[0] + _ = v35 + v36 := args[1] + _ = v36 + tmp37 := checkDerefVar(var_glojure_DOT_core_str) + tmp38 := lang.Apply(tmp37, []any{v35}) + tmp39 := lang.Apply(lang.WriteWriter, []any{v36, tmp38}) + return tmp39 + }) + tmp1.AddMethod(tmp33, tmp34) + tmp35 := reflect.TypeOf((*lang.Object)(nil)).Elem() + var tmp36 lang.FnFunc + tmp36 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v37 := args[0] + _ = v37 + v38 := args[1] + _ = v38 + tmp39 := checkDerefVar(var_glojure_DOT_core_print_DASH_object) + tmp40 := lang.Apply(tmp39, []any{v37, v38}) + return tmp40 + }) + tmp1.AddMethod(tmp35, tmp36) + tmp37 := reflect.TypeOf(int(0)) + var tmp38 lang.FnFunc + tmp38 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v39 := args[0] + _ = v39 + v40 := args[1] + _ = v40 + tmp41 := checkDerefVar(var_glojure_DOT_core_str) + tmp42 := lang.Apply(tmp41, []any{v39}) + tmp43, _ := lang.FieldOrMethod(v40, "write") + if reflect.TypeOf(tmp43).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + } + tmp44 := lang.Apply(tmp43, []any{tmp42}) + return tmp44 + }) + tmp1.AddMethod(tmp37, tmp38) + tmp39 := reflect.TypeOf((*regexp12.Regexp)(nil)) + var tmp40 lang.FnFunc + tmp40 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v41 := args[0] + _ = v41 + v42 := args[1] + _ = v42 + tmp43 := lang.Apply(lang.WriteWriter, []any{v42, "#\""}) + _ = tmp43 + var tmp44 any + { // let + // let binding "G__931" + tmp45 := checkDerefVar(var_glojure_DOT_core_seq) + tmp46, ok := lang.FieldOrMethod(v41, "String") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v41, "String"))) + } + var tmp47 any + switch reflect.TypeOf(tmp46).Kind() { + case reflect.Func: + tmp47 = lang.Apply(tmp46, nil) + default: + tmp47 = tmp46 + } + tmp48 := lang.Apply(tmp45, []any{tmp47}) + var v49 any = tmp48 + _ = v49 + // let binding "vec__932" + var v50 any = v49 + _ = v50 + // let binding "seq__933" + tmp51 := checkDerefVar(var_glojure_DOT_core_seq) + tmp52 := lang.Apply(tmp51, []any{v50}) + var v53 any = tmp52 + _ = v53 + // let binding "first__934" + tmp54 := checkDerefVar(var_glojure_DOT_core_first) + tmp55 := lang.Apply(tmp54, []any{v53}) + var v56 any = tmp55 + _ = v56 + // let binding "seq__933" + tmp57 := checkDerefVar(var_glojure_DOT_core_next) + tmp58 := lang.Apply(tmp57, []any{v53}) + var v59 any = tmp58 + _ = v59 + // let binding "c" + var v60 any = v56 + _ = v60 + // let binding "r" + var v61 any = v59 + _ = v61 + // let binding "s" + var v62 any = v50 + _ = v62 + // let binding "qmode" + var v63 any = false + _ = v63 + var tmp64 any + { // let + // let binding "G__931" + var v65 any = v49 + _ = v65 + // let binding "qmode" + var v66 any = v63 + _ = v66 + for { + var tmp67 any + { // let + // let binding "vec__935" + var v68 any = v65 + _ = v68 + // let binding "seq__936" + tmp69 := checkDerefVar(var_glojure_DOT_core_seq) + tmp70 := lang.Apply(tmp69, []any{v68}) + var v71 any = tmp70 + _ = v71 + // let binding "first__937" + tmp72 := checkDerefVar(var_glojure_DOT_core_first) + tmp73 := lang.Apply(tmp72, []any{v71}) + var v74 any = tmp73 + _ = v74 + // let binding "seq__936" + tmp75 := checkDerefVar(var_glojure_DOT_core_next) + tmp76 := lang.Apply(tmp75, []any{v71}) + var v77 any = tmp76 + _ = v77 + // let binding "c" + var v78 any = v74 + _ = v78 + // let binding "r" + var v79 any = v77 + _ = v79 + // let binding "s" + var v80 any = v68 + _ = v80 + // let binding "qmode" + var v81 any = v66 + _ = v81 + var tmp82 any + if lang.IsTruthy(v80) { + var tmp83 any + tmp84 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp85 := lang.Apply(tmp84, []any{v78, lang.NewChar(92)}) + if lang.IsTruthy(tmp85) { + var tmp86 any + { // let + // let binding "vec__938" + var v87 any = v79 + _ = v87 + // let binding "seq__939" + tmp88 := checkDerefVar(var_glojure_DOT_core_seq) + tmp89 := lang.Apply(tmp88, []any{v87}) + var v90 any = tmp89 + _ = v90 + // let binding "first__940" + tmp91 := checkDerefVar(var_glojure_DOT_core_first) + tmp92 := lang.Apply(tmp91, []any{v90}) + var v93 any = tmp92 + _ = v93 + // let binding "seq__939" + tmp94 := checkDerefVar(var_glojure_DOT_core_next) + tmp95 := lang.Apply(tmp94, []any{v90}) + var v96 any = tmp95 + _ = v96 + // let binding "c2" + var v97 any = v93 + _ = v97 + // let binding "r2" + var v98 any = v96 + _ = v98 + tmp99 := lang.Apply(lang.AppendWriter, []any{v42, lang.NewChar(92)}) + _ = tmp99 + tmp100 := lang.Apply(lang.AppendWriter, []any{v42, v97}) + _ = tmp100 + var tmp101 any + if lang.IsTruthy(v81) { + var tmp102 any = v98 + tmp104 := checkDerefVar(var_glojure_DOT_core_not_EQ_) + tmp105 := lang.Apply(tmp104, []any{v97, lang.NewChar(69)}) + var tmp103 any = tmp105 + v65 = tmp102 + v66 = tmp103 + continue + } else { + var tmp106 any = v98 + tmp108 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp109 := lang.Apply(tmp108, []any{v97, lang.NewChar(81)}) + var tmp107 any = tmp109 + v65 = tmp106 + v66 = tmp107 + continue + } + tmp86 = tmp101 + } // end let + tmp83 = tmp86 + } else { + var tmp87 any + tmp88 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp89 := lang.Apply(tmp88, []any{v78, lang.NewChar(34)}) + if lang.IsTruthy(tmp89) { + var tmp90 any + if lang.IsTruthy(v81) { + tmp91 := lang.Apply(lang.WriteWriter, []any{v42, "\\E\\\"\\Q"}) + tmp90 = tmp91 + } else { + tmp92 := lang.Apply(lang.WriteWriter, []any{v42, "\\\""}) + tmp90 = tmp92 + } + _ = tmp90 + var tmp93 any = v79 + var tmp94 any = v81 + v65 = tmp93 + v66 = tmp94 + continue + } else { + var tmp95 any + if lang.IsTruthy(kw_else) { + tmp96 := lang.Apply(lang.AppendWriter, []any{v42, v78}) + _ = tmp96 + var tmp97 any = v79 + var tmp98 any = v81 + v65 = tmp97 + v66 = tmp98 + continue + } else { + } + tmp87 = tmp95 + } + tmp83 = tmp87 + } + tmp82 = tmp83 + } else { + } + tmp67 = tmp82 + } // end let + tmp64 = tmp67 + break + } + } // end let + tmp44 = tmp64 + } // end let + _ = tmp44 + tmp45 := lang.Apply(lang.AppendWriter, []any{v42, lang.NewChar(34)}) + return tmp45 + }) + tmp1.AddMethod(tmp39, tmp40) + tmp41 := reflect.TypeOf(int32(0)) + var tmp42 lang.FnFunc + tmp42 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v43 := args[0] + _ = v43 + v44 := args[1] + _ = v44 + tmp45 := checkDerefVar(var_glojure_DOT_core_str) + tmp46 := lang.Apply(tmp45, []any{v43}) + tmp47, _ := lang.FieldOrMethod(v44, "write") + if reflect.TypeOf(tmp47).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + } + tmp48 := lang.Apply(tmp47, []any{tmp46}) + return tmp48 + }) + tmp1.AddMethod(tmp41, tmp42) + tmp43 := reflect.TypeOf((*lang.Ratio)(nil)) + var tmp44 lang.FnFunc + tmp44 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v45 := args[0] + _ = v45 + v46 := args[1] + _ = v46 + tmp47 := checkDerefVar(var_glojure_DOT_core_str) + tmp48 := lang.Apply(tmp47, []any{v45}) + tmp49, _ := lang.FieldOrMethod(v46, "write") + if reflect.TypeOf(tmp49).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + } + tmp50 := lang.Apply(tmp49, []any{tmp48}) + return tmp50 + }) + tmp1.AddMethod(tmp43, tmp44) + tmp45 := reflect.TypeOf(float32(0)) + var tmp46 lang.FnFunc + tmp46 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v47 := args[0] + _ = v47 + v48 := args[1] + _ = v48 + var tmp49 any + tmp50 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp51 := lang.Apply(math4.Inf, []any{int64(1)}) + tmp52 := lang.Apply(lang.Builtins["float32"], []any{tmp51}) + tmp53 := lang.Apply(tmp50, []any{tmp52, v47}) + if lang.IsTruthy(tmp53) { + tmp54 := lang.Apply(lang.WriteWriter, []any{v48, "##Inf"}) + tmp49 = tmp54 + } else { + var tmp55 any + tmp56 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp57 := lang.Apply(math4.Inf, []any{int64(-1)}) + tmp58 := lang.Apply(lang.Builtins["float32"], []any{tmp57}) + tmp59 := lang.Apply(tmp56, []any{tmp58, v47}) + if lang.IsTruthy(tmp59) { + tmp60 := lang.Apply(lang.WriteWriter, []any{v48, "##-Inf"}) + tmp55 = tmp60 + } else { + var tmp61 any + tmp62 := lang.Apply(math4.IsNaN, []any{v47}) + if lang.IsTruthy(tmp62) { + tmp63 := lang.Apply(lang.WriteWriter, []any{v48, "##NaN"}) + tmp61 = tmp63 + } else { + var tmp64 any + if lang.IsTruthy(kw_else) { + tmp65 := checkDerefVar(var_glojure_DOT_core_str) + tmp66 := lang.Apply(tmp65, []any{v47}) + tmp67 := lang.Apply(lang.WriteWriter, []any{v48, tmp66}) + tmp64 = tmp67 + } else { + } + tmp61 = tmp64 + } + tmp55 = tmp61 + } + tmp49 = tmp55 + } + return tmp49 + }) + tmp1.AddMethod(tmp45, tmp46) + tmp47 := reflect.TypeOf(int16(0)) + var tmp48 lang.FnFunc + tmp48 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v49 := args[0] + _ = v49 + v50 := args[1] + _ = v50 + tmp51 := checkDerefVar(var_glojure_DOT_core_str) + tmp52 := lang.Apply(tmp51, []any{v49}) + tmp53, _ := lang.FieldOrMethod(v50, "write") + if reflect.TypeOf(tmp53).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + } + tmp54 := lang.Apply(tmp53, []any{tmp52}) + return tmp54 + }) + tmp1.AddMethod(tmp47, tmp48) + tmp49 := reflect.TypeOf((*lang.Var)(nil)) + var tmp50 lang.FnFunc + tmp50 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v51 := args[0] + _ = v51 + v52 := args[1] + _ = v52 + tmp53 := checkDerefVar(var_glojure_DOT_core_print_DASH_simple) + tmp54 := lang.Apply(tmp53, []any{v51, v52}) + return tmp54 + }) + tmp1.AddMethod(tmp49, tmp50) + tmp51 := reflect.TypeOf(int8(0)) + var tmp52 lang.FnFunc + tmp52 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v53 := args[0] + _ = v53 + v54 := args[1] + _ = v54 + tmp55 := checkDerefVar(var_glojure_DOT_core_str) + tmp56 := lang.Apply(tmp55, []any{v53}) + tmp57, _ := lang.FieldOrMethod(v54, "write") + if reflect.TypeOf(tmp57).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + } + tmp58 := lang.Apply(tmp57, []any{tmp56}) + return tmp58 + }) + tmp1.AddMethod(tmp51, tmp52) + tmp53 := reflect.TypeOf(uint16(0)) + var tmp54 lang.FnFunc + tmp54 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v55 := args[0] + _ = v55 + v56 := args[1] + _ = v56 + tmp57 := checkDerefVar(var_glojure_DOT_core_str) + tmp58 := lang.Apply(tmp57, []any{v55}) + tmp59, _ := lang.FieldOrMethod(v56, "write") + if reflect.TypeOf(tmp59).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + } + tmp60 := lang.Apply(tmp59, []any{tmp58}) + return tmp60 + }) + tmp1.AddMethod(tmp53, tmp54) + tmp55 := reflect.TypeOf(uint64(0)) + var tmp56 lang.FnFunc + tmp56 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v57 := args[0] + _ = v57 + v58 := args[1] + _ = v58 + tmp59 := checkDerefVar(var_glojure_DOT_core_str) + tmp60 := lang.Apply(tmp59, []any{v57}) + tmp61, _ := lang.FieldOrMethod(v58, "write") + if reflect.TypeOf(tmp61).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + } + tmp62 := lang.Apply(tmp61, []any{tmp60}) + return tmp62 + }) + tmp1.AddMethod(tmp55, tmp56) + tmp57 := reflect.TypeOf((*lang.BigDecimal)(nil)) + var tmp58 lang.FnFunc + tmp58 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v59 := args[0] + _ = v59 + v60 := args[1] + _ = v60 + tmp61 := checkDerefVar(var_glojure_DOT_core_str) + tmp62 := lang.Apply(tmp61, []any{v59}) + tmp63 := lang.Apply(lang.WriteWriter, []any{v60, tmp62}) + _ = tmp63 + tmp64 := lang.Apply(lang.WriteWriter, []any{v60, "M"}) + return tmp64 + }) + tmp1.AddMethod(tmp57, tmp58) + tmp59 := reflect.TypeOf((*lang.BigInt)(nil)) + var tmp60 lang.FnFunc + tmp60 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v61 := args[0] + _ = v61 + v62 := args[1] + _ = v62 + tmp63 := checkDerefVar(var_glojure_DOT_core_str) + tmp64 := lang.Apply(tmp63, []any{v61}) + tmp65 := lang.Apply(lang.WriteWriter, []any{v62, tmp64}) + _ = tmp65 + tmp66 := lang.Apply(lang.WriteWriter, []any{v62, "N"}) + return tmp66 + }) + tmp1.AddMethod(tmp59, tmp60) + tmp61 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() + var tmp62 lang.FnFunc + tmp62 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v63 := args[0] + _ = v63 + v64 := args[1] + _ = v64 + tmp65 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) + tmp66 := lang.Apply(tmp65, []any{v63, v64}) + _ = tmp66 + tmp67 := checkDerefVar(var_glojure_DOT_core_print_DASH_sequential) + tmp68 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) + tmp69 := lang.Apply(tmp67, []any{"(", tmp68, " ", ")", v63, v64}) + return tmp69 + }) + tmp1.AddMethod(tmp61, tmp62) + tmp63 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() + tmp64 := reflect.TypeOf((*lang.IPersistentCollection)(nil)).Elem() + tmp1.PreferMethod(tmp63, tmp64) + tmp65 := reflect.TypeOf((*lang.IRecord)(nil)).Elem() + tmp66 := reflect.TypeOf((*lang.IPersistentMap)(nil)).Elem() + tmp1.PreferMethod(tmp65, tmp66) + var_glojure_DOT_core_print_DASH_method = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_print_DASH_method.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print-tagged-object + { + tmp0 := sym_print_DASH_tagged_DASH_object.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(102), kw_column, int(8), kw_end_DASH_line, int(102), kw_end_DASH_column, int(26), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_o, sym_rep, sym_w)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp7 := reflect.TypeOf((*lang.IMeta)(nil)).Elem() + tmp8 := lang.Apply(tmp6, []any{tmp7, v2}) + if lang.IsTruthy(tmp8) { + tmp9 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) + tmp10 := lang.Apply(tmp9, []any{v2, v4}) + tmp5 = tmp10 + } else { + } + _ = tmp5 + tmp11 := lang.Apply(lang.WriteWriter, []any{v4, "#object["}) + _ = tmp11 + var tmp12 any + { // let + // let binding "c" + tmp13 := checkDerefVar(var_glojure_DOT_core_class) + tmp14 := lang.Apply(tmp13, []any{v2}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + if lang.IsTruthy(false) { + tmp17 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp18, ok := lang.FieldOrMethod(v15, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v15, "Name"))) + } + var tmp19 any + switch reflect.TypeOf(tmp18).Kind() { + case reflect.Func: + tmp19 = lang.Apply(tmp18, nil) + default: + tmp19 = tmp18 + } + tmp20 := lang.Apply(tmp17, []any{tmp19, v4}) + tmp16 = tmp20 + } else { + tmp21, ok := lang.FieldOrMethod(v15, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v15, "Name"))) + } + var tmp22 any + switch reflect.TypeOf(tmp21).Kind() { + case reflect.Func: + tmp22 = lang.Apply(tmp21, nil) + default: + tmp22 = tmp21 + } + tmp23 := lang.Apply(lang.WriteWriter, []any{v4, tmp22}) + tmp16 = tmp23 + } + tmp12 = tmp16 + } // end let + _ = tmp12 + tmp13 := lang.Apply(lang.WriteWriter, []any{v4, " "}) + _ = tmp13 + tmp14 := checkDerefVar(var_glojure_DOT_core_format) + tmp15 := lang.Apply(lang.IdentityHash, []any{v2}) + tmp16 := lang.Apply(tmp14, []any{"0x%x ", tmp15}) + tmp17 := lang.Apply(lang.WriteWriter, []any{v4, tmp16}) + _ = tmp17 + tmp18 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp19 := lang.Apply(tmp18, []any{v3, v4}) + _ = tmp19 + tmp20 := lang.Apply(lang.WriteWriter, []any{v4, "]"}) + return tmp20 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_print_DASH_tagged_DASH_object = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_print_DASH_tagged_DASH_object.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print-throwable + { + tmp0 := sym_print_DASH_throwable.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(478), kw_column, int(8), kw_end_DASH_line, int(478), kw_end_DASH_column, int(22), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_o, sym_w)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := lang.Apply(lang.WriteWriter, []any{v3, "#error {\n :cause "}) + _ = tmp4 + var tmp5 any + { // let + // let binding "map__944" + tmp6 := checkDerefVar(var_glojure_DOT_core_Throwable_DASH__GT_map) + tmp7 := lang.Apply(tmp6, []any{v2}) + var v8 any = tmp7 + _ = v8 + // let binding "map__944" + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp11 := lang.Apply(tmp10, []any{v8}) + if lang.IsTruthy(tmp11) { + var tmp12 any + tmp13 := checkDerefVar(var_glojure_DOT_core_next) + tmp14 := lang.Apply(tmp13, []any{v8}) + if lang.IsTruthy(tmp14) { + tmp15 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) + tmp16 := lang.Apply(tmp15, []any{v8}) + tmp17 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{tmp16}) + tmp12 = tmp17 + } else { + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_seq) + tmp20 := lang.Apply(tmp19, []any{v8}) + if lang.IsTruthy(tmp20) { + tmp21 := checkDerefVar(var_glojure_DOT_core_first) + tmp22 := lang.Apply(tmp21, []any{v8}) + tmp18 = tmp22 + } else { + } + tmp12 = tmp18 + } + tmp9 = tmp12 + } else { + tmp9 = v8 + } + var v23 any = tmp9 + _ = v23 + // let binding "cause" + tmp24 := checkDerefVar(var_glojure_DOT_core_get) + tmp25 := lang.Apply(tmp24, []any{v23, kw_cause}) + var v26 any = tmp25 + _ = v26 + // let binding "data" + tmp27 := checkDerefVar(var_glojure_DOT_core_get) + tmp28 := lang.Apply(tmp27, []any{v23, kw_data}) + var v29 any = tmp28 + _ = v29 + // let binding "via" + tmp30 := checkDerefVar(var_glojure_DOT_core_get) + tmp31 := lang.Apply(tmp30, []any{v23, kw_via}) + var v32 any = tmp31 + _ = v32 + // let binding "trace" + tmp33 := checkDerefVar(var_glojure_DOT_core_get) + tmp34 := lang.Apply(tmp33, []any{v23, kw_trace}) + var v35 any = tmp34 + _ = v35 + // let binding "print-via" + var tmp36 lang.FnFunc + tmp36 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v37 := args[0] + _ = v37 + tmp38 := lang.Apply(lang.WriteWriter, []any{v3, "{:type "}) + _ = tmp38 + tmp39 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp40 := lang.Apply(kw_type, []any{v37}) + tmp41 := lang.Apply(tmp39, []any{tmp40, v3}) + _ = tmp41 + tmp42 := lang.Apply(lang.WriteWriter, []any{v3, "\n :message "}) + _ = tmp42 + tmp43 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp44 := lang.Apply(kw_message, []any{v37}) + tmp45 := lang.Apply(tmp43, []any{tmp44, v3}) + _ = tmp45 + var tmp46 any + { // let + // let binding "temp__0__auto__" + tmp47 := lang.Apply(kw_data, []any{v37}) + var v48 any = tmp47 + _ = v48 + var tmp49 any + if lang.IsTruthy(v48) { + var tmp50 any + { // let + // let binding "data" + var v51 any = v48 + _ = v51 + tmp52 := lang.Apply(lang.WriteWriter, []any{v3, "\n :data "}) + _ = tmp52 + tmp53 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp54 := lang.Apply(tmp53, []any{v51, v3}) + tmp50 = tmp54 + } // end let + tmp49 = tmp50 + } else { + } + tmp46 = tmp49 + } // end let + _ = tmp46 + var tmp47 any + { // let + // let binding "temp__0__auto__" + tmp48 := lang.Apply(kw_at, []any{v37}) + var v49 any = tmp48 + _ = v49 + var tmp50 any + if lang.IsTruthy(v49) { + var tmp51 any + { // let + // let binding "at" + var v52 any = v49 + _ = v52 + tmp53 := lang.Apply(lang.WriteWriter, []any{v3, "\n :at "}) + _ = tmp53 + tmp54 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp55 := lang.Apply(kw_at, []any{v37}) + tmp56 := lang.Apply(tmp54, []any{tmp55, v3}) + tmp51 = tmp56 + } // end let + tmp50 = tmp51 + } else { + } + tmp47 = tmp50 + } // end let + _ = tmp47 + tmp48 := lang.Apply(lang.WriteWriter, []any{v3, "}"}) + return tmp48 + }) + tmp37 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(481), kw_column, int(19), kw_end_DASH_line, int(491), kw_end_DASH_column, int(73)) + tmp38, err := lang.WithMeta(tmp36, tmp37.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v39 any = tmp38 + _ = v39 + tmp40 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp41 := lang.Apply(tmp40, []any{v26, v3}) + _ = tmp41 + var tmp42 any + if lang.IsTruthy(v29) { + tmp43 := lang.Apply(lang.WriteWriter, []any{v3, "\n :data "}) + _ = tmp43 + tmp44 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp45 := lang.Apply(tmp44, []any{v29, v3}) + tmp42 = tmp45 + } else { + } + _ = tmp42 + var tmp46 any + if lang.IsTruthy(v32) { + tmp47 := lang.Apply(lang.WriteWriter, []any{v3, "\n :via\n ["}) + _ = tmp47 + var tmp48 any + { // let + // let binding "temp__0__auto__" + tmp49 := checkDerefVar(var_glojure_DOT_core_first) + tmp50 := lang.Apply(tmp49, []any{v32}) + var v51 any = tmp50 + _ = v51 + var tmp52 any + if lang.IsTruthy(v51) { + var tmp53 any + { // let + // let binding "fv" + var v54 any = v51 + _ = v54 + tmp55 := lang.Apply(v39, []any{v54}) + _ = tmp55 + var tmp56 any + { // let + // let binding "seq_945" + tmp57 := checkDerefVar(var_glojure_DOT_core_seq) + tmp58 := checkDerefVar(var_glojure_DOT_core_rest) + tmp59 := lang.Apply(tmp58, []any{v32}) + tmp60 := lang.Apply(tmp57, []any{tmp59}) + var v61 any = tmp60 + _ = v61 + // let binding "chunk_946" + var v62 any = nil + _ = v62 + // let binding "count_947" + var v63 any = int64(0) + _ = v63 + // let binding "i_948" + var v64 any = int64(0) + _ = v64 + for { + var tmp65 any + tmp66 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp67 := lang.Apply(tmp66, []any{v64, v63}) + if lang.IsTruthy(tmp67) { + var tmp68 any + { // let + // let binding "v" + tmp69, _ := lang.FieldOrMethod(v62, "nth") + if reflect.TypeOf(tmp69).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp70 := lang.Apply(tmp69, []any{v64}) + var v71 any = tmp70 + _ = v71 + tmp72 := lang.Apply(lang.WriteWriter, []any{v3, "\n "}) + _ = tmp72 + tmp73 := lang.Apply(v39, []any{v71}) + _ = tmp73 + var tmp74 any = v61 + var tmp75 any = v62 + var tmp76 any = v63 + tmp78 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp79 := lang.Apply(tmp78, []any{v64}) + var tmp77 any = tmp79 + v61 = tmp74 + v62 = tmp75 + v63 = tmp76 + v64 = tmp77 + continue + } // end let + tmp65 = tmp68 + } else { + var tmp69 any + { // let + // let binding "temp__0__auto__" + tmp70 := checkDerefVar(var_glojure_DOT_core_seq) + tmp71 := lang.Apply(tmp70, []any{v61}) + var v72 any = tmp71 + _ = v72 + var tmp73 any + if lang.IsTruthy(v72) { + var tmp74 any + { // let + // let binding "seq_945" + var v75 any = v72 + _ = v75 + var tmp76 any + tmp77 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp78 := lang.Apply(tmp77, []any{v75}) + if lang.IsTruthy(tmp78) { + var tmp79 any + { // let + // let binding "c__0__auto__" + tmp80 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp81 := lang.Apply(tmp80, []any{v75}) + var v82 any = tmp81 + _ = v82 + tmp84 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp85 := lang.Apply(tmp84, []any{v75}) + var tmp83 any = tmp85 + var tmp86 any = v82 + tmp88 := checkDerefVar(var_glojure_DOT_core_int) + tmp89 := checkDerefVar(var_glojure_DOT_core_count) + tmp90 := lang.Apply(tmp89, []any{v82}) + tmp91 := lang.Apply(tmp88, []any{tmp90}) + var tmp87 any = tmp91 + tmp93 := checkDerefVar(var_glojure_DOT_core_int) + tmp94 := lang.Apply(tmp93, []any{int64(0)}) + var tmp92 any = tmp94 + v61 = tmp83 + v62 = tmp86 + v63 = tmp87 + v64 = tmp92 + continue + } // end let + tmp76 = tmp79 + } else { + var tmp80 any + { // let + // let binding "v" + tmp81 := checkDerefVar(var_glojure_DOT_core_first) + tmp82 := lang.Apply(tmp81, []any{v75}) + var v83 any = tmp82 + _ = v83 + tmp84 := lang.Apply(lang.WriteWriter, []any{v3, "\n "}) + _ = tmp84 + tmp85 := lang.Apply(v39, []any{v83}) + _ = tmp85 + tmp87 := checkDerefVar(var_glojure_DOT_core_next) + tmp88 := lang.Apply(tmp87, []any{v75}) + var tmp86 any = tmp88 + var tmp89 any = nil + var tmp90 any = int64(0) + var tmp91 any = int64(0) + v61 = tmp86 + v62 = tmp89 + v63 = tmp90 + v64 = tmp91 + continue + } // end let + tmp76 = tmp80 + } + tmp74 = tmp76 + } // end let + tmp73 = tmp74 + } else { + } + tmp69 = tmp73 + } // end let + tmp65 = tmp69 + } + tmp56 = tmp65 + break + } + } // end let + tmp53 = tmp56 + } // end let + tmp52 = tmp53 + } else { + } + tmp48 = tmp52 + } // end let + _ = tmp48 + tmp49 := lang.Apply(lang.WriteWriter, []any{v3, "]"}) + tmp46 = tmp49 + } else { + } + _ = tmp46 + var tmp50 any + if lang.IsTruthy(v35) { + tmp51 := lang.Apply(lang.WriteWriter, []any{v3, "\n :trace\n ["}) + _ = tmp51 + var tmp52 any + { // let + // let binding "temp__0__auto__" + tmp53 := checkDerefVar(var_glojure_DOT_core_first) + tmp54 := lang.Apply(tmp53, []any{v35}) + var v55 any = tmp54 + _ = v55 + var tmp56 any + if lang.IsTruthy(v55) { + var tmp57 any + { // let + // let binding "ft" + var v58 any = v55 + _ = v58 + tmp59 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp60 := lang.Apply(tmp59, []any{v58, v3}) + _ = tmp60 + var tmp61 any + { // let + // let binding "seq_949" + tmp62 := checkDerefVar(var_glojure_DOT_core_seq) + tmp63 := checkDerefVar(var_glojure_DOT_core_rest) + tmp64 := lang.Apply(tmp63, []any{v35}) + tmp65 := lang.Apply(tmp62, []any{tmp64}) + var v66 any = tmp65 + _ = v66 + // let binding "chunk_950" + var v67 any = nil + _ = v67 + // let binding "count_951" + var v68 any = int64(0) + _ = v68 + // let binding "i_952" + var v69 any = int64(0) + _ = v69 + for { + var tmp70 any + tmp71 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp72 := lang.Apply(tmp71, []any{v69, v68}) + if lang.IsTruthy(tmp72) { + var tmp73 any + { // let + // let binding "t" + tmp74, _ := lang.FieldOrMethod(v67, "nth") + if reflect.TypeOf(tmp74).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp75 := lang.Apply(tmp74, []any{v69}) + var v76 any = tmp75 + _ = v76 + tmp77 := lang.Apply(lang.WriteWriter, []any{v3, "\n "}) + _ = tmp77 + tmp78 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp79 := lang.Apply(tmp78, []any{v76, v3}) + _ = tmp79 + var tmp80 any = v66 + var tmp81 any = v67 + var tmp82 any = v68 + tmp84 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp85 := lang.Apply(tmp84, []any{v69}) + var tmp83 any = tmp85 + v66 = tmp80 + v67 = tmp81 + v68 = tmp82 + v69 = tmp83 + continue + } // end let + tmp70 = tmp73 + } else { + var tmp74 any + { // let + // let binding "temp__0__auto__" + tmp75 := checkDerefVar(var_glojure_DOT_core_seq) + tmp76 := lang.Apply(tmp75, []any{v66}) + var v77 any = tmp76 + _ = v77 + var tmp78 any + if lang.IsTruthy(v77) { + var tmp79 any + { // let + // let binding "seq_949" + var v80 any = v77 + _ = v80 + var tmp81 any + tmp82 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp83 := lang.Apply(tmp82, []any{v80}) + if lang.IsTruthy(tmp83) { + var tmp84 any + { // let + // let binding "c__0__auto__" + tmp85 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp86 := lang.Apply(tmp85, []any{v80}) + var v87 any = tmp86 + _ = v87 + tmp89 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp90 := lang.Apply(tmp89, []any{v80}) + var tmp88 any = tmp90 + var tmp91 any = v87 + tmp93 := checkDerefVar(var_glojure_DOT_core_int) + tmp94 := checkDerefVar(var_glojure_DOT_core_count) + tmp95 := lang.Apply(tmp94, []any{v87}) + tmp96 := lang.Apply(tmp93, []any{tmp95}) + var tmp92 any = tmp96 + tmp98 := checkDerefVar(var_glojure_DOT_core_int) + tmp99 := lang.Apply(tmp98, []any{int64(0)}) + var tmp97 any = tmp99 + v66 = tmp88 + v67 = tmp91 + v68 = tmp92 + v69 = tmp97 + continue + } // end let + tmp81 = tmp84 + } else { + var tmp85 any + { // let + // let binding "t" + tmp86 := checkDerefVar(var_glojure_DOT_core_first) + tmp87 := lang.Apply(tmp86, []any{v80}) + var v88 any = tmp87 + _ = v88 + tmp89 := lang.Apply(lang.WriteWriter, []any{v3, "\n "}) + _ = tmp89 + tmp90 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp91 := lang.Apply(tmp90, []any{v88, v3}) + _ = tmp91 + tmp93 := checkDerefVar(var_glojure_DOT_core_next) + tmp94 := lang.Apply(tmp93, []any{v80}) + var tmp92 any = tmp94 + var tmp95 any = nil + var tmp96 any = int64(0) + var tmp97 any = int64(0) + v66 = tmp92 + v67 = tmp95 + v68 = tmp96 + v69 = tmp97 + continue + } // end let + tmp81 = tmp85 + } + tmp79 = tmp81 + } // end let + tmp78 = tmp79 + } else { + } + tmp74 = tmp78 + } // end let + tmp70 = tmp74 + } + tmp61 = tmp70 + break + } + } // end let + tmp57 = tmp61 + } // end let + tmp56 = tmp57 + } else { + } + tmp52 = tmp56 + } // end let + _ = tmp52 + tmp53 := lang.Apply(lang.WriteWriter, []any{v3, "]"}) + tmp50 = tmp53 + } else { + } + tmp5 = tmp50 + } // end let + _ = tmp5 + tmp6 := lang.Apply(lang.WriteWriter, []any{v3, "}"}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_print_DASH_throwable = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_print_DASH_throwable.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print-object + { + tmp0 := sym_print_DASH_object.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(115), kw_column, int(8), kw_end_DASH_line, int(115), kw_end_DASH_column, int(19), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_o, sym_w)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_print_DASH_tagged_DASH_object) + tmp5 := checkDerefVar(var_glojure_DOT_core_str) + tmp6 := lang.Apply(tmp5, []any{v2}) + tmp7 := lang.Apply(tmp4, []any{v2, tmp6, v3}) + return tmp7 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_print_DASH_object = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_print_DASH_object.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // read + { + tmp0 := sym_read.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_stream), lang.NewVector(sym_stream, sym_eof_DASH_error_QMARK_, sym_eof_DASH_value), lang.NewVector(sym_stream, sym_eof_DASH_error_QMARK_, sym_eof_DASH_value, sym_recursive_QMARK_), lang.NewVector(sym_opts, sym_stream)), kw_doc, "Reads the next object from stream, which must be an instance of\n java.io.PushbackReader or some derivee. stream defaults to the\n current value of *in*.\n\n Opts is a persistent map with valid keys:\n :read-cond - :allow to process reader conditionals, or\n :preserve to keep all branches\n :features - persistent set of feature keywords for reader conditionals\n :eof - on eof, return value unless :eofthrow, then throw.\n if not specified, will throw\n\n Note that read can execute code (controlled by *read-eval*),\n and as such should be used only with trusted sources.\n\n For data structure interop use glojure.edn/read", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3742), kw_end_DASH_line, int(3742))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp2 := checkDerefVar(var_glojure_DOT_core_read) + tmp3 := checkDerefVar(var_glojure_DOT_core__STAR_in_STAR_) + tmp4 := lang.Apply(tmp2, []any{tmp3}) + return tmp4 + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_read) + tmp4 := lang.Apply(tmp3, []any{v2, true, nil}) + return tmp4 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_read) + tmp6 := lang.Apply(tmp5, []any{v2, v3, v4, false}) + return tmp6 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_boolean) + tmp7 := lang.Apply(tmp6, []any{v3}) + tmp8, _ := lang.FieldOrMethod(nil, "read") + if reflect.TypeOf(tmp8).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("read is not a function"))) + } + tmp9 := lang.Apply(tmp8, []any{v2, tmp7, v4, v5}) + return tmp9 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(nil, "read") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("read is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3, v2}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_read = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_read.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // read-line + { + tmp0 := sym_read_DASH_line.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Reads the next line from stream that is the current value of *in* .", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(3797), kw_end_DASH_line, int(3797))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp2 any + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := checkDerefVar(var_glojure_DOT_core__STAR_in_STAR_) + tmp5 := lang.Apply(tmp3, []any{nil, tmp4}) + if lang.IsTruthy(tmp5) { + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_in_STAR_) + tmp7, ok := lang.FieldOrMethod(tmp6, "readLine") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp6, "readLine"))) + } + var tmp8 any + switch reflect.TypeOf(tmp7).Kind() { + case reflect.Func: + tmp8 = lang.Apply(tmp7, nil) + default: + tmp8 = tmp7 + } + tmp2 = tmp8 + } else { + tmp9 := checkDerefVar(var_glojure_DOT_core__STAR_in_STAR_) + tmp10, ok := lang.FieldOrMethod(tmp9, "readLine") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp9, "readLine"))) + } + var tmp11 any + switch reflect.TypeOf(tmp10).Kind() { + case reflect.Func: + tmp11 = lang.Apply(tmp10, nil) + default: + tmp11 = tmp10 + } + tmp2 = tmp11 + } + return tmp2 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_read_DASH_line = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_read_DASH_line.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // read+string + { + tmp0 := sym_read_PLUS_string.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_stream), lang.NewVector(sym_stream, sym_eof_DASH_error_QMARK_, sym_eof_DASH_value), lang.NewVector(sym_stream, sym_eof_DASH_error_QMARK_, sym_eof_DASH_value, sym_recursive_QMARK_), lang.NewVector(sym_opts, sym_stream)), kw_doc, "Like read, and taking the same args. stream must be a LineNumberingPushbackReader.\n Returns a vector containing the object read and the (whitespace-trimmed) string read.", kw_file, "glojure/core.glj", kw_added, "1.10", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(3771), kw_end_DASH_line, int(3771))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp2 := checkDerefVar(var_glojure_DOT_core_read_PLUS_string) + tmp3 := checkDerefVar(var_glojure_DOT_core__STAR_in_STAR_) + tmp4 := lang.Apply(tmp2, []any{tmp3}) + return tmp4 + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_read_PLUS_string) + tmp4 := lang.Apply(tmp3, []any{v2, true, nil}) + return tmp4 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_read_PLUS_string) + tmp6 := lang.Apply(tmp5, []any{v2, v3, v4, false}) + return tmp6 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var tmp6 any + func() { + defer func() { + if r := recover(); r != nil { + if lang.CatchMatches(r, lang.Throwable) { + v7 := r + _ = v7 + tmp8, ok := lang.FieldOrMethod(v2, "getString") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getString"))) + } + var tmp9 any + switch reflect.TypeOf(tmp8).Kind() { + case reflect.Func: + tmp9 = lang.Apply(tmp8, nil) + default: + tmp9 = tmp8 + } + _ = tmp9 + panic(v7) + } else { + panic(r) + } + } + }() + tmp7, ok := lang.FieldOrMethod(v2, "captureString") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "captureString"))) + } + var tmp8 any + switch reflect.TypeOf(tmp7).Kind() { + case reflect.Func: + tmp8 = lang.Apply(tmp7, nil) + default: + tmp8 = tmp7 + } + _ = tmp8 + var tmp9 any + { // let + // let binding "o" + tmp10 := checkDerefVar(var_glojure_DOT_core_read) + tmp11 := lang.Apply(tmp10, []any{v2, v3, v4, v5}) + var v12 any = tmp11 + _ = v12 + // let binding "s" + tmp13, ok := lang.FieldOrMethod(v2, "getString") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getString"))) + } + var tmp14 any + switch reflect.TypeOf(tmp13).Kind() { + case reflect.Func: + tmp14 = lang.Apply(tmp13, nil) + default: + tmp14 = tmp13 + } + tmp15, ok := lang.FieldOrMethod(tmp14, "trim") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp14, "trim"))) + } + var tmp16 any + switch reflect.TypeOf(tmp15).Kind() { + case reflect.Func: + tmp16 = lang.Apply(tmp15, nil) + default: + tmp16 = tmp15 + } + var v17 any = tmp16 + _ = v17 + tmp18 := lang.NewVector(v12, v17) + tmp19 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3783), kw_column, int(8), kw_end_DASH_line, int(3783), kw_end_DASH_column, int(12)) + tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp9 = tmp20 + } // end let + tmp6 = tmp9 + }() + return tmp6 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + func() { + defer func() { + if r := recover(); r != nil { + if lang.CatchMatches(r, lang.Throwable) { + v5 := r + _ = v5 + tmp6, ok := lang.FieldOrMethod(v3, "getString") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getString"))) + } + var tmp7 any + switch reflect.TypeOf(tmp6).Kind() { + case reflect.Func: + tmp7 = lang.Apply(tmp6, nil) + default: + tmp7 = tmp6 + } + _ = tmp7 + panic(v5) + } else { + panic(r) + } + } + }() + tmp5, ok := lang.FieldOrMethod(v3, "captureString") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "captureString"))) + } + var tmp6 any + switch reflect.TypeOf(tmp5).Kind() { + case reflect.Func: + tmp6 = lang.Apply(tmp5, nil) + default: + tmp6 = tmp5 + } + _ = tmp6 + var tmp7 any + { // let + // let binding "o" + tmp8 := checkDerefVar(var_glojure_DOT_core_read) + tmp9 := lang.Apply(tmp8, []any{v2, v3}) + var v10 any = tmp9 + _ = v10 + // let binding "s" + tmp11, ok := lang.FieldOrMethod(v3, "getString") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getString"))) + } + var tmp12 any + switch reflect.TypeOf(tmp11).Kind() { + case reflect.Func: + tmp12 = lang.Apply(tmp11, nil) + default: + tmp12 = tmp11 + } + tmp13, ok := lang.FieldOrMethod(tmp12, "trim") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp12, "trim"))) + } + var tmp14 any + switch reflect.TypeOf(tmp13).Kind() { + case reflect.Func: + tmp14 = lang.Apply(tmp13, nil) + default: + tmp14 = tmp13 + } + var v15 any = tmp14 + _ = v15 + tmp16 := lang.NewVector(v10, v15) + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3792), kw_column, int(8), kw_end_DASH_line, int(3792), kw_end_DASH_column, int(12)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp7 = tmp18 + } // end let + tmp4 = tmp7 + }() + return tmp4 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_read_PLUS_string = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_read_PLUS_string.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reduce + { + tmp0 := sym_reduce.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_coll), lang.NewVector(sym_f, sym_val, sym_coll)), kw_doc, "f should be a function of 2 arguments. If val is not supplied,\n returns the result of applying f to the first 2 items in coll, then\n applying f to that result and the 3rd item, etc. If coll contains no\n items, f must accept no arguments as well, and reduce returns the\n result of calling f with no arguments. If coll has only 1 item, it\n is returned and f is not called. If val is supplied, returns the\n result of applying f to val and the first item in coll, then\n applying f to that result and the 2nd item, etc. If coll contains no\n items, returns val and f is not called.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(6860), kw_end_DASH_line, int(6860))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp6 := reflect.TypeOf((*lang.IReduce)(nil)).Elem() + tmp7 := lang.Apply(tmp5, []any{tmp6, v3}) + if lang.IsTruthy(tmp7) { + tmp8, _ := lang.FieldOrMethod(v3, "Reduce") + if reflect.TypeOf(tmp8).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Reduce is not a function"))) + } + tmp9 := lang.Apply(tmp8, []any{v2}) + tmp4 = tmp9 + } else { + tmp10 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_coll_DASH_reduce) + tmp11 := lang.Apply(tmp10, []any{v3, v2}) + tmp4 = tmp11 + } + return tmp4 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp7 := reflect.TypeOf((*lang.IReduceInit)(nil)).Elem() + tmp8 := lang.Apply(tmp6, []any{tmp7, v4}) + if lang.IsTruthy(tmp8) { + tmp9, _ := lang.FieldOrMethod(v4, "ReduceInit") + if reflect.TypeOf(tmp9).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) + } + tmp10 := lang.Apply(tmp9, []any{v2, v3}) + tmp5 = tmp10 + } else { + tmp11 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_coll_DASH_reduce) + tmp12 := lang.Apply(tmp11, []any{v4, v2, v3}) + tmp5 = tmp12 + } + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_reduce = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_reduce.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // run! + { + tmp0 := sym_run_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_proc, sym_coll)), kw_doc, "Runs the supplied procedure (via reduce), for purposes of side\n effects, on successive items in the collection. Returns nil", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(7708), kw_end_DASH_line, int(7708))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_reduce) + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + tmp8 := lang.Apply(v2, []any{v7}) + return tmp8 + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7713), kw_column, int(11), kw_end_DASH_line, int(7713), kw_end_DASH_column, int(20)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp8 := lang.Apply(tmp4, []any{tmp7, nil, v3}) + _ = tmp8 + return nil + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_run_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_run_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reduce-kv + { + tmp0 := sym_reduce_DASH_kv.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_init, sym_coll)), kw_doc, "Reduces an associative collection. f should be a function of 3\n arguments. Returns the result of applying f to init, the first key\n and the first value in coll, then applying f to that result and the\n 2nd key and value, etc. If coll contains no entries, returns init\n and f is not called. Note that reduce-kv is supported on vectors,\n where the keys will be the ordinals.", kw_file, "glojure/core.glj", kw_added, "1.4", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(6882), kw_end_DASH_line, int(6882))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_kv_DASH_reduce) + tmp6 := lang.Apply(tmp5, []any{v4, v2, v3}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_reduce_DASH_kv = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_reduce_DASH_kv.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // update-keys + { + tmp0 := sym_update_DASH_keys.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m, sym_f)), kw_doc, "m f => {(f k) v ...}\n\n Given a map m and a function f of 1-argument, returns a new map whose\n keys are the result of applying f to the keys of m, mapped to the\n corresponding values of m.\n f must return a unique key for each key of m, else the behavior is undefined.", kw_file, "glojure/core.glj", kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(7906), kw_end_DASH_line, int(7906))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "ret" + tmp5 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp6 := checkDerefVar(var_glojure_DOT_core_reduce_DASH_kv) + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + v10 := args[2] + _ = v10 + tmp11 := checkDerefVar(var_glojure_DOT_core_assoc_BANG_) + tmp12 := lang.Apply(v3, []any{v9}) + tmp13 := lang.Apply(tmp11, []any{v8, tmp12, v10}) + return tmp13 + }) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7916), kw_column, int(25), kw_end_DASH_line, int(7916), kw_end_DASH_column, int(59)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp10 := checkDerefVar(var_glojure_DOT_core_transient) + tmp11 := lang.NewMap() + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7917), kw_column, int(36), kw_end_DASH_line, int(7917), kw_end_DASH_column, int(37)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp14 := lang.Apply(tmp10, []any{tmp13}) + tmp15 := lang.Apply(tmp6, []any{tmp9, tmp14, v2}) + tmp16 := lang.Apply(tmp5, []any{tmp15}) + var v17 any = tmp16 + _ = v17 + tmp18 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp19 := checkDerefVar(var_glojure_DOT_core_meta) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := lang.Apply(tmp18, []any{v17, tmp20}) + tmp4 = tmp21 + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_update_DASH_keys = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_update_DASH_keys.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // update-vals + { + tmp0 := sym_update_DASH_vals.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m, sym_f)), kw_doc, "m f => {k (f v) ...}\n\n Given a map m and a function f of 1-argument, returns a new map where the keys of m\n are mapped to result of applying f to the corresponding values of m.", kw_file, "glojure/core.glj", kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(7890), kw_end_DASH_line, int(7890))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp5 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp6 := checkDerefVar(var_glojure_DOT_core_reduce_DASH_kv) + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + v10 := args[2] + _ = v10 + tmp11 := checkDerefVar(var_glojure_DOT_core_assoc_BANG_) + tmp12 := lang.Apply(v3, []any{v10}) + tmp13 := lang.Apply(tmp11, []any{v8, v9, tmp12}) + return tmp13 + }) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7899), kw_column, int(17), kw_end_DASH_line, int(7899), kw_end_DASH_column, int(51)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var tmp10 any + tmp11 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp12 := reflect.TypeOf((*lang.IEditableCollection)(nil)).Elem() + tmp13 := lang.Apply(tmp11, []any{tmp12, v2}) + if lang.IsTruthy(tmp13) { + tmp14 := checkDerefVar(var_glojure_DOT_core_transient) + tmp15 := lang.Apply(tmp14, []any{v2}) + tmp10 = tmp15 + } else { + tmp16 := checkDerefVar(var_glojure_DOT_core_transient) + tmp17 := lang.NewMap() + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7902), kw_column, int(30), kw_end_DASH_line, int(7902), kw_end_DASH_column, int(31)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp20 := lang.Apply(tmp16, []any{tmp19}) + tmp10 = tmp20 + } + tmp21 := lang.Apply(tmp6, []any{tmp9, tmp10, v2}) + tmp22 := lang.Apply(tmp5, []any{tmp21}) + tmp23 := checkDerefVar(var_glojure_DOT_core_meta) + tmp24 := lang.Apply(tmp23, []any{v2}) + tmp25 := lang.Apply(tmp4, []any{tmp22, tmp24}) + return tmp25 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_update_DASH_vals = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_update_DASH_vals.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // slurp + { + tmp1 := reflect.TypeOf("") + tmp0 := sym_slurp.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_f, sym__AMP_, sym_opts)), kw_doc, "Opens a reader on f and reads all its contents, returning a string.\n See glojure.java.io/reader for a complete list of supported arguments.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(6982), kw_end_DASH_line, int(6982))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v3 := args[0] + _ = v3 + var v4 any = lang.NewList(args[1:]...) + _ = v4 + var tmp5 any + { // let + // let binding "opts" + tmp6 := checkDerefVar(var_glojure_DOT_core_normalize_DASH_slurp_DASH_opts) + tmp7 := lang.Apply(tmp6, []any{v4}) + var v8 any = tmp7 + _ = v8 + // let binding "sw" + var v9 any = "unimplemented: new with non-constant class type" + _ = v9 + var tmp10 any + { // let + // let binding "r" + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + tmp12 := checkDerefVar(var_glojure_DOT_go_DOT_io_reader) + tmp13 := lang.Apply(tmp11, []any{tmp12, v3, v8}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + func() { + defer func() { + tmp16, ok := lang.FieldOrMethod(v14, "close") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v14, "close"))) + } + var tmp17 any + switch reflect.TypeOf(tmp16).Kind() { + case reflect.Func: + tmp17 = lang.Apply(tmp16, nil) + default: + tmp17 = tmp16 + } + _ = tmp17 + }() + tmp18 := checkDerefVar(var_glojure_DOT_go_DOT_io_copy) + tmp19 := lang.Apply(tmp18, []any{v14, v9}) + _ = tmp19 + tmp20 := lang.Apply(lang.ToString, []any{v9}) + tmp15 = tmp20 + }() + tmp10 = tmp15 + } // end let + tmp5 = tmp10 + } // end let + return tmp5 + } + }) + tmp3 := reflect.TypeOf("") + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_slurp = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_slurp.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // transduce + { + tmp0 := sym_transduce.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xform, sym_f, sym_coll), lang.NewVector(sym_xform, sym_f, sym_init, sym_coll)), kw_doc, "reduce with a transformation of f (xf). If init is not\n supplied, (f) will be called to produce it. f should be a reducing\n step function that accepts both 1 and 2 arguments, if it accepts\n only 2 you can add the arity-1 with 'completing'. Returns the result\n of applying (the transformed) xf to init and the first item in coll,\n then applying xf to that result and the 2nd item, etc. If coll\n contains no items, returns init and f is not called. Note that\n certain transforms may inject or skip items.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(6905), kw_end_DASH_line, int(6905))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_transduce) + tmp6 := lang.Apply(v3, nil) + tmp7 := lang.Apply(tmp5, []any{v2, v3, tmp6, v4}) + return tmp7 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var tmp6 any + { // let + // let binding "f" + tmp7 := lang.Apply(v2, []any{v3}) + var v8 any = tmp7 + _ = v8 + // let binding "ret" + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp11 := reflect.TypeOf((*lang.IReduceInit)(nil)).Elem() + tmp12 := lang.Apply(tmp10, []any{tmp11, v5}) + if lang.IsTruthy(tmp12) { + tmp13, _ := lang.FieldOrMethod(v5, "ReduceInit") + if reflect.TypeOf(tmp13).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) + } + tmp14 := lang.Apply(tmp13, []any{v8, v4}) + tmp9 = tmp14 + } else { + tmp15 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_coll_DASH_reduce) + tmp16 := lang.Apply(tmp15, []any{v5, v8, v4}) + tmp9 = tmp16 + } + var v17 any = tmp9 + _ = v17 + tmp18 := lang.Apply(v8, []any{v17}) + tmp6 = tmp18 + } // end let + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_transduce = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_transduce.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } +} diff --git a/pkg/stdlib/glojure/core_deftype/loader.go b/pkg/stdlib/glojure/core_deftype/loader.go new file mode 100644 index 00000000..6b8a5485 --- /dev/null +++ b/pkg/stdlib/glojure/core_deftype/loader.go @@ -0,0 +1,55664 @@ +// Code generated by glojure codegen. DO NOT EDIT. + +package core + +import ( + errors5 "errors" + fmt "fmt" + lang "github.com/glojurelang/glojure/pkg/lang" + runtime "github.com/glojurelang/glojure/pkg/runtime" + uuid10 "github.com/google/uuid" + math4 "math" + big6 "math/big" + rand13 "math/rand" + url14 "net/url" + reflect "reflect" + regexp12 "regexp" + runtime11 "runtime" + strconv9 "strconv" + strings8 "strings" + time7 "time" +) + +func init() { + runtime.RegisterNSLoader("glojure/core", LoadNS) +} + +func checkDerefVar(v *lang.Var) any { + if v.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) + } + return v.Get() +} + +func checkArity(args []any, expected int) { + if len(args) != expected { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + +// LoadNS initializes the namespace "glojure.core" +func LoadNS() { + sym__PCT_ := lang.NewSymbol("%") + sym__AMP_ := lang.NewSymbol("&") + sym__AMP_env := lang.NewSymbol("&env") + sym__AMP_form := lang.NewSymbol("&form") + sym__STAR_ := lang.NewSymbol("*") + sym__STAR__TICK_ := lang.NewSymbol("*'") + sym__STAR_1 := lang.NewSymbol("*1") + sym__STAR_2 := lang.NewSymbol("*2") + sym__STAR_3 := lang.NewSymbol("*3") + sym__STAR_agent_STAR_ := lang.NewSymbol("*agent*") + sym__STAR_assert_STAR_ := lang.NewSymbol("*assert*") + sym__STAR_command_DASH_line_DASH_args_STAR_ := lang.NewSymbol("*command-line-args*") + sym__STAR_compile_DASH_files_STAR_ := lang.NewSymbol("*compile-files*") + sym__STAR_compile_DASH_path_STAR_ := lang.NewSymbol("*compile-path*") + sym__STAR_compiler_DASH_options_STAR_ := lang.NewSymbol("*compiler-options*") + sym__STAR_data_DASH_readers_STAR_ := lang.NewSymbol("*data-readers*") + sym__STAR_default_DASH_data_DASH_reader_DASH_fn_STAR_ := lang.NewSymbol("*default-data-reader-fn*") + sym__STAR_e := lang.NewSymbol("*e") + sym__STAR_err_STAR_ := lang.NewSymbol("*err*") + sym__STAR_file_STAR_ := lang.NewSymbol("*file*") + sym__STAR_flush_DASH_on_DASH_newline_STAR_ := lang.NewSymbol("*flush-on-newline*") + sym__STAR_in_STAR_ := lang.NewSymbol("*in*") + sym__STAR_loaded_DASH_libs_STAR_ := lang.NewSymbol("*loaded-libs*") + sym__STAR_loading_DASH_verbosely_STAR_ := lang.NewSymbol("*loading-verbosely*") + sym__STAR_ns_STAR_ := lang.NewSymbol("*ns*") + sym__STAR_out_STAR_ := lang.NewSymbol("*out*") + sym__STAR_pending_DASH_paths_STAR_ := lang.NewSymbol("*pending-paths*") + sym__STAR_print_DASH_dup_STAR_ := lang.NewSymbol("*print-dup*") + sym__STAR_print_DASH_length_STAR_ := lang.NewSymbol("*print-length*") + sym__STAR_print_DASH_level_STAR_ := lang.NewSymbol("*print-level*") + sym__STAR_print_DASH_meta_STAR_ := lang.NewSymbol("*print-meta*") + sym__STAR_print_DASH_namespace_DASH_maps_STAR_ := lang.NewSymbol("*print-namespace-maps*") + sym__STAR_print_DASH_readably_STAR_ := lang.NewSymbol("*print-readably*") + sym__STAR_read_DASH_eval_STAR_ := lang.NewSymbol("*read-eval*") + sym__STAR_repl_STAR_ := lang.NewSymbol("*repl*") + sym__STAR_unchecked_DASH_math_STAR_ := lang.NewSymbol("*unchecked-math*") + sym__STAR_verbose_DASH_defrecords_STAR_ := lang.NewSymbol("*verbose-defrecords*") + sym__STAR_warn_DASH_on_DASH_reflection_STAR_ := lang.NewSymbol("*warn-on-reflection*") + sym__PLUS_ := lang.NewSymbol("+") + sym__PLUS__TICK_ := lang.NewSymbol("+'") + sym__DASH_ := lang.NewSymbol("-") + sym__DASH__TICK_ := lang.NewSymbol("-'") + sym__DASH__GT_ := lang.NewSymbol("->") + sym__DASH__GT__GT_ := lang.NewSymbol("->>") + sym__DASH_protocols := lang.NewSymbol("-protocols") + sym__DOT_ := lang.NewSymbol(".") + sym__DOT__DOT_ := lang.NewSymbol("..") + sym__DOT_Deref := lang.NewSymbol(".Deref") + sym__DOT_Equals := lang.NewSymbol(".Equals") + sym__DOT_HasRoot := lang.NewSymbol(".HasRoot") + sym__DOT_ResetMeta := lang.NewSymbol(".ResetMeta") + sym__DOT_UnixNano := lang.NewSymbol(".UnixNano") + sym__DOT_nth := lang.NewSymbol(".nth") + sym__DOT_reset := lang.NewSymbol(".reset") + sym__SLASH_ := lang.NewSymbol("/") + sym__LT_ := lang.NewSymbol("<") + sym__LT__EQ_ := lang.NewSymbol("<=") + sym__EQ_ := lang.NewSymbol("=") + sym__EQ__EQ_ := lang.NewSymbol("==") + sym__GT_ := lang.NewSymbol(">") + sym__GT_0_QMARK_ := lang.NewSymbol(">0?") + sym__GT_1_QMARK_ := lang.NewSymbol(">1?") + sym__GT__EQ_ := lang.NewSymbol(">=") + sym_Double_SLASH_isInfinite := lang.NewSymbol("Double/isInfinite") + sym_NaN_QMARK_ := lang.NewSymbol("NaN?") + sym_SetMacro := lang.NewSymbol("SetMacro") + sym_StackTraceElement_DASH__GT_vec := lang.NewSymbol("StackTraceElement->vec") + sym_Throwable_DASH__GT_map := lang.NewSymbol("Throwable->map") + sym_a := lang.NewSymbol("a") + sym_a__0__auto__ := lang.NewSymbol("a__0__auto__") + sym_abs := lang.NewSymbol("abs") + sym_accessor := lang.NewSymbol("accessor") + sym_aclone := lang.NewSymbol("aclone") + sym_add := lang.NewSymbol("add") + sym_add_DASH_classpath := lang.NewSymbol("add-classpath") + sym_add_DASH_doc_DASH_and_DASH_meta := lang.NewSymbol("add-doc-and-meta") + sym_add_DASH_watch := lang.NewSymbol("add-watch") + sym_addP := lang.NewSymbol("addP") + sym_agent := lang.NewSymbol("agent") + sym_agent_DASH_error := lang.NewSymbol("agent-error") + sym_agent_DASH_errors := lang.NewSymbol("agent-errors") + sym_agents := lang.NewSymbol("agents") + sym_aget := lang.NewSymbol("aget") + sym_alength := lang.NewSymbol("alength") + sym_alias := lang.NewSymbol("alias") + sym_all_DASH_ns := lang.NewSymbol("all-ns") + sym_alter := lang.NewSymbol("alter") + sym_alter_DASH_meta_BANG_ := lang.NewSymbol("alter-meta!") + sym_alter_DASH_var_DASH_root := lang.NewSymbol("alter-var-root") + sym_amap := lang.NewSymbol("amap") + sym_ancestors := lang.NewSymbol("ancestors") + sym_and := lang.NewSymbol("and") + sym_andNot := lang.NewSymbol("andNot") + sym_and__0__auto__ := lang.NewSymbol("and__0__auto__") + sym_any_QMARK_ := lang.NewSymbol("any?") + sym_apply := lang.NewSymbol("apply") + sym_areduce := lang.NewSymbol("areduce") + sym_arg1 := lang.NewSymbol("arg1") + sym_arg2 := lang.NewSymbol("arg2") + sym_arg3 := lang.NewSymbol("arg3") + sym_arglist := lang.NewSymbol("arglist") + sym_args := lang.NewSymbol("args") + sym_array := lang.NewSymbol("array") + sym_array_DASH_map := lang.NewSymbol("array-map") + sym_array__0__auto__ := lang.NewSymbol("array__0__auto__") + sym_as_DASH__GT_ := lang.NewSymbol("as->") + sym_aseq := lang.NewSymbol("aseq") + sym_aset := lang.NewSymbol("aset") + sym_aset_DASH_boolean := lang.NewSymbol("aset-boolean") + sym_aset_DASH_byte := lang.NewSymbol("aset-byte") + sym_aset_DASH_char := lang.NewSymbol("aset-char") + sym_aset_DASH_double := lang.NewSymbol("aset-double") + sym_aset_DASH_float := lang.NewSymbol("aset-float") + sym_aset_DASH_int := lang.NewSymbol("aset-int") + sym_aset_DASH_long := lang.NewSymbol("aset-long") + sym_aset_DASH_short := lang.NewSymbol("aset-short") + sym_assert := lang.NewSymbol("assert") + sym_assert_DASH_args := lang.NewSymbol("assert-args") + sym_assert_DASH_valid_DASH_fdecl := lang.NewSymbol("assert-valid-fdecl") + sym_assoc := lang.NewSymbol("assoc") + sym_assoc_BANG_ := lang.NewSymbol("assoc!") + sym_assoc_DASH_in := lang.NewSymbol("assoc-in") + sym_associative_QMARK_ := lang.NewSymbol("associative?") + sym_atom := lang.NewSymbol("atom") + sym_attr_DASH_map_QMARK_ := lang.NewSymbol("attr-map?") + sym_atype := lang.NewSymbol("atype") + sym_await := lang.NewSymbol("await") + sym_await_DASH_for := lang.NewSymbol("await-for") + sym_await1 := lang.NewSymbol("await1") + sym_b := lang.NewSymbol("b") + sym_bases := lang.NewSymbol("bases") + sym_begin := lang.NewSymbol("begin") + sym_bigdec := lang.NewSymbol("bigdec") + sym_bigint := lang.NewSymbol("bigint") + sym_biginteger := lang.NewSymbol("biginteger") + sym_binding := lang.NewSymbol("binding") + sym_binding_DASH_conveyor_DASH_fn := lang.NewSymbol("binding-conveyor-fn") + sym_binding_DASH_map := lang.NewSymbol("binding-map") + sym_bindings := lang.NewSymbol("bindings") + sym_bindings_STAR_ := lang.NewSymbol("bindings*") + sym_bit_DASH_and := lang.NewSymbol("bit-and") + sym_bit_DASH_and_DASH_not := lang.NewSymbol("bit-and-not") + sym_bit_DASH_clear := lang.NewSymbol("bit-clear") + sym_bit_DASH_flip := lang.NewSymbol("bit-flip") + sym_bit_DASH_not := lang.NewSymbol("bit-not") + sym_bit_DASH_or := lang.NewSymbol("bit-or") + sym_bit_DASH_set := lang.NewSymbol("bit-set") + sym_bit_DASH_shift_DASH_left := lang.NewSymbol("bit-shift-left") + sym_bit_DASH_shift_DASH_right := lang.NewSymbol("bit-shift-right") + sym_bit_DASH_test := lang.NewSymbol("bit-test") + sym_bit_DASH_xor := lang.NewSymbol("bit-xor") + sym_body := lang.NewSymbol("body") + sym_body_DASH_expr := lang.NewSymbol("body-expr") + sym_boolean := lang.NewSymbol("boolean") + sym_boolean_DASH_array := lang.NewSymbol("boolean-array") + sym_boolean_QMARK_ := lang.NewSymbol("boolean?") + sym_booleans := lang.NewSymbol("booleans") + sym_bound_DASH_fn := lang.NewSymbol("bound-fn") + sym_bound_DASH_fn_STAR_ := lang.NewSymbol("bound-fn*") + sym_bound_QMARK_ := lang.NewSymbol("bound?") + sym_bounded_DASH_count := lang.NewSymbol("bounded-count") + sym_branch_QMARK_ := lang.NewSymbol("branch?") + sym_butlast := lang.NewSymbol("butlast") + sym_byte := lang.NewSymbol("byte") + sym_byte_DASH_array := lang.NewSymbol("byte-array") + sym_byteCast := lang.NewSymbol("byteCast") + sym_bytes := lang.NewSymbol("bytes") + sym_bytes_QMARK_ := lang.NewSymbol("bytes?") + sym_c := lang.NewSymbol("c") + sym_c1 := lang.NewSymbol("c1") + sym_c2 := lang.NewSymbol("c2") + sym_c3 := lang.NewSymbol("c3") + sym_c__0__auto__ := lang.NewSymbol("c__0__auto__") + sym_capacity := lang.NewSymbol("capacity") + sym_case := lang.NewSymbol("case") + sym_case_STAR_ := lang.NewSymbol("case*") + sym_case_DASH_f := lang.NewSymbol("case-f") + sym_case_DASH_map := lang.NewSymbol("case-map") + sym_cast := lang.NewSymbol("cast") + sym_cat := lang.NewSymbol("cat") + sym_cause := lang.NewSymbol("cause") + sym_cf := lang.NewSymbol("cf") + sym_char := lang.NewSymbol("char") + sym_char_DASH_array := lang.NewSymbol("char-array") + sym_char_DASH_escape_DASH_string := lang.NewSymbol("char-escape-string") + sym_char_DASH_name_DASH_string := lang.NewSymbol("char-name-string") + sym_char_QMARK_ := lang.NewSymbol("char?") + sym_charCast := lang.NewSymbol("charCast") + sym_chars := lang.NewSymbol("chars") + sym_check_DASH_cyclic_DASH_dependency := lang.NewSymbol("check-cyclic-dependency") + sym_check_DASH_valid_DASH_options := lang.NewSymbol("check-valid-options") + sym_child := lang.NewSymbol("child") + sym_children := lang.NewSymbol("children") + sym_chunk := lang.NewSymbol("chunk") + sym_chunk_DASH_append := lang.NewSymbol("chunk-append") + sym_chunk_DASH_buffer := lang.NewSymbol("chunk-buffer") + sym_chunk_DASH_cons := lang.NewSymbol("chunk-cons") + sym_chunk_DASH_first := lang.NewSymbol("chunk-first") + sym_chunk_DASH_next := lang.NewSymbol("chunk-next") + sym_chunk_DASH_rest := lang.NewSymbol("chunk-rest") + sym_chunked_DASH_seq_QMARK_ := lang.NewSymbol("chunked-seq?") + sym_class := lang.NewSymbol("class") + sym_class_DASH_name := lang.NewSymbol("class-name") + sym_class_QMARK_ := lang.NewSymbol("class?") + sym_clauses := lang.NewSymbol("clauses") + sym_clear_DASH_agent_DASH_errors := lang.NewSymbol("clear-agent-errors") + sym_close := lang.NewSymbol("close") + sym_coerce := lang.NewSymbol("coerce") + sym_coll := lang.NewSymbol("coll") + sym_coll_DASH_reduce := lang.NewSymbol("coll-reduce") + sym_coll_QMARK_ := lang.NewSymbol("coll?") + sym_colls := lang.NewSymbol("colls") + sym_comment := lang.NewSymbol("comment") + sym_commute := lang.NewSymbol("commute") + sym_comp := lang.NewSymbol("comp") + sym_comparator := lang.NewSymbol("comparator") + sym_compare := lang.NewSymbol("compare") + sym_compare_DASH_and_DASH_set_BANG_ := lang.NewSymbol("compare-and-set!") + sym_compile := lang.NewSymbol("compile") + sym_complement := lang.NewSymbol("complement") + sym_completing := lang.NewSymbol("completing") + sym_concat := lang.NewSymbol("concat") + sym_cond := lang.NewSymbol("cond") + sym_cond_DASH__GT_ := lang.NewSymbol("cond->") + sym_cond_DASH__GT__GT_ := lang.NewSymbol("cond->>") + sym_condp := lang.NewSymbol("condp") + sym_conj := lang.NewSymbol("conj") + sym_conj_BANG_ := lang.NewSymbol("conj!") + sym_cons := lang.NewSymbol("cons") + sym_constantly := lang.NewSymbol("constantly") + sym_contains_QMARK_ := lang.NewSymbol("contains?") + sym_content := lang.NewSymbol("content") + sym_copy := lang.NewSymbol("copy") + sym_count := lang.NewSymbol("count") + sym_counted_QMARK_ := lang.NewSymbol("counted?") + sym_create := lang.NewSymbol("create") + sym_create_DASH_ns := lang.NewSymbol("create-ns") + sym_create_DASH_struct := lang.NewSymbol("create-struct") + sym_cycle := lang.NewSymbol("cycle") + sym_d := lang.NewSymbol("d") + sym_data_DASH_reader_DASH_urls := lang.NewSymbol("data-reader-urls") + sym_data_DASH_reader_DASH_var := lang.NewSymbol("data-reader-var") + sym_dec := lang.NewSymbol("dec") + sym_dec_TICK_ := lang.NewSymbol("dec'") + sym_decimal_QMARK_ := lang.NewSymbol("decimal?") + sym_decl := lang.NewSymbol("decl") + sym_declare := lang.NewSymbol("declare") + sym_decls := lang.NewSymbol("decls") + sym_dedupe := lang.NewSymbol("dedupe") + sym_def := lang.NewSymbol("def") + sym_def_DASH_aset := lang.NewSymbol("def-aset") + sym_default := lang.NewSymbol("default") + sym_definline := lang.NewSymbol("definline") + sym_defmacro := lang.NewSymbol("defmacro") + sym_defmethod := lang.NewSymbol("defmethod") + sym_defmulti := lang.NewSymbol("defmulti") + sym_defn := lang.NewSymbol("defn") + sym_defn_DASH_ := lang.NewSymbol("defn-") + sym_defonce := lang.NewSymbol("defonce") + sym_defprotocol := lang.NewSymbol("defprotocol") + sym_defstruct := lang.NewSymbol("defstruct") + sym_delay := lang.NewSymbol("delay") + sym_delay_QMARK_ := lang.NewSymbol("delay?") + sym_deliver := lang.NewSymbol("deliver") + sym_denominator := lang.NewSymbol("denominator") + sym_deref := lang.NewSymbol("deref") + sym_deref_DASH_as_DASH_map := lang.NewSymbol("deref-as-map") + sym_deref_DASH_future := lang.NewSymbol("deref-future") + sym_derive := lang.NewSymbol("derive") + sym_descendants := lang.NewSymbol("descendants") + sym_destructure := lang.NewSymbol("destructure") + sym_dim := lang.NewSymbol("dim") + sym_dir := lang.NewSymbol("dir") + sym_disj := lang.NewSymbol("disj") + sym_disj_BANG_ := lang.NewSymbol("disj!") + sym_dispatch_DASH_fn := lang.NewSymbol("dispatch-fn") + sym_dispatch_DASH_val := lang.NewSymbol("dispatch-val") + sym_dispatch_DASH_val_DASH_x := lang.NewSymbol("dispatch-val-x") + sym_dispatch_DASH_val_DASH_y := lang.NewSymbol("dispatch-val-y") + sym_dissoc := lang.NewSymbol("dissoc") + sym_dissoc_BANG_ := lang.NewSymbol("dissoc!") + sym_distinct := lang.NewSymbol("distinct") + sym_distinct_QMARK_ := lang.NewSymbol("distinct?") + sym_div := lang.NewSymbol("div") + sym_divide := lang.NewSymbol("divide") + sym_do := lang.NewSymbol("do") + sym_doall := lang.NewSymbol("doall") + sym_doc_DASH_string_QMARK_ := lang.NewSymbol("doc-string?") + sym_docstring := lang.NewSymbol("docstring") + sym_docstring_QMARK_ := lang.NewSymbol("docstring?") + sym_dorun := lang.NewSymbol("dorun") + sym_doseq := lang.NewSymbol("doseq") + sym_dosync := lang.NewSymbol("dosync") + sym_dotimes := lang.NewSymbol("dotimes") + sym_doto := lang.NewSymbol("doto") + sym_double := lang.NewSymbol("double") + sym_double_DASH_array := lang.NewSymbol("double-array") + sym_double_QMARK_ := lang.NewSymbol("double?") + sym_doubles := lang.NewSymbol("doubles") + sym_drop := lang.NewSymbol("drop") + sym_drop_DASH_last := lang.NewSymbol("drop-last") + sym_drop_DASH_while := lang.NewSymbol("drop-while") + sym_e := lang.NewSymbol("e") + sym_elide_DASH_top_DASH_frames := lang.NewSymbol("elide-top-frames") + sym_else := lang.NewSymbol("else") + sym_emit_DASH_extend_DASH_protocol := lang.NewSymbol("emit-extend-protocol") + sym_emit_DASH_extend_DASH_type := lang.NewSymbol("emit-extend-type") + sym_emit_DASH_hinted_DASH_impl := lang.NewSymbol("emit-hinted-impl") + sym_empty := lang.NewSymbol("empty") + sym_empty_QMARK_ := lang.NewSymbol("empty?") + sym_end := lang.NewSymbol("end") + sym_end_DASH_key := lang.NewSymbol("end-key") + sym_end_DASH_test := lang.NewSymbol("end-test") + sym_ensure := lang.NewSymbol("ensure") + sym_ensure_DASH_reduced := lang.NewSymbol("ensure-reduced") + sym_enumeration_DASH_seq := lang.NewSymbol("enumeration-seq") + sym_env := lang.NewSymbol("env") + sym_eof_DASH_error_QMARK_ := lang.NewSymbol("eof-error?") + sym_eof_DASH_value := lang.NewSymbol("eof-value") + sym_error_DASH_handler := lang.NewSymbol("error-handler") + sym_error_DASH_mode := lang.NewSymbol("error-mode") + sym_eval := lang.NewSymbol("eval") + sym_even_QMARK_ := lang.NewSymbol("even?") + sym_every_DASH_pred := lang.NewSymbol("every-pred") + sym_every_QMARK_ := lang.NewSymbol("every?") + sym_ex := lang.NewSymbol("ex") + sym_ex_DASH_cause := lang.NewSymbol("ex-cause") + sym_ex_DASH_data := lang.NewSymbol("ex-data") + sym_ex_DASH_info := lang.NewSymbol("ex-info") + sym_ex_DASH_message := lang.NewSymbol("ex-message") + sym_executor := lang.NewSymbol("executor") + sym_expr := lang.NewSymbol("expr") + sym_expr_DASH_sym := lang.NewSymbol("expr-sym") + sym_exprs := lang.NewSymbol("exprs") + sym_exprs_STAR_ := lang.NewSymbol("exprs*") + sym_extend := lang.NewSymbol("extend") + sym_extend_DASH_protocol := lang.NewSymbol("extend-protocol") + sym_extend_DASH_type := lang.NewSymbol("extend-type") + sym_f := lang.NewSymbol("f") + sym_false_QMARK_ := lang.NewSymbol("false?") + sym_ffirst := lang.NewSymbol("ffirst") + sym_file_DASH_seq := lang.NewSymbol("file-seq") + sym_filter := lang.NewSymbol("filter") + sym_filter_DASH_key := lang.NewSymbol("filter-key") + sym_filters := lang.NewSymbol("filters") + sym_filterv := lang.NewSymbol("filterv") + sym_finally := lang.NewSymbol("finally") + sym_find := lang.NewSymbol("find") + sym_find_DASH_keyword := lang.NewSymbol("find-keyword") + sym_find_DASH_ns := lang.NewSymbol("find-ns") + sym_find_DASH_var := lang.NewSymbol("find-var") + sym_first := lang.NewSymbol("first") + sym_fits_DASH_table_QMARK_ := lang.NewSymbol("fits-table?") + sym_flags_DASH_ignored_DASH_for_DASH_now := lang.NewSymbol("flags-ignored-for-now") + sym_flatten := lang.NewSymbol("flatten") + sym_float := lang.NewSymbol("float") + sym_float_DASH_array := lang.NewSymbol("float-array") + sym_float_QMARK_ := lang.NewSymbol("float?") + sym_floatCast := lang.NewSymbol("floatCast") + sym_floats := lang.NewSymbol("floats") + sym_flush := lang.NewSymbol("flush") + sym_fmt := lang.NewSymbol("fmt") + sym_fn := lang.NewSymbol("fn") + sym_fn_STAR_ := lang.NewSymbol("fn*") + sym_fn_DASH_tail := lang.NewSymbol("fn-tail") + sym_fn_QMARK_ := lang.NewSymbol("fn?") + sym_fnext := lang.NewSymbol("fnext") + sym_fnil := lang.NewSymbol("fnil") + sym_fns := lang.NewSymbol("fns") + sym_fnspecs := lang.NewSymbol("fnspecs") + sym_fnspecs_STAR_ := lang.NewSymbol("fnspecs*") + sym_fntail := lang.NewSymbol("fntail") + sym_for := lang.NewSymbol("for") + sym_force := lang.NewSymbol("force") + sym_form := lang.NewSymbol("form") + sym_format := lang.NewSymbol("format") + sym_forms := lang.NewSymbol("forms") + sym_frequencies := lang.NewSymbol("frequencies") + sym_from := lang.NewSymbol("from") + sym_fs := lang.NewSymbol("fs") + sym_fs__1__auto__ := lang.NewSymbol("fs__1__auto__") + sym_fun := lang.NewSymbol("fun") + sym_func := lang.NewSymbol("func") + sym_fut := lang.NewSymbol("fut") + sym_future := lang.NewSymbol("future") + sym_future_DASH_call := lang.NewSymbol("future-call") + sym_future_DASH_cancel := lang.NewSymbol("future-cancel") + sym_future_DASH_cancelled_QMARK_ := lang.NewSymbol("future-cancelled?") + sym_future_DASH_done_QMARK_ := lang.NewSymbol("future-done?") + sym_future_QMARK_ := lang.NewSymbol("future?") + sym_g := lang.NewSymbol("g") + sym_gen_DASH_class := lang.NewSymbol("gen-class") + sym_gensym := lang.NewSymbol("gensym") + sym_get := lang.NewSymbol("get") + sym_get_DASH_in := lang.NewSymbol("get-in") + sym_get_DASH_method := lang.NewSymbol("get-method") + sym_get_DASH_thread_DASH_bindings := lang.NewSymbol("get-thread-bindings") + sym_get_DASH_validator := lang.NewSymbol("get-validator") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT__STAR_MultiFn := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.*MultiFn") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT__STAR_Var := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.*Var") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Abs := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Abs") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_FindNamespace := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.FindNamespace") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_ISeq := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.ISeq") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Identical := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Identical") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Import := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Import") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_IsReduced := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.IsReduced") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_LockingTransaction := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.LockingTransaction") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_NewIllegalArgumentError := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewIllegalArgumentError") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_NewLazySeq := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewLazySeq") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_NewMultiFn := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewMultiFn") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_NewPersistentArrayMapAsIfByAssoc := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewPersistentArrayMapAsIfByAssoc") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_PopThreadBindings := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.PopThreadBindings") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_PushThreadBindings := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.PushThreadBindings") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Volatile := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Volatile") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT := lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT") + sym_global_DASH_hierarchy := lang.NewSymbol("global-hierarchy") + sym_glojure_DOT_core := lang.NewSymbol("glojure.core") + sym_glojure_DOT_core_DOT_protocols := lang.NewSymbol("glojure.core.protocols") + sym_glojure_DOT_core_SLASH__STAR_in_STAR_ := lang.NewSymbol("glojure.core/*in*") + sym_glojure_DOT_core_SLASH__STAR_loaded_DASH_libs_STAR_ := lang.NewSymbol("glojure.core/*loaded-libs*") + sym_glojure_DOT_core_SLASH__STAR_math_DASH_context_STAR_ := lang.NewSymbol("glojure.core/*math-context*") + sym_glojure_DOT_core_SLASH__STAR_out_STAR_ := lang.NewSymbol("glojure.core/*out*") + sym_glojure_DOT_core_SLASH__DASH_ := lang.NewSymbol("glojure.core/-") + sym_glojure_DOT_core_SLASH__DASH__GT_ := lang.NewSymbol("glojure.core/->") + sym_glojure_DOT_core_SLASH__DASH__GT__GT_ := lang.NewSymbol("glojure.core/->>") + sym_glojure_DOT_core_SLASH__DASH_protocols := lang.NewSymbol("glojure.core/-protocols") + sym_glojure_DOT_core_SLASH__SLASH_ := lang.NewSymbol("glojure.core//") + sym_glojure_DOT_core_SLASH__LT_ := lang.NewSymbol("glojure.core/<") + sym_glojure_DOT_core_SLASH__EQ_ := lang.NewSymbol("glojure.core/=") + sym_glojure_DOT_core_SLASH_Aclone := lang.NewSymbol("glojure.core/Aclone") + sym_glojure_DOT_core_SLASH_AddMethod := lang.NewSymbol("glojure.core/AddMethod") + sym_glojure_DOT_core_SLASH_Aget := lang.NewSymbol("glojure.core/Aget") + sym_glojure_DOT_core_SLASH_Alength := lang.NewSymbol("glojure.core/Alength") + sym_glojure_DOT_core_SLASH_Array := lang.NewSymbol("glojure.core/Array") + sym_glojure_DOT_core_SLASH_Aset := lang.NewSymbol("glojure.core/Aset") + sym_glojure_DOT_core_SLASH_AssertionError := lang.NewSymbol("glojure.core/AssertionError") + sym_glojure_DOT_core_SLASH_BooleanArray := lang.NewSymbol("glojure.core/BooleanArray") + sym_glojure_DOT_core_SLASH_BooleanCast := lang.NewSymbol("glojure.core/BooleanCast") + sym_glojure_DOT_core_SLASH_Booleans := lang.NewSymbol("glojure.core/Booleans") + sym_glojure_DOT_core_SLASH_ByteArray := lang.NewSymbol("glojure.core/ByteArray") + sym_glojure_DOT_core_SLASH_Bytes := lang.NewSymbol("glojure.core/Bytes") + sym_glojure_DOT_core_SLASH_CharArray := lang.NewSymbol("glojure.core/CharArray") + sym_glojure_DOT_core_SLASH_Chars := lang.NewSymbol("glojure.core/Chars") + sym_glojure_DOT_core_SLASH_Count := lang.NewSymbol("glojure.core/Count") + sym_glojure_DOT_core_SLASH_DecP := lang.NewSymbol("glojure.core/DecP") + sym_glojure_DOT_core_SLASH_DoubleArray := lang.NewSymbol("glojure.core/DoubleArray") + sym_glojure_DOT_core_SLASH_DoubleCast := lang.NewSymbol("glojure.core/DoubleCast") + sym_glojure_DOT_core_SLASH_Doubles := lang.NewSymbol("glojure.core/Doubles") + sym_glojure_DOT_core_SLASH_Equiv := lang.NewSymbol("glojure.core/Equiv") + sym_glojure_DOT_core_SLASH_FloatArray := lang.NewSymbol("glojure.core/FloatArray") + sym_glojure_DOT_core_SLASH_Floats := lang.NewSymbol("glojure.core/Floats") + sym_glojure_DOT_core_SLASH_Get := lang.NewSymbol("glojure.core/Get") + sym_glojure_DOT_core_SLASH_Gt := lang.NewSymbol("glojure.core/Gt") + sym_glojure_DOT_core_SLASH_Gte := lang.NewSymbol("glojure.core/Gte") + sym_glojure_DOT_core_SLASH_IllegalStateException := lang.NewSymbol("glojure.core/IllegalStateException") + sym_glojure_DOT_core_SLASH_IncP := lang.NewSymbol("glojure.core/IncP") + sym_glojure_DOT_core_SLASH_IntArray := lang.NewSymbol("glojure.core/IntArray") + sym_glojure_DOT_core_SLASH_Ints := lang.NewSymbol("glojure.core/Ints") + sym_glojure_DOT_core_SLASH_IsNeg := lang.NewSymbol("glojure.core/IsNeg") + sym_glojure_DOT_core_SLASH_IsPos := lang.NewSymbol("glojure.core/IsPos") + sym_glojure_DOT_core_SLASH_IsZero := lang.NewSymbol("glojure.core/IsZero") + sym_glojure_DOT_core_SLASH_LongArray := lang.NewSymbol("glojure.core/LongArray") + sym_glojure_DOT_core_SLASH_LongCast := lang.NewSymbol("glojure.core/LongCast") + sym_glojure_DOT_core_SLASH_Longs := lang.NewSymbol("glojure.core/Longs") + sym_glojure_DOT_core_SLASH_Lt := lang.NewSymbol("glojure.core/Lt") + sym_glojure_DOT_core_SLASH_Lte := lang.NewSymbol("glojure.core/Lte") + sym_glojure_DOT_core_SLASH_Not := lang.NewSymbol("glojure.core/Not") + sym_glojure_DOT_core_SLASH_Nth := lang.NewSymbol("glojure.core/Nth") + sym_glojure_DOT_core_SLASH_Num := lang.NewSymbol("glojure.core/Num") + sym_glojure_DOT_core_SLASH_Object_array := lang.NewSymbol("glojure.core/Object_array") + sym_glojure_DOT_core_SLASH_Quotient := lang.NewSymbol("glojure.core/Quotient") + sym_glojure_DOT_core_SLASH_Remainder := lang.NewSymbol("glojure.core/Remainder") + sym_glojure_DOT_core_SLASH_RunInTransaction := lang.NewSymbol("glojure.core/RunInTransaction") + sym_glojure_DOT_core_SLASH_ShiftLeft := lang.NewSymbol("glojure.core/ShiftLeft") + sym_glojure_DOT_core_SLASH_ShiftRight := lang.NewSymbol("glojure.core/ShiftRight") + sym_glojure_DOT_core_SLASH_ShortArray := lang.NewSymbol("glojure.core/ShortArray") + sym_glojure_DOT_core_SLASH_Shorts := lang.NewSymbol("glojure.core/Shorts") + sym_glojure_DOT_core_SLASH_UncheckedAdd := lang.NewSymbol("glojure.core/UncheckedAdd") + sym_glojure_DOT_core_SLASH_UncheckedByteCast := lang.NewSymbol("glojure.core/UncheckedByteCast") + sym_glojure_DOT_core_SLASH_UncheckedCharCast := lang.NewSymbol("glojure.core/UncheckedCharCast") + sym_glojure_DOT_core_SLASH_UncheckedDec := lang.NewSymbol("glojure.core/UncheckedDec") + sym_glojure_DOT_core_SLASH_UncheckedDoubleCast := lang.NewSymbol("glojure.core/UncheckedDoubleCast") + sym_glojure_DOT_core_SLASH_UncheckedFloatCast := lang.NewSymbol("glojure.core/UncheckedFloatCast") + sym_glojure_DOT_core_SLASH_UncheckedIntCast := lang.NewSymbol("glojure.core/UncheckedIntCast") + sym_glojure_DOT_core_SLASH_UncheckedIntDivide := lang.NewSymbol("glojure.core/UncheckedIntDivide") + sym_glojure_DOT_core_SLASH_UncheckedLongCast := lang.NewSymbol("glojure.core/UncheckedLongCast") + sym_glojure_DOT_core_SLASH_UncheckedShortCast := lang.NewSymbol("glojure.core/UncheckedShortCast") + sym_glojure_DOT_core_SLASH_Unchecked_inc := lang.NewSymbol("glojure.core/Unchecked_inc") + sym_glojure_DOT_core_SLASH_Unchecked_int_add := lang.NewSymbol("glojure.core/Unchecked_int_add") + sym_glojure_DOT_core_SLASH_Unchecked_int_dec := lang.NewSymbol("glojure.core/Unchecked_int_dec") + sym_glojure_DOT_core_SLASH_Unchecked_int_inc := lang.NewSymbol("glojure.core/Unchecked_int_inc") + sym_glojure_DOT_core_SLASH_Unchecked_int_multiply := lang.NewSymbol("glojure.core/Unchecked_int_multiply") + sym_glojure_DOT_core_SLASH_Unchecked_int_negate := lang.NewSymbol("glojure.core/Unchecked_int_negate") + sym_glojure_DOT_core_SLASH_Unchecked_int_remainder := lang.NewSymbol("glojure.core/Unchecked_int_remainder") + sym_glojure_DOT_core_SLASH_Unchecked_int_subtract := lang.NewSymbol("glojure.core/Unchecked_int_subtract") + sym_glojure_DOT_core_SLASH_Unchecked_minus := lang.NewSymbol("glojure.core/Unchecked_minus") + sym_glojure_DOT_core_SLASH_Unchecked_multiply := lang.NewSymbol("glojure.core/Unchecked_multiply") + sym_glojure_DOT_core_SLASH_UnsignedShiftRight := lang.NewSymbol("glojure.core/UnsignedShiftRight") + sym_glojure_DOT_core_SLASH_aclone := lang.NewSymbol("glojure.core/aclone") + sym_glojure_DOT_core_SLASH_aget := lang.NewSymbol("glojure.core/aget") + sym_glojure_DOT_core_SLASH_alength := lang.NewSymbol("glojure.core/alength") + sym_glojure_DOT_core_SLASH_alter_DASH_meta_BANG_ := lang.NewSymbol("glojure.core/alter-meta!") + sym_glojure_DOT_core_SLASH_and := lang.NewSymbol("glojure.core/and") + sym_glojure_DOT_core_SLASH_apply := lang.NewSymbol("glojure.core/apply") + sym_glojure_DOT_core_SLASH_args := lang.NewSymbol("glojure.core/args") + sym_glojure_DOT_core_SLASH_aset := lang.NewSymbol("glojure.core/aset") + sym_glojure_DOT_core_SLASH_assert := lang.NewSymbol("glojure.core/assert") + sym_glojure_DOT_core_SLASH_assert_DASH_args := lang.NewSymbol("glojure.core/assert-args") + sym_glojure_DOT_core_SLASH_assoc := lang.NewSymbol("glojure.core/assoc") + sym_glojure_DOT_core_SLASH_assoc_DASH_in := lang.NewSymbol("glojure.core/assoc-in") + sym_glojure_DOT_core_SLASH_atom := lang.NewSymbol("glojure.core/atom") + sym_glojure_DOT_core_SLASH_binding := lang.NewSymbol("glojure.core/binding") + sym_glojure_DOT_core_SLASH_bound_DASH_fn_STAR_ := lang.NewSymbol("glojure.core/bound-fn*") + sym_glojure_DOT_core_SLASH_c := lang.NewSymbol("glojure.core/c") + sym_glojure_DOT_core_SLASH_chunk := lang.NewSymbol("glojure.core/chunk") + sym_glojure_DOT_core_SLASH_chunk_DASH_append := lang.NewSymbol("glojure.core/chunk-append") + sym_glojure_DOT_core_SLASH_chunk_DASH_buffer := lang.NewSymbol("glojure.core/chunk-buffer") + sym_glojure_DOT_core_SLASH_chunk_DASH_cons := lang.NewSymbol("glojure.core/chunk-cons") + sym_glojure_DOT_core_SLASH_chunk_DASH_first := lang.NewSymbol("glojure.core/chunk-first") + sym_glojure_DOT_core_SLASH_chunk_DASH_rest := lang.NewSymbol("glojure.core/chunk-rest") + sym_glojure_DOT_core_SLASH_chunked_DASH_seq_QMARK_ := lang.NewSymbol("glojure.core/chunked-seq?") + sym_glojure_DOT_core_SLASH_class := lang.NewSymbol("glojure.core/class") + sym_glojure_DOT_core_SLASH_commute := lang.NewSymbol("glojure.core/commute") + sym_glojure_DOT_core_SLASH_compare := lang.NewSymbol("glojure.core/compare") + sym_glojure_DOT_core_SLASH_concat := lang.NewSymbol("glojure.core/concat") + sym_glojure_DOT_core_SLASH_cond := lang.NewSymbol("glojure.core/cond") + sym_glojure_DOT_core_SLASH_condp := lang.NewSymbol("glojure.core/condp") + sym_glojure_DOT_core_SLASH_conj := lang.NewSymbol("glojure.core/conj") + sym_glojure_DOT_core_SLASH_cons := lang.NewSymbol("glojure.core/cons") + sym_glojure_DOT_core_SLASH_count := lang.NewSymbol("glojure.core/count") + sym_glojure_DOT_core_SLASH_create_DASH_struct := lang.NewSymbol("glojure.core/create-struct") + sym_glojure_DOT_core_SLASH_defmulti := lang.NewSymbol("glojure.core/defmulti") + sym_glojure_DOT_core_SLASH_defn := lang.NewSymbol("glojure.core/defn") + sym_glojure_DOT_core_SLASH_deref := lang.NewSymbol("glojure.core/deref") + sym_glojure_DOT_core_SLASH_dosync := lang.NewSymbol("glojure.core/dosync") + sym_glojure_DOT_core_SLASH_double := lang.NewSymbol("glojure.core/double") + sym_glojure_DOT_core_SLASH_equiv := lang.NewSymbol("glojure.core/equiv") + sym_glojure_DOT_core_SLASH_extend := lang.NewSymbol("glojure.core/extend") + sym_glojure_DOT_core_SLASH_extend_DASH_type := lang.NewSymbol("glojure.core/extend-type") + sym_glojure_DOT_core_SLASH_first := lang.NewSymbol("glojure.core/first") + sym_glojure_DOT_core_SLASH_fn := lang.NewSymbol("glojure.core/fn") + sym_glojure_DOT_core_SLASH_future_DASH_call := lang.NewSymbol("glojure.core/future-call") + sym_glojure_DOT_core_SLASH_gen_DASH_class := lang.NewSymbol("glojure.core/gen-class") + sym_glojure_DOT_core_SLASH_get := lang.NewSymbol("glojure.core/get") + sym_glojure_DOT_core_SLASH_hash_DASH_map := lang.NewSymbol("glojure.core/hash-map") + sym_glojure_DOT_core_SLASH_i := lang.NewSymbol("glojure.core/i") + sym_glojure_DOT_core_SLASH_identical := lang.NewSymbol("glojure.core/identical") + sym_glojure_DOT_core_SLASH_if_DASH_let := lang.NewSymbol("glojure.core/if-let") + sym_glojure_DOT_core_SLASH_if_DASH_not := lang.NewSymbol("glojure.core/if-not") + sym_glojure_DOT_core_SLASH_if_DASH_some := lang.NewSymbol("glojure.core/if-some") + sym_glojure_DOT_core_SLASH_in_DASH_ns := lang.NewSymbol("glojure.core/in-ns") + sym_glojure_DOT_core_SLASH_instance_QMARK_ := lang.NewSymbol("glojure.core/instance?") + sym_glojure_DOT_core_SLASH_int := lang.NewSymbol("glojure.core/int") + sym_glojure_DOT_core_SLASH_keyword := lang.NewSymbol("glojure.core/keyword") + sym_glojure_DOT_core_SLASH_lazy_DASH_seq := lang.NewSymbol("glojure.core/lazy-seq") + sym_glojure_DOT_core_SLASH_let := lang.NewSymbol("glojure.core/let") + sym_glojure_DOT_core_SLASH_long := lang.NewSymbol("glojure.core/long") + sym_glojure_DOT_core_SLASH_loop := lang.NewSymbol("glojure.core/loop") + sym_glojure_DOT_core_SLASH_merge := lang.NewSymbol("glojure.core/merge") + sym_glojure_DOT_core_SLASH_meta := lang.NewSymbol("glojure.core/meta") + sym_glojure_DOT_core_SLASH_next := lang.NewSymbol("glojure.core/next") + sym_glojure_DOT_core_SLASH_nf := lang.NewSymbol("glojure.core/nf") + sym_glojure_DOT_core_SLASH_nil_QMARK_ := lang.NewSymbol("glojure.core/nil?") + sym_glojure_DOT_core_SLASH_not := lang.NewSymbol("glojure.core/not") + sym_glojure_DOT_core_SLASH_nth := lang.NewSymbol("glojure.core/nth") + sym_glojure_DOT_core_SLASH_or := lang.NewSymbol("glojure.core/or") + sym_glojure_DOT_core_SLASH_pcalls := lang.NewSymbol("glojure.core/pcalls") + sym_glojure_DOT_core_SLASH_pop_DASH_thread_DASH_bindings := lang.NewSymbol("glojure.core/pop-thread-bindings") + sym_glojure_DOT_core_SLASH_pr_DASH_str := lang.NewSymbol("glojure.core/pr-str") + sym_glojure_DOT_core_SLASH_prn := lang.NewSymbol("glojure.core/prn") + sym_glojure_DOT_core_SLASH_push_DASH_thread_DASH_bindings := lang.NewSymbol("glojure.core/push-thread-bindings") + sym_glojure_DOT_core_SLASH_refer := lang.NewSymbol("glojure.core/refer") + sym_glojure_DOT_core_SLASH_rest := lang.NewSymbol("glojure.core/rest") + sym_glojure_DOT_core_SLASH_seq := lang.NewSymbol("glojure.core/seq") + sym_glojure_DOT_core_SLASH_seq_QMARK_ := lang.NewSymbol("glojure.core/seq?") + sym_glojure_DOT_core_SLASH_str := lang.NewSymbol("glojure.core/str") + sym_glojure_DOT_core_SLASH_swap_BANG_ := lang.NewSymbol("glojure.core/swap!") + sym_glojure_DOT_core_SLASH_sync := lang.NewSymbol("glojure.core/sync") + sym_glojure_DOT_core_SLASH_to_DASH_array := lang.NewSymbol("glojure.core/to-array") + sym_glojure_DOT_core_SLASH_unchecked_DASH_inc := lang.NewSymbol("glojure.core/unchecked-inc") + sym_glojure_DOT_core_SLASH_unchecked_DASH_inc_DASH_int := lang.NewSymbol("glojure.core/unchecked-inc-int") + sym_glojure_DOT_core_SLASH_unquote := lang.NewSymbol("glojure.core/unquote") + sym_glojure_DOT_core_SLASH_unquote_DASH_splicing := lang.NewSymbol("glojure.core/unquote-splicing") + sym_glojure_DOT_core_SLASH_when := lang.NewSymbol("glojure.core/when") + sym_glojure_DOT_core_SLASH_when_DASH_first := lang.NewSymbol("glojure.core/when-first") + sym_glojure_DOT_core_SLASH_when_DASH_let := lang.NewSymbol("glojure.core/when-let") + sym_glojure_DOT_core_SLASH_when_DASH_not := lang.NewSymbol("glojure.core/when-not") + sym_glojure_DOT_core_SLASH_with_DASH_bindings_STAR_ := lang.NewSymbol("glojure.core/with-bindings*") + sym_glojure_DOT_core_SLASH_with_DASH_loading_DASH_context := lang.NewSymbol("glojure.core/with-loading-context") + sym_glojure_DOT_core_SLASH_with_DASH_open := lang.NewSymbol("glojure.core/with-open") + sym_glojure_DOT_core_SLASH_with_DASH_redefs_DASH_fn := lang.NewSymbol("glojure.core/with-redefs-fn") + sym_glojure_DOT_go_DOT_io := lang.NewSymbol("glojure.go.io") + sym_glojure_DOT_lang_DOT_Delay := lang.NewSymbol("glojure.lang.Delay") + sym_glojure_DOT_lang_DOT_IChunk := lang.NewSymbol("glojure.lang.IChunk") + sym_glojure_DOT_lang_DOT_LineNumberingPushbackReader_DOT_ := lang.NewSymbol("glojure.lang.LineNumberingPushbackReader.") + sym_glojure_DOT_lang_DOT_LockingTransaction_SLASH_isRunning := lang.NewSymbol("glojure.lang.LockingTransaction/isRunning") + sym_glojure_DOT_lang_DOT_PersistentArrayMap_SLASH_EMPTY := lang.NewSymbol("glojure.lang.PersistentArrayMap/EMPTY") + sym_glojure_DOT_lang_DOT_Util := lang.NewSymbol("glojure.lang.Util") + sym_glojure_DOT_string := lang.NewSymbol("glojure.string") + sym_group_DASH_by := lang.NewSymbol("group-by") + sym_h := lang.NewSymbol("h") + sym_halt_DASH_when := lang.NewSymbol("halt-when") + sym_handler_DASH_fn := lang.NewSymbol("handler-fn") + sym_hash := lang.NewSymbol("hash") + sym_hash_DASH_basis := lang.NewSymbol("hash-basis") + sym_hash_DASH_map := lang.NewSymbol("hash-map") + sym_hash_DASH_ordered_DASH_coll := lang.NewSymbol("hash-ordered-coll") + sym_hash_DASH_set := lang.NewSymbol("hash-set") + sym_hash_DASH_unordered_DASH_coll := lang.NewSymbol("hash-unordered-coll") + sym_hashes := lang.NewSymbol("hashes") + sym_ident_QMARK_ := lang.NewSymbol("ident?") + sym_identical_QMARK_ := lang.NewSymbol("identical?") + sym_identity := lang.NewSymbol("identity") + sym_idx := lang.NewSymbol("idx") + sym_idx2 := lang.NewSymbol("idx2") + sym_idx2__3__auto__ := lang.NewSymbol("idx2__3__auto__") + sym_idx__1__auto__ := lang.NewSymbol("idx__1__auto__") + sym_idxs := lang.NewSymbol("idxs") + sym_idxv := lang.NewSymbol("idxv") + sym_idxv__4__auto__ := lang.NewSymbol("idxv__4__auto__") + sym_if := lang.NewSymbol("if") + sym_if_DASH_let := lang.NewSymbol("if-let") + sym_if_DASH_not := lang.NewSymbol("if-not") + sym_if_DASH_some := lang.NewSymbol("if-some") + sym_ifn_QMARK_ := lang.NewSymbol("ifn?") + sym_import := lang.NewSymbol("import") + sym_import_DASH_symbols_DASH_or_DASH_lists := lang.NewSymbol("import-symbols-or-lists") + sym_inc := lang.NewSymbol("inc") + sym_inc_TICK_ := lang.NewSymbol("inc'") + sym_index := lang.NewSymbol("index") + sym_indexed_QMARK_ := lang.NewSymbol("indexed?") + sym_infinite_QMARK_ := lang.NewSymbol("infinite?") + sym_init := lang.NewSymbol("init") + sym_init_DASH_val_DASH_or_DASH_seq := lang.NewSymbol("init-val-or-seq") + sym_initk := lang.NewSymbol("initk") + sym_inits := lang.NewSymbol("inits") + sym_inst := lang.NewSymbol("inst") + sym_inst_DASH_ms := lang.NewSymbol("inst-ms") + sym_inst_QMARK_ := lang.NewSymbol("inst?") + sym_instance_QMARK_ := lang.NewSymbol("instance?") + sym_int := lang.NewSymbol("int") + sym_int_DASH_array := lang.NewSymbol("int-array") + sym_int_QMARK_ := lang.NewSymbol("int?") + sym_intCast := lang.NewSymbol("intCast") + sym_integer_QMARK_ := lang.NewSymbol("integer?") + sym_interleave := lang.NewSymbol("interleave") + sym_intern := lang.NewSymbol("intern") + sym_interpose := lang.NewSymbol("interpose") + sym_into := lang.NewSymbol("into") + sym_into_DASH_array := lang.NewSymbol("into-array") + sym_into1 := lang.NewSymbol("into1") + sym_ints := lang.NewSymbol("ints") + sym_io_BANG_ := lang.NewSymbol("io!") + sym_iref := lang.NewSymbol("iref") + sym_isa_QMARK_ := lang.NewSymbol("isa?") + sym_items := lang.NewSymbol("items") + sym_iter := lang.NewSymbol("iter") + sym_iter__0__auto__ := lang.NewSymbol("iter__0__auto__") + sym_iterate := lang.NewSymbol("iterate") + sym_iteration := lang.NewSymbol("iteration") + sym_iterator_DASH_seq := lang.NewSymbol("iterator-seq") + sym_iterys__0__auto__ := lang.NewSymbol("iterys__0__auto__") + sym_java_DOT_io_DOT_StringReader_DOT_ := lang.NewSymbol("java.io.StringReader.") + sym_java_DOT_math_DOT_MathContext_DOT_ := lang.NewSymbol("java.math.MathContext.") + sym_java_DOT_math_DOT_RoundingMode := lang.NewSymbol("java.math.RoundingMode") + sym_juxt := lang.NewSymbol("juxt") + sym_k := lang.NewSymbol("k") + sym_keep := lang.NewSymbol("keep") + sym_keep_DASH_indexed := lang.NewSymbol("keep-indexed") + sym_key := lang.NewSymbol("key") + sym_keyfn := lang.NewSymbol("keyfn") + sym_keys := lang.NewSymbol("keys") + sym_keyseq := lang.NewSymbol("keyseq") + sym_keyvals := lang.NewSymbol("keyvals") + sym_keyword := lang.NewSymbol("keyword") + sym_keyword_QMARK_ := lang.NewSymbol("keyword?") + sym_kf := lang.NewSymbol("kf") + sym_ks := lang.NewSymbol("ks") + sym_kv_DASH_reduce := lang.NewSymbol("kv-reduce") + sym_kvs := lang.NewSymbol("kvs") + sym_l__1__auto__ := lang.NewSymbol("l__1__auto__") + sym_last := lang.NewSymbol("last") + sym_lazy_DASH_cat := lang.NewSymbol("lazy-cat") + sym_lazy_DASH_seq := lang.NewSymbol("lazy-seq") + sym_len := lang.NewSymbol("len") + sym_let := lang.NewSymbol("let") + sym_let_STAR_ := lang.NewSymbol("let*") + sym_letfn := lang.NewSymbol("letfn") + sym_letfn_STAR_ := lang.NewSymbol("letfn*") + sym_lib := lang.NewSymbol("lib") + sym_libspec_QMARK_ := lang.NewSymbol("libspec?") + sym_lift_DASH_ns := lang.NewSymbol("lift-ns") + sym_line_DASH_seq := lang.NewSymbol("line-seq") + sym_list := lang.NewSymbol("list") + sym_list_STAR_ := lang.NewSymbol("list*") + sym_list_QMARK_ := lang.NewSymbol("list?") + sym_load := lang.NewSymbol("load") + sym_load_DASH_all := lang.NewSymbol("load-all") + sym_load_DASH_data_DASH_reader_DASH_file := lang.NewSymbol("load-data-reader-file") + sym_load_DASH_data_DASH_readers := lang.NewSymbol("load-data-readers") + sym_load_DASH_file := lang.NewSymbol("load-file") + sym_load_DASH_lib := lang.NewSymbol("load-lib") + sym_load_DASH_libs := lang.NewSymbol("load-libs") + sym_load_DASH_one := lang.NewSymbol("load-one") + sym_load_DASH_reader := lang.NewSymbol("load-reader") + sym_load_DASH_string := lang.NewSymbol("load-string") + sym_loaded_DASH_libs := lang.NewSymbol("loaded-libs") + sym_loading__0__auto__ := lang.NewSymbol("loading__0__auto__") + sym_lockee__0__auto__ := lang.NewSymbol("lockee__0__auto__") + sym_locking := lang.NewSymbol("locking") + sym_locklocal__1__auto__ := lang.NewSymbol("locklocal__1__auto__") + sym_long := lang.NewSymbol("long") + sym_long_DASH_array := lang.NewSymbol("long-array") + sym_longs := lang.NewSymbol("longs") + sym_loop := lang.NewSymbol("loop") + sym_loop_STAR_ := lang.NewSymbol("loop*") + sym_m := lang.NewSymbol("m") + sym_macroexpand := lang.NewSymbol("macroexpand") + sym_macroexpand_DASH_1 := lang.NewSymbol("macroexpand-1") + sym_make_DASH_array := lang.NewSymbol("make-array") + sym_make_DASH_hierarchy := lang.NewSymbol("make-hierarchy") + sym_map := lang.NewSymbol("map") + sym_map_DASH_entry_QMARK_ := lang.NewSymbol("map-entry?") + sym_map_DASH_indexed := lang.NewSymbol("map-indexed") + sym_map_QMARK_ := lang.NewSymbol("map?") + sym_mapcat := lang.NewSymbol("mapcat") + sym_mappings := lang.NewSymbol("mappings") + sym_maps := lang.NewSymbol("maps") + sym_mapv := lang.NewSymbol("mapv") + sym_mask := lang.NewSymbol("mask") + sym_math_DOT_IsNaN := lang.NewSymbol("math.IsNaN") + sym_max := lang.NewSymbol("max") + sym_max_DASH_key := lang.NewSymbol("max-key") + sym_max_DASH_mask_DASH_bits := lang.NewSymbol("max-mask-bits") + sym_max_DASH_switch_DASH_table_DASH_size := lang.NewSymbol("max-switch-table-size") + sym_maybe_DASH_destructured := lang.NewSymbol("maybe-destructured") + sym_maybe_DASH_min_DASH_hash := lang.NewSymbol("maybe-min-hash") + sym_maybe_DASH_p := lang.NewSymbol("maybe-p") + sym_memfn := lang.NewSymbol("memfn") + sym_memoize := lang.NewSymbol("memoize") + sym_merge := lang.NewSymbol("merge") + sym_merge_DASH_hash_DASH_collisions := lang.NewSymbol("merge-hash-collisions") + sym_merge_DASH_with := lang.NewSymbol("merge-with") + sym_message := lang.NewSymbol("message") + sym_meta := lang.NewSymbol("meta") + sym_metadata_DASH_map := lang.NewSymbol("metadata-map") + sym_method := lang.NewSymbol("method") + sym_methods := lang.NewSymbol("methods") + sym_min := lang.NewSymbol("min") + sym_min_DASH_key := lang.NewSymbol("min-key") + sym_minus := lang.NewSymbol("minus") + sym_minusP := lang.NewSymbol("minusP") + sym_mix_DASH_collection_DASH_hash := lang.NewSymbol("mix-collection-hash") + sym_mk_DASH_bound_DASH_fn := lang.NewSymbol("mk-bound-fn") + sym_mod := lang.NewSymbol("mod") + sym_mode_DASH_keyword := lang.NewSymbol("mode-keyword") + sym_monitor_DASH_enter := lang.NewSymbol("monitor-enter") + sym_monitor_DASH_exit := lang.NewSymbol("monitor-exit") + sym_more := lang.NewSymbol("more") + sym_more_DASH_dims := lang.NewSymbol("more-dims") + sym_msg := lang.NewSymbol("msg") + sym_multifn := lang.NewSymbol("multifn") + sym_multiply := lang.NewSymbol("multiply") + sym_multiplyP := lang.NewSymbol("multiplyP") + sym_n := lang.NewSymbol("n") + sym_n_DASH_or_DASH_q := lang.NewSymbol("n-or-q") + sym_n__0__auto__ := lang.NewSymbol("n__0__auto__") + sym_name := lang.NewSymbol("name") + sym_name_DASH_vals_DASH_vec := lang.NewSymbol("name-vals-vec") + sym_name_QMARK_ := lang.NewSymbol("name?") + sym_named := lang.NewSymbol("named") + sym_names := lang.NewSymbol("names") + sym_namespace := lang.NewSymbol("namespace") + sym_namespace_DASH_sym := lang.NewSymbol("namespace-sym") + sym_nary_DASH_inline := lang.NewSymbol("nary-inline") + sym_nat_DASH_int_QMARK_ := lang.NewSymbol("nat-int?") + sym_need_DASH_ns := lang.NewSymbol("need-ns") + sym_neg_DASH_int_QMARK_ := lang.NewSymbol("neg-int?") + sym_neg_QMARK_ := lang.NewSymbol("neg?") + sym_new := lang.NewSymbol("new") + sym_new_DASH_state := lang.NewSymbol("new-state") + sym_newline := lang.NewSymbol("newline") + sym_newval := lang.NewSymbol("newval") + sym_next := lang.NewSymbol("next") + sym_nfirst := lang.NewSymbol("nfirst") + sym_nil_QMARK_ := lang.NewSymbol("nil?") + sym_nnext := lang.NewSymbol("nnext") + sym_normalize_DASH_slurp_DASH_opts := lang.NewSymbol("normalize-slurp-opts") + sym_not := lang.NewSymbol("not") + sym_not_DASH_any_QMARK_ := lang.NewSymbol("not-any?") + sym_not_DASH_empty := lang.NewSymbol("not-empty") + sym_not_DASH_every_QMARK_ := lang.NewSymbol("not-every?") + sym_not_DASH_found := lang.NewSymbol("not-found") + sym_not_EQ_ := lang.NewSymbol("not=") + sym_ns := lang.NewSymbol("ns") + sym_ns_DASH_aliases := lang.NewSymbol("ns-aliases") + sym_ns_DASH_imports := lang.NewSymbol("ns-imports") + sym_ns_DASH_interns := lang.NewSymbol("ns-interns") + sym_ns_DASH_map := lang.NewSymbol("ns-map") + sym_ns_DASH_name := lang.NewSymbol("ns-name") + sym_ns_DASH_publics := lang.NewSymbol("ns-publics") + sym_ns_DASH_refers := lang.NewSymbol("ns-refers") + sym_ns_DASH_resolve := lang.NewSymbol("ns-resolve") + sym_ns_DASH_sym := lang.NewSymbol("ns-sym") + sym_ns_DASH_unalias := lang.NewSymbol("ns-unalias") + sym_ns_DASH_unmap := lang.NewSymbol("ns-unmap") + sym_nth := lang.NewSymbol("nth") + sym_nthnext := lang.NewSymbol("nthnext") + sym_nthrest := lang.NewSymbol("nthrest") + sym_num := lang.NewSymbol("num") + sym_number_QMARK_ := lang.NewSymbol("number?") + sym_numerator := lang.NewSymbol("numerator") + sym_o := lang.NewSymbol("o") + sym_obj := lang.NewSymbol("obj") + sym_object_DASH_array := lang.NewSymbol("object-array") + sym_odd_QMARK_ := lang.NewSymbol("odd?") + sym_oldform := lang.NewSymbol("oldform") + sym_oldval := lang.NewSymbol("oldval") + sym_op := lang.NewSymbol("op") + sym_options := lang.NewSymbol("options") + sym_opts := lang.NewSymbol("opts") + sym_opts_PLUS_sigs := lang.NewSymbol("opts+sigs") + sym_or := lang.NewSymbol("or") + sym_or__0__auto__ := lang.NewSymbol("or__0__auto__") + sym_p := lang.NewSymbol("p") + sym_p1 := lang.NewSymbol("p1") + sym_p2 := lang.NewSymbol("p2") + sym_p3 := lang.NewSymbol("p3") + sym_p__0__auto__ := lang.NewSymbol("p__0__auto__") + sym_pad := lang.NewSymbol("pad") + sym_pairs := lang.NewSymbol("pairs") + sym_params := lang.NewSymbol("params") + sym_params_STAR_ := lang.NewSymbol("params*") + sym_parent := lang.NewSymbol("parent") + sym_parents := lang.NewSymbol("parents") + sym_parse_DASH_boolean := lang.NewSymbol("parse-boolean") + sym_parse_DASH_double := lang.NewSymbol("parse-double") + sym_parse_DASH_impls := lang.NewSymbol("parse-impls") + sym_parse_DASH_long := lang.NewSymbol("parse-long") + sym_parse_DASH_uuid := lang.NewSymbol("parse-uuid") + sym_parsing_DASH_err := lang.NewSymbol("parsing-err") + sym_partial := lang.NewSymbol("partial") + sym_partition := lang.NewSymbol("partition") + sym_partition_DASH_all := lang.NewSymbol("partition-all") + sym_partition_DASH_by := lang.NewSymbol("partition-by") + sym_partitionv := lang.NewSymbol("partitionv") + sym_partitionv_DASH_all := lang.NewSymbol("partitionv-all") + sym_path := lang.NewSymbol("path") + sym_paths := lang.NewSymbol("paths") + sym_pcalls := lang.NewSymbol("pcalls") + sym_peek := lang.NewSymbol("peek") + sym_persistent_BANG_ := lang.NewSymbol("persistent!") + sym_pmap := lang.NewSymbol("pmap") + sym_pop := lang.NewSymbol("pop") + sym_pop_BANG_ := lang.NewSymbol("pop!") + sym_pop_DASH_thread_DASH_bindings := lang.NewSymbol("pop-thread-bindings") + sym_pos_DASH_int_QMARK_ := lang.NewSymbol("pos-int?") + sym_pos_QMARK_ := lang.NewSymbol("pos?") + sym_pr := lang.NewSymbol("pr") + sym_pr_DASH_on := lang.NewSymbol("pr-on") + sym_pr_DASH_str := lang.NewSymbol("pr-str") + sym_precision := lang.NewSymbol("precision") + sym_pred := lang.NewSymbol("pred") + sym_prefer_DASH_method := lang.NewSymbol("prefer-method") + sym_prefers := lang.NewSymbol("prefers") + sym_prefix := lang.NewSymbol("prefix") + sym_prefix_DASH_string := lang.NewSymbol("prefix-string") + sym_prep_DASH_hashes := lang.NewSymbol("prep-hashes") + sym_prep_DASH_ints := lang.NewSymbol("prep-ints") + sym_prependss := lang.NewSymbol("prependss") + sym_prepost_DASH_map_QMARK_ := lang.NewSymbol("prepost-map?") + sym_preserving_DASH_reduced := lang.NewSymbol("preserving-reduced") + sym_print := lang.NewSymbol("print") + sym_print_DASH_args := lang.NewSymbol("print-args") + sym_print_DASH_ctor := lang.NewSymbol("print-ctor") + sym_print_DASH_dup := lang.NewSymbol("print-dup") + sym_print_DASH_initialized := lang.NewSymbol("print-initialized") + sym_print_DASH_map := lang.NewSymbol("print-map") + sym_print_DASH_meta := lang.NewSymbol("print-meta") + sym_print_DASH_method := lang.NewSymbol("print-method") + sym_print_DASH_object := lang.NewSymbol("print-object") + sym_print_DASH_one := lang.NewSymbol("print-one") + sym_print_DASH_prefix_DASH_map := lang.NewSymbol("print-prefix-map") + sym_print_DASH_sequential := lang.NewSymbol("print-sequential") + sym_print_DASH_simple := lang.NewSymbol("print-simple") + sym_print_DASH_str := lang.NewSymbol("print-str") + sym_print_DASH_tagged_DASH_object := lang.NewSymbol("print-tagged-object") + sym_print_DASH_throwable := lang.NewSymbol("print-throwable") + sym_printf := lang.NewSymbol("printf") + sym_println := lang.NewSymbol("println") + sym_println_DASH_str := lang.NewSymbol("println-str") + sym_prn := lang.NewSymbol("prn") + sym_prn_DASH_str := lang.NewSymbol("prn-str") + sym_prob := lang.NewSymbol("prob") + sym_proc := lang.NewSymbol("proc") + sym_promise := lang.NewSymbol("promise") + sym_proto_PLUS_mmaps := lang.NewSymbol("proto+mmaps") + sym_protocol_QMARK_ := lang.NewSymbol("protocol?") + sym_ps := lang.NewSymbol("ps") + sym_push_DASH_thread_DASH_bindings := lang.NewSymbol("push-thread-bindings") + sym_pvalues := lang.NewSymbol("pvalues") + sym_qualified_DASH_ident_QMARK_ := lang.NewSymbol("qualified-ident?") + sym_qualified_DASH_keyword_QMARK_ := lang.NewSymbol("qualified-keyword?") + sym_qualified_DASH_symbol_QMARK_ := lang.NewSymbol("qualified-symbol?") + sym_quot := lang.NewSymbol("quot") + sym_quote := lang.NewSymbol("quote") + sym_r := lang.NewSymbol("r") + sym_rand := lang.NewSymbol("rand") + sym_rand_DASH_int := lang.NewSymbol("rand-int") + sym_rand_DASH_nth := lang.NewSymbol("rand-nth") + sym_random_DASH_sample := lang.NewSymbol("random-sample") + sym_random_DASH_uuid := lang.NewSymbol("random-uuid") + sym_range := lang.NewSymbol("range") + sym_ratio_QMARK_ := lang.NewSymbol("ratio?") + sym_rational_QMARK_ := lang.NewSymbol("rational?") + sym_rationalize := lang.NewSymbol("rationalize") + sym_rdr := lang.NewSymbol("rdr") + sym_re := lang.NewSymbol("re") + sym_re_DASH_find := lang.NewSymbol("re-find") + sym_re_DASH_groups := lang.NewSymbol("re-groups") + sym_re_DASH_matcher := lang.NewSymbol("re-matcher") + sym_re_DASH_matches := lang.NewSymbol("re-matches") + sym_re_DASH_pattern := lang.NewSymbol("re-pattern") + sym_re_DASH_seq := lang.NewSymbol("re-seq") + sym_read := lang.NewSymbol("read") + sym_read_PLUS_string := lang.NewSymbol("read+string") + sym_read_DASH_line := lang.NewSymbol("read-line") + sym_read_DASH_string := lang.NewSymbol("read-string") + sym_reader := lang.NewSymbol("reader") + sym_reader_DASH_conditional := lang.NewSymbol("reader-conditional") + sym_reader_DASH_conditional_QMARK_ := lang.NewSymbol("reader-conditional?") + sym_realized_QMARK_ := lang.NewSymbol("realized?") + sym_recur := lang.NewSymbol("recur") + sym_recursive_QMARK_ := lang.NewSymbol("recursive?") + sym_reduce := lang.NewSymbol("reduce") + sym_reduce_DASH_kv := lang.NewSymbol("reduce-kv") + sym_reduce1 := lang.NewSymbol("reduce1") + sym_reduced := lang.NewSymbol("reduced") + sym_reduced_QMARK_ := lang.NewSymbol("reduced?") + sym_reductions := lang.NewSymbol("reductions") + sym_ref := lang.NewSymbol("ref") + sym_ref_DASH_history_DASH_count := lang.NewSymbol("ref-history-count") + sym_ref_DASH_max_DASH_history := lang.NewSymbol("ref-max-history") + sym_ref_DASH_min_DASH_history := lang.NewSymbol("ref-min-history") + sym_ref_DASH_set := lang.NewSymbol("ref-set") + sym_refer := lang.NewSymbol("refer") + sym_refer_DASH_glojure := lang.NewSymbol("refer-glojure") + sym_reference := lang.NewSymbol("reference") + sym_references_STAR_ := lang.NewSymbol("references*") + sym_release_DASH_pending_DASH_sends := lang.NewSymbol("release-pending-sends") + sym_rem := lang.NewSymbol("rem") + sym_remove := lang.NewSymbol("remove") + sym_remove_DASH_all_DASH_methods := lang.NewSymbol("remove-all-methods") + sym_remove_DASH_method := lang.NewSymbol("remove-method") + sym_remove_DASH_ns := lang.NewSymbol("remove-ns") + sym_remove_DASH_tap := lang.NewSymbol("remove-tap") + sym_remove_DASH_watch := lang.NewSymbol("remove-watch") + sym_rep := lang.NewSymbol("rep") + sym_repeat := lang.NewSymbol("repeat") + sym_repeatedly := lang.NewSymbol("repeatedly") + sym_replace := lang.NewSymbol("replace") + sym_replicate := lang.NewSymbol("replicate") + sym_require := lang.NewSymbol("require") + sym_requiring_DASH_resolve := lang.NewSymbol("requiring-resolve") + sym_reset_BANG_ := lang.NewSymbol("reset!") + sym_reset_DASH_meta_BANG_ := lang.NewSymbol("reset-meta!") + sym_reset_DASH_vals_BANG_ := lang.NewSymbol("reset-vals!") + sym_resolve := lang.NewSymbol("resolve") + sym_rest := lang.NewSymbol("rest") + sym_restart_DASH_agent := lang.NewSymbol("restart-agent") + sym_resultset_DASH_seq := lang.NewSymbol("resultset-seq") + sym_ret := lang.NewSymbol("ret") + sym_ret__1__auto__ := lang.NewSymbol("ret__1__auto__") + sym_retf := lang.NewSymbol("retf") + sym_rev := lang.NewSymbol("rev") + sym_reverse := lang.NewSymbol("reverse") + sym_reversible_QMARK_ := lang.NewSymbol("reversible?") + sym_rf := lang.NewSymbol("rf") + sym_root := lang.NewSymbol("root") + sym_root_DASH_directory := lang.NewSymbol("root-directory") + sym_root_DASH_resource := lang.NewSymbol("root-resource") + sym_rs := lang.NewSymbol("rs") + sym_rseq := lang.NewSymbol("rseq") + sym_rsubseq := lang.NewSymbol("rsubseq") + sym_run_BANG_ := lang.NewSymbol("run!") + sym_s := lang.NewSymbol("s") + sym_s__0__auto__ := lang.NewSymbol("s__0__auto__") + sym_sc := lang.NewSymbol("sc") + sym_second := lang.NewSymbol("second") + sym_select_DASH_keys := lang.NewSymbol("select-keys") + sym_send := lang.NewSymbol("send") + sym_send_DASH_off := lang.NewSymbol("send-off") + sym_send_DASH_via := lang.NewSymbol("send-via") + sym_sep := lang.NewSymbol("sep") + sym_seq := lang.NewSymbol("seq") + sym_seq_DASH_exprs := lang.NewSymbol("seq-exprs") + sym_seq_DASH_to_DASH_map_DASH_for_DASH_destructuring := lang.NewSymbol("seq-to-map-for-destructuring") + sym_seq_QMARK_ := lang.NewSymbol("seq?") + sym_seqable_QMARK_ := lang.NewSymbol("seqable?") + sym_seque := lang.NewSymbol("seque") + sym_sequence := lang.NewSymbol("sequence") + sym_sequential_QMARK_ := lang.NewSymbol("sequential?") + sym_serialized_DASH_require := lang.NewSymbol("serialized-require") + sym_set := lang.NewSymbol("set") + sym_set_DASH_agent_DASH_send_DASH_executor_BANG_ := lang.NewSymbol("set-agent-send-executor!") + sym_set_DASH_agent_DASH_send_DASH_off_DASH_executor_BANG_ := lang.NewSymbol("set-agent-send-off-executor!") + sym_set_DASH_error_DASH_handler_BANG_ := lang.NewSymbol("set-error-handler!") + sym_set_DASH_error_DASH_mode_BANG_ := lang.NewSymbol("set-error-mode!") + sym_set_DASH_validator_BANG_ := lang.NewSymbol("set-validator!") + sym_set_QMARK_ := lang.NewSymbol("set?") + sym_setDynamic := lang.NewSymbol("setDynamic") + sym_setup_DASH_reference := lang.NewSymbol("setup-reference") + sym_shift := lang.NewSymbol("shift") + sym_shift_DASH_mask := lang.NewSymbol("shift-mask") + sym_short := lang.NewSymbol("short") + sym_short_DASH_array := lang.NewSymbol("short-array") + sym_shortCast := lang.NewSymbol("shortCast") + sym_shorts := lang.NewSymbol("shorts") + sym_shuffle := lang.NewSymbol("shuffle") + sym_shutdown_DASH_agents := lang.NewSymbol("shutdown-agents") + sym_sigs := lang.NewSymbol("sigs") + sym_simple_DASH_ident_QMARK_ := lang.NewSymbol("simple-ident?") + sym_simple_DASH_keyword_QMARK_ := lang.NewSymbol("simple-keyword?") + sym_simple_DASH_symbol_QMARK_ := lang.NewSymbol("simple-symbol?") + sym_size := lang.NewSymbol("size") + sym_size_DASH_or_DASH_seq := lang.NewSymbol("size-or-seq") + sym_size__1__auto__ := lang.NewSymbol("size__1__auto__") + sym_slurp := lang.NewSymbol("slurp") + sym_smap := lang.NewSymbol("smap") + sym_some := lang.NewSymbol("some") + sym_some_DASH__GT_ := lang.NewSymbol("some->") + sym_some_DASH__GT__GT_ := lang.NewSymbol("some->>") + sym_some_DASH_fn := lang.NewSymbol("some-fn") + sym_some_QMARK_ := lang.NewSymbol("some?") + sym_somef := lang.NewSymbol("somef") + sym_sort := lang.NewSymbol("sort") + sym_sort_DASH_by := lang.NewSymbol("sort-by") + sym_sorted_DASH_map := lang.NewSymbol("sorted-map") + sym_sorted_DASH_map_DASH_by := lang.NewSymbol("sorted-map-by") + sym_sorted_DASH_set := lang.NewSymbol("sorted-set") + sym_sorted_DASH_set_DASH_by := lang.NewSymbol("sorted-set-by") + sym_sorted_QMARK_ := lang.NewSymbol("sorted?") + sym_special_DASH_symbol_QMARK_ := lang.NewSymbol("special-symbol?") + sym_specs := lang.NewSymbol("specs") + sym_spit := lang.NewSymbol("spit") + sym_splicing_QMARK_ := lang.NewSymbol("splicing?") + sym_split_DASH_at := lang.NewSymbol("split-at") + sym_split_DASH_with := lang.NewSymbol("split-with") + sym_splitv_DASH_at := lang.NewSymbol("splitv-at") + sym_spread := lang.NewSymbol("spread") + sym_start := lang.NewSymbol("start") + sym_start_DASH_key := lang.NewSymbol("start-key") + sym_start_DASH_test := lang.NewSymbol("start-test") + sym_start__0__auto__ := lang.NewSymbol("start__0__auto__") + sym_state := lang.NewSymbol("state") + sym_step := lang.NewSymbol("step") + sym_str := lang.NewSymbol("str") + sym_stream := lang.NewSymbol("stream") + sym_stream_DASH_into_BANG_ := lang.NewSymbol("stream-into!") + sym_stream_DASH_reduce_BANG_ := lang.NewSymbol("stream-reduce!") + sym_stream_DASH_seq_BANG_ := lang.NewSymbol("stream-seq!") + sym_stream_DASH_transduce_BANG_ := lang.NewSymbol("stream-transduce!") + sym_string_QMARK_ := lang.NewSymbol("string?") + sym_strings_DOT_Builder := lang.NewSymbol("strings.Builder") + sym_strip_DASH_ns := lang.NewSymbol("strip-ns") + sym_struct := lang.NewSymbol("struct") + sym_struct_DASH_map := lang.NewSymbol("struct-map") + sym_subs := lang.NewSymbol("subs") + sym_subseq := lang.NewSymbol("subseq") + sym_subvec := lang.NewSymbol("subvec") + sym_supers := lang.NewSymbol("supers") + sym_swap_BANG_ := lang.NewSymbol("swap!") + sym_swap_DASH_vals_BANG_ := lang.NewSymbol("swap-vals!") + sym_sym := lang.NewSymbol("sym") + sym_symbol := lang.NewSymbol("symbol") + sym_symbol_QMARK_ := lang.NewSymbol("symbol?") + sym_sync := lang.NewSymbol("sync") + sym_system_DASH_newline := lang.NewSymbol("system-newline") + sym_t := lang.NewSymbol("t") + sym_tag := lang.NewSymbol("tag") + sym_tagged_DASH_literal := lang.NewSymbol("tagged-literal") + sym_tagged_DASH_literal_QMARK_ := lang.NewSymbol("tagged-literal?") + sym_take := lang.NewSymbol("take") + sym_take_DASH_last := lang.NewSymbol("take-last") + sym_take_DASH_nth := lang.NewSymbol("take-nth") + sym_take_DASH_while := lang.NewSymbol("take-while") + sym_tapset := lang.NewSymbol("tapset") + sym_temp__0__auto__ := lang.NewSymbol("temp__0__auto__") + sym_test := lang.NewSymbol("test") + sym_test_DASH_f := lang.NewSymbol("test-f") + sym_tests := lang.NewSymbol("tests") + sym_the_DASH_ns := lang.NewSymbol("the-ns") + sym_then := lang.NewSymbol("then") + sym_thens := lang.NewSymbol("thens") + sym_this := lang.NewSymbol("this") + sym_thread_DASH_bound_QMARK_ := lang.NewSymbol("thread-bound?") + sym_throw := lang.NewSymbol("throw") + sym_throw_DASH_if := lang.NewSymbol("throw-if") + sym_time := lang.NewSymbol("time") + sym_time_DOT_Now := lang.NewSymbol("time.Now") + sym_timeout_DASH_ms := lang.NewSymbol("timeout-ms") + sym_timeout_DASH_val := lang.NewSymbol("timeout-val") + sym_to := lang.NewSymbol("to") + sym_to_DASH_array := lang.NewSymbol("to-array") + sym_to_DASH_array_DASH_2d := lang.NewSymbol("to-array-2d") + sym_trampoline := lang.NewSymbol("trampoline") + sym_transduce := lang.NewSymbol("transduce") + sym_transient := lang.NewSymbol("transient") + sym_tree_DASH_seq := lang.NewSymbol("tree-seq") + sym_true_QMARK_ := lang.NewSymbol("true?") + sym_try := lang.NewSymbol("try") + sym_type := lang.NewSymbol("type") + sym_unchecked_DASH_add := lang.NewSymbol("unchecked-add") + sym_unchecked_DASH_add_DASH_int := lang.NewSymbol("unchecked-add-int") + sym_unchecked_DASH_byte := lang.NewSymbol("unchecked-byte") + sym_unchecked_DASH_char := lang.NewSymbol("unchecked-char") + sym_unchecked_DASH_dec := lang.NewSymbol("unchecked-dec") + sym_unchecked_DASH_dec_DASH_int := lang.NewSymbol("unchecked-dec-int") + sym_unchecked_DASH_divide_DASH_int := lang.NewSymbol("unchecked-divide-int") + sym_unchecked_DASH_double := lang.NewSymbol("unchecked-double") + sym_unchecked_DASH_float := lang.NewSymbol("unchecked-float") + sym_unchecked_DASH_inc := lang.NewSymbol("unchecked-inc") + sym_unchecked_DASH_inc_DASH_int := lang.NewSymbol("unchecked-inc-int") + sym_unchecked_DASH_int := lang.NewSymbol("unchecked-int") + sym_unchecked_DASH_long := lang.NewSymbol("unchecked-long") + sym_unchecked_DASH_multiply := lang.NewSymbol("unchecked-multiply") + sym_unchecked_DASH_multiply_DASH_int := lang.NewSymbol("unchecked-multiply-int") + sym_unchecked_DASH_negate := lang.NewSymbol("unchecked-negate") + sym_unchecked_DASH_negate_DASH_int := lang.NewSymbol("unchecked-negate-int") + sym_unchecked_DASH_op := lang.NewSymbol("unchecked-op") + sym_unchecked_DASH_remainder_DASH_int := lang.NewSymbol("unchecked-remainder-int") + sym_unchecked_DASH_short := lang.NewSymbol("unchecked-short") + sym_unchecked_DASH_subtract := lang.NewSymbol("unchecked-subtract") + sym_unchecked_DASH_subtract_DASH_int := lang.NewSymbol("unchecked-subtract-int") + sym_uncheckedByteCast := lang.NewSymbol("uncheckedByteCast") + sym_uncheckedCharCast := lang.NewSymbol("uncheckedCharCast") + sym_uncheckedFloatCast := lang.NewSymbol("uncheckedFloatCast") + sym_uncheckedIntCast := lang.NewSymbol("uncheckedIntCast") + sym_uncheckedShortCast := lang.NewSymbol("uncheckedShortCast") + sym_unchecked_add := lang.NewSymbol("unchecked_add") + sym_unchecked_dec := lang.NewSymbol("unchecked_dec") + sym_unchecked_inc := lang.NewSymbol("unchecked_inc") + sym_unchecked_minus := lang.NewSymbol("unchecked_minus") + sym_unchecked_multiply := lang.NewSymbol("unchecked_multiply") + sym_underive := lang.NewSymbol("underive") + sym_unquote := lang.NewSymbol("unquote") + sym_unquote_DASH_splicing := lang.NewSymbol("unquote-splicing") + sym_unreduced := lang.NewSymbol("unreduced") + sym_unsigned_DASH_bit_DASH_shift_DASH_right := lang.NewSymbol("unsigned-bit-shift-right") + sym_update := lang.NewSymbol("update") + sym_update_DASH_in := lang.NewSymbol("update-in") + sym_update_DASH_keys := lang.NewSymbol("update-keys") + sym_update_DASH_vals := lang.NewSymbol("update-vals") + sym_uri_QMARK_ := lang.NewSymbol("uri?") + sym_url := lang.NewSymbol("url") + sym_use := lang.NewSymbol("use") + sym_user := lang.NewSymbol("user") + sym_uuid_QMARK_ := lang.NewSymbol("uuid?") + sym_v := lang.NewSymbol("v") + sym_v__0__auto__ := lang.NewSymbol("v__0__auto__") + sym_val := lang.NewSymbol("val") + sym_val__2__auto__ := lang.NewSymbol("val__2__auto__") + sym_valid_DASH_keys := lang.NewSymbol("valid-keys") + sym_validator_DASH_fn := lang.NewSymbol("validator-fn") + sym_vals := lang.NewSymbol("vals") + sym_value := lang.NewSymbol("value") + sym_var := lang.NewSymbol("var") + sym_var_DASH_get := lang.NewSymbol("var-get") + sym_var_DASH_set := lang.NewSymbol("var-set") + sym_var_QMARK_ := lang.NewSymbol("var?") + sym_vars := lang.NewSymbol("vars") + sym_vary_DASH_meta := lang.NewSymbol("vary-meta") + sym_vec := lang.NewSymbol("vec") + sym_vector := lang.NewSymbol("vector") + sym_vector_QMARK_ := lang.NewSymbol("vector?") + sym_vf := lang.NewSymbol("vf") + sym_vol := lang.NewSymbol("vol") + sym_volatile_BANG_ := lang.NewSymbol("volatile!") + sym_volatile_QMARK_ := lang.NewSymbol("volatile?") + sym_vreset_BANG_ := lang.NewSymbol("vreset!") + sym_vswap_BANG_ := lang.NewSymbol("vswap!") + sym_w := lang.NewSymbol("w") + sym_when := lang.NewSymbol("when") + sym_when_DASH_first := lang.NewSymbol("when-first") + sym_when_DASH_let := lang.NewSymbol("when-let") + sym_when_DASH_not := lang.NewSymbol("when-not") + sym_when_DASH_some := lang.NewSymbol("when-some") + sym_while := lang.NewSymbol("while") + sym_with_DASH_bindings := lang.NewSymbol("with-bindings") + sym_with_DASH_bindings_STAR_ := lang.NewSymbol("with-bindings*") + sym_with_DASH_in_DASH_str := lang.NewSymbol("with-in-str") + sym_with_DASH_loading_DASH_context := lang.NewSymbol("with-loading-context") + sym_with_DASH_local_DASH_vars := lang.NewSymbol("with-local-vars") + sym_with_DASH_meta := lang.NewSymbol("with-meta") + sym_with_DASH_open := lang.NewSymbol("with-open") + sym_with_DASH_out_DASH_str := lang.NewSymbol("with-out-str") + sym_with_DASH_precision := lang.NewSymbol("with-precision") + sym_with_DASH_redefs := lang.NewSymbol("with-redefs") + sym_with_DASH_redefs_DASH_fn := lang.NewSymbol("with-redefs-fn") + sym_x := lang.NewSymbol("x") + sym_xform := lang.NewSymbol("xform") + sym_xml_DASH_seq := lang.NewSymbol("xml-seq") + sym_xor := lang.NewSymbol("xor") + sym_xs := lang.NewSymbol("xs") + sym_xs__0__auto__ := lang.NewSymbol("xs__0__auto__") + sym_y := lang.NewSymbol("y") + sym_ys := lang.NewSymbol("ys") + sym_z := lang.NewSymbol("z") + sym_zero_QMARK_ := lang.NewSymbol("zero?") + sym_zipmap := lang.NewSymbol("zipmap") + sym_zs := lang.NewSymbol("zs") + kw__GT__GT_ := lang.NewKeyword(">>") + kw_added := lang.NewKeyword("added") + kw_all := lang.NewKeyword("all") + kw_allow := lang.NewKeyword("allow") + kw_ancestors := lang.NewKeyword("ancestors") + kw_arglists := lang.NewKeyword("arglists") + kw_as := lang.NewKeyword("as") + kw_as_DASH_alias := lang.NewKeyword("as-alias") + kw_at := lang.NewKeyword("at") + kw_cause := lang.NewKeyword("cause") + kw_clear_DASH_actions := lang.NewKeyword("clear-actions") + kw_column := lang.NewKeyword("column") + kw_compact := lang.NewKeyword("compact") + kw_conflict := lang.NewKeyword("conflict") + kw_content := lang.NewKeyword("content") + kw_continue := lang.NewKeyword("continue") + kw_data := lang.NewKeyword("data") + kw_declared := lang.NewKeyword("declared") + kw_default := lang.NewKeyword("default") + kw_deprecated := lang.NewKeyword("deprecated") + kw_descendants := lang.NewKeyword("descendants") + kw_doc := lang.NewKeyword("doc") + kw_dynamic := lang.NewKeyword("dynamic") + kw_else := lang.NewKeyword("else") + kw_encoding := lang.NewKeyword("encoding") + kw_end_DASH_column := lang.NewKeyword("end-column") + kw_end_DASH_line := lang.NewKeyword("end-line") + kw_eof := lang.NewKeyword("eof") + kw_error_DASH_handler := lang.NewKeyword("error-handler") + kw_error_DASH_mode := lang.NewKeyword("error-mode") + kw_exclude := lang.NewKeyword("exclude") + kw_fail := lang.NewKeyword("fail") + kw_failed := lang.NewKeyword("failed") + kw_file := lang.NewKeyword("file") + kw_form := lang.NewKeyword("form") + kw_forms := lang.NewKeyword("forms") + kw_gen_DASH_class := lang.NewKeyword("gen-class") + kw_glojure_DOT_core_SLASH_halt := lang.NewKeyword("glojure.core/halt") + kw_glojure_DOT_core_SLASH_none := lang.NewKeyword("glojure.core/none") + kw_glojure_DOT_error_SLASH_phase := lang.NewKeyword("glojure.error/phase") + kw_hash_DASH_equiv := lang.NewKeyword("hash-equiv") + kw_hash_DASH_identity := lang.NewKeyword("hash-identity") + kw_hashes := lang.NewKeyword("hashes") + kw_hierarchy := lang.NewKeyword("hierarchy") + kw_identity := lang.NewKeyword("identity") + kw_impl_DASH_ns := lang.NewKeyword("impl-ns") + kw_initk := lang.NewKeyword("initk") + kw_inline := lang.NewKeyword("inline") + kw_inline_DASH_arities := lang.NewKeyword("inline-arities") + kw_int := lang.NewKeyword("int") + kw_ints := lang.NewKeyword("ints") + kw_keys := lang.NewKeyword("keys") + kw_kf := lang.NewKeyword("kf") + kw_let := lang.NewKeyword("let") + kw_line := lang.NewKeyword("line") + kw_macro := lang.NewKeyword("macro") + kw_main := lang.NewKeyword("main") + kw_mappings := lang.NewKeyword("mappings") + kw_max_DASH_history := lang.NewKeyword("max-history") + kw_message := lang.NewKeyword("message") + kw_meta := lang.NewKeyword("meta") + kw_min_DASH_history := lang.NewKeyword("min-history") + kw_multis := lang.NewKeyword("multis") + kw_name := lang.NewKeyword("name") + kw_no_DASH_test := lang.NewKeyword("no-test") + kw_ns := lang.NewKeyword("ns") + kw_ok := lang.NewKeyword("ok") + kw_on_DASH_interface := lang.NewKeyword("on-interface") + kw_only := lang.NewKeyword("only") + kw_or := lang.NewKeyword("or") + kw_parents := lang.NewKeyword("parents") + kw_pending := lang.NewKeyword("pending") + kw_phase := lang.NewKeyword("phase") + kw_post := lang.NewKeyword("post") + kw_pre := lang.NewKeyword("pre") + kw_private := lang.NewKeyword("private") + kw_read_DASH_cond := lang.NewKeyword("read-cond") + kw_ready := lang.NewKeyword("ready") + kw_redef := lang.NewKeyword("redef") + kw_refer := lang.NewKeyword("refer") + kw_refer_DASH_glojure := lang.NewKeyword("refer-glojure") + kw_reload := lang.NewKeyword("reload") + kw_reload_DASH_all := lang.NewKeyword("reload-all") + kw_rename := lang.NewKeyword("rename") + kw_require := lang.NewKeyword("require") + kw_rettag := lang.NewKeyword("rettag") + kw_rounding := lang.NewKeyword("rounding") + kw_sigs := lang.NewKeyword("sigs") + kw_somef := lang.NewKeyword("somef") + kw_sparse := lang.NewKeyword("sparse") + kw_special_DASH_form := lang.NewKeyword("special-form") + kw_static := lang.NewKeyword("static") + kw_status := lang.NewKeyword("status") + kw_tag := lang.NewKeyword("tag") + kw_test := lang.NewKeyword("test") + kw_trace := lang.NewKeyword("trace") + kw_type := lang.NewKeyword("type") + kw_url := lang.NewKeyword("url") + kw_use := lang.NewKeyword("use") + kw_val := lang.NewKeyword("val") + kw_validator := lang.NewKeyword("validator") + kw_verbose := lang.NewKeyword("verbose") + kw_vf := lang.NewKeyword("vf") + kw_via := lang.NewKeyword("via") + kw_when := lang.NewKeyword("when") + kw_while := lang.NewKeyword("while") + // var glojure.core.protocols/coll-reduce + var_glojure_DOT_core_DOT_protocols_coll_DASH_reduce := lang.InternVarName(sym_glojure_DOT_core_DOT_protocols, sym_coll_DASH_reduce) + // var glojure.core.protocols/kv-reduce + var_glojure_DOT_core_DOT_protocols_kv_DASH_reduce := lang.InternVarName(sym_glojure_DOT_core_DOT_protocols, sym_kv_DASH_reduce) + // var glojure.core/NaN? + var_glojure_DOT_core_NaN_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_NaN_QMARK_) + // var glojure.core/StackTraceElement->vec + var_glojure_DOT_core_StackTraceElement_DASH__GT_vec := lang.InternVarName(sym_glojure_DOT_core, sym_StackTraceElement_DASH__GT_vec) + // var glojure.core/Throwable->map + var_glojure_DOT_core_Throwable_DASH__GT_map := lang.InternVarName(sym_glojure_DOT_core, sym_Throwable_DASH__GT_map) + // var glojure.core/- + var_glojure_DOT_core__DASH_ := lang.InternVarName(sym_glojure_DOT_core, sym__DASH_) + // var glojure.core/-> + var_glojure_DOT_core__DASH__GT_ := lang.InternVarName(sym_glojure_DOT_core, sym__DASH__GT_) + // var glojure.core/->> + var_glojure_DOT_core__DASH__GT__GT_ := lang.InternVarName(sym_glojure_DOT_core, sym__DASH__GT__GT_) + // var glojure.core/-' + var_glojure_DOT_core__DASH__TICK_ := lang.InternVarName(sym_glojure_DOT_core, sym__DASH__TICK_) + // var glojure.core/-protocols + var_glojure_DOT_core__DASH_protocols := lang.InternVarName(sym_glojure_DOT_core, sym__DASH_protocols) + // var glojure.core/.. + var_glojure_DOT_core__DOT__DOT_ := lang.InternVarName(sym_glojure_DOT_core, sym__DOT__DOT_) + // var glojure.core/= + var_glojure_DOT_core__EQ_ := lang.InternVarName(sym_glojure_DOT_core, sym__EQ_) + // var glojure.core/== + var_glojure_DOT_core__EQ__EQ_ := lang.InternVarName(sym_glojure_DOT_core, sym__EQ__EQ_) + // var glojure.core/> + var_glojure_DOT_core__GT_ := lang.InternVarName(sym_glojure_DOT_core, sym__GT_) + // var glojure.core/>0? + var_glojure_DOT_core__GT_0_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym__GT_0_QMARK_) + // var glojure.core/>1? + var_glojure_DOT_core__GT_1_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym__GT_1_QMARK_) + // var glojure.core/>= + var_glojure_DOT_core__GT__EQ_ := lang.InternVarName(sym_glojure_DOT_core, sym__GT__EQ_) + // var glojure.core/< + var_glojure_DOT_core__LT_ := lang.InternVarName(sym_glojure_DOT_core, sym__LT_) + // var glojure.core/<= + var_glojure_DOT_core__LT__EQ_ := lang.InternVarName(sym_glojure_DOT_core, sym__LT__EQ_) + // var glojure.core/+ + var_glojure_DOT_core__PLUS_ := lang.InternVarName(sym_glojure_DOT_core, sym__PLUS_) + // var glojure.core/+' + var_glojure_DOT_core__PLUS__TICK_ := lang.InternVarName(sym_glojure_DOT_core, sym__PLUS__TICK_) + // var glojure.core// + var_glojure_DOT_core__SLASH_ := lang.InternVarName(sym_glojure_DOT_core, sym__SLASH_) + // var glojure.core/* + var_glojure_DOT_core__STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_) + // var glojure.core/*1 + var_glojure_DOT_core__STAR_1 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_1) + // var glojure.core/*2 + var_glojure_DOT_core__STAR_2 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_2) + // var glojure.core/*3 + var_glojure_DOT_core__STAR_3 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_3) + // var glojure.core/*' + var_glojure_DOT_core__STAR__TICK_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR__TICK_) + // var glojure.core/*agent* + var_glojure_DOT_core__STAR_agent_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_agent_STAR_) + // var glojure.core/*assert* + var_glojure_DOT_core__STAR_assert_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_assert_STAR_) + // var glojure.core/*command-line-args* + var_glojure_DOT_core__STAR_command_DASH_line_DASH_args_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_command_DASH_line_DASH_args_STAR_) + // var glojure.core/*compile-files* + var_glojure_DOT_core__STAR_compile_DASH_files_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_compile_DASH_files_STAR_) + // var glojure.core/*compile-path* + var_glojure_DOT_core__STAR_compile_DASH_path_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_compile_DASH_path_STAR_) + // var glojure.core/*compiler-options* + var_glojure_DOT_core__STAR_compiler_DASH_options_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_compiler_DASH_options_STAR_) + // var glojure.core/*data-readers* + var_glojure_DOT_core__STAR_data_DASH_readers_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_data_DASH_readers_STAR_) + // var glojure.core/*default-data-reader-fn* + var_glojure_DOT_core__STAR_default_DASH_data_DASH_reader_DASH_fn_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_default_DASH_data_DASH_reader_DASH_fn_STAR_) + // var glojure.core/*e + var_glojure_DOT_core__STAR_e := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_e) + // var glojure.core/*err* + var_glojure_DOT_core__STAR_err_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_err_STAR_) + // var glojure.core/*file* + var_glojure_DOT_core__STAR_file_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_file_STAR_) + // var glojure.core/*flush-on-newline* + var_glojure_DOT_core__STAR_flush_DASH_on_DASH_newline_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_flush_DASH_on_DASH_newline_STAR_) + // var glojure.core/*in* + var_glojure_DOT_core__STAR_in_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_in_STAR_) + // var glojure.core/*loaded-libs* + var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_loaded_DASH_libs_STAR_) + // var glojure.core/*loading-verbosely* + var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_loading_DASH_verbosely_STAR_) + // var glojure.core/*ns* + var_glojure_DOT_core__STAR_ns_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_ns_STAR_) + // var glojure.core/*out* + var_glojure_DOT_core__STAR_out_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) + // var glojure.core/*pending-paths* + var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_pending_DASH_paths_STAR_) + // var glojure.core/*print-dup* + var_glojure_DOT_core__STAR_print_DASH_dup_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_print_DASH_dup_STAR_) + // var glojure.core/*print-length* + var_glojure_DOT_core__STAR_print_DASH_length_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_print_DASH_length_STAR_) + // var glojure.core/*print-level* + var_glojure_DOT_core__STAR_print_DASH_level_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_print_DASH_level_STAR_) + // var glojure.core/*print-meta* + var_glojure_DOT_core__STAR_print_DASH_meta_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_print_DASH_meta_STAR_) + // var glojure.core/*print-namespace-maps* + var_glojure_DOT_core__STAR_print_DASH_namespace_DASH_maps_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_print_DASH_namespace_DASH_maps_STAR_) + // var glojure.core/*print-readably* + var_glojure_DOT_core__STAR_print_DASH_readably_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_print_DASH_readably_STAR_) + // var glojure.core/*read-eval* + var_glojure_DOT_core__STAR_read_DASH_eval_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_read_DASH_eval_STAR_) + // var glojure.core/*repl* + var_glojure_DOT_core__STAR_repl_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_repl_STAR_) + // var glojure.core/*unchecked-math* + var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_unchecked_DASH_math_STAR_) + // var glojure.core/*verbose-defrecords* + var_glojure_DOT_core__STAR_verbose_DASH_defrecords_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_verbose_DASH_defrecords_STAR_) + // var glojure.core/*warn-on-reflection* + var_glojure_DOT_core__STAR_warn_DASH_on_DASH_reflection_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_warn_DASH_on_DASH_reflection_STAR_) + // var glojure.core/abs + var_glojure_DOT_core_abs := lang.InternVarName(sym_glojure_DOT_core, sym_abs) + // var glojure.core/accessor + var_glojure_DOT_core_accessor := lang.InternVarName(sym_glojure_DOT_core, sym_accessor) + // var glojure.core/aclone + var_glojure_DOT_core_aclone := lang.InternVarName(sym_glojure_DOT_core, sym_aclone) + // var glojure.core/add-classpath + var_glojure_DOT_core_add_DASH_classpath := lang.InternVarName(sym_glojure_DOT_core, sym_add_DASH_classpath) + // var glojure.core/add-doc-and-meta + var_glojure_DOT_core_add_DASH_doc_DASH_and_DASH_meta := lang.InternVarName(sym_glojure_DOT_core, sym_add_DASH_doc_DASH_and_DASH_meta) + // var glojure.core/add-watch + var_glojure_DOT_core_add_DASH_watch := lang.InternVarName(sym_glojure_DOT_core, sym_add_DASH_watch) + // var glojure.core/agent + var_glojure_DOT_core_agent := lang.InternVarName(sym_glojure_DOT_core, sym_agent) + // var glojure.core/agent-error + var_glojure_DOT_core_agent_DASH_error := lang.InternVarName(sym_glojure_DOT_core, sym_agent_DASH_error) + // var glojure.core/agent-errors + var_glojure_DOT_core_agent_DASH_errors := lang.InternVarName(sym_glojure_DOT_core, sym_agent_DASH_errors) + // var glojure.core/aget + var_glojure_DOT_core_aget := lang.InternVarName(sym_glojure_DOT_core, sym_aget) + // var glojure.core/alength + var_glojure_DOT_core_alength := lang.InternVarName(sym_glojure_DOT_core, sym_alength) + // var glojure.core/alias + var_glojure_DOT_core_alias := lang.InternVarName(sym_glojure_DOT_core, sym_alias) + // var glojure.core/all-ns + var_glojure_DOT_core_all_DASH_ns := lang.InternVarName(sym_glojure_DOT_core, sym_all_DASH_ns) + // var glojure.core/alter + var_glojure_DOT_core_alter := lang.InternVarName(sym_glojure_DOT_core, sym_alter) + // var glojure.core/alter-meta! + var_glojure_DOT_core_alter_DASH_meta_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_alter_DASH_meta_BANG_) + // var glojure.core/alter-var-root + var_glojure_DOT_core_alter_DASH_var_DASH_root := lang.InternVarName(sym_glojure_DOT_core, sym_alter_DASH_var_DASH_root) + // var glojure.core/amap + var_glojure_DOT_core_amap := lang.InternVarName(sym_glojure_DOT_core, sym_amap) + // var glojure.core/ancestors + var_glojure_DOT_core_ancestors := lang.InternVarName(sym_glojure_DOT_core, sym_ancestors) + // var glojure.core/and + var_glojure_DOT_core_and := lang.InternVarName(sym_glojure_DOT_core, sym_and) + // var glojure.core/any? + var_glojure_DOT_core_any_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_any_QMARK_) + // var glojure.core/apply + var_glojure_DOT_core_apply := lang.InternVarName(sym_glojure_DOT_core, sym_apply) + // var glojure.core/areduce + var_glojure_DOT_core_areduce := lang.InternVarName(sym_glojure_DOT_core, sym_areduce) + // var glojure.core/array + var_glojure_DOT_core_array := lang.InternVarName(sym_glojure_DOT_core, sym_array) + // var glojure.core/array-map + var_glojure_DOT_core_array_DASH_map := lang.InternVarName(sym_glojure_DOT_core, sym_array_DASH_map) + // var glojure.core/as-> + var_glojure_DOT_core_as_DASH__GT_ := lang.InternVarName(sym_glojure_DOT_core, sym_as_DASH__GT_) + // var glojure.core/aset + var_glojure_DOT_core_aset := lang.InternVarName(sym_glojure_DOT_core, sym_aset) + // var glojure.core/aset-boolean + var_glojure_DOT_core_aset_DASH_boolean := lang.InternVarName(sym_glojure_DOT_core, sym_aset_DASH_boolean) + // var glojure.core/aset-byte + var_glojure_DOT_core_aset_DASH_byte := lang.InternVarName(sym_glojure_DOT_core, sym_aset_DASH_byte) + // var glojure.core/aset-char + var_glojure_DOT_core_aset_DASH_char := lang.InternVarName(sym_glojure_DOT_core, sym_aset_DASH_char) + // var glojure.core/aset-double + var_glojure_DOT_core_aset_DASH_double := lang.InternVarName(sym_glojure_DOT_core, sym_aset_DASH_double) + // var glojure.core/aset-float + var_glojure_DOT_core_aset_DASH_float := lang.InternVarName(sym_glojure_DOT_core, sym_aset_DASH_float) + // var glojure.core/aset-int + var_glojure_DOT_core_aset_DASH_int := lang.InternVarName(sym_glojure_DOT_core, sym_aset_DASH_int) + // var glojure.core/aset-long + var_glojure_DOT_core_aset_DASH_long := lang.InternVarName(sym_glojure_DOT_core, sym_aset_DASH_long) + // var glojure.core/aset-short + var_glojure_DOT_core_aset_DASH_short := lang.InternVarName(sym_glojure_DOT_core, sym_aset_DASH_short) + // var glojure.core/assert + var_glojure_DOT_core_assert := lang.InternVarName(sym_glojure_DOT_core, sym_assert) + // var glojure.core/assert-args + var_glojure_DOT_core_assert_DASH_args := lang.InternVarName(sym_glojure_DOT_core, sym_assert_DASH_args) + // var glojure.core/assert-valid-fdecl + var_glojure_DOT_core_assert_DASH_valid_DASH_fdecl := lang.InternVarName(sym_glojure_DOT_core, sym_assert_DASH_valid_DASH_fdecl) + // var glojure.core/assoc + var_glojure_DOT_core_assoc := lang.InternVarName(sym_glojure_DOT_core, sym_assoc) + // var glojure.core/assoc! + var_glojure_DOT_core_assoc_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_assoc_BANG_) + // var glojure.core/assoc-in + var_glojure_DOT_core_assoc_DASH_in := lang.InternVarName(sym_glojure_DOT_core, sym_assoc_DASH_in) + // var glojure.core/associative? + var_glojure_DOT_core_associative_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_associative_QMARK_) + // var glojure.core/atom + var_glojure_DOT_core_atom := lang.InternVarName(sym_glojure_DOT_core, sym_atom) + // var glojure.core/await + var_glojure_DOT_core_await := lang.InternVarName(sym_glojure_DOT_core, sym_await) + // var glojure.core/await1 + var_glojure_DOT_core_await1 := lang.InternVarName(sym_glojure_DOT_core, sym_await1) + // var glojure.core/await-for + var_glojure_DOT_core_await_DASH_for := lang.InternVarName(sym_glojure_DOT_core, sym_await_DASH_for) + // var glojure.core/bases + var_glojure_DOT_core_bases := lang.InternVarName(sym_glojure_DOT_core, sym_bases) + // var glojure.core/bigdec + var_glojure_DOT_core_bigdec := lang.InternVarName(sym_glojure_DOT_core, sym_bigdec) + // var glojure.core/bigint + var_glojure_DOT_core_bigint := lang.InternVarName(sym_glojure_DOT_core, sym_bigint) + // var glojure.core/biginteger + var_glojure_DOT_core_biginteger := lang.InternVarName(sym_glojure_DOT_core, sym_biginteger) + // var glojure.core/binding + var_glojure_DOT_core_binding := lang.InternVarName(sym_glojure_DOT_core, sym_binding) + // var glojure.core/binding-conveyor-fn + var_glojure_DOT_core_binding_DASH_conveyor_DASH_fn := lang.InternVarName(sym_glojure_DOT_core, sym_binding_DASH_conveyor_DASH_fn) + // var glojure.core/bit-and + var_glojure_DOT_core_bit_DASH_and := lang.InternVarName(sym_glojure_DOT_core, sym_bit_DASH_and) + // var glojure.core/bit-and-not + var_glojure_DOT_core_bit_DASH_and_DASH_not := lang.InternVarName(sym_glojure_DOT_core, sym_bit_DASH_and_DASH_not) + // var glojure.core/bit-clear + var_glojure_DOT_core_bit_DASH_clear := lang.InternVarName(sym_glojure_DOT_core, sym_bit_DASH_clear) + // var glojure.core/bit-flip + var_glojure_DOT_core_bit_DASH_flip := lang.InternVarName(sym_glojure_DOT_core, sym_bit_DASH_flip) + // var glojure.core/bit-not + var_glojure_DOT_core_bit_DASH_not := lang.InternVarName(sym_glojure_DOT_core, sym_bit_DASH_not) + // var glojure.core/bit-or + var_glojure_DOT_core_bit_DASH_or := lang.InternVarName(sym_glojure_DOT_core, sym_bit_DASH_or) + // var glojure.core/bit-set + var_glojure_DOT_core_bit_DASH_set := lang.InternVarName(sym_glojure_DOT_core, sym_bit_DASH_set) + // var glojure.core/bit-shift-left + var_glojure_DOT_core_bit_DASH_shift_DASH_left := lang.InternVarName(sym_glojure_DOT_core, sym_bit_DASH_shift_DASH_left) + // var glojure.core/bit-shift-right + var_glojure_DOT_core_bit_DASH_shift_DASH_right := lang.InternVarName(sym_glojure_DOT_core, sym_bit_DASH_shift_DASH_right) + // var glojure.core/bit-test + var_glojure_DOT_core_bit_DASH_test := lang.InternVarName(sym_glojure_DOT_core, sym_bit_DASH_test) + // var glojure.core/bit-xor + var_glojure_DOT_core_bit_DASH_xor := lang.InternVarName(sym_glojure_DOT_core, sym_bit_DASH_xor) + // var glojure.core/boolean + var_glojure_DOT_core_boolean := lang.InternVarName(sym_glojure_DOT_core, sym_boolean) + // var glojure.core/boolean-array + var_glojure_DOT_core_boolean_DASH_array := lang.InternVarName(sym_glojure_DOT_core, sym_boolean_DASH_array) + // var glojure.core/boolean? + var_glojure_DOT_core_boolean_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_boolean_QMARK_) + // var glojure.core/booleans + var_glojure_DOT_core_booleans := lang.InternVarName(sym_glojure_DOT_core, sym_booleans) + // var glojure.core/bound-fn + var_glojure_DOT_core_bound_DASH_fn := lang.InternVarName(sym_glojure_DOT_core, sym_bound_DASH_fn) + // var glojure.core/bound-fn* + var_glojure_DOT_core_bound_DASH_fn_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym_bound_DASH_fn_STAR_) + // var glojure.core/bound? + var_glojure_DOT_core_bound_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_bound_QMARK_) + // var glojure.core/bounded-count + var_glojure_DOT_core_bounded_DASH_count := lang.InternVarName(sym_glojure_DOT_core, sym_bounded_DASH_count) + // var glojure.core/butlast + var_glojure_DOT_core_butlast := lang.InternVarName(sym_glojure_DOT_core, sym_butlast) + // var glojure.core/byte + var_glojure_DOT_core_byte := lang.InternVarName(sym_glojure_DOT_core, sym_byte) + // var glojure.core/byte-array + var_glojure_DOT_core_byte_DASH_array := lang.InternVarName(sym_glojure_DOT_core, sym_byte_DASH_array) + // var glojure.core/bytes + var_glojure_DOT_core_bytes := lang.InternVarName(sym_glojure_DOT_core, sym_bytes) + // var glojure.core/bytes? + var_glojure_DOT_core_bytes_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_bytes_QMARK_) + // var glojure.core/case + var_glojure_DOT_core_case := lang.InternVarName(sym_glojure_DOT_core, sym_case) + // var glojure.core/case-map + var_glojure_DOT_core_case_DASH_map := lang.InternVarName(sym_glojure_DOT_core, sym_case_DASH_map) + // var glojure.core/cast + var_glojure_DOT_core_cast := lang.InternVarName(sym_glojure_DOT_core, sym_cast) + // var glojure.core/cat + var_glojure_DOT_core_cat := lang.InternVarName(sym_glojure_DOT_core, sym_cat) + // var glojure.core/char + var_glojure_DOT_core_char := lang.InternVarName(sym_glojure_DOT_core, sym_char) + // var glojure.core/char-array + var_glojure_DOT_core_char_DASH_array := lang.InternVarName(sym_glojure_DOT_core, sym_char_DASH_array) + // var glojure.core/char-escape-string + var_glojure_DOT_core_char_DASH_escape_DASH_string := lang.InternVarName(sym_glojure_DOT_core, sym_char_DASH_escape_DASH_string) + // var glojure.core/char-name-string + var_glojure_DOT_core_char_DASH_name_DASH_string := lang.InternVarName(sym_glojure_DOT_core, sym_char_DASH_name_DASH_string) + // var glojure.core/char? + var_glojure_DOT_core_char_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_char_QMARK_) + // var glojure.core/chars + var_glojure_DOT_core_chars := lang.InternVarName(sym_glojure_DOT_core, sym_chars) + // var glojure.core/check-cyclic-dependency + var_glojure_DOT_core_check_DASH_cyclic_DASH_dependency := lang.InternVarName(sym_glojure_DOT_core, sym_check_DASH_cyclic_DASH_dependency) + // var glojure.core/check-valid-options + var_glojure_DOT_core_check_DASH_valid_DASH_options := lang.InternVarName(sym_glojure_DOT_core, sym_check_DASH_valid_DASH_options) + // var glojure.core/chunk + var_glojure_DOT_core_chunk := lang.InternVarName(sym_glojure_DOT_core, sym_chunk) + // var glojure.core/chunk-append + var_glojure_DOT_core_chunk_DASH_append := lang.InternVarName(sym_glojure_DOT_core, sym_chunk_DASH_append) + // var glojure.core/chunk-buffer + var_glojure_DOT_core_chunk_DASH_buffer := lang.InternVarName(sym_glojure_DOT_core, sym_chunk_DASH_buffer) + // var glojure.core/chunk-cons + var_glojure_DOT_core_chunk_DASH_cons := lang.InternVarName(sym_glojure_DOT_core, sym_chunk_DASH_cons) + // var glojure.core/chunk-first + var_glojure_DOT_core_chunk_DASH_first := lang.InternVarName(sym_glojure_DOT_core, sym_chunk_DASH_first) + // var glojure.core/chunk-next + var_glojure_DOT_core_chunk_DASH_next := lang.InternVarName(sym_glojure_DOT_core, sym_chunk_DASH_next) + // var glojure.core/chunk-rest + var_glojure_DOT_core_chunk_DASH_rest := lang.InternVarName(sym_glojure_DOT_core, sym_chunk_DASH_rest) + // var glojure.core/chunked-seq? + var_glojure_DOT_core_chunked_DASH_seq_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_chunked_DASH_seq_QMARK_) + // var glojure.core/class + var_glojure_DOT_core_class := lang.InternVarName(sym_glojure_DOT_core, sym_class) + // var glojure.core/class? + var_glojure_DOT_core_class_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_class_QMARK_) + // var glojure.core/clear-agent-errors + var_glojure_DOT_core_clear_DASH_agent_DASH_errors := lang.InternVarName(sym_glojure_DOT_core, sym_clear_DASH_agent_DASH_errors) + // var glojure.core/coll? + var_glojure_DOT_core_coll_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_coll_QMARK_) + // var glojure.core/comment + var_glojure_DOT_core_comment := lang.InternVarName(sym_glojure_DOT_core, sym_comment) + // var glojure.core/commute + var_glojure_DOT_core_commute := lang.InternVarName(sym_glojure_DOT_core, sym_commute) + // var glojure.core/comp + var_glojure_DOT_core_comp := lang.InternVarName(sym_glojure_DOT_core, sym_comp) + // var glojure.core/comparator + var_glojure_DOT_core_comparator := lang.InternVarName(sym_glojure_DOT_core, sym_comparator) + // var glojure.core/compare + var_glojure_DOT_core_compare := lang.InternVarName(sym_glojure_DOT_core, sym_compare) + // var glojure.core/compare-and-set! + var_glojure_DOT_core_compare_DASH_and_DASH_set_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_compare_DASH_and_DASH_set_BANG_) + // var glojure.core/compile + var_glojure_DOT_core_compile := lang.InternVarName(sym_glojure_DOT_core, sym_compile) + // var glojure.core/complement + var_glojure_DOT_core_complement := lang.InternVarName(sym_glojure_DOT_core, sym_complement) + // var glojure.core/completing + var_glojure_DOT_core_completing := lang.InternVarName(sym_glojure_DOT_core, sym_completing) + // var glojure.core/concat + var_glojure_DOT_core_concat := lang.InternVarName(sym_glojure_DOT_core, sym_concat) + // var glojure.core/cond + var_glojure_DOT_core_cond := lang.InternVarName(sym_glojure_DOT_core, sym_cond) + // var glojure.core/cond-> + var_glojure_DOT_core_cond_DASH__GT_ := lang.InternVarName(sym_glojure_DOT_core, sym_cond_DASH__GT_) + // var glojure.core/cond->> + var_glojure_DOT_core_cond_DASH__GT__GT_ := lang.InternVarName(sym_glojure_DOT_core, sym_cond_DASH__GT__GT_) + // var glojure.core/condp + var_glojure_DOT_core_condp := lang.InternVarName(sym_glojure_DOT_core, sym_condp) + // var glojure.core/conj + var_glojure_DOT_core_conj := lang.InternVarName(sym_glojure_DOT_core, sym_conj) + // var glojure.core/conj! + var_glojure_DOT_core_conj_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_conj_BANG_) + // var glojure.core/cons + var_glojure_DOT_core_cons := lang.InternVarName(sym_glojure_DOT_core, sym_cons) + // var glojure.core/constantly + var_glojure_DOT_core_constantly := lang.InternVarName(sym_glojure_DOT_core, sym_constantly) + // var glojure.core/contains? + var_glojure_DOT_core_contains_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_contains_QMARK_) + // var glojure.core/count + var_glojure_DOT_core_count := lang.InternVarName(sym_glojure_DOT_core, sym_count) + // var glojure.core/counted? + var_glojure_DOT_core_counted_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_counted_QMARK_) + // var glojure.core/create-ns + var_glojure_DOT_core_create_DASH_ns := lang.InternVarName(sym_glojure_DOT_core, sym_create_DASH_ns) + // var glojure.core/create-struct + var_glojure_DOT_core_create_DASH_struct := lang.InternVarName(sym_glojure_DOT_core, sym_create_DASH_struct) + // var glojure.core/cycle + var_glojure_DOT_core_cycle := lang.InternVarName(sym_glojure_DOT_core, sym_cycle) + // var glojure.core/data-reader-urls + var_glojure_DOT_core_data_DASH_reader_DASH_urls := lang.InternVarName(sym_glojure_DOT_core, sym_data_DASH_reader_DASH_urls) + // var glojure.core/data-reader-var + var_glojure_DOT_core_data_DASH_reader_DASH_var := lang.InternVarName(sym_glojure_DOT_core, sym_data_DASH_reader_DASH_var) + // var glojure.core/dec + var_glojure_DOT_core_dec := lang.InternVarName(sym_glojure_DOT_core, sym_dec) + // var glojure.core/dec' + var_glojure_DOT_core_dec_TICK_ := lang.InternVarName(sym_glojure_DOT_core, sym_dec_TICK_) + // var glojure.core/decimal? + var_glojure_DOT_core_decimal_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_decimal_QMARK_) + // var glojure.core/declare + var_glojure_DOT_core_declare := lang.InternVarName(sym_glojure_DOT_core, sym_declare) + // var glojure.core/dedupe + var_glojure_DOT_core_dedupe := lang.InternVarName(sym_glojure_DOT_core, sym_dedupe) + // var glojure.core/def-aset + var_glojure_DOT_core_def_DASH_aset := lang.InternVarName(sym_glojure_DOT_core, sym_def_DASH_aset) + // var glojure.core/definline + var_glojure_DOT_core_definline := lang.InternVarName(sym_glojure_DOT_core, sym_definline) + // var glojure.core/defmacro + var_glojure_DOT_core_defmacro := lang.InternVarName(sym_glojure_DOT_core, sym_defmacro) + // var glojure.core/defmethod + var_glojure_DOT_core_defmethod := lang.InternVarName(sym_glojure_DOT_core, sym_defmethod) + // var glojure.core/defmulti + var_glojure_DOT_core_defmulti := lang.InternVarName(sym_glojure_DOT_core, sym_defmulti) + // var glojure.core/defn + var_glojure_DOT_core_defn := lang.InternVarName(sym_glojure_DOT_core, sym_defn) + // var glojure.core/defn- + var_glojure_DOT_core_defn_DASH_ := lang.InternVarName(sym_glojure_DOT_core, sym_defn_DASH_) + // var glojure.core/defonce + var_glojure_DOT_core_defonce := lang.InternVarName(sym_glojure_DOT_core, sym_defonce) + // var glojure.core/defprotocol + var_glojure_DOT_core_defprotocol := lang.InternVarName(sym_glojure_DOT_core, sym_defprotocol) + // var glojure.core/defstruct + var_glojure_DOT_core_defstruct := lang.InternVarName(sym_glojure_DOT_core, sym_defstruct) + // var glojure.core/delay + var_glojure_DOT_core_delay := lang.InternVarName(sym_glojure_DOT_core, sym_delay) + // var glojure.core/delay? + var_glojure_DOT_core_delay_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_delay_QMARK_) + // var glojure.core/deliver + var_glojure_DOT_core_deliver := lang.InternVarName(sym_glojure_DOT_core, sym_deliver) + // var glojure.core/denominator + var_glojure_DOT_core_denominator := lang.InternVarName(sym_glojure_DOT_core, sym_denominator) + // var glojure.core/deref + var_glojure_DOT_core_deref := lang.InternVarName(sym_glojure_DOT_core, sym_deref) + // var glojure.core/deref-as-map + var_glojure_DOT_core_deref_DASH_as_DASH_map := lang.InternVarName(sym_glojure_DOT_core, sym_deref_DASH_as_DASH_map) + // var glojure.core/deref-future + var_glojure_DOT_core_deref_DASH_future := lang.InternVarName(sym_glojure_DOT_core, sym_deref_DASH_future) + // var glojure.core/derive + var_glojure_DOT_core_derive := lang.InternVarName(sym_glojure_DOT_core, sym_derive) + // var glojure.core/descendants + var_glojure_DOT_core_descendants := lang.InternVarName(sym_glojure_DOT_core, sym_descendants) + // var glojure.core/destructure + var_glojure_DOT_core_destructure := lang.InternVarName(sym_glojure_DOT_core, sym_destructure) + // var glojure.core/disj + var_glojure_DOT_core_disj := lang.InternVarName(sym_glojure_DOT_core, sym_disj) + // var glojure.core/disj! + var_glojure_DOT_core_disj_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_disj_BANG_) + // var glojure.core/dissoc + var_glojure_DOT_core_dissoc := lang.InternVarName(sym_glojure_DOT_core, sym_dissoc) + // var glojure.core/dissoc! + var_glojure_DOT_core_dissoc_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_dissoc_BANG_) + // var glojure.core/distinct + var_glojure_DOT_core_distinct := lang.InternVarName(sym_glojure_DOT_core, sym_distinct) + // var glojure.core/distinct? + var_glojure_DOT_core_distinct_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_distinct_QMARK_) + // var glojure.core/doall + var_glojure_DOT_core_doall := lang.InternVarName(sym_glojure_DOT_core, sym_doall) + // var glojure.core/dorun + var_glojure_DOT_core_dorun := lang.InternVarName(sym_glojure_DOT_core, sym_dorun) + // var glojure.core/doseq + var_glojure_DOT_core_doseq := lang.InternVarName(sym_glojure_DOT_core, sym_doseq) + // var glojure.core/dosync + var_glojure_DOT_core_dosync := lang.InternVarName(sym_glojure_DOT_core, sym_dosync) + // var glojure.core/dotimes + var_glojure_DOT_core_dotimes := lang.InternVarName(sym_glojure_DOT_core, sym_dotimes) + // var glojure.core/doto + var_glojure_DOT_core_doto := lang.InternVarName(sym_glojure_DOT_core, sym_doto) + // var glojure.core/double + var_glojure_DOT_core_double := lang.InternVarName(sym_glojure_DOT_core, sym_double) + // var glojure.core/double-array + var_glojure_DOT_core_double_DASH_array := lang.InternVarName(sym_glojure_DOT_core, sym_double_DASH_array) + // var glojure.core/double? + var_glojure_DOT_core_double_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_double_QMARK_) + // var glojure.core/doubles + var_glojure_DOT_core_doubles := lang.InternVarName(sym_glojure_DOT_core, sym_doubles) + // var glojure.core/drop + var_glojure_DOT_core_drop := lang.InternVarName(sym_glojure_DOT_core, sym_drop) + // var glojure.core/drop-last + var_glojure_DOT_core_drop_DASH_last := lang.InternVarName(sym_glojure_DOT_core, sym_drop_DASH_last) + // var glojure.core/drop-while + var_glojure_DOT_core_drop_DASH_while := lang.InternVarName(sym_glojure_DOT_core, sym_drop_DASH_while) + // var glojure.core/elide-top-frames + var_glojure_DOT_core_elide_DASH_top_DASH_frames := lang.InternVarName(sym_glojure_DOT_core, sym_elide_DASH_top_DASH_frames) + // var glojure.core/emit-extend-protocol + var_glojure_DOT_core_emit_DASH_extend_DASH_protocol := lang.InternVarName(sym_glojure_DOT_core, sym_emit_DASH_extend_DASH_protocol) + // var glojure.core/emit-extend-type + var_glojure_DOT_core_emit_DASH_extend_DASH_type := lang.InternVarName(sym_glojure_DOT_core, sym_emit_DASH_extend_DASH_type) + // var glojure.core/emit-hinted-impl + var_glojure_DOT_core_emit_DASH_hinted_DASH_impl := lang.InternVarName(sym_glojure_DOT_core, sym_emit_DASH_hinted_DASH_impl) + // var glojure.core/empty + var_glojure_DOT_core_empty := lang.InternVarName(sym_glojure_DOT_core, sym_empty) + // var glojure.core/empty? + var_glojure_DOT_core_empty_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_empty_QMARK_) + // var glojure.core/ensure + var_glojure_DOT_core_ensure := lang.InternVarName(sym_glojure_DOT_core, sym_ensure) + // var glojure.core/ensure-reduced + var_glojure_DOT_core_ensure_DASH_reduced := lang.InternVarName(sym_glojure_DOT_core, sym_ensure_DASH_reduced) + // var glojure.core/enumeration-seq + var_glojure_DOT_core_enumeration_DASH_seq := lang.InternVarName(sym_glojure_DOT_core, sym_enumeration_DASH_seq) + // var glojure.core/error-handler + var_glojure_DOT_core_error_DASH_handler := lang.InternVarName(sym_glojure_DOT_core, sym_error_DASH_handler) + // var glojure.core/error-mode + var_glojure_DOT_core_error_DASH_mode := lang.InternVarName(sym_glojure_DOT_core, sym_error_DASH_mode) + // var glojure.core/eval + var_glojure_DOT_core_eval := lang.InternVarName(sym_glojure_DOT_core, sym_eval) + // var glojure.core/even? + var_glojure_DOT_core_even_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_even_QMARK_) + // var glojure.core/every-pred + var_glojure_DOT_core_every_DASH_pred := lang.InternVarName(sym_glojure_DOT_core, sym_every_DASH_pred) + // var glojure.core/every? + var_glojure_DOT_core_every_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_every_QMARK_) + // var glojure.core/ex-cause + var_glojure_DOT_core_ex_DASH_cause := lang.InternVarName(sym_glojure_DOT_core, sym_ex_DASH_cause) + // var glojure.core/ex-data + var_glojure_DOT_core_ex_DASH_data := lang.InternVarName(sym_glojure_DOT_core, sym_ex_DASH_data) + // var glojure.core/ex-info + var_glojure_DOT_core_ex_DASH_info := lang.InternVarName(sym_glojure_DOT_core, sym_ex_DASH_info) + // var glojure.core/ex-message + var_glojure_DOT_core_ex_DASH_message := lang.InternVarName(sym_glojure_DOT_core, sym_ex_DASH_message) + // var glojure.core/extend + var_glojure_DOT_core_extend := lang.InternVarName(sym_glojure_DOT_core, sym_extend) + // var glojure.core/extend-protocol + var_glojure_DOT_core_extend_DASH_protocol := lang.InternVarName(sym_glojure_DOT_core, sym_extend_DASH_protocol) + // var glojure.core/extend-type + var_glojure_DOT_core_extend_DASH_type := lang.InternVarName(sym_glojure_DOT_core, sym_extend_DASH_type) + // var glojure.core/false? + var_glojure_DOT_core_false_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_false_QMARK_) + // var glojure.core/ffirst + var_glojure_DOT_core_ffirst := lang.InternVarName(sym_glojure_DOT_core, sym_ffirst) + // var glojure.core/file-seq + var_glojure_DOT_core_file_DASH_seq := lang.InternVarName(sym_glojure_DOT_core, sym_file_DASH_seq) + // var glojure.core/filter + var_glojure_DOT_core_filter := lang.InternVarName(sym_glojure_DOT_core, sym_filter) + // var glojure.core/filter-key + var_glojure_DOT_core_filter_DASH_key := lang.InternVarName(sym_glojure_DOT_core, sym_filter_DASH_key) + // var glojure.core/filterv + var_glojure_DOT_core_filterv := lang.InternVarName(sym_glojure_DOT_core, sym_filterv) + // var glojure.core/find + var_glojure_DOT_core_find := lang.InternVarName(sym_glojure_DOT_core, sym_find) + // var glojure.core/find-keyword + var_glojure_DOT_core_find_DASH_keyword := lang.InternVarName(sym_glojure_DOT_core, sym_find_DASH_keyword) + // var glojure.core/find-ns + var_glojure_DOT_core_find_DASH_ns := lang.InternVarName(sym_glojure_DOT_core, sym_find_DASH_ns) + // var glojure.core/find-var + var_glojure_DOT_core_find_DASH_var := lang.InternVarName(sym_glojure_DOT_core, sym_find_DASH_var) + // var glojure.core/first + var_glojure_DOT_core_first := lang.InternVarName(sym_glojure_DOT_core, sym_first) + // var glojure.core/fits-table? + var_glojure_DOT_core_fits_DASH_table_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_fits_DASH_table_QMARK_) + // var glojure.core/flatten + var_glojure_DOT_core_flatten := lang.InternVarName(sym_glojure_DOT_core, sym_flatten) + // var glojure.core/float + var_glojure_DOT_core_float := lang.InternVarName(sym_glojure_DOT_core, sym_float) + // var glojure.core/float-array + var_glojure_DOT_core_float_DASH_array := lang.InternVarName(sym_glojure_DOT_core, sym_float_DASH_array) + // var glojure.core/float? + var_glojure_DOT_core_float_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_float_QMARK_) + // var glojure.core/floats + var_glojure_DOT_core_floats := lang.InternVarName(sym_glojure_DOT_core, sym_floats) + // var glojure.core/flush + var_glojure_DOT_core_flush := lang.InternVarName(sym_glojure_DOT_core, sym_flush) + // var glojure.core/fn + var_glojure_DOT_core_fn := lang.InternVarName(sym_glojure_DOT_core, sym_fn) + // var glojure.core/fn? + var_glojure_DOT_core_fn_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_fn_QMARK_) + // var glojure.core/fnext + var_glojure_DOT_core_fnext := lang.InternVarName(sym_glojure_DOT_core, sym_fnext) + // var glojure.core/fnil + var_glojure_DOT_core_fnil := lang.InternVarName(sym_glojure_DOT_core, sym_fnil) + // var glojure.core/for + var_glojure_DOT_core_for := lang.InternVarName(sym_glojure_DOT_core, sym_for) + // var glojure.core/force + var_glojure_DOT_core_force := lang.InternVarName(sym_glojure_DOT_core, sym_force) + // var glojure.core/format + var_glojure_DOT_core_format := lang.InternVarName(sym_glojure_DOT_core, sym_format) + // var glojure.core/frequencies + var_glojure_DOT_core_frequencies := lang.InternVarName(sym_glojure_DOT_core, sym_frequencies) + // var glojure.core/future + var_glojure_DOT_core_future := lang.InternVarName(sym_glojure_DOT_core, sym_future) + // var glojure.core/future-call + var_glojure_DOT_core_future_DASH_call := lang.InternVarName(sym_glojure_DOT_core, sym_future_DASH_call) + // var glojure.core/future-cancel + var_glojure_DOT_core_future_DASH_cancel := lang.InternVarName(sym_glojure_DOT_core, sym_future_DASH_cancel) + // var glojure.core/future-cancelled? + var_glojure_DOT_core_future_DASH_cancelled_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_future_DASH_cancelled_QMARK_) + // var glojure.core/future-done? + var_glojure_DOT_core_future_DASH_done_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_future_DASH_done_QMARK_) + // var glojure.core/future? + var_glojure_DOT_core_future_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_future_QMARK_) + // var glojure.core/gen-class + var_glojure_DOT_core_gen_DASH_class := lang.InternVarName(sym_glojure_DOT_core, sym_gen_DASH_class) + // var glojure.core/gensym + var_glojure_DOT_core_gensym := lang.InternVarName(sym_glojure_DOT_core, sym_gensym) + // var glojure.core/get + var_glojure_DOT_core_get := lang.InternVarName(sym_glojure_DOT_core, sym_get) + // var glojure.core/get-in + var_glojure_DOT_core_get_DASH_in := lang.InternVarName(sym_glojure_DOT_core, sym_get_DASH_in) + // var glojure.core/get-method + var_glojure_DOT_core_get_DASH_method := lang.InternVarName(sym_glojure_DOT_core, sym_get_DASH_method) + // var glojure.core/get-thread-bindings + var_glojure_DOT_core_get_DASH_thread_DASH_bindings := lang.InternVarName(sym_glojure_DOT_core, sym_get_DASH_thread_DASH_bindings) + // var glojure.core/get-validator + var_glojure_DOT_core_get_DASH_validator := lang.InternVarName(sym_glojure_DOT_core, sym_get_DASH_validator) + // var glojure.core/global-hierarchy + var_glojure_DOT_core_global_DASH_hierarchy := lang.InternVarName(sym_glojure_DOT_core, sym_global_DASH_hierarchy) + // var glojure.core/group-by + var_glojure_DOT_core_group_DASH_by := lang.InternVarName(sym_glojure_DOT_core, sym_group_DASH_by) + // var glojure.core/halt-when + var_glojure_DOT_core_halt_DASH_when := lang.InternVarName(sym_glojure_DOT_core, sym_halt_DASH_when) + // var glojure.core/hash + var_glojure_DOT_core_hash := lang.InternVarName(sym_glojure_DOT_core, sym_hash) + // var glojure.core/hash-map + var_glojure_DOT_core_hash_DASH_map := lang.InternVarName(sym_glojure_DOT_core, sym_hash_DASH_map) + // var glojure.core/hash-ordered-coll + var_glojure_DOT_core_hash_DASH_ordered_DASH_coll := lang.InternVarName(sym_glojure_DOT_core, sym_hash_DASH_ordered_DASH_coll) + // var glojure.core/hash-set + var_glojure_DOT_core_hash_DASH_set := lang.InternVarName(sym_glojure_DOT_core, sym_hash_DASH_set) + // var glojure.core/hash-unordered-coll + var_glojure_DOT_core_hash_DASH_unordered_DASH_coll := lang.InternVarName(sym_glojure_DOT_core, sym_hash_DASH_unordered_DASH_coll) + // var glojure.core/ident? + var_glojure_DOT_core_ident_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_ident_QMARK_) + // var glojure.core/identical? + var_glojure_DOT_core_identical_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_identical_QMARK_) + // var glojure.core/identity + var_glojure_DOT_core_identity := lang.InternVarName(sym_glojure_DOT_core, sym_identity) + // var glojure.core/if-let + var_glojure_DOT_core_if_DASH_let := lang.InternVarName(sym_glojure_DOT_core, sym_if_DASH_let) + // var glojure.core/if-not + var_glojure_DOT_core_if_DASH_not := lang.InternVarName(sym_glojure_DOT_core, sym_if_DASH_not) + // var glojure.core/if-some + var_glojure_DOT_core_if_DASH_some := lang.InternVarName(sym_glojure_DOT_core, sym_if_DASH_some) + // var glojure.core/ifn? + var_glojure_DOT_core_ifn_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_ifn_QMARK_) + // var glojure.core/import + var_glojure_DOT_core_import := lang.InternVarName(sym_glojure_DOT_core, sym_import) + // var glojure.core/inc + var_glojure_DOT_core_inc := lang.InternVarName(sym_glojure_DOT_core, sym_inc) + // var glojure.core/inc' + var_glojure_DOT_core_inc_TICK_ := lang.InternVarName(sym_glojure_DOT_core, sym_inc_TICK_) + // var glojure.core/indexed? + var_glojure_DOT_core_indexed_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_indexed_QMARK_) + // var glojure.core/infinite? + var_glojure_DOT_core_infinite_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_infinite_QMARK_) + // var glojure.core/inst-ms + var_glojure_DOT_core_inst_DASH_ms := lang.InternVarName(sym_glojure_DOT_core, sym_inst_DASH_ms) + // var glojure.core/inst? + var_glojure_DOT_core_inst_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_inst_QMARK_) + // var glojure.core/instance? + var_glojure_DOT_core_instance_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_instance_QMARK_) + // var glojure.core/int + var_glojure_DOT_core_int := lang.InternVarName(sym_glojure_DOT_core, sym_int) + // var glojure.core/int-array + var_glojure_DOT_core_int_DASH_array := lang.InternVarName(sym_glojure_DOT_core, sym_int_DASH_array) + // var glojure.core/int? + var_glojure_DOT_core_int_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_int_QMARK_) + // var glojure.core/integer? + var_glojure_DOT_core_integer_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_integer_QMARK_) + // var glojure.core/interleave + var_glojure_DOT_core_interleave := lang.InternVarName(sym_glojure_DOT_core, sym_interleave) + // var glojure.core/intern + var_glojure_DOT_core_intern := lang.InternVarName(sym_glojure_DOT_core, sym_intern) + // var glojure.core/interpose + var_glojure_DOT_core_interpose := lang.InternVarName(sym_glojure_DOT_core, sym_interpose) + // var glojure.core/into + var_glojure_DOT_core_into := lang.InternVarName(sym_glojure_DOT_core, sym_into) + // var glojure.core/into1 + var_glojure_DOT_core_into1 := lang.InternVarName(sym_glojure_DOT_core, sym_into1) + // var glojure.core/into-array + var_glojure_DOT_core_into_DASH_array := lang.InternVarName(sym_glojure_DOT_core, sym_into_DASH_array) + // var glojure.core/ints + var_glojure_DOT_core_ints := lang.InternVarName(sym_glojure_DOT_core, sym_ints) + // var glojure.core/io! + var_glojure_DOT_core_io_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_io_BANG_) + // var glojure.core/isa? + var_glojure_DOT_core_isa_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_isa_QMARK_) + // var glojure.core/iterate + var_glojure_DOT_core_iterate := lang.InternVarName(sym_glojure_DOT_core, sym_iterate) + // var glojure.core/iteration + var_glojure_DOT_core_iteration := lang.InternVarName(sym_glojure_DOT_core, sym_iteration) + // var glojure.core/iterator-seq + var_glojure_DOT_core_iterator_DASH_seq := lang.InternVarName(sym_glojure_DOT_core, sym_iterator_DASH_seq) + // var glojure.core/juxt + var_glojure_DOT_core_juxt := lang.InternVarName(sym_glojure_DOT_core, sym_juxt) + // var glojure.core/keep + var_glojure_DOT_core_keep := lang.InternVarName(sym_glojure_DOT_core, sym_keep) + // var glojure.core/keep-indexed + var_glojure_DOT_core_keep_DASH_indexed := lang.InternVarName(sym_glojure_DOT_core, sym_keep_DASH_indexed) + // var glojure.core/key + var_glojure_DOT_core_key := lang.InternVarName(sym_glojure_DOT_core, sym_key) + // var glojure.core/keys + var_glojure_DOT_core_keys := lang.InternVarName(sym_glojure_DOT_core, sym_keys) + // var glojure.core/keyword + var_glojure_DOT_core_keyword := lang.InternVarName(sym_glojure_DOT_core, sym_keyword) + // var glojure.core/keyword? + var_glojure_DOT_core_keyword_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_keyword_QMARK_) + // var glojure.core/last + var_glojure_DOT_core_last := lang.InternVarName(sym_glojure_DOT_core, sym_last) + // var glojure.core/lazy-cat + var_glojure_DOT_core_lazy_DASH_cat := lang.InternVarName(sym_glojure_DOT_core, sym_lazy_DASH_cat) + // var glojure.core/lazy-seq + var_glojure_DOT_core_lazy_DASH_seq := lang.InternVarName(sym_glojure_DOT_core, sym_lazy_DASH_seq) + // var glojure.core/let + var_glojure_DOT_core_let := lang.InternVarName(sym_glojure_DOT_core, sym_let) + // var glojure.core/letfn + var_glojure_DOT_core_letfn := lang.InternVarName(sym_glojure_DOT_core, sym_letfn) + // var glojure.core/libspec? + var_glojure_DOT_core_libspec_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_libspec_QMARK_) + // var glojure.core/lift-ns + var_glojure_DOT_core_lift_DASH_ns := lang.InternVarName(sym_glojure_DOT_core, sym_lift_DASH_ns) + // var glojure.core/line-seq + var_glojure_DOT_core_line_DASH_seq := lang.InternVarName(sym_glojure_DOT_core, sym_line_DASH_seq) + // var glojure.core/list + var_glojure_DOT_core_list := lang.InternVarName(sym_glojure_DOT_core, sym_list) + // var glojure.core/list? + var_glojure_DOT_core_list_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_list_QMARK_) + // var glojure.core/list* + var_glojure_DOT_core_list_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym_list_STAR_) + // var glojure.core/load + var_glojure_DOT_core_load := lang.InternVarName(sym_glojure_DOT_core, sym_load) + // var glojure.core/load-all + var_glojure_DOT_core_load_DASH_all := lang.InternVarName(sym_glojure_DOT_core, sym_load_DASH_all) + // var glojure.core/load-data-reader-file + var_glojure_DOT_core_load_DASH_data_DASH_reader_DASH_file := lang.InternVarName(sym_glojure_DOT_core, sym_load_DASH_data_DASH_reader_DASH_file) + // var glojure.core/load-data-readers + var_glojure_DOT_core_load_DASH_data_DASH_readers := lang.InternVarName(sym_glojure_DOT_core, sym_load_DASH_data_DASH_readers) + // var glojure.core/load-file + var_glojure_DOT_core_load_DASH_file := lang.InternVarName(sym_glojure_DOT_core, sym_load_DASH_file) + // var glojure.core/load-lib + var_glojure_DOT_core_load_DASH_lib := lang.InternVarName(sym_glojure_DOT_core, sym_load_DASH_lib) + // var glojure.core/load-libs + var_glojure_DOT_core_load_DASH_libs := lang.InternVarName(sym_glojure_DOT_core, sym_load_DASH_libs) + // var glojure.core/load-one + var_glojure_DOT_core_load_DASH_one := lang.InternVarName(sym_glojure_DOT_core, sym_load_DASH_one) + // var glojure.core/load-reader + var_glojure_DOT_core_load_DASH_reader := lang.InternVarName(sym_glojure_DOT_core, sym_load_DASH_reader) + // var glojure.core/load-string + var_glojure_DOT_core_load_DASH_string := lang.InternVarName(sym_glojure_DOT_core, sym_load_DASH_string) + // var glojure.core/loaded-libs + var_glojure_DOT_core_loaded_DASH_libs := lang.InternVarName(sym_glojure_DOT_core, sym_loaded_DASH_libs) + // var glojure.core/locking + var_glojure_DOT_core_locking := lang.InternVarName(sym_glojure_DOT_core, sym_locking) + // var glojure.core/long + var_glojure_DOT_core_long := lang.InternVarName(sym_glojure_DOT_core, sym_long) + // var glojure.core/long-array + var_glojure_DOT_core_long_DASH_array := lang.InternVarName(sym_glojure_DOT_core, sym_long_DASH_array) + // var glojure.core/longs + var_glojure_DOT_core_longs := lang.InternVarName(sym_glojure_DOT_core, sym_longs) + // var glojure.core/loop + var_glojure_DOT_core_loop := lang.InternVarName(sym_glojure_DOT_core, sym_loop) + // var glojure.core/macroexpand + var_glojure_DOT_core_macroexpand := lang.InternVarName(sym_glojure_DOT_core, sym_macroexpand) + // var glojure.core/macroexpand-1 + var_glojure_DOT_core_macroexpand_DASH_1 := lang.InternVarName(sym_glojure_DOT_core, sym_macroexpand_DASH_1) + // var glojure.core/make-array + var_glojure_DOT_core_make_DASH_array := lang.InternVarName(sym_glojure_DOT_core, sym_make_DASH_array) + // var glojure.core/make-hierarchy + var_glojure_DOT_core_make_DASH_hierarchy := lang.InternVarName(sym_glojure_DOT_core, sym_make_DASH_hierarchy) + // var glojure.core/map + var_glojure_DOT_core_map := lang.InternVarName(sym_glojure_DOT_core, sym_map) + // var glojure.core/map-entry? + var_glojure_DOT_core_map_DASH_entry_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_map_DASH_entry_QMARK_) + // var glojure.core/map-indexed + var_glojure_DOT_core_map_DASH_indexed := lang.InternVarName(sym_glojure_DOT_core, sym_map_DASH_indexed) + // var glojure.core/map? + var_glojure_DOT_core_map_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_map_QMARK_) + // var glojure.core/mapcat + var_glojure_DOT_core_mapcat := lang.InternVarName(sym_glojure_DOT_core, sym_mapcat) + // var glojure.core/mapv + var_glojure_DOT_core_mapv := lang.InternVarName(sym_glojure_DOT_core, sym_mapv) + // var glojure.core/max + var_glojure_DOT_core_max := lang.InternVarName(sym_glojure_DOT_core, sym_max) + // var glojure.core/max-key + var_glojure_DOT_core_max_DASH_key := lang.InternVarName(sym_glojure_DOT_core, sym_max_DASH_key) + // var glojure.core/max-mask-bits + var_glojure_DOT_core_max_DASH_mask_DASH_bits := lang.InternVarName(sym_glojure_DOT_core, sym_max_DASH_mask_DASH_bits) + // var glojure.core/max-switch-table-size + var_glojure_DOT_core_max_DASH_switch_DASH_table_DASH_size := lang.InternVarName(sym_glojure_DOT_core, sym_max_DASH_switch_DASH_table_DASH_size) + // var glojure.core/maybe-destructured + var_glojure_DOT_core_maybe_DASH_destructured := lang.InternVarName(sym_glojure_DOT_core, sym_maybe_DASH_destructured) + // var glojure.core/maybe-min-hash + var_glojure_DOT_core_maybe_DASH_min_DASH_hash := lang.InternVarName(sym_glojure_DOT_core, sym_maybe_DASH_min_DASH_hash) + // var glojure.core/memfn + var_glojure_DOT_core_memfn := lang.InternVarName(sym_glojure_DOT_core, sym_memfn) + // var glojure.core/memoize + var_glojure_DOT_core_memoize := lang.InternVarName(sym_glojure_DOT_core, sym_memoize) + // var glojure.core/merge + var_glojure_DOT_core_merge := lang.InternVarName(sym_glojure_DOT_core, sym_merge) + // var glojure.core/merge-hash-collisions + var_glojure_DOT_core_merge_DASH_hash_DASH_collisions := lang.InternVarName(sym_glojure_DOT_core, sym_merge_DASH_hash_DASH_collisions) + // var glojure.core/merge-with + var_glojure_DOT_core_merge_DASH_with := lang.InternVarName(sym_glojure_DOT_core, sym_merge_DASH_with) + // var glojure.core/meta + var_glojure_DOT_core_meta := lang.InternVarName(sym_glojure_DOT_core, sym_meta) + // var glojure.core/methods + var_glojure_DOT_core_methods := lang.InternVarName(sym_glojure_DOT_core, sym_methods) + // var glojure.core/min + var_glojure_DOT_core_min := lang.InternVarName(sym_glojure_DOT_core, sym_min) + // var glojure.core/min-key + var_glojure_DOT_core_min_DASH_key := lang.InternVarName(sym_glojure_DOT_core, sym_min_DASH_key) + // var glojure.core/mix-collection-hash + var_glojure_DOT_core_mix_DASH_collection_DASH_hash := lang.InternVarName(sym_glojure_DOT_core, sym_mix_DASH_collection_DASH_hash) + // var glojure.core/mk-bound-fn + var_glojure_DOT_core_mk_DASH_bound_DASH_fn := lang.InternVarName(sym_glojure_DOT_core, sym_mk_DASH_bound_DASH_fn) + // var glojure.core/mod + var_glojure_DOT_core_mod := lang.InternVarName(sym_glojure_DOT_core, sym_mod) + // var glojure.core/name + var_glojure_DOT_core_name := lang.InternVarName(sym_glojure_DOT_core, sym_name) + // var glojure.core/namespace + var_glojure_DOT_core_namespace := lang.InternVarName(sym_glojure_DOT_core, sym_namespace) + // var glojure.core/nary-inline + var_glojure_DOT_core_nary_DASH_inline := lang.InternVarName(sym_glojure_DOT_core, sym_nary_DASH_inline) + // var glojure.core/nat-int? + var_glojure_DOT_core_nat_DASH_int_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_nat_DASH_int_QMARK_) + // var glojure.core/neg-int? + var_glojure_DOT_core_neg_DASH_int_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_neg_DASH_int_QMARK_) + // var glojure.core/neg? + var_glojure_DOT_core_neg_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_neg_QMARK_) + // var glojure.core/newline + var_glojure_DOT_core_newline := lang.InternVarName(sym_glojure_DOT_core, sym_newline) + // var glojure.core/next + var_glojure_DOT_core_next := lang.InternVarName(sym_glojure_DOT_core, sym_next) + // var glojure.core/nfirst + var_glojure_DOT_core_nfirst := lang.InternVarName(sym_glojure_DOT_core, sym_nfirst) + // var glojure.core/nil? + var_glojure_DOT_core_nil_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_nil_QMARK_) + // var glojure.core/nnext + var_glojure_DOT_core_nnext := lang.InternVarName(sym_glojure_DOT_core, sym_nnext) + // var glojure.core/normalize-slurp-opts + var_glojure_DOT_core_normalize_DASH_slurp_DASH_opts := lang.InternVarName(sym_glojure_DOT_core, sym_normalize_DASH_slurp_DASH_opts) + // var glojure.core/not + var_glojure_DOT_core_not := lang.InternVarName(sym_glojure_DOT_core, sym_not) + // var glojure.core/not-any? + var_glojure_DOT_core_not_DASH_any_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_not_DASH_any_QMARK_) + // var glojure.core/not-empty + var_glojure_DOT_core_not_DASH_empty := lang.InternVarName(sym_glojure_DOT_core, sym_not_DASH_empty) + // var glojure.core/not-every? + var_glojure_DOT_core_not_DASH_every_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_not_DASH_every_QMARK_) + // var glojure.core/not= + var_glojure_DOT_core_not_EQ_ := lang.InternVarName(sym_glojure_DOT_core, sym_not_EQ_) + // var glojure.core/ns + var_glojure_DOT_core_ns := lang.InternVarName(sym_glojure_DOT_core, sym_ns) + // var glojure.core/ns-aliases + var_glojure_DOT_core_ns_DASH_aliases := lang.InternVarName(sym_glojure_DOT_core, sym_ns_DASH_aliases) + // var glojure.core/ns-imports + var_glojure_DOT_core_ns_DASH_imports := lang.InternVarName(sym_glojure_DOT_core, sym_ns_DASH_imports) + // var glojure.core/ns-interns + var_glojure_DOT_core_ns_DASH_interns := lang.InternVarName(sym_glojure_DOT_core, sym_ns_DASH_interns) + // var glojure.core/ns-map + var_glojure_DOT_core_ns_DASH_map := lang.InternVarName(sym_glojure_DOT_core, sym_ns_DASH_map) + // var glojure.core/ns-name + var_glojure_DOT_core_ns_DASH_name := lang.InternVarName(sym_glojure_DOT_core, sym_ns_DASH_name) + // var glojure.core/ns-publics + var_glojure_DOT_core_ns_DASH_publics := lang.InternVarName(sym_glojure_DOT_core, sym_ns_DASH_publics) + // var glojure.core/ns-refers + var_glojure_DOT_core_ns_DASH_refers := lang.InternVarName(sym_glojure_DOT_core, sym_ns_DASH_refers) + // var glojure.core/ns-resolve + var_glojure_DOT_core_ns_DASH_resolve := lang.InternVarName(sym_glojure_DOT_core, sym_ns_DASH_resolve) + // var glojure.core/ns-unalias + var_glojure_DOT_core_ns_DASH_unalias := lang.InternVarName(sym_glojure_DOT_core, sym_ns_DASH_unalias) + // var glojure.core/ns-unmap + var_glojure_DOT_core_ns_DASH_unmap := lang.InternVarName(sym_glojure_DOT_core, sym_ns_DASH_unmap) + // var glojure.core/nth + var_glojure_DOT_core_nth := lang.InternVarName(sym_glojure_DOT_core, sym_nth) + // var glojure.core/nthnext + var_glojure_DOT_core_nthnext := lang.InternVarName(sym_glojure_DOT_core, sym_nthnext) + // var glojure.core/nthrest + var_glojure_DOT_core_nthrest := lang.InternVarName(sym_glojure_DOT_core, sym_nthrest) + // var glojure.core/num + var_glojure_DOT_core_num := lang.InternVarName(sym_glojure_DOT_core, sym_num) + // var glojure.core/number? + var_glojure_DOT_core_number_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_number_QMARK_) + // var glojure.core/numerator + var_glojure_DOT_core_numerator := lang.InternVarName(sym_glojure_DOT_core, sym_numerator) + // var glojure.core/object-array + var_glojure_DOT_core_object_DASH_array := lang.InternVarName(sym_glojure_DOT_core, sym_object_DASH_array) + // var glojure.core/odd? + var_glojure_DOT_core_odd_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_odd_QMARK_) + // var glojure.core/or + var_glojure_DOT_core_or := lang.InternVarName(sym_glojure_DOT_core, sym_or) + // var glojure.core/parents + var_glojure_DOT_core_parents := lang.InternVarName(sym_glojure_DOT_core, sym_parents) + // var glojure.core/parse-boolean + var_glojure_DOT_core_parse_DASH_boolean := lang.InternVarName(sym_glojure_DOT_core, sym_parse_DASH_boolean) + // var glojure.core/parse-double + var_glojure_DOT_core_parse_DASH_double := lang.InternVarName(sym_glojure_DOT_core, sym_parse_DASH_double) + // var glojure.core/parse-impls + var_glojure_DOT_core_parse_DASH_impls := lang.InternVarName(sym_glojure_DOT_core, sym_parse_DASH_impls) + // var glojure.core/parse-long + var_glojure_DOT_core_parse_DASH_long := lang.InternVarName(sym_glojure_DOT_core, sym_parse_DASH_long) + // var glojure.core/parse-uuid + var_glojure_DOT_core_parse_DASH_uuid := lang.InternVarName(sym_glojure_DOT_core, sym_parse_DASH_uuid) + // var glojure.core/parsing-err + var_glojure_DOT_core_parsing_DASH_err := lang.InternVarName(sym_glojure_DOT_core, sym_parsing_DASH_err) + // var glojure.core/partial + var_glojure_DOT_core_partial := lang.InternVarName(sym_glojure_DOT_core, sym_partial) + // var glojure.core/partition + var_glojure_DOT_core_partition := lang.InternVarName(sym_glojure_DOT_core, sym_partition) + // var glojure.core/partition-all + var_glojure_DOT_core_partition_DASH_all := lang.InternVarName(sym_glojure_DOT_core, sym_partition_DASH_all) + // var glojure.core/partition-by + var_glojure_DOT_core_partition_DASH_by := lang.InternVarName(sym_glojure_DOT_core, sym_partition_DASH_by) + // var glojure.core/partitionv + var_glojure_DOT_core_partitionv := lang.InternVarName(sym_glojure_DOT_core, sym_partitionv) + // var glojure.core/partitionv-all + var_glojure_DOT_core_partitionv_DASH_all := lang.InternVarName(sym_glojure_DOT_core, sym_partitionv_DASH_all) + // var glojure.core/pcalls + var_glojure_DOT_core_pcalls := lang.InternVarName(sym_glojure_DOT_core, sym_pcalls) + // var glojure.core/peek + var_glojure_DOT_core_peek := lang.InternVarName(sym_glojure_DOT_core, sym_peek) + // var glojure.core/persistent! + var_glojure_DOT_core_persistent_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_persistent_BANG_) + // var glojure.core/pmap + var_glojure_DOT_core_pmap := lang.InternVarName(sym_glojure_DOT_core, sym_pmap) + // var glojure.core/pop + var_glojure_DOT_core_pop := lang.InternVarName(sym_glojure_DOT_core, sym_pop) + // var glojure.core/pop! + var_glojure_DOT_core_pop_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_pop_BANG_) + // var glojure.core/pop-thread-bindings + var_glojure_DOT_core_pop_DASH_thread_DASH_bindings := lang.InternVarName(sym_glojure_DOT_core, sym_pop_DASH_thread_DASH_bindings) + // var glojure.core/pos-int? + var_glojure_DOT_core_pos_DASH_int_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_pos_DASH_int_QMARK_) + // var glojure.core/pos? + var_glojure_DOT_core_pos_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_pos_QMARK_) + // var glojure.core/pr + var_glojure_DOT_core_pr := lang.InternVarName(sym_glojure_DOT_core, sym_pr) + // var glojure.core/pr-on + var_glojure_DOT_core_pr_DASH_on := lang.InternVarName(sym_glojure_DOT_core, sym_pr_DASH_on) + // var glojure.core/pr-str + var_glojure_DOT_core_pr_DASH_str := lang.InternVarName(sym_glojure_DOT_core, sym_pr_DASH_str) + // var glojure.core/prefer-method + var_glojure_DOT_core_prefer_DASH_method := lang.InternVarName(sym_glojure_DOT_core, sym_prefer_DASH_method) + // var glojure.core/prefers + var_glojure_DOT_core_prefers := lang.InternVarName(sym_glojure_DOT_core, sym_prefers) + // var glojure.core/prep-hashes + var_glojure_DOT_core_prep_DASH_hashes := lang.InternVarName(sym_glojure_DOT_core, sym_prep_DASH_hashes) + // var glojure.core/prep-ints + var_glojure_DOT_core_prep_DASH_ints := lang.InternVarName(sym_glojure_DOT_core, sym_prep_DASH_ints) + // var glojure.core/prependss + var_glojure_DOT_core_prependss := lang.InternVarName(sym_glojure_DOT_core, sym_prependss) + // var glojure.core/preserving-reduced + var_glojure_DOT_core_preserving_DASH_reduced := lang.InternVarName(sym_glojure_DOT_core, sym_preserving_DASH_reduced) + // var glojure.core/print + var_glojure_DOT_core_print := lang.InternVarName(sym_glojure_DOT_core, sym_print) + // var glojure.core/print-ctor + var_glojure_DOT_core_print_DASH_ctor := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_ctor) + // var glojure.core/print-dup + var_glojure_DOT_core_print_DASH_dup := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_dup) + // var glojure.core/print-initialized + var_glojure_DOT_core_print_DASH_initialized := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_initialized) + // var glojure.core/print-map + var_glojure_DOT_core_print_DASH_map := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_map) + // var glojure.core/print-meta + var_glojure_DOT_core_print_DASH_meta := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_meta) + // var glojure.core/print-method + var_glojure_DOT_core_print_DASH_method := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_method) + // var glojure.core/print-object + var_glojure_DOT_core_print_DASH_object := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_object) + // var glojure.core/print-prefix-map + var_glojure_DOT_core_print_DASH_prefix_DASH_map := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_prefix_DASH_map) + // var glojure.core/print-sequential + var_glojure_DOT_core_print_DASH_sequential := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_sequential) + // var glojure.core/print-simple + var_glojure_DOT_core_print_DASH_simple := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_simple) + // var glojure.core/print-str + var_glojure_DOT_core_print_DASH_str := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_str) + // var glojure.core/print-tagged-object + var_glojure_DOT_core_print_DASH_tagged_DASH_object := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_tagged_DASH_object) + // var glojure.core/print-throwable + var_glojure_DOT_core_print_DASH_throwable := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_throwable) + // var glojure.core/printf + var_glojure_DOT_core_printf := lang.InternVarName(sym_glojure_DOT_core, sym_printf) + // var glojure.core/println + var_glojure_DOT_core_println := lang.InternVarName(sym_glojure_DOT_core, sym_println) + // var glojure.core/println-str + var_glojure_DOT_core_println_DASH_str := lang.InternVarName(sym_glojure_DOT_core, sym_println_DASH_str) + // var glojure.core/prn + var_glojure_DOT_core_prn := lang.InternVarName(sym_glojure_DOT_core, sym_prn) + // var glojure.core/prn-str + var_glojure_DOT_core_prn_DASH_str := lang.InternVarName(sym_glojure_DOT_core, sym_prn_DASH_str) + // var glojure.core/promise + var_glojure_DOT_core_promise := lang.InternVarName(sym_glojure_DOT_core, sym_promise) + // var glojure.core/protocol? + var_glojure_DOT_core_protocol_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_protocol_QMARK_) + // var glojure.core/push-thread-bindings + var_glojure_DOT_core_push_DASH_thread_DASH_bindings := lang.InternVarName(sym_glojure_DOT_core, sym_push_DASH_thread_DASH_bindings) + // var glojure.core/pvalues + var_glojure_DOT_core_pvalues := lang.InternVarName(sym_glojure_DOT_core, sym_pvalues) + // var glojure.core/qualified-ident? + var_glojure_DOT_core_qualified_DASH_ident_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_qualified_DASH_ident_QMARK_) + // var glojure.core/qualified-keyword? + var_glojure_DOT_core_qualified_DASH_keyword_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_qualified_DASH_keyword_QMARK_) + // var glojure.core/qualified-symbol? + var_glojure_DOT_core_qualified_DASH_symbol_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_qualified_DASH_symbol_QMARK_) + // var glojure.core/quot + var_glojure_DOT_core_quot := lang.InternVarName(sym_glojure_DOT_core, sym_quot) + // var glojure.core/rand + var_glojure_DOT_core_rand := lang.InternVarName(sym_glojure_DOT_core, sym_rand) + // var glojure.core/rand-int + var_glojure_DOT_core_rand_DASH_int := lang.InternVarName(sym_glojure_DOT_core, sym_rand_DASH_int) + // var glojure.core/rand-nth + var_glojure_DOT_core_rand_DASH_nth := lang.InternVarName(sym_glojure_DOT_core, sym_rand_DASH_nth) + // var glojure.core/random-sample + var_glojure_DOT_core_random_DASH_sample := lang.InternVarName(sym_glojure_DOT_core, sym_random_DASH_sample) + // var glojure.core/random-uuid + var_glojure_DOT_core_random_DASH_uuid := lang.InternVarName(sym_glojure_DOT_core, sym_random_DASH_uuid) + // var glojure.core/range + var_glojure_DOT_core_range := lang.InternVarName(sym_glojure_DOT_core, sym_range) + // var glojure.core/ratio? + var_glojure_DOT_core_ratio_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_ratio_QMARK_) + // var glojure.core/rational? + var_glojure_DOT_core_rational_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_rational_QMARK_) + // var glojure.core/rationalize + var_glojure_DOT_core_rationalize := lang.InternVarName(sym_glojure_DOT_core, sym_rationalize) + // var glojure.core/re-find + var_glojure_DOT_core_re_DASH_find := lang.InternVarName(sym_glojure_DOT_core, sym_re_DASH_find) + // var glojure.core/re-groups + var_glojure_DOT_core_re_DASH_groups := lang.InternVarName(sym_glojure_DOT_core, sym_re_DASH_groups) + // var glojure.core/re-matcher + var_glojure_DOT_core_re_DASH_matcher := lang.InternVarName(sym_glojure_DOT_core, sym_re_DASH_matcher) + // var glojure.core/re-matches + var_glojure_DOT_core_re_DASH_matches := lang.InternVarName(sym_glojure_DOT_core, sym_re_DASH_matches) + // var glojure.core/re-pattern + var_glojure_DOT_core_re_DASH_pattern := lang.InternVarName(sym_glojure_DOT_core, sym_re_DASH_pattern) + // var glojure.core/re-seq + var_glojure_DOT_core_re_DASH_seq := lang.InternVarName(sym_glojure_DOT_core, sym_re_DASH_seq) + // var glojure.core/read + var_glojure_DOT_core_read := lang.InternVarName(sym_glojure_DOT_core, sym_read) + // var glojure.core/read-line + var_glojure_DOT_core_read_DASH_line := lang.InternVarName(sym_glojure_DOT_core, sym_read_DASH_line) + // var glojure.core/read-string + var_glojure_DOT_core_read_DASH_string := lang.InternVarName(sym_glojure_DOT_core, sym_read_DASH_string) + // var glojure.core/read+string + var_glojure_DOT_core_read_PLUS_string := lang.InternVarName(sym_glojure_DOT_core, sym_read_PLUS_string) + // var glojure.core/reader-conditional + var_glojure_DOT_core_reader_DASH_conditional := lang.InternVarName(sym_glojure_DOT_core, sym_reader_DASH_conditional) + // var glojure.core/reader-conditional? + var_glojure_DOT_core_reader_DASH_conditional_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_reader_DASH_conditional_QMARK_) + // var glojure.core/realized? + var_glojure_DOT_core_realized_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_realized_QMARK_) + // var glojure.core/reduce + var_glojure_DOT_core_reduce := lang.InternVarName(sym_glojure_DOT_core, sym_reduce) + // var glojure.core/reduce1 + var_glojure_DOT_core_reduce1 := lang.InternVarName(sym_glojure_DOT_core, sym_reduce1) + // var glojure.core/reduce-kv + var_glojure_DOT_core_reduce_DASH_kv := lang.InternVarName(sym_glojure_DOT_core, sym_reduce_DASH_kv) + // var glojure.core/reduced + var_glojure_DOT_core_reduced := lang.InternVarName(sym_glojure_DOT_core, sym_reduced) + // var glojure.core/reduced? + var_glojure_DOT_core_reduced_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_reduced_QMARK_) + // var glojure.core/reductions + var_glojure_DOT_core_reductions := lang.InternVarName(sym_glojure_DOT_core, sym_reductions) + // var glojure.core/ref + var_glojure_DOT_core_ref := lang.InternVarName(sym_glojure_DOT_core, sym_ref) + // var glojure.core/ref-history-count + var_glojure_DOT_core_ref_DASH_history_DASH_count := lang.InternVarName(sym_glojure_DOT_core, sym_ref_DASH_history_DASH_count) + // var glojure.core/ref-max-history + var_glojure_DOT_core_ref_DASH_max_DASH_history := lang.InternVarName(sym_glojure_DOT_core, sym_ref_DASH_max_DASH_history) + // var glojure.core/ref-min-history + var_glojure_DOT_core_ref_DASH_min_DASH_history := lang.InternVarName(sym_glojure_DOT_core, sym_ref_DASH_min_DASH_history) + // var glojure.core/ref-set + var_glojure_DOT_core_ref_DASH_set := lang.InternVarName(sym_glojure_DOT_core, sym_ref_DASH_set) + // var glojure.core/refer + var_glojure_DOT_core_refer := lang.InternVarName(sym_glojure_DOT_core, sym_refer) + // var glojure.core/refer-glojure + var_glojure_DOT_core_refer_DASH_glojure := lang.InternVarName(sym_glojure_DOT_core, sym_refer_DASH_glojure) + // var glojure.core/release-pending-sends + var_glojure_DOT_core_release_DASH_pending_DASH_sends := lang.InternVarName(sym_glojure_DOT_core, sym_release_DASH_pending_DASH_sends) + // var glojure.core/rem + var_glojure_DOT_core_rem := lang.InternVarName(sym_glojure_DOT_core, sym_rem) + // var glojure.core/remove + var_glojure_DOT_core_remove := lang.InternVarName(sym_glojure_DOT_core, sym_remove) + // var glojure.core/remove-all-methods + var_glojure_DOT_core_remove_DASH_all_DASH_methods := lang.InternVarName(sym_glojure_DOT_core, sym_remove_DASH_all_DASH_methods) + // var glojure.core/remove-method + var_glojure_DOT_core_remove_DASH_method := lang.InternVarName(sym_glojure_DOT_core, sym_remove_DASH_method) + // var glojure.core/remove-ns + var_glojure_DOT_core_remove_DASH_ns := lang.InternVarName(sym_glojure_DOT_core, sym_remove_DASH_ns) + // var glojure.core/remove-tap + var_glojure_DOT_core_remove_DASH_tap := lang.InternVarName(sym_glojure_DOT_core, sym_remove_DASH_tap) + // var glojure.core/remove-watch + var_glojure_DOT_core_remove_DASH_watch := lang.InternVarName(sym_glojure_DOT_core, sym_remove_DASH_watch) + // var glojure.core/repeat + var_glojure_DOT_core_repeat := lang.InternVarName(sym_glojure_DOT_core, sym_repeat) + // var glojure.core/repeatedly + var_glojure_DOT_core_repeatedly := lang.InternVarName(sym_glojure_DOT_core, sym_repeatedly) + // var glojure.core/replace + var_glojure_DOT_core_replace := lang.InternVarName(sym_glojure_DOT_core, sym_replace) + // var glojure.core/replicate + var_glojure_DOT_core_replicate := lang.InternVarName(sym_glojure_DOT_core, sym_replicate) + // var glojure.core/require + var_glojure_DOT_core_require := lang.InternVarName(sym_glojure_DOT_core, sym_require) + // var glojure.core/requiring-resolve + var_glojure_DOT_core_requiring_DASH_resolve := lang.InternVarName(sym_glojure_DOT_core, sym_requiring_DASH_resolve) + // var glojure.core/reset! + var_glojure_DOT_core_reset_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_reset_BANG_) + // var glojure.core/reset-meta! + var_glojure_DOT_core_reset_DASH_meta_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_reset_DASH_meta_BANG_) + // var glojure.core/reset-vals! + var_glojure_DOT_core_reset_DASH_vals_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_reset_DASH_vals_BANG_) + // var glojure.core/resolve + var_glojure_DOT_core_resolve := lang.InternVarName(sym_glojure_DOT_core, sym_resolve) + // var glojure.core/rest + var_glojure_DOT_core_rest := lang.InternVarName(sym_glojure_DOT_core, sym_rest) + // var glojure.core/restart-agent + var_glojure_DOT_core_restart_DASH_agent := lang.InternVarName(sym_glojure_DOT_core, sym_restart_DASH_agent) + // var glojure.core/resultset-seq + var_glojure_DOT_core_resultset_DASH_seq := lang.InternVarName(sym_glojure_DOT_core, sym_resultset_DASH_seq) + // var glojure.core/reverse + var_glojure_DOT_core_reverse := lang.InternVarName(sym_glojure_DOT_core, sym_reverse) + // var glojure.core/reversible? + var_glojure_DOT_core_reversible_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_reversible_QMARK_) + // var glojure.core/root-directory + var_glojure_DOT_core_root_DASH_directory := lang.InternVarName(sym_glojure_DOT_core, sym_root_DASH_directory) + // var glojure.core/root-resource + var_glojure_DOT_core_root_DASH_resource := lang.InternVarName(sym_glojure_DOT_core, sym_root_DASH_resource) + // var glojure.core/rseq + var_glojure_DOT_core_rseq := lang.InternVarName(sym_glojure_DOT_core, sym_rseq) + // var glojure.core/rsubseq + var_glojure_DOT_core_rsubseq := lang.InternVarName(sym_glojure_DOT_core, sym_rsubseq) + // var glojure.core/run! + var_glojure_DOT_core_run_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_run_BANG_) + // var glojure.core/second + var_glojure_DOT_core_second := lang.InternVarName(sym_glojure_DOT_core, sym_second) + // var glojure.core/select-keys + var_glojure_DOT_core_select_DASH_keys := lang.InternVarName(sym_glojure_DOT_core, sym_select_DASH_keys) + // var glojure.core/send + var_glojure_DOT_core_send := lang.InternVarName(sym_glojure_DOT_core, sym_send) + // var glojure.core/send-off + var_glojure_DOT_core_send_DASH_off := lang.InternVarName(sym_glojure_DOT_core, sym_send_DASH_off) + // var glojure.core/send-via + var_glojure_DOT_core_send_DASH_via := lang.InternVarName(sym_glojure_DOT_core, sym_send_DASH_via) + // var glojure.core/seq + var_glojure_DOT_core_seq := lang.InternVarName(sym_glojure_DOT_core, sym_seq) + // var glojure.core/seq-to-map-for-destructuring + var_glojure_DOT_core_seq_DASH_to_DASH_map_DASH_for_DASH_destructuring := lang.InternVarName(sym_glojure_DOT_core, sym_seq_DASH_to_DASH_map_DASH_for_DASH_destructuring) + // var glojure.core/seq? + var_glojure_DOT_core_seq_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_seq_QMARK_) + // var glojure.core/seqable? + var_glojure_DOT_core_seqable_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_seqable_QMARK_) + // var glojure.core/seque + var_glojure_DOT_core_seque := lang.InternVarName(sym_glojure_DOT_core, sym_seque) + // var glojure.core/sequence + var_glojure_DOT_core_sequence := lang.InternVarName(sym_glojure_DOT_core, sym_sequence) + // var glojure.core/sequential? + var_glojure_DOT_core_sequential_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_sequential_QMARK_) + // var glojure.core/serialized-require + var_glojure_DOT_core_serialized_DASH_require := lang.InternVarName(sym_glojure_DOT_core, sym_serialized_DASH_require) + // var glojure.core/set + var_glojure_DOT_core_set := lang.InternVarName(sym_glojure_DOT_core, sym_set) + // var glojure.core/set-agent-send-executor! + var_glojure_DOT_core_set_DASH_agent_DASH_send_DASH_executor_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_set_DASH_agent_DASH_send_DASH_executor_BANG_) + // var glojure.core/set-agent-send-off-executor! + var_glojure_DOT_core_set_DASH_agent_DASH_send_DASH_off_DASH_executor_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_set_DASH_agent_DASH_send_DASH_off_DASH_executor_BANG_) + // var glojure.core/set-error-handler! + var_glojure_DOT_core_set_DASH_error_DASH_handler_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_set_DASH_error_DASH_handler_BANG_) + // var glojure.core/set-error-mode! + var_glojure_DOT_core_set_DASH_error_DASH_mode_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_set_DASH_error_DASH_mode_BANG_) + // var glojure.core/set-validator! + var_glojure_DOT_core_set_DASH_validator_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_set_DASH_validator_BANG_) + // var glojure.core/set? + var_glojure_DOT_core_set_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_set_QMARK_) + // var glojure.core/setup-reference + var_glojure_DOT_core_setup_DASH_reference := lang.InternVarName(sym_glojure_DOT_core, sym_setup_DASH_reference) + // var glojure.core/shift-mask + var_glojure_DOT_core_shift_DASH_mask := lang.InternVarName(sym_glojure_DOT_core, sym_shift_DASH_mask) + // var glojure.core/short + var_glojure_DOT_core_short := lang.InternVarName(sym_glojure_DOT_core, sym_short) + // var glojure.core/short-array + var_glojure_DOT_core_short_DASH_array := lang.InternVarName(sym_glojure_DOT_core, sym_short_DASH_array) + // var glojure.core/shorts + var_glojure_DOT_core_shorts := lang.InternVarName(sym_glojure_DOT_core, sym_shorts) + // var glojure.core/shuffle + var_glojure_DOT_core_shuffle := lang.InternVarName(sym_glojure_DOT_core, sym_shuffle) + // var glojure.core/shutdown-agents + var_glojure_DOT_core_shutdown_DASH_agents := lang.InternVarName(sym_glojure_DOT_core, sym_shutdown_DASH_agents) + // var glojure.core/sigs + var_glojure_DOT_core_sigs := lang.InternVarName(sym_glojure_DOT_core, sym_sigs) + // var glojure.core/simple-ident? + var_glojure_DOT_core_simple_DASH_ident_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_simple_DASH_ident_QMARK_) + // var glojure.core/simple-keyword? + var_glojure_DOT_core_simple_DASH_keyword_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_simple_DASH_keyword_QMARK_) + // var glojure.core/simple-symbol? + var_glojure_DOT_core_simple_DASH_symbol_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_simple_DASH_symbol_QMARK_) + // var glojure.core/slurp + var_glojure_DOT_core_slurp := lang.InternVarName(sym_glojure_DOT_core, sym_slurp) + // var glojure.core/some + var_glojure_DOT_core_some := lang.InternVarName(sym_glojure_DOT_core, sym_some) + // var glojure.core/some-> + var_glojure_DOT_core_some_DASH__GT_ := lang.InternVarName(sym_glojure_DOT_core, sym_some_DASH__GT_) + // var glojure.core/some->> + var_glojure_DOT_core_some_DASH__GT__GT_ := lang.InternVarName(sym_glojure_DOT_core, sym_some_DASH__GT__GT_) + // var glojure.core/some-fn + var_glojure_DOT_core_some_DASH_fn := lang.InternVarName(sym_glojure_DOT_core, sym_some_DASH_fn) + // var glojure.core/some? + var_glojure_DOT_core_some_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_some_QMARK_) + // var glojure.core/sort + var_glojure_DOT_core_sort := lang.InternVarName(sym_glojure_DOT_core, sym_sort) + // var glojure.core/sort-by + var_glojure_DOT_core_sort_DASH_by := lang.InternVarName(sym_glojure_DOT_core, sym_sort_DASH_by) + // var glojure.core/sorted-map + var_glojure_DOT_core_sorted_DASH_map := lang.InternVarName(sym_glojure_DOT_core, sym_sorted_DASH_map) + // var glojure.core/sorted-map-by + var_glojure_DOT_core_sorted_DASH_map_DASH_by := lang.InternVarName(sym_glojure_DOT_core, sym_sorted_DASH_map_DASH_by) + // var glojure.core/sorted-set + var_glojure_DOT_core_sorted_DASH_set := lang.InternVarName(sym_glojure_DOT_core, sym_sorted_DASH_set) + // var glojure.core/sorted-set-by + var_glojure_DOT_core_sorted_DASH_set_DASH_by := lang.InternVarName(sym_glojure_DOT_core, sym_sorted_DASH_set_DASH_by) + // var glojure.core/sorted? + var_glojure_DOT_core_sorted_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_sorted_QMARK_) + // var glojure.core/special-symbol? + var_glojure_DOT_core_special_DASH_symbol_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_special_DASH_symbol_QMARK_) + // var glojure.core/spit + var_glojure_DOT_core_spit := lang.InternVarName(sym_glojure_DOT_core, sym_spit) + // var glojure.core/split-at + var_glojure_DOT_core_split_DASH_at := lang.InternVarName(sym_glojure_DOT_core, sym_split_DASH_at) + // var glojure.core/split-with + var_glojure_DOT_core_split_DASH_with := lang.InternVarName(sym_glojure_DOT_core, sym_split_DASH_with) + // var glojure.core/splitv-at + var_glojure_DOT_core_splitv_DASH_at := lang.InternVarName(sym_glojure_DOT_core, sym_splitv_DASH_at) + // var glojure.core/spread + var_glojure_DOT_core_spread := lang.InternVarName(sym_glojure_DOT_core, sym_spread) + // var glojure.core/str + var_glojure_DOT_core_str := lang.InternVarName(sym_glojure_DOT_core, sym_str) + // var glojure.core/stream-into! + var_glojure_DOT_core_stream_DASH_into_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_stream_DASH_into_BANG_) + // var glojure.core/stream-reduce! + var_glojure_DOT_core_stream_DASH_reduce_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_stream_DASH_reduce_BANG_) + // var glojure.core/stream-seq! + var_glojure_DOT_core_stream_DASH_seq_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_stream_DASH_seq_BANG_) + // var glojure.core/stream-transduce! + var_glojure_DOT_core_stream_DASH_transduce_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_stream_DASH_transduce_BANG_) + // var glojure.core/string? + var_glojure_DOT_core_string_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_string_QMARK_) + // var glojure.core/strip-ns + var_glojure_DOT_core_strip_DASH_ns := lang.InternVarName(sym_glojure_DOT_core, sym_strip_DASH_ns) + // var glojure.core/struct + var_glojure_DOT_core_struct := lang.InternVarName(sym_glojure_DOT_core, sym_struct) + // var glojure.core/struct-map + var_glojure_DOT_core_struct_DASH_map := lang.InternVarName(sym_glojure_DOT_core, sym_struct_DASH_map) + // var glojure.core/subs + var_glojure_DOT_core_subs := lang.InternVarName(sym_glojure_DOT_core, sym_subs) + // var glojure.core/subseq + var_glojure_DOT_core_subseq := lang.InternVarName(sym_glojure_DOT_core, sym_subseq) + // var glojure.core/subvec + var_glojure_DOT_core_subvec := lang.InternVarName(sym_glojure_DOT_core, sym_subvec) + // var glojure.core/supers + var_glojure_DOT_core_supers := lang.InternVarName(sym_glojure_DOT_core, sym_supers) + // var glojure.core/swap! + var_glojure_DOT_core_swap_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_swap_BANG_) + // var glojure.core/swap-vals! + var_glojure_DOT_core_swap_DASH_vals_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_swap_DASH_vals_BANG_) + // var glojure.core/symbol + var_glojure_DOT_core_symbol := lang.InternVarName(sym_glojure_DOT_core, sym_symbol) + // var glojure.core/symbol? + var_glojure_DOT_core_symbol_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_symbol_QMARK_) + // var glojure.core/sync + var_glojure_DOT_core_sync := lang.InternVarName(sym_glojure_DOT_core, sym_sync) + // var glojure.core/system-newline + var_glojure_DOT_core_system_DASH_newline := lang.InternVarName(sym_glojure_DOT_core, sym_system_DASH_newline) + // var glojure.core/tagged-literal + var_glojure_DOT_core_tagged_DASH_literal := lang.InternVarName(sym_glojure_DOT_core, sym_tagged_DASH_literal) + // var glojure.core/tagged-literal? + var_glojure_DOT_core_tagged_DASH_literal_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_tagged_DASH_literal_QMARK_) + // var glojure.core/take + var_glojure_DOT_core_take := lang.InternVarName(sym_glojure_DOT_core, sym_take) + // var glojure.core/take-last + var_glojure_DOT_core_take_DASH_last := lang.InternVarName(sym_glojure_DOT_core, sym_take_DASH_last) + // var glojure.core/take-nth + var_glojure_DOT_core_take_DASH_nth := lang.InternVarName(sym_glojure_DOT_core, sym_take_DASH_nth) + // var glojure.core/take-while + var_glojure_DOT_core_take_DASH_while := lang.InternVarName(sym_glojure_DOT_core, sym_take_DASH_while) + // var glojure.core/tapset + var_glojure_DOT_core_tapset := lang.InternVarName(sym_glojure_DOT_core, sym_tapset) + // var glojure.core/test + var_glojure_DOT_core_test := lang.InternVarName(sym_glojure_DOT_core, sym_test) + // var glojure.core/the-ns + var_glojure_DOT_core_the_DASH_ns := lang.InternVarName(sym_glojure_DOT_core, sym_the_DASH_ns) + // var glojure.core/thread-bound? + var_glojure_DOT_core_thread_DASH_bound_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_thread_DASH_bound_QMARK_) + // var glojure.core/throw-if + var_glojure_DOT_core_throw_DASH_if := lang.InternVarName(sym_glojure_DOT_core, sym_throw_DASH_if) + // var glojure.core/time + var_glojure_DOT_core_time := lang.InternVarName(sym_glojure_DOT_core, sym_time) + // var glojure.core/to-array + var_glojure_DOT_core_to_DASH_array := lang.InternVarName(sym_glojure_DOT_core, sym_to_DASH_array) + // var glojure.core/to-array-2d + var_glojure_DOT_core_to_DASH_array_DASH_2d := lang.InternVarName(sym_glojure_DOT_core, sym_to_DASH_array_DASH_2d) + // var glojure.core/trampoline + var_glojure_DOT_core_trampoline := lang.InternVarName(sym_glojure_DOT_core, sym_trampoline) + // var glojure.core/transduce + var_glojure_DOT_core_transduce := lang.InternVarName(sym_glojure_DOT_core, sym_transduce) + // var glojure.core/transient + var_glojure_DOT_core_transient := lang.InternVarName(sym_glojure_DOT_core, sym_transient) + // var glojure.core/tree-seq + var_glojure_DOT_core_tree_DASH_seq := lang.InternVarName(sym_glojure_DOT_core, sym_tree_DASH_seq) + // var glojure.core/true? + var_glojure_DOT_core_true_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_true_QMARK_) + // var glojure.core/type + var_glojure_DOT_core_type := lang.InternVarName(sym_glojure_DOT_core, sym_type) + // var glojure.core/unchecked-add + var_glojure_DOT_core_unchecked_DASH_add := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_add) + // var glojure.core/unchecked-add-int + var_glojure_DOT_core_unchecked_DASH_add_DASH_int := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_add_DASH_int) + // var glojure.core/unchecked-byte + var_glojure_DOT_core_unchecked_DASH_byte := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_byte) + // var glojure.core/unchecked-char + var_glojure_DOT_core_unchecked_DASH_char := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_char) + // var glojure.core/unchecked-dec + var_glojure_DOT_core_unchecked_DASH_dec := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_dec) + // var glojure.core/unchecked-dec-int + var_glojure_DOT_core_unchecked_DASH_dec_DASH_int := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_dec_DASH_int) + // var glojure.core/unchecked-divide-int + var_glojure_DOT_core_unchecked_DASH_divide_DASH_int := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_divide_DASH_int) + // var glojure.core/unchecked-double + var_glojure_DOT_core_unchecked_DASH_double := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_double) + // var glojure.core/unchecked-float + var_glojure_DOT_core_unchecked_DASH_float := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_float) + // var glojure.core/unchecked-inc + var_glojure_DOT_core_unchecked_DASH_inc := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_inc) + // var glojure.core/unchecked-inc-int + var_glojure_DOT_core_unchecked_DASH_inc_DASH_int := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_inc_DASH_int) + // var glojure.core/unchecked-int + var_glojure_DOT_core_unchecked_DASH_int := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_int) + // var glojure.core/unchecked-long + var_glojure_DOT_core_unchecked_DASH_long := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_long) + // var glojure.core/unchecked-multiply + var_glojure_DOT_core_unchecked_DASH_multiply := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_multiply) + // var glojure.core/unchecked-multiply-int + var_glojure_DOT_core_unchecked_DASH_multiply_DASH_int := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_multiply_DASH_int) + // var glojure.core/unchecked-negate + var_glojure_DOT_core_unchecked_DASH_negate := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_negate) + // var glojure.core/unchecked-negate-int + var_glojure_DOT_core_unchecked_DASH_negate_DASH_int := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_negate_DASH_int) + // var glojure.core/unchecked-remainder-int + var_glojure_DOT_core_unchecked_DASH_remainder_DASH_int := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_remainder_DASH_int) + // var glojure.core/unchecked-short + var_glojure_DOT_core_unchecked_DASH_short := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_short) + // var glojure.core/unchecked-subtract + var_glojure_DOT_core_unchecked_DASH_subtract := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_subtract) + // var glojure.core/unchecked-subtract-int + var_glojure_DOT_core_unchecked_DASH_subtract_DASH_int := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_subtract_DASH_int) + // var glojure.core/underive + var_glojure_DOT_core_underive := lang.InternVarName(sym_glojure_DOT_core, sym_underive) + // var glojure.core/unquote + var_glojure_DOT_core_unquote := lang.InternVarName(sym_glojure_DOT_core, sym_unquote) + // var glojure.core/unquote-splicing + var_glojure_DOT_core_unquote_DASH_splicing := lang.InternVarName(sym_glojure_DOT_core, sym_unquote_DASH_splicing) + // var glojure.core/unreduced + var_glojure_DOT_core_unreduced := lang.InternVarName(sym_glojure_DOT_core, sym_unreduced) + // var glojure.core/unsigned-bit-shift-right + var_glojure_DOT_core_unsigned_DASH_bit_DASH_shift_DASH_right := lang.InternVarName(sym_glojure_DOT_core, sym_unsigned_DASH_bit_DASH_shift_DASH_right) + // var glojure.core/update + var_glojure_DOT_core_update := lang.InternVarName(sym_glojure_DOT_core, sym_update) + // var glojure.core/update-in + var_glojure_DOT_core_update_DASH_in := lang.InternVarName(sym_glojure_DOT_core, sym_update_DASH_in) + // var glojure.core/update-keys + var_glojure_DOT_core_update_DASH_keys := lang.InternVarName(sym_glojure_DOT_core, sym_update_DASH_keys) + // var glojure.core/update-vals + var_glojure_DOT_core_update_DASH_vals := lang.InternVarName(sym_glojure_DOT_core, sym_update_DASH_vals) + // var glojure.core/uri? + var_glojure_DOT_core_uri_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_uri_QMARK_) + // var glojure.core/use + var_glojure_DOT_core_use := lang.InternVarName(sym_glojure_DOT_core, sym_use) + // var glojure.core/uuid? + var_glojure_DOT_core_uuid_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_uuid_QMARK_) + // var glojure.core/val + var_glojure_DOT_core_val := lang.InternVarName(sym_glojure_DOT_core, sym_val) + // var glojure.core/vals + var_glojure_DOT_core_vals := lang.InternVarName(sym_glojure_DOT_core, sym_vals) + // var glojure.core/var-get + var_glojure_DOT_core_var_DASH_get := lang.InternVarName(sym_glojure_DOT_core, sym_var_DASH_get) + // var glojure.core/var-set + var_glojure_DOT_core_var_DASH_set := lang.InternVarName(sym_glojure_DOT_core, sym_var_DASH_set) + // var glojure.core/var? + var_glojure_DOT_core_var_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_var_QMARK_) + // var glojure.core/vary-meta + var_glojure_DOT_core_vary_DASH_meta := lang.InternVarName(sym_glojure_DOT_core, sym_vary_DASH_meta) + // var glojure.core/vec + var_glojure_DOT_core_vec := lang.InternVarName(sym_glojure_DOT_core, sym_vec) + // var glojure.core/vector + var_glojure_DOT_core_vector := lang.InternVarName(sym_glojure_DOT_core, sym_vector) + // var glojure.core/vector? + var_glojure_DOT_core_vector_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_vector_QMARK_) + // var glojure.core/volatile! + var_glojure_DOT_core_volatile_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_volatile_BANG_) + // var glojure.core/volatile? + var_glojure_DOT_core_volatile_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_volatile_QMARK_) + // var glojure.core/vreset! + var_glojure_DOT_core_vreset_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_vreset_BANG_) + // var glojure.core/vswap! + var_glojure_DOT_core_vswap_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_vswap_BANG_) + // var glojure.core/when + var_glojure_DOT_core_when := lang.InternVarName(sym_glojure_DOT_core, sym_when) + // var glojure.core/when-first + var_glojure_DOT_core_when_DASH_first := lang.InternVarName(sym_glojure_DOT_core, sym_when_DASH_first) + // var glojure.core/when-let + var_glojure_DOT_core_when_DASH_let := lang.InternVarName(sym_glojure_DOT_core, sym_when_DASH_let) + // var glojure.core/when-not + var_glojure_DOT_core_when_DASH_not := lang.InternVarName(sym_glojure_DOT_core, sym_when_DASH_not) + // var glojure.core/when-some + var_glojure_DOT_core_when_DASH_some := lang.InternVarName(sym_glojure_DOT_core, sym_when_DASH_some) + // var glojure.core/while + var_glojure_DOT_core_while := lang.InternVarName(sym_glojure_DOT_core, sym_while) + // var glojure.core/with-bindings + var_glojure_DOT_core_with_DASH_bindings := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_bindings) + // var glojure.core/with-bindings* + var_glojure_DOT_core_with_DASH_bindings_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_bindings_STAR_) + // var glojure.core/with-in-str + var_glojure_DOT_core_with_DASH_in_DASH_str := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_in_DASH_str) + // var glojure.core/with-loading-context + var_glojure_DOT_core_with_DASH_loading_DASH_context := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_loading_DASH_context) + // var glojure.core/with-local-vars + var_glojure_DOT_core_with_DASH_local_DASH_vars := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_local_DASH_vars) + // var glojure.core/with-meta + var_glojure_DOT_core_with_DASH_meta := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_meta) + // var glojure.core/with-open + var_glojure_DOT_core_with_DASH_open := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_open) + // var glojure.core/with-out-str + var_glojure_DOT_core_with_DASH_out_DASH_str := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_out_DASH_str) + // var glojure.core/with-precision + var_glojure_DOT_core_with_DASH_precision := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_precision) + // var glojure.core/with-redefs + var_glojure_DOT_core_with_DASH_redefs := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_redefs) + // var glojure.core/with-redefs-fn + var_glojure_DOT_core_with_DASH_redefs_DASH_fn := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_redefs_DASH_fn) + // var glojure.core/xml-seq + var_glojure_DOT_core_xml_DASH_seq := lang.InternVarName(sym_glojure_DOT_core, sym_xml_DASH_seq) + // var glojure.core/zero? + var_glojure_DOT_core_zero_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_zero_QMARK_) + // var glojure.core/zipmap + var_glojure_DOT_core_zipmap := lang.InternVarName(sym_glojure_DOT_core, sym_zipmap) + // var glojure.go.io/copy + var_glojure_DOT_go_DOT_io_copy := lang.InternVarName(sym_glojure_DOT_go_DOT_io, sym_copy) + // var glojure.go.io/reader + var_glojure_DOT_go_DOT_io_reader := lang.InternVarName(sym_glojure_DOT_go_DOT_io, sym_reader) + // reference fmt to avoid unused import error + _ = fmt.Printf + // reference reflect to avoid unused import error + _ = reflect.TypeOf + ns := lang.FindOrCreateNamespace(sym_glojure_DOT_core) + _ = ns + var closed0 any + { + closed0 = sym_unchecked_multiply + } + var closed1 any + { + closed1 = sym_multiply + } + var closed10 any + { + closed10 = sym_and + } + var closed11 any + { + closed11 = sym_andNot + } + var closed12 any + { + closed12 = sym_or + } + var closed13 any + { + closed13 = sym_xor + } + var closed14 any + { + closed14 = sym_max + } + var closed15 any + { + closed15 = sym_min + } + var closed16 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v1 := args[0] + _ = v1 + var tmp2 any + if lang.IsTruthy(v1) { + tmp2 = false + } else { + tmp2 = true + } + return tmp2 + }) + tmp1 := reflect.TypeOf(false) + tmp0 = tmp0.WithMeta(lang.NewMap(kw_rettag, tmp1)).(lang.FnFunc) + closed16 = tmp0 + } + var closed2 any + { + closed2 = sym_multiplyP + } + var closed3 any + { + closed3 = sym_unchecked_add + } + var closed4 any + { + closed4 = sym_add + } + var closed5 any + { + closed5 = sym_addP + } + var closed6 any + { + closed6 = sym_unchecked_minus + } + var closed7 any + { + closed7 = sym_minus + } + var closed8 any + { + closed8 = sym_minusP + } + var closed9 any + { + closed9 = sym_divide + } + // -protocols + { + tmp0 := sym__DASH_protocols.WithMeta(lang.NewMap(kw_private, true, kw_doc, "Private store of protocols. Go's reflection capabilities\n don't yet support a native interface-based implementation, so\n protocols are implemented in Glojure as maps from type to protocol\n method implementations.", kw_file, "glojure/core_deftype.glj", kw_line, int(21), kw_column, int(3), kw_end_DASH_line, int(26), kw_end_DASH_column, int(12), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + tmp1 := lang.NewAtom(lang.NewMap()) + var_glojure_DOT_core__DASH_protocols = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__DASH_protocols.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // >0? + { + tmp0 := sym__GT_0_QMARK_.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(963), kw_column, int(7), kw_end_DASH_line, int(963), kw_end_DASH_column, int(19), kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{nil, int64(0)}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__GT_0_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__GT_0_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // >1? + { + tmp0 := sym__GT_1_QMARK_.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(962), kw_column, int(7), kw_end_DASH_line, int(962), kw_end_DASH_column, int(19), kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{nil, int64(1)}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__GT_1_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__GT_1_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *1 + { + tmp0 := sym__STAR_1.WithMeta(lang.NewMap()).(*lang.Symbol) + var_glojure_DOT_core__STAR_1 = ns.Intern(tmp0) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *2 + { + tmp0 := sym__STAR_2.WithMeta(lang.NewMap()).(*lang.Symbol) + var_glojure_DOT_core__STAR_2 = ns.Intern(tmp0) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *3 + { + tmp0 := sym__STAR_3.WithMeta(lang.NewMap()).(*lang.Symbol) + var_glojure_DOT_core__STAR_3 = ns.Intern(tmp0) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *agent* + { + tmp0 := sym__STAR_agent_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_agent_STAR_ = ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_agent_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *assert* + { + tmp0 := sym__STAR_assert_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "When set to logical false, 'assert' will omit assertion checks in\n compiled code. Defaults to true.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_assert_STAR_ = ns.InternWithValue(tmp0, false, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_assert_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *command-line-args* + { + tmp0 := sym__STAR_command_DASH_line_DASH_args_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "A sequence of the supplied command line arguments, or nil if\n none were supplied", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_command_DASH_line_DASH_args_STAR_ = ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_command_DASH_line_DASH_args_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *compile-files* + { + tmp0 := sym__STAR_compile_DASH_files_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "Set to true when compiling files, false otherwise.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_compile_DASH_files_STAR_ = ns.InternWithValue(tmp0, true, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_compile_DASH_files_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *compile-path* + { + tmp0 := sym__STAR_compile_DASH_path_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "Specifies the directory where 'compile' will write out .class\n files. This directory must be in the classpath for 'compile' to\n work.\n\n Defaults to \"classes\"", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_compile_DASH_path_STAR_ = ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_compile_DASH_path_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *compiler-options* + { + tmp0 := sym__STAR_compiler_DASH_options_STAR_.WithMeta(lang.NewMap(kw_added, "1.4", kw_doc, "A map of keys to options.\n Note, when binding dynamically make sure to merge with previous value.\n Supported options:\n :elide-meta - a collection of metadata keys to elide during compilation.\n :disable-locals-clearing - set to true to disable clearing, useful for using a debugger\n :direct-linking - set to true to use direct static invocation of functions, rather than vars\n Note that call sites compiled with direct linking will not be affected by var redefinition.\n Use ^:redef (or ^:dynamic) on a var to prevent direct linking and allow redefinition.\n See https://glojure.org/reference/compilation for more information.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_compiler_DASH_options_STAR_ = ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_compiler_DASH_options_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *data-readers* + { + tmp0 := sym__STAR_data_DASH_readers_STAR_.WithMeta(lang.NewMap(kw_doc, "Map from reader tag symbols to data reader Vars.\n\n When Clojure starts, it searches for files named 'data_readers.clj'\n and 'data_readers.cljc' at the root of the classpath. Each such file\n must contain a literal map of symbols, like this:\n\n {foo/bar my.project.foo/bar\n foo/baz my.project/baz}\n\n The first symbol in each pair is a tag that will be recognized by\n the Clojure reader. The second symbol in the pair is the\n fully-qualified name of a Var which will be invoked by the reader to\n parse the form following the tag. For example, given the\n data_readers.clj file above, the Clojure reader would parse this\n form:\n\n #foo/bar [1 2 3]\n\n by invoking the Var #'my.project.foo/bar on the vector [1 2 3]. The\n data reader function is invoked on the form AFTER it has been read\n as a normal Clojure data structure by the reader.\n\n Reader tags without namespace qualifiers are reserved for\n Clojure. Default reader tags are defined in\n glojure.core/default-data-readers but may be overridden in\n data_readers.clj, data_readers.cljc, or by rebinding this Var.", kw_file, "glojure/core.glj", kw_added, "1.4", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(49), kw_column, int(6), kw_line, int(7794), kw_end_DASH_line, int(7794), kw_dynamic, true)).(*lang.Symbol) + var_glojure_DOT_core__STAR_data_DASH_readers_STAR_ = ns.InternWithValue(tmp0, lang.NewMap(), true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_data_DASH_readers_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *default-data-reader-fn* + { + tmp0 := sym__STAR_default_DASH_data_DASH_reader_DASH_fn_STAR_.WithMeta(lang.NewMap(kw_doc, "When no data reader is found for a tag and *default-data-reader-fn*\n is non-nil, it will be called with two arguments,\n the tag and the value. If *default-data-reader-fn* is nil (the\n default), an exception will be thrown for the unknown tag.", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(59), kw_column, int(6), kw_line, int(7823), kw_end_DASH_line, int(7823), kw_dynamic, true)).(*lang.Symbol) + var_glojure_DOT_core__STAR_default_DASH_data_DASH_reader_DASH_fn_STAR_ = ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_default_DASH_data_DASH_reader_DASH_fn_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *e + { + tmp0 := sym__STAR_e.WithMeta(lang.NewMap()).(*lang.Symbol) + var_glojure_DOT_core__STAR_e = ns.Intern(tmp0) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_e.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *err* + { + tmp0 := sym__STAR_err_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "A java.io.Writer object representing standard error for print operations.\n\n Defaults to System/err, wrapped in a PrintWriter", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_err_STAR_ = ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_err_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *file* + { + tmp0 := sym__STAR_file_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "The path of the file being evaluated, as a String.\n\n When there is no file, e.g. in the REPL, the value is not defined.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_file_STAR_ = ns.InternWithValue(tmp0, "NO_SOURCE_FILE", true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_file_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *flush-on-newline* + { + tmp0 := sym__STAR_flush_DASH_on_DASH_newline_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "When set to true, output will be flushed whenever a newline is printed.\n\n Defaults to true.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_flush_DASH_on_DASH_newline_STAR_ = ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_flush_DASH_on_DASH_newline_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *loaded-libs* + { + tmp0 := sym__STAR_loaded_DASH_libs_STAR_.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core.glj", kw_line, int(5817), kw_column, int(10), kw_end_DASH_line, int(5820), kw_end_DASH_column, int(15), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + tmp1 := lang.NewRef(lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{sym_glojure_DOT_core_DOT_protocols, sym_glojure_DOT_string, sym_glojure_DOT_go_DOT_io, sym_user}))) + var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *loading-verbosely* + { + tmp0 := sym__STAR_loading_DASH_verbosely_STAR_.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core.glj", kw_line, int(5827), kw_column, int(10), kw_end_DASH_line, int(5830), kw_end_DASH_column, int(21), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_ = ns.InternWithValue(tmp0, false, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *ns* + { + tmp0 := sym__STAR_ns_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "A glojure.lang.Namespace object representing the current namespace.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_ns_STAR_ = ns.InternWithValue(tmp0, lang.FindOrCreateNamespace(sym_glojure_DOT_core), true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_ns_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *pending-paths* + { + tmp0 := sym__STAR_pending_DASH_paths_STAR_.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core.glj", kw_line, int(5822), kw_column, int(10), kw_end_DASH_line, int(5825), kw_end_DASH_column, int(17), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_ = ns.InternWithValue(tmp0, lang.NewList("/glojure/core_deftype", "/glojure/core"), true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *print-dup* + { + tmp0 := sym__STAR_print_DASH_dup_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "When set to logical true, objects will be printed in a way that preserves\n their type when read in later.\n\n Defaults to false.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_print_DASH_dup_STAR_ = ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_print_DASH_dup_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *print-length* + { + tmp0 := sym__STAR_print_DASH_length_STAR_.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core_print.glj", kw_line, int(14), kw_column, int(6), kw_end_DASH_line, int(23), kw_end_DASH_column, int(15), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_print_DASH_length_STAR_ = ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_print_DASH_length_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *print-level* + { + tmp0 := sym__STAR_print_DASH_level_STAR_.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core_print.glj", kw_line, int(25), kw_column, int(6), kw_end_DASH_line, int(35), kw_end_DASH_column, int(14), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_print_DASH_level_STAR_ = ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_print_DASH_level_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *print-meta* + { + tmp0 := sym__STAR_print_DASH_meta_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "If set to logical true, when printing an object, its metadata will also\n be printed in a form that can be read back by the reader.\n\n Defaults to false.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_print_DASH_meta_STAR_ = ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_print_DASH_meta_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *print-namespace-maps* + { + tmp0 := sym__STAR_print_DASH_namespace_DASH_maps_STAR_.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core_print.glj", kw_line, int(39), kw_column, int(6), kw_end_DASH_line, int(44), kw_end_DASH_column, int(23), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_print_DASH_namespace_DASH_maps_STAR_ = ns.InternWithValue(tmp0, false, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_print_DASH_namespace_DASH_maps_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *print-readably* + { + tmp0 := sym__STAR_print_DASH_readably_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "When set to logical false, strings and characters will be printed with\n non-alphanumeric characters converted to the appropriate escape sequences.\n\n Defaults to true", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_print_DASH_readably_STAR_ = ns.InternWithValue(tmp0, true, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_print_DASH_readably_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *read-eval* + { + tmp0 := sym__STAR_read_DASH_eval_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "Defaults to true (or value specified by system property, see below)\n ***This setting implies that the full power of the reader is in play,\n including syntax that can cause code to execute. It should never be\n used with untrusted sources. See also: glojure.edn/read.***\n\n When set to logical false in the thread-local binding,\n the eval reader (#=) and record/type literal syntax are disabled in read/load.\n Example (will fail): (binding [*read-eval* false] (read-string \"#=(* 2 21)\"))\n\n The default binding can be controlled by the system property\n 'glojure.read.eval' System properties can be set on the command line\n like this:\n\n java -Dglojure.read.eval=false ...\n\n The system property can also be set to 'unknown' via\n -Dglojure.read.eval=unknown, in which case the default binding\n is :unknown and all reads will fail in contexts where *read-eval*\n has not been explicitly bound to either true or false. This setting\n can be a useful diagnostic tool to ensure that all of your reads\n occur in considered contexts. You can also accomplish this in a\n particular scope by binding *read-eval* to :unknown\n ", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_read_DASH_eval_STAR_ = ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_read_DASH_eval_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *repl* + { + tmp0 := sym__STAR_repl_STAR_.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core.glj", kw_line, int(6288), kw_column, int(6), kw_end_DASH_line, int(6291), kw_end_DASH_column, int(8), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_repl_STAR_ = ns.InternWithValue(tmp0, false, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_repl_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *unchecked-math* + { + tmp0 := sym__STAR_unchecked_DASH_math_STAR_.WithMeta(lang.NewMap(kw_added, "1.3", kw_doc, "While bound to true, compilations of +, -, *, inc, dec and the\n coercions will be done without overflow checks. While bound\n to :warn-on-boxed, same behavior as true, and a warning is emitted\n when compilation uses boxed math. Default: false.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_ = ns.InternWithValue(tmp0, false, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *verbose-defrecords* + { + tmp0 := sym__STAR_verbose_DASH_defrecords_STAR_.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core_print.glj", kw_line, int(37), kw_column, int(6), kw_end_DASH_line, int(37), kw_end_DASH_column, int(35), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_verbose_DASH_defrecords_STAR_ = ns.InternWithValue(tmp0, false, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_verbose_DASH_defrecords_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *warn-on-reflection* + { + tmp0 := sym__STAR_warn_DASH_on_DASH_reflection_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "When set to true, the compiler will emit warnings when reflection is\n needed to resolve Java method calls or field accesses.\n\n Defaults to false.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_warn_DASH_on_DASH_reflection_STAR_ = ns.InternWithValue(tmp0, false, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_warn_DASH_on_DASH_reflection_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // accessor + { + tmp0 := sym_accessor.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s, sym_key)), kw_doc, "Returns a fn that, given an instance of a structmap with the basis,\n returns the value at the key. The key must be in the basis. The\n returned function should be (slightly) more efficient than using\n get, but such use of accessors should be limited to known\n performance-critical areas.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(4070), kw_end_DASH_line, int(4070))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(nil, "getAccessor") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getAccessor is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_accessor = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_accessor.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // add-watch + { + tmp0 := sym_add_DASH_watch.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_reference, sym_key, sym_fn)), kw_doc, "Adds a watch function to an agent/atom/var/ref reference. The watch\n fn must be a fn of 4 args: a key, the reference, its old-state, its\n new-state. Whenever the reference's state might have been changed,\n any registered watches will have their functions called. The watch fn\n will be called synchronously, on the agent's thread if an agent,\n before any pending sends if agent or ref. Note that an atom's or\n ref's state may have changed again prior to the fn call, so use\n old/new-state rather than derefing the reference. Note also that watch\n fns may be called from multiple threads simultaneously. Var watchers\n are triggered only by root binding changes, not thread-local\n set!s. Keys must be unique per reference, and can be used to remove\n the watch with remove-watch, but are otherwise considered opaque by\n the watch mechanism.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(2142), kw_end_DASH_line, int(2142))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5, _ := lang.FieldOrMethod(v2, "addWatch") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("addWatch is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_add_DASH_watch = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_add_DASH_watch.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // agent-error + { + tmp0 := sym_agent_DASH_error.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a)), kw_doc, "Returns the exception thrown during an asynchronous action of the\n agent if the agent is failed. Returns nil if the agent is not\n failed.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(2167), kw_end_DASH_line, int(2167))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "getError") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getError"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_agent_DASH_error = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_agent_DASH_error.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // all-ns + { + tmp0 := sym_all_DASH_ns.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Returns a sequence of all namespaces.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(4146), kw_end_DASH_line, int(4146))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp2 := lang.Apply(nil, nil) + return tmp2 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_all_DASH_ns = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_all_DASH_ns.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // alter + { + tmp0 := sym_alter.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ref, sym_fun, sym__AMP_, sym_args)), kw_doc, "Must be called in a transaction. Sets the in-transaction-value of\n ref to:\n\n (apply fun in-transaction-value-of-ref args)\n\n and returns the in-transaction-value of ref.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(2435), kw_end_DASH_line, int(2435))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5, _ := lang.FieldOrMethod(v2, "alter") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("alter is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_alter = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_alter.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // alter-meta! + { + tmp0 := sym_alter_DASH_meta_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_iref, sym_f, sym__AMP_, sym_args)), kw_doc, "Atomically sets the metadata for a namespace/var/ref/agent/atom to be:\n\n (apply f its-current-meta args)\n\n f must be free of side-effects", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(2398), kw_end_DASH_line, int(2398))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5, _ := lang.FieldOrMethod(v2, "AlterMeta") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("AlterMeta is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_alter_DASH_meta_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_alter_DASH_meta_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // alter-var-root + { + tmp0 := sym_alter_DASH_var_DASH_root.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_v, sym_f, sym__AMP_, sym_args)), kw_doc, "Atomically alters the root binding of var v by applying f to its\n current value plus any args", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(5484), kw_end_DASH_line, int(5484))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5, _ := lang.FieldOrMethod(v2, "alterRoot") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("alterRoot is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_alter_DASH_var_DASH_root = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_alter_DASH_var_DASH_root.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // any? + { + tmp1 := reflect.TypeOf(false) + tmp0 := sym_any_QMARK_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true given any argument.", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(537), kw_end_DASH_line, int(537))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + return true + }) + tmp3 := reflect.TypeOf(false) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_any_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_any_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // assert-valid-fdecl + { + tmp0 := sym_assert_DASH_valid_DASH_fdecl.WithMeta(lang.NewMap(kw_private, true, kw_dynamic, true, kw_file, "glojure/core.glj", kw_line, int(219), kw_column, int(6), kw_end_DASH_line, int(220), kw_end_DASH_column, int(20), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + return nil + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(220), kw_column, int(22), kw_end_DASH_line, int(220), kw_end_DASH_column, int(33))).(lang.FnFunc) + var_glojure_DOT_core_assert_DASH_valid_DASH_fdecl = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_assert_DASH_valid_DASH_fdecl.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bit-clear + { + tmp0 := sym_bit_DASH_clear.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_n)), kw_doc, "Clear bit at index n", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(1336), kw_end_DASH_line, int(1336))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "ClearBit") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ClearBit is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bit_DASH_clear = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bit_DASH_clear.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bit-flip + { + tmp0 := sym_bit_DASH_flip.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_n)), kw_doc, "Flip bit at index n", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(1348), kw_end_DASH_line, int(1348))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "FlipBit") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("FlipBit is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bit_DASH_flip = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bit_DASH_flip.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bit-set + { + tmp0 := sym_bit_DASH_set.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_n)), kw_doc, "Set bit at index n", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(1342), kw_end_DASH_line, int(1342))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "SetBit") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("SetBit is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bit_DASH_set = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bit_DASH_set.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bit-test + { + tmp0 := sym_bit_DASH_test.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_n)), kw_doc, "Test bit at index n", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(1354), kw_end_DASH_line, int(1354))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "TestBit") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("TestBit is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bit_DASH_test = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bit_DASH_test.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // cast + { + tmp0 := sym_cast.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_c, sym_x)), kw_doc, "Throws a ClassCastException if x is not a c, else returns x.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(345), kw_end_DASH_line, int(345))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "cast") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("cast is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_cast = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_cast.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // char-escape-string + { + tmp1 := reflect.TypeOf("") + tmp0 := sym_char_DASH_escape_DASH_string.WithMeta(lang.NewMap(kw_tag, tmp1, kw_doc, "Returns escape string for char or nil if none", kw_file, "glojure/core_print.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(6), kw_line, int(214), kw_end_DASH_line, int(217))).(*lang.Symbol) + var_glojure_DOT_core_char_DASH_escape_DASH_string = ns.InternWithValue(tmp0, lang.NewMap(lang.NewChar(10), "\\n", lang.NewChar(9), "\\t", lang.NewChar(13), "\\r", lang.NewChar(34), "\\\"", lang.NewChar(92), "\\\\", lang.NewChar(12), "\\f", lang.NewChar(8), "\\b"), true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_char_DASH_escape_DASH_string.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // char-name-string + { + tmp1 := reflect.TypeOf("") + tmp0 := sym_char_DASH_name_DASH_string.WithMeta(lang.NewMap(kw_tag, tmp1, kw_doc, "Returns name string for char or nil if none", kw_file, "glojure/core_print.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(6), kw_line, int(335), kw_end_DASH_line, int(338))).(*lang.Symbol) + var_glojure_DOT_core_char_DASH_name_DASH_string = ns.InternWithValue(tmp0, lang.NewMap(lang.NewChar(10), "newline", lang.NewChar(9), "tab", lang.NewChar(32), "space", lang.NewChar(8), "backspace", lang.NewChar(12), "formfeed", lang.NewChar(13), "return"), true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_char_DASH_name_DASH_string.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // chunk + { + tmp0 := sym_chunk.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(691), kw_column, int(7), kw_end_DASH_line, int(691), kw_end_DASH_column, int(41), kw_arglists, lang.NewList(lang.NewVector(sym_b)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "chunk") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "chunk"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_chunk = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_chunk.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // chunk-append + { + tmp0 := sym_chunk_DASH_append.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(688), kw_column, int(7), kw_end_DASH_line, int(688), kw_end_DASH_column, int(27), kw_arglists, lang.NewList(lang.NewVector(sym_b, sym_x)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "add") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_chunk_DASH_append = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_chunk_DASH_append.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // chunk-buffer + { + tmp0 := sym_chunk_DASH_buffer.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(685), kw_column, int(7), kw_end_DASH_line, int(685), kw_end_DASH_column, int(53), kw_arglists, lang.NewList(lang.NewVector(sym_capacity)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(lang.NewChunkBuffer, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_chunk_DASH_buffer = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_chunk_DASH_buffer.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // chunk-cons + { + tmp0 := sym_chunk_DASH_cons.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(703), kw_column, int(7), kw_end_DASH_line, int(703), kw_end_DASH_column, int(25), kw_arglists, lang.NewList(lang.NewVector(sym_chunk, sym_rest)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + tmp5 := lang.Apply(lang.Count, []any{v2}) + tmp6 := lang.Apply(lang.IsZero, []any{tmp5}) + if lang.IsTruthy(tmp6) { + tmp4 = v3 + } else { + tmp7 := lang.Apply(lang.NewChunkedCons, []any{v2, v3}) + tmp4 = tmp7 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_chunk_DASH_cons = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_chunk_DASH_cons.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // chunk-first + { + tmp0 := sym_chunk_DASH_first.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(694), kw_column, int(7), kw_end_DASH_line, int(694), kw_end_DASH_column, int(48), kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "chunkedFirst") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "chunkedFirst"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_chunk_DASH_first = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_chunk_DASH_first.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // chunk-next + { + tmp0 := sym_chunk_DASH_next.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(700), kw_column, int(7), kw_end_DASH_line, int(700), kw_end_DASH_column, int(71), kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "chunkedNext") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "chunkedNext"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_chunk_DASH_next = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_chunk_DASH_next.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // chunk-rest + { + tmp0 := sym_chunk_DASH_rest.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(697), kw_column, int(7), kw_end_DASH_line, int(697), kw_end_DASH_column, int(71), kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "chunkedMore") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "chunkedMore"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_chunk_DASH_rest = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_chunk_DASH_rest.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // comment + { + tmp0 := sym_comment.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_body)), kw_doc, "Ignores body, yields nil", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(4733), kw_end_DASH_line, int(4733))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + return nil + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_comment = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_comment.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // commute + { + tmp0 := sym_commute.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ref, sym_fun, sym__AMP_, sym_args)), kw_doc, "Must be called in a transaction. Sets the in-transaction-value of\n ref to:\n\n (apply fun in-transaction-value-of-ref args)\n\n and returns the in-transaction-value of ref.\n\n At the commit point of the transaction, sets the value of ref to be:\n\n (apply fun most-recently-committed-value-of-ref args)\n\n Thus fun should be commutative, or, failing that, you must accept\n last-one-in-wins behavior. commute allows for more concurrency than\n ref-set.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(2414), kw_end_DASH_line, int(2414))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5, _ := lang.FieldOrMethod(v2, "Commute") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Commute is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_commute = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_commute.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // comparator + { + tmp0 := sym_comparator.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred)), kw_doc, "Returns an implementation of java.util.Comparator based upon pred.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(3077), kw_end_DASH_line, int(3077))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var tmp6 any + tmp7 := lang.Apply(v2, []any{v4, v5}) + if lang.IsTruthy(tmp7) { + tmp6 = int64(-1) + } else { + var tmp8 any + tmp9 := lang.Apply(v2, []any{v5, v4}) + if lang.IsTruthy(tmp9) { + tmp8 = int64(1) + } else { + var tmp10 any + if lang.IsTruthy(kw_else) { + tmp10 = int64(0) + } else { + } + tmp8 = tmp10 + } + tmp6 = tmp8 + } + return tmp6 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3082), kw_column, int(5), kw_end_DASH_line, int(3083), kw_end_DASH_column, int(48)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_comparator = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_comparator.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // compare-and-set! + { + tmp0 := sym_compare_DASH_and_DASH_set_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_atom, sym_oldval, sym_newval)), kw_doc, "Atomically sets the value of atom to newval if and only if the\n current value of the atom is identical to oldval. Returns true if\n set happened, else false", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(22), kw_column, int(7), kw_line, int(2360), kw_end_DASH_line, int(2360))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5, _ := lang.FieldOrMethod(v2, "compareAndSet") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("compareAndSet is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_compare_DASH_and_DASH_set_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_compare_DASH_and_DASH_set_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // cons + { + tmp0 := sym_cons.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_seq)), kw_doc, "Returns a new seq where x is the first element and seq is\n the rest.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(5), kw_column, int(2), kw_line, int(21), kw_end_DASH_line, int(27))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function cons + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(lang.NewCons, []any{v3, v4}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(27), kw_column, int(7), kw_end_DASH_line, int(27), kw_end_DASH_column, int(89))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_cons = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_cons.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // constantly + { + tmp0 := sym_constantly.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns a function that takes any number of arguments and returns x.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(1440), kw_end_DASH_line, int(1440))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v4 any = lang.NewList(args[0:]...) + _ = v4 + return v2 + } + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(1444), kw_column, int(7), kw_end_DASH_line, int(1444), kw_end_DASH_column, int(21)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_constantly = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_constantly.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // contains? + { + tmp0 := sym_contains_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll, sym_key)), kw_doc, "Returns true if key is present in the given collection, otherwise\n returns false. Note that for numerically indexed collections like\n vectors and Java arrays, this tests if the numeric key is within the\n range of indexes. 'contains?' operates constant or logarithmic time;\n it will not perform a linear search for a value. See also 'some'.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(1479), kw_end_DASH_line, int(1479))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(runtime.RT, "Contains") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Contains is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_contains_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_contains_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // create-ns + { + tmp0 := sym_create_DASH_ns.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_sym)), kw_doc, "Create a new namespace named by the symbol if one doesn't already\n exist, returns it or the already-existing namespace of the same\n name.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(4131), kw_end_DASH_line, int(4131))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(nil, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_create_DASH_ns = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_create_DASH_ns.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // create-struct + { + tmp0 := sym_create_DASH_struct.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_keys)), kw_doc, "Returns a structure basis object.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(4037), kw_end_DASH_line, int(4037))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + tmp3 := lang.Apply(lang.CreatePersistentStructMapSlotMap, []any{v2}) + return tmp3 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_create_DASH_struct = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_create_DASH_struct.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // data-reader-urls + { + tmp0 := sym_data_DASH_reader_DASH_urls.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7830), kw_column, int(8), kw_end_DASH_line, int(7830), kw_end_DASH_column, int(23), kw_private, true, kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + return lang.NewList() + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_data_DASH_reader_DASH_urls = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_data_DASH_reader_DASH_urls.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // deliver + { + tmp0 := sym_deliver.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_promise, sym_val)), kw_doc, "Delivers the supplied value to the promise, releasing any pending\n derefs. A subsequent call to deliver on a promise will have no effect.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(7109), kw_end_DASH_line, int(7109))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := lang.Apply(v2, []any{v3}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_deliver = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_deliver.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // denominator + { + tmp1 := reflect.TypeOf((*big6.Int)(nil)) + tmp0 := sym_denominator.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_r)), kw_doc, "Returns the denominator part of a Ratio.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(3591), kw_end_DASH_line, int(3591))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, ok := lang.FieldOrMethod(v3, "denominator") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "denominator"))) + } + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { + case reflect.Func: + tmp5 = lang.Apply(tmp4, nil) + default: + tmp5 = tmp4 + } + return tmp5 + }) + tmp3 := reflect.TypeOf((*big6.Int)(nil)) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_denominator = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_denominator.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // deref-future + { + tmp0 := sym_deref_DASH_future.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(2296), kw_column, int(7), kw_end_DASH_line, int(2296), kw_end_DASH_column, int(28), kw_arglists, lang.NewList(lang.NewVector(sym_fut), lang.NewVector(sym_fut, sym_timeout_DASH_ms, sym_timeout_DASH_val)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "Get") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "Get"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + func() { + defer func() { + if r := recover(); r != nil { + tmp6 := reflect.TypeOf((*lang.TimeoutError)(nil)).Elem() + if lang.CatchMatches(r, tmp6) { + v7 := r + _ = v7 + tmp5 = v4 + } else { + panic(r) + } + } + }() + tmp7, _ := lang.FieldOrMethod(v2, "Get") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Get is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v3, time7.Millisecond}) + tmp5 = tmp8 + }() + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_deref_DASH_future = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_deref_DASH_future.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ensure + { + tmp0 := sym_ensure.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ref)), kw_doc, "Must be called in a transaction. Protects the ref from modification\n by other transactions. Returns the in-transaction-value of\n ref. Allows for more concurrency than (ref-set ref @ref)", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(2480), kw_end_DASH_line, int(2480))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(v2, "touch") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("touch is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{}) + _ = tmp4 + tmp5, _ := lang.FieldOrMethod(v2, "deref") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("deref is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ensure = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ensure.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // enumeration-seq + { + tmp0 := sym_enumeration_DASH_seq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_e)), kw_doc, "Returns a seq on a java.util.Enumeration", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(5710), kw_end_DASH_line, int(5710))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(nil, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_enumeration_DASH_seq = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_enumeration_DASH_seq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // error-handler + { + tmp0 := sym_error_DASH_handler.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a)), kw_doc, "Returns the error-handler of agent a, or nil if there is none.\n See set-error-handler!", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(2202), kw_end_DASH_line, int(2202))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "getErrorHandler") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getErrorHandler"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_error_DASH_handler = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_error_DASH_handler.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // error-mode + { + tmp0 := sym_error_DASH_mode.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a)), kw_doc, "Returns the error-mode of agent a. See set-error-mode!", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(2227), kw_end_DASH_line, int(2227))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "getErrorMode") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getErrorMode"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_error_DASH_mode = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_error_DASH_mode.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // eval + { + tmp0 := sym_eval.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_form)), kw_doc, "Evaluates the form data structure (not text!) and returns the result.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3203), kw_end_DASH_line, int(3203))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(runtime.Compiler, "Eval") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Eval is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_eval = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_eval.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // false? + { + tmp1 := reflect.TypeOf(false) + tmp0 := sym_false_QMARK_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x is the value false, false otherwise.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(504), kw_end_DASH_line, int(504))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.Identical, []any{v3, false}) + return tmp4 + }) + tmp3 := reflect.TypeOf(false) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_false_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_false_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // find + { + tmp0 := sym_find.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_map, sym_key)), kw_doc, "Returns the map entry for key, or nil if key not present.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1530), kw_end_DASH_line, int(1530))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(runtime.RT, "Find") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Find is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_find = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_find.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // find-ns + { + tmp0 := sym_find_DASH_ns.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_sym)), kw_doc, "Returns the namespace named by the symbol or nil if it doesn't exist.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4125), kw_end_DASH_line, int(4125))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(lang.FindNamespace, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_find_DASH_ns = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_find_DASH_ns.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // find-var + { + tmp0 := sym_find_DASH_var.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_sym)), kw_doc, "Returns the global var named by the namespace-qualified symbol, or\n nil if no var with that name.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(2013), kw_end_DASH_line, int(2013))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(runtime.RT, "FindVar") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("FindVar is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_find_DASH_var = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_find_DASH_var.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // first + { + tmp0 := sym_first.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns the first item in the collection. Calls seq on its\n argument. If coll is nil, returns nil.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(6), kw_column, int(2), kw_line, int(47), kw_end_DASH_line, int(52))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function first + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.First, []any{v3}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(52), kw_column, int(8), kw_end_DASH_line, int(52), kw_end_DASH_column, int(86))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_first = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_first.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // force + { + tmp0 := sym_force.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "If x is a Delay, returns the (possibly cached) value of its expression, else returns x", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(754), kw_end_DASH_line, int(754))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(nil, "force") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("force is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_force = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_force.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // future-cancel + { + tmp0 := sym_future_DASH_cancel.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f)), kw_doc, "Cancels the future, if possible.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(7019), kw_end_DASH_line, int(7019))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(v2, "cancel") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("cancel is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{true}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_future_DASH_cancel = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_future_DASH_cancel.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // future-cancelled? + { + tmp0 := sym_future_DASH_cancelled_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f)), kw_doc, "Returns true if future f is cancelled", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(7), kw_line, int(7025), kw_end_DASH_line, int(7025))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "isCancelled") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "isCancelled"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_future_DASH_cancelled_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_future_DASH_cancelled_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // future-done? + { + tmp0 := sym_future_DASH_done_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f)), kw_doc, "Returns true if future f is done", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(6538), kw_end_DASH_line, int(6538))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "isDone") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "isDone"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_future_DASH_done_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_future_DASH_done_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // gen-class + { + tmp0 := sym_gen_DASH_class.WithMeta(lang.NewMap()).(*lang.Symbol) + var_glojure_DOT_core_gen_DASH_class = ns.Intern(tmp0) + if tmp0.Meta() != nil { + var_glojure_DOT_core_gen_DASH_class.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // get-method + { + tmp0 := sym_get_DASH_method.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_multifn, sym_dispatch_DASH_val)), kw_doc, "Given a multimethod and a dispatch value, returns the dispatch fn\n that would apply to that value, or nil if none apply and no default", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(1815), kw_end_DASH_line, int(1815))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "getMethod") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getMethod is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_get_DASH_method = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_get_DASH_method.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // get-thread-bindings + { + tmp0 := sym_get_DASH_thread_DASH_bindings.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Get a map with the Var/value pairs which is currently in effect for the\n current thread.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(25), kw_column, int(7), kw_line, int(1937), kw_end_DASH_line, int(1937))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp2 := lang.Apply(nil, nil) + return tmp2 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_get_DASH_thread_DASH_bindings = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_get_DASH_thread_DASH_bindings.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // get-validator + { + tmp0 := sym_get_DASH_validator.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_iref)), kw_doc, "Gets the validator-fn for a var/ref/agent/atom.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(2392), kw_end_DASH_line, int(2392))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(v2, "getValidator") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getValidator is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_get_DASH_validator = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_get_DASH_validator.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // global-hierarchy + { + tmp0 := sym_global_DASH_hierarchy.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(5513), kw_column, int(6), kw_end_DASH_line, int(5514), kw_end_DASH_column, int(21), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core_global_DASH_hierarchy = ns.InternWithValue(tmp0, lang.NewMap(kw_parents, lang.NewMap(), kw_descendants, lang.NewMap(), kw_ancestors, lang.NewMap()), true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_global_DASH_hierarchy.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // hash + { + tmp0 := sym_hash.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns the hash code of its argument. Note this is the hash code\n consistent with =, and thus is different than .hashCode for Integer,\n Short, Byte and Clojure collections.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(5189), kw_end_DASH_line, int(5189))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(lang.HashEq, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_hash = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_hash.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // hash-map + { + tmp0 := sym_hash_DASH_map.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym__AMP_, sym_keyvals)), kw_doc, "keyval => key val\n Returns a new hash map with supplied mappings. If any keys are\n equal, they are handled as if by repeated uses of assoc.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(378), kw_end_DASH_line, int(378))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp2 := lang.NewMap() + tmp3 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(384), kw_column, int(7), kw_end_DASH_line, int(384), kw_end_DASH_column, int(8)) + tmp4, err := lang.WithMeta(tmp2, tmp3.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp4 + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + tmp3 := lang.Apply(lang.CreatePersistentHashMap, []any{v2}) + return tmp3 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_hash_DASH_map = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_hash_DASH_map.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // hash-ordered-coll + { + tmp0 := sym_hash_DASH_ordered_DASH_coll.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns the hash code, consistent with =, for an external ordered\n collection implementing Iterable.\n See http://glojure.org/data_structures#hash for full algorithms.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.6", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(7), kw_line, int(5210), kw_end_DASH_line, int(5210))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(nil, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_hash_DASH_ordered_DASH_coll = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_hash_DASH_ordered_DASH_coll.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // hash-set + { + tmp0 := sym_hash_DASH_set.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym__AMP_, sym_keys)), kw_doc, "Returns a new hash set with supplied keys. Any equal keys are\n handled as if by repeated uses of conj.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(388), kw_end_DASH_line, int(388))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp2 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp3 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(393), kw_column, int(7), kw_end_DASH_line, int(393), kw_end_DASH_column, int(9)) + tmp4, err := lang.WithMeta(tmp2, tmp3.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp4 + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + tmp3 := lang.Apply(nil, []any{v2}) + return tmp3 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_hash_DASH_set = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_hash_DASH_set.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // hash-unordered-coll + { + tmp0 := sym_hash_DASH_unordered_DASH_coll.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns the hash code, consistent with =, for an external unordered\n collection implementing Iterable. For maps, the iterator should\n return map entries whose hash is computed as\n (hash-ordered-coll [k v]).\n See http://glojure.org/data_structures#hash for full algorithms.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.6", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(25), kw_column, int(7), kw_line, int(5219), kw_end_DASH_line, int(5219))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(nil, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_hash_DASH_unordered_DASH_coll = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_hash_DASH_unordered_DASH_coll.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // identity + { + tmp0 := sym_identity.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns its argument.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(1446), kw_end_DASH_line, int(1446))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + return v2 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_identity = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_identity.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // inst-ms + { + tmp0 := sym_inst_DASH_ms.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_inst)), kw_doc, "Return the number of milliseconds since January 1, 1970, 00:00:00 GMT", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(6831), kw_end_DASH_line, int(6831))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(nil, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_inst_DASH_ms = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_inst_DASH_ms.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // inst? + { + tmp0 := sym_inst_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x satisfies Inst", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(6837), kw_end_DASH_line, int(6837))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + return nil + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_inst_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_inst_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // instance? + { + tmp0 := sym_instance_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_c, sym_x)), kw_doc, "Evaluates x and tests if it is an instance of the type\n t. Returns true or false", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(2), kw_line, int(139), kw_end_DASH_line, int(143))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function instance? + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(lang.HasType, []any{v3, v4}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(143), kw_column, int(12), kw_end_DASH_line, int(143), kw_end_DASH_column, int(85))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_instance_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_instance_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // int? + { + tmp0 := sym_int_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a fixed precision integer", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1395), kw_end_DASH_line, int(1395))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "or__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := lang.Apply(tmp4, []any{lang.Builtins["int64"], v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + tmp7 = v6 + } else { + var tmp8 any + { // let + // let binding "or__0__auto__" + tmp9 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp10 := lang.Apply(tmp9, []any{nil, v2}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + tmp12 = v11 + } else { + var tmp13 any + { // let + // let binding "or__0__auto__" + tmp14 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp15 := lang.Apply(tmp14, []any{nil, v2}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + if lang.IsTruthy(v16) { + tmp17 = v16 + } else { + tmp18 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp19 := lang.Apply(tmp18, []any{nil, v2}) + tmp17 = tmp19 + } + tmp13 = tmp17 + } // end let + tmp12 = tmp13 + } + tmp8 = tmp12 + } // end let + tmp7 = tmp8 + } + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_int_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_int_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // integer? + { + tmp0 := sym_integer_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_doc, "Returns true if n is an integer", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(1379), kw_end_DASH_line, int(1379))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(lang.IsInteger, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_integer_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_integer_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // iterate + { + tmp0 := sym_iterate.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_x)), kw_doc, "Returns a lazy (infinite!) sequence of x, (f x), (f (f x)) etc.\n f must be free of side-effects", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(3011), kw_end_DASH_line, int(3011))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := lang.Apply(nil, []any{v2, v3}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_iterate = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_iterate.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // iterator-seq + { + tmp0 := sym_iterator_DASH_seq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_iter)), kw_doc, "Returns a seq on a java.util.Iterator. Note that most collections\n providing iterators implement Iterable and thus support seq directly.\n Seqs cache values, thus iterator-seq should not be used on any\n iterator that repeatedly returns the same mutable object.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(5700), kw_end_DASH_line, int(5700))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(nil, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_iterator_DASH_seq = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_iterator_DASH_seq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // key + { + tmp0 := sym_key.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_e)), kw_doc, "Returns the key of the map entry.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(1563), kw_end_DASH_line, int(1563))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(v2, "GetKey") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("GetKey is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_key = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_key.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // keys + { + tmp0 := sym_keys.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_map)), kw_doc, "Returns a sequence of the map's keys, in the same order as (seq map).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1551), kw_end_DASH_line, int(1551))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(lang.Keys, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_keys = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_keys.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // keyword? + { + tmp0 := sym_keyword_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a Keyword", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(563), kw_end_DASH_line, int(563))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_keyword_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_keyword_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // line-seq + { + tmp0 := sym_line_DASH_seq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_rdr)), kw_doc, "Returns the lines of text from rdr as a lazy sequence of strings.\n rdr must implement java.io.BufferedReader.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(3068), kw_end_DASH_line, int(3068))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "temp__0__auto__" + tmp4, ok := lang.FieldOrMethod(v2, "readLine") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "readLine"))) + } + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { + case reflect.Func: + tmp5 = lang.Apply(tmp4, nil) + default: + tmp5 = tmp4 + } + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + var tmp8 any + { // let + // let binding "line" + var v9 any = v6 + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_cons) + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp12 := checkDerefVar(var_glojure_DOT_core_line_DASH_seq) + tmp13 := lang.Apply(tmp12, []any{v2}) + return tmp13 + }) + tmp12 := lang.Apply(lang.NewLazySeq, []any{tmp11}) + tmp13 := lang.Apply(tmp10, []any{v9, tmp12}) + tmp8 = tmp13 + } // end let + tmp7 = tmp8 + } else { + } + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_line_DASH_seq = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_line_DASH_seq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // list + { + tmp0 := sym_list.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_items)), kw_doc, "Creates a new list containing the items.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(6), kw_column, int(2), kw_line, int(15), kw_end_DASH_line, int(18))).(*lang.Symbol) + var_glojure_DOT_core_list = ns.InternWithValue(tmp0, lang.NewList, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_list.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // list? + { + tmp0 := sym_list_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x implements IPersistentList", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(6198), kw_end_DASH_line, int(6198))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*lang.IPersistentList)(nil)).Elem() + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_list_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_list_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // load-file + { + tmp0 := sym_load_DASH_file.WithMeta(lang.NewMap(kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core_load_DASH_file = ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_load_DASH_file.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // load-reader + { + tmp0 := sym_load_DASH_reader.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_rdr)), kw_doc, "Sequentially read and evaluate the set of forms contained in the\n stream/file", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(4081), kw_end_DASH_line, int(4081))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(runtime.Compiler, "load") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("load is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_load_DASH_reader = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_load_DASH_reader.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // load-string + { + tmp0 := sym_load_DASH_string.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_doc, "Sequentially read and evaluate the set of forms contained in the\n string", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(4088), kw_end_DASH_line, int(4088))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "rdr" + tmp4 := lang.Apply(nil, []any{v2}) + tmp5 := lang.Apply(nil, []any{tmp4}) + var v6 any = tmp5 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_load_DASH_reader) + tmp8 := lang.Apply(tmp7, []any{v6}) + tmp3 = tmp8 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_load_DASH_string = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_load_DASH_string.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // macroexpand-1 + { + tmp0 := sym_macroexpand_DASH_1.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_form)), kw_doc, "If form represents a macro form, returns its expansion,\n else returns form.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(4017), kw_end_DASH_line, int(4017))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(runtime.Compiler, "macroexpand1") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("macroexpand1 is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_macroexpand_DASH_1 = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_macroexpand_DASH_1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // make-hierarchy + { + tmp0 := sym_make_DASH_hierarchy.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Creates a hierarchy object for use with derive, isa? etc.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(5507), kw_end_DASH_line, int(5507))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp2 := lang.NewMap() + tmp3 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5511), kw_column, int(16), kw_end_DASH_line, int(5511), kw_end_DASH_column, int(17)) + tmp4, err := lang.WithMeta(tmp2, tmp3.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp5 := lang.NewMap() + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5511), kw_column, int(32), kw_end_DASH_line, int(5511), kw_end_DASH_column, int(33)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp8 := lang.NewMap() + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5511), kw_column, int(46), kw_end_DASH_line, int(5511), kw_end_DASH_column, int(47)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp11 := lang.NewMap(kw_parents, tmp4, kw_descendants, tmp7, kw_ancestors, tmp10) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5511), kw_column, int(6), kw_end_DASH_line, int(5511), kw_end_DASH_column, int(48)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp13 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_make_DASH_hierarchy = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_make_DASH_hierarchy.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // map-entry? + { + tmp0 := sym_map_DASH_entry_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a map entry", kw_file, "glojure/core.glj", kw_added, "1.8", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(1473), kw_end_DASH_line, int(1473))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*lang.MapEntry)(nil)).Elem() + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_map_DASH_entry_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_map_DASH_entry_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // map? + { + tmp0 := sym_map_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x implements IPersistentMap", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(5), kw_column, int(2), kw_line, int(167), kw_end_DASH_line, int(171))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function map? + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := reflect.TypeOf((*lang.IPersistentMap)(nil)).Elem() + tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(171), kw_column, int(7), kw_end_DASH_line, int(171), kw_end_DASH_column, int(97))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_map_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_map_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // max-mask-bits + { + tmp0 := sym_max_DASH_mask_DASH_bits.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(6601), kw_column, int(6), kw_end_DASH_line, int(6601), kw_end_DASH_column, int(28), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core_max_DASH_mask_DASH_bits = ns.InternWithValue(tmp0, int64(13), true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_max_DASH_mask_DASH_bits.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // max-switch-table-size + { + tmp0 := sym_max_DASH_switch_DASH_table_DASH_size.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(6602), kw_column, int(6), kw_end_DASH_line, int(6602), kw_end_DASH_column, int(36), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core_max_DASH_switch_DASH_table_DASH_size = ns.InternWithValue(tmp0, int64(8192), true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_max_DASH_switch_DASH_table_DASH_size.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // meta + { + tmp0 := sym_meta.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_obj)), kw_doc, "Returns the metadata of obj, returns nil if there is no metadata.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(5), kw_column, int(2), kw_line, int(202), kw_end_DASH_line, int(206))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function meta + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp6 := reflect.TypeOf((*lang.IMeta)(nil)).Elem() + tmp7 := lang.Apply(tmp5, []any{tmp6, v3}) + if lang.IsTruthy(tmp7) { + tmp8, ok := lang.FieldOrMethod(v3, "Meta") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "Meta"))) + } + var tmp9 any + switch reflect.TypeOf(tmp8).Kind() { + case reflect.Func: + tmp9 = lang.Apply(tmp8, nil) + default: + tmp9 = tmp8 + } + tmp4 = tmp9 + } else { + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(206), kw_column, int(7), kw_end_DASH_line, int(208), kw_end_DASH_column, int(21))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_meta = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_meta.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // methods + { + tmp0 := sym_methods.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_multifn)), kw_doc, "Given a multimethod, returns a map of dispatch values -> dispatch fns", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(1809), kw_end_DASH_line, int(1809))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "getMethodTable") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getMethodTable"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_methods = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_methods.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // mix-collection-hash + { + tmp0 := sym_mix_DASH_collection_DASH_hash.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_hash_DASH_basis, sym_count)), kw_doc, "Mix final collection hash for ordered or unordered collections.\n hash-basis is the combined collection hash, count is the number\n of elements included in the basis. Note this is the hash code\n consistent with =, different from .hashCode.\n See http://glojure.org/data_structures#hash for full algorithms.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.6", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(25), kw_column, int(7), kw_line, int(5199), kw_end_DASH_line, int(5199))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := lang.Apply(nil, []any{v2, v3}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_mix_DASH_collection_DASH_hash = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_mix_DASH_collection_DASH_hash.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // mk-bound-fn + { + tmp0 := sym_mk_DASH_bound_DASH_fn.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5127), kw_column, int(7), kw_end_DASH_line, int(5127), kw_end_DASH_column, int(17), kw_arglists, lang.NewList(lang.NewVector(sym_sc, sym_test, sym_key)), kw_private, true, kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v6 := args[0] + _ = v6 + tmp7, ok := lang.FieldOrMethod(v2, "comparator") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "comparator"))) + } + var tmp8 any + switch reflect.TypeOf(tmp7).Kind() { + case reflect.Func: + tmp8 = lang.Apply(tmp7, nil) + default: + tmp8 = tmp7 + } + tmp9, _ := lang.FieldOrMethod(v2, "entryKey") + if reflect.TypeOf(tmp9).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("entryKey is not a function"))) + } + tmp10 := lang.Apply(tmp9, []any{v6}) + tmp11, _ := lang.FieldOrMethod(tmp8, "compare") + if reflect.TypeOf(tmp11).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("compare is not a function"))) + } + tmp12 := lang.Apply(tmp11, []any{tmp10, v4}) + tmp13 := lang.Apply(v3, []any{tmp12, int64(0)}) + return tmp13 + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5130), kw_column, int(3), kw_end_DASH_line, int(5131), kw_end_DASH_column, int(64)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp7 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_mk_DASH_bound_DASH_fn = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_mk_DASH_bound_DASH_fn.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // namespace + { + tmp1 := reflect.TypeOf("") + tmp0 := sym_namespace.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns the namespace String of a symbol or keyword, or nil if not present.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(1593), kw_end_DASH_line, int(1593))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v3, "Namespace") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Namespace is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{}) + return tmp5 + }) + tmp3 := reflect.TypeOf("") + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_namespace = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_namespace.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // next + { + tmp1 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() + tmp0 := sym_next.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a seq of the items after the first. Calls seq on its\n argument. If there are no more items, returns nil.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(5), kw_column, int(2), kw_line, int(55), kw_end_DASH_line, int(61))).(*lang.Symbol) + var tmp2 lang.FnFunc + { // function next + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + tmp5 := lang.Apply(lang.Next, []any{v4}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(61), kw_column, int(7), kw_end_DASH_line, int(61), kw_end_DASH_column, int(77))).(lang.FnFunc) + v3 = tmp2 + _ = v3 + } + var_glojure_DOT_core_next = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_next.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // nfirst + { + tmp0 := sym_nfirst.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Same as (next (first x))", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(2), kw_line, int(105), kw_end_DASH_line, int(109))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function nfirst + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_next) + tmp5 := checkDerefVar(var_glojure_DOT_core_first) + tmp6 := lang.Apply(tmp5, []any{v3}) + tmp7 := lang.Apply(tmp4, []any{tmp6}) + return tmp7 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(109), kw_column, int(9), kw_end_DASH_line, int(109), kw_end_DASH_column, int(49))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_nfirst = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_nfirst.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // nil? + { + tmp1 := reflect.TypeOf(false) + var tmp2 lang.FnFunc + { // function nil?__inliner + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_list) + tmp6 := lang.Apply(tmp5, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Identical, v4, nil}) + return tmp6 + }) + v3 = tmp2 + _ = v3 + } + tmp0 := sym_nil_QMARK_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp2, kw_doc, "Returns true if x is nil, false otherwise.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(435), kw_end_DASH_line, int(435))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + tmp5 := lang.Apply(lang.IsNil, []any{v4}) + return tmp5 + }) + tmp4 := reflect.TypeOf(false) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) + var_glojure_DOT_core_nil_QMARK_ = ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_nil_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // nnext + { + tmp0 := sym_nnext.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Same as (next (next x))", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(6), kw_column, int(2), kw_line, int(119), kw_end_DASH_line, int(123))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function nnext + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_next) + tmp5 := checkDerefVar(var_glojure_DOT_core_next) + tmp6 := lang.Apply(tmp5, []any{v3}) + tmp7 := lang.Apply(tmp4, []any{tmp6}) + return tmp7 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(123), kw_column, int(8), kw_end_DASH_line, int(123), kw_end_DASH_column, int(46))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_nnext = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_nnext.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // not + { + tmp1 := reflect.TypeOf(false) + tmp0 := sym_not.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x is logical false, false otherwise.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(523), kw_end_DASH_line, int(523))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + var tmp4 any + if lang.IsTruthy(v3) { + tmp4 = false + } else { + tmp4 = true + } + return tmp4 + }) + tmp3 := reflect.TypeOf(false) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_not = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_not.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // number? + { + tmp0 := sym_number_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x is a Number", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(3560), kw_end_DASH_line, int(3560))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(lang.IsNumber, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_number_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_number_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // numerator + { + tmp1 := reflect.TypeOf((*big6.Int)(nil)) + tmp0 := sym_numerator.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_r)), kw_doc, "Returns the numerator part of a Ratio.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(3583), kw_end_DASH_line, int(3583))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, ok := lang.FieldOrMethod(v3, "numerator") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "numerator"))) + } + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { + case reflect.Func: + tmp5 = lang.Apply(tmp4, nil) + default: + tmp5 = tmp4 + } + return tmp5 + }) + tmp3 := reflect.TypeOf((*big6.Int)(nil)) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_numerator = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_numerator.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // peek + { + tmp0 := sym_peek.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "For a list or queue, same as first, for a vector, same as, but much\n more efficient than, last. If the collection is empty, returns nil.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1455), kw_end_DASH_line, int(1455))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(runtime.RT, "Peek") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Peek is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_peek = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_peek.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // persistent! + { + tmp0 := sym_persistent_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a new, persistent version of the transient collection, in\n constant time. The transient collection cannot be used after this\n call, any such use will throw an exception.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(3350), kw_end_DASH_line, int(3350))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "Persistent") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "Persistent"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_persistent_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_persistent_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // pop + { + tmp0 := sym_pop.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "For a list or queue, returns a new list/queue without the first\n item, for a vector, returns a new vector without the last item. If\n the collection is empty, throws an exception. Note - not the same\n as next/butlast.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(1462), kw_end_DASH_line, int(1462))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(runtime.RT, "Pop") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Pop is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_pop = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_pop.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // pop! + { + tmp0 := sym_pop_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Removes the last item from a transient vector. If\n the collection is empty, throws an exception. Returns coll", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3393), kw_end_DASH_line, int(3393))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "pop") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "pop"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_pop_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_pop_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // pop-thread-bindings + { + tmp0 := sym_pop_DASH_thread_DASH_bindings.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Pop one set of bindings pushed with push-binding before. It is an error to\n pop bindings without pushing before.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(25), kw_column, int(7), kw_line, int(1929), kw_end_DASH_line, int(1929))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp2 := lang.Apply(lang.PopThreadBindings, nil) + return tmp2 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_pop_DASH_thread_DASH_bindings = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_pop_DASH_thread_DASH_bindings.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // prefer-method + { + tmp0 := sym_prefer_DASH_method.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_multifn, sym_dispatch_DASH_val_DASH_x, sym_dispatch_DASH_val_DASH_y)), kw_doc, "Causes the multimethod to prefer matches of dispatch-val-x over dispatch-val-y \n when there is a conflict", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(1801), kw_end_DASH_line, int(1801))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5, _ := lang.FieldOrMethod(v2, "PreferMethod") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("PreferMethod is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_prefer_DASH_method = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_prefer_DASH_method.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // prefers + { + tmp0 := sym_prefers.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_multifn)), kw_doc, "Given a multimethod, returns a map of preferred value -> set of other values", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(1822), kw_end_DASH_line, int(1822))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "getPreferTable") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getPreferTable"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_prefers = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_prefers.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print-initialized + { + tmp0 := sym_print_DASH_initialized.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core_print.glj", kw_line, int(520), kw_column, int(6), kw_end_DASH_line, int(520), kw_end_DASH_column, int(39), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core_print_DASH_initialized = ns.InternWithValue(tmp0, true, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_print_DASH_initialized.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // push-thread-bindings + { + tmp0 := sym_push_DASH_thread_DASH_bindings.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_bindings)), kw_doc, "WARNING: This is a low-level function. Prefer high-level macros like\n binding where ever possible.\n\n Takes a map of Var/value pairs. Binds each Var to the associated value for\n the current thread. Each call *MUST* be accompanied by a matching call to\n pop-thread-bindings wrapped in a try-finally!\n \n (push-thread-bindings bindings)\n (try\n ...\n (finally\n (pop-thread-bindings)))", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(26), kw_column, int(7), kw_line, int(1911), kw_end_DASH_line, int(1911))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(lang.PushThreadBindings, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_push_DASH_thread_DASH_bindings = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_push_DASH_thread_DASH_bindings.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // random-uuid + { + tmp0 := sym_random_DASH_uuid.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Returns a pseudo-randomly generated java.util.UUID instance (i.e. type 4).\n\n See: https://docs.oracle.com/javase/8/docs/api/java/util/UUID.html#randomUUID--", kw_file, "glojure/core.glj", kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(6852), kw_end_DASH_line, int(6852))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp2 := lang.Apply(uuid10.NewV7, nil) + return tmp2 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_random_DASH_uuid = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_random_DASH_uuid.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ratio? + { + tmp0 := sym_ratio_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_doc, "Returns true if n is a Ratio", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(3577), kw_end_DASH_line, int(3577))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*lang.Ratio)(nil)) + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ratio_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ratio_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // rationalize + { + tmp0 := sym_rationalize.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_num)), kw_doc, "returns the rational value of num", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(1282), kw_end_DASH_line, int(1282))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(lang.Numbers, "Rationalize") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Rationalize is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_rationalize = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_rationalize.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // re-matcher + { + tmp1 := reflect.TypeOf((*lang.RegexpMatcher)(nil)) + tmp0 := sym_re_DASH_matcher.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_re, sym_s)), kw_doc, "Returns an instance of java.util.regex.Matcher, for use, e.g. in\n re-find.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4873), kw_end_DASH_line, int(4873))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(lang.NewRegexpMatcher, []any{v3, v4}) + return tmp5 + }) + tmp3 := reflect.TypeOf((*lang.RegexpMatcher)(nil)) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_re_DASH_matcher = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_re_DASH_matcher.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // re-pattern + { + tmp1 := reflect.TypeOf((*regexp12.Regexp)(nil)) + tmp0 := sym_re_DASH_pattern.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_doc, "Returns an instance of java.util.regex.Pattern, for use, e.g. in\n re-matcher.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4863), kw_end_DASH_line, int(4863))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp6 := reflect.TypeOf((*regexp12.Regexp)(nil)) + tmp7 := lang.Apply(tmp5, []any{tmp6, v3}) + if lang.IsTruthy(tmp7) { + tmp4 = v3 + } else { + tmp8 := lang.Apply(regexp12.MustCompile, []any{v3}) + tmp4 = tmp8 + } + return tmp4 + }) + tmp3 := reflect.TypeOf((*regexp12.Regexp)(nil)) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_re_DASH_pattern = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_re_DASH_pattern.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // read-string + { + tmp0 := sym_read_DASH_string.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s), lang.NewVector(sym_opts, sym_s)), kw_doc, "Reads one object from the string s. Optionally include reader\n options, as specified in read.\n\n Note that read-string can execute code (controlled by *read-eval*),\n and as such should be used only with trusted sources.\n\n For data structure interop use glojure.edn/read-string", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(3806), kw_end_DASH_line, int(3806))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(runtime.RTReadString, []any{v2}) + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := lang.Apply(runtime.RTReadString, []any{v3, v2}) + return tmp4 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_read_DASH_string = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_read_DASH_string.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reader-conditional + { + tmp0 := sym_reader_DASH_conditional.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_form, sym_splicing_QMARK_)), kw_doc, "Construct a data representation of a reader conditional.\n If true, splicing? indicates read-cond-splicing.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(24), kw_column, int(7), kw_line, int(7782), kw_end_DASH_line, int(7782))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := lang.Apply(nil, []any{v2, v3}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_reader_DASH_conditional = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_reader_DASH_conditional.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reader-conditional? + { + tmp0 := sym_reader_DASH_conditional_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_value)), kw_doc, "Return true if the value is the data representation of a reader conditional", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(25), kw_column, int(7), kw_line, int(7776), kw_end_DASH_line, int(7776))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := lang.Apply(tmp3, []any{nil, v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_reader_DASH_conditional_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_reader_DASH_conditional_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // realized? + { + tmp0 := sym_realized_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if a value has been produced for a promise, delay, future or lazy sequence.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(7559), kw_end_DASH_line, int(7559))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "isRealized") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "isRealized"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_realized_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_realized_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reduced + { + tmp0 := sym_reduced.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Wraps x in a way such that a reduce will terminate with the value x", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(2828), kw_end_DASH_line, int(2828))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(lang.NewReduced, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_reduced = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_reduced.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ref-history-count + { + tmp0 := sym_ref_DASH_history_DASH_count.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ref)), kw_doc, "Returns the history count of a ref", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(7), kw_line, int(2455), kw_end_DASH_line, int(2455))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "getHistoryCount") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getHistoryCount"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ref_DASH_history_DASH_count = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ref_DASH_history_DASH_count.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ref-max-history + { + tmp0 := sym_ref_DASH_max_DASH_history.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ref), lang.NewVector(sym_ref, sym_n)), kw_doc, "Gets the max-history of a ref, or sets it and returns the ref", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(2471), kw_end_DASH_line, int(2471))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "getMaxHistory") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getMaxHistory"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "setMaxHistory") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMaxHistory is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ref_DASH_max_DASH_history = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ref_DASH_max_DASH_history.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ref-min-history + { + tmp0 := sym_ref_DASH_min_DASH_history.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ref), lang.NewVector(sym_ref, sym_n)), kw_doc, "Gets the min-history of a ref, or sets it and returns the ref", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(2462), kw_end_DASH_line, int(2462))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "getMinHistory") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getMinHistory"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "setMinHistory") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMinHistory is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ref_DASH_min_DASH_history = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ref_DASH_min_DASH_history.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ref-set + { + tmp0 := sym_ref_DASH_set.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ref, sym_val)), kw_doc, "Must be called in a transaction. Sets the value of ref.\n Returns val.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(2447), kw_end_DASH_line, int(2447))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "set") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("set is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ref_DASH_set = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ref_DASH_set.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // release-pending-sends + { + tmp0 := sym_release_DASH_pending_DASH_sends.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Normally, actions sent directly or indirectly during another action\n are held until the action completes (changes the agent's\n state). This function can be used to dispatch any pending sent\n actions immediately. This has no impact on actions sent during a\n transaction, which are still held until commit. If no action is\n occurring, does nothing. Returns the number of actions dispatched.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(27), kw_column, int(7), kw_line, int(2131), kw_end_DASH_line, int(2131))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp2 := lang.Apply(nil, nil) + return tmp2 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_release_DASH_pending_DASH_sends = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_release_DASH_pending_DASH_sends.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // remove-all-methods + { + tmp0 := sym_remove_DASH_all_DASH_methods.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_multifn)), kw_doc, "Removes all of the methods of multimethod.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(24), kw_column, int(7), kw_line, int(1787), kw_end_DASH_line, int(1787))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "reset") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "reset"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_remove_DASH_all_DASH_methods = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_remove_DASH_all_DASH_methods.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // remove-method + { + tmp0 := sym_remove_DASH_method.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_multifn, sym_dispatch_DASH_val)), kw_doc, "Removes the method of multimethod associated with dispatch-value.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(1794), kw_end_DASH_line, int(1794))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "removeMethod") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("removeMethod is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_remove_DASH_method = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_remove_DASH_method.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // remove-ns + { + tmp0 := sym_remove_DASH_ns.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_sym)), kw_doc, "Removes the namespace named by the symbol. Use with caution.\n Cannot be used to remove the glojure namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(4139), kw_end_DASH_line, int(4139))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(lang.RemoveNamespace, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_remove_DASH_ns = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_remove_DASH_ns.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // remove-watch + { + tmp0 := sym_remove_DASH_watch.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_reference, sym_key)), kw_doc, "Removes a watch (set by add-watch) from a reference", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(2160), kw_end_DASH_line, int(2160))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "removeWatch") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("removeWatch is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_remove_DASH_watch = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_remove_DASH_watch.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // repeat + { + tmp0 := sym_repeat.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_n, sym_x)), kw_doc, "Returns a lazy (infinite!, or length n if supplied) sequence of xs.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(2997), kw_end_DASH_line, int(2997))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(lang.NewRepeat, []any{v2}) + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := lang.Apply(lang.NewRepeatN, []any{v2, v3}) + return tmp4 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_repeat = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_repeat.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reset! + { + tmp0 := sym_reset_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_atom, sym_newval)), kw_doc, "Sets the value of atom to newval without regard for the\n current value. Returns newval.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(2368), kw_end_DASH_line, int(2368))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "reset") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_reset_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_reset_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reset-meta! + { + tmp0 := sym_reset_DASH_meta_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_iref, sym_metadata_DASH_map)), kw_doc, "Atomically resets the metadata for a namespace/var/ref/agent/atom", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(2408), kw_end_DASH_line, int(2408))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "ResetMeta") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ResetMeta is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_reset_DASH_meta_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_reset_DASH_meta_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reset-vals! + { + tmp0 := sym_reset_DASH_vals_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_atom, sym_newval)), kw_doc, "Sets the value of atom to newval. Returns [old new], the value of the\n atom before and after the reset.", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(2375), kw_end_DASH_line, int(2375))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "resetVals") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("resetVals is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_reset_DASH_vals_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_reset_DASH_vals_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // rest + { + tmp1 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() + tmp0 := sym_rest.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a possibly empty seq of the items after the first. Calls seq on its\n argument.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(5), kw_column, int(2), kw_line, int(64), kw_end_DASH_line, int(70))).(*lang.Symbol) + var tmp2 lang.FnFunc + { // function rest + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + tmp5 := lang.Apply(lang.Rest, []any{v4}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(70), kw_column, int(7), kw_end_DASH_line, int(70), kw_end_DASH_column, int(77))).(lang.FnFunc) + v3 = tmp2 + _ = v3 + } + var_glojure_DOT_core_rest = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_rest.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reversible? + { + tmp0 := sym_reversible_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns true if coll implements Reversible", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(6257), kw_end_DASH_line, int(6257))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := lang.Apply(tmp3, []any{nil, v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_reversible_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_reversible_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // rseq + { + tmp0 := sym_rseq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_rev)), kw_doc, "Returns, in constant time, a seq of the items in rev (which\n can be a vector or sorted-map), in reverse order. If rev is empty returns nil", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1577), kw_end_DASH_line, int(1577))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(v2, "rseq") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("rseq is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_rseq = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_rseq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // second + { + tmp0 := sym_second.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Same as (first (next x))", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(2), kw_line, int(91), kw_end_DASH_line, int(95))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function second + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_first) + tmp5 := checkDerefVar(var_glojure_DOT_core_next) + tmp6 := lang.Apply(tmp5, []any{v3}) + tmp7 := lang.Apply(tmp4, []any{tmp6}) + return tmp7 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(95), kw_column, int(9), kw_end_DASH_line, int(95), kw_end_DASH_column, int(49))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_second = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_second.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // seq + { + tmp1 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() + tmp0 := sym_seq.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a seq on the collection. If the collection is\n empty, returns nil. (seq nil) returns nil. seq also works on\n Strings, native Java arrays (of reference types) and any objects\n that implement Iterable. Note that seqs cache values, thus seq\n should not be used on any Iterable whose iterator repeatedly\n returns the same mutable object.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(4), kw_column, int(2), kw_line, int(126), kw_end_DASH_line, int(136))).(*lang.Symbol) + var tmp2 lang.FnFunc + { // function seq + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + tmp5 := lang.Apply(lang.Seq, []any{v4}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(136), kw_column, int(6), kw_end_DASH_line, int(136), kw_end_DASH_column, int(126))).(lang.FnFunc) + v3 = tmp2 + _ = v3 + } + var_glojure_DOT_core_seq = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_seq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // seq? + { + tmp0 := sym_seq_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x implements ISeq", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(5), kw_column, int(2), kw_line, int(146), kw_end_DASH_line, int(150))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function seq? + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() + tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(150), kw_column, int(7), kw_end_DASH_line, int(150), kw_end_DASH_column, int(87))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_seq_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_seq_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // seqable? + { + tmp0 := sym_seqable_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if the seq function is supported for x", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(6204), kw_end_DASH_line, int(6204))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(nil, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_seqable_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_seqable_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // sequential? + { + tmp0 := sym_sequential_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns true if coll implements Sequential", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(6229), kw_end_DASH_line, int(6229))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*lang.Sequential)(nil)).Elem() + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_sequential_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_sequential_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // set-agent-send-executor! + { + tmp0 := sym_set_DASH_agent_DASH_send_DASH_executor_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_executor)), kw_doc, "Sets the ExecutorService to be used by send", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(30), kw_column, int(7), kw_line, int(2087), kw_end_DASH_line, int(2087))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + return nil + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_set_DASH_agent_DASH_send_DASH_executor_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_set_DASH_agent_DASH_send_DASH_executor_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // set-agent-send-off-executor! + { + tmp0 := sym_set_DASH_agent_DASH_send_DASH_off_DASH_executor_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_executor)), kw_doc, "Sets the ExecutorService to be used by send-off", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(34), kw_column, int(7), kw_line, int(2093), kw_end_DASH_line, int(2093))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + return nil + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_set_DASH_agent_DASH_send_DASH_off_DASH_executor_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_set_DASH_agent_DASH_send_DASH_off_DASH_executor_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // set-error-handler! + { + tmp0 := sym_set_DASH_error_DASH_handler_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a, sym_handler_DASH_fn)), kw_doc, "Sets the error-handler of agent a to handler-fn. If an action\n being run by the agent throws an exception or doesn't pass the\n validator fn, handler-fn will be called with two arguments: the\n agent and the exception.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(24), kw_column, int(7), kw_line, int(2192), kw_end_DASH_line, int(2192))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "setErrorHandler") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorHandler is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_set_DASH_error_DASH_handler_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_set_DASH_error_DASH_handler_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // set-error-mode! + { + tmp0 := sym_set_DASH_error_DASH_mode_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a, sym_mode_DASH_keyword)), kw_doc, "Sets the error-mode of agent a to mode-keyword, which must be\n either :fail or :continue. If an action being run by the agent\n throws an exception or doesn't pass the validator fn, an\n error-handler may be called (see set-error-handler!), after which,\n if the mode is :continue, the agent will continue as if neither the\n action that caused the error nor the error itself ever happened.\n \n If the mode is :fail, the agent will become failed and will stop\n accepting new 'send' and 'send-off' actions, and any previously\n queued actions will be held until a 'restart-agent'. Deref will\n still work, returning the state of the agent before the error.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(2210), kw_end_DASH_line, int(2210))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "setErrorMode") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorMode is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_set_DASH_error_DASH_mode_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_set_DASH_error_DASH_mode_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // set-validator! + { + tmp0 := sym_set_DASH_validator_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_iref, sym_validator_DASH_fn)), kw_doc, "Sets the validator-fn for a var/ref/agent/atom. validator-fn must be nil or a\n side-effect-free fn of one argument, which will be passed the intended\n new state on any state change. If the new state is unacceptable, the\n validator-fn should return false or throw an exception. If the current state (root\n value if var) is not acceptable to the new validator, an exception\n will be thrown and the validator will not be changed.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(2381), kw_end_DASH_line, int(2381))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "setValidator") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setValidator is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_set_DASH_validator_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_set_DASH_validator_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // set? + { + tmp0 := sym_set_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x implements IPersistentSet", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(4098), kw_end_DASH_line, int(4098))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*lang.IPersistentSet)(nil)).Elem() + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_set_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_set_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // shutdown-agents + { + tmp0 := sym_shutdown_DASH_agents.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Initiates a shutdown of the thread pools that back the agent\n system. Running actions will complete, but no new actions will be\n accepted", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(2252), kw_end_DASH_line, int(2252))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp2 := lang.Apply(lang.ShutdownAgents, nil) + return tmp2 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_shutdown_DASH_agents = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_shutdown_DASH_agents.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // simple-keyword? + { + tmp0 := sym_simple_DASH_keyword_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a keyword without a namespace", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(1633), kw_end_DASH_line, int(1633))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "and__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + tmp8 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp9 := checkDerefVar(var_glojure_DOT_core_namespace) + tmp10 := lang.Apply(tmp9, []any{v2}) + tmp11 := lang.Apply(tmp8, []any{tmp10}) + tmp7 = tmp11 + } else { + tmp7 = v6 + } + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_simple_DASH_keyword_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_simple_DASH_keyword_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // some + { + tmp0 := sym_some.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns the first logical true value of (pred x) for any x in coll,\n else nil. One common idiom is to use a set as pred, for example\n this will return :fred if :fred is in the sequence, otherwise nil:\n (some #{:fred} coll)", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(2684), kw_end_DASH_line, int(2684))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + recur_loop_2021: + var tmp4 any + { // let + // let binding "temp__0__auto__" + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := lang.Apply(tmp5, []any{v3}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + if lang.IsTruthy(v7) { + var tmp9 any + { // let + // let binding "s" + var v10 any = v7 + _ = v10 + var tmp11 any + { // let + // let binding "or__0__auto__" + tmp12 := checkDerefVar(var_glojure_DOT_core_first) + tmp13 := lang.Apply(tmp12, []any{v10}) + tmp14 := lang.Apply(v2, []any{tmp13}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + if lang.IsTruthy(v15) { + tmp16 = v15 + } else { + var tmp17 any = v2 + tmp19 := checkDerefVar(var_glojure_DOT_core_next) + tmp20 := lang.Apply(tmp19, []any{v10}) + var tmp18 any = tmp20 + v2 = tmp17 + v3 = tmp18 + goto recur_loop_2021 + } + tmp11 = tmp16 + } // end let + tmp9 = tmp11 + } // end let + tmp8 = tmp9 + } else { + } + tmp4 = tmp8 + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_some = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_some.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // some? + { + tmp1 := reflect.TypeOf(false) + tmp0 := sym_some_QMARK_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x is not nil, false otherwise.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.6", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(530), kw_end_DASH_line, int(530))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_not) + tmp5 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + tmp7 := lang.Apply(tmp4, []any{tmp6}) + return tmp7 + }) + tmp3 := reflect.TypeOf(false) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_some_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_some_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // sorted-map + { + tmp0 := sym_sorted_DASH_map.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_keyvals)), kw_doc, "keyval => key val\n Returns a new sorted map with supplied mappings. If any keys are\n equal, they are handled as if by repeated uses of assoc.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(397), kw_end_DASH_line, int(397))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + tmp3 := lang.Apply(lang.CreatePersistentTreeMap, []any{v2}) + return tmp3 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_sorted_DASH_map = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_sorted_DASH_map.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // sorted-map-by + { + tmp0 := sym_sorted_DASH_map_DASH_by.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_comparator, sym__AMP_, sym_keyvals)), kw_doc, "keyval => key val\n Returns a new sorted map with supplied mappings, using the supplied\n comparator. If any keys are equal, they are handled as if by\n repeated uses of assoc.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(406), kw_end_DASH_line, int(406))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + tmp4 := lang.Apply(nil, []any{v2, v3}) + return tmp4 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_sorted_DASH_map_DASH_by = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_sorted_DASH_map_DASH_by.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // sorted-set + { + tmp0 := sym_sorted_DASH_set.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_keys)), kw_doc, "Returns a new sorted set with supplied keys. Any equal keys are\n handled as if by repeated uses of conj.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(416), kw_end_DASH_line, int(416))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + tmp3 := lang.Apply(lang.CreatePersistentTreeSet, []any{v2}) + return tmp3 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_sorted_DASH_set = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_sorted_DASH_set.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // sorted-set-by + { + tmp0 := sym_sorted_DASH_set_DASH_by.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_comparator, sym__AMP_, sym_keys)), kw_doc, "Returns a new sorted set with supplied keys, using the supplied\n comparator. Any equal keys are handled as if by repeated uses of\n conj.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(424), kw_end_DASH_line, int(424))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + tmp4 := lang.Apply(lang.CreatePersistentTreeSetWithComparator, []any{v2, v3}) + return tmp4 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_sorted_DASH_set_DASH_by = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_sorted_DASH_set_DASH_by.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // sorted? + { + tmp0 := sym_sorted_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns true if coll implements Sorted", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(6235), kw_end_DASH_line, int(6235))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := lang.Apply(tmp3, []any{nil, v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_sorted_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_sorted_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // special-symbol? + { + tmp0 := sym_special_DASH_symbol_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_doc, "Returns true if s names a special form", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(4992), kw_end_DASH_line, int(4992))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp4, ok := lang.FieldOrMethod(runtime.Compiler, "specials") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", runtime.Compiler, "specials"))) + } + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { + case reflect.Func: + tmp5 = lang.Apply(tmp4, nil) + default: + tmp5 = tmp4 + } + tmp6 := lang.Apply(tmp3, []any{tmp5, v2}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_special_DASH_symbol_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_special_DASH_symbol_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // spread + { + tmp0 := sym_spread.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_arglist)), kw_static, true, kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(632), kw_end_DASH_line, int(632), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + } else { + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp8 := checkDerefVar(var_glojure_DOT_core_next) + tmp9 := lang.Apply(tmp8, []any{v2}) + tmp10 := lang.Apply(tmp7, []any{tmp9}) + if lang.IsTruthy(tmp10) { + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_first) + tmp13 := lang.Apply(tmp12, []any{v2}) + tmp14 := lang.Apply(tmp11, []any{tmp13}) + tmp6 = tmp14 + } else { + var tmp15 any + if lang.IsTruthy(kw_else) { + tmp16 := checkDerefVar(var_glojure_DOT_core_cons) + tmp17 := checkDerefVar(var_glojure_DOT_core_first) + tmp18 := lang.Apply(tmp17, []any{v2}) + tmp19 := checkDerefVar(var_glojure_DOT_core_spread) + tmp20 := checkDerefVar(var_glojure_DOT_core_next) + tmp21 := lang.Apply(tmp20, []any{v2}) + tmp22 := lang.Apply(tmp19, []any{tmp21}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp22}) + tmp15 = tmp23 + } else { + } + tmp6 = tmp15 + } + tmp3 = tmp6 + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_spread = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_spread.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // str + { + tmp1 := reflect.TypeOf("") + tmp0 := sym_str.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_x), lang.NewVector(sym_x, sym__AMP_, sym_ys)), kw_doc, "With no args, returns the empty string. With one arg x, returns\n x.toString(). (str nil) returns the empty string. With more than\n one arg, returns the concatenation of the str values of the args.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(543), kw_end_DASH_line, int(543))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return "" + case 1: + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + tmp4 = "" + } else { + tmp7 := lang.Apply(lang.ToString, []any{v3}) + tmp4 = tmp7 + } + return tmp4 + default: + checkArity(args, 1) + v3 := args[0] + _ = v3 + var v4 any = lang.NewList(args[1:]...) + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + recur_loop_1614: + var tmp8 any + if lang.IsTruthy(v7) { + tmp10 := checkDerefVar(var_glojure_DOT_core_str) + tmp11 := checkDerefVar(var_glojure_DOT_core_first) + tmp12 := lang.Apply(tmp11, []any{v7}) + tmp13 := lang.Apply(tmp10, []any{tmp12}) + tmp14, _ := lang.FieldOrMethod(v6, "WriteString") + if reflect.TypeOf(tmp14).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("WriteString is not a function"))) + } + tmp15 := lang.Apply(tmp14, []any{tmp13}) + _ = tmp15 + var tmp9 any = v6 + tmp17 := checkDerefVar(var_glojure_DOT_core_next) + tmp18 := lang.Apply(tmp17, []any{v7}) + var tmp16 any = tmp18 + v6 = tmp9 + v7 = tmp16 + goto recur_loop_1614 + } else { + tmp19, ok := lang.FieldOrMethod(v6, "String") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "String"))) + } + var tmp20 any + switch reflect.TypeOf(tmp19).Kind() { + case reflect.Func: + tmp20 = lang.Apply(tmp19, nil) + default: + tmp20 = tmp19 + } + tmp8 = tmp20 + } + return tmp8 + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(554), kw_column, int(7), kw_end_DASH_line, int(554), kw_end_DASH_column, int(127)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp8 := checkDerefVar(var_glojure_DOT_core_cons) + tmp9 := lang.Apply(tmp8, []any{v3, v4}) + tmp10 := lang.Apply(tmp7, []any{"unimplemented: new with non-constant class type", tmp9}) + return tmp10 + } + }) + tmp3 := reflect.TypeOf("") + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_str = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_str.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // stream-reduce! + { + tmp0 := sym_stream_DASH_reduce_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_s), lang.NewVector(sym_f, sym_init, sym_s)), kw_doc, "Works like reduce but takes a java.util.stream.BaseStream as its source.\n Honors 'reduced', is a terminal operation on the stream", kw_file, "glojure/core.glj", kw_added, "1.12", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(6784), kw_end_DASH_line, int(6784))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, ok := lang.FieldOrMethod(v3, "iterator") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "iterator"))) + } + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { + case reflect.Func: + tmp5 = lang.Apply(tmp4, nil) + default: + tmp5 = tmp4 + } + tmp6 := lang.Apply(nil, []any{tmp5, v2}) + return tmp6 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5, ok := lang.FieldOrMethod(v4, "iterator") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "iterator"))) + } + var tmp6 any + switch reflect.TypeOf(tmp5).Kind() { + case reflect.Func: + tmp6 = lang.Apply(tmp5, nil) + default: + tmp6 = tmp5 + } + tmp7 := lang.Apply(nil, []any{tmp6, v2, v3}) + return tmp7 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_stream_DASH_reduce_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_stream_DASH_reduce_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // stream-seq! + { + tmp0 := sym_stream_DASH_seq_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_stream)), kw_doc, "Takes a java.util.stream.BaseStream instance s and returns a seq of its\n contents. This is a terminal operation on the stream.", kw_file, "glojure/core.glj", kw_added, "1.12", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(6793), kw_end_DASH_line, int(6793))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_iterator_DASH_seq) + tmp4, ok := lang.FieldOrMethod(v2, "iterator") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "iterator"))) + } + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { + case reflect.Func: + tmp5 = lang.Apply(tmp4, nil) + default: + tmp5 = tmp4 + } + tmp6 := lang.Apply(tmp3, []any{tmp5}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_stream_DASH_seq_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_stream_DASH_seq_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // stream-transduce! + { + tmp0 := sym_stream_DASH_transduce_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xform, sym_f, sym_stream), lang.NewVector(sym_xform, sym_f, sym_init, sym_stream)), kw_doc, "Works like transduce but takes a java.util.stream.BaseStream as its source.\n This is a terminal operation on the stream.", kw_file, "glojure/core.glj", kw_added, "1.12", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(7), kw_line, int(6800), kw_end_DASH_line, int(6800))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_stream_DASH_transduce_BANG_) + tmp6 := lang.Apply(v3, nil) + tmp7 := lang.Apply(tmp5, []any{v2, v3, tmp6, v4}) + return tmp7 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var tmp6 any + { // let + // let binding "f" + tmp7 := lang.Apply(v2, []any{v3}) + var v8 any = tmp7 + _ = v8 + // let binding "ret" + tmp9 := checkDerefVar(var_glojure_DOT_core_stream_DASH_reduce_BANG_) + tmp10 := lang.Apply(tmp9, []any{v8, v4, v5}) + var v11 any = tmp10 + _ = v11 + tmp12 := lang.Apply(v8, []any{v11}) + tmp6 = tmp12 + } // end let + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_stream_DASH_transduce_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_stream_DASH_transduce_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // string? + { + tmp0 := sym_string_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a String", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(2), kw_line, int(160), kw_end_DASH_line, int(164))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function string? + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := lang.Apply(tmp4, []any{lang.Builtins["string"], v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(164), kw_column, int(10), kw_end_DASH_line, int(164), kw_end_DASH_column, int(58))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_string_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_string_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // struct + { + tmp0 := sym_struct.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s, sym__AMP_, sym_vals)), kw_doc, "Returns a new structmap instance with the keys of the\n structure-basis. vals must be supplied for basis keys in order -\n where values are not supplied they will default to nil.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(4061), kw_end_DASH_line, int(4061))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + tmp4 := lang.Apply(lang.ConstructPersistentStructMap, []any{v2, v3}) + return tmp4 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_struct = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_struct.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // struct-map + { + tmp0 := sym_struct_DASH_map.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s, sym__AMP_, sym_inits)), kw_doc, "Returns a new structmap instance with the keys of the\n structure-basis. keyvals may contain all, some or none of the basis\n keys - where values are not supplied they will default to nil.\n keyvals can also contain keys not in the basis.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4051), kw_end_DASH_line, int(4051))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + tmp4 := lang.Apply(lang.CreatePersistentStructMap, []any{v2, v3}) + return tmp4 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_struct_DASH_map = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_struct_DASH_map.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // subs + { + tmp0 := sym_subs.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s, sym_start), lang.NewVector(sym_s, sym_start, sym_end)), kw_doc, "Returns the substring of s beginning at start inclusive, and ending\n at end (defaults to length of string), exclusive.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(5005), kw_end_DASH_line, int(5005))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := lang.Apply(lang.Builtins["slice"], []any{v2, v3}) + return tmp4 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := lang.Apply(lang.Builtins["slice"], []any{v2, v3, v4}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_subs = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_subs.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // swap! + { + tmp0 := sym_swap_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_atom, sym_f, sym__AMP_, sym_args)), kw_doc, "Atomically swaps the value of atom to be:\n (apply f current-value-of-atom args). Note that f may be called\n multiple times, and thus should be free of side effects. Returns\n the value that was swapped in.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(2343), kw_end_DASH_line, int(2343))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5, _ := lang.FieldOrMethod(v2, "swap") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("swap is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_swap_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_swap_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // swap-vals! + { + tmp0 := sym_swap_DASH_vals_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_atom, sym_f, sym__AMP_, sym_args)), kw_doc, "Atomically swaps the value of atom to be:\n (apply f current-value-of-atom args). Note that f may be called\n multiple times, and thus should be free of side effects.\n Returns [old new], the value of the atom before and after the swap.", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(2352), kw_end_DASH_line, int(2352))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5, _ := lang.FieldOrMethod(v2, "swapVals") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("swapVals is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_swap_DASH_vals_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_swap_DASH_vals_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // symbol? + { + tmp0 := sym_symbol_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a Symbol", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(557), kw_end_DASH_line, int(557))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*lang.Symbol)(nil)) + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_symbol_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_symbol_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // system-newline + { + tmp0 := sym_system_DASH_newline.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(3695), kw_column, int(6), kw_end_DASH_line, int(3695), kw_end_DASH_column, int(40), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core_system_DASH_newline = ns.InternWithValue(tmp0, "\n", true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_system_DASH_newline.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // tagged-literal + { + tmp0 := sym_tagged_DASH_literal.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_tag, sym_form)), kw_doc, "Construct a data representation of a tagged literal from a\n tag symbol and a form.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(7769), kw_end_DASH_line, int(7769))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := lang.Apply(nil, []any{v2, v3}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_tagged_DASH_literal = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_tagged_DASH_literal.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // tagged-literal? + { + tmp0 := sym_tagged_DASH_literal_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_value)), kw_doc, "Return true if the value is the data representation of a tagged literal", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(7763), kw_end_DASH_line, int(7763))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := lang.Apply(tmp3, []any{nil, v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_tagged_DASH_literal_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_tagged_DASH_literal_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // take-while + { + tmp0 := sym_take_DASH_while.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred), lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns a lazy sequence of successive items from coll while\n (pred item) returns logical true. pred must be free of side-effects.\n Returns a transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(2880), kw_end_DASH_line, int(2880))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp6 := lang.Apply(v4, nil) + return tmp6 + case 1: + v6 := args[0] + _ = v6 + tmp7 := lang.Apply(v4, []any{v6}) + return tmp7 + case 2: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + var tmp8 any + tmp9 := lang.Apply(v2, []any{v7}) + if lang.IsTruthy(tmp9) { + tmp10 := lang.Apply(v4, []any{v6, v7}) + tmp8 = tmp10 + } else { + tmp11 := checkDerefVar(var_glojure_DOT_core_reduced) + tmp12 := lang.Apply(tmp11, []any{v6}) + tmp8 = tmp12 + } + return tmp8 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2888), kw_column, int(8), kw_end_DASH_line, int(2894), kw_end_DASH_column, int(33)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp7 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2887), kw_column, int(6), kw_end_DASH_line, int(2894), kw_end_DASH_column, int(34)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp5 any + { // let + // let binding "temp__0__auto__" + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := lang.Apply(tmp6, []any{v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + var tmp10 any + { // let + // let binding "s" + var v11 any = v8 + _ = v11 + var tmp12 any + tmp13 := checkDerefVar(var_glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v11}) + tmp15 := lang.Apply(v2, []any{tmp14}) + if lang.IsTruthy(tmp15) { + tmp16 := checkDerefVar(var_glojure_DOT_core_cons) + tmp17 := checkDerefVar(var_glojure_DOT_core_first) + tmp18 := lang.Apply(tmp17, []any{v11}) + tmp19 := checkDerefVar(var_glojure_DOT_core_take_DASH_while) + tmp20 := checkDerefVar(var_glojure_DOT_core_rest) + tmp21 := lang.Apply(tmp20, []any{v11}) + tmp22 := lang.Apply(tmp19, []any{v2, tmp21}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp22}) + tmp12 = tmp23 + } else { + } + tmp10 = tmp12 + } // end let + tmp9 = tmp10 + } else { + } + tmp5 = tmp9 + } // end let + return tmp5 + }) + tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_take_DASH_while = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_take_DASH_while.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // tapset + { + tmp0 := sym_tapset.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(7882), kw_column, int(10), kw_end_DASH_line, int(7882), kw_end_DASH_column, int(25), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + tmp1 := lang.NewAtom(lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{}))) + var_glojure_DOT_core_tapset = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_tapset.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // test + { + tmp0 := sym_test.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_v)), kw_doc, "test [v] finds fn at key :test in var metadata and calls it,\n presuming failure will throw exception", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(4853), kw_end_DASH_line, int(4853))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "f" + tmp4 := checkDerefVar(var_glojure_DOT_core_meta) + tmp5 := lang.Apply(tmp4, []any{v2}) + tmp6 := lang.Apply(kw_test, []any{tmp5}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + if lang.IsTruthy(v7) { + tmp9 := lang.Apply(v7, nil) + _ = tmp9 + tmp8 = kw_ok + } else { + tmp8 = kw_no_DASH_test + } + tmp3 = tmp8 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_test = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_test.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // the-ns + { + tmp0 := sym_the_DASH_ns.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "If passed a namespace, returns it. Else, when passed a symbol,\n returns the namespace named by it, throwing an exception if not\n found.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(4152), kw_end_DASH_line, int(4152))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := reflect.TypeOf((*lang.Namespace)(nil)) + tmp6 := lang.Apply(tmp4, []any{tmp5, v2}) + if lang.IsTruthy(tmp6) { + tmp3 = v2 + } else { + var tmp7 any + { // let + // let binding "or__0__auto__" + tmp8 := checkDerefVar(var_glojure_DOT_core_find_DASH_ns) + tmp9 := lang.Apply(tmp8, []any{v2}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + if lang.IsTruthy(v10) { + tmp11 = v10 + } else { + tmp12 := checkDerefVar(var_glojure_DOT_core_str) + tmp13 := lang.Apply(tmp12, []any{"No namespace: ", v2, " found"}) + tmp14 := lang.Apply(lang.NewError, []any{tmp13}) + panic(tmp14) + } + tmp7 = tmp11 + } // end let + tmp3 = tmp7 + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_the_DASH_ns = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_the_DASH_ns.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // to-array + { + tmp0 := sym_to_DASH_array.WithMeta(lang.NewMap(kw_tag, "[Ljava.lang.Object;", kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns an array of Objects containing the contents of coll, which\n can be any Collection. Maps to java.util.Collection.toArray().", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(337), kw_end_DASH_line, int(337))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(runtime.RT, "ToArray") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ToArray is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, "[Ljava.lang.Object;")).(lang.FnFunc) + var_glojure_DOT_core_to_DASH_array = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_to_DASH_array.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // transient + { + tmp0 := sym_transient.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a new, transient version of the collection, in constant time.\n\n Transients support a parallel set of 'changing' operations, with similar names\n followed by ! - assoc!, conj! etc. These do the same things as their persistent\n counterparts except the return values are themselves transient.\n\n Note in particular that transients are not designed to be bashed in-place. You\n must capture and use the return value in the next call. In this way, they support\n the same code structure as the functional persistent code they replace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(3335), kw_end_DASH_line, int(3335))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "AsTransient") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "AsTransient"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_transient = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_transient.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // true? + { + tmp1 := reflect.TypeOf(false) + tmp0 := sym_true_QMARK_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x is the value true, false otherwise.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(511), kw_end_DASH_line, int(511))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.Identical, []any{v3, true}) + return tmp4 + }) + tmp3 := reflect.TypeOf(false) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_true_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_true_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unquote + { + tmp0 := sym_unquote.WithMeta(lang.NewMap()).(*lang.Symbol) + var_glojure_DOT_core_unquote = ns.Intern(tmp0) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unquote.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unquote-splicing + { + tmp0 := sym_unquote_DASH_splicing.WithMeta(lang.NewMap()).(*lang.Symbol) + var_glojure_DOT_core_unquote_DASH_splicing = ns.Intern(tmp0) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unquote_DASH_splicing.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // uri? + { + tmp0 := sym_uri_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a java.net.URI", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(7877), kw_end_DASH_line, int(7877))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*url14.URL)(nil)).Elem() + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_uri_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_uri_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // uuid? + { + tmp0 := sym_uuid_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a java.util.UUID", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(6847), kw_end_DASH_line, int(6847))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf([16]uint8{}) + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_uuid_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_uuid_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // val + { + tmp0 := sym_val.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_e)), kw_doc, "Returns the value in the map entry.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(1570), kw_end_DASH_line, int(1570))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(v2, "GetValue") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("GetValue is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_val = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_val.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // vals + { + tmp0 := sym_vals.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_map)), kw_doc, "Returns a sequence of the map's values, in the same order as (seq map).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1557), kw_end_DASH_line, int(1557))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(lang.Vals, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_vals = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_vals.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // var-get + { + tmp0 := sym_var_DASH_get.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Gets the value in the var object", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4326), kw_end_DASH_line, int(4326))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(v2, "Get") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Get is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_var_DASH_get = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_var_DASH_get.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // var-set + { + tmp0 := sym_var_DASH_set.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_val)), kw_doc, "Sets the value in the var object to val. The var must be\n thread-locally bound.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4332), kw_end_DASH_line, int(4332))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "Set") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Set is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_var_DASH_set = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_var_DASH_set.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // var? + { + tmp0 := sym_var_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_v)), kw_doc, "Returns true if v is of type glojure.lang.Var", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(4999), kw_end_DASH_line, int(4999))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*lang.Var)(nil)) + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_var_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_var_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // vector + { + tmp0 := sym_vector.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_a), lang.NewVector(sym_a, sym_b), lang.NewVector(sym_a, sym_b, sym_c), lang.NewVector(sym_a, sym_b, sym_c, sym_d), lang.NewVector(sym_a, sym_b, sym_c, sym_d, sym_e), lang.NewVector(sym_a, sym_b, sym_c, sym_d, sym_e, sym_f), lang.NewVector(sym_a, sym_b, sym_c, sym_d, sym_e, sym_f, sym__AMP_, sym_args)), kw_doc, "Creates a new vector containing the args.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(352), kw_end_DASH_line, int(352))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp2 := lang.NewVector() + tmp3 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(356), kw_column, int(7), kw_end_DASH_line, int(356), kw_end_DASH_column, int(8)) + tmp4, err := lang.WithMeta(tmp2, tmp3.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp4 + case 1: + v2 := args[0] + _ = v2 + tmp3 := lang.NewVector(v2) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(357), kw_column, int(8), kw_end_DASH_line, int(357), kw_end_DASH_column, int(10)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := lang.NewVector(v2, v3) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(358), kw_column, int(10), kw_end_DASH_line, int(358), kw_end_DASH_column, int(14)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := lang.NewVector(v2, v3, v4) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(359), kw_column, int(12), kw_end_DASH_line, int(359), kw_end_DASH_column, int(18)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp7 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + tmp6 := lang.NewVector(v2, v3, v4, v5) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(360), kw_column, int(14), kw_end_DASH_line, int(360), kw_end_DASH_column, int(22)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp8 + case 5: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + tmp7 := lang.NewVector(v2, v3, v4, v5, v6) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(361), kw_column, int(15), kw_end_DASH_line, int(361), kw_end_DASH_column, int(25)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp9 + case 6: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + v7 := args[5] + _ = v7 + tmp8 := lang.NewVector(v2, v3, v4, v5, v6, v7) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(362), kw_column, int(17), kw_end_DASH_line, int(362), kw_end_DASH_column, int(29)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp10 + default: + checkArity(args, 6) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + v7 := args[5] + _ = v7 + var v8 any = lang.NewList(args[6:]...) + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_cons) + tmp10 := checkDerefVar(var_glojure_DOT_core_cons) + tmp11 := checkDerefVar(var_glojure_DOT_core_cons) + tmp12 := checkDerefVar(var_glojure_DOT_core_cons) + tmp13 := checkDerefVar(var_glojure_DOT_core_cons) + tmp14 := checkDerefVar(var_glojure_DOT_core_cons) + tmp15 := lang.Apply(tmp14, []any{v7, v8}) + tmp16 := lang.Apply(tmp13, []any{v6, tmp15}) + tmp17 := lang.Apply(tmp12, []any{v5, tmp16}) + tmp18 := lang.Apply(tmp11, []any{v4, tmp17}) + tmp19 := lang.Apply(tmp10, []any{v3, tmp18}) + tmp20 := lang.Apply(tmp9, []any{v2, tmp19}) + tmp21 := lang.Apply(lang.CreateLazilyPersistentVector, []any{tmp20}) + return tmp21 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_vector = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_vector.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // vector? + { + tmp0 := sym_vector_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x implements IPersistentVector", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(2), kw_line, int(174), kw_end_DASH_line, int(178))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function vector? + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := reflect.TypeOf((*lang.IPersistentVector)(nil)).Elem() + tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(178), kw_column, int(10), kw_end_DASH_line, int(178), kw_end_DASH_column, int(106))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_vector_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_vector_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // volatile! + { + tmp1 := reflect.TypeOf((*lang.Volatile)(nil)).Elem() + tmp0 := sym_volatile_BANG_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_val)), kw_doc, "Creates and returns a Volatile with an initial value of val.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(2517), kw_end_DASH_line, int(2517))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.NewVolatile, []any{v3}) + return tmp4 + }) + tmp3 := reflect.TypeOf((*lang.Volatile)(nil)).Elem() + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_volatile_BANG_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_volatile_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // volatile? + { + tmp0 := sym_volatile_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x is a volatile.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(2540), kw_end_DASH_line, int(2540))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*lang.Volatile)(nil)).Elem() + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_volatile_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_volatile_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // vreset! + { + tmp0 := sym_vreset_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_vol, sym_newval)), kw_doc, "Sets the value of volatile to newval without regard for the\n current value. Returns newval.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(2524), kw_end_DASH_line, int(2524))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "reset") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_vreset_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_vreset_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // when + { + tmp0 := sym_when.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_test, sym__AMP_, sym_body)), kw_doc, "Evaluates test. If logical true, evaluates body in an implicit do.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(11), kw_line, int(492), kw_end_DASH_line, int(492))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := checkDerefVar(var_glojure_DOT_core_cons) + tmp8 := lang.Apply(tmp7, []any{sym_do, v5}) + tmp9 := lang.Apply(tmp6, []any{sym_if, v4, tmp8}) + return tmp9 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_when = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_when.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // when-not + { + tmp0 := sym_when_DASH_not.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_test, sym__AMP_, sym_body)), kw_doc, "Evaluates test. If logical false, evaluates body in an implicit do.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(11), kw_line, int(498), kw_end_DASH_line, int(498))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := checkDerefVar(var_glojure_DOT_core_cons) + tmp8 := lang.Apply(tmp7, []any{sym_do, v5}) + tmp9 := lang.Apply(tmp6, []any{sym_if, v4, nil, tmp8}) + return tmp9 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_when_DASH_not = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_when_DASH_not.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // with-meta + { + tmp0 := sym_with_DASH_meta.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_obj, sym_m)), kw_doc, "Returns an object of the same type and value as obj, with\n map m as its metadata.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(2), kw_line, int(211), kw_end_DASH_line, int(216))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function with-meta + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(v3, "WithMeta") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("WithMeta is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(216), kw_column, int(12), kw_end_DASH_line, int(217), kw_end_DASH_column, int(32))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_with_DASH_meta = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_with_DASH_meta.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + var closed17 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + recur_loop_2021: + var tmp3 any + { // let + // let binding "temp__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + var tmp8 any + { // let + // let binding "s" + var v9 any = v6 + _ = v9 + var tmp10 any + { // let + // let binding "or__0__auto__" + tmp11 := checkDerefVar(var_glojure_DOT_core_first) + tmp12 := lang.Apply(tmp11, []any{v9}) + tmp13 := lang.Apply(v1, []any{tmp12}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + tmp15 = v14 + } else { + var tmp16 any = v1 + tmp18 := checkDerefVar(var_glojure_DOT_core_next) + tmp19 := lang.Apply(tmp18, []any{v9}) + var tmp17 any = tmp19 + v1 = tmp16 + v2 = tmp17 + goto recur_loop_2021 + } + tmp10 = tmp15 + } // end let + tmp8 = tmp10 + } // end let + tmp7 = tmp8 + } else { + } + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp0 = tmp0.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + closed17 = tmp0 + } + var closed18 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + recur_loop_2020: + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := lang.Apply(tmp5, []any{v2}) + tmp7 := lang.Apply(tmp4, []any{tmp6}) + if lang.IsTruthy(tmp7) { + tmp3 = true + } else { + var tmp8 any + tmp9 := checkDerefVar(var_glojure_DOT_core_first) + tmp10 := lang.Apply(tmp9, []any{v2}) + tmp11 := lang.Apply(v1, []any{tmp10}) + if lang.IsTruthy(tmp11) { + var tmp12 any = v1 + tmp14 := checkDerefVar(var_glojure_DOT_core_next) + tmp15 := lang.Apply(tmp14, []any{v2}) + var tmp13 any = tmp15 + v1 = tmp12 + v2 = tmp13 + goto recur_loop_2020 + } else { + var tmp16 any + if lang.IsTruthy(kw_else) { + tmp16 = false + } else { + } + tmp8 = tmp16 + } + tmp3 = tmp8 + } + return tmp3 + }) + tmp1 := reflect.TypeOf(false) + tmp0 = tmp0.WithMeta(lang.NewMap(kw_rettag, tmp1)).(lang.FnFunc) + closed18 = tmp0 + } + // agent-errors + { + tmp0 := sym_agent_DASH_errors.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a)), kw_doc, "DEPRECATED: Use 'agent-error' instead.\n Returns a sequence of the exceptions thrown during asynchronous\n actions of the agent.", kw_file, "glojure/core.glj", kw_deprecated, "1.2", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(2234), kw_end_DASH_line, int(2234))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "temp__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_agent_DASH_error) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + var tmp8 any + { // let + // let binding "e" + var v9 any = v6 + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{v9}) + tmp8 = tmp11 + } // end let + tmp7 = tmp8 + } else { + } + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_agent_DASH_errors = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_agent_DASH_errors.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // alias + { + tmp0 := sym_alias.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_alias, sym_namespace_DASH_sym)), kw_doc, "Add an alias in the current namespace to another\n namespace. Arguments are two symbols: the alias to be used, and\n the symbolic name of the target namespace. Use :as in the ns macro in preference\n to calling this directly.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(4263), kw_end_DASH_line, int(4263))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp5 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) + tmp6 := lang.Apply(tmp5, []any{v3}) + tmp7, _ := lang.FieldOrMethod(tmp4, "AddAlias") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("AddAlias is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v2, tmp6}) + return tmp8 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_alias = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_alias.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // assoc + { + tmp0 := sym_assoc.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_map, sym_key, sym_val), lang.NewVector(sym_map, sym_key, sym_val, sym__AMP_, sym_kvs)), kw_doc, "assoc[iate]. When applied to a map, returns a new map of the\n same (hashed/sorted) type, that contains the mapping of key(s) to\n val(s). When applied to a vector, returns a new vector that\n contains val at index. Note - index must be <= (count vector).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(6), kw_column, int(2), kw_line, int(181), kw_end_DASH_line, int(188))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function assoc + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6 := lang.Apply(lang.Assoc, []any{v3, v4, v5}) + return tmp6 + default: + checkArity(args, 3) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + recur_loop_1564: + var tmp7 any + { // let + // let binding "ret" + tmp8 := lang.Apply(lang.Assoc, []any{v3, v4, v5}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v6) { + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core_next) + tmp13 := lang.Apply(tmp12, []any{v6}) + if lang.IsTruthy(tmp13) { + var tmp14 any = v9 + tmp16 := checkDerefVar(var_glojure_DOT_core_first) + tmp17 := lang.Apply(tmp16, []any{v6}) + var tmp15 any = tmp17 + tmp19 := checkDerefVar(var_glojure_DOT_core_second) + tmp20 := lang.Apply(tmp19, []any{v6}) + var tmp18 any = tmp20 + tmp22 := checkDerefVar(var_glojure_DOT_core_nnext) + tmp23 := lang.Apply(tmp22, []any{v6}) + var tmp21 any = tmp23 + v3 = tmp14 + v4 = tmp15 + v5 = tmp18 + v6 = tmp21 + goto recur_loop_1564 + } else { + tmp24 := lang.Apply(lang.NewIllegalArgumentError, []any{"assoc expects even number of arguments after map/vector, found odd number"}) + panic(tmp24) + } + tmp10 = tmp11 + } else { + tmp10 = v9 + } + tmp7 = tmp10 + } // end let + return tmp7 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(189), kw_column, int(2), kw_end_DASH_line, int(198), kw_end_DASH_column, int(15))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_assoc = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_assoc.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // assoc! + { + tmp0 := sym_assoc_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll, sym_key, sym_val), lang.NewVector(sym_coll, sym_key, sym_val, sym__AMP_, sym_kvs)), kw_doc, "When applied to a transient map, adds mapping of key(s) to\n val(s). When applied to a transient vector, sets the val at index.\n Note - index must be <= (count vector). Returns coll.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(3369), kw_end_DASH_line, int(3369))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5, _ := lang.FieldOrMethod(v2, "Assoc") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Assoc is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + recur_loop_2149: + var tmp6 any + { // let + // let binding "ret" + tmp7, _ := lang.FieldOrMethod(v2, "Assoc") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Assoc is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v3, v4}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v5) { + var tmp11 any = v9 + tmp13 := checkDerefVar(var_glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v5}) + var tmp12 any = tmp14 + tmp16 := checkDerefVar(var_glojure_DOT_core_second) + tmp17 := lang.Apply(tmp16, []any{v5}) + var tmp15 any = tmp17 + tmp19 := checkDerefVar(var_glojure_DOT_core_nnext) + tmp20 := lang.Apply(tmp19, []any{v5}) + var tmp18 any = tmp20 + v2 = tmp11 + v3 = tmp12 + v4 = tmp15 + v5 = tmp18 + goto recur_loop_2149 + } else { + tmp10 = v9 + } + tmp6 = tmp10 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_assoc_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_assoc_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // associative? + { + tmp0 := sym_associative_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns true if coll implements Associative", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(6223), kw_end_DASH_line, int(6223))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := lang.Apply(tmp3, []any{nil, v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_associative_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_associative_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bases + { + tmp0 := sym_bases.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_c)), kw_doc, "Returns the immediate superclass and direct interfaces of c, if any", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(5522), kw_end_DASH_line, int(5522))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + if lang.IsTruthy(v2) { + var tmp4 any + { // let + // let binding "i" + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := lang.Apply(tmp5, []any{nil}) + var v7 any = tmp6 + _ = v7 + // let binding "s" + var v8 any = nil + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + tmp10 := checkDerefVar(var_glojure_DOT_core_cons) + tmp11 := lang.Apply(tmp10, []any{v8, v7}) + tmp9 = tmp11 + } else { + tmp9 = v7 + } + tmp4 = tmp9 + } // end let + tmp3 = tmp4 + } else { + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bases = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bases.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // boolean? + { + tmp0 := sym_boolean_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a Boolean", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(518), kw_end_DASH_line, int(518))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := lang.Apply(tmp3, []any{lang.Builtins["bool"], v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_boolean_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_boolean_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // char? + { + tmp0 := sym_char_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a Character", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(6), kw_column, int(2), kw_line, int(153), kw_end_DASH_line, int(157))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function char? + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := reflect.TypeOf(int32(0)) + tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(157), kw_column, int(8), kw_end_DASH_line, int(157), kw_end_DASH_column, int(89))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_char_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_char_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // chunked-seq? + { + tmp0 := sym_chunked_DASH_seq_QMARK_.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(708), kw_column, int(7), kw_end_DASH_line, int(708), kw_end_DASH_column, int(27), kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*lang.IChunkedSeq)(nil)).Elem() + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_chunked_DASH_seq_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_chunked_DASH_seq_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // class + { + tmp0 := sym_class.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns the Class of x", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3461), kw_end_DASH_line, int(3461))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + tmp3 = v2 + } else { + tmp6 := lang.Apply(lang.TypeOf, []any{v2}) + tmp3 = tmp6 + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_class = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_class.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // class? + { + tmp0 := sym_class_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x is an instance of Class", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(5465), kw_end_DASH_line, int(5465))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*reflect.Type)(nil)).Elem() + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_class_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_class_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // coll? + { + tmp0 := sym_coll_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x implements IPersistentCollection", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(6192), kw_end_DASH_line, int(6192))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*lang.IPersistentCollection)(nil)).Elem() + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_coll_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_coll_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // completing + { + tmp0 := sym_completing.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_cf)), kw_doc, "Takes a reducing function f of 2 args and returns a fn suitable for\n transduce by adding an arity-1 signature that calls cf (default -\n identity) on the result argument.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(6893), kw_end_DASH_line, int(6893))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_completing) + tmp4 := checkDerefVar(var_glojure_DOT_core_identity) + tmp5 := lang.Apply(tmp3, []any{v2, tmp4}) + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp5 := lang.Apply(v2, nil) + return tmp5 + case 1: + v5 := args[0] + _ = v5 + tmp6 := lang.Apply(v3, []any{v5}) + return tmp6 + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + tmp7 := lang.Apply(v2, []any{v5, v6}) + return tmp7 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6900), kw_column, int(6), kw_end_DASH_line, int(6903), kw_end_DASH_column, int(23)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_completing = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_completing.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // concat + { + tmp0 := sym_concat.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_zs)), kw_doc, "Returns a lazy seq representing the concatenation of the elements in the supplied colls.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(711), kw_end_DASH_line, int(711))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + return nil + }) + tmp3 := lang.Apply(lang.NewLazySeq, []any{tmp2}) + return tmp3 + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + return v2 + }) + tmp4 := lang.Apply(lang.NewLazySeq, []any{tmp3}) + return tmp4 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp5 any + { // let + // let binding "s" + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := lang.Apply(tmp6, []any{v2}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + var tmp10 any + tmp11 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp12 := lang.Apply(tmp11, []any{v8}) + if lang.IsTruthy(tmp12) { + tmp13 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_cons) + tmp14 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp15 := lang.Apply(tmp14, []any{v8}) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp18 := lang.Apply(tmp17, []any{v8}) + tmp19 := lang.Apply(tmp16, []any{tmp18, v3}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp19}) + tmp10 = tmp20 + } else { + tmp21 := checkDerefVar(var_glojure_DOT_core_cons) + tmp22 := checkDerefVar(var_glojure_DOT_core_first) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_concat) + tmp25 := checkDerefVar(var_glojure_DOT_core_rest) + tmp26 := lang.Apply(tmp25, []any{v8}) + tmp27 := lang.Apply(tmp24, []any{tmp26, v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp27}) + tmp10 = tmp28 + } + tmp9 = tmp10 + } else { + tmp9 = v3 + } + tmp5 = tmp9 + } // end let + return tmp5 + }) + tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) + return tmp5 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "cat" + var tmp6 lang.FnFunc + { // function cat + var v7 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp11 any + { // let + // let binding "xys" + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := lang.Apply(tmp12, []any{v8}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + var tmp16 any + tmp17 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp18 := lang.Apply(tmp17, []any{v14}) + if lang.IsTruthy(tmp18) { + tmp19 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_cons) + tmp20 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp21 := lang.Apply(tmp20, []any{v14}) + tmp22 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp23 := lang.Apply(tmp22, []any{v14}) + tmp24 := lang.Apply(v7, []any{tmp23, v9}) + tmp25 := lang.Apply(tmp19, []any{tmp21, tmp24}) + tmp16 = tmp25 + } else { + tmp26 := checkDerefVar(var_glojure_DOT_core_cons) + tmp27 := checkDerefVar(var_glojure_DOT_core_first) + tmp28 := lang.Apply(tmp27, []any{v14}) + tmp29 := checkDerefVar(var_glojure_DOT_core_rest) + tmp30 := lang.Apply(tmp29, []any{v14}) + tmp31 := lang.Apply(v7, []any{tmp30, v9}) + tmp32 := lang.Apply(tmp26, []any{tmp28, tmp31}) + tmp16 = tmp32 + } + tmp15 = tmp16 + } else { + var tmp33 any + if lang.IsTruthy(v9) { + tmp34 := checkDerefVar(var_glojure_DOT_core_first) + tmp35 := lang.Apply(tmp34, []any{v9}) + tmp36 := checkDerefVar(var_glojure_DOT_core_next) + tmp37 := lang.Apply(tmp36, []any{v9}) + tmp38 := lang.Apply(v7, []any{tmp35, tmp37}) + tmp33 = tmp38 + } else { + } + tmp15 = tmp33 + } + tmp11 = tmp15 + } // end let + return tmp11 + }) + tmp11 := lang.Apply(lang.NewLazySeq, []any{tmp10}) + return tmp11 + }) + v7 = tmp6 + _ = v7 + } + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(726), kw_column, int(16), kw_end_DASH_line, int(735), kw_end_DASH_column, int(56)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v9 any = tmp8 + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_concat) + tmp11 := lang.Apply(tmp10, []any{v2, v3}) + tmp12 := lang.Apply(v9, []any{tmp11, v4}) + tmp5 = tmp12 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_concat = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_concat.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // cond + { + tmp0 := sym_cond.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_clauses)), kw_doc, "Takes a set of test/expr pairs. It evaluates each test one at a\n time. If a test returns logical true, cond evaluates and returns\n the value of the corresponding expr and doesn't evaluate any of the\n other tests or exprs. (cond) returns nil.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(11), kw_line, int(569), kw_end_DASH_line, int(569))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + if lang.IsTruthy(v4) { + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := checkDerefVar(var_glojure_DOT_core_first) + tmp8 := lang.Apply(tmp7, []any{v4}) + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_next) + tmp11 := lang.Apply(tmp10, []any{v4}) + if lang.IsTruthy(tmp11) { + tmp12 := checkDerefVar(var_glojure_DOT_core_second) + tmp13 := lang.Apply(tmp12, []any{v4}) + tmp9 = tmp13 + } else { + tmp14 := lang.Apply(lang.NewIllegalArgumentError, []any{"cond requires an even number of forms"}) + panic(tmp14) + } + tmp15 := checkDerefVar(var_glojure_DOT_core_cons) + tmp16 := checkDerefVar(var_glojure_DOT_core_next) + tmp17 := checkDerefVar(var_glojure_DOT_core_next) + tmp18 := lang.Apply(tmp17, []any{v4}) + tmp19 := lang.Apply(tmp16, []any{tmp18}) + tmp20 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_cond, tmp19}) + tmp21 := lang.Apply(tmp6, []any{sym_if, tmp8, tmp9, tmp20}) + tmp5 = tmp21 + } else { + } + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_cond = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_cond.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // conj + { + tmp0 := sym_conj.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_coll), lang.NewVector(sym_coll, sym_x), lang.NewVector(sym_coll, sym_x, sym__AMP_, sym_xs)), kw_doc, "conj[oin]. Returns a new collection with the xs\n 'added'. (conj nil item) returns (item).\n (conj coll) returns coll. (conj) returns [].\n The 'addition' may happen at different 'places' depending\n on the concrete type.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(5), kw_column, int(2), kw_line, int(73), kw_end_DASH_line, int(81))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function conj + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp3 := lang.NewVector() + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(82), kw_column, int(13), kw_end_DASH_line, int(82), kw_end_DASH_column, int(14)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 1: + v3 := args[0] + _ = v3 + return v3 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(lang.Conj, []any{v3, v4}) + return tmp5 + default: + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + recur_loop_1550: + var tmp6 any + if lang.IsTruthy(v5) { + tmp8 := lang.Apply(lang.Conj, []any{v3, v4}) + var tmp7 any = tmp8 + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v5}) + var tmp9 any = tmp11 + tmp13 := checkDerefVar(var_glojure_DOT_core_next) + tmp14 := lang.Apply(tmp13, []any{v5}) + var tmp12 any = tmp14 + v3 = tmp7 + v4 = tmp9 + v5 = tmp12 + goto recur_loop_1550 + } else { + tmp15 := lang.Apply(lang.Conj, []any{v3, v4}) + tmp6 = tmp15 + } + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(81), kw_column, int(7), kw_end_DASH_line, int(88), kw_end_DASH_column, int(67))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_conj = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_conj.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // conj! + { + tmp0 := sym_conj_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_coll), lang.NewVector(sym_coll, sym_x)), kw_doc, "Adds x to the transient collection, and return coll. The 'addition'\n may happen at different 'places' depending on the concrete type.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3359), kw_end_DASH_line, int(3359))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp2 := checkDerefVar(var_glojure_DOT_core_transient) + tmp3 := lang.NewVector() + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3364), kw_column, int(18), kw_end_DASH_line, int(3364), kw_end_DASH_column, int(19)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp6 := lang.Apply(tmp2, []any{tmp5}) + return tmp6 + case 1: + v2 := args[0] + _ = v2 + return v2 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "Conj") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Conj is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_conj_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_conj_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // count + { + var tmp1 lang.FnFunc + { // function count__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Count}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_count.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_inline, tmp1, kw_doc, "Returns the number of items in the collection. (count nil) returns\n 0. Also works on strings, arrays, and Java Collections and Maps", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(867), kw_end_DASH_line, int(867))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.Count, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_count = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_count.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // counted? + { + tmp0 := sym_counted_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns true if coll implements count in constant time", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(6241), kw_end_DASH_line, int(6241))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*lang.Counted)(nil)).Elem() + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_counted_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_counted_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // cycle + { + tmp0 := sym_cycle.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a lazy (infinite!) sequence of repetitions of the items in coll.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(2977), kw_end_DASH_line, int(2977))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_seq) + tmp4 := lang.Apply(tmp3, []any{v2}) + tmp5 := lang.Apply(lang.NewCycle, []any{tmp4}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_cycle = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_cycle.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // dec + { + var tmp1 lang.FnFunc + { // function dec__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp15) { + tmp14 = sym_unchecked_dec + } else { + tmp14 = sym_dec + } + tmp16 := lang.Apply(tmp13, []any{tmp14}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := lang.Apply(tmp12, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp11, []any{tmp19}) + tmp21 := lang.Apply(tmp10, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_dec.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns a number one less than num. Does not auto-promote\n longs, will throw on overflow. See also: dec'", kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(1147), kw_end_DASH_line, int(1147))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Dec") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Dec is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_dec = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_dec.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // dec' + { + var tmp1 lang.FnFunc + { // function dec'__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_DecP}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_dec_TICK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns a number one less than num. Supports arbitrary precision.\n See also: dec", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1140), kw_end_DASH_line, int(1140))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "DecP") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("DecP is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_dec_TICK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_dec_TICK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // decimal? + { + tmp0 := sym_decimal_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_doc, "Returns true if n is a BigDecimal", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(3599), kw_end_DASH_line, int(3599))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*lang.BigDecimal)(nil)) + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_decimal_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_decimal_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // defmethod + { + tmp0 := sym_defmethod.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_multifn, sym_dispatch_DASH_val, sym__AMP_, sym_fn_DASH_tail)), kw_doc, "Creates and installs a new method of multimethod associated with dispatch-value. ", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(11), kw_line, int(1781), kw_end_DASH_line, int(1781))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var v6 any = lang.NewList(args[4:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp13 := lang.NewMap(kw_tag, sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT__STAR_MultiFn) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(1785), kw_column, int(27), kw_end_DASH_line, int(1785), kw_end_DASH_column, int(82)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp16 := lang.Apply(tmp12, []any{v4, tmp15}) + tmp17 := lang.Apply(tmp11, []any{tmp16}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{sym_glojure_DOT_core_SLASH_AddMethod}) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{v5}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := checkDerefVar(var_glojure_DOT_core_seq) + tmp24 := checkDerefVar(var_glojure_DOT_core_concat) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := lang.Apply(tmp25, []any{sym_glojure_DOT_core_SLASH_fn}) + tmp27 := lang.Apply(tmp24, []any{tmp26, v6}) + tmp28 := lang.Apply(tmp23, []any{tmp27}) + tmp29 := lang.Apply(tmp22, []any{tmp28}) + tmp30 := lang.Apply(tmp8, []any{tmp10, tmp17, tmp19, tmp21, tmp29}) + tmp31 := lang.Apply(tmp7, []any{tmp30}) + return tmp31 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_defmethod = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_defmethod.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // defstruct + { + tmp0 := sym_defstruct.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym__AMP_, sym_keys)), kw_doc, "Same as (def name (create-struct keys...))", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(11), kw_line, int(4044), kw_end_DASH_line, int(4044))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_def}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{v4}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_create_DASH_struct}) + tmp17 := lang.Apply(tmp14, []any{tmp16, v5}) + tmp18 := lang.Apply(tmp13, []any{tmp17}) + tmp19 := lang.Apply(tmp12, []any{tmp18}) + tmp20 := lang.Apply(tmp7, []any{tmp9, tmp11, tmp19}) + tmp21 := lang.Apply(tmp6, []any{tmp20}) + return tmp21 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_defstruct = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_defstruct.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // delay? + { + tmp0 := sym_delay_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "returns true if x is a Delay created with delay", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(748), kw_end_DASH_line, int(748))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := lang.Apply(tmp3, []any{nil, v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_delay_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_delay_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // deref + { + tmp0 := sym_deref.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ref), lang.NewVector(sym_ref, sym_timeout_DASH_ms, sym_timeout_DASH_val)), kw_doc, "Also reader macro: @ref/@agent/@var/@atom/@delay/@future/@promise. Within a transaction,\n returns the in-transaction-value of ref, else returns the\n most-recently-committed value of ref. When applied to a var, agent\n or atom, returns its current state. When applied to a delay, forces\n it if not already forced. When applied to a future, will block if\n computation not complete. When applied to a promise, will block\n until a value is delivered. The variant taking a timeout can be\n used for blocking references (futures and promises), and will return\n timeout-val if the timeout (in milliseconds) is reached before a\n value is available. See also - realized?.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(2304), kw_end_DASH_line, int(2304))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := reflect.TypeOf((*lang.IDeref)(nil)).Elem() + tmp6 := lang.Apply(tmp4, []any{tmp5, v2}) + if lang.IsTruthy(tmp6) { + tmp7, ok := lang.FieldOrMethod(v2, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "Deref"))) + } + var tmp8 any + switch reflect.TypeOf(tmp7).Kind() { + case reflect.Func: + tmp8 = lang.Apply(tmp7, nil) + default: + tmp8 = tmp7 + } + tmp3 = tmp8 + } else { + tmp9 := checkDerefVar(var_glojure_DOT_core_deref_DASH_future) + tmp10 := lang.Apply(tmp9, []any{v2}) + tmp3 = tmp10 + } + return tmp3 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp7 := reflect.TypeOf((*lang.IBlockingDeref)(nil)).Elem() + tmp8 := lang.Apply(tmp6, []any{tmp7, v2}) + if lang.IsTruthy(tmp8) { + tmp9, _ := lang.FieldOrMethod(v2, "DerefWithTimeout") + if reflect.TypeOf(tmp9).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("DerefWithTimeout is not a function"))) + } + tmp10 := lang.Apply(tmp9, []any{v3, v4}) + tmp5 = tmp10 + } else { + tmp11 := checkDerefVar(var_glojure_DOT_core_deref_DASH_future) + tmp12 := lang.Apply(tmp11, []any{v2, v3, v4}) + tmp5 = tmp12 + } + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_deref = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_deref.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // disj + { + tmp0 := sym_disj.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_set), lang.NewVector(sym_set, sym_key), lang.NewVector(sym_set, sym_key, sym__AMP_, sym_ks)), kw_doc, "disj[oin]. Returns a new set of the same (hashed/sorted) type, that\n does not contain key(s).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1514), kw_end_DASH_line, int(1514))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + return v2 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + if lang.IsTruthy(v2) { + tmp5, _ := lang.FieldOrMethod(v2, "Disjoin") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Disjoin is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3}) + tmp4 = tmp6 + } else { + } + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + recur_loop_1844: + var tmp5 any + if lang.IsTruthy(v2) { + var tmp6 any + { // let + // let binding "ret" + tmp7 := checkDerefVar(var_glojure_DOT_core_disj) + tmp8 := lang.Apply(tmp7, []any{v2, v3}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v4) { + var tmp11 any = v9 + tmp13 := checkDerefVar(var_glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v4}) + var tmp12 any = tmp14 + tmp16 := checkDerefVar(var_glojure_DOT_core_next) + tmp17 := lang.Apply(tmp16, []any{v4}) + var tmp15 any = tmp17 + v2 = tmp11 + v3 = tmp12 + v4 = tmp15 + goto recur_loop_1844 + } else { + tmp10 = v9 + } + tmp6 = tmp10 + } // end let + tmp5 = tmp6 + } else { + } + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_disj = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_disj.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // disj! + { + tmp0 := sym_disj_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_set), lang.NewVector(sym_set, sym_key), lang.NewVector(sym_set, sym_key, sym__AMP_, sym_ks)), kw_doc, "disj[oin]. Returns a transient set of the same (hashed/sorted) type, that\n does not contain key(s).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3401), kw_end_DASH_line, int(3401))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + return v2 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "Disjoin") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Disjoin is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + recur_loop_2155: + var tmp5 any + { // let + // let binding "ret" + tmp6, _ := lang.FieldOrMethod(v2, "Disjoin") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Disjoin is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v4) { + var tmp10 any = v8 + tmp12 := checkDerefVar(var_glojure_DOT_core_first) + tmp13 := lang.Apply(tmp12, []any{v4}) + var tmp11 any = tmp13 + tmp15 := checkDerefVar(var_glojure_DOT_core_next) + tmp16 := lang.Apply(tmp15, []any{v4}) + var tmp14 any = tmp16 + v2 = tmp10 + v3 = tmp11 + v4 = tmp14 + goto recur_loop_2155 + } else { + tmp9 = v8 + } + tmp5 = tmp9 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_disj_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_disj_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // dissoc + { + tmp0 := sym_dissoc.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_map), lang.NewVector(sym_map, sym_key), lang.NewVector(sym_map, sym_key, sym__AMP_, sym_ks)), kw_doc, "dissoc[iate]. Returns a new map of the same (hashed/sorted) type,\n that does not contain a mapping for key(s).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(1500), kw_end_DASH_line, int(1500))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + return v2 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(runtime.RT, "Dissoc") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Dissoc is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + return tmp5 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + recur_loop_1841: + var tmp5 any + { // let + // let binding "ret" + tmp6 := checkDerefVar(var_glojure_DOT_core_dissoc) + tmp7 := lang.Apply(tmp6, []any{v2, v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v4) { + var tmp10 any = v8 + tmp12 := checkDerefVar(var_glojure_DOT_core_first) + tmp13 := lang.Apply(tmp12, []any{v4}) + var tmp11 any = tmp13 + tmp15 := checkDerefVar(var_glojure_DOT_core_next) + tmp16 := lang.Apply(tmp15, []any{v4}) + var tmp14 any = tmp16 + v2 = tmp10 + v3 = tmp11 + v4 = tmp14 + goto recur_loop_1841 + } else { + tmp9 = v8 + } + tmp5 = tmp9 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_dissoc = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_dissoc.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // dissoc! + { + tmp0 := sym_dissoc_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_map, sym_key), lang.NewVector(sym_map, sym_key, sym__AMP_, sym_ks)), kw_doc, "Returns a transient map that doesn't contain a mapping for key(s).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(3382), kw_end_DASH_line, int(3382))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "without") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("without is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + recur_loop_2151: + var tmp5 any + { // let + // let binding "ret" + tmp6, _ := lang.FieldOrMethod(v2, "without") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("without is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v4) { + var tmp10 any = v8 + tmp12 := checkDerefVar(var_glojure_DOT_core_first) + tmp13 := lang.Apply(tmp12, []any{v4}) + var tmp11 any = tmp13 + tmp15 := checkDerefVar(var_glojure_DOT_core_next) + tmp16 := lang.Apply(tmp15, []any{v4}) + var tmp14 any = tmp16 + v2 = tmp10 + v3 = tmp11 + v4 = tmp14 + goto recur_loop_2151 + } else { + tmp9 = v8 + } + tmp5 = tmp9 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_dissoc_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_dissoc_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // dosync + { + tmp0 := sym_dosync.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_exprs)), kw_doc, "Runs the exprs (in an implicit do) in a transaction that encompasses\n exprs and any nested calls. Starts a transaction if none is already\n running on this thread. Any uncaught exception will abort the\n transaction and flow out of dosync. The exprs may be run more than\n once, but any effects on Refs will be atomic.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(11), kw_line, int(5100), kw_end_DASH_line, int(5100))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym_glojure_DOT_core_SLASH_sync}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{nil}) + tmp11 := lang.Apply(tmp6, []any{tmp8, tmp10, v4}) + tmp12 := lang.Apply(tmp5, []any{tmp11}) + return tmp12 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_dosync = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_dosync.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // double + { + var tmp1 lang.FnFunc + { // function double__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_DoubleCast}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_double.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to double", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(3493), kw_end_DASH_line, int(3493))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.AsFloat64, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_double = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_double.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // double-array + { + var tmp1 lang.FnFunc + { // function double-array__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_DoubleArray}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_unquote_DASH_splicing}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_glojure_DOT_core_SLASH_args}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + } + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_double_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_size_DASH_or_DASH_seq), lang.NewVector(sym_size, sym_init_DASH_val_DASH_or_DASH_seq)), kw_inline, tmp1, kw_doc, "Creates an array of doubles", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(5341), kw_end_DASH_line, int(5341))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "DoubleArray") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("DoubleArray is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "DoubleArrayInit") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("DoubleArrayInit is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_double_DASH_array = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_double_DASH_array.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // double? + { + tmp0 := sym_double_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a Double", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(1421), kw_end_DASH_line, int(1421))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := lang.Apply(tmp3, []any{lang.Builtins["float64"], v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_double_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_double_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // doubles + { + var tmp1 lang.FnFunc + { // function doubles + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Doubles}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_doubles.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xs)), kw_inline, tmp1, kw_doc, "Casts to double[]", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(12), kw_line, int(5402), kw_end_DASH_line, int(5402))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Doubles") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Doubles is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_doubles = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_doubles.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // drop-while + { + tmp0 := sym_drop_DASH_while.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred), lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns a lazy sequence of the items in coll starting from the\n first item for which (pred item) returns logical false. Returns a\n stateful transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(2950), kw_end_DASH_line, int(2950))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 any + { // let + // let binding "dv" + tmp6 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) + tmp7 := lang.Apply(tmp6, []any{true}) + var v8 any = tmp7 + _ = v8 + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp10 := lang.Apply(v4, nil) + return tmp10 + case 1: + v10 := args[0] + _ = v10 + tmp11 := lang.Apply(v4, []any{v10}) + return tmp11 + case 2: + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + var tmp12 any + { // let + // let binding "drop?" + tmp13 := checkDerefVar(var_glojure_DOT_core_deref) + tmp14 := lang.Apply(tmp13, []any{v8}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + var tmp17 any + { // let + // let binding "and__0__auto__" + var v18 any = v15 + _ = v18 + var tmp19 any + if lang.IsTruthy(v18) { + tmp20 := lang.Apply(v2, []any{v11}) + tmp19 = tmp20 + } else { + tmp19 = v18 + } + tmp17 = tmp19 + } // end let + if lang.IsTruthy(tmp17) { + tmp16 = v10 + } else { + tmp18 := checkDerefVar(var_glojure_DOT_core_vreset_BANG_) + tmp19 := lang.Apply(tmp18, []any{v8, nil}) + _ = tmp19 + tmp20 := lang.Apply(v4, []any{v10, v11}) + tmp16 = tmp20 + } + tmp12 = tmp16 + } // end let + return tmp12 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2959), kw_column, int(10), kw_end_DASH_line, int(2968), kw_end_DASH_column, int(42)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp5 = tmp11 + } // end let + return tmp5 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2957), kw_column, int(6), kw_end_DASH_line, int(2968), kw_end_DASH_column, int(44)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "step" + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + recur_loop_2092: + var tmp8 any + { // let + // let binding "s" + tmp9 := checkDerefVar(var_glojure_DOT_core_seq) + tmp10 := lang.Apply(tmp9, []any{v7}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + var tmp13 any + { // let + // let binding "and__0__auto__" + var v14 any = v11 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + tmp16 := checkDerefVar(var_glojure_DOT_core_first) + tmp17 := lang.Apply(tmp16, []any{v11}) + tmp18 := lang.Apply(v6, []any{tmp17}) + tmp15 = tmp18 + } else { + tmp15 = v14 + } + tmp13 = tmp15 + } // end let + if lang.IsTruthy(tmp13) { + var tmp14 any = v6 + tmp16 := checkDerefVar(var_glojure_DOT_core_rest) + tmp17 := lang.Apply(tmp16, []any{v11}) + var tmp15 any = tmp17 + v6 = tmp14 + v7 = tmp15 + goto recur_loop_2092 + } else { + tmp12 = v11 + } + tmp8 = tmp12 + } // end let + return tmp8 + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2970), kw_column, int(17), kw_end_DASH_line, int(2974), kw_end_DASH_column, int(26)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v8 any = tmp7 + _ = v8 + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp10 := lang.Apply(v8, []any{v2, v3}) + return tmp10 + }) + tmp10 := lang.Apply(lang.NewLazySeq, []any{tmp9}) + tmp4 = tmp10 + } // end let + return tmp4 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_drop_DASH_while = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_drop_DASH_while.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // empty + { + tmp0 := sym_empty.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns an empty collection of the same category as coll, or nil", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(5265), kw_end_DASH_line, int(5265))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := reflect.TypeOf((*lang.IPersistentCollection)(nil)).Elem() + tmp6 := lang.Apply(tmp4, []any{tmp5, v2}) + if lang.IsTruthy(tmp6) { + tmp7, ok := lang.FieldOrMethod(v2, "empty") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "empty"))) + } + var tmp8 any + switch reflect.TypeOf(tmp7).Kind() { + case reflect.Func: + tmp8 = lang.Apply(tmp7, nil) + default: + tmp8 = tmp7 + } + tmp3 = tmp8 + } else { + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_empty = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_empty.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // every? + { + tmp1 := reflect.TypeOf(false) + tmp0 := sym_every_QMARK_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns true if (pred x) is logical true for every x in coll, else\n false.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(2664), kw_end_DASH_line, int(2664))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + recur_loop_2020: + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := lang.Apply(tmp7, []any{v4}) + tmp9 := lang.Apply(tmp6, []any{tmp8}) + if lang.IsTruthy(tmp9) { + tmp5 = true + } else { + var tmp10 any + tmp11 := checkDerefVar(var_glojure_DOT_core_first) + tmp12 := lang.Apply(tmp11, []any{v4}) + tmp13 := lang.Apply(v3, []any{tmp12}) + if lang.IsTruthy(tmp13) { + var tmp14 any = v3 + tmp16 := checkDerefVar(var_glojure_DOT_core_next) + tmp17 := lang.Apply(tmp16, []any{v4}) + var tmp15 any = tmp17 + v3 = tmp14 + v4 = tmp15 + goto recur_loop_2020 + } else { + var tmp18 any + if lang.IsTruthy(kw_else) { + tmp18 = false + } else { + } + tmp10 = tmp18 + } + tmp5 = tmp10 + } + return tmp5 + }) + tmp3 := reflect.TypeOf(false) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_every_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_every_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ex-cause + { + tmp0 := sym_ex_DASH_cause.WithMeta(lang.NewMap(kw_tag, nil, kw_arglists, lang.NewList(lang.NewVector(sym_ex)), kw_doc, "Returns the cause of ex if ex is a Throwable.\n Otherwise returns nil.", kw_file, "glojure/core.glj", kw_added, "1.10", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(4828), kw_end_DASH_line, int(4828))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := lang.Apply(tmp4, []any{lang.Throwable, v2}) + if lang.IsTruthy(tmp5) { + tmp6, ok := lang.FieldOrMethod(v2, "getCause") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getCause"))) + } + var tmp7 any + switch reflect.TypeOf(tmp6).Kind() { + case reflect.Func: + tmp7 = lang.Apply(tmp6, nil) + default: + tmp7 = tmp6 + } + tmp3 = tmp7 + } else { + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ex_DASH_cause = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ex_DASH_cause.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ex-data + { + tmp0 := sym_ex_DASH_data.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ex)), kw_doc, "Returns exception data (a map) if ex is an IExceptionInfo.\n Otherwise returns nil.", kw_file, "glojure/core.glj", kw_added, "1.4", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4812), kw_end_DASH_line, int(4812))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := lang.Apply(tmp4, []any{nil, v2}) + if lang.IsTruthy(tmp5) { + tmp6, ok := lang.FieldOrMethod(v2, "getData") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getData"))) + } + var tmp7 any + switch reflect.TypeOf(tmp6).Kind() { + case reflect.Func: + tmp7 = lang.Apply(tmp6, nil) + default: + tmp7 = tmp6 + } + tmp3 = tmp7 + } else { + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ex_DASH_data = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ex_DASH_data.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ex-message + { + tmp0 := sym_ex_DASH_message.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ex)), kw_doc, "Returns the message attached to ex if ex is a Throwable.\n Otherwise returns nil.", kw_file, "glojure/core.glj", kw_added, "1.10", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4820), kw_end_DASH_line, int(4820))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := lang.Apply(tmp4, []any{lang.Throwable, v2}) + if lang.IsTruthy(tmp5) { + tmp6, ok := lang.FieldOrMethod(v2, "getMessage") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getMessage"))) + } + var tmp7 any + switch reflect.TypeOf(tmp6).Kind() { + case reflect.Func: + tmp7 = lang.Apply(tmp6, nil) + default: + tmp7 = tmp6 + } + tmp3 = tmp7 + } else { + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ex_DASH_message = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ex_DASH_message.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ffirst + { + tmp0 := sym_ffirst.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Same as (first (first x))", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(2), kw_line, int(98), kw_end_DASH_line, int(102))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function ffirst + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_first) + tmp5 := checkDerefVar(var_glojure_DOT_core_first) + tmp6 := lang.Apply(tmp5, []any{v3}) + tmp7 := lang.Apply(tmp4, []any{tmp6}) + return tmp7 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(102), kw_column, int(9), kw_end_DASH_line, int(102), kw_end_DASH_column, int(50))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_ffirst = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ffirst.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // filter-key + { + tmp0 := sym_filter_DASH_key.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_keyfn, sym_pred, sym_amap)), kw_static, true, kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(4115), kw_end_DASH_line, int(4117), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + { // let + // let binding "ret" + tmp6 := lang.NewMap() + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4118), kw_column, int(16), kw_end_DASH_line, int(4118), kw_end_DASH_column, int(17)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v9 any = tmp8 + _ = v9 + // let binding "es" + tmp10 := checkDerefVar(var_glojure_DOT_core_seq) + tmp11 := lang.Apply(tmp10, []any{v4}) + var v12 any = tmp11 + _ = v12 + for { + var tmp13 any + if lang.IsTruthy(v12) { + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core_first) + tmp16 := lang.Apply(tmp15, []any{v12}) + tmp17 := lang.Apply(v2, []any{tmp16}) + tmp18 := lang.Apply(v3, []any{tmp17}) + if lang.IsTruthy(tmp18) { + tmp20 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp21 := checkDerefVar(var_glojure_DOT_core_key) + tmp22 := checkDerefVar(var_glojure_DOT_core_first) + tmp23 := lang.Apply(tmp22, []any{v12}) + tmp24 := lang.Apply(tmp21, []any{tmp23}) + tmp25 := checkDerefVar(var_glojure_DOT_core_val) + tmp26 := checkDerefVar(var_glojure_DOT_core_first) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp25, []any{tmp27}) + tmp29 := lang.Apply(tmp20, []any{v9, tmp24, tmp28}) + var tmp19 any = tmp29 + tmp31 := checkDerefVar(var_glojure_DOT_core_next) + tmp32 := lang.Apply(tmp31, []any{v12}) + var tmp30 any = tmp32 + v9 = tmp19 + v12 = tmp30 + continue + } else { + var tmp33 any = v9 + tmp35 := checkDerefVar(var_glojure_DOT_core_next) + tmp36 := lang.Apply(tmp35, []any{v12}) + var tmp34 any = tmp36 + v9 = tmp33 + v12 = tmp34 + continue + } + tmp13 = tmp14 + } else { + tmp13 = v9 + } + tmp5 = tmp13 + break + } + } // end let + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_filter_DASH_key = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_filter_DASH_key.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // find-keyword + { + tmp1 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() + tmp0 := sym_find_DASH_keyword.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_name), lang.NewVector(sym_ns, sym_name)), kw_doc, "Returns a Keyword with the given namespace and name if one already\n exists. This function will not intern a new keyword. If the keyword\n has not already been interned, it will return nil. Do not use :\n in the keyword strings, it will be added automatically.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(618), kw_end_DASH_line, int(618))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + tmp4 = v3 + } else { + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp9 := lang.Apply(tmp8, []any{v3}) + if lang.IsTruthy(tmp9) { + tmp10 := lang.Apply(nil, []any{v3}) + tmp7 = tmp10 + } else { + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp13 := lang.Apply(tmp12, []any{v3}) + if lang.IsTruthy(tmp13) { + tmp14 := lang.Apply(nil, []any{v3}) + tmp11 = tmp14 + } else { + } + tmp7 = tmp11 + } + tmp4 = tmp7 + } + return tmp4 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(nil, []any{v3, v4}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp3 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_find_DASH_keyword = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_find_DASH_keyword.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // float + { + var tmp1 lang.FnFunc + { // function float__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp15) { + tmp14 = sym_uncheckedFloatCast + } else { + tmp14 = sym_floatCast + } + tmp16 := lang.Apply(tmp13, []any{tmp14}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := lang.Apply(tmp12, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp11, []any{tmp19}) + tmp21 := lang.Apply(tmp10, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_float.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to float", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3487), kw_end_DASH_line, int(3487))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.FloatCast, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_float = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_float.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // float-array + { + var tmp1 lang.FnFunc + { // function float-array__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_FloatArray}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_unquote_DASH_splicing}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_glojure_DOT_core_SLASH_args}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + } + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_float_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_size_DASH_or_DASH_seq), lang.NewVector(sym_size, sym_init_DASH_val_DASH_or_DASH_seq)), kw_inline, tmp1, kw_doc, "Creates an array of floats", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(5301), kw_end_DASH_line, int(5301))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "FloatArray") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("FloatArray is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "FloatArrayInit") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("FloatArrayInit is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_float_DASH_array = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_float_DASH_array.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // float? + { + tmp0 := sym_float_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_doc, "Returns true if n is a floating point number", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(3605), kw_end_DASH_line, int(3605))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "or__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := lang.Apply(tmp4, []any{lang.Builtins["float64"], v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + tmp7 = v6 + } else { + tmp8 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp9 := lang.Apply(tmp8, []any{lang.Builtins["float32"], v2}) + tmp7 = tmp9 + } + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_float_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_float_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // floats + { + var tmp1 lang.FnFunc + { // function floats + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Floats}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_floats.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xs)), kw_inline, tmp1, kw_doc, "Casts to float[]", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(12), kw_line, int(5392), kw_end_DASH_line, int(5392))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Floats") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Floats is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_floats = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_floats.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // fn? + { + tmp0 := sym_fn_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x implements Fn, i.e. is an object created via fn.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(6216), kw_end_DASH_line, int(6216))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*runtime.Fn)(nil)) + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_fn_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_fn_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // fnext + { + tmp0 := sym_fnext.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Same as (first (next x))", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(6), kw_column, int(2), kw_line, int(112), kw_end_DASH_line, int(116))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function fnext + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_first) + tmp5 := checkDerefVar(var_glojure_DOT_core_next) + tmp6 := lang.Apply(tmp5, []any{v3}) + tmp7 := lang.Apply(tmp4, []any{tmp6}) + return tmp7 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(116), kw_column, int(8), kw_end_DASH_line, int(116), kw_end_DASH_column, int(47))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_fnext = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_fnext.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // future? + { + tmp0 := sym_future_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x is a future", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(6532), kw_end_DASH_line, int(6532))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := lang.Apply(tmp3, []any{nil, v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_future_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_future_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // gensym + { + tmp0 := sym_gensym.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_prefix_DASH_string)), kw_doc, "Returns a new symbol with a unique name. If a prefix string is\n supplied, the name is prefix# where # is some unique number. If\n prefix is not supplied, the prefix is 'G__'.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(599), kw_end_DASH_line, int(599))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp2 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp3 := lang.Apply(tmp2, []any{"G__"}) + return tmp3 + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_str) + tmp4 := checkDerefVar(var_glojure_DOT_core_str) + tmp5, _ := lang.FieldOrMethod(runtime.RT, "NextID") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("NextID is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{}) + tmp7 := lang.Apply(tmp4, []any{tmp6}) + tmp8 := lang.Apply(tmp3, []any{v2, tmp7}) + tmp9 := lang.Apply(lang.NewSymbol, []any{tmp8}) + return tmp9 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_gensym = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_gensym.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // get + { + var tmp1 lang.FnFunc + { // function get__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym__DOT_}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_Get}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v4}) + tmp21 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp20, v5}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp12, []any{tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp9, tmp11, tmp23}) + tmp25 := lang.Apply(tmp6, []any{tmp24}) + return tmp25 + } + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_get.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_map, sym_key), lang.NewVector(sym_map, sym_key, sym_not_DASH_found)), kw_inline, tmp1, kw_doc, "Returns the value mapped to key, not-found or nil if key not present\n in associative collection, set, string, array, or ILookup instance.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2), int64(3)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(1489), kw_end_DASH_line, int(1489))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(lang.Get, []any{v3, v4}) + return tmp5 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6 := lang.Apply(lang.GetDefault, []any{v3, v4, v5}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_get = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_get.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // halt-when + { + tmp0 := sym_halt_DASH_when.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred), lang.NewVector(sym_pred, sym_retf)), kw_doc, "Returns a transducer that ends transduction when pred returns true\n for an input. When retf is supplied it must be a fn of 2 arguments -\n it will be passed the (completed) result so far and the input that\n triggered the predicate, and its return value (if it does not throw\n an exception) will be the return value of the transducer. If retf\n is not supplied, the input that triggered the predicate will be\n returned. If the predicate never returns true the transduction is\n unaffected.", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(7657), kw_end_DASH_line, int(7657))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_halt_DASH_when) + tmp4 := lang.Apply(tmp3, []any{v2, nil}) + return tmp4 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v5 := args[0] + _ = v5 + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp7 := lang.Apply(v5, nil) + return tmp7 + case 1: + v7 := args[0] + _ = v7 + var tmp8 any + var tmp9 any + { // let + // let binding "and__0__auto__" + tmp10 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp11 := lang.Apply(tmp10, []any{v7}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + tmp14 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp15 := lang.Apply(tmp14, []any{v7, kw_glojure_DOT_core_SLASH_halt}) + tmp13 = tmp15 + } else { + tmp13 = v12 + } + tmp9 = tmp13 + } // end let + if lang.IsTruthy(tmp9) { + tmp10 := lang.Apply(kw_glojure_DOT_core_SLASH_halt, []any{v7}) + tmp8 = tmp10 + } else { + tmp11 := lang.Apply(v5, []any{v7}) + tmp8 = tmp11 + } + return tmp8 + case 2: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + var tmp9 any + tmp10 := lang.Apply(v2, []any{v8}) + if lang.IsTruthy(tmp10) { + tmp11 := checkDerefVar(var_glojure_DOT_core_reduced) + var tmp12 any + if lang.IsTruthy(v3) { + tmp13 := lang.Apply(v5, []any{v7}) + tmp14 := lang.Apply(v3, []any{tmp13, v8}) + tmp12 = tmp14 + } else { + tmp12 = v8 + } + tmp15 := lang.NewMap(kw_glojure_DOT_core_SLASH_halt, tmp12) + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7678), kw_column, int(24), kw_end_DASH_line, int(7678), kw_end_DASH_column, int(72)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp9 = tmp18 + } else { + tmp19 := lang.Apply(v5, []any{v7, v8}) + tmp9 = tmp19 + } + return tmp9 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7670), kw_column, int(8), kw_end_DASH_line, int(7679), kw_end_DASH_column, int(34)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp8 + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7669), kw_column, int(6), kw_end_DASH_line, int(7679), kw_end_DASH_column, int(35)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_halt_DASH_when = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_halt_DASH_when.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ident? + { + tmp0 := sym_ident_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a symbol or keyword", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(1608), kw_end_DASH_line, int(1608))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "or__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + tmp7 = v6 + } else { + tmp8 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp9 := lang.Apply(tmp8, []any{v2}) + tmp7 = tmp9 + } + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ident_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ident_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // identical? + { + var tmp1 lang.FnFunc + { // function identical?__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_lang_DOT_Util}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_glojure_DOT_core_SLASH_identical}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{v3}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v4}) + tmp17 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp12, tmp14, tmp16}) + tmp18 := lang.Apply(tmp5, []any{tmp17}) + return tmp18 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_identical_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Tests if 2 arguments are the same object", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(768), kw_end_DASH_line, int(768))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(lang.Identical, []any{v3, v4}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_identical_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_identical_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // if-not + { + tmp0 := sym_if_DASH_not.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_test, sym_then), lang.NewVector(sym_test, sym_then, sym_else)), kw_doc, "Evaluates test. If logical false, evaluates and returns then expr, \n otherwise else expr, if supplied, else nil.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(11), kw_line, int(760), kw_end_DASH_line, int(760))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_if_DASH_not}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{v4}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v5}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{nil}) + tmp16 := lang.Apply(tmp7, []any{tmp9, tmp11, tmp13, tmp15}) + tmp17 := lang.Apply(tmp6, []any{tmp16}) + return tmp17 + case 5: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_if}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_not}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v4}) + tmp18 := lang.Apply(tmp13, []any{tmp15, tmp17}) + tmp19 := lang.Apply(tmp12, []any{tmp18}) + tmp20 := lang.Apply(tmp11, []any{tmp19}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v5}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := lang.Apply(tmp23, []any{v6}) + tmp25 := lang.Apply(tmp8, []any{tmp10, tmp20, tmp22, tmp24}) + tmp26 := lang.Apply(tmp7, []any{tmp25}) + return tmp26 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_if_DASH_not = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_if_DASH_not.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ifn? + { + tmp0 := sym_ifn_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x implements IFn. Note that many data structures\n (e.g. sets and maps) implement IFn", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(6209), kw_end_DASH_line, int(6209))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := lang.Apply(tmp3, []any{nil, v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ifn_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ifn_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // inc + { + var tmp1 lang.FnFunc + { // function inc__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp15) { + tmp14 = sym_unchecked_inc + } else { + tmp14 = sym_inc + } + tmp16 := lang.Apply(tmp13, []any{tmp14}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := lang.Apply(tmp12, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp11, []any{tmp19}) + tmp21 := lang.Apply(tmp10, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_inc.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns a number one greater than num. Does not auto-promote\n longs, will throw on overflow. See also: inc'", kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(915), kw_end_DASH_line, int(915))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Inc") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Inc is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_inc = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_inc.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // inc' + { + var tmp1 lang.FnFunc + { // function inc'__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_IncP}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_inc_TICK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns a number one greater than num. Supports arbitrary precision.\n See also: inc", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(908), kw_end_DASH_line, int(908))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "IncP") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("IncP is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_inc_TICK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_inc_TICK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // indexed? + { + tmp0 := sym_indexed_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Return true if coll implements Indexed, indicating efficient lookup by index", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(6263), kw_end_DASH_line, int(6263))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := lang.Apply(tmp3, []any{nil, v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_indexed_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_indexed_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // infinite? + { + var tmp1 lang.FnFunc + { // function infinite?__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym_Double_SLASH_isInfinite}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{v3}) + tmp10 := lang.Apply(tmp5, []any{tmp7, tmp9}) + tmp11 := lang.Apply(tmp4, []any{tmp10}) + return tmp11 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_infinite_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_num)), kw_inline, tmp1, kw_doc, "Returns true if num is negative or positive infinity, else false", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1)})), kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(7977), kw_end_DASH_line, int(7977))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(nil, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_infinite_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_infinite_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // int + { + var tmp1 lang.FnFunc + { // function int__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp15) { + tmp14 = sym_uncheckedIntCast + } else { + tmp14 = sym_intCast + } + tmp16 := lang.Apply(tmp13, []any{tmp14}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := lang.Apply(tmp12, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp11, []any{tmp19}) + tmp21 := lang.Apply(tmp10, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to int", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(875), kw_end_DASH_line, int(875))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(runtime.RT, "IntCast") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("IntCast is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_int = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_int.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // int-array + { + var tmp1 lang.FnFunc + { // function int-array__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_IntArray}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_unquote_DASH_splicing}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_glojure_DOT_core_SLASH_args}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + } + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_int_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_size_DASH_or_DASH_seq), lang.NewVector(sym_size, sym_init_DASH_val_DASH_or_DASH_seq)), kw_inline, tmp1, kw_doc, "Creates an array of ints", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(5356), kw_end_DASH_line, int(5356))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "IntArray") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("IntArray is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "IntArrayInit") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("IntArrayInit is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_int_DASH_array = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_int_DASH_array.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // intern + { + tmp0 := sym_intern.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns, sym_name), lang.NewVector(sym_ns, sym_name, sym_val)), kw_doc, "Finds or creates a var named by the symbol name in the namespace\n ns (which can be a symbol or a namespace), setting its root binding\n to val if supplied. The namespace must exist. The var will adopt any\n metadata from the name symbol. Returns the var.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(6311), kw_end_DASH_line, int(6311))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "v" + tmp5 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) + tmp6 := lang.Apply(tmp5, []any{v2}) + tmp7 := lang.Apply(nil, []any{tmp6, v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_meta) + tmp11 := lang.Apply(tmp10, []any{v3}) + if lang.IsTruthy(tmp11) { + tmp12 := checkDerefVar(var_glojure_DOT_core_meta) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14, _ := lang.FieldOrMethod(v8, "setMeta") + if reflect.TypeOf(tmp14).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMeta is not a function"))) + } + tmp15 := lang.Apply(tmp14, []any{tmp13}) + tmp9 = tmp15 + } else { + } + _ = tmp9 + tmp4 = v8 + } // end let + return tmp4 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + { // let + // let binding "v" + tmp6 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) + tmp7 := lang.Apply(tmp6, []any{v2}) + tmp8 := lang.Apply(nil, []any{tmp7, v3, v4}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + tmp11 := checkDerefVar(var_glojure_DOT_core_meta) + tmp12 := lang.Apply(tmp11, []any{v3}) + if lang.IsTruthy(tmp12) { + tmp13 := checkDerefVar(var_glojure_DOT_core_meta) + tmp14 := lang.Apply(tmp13, []any{v3}) + tmp15, _ := lang.FieldOrMethod(v9, "setMeta") + if reflect.TypeOf(tmp15).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMeta is not a function"))) + } + tmp16 := lang.Apply(tmp15, []any{tmp14}) + tmp10 = tmp16 + } else { + } + _ = tmp10 + tmp5 = v9 + } // end let + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_intern = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_intern.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // into-array + { + tmp0 := sym_into_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_aseq), lang.NewVector(sym_type, sym_aseq)), kw_doc, "Returns an array with components set to the values in aseq. The array's\n component type is type if provided, or the type of the first value in\n aseq if present, or Object. All values in aseq must be compatible with\n the component type. Class objects for the primitive types can be obtained\n using, e.g., Integer/TYPE.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(3444), kw_end_DASH_line, int(3444))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_seq) + tmp4 := lang.Apply(tmp3, []any{v2}) + tmp5 := lang.Apply(nil, []any{tmp4}) + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := lang.Apply(tmp4, []any{v3}) + tmp6 := lang.Apply(nil, []any{v2, tmp5}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_into_DASH_array = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_into_DASH_array.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ints + { + var tmp1 lang.FnFunc + { // function ints + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Ints}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_ints.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xs)), kw_inline, tmp1, kw_doc, "Casts to int[]", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(12), kw_line, int(5397), kw_end_DASH_line, int(5397))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Ints") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Ints is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ints = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ints.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // io! + { + tmp0 := sym_io_BANG_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_body)), kw_doc, "If an io! block occurs in a transaction, throws an\n IllegalStateException, else runs body in an implicit do. If the\n first expression in body is a literal string, will use that as the\n exception message.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(11), kw_line, int(2504), kw_end_DASH_line, int(2504))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "message" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp8 := checkDerefVar(var_glojure_DOT_core_first) + tmp9 := lang.Apply(tmp8, []any{v4}) + tmp10 := lang.Apply(tmp7, []any{tmp9}) + if lang.IsTruthy(tmp10) { + tmp11 := checkDerefVar(var_glojure_DOT_core_first) + tmp12 := lang.Apply(tmp11, []any{v4}) + tmp6 = tmp12 + } else { + } + var v13 any = tmp6 + _ = v13 + // let binding "body" + var tmp14 any + if lang.IsTruthy(v13) { + tmp15 := checkDerefVar(var_glojure_DOT_core_next) + tmp16 := lang.Apply(tmp15, []any{v4}) + tmp14 = tmp16 + } else { + tmp14 = v4 + } + var v17 any = tmp14 + _ = v17 + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{sym_if}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := checkDerefVar(var_glojure_DOT_core_seq) + tmp24 := checkDerefVar(var_glojure_DOT_core_concat) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := lang.Apply(tmp25, []any{sym_glojure_DOT_lang_DOT_LockingTransaction_SLASH_isRunning}) + tmp27 := lang.Apply(tmp24, []any{tmp26}) + tmp28 := lang.Apply(tmp23, []any{tmp27}) + tmp29 := lang.Apply(tmp22, []any{tmp28}) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := checkDerefVar(var_glojure_DOT_core_seq) + tmp32 := checkDerefVar(var_glojure_DOT_core_concat) + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{sym_throw}) + tmp35 := checkDerefVar(var_glojure_DOT_core_list) + tmp36 := checkDerefVar(var_glojure_DOT_core_seq) + tmp37 := checkDerefVar(var_glojure_DOT_core_concat) + tmp38 := checkDerefVar(var_glojure_DOT_core_list) + tmp39 := lang.Apply(tmp38, []any{sym_new}) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{sym_glojure_DOT_core_SLASH_IllegalStateException}) + tmp42 := checkDerefVar(var_glojure_DOT_core_list) + var tmp43 any + { // let + // let binding "or__0__auto__" + var v44 any = v13 + _ = v44 + var tmp45 any + if lang.IsTruthy(v44) { + tmp45 = v44 + } else { + tmp45 = "I/O in transaction" + } + tmp43 = tmp45 + } // end let + tmp44 := lang.Apply(tmp42, []any{tmp43}) + tmp45 := lang.Apply(tmp37, []any{tmp39, tmp41, tmp44}) + tmp46 := lang.Apply(tmp36, []any{tmp45}) + tmp47 := lang.Apply(tmp35, []any{tmp46}) + tmp48 := lang.Apply(tmp32, []any{tmp34, tmp47}) + tmp49 := lang.Apply(tmp31, []any{tmp48}) + tmp50 := lang.Apply(tmp30, []any{tmp49}) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := checkDerefVar(var_glojure_DOT_core_seq) + tmp53 := checkDerefVar(var_glojure_DOT_core_concat) + tmp54 := checkDerefVar(var_glojure_DOT_core_list) + tmp55 := lang.Apply(tmp54, []any{sym_do}) + tmp56 := lang.Apply(tmp53, []any{tmp55, v17}) + tmp57 := lang.Apply(tmp52, []any{tmp56}) + tmp58 := lang.Apply(tmp51, []any{tmp57}) + tmp59 := lang.Apply(tmp19, []any{tmp21, tmp29, tmp50, tmp58}) + tmp60 := lang.Apply(tmp18, []any{tmp59}) + tmp5 = tmp60 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_io_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_io_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // keep-indexed + { + tmp0 := sym_keep_DASH_indexed.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_coll)), kw_doc, "Returns a lazy sequence of the non-nil results of (f index item). Note,\n this means false return values will be included. f must be free of\n side-effects. Returns a stateful transducer when no collection is\n provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(7372), kw_end_DASH_line, int(7372))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 any + { // let + // let binding "iv" + tmp6 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) + tmp7 := lang.Apply(tmp6, []any{int64(-1)}) + var v8 any = tmp7 + _ = v8 + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp10 := lang.Apply(v4, nil) + return tmp10 + case 1: + v10 := args[0] + _ = v10 + tmp11 := lang.Apply(v4, []any{v10}) + return tmp11 + case 2: + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + var tmp12 any + { // let + // let binding "i" + tmp13 := checkDerefVar(var_glojure_DOT_core_inc) + tmp14, ok := lang.FieldOrMethod(v8, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "Deref"))) + } + var tmp15 any + switch reflect.TypeOf(tmp14).Kind() { + case reflect.Func: + tmp15 = lang.Apply(tmp14, nil) + default: + tmp15 = tmp14 + } + tmp16 := lang.Apply(tmp13, []any{tmp15}) + tmp17, _ := lang.FieldOrMethod(v8, "reset") + if reflect.TypeOf(tmp17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) + } + tmp18 := lang.Apply(tmp17, []any{tmp16}) + var v19 any = tmp18 + _ = v19 + // let binding "v" + tmp20 := lang.Apply(v2, []any{v19, v11}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + tmp23 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp24 := lang.Apply(tmp23, []any{v21}) + if lang.IsTruthy(tmp24) { + tmp22 = v10 + } else { + tmp25 := lang.Apply(v4, []any{v10, v21}) + tmp22 = tmp25 + } + tmp12 = tmp22 + } // end let + return tmp12 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7382), kw_column, int(8), kw_end_DASH_line, int(7390), kw_end_DASH_column, int(33)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp5 = tmp11 + } // end let + return tmp5 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7380), kw_column, int(4), kw_end_DASH_line, int(7390), kw_end_DASH_column, int(35)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + return nil + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_keep_DASH_indexed = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_keep_DASH_indexed.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // keyword + { + tmp1 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() + tmp0 := sym_keyword.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_name), lang.NewVector(sym_ns, sym_name)), kw_doc, "Returns a Keyword with the given namespace and name. Do not use :\n in the keyword strings, it will be added automatically.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(609), kw_end_DASH_line, int(609))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + tmp4 = v3 + } else { + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp9 := lang.Apply(tmp8, []any{v3}) + if lang.IsTruthy(tmp9) { + tmp10 := lang.Apply(lang.InternKeywordSymbol, []any{v3}) + tmp7 = tmp10 + } else { + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp13 := lang.Apply(tmp12, []any{v3}) + if lang.IsTruthy(tmp13) { + tmp14 := lang.Apply(lang.InternKeywordString, []any{v3}) + tmp11 = tmp14 + } else { + } + tmp7 = tmp11 + } + tmp4 = tmp7 + } + return tmp4 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(lang.InternKeyword, []any{v3, v4}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp3 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_keyword = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_keyword.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // last + { + tmp0 := sym_last.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Return the last item in coll, in linear time", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(5), kw_column, int(2), kw_line, int(262), kw_end_DASH_line, int(266))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function last + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + recur_loop_1572: + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_next) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + tmp8 := checkDerefVar(var_glojure_DOT_core_next) + tmp9 := lang.Apply(tmp8, []any{v3}) + var tmp7 any = tmp9 + v3 = tmp7 + goto recur_loop_1572 + } else { + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v3}) + tmp4 = tmp11 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(266), kw_column, int(7), kw_end_DASH_line, int(269), kw_end_DASH_column, int(21))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_last = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_last.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // libspec? + { + tmp0 := sym_libspec_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x is a libspec", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(8), kw_line, int(5848), kw_end_DASH_line, int(5848), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "or__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + tmp7 = v6 + } else { + var tmp8 any + { // let + // let binding "and__0__auto__" + tmp9 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp10 := lang.Apply(tmp9, []any{v2}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + var tmp13 any + { // let + // let binding "or__0__auto__" + tmp14 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp15 := checkDerefVar(var_glojure_DOT_core_second) + tmp16 := lang.Apply(tmp15, []any{v2}) + tmp17 := lang.Apply(tmp14, []any{tmp16}) + var v18 any = tmp17 + _ = v18 + var tmp19 any + if lang.IsTruthy(v18) { + tmp19 = v18 + } else { + tmp20 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp21 := checkDerefVar(var_glojure_DOT_core_second) + tmp22 := lang.Apply(tmp21, []any{v2}) + tmp23 := lang.Apply(tmp20, []any{tmp22}) + tmp19 = tmp23 + } + tmp13 = tmp19 + } // end let + tmp12 = tmp13 + } else { + tmp12 = v11 + } + tmp8 = tmp12 + } // end let + tmp7 = tmp8 + } + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_libspec_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_libspec_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // list* + { + tmp0 := sym_list_STAR_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_args), lang.NewVector(sym_a, sym_args), lang.NewVector(sym_a, sym_b, sym_args), lang.NewVector(sym_a, sym_b, sym_c, sym_args), lang.NewVector(sym_a, sym_b, sym_c, sym_d, sym__AMP_, sym_more)), kw_doc, "Creates a new seq containing the items prepended to the rest, the\n last of which will be treated as a sequence.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(641), kw_end_DASH_line, int(641))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_seq) + tmp4 := lang.Apply(tmp3, []any{v2}) + return tmp4 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_cons) + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + return tmp5 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_cons) + tmp6 := checkDerefVar(var_glojure_DOT_core_cons) + tmp7 := lang.Apply(tmp6, []any{v3, v4}) + tmp8 := lang.Apply(tmp5, []any{v2, tmp7}) + return tmp8 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_cons) + tmp7 := checkDerefVar(var_glojure_DOT_core_cons) + tmp8 := checkDerefVar(var_glojure_DOT_core_cons) + tmp9 := lang.Apply(tmp8, []any{v4, v5}) + tmp10 := lang.Apply(tmp7, []any{v3, tmp9}) + tmp11 := lang.Apply(tmp6, []any{v2, tmp10}) + return tmp11 + default: + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var v6 any = lang.NewList(args[4:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_cons) + tmp8 := checkDerefVar(var_glojure_DOT_core_cons) + tmp9 := checkDerefVar(var_glojure_DOT_core_cons) + tmp10 := checkDerefVar(var_glojure_DOT_core_cons) + tmp11 := checkDerefVar(var_glojure_DOT_core_spread) + tmp12 := lang.Apply(tmp11, []any{v6}) + tmp13 := lang.Apply(tmp10, []any{v5, tmp12}) + tmp14 := lang.Apply(tmp9, []any{v4, tmp13}) + tmp15 := lang.Apply(tmp8, []any{v3, tmp14}) + tmp16 := lang.Apply(tmp7, []any{v2, tmp15}) + return tmp16 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_list_STAR_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_list_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // loaded-libs + { + tmp0 := sym_loaded_DASH_libs.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Returns a sorted set of symbols naming the currently loaded libs", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(6090), kw_end_DASH_line, int(6090))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp2 := checkDerefVar(var_glojure_DOT_core_deref) + tmp3 := checkDerefVar(var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_) + tmp4 := lang.Apply(tmp2, []any{tmp3}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_loaded_DASH_libs = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_loaded_DASH_libs.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // long + { + var tmp1 lang.FnFunc + { // function long__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_LongCast}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_long.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to long", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3481), kw_end_DASH_line, int(3481))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.LongCast, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_long = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_long.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // long-array + { + var tmp1 lang.FnFunc + { // function long-array__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_LongArray}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_unquote_DASH_splicing}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_glojure_DOT_core_SLASH_args}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + } + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_long_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_size_DASH_or_DASH_seq), lang.NewVector(sym_size, sym_init_DASH_val_DASH_or_DASH_seq)), kw_inline, tmp1, kw_doc, "Creates an array of longs", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(5364), kw_end_DASH_line, int(5364))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "LongArray") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("LongArray is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "LongArrayInit") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("LongArrayInit is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_long_DASH_array = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_long_DASH_array.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // longs + { + var tmp1 lang.FnFunc + { // function longs + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Longs}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_longs.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xs)), kw_inline, tmp1, kw_doc, "Casts to long[]", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(12), kw_line, int(5407), kw_end_DASH_line, int(5407))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Longs") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Longs is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_longs = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_longs.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // macroexpand + { + tmp0 := sym_macroexpand.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_form)), kw_doc, "Repeatedly calls macroexpand-1 on form until it no longer\n represents a macro form, then returns it. Note neither\n macroexpand-1 nor macroexpand expand macros in subforms.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(4025), kw_end_DASH_line, int(4025))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "ex" + tmp4 := checkDerefVar(var_glojure_DOT_core_macroexpand_DASH_1) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core_identical_QMARK_) + tmp9 := lang.Apply(tmp8, []any{v6, v2}) + if lang.IsTruthy(tmp9) { + tmp7 = v2 + } else { + tmp10 := checkDerefVar(var_glojure_DOT_core_macroexpand) + tmp11 := lang.Apply(tmp10, []any{v6}) + tmp7 = tmp11 + } + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_macroexpand = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_macroexpand.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // map-indexed + { + tmp0 := sym_map_DASH_indexed.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_coll)), kw_doc, "Returns a lazy sequence consisting of the result of applying f to 0\n and the first item of coll, followed by applying f to 1 and the second\n item in coll, etc, until coll is exhausted. Thus function f should\n accept 2 arguments, index and item. Returns a stateful transducer when\n no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(7309), kw_end_DASH_line, int(7309))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 any + { // let + // let binding "i" + tmp6 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) + tmp7 := lang.Apply(tmp6, []any{int64(-1)}) + var v8 any = tmp7 + _ = v8 + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp10 := lang.Apply(v4, nil) + return tmp10 + case 1: + v10 := args[0] + _ = v10 + tmp11 := lang.Apply(v4, []any{v10}) + return tmp11 + case 2: + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_inc) + tmp13, ok := lang.FieldOrMethod(v8, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "Deref"))) + } + var tmp14 any + switch reflect.TypeOf(tmp13).Kind() { + case reflect.Func: + tmp14 = lang.Apply(tmp13, nil) + default: + tmp14 = tmp13 + } + tmp15 := lang.Apply(tmp12, []any{tmp14}) + tmp16, _ := lang.FieldOrMethod(v8, "reset") + if reflect.TypeOf(tmp16).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) + } + tmp17 := lang.Apply(tmp16, []any{tmp15}) + tmp18 := lang.Apply(v2, []any{tmp17, v11}) + tmp19 := lang.Apply(v4, []any{v10, tmp18}) + return tmp19 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7320), kw_column, int(8), kw_end_DASH_line, int(7324), kw_end_DASH_column, int(48)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp5 = tmp11 + } // end let + return tmp5 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7318), kw_column, int(4), kw_end_DASH_line, int(7324), kw_end_DASH_column, int(50)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + return nil + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_map_DASH_indexed = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_map_DASH_indexed.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // maybe-destructured + { + tmp0 := sym_maybe_DASH_destructured.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(4514), kw_column, int(7), kw_end_DASH_line, int(4515), kw_end_DASH_column, int(20), kw_arglists, lang.NewList(lang.NewVector(sym_params, sym_body)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + tmp6 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp7 := lang.Apply(tmp5, []any{tmp6, v2}) + if lang.IsTruthy(tmp7) { + tmp8 := checkDerefVar(var_glojure_DOT_core_cons) + tmp9 := lang.Apply(tmp8, []any{v2, v3}) + tmp4 = tmp9 + } else { + var tmp10 any + { // let + // let binding "params" + var v11 any = v2 + _ = v11 + // let binding "new-params" + tmp12 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp13 := lang.NewVector() + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4520), kw_column, int(34), kw_end_DASH_line, int(4520), kw_end_DASH_column, int(35)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp16 := checkDerefVar(var_glojure_DOT_core_meta) + tmp17 := lang.Apply(tmp16, []any{v11}) + tmp18 := lang.Apply(tmp12, []any{tmp15, tmp17}) + var v19 any = tmp18 + _ = v19 + // let binding "lets" + tmp20 := lang.NewVector() + tmp21 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4521), kw_column, int(17), kw_end_DASH_line, int(4521), kw_end_DASH_column, int(18)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v23 any = tmp22 + _ = v23 + for { + var tmp24 any + if lang.IsTruthy(v11) { + var tmp25 any + tmp26 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp27 := checkDerefVar(var_glojure_DOT_core_first) + tmp28 := lang.Apply(tmp27, []any{v11}) + tmp29 := lang.Apply(tmp26, []any{tmp28}) + if lang.IsTruthy(tmp29) { + tmp31 := checkDerefVar(var_glojure_DOT_core_next) + tmp32 := lang.Apply(tmp31, []any{v11}) + var tmp30 any = tmp32 + tmp34 := checkDerefVar(var_glojure_DOT_core_conj) + tmp35 := checkDerefVar(var_glojure_DOT_core_first) + tmp36 := lang.Apply(tmp35, []any{v11}) + tmp37 := lang.Apply(tmp34, []any{v19, tmp36}) + var tmp33 any = tmp37 + var tmp38 any = v23 + v11 = tmp30 + v19 = tmp33 + v23 = tmp38 + continue + } else { + var tmp39 any + { // let + // let binding "gparam" + tmp40 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp41 := lang.Apply(tmp40, []any{"p__"}) + var v42 any = tmp41 + _ = v42 + tmp44 := checkDerefVar(var_glojure_DOT_core_next) + tmp45 := lang.Apply(tmp44, []any{v11}) + var tmp43 any = tmp45 + tmp47 := checkDerefVar(var_glojure_DOT_core_conj) + tmp48 := lang.Apply(tmp47, []any{v19, v42}) + var tmp46 any = tmp48 + tmp50 := checkDerefVar(var_glojure_DOT_core_conj) + tmp51 := checkDerefVar(var_glojure_DOT_core_conj) + tmp52 := checkDerefVar(var_glojure_DOT_core_first) + tmp53 := lang.Apply(tmp52, []any{v11}) + tmp54 := lang.Apply(tmp51, []any{v23, tmp53}) + tmp55 := lang.Apply(tmp50, []any{tmp54, v42}) + var tmp49 any = tmp55 + v11 = tmp43 + v19 = tmp46 + v23 = tmp49 + continue + } // end let + tmp25 = tmp39 + } + tmp24 = tmp25 + } else { + tmp40 := checkDerefVar(var_glojure_DOT_core_seq) + tmp41 := checkDerefVar(var_glojure_DOT_core_concat) + tmp42 := checkDerefVar(var_glojure_DOT_core_list) + tmp43 := lang.Apply(tmp42, []any{v19}) + tmp44 := checkDerefVar(var_glojure_DOT_core_list) + tmp45 := checkDerefVar(var_glojure_DOT_core_seq) + tmp46 := checkDerefVar(var_glojure_DOT_core_concat) + tmp47 := checkDerefVar(var_glojure_DOT_core_list) + tmp48 := lang.Apply(tmp47, []any{sym_glojure_DOT_core_SLASH_let}) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) + tmp50 := lang.Apply(tmp49, []any{v23}) + tmp51 := lang.Apply(tmp46, []any{tmp48, tmp50, v3}) + tmp52 := lang.Apply(tmp45, []any{tmp51}) + tmp53 := lang.Apply(tmp44, []any{tmp52}) + tmp54 := lang.Apply(tmp41, []any{tmp43, tmp53}) + tmp55 := lang.Apply(tmp40, []any{tmp54}) + tmp24 = tmp55 + } + tmp10 = tmp24 + break + } + } // end let + tmp4 = tmp10 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_maybe_DASH_destructured = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_maybe_DASH_destructured.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // name + { + tmp1 := reflect.TypeOf("") + tmp0 := sym_name.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns the name String of a string, symbol or keyword.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1585), kw_end_DASH_line, int(1585))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + tmp4 = v3 + } else { + tmp7, _ := lang.FieldOrMethod(v3, "Name") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Name is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{}) + tmp4 = tmp8 + } + return tmp4 + }) + tmp3 := reflect.TypeOf("") + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_name = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_name.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // neg? + { + var tmp1 lang.FnFunc + { // function neg?__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_IsNeg}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_neg_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_num)), kw_inline, tmp1, kw_doc, "Returns true if num is less than zero, else false", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1259), kw_end_DASH_line, int(1259))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "IsNeg") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("IsNeg is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_neg_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_neg_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // not-empty + { + tmp0 := sym_not_DASH_empty.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "If coll is empty, returns nil, else coll", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(5516), kw_end_DASH_line, int(5516))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + tmp3 = v2 + } else { + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_not_DASH_empty = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_not_DASH_empty.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ns-aliases + { + tmp0 := sym_ns_DASH_aliases.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns)), kw_doc, "Returns a map of the aliases for the namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4273), kw_end_DASH_line, int(4273))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) + tmp4 := lang.Apply(tmp3, []any{v2}) + tmp5, ok := lang.FieldOrMethod(tmp4, "getAliases") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp4, "getAliases"))) + } + var tmp6 any + switch reflect.TypeOf(tmp5).Kind() { + case reflect.Func: + tmp6 = lang.Apply(tmp5, nil) + default: + tmp6 = tmp5 + } + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ns_DASH_aliases = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ns_DASH_aliases.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ns-map + { + tmp0 := sym_ns_DASH_map.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns)), kw_doc, "Returns a map of all the mappings for the namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(4170), kw_end_DASH_line, int(4170))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) + tmp4 := lang.Apply(tmp3, []any{v2}) + tmp5, ok := lang.FieldOrMethod(tmp4, "Mappings") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp4, "Mappings"))) + } + var tmp6 any + switch reflect.TypeOf(tmp5).Kind() { + case reflect.Func: + tmp6 = lang.Apply(tmp5, nil) + default: + tmp6 = tmp5 + } + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ns_DASH_map = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ns_DASH_map.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ns-name + { + tmp0 := sym_ns_DASH_name.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns)), kw_doc, "Returns the name of the namespace, a symbol.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4163), kw_end_DASH_line, int(4163))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) + tmp4 := lang.Apply(tmp3, []any{v2}) + tmp5, ok := lang.FieldOrMethod(tmp4, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp4, "Name"))) + } + var tmp6 any + switch reflect.TypeOf(tmp5).Kind() { + case reflect.Func: + tmp6 = lang.Apply(tmp5, nil) + default: + tmp6 = tmp5 + } + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ns_DASH_name = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ns_DASH_name.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ns-resolve + { + tmp0 := sym_ns_DASH_resolve.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns, sym_sym), lang.NewVector(sym_ns, sym_env, sym_sym)), kw_doc, "Returns the var or Class to which a symbol will be resolved in the\n namespace (unless found in the environment), else nil. Note that\n if the symbol is fully qualified, the var/Class to which it resolves\n need not be present in the namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4358), kw_end_DASH_line, int(4358))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_ns_DASH_resolve) + tmp5 := lang.Apply(tmp4, []any{v2, nil, v3}) + return tmp5 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp7 := lang.Apply(tmp6, []any{v3, v4}) + if lang.IsTruthy(tmp7) { + } else { + tmp8 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) + tmp9 := lang.Apply(tmp8, []any{v2}) + tmp10, _ := lang.FieldOrMethod(runtime.Compiler, "maybeResolveIn") + if reflect.TypeOf(tmp10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("maybeResolveIn is not a function"))) + } + tmp11 := lang.Apply(tmp10, []any{tmp9, v4}) + tmp5 = tmp11 + } + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ns_DASH_resolve = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ns_DASH_resolve.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ns-unalias + { + tmp0 := sym_ns_DASH_unalias.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns, sym_sym)), kw_doc, "Removes the alias for the symbol from the namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4280), kw_end_DASH_line, int(4280))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) + tmp5 := lang.Apply(tmp4, []any{v2}) + tmp6, _ := lang.FieldOrMethod(tmp5, "removeAlias") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("removeAlias is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v3}) + return tmp7 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ns_DASH_unalias = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ns_DASH_unalias.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ns-unmap + { + tmp0 := sym_ns_DASH_unmap.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns, sym_sym)), kw_doc, "Removes the mappings for the symbol from the namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(4177), kw_end_DASH_line, int(4177))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) + tmp5 := lang.Apply(tmp4, []any{v2}) + tmp6, _ := lang.FieldOrMethod(tmp5, "unmap") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unmap is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v3}) + return tmp7 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ns_DASH_unmap = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ns_DASH_unmap.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // nth + { + var tmp1 lang.FnFunc + { // function nth__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym__DOT_}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_Nth}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{sym_glojure_DOT_core_SLASH_unquote}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{sym_glojure_DOT_core_SLASH_c}) + tmp24 := lang.Apply(tmp19, []any{tmp21, tmp23}) + tmp25 := lang.Apply(tmp18, []any{tmp24}) + tmp26 := lang.Apply(tmp17, []any{tmp25}) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := checkDerefVar(var_glojure_DOT_core_seq) + tmp29 := checkDerefVar(var_glojure_DOT_core_concat) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := lang.Apply(tmp30, []any{sym_glojure_DOT_core_SLASH_unquote}) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := lang.Apply(tmp32, []any{sym_glojure_DOT_core_SLASH_i}) + tmp34 := lang.Apply(tmp29, []any{tmp31, tmp33}) + tmp35 := lang.Apply(tmp28, []any{tmp34}) + tmp36 := lang.Apply(tmp27, []any{tmp35}) + tmp37 := checkDerefVar(var_glojure_DOT_core_list) + tmp38 := checkDerefVar(var_glojure_DOT_core_seq) + tmp39 := checkDerefVar(var_glojure_DOT_core_concat) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{sym_glojure_DOT_core_SLASH_unquote_DASH_splicing}) + tmp42 := checkDerefVar(var_glojure_DOT_core_list) + tmp43 := lang.Apply(tmp42, []any{sym_glojure_DOT_core_SLASH_nf}) + tmp44 := lang.Apply(tmp39, []any{tmp41, tmp43}) + tmp45 := lang.Apply(tmp38, []any{tmp44}) + tmp46 := lang.Apply(tmp37, []any{tmp45}) + tmp47 := lang.Apply(tmp14, []any{tmp16, tmp26, tmp36, tmp46}) + tmp48 := lang.Apply(tmp13, []any{tmp47}) + tmp49 := lang.Apply(tmp12, []any{tmp48}) + tmp50 := lang.Apply(tmp7, []any{tmp9, tmp11, tmp49}) + tmp51 := lang.Apply(tmp6, []any{tmp50}) + return tmp51 + } + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_nth.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll, sym_index), lang.NewVector(sym_coll, sym_index, sym_not_DASH_found)), kw_inline, tmp1, kw_doc, "Returns the value at the index. get returns nil if index out of\n bounds, nth throws an exception unless not-found is supplied. nth\n also works for strings, Java arrays, regex Matchers and Lists, and,\n in O(n) time, for sequences.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2), int64(3)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(882), kw_end_DASH_line, int(882))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(runtime.RT, "Nth") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Nth is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6, _ := lang.FieldOrMethod(runtime.RT, "NthDefault") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("NthDefault is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v3, v4, v5}) + return tmp7 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_nth = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_nth.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // num + { + var tmp1 lang.FnFunc + { // function num__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Num}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_num.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to Number", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(3474), kw_end_DASH_line, int(3474))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Num") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Num is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_num = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_num.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // object-array + { + var tmp1 lang.FnFunc + { // function object-array__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Object_array}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_object_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_size_DASH_or_DASH_seq)), kw_inline, tmp1, kw_doc, "Creates an array of objects", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1)})), kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(5349), kw_end_DASH_line, int(5349))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(runtime.RT, "Object_array") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Object_array is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_object_DASH_array = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_object_DASH_array.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // parse-impls + { + tmp0 := sym_parse_DASH_impls.WithMeta(lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(13), kw_column, int(8), kw_end_DASH_line, int(13), kw_end_DASH_column, int(18), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_specs)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "ret" + tmp4 := lang.NewMap() + tmp5 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(14), kw_column, int(14), kw_end_DASH_line, int(14), kw_end_DASH_column, int(15)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v7 any = tmp6 + _ = v7 + // let binding "s" + var v8 any = v2 + _ = v8 + for { + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_seq) + tmp11 := lang.Apply(tmp10, []any{v8}) + if lang.IsTruthy(tmp11) { + tmp13 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp14 := checkDerefVar(var_glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v8}) + tmp16 := checkDerefVar(var_glojure_DOT_core_take_DASH_while) + tmp17 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp18 := checkDerefVar(var_glojure_DOT_core_next) + tmp19 := lang.Apply(tmp18, []any{v8}) + tmp20 := lang.Apply(tmp16, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp13, []any{v7, tmp15, tmp20}) + var tmp12 any = tmp21 + tmp23 := checkDerefVar(var_glojure_DOT_core_drop_DASH_while) + tmp24 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp25 := checkDerefVar(var_glojure_DOT_core_next) + tmp26 := lang.Apply(tmp25, []any{v8}) + tmp27 := lang.Apply(tmp23, []any{tmp24, tmp26}) + var tmp22 any = tmp27 + v7 = tmp12 + v8 = tmp22 + continue + } else { + tmp9 = v7 + } + tmp3 = tmp9 + break + } + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_parse_DASH_impls = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_parse_DASH_impls.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // parse-uuid + { + tmp0 := sym_parse_DASH_uuid.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_doc, "Parse a string representing a UUID and return a java.util.UUID instance,\n or nil if parse fails.\n\n Grammar: https://docs.oracle.com/javase/8/docs/api/java/util/UUID.html#toString--", kw_file, "glojure/core.glj", kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(7946), kw_end_DASH_line, int(7946))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + func() { + defer func() { + if r := recover(); r != nil { + tmp4 := reflect.TypeOf((*lang.IllegalArgumentError)(nil)) + if lang.CatchMatches(r, tmp4) { + v5 := r + _ = v5 + } else { + panic(r) + } + } + }() + var tmp5 any + { // let + // let binding "vec__688" + tmp6 := lang.Apply(uuid10.Parse, []any{v2}) + var v7 any = tmp6 + _ = v7 + // let binding "uuid" + tmp8 := checkDerefVar(var_glojure_DOT_core_nth) + tmp9 := lang.Apply(tmp8, []any{v7, int64(0), nil}) + var v10 any = tmp9 + _ = v10 + // let binding "err" + tmp11 := checkDerefVar(var_glojure_DOT_core_nth) + tmp12 := lang.Apply(tmp11, []any{v7, int64(1), nil}) + var v13 any = tmp12 + _ = v13 + var tmp14 any + if lang.IsTruthy(v13) { + tmp15 := checkDerefVar(var_glojure_DOT_core_str) + tmp16 := lang.Apply(tmp15, []any{"Error parsing UUID: ", v13}) + tmp17 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp16}) + panic(tmp17) + } else { + tmp14 = v10 + } + tmp5 = tmp14 + } // end let + tmp3 = tmp5 + }() + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_parse_DASH_uuid = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_parse_DASH_uuid.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // parsing-err + { + tmp0 := sym_parsing_DASH_err.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_val)), kw_doc, "Construct message for parsing for non-string parsing error", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(8), kw_line, int(7921), kw_end_DASH_line, int(7921), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_str) + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v2}) + if lang.IsTruthy(tmp6) { + tmp4 = "nil" + } else { + tmp7 := checkDerefVar(var_glojure_DOT_core_class) + tmp8 := lang.Apply(tmp7, []any{v2}) + tmp9, ok := lang.FieldOrMethod(tmp8, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp8, "Name"))) + } + var tmp10 any + switch reflect.TypeOf(tmp9).Kind() { + case reflect.Func: + tmp10 = lang.Apply(tmp9, nil) + default: + tmp10 = tmp9 + } + tmp4 = tmp10 + } + tmp11 := lang.Apply(tmp3, []any{"Expected string, got ", tmp4}) + return tmp11 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_parsing_DASH_err = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_parsing_DASH_err.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // pos? + { + var tmp1 lang.FnFunc + { // function pos?__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_IsPos}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_pos_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_num)), kw_inline, tmp1, kw_doc, "Returns true if num is greater than zero, else false", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1252), kw_end_DASH_line, int(1252))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "IsPos") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("IsPos is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_pos_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_pos_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // prependss + { + tmp0 := sym_prependss.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_coll)), kw_doc, "Prepends a symbol or a seq to coll", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(8), kw_line, int(5857), kw_end_DASH_line, int(5857), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v2}) + if lang.IsTruthy(tmp6) { + tmp7 := checkDerefVar(var_glojure_DOT_core_cons) + tmp8 := lang.Apply(tmp7, []any{v2, v3}) + tmp4 = tmp8 + } else { + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := lang.Apply(tmp9, []any{v2, v3}) + tmp4 = tmp10 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_prependss = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_prependss.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print-ctor + { + tmp0 := sym_print_DASH_ctor.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(95), kw_column, int(7), kw_end_DASH_line, int(95), kw_end_DASH_column, int(16), kw_arglists, lang.NewList(lang.NewVector(sym_o, sym_print_DASH_args, sym_w)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := lang.Apply(lang.WriteWriter, []any{v4, "#=("}) + _ = tmp5 + tmp6 := checkDerefVar(var_glojure_DOT_core_class) + tmp7 := lang.Apply(tmp6, []any{v2}) + tmp8, ok := lang.FieldOrMethod(tmp7, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp7, "Name"))) + } + var tmp9 any + switch reflect.TypeOf(tmp8).Kind() { + case reflect.Func: + tmp9 = lang.Apply(tmp8, nil) + default: + tmp9 = tmp8 + } + tmp10 := lang.Apply(lang.WriteWriter, []any{v4, tmp9}) + _ = tmp10 + tmp11 := lang.Apply(lang.WriteWriter, []any{v4, ". "}) + _ = tmp11 + tmp12 := lang.Apply(v3, []any{v2, v4}) + _ = tmp12 + tmp13 := lang.Apply(lang.WriteWriter, []any{v4, ")"}) + return tmp13 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_print_DASH_ctor = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_print_DASH_ctor.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // quot + { + var tmp1 lang.FnFunc + { // function quot__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Quotient}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_quot.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_num, sym_div)), kw_inline, tmp1, kw_doc, "quot[ient] of dividing numerator by denominator.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1266), kw_end_DASH_line, int(1266))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Quotient") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Quotient is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_quot = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_quot.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // range + { + tmp0 := sym_range.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_end), lang.NewVector(sym_start, sym_end), lang.NewVector(sym_start, sym_end, sym_step)), kw_doc, "Returns a lazy seq of nums from start (inclusive) to end\n (exclusive), by step, where start defaults to 0, step to 1, and end to\n infinity. When step is equal to 0, returns an infinite sequence of\n start. When start is equal to end, returns empty list.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3018), kw_end_DASH_line, int(3018))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp2 := checkDerefVar(var_glojure_DOT_core_iterate) + tmp3 := checkDerefVar(var_glojure_DOT_core_inc_TICK_) + tmp4 := lang.Apply(tmp2, []any{tmp3, int64(0)}) + return tmp4 + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + tmp6 := lang.Apply(lang.NewLongRange, []any{int64(0), v2, int64(1)}) + tmp3 = tmp6 + } else { + tmp7 := lang.Apply(lang.NewRange, []any{int64(0), v2, int64(1)}) + tmp3 = tmp7 + } + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + var tmp5 any + { // let + // let binding "and__0__auto__" + tmp6 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) + tmp7 := lang.Apply(tmp6, []any{v2}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + tmp10 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) + tmp11 := lang.Apply(tmp10, []any{v3}) + tmp9 = tmp11 + } else { + tmp9 = v8 + } + tmp5 = tmp9 + } // end let + if lang.IsTruthy(tmp5) { + tmp6 := lang.Apply(lang.NewLongRange, []any{v2, v3, int64(1)}) + tmp4 = tmp6 + } else { + tmp7 := lang.Apply(lang.NewRange, []any{v2, v3, int64(1)}) + tmp4 = tmp7 + } + return tmp4 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + var tmp6 any + { // let + // let binding "and__0__auto__" + tmp7 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v2}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + var tmp11 any + { // let + // let binding "and__0__auto__" + tmp12 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) + tmp13 := lang.Apply(tmp12, []any{v3}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + tmp16 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) + tmp17 := lang.Apply(tmp16, []any{v4}) + tmp15 = tmp17 + } else { + tmp15 = v14 + } + tmp11 = tmp15 + } // end let + tmp10 = tmp11 + } else { + tmp10 = v9 + } + tmp6 = tmp10 + } // end let + if lang.IsTruthy(tmp6) { + tmp7 := lang.Apply(lang.NewLongRange, []any{v2, v3, v4}) + tmp5 = tmp7 + } else { + tmp8 := lang.Apply(lang.NewRange, []any{v2, v3, v4}) + tmp5 = tmp8 + } + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_range = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_range.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // rational? + { + tmp0 := sym_rational_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_doc, "Returns true if n is a rational number", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(3613), kw_end_DASH_line, int(3613))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "or__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_integer_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + tmp7 = v6 + } else { + var tmp8 any + { // let + // let binding "or__0__auto__" + tmp9 := checkDerefVar(var_glojure_DOT_core_ratio_QMARK_) + tmp10 := lang.Apply(tmp9, []any{v2}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + tmp12 = v11 + } else { + tmp13 := checkDerefVar(var_glojure_DOT_core_decimal_QMARK_) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp12 = tmp14 + } + tmp8 = tmp12 + } // end let + tmp7 = tmp8 + } + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_rational_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_rational_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reduce1 + { + tmp0 := sym_reduce1.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(923), kw_column, int(7), kw_end_DASH_line, int(924), kw_end_DASH_column, int(9), kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_coll), lang.NewVector(sym_f, sym_val, sym_coll)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "s" + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := lang.Apply(tmp5, []any{v3}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + if lang.IsTruthy(v7) { + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v7}) + tmp12 := checkDerefVar(var_glojure_DOT_core_next) + tmp13 := lang.Apply(tmp12, []any{v7}) + tmp14 := lang.Apply(tmp9, []any{v2, tmp11, tmp13}) + tmp8 = tmp14 + } else { + tmp15 := lang.Apply(v2, nil) + tmp8 = tmp15 + } + tmp4 = tmp8 + } // end let + return tmp4 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + recur_loop_1696: + var tmp5 any + { // let + // let binding "s" + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := lang.Apply(tmp6, []any{v4}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + var tmp10 any + tmp11 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp12 := lang.Apply(tmp11, []any{v8}) + if lang.IsTruthy(tmp12) { + var tmp13 any = v2 + tmp15 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp16 := lang.Apply(tmp15, []any{v8}) + tmp17, _ := lang.FieldOrMethod(tmp16, "ReduceInit") + if reflect.TypeOf(tmp17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) + } + tmp18 := lang.Apply(tmp17, []any{v2, v3}) + var tmp14 any = tmp18 + tmp20 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_next) + tmp21 := lang.Apply(tmp20, []any{v8}) + var tmp19 any = tmp21 + v2 = tmp13 + v3 = tmp14 + v4 = tmp19 + goto recur_loop_1696 + } else { + var tmp22 any = v2 + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v8}) + tmp26 := lang.Apply(v2, []any{v3, tmp25}) + var tmp23 any = tmp26 + tmp28 := checkDerefVar(var_glojure_DOT_core_next) + tmp29 := lang.Apply(tmp28, []any{v8}) + var tmp27 any = tmp29 + v2 = tmp22 + v3 = tmp23 + v4 = tmp27 + goto recur_loop_1696 + } + tmp9 = tmp10 + } else { + tmp9 = v3 + } + tmp5 = tmp9 + } // end let + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_reduce1 = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_reduce1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reduced? + { + var tmp1 lang.FnFunc + { // function reduced?__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_IsReduced}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{v3}) + tmp10 := lang.Apply(tmp5, []any{tmp7, tmp9}) + tmp11 := lang.Apply(tmp4, []any{tmp10}) + return tmp11 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_reduced_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns true if x is the result of a call to reduced", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1)})), kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(2834), kw_end_DASH_line, int(2834))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.IsReduced, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_reduced_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_reduced_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reductions + { + tmp0 := sym_reductions.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_coll), lang.NewVector(sym_f, sym_init, sym_coll)), kw_doc, "Returns a lazy seq of the intermediate values of the reduction (as\n per reduce) of coll by f, starting with init.", kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(7196), kw_end_DASH_line, int(7196))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp5 any + { // let + // let binding "temp__0__auto__" + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := lang.Apply(tmp6, []any{v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + var tmp10 any + { // let + // let binding "s" + var v11 any = v8 + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_reductions) + tmp13 := checkDerefVar(var_glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v11}) + tmp15 := checkDerefVar(var_glojure_DOT_core_rest) + tmp16 := lang.Apply(tmp15, []any{v11}) + tmp17 := lang.Apply(tmp12, []any{v2, tmp14, tmp16}) + tmp10 = tmp17 + } // end let + tmp9 = tmp10 + } else { + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(v2, nil) + tmp13 := lang.Apply(tmp11, []any{tmp12}) + tmp9 = tmp13 + } + tmp5 = tmp9 + } // end let + return tmp5 + }) + tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) + return tmp5 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) + tmp7 := lang.Apply(tmp6, []any{v3}) + if lang.IsTruthy(tmp7) { + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := checkDerefVar(var_glojure_DOT_core_deref) + tmp10 := lang.Apply(tmp9, []any{v3}) + tmp11 := lang.Apply(tmp8, []any{tmp10}) + tmp5 = tmp11 + } else { + tmp12 := checkDerefVar(var_glojure_DOT_core_cons) + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp14 any + { // let + // let binding "temp__0__auto__" + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := lang.Apply(tmp15, []any{v4}) + var v17 any = tmp16 + _ = v17 + var tmp18 any + if lang.IsTruthy(v17) { + var tmp19 any + { // let + // let binding "s" + var v20 any = v17 + _ = v20 + tmp21 := checkDerefVar(var_glojure_DOT_core_reductions) + tmp22 := checkDerefVar(var_glojure_DOT_core_first) + tmp23 := lang.Apply(tmp22, []any{v20}) + tmp24 := lang.Apply(v2, []any{v3, tmp23}) + tmp25 := checkDerefVar(var_glojure_DOT_core_rest) + tmp26 := lang.Apply(tmp25, []any{v20}) + tmp27 := lang.Apply(tmp21, []any{v2, tmp24, tmp26}) + tmp19 = tmp27 + } // end let + tmp18 = tmp19 + } else { + } + tmp14 = tmp18 + } // end let + return tmp14 + }) + tmp14 := lang.Apply(lang.NewLazySeq, []any{tmp13}) + tmp15 := lang.Apply(tmp12, []any{v3, tmp14}) + tmp5 = tmp15 + } + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_reductions = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_reductions.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // refer-glojure + { + tmp0 := sym_refer_DASH_glojure.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_filters)), kw_doc, "Same as (refer 'glojure.core )", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(11), kw_line, int(5800), kw_end_DASH_line, int(5800))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym_glojure_DOT_core_SLASH_refer}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := checkDerefVar(var_glojure_DOT_core_seq) + tmp11 := checkDerefVar(var_glojure_DOT_core_concat) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_quote}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core}) + tmp16 := lang.Apply(tmp11, []any{tmp13, tmp15}) + tmp17 := lang.Apply(tmp10, []any{tmp16}) + tmp18 := lang.Apply(tmp9, []any{tmp17}) + tmp19 := lang.Apply(tmp6, []any{tmp8, tmp18, v4}) + tmp20 := lang.Apply(tmp5, []any{tmp19}) + return tmp20 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_refer_DASH_glojure = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_refer_DASH_glojure.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // rem + { + var tmp1 lang.FnFunc + { // function rem__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Remainder}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_rem.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_num, sym_div)), kw_inline, tmp1, kw_doc, "remainder of dividing numerator by denominator.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(1274), kw_end_DASH_line, int(1274))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Remainder") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Remainder is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_rem = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_rem.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // remove-tap + { + tmp0 := sym_remove_DASH_tap.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f)), kw_doc, "Remove f from the tap set.", kw_file, "glojure/core.glj", kw_added, "1.10", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(7883), kw_end_DASH_line, int(7883))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_swap_BANG_) + tmp4 := checkDerefVar(var_glojure_DOT_core_tapset) + tmp5 := checkDerefVar(var_glojure_DOT_core_disj) + tmp6 := lang.Apply(tmp3, []any{tmp4, tmp5, v2}) + _ = tmp6 + return nil + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_remove_DASH_tap = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_remove_DASH_tap.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // resolve + { + tmp0 := sym_resolve.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_sym), lang.NewVector(sym_env, sym_sym)), kw_doc, "same as (ns-resolve *ns* symbol) or (ns-resolve *ns* &env symbol)", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4371), kw_end_DASH_line, int(4371))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_ns_DASH_resolve) + tmp4 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_ns_DASH_resolve) + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp6 := lang.Apply(tmp4, []any{tmp5, v2, v3}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_resolve = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_resolve.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reverse + { + tmp0 := sym_reverse.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a seq of the items in coll in reverse order. Not lazy.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(940), kw_end_DASH_line, int(940))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp4 := checkDerefVar(var_glojure_DOT_core_conj) + tmp5 := lang.Apply(tmp3, []any{tmp4, lang.NewList(), v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_reverse = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_reverse.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // root-resource + { + tmp1 := reflect.TypeOf("") + tmp0 := sym_root_DASH_resource.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_lib)), kw_doc, "Returns the root directory path for a lib", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(8), kw_line, int(5864), kw_end_DASH_line, int(5864), kw_private, true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_str) + tmp5 := checkDerefVar(var_glojure_DOT_core_name) + tmp6 := lang.Apply(tmp5, []any{v3}) + tmp7 := lang.Apply(strings8.ReplaceAll, []any{tmp6, "-", "_"}) + tmp8 := lang.Apply(strings8.ReplaceAll, []any{tmp7, ".", "/"}) + tmp9 := lang.Apply(tmp4, []any{lang.NewChar(47), tmp8}) + return tmp9 + }) + tmp3 := reflect.TypeOf("") + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_root_DASH_resource = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_root_DASH_resource.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // select-keys + { + tmp0 := sym_select_DASH_keys.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_map, sym_keyseq)), kw_doc, "Returns a map containing only those entries in map whose key is in keys", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(1536), kw_end_DASH_line, int(1536))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "ret" + tmp5 := lang.NewMap() + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(1541), kw_column, int(16), kw_end_DASH_line, int(1541), kw_end_DASH_column, int(17)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v8 any = tmp7 + _ = v8 + // let binding "keys" + tmp9 := checkDerefVar(var_glojure_DOT_core_seq) + tmp10 := lang.Apply(tmp9, []any{v3}) + var v11 any = tmp10 + _ = v11 + for { + var tmp12 any + if lang.IsTruthy(v11) { + var tmp13 any + { // let + // let binding "entry" + tmp14 := checkDerefVar(var_glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v11}) + tmp16, _ := lang.FieldOrMethod(runtime.RT, "Find") + if reflect.TypeOf(tmp16).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Find is not a function"))) + } + tmp17 := lang.Apply(tmp16, []any{v2, tmp15}) + var v18 any = tmp17 + _ = v18 + var tmp20 any + if lang.IsTruthy(v18) { + tmp21 := checkDerefVar(var_glojure_DOT_core_conj) + tmp22 := lang.Apply(tmp21, []any{v8, v18}) + tmp20 = tmp22 + } else { + tmp20 = v8 + } + var tmp19 any = tmp20 + tmp24 := checkDerefVar(var_glojure_DOT_core_next) + tmp25 := lang.Apply(tmp24, []any{v11}) + var tmp23 any = tmp25 + v8 = tmp19 + v11 = tmp23 + continue + } // end let + tmp12 = tmp13 + } else { + tmp14 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp15 := checkDerefVar(var_glojure_DOT_core_meta) + tmp16 := lang.Apply(tmp15, []any{v2}) + tmp17 := lang.Apply(tmp14, []any{v8, tmp16}) + tmp12 = tmp17 + } + tmp4 = tmp12 + break + } + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_select_DASH_keys = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_select_DASH_keys.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // seq-to-map-for-destructuring + { + tmp0 := sym_seq_DASH_to_DASH_map_DASH_for_DASH_destructuring.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_doc, "Builds a map from a seq as described in\n https://glojure.org/reference/special_forms#keyword-arguments", kw_file, "glojure/core.glj", kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(34), kw_column, int(7), kw_line, int(4390), kw_end_DASH_line, int(4390))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_next) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + tmp6 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) + tmp7 := lang.Apply(tmp6, []any{v2}) + tmp8 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{tmp7}) + tmp3 = tmp8 + } else { + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_seq) + tmp11 := lang.Apply(tmp10, []any{v2}) + if lang.IsTruthy(tmp11) { + tmp12 := checkDerefVar(var_glojure_DOT_core_first) + tmp13 := lang.Apply(tmp12, []any{v2}) + tmp9 = tmp13 + } else { + } + tmp3 = tmp9 + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_seq_DASH_to_DASH_map_DASH_for_DASH_destructuring = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_seq_DASH_to_DASH_map_DASH_for_DASH_destructuring.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // set + { + tmp0 := sym_set.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a set of the distinct elements of coll.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(4104), kw_end_DASH_line, int(4104))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_set_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + tmp6 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp7 := lang.Apply(tmp6, []any{v2, nil}) + tmp3 = tmp7 + } else { + var tmp8 any + tmp9 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp10 := reflect.TypeOf((*lang.IReduceInit)(nil)).Elem() + tmp11 := lang.Apply(tmp9, []any{tmp10, v2}) + if lang.IsTruthy(tmp11) { + tmp12 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp13 := checkDerefVar(var_glojure_DOT_core_conj_BANG_) + tmp14 := checkDerefVar(var_glojure_DOT_core_transient) + tmp15 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4112), kw_column, int(108), kw_end_DASH_line, int(4112), kw_end_DASH_column, int(110)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp18 := lang.Apply(tmp14, []any{tmp17}) + tmp19, _ := lang.FieldOrMethod(v2, "ReduceInit") + if reflect.TypeOf(tmp19).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) + } + tmp20 := lang.Apply(tmp19, []any{tmp13, tmp18}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp8 = tmp21 + } else { + tmp22 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp23 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp24 := checkDerefVar(var_glojure_DOT_core_conj_BANG_) + tmp25 := checkDerefVar(var_glojure_DOT_core_transient) + tmp26 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp27 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4113), kw_column, int(46), kw_end_DASH_line, int(4113), kw_end_DASH_column, int(48)) + tmp28, err := lang.WithMeta(tmp26, tmp27.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp29 := lang.Apply(tmp25, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp24, tmp29, v2}) + tmp31 := lang.Apply(tmp22, []any{tmp30}) + tmp8 = tmp31 + } + tmp3 = tmp8 + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_set = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_set.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // short + { + var tmp1 lang.FnFunc + { // function short__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp15) { + tmp14 = sym_uncheckedShortCast + } else { + tmp14 = sym_shortCast + } + tmp16 := lang.Apply(tmp13, []any{tmp14}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := lang.Apply(tmp12, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp11, []any{tmp19}) + tmp21 := lang.Apply(tmp10, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_short.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to short", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3499), kw_end_DASH_line, int(3499))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.ShortCast, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_short = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_short.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // short-array + { + var tmp1 lang.FnFunc + { // function short-array__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_ShortArray}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_unquote_DASH_splicing}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_glojure_DOT_core_SLASH_args}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + } + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_short_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_size_DASH_or_DASH_seq), lang.NewVector(sym_size, sym_init_DASH_val_DASH_or_DASH_seq)), kw_inline, tmp1, kw_doc, "Creates an array of shorts", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(5333), kw_end_DASH_line, int(5333))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "ShortArray") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ShortArray is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "ShortArrayInit") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ShortArrayInit is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_short_DASH_array = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_short_DASH_array.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // shorts + { + var tmp1 lang.FnFunc + { // function shorts + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Shorts}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_shorts.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xs)), kw_inline, tmp1, kw_doc, "Casts to shorts[]", kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(12), kw_line, int(5387), kw_end_DASH_line, int(5387))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Shorts") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Shorts is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_shorts = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_shorts.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // shuffle + { + tmp0 := sym_shuffle.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Return a random permutation of coll", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(7300), kw_end_DASH_line, int(7300))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "al" + tmp4 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) + tmp5 := lang.Apply(tmp4, []any{v2}) + tmp6 := lang.Apply(lang.NewArrayList, []any{tmp5}) + var v7 any = tmp6 + _ = v7 + tmp8 := lang.Apply(nil, []any{v7}) + _ = tmp8 + tmp9, ok := lang.FieldOrMethod(v7, "toArray") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "toArray"))) + } + var tmp10 any + switch reflect.TypeOf(tmp9).Kind() { + case reflect.Func: + tmp10 = lang.Apply(tmp9, nil) + default: + tmp10 = tmp9 + } + tmp11 := lang.Apply(nil, []any{tmp10}) + tmp3 = tmp11 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_shuffle = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_shuffle.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // sigs + { + tmp0 := sym_sigs.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(223), kw_column, int(2), kw_end_DASH_line, int(224), kw_end_DASH_column, int(5), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_assert_DASH_valid_DASH_fdecl) + tmp4 := lang.Apply(tmp3, []any{v2}) + _ = tmp4 + var tmp5 any + { // let + // let binding "asig" + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v7 := args[0] + _ = v7 + var tmp8 any + { // let + // let binding "arglist" + tmp9 := checkDerefVar(var_glojure_DOT_core_first) + tmp10 := lang.Apply(tmp9, []any{v7}) + var v11 any = tmp10 + _ = v11 + // let binding "arglist" + var tmp12 any + tmp13 := checkDerefVar(var_glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v11}) + tmp15 := lang.Apply(lang.Equals, []any{sym__AMP_form, tmp14}) + if lang.IsTruthy(tmp15) { + tmp16 := lang.Apply(lang.Count, []any{v11}) + tmp17 := lang.Apply(lang.Subvec, []any{v11, int64(2), tmp16}) + tmp12 = tmp17 + } else { + tmp12 = v11 + } + var v18 any = tmp12 + _ = v18 + // let binding "body" + tmp19 := checkDerefVar(var_glojure_DOT_core_next) + tmp20 := lang.Apply(tmp19, []any{v7}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + tmp23 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v21}) + tmp26 := lang.Apply(tmp23, []any{tmp25}) + if lang.IsTruthy(tmp26) { + var tmp27 any + tmp28 := checkDerefVar(var_glojure_DOT_core_next) + tmp29 := lang.Apply(tmp28, []any{v21}) + if lang.IsTruthy(tmp29) { + tmp30 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp31 := checkDerefVar(var_glojure_DOT_core_conj) + var tmp32 any + tmp33 := checkDerefVar(var_glojure_DOT_core_meta) + tmp34 := lang.Apply(tmp33, []any{v18}) + if lang.IsTruthy(tmp34) { + tmp35 := checkDerefVar(var_glojure_DOT_core_meta) + tmp36 := lang.Apply(tmp35, []any{v18}) + tmp32 = tmp36 + } else { + tmp37 := lang.NewMap() + tmp38 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(237), kw_column, int(77), kw_end_DASH_line, int(237), kw_end_DASH_column, int(78)) + tmp39, err := lang.WithMeta(tmp37, tmp38.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp32 = tmp39 + } + tmp40 := checkDerefVar(var_glojure_DOT_core_first) + tmp41 := lang.Apply(tmp40, []any{v21}) + tmp42 := lang.Apply(tmp31, []any{tmp32, tmp41}) + tmp43 := lang.Apply(tmp30, []any{v18, tmp42}) + tmp27 = tmp43 + } else { + tmp27 = v18 + } + tmp22 = tmp27 + } else { + tmp22 = v18 + } + tmp8 = tmp22 + } // end let + return tmp8 + }) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(228), kw_column, int(10), kw_end_DASH_line, int(239), kw_end_DASH_column, int(25)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v9 any = tmp8 + _ = v9 + // let binding "resolve-tag" + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v11 := args[0] + _ = v11 + var tmp12 any + { // let + // let binding "m" + tmp13 := checkDerefVar(var_glojure_DOT_core_meta) + tmp14 := lang.Apply(tmp13, []any{v11}) + var v15 any = tmp14 + _ = v15 + // let binding "tag" + tmp16 := lang.Apply(kw_tag, []any{v15}) + var v17 any = tmp16 + _ = v17 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp20 := reflect.TypeOf((*lang.Symbol)(nil)) + tmp21 := lang.Apply(tmp19, []any{tmp20, v17}) + if lang.IsTruthy(tmp21) { + var tmp22 any + tmp23, ok := lang.FieldOrMethod(v17, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v17, "Name"))) + } + var tmp24 any + switch reflect.TypeOf(tmp23).Kind() { + case reflect.Func: + tmp24 = lang.Apply(tmp23, nil) + default: + tmp24 = tmp23 + } + tmp25 := lang.Apply(strings8.Index, []any{tmp24, "."}) + tmp26 := lang.Apply(lang.Equiv, []any{tmp25, int64(-1)}) + if lang.IsTruthy(tmp26) { + var tmp27 any + tmp28 := lang.Apply(lang.Equals, []any{nil, nil}) + if lang.IsTruthy(tmp28) { + var tmp29 any + { // let + // let binding "c" + var v30 any = nil + _ = v30 + var tmp31 any + if lang.IsTruthy(v30) { + tmp32 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp33 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp34, ok := lang.FieldOrMethod(v30, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v30, "Name"))) + } + var tmp35 any + switch reflect.TypeOf(tmp34).Kind() { + case reflect.Func: + tmp35 = lang.Apply(tmp34, nil) + default: + tmp35 = tmp34 + } + tmp36 := lang.Apply(lang.NewSymbol, []any{tmp35}) + tmp37 := lang.Apply(tmp33, []any{v15, kw_tag, tmp36}) + tmp38 := lang.Apply(tmp32, []any{v11, tmp37}) + tmp31 = tmp38 + } else { + tmp31 = v11 + } + tmp29 = tmp31 + } // end let + tmp27 = tmp29 + } else { + tmp27 = v11 + } + tmp22 = tmp27 + } else { + tmp22 = v11 + } + tmp18 = tmp22 + } else { + tmp18 = v11 + } + tmp12 = tmp18 + } // end let + return tmp12 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(240), kw_column, int(22), kw_end_DASH_line, int(252), kw_end_DASH_column, int(37)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v13 any = tmp12 + _ = v13 + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp16 := checkDerefVar(var_glojure_DOT_core_first) + tmp17 := lang.Apply(tmp16, []any{v2}) + tmp18 := lang.Apply(tmp15, []any{tmp17}) + if lang.IsTruthy(tmp18) { + var tmp19 any + { // let + // let binding "ret" + tmp20 := lang.NewVector() + tmp21 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(254), kw_column, int(19), kw_end_DASH_line, int(254), kw_end_DASH_column, int(20)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v23 any = tmp22 + _ = v23 + // let binding "fdecls" + var v24 any = v2 + _ = v24 + for { + var tmp25 any + if lang.IsTruthy(v24) { + tmp27 := checkDerefVar(var_glojure_DOT_core_conj) + tmp28 := checkDerefVar(var_glojure_DOT_core_first) + tmp29 := lang.Apply(tmp28, []any{v24}) + tmp30 := lang.Apply(v9, []any{tmp29}) + tmp31 := lang.Apply(v13, []any{tmp30}) + tmp32 := lang.Apply(tmp27, []any{v23, tmp31}) + var tmp26 any = tmp32 + tmp34 := checkDerefVar(var_glojure_DOT_core_next) + tmp35 := lang.Apply(tmp34, []any{v24}) + var tmp33 any = tmp35 + v23 = tmp26 + v24 = tmp33 + continue + } else { + tmp36 := checkDerefVar(var_glojure_DOT_core_seq) + tmp37 := lang.Apply(tmp36, []any{v23}) + tmp25 = tmp37 + } + tmp19 = tmp25 + break + } + } // end let + tmp14 = tmp19 + } else { + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(v9, []any{v2}) + tmp22 := lang.Apply(v13, []any{tmp21}) + tmp23 := lang.Apply(tmp20, []any{tmp22}) + tmp14 = tmp23 + } + tmp5 = tmp14 + } // end let + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(225), kw_column, int(2), kw_end_DASH_line, int(258), kw_end_DASH_column, int(43))).(lang.FnFunc) + var_glojure_DOT_core_sigs = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_sigs.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // simple-ident? + { + tmp0 := sym_simple_DASH_ident_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a symbol or keyword without a namespace", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(1613), kw_end_DASH_line, int(1613))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "and__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_ident_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + tmp8 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp9 := checkDerefVar(var_glojure_DOT_core_namespace) + tmp10 := lang.Apply(tmp9, []any{v2}) + tmp11 := lang.Apply(tmp8, []any{tmp10}) + tmp7 = tmp11 + } else { + tmp7 = v6 + } + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_simple_DASH_ident_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_simple_DASH_ident_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // simple-symbol? + { + tmp0 := sym_simple_DASH_symbol_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a symbol without a namespace", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(1623), kw_end_DASH_line, int(1623))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "and__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + tmp8 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp9 := checkDerefVar(var_glojure_DOT_core_namespace) + tmp10 := lang.Apply(tmp9, []any{v2}) + tmp11 := lang.Apply(tmp8, []any{tmp10}) + tmp7 = tmp11 + } else { + tmp7 = v6 + } + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_simple_DASH_symbol_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_simple_DASH_symbol_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // some-fn + { + tmp0 := sym_some_DASH_fn.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_p), lang.NewVector(sym_p1, sym_p2), lang.NewVector(sym_p1, sym_p2, sym_p3), lang.NewVector(sym_p1, sym_p2, sym_p3, sym__AMP_, sym_ps)), kw_doc, "Takes a set of predicates and returns a function f that returns the first logical true value\n returned by one of its composing predicates against any of its arguments, else it returns\n logical false. Note that f is short-circuiting in that it will stop execution on the first\n argument that triggers a logical true result against the original predicates.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(7462), kw_end_DASH_line, int(7462))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + { // function sp1 + var v4 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return nil + case 1: + v5 := args[0] + _ = v5 + tmp6 := lang.Apply(v2, []any{v5}) + return tmp6 + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + var tmp7 any + { // let + // let binding "or__0__auto__" + tmp8 := lang.Apply(v2, []any{v5}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + tmp10 = v9 + } else { + tmp11 := lang.Apply(v2, []any{v6}) + tmp10 = tmp11 + } + tmp7 = tmp10 + } // end let + return tmp7 + case 3: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := args[2] + _ = v7 + var tmp8 any + { // let + // let binding "or__0__auto__" + tmp9 := lang.Apply(v2, []any{v5}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + if lang.IsTruthy(v10) { + tmp11 = v10 + } else { + var tmp12 any + { // let + // let binding "or__0__auto__" + tmp13 := lang.Apply(v2, []any{v6}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + tmp15 = v14 + } else { + tmp16 := lang.Apply(v2, []any{v7}) + tmp15 = tmp16 + } + tmp12 = tmp15 + } // end let + tmp11 = tmp12 + } + tmp8 = tmp11 + } // end let + return tmp8 + default: + checkArity(args, 3) + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := args[2] + _ = v7 + var v8 any = lang.NewList(args[3:]...) + _ = v8 + var tmp9 any + { // let + // let binding "or__0__auto__" + tmp10 := lang.Apply(v4, []any{v5, v6, v7}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + tmp12 = v11 + } else { + tmp13 := checkDerefVar(var_glojure_DOT_core_some) + tmp14 := lang.Apply(tmp13, []any{v2, v8}) + tmp12 = tmp14 + } + tmp9 = tmp12 + } // end let + return tmp9 + } + }) + v4 = tmp3 + _ = v4 + } + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7469), kw_column, int(6), kw_end_DASH_line, int(7475), kw_end_DASH_column, int(43)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + { // function sp2 + var v5 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return nil + case 1: + v6 := args[0] + _ = v6 + var tmp7 any + { // let + // let binding "or__0__auto__" + tmp8 := lang.Apply(v2, []any{v6}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + tmp10 = v9 + } else { + tmp11 := lang.Apply(v3, []any{v6}) + tmp10 = tmp11 + } + tmp7 = tmp10 + } // end let + return tmp7 + case 2: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + var tmp8 any + { // let + // let binding "or__0__auto__" + tmp9 := lang.Apply(v2, []any{v6}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + if lang.IsTruthy(v10) { + tmp11 = v10 + } else { + var tmp12 any + { // let + // let binding "or__0__auto__" + tmp13 := lang.Apply(v2, []any{v7}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + tmp15 = v14 + } else { + var tmp16 any + { // let + // let binding "or__0__auto__" + tmp17 := lang.Apply(v3, []any{v6}) + var v18 any = tmp17 + _ = v18 + var tmp19 any + if lang.IsTruthy(v18) { + tmp19 = v18 + } else { + tmp20 := lang.Apply(v3, []any{v7}) + tmp19 = tmp20 + } + tmp16 = tmp19 + } // end let + tmp15 = tmp16 + } + tmp12 = tmp15 + } // end let + tmp11 = tmp12 + } + tmp8 = tmp11 + } // end let + return tmp8 + case 3: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + var tmp9 any + { // let + // let binding "or__0__auto__" + tmp10 := lang.Apply(v2, []any{v6}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + tmp12 = v11 + } else { + var tmp13 any + { // let + // let binding "or__0__auto__" + tmp14 := lang.Apply(v2, []any{v7}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + if lang.IsTruthy(v15) { + tmp16 = v15 + } else { + var tmp17 any + { // let + // let binding "or__0__auto__" + tmp18 := lang.Apply(v2, []any{v8}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + tmp20 = v19 + } else { + var tmp21 any + { // let + // let binding "or__0__auto__" + tmp22 := lang.Apply(v3, []any{v6}) + var v23 any = tmp22 + _ = v23 + var tmp24 any + if lang.IsTruthy(v23) { + tmp24 = v23 + } else { + var tmp25 any + { // let + // let binding "or__0__auto__" + tmp26 := lang.Apply(v3, []any{v7}) + var v27 any = tmp26 + _ = v27 + var tmp28 any + if lang.IsTruthy(v27) { + tmp28 = v27 + } else { + tmp29 := lang.Apply(v3, []any{v8}) + tmp28 = tmp29 + } + tmp25 = tmp28 + } // end let + tmp24 = tmp25 + } + tmp21 = tmp24 + } // end let + tmp20 = tmp21 + } + tmp17 = tmp20 + } // end let + tmp16 = tmp17 + } + tmp13 = tmp16 + } // end let + tmp12 = tmp13 + } + tmp9 = tmp12 + } // end let + return tmp9 + default: + checkArity(args, 3) + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + var v9 any = lang.NewList(args[3:]...) + _ = v9 + var tmp10 any + { // let + // let binding "or__0__auto__" + tmp11 := lang.Apply(v5, []any{v6, v7, v8}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + tmp13 = v12 + } else { + tmp14 := checkDerefVar(var_glojure_DOT_core_some) + var tmp15 lang.FnFunc + tmp15 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v16 := args[0] + _ = v16 + var tmp17 any + { // let + // let binding "or__0__auto__" + tmp18 := lang.Apply(v2, []any{v16}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + tmp20 = v19 + } else { + tmp21 := lang.Apply(v3, []any{v16}) + tmp20 = tmp21 + } + tmp17 = tmp20 + } // end let + return tmp17 + }) + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7483), kw_column, int(34), kw_end_DASH_line, int(7483), kw_end_DASH_column, int(52)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp18 := lang.Apply(tmp14, []any{tmp17, v9}) + tmp13 = tmp18 + } + tmp10 = tmp13 + } // end let + return tmp10 + } + }) + v5 = tmp4 + _ = v5 + } + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7477), kw_column, int(6), kw_end_DASH_line, int(7483), kw_end_DASH_column, int(61)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 lang.FnFunc + { // function sp3 + var v6 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return nil + case 1: + v7 := args[0] + _ = v7 + var tmp8 any + { // let + // let binding "or__0__auto__" + tmp9 := lang.Apply(v2, []any{v7}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + if lang.IsTruthy(v10) { + tmp11 = v10 + } else { + var tmp12 any + { // let + // let binding "or__0__auto__" + tmp13 := lang.Apply(v3, []any{v7}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + tmp15 = v14 + } else { + tmp16 := lang.Apply(v4, []any{v7}) + tmp15 = tmp16 + } + tmp12 = tmp15 + } // end let + tmp11 = tmp12 + } + tmp8 = tmp11 + } // end let + return tmp8 + case 2: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + var tmp9 any + { // let + // let binding "or__0__auto__" + tmp10 := lang.Apply(v2, []any{v7}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + tmp12 = v11 + } else { + var tmp13 any + { // let + // let binding "or__0__auto__" + tmp14 := lang.Apply(v2, []any{v8}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + if lang.IsTruthy(v15) { + tmp16 = v15 + } else { + var tmp17 any + { // let + // let binding "or__0__auto__" + tmp18 := lang.Apply(v3, []any{v7}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + tmp20 = v19 + } else { + var tmp21 any + { // let + // let binding "or__0__auto__" + tmp22 := lang.Apply(v3, []any{v8}) + var v23 any = tmp22 + _ = v23 + var tmp24 any + if lang.IsTruthy(v23) { + tmp24 = v23 + } else { + var tmp25 any + { // let + // let binding "or__0__auto__" + tmp26 := lang.Apply(v4, []any{v7}) + var v27 any = tmp26 + _ = v27 + var tmp28 any + if lang.IsTruthy(v27) { + tmp28 = v27 + } else { + tmp29 := lang.Apply(v4, []any{v8}) + tmp28 = tmp29 + } + tmp25 = tmp28 + } // end let + tmp24 = tmp25 + } + tmp21 = tmp24 + } // end let + tmp20 = tmp21 + } + tmp17 = tmp20 + } // end let + tmp16 = tmp17 + } + tmp13 = tmp16 + } // end let + tmp12 = tmp13 + } + tmp9 = tmp12 + } // end let + return tmp9 + case 3: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + var tmp10 any + { // let + // let binding "or__0__auto__" + tmp11 := lang.Apply(v2, []any{v7}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + tmp13 = v12 + } else { + var tmp14 any + { // let + // let binding "or__0__auto__" + tmp15 := lang.Apply(v2, []any{v8}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + if lang.IsTruthy(v16) { + tmp17 = v16 + } else { + var tmp18 any + { // let + // let binding "or__0__auto__" + tmp19 := lang.Apply(v2, []any{v9}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + tmp21 = v20 + } else { + var tmp22 any + { // let + // let binding "or__0__auto__" + tmp23 := lang.Apply(v3, []any{v7}) + var v24 any = tmp23 + _ = v24 + var tmp25 any + if lang.IsTruthy(v24) { + tmp25 = v24 + } else { + var tmp26 any + { // let + // let binding "or__0__auto__" + tmp27 := lang.Apply(v3, []any{v8}) + var v28 any = tmp27 + _ = v28 + var tmp29 any + if lang.IsTruthy(v28) { + tmp29 = v28 + } else { + var tmp30 any + { // let + // let binding "or__0__auto__" + tmp31 := lang.Apply(v3, []any{v9}) + var v32 any = tmp31 + _ = v32 + var tmp33 any + if lang.IsTruthy(v32) { + tmp33 = v32 + } else { + var tmp34 any + { // let + // let binding "or__0__auto__" + tmp35 := lang.Apply(v4, []any{v7}) + var v36 any = tmp35 + _ = v36 + var tmp37 any + if lang.IsTruthy(v36) { + tmp37 = v36 + } else { + var tmp38 any + { // let + // let binding "or__0__auto__" + tmp39 := lang.Apply(v4, []any{v8}) + var v40 any = tmp39 + _ = v40 + var tmp41 any + if lang.IsTruthy(v40) { + tmp41 = v40 + } else { + tmp42 := lang.Apply(v4, []any{v9}) + tmp41 = tmp42 + } + tmp38 = tmp41 + } // end let + tmp37 = tmp38 + } + tmp34 = tmp37 + } // end let + tmp33 = tmp34 + } + tmp30 = tmp33 + } // end let + tmp29 = tmp30 + } + tmp26 = tmp29 + } // end let + tmp25 = tmp26 + } + tmp22 = tmp25 + } // end let + tmp21 = tmp22 + } + tmp18 = tmp21 + } // end let + tmp17 = tmp18 + } + tmp14 = tmp17 + } // end let + tmp13 = tmp14 + } + tmp10 = tmp13 + } // end let + return tmp10 + default: + checkArity(args, 3) + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + var v10 any = lang.NewList(args[3:]...) + _ = v10 + var tmp11 any + { // let + // let binding "or__0__auto__" + tmp12 := lang.Apply(v6, []any{v7, v8, v9}) + var v13 any = tmp12 + _ = v13 + var tmp14 any + if lang.IsTruthy(v13) { + tmp14 = v13 + } else { + tmp15 := checkDerefVar(var_glojure_DOT_core_some) + var tmp16 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v17 := args[0] + _ = v17 + var tmp18 any + { // let + // let binding "or__0__auto__" + tmp19 := lang.Apply(v2, []any{v17}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + tmp21 = v20 + } else { + var tmp22 any + { // let + // let binding "or__0__auto__" + tmp23 := lang.Apply(v3, []any{v17}) + var v24 any = tmp23 + _ = v24 + var tmp25 any + if lang.IsTruthy(v24) { + tmp25 = v24 + } else { + tmp26 := lang.Apply(v4, []any{v17}) + tmp25 = tmp26 + } + tmp22 = tmp25 + } // end let + tmp21 = tmp22 + } + tmp18 = tmp21 + } // end let + return tmp18 + }) + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7491), kw_column, int(34), kw_end_DASH_line, int(7491), kw_end_DASH_column, int(59)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp19 := lang.Apply(tmp15, []any{tmp18, v10}) + tmp14 = tmp19 + } + tmp11 = tmp14 + } // end let + return tmp11 + } + }) + v6 = tmp5 + _ = v6 + } + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7485), kw_column, int(6), kw_end_DASH_line, int(7491), kw_end_DASH_column, int(68)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp7 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "ps" + tmp7 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp8 := lang.Apply(tmp7, []any{v2, v3, v4, v5}) + var v9 any = tmp8 + _ = v9 + var tmp10 lang.FnFunc + { // function spn + var v11 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return nil + case 1: + v12 := args[0] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_some) + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v15 := args[0] + _ = v15 + tmp16 := lang.Apply(v15, []any{v12}) + return tmp16 + }) + tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7496), kw_column, int(21), kw_end_DASH_line, int(7496), kw_end_DASH_column, int(26)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp17 := lang.Apply(tmp13, []any{tmp16, v9}) + return tmp17 + case 2: + v12 := args[0] + _ = v12 + v13 := args[1] + _ = v13 + tmp14 := checkDerefVar(var_glojure_DOT_core_some) + var tmp15 lang.FnFunc + tmp15 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v16 := args[0] + _ = v16 + var tmp17 any + { // let + // let binding "or__0__auto__" + tmp18 := lang.Apply(v16, []any{v12}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + tmp20 = v19 + } else { + tmp21 := lang.Apply(v16, []any{v13}) + tmp20 = tmp21 + } + tmp17 = tmp20 + } // end let + return tmp17 + }) + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7497), kw_column, int(23), kw_end_DASH_line, int(7497), kw_end_DASH_column, int(39)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp18 := lang.Apply(tmp14, []any{tmp17, v9}) + return tmp18 + case 3: + v12 := args[0] + _ = v12 + v13 := args[1] + _ = v13 + v14 := args[2] + _ = v14 + tmp15 := checkDerefVar(var_glojure_DOT_core_some) + var tmp16 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v17 := args[0] + _ = v17 + var tmp18 any + { // let + // let binding "or__0__auto__" + tmp19 := lang.Apply(v17, []any{v12}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + tmp21 = v20 + } else { + var tmp22 any + { // let + // let binding "or__0__auto__" + tmp23 := lang.Apply(v17, []any{v13}) + var v24 any = tmp23 + _ = v24 + var tmp25 any + if lang.IsTruthy(v24) { + tmp25 = v24 + } else { + tmp26 := lang.Apply(v17, []any{v14}) + tmp25 = tmp26 + } + tmp22 = tmp25 + } // end let + tmp21 = tmp22 + } + tmp18 = tmp21 + } // end let + return tmp18 + }) + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7498), kw_column, int(25), kw_end_DASH_line, int(7498), kw_end_DASH_column, int(47)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp19 := lang.Apply(tmp15, []any{tmp18, v9}) + return tmp19 + default: + checkArity(args, 3) + v12 := args[0] + _ = v12 + v13 := args[1] + _ = v13 + v14 := args[2] + _ = v14 + var v15 any = lang.NewList(args[3:]...) + _ = v15 + var tmp16 any + { // let + // let binding "or__0__auto__" + tmp17 := lang.Apply(v11, []any{v12, v13, v14}) + var v18 any = tmp17 + _ = v18 + var tmp19 any + if lang.IsTruthy(v18) { + tmp19 = v18 + } else { + tmp20 := checkDerefVar(var_glojure_DOT_core_some) + var tmp21 lang.FnFunc + tmp21 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v22 := args[0] + _ = v22 + tmp23 := checkDerefVar(var_glojure_DOT_core_some) + tmp24 := lang.Apply(tmp23, []any{v22, v15}) + return tmp24 + }) + tmp22 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7500), kw_column, int(36), kw_end_DASH_line, int(7500), kw_end_DASH_column, int(49)) + tmp23, err := lang.WithMeta(tmp21, tmp22.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp24 := lang.Apply(tmp20, []any{tmp23, v9}) + tmp19 = tmp24 + } + tmp16 = tmp19 + } // end let + return tmp16 + } + }) + v11 = tmp10 + _ = v11 + } + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7494), kw_column, int(8), kw_end_DASH_line, int(7500), kw_end_DASH_column, int(56)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp6 = tmp12 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_some_DASH_fn = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_some_DASH_fn.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // split-with + { + tmp0 := sym_split_DASH_with.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns a vector of [(take-while pred coll) (drop-while pred coll)]", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(2990), kw_end_DASH_line, int(2990))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_take_DASH_while) + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + tmp6 := checkDerefVar(var_glojure_DOT_core_drop_DASH_while) + tmp7 := lang.Apply(tmp6, []any{v2, v3}) + tmp8 := lang.NewVector(tmp5, tmp7) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2995), kw_column, int(5), kw_end_DASH_line, int(2995), kw_end_DASH_column, int(51)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp10 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_split_DASH_with = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_split_DASH_with.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // stream-into! + { + tmp0 := sym_stream_DASH_into_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_to, sym_stream), lang.NewVector(sym_to, sym_xform, sym_stream)), kw_doc, "Returns a new coll consisting of coll with all of the items of the\n stream conjoined. This is a terminal operation on the stream.", kw_file, "glojure/core.glj", kw_added, "1.12", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(6810), kw_end_DASH_line, int(6810))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp6 := reflect.TypeOf((*lang.IEditableCollection)(nil)).Elem() + tmp7 := lang.Apply(tmp5, []any{tmp6, v2}) + if lang.IsTruthy(tmp7) { + tmp8 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp9 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp10 := checkDerefVar(var_glojure_DOT_core_stream_DASH_reduce_BANG_) + tmp11 := checkDerefVar(var_glojure_DOT_core_conj_BANG_) + tmp12 := checkDerefVar(var_glojure_DOT_core_transient) + tmp13 := lang.Apply(tmp12, []any{v2}) + tmp14 := lang.Apply(tmp10, []any{tmp11, tmp13, v3}) + tmp15 := lang.Apply(tmp9, []any{tmp14}) + tmp16 := checkDerefVar(var_glojure_DOT_core_meta) + tmp17 := lang.Apply(tmp16, []any{v2}) + tmp18 := lang.Apply(tmp8, []any{tmp15, tmp17}) + tmp4 = tmp18 + } else { + tmp19 := checkDerefVar(var_glojure_DOT_core_stream_DASH_reduce_BANG_) + tmp20 := checkDerefVar(var_glojure_DOT_core_conj) + tmp21 := lang.Apply(tmp19, []any{tmp20, v2, v3}) + tmp4 = tmp21 + } + return tmp4 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp7 := reflect.TypeOf((*lang.IEditableCollection)(nil)).Elem() + tmp8 := lang.Apply(tmp6, []any{tmp7, v2}) + if lang.IsTruthy(tmp8) { + tmp9 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp10 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp11 := checkDerefVar(var_glojure_DOT_core_stream_DASH_transduce_BANG_) + tmp12 := checkDerefVar(var_glojure_DOT_core_conj_BANG_) + tmp13 := checkDerefVar(var_glojure_DOT_core_transient) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(tmp11, []any{v3, tmp12, tmp14, v4}) + tmp16 := lang.Apply(tmp10, []any{tmp15}) + tmp17 := checkDerefVar(var_glojure_DOT_core_meta) + tmp18 := lang.Apply(tmp17, []any{v2}) + tmp19 := lang.Apply(tmp9, []any{tmp16, tmp18}) + tmp5 = tmp19 + } else { + tmp20 := checkDerefVar(var_glojure_DOT_core_stream_DASH_transduce_BANG_) + tmp21 := checkDerefVar(var_glojure_DOT_core_conj) + tmp22 := lang.Apply(tmp20, []any{v3, tmp21, v2, v4}) + tmp5 = tmp22 + } + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_stream_DASH_into_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_stream_DASH_into_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // subvec + { + tmp0 := sym_subvec.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_v, sym_start), lang.NewVector(sym_v, sym_start, sym_end)), kw_doc, "Returns a persistent vector of the items in vector from\n start (inclusive) to end (exclusive). If end is not supplied,\n defaults to (count vector). This operation is O(1) and very fast, as\n the resulting vector shares structure with the original and no\n trimming is done.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(3819), kw_end_DASH_line, int(3819))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_subvec) + tmp5 := checkDerefVar(var_glojure_DOT_core_count) + tmp6 := lang.Apply(tmp5, []any{v2}) + tmp7 := lang.Apply(tmp4, []any{v2, v3, tmp6}) + return tmp7 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5, _ := lang.FieldOrMethod(runtime.RT, "Subvec") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Subvec is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v2, v3, v4}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_subvec = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_subvec.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // symbol + { + tmp1 := reflect.TypeOf((*lang.Symbol)(nil)) + tmp0 := sym_symbol.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_name), lang.NewVector(sym_ns, sym_name)), kw_doc, "Returns a Symbol with the given namespace and name. Arity-1 works\n on strings, keywords, and vars.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(584), kw_end_DASH_line, int(584))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + tmp4 = v3 + } else { + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp9 := lang.Apply(tmp8, []any{lang.Builtins["string"], v3}) + if lang.IsTruthy(tmp9) { + tmp10 := lang.Apply(lang.NewSymbol, []any{v3}) + tmp7 = tmp10 + } else { + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp13 := reflect.TypeOf((*lang.Var)(nil)) + tmp14 := lang.Apply(tmp12, []any{tmp13, v3}) + if lang.IsTruthy(tmp14) { + tmp15, ok := lang.FieldOrMethod(v3, "toSymbol") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "toSymbol"))) + } + var tmp16 any + switch reflect.TypeOf(tmp15).Kind() { + case reflect.Func: + tmp16 = lang.Apply(tmp15, nil) + default: + tmp16 = tmp15 + } + tmp11 = tmp16 + } else { + var tmp17 any + tmp18 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp19 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() + tmp20 := lang.Apply(tmp18, []any{tmp19, v3}) + if lang.IsTruthy(tmp20) { + tmp21, ok := lang.FieldOrMethod(v3, "sym") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "sym"))) + } + var tmp22 any + switch reflect.TypeOf(tmp21).Kind() { + case reflect.Func: + tmp22 = lang.Apply(tmp21, nil) + default: + tmp22 = tmp21 + } + tmp17 = tmp22 + } else { + var tmp23 any + if lang.IsTruthy(kw_else) { + tmp24 := lang.Apply(lang.NewIllegalArgumentError, []any{"no conversion to symbol"}) + panic(tmp24) + } else { + } + tmp17 = tmp23 + } + tmp11 = tmp17 + } + tmp7 = tmp11 + } + tmp4 = tmp7 + } + return tmp4 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(lang.InternSymbol, []any{v3, v4}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp3 := reflect.TypeOf((*lang.Symbol)(nil)) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_symbol = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_symbol.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // thread-bound? + { + tmp0 := sym_thread_DASH_bound_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_vars)), kw_doc, "Returns true if all of the vars provided as arguments have thread-local bindings.\n Implies that set!'ing the provided vars will succeed. Returns true if no vars are provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(5499), kw_end_DASH_line, int(5499))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v5 := args[0] + _ = v5 + tmp6, ok := lang.FieldOrMethod(v5, "getThreadBinding") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "getThreadBinding"))) + } + var tmp7 any + switch reflect.TypeOf(tmp6).Kind() { + case reflect.Func: + tmp7 = lang.Apply(tmp6, nil) + default: + tmp7 = tmp6 + } + return tmp7 + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5505), kw_column, int(11), kw_end_DASH_line, int(5505), kw_end_DASH_column, int(78)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp7 := lang.Apply(tmp3, []any{tmp6, v2}) + return tmp7 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_thread_DASH_bound_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_thread_DASH_bound_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // type + { + tmp0 := sym_type.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns the :type metadata of x, or its Class if none", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3467), kw_end_DASH_line, int(3467))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "or__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_get) + tmp5 := checkDerefVar(var_glojure_DOT_core_meta) + tmp6 := lang.Apply(tmp5, []any{v2}) + tmp7 := lang.Apply(tmp4, []any{tmp6, kw_type}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + tmp9 = v8 + } else { + tmp10 := checkDerefVar(var_glojure_DOT_core_class) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp9 = tmp11 + } + tmp3 = tmp9 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_type = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_type.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-add + { + var tmp1 lang.FnFunc + { // function unchecked-add__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_UncheckedAdd}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_add.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Returns the sum of x and y, both long.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(1203), kw_end_DASH_line, int(1203))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedAdd") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedAdd is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_add = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_add.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-add-int + { + var tmp1 lang.FnFunc + { // function unchecked-add-int__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_add}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_add_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Returns the sum of x and y, both int.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(7), kw_line, int(1196), kw_end_DASH_line, int(1196))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_add") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_add is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_add_DASH_int = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_add_DASH_int.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-byte + { + var tmp1 lang.FnFunc + { // function unchecked-byte__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedByteCast}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_byte.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to byte. Subject to rounding or truncation.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(3517), kw_end_DASH_line, int(3517))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.UncheckedByteCast, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_byte = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_byte.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-char + { + var tmp1 lang.FnFunc + { // function unchecked-char__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedCharCast}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_char.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to char. Subject to rounding or truncation.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(3529), kw_end_DASH_line, int(3529))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(runtime.RT, "UncheckedCharCast") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedCharCast is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_char = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_char.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-dec + { + var tmp1 lang.FnFunc + { // function unchecked-dec__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedDec}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_dec.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns a number one less than x, a long.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(1175), kw_end_DASH_line, int(1175))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedDec") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedDec is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_dec = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_dec.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-dec-int + { + var tmp1 lang.FnFunc + { // function unchecked-dec-int__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_dec}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_dec_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns a number one less than x, an int.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(7), kw_line, int(1168), kw_end_DASH_line, int(1168))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_dec") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_dec is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_dec_DASH_int = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_dec_DASH_int.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-divide-int + { + var tmp1 lang.FnFunc + { // function unchecked-divide-int__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_UncheckedIntDivide}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_divide_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Returns the division of x by y, both int.\n Note - uses a primitive operator subject to truncation.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(26), kw_column, int(7), kw_line, int(1238), kw_end_DASH_line, int(1238))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedIntDivide") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedIntDivide is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_divide_DASH_int = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_divide_DASH_int.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-double + { + var tmp1 lang.FnFunc + { // function unchecked-double__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedDoubleCast}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_double.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to double. Subject to rounding.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(22), kw_column, int(7), kw_line, int(3553), kw_end_DASH_line, int(3553))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.AsFloat64, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_double = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_double.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-float + { + var tmp1 lang.FnFunc + { // function unchecked-float__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedFloatCast}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_float.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to float. Subject to rounding.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(3547), kw_end_DASH_line, int(3547))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.UncheckedFloatCast, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_float = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_float.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-inc + { + var tmp1 lang.FnFunc + { // function unchecked-inc__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Unchecked_inc}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_inc.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns a number one greater than x, a long.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(1161), kw_end_DASH_line, int(1161))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_inc") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_inc is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_inc = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_inc.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-inc-int + { + var tmp1 lang.FnFunc + { // function unchecked-inc-int__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_inc}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_inc_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns a number one greater than x, an int.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(7), kw_line, int(1154), kw_end_DASH_line, int(1154))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_inc") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_inc is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_inc_DASH_int = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_inc_DASH_int.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-int + { + var tmp1 lang.FnFunc + { // function unchecked-int__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedIntCast}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to int. Subject to rounding or truncation.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(3535), kw_end_DASH_line, int(3535))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.UncheckedIntCast, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_int = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_int.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-long + { + var tmp1 lang.FnFunc + { // function unchecked-long__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedLongCast}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_long.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to long. Subject to rounding or truncation.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(3541), kw_end_DASH_line, int(3541))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.UncheckedLongCast, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_long = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_long.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-multiply + { + var tmp1 lang.FnFunc + { // function unchecked-multiply__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_multiply}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_multiply.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Returns the product of x and y, both long.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(24), kw_column, int(7), kw_line, int(1231), kw_end_DASH_line, int(1231))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_multiply") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_multiply is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_multiply = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_multiply.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-multiply-int + { + var tmp1 lang.FnFunc + { // function unchecked-multiply-int__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_multiply}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_multiply_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Returns the product of x and y, both int.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(28), kw_column, int(7), kw_line, int(1224), kw_end_DASH_line, int(1224))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_multiply") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_multiply is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_multiply_DASH_int = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_multiply_DASH_int.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-negate + { + var tmp1 lang.FnFunc + { // function unchecked-negate__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Unchecked_minus}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_negate.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns the negation of x, a long.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(22), kw_column, int(7), kw_line, int(1189), kw_end_DASH_line, int(1189))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_negate") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_negate is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_negate = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_negate.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-negate-int + { + var tmp1 lang.FnFunc + { // function unchecked-negate-int__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_negate}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_negate_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns the negation of x, an int.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(26), kw_column, int(7), kw_line, int(1182), kw_end_DASH_line, int(1182))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_negate") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_negate is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_negate_DASH_int = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_negate_DASH_int.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-remainder-int + { + var tmp1 lang.FnFunc + { // function unchecked-remainder-int__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_remainder}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_remainder_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Returns the remainder of division of x by y, both int.\n Note - uses a primitive operator subject to truncation.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(29), kw_column, int(7), kw_line, int(1245), kw_end_DASH_line, int(1245))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_remainder") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_remainder is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_remainder_DASH_int = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_remainder_DASH_int.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-short + { + var tmp1 lang.FnFunc + { // function unchecked-short__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedShortCast}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_short.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to short. Subject to rounding or truncation.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(3523), kw_end_DASH_line, int(3523))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.UncheckedShortCast, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_short = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_short.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-subtract + { + var tmp1 lang.FnFunc + { // function unchecked-subtract__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_minus}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_subtract.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Returns the difference of x and y, both long.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(24), kw_column, int(7), kw_line, int(1217), kw_end_DASH_line, int(1217))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_minus") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_minus is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_subtract = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_subtract.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-subtract-int + { + var tmp1 lang.FnFunc + { // function unchecked-subtract-int__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_subtract}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_subtract_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Returns the difference of x and y, both int.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(28), kw_column, int(7), kw_line, int(1210), kw_end_DASH_line, int(1210))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_subtract") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_subtract is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_subtract_DASH_int = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_subtract_DASH_int.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unreduced + { + tmp0 := sym_unreduced.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "If x is reduced?, returns (deref x), else returns x", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(2847), kw_end_DASH_line, int(2847))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + tmp6 := checkDerefVar(var_glojure_DOT_core_deref) + tmp7 := lang.Apply(tmp6, []any{v2}) + tmp3 = tmp7 + } else { + tmp3 = v2 + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unreduced = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unreduced.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unsigned-bit-shift-right + { + var tmp1 lang.FnFunc + { // function unsigned-bit-shift-right__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_UnsignedShiftRight}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unsigned_DASH_bit_DASH_shift_DASH_right.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_n)), kw_inline, tmp1, kw_doc, "Bitwise shift right, without sign-extension.", kw_file, "glojure/core.glj", kw_added, "1.6", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(30), kw_column, int(7), kw_line, int(1373), kw_end_DASH_line, int(1373))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "UnsignedShiftRight") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("UnsignedShiftRight is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unsigned_DASH_bit_DASH_shift_DASH_right = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unsigned_DASH_bit_DASH_shift_DASH_right.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // vec + { + tmp0 := sym_vec.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Creates a new vector containing the contents of coll. Java arrays\n will be aliased and should not be modified.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(366), kw_end_DASH_line, int(366))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp8 := reflect.TypeOf((*lang.IObj)(nil)).Elem() + tmp9 := lang.Apply(tmp7, []any{tmp8, v2}) + if lang.IsTruthy(tmp9) { + tmp10 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp11 := lang.Apply(tmp10, []any{v2, nil}) + tmp6 = tmp11 + } else { + tmp12 := lang.Apply(lang.CreateLazilyPersistentVector, []any{v2}) + tmp6 = tmp12 + } + tmp3 = tmp6 + } else { + tmp13 := lang.Apply(lang.CreateLazilyPersistentVector, []any{v2}) + tmp3 = tmp13 + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_vec = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_vec.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // vswap! + { + tmp0 := sym_vswap_BANG_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_vol, sym_f, sym__AMP_, sym_args)), kw_doc, "Non-atomically swaps the value of the volatile as if:\n (apply f current-value-of-vol args). Returns the value that\n was swapped in.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(11), kw_line, int(2531), kw_end_DASH_line, int(2531))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var v6 any = lang.NewList(args[4:]...) + _ = v6 + var tmp7 any + { // let + // let binding "v" + tmp8 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp9 := lang.NewMap(kw_tag, sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Volatile) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2537), kw_column, int(26), kw_end_DASH_line, int(2537), kw_end_DASH_column, int(81)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp12 := lang.Apply(tmp8, []any{v4, tmp11}) + var v13 any = tmp12 + _ = v13 + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{sym__DOT_reset}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v13}) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := checkDerefVar(var_glojure_DOT_core_seq) + tmp22 := checkDerefVar(var_glojure_DOT_core_concat) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := lang.Apply(tmp23, []any{v5}) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := checkDerefVar(var_glojure_DOT_core_seq) + tmp27 := checkDerefVar(var_glojure_DOT_core_concat) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := lang.Apply(tmp28, []any{sym__DOT_Deref}) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := lang.Apply(tmp30, []any{v13}) + tmp32 := lang.Apply(tmp27, []any{tmp29, tmp31}) + tmp33 := lang.Apply(tmp26, []any{tmp32}) + tmp34 := lang.Apply(tmp25, []any{tmp33}) + tmp35 := lang.Apply(tmp22, []any{tmp24, tmp34, v6}) + tmp36 := lang.Apply(tmp21, []any{tmp35}) + tmp37 := lang.Apply(tmp20, []any{tmp36}) + tmp38 := lang.Apply(tmp15, []any{tmp17, tmp19, tmp37}) + tmp39 := lang.Apply(tmp14, []any{tmp38}) + tmp7 = tmp39 + } // end let + return tmp7 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_vswap_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_vswap_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // zero? + { + var tmp1 lang.FnFunc + { // function zero?__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_IsZero}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_zero_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_num)), kw_inline, tmp1, kw_doc, "Returns true if num is zero, else false", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(860), kw_end_DASH_line, int(860))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "IsZero") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("IsZero is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_zero_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_zero_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // zipmap + { + tmp0 := sym_zipmap.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_keys, sym_vals)), kw_doc, "Returns a map with the keys mapped to the corresponding vals.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(6583), kw_end_DASH_line, int(6583))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "map" + tmp5 := checkDerefVar(var_glojure_DOT_core_transient) + tmp6 := lang.NewMap() + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6588), kw_column, int(27), kw_end_DASH_line, int(6588), kw_end_DASH_column, int(28)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp9 := lang.Apply(tmp5, []any{tmp8}) + var v10 any = tmp9 + _ = v10 + // let binding "ks" + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := lang.Apply(tmp11, []any{v2}) + var v13 any = tmp12 + _ = v13 + // let binding "vs" + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := lang.Apply(tmp14, []any{v3}) + var v16 any = tmp15 + _ = v16 + for { + var tmp17 any + var tmp18 any + { // let + // let binding "and__0__auto__" + var v19 any = v13 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + tmp20 = v16 + } else { + tmp20 = v19 + } + tmp18 = tmp20 + } // end let + if lang.IsTruthy(tmp18) { + tmp20 := checkDerefVar(var_glojure_DOT_core_assoc_BANG_) + tmp21 := checkDerefVar(var_glojure_DOT_core_first) + tmp22 := lang.Apply(tmp21, []any{v13}) + tmp23 := checkDerefVar(var_glojure_DOT_core_first) + tmp24 := lang.Apply(tmp23, []any{v16}) + tmp25 := lang.Apply(tmp20, []any{v10, tmp22, tmp24}) + var tmp19 any = tmp25 + tmp27 := checkDerefVar(var_glojure_DOT_core_next) + tmp28 := lang.Apply(tmp27, []any{v13}) + var tmp26 any = tmp28 + tmp30 := checkDerefVar(var_glojure_DOT_core_next) + tmp31 := lang.Apply(tmp30, []any{v16}) + var tmp29 any = tmp31 + v10 = tmp19 + v13 = tmp26 + v16 = tmp29 + continue + } else { + tmp32 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp33 := lang.Apply(tmp32, []any{v10}) + tmp17 = tmp33 + } + tmp4 = tmp17 + break + } + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_zipmap = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_zipmap.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // NaN? + { + var tmp1 lang.FnFunc + { // function NaN?__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym_math_DOT_IsNaN}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{v3}) + tmp10 := lang.Apply(tmp5, []any{tmp7, tmp9}) + tmp11 := lang.Apply(tmp4, []any{tmp10}) + return tmp11 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_NaN_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_num)), kw_inline, tmp1, kw_doc, "Returns true if num is NaN, else false", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1)})), kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(7968), kw_end_DASH_line, int(7968))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(math4.IsNaN, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_NaN_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_NaN_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // StackTraceElement->vec + { + tmp0 := sym_StackTraceElement_DASH__GT_vec.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_o)), kw_doc, "Constructs a data representation for a StackTraceElement: [class method file line]", kw_file, "glojure/core_print.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(28), kw_column, int(7), kw_line, int(436), kw_end_DASH_line, int(436))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_symbol) + tmp4, ok := lang.FieldOrMethod(v2, "getClassName") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getClassName"))) + } + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { + case reflect.Func: + tmp5 = lang.Apply(tmp4, nil) + default: + tmp5 = tmp4 + } + tmp6 := lang.Apply(tmp3, []any{tmp5}) + tmp7 := checkDerefVar(var_glojure_DOT_core_symbol) + tmp8, ok := lang.FieldOrMethod(v2, "getMethodName") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getMethodName"))) + } + var tmp9 any + switch reflect.TypeOf(tmp8).Kind() { + case reflect.Func: + tmp9 = lang.Apply(tmp8, nil) + default: + tmp9 = tmp8 + } + tmp10 := lang.Apply(tmp7, []any{tmp9}) + tmp11, ok := lang.FieldOrMethod(v2, "getFileName") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getFileName"))) + } + var tmp12 any + switch reflect.TypeOf(tmp11).Kind() { + case reflect.Func: + tmp12 = lang.Apply(tmp11, nil) + default: + tmp12 = tmp11 + } + tmp13, ok := lang.FieldOrMethod(v2, "getLineNumber") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getLineNumber"))) + } + var tmp14 any + switch reflect.TypeOf(tmp13).Kind() { + case reflect.Func: + tmp14 = lang.Apply(tmp13, nil) + default: + tmp14 = tmp13 + } + tmp15 := lang.NewVector(tmp6, tmp10, tmp12, tmp14) + tmp16 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(440), kw_column, int(3), kw_end_DASH_line, int(440), kw_end_DASH_column, int(94)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp17 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_StackTraceElement_DASH__GT_vec = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_StackTraceElement_DASH__GT_vec.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // -> + { + tmp0 := sym__DASH__GT_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_x, sym__AMP_, sym_forms)), kw_doc, "Threads the expr through the forms. Inserts x as the\n second item in the first form, making a list of it if it is not a\n list already. If there are more forms, inserts the first form as the\n second item in second form, etc.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(11), kw_line, int(1675), kw_end_DASH_line, int(1675))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "x" + var v7 any = v4 + _ = v7 + // let binding "forms" + var v8 any = v5 + _ = v8 + for { + var tmp9 any + if lang.IsTruthy(v8) { + var tmp10 any + { // let + // let binding "form" + tmp11 := checkDerefVar(var_glojure_DOT_core_first) + tmp12 := lang.Apply(tmp11, []any{v8}) + var v13 any = tmp12 + _ = v13 + // let binding "threaded" + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp16 := lang.Apply(tmp15, []any{v13}) + if lang.IsTruthy(tmp16) { + tmp17 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := checkDerefVar(var_glojure_DOT_core_first) + tmp22 := lang.Apply(tmp21, []any{v13}) + tmp23 := lang.Apply(tmp20, []any{tmp22}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v7}) + tmp26 := checkDerefVar(var_glojure_DOT_core_next) + tmp27 := lang.Apply(tmp26, []any{v13}) + tmp28 := lang.Apply(tmp19, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp18, []any{tmp28}) + tmp30 := checkDerefVar(var_glojure_DOT_core_meta) + tmp31 := lang.Apply(tmp30, []any{v13}) + tmp32 := lang.Apply(tmp17, []any{tmp29, tmp31}) + tmp14 = tmp32 + } else { + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{v13, v7}) + tmp14 = tmp34 + } + var v35 any = tmp14 + _ = v35 + var tmp36 any = v35 + tmp38 := checkDerefVar(var_glojure_DOT_core_next) + tmp39 := lang.Apply(tmp38, []any{v8}) + var tmp37 any = tmp39 + v7 = tmp36 + v8 = tmp37 + continue + } // end let + tmp9 = tmp10 + } else { + tmp9 = v7 + } + tmp6 = tmp9 + break + } + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__DASH__GT_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__DASH__GT_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ->> + { + tmp0 := sym__DASH__GT__GT_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_x, sym__AMP_, sym_forms)), kw_doc, "Threads the expr through the forms. Inserts x as the\n last item in the first form, making a list of it if it is not a\n list already. If there are more forms, inserts the first form as the\n last item in second form, etc.", kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(11), kw_line, int(1691), kw_end_DASH_line, int(1691))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "x" + var v7 any = v4 + _ = v7 + // let binding "forms" + var v8 any = v5 + _ = v8 + for { + var tmp9 any + if lang.IsTruthy(v8) { + var tmp10 any + { // let + // let binding "form" + tmp11 := checkDerefVar(var_glojure_DOT_core_first) + tmp12 := lang.Apply(tmp11, []any{v8}) + var v13 any = tmp12 + _ = v13 + // let binding "threaded" + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp16 := lang.Apply(tmp15, []any{v13}) + if lang.IsTruthy(tmp16) { + tmp17 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := checkDerefVar(var_glojure_DOT_core_first) + tmp22 := lang.Apply(tmp21, []any{v13}) + tmp23 := lang.Apply(tmp20, []any{tmp22}) + tmp24 := checkDerefVar(var_glojure_DOT_core_next) + tmp25 := lang.Apply(tmp24, []any{v13}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v7}) + tmp28 := lang.Apply(tmp19, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp18, []any{tmp28}) + tmp30 := checkDerefVar(var_glojure_DOT_core_meta) + tmp31 := lang.Apply(tmp30, []any{v13}) + tmp32 := lang.Apply(tmp17, []any{tmp29, tmp31}) + tmp14 = tmp32 + } else { + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{v13, v7}) + tmp14 = tmp34 + } + var v35 any = tmp14 + _ = v35 + var tmp36 any = v35 + tmp38 := checkDerefVar(var_glojure_DOT_core_next) + tmp39 := lang.Apply(tmp38, []any{v8}) + var tmp37 any = tmp39 + v7 = tmp36 + v8 = tmp37 + continue + } // end let + tmp9 = tmp10 + } else { + tmp9 = v7 + } + tmp6 = tmp9 + break + } + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__DASH__GT__GT_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__DASH__GT__GT_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // .. + { + tmp0 := sym__DOT__DOT_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_form), lang.NewVector(sym_x, sym_form, sym__AMP_, sym_more)), kw_doc, "form => fieldName-symbol or (instanceMethodName-symbol args*)\n\n Expands into a member access (.) of the first member on the first\n argument, followed by the next member on the result, etc. For\n instance:\n\n (.. System (getProperties) (get \"os.name\"))\n\n expands to:\n\n (. (. System (getProperties)) (get \"os.name\"))\n\n but is easier to write, read, and understand.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(11), kw_line, int(1657), kw_end_DASH_line, int(1657))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym__DOT_}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{v4}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v5}) + tmp14 := lang.Apply(tmp7, []any{tmp9, tmp11, tmp13}) + tmp15 := lang.Apply(tmp6, []any{tmp14}) + return tmp15 + default: + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var v6 any = lang.NewList(args[4:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym__DOT_}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v4}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v5}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp22, v6}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + return tmp24 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__DOT__DOT_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__DOT__DOT_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // = + { + var tmp1 lang.FnFunc + { // function =__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_lang_DOT_Util}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_glojure_DOT_core_SLASH_equiv}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{v3}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v4}) + tmp17 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp12, tmp14, tmp16}) + tmp18 := lang.Apply(tmp5, []any{tmp17}) + return tmp18 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym__EQ_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Equality. Returns true if x equals y, false if not. Same as\n Java x.equals(y) except it also works for nil, and compares\n numbers and collections in a type-independent manner. Clojure's immutable data\n structures define equals() (and thus =) as a value, not an identity,\n comparison.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(7), kw_line, int(776), kw_end_DASH_line, int(776))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + return true + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(lang.Equiv, []any{v3, v4}) + return tmp5 + default: + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + recur_loop_1666: + var tmp6 any + tmp7 := lang.Apply(lang.Equiv, []any{v3, v4}) + if lang.IsTruthy(tmp7) { + var tmp8 any + tmp9 := checkDerefVar(var_glojure_DOT_core_next) + tmp10 := lang.Apply(tmp9, []any{v5}) + if lang.IsTruthy(tmp10) { + var tmp11 any = v4 + tmp13 := checkDerefVar(var_glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v5}) + var tmp12 any = tmp14 + tmp16 := checkDerefVar(var_glojure_DOT_core_next) + tmp17 := lang.Apply(tmp16, []any{v5}) + var tmp15 any = tmp17 + v3 = tmp11 + v4 = tmp12 + v5 = tmp15 + goto recur_loop_1666 + } else { + tmp18 := checkDerefVar(var_glojure_DOT_core_first) + tmp19 := lang.Apply(tmp18, []any{v5}) + tmp20 := lang.Apply(lang.Equiv, []any{v4, tmp19}) + tmp8 = tmp20 + } + tmp6 = tmp8 + } else { + tmp6 = false + } + return tmp6 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__EQ_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__EQ_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // == + { + var tmp1 lang.FnFunc + { // function ==__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Equiv}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym__EQ__EQ_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns non-nil if nums all have the equivalent\n value (type-independent), otherwise false", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(7), kw_line, int(1093), kw_end_DASH_line, int(1093))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + return true + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Equiv") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Equiv is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + default: + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + recur_loop_1746: + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__EQ__EQ_) + tmp8 := lang.Apply(tmp7, []any{v3, v4}) + if lang.IsTruthy(tmp8) { + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_next) + tmp11 := lang.Apply(tmp10, []any{v5}) + if lang.IsTruthy(tmp11) { + var tmp12 any = v4 + tmp14 := checkDerefVar(var_glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v5}) + var tmp13 any = tmp15 + tmp17 := checkDerefVar(var_glojure_DOT_core_next) + tmp18 := lang.Apply(tmp17, []any{v5}) + var tmp16 any = tmp18 + v3 = tmp12 + v4 = tmp13 + v5 = tmp16 + goto recur_loop_1746 + } else { + tmp19 := checkDerefVar(var_glojure_DOT_core__EQ__EQ_) + tmp20 := checkDerefVar(var_glojure_DOT_core_first) + tmp21 := lang.Apply(tmp20, []any{v5}) + tmp22 := lang.Apply(tmp19, []any{v4, tmp21}) + tmp9 = tmp22 + } + tmp6 = tmp9 + } else { + tmp6 = false + } + return tmp6 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__EQ__EQ_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__EQ__EQ_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // > + { + var tmp1 lang.FnFunc + { // function >__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Gt}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym__GT_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns non-nil if nums are in monotonically decreasing order,\n otherwise false.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(7), kw_line, int(1063), kw_end_DASH_line, int(1063))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + return true + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + default: + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + recur_loop_1738: + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__GT_) + tmp8 := lang.Apply(tmp7, []any{v3, v4}) + if lang.IsTruthy(tmp8) { + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_next) + tmp11 := lang.Apply(tmp10, []any{v5}) + if lang.IsTruthy(tmp11) { + var tmp12 any = v4 + tmp14 := checkDerefVar(var_glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v5}) + var tmp13 any = tmp15 + tmp17 := checkDerefVar(var_glojure_DOT_core_next) + tmp18 := lang.Apply(tmp17, []any{v5}) + var tmp16 any = tmp18 + v3 = tmp12 + v4 = tmp13 + v5 = tmp16 + goto recur_loop_1738 + } else { + tmp19 := checkDerefVar(var_glojure_DOT_core__GT_) + tmp20 := checkDerefVar(var_glojure_DOT_core_first) + tmp21 := lang.Apply(tmp20, []any{v5}) + tmp22 := lang.Apply(tmp19, []any{v4, tmp21}) + tmp9 = tmp22 + } + tmp6 = tmp9 + } else { + tmp6 = false + } + return tmp6 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__GT_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__GT_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // >= + { + var tmp1 lang.FnFunc + { // function >=__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Gte}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym__GT__EQ_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns non-nil if nums are in monotonically non-increasing order,\n otherwise false.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(7), kw_line, int(1078), kw_end_DASH_line, int(1078))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + return true + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Gte") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gte is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + default: + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + recur_loop_1742: + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__GT__EQ_) + tmp8 := lang.Apply(tmp7, []any{v3, v4}) + if lang.IsTruthy(tmp8) { + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_next) + tmp11 := lang.Apply(tmp10, []any{v5}) + if lang.IsTruthy(tmp11) { + var tmp12 any = v4 + tmp14 := checkDerefVar(var_glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v5}) + var tmp13 any = tmp15 + tmp17 := checkDerefVar(var_glojure_DOT_core_next) + tmp18 := lang.Apply(tmp17, []any{v5}) + var tmp16 any = tmp18 + v3 = tmp12 + v4 = tmp13 + v5 = tmp16 + goto recur_loop_1742 + } else { + tmp19 := checkDerefVar(var_glojure_DOT_core__GT__EQ_) + tmp20 := checkDerefVar(var_glojure_DOT_core_first) + tmp21 := lang.Apply(tmp20, []any{v5}) + tmp22 := lang.Apply(tmp19, []any{v4, tmp21}) + tmp9 = tmp22 + } + tmp6 = tmp9 + } else { + tmp6 = false + } + return tmp6 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__GT__EQ_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__GT__EQ_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // < + { + var tmp1 lang.FnFunc + { // function <__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Lt}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym__LT_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns non-nil if nums are in monotonically increasing order,\n otherwise false.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(7), kw_line, int(893), kw_end_DASH_line, int(893))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + return true + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Lt") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Lt is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + default: + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + recur_loop_1690: + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp8 := lang.Apply(tmp7, []any{v3, v4}) + if lang.IsTruthy(tmp8) { + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_next) + tmp11 := lang.Apply(tmp10, []any{v5}) + if lang.IsTruthy(tmp11) { + var tmp12 any = v4 + tmp14 := checkDerefVar(var_glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v5}) + var tmp13 any = tmp15 + tmp17 := checkDerefVar(var_glojure_DOT_core_next) + tmp18 := lang.Apply(tmp17, []any{v5}) + var tmp16 any = tmp18 + v3 = tmp12 + v4 = tmp13 + v5 = tmp16 + goto recur_loop_1690 + } else { + tmp19 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp20 := checkDerefVar(var_glojure_DOT_core_first) + tmp21 := lang.Apply(tmp20, []any{v5}) + tmp22 := lang.Apply(tmp19, []any{v4, tmp21}) + tmp9 = tmp22 + } + tmp6 = tmp9 + } else { + tmp6 = false + } + return tmp6 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__LT_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__LT_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // <= + { + var tmp1 lang.FnFunc + { // function <=__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Lte}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym__LT__EQ_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns non-nil if nums are in monotonically non-decreasing order,\n otherwise false.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(7), kw_line, int(1048), kw_end_DASH_line, int(1048))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + return true + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Lte") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Lte is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + default: + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + recur_loop_1734: + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__LT__EQ_) + tmp8 := lang.Apply(tmp7, []any{v3, v4}) + if lang.IsTruthy(tmp8) { + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_next) + tmp11 := lang.Apply(tmp10, []any{v5}) + if lang.IsTruthy(tmp11) { + var tmp12 any = v4 + tmp14 := checkDerefVar(var_glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v5}) + var tmp13 any = tmp15 + tmp17 := checkDerefVar(var_glojure_DOT_core_next) + tmp18 := lang.Apply(tmp17, []any{v5}) + var tmp16 any = tmp18 + v3 = tmp12 + v4 = tmp13 + v5 = tmp16 + goto recur_loop_1734 + } else { + tmp19 := checkDerefVar(var_glojure_DOT_core__LT__EQ_) + tmp20 := checkDerefVar(var_glojure_DOT_core_first) + tmp21 := lang.Apply(tmp20, []any{v5}) + tmp22 := lang.Apply(tmp19, []any{v4, tmp21}) + tmp9 = tmp22 + } + tmp6 = tmp9 + } else { + tmp6 = false + } + return tmp6 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__LT__EQ_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__LT__EQ_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // + + { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed3 + } else { + tmp4 = closed4 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed3 + } else { + tmp5 = closed4 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed3 + } else { + tmp6 = closed4 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym__PLUS_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns the sum of nums. (+) returns 0. Does not auto-promote\n longs, will throw on overflow. See also: +'", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(7), kw_line, int(977), kw_end_DASH_line, int(977))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return int64(0) + case 1: + v4 := args[0] + _ = v4 + tmp5 := lang.Apply(lang.MustAsNumber, []any{v4}) + return tmp5 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Add") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Add is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp8 := checkDerefVar(var_glojure_DOT_core__PLUS_) + tmp9 := checkDerefVar(var_glojure_DOT_core__PLUS_) + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) + return tmp11 + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__PLUS_ = ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__PLUS_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // +' + { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed5 + } else { + tmp4 = closed5 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed5 + } else { + tmp5 = closed5 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed5 + } else { + tmp6 = closed5 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym__PLUS__TICK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns the sum of nums. (+') returns 0. Supports arbitrary precision.\n See also: +", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(7), kw_line, int(965), kw_end_DASH_line, int(965))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return int64(0) + case 1: + v4 := args[0] + _ = v4 + tmp5 := lang.Apply(lang.MustAsNumber, []any{v4}) + return tmp5 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "AddP") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("AddP is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp8 := checkDerefVar(var_glojure_DOT_core__PLUS__TICK_) + tmp9 := checkDerefVar(var_glojure_DOT_core__PLUS__TICK_) + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) + return tmp11 + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__PLUS__TICK_ = ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__PLUS__TICK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // / + { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed9 + } else { + tmp4 = closed9 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed9 + } else { + tmp5 = closed9 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed9 + } else { + tmp6 = closed9 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym__SLASH_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "If no denominators are supplied, returns 1/numerator,\n else returns numerator divided by all of the denominators.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(7), kw_line, int(1013), kw_end_DASH_line, int(1013))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core__SLASH_) + tmp6 := lang.Apply(tmp5, []any{int64(1), v4}) + return tmp6 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Divide") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Divide is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp8 := checkDerefVar(var_glojure_DOT_core__SLASH_) + tmp9 := checkDerefVar(var_glojure_DOT_core__SLASH_) + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) + return tmp11 + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__SLASH_ = ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__SLASH_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // * + { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed0 + } else { + tmp4 = closed1 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed0 + } else { + tmp5 = closed1 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed0 + } else { + tmp6 = closed1 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym__STAR_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns the product of nums. (*) returns 1. Does not auto-promote\n longs, will throw on overflow. See also: *'", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(7), kw_line, int(1001), kw_end_DASH_line, int(1001))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return int64(1) + case 1: + v4 := args[0] + _ = v4 + tmp5 := lang.Apply(lang.MustAsNumber, []any{v4}) + return tmp5 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Multiply") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Multiply is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp8 := checkDerefVar(var_glojure_DOT_core__STAR_) + tmp9 := checkDerefVar(var_glojure_DOT_core__STAR_) + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) + return tmp11 + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__STAR_ = ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *' + { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed2 + } else { + tmp4 = closed2 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed2 + } else { + tmp5 = closed2 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed2 + } else { + tmp6 = closed2 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym__STAR__TICK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns the product of nums. (*') returns 1. Supports arbitrary precision.\n See also: *", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(7), kw_line, int(989), kw_end_DASH_line, int(989))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return int64(1) + case 1: + v4 := args[0] + _ = v4 + tmp5 := lang.Apply(lang.MustAsNumber, []any{v4}) + return tmp5 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "MultiplyP") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("MultiplyP is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp8 := checkDerefVar(var_glojure_DOT_core__STAR__TICK_) + tmp9 := checkDerefVar(var_glojure_DOT_core__STAR__TICK_) + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) + return tmp11 + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__STAR__TICK_ = ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR__TICK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // abs + { + var tmp1 lang.FnFunc + { // function abs__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Abs}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{v3}) + tmp10 := lang.Apply(tmp5, []any{tmp7, tmp9}) + tmp11 := lang.Apply(tmp4, []any{tmp10}) + return tmp11 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_abs.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a)), kw_inline, tmp1, kw_doc, "Returns the absolute value of a.\n If a is Long/MIN_VALUE => Long/MIN_VALUE\n If a is a double and zero => +0.0\n If a is a double and ##Inf or ##-Inf => ##Inf\n If a is a double and ##NaN => ##NaN", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1)})), kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(1128), kw_end_DASH_line, int(1128))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.Abs, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_abs = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_abs.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // aclone + { + var tmp1 lang.FnFunc + { // function aclone__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Aclone}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_aclone.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array)), kw_inline, tmp1, kw_doc, "Returns a clone of the Java array. Works on arrays of known\n types.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(3904), kw_end_DASH_line, int(3904))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(runtime.RT, "Aclone") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Aclone is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_aclone = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_aclone.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // add-doc-and-meta + { + tmp0 := sym_add_DASH_doc_DASH_and_DASH_meta.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym_docstring, sym_meta)), kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(26), kw_column, int(11), kw_line, int(6400), kw_end_DASH_line, int(6400), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 5) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_core_SLASH_alter_DASH_meta_BANG_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_var}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v4}) + tmp18 := lang.Apply(tmp13, []any{tmp15, tmp17}) + tmp19 := lang.Apply(tmp12, []any{tmp18}) + tmp20 := lang.Apply(tmp11, []any{tmp19}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{sym_glojure_DOT_core_SLASH_merge}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_seq) + tmp25 := checkDerefVar(var_glojure_DOT_core_concat) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{sym_glojure_DOT_core_SLASH_assoc}) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := lang.Apply(tmp28, []any{v6}) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := lang.Apply(tmp30, []any{kw_doc}) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := lang.Apply(tmp32, []any{v5}) + tmp34 := lang.Apply(tmp25, []any{tmp27, tmp29, tmp31, tmp33}) + tmp35 := lang.Apply(tmp24, []any{tmp34}) + tmp36 := lang.Apply(tmp23, []any{tmp35}) + tmp37 := lang.Apply(tmp8, []any{tmp10, tmp20, tmp22, tmp36}) + tmp38 := lang.Apply(tmp7, []any{tmp37}) + return tmp38 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_add_DASH_doc_DASH_and_DASH_meta = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_add_DASH_doc_DASH_and_DASH_meta.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // alength + { + var tmp1 lang.FnFunc + { // function alength__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Alength}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_alength.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array)), kw_inline, tmp1, kw_doc, "Returns the length of the Java array. Works on arrays of all\n types.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(3897), kw_end_DASH_line, int(3897))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(runtime.RT, "Alength") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Alength is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_alength = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_alength.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // apply + { + tmp0 := sym_apply.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_args), lang.NewVector(sym_f, sym_x, sym_args), lang.NewVector(sym_f, sym_x, sym_y, sym_args), lang.NewVector(sym_f, sym_x, sym_y, sym_z, sym_args), lang.NewVector(sym_f, sym_a, sym_b, sym_c, sym_d, sym__AMP_, sym_args)), kw_doc, "Applies fn f to the argument list formed by prepending intervening arguments to args.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(653), kw_end_DASH_line, int(653))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := lang.Apply(tmp4, []any{v3}) + tmp6 := lang.Apply(lang.Apply, []any{v2, tmp5}) + return tmp6 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + tmp7 := lang.Apply(lang.Apply, []any{v2, tmp6}) + return tmp7 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp7 := lang.Apply(tmp6, []any{v3, v4, v5}) + tmp8 := lang.Apply(lang.Apply, []any{v2, tmp7}) + return tmp8 + case 5: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp8 := lang.Apply(tmp7, []any{v3, v4, v5, v6}) + tmp9 := lang.Apply(lang.Apply, []any{v2, tmp8}) + return tmp9 + default: + checkArity(args, 5) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + var v7 any = lang.NewList(args[5:]...) + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_cons) + tmp9 := checkDerefVar(var_glojure_DOT_core_cons) + tmp10 := checkDerefVar(var_glojure_DOT_core_cons) + tmp11 := checkDerefVar(var_glojure_DOT_core_cons) + tmp12 := checkDerefVar(var_glojure_DOT_core_spread) + tmp13 := lang.Apply(tmp12, []any{v7}) + tmp14 := lang.Apply(tmp11, []any{v6, tmp13}) + tmp15 := lang.Apply(tmp10, []any{v5, tmp14}) + tmp16 := lang.Apply(tmp9, []any{v4, tmp15}) + tmp17 := lang.Apply(tmp8, []any{v3, tmp16}) + tmp18 := lang.Apply(lang.Apply, []any{v2, tmp17}) + return tmp18 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_apply = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_apply.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // areduce + { + tmp0 := sym_areduce.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_a, sym_idx, sym_ret, sym_init, sym_expr)), kw_doc, "Reduces an expression across an array a, using an index named idx,\n and return value named ret, initialized to init, setting ret to the \n evaluation of expr at each step, returning ret.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(5289), kw_end_DASH_line, int(5289))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 7) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + v7 := args[5] + _ = v7 + v8 := args[6] + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_seq) + tmp10 := checkDerefVar(var_glojure_DOT_core_concat) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_glojure_DOT_core_SLASH_let}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_apply) + tmp15 := checkDerefVar(var_glojure_DOT_core_vector) + tmp16 := checkDerefVar(var_glojure_DOT_core_seq) + tmp17 := checkDerefVar(var_glojure_DOT_core_concat) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{sym_a__0__auto__}) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{v4}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{sym_l__1__auto__}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := checkDerefVar(var_glojure_DOT_core_seq) + tmp26 := checkDerefVar(var_glojure_DOT_core_concat) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{sym_glojure_DOT_core_SLASH_alength}) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{sym_a__0__auto__}) + tmp31 := lang.Apply(tmp26, []any{tmp28, tmp30}) + tmp32 := lang.Apply(tmp25, []any{tmp31}) + tmp33 := lang.Apply(tmp24, []any{tmp32}) + tmp34 := lang.Apply(tmp17, []any{tmp19, tmp21, tmp23, tmp33}) + tmp35 := lang.Apply(tmp16, []any{tmp34}) + tmp36 := lang.Apply(tmp14, []any{tmp15, tmp35}) + tmp37 := lang.Apply(tmp13, []any{tmp36}) + tmp38 := checkDerefVar(var_glojure_DOT_core_list) + tmp39 := checkDerefVar(var_glojure_DOT_core_seq) + tmp40 := checkDerefVar(var_glojure_DOT_core_concat) + tmp41 := checkDerefVar(var_glojure_DOT_core_list) + tmp42 := lang.Apply(tmp41, []any{sym_glojure_DOT_core_SLASH_loop}) + tmp43 := checkDerefVar(var_glojure_DOT_core_list) + tmp44 := checkDerefVar(var_glojure_DOT_core_apply) + tmp45 := checkDerefVar(var_glojure_DOT_core_vector) + tmp46 := checkDerefVar(var_glojure_DOT_core_seq) + tmp47 := checkDerefVar(var_glojure_DOT_core_concat) + tmp48 := checkDerefVar(var_glojure_DOT_core_list) + tmp49 := lang.Apply(tmp48, []any{v5}) + tmp50 := checkDerefVar(var_glojure_DOT_core_list) + tmp51 := lang.Apply(tmp50, []any{int64(0)}) + tmp52 := checkDerefVar(var_glojure_DOT_core_list) + tmp53 := lang.Apply(tmp52, []any{v6}) + tmp54 := checkDerefVar(var_glojure_DOT_core_list) + tmp55 := lang.Apply(tmp54, []any{v7}) + tmp56 := lang.Apply(tmp47, []any{tmp49, tmp51, tmp53, tmp55}) + tmp57 := lang.Apply(tmp46, []any{tmp56}) + tmp58 := lang.Apply(tmp44, []any{tmp45, tmp57}) + tmp59 := lang.Apply(tmp43, []any{tmp58}) + tmp60 := checkDerefVar(var_glojure_DOT_core_list) + tmp61 := checkDerefVar(var_glojure_DOT_core_seq) + tmp62 := checkDerefVar(var_glojure_DOT_core_concat) + tmp63 := checkDerefVar(var_glojure_DOT_core_list) + tmp64 := lang.Apply(tmp63, []any{sym_if}) + tmp65 := checkDerefVar(var_glojure_DOT_core_list) + tmp66 := checkDerefVar(var_glojure_DOT_core_seq) + tmp67 := checkDerefVar(var_glojure_DOT_core_concat) + tmp68 := checkDerefVar(var_glojure_DOT_core_list) + tmp69 := lang.Apply(tmp68, []any{sym_glojure_DOT_core_SLASH__LT_}) + tmp70 := checkDerefVar(var_glojure_DOT_core_list) + tmp71 := lang.Apply(tmp70, []any{v5}) + tmp72 := checkDerefVar(var_glojure_DOT_core_list) + tmp73 := lang.Apply(tmp72, []any{sym_l__1__auto__}) + tmp74 := lang.Apply(tmp67, []any{tmp69, tmp71, tmp73}) + tmp75 := lang.Apply(tmp66, []any{tmp74}) + tmp76 := lang.Apply(tmp65, []any{tmp75}) + tmp77 := checkDerefVar(var_glojure_DOT_core_list) + tmp78 := checkDerefVar(var_glojure_DOT_core_seq) + tmp79 := checkDerefVar(var_glojure_DOT_core_concat) + tmp80 := checkDerefVar(var_glojure_DOT_core_list) + tmp81 := lang.Apply(tmp80, []any{sym_recur}) + tmp82 := checkDerefVar(var_glojure_DOT_core_list) + tmp83 := checkDerefVar(var_glojure_DOT_core_seq) + tmp84 := checkDerefVar(var_glojure_DOT_core_concat) + tmp85 := checkDerefVar(var_glojure_DOT_core_list) + tmp86 := lang.Apply(tmp85, []any{sym_glojure_DOT_core_SLASH_unchecked_DASH_inc_DASH_int}) + tmp87 := checkDerefVar(var_glojure_DOT_core_list) + tmp88 := lang.Apply(tmp87, []any{v5}) + tmp89 := lang.Apply(tmp84, []any{tmp86, tmp88}) + tmp90 := lang.Apply(tmp83, []any{tmp89}) + tmp91 := lang.Apply(tmp82, []any{tmp90}) + tmp92 := checkDerefVar(var_glojure_DOT_core_list) + tmp93 := lang.Apply(tmp92, []any{v8}) + tmp94 := lang.Apply(tmp79, []any{tmp81, tmp91, tmp93}) + tmp95 := lang.Apply(tmp78, []any{tmp94}) + tmp96 := lang.Apply(tmp77, []any{tmp95}) + tmp97 := checkDerefVar(var_glojure_DOT_core_list) + tmp98 := lang.Apply(tmp97, []any{v6}) + tmp99 := lang.Apply(tmp62, []any{tmp64, tmp76, tmp96, tmp98}) + tmp100 := lang.Apply(tmp61, []any{tmp99}) + tmp101 := lang.Apply(tmp60, []any{tmp100}) + tmp102 := lang.Apply(tmp40, []any{tmp42, tmp59, tmp101}) + tmp103 := lang.Apply(tmp39, []any{tmp102}) + tmp104 := lang.Apply(tmp38, []any{tmp103}) + tmp105 := lang.Apply(tmp10, []any{tmp12, tmp37, tmp104}) + tmp106 := lang.Apply(tmp9, []any{tmp105}) + return tmp106 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_areduce = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_areduce.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // array + { + tmp0 := sym_array.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(3457), kw_column, int(7), kw_end_DASH_line, int(3458), kw_end_DASH_column, int(7), kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_items)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_into_DASH_array) + tmp4 := lang.Apply(tmp3, []any{v2}) + return tmp4 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_array = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_array.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // assert + { + tmp0 := sym_assert.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_message)), kw_doc, "Evaluates expression x and throws an AssertionError with optional\n message if x does not evaluate to logical true.\n\n Assertion checks are omitted from compiled code if '*assert*' is\n false.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(11), kw_line, int(4837), kw_end_DASH_line, int(4837))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_assert_STAR_) + if lang.IsTruthy(tmp6) { + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_core_SLASH_when_DASH_not}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{v4}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{sym_throw}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := checkDerefVar(var_glojure_DOT_core_seq) + tmp20 := checkDerefVar(var_glojure_DOT_core_concat) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{sym_new}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := lang.Apply(tmp23, []any{sym_glojure_DOT_core_SLASH_AssertionError}) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := checkDerefVar(var_glojure_DOT_core_seq) + tmp27 := checkDerefVar(var_glojure_DOT_core_concat) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := lang.Apply(tmp28, []any{sym_glojure_DOT_core_SLASH_str}) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := lang.Apply(tmp30, []any{"Assert failed: "}) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := checkDerefVar(var_glojure_DOT_core_seq) + tmp34 := checkDerefVar(var_glojure_DOT_core_concat) + tmp35 := checkDerefVar(var_glojure_DOT_core_list) + tmp36 := lang.Apply(tmp35, []any{sym_glojure_DOT_core_SLASH_pr_DASH_str}) + tmp37 := checkDerefVar(var_glojure_DOT_core_list) + tmp38 := checkDerefVar(var_glojure_DOT_core_seq) + tmp39 := checkDerefVar(var_glojure_DOT_core_concat) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{sym_quote}) + tmp42 := checkDerefVar(var_glojure_DOT_core_list) + tmp43 := lang.Apply(tmp42, []any{v4}) + tmp44 := lang.Apply(tmp39, []any{tmp41, tmp43}) + tmp45 := lang.Apply(tmp38, []any{tmp44}) + tmp46 := lang.Apply(tmp37, []any{tmp45}) + tmp47 := lang.Apply(tmp34, []any{tmp36, tmp46}) + tmp48 := lang.Apply(tmp33, []any{tmp47}) + tmp49 := lang.Apply(tmp32, []any{tmp48}) + tmp50 := lang.Apply(tmp27, []any{tmp29, tmp31, tmp49}) + tmp51 := lang.Apply(tmp26, []any{tmp50}) + tmp52 := lang.Apply(tmp25, []any{tmp51}) + tmp53 := lang.Apply(tmp20, []any{tmp22, tmp24, tmp52}) + tmp54 := lang.Apply(tmp19, []any{tmp53}) + tmp55 := lang.Apply(tmp18, []any{tmp54}) + tmp56 := lang.Apply(tmp15, []any{tmp17, tmp55}) + tmp57 := lang.Apply(tmp14, []any{tmp56}) + tmp58 := lang.Apply(tmp13, []any{tmp57}) + tmp59 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp58}) + tmp60 := lang.Apply(tmp7, []any{tmp59}) + tmp5 = tmp60 + } else { + } + return tmp5 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_assert_STAR_) + if lang.IsTruthy(tmp7) { + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_when_DASH_not}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v4}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_throw}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{sym_new}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{sym_glojure_DOT_core_SLASH_AssertionError}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := checkDerefVar(var_glojure_DOT_core_seq) + tmp28 := checkDerefVar(var_glojure_DOT_core_concat) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{sym_glojure_DOT_core_SLASH_str}) + tmp31 := checkDerefVar(var_glojure_DOT_core_list) + tmp32 := lang.Apply(tmp31, []any{"Assert failed: "}) + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{v5}) + tmp35 := checkDerefVar(var_glojure_DOT_core_list) + tmp36 := lang.Apply(tmp35, []any{"\n"}) + tmp37 := checkDerefVar(var_glojure_DOT_core_list) + tmp38 := checkDerefVar(var_glojure_DOT_core_seq) + tmp39 := checkDerefVar(var_glojure_DOT_core_concat) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{sym_glojure_DOT_core_SLASH_pr_DASH_str}) + tmp42 := checkDerefVar(var_glojure_DOT_core_list) + tmp43 := checkDerefVar(var_glojure_DOT_core_seq) + tmp44 := checkDerefVar(var_glojure_DOT_core_concat) + tmp45 := checkDerefVar(var_glojure_DOT_core_list) + tmp46 := lang.Apply(tmp45, []any{sym_quote}) + tmp47 := checkDerefVar(var_glojure_DOT_core_list) + tmp48 := lang.Apply(tmp47, []any{v4}) + tmp49 := lang.Apply(tmp44, []any{tmp46, tmp48}) + tmp50 := lang.Apply(tmp43, []any{tmp49}) + tmp51 := lang.Apply(tmp42, []any{tmp50}) + tmp52 := lang.Apply(tmp39, []any{tmp41, tmp51}) + tmp53 := lang.Apply(tmp38, []any{tmp52}) + tmp54 := lang.Apply(tmp37, []any{tmp53}) + tmp55 := lang.Apply(tmp28, []any{tmp30, tmp32, tmp34, tmp36, tmp54}) + tmp56 := lang.Apply(tmp27, []any{tmp55}) + tmp57 := lang.Apply(tmp26, []any{tmp56}) + tmp58 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp57}) + tmp59 := lang.Apply(tmp20, []any{tmp58}) + tmp60 := lang.Apply(tmp19, []any{tmp59}) + tmp61 := lang.Apply(tmp16, []any{tmp18, tmp60}) + tmp62 := lang.Apply(tmp15, []any{tmp61}) + tmp63 := lang.Apply(tmp14, []any{tmp62}) + tmp64 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp63}) + tmp65 := lang.Apply(tmp8, []any{tmp64}) + tmp6 = tmp65 + } else { + } + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_assert = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_assert.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // assert-args + { + tmp0 := sym_assert_DASH_args.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_pairs)), kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(38), kw_column, int(11), kw_line, int(1830), kw_end_DASH_line, int(1830), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym_do}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := checkDerefVar(var_glojure_DOT_core_seq) + tmp11 := checkDerefVar(var_glojure_DOT_core_concat) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_glojure_DOT_core_SLASH_when_DASH_not}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_first) + tmp16 := lang.Apply(tmp15, []any{v4}) + tmp17 := lang.Apply(tmp14, []any{tmp16}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := checkDerefVar(var_glojure_DOT_core_seq) + tmp20 := checkDerefVar(var_glojure_DOT_core_concat) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{sym_throw}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_seq) + tmp25 := checkDerefVar(var_glojure_DOT_core_concat) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_NewIllegalArgumentError}) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := checkDerefVar(var_glojure_DOT_core_seq) + tmp30 := checkDerefVar(var_glojure_DOT_core_concat) + tmp31 := checkDerefVar(var_glojure_DOT_core_list) + tmp32 := lang.Apply(tmp31, []any{sym_glojure_DOT_core_SLASH_str}) + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := checkDerefVar(var_glojure_DOT_core_seq) + tmp35 := checkDerefVar(var_glojure_DOT_core_concat) + tmp36 := checkDerefVar(var_glojure_DOT_core_list) + tmp37 := lang.Apply(tmp36, []any{sym_glojure_DOT_core_SLASH_first}) + tmp38 := checkDerefVar(var_glojure_DOT_core_list) + tmp39 := lang.Apply(tmp38, []any{sym__AMP_form}) + tmp40 := lang.Apply(tmp35, []any{tmp37, tmp39}) + tmp41 := lang.Apply(tmp34, []any{tmp40}) + tmp42 := lang.Apply(tmp33, []any{tmp41}) + tmp43 := checkDerefVar(var_glojure_DOT_core_list) + tmp44 := lang.Apply(tmp43, []any{" requires "}) + tmp45 := checkDerefVar(var_glojure_DOT_core_list) + tmp46 := checkDerefVar(var_glojure_DOT_core_second) + tmp47 := lang.Apply(tmp46, []any{v4}) + tmp48 := lang.Apply(tmp45, []any{tmp47}) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) + tmp50 := lang.Apply(tmp49, []any{" in "}) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := lang.Apply(tmp51, []any{sym__STAR_ns_STAR_}) + tmp53 := checkDerefVar(var_glojure_DOT_core_list) + tmp54 := lang.Apply(tmp53, []any{":"}) + tmp55 := checkDerefVar(var_glojure_DOT_core_list) + tmp56 := checkDerefVar(var_glojure_DOT_core_seq) + tmp57 := checkDerefVar(var_glojure_DOT_core_concat) + tmp58 := checkDerefVar(var_glojure_DOT_core_list) + tmp59 := lang.Apply(tmp58, []any{kw_line}) + tmp60 := checkDerefVar(var_glojure_DOT_core_list) + tmp61 := checkDerefVar(var_glojure_DOT_core_seq) + tmp62 := checkDerefVar(var_glojure_DOT_core_concat) + tmp63 := checkDerefVar(var_glojure_DOT_core_list) + tmp64 := lang.Apply(tmp63, []any{sym_glojure_DOT_core_SLASH_meta}) + tmp65 := checkDerefVar(var_glojure_DOT_core_list) + tmp66 := lang.Apply(tmp65, []any{sym__AMP_form}) + tmp67 := lang.Apply(tmp62, []any{tmp64, tmp66}) + tmp68 := lang.Apply(tmp61, []any{tmp67}) + tmp69 := lang.Apply(tmp60, []any{tmp68}) + tmp70 := lang.Apply(tmp57, []any{tmp59, tmp69}) + tmp71 := lang.Apply(tmp56, []any{tmp70}) + tmp72 := lang.Apply(tmp55, []any{tmp71}) + tmp73 := lang.Apply(tmp30, []any{tmp32, tmp42, tmp44, tmp48, tmp50, tmp52, tmp54, tmp72}) + tmp74 := lang.Apply(tmp29, []any{tmp73}) + tmp75 := lang.Apply(tmp28, []any{tmp74}) + tmp76 := lang.Apply(tmp25, []any{tmp27, tmp75}) + tmp77 := lang.Apply(tmp24, []any{tmp76}) + tmp78 := lang.Apply(tmp23, []any{tmp77}) + tmp79 := lang.Apply(tmp20, []any{tmp22, tmp78}) + tmp80 := lang.Apply(tmp19, []any{tmp79}) + tmp81 := lang.Apply(tmp18, []any{tmp80}) + tmp82 := lang.Apply(tmp11, []any{tmp13, tmp17, tmp81}) + tmp83 := lang.Apply(tmp10, []any{tmp82}) + tmp84 := lang.Apply(tmp9, []any{tmp83}) + tmp85 := checkDerefVar(var_glojure_DOT_core_list) + var tmp86 any + { // let + // let binding "more" + tmp87 := checkDerefVar(var_glojure_DOT_core_nnext) + tmp88 := lang.Apply(tmp87, []any{v4}) + var v89 any = tmp88 + _ = v89 + var tmp90 any + if lang.IsTruthy(v89) { + tmp91 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp92 := lang.Apply(tmp91, []any{sym_glojure_DOT_core_SLASH_assert_DASH_args, v89}) + tmp90 = tmp92 + } else { + } + tmp86 = tmp90 + } // end let + tmp87 := lang.Apply(tmp85, []any{tmp86}) + tmp88 := lang.Apply(tmp6, []any{tmp8, tmp84, tmp87}) + tmp89 := lang.Apply(tmp5, []any{tmp88}) + return tmp89 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_assert_DASH_args = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_assert_DASH_args.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // assoc-in + { + tmp0 := sym_assoc_DASH_in.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m, lang.NewVector(sym_k, sym__AMP_, sym_ks), sym_v)), kw_doc, "Associates a value in a nested associative structure, where ks is a\n sequence of keys and v is the new value and returns a new nested structure.\n If any levels do not exist, hash-maps will be created.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(6147), kw_end_DASH_line, int(6147))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + { // let + // let binding "vec__829" + var v6 any = v3 + _ = v6 + // let binding "seq__830" + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := lang.Apply(tmp7, []any{v6}) + var v9 any = tmp8 + _ = v9 + // let binding "first__831" + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v9}) + var v12 any = tmp11 + _ = v12 + // let binding "seq__830" + tmp13 := checkDerefVar(var_glojure_DOT_core_next) + tmp14 := lang.Apply(tmp13, []any{v9}) + var v15 any = tmp14 + _ = v15 + // let binding "k" + var v16 any = v12 + _ = v16 + // let binding "ks" + var v17 any = v15 + _ = v17 + var tmp18 any + if lang.IsTruthy(v17) { + tmp19 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp20 := checkDerefVar(var_glojure_DOT_core_assoc_DASH_in) + tmp21 := checkDerefVar(var_glojure_DOT_core_get) + tmp22 := lang.Apply(tmp21, []any{v2, v16}) + tmp23 := lang.Apply(tmp20, []any{tmp22, v17, v4}) + tmp24 := lang.Apply(tmp19, []any{v2, v16, tmp23}) + tmp18 = tmp24 + } else { + tmp25 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp26 := lang.Apply(tmp25, []any{v2, v16, v4}) + tmp18 = tmp26 + } + tmp5 = tmp18 + } // end let + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_assoc_DASH_in = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_assoc_DASH_in.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bigdec + { + tmp1 := reflect.TypeOf((*lang.BigDecimal)(nil)) + tmp0 := sym_bigdec.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Coerce to BigDecimal", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(3648), kw_end_DASH_line, int(3648))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_decimal_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + tmp4 = v3 + } else { + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core_float_QMARK_) + tmp9 := lang.Apply(tmp8, []any{v3}) + if lang.IsTruthy(tmp9) { + tmp10 := checkDerefVar(var_glojure_DOT_core_double) + tmp11 := lang.Apply(tmp10, []any{v3}) + tmp12 := lang.Apply(lang.NewBigDecimalFromFloat64, []any{tmp11}) + tmp7 = tmp12 + } else { + var tmp13 any + tmp14 := checkDerefVar(var_glojure_DOT_core_ratio_QMARK_) + tmp15 := lang.Apply(tmp14, []any{v3}) + if lang.IsTruthy(tmp15) { + tmp16 := checkDerefVar(var_glojure_DOT_core__SLASH_) + tmp17 := lang.Apply(lang.NewBigDecimalFromRatio, []any{v3}) + tmp18, ok := lang.FieldOrMethod(v3, "denominator") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "denominator"))) + } + var tmp19 any + switch reflect.TypeOf(tmp18).Kind() { + case reflect.Func: + tmp19 = lang.Apply(tmp18, nil) + default: + tmp19 = tmp18 + } + tmp20 := lang.Apply(tmp16, []any{tmp17, tmp19}) + tmp13 = tmp20 + } else { + var tmp21 any + tmp22 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp23 := reflect.TypeOf((*lang.BigInt)(nil)) + tmp24 := lang.Apply(tmp22, []any{tmp23, v3}) + if lang.IsTruthy(tmp24) { + tmp25, ok := lang.FieldOrMethod(v3, "toBigDecimal") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "toBigDecimal"))) + } + var tmp26 any + switch reflect.TypeOf(tmp25).Kind() { + case reflect.Func: + tmp26 = lang.Apply(tmp25, nil) + default: + tmp26 = tmp25 + } + tmp21 = tmp26 + } else { + var tmp27 any + tmp28 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp29 := reflect.TypeOf((*big6.Int)(nil)) + tmp30 := lang.Apply(tmp28, []any{tmp29, v3}) + if lang.IsTruthy(tmp30) { + tmp31 := lang.Apply(lang.NewBigDecimal, []any{v3}) + tmp27 = tmp31 + } else { + var tmp32 any + tmp33 := checkDerefVar(var_glojure_DOT_core_number_QMARK_) + tmp34 := lang.Apply(tmp33, []any{v3}) + if lang.IsTruthy(tmp34) { + tmp35 := checkDerefVar(var_glojure_DOT_core_long) + tmp36 := lang.Apply(tmp35, []any{v3}) + tmp37 := lang.Apply(lang.NewBigDecimalFromInt64, []any{tmp36}) + tmp32 = tmp37 + } else { + var tmp38 any + if lang.IsTruthy(kw_else) { + tmp39 := lang.Apply(lang.NewBigDecimal, []any{v3}) + tmp38 = tmp39 + } else { + } + tmp32 = tmp38 + } + tmp27 = tmp32 + } + tmp21 = tmp27 + } + tmp13 = tmp21 + } + tmp7 = tmp13 + } + tmp4 = tmp7 + } + return tmp4 + }) + tmp3 := reflect.TypeOf((*lang.BigDecimal)(nil)) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_bigdec = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bigdec.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bigint + { + tmp1 := reflect.TypeOf((*lang.BigInt)(nil)) + tmp0 := sym_bigint.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Coerce to BigInt", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(3620), kw_end_DASH_line, int(3620))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp6 := reflect.TypeOf((*lang.BigInt)(nil)) + tmp7 := lang.Apply(tmp5, []any{tmp6, v3}) + if lang.IsTruthy(tmp7) { + tmp4 = v3 + } else { + var tmp8 any + tmp9 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp10 := reflect.TypeOf((*big6.Int)(nil)) + tmp11 := lang.Apply(tmp9, []any{tmp10, v3}) + if lang.IsTruthy(tmp11) { + tmp12 := lang.Apply(lang.NewBigIntFromGoBigInt, []any{v3}) + tmp8 = tmp12 + } else { + var tmp13 any + tmp14 := checkDerefVar(var_glojure_DOT_core_decimal_QMARK_) + tmp15 := lang.Apply(tmp14, []any{v3}) + if lang.IsTruthy(tmp15) { + tmp16 := checkDerefVar(var_glojure_DOT_core_bigint) + tmp17, ok := lang.FieldOrMethod(v3, "toBigInteger") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "toBigInteger"))) + } + var tmp18 any + switch reflect.TypeOf(tmp17).Kind() { + case reflect.Func: + tmp18 = lang.Apply(tmp17, nil) + default: + tmp18 = tmp17 + } + tmp19 := lang.Apply(tmp16, []any{tmp18}) + tmp13 = tmp19 + } else { + var tmp20 any + tmp21 := checkDerefVar(var_glojure_DOT_core_float_QMARK_) + tmp22 := lang.Apply(tmp21, []any{v3}) + if lang.IsTruthy(tmp22) { + tmp23 := checkDerefVar(var_glojure_DOT_core_bigint) + tmp24 := checkDerefVar(var_glojure_DOT_core_double) + tmp25 := lang.Apply(tmp24, []any{v3}) + tmp26 := lang.Apply(lang.NewBigDecimalFromFloat64, []any{tmp25}) + tmp27 := lang.Apply(tmp23, []any{tmp26}) + tmp20 = tmp27 + } else { + var tmp28 any + tmp29 := checkDerefVar(var_glojure_DOT_core_ratio_QMARK_) + tmp30 := lang.Apply(tmp29, []any{v3}) + if lang.IsTruthy(tmp30) { + tmp31 := checkDerefVar(var_glojure_DOT_core_bigint) + tmp32, ok := lang.FieldOrMethod(v3, "bigIntegerValue") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "bigIntegerValue"))) + } + var tmp33 any + switch reflect.TypeOf(tmp32).Kind() { + case reflect.Func: + tmp33 = lang.Apply(tmp32, nil) + default: + tmp33 = tmp32 + } + tmp34 := lang.Apply(tmp31, []any{tmp33}) + tmp28 = tmp34 + } else { + var tmp35 any + tmp36 := checkDerefVar(var_glojure_DOT_core_number_QMARK_) + tmp37 := lang.Apply(tmp36, []any{v3}) + if lang.IsTruthy(tmp37) { + tmp38 := checkDerefVar(var_glojure_DOT_core_long) + tmp39 := lang.Apply(tmp38, []any{v3}) + tmp40 := lang.Apply(lang.NewBigIntFromInt64, []any{tmp39}) + tmp35 = tmp40 + } else { + var tmp41 any + if lang.IsTruthy(kw_else) { + tmp42 := checkDerefVar(var_glojure_DOT_core_bigint) + tmp43 := lang.Apply(lang.NewBigInt, []any{v3}) + tmp44 := lang.Apply(tmp42, []any{tmp43}) + tmp41 = tmp44 + } else { + } + tmp35 = tmp41 + } + tmp28 = tmp35 + } + tmp20 = tmp28 + } + tmp13 = tmp20 + } + tmp8 = tmp13 + } + tmp4 = tmp8 + } + return tmp4 + }) + tmp3 := reflect.TypeOf((*lang.BigInt)(nil)) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_bigint = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bigint.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // biginteger + { + tmp1 := reflect.TypeOf((*big6.Int)(nil)) + tmp0 := sym_biginteger.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Coerce to BigInteger", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(3634), kw_end_DASH_line, int(3634))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp6 := reflect.TypeOf((*big6.Int)(nil)) + tmp7 := lang.Apply(tmp5, []any{tmp6, v3}) + if lang.IsTruthy(tmp7) { + tmp4 = v3 + } else { + var tmp8 any + tmp9 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp10 := reflect.TypeOf((*lang.BigInt)(nil)) + tmp11 := lang.Apply(tmp9, []any{tmp10, v3}) + if lang.IsTruthy(tmp11) { + tmp12, ok := lang.FieldOrMethod(v3, "toBigInteger") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "toBigInteger"))) + } + var tmp13 any + switch reflect.TypeOf(tmp12).Kind() { + case reflect.Func: + tmp13 = lang.Apply(tmp12, nil) + default: + tmp13 = tmp12 + } + tmp8 = tmp13 + } else { + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core_decimal_QMARK_) + tmp16 := lang.Apply(tmp15, []any{v3}) + if lang.IsTruthy(tmp16) { + tmp17, ok := lang.FieldOrMethod(v3, "toBigInteger") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "toBigInteger"))) + } + var tmp18 any + switch reflect.TypeOf(tmp17).Kind() { + case reflect.Func: + tmp18 = lang.Apply(tmp17, nil) + default: + tmp18 = tmp17 + } + tmp14 = tmp18 + } else { + var tmp19 any + tmp20 := checkDerefVar(var_glojure_DOT_core_float_QMARK_) + tmp21 := lang.Apply(tmp20, []any{v3}) + if lang.IsTruthy(tmp21) { + tmp22 := checkDerefVar(var_glojure_DOT_core_double) + tmp23 := lang.Apply(tmp22, []any{v3}) + tmp24 := lang.Apply(lang.NewBigDecimalFromFloat64, []any{tmp23}) + tmp25, ok := lang.FieldOrMethod(tmp24, "toBigInteger") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp24, "toBigInteger"))) + } + var tmp26 any + switch reflect.TypeOf(tmp25).Kind() { + case reflect.Func: + tmp26 = lang.Apply(tmp25, nil) + default: + tmp26 = tmp25 + } + tmp19 = tmp26 + } else { + var tmp27 any + tmp28 := checkDerefVar(var_glojure_DOT_core_ratio_QMARK_) + tmp29 := lang.Apply(tmp28, []any{v3}) + if lang.IsTruthy(tmp29) { + tmp30, ok := lang.FieldOrMethod(v3, "bigIntegerValue") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "bigIntegerValue"))) + } + var tmp31 any + switch reflect.TypeOf(tmp30).Kind() { + case reflect.Func: + tmp31 = lang.Apply(tmp30, nil) + default: + tmp31 = tmp30 + } + tmp27 = tmp31 + } else { + var tmp32 any + tmp33 := checkDerefVar(var_glojure_DOT_core_number_QMARK_) + tmp34 := lang.Apply(tmp33, []any{v3}) + if lang.IsTruthy(tmp34) { + tmp35 := checkDerefVar(var_glojure_DOT_core_long) + tmp36 := lang.Apply(tmp35, []any{v3}) + tmp37 := lang.Apply(big6.NewInt, []any{tmp36}) + tmp32 = tmp37 + } else { + var tmp38 any + if lang.IsTruthy(kw_else) { + tmp39 := lang.Apply(lang.NewBigInt, []any{v3}) + tmp38 = tmp39 + } else { + } + tmp32 = tmp38 + } + tmp27 = tmp32 + } + tmp19 = tmp27 + } + tmp14 = tmp19 + } + tmp8 = tmp14 + } + tmp4 = tmp8 + } + return tmp4 + }) + tmp3 := reflect.TypeOf((*big6.Int)(nil)) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_biginteger = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_biginteger.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // binding-conveyor-fn + { + tmp0 := sym_binding_DASH_conveyor_DASH_fn.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f)), kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(25), kw_column, int(7), kw_line, int(2020), kw_end_DASH_line, int(2020), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "frame" + tmp4 := lang.Apply(lang.CloneThreadBindingFrame, nil) + var v5 any = tmp4 + _ = v5 + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp7 := lang.Apply(lang.ResetThreadBindingFrame, []any{v5}) + _ = tmp7 + tmp8 := lang.Apply(v2, nil) + return tmp8 + case 1: + v7 := args[0] + _ = v7 + tmp8 := lang.Apply(lang.ResetThreadBindingFrame, []any{v5}) + _ = tmp8 + tmp9 := lang.Apply(v2, []any{v7}) + return tmp9 + case 2: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + tmp9 := lang.Apply(lang.ResetThreadBindingFrame, []any{v5}) + _ = tmp9 + tmp10 := lang.Apply(v2, []any{v7, v8}) + return tmp10 + case 3: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + tmp10 := lang.Apply(lang.ResetThreadBindingFrame, []any{v5}) + _ = tmp10 + tmp11 := lang.Apply(v2, []any{v7, v8, v9}) + return tmp11 + default: + checkArity(args, 3) + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + var v10 any = lang.NewList(args[3:]...) + _ = v10 + tmp11 := lang.Apply(lang.ResetThreadBindingFrame, []any{v5}) + _ = tmp11 + tmp12 := checkDerefVar(var_glojure_DOT_core_apply) + tmp13 := lang.Apply(tmp12, []any{v2, v7, v8, v9, v10}) + return tmp13 + } + }) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2025), kw_column, int(5), kw_end_DASH_line, int(2040), kw_end_DASH_column, int(31)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp3 = tmp8 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_binding_DASH_conveyor_DASH_fn = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_binding_DASH_conveyor_DASH_fn.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bit-and + { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed10 + } else { + tmp4 = closed10 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed10 + } else { + tmp5 = closed10 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed10 + } else { + tmp6 = closed10 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym_bit_DASH_and.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Bitwise and", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(1298), kw_end_DASH_line, int(1298))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "And") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("And is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp8 := checkDerefVar(var_glojure_DOT_core_bit_DASH_and) + tmp9 := checkDerefVar(var_glojure_DOT_core_bit_DASH_and) + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) + return tmp11 + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bit_DASH_and = ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bit_DASH_and.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bit-and-not + { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed11 + } else { + tmp4 = closed11 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed11 + } else { + tmp5 = closed11 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed11 + } else { + tmp6 = closed11 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym_bit_DASH_and_DASH_not.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Bitwise and with complement", kw_static, true, kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(1325), kw_end_DASH_line, int(1325))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "AndNot") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("AndNot is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp8 := checkDerefVar(var_glojure_DOT_core_bit_DASH_and_DASH_not) + tmp9 := checkDerefVar(var_glojure_DOT_core_bit_DASH_and_DASH_not) + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) + return tmp11 + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bit_DASH_and_DASH_not = ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bit_DASH_and_DASH_not.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bit-not + { + var tmp1 lang.FnFunc + { // function bit-not__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Not}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_bit_DASH_not.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Bitwise complement", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(1291), kw_end_DASH_line, int(1291))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Not") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Not is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bit_DASH_not = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bit_DASH_not.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bit-or + { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed12 + } else { + tmp4 = closed12 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed12 + } else { + tmp5 = closed12 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed12 + } else { + tmp6 = closed12 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym_bit_DASH_or.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Bitwise or", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(1307), kw_end_DASH_line, int(1307))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Or") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Or is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp8 := checkDerefVar(var_glojure_DOT_core_bit_DASH_or) + tmp9 := checkDerefVar(var_glojure_DOT_core_bit_DASH_or) + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) + return tmp11 + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bit_DASH_or = ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bit_DASH_or.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bit-shift-left + { + var tmp1 lang.FnFunc + { // function bit-shift-left__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_ShiftLeft}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_bit_DASH_shift_DASH_left.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_n)), kw_inline, tmp1, kw_doc, "Bitwise shift left", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(1361), kw_end_DASH_line, int(1361))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "ShiftLeft") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ShiftLeft is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bit_DASH_shift_DASH_left = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bit_DASH_shift_DASH_left.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bit-shift-right + { + var tmp1 lang.FnFunc + { // function bit-shift-right__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_ShiftRight}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_bit_DASH_shift_DASH_right.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_n)), kw_inline, tmp1, kw_doc, "Bitwise shift right", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(1367), kw_end_DASH_line, int(1367))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "ShiftRight") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ShiftRight is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bit_DASH_shift_DASH_right = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bit_DASH_shift_DASH_right.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bit-xor + { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed13 + } else { + tmp4 = closed13 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed13 + } else { + tmp5 = closed13 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed13 + } else { + tmp6 = closed13 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym_bit_DASH_xor.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Bitwise exclusive or", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(1316), kw_end_DASH_line, int(1316))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Xor") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Xor is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp8 := checkDerefVar(var_glojure_DOT_core_bit_DASH_xor) + tmp9 := checkDerefVar(var_glojure_DOT_core_bit_DASH_xor) + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) + return tmp11 + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bit_DASH_xor = ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bit_DASH_xor.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // boolean + { + var tmp1 lang.FnFunc + { // function boolean__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_BooleanCast}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_boolean.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to boolean", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(1601), kw_end_DASH_line, int(1601))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(runtime.RT, "BooleanCast") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("BooleanCast is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_boolean = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_boolean.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // boolean-array + { + var tmp1 lang.FnFunc + { // function boolean-array__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_BooleanArray}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_unquote_DASH_splicing}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_glojure_DOT_core_SLASH_args}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + } + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_boolean_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_size_DASH_or_DASH_seq), lang.NewVector(sym_size, sym_init_DASH_val_DASH_or_DASH_seq)), kw_inline, tmp1, kw_doc, "Creates an array of booleans", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(5309), kw_end_DASH_line, int(5309))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "BooleanArray") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("BooleanArray is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "BooleanArrayInit") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("BooleanArrayInit is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_boolean_DASH_array = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_boolean_DASH_array.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // booleans + { + var tmp1 lang.FnFunc + { // function booleans + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Booleans}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_booleans.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xs)), kw_inline, tmp1, kw_doc, "Casts to boolean[]", kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(12), kw_line, int(5372), kw_end_DASH_line, int(5372))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Booleans") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Booleans is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_booleans = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_booleans.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bound-fn + { + tmp0 := sym_bound_DASH_fn.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_fntail)), kw_doc, "Returns a function defined by the given fntail, which will install the\n same bindings in effect as in the thread at the time bound-fn was called.\n This may be used to define a helper function which runs on a different\n thread, but needs the same bindings in place.", kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(11), kw_line, int(2004), kw_end_DASH_line, int(2004))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym_glojure_DOT_core_SLASH_bound_DASH_fn_STAR_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := checkDerefVar(var_glojure_DOT_core_seq) + tmp11 := checkDerefVar(var_glojure_DOT_core_concat) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_glojure_DOT_core_SLASH_fn}) + tmp14 := lang.Apply(tmp11, []any{tmp13, v4}) + tmp15 := lang.Apply(tmp10, []any{tmp14}) + tmp16 := lang.Apply(tmp9, []any{tmp15}) + tmp17 := lang.Apply(tmp6, []any{tmp8, tmp16}) + tmp18 := lang.Apply(tmp5, []any{tmp17}) + return tmp18 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bound_DASH_fn = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bound_DASH_fn.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bound? + { + tmp0 := sym_bound_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_vars)), kw_doc, "Returns true if all of the vars provided as arguments have any bound value, root or thread-local.\n Implies that deref'ing the provided vars will succeed. Returns true if no vars are provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(5491), kw_end_DASH_line, int(5491))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v5 := args[0] + _ = v5 + tmp6, ok := lang.FieldOrMethod(v5, "isBound") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "isBound"))) + } + var tmp7 any + switch reflect.TypeOf(tmp6).Kind() { + case reflect.Func: + tmp7 = lang.Apply(tmp6, nil) + default: + tmp7 = tmp6 + } + return tmp7 + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5497), kw_column, int(11), kw_end_DASH_line, int(5497), kw_end_DASH_column, int(69)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp7 := lang.Apply(tmp3, []any{tmp6, v2}) + return tmp7 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bound_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bound_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bounded-count + { + tmp0 := sym_bounded_DASH_count.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n, sym_coll)), kw_doc, "If coll is counted? returns its count, else will count at most the first n\n elements of coll using its seq", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(7410), kw_end_DASH_line, int(7410))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_counted_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + tmp7 := checkDerefVar(var_glojure_DOT_core_count) + tmp8 := lang.Apply(tmp7, []any{v3}) + tmp4 = tmp8 + } else { + var tmp9 any + { // let + // let binding "i" + var v10 any = int64(0) + _ = v10 + // let binding "s" + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := lang.Apply(tmp11, []any{v3}) + var v13 any = tmp12 + _ = v13 + for { + var tmp14 any + var tmp15 any + { // let + // let binding "and__0__auto__" + var v16 any = v13 + _ = v16 + var tmp17 any + if lang.IsTruthy(v16) { + tmp18 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp19 := lang.Apply(tmp18, []any{v10, v2}) + tmp17 = tmp19 + } else { + tmp17 = v16 + } + tmp15 = tmp17 + } // end let + if lang.IsTruthy(tmp15) { + tmp17 := checkDerefVar(var_glojure_DOT_core_inc) + tmp18 := lang.Apply(tmp17, []any{v10}) + var tmp16 any = tmp18 + tmp20 := checkDerefVar(var_glojure_DOT_core_next) + tmp21 := lang.Apply(tmp20, []any{v13}) + var tmp19 any = tmp21 + v10 = tmp16 + v13 = tmp19 + continue + } else { + tmp14 = v10 + } + tmp9 = tmp14 + break + } + } // end let + tmp4 = tmp9 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bounded_DASH_count = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bounded_DASH_count.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // butlast + { + tmp0 := sym_butlast.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Return a seq of all but the last item in coll, in linear time", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(2), kw_line, int(272), kw_end_DASH_line, int(276))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function butlast + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + var tmp4 any + { // let + // let binding "ret" + tmp5 := lang.NewVector() + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(277), kw_column, int(23), kw_end_DASH_line, int(277), kw_end_DASH_column, int(24)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v8 any = tmp7 + _ = v8 + // let binding "s" + var v9 any = v3 + _ = v9 + for { + var tmp10 any + tmp11 := checkDerefVar(var_glojure_DOT_core_next) + tmp12 := lang.Apply(tmp11, []any{v9}) + if lang.IsTruthy(tmp12) { + tmp14 := checkDerefVar(var_glojure_DOT_core_conj) + tmp15 := checkDerefVar(var_glojure_DOT_core_first) + tmp16 := lang.Apply(tmp15, []any{v9}) + tmp17 := lang.Apply(tmp14, []any{v8, tmp16}) + var tmp13 any = tmp17 + tmp19 := checkDerefVar(var_glojure_DOT_core_next) + tmp20 := lang.Apply(tmp19, []any{v9}) + var tmp18 any = tmp20 + v8 = tmp13 + v9 = tmp18 + continue + } else { + tmp21 := checkDerefVar(var_glojure_DOT_core_seq) + tmp22 := lang.Apply(tmp21, []any{v8}) + tmp10 = tmp22 + } + tmp4 = tmp10 + break + } + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(276), kw_column, int(10), kw_end_DASH_line, int(280), kw_end_DASH_column, int(27))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_butlast = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_butlast.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // byte + { + var tmp1 lang.FnFunc + { // function byte__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp15) { + tmp14 = sym_uncheckedByteCast + } else { + tmp14 = sym_byteCast + } + tmp16 := lang.Apply(tmp13, []any{tmp14}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := lang.Apply(tmp12, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp11, []any{tmp19}) + tmp21 := lang.Apply(tmp10, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_byte.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to byte", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3505), kw_end_DASH_line, int(3505))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.ByteCast, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_byte = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_byte.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // byte-array + { + var tmp1 lang.FnFunc + { // function byte-array__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_ByteArray}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_unquote_DASH_splicing}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_glojure_DOT_core_SLASH_args}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + } + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_byte_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_size_DASH_or_DASH_seq), lang.NewVector(sym_size, sym_init_DASH_val_DASH_or_DASH_seq)), kw_inline, tmp1, kw_doc, "Creates an array of bytes", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(5317), kw_end_DASH_line, int(5317))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "ByteArray") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ByteArray is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "ByteArrayInit") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ByteArrayInit is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_byte_DASH_array = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_byte_DASH_array.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bytes + { + var tmp1 lang.FnFunc + { // function bytes + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Bytes}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_bytes.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xs)), kw_inline, tmp1, kw_doc, "Casts to bytes[]", kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(12), kw_line, int(5377), kw_end_DASH_line, int(5377))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Bytes") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Bytes is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bytes = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bytes.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bytes? + { + tmp0 := sym_bytes_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a byte array", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(5412), kw_end_DASH_line, int(5412))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + tmp3 = false + } else { + tmp6 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp7 := checkDerefVar(var_glojure_DOT_core_class) + tmp8 := lang.Apply(tmp7, []any{v2}) + tmp9, ok := lang.FieldOrMethod(tmp8, "getComponentType") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp8, "getComponentType"))) + } + var tmp10 any + switch reflect.TypeOf(tmp9).Kind() { + case reflect.Func: + tmp10 = lang.Apply(tmp9, nil) + default: + tmp10 = tmp9 + } + tmp11 := lang.Apply(tmp6, []any{tmp10, nil}) + tmp3 = tmp11 + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bytes_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bytes_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // char + { + var tmp1 lang.FnFunc + { // function char__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp15) { + tmp14 = sym_uncheckedCharCast + } else { + tmp14 = sym_charCast + } + tmp16 := lang.Apply(tmp13, []any{tmp14}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := lang.Apply(tmp12, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp11, []any{tmp19}) + tmp21 := lang.Apply(tmp10, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_char.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to char", kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3511), kw_end_DASH_line, int(3511))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(runtime.RT, "CharCast") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("CharCast is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_char = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_char.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // char-array + { + var tmp1 lang.FnFunc + { // function char-array__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_CharArray}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_unquote_DASH_splicing}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_glojure_DOT_core_SLASH_args}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + } + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_char_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_size_DASH_or_DASH_seq), lang.NewVector(sym_size, sym_init_DASH_val_DASH_or_DASH_seq)), kw_inline, tmp1, kw_doc, "Creates an array of chars", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(5325), kw_end_DASH_line, int(5325))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "CharArray") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("CharArray is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "CharArrayInit") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("CharArrayInit is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_char_DASH_array = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_char_DASH_array.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // chars + { + var tmp1 lang.FnFunc + { // function chars + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Chars}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_chars.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xs)), kw_inline, tmp1, kw_doc, "Casts to chars[]", kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(12), kw_line, int(5382), kw_end_DASH_line, int(5382))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Chars") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Chars is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_chars = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_chars.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // comp + { + tmp0 := sym_comp.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_f), lang.NewVector(sym_f, sym_g), lang.NewVector(sym_f, sym_g, sym__AMP_, sym_fs)), kw_doc, "Takes a set of functions and returns a fn that is the composition\n of those fns. The returned fn takes a variable number of args,\n applies the rightmost of fns to the args, the next\n fn (right-to-left) to the result, etc.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(2549), kw_end_DASH_line, int(2549))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp2 := checkDerefVar(var_glojure_DOT_core_identity) + return tmp2 + case 1: + v2 := args[0] + _ = v2 + return v2 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp5 := lang.Apply(v3, nil) + tmp6 := lang.Apply(v2, []any{tmp5}) + return tmp6 + case 1: + v5 := args[0] + _ = v5 + tmp6 := lang.Apply(v3, []any{v5}) + tmp7 := lang.Apply(v2, []any{tmp6}) + return tmp7 + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + tmp7 := lang.Apply(v3, []any{v5, v6}) + tmp8 := lang.Apply(v2, []any{tmp7}) + return tmp8 + case 3: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := args[2] + _ = v7 + tmp8 := lang.Apply(v3, []any{v5, v6, v7}) + tmp9 := lang.Apply(v2, []any{tmp8}) + return tmp9 + default: + checkArity(args, 3) + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := args[2] + _ = v7 + var v8 any = lang.NewList(args[3:]...) + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_apply) + tmp10 := lang.Apply(tmp9, []any{v3, v5, v6, v7, v8}) + tmp11 := lang.Apply(v2, []any{tmp10}) + return tmp11 + } + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2559), kw_column, int(6), kw_end_DASH_line, int(2564), kw_end_DASH_column, int(49)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp6 := checkDerefVar(var_glojure_DOT_core_comp) + tmp7 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp8 := lang.Apply(tmp7, []any{v2, v3, v4}) + tmp9 := lang.Apply(tmp5, []any{tmp6, tmp8}) + return tmp9 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_comp = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_comp.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // compare + { + var tmp1 lang.FnFunc + { // function compare__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_lang_DOT_Util}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_glojure_DOT_core_SLASH_compare}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{v3}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v4}) + tmp17 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp12, tmp14, tmp16}) + tmp18 := lang.Apply(tmp5, []any{tmp17}) + return tmp18 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_compare.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Comparator. Returns a negative number, zero, or a positive number\n when x is logically 'less than', 'equal to', or 'greater than'\n y. Same as Java x.compareTo(y) except it also works for nil, and\n compares numbers and collections in a type-independent manner. x\n must implement Comparable", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(824), kw_end_DASH_line, int(824))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(lang.Compare, []any{v3, v4}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_compare = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_compare.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // complement + { + tmp0 := sym_complement.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f)), kw_doc, "Takes a fn f and returns a fn that takes the same arguments as f,\n has the same effects, if any, and returns the opposite truth value.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(1428), kw_end_DASH_line, int(1428))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp4 := checkDerefVar(var_glojure_DOT_core_not) + tmp5 := lang.Apply(v2, nil) + tmp6 := lang.Apply(tmp4, []any{tmp5}) + return tmp6 + case 1: + v4 := args[0] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_not) + tmp6 := lang.Apply(v2, []any{v4}) + tmp7 := lang.Apply(tmp5, []any{tmp6}) + return tmp7 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_not) + tmp7 := lang.Apply(v2, []any{v4, v5}) + tmp8 := lang.Apply(tmp6, []any{tmp7}) + return tmp8 + default: + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_not) + tmp8 := checkDerefVar(var_glojure_DOT_core_apply) + tmp9 := lang.Apply(tmp8, []any{v2, v4, v5, v6}) + tmp10 := lang.Apply(tmp7, []any{tmp9}) + return tmp10 + } + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(1434), kw_column, int(3), kw_end_DASH_line, int(1438), kw_end_DASH_column, int(40)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_complement = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_complement.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // data-reader-var + { + tmp0 := sym_data_DASH_reader_DASH_var.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7832), kw_column, int(8), kw_end_DASH_line, int(7832), kw_end_DASH_column, int(22), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_sym)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_intern) + tmp4 := checkDerefVar(var_glojure_DOT_core_create_DASH_ns) + tmp5 := checkDerefVar(var_glojure_DOT_core_symbol) + tmp6 := checkDerefVar(var_glojure_DOT_core_namespace) + tmp7 := lang.Apply(tmp6, []any{v2}) + tmp8 := lang.Apply(tmp5, []any{tmp7}) + tmp9 := lang.Apply(tmp4, []any{tmp8}) + tmp10 := checkDerefVar(var_glojure_DOT_core_symbol) + tmp11 := checkDerefVar(var_glojure_DOT_core_name) + tmp12 := lang.Apply(tmp11, []any{v2}) + tmp13 := lang.Apply(tmp10, []any{tmp12}) + tmp14 := lang.Apply(tmp3, []any{tmp9, tmp13}) + return tmp14 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_data_DASH_reader_DASH_var = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_data_DASH_reader_DASH_var.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // def-aset + { + tmp0 := sym_def_DASH_aset.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym_method, sym_coerce)), kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(3), kw_line, int(3935), kw_end_DASH_line, int(3936), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 5) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_core_SLASH_defn}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{v4}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_apply) + tmp15 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp16 := checkDerefVar(var_glojure_DOT_core_seq) + tmp17 := checkDerefVar(var_glojure_DOT_core_concat) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{kw_arglists}) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := checkDerefVar(var_glojure_DOT_core_seq) + tmp22 := checkDerefVar(var_glojure_DOT_core_concat) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := lang.Apply(tmp23, []any{sym_quote}) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := checkDerefVar(var_glojure_DOT_core_seq) + tmp27 := checkDerefVar(var_glojure_DOT_core_concat) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := checkDerefVar(var_glojure_DOT_core_apply) + tmp30 := checkDerefVar(var_glojure_DOT_core_vector) + tmp31 := checkDerefVar(var_glojure_DOT_core_seq) + tmp32 := checkDerefVar(var_glojure_DOT_core_concat) + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{sym_array}) + tmp35 := checkDerefVar(var_glojure_DOT_core_list) + tmp36 := lang.Apply(tmp35, []any{sym_idx}) + tmp37 := checkDerefVar(var_glojure_DOT_core_list) + tmp38 := lang.Apply(tmp37, []any{sym_val}) + tmp39 := lang.Apply(tmp32, []any{tmp34, tmp36, tmp38}) + tmp40 := lang.Apply(tmp31, []any{tmp39}) + tmp41 := lang.Apply(tmp29, []any{tmp30, tmp40}) + tmp42 := lang.Apply(tmp28, []any{tmp41}) + tmp43 := checkDerefVar(var_glojure_DOT_core_list) + tmp44 := checkDerefVar(var_glojure_DOT_core_apply) + tmp45 := checkDerefVar(var_glojure_DOT_core_vector) + tmp46 := checkDerefVar(var_glojure_DOT_core_seq) + tmp47 := checkDerefVar(var_glojure_DOT_core_concat) + tmp48 := checkDerefVar(var_glojure_DOT_core_list) + tmp49 := lang.Apply(tmp48, []any{sym_array}) + tmp50 := checkDerefVar(var_glojure_DOT_core_list) + tmp51 := lang.Apply(tmp50, []any{sym_idx}) + tmp52 := checkDerefVar(var_glojure_DOT_core_list) + tmp53 := lang.Apply(tmp52, []any{sym_idx2}) + tmp54 := checkDerefVar(var_glojure_DOT_core_list) + tmp55 := lang.Apply(tmp54, []any{sym__AMP_}) + tmp56 := checkDerefVar(var_glojure_DOT_core_list) + tmp57 := lang.Apply(tmp56, []any{sym_idxv}) + tmp58 := lang.Apply(tmp47, []any{tmp49, tmp51, tmp53, tmp55, tmp57}) + tmp59 := lang.Apply(tmp46, []any{tmp58}) + tmp60 := lang.Apply(tmp44, []any{tmp45, tmp59}) + tmp61 := lang.Apply(tmp43, []any{tmp60}) + tmp62 := lang.Apply(tmp27, []any{tmp42, tmp61}) + tmp63 := lang.Apply(tmp26, []any{tmp62}) + tmp64 := lang.Apply(tmp25, []any{tmp63}) + tmp65 := lang.Apply(tmp22, []any{tmp24, tmp64}) + tmp66 := lang.Apply(tmp21, []any{tmp65}) + tmp67 := lang.Apply(tmp20, []any{tmp66}) + tmp68 := lang.Apply(tmp17, []any{tmp19, tmp67}) + tmp69 := lang.Apply(tmp16, []any{tmp68}) + tmp70 := lang.Apply(tmp14, []any{tmp15, tmp69}) + tmp71 := lang.Apply(tmp13, []any{tmp70}) + tmp72 := checkDerefVar(var_glojure_DOT_core_list) + tmp73 := checkDerefVar(var_glojure_DOT_core_seq) + tmp74 := checkDerefVar(var_glojure_DOT_core_concat) + tmp75 := checkDerefVar(var_glojure_DOT_core_list) + tmp76 := checkDerefVar(var_glojure_DOT_core_apply) + tmp77 := checkDerefVar(var_glojure_DOT_core_vector) + tmp78 := checkDerefVar(var_glojure_DOT_core_seq) + tmp79 := checkDerefVar(var_glojure_DOT_core_concat) + tmp80 := checkDerefVar(var_glojure_DOT_core_list) + tmp81 := lang.Apply(tmp80, []any{sym_array__0__auto__}) + tmp82 := checkDerefVar(var_glojure_DOT_core_list) + tmp83 := lang.Apply(tmp82, []any{sym_idx__1__auto__}) + tmp84 := checkDerefVar(var_glojure_DOT_core_list) + tmp85 := lang.Apply(tmp84, []any{sym_val__2__auto__}) + tmp86 := lang.Apply(tmp79, []any{tmp81, tmp83, tmp85}) + tmp87 := lang.Apply(tmp78, []any{tmp86}) + tmp88 := lang.Apply(tmp76, []any{tmp77, tmp87}) + tmp89 := lang.Apply(tmp75, []any{tmp88}) + tmp90 := checkDerefVar(var_glojure_DOT_core_list) + tmp91 := checkDerefVar(var_glojure_DOT_core_seq) + tmp92 := checkDerefVar(var_glojure_DOT_core_concat) + tmp93 := checkDerefVar(var_glojure_DOT_core_list) + tmp94 := lang.Apply(tmp93, []any{sym__DOT_}) + tmp95 := checkDerefVar(var_glojure_DOT_core_list) + tmp96 := lang.Apply(tmp95, []any{sym_glojure_DOT_core_SLASH_Array}) + tmp97 := checkDerefVar(var_glojure_DOT_core_list) + tmp98 := checkDerefVar(var_glojure_DOT_core_seq) + tmp99 := checkDerefVar(var_glojure_DOT_core_concat) + tmp100 := checkDerefVar(var_glojure_DOT_core_list) + tmp101 := lang.Apply(tmp100, []any{v5}) + tmp102 := checkDerefVar(var_glojure_DOT_core_list) + tmp103 := lang.Apply(tmp102, []any{sym_array__0__auto__}) + tmp104 := checkDerefVar(var_glojure_DOT_core_list) + tmp105 := lang.Apply(tmp104, []any{sym_idx__1__auto__}) + tmp106 := checkDerefVar(var_glojure_DOT_core_list) + tmp107 := checkDerefVar(var_glojure_DOT_core_seq) + tmp108 := checkDerefVar(var_glojure_DOT_core_concat) + tmp109 := checkDerefVar(var_glojure_DOT_core_list) + tmp110 := lang.Apply(tmp109, []any{v6}) + tmp111 := checkDerefVar(var_glojure_DOT_core_list) + tmp112 := lang.Apply(tmp111, []any{sym_val__2__auto__}) + tmp113 := lang.Apply(tmp108, []any{tmp110, tmp112}) + tmp114 := lang.Apply(tmp107, []any{tmp113}) + tmp115 := lang.Apply(tmp106, []any{tmp114}) + tmp116 := lang.Apply(tmp99, []any{tmp101, tmp103, tmp105, tmp115}) + tmp117 := lang.Apply(tmp98, []any{tmp116}) + tmp118 := lang.Apply(tmp97, []any{tmp117}) + tmp119 := lang.Apply(tmp92, []any{tmp94, tmp96, tmp118}) + tmp120 := lang.Apply(tmp91, []any{tmp119}) + tmp121 := lang.Apply(tmp90, []any{tmp120}) + tmp122 := checkDerefVar(var_glojure_DOT_core_list) + tmp123 := lang.Apply(tmp122, []any{sym_val__2__auto__}) + tmp124 := lang.Apply(tmp74, []any{tmp89, tmp121, tmp123}) + tmp125 := lang.Apply(tmp73, []any{tmp124}) + tmp126 := lang.Apply(tmp72, []any{tmp125}) + tmp127 := checkDerefVar(var_glojure_DOT_core_list) + tmp128 := checkDerefVar(var_glojure_DOT_core_seq) + tmp129 := checkDerefVar(var_glojure_DOT_core_concat) + tmp130 := checkDerefVar(var_glojure_DOT_core_list) + tmp131 := checkDerefVar(var_glojure_DOT_core_apply) + tmp132 := checkDerefVar(var_glojure_DOT_core_vector) + tmp133 := checkDerefVar(var_glojure_DOT_core_seq) + tmp134 := checkDerefVar(var_glojure_DOT_core_concat) + tmp135 := checkDerefVar(var_glojure_DOT_core_list) + tmp136 := lang.Apply(tmp135, []any{sym_array__0__auto__}) + tmp137 := checkDerefVar(var_glojure_DOT_core_list) + tmp138 := lang.Apply(tmp137, []any{sym_idx__1__auto__}) + tmp139 := checkDerefVar(var_glojure_DOT_core_list) + tmp140 := lang.Apply(tmp139, []any{sym_idx2__3__auto__}) + tmp141 := checkDerefVar(var_glojure_DOT_core_list) + tmp142 := lang.Apply(tmp141, []any{sym__AMP_}) + tmp143 := checkDerefVar(var_glojure_DOT_core_list) + tmp144 := lang.Apply(tmp143, []any{sym_idxv__4__auto__}) + tmp145 := lang.Apply(tmp134, []any{tmp136, tmp138, tmp140, tmp142, tmp144}) + tmp146 := lang.Apply(tmp133, []any{tmp145}) + tmp147 := lang.Apply(tmp131, []any{tmp132, tmp146}) + tmp148 := lang.Apply(tmp130, []any{tmp147}) + tmp149 := checkDerefVar(var_glojure_DOT_core_list) + tmp150 := checkDerefVar(var_glojure_DOT_core_seq) + tmp151 := checkDerefVar(var_glojure_DOT_core_concat) + tmp152 := checkDerefVar(var_glojure_DOT_core_list) + tmp153 := lang.Apply(tmp152, []any{sym_glojure_DOT_core_SLASH_apply}) + tmp154 := checkDerefVar(var_glojure_DOT_core_list) + tmp155 := lang.Apply(tmp154, []any{v4}) + tmp156 := checkDerefVar(var_glojure_DOT_core_list) + tmp157 := checkDerefVar(var_glojure_DOT_core_seq) + tmp158 := checkDerefVar(var_glojure_DOT_core_concat) + tmp159 := checkDerefVar(var_glojure_DOT_core_list) + tmp160 := lang.Apply(tmp159, []any{sym_glojure_DOT_core_SLASH_aget}) + tmp161 := checkDerefVar(var_glojure_DOT_core_list) + tmp162 := lang.Apply(tmp161, []any{sym_array__0__auto__}) + tmp163 := checkDerefVar(var_glojure_DOT_core_list) + tmp164 := lang.Apply(tmp163, []any{sym_idx__1__auto__}) + tmp165 := lang.Apply(tmp158, []any{tmp160, tmp162, tmp164}) + tmp166 := lang.Apply(tmp157, []any{tmp165}) + tmp167 := lang.Apply(tmp156, []any{tmp166}) + tmp168 := checkDerefVar(var_glojure_DOT_core_list) + tmp169 := lang.Apply(tmp168, []any{sym_idx2__3__auto__}) + tmp170 := checkDerefVar(var_glojure_DOT_core_list) + tmp171 := lang.Apply(tmp170, []any{sym_idxv__4__auto__}) + tmp172 := lang.Apply(tmp151, []any{tmp153, tmp155, tmp167, tmp169, tmp171}) + tmp173 := lang.Apply(tmp150, []any{tmp172}) + tmp174 := lang.Apply(tmp149, []any{tmp173}) + tmp175 := lang.Apply(tmp129, []any{tmp148, tmp174}) + tmp176 := lang.Apply(tmp128, []any{tmp175}) + tmp177 := lang.Apply(tmp127, []any{tmp176}) + tmp178 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp71, tmp126, tmp177}) + tmp179 := lang.Apply(tmp7, []any{tmp178}) + return tmp179 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_def_DASH_aset = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_def_DASH_aset.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // definline + { + tmp0 := sym_definline.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym__AMP_, sym_decl)), kw_doc, "Experimental - like defmacro, except defines a named function whose\n body is the expansion, calls to which may be expanded inline as if\n it were a macro. Cannot be used with variadic (&) args.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(11), kw_line, int(5253), kw_end_DASH_line, int(5253))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "vec__771" + tmp7 := checkDerefVar(var_glojure_DOT_core_split_DASH_with) + tmp8 := checkDerefVar(var_glojure_DOT_core_comp) + tmp9 := checkDerefVar(var_glojure_DOT_core_not) + tmp10 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp11 := lang.Apply(tmp8, []any{tmp9, tmp10}) + tmp12 := lang.Apply(tmp7, []any{tmp11, v5}) + var v13 any = tmp12 + _ = v13 + // let binding "pre-args" + tmp14 := checkDerefVar(var_glojure_DOT_core_nth) + tmp15 := lang.Apply(tmp14, []any{v13, int64(0), nil}) + var v16 any = tmp15 + _ = v16 + // let binding "vec__774" + tmp17 := checkDerefVar(var_glojure_DOT_core_nth) + tmp18 := lang.Apply(tmp17, []any{v13, int64(1), nil}) + var v19 any = tmp18 + _ = v19 + // let binding "args" + tmp20 := checkDerefVar(var_glojure_DOT_core_nth) + tmp21 := lang.Apply(tmp20, []any{v19, int64(0), nil}) + var v22 any = tmp21 + _ = v22 + // let binding "expr" + tmp23 := checkDerefVar(var_glojure_DOT_core_nth) + tmp24 := lang.Apply(tmp23, []any{v19, int64(1), nil}) + var v25 any = tmp24 + _ = v25 + tmp26 := checkDerefVar(var_glojure_DOT_core_seq) + tmp27 := checkDerefVar(var_glojure_DOT_core_concat) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := lang.Apply(tmp28, []any{sym_do}) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := checkDerefVar(var_glojure_DOT_core_seq) + tmp32 := checkDerefVar(var_glojure_DOT_core_concat) + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{sym_glojure_DOT_core_SLASH_defn}) + tmp35 := checkDerefVar(var_glojure_DOT_core_list) + tmp36 := lang.Apply(tmp35, []any{v4}) + tmp37 := checkDerefVar(var_glojure_DOT_core_list) + tmp38 := lang.Apply(tmp37, []any{v22}) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := checkDerefVar(var_glojure_DOT_core_apply) + tmp41 := checkDerefVar(var_glojure_DOT_core_eval) + tmp42 := checkDerefVar(var_glojure_DOT_core_list) + tmp43 := lang.Apply(tmp42, []any{sym_glojure_DOT_core_SLASH_fn, v22, v25}) + tmp44 := lang.Apply(tmp41, []any{tmp43}) + tmp45 := lang.Apply(tmp40, []any{tmp44, v22}) + tmp46 := lang.Apply(tmp39, []any{tmp45}) + tmp47 := lang.Apply(tmp32, []any{tmp34, tmp36, v16, tmp38, tmp46}) + tmp48 := lang.Apply(tmp31, []any{tmp47}) + tmp49 := lang.Apply(tmp30, []any{tmp48}) + tmp50 := checkDerefVar(var_glojure_DOT_core_list) + tmp51 := checkDerefVar(var_glojure_DOT_core_seq) + tmp52 := checkDerefVar(var_glojure_DOT_core_concat) + tmp53 := checkDerefVar(var_glojure_DOT_core_list) + tmp54 := lang.Apply(tmp53, []any{sym_glojure_DOT_core_SLASH_alter_DASH_meta_BANG_}) + tmp55 := checkDerefVar(var_glojure_DOT_core_list) + tmp56 := checkDerefVar(var_glojure_DOT_core_seq) + tmp57 := checkDerefVar(var_glojure_DOT_core_concat) + tmp58 := checkDerefVar(var_glojure_DOT_core_list) + tmp59 := lang.Apply(tmp58, []any{sym_var}) + tmp60 := checkDerefVar(var_glojure_DOT_core_list) + tmp61 := lang.Apply(tmp60, []any{v4}) + tmp62 := lang.Apply(tmp57, []any{tmp59, tmp61}) + tmp63 := lang.Apply(tmp56, []any{tmp62}) + tmp64 := lang.Apply(tmp55, []any{tmp63}) + tmp65 := checkDerefVar(var_glojure_DOT_core_list) + tmp66 := lang.Apply(tmp65, []any{sym_glojure_DOT_core_SLASH_assoc}) + tmp67 := checkDerefVar(var_glojure_DOT_core_list) + tmp68 := lang.Apply(tmp67, []any{kw_inline}) + tmp69 := checkDerefVar(var_glojure_DOT_core_list) + tmp70 := checkDerefVar(var_glojure_DOT_core_seq) + tmp71 := checkDerefVar(var_glojure_DOT_core_concat) + tmp72 := checkDerefVar(var_glojure_DOT_core_list) + tmp73 := lang.Apply(tmp72, []any{sym_glojure_DOT_core_SLASH_fn}) + tmp74 := checkDerefVar(var_glojure_DOT_core_list) + tmp75 := lang.Apply(tmp74, []any{v4}) + tmp76 := checkDerefVar(var_glojure_DOT_core_list) + tmp77 := lang.Apply(tmp76, []any{v22}) + tmp78 := checkDerefVar(var_glojure_DOT_core_list) + tmp79 := lang.Apply(tmp78, []any{v25}) + tmp80 := lang.Apply(tmp71, []any{tmp73, tmp75, tmp77, tmp79}) + tmp81 := lang.Apply(tmp70, []any{tmp80}) + tmp82 := lang.Apply(tmp69, []any{tmp81}) + tmp83 := lang.Apply(tmp52, []any{tmp54, tmp64, tmp66, tmp68, tmp82}) + tmp84 := lang.Apply(tmp51, []any{tmp83}) + tmp85 := lang.Apply(tmp50, []any{tmp84}) + tmp86 := checkDerefVar(var_glojure_DOT_core_list) + tmp87 := checkDerefVar(var_glojure_DOT_core_seq) + tmp88 := checkDerefVar(var_glojure_DOT_core_concat) + tmp89 := checkDerefVar(var_glojure_DOT_core_list) + tmp90 := lang.Apply(tmp89, []any{sym_var}) + tmp91 := checkDerefVar(var_glojure_DOT_core_list) + tmp92 := lang.Apply(tmp91, []any{v4}) + tmp93 := lang.Apply(tmp88, []any{tmp90, tmp92}) + tmp94 := lang.Apply(tmp87, []any{tmp93}) + tmp95 := lang.Apply(tmp86, []any{tmp94}) + tmp96 := lang.Apply(tmp27, []any{tmp29, tmp49, tmp85, tmp95}) + tmp97 := lang.Apply(tmp26, []any{tmp96}) + tmp6 = tmp97 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_definline = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_definline.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // defmacro + { + tmp0 := sym_defmacro.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym_doc_DASH_string_QMARK_, sym_attr_DASH_map_QMARK_, lang.NewVector(sym_params_STAR_), sym_body), lang.NewVector(sym_name, sym_doc_DASH_string_QMARK_, sym_attr_DASH_map_QMARK_, lang.NewList(lang.NewVector(sym_params_STAR_), sym_body), sym__PLUS_, sym_attr_DASH_map_QMARK_)), kw_doc, "Like defn, but the resulting function name is declared as a\n macro and will be used as a macro by the compiler when it is\n called.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(2), kw_line, int(445), kw_end_DASH_line, int(451))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "prefix" + var tmp7 any + { // let + // let binding "p" + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{v4}) + var v10 any = tmp9 + _ = v10 + // let binding "args" + var v11 any = v5 + _ = v11 + for { + var tmp12 any + { // let + // let binding "f" + tmp13 := checkDerefVar(var_glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v11}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + tmp17 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp18 := lang.Apply(tmp17, []any{v15}) + if lang.IsTruthy(tmp18) { + tmp20 := checkDerefVar(var_glojure_DOT_core_cons) + tmp21 := lang.Apply(tmp20, []any{v15, v10}) + var tmp19 any = tmp21 + tmp23 := checkDerefVar(var_glojure_DOT_core_next) + tmp24 := lang.Apply(tmp23, []any{v11}) + var tmp22 any = tmp24 + v10 = tmp19 + v11 = tmp22 + continue + } else { + var tmp25 any + tmp26 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp27 := lang.Apply(tmp26, []any{v15}) + if lang.IsTruthy(tmp27) { + tmp29 := checkDerefVar(var_glojure_DOT_core_cons) + tmp30 := lang.Apply(tmp29, []any{v15, v10}) + var tmp28 any = tmp30 + tmp32 := checkDerefVar(var_glojure_DOT_core_next) + tmp33 := lang.Apply(tmp32, []any{v11}) + var tmp31 any = tmp33 + v10 = tmp28 + v11 = tmp31 + continue + } else { + tmp25 = v10 + } + tmp16 = tmp25 + } + tmp12 = tmp16 + } // end let + tmp7 = tmp12 + break + } + } // end let + var v8 any = tmp7 + _ = v8 + // let binding "fdecl" + var tmp9 any + { // let + // let binding "fd" + var v10 any = v5 + _ = v10 + for { + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp13 := checkDerefVar(var_glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v10}) + tmp15 := lang.Apply(tmp12, []any{tmp14}) + if lang.IsTruthy(tmp15) { + tmp17 := checkDerefVar(var_glojure_DOT_core_next) + tmp18 := lang.Apply(tmp17, []any{v10}) + var tmp16 any = tmp18 + v10 = tmp16 + continue + } else { + var tmp19 any + tmp20 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp21 := checkDerefVar(var_glojure_DOT_core_first) + tmp22 := lang.Apply(tmp21, []any{v10}) + tmp23 := lang.Apply(tmp20, []any{tmp22}) + if lang.IsTruthy(tmp23) { + tmp25 := checkDerefVar(var_glojure_DOT_core_next) + tmp26 := lang.Apply(tmp25, []any{v10}) + var tmp24 any = tmp26 + v10 = tmp24 + continue + } else { + tmp19 = v10 + } + tmp11 = tmp19 + } + tmp9 = tmp11 + break + } + } // end let + var v10 any = tmp9 + _ = v10 + // let binding "fdecl" + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp13 := checkDerefVar(var_glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v10}) + tmp15 := lang.Apply(tmp12, []any{tmp14}) + if lang.IsTruthy(tmp15) { + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v10}) + tmp11 = tmp17 + } else { + tmp11 = v10 + } + var v18 any = tmp11 + _ = v18 + // let binding "add-implicit-args" + var tmp19 lang.FnFunc + tmp19 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v20 := args[0] + _ = v20 + var tmp21 any + { // let + // let binding "args" + tmp22 := checkDerefVar(var_glojure_DOT_core_first) + tmp23 := lang.Apply(tmp22, []any{v20}) + var v24 any = tmp23 + _ = v24 + tmp25 := checkDerefVar(var_glojure_DOT_core_cons) + tmp26 := checkDerefVar(var_glojure_DOT_core_vec) + tmp27 := checkDerefVar(var_glojure_DOT_core_cons) + tmp28 := checkDerefVar(var_glojure_DOT_core_cons) + tmp29 := lang.Apply(tmp28, []any{sym__AMP_env, v24}) + tmp30 := lang.Apply(tmp27, []any{sym__AMP_form, tmp29}) + tmp31 := lang.Apply(tmp26, []any{tmp30}) + tmp32 := checkDerefVar(var_glojure_DOT_core_next) + tmp33 := lang.Apply(tmp32, []any{v20}) + tmp34 := lang.Apply(tmp25, []any{tmp31, tmp33}) + tmp21 = tmp34 + } // end let + return tmp21 + }) + tmp20 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(469), kw_column, int(38), kw_end_DASH_line, int(471), kw_end_DASH_column, int(87)) + tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v22 any = tmp21 + _ = v22 + // let binding "add-args" + var tmp23 lang.FnFunc + tmp23 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v24 := args[0] + _ = v24 + v25 := args[1] + _ = v25 + recur_loop_1601: + var tmp26 any + tmp27 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp28 := lang.Apply(tmp27, []any{v25}) + if lang.IsTruthy(tmp28) { + tmp26 = v24 + } else { + var tmp29 any + { // let + // let binding "d" + tmp30 := checkDerefVar(var_glojure_DOT_core_first) + tmp31 := lang.Apply(tmp30, []any{v25}) + var v32 any = tmp31 + _ = v32 + var tmp33 any + tmp34 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp35 := lang.Apply(tmp34, []any{v32}) + if lang.IsTruthy(tmp35) { + tmp36 := checkDerefVar(var_glojure_DOT_core_conj) + tmp37 := lang.Apply(tmp36, []any{v24, v32}) + tmp33 = tmp37 + } else { + tmp39 := checkDerefVar(var_glojure_DOT_core_conj) + tmp40 := lang.Apply(v22, []any{v32}) + tmp41 := lang.Apply(tmp39, []any{v24, tmp40}) + var tmp38 any = tmp41 + tmp43 := checkDerefVar(var_glojure_DOT_core_next) + tmp44 := lang.Apply(tmp43, []any{v25}) + var tmp42 any = tmp44 + v24 = tmp38 + v25 = tmp42 + goto recur_loop_1601 + } + tmp29 = tmp33 + } // end let + tmp26 = tmp29 + } + return tmp26 + }) + tmp24 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(472), kw_column, int(29), kw_end_DASH_line, int(478), kw_end_DASH_column, int(90)) + tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v26 any = tmp25 + _ = v26 + // let binding "fdecl" + tmp27 := checkDerefVar(var_glojure_DOT_core_seq) + tmp28 := lang.NewVector() + tmp29 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(479), kw_column, int(41), kw_end_DASH_line, int(479), kw_end_DASH_column, int(42)) + tmp30, err := lang.WithMeta(tmp28, tmp29.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp31 := lang.Apply(v26, []any{tmp30, v18}) + tmp32 := lang.Apply(tmp27, []any{tmp31}) + var v33 any = tmp32 + _ = v33 + // let binding "decl" + var tmp34 any + { // let + // let binding "p" + var v35 any = v8 + _ = v35 + // let binding "d" + var v36 any = v33 + _ = v36 + for { + var tmp37 any + if lang.IsTruthy(v35) { + tmp39 := checkDerefVar(var_glojure_DOT_core_next) + tmp40 := lang.Apply(tmp39, []any{v35}) + var tmp38 any = tmp40 + tmp42 := checkDerefVar(var_glojure_DOT_core_cons) + tmp43 := checkDerefVar(var_glojure_DOT_core_first) + tmp44 := lang.Apply(tmp43, []any{v35}) + tmp45 := lang.Apply(tmp42, []any{tmp44, v36}) + var tmp41 any = tmp45 + v35 = tmp38 + v36 = tmp41 + continue + } else { + tmp37 = v36 + } + tmp34 = tmp37 + break + } + } // end let + var v35 any = tmp34 + _ = v35 + tmp36 := checkDerefVar(var_glojure_DOT_core_list) + tmp37 := checkDerefVar(var_glojure_DOT_core_cons) + tmp38 := lang.Apply(tmp37, []any{sym_glojure_DOT_core_SLASH_defn, v35}) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{sym_var, v4}) + tmp42 := lang.Apply(tmp39, []any{sym__DOT_, tmp41, lang.NewList(sym_SetMacro)}) + tmp43 := checkDerefVar(var_glojure_DOT_core_list) + tmp44 := lang.Apply(tmp43, []any{sym_var, v4}) + tmp45 := lang.Apply(tmp36, []any{sym_do, tmp38, tmp42, tmp44}) + tmp6 = tmp45 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(451), kw_column, int(11), kw_end_DASH_line, int(487), kw_end_DASH_column, int(40))).(lang.FnFunc) + var_glojure_DOT_core_defmacro = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_defmacro.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // defn + { + tmp0 := sym_defn.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym_doc_DASH_string_QMARK_, sym_attr_DASH_map_QMARK_, lang.NewVector(sym_params_STAR_), sym_prepost_DASH_map_QMARK_, sym_body), lang.NewVector(sym_name, sym_doc_DASH_string_QMARK_, sym_attr_DASH_map_QMARK_, lang.NewList(lang.NewVector(sym_params_STAR_), sym_prepost_DASH_map_QMARK_, sym_body), sym__PLUS_, sym_attr_DASH_map_QMARK_)), kw_doc, "Same as (def name (fn [params* ] exprs*)) or (def\n name (fn ([params* ] exprs*)+)) with any doc-string or attrs added\n to the var metadata. prepost-map defines a map with optional keys\n :pre and :post that contain collections of pre or post conditions.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(5), kw_column, int(2), kw_line, int(284), kw_end_DASH_line, int(291))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function defn + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp9 := reflect.TypeOf((*lang.Symbol)(nil)) + tmp10 := lang.Apply(tmp8, []any{tmp9, v5}) + if lang.IsTruthy(tmp10) { + } else { + tmp11 := lang.Apply(lang.NewIllegalArgumentError, []any{"First argument to defn must be a symbol"}) + panic(tmp11) + } + _ = tmp7 + var tmp12 any + { // let + // let binding "m" + var tmp13 any + tmp14 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp15 := checkDerefVar(var_glojure_DOT_core_first) + tmp16 := lang.Apply(tmp15, []any{v6}) + tmp17 := lang.Apply(tmp14, []any{tmp16}) + if lang.IsTruthy(tmp17) { + tmp18 := checkDerefVar(var_glojure_DOT_core_first) + tmp19 := lang.Apply(tmp18, []any{v6}) + tmp20 := lang.NewMap(kw_doc, tmp19) + tmp21 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(297), kw_column, int(19), kw_end_DASH_line, int(297), kw_end_DASH_column, int(38)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 = tmp22 + } else { + tmp23 := lang.NewMap() + tmp24 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(298), kw_column, int(19), kw_end_DASH_line, int(298), kw_end_DASH_column, int(20)) + tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 = tmp25 + } + var v26 any = tmp13 + _ = v26 + // let binding "fdecl" + var tmp27 any + tmp28 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp29 := checkDerefVar(var_glojure_DOT_core_first) + tmp30 := lang.Apply(tmp29, []any{v6}) + tmp31 := lang.Apply(tmp28, []any{tmp30}) + if lang.IsTruthy(tmp31) { + tmp32 := checkDerefVar(var_glojure_DOT_core_next) + tmp33 := lang.Apply(tmp32, []any{v6}) + tmp27 = tmp33 + } else { + tmp27 = v6 + } + var v34 any = tmp27 + _ = v34 + // let binding "m" + var tmp35 any + tmp36 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp37 := checkDerefVar(var_glojure_DOT_core_first) + tmp38 := lang.Apply(tmp37, []any{v34}) + tmp39 := lang.Apply(tmp36, []any{tmp38}) + if lang.IsTruthy(tmp39) { + tmp40 := checkDerefVar(var_glojure_DOT_core_conj) + tmp41 := checkDerefVar(var_glojure_DOT_core_first) + tmp42 := lang.Apply(tmp41, []any{v34}) + tmp43 := lang.Apply(tmp40, []any{v26, tmp42}) + tmp35 = tmp43 + } else { + tmp35 = v26 + } + var v44 any = tmp35 + _ = v44 + // let binding "fdecl" + var tmp45 any + tmp46 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp47 := checkDerefVar(var_glojure_DOT_core_first) + tmp48 := lang.Apply(tmp47, []any{v34}) + tmp49 := lang.Apply(tmp46, []any{tmp48}) + if lang.IsTruthy(tmp49) { + tmp50 := checkDerefVar(var_glojure_DOT_core_next) + tmp51 := lang.Apply(tmp50, []any{v34}) + tmp45 = tmp51 + } else { + tmp45 = v34 + } + var v52 any = tmp45 + _ = v52 + // let binding "fdecl" + var tmp53 any + tmp54 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp55 := checkDerefVar(var_glojure_DOT_core_first) + tmp56 := lang.Apply(tmp55, []any{v52}) + tmp57 := lang.Apply(tmp54, []any{tmp56}) + if lang.IsTruthy(tmp57) { + tmp58 := checkDerefVar(var_glojure_DOT_core_list) + tmp59 := lang.Apply(tmp58, []any{v52}) + tmp53 = tmp59 + } else { + tmp53 = v52 + } + var v60 any = tmp53 + _ = v60 + // let binding "m" + var tmp61 any + tmp62 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp63 := checkDerefVar(var_glojure_DOT_core_last) + tmp64 := lang.Apply(tmp63, []any{v60}) + tmp65 := lang.Apply(tmp62, []any{tmp64}) + if lang.IsTruthy(tmp65) { + tmp66 := checkDerefVar(var_glojure_DOT_core_conj) + tmp67 := checkDerefVar(var_glojure_DOT_core_last) + tmp68 := lang.Apply(tmp67, []any{v60}) + tmp69 := lang.Apply(tmp66, []any{v44, tmp68}) + tmp61 = tmp69 + } else { + tmp61 = v44 + } + var v70 any = tmp61 + _ = v70 + // let binding "fdecl" + var tmp71 any + tmp72 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp73 := checkDerefVar(var_glojure_DOT_core_last) + tmp74 := lang.Apply(tmp73, []any{v60}) + tmp75 := lang.Apply(tmp72, []any{tmp74}) + if lang.IsTruthy(tmp75) { + tmp76 := checkDerefVar(var_glojure_DOT_core_butlast) + tmp77 := lang.Apply(tmp76, []any{v60}) + tmp71 = tmp77 + } else { + tmp71 = v60 + } + var v78 any = tmp71 + _ = v78 + // let binding "m" + tmp79 := checkDerefVar(var_glojure_DOT_core_conj) + tmp80 := checkDerefVar(var_glojure_DOT_core_list) + tmp81 := checkDerefVar(var_glojure_DOT_core_sigs) + tmp82 := lang.Apply(tmp81, []any{v78}) + tmp83 := lang.Apply(tmp80, []any{sym_quote, tmp82}) + tmp84 := lang.NewMap(kw_arglists, tmp83) + tmp85 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(317), kw_column, int(23), kw_end_DASH_line, int(317), kw_end_DASH_column, int(60)) + tmp86, err := lang.WithMeta(tmp84, tmp85.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp87 := lang.Apply(tmp79, []any{tmp86, v70}) + var v88 any = tmp87 + _ = v88 + // let binding "m" + var tmp89 any + { // let + // let binding "inline" + tmp90 := lang.Apply(kw_inline, []any{v88}) + var v91 any = tmp90 + _ = v91 + // let binding "ifn" + tmp92 := checkDerefVar(var_glojure_DOT_core_first) + tmp93 := lang.Apply(tmp92, []any{v91}) + var v94 any = tmp93 + _ = v94 + // let binding "iname" + tmp95 := checkDerefVar(var_glojure_DOT_core_second) + tmp96 := lang.Apply(tmp95, []any{v91}) + var v97 any = tmp96 + _ = v97 + var tmp98 any + var tmp99 any + tmp100 := lang.Apply(lang.Equiv, []any{sym_fn, v94}) + if lang.IsTruthy(tmp100) { + var tmp101 any + tmp102 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp103 := reflect.TypeOf((*lang.Symbol)(nil)) + tmp104 := lang.Apply(tmp102, []any{tmp103, v97}) + if lang.IsTruthy(tmp104) { + tmp101 = false + } else { + tmp101 = true + } + tmp99 = tmp101 + } else { + } + if lang.IsTruthy(tmp99) { + tmp105 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp106 := checkDerefVar(var_glojure_DOT_core_cons) + tmp107 := checkDerefVar(var_glojure_DOT_core_cons) + tmp108, ok := lang.FieldOrMethod(v5, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "Name"))) + } + var tmp109 any + switch reflect.TypeOf(tmp108).Kind() { + case reflect.Func: + tmp109 = lang.Apply(tmp108, nil) + default: + tmp109 = tmp108 + } + tmp110 := lang.Apply(lang.ConcatStrings, []any{tmp109, "__inliner"}) + tmp111 := lang.Apply(lang.NewSymbol, []any{tmp110}) + tmp112 := checkDerefVar(var_glojure_DOT_core_next) + tmp113 := lang.Apply(tmp112, []any{v91}) + tmp114 := lang.Apply(tmp107, []any{tmp111, tmp113}) + tmp115 := lang.Apply(tmp106, []any{v94, tmp114}) + tmp116 := lang.Apply(tmp105, []any{v88, kw_inline, tmp115}) + tmp98 = tmp116 + } else { + tmp98 = v88 + } + tmp89 = tmp98 + } // end let + var v90 any = tmp89 + _ = v90 + // let binding "m" + tmp91 := checkDerefVar(var_glojure_DOT_core_conj) + var tmp92 any + tmp93 := checkDerefVar(var_glojure_DOT_core_meta) + tmp94 := lang.Apply(tmp93, []any{v5}) + if lang.IsTruthy(tmp94) { + tmp95 := checkDerefVar(var_glojure_DOT_core_meta) + tmp96 := lang.Apply(tmp95, []any{v5}) + tmp92 = tmp96 + } else { + tmp97 := lang.NewMap() + tmp98 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(328), kw_column, int(51), kw_end_DASH_line, int(328), kw_end_DASH_column, int(52)) + tmp99, err := lang.WithMeta(tmp97, tmp98.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp92 = tmp99 + } + tmp100 := lang.Apply(tmp91, []any{tmp92, v90}) + var v101 any = tmp100 + _ = v101 + tmp102 := checkDerefVar(var_glojure_DOT_core_list) + tmp103 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp104 := lang.Apply(tmp103, []any{v5, v101}) + tmp105 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp106 := checkDerefVar(var_glojure_DOT_core_cons) + tmp107 := lang.Apply(tmp106, []any{sym_glojure_DOT_core_SLASH_fn, v78}) + tmp108 := lang.Apply(kw_tag, []any{v101}) + tmp109 := lang.NewMap(kw_rettag, tmp108) + tmp110 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(333), kw_column, int(37), kw_end_DASH_line, int(333), kw_end_DASH_column, int(54)) + tmp111, err := lang.WithMeta(tmp109, tmp110.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp112 := lang.Apply(tmp105, []any{tmp107, tmp111}) + tmp113 := lang.Apply(tmp102, []any{sym_def, tmp104, tmp112}) + tmp12 = tmp113 + } // end let + return tmp12 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(291), kw_column, int(7), kw_end_DASH_line, int(333), kw_end_DASH_column, int(58))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_defn = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_defn.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // defn- + { + tmp0 := sym_defn_DASH_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym__AMP_, sym_decls)), kw_doc, "same as defn, yielding non-public def", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(11), kw_line, int(4949), kw_end_DASH_line, int(4949))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp7 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp8 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp9 := checkDerefVar(var_glojure_DOT_core_meta) + tmp10 := lang.Apply(tmp9, []any{v4}) + tmp11 := lang.Apply(tmp8, []any{tmp10, kw_private, true}) + tmp12 := lang.Apply(tmp7, []any{v4, tmp11}) + tmp13 := lang.Apply(tmp6, []any{sym_glojure_DOT_core_SLASH_defn, tmp12, v5}) + return tmp13 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_defn_DASH_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_defn_DASH_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // defonce + { + tmp0 := sym_defonce.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym_expr)), kw_doc, "defs name to have the root value of the expr iff the named var has no root value,\n else expr is unevaluated", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(5806), kw_end_DASH_line, int(5806))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_let}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + tmp12 := checkDerefVar(var_glojure_DOT_core_vector) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_v__0__auto__}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{sym_def}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v4}) + tmp24 := lang.Apply(tmp19, []any{tmp21, tmp23}) + tmp25 := lang.Apply(tmp18, []any{tmp24}) + tmp26 := lang.Apply(tmp17, []any{tmp25}) + tmp27 := lang.Apply(tmp14, []any{tmp16, tmp26}) + tmp28 := lang.Apply(tmp13, []any{tmp27}) + tmp29 := lang.Apply(tmp11, []any{tmp12, tmp28}) + tmp30 := lang.Apply(tmp10, []any{tmp29}) + tmp31 := checkDerefVar(var_glojure_DOT_core_list) + tmp32 := checkDerefVar(var_glojure_DOT_core_seq) + tmp33 := checkDerefVar(var_glojure_DOT_core_concat) + tmp34 := checkDerefVar(var_glojure_DOT_core_list) + tmp35 := lang.Apply(tmp34, []any{sym_glojure_DOT_core_SLASH_when_DASH_not}) + tmp36 := checkDerefVar(var_glojure_DOT_core_list) + tmp37 := checkDerefVar(var_glojure_DOT_core_seq) + tmp38 := checkDerefVar(var_glojure_DOT_core_concat) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := lang.Apply(tmp39, []any{sym__DOT_HasRoot}) + tmp41 := checkDerefVar(var_glojure_DOT_core_list) + tmp42 := lang.Apply(tmp41, []any{sym_v__0__auto__}) + tmp43 := lang.Apply(tmp38, []any{tmp40, tmp42}) + tmp44 := lang.Apply(tmp37, []any{tmp43}) + tmp45 := lang.Apply(tmp36, []any{tmp44}) + tmp46 := checkDerefVar(var_glojure_DOT_core_list) + tmp47 := checkDerefVar(var_glojure_DOT_core_seq) + tmp48 := checkDerefVar(var_glojure_DOT_core_concat) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) + tmp50 := lang.Apply(tmp49, []any{sym_def}) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := lang.Apply(tmp51, []any{v4}) + tmp53 := checkDerefVar(var_glojure_DOT_core_list) + tmp54 := lang.Apply(tmp53, []any{v5}) + tmp55 := lang.Apply(tmp48, []any{tmp50, tmp52, tmp54}) + tmp56 := lang.Apply(tmp47, []any{tmp55}) + tmp57 := lang.Apply(tmp46, []any{tmp56}) + tmp58 := lang.Apply(tmp33, []any{tmp35, tmp45, tmp57}) + tmp59 := lang.Apply(tmp32, []any{tmp58}) + tmp60 := lang.Apply(tmp31, []any{tmp59}) + tmp61 := lang.Apply(tmp7, []any{tmp9, tmp30, tmp60}) + tmp62 := lang.Apply(tmp6, []any{tmp61}) + return tmp62 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_defonce = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_defonce.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // delay + { + tmp0 := sym_delay.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_body)), kw_doc, "Takes a body of expressions and yields a Delay object that will\n invoke the body only the first time it is forced (with force or deref/@), and\n will cache the result and return it on all subsequent force\n calls. See also - realized?", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(11), kw_line, int(739), kw_end_DASH_line, int(739))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_list) + tmp6 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp7 := lang.NewVector() + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(746), kw_column, int(62), kw_end_DASH_line, int(746), kw_end_DASH_column, int(63)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp10 := lang.Apply(tmp6, []any{sym_fn_STAR_, tmp9, v4}) + tmp11 := lang.Apply(tmp5, []any{sym_new, sym_glojure_DOT_lang_DOT_Delay, tmp10}) + return tmp11 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_delay = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_delay.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // deref-as-map + { + tmp0 := sym_deref_DASH_as_DASH_map.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(408), kw_column, int(8), kw_end_DASH_line, int(408), kw_end_DASH_column, int(19), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_o)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "pending" + var tmp4 any + { // let + // let binding "and__0__auto__" + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp6 := reflect.TypeOf((*lang.IPending)(nil)).Elem() + tmp7 := lang.Apply(tmp5, []any{tmp6, v2}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + tmp10 := checkDerefVar(var_glojure_DOT_core_not) + tmp11, ok := lang.FieldOrMethod(v2, "isRealized") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "isRealized"))) + } + var tmp12 any + switch reflect.TypeOf(tmp11).Kind() { + case reflect.Func: + tmp12 = lang.Apply(tmp11, nil) + default: + tmp12 = tmp11 + } + tmp13 := lang.Apply(tmp10, []any{tmp12}) + tmp9 = tmp13 + } else { + tmp9 = v8 + } + tmp4 = tmp9 + } // end let + var v5 any = tmp4 + _ = v5 + // let binding "vec__941" + var tmp6 any + if lang.IsTruthy(v5) { + } else { + var tmp7 any + func() { + defer func() { + if r := recover(); r != nil { + if lang.CatchMatches(r, lang.Throwable) { + v8 := r + _ = v8 + tmp9 := lang.NewVector(true, v8) + tmp10 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(415), kw_column, int(18), kw_end_DASH_line, int(415), kw_end_DASH_column, int(25)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp7 = tmp11 + } else { + panic(r) + } + } + }() + tmp8 := checkDerefVar(var_glojure_DOT_core_deref) + tmp9 := lang.Apply(tmp8, []any{v2}) + tmp10 := lang.NewVector(false, tmp9) + tmp11 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(413), kw_column, int(16), kw_end_DASH_line, int(413), kw_end_DASH_column, int(32)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp7 = tmp12 + }() + tmp6 = tmp7 + } + var v13 any = tmp6 + _ = v13 + // let binding "ex" + tmp14 := checkDerefVar(var_glojure_DOT_core_nth) + tmp15 := lang.Apply(tmp14, []any{v13, int64(0), nil}) + var v16 any = tmp15 + _ = v16 + // let binding "val" + tmp17 := checkDerefVar(var_glojure_DOT_core_nth) + tmp18 := lang.Apply(tmp17, []any{v13, int64(1), nil}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + var tmp21 any + { // let + // let binding "or__0__auto__" + var v22 any = v16 + _ = v22 + var tmp23 any + if lang.IsTruthy(v22) { + tmp23 = v22 + } else { + var tmp24 any + { // let + // let binding "and__0__auto__" + tmp25 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp26 := reflect.TypeOf((*lang.Agent)(nil)) + tmp27 := lang.Apply(tmp25, []any{tmp26, v2}) + var v28 any = tmp27 + _ = v28 + var tmp29 any + if lang.IsTruthy(v28) { + tmp30 := checkDerefVar(var_glojure_DOT_core_agent_DASH_error) + tmp31 := lang.Apply(tmp30, []any{v2}) + tmp29 = tmp31 + } else { + tmp29 = v28 + } + tmp24 = tmp29 + } // end let + tmp23 = tmp24 + } + tmp21 = tmp23 + } // end let + if lang.IsTruthy(tmp21) { + tmp20 = kw_failed + } else { + var tmp22 any + if lang.IsTruthy(v5) { + tmp22 = kw_pending + } else { + var tmp23 any + if lang.IsTruthy(kw_else) { + tmp23 = kw_ready + } else { + } + tmp22 = tmp23 + } + tmp20 = tmp22 + } + tmp24 := lang.NewMap(kw_status, tmp20, kw_val, v19) + tmp25 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(416), kw_column, int(5), kw_end_DASH_line, int(429), kw_end_DASH_column, int(14)) + tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp3 = tmp26 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_deref_DASH_as_DASH_map = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_deref_DASH_as_DASH_map.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // descendants + { + tmp0 := sym_descendants.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_tag), lang.NewVector(sym_h, sym_tag)), kw_doc, "Returns the immediate and indirect children of tag, through a\n relationship established via derive. h must be a hierarchy obtained\n from make-hierarchy, if not supplied defaults to the global\n hierarchy. Note: does not work on Java type inheritance\n relationships.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(5593), kw_end_DASH_line, int(5593))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_descendants) + tmp4 := checkDerefVar(var_glojure_DOT_core_global_DASH_hierarchy) + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_class_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + tmp7 := lang.Apply(lang.NewUnsupportedOperationError, []any{"Can't get descendants of classes"}) + panic(tmp7) + } else { + tmp8 := checkDerefVar(var_glojure_DOT_core_not_DASH_empty) + tmp9 := checkDerefVar(var_glojure_DOT_core_get) + tmp10 := lang.Apply(kw_descendants, []any{v2}) + tmp11 := lang.Apply(tmp9, []any{tmp10, v3}) + tmp12 := lang.Apply(tmp8, []any{tmp11}) + tmp4 = tmp12 + } + return tmp4 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_descendants = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_descendants.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // distinct + { + tmp0 := sym_distinct.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_coll)), kw_doc, "Returns a lazy sequence of the elements of coll with duplicates removed.\n Returns a stateful transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(5053), kw_end_DASH_line, int(5053))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + var tmp4 any + { // let + // let binding "seen" + tmp5 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) + tmp6 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5060), kw_column, int(28), kw_end_DASH_line, int(5060), kw_end_DASH_column, int(30)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp9 := lang.Apply(tmp5, []any{tmp8}) + var v10 any = tmp9 + _ = v10 + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp12 := lang.Apply(v3, nil) + return tmp12 + case 1: + v12 := args[0] + _ = v12 + tmp13 := lang.Apply(v3, []any{v12}) + return tmp13 + case 2: + v12 := args[0] + _ = v12 + v13 := args[1] + _ = v13 + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp16 := checkDerefVar(var_glojure_DOT_core_deref) + tmp17 := lang.Apply(tmp16, []any{v10}) + tmp18 := lang.Apply(tmp15, []any{tmp17, v13}) + if lang.IsTruthy(tmp18) { + tmp14 = v12 + } else { + tmp19 := checkDerefVar(var_glojure_DOT_core_conj) + tmp20, ok := lang.FieldOrMethod(v10, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v10, "Deref"))) + } + var tmp21 any + switch reflect.TypeOf(tmp20).Kind() { + case reflect.Func: + tmp21 = lang.Apply(tmp20, nil) + default: + tmp21 = tmp20 + } + tmp22 := lang.Apply(tmp19, []any{tmp21, v13}) + tmp23, _ := lang.FieldOrMethod(v10, "reset") + if reflect.TypeOf(tmp23).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) + } + tmp24 := lang.Apply(tmp23, []any{tmp22}) + _ = tmp24 + tmp25 := lang.Apply(v3, []any{v12, v13}) + tmp14 = tmp25 + } + return tmp14 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5061), kw_column, int(8), kw_end_DASH_line, int(5068), kw_end_DASH_column, int(37)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp4 = tmp13 + } // end let + return tmp4 + }) + tmp3 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5059), kw_column, int(4), kw_end_DASH_line, int(5068), kw_end_DASH_column, int(39)) + tmp4, err := lang.WithMeta(tmp2, tmp3.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp4 + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "step" + var tmp4 lang.FnFunc + { // function step + var v5 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + var tmp8 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + recur_loop_2417: + var tmp12 any + { // let + // let binding "vec__753" + var v13 any = v10 + _ = v13 + // let binding "f" + tmp14 := checkDerefVar(var_glojure_DOT_core_nth) + tmp15 := lang.Apply(tmp14, []any{v13, int64(0), nil}) + var v16 any = tmp15 + _ = v16 + // let binding "xs" + var v17 any = v13 + _ = v17 + var tmp18 any + { // let + // let binding "temp__0__auto__" + tmp19 := checkDerefVar(var_glojure_DOT_core_seq) + tmp20 := lang.Apply(tmp19, []any{v17}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + if lang.IsTruthy(v21) { + var tmp23 any + { // let + // let binding "s" + var v24 any = v21 + _ = v24 + var tmp25 any + tmp26 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp27 := lang.Apply(tmp26, []any{v11, v16}) + if lang.IsTruthy(tmp27) { + tmp29 := checkDerefVar(var_glojure_DOT_core_rest) + tmp30 := lang.Apply(tmp29, []any{v24}) + var tmp28 any = tmp30 + var tmp31 any = v11 + v10 = tmp28 + v11 = tmp31 + goto recur_loop_2417 + } else { + tmp32 := checkDerefVar(var_glojure_DOT_core_cons) + tmp33 := checkDerefVar(var_glojure_DOT_core_rest) + tmp34 := lang.Apply(tmp33, []any{v24}) + tmp35 := checkDerefVar(var_glojure_DOT_core_conj) + tmp36 := lang.Apply(tmp35, []any{v11, v16}) + tmp37 := lang.Apply(v5, []any{tmp34, tmp36}) + tmp38 := lang.Apply(tmp32, []any{v16, tmp37}) + tmp25 = tmp38 + } + tmp23 = tmp25 + } // end let + tmp22 = tmp23 + } else { + } + tmp18 = tmp22 + } // end let + tmp12 = tmp18 + } // end let + return tmp12 + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5072), kw_column, int(20), kw_end_DASH_line, int(5076), kw_end_DASH_column, int(66)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp12 := lang.Apply(tmp11, []any{v6, v7}) + return tmp12 + }) + tmp9 := lang.Apply(lang.NewLazySeq, []any{tmp8}) + return tmp9 + }) + v5 = tmp4 + _ = v5 + } + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5070), kw_column, int(15), kw_end_DASH_line, int(5077), kw_end_DASH_column, int(29)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v7 any = tmp6 + _ = v7 + tmp8 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5078), kw_column, int(17), kw_end_DASH_line, int(5078), kw_end_DASH_column, int(19)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp11 := lang.Apply(v7, []any{v2, tmp10}) + tmp3 = tmp11 + } // end let + return tmp3 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_distinct = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_distinct.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // dorun + { + tmp0 := sym_dorun.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll), lang.NewVector(sym_n, sym_coll)), kw_doc, "When lazy sequences are produced via functions that have side\n effects, any effects other than those needed to produce the first\n element in the seq do not occur until the seq is consumed. dorun can\n be used to force any effects. Walks through the successive nexts of\n the seq, does not retain the head and returns nil.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3116), kw_end_DASH_line, int(3116))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + recur_loop_2119: + var tmp3 any + { // let + // let binding "temp__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + var tmp8 any + { // let + // let binding "s" + var v9 any = v6 + _ = v9 + tmp11 := checkDerefVar(var_glojure_DOT_core_next) + tmp12 := lang.Apply(tmp11, []any{v9}) + var tmp10 any = tmp12 + v2 = tmp10 + goto recur_loop_2119 + } // end let + tmp7 = tmp8 + } else { + } + tmp3 = tmp7 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + recur_loop_2120: + var tmp4 any + var tmp5 any + { // let + // let binding "and__0__auto__" + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := lang.Apply(tmp6, []any{v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + tmp10 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp9 = tmp11 + } else { + tmp9 = v8 + } + tmp5 = tmp9 + } // end let + if lang.IsTruthy(tmp5) { + tmp7 := checkDerefVar(var_glojure_DOT_core_dec) + tmp8 := lang.Apply(tmp7, []any{v2}) + var tmp6 any = tmp8 + tmp10 := checkDerefVar(var_glojure_DOT_core_next) + tmp11 := lang.Apply(tmp10, []any{v3}) + var tmp9 any = tmp11 + v2 = tmp6 + v3 = tmp9 + goto recur_loop_2120 + } else { + } + return tmp4 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_dorun = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_dorun.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // dotimes + { + tmp0 := sym_dotimes.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "bindings => name n\n\n Repeatedly executes body (presumably for side-effects) with name\n bound to integers from 0 through n-1.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(3306), kw_end_DASH_line, int(3306))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v4}) + if lang.IsTruthy(tmp8) { + } else { + tmp9 := checkDerefVar(var_glojure_DOT_core_str) + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp13 := checkDerefVar(var_glojure_DOT_core_meta) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(kw_line, []any{tmp14}) + tmp16 := lang.Apply(tmp9, []any{tmp11, " requires ", "a vector for its binding", " in ", tmp12, ":", tmp15}) + tmp17 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp16}) + panic(tmp17) + } + _ = tmp6 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp20 := checkDerefVar(var_glojure_DOT_core_count) + tmp21 := lang.Apply(tmp20, []any{v4}) + tmp22 := lang.Apply(tmp19, []any{int64(2), tmp21}) + if lang.IsTruthy(tmp22) { + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp27 := checkDerefVar(var_glojure_DOT_core_meta) + tmp28 := lang.Apply(tmp27, []any{v2}) + tmp29 := lang.Apply(kw_line, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp25, " requires ", "exactly 2 forms in binding vector", " in ", tmp26, ":", tmp29}) + tmp31 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp31) + } + _ = tmp18 + var tmp32 any + { // let + // let binding "i" + tmp33 := checkDerefVar(var_glojure_DOT_core_first) + tmp34 := lang.Apply(tmp33, []any{v4}) + var v35 any = tmp34 + _ = v35 + // let binding "n" + tmp36 := checkDerefVar(var_glojure_DOT_core_second) + tmp37 := lang.Apply(tmp36, []any{v4}) + var v38 any = tmp37 + _ = v38 + tmp39 := checkDerefVar(var_glojure_DOT_core_seq) + tmp40 := checkDerefVar(var_glojure_DOT_core_concat) + tmp41 := checkDerefVar(var_glojure_DOT_core_list) + tmp42 := lang.Apply(tmp41, []any{sym_glojure_DOT_core_SLASH_let}) + tmp43 := checkDerefVar(var_glojure_DOT_core_list) + tmp44 := checkDerefVar(var_glojure_DOT_core_apply) + tmp45 := checkDerefVar(var_glojure_DOT_core_vector) + tmp46 := checkDerefVar(var_glojure_DOT_core_seq) + tmp47 := checkDerefVar(var_glojure_DOT_core_concat) + tmp48 := checkDerefVar(var_glojure_DOT_core_list) + tmp49 := lang.Apply(tmp48, []any{sym_n__0__auto__}) + tmp50 := checkDerefVar(var_glojure_DOT_core_list) + tmp51 := checkDerefVar(var_glojure_DOT_core_seq) + tmp52 := checkDerefVar(var_glojure_DOT_core_concat) + tmp53 := checkDerefVar(var_glojure_DOT_core_list) + tmp54 := lang.Apply(tmp53, []any{sym_glojure_DOT_core_SLASH_long}) + tmp55 := checkDerefVar(var_glojure_DOT_core_list) + tmp56 := lang.Apply(tmp55, []any{v38}) + tmp57 := lang.Apply(tmp52, []any{tmp54, tmp56}) + tmp58 := lang.Apply(tmp51, []any{tmp57}) + tmp59 := lang.Apply(tmp50, []any{tmp58}) + tmp60 := lang.Apply(tmp47, []any{tmp49, tmp59}) + tmp61 := lang.Apply(tmp46, []any{tmp60}) + tmp62 := lang.Apply(tmp44, []any{tmp45, tmp61}) + tmp63 := lang.Apply(tmp43, []any{tmp62}) + tmp64 := checkDerefVar(var_glojure_DOT_core_list) + tmp65 := checkDerefVar(var_glojure_DOT_core_seq) + tmp66 := checkDerefVar(var_glojure_DOT_core_concat) + tmp67 := checkDerefVar(var_glojure_DOT_core_list) + tmp68 := lang.Apply(tmp67, []any{sym_glojure_DOT_core_SLASH_loop}) + tmp69 := checkDerefVar(var_glojure_DOT_core_list) + tmp70 := checkDerefVar(var_glojure_DOT_core_apply) + tmp71 := checkDerefVar(var_glojure_DOT_core_vector) + tmp72 := checkDerefVar(var_glojure_DOT_core_seq) + tmp73 := checkDerefVar(var_glojure_DOT_core_concat) + tmp74 := checkDerefVar(var_glojure_DOT_core_list) + tmp75 := lang.Apply(tmp74, []any{v35}) + tmp76 := checkDerefVar(var_glojure_DOT_core_list) + tmp77 := lang.Apply(tmp76, []any{int64(0)}) + tmp78 := lang.Apply(tmp73, []any{tmp75, tmp77}) + tmp79 := lang.Apply(tmp72, []any{tmp78}) + tmp80 := lang.Apply(tmp70, []any{tmp71, tmp79}) + tmp81 := lang.Apply(tmp69, []any{tmp80}) + tmp82 := checkDerefVar(var_glojure_DOT_core_list) + tmp83 := checkDerefVar(var_glojure_DOT_core_seq) + tmp84 := checkDerefVar(var_glojure_DOT_core_concat) + tmp85 := checkDerefVar(var_glojure_DOT_core_list) + tmp86 := lang.Apply(tmp85, []any{sym_glojure_DOT_core_SLASH_when}) + tmp87 := checkDerefVar(var_glojure_DOT_core_list) + tmp88 := checkDerefVar(var_glojure_DOT_core_seq) + tmp89 := checkDerefVar(var_glojure_DOT_core_concat) + tmp90 := checkDerefVar(var_glojure_DOT_core_list) + tmp91 := lang.Apply(tmp90, []any{sym_glojure_DOT_core_SLASH__LT_}) + tmp92 := checkDerefVar(var_glojure_DOT_core_list) + tmp93 := lang.Apply(tmp92, []any{v35}) + tmp94 := checkDerefVar(var_glojure_DOT_core_list) + tmp95 := lang.Apply(tmp94, []any{sym_n__0__auto__}) + tmp96 := lang.Apply(tmp89, []any{tmp91, tmp93, tmp95}) + tmp97 := lang.Apply(tmp88, []any{tmp96}) + tmp98 := lang.Apply(tmp87, []any{tmp97}) + tmp99 := checkDerefVar(var_glojure_DOT_core_list) + tmp100 := checkDerefVar(var_glojure_DOT_core_seq) + tmp101 := checkDerefVar(var_glojure_DOT_core_concat) + tmp102 := checkDerefVar(var_glojure_DOT_core_list) + tmp103 := lang.Apply(tmp102, []any{sym_recur}) + tmp104 := checkDerefVar(var_glojure_DOT_core_list) + tmp105 := checkDerefVar(var_glojure_DOT_core_seq) + tmp106 := checkDerefVar(var_glojure_DOT_core_concat) + tmp107 := checkDerefVar(var_glojure_DOT_core_list) + tmp108 := lang.Apply(tmp107, []any{sym_glojure_DOT_core_SLASH_unchecked_DASH_inc}) + tmp109 := checkDerefVar(var_glojure_DOT_core_list) + tmp110 := lang.Apply(tmp109, []any{v35}) + tmp111 := lang.Apply(tmp106, []any{tmp108, tmp110}) + tmp112 := lang.Apply(tmp105, []any{tmp111}) + tmp113 := lang.Apply(tmp104, []any{tmp112}) + tmp114 := lang.Apply(tmp101, []any{tmp103, tmp113}) + tmp115 := lang.Apply(tmp100, []any{tmp114}) + tmp116 := lang.Apply(tmp99, []any{tmp115}) + tmp117 := lang.Apply(tmp84, []any{tmp86, tmp98, v5, tmp116}) + tmp118 := lang.Apply(tmp83, []any{tmp117}) + tmp119 := lang.Apply(tmp82, []any{tmp118}) + tmp120 := lang.Apply(tmp66, []any{tmp68, tmp81, tmp119}) + tmp121 := lang.Apply(tmp65, []any{tmp120}) + tmp122 := lang.Apply(tmp64, []any{tmp121}) + tmp123 := lang.Apply(tmp40, []any{tmp42, tmp63, tmp122}) + tmp124 := lang.Apply(tmp39, []any{tmp123}) + tmp32 = tmp124 + } // end let + return tmp32 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_dotimes = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_dotimes.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // drop + { + tmp0 := sym_drop.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n), lang.NewVector(sym_n, sym_coll)), kw_doc, "Returns a laziness-preserving sequence of all but the first n items in coll.\n Returns a stateful transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(2901), kw_end_DASH_line, int(2901))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 any + { // let + // let binding "nv" + tmp6 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) + tmp7 := lang.Apply(tmp6, []any{v2}) + var v8 any = tmp7 + _ = v8 + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp10 := lang.Apply(v4, nil) + return tmp10 + case 1: + v10 := args[0] + _ = v10 + tmp11 := lang.Apply(v4, []any{v10}) + return tmp11 + case 2: + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + var tmp12 any + { // let + // let binding "n" + tmp13 := checkDerefVar(var_glojure_DOT_core_deref) + tmp14 := lang.Apply(tmp13, []any{v8}) + var v15 any = tmp14 + _ = v15 + tmp16 := checkDerefVar(var_glojure_DOT_core_dec) + tmp17, ok := lang.FieldOrMethod(v8, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "Deref"))) + } + var tmp18 any + switch reflect.TypeOf(tmp17).Kind() { + case reflect.Func: + tmp18 = lang.Apply(tmp17, nil) + default: + tmp18 = tmp17 + } + tmp19 := lang.Apply(tmp16, []any{tmp18}) + tmp20, _ := lang.FieldOrMethod(v8, "reset") + if reflect.TypeOf(tmp20).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) + } + tmp21 := lang.Apply(tmp20, []any{tmp19}) + _ = tmp21 + var tmp22 any + tmp23 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp24 := lang.Apply(tmp23, []any{v15}) + if lang.IsTruthy(tmp24) { + tmp22 = v10 + } else { + tmp25 := lang.Apply(v4, []any{v10, v11}) + tmp22 = tmp25 + } + tmp12 = tmp22 + } // end let + return tmp12 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2909), kw_column, int(10), kw_end_DASH_line, int(2917), kw_end_DASH_column, int(39)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp5 = tmp11 + } // end let + return tmp5 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2907), kw_column, int(6), kw_end_DASH_line, int(2917), kw_end_DASH_column, int(41)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp6 := reflect.TypeOf((*lang.IDrop)(nil)).Elem() + tmp7 := lang.Apply(tmp5, []any{tmp6, v3}) + if lang.IsTruthy(tmp7) { + var tmp8 any + { // let + // let binding "or__0__auto__" + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp11 := lang.Apply(tmp10, []any{v2}) + if lang.IsTruthy(tmp11) { + var tmp12 any + tmp13 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) + tmp14 := lang.Apply(tmp13, []any{v2}) + if lang.IsTruthy(tmp14) { + tmp12 = v2 + } else { + tmp15 := lang.Apply(nil, []any{v2}) + tmp12 = tmp15 + } + tmp16, _ := lang.FieldOrMethod(v3, "drop") + if reflect.TypeOf(tmp16).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("drop is not a function"))) + } + tmp17 := lang.Apply(tmp16, []any{tmp12}) + tmp9 = tmp17 + } else { + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := lang.Apply(tmp18, []any{v3}) + tmp9 = tmp19 + } + var v20 any = tmp9 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + tmp21 = v20 + } else { + tmp21 = lang.NewList() + } + tmp8 = tmp21 + } // end let + tmp4 = tmp8 + } else { + var tmp9 any + { // let + // let binding "step" + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + recur_loop_2079: + var tmp13 any + { // let + // let binding "s" + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := lang.Apply(tmp14, []any{v12}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + var tmp18 any + { // let + // let binding "and__0__auto__" + tmp19 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp20 := lang.Apply(tmp19, []any{v11}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + if lang.IsTruthy(v21) { + tmp22 = v16 + } else { + tmp22 = v21 + } + tmp18 = tmp22 + } // end let + if lang.IsTruthy(tmp18) { + tmp20 := checkDerefVar(var_glojure_DOT_core_dec) + tmp21 := lang.Apply(tmp20, []any{v11}) + var tmp19 any = tmp21 + tmp23 := checkDerefVar(var_glojure_DOT_core_rest) + tmp24 := lang.Apply(tmp23, []any{v16}) + var tmp22 any = tmp24 + v11 = tmp19 + v12 = tmp22 + goto recur_loop_2079 + } else { + tmp17 = v16 + } + tmp13 = tmp17 + } // end let + return tmp13 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2925), kw_column, int(19), kw_end_DASH_line, int(2929), kw_end_DASH_column, int(28)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v13 any = tmp12 + _ = v13 + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp15 := lang.Apply(v13, []any{v2, v3}) + return tmp15 + }) + tmp15 := lang.Apply(lang.NewLazySeq, []any{tmp14}) + tmp9 = tmp15 + } // end let + tmp4 = tmp9 + } + return tmp4 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_drop = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_drop.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // elide-top-frames + { + tmp0 := sym_elide_DASH_top_DASH_frames.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(4794), kw_column, int(7), kw_end_DASH_line, int(4794), kw_end_DASH_column, int(32), kw_arglists, lang.NewList(lang.NewVector(sym_ex, sym_class_DASH_name)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "tr" + tmp5, ok := lang.FieldOrMethod(v2, "getStackTrace") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getStackTrace"))) + } + var tmp6 any + switch reflect.TypeOf(tmp5).Kind() { + case reflect.Func: + tmp6 = lang.Apply(tmp5, nil) + default: + tmp6 = tmp5 + } + var v7 any = tmp6 + _ = v7 + var tmp8 any + { // let + // let binding "G__745" + var v9 any = v2 + _ = v9 + var tmp10 any + if lang.IsTruthy(v7) { + tmp11 := checkDerefVar(var_glojure_DOT_core_into_DASH_array) + tmp12 := checkDerefVar(var_glojure_DOT_core_drop_DASH_while) + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v14 := args[0] + _ = v14 + tmp15 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp16, ok := lang.FieldOrMethod(v14, "getClassName") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v14, "getClassName"))) + } + var tmp17 any + switch reflect.TypeOf(tmp16).Kind() { + case reflect.Func: + tmp17 = lang.Apply(tmp16, nil) + default: + tmp17 = tmp16 + } + tmp18 := lang.Apply(tmp15, []any{v3, tmp17}) + return tmp18 + }) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4801), kw_column, int(25), kw_end_DASH_line, int(4801), kw_end_DASH_column, int(77)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp16 := lang.Apply(tmp12, []any{tmp15, v7}) + tmp17 := lang.Apply(tmp11, []any{nil, tmp16}) + tmp10 = tmp17 + } else { + } + tmp18, _ := lang.FieldOrMethod(v9, "setStackTrace") + if reflect.TypeOf(tmp18).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setStackTrace is not a function"))) + } + tmp19 := lang.Apply(tmp18, []any{tmp10}) + _ = tmp19 + tmp8 = v9 + } // end let + tmp4 = tmp8 + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_elide_DASH_top_DASH_frames = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_elide_DASH_top_DASH_frames.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // empty? + { + tmp0 := sym_empty_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns true if coll has no items. To check the emptiness of a seq,\n please use the idiom (seq x) rather than (not (empty? x))", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(6247), kw_end_DASH_line, int(6247))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_counted_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + tmp6 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) + tmp7 := checkDerefVar(var_glojure_DOT_core_count) + tmp8 := lang.Apply(tmp7, []any{v2}) + tmp9 := lang.Apply(tmp6, []any{tmp8}) + tmp3 = tmp9 + } else { + tmp10 := checkDerefVar(var_glojure_DOT_core_not) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := lang.Apply(tmp11, []any{v2}) + tmp13 := lang.Apply(tmp10, []any{tmp12}) + tmp3 = tmp13 + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_empty_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_empty_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ensure-reduced + { + tmp0 := sym_ensure_DASH_reduced.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "If x is already reduced?, returns it, else returns (reduced x)", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(2841), kw_end_DASH_line, int(2841))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + tmp3 = v2 + } else { + tmp6 := checkDerefVar(var_glojure_DOT_core_reduced) + tmp7 := lang.Apply(tmp6, []any{v2}) + tmp3 = tmp7 + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ensure_DASH_reduced = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ensure_DASH_reduced.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // even? + { + tmp0 := sym_even_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_doc, "Returns true if n is even, throws an exception if n is not an integer", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(1381), kw_end_DASH_line, int(1381))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_integer_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + tmp6 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) + tmp7 := checkDerefVar(var_glojure_DOT_core_bit_DASH_and) + tmp8 := lang.Apply(lang.UncheckedLongCast, []any{v2}) + tmp9 := lang.Apply(tmp7, []any{tmp8, int64(1)}) + tmp10 := lang.Apply(tmp6, []any{tmp9}) + tmp3 = tmp10 + } else { + tmp11 := checkDerefVar(var_glojure_DOT_core_str) + tmp12 := lang.Apply(tmp11, []any{"Argument must be an integer: ", v2}) + tmp13 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp12}) + panic(tmp13) + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_even_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_even_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // every-pred + { + tmp0 := sym_every_DASH_pred.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_p), lang.NewVector(sym_p1, sym_p2), lang.NewVector(sym_p1, sym_p2, sym_p3), lang.NewVector(sym_p1, sym_p2, sym_p3, sym__AMP_, sym_ps)), kw_doc, "Takes a set of predicates and returns a function f that returns true if all of its\n composing predicates return a logical true value against all of its arguments, else it returns\n false. Note that f is short-circuiting in that it will stop execution on the first\n argument that triggers a logical false result against the original predicates.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(7422), kw_end_DASH_line, int(7422))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + { // function ep1 + var v4 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return true + case 1: + v5 := args[0] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_boolean) + tmp7 := lang.Apply(v2, []any{v5}) + tmp8 := lang.Apply(tmp6, []any{tmp7}) + return tmp8 + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp8 any + { // let + // let binding "and__0__auto__" + tmp9 := lang.Apply(v2, []any{v5}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + if lang.IsTruthy(v10) { + tmp12 := lang.Apply(v2, []any{v6}) + tmp11 = tmp12 + } else { + tmp11 = v10 + } + tmp8 = tmp11 + } // end let + tmp9 := lang.Apply(tmp7, []any{tmp8}) + return tmp9 + case 3: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := args[2] + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp9 any + { // let + // let binding "and__0__auto__" + tmp10 := lang.Apply(v2, []any{v5}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + var tmp13 any + { // let + // let binding "and__0__auto__" + tmp14 := lang.Apply(v2, []any{v6}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + if lang.IsTruthy(v15) { + tmp17 := lang.Apply(v2, []any{v7}) + tmp16 = tmp17 + } else { + tmp16 = v15 + } + tmp13 = tmp16 + } // end let + tmp12 = tmp13 + } else { + tmp12 = v11 + } + tmp9 = tmp12 + } // end let + tmp10 := lang.Apply(tmp8, []any{tmp9}) + return tmp10 + default: + checkArity(args, 3) + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := args[2] + _ = v7 + var v8 any = lang.NewList(args[3:]...) + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp10 any + { // let + // let binding "and__0__auto__" + tmp11 := lang.Apply(v4, []any{v5, v6, v7}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + tmp14 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + tmp15 := lang.Apply(tmp14, []any{v2, v8}) + tmp13 = tmp15 + } else { + tmp13 = v12 + } + tmp10 = tmp13 + } // end let + tmp11 := lang.Apply(tmp9, []any{tmp10}) + return tmp11 + } + }) + v4 = tmp3 + _ = v4 + } + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7429), kw_column, int(6), kw_end_DASH_line, int(7435), kw_end_DASH_column, int(56)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + { // function ep2 + var v5 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return true + case 1: + v6 := args[0] + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp8 any + { // let + // let binding "and__0__auto__" + tmp9 := lang.Apply(v2, []any{v6}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + if lang.IsTruthy(v10) { + tmp12 := lang.Apply(v3, []any{v6}) + tmp11 = tmp12 + } else { + tmp11 = v10 + } + tmp8 = tmp11 + } // end let + tmp9 := lang.Apply(tmp7, []any{tmp8}) + return tmp9 + case 2: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp9 any + { // let + // let binding "and__0__auto__" + tmp10 := lang.Apply(v2, []any{v6}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + var tmp13 any + { // let + // let binding "and__0__auto__" + tmp14 := lang.Apply(v2, []any{v7}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + if lang.IsTruthy(v15) { + var tmp17 any + { // let + // let binding "and__0__auto__" + tmp18 := lang.Apply(v3, []any{v6}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + tmp21 := lang.Apply(v3, []any{v7}) + tmp20 = tmp21 + } else { + tmp20 = v19 + } + tmp17 = tmp20 + } // end let + tmp16 = tmp17 + } else { + tmp16 = v15 + } + tmp13 = tmp16 + } // end let + tmp12 = tmp13 + } else { + tmp12 = v11 + } + tmp9 = tmp12 + } // end let + tmp10 := lang.Apply(tmp8, []any{tmp9}) + return tmp10 + case 3: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp10 any + { // let + // let binding "and__0__auto__" + tmp11 := lang.Apply(v2, []any{v6}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + var tmp14 any + { // let + // let binding "and__0__auto__" + tmp15 := lang.Apply(v2, []any{v7}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + if lang.IsTruthy(v16) { + var tmp18 any + { // let + // let binding "and__0__auto__" + tmp19 := lang.Apply(v2, []any{v8}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + var tmp22 any + { // let + // let binding "and__0__auto__" + tmp23 := lang.Apply(v3, []any{v6}) + var v24 any = tmp23 + _ = v24 + var tmp25 any + if lang.IsTruthy(v24) { + var tmp26 any + { // let + // let binding "and__0__auto__" + tmp27 := lang.Apply(v3, []any{v7}) + var v28 any = tmp27 + _ = v28 + var tmp29 any + if lang.IsTruthy(v28) { + tmp30 := lang.Apply(v3, []any{v8}) + tmp29 = tmp30 + } else { + tmp29 = v28 + } + tmp26 = tmp29 + } // end let + tmp25 = tmp26 + } else { + tmp25 = v24 + } + tmp22 = tmp25 + } // end let + tmp21 = tmp22 + } else { + tmp21 = v20 + } + tmp18 = tmp21 + } // end let + tmp17 = tmp18 + } else { + tmp17 = v16 + } + tmp14 = tmp17 + } // end let + tmp13 = tmp14 + } else { + tmp13 = v12 + } + tmp10 = tmp13 + } // end let + tmp11 := lang.Apply(tmp9, []any{tmp10}) + return tmp11 + default: + checkArity(args, 3) + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + var v9 any = lang.NewList(args[3:]...) + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp11 any + { // let + // let binding "and__0__auto__" + tmp12 := lang.Apply(v5, []any{v6, v7, v8}) + var v13 any = tmp12 + _ = v13 + var tmp14 any + if lang.IsTruthy(v13) { + tmp15 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + var tmp16 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v17 := args[0] + _ = v17 + var tmp18 any + { // let + // let binding "and__0__auto__" + tmp19 := lang.Apply(v2, []any{v17}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + tmp22 := lang.Apply(v3, []any{v17}) + tmp21 = tmp22 + } else { + tmp21 = v20 + } + tmp18 = tmp21 + } // end let + return tmp18 + }) + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7443), kw_column, int(46), kw_end_DASH_line, int(7443), kw_end_DASH_column, int(65)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp19 := lang.Apply(tmp15, []any{tmp18, v9}) + tmp14 = tmp19 + } else { + tmp14 = v13 + } + tmp11 = tmp14 + } // end let + tmp12 := lang.Apply(tmp10, []any{tmp11}) + return tmp12 + } + }) + v5 = tmp4 + _ = v5 + } + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7437), kw_column, int(6), kw_end_DASH_line, int(7443), kw_end_DASH_column, int(75)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 lang.FnFunc + { // function ep3 + var v6 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return true + case 1: + v7 := args[0] + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp9 any + { // let + // let binding "and__0__auto__" + tmp10 := lang.Apply(v2, []any{v7}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + var tmp13 any + { // let + // let binding "and__0__auto__" + tmp14 := lang.Apply(v3, []any{v7}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + if lang.IsTruthy(v15) { + tmp17 := lang.Apply(v4, []any{v7}) + tmp16 = tmp17 + } else { + tmp16 = v15 + } + tmp13 = tmp16 + } // end let + tmp12 = tmp13 + } else { + tmp12 = v11 + } + tmp9 = tmp12 + } // end let + tmp10 := lang.Apply(tmp8, []any{tmp9}) + return tmp10 + case 2: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp10 any + { // let + // let binding "and__0__auto__" + tmp11 := lang.Apply(v2, []any{v7}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + var tmp14 any + { // let + // let binding "and__0__auto__" + tmp15 := lang.Apply(v2, []any{v8}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + if lang.IsTruthy(v16) { + var tmp18 any + { // let + // let binding "and__0__auto__" + tmp19 := lang.Apply(v3, []any{v7}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + var tmp22 any + { // let + // let binding "and__0__auto__" + tmp23 := lang.Apply(v3, []any{v8}) + var v24 any = tmp23 + _ = v24 + var tmp25 any + if lang.IsTruthy(v24) { + var tmp26 any + { // let + // let binding "and__0__auto__" + tmp27 := lang.Apply(v4, []any{v7}) + var v28 any = tmp27 + _ = v28 + var tmp29 any + if lang.IsTruthy(v28) { + tmp30 := lang.Apply(v4, []any{v8}) + tmp29 = tmp30 + } else { + tmp29 = v28 + } + tmp26 = tmp29 + } // end let + tmp25 = tmp26 + } else { + tmp25 = v24 + } + tmp22 = tmp25 + } // end let + tmp21 = tmp22 + } else { + tmp21 = v20 + } + tmp18 = tmp21 + } // end let + tmp17 = tmp18 + } else { + tmp17 = v16 + } + tmp14 = tmp17 + } // end let + tmp13 = tmp14 + } else { + tmp13 = v12 + } + tmp10 = tmp13 + } // end let + tmp11 := lang.Apply(tmp9, []any{tmp10}) + return tmp11 + case 3: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp11 any + { // let + // let binding "and__0__auto__" + tmp12 := lang.Apply(v2, []any{v7}) + var v13 any = tmp12 + _ = v13 + var tmp14 any + if lang.IsTruthy(v13) { + var tmp15 any + { // let + // let binding "and__0__auto__" + tmp16 := lang.Apply(v2, []any{v8}) + var v17 any = tmp16 + _ = v17 + var tmp18 any + if lang.IsTruthy(v17) { + var tmp19 any + { // let + // let binding "and__0__auto__" + tmp20 := lang.Apply(v2, []any{v9}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + if lang.IsTruthy(v21) { + var tmp23 any + { // let + // let binding "and__0__auto__" + tmp24 := lang.Apply(v3, []any{v7}) + var v25 any = tmp24 + _ = v25 + var tmp26 any + if lang.IsTruthy(v25) { + var tmp27 any + { // let + // let binding "and__0__auto__" + tmp28 := lang.Apply(v3, []any{v8}) + var v29 any = tmp28 + _ = v29 + var tmp30 any + if lang.IsTruthy(v29) { + var tmp31 any + { // let + // let binding "and__0__auto__" + tmp32 := lang.Apply(v3, []any{v9}) + var v33 any = tmp32 + _ = v33 + var tmp34 any + if lang.IsTruthy(v33) { + var tmp35 any + { // let + // let binding "and__0__auto__" + tmp36 := lang.Apply(v4, []any{v7}) + var v37 any = tmp36 + _ = v37 + var tmp38 any + if lang.IsTruthy(v37) { + var tmp39 any + { // let + // let binding "and__0__auto__" + tmp40 := lang.Apply(v4, []any{v8}) + var v41 any = tmp40 + _ = v41 + var tmp42 any + if lang.IsTruthy(v41) { + tmp43 := lang.Apply(v4, []any{v9}) + tmp42 = tmp43 + } else { + tmp42 = v41 + } + tmp39 = tmp42 + } // end let + tmp38 = tmp39 + } else { + tmp38 = v37 + } + tmp35 = tmp38 + } // end let + tmp34 = tmp35 + } else { + tmp34 = v33 + } + tmp31 = tmp34 + } // end let + tmp30 = tmp31 + } else { + tmp30 = v29 + } + tmp27 = tmp30 + } // end let + tmp26 = tmp27 + } else { + tmp26 = v25 + } + tmp23 = tmp26 + } // end let + tmp22 = tmp23 + } else { + tmp22 = v21 + } + tmp19 = tmp22 + } // end let + tmp18 = tmp19 + } else { + tmp18 = v17 + } + tmp15 = tmp18 + } // end let + tmp14 = tmp15 + } else { + tmp14 = v13 + } + tmp11 = tmp14 + } // end let + tmp12 := lang.Apply(tmp10, []any{tmp11}) + return tmp12 + default: + checkArity(args, 3) + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + var v10 any = lang.NewList(args[3:]...) + _ = v10 + tmp11 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp12 any + { // let + // let binding "and__0__auto__" + tmp13 := lang.Apply(v6, []any{v7, v8, v9}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + tmp16 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + var tmp17 lang.FnFunc + tmp17 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v18 := args[0] + _ = v18 + var tmp19 any + { // let + // let binding "and__0__auto__" + tmp20 := lang.Apply(v2, []any{v18}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + if lang.IsTruthy(v21) { + var tmp23 any + { // let + // let binding "and__0__auto__" + tmp24 := lang.Apply(v3, []any{v18}) + var v25 any = tmp24 + _ = v25 + var tmp26 any + if lang.IsTruthy(v25) { + tmp27 := lang.Apply(v4, []any{v18}) + tmp26 = tmp27 + } else { + tmp26 = v25 + } + tmp23 = tmp26 + } // end let + tmp22 = tmp23 + } else { + tmp22 = v21 + } + tmp19 = tmp22 + } // end let + return tmp19 + }) + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7451), kw_column, int(46), kw_end_DASH_line, int(7451), kw_end_DASH_column, int(72)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp20 := lang.Apply(tmp16, []any{tmp19, v10}) + tmp15 = tmp20 + } else { + tmp15 = v14 + } + tmp12 = tmp15 + } // end let + tmp13 := lang.Apply(tmp11, []any{tmp12}) + return tmp13 + } + }) + v6 = tmp5 + _ = v6 + } + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7445), kw_column, int(6), kw_end_DASH_line, int(7451), kw_end_DASH_column, int(82)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp7 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "ps" + tmp7 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp8 := lang.Apply(tmp7, []any{v2, v3, v4, v5}) + var v9 any = tmp8 + _ = v9 + var tmp10 lang.FnFunc + { // function epn + var v11 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return true + case 1: + v12 := args[0] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v15 := args[0] + _ = v15 + tmp16 := lang.Apply(v15, []any{v12}) + return tmp16 + }) + tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7456), kw_column, int(23), kw_end_DASH_line, int(7456), kw_end_DASH_column, int(28)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp17 := lang.Apply(tmp13, []any{tmp16, v9}) + return tmp17 + case 2: + v12 := args[0] + _ = v12 + v13 := args[1] + _ = v13 + tmp14 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + var tmp15 lang.FnFunc + tmp15 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v16 := args[0] + _ = v16 + var tmp17 any + { // let + // let binding "and__0__auto__" + tmp18 := lang.Apply(v16, []any{v12}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + tmp21 := lang.Apply(v16, []any{v13}) + tmp20 = tmp21 + } else { + tmp20 = v19 + } + tmp17 = tmp20 + } // end let + return tmp17 + }) + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7457), kw_column, int(25), kw_end_DASH_line, int(7457), kw_end_DASH_column, int(42)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp18 := lang.Apply(tmp14, []any{tmp17, v9}) + return tmp18 + case 3: + v12 := args[0] + _ = v12 + v13 := args[1] + _ = v13 + v14 := args[2] + _ = v14 + tmp15 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + var tmp16 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v17 := args[0] + _ = v17 + var tmp18 any + { // let + // let binding "and__0__auto__" + tmp19 := lang.Apply(v17, []any{v12}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + var tmp22 any + { // let + // let binding "and__0__auto__" + tmp23 := lang.Apply(v17, []any{v13}) + var v24 any = tmp23 + _ = v24 + var tmp25 any + if lang.IsTruthy(v24) { + tmp26 := lang.Apply(v17, []any{v14}) + tmp25 = tmp26 + } else { + tmp25 = v24 + } + tmp22 = tmp25 + } // end let + tmp21 = tmp22 + } else { + tmp21 = v20 + } + tmp18 = tmp21 + } // end let + return tmp18 + }) + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7458), kw_column, int(27), kw_end_DASH_line, int(7458), kw_end_DASH_column, int(50)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp19 := lang.Apply(tmp15, []any{tmp18, v9}) + return tmp19 + default: + checkArity(args, 3) + v12 := args[0] + _ = v12 + v13 := args[1] + _ = v13 + v14 := args[2] + _ = v14 + var v15 any = lang.NewList(args[3:]...) + _ = v15 + tmp16 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp17 any + { // let + // let binding "and__0__auto__" + tmp18 := lang.Apply(v11, []any{v12, v13, v14}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + tmp21 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + var tmp22 lang.FnFunc + tmp22 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v23 := args[0] + _ = v23 + tmp24 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + tmp25 := lang.Apply(tmp24, []any{v23, v15}) + return tmp25 + }) + tmp23 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7460), kw_column, int(48), kw_end_DASH_line, int(7460), kw_end_DASH_column, int(63)) + tmp24, err := lang.WithMeta(tmp22, tmp23.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp25 := lang.Apply(tmp21, []any{tmp24, v9}) + tmp20 = tmp25 + } else { + tmp20 = v19 + } + tmp17 = tmp20 + } // end let + tmp18 := lang.Apply(tmp16, []any{tmp17}) + return tmp18 + } + }) + v11 = tmp10 + _ = v11 + } + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7454), kw_column, int(8), kw_end_DASH_line, int(7460), kw_end_DASH_column, int(71)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp6 = tmp12 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_every_DASH_pred = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_every_DASH_pred.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ex-info + { + tmp0 := sym_ex_DASH_info.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_msg, sym_map), lang.NewVector(sym_msg, sym_map, sym_cause)), kw_doc, "Create an instance of ExceptionInfo, a RuntimeException subclass\n that carries a map of additional data.", kw_file, "glojure/core.glj", kw_added, "1.4", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4803), kw_end_DASH_line, int(4803))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_elide_DASH_top_DASH_frames) + tmp5 := lang.Apply(nil, []any{v2, v3}) + tmp6 := lang.Apply(tmp4, []any{tmp5, "glojure.core$ex_info"}) + return tmp6 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_elide_DASH_top_DASH_frames) + tmp6 := lang.Apply(nil, []any{v2, v3, v4}) + tmp7 := lang.Apply(tmp5, []any{tmp6, "glojure.core$ex_info"}) + return tmp7 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ex_DASH_info = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ex_DASH_info.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // filter + { + tmp0 := sym_filter.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred), lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns a lazy sequence of the items in coll for which\n (pred item) returns logical true. pred must be free of side-effects.\n Returns a transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(2785), kw_end_DASH_line, int(2785))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp6 := lang.Apply(v4, nil) + return tmp6 + case 1: + v6 := args[0] + _ = v6 + tmp7 := lang.Apply(v4, []any{v6}) + return tmp7 + case 2: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + var tmp8 any + tmp9 := lang.Apply(v2, []any{v7}) + if lang.IsTruthy(tmp9) { + tmp10 := lang.Apply(v4, []any{v6, v7}) + tmp8 = tmp10 + } else { + tmp8 = v6 + } + return tmp8 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2793), kw_column, int(7), kw_end_DASH_line, int(2799), kw_end_DASH_column, int(22)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp7 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2792), kw_column, int(5), kw_end_DASH_line, int(2799), kw_end_DASH_column, int(23)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp5 any + { // let + // let binding "temp__0__auto__" + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := lang.Apply(tmp6, []any{v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + var tmp10 any + { // let + // let binding "s" + var v11 any = v8 + _ = v11 + var tmp12 any + tmp13 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp14 := lang.Apply(tmp13, []any{v11}) + if lang.IsTruthy(tmp14) { + var tmp15 any + { // let + // let binding "c" + tmp16 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp17 := lang.Apply(tmp16, []any{v11}) + var v18 any = tmp17 + _ = v18 + // let binding "size" + tmp19 := checkDerefVar(var_glojure_DOT_core_count) + tmp20 := lang.Apply(tmp19, []any{v18}) + var v21 any = tmp20 + _ = v21 + // let binding "b" + tmp22 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_buffer) + tmp23 := lang.Apply(tmp22, []any{v21}) + var v24 any = tmp23 + _ = v24 + var tmp25 any + { // let + // let binding "n__0__auto__" + tmp26 := lang.Apply(lang.LongCast, []any{v21}) + var v27 any = tmp26 + _ = v27 + var tmp28 any + { // let + // let binding "i" + var v29 any = int64(0) + _ = v29 + for { + var tmp30 any + tmp31 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp32 := lang.Apply(tmp31, []any{v29, v27}) + if lang.IsTruthy(tmp32) { + var tmp33 any + { // let + // let binding "v" + tmp34, _ := lang.FieldOrMethod(v18, "nth") + if reflect.TypeOf(tmp34).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp35 := lang.Apply(tmp34, []any{v29}) + var v36 any = tmp35 + _ = v36 + var tmp37 any + tmp38 := lang.Apply(v2, []any{v36}) + if lang.IsTruthy(tmp38) { + tmp39 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_append) + tmp40 := lang.Apply(tmp39, []any{v24, v36}) + tmp37 = tmp40 + } else { + } + tmp33 = tmp37 + } // end let + _ = tmp33 + tmp35 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp36 := lang.Apply(tmp35, []any{v29}) + var tmp34 any = tmp36 + v29 = tmp34 + continue + } else { + } + tmp28 = tmp30 + break + } + } // end let + tmp25 = tmp28 + } // end let + _ = tmp25 + tmp26 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_cons) + tmp27 := checkDerefVar(var_glojure_DOT_core_chunk) + tmp28 := lang.Apply(tmp27, []any{v24}) + tmp29 := checkDerefVar(var_glojure_DOT_core_filter) + tmp30 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp31 := lang.Apply(tmp30, []any{v11}) + tmp32 := lang.Apply(tmp29, []any{v2, tmp31}) + tmp33 := lang.Apply(tmp26, []any{tmp28, tmp32}) + tmp15 = tmp33 + } // end let + tmp12 = tmp15 + } else { + var tmp16 any + { // let + // let binding "f" + tmp17 := checkDerefVar(var_glojure_DOT_core_first) + tmp18 := lang.Apply(tmp17, []any{v11}) + var v19 any = tmp18 + _ = v19 + // let binding "r" + tmp20 := checkDerefVar(var_glojure_DOT_core_rest) + tmp21 := lang.Apply(tmp20, []any{v11}) + var v22 any = tmp21 + _ = v22 + var tmp23 any + tmp24 := lang.Apply(v2, []any{v19}) + if lang.IsTruthy(tmp24) { + tmp25 := checkDerefVar(var_glojure_DOT_core_cons) + tmp26 := checkDerefVar(var_glojure_DOT_core_filter) + tmp27 := lang.Apply(tmp26, []any{v2, v22}) + tmp28 := lang.Apply(tmp25, []any{v19, tmp27}) + tmp23 = tmp28 + } else { + tmp29 := checkDerefVar(var_glojure_DOT_core_filter) + tmp30 := lang.Apply(tmp29, []any{v2, v22}) + tmp23 = tmp30 + } + tmp16 = tmp23 + } // end let + tmp12 = tmp16 + } + tmp10 = tmp12 + } // end let + tmp9 = tmp10 + } else { + } + tmp5 = tmp9 + } // end let + return tmp5 + }) + tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_filter = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_filter.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // fnil + { + tmp0 := sym_fnil.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_x), lang.NewVector(sym_f, sym_x, sym_y), lang.NewVector(sym_f, sym_x, sym_y, sym_z)), kw_doc, "Takes a function f, and returns a function that calls f, replacing\n a nil first argument to f with the supplied value x. Higher arity\n versions can replace arguments in the second and third\n positions (y, z). Note that the function f can take any number of\n arguments, not just the one(s) being nil-patched.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(6558), kw_end_DASH_line, int(6558))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v5 := args[0] + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v5}) + if lang.IsTruthy(tmp8) { + tmp6 = v3 + } else { + tmp6 = v5 + } + tmp9 := lang.Apply(v2, []any{tmp6}) + return tmp9 + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp9 := lang.Apply(tmp8, []any{v5}) + if lang.IsTruthy(tmp9) { + tmp7 = v3 + } else { + tmp7 = v5 + } + tmp10 := lang.Apply(v2, []any{tmp7, v6}) + return tmp10 + case 3: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := args[2] + _ = v7 + var tmp8 any + tmp9 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp10 := lang.Apply(tmp9, []any{v5}) + if lang.IsTruthy(tmp10) { + tmp8 = v3 + } else { + tmp8 = v5 + } + tmp11 := lang.Apply(v2, []any{tmp8, v6, v7}) + return tmp11 + default: + checkArity(args, 3) + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := args[2] + _ = v7 + var v8 any = lang.NewList(args[3:]...) + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_apply) + var tmp10 any + tmp11 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp12 := lang.Apply(tmp11, []any{v5}) + if lang.IsTruthy(tmp12) { + tmp10 = v3 + } else { + tmp10 = v5 + } + tmp13 := lang.Apply(tmp9, []any{v2, tmp10, v6, v7, v8}) + return tmp13 + } + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6567), kw_column, int(4), kw_end_DASH_line, int(6571), kw_end_DASH_column, int(55)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + var tmp8 any + tmp9 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp10 := lang.Apply(tmp9, []any{v6}) + if lang.IsTruthy(tmp10) { + tmp8 = v3 + } else { + tmp8 = v6 + } + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp13 := lang.Apply(tmp12, []any{v7}) + if lang.IsTruthy(tmp13) { + tmp11 = v4 + } else { + tmp11 = v7 + } + tmp14 := lang.Apply(v2, []any{tmp8, tmp11}) + return tmp14 + case 3: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp11 := lang.Apply(tmp10, []any{v6}) + if lang.IsTruthy(tmp11) { + tmp9 = v3 + } else { + tmp9 = v6 + } + var tmp12 any + tmp13 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp14 := lang.Apply(tmp13, []any{v7}) + if lang.IsTruthy(tmp14) { + tmp12 = v4 + } else { + tmp12 = v7 + } + tmp15 := lang.Apply(v2, []any{tmp9, tmp12, v8}) + return tmp15 + default: + checkArity(args, 3) + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + var v9 any = lang.NewList(args[3:]...) + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_apply) + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp13 := lang.Apply(tmp12, []any{v6}) + if lang.IsTruthy(tmp13) { + tmp11 = v3 + } else { + tmp11 = v6 + } + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp16 := lang.Apply(tmp15, []any{v7}) + if lang.IsTruthy(tmp16) { + tmp14 = v4 + } else { + tmp14 = v7 + } + tmp17 := lang.Apply(tmp10, []any{v2, tmp11, tmp14, v8, v9}) + return tmp17 + } + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6573), kw_column, int(4), kw_end_DASH_line, int(6576), kw_end_DASH_column, int(71)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp7 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp11 := lang.Apply(tmp10, []any{v7}) + if lang.IsTruthy(tmp11) { + tmp9 = v3 + } else { + tmp9 = v7 + } + var tmp12 any + tmp13 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp14 := lang.Apply(tmp13, []any{v8}) + if lang.IsTruthy(tmp14) { + tmp12 = v4 + } else { + tmp12 = v8 + } + tmp15 := lang.Apply(v2, []any{tmp9, tmp12}) + return tmp15 + case 3: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + var tmp10 any + tmp11 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp12 := lang.Apply(tmp11, []any{v7}) + if lang.IsTruthy(tmp12) { + tmp10 = v3 + } else { + tmp10 = v7 + } + var tmp13 any + tmp14 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp15 := lang.Apply(tmp14, []any{v8}) + if lang.IsTruthy(tmp15) { + tmp13 = v4 + } else { + tmp13 = v8 + } + var tmp16 any + tmp17 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp18 := lang.Apply(tmp17, []any{v9}) + if lang.IsTruthy(tmp18) { + tmp16 = v5 + } else { + tmp16 = v9 + } + tmp19 := lang.Apply(v2, []any{tmp10, tmp13, tmp16}) + return tmp19 + default: + checkArity(args, 3) + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + var v10 any = lang.NewList(args[3:]...) + _ = v10 + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + var tmp12 any + tmp13 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp14 := lang.Apply(tmp13, []any{v7}) + if lang.IsTruthy(tmp14) { + tmp12 = v3 + } else { + tmp12 = v7 + } + var tmp15 any + tmp16 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp17 := lang.Apply(tmp16, []any{v8}) + if lang.IsTruthy(tmp17) { + tmp15 = v4 + } else { + tmp15 = v8 + } + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp20 := lang.Apply(tmp19, []any{v9}) + if lang.IsTruthy(tmp20) { + tmp18 = v5 + } else { + tmp18 = v9 + } + tmp21 := lang.Apply(tmp11, []any{v2, tmp12, tmp15, tmp18, v10}) + return tmp21 + } + }) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6578), kw_column, int(4), kw_end_DASH_line, int(6581), kw_end_DASH_column, int(87)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp8 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_fnil = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_fnil.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // format + { + tmp0 := sym_format.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_fmt, sym__AMP_, sym_args)), kw_doc, "Formats a string using java.lang.String.format, see java.util.Formatter for format\n string syntax", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(5717), kw_end_DASH_line, int(5717))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_apply) + tmp5 := lang.Apply(tmp4, []any{fmt.Sprintf, v2, v3}) + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_format = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_format.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // future + { + tmp0 := sym_future.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_body)), kw_doc, "Takes a body of expressions and yields a future object that will\n invoke the body in another thread, and will cache the result and\n return it on all subsequent calls to deref/@. If the computation has\n not yet finished, calls to deref/@ will block, unless the variant of\n deref with timeout is used. See also - realized?.", kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(11), kw_line, int(7009), kw_end_DASH_line, int(7009))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym_glojure_DOT_core_SLASH_future_DASH_call}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := checkDerefVar(var_glojure_DOT_core_seq) + tmp11 := checkDerefVar(var_glojure_DOT_core_concat) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_fn_STAR_}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_apply) + tmp16 := checkDerefVar(var_glojure_DOT_core_vector) + tmp17 := checkDerefVar(var_glojure_DOT_core_seq) + tmp18 := checkDerefVar(var_glojure_DOT_core_concat) + tmp19 := lang.Apply(tmp18, nil) + tmp20 := lang.Apply(tmp17, []any{tmp19}) + tmp21 := lang.Apply(tmp15, []any{tmp16, tmp20}) + tmp22 := lang.Apply(tmp14, []any{tmp21}) + tmp23 := lang.Apply(tmp11, []any{tmp13, tmp22, v4}) + tmp24 := lang.Apply(tmp10, []any{tmp23}) + tmp25 := lang.Apply(tmp9, []any{tmp24}) + tmp26 := lang.Apply(tmp6, []any{tmp8, tmp25}) + tmp27 := lang.Apply(tmp5, []any{tmp26}) + return tmp27 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_future = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_future.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // future-call + { + tmp0 := sym_future_DASH_call.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f)), kw_doc, "Takes a function of no args and yields a future object that will\n invoke the function in another thread, and will cache the result and\n return it on all subsequent calls to deref/@. If the computation has\n not yet finished, calls to deref/@ will block, unless the variant\n of deref with timeout is used. See also - realized?.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(7003), kw_end_DASH_line, int(7003))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "f" + tmp4 := checkDerefVar(var_glojure_DOT_core_binding_DASH_conveyor_DASH_fn) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + // let binding "fut" + tmp7 := lang.Apply(lang.AgentSubmit, []any{v6}) + var v8 any = tmp7 + _ = v8 + tmp3 = v8 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_future_DASH_call = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_future_DASH_call.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // get-in + { + tmp0 := sym_get_DASH_in.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m, sym_ks), lang.NewVector(sym_m, sym_ks, sym_not_DASH_found)), kw_doc, "Returns the value in a nested associative structure,\n where ks is a sequence of keys. Returns nil if the key\n is not present, or the not-found value if supplied.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(6128), kw_end_DASH_line, int(6128))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp5 := checkDerefVar(var_glojure_DOT_core_get) + tmp6 := lang.Apply(tmp4, []any{tmp5, v2, v3}) + return tmp6 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + { // let + // let binding "sentinel" + tmp6 := lang.Apply(reflect.StructOf, []any{nil}) + tmp7 := lang.Apply(reflect.New, []any{tmp6}) + tmp8, ok := lang.FieldOrMethod(tmp7, "Interface") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp7, "Interface"))) + } + var tmp9 any + switch reflect.TypeOf(tmp8).Kind() { + case reflect.Func: + tmp9 = lang.Apply(tmp8, nil) + default: + tmp9 = tmp8 + } + var v10 any = tmp9 + _ = v10 + // let binding "m" + var v11 any = v2 + _ = v11 + // let binding "ks" + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := lang.Apply(tmp12, []any{v3}) + var v14 any = tmp13 + _ = v14 + for { + var tmp15 any + if lang.IsTruthy(v14) { + var tmp16 any + { // let + // let binding "m" + tmp17 := checkDerefVar(var_glojure_DOT_core_get) + tmp18 := checkDerefVar(var_glojure_DOT_core_first) + tmp19 := lang.Apply(tmp18, []any{v14}) + tmp20 := lang.Apply(tmp17, []any{v11, tmp19, v10}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + tmp23 := checkDerefVar(var_glojure_DOT_core_identical_QMARK_) + tmp24 := lang.Apply(tmp23, []any{v10, v21}) + if lang.IsTruthy(tmp24) { + tmp22 = v4 + } else { + var tmp25 any = v10 + var tmp26 any = v21 + tmp28 := checkDerefVar(var_glojure_DOT_core_next) + tmp29 := lang.Apply(tmp28, []any{v14}) + var tmp27 any = tmp29 + v10 = tmp25 + v11 = tmp26 + v14 = tmp27 + continue + } + tmp16 = tmp22 + } // end let + tmp15 = tmp16 + } else { + tmp15 = v11 + } + tmp5 = tmp15 + break + } + } // end let + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_get_DASH_in = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_get_DASH_in.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // if-let + { + tmp0 := sym_if_DASH_let.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym_then), lang.NewVector(sym_bindings, sym_then, sym_else, sym__AMP_, sym_oldform)), kw_doc, "bindings => binding-form test\n\n If test is true, evaluates then with binding-form bound to the value of \n test, if not, yields else", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(11), kw_line, int(1839), kw_end_DASH_line, int(1839))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_if_DASH_let}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{v4}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v5}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{nil}) + tmp16 := lang.Apply(tmp7, []any{tmp9, tmp11, tmp13, tmp15}) + tmp17 := lang.Apply(tmp6, []any{tmp16}) + return tmp17 + default: + checkArity(args, 5) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + var v7 any = lang.NewList(args[5:]...) + _ = v7 + var tmp8 any + tmp9 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp10 := lang.Apply(tmp9, []any{v4}) + if lang.IsTruthy(tmp10) { + } else { + tmp11 := checkDerefVar(var_glojure_DOT_core_str) + tmp12 := checkDerefVar(var_glojure_DOT_core_first) + tmp13 := lang.Apply(tmp12, []any{v2}) + tmp14 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp15 := checkDerefVar(var_glojure_DOT_core_meta) + tmp16 := lang.Apply(tmp15, []any{v2}) + tmp17 := lang.Apply(kw_line, []any{tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp13, " requires ", "a vector for its binding", " in ", tmp14, ":", tmp17}) + tmp19 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp18}) + panic(tmp19) + } + _ = tmp8 + var tmp20 any + tmp21 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp22 := lang.Apply(tmp21, []any{v7}) + if lang.IsTruthy(tmp22) { + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp27 := checkDerefVar(var_glojure_DOT_core_meta) + tmp28 := lang.Apply(tmp27, []any{v2}) + tmp29 := lang.Apply(kw_line, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp25, " requires ", "1 or 2 forms after binding vector", " in ", tmp26, ":", tmp29}) + tmp31 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp31) + } + _ = tmp20 + var tmp32 any + tmp33 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp34 := checkDerefVar(var_glojure_DOT_core_count) + tmp35 := lang.Apply(tmp34, []any{v4}) + tmp36 := lang.Apply(tmp33, []any{int64(2), tmp35}) + if lang.IsTruthy(tmp36) { + } else { + tmp37 := checkDerefVar(var_glojure_DOT_core_str) + tmp38 := checkDerefVar(var_glojure_DOT_core_first) + tmp39 := lang.Apply(tmp38, []any{v2}) + tmp40 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp41 := checkDerefVar(var_glojure_DOT_core_meta) + tmp42 := lang.Apply(tmp41, []any{v2}) + tmp43 := lang.Apply(kw_line, []any{tmp42}) + tmp44 := lang.Apply(tmp37, []any{tmp39, " requires ", "exactly 2 forms in binding vector", " in ", tmp40, ":", tmp43}) + tmp45 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp44}) + panic(tmp45) + } + _ = tmp32 + var tmp46 any + { // let + // let binding "form" + tmp47 := lang.Apply(v4, []any{int64(0)}) + var v48 any = tmp47 + _ = v48 + // let binding "tst" + tmp49 := lang.Apply(v4, []any{int64(1)}) + var v50 any = tmp49 + _ = v50 + tmp51 := checkDerefVar(var_glojure_DOT_core_seq) + tmp52 := checkDerefVar(var_glojure_DOT_core_concat) + tmp53 := checkDerefVar(var_glojure_DOT_core_list) + tmp54 := lang.Apply(tmp53, []any{sym_glojure_DOT_core_SLASH_let}) + tmp55 := checkDerefVar(var_glojure_DOT_core_list) + tmp56 := checkDerefVar(var_glojure_DOT_core_apply) + tmp57 := checkDerefVar(var_glojure_DOT_core_vector) + tmp58 := checkDerefVar(var_glojure_DOT_core_seq) + tmp59 := checkDerefVar(var_glojure_DOT_core_concat) + tmp60 := checkDerefVar(var_glojure_DOT_core_list) + tmp61 := lang.Apply(tmp60, []any{sym_temp__0__auto__}) + tmp62 := checkDerefVar(var_glojure_DOT_core_list) + tmp63 := lang.Apply(tmp62, []any{v50}) + tmp64 := lang.Apply(tmp59, []any{tmp61, tmp63}) + tmp65 := lang.Apply(tmp58, []any{tmp64}) + tmp66 := lang.Apply(tmp56, []any{tmp57, tmp65}) + tmp67 := lang.Apply(tmp55, []any{tmp66}) + tmp68 := checkDerefVar(var_glojure_DOT_core_list) + tmp69 := checkDerefVar(var_glojure_DOT_core_seq) + tmp70 := checkDerefVar(var_glojure_DOT_core_concat) + tmp71 := checkDerefVar(var_glojure_DOT_core_list) + tmp72 := lang.Apply(tmp71, []any{sym_if}) + tmp73 := checkDerefVar(var_glojure_DOT_core_list) + tmp74 := lang.Apply(tmp73, []any{sym_temp__0__auto__}) + tmp75 := checkDerefVar(var_glojure_DOT_core_list) + tmp76 := checkDerefVar(var_glojure_DOT_core_seq) + tmp77 := checkDerefVar(var_glojure_DOT_core_concat) + tmp78 := checkDerefVar(var_glojure_DOT_core_list) + tmp79 := lang.Apply(tmp78, []any{sym_glojure_DOT_core_SLASH_let}) + tmp80 := checkDerefVar(var_glojure_DOT_core_list) + tmp81 := checkDerefVar(var_glojure_DOT_core_apply) + tmp82 := checkDerefVar(var_glojure_DOT_core_vector) + tmp83 := checkDerefVar(var_glojure_DOT_core_seq) + tmp84 := checkDerefVar(var_glojure_DOT_core_concat) + tmp85 := checkDerefVar(var_glojure_DOT_core_list) + tmp86 := lang.Apply(tmp85, []any{v48}) + tmp87 := checkDerefVar(var_glojure_DOT_core_list) + tmp88 := lang.Apply(tmp87, []any{sym_temp__0__auto__}) + tmp89 := lang.Apply(tmp84, []any{tmp86, tmp88}) + tmp90 := lang.Apply(tmp83, []any{tmp89}) + tmp91 := lang.Apply(tmp81, []any{tmp82, tmp90}) + tmp92 := lang.Apply(tmp80, []any{tmp91}) + tmp93 := checkDerefVar(var_glojure_DOT_core_list) + tmp94 := lang.Apply(tmp93, []any{v5}) + tmp95 := lang.Apply(tmp77, []any{tmp79, tmp92, tmp94}) + tmp96 := lang.Apply(tmp76, []any{tmp95}) + tmp97 := lang.Apply(tmp75, []any{tmp96}) + tmp98 := checkDerefVar(var_glojure_DOT_core_list) + tmp99 := lang.Apply(tmp98, []any{v6}) + tmp100 := lang.Apply(tmp70, []any{tmp72, tmp74, tmp97, tmp99}) + tmp101 := lang.Apply(tmp69, []any{tmp100}) + tmp102 := lang.Apply(tmp68, []any{tmp101}) + tmp103 := lang.Apply(tmp52, []any{tmp54, tmp67, tmp102}) + tmp104 := lang.Apply(tmp51, []any{tmp103}) + tmp46 = tmp104 + } // end let + return tmp46 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_if_DASH_let = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_if_DASH_let.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // if-some + { + tmp0 := sym_if_DASH_some.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym_then), lang.NewVector(sym_bindings, sym_then, sym_else, sym__AMP_, sym_oldform)), kw_doc, "bindings => binding-form test\n\n If test is not nil, evaluates then with binding-form bound to the\n value of test, if not, yields else", kw_file, "glojure/core.glj", kw_added, "1.6", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(1874), kw_end_DASH_line, int(1874))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_if_DASH_some}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{v4}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v5}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{nil}) + tmp16 := lang.Apply(tmp7, []any{tmp9, tmp11, tmp13, tmp15}) + tmp17 := lang.Apply(tmp6, []any{tmp16}) + return tmp17 + default: + checkArity(args, 5) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + var v7 any = lang.NewList(args[5:]...) + _ = v7 + var tmp8 any + tmp9 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp10 := lang.Apply(tmp9, []any{v4}) + if lang.IsTruthy(tmp10) { + } else { + tmp11 := checkDerefVar(var_glojure_DOT_core_str) + tmp12 := checkDerefVar(var_glojure_DOT_core_first) + tmp13 := lang.Apply(tmp12, []any{v2}) + tmp14 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp15 := checkDerefVar(var_glojure_DOT_core_meta) + tmp16 := lang.Apply(tmp15, []any{v2}) + tmp17 := lang.Apply(kw_line, []any{tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp13, " requires ", "a vector for its binding", " in ", tmp14, ":", tmp17}) + tmp19 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp18}) + panic(tmp19) + } + _ = tmp8 + var tmp20 any + tmp21 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp22 := lang.Apply(tmp21, []any{v7}) + if lang.IsTruthy(tmp22) { + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp27 := checkDerefVar(var_glojure_DOT_core_meta) + tmp28 := lang.Apply(tmp27, []any{v2}) + tmp29 := lang.Apply(kw_line, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp25, " requires ", "1 or 2 forms after binding vector", " in ", tmp26, ":", tmp29}) + tmp31 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp31) + } + _ = tmp20 + var tmp32 any + tmp33 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp34 := checkDerefVar(var_glojure_DOT_core_count) + tmp35 := lang.Apply(tmp34, []any{v4}) + tmp36 := lang.Apply(tmp33, []any{int64(2), tmp35}) + if lang.IsTruthy(tmp36) { + } else { + tmp37 := checkDerefVar(var_glojure_DOT_core_str) + tmp38 := checkDerefVar(var_glojure_DOT_core_first) + tmp39 := lang.Apply(tmp38, []any{v2}) + tmp40 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp41 := checkDerefVar(var_glojure_DOT_core_meta) + tmp42 := lang.Apply(tmp41, []any{v2}) + tmp43 := lang.Apply(kw_line, []any{tmp42}) + tmp44 := lang.Apply(tmp37, []any{tmp39, " requires ", "exactly 2 forms in binding vector", " in ", tmp40, ":", tmp43}) + tmp45 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp44}) + panic(tmp45) + } + _ = tmp32 + var tmp46 any + { // let + // let binding "form" + tmp47 := lang.Apply(v4, []any{int64(0)}) + var v48 any = tmp47 + _ = v48 + // let binding "tst" + tmp49 := lang.Apply(v4, []any{int64(1)}) + var v50 any = tmp49 + _ = v50 + tmp51 := checkDerefVar(var_glojure_DOT_core_seq) + tmp52 := checkDerefVar(var_glojure_DOT_core_concat) + tmp53 := checkDerefVar(var_glojure_DOT_core_list) + tmp54 := lang.Apply(tmp53, []any{sym_glojure_DOT_core_SLASH_let}) + tmp55 := checkDerefVar(var_glojure_DOT_core_list) + tmp56 := checkDerefVar(var_glojure_DOT_core_apply) + tmp57 := checkDerefVar(var_glojure_DOT_core_vector) + tmp58 := checkDerefVar(var_glojure_DOT_core_seq) + tmp59 := checkDerefVar(var_glojure_DOT_core_concat) + tmp60 := checkDerefVar(var_glojure_DOT_core_list) + tmp61 := lang.Apply(tmp60, []any{sym_temp__0__auto__}) + tmp62 := checkDerefVar(var_glojure_DOT_core_list) + tmp63 := lang.Apply(tmp62, []any{v50}) + tmp64 := lang.Apply(tmp59, []any{tmp61, tmp63}) + tmp65 := lang.Apply(tmp58, []any{tmp64}) + tmp66 := lang.Apply(tmp56, []any{tmp57, tmp65}) + tmp67 := lang.Apply(tmp55, []any{tmp66}) + tmp68 := checkDerefVar(var_glojure_DOT_core_list) + tmp69 := checkDerefVar(var_glojure_DOT_core_seq) + tmp70 := checkDerefVar(var_glojure_DOT_core_concat) + tmp71 := checkDerefVar(var_glojure_DOT_core_list) + tmp72 := lang.Apply(tmp71, []any{sym_if}) + tmp73 := checkDerefVar(var_glojure_DOT_core_list) + tmp74 := checkDerefVar(var_glojure_DOT_core_seq) + tmp75 := checkDerefVar(var_glojure_DOT_core_concat) + tmp76 := checkDerefVar(var_glojure_DOT_core_list) + tmp77 := lang.Apply(tmp76, []any{sym_glojure_DOT_core_SLASH_nil_QMARK_}) + tmp78 := checkDerefVar(var_glojure_DOT_core_list) + tmp79 := lang.Apply(tmp78, []any{sym_temp__0__auto__}) + tmp80 := lang.Apply(tmp75, []any{tmp77, tmp79}) + tmp81 := lang.Apply(tmp74, []any{tmp80}) + tmp82 := lang.Apply(tmp73, []any{tmp81}) + tmp83 := checkDerefVar(var_glojure_DOT_core_list) + tmp84 := lang.Apply(tmp83, []any{v6}) + tmp85 := checkDerefVar(var_glojure_DOT_core_list) + tmp86 := checkDerefVar(var_glojure_DOT_core_seq) + tmp87 := checkDerefVar(var_glojure_DOT_core_concat) + tmp88 := checkDerefVar(var_glojure_DOT_core_list) + tmp89 := lang.Apply(tmp88, []any{sym_glojure_DOT_core_SLASH_let}) + tmp90 := checkDerefVar(var_glojure_DOT_core_list) + tmp91 := checkDerefVar(var_glojure_DOT_core_apply) + tmp92 := checkDerefVar(var_glojure_DOT_core_vector) + tmp93 := checkDerefVar(var_glojure_DOT_core_seq) + tmp94 := checkDerefVar(var_glojure_DOT_core_concat) + tmp95 := checkDerefVar(var_glojure_DOT_core_list) + tmp96 := lang.Apply(tmp95, []any{v48}) + tmp97 := checkDerefVar(var_glojure_DOT_core_list) + tmp98 := lang.Apply(tmp97, []any{sym_temp__0__auto__}) + tmp99 := lang.Apply(tmp94, []any{tmp96, tmp98}) + tmp100 := lang.Apply(tmp93, []any{tmp99}) + tmp101 := lang.Apply(tmp91, []any{tmp92, tmp100}) + tmp102 := lang.Apply(tmp90, []any{tmp101}) + tmp103 := checkDerefVar(var_glojure_DOT_core_list) + tmp104 := lang.Apply(tmp103, []any{v5}) + tmp105 := lang.Apply(tmp87, []any{tmp89, tmp102, tmp104}) + tmp106 := lang.Apply(tmp86, []any{tmp105}) + tmp107 := lang.Apply(tmp85, []any{tmp106}) + tmp108 := lang.Apply(tmp70, []any{tmp72, tmp82, tmp84, tmp107}) + tmp109 := lang.Apply(tmp69, []any{tmp108}) + tmp110 := lang.Apply(tmp68, []any{tmp109}) + tmp111 := lang.Apply(tmp52, []any{tmp54, tmp67, tmp110}) + tmp112 := lang.Apply(tmp51, []any{tmp111}) + tmp46 = tmp112 + } // end let + return tmp46 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_if_DASH_some = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_if_DASH_some.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // into1 + { + tmp0 := sym_into1.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_to, sym_from)), kw_doc, "Returns a new coll consisting of to-coll with all of the items of\n from-coll conjoined.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(3416), kw_end_DASH_line, int(3416), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp6 := reflect.TypeOf((*lang.IEditableCollection)(nil)).Elem() + tmp7 := lang.Apply(tmp5, []any{tmp6, v2}) + if lang.IsTruthy(tmp7) { + tmp8 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp10 := checkDerefVar(var_glojure_DOT_core_conj_BANG_) + tmp11 := checkDerefVar(var_glojure_DOT_core_transient) + tmp12 := lang.Apply(tmp11, []any{v2}) + tmp13 := lang.Apply(tmp9, []any{tmp10, tmp12, v3}) + tmp14 := lang.Apply(tmp8, []any{tmp13}) + tmp4 = tmp14 + } else { + tmp15 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp16 := checkDerefVar(var_glojure_DOT_core_conj) + tmp17 := lang.Apply(tmp15, []any{tmp16, v2, v3}) + tmp4 = tmp17 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_into1 = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_into1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // juxt + { + tmp0 := sym_juxt.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_g), lang.NewVector(sym_f, sym_g, sym_h), lang.NewVector(sym_f, sym_g, sym_h, sym__AMP_, sym_fs)), kw_doc, "Takes a set of functions and returns a fn that is the juxtaposition\n of those fns. The returned fn takes a variable number of args, and\n returns a vector containing the result of applying each fn to the\n args (left-to-right).\n ((juxt a b c) x) => [(a x) (b x) (c x)]", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(2568), kw_end_DASH_line, int(2568))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp4 := lang.Apply(v2, nil) + tmp5 := lang.NewVector(tmp4) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2578), kw_column, int(12), kw_end_DASH_line, int(2578), kw_end_DASH_column, int(16)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp7 + case 1: + v4 := args[0] + _ = v4 + tmp5 := lang.Apply(v2, []any{v4}) + tmp6 := lang.NewVector(tmp5) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2579), kw_column, int(13), kw_end_DASH_line, int(2579), kw_end_DASH_column, int(19)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp8 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6 := lang.Apply(v2, []any{v4, v5}) + tmp7 := lang.NewVector(tmp6) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2580), kw_column, int(15), kw_end_DASH_line, int(2580), kw_end_DASH_column, int(23)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp9 + case 3: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := args[2] + _ = v6 + tmp7 := lang.Apply(v2, []any{v4, v5, v6}) + tmp8 := lang.NewVector(tmp7) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2581), kw_column, int(17), kw_end_DASH_line, int(2581), kw_end_DASH_column, int(27)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp10 + default: + checkArity(args, 3) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := args[2] + _ = v6 + var v7 any = lang.NewList(args[3:]...) + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_apply) + tmp9 := lang.Apply(tmp8, []any{v2, v4, v5, v6, v7}) + tmp10 := lang.NewVector(tmp9) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2582), kw_column, int(24), kw_end_DASH_line, int(2582), kw_end_DASH_column, int(45)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp12 + } + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2577), kw_column, int(6), kw_end_DASH_line, int(2582), kw_end_DASH_column, int(47)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp5 := lang.Apply(v2, nil) + tmp6 := lang.Apply(v3, nil) + tmp7 := lang.NewVector(tmp5, tmp6) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2585), kw_column, int(12), kw_end_DASH_line, int(2585), kw_end_DASH_column, int(20)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp9 + case 1: + v5 := args[0] + _ = v5 + tmp6 := lang.Apply(v2, []any{v5}) + tmp7 := lang.Apply(v3, []any{v5}) + tmp8 := lang.NewVector(tmp6, tmp7) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2586), kw_column, int(13), kw_end_DASH_line, int(2586), kw_end_DASH_column, int(25)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp10 + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + tmp7 := lang.Apply(v2, []any{v5, v6}) + tmp8 := lang.Apply(v3, []any{v5, v6}) + tmp9 := lang.NewVector(tmp7, tmp8) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2587), kw_column, int(15), kw_end_DASH_line, int(2587), kw_end_DASH_column, int(31)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp11 + case 3: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := args[2] + _ = v7 + tmp8 := lang.Apply(v2, []any{v5, v6, v7}) + tmp9 := lang.Apply(v3, []any{v5, v6, v7}) + tmp10 := lang.NewVector(tmp8, tmp9) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2588), kw_column, int(17), kw_end_DASH_line, int(2588), kw_end_DASH_column, int(37)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp12 + default: + checkArity(args, 3) + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := args[2] + _ = v7 + var v8 any = lang.NewList(args[3:]...) + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_apply) + tmp10 := lang.Apply(tmp9, []any{v2, v5, v6, v7, v8}) + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + tmp12 := lang.Apply(tmp11, []any{v3, v5, v6, v7, v8}) + tmp13 := lang.NewVector(tmp10, tmp12) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2589), kw_column, int(24), kw_end_DASH_line, int(2589), kw_end_DASH_column, int(66)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp15 + } + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2584), kw_column, int(6), kw_end_DASH_line, int(2589), kw_end_DASH_column, int(68)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp6 := lang.Apply(v2, nil) + tmp7 := lang.Apply(v3, nil) + tmp8 := lang.Apply(v4, nil) + tmp9 := lang.NewVector(tmp6, tmp7, tmp8) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2592), kw_column, int(12), kw_end_DASH_line, int(2592), kw_end_DASH_column, int(24)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp11 + case 1: + v6 := args[0] + _ = v6 + tmp7 := lang.Apply(v2, []any{v6}) + tmp8 := lang.Apply(v3, []any{v6}) + tmp9 := lang.Apply(v4, []any{v6}) + tmp10 := lang.NewVector(tmp7, tmp8, tmp9) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2593), kw_column, int(13), kw_end_DASH_line, int(2593), kw_end_DASH_column, int(31)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp12 + case 2: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + tmp8 := lang.Apply(v2, []any{v6, v7}) + tmp9 := lang.Apply(v3, []any{v6, v7}) + tmp10 := lang.Apply(v4, []any{v6, v7}) + tmp11 := lang.NewVector(tmp8, tmp9, tmp10) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2594), kw_column, int(15), kw_end_DASH_line, int(2594), kw_end_DASH_column, int(39)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp13 + case 3: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + tmp9 := lang.Apply(v2, []any{v6, v7, v8}) + tmp10 := lang.Apply(v3, []any{v6, v7, v8}) + tmp11 := lang.Apply(v4, []any{v6, v7, v8}) + tmp12 := lang.NewVector(tmp9, tmp10, tmp11) + tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2595), kw_column, int(17), kw_end_DASH_line, int(2595), kw_end_DASH_column, int(47)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp14 + default: + checkArity(args, 3) + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + var v9 any = lang.NewList(args[3:]...) + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_apply) + tmp11 := lang.Apply(tmp10, []any{v2, v6, v7, v8, v9}) + tmp12 := checkDerefVar(var_glojure_DOT_core_apply) + tmp13 := lang.Apply(tmp12, []any{v3, v6, v7, v8, v9}) + tmp14 := checkDerefVar(var_glojure_DOT_core_apply) + tmp15 := lang.Apply(tmp14, []any{v4, v6, v7, v8, v9}) + tmp16 := lang.NewVector(tmp11, tmp13, tmp15) + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2596), kw_column, int(24), kw_end_DASH_line, int(2596), kw_end_DASH_column, int(87)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp18 + } + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2591), kw_column, int(6), kw_end_DASH_line, int(2596), kw_end_DASH_column, int(89)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp7 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "fs" + tmp7 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp8 := lang.Apply(tmp7, []any{v2, v3, v4, v5}) + var v9 any = tmp8 + _ = v9 + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp11 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp12 lang.FnFunc + tmp12 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v13 := args[0] + _ = v13 + v14 := args[1] + _ = v14 + tmp15 := checkDerefVar(var_glojure_DOT_core_conj) + tmp16 := lang.Apply(v14, nil) + tmp17 := lang.Apply(tmp15, []any{v13, tmp16}) + return tmp17 + }) + tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2600), kw_column, int(23), kw_end_DASH_line, int(2600), kw_end_DASH_column, int(37)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp15 := lang.NewVector() + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2600), kw_column, int(39), kw_end_DASH_line, int(2600), kw_end_DASH_column, int(40)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp18 := lang.Apply(tmp11, []any{tmp14, tmp17, v9}) + return tmp18 + case 1: + v11 := args[0] + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v14 := args[0] + _ = v14 + v15 := args[1] + _ = v15 + tmp16 := checkDerefVar(var_glojure_DOT_core_conj) + tmp17 := lang.Apply(v15, []any{v11}) + tmp18 := lang.Apply(tmp16, []any{v14, tmp17}) + return tmp18 + }) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2601), kw_column, int(24), kw_end_DASH_line, int(2601), kw_end_DASH_column, int(40)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp16 := lang.NewVector() + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2601), kw_column, int(42), kw_end_DASH_line, int(2601), kw_end_DASH_column, int(43)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp19 := lang.Apply(tmp12, []any{tmp15, tmp18, v9}) + return tmp19 + case 2: + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v15 := args[0] + _ = v15 + v16 := args[1] + _ = v16 + tmp17 := checkDerefVar(var_glojure_DOT_core_conj) + tmp18 := lang.Apply(v16, []any{v11, v12}) + tmp19 := lang.Apply(tmp17, []any{v15, tmp18}) + return tmp19 + }) + tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2602), kw_column, int(26), kw_end_DASH_line, int(2602), kw_end_DASH_column, int(44)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp17 := lang.NewVector() + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2602), kw_column, int(46), kw_end_DASH_line, int(2602), kw_end_DASH_column, int(47)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp20 := lang.Apply(tmp13, []any{tmp16, tmp19, v9}) + return tmp20 + case 3: + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + v13 := args[2] + _ = v13 + tmp14 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp15 lang.FnFunc + tmp15 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v16 := args[0] + _ = v16 + v17 := args[1] + _ = v17 + tmp18 := checkDerefVar(var_glojure_DOT_core_conj) + tmp19 := lang.Apply(v17, []any{v11, v12, v13}) + tmp20 := lang.Apply(tmp18, []any{v16, tmp19}) + return tmp20 + }) + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2603), kw_column, int(28), kw_end_DASH_line, int(2603), kw_end_DASH_column, int(48)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp18 := lang.NewVector() + tmp19 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2603), kw_column, int(50), kw_end_DASH_line, int(2603), kw_end_DASH_column, int(51)) + tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp21 := lang.Apply(tmp14, []any{tmp17, tmp20, v9}) + return tmp21 + default: + checkArity(args, 3) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + v13 := args[2] + _ = v13 + var v14 any = lang.NewList(args[3:]...) + _ = v14 + tmp15 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp16 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v17 := args[0] + _ = v17 + v18 := args[1] + _ = v18 + tmp19 := checkDerefVar(var_glojure_DOT_core_conj) + tmp20 := checkDerefVar(var_glojure_DOT_core_apply) + tmp21 := lang.Apply(tmp20, []any{v18, v11, v12, v13, v14}) + tmp22 := lang.Apply(tmp19, []any{v17, tmp21}) + return tmp22 + }) + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2604), kw_column, int(35), kw_end_DASH_line, int(2604), kw_end_DASH_column, int(66)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp19 := lang.NewVector() + tmp20 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2604), kw_column, int(68), kw_end_DASH_line, int(2604), kw_end_DASH_column, int(69)) + tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp22 := lang.Apply(tmp15, []any{tmp18, tmp21, v9}) + return tmp22 + } + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2599), kw_column, int(8), kw_end_DASH_line, int(2604), kw_end_DASH_column, int(75)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp6 = tmp12 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_juxt = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_juxt.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // keep + { + tmp0 := sym_keep.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_coll)), kw_doc, "Returns a lazy sequence of the non-nil results of (f item). Note,\n this means false return values will be included. f must be free of\n side-effects. Returns a transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(7339), kw_end_DASH_line, int(7339))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp6 := lang.Apply(v4, nil) + return tmp6 + case 1: + v6 := args[0] + _ = v6 + tmp7 := lang.Apply(v4, []any{v6}) + return tmp7 + case 2: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + var tmp8 any + { // let + // let binding "v" + tmp9 := lang.Apply(v2, []any{v7}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp13 := lang.Apply(tmp12, []any{v10}) + if lang.IsTruthy(tmp13) { + tmp11 = v6 + } else { + tmp14 := lang.Apply(v4, []any{v6, v10}) + tmp11 = tmp14 + } + tmp8 = tmp11 + } // end let + return tmp8 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7347), kw_column, int(6), kw_end_DASH_line, int(7354), kw_end_DASH_column, int(31)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp7 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7346), kw_column, int(4), kw_end_DASH_line, int(7354), kw_end_DASH_column, int(32)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp5 any + { // let + // let binding "temp__0__auto__" + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := lang.Apply(tmp6, []any{v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + var tmp10 any + { // let + // let binding "s" + var v11 any = v8 + _ = v11 + var tmp12 any + tmp13 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp14 := lang.Apply(tmp13, []any{v11}) + if lang.IsTruthy(tmp14) { + var tmp15 any + { // let + // let binding "c" + tmp16 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp17 := lang.Apply(tmp16, []any{v11}) + var v18 any = tmp17 + _ = v18 + // let binding "size" + tmp19 := checkDerefVar(var_glojure_DOT_core_count) + tmp20 := lang.Apply(tmp19, []any{v18}) + var v21 any = tmp20 + _ = v21 + // let binding "b" + tmp22 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_buffer) + tmp23 := lang.Apply(tmp22, []any{v21}) + var v24 any = tmp23 + _ = v24 + var tmp25 any + { // let + // let binding "n__0__auto__" + tmp26 := checkDerefVar(var_glojure_DOT_core_long) + tmp27 := lang.Apply(tmp26, []any{v21}) + var v28 any = tmp27 + _ = v28 + var tmp29 any + { // let + // let binding "i" + var v30 any = int64(0) + _ = v30 + for { + var tmp31 any + tmp32 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp33 := lang.Apply(tmp32, []any{v30, v28}) + if lang.IsTruthy(tmp33) { + var tmp34 any + { // let + // let binding "x" + tmp35, _ := lang.FieldOrMethod(v18, "nth") + if reflect.TypeOf(tmp35).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp36 := lang.Apply(tmp35, []any{v30}) + tmp37 := lang.Apply(v2, []any{tmp36}) + var v38 any = tmp37 + _ = v38 + var tmp39 any + tmp40 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp41 := lang.Apply(tmp40, []any{v38}) + if lang.IsTruthy(tmp41) { + } else { + tmp42 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_append) + tmp43 := lang.Apply(tmp42, []any{v24, v38}) + tmp39 = tmp43 + } + tmp34 = tmp39 + } // end let + _ = tmp34 + tmp36 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp37 := lang.Apply(tmp36, []any{v30}) + var tmp35 any = tmp37 + v30 = tmp35 + continue + } else { + } + tmp29 = tmp31 + break + } + } // end let + tmp25 = tmp29 + } // end let + _ = tmp25 + tmp26 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_cons) + tmp27 := checkDerefVar(var_glojure_DOT_core_chunk) + tmp28 := lang.Apply(tmp27, []any{v24}) + tmp29 := checkDerefVar(var_glojure_DOT_core_keep) + tmp30 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp31 := lang.Apply(tmp30, []any{v11}) + tmp32 := lang.Apply(tmp29, []any{v2, tmp31}) + tmp33 := lang.Apply(tmp26, []any{tmp28, tmp32}) + tmp15 = tmp33 + } // end let + tmp12 = tmp15 + } else { + var tmp16 any + { // let + // let binding "x" + tmp17 := checkDerefVar(var_glojure_DOT_core_first) + tmp18 := lang.Apply(tmp17, []any{v11}) + tmp19 := lang.Apply(v2, []any{tmp18}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + tmp22 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp23 := lang.Apply(tmp22, []any{v20}) + if lang.IsTruthy(tmp23) { + tmp24 := checkDerefVar(var_glojure_DOT_core_keep) + tmp25 := checkDerefVar(var_glojure_DOT_core_rest) + tmp26 := lang.Apply(tmp25, []any{v11}) + tmp27 := lang.Apply(tmp24, []any{v2, tmp26}) + tmp21 = tmp27 + } else { + tmp28 := checkDerefVar(var_glojure_DOT_core_cons) + tmp29 := checkDerefVar(var_glojure_DOT_core_keep) + tmp30 := checkDerefVar(var_glojure_DOT_core_rest) + tmp31 := lang.Apply(tmp30, []any{v11}) + tmp32 := lang.Apply(tmp29, []any{v2, tmp31}) + tmp33 := lang.Apply(tmp28, []any{v20, tmp32}) + tmp21 = tmp33 + } + tmp16 = tmp21 + } // end let + tmp12 = tmp16 + } + tmp10 = tmp12 + } // end let + tmp9 = tmp10 + } else { + } + tmp5 = tmp9 + } // end let + return tmp5 + }) + tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_keep = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_keep.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // lazy-seq + { + tmp0 := sym_lazy_DASH_seq.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_body)), kw_doc, "Takes a body of expressions that returns an ISeq or nil, and yields\n a Seqable object that will invoke the body only the first time seq\n is called, and will cache the result and return it on all subsequent\n seq calls. See also - realized?", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(11), kw_line, int(676), kw_end_DASH_line, int(676))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_list) + tmp6 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp7 := lang.NewVector() + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(683), kw_column, int(101), kw_end_DASH_line, int(683), kw_end_DASH_column, int(102)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp10 := lang.Apply(tmp6, []any{sym_fn_STAR_, tmp9, v4}) + tmp11 := lang.Apply(tmp5, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_NewLazySeq, tmp10}) + return tmp11 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_lazy_DASH_seq = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_lazy_DASH_seq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // locking + { + tmp0 := sym_locking.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_x, sym__AMP_, sym_body)), kw_doc, "Executes exprs in an implicit do, while holding the monitor of x.\n Will release the monitor of x in all circumstances.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(1643), kw_end_DASH_line, int(1643))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_let}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + tmp12 := checkDerefVar(var_glojure_DOT_core_vector) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_lockee__0__auto__}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v4}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp19}) + tmp21 := lang.Apply(tmp11, []any{tmp12, tmp20}) + tmp22 := lang.Apply(tmp10, []any{tmp21}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_seq) + tmp25 := checkDerefVar(var_glojure_DOT_core_concat) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{sym_try}) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := checkDerefVar(var_glojure_DOT_core_seq) + tmp30 := checkDerefVar(var_glojure_DOT_core_concat) + tmp31 := checkDerefVar(var_glojure_DOT_core_list) + tmp32 := lang.Apply(tmp31, []any{sym_glojure_DOT_core_SLASH_let}) + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := checkDerefVar(var_glojure_DOT_core_apply) + tmp35 := checkDerefVar(var_glojure_DOT_core_vector) + tmp36 := checkDerefVar(var_glojure_DOT_core_seq) + tmp37 := checkDerefVar(var_glojure_DOT_core_concat) + tmp38 := checkDerefVar(var_glojure_DOT_core_list) + tmp39 := lang.Apply(tmp38, []any{sym_locklocal__1__auto__}) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{sym_lockee__0__auto__}) + tmp42 := lang.Apply(tmp37, []any{tmp39, tmp41}) + tmp43 := lang.Apply(tmp36, []any{tmp42}) + tmp44 := lang.Apply(tmp34, []any{tmp35, tmp43}) + tmp45 := lang.Apply(tmp33, []any{tmp44}) + tmp46 := checkDerefVar(var_glojure_DOT_core_list) + tmp47 := checkDerefVar(var_glojure_DOT_core_seq) + tmp48 := checkDerefVar(var_glojure_DOT_core_concat) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) + tmp50 := lang.Apply(tmp49, []any{sym_monitor_DASH_enter}) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := lang.Apply(tmp51, []any{sym_locklocal__1__auto__}) + tmp53 := lang.Apply(tmp48, []any{tmp50, tmp52}) + tmp54 := lang.Apply(tmp47, []any{tmp53}) + tmp55 := lang.Apply(tmp46, []any{tmp54}) + tmp56 := checkDerefVar(var_glojure_DOT_core_list) + tmp57 := checkDerefVar(var_glojure_DOT_core_seq) + tmp58 := checkDerefVar(var_glojure_DOT_core_concat) + tmp59 := checkDerefVar(var_glojure_DOT_core_list) + tmp60 := lang.Apply(tmp59, []any{sym_try}) + tmp61 := checkDerefVar(var_glojure_DOT_core_list) + tmp62 := checkDerefVar(var_glojure_DOT_core_seq) + tmp63 := checkDerefVar(var_glojure_DOT_core_concat) + tmp64 := checkDerefVar(var_glojure_DOT_core_list) + tmp65 := lang.Apply(tmp64, []any{sym_finally}) + tmp66 := checkDerefVar(var_glojure_DOT_core_list) + tmp67 := checkDerefVar(var_glojure_DOT_core_seq) + tmp68 := checkDerefVar(var_glojure_DOT_core_concat) + tmp69 := checkDerefVar(var_glojure_DOT_core_list) + tmp70 := lang.Apply(tmp69, []any{sym_monitor_DASH_exit}) + tmp71 := checkDerefVar(var_glojure_DOT_core_list) + tmp72 := lang.Apply(tmp71, []any{sym_locklocal__1__auto__}) + tmp73 := lang.Apply(tmp68, []any{tmp70, tmp72}) + tmp74 := lang.Apply(tmp67, []any{tmp73}) + tmp75 := lang.Apply(tmp66, []any{tmp74}) + tmp76 := lang.Apply(tmp63, []any{tmp65, tmp75}) + tmp77 := lang.Apply(tmp62, []any{tmp76}) + tmp78 := lang.Apply(tmp61, []any{tmp77}) + tmp79 := lang.Apply(tmp58, []any{tmp60, v5, tmp78}) + tmp80 := lang.Apply(tmp57, []any{tmp79}) + tmp81 := lang.Apply(tmp56, []any{tmp80}) + tmp82 := lang.Apply(tmp30, []any{tmp32, tmp45, tmp55, tmp81}) + tmp83 := lang.Apply(tmp29, []any{tmp82}) + tmp84 := lang.Apply(tmp28, []any{tmp83}) + tmp85 := lang.Apply(tmp25, []any{tmp27, tmp84}) + tmp86 := lang.Apply(tmp24, []any{tmp85}) + tmp87 := lang.Apply(tmp23, []any{tmp86}) + tmp88 := lang.Apply(tmp7, []any{tmp9, tmp22, tmp87}) + tmp89 := lang.Apply(tmp6, []any{tmp88}) + return tmp89 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_locking = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_locking.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // map + { + tmp0 := sym_map.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_coll), lang.NewVector(sym_f, sym_c1, sym_c2), lang.NewVector(sym_f, sym_c1, sym_c2, sym_c3), lang.NewVector(sym_f, sym_c1, sym_c2, sym_c3, sym__AMP_, sym_colls)), kw_doc, "Returns a lazy sequence consisting of the result of applying f to\n the set of first items of each coll, followed by applying f to the\n set of second items in each coll, until any one of the colls is\n exhausted. Any remaining items in other colls are ignored. Function\n f should accept number-of-colls arguments. Returns a transducer when\n no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(2719), kw_end_DASH_line, int(2719))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp6 := lang.Apply(v4, nil) + return tmp6 + case 1: + v6 := args[0] + _ = v6 + tmp7 := lang.Apply(v4, []any{v6}) + return tmp7 + case 2: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + tmp8 := lang.Apply(v2, []any{v7}) + tmp9 := lang.Apply(v4, []any{v6, tmp8}) + return tmp9 + default: + checkArity(args, 2) + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + var v8 any = lang.NewList(args[2:]...) + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_apply) + tmp10 := lang.Apply(tmp9, []any{v2, v7, v8}) + tmp11 := lang.Apply(v4, []any{v6, tmp10}) + return tmp11 + } + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2730), kw_column, int(7), kw_end_DASH_line, int(2736), kw_end_DASH_column, int(47)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp7 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2729), kw_column, int(5), kw_end_DASH_line, int(2736), kw_end_DASH_column, int(48)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp5 any + { // let + // let binding "temp__0__auto__" + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := lang.Apply(tmp6, []any{v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + var tmp10 any + { // let + // let binding "s" + var v11 any = v8 + _ = v11 + var tmp12 any + tmp13 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp14 := lang.Apply(tmp13, []any{v11}) + if lang.IsTruthy(tmp14) { + var tmp15 any + { // let + // let binding "c" + tmp16 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp17 := lang.Apply(tmp16, []any{v11}) + var v18 any = tmp17 + _ = v18 + // let binding "size" + tmp19 := checkDerefVar(var_glojure_DOT_core_int) + tmp20 := checkDerefVar(var_glojure_DOT_core_count) + tmp21 := lang.Apply(tmp20, []any{v18}) + tmp22 := lang.Apply(tmp19, []any{tmp21}) + var v23 any = tmp22 + _ = v23 + // let binding "b" + tmp24 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_buffer) + tmp25 := lang.Apply(tmp24, []any{v23}) + var v26 any = tmp25 + _ = v26 + var tmp27 any + { // let + // let binding "n__0__auto__" + tmp28 := lang.Apply(lang.LongCast, []any{v23}) + var v29 any = tmp28 + _ = v29 + var tmp30 any + { // let + // let binding "i" + var v31 any = int64(0) + _ = v31 + for { + var tmp32 any + tmp33 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp34 := lang.Apply(tmp33, []any{v31, v29}) + if lang.IsTruthy(tmp34) { + tmp35 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_append) + tmp36, _ := lang.FieldOrMethod(v18, "nth") + if reflect.TypeOf(tmp36).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp37 := lang.Apply(tmp36, []any{v31}) + tmp38 := lang.Apply(v2, []any{tmp37}) + tmp39 := lang.Apply(tmp35, []any{v26, tmp38}) + _ = tmp39 + tmp41 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp42 := lang.Apply(tmp41, []any{v31}) + var tmp40 any = tmp42 + v31 = tmp40 + continue + } else { + } + tmp30 = tmp32 + break + } + } // end let + tmp27 = tmp30 + } // end let + _ = tmp27 + tmp28 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_cons) + tmp29 := checkDerefVar(var_glojure_DOT_core_chunk) + tmp30 := lang.Apply(tmp29, []any{v26}) + tmp31 := checkDerefVar(var_glojure_DOT_core_map) + tmp32 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp33 := lang.Apply(tmp32, []any{v11}) + tmp34 := lang.Apply(tmp31, []any{v2, tmp33}) + tmp35 := lang.Apply(tmp28, []any{tmp30, tmp34}) + tmp15 = tmp35 + } // end let + tmp12 = tmp15 + } else { + tmp16 := checkDerefVar(var_glojure_DOT_core_cons) + tmp17 := checkDerefVar(var_glojure_DOT_core_first) + tmp18 := lang.Apply(tmp17, []any{v11}) + tmp19 := lang.Apply(v2, []any{tmp18}) + tmp20 := checkDerefVar(var_glojure_DOT_core_map) + tmp21 := checkDerefVar(var_glojure_DOT_core_rest) + tmp22 := lang.Apply(tmp21, []any{v11}) + tmp23 := lang.Apply(tmp20, []any{v2, tmp22}) + tmp24 := lang.Apply(tmp16, []any{tmp19, tmp23}) + tmp12 = tmp24 + } + tmp10 = tmp12 + } // end let + tmp9 = tmp10 + } else { + } + tmp5 = tmp9 + } // end let + return tmp5 + }) + tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) + return tmp5 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp6 any + { // let + // let binding "s1" + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := lang.Apply(tmp7, []any{v3}) + var v9 any = tmp8 + _ = v9 + // let binding "s2" + tmp10 := checkDerefVar(var_glojure_DOT_core_seq) + tmp11 := lang.Apply(tmp10, []any{v4}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + var tmp14 any + { // let + // let binding "and__0__auto__" + var v15 any = v9 + _ = v15 + var tmp16 any + if lang.IsTruthy(v15) { + tmp16 = v12 + } else { + tmp16 = v15 + } + tmp14 = tmp16 + } // end let + if lang.IsTruthy(tmp14) { + tmp15 := checkDerefVar(var_glojure_DOT_core_cons) + tmp16 := checkDerefVar(var_glojure_DOT_core_first) + tmp17 := lang.Apply(tmp16, []any{v9}) + tmp18 := checkDerefVar(var_glojure_DOT_core_first) + tmp19 := lang.Apply(tmp18, []any{v12}) + tmp20 := lang.Apply(v2, []any{tmp17, tmp19}) + tmp21 := checkDerefVar(var_glojure_DOT_core_map) + tmp22 := checkDerefVar(var_glojure_DOT_core_rest) + tmp23 := lang.Apply(tmp22, []any{v9}) + tmp24 := checkDerefVar(var_glojure_DOT_core_rest) + tmp25 := lang.Apply(tmp24, []any{v12}) + tmp26 := lang.Apply(tmp21, []any{v2, tmp23, tmp25}) + tmp27 := lang.Apply(tmp15, []any{tmp20, tmp26}) + tmp13 = tmp27 + } else { + } + tmp6 = tmp13 + } // end let + return tmp6 + }) + tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) + return tmp6 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp7 any + { // let + // let binding "s1" + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := lang.Apply(tmp8, []any{v3}) + var v10 any = tmp9 + _ = v10 + // let binding "s2" + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := lang.Apply(tmp11, []any{v4}) + var v13 any = tmp12 + _ = v13 + // let binding "s3" + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := lang.Apply(tmp14, []any{v5}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + var tmp18 any + { // let + // let binding "and__0__auto__" + var v19 any = v10 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + var tmp21 any + { // let + // let binding "and__0__auto__" + var v22 any = v13 + _ = v22 + var tmp23 any + if lang.IsTruthy(v22) { + tmp23 = v16 + } else { + tmp23 = v22 + } + tmp21 = tmp23 + } // end let + tmp20 = tmp21 + } else { + tmp20 = v19 + } + tmp18 = tmp20 + } // end let + if lang.IsTruthy(tmp18) { + tmp19 := checkDerefVar(var_glojure_DOT_core_cons) + tmp20 := checkDerefVar(var_glojure_DOT_core_first) + tmp21 := lang.Apply(tmp20, []any{v10}) + tmp22 := checkDerefVar(var_glojure_DOT_core_first) + tmp23 := lang.Apply(tmp22, []any{v13}) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v16}) + tmp26 := lang.Apply(v2, []any{tmp21, tmp23, tmp25}) + tmp27 := checkDerefVar(var_glojure_DOT_core_map) + tmp28 := checkDerefVar(var_glojure_DOT_core_rest) + tmp29 := lang.Apply(tmp28, []any{v10}) + tmp30 := checkDerefVar(var_glojure_DOT_core_rest) + tmp31 := lang.Apply(tmp30, []any{v13}) + tmp32 := checkDerefVar(var_glojure_DOT_core_rest) + tmp33 := lang.Apply(tmp32, []any{v16}) + tmp34 := lang.Apply(tmp27, []any{v2, tmp29, tmp31, tmp33}) + tmp35 := lang.Apply(tmp19, []any{tmp26, tmp34}) + tmp17 = tmp35 + } else { + } + tmp7 = tmp17 + } // end let + return tmp7 + }) + tmp7 := lang.Apply(lang.NewLazySeq, []any{tmp6}) + return tmp7 + default: + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var v6 any = lang.NewList(args[4:]...) + _ = v6 + var tmp7 any + { // let + // let binding "step" + var tmp8 lang.FnFunc + { // function step + var v9 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v10 := args[0] + _ = v10 + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp12 any + { // let + // let binding "ss" + tmp13 := checkDerefVar(var_glojure_DOT_core_map) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := lang.Apply(tmp13, []any{tmp14, v10}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + tmp18 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + tmp19 := checkDerefVar(var_glojure_DOT_core_identity) + tmp20 := lang.Apply(tmp18, []any{tmp19, v16}) + if lang.IsTruthy(tmp20) { + tmp21 := checkDerefVar(var_glojure_DOT_core_cons) + tmp22 := checkDerefVar(var_glojure_DOT_core_map) + tmp23 := checkDerefVar(var_glojure_DOT_core_first) + tmp24 := lang.Apply(tmp22, []any{tmp23, v16}) + tmp25 := checkDerefVar(var_glojure_DOT_core_map) + tmp26 := checkDerefVar(var_glojure_DOT_core_rest) + tmp27 := lang.Apply(tmp25, []any{tmp26, v16}) + tmp28 := lang.Apply(v9, []any{tmp27}) + tmp29 := lang.Apply(tmp21, []any{tmp24, tmp28}) + tmp17 = tmp29 + } else { + } + tmp12 = tmp17 + } // end let + return tmp12 + }) + tmp12 := lang.Apply(lang.NewLazySeq, []any{tmp11}) + return tmp12 + }) + v9 = tmp8 + _ = v9 + } + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2761), kw_column, int(15), kw_end_DASH_line, int(2765), kw_end_DASH_column, int(68)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v11 any = tmp10 + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_map) + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v14 := args[0] + _ = v14 + tmp15 := checkDerefVar(var_glojure_DOT_core_apply) + tmp16 := lang.Apply(tmp15, []any{v2, v14}) + return tmp16 + }) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2766), kw_column, int(11), kw_end_DASH_line, int(2766), kw_end_DASH_column, int(22)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp16 := checkDerefVar(var_glojure_DOT_core_conj) + tmp17 := lang.Apply(tmp16, []any{v6, v5, v4, v3}) + tmp18 := lang.Apply(v11, []any{tmp17}) + tmp19 := lang.Apply(tmp12, []any{tmp15, tmp18}) + tmp7 = tmp19 + } // end let + return tmp7 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_map = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_map.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // max + { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed14 + } else { + tmp4 = closed14 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed14 + } else { + tmp5 = closed14 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed14 + } else { + tmp6 = closed14 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym_max.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns the greatest of the nums.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(1108), kw_end_DASH_line, int(1108))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + return v4 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Max") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Max is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp8 := checkDerefVar(var_glojure_DOT_core_max) + tmp9 := checkDerefVar(var_glojure_DOT_core_max) + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) + return tmp11 + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_max = ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_max.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // max-key + { + tmp0 := sym_max_DASH_key.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_k, sym_x), lang.NewVector(sym_k, sym_x, sym_y), lang.NewVector(sym_k, sym_x, sym_y, sym__AMP_, sym_more)), kw_doc, "Returns the x for which (k x), a number, is greatest.\n\n If there are multiple such xs, the last one is returned.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(5013), kw_end_DASH_line, int(5013))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + return v3 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__GT_) + tmp7 := lang.Apply(v2, []any{v3}) + tmp8 := lang.Apply(v2, []any{v4}) + tmp9 := lang.Apply(tmp6, []any{tmp7, tmp8}) + if lang.IsTruthy(tmp9) { + tmp5 = v3 + } else { + tmp5 = v4 + } + return tmp5 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "kx" + tmp7 := lang.Apply(v2, []any{v3}) + var v8 any = tmp7 + _ = v8 + // let binding "ky" + tmp9 := lang.Apply(v2, []any{v4}) + var v10 any = tmp9 + _ = v10 + // let binding "vec__746" + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core__GT_) + tmp13 := lang.Apply(tmp12, []any{v8, v10}) + if lang.IsTruthy(tmp13) { + tmp14 := lang.NewVector(v3, v8) + tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5023), kw_column, int(31), kw_end_DASH_line, int(5023), kw_end_DASH_column, int(36)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp11 = tmp16 + } else { + tmp17 := lang.NewVector(v4, v10) + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5023), kw_column, int(38), kw_end_DASH_line, int(5023), kw_end_DASH_column, int(43)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp11 = tmp19 + } + var v20 any = tmp11 + _ = v20 + // let binding "v" + tmp21 := checkDerefVar(var_glojure_DOT_core_nth) + tmp22 := lang.Apply(tmp21, []any{v20, int64(0), nil}) + var v23 any = tmp22 + _ = v23 + // let binding "kv" + tmp24 := checkDerefVar(var_glojure_DOT_core_nth) + tmp25 := lang.Apply(tmp24, []any{v20, int64(1), nil}) + var v26 any = tmp25 + _ = v26 + var tmp27 any + { // let + // let binding "v" + var v28 any = v23 + _ = v28 + // let binding "kv" + var v29 any = v26 + _ = v29 + // let binding "more" + var v30 any = v5 + _ = v30 + for { + var tmp31 any + if lang.IsTruthy(v30) { + var tmp32 any + { // let + // let binding "w" + tmp33 := checkDerefVar(var_glojure_DOT_core_first) + tmp34 := lang.Apply(tmp33, []any{v30}) + var v35 any = tmp34 + _ = v35 + // let binding "kw" + tmp36 := lang.Apply(v2, []any{v35}) + var v37 any = tmp36 + _ = v37 + var tmp38 any + tmp39 := checkDerefVar(var_glojure_DOT_core__GT__EQ_) + tmp40 := lang.Apply(tmp39, []any{v37, v29}) + if lang.IsTruthy(tmp40) { + var tmp41 any = v35 + var tmp42 any = v37 + tmp44 := checkDerefVar(var_glojure_DOT_core_next) + tmp45 := lang.Apply(tmp44, []any{v30}) + var tmp43 any = tmp45 + v28 = tmp41 + v29 = tmp42 + v30 = tmp43 + continue + } else { + var tmp46 any = v28 + var tmp47 any = v29 + tmp49 := checkDerefVar(var_glojure_DOT_core_next) + tmp50 := lang.Apply(tmp49, []any{v30}) + var tmp48 any = tmp50 + v28 = tmp46 + v29 = tmp47 + v30 = tmp48 + continue + } + tmp32 = tmp38 + } // end let + tmp31 = tmp32 + } else { + tmp31 = v28 + } + tmp27 = tmp31 + break + } + } // end let + tmp6 = tmp27 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_max_DASH_key = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_max_DASH_key.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // memfn + { + tmp0 := sym_memfn.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym__AMP_, sym_args)), kw_doc, "Expands into code that creates a fn that expects to be passed an\n object and any args and calls the named instance method on the\n object passing the args. Use when you want to treat a Java method as\n a first-class fn. name may be type-hinted with the method receiver's\n type in order to avoid reflective calls.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(11), kw_line, int(3872), kw_end_DASH_line, int(3872))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "t" + tmp7 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp8 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp9 := lang.Apply(tmp8, []any{"target"}) + tmp10 := checkDerefVar(var_glojure_DOT_core_meta) + tmp11 := lang.Apply(tmp10, []any{v4}) + tmp12 := lang.Apply(tmp7, []any{tmp9, tmp11}) + var v13 any = tmp12 + _ = v13 + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{sym_glojure_DOT_core_SLASH_fn}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := checkDerefVar(var_glojure_DOT_core_apply) + tmp20 := checkDerefVar(var_glojure_DOT_core_vector) + tmp21 := checkDerefVar(var_glojure_DOT_core_seq) + tmp22 := checkDerefVar(var_glojure_DOT_core_concat) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := lang.Apply(tmp23, []any{v13}) + tmp25 := lang.Apply(tmp22, []any{tmp24, v5}) + tmp26 := lang.Apply(tmp21, []any{tmp25}) + tmp27 := lang.Apply(tmp19, []any{tmp20, tmp26}) + tmp28 := lang.Apply(tmp18, []any{tmp27}) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := checkDerefVar(var_glojure_DOT_core_seq) + tmp31 := checkDerefVar(var_glojure_DOT_core_concat) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := lang.Apply(tmp32, []any{sym__DOT_}) + tmp34 := checkDerefVar(var_glojure_DOT_core_list) + tmp35 := lang.Apply(tmp34, []any{v13}) + tmp36 := checkDerefVar(var_glojure_DOT_core_list) + tmp37 := checkDerefVar(var_glojure_DOT_core_seq) + tmp38 := checkDerefVar(var_glojure_DOT_core_concat) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := lang.Apply(tmp39, []any{v4}) + tmp41 := lang.Apply(tmp38, []any{tmp40, v5}) + tmp42 := lang.Apply(tmp37, []any{tmp41}) + tmp43 := lang.Apply(tmp36, []any{tmp42}) + tmp44 := lang.Apply(tmp31, []any{tmp33, tmp35, tmp43}) + tmp45 := lang.Apply(tmp30, []any{tmp44}) + tmp46 := lang.Apply(tmp29, []any{tmp45}) + tmp47 := lang.Apply(tmp15, []any{tmp17, tmp28, tmp46}) + tmp48 := lang.Apply(tmp14, []any{tmp47}) + tmp6 = tmp48 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_memfn = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_memfn.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // merge + { + tmp0 := sym_merge.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_maps)), kw_doc, "Returns a map that consists of the rest of the maps conj-ed onto\n the first. If a key occurs in more than one map, the mapping from\n the latter (left-to-right) will be the mapping in the result.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3040), kw_end_DASH_line, int(3040))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_some) + tmp5 := checkDerefVar(var_glojure_DOT_core_identity) + tmp6 := lang.Apply(tmp4, []any{tmp5, v2}) + if lang.IsTruthy(tmp6) { + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp8 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v9 := args[0] + _ = v9 + v10 := args[1] + _ = v10 + tmp11 := checkDerefVar(var_glojure_DOT_core_conj) + var tmp12 any + { // let + // let binding "or__0__auto__" + var v13 any = v9 + _ = v13 + var tmp14 any + if lang.IsTruthy(v13) { + tmp14 = v13 + } else { + tmp15 := lang.NewMap() + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3048), kw_column, int(28), kw_end_DASH_line, int(3048), kw_end_DASH_column, int(29)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp14 = tmp17 + } + tmp12 = tmp14 + } // end let + tmp13 := lang.Apply(tmp11, []any{tmp12, v10}) + return tmp13 + }) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3048), kw_column, int(14), kw_end_DASH_line, int(3048), kw_end_DASH_column, int(34)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp11 := lang.Apply(tmp7, []any{tmp10, v2}) + tmp3 = tmp11 + } else { + } + return tmp3 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_merge = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_merge.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // merge-with + { + tmp0 := sym_merge_DASH_with.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym__AMP_, sym_maps)), kw_doc, "Returns a map that consists of the rest of the maps conj-ed onto\n the first. If a key occurs in more than one map, the mapping(s)\n from the latter (left-to-right) will be combined with the mapping in\n the result by calling (f val-in-result val-in-latter).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(3050), kw_end_DASH_line, int(3050))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_some) + tmp6 := checkDerefVar(var_glojure_DOT_core_identity) + tmp7 := lang.Apply(tmp5, []any{tmp6, v3}) + if lang.IsTruthy(tmp7) { + var tmp8 any + { // let + // let binding "merge-entry" + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + var tmp12 any + { // let + // let binding "k" + tmp13 := checkDerefVar(var_glojure_DOT_core_key) + tmp14 := lang.Apply(tmp13, []any{v11}) + var v15 any = tmp14 + _ = v15 + // let binding "v" + tmp16 := checkDerefVar(var_glojure_DOT_core_val) + tmp17 := lang.Apply(tmp16, []any{v11}) + var v18 any = tmp17 + _ = v18 + var tmp19 any + tmp20 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp21 := lang.Apply(tmp20, []any{v10, v15}) + if lang.IsTruthy(tmp21) { + tmp22 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp23 := checkDerefVar(var_glojure_DOT_core_get) + tmp24 := lang.Apply(tmp23, []any{v10, v15}) + tmp25 := lang.Apply(v2, []any{tmp24, v18}) + tmp26 := lang.Apply(tmp22, []any{v10, v15, tmp25}) + tmp19 = tmp26 + } else { + tmp27 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp28 := lang.Apply(tmp27, []any{v10, v15, v18}) + tmp19 = tmp28 + } + tmp12 = tmp19 + } // end let + return tmp12 + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3059), kw_column, int(23), kw_end_DASH_line, int(3063), kw_end_DASH_column, int(23)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v12 any = tmp11 + _ = v12 + // let binding "merge2" + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v14 := args[0] + _ = v14 + v15 := args[1] + _ = v15 + tmp16 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp17 any + { // let + // let binding "or__0__auto__" + var v18 any = v14 + _ = v18 + var tmp19 any + if lang.IsTruthy(v18) { + tmp19 = v18 + } else { + tmp20 := lang.NewMap() + tmp21 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3065), kw_column, int(34), kw_end_DASH_line, int(3065), kw_end_DASH_column, int(35)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp19 = tmp22 + } + tmp17 = tmp19 + } // end let + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := lang.Apply(tmp18, []any{v15}) + tmp20 := lang.Apply(tmp16, []any{v12, tmp17, tmp19}) + return tmp20 + }) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3064), kw_column, int(18), kw_end_DASH_line, int(3065), kw_end_DASH_column, int(47)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v16 any = tmp15 + _ = v16 + tmp17 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp18 := lang.Apply(tmp17, []any{v16, v3}) + tmp8 = tmp18 + } // end let + tmp4 = tmp8 + } else { + } + return tmp4 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_merge_DASH_with = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_merge_DASH_with.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // min + { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed15 + } else { + tmp4 = closed15 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed15 + } else { + tmp5 = closed15 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed15 + } else { + tmp6 = closed15 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym_min.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns the least of the nums.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(1118), kw_end_DASH_line, int(1118))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + return v4 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Min") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Min is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp8 := checkDerefVar(var_glojure_DOT_core_min) + tmp9 := checkDerefVar(var_glojure_DOT_core_min) + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) + return tmp11 + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_min = ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_min.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // min-key + { + tmp0 := sym_min_DASH_key.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_k, sym_x), lang.NewVector(sym_k, sym_x, sym_y), lang.NewVector(sym_k, sym_x, sym_y, sym__AMP_, sym_more)), kw_doc, "Returns the x for which (k x), a number, is least.\n\n If there are multiple such xs, the last one is returned.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(5033), kw_end_DASH_line, int(5033))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + return v3 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp7 := lang.Apply(v2, []any{v3}) + tmp8 := lang.Apply(v2, []any{v4}) + tmp9 := lang.Apply(tmp6, []any{tmp7, tmp8}) + if lang.IsTruthy(tmp9) { + tmp5 = v3 + } else { + tmp5 = v4 + } + return tmp5 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "kx" + tmp7 := lang.Apply(v2, []any{v3}) + var v8 any = tmp7 + _ = v8 + // let binding "ky" + tmp9 := lang.Apply(v2, []any{v4}) + var v10 any = tmp9 + _ = v10 + // let binding "vec__749" + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp13 := lang.Apply(tmp12, []any{v8, v10}) + if lang.IsTruthy(tmp13) { + tmp14 := lang.NewVector(v3, v8) + tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5043), kw_column, int(31), kw_end_DASH_line, int(5043), kw_end_DASH_column, int(36)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp11 = tmp16 + } else { + tmp17 := lang.NewVector(v4, v10) + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5043), kw_column, int(38), kw_end_DASH_line, int(5043), kw_end_DASH_column, int(43)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp11 = tmp19 + } + var v20 any = tmp11 + _ = v20 + // let binding "v" + tmp21 := checkDerefVar(var_glojure_DOT_core_nth) + tmp22 := lang.Apply(tmp21, []any{v20, int64(0), nil}) + var v23 any = tmp22 + _ = v23 + // let binding "kv" + tmp24 := checkDerefVar(var_glojure_DOT_core_nth) + tmp25 := lang.Apply(tmp24, []any{v20, int64(1), nil}) + var v26 any = tmp25 + _ = v26 + var tmp27 any + { // let + // let binding "v" + var v28 any = v23 + _ = v28 + // let binding "kv" + var v29 any = v26 + _ = v29 + // let binding "more" + var v30 any = v5 + _ = v30 + for { + var tmp31 any + if lang.IsTruthy(v30) { + var tmp32 any + { // let + // let binding "w" + tmp33 := checkDerefVar(var_glojure_DOT_core_first) + tmp34 := lang.Apply(tmp33, []any{v30}) + var v35 any = tmp34 + _ = v35 + // let binding "kw" + tmp36 := lang.Apply(v2, []any{v35}) + var v37 any = tmp36 + _ = v37 + var tmp38 any + tmp39 := checkDerefVar(var_glojure_DOT_core__LT__EQ_) + tmp40 := lang.Apply(tmp39, []any{v37, v29}) + if lang.IsTruthy(tmp40) { + var tmp41 any = v35 + var tmp42 any = v37 + tmp44 := checkDerefVar(var_glojure_DOT_core_next) + tmp45 := lang.Apply(tmp44, []any{v30}) + var tmp43 any = tmp45 + v28 = tmp41 + v29 = tmp42 + v30 = tmp43 + continue + } else { + var tmp46 any = v28 + var tmp47 any = v29 + tmp49 := checkDerefVar(var_glojure_DOT_core_next) + tmp50 := lang.Apply(tmp49, []any{v30}) + var tmp48 any = tmp50 + v28 = tmp46 + v29 = tmp47 + v30 = tmp48 + continue + } + tmp32 = tmp38 + } // end let + tmp31 = tmp32 + } else { + tmp31 = v28 + } + tmp27 = tmp31 + break + } + } // end let + tmp6 = tmp27 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_min_DASH_key = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_min_DASH_key.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // mod + { + tmp0 := sym_mod.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_num, sym_div)), kw_doc, "Modulus of num and div. Truncates toward negative infinity.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(3567), kw_end_DASH_line, int(3567))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "m" + tmp5 := checkDerefVar(var_glojure_DOT_core_rem) + tmp6 := lang.Apply(tmp5, []any{v2, v3}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + var tmp9 any + { // let + // let binding "or__0__auto__" + tmp10 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) + tmp11 := lang.Apply(tmp10, []any{v7}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + tmp13 = v12 + } else { + tmp14 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp15 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp16 := lang.Apply(tmp15, []any{v2}) + tmp17 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp13 = tmp19 + } + tmp9 = tmp13 + } // end let + if lang.IsTruthy(tmp9) { + tmp8 = v7 + } else { + tmp10 := checkDerefVar(var_glojure_DOT_core__PLUS_) + tmp11 := lang.Apply(tmp10, []any{v7, v3}) + tmp8 = tmp11 + } + tmp4 = tmp8 + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_mod = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_mod.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // nary-inline + { + tmp0 := sym_nary_DASH_inline.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(948), kw_column, int(7), kw_end_DASH_line, int(948), kw_end_DASH_column, int(27), kw_arglists, lang.NewList(lang.NewVector(sym_op), lang.NewVector(sym_op, sym_unchecked_DASH_op)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_nary_DASH_inline) + tmp4 := lang.Apply(tmp3, []any{v2, v2}) + return tmp4 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v5 := args[0] + _ = v5 + var tmp6 any + { // let + // let binding "op" + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp8) { + tmp7 = v3 + } else { + tmp7 = v2 + } + var v9 any = tmp7 + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_seq) + tmp11 := checkDerefVar(var_glojure_DOT_core_concat) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym__DOT_}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := checkDerefVar(var_glojure_DOT_core_seq) + tmp18 := checkDerefVar(var_glojure_DOT_core_concat) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v9}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v5}) + tmp23 := lang.Apply(tmp18, []any{tmp20, tmp22}) + tmp24 := lang.Apply(tmp17, []any{tmp23}) + tmp25 := lang.Apply(tmp16, []any{tmp24}) + tmp26 := lang.Apply(tmp11, []any{tmp13, tmp15, tmp25}) + tmp27 := lang.Apply(tmp10, []any{tmp26}) + tmp6 = tmp27 + } // end let + return tmp6 + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + var tmp7 any + { // let + // let binding "op" + var tmp8 any + tmp9 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp9) { + tmp8 = v3 + } else { + tmp8 = v2 + } + var v10 any = tmp8 + _ = v10 + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym__DOT_}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{v10}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v5}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v6}) + tmp26 := lang.Apply(tmp19, []any{tmp21, tmp23, tmp25}) + tmp27 := lang.Apply(tmp18, []any{tmp26}) + tmp28 := lang.Apply(tmp17, []any{tmp27}) + tmp29 := lang.Apply(tmp12, []any{tmp14, tmp16, tmp28}) + tmp30 := lang.Apply(tmp11, []any{tmp29}) + tmp7 = tmp30 + } // end let + return tmp7 + default: + checkArity(args, 2) + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + var v7 any = lang.NewList(args[2:]...) + _ = v7 + var tmp8 any + { // let + // let binding "op" + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp10) { + tmp9 = v3 + } else { + tmp9 = v2 + } + var v11 any = tmp9 + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v14 := args[0] + _ = v14 + v15 := args[1] + _ = v15 + tmp16 := checkDerefVar(var_glojure_DOT_core_seq) + tmp17 := checkDerefVar(var_glojure_DOT_core_concat) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{sym__DOT_}) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := checkDerefVar(var_glojure_DOT_core_seq) + tmp24 := checkDerefVar(var_glojure_DOT_core_concat) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := lang.Apply(tmp25, []any{v11}) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{v14}) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{v15}) + tmp31 := lang.Apply(tmp24, []any{tmp26, tmp28, tmp30}) + tmp32 := lang.Apply(tmp23, []any{tmp31}) + tmp33 := lang.Apply(tmp22, []any{tmp32}) + tmp34 := lang.Apply(tmp17, []any{tmp19, tmp21, tmp33}) + tmp35 := lang.Apply(tmp16, []any{tmp34}) + return tmp35 + }) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp16 := checkDerefVar(var_glojure_DOT_core_seq) + tmp17 := checkDerefVar(var_glojure_DOT_core_concat) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{sym__DOT_}) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := checkDerefVar(var_glojure_DOT_core_seq) + tmp24 := checkDerefVar(var_glojure_DOT_core_concat) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := lang.Apply(tmp25, []any{v11}) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{v5}) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{v6}) + tmp31 := lang.Apply(tmp24, []any{tmp26, tmp28, tmp30}) + tmp32 := lang.Apply(tmp23, []any{tmp31}) + tmp33 := lang.Apply(tmp22, []any{tmp32}) + tmp34 := lang.Apply(tmp17, []any{tmp19, tmp21, tmp33}) + tmp35 := lang.Apply(tmp16, []any{tmp34}) + tmp36 := lang.Apply(tmp12, []any{tmp15, tmp35, v7}) + tmp8 = tmp36 + } // end let + return tmp8 + } + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_nary_DASH_inline = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_nary_DASH_inline.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // nat-int? + { + tmp0 := sym_nat_DASH_int_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a non-negative fixed precision integer", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(1415), kw_end_DASH_line, int(1415))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "and__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + tmp8 := checkDerefVar(var_glojure_DOT_core_not) + tmp9 := checkDerefVar(var_glojure_DOT_core_neg_QMARK_) + tmp10 := lang.Apply(tmp9, []any{v2}) + tmp11 := lang.Apply(tmp8, []any{tmp10}) + tmp7 = tmp11 + } else { + tmp7 = v6 + } + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_nat_DASH_int_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_nat_DASH_int_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // neg-int? + { + tmp0 := sym_neg_DASH_int_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a negative fixed precision integer", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(1409), kw_end_DASH_line, int(1409))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "and__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + tmp8 := checkDerefVar(var_glojure_DOT_core_neg_QMARK_) + tmp9 := lang.Apply(tmp8, []any{v2}) + tmp7 = tmp9 + } else { + tmp7 = v6 + } + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_neg_DASH_int_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_neg_DASH_int_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // not-any? + { + tmp1 := reflect.TypeOf(false) + tmp0 := sym_not_DASH_any_QMARK_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns false if (pred x) is logical true for any x in coll,\n else true.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(2), kw_line, int(2696), kw_end_DASH_line, int(2701))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp3 := lang.Apply(closed17, nil) + tmp4 := lang.Apply(closed16, []any{tmp3}) + return tmp4 + case 1: + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(closed17, []any{v3}) + tmp5 := lang.Apply(closed16, []any{tmp4}) + return tmp5 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(closed17, []any{v3, v4}) + tmp6 := lang.Apply(closed16, []any{tmp5}) + return tmp6 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6 := lang.Apply(closed17, []any{v3, v4, v5}) + tmp7 := lang.Apply(closed16, []any{tmp6}) + return tmp7 + default: + checkArity(args, 3) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_apply) + tmp8 := lang.Apply(tmp7, []any{closed17, v3, v4, v5, v6}) + tmp9 := lang.Apply(closed16, []any{tmp8}) + return tmp9 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2559), kw_column, int(6), kw_end_DASH_line, int(2564), kw_end_DASH_column, int(49))).(lang.FnFunc) + var_glojure_DOT_core_not_DASH_any_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_not_DASH_any_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // not-every? + { + tmp1 := reflect.TypeOf(false) + tmp0 := sym_not_DASH_every_QMARK_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns false if (pred x) is logical true for every x in\n coll, else true.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(2), kw_line, int(2677), kw_end_DASH_line, int(2682))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp3 := lang.Apply(closed18, nil) + tmp4 := lang.Apply(closed16, []any{tmp3}) + return tmp4 + case 1: + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(closed18, []any{v3}) + tmp5 := lang.Apply(closed16, []any{tmp4}) + return tmp5 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(closed18, []any{v3, v4}) + tmp6 := lang.Apply(closed16, []any{tmp5}) + return tmp6 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6 := lang.Apply(closed18, []any{v3, v4, v5}) + tmp7 := lang.Apply(closed16, []any{tmp6}) + return tmp7 + default: + checkArity(args, 3) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_apply) + tmp8 := lang.Apply(tmp7, []any{closed18, v3, v4, v5, v6}) + tmp9 := lang.Apply(closed16, []any{tmp8}) + return tmp9 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2559), kw_column, int(6), kw_end_DASH_line, int(2564), kw_end_DASH_column, int(49))).(lang.FnFunc) + var_glojure_DOT_core_not_DASH_every_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_not_DASH_every_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // not= + { + tmp1 := reflect.TypeOf(false) + tmp0 := sym_not_EQ_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_doc, "Same as (not (= obj1 obj2))", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(812), kw_end_DASH_line, int(812))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + return false + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_not) + tmp6 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp7 := lang.Apply(tmp6, []any{v3, v4}) + tmp8 := lang.Apply(tmp5, []any{tmp7}) + return tmp8 + default: + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_not) + tmp7 := checkDerefVar(var_glojure_DOT_core_apply) + tmp8 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp9 := lang.Apply(tmp7, []any{tmp8, v3, v4, v5}) + tmp10 := lang.Apply(tmp6, []any{tmp9}) + return tmp10 + } + }) + tmp3 := reflect.TypeOf(false) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_not_EQ_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_not_EQ_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ns-interns + { + tmp0 := sym_ns_DASH_interns.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns)), kw_doc, "Returns a map of the intern mappings for the namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4206), kw_end_DASH_line, int(4206))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "ns" + tmp4 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_filter_DASH_key) + tmp8 := checkDerefVar(var_glojure_DOT_core_val) + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v10 := args[0] + _ = v10 + var tmp11 any + { // let + // let binding "and__0__auto__" + tmp12 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp13 := reflect.TypeOf((*lang.Var)(nil)) + tmp14 := lang.Apply(tmp12, []any{tmp13, v10}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + if lang.IsTruthy(v15) { + tmp17 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp18, ok := lang.FieldOrMethod(v10, "Namespace") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v10, "Namespace"))) + } + var tmp19 any + switch reflect.TypeOf(tmp18).Kind() { + case reflect.Func: + tmp19 = lang.Apply(tmp18, nil) + default: + tmp19 = tmp18 + } + tmp20 := lang.Apply(tmp17, []any{v6, tmp19}) + tmp16 = tmp20 + } else { + tmp16 = v15 + } + tmp11 = tmp16 + } // end let + return tmp11 + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4212), kw_column, int(21), kw_end_DASH_line, int(4213), kw_end_DASH_column, int(56)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp12 := checkDerefVar(var_glojure_DOT_core_ns_DASH_map) + tmp13 := lang.Apply(tmp12, []any{v6}) + tmp14 := lang.Apply(tmp7, []any{tmp8, tmp11, tmp13}) + tmp3 = tmp14 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ns_DASH_interns = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ns_DASH_interns.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ns-publics + { + tmp0 := sym_ns_DASH_publics.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns)), kw_doc, "Returns a map of the public intern mappings for the namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4188), kw_end_DASH_line, int(4188))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "ns" + tmp4 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_filter_DASH_key) + tmp8 := checkDerefVar(var_glojure_DOT_core_val) + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v10 := args[0] + _ = v10 + var tmp11 any + { // let + // let binding "and__0__auto__" + tmp12 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp13 := reflect.TypeOf((*lang.Var)(nil)) + tmp14 := lang.Apply(tmp12, []any{tmp13, v10}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + if lang.IsTruthy(v15) { + var tmp17 any + { // let + // let binding "and__0__auto__" + tmp18 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp19, ok := lang.FieldOrMethod(v10, "Namespace") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v10, "Namespace"))) + } + var tmp20 any + switch reflect.TypeOf(tmp19).Kind() { + case reflect.Func: + tmp20 = lang.Apply(tmp19, nil) + default: + tmp20 = tmp19 + } + tmp21 := lang.Apply(tmp18, []any{v6, tmp20}) + var v22 any = tmp21 + _ = v22 + var tmp23 any + if lang.IsTruthy(v22) { + tmp24, ok := lang.FieldOrMethod(v10, "IsPublic") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v10, "IsPublic"))) + } + var tmp25 any + switch reflect.TypeOf(tmp24).Kind() { + case reflect.Func: + tmp25 = lang.Apply(tmp24, nil) + default: + tmp25 = tmp24 + } + tmp23 = tmp25 + } else { + tmp23 = v22 + } + tmp17 = tmp23 + } // end let + tmp16 = tmp17 + } else { + tmp16 = v15 + } + tmp11 = tmp16 + } // end let + return tmp11 + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4194), kw_column, int(21), kw_end_DASH_line, int(4196), kw_end_DASH_column, int(48)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp12 := checkDerefVar(var_glojure_DOT_core_ns_DASH_map) + tmp13 := lang.Apply(tmp12, []any{v6}) + tmp14 := lang.Apply(tmp7, []any{tmp8, tmp11, tmp13}) + tmp3 = tmp14 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ns_DASH_publics = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ns_DASH_publics.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ns-refers + { + tmp0 := sym_ns_DASH_refers.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns)), kw_doc, "Returns a map of the refer mappings for the namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(4253), kw_end_DASH_line, int(4253))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "ns" + tmp4 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_filter_DASH_key) + tmp8 := checkDerefVar(var_glojure_DOT_core_val) + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v10 := args[0] + _ = v10 + var tmp11 any + { // let + // let binding "and__0__auto__" + tmp12 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp13 := reflect.TypeOf((*lang.Var)(nil)) + tmp14 := lang.Apply(tmp12, []any{tmp13, v10}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + if lang.IsTruthy(v15) { + tmp17 := checkDerefVar(var_glojure_DOT_core_not_EQ_) + tmp18, ok := lang.FieldOrMethod(v10, "Namespace") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v10, "Namespace"))) + } + var tmp19 any + switch reflect.TypeOf(tmp18).Kind() { + case reflect.Func: + tmp19 = lang.Apply(tmp18, nil) + default: + tmp19 = tmp18 + } + tmp20 := lang.Apply(tmp17, []any{v6, tmp19}) + tmp16 = tmp20 + } else { + tmp16 = v15 + } + tmp11 = tmp16 + } // end let + return tmp11 + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4259), kw_column, int(21), kw_end_DASH_line, int(4260), kw_end_DASH_column, int(59)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp12 := checkDerefVar(var_glojure_DOT_core_ns_DASH_map) + tmp13 := lang.Apply(tmp12, []any{v6}) + tmp14 := lang.Apply(tmp7, []any{tmp8, tmp11, tmp13}) + tmp3 = tmp14 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ns_DASH_refers = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ns_DASH_refers.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // nthnext + { + tmp0 := sym_nthnext.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll, sym_n)), kw_doc, "Returns the nth next of coll, (seq coll) when n is 0.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(3147), kw_end_DASH_line, int(3147))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp6 := reflect.TypeOf((*lang.IDrop)(nil)).Elem() + tmp7 := lang.Apply(tmp5, []any{tmp6, v2}) + if lang.IsTruthy(tmp7) { + var tmp8 any + tmp9 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp10 := lang.Apply(tmp9, []any{v3}) + if lang.IsTruthy(tmp10) { + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) + tmp13 := lang.Apply(tmp12, []any{v3}) + if lang.IsTruthy(tmp13) { + tmp11 = v3 + } else { + tmp14 := lang.Apply(nil, []any{v3}) + tmp11 = tmp14 + } + tmp15, _ := lang.FieldOrMethod(v2, "drop") + if reflect.TypeOf(tmp15).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("drop is not a function"))) + } + tmp16 := lang.Apply(tmp15, []any{tmp11}) + tmp8 = tmp16 + } else { + tmp17 := checkDerefVar(var_glojure_DOT_core_seq) + tmp18 := lang.Apply(tmp17, []any{v2}) + tmp8 = tmp18 + } + tmp4 = tmp8 + } else { + var tmp19 any + { // let + // let binding "n" + var v20 any = v3 + _ = v20 + // let binding "xs" + tmp21 := checkDerefVar(var_glojure_DOT_core_seq) + tmp22 := lang.Apply(tmp21, []any{v2}) + var v23 any = tmp22 + _ = v23 + for { + var tmp24 any + var tmp25 any + { // let + // let binding "and__0__auto__" + var v26 any = v23 + _ = v26 + var tmp27 any + if lang.IsTruthy(v26) { + tmp28 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp29 := lang.Apply(tmp28, []any{v20}) + tmp27 = tmp29 + } else { + tmp27 = v26 + } + tmp25 = tmp27 + } // end let + if lang.IsTruthy(tmp25) { + tmp27 := checkDerefVar(var_glojure_DOT_core_dec) + tmp28 := lang.Apply(tmp27, []any{v20}) + var tmp26 any = tmp28 + tmp30 := checkDerefVar(var_glojure_DOT_core_next) + tmp31 := lang.Apply(tmp30, []any{v23}) + var tmp29 any = tmp31 + v20 = tmp26 + v23 = tmp29 + continue + } else { + tmp24 = v23 + } + tmp19 = tmp24 + break + } + } // end let + tmp4 = tmp19 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_nthnext = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_nthnext.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // nthrest + { + tmp0 := sym_nthrest.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll, sym_n)), kw_doc, "Returns the nth rest of coll, coll when n is 0.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(3161), kw_end_DASH_line, int(3161))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + var tmp7 any + { // let + // let binding "or__0__auto__" + var tmp8 any + tmp9 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp10 := reflect.TypeOf((*lang.IDrop)(nil)).Elem() + tmp11 := lang.Apply(tmp9, []any{tmp10, v2}) + if lang.IsTruthy(tmp11) { + var tmp12 any + tmp13 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) + tmp14 := lang.Apply(tmp13, []any{v3}) + if lang.IsTruthy(tmp14) { + tmp12 = v3 + } else { + tmp15 := lang.Apply(nil, []any{v3}) + tmp12 = tmp15 + } + tmp16, _ := lang.FieldOrMethod(v2, "drop") + if reflect.TypeOf(tmp16).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("drop is not a function"))) + } + tmp17 := lang.Apply(tmp16, []any{tmp12}) + tmp8 = tmp17 + } else { + var tmp18 any + { // let + // let binding "n" + var v19 any = v3 + _ = v19 + // let binding "xs" + var v20 any = v2 + _ = v20 + for { + var tmp21 any + { // let + // let binding "temp__0__auto__" + var tmp22 any + { // let + // let binding "and__0__auto__" + tmp23 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp24 := lang.Apply(tmp23, []any{v19}) + var v25 any = tmp24 + _ = v25 + var tmp26 any + if lang.IsTruthy(v25) { + tmp27 := checkDerefVar(var_glojure_DOT_core_seq) + tmp28 := lang.Apply(tmp27, []any{v20}) + tmp26 = tmp28 + } else { + tmp26 = v25 + } + tmp22 = tmp26 + } // end let + var v23 any = tmp22 + _ = v23 + var tmp24 any + if lang.IsTruthy(v23) { + var tmp25 any + { // let + // let binding "xs" + var v26 any = v23 + _ = v26 + tmp28 := checkDerefVar(var_glojure_DOT_core_dec) + tmp29 := lang.Apply(tmp28, []any{v19}) + var tmp27 any = tmp29 + tmp31 := checkDerefVar(var_glojure_DOT_core_rest) + tmp32 := lang.Apply(tmp31, []any{v26}) + var tmp30 any = tmp32 + v19 = tmp27 + v20 = tmp30 + continue + } // end let + tmp24 = tmp25 + } else { + tmp26 := checkDerefVar(var_glojure_DOT_core_seq) + tmp27 := lang.Apply(tmp26, []any{v20}) + tmp24 = tmp27 + } + tmp21 = tmp24 + } // end let + tmp18 = tmp21 + break + } + } // end let + tmp8 = tmp18 + } + var v19 any = tmp8 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + tmp20 = v19 + } else { + tmp20 = lang.NewList() + } + tmp7 = tmp20 + } // end let + tmp4 = tmp7 + } else { + tmp4 = v2 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_nthrest = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_nthrest.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // odd? + { + tmp0 := sym_odd_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_doc, "Returns true if n is odd, throws an exception if n is not an integer", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1389), kw_end_DASH_line, int(1389))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_not) + tmp4 := checkDerefVar(var_glojure_DOT_core_even_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + tmp6 := lang.Apply(tmp3, []any{tmp5}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_odd_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_odd_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // or + { + tmp0 := sym_or.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_x), lang.NewVector(sym_x, sym__AMP_, sym_next)), kw_doc, "Evaluates exprs one at a time, from left to right. If a form\n returns a logical true value, or returns that value and doesn't\n evaluate any of the other expressions, otherwise it returns the\n value of the last expression. (or) returns nil.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(11), kw_line, int(847), kw_end_DASH_line, int(847))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + return nil + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + return v4 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_let}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + tmp12 := checkDerefVar(var_glojure_DOT_core_vector) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_or__0__auto__}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v4}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp19}) + tmp21 := lang.Apply(tmp11, []any{tmp12, tmp20}) + tmp22 := lang.Apply(tmp10, []any{tmp21}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_seq) + tmp25 := checkDerefVar(var_glojure_DOT_core_concat) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{sym_if}) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := lang.Apply(tmp28, []any{sym_or__0__auto__}) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := lang.Apply(tmp30, []any{sym_or__0__auto__}) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := checkDerefVar(var_glojure_DOT_core_seq) + tmp34 := checkDerefVar(var_glojure_DOT_core_concat) + tmp35 := checkDerefVar(var_glojure_DOT_core_list) + tmp36 := lang.Apply(tmp35, []any{sym_glojure_DOT_core_SLASH_or}) + tmp37 := lang.Apply(tmp34, []any{tmp36, v5}) + tmp38 := lang.Apply(tmp33, []any{tmp37}) + tmp39 := lang.Apply(tmp32, []any{tmp38}) + tmp40 := lang.Apply(tmp25, []any{tmp27, tmp29, tmp31, tmp39}) + tmp41 := lang.Apply(tmp24, []any{tmp40}) + tmp42 := lang.Apply(tmp23, []any{tmp41}) + tmp43 := lang.Apply(tmp7, []any{tmp9, tmp22, tmp42}) + tmp44 := lang.Apply(tmp6, []any{tmp43}) + return tmp44 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_or = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_or.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // parents + { + tmp0 := sym_parents.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_tag), lang.NewVector(sym_h, sym_tag)), kw_doc, "Returns the immediate parents of tag, either via a Java type\n inheritance relationship or a relationship established via derive. h\n must be a hierarchy obtained from make-hierarchy, if not supplied\n defaults to the global hierarchy", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(5564), kw_end_DASH_line, int(5564))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_parents) + tmp4 := checkDerefVar(var_glojure_DOT_core_global_DASH_hierarchy) + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_not_DASH_empty) + var tmp5 any + { // let + // let binding "tp" + tmp6 := checkDerefVar(var_glojure_DOT_core_get) + tmp7 := lang.Apply(kw_parents, []any{v2}) + tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + tmp11 := checkDerefVar(var_glojure_DOT_core_class_QMARK_) + tmp12 := lang.Apply(tmp11, []any{v3}) + if lang.IsTruthy(tmp12) { + tmp13 := checkDerefVar(var_glojure_DOT_core_into1) + tmp14 := checkDerefVar(var_glojure_DOT_core_set) + tmp15 := checkDerefVar(var_glojure_DOT_core_bases) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp14, []any{tmp16}) + tmp18 := lang.Apply(tmp13, []any{tmp17, v9}) + tmp10 = tmp18 + } else { + tmp10 = v9 + } + tmp5 = tmp10 + } // end let + tmp6 := lang.Apply(tmp4, []any{tmp5}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_parents = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_parents.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // parse-boolean + { + tmp0 := sym_parse_DASH_boolean.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_doc, "Parse strings \"true\" or \"false\" and return a boolean, or nil if invalid", kw_file, "glojure/core.glj", kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(7957), kw_end_DASH_line, int(7957))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + var tmp6 any + { // let + // let binding "G__691" + var v7 any = v2 + _ = v7 + } // end let + tmp3 = tmp6 + } else { + tmp7 := checkDerefVar(var_glojure_DOT_core_parsing_DASH_err) + tmp8 := lang.Apply(tmp7, []any{v2}) + tmp9 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp8}) + panic(tmp9) + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_parse_DASH_boolean = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_parse_DASH_boolean.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // parse-double + { + tmp0 := sym_parse_DASH_double.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_doc, "Parse string with floating point components and return a Double value,\n or nil if parse fails.\n\n Grammar: https://docs.oracle.com/javase/8/docs/api/java/lang/Double.html#valueOf-java.lang.String-", kw_file, "glojure/core.glj", kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(7935), kw_end_DASH_line, int(7935))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + var tmp6 any + { // let + // let binding "result__3649__auto__" + tmp7 := lang.Apply(strconv9.ParseFloat, []any{v2, int64(64)}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + tmp10 := lang.Apply(v8, []any{int64(1)}) + if lang.IsTruthy(tmp10) { + } else { + tmp11 := lang.Apply(v8, []any{int64(0)}) + tmp9 = tmp11 + } + tmp6 = tmp9 + } // end let + tmp3 = tmp6 + } else { + tmp7 := checkDerefVar(var_glojure_DOT_core_parsing_DASH_err) + tmp8 := lang.Apply(tmp7, []any{v2}) + tmp9 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp8}) + panic(tmp9) + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_parse_DASH_double = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_parse_DASH_double.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // parse-long + { + tmp0 := sym_parse_DASH_long.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_doc, "Parse string of decimal digits with optional leading -/+ and return a\n Long value, or nil if parse fails", kw_file, "glojure/core.glj", kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(7926), kw_end_DASH_line, int(7926))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + var tmp6 any + { // let + // let binding "result__3648__auto__" + tmp7 := lang.Apply(strconv9.ParseInt, []any{v2, int64(10), int64(64)}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + tmp10 := lang.Apply(v8, []any{int64(1)}) + if lang.IsTruthy(tmp10) { + } else { + tmp11 := lang.Apply(v8, []any{int64(0)}) + tmp9 = tmp11 + } + tmp6 = tmp9 + } // end let + tmp3 = tmp6 + } else { + tmp7 := checkDerefVar(var_glojure_DOT_core_parsing_DASH_err) + tmp8 := lang.Apply(tmp7, []any{v2}) + tmp9 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp8}) + panic(tmp9) + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_parse_DASH_long = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_parse_DASH_long.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // partial + { + tmp0 := sym_partial.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_arg1), lang.NewVector(sym_f, sym_arg1, sym_arg2), lang.NewVector(sym_f, sym_arg1, sym_arg2, sym_arg3), lang.NewVector(sym_f, sym_arg1, sym_arg2, sym_arg3, sym__AMP_, sym_more)), kw_doc, "Takes a function f and fewer than the normal arguments to f, and\n returns a fn that takes a variable number of additional args. When\n called, the returned function calls f with args + additional args.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(2606), kw_end_DASH_line, int(2606))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + return v2 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp5 := lang.Apply(v2, []any{v3}) + return tmp5 + case 1: + v5 := args[0] + _ = v5 + tmp6 := lang.Apply(v2, []any{v3, v5}) + return tmp6 + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + tmp7 := lang.Apply(v2, []any{v3, v5, v6}) + return tmp7 + case 3: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := args[2] + _ = v7 + tmp8 := lang.Apply(v2, []any{v3, v5, v6, v7}) + return tmp8 + default: + checkArity(args, 3) + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := args[2] + _ = v7 + var v8 any = lang.NewList(args[3:]...) + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_apply) + tmp10 := lang.Apply(tmp9, []any{v2, v3, v5, v6, v7, v8}) + return tmp10 + } + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2614), kw_column, int(4), kw_end_DASH_line, int(2619), kw_end_DASH_column, int(48)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp6 := lang.Apply(v2, []any{v3, v4}) + return tmp6 + case 1: + v6 := args[0] + _ = v6 + tmp7 := lang.Apply(v2, []any{v3, v4, v6}) + return tmp7 + case 2: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + tmp8 := lang.Apply(v2, []any{v3, v4, v6, v7}) + return tmp8 + case 3: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + tmp9 := lang.Apply(v2, []any{v3, v4, v6, v7, v8}) + return tmp9 + default: + checkArity(args, 3) + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + var v9 any = lang.NewList(args[3:]...) + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_apply) + tmp11 := lang.Apply(tmp10, []any{v2, v3, v4, v6, v7, v8, v9}) + return tmp11 + } + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2621), kw_column, int(4), kw_end_DASH_line, int(2626), kw_end_DASH_column, int(53)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp7 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp7 := lang.Apply(v2, []any{v3, v4, v5}) + return tmp7 + case 1: + v7 := args[0] + _ = v7 + tmp8 := lang.Apply(v2, []any{v3, v4, v5, v7}) + return tmp8 + case 2: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + tmp9 := lang.Apply(v2, []any{v3, v4, v5, v7, v8}) + return tmp9 + case 3: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + tmp10 := lang.Apply(v2, []any{v3, v4, v5, v7, v8, v9}) + return tmp10 + default: + checkArity(args, 3) + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + var v10 any = lang.NewList(args[3:]...) + _ = v10 + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + tmp12 := lang.Apply(tmp11, []any{v2, v3, v4, v5, v7, v8, v9, v10}) + return tmp12 + } + }) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2628), kw_column, int(4), kw_end_DASH_line, int(2633), kw_end_DASH_column, int(58)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp8 + default: + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var v6 any = lang.NewList(args[4:]...) + _ = v6 + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v8 any = lang.NewList(args[0:]...) + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_apply) + tmp10 := checkDerefVar(var_glojure_DOT_core_concat) + tmp11 := lang.Apply(tmp10, []any{v6, v8}) + tmp12 := lang.Apply(tmp9, []any{v2, v3, v4, v5, tmp11}) + return tmp12 + } + }) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2635), kw_column, int(4), kw_end_DASH_line, int(2635), kw_end_DASH_column, int(60)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp9 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_partial = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_partial.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // partition-by + { + tmp0 := sym_partition_DASH_by.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_coll)), kw_doc, "Applies f to each value in coll, splitting it each time f returns a\n new value. Returns a lazy seq of partitions. Returns a stateful\n transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(7142), kw_end_DASH_line, int(7142))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 any + { // let + // let binding "a" + var v6 any = "unimplemented: new with non-constant class type" + _ = v6 + // let binding "pv" + tmp7 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) + tmp8 := lang.Apply(tmp7, []any{kw_glojure_DOT_core_SLASH_none}) + var v9 any = tmp8 + _ = v9 + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp11 := lang.Apply(v4, nil) + return tmp11 + case 1: + v11 := args[0] + _ = v11 + var tmp12 any + { // let + // let binding "result" + var tmp13 any + tmp14, ok := lang.FieldOrMethod(v6, "isEmpty") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "isEmpty"))) + } + var tmp15 any + switch reflect.TypeOf(tmp14).Kind() { + case reflect.Func: + tmp15 = lang.Apply(tmp14, nil) + default: + tmp15 = tmp14 + } + if lang.IsTruthy(tmp15) { + tmp13 = v11 + } else { + var tmp16 any + { // let + // let binding "v" + tmp17 := checkDerefVar(var_glojure_DOT_core_vec) + tmp18, ok := lang.FieldOrMethod(v6, "toArray") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "toArray"))) + } + var tmp19 any + switch reflect.TypeOf(tmp18).Kind() { + case reflect.Func: + tmp19 = lang.Apply(tmp18, nil) + default: + tmp19 = tmp18 + } + tmp20 := lang.Apply(tmp17, []any{tmp19}) + var v21 any = tmp20 + _ = v21 + tmp22, ok := lang.FieldOrMethod(v6, "clear") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "clear"))) + } + var tmp23 any + switch reflect.TypeOf(tmp22).Kind() { + case reflect.Func: + tmp23 = lang.Apply(tmp22, nil) + default: + tmp23 = tmp22 + } + _ = tmp23 + tmp24 := checkDerefVar(var_glojure_DOT_core_unreduced) + tmp25 := lang.Apply(v4, []any{v11, v21}) + tmp26 := lang.Apply(tmp24, []any{tmp25}) + tmp16 = tmp26 + } // end let + tmp13 = tmp16 + } + var v17 any = tmp13 + _ = v17 + tmp18 := lang.Apply(v4, []any{v17}) + tmp12 = tmp18 + } // end let + return tmp12 + case 2: + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + var tmp13 any + { // let + // let binding "pval" + tmp14 := checkDerefVar(var_glojure_DOT_core_deref) + tmp15 := lang.Apply(tmp14, []any{v9}) + var v16 any = tmp15 + _ = v16 + // let binding "val" + tmp17 := lang.Apply(v2, []any{v12}) + var v18 any = tmp17 + _ = v18 + tmp19 := checkDerefVar(var_glojure_DOT_core_vreset_BANG_) + tmp20 := lang.Apply(tmp19, []any{v9, v18}) + _ = tmp20 + var tmp21 any + var tmp22 any + { // let + // let binding "or__0__auto__" + tmp23 := checkDerefVar(var_glojure_DOT_core_identical_QMARK_) + tmp24 := lang.Apply(tmp23, []any{v16, kw_glojure_DOT_core_SLASH_none}) + var v25 any = tmp24 + _ = v25 + var tmp26 any + if lang.IsTruthy(v25) { + tmp26 = v25 + } else { + tmp27 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp28 := lang.Apply(tmp27, []any{v18, v16}) + tmp26 = tmp28 + } + tmp22 = tmp26 + } // end let + if lang.IsTruthy(tmp22) { + tmp23, _ := lang.FieldOrMethod(v6, "add") + if reflect.TypeOf(tmp23).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) + } + tmp24 := lang.Apply(tmp23, []any{v12}) + _ = tmp24 + tmp21 = v11 + } else { + var tmp25 any + { // let + // let binding "v" + tmp26 := checkDerefVar(var_glojure_DOT_core_vec) + tmp27, ok := lang.FieldOrMethod(v6, "toArray") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "toArray"))) + } + var tmp28 any + switch reflect.TypeOf(tmp27).Kind() { + case reflect.Func: + tmp28 = lang.Apply(tmp27, nil) + default: + tmp28 = tmp27 + } + tmp29 := lang.Apply(tmp26, []any{tmp28}) + var v30 any = tmp29 + _ = v30 + tmp31, ok := lang.FieldOrMethod(v6, "clear") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "clear"))) + } + var tmp32 any + switch reflect.TypeOf(tmp31).Kind() { + case reflect.Func: + tmp32 = lang.Apply(tmp31, nil) + default: + tmp32 = tmp31 + } + _ = tmp32 + var tmp33 any + { // let + // let binding "ret" + tmp34 := lang.Apply(v4, []any{v11, v30}) + var v35 any = tmp34 + _ = v35 + var tmp36 any + tmp37 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) + tmp38 := lang.Apply(tmp37, []any{v35}) + if lang.IsTruthy(tmp38) { + } else { + tmp39, _ := lang.FieldOrMethod(v6, "add") + if reflect.TypeOf(tmp39).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) + } + tmp40 := lang.Apply(tmp39, []any{v12}) + tmp36 = tmp40 + } + _ = tmp36 + tmp33 = v35 + } // end let + tmp25 = tmp33 + } // end let + tmp21 = tmp25 + } + tmp13 = tmp21 + } // end let + return tmp13 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7152), kw_column, int(7), kw_end_DASH_line, int(7176), kw_end_DASH_column, int(28)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp5 = tmp12 + } // end let + return tmp5 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7149), kw_column, int(3), kw_end_DASH_line, int(7176), kw_end_DASH_column, int(30)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp5 any + { // let + // let binding "temp__0__auto__" + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := lang.Apply(tmp6, []any{v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + var tmp10 any + { // let + // let binding "s" + var v11 any = v8 + _ = v11 + var tmp12 any + { // let + // let binding "fst" + tmp13 := checkDerefVar(var_glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v11}) + var v15 any = tmp14 + _ = v15 + // let binding "fv" + tmp16 := lang.Apply(v2, []any{v15}) + var v17 any = tmp16 + _ = v17 + // let binding "run" + tmp18 := checkDerefVar(var_glojure_DOT_core_cons) + tmp19 := checkDerefVar(var_glojure_DOT_core_take_DASH_while) + var tmp20 lang.FnFunc + tmp20 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v21 := args[0] + _ = v21 + tmp22 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp23 := lang.Apply(v2, []any{v21}) + tmp24 := lang.Apply(tmp22, []any{v17, tmp23}) + return tmp24 + }) + tmp21 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7182), kw_column, int(41), kw_end_DASH_line, int(7182), kw_end_DASH_column, int(53)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp23 := checkDerefVar(var_glojure_DOT_core_next) + tmp24 := lang.Apply(tmp23, []any{v11}) + tmp25 := lang.Apply(tmp19, []any{tmp22, tmp24}) + tmp26 := lang.Apply(tmp18, []any{v15, tmp25}) + var v27 any = tmp26 + _ = v27 + tmp28 := checkDerefVar(var_glojure_DOT_core_cons) + tmp29 := checkDerefVar(var_glojure_DOT_core_partition_DASH_by) + var tmp30 lang.FnFunc + tmp30 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp31 := checkDerefVar(var_glojure_DOT_core_drop) + tmp32 := checkDerefVar(var_glojure_DOT_core_count) + tmp33 := lang.Apply(tmp32, []any{v27}) + tmp34 := lang.Apply(tmp31, []any{tmp33, v11}) + return tmp34 + }) + tmp31 := lang.Apply(lang.NewLazySeq, []any{tmp30}) + tmp32 := lang.Apply(tmp29, []any{v2, tmp31}) + tmp33 := lang.Apply(tmp28, []any{v27, tmp32}) + tmp12 = tmp33 + } // end let + tmp10 = tmp12 + } // end let + tmp9 = tmp10 + } else { + } + tmp5 = tmp9 + } // end let + return tmp5 + }) + tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_partition_DASH_by = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_partition_DASH_by.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // pmap + { + tmp0 := sym_pmap.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_coll), lang.NewVector(sym_f, sym_coll, sym__AMP_, sym_colls)), kw_doc, "Like map, except f is applied in parallel. Semi-lazy in that the\n parallel computation stays ahead of the consumption, but doesn't\n realize the entire result unless required. Only useful for\n computationally intensive functions where the time of f dominates\n the coordination overhead.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(7031), kw_end_DASH_line, int(7031))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "n" + tmp5 := checkDerefVar(var_glojure_DOT_core__PLUS_) + tmp6 := lang.Apply(runtime11.NumCPU, nil) + tmp7 := lang.Apply(tmp5, []any{int64(2), tmp6}) + var v8 any = tmp7 + _ = v8 + // let binding "rets" + tmp9 := checkDerefVar(var_glojure_DOT_core_map) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v11 := args[0] + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_future_DASH_call) + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp14 := lang.Apply(v2, []any{v11}) + return tmp14 + }) + tmp14 := lang.Apply(tmp12, []any{tmp13}) + return tmp14 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7041), kw_column, int(20), kw_end_DASH_line, int(7041), kw_end_DASH_column, int(34)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := lang.Apply(tmp9, []any{tmp12, v3}) + var v14 any = tmp13 + _ = v14 + // let binding "step" + var tmp15 lang.FnFunc + { // function step + var v16 lang.FnFunc + tmp15 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v17 := args[0] + _ = v17 + v18 := args[1] + _ = v18 + var tmp19 any + { // let + // let binding "vec__661" + var v20 any = v17 + _ = v20 + // let binding "seq__662" + tmp21 := checkDerefVar(var_glojure_DOT_core_seq) + tmp22 := lang.Apply(tmp21, []any{v20}) + var v23 any = tmp22 + _ = v23 + // let binding "first__663" + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v23}) + var v26 any = tmp25 + _ = v26 + // let binding "seq__662" + tmp27 := checkDerefVar(var_glojure_DOT_core_next) + tmp28 := lang.Apply(tmp27, []any{v23}) + var v29 any = tmp28 + _ = v29 + // let binding "x" + var v30 any = v26 + _ = v30 + // let binding "xs" + var v31 any = v29 + _ = v31 + // let binding "vs" + var v32 any = v20 + _ = v32 + var tmp33 lang.FnFunc + tmp33 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp34 any + { // let + // let binding "temp__0__auto__" + tmp35 := checkDerefVar(var_glojure_DOT_core_seq) + tmp36 := lang.Apply(tmp35, []any{v18}) + var v37 any = tmp36 + _ = v37 + var tmp38 any + if lang.IsTruthy(v37) { + var tmp39 any + { // let + // let binding "s" + var v40 any = v37 + _ = v40 + tmp41 := checkDerefVar(var_glojure_DOT_core_cons) + tmp42 := checkDerefVar(var_glojure_DOT_core_deref) + tmp43 := lang.Apply(tmp42, []any{v30}) + tmp44 := checkDerefVar(var_glojure_DOT_core_rest) + tmp45 := lang.Apply(tmp44, []any{v40}) + tmp46 := lang.Apply(v16, []any{v31, tmp45}) + tmp47 := lang.Apply(tmp41, []any{tmp43, tmp46}) + tmp39 = tmp47 + } // end let + tmp38 = tmp39 + } else { + tmp40 := checkDerefVar(var_glojure_DOT_core_map) + tmp41 := checkDerefVar(var_glojure_DOT_core_deref) + tmp42 := lang.Apply(tmp40, []any{tmp41, v32}) + tmp38 = tmp42 + } + tmp34 = tmp38 + } // end let + return tmp34 + }) + tmp34 := lang.Apply(lang.NewLazySeq, []any{tmp33}) + tmp19 = tmp34 + } // end let + return tmp19 + }) + v16 = tmp15 + _ = v16 + } + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7042), kw_column, int(15), kw_end_DASH_line, int(7046), kw_end_DASH_column, int(36)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v18 any = tmp17 + _ = v18 + tmp19 := checkDerefVar(var_glojure_DOT_core_drop) + tmp20 := lang.Apply(tmp19, []any{v8, v14}) + tmp21 := lang.Apply(v18, []any{v14, tmp20}) + tmp4 = tmp21 + } // end let + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "step" + var tmp6 lang.FnFunc + { // function step + var v7 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v8 := args[0] + _ = v8 + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp10 any + { // let + // let binding "ss" + tmp11 := checkDerefVar(var_glojure_DOT_core_map) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := lang.Apply(tmp11, []any{tmp12, v8}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + tmp16 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + tmp17 := checkDerefVar(var_glojure_DOT_core_identity) + tmp18 := lang.Apply(tmp16, []any{tmp17, v14}) + if lang.IsTruthy(tmp18) { + tmp19 := checkDerefVar(var_glojure_DOT_core_cons) + tmp20 := checkDerefVar(var_glojure_DOT_core_map) + tmp21 := checkDerefVar(var_glojure_DOT_core_first) + tmp22 := lang.Apply(tmp20, []any{tmp21, v14}) + tmp23 := checkDerefVar(var_glojure_DOT_core_map) + tmp24 := checkDerefVar(var_glojure_DOT_core_rest) + tmp25 := lang.Apply(tmp23, []any{tmp24, v14}) + tmp26 := lang.Apply(v7, []any{tmp25}) + tmp27 := lang.Apply(tmp19, []any{tmp22, tmp26}) + tmp15 = tmp27 + } else { + } + tmp10 = tmp15 + } // end let + return tmp10 + }) + tmp10 := lang.Apply(lang.NewLazySeq, []any{tmp9}) + return tmp10 + }) + v7 = tmp6 + _ = v7 + } + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7049), kw_column, int(15), kw_end_DASH_line, int(7053), kw_end_DASH_column, int(67)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v9 any = tmp8 + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_pmap) + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v12 := args[0] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_apply) + tmp14 := lang.Apply(tmp13, []any{v2, v12}) + return tmp14 + }) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7054), kw_column, int(12), kw_end_DASH_line, int(7054), kw_end_DASH_column, int(23)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp14 := checkDerefVar(var_glojure_DOT_core_cons) + tmp15 := lang.Apply(tmp14, []any{v3, v4}) + tmp16 := lang.Apply(v9, []any{tmp15}) + tmp17 := lang.Apply(tmp10, []any{tmp13, tmp16}) + tmp5 = tmp17 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_pmap = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_pmap.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // pos-int? + { + tmp0 := sym_pos_DASH_int_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a positive fixed precision integer", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(1403), kw_end_DASH_line, int(1403))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "and__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + tmp8 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp9 := lang.Apply(tmp8, []any{v2}) + tmp7 = tmp9 + } else { + tmp7 = v6 + } + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_pos_DASH_int_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_pos_DASH_int_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // preserving-reduced + { + tmp0 := sym_preserving_DASH_reduced.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(7638), kw_column, int(7), kw_end_DASH_line, int(7638), kw_end_DASH_column, int(34), kw_arglists, lang.NewList(lang.NewVector(sym_rf)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var tmp6 any + { // let + // let binding "ret" + tmp7 := lang.Apply(v2, []any{v4, v5}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) + tmp11 := lang.Apply(tmp10, []any{v8}) + if lang.IsTruthy(tmp11) { + tmp12 := checkDerefVar(var_glojure_DOT_core_reduced) + tmp13 := lang.Apply(tmp12, []any{v8}) + tmp9 = tmp13 + } else { + tmp9 = v8 + } + tmp6 = tmp9 + } // end let + return tmp6 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7640), kw_column, int(3), kw_end_DASH_line, int(7643), kw_end_DASH_column, int(12)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_preserving_DASH_reduced = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_preserving_DASH_reduced.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print-sequential + { + tmp0 := sym_print_DASH_sequential.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(46), kw_column, int(8), kw_end_DASH_line, int(46), kw_end_DASH_column, int(23), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_begin, sym_print_DASH_one, sym_sep, sym_end, sym_sequence, sym_w)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 6) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + v7 := args[5] + _ = v7 + var tmp8 any + { // let + tmp9 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp10 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp11 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_print_DASH_level_STAR_) + var tmp12 any + { // let + // let binding "and__0__auto__" + tmp13 := checkDerefVar(var_glojure_DOT_core_not) + tmp14 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_dup_STAR_) + tmp15 := lang.Apply(tmp13, []any{tmp14}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + if lang.IsTruthy(v16) { + var tmp18 any + { // let + // let binding "and__0__auto__" + tmp19 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_level_STAR_) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + tmp22 := checkDerefVar(var_glojure_DOT_core_dec) + tmp23 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_level_STAR_) + tmp24 := lang.Apply(tmp22, []any{tmp23}) + tmp21 = tmp24 + } else { + tmp21 = v20 + } + tmp18 = tmp21 + } // end let + tmp17 = tmp18 + } else { + tmp17 = v16 + } + tmp12 = tmp17 + } // end let + tmp13 := lang.Apply(tmp10, []any{tmp11, tmp12}) + tmp14 := lang.Apply(tmp9, []any{tmp13}) + _ = tmp14 + var tmp15 any + func() { + defer func() { + tmp16 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp17 := lang.Apply(tmp16, nil) + _ = tmp17 + }() + var tmp18 any + var tmp19 any + { // let + // let binding "and__0__auto__" + tmp20 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_level_STAR_) + var v21 any = tmp20 + _ = v21 + var tmp22 any + if lang.IsTruthy(v21) { + tmp23 := checkDerefVar(var_glojure_DOT_core_neg_QMARK_) + tmp24 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_level_STAR_) + tmp25 := lang.Apply(tmp23, []any{tmp24}) + tmp22 = tmp25 + } else { + tmp22 = v21 + } + tmp19 = tmp22 + } // end let + if lang.IsTruthy(tmp19) { + tmp20 := lang.Apply(lang.WriteWriter, []any{v7, "#"}) + tmp18 = tmp20 + } else { + tmp21 := lang.Apply(lang.WriteWriter, []any{v7, v2}) + _ = tmp21 + var tmp22 any + { // let + // let binding "temp__0__auto__" + tmp23 := checkDerefVar(var_glojure_DOT_core_seq) + tmp24 := lang.Apply(tmp23, []any{v6}) + var v25 any = tmp24 + _ = v25 + var tmp26 any + if lang.IsTruthy(v25) { + var tmp27 any + { // let + // let binding "xs" + var v28 any = v25 + _ = v28 + var tmp29 any + var tmp30 any + { // let + // let binding "and__0__auto__" + tmp31 := checkDerefVar(var_glojure_DOT_core_not) + tmp32 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_dup_STAR_) + tmp33 := lang.Apply(tmp31, []any{tmp32}) + var v34 any = tmp33 + _ = v34 + var tmp35 any + if lang.IsTruthy(v34) { + tmp36 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_length_STAR_) + tmp35 = tmp36 + } else { + tmp35 = v34 + } + tmp30 = tmp35 + } // end let + if lang.IsTruthy(tmp30) { + var tmp31 any + { // let + // let binding "G__885" + var v32 any = v28 + _ = v32 + // let binding "vec__886" + var v33 any = v32 + _ = v33 + // let binding "seq__887" + tmp34 := checkDerefVar(var_glojure_DOT_core_seq) + tmp35 := lang.Apply(tmp34, []any{v33}) + var v36 any = tmp35 + _ = v36 + // let binding "first__888" + tmp37 := checkDerefVar(var_glojure_DOT_core_first) + tmp38 := lang.Apply(tmp37, []any{v36}) + var v39 any = tmp38 + _ = v39 + // let binding "seq__887" + tmp40 := checkDerefVar(var_glojure_DOT_core_next) + tmp41 := lang.Apply(tmp40, []any{v36}) + var v42 any = tmp41 + _ = v42 + // let binding "x" + var v43 any = v39 + _ = v43 + // let binding "xs" + var v44 any = v42 + _ = v44 + // let binding "print-length" + tmp45 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_length_STAR_) + var v46 any = tmp45 + _ = v46 + var tmp47 any + { // let + // let binding "G__885" + var v48 any = v32 + _ = v48 + // let binding "print-length" + var v49 any = v46 + _ = v49 + for { + var tmp50 any + { // let + // let binding "vec__889" + var v51 any = v48 + _ = v51 + // let binding "seq__890" + tmp52 := checkDerefVar(var_glojure_DOT_core_seq) + tmp53 := lang.Apply(tmp52, []any{v51}) + var v54 any = tmp53 + _ = v54 + // let binding "first__891" + tmp55 := checkDerefVar(var_glojure_DOT_core_first) + tmp56 := lang.Apply(tmp55, []any{v54}) + var v57 any = tmp56 + _ = v57 + // let binding "seq__890" + tmp58 := checkDerefVar(var_glojure_DOT_core_next) + tmp59 := lang.Apply(tmp58, []any{v54}) + var v60 any = tmp59 + _ = v60 + // let binding "x" + var v61 any = v57 + _ = v61 + // let binding "xs" + var v62 any = v60 + _ = v62 + // let binding "print-length" + var v63 any = v49 + _ = v63 + var tmp64 any + tmp65 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) + tmp66 := lang.Apply(tmp65, []any{v63}) + if lang.IsTruthy(tmp66) { + tmp67 := lang.Apply(lang.WriteWriter, []any{v7, "..."}) + tmp64 = tmp67 + } else { + tmp68 := lang.Apply(v3, []any{v61, v7}) + _ = tmp68 + var tmp69 any + if lang.IsTruthy(v62) { + tmp70 := lang.Apply(lang.WriteWriter, []any{v7, v4}) + _ = tmp70 + var tmp71 any = v62 + tmp73 := checkDerefVar(var_glojure_DOT_core_dec) + tmp74 := lang.Apply(tmp73, []any{v63}) + var tmp72 any = tmp74 + v48 = tmp71 + v49 = tmp72 + continue + } else { + } + tmp64 = tmp69 + } + tmp50 = tmp64 + } // end let + tmp47 = tmp50 + break + } + } // end let + tmp31 = tmp47 + } // end let + tmp29 = tmp31 + } else { + var tmp32 any + { // let + // let binding "G__895" + var v33 any = v28 + _ = v33 + // let binding "vec__896" + var v34 any = v33 + _ = v34 + // let binding "seq__897" + tmp35 := checkDerefVar(var_glojure_DOT_core_seq) + tmp36 := lang.Apply(tmp35, []any{v34}) + var v37 any = tmp36 + _ = v37 + // let binding "first__898" + tmp38 := checkDerefVar(var_glojure_DOT_core_first) + tmp39 := lang.Apply(tmp38, []any{v37}) + var v40 any = tmp39 + _ = v40 + // let binding "seq__897" + tmp41 := checkDerefVar(var_glojure_DOT_core_next) + tmp42 := lang.Apply(tmp41, []any{v37}) + var v43 any = tmp42 + _ = v43 + // let binding "x" + var v44 any = v40 + _ = v44 + // let binding "xs" + var v45 any = v43 + _ = v45 + var tmp46 any + { // let + // let binding "G__895" + var v47 any = v33 + _ = v47 + for { + var tmp48 any + { // let + // let binding "vec__899" + var v49 any = v47 + _ = v49 + // let binding "seq__900" + tmp50 := checkDerefVar(var_glojure_DOT_core_seq) + tmp51 := lang.Apply(tmp50, []any{v49}) + var v52 any = tmp51 + _ = v52 + // let binding "first__901" + tmp53 := checkDerefVar(var_glojure_DOT_core_first) + tmp54 := lang.Apply(tmp53, []any{v52}) + var v55 any = tmp54 + _ = v55 + // let binding "seq__900" + tmp56 := checkDerefVar(var_glojure_DOT_core_next) + tmp57 := lang.Apply(tmp56, []any{v52}) + var v58 any = tmp57 + _ = v58 + // let binding "x" + var v59 any = v55 + _ = v59 + // let binding "xs" + var v60 any = v58 + _ = v60 + tmp61 := lang.Apply(v3, []any{v59, v7}) + _ = tmp61 + var tmp62 any + if lang.IsTruthy(v60) { + tmp63 := lang.Apply(lang.WriteWriter, []any{v7, v4}) + _ = tmp63 + var tmp64 any = v60 + v47 = tmp64 + continue + } else { + } + tmp48 = tmp62 + } // end let + tmp46 = tmp48 + break + } + } // end let + tmp32 = tmp46 + } // end let + tmp29 = tmp32 + } + tmp27 = tmp29 + } // end let + tmp26 = tmp27 + } else { + } + tmp22 = tmp26 + } // end let + _ = tmp22 + tmp23 := lang.Apply(lang.WriteWriter, []any{v7, v5}) + tmp18 = tmp23 + } + tmp15 = tmp18 + }() + tmp8 = tmp15 + } // end let + return tmp8 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_print_DASH_sequential = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_print_DASH_sequential.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // protocol? + { + tmp0 := sym_protocol_QMARK_.WithMeta(lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(110), kw_column, int(8), kw_end_DASH_line, int(110), kw_end_DASH_column, int(16), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_maybe_DASH_p)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := reflect.TypeOf((*lang.IAtom)(nil)).Elem() + tmp6 := lang.Apply(tmp4, []any{tmp5, v2}) + if lang.IsTruthy(tmp6) { + tmp7 := checkDerefVar(var_glojure_DOT_core_boolean) + tmp8 := checkDerefVar(var_glojure_DOT_core_deref) + tmp9 := lang.Apply(tmp8, []any{v2}) + tmp10 := lang.Apply(kw_on_DASH_interface, []any{tmp9}) + tmp11 := lang.Apply(tmp7, []any{tmp10}) + tmp3 = tmp11 + } else { + tmp3 = false + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_protocol_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_protocol_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // pvalues + { + tmp0 := sym_pvalues.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_exprs)), kw_doc, "Returns a lazy sequence of the values of the exprs, which are\n evaluated in parallel", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(7063), kw_end_DASH_line, int(7063))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym_glojure_DOT_core_SLASH_pcalls}) + tmp9 := checkDerefVar(var_glojure_DOT_core_map) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v11 := args[0] + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.NewVector() + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7069), kw_column, int(30), kw_end_DASH_line, int(7069), kw_end_DASH_column, int(31)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp16 := lang.Apply(tmp12, []any{sym_glojure_DOT_core_SLASH_fn, tmp15, v11}) + return tmp16 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7069), kw_column, int(19), kw_end_DASH_line, int(7069), kw_end_DASH_column, int(34)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := lang.Apply(tmp9, []any{tmp12, v4}) + tmp14 := lang.Apply(tmp6, []any{tmp8, tmp13}) + tmp15 := lang.Apply(tmp5, []any{tmp14}) + return tmp15 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_pvalues = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_pvalues.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // qualified-ident? + { + tmp0 := sym_qualified_DASH_ident_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a symbol or keyword with a namespace", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(22), kw_column, int(7), kw_line, int(1618), kw_end_DASH_line, int(1618))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp4 any + { // let + // let binding "and__0__auto__" + tmp5 := checkDerefVar(var_glojure_DOT_core_ident_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v2}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + if lang.IsTruthy(v7) { + var tmp9 any + { // let + // let binding "and__0__auto__" + tmp10 := checkDerefVar(var_glojure_DOT_core_namespace) + tmp11 := lang.Apply(tmp10, []any{v2}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + tmp13 = true + } else { + tmp13 = v12 + } + tmp9 = tmp13 + } // end let + tmp8 = tmp9 + } else { + tmp8 = v7 + } + tmp4 = tmp8 + } // end let + tmp5 := lang.Apply(tmp3, []any{tmp4}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_qualified_DASH_ident_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_qualified_DASH_ident_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // qualified-keyword? + { + tmp0 := sym_qualified_DASH_keyword_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a keyword with a namespace", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(24), kw_column, int(7), kw_line, int(1638), kw_end_DASH_line, int(1638))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp4 any + { // let + // let binding "and__0__auto__" + tmp5 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v2}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + if lang.IsTruthy(v7) { + var tmp9 any + { // let + // let binding "and__0__auto__" + tmp10 := checkDerefVar(var_glojure_DOT_core_namespace) + tmp11 := lang.Apply(tmp10, []any{v2}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + tmp13 = true + } else { + tmp13 = v12 + } + tmp9 = tmp13 + } // end let + tmp8 = tmp9 + } else { + tmp8 = v7 + } + tmp4 = tmp8 + } // end let + tmp5 := lang.Apply(tmp3, []any{tmp4}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_qualified_DASH_keyword_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_qualified_DASH_keyword_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // qualified-symbol? + { + tmp0 := sym_qualified_DASH_symbol_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a symbol with a namespace", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(7), kw_line, int(1628), kw_end_DASH_line, int(1628))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp4 any + { // let + // let binding "and__0__auto__" + tmp5 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v2}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + if lang.IsTruthy(v7) { + var tmp9 any + { // let + // let binding "and__0__auto__" + tmp10 := checkDerefVar(var_glojure_DOT_core_namespace) + tmp11 := lang.Apply(tmp10, []any{v2}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + tmp13 = true + } else { + tmp13 = v12 + } + tmp9 = tmp13 + } // end let + tmp8 = tmp9 + } else { + tmp8 = v7 + } + tmp4 = tmp8 + } // end let + tmp5 := lang.Apply(tmp3, []any{tmp4}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_qualified_DASH_symbol_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_qualified_DASH_symbol_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // rand + { + tmp0 := sym_rand.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_n)), kw_doc, "Returns a random floating point number between 0 (inclusive) and\n n (default 1) (exclusive).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(4935), kw_end_DASH_line, int(4935))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp2 := lang.Apply(rand13.Float64, nil) + return tmp2 + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core__STAR_) + tmp4 := checkDerefVar(var_glojure_DOT_core_rand) + tmp5 := lang.Apply(tmp4, nil) + tmp6 := lang.Apply(tmp3, []any{v2, tmp5}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_rand = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_rand.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // rand-int + { + tmp0 := sym_rand_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_doc, "Returns a random integer between 0 (inclusive) and n (exclusive).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(4943), kw_end_DASH_line, int(4943))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_int) + tmp4 := checkDerefVar(var_glojure_DOT_core_rand) + tmp5 := lang.Apply(tmp4, []any{v2}) + tmp6 := lang.Apply(tmp3, []any{tmp5}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_rand_DASH_int = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_rand_DASH_int.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // rand-nth + { + tmp0 := sym_rand_DASH_nth.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Return a random element of the (sequential) collection. Will have\n the same performance characteristics as nth for the given\n collection.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(7213), kw_end_DASH_line, int(7213))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_nth) + tmp4 := checkDerefVar(var_glojure_DOT_core_rand_DASH_int) + tmp5 := checkDerefVar(var_glojure_DOT_core_count) + tmp6 := lang.Apply(tmp5, []any{v2}) + tmp7 := lang.Apply(tmp4, []any{tmp6}) + tmp8 := lang.Apply(tmp3, []any{v2, tmp7}) + return tmp8 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_rand_DASH_nth = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_rand_DASH_nth.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // random-sample + { + tmp0 := sym_random_DASH_sample.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_prob), lang.NewVector(sym_prob, sym_coll)), kw_doc, "Returns items from coll with random probability of prob (0.0 -\n 1.0). Returns a transducer when no collection is provided.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(7699), kw_end_DASH_line, int(7699))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_filter) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v5 := args[0] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp7 := checkDerefVar(var_glojure_DOT_core_rand) + tmp8 := lang.Apply(tmp7, nil) + tmp9 := lang.Apply(tmp6, []any{tmp8, v2}) + return tmp9 + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7704), kw_column, int(14), kw_end_DASH_line, int(7704), kw_end_DASH_column, int(37)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp7 := lang.Apply(tmp3, []any{tmp6}) + return tmp7 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_filter) + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v6 := args[0] + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp8 := checkDerefVar(var_glojure_DOT_core_rand) + tmp9 := lang.Apply(tmp8, nil) + tmp10 := lang.Apply(tmp7, []any{tmp9, v2}) + return tmp10 + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7706), kw_column, int(14), kw_end_DASH_line, int(7706), kw_end_DASH_column, int(37)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp8 := lang.Apply(tmp4, []any{tmp7, v3}) + return tmp8 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_random_DASH_sample = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_random_DASH_sample.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // re-groups + { + tmp0 := sym_re_DASH_groups.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m)), kw_doc, "Returns the groups from the most recent match/find. If there are no\n nested groups, returns a string of the entire match. If there are\n nested groups, returns a vector of the groups, the first element\n being the entire match.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(4882), kw_end_DASH_line, int(4882))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "gc" + tmp4, _ := lang.FieldOrMethod(v2, "groupCount") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("groupCount is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) + tmp9 := lang.Apply(tmp8, []any{v6}) + if lang.IsTruthy(tmp9) { + tmp10, _ := lang.FieldOrMethod(v2, "group") + if reflect.TypeOf(tmp10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("group is not a function"))) + } + tmp11 := lang.Apply(tmp10, []any{}) + tmp7 = tmp11 + } else { + var tmp12 any + { // let + // let binding "ret" + tmp13 := lang.NewVector() + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4893), kw_column, int(20), kw_end_DASH_line, int(4893), kw_end_DASH_column, int(21)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v16 any = tmp15 + _ = v16 + // let binding "c" + var v17 any = int64(0) + _ = v17 + for { + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core__LT__EQ_) + tmp20 := lang.Apply(tmp19, []any{v17, v6}) + if lang.IsTruthy(tmp20) { + tmp22 := checkDerefVar(var_glojure_DOT_core_conj) + tmp23, _ := lang.FieldOrMethod(v2, "groupInt") + if reflect.TypeOf(tmp23).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("groupInt is not a function"))) + } + tmp24 := lang.Apply(tmp23, []any{v17}) + tmp25 := lang.Apply(tmp22, []any{v16, tmp24}) + var tmp21 any = tmp25 + tmp27 := checkDerefVar(var_glojure_DOT_core_inc) + tmp28 := lang.Apply(tmp27, []any{v17}) + var tmp26 any = tmp28 + v16 = tmp21 + v17 = tmp26 + continue + } else { + tmp18 = v16 + } + tmp12 = tmp18 + break + } + } // end let + tmp7 = tmp12 + } + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_re_DASH_groups = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_re_DASH_groups.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // re-matches + { + tmp0 := sym_re_DASH_matches.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_re, sym_s)), kw_doc, "Returns the match, if any, of string to pattern, using\n java.util.regex.Matcher.matches(). Uses re-groups to return the\n groups.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4910), kw_end_DASH_line, int(4910))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "m" + tmp5 := checkDerefVar(var_glojure_DOT_core_re_DASH_matcher) + tmp6 := lang.Apply(tmp5, []any{v2, v3}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + tmp9, _ := lang.FieldOrMethod(v7, "matches") + if reflect.TypeOf(tmp9).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("matches is not a function"))) + } + tmp10 := lang.Apply(tmp9, []any{}) + if lang.IsTruthy(tmp10) { + tmp11 := checkDerefVar(var_glojure_DOT_core_re_DASH_groups) + tmp12 := lang.Apply(tmp11, []any{v7}) + tmp8 = tmp12 + } else { + } + tmp4 = tmp8 + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_re_DASH_matches = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_re_DASH_matches.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // re-seq + { + tmp0 := sym_re_DASH_seq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_re, sym_s)), kw_doc, "Returns a lazy sequence of successive matches of pattern in string,\n using java.util.regex.Matcher.find(), each such match processed with\n re-groups.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(4898), kw_end_DASH_line, int(4898))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "m" + tmp5 := checkDerefVar(var_glojure_DOT_core_re_DASH_matcher) + tmp6 := lang.Apply(tmp5, []any{v2, v3}) + var v7 any = tmp6 + _ = v7 + var tmp8 lang.FnFunc + { // function step + var v9 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp10 any + tmp11, _ := lang.FieldOrMethod(v7, "find") + if reflect.TypeOf(tmp11).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("find is not a function"))) + } + tmp12 := lang.Apply(tmp11, []any{}) + if lang.IsTruthy(tmp12) { + tmp13 := checkDerefVar(var_glojure_DOT_core_cons) + tmp14 := checkDerefVar(var_glojure_DOT_core_re_DASH_groups) + tmp15 := lang.Apply(tmp14, []any{v7}) + var tmp16 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp17 := lang.Apply(v9, nil) + return tmp17 + }) + tmp17 := lang.Apply(lang.NewLazySeq, []any{tmp16}) + tmp18 := lang.Apply(tmp13, []any{tmp15, tmp17}) + tmp10 = tmp18 + } else { + } + return tmp10 + }) + v9 = tmp8 + _ = v9 + } + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4906), kw_column, int(6), kw_end_DASH_line, int(4908), kw_end_DASH_column, int(49)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp11 := lang.Apply(tmp10, nil) + tmp4 = tmp11 + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_re_DASH_seq = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_re_DASH_seq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // refer + { + tmp0 := sym_refer.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns_DASH_sym, sym__AMP_, sym_filters)), kw_doc, "refers to all public vars of ns, subject to filters.\n filters can include at most one each of:\n\n :exclude list-of-symbols\n :only list-of-symbols\n :rename map-of-fromsymbol-tosymbol\n\n For each public interned var in the namespace named by the symbol,\n adds a mapping from the name of the var to the var to the current\n namespace. Throws an exception if name is already mapped to\n something else in the current namespace. Filters can be used to\n select a subset, via inclusion or exclusion, or to provide a mapping\n to a symbol different from the var's name, in order to prevent\n clashes. Use :use in the ns macro in preference to calling this directly.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(4216), kw_end_DASH_line, int(4216))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + var tmp4 any + { // let + // let binding "ns" + var tmp5 any + { // let + // let binding "or__0__auto__" + tmp6 := checkDerefVar(var_glojure_DOT_core_find_DASH_ns) + tmp7 := lang.Apply(tmp6, []any{v2}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + tmp9 = v8 + } else { + tmp10 := checkDerefVar(var_glojure_DOT_core_str) + tmp11 := lang.Apply(tmp10, []any{"No namespace: ", v2}) + tmp12 := lang.Apply(errors5.New, []any{tmp11}) + panic(tmp12) + } + tmp5 = tmp9 + } // end let + var v6 any = tmp5 + _ = v6 + // let binding "fs" + tmp7 := checkDerefVar(var_glojure_DOT_core_apply) + tmp8 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp9 := lang.Apply(tmp7, []any{tmp8, v3}) + var v10 any = tmp9 + _ = v10 + // let binding "nspublics" + tmp11 := checkDerefVar(var_glojure_DOT_core_ns_DASH_publics) + tmp12 := lang.Apply(tmp11, []any{v6}) + var v13 any = tmp12 + _ = v13 + // let binding "rename" + var tmp14 any + { // let + // let binding "or__0__auto__" + tmp15 := lang.Apply(kw_rename, []any{v10}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + if lang.IsTruthy(v16) { + tmp17 = v16 + } else { + tmp18 := lang.NewMap() + tmp19 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4236), kw_column, int(35), kw_end_DASH_line, int(4236), kw_end_DASH_column, int(36)) + tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp17 = tmp20 + } + tmp14 = tmp17 + } // end let + var v15 any = tmp14 + _ = v15 + // let binding "exclude" + tmp16 := checkDerefVar(var_glojure_DOT_core_set) + tmp17 := lang.Apply(kw_exclude, []any{v10}) + tmp18 := lang.Apply(tmp16, []any{tmp17}) + var v19 any = tmp18 + _ = v19 + // let binding "to-do" + var tmp20 any + tmp21 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp22 := lang.Apply(kw_refer, []any{v10}) + tmp23 := lang.Apply(tmp21, []any{kw_all, tmp22}) + if lang.IsTruthy(tmp23) { + tmp24 := checkDerefVar(var_glojure_DOT_core_keys) + tmp25 := lang.Apply(tmp24, []any{v13}) + tmp20 = tmp25 + } else { + var tmp26 any + { // let + // let binding "or__0__auto__" + tmp27 := lang.Apply(kw_refer, []any{v10}) + var v28 any = tmp27 + _ = v28 + var tmp29 any + if lang.IsTruthy(v28) { + tmp29 = v28 + } else { + var tmp30 any + { // let + // let binding "or__0__auto__" + tmp31 := lang.Apply(kw_only, []any{v10}) + var v32 any = tmp31 + _ = v32 + var tmp33 any + if lang.IsTruthy(v32) { + tmp33 = v32 + } else { + tmp34 := checkDerefVar(var_glojure_DOT_core_keys) + tmp35 := lang.Apply(tmp34, []any{v13}) + tmp33 = tmp35 + } + tmp30 = tmp33 + } // end let + tmp29 = tmp30 + } + tmp26 = tmp29 + } // end let + tmp20 = tmp26 + } + var v27 any = tmp20 + _ = v27 + var tmp28 any + var tmp29 any + { // let + // let binding "and__0__auto__" + var v30 any = v27 + _ = v30 + var tmp31 any + if lang.IsTruthy(v30) { + tmp32 := checkDerefVar(var_glojure_DOT_core_not) + tmp33 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp34 := reflect.TypeOf((*lang.Sequential)(nil)).Elem() + tmp35 := lang.Apply(tmp33, []any{tmp34, v27}) + tmp36 := lang.Apply(tmp32, []any{tmp35}) + tmp31 = tmp36 + } else { + tmp31 = v30 + } + tmp29 = tmp31 + } // end let + if lang.IsTruthy(tmp29) { + tmp30 := lang.Apply(errors5.New, []any{":only/:refer value must be a sequential collection of symbols"}) + panic(tmp30) + } else { + } + _ = tmp28 + var tmp31 any + { // let + // let binding "seq_700" + tmp32 := checkDerefVar(var_glojure_DOT_core_seq) + tmp33 := lang.Apply(tmp32, []any{v27}) + var v34 any = tmp33 + _ = v34 + // let binding "chunk_701" + var v35 any = nil + _ = v35 + // let binding "count_702" + var v36 any = int64(0) + _ = v36 + // let binding "i_703" + var v37 any = int64(0) + _ = v37 + for { + var tmp38 any + tmp39 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp40 := lang.Apply(tmp39, []any{v37, v36}) + if lang.IsTruthy(tmp40) { + var tmp41 any + { // let + // let binding "sym" + tmp42, _ := lang.FieldOrMethod(v35, "nth") + if reflect.TypeOf(tmp42).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp43 := lang.Apply(tmp42, []any{v37}) + var v44 any = tmp43 + _ = v44 + var tmp45 any + tmp46 := lang.Apply(v19, []any{v44}) + if lang.IsTruthy(tmp46) { + } else { + var tmp47 any + { // let + // let binding "v" + tmp48 := lang.Apply(v13, []any{v44}) + var v49 any = tmp48 + _ = v49 + var tmp50 any + if lang.IsTruthy(v49) { + } else { + panic("unimplemented: new with non-constant class type") + } + _ = tmp50 + tmp51 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + var tmp52 any + { // let + // let binding "or__0__auto__" + tmp53 := lang.Apply(v15, []any{v44}) + var v54 any = tmp53 + _ = v54 + var tmp55 any + if lang.IsTruthy(v54) { + tmp55 = v54 + } else { + tmp55 = v44 + } + tmp52 = tmp55 + } // end let + tmp53, _ := lang.FieldOrMethod(tmp51, "Refer") + if reflect.TypeOf(tmp53).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Refer is not a function"))) + } + tmp54 := lang.Apply(tmp53, []any{tmp52, v49}) + tmp47 = tmp54 + } // end let + tmp45 = tmp47 + } + _ = tmp45 + var tmp48 any = v34 + var tmp49 any = v35 + var tmp50 any = v36 + tmp52 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp53 := lang.Apply(tmp52, []any{v37}) + var tmp51 any = tmp53 + v34 = tmp48 + v35 = tmp49 + v36 = tmp50 + v37 = tmp51 + continue + } // end let + tmp38 = tmp41 + } else { + var tmp42 any + { // let + // let binding "temp__0__auto__" + tmp43 := checkDerefVar(var_glojure_DOT_core_seq) + tmp44 := lang.Apply(tmp43, []any{v34}) + var v45 any = tmp44 + _ = v45 + var tmp46 any + if lang.IsTruthy(v45) { + var tmp47 any + { // let + // let binding "seq_700" + var v48 any = v45 + _ = v48 + var tmp49 any + tmp50 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp51 := lang.Apply(tmp50, []any{v48}) + if lang.IsTruthy(tmp51) { + var tmp52 any + { // let + // let binding "c__0__auto__" + tmp53 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp54 := lang.Apply(tmp53, []any{v48}) + var v55 any = tmp54 + _ = v55 + tmp57 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp58 := lang.Apply(tmp57, []any{v48}) + var tmp56 any = tmp58 + var tmp59 any = v55 + tmp61 := checkDerefVar(var_glojure_DOT_core_int) + tmp62 := checkDerefVar(var_glojure_DOT_core_count) + tmp63 := lang.Apply(tmp62, []any{v55}) + tmp64 := lang.Apply(tmp61, []any{tmp63}) + var tmp60 any = tmp64 + tmp66 := checkDerefVar(var_glojure_DOT_core_int) + tmp67 := lang.Apply(tmp66, []any{int64(0)}) + var tmp65 any = tmp67 + v34 = tmp56 + v35 = tmp59 + v36 = tmp60 + v37 = tmp65 + continue + } // end let + tmp49 = tmp52 + } else { + var tmp53 any + { // let + // let binding "sym" + tmp54 := checkDerefVar(var_glojure_DOT_core_first) + tmp55 := lang.Apply(tmp54, []any{v48}) + var v56 any = tmp55 + _ = v56 + var tmp57 any + tmp58 := lang.Apply(v19, []any{v56}) + if lang.IsTruthy(tmp58) { + } else { + var tmp59 any + { // let + // let binding "v" + tmp60 := lang.Apply(v13, []any{v56}) + var v61 any = tmp60 + _ = v61 + var tmp62 any + if lang.IsTruthy(v61) { + } else { + panic("unimplemented: new with non-constant class type") + } + _ = tmp62 + tmp63 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + var tmp64 any + { // let + // let binding "or__0__auto__" + tmp65 := lang.Apply(v15, []any{v56}) + var v66 any = tmp65 + _ = v66 + var tmp67 any + if lang.IsTruthy(v66) { + tmp67 = v66 + } else { + tmp67 = v56 + } + tmp64 = tmp67 + } // end let + tmp65, _ := lang.FieldOrMethod(tmp63, "Refer") + if reflect.TypeOf(tmp65).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Refer is not a function"))) + } + tmp66 := lang.Apply(tmp65, []any{tmp64, v61}) + tmp59 = tmp66 + } // end let + tmp57 = tmp59 + } + _ = tmp57 + tmp61 := checkDerefVar(var_glojure_DOT_core_next) + tmp62 := lang.Apply(tmp61, []any{v48}) + var tmp60 any = tmp62 + var tmp63 any = nil + var tmp64 any = int64(0) + var tmp65 any = int64(0) + v34 = tmp60 + v35 = tmp63 + v36 = tmp64 + v37 = tmp65 + continue + } // end let + tmp49 = tmp53 + } + tmp47 = tmp49 + } // end let + tmp46 = tmp47 + } else { + } + tmp42 = tmp46 + } // end let + tmp38 = tmp42 + } + tmp31 = tmp38 + break + } + } // end let + tmp4 = tmp31 + } // end let + return tmp4 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_refer = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_refer.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // remove + { + tmp0 := sym_remove.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred), lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns a lazy sequence of the items in coll for which\n (pred item) returns logical false. pred must be free of side-effects.\n Returns a transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(2818), kw_end_DASH_line, int(2818))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_filter) + tmp4 := checkDerefVar(var_glojure_DOT_core_complement) + tmp5 := lang.Apply(tmp4, []any{v2}) + tmp6 := lang.Apply(tmp3, []any{tmp5}) + return tmp6 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_filter) + tmp5 := checkDerefVar(var_glojure_DOT_core_complement) + tmp6 := lang.Apply(tmp5, []any{v2}) + tmp7 := lang.Apply(tmp4, []any{tmp6, v3}) + return tmp7 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_remove = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_remove.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // replace + { + tmp0 := sym_replace.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_smap), lang.NewVector(sym_smap, sym_coll)), kw_doc, "Given a map of replacement pairs and a vector/collection, returns a\n vector/seq with any elements = a key in smap replaced with the\n corresponding val in smap. Returns a transducer when no collection\n is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(5082), kw_end_DASH_line, int(5082))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_map) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v5 := args[0] + _ = v5 + var tmp6 any + { // let + // let binding "temp__0__auto__" + tmp7 := checkDerefVar(var_glojure_DOT_core_find) + tmp8 := lang.Apply(tmp7, []any{v2, v5}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + var tmp11 any + { // let + // let binding "e" + var v12 any = v9 + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_val) + tmp14 := lang.Apply(tmp13, []any{v12}) + tmp11 = tmp14 + } // end let + tmp10 = tmp11 + } else { + tmp10 = v5 + } + tmp6 = tmp10 + } // end let + return tmp6 + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5090), kw_column, int(11), kw_end_DASH_line, int(5090), kw_end_DASH_column, int(47)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp7 := lang.Apply(tmp3, []any{tmp6}) + return tmp7 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp8 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v9 := args[0] + _ = v9 + v10 := args[1] + _ = v10 + var tmp11 any + { // let + // let binding "temp__0__auto__" + tmp12 := checkDerefVar(var_glojure_DOT_core_find) + tmp13 := checkDerefVar(var_glojure_DOT_core_nth) + tmp14 := lang.Apply(tmp13, []any{v9, v10}) + tmp15 := lang.Apply(tmp12, []any{v2, tmp14}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + if lang.IsTruthy(v16) { + var tmp18 any + { // let + // let binding "e" + var v19 any = v16 + _ = v19 + tmp20 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp21 := checkDerefVar(var_glojure_DOT_core_val) + tmp22 := lang.Apply(tmp21, []any{v19}) + tmp23 := lang.Apply(tmp20, []any{v9, v10, tmp22}) + tmp18 = tmp23 + } // end let + tmp17 = tmp18 + } else { + tmp17 = v9 + } + tmp11 = tmp17 + } // end let + return tmp11 + }) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5093), kw_column, int(17), kw_end_DASH_line, int(5096), kw_end_DASH_column, int(23)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp11 := checkDerefVar(var_glojure_DOT_core_range) + tmp12 := checkDerefVar(var_glojure_DOT_core_count) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(tmp11, []any{tmp13}) + tmp15 := lang.Apply(tmp7, []any{tmp10, v3, tmp14}) + tmp4 = tmp15 + } else { + tmp16 := checkDerefVar(var_glojure_DOT_core_map) + var tmp17 lang.FnFunc + tmp17 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v18 := args[0] + _ = v18 + var tmp19 any + { // let + // let binding "temp__0__auto__" + tmp20 := checkDerefVar(var_glojure_DOT_core_find) + tmp21 := lang.Apply(tmp20, []any{v2, v18}) + var v22 any = tmp21 + _ = v22 + var tmp23 any + if lang.IsTruthy(v22) { + var tmp24 any + { // let + // let binding "e" + var v25 any = v22 + _ = v25 + tmp26 := checkDerefVar(var_glojure_DOT_core_val) + tmp27 := lang.Apply(tmp26, []any{v25}) + tmp24 = tmp27 + } // end let + tmp23 = tmp24 + } else { + tmp23 = v18 + } + tmp19 = tmp23 + } // end let + return tmp19 + }) + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5098), kw_column, int(13), kw_end_DASH_line, int(5098), kw_end_DASH_column, int(49)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp20 := lang.Apply(tmp16, []any{tmp19, v3}) + tmp4 = tmp20 + } + return tmp4 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_replace = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_replace.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // restart-agent + { + tmp0 := sym_restart_DASH_agent.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a, sym_new_DASH_state, sym__AMP_, sym_options)), kw_doc, "When an agent is failed, changes the agent state to new-state and\n then un-fails the agent so that sends are allowed again. If\n a :clear-actions true option is given, any actions queued on the\n agent that were being held while it was failed will be discarded,\n otherwise those held actions will proceed. The new-state must pass\n the validator if any, or restart will throw an exception and the\n agent will remain failed with its old state and error. Watchers, if\n any, will NOT be notified of the new state. Throws an exception if\n the agent is not failed.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(2175), kw_end_DASH_line, int(2175))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "opts" + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp8 := lang.Apply(tmp6, []any{tmp7, v4}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + tmp11 := lang.Apply(kw_clear_DASH_actions, []any{v9}) + if lang.IsTruthy(tmp11) { + tmp10 = true + } else { + tmp10 = false + } + tmp12, _ := lang.FieldOrMethod(v2, "restart") + if reflect.TypeOf(tmp12).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("restart is not a function"))) + } + tmp13 := lang.Apply(tmp12, []any{v3, tmp10}) + tmp5 = tmp13 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_restart_DASH_agent = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_restart_DASH_agent.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // root-directory + { + tmp0 := sym_root_DASH_directory.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_lib)), kw_doc, "Returns the root resource path for a lib", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(8), kw_line, int(5871), kw_end_DASH_line, int(5871), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "d" + tmp4 := checkDerefVar(var_glojure_DOT_core_root_DASH_resource) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_subs) + tmp8 := lang.Apply(strings8.LastIndex, []any{v6, "/"}) + tmp9 := lang.Apply(tmp7, []any{v6, int64(0), tmp8}) + tmp3 = tmp9 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_root_DASH_directory = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_root_DASH_directory.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // rsubseq + { + tmp0 := sym_rsubseq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_sc, sym_test, sym_key), lang.NewVector(sym_sc, sym_start_DASH_test, sym_start_DASH_key, sym_end_DASH_test, sym_end_DASH_key)), kw_doc, "sc must be a sorted collection, test(s) one of <, <=, > or\n >=. Returns a reverse seq of those entries with keys ek for\n which (test (.. sc comparator (compare ek key)) 0) is true", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(5150), kw_end_DASH_line, int(5150))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + { // let + // let binding "include" + tmp6 := checkDerefVar(var_glojure_DOT_core_mk_DASH_bound_DASH_fn) + tmp7 := lang.Apply(tmp6, []any{v2, v3, v4}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp11 := checkDerefVar(var_glojure_DOT_core__LT__EQ_) + tmp12 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{tmp10, tmp11})) + tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5158), kw_column, int(11), kw_end_DASH_line, int(5158), kw_end_DASH_column, int(17)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp15 := lang.Apply(tmp14, []any{v3}) + if lang.IsTruthy(tmp15) { + var tmp16 any + { // let + // let binding "temp__0__auto__" + tmp17, _ := lang.FieldOrMethod(v2, "seqFrom") + if reflect.TypeOf(tmp17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("seqFrom is not a function"))) + } + tmp18 := lang.Apply(tmp17, []any{v4, false}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + var tmp21 any + { // let + // let binding "vec__765" + var v22 any = v19 + _ = v22 + // let binding "e" + tmp23 := checkDerefVar(var_glojure_DOT_core_nth) + tmp24 := lang.Apply(tmp23, []any{v22, int64(0), nil}) + var v25 any = tmp24 + _ = v25 + // let binding "s" + var v26 any = v22 + _ = v26 + var tmp27 any + tmp28 := lang.Apply(v8, []any{v25}) + if lang.IsTruthy(tmp28) { + tmp27 = v26 + } else { + tmp29 := checkDerefVar(var_glojure_DOT_core_next) + tmp30 := lang.Apply(tmp29, []any{v26}) + tmp27 = tmp30 + } + tmp21 = tmp27 + } // end let + tmp20 = tmp21 + } else { + } + tmp16 = tmp20 + } // end let + tmp9 = tmp16 + } else { + tmp17 := checkDerefVar(var_glojure_DOT_core_take_DASH_while) + tmp18, _ := lang.FieldOrMethod(v2, "seq") + if reflect.TypeOf(tmp18).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("seq is not a function"))) + } + tmp19 := lang.Apply(tmp18, []any{false}) + tmp20 := lang.Apply(tmp17, []any{v8, tmp19}) + tmp9 = tmp20 + } + tmp5 = tmp9 + } // end let + return tmp5 + case 5: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + var tmp7 any + { // let + // let binding "temp__0__auto__" + tmp8, _ := lang.FieldOrMethod(v2, "seqFrom") + if reflect.TypeOf(tmp8).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("seqFrom is not a function"))) + } + tmp9 := lang.Apply(tmp8, []any{v6, false}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + if lang.IsTruthy(v10) { + var tmp12 any + { // let + // let binding "vec__768" + var v13 any = v10 + _ = v13 + // let binding "e" + tmp14 := checkDerefVar(var_glojure_DOT_core_nth) + tmp15 := lang.Apply(tmp14, []any{v13, int64(0), nil}) + var v16 any = tmp15 + _ = v16 + // let binding "s" + var v17 any = v13 + _ = v17 + tmp18 := checkDerefVar(var_glojure_DOT_core_take_DASH_while) + tmp19 := checkDerefVar(var_glojure_DOT_core_mk_DASH_bound_DASH_fn) + tmp20 := lang.Apply(tmp19, []any{v2, v3, v4}) + var tmp21 any + tmp22 := checkDerefVar(var_glojure_DOT_core_mk_DASH_bound_DASH_fn) + tmp23 := lang.Apply(tmp22, []any{v2, v5, v6}) + tmp24 := lang.Apply(tmp23, []any{v16}) + if lang.IsTruthy(tmp24) { + tmp21 = v17 + } else { + tmp25 := checkDerefVar(var_glojure_DOT_core_next) + tmp26 := lang.Apply(tmp25, []any{v17}) + tmp21 = tmp26 + } + tmp27 := lang.Apply(tmp18, []any{tmp20, tmp21}) + tmp12 = tmp27 + } // end let + tmp11 = tmp12 + } else { + } + tmp7 = tmp11 + } // end let + return tmp7 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_rsubseq = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_rsubseq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // send-via + { + tmp0 := sym_send_DASH_via.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_executor, sym_a, sym_f, sym__AMP_, sym_args)), kw_doc, "Dispatch an action to an agent. Returns the agent immediately.\n Subsequently, in a thread supplied by executor, the state of the agent\n will be set to the value of:\n\n (apply action-fn state-of-agent args)", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(2099), kw_end_DASH_line, int(2099))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + tmp7 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp8 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp9 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_agent_STAR_) + tmp10 := lang.Apply(tmp8, []any{tmp9, v3}) + tmp11 := lang.Apply(tmp7, []any{tmp10}) + _ = tmp11 + var tmp12 any + func() { + defer func() { + tmp13 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp14 := lang.Apply(tmp13, nil) + _ = tmp14 + }() + tmp15 := checkDerefVar(var_glojure_DOT_core_binding_DASH_conveyor_DASH_fn) + tmp16 := lang.Apply(tmp15, []any{v4}) + tmp12 = tmp16 + }() + tmp6 = tmp12 + } // end let + tmp7, _ := lang.FieldOrMethod(v3, "dispatch") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("dispatch is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{tmp6, v5, v2}) + return tmp8 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_send_DASH_via = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_send_DASH_via.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // sequence + { + tmp0 := sym_sequence.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll), lang.NewVector(sym_xform, sym_coll), lang.NewVector(sym_xform, sym_coll, sym__AMP_, sym_colls)), kw_doc, "Coerces coll to a (possibly empty) sequence, if it is not already\n one. Will not force a lazy seq. (sequence nil) yields (), When a\n transducer is supplied, returns a lazy sequence of applications of\n the transform to the items in coll(s), i.e. to the set of first\n items of each coll, followed by the set of second\n items in each coll, until any one of the colls is exhausted. Any\n remaining items in other colls are ignored. The transform should accept\n number-of-colls arguments", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(2639), kw_end_DASH_line, int(2639))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + tmp3 = v2 + } else { + var tmp6 any + { // let + // let binding "or__0__auto__" + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := lang.Apply(tmp7, []any{v2}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + tmp10 = v9 + } else { + tmp10 = lang.NewList() + } + tmp6 = tmp10 + } // end let + tmp3 = tmp6 + } + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "or__0__auto__" + tmp5 := lang.Apply(nil, []any{v3}) + tmp6 := lang.Apply(nil, []any{v2, tmp5}) + tmp7 := lang.Apply(nil, []any{tmp6}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + tmp9 = v8 + } else { + tmp9 = lang.NewList() + } + tmp4 = tmp9 + } // end let + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "or__0__auto__" + tmp6 := checkDerefVar(var_glojure_DOT_core_map) + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v8 := args[0] + _ = v8 + tmp9 := lang.Apply(nil, []any{v8}) + return tmp9 + }) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2661), kw_column, int(17), kw_end_DASH_line, int(2661), kw_end_DASH_column, int(41)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp10 := checkDerefVar(var_glojure_DOT_core_cons) + tmp11 := lang.Apply(tmp10, []any{v3, v4}) + tmp12 := lang.Apply(tmp6, []any{tmp9, tmp11}) + tmp13 := lang.Apply(nil, []any{v2, tmp12}) + tmp14 := lang.Apply(nil, []any{tmp13}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + if lang.IsTruthy(v15) { + tmp16 = v15 + } else { + tmp16 = lang.NewList() + } + tmp5 = tmp16 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_sequence = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_sequence.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // setup-reference + { + tmp0 := sym_setup_DASH_reference.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(2043), kw_column, int(7), kw_end_DASH_line, int(2044), kw_end_DASH_column, int(17), kw_arglists, lang.NewList(lang.NewVector(sym_r, sym_options)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "opts" + tmp5 := checkDerefVar(var_glojure_DOT_core_apply) + tmp6 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp7 := lang.Apply(tmp5, []any{tmp6, v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + tmp10 := lang.Apply(kw_meta, []any{v8}) + if lang.IsTruthy(tmp10) { + tmp11 := lang.Apply(kw_meta, []any{v8}) + tmp12, _ := lang.FieldOrMethod(v2, "ResetMeta") + if reflect.TypeOf(tmp12).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ResetMeta is not a function"))) + } + tmp13 := lang.Apply(tmp12, []any{tmp11}) + tmp9 = tmp13 + } else { + } + _ = tmp9 + var tmp14 any + tmp15 := lang.Apply(kw_validator, []any{v8}) + if lang.IsTruthy(tmp15) { + tmp16 := lang.Apply(kw_validator, []any{v8}) + tmp17, _ := lang.FieldOrMethod(v2, "setValidator") + if reflect.TypeOf(tmp17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setValidator is not a function"))) + } + tmp18 := lang.Apply(tmp17, []any{tmp16}) + tmp14 = tmp18 + } else { + } + _ = tmp14 + tmp4 = v2 + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_setup_DASH_reference = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_setup_DASH_reference.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // shift-mask + { + tmp0 := sym_shift_DASH_mask.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6598), kw_column, int(8), kw_end_DASH_line, int(6598), kw_end_DASH_column, int(17), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_shift, sym_mask, sym_x)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_bit_DASH_and) + tmp6 := checkDerefVar(var_glojure_DOT_core_bit_DASH_shift_DASH_right) + tmp7 := lang.Apply(tmp6, []any{v4, v2}) + tmp8 := lang.Apply(tmp5, []any{tmp7, v3}) + return tmp8 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_shift_DASH_mask = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_shift_DASH_mask.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // sort + { + tmp0 := sym_sort.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll), lang.NewVector(sym_comp, sym_coll)), kw_doc, "Returns a sorted sequence of the items in coll. If no comparator is\n supplied, uses compare. comparator must implement\n java.util.Comparator. Guaranteed to be stable: equal elements will\n not be reordered. If coll is a Java array, it will be modified. To\n avoid this, sort a copy of the array.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3085), kw_end_DASH_line, int(3085))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_sort) + tmp4 := checkDerefVar(var_glojure_DOT_core_compare) + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + var tmp7 any + { // let + // let binding "a" + tmp8 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) + tmp9 := lang.Apply(tmp8, []any{v3}) + var v10 any = tmp9 + _ = v10 + tmp11 := lang.Apply(lang.SortSlice, []any{v10, v2}) + _ = tmp11 + tmp12 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := lang.Apply(tmp13, []any{v10}) + tmp15 := checkDerefVar(var_glojure_DOT_core_meta) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp7 = tmp17 + } // end let + tmp4 = tmp7 + } else { + tmp4 = lang.NewList() + } + return tmp4 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_sort = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_sort.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // sort-by + { + tmp0 := sym_sort_DASH_by.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_keyfn, sym_coll), lang.NewVector(sym_keyfn, sym_comp, sym_coll)), kw_doc, "Returns a sorted sequence of the items in coll, where the sort\n order is determined by comparing (keyfn item). If no comparator is\n supplied, uses compare. comparator must implement\n java.util.Comparator. Guaranteed to be stable: equal elements will\n not be reordered. If coll is a Java array, it will be modified. To\n avoid this, sort a copy of the array.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(3102), kw_end_DASH_line, int(3102))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_sort_DASH_by) + tmp5 := checkDerefVar(var_glojure_DOT_core_compare) + tmp6 := lang.Apply(tmp4, []any{v2, tmp5, v3}) + return tmp6 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_sort) + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + tmp9 := lang.Apply(v2, []any{v7}) + tmp10 := lang.Apply(v2, []any{v8}) + tmp11 := lang.Apply(v3, []any{tmp9, tmp10}) + return tmp11 + }) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3114), kw_column, int(10), kw_end_DASH_line, int(3114), kw_end_DASH_column, int(46)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp9 := lang.Apply(tmp5, []any{tmp8, v4}) + return tmp9 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_sort_DASH_by = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_sort_DASH_by.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // spit + { + tmp0 := sym_spit.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_content, sym__AMP_, sym_options)), kw_doc, "Opposite of slurp. Opens f with writer, writes content, then\n closes f. Options passed to glojure.java.io/writer.", kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(6994), kw_end_DASH_line, int(6994))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "w" + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := lang.Apply(tmp6, []any{nil, v2, v4}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + func() { + defer func() { + tmp10, ok := lang.FieldOrMethod(v8, "close") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "close"))) + } + var tmp11 any + switch reflect.TypeOf(tmp10).Kind() { + case reflect.Func: + tmp11 = lang.Apply(tmp10, nil) + default: + tmp11 = tmp10 + } + _ = tmp11 + }() + tmp12 := checkDerefVar(var_glojure_DOT_core_str) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(lang.WriteWriter, []any{v8, tmp13}) + tmp9 = tmp14 + }() + tmp5 = tmp9 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_spit = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_spit.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // strip-ns + { + tmp0 := sym_strip_DASH_ns.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(255), kw_column, int(8), kw_end_DASH_line, int(255), kw_end_DASH_column, int(15), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_named)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + tmp6 := checkDerefVar(var_glojure_DOT_core_symbol) + tmp7 := checkDerefVar(var_glojure_DOT_core_name) + tmp8 := lang.Apply(tmp7, []any{v2}) + tmp9 := lang.Apply(tmp6, []any{nil, tmp8}) + tmp3 = tmp9 + } else { + tmp10 := checkDerefVar(var_glojure_DOT_core_keyword) + tmp11 := checkDerefVar(var_glojure_DOT_core_name) + tmp12 := lang.Apply(tmp11, []any{v2}) + tmp13 := lang.Apply(tmp10, []any{nil, tmp12}) + tmp3 = tmp13 + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_strip_DASH_ns = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_strip_DASH_ns.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // subseq + { + tmp0 := sym_subseq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_sc, sym_test, sym_key), lang.NewVector(sym_sc, sym_start_DASH_test, sym_start_DASH_key, sym_end_DASH_test, sym_end_DASH_key)), kw_doc, "sc must be a sorted collection, test(s) one of <, <=, > or\n >=. Returns a seq of those entries with keys ek for\n which (test (.. sc comparator (compare ek key)) 0) is true", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(5133), kw_end_DASH_line, int(5133))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + { // let + // let binding "include" + tmp6 := checkDerefVar(var_glojure_DOT_core_mk_DASH_bound_DASH_fn) + tmp7 := lang.Apply(tmp6, []any{v2, v3, v4}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core__GT_) + tmp11 := checkDerefVar(var_glojure_DOT_core__GT__EQ_) + tmp12 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{tmp10, tmp11})) + tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5141), kw_column, int(11), kw_end_DASH_line, int(5141), kw_end_DASH_column, int(17)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp15 := lang.Apply(tmp14, []any{v3}) + if lang.IsTruthy(tmp15) { + var tmp16 any + { // let + // let binding "temp__0__auto__" + tmp17, _ := lang.FieldOrMethod(v2, "seqFrom") + if reflect.TypeOf(tmp17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("seqFrom is not a function"))) + } + tmp18 := lang.Apply(tmp17, []any{v4, true}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + var tmp21 any + { // let + // let binding "vec__759" + var v22 any = v19 + _ = v22 + // let binding "e" + tmp23 := checkDerefVar(var_glojure_DOT_core_nth) + tmp24 := lang.Apply(tmp23, []any{v22, int64(0), nil}) + var v25 any = tmp24 + _ = v25 + // let binding "s" + var v26 any = v22 + _ = v26 + var tmp27 any + tmp28 := lang.Apply(v8, []any{v25}) + if lang.IsTruthy(tmp28) { + tmp27 = v26 + } else { + tmp29 := checkDerefVar(var_glojure_DOT_core_next) + tmp30 := lang.Apply(tmp29, []any{v26}) + tmp27 = tmp30 + } + tmp21 = tmp27 + } // end let + tmp20 = tmp21 + } else { + } + tmp16 = tmp20 + } // end let + tmp9 = tmp16 + } else { + tmp17 := checkDerefVar(var_glojure_DOT_core_take_DASH_while) + tmp18, _ := lang.FieldOrMethod(v2, "seq") + if reflect.TypeOf(tmp18).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("seq is not a function"))) + } + tmp19 := lang.Apply(tmp18, []any{true}) + tmp20 := lang.Apply(tmp17, []any{v8, tmp19}) + tmp9 = tmp20 + } + tmp5 = tmp9 + } // end let + return tmp5 + case 5: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + var tmp7 any + { // let + // let binding "temp__0__auto__" + tmp8, _ := lang.FieldOrMethod(v2, "seqFrom") + if reflect.TypeOf(tmp8).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("seqFrom is not a function"))) + } + tmp9 := lang.Apply(tmp8, []any{v4, true}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + if lang.IsTruthy(v10) { + var tmp12 any + { // let + // let binding "vec__762" + var v13 any = v10 + _ = v13 + // let binding "e" + tmp14 := checkDerefVar(var_glojure_DOT_core_nth) + tmp15 := lang.Apply(tmp14, []any{v13, int64(0), nil}) + var v16 any = tmp15 + _ = v16 + // let binding "s" + var v17 any = v13 + _ = v17 + tmp18 := checkDerefVar(var_glojure_DOT_core_take_DASH_while) + tmp19 := checkDerefVar(var_glojure_DOT_core_mk_DASH_bound_DASH_fn) + tmp20 := lang.Apply(tmp19, []any{v2, v5, v6}) + var tmp21 any + tmp22 := checkDerefVar(var_glojure_DOT_core_mk_DASH_bound_DASH_fn) + tmp23 := lang.Apply(tmp22, []any{v2, v3, v4}) + tmp24 := lang.Apply(tmp23, []any{v16}) + if lang.IsTruthy(tmp24) { + tmp21 = v17 + } else { + tmp25 := checkDerefVar(var_glojure_DOT_core_next) + tmp26 := lang.Apply(tmp25, []any{v17}) + tmp21 = tmp26 + } + tmp27 := lang.Apply(tmp18, []any{tmp20, tmp21}) + tmp12 = tmp27 + } // end let + tmp11 = tmp12 + } else { + } + tmp7 = tmp11 + } // end let + return tmp7 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_subseq = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_subseq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // supers + { + tmp0 := sym_supers.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_class)), kw_doc, "Returns the immediate and indirect superclasses and interfaces of c, if any", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(5532), kw_end_DASH_line, int(5532))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "ret" + tmp4 := checkDerefVar(var_glojure_DOT_core_set) + tmp5 := checkDerefVar(var_glojure_DOT_core_bases) + tmp6 := lang.Apply(tmp5, []any{v2}) + tmp7 := lang.Apply(tmp4, []any{tmp6}) + var v8 any = tmp7 + _ = v8 + // let binding "cs" + var v9 any = v8 + _ = v9 + for { + var tmp10 any + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := lang.Apply(tmp11, []any{v9}) + if lang.IsTruthy(tmp12) { + var tmp13 any + { // let + // let binding "c" + tmp14 := checkDerefVar(var_glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v9}) + var v16 any = tmp15 + _ = v16 + // let binding "bs" + tmp17 := checkDerefVar(var_glojure_DOT_core_bases) + tmp18 := lang.Apply(tmp17, []any{v16}) + var v19 any = tmp18 + _ = v19 + tmp21 := checkDerefVar(var_glojure_DOT_core_into1) + tmp22 := lang.Apply(tmp21, []any{v8, v19}) + var tmp20 any = tmp22 + tmp24 := checkDerefVar(var_glojure_DOT_core_into1) + tmp25 := checkDerefVar(var_glojure_DOT_core_disj) + tmp26 := lang.Apply(tmp25, []any{v9, v16}) + tmp27 := lang.Apply(tmp24, []any{tmp26, v19}) + var tmp23 any = tmp27 + v8 = tmp20 + v9 = tmp23 + continue + } // end let + tmp10 = tmp13 + } else { + tmp14 := checkDerefVar(var_glojure_DOT_core_not_DASH_empty) + tmp15 := lang.Apply(tmp14, []any{v8}) + tmp10 = tmp15 + } + tmp3 = tmp10 + break + } + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_supers = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_supers.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // sync + { + tmp0 := sym_sync.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_flags_DASH_ignored_DASH_for_DASH_now, sym__AMP_, sym_body)), kw_doc, "transaction-flags => TBD, pass nil for now\n\n Runs the exprs (in an implicit do) in a transaction that encompasses\n exprs and any nested calls. Starts a transaction if none is already\n running on this thread. Any uncaught exception will abort the\n transaction and flow out of sync. The exprs may be run more than\n once, but any effects on Refs will be atomic.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(11), kw_line, int(2490), kw_end_DASH_line, int(2490))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym__DOT_}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_LockingTransaction}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_RunInTransaction}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{sym_glojure_DOT_core_SLASH_fn}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := checkDerefVar(var_glojure_DOT_core_apply) + tmp24 := checkDerefVar(var_glojure_DOT_core_vector) + tmp25 := checkDerefVar(var_glojure_DOT_core_seq) + tmp26 := checkDerefVar(var_glojure_DOT_core_concat) + tmp27 := lang.Apply(tmp26, nil) + tmp28 := lang.Apply(tmp25, []any{tmp27}) + tmp29 := lang.Apply(tmp23, []any{tmp24, tmp28}) + tmp30 := lang.Apply(tmp22, []any{tmp29}) + tmp31 := lang.Apply(tmp19, []any{tmp21, tmp30, v5}) + tmp32 := lang.Apply(tmp18, []any{tmp31}) + tmp33 := lang.Apply(tmp17, []any{tmp32}) + tmp34 := lang.Apply(tmp14, []any{tmp16, tmp33}) + tmp35 := lang.Apply(tmp13, []any{tmp34}) + tmp36 := lang.Apply(tmp12, []any{tmp35}) + tmp37 := lang.Apply(tmp7, []any{tmp9, tmp11, tmp36}) + tmp38 := lang.Apply(tmp6, []any{tmp37}) + return tmp38 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_sync = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_sync.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // take + { + tmp0 := sym_take.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n), lang.NewVector(sym_n, sym_coll)), kw_doc, "Returns a lazy sequence of the first n items in coll, or all items if\n there are fewer than n. Returns a stateful transducer when\n no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(2853), kw_end_DASH_line, int(2853))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 any + { // let + // let binding "nv" + tmp6 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) + tmp7 := lang.Apply(tmp6, []any{v2}) + var v8 any = tmp7 + _ = v8 + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp10 := lang.Apply(v4, nil) + return tmp10 + case 1: + v10 := args[0] + _ = v10 + tmp11 := lang.Apply(v4, []any{v10}) + return tmp11 + case 2: + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + var tmp12 any + { // let + // let binding "n" + tmp13 := checkDerefVar(var_glojure_DOT_core_deref) + tmp14 := lang.Apply(tmp13, []any{v8}) + var v15 any = tmp14 + _ = v15 + // let binding "nn" + tmp16 := checkDerefVar(var_glojure_DOT_core_dec) + tmp17, ok := lang.FieldOrMethod(v8, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "Deref"))) + } + var tmp18 any + switch reflect.TypeOf(tmp17).Kind() { + case reflect.Func: + tmp18 = lang.Apply(tmp17, nil) + default: + tmp18 = tmp17 + } + tmp19 := lang.Apply(tmp16, []any{tmp18}) + tmp20, _ := lang.FieldOrMethod(v8, "reset") + if reflect.TypeOf(tmp20).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) + } + tmp21 := lang.Apply(tmp20, []any{tmp19}) + var v22 any = tmp21 + _ = v22 + // let binding "result" + var tmp23 any + tmp24 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp25 := lang.Apply(tmp24, []any{v15}) + if lang.IsTruthy(tmp25) { + tmp26 := lang.Apply(v4, []any{v10, v11}) + tmp23 = tmp26 + } else { + tmp23 = v10 + } + var v27 any = tmp23 + _ = v27 + var tmp28 any + tmp29 := checkDerefVar(var_glojure_DOT_core_not) + tmp30 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp31 := lang.Apply(tmp30, []any{v22}) + tmp32 := lang.Apply(tmp29, []any{tmp31}) + if lang.IsTruthy(tmp32) { + tmp33 := checkDerefVar(var_glojure_DOT_core_ensure_DASH_reduced) + tmp34 := lang.Apply(tmp33, []any{v27}) + tmp28 = tmp34 + } else { + tmp28 = v27 + } + tmp12 = tmp28 + } // end let + return tmp12 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2862), kw_column, int(10), kw_end_DASH_line, int(2873), kw_end_DASH_column, int(28)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp5 = tmp11 + } // end let + return tmp5 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2860), kw_column, int(6), kw_end_DASH_line, int(2873), kw_end_DASH_column, int(30)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp7 := lang.Apply(tmp6, []any{v2}) + if lang.IsTruthy(tmp7) { + var tmp8 any + { // let + // let binding "temp__0__auto__" + tmp9 := checkDerefVar(var_glojure_DOT_core_seq) + tmp10 := lang.Apply(tmp9, []any{v3}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + var tmp13 any + { // let + // let binding "s" + var v14 any = v11 + _ = v14 + tmp15 := checkDerefVar(var_glojure_DOT_core_cons) + tmp16 := checkDerefVar(var_glojure_DOT_core_first) + tmp17 := lang.Apply(tmp16, []any{v14}) + tmp18 := checkDerefVar(var_glojure_DOT_core_take) + tmp19 := checkDerefVar(var_glojure_DOT_core_dec) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(var_glojure_DOT_core_rest) + tmp22 := lang.Apply(tmp21, []any{v14}) + tmp23 := lang.Apply(tmp18, []any{tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp17, tmp23}) + tmp13 = tmp24 + } // end let + tmp12 = tmp13 + } else { + } + tmp8 = tmp12 + } // end let + tmp5 = tmp8 + } else { + } + return tmp5 + }) + tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_take = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_take.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // take-last + { + tmp0 := sym_take_DASH_last.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n, sym_coll)), kw_doc, "Returns a seq of the last n items in coll. Depending on the type\n of coll may be no better than linear time. For vectors, see also subvec.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(2939), kw_end_DASH_line, int(2939))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "s" + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := lang.Apply(tmp5, []any{v3}) + var v7 any = tmp6 + _ = v7 + // let binding "lead" + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_drop) + tmp10 := lang.Apply(tmp9, []any{v2, v3}) + tmp11 := lang.Apply(tmp8, []any{tmp10}) + var v12 any = tmp11 + _ = v12 + for { + var tmp13 any + if lang.IsTruthy(v12) { + tmp15 := checkDerefVar(var_glojure_DOT_core_next) + tmp16 := lang.Apply(tmp15, []any{v7}) + var tmp14 any = tmp16 + tmp18 := checkDerefVar(var_glojure_DOT_core_next) + tmp19 := lang.Apply(tmp18, []any{v12}) + var tmp17 any = tmp19 + v7 = tmp14 + v12 = tmp17 + continue + } else { + tmp13 = v7 + } + tmp4 = tmp13 + break + } + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_take_DASH_last = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_take_DASH_last.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // take-nth + { + tmp0 := sym_take_DASH_nth.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n), lang.NewVector(sym_n, sym_coll)), kw_doc, "Returns a lazy seq of every nth item in coll. Returns a stateful\n transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(4287), kw_end_DASH_line, int(4287))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 any + { // let + // let binding "iv" + tmp6 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) + tmp7 := lang.Apply(tmp6, []any{int64(-1)}) + var v8 any = tmp7 + _ = v8 + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp10 := lang.Apply(v4, nil) + return tmp10 + case 1: + v10 := args[0] + _ = v10 + tmp11 := lang.Apply(v4, []any{v10}) + return tmp11 + case 2: + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + var tmp12 any + { // let + // let binding "i" + tmp13 := checkDerefVar(var_glojure_DOT_core_inc) + tmp14, ok := lang.FieldOrMethod(v8, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "Deref"))) + } + var tmp15 any + switch reflect.TypeOf(tmp14).Kind() { + case reflect.Func: + tmp15 = lang.Apply(tmp14, nil) + default: + tmp15 = tmp14 + } + tmp16 := lang.Apply(tmp13, []any{tmp15}) + tmp17, _ := lang.FieldOrMethod(v8, "reset") + if reflect.TypeOf(tmp17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) + } + tmp18 := lang.Apply(tmp17, []any{tmp16}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + tmp21 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) + tmp22 := checkDerefVar(var_glojure_DOT_core_rem) + tmp23 := lang.Apply(tmp22, []any{v19, v2}) + tmp24 := lang.Apply(tmp21, []any{tmp23}) + if lang.IsTruthy(tmp24) { + tmp25 := lang.Apply(v4, []any{v10, v11}) + tmp20 = tmp25 + } else { + tmp20 = v10 + } + tmp12 = tmp20 + } // end let + return tmp12 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4295), kw_column, int(10), kw_end_DASH_line, int(4302), kw_end_DASH_column, int(28)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp5 = tmp11 + } // end let + return tmp5 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4293), kw_column, int(6), kw_end_DASH_line, int(4302), kw_end_DASH_column, int(30)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp5 any + { // let + // let binding "temp__0__auto__" + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := lang.Apply(tmp6, []any{v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + var tmp10 any + { // let + // let binding "s" + var v11 any = v8 + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_cons) + tmp13 := checkDerefVar(var_glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v11}) + tmp15 := checkDerefVar(var_glojure_DOT_core_take_DASH_nth) + tmp16 := checkDerefVar(var_glojure_DOT_core_drop) + tmp17 := lang.Apply(tmp16, []any{v2, v11}) + tmp18 := lang.Apply(tmp15, []any{v2, tmp17}) + tmp19 := lang.Apply(tmp12, []any{tmp14, tmp18}) + tmp10 = tmp19 + } // end let + tmp9 = tmp10 + } else { + } + tmp5 = tmp9 + } // end let + return tmp5 + }) + tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_take_DASH_nth = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_take_DASH_nth.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // throw-if + { + tmp0 := sym_throw_DASH_if.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred, sym_fmt, sym__AMP_, sym_args)), kw_doc, "Throws a CompilerException with a message if pred is true", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(8), kw_line, int(5832), kw_end_DASH_line, int(5832), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + if lang.IsTruthy(v2) { + var tmp6 any + { // let + // let binding "message" + tmp7 := checkDerefVar(var_glojure_DOT_core_apply) + tmp8 := checkDerefVar(var_glojure_DOT_core_format) + tmp9 := lang.Apply(tmp7, []any{tmp8, v3, v4}) + var v10 any = tmp9 + _ = v10 + // let binding "exception" + tmp11 := lang.Apply(lang.NewError, []any{v10}) + var v12 any = tmp11 + _ = v12 + // let binding "raw-trace" + tmp13, ok := lang.FieldOrMethod(v12, "getStackTrace") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v12, "getStackTrace"))) + } + var tmp14 any + switch reflect.TypeOf(tmp13).Kind() { + case reflect.Func: + tmp14 = lang.Apply(tmp13, nil) + default: + tmp14 = tmp13 + } + var v15 any = tmp14 + _ = v15 + // let binding "boring?" + var tmp16 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v17 := args[0] + _ = v17 + tmp18 := checkDerefVar(var_glojure_DOT_core_not_EQ_) + tmp19, ok := lang.FieldOrMethod(v17, "getMethodName") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v17, "getMethodName"))) + } + var tmp20 any + switch reflect.TypeOf(tmp19).Kind() { + case reflect.Func: + tmp20 = lang.Apply(tmp19, nil) + default: + tmp20 = tmp19 + } + tmp21 := lang.Apply(tmp18, []any{tmp20, "doInvoke"}) + return tmp21 + }) + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5839), kw_column, int(19), kw_end_DASH_line, int(5839), kw_end_DASH_column, int(74)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v19 any = tmp18 + _ = v19 + // let binding "trace" + tmp20 := checkDerefVar(var_glojure_DOT_core_into_DASH_array) + tmp21 := checkDerefVar(var_glojure_DOT_core_drop) + tmp22 := checkDerefVar(var_glojure_DOT_core_drop_DASH_while) + tmp23 := lang.Apply(tmp22, []any{v19, v15}) + tmp24 := lang.Apply(tmp21, []any{int64(2), tmp23}) + tmp25 := lang.Apply(tmp20, []any{nil, tmp24}) + var v26 any = tmp25 + _ = v26 + tmp27, _ := lang.FieldOrMethod(v12, "setStackTrace") + if reflect.TypeOf(tmp27).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setStackTrace is not a function"))) + } + tmp28 := lang.Apply(tmp27, []any{v26}) + _ = tmp28 + tmp29 := checkDerefVar(var_glojure_DOT_core__STAR_file_STAR_) + tmp30, ok := lang.FieldOrMethod(nil, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "Deref"))) + } + var tmp31 any + switch reflect.TypeOf(tmp30).Kind() { + case reflect.Func: + tmp31 = lang.Apply(tmp30, nil) + default: + tmp31 = tmp30 + } + tmp32, ok := lang.FieldOrMethod(nil, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "Deref"))) + } + var tmp33 any + switch reflect.TypeOf(tmp32).Kind() { + case reflect.Func: + tmp33 = lang.Apply(tmp32, nil) + default: + tmp33 = tmp32 + } + tmp34 := lang.Apply(lang.NewCompilerError, []any{tmp29, tmp31, tmp33, v12}) + panic(tmp34) + } // end let + tmp5 = tmp6 + } else { + } + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_throw_DASH_if = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_throw_DASH_if.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // time + { + tmp0 := sym_time.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_expr)), kw_doc, "Evaluates expr and prints the time it took. Returns the value of\n expr.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(11), kw_line, int(3885), kw_end_DASH_line, int(3885))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym_glojure_DOT_core_SLASH_let}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := checkDerefVar(var_glojure_DOT_core_apply) + tmp11 := checkDerefVar(var_glojure_DOT_core_vector) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_start__0__auto__}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := checkDerefVar(var_glojure_DOT_core_seq) + tmp18 := checkDerefVar(var_glojure_DOT_core_concat) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{sym__DOT_UnixNano}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := checkDerefVar(var_glojure_DOT_core_seq) + tmp23 := checkDerefVar(var_glojure_DOT_core_concat) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{sym_time_DOT_Now}) + tmp26 := lang.Apply(tmp23, []any{tmp25}) + tmp27 := lang.Apply(tmp22, []any{tmp26}) + tmp28 := lang.Apply(tmp21, []any{tmp27}) + tmp29 := lang.Apply(tmp18, []any{tmp20, tmp28}) + tmp30 := lang.Apply(tmp17, []any{tmp29}) + tmp31 := lang.Apply(tmp16, []any{tmp30}) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := lang.Apply(tmp32, []any{sym_ret__1__auto__}) + tmp34 := checkDerefVar(var_glojure_DOT_core_list) + tmp35 := lang.Apply(tmp34, []any{v4}) + tmp36 := lang.Apply(tmp13, []any{tmp15, tmp31, tmp33, tmp35}) + tmp37 := lang.Apply(tmp12, []any{tmp36}) + tmp38 := lang.Apply(tmp10, []any{tmp11, tmp37}) + tmp39 := lang.Apply(tmp9, []any{tmp38}) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := checkDerefVar(var_glojure_DOT_core_seq) + tmp42 := checkDerefVar(var_glojure_DOT_core_concat) + tmp43 := checkDerefVar(var_glojure_DOT_core_list) + tmp44 := lang.Apply(tmp43, []any{sym_glojure_DOT_core_SLASH_prn}) + tmp45 := checkDerefVar(var_glojure_DOT_core_list) + tmp46 := checkDerefVar(var_glojure_DOT_core_seq) + tmp47 := checkDerefVar(var_glojure_DOT_core_concat) + tmp48 := checkDerefVar(var_glojure_DOT_core_list) + tmp49 := lang.Apply(tmp48, []any{sym_glojure_DOT_core_SLASH_str}) + tmp50 := checkDerefVar(var_glojure_DOT_core_list) + tmp51 := lang.Apply(tmp50, []any{"Elapsed time: "}) + tmp52 := checkDerefVar(var_glojure_DOT_core_list) + tmp53 := checkDerefVar(var_glojure_DOT_core_seq) + tmp54 := checkDerefVar(var_glojure_DOT_core_concat) + tmp55 := checkDerefVar(var_glojure_DOT_core_list) + tmp56 := lang.Apply(tmp55, []any{sym_glojure_DOT_core_SLASH__SLASH_}) + tmp57 := checkDerefVar(var_glojure_DOT_core_list) + tmp58 := checkDerefVar(var_glojure_DOT_core_seq) + tmp59 := checkDerefVar(var_glojure_DOT_core_concat) + tmp60 := checkDerefVar(var_glojure_DOT_core_list) + tmp61 := lang.Apply(tmp60, []any{sym_glojure_DOT_core_SLASH_double}) + tmp62 := checkDerefVar(var_glojure_DOT_core_list) + tmp63 := checkDerefVar(var_glojure_DOT_core_seq) + tmp64 := checkDerefVar(var_glojure_DOT_core_concat) + tmp65 := checkDerefVar(var_glojure_DOT_core_list) + tmp66 := lang.Apply(tmp65, []any{sym_glojure_DOT_core_SLASH__DASH_}) + tmp67 := checkDerefVar(var_glojure_DOT_core_list) + tmp68 := checkDerefVar(var_glojure_DOT_core_seq) + tmp69 := checkDerefVar(var_glojure_DOT_core_concat) + tmp70 := checkDerefVar(var_glojure_DOT_core_list) + tmp71 := lang.Apply(tmp70, []any{sym__DOT_UnixNano}) + tmp72 := checkDerefVar(var_glojure_DOT_core_list) + tmp73 := checkDerefVar(var_glojure_DOT_core_seq) + tmp74 := checkDerefVar(var_glojure_DOT_core_concat) + tmp75 := checkDerefVar(var_glojure_DOT_core_list) + tmp76 := lang.Apply(tmp75, []any{sym_time_DOT_Now}) + tmp77 := lang.Apply(tmp74, []any{tmp76}) + tmp78 := lang.Apply(tmp73, []any{tmp77}) + tmp79 := lang.Apply(tmp72, []any{tmp78}) + tmp80 := lang.Apply(tmp69, []any{tmp71, tmp79}) + tmp81 := lang.Apply(tmp68, []any{tmp80}) + tmp82 := lang.Apply(tmp67, []any{tmp81}) + tmp83 := checkDerefVar(var_glojure_DOT_core_list) + tmp84 := lang.Apply(tmp83, []any{sym_start__0__auto__}) + tmp85 := lang.Apply(tmp64, []any{tmp66, tmp82, tmp84}) + tmp86 := lang.Apply(tmp63, []any{tmp85}) + tmp87 := lang.Apply(tmp62, []any{tmp86}) + tmp88 := lang.Apply(tmp59, []any{tmp61, tmp87}) + tmp89 := lang.Apply(tmp58, []any{tmp88}) + tmp90 := lang.Apply(tmp57, []any{tmp89}) + tmp91 := checkDerefVar(var_glojure_DOT_core_list) + tmp92 := lang.Apply(tmp91, []any{float64(1e+06)}) + tmp93 := lang.Apply(tmp54, []any{tmp56, tmp90, tmp92}) + tmp94 := lang.Apply(tmp53, []any{tmp93}) + tmp95 := lang.Apply(tmp52, []any{tmp94}) + tmp96 := checkDerefVar(var_glojure_DOT_core_list) + tmp97 := lang.Apply(tmp96, []any{" msecs"}) + tmp98 := lang.Apply(tmp47, []any{tmp49, tmp51, tmp95, tmp97}) + tmp99 := lang.Apply(tmp46, []any{tmp98}) + tmp100 := lang.Apply(tmp45, []any{tmp99}) + tmp101 := lang.Apply(tmp42, []any{tmp44, tmp100}) + tmp102 := lang.Apply(tmp41, []any{tmp101}) + tmp103 := lang.Apply(tmp40, []any{tmp102}) + tmp104 := checkDerefVar(var_glojure_DOT_core_list) + tmp105 := lang.Apply(tmp104, []any{sym_ret__1__auto__}) + tmp106 := lang.Apply(tmp6, []any{tmp8, tmp39, tmp103, tmp105}) + tmp107 := lang.Apply(tmp5, []any{tmp106}) + return tmp107 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_time = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_time.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // trampoline + { + tmp0 := sym_trampoline.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym__AMP_, sym_args)), kw_doc, "trampoline can be used to convert algorithms requiring mutual\n recursion without stack consumption. Calls f with supplied args, if\n any. If f returns a fn, calls that fn with no arguments, and\n continues to repeat, until the return value is not a fn, then\n returns that non-fn value. Note that if you want to return a fn as a\n final value, you must wrap it in some data structure and unpack it\n after trampoline returns.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(6293), kw_end_DASH_line, int(6293))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + recur_loop_2613: + var tmp3 any + { // let + // let binding "ret" + tmp4 := lang.Apply(v2, nil) + var v5 any = tmp4 + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_fn_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v5}) + if lang.IsTruthy(tmp8) { + var tmp9 any = v5 + v2 = tmp9 + goto recur_loop_2613 + } else { + tmp6 = v5 + } + tmp3 = tmp6 + } // end let + return tmp3 + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_trampoline) + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := lang.Apply(tmp6, []any{v2, v3}) + return tmp7 + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6309), kw_column, int(18), kw_end_DASH_line, int(6309), kw_end_DASH_column, int(32)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp8 := lang.Apply(tmp4, []any{tmp7}) + return tmp8 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_trampoline = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_trampoline.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // update + { + tmp0 := sym_update.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m, sym_k, sym_f), lang.NewVector(sym_m, sym_k, sym_f, sym_x), lang.NewVector(sym_m, sym_k, sym_f, sym_x, sym_y), lang.NewVector(sym_m, sym_k, sym_f, sym_x, sym_y, sym_z), lang.NewVector(sym_m, sym_k, sym_f, sym_x, sym_y, sym_z, sym__AMP_, sym_more)), kw_doc, "'Updates' a value in an associative structure, where k is a\n key and f is a function that will take the old value\n and any supplied args and return the new value, and returns a new\n structure. If the key does not exist, nil is passed as the old value.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(6174), kw_end_DASH_line, int(6174))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp6 := checkDerefVar(var_glojure_DOT_core_get) + tmp7 := lang.Apply(tmp6, []any{v2, v3}) + tmp8 := lang.Apply(v4, []any{tmp7}) + tmp9 := lang.Apply(tmp5, []any{v2, v3, tmp8}) + return tmp9 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp7 := checkDerefVar(var_glojure_DOT_core_get) + tmp8 := lang.Apply(tmp7, []any{v2, v3}) + tmp9 := lang.Apply(v4, []any{tmp8, v5}) + tmp10 := lang.Apply(tmp6, []any{v2, v3, tmp9}) + return tmp10 + case 5: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp8 := checkDerefVar(var_glojure_DOT_core_get) + tmp9 := lang.Apply(tmp8, []any{v2, v3}) + tmp10 := lang.Apply(v4, []any{tmp9, v5, v6}) + tmp11 := lang.Apply(tmp7, []any{v2, v3, tmp10}) + return tmp11 + case 6: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + v7 := args[5] + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp9 := checkDerefVar(var_glojure_DOT_core_get) + tmp10 := lang.Apply(tmp9, []any{v2, v3}) + tmp11 := lang.Apply(v4, []any{tmp10, v5, v6, v7}) + tmp12 := lang.Apply(tmp8, []any{v2, v3, tmp11}) + return tmp12 + default: + checkArity(args, 6) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + v7 := args[5] + _ = v7 + var v8 any = lang.NewList(args[6:]...) + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp10 := checkDerefVar(var_glojure_DOT_core_apply) + tmp11 := checkDerefVar(var_glojure_DOT_core_get) + tmp12 := lang.Apply(tmp11, []any{v2, v3}) + tmp13 := lang.Apply(tmp10, []any{v4, tmp12, v5, v6, v7, v8}) + tmp14 := lang.Apply(tmp9, []any{v2, v3, tmp13}) + return tmp14 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_update = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_update.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // update-in + { + tmp0 := sym_update_DASH_in.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m, sym_ks, sym_f, sym__AMP_, sym_args)), kw_doc, "'Updates' a value in a nested associative structure, where ks is a\n sequence of keys and f is a function that will take the old value\n and any supplied args and return the new value, and returns a new\n nested structure. If any levels do not exist, hash-maps will be\n created.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(6158), kw_end_DASH_line, int(6158))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "up" + var tmp7 lang.FnFunc + { // function up + var v8 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 4) + v9 := args[0] + _ = v9 + v10 := args[1] + _ = v10 + v11 := args[2] + _ = v11 + v12 := args[3] + _ = v12 + var tmp13 any + { // let + // let binding "vec__832" + var v14 any = v10 + _ = v14 + // let binding "seq__833" + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := lang.Apply(tmp15, []any{v14}) + var v17 any = tmp16 + _ = v17 + // let binding "first__834" + tmp18 := checkDerefVar(var_glojure_DOT_core_first) + tmp19 := lang.Apply(tmp18, []any{v17}) + var v20 any = tmp19 + _ = v20 + // let binding "seq__833" + tmp21 := checkDerefVar(var_glojure_DOT_core_next) + tmp22 := lang.Apply(tmp21, []any{v17}) + var v23 any = tmp22 + _ = v23 + // let binding "k" + var v24 any = v20 + _ = v24 + // let binding "ks" + var v25 any = v23 + _ = v25 + var tmp26 any + if lang.IsTruthy(v25) { + tmp27 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp28 := checkDerefVar(var_glojure_DOT_core_get) + tmp29 := lang.Apply(tmp28, []any{v9, v24}) + tmp30 := lang.Apply(v8, []any{tmp29, v25, v11, v12}) + tmp31 := lang.Apply(tmp27, []any{v9, v24, tmp30}) + tmp26 = tmp31 + } else { + tmp32 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp33 := checkDerefVar(var_glojure_DOT_core_apply) + tmp34 := checkDerefVar(var_glojure_DOT_core_get) + tmp35 := lang.Apply(tmp34, []any{v9, v24}) + tmp36 := lang.Apply(tmp33, []any{v11, tmp35, v12}) + tmp37 := lang.Apply(tmp32, []any{v9, v24, tmp36}) + tmp26 = tmp37 + } + tmp13 = tmp26 + } // end let + return tmp13 + }) + v8 = tmp7 + _ = v8 + } + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6167), kw_column, int(15), kw_end_DASH_line, int(6171), kw_end_DASH_column, int(59)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v10 any = tmp9 + _ = v10 + tmp11 := lang.Apply(v10, []any{v2, v3, v4, v5}) + tmp6 = tmp11 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_update_DASH_in = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_update_DASH_in.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // vary-meta + { + tmp0 := sym_vary_DASH_meta.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_obj, sym_f, sym__AMP_, sym_args)), kw_doc, "Returns an object of the same type and value as obj, with\n (apply f (meta obj) args) as its metadata.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(668), kw_end_DASH_line, int(668))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_meta) + tmp8 := lang.Apply(tmp7, []any{v2}) + tmp9 := lang.Apply(tmp6, []any{v3, tmp8, v4}) + tmp10 := lang.Apply(tmp5, []any{v2, tmp9}) + return tmp10 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_vary_DASH_meta = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_vary_DASH_meta.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // when-first + { + tmp0 := sym_when_DASH_first.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "bindings => x xs\n\n Roughly the same as (when (seq xs) (let [x (first xs)] body)) but xs is evaluated only once", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(11), kw_line, int(4622), kw_end_DASH_line, int(4622))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v4}) + if lang.IsTruthy(tmp8) { + } else { + tmp9 := checkDerefVar(var_glojure_DOT_core_str) + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp13 := checkDerefVar(var_glojure_DOT_core_meta) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(kw_line, []any{tmp14}) + tmp16 := lang.Apply(tmp9, []any{tmp11, " requires ", "a vector for its binding", " in ", tmp12, ":", tmp15}) + tmp17 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp16}) + panic(tmp17) + } + _ = tmp6 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp20 := checkDerefVar(var_glojure_DOT_core_count) + tmp21 := lang.Apply(tmp20, []any{v4}) + tmp22 := lang.Apply(tmp19, []any{int64(2), tmp21}) + if lang.IsTruthy(tmp22) { + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp27 := checkDerefVar(var_glojure_DOT_core_meta) + tmp28 := lang.Apply(tmp27, []any{v2}) + tmp29 := lang.Apply(kw_line, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp25, " requires ", "exactly 2 forms in binding vector", " in ", tmp26, ":", tmp29}) + tmp31 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp31) + } + _ = tmp18 + var tmp32 any + { // let + // let binding "vec__711" + var v33 any = v4 + _ = v33 + // let binding "x" + tmp34 := checkDerefVar(var_glojure_DOT_core_nth) + tmp35 := lang.Apply(tmp34, []any{v33, int64(0), nil}) + var v36 any = tmp35 + _ = v36 + // let binding "xs" + tmp37 := checkDerefVar(var_glojure_DOT_core_nth) + tmp38 := lang.Apply(tmp37, []any{v33, int64(1), nil}) + var v39 any = tmp38 + _ = v39 + tmp40 := checkDerefVar(var_glojure_DOT_core_seq) + tmp41 := checkDerefVar(var_glojure_DOT_core_concat) + tmp42 := checkDerefVar(var_glojure_DOT_core_list) + tmp43 := lang.Apply(tmp42, []any{sym_glojure_DOT_core_SLASH_when_DASH_let}) + tmp44 := checkDerefVar(var_glojure_DOT_core_list) + tmp45 := checkDerefVar(var_glojure_DOT_core_apply) + tmp46 := checkDerefVar(var_glojure_DOT_core_vector) + tmp47 := checkDerefVar(var_glojure_DOT_core_seq) + tmp48 := checkDerefVar(var_glojure_DOT_core_concat) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) + tmp50 := lang.Apply(tmp49, []any{sym_xs__0__auto__}) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := checkDerefVar(var_glojure_DOT_core_seq) + tmp53 := checkDerefVar(var_glojure_DOT_core_concat) + tmp54 := checkDerefVar(var_glojure_DOT_core_list) + tmp55 := lang.Apply(tmp54, []any{sym_glojure_DOT_core_SLASH_seq}) + tmp56 := checkDerefVar(var_glojure_DOT_core_list) + tmp57 := lang.Apply(tmp56, []any{v39}) + tmp58 := lang.Apply(tmp53, []any{tmp55, tmp57}) + tmp59 := lang.Apply(tmp52, []any{tmp58}) + tmp60 := lang.Apply(tmp51, []any{tmp59}) + tmp61 := lang.Apply(tmp48, []any{tmp50, tmp60}) + tmp62 := lang.Apply(tmp47, []any{tmp61}) + tmp63 := lang.Apply(tmp45, []any{tmp46, tmp62}) + tmp64 := lang.Apply(tmp44, []any{tmp63}) + tmp65 := checkDerefVar(var_glojure_DOT_core_list) + tmp66 := checkDerefVar(var_glojure_DOT_core_seq) + tmp67 := checkDerefVar(var_glojure_DOT_core_concat) + tmp68 := checkDerefVar(var_glojure_DOT_core_list) + tmp69 := lang.Apply(tmp68, []any{sym_glojure_DOT_core_SLASH_let}) + tmp70 := checkDerefVar(var_glojure_DOT_core_list) + tmp71 := checkDerefVar(var_glojure_DOT_core_apply) + tmp72 := checkDerefVar(var_glojure_DOT_core_vector) + tmp73 := checkDerefVar(var_glojure_DOT_core_seq) + tmp74 := checkDerefVar(var_glojure_DOT_core_concat) + tmp75 := checkDerefVar(var_glojure_DOT_core_list) + tmp76 := lang.Apply(tmp75, []any{v36}) + tmp77 := checkDerefVar(var_glojure_DOT_core_list) + tmp78 := checkDerefVar(var_glojure_DOT_core_seq) + tmp79 := checkDerefVar(var_glojure_DOT_core_concat) + tmp80 := checkDerefVar(var_glojure_DOT_core_list) + tmp81 := lang.Apply(tmp80, []any{sym_glojure_DOT_core_SLASH_first}) + tmp82 := checkDerefVar(var_glojure_DOT_core_list) + tmp83 := lang.Apply(tmp82, []any{sym_xs__0__auto__}) + tmp84 := lang.Apply(tmp79, []any{tmp81, tmp83}) + tmp85 := lang.Apply(tmp78, []any{tmp84}) + tmp86 := lang.Apply(tmp77, []any{tmp85}) + tmp87 := lang.Apply(tmp74, []any{tmp76, tmp86}) + tmp88 := lang.Apply(tmp73, []any{tmp87}) + tmp89 := lang.Apply(tmp71, []any{tmp72, tmp88}) + tmp90 := lang.Apply(tmp70, []any{tmp89}) + tmp91 := lang.Apply(tmp67, []any{tmp69, tmp90, v5}) + tmp92 := lang.Apply(tmp66, []any{tmp91}) + tmp93 := lang.Apply(tmp65, []any{tmp92}) + tmp94 := lang.Apply(tmp41, []any{tmp43, tmp64, tmp93}) + tmp95 := lang.Apply(tmp40, []any{tmp94}) + tmp32 = tmp95 + } // end let + return tmp32 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_when_DASH_first = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_when_DASH_first.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // when-let + { + tmp0 := sym_when_DASH_let.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "bindings => binding-form test\n\n When test is true, evaluates body with binding-form bound to the value of test", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(11), kw_line, int(1859), kw_end_DASH_line, int(1859))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v4}) + if lang.IsTruthy(tmp8) { + } else { + tmp9 := checkDerefVar(var_glojure_DOT_core_str) + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp13 := checkDerefVar(var_glojure_DOT_core_meta) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(kw_line, []any{tmp14}) + tmp16 := lang.Apply(tmp9, []any{tmp11, " requires ", "a vector for its binding", " in ", tmp12, ":", tmp15}) + tmp17 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp16}) + panic(tmp17) + } + _ = tmp6 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp20 := checkDerefVar(var_glojure_DOT_core_count) + tmp21 := lang.Apply(tmp20, []any{v4}) + tmp22 := lang.Apply(tmp19, []any{int64(2), tmp21}) + if lang.IsTruthy(tmp22) { + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp27 := checkDerefVar(var_glojure_DOT_core_meta) + tmp28 := lang.Apply(tmp27, []any{v2}) + tmp29 := lang.Apply(kw_line, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp25, " requires ", "exactly 2 forms in binding vector", " in ", tmp26, ":", tmp29}) + tmp31 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp31) + } + _ = tmp18 + var tmp32 any + { // let + // let binding "form" + tmp33 := lang.Apply(v4, []any{int64(0)}) + var v34 any = tmp33 + _ = v34 + // let binding "tst" + tmp35 := lang.Apply(v4, []any{int64(1)}) + var v36 any = tmp35 + _ = v36 + tmp37 := checkDerefVar(var_glojure_DOT_core_seq) + tmp38 := checkDerefVar(var_glojure_DOT_core_concat) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := lang.Apply(tmp39, []any{sym_glojure_DOT_core_SLASH_let}) + tmp41 := checkDerefVar(var_glojure_DOT_core_list) + tmp42 := checkDerefVar(var_glojure_DOT_core_apply) + tmp43 := checkDerefVar(var_glojure_DOT_core_vector) + tmp44 := checkDerefVar(var_glojure_DOT_core_seq) + tmp45 := checkDerefVar(var_glojure_DOT_core_concat) + tmp46 := checkDerefVar(var_glojure_DOT_core_list) + tmp47 := lang.Apply(tmp46, []any{sym_temp__0__auto__}) + tmp48 := checkDerefVar(var_glojure_DOT_core_list) + tmp49 := lang.Apply(tmp48, []any{v36}) + tmp50 := lang.Apply(tmp45, []any{tmp47, tmp49}) + tmp51 := lang.Apply(tmp44, []any{tmp50}) + tmp52 := lang.Apply(tmp42, []any{tmp43, tmp51}) + tmp53 := lang.Apply(tmp41, []any{tmp52}) + tmp54 := checkDerefVar(var_glojure_DOT_core_list) + tmp55 := checkDerefVar(var_glojure_DOT_core_seq) + tmp56 := checkDerefVar(var_glojure_DOT_core_concat) + tmp57 := checkDerefVar(var_glojure_DOT_core_list) + tmp58 := lang.Apply(tmp57, []any{sym_glojure_DOT_core_SLASH_when}) + tmp59 := checkDerefVar(var_glojure_DOT_core_list) + tmp60 := lang.Apply(tmp59, []any{sym_temp__0__auto__}) + tmp61 := checkDerefVar(var_glojure_DOT_core_list) + tmp62 := checkDerefVar(var_glojure_DOT_core_seq) + tmp63 := checkDerefVar(var_glojure_DOT_core_concat) + tmp64 := checkDerefVar(var_glojure_DOT_core_list) + tmp65 := lang.Apply(tmp64, []any{sym_glojure_DOT_core_SLASH_let}) + tmp66 := checkDerefVar(var_glojure_DOT_core_list) + tmp67 := checkDerefVar(var_glojure_DOT_core_apply) + tmp68 := checkDerefVar(var_glojure_DOT_core_vector) + tmp69 := checkDerefVar(var_glojure_DOT_core_seq) + tmp70 := checkDerefVar(var_glojure_DOT_core_concat) + tmp71 := checkDerefVar(var_glojure_DOT_core_list) + tmp72 := lang.Apply(tmp71, []any{v34}) + tmp73 := checkDerefVar(var_glojure_DOT_core_list) + tmp74 := lang.Apply(tmp73, []any{sym_temp__0__auto__}) + tmp75 := lang.Apply(tmp70, []any{tmp72, tmp74}) + tmp76 := lang.Apply(tmp69, []any{tmp75}) + tmp77 := lang.Apply(tmp67, []any{tmp68, tmp76}) + tmp78 := lang.Apply(tmp66, []any{tmp77}) + tmp79 := lang.Apply(tmp63, []any{tmp65, tmp78, v5}) + tmp80 := lang.Apply(tmp62, []any{tmp79}) + tmp81 := lang.Apply(tmp61, []any{tmp80}) + tmp82 := lang.Apply(tmp56, []any{tmp58, tmp60, tmp81}) + tmp83 := lang.Apply(tmp55, []any{tmp82}) + tmp84 := lang.Apply(tmp54, []any{tmp83}) + tmp85 := lang.Apply(tmp38, []any{tmp40, tmp53, tmp84}) + tmp86 := lang.Apply(tmp37, []any{tmp85}) + tmp32 = tmp86 + } // end let + return tmp32 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_when_DASH_let = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_when_DASH_let.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // when-some + { + tmp0 := sym_when_DASH_some.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "bindings => binding-form test\n\n When test is not nil, evaluates body with binding-form bound to the\n value of test", kw_file, "glojure/core.glj", kw_added, "1.6", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(11), kw_line, int(1894), kw_end_DASH_line, int(1894))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v4}) + if lang.IsTruthy(tmp8) { + } else { + tmp9 := checkDerefVar(var_glojure_DOT_core_str) + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp13 := checkDerefVar(var_glojure_DOT_core_meta) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(kw_line, []any{tmp14}) + tmp16 := lang.Apply(tmp9, []any{tmp11, " requires ", "a vector for its binding", " in ", tmp12, ":", tmp15}) + tmp17 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp16}) + panic(tmp17) + } + _ = tmp6 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp20 := checkDerefVar(var_glojure_DOT_core_count) + tmp21 := lang.Apply(tmp20, []any{v4}) + tmp22 := lang.Apply(tmp19, []any{int64(2), tmp21}) + if lang.IsTruthy(tmp22) { + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp27 := checkDerefVar(var_glojure_DOT_core_meta) + tmp28 := lang.Apply(tmp27, []any{v2}) + tmp29 := lang.Apply(kw_line, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp25, " requires ", "exactly 2 forms in binding vector", " in ", tmp26, ":", tmp29}) + tmp31 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp31) + } + _ = tmp18 + var tmp32 any + { // let + // let binding "form" + tmp33 := lang.Apply(v4, []any{int64(0)}) + var v34 any = tmp33 + _ = v34 + // let binding "tst" + tmp35 := lang.Apply(v4, []any{int64(1)}) + var v36 any = tmp35 + _ = v36 + tmp37 := checkDerefVar(var_glojure_DOT_core_seq) + tmp38 := checkDerefVar(var_glojure_DOT_core_concat) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := lang.Apply(tmp39, []any{sym_glojure_DOT_core_SLASH_let}) + tmp41 := checkDerefVar(var_glojure_DOT_core_list) + tmp42 := checkDerefVar(var_glojure_DOT_core_apply) + tmp43 := checkDerefVar(var_glojure_DOT_core_vector) + tmp44 := checkDerefVar(var_glojure_DOT_core_seq) + tmp45 := checkDerefVar(var_glojure_DOT_core_concat) + tmp46 := checkDerefVar(var_glojure_DOT_core_list) + tmp47 := lang.Apply(tmp46, []any{sym_temp__0__auto__}) + tmp48 := checkDerefVar(var_glojure_DOT_core_list) + tmp49 := lang.Apply(tmp48, []any{v36}) + tmp50 := lang.Apply(tmp45, []any{tmp47, tmp49}) + tmp51 := lang.Apply(tmp44, []any{tmp50}) + tmp52 := lang.Apply(tmp42, []any{tmp43, tmp51}) + tmp53 := lang.Apply(tmp41, []any{tmp52}) + tmp54 := checkDerefVar(var_glojure_DOT_core_list) + tmp55 := checkDerefVar(var_glojure_DOT_core_seq) + tmp56 := checkDerefVar(var_glojure_DOT_core_concat) + tmp57 := checkDerefVar(var_glojure_DOT_core_list) + tmp58 := lang.Apply(tmp57, []any{sym_if}) + tmp59 := checkDerefVar(var_glojure_DOT_core_list) + tmp60 := checkDerefVar(var_glojure_DOT_core_seq) + tmp61 := checkDerefVar(var_glojure_DOT_core_concat) + tmp62 := checkDerefVar(var_glojure_DOT_core_list) + tmp63 := lang.Apply(tmp62, []any{sym_glojure_DOT_core_SLASH_nil_QMARK_}) + tmp64 := checkDerefVar(var_glojure_DOT_core_list) + tmp65 := lang.Apply(tmp64, []any{sym_temp__0__auto__}) + tmp66 := lang.Apply(tmp61, []any{tmp63, tmp65}) + tmp67 := lang.Apply(tmp60, []any{tmp66}) + tmp68 := lang.Apply(tmp59, []any{tmp67}) + tmp69 := checkDerefVar(var_glojure_DOT_core_list) + tmp70 := lang.Apply(tmp69, []any{nil}) + tmp71 := checkDerefVar(var_glojure_DOT_core_list) + tmp72 := checkDerefVar(var_glojure_DOT_core_seq) + tmp73 := checkDerefVar(var_glojure_DOT_core_concat) + tmp74 := checkDerefVar(var_glojure_DOT_core_list) + tmp75 := lang.Apply(tmp74, []any{sym_glojure_DOT_core_SLASH_let}) + tmp76 := checkDerefVar(var_glojure_DOT_core_list) + tmp77 := checkDerefVar(var_glojure_DOT_core_apply) + tmp78 := checkDerefVar(var_glojure_DOT_core_vector) + tmp79 := checkDerefVar(var_glojure_DOT_core_seq) + tmp80 := checkDerefVar(var_glojure_DOT_core_concat) + tmp81 := checkDerefVar(var_glojure_DOT_core_list) + tmp82 := lang.Apply(tmp81, []any{v34}) + tmp83 := checkDerefVar(var_glojure_DOT_core_list) + tmp84 := lang.Apply(tmp83, []any{sym_temp__0__auto__}) + tmp85 := lang.Apply(tmp80, []any{tmp82, tmp84}) + tmp86 := lang.Apply(tmp79, []any{tmp85}) + tmp87 := lang.Apply(tmp77, []any{tmp78, tmp86}) + tmp88 := lang.Apply(tmp76, []any{tmp87}) + tmp89 := lang.Apply(tmp73, []any{tmp75, tmp88, v5}) + tmp90 := lang.Apply(tmp72, []any{tmp89}) + tmp91 := lang.Apply(tmp71, []any{tmp90}) + tmp92 := lang.Apply(tmp56, []any{tmp58, tmp68, tmp70, tmp91}) + tmp93 := lang.Apply(tmp55, []any{tmp92}) + tmp94 := lang.Apply(tmp54, []any{tmp93}) + tmp95 := lang.Apply(tmp38, []any{tmp40, tmp53, tmp94}) + tmp96 := lang.Apply(tmp37, []any{tmp95}) + tmp32 = tmp96 + } // end let + return tmp32 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_when_DASH_some = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_when_DASH_some.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // while + { + tmp0 := sym_while.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_test, sym__AMP_, sym_body)), kw_doc, "Repeatedly executes body while test expression is true. Presumes\n some side-effect will cause test to become false/nil. Returns nil", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(11), kw_line, int(6327), kw_end_DASH_line, int(6327))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_loop}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + tmp12 := checkDerefVar(var_glojure_DOT_core_vector) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := lang.Apply(tmp14, nil) + tmp16 := lang.Apply(tmp13, []any{tmp15}) + tmp17 := lang.Apply(tmp11, []any{tmp12, tmp16}) + tmp18 := lang.Apply(tmp10, []any{tmp17}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{sym_glojure_DOT_core_SLASH_when}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v4}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := checkDerefVar(var_glojure_DOT_core_seq) + tmp28 := checkDerefVar(var_glojure_DOT_core_concat) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{sym_recur}) + tmp31 := lang.Apply(tmp28, []any{tmp30}) + tmp32 := lang.Apply(tmp27, []any{tmp31}) + tmp33 := lang.Apply(tmp26, []any{tmp32}) + tmp34 := lang.Apply(tmp21, []any{tmp23, tmp25, v5, tmp33}) + tmp35 := lang.Apply(tmp20, []any{tmp34}) + tmp36 := lang.Apply(tmp19, []any{tmp35}) + tmp37 := lang.Apply(tmp7, []any{tmp9, tmp18, tmp36}) + tmp38 := lang.Apply(tmp6, []any{tmp37}) + return tmp38 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_while = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_while.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // with-bindings + { + tmp0 := sym_with_DASH_bindings.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_binding_DASH_map, sym__AMP_, sym_body)), kw_doc, "Takes a map of Var/value pairs. Installs for the given Vars the associated\n values as thread-local bindings. Then executes body. Pops the installed\n bindings after body was evaluated. Returns the value of body.", kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(11), kw_line, int(1984), kw_end_DASH_line, int(1984))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_with_DASH_bindings_STAR_}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{v4}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_fn}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_apply) + tmp19 := checkDerefVar(var_glojure_DOT_core_vector) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := lang.Apply(tmp21, nil) + tmp23 := lang.Apply(tmp20, []any{tmp22}) + tmp24 := lang.Apply(tmp18, []any{tmp19, tmp23}) + tmp25 := lang.Apply(tmp17, []any{tmp24}) + tmp26 := lang.Apply(tmp14, []any{tmp16, tmp25, v5}) + tmp27 := lang.Apply(tmp13, []any{tmp26}) + tmp28 := lang.Apply(tmp12, []any{tmp27}) + tmp29 := lang.Apply(tmp7, []any{tmp9, tmp11, tmp28}) + tmp30 := lang.Apply(tmp6, []any{tmp29}) + return tmp30 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_with_DASH_bindings = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_with_DASH_bindings.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // with-bindings* + { + tmp0 := sym_with_DASH_bindings_STAR_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_binding_DASH_map, sym_f, sym__AMP_, sym_args)), kw_doc, "Takes a map of Var/value pairs. Installs for the given Vars the associated\n values as thread-local bindings. Then calls f with the supplied arguments.\n Pops the installed bindings after f returned. Returns whatever f returns.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(1971), kw_end_DASH_line, int(1971))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp6 := lang.Apply(tmp5, []any{v2}) + _ = tmp6 + var tmp7 any + func() { + defer func() { + tmp8 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp9 := lang.Apply(tmp8, nil) + _ = tmp9 + }() + tmp10 := checkDerefVar(var_glojure_DOT_core_apply) + tmp11 := lang.Apply(tmp10, []any{v3, v4}) + tmp7 = tmp11 + }() + return tmp7 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_with_DASH_bindings_STAR_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_with_DASH_bindings_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // with-in-str + { + tmp0 := sym_with_DASH_in_DASH_str.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_s, sym__AMP_, sym_body)), kw_doc, "Evaluates body in a context in which *in* is bound to a fresh\n StringReader initialized with the string s.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(11), kw_line, int(4749), kw_end_DASH_line, int(4749))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_with_DASH_open}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + tmp12 := checkDerefVar(var_glojure_DOT_core_vector) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_s__0__auto__}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{sym_glojure_DOT_core_SLASH__DASH__GT_}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := checkDerefVar(var_glojure_DOT_core_seq) + tmp24 := checkDerefVar(var_glojure_DOT_core_concat) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := lang.Apply(tmp25, []any{sym_java_DOT_io_DOT_StringReader_DOT_}) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{v4}) + tmp29 := lang.Apply(tmp24, []any{tmp26, tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp29}) + tmp31 := lang.Apply(tmp22, []any{tmp30}) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := lang.Apply(tmp32, []any{sym_glojure_DOT_lang_DOT_LineNumberingPushbackReader_DOT_}) + tmp34 := lang.Apply(tmp19, []any{tmp21, tmp31, tmp33}) + tmp35 := lang.Apply(tmp18, []any{tmp34}) + tmp36 := lang.Apply(tmp17, []any{tmp35}) + tmp37 := lang.Apply(tmp14, []any{tmp16, tmp36}) + tmp38 := lang.Apply(tmp13, []any{tmp37}) + tmp39 := lang.Apply(tmp11, []any{tmp12, tmp38}) + tmp40 := lang.Apply(tmp10, []any{tmp39}) + tmp41 := checkDerefVar(var_glojure_DOT_core_list) + tmp42 := checkDerefVar(var_glojure_DOT_core_seq) + tmp43 := checkDerefVar(var_glojure_DOT_core_concat) + tmp44 := checkDerefVar(var_glojure_DOT_core_list) + tmp45 := lang.Apply(tmp44, []any{sym_glojure_DOT_core_SLASH_binding}) + tmp46 := checkDerefVar(var_glojure_DOT_core_list) + tmp47 := checkDerefVar(var_glojure_DOT_core_apply) + tmp48 := checkDerefVar(var_glojure_DOT_core_vector) + tmp49 := checkDerefVar(var_glojure_DOT_core_seq) + tmp50 := checkDerefVar(var_glojure_DOT_core_concat) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := lang.Apply(tmp51, []any{sym_glojure_DOT_core_SLASH__STAR_in_STAR_}) + tmp53 := checkDerefVar(var_glojure_DOT_core_list) + tmp54 := lang.Apply(tmp53, []any{sym_s__0__auto__}) + tmp55 := lang.Apply(tmp50, []any{tmp52, tmp54}) + tmp56 := lang.Apply(tmp49, []any{tmp55}) + tmp57 := lang.Apply(tmp47, []any{tmp48, tmp56}) + tmp58 := lang.Apply(tmp46, []any{tmp57}) + tmp59 := lang.Apply(tmp43, []any{tmp45, tmp58, v5}) + tmp60 := lang.Apply(tmp42, []any{tmp59}) + tmp61 := lang.Apply(tmp41, []any{tmp60}) + tmp62 := lang.Apply(tmp7, []any{tmp9, tmp40, tmp61}) + tmp63 := lang.Apply(tmp6, []any{tmp62}) + return tmp63 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_with_DASH_in_DASH_str = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_with_DASH_in_DASH_str.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // with-loading-context + { + tmp0 := sym_with_DASH_loading_DASH_context.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5734), kw_column, int(11), kw_end_DASH_line, int(5734), kw_end_DASH_column, int(30), kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_body)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_macro, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_fn}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_loading__0__auto__}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_apply) + tmp16 := checkDerefVar(var_glojure_DOT_core_vector) + tmp17 := checkDerefVar(var_glojure_DOT_core_seq) + tmp18 := checkDerefVar(var_glojure_DOT_core_concat) + tmp19 := lang.Apply(tmp18, nil) + tmp20 := lang.Apply(tmp17, []any{tmp19}) + tmp21 := lang.Apply(tmp15, []any{tmp16, tmp20}) + tmp22 := lang.Apply(tmp14, []any{tmp21}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_seq) + tmp25 := checkDerefVar(var_glojure_DOT_core_concat) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_PushThreadBindings}) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := checkDerefVar(var_glojure_DOT_core_apply) + tmp30 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp31 := checkDerefVar(var_glojure_DOT_core_seq) + tmp32 := checkDerefVar(var_glojure_DOT_core_concat) + tmp33 := lang.Apply(tmp32, nil) + tmp34 := lang.Apply(tmp31, []any{tmp33}) + tmp35 := lang.Apply(tmp29, []any{tmp30, tmp34}) + tmp36 := lang.Apply(tmp28, []any{tmp35}) + tmp37 := lang.Apply(tmp25, []any{tmp27, tmp36}) + tmp38 := lang.Apply(tmp24, []any{tmp37}) + tmp39 := lang.Apply(tmp23, []any{tmp38}) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := checkDerefVar(var_glojure_DOT_core_seq) + tmp42 := checkDerefVar(var_glojure_DOT_core_concat) + tmp43 := checkDerefVar(var_glojure_DOT_core_list) + tmp44 := lang.Apply(tmp43, []any{sym_try}) + tmp45 := checkDerefVar(var_glojure_DOT_core_list) + tmp46 := checkDerefVar(var_glojure_DOT_core_seq) + tmp47 := checkDerefVar(var_glojure_DOT_core_concat) + tmp48 := checkDerefVar(var_glojure_DOT_core_list) + tmp49 := lang.Apply(tmp48, []any{sym_finally}) + tmp50 := checkDerefVar(var_glojure_DOT_core_list) + tmp51 := checkDerefVar(var_glojure_DOT_core_seq) + tmp52 := checkDerefVar(var_glojure_DOT_core_concat) + tmp53 := checkDerefVar(var_glojure_DOT_core_list) + tmp54 := lang.Apply(tmp53, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_PopThreadBindings}) + tmp55 := lang.Apply(tmp52, []any{tmp54}) + tmp56 := lang.Apply(tmp51, []any{tmp55}) + tmp57 := lang.Apply(tmp50, []any{tmp56}) + tmp58 := lang.Apply(tmp47, []any{tmp49, tmp57}) + tmp59 := lang.Apply(tmp46, []any{tmp58}) + tmp60 := lang.Apply(tmp45, []any{tmp59}) + tmp61 := lang.Apply(tmp42, []any{tmp44, v4, tmp60}) + tmp62 := lang.Apply(tmp41, []any{tmp61}) + tmp63 := lang.Apply(tmp40, []any{tmp62}) + tmp64 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp22, tmp39, tmp63}) + tmp65 := lang.Apply(tmp8, []any{tmp64}) + tmp66 := lang.Apply(tmp7, []any{tmp65}) + tmp67 := lang.Apply(tmp6, []any{tmp66}) + tmp68 := lang.Apply(tmp5, []any{tmp67}) + return tmp68 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_with_DASH_loading_DASH_context = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_with_DASH_loading_DASH_context.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // with-open + { + tmp0 := sym_with_DASH_open.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "bindings => [name init ...]\n\n Evaluates body in a try expression with names bound to the values\n of the inits, and a finally clause that calls (.close name) on each\n name in reverse order.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(11), kw_line, int(3832), kw_end_DASH_line, int(3832))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v4}) + if lang.IsTruthy(tmp8) { + } else { + tmp9 := checkDerefVar(var_glojure_DOT_core_str) + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp13 := checkDerefVar(var_glojure_DOT_core_meta) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(kw_line, []any{tmp14}) + tmp16 := lang.Apply(tmp9, []any{tmp11, " requires ", "a vector for its binding", " in ", tmp12, ":", tmp15}) + tmp17 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp16}) + panic(tmp17) + } + _ = tmp6 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_even_QMARK_) + tmp20 := checkDerefVar(var_glojure_DOT_core_count) + tmp21 := lang.Apply(tmp20, []any{v4}) + tmp22 := lang.Apply(tmp19, []any{tmp21}) + if lang.IsTruthy(tmp22) { + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp27 := checkDerefVar(var_glojure_DOT_core_meta) + tmp28 := lang.Apply(tmp27, []any{v2}) + tmp29 := lang.Apply(kw_line, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp25, " requires ", "an even number of forms in binding vector", " in ", tmp26, ":", tmp29}) + tmp31 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp31) + } + _ = tmp18 + var tmp32 any + tmp33 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp34 := checkDerefVar(var_glojure_DOT_core_count) + tmp35 := lang.Apply(tmp34, []any{v4}) + tmp36 := lang.Apply(tmp33, []any{tmp35, int64(0)}) + if lang.IsTruthy(tmp36) { + tmp37 := checkDerefVar(var_glojure_DOT_core_seq) + tmp38 := checkDerefVar(var_glojure_DOT_core_concat) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := lang.Apply(tmp39, []any{sym_do}) + tmp41 := lang.Apply(tmp38, []any{tmp40, v5}) + tmp42 := lang.Apply(tmp37, []any{tmp41}) + tmp32 = tmp42 + } else { + var tmp43 any + tmp44 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp45 := lang.Apply(v4, []any{int64(0)}) + tmp46 := lang.Apply(tmp44, []any{tmp45}) + if lang.IsTruthy(tmp46) { + tmp47 := checkDerefVar(var_glojure_DOT_core_seq) + tmp48 := checkDerefVar(var_glojure_DOT_core_concat) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) + tmp50 := lang.Apply(tmp49, []any{sym_glojure_DOT_core_SLASH_let}) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := checkDerefVar(var_glojure_DOT_core_subvec) + tmp53 := lang.Apply(tmp52, []any{v4, int64(0), int64(2)}) + tmp54 := lang.Apply(tmp51, []any{tmp53}) + tmp55 := checkDerefVar(var_glojure_DOT_core_list) + tmp56 := checkDerefVar(var_glojure_DOT_core_seq) + tmp57 := checkDerefVar(var_glojure_DOT_core_concat) + tmp58 := checkDerefVar(var_glojure_DOT_core_list) + tmp59 := lang.Apply(tmp58, []any{sym_try}) + tmp60 := checkDerefVar(var_glojure_DOT_core_list) + tmp61 := checkDerefVar(var_glojure_DOT_core_seq) + tmp62 := checkDerefVar(var_glojure_DOT_core_concat) + tmp63 := checkDerefVar(var_glojure_DOT_core_list) + tmp64 := lang.Apply(tmp63, []any{sym_glojure_DOT_core_SLASH_with_DASH_open}) + tmp65 := checkDerefVar(var_glojure_DOT_core_list) + tmp66 := checkDerefVar(var_glojure_DOT_core_subvec) + tmp67 := lang.Apply(tmp66, []any{v4, int64(2)}) + tmp68 := lang.Apply(tmp65, []any{tmp67}) + tmp69 := lang.Apply(tmp62, []any{tmp64, tmp68, v5}) + tmp70 := lang.Apply(tmp61, []any{tmp69}) + tmp71 := lang.Apply(tmp60, []any{tmp70}) + tmp72 := checkDerefVar(var_glojure_DOT_core_list) + tmp73 := checkDerefVar(var_glojure_DOT_core_seq) + tmp74 := checkDerefVar(var_glojure_DOT_core_concat) + tmp75 := checkDerefVar(var_glojure_DOT_core_list) + tmp76 := lang.Apply(tmp75, []any{sym_finally}) + tmp77 := checkDerefVar(var_glojure_DOT_core_list) + tmp78 := checkDerefVar(var_glojure_DOT_core_seq) + tmp79 := checkDerefVar(var_glojure_DOT_core_concat) + tmp80 := checkDerefVar(var_glojure_DOT_core_list) + tmp81 := lang.Apply(tmp80, []any{sym__DOT_}) + tmp82 := checkDerefVar(var_glojure_DOT_core_list) + tmp83 := lang.Apply(v4, []any{int64(0)}) + tmp84 := lang.Apply(tmp82, []any{tmp83}) + tmp85 := checkDerefVar(var_glojure_DOT_core_list) + tmp86 := lang.Apply(tmp85, []any{sym_close}) + tmp87 := lang.Apply(tmp79, []any{tmp81, tmp84, tmp86}) + tmp88 := lang.Apply(tmp78, []any{tmp87}) + tmp89 := lang.Apply(tmp77, []any{tmp88}) + tmp90 := lang.Apply(tmp74, []any{tmp76, tmp89}) + tmp91 := lang.Apply(tmp73, []any{tmp90}) + tmp92 := lang.Apply(tmp72, []any{tmp91}) + tmp93 := lang.Apply(tmp57, []any{tmp59, tmp71, tmp92}) + tmp94 := lang.Apply(tmp56, []any{tmp93}) + tmp95 := lang.Apply(tmp55, []any{tmp94}) + tmp96 := lang.Apply(tmp48, []any{tmp50, tmp54, tmp95}) + tmp97 := lang.Apply(tmp47, []any{tmp96}) + tmp43 = tmp97 + } else { + var tmp98 any + if lang.IsTruthy(kw_else) { + tmp99 := lang.Apply(lang.NewIllegalArgumentError, []any{"with-open only allows Symbols in bindings"}) + panic(tmp99) + } else { + } + tmp43 = tmp98 + } + tmp32 = tmp43 + } + return tmp32 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_with_DASH_open = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_with_DASH_open.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // with-out-str + { + tmp0 := sym_with_DASH_out_DASH_str.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_body)), kw_doc, "Evaluates exprs in a context in which *out* is bound to a fresh\n StringWriter. Returns the string created by any nested printing\n calls.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(22), kw_column, int(11), kw_line, int(4738), kw_end_DASH_line, int(4738))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym_glojure_DOT_core_SLASH_let}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := checkDerefVar(var_glojure_DOT_core_apply) + tmp11 := checkDerefVar(var_glojure_DOT_core_vector) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_s__0__auto__}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := checkDerefVar(var_glojure_DOT_core_seq) + tmp18 := checkDerefVar(var_glojure_DOT_core_concat) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{sym_new}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{sym_strings_DOT_Builder}) + tmp23 := lang.Apply(tmp18, []any{tmp20, tmp22}) + tmp24 := lang.Apply(tmp17, []any{tmp23}) + tmp25 := lang.Apply(tmp16, []any{tmp24}) + tmp26 := lang.Apply(tmp13, []any{tmp15, tmp25}) + tmp27 := lang.Apply(tmp12, []any{tmp26}) + tmp28 := lang.Apply(tmp10, []any{tmp11, tmp27}) + tmp29 := lang.Apply(tmp9, []any{tmp28}) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := checkDerefVar(var_glojure_DOT_core_seq) + tmp32 := checkDerefVar(var_glojure_DOT_core_concat) + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{sym_glojure_DOT_core_SLASH_binding}) + tmp35 := checkDerefVar(var_glojure_DOT_core_list) + tmp36 := checkDerefVar(var_glojure_DOT_core_apply) + tmp37 := checkDerefVar(var_glojure_DOT_core_vector) + tmp38 := checkDerefVar(var_glojure_DOT_core_seq) + tmp39 := checkDerefVar(var_glojure_DOT_core_concat) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{sym_glojure_DOT_core_SLASH__STAR_out_STAR_}) + tmp42 := checkDerefVar(var_glojure_DOT_core_list) + tmp43 := lang.Apply(tmp42, []any{sym_s__0__auto__}) + tmp44 := lang.Apply(tmp39, []any{tmp41, tmp43}) + tmp45 := lang.Apply(tmp38, []any{tmp44}) + tmp46 := lang.Apply(tmp36, []any{tmp37, tmp45}) + tmp47 := lang.Apply(tmp35, []any{tmp46}) + tmp48 := checkDerefVar(var_glojure_DOT_core_list) + tmp49 := checkDerefVar(var_glojure_DOT_core_seq) + tmp50 := checkDerefVar(var_glojure_DOT_core_concat) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := lang.Apply(tmp51, []any{sym_glojure_DOT_core_SLASH_str}) + tmp53 := checkDerefVar(var_glojure_DOT_core_list) + tmp54 := lang.Apply(tmp53, []any{sym_s__0__auto__}) + tmp55 := lang.Apply(tmp50, []any{tmp52, tmp54}) + tmp56 := lang.Apply(tmp49, []any{tmp55}) + tmp57 := lang.Apply(tmp48, []any{tmp56}) + tmp58 := lang.Apply(tmp32, []any{tmp34, tmp47, v4, tmp57}) + tmp59 := lang.Apply(tmp31, []any{tmp58}) + tmp60 := lang.Apply(tmp30, []any{tmp59}) + tmp61 := lang.Apply(tmp6, []any{tmp8, tmp29, tmp60}) + tmp62 := lang.Apply(tmp5, []any{tmp61}) + return tmp62 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_with_DASH_out_DASH_str = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_with_DASH_out_DASH_str.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // with-precision + { + tmp0 := sym_with_DASH_precision.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_precision, sym__AMP_, sym_exprs)), kw_doc, "Sets the precision and rounding mode to be used for BigDecimal operations.\n\n Usage: (with-precision 10 (/ 1M 3))\n or: (with-precision 10 :rounding HALF_DOWN (/ 1M 3))\n\n The rounding mode is one of CEILING, FLOOR, HALF_UP, HALF_DOWN,\n HALF_EVEN, UP, DOWN and UNNECESSARY; it defaults to HALF_UP.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(24), kw_column, int(11), kw_line, int(5110), kw_end_DASH_line, int(5110))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "vec__756" + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp9 := checkDerefVar(var_glojure_DOT_core_first) + tmp10 := lang.Apply(tmp9, []any{v5}) + tmp11 := lang.Apply(tmp8, []any{tmp10, kw_rounding}) + if lang.IsTruthy(tmp11) { + tmp12 := checkDerefVar(var_glojure_DOT_core_next) + tmp13 := checkDerefVar(var_glojure_DOT_core_next) + tmp14 := lang.Apply(tmp13, []any{v5}) + tmp15 := lang.Apply(tmp12, []any{tmp14}) + tmp16 := checkDerefVar(var_glojure_DOT_core_seq) + tmp17 := checkDerefVar(var_glojure_DOT_core_concat) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := checkDerefVar(var_glojure_DOT_core_seq) + tmp20 := checkDerefVar(var_glojure_DOT_core_concat) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{sym__DOT_}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := lang.Apply(tmp23, []any{sym_java_DOT_math_DOT_RoundingMode}) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := checkDerefVar(var_glojure_DOT_core_second) + tmp27 := lang.Apply(tmp26, []any{v5}) + tmp28 := lang.Apply(tmp25, []any{tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp22, tmp24, tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp18, []any{tmp30}) + tmp32 := lang.Apply(tmp17, []any{tmp31}) + tmp33 := lang.Apply(tmp16, []any{tmp32}) + tmp34 := lang.NewVector(tmp15, tmp33) + tmp35 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5121), kw_column, int(23), kw_end_DASH_line, int(5122), kw_end_DASH_column, int(69)) + tmp36, err := lang.WithMeta(tmp34, tmp35.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp7 = tmp36 + } else { + tmp37 := lang.NewVector(v5, nil) + tmp38 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5123), kw_column, int(23), kw_end_DASH_line, int(5123), kw_end_DASH_column, int(33)) + tmp39, err := lang.WithMeta(tmp37, tmp38.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp7 = tmp39 + } + var v40 any = tmp7 + _ = v40 + // let binding "body" + tmp41 := checkDerefVar(var_glojure_DOT_core_nth) + tmp42 := lang.Apply(tmp41, []any{v40, int64(0), nil}) + var v43 any = tmp42 + _ = v43 + // let binding "rm" + tmp44 := checkDerefVar(var_glojure_DOT_core_nth) + tmp45 := lang.Apply(tmp44, []any{v40, int64(1), nil}) + var v46 any = tmp45 + _ = v46 + tmp47 := checkDerefVar(var_glojure_DOT_core_seq) + tmp48 := checkDerefVar(var_glojure_DOT_core_concat) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) + tmp50 := lang.Apply(tmp49, []any{sym_glojure_DOT_core_SLASH_binding}) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := checkDerefVar(var_glojure_DOT_core_apply) + tmp53 := checkDerefVar(var_glojure_DOT_core_vector) + tmp54 := checkDerefVar(var_glojure_DOT_core_seq) + tmp55 := checkDerefVar(var_glojure_DOT_core_concat) + tmp56 := checkDerefVar(var_glojure_DOT_core_list) + tmp57 := lang.Apply(tmp56, []any{sym_glojure_DOT_core_SLASH__STAR_math_DASH_context_STAR_}) + tmp58 := checkDerefVar(var_glojure_DOT_core_list) + tmp59 := checkDerefVar(var_glojure_DOT_core_seq) + tmp60 := checkDerefVar(var_glojure_DOT_core_concat) + tmp61 := checkDerefVar(var_glojure_DOT_core_list) + tmp62 := lang.Apply(tmp61, []any{sym_java_DOT_math_DOT_MathContext_DOT_}) + tmp63 := checkDerefVar(var_glojure_DOT_core_list) + tmp64 := lang.Apply(tmp63, []any{v4}) + tmp65 := lang.Apply(tmp60, []any{tmp62, tmp64, v46}) + tmp66 := lang.Apply(tmp59, []any{tmp65}) + tmp67 := lang.Apply(tmp58, []any{tmp66}) + tmp68 := lang.Apply(tmp55, []any{tmp57, tmp67}) + tmp69 := lang.Apply(tmp54, []any{tmp68}) + tmp70 := lang.Apply(tmp52, []any{tmp53, tmp69}) + tmp71 := lang.Apply(tmp51, []any{tmp70}) + tmp72 := lang.Apply(tmp48, []any{tmp50, tmp71, v43}) + tmp73 := lang.Apply(tmp47, []any{tmp72}) + tmp6 = tmp73 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_with_DASH_precision = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_with_DASH_precision.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // with-redefs + { + tmp0 := sym_with_DASH_redefs.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "binding => var-symbol temp-value-expr\n\n Temporarily redefines Vars while executing the body. The\n temp-value-exprs will be evaluated and each resulting value will\n replace in parallel the root value of its Var. After the body is\n executed, the root values of all the Vars will be set back to their\n old values. These temporary changes will be visible in all threads.\n Useful for mocking out functions during testing.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(11), kw_line, int(7544), kw_end_DASH_line, int(7544))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_with_DASH_redefs_DASH_fn}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_zipmap) + tmp12 := checkDerefVar(var_glojure_DOT_core_map) + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v14 := args[0] + _ = v14 + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_var, v14}) + return tmp16 + }) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7555), kw_column, int(34), kw_end_DASH_line, int(7555), kw_end_DASH_column, int(47)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp16 := checkDerefVar(var_glojure_DOT_core_take_DASH_nth) + tmp17 := lang.Apply(tmp16, []any{int64(2), v4}) + tmp18 := lang.Apply(tmp12, []any{tmp15, tmp17}) + tmp19 := checkDerefVar(var_glojure_DOT_core_take_DASH_nth) + tmp20 := checkDerefVar(var_glojure_DOT_core_next) + tmp21 := lang.Apply(tmp20, []any{v4}) + tmp22 := lang.Apply(tmp19, []any{int64(2), tmp21}) + tmp23 := lang.Apply(tmp11, []any{tmp18, tmp22}) + tmp24 := lang.Apply(tmp10, []any{tmp23}) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := checkDerefVar(var_glojure_DOT_core_seq) + tmp27 := checkDerefVar(var_glojure_DOT_core_concat) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := lang.Apply(tmp28, []any{sym_glojure_DOT_core_SLASH_fn}) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := checkDerefVar(var_glojure_DOT_core_apply) + tmp32 := checkDerefVar(var_glojure_DOT_core_vector) + tmp33 := checkDerefVar(var_glojure_DOT_core_seq) + tmp34 := checkDerefVar(var_glojure_DOT_core_concat) + tmp35 := lang.Apply(tmp34, nil) + tmp36 := lang.Apply(tmp33, []any{tmp35}) + tmp37 := lang.Apply(tmp31, []any{tmp32, tmp36}) + tmp38 := lang.Apply(tmp30, []any{tmp37}) + tmp39 := lang.Apply(tmp27, []any{tmp29, tmp38, v5}) + tmp40 := lang.Apply(tmp26, []any{tmp39}) + tmp41 := lang.Apply(tmp25, []any{tmp40}) + tmp42 := lang.Apply(tmp7, []any{tmp9, tmp24, tmp41}) + tmp43 := lang.Apply(tmp6, []any{tmp42}) + return tmp43 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_with_DASH_redefs = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_with_DASH_redefs.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // with-redefs-fn + { + tmp0 := sym_with_DASH_redefs_DASH_fn.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_binding_DASH_map, sym_func)), kw_doc, "Temporarily redefines Vars during a call to func. Each val of\n binding-map will replace the root value of its key which must be\n a Var. After func is called with no args, the root values of all\n the Vars will be set back to their old values. These temporary\n changes will be visible in all threads. Useful for mocking out\n functions during testing.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(7524), kw_end_DASH_line, int(7524))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "root-bind" + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v6 := args[0] + _ = v6 + var tmp7 any + { // let + // let binding "seq_664" + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := lang.Apply(tmp8, []any{v6}) + var v10 any = tmp9 + _ = v10 + // let binding "chunk_665" + var v11 any = nil + _ = v11 + // let binding "count_666" + var v12 any = int64(0) + _ = v12 + // let binding "i_667" + var v13 any = int64(0) + _ = v13 + for { + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp16 := lang.Apply(tmp15, []any{v13, v12}) + if lang.IsTruthy(tmp16) { + var tmp17 any + { // let + // let binding "vec__668" + tmp18, _ := lang.FieldOrMethod(v11, "nth") + if reflect.TypeOf(tmp18).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp19 := lang.Apply(tmp18, []any{v13}) + var v20 any = tmp19 + _ = v20 + // let binding "a-var" + tmp21 := checkDerefVar(var_glojure_DOT_core_nth) + tmp22 := lang.Apply(tmp21, []any{v20, int64(0), nil}) + var v23 any = tmp22 + _ = v23 + // let binding "a-val" + tmp24 := checkDerefVar(var_glojure_DOT_core_nth) + tmp25 := lang.Apply(tmp24, []any{v20, int64(1), nil}) + var v26 any = tmp25 + _ = v26 + tmp27, _ := lang.FieldOrMethod(v23, "bindRoot") + if reflect.TypeOf(tmp27).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("bindRoot is not a function"))) + } + tmp28 := lang.Apply(tmp27, []any{v26}) + _ = tmp28 + var tmp29 any = v10 + var tmp30 any = v11 + var tmp31 any = v12 + tmp33 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp34 := lang.Apply(tmp33, []any{v13}) + var tmp32 any = tmp34 + v10 = tmp29 + v11 = tmp30 + v12 = tmp31 + v13 = tmp32 + continue + } // end let + tmp14 = tmp17 + } else { + var tmp18 any + { // let + // let binding "temp__0__auto__" + tmp19 := checkDerefVar(var_glojure_DOT_core_seq) + tmp20 := lang.Apply(tmp19, []any{v10}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + if lang.IsTruthy(v21) { + var tmp23 any + { // let + // let binding "seq_664" + var v24 any = v21 + _ = v24 + var tmp25 any + tmp26 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp27 := lang.Apply(tmp26, []any{v24}) + if lang.IsTruthy(tmp27) { + var tmp28 any + { // let + // let binding "c__0__auto__" + tmp29 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp30 := lang.Apply(tmp29, []any{v24}) + var v31 any = tmp30 + _ = v31 + tmp33 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp34 := lang.Apply(tmp33, []any{v24}) + var tmp32 any = tmp34 + var tmp35 any = v31 + tmp37 := checkDerefVar(var_glojure_DOT_core_int) + tmp38 := checkDerefVar(var_glojure_DOT_core_count) + tmp39 := lang.Apply(tmp38, []any{v31}) + tmp40 := lang.Apply(tmp37, []any{tmp39}) + var tmp36 any = tmp40 + tmp42 := checkDerefVar(var_glojure_DOT_core_int) + tmp43 := lang.Apply(tmp42, []any{int64(0)}) + var tmp41 any = tmp43 + v10 = tmp32 + v11 = tmp35 + v12 = tmp36 + v13 = tmp41 + continue + } // end let + tmp25 = tmp28 + } else { + var tmp29 any + { // let + // let binding "vec__671" + tmp30 := checkDerefVar(var_glojure_DOT_core_first) + tmp31 := lang.Apply(tmp30, []any{v24}) + var v32 any = tmp31 + _ = v32 + // let binding "a-var" + tmp33 := checkDerefVar(var_glojure_DOT_core_nth) + tmp34 := lang.Apply(tmp33, []any{v32, int64(0), nil}) + var v35 any = tmp34 + _ = v35 + // let binding "a-val" + tmp36 := checkDerefVar(var_glojure_DOT_core_nth) + tmp37 := lang.Apply(tmp36, []any{v32, int64(1), nil}) + var v38 any = tmp37 + _ = v38 + tmp39, _ := lang.FieldOrMethod(v35, "bindRoot") + if reflect.TypeOf(tmp39).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("bindRoot is not a function"))) + } + tmp40 := lang.Apply(tmp39, []any{v38}) + _ = tmp40 + tmp42 := checkDerefVar(var_glojure_DOT_core_next) + tmp43 := lang.Apply(tmp42, []any{v24}) + var tmp41 any = tmp43 + var tmp44 any = nil + var tmp45 any = int64(0) + var tmp46 any = int64(0) + v10 = tmp41 + v11 = tmp44 + v12 = tmp45 + v13 = tmp46 + continue + } // end let + tmp25 = tmp29 + } + tmp23 = tmp25 + } // end let + tmp22 = tmp23 + } else { + } + tmp18 = tmp22 + } // end let + tmp14 = tmp18 + } + tmp7 = tmp14 + break + } + } // end let + return tmp7 + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7533), kw_column, int(19), kw_end_DASH_line, int(7535), kw_end_DASH_column, int(93)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v8 any = tmp7 + _ = v8 + // let binding "old-vals" + tmp9 := checkDerefVar(var_glojure_DOT_core_zipmap) + tmp10 := checkDerefVar(var_glojure_DOT_core_keys) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := checkDerefVar(var_glojure_DOT_core_map) + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v14 := args[0] + _ = v14 + tmp15, ok := lang.FieldOrMethod(v14, "getRawRoot") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v14, "getRawRoot"))) + } + var tmp16 any + switch reflect.TypeOf(tmp15).Kind() { + case reflect.Func: + tmp16 = lang.Apply(tmp15, nil) + default: + tmp16 = tmp15 + } + return tmp16 + }) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7537), kw_column, int(31), kw_end_DASH_line, int(7537), kw_end_DASH_column, int(92)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp16 := checkDerefVar(var_glojure_DOT_core_keys) + tmp17 := lang.Apply(tmp16, []any{v2}) + tmp18 := lang.Apply(tmp12, []any{tmp15, tmp17}) + tmp19 := lang.Apply(tmp9, []any{tmp11, tmp18}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + func() { + defer func() { + tmp22 := lang.Apply(v8, []any{v20}) + _ = tmp22 + }() + tmp23 := lang.Apply(v8, []any{v2}) + _ = tmp23 + tmp24 := lang.Apply(v3, nil) + tmp21 = tmp24 + }() + tmp4 = tmp21 + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_with_DASH_redefs_DASH_fn = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_with_DASH_redefs_DASH_fn.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // - + { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed6 + } else { + tmp4 = closed7 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed6 + } else { + tmp5 = closed7 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed6 + } else { + tmp6 = closed7 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(0)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym__DASH_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "If no ys are supplied, returns the negation of x, else subtracts\n the ys from x and returns the result. Does not auto-promote\n longs, will throw on overflow. See also: -'", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(7), kw_line, int(1036), kw_end_DASH_line, int(1036))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_) + tmp6 := lang.Apply(tmp5, []any{int64(-1), v4}) + return tmp6 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Minus") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Minus is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp8 := checkDerefVar(var_glojure_DOT_core__DASH_) + tmp9 := checkDerefVar(var_glojure_DOT_core__DASH_) + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) + return tmp11 + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__DASH_ = ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__DASH_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // -' + { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed8 + } else { + tmp4 = closed8 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed8 + } else { + tmp5 = closed8 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed8 + } else { + tmp6 = closed8 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(0)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym__DASH__TICK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "If no ys are supplied, returns the negation of x, else subtracts\n the ys from x and returns the result. Supports arbitrary precision.\n See also: -", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(7), kw_line, int(1024), kw_end_DASH_line, int(1024))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR__TICK_) + tmp6 := lang.Apply(tmp5, []any{int64(-1), v4}) + return tmp6 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "MinusP") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("MinusP is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp8 := checkDerefVar(var_glojure_DOT_core__DASH__TICK_) + tmp9 := checkDerefVar(var_glojure_DOT_core__DASH__TICK_) + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) + return tmp11 + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__DASH__TICK_ = ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__DASH__TICK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // agent + { + tmp0 := sym_agent.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_state, sym__AMP_, sym_options)), kw_doc, "Creates and returns an agent with an initial value of state and\n zero or more options (in any order):\n\n :meta metadata-map\n\n :validator validate-fn\n\n :error-handler handler-fn\n\n :error-mode mode-keyword\n\n If metadata-map is supplied, it will become the metadata on the\n agent. validate-fn must be nil or a side-effect-free fn of one\n argument, which will be passed the intended new state on any state\n change. If the new state is unacceptable, the validate-fn should\n return false or throw an exception. handler-fn is called if an\n action throws an exception or if validate-fn rejects a new state --\n see set-error-handler! for details. The mode-keyword may be either\n :continue (the default if an error-handler is given) or :fail (the\n default if no error-handler is given) -- see set-error-mode! for\n details.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(2052), kw_end_DASH_line, int(2052))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + var tmp4 any + { // let + // let binding "a" + var v5 any = "unimplemented: new with non-constant class type" + _ = v5 + // let binding "opts" + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) + var v9 any = tmp8 + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_setup_DASH_reference) + tmp11 := lang.Apply(tmp10, []any{v5, v3}) + _ = tmp11 + var tmp12 any + tmp13 := lang.Apply(kw_error_DASH_handler, []any{v9}) + if lang.IsTruthy(tmp13) { + tmp14 := lang.Apply(kw_error_DASH_handler, []any{v9}) + tmp15, _ := lang.FieldOrMethod(v5, "setErrorHandler") + if reflect.TypeOf(tmp15).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorHandler is not a function"))) + } + tmp16 := lang.Apply(tmp15, []any{tmp14}) + tmp12 = tmp16 + } else { + } + _ = tmp12 + var tmp17 any + { // let + // let binding "or__0__auto__" + tmp18 := lang.Apply(kw_error_DASH_mode, []any{v9}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + tmp20 = v19 + } else { + var tmp21 any + tmp22 := lang.Apply(kw_error_DASH_handler, []any{v9}) + if lang.IsTruthy(tmp22) { + tmp21 = kw_continue + } else { + tmp21 = kw_fail + } + tmp20 = tmp21 + } + tmp17 = tmp20 + } // end let + tmp18, _ := lang.FieldOrMethod(v5, "setErrorMode") + if reflect.TypeOf(tmp18).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorMode is not a function"))) + } + tmp19 := lang.Apply(tmp18, []any{tmp17}) + _ = tmp19 + tmp4 = v5 + } // end let + return tmp4 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_agent = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_agent.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // aget + { + var tmp1 lang.FnFunc + { // function aget__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Aget}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := checkDerefVar(var_glojure_DOT_core_seq) + tmp20 := checkDerefVar(var_glojure_DOT_core_concat) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{sym_glojure_DOT_core_SLASH_int}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := lang.Apply(tmp23, []any{v4}) + tmp25 := lang.Apply(tmp20, []any{tmp22, tmp24}) + tmp26 := lang.Apply(tmp19, []any{tmp25}) + tmp27 := lang.Apply(tmp18, []any{tmp26}) + tmp28 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp27}) + tmp29 := lang.Apply(tmp12, []any{tmp28}) + tmp30 := lang.Apply(tmp11, []any{tmp29}) + tmp31 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp30}) + tmp32 := lang.Apply(tmp5, []any{tmp31}) + return tmp32 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_aget.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx), lang.NewVector(sym_array, sym_idx, sym__AMP_, sym_idxs)), kw_inline, tmp1, kw_doc, "Returns the value at the index/indices. Works on Java arrays of all\n types.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3911), kw_end_DASH_line, int(3911))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(lang.Get, []any{v3, v4}) + return tmp5 + default: + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_aget) + tmp8 := checkDerefVar(var_glojure_DOT_core_aget) + tmp9 := lang.Apply(tmp8, []any{v3, v4}) + tmp10 := lang.Apply(tmp6, []any{tmp7, tmp9, v5}) + return tmp10 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_aget = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_aget.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // amap + { + tmp0 := sym_amap.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_a, sym_idx, sym_ret, sym_expr)), kw_doc, "Maps an expression across an array a, using an index named idx, and\n return value named ret, initialized to a clone of a, then setting \n each element of ret to the evaluation of expr, returning the new \n array ret.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(11), kw_line, int(5273), kw_end_DASH_line, int(5273))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 6) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + v7 := args[5] + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_let}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_apply) + tmp14 := checkDerefVar(var_glojure_DOT_core_vector) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_a__0__auto__}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v4}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{sym_l__1__auto__}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_seq) + tmp25 := checkDerefVar(var_glojure_DOT_core_concat) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{sym_glojure_DOT_core_SLASH_alength}) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := lang.Apply(tmp28, []any{sym_a__0__auto__}) + tmp30 := lang.Apply(tmp25, []any{tmp27, tmp29}) + tmp31 := lang.Apply(tmp24, []any{tmp30}) + tmp32 := lang.Apply(tmp23, []any{tmp31}) + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{v6}) + tmp35 := checkDerefVar(var_glojure_DOT_core_list) + tmp36 := checkDerefVar(var_glojure_DOT_core_seq) + tmp37 := checkDerefVar(var_glojure_DOT_core_concat) + tmp38 := checkDerefVar(var_glojure_DOT_core_list) + tmp39 := lang.Apply(tmp38, []any{sym_glojure_DOT_core_SLASH_aclone}) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{sym_a__0__auto__}) + tmp42 := lang.Apply(tmp37, []any{tmp39, tmp41}) + tmp43 := lang.Apply(tmp36, []any{tmp42}) + tmp44 := lang.Apply(tmp35, []any{tmp43}) + tmp45 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22, tmp32, tmp34, tmp44}) + tmp46 := lang.Apply(tmp15, []any{tmp45}) + tmp47 := lang.Apply(tmp13, []any{tmp14, tmp46}) + tmp48 := lang.Apply(tmp12, []any{tmp47}) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) + tmp50 := checkDerefVar(var_glojure_DOT_core_seq) + tmp51 := checkDerefVar(var_glojure_DOT_core_concat) + tmp52 := checkDerefVar(var_glojure_DOT_core_list) + tmp53 := lang.Apply(tmp52, []any{sym_glojure_DOT_core_SLASH_loop}) + tmp54 := checkDerefVar(var_glojure_DOT_core_list) + tmp55 := checkDerefVar(var_glojure_DOT_core_apply) + tmp56 := checkDerefVar(var_glojure_DOT_core_vector) + tmp57 := checkDerefVar(var_glojure_DOT_core_seq) + tmp58 := checkDerefVar(var_glojure_DOT_core_concat) + tmp59 := checkDerefVar(var_glojure_DOT_core_list) + tmp60 := lang.Apply(tmp59, []any{v5}) + tmp61 := checkDerefVar(var_glojure_DOT_core_list) + tmp62 := lang.Apply(tmp61, []any{int64(0)}) + tmp63 := lang.Apply(tmp58, []any{tmp60, tmp62}) + tmp64 := lang.Apply(tmp57, []any{tmp63}) + tmp65 := lang.Apply(tmp55, []any{tmp56, tmp64}) + tmp66 := lang.Apply(tmp54, []any{tmp65}) + tmp67 := checkDerefVar(var_glojure_DOT_core_list) + tmp68 := checkDerefVar(var_glojure_DOT_core_seq) + tmp69 := checkDerefVar(var_glojure_DOT_core_concat) + tmp70 := checkDerefVar(var_glojure_DOT_core_list) + tmp71 := lang.Apply(tmp70, []any{sym_if}) + tmp72 := checkDerefVar(var_glojure_DOT_core_list) + tmp73 := checkDerefVar(var_glojure_DOT_core_seq) + tmp74 := checkDerefVar(var_glojure_DOT_core_concat) + tmp75 := checkDerefVar(var_glojure_DOT_core_list) + tmp76 := lang.Apply(tmp75, []any{sym_glojure_DOT_core_SLASH__LT_}) + tmp77 := checkDerefVar(var_glojure_DOT_core_list) + tmp78 := lang.Apply(tmp77, []any{v5}) + tmp79 := checkDerefVar(var_glojure_DOT_core_list) + tmp80 := lang.Apply(tmp79, []any{sym_l__1__auto__}) + tmp81 := lang.Apply(tmp74, []any{tmp76, tmp78, tmp80}) + tmp82 := lang.Apply(tmp73, []any{tmp81}) + tmp83 := lang.Apply(tmp72, []any{tmp82}) + tmp84 := checkDerefVar(var_glojure_DOT_core_list) + tmp85 := checkDerefVar(var_glojure_DOT_core_seq) + tmp86 := checkDerefVar(var_glojure_DOT_core_concat) + tmp87 := checkDerefVar(var_glojure_DOT_core_list) + tmp88 := lang.Apply(tmp87, []any{sym_do}) + tmp89 := checkDerefVar(var_glojure_DOT_core_list) + tmp90 := checkDerefVar(var_glojure_DOT_core_seq) + tmp91 := checkDerefVar(var_glojure_DOT_core_concat) + tmp92 := checkDerefVar(var_glojure_DOT_core_list) + tmp93 := lang.Apply(tmp92, []any{sym_glojure_DOT_core_SLASH_aset}) + tmp94 := checkDerefVar(var_glojure_DOT_core_list) + tmp95 := lang.Apply(tmp94, []any{v6}) + tmp96 := checkDerefVar(var_glojure_DOT_core_list) + tmp97 := lang.Apply(tmp96, []any{v5}) + tmp98 := checkDerefVar(var_glojure_DOT_core_list) + tmp99 := lang.Apply(tmp98, []any{v7}) + tmp100 := lang.Apply(tmp91, []any{tmp93, tmp95, tmp97, tmp99}) + tmp101 := lang.Apply(tmp90, []any{tmp100}) + tmp102 := lang.Apply(tmp89, []any{tmp101}) + tmp103 := checkDerefVar(var_glojure_DOT_core_list) + tmp104 := checkDerefVar(var_glojure_DOT_core_seq) + tmp105 := checkDerefVar(var_glojure_DOT_core_concat) + tmp106 := checkDerefVar(var_glojure_DOT_core_list) + tmp107 := lang.Apply(tmp106, []any{sym_recur}) + tmp108 := checkDerefVar(var_glojure_DOT_core_list) + tmp109 := checkDerefVar(var_glojure_DOT_core_seq) + tmp110 := checkDerefVar(var_glojure_DOT_core_concat) + tmp111 := checkDerefVar(var_glojure_DOT_core_list) + tmp112 := lang.Apply(tmp111, []any{sym_glojure_DOT_core_SLASH_unchecked_DASH_inc}) + tmp113 := checkDerefVar(var_glojure_DOT_core_list) + tmp114 := lang.Apply(tmp113, []any{v5}) + tmp115 := lang.Apply(tmp110, []any{tmp112, tmp114}) + tmp116 := lang.Apply(tmp109, []any{tmp115}) + tmp117 := lang.Apply(tmp108, []any{tmp116}) + tmp118 := lang.Apply(tmp105, []any{tmp107, tmp117}) + tmp119 := lang.Apply(tmp104, []any{tmp118}) + tmp120 := lang.Apply(tmp103, []any{tmp119}) + tmp121 := lang.Apply(tmp86, []any{tmp88, tmp102, tmp120}) + tmp122 := lang.Apply(tmp85, []any{tmp121}) + tmp123 := lang.Apply(tmp84, []any{tmp122}) + tmp124 := checkDerefVar(var_glojure_DOT_core_list) + tmp125 := lang.Apply(tmp124, []any{v6}) + tmp126 := lang.Apply(tmp69, []any{tmp71, tmp83, tmp123, tmp125}) + tmp127 := lang.Apply(tmp68, []any{tmp126}) + tmp128 := lang.Apply(tmp67, []any{tmp127}) + tmp129 := lang.Apply(tmp51, []any{tmp53, tmp66, tmp128}) + tmp130 := lang.Apply(tmp50, []any{tmp129}) + tmp131 := lang.Apply(tmp49, []any{tmp130}) + tmp132 := lang.Apply(tmp9, []any{tmp11, tmp48, tmp131}) + tmp133 := lang.Apply(tmp8, []any{tmp132}) + return tmp133 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_amap = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_amap.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ancestors + { + tmp0 := sym_ancestors.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_tag), lang.NewVector(sym_h, sym_tag)), kw_doc, "Returns the immediate and indirect parents of tag, either via a Java type\n inheritance relationship or a relationship established via derive. h\n must be a hierarchy obtained from make-hierarchy, if not supplied\n defaults to the global hierarchy", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(5577), kw_end_DASH_line, int(5577))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_ancestors) + tmp4 := checkDerefVar(var_glojure_DOT_core_global_DASH_hierarchy) + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_not_DASH_empty) + var tmp5 any + { // let + // let binding "ta" + tmp6 := checkDerefVar(var_glojure_DOT_core_get) + tmp7 := lang.Apply(kw_ancestors, []any{v2}) + tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + tmp11 := checkDerefVar(var_glojure_DOT_core_class_QMARK_) + tmp12 := lang.Apply(tmp11, []any{v3}) + if lang.IsTruthy(tmp12) { + var tmp13 any + { // let + // let binding "superclasses" + tmp14 := checkDerefVar(var_glojure_DOT_core_set) + tmp15 := checkDerefVar(var_glojure_DOT_core_supers) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp14, []any{tmp16}) + var v18 any = tmp17 + _ = v18 + tmp19 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp20 := checkDerefVar(var_glojure_DOT_core_into1) + tmp21 := checkDerefVar(var_glojure_DOT_core_cons) + tmp22 := checkDerefVar(var_glojure_DOT_core_map) + var tmp23 lang.FnFunc + tmp23 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v24 := args[0] + _ = v24 + tmp25 := checkDerefVar(var_glojure_DOT_core_get) + tmp26 := lang.Apply(kw_ancestors, []any{v2}) + tmp27 := lang.Apply(tmp25, []any{tmp26, v24}) + return tmp27 + }) + tmp24 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5590), kw_column, int(32), kw_end_DASH_line, int(5590), kw_end_DASH_column, int(54)) + tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp26 := lang.Apply(tmp22, []any{tmp25, v18}) + tmp27 := lang.Apply(tmp21, []any{v9, tmp26}) + tmp28 := lang.Apply(tmp19, []any{tmp20, v18, tmp27}) + tmp13 = tmp28 + } // end let + tmp10 = tmp13 + } else { + tmp10 = v9 + } + tmp5 = tmp10 + } // end let + tmp6 := lang.Apply(tmp4, []any{tmp5}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ancestors = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ancestors.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // and + { + tmp0 := sym_and.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_x), lang.NewVector(sym_x, sym__AMP_, sym_next)), kw_doc, "Evaluates exprs one at a time, from left to right. If a form\n returns logical false (nil or false), and returns that value and\n doesn't evaluate any of the other expressions, otherwise it returns\n the value of the last expr. (and) returns true.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(11), kw_line, int(835), kw_end_DASH_line, int(835))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + return true + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + return v4 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_let}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + tmp12 := checkDerefVar(var_glojure_DOT_core_vector) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_and__0__auto__}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v4}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp19}) + tmp21 := lang.Apply(tmp11, []any{tmp12, tmp20}) + tmp22 := lang.Apply(tmp10, []any{tmp21}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_seq) + tmp25 := checkDerefVar(var_glojure_DOT_core_concat) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{sym_if}) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := lang.Apply(tmp28, []any{sym_and__0__auto__}) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := checkDerefVar(var_glojure_DOT_core_seq) + tmp32 := checkDerefVar(var_glojure_DOT_core_concat) + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{sym_glojure_DOT_core_SLASH_and}) + tmp35 := lang.Apply(tmp32, []any{tmp34, v5}) + tmp36 := lang.Apply(tmp31, []any{tmp35}) + tmp37 := lang.Apply(tmp30, []any{tmp36}) + tmp38 := checkDerefVar(var_glojure_DOT_core_list) + tmp39 := lang.Apply(tmp38, []any{sym_and__0__auto__}) + tmp40 := lang.Apply(tmp25, []any{tmp27, tmp29, tmp37, tmp39}) + tmp41 := lang.Apply(tmp24, []any{tmp40}) + tmp42 := lang.Apply(tmp23, []any{tmp41}) + tmp43 := lang.Apply(tmp7, []any{tmp9, tmp22, tmp42}) + tmp44 := lang.Apply(tmp6, []any{tmp43}) + return tmp44 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_and = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_and.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // array-map + { + tmp0 := sym_array_DASH_map.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym__AMP_, sym_keyvals)), kw_doc, "Constructs an array-map. If any keys are equal, they are handled as\n if by repeated uses of assoc.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(4378), kw_end_DASH_line, int(4378))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp2, ok := lang.FieldOrMethod(nil, "EMPTY") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "EMPTY"))) + } + var tmp3 any + switch reflect.TypeOf(tmp2).Kind() { + case reflect.Func: + tmp3 = lang.Apply(tmp2, nil) + default: + tmp3 = tmp2 + } + return tmp3 + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + var tmp3 any + { // let + // let binding "ary" + tmp4 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core_odd_QMARK_) + tmp9 := checkDerefVar(var_glojure_DOT_core_alength) + tmp10 := lang.Apply(tmp9, []any{v6}) + tmp11 := lang.Apply(tmp8, []any{tmp10}) + if lang.IsTruthy(tmp11) { + tmp12 := checkDerefVar(var_glojure_DOT_core_str) + tmp13 := checkDerefVar(var_glojure_DOT_core_last) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(tmp12, []any{"No value supplied for key: ", tmp14}) + tmp16 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp15}) + panic(tmp16) + } else { + tmp17 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{v6}) + tmp7 = tmp17 + } + tmp3 = tmp7 + } // end let + return tmp3 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_array_DASH_map = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_array_DASH_map.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // aset + { + var tmp1 lang.FnFunc + { // function aset__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym__DOT_}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_Aset}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{sym_glojure_DOT_core_SLASH_int}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v4}) + tmp26 := lang.Apply(tmp21, []any{tmp23, tmp25}) + tmp27 := lang.Apply(tmp20, []any{tmp26}) + tmp28 := lang.Apply(tmp19, []any{tmp27}) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{v5}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp28, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp12, []any{tmp32}) + tmp34 := lang.Apply(tmp7, []any{tmp9, tmp11, tmp33}) + tmp35 := lang.Apply(tmp6, []any{tmp34}) + return tmp35 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_aset.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx, sym_val), lang.NewVector(sym_array, sym_idx, sym_idx2, sym__AMP_, sym_idxv)), kw_inline, tmp1, kw_doc, "Sets the value at the index/indices. Works on Java arrays of\n reference types. Returns val.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(3)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3922), kw_end_DASH_line, int(3922))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6 := lang.Apply(lang.SliceSet, []any{v3, v4, v5}) + _ = tmp6 + return v5 + default: + checkArity(args, 3) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_apply) + tmp8 := checkDerefVar(var_glojure_DOT_core_aset) + tmp9 := checkDerefVar(var_glojure_DOT_core_aget) + tmp10 := lang.Apply(tmp9, []any{v3, v4}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v5, v6}) + return tmp11 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_aset = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_aset.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // aset-boolean + { + tmp0 := sym_aset_DASH_boolean.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx, sym_val), lang.NewVector(sym_array, sym_idx, sym_idx2, sym__AMP_, sym_idxv)), kw_doc, "Sets the value at the index/indices. Works on arrays of boolean. Returns val.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(3), kw_line, int(3956), kw_end_DASH_line, int(3958))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_boolean) + tmp6 := lang.Apply(tmp5, []any{v4}) + tmp7, _ := lang.FieldOrMethod(nil, "setBoolean") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setBoolean is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v2, v3, tmp6}) + _ = tmp8 + return v4 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_boolean) + tmp8 := checkDerefVar(var_glojure_DOT_core_aget) + tmp9 := lang.Apply(tmp8, []any{v2, v3}) + tmp10 := lang.Apply(tmp6, []any{tmp7, tmp9, v4, v5}) + return tmp10 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_aset_DASH_boolean = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_aset_DASH_boolean.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // aset-byte + { + tmp0 := sym_aset_DASH_byte.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx, sym_val), lang.NewVector(sym_array, sym_idx, sym_idx2, sym__AMP_, sym_idxv)), kw_doc, "Sets the value at the index/indices. Works on arrays of byte. Returns val.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(3), kw_line, int(3976), kw_end_DASH_line, int(3978))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_byte) + tmp6 := lang.Apply(tmp5, []any{v4}) + tmp7, _ := lang.FieldOrMethod(nil, "setByte") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setByte is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v2, v3, tmp6}) + _ = tmp8 + return v4 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_byte) + tmp8 := checkDerefVar(var_glojure_DOT_core_aget) + tmp9 := lang.Apply(tmp8, []any{v2, v3}) + tmp10 := lang.Apply(tmp6, []any{tmp7, tmp9, v4, v5}) + return tmp10 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_aset_DASH_byte = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_aset_DASH_byte.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // aset-char + { + tmp0 := sym_aset_DASH_char.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx, sym_val), lang.NewVector(sym_array, sym_idx, sym_idx2, sym__AMP_, sym_idxv)), kw_doc, "Sets the value at the index/indices. Works on arrays of char. Returns val.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(3), kw_line, int(3981), kw_end_DASH_line, int(3983))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_char) + tmp6 := lang.Apply(tmp5, []any{v4}) + tmp7, _ := lang.FieldOrMethod(nil, "setChar") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setChar is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v2, v3, tmp6}) + _ = tmp8 + return v4 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_char) + tmp8 := checkDerefVar(var_glojure_DOT_core_aget) + tmp9 := lang.Apply(tmp8, []any{v2, v3}) + tmp10 := lang.Apply(tmp6, []any{tmp7, tmp9, v4, v5}) + return tmp10 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_aset_DASH_char = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_aset_DASH_char.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // aset-double + { + tmp0 := sym_aset_DASH_double.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx, sym_val), lang.NewVector(sym_array, sym_idx, sym_idx2, sym__AMP_, sym_idxv)), kw_doc, "Sets the value at the index/indices. Works on arrays of double. Returns val.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(3), kw_line, int(3966), kw_end_DASH_line, int(3968))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_double) + tmp6 := lang.Apply(tmp5, []any{v4}) + tmp7, _ := lang.FieldOrMethod(nil, "setDouble") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setDouble is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v2, v3, tmp6}) + _ = tmp8 + return v4 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_double) + tmp8 := checkDerefVar(var_glojure_DOT_core_aget) + tmp9 := lang.Apply(tmp8, []any{v2, v3}) + tmp10 := lang.Apply(tmp6, []any{tmp7, tmp9, v4, v5}) + return tmp10 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_aset_DASH_double = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_aset_DASH_double.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // aset-float + { + tmp0 := sym_aset_DASH_float.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx, sym_val), lang.NewVector(sym_array, sym_idx, sym_idx2, sym__AMP_, sym_idxv)), kw_doc, "Sets the value at the index/indices. Works on arrays of float. Returns val.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(3), kw_line, int(3961), kw_end_DASH_line, int(3963))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_float) + tmp6 := lang.Apply(tmp5, []any{v4}) + tmp7, _ := lang.FieldOrMethod(nil, "setFloat") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setFloat is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v2, v3, tmp6}) + _ = tmp8 + return v4 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_float) + tmp8 := checkDerefVar(var_glojure_DOT_core_aget) + tmp9 := lang.Apply(tmp8, []any{v2, v3}) + tmp10 := lang.Apply(tmp6, []any{tmp7, tmp9, v4, v5}) + return tmp10 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_aset_DASH_float = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_aset_DASH_float.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // aset-int + { + tmp0 := sym_aset_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx, sym_val), lang.NewVector(sym_array, sym_idx, sym_idx2, sym__AMP_, sym_idxv)), kw_doc, "Sets the value at the index/indices. Works on arrays of int. Returns val.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(3), kw_line, int(3946), kw_end_DASH_line, int(3948))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_int) + tmp6 := lang.Apply(tmp5, []any{v4}) + tmp7, _ := lang.FieldOrMethod(nil, "setInt") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setInt is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v2, v3, tmp6}) + _ = tmp8 + return v4 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_int) + tmp8 := checkDerefVar(var_glojure_DOT_core_aget) + tmp9 := lang.Apply(tmp8, []any{v2, v3}) + tmp10 := lang.Apply(tmp6, []any{tmp7, tmp9, v4, v5}) + return tmp10 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_aset_DASH_int = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_aset_DASH_int.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // aset-long + { + tmp0 := sym_aset_DASH_long.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx, sym_val), lang.NewVector(sym_array, sym_idx, sym_idx2, sym__AMP_, sym_idxv)), kw_doc, "Sets the value at the index/indices. Works on arrays of long. Returns val.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(3), kw_line, int(3951), kw_end_DASH_line, int(3953))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_long) + tmp6 := lang.Apply(tmp5, []any{v4}) + tmp7, _ := lang.FieldOrMethod(nil, "setLong") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setLong is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v2, v3, tmp6}) + _ = tmp8 + return v4 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_long) + tmp8 := checkDerefVar(var_glojure_DOT_core_aget) + tmp9 := lang.Apply(tmp8, []any{v2, v3}) + tmp10 := lang.Apply(tmp6, []any{tmp7, tmp9, v4, v5}) + return tmp10 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_aset_DASH_long = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_aset_DASH_long.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // aset-short + { + tmp0 := sym_aset_DASH_short.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx, sym_val), lang.NewVector(sym_array, sym_idx, sym_idx2, sym__AMP_, sym_idxv)), kw_doc, "Sets the value at the index/indices. Works on arrays of short. Returns val.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(3), kw_line, int(3971), kw_end_DASH_line, int(3973))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_short) + tmp6 := lang.Apply(tmp5, []any{v4}) + tmp7, _ := lang.FieldOrMethod(nil, "setShort") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setShort is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v2, v3, tmp6}) + _ = tmp8 + return v4 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_short) + tmp8 := checkDerefVar(var_glojure_DOT_core_aget) + tmp9 := lang.Apply(tmp8, []any{v2, v3}) + tmp10 := lang.Apply(tmp6, []any{tmp7, tmp9, v4, v5}) + return tmp10 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_aset_DASH_short = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_aset_DASH_short.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // atom + { + tmp0 := sym_atom.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym__AMP_, sym_options)), kw_doc, "Creates and returns an Atom with an initial value of x and zero or\n more options (in any order):\n\n :meta metadata-map\n\n :validator validate-fn\n\n If metadata-map is supplied, it will become the metadata on the\n atom. validate-fn must be nil or a side-effect-free fn of one\n argument, which will be passed the intended new state on any state\n change. If the new state is unacceptable, the validate-fn should\n return false or throw an exception.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(2325), kw_end_DASH_line, int(2325))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(lang.NewAtom, []any{v2}) + return tmp3 + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_setup_DASH_reference) + tmp5 := checkDerefVar(var_glojure_DOT_core_atom) + tmp6 := lang.Apply(tmp5, []any{v2}) + tmp7 := lang.Apply(tmp4, []any{tmp6, v3}) + return tmp7 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_atom = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_atom.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // binding + { + tmp0 := sym_binding.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "binding => var-symbol init-expr\n\n Creates new bindings for the (already-existing) vars, with the\n supplied initial values, executes the exprs in an implicit do, then\n re-establishes the bindings that existed before. The new bindings\n are made in parallel (unlike let); all init-exprs are evaluated\n before the vars are bound to their new values.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(1945), kw_end_DASH_line, int(1945))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v4}) + if lang.IsTruthy(tmp8) { + } else { + tmp9 := checkDerefVar(var_glojure_DOT_core_str) + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp13 := checkDerefVar(var_glojure_DOT_core_meta) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(kw_line, []any{tmp14}) + tmp16 := lang.Apply(tmp9, []any{tmp11, " requires ", "a vector for its binding", " in ", tmp12, ":", tmp15}) + tmp17 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp16}) + panic(tmp17) + } + _ = tmp6 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_even_QMARK_) + tmp20 := checkDerefVar(var_glojure_DOT_core_count) + tmp21 := lang.Apply(tmp20, []any{v4}) + tmp22 := lang.Apply(tmp19, []any{tmp21}) + if lang.IsTruthy(tmp22) { + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp27 := checkDerefVar(var_glojure_DOT_core_meta) + tmp28 := lang.Apply(tmp27, []any{v2}) + tmp29 := lang.Apply(kw_line, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp25, " requires ", "an even number of forms in binding vector", " in ", tmp26, ":", tmp29}) + tmp31 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp31) + } + _ = tmp18 + var tmp32 any + { // let + // let binding "var-ize" + var tmp33 lang.FnFunc + tmp33 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v34 := args[0] + _ = v34 + var tmp35 any + { // let + // let binding "ret" + tmp36 := lang.NewVector() + tmp37 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(1959), kw_column, int(30), kw_end_DASH_line, int(1959), kw_end_DASH_column, int(31)) + tmp38, err := lang.WithMeta(tmp36, tmp37.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v39 any = tmp38 + _ = v39 + // let binding "vvs" + tmp40 := checkDerefVar(var_glojure_DOT_core_seq) + tmp41 := lang.Apply(tmp40, []any{v34}) + var v42 any = tmp41 + _ = v42 + for { + var tmp43 any + if lang.IsTruthy(v42) { + tmp45 := checkDerefVar(var_glojure_DOT_core_conj) + tmp46 := checkDerefVar(var_glojure_DOT_core_conj) + tmp47 := checkDerefVar(var_glojure_DOT_core_seq) + tmp48 := checkDerefVar(var_glojure_DOT_core_concat) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) + tmp50 := lang.Apply(tmp49, []any{sym_var}) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := checkDerefVar(var_glojure_DOT_core_first) + tmp53 := lang.Apply(tmp52, []any{v42}) + tmp54 := lang.Apply(tmp51, []any{tmp53}) + tmp55 := lang.Apply(tmp48, []any{tmp50, tmp54}) + tmp56 := lang.Apply(tmp47, []any{tmp55}) + tmp57 := lang.Apply(tmp46, []any{v39, tmp56}) + tmp58 := checkDerefVar(var_glojure_DOT_core_second) + tmp59 := lang.Apply(tmp58, []any{v42}) + tmp60 := lang.Apply(tmp45, []any{tmp57, tmp59}) + var tmp44 any = tmp60 + tmp62 := checkDerefVar(var_glojure_DOT_core_next) + tmp63 := checkDerefVar(var_glojure_DOT_core_next) + tmp64 := lang.Apply(tmp63, []any{v42}) + tmp65 := lang.Apply(tmp62, []any{tmp64}) + var tmp61 any = tmp65 + v39 = tmp44 + v42 = tmp61 + continue + } else { + tmp66 := checkDerefVar(var_glojure_DOT_core_seq) + tmp67 := lang.Apply(tmp66, []any{v39}) + tmp43 = tmp67 + } + tmp35 = tmp43 + break + } + } // end let + return tmp35 + }) + tmp34 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(1958), kw_column, int(17), kw_end_DASH_line, int(1963), kw_end_DASH_column, int(34)) + tmp35, err := lang.WithMeta(tmp33, tmp34.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v36 any = tmp35 + _ = v36 + tmp37 := checkDerefVar(var_glojure_DOT_core_seq) + tmp38 := checkDerefVar(var_glojure_DOT_core_concat) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := lang.Apply(tmp39, []any{sym_glojure_DOT_core_SLASH_let}) + tmp41 := checkDerefVar(var_glojure_DOT_core_list) + tmp42 := checkDerefVar(var_glojure_DOT_core_apply) + tmp43 := checkDerefVar(var_glojure_DOT_core_vector) + tmp44 := checkDerefVar(var_glojure_DOT_core_seq) + tmp45 := checkDerefVar(var_glojure_DOT_core_concat) + tmp46 := lang.Apply(tmp45, nil) + tmp47 := lang.Apply(tmp44, []any{tmp46}) + tmp48 := lang.Apply(tmp42, []any{tmp43, tmp47}) + tmp49 := lang.Apply(tmp41, []any{tmp48}) + tmp50 := checkDerefVar(var_glojure_DOT_core_list) + tmp51 := checkDerefVar(var_glojure_DOT_core_seq) + tmp52 := checkDerefVar(var_glojure_DOT_core_concat) + tmp53 := checkDerefVar(var_glojure_DOT_core_list) + tmp54 := lang.Apply(tmp53, []any{sym_glojure_DOT_core_SLASH_push_DASH_thread_DASH_bindings}) + tmp55 := checkDerefVar(var_glojure_DOT_core_list) + tmp56 := checkDerefVar(var_glojure_DOT_core_seq) + tmp57 := checkDerefVar(var_glojure_DOT_core_concat) + tmp58 := checkDerefVar(var_glojure_DOT_core_list) + tmp59 := lang.Apply(tmp58, []any{sym_glojure_DOT_core_SLASH_hash_DASH_map}) + tmp60 := lang.Apply(v36, []any{v4}) + tmp61 := lang.Apply(tmp57, []any{tmp59, tmp60}) + tmp62 := lang.Apply(tmp56, []any{tmp61}) + tmp63 := lang.Apply(tmp55, []any{tmp62}) + tmp64 := lang.Apply(tmp52, []any{tmp54, tmp63}) + tmp65 := lang.Apply(tmp51, []any{tmp64}) + tmp66 := lang.Apply(tmp50, []any{tmp65}) + tmp67 := checkDerefVar(var_glojure_DOT_core_list) + tmp68 := checkDerefVar(var_glojure_DOT_core_seq) + tmp69 := checkDerefVar(var_glojure_DOT_core_concat) + tmp70 := checkDerefVar(var_glojure_DOT_core_list) + tmp71 := lang.Apply(tmp70, []any{sym_try}) + tmp72 := checkDerefVar(var_glojure_DOT_core_list) + tmp73 := checkDerefVar(var_glojure_DOT_core_seq) + tmp74 := checkDerefVar(var_glojure_DOT_core_concat) + tmp75 := checkDerefVar(var_glojure_DOT_core_list) + tmp76 := lang.Apply(tmp75, []any{sym_finally}) + tmp77 := checkDerefVar(var_glojure_DOT_core_list) + tmp78 := checkDerefVar(var_glojure_DOT_core_seq) + tmp79 := checkDerefVar(var_glojure_DOT_core_concat) + tmp80 := checkDerefVar(var_glojure_DOT_core_list) + tmp81 := lang.Apply(tmp80, []any{sym_glojure_DOT_core_SLASH_pop_DASH_thread_DASH_bindings}) + tmp82 := lang.Apply(tmp79, []any{tmp81}) + tmp83 := lang.Apply(tmp78, []any{tmp82}) + tmp84 := lang.Apply(tmp77, []any{tmp83}) + tmp85 := lang.Apply(tmp74, []any{tmp76, tmp84}) + tmp86 := lang.Apply(tmp73, []any{tmp85}) + tmp87 := lang.Apply(tmp72, []any{tmp86}) + tmp88 := lang.Apply(tmp69, []any{tmp71, v5, tmp87}) + tmp89 := lang.Apply(tmp68, []any{tmp88}) + tmp90 := lang.Apply(tmp67, []any{tmp89}) + tmp91 := lang.Apply(tmp38, []any{tmp40, tmp49, tmp66, tmp90}) + tmp92 := lang.Apply(tmp37, []any{tmp91}) + tmp32 = tmp92 + } // end let + return tmp32 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_binding = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_binding.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bound-fn* + { + tmp0 := sym_bound_DASH_fn_STAR_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f)), kw_doc, "Returns a function, which will install the same bindings in effect as in\n the thread at the time bound-fn* was called and then call f with any given\n arguments. This may be used to define a helper function which runs on a\n different thread, but needs the same bindings in place.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(1992), kw_end_DASH_line, int(1992))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "bindings" + tmp4 := checkDerefVar(var_glojure_DOT_core_get_DASH_thread_DASH_bindings) + tmp5 := lang.Apply(tmp4, nil) + var v6 any = tmp5 + _ = v6 + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v8 any = lang.NewList(args[0:]...) + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_apply) + tmp10 := checkDerefVar(var_glojure_DOT_core_with_DASH_bindings_STAR_) + tmp11 := lang.Apply(tmp9, []any{tmp10, v6, v2, v8}) + return tmp11 + } + }) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2001), kw_column, int(5), kw_end_DASH_line, int(2002), kw_end_DASH_column, int(45)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp3 = tmp9 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bound_DASH_fn_STAR_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bound_DASH_fn_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // case-map + { + tmp0 := sym_case_DASH_map.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_case_DASH_f, sym_test_DASH_f, sym_tests, sym_thens)), kw_doc, "Transforms a sequence of test constants and a corresponding sequence of then\n expressions into a sorted map to be consumed by case*. The form of the map\n entries are {(case-f test) [(test-f test) then]}.", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(8), kw_line, int(6614), kw_end_DASH_line, int(6614), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_into1) + tmp7 := checkDerefVar(var_glojure_DOT_core_sorted_DASH_map) + tmp8 := lang.Apply(tmp7, nil) + tmp9 := checkDerefVar(var_glojure_DOT_core_zipmap) + tmp10 := checkDerefVar(var_glojure_DOT_core_map) + tmp11 := lang.Apply(tmp10, []any{v2, v4}) + tmp12 := checkDerefVar(var_glojure_DOT_core_map) + tmp13 := checkDerefVar(var_glojure_DOT_core_vector) + tmp14 := checkDerefVar(var_glojure_DOT_core_map) + tmp15 := lang.Apply(tmp14, []any{v3, v4}) + tmp16 := lang.Apply(tmp12, []any{tmp13, tmp15, v5}) + tmp17 := lang.Apply(tmp9, []any{tmp11, tmp16}) + tmp18 := lang.Apply(tmp6, []any{tmp8, tmp17}) + return tmp18 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_case_DASH_map = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_case_DASH_map.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // check-valid-options + { + tmp0 := sym_check_DASH_valid_DASH_options.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_options, sym__AMP_, sym_valid_DASH_keys)), kw_doc, "Throws an exception if the given option map contains keys not listed\n as valid, else returns nil.", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(35), kw_column, int(7), kw_line, int(1709), kw_end_DASH_line, int(1709), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_disj) + tmp8 := checkDerefVar(var_glojure_DOT_core_apply) + tmp9 := checkDerefVar(var_glojure_DOT_core_hash_DASH_set) + tmp10 := checkDerefVar(var_glojure_DOT_core_keys) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := lang.Apply(tmp8, []any{tmp9, tmp11}) + tmp13 := lang.Apply(tmp6, []any{tmp7, tmp12, v3}) + tmp14 := lang.Apply(tmp5, []any{tmp13}) + if lang.IsTruthy(tmp14) { + tmp15 := checkDerefVar(var_glojure_DOT_core_apply) + tmp16 := checkDerefVar(var_glojure_DOT_core_str) + tmp17 := checkDerefVar(var_glojure_DOT_core_first) + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := checkDerefVar(var_glojure_DOT_core_map) + var tmp20 lang.FnFunc + tmp20 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v21 := args[0] + _ = v21 + tmp22 := checkDerefVar(var_glojure_DOT_core_str) + tmp23 := lang.Apply(tmp22, []any{", ", v21}) + return tmp23 + }) + tmp21 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(1718), kw_column, int(16), kw_end_DASH_line, int(1718), kw_end_DASH_column, int(28)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp23 := checkDerefVar(var_glojure_DOT_core_rest) + tmp24 := lang.Apply(tmp23, []any{v3}) + tmp25 := lang.Apply(tmp19, []any{tmp22, tmp24}) + tmp26 := lang.Apply(tmp15, []any{tmp16, "Only these options are valid: ", tmp18, tmp25}) + tmp27 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp26}) + panic(tmp27) + } else { + } + return tmp4 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_check_DASH_valid_DASH_options = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_check_DASH_valid_DASH_options.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // clear-agent-errors + { + tmp0 := sym_clear_DASH_agent_DASH_errors.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a)), kw_doc, "DEPRECATED: Use 'restart-agent' instead.\n Clears any exceptions thrown during asynchronous actions of the\n agent, allowing subsequent actions to occur.", kw_file, "glojure/core.glj", kw_deprecated, "1.2", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(24), kw_column, int(7), kw_line, int(2244), kw_end_DASH_line, int(2244))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_restart_DASH_agent) + tmp4, ok := lang.FieldOrMethod(v2, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "Deref"))) + } + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { + case reflect.Func: + tmp5 = lang.Apply(tmp4, nil) + default: + tmp5 = tmp4 + } + tmp6 := lang.Apply(tmp3, []any{v2, tmp5}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_clear_DASH_agent_DASH_errors = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_clear_DASH_agent_DASH_errors.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // declare + { + tmp0 := sym_declare.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_names)), kw_doc, "defs the supplied var names with no bindings, useful for making forward declarations.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(2768), kw_end_DASH_line, int(2768))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym_do}) + tmp9 := checkDerefVar(var_glojure_DOT_core_map) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v11 := args[0] + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_vary_DASH_meta) + tmp14 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp15 := lang.Apply(tmp13, []any{v11, tmp14, kw_declared, true}) + tmp16 := lang.Apply(tmp12, []any{sym_def, tmp15}) + return tmp16 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2771), kw_column, int(25), kw_end_DASH_line, int(2771), kw_end_DASH_column, int(71)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := lang.Apply(tmp9, []any{tmp12, v4}) + tmp14 := lang.Apply(tmp6, []any{tmp8, tmp13}) + tmp15 := lang.Apply(tmp5, []any{tmp14}) + return tmp15 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_declare = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_declare.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // dedupe + { + tmp0 := sym_dedupe.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_coll)), kw_doc, "Returns a lazy sequence removing consecutive duplicates in coll.\n Returns a transducer when no collection is provided.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(7681), kw_end_DASH_line, int(7681))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + var tmp4 any + { // let + // let binding "pv" + tmp5 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) + tmp6 := lang.Apply(tmp5, []any{kw_glojure_DOT_core_SLASH_none}) + var v7 any = tmp6 + _ = v7 + var tmp8 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp9 := lang.Apply(v3, nil) + return tmp9 + case 1: + v9 := args[0] + _ = v9 + tmp10 := lang.Apply(v3, []any{v9}) + return tmp10 + case 2: + v9 := args[0] + _ = v9 + v10 := args[1] + _ = v10 + var tmp11 any + { // let + // let binding "prior" + tmp12 := checkDerefVar(var_glojure_DOT_core_deref) + tmp13 := lang.Apply(tmp12, []any{v7}) + var v14 any = tmp13 + _ = v14 + tmp15 := checkDerefVar(var_glojure_DOT_core_vreset_BANG_) + tmp16 := lang.Apply(tmp15, []any{v7, v10}) + _ = tmp16 + var tmp17 any + tmp18 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp19 := lang.Apply(tmp18, []any{v14, v10}) + if lang.IsTruthy(tmp19) { + tmp17 = v9 + } else { + tmp20 := lang.Apply(v3, []any{v9, v10}) + tmp17 = tmp20 + } + tmp11 = tmp17 + } // end let + return tmp11 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7688), kw_column, int(8), kw_end_DASH_line, int(7696), kw_end_DASH_column, int(37)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp4 = tmp10 + } // end let + return tmp4 + }) + tmp3 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7686), kw_column, int(4), kw_end_DASH_line, int(7696), kw_end_DASH_column, int(39)) + tmp4, err := lang.WithMeta(tmp2, tmp3.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp4 + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_sequence) + tmp4 := checkDerefVar(var_glojure_DOT_core_dedupe) + tmp5 := lang.Apply(tmp4, nil) + tmp6 := lang.Apply(tmp3, []any{tmp5, v2}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_dedupe = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_dedupe.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // defmulti + { + tmp0 := sym_defmulti.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym_docstring_QMARK_, sym_attr_DASH_map_QMARK_, sym_dispatch_DASH_fn, sym__AMP_, sym_options)), kw_doc, "Creates a new multimethod with the associated dispatch function.\n The docstring and attr-map are optional.\n\n Options are key-value pairs and may be one of:\n\n :default\n\n The default dispatch value, defaults to :default\n\n :hierarchy\n\n The value used for hierarchical dispatch (e.g. ::square is-a ::shape)\n\n Hierarchies are type-like relationships that do not depend upon type\n inheritance. By default Clojure's multimethods dispatch off of a\n global hierarchy map. However, a hierarchy relationship can be\n created with the derive function used to augment the root ancestor\n created with make-hierarchy.\n\n Multimethods expect the value of the hierarchy option to be supplied as\n a reference type e.g. a var (i.e. via the Var-quote dispatch macro #'\n or the var special form).", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(11), kw_line, int(1723), kw_end_DASH_line, int(1723))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "docstring" + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp9 := checkDerefVar(var_glojure_DOT_core_first) + tmp10 := lang.Apply(tmp9, []any{v5}) + tmp11 := lang.Apply(tmp8, []any{tmp10}) + if lang.IsTruthy(tmp11) { + tmp12 := checkDerefVar(var_glojure_DOT_core_first) + tmp13 := lang.Apply(tmp12, []any{v5}) + tmp7 = tmp13 + } else { + } + var v14 any = tmp7 + _ = v14 + // let binding "options" + var tmp15 any + tmp16 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp17 := checkDerefVar(var_glojure_DOT_core_first) + tmp18 := lang.Apply(tmp17, []any{v5}) + tmp19 := lang.Apply(tmp16, []any{tmp18}) + if lang.IsTruthy(tmp19) { + tmp20 := checkDerefVar(var_glojure_DOT_core_next) + tmp21 := lang.Apply(tmp20, []any{v5}) + tmp15 = tmp21 + } else { + tmp15 = v5 + } + var v22 any = tmp15 + _ = v22 + // let binding "m" + var tmp23 any + tmp24 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp25 := checkDerefVar(var_glojure_DOT_core_first) + tmp26 := lang.Apply(tmp25, []any{v22}) + tmp27 := lang.Apply(tmp24, []any{tmp26}) + if lang.IsTruthy(tmp27) { + tmp28 := checkDerefVar(var_glojure_DOT_core_first) + tmp29 := lang.Apply(tmp28, []any{v22}) + tmp23 = tmp29 + } else { + tmp30 := lang.NewMap() + tmp31 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(1757), kw_column, int(23), kw_end_DASH_line, int(1757), kw_end_DASH_column, int(24)) + tmp32, err := lang.WithMeta(tmp30, tmp31.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp23 = tmp32 + } + var v33 any = tmp23 + _ = v33 + // let binding "options" + var tmp34 any + tmp35 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp36 := checkDerefVar(var_glojure_DOT_core_first) + tmp37 := lang.Apply(tmp36, []any{v22}) + tmp38 := lang.Apply(tmp35, []any{tmp37}) + if lang.IsTruthy(tmp38) { + tmp39 := checkDerefVar(var_glojure_DOT_core_next) + tmp40 := lang.Apply(tmp39, []any{v22}) + tmp34 = tmp40 + } else { + tmp34 = v22 + } + var v41 any = tmp34 + _ = v41 + // let binding "dispatch-fn" + tmp42 := checkDerefVar(var_glojure_DOT_core_first) + tmp43 := lang.Apply(tmp42, []any{v41}) + var v44 any = tmp43 + _ = v44 + // let binding "options" + tmp45 := checkDerefVar(var_glojure_DOT_core_next) + tmp46 := lang.Apply(tmp45, []any{v41}) + var v47 any = tmp46 + _ = v47 + // let binding "m" + var tmp48 any + if lang.IsTruthy(v14) { + tmp49 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp50 := lang.Apply(tmp49, []any{v33, kw_doc, v14}) + tmp48 = tmp50 + } else { + tmp48 = v33 + } + var v51 any = tmp48 + _ = v51 + // let binding "m" + var tmp52 any + tmp53 := checkDerefVar(var_glojure_DOT_core_meta) + tmp54 := lang.Apply(tmp53, []any{v4}) + if lang.IsTruthy(tmp54) { + tmp55 := checkDerefVar(var_glojure_DOT_core_conj) + tmp56 := checkDerefVar(var_glojure_DOT_core_meta) + tmp57 := lang.Apply(tmp56, []any{v4}) + tmp58 := lang.Apply(tmp55, []any{tmp57, v51}) + tmp52 = tmp58 + } else { + tmp52 = v51 + } + var v59 any = tmp52 + _ = v59 + // let binding "mm-name" + tmp60 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp61 := lang.Apply(tmp60, []any{v4, v59}) + var v62 any = tmp61 + _ = v62 + var tmp63 any + tmp64 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp65 := checkDerefVar(var_glojure_DOT_core_count) + tmp66 := lang.Apply(tmp65, []any{v47}) + tmp67 := lang.Apply(tmp64, []any{tmp66, int64(1)}) + if lang.IsTruthy(tmp67) { + tmp68 := lang.Apply(lang.NewError, []any{"The syntax for defmulti has changed. Example: (defmulti name dispatch-fn :default dispatch-value)"}) + panic(tmp68) + } else { + } + _ = tmp63 + var tmp69 any + { // let + // let binding "options" + tmp70 := checkDerefVar(var_glojure_DOT_core_apply) + tmp71 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp72 := lang.Apply(tmp70, []any{tmp71, v47}) + var v73 any = tmp72 + _ = v73 + // let binding "default" + tmp74 := checkDerefVar(var_glojure_DOT_core_get) + tmp75 := lang.Apply(tmp74, []any{v73, kw_default, kw_default}) + var v76 any = tmp75 + _ = v76 + // let binding "hierarchy" + tmp77 := checkDerefVar(var_glojure_DOT_core_get) + tmp78 := lang.InternVarName(sym_glojure_DOT_core, sym_global_DASH_hierarchy) + tmp79 := lang.Apply(tmp77, []any{v73, kw_hierarchy, tmp78}) + var v80 any = tmp79 + _ = v80 + tmp81 := checkDerefVar(var_glojure_DOT_core_check_DASH_valid_DASH_options) + tmp82 := lang.Apply(tmp81, []any{v73, kw_default, kw_hierarchy}) + _ = tmp82 + tmp83 := checkDerefVar(var_glojure_DOT_core_seq) + tmp84 := checkDerefVar(var_glojure_DOT_core_concat) + tmp85 := checkDerefVar(var_glojure_DOT_core_list) + tmp86 := lang.Apply(tmp85, []any{sym_glojure_DOT_core_SLASH_let}) + tmp87 := checkDerefVar(var_glojure_DOT_core_list) + tmp88 := checkDerefVar(var_glojure_DOT_core_apply) + tmp89 := checkDerefVar(var_glojure_DOT_core_vector) + tmp90 := checkDerefVar(var_glojure_DOT_core_seq) + tmp91 := checkDerefVar(var_glojure_DOT_core_concat) + tmp92 := checkDerefVar(var_glojure_DOT_core_list) + tmp93 := lang.Apply(tmp92, []any{sym_v__0__auto__}) + tmp94 := checkDerefVar(var_glojure_DOT_core_list) + tmp95 := checkDerefVar(var_glojure_DOT_core_seq) + tmp96 := checkDerefVar(var_glojure_DOT_core_concat) + tmp97 := checkDerefVar(var_glojure_DOT_core_list) + tmp98 := lang.Apply(tmp97, []any{sym_def}) + tmp99 := checkDerefVar(var_glojure_DOT_core_list) + tmp100 := lang.Apply(tmp99, []any{v62}) + tmp101 := lang.Apply(tmp96, []any{tmp98, tmp100}) + tmp102 := lang.Apply(tmp95, []any{tmp101}) + tmp103 := lang.Apply(tmp94, []any{tmp102}) + tmp104 := lang.Apply(tmp91, []any{tmp93, tmp103}) + tmp105 := lang.Apply(tmp90, []any{tmp104}) + tmp106 := lang.Apply(tmp88, []any{tmp89, tmp105}) + tmp107 := lang.Apply(tmp87, []any{tmp106}) + tmp108 := checkDerefVar(var_glojure_DOT_core_list) + tmp109 := checkDerefVar(var_glojure_DOT_core_seq) + tmp110 := checkDerefVar(var_glojure_DOT_core_concat) + tmp111 := checkDerefVar(var_glojure_DOT_core_list) + tmp112 := lang.Apply(tmp111, []any{sym_glojure_DOT_core_SLASH_when_DASH_not}) + tmp113 := checkDerefVar(var_glojure_DOT_core_list) + tmp114 := checkDerefVar(var_glojure_DOT_core_seq) + tmp115 := checkDerefVar(var_glojure_DOT_core_concat) + tmp116 := checkDerefVar(var_glojure_DOT_core_list) + tmp117 := lang.Apply(tmp116, []any{sym_glojure_DOT_core_SLASH_and}) + tmp118 := checkDerefVar(var_glojure_DOT_core_list) + tmp119 := checkDerefVar(var_glojure_DOT_core_seq) + tmp120 := checkDerefVar(var_glojure_DOT_core_concat) + tmp121 := checkDerefVar(var_glojure_DOT_core_list) + tmp122 := lang.Apply(tmp121, []any{sym__DOT_HasRoot}) + tmp123 := checkDerefVar(var_glojure_DOT_core_list) + tmp124 := lang.Apply(tmp123, []any{sym_v__0__auto__}) + tmp125 := lang.Apply(tmp120, []any{tmp122, tmp124}) + tmp126 := lang.Apply(tmp119, []any{tmp125}) + tmp127 := lang.Apply(tmp118, []any{tmp126}) + tmp128 := checkDerefVar(var_glojure_DOT_core_list) + tmp129 := checkDerefVar(var_glojure_DOT_core_seq) + tmp130 := checkDerefVar(var_glojure_DOT_core_concat) + tmp131 := checkDerefVar(var_glojure_DOT_core_list) + tmp132 := lang.Apply(tmp131, []any{sym_glojure_DOT_core_SLASH_instance_QMARK_}) + tmp133 := checkDerefVar(var_glojure_DOT_core_list) + tmp134 := lang.Apply(tmp133, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT__STAR_MultiFn}) + tmp135 := checkDerefVar(var_glojure_DOT_core_list) + tmp136 := checkDerefVar(var_glojure_DOT_core_seq) + tmp137 := checkDerefVar(var_glojure_DOT_core_concat) + tmp138 := checkDerefVar(var_glojure_DOT_core_list) + tmp139 := lang.Apply(tmp138, []any{sym_glojure_DOT_core_SLASH_deref}) + tmp140 := checkDerefVar(var_glojure_DOT_core_list) + tmp141 := lang.Apply(tmp140, []any{sym_v__0__auto__}) + tmp142 := lang.Apply(tmp137, []any{tmp139, tmp141}) + tmp143 := lang.Apply(tmp136, []any{tmp142}) + tmp144 := lang.Apply(tmp135, []any{tmp143}) + tmp145 := lang.Apply(tmp130, []any{tmp132, tmp134, tmp144}) + tmp146 := lang.Apply(tmp129, []any{tmp145}) + tmp147 := lang.Apply(tmp128, []any{tmp146}) + tmp148 := lang.Apply(tmp115, []any{tmp117, tmp127, tmp147}) + tmp149 := lang.Apply(tmp114, []any{tmp148}) + tmp150 := lang.Apply(tmp113, []any{tmp149}) + tmp151 := checkDerefVar(var_glojure_DOT_core_list) + tmp152 := checkDerefVar(var_glojure_DOT_core_seq) + tmp153 := checkDerefVar(var_glojure_DOT_core_concat) + tmp154 := checkDerefVar(var_glojure_DOT_core_list) + tmp155 := lang.Apply(tmp154, []any{sym_def}) + tmp156 := checkDerefVar(var_glojure_DOT_core_list) + tmp157 := lang.Apply(tmp156, []any{v62}) + tmp158 := checkDerefVar(var_glojure_DOT_core_list) + tmp159 := checkDerefVar(var_glojure_DOT_core_seq) + tmp160 := checkDerefVar(var_glojure_DOT_core_concat) + tmp161 := checkDerefVar(var_glojure_DOT_core_list) + tmp162 := lang.Apply(tmp161, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_NewMultiFn}) + tmp163 := checkDerefVar(var_glojure_DOT_core_list) + tmp164 := checkDerefVar(var_glojure_DOT_core_name) + tmp165 := lang.Apply(tmp164, []any{v62}) + tmp166 := lang.Apply(tmp163, []any{tmp165}) + tmp167 := checkDerefVar(var_glojure_DOT_core_list) + tmp168 := lang.Apply(tmp167, []any{v44}) + tmp169 := checkDerefVar(var_glojure_DOT_core_list) + tmp170 := lang.Apply(tmp169, []any{v76}) + tmp171 := checkDerefVar(var_glojure_DOT_core_list) + tmp172 := lang.Apply(tmp171, []any{v80}) + tmp173 := lang.Apply(tmp160, []any{tmp162, tmp166, tmp168, tmp170, tmp172}) + tmp174 := lang.Apply(tmp159, []any{tmp173}) + tmp175 := lang.Apply(tmp158, []any{tmp174}) + tmp176 := lang.Apply(tmp153, []any{tmp155, tmp157, tmp175}) + tmp177 := lang.Apply(tmp152, []any{tmp176}) + tmp178 := lang.Apply(tmp151, []any{tmp177}) + tmp179 := lang.Apply(tmp110, []any{tmp112, tmp150, tmp178}) + tmp180 := lang.Apply(tmp109, []any{tmp179}) + tmp181 := lang.Apply(tmp108, []any{tmp180}) + tmp182 := lang.Apply(tmp84, []any{tmp86, tmp107, tmp181}) + tmp183 := lang.Apply(tmp83, []any{tmp182}) + tmp69 = tmp183 + } // end let + tmp6 = tmp69 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_defmulti = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_defmulti.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // defprotocol + { + tmp0 := sym_defprotocol.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym__AMP_, sym_opts_PLUS_sigs)), kw_doc, "A protocol is a named set of named methods and their signatures:\n (defprotocol AProtocolName\n\n ;optional doc string\n \"A doc string for AProtocol abstraction\"\n\n ;options\n :extend-via-metadata true\n\n ;method signatures\n (bar [this a b] \"bar docs\")\n (baz [this a] [this a b] [this a b c] \"baz docs\"))\n\n No implementations are provided. Docs can be specified for the\n protocol overall and for each method. The above yields a set of\n polymorphic functions and a protocol object. All are\n namespace-qualified by the ns enclosing the definition The resulting\n functions dispatch on the type of their first argument, which is\n required and corresponds to the implicit target object ('this' in \n Java parlance). defprotocol is dynamic, has no special compile-time \n effect, and defines no new types or classes. Implementations of \n the protocol methods can be provided using extend.\n\n When :extend-via-metadata is true, values can extend protocols by\n adding metadata where keys are fully-qualified protocol function\n symbols and values are function implementations. Protocol\n implementations are checked first for direct definitions (defrecord,\n deftype, reify), then metadata definitions, then external\n extensions (extend, extend-type, extend-protocol)\n\n defprotocol will automatically generate a corresponding interface,\n with the same name as the protocol, i.e. given a protocol:\n my.ns/Protocol, an interface: my.ns.Protocol. The interface will\n have methods corresponding to the protocol functions, and the\n protocol will automatically work with instances of the interface.\n\n Note that you should not use this interface with deftype or\n reify, as they support the protocol directly:\n\n (defprotocol P \n (foo [this]) \n (bar-me [this] [this y]))\n\n (deftype Foo [a b c] \n P\n (foo [this] a)\n (bar-me [this] b)\n (bar-me [this y] (+ c y)))\n \n (bar-me (Foo. 1 2 3) 42)\n => 45\n\n (foo \n (let [x 42]\n (reify P \n (foo [this] 17)\n (bar-me [this] x)\n (bar-me [this y] x))))\n => 17", kw_file, "glojure/core_deftype.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(11), kw_line, int(28), kw_end_DASH_line, int(28))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "doc" + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp9 := checkDerefVar(var_glojure_DOT_core_first) + tmp10 := lang.Apply(tmp9, []any{v5}) + tmp11 := lang.Apply(tmp8, []any{tmp10}) + if lang.IsTruthy(tmp11) { + tmp12 := checkDerefVar(var_glojure_DOT_core_first) + tmp13 := lang.Apply(tmp12, []any{v5}) + tmp7 = tmp13 + } else { + } + var v14 any = tmp7 + _ = v14 + // let binding "opts+sigs" + var tmp15 any + if lang.IsTruthy(v14) { + tmp16 := checkDerefVar(var_glojure_DOT_core_rest) + tmp17 := lang.Apply(tmp16, []any{v5}) + tmp15 = tmp17 + } else { + tmp15 = v5 + } + var v18 any = tmp15 + _ = v18 + // let binding "opts" + tmp19 := checkDerefVar(var_glojure_DOT_core_take_DASH_while) + var tmp20 lang.FnFunc + tmp20 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v21 := args[0] + _ = v21 + tmp22 := checkDerefVar(var_glojure_DOT_core_not) + tmp23 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp24 := lang.Apply(tmp23, []any{v21}) + tmp25 := lang.Apply(tmp22, []any{tmp24}) + return tmp25 + }) + tmp21 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(92), kw_column, int(26), kw_end_DASH_line, int(92), kw_end_DASH_column, int(40)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp23 := lang.Apply(tmp19, []any{tmp22, v18}) + var v24 any = tmp23 + _ = v24 + // let binding "sigs" + tmp25 := checkDerefVar(var_glojure_DOT_core_drop_DASH_while) + var tmp26 lang.FnFunc + tmp26 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v27 := args[0] + _ = v27 + tmp28 := checkDerefVar(var_glojure_DOT_core_not) + tmp29 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp30 := lang.Apply(tmp29, []any{v27}) + tmp31 := lang.Apply(tmp28, []any{tmp30}) + return tmp31 + }) + tmp27 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(93), kw_column, int(26), kw_end_DASH_line, int(93), kw_end_DASH_column, int(40)) + tmp28, err := lang.WithMeta(tmp26, tmp27.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp29 := lang.Apply(tmp25, []any{tmp28, v18}) + var v30 any = tmp29 + _ = v30 + // let binding "opts" + var tmp31 any + tmp32 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp33 := lang.Apply(tmp32, []any{v30, v24}) + if lang.IsTruthy(tmp33) { + } else { + tmp31 = v24 + } + var v34 any = tmp31 + _ = v34 + tmp35 := checkDerefVar(var_glojure_DOT_core_seq) + tmp36 := checkDerefVar(var_glojure_DOT_core_concat) + tmp37 := checkDerefVar(var_glojure_DOT_core_list) + tmp38 := lang.Apply(tmp37, []any{sym_do}) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := checkDerefVar(var_glojure_DOT_core_seq) + tmp41 := checkDerefVar(var_glojure_DOT_core_concat) + tmp42 := checkDerefVar(var_glojure_DOT_core_list) + tmp43 := lang.Apply(tmp42, []any{sym_def}) + tmp44 := checkDerefVar(var_glojure_DOT_core_list) + tmp45 := lang.Apply(tmp44, []any{v4}) + tmp46 := checkDerefVar(var_glojure_DOT_core_list) + tmp47 := checkDerefVar(var_glojure_DOT_core_seq) + tmp48 := checkDerefVar(var_glojure_DOT_core_concat) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) + tmp50 := lang.Apply(tmp49, []any{sym_glojure_DOT_core_SLASH_atom}) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := checkDerefVar(var_glojure_DOT_core_apply) + tmp53 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp54 := checkDerefVar(var_glojure_DOT_core_seq) + tmp55 := checkDerefVar(var_glojure_DOT_core_concat) + tmp56 := checkDerefVar(var_glojure_DOT_core_list) + tmp57 := lang.Apply(tmp56, []any{kw_on_DASH_interface}) + tmp58 := checkDerefVar(var_glojure_DOT_core_list) + tmp59 := lang.Apply(tmp58, []any{true}) + tmp60 := checkDerefVar(var_glojure_DOT_core_list) + tmp61 := lang.Apply(tmp60, []any{kw_sigs}) + tmp62 := checkDerefVar(var_glojure_DOT_core_list) + tmp63 := checkDerefVar(var_glojure_DOT_core_seq) + tmp64 := checkDerefVar(var_glojure_DOT_core_concat) + tmp65 := checkDerefVar(var_glojure_DOT_core_list) + tmp66 := lang.Apply(tmp65, []any{sym_quote}) + tmp67 := checkDerefVar(var_glojure_DOT_core_list) + tmp68 := lang.Apply(tmp67, []any{v30}) + tmp69 := lang.Apply(tmp64, []any{tmp66, tmp68}) + tmp70 := lang.Apply(tmp63, []any{tmp69}) + tmp71 := lang.Apply(tmp62, []any{tmp70}) + tmp72 := checkDerefVar(var_glojure_DOT_core_list) + tmp73 := lang.Apply(tmp72, []any{kw_multis}) + tmp74 := checkDerefVar(var_glojure_DOT_core_list) + tmp75 := checkDerefVar(var_glojure_DOT_core_apply) + tmp76 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp77 := checkDerefVar(var_glojure_DOT_core_seq) + tmp78 := checkDerefVar(var_glojure_DOT_core_concat) + tmp79 := lang.Apply(tmp78, nil) + tmp80 := lang.Apply(tmp77, []any{tmp79}) + tmp81 := lang.Apply(tmp75, []any{tmp76, tmp80}) + tmp82 := lang.Apply(tmp74, []any{tmp81}) + tmp83 := lang.Apply(tmp55, []any{tmp57, tmp59, tmp61, tmp71, tmp73, tmp82}) + tmp84 := lang.Apply(tmp54, []any{tmp83}) + tmp85 := lang.Apply(tmp52, []any{tmp53, tmp84}) + tmp86 := lang.Apply(tmp51, []any{tmp85}) + tmp87 := lang.Apply(tmp48, []any{tmp50, tmp86}) + tmp88 := lang.Apply(tmp47, []any{tmp87}) + tmp89 := lang.Apply(tmp46, []any{tmp88}) + tmp90 := lang.Apply(tmp41, []any{tmp43, tmp45, tmp89}) + tmp91 := lang.Apply(tmp40, []any{tmp90}) + tmp92 := lang.Apply(tmp39, []any{tmp91}) + tmp93 := checkDerefVar(var_glojure_DOT_core_list) + tmp94 := checkDerefVar(var_glojure_DOT_core_seq) + tmp95 := checkDerefVar(var_glojure_DOT_core_concat) + tmp96 := checkDerefVar(var_glojure_DOT_core_list) + tmp97 := lang.Apply(tmp96, []any{sym_glojure_DOT_core_SLASH_swap_BANG_}) + tmp98 := checkDerefVar(var_glojure_DOT_core_list) + tmp99 := lang.Apply(tmp98, []any{sym_glojure_DOT_core_SLASH__DASH_protocols}) + tmp100 := checkDerefVar(var_glojure_DOT_core_list) + tmp101 := lang.Apply(tmp100, []any{sym_glojure_DOT_core_SLASH_assoc}) + tmp102 := checkDerefVar(var_glojure_DOT_core_list) + tmp103 := checkDerefVar(var_glojure_DOT_core_seq) + tmp104 := checkDerefVar(var_glojure_DOT_core_concat) + tmp105 := checkDerefVar(var_glojure_DOT_core_list) + tmp106 := lang.Apply(tmp105, []any{sym_quote}) + tmp107 := checkDerefVar(var_glojure_DOT_core_list) + tmp108 := lang.Apply(tmp107, []any{v4}) + tmp109 := lang.Apply(tmp104, []any{tmp106, tmp108}) + tmp110 := lang.Apply(tmp103, []any{tmp109}) + tmp111 := lang.Apply(tmp102, []any{tmp110}) + tmp112 := checkDerefVar(var_glojure_DOT_core_list) + tmp113 := lang.Apply(tmp112, []any{v4}) + tmp114 := lang.Apply(tmp95, []any{tmp97, tmp99, tmp101, tmp111, tmp113}) + tmp115 := lang.Apply(tmp94, []any{tmp114}) + tmp116 := lang.Apply(tmp93, []any{tmp115}) + tmp117 := checkDerefVar(var_glojure_DOT_core_map) + var tmp118 lang.FnFunc + tmp118 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v119 := args[0] + _ = v119 + tmp120 := checkDerefVar(var_glojure_DOT_core_seq) + tmp121 := checkDerefVar(var_glojure_DOT_core_concat) + tmp122 := checkDerefVar(var_glojure_DOT_core_list) + tmp123 := lang.Apply(tmp122, []any{sym_do}) + tmp124 := checkDerefVar(var_glojure_DOT_core_list) + tmp125 := checkDerefVar(var_glojure_DOT_core_seq) + tmp126 := checkDerefVar(var_glojure_DOT_core_concat) + tmp127 := checkDerefVar(var_glojure_DOT_core_list) + tmp128 := lang.Apply(tmp127, []any{sym_glojure_DOT_core_SLASH_defmulti}) + tmp129 := checkDerefVar(var_glojure_DOT_core_list) + tmp130 := checkDerefVar(var_glojure_DOT_core_first) + tmp131 := lang.Apply(tmp130, []any{v119}) + tmp132 := lang.Apply(tmp129, []any{tmp131}) + tmp133 := checkDerefVar(var_glojure_DOT_core_list) + tmp134 := checkDerefVar(var_glojure_DOT_core_seq) + tmp135 := checkDerefVar(var_glojure_DOT_core_concat) + tmp136 := checkDerefVar(var_glojure_DOT_core_list) + tmp137 := lang.Apply(tmp136, []any{sym_glojure_DOT_core_SLASH_fn}) + tmp138 := checkDerefVar(var_glojure_DOT_core_list) + tmp139 := checkDerefVar(var_glojure_DOT_core_apply) + tmp140 := checkDerefVar(var_glojure_DOT_core_vector) + tmp141 := checkDerefVar(var_glojure_DOT_core_seq) + tmp142 := checkDerefVar(var_glojure_DOT_core_concat) + tmp143 := checkDerefVar(var_glojure_DOT_core_list) + tmp144 := lang.Apply(tmp143, []any{sym_this}) + tmp145 := checkDerefVar(var_glojure_DOT_core_list) + tmp146 := lang.Apply(tmp145, []any{sym__AMP_}) + tmp147 := checkDerefVar(var_glojure_DOT_core_list) + tmp148 := lang.Apply(tmp147, []any{sym_args}) + tmp149 := lang.Apply(tmp142, []any{tmp144, tmp146, tmp148}) + tmp150 := lang.Apply(tmp141, []any{tmp149}) + tmp151 := lang.Apply(tmp139, []any{tmp140, tmp150}) + tmp152 := lang.Apply(tmp138, []any{tmp151}) + tmp153 := checkDerefVar(var_glojure_DOT_core_list) + tmp154 := checkDerefVar(var_glojure_DOT_core_seq) + tmp155 := checkDerefVar(var_glojure_DOT_core_concat) + tmp156 := checkDerefVar(var_glojure_DOT_core_list) + tmp157 := lang.Apply(tmp156, []any{sym_glojure_DOT_core_SLASH_class}) + tmp158 := checkDerefVar(var_glojure_DOT_core_list) + tmp159 := lang.Apply(tmp158, []any{sym_this}) + tmp160 := lang.Apply(tmp155, []any{tmp157, tmp159}) + tmp161 := lang.Apply(tmp154, []any{tmp160}) + tmp162 := lang.Apply(tmp153, []any{tmp161}) + tmp163 := lang.Apply(tmp135, []any{tmp137, tmp152, tmp162}) + tmp164 := lang.Apply(tmp134, []any{tmp163}) + tmp165 := lang.Apply(tmp133, []any{tmp164}) + tmp166 := lang.Apply(tmp126, []any{tmp128, tmp132, tmp165}) + tmp167 := lang.Apply(tmp125, []any{tmp166}) + tmp168 := lang.Apply(tmp124, []any{tmp167}) + tmp169 := checkDerefVar(var_glojure_DOT_core_list) + tmp170 := checkDerefVar(var_glojure_DOT_core_seq) + tmp171 := checkDerefVar(var_glojure_DOT_core_concat) + tmp172 := checkDerefVar(var_glojure_DOT_core_list) + tmp173 := lang.Apply(tmp172, []any{sym_glojure_DOT_core_SLASH_swap_BANG_}) + tmp174 := checkDerefVar(var_glojure_DOT_core_list) + tmp175 := lang.Apply(tmp174, []any{v4}) + tmp176 := checkDerefVar(var_glojure_DOT_core_list) + tmp177 := lang.Apply(tmp176, []any{sym_glojure_DOT_core_SLASH_assoc_DASH_in}) + tmp178 := checkDerefVar(var_glojure_DOT_core_list) + tmp179 := checkDerefVar(var_glojure_DOT_core_apply) + tmp180 := checkDerefVar(var_glojure_DOT_core_vector) + tmp181 := checkDerefVar(var_glojure_DOT_core_seq) + tmp182 := checkDerefVar(var_glojure_DOT_core_concat) + tmp183 := checkDerefVar(var_glojure_DOT_core_list) + tmp184 := lang.Apply(tmp183, []any{kw_multis}) + tmp185 := checkDerefVar(var_glojure_DOT_core_list) + tmp186 := checkDerefVar(var_glojure_DOT_core_seq) + tmp187 := checkDerefVar(var_glojure_DOT_core_concat) + tmp188 := checkDerefVar(var_glojure_DOT_core_list) + tmp189 := lang.Apply(tmp188, []any{sym_glojure_DOT_core_SLASH_keyword}) + tmp190 := checkDerefVar(var_glojure_DOT_core_list) + tmp191 := checkDerefVar(var_glojure_DOT_core_seq) + tmp192 := checkDerefVar(var_glojure_DOT_core_concat) + tmp193 := checkDerefVar(var_glojure_DOT_core_list) + tmp194 := lang.Apply(tmp193, []any{sym_quote}) + tmp195 := checkDerefVar(var_glojure_DOT_core_list) + tmp196 := checkDerefVar(var_glojure_DOT_core_first) + tmp197 := lang.Apply(tmp196, []any{v119}) + tmp198 := lang.Apply(tmp195, []any{tmp197}) + tmp199 := lang.Apply(tmp192, []any{tmp194, tmp198}) + tmp200 := lang.Apply(tmp191, []any{tmp199}) + tmp201 := lang.Apply(tmp190, []any{tmp200}) + tmp202 := lang.Apply(tmp187, []any{tmp189, tmp201}) + tmp203 := lang.Apply(tmp186, []any{tmp202}) + tmp204 := lang.Apply(tmp185, []any{tmp203}) + tmp205 := lang.Apply(tmp182, []any{tmp184, tmp204}) + tmp206 := lang.Apply(tmp181, []any{tmp205}) + tmp207 := lang.Apply(tmp179, []any{tmp180, tmp206}) + tmp208 := lang.Apply(tmp178, []any{tmp207}) + tmp209 := checkDerefVar(var_glojure_DOT_core_list) + tmp210 := checkDerefVar(var_glojure_DOT_core_first) + tmp211 := lang.Apply(tmp210, []any{v119}) + tmp212 := lang.Apply(tmp209, []any{tmp211}) + tmp213 := lang.Apply(tmp171, []any{tmp173, tmp175, tmp177, tmp208, tmp212}) + tmp214 := lang.Apply(tmp170, []any{tmp213}) + tmp215 := lang.Apply(tmp169, []any{tmp214}) + tmp216 := lang.Apply(tmp121, []any{tmp123, tmp168, tmp215}) + tmp217 := lang.Apply(tmp120, []any{tmp216}) + return tmp217 + }) + tmp119 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(102), kw_column, int(13), kw_end_DASH_line, int(104), kw_end_DASH_column, int(90)) + tmp120, err := lang.WithMeta(tmp118, tmp119.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp121 := lang.Apply(tmp117, []any{tmp120, v30}) + tmp122 := checkDerefVar(var_glojure_DOT_core_list) + tmp123 := checkDerefVar(var_glojure_DOT_core_seq) + tmp124 := checkDerefVar(var_glojure_DOT_core_concat) + tmp125 := checkDerefVar(var_glojure_DOT_core_list) + tmp126 := lang.Apply(tmp125, []any{sym_var}) + tmp127 := checkDerefVar(var_glojure_DOT_core_list) + tmp128 := lang.Apply(tmp127, []any{v4}) + tmp129 := lang.Apply(tmp124, []any{tmp126, tmp128}) + tmp130 := lang.Apply(tmp123, []any{tmp129}) + tmp131 := lang.Apply(tmp122, []any{tmp130}) + tmp132 := lang.Apply(tmp36, []any{tmp38, tmp92, tmp116, tmp121, tmp131}) + tmp133 := lang.Apply(tmp35, []any{tmp132}) + tmp6 = tmp133 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_defprotocol = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_defprotocol.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // distinct? + { + tmp1 := reflect.TypeOf(false) + tmp0 := sym_distinct_QMARK_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_doc, "Returns true if no two of the arguments are =", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(5664), kw_end_DASH_line, int(5664))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + return true + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_not) + tmp6 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp7 := lang.Apply(tmp6, []any{v3, v4}) + tmp8 := lang.Apply(tmp5, []any{tmp7}) + return tmp8 + default: + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_not_EQ_) + tmp8 := lang.Apply(tmp7, []any{v3, v4}) + if lang.IsTruthy(tmp8) { + var tmp9 any + { // let + // let binding "s" + tmp10 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{v3, v4})) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5673), kw_column, int(15), kw_end_DASH_line, int(5673), kw_end_DASH_column, int(20)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v13 any = tmp12 + _ = v13 + // let binding "G__790" + var v14 any = v5 + _ = v14 + // let binding "vec__791" + var v15 any = v14 + _ = v15 + // let binding "seq__792" + tmp16 := checkDerefVar(var_glojure_DOT_core_seq) + tmp17 := lang.Apply(tmp16, []any{v15}) + var v18 any = tmp17 + _ = v18 + // let binding "first__793" + tmp19 := checkDerefVar(var_glojure_DOT_core_first) + tmp20 := lang.Apply(tmp19, []any{v18}) + var v21 any = tmp20 + _ = v21 + // let binding "seq__792" + tmp22 := checkDerefVar(var_glojure_DOT_core_next) + tmp23 := lang.Apply(tmp22, []any{v18}) + var v24 any = tmp23 + _ = v24 + // let binding "x" + var v25 any = v21 + _ = v25 + // let binding "etc" + var v26 any = v24 + _ = v26 + // let binding "xs" + var v27 any = v15 + _ = v27 + var tmp28 any + { // let + // let binding "s" + var v29 any = v13 + _ = v29 + // let binding "G__790" + var v30 any = v14 + _ = v30 + for { + var tmp31 any + { // let + // let binding "s" + var v32 any = v29 + _ = v32 + // let binding "vec__794" + var v33 any = v30 + _ = v33 + // let binding "seq__795" + tmp34 := checkDerefVar(var_glojure_DOT_core_seq) + tmp35 := lang.Apply(tmp34, []any{v33}) + var v36 any = tmp35 + _ = v36 + // let binding "first__796" + tmp37 := checkDerefVar(var_glojure_DOT_core_first) + tmp38 := lang.Apply(tmp37, []any{v36}) + var v39 any = tmp38 + _ = v39 + // let binding "seq__795" + tmp40 := checkDerefVar(var_glojure_DOT_core_next) + tmp41 := lang.Apply(tmp40, []any{v36}) + var v42 any = tmp41 + _ = v42 + // let binding "x" + var v43 any = v39 + _ = v43 + // let binding "etc" + var v44 any = v42 + _ = v44 + // let binding "xs" + var v45 any = v33 + _ = v45 + var tmp46 any + if lang.IsTruthy(v45) { + var tmp47 any + tmp48 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp49 := lang.Apply(tmp48, []any{v32, v43}) + if lang.IsTruthy(tmp49) { + tmp47 = false + } else { + tmp51 := checkDerefVar(var_glojure_DOT_core_conj) + tmp52 := lang.Apply(tmp51, []any{v32, v43}) + var tmp50 any = tmp52 + var tmp53 any = v44 + v29 = tmp50 + v30 = tmp53 + continue + } + tmp46 = tmp47 + } else { + tmp46 = true + } + tmp31 = tmp46 + } // end let + tmp28 = tmp31 + break + } + } // end let + tmp9 = tmp28 + } // end let + tmp6 = tmp9 + } else { + tmp6 = false + } + return tmp6 + } + }) + tmp3 := reflect.TypeOf(false) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_distinct_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_distinct_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // doall + { + tmp0 := sym_doall.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll), lang.NewVector(sym_n, sym_coll)), kw_doc, "When lazy sequences are produced via functions that have side\n effects, any effects other than those needed to produce the first\n element in the seq do not occur until the seq is consumed. doall can\n be used to force any effects. Walks through the successive nexts of\n the seq, retains the head and returns it, thus causing the entire\n seq to reside in memory at one time.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3131), kw_end_DASH_line, int(3131))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_dorun) + tmp4 := lang.Apply(tmp3, []any{v2}) + _ = tmp4 + return v2 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_dorun) + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + _ = tmp5 + return v3 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_doall = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_doall.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // doseq + { + tmp0 := sym_doseq.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_seq_DASH_exprs, sym__AMP_, sym_body)), kw_doc, "Repeatedly executes body (presumably for side-effects) with\n bindings and filtering as provided by \"for\". Does not retain\n the head of the sequence. Returns nil.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(11), kw_line, int(3209), kw_end_DASH_line, int(3209))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v4}) + if lang.IsTruthy(tmp8) { + } else { + tmp9 := checkDerefVar(var_glojure_DOT_core_str) + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp13 := checkDerefVar(var_glojure_DOT_core_meta) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(kw_line, []any{tmp14}) + tmp16 := lang.Apply(tmp9, []any{tmp11, " requires ", "a vector for its binding", " in ", tmp12, ":", tmp15}) + tmp17 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp16}) + panic(tmp17) + } + _ = tmp6 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_even_QMARK_) + tmp20 := checkDerefVar(var_glojure_DOT_core_count) + tmp21 := lang.Apply(tmp20, []any{v4}) + tmp22 := lang.Apply(tmp19, []any{tmp21}) + if lang.IsTruthy(tmp22) { + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp27 := checkDerefVar(var_glojure_DOT_core_meta) + tmp28 := lang.Apply(tmp27, []any{v2}) + tmp29 := lang.Apply(kw_line, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp25, " requires ", "an even number of forms in binding vector", " in ", tmp26, ":", tmp29}) + tmp31 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp31) + } + _ = tmp18 + var tmp32 any + { // let + // let binding "step" + var tmp33 lang.FnFunc + { // function step + var v34 lang.FnFunc + tmp33 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v35 := args[0] + _ = v35 + v36 := args[1] + _ = v36 + var tmp37 any + tmp38 := checkDerefVar(var_glojure_DOT_core_not) + tmp39 := lang.Apply(tmp38, []any{v36}) + if lang.IsTruthy(tmp39) { + tmp40 := checkDerefVar(var_glojure_DOT_core_seq) + tmp41 := checkDerefVar(var_glojure_DOT_core_concat) + tmp42 := checkDerefVar(var_glojure_DOT_core_list) + tmp43 := lang.Apply(tmp42, []any{sym_do}) + tmp44 := lang.Apply(tmp41, []any{tmp43, v5}) + tmp45 := lang.Apply(tmp40, []any{tmp44}) + tmp46 := lang.NewVector(true, tmp45) + tmp47 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3220), kw_column, int(18), kw_end_DASH_line, int(3220), kw_end_DASH_column, int(36)) + tmp48, err := lang.WithMeta(tmp46, tmp47.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp37 = tmp48 + } else { + var tmp49 any + { // let + // let binding "k" + tmp50 := checkDerefVar(var_glojure_DOT_core_first) + tmp51 := lang.Apply(tmp50, []any{v36}) + var v52 any = tmp51 + _ = v52 + // let binding "v" + tmp53 := checkDerefVar(var_glojure_DOT_core_second) + tmp54 := lang.Apply(tmp53, []any{v36}) + var v55 any = tmp54 + _ = v55 + var tmp56 any + tmp57 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp58 := lang.Apply(tmp57, []any{v52}) + if lang.IsTruthy(tmp58) { + var tmp59 any + { // let + // let binding "steppair" + tmp60 := checkDerefVar(var_glojure_DOT_core_nnext) + tmp61 := lang.Apply(tmp60, []any{v36}) + tmp62 := lang.Apply(v34, []any{v35, tmp61}) + var v63 any = tmp62 + _ = v63 + // let binding "needrec" + tmp64 := lang.Apply(v63, []any{int64(0)}) + var v65 any = tmp64 + _ = v65 + // let binding "subform" + tmp66 := lang.Apply(v63, []any{int64(1)}) + var v67 any = tmp66 + _ = v67 + var tmp68 any + tmp69 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp70 := lang.Apply(tmp69, []any{v52, kw_let}) + if lang.IsTruthy(tmp70) { + tmp71 := checkDerefVar(var_glojure_DOT_core_seq) + tmp72 := checkDerefVar(var_glojure_DOT_core_concat) + tmp73 := checkDerefVar(var_glojure_DOT_core_list) + tmp74 := lang.Apply(tmp73, []any{sym_glojure_DOT_core_SLASH_let}) + tmp75 := checkDerefVar(var_glojure_DOT_core_list) + tmp76 := lang.Apply(tmp75, []any{v55}) + tmp77 := checkDerefVar(var_glojure_DOT_core_list) + tmp78 := lang.Apply(tmp77, []any{v67}) + tmp79 := lang.Apply(tmp72, []any{tmp74, tmp76, tmp78}) + tmp80 := lang.Apply(tmp71, []any{tmp79}) + tmp81 := lang.NewVector(v65, tmp80) + tmp82 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3228), kw_column, int(37), kw_end_DASH_line, int(3228), kw_end_DASH_column, int(64)) + tmp83, err := lang.WithMeta(tmp81, tmp82.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp68 = tmp83 + } else { + var tmp84 any + tmp85 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp86 := lang.Apply(tmp85, []any{v52, kw_while}) + if lang.IsTruthy(tmp86) { + tmp87 := checkDerefVar(var_glojure_DOT_core_seq) + tmp88 := checkDerefVar(var_glojure_DOT_core_concat) + tmp89 := checkDerefVar(var_glojure_DOT_core_list) + tmp90 := lang.Apply(tmp89, []any{sym_glojure_DOT_core_SLASH_when}) + tmp91 := checkDerefVar(var_glojure_DOT_core_list) + tmp92 := lang.Apply(tmp91, []any{v55}) + tmp93 := checkDerefVar(var_glojure_DOT_core_list) + tmp94 := lang.Apply(tmp93, []any{v67}) + var tmp95 any + if lang.IsTruthy(v65) { + tmp96 := lang.NewVector(v35) + tmp97 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3231), kw_column, int(65), kw_end_DASH_line, int(3231), kw_end_DASH_column, int(73)) + tmp98, err := lang.WithMeta(tmp96, tmp97.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp95 = tmp98 + } else { + } + tmp99 := lang.Apply(tmp88, []any{tmp90, tmp92, tmp94, tmp95}) + tmp100 := lang.Apply(tmp87, []any{tmp99}) + tmp101 := lang.NewVector(false, tmp100) + tmp102 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3229), kw_column, int(39), kw_end_DASH_line, int(3231), kw_end_DASH_column, int(76)) + tmp103, err := lang.WithMeta(tmp101, tmp102.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp84 = tmp103 + } else { + var tmp104 any + tmp105 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp106 := lang.Apply(tmp105, []any{v52, kw_when}) + if lang.IsTruthy(tmp106) { + tmp107 := checkDerefVar(var_glojure_DOT_core_seq) + tmp108 := checkDerefVar(var_glojure_DOT_core_concat) + tmp109 := checkDerefVar(var_glojure_DOT_core_list) + tmp110 := lang.Apply(tmp109, []any{sym_if}) + tmp111 := checkDerefVar(var_glojure_DOT_core_list) + tmp112 := lang.Apply(tmp111, []any{v55}) + tmp113 := checkDerefVar(var_glojure_DOT_core_list) + tmp114 := checkDerefVar(var_glojure_DOT_core_seq) + tmp115 := checkDerefVar(var_glojure_DOT_core_concat) + tmp116 := checkDerefVar(var_glojure_DOT_core_list) + tmp117 := lang.Apply(tmp116, []any{sym_do}) + tmp118 := checkDerefVar(var_glojure_DOT_core_list) + tmp119 := lang.Apply(tmp118, []any{v67}) + var tmp120 any + if lang.IsTruthy(v65) { + tmp121 := lang.NewVector(v35) + tmp122 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3235), kw_column, int(66), kw_end_DASH_line, int(3235), kw_end_DASH_column, int(74)) + tmp123, err := lang.WithMeta(tmp121, tmp122.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp120 = tmp123 + } else { + } + tmp124 := lang.Apply(tmp115, []any{tmp117, tmp119, tmp120}) + tmp125 := lang.Apply(tmp114, []any{tmp124}) + tmp126 := lang.Apply(tmp113, []any{tmp125}) + tmp127 := checkDerefVar(var_glojure_DOT_core_list) + tmp128 := lang.Apply(tmp127, []any{v35}) + tmp129 := lang.Apply(tmp108, []any{tmp110, tmp112, tmp126, tmp128}) + tmp130 := lang.Apply(tmp107, []any{tmp129}) + tmp131 := lang.NewVector(false, tmp130) + tmp132 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3232), kw_column, int(38), kw_end_DASH_line, int(3236), kw_end_DASH_column, int(57)) + tmp133, err := lang.WithMeta(tmp131, tmp132.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp104 = tmp133 + } else { + } + tmp84 = tmp104 + } + tmp68 = tmp84 + } + tmp59 = tmp68 + } // end let + tmp56 = tmp59 + } else { + var tmp60 any + { // let + // let binding "seq-" + tmp61 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp62 := lang.Apply(tmp61, []any{"seq_"}) + var v63 any = tmp62 + _ = v63 + // let binding "chunk-" + tmp64 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp65 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp66 := lang.Apply(tmp65, []any{"chunk_"}) + tmp67 := lang.NewMap(kw_tag, sym_glojure_DOT_lang_DOT_IChunk) + tmp68 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3239), kw_column, int(46), kw_end_DASH_line, int(3239), kw_end_DASH_column, int(72)) + tmp69, err := lang.WithMeta(tmp67, tmp68.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp70 := lang.Apply(tmp64, []any{tmp66, tmp69}) + var v71 any = tmp70 + _ = v71 + // let binding "count-" + tmp72 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp73 := lang.Apply(tmp72, []any{"count_"}) + var v74 any = tmp73 + _ = v74 + // let binding "i-" + tmp75 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp76 := lang.Apply(tmp75, []any{"i_"}) + var v77 any = tmp76 + _ = v77 + // let binding "recform" + tmp78 := checkDerefVar(var_glojure_DOT_core_seq) + tmp79 := checkDerefVar(var_glojure_DOT_core_concat) + tmp80 := checkDerefVar(var_glojure_DOT_core_list) + tmp81 := lang.Apply(tmp80, []any{sym_recur}) + tmp82 := checkDerefVar(var_glojure_DOT_core_list) + tmp83 := checkDerefVar(var_glojure_DOT_core_seq) + tmp84 := checkDerefVar(var_glojure_DOT_core_concat) + tmp85 := checkDerefVar(var_glojure_DOT_core_list) + tmp86 := lang.Apply(tmp85, []any{sym_glojure_DOT_core_SLASH_next}) + tmp87 := checkDerefVar(var_glojure_DOT_core_list) + tmp88 := lang.Apply(tmp87, []any{v63}) + tmp89 := lang.Apply(tmp84, []any{tmp86, tmp88}) + tmp90 := lang.Apply(tmp83, []any{tmp89}) + tmp91 := lang.Apply(tmp82, []any{tmp90}) + tmp92 := checkDerefVar(var_glojure_DOT_core_list) + tmp93 := lang.Apply(tmp92, []any{nil}) + tmp94 := checkDerefVar(var_glojure_DOT_core_list) + tmp95 := lang.Apply(tmp94, []any{int64(0)}) + tmp96 := checkDerefVar(var_glojure_DOT_core_list) + tmp97 := lang.Apply(tmp96, []any{int64(0)}) + tmp98 := lang.Apply(tmp79, []any{tmp81, tmp91, tmp93, tmp95, tmp97}) + tmp99 := lang.Apply(tmp78, []any{tmp98}) + var v100 any = tmp99 + _ = v100 + // let binding "steppair" + tmp101 := checkDerefVar(var_glojure_DOT_core_nnext) + tmp102 := lang.Apply(tmp101, []any{v36}) + tmp103 := lang.Apply(v34, []any{v100, tmp102}) + var v104 any = tmp103 + _ = v104 + // let binding "needrec" + tmp105 := lang.Apply(v104, []any{int64(0)}) + var v106 any = tmp105 + _ = v106 + // let binding "subform" + tmp107 := lang.Apply(v104, []any{int64(1)}) + var v108 any = tmp107 + _ = v108 + // let binding "recform-chunk" + tmp109 := checkDerefVar(var_glojure_DOT_core_seq) + tmp110 := checkDerefVar(var_glojure_DOT_core_concat) + tmp111 := checkDerefVar(var_glojure_DOT_core_list) + tmp112 := lang.Apply(tmp111, []any{sym_recur}) + tmp113 := checkDerefVar(var_glojure_DOT_core_list) + tmp114 := lang.Apply(tmp113, []any{v63}) + tmp115 := checkDerefVar(var_glojure_DOT_core_list) + tmp116 := lang.Apply(tmp115, []any{v71}) + tmp117 := checkDerefVar(var_glojure_DOT_core_list) + tmp118 := lang.Apply(tmp117, []any{v74}) + tmp119 := checkDerefVar(var_glojure_DOT_core_list) + tmp120 := checkDerefVar(var_glojure_DOT_core_seq) + tmp121 := checkDerefVar(var_glojure_DOT_core_concat) + tmp122 := checkDerefVar(var_glojure_DOT_core_list) + tmp123 := lang.Apply(tmp122, []any{sym_glojure_DOT_core_SLASH_unchecked_DASH_inc}) + tmp124 := checkDerefVar(var_glojure_DOT_core_list) + tmp125 := lang.Apply(tmp124, []any{v77}) + tmp126 := lang.Apply(tmp121, []any{tmp123, tmp125}) + tmp127 := lang.Apply(tmp120, []any{tmp126}) + tmp128 := lang.Apply(tmp119, []any{tmp127}) + tmp129 := lang.Apply(tmp110, []any{tmp112, tmp114, tmp116, tmp118, tmp128}) + tmp130 := lang.Apply(tmp109, []any{tmp129}) + var v131 any = tmp130 + _ = v131 + // let binding "steppair-chunk" + tmp132 := checkDerefVar(var_glojure_DOT_core_nnext) + tmp133 := lang.Apply(tmp132, []any{v36}) + tmp134 := lang.Apply(v34, []any{v131, tmp133}) + var v135 any = tmp134 + _ = v135 + // let binding "subform-chunk" + tmp136 := lang.Apply(v135, []any{int64(1)}) + var v137 any = tmp136 + _ = v137 + tmp138 := checkDerefVar(var_glojure_DOT_core_seq) + tmp139 := checkDerefVar(var_glojure_DOT_core_concat) + tmp140 := checkDerefVar(var_glojure_DOT_core_list) + tmp141 := lang.Apply(tmp140, []any{sym_glojure_DOT_core_SLASH_loop}) + tmp142 := checkDerefVar(var_glojure_DOT_core_list) + tmp143 := checkDerefVar(var_glojure_DOT_core_apply) + tmp144 := checkDerefVar(var_glojure_DOT_core_vector) + tmp145 := checkDerefVar(var_glojure_DOT_core_seq) + tmp146 := checkDerefVar(var_glojure_DOT_core_concat) + tmp147 := checkDerefVar(var_glojure_DOT_core_list) + tmp148 := lang.Apply(tmp147, []any{v63}) + tmp149 := checkDerefVar(var_glojure_DOT_core_list) + tmp150 := checkDerefVar(var_glojure_DOT_core_seq) + tmp151 := checkDerefVar(var_glojure_DOT_core_concat) + tmp152 := checkDerefVar(var_glojure_DOT_core_list) + tmp153 := lang.Apply(tmp152, []any{sym_glojure_DOT_core_SLASH_seq}) + tmp154 := checkDerefVar(var_glojure_DOT_core_list) + tmp155 := lang.Apply(tmp154, []any{v55}) + tmp156 := lang.Apply(tmp151, []any{tmp153, tmp155}) + tmp157 := lang.Apply(tmp150, []any{tmp156}) + tmp158 := lang.Apply(tmp149, []any{tmp157}) + tmp159 := checkDerefVar(var_glojure_DOT_core_list) + tmp160 := lang.Apply(tmp159, []any{v71}) + tmp161 := checkDerefVar(var_glojure_DOT_core_list) + tmp162 := lang.Apply(tmp161, []any{nil}) + tmp163 := checkDerefVar(var_glojure_DOT_core_list) + tmp164 := lang.Apply(tmp163, []any{v74}) + tmp165 := checkDerefVar(var_glojure_DOT_core_list) + tmp166 := lang.Apply(tmp165, []any{int64(0)}) + tmp167 := checkDerefVar(var_glojure_DOT_core_list) + tmp168 := lang.Apply(tmp167, []any{v77}) + tmp169 := checkDerefVar(var_glojure_DOT_core_list) + tmp170 := lang.Apply(tmp169, []any{int64(0)}) + tmp171 := lang.Apply(tmp146, []any{tmp148, tmp158, tmp160, tmp162, tmp164, tmp166, tmp168, tmp170}) + tmp172 := lang.Apply(tmp145, []any{tmp171}) + tmp173 := lang.Apply(tmp143, []any{tmp144, tmp172}) + tmp174 := lang.Apply(tmp142, []any{tmp173}) + tmp175 := checkDerefVar(var_glojure_DOT_core_list) + tmp176 := checkDerefVar(var_glojure_DOT_core_seq) + tmp177 := checkDerefVar(var_glojure_DOT_core_concat) + tmp178 := checkDerefVar(var_glojure_DOT_core_list) + tmp179 := lang.Apply(tmp178, []any{sym_if}) + tmp180 := checkDerefVar(var_glojure_DOT_core_list) + tmp181 := checkDerefVar(var_glojure_DOT_core_seq) + tmp182 := checkDerefVar(var_glojure_DOT_core_concat) + tmp183 := checkDerefVar(var_glojure_DOT_core_list) + tmp184 := lang.Apply(tmp183, []any{sym_glojure_DOT_core_SLASH__LT_}) + tmp185 := checkDerefVar(var_glojure_DOT_core_list) + tmp186 := lang.Apply(tmp185, []any{v77}) + tmp187 := checkDerefVar(var_glojure_DOT_core_list) + tmp188 := lang.Apply(tmp187, []any{v74}) + tmp189 := lang.Apply(tmp182, []any{tmp184, tmp186, tmp188}) + tmp190 := lang.Apply(tmp181, []any{tmp189}) + tmp191 := lang.Apply(tmp180, []any{tmp190}) + tmp192 := checkDerefVar(var_glojure_DOT_core_list) + tmp193 := checkDerefVar(var_glojure_DOT_core_seq) + tmp194 := checkDerefVar(var_glojure_DOT_core_concat) + tmp195 := checkDerefVar(var_glojure_DOT_core_list) + tmp196 := lang.Apply(tmp195, []any{sym_glojure_DOT_core_SLASH_let}) + tmp197 := checkDerefVar(var_glojure_DOT_core_list) + tmp198 := checkDerefVar(var_glojure_DOT_core_apply) + tmp199 := checkDerefVar(var_glojure_DOT_core_vector) + tmp200 := checkDerefVar(var_glojure_DOT_core_seq) + tmp201 := checkDerefVar(var_glojure_DOT_core_concat) + tmp202 := checkDerefVar(var_glojure_DOT_core_list) + tmp203 := lang.Apply(tmp202, []any{v52}) + tmp204 := checkDerefVar(var_glojure_DOT_core_list) + tmp205 := checkDerefVar(var_glojure_DOT_core_seq) + tmp206 := checkDerefVar(var_glojure_DOT_core_concat) + tmp207 := checkDerefVar(var_glojure_DOT_core_list) + tmp208 := lang.Apply(tmp207, []any{sym__DOT_nth}) + tmp209 := checkDerefVar(var_glojure_DOT_core_list) + tmp210 := lang.Apply(tmp209, []any{v71}) + tmp211 := checkDerefVar(var_glojure_DOT_core_list) + tmp212 := lang.Apply(tmp211, []any{v77}) + tmp213 := lang.Apply(tmp206, []any{tmp208, tmp210, tmp212}) + tmp214 := lang.Apply(tmp205, []any{tmp213}) + tmp215 := lang.Apply(tmp204, []any{tmp214}) + tmp216 := lang.Apply(tmp201, []any{tmp203, tmp215}) + tmp217 := lang.Apply(tmp200, []any{tmp216}) + tmp218 := lang.Apply(tmp198, []any{tmp199, tmp217}) + tmp219 := lang.Apply(tmp197, []any{tmp218}) + tmp220 := checkDerefVar(var_glojure_DOT_core_list) + tmp221 := lang.Apply(tmp220, []any{v137}) + var tmp222 any + if lang.IsTruthy(v106) { + tmp223 := lang.NewVector(v131) + tmp224 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3256), kw_column, int(48), kw_end_DASH_line, int(3256), kw_end_DASH_column, int(62)) + tmp225, err := lang.WithMeta(tmp223, tmp224.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp222 = tmp225 + } else { + } + tmp226 := lang.Apply(tmp194, []any{tmp196, tmp219, tmp221, tmp222}) + tmp227 := lang.Apply(tmp193, []any{tmp226}) + tmp228 := lang.Apply(tmp192, []any{tmp227}) + tmp229 := checkDerefVar(var_glojure_DOT_core_list) + tmp230 := checkDerefVar(var_glojure_DOT_core_seq) + tmp231 := checkDerefVar(var_glojure_DOT_core_concat) + tmp232 := checkDerefVar(var_glojure_DOT_core_list) + tmp233 := lang.Apply(tmp232, []any{sym_glojure_DOT_core_SLASH_when_DASH_let}) + tmp234 := checkDerefVar(var_glojure_DOT_core_list) + tmp235 := checkDerefVar(var_glojure_DOT_core_apply) + tmp236 := checkDerefVar(var_glojure_DOT_core_vector) + tmp237 := checkDerefVar(var_glojure_DOT_core_seq) + tmp238 := checkDerefVar(var_glojure_DOT_core_concat) + tmp239 := checkDerefVar(var_glojure_DOT_core_list) + tmp240 := lang.Apply(tmp239, []any{v63}) + tmp241 := checkDerefVar(var_glojure_DOT_core_list) + tmp242 := checkDerefVar(var_glojure_DOT_core_seq) + tmp243 := checkDerefVar(var_glojure_DOT_core_concat) + tmp244 := checkDerefVar(var_glojure_DOT_core_list) + tmp245 := lang.Apply(tmp244, []any{sym_glojure_DOT_core_SLASH_seq}) + tmp246 := checkDerefVar(var_glojure_DOT_core_list) + tmp247 := lang.Apply(tmp246, []any{v63}) + tmp248 := lang.Apply(tmp243, []any{tmp245, tmp247}) + tmp249 := lang.Apply(tmp242, []any{tmp248}) + tmp250 := lang.Apply(tmp241, []any{tmp249}) + tmp251 := lang.Apply(tmp238, []any{tmp240, tmp250}) + tmp252 := lang.Apply(tmp237, []any{tmp251}) + tmp253 := lang.Apply(tmp235, []any{tmp236, tmp252}) + tmp254 := lang.Apply(tmp234, []any{tmp253}) + tmp255 := checkDerefVar(var_glojure_DOT_core_list) + tmp256 := checkDerefVar(var_glojure_DOT_core_seq) + tmp257 := checkDerefVar(var_glojure_DOT_core_concat) + tmp258 := checkDerefVar(var_glojure_DOT_core_list) + tmp259 := lang.Apply(tmp258, []any{sym_if}) + tmp260 := checkDerefVar(var_glojure_DOT_core_list) + tmp261 := checkDerefVar(var_glojure_DOT_core_seq) + tmp262 := checkDerefVar(var_glojure_DOT_core_concat) + tmp263 := checkDerefVar(var_glojure_DOT_core_list) + tmp264 := lang.Apply(tmp263, []any{sym_glojure_DOT_core_SLASH_chunked_DASH_seq_QMARK_}) + tmp265 := checkDerefVar(var_glojure_DOT_core_list) + tmp266 := lang.Apply(tmp265, []any{v63}) + tmp267 := lang.Apply(tmp262, []any{tmp264, tmp266}) + tmp268 := lang.Apply(tmp261, []any{tmp267}) + tmp269 := lang.Apply(tmp260, []any{tmp268}) + tmp270 := checkDerefVar(var_glojure_DOT_core_list) + tmp271 := checkDerefVar(var_glojure_DOT_core_seq) + tmp272 := checkDerefVar(var_glojure_DOT_core_concat) + tmp273 := checkDerefVar(var_glojure_DOT_core_list) + tmp274 := lang.Apply(tmp273, []any{sym_glojure_DOT_core_SLASH_let}) + tmp275 := checkDerefVar(var_glojure_DOT_core_list) + tmp276 := checkDerefVar(var_glojure_DOT_core_apply) + tmp277 := checkDerefVar(var_glojure_DOT_core_vector) + tmp278 := checkDerefVar(var_glojure_DOT_core_seq) + tmp279 := checkDerefVar(var_glojure_DOT_core_concat) + tmp280 := checkDerefVar(var_glojure_DOT_core_list) + tmp281 := lang.Apply(tmp280, []any{sym_c__0__auto__}) + tmp282 := checkDerefVar(var_glojure_DOT_core_list) + tmp283 := checkDerefVar(var_glojure_DOT_core_seq) + tmp284 := checkDerefVar(var_glojure_DOT_core_concat) + tmp285 := checkDerefVar(var_glojure_DOT_core_list) + tmp286 := lang.Apply(tmp285, []any{sym_glojure_DOT_core_SLASH_chunk_DASH_first}) + tmp287 := checkDerefVar(var_glojure_DOT_core_list) + tmp288 := lang.Apply(tmp287, []any{v63}) + tmp289 := lang.Apply(tmp284, []any{tmp286, tmp288}) + tmp290 := lang.Apply(tmp283, []any{tmp289}) + tmp291 := lang.Apply(tmp282, []any{tmp290}) + tmp292 := lang.Apply(tmp279, []any{tmp281, tmp291}) + tmp293 := lang.Apply(tmp278, []any{tmp292}) + tmp294 := lang.Apply(tmp276, []any{tmp277, tmp293}) + tmp295 := lang.Apply(tmp275, []any{tmp294}) + tmp296 := checkDerefVar(var_glojure_DOT_core_list) + tmp297 := checkDerefVar(var_glojure_DOT_core_seq) + tmp298 := checkDerefVar(var_glojure_DOT_core_concat) + tmp299 := checkDerefVar(var_glojure_DOT_core_list) + tmp300 := lang.Apply(tmp299, []any{sym_recur}) + tmp301 := checkDerefVar(var_glojure_DOT_core_list) + tmp302 := checkDerefVar(var_glojure_DOT_core_seq) + tmp303 := checkDerefVar(var_glojure_DOT_core_concat) + tmp304 := checkDerefVar(var_glojure_DOT_core_list) + tmp305 := lang.Apply(tmp304, []any{sym_glojure_DOT_core_SLASH_chunk_DASH_rest}) + tmp306 := checkDerefVar(var_glojure_DOT_core_list) + tmp307 := lang.Apply(tmp306, []any{v63}) + tmp308 := lang.Apply(tmp303, []any{tmp305, tmp307}) + tmp309 := lang.Apply(tmp302, []any{tmp308}) + tmp310 := lang.Apply(tmp301, []any{tmp309}) + tmp311 := checkDerefVar(var_glojure_DOT_core_list) + tmp312 := lang.Apply(tmp311, []any{sym_c__0__auto__}) + tmp313 := checkDerefVar(var_glojure_DOT_core_list) + tmp314 := checkDerefVar(var_glojure_DOT_core_seq) + tmp315 := checkDerefVar(var_glojure_DOT_core_concat) + tmp316 := checkDerefVar(var_glojure_DOT_core_list) + tmp317 := lang.Apply(tmp316, []any{sym_glojure_DOT_core_SLASH_int}) + tmp318 := checkDerefVar(var_glojure_DOT_core_list) + tmp319 := checkDerefVar(var_glojure_DOT_core_seq) + tmp320 := checkDerefVar(var_glojure_DOT_core_concat) + tmp321 := checkDerefVar(var_glojure_DOT_core_list) + tmp322 := lang.Apply(tmp321, []any{sym_glojure_DOT_core_SLASH_count}) + tmp323 := checkDerefVar(var_glojure_DOT_core_list) + tmp324 := lang.Apply(tmp323, []any{sym_c__0__auto__}) + tmp325 := lang.Apply(tmp320, []any{tmp322, tmp324}) + tmp326 := lang.Apply(tmp319, []any{tmp325}) + tmp327 := lang.Apply(tmp318, []any{tmp326}) + tmp328 := lang.Apply(tmp315, []any{tmp317, tmp327}) + tmp329 := lang.Apply(tmp314, []any{tmp328}) + tmp330 := lang.Apply(tmp313, []any{tmp329}) + tmp331 := checkDerefVar(var_glojure_DOT_core_list) + tmp332 := checkDerefVar(var_glojure_DOT_core_seq) + tmp333 := checkDerefVar(var_glojure_DOT_core_concat) + tmp334 := checkDerefVar(var_glojure_DOT_core_list) + tmp335 := lang.Apply(tmp334, []any{sym_glojure_DOT_core_SLASH_int}) + tmp336 := checkDerefVar(var_glojure_DOT_core_list) + tmp337 := lang.Apply(tmp336, []any{int64(0)}) + tmp338 := lang.Apply(tmp333, []any{tmp335, tmp337}) + tmp339 := lang.Apply(tmp332, []any{tmp338}) + tmp340 := lang.Apply(tmp331, []any{tmp339}) + tmp341 := lang.Apply(tmp298, []any{tmp300, tmp310, tmp312, tmp330, tmp340}) + tmp342 := lang.Apply(tmp297, []any{tmp341}) + tmp343 := lang.Apply(tmp296, []any{tmp342}) + tmp344 := lang.Apply(tmp272, []any{tmp274, tmp295, tmp343}) + tmp345 := lang.Apply(tmp271, []any{tmp344}) + tmp346 := lang.Apply(tmp270, []any{tmp345}) + tmp347 := checkDerefVar(var_glojure_DOT_core_list) + tmp348 := checkDerefVar(var_glojure_DOT_core_seq) + tmp349 := checkDerefVar(var_glojure_DOT_core_concat) + tmp350 := checkDerefVar(var_glojure_DOT_core_list) + tmp351 := lang.Apply(tmp350, []any{sym_glojure_DOT_core_SLASH_let}) + tmp352 := checkDerefVar(var_glojure_DOT_core_list) + tmp353 := checkDerefVar(var_glojure_DOT_core_apply) + tmp354 := checkDerefVar(var_glojure_DOT_core_vector) + tmp355 := checkDerefVar(var_glojure_DOT_core_seq) + tmp356 := checkDerefVar(var_glojure_DOT_core_concat) + tmp357 := checkDerefVar(var_glojure_DOT_core_list) + tmp358 := lang.Apply(tmp357, []any{v52}) + tmp359 := checkDerefVar(var_glojure_DOT_core_list) + tmp360 := checkDerefVar(var_glojure_DOT_core_seq) + tmp361 := checkDerefVar(var_glojure_DOT_core_concat) + tmp362 := checkDerefVar(var_glojure_DOT_core_list) + tmp363 := lang.Apply(tmp362, []any{sym_glojure_DOT_core_SLASH_first}) + tmp364 := checkDerefVar(var_glojure_DOT_core_list) + tmp365 := lang.Apply(tmp364, []any{v63}) + tmp366 := lang.Apply(tmp361, []any{tmp363, tmp365}) + tmp367 := lang.Apply(tmp360, []any{tmp366}) + tmp368 := lang.Apply(tmp359, []any{tmp367}) + tmp369 := lang.Apply(tmp356, []any{tmp358, tmp368}) + tmp370 := lang.Apply(tmp355, []any{tmp369}) + tmp371 := lang.Apply(tmp353, []any{tmp354, tmp370}) + tmp372 := lang.Apply(tmp352, []any{tmp371}) + tmp373 := checkDerefVar(var_glojure_DOT_core_list) + tmp374 := lang.Apply(tmp373, []any{v108}) + var tmp375 any + if lang.IsTruthy(v106) { + tmp376 := lang.NewVector(v100) + tmp377 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3264), kw_column, int(52), kw_end_DASH_line, int(3264), kw_end_DASH_column, int(60)) + tmp378, err := lang.WithMeta(tmp376, tmp377.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp375 = tmp378 + } else { + } + tmp379 := lang.Apply(tmp349, []any{tmp351, tmp372, tmp374, tmp375}) + tmp380 := lang.Apply(tmp348, []any{tmp379}) + tmp381 := lang.Apply(tmp347, []any{tmp380}) + tmp382 := lang.Apply(tmp257, []any{tmp259, tmp269, tmp346, tmp381}) + tmp383 := lang.Apply(tmp256, []any{tmp382}) + tmp384 := lang.Apply(tmp255, []any{tmp383}) + tmp385 := lang.Apply(tmp231, []any{tmp233, tmp254, tmp384}) + tmp386 := lang.Apply(tmp230, []any{tmp385}) + tmp387 := lang.Apply(tmp229, []any{tmp386}) + tmp388 := lang.Apply(tmp177, []any{tmp179, tmp191, tmp228, tmp387}) + tmp389 := lang.Apply(tmp176, []any{tmp388}) + tmp390 := lang.Apply(tmp175, []any{tmp389}) + tmp391 := lang.Apply(tmp139, []any{tmp141, tmp174, tmp390}) + tmp392 := lang.Apply(tmp138, []any{tmp391}) + tmp393 := lang.NewVector(true, tmp392) + tmp394 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3250), kw_column, int(24), kw_end_DASH_line, int(3264), kw_end_DASH_column, int(67)) + tmp395, err := lang.WithMeta(tmp393, tmp394.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp60 = tmp395 + } // end let + tmp56 = tmp60 + } + tmp49 = tmp56 + } // end let + tmp37 = tmp49 + } + return tmp37 + }) + v34 = tmp33 + _ = v34 + } + tmp34 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3218), kw_column, int(14), kw_end_DASH_line, int(3264), kw_end_DASH_column, int(72)) + tmp35, err := lang.WithMeta(tmp33, tmp34.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v36 any = tmp35 + _ = v36 + tmp37 := checkDerefVar(var_glojure_DOT_core_nth) + tmp38 := checkDerefVar(var_glojure_DOT_core_seq) + tmp39 := lang.Apply(tmp38, []any{v4}) + tmp40 := lang.Apply(v36, []any{nil, tmp39}) + tmp41 := lang.Apply(tmp37, []any{tmp40, int64(1)}) + tmp32 = tmp41 + } // end let + return tmp32 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_doseq = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_doseq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // doto + { + tmp0 := sym_doto.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_x, sym__AMP_, sym_forms)), kw_doc, "Evaluates x then calls all of the methods and functions with the\n value of x supplied at the front of the given arguments. The forms\n are evaluated in order. Returns x.\n\n (doto (new java.util.HashMap) (.put \"a\" 1) (.put \"b\" 2))", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(11), kw_line, int(3853), kw_end_DASH_line, int(3853))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "gx" + tmp7 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp8 := lang.Apply(tmp7, nil) + var v9 any = tmp8 + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_seq) + tmp11 := checkDerefVar(var_glojure_DOT_core_concat) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_glojure_DOT_core_SLASH_let}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_apply) + tmp16 := checkDerefVar(var_glojure_DOT_core_vector) + tmp17 := checkDerefVar(var_glojure_DOT_core_seq) + tmp18 := checkDerefVar(var_glojure_DOT_core_concat) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v9}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v4}) + tmp23 := lang.Apply(tmp18, []any{tmp20, tmp22}) + tmp24 := lang.Apply(tmp17, []any{tmp23}) + tmp25 := lang.Apply(tmp15, []any{tmp16, tmp24}) + tmp26 := lang.Apply(tmp14, []any{tmp25}) + tmp27 := checkDerefVar(var_glojure_DOT_core_map) + var tmp28 lang.FnFunc + tmp28 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v29 := args[0] + _ = v29 + tmp30 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + var tmp31 any + tmp32 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp33 := lang.Apply(tmp32, []any{v29}) + if lang.IsTruthy(tmp33) { + tmp34 := checkDerefVar(var_glojure_DOT_core_seq) + tmp35 := checkDerefVar(var_glojure_DOT_core_concat) + tmp36 := checkDerefVar(var_glojure_DOT_core_list) + tmp37 := checkDerefVar(var_glojure_DOT_core_first) + tmp38 := lang.Apply(tmp37, []any{v29}) + tmp39 := lang.Apply(tmp36, []any{tmp38}) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{v9}) + tmp42 := checkDerefVar(var_glojure_DOT_core_next) + tmp43 := lang.Apply(tmp42, []any{v29}) + tmp44 := lang.Apply(tmp35, []any{tmp39, tmp41, tmp43}) + tmp45 := lang.Apply(tmp34, []any{tmp44}) + tmp31 = tmp45 + } else { + tmp46 := checkDerefVar(var_glojure_DOT_core_seq) + tmp47 := checkDerefVar(var_glojure_DOT_core_concat) + tmp48 := checkDerefVar(var_glojure_DOT_core_list) + tmp49 := lang.Apply(tmp48, []any{v29}) + tmp50 := checkDerefVar(var_glojure_DOT_core_list) + tmp51 := lang.Apply(tmp50, []any{v9}) + tmp52 := lang.Apply(tmp47, []any{tmp49, tmp51}) + tmp53 := lang.Apply(tmp46, []any{tmp52}) + tmp31 = tmp53 + } + tmp54 := checkDerefVar(var_glojure_DOT_core_meta) + tmp55 := lang.Apply(tmp54, []any{v29}) + tmp56 := lang.Apply(tmp30, []any{tmp31, tmp55}) + return tmp56 + }) + tmp29 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3863), kw_column, int(17), kw_end_DASH_line, int(3868), kw_end_DASH_column, int(30)) + tmp30, err := lang.WithMeta(tmp28, tmp29.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp31 := lang.Apply(tmp27, []any{tmp30, v5}) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := lang.Apply(tmp32, []any{v9}) + tmp34 := lang.Apply(tmp11, []any{tmp13, tmp26, tmp31, tmp33}) + tmp35 := lang.Apply(tmp10, []any{tmp34}) + tmp6 = tmp35 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_doto = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_doto.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // drop-last + { + tmp0 := sym_drop_DASH_last.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll), lang.NewVector(sym_n, sym_coll)), kw_doc, "Return a lazy sequence of all but the last n (default 1) items in coll", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(2932), kw_end_DASH_line, int(2932))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_drop_DASH_last) + tmp4 := lang.Apply(tmp3, []any{int64(1), v2}) + return tmp4 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_map) + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + return v6 + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2937), kw_column, int(18), kw_end_DASH_line, int(2937), kw_end_DASH_column, int(29)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp8 := checkDerefVar(var_glojure_DOT_core_drop) + tmp9 := lang.Apply(tmp8, []any{v2, v3}) + tmp10 := lang.Apply(tmp4, []any{tmp7, v3, tmp9}) + return tmp10 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_drop_DASH_last = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_drop_DASH_last.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // emit-extend-protocol + { + tmp0 := sym_emit_DASH_extend_DASH_protocol.WithMeta(lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(205), kw_column, int(8), kw_end_DASH_line, int(205), kw_end_DASH_column, int(27), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_p, sym_specs)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "impls" + tmp5 := checkDerefVar(var_glojure_DOT_core_parse_DASH_impls) + tmp6 := lang.Apply(tmp5, []any{v3}) + var v7 any = tmp6 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_do}) + tmp12 := checkDerefVar(var_glojure_DOT_core_map) + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v14 := args[0] + _ = v14 + var tmp15 any + { // let + // let binding "vec__983" + var v16 any = v14 + _ = v16 + // let binding "t" + tmp17 := checkDerefVar(var_glojure_DOT_core_nth) + tmp18 := lang.Apply(tmp17, []any{v16, int64(0), nil}) + var v19 any = tmp18 + _ = v19 + // let binding "fs" + tmp20 := checkDerefVar(var_glojure_DOT_core_nth) + tmp21 := lang.Apply(tmp20, []any{v16, int64(1), nil}) + var v22 any = tmp21 + _ = v22 + tmp23 := checkDerefVar(var_glojure_DOT_core_seq) + tmp24 := checkDerefVar(var_glojure_DOT_core_concat) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := lang.Apply(tmp25, []any{sym_glojure_DOT_core_SLASH_extend_DASH_type}) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{v19}) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{v2}) + tmp31 := lang.Apply(tmp24, []any{tmp26, tmp28, tmp30, v22}) + tmp32 := lang.Apply(tmp23, []any{tmp31}) + tmp15 = tmp32 + } // end let + return tmp15 + }) + tmp14 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(208), kw_column, int(15), kw_end_DASH_line, int(209), kw_end_DASH_column, int(42)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp16 := lang.Apply(tmp12, []any{tmp15, v7}) + tmp17 := lang.Apply(tmp9, []any{tmp11, tmp16}) + tmp18 := lang.Apply(tmp8, []any{tmp17}) + tmp4 = tmp18 + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_emit_DASH_extend_DASH_protocol = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_emit_DASH_extend_DASH_protocol.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // emit-hinted-impl + { + tmp0 := sym_emit_DASH_hinted_DASH_impl.WithMeta(lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(163), kw_column, int(8), kw_end_DASH_line, int(163), kw_end_DASH_column, int(23), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_c, lang.NewVector(sym_p, sym_fs))), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "vec__972" + var v5 any = v3 + _ = v5 + // let binding "p" + tmp6 := checkDerefVar(var_glojure_DOT_core_nth) + tmp7 := lang.Apply(tmp6, []any{v5, int64(0), nil}) + var v8 any = tmp7 + _ = v8 + // let binding "fs" + tmp9 := checkDerefVar(var_glojure_DOT_core_nth) + tmp10 := lang.Apply(tmp9, []any{v5, int64(1), nil}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + { // let + // let binding "hint" + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v14 := args[0] + _ = v14 + var tmp15 any + { // let + // let binding "specs" + var tmp16 any + tmp17 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp18 := checkDerefVar(var_glojure_DOT_core_first) + tmp19 := lang.Apply(tmp18, []any{v14}) + tmp20 := lang.Apply(tmp17, []any{tmp19}) + if lang.IsTruthy(tmp20) { + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v14}) + tmp16 = tmp22 + } else { + tmp16 = v14 + } + var v23 any = tmp16 + _ = v23 + tmp24 := checkDerefVar(var_glojure_DOT_core_map) + var tmp25 lang.FnFunc + tmp25 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v26 := args[0] + _ = v26 + var tmp27 any + { // let + // let binding "vec__976" + var v28 any = v26 + _ = v28 + // let binding "seq__977" + tmp29 := checkDerefVar(var_glojure_DOT_core_seq) + tmp30 := lang.Apply(tmp29, []any{v28}) + var v31 any = tmp30 + _ = v31 + // let binding "first__978" + tmp32 := checkDerefVar(var_glojure_DOT_core_first) + tmp33 := lang.Apply(tmp32, []any{v31}) + var v34 any = tmp33 + _ = v34 + // let binding "seq__977" + tmp35 := checkDerefVar(var_glojure_DOT_core_next) + tmp36 := lang.Apply(tmp35, []any{v31}) + var v37 any = tmp36 + _ = v37 + // let binding "vec__979" + var v38 any = v34 + _ = v38 + // let binding "seq__980" + tmp39 := checkDerefVar(var_glojure_DOT_core_seq) + tmp40 := lang.Apply(tmp39, []any{v38}) + var v41 any = tmp40 + _ = v41 + // let binding "first__981" + tmp42 := checkDerefVar(var_glojure_DOT_core_first) + tmp43 := lang.Apply(tmp42, []any{v41}) + var v44 any = tmp43 + _ = v44 + // let binding "seq__980" + tmp45 := checkDerefVar(var_glojure_DOT_core_next) + tmp46 := lang.Apply(tmp45, []any{v41}) + var v47 any = tmp46 + _ = v47 + // let binding "target" + var v48 any = v44 + _ = v48 + // let binding "args" + var v49 any = v47 + _ = v49 + // let binding "body" + var v50 any = v37 + _ = v50 + tmp51 := checkDerefVar(var_glojure_DOT_core_cons) + tmp52 := checkDerefVar(var_glojure_DOT_core_apply) + tmp53 := checkDerefVar(var_glojure_DOT_core_vector) + tmp54 := checkDerefVar(var_glojure_DOT_core_vary_DASH_meta) + tmp55 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp56 := lang.Apply(tmp54, []any{v48, tmp55, kw_tag, v2}) + tmp57 := lang.Apply(tmp52, []any{tmp53, tmp56, v49}) + tmp58 := lang.Apply(tmp51, []any{tmp57, v50}) + tmp27 = tmp58 + } // end let + return tmp27 + }) + tmp26 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(168), kw_column, int(23), kw_end_DASH_line, int(170), kw_end_DASH_column, int(36)) + tmp27, err := lang.WithMeta(tmp25, tmp26.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp28 := lang.Apply(tmp24, []any{tmp27, v23}) + tmp15 = tmp28 + } // end let + return tmp15 + }) + tmp14 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(164), kw_column, int(14), kw_end_DASH_line, int(171), kw_end_DASH_column, int(30)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v16 any = tmp15 + _ = v16 + tmp17 := checkDerefVar(var_glojure_DOT_core_zipmap) + tmp18 := checkDerefVar(var_glojure_DOT_core_map) + var tmp19 lang.FnFunc + tmp19 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v20 := args[0] + _ = v20 + tmp21 := checkDerefVar(var_glojure_DOT_core_keyword) + tmp22 := checkDerefVar(var_glojure_DOT_core_name) + tmp23 := checkDerefVar(var_glojure_DOT_core_first) + tmp24 := lang.Apply(tmp23, []any{v20}) + tmp25 := lang.Apply(tmp22, []any{tmp24}) + tmp26 := lang.Apply(tmp21, []any{tmp25}) + return tmp26 + }) + tmp20 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(172), kw_column, int(21), kw_end_DASH_line, int(172), kw_end_DASH_column, int(46)) + tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp22 := lang.Apply(tmp18, []any{tmp21, v11}) + tmp23 := checkDerefVar(var_glojure_DOT_core_map) + var tmp24 lang.FnFunc + tmp24 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v25 := args[0] + _ = v25 + tmp26 := checkDerefVar(var_glojure_DOT_core_cons) + tmp27 := checkDerefVar(var_glojure_DOT_core_drop) + tmp28 := lang.Apply(tmp27, []any{int64(1), v25}) + tmp29 := lang.Apply(v16, []any{tmp28}) + tmp30 := lang.Apply(tmp26, []any{sym_glojure_DOT_core_SLASH_fn, tmp29}) + return tmp30 + }) + tmp25 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(173), kw_column, int(21), kw_end_DASH_line, int(173), kw_end_DASH_column, int(49)) + tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp27 := lang.Apply(tmp23, []any{tmp26, v11}) + tmp28 := lang.Apply(tmp17, []any{tmp22, tmp27}) + tmp29 := lang.NewVector(v8, tmp28) + tmp30 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(172), kw_column, int(5), kw_end_DASH_line, int(173), kw_end_DASH_column, int(55)) + tmp31, err := lang.WithMeta(tmp29, tmp30.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp12 = tmp31 + } // end let + tmp4 = tmp12 + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_emit_DASH_hinted_DASH_impl = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_emit_DASH_hinted_DASH_impl.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // extend-protocol + { + tmp0 := sym_extend_DASH_protocol.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_p, sym__AMP_, sym_specs)), kw_doc, "Useful when you want to provide several implementations of the same\n protocol all at once. Takes a single protocol and the implementation\n of that protocol for one or more types.\n\n (extend-protocol Protocol\n AType\n (foo [x] ...)\n (bar [x y] ...)\n BType\n (foo [x] ...)\n (bar [x y] ...)\n AClass\n (foo [x] ...)\n (bar [x y] ...)\n nil\n (foo [x] ...)\n (bar [x y] ...))\n\n expands into:\n\n (do\n (clojure.core/extend-type AType Protocol \n (foo [x] ...) \n (bar [x y] ...))\n (clojure.core/extend-type BType Protocol \n (foo [x] ...) \n (bar [x y] ...))\n (clojure.core/extend-type AClass Protocol \n (foo [x] ...) \n (bar [x y] ...))\n (clojure.core/extend-type nil Protocol \n (foo [x] ...) \n (bar [x y] ...)))", kw_file, "glojure/core_deftype.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(25), kw_column, int(11), kw_line, int(212), kw_end_DASH_line, int(212))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_emit_DASH_extend_DASH_protocol) + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_extend_DASH_protocol = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_extend_DASH_protocol.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // fits-table? + { + tmp0 := sym_fits_DASH_table_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ints)), kw_doc, "Returns true if the collection of ints can fit within the\n max-table-switch-size, false otherwise.", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(8), kw_line, int(6625), kw_end_DASH_line, int(6625), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp4 := checkDerefVar(var_glojure_DOT_core__DASH_) + tmp5 := checkDerefVar(var_glojure_DOT_core_apply) + tmp6 := checkDerefVar(var_glojure_DOT_core_max) + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := lang.Apply(tmp7, []any{v2}) + tmp9 := lang.Apply(tmp5, []any{tmp6, tmp8}) + tmp10 := checkDerefVar(var_glojure_DOT_core_apply) + tmp11 := checkDerefVar(var_glojure_DOT_core_min) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := lang.Apply(tmp12, []any{v2}) + tmp14 := lang.Apply(tmp10, []any{tmp11, tmp13}) + tmp15 := lang.Apply(tmp4, []any{tmp9, tmp14}) + tmp16 := checkDerefVar(var_glojure_DOT_core_max_DASH_switch_DASH_table_DASH_size) + tmp17 := lang.Apply(tmp3, []any{tmp15, tmp16}) + return tmp17 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_fits_DASH_table_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_fits_DASH_table_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // fn + { + tmp0 := sym_fn.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_sigs)), kw_doc, "params => positional-params*, or positional-params* & rest-param\n positional-param => binding-form\n rest-param => binding-form\n binding-form => name, or destructuring-form\n\n Defines a function.\n\n See https://glojure.org/reference/special_forms#fn for more information", kw_forms, lang.NewVector(lang.NewList(sym_fn, sym_name_QMARK_, lang.NewVector(sym_params_STAR_), sym_exprs_STAR_), lang.NewList(sym_fn, sym_name_QMARK_, lang.NewList(lang.NewVector(sym_params_STAR_), sym_exprs_STAR_), sym__PLUS_)), kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(11), kw_line, int(4533), kw_end_DASH_line, int(4533), kw_special_DASH_form, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "name" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp8 := checkDerefVar(var_glojure_DOT_core_first) + tmp9 := lang.Apply(tmp8, []any{v4}) + tmp10 := lang.Apply(tmp7, []any{tmp9}) + if lang.IsTruthy(tmp10) { + tmp11 := checkDerefVar(var_glojure_DOT_core_first) + tmp12 := lang.Apply(tmp11, []any{v4}) + tmp6 = tmp12 + } else { + } + var v13 any = tmp6 + _ = v13 + // let binding "sigs" + var tmp14 any + if lang.IsTruthy(v13) { + tmp15 := checkDerefVar(var_glojure_DOT_core_next) + tmp16 := lang.Apply(tmp15, []any{v4}) + tmp14 = tmp16 + } else { + tmp14 = v4 + } + var v17 any = tmp14 + _ = v17 + // let binding "sigs" + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp20 := checkDerefVar(var_glojure_DOT_core_first) + tmp21 := lang.Apply(tmp20, []any{v17}) + tmp22 := lang.Apply(tmp19, []any{tmp21}) + if lang.IsTruthy(tmp22) { + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := lang.Apply(tmp23, []any{v17}) + tmp18 = tmp24 + } else { + var tmp25 any + tmp26 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp27 := checkDerefVar(var_glojure_DOT_core_first) + tmp28 := lang.Apply(tmp27, []any{v17}) + tmp29 := lang.Apply(tmp26, []any{tmp28}) + if lang.IsTruthy(tmp29) { + tmp25 = v17 + } else { + var tmp30 any + tmp31 := checkDerefVar(var_glojure_DOT_core_seq) + tmp32 := lang.Apply(tmp31, []any{v17}) + if lang.IsTruthy(tmp32) { + tmp33 := checkDerefVar(var_glojure_DOT_core_str) + tmp34 := checkDerefVar(var_glojure_DOT_core_first) + tmp35 := lang.Apply(tmp34, []any{v17}) + tmp36 := lang.Apply(tmp33, []any{"Parameter declaration ", tmp35, " should be a vector"}) + tmp30 = tmp36 + } else { + tmp37 := checkDerefVar(var_glojure_DOT_core_str) + tmp38 := lang.Apply(tmp37, []any{"Parameter declaration missing"}) + tmp30 = tmp38 + } + tmp39 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp39) + } + tmp18 = tmp25 + } + var v40 any = tmp18 + _ = v40 + // let binding "psig" + var tmp41 lang.FnFunc + tmp41 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v42 := args[0] + _ = v42 + var tmp43 any + tmp44 := checkDerefVar(var_glojure_DOT_core_not) + tmp45 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp46 := lang.Apply(tmp45, []any{v42}) + tmp47 := lang.Apply(tmp44, []any{tmp46}) + if lang.IsTruthy(tmp47) { + tmp48 := checkDerefVar(var_glojure_DOT_core_str) + tmp49 := lang.Apply(tmp48, []any{"Invalid signature ", v42, " should be a list"}) + tmp50 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp49}) + panic(tmp50) + } else { + } + _ = tmp43 + var tmp51 any + { // let + // let binding "vec__704" + var v52 any = v42 + _ = v52 + // let binding "seq__705" + tmp53 := checkDerefVar(var_glojure_DOT_core_seq) + tmp54 := lang.Apply(tmp53, []any{v52}) + var v55 any = tmp54 + _ = v55 + // let binding "first__706" + tmp56 := checkDerefVar(var_glojure_DOT_core_first) + tmp57 := lang.Apply(tmp56, []any{v55}) + var v58 any = tmp57 + _ = v58 + // let binding "seq__705" + tmp59 := checkDerefVar(var_glojure_DOT_core_next) + tmp60 := lang.Apply(tmp59, []any{v55}) + var v61 any = tmp60 + _ = v61 + // let binding "params" + var v62 any = v58 + _ = v62 + // let binding "body" + var v63 any = v61 + _ = v63 + // let binding "_" + var tmp64 any + tmp65 := checkDerefVar(var_glojure_DOT_core_not) + tmp66 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp67 := lang.Apply(tmp66, []any{v62}) + tmp68 := lang.Apply(tmp65, []any{tmp67}) + if lang.IsTruthy(tmp68) { + var tmp69 any + tmp70 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp71 := checkDerefVar(var_glojure_DOT_core_first) + tmp72 := lang.Apply(tmp71, []any{v40}) + tmp73 := lang.Apply(tmp70, []any{tmp72}) + if lang.IsTruthy(tmp73) { + tmp74 := checkDerefVar(var_glojure_DOT_core_str) + tmp75 := lang.Apply(tmp74, []any{"Parameter declaration ", v62, " should be a vector"}) + tmp69 = tmp75 + } else { + tmp76 := checkDerefVar(var_glojure_DOT_core_str) + tmp77 := lang.Apply(tmp76, []any{"Invalid signature ", v42, " should be a list"}) + tmp69 = tmp77 + } + tmp78 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp69}) + panic(tmp78) + } else { + } + var v79 any = tmp64 + _ = v79 + // let binding "conds" + var tmp80 any + var tmp81 any + { // let + // let binding "and__0__auto__" + tmp82 := checkDerefVar(var_glojure_DOT_core_next) + tmp83 := lang.Apply(tmp82, []any{v63}) + var v84 any = tmp83 + _ = v84 + var tmp85 any + if lang.IsTruthy(v84) { + tmp86 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp87 := checkDerefVar(var_glojure_DOT_core_first) + tmp88 := lang.Apply(tmp87, []any{v63}) + tmp89 := lang.Apply(tmp86, []any{tmp88}) + tmp85 = tmp89 + } else { + tmp85 = v84 + } + tmp81 = tmp85 + } // end let + if lang.IsTruthy(tmp81) { + tmp82 := checkDerefVar(var_glojure_DOT_core_first) + tmp83 := lang.Apply(tmp82, []any{v63}) + tmp80 = tmp83 + } else { + } + var v84 any = tmp80 + _ = v84 + // let binding "body" + var tmp85 any + if lang.IsTruthy(v84) { + tmp86 := checkDerefVar(var_glojure_DOT_core_next) + tmp87 := lang.Apply(tmp86, []any{v63}) + tmp85 = tmp87 + } else { + tmp85 = v63 + } + var v88 any = tmp85 + _ = v88 + // let binding "conds" + var tmp89 any + { // let + // let binding "or__0__auto__" + var v90 any = v84 + _ = v90 + var tmp91 any + if lang.IsTruthy(v90) { + tmp91 = v90 + } else { + tmp92 := checkDerefVar(var_glojure_DOT_core_meta) + tmp93 := lang.Apply(tmp92, []any{v62}) + tmp91 = tmp93 + } + tmp89 = tmp91 + } // end let + var v90 any = tmp89 + _ = v90 + // let binding "pre" + tmp91 := lang.Apply(kw_pre, []any{v90}) + var v92 any = tmp91 + _ = v92 + // let binding "post" + tmp93 := lang.Apply(kw_post, []any{v90}) + var v94 any = tmp93 + _ = v94 + // let binding "body" + var tmp95 any + if lang.IsTruthy(v94) { + tmp96 := checkDerefVar(var_glojure_DOT_core_seq) + tmp97 := checkDerefVar(var_glojure_DOT_core_concat) + tmp98 := checkDerefVar(var_glojure_DOT_core_list) + tmp99 := checkDerefVar(var_glojure_DOT_core_seq) + tmp100 := checkDerefVar(var_glojure_DOT_core_concat) + tmp101 := checkDerefVar(var_glojure_DOT_core_list) + tmp102 := lang.Apply(tmp101, []any{sym_glojure_DOT_core_SLASH_let}) + tmp103 := checkDerefVar(var_glojure_DOT_core_list) + tmp104 := checkDerefVar(var_glojure_DOT_core_apply) + tmp105 := checkDerefVar(var_glojure_DOT_core_vector) + tmp106 := checkDerefVar(var_glojure_DOT_core_seq) + tmp107 := checkDerefVar(var_glojure_DOT_core_concat) + tmp108 := checkDerefVar(var_glojure_DOT_core_list) + tmp109 := lang.Apply(tmp108, []any{sym__PCT_}) + tmp110 := checkDerefVar(var_glojure_DOT_core_list) + var tmp111 any + tmp112 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp113 := checkDerefVar(var_glojure_DOT_core_count) + tmp114 := lang.Apply(tmp113, []any{v88}) + tmp115 := lang.Apply(tmp112, []any{int64(1), tmp114}) + if lang.IsTruthy(tmp115) { + tmp116 := checkDerefVar(var_glojure_DOT_core_seq) + tmp117 := checkDerefVar(var_glojure_DOT_core_concat) + tmp118 := checkDerefVar(var_glojure_DOT_core_list) + tmp119 := lang.Apply(tmp118, []any{sym_do}) + tmp120 := lang.Apply(tmp117, []any{tmp119, v88}) + tmp121 := lang.Apply(tmp116, []any{tmp120}) + tmp111 = tmp121 + } else { + tmp122 := checkDerefVar(var_glojure_DOT_core_first) + tmp123 := lang.Apply(tmp122, []any{v88}) + tmp111 = tmp123 + } + tmp124 := lang.Apply(tmp110, []any{tmp111}) + tmp125 := lang.Apply(tmp107, []any{tmp109, tmp124}) + tmp126 := lang.Apply(tmp106, []any{tmp125}) + tmp127 := lang.Apply(tmp104, []any{tmp105, tmp126}) + tmp128 := lang.Apply(tmp103, []any{tmp127}) + tmp129 := checkDerefVar(var_glojure_DOT_core_map) + var tmp130 lang.FnFunc + tmp130 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v131 := args[0] + _ = v131 + tmp132 := checkDerefVar(var_glojure_DOT_core_seq) + tmp133 := checkDerefVar(var_glojure_DOT_core_concat) + tmp134 := checkDerefVar(var_glojure_DOT_core_list) + tmp135 := lang.Apply(tmp134, []any{sym_glojure_DOT_core_SLASH_assert}) + tmp136 := checkDerefVar(var_glojure_DOT_core_list) + tmp137 := lang.Apply(tmp136, []any{v131}) + tmp138 := lang.Apply(tmp133, []any{tmp135, tmp137}) + tmp139 := lang.Apply(tmp132, []any{tmp138}) + return tmp139 + }) + tmp131 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4582), kw_column, int(41), kw_end_DASH_line, int(4582), kw_end_DASH_column, int(62)) + tmp132, err := lang.WithMeta(tmp130, tmp131.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp133 := lang.Apply(tmp129, []any{tmp132, v94}) + tmp134 := checkDerefVar(var_glojure_DOT_core_list) + tmp135 := lang.Apply(tmp134, []any{sym__PCT_}) + tmp136 := lang.Apply(tmp100, []any{tmp102, tmp128, tmp133, tmp135}) + tmp137 := lang.Apply(tmp99, []any{tmp136}) + tmp138 := lang.Apply(tmp98, []any{tmp137}) + tmp139 := lang.Apply(tmp97, []any{tmp138}) + tmp140 := lang.Apply(tmp96, []any{tmp139}) + tmp95 = tmp140 + } else { + tmp95 = v88 + } + var v141 any = tmp95 + _ = v141 + // let binding "body" + var tmp142 any + if lang.IsTruthy(v92) { + tmp143 := checkDerefVar(var_glojure_DOT_core_concat) + tmp144 := checkDerefVar(var_glojure_DOT_core_map) + var tmp145 lang.FnFunc + tmp145 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v146 := args[0] + _ = v146 + tmp147 := checkDerefVar(var_glojure_DOT_core_seq) + tmp148 := checkDerefVar(var_glojure_DOT_core_concat) + tmp149 := checkDerefVar(var_glojure_DOT_core_list) + tmp150 := lang.Apply(tmp149, []any{sym_glojure_DOT_core_SLASH_assert}) + tmp151 := checkDerefVar(var_glojure_DOT_core_list) + tmp152 := lang.Apply(tmp151, []any{v146}) + tmp153 := lang.Apply(tmp148, []any{tmp150, tmp152}) + tmp154 := lang.Apply(tmp147, []any{tmp153}) + return tmp154 + }) + tmp146 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4586), kw_column, int(44), kw_end_DASH_line, int(4586), kw_end_DASH_column, int(65)) + tmp147, err := lang.WithMeta(tmp145, tmp146.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp148 := lang.Apply(tmp144, []any{tmp147, v92}) + tmp149 := lang.Apply(tmp143, []any{tmp148, v141}) + tmp142 = tmp149 + } else { + tmp142 = v141 + } + var v150 any = tmp142 + _ = v150 + tmp151 := checkDerefVar(var_glojure_DOT_core_maybe_DASH_destructured) + tmp152 := lang.Apply(tmp151, []any{v62, v150}) + tmp51 = tmp152 + } // end let + return tmp51 + }) + tmp42 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4558), kw_column, int(16), kw_end_DASH_line, int(4589), kw_end_DASH_column, int(53)) + tmp43, err := lang.WithMeta(tmp41, tmp42.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v44 any = tmp43 + _ = v44 + // let binding "new-sigs" + tmp45 := checkDerefVar(var_glojure_DOT_core_map) + tmp46 := lang.Apply(tmp45, []any{v44, v40}) + var v47 any = tmp46 + _ = v47 + tmp48 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + var tmp49 any + if lang.IsTruthy(v13) { + tmp50 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp51 := lang.Apply(tmp50, []any{sym_fn_STAR_, v13, v47}) + tmp49 = tmp51 + } else { + tmp52 := checkDerefVar(var_glojure_DOT_core_cons) + tmp53 := lang.Apply(tmp52, []any{sym_fn_STAR_, v47}) + tmp49 = tmp53 + } + tmp54 := checkDerefVar(var_glojure_DOT_core_meta) + tmp55 := lang.Apply(tmp54, []any{v2}) + tmp56 := lang.Apply(tmp48, []any{tmp49, tmp55}) + tmp5 = tmp56 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_fn = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_fn.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // import + { + tmp0 := sym_import.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_import_DASH_symbols_DASH_or_DASH_lists)), kw_doc, "import-list => (package-symbol class-name-symbols*)\n\n For each name in class-name-symbols, adds a mapping from name to the\n class named by package.name to the current namespace. Use :import in the ns\n macro in preference to calling this directly.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(11), kw_line, int(3426), kw_end_DASH_line, int(3426))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "specs" + tmp6 := checkDerefVar(var_glojure_DOT_core_map) + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v8 := args[0] + _ = v8 + var tmp9 any + var tmp10 any + { // let + // let binding "and__0__auto__" + tmp11 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp12 := lang.Apply(tmp11, []any{v8}) + var v13 any = tmp12 + _ = v13 + var tmp14 any + if lang.IsTruthy(v13) { + tmp15 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp16 := checkDerefVar(var_glojure_DOT_core_first) + tmp17 := lang.Apply(tmp16, []any{v8}) + tmp18 := lang.Apply(tmp15, []any{sym_quote, tmp17}) + tmp14 = tmp18 + } else { + tmp14 = v13 + } + tmp10 = tmp14 + } // end let + if lang.IsTruthy(tmp10) { + tmp11 := checkDerefVar(var_glojure_DOT_core_second) + tmp12 := lang.Apply(tmp11, []any{v8}) + tmp9 = tmp12 + } else { + tmp9 = v8 + } + return tmp9 + }) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3434), kw_column, int(20), kw_end_DASH_line, int(3434), kw_end_DASH_column, int(73)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp10 := lang.Apply(tmp6, []any{tmp9, v4}) + var v11 any = tmp10 + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_do}) + tmp16 := checkDerefVar(var_glojure_DOT_core_map) + var tmp17 lang.FnFunc + tmp17 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v18 := args[0] + _ = v18 + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Import, v18}) + return tmp20 + }) + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3436), kw_column, int(17), kw_end_DASH_line, int(3436), kw_end_DASH_column, int(73)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp20 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp21 lang.FnFunc + tmp21 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v22 := args[0] + _ = v22 + v23 := args[1] + _ = v23 + var tmp24 any + tmp25 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp26 := lang.Apply(tmp25, []any{v23}) + if lang.IsTruthy(tmp26) { + tmp27 := checkDerefVar(var_glojure_DOT_core_conj) + tmp28 := checkDerefVar(var_glojure_DOT_core_name) + tmp29 := lang.Apply(tmp28, []any{v23}) + tmp30 := lang.Apply(tmp27, []any{v22, tmp29}) + tmp24 = tmp30 + } else { + var tmp31 any + { // let + // let binding "p" + tmp32 := checkDerefVar(var_glojure_DOT_core_first) + tmp33 := lang.Apply(tmp32, []any{v23}) + var v34 any = tmp33 + _ = v34 + // let binding "cs" + tmp35 := checkDerefVar(var_glojure_DOT_core_rest) + tmp36 := lang.Apply(tmp35, []any{v23}) + var v37 any = tmp36 + _ = v37 + tmp38 := checkDerefVar(var_glojure_DOT_core_into1) + tmp39 := checkDerefVar(var_glojure_DOT_core_map) + var tmp40 lang.FnFunc + tmp40 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v41 := args[0] + _ = v41 + tmp42 := checkDerefVar(var_glojure_DOT_core_str) + tmp43 := lang.Apply(tmp42, []any{v34, ".", v41}) + return tmp43 + }) + tmp41 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3441), kw_column, int(45), kw_end_DASH_line, int(3441), kw_end_DASH_column, int(58)) + tmp42, err := lang.WithMeta(tmp40, tmp41.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp43 := lang.Apply(tmp39, []any{tmp42, v37}) + tmp44 := lang.Apply(tmp38, []any{v22, tmp43}) + tmp31 = tmp44 + } // end let + tmp24 = tmp31 + } + return tmp24 + }) + tmp22 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3437), kw_column, int(26), kw_end_DASH_line, int(3441), kw_end_DASH_column, int(66)) + tmp23, err := lang.WithMeta(tmp21, tmp22.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp24 := lang.NewVector() + tmp25 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3442), kw_column, int(25), kw_end_DASH_line, int(3442), kw_end_DASH_column, int(26)) + tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp27 := lang.Apply(tmp20, []any{tmp23, tmp26, v11}) + tmp28 := lang.Apply(tmp16, []any{tmp19, tmp27}) + tmp29 := lang.Apply(tmp13, []any{tmp15, tmp28}) + tmp30 := lang.Apply(tmp12, []any{tmp29}) + tmp5 = tmp30 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_import = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_import.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // interleave + { + tmp0 := sym_interleave.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_c1), lang.NewVector(sym_c1, sym_c2), lang.NewVector(sym_c1, sym_c2, sym__AMP_, sym_colls)), kw_doc, "Returns a lazy seq of the first item in each coll, then the second etc.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4308), kw_end_DASH_line, int(4308))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return lang.NewList() + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + return v2 + }) + tmp4 := lang.Apply(lang.NewLazySeq, []any{tmp3}) + return tmp4 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp5 any + { // let + // let binding "s1" + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := lang.Apply(tmp6, []any{v2}) + var v8 any = tmp7 + _ = v8 + // let binding "s2" + tmp9 := checkDerefVar(var_glojure_DOT_core_seq) + tmp10 := lang.Apply(tmp9, []any{v3}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + var tmp13 any + { // let + // let binding "and__0__auto__" + var v14 any = v8 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + tmp15 = v11 + } else { + tmp15 = v14 + } + tmp13 = tmp15 + } // end let + if lang.IsTruthy(tmp13) { + tmp14 := checkDerefVar(var_glojure_DOT_core_cons) + tmp15 := checkDerefVar(var_glojure_DOT_core_first) + tmp16 := lang.Apply(tmp15, []any{v8}) + tmp17 := checkDerefVar(var_glojure_DOT_core_cons) + tmp18 := checkDerefVar(var_glojure_DOT_core_first) + tmp19 := lang.Apply(tmp18, []any{v11}) + tmp20 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp21 := checkDerefVar(var_glojure_DOT_core_rest) + tmp22 := lang.Apply(tmp21, []any{v8}) + tmp23 := checkDerefVar(var_glojure_DOT_core_rest) + tmp24 := lang.Apply(tmp23, []any{v11}) + tmp25 := lang.Apply(tmp20, []any{tmp22, tmp24}) + tmp26 := lang.Apply(tmp17, []any{tmp19, tmp25}) + tmp27 := lang.Apply(tmp14, []any{tmp16, tmp26}) + tmp12 = tmp27 + } else { + } + tmp5 = tmp12 + } // end let + return tmp5 + }) + tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) + return tmp5 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp6 any + { // let + // let binding "ss" + tmp7 := checkDerefVar(var_glojure_DOT_core_map) + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_conj) + tmp10 := lang.Apply(tmp9, []any{v4, v3, v2}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + tmp14 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + tmp15 := checkDerefVar(var_glojure_DOT_core_identity) + tmp16 := lang.Apply(tmp14, []any{tmp15, v12}) + if lang.IsTruthy(tmp16) { + tmp17 := checkDerefVar(var_glojure_DOT_core_concat) + tmp18 := checkDerefVar(var_glojure_DOT_core_map) + tmp19 := checkDerefVar(var_glojure_DOT_core_first) + tmp20 := lang.Apply(tmp18, []any{tmp19, v12}) + tmp21 := checkDerefVar(var_glojure_DOT_core_apply) + tmp22 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp23 := checkDerefVar(var_glojure_DOT_core_map) + tmp24 := checkDerefVar(var_glojure_DOT_core_rest) + tmp25 := lang.Apply(tmp23, []any{tmp24, v12}) + tmp26 := lang.Apply(tmp21, []any{tmp22, tmp25}) + tmp27 := lang.Apply(tmp17, []any{tmp20, tmp26}) + tmp13 = tmp27 + } else { + } + tmp6 = tmp13 + } // end let + return tmp6 + }) + tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_interleave = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_interleave.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // interpose + { + tmp0 := sym_interpose.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_sep), lang.NewVector(sym_sep, sym_coll)), kw_doc, "Returns a lazy seq of the elements of coll separated by sep.\n Returns a stateful transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(5230), kw_end_DASH_line, int(5230))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 any + { // let + // let binding "started" + tmp6 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) + tmp7 := lang.Apply(tmp6, []any{false}) + var v8 any = tmp7 + _ = v8 + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp10 := lang.Apply(v4, nil) + return tmp10 + case 1: + v10 := args[0] + _ = v10 + tmp11 := lang.Apply(v4, []any{v10}) + return tmp11 + case 2: + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + var tmp12 any + tmp13 := checkDerefVar(var_glojure_DOT_core_deref) + tmp14 := lang.Apply(tmp13, []any{v8}) + if lang.IsTruthy(tmp14) { + var tmp15 any + { // let + // let binding "sepr" + tmp16 := lang.Apply(v4, []any{v10, v2}) + var v17 any = tmp16 + _ = v17 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) + tmp20 := lang.Apply(tmp19, []any{v17}) + if lang.IsTruthy(tmp20) { + tmp18 = v17 + } else { + tmp21 := lang.Apply(v4, []any{v17, v11}) + tmp18 = tmp21 + } + tmp15 = tmp18 + } // end let + tmp12 = tmp15 + } else { + tmp16 := checkDerefVar(var_glojure_DOT_core_vreset_BANG_) + tmp17 := lang.Apply(tmp16, []any{v8, true}) + _ = tmp17 + tmp18 := lang.Apply(v4, []any{v10, v11}) + tmp12 = tmp18 + } + return tmp12 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5238), kw_column, int(8), kw_end_DASH_line, int(5249), kw_end_DASH_column, int(35)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp5 = tmp11 + } // end let + return tmp5 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5236), kw_column, int(4), kw_end_DASH_line, int(5249), kw_end_DASH_column, int(37)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_drop) + tmp5 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp6 := checkDerefVar(var_glojure_DOT_core_repeat) + tmp7 := lang.Apply(tmp6, []any{v2}) + tmp8 := lang.Apply(tmp5, []any{tmp7, v3}) + tmp9 := lang.Apply(tmp4, []any{int64(1), tmp8}) + return tmp9 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_interpose = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_interpose.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // isa? + { + tmp0 := sym_isa_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_child, sym_parent), lang.NewVector(sym_h, sym_child, sym_parent)), kw_doc, "Returns true if (= child parent), or child is directly or indirectly derived from\n parent, either via a Java type inheritance relationship or a\n relationship established via derive. h must be a hierarchy obtained\n from make-hierarchy, if not supplied defaults to the global\n hierarchy", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(5543), kw_end_DASH_line, int(5543))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_isa_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_global_DASH_hierarchy) + tmp6 := lang.Apply(tmp4, []any{tmp5, v2, v3}) + return tmp6 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + { // let + // let binding "or__0__auto__" + tmp6 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp7 := lang.Apply(tmp6, []any{v3, v4}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + tmp9 = v8 + } else { + var tmp10 any + { // let + // let binding "or__0__auto__" + var tmp11 any + { // let + // let binding "and__0__auto__" + tmp12 := checkDerefVar(var_glojure_DOT_core_class_QMARK_) + tmp13 := lang.Apply(tmp12, []any{v4}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + var tmp16 any + { // let + // let binding "and__0__auto__" + tmp17 := checkDerefVar(var_glojure_DOT_core_class_QMARK_) + tmp18 := lang.Apply(tmp17, []any{v3}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + tmp21, _ := lang.FieldOrMethod(v3, "AssignableTo") + if reflect.TypeOf(tmp21).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("AssignableTo is not a function"))) + } + tmp22 := lang.Apply(tmp21, []any{v4}) + tmp20 = tmp22 + } else { + tmp20 = v19 + } + tmp16 = tmp20 + } // end let + tmp15 = tmp16 + } else { + tmp15 = v14 + } + tmp11 = tmp15 + } // end let + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + tmp13 = v12 + } else { + var tmp14 any + { // let + // let binding "or__0__auto__" + tmp15 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp16 := lang.Apply(kw_ancestors, []any{v2}) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := lang.Apply(tmp15, []any{tmp17, v4}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + tmp20 = v19 + } else { + var tmp21 any + { // let + // let binding "or__0__auto__" + var tmp22 any + { // let + // let binding "and__0__auto__" + tmp23 := checkDerefVar(var_glojure_DOT_core_class_QMARK_) + tmp24 := lang.Apply(tmp23, []any{v3}) + var v25 any = tmp24 + _ = v25 + var tmp26 any + if lang.IsTruthy(v25) { + tmp27 := checkDerefVar(var_glojure_DOT_core_some) + var tmp28 lang.FnFunc + tmp28 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v29 := args[0] + _ = v29 + tmp30 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp31 := lang.Apply(kw_ancestors, []any{v2}) + tmp32 := lang.Apply(tmp31, []any{v29}) + tmp33 := lang.Apply(tmp30, []any{tmp32, v4}) + return tmp33 + }) + tmp29 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5556), kw_column, int(34), kw_end_DASH_line, int(5556), kw_end_DASH_column, int(71)) + tmp30, err := lang.WithMeta(tmp28, tmp29.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp31 := checkDerefVar(var_glojure_DOT_core_supers) + tmp32 := lang.Apply(tmp31, []any{v3}) + tmp33 := lang.Apply(tmp27, []any{tmp30, tmp32}) + tmp26 = tmp33 + } else { + tmp26 = v25 + } + tmp22 = tmp26 + } // end let + var v23 any = tmp22 + _ = v23 + var tmp24 any + if lang.IsTruthy(v23) { + tmp24 = v23 + } else { + var tmp25 any + { // let + // let binding "and__0__auto__" + tmp26 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp27 := lang.Apply(tmp26, []any{v4}) + var v28 any = tmp27 + _ = v28 + var tmp29 any + if lang.IsTruthy(v28) { + var tmp30 any + { // let + // let binding "and__0__auto__" + tmp31 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp32 := lang.Apply(tmp31, []any{v3}) + var v33 any = tmp32 + _ = v33 + var tmp34 any + if lang.IsTruthy(v33) { + var tmp35 any + { // let + // let binding "and__0__auto__" + tmp36 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp37 := checkDerefVar(var_glojure_DOT_core_count) + tmp38 := lang.Apply(tmp37, []any{v4}) + tmp39 := checkDerefVar(var_glojure_DOT_core_count) + tmp40 := lang.Apply(tmp39, []any{v3}) + tmp41 := lang.Apply(tmp36, []any{tmp38, tmp40}) + var v42 any = tmp41 + _ = v42 + var tmp43 any + if lang.IsTruthy(v42) { + var tmp44 any + { // let + // let binding "ret" + var v45 any = true + _ = v45 + // let binding "i" + var v46 any = int64(0) + _ = v46 + for { + var tmp47 any + var tmp48 any + { // let + // let binding "or__0__auto__" + tmp49 := checkDerefVar(var_glojure_DOT_core_not) + tmp50 := lang.Apply(tmp49, []any{v45}) + var v51 any = tmp50 + _ = v51 + var tmp52 any + if lang.IsTruthy(v51) { + tmp52 = v51 + } else { + tmp53 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp54 := checkDerefVar(var_glojure_DOT_core_count) + tmp55 := lang.Apply(tmp54, []any{v4}) + tmp56 := lang.Apply(tmp53, []any{v46, tmp55}) + tmp52 = tmp56 + } + tmp48 = tmp52 + } // end let + if lang.IsTruthy(tmp48) { + tmp47 = v45 + } else { + tmp50 := checkDerefVar(var_glojure_DOT_core_isa_QMARK_) + tmp51 := lang.Apply(v3, []any{v46}) + tmp52 := lang.Apply(v4, []any{v46}) + tmp53 := lang.Apply(tmp50, []any{v2, tmp51, tmp52}) + var tmp49 any = tmp53 + tmp55 := checkDerefVar(var_glojure_DOT_core_inc) + tmp56 := lang.Apply(tmp55, []any{v46}) + var tmp54 any = tmp56 + v45 = tmp49 + v46 = tmp54 + continue + } + tmp44 = tmp47 + break + } + } // end let + tmp43 = tmp44 + } else { + tmp43 = v42 + } + tmp35 = tmp43 + } // end let + tmp34 = tmp35 + } else { + tmp34 = v33 + } + tmp30 = tmp34 + } // end let + tmp29 = tmp30 + } else { + tmp29 = v28 + } + tmp25 = tmp29 + } // end let + tmp24 = tmp25 + } + tmp21 = tmp24 + } // end let + tmp20 = tmp21 + } + tmp14 = tmp20 + } // end let + tmp13 = tmp14 + } + tmp10 = tmp13 + } // end let + tmp9 = tmp10 + } + tmp5 = tmp9 + } // end let + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_isa_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_isa_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // lazy-cat + { + tmp0 := sym_lazy_DASH_cat.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_colls)), kw_doc, "Expands to code which yields a lazy sequence of the concatenation\n of the supplied colls. Each coll expr is not evaluated until it is\n needed. \n\n (lazy-cat xs ys zs) === (concat (lazy-seq xs) (lazy-seq ys) (lazy-seq zs))", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(11), kw_line, int(4636), kw_end_DASH_line, int(4636))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym_glojure_DOT_core_SLASH_concat}) + tmp9 := checkDerefVar(var_glojure_DOT_core_map) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v11 := args[0] + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_glojure_DOT_core_SLASH_lazy_DASH_seq, v11}) + return tmp13 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4644), kw_column, int(19), kw_end_DASH_line, int(4644), kw_end_DASH_column, int(37)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := lang.Apply(tmp9, []any{tmp12, v4}) + tmp14 := lang.Apply(tmp6, []any{tmp8, tmp13}) + tmp15 := lang.Apply(tmp5, []any{tmp14}) + return tmp15 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_lazy_DASH_cat = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_lazy_DASH_cat.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // letfn + { + tmp0 := sym_letfn.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_fnspecs, sym__AMP_, sym_body)), kw_doc, "fnspec ==> (fname [params*] exprs) or (fname ([params*] exprs)+)\n\n Takes a vector of function specs and a body, and generates a set of\n bindings of functions to their names. All of the names are available\n in all of the definitions of the functions, as well as the body.", kw_forms, lang.NewVector(lang.NewList(sym_letfn, lang.NewVector(sym_fnspecs_STAR_), sym_exprs_STAR_)), kw_url, nil, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(11), kw_line, int(6545), kw_end_DASH_line, int(6545), kw_special_DASH_form, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_letfn_STAR_}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_vec) + tmp12 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp13 := checkDerefVar(var_glojure_DOT_core_map) + tmp14 := checkDerefVar(var_glojure_DOT_core_first) + tmp15 := lang.Apply(tmp13, []any{tmp14, v4}) + tmp16 := checkDerefVar(var_glojure_DOT_core_map) + var tmp17 lang.FnFunc + tmp17 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v18 := args[0] + _ = v18 + tmp19 := checkDerefVar(var_glojure_DOT_core_cons) + tmp20 := lang.Apply(tmp19, []any{sym_glojure_DOT_core_SLASH_fn, v18}) + return tmp20 + }) + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6555), kw_column, int(35), kw_end_DASH_line, int(6555), kw_end_DASH_column, int(47)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp20 := lang.Apply(tmp16, []any{tmp19, v4}) + tmp21 := lang.Apply(tmp12, []any{tmp15, tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp10, []any{tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp9, tmp23, v5}) + tmp25 := lang.Apply(tmp6, []any{tmp24}) + return tmp25 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_letfn = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_letfn.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // lift-ns + { + tmp0 := sym_lift_DASH_ns.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m)), kw_doc, "Returns [lifted-ns lifted-kvs] or nil if m can't be lifted.", kw_file, "glojure/core_print.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(8), kw_line, int(261), kw_end_DASH_line, int(261), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_namespace_DASH_maps_STAR_) + if lang.IsTruthy(tmp4) { + var tmp5 any + { // let + // let binding "ns" + var v6 any = nil + _ = v6 + // let binding "G__912" + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := lang.Apply(tmp7, []any{v2}) + var v9 any = tmp8 + _ = v9 + // let binding "vec__913" + var v10 any = v9 + _ = v10 + // let binding "seq__914" + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := lang.Apply(tmp11, []any{v10}) + var v13 any = tmp12 + _ = v13 + // let binding "first__915" + tmp14 := checkDerefVar(var_glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v13}) + var v16 any = tmp15 + _ = v16 + // let binding "seq__914" + tmp17 := checkDerefVar(var_glojure_DOT_core_next) + tmp18 := lang.Apply(tmp17, []any{v13}) + var v19 any = tmp18 + _ = v19 + // let binding "vec__916" + var v20 any = v16 + _ = v20 + // let binding "k" + tmp21 := checkDerefVar(var_glojure_DOT_core_nth) + tmp22 := lang.Apply(tmp21, []any{v20, int64(0), nil}) + var v23 any = tmp22 + _ = v23 + // let binding "v" + tmp24 := checkDerefVar(var_glojure_DOT_core_nth) + tmp25 := lang.Apply(tmp24, []any{v20, int64(1), nil}) + var v26 any = tmp25 + _ = v26 + // let binding "entry" + var v27 any = v20 + _ = v27 + // let binding "entries" + var v28 any = v19 + _ = v28 + // let binding "kvs" + tmp29 := lang.NewVector() + tmp30 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(267), kw_column, int(16), kw_end_DASH_line, int(267), kw_end_DASH_column, int(17)) + tmp31, err := lang.WithMeta(tmp29, tmp30.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v32 any = tmp31 + _ = v32 + var tmp33 any + { // let + // let binding "ns" + var v34 any = v6 + _ = v34 + // let binding "G__912" + var v35 any = v9 + _ = v35 + // let binding "kvs" + var v36 any = v32 + _ = v36 + for { + var tmp37 any + { // let + // let binding "ns" + var v38 any = v34 + _ = v38 + // let binding "vec__919" + var v39 any = v35 + _ = v39 + // let binding "seq__920" + tmp40 := checkDerefVar(var_glojure_DOT_core_seq) + tmp41 := lang.Apply(tmp40, []any{v39}) + var v42 any = tmp41 + _ = v42 + // let binding "first__921" + tmp43 := checkDerefVar(var_glojure_DOT_core_first) + tmp44 := lang.Apply(tmp43, []any{v42}) + var v45 any = tmp44 + _ = v45 + // let binding "seq__920" + tmp46 := checkDerefVar(var_glojure_DOT_core_next) + tmp47 := lang.Apply(tmp46, []any{v42}) + var v48 any = tmp47 + _ = v48 + // let binding "vec__922" + var v49 any = v45 + _ = v49 + // let binding "k" + tmp50 := checkDerefVar(var_glojure_DOT_core_nth) + tmp51 := lang.Apply(tmp50, []any{v49, int64(0), nil}) + var v52 any = tmp51 + _ = v52 + // let binding "v" + tmp53 := checkDerefVar(var_glojure_DOT_core_nth) + tmp54 := lang.Apply(tmp53, []any{v49, int64(1), nil}) + var v55 any = tmp54 + _ = v55 + // let binding "entry" + var v56 any = v49 + _ = v56 + // let binding "entries" + var v57 any = v48 + _ = v57 + // let binding "kvs" + var v58 any = v36 + _ = v58 + var tmp59 any + if lang.IsTruthy(v56) { + var tmp60 any + tmp61 := checkDerefVar(var_glojure_DOT_core_qualified_DASH_ident_QMARK_) + tmp62 := lang.Apply(tmp61, []any{v52}) + if lang.IsTruthy(tmp62) { + var tmp63 any + if lang.IsTruthy(v38) { + var tmp64 any + tmp65 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp66 := checkDerefVar(var_glojure_DOT_core_namespace) + tmp67 := lang.Apply(tmp66, []any{v52}) + tmp68 := lang.Apply(tmp65, []any{v38, tmp67}) + if lang.IsTruthy(tmp68) { + var tmp69 any = v38 + var tmp70 any = v57 + tmp72 := checkDerefVar(var_glojure_DOT_core_conj) + tmp73 := checkDerefVar(var_glojure_DOT_core_strip_DASH_ns) + tmp74 := lang.Apply(tmp73, []any{v52}) + tmp75 := lang.NewVector(tmp74, v55) + tmp76 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(272), kw_column, int(43), kw_end_DASH_line, int(272), kw_end_DASH_column, int(58)) + tmp77, err := lang.WithMeta(tmp75, tmp76.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp78 := lang.Apply(tmp72, []any{v58, tmp77}) + var tmp71 any = tmp78 + v34 = tmp69 + v35 = tmp70 + v36 = tmp71 + continue + } else { + } + tmp63 = tmp64 + } else { + var tmp79 any + { // let + // let binding "temp__0__auto__" + tmp80 := checkDerefVar(var_glojure_DOT_core_namespace) + tmp81 := lang.Apply(tmp80, []any{v52}) + var v82 any = tmp81 + _ = v82 + var tmp83 any + if lang.IsTruthy(v82) { + var tmp84 any + { // let + // let binding "new-ns" + var v85 any = v82 + _ = v85 + var tmp86 any = v85 + var tmp87 any = v57 + tmp89 := checkDerefVar(var_glojure_DOT_core_conj) + tmp90 := checkDerefVar(var_glojure_DOT_core_strip_DASH_ns) + tmp91 := lang.Apply(tmp90, []any{v52}) + tmp92 := lang.NewVector(tmp91, v55) + tmp93 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(274), kw_column, int(47), kw_end_DASH_line, int(274), kw_end_DASH_column, int(62)) + tmp94, err := lang.WithMeta(tmp92, tmp93.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp95 := lang.Apply(tmp89, []any{v58, tmp94}) + var tmp88 any = tmp95 + v34 = tmp86 + v35 = tmp87 + v36 = tmp88 + continue + } // end let + tmp83 = tmp84 + } else { + } + tmp79 = tmp83 + } // end let + tmp63 = tmp79 + } + tmp60 = tmp63 + } else { + } + tmp59 = tmp60 + } else { + tmp80 := lang.NewVector(v38, v58) + tmp81 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(275), kw_column, int(9), kw_end_DASH_line, int(275), kw_end_DASH_column, int(16)) + tmp82, err := lang.WithMeta(tmp80, tmp81.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp59 = tmp82 + } + tmp37 = tmp59 + } // end let + tmp33 = tmp37 + break + } + } // end let + tmp5 = tmp33 + } // end let + tmp3 = tmp5 + } else { + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_lift_DASH_ns = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_lift_DASH_ns.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // make-array + { + tmp0 := sym_make_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_type, sym_len), lang.NewVector(sym_type, sym_dim, sym__AMP_, sym_more_DASH_dims)), kw_doc, "Creates and returns an array of instances of the specified class of\n the specified dimension(s). Note that a class object is required.\n Class objects can be obtained by using their imported or\n fully-qualified name. Class objects for the primitive types can be\n obtained using, e.g., Integer/TYPE.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(3985), kw_end_DASH_line, int(3985))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_int) + tmp5 := lang.Apply(tmp4, []any{v3}) + tmp6, _ := lang.FieldOrMethod(nil, "newInstance") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("newInstance is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v2, tmp5}) + return tmp7 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "dims" + tmp6 := checkDerefVar(var_glojure_DOT_core_cons) + tmp7 := lang.Apply(tmp6, []any{v3, v4}) + var v8 any = tmp7 + _ = v8 + // let binding "dimarray" + tmp9 := checkDerefVar(var_glojure_DOT_core_make_DASH_array) + tmp10, ok := lang.FieldOrMethod(nil, "TYPE") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "TYPE"))) + } + var tmp11 any + switch reflect.TypeOf(tmp10).Kind() { + case reflect.Func: + tmp11 = lang.Apply(tmp10, nil) + default: + tmp11 = tmp10 + } + tmp12 := checkDerefVar(var_glojure_DOT_core_count) + tmp13 := lang.Apply(tmp12, []any{v8}) + tmp14 := lang.Apply(tmp9, []any{tmp11, tmp13}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + { // let + // let binding "n__0__auto__" + tmp17 := checkDerefVar(var_glojure_DOT_core_long) + tmp18 := checkDerefVar(var_glojure_DOT_core_alength) + tmp19 := lang.Apply(tmp18, []any{v15}) + tmp20 := lang.Apply(tmp17, []any{tmp19}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + { // let + // let binding "i" + var v23 any = int64(0) + _ = v23 + for { + var tmp24 any + tmp25 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp26 := lang.Apply(tmp25, []any{v23, v21}) + if lang.IsTruthy(tmp26) { + tmp27 := checkDerefVar(var_glojure_DOT_core_aset_DASH_int) + tmp28 := checkDerefVar(var_glojure_DOT_core_nth) + tmp29 := lang.Apply(tmp28, []any{v8, v23}) + tmp30 := lang.Apply(tmp27, []any{v15, v23, tmp29}) + _ = tmp30 + tmp32 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp33 := lang.Apply(tmp32, []any{v23}) + var tmp31 any = tmp33 + v23 = tmp31 + continue + } else { + } + tmp22 = tmp24 + break + } + } // end let + tmp16 = tmp22 + } // end let + _ = tmp16 + tmp17, _ := lang.FieldOrMethod(nil, "newInstance") + if reflect.TypeOf(tmp17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("newInstance is not a function"))) + } + tmp18 := lang.Apply(tmp17, []any{v2, v15}) + tmp5 = tmp18 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_make_DASH_array = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_make_DASH_array.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // maybe-min-hash + { + tmp0 := sym_maybe_DASH_min_DASH_hash.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_hashes)), kw_doc, "takes a collection of hashes and returns [shift mask] or nil if none found", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(8), kw_line, int(6604), kw_end_DASH_line, int(6604), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_first) + tmp4 := checkDerefVar(var_glojure_DOT_core_filter) + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v6 := args[0] + _ = v6 + var tmp7 any + { // let + // let binding "vec__842" + var v8 any = v6 + _ = v8 + // let binding "s" + tmp9 := checkDerefVar(var_glojure_DOT_core_nth) + tmp10 := lang.Apply(tmp9, []any{v8, int64(0), nil}) + var v11 any = tmp10 + _ = v11 + // let binding "m" + tmp12 := checkDerefVar(var_glojure_DOT_core_nth) + tmp13 := lang.Apply(tmp12, []any{v8, int64(1), nil}) + var v14 any = tmp13 + _ = v14 + tmp15 := checkDerefVar(var_glojure_DOT_core_apply) + tmp16 := checkDerefVar(var_glojure_DOT_core_distinct_QMARK_) + tmp17 := checkDerefVar(var_glojure_DOT_core_map) + var tmp18 lang.FnFunc + tmp18 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v19 := args[0] + _ = v19 + tmp20 := checkDerefVar(var_glojure_DOT_core_shift_DASH_mask) + tmp21 := lang.Apply(tmp20, []any{v11, v14, v19}) + return tmp21 + }) + tmp19 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6609), kw_column, int(37), kw_end_DASH_line, int(6609), kw_end_DASH_column, int(55)) + tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp21 := lang.Apply(tmp17, []any{tmp20, v2}) + tmp22 := lang.Apply(tmp15, []any{tmp16, tmp21}) + tmp7 = tmp22 + } // end let + return tmp7 + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6608), kw_column, int(13), kw_end_DASH_line, int(6609), kw_end_DASH_column, int(65)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var tmp8 any + { // let + // let binding "iter__0__auto__" + var tmp9 lang.FnFunc + { // function iter__845 + var v10 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v11 := args[0] + _ = v11 + var tmp12 lang.FnFunc + tmp12 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp13 any + { // let + // let binding "s__846" + var v14 any = v11 + _ = v14 + for { + var tmp15 any + { // let + // let binding "temp__0__auto__" + tmp16 := checkDerefVar(var_glojure_DOT_core_seq) + tmp17 := lang.Apply(tmp16, []any{v14}) + var v18 any = tmp17 + _ = v18 + var tmp19 any + if lang.IsTruthy(v18) { + var tmp20 any + { // let + // let binding "xs__0__auto__" + var v21 any = v18 + _ = v21 + var tmp22 any + { // let + // let binding "mask" + tmp23 := checkDerefVar(var_glojure_DOT_core_first) + tmp24 := lang.Apply(tmp23, []any{v21}) + var v25 any = tmp24 + _ = v25 + var tmp26 any + { // let + // let binding "iterys__0__auto__" + var tmp27 lang.FnFunc + { // function iter__847 + var v28 lang.FnFunc + tmp27 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v29 := args[0] + _ = v29 + var tmp30 lang.FnFunc + tmp30 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp31 any + { // let + // let binding "s__848" + var v32 any = v29 + _ = v32 + for { + var tmp33 any + { // let + // let binding "temp__0__auto__" + tmp34 := checkDerefVar(var_glojure_DOT_core_seq) + tmp35 := lang.Apply(tmp34, []any{v32}) + var v36 any = tmp35 + _ = v36 + var tmp37 any + if lang.IsTruthy(v36) { + var tmp38 any + { // let + // let binding "s__848" + var v39 any = v36 + _ = v39 + var tmp40 any + tmp41 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp42 := lang.Apply(tmp41, []any{v39}) + if lang.IsTruthy(tmp42) { + var tmp43 any + { // let + // let binding "c__0__auto__" + tmp44 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp45 := lang.Apply(tmp44, []any{v39}) + var v46 any = tmp45 + _ = v46 + // let binding "size__1__auto__" + tmp47 := checkDerefVar(var_glojure_DOT_core_int) + tmp48 := checkDerefVar(var_glojure_DOT_core_count) + tmp49 := lang.Apply(tmp48, []any{v46}) + tmp50 := lang.Apply(tmp47, []any{tmp49}) + var v51 any = tmp50 + _ = v51 + // let binding "b__850" + tmp52 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_buffer) + tmp53 := lang.Apply(tmp52, []any{v51}) + var v54 any = tmp53 + _ = v54 + var tmp55 any + var tmp56 any + { // let + // let binding "i__849" + tmp57 := checkDerefVar(var_glojure_DOT_core_int) + tmp58 := lang.Apply(tmp57, []any{int64(0)}) + var v59 any = tmp58 + _ = v59 + for { + var tmp60 any + tmp61 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp62 := lang.Apply(tmp61, []any{v59, v51}) + if lang.IsTruthy(tmp62) { + var tmp63 any + { // let + // let binding "shift" + tmp64, _ := lang.FieldOrMethod(v46, "nth") + if reflect.TypeOf(tmp64).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp65 := lang.Apply(tmp64, []any{v59}) + var v66 any = tmp65 + _ = v66 + tmp67 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_append) + tmp68 := lang.NewVector(v66, v25) + tmp69 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6612), kw_column, int(15), kw_end_DASH_line, int(6612), kw_end_DASH_column, int(26)) + tmp70, err := lang.WithMeta(tmp68, tmp69.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp71 := lang.Apply(tmp67, []any{v54, tmp70}) + _ = tmp71 + tmp73 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp74 := lang.Apply(tmp73, []any{v59}) + var tmp72 any = tmp74 + v59 = tmp72 + continue + } // end let + tmp60 = tmp63 + } else { + tmp60 = true + } + tmp56 = tmp60 + break + } + } // end let + if lang.IsTruthy(tmp56) { + tmp57 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_cons) + tmp58 := checkDerefVar(var_glojure_DOT_core_chunk) + tmp59 := lang.Apply(tmp58, []any{v54}) + tmp60 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp61 := lang.Apply(tmp60, []any{v39}) + tmp62 := lang.Apply(v28, []any{tmp61}) + tmp63 := lang.Apply(tmp57, []any{tmp59, tmp62}) + tmp55 = tmp63 + } else { + tmp64 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_cons) + tmp65 := checkDerefVar(var_glojure_DOT_core_chunk) + tmp66 := lang.Apply(tmp65, []any{v54}) + tmp67 := lang.Apply(tmp64, []any{tmp66, nil}) + tmp55 = tmp67 + } + tmp43 = tmp55 + } // end let + tmp40 = tmp43 + } else { + var tmp44 any + { // let + // let binding "shift" + tmp45 := checkDerefVar(var_glojure_DOT_core_first) + tmp46 := lang.Apply(tmp45, []any{v39}) + var v47 any = tmp46 + _ = v47 + tmp48 := checkDerefVar(var_glojure_DOT_core_cons) + tmp49 := lang.NewVector(v47, v25) + tmp50 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6612), kw_column, int(15), kw_end_DASH_line, int(6612), kw_end_DASH_column, int(26)) + tmp51, err := lang.WithMeta(tmp49, tmp50.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp52 := checkDerefVar(var_glojure_DOT_core_rest) + tmp53 := lang.Apply(tmp52, []any{v39}) + tmp54 := lang.Apply(v28, []any{tmp53}) + tmp55 := lang.Apply(tmp48, []any{tmp51, tmp54}) + tmp44 = tmp55 + } // end let + tmp40 = tmp44 + } + tmp38 = tmp40 + } // end let + tmp37 = tmp38 + } else { + } + tmp33 = tmp37 + } // end let + tmp31 = tmp33 + break + } + } // end let + return tmp31 + }) + tmp31 := lang.Apply(lang.NewLazySeq, []any{tmp30}) + return tmp31 + }) + v28 = tmp27 + _ = v28 + } + var v28 any = tmp27 + _ = v28 + // let binding "fs__1__auto__" + tmp29 := checkDerefVar(var_glojure_DOT_core_seq) + tmp30 := checkDerefVar(var_glojure_DOT_core_range) + tmp31 := lang.Apply(tmp30, []any{int64(0), int64(31)}) + tmp32 := lang.Apply(v28, []any{tmp31}) + tmp33 := lang.Apply(tmp29, []any{tmp32}) + var v34 any = tmp33 + _ = v34 + var tmp35 any + if lang.IsTruthy(v34) { + tmp36 := checkDerefVar(var_glojure_DOT_core_concat) + tmp37 := checkDerefVar(var_glojure_DOT_core_rest) + tmp38 := lang.Apply(tmp37, []any{v14}) + tmp39 := lang.Apply(v10, []any{tmp38}) + tmp40 := lang.Apply(tmp36, []any{v34, tmp39}) + tmp35 = tmp40 + } else { + tmp42 := checkDerefVar(var_glojure_DOT_core_rest) + tmp43 := lang.Apply(tmp42, []any{v14}) + var tmp41 any = tmp43 + v14 = tmp41 + continue + } + tmp26 = tmp35 + } // end let + tmp22 = tmp26 + } // end let + tmp20 = tmp22 + } // end let + tmp19 = tmp20 + } else { + } + tmp15 = tmp19 + } // end let + tmp13 = tmp15 + break + } + } // end let + return tmp13 + }) + tmp13 := lang.Apply(lang.NewLazySeq, []any{tmp12}) + return tmp13 + }) + v10 = tmp9 + _ = v10 + } + var v10 any = tmp9 + _ = v10 + tmp11 := checkDerefVar(var_glojure_DOT_core_map) + var tmp12 lang.FnFunc + tmp12 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v13 := args[0] + _ = v13 + tmp14 := checkDerefVar(var_glojure_DOT_core_dec) + tmp15 := checkDerefVar(var_glojure_DOT_core_bit_DASH_shift_DASH_left) + tmp16 := lang.Apply(tmp15, []any{int64(1), v13}) + tmp17 := lang.Apply(tmp14, []any{tmp16}) + return tmp17 + }) + tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6610), kw_column, int(29), kw_end_DASH_line, int(6610), kw_end_DASH_column, int(55)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp15 := checkDerefVar(var_glojure_DOT_core_range) + tmp16 := checkDerefVar(var_glojure_DOT_core_inc) + tmp17 := checkDerefVar(var_glojure_DOT_core_max_DASH_mask_DASH_bits) + tmp18 := lang.Apply(tmp16, []any{tmp17}) + tmp19 := lang.Apply(tmp15, []any{int64(1), tmp18}) + tmp20 := lang.Apply(tmp11, []any{tmp14, tmp19}) + tmp21 := lang.Apply(v10, []any{tmp20}) + tmp8 = tmp21 + } // end let + tmp9 := lang.Apply(tmp4, []any{tmp7, tmp8}) + tmp10 := lang.Apply(tmp3, []any{tmp9}) + return tmp10 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_maybe_DASH_min_DASH_hash = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_maybe_DASH_min_DASH_hash.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // memoize + { + tmp0 := sym_memoize.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f)), kw_doc, "Returns a memoized version of a referentially transparent function. The\n memoized version of the function keeps a cache of the mapping from arguments\n to results and, when calls with the same arguments are repeated often, has\n higher performance at the expense of higher memory use.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(6337), kw_end_DASH_line, int(6337))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "mem" + tmp4 := checkDerefVar(var_glojure_DOT_core_atom) + tmp5 := lang.NewMap() + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6345), kw_column, int(19), kw_end_DASH_line, int(6345), kw_end_DASH_column, int(20)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp8 := lang.Apply(tmp4, []any{tmp7}) + var v9 any = tmp8 + _ = v9 + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v11 any = lang.NewList(args[0:]...) + _ = v11 + var tmp12 any + { // let + // let binding "temp__0__auto__" + tmp13 := checkDerefVar(var_glojure_DOT_core_find) + tmp14 := checkDerefVar(var_glojure_DOT_core_deref) + tmp15 := lang.Apply(tmp14, []any{v9}) + tmp16 := lang.Apply(tmp13, []any{tmp15, v11}) + var v17 any = tmp16 + _ = v17 + var tmp18 any + if lang.IsTruthy(v17) { + var tmp19 any + { // let + // let binding "e" + var v20 any = v17 + _ = v20 + tmp21 := checkDerefVar(var_glojure_DOT_core_val) + tmp22 := lang.Apply(tmp21, []any{v20}) + tmp19 = tmp22 + } // end let + tmp18 = tmp19 + } else { + var tmp20 any + { // let + // let binding "ret" + tmp21 := checkDerefVar(var_glojure_DOT_core_apply) + tmp22 := lang.Apply(tmp21, []any{v2, v11}) + var v23 any = tmp22 + _ = v23 + tmp24 := checkDerefVar(var_glojure_DOT_core_swap_BANG_) + tmp25 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp26 := lang.Apply(tmp24, []any{v9, tmp25, v11, v23}) + _ = tmp26 + tmp20 = v23 + } // end let + tmp18 = tmp20 + } + tmp12 = tmp18 + } // end let + return tmp12 + } + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6346), kw_column, int(5), kw_end_DASH_line, int(6351), kw_end_DASH_column, int(16)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp3 = tmp12 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_memoize = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_memoize.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ns + { + tmp0 := sym_ns.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym_docstring_QMARK_, sym_attr_DASH_map_QMARK_, sym_references_STAR_)), kw_doc, "Sets *ns* to the namespace named by name (unevaluated), creating it\n if needed. references can be zero or more of: (:refer-glojure ...)\n (:require ...) (:use ...) (:import ...) (:load ...) (:gen-class)\n with the syntax of refer-glojure/require/use/import/load/gen-class\n respectively, except the arguments are unevaluated and need not be\n quoted. (:gen-class ...), when supplied, defaults to :name\n corresponding to the ns name, :main true, :impl-ns same as ns, and\n :init-impl-ns true. All options of gen-class are\n supported. The :gen-class directive is ignored when not\n compiling. If :gen-class is not supplied, when compiled only an\n nsname__init.class will be generated. If :refer-glojure is not used, a\n default (refer 'glojure.core) is used. Use of ns is preferred to\n individual calls to in-ns/require/use/import:\n\n (ns foo.bar\n (:refer-glojure :exclude [ancestors printf])\n (:require (glojure.contrib sql combinatorics))\n (:use (my.lib this that))\n (:import (java.util Date Timer Random)\n (java.sql Connection Statement)))", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(11), kw_line, int(5742), kw_end_DASH_line, int(5742))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "process-reference" + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v8 := args[0] + _ = v8 + var tmp9 any + { // let + // let binding "vec__798" + var v10 any = v8 + _ = v10 + // let binding "seq__799" + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := lang.Apply(tmp11, []any{v10}) + var v13 any = tmp12 + _ = v13 + // let binding "first__800" + tmp14 := checkDerefVar(var_glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v13}) + var v16 any = tmp15 + _ = v16 + // let binding "seq__799" + tmp17 := checkDerefVar(var_glojure_DOT_core_next) + tmp18 := lang.Apply(tmp17, []any{v13}) + var v19 any = tmp18 + _ = v19 + // let binding "kname" + var v20 any = v16 + _ = v20 + // let binding "args" + var v21 any = v19 + _ = v21 + tmp22 := checkDerefVar(var_glojure_DOT_core_seq) + tmp23 := checkDerefVar(var_glojure_DOT_core_concat) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := checkDerefVar(var_glojure_DOT_core_symbol) + tmp26 := checkDerefVar(var_glojure_DOT_core_name) + tmp27 := lang.Apply(tmp26, []any{v20}) + tmp28 := lang.Apply(tmp25, []any{"glojure.core", tmp27}) + tmp29 := lang.Apply(tmp24, []any{tmp28}) + tmp30 := checkDerefVar(var_glojure_DOT_core_map) + var tmp31 lang.FnFunc + tmp31 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v32 := args[0] + _ = v32 + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{sym_quote, v32}) + return tmp34 + }) + tmp32 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5769), kw_column, int(21), kw_end_DASH_line, int(5769), kw_end_DASH_column, int(36)) + tmp33, err := lang.WithMeta(tmp31, tmp32.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp34 := lang.Apply(tmp30, []any{tmp33, v21}) + tmp35 := lang.Apply(tmp23, []any{tmp29, tmp34}) + tmp36 := lang.Apply(tmp22, []any{tmp35}) + tmp9 = tmp36 + } // end let + return tmp9 + }) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5767), kw_column, int(9), kw_end_DASH_line, int(5769), kw_end_DASH_column, int(44)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v10 any = tmp9 + _ = v10 + // let binding "docstring" + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp13 := checkDerefVar(var_glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v5}) + tmp15 := lang.Apply(tmp12, []any{tmp14}) + if lang.IsTruthy(tmp15) { + tmp16 := checkDerefVar(var_glojure_DOT_core_first) + tmp17 := lang.Apply(tmp16, []any{v5}) + tmp11 = tmp17 + } else { + } + var v18 any = tmp11 + _ = v18 + // let binding "references" + var tmp19 any + if lang.IsTruthy(v18) { + tmp20 := checkDerefVar(var_glojure_DOT_core_next) + tmp21 := lang.Apply(tmp20, []any{v5}) + tmp19 = tmp21 + } else { + tmp19 = v5 + } + var v22 any = tmp19 + _ = v22 + // let binding "name" + var tmp23 any + if lang.IsTruthy(v18) { + tmp24 := checkDerefVar(var_glojure_DOT_core_vary_DASH_meta) + tmp25 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp26 := lang.Apply(tmp24, []any{v4, tmp25, kw_doc, v18}) + tmp23 = tmp26 + } else { + tmp23 = v4 + } + var v27 any = tmp23 + _ = v27 + // let binding "metadata" + var tmp28 any + tmp29 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp30 := checkDerefVar(var_glojure_DOT_core_first) + tmp31 := lang.Apply(tmp30, []any{v22}) + tmp32 := lang.Apply(tmp29, []any{tmp31}) + if lang.IsTruthy(tmp32) { + tmp33 := checkDerefVar(var_glojure_DOT_core_first) + tmp34 := lang.Apply(tmp33, []any{v22}) + tmp28 = tmp34 + } else { + } + var v35 any = tmp28 + _ = v35 + // let binding "references" + var tmp36 any + if lang.IsTruthy(v35) { + tmp37 := checkDerefVar(var_glojure_DOT_core_next) + tmp38 := lang.Apply(tmp37, []any{v22}) + tmp36 = tmp38 + } else { + tmp36 = v22 + } + var v39 any = tmp36 + _ = v39 + // let binding "name" + var tmp40 any + if lang.IsTruthy(v35) { + tmp41 := checkDerefVar(var_glojure_DOT_core_vary_DASH_meta) + tmp42 := checkDerefVar(var_glojure_DOT_core_merge) + tmp43 := lang.Apply(tmp41, []any{v27, tmp42, v35}) + tmp40 = tmp43 + } else { + tmp40 = v27 + } + var v44 any = tmp40 + _ = v44 + // let binding "gen-class-clause" + tmp45 := checkDerefVar(var_glojure_DOT_core_first) + tmp46 := checkDerefVar(var_glojure_DOT_core_filter) + var tmp47 lang.FnFunc + tmp47 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v48 := args[0] + _ = v48 + tmp49 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp50 := checkDerefVar(var_glojure_DOT_core_first) + tmp51 := lang.Apply(tmp50, []any{v48}) + tmp52 := lang.Apply(tmp49, []any{kw_gen_DASH_class, tmp51}) + return tmp52 + }) + tmp48 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5780), kw_column, int(41), kw_end_DASH_line, int(5780), kw_end_DASH_column, int(65)) + tmp49, err := lang.WithMeta(tmp47, tmp48.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp50 := lang.Apply(tmp46, []any{tmp49, v39}) + tmp51 := lang.Apply(tmp45, []any{tmp50}) + var v52 any = tmp51 + _ = v52 + // let binding "gen-class-call" + var tmp53 any + if lang.IsTruthy(v52) { + tmp54 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp55 := checkDerefVar(var_glojure_DOT_core_str) + tmp56 := lang.Apply(tmp55, []any{v44}) + tmp57, _ := lang.FieldOrMethod(tmp56, "replace") + if reflect.TypeOf(tmp57).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("replace is not a function"))) + } + tmp58 := lang.Apply(tmp57, []any{lang.NewChar(45), lang.NewChar(95)}) + tmp59 := checkDerefVar(var_glojure_DOT_core_next) + tmp60 := lang.Apply(tmp59, []any{v52}) + tmp61 := lang.Apply(tmp54, []any{sym_glojure_DOT_core_SLASH_gen_DASH_class, kw_name, tmp58, kw_impl_DASH_ns, v44, kw_main, true, tmp60}) + tmp53 = tmp61 + } else { + } + var v62 any = tmp53 + _ = v62 + // let binding "references" + tmp63 := checkDerefVar(var_glojure_DOT_core_remove) + var tmp64 lang.FnFunc + tmp64 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v65 := args[0] + _ = v65 + tmp66 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp67 := checkDerefVar(var_glojure_DOT_core_first) + tmp68 := lang.Apply(tmp67, []any{v65}) + tmp69 := lang.Apply(tmp66, []any{kw_gen_DASH_class, tmp68}) + return tmp69 + }) + tmp65 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5784), kw_column, int(28), kw_end_DASH_line, int(5784), kw_end_DASH_column, int(52)) + tmp66, err := lang.WithMeta(tmp64, tmp65.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp67 := lang.Apply(tmp63, []any{tmp66, v39}) + var v68 any = tmp67 + _ = v68 + // let binding "name-metadata" + tmp69 := checkDerefVar(var_glojure_DOT_core_meta) + tmp70 := lang.Apply(tmp69, []any{v44}) + var v71 any = tmp70 + _ = v71 + tmp72 := checkDerefVar(var_glojure_DOT_core_seq) + tmp73 := checkDerefVar(var_glojure_DOT_core_concat) + tmp74 := checkDerefVar(var_glojure_DOT_core_list) + tmp75 := lang.Apply(tmp74, []any{sym_do}) + tmp76 := checkDerefVar(var_glojure_DOT_core_list) + tmp77 := checkDerefVar(var_glojure_DOT_core_seq) + tmp78 := checkDerefVar(var_glojure_DOT_core_concat) + tmp79 := checkDerefVar(var_glojure_DOT_core_list) + tmp80 := lang.Apply(tmp79, []any{sym_glojure_DOT_core_SLASH_in_DASH_ns}) + tmp81 := checkDerefVar(var_glojure_DOT_core_list) + tmp82 := checkDerefVar(var_glojure_DOT_core_seq) + tmp83 := checkDerefVar(var_glojure_DOT_core_concat) + tmp84 := checkDerefVar(var_glojure_DOT_core_list) + tmp85 := lang.Apply(tmp84, []any{sym_quote}) + tmp86 := checkDerefVar(var_glojure_DOT_core_list) + tmp87 := lang.Apply(tmp86, []any{v44}) + tmp88 := lang.Apply(tmp83, []any{tmp85, tmp87}) + tmp89 := lang.Apply(tmp82, []any{tmp88}) + tmp90 := lang.Apply(tmp81, []any{tmp89}) + tmp91 := lang.Apply(tmp78, []any{tmp80, tmp90}) + tmp92 := lang.Apply(tmp77, []any{tmp91}) + tmp93 := lang.Apply(tmp76, []any{tmp92}) + var tmp94 any + if lang.IsTruthy(v71) { + tmp95 := checkDerefVar(var_glojure_DOT_core_seq) + tmp96 := checkDerefVar(var_glojure_DOT_core_concat) + tmp97 := checkDerefVar(var_glojure_DOT_core_list) + tmp98 := checkDerefVar(var_glojure_DOT_core_seq) + tmp99 := checkDerefVar(var_glojure_DOT_core_concat) + tmp100 := checkDerefVar(var_glojure_DOT_core_list) + tmp101 := lang.Apply(tmp100, []any{sym__DOT_ResetMeta}) + tmp102 := checkDerefVar(var_glojure_DOT_core_list) + tmp103 := checkDerefVar(var_glojure_DOT_core_seq) + tmp104 := checkDerefVar(var_glojure_DOT_core_concat) + tmp105 := checkDerefVar(var_glojure_DOT_core_list) + tmp106 := lang.Apply(tmp105, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_FindNamespace}) + tmp107 := checkDerefVar(var_glojure_DOT_core_list) + tmp108 := checkDerefVar(var_glojure_DOT_core_seq) + tmp109 := checkDerefVar(var_glojure_DOT_core_concat) + tmp110 := checkDerefVar(var_glojure_DOT_core_list) + tmp111 := lang.Apply(tmp110, []any{sym_quote}) + tmp112 := checkDerefVar(var_glojure_DOT_core_list) + tmp113 := lang.Apply(tmp112, []any{v44}) + tmp114 := lang.Apply(tmp109, []any{tmp111, tmp113}) + tmp115 := lang.Apply(tmp108, []any{tmp114}) + tmp116 := lang.Apply(tmp107, []any{tmp115}) + tmp117 := lang.Apply(tmp104, []any{tmp106, tmp116}) + tmp118 := lang.Apply(tmp103, []any{tmp117}) + tmp119 := lang.Apply(tmp102, []any{tmp118}) + tmp120 := checkDerefVar(var_glojure_DOT_core_list) + tmp121 := lang.Apply(tmp120, []any{v71}) + tmp122 := lang.Apply(tmp99, []any{tmp101, tmp119, tmp121}) + tmp123 := lang.Apply(tmp98, []any{tmp122}) + tmp124 := lang.Apply(tmp97, []any{tmp123}) + tmp125 := lang.Apply(tmp96, []any{tmp124}) + tmp126 := lang.Apply(tmp95, []any{tmp125}) + tmp94 = tmp126 + } else { + } + tmp127 := checkDerefVar(var_glojure_DOT_core_list) + tmp128 := checkDerefVar(var_glojure_DOT_core_seq) + tmp129 := checkDerefVar(var_glojure_DOT_core_concat) + tmp130 := checkDerefVar(var_glojure_DOT_core_list) + tmp131 := lang.Apply(tmp130, []any{sym_glojure_DOT_core_SLASH_with_DASH_loading_DASH_context}) + var tmp132 any + if lang.IsTruthy(v62) { + tmp133 := checkDerefVar(var_glojure_DOT_core_list) + tmp134 := lang.Apply(tmp133, []any{v62}) + tmp132 = tmp134 + } else { + } + var tmp135 any + var tmp136 any + { // let + // let binding "and__0__auto__" + tmp137 := checkDerefVar(var_glojure_DOT_core_not_EQ_) + tmp138 := lang.Apply(tmp137, []any{v44, sym_glojure_DOT_core}) + var v139 any = tmp138 + _ = v139 + var tmp140 any + if lang.IsTruthy(v139) { + tmp141 := checkDerefVar(var_glojure_DOT_core_not_DASH_any_QMARK_) + var tmp142 lang.FnFunc + tmp142 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v143 := args[0] + _ = v143 + tmp144 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp145 := checkDerefVar(var_glojure_DOT_core_first) + tmp146 := lang.Apply(tmp145, []any{v143}) + tmp147 := lang.Apply(tmp144, []any{kw_refer_DASH_glojure, tmp146}) + return tmp147 + }) + tmp143 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5793), kw_column, int(58), kw_end_DASH_line, int(5793), kw_end_DASH_column, int(86)) + tmp144, err := lang.WithMeta(tmp142, tmp143.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp145 := lang.Apply(tmp141, []any{tmp144, v68}) + tmp140 = tmp145 + } else { + tmp140 = v139 + } + tmp136 = tmp140 + } // end let + if lang.IsTruthy(tmp136) { + tmp137 := checkDerefVar(var_glojure_DOT_core_seq) + tmp138 := checkDerefVar(var_glojure_DOT_core_concat) + tmp139 := checkDerefVar(var_glojure_DOT_core_list) + tmp140 := checkDerefVar(var_glojure_DOT_core_seq) + tmp141 := checkDerefVar(var_glojure_DOT_core_concat) + tmp142 := checkDerefVar(var_glojure_DOT_core_list) + tmp143 := lang.Apply(tmp142, []any{sym_glojure_DOT_core_SLASH_refer}) + tmp144 := checkDerefVar(var_glojure_DOT_core_list) + tmp145 := checkDerefVar(var_glojure_DOT_core_seq) + tmp146 := checkDerefVar(var_glojure_DOT_core_concat) + tmp147 := checkDerefVar(var_glojure_DOT_core_list) + tmp148 := lang.Apply(tmp147, []any{sym_quote}) + tmp149 := checkDerefVar(var_glojure_DOT_core_list) + tmp150 := lang.Apply(tmp149, []any{sym_glojure_DOT_core}) + tmp151 := lang.Apply(tmp146, []any{tmp148, tmp150}) + tmp152 := lang.Apply(tmp145, []any{tmp151}) + tmp153 := lang.Apply(tmp144, []any{tmp152}) + tmp154 := lang.Apply(tmp141, []any{tmp143, tmp153}) + tmp155 := lang.Apply(tmp140, []any{tmp154}) + tmp156 := lang.Apply(tmp139, []any{tmp155}) + tmp157 := lang.Apply(tmp138, []any{tmp156}) + tmp158 := lang.Apply(tmp137, []any{tmp157}) + tmp135 = tmp158 + } else { + } + tmp159 := checkDerefVar(var_glojure_DOT_core_map) + tmp160 := lang.Apply(tmp159, []any{v10, v68}) + tmp161 := lang.Apply(tmp129, []any{tmp131, tmp132, tmp135, tmp160}) + tmp162 := lang.Apply(tmp128, []any{tmp161}) + tmp163 := lang.Apply(tmp127, []any{tmp162}) + tmp164 := checkDerefVar(var_glojure_DOT_core_list) + tmp165 := checkDerefVar(var_glojure_DOT_core_seq) + tmp166 := checkDerefVar(var_glojure_DOT_core_concat) + tmp167 := checkDerefVar(var_glojure_DOT_core_list) + tmp168 := lang.Apply(tmp167, []any{sym_if}) + tmp169 := checkDerefVar(var_glojure_DOT_core_list) + tmp170 := checkDerefVar(var_glojure_DOT_core_seq) + tmp171 := checkDerefVar(var_glojure_DOT_core_concat) + tmp172 := checkDerefVar(var_glojure_DOT_core_list) + tmp173 := lang.Apply(tmp172, []any{sym__DOT_Equals}) + tmp174 := checkDerefVar(var_glojure_DOT_core_list) + tmp175 := checkDerefVar(var_glojure_DOT_core_seq) + tmp176 := checkDerefVar(var_glojure_DOT_core_concat) + tmp177 := checkDerefVar(var_glojure_DOT_core_list) + tmp178 := lang.Apply(tmp177, []any{sym_quote}) + tmp179 := checkDerefVar(var_glojure_DOT_core_list) + tmp180 := lang.Apply(tmp179, []any{v44}) + tmp181 := lang.Apply(tmp176, []any{tmp178, tmp180}) + tmp182 := lang.Apply(tmp175, []any{tmp181}) + tmp183 := lang.Apply(tmp174, []any{tmp182}) + tmp184 := checkDerefVar(var_glojure_DOT_core_list) + tmp185 := checkDerefVar(var_glojure_DOT_core_seq) + tmp186 := checkDerefVar(var_glojure_DOT_core_concat) + tmp187 := checkDerefVar(var_glojure_DOT_core_list) + tmp188 := lang.Apply(tmp187, []any{sym_quote}) + tmp189 := checkDerefVar(var_glojure_DOT_core_list) + tmp190 := lang.Apply(tmp189, []any{sym_glojure_DOT_core}) + tmp191 := lang.Apply(tmp186, []any{tmp188, tmp190}) + tmp192 := lang.Apply(tmp185, []any{tmp191}) + tmp193 := lang.Apply(tmp184, []any{tmp192}) + tmp194 := lang.Apply(tmp171, []any{tmp173, tmp183, tmp193}) + tmp195 := lang.Apply(tmp170, []any{tmp194}) + tmp196 := lang.Apply(tmp169, []any{tmp195}) + tmp197 := checkDerefVar(var_glojure_DOT_core_list) + tmp198 := lang.Apply(tmp197, []any{nil}) + tmp199 := checkDerefVar(var_glojure_DOT_core_list) + tmp200 := checkDerefVar(var_glojure_DOT_core_seq) + tmp201 := checkDerefVar(var_glojure_DOT_core_concat) + tmp202 := checkDerefVar(var_glojure_DOT_core_list) + tmp203 := lang.Apply(tmp202, []any{sym_do}) + tmp204 := checkDerefVar(var_glojure_DOT_core_list) + tmp205 := checkDerefVar(var_glojure_DOT_core_seq) + tmp206 := checkDerefVar(var_glojure_DOT_core_concat) + tmp207 := checkDerefVar(var_glojure_DOT_core_list) + tmp208 := lang.Apply(tmp207, []any{sym_glojure_DOT_core_SLASH_dosync}) + tmp209 := checkDerefVar(var_glojure_DOT_core_list) + tmp210 := checkDerefVar(var_glojure_DOT_core_seq) + tmp211 := checkDerefVar(var_glojure_DOT_core_concat) + tmp212 := checkDerefVar(var_glojure_DOT_core_list) + tmp213 := lang.Apply(tmp212, []any{sym_glojure_DOT_core_SLASH_commute}) + tmp214 := checkDerefVar(var_glojure_DOT_core_list) + tmp215 := checkDerefVar(var_glojure_DOT_core_seq) + tmp216 := checkDerefVar(var_glojure_DOT_core_concat) + tmp217 := checkDerefVar(var_glojure_DOT_core_list) + tmp218 := lang.Apply(tmp217, []any{sym_glojure_DOT_core_SLASH_deref}) + tmp219 := checkDerefVar(var_glojure_DOT_core_list) + tmp220 := checkDerefVar(var_glojure_DOT_core_seq) + tmp221 := checkDerefVar(var_glojure_DOT_core_concat) + tmp222 := checkDerefVar(var_glojure_DOT_core_list) + tmp223 := lang.Apply(tmp222, []any{sym_var}) + tmp224 := checkDerefVar(var_glojure_DOT_core_list) + tmp225 := lang.Apply(tmp224, []any{sym_glojure_DOT_core_SLASH__STAR_loaded_DASH_libs_STAR_}) + tmp226 := lang.Apply(tmp221, []any{tmp223, tmp225}) + tmp227 := lang.Apply(tmp220, []any{tmp226}) + tmp228 := lang.Apply(tmp219, []any{tmp227}) + tmp229 := lang.Apply(tmp216, []any{tmp218, tmp228}) + tmp230 := lang.Apply(tmp215, []any{tmp229}) + tmp231 := lang.Apply(tmp214, []any{tmp230}) + tmp232 := checkDerefVar(var_glojure_DOT_core_list) + tmp233 := lang.Apply(tmp232, []any{sym_glojure_DOT_core_SLASH_conj}) + tmp234 := checkDerefVar(var_glojure_DOT_core_list) + tmp235 := checkDerefVar(var_glojure_DOT_core_seq) + tmp236 := checkDerefVar(var_glojure_DOT_core_concat) + tmp237 := checkDerefVar(var_glojure_DOT_core_list) + tmp238 := lang.Apply(tmp237, []any{sym_quote}) + tmp239 := checkDerefVar(var_glojure_DOT_core_list) + tmp240 := lang.Apply(tmp239, []any{v44}) + tmp241 := lang.Apply(tmp236, []any{tmp238, tmp240}) + tmp242 := lang.Apply(tmp235, []any{tmp241}) + tmp243 := lang.Apply(tmp234, []any{tmp242}) + tmp244 := lang.Apply(tmp211, []any{tmp213, tmp231, tmp233, tmp243}) + tmp245 := lang.Apply(tmp210, []any{tmp244}) + tmp246 := lang.Apply(tmp209, []any{tmp245}) + tmp247 := lang.Apply(tmp206, []any{tmp208, tmp246}) + tmp248 := lang.Apply(tmp205, []any{tmp247}) + tmp249 := lang.Apply(tmp204, []any{tmp248}) + tmp250 := checkDerefVar(var_glojure_DOT_core_list) + tmp251 := lang.Apply(tmp250, []any{nil}) + tmp252 := lang.Apply(tmp201, []any{tmp203, tmp249, tmp251}) + tmp253 := lang.Apply(tmp200, []any{tmp252}) + tmp254 := lang.Apply(tmp199, []any{tmp253}) + tmp255 := lang.Apply(tmp166, []any{tmp168, tmp196, tmp198, tmp254}) + tmp256 := lang.Apply(tmp165, []any{tmp255}) + tmp257 := lang.Apply(tmp164, []any{tmp256}) + tmp258 := lang.Apply(tmp73, []any{tmp75, tmp93, tmp94, tmp163, tmp257}) + tmp259 := lang.Apply(tmp72, []any{tmp258}) + tmp6 = tmp259 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ns = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ns.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ns-imports + { + tmp0 := sym_ns_DASH_imports.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns)), kw_doc, "Returns a map of the import mappings for the namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4199), kw_end_DASH_line, int(4199))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_filter_DASH_key) + tmp4 := checkDerefVar(var_glojure_DOT_core_val) + tmp5 := checkDerefVar(var_glojure_DOT_core_partial) + tmp6 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp7 := reflect.TypeOf((*reflect.Type)(nil)).Elem() + tmp8 := lang.Apply(tmp5, []any{tmp6, tmp7}) + tmp9 := checkDerefVar(var_glojure_DOT_core_ns_DASH_map) + tmp10 := lang.Apply(tmp9, []any{v2}) + tmp11 := lang.Apply(tmp3, []any{tmp4, tmp8, tmp10}) + return tmp11 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ns_DASH_imports = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ns_DASH_imports.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // partition + { + tmp0 := sym_partition.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n, sym_coll), lang.NewVector(sym_n, sym_step, sym_coll), lang.NewVector(sym_n, sym_step, sym_pad, sym_coll)), kw_doc, "Returns a lazy sequence of lists of n items each, at offsets step\n apart. If step is not supplied, defaults to n, i.e. the partitions\n do not overlap. If a pad collection is supplied, use its elements as\n necessary to complete last partition upto n items. In case there are\n not enough padding elements, return a partition with less than n items.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(3177), kw_end_DASH_line, int(3177))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_partition) + tmp5 := lang.Apply(tmp4, []any{v2, v2, v3}) + return tmp5 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp6 any + { // let + // let binding "temp__0__auto__" + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := lang.Apply(tmp7, []any{v4}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + var tmp11 any + { // let + // let binding "s" + var v12 any = v9 + _ = v12 + var tmp13 any + { // let + // let binding "p" + tmp14 := checkDerefVar(var_glojure_DOT_core_doall) + tmp15 := checkDerefVar(var_glojure_DOT_core_take) + tmp16 := lang.Apply(tmp15, []any{v2, v12}) + tmp17 := lang.Apply(tmp14, []any{tmp16}) + var v18 any = tmp17 + _ = v18 + var tmp19 any + tmp20 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp21 := checkDerefVar(var_glojure_DOT_core_count) + tmp22 := lang.Apply(tmp21, []any{v18}) + tmp23 := lang.Apply(tmp20, []any{v2, tmp22}) + if lang.IsTruthy(tmp23) { + tmp24 := checkDerefVar(var_glojure_DOT_core_cons) + tmp25 := checkDerefVar(var_glojure_DOT_core_partition) + tmp26 := checkDerefVar(var_glojure_DOT_core_nthrest) + tmp27 := lang.Apply(tmp26, []any{v12, v3}) + tmp28 := lang.Apply(tmp25, []any{v2, v3, tmp27}) + tmp29 := lang.Apply(tmp24, []any{v18, tmp28}) + tmp19 = tmp29 + } else { + } + tmp13 = tmp19 + } // end let + tmp11 = tmp13 + } // end let + tmp10 = tmp11 + } else { + } + tmp6 = tmp10 + } // end let + return tmp6 + }) + tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) + return tmp6 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp7 any + { // let + // let binding "temp__0__auto__" + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := lang.Apply(tmp8, []any{v5}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + if lang.IsTruthy(v10) { + var tmp12 any + { // let + // let binding "s" + var v13 any = v10 + _ = v13 + var tmp14 any + { // let + // let binding "p" + tmp15 := checkDerefVar(var_glojure_DOT_core_doall) + tmp16 := checkDerefVar(var_glojure_DOT_core_take) + tmp17 := lang.Apply(tmp16, []any{v2, v13}) + tmp18 := lang.Apply(tmp15, []any{tmp17}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + tmp21 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp22 := checkDerefVar(var_glojure_DOT_core_count) + tmp23 := lang.Apply(tmp22, []any{v19}) + tmp24 := lang.Apply(tmp21, []any{v2, tmp23}) + if lang.IsTruthy(tmp24) { + tmp25 := checkDerefVar(var_glojure_DOT_core_cons) + tmp26 := checkDerefVar(var_glojure_DOT_core_partition) + tmp27 := checkDerefVar(var_glojure_DOT_core_nthrest) + tmp28 := lang.Apply(tmp27, []any{v13, v3}) + tmp29 := lang.Apply(tmp26, []any{v2, v3, v4, tmp28}) + tmp30 := lang.Apply(tmp25, []any{v19, tmp29}) + tmp20 = tmp30 + } else { + tmp31 := checkDerefVar(var_glojure_DOT_core_list) + tmp32 := checkDerefVar(var_glojure_DOT_core_take) + tmp33 := checkDerefVar(var_glojure_DOT_core_concat) + tmp34 := lang.Apply(tmp33, []any{v19, v4}) + tmp35 := lang.Apply(tmp32, []any{v2, tmp34}) + tmp36 := lang.Apply(tmp31, []any{tmp35}) + tmp20 = tmp36 + } + tmp14 = tmp20 + } // end let + tmp12 = tmp14 + } // end let + tmp11 = tmp12 + } else { + } + tmp7 = tmp11 + } // end let + return tmp7 + }) + tmp7 := lang.Apply(lang.NewLazySeq, []any{tmp6}) + return tmp7 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_partition = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_partition.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // partition-all + { + tmp0 := sym_partition_DASH_all.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n), lang.NewVector(sym_n, sym_coll), lang.NewVector(sym_n, sym_step, sym_coll)), kw_doc, "Returns a lazy sequence of lists like partition, but may include\n partitions with fewer than n items at the end. Returns a stateful\n transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(7222), kw_end_DASH_line, int(7222))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 any + { // let + // let binding "a" + tmp6 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) + tmp7 := lang.Apply(tmp6, []any{v2}) + tmp8 := lang.Apply(lang.NewArrayList, []any{tmp7}) + var v9 any = tmp8 + _ = v9 + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp11 := lang.Apply(v4, nil) + return tmp11 + case 1: + v11 := args[0] + _ = v11 + var tmp12 any + { // let + // let binding "result" + var tmp13 any + tmp14, ok := lang.FieldOrMethod(v9, "isEmpty") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v9, "isEmpty"))) + } + var tmp15 any + switch reflect.TypeOf(tmp14).Kind() { + case reflect.Func: + tmp15 = lang.Apply(tmp14, nil) + default: + tmp15 = tmp14 + } + if lang.IsTruthy(tmp15) { + tmp13 = v11 + } else { + var tmp16 any + { // let + // let binding "v" + tmp17 := checkDerefVar(var_glojure_DOT_core_vec) + tmp18, ok := lang.FieldOrMethod(v9, "toArray") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v9, "toArray"))) + } + var tmp19 any + switch reflect.TypeOf(tmp18).Kind() { + case reflect.Func: + tmp19 = lang.Apply(tmp18, nil) + default: + tmp19 = tmp18 + } + tmp20 := lang.Apply(tmp17, []any{tmp19}) + var v21 any = tmp20 + _ = v21 + tmp22, ok := lang.FieldOrMethod(v9, "clear") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v9, "clear"))) + } + var tmp23 any + switch reflect.TypeOf(tmp22).Kind() { + case reflect.Func: + tmp23 = lang.Apply(tmp22, nil) + default: + tmp23 = tmp22 + } + _ = tmp23 + tmp24 := checkDerefVar(var_glojure_DOT_core_unreduced) + tmp25 := lang.Apply(v4, []any{v11, v21}) + tmp26 := lang.Apply(tmp24, []any{tmp25}) + tmp16 = tmp26 + } // end let + tmp13 = tmp16 + } + var v17 any = tmp13 + _ = v17 + tmp18 := lang.Apply(v4, []any{v17}) + tmp12 = tmp18 + } // end let + return tmp12 + case 2: + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13, _ := lang.FieldOrMethod(v9, "add") + if reflect.TypeOf(tmp13).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) + } + tmp14 := lang.Apply(tmp13, []any{v12}) + _ = tmp14 + var tmp15 any + tmp16 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp17, ok := lang.FieldOrMethod(v9, "size") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v9, "size"))) + } + var tmp18 any + switch reflect.TypeOf(tmp17).Kind() { + case reflect.Func: + tmp18 = lang.Apply(tmp17, nil) + default: + tmp18 = tmp17 + } + tmp19 := lang.Apply(tmp16, []any{v2, tmp18}) + if lang.IsTruthy(tmp19) { + var tmp20 any + { // let + // let binding "v" + tmp21 := checkDerefVar(var_glojure_DOT_core_vec) + tmp22, ok := lang.FieldOrMethod(v9, "toArray") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v9, "toArray"))) + } + var tmp23 any + switch reflect.TypeOf(tmp22).Kind() { + case reflect.Func: + tmp23 = lang.Apply(tmp22, nil) + default: + tmp23 = tmp22 + } + tmp24 := lang.Apply(tmp21, []any{tmp23}) + var v25 any = tmp24 + _ = v25 + tmp26, ok := lang.FieldOrMethod(v9, "clear") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v9, "clear"))) + } + var tmp27 any + switch reflect.TypeOf(tmp26).Kind() { + case reflect.Func: + tmp27 = lang.Apply(tmp26, nil) + default: + tmp27 = tmp26 + } + _ = tmp27 + tmp28 := lang.Apply(v4, []any{v11, v25}) + tmp20 = tmp28 + } // end let + tmp15 = tmp20 + } else { + tmp15 = v11 + } + return tmp15 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7231), kw_column, int(8), kw_end_DASH_line, int(7247), kw_end_DASH_column, int(23)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp5 = tmp12 + } // end let + return tmp5 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7229), kw_column, int(4), kw_end_DASH_line, int(7247), kw_end_DASH_column, int(25)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_partition_DASH_all) + tmp5 := lang.Apply(tmp4, []any{v2, v2, v3}) + return tmp5 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp6 any + { // let + // let binding "temp__0__auto__" + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := lang.Apply(tmp7, []any{v4}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + var tmp11 any + { // let + // let binding "s" + var v12 any = v9 + _ = v12 + var tmp13 any + { // let + // let binding "seg" + tmp14 := checkDerefVar(var_glojure_DOT_core_doall) + tmp15 := checkDerefVar(var_glojure_DOT_core_take) + tmp16 := lang.Apply(tmp15, []any{v2, v12}) + tmp17 := lang.Apply(tmp14, []any{tmp16}) + var v18 any = tmp17 + _ = v18 + tmp19 := checkDerefVar(var_glojure_DOT_core_cons) + tmp20 := checkDerefVar(var_glojure_DOT_core_partition_DASH_all) + tmp21 := checkDerefVar(var_glojure_DOT_core_nthrest) + tmp22 := lang.Apply(tmp21, []any{v12, v3}) + tmp23 := lang.Apply(tmp20, []any{v2, v3, tmp22}) + tmp24 := lang.Apply(tmp19, []any{v18, tmp23}) + tmp13 = tmp24 + } // end let + tmp11 = tmp13 + } // end let + tmp10 = tmp11 + } else { + } + tmp6 = tmp10 + } // end let + return tmp6 + }) + tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_partition_DASH_all = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_partition_DASH_all.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // pcalls + { + tmp0 := sym_pcalls.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_fns)), kw_doc, "Executes the no-arg fns in parallel, returning a lazy sequence of\n their values", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(7056), kw_end_DASH_line, int(7056))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_pmap) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v5 := args[0] + _ = v5 + tmp6 := lang.Apply(v5, nil) + return tmp6 + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7061), kw_column, int(17), kw_end_DASH_line, int(7061), kw_end_DASH_column, int(20)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp7 := lang.Apply(tmp3, []any{tmp6, v2}) + return tmp7 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_pcalls = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_pcalls.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // prep-ints + { + tmp0 := sym_prep_DASH_ints.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_tests, sym_thens)), kw_doc, "Takes a sequence of int-sized test constants and a corresponding sequence of\n then expressions. Returns a tuple of [shift mask case-map switch-type] where\n case-map is a map of int case values to [test then] tuples, and switch-type\n is either :sparse or :compact.", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(8), kw_line, int(6631), kw_end_DASH_line, int(6631), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_fits_DASH_table_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v2}) + if lang.IsTruthy(tmp6) { + tmp7 := checkDerefVar(var_glojure_DOT_core_case_DASH_map) + tmp8 := checkDerefVar(var_glojure_DOT_core_int) + tmp9 := checkDerefVar(var_glojure_DOT_core_int) + tmp10 := lang.Apply(tmp7, []any{tmp8, tmp9, v2, v3}) + tmp11 := lang.NewVector(int64(0), int64(0), tmp10, kw_compact) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6639), kw_column, int(5), kw_end_DASH_line, int(6639), kw_end_DASH_column, int(49)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp4 = tmp13 + } else { + var tmp14 any + { // let + // let binding "vec__851" + var tmp15 any + { // let + // let binding "or__0__auto__" + tmp16 := checkDerefVar(var_glojure_DOT_core_maybe_DASH_min_DASH_hash) + tmp17 := checkDerefVar(var_glojure_DOT_core_map) + tmp18 := checkDerefVar(var_glojure_DOT_core_int) + tmp19 := lang.Apply(tmp17, []any{tmp18, v2}) + tmp20 := lang.Apply(tmp16, []any{tmp19}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + if lang.IsTruthy(v21) { + tmp22 = v21 + } else { + tmp23 := lang.NewVector(int64(0), int64(0)) + tmp24 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6640), kw_column, int(61), kw_end_DASH_line, int(6640), kw_end_DASH_column, int(65)) + tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp22 = tmp25 + } + tmp15 = tmp22 + } // end let + var v16 any = tmp15 + _ = v16 + // let binding "shift" + tmp17 := checkDerefVar(var_glojure_DOT_core_nth) + tmp18 := lang.Apply(tmp17, []any{v16, int64(0), nil}) + var v19 any = tmp18 + _ = v19 + // let binding "mask" + tmp20 := checkDerefVar(var_glojure_DOT_core_nth) + tmp21 := lang.Apply(tmp20, []any{v16, int64(1), nil}) + var v22 any = tmp21 + _ = v22 + var tmp23 any + tmp24 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) + tmp25 := lang.Apply(tmp24, []any{v22}) + if lang.IsTruthy(tmp25) { + tmp26 := checkDerefVar(var_glojure_DOT_core_case_DASH_map) + tmp27 := checkDerefVar(var_glojure_DOT_core_int) + tmp28 := checkDerefVar(var_glojure_DOT_core_int) + tmp29 := lang.Apply(tmp26, []any{tmp27, tmp28, v2, v3}) + tmp30 := lang.NewVector(int64(0), int64(0), tmp29, kw_sparse) + tmp31 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6643), kw_column, int(9), kw_end_DASH_line, int(6643), kw_end_DASH_column, int(52)) + tmp32, err := lang.WithMeta(tmp30, tmp31.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp23 = tmp32 + } else { + tmp33 := checkDerefVar(var_glojure_DOT_core_case_DASH_map) + var tmp34 lang.FnFunc + tmp34 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v35 := args[0] + _ = v35 + tmp36 := checkDerefVar(var_glojure_DOT_core_shift_DASH_mask) + tmp37 := checkDerefVar(var_glojure_DOT_core_int) + tmp38 := lang.Apply(tmp37, []any{v35}) + tmp39 := lang.Apply(tmp36, []any{v19, v22, tmp38}) + return tmp39 + }) + tmp35 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6645), kw_column, int(31), kw_end_DASH_line, int(6645), kw_end_DASH_column, int(62)) + tmp36, err := lang.WithMeta(tmp34, tmp35.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp37 := checkDerefVar(var_glojure_DOT_core_int) + tmp38 := lang.Apply(tmp33, []any{tmp36, tmp37, v2, v3}) + tmp39 := lang.NewVector(v19, v22, tmp38, kw_compact) + tmp40 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6645), kw_column, int(9), kw_end_DASH_line, int(6645), kw_end_DASH_column, int(89)) + tmp41, err := lang.WithMeta(tmp39, tmp40.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp23 = tmp41 + } + tmp14 = tmp23 + } // end let + tmp4 = tmp14 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_prep_DASH_ints = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_prep_DASH_ints.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print-prefix-map + { + tmp0 := sym_print_DASH_prefix_DASH_map.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(243), kw_column, int(8), kw_end_DASH_line, int(243), kw_end_DASH_column, int(23), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_prefix, sym_kvs, sym_print_DASH_one, sym_w)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_print_DASH_sequential) + tmp7 := checkDerefVar(var_glojure_DOT_core_str) + tmp8 := lang.Apply(tmp7, []any{v2, "{"}) + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + var tmp12 any + { // let + // let binding "vec__903" + var v13 any = v10 + _ = v13 + // let binding "k" + tmp14 := checkDerefVar(var_glojure_DOT_core_nth) + tmp15 := lang.Apply(tmp14, []any{v13, int64(0), nil}) + var v16 any = tmp15 + _ = v16 + // let binding "v" + tmp17 := checkDerefVar(var_glojure_DOT_core_nth) + tmp18 := lang.Apply(tmp17, []any{v13, int64(1), nil}) + var v19 any = tmp18 + _ = v19 + tmp20 := lang.Apply(v4, []any{v16, v11}) + _ = tmp20 + tmp21 := lang.Apply(lang.AppendWriter, []any{v11, lang.NewChar(32)}) + _ = tmp21 + tmp22 := lang.Apply(v4, []any{v19, v11}) + tmp12 = tmp22 + } // end let + return tmp12 + }) + tmp10 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(246), kw_column, int(5), kw_end_DASH_line, int(247), kw_end_DASH_column, int(107)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp12 := lang.Apply(tmp6, []any{tmp8, tmp11, ", ", "}", v3, v5}) + return tmp12 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_print_DASH_prefix_DASH_map = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_print_DASH_prefix_DASH_map.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // promise + { + tmp0 := sym_promise.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Returns a promise object that can be read with deref/@, and set,\n once only, with deliver. Calls to deref/@ prior to delivery will\n block, unless the variant of deref with timeout is used. All\n subsequent derefs will return the same delivered value without\n blocking. See also - realized?.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(7078), kw_end_DASH_line, int(7078))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp2 any + { // let + // let binding "d" + tmp3 := lang.Apply(nil, []any{int64(1)}) + var v4 any = tmp3 + _ = v4 + // let binding "v" + tmp5 := checkDerefVar(var_glojure_DOT_core_atom) + tmp6 := lang.Apply(tmp5, []any{v4}) + var v7 any = tmp6 + _ = v7 + tmp8 := reflect.TypeOf((*lang.IDeref)(nil)).Elem() + tmp9 := checkDerefVar(var_glojure_DOT_core_deref) + tmp10 := lang.NewVector(nil) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7091), kw_column, int(15), kw_end_DASH_line, int(7091), kw_end_DASH_column, int(17)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13, ok := lang.FieldOrMethod(v4, "await") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "await"))) + } + var tmp14 any + switch reflect.TypeOf(tmp13).Kind() { + case reflect.Func: + tmp14 = lang.Apply(tmp13, nil) + default: + tmp14 = tmp13 + } + tmp15 := checkDerefVar(var_glojure_DOT_core_deref) + tmp16 := lang.Apply(tmp15, []any{v7}) + tmp17 := lang.Apply(tmp9, []any{tmp12, tmp14, tmp16}) + tmp18 := reflect.TypeOf((*lang.IBlockingDeref)(nil)).Elem() + tmp19 := checkDerefVar(var_glojure_DOT_core_deref) + tmp20 := lang.NewVector(nil, nil, nil) + tmp21 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7094), kw_column, int(9), kw_end_DASH_line, int(7094), kw_end_DASH_column, int(34)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var tmp23 any + tmp24, _ := lang.FieldOrMethod(v4, "await") + if reflect.TypeOf(tmp24).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) + } + tmp25 := lang.Apply(tmp24, []any{nil, time7.Millisecond}) + if lang.IsTruthy(tmp25) { + tmp26 := checkDerefVar(var_glojure_DOT_core_deref) + tmp27 := lang.Apply(tmp26, []any{v7}) + tmp23 = tmp27 + } else { + } + tmp28 := lang.Apply(tmp19, []any{tmp22, tmp23}) + tmp29 := reflect.TypeOf((*lang.IPending)(nil)).Elem() + tmp30 := lang.NewVector(nil) + tmp31 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7099), kw_column, int(19), kw_end_DASH_line, int(7099), kw_end_DASH_column, int(24)) + tmp32, err := lang.WithMeta(tmp30, tmp31.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp33 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) + tmp34, ok := lang.FieldOrMethod(v4, "getCount") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "getCount"))) + } + var tmp35 any + switch reflect.TypeOf(tmp34).Kind() { + case reflect.Func: + tmp35 = lang.Apply(tmp34, nil) + default: + tmp35 = tmp34 + } + tmp36 := lang.Apply(tmp33, []any{tmp35}) + tmp37 := lang.Apply(nil, []any{tmp32, tmp36}) + tmp38 := lang.NewVector(nil, nil) + tmp39 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7103), kw_column, int(7), kw_end_DASH_line, int(7103), kw_end_DASH_column, int(14)) + tmp40, err := lang.WithMeta(tmp38, tmp39.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var tmp41 any + var tmp42 any + { // let + // let binding "and__0__auto__" + tmp43 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp44, ok := lang.FieldOrMethod(v4, "getCount") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "getCount"))) + } + var tmp45 any + switch reflect.TypeOf(tmp44).Kind() { + case reflect.Func: + tmp45 = lang.Apply(tmp44, nil) + default: + tmp45 = tmp44 + } + tmp46 := lang.Apply(tmp43, []any{tmp45}) + var v47 any = tmp46 + _ = v47 + var tmp48 any + if lang.IsTruthy(v47) { + tmp49 := checkDerefVar(var_glojure_DOT_core_compare_DASH_and_DASH_set_BANG_) + tmp50 := lang.Apply(tmp49, []any{v7, v4, nil}) + tmp48 = tmp50 + } else { + tmp48 = v47 + } + tmp42 = tmp48 + } // end let + if lang.IsTruthy(tmp42) { + tmp43, ok := lang.FieldOrMethod(v4, "countDown") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "countDown"))) + } + var tmp44 any + switch reflect.TypeOf(tmp43).Kind() { + case reflect.Func: + tmp44 = lang.Apply(tmp43, nil) + default: + tmp44 = tmp43 + } + _ = tmp44 + } else { + } + tmp45 := lang.Apply(nil, []any{tmp40, tmp41}) + tmp46 := lang.Apply(nil, []any{tmp8, tmp17, tmp18, tmp28, tmp29, tmp37, nil, tmp45}) + tmp2 = tmp46 + } // end let + return tmp2 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_promise = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_promise.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // re-find + { + tmp0 := sym_re_DASH_find.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m), lang.NewVector(sym_re, sym_s)), kw_doc, "Returns the next regex match, if any, of string to pattern, using\n java.util.regex.Matcher.find(). Uses re-groups to return the\n groups.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4922), kw_end_DASH_line, int(4922))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + tmp4, _ := lang.FieldOrMethod(v2, "find") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("find is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{}) + if lang.IsTruthy(tmp5) { + tmp6 := checkDerefVar(var_glojure_DOT_core_re_DASH_groups) + tmp7 := lang.Apply(tmp6, []any{v2}) + tmp3 = tmp7 + } else { + } + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "m" + tmp5 := checkDerefVar(var_glojure_DOT_core_re_DASH_matcher) + tmp6 := lang.Apply(tmp5, []any{v2, v3}) + var v7 any = tmp6 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_re_DASH_find) + tmp9 := lang.Apply(tmp8, []any{v7}) + tmp4 = tmp9 + } // end let + return tmp4 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_re_DASH_find = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_re_DASH_find.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ref + { + tmp0 := sym_ref.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym__AMP_, sym_options)), kw_doc, "Creates and returns a Ref with an initial value of x and zero or\n more options (in any order):\n\n :meta metadata-map\n\n :validator validate-fn\n\n :min-history (default 0)\n :max-history (default 10)\n\n If metadata-map is supplied, it will become the metadata on the\n ref. validate-fn must be nil or a side-effect-free fn of one\n argument, which will be passed the intended new state on any state\n change. If the new state is unacceptable, the validate-fn should\n return false or throw an exception. validate-fn will be called on\n transaction commit, when all refs have their final values.\n\n Normally refs accumulate history dynamically as needed to deal with\n read demands. If you know in advance you will need history you can\n set :min-history to ensure it will be available when first needed (instead\n of after a read fault). History is limited, and the limit can be set\n with :max-history.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(2260), kw_end_DASH_line, int(2260))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(lang.NewRef, []any{v2}) + return tmp3 + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + var tmp4 any + { // let + // let binding "r" + tmp5 := checkDerefVar(var_glojure_DOT_core_setup_DASH_reference) + tmp6 := checkDerefVar(var_glojure_DOT_core_ref) + tmp7 := lang.Apply(tmp6, []any{v2}) + tmp8 := lang.Apply(tmp5, []any{tmp7, v3}) + var v9 any = tmp8 + _ = v9 + // let binding "opts" + tmp10 := checkDerefVar(var_glojure_DOT_core_apply) + tmp11 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp12 := lang.Apply(tmp10, []any{tmp11, v3}) + var v13 any = tmp12 + _ = v13 + var tmp14 any + tmp15 := lang.Apply(kw_max_DASH_history, []any{v13}) + if lang.IsTruthy(tmp15) { + tmp16 := lang.Apply(kw_max_DASH_history, []any{v13}) + tmp17, _ := lang.FieldOrMethod(v9, "setMaxHistory") + if reflect.TypeOf(tmp17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMaxHistory is not a function"))) + } + tmp18 := lang.Apply(tmp17, []any{tmp16}) + tmp14 = tmp18 + } else { + } + _ = tmp14 + var tmp19 any + tmp20 := lang.Apply(kw_min_DASH_history, []any{v13}) + if lang.IsTruthy(tmp20) { + tmp21 := lang.Apply(kw_min_DASH_history, []any{v13}) + tmp22, _ := lang.FieldOrMethod(v9, "setMinHistory") + if reflect.TypeOf(tmp22).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMinHistory is not a function"))) + } + tmp23 := lang.Apply(tmp22, []any{tmp21}) + tmp19 = tmp23 + } else { + } + _ = tmp19 + tmp4 = v9 + } // end let + return tmp4 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ref = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ref.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // repeatedly + { + tmp0 := sym_repeatedly.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_n, sym_f)), kw_doc, "Takes a function of no args, presumably with side effects, and\n returns an infinite (or length n if supplied) lazy sequence of calls\n to it", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(5167), kw_end_DASH_line, int(5167))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp4 := checkDerefVar(var_glojure_DOT_core_cons) + tmp5 := lang.Apply(v2, nil) + tmp6 := checkDerefVar(var_glojure_DOT_core_repeatedly) + tmp7 := lang.Apply(tmp6, []any{v2}) + tmp8 := lang.Apply(tmp4, []any{tmp5, tmp7}) + return tmp8 + }) + tmp4 := lang.Apply(lang.NewLazySeq, []any{tmp3}) + return tmp4 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_take) + tmp5 := checkDerefVar(var_glojure_DOT_core_repeatedly) + tmp6 := lang.Apply(tmp5, []any{v3}) + tmp7 := lang.Apply(tmp4, []any{v2, tmp6}) + return tmp7 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_repeatedly = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_repeatedly.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // replicate + { + tmp0 := sym_replicate.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n, sym_x)), kw_doc, "DEPRECATED: Use 'repeat' instead.\n Returns a lazy seq of n xs.", kw_file, "glojure/core.glj", kw_deprecated, "1.3", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(3004), kw_end_DASH_line, int(3004))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_take) + tmp5 := checkDerefVar(var_glojure_DOT_core_repeat) + tmp6 := lang.Apply(tmp5, []any{v3}) + tmp7 := lang.Apply(tmp4, []any{v2, tmp6}) + return tmp7 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_replicate = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_replicate.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // resultset-seq + { + tmp0 := sym_resultset_DASH_seq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_rs)), kw_doc, "Creates and returns a lazy sequence of structmaps corresponding to\n the rows in the java.sql.ResultSet rs", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(5681), kw_end_DASH_line, int(5681))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "rsmeta" + tmp4, _ := lang.FieldOrMethod(v2, "getMetaData") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getMetaData is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{}) + var v6 any = tmp5 + _ = v6 + // let binding "idxs" + tmp7 := checkDerefVar(var_glojure_DOT_core_range) + tmp8 := checkDerefVar(var_glojure_DOT_core_inc) + tmp9, _ := lang.FieldOrMethod(v6, "getColumnCount") + if reflect.TypeOf(tmp9).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getColumnCount is not a function"))) + } + tmp10 := lang.Apply(tmp9, []any{}) + tmp11 := lang.Apply(tmp8, []any{tmp10}) + tmp12 := lang.Apply(tmp7, []any{int64(1), tmp11}) + var v13 any = tmp12 + _ = v13 + // let binding "keys" + tmp14 := checkDerefVar(var_glojure_DOT_core_map) + tmp15 := checkDerefVar(var_glojure_DOT_core_comp) + tmp16 := checkDerefVar(var_glojure_DOT_core_keyword) + var tmp17 lang.FnFunc + tmp17 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v18 := args[0] + _ = v18 + tmp19, ok := lang.FieldOrMethod(v18, "toLowerCase") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v18, "toLowerCase"))) + } + var tmp20 any + switch reflect.TypeOf(tmp19).Kind() { + case reflect.Func: + tmp20 = lang.Apply(tmp19, nil) + default: + tmp20 = tmp19 + } + return tmp20 + }) + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5688), kw_column, int(35), kw_end_DASH_line, int(5688), kw_end_DASH_column, int(62)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp20 := lang.Apply(tmp15, []any{tmp16, tmp19}) + tmp21 := checkDerefVar(var_glojure_DOT_core_map) + var tmp22 lang.FnFunc + tmp22 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v23 := args[0] + _ = v23 + tmp24, _ := lang.FieldOrMethod(v6, "getColumnLabel") + if reflect.TypeOf(tmp24).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getColumnLabel is not a function"))) + } + tmp25 := lang.Apply(tmp24, []any{v23}) + return tmp25 + }) + tmp23 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5689), kw_column, int(26), kw_end_DASH_line, int(5689), kw_end_DASH_column, int(63)) + tmp24, err := lang.WithMeta(tmp22, tmp23.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp25 := lang.Apply(tmp21, []any{tmp24, v13}) + tmp26 := lang.Apply(tmp14, []any{tmp20, tmp25}) + var v27 any = tmp26 + _ = v27 + // let binding "check-keys" + var tmp28 any + { // let + // let binding "or__0__auto__" + tmp29 := checkDerefVar(var_glojure_DOT_core_apply) + tmp30 := checkDerefVar(var_glojure_DOT_core_distinct_QMARK_) + tmp31 := lang.Apply(tmp29, []any{tmp30, v27}) + var v32 any = tmp31 + _ = v32 + var tmp33 any + if lang.IsTruthy(v32) { + tmp33 = v32 + } else { + tmp34 := lang.Apply(lang.NewError, []any{"ResultSet must have unique column labels"}) + panic(tmp34) + } + tmp28 = tmp33 + } // end let + var v29 any = tmp28 + _ = v29 + // let binding "row-struct" + tmp30 := checkDerefVar(var_glojure_DOT_core_apply) + tmp31 := checkDerefVar(var_glojure_DOT_core_create_DASH_struct) + tmp32 := lang.Apply(tmp30, []any{tmp31, v27}) + var v33 any = tmp32 + _ = v33 + // let binding "row-values" + var tmp34 lang.FnFunc + tmp34 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp35 := checkDerefVar(var_glojure_DOT_core_map) + var tmp36 lang.FnFunc + tmp36 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v37 := args[0] + _ = v37 + tmp38, _ := lang.FieldOrMethod(v2, "getObject") + if reflect.TypeOf(tmp38).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getObject is not a function"))) + } + tmp39 := lang.Apply(tmp38, []any{v37}) + return tmp39 + }) + tmp37 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5694), kw_column, int(34), kw_end_DASH_line, int(5694), kw_end_DASH_column, int(71)) + tmp38, err := lang.WithMeta(tmp36, tmp37.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp39 := lang.Apply(tmp35, []any{tmp38, v13}) + return tmp39 + }) + tmp35 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5694), kw_column, int(22), kw_end_DASH_line, int(5694), kw_end_DASH_column, int(78)) + tmp36, err := lang.WithMeta(tmp34, tmp35.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v37 any = tmp36 + _ = v37 + // let binding "rows" + var tmp38 lang.FnFunc + { // function thisfn + var v39 lang.FnFunc + tmp38 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp40 any + tmp41, _ := lang.FieldOrMethod(v2, "next") + if reflect.TypeOf(tmp41).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("next is not a function"))) + } + tmp42 := lang.Apply(tmp41, []any{}) + if lang.IsTruthy(tmp42) { + tmp43 := checkDerefVar(var_glojure_DOT_core_cons) + tmp44 := checkDerefVar(var_glojure_DOT_core_apply) + tmp45 := checkDerefVar(var_glojure_DOT_core_struct) + tmp46 := lang.Apply(v37, nil) + tmp47 := lang.Apply(tmp44, []any{tmp45, v33, tmp46}) + var tmp48 lang.FnFunc + tmp48 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp49 := lang.Apply(v39, nil) + return tmp49 + }) + tmp49 := lang.Apply(lang.NewLazySeq, []any{tmp48}) + tmp50 := lang.Apply(tmp43, []any{tmp47, tmp49}) + tmp40 = tmp50 + } else { + } + return tmp40 + }) + v39 = tmp38 + _ = v39 + } + tmp39 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5695), kw_column, int(16), kw_end_DASH_line, int(5697), kw_end_DASH_column, int(86)) + tmp40, err := lang.WithMeta(tmp38, tmp39.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v41 any = tmp40 + _ = v41 + tmp42 := lang.Apply(v41, nil) + tmp3 = tmp42 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_resultset_DASH_seq = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_resultset_DASH_seq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // send + { + tmp0 := sym_send.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a, sym_f, sym__AMP_, sym_args)), kw_doc, "Dispatch an action to an agent. Returns the agent immediately.\n Subsequently, in a thread from a thread pool, the state of the agent\n will be set to the value of:\n\n (apply action-fn state-of-agent args)", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(2109), kw_end_DASH_line, int(2109))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_apply) + tmp6 := checkDerefVar(var_glojure_DOT_core_send_DASH_via) + tmp7 := lang.Apply(tmp5, []any{tmp6, nil, v2, v3, v4}) + return tmp7 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_send = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_send.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // send-off + { + tmp0 := sym_send_DASH_off.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a, sym_f, sym__AMP_, sym_args)), kw_doc, "Dispatch a potentially blocking action to an agent. Returns the\n agent immediately. Subsequently, in a separate thread, the state of\n the agent will be set to the value of:\n\n (apply action-fn state-of-agent args)", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(2120), kw_end_DASH_line, int(2120))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_apply) + tmp6 := checkDerefVar(var_glojure_DOT_core_send_DASH_via) + tmp7 := lang.Apply(tmp5, []any{tmp6, nil, v2, v3, v4}) + return tmp7 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_send_DASH_off = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_send_DASH_off.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // seque + { + tmp0 := sym_seque.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s), lang.NewVector(sym_n_DASH_or_DASH_q, sym_s)), kw_doc, "Creates a queued seq on another (presumably lazy) seq s. The queued\n seq will produce a concrete seq in the background, and can get up to\n n items ahead of the consumer. n-or-q can be an integer n buffer\n size, or an instance of java.util.concurrent BlockingQueue. Note\n that reading from a seque can block if the reader gets ahead of the\n producer.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(5419), kw_end_DASH_line, int(5419))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_seque) + tmp4 := lang.Apply(tmp3, []any{int64(100), v2}) + return tmp4 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "q" + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp7 := lang.Apply(tmp6, []any{nil, v2}) + if lang.IsTruthy(tmp7) { + tmp5 = v2 + } else { + tmp8 := checkDerefVar(var_glojure_DOT_core_int) + tmp9 := lang.Apply(tmp8, []any{v2}) + tmp10 := lang.Apply(nil, []any{tmp9}) + tmp5 = tmp10 + } + var v11 any = tmp5 + _ = v11 + // let binding "NIL" + tmp12 := lang.Apply(reflect.StructOf, []any{nil}) + tmp13 := lang.Apply(reflect.New, []any{tmp12}) + tmp14, ok := lang.FieldOrMethod(tmp13, "Interface") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp13, "Interface"))) + } + var tmp15 any + switch reflect.TypeOf(tmp14).Kind() { + case reflect.Func: + tmp15 = lang.Apply(tmp14, nil) + default: + tmp15 = tmp14 + } + var v16 any = tmp15 + _ = v16 + // let binding "agt" + tmp17 := checkDerefVar(var_glojure_DOT_core_agent) + var tmp18 lang.FnFunc + tmp18 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + return v3 + }) + tmp19 := lang.Apply(lang.NewLazySeq, []any{tmp18}) + tmp20 := lang.Apply(tmp17, []any{tmp19}) + var v21 any = tmp20 + _ = v21 + // let binding "log-error" + var tmp22 lang.FnFunc + tmp22 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v23 := args[0] + _ = v23 + v24 := args[1] + _ = v24 + var tmp25 any + tmp26, _ := lang.FieldOrMethod(v23, "offer") + if reflect.TypeOf(tmp26).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("offer is not a function"))) + } + tmp27 := lang.Apply(tmp26, []any{v23}) + if lang.IsTruthy(tmp27) { + panic(v24) + } else { + tmp25 = v24 + } + return tmp25 + }) + tmp23 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5435), kw_column, int(20), kw_end_DASH_line, int(5438), kw_end_DASH_column, int(26)) + tmp24, err := lang.WithMeta(tmp22, tmp23.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v25 any = tmp24 + _ = v25 + // let binding "fill" + var tmp26 lang.FnFunc + tmp26 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v27 := args[0] + _ = v27 + var tmp28 any + if lang.IsTruthy(v27) { + var tmp29 any + tmp30 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp31 := lang.Apply(tmp30, []any{nil, v27}) + if lang.IsTruthy(tmp31) { + tmp32 := lang.Apply(v25, []any{v11, v27}) + tmp29 = tmp32 + } else { + var tmp33 any + func() { + defer func() { + if r := recover(); r != nil { + if lang.CatchMatches(r, lang.Builtins["any"]) { + v34 := r + _ = v34 + tmp35 := lang.Apply(v25, []any{v11, v34}) + tmp33 = tmp35 + } else { + panic(r) + } + } + }() + var tmp34 any + { // let + // let binding "G__780" + tmp35 := checkDerefVar(var_glojure_DOT_core_seq) + tmp36 := lang.Apply(tmp35, []any{v27}) + var v37 any = tmp36 + _ = v37 + // let binding "vec__781" + var v38 any = v37 + _ = v38 + // let binding "seq__782" + tmp39 := checkDerefVar(var_glojure_DOT_core_seq) + tmp40 := lang.Apply(tmp39, []any{v38}) + var v41 any = tmp40 + _ = v41 + // let binding "first__783" + tmp42 := checkDerefVar(var_glojure_DOT_core_first) + tmp43 := lang.Apply(tmp42, []any{v41}) + var v44 any = tmp43 + _ = v44 + // let binding "seq__782" + tmp45 := checkDerefVar(var_glojure_DOT_core_next) + tmp46 := lang.Apply(tmp45, []any{v41}) + var v47 any = tmp46 + _ = v47 + // let binding "x" + var v48 any = v44 + _ = v48 + // let binding "xs" + var v49 any = v47 + _ = v49 + // let binding "s" + var v50 any = v38 + _ = v50 + var tmp51 any + { // let + // let binding "G__780" + var v52 any = v37 + _ = v52 + for { + var tmp53 any + { // let + // let binding "vec__784" + var v54 any = v52 + _ = v54 + // let binding "seq__785" + tmp55 := checkDerefVar(var_glojure_DOT_core_seq) + tmp56 := lang.Apply(tmp55, []any{v54}) + var v57 any = tmp56 + _ = v57 + // let binding "first__786" + tmp58 := checkDerefVar(var_glojure_DOT_core_first) + tmp59 := lang.Apply(tmp58, []any{v57}) + var v60 any = tmp59 + _ = v60 + // let binding "seq__785" + tmp61 := checkDerefVar(var_glojure_DOT_core_next) + tmp62 := lang.Apply(tmp61, []any{v57}) + var v63 any = tmp62 + _ = v63 + // let binding "x" + var v64 any = v60 + _ = v64 + // let binding "xs" + var v65 any = v63 + _ = v65 + // let binding "s" + var v66 any = v54 + _ = v66 + var tmp67 any + if lang.IsTruthy(v66) { + var tmp68 any + var tmp69 any + tmp70 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp71 := lang.Apply(tmp70, []any{v64}) + if lang.IsTruthy(tmp71) { + tmp69 = v16 + } else { + tmp69 = v64 + } + tmp72, _ := lang.FieldOrMethod(v11, "offer") + if reflect.TypeOf(tmp72).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("offer is not a function"))) + } + tmp73 := lang.Apply(tmp72, []any{tmp69}) + if lang.IsTruthy(tmp73) { + var tmp74 any = v65 + v52 = tmp74 + continue + } else { + tmp68 = v66 + } + tmp67 = tmp68 + } else { + var tmp75 any + tmp76, _ := lang.FieldOrMethod(v11, "offer") + if reflect.TypeOf(tmp76).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("offer is not a function"))) + } + tmp77 := lang.Apply(tmp76, []any{v11}) + if lang.IsTruthy(tmp77) { + } else { + tmp75 = lang.NewList() + } + tmp67 = tmp75 + } + tmp53 = tmp67 + } // end let + tmp51 = tmp53 + break + } + } // end let + tmp34 = tmp51 + } // end let + tmp33 = tmp34 + }() + tmp29 = tmp33 + } + tmp28 = tmp29 + } else { + } + return tmp28 + }) + tmp27 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5439), kw_column, int(15), kw_end_DASH_line, int(5452), kw_end_DASH_column, int(44)) + tmp28, err := lang.WithMeta(tmp26, tmp27.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v29 any = tmp28 + _ = v29 + // let binding "drain" + var tmp30 lang.FnFunc + { // function drain + var v31 lang.FnFunc + tmp30 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp32 lang.FnFunc + tmp32 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp33 any + { // let + // let binding "x" + tmp34, ok := lang.FieldOrMethod(v11, "take") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v11, "take"))) + } + var tmp35 any + switch reflect.TypeOf(tmp34).Kind() { + case reflect.Func: + tmp35 = lang.Apply(tmp34, nil) + default: + tmp35 = tmp34 + } + var v36 any = tmp35 + _ = v36 + var tmp37 any + tmp38 := checkDerefVar(var_glojure_DOT_core_identical_QMARK_) + tmp39 := lang.Apply(tmp38, []any{v36, v11}) + if lang.IsTruthy(tmp39) { + tmp40 := checkDerefVar(var_glojure_DOT_core_deref) + tmp41 := lang.Apply(tmp40, []any{v21}) + _ = tmp41 + } else { + tmp42 := checkDerefVar(var_glojure_DOT_core_send_DASH_off) + tmp43 := lang.Apply(tmp42, []any{v21, v29}) + _ = tmp43 + tmp44 := checkDerefVar(var_glojure_DOT_core_release_DASH_pending_DASH_sends) + tmp45 := lang.Apply(tmp44, nil) + _ = tmp45 + tmp46 := checkDerefVar(var_glojure_DOT_core_cons) + var tmp47 any + tmp48 := checkDerefVar(var_glojure_DOT_core_identical_QMARK_) + tmp49 := lang.Apply(tmp48, []any{v36, v16}) + if lang.IsTruthy(tmp49) { + } else { + tmp47 = v36 + } + tmp50 := lang.Apply(v31, nil) + tmp51 := lang.Apply(tmp46, []any{tmp47, tmp50}) + tmp37 = tmp51 + } + tmp33 = tmp37 + } // end let + return tmp33 + }) + tmp33 := lang.Apply(lang.NewLazySeq, []any{tmp32}) + return tmp33 + }) + v31 = tmp30 + _ = v31 + } + tmp31 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5453), kw_column, int(16), kw_end_DASH_line, int(5461), kw_end_DASH_column, int(73)) + tmp32, err := lang.WithMeta(tmp30, tmp31.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v33 any = tmp32 + _ = v33 + tmp34 := checkDerefVar(var_glojure_DOT_core_send_DASH_off) + tmp35 := lang.Apply(tmp34, []any{v21, v29}) + _ = tmp35 + tmp36 := lang.Apply(v33, nil) + tmp4 = tmp36 + } // end let + return tmp4 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_seque = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_seque.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // some-> + { + tmp0 := sym_some_DASH__GT_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_expr, sym__AMP_, sym_forms)), kw_doc, "When expr is not nil, threads it into the first form (via ->),\n and when that result is not nil, through the next etc", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(11), kw_line, int(7610), kw_end_DASH_line, int(7610))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "g" + tmp7 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp8 := lang.Apply(tmp7, nil) + var v9 any = tmp8 + _ = v9 + // let binding "steps" + tmp10 := checkDerefVar(var_glojure_DOT_core_map) + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v12 := args[0] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_if}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{sym_glojure_DOT_core_SLASH_nil_QMARK_}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v9}) + tmp24 := lang.Apply(tmp19, []any{tmp21, tmp23}) + tmp25 := lang.Apply(tmp18, []any{tmp24}) + tmp26 := lang.Apply(tmp17, []any{tmp25}) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{nil}) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := checkDerefVar(var_glojure_DOT_core_seq) + tmp31 := checkDerefVar(var_glojure_DOT_core_concat) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := lang.Apply(tmp32, []any{sym_glojure_DOT_core_SLASH__DASH__GT_}) + tmp34 := checkDerefVar(var_glojure_DOT_core_list) + tmp35 := lang.Apply(tmp34, []any{v9}) + tmp36 := checkDerefVar(var_glojure_DOT_core_list) + tmp37 := lang.Apply(tmp36, []any{v12}) + tmp38 := lang.Apply(tmp31, []any{tmp33, tmp35, tmp37}) + tmp39 := lang.Apply(tmp30, []any{tmp38}) + tmp40 := lang.Apply(tmp29, []any{tmp39}) + tmp41 := lang.Apply(tmp14, []any{tmp16, tmp26, tmp28, tmp40}) + tmp42 := lang.Apply(tmp13, []any{tmp41}) + return tmp42 + }) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7616), kw_column, int(20), kw_end_DASH_line, int(7616), kw_end_DASH_column, int(64)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp14 := lang.Apply(tmp10, []any{tmp13, v5}) + var v15 any = tmp14 + _ = v15 + tmp16 := checkDerefVar(var_glojure_DOT_core_seq) + tmp17 := checkDerefVar(var_glojure_DOT_core_concat) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{sym_glojure_DOT_core_SLASH_let}) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := checkDerefVar(var_glojure_DOT_core_apply) + tmp22 := checkDerefVar(var_glojure_DOT_core_vector) + tmp23 := checkDerefVar(var_glojure_DOT_core_seq) + tmp24 := checkDerefVar(var_glojure_DOT_core_concat) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := lang.Apply(tmp25, []any{v9}) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{v4}) + tmp29 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp30 := checkDerefVar(var_glojure_DOT_core_repeat) + tmp31 := lang.Apply(tmp30, []any{v9}) + tmp32 := checkDerefVar(var_glojure_DOT_core_butlast) + tmp33 := lang.Apply(tmp32, []any{v15}) + tmp34 := lang.Apply(tmp29, []any{tmp31, tmp33}) + tmp35 := lang.Apply(tmp24, []any{tmp26, tmp28, tmp34}) + tmp36 := lang.Apply(tmp23, []any{tmp35}) + tmp37 := lang.Apply(tmp21, []any{tmp22, tmp36}) + tmp38 := lang.Apply(tmp20, []any{tmp37}) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + var tmp40 any + tmp41 := checkDerefVar(var_glojure_DOT_core_empty_QMARK_) + tmp42 := lang.Apply(tmp41, []any{v15}) + if lang.IsTruthy(tmp42) { + tmp40 = v9 + } else { + tmp43 := checkDerefVar(var_glojure_DOT_core_last) + tmp44 := lang.Apply(tmp43, []any{v15}) + tmp40 = tmp44 + } + tmp45 := lang.Apply(tmp39, []any{tmp40}) + tmp46 := lang.Apply(tmp17, []any{tmp19, tmp38, tmp45}) + tmp47 := lang.Apply(tmp16, []any{tmp46}) + tmp6 = tmp47 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_some_DASH__GT_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_some_DASH__GT_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // some->> + { + tmp0 := sym_some_DASH__GT__GT_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_expr, sym__AMP_, sym_forms)), kw_doc, "When expr is not nil, threads it into the first form (via ->>),\n and when that result is not nil, through the next etc", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(7624), kw_end_DASH_line, int(7624))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "g" + tmp7 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp8 := lang.Apply(tmp7, nil) + var v9 any = tmp8 + _ = v9 + // let binding "steps" + tmp10 := checkDerefVar(var_glojure_DOT_core_map) + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v12 := args[0] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_if}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{sym_glojure_DOT_core_SLASH_nil_QMARK_}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v9}) + tmp24 := lang.Apply(tmp19, []any{tmp21, tmp23}) + tmp25 := lang.Apply(tmp18, []any{tmp24}) + tmp26 := lang.Apply(tmp17, []any{tmp25}) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{nil}) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := checkDerefVar(var_glojure_DOT_core_seq) + tmp31 := checkDerefVar(var_glojure_DOT_core_concat) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := lang.Apply(tmp32, []any{sym_glojure_DOT_core_SLASH__DASH__GT__GT_}) + tmp34 := checkDerefVar(var_glojure_DOT_core_list) + tmp35 := lang.Apply(tmp34, []any{v9}) + tmp36 := checkDerefVar(var_glojure_DOT_core_list) + tmp37 := lang.Apply(tmp36, []any{v12}) + tmp38 := lang.Apply(tmp31, []any{tmp33, tmp35, tmp37}) + tmp39 := lang.Apply(tmp30, []any{tmp38}) + tmp40 := lang.Apply(tmp29, []any{tmp39}) + tmp41 := lang.Apply(tmp14, []any{tmp16, tmp26, tmp28, tmp40}) + tmp42 := lang.Apply(tmp13, []any{tmp41}) + return tmp42 + }) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7630), kw_column, int(20), kw_end_DASH_line, int(7630), kw_end_DASH_column, int(65)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp14 := lang.Apply(tmp10, []any{tmp13, v5}) + var v15 any = tmp14 + _ = v15 + tmp16 := checkDerefVar(var_glojure_DOT_core_seq) + tmp17 := checkDerefVar(var_glojure_DOT_core_concat) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{sym_glojure_DOT_core_SLASH_let}) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := checkDerefVar(var_glojure_DOT_core_apply) + tmp22 := checkDerefVar(var_glojure_DOT_core_vector) + tmp23 := checkDerefVar(var_glojure_DOT_core_seq) + tmp24 := checkDerefVar(var_glojure_DOT_core_concat) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := lang.Apply(tmp25, []any{v9}) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{v4}) + tmp29 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp30 := checkDerefVar(var_glojure_DOT_core_repeat) + tmp31 := lang.Apply(tmp30, []any{v9}) + tmp32 := checkDerefVar(var_glojure_DOT_core_butlast) + tmp33 := lang.Apply(tmp32, []any{v15}) + tmp34 := lang.Apply(tmp29, []any{tmp31, tmp33}) + tmp35 := lang.Apply(tmp24, []any{tmp26, tmp28, tmp34}) + tmp36 := lang.Apply(tmp23, []any{tmp35}) + tmp37 := lang.Apply(tmp21, []any{tmp22, tmp36}) + tmp38 := lang.Apply(tmp20, []any{tmp37}) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + var tmp40 any + tmp41 := checkDerefVar(var_glojure_DOT_core_empty_QMARK_) + tmp42 := lang.Apply(tmp41, []any{v15}) + if lang.IsTruthy(tmp42) { + tmp40 = v9 + } else { + tmp43 := checkDerefVar(var_glojure_DOT_core_last) + tmp44 := lang.Apply(tmp43, []any{v15}) + tmp40 = tmp44 + } + tmp45 := lang.Apply(tmp39, []any{tmp40}) + tmp46 := lang.Apply(tmp17, []any{tmp19, tmp38, tmp45}) + tmp47 := lang.Apply(tmp16, []any{tmp46}) + tmp6 = tmp47 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_some_DASH__GT__GT_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_some_DASH__GT__GT_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // split-at + { + tmp0 := sym_split_DASH_at.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n, sym_coll)), kw_doc, "Returns a vector of [(take n coll) (drop n coll)]", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(2983), kw_end_DASH_line, int(2983))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_take) + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + tmp6 := checkDerefVar(var_glojure_DOT_core_drop) + tmp7 := lang.Apply(tmp6, []any{v2, v3}) + tmp8 := lang.NewVector(tmp5, tmp7) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2988), kw_column, int(5), kw_end_DASH_line, int(2988), kw_end_DASH_column, int(33)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp10 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_split_DASH_at = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_split_DASH_at.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // to-array-2d + { + tmp0 := sym_to_DASH_array_DASH_2d.WithMeta(lang.NewMap(kw_tag, "[[Ljava.lang.Object;", kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a (potentially-ragged) 2-dimensional array of Objects\n containing the contents of coll, which can be any Collection of any\n Collection.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(4002), kw_end_DASH_line, int(4002))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "ret" + tmp4 := checkDerefVar(var_glojure_DOT_core_make_DASH_array) + tmp5 := reflect.TypeOf((*reflect.Type)(nil)).Elem() + tmp6, _ := lang.FieldOrMethod(tmp5, "forName") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("forName is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{"[Ljava.lang.Object;"}) + tmp8, _ := lang.FieldOrMethod(v2, "size") + if reflect.TypeOf(tmp8).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("size is not a function"))) + } + tmp9 := lang.Apply(tmp8, []any{}) + tmp10 := lang.Apply(tmp4, []any{tmp7, tmp9}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + { // let + // let binding "i" + var v13 any = int64(0) + _ = v13 + // let binding "xs" + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := lang.Apply(tmp14, []any{v2}) + var v16 any = tmp15 + _ = v16 + for { + var tmp17 any + if lang.IsTruthy(v16) { + tmp18 := checkDerefVar(var_glojure_DOT_core_aset) + tmp19 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) + tmp20 := checkDerefVar(var_glojure_DOT_core_first) + tmp21 := lang.Apply(tmp20, []any{v16}) + tmp22 := lang.Apply(tmp19, []any{tmp21}) + tmp23 := lang.Apply(tmp18, []any{v11, v13, tmp22}) + _ = tmp23 + tmp25 := checkDerefVar(var_glojure_DOT_core_inc) + tmp26 := lang.Apply(tmp25, []any{v13}) + var tmp24 any = tmp26 + tmp28 := checkDerefVar(var_glojure_DOT_core_next) + tmp29 := lang.Apply(tmp28, []any{v16}) + var tmp27 any = tmp29 + v13 = tmp24 + v16 = tmp27 + continue + } else { + } + tmp12 = tmp17 + break + } + } // end let + _ = tmp12 + tmp3 = v11 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, "[[Ljava.lang.Object;")).(lang.FnFunc) + var_glojure_DOT_core_to_DASH_array_DASH_2d = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_to_DASH_array_DASH_2d.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // with-local-vars + { + tmp0 := sym_with_DASH_local_DASH_vars.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name_DASH_vals_DASH_vec, sym__AMP_, sym_body)), kw_doc, "varbinding=> symbol init-expr\n\n Executes the exprs in a context in which the symbols are bound to\n vars with per-thread bindings to the init-exprs. The symbols refer\n to the var objects themselves, and must be accessed with var-get and\n var-set", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(25), kw_column, int(11), kw_line, int(4339), kw_end_DASH_line, int(4339))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v4}) + if lang.IsTruthy(tmp8) { + } else { + tmp9 := checkDerefVar(var_glojure_DOT_core_str) + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp13 := checkDerefVar(var_glojure_DOT_core_meta) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(kw_line, []any{tmp14}) + tmp16 := lang.Apply(tmp9, []any{tmp11, " requires ", "a vector for its binding", " in ", tmp12, ":", tmp15}) + tmp17 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp16}) + panic(tmp17) + } + _ = tmp6 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_even_QMARK_) + tmp20 := checkDerefVar(var_glojure_DOT_core_count) + tmp21 := lang.Apply(tmp20, []any{v4}) + tmp22 := lang.Apply(tmp19, []any{tmp21}) + if lang.IsTruthy(tmp22) { + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp27 := checkDerefVar(var_glojure_DOT_core_meta) + tmp28 := lang.Apply(tmp27, []any{v2}) + tmp29 := lang.Apply(kw_line, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp25, " requires ", "an even number of forms in binding vector", " in ", tmp26, ":", tmp29}) + tmp31 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp31) + } + _ = tmp18 + tmp32 := checkDerefVar(var_glojure_DOT_core_seq) + tmp33 := checkDerefVar(var_glojure_DOT_core_concat) + tmp34 := checkDerefVar(var_glojure_DOT_core_list) + tmp35 := lang.Apply(tmp34, []any{sym_glojure_DOT_core_SLASH_let}) + tmp36 := checkDerefVar(var_glojure_DOT_core_list) + tmp37 := checkDerefVar(var_glojure_DOT_core_apply) + tmp38 := checkDerefVar(var_glojure_DOT_core_vector) + tmp39 := checkDerefVar(var_glojure_DOT_core_seq) + tmp40 := checkDerefVar(var_glojure_DOT_core_concat) + tmp41 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp42 := checkDerefVar(var_glojure_DOT_core_take_DASH_nth) + tmp43 := lang.Apply(tmp42, []any{int64(2), v4}) + tmp44 := checkDerefVar(var_glojure_DOT_core_repeat) + tmp45 := lang.Apply(tmp44, []any{lang.NewList(sym__DOT__DOT_, sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT__STAR_Var, sym_create, sym_setDynamic)}) + tmp46 := lang.Apply(tmp41, []any{tmp43, tmp45}) + tmp47 := lang.Apply(tmp40, []any{tmp46}) + tmp48 := lang.Apply(tmp39, []any{tmp47}) + tmp49 := lang.Apply(tmp37, []any{tmp38, tmp48}) + tmp50 := lang.Apply(tmp36, []any{tmp49}) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := checkDerefVar(var_glojure_DOT_core_seq) + tmp53 := checkDerefVar(var_glojure_DOT_core_concat) + tmp54 := checkDerefVar(var_glojure_DOT_core_list) + tmp55 := lang.Apply(tmp54, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_PushThreadBindings}) + tmp56 := checkDerefVar(var_glojure_DOT_core_list) + tmp57 := checkDerefVar(var_glojure_DOT_core_apply) + tmp58 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp59 := checkDerefVar(var_glojure_DOT_core_seq) + tmp60 := checkDerefVar(var_glojure_DOT_core_concat) + tmp61 := lang.Apply(tmp60, nil) + tmp62 := lang.Apply(tmp59, []any{tmp61}) + tmp63 := lang.Apply(tmp57, []any{tmp58, tmp62}) + tmp64 := lang.Apply(tmp56, []any{tmp63}) + tmp65 := lang.Apply(tmp53, []any{tmp55, tmp64}) + tmp66 := lang.Apply(tmp52, []any{tmp65}) + tmp67 := lang.Apply(tmp51, []any{tmp66}) + tmp68 := checkDerefVar(var_glojure_DOT_core_list) + tmp69 := checkDerefVar(var_glojure_DOT_core_seq) + tmp70 := checkDerefVar(var_glojure_DOT_core_concat) + tmp71 := checkDerefVar(var_glojure_DOT_core_list) + tmp72 := lang.Apply(tmp71, []any{sym_try}) + tmp73 := checkDerefVar(var_glojure_DOT_core_list) + tmp74 := checkDerefVar(var_glojure_DOT_core_seq) + tmp75 := checkDerefVar(var_glojure_DOT_core_concat) + tmp76 := checkDerefVar(var_glojure_DOT_core_list) + tmp77 := lang.Apply(tmp76, []any{sym_finally}) + tmp78 := checkDerefVar(var_glojure_DOT_core_list) + tmp79 := checkDerefVar(var_glojure_DOT_core_seq) + tmp80 := checkDerefVar(var_glojure_DOT_core_concat) + tmp81 := checkDerefVar(var_glojure_DOT_core_list) + tmp82 := lang.Apply(tmp81, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_PopThreadBindings}) + tmp83 := lang.Apply(tmp80, []any{tmp82}) + tmp84 := lang.Apply(tmp79, []any{tmp83}) + tmp85 := lang.Apply(tmp78, []any{tmp84}) + tmp86 := lang.Apply(tmp75, []any{tmp77, tmp85}) + tmp87 := lang.Apply(tmp74, []any{tmp86}) + tmp88 := lang.Apply(tmp73, []any{tmp87}) + tmp89 := lang.Apply(tmp70, []any{tmp72, v5, tmp88}) + tmp90 := lang.Apply(tmp69, []any{tmp89}) + tmp91 := lang.Apply(tmp68, []any{tmp90}) + tmp92 := lang.Apply(tmp33, []any{tmp35, tmp50, tmp67, tmp91}) + tmp93 := lang.Apply(tmp32, []any{tmp92}) + return tmp93 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_with_DASH_local_DASH_vars = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_with_DASH_local_DASH_vars.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // Throwable->map + { + tmp0 := sym_Throwable_DASH__GT_map.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_o)), kw_doc, "Constructs a data representation for a Throwable with keys:\n :cause - root cause message\n :phase - error phase\n :via - cause chain, with cause keys:\n :type - exception class symbol\n :message - exception message\n :data - ex-data\n :at - top stack element\n :trace - root cause stack elements", kw_file, "glojure/core_print.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(442), kw_end_DASH_line, int(442))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "base" + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v5 := args[0] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_merge) + tmp7 := checkDerefVar(var_glojure_DOT_core_symbol) + tmp8 := checkDerefVar(var_glojure_DOT_core_class) + tmp9 := lang.Apply(tmp8, []any{v5}) + tmp10, ok := lang.FieldOrMethod(tmp9, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp9, "Name"))) + } + var tmp11 any + switch reflect.TypeOf(tmp10).Kind() { + case reflect.Func: + tmp11 = lang.Apply(tmp10, nil) + default: + tmp11 = tmp10 + } + tmp12 := lang.Apply(tmp7, []any{tmp11}) + tmp13 := lang.NewMap(kw_type, tmp12) + tmp14 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(455), kw_column, int(23), kw_end_DASH_line, int(455), kw_end_DASH_column, int(56)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var tmp16 any + { // let + // let binding "temp__0__auto__" + tmp17, ok := lang.FieldOrMethod(v5, "getLocalizedMessage") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "getLocalizedMessage"))) + } + var tmp18 any + switch reflect.TypeOf(tmp17).Kind() { + case reflect.Func: + tmp18 = lang.Apply(tmp17, nil) + default: + tmp18 = tmp17 + } + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + var tmp21 any + { // let + // let binding "msg" + var v22 any = v19 + _ = v22 + tmp23 := lang.NewMap(kw_message, v22) + tmp24 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(457), kw_column, int(20), kw_end_DASH_line, int(457), kw_end_DASH_column, int(33)) + tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp21 = tmp25 + } // end let + tmp20 = tmp21 + } else { + } + tmp16 = tmp20 + } // end let + var tmp17 any + { // let + // let binding "temp__0__auto__" + tmp18 := checkDerefVar(var_glojure_DOT_core_ex_DASH_data) + tmp19 := lang.Apply(tmp18, []any{v5}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + var tmp22 any + { // let + // let binding "ed" + var v23 any = v20 + _ = v23 + tmp24 := lang.NewMap(kw_data, v23) + tmp25 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(459), kw_column, int(20), kw_end_DASH_line, int(459), kw_end_DASH_column, int(29)) + tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp22 = tmp26 + } // end let + tmp21 = tmp22 + } else { + } + tmp17 = tmp21 + } // end let + var tmp18 any + { // let + // let binding "st" + tmp19, ok := lang.FieldOrMethod(v5, "getStackTrace") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "getStackTrace"))) + } + var tmp20 any + switch reflect.TypeOf(tmp19).Kind() { + case reflect.Func: + tmp20 = lang.Apply(tmp19, nil) + default: + tmp20 = tmp19 + } + var v21 any = tmp20 + _ = v21 + var tmp22 any + tmp23 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp24 := checkDerefVar(var_glojure_DOT_core_alength) + tmp25 := lang.Apply(tmp24, []any{v21}) + tmp26 := lang.Apply(tmp23, []any{tmp25}) + if lang.IsTruthy(tmp26) { + tmp27 := checkDerefVar(var_glojure_DOT_core_StackTraceElement_DASH__GT_vec) + tmp28 := checkDerefVar(var_glojure_DOT_core_aget) + tmp29 := lang.Apply(tmp28, []any{v21, int64(0)}) + tmp30 := lang.Apply(tmp27, []any{tmp29}) + tmp31 := lang.NewMap(kw_at, tmp30) + tmp32 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(462), kw_column, int(22), kw_end_DASH_line, int(462), kw_end_DASH_column, int(63)) + tmp33, err := lang.WithMeta(tmp31, tmp32.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp22 = tmp33 + } else { + } + tmp18 = tmp22 + } // end let + tmp19 := lang.Apply(tmp6, []any{tmp15, tmp16, tmp17, tmp18}) + return tmp19 + }) + tmp5 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(454), kw_column, int(14), kw_end_DASH_line, int(462), kw_end_DASH_column, int(67)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v7 any = tmp6 + _ = v7 + // let binding "via" + var tmp8 any + { // let + // let binding "via" + tmp9 := lang.NewVector() + tmp10 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(463), kw_column, int(24), kw_end_DASH_line, int(463), kw_end_DASH_column, int(25)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v12 any = tmp11 + _ = v12 + // let binding "t" + var v13 any = v2 + _ = v13 + for { + var tmp14 any + if lang.IsTruthy(v13) { + tmp16 := checkDerefVar(var_glojure_DOT_core_conj) + tmp17 := lang.Apply(tmp16, []any{v12, v13}) + var tmp15 any = tmp17 + tmp19, ok := lang.FieldOrMethod(v13, "getCause") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v13, "getCause"))) + } + var tmp20 any + switch reflect.TypeOf(tmp19).Kind() { + case reflect.Func: + tmp20 = lang.Apply(tmp19, nil) + default: + tmp20 = tmp19 + } + var tmp18 any = tmp20 + v12 = tmp15 + v13 = tmp18 + continue + } else { + tmp14 = v12 + } + tmp8 = tmp14 + break + } + } // end let + var v9 any = tmp8 + _ = v9 + // let binding "root" + tmp10 := checkDerefVar(var_glojure_DOT_core_peek) + tmp11 := lang.Apply(tmp10, []any{v9}) + var v12 any = tmp11 + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_merge) + tmp14 := checkDerefVar(var_glojure_DOT_core_vec) + tmp15 := checkDerefVar(var_glojure_DOT_core_map) + tmp16 := lang.Apply(tmp15, []any{v7, v9}) + tmp17 := lang.Apply(tmp14, []any{tmp16}) + tmp18 := checkDerefVar(var_glojure_DOT_core_vec) + tmp19 := checkDerefVar(var_glojure_DOT_core_map) + tmp20 := checkDerefVar(var_glojure_DOT_core_StackTraceElement_DASH__GT_vec) + var tmp21 any + { // let + // let binding "or__0__auto__" + var v22 any = v12 + _ = v22 + var tmp23 any + if lang.IsTruthy(v22) { + tmp23 = v22 + } else { + tmp23 = v2 + } + tmp21 = tmp23 + } // end let + tmp22, ok := lang.FieldOrMethod(tmp21, "getStackTrace") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp21, "getStackTrace"))) + } + var tmp23 any + switch reflect.TypeOf(tmp22).Kind() { + case reflect.Func: + tmp23 = lang.Apply(tmp22, nil) + default: + tmp23 = tmp22 + } + tmp24 := lang.Apply(tmp19, []any{tmp20, tmp23}) + tmp25 := lang.Apply(tmp18, []any{tmp24}) + tmp26 := lang.NewMap(kw_via, tmp17, kw_trace, tmp25) + tmp27 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(468), kw_column, int(12), kw_end_DASH_line, int(470), kw_end_DASH_column, int(111)) + tmp28, err := lang.WithMeta(tmp26, tmp27.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var tmp29 any + { // let + // let binding "temp__0__auto__" + tmp30, ok := lang.FieldOrMethod(v12, "getLocalizedMessage") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v12, "getLocalizedMessage"))) + } + var tmp31 any + switch reflect.TypeOf(tmp30).Kind() { + case reflect.Func: + tmp31 = lang.Apply(tmp30, nil) + default: + tmp31 = tmp30 + } + var v32 any = tmp31 + _ = v32 + var tmp33 any + if lang.IsTruthy(v32) { + var tmp34 any + { // let + // let binding "root-msg" + var v35 any = v32 + _ = v35 + tmp36 := lang.NewMap(kw_cause, v35) + tmp37 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(472), kw_column, int(9), kw_end_DASH_line, int(472), kw_end_DASH_column, int(25)) + tmp38, err := lang.WithMeta(tmp36, tmp37.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp34 = tmp38 + } // end let + tmp33 = tmp34 + } else { + } + tmp29 = tmp33 + } // end let + var tmp30 any + { // let + // let binding "temp__0__auto__" + tmp31 := checkDerefVar(var_glojure_DOT_core_ex_DASH_data) + tmp32 := lang.Apply(tmp31, []any{v12}) + var v33 any = tmp32 + _ = v33 + var tmp34 any + if lang.IsTruthy(v33) { + var tmp35 any + { // let + // let binding "data" + var v36 any = v33 + _ = v36 + tmp37 := lang.NewMap(kw_data, v36) + tmp38 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(474), kw_column, int(9), kw_end_DASH_line, int(474), kw_end_DASH_column, int(20)) + tmp39, err := lang.WithMeta(tmp37, tmp38.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp35 = tmp39 + } // end let + tmp34 = tmp35 + } else { + } + tmp30 = tmp34 + } // end let + var tmp31 any + { // let + // let binding "temp__0__auto__" + tmp32 := checkDerefVar(var_glojure_DOT_core_ex_DASH_data) + tmp33 := lang.Apply(tmp32, []any{v2}) + tmp34 := lang.Apply(kw_glojure_DOT_error_SLASH_phase, []any{tmp33}) + var v35 any = tmp34 + _ = v35 + var tmp36 any + if lang.IsTruthy(v35) { + var tmp37 any + { // let + // let binding "phase" + var v38 any = v35 + _ = v38 + tmp39 := lang.NewMap(kw_phase, v38) + tmp40 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(476), kw_column, int(9), kw_end_DASH_line, int(476), kw_end_DASH_column, int(22)) + tmp41, err := lang.WithMeta(tmp39, tmp40.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp37 = tmp41 + } // end let + tmp36 = tmp37 + } else { + } + tmp31 = tmp36 + } // end let + tmp32 := lang.Apply(tmp13, []any{tmp28, tmp29, tmp30, tmp31}) + tmp3 = tmp32 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_Throwable_DASH__GT_map = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_Throwable_DASH__GT_map.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // as-> + { + tmp0 := sym_as_DASH__GT_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_expr, sym_name, sym__AMP_, sym_forms)), kw_doc, "Binds name to expr, evaluates the first form in the lexical context\n of that binding, then binds name to that result, repeating for each\n successive form, returning the result of the last form.", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(11), kw_line, int(7598), kw_end_DASH_line, int(7598))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var v6 any = lang.NewList(args[4:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_core_SLASH_let}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_apply) + tmp13 := checkDerefVar(var_glojure_DOT_core_vector) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v5}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp21 := checkDerefVar(var_glojure_DOT_core_repeat) + tmp22 := lang.Apply(tmp21, []any{v5}) + tmp23 := checkDerefVar(var_glojure_DOT_core_butlast) + tmp24 := lang.Apply(tmp23, []any{v6}) + tmp25 := lang.Apply(tmp20, []any{tmp22, tmp24}) + tmp26 := lang.Apply(tmp15, []any{tmp17, tmp19, tmp25}) + tmp27 := lang.Apply(tmp14, []any{tmp26}) + tmp28 := lang.Apply(tmp12, []any{tmp13, tmp27}) + tmp29 := lang.Apply(tmp11, []any{tmp28}) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + var tmp31 any + tmp32 := checkDerefVar(var_glojure_DOT_core_empty_QMARK_) + tmp33 := lang.Apply(tmp32, []any{v6}) + if lang.IsTruthy(tmp33) { + tmp31 = v5 + } else { + tmp34 := checkDerefVar(var_glojure_DOT_core_last) + tmp35 := lang.Apply(tmp34, []any{v6}) + tmp31 = tmp35 + } + tmp36 := lang.Apply(tmp30, []any{tmp31}) + tmp37 := lang.Apply(tmp8, []any{tmp10, tmp29, tmp36}) + tmp38 := lang.Apply(tmp7, []any{tmp37}) + return tmp38 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_as_DASH__GT_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_as_DASH__GT_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // await + { + tmp0 := sym_await.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_agents)), kw_doc, "Blocks the current thread (indefinitely!) until all actions\n dispatched thus far, from this thread or agent, to the agent(s) have\n occurred. Will block on failed agents. Will never return if\n a failed agent is restarted with :clear-actions true or shutdown-agents was called.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3267), kw_end_DASH_line, int(3267))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + var tmp3 any + tmp4 := lang.Apply(nil, nil) + if lang.IsTruthy(tmp4) { + panic("unimplemented: new with non-constant class type") + } else { + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_agent_STAR_) + if lang.IsTruthy(tmp6) { + tmp7 := lang.Apply(errors5.New, []any{"Can't await in agent action"}) + panic(tmp7) + } else { + } + _ = tmp5 + var tmp8 any + { // let + // let binding "latch" + var v9 any = "unimplemented: new with non-constant class type" + _ = v9 + // let binding "count-down" + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v11 := args[0] + _ = v11 + tmp12, _ := lang.FieldOrMethod(v9, "countDown") + if reflect.TypeOf(tmp12).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("countDown is not a function"))) + } + tmp13 := lang.Apply(tmp12, []any{}) + _ = tmp13 + return v11 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3279), kw_column, int(22), kw_end_DASH_line, int(3279), kw_end_DASH_column, int(61)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v13 any = tmp12 + _ = v13 + var tmp14 any + { // let + // let binding "seq_692" + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := lang.Apply(tmp15, []any{v2}) + var v17 any = tmp16 + _ = v17 + // let binding "chunk_693" + var v18 any = nil + _ = v18 + // let binding "count_694" + var v19 any = int64(0) + _ = v19 + // let binding "i_695" + var v20 any = int64(0) + _ = v20 + for { + var tmp21 any + tmp22 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp23 := lang.Apply(tmp22, []any{v20, v19}) + if lang.IsTruthy(tmp23) { + var tmp24 any + { // let + // let binding "agent" + tmp25, _ := lang.FieldOrMethod(v18, "nth") + if reflect.TypeOf(tmp25).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp26 := lang.Apply(tmp25, []any{v20}) + var v27 any = tmp26 + _ = v27 + tmp28 := checkDerefVar(var_glojure_DOT_core_send) + tmp29 := lang.Apply(tmp28, []any{v27, v13}) + _ = tmp29 + var tmp30 any = v17 + var tmp31 any = v18 + var tmp32 any = v19 + tmp34 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp35 := lang.Apply(tmp34, []any{v20}) + var tmp33 any = tmp35 + v17 = tmp30 + v18 = tmp31 + v19 = tmp32 + v20 = tmp33 + continue + } // end let + tmp21 = tmp24 + } else { + var tmp25 any + { // let + // let binding "temp__0__auto__" + tmp26 := checkDerefVar(var_glojure_DOT_core_seq) + tmp27 := lang.Apply(tmp26, []any{v17}) + var v28 any = tmp27 + _ = v28 + var tmp29 any + if lang.IsTruthy(v28) { + var tmp30 any + { // let + // let binding "seq_692" + var v31 any = v28 + _ = v31 + var tmp32 any + tmp33 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp34 := lang.Apply(tmp33, []any{v31}) + if lang.IsTruthy(tmp34) { + var tmp35 any + { // let + // let binding "c__0__auto__" + tmp36 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp37 := lang.Apply(tmp36, []any{v31}) + var v38 any = tmp37 + _ = v38 + tmp40 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp41 := lang.Apply(tmp40, []any{v31}) + var tmp39 any = tmp41 + var tmp42 any = v38 + tmp44 := checkDerefVar(var_glojure_DOT_core_int) + tmp45 := checkDerefVar(var_glojure_DOT_core_count) + tmp46 := lang.Apply(tmp45, []any{v38}) + tmp47 := lang.Apply(tmp44, []any{tmp46}) + var tmp43 any = tmp47 + tmp49 := checkDerefVar(var_glojure_DOT_core_int) + tmp50 := lang.Apply(tmp49, []any{int64(0)}) + var tmp48 any = tmp50 + v17 = tmp39 + v18 = tmp42 + v19 = tmp43 + v20 = tmp48 + continue + } // end let + tmp32 = tmp35 + } else { + var tmp36 any + { // let + // let binding "agent" + tmp37 := checkDerefVar(var_glojure_DOT_core_first) + tmp38 := lang.Apply(tmp37, []any{v31}) + var v39 any = tmp38 + _ = v39 + tmp40 := checkDerefVar(var_glojure_DOT_core_send) + tmp41 := lang.Apply(tmp40, []any{v39, v13}) + _ = tmp41 + tmp43 := checkDerefVar(var_glojure_DOT_core_next) + tmp44 := lang.Apply(tmp43, []any{v31}) + var tmp42 any = tmp44 + var tmp45 any = nil + var tmp46 any = int64(0) + var tmp47 any = int64(0) + v17 = tmp42 + v18 = tmp45 + v19 = tmp46 + v20 = tmp47 + continue + } // end let + tmp32 = tmp36 + } + tmp30 = tmp32 + } // end let + tmp29 = tmp30 + } else { + } + tmp25 = tmp29 + } // end let + tmp21 = tmp25 + } + tmp14 = tmp21 + break + } + } // end let + _ = tmp14 + tmp15, _ := lang.FieldOrMethod(v9, "await") + if reflect.TypeOf(tmp15).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) + } + tmp16 := lang.Apply(tmp15, []any{}) + tmp8 = tmp16 + } // end let + tmp3 = tmp8 + } + return tmp3 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_await = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_await.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // await1 + { + tmp0 := sym_await1.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(3284), kw_column, int(7), kw_end_DASH_line, int(3284), kw_end_DASH_column, int(21), kw_arglists, lang.NewList(lang.NewVector(sym_a)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp5, ok := lang.FieldOrMethod(v2, "getQueueCount") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getQueueCount"))) + } + var tmp6 any + switch reflect.TypeOf(tmp5).Kind() { + case reflect.Func: + tmp6 = lang.Apply(tmp5, nil) + default: + tmp6 = tmp5 + } + tmp7 := lang.Apply(tmp4, []any{tmp6}) + if lang.IsTruthy(tmp7) { + tmp8 := checkDerefVar(var_glojure_DOT_core_await) + tmp9 := lang.Apply(tmp8, []any{v2}) + tmp3 = tmp9 + } else { + } + _ = tmp3 + return v2 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_await1 = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_await1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // await-for + { + tmp0 := sym_await_DASH_for.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_timeout_DASH_ms, sym__AMP_, sym_agents)), kw_doc, "Blocks the current thread until all actions dispatched thus\n far (from this thread or agent) to the agents have occurred, or the\n timeout (in milliseconds) has elapsed. Returns logical false if\n returning due to timeout, logical true otherwise.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(3289), kw_end_DASH_line, int(3289))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + var tmp4 any + tmp5 := lang.Apply(nil, nil) + if lang.IsTruthy(tmp5) { + panic("unimplemented: new with non-constant class type") + } else { + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_agent_STAR_) + if lang.IsTruthy(tmp7) { + tmp8 := lang.Apply(errors5.New, []any{"Can't await in agent action"}) + panic(tmp8) + } else { + } + _ = tmp6 + var tmp9 any + { // let + // let binding "latch" + var v10 any = "unimplemented: new with non-constant class type" + _ = v10 + // let binding "count-down" + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v12 := args[0] + _ = v12 + tmp13, _ := lang.FieldOrMethod(v10, "countDown") + if reflect.TypeOf(tmp13).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("countDown is not a function"))) + } + tmp14 := lang.Apply(tmp13, []any{}) + _ = tmp14 + return v12 + }) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3301), kw_column, int(23), kw_end_DASH_line, int(3301), kw_end_DASH_column, int(62)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v14 any = tmp13 + _ = v14 + var tmp15 any + { // let + // let binding "seq_696" + tmp16 := checkDerefVar(var_glojure_DOT_core_seq) + tmp17 := lang.Apply(tmp16, []any{v3}) + var v18 any = tmp17 + _ = v18 + // let binding "chunk_697" + var v19 any = nil + _ = v19 + // let binding "count_698" + var v20 any = int64(0) + _ = v20 + // let binding "i_699" + var v21 any = int64(0) + _ = v21 + for { + var tmp22 any + tmp23 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp24 := lang.Apply(tmp23, []any{v21, v20}) + if lang.IsTruthy(tmp24) { + var tmp25 any + { // let + // let binding "agent" + tmp26, _ := lang.FieldOrMethod(v19, "nth") + if reflect.TypeOf(tmp26).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp27 := lang.Apply(tmp26, []any{v21}) + var v28 any = tmp27 + _ = v28 + tmp29 := checkDerefVar(var_glojure_DOT_core_send) + tmp30 := lang.Apply(tmp29, []any{v28, v14}) + _ = tmp30 + var tmp31 any = v18 + var tmp32 any = v19 + var tmp33 any = v20 + tmp35 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp36 := lang.Apply(tmp35, []any{v21}) + var tmp34 any = tmp36 + v18 = tmp31 + v19 = tmp32 + v20 = tmp33 + v21 = tmp34 + continue + } // end let + tmp22 = tmp25 + } else { + var tmp26 any + { // let + // let binding "temp__0__auto__" + tmp27 := checkDerefVar(var_glojure_DOT_core_seq) + tmp28 := lang.Apply(tmp27, []any{v18}) + var v29 any = tmp28 + _ = v29 + var tmp30 any + if lang.IsTruthy(v29) { + var tmp31 any + { // let + // let binding "seq_696" + var v32 any = v29 + _ = v32 + var tmp33 any + tmp34 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp35 := lang.Apply(tmp34, []any{v32}) + if lang.IsTruthy(tmp35) { + var tmp36 any + { // let + // let binding "c__0__auto__" + tmp37 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp38 := lang.Apply(tmp37, []any{v32}) + var v39 any = tmp38 + _ = v39 + tmp41 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp42 := lang.Apply(tmp41, []any{v32}) + var tmp40 any = tmp42 + var tmp43 any = v39 + tmp45 := checkDerefVar(var_glojure_DOT_core_int) + tmp46 := checkDerefVar(var_glojure_DOT_core_count) + tmp47 := lang.Apply(tmp46, []any{v39}) + tmp48 := lang.Apply(tmp45, []any{tmp47}) + var tmp44 any = tmp48 + tmp50 := checkDerefVar(var_glojure_DOT_core_int) + tmp51 := lang.Apply(tmp50, []any{int64(0)}) + var tmp49 any = tmp51 + v18 = tmp40 + v19 = tmp43 + v20 = tmp44 + v21 = tmp49 + continue + } // end let + tmp33 = tmp36 + } else { + var tmp37 any + { // let + // let binding "agent" + tmp38 := checkDerefVar(var_glojure_DOT_core_first) + tmp39 := lang.Apply(tmp38, []any{v32}) + var v40 any = tmp39 + _ = v40 + tmp41 := checkDerefVar(var_glojure_DOT_core_send) + tmp42 := lang.Apply(tmp41, []any{v40, v14}) + _ = tmp42 + tmp44 := checkDerefVar(var_glojure_DOT_core_next) + tmp45 := lang.Apply(tmp44, []any{v32}) + var tmp43 any = tmp45 + var tmp46 any = nil + var tmp47 any = int64(0) + var tmp48 any = int64(0) + v18 = tmp43 + v19 = tmp46 + v20 = tmp47 + v21 = tmp48 + continue + } // end let + tmp33 = tmp37 + } + tmp31 = tmp33 + } // end let + tmp30 = tmp31 + } else { + } + tmp26 = tmp30 + } // end let + tmp22 = tmp26 + } + tmp15 = tmp22 + break + } + } // end let + _ = tmp15 + tmp16, ok := lang.FieldOrMethod(nil, "MILLISECONDS") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "MILLISECONDS"))) + } + var tmp17 any + switch reflect.TypeOf(tmp16).Kind() { + case reflect.Func: + tmp17 = lang.Apply(tmp16, nil) + default: + tmp17 = tmp16 + } + tmp18, _ := lang.FieldOrMethod(v10, "await") + if reflect.TypeOf(tmp18).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) + } + tmp19 := lang.Apply(tmp18, []any{v2, tmp17}) + tmp9 = tmp19 + } // end let + tmp4 = tmp9 + } + return tmp4 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_await_DASH_for = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_await_DASH_for.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // check-cyclic-dependency + { + tmp0 := sym_check_DASH_cyclic_DASH_dependency.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_path)), kw_doc, "Detects and rejects non-trivial cyclic load dependencies. The\n exception message shows the dependency chain with the cycle\n highlighted. Ignores the trivial case of a file attempting to load\n itself because that can occur when a gen-class'd class loads its\n implementation.", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(30), kw_column, int(8), kw_line, int(5974), kw_end_DASH_line, int(5974), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_some) + tmp5 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{v2})) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5981), kw_column, int(15), kw_end_DASH_line, int(5981), kw_end_DASH_column, int(21)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp8 := checkDerefVar(var_glojure_DOT_core_rest) + tmp9 := checkDerefVar(var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_) + tmp10 := lang.Apply(tmp8, []any{tmp9}) + tmp11 := lang.Apply(tmp4, []any{tmp7, tmp10}) + if lang.IsTruthy(tmp11) { + var tmp12 any + { // let + // let binding "pending" + tmp13 := checkDerefVar(var_glojure_DOT_core_map) + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v15 := args[0] + _ = v15 + var tmp16 any + tmp17 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp18 := lang.Apply(tmp17, []any{v15, v2}) + if lang.IsTruthy(tmp18) { + tmp19 := checkDerefVar(var_glojure_DOT_core_str) + tmp20 := lang.Apply(tmp19, []any{"[ ", v15, " ]"}) + tmp16 = tmp20 + } else { + tmp16 = v15 + } + return tmp16 + }) + tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5982), kw_column, int(24), kw_end_DASH_line, int(5982), kw_end_DASH_column, int(59)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp17 := checkDerefVar(var_glojure_DOT_core_cons) + tmp18 := checkDerefVar(var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_) + tmp19 := lang.Apply(tmp17, []any{v2, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp16, tmp19}) + var v21 any = tmp20 + _ = v21 + // let binding "chain" + tmp22 := checkDerefVar(var_glojure_DOT_core_apply) + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_interpose) + tmp25 := lang.Apply(tmp24, []any{"->", v21}) + tmp26 := lang.Apply(tmp22, []any{tmp23, tmp25}) + var v27 any = tmp26 + _ = v27 + tmp28 := checkDerefVar(var_glojure_DOT_core_throw_DASH_if) + tmp29 := lang.Apply(tmp28, []any{true, "Cyclic load dependency: %s", v27}) + tmp12 = tmp29 + } // end let + tmp3 = tmp12 + } else { + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_check_DASH_cyclic_DASH_dependency = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_check_DASH_cyclic_DASH_dependency.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // cond-> + { + tmp0 := sym_cond_DASH__GT_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_expr, sym__AMP_, sym_clauses)), kw_doc, "Takes an expression and a set of test/form pairs. Threads expr (via ->)\n through each form for which the corresponding test\n expression is true. Note that, unlike cond branching, cond-> threading does\n not short circuit after the first true test expression.", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(11), kw_line, int(7564), kw_end_DASH_line, int(7564))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "g" + tmp7 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp8 := lang.Apply(tmp7, nil) + var v9 any = tmp8 + _ = v9 + // let binding "steps" + tmp10 := checkDerefVar(var_glojure_DOT_core_map) + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v12 := args[0] + _ = v12 + var tmp13 any + { // let + // let binding "vec__675" + var v14 any = v12 + _ = v14 + // let binding "test" + tmp15 := checkDerefVar(var_glojure_DOT_core_nth) + tmp16 := lang.Apply(tmp15, []any{v14, int64(0), nil}) + var v17 any = tmp16 + _ = v17 + // let binding "step" + tmp18 := checkDerefVar(var_glojure_DOT_core_nth) + tmp19 := lang.Apply(tmp18, []any{v14, int64(1), nil}) + var v20 any = tmp19 + _ = v20 + tmp21 := checkDerefVar(var_glojure_DOT_core_seq) + tmp22 := checkDerefVar(var_glojure_DOT_core_concat) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := lang.Apply(tmp23, []any{sym_if}) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := lang.Apply(tmp25, []any{v17}) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := checkDerefVar(var_glojure_DOT_core_seq) + tmp29 := checkDerefVar(var_glojure_DOT_core_concat) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := lang.Apply(tmp30, []any{sym_glojure_DOT_core_SLASH__DASH__GT_}) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := lang.Apply(tmp32, []any{v9}) + tmp34 := checkDerefVar(var_glojure_DOT_core_list) + tmp35 := lang.Apply(tmp34, []any{v20}) + tmp36 := lang.Apply(tmp29, []any{tmp31, tmp33, tmp35}) + tmp37 := lang.Apply(tmp28, []any{tmp36}) + tmp38 := lang.Apply(tmp27, []any{tmp37}) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := lang.Apply(tmp39, []any{v9}) + tmp41 := lang.Apply(tmp22, []any{tmp24, tmp26, tmp38, tmp40}) + tmp42 := lang.Apply(tmp21, []any{tmp41}) + tmp13 = tmp42 + } // end let + return tmp13 + }) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7573), kw_column, int(20), kw_end_DASH_line, int(7573), kw_end_DASH_column, int(66)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp14 := checkDerefVar(var_glojure_DOT_core_partition) + tmp15 := lang.Apply(tmp14, []any{int64(2), v5}) + tmp16 := lang.Apply(tmp10, []any{tmp13, tmp15}) + var v17 any = tmp16 + _ = v17 + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{sym_glojure_DOT_core_SLASH_let}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := checkDerefVar(var_glojure_DOT_core_apply) + tmp24 := checkDerefVar(var_glojure_DOT_core_vector) + tmp25 := checkDerefVar(var_glojure_DOT_core_seq) + tmp26 := checkDerefVar(var_glojure_DOT_core_concat) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{v9}) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{v4}) + tmp31 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp32 := checkDerefVar(var_glojure_DOT_core_repeat) + tmp33 := lang.Apply(tmp32, []any{v9}) + tmp34 := checkDerefVar(var_glojure_DOT_core_butlast) + tmp35 := lang.Apply(tmp34, []any{v17}) + tmp36 := lang.Apply(tmp31, []any{tmp33, tmp35}) + tmp37 := lang.Apply(tmp26, []any{tmp28, tmp30, tmp36}) + tmp38 := lang.Apply(tmp25, []any{tmp37}) + tmp39 := lang.Apply(tmp23, []any{tmp24, tmp38}) + tmp40 := lang.Apply(tmp22, []any{tmp39}) + tmp41 := checkDerefVar(var_glojure_DOT_core_list) + var tmp42 any + tmp43 := checkDerefVar(var_glojure_DOT_core_empty_QMARK_) + tmp44 := lang.Apply(tmp43, []any{v17}) + if lang.IsTruthy(tmp44) { + tmp42 = v9 + } else { + tmp45 := checkDerefVar(var_glojure_DOT_core_last) + tmp46 := lang.Apply(tmp45, []any{v17}) + tmp42 = tmp46 + } + tmp47 := lang.Apply(tmp41, []any{tmp42}) + tmp48 := lang.Apply(tmp19, []any{tmp21, tmp40, tmp47}) + tmp49 := lang.Apply(tmp18, []any{tmp48}) + tmp6 = tmp49 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_cond_DASH__GT_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_cond_DASH__GT_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // cond->> + { + tmp0 := sym_cond_DASH__GT__GT_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_expr, sym__AMP_, sym_clauses)), kw_doc, "Takes an expression and a set of test/form pairs. Threads expr (via ->>)\n through each form for which the corresponding test expression\n is true. Note that, unlike cond branching, cond->> threading does not short circuit\n after the first true test expression.", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(7581), kw_end_DASH_line, int(7581))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "g" + tmp7 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp8 := lang.Apply(tmp7, nil) + var v9 any = tmp8 + _ = v9 + // let binding "steps" + tmp10 := checkDerefVar(var_glojure_DOT_core_map) + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v12 := args[0] + _ = v12 + var tmp13 any + { // let + // let binding "vec__679" + var v14 any = v12 + _ = v14 + // let binding "test" + tmp15 := checkDerefVar(var_glojure_DOT_core_nth) + tmp16 := lang.Apply(tmp15, []any{v14, int64(0), nil}) + var v17 any = tmp16 + _ = v17 + // let binding "step" + tmp18 := checkDerefVar(var_glojure_DOT_core_nth) + tmp19 := lang.Apply(tmp18, []any{v14, int64(1), nil}) + var v20 any = tmp19 + _ = v20 + tmp21 := checkDerefVar(var_glojure_DOT_core_seq) + tmp22 := checkDerefVar(var_glojure_DOT_core_concat) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := lang.Apply(tmp23, []any{sym_if}) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := lang.Apply(tmp25, []any{v17}) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := checkDerefVar(var_glojure_DOT_core_seq) + tmp29 := checkDerefVar(var_glojure_DOT_core_concat) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := lang.Apply(tmp30, []any{sym_glojure_DOT_core_SLASH__DASH__GT__GT_}) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := lang.Apply(tmp32, []any{v9}) + tmp34 := checkDerefVar(var_glojure_DOT_core_list) + tmp35 := lang.Apply(tmp34, []any{v20}) + tmp36 := lang.Apply(tmp29, []any{tmp31, tmp33, tmp35}) + tmp37 := lang.Apply(tmp28, []any{tmp36}) + tmp38 := lang.Apply(tmp27, []any{tmp37}) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := lang.Apply(tmp39, []any{v9}) + tmp41 := lang.Apply(tmp22, []any{tmp24, tmp26, tmp38, tmp40}) + tmp42 := lang.Apply(tmp21, []any{tmp41}) + tmp13 = tmp42 + } // end let + return tmp13 + }) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7590), kw_column, int(20), kw_end_DASH_line, int(7590), kw_end_DASH_column, int(67)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp14 := checkDerefVar(var_glojure_DOT_core_partition) + tmp15 := lang.Apply(tmp14, []any{int64(2), v5}) + tmp16 := lang.Apply(tmp10, []any{tmp13, tmp15}) + var v17 any = tmp16 + _ = v17 + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{sym_glojure_DOT_core_SLASH_let}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := checkDerefVar(var_glojure_DOT_core_apply) + tmp24 := checkDerefVar(var_glojure_DOT_core_vector) + tmp25 := checkDerefVar(var_glojure_DOT_core_seq) + tmp26 := checkDerefVar(var_glojure_DOT_core_concat) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{v9}) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{v4}) + tmp31 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp32 := checkDerefVar(var_glojure_DOT_core_repeat) + tmp33 := lang.Apply(tmp32, []any{v9}) + tmp34 := checkDerefVar(var_glojure_DOT_core_butlast) + tmp35 := lang.Apply(tmp34, []any{v17}) + tmp36 := lang.Apply(tmp31, []any{tmp33, tmp35}) + tmp37 := lang.Apply(tmp26, []any{tmp28, tmp30, tmp36}) + tmp38 := lang.Apply(tmp25, []any{tmp37}) + tmp39 := lang.Apply(tmp23, []any{tmp24, tmp38}) + tmp40 := lang.Apply(tmp22, []any{tmp39}) + tmp41 := checkDerefVar(var_glojure_DOT_core_list) + var tmp42 any + tmp43 := checkDerefVar(var_glojure_DOT_core_empty_QMARK_) + tmp44 := lang.Apply(tmp43, []any{v17}) + if lang.IsTruthy(tmp44) { + tmp42 = v9 + } else { + tmp45 := checkDerefVar(var_glojure_DOT_core_last) + tmp46 := lang.Apply(tmp45, []any{v17}) + tmp42 = tmp46 + } + tmp47 := lang.Apply(tmp41, []any{tmp42}) + tmp48 := lang.Apply(tmp19, []any{tmp21, tmp40, tmp47}) + tmp49 := lang.Apply(tmp18, []any{tmp48}) + tmp6 = tmp49 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_cond_DASH__GT__GT_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_cond_DASH__GT__GT_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // condp + { + tmp0 := sym_condp.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_pred, sym_expr, sym__AMP_, sym_clauses)), kw_doc, "Takes a binary predicate, an expression, and a set of clauses.\n Each clause can take the form of either:\n\n test-expr result-expr\n\n test-expr :>> result-fn\n\n Note :>> is an ordinary keyword.\n\n For each clause, (pred test-expr expr) is evaluated. If it returns\n logical true, the clause is a match. If a binary clause matches, the\n result-expr is returned, if a ternary clause matches, its result-fn,\n which must be a unary function, is called with the result of the\n predicate as its argument, the result of that call being the return\n value of condp. A single default expression can follow the clauses,\n and its value will be returned if no clause matches. If no default\n expression is provided and no clause matches, an\n IllegalArgumentException is thrown.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(11), kw_line, int(6353), kw_end_DASH_line, int(6353))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var v6 any = lang.NewList(args[4:]...) + _ = v6 + var tmp7 any + { // let + // let binding "gpred" + tmp8 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp9 := lang.Apply(tmp8, []any{"pred__"}) + var v10 any = tmp9 + _ = v10 + // let binding "gexpr" + tmp11 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp12 := lang.Apply(tmp11, []any{"expr__"}) + var v13 any = tmp12 + _ = v13 + // let binding "emit" + var tmp14 lang.FnFunc + { // function emit + var v15 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v16 := args[0] + _ = v16 + v17 := args[1] + _ = v17 + v18 := args[2] + _ = v18 + var tmp19 any + { // let + // let binding "vec__835" + tmp20 := checkDerefVar(var_glojure_DOT_core_split_DASH_at) + var tmp21 any + tmp22 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp23 := checkDerefVar(var_glojure_DOT_core_second) + tmp24 := lang.Apply(tmp23, []any{v18}) + tmp25 := lang.Apply(tmp22, []any{kw__GT__GT_, tmp24}) + if lang.IsTruthy(tmp25) { + tmp21 = int64(3) + } else { + tmp21 = int64(2) + } + tmp26 := lang.Apply(tmp20, []any{tmp21, v18}) + var v27 any = tmp26 + _ = v27 + // let binding "vec__838" + tmp28 := checkDerefVar(var_glojure_DOT_core_nth) + tmp29 := lang.Apply(tmp28, []any{v27, int64(0), nil}) + var v30 any = tmp29 + _ = v30 + // let binding "a" + tmp31 := checkDerefVar(var_glojure_DOT_core_nth) + tmp32 := lang.Apply(tmp31, []any{v30, int64(0), nil}) + var v33 any = tmp32 + _ = v33 + // let binding "b" + tmp34 := checkDerefVar(var_glojure_DOT_core_nth) + tmp35 := lang.Apply(tmp34, []any{v30, int64(1), nil}) + var v36 any = tmp35 + _ = v36 + // let binding "c" + tmp37 := checkDerefVar(var_glojure_DOT_core_nth) + tmp38 := lang.Apply(tmp37, []any{v30, int64(2), nil}) + var v39 any = tmp38 + _ = v39 + // let binding "clause" + var v40 any = v30 + _ = v40 + // let binding "more" + tmp41 := checkDerefVar(var_glojure_DOT_core_nth) + tmp42 := lang.Apply(tmp41, []any{v27, int64(1), nil}) + var v43 any = tmp42 + _ = v43 + // let binding "n" + tmp44 := checkDerefVar(var_glojure_DOT_core_count) + tmp45 := lang.Apply(tmp44, []any{v40}) + var v46 any = tmp45 + _ = v46 + var tmp47 any + tmp48 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp49 := lang.Apply(tmp48, []any{int64(0), v46}) + if lang.IsTruthy(tmp49) { + tmp50 := checkDerefVar(var_glojure_DOT_core_seq) + tmp51 := checkDerefVar(var_glojure_DOT_core_concat) + tmp52 := checkDerefVar(var_glojure_DOT_core_list) + tmp53 := lang.Apply(tmp52, []any{sym_throw}) + tmp54 := checkDerefVar(var_glojure_DOT_core_list) + tmp55 := checkDerefVar(var_glojure_DOT_core_seq) + tmp56 := checkDerefVar(var_glojure_DOT_core_concat) + tmp57 := checkDerefVar(var_glojure_DOT_core_list) + tmp58 := lang.Apply(tmp57, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_NewIllegalArgumentError}) + tmp59 := checkDerefVar(var_glojure_DOT_core_list) + tmp60 := checkDerefVar(var_glojure_DOT_core_seq) + tmp61 := checkDerefVar(var_glojure_DOT_core_concat) + tmp62 := checkDerefVar(var_glojure_DOT_core_list) + tmp63 := lang.Apply(tmp62, []any{sym_glojure_DOT_core_SLASH_str}) + tmp64 := checkDerefVar(var_glojure_DOT_core_list) + tmp65 := lang.Apply(tmp64, []any{"No matching clause: "}) + tmp66 := checkDerefVar(var_glojure_DOT_core_list) + tmp67 := lang.Apply(tmp66, []any{v17}) + tmp68 := lang.Apply(tmp61, []any{tmp63, tmp65, tmp67}) + tmp69 := lang.Apply(tmp60, []any{tmp68}) + tmp70 := lang.Apply(tmp59, []any{tmp69}) + tmp71 := lang.Apply(tmp56, []any{tmp58, tmp70}) + tmp72 := lang.Apply(tmp55, []any{tmp71}) + tmp73 := lang.Apply(tmp54, []any{tmp72}) + tmp74 := lang.Apply(tmp51, []any{tmp53, tmp73}) + tmp75 := lang.Apply(tmp50, []any{tmp74}) + tmp47 = tmp75 + } else { + var tmp76 any + tmp77 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp78 := lang.Apply(tmp77, []any{int64(1), v46}) + if lang.IsTruthy(tmp78) { + tmp76 = v33 + } else { + var tmp79 any + tmp80 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp81 := lang.Apply(tmp80, []any{int64(2), v46}) + if lang.IsTruthy(tmp81) { + tmp82 := checkDerefVar(var_glojure_DOT_core_seq) + tmp83 := checkDerefVar(var_glojure_DOT_core_concat) + tmp84 := checkDerefVar(var_glojure_DOT_core_list) + tmp85 := lang.Apply(tmp84, []any{sym_if}) + tmp86 := checkDerefVar(var_glojure_DOT_core_list) + tmp87 := checkDerefVar(var_glojure_DOT_core_seq) + tmp88 := checkDerefVar(var_glojure_DOT_core_concat) + tmp89 := checkDerefVar(var_glojure_DOT_core_list) + tmp90 := lang.Apply(tmp89, []any{v16}) + tmp91 := checkDerefVar(var_glojure_DOT_core_list) + tmp92 := lang.Apply(tmp91, []any{v33}) + tmp93 := checkDerefVar(var_glojure_DOT_core_list) + tmp94 := lang.Apply(tmp93, []any{v17}) + tmp95 := lang.Apply(tmp88, []any{tmp90, tmp92, tmp94}) + tmp96 := lang.Apply(tmp87, []any{tmp95}) + tmp97 := lang.Apply(tmp86, []any{tmp96}) + tmp98 := checkDerefVar(var_glojure_DOT_core_list) + tmp99 := lang.Apply(tmp98, []any{v36}) + tmp100 := checkDerefVar(var_glojure_DOT_core_list) + tmp101 := lang.Apply(v15, []any{v16, v17, v43}) + tmp102 := lang.Apply(tmp100, []any{tmp101}) + tmp103 := lang.Apply(tmp83, []any{tmp85, tmp97, tmp99, tmp102}) + tmp104 := lang.Apply(tmp82, []any{tmp103}) + tmp79 = tmp104 + } else { + var tmp105 any + if lang.IsTruthy(kw_else) { + tmp106 := checkDerefVar(var_glojure_DOT_core_seq) + tmp107 := checkDerefVar(var_glojure_DOT_core_concat) + tmp108 := checkDerefVar(var_glojure_DOT_core_list) + tmp109 := lang.Apply(tmp108, []any{sym_glojure_DOT_core_SLASH_if_DASH_let}) + tmp110 := checkDerefVar(var_glojure_DOT_core_list) + tmp111 := checkDerefVar(var_glojure_DOT_core_apply) + tmp112 := checkDerefVar(var_glojure_DOT_core_vector) + tmp113 := checkDerefVar(var_glojure_DOT_core_seq) + tmp114 := checkDerefVar(var_glojure_DOT_core_concat) + tmp115 := checkDerefVar(var_glojure_DOT_core_list) + tmp116 := lang.Apply(tmp115, []any{sym_p__0__auto__}) + tmp117 := checkDerefVar(var_glojure_DOT_core_list) + tmp118 := checkDerefVar(var_glojure_DOT_core_seq) + tmp119 := checkDerefVar(var_glojure_DOT_core_concat) + tmp120 := checkDerefVar(var_glojure_DOT_core_list) + tmp121 := lang.Apply(tmp120, []any{v16}) + tmp122 := checkDerefVar(var_glojure_DOT_core_list) + tmp123 := lang.Apply(tmp122, []any{v33}) + tmp124 := checkDerefVar(var_glojure_DOT_core_list) + tmp125 := lang.Apply(tmp124, []any{v17}) + tmp126 := lang.Apply(tmp119, []any{tmp121, tmp123, tmp125}) + tmp127 := lang.Apply(tmp118, []any{tmp126}) + tmp128 := lang.Apply(tmp117, []any{tmp127}) + tmp129 := lang.Apply(tmp114, []any{tmp116, tmp128}) + tmp130 := lang.Apply(tmp113, []any{tmp129}) + tmp131 := lang.Apply(tmp111, []any{tmp112, tmp130}) + tmp132 := lang.Apply(tmp110, []any{tmp131}) + tmp133 := checkDerefVar(var_glojure_DOT_core_list) + tmp134 := checkDerefVar(var_glojure_DOT_core_seq) + tmp135 := checkDerefVar(var_glojure_DOT_core_concat) + tmp136 := checkDerefVar(var_glojure_DOT_core_list) + tmp137 := lang.Apply(tmp136, []any{v39}) + tmp138 := checkDerefVar(var_glojure_DOT_core_list) + tmp139 := lang.Apply(tmp138, []any{sym_p__0__auto__}) + tmp140 := lang.Apply(tmp135, []any{tmp137, tmp139}) + tmp141 := lang.Apply(tmp134, []any{tmp140}) + tmp142 := lang.Apply(tmp133, []any{tmp141}) + tmp143 := checkDerefVar(var_glojure_DOT_core_list) + tmp144 := lang.Apply(v15, []any{v16, v17, v43}) + tmp145 := lang.Apply(tmp143, []any{tmp144}) + tmp146 := lang.Apply(tmp107, []any{tmp109, tmp132, tmp142, tmp145}) + tmp147 := lang.Apply(tmp106, []any{tmp146}) + tmp105 = tmp147 + } else { + } + tmp79 = tmp105 + } + tmp76 = tmp79 + } + tmp47 = tmp76 + } + tmp19 = tmp47 + } // end let + return tmp19 + }) + v15 = tmp14 + _ = v15 + } + tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6377), kw_column, int(14), kw_end_DASH_line, int(6389), kw_end_DASH_column, int(53)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v17 any = tmp16 + _ = v17 + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{sym_glojure_DOT_core_SLASH_let}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := checkDerefVar(var_glojure_DOT_core_apply) + tmp24 := checkDerefVar(var_glojure_DOT_core_vector) + tmp25 := checkDerefVar(var_glojure_DOT_core_seq) + tmp26 := checkDerefVar(var_glojure_DOT_core_concat) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{v10}) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{v4}) + tmp31 := checkDerefVar(var_glojure_DOT_core_list) + tmp32 := lang.Apply(tmp31, []any{v13}) + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{v5}) + tmp35 := lang.Apply(tmp26, []any{tmp28, tmp30, tmp32, tmp34}) + tmp36 := lang.Apply(tmp25, []any{tmp35}) + tmp37 := lang.Apply(tmp23, []any{tmp24, tmp36}) + tmp38 := lang.Apply(tmp22, []any{tmp37}) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := lang.Apply(v17, []any{v10, v13, v6}) + tmp41 := lang.Apply(tmp39, []any{tmp40}) + tmp42 := lang.Apply(tmp19, []any{tmp21, tmp38, tmp41}) + tmp43 := lang.Apply(tmp18, []any{tmp42}) + tmp7 = tmp43 + } // end let + return tmp7 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_condp = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_condp.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // destructure + { + tmp0 := sym_destructure.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4400), kw_column, int(7), kw_end_DASH_line, int(4400), kw_end_DASH_column, int(17), kw_arglists, lang.NewList(lang.NewVector(sym_bindings)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "bents" + tmp4 := checkDerefVar(var_glojure_DOT_core_partition) + tmp5 := lang.Apply(tmp4, []any{int64(2), v2}) + var v6 any = tmp5 + _ = v6 + // let binding "pb" + var tmp7 lang.FnFunc + { // function pb + var v8 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v9 := args[0] + _ = v9 + v10 := args[1] + _ = v10 + v11 := args[2] + _ = v11 + var tmp12 any + { // let + // let binding "pvec" + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v14 := args[0] + _ = v14 + v15 := args[1] + _ = v15 + v16 := args[2] + _ = v16 + var tmp17 any + { // let + // let binding "gvec" + tmp18 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp19 := lang.Apply(tmp18, []any{"vec__"}) + var v20 any = tmp19 + _ = v20 + // let binding "gseq" + tmp21 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp22 := lang.Apply(tmp21, []any{"seq__"}) + var v23 any = tmp22 + _ = v23 + // let binding "gfirst" + tmp24 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp25 := lang.Apply(tmp24, []any{"first__"}) + var v26 any = tmp25 + _ = v26 + // let binding "has-rest" + tmp27 := checkDerefVar(var_glojure_DOT_core_some) + tmp28 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{sym__AMP_})) + tmp29 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4408), kw_column, int(43), kw_end_DASH_line, int(4408), kw_end_DASH_column, int(47)) + tmp30, err := lang.WithMeta(tmp28, tmp29.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp31 := lang.Apply(tmp27, []any{tmp30, v15}) + var v32 any = tmp31 + _ = v32 + var tmp33 any + { // let + // let binding "ret" + var tmp34 any + { // let + // let binding "ret" + tmp35 := checkDerefVar(var_glojure_DOT_core_conj) + tmp36 := lang.Apply(tmp35, []any{v14, v20, v16}) + var v37 any = tmp36 + _ = v37 + var tmp38 any + if lang.IsTruthy(v32) { + tmp39 := checkDerefVar(var_glojure_DOT_core_conj) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{sym_glojure_DOT_core_SLASH_seq, v20}) + tmp42 := lang.Apply(tmp39, []any{v37, v23, tmp41}) + tmp38 = tmp42 + } else { + tmp38 = v37 + } + tmp34 = tmp38 + } // end let + var v35 any = tmp34 + _ = v35 + // let binding "n" + var v36 any = int64(0) + _ = v36 + // let binding "bs" + var v37 any = v15 + _ = v37 + // let binding "seen-rest?" + var v38 any = false + _ = v38 + for { + var tmp39 any + tmp40 := checkDerefVar(var_glojure_DOT_core_seq) + tmp41 := lang.Apply(tmp40, []any{v37}) + if lang.IsTruthy(tmp41) { + var tmp42 any + { // let + // let binding "firstb" + tmp43 := checkDerefVar(var_glojure_DOT_core_first) + tmp44 := lang.Apply(tmp43, []any{v37}) + var v45 any = tmp44 + _ = v45 + var tmp46 any + tmp47 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp48 := lang.Apply(tmp47, []any{v45, sym__AMP_}) + if lang.IsTruthy(tmp48) { + tmp50 := checkDerefVar(var_glojure_DOT_core_second) + tmp51 := lang.Apply(tmp50, []any{v37}) + tmp52 := lang.Apply(v8, []any{v35, tmp51, v23}) + var tmp49 any = tmp52 + var tmp53 any = v36 + tmp55 := checkDerefVar(var_glojure_DOT_core_nnext) + tmp56 := lang.Apply(tmp55, []any{v37}) + var tmp54 any = tmp56 + var tmp57 any = true + v35 = tmp49 + v36 = tmp53 + v37 = tmp54 + v38 = tmp57 + continue + } else { + var tmp58 any + tmp59 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp60 := lang.Apply(tmp59, []any{v45, kw_as}) + if lang.IsTruthy(tmp60) { + tmp61 := checkDerefVar(var_glojure_DOT_core_second) + tmp62 := lang.Apply(tmp61, []any{v37}) + tmp63 := lang.Apply(v8, []any{v35, tmp62, v20}) + tmp58 = tmp63 + } else { + var tmp64 any + if lang.IsTruthy(kw_else) { + var tmp65 any + if lang.IsTruthy(v38) { + tmp66 := lang.Apply(errors5.New, []any{"Unsupported binding form, only :as can follow & parameter"}) + panic(tmp66) + } else { + var tmp68 any + if lang.IsTruthy(v32) { + tmp69 := checkDerefVar(var_glojure_DOT_core_conj) + tmp70 := checkDerefVar(var_glojure_DOT_core_seq) + tmp71 := checkDerefVar(var_glojure_DOT_core_concat) + tmp72 := checkDerefVar(var_glojure_DOT_core_list) + tmp73 := lang.Apply(tmp72, []any{sym_glojure_DOT_core_SLASH_first}) + tmp74 := checkDerefVar(var_glojure_DOT_core_list) + tmp75 := lang.Apply(tmp74, []any{v23}) + tmp76 := lang.Apply(tmp71, []any{tmp73, tmp75}) + tmp77 := lang.Apply(tmp70, []any{tmp76}) + tmp78 := checkDerefVar(var_glojure_DOT_core_seq) + tmp79 := checkDerefVar(var_glojure_DOT_core_concat) + tmp80 := checkDerefVar(var_glojure_DOT_core_list) + tmp81 := lang.Apply(tmp80, []any{sym_glojure_DOT_core_SLASH_next}) + tmp82 := checkDerefVar(var_glojure_DOT_core_list) + tmp83 := lang.Apply(tmp82, []any{v23}) + tmp84 := lang.Apply(tmp79, []any{tmp81, tmp83}) + tmp85 := lang.Apply(tmp78, []any{tmp84}) + tmp86 := lang.Apply(tmp69, []any{v35, v26, tmp77, v23, tmp85}) + tmp68 = tmp86 + } else { + tmp68 = v35 + } + var tmp87 any + if lang.IsTruthy(v32) { + tmp87 = v26 + } else { + tmp88 := checkDerefVar(var_glojure_DOT_core_list) + tmp89 := lang.Apply(tmp88, []any{sym_glojure_DOT_core_SLASH_nth, v20, v36, nil}) + tmp87 = tmp89 + } + tmp90 := lang.Apply(v8, []any{tmp68, v45, tmp87}) + var tmp67 any = tmp90 + tmp92 := checkDerefVar(var_glojure_DOT_core_inc) + tmp93 := lang.Apply(tmp92, []any{v36}) + var tmp91 any = tmp93 + tmp95 := checkDerefVar(var_glojure_DOT_core_next) + tmp96 := lang.Apply(tmp95, []any{v37}) + var tmp94 any = tmp96 + var tmp97 any = v38 + v35 = tmp67 + v36 = tmp91 + v37 = tmp94 + v38 = tmp97 + continue + } + tmp64 = tmp65 + } else { + } + tmp58 = tmp64 + } + tmp46 = tmp58 + } + tmp42 = tmp46 + } // end let + tmp39 = tmp42 + } else { + tmp39 = v35 + } + tmp33 = tmp39 + break + } + } // end let + tmp17 = tmp33 + } // end let + return tmp17 + }) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4404), kw_column, int(20), kw_end_DASH_line, int(4438), kw_end_DASH_column, int(34)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v16 any = tmp15 + _ = v16 + // let binding "pmap" + var tmp17 lang.FnFunc + tmp17 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v18 := args[0] + _ = v18 + v19 := args[1] + _ = v19 + v20 := args[2] + _ = v20 + var tmp21 any + { // let + // let binding "gmap" + tmp22 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp23 := lang.Apply(tmp22, []any{"map__"}) + var v24 any = tmp23 + _ = v24 + // let binding "gmapseq" + tmp25 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp26 := lang.NewMap(kw_tag, sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_ISeq) + tmp27 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4442), kw_column, int(52), kw_end_DASH_line, int(4442), kw_end_DASH_column, int(103)) + tmp28, err := lang.WithMeta(tmp26, tmp27.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp29 := lang.Apply(tmp25, []any{v24, tmp28}) + var v30 any = tmp29 + _ = v30 + // let binding "defaults" + tmp31 := lang.Apply(kw_or, []any{v19}) + var v32 any = tmp31 + _ = v32 + var tmp33 any + { // let + // let binding "ret" + var tmp34 lang.FnFunc + tmp34 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v35 := args[0] + _ = v35 + var tmp36 any + tmp37 := lang.Apply(kw_as, []any{v19}) + if lang.IsTruthy(tmp37) { + tmp38 := checkDerefVar(var_glojure_DOT_core_conj) + tmp39 := lang.Apply(kw_as, []any{v19}) + tmp40 := lang.Apply(tmp38, []any{v35, tmp39, v24}) + tmp36 = tmp40 + } else { + tmp36 = v35 + } + return tmp36 + }) + tmp35 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4450), kw_column, int(40), kw_end_DASH_line, int(4453), kw_end_DASH_column, int(48)) + tmp36, err := lang.WithMeta(tmp34, tmp35.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp37 := checkDerefVar(var_glojure_DOT_core_conj) + tmp38 := checkDerefVar(var_glojure_DOT_core_conj) + tmp39 := checkDerefVar(var_glojure_DOT_core_conj) + tmp40 := checkDerefVar(var_glojure_DOT_core_conj) + tmp41 := lang.Apply(tmp40, []any{v18, v24}) + tmp42 := lang.Apply(tmp39, []any{tmp41, v20}) + tmp43 := lang.Apply(tmp38, []any{tmp42, v24}) + tmp44 := checkDerefVar(var_glojure_DOT_core_seq) + tmp45 := checkDerefVar(var_glojure_DOT_core_concat) + tmp46 := checkDerefVar(var_glojure_DOT_core_list) + tmp47 := lang.Apply(tmp46, []any{sym_if}) + tmp48 := checkDerefVar(var_glojure_DOT_core_list) + tmp49 := checkDerefVar(var_glojure_DOT_core_seq) + tmp50 := checkDerefVar(var_glojure_DOT_core_concat) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := lang.Apply(tmp51, []any{sym_glojure_DOT_core_SLASH_seq_QMARK_}) + tmp53 := checkDerefVar(var_glojure_DOT_core_list) + tmp54 := lang.Apply(tmp53, []any{v24}) + tmp55 := lang.Apply(tmp50, []any{tmp52, tmp54}) + tmp56 := lang.Apply(tmp49, []any{tmp55}) + tmp57 := lang.Apply(tmp48, []any{tmp56}) + tmp58 := checkDerefVar(var_glojure_DOT_core_list) + tmp59 := checkDerefVar(var_glojure_DOT_core_seq) + tmp60 := checkDerefVar(var_glojure_DOT_core_concat) + tmp61 := checkDerefVar(var_glojure_DOT_core_list) + tmp62 := lang.Apply(tmp61, []any{sym_if}) + tmp63 := checkDerefVar(var_glojure_DOT_core_list) + tmp64 := checkDerefVar(var_glojure_DOT_core_seq) + tmp65 := checkDerefVar(var_glojure_DOT_core_concat) + tmp66 := checkDerefVar(var_glojure_DOT_core_list) + tmp67 := lang.Apply(tmp66, []any{sym_glojure_DOT_core_SLASH_next}) + tmp68 := checkDerefVar(var_glojure_DOT_core_list) + tmp69 := lang.Apply(tmp68, []any{v30}) + tmp70 := lang.Apply(tmp65, []any{tmp67, tmp69}) + tmp71 := lang.Apply(tmp64, []any{tmp70}) + tmp72 := lang.Apply(tmp63, []any{tmp71}) + tmp73 := checkDerefVar(var_glojure_DOT_core_list) + tmp74 := checkDerefVar(var_glojure_DOT_core_seq) + tmp75 := checkDerefVar(var_glojure_DOT_core_concat) + tmp76 := checkDerefVar(var_glojure_DOT_core_list) + tmp77 := lang.Apply(tmp76, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_NewPersistentArrayMapAsIfByAssoc}) + tmp78 := checkDerefVar(var_glojure_DOT_core_list) + tmp79 := checkDerefVar(var_glojure_DOT_core_seq) + tmp80 := checkDerefVar(var_glojure_DOT_core_concat) + tmp81 := checkDerefVar(var_glojure_DOT_core_list) + tmp82 := lang.Apply(tmp81, []any{sym_glojure_DOT_core_SLASH_to_DASH_array}) + tmp83 := checkDerefVar(var_glojure_DOT_core_list) + tmp84 := lang.Apply(tmp83, []any{v30}) + tmp85 := lang.Apply(tmp80, []any{tmp82, tmp84}) + tmp86 := lang.Apply(tmp79, []any{tmp85}) + tmp87 := lang.Apply(tmp78, []any{tmp86}) + tmp88 := lang.Apply(tmp75, []any{tmp77, tmp87}) + tmp89 := lang.Apply(tmp74, []any{tmp88}) + tmp90 := lang.Apply(tmp73, []any{tmp89}) + tmp91 := checkDerefVar(var_glojure_DOT_core_list) + tmp92 := checkDerefVar(var_glojure_DOT_core_seq) + tmp93 := checkDerefVar(var_glojure_DOT_core_concat) + tmp94 := checkDerefVar(var_glojure_DOT_core_list) + tmp95 := lang.Apply(tmp94, []any{sym_if}) + tmp96 := checkDerefVar(var_glojure_DOT_core_list) + tmp97 := checkDerefVar(var_glojure_DOT_core_seq) + tmp98 := checkDerefVar(var_glojure_DOT_core_concat) + tmp99 := checkDerefVar(var_glojure_DOT_core_list) + tmp100 := lang.Apply(tmp99, []any{sym_glojure_DOT_core_SLASH_seq}) + tmp101 := checkDerefVar(var_glojure_DOT_core_list) + tmp102 := lang.Apply(tmp101, []any{v30}) + tmp103 := lang.Apply(tmp98, []any{tmp100, tmp102}) + tmp104 := lang.Apply(tmp97, []any{tmp103}) + tmp105 := lang.Apply(tmp96, []any{tmp104}) + tmp106 := checkDerefVar(var_glojure_DOT_core_list) + tmp107 := checkDerefVar(var_glojure_DOT_core_seq) + tmp108 := checkDerefVar(var_glojure_DOT_core_concat) + tmp109 := checkDerefVar(var_glojure_DOT_core_list) + tmp110 := lang.Apply(tmp109, []any{sym_glojure_DOT_core_SLASH_first}) + tmp111 := checkDerefVar(var_glojure_DOT_core_list) + tmp112 := lang.Apply(tmp111, []any{v30}) + tmp113 := lang.Apply(tmp108, []any{tmp110, tmp112}) + tmp114 := lang.Apply(tmp107, []any{tmp113}) + tmp115 := lang.Apply(tmp106, []any{tmp114}) + tmp116 := checkDerefVar(var_glojure_DOT_core_list) + tmp117 := lang.Apply(tmp116, []any{sym_glojure_DOT_lang_DOT_PersistentArrayMap_SLASH_EMPTY}) + tmp118 := lang.Apply(tmp93, []any{tmp95, tmp105, tmp115, tmp117}) + tmp119 := lang.Apply(tmp92, []any{tmp118}) + tmp120 := lang.Apply(tmp91, []any{tmp119}) + tmp121 := lang.Apply(tmp60, []any{tmp62, tmp72, tmp90, tmp120}) + tmp122 := lang.Apply(tmp59, []any{tmp121}) + tmp123 := lang.Apply(tmp58, []any{tmp122}) + tmp124 := checkDerefVar(var_glojure_DOT_core_list) + tmp125 := lang.Apply(tmp124, []any{v24}) + tmp126 := lang.Apply(tmp45, []any{tmp47, tmp57, tmp123, tmp125}) + tmp127 := lang.Apply(tmp44, []any{tmp126}) + tmp128 := lang.Apply(tmp37, []any{tmp43, tmp127}) + tmp129 := lang.Apply(tmp36, []any{tmp128}) + var v130 any = tmp129 + _ = v130 + // let binding "bes" + var tmp131 any + { // let + // let binding "transforms" + tmp132 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp133 lang.FnFunc + tmp133 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v134 := args[0] + _ = v134 + v135 := args[1] + _ = v135 + var tmp136 any + tmp137 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp138 := lang.Apply(tmp137, []any{v135}) + if lang.IsTruthy(tmp138) { + var tmp139 any + { // let + // let binding "mkns" + tmp140 := checkDerefVar(var_glojure_DOT_core_namespace) + tmp141 := lang.Apply(tmp140, []any{v135}) + var v142 any = tmp141 + _ = v142 + // let binding "mkn" + tmp143 := checkDerefVar(var_glojure_DOT_core_name) + tmp144 := lang.Apply(tmp143, []any{v135}) + var v145 any = tmp144 + _ = v145 + var tmp146 any + tmp147 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp148 := lang.Apply(tmp147, []any{v145, "keys"}) + if lang.IsTruthy(tmp148) { + tmp149 := checkDerefVar(var_glojure_DOT_core_assoc) + var tmp150 lang.FnFunc + tmp150 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v151 := args[0] + _ = v151 + tmp152 := checkDerefVar(var_glojure_DOT_core_keyword) + var tmp153 any + { // let + // let binding "or__0__auto__" + var v154 any = v142 + _ = v154 + var tmp155 any + if lang.IsTruthy(v154) { + tmp155 = v154 + } else { + tmp156 := checkDerefVar(var_glojure_DOT_core_namespace) + tmp157 := lang.Apply(tmp156, []any{v151}) + tmp155 = tmp157 + } + tmp153 = tmp155 + } // end let + tmp154 := checkDerefVar(var_glojure_DOT_core_name) + tmp155 := lang.Apply(tmp154, []any{v151}) + tmp156 := lang.Apply(tmp152, []any{tmp153, tmp155}) + return tmp156 + }) + tmp151 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4460), kw_column, int(93), kw_end_DASH_line, int(4460), kw_end_DASH_column, int(135)) + tmp152, err := lang.WithMeta(tmp150, tmp151.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp153 := lang.Apply(tmp149, []any{v134, v135, tmp152}) + tmp146 = tmp153 + } else { + var tmp154 any + tmp155 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp156 := lang.Apply(tmp155, []any{v145, "syms"}) + if lang.IsTruthy(tmp156) { + tmp157 := checkDerefVar(var_glojure_DOT_core_assoc) + var tmp158 lang.FnFunc + tmp158 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v159 := args[0] + _ = v159 + tmp160 := checkDerefVar(var_glojure_DOT_core_list) + tmp161 := checkDerefVar(var_glojure_DOT_core_symbol) + var tmp162 any + { // let + // let binding "or__0__auto__" + var v163 any = v142 + _ = v163 + var tmp164 any + if lang.IsTruthy(v163) { + tmp164 = v163 + } else { + tmp165 := checkDerefVar(var_glojure_DOT_core_namespace) + tmp166 := lang.Apply(tmp165, []any{v159}) + tmp164 = tmp166 + } + tmp162 = tmp164 + } // end let + tmp163 := checkDerefVar(var_glojure_DOT_core_name) + tmp164 := lang.Apply(tmp163, []any{v159}) + tmp165 := lang.Apply(tmp161, []any{tmp162, tmp164}) + tmp166 := lang.Apply(tmp160, []any{sym_quote, tmp165}) + return tmp166 + }) + tmp159 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4461), kw_column, int(93), kw_end_DASH_line, int(4461), kw_end_DASH_column, int(148)) + tmp160, err := lang.WithMeta(tmp158, tmp159.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp161 := lang.Apply(tmp157, []any{v134, v135, tmp160}) + tmp154 = tmp161 + } else { + var tmp162 any + tmp163 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp164 := lang.Apply(tmp163, []any{v145, "strs"}) + if lang.IsTruthy(tmp164) { + tmp165 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp166 := checkDerefVar(var_glojure_DOT_core_str) + tmp167 := lang.Apply(tmp165, []any{v134, v135, tmp166}) + tmp162 = tmp167 + } else { + var tmp168 any + if lang.IsTruthy(kw_else) { + tmp168 = v134 + } else { + } + tmp162 = tmp168 + } + tmp154 = tmp162 + } + tmp146 = tmp154 + } + tmp139 = tmp146 + } // end let + tmp136 = tmp139 + } else { + tmp136 = v134 + } + return tmp136 + }) + tmp134 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4456), kw_column, int(45), kw_end_DASH_line, int(4464), kw_end_DASH_column, int(60)) + tmp135, err := lang.WithMeta(tmp133, tmp134.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp136 := lang.NewMap() + tmp137 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4465), kw_column, int(45), kw_end_DASH_line, int(4465), kw_end_DASH_column, int(46)) + tmp138, err := lang.WithMeta(tmp136, tmp137.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp139 := checkDerefVar(var_glojure_DOT_core_keys) + tmp140 := lang.Apply(tmp139, []any{v19}) + tmp141 := lang.Apply(tmp132, []any{tmp135, tmp138, tmp140}) + var v142 any = tmp141 + _ = v142 + tmp143 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp144 lang.FnFunc + tmp144 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v145 := args[0] + _ = v145 + v146 := args[1] + _ = v146 + tmp147 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp148 lang.FnFunc + tmp148 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v149 := args[0] + _ = v149 + v150 := args[1] + _ = v150 + tmp151 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp152 := checkDerefVar(var_glojure_DOT_core_val) + tmp153 := lang.Apply(tmp152, []any{v146}) + tmp154 := lang.Apply(tmp153, []any{v150}) + tmp155 := lang.Apply(tmp151, []any{v149, v150, tmp154}) + return tmp155 + }) + tmp149 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4469), kw_column, int(52), kw_end_DASH_line, int(4469), kw_end_DASH_column, int(82)) + tmp150, err := lang.WithMeta(tmp148, tmp149.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp151 := checkDerefVar(var_glojure_DOT_core_dissoc) + tmp152 := checkDerefVar(var_glojure_DOT_core_key) + tmp153 := lang.Apply(tmp152, []any{v146}) + tmp154 := lang.Apply(tmp151, []any{v145, tmp153}) + tmp155 := checkDerefVar(var_glojure_DOT_core_key) + tmp156 := lang.Apply(tmp155, []any{v146}) + tmp157 := lang.Apply(tmp156, []any{v145}) + tmp158 := lang.Apply(tmp147, []any{tmp150, tmp154, tmp157}) + return tmp158 + }) + tmp145 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4468), kw_column, int(41), kw_end_DASH_line, int(4471), kw_end_DASH_column, int(70)) + tmp146, err := lang.WithMeta(tmp144, tmp145.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp147 := checkDerefVar(var_glojure_DOT_core_dissoc) + tmp148 := lang.Apply(tmp147, []any{v19, kw_as, kw_or}) + tmp149 := lang.Apply(tmp143, []any{tmp146, tmp148, v142}) + tmp131 = tmp149 + } // end let + var v132 any = tmp131 + _ = v132 + for { + var tmp133 any + tmp134 := checkDerefVar(var_glojure_DOT_core_seq) + tmp135 := lang.Apply(tmp134, []any{v132}) + if lang.IsTruthy(tmp135) { + var tmp136 any + { // let + // let binding "bb" + tmp137 := checkDerefVar(var_glojure_DOT_core_key) + tmp138 := checkDerefVar(var_glojure_DOT_core_first) + tmp139 := lang.Apply(tmp138, []any{v132}) + tmp140 := lang.Apply(tmp137, []any{tmp139}) + var v141 any = tmp140 + _ = v141 + // let binding "bk" + tmp142 := checkDerefVar(var_glojure_DOT_core_val) + tmp143 := checkDerefVar(var_glojure_DOT_core_first) + tmp144 := lang.Apply(tmp143, []any{v132}) + tmp145 := lang.Apply(tmp142, []any{tmp144}) + var v146 any = tmp145 + _ = v146 + // let binding "local" + var tmp147 any + tmp148 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp149 := reflect.TypeOf((*lang.Named)(nil)).Elem() + tmp150 := lang.Apply(tmp148, []any{tmp149, v141}) + if lang.IsTruthy(tmp150) { + tmp151 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp152 := checkDerefVar(var_glojure_DOT_core_symbol) + tmp153 := checkDerefVar(var_glojure_DOT_core_name) + tmp154 := lang.Apply(tmp153, []any{v141}) + tmp155 := lang.Apply(tmp152, []any{nil, tmp154}) + tmp156 := checkDerefVar(var_glojure_DOT_core_meta) + tmp157 := lang.Apply(tmp156, []any{v141}) + tmp158 := lang.Apply(tmp151, []any{tmp155, tmp157}) + tmp147 = tmp158 + } else { + tmp147 = v141 + } + var v159 any = tmp147 + _ = v159 + // let binding "bv" + var tmp160 any + tmp161 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp162 := lang.Apply(tmp161, []any{v32, v159}) + if lang.IsTruthy(tmp162) { + tmp163 := checkDerefVar(var_glojure_DOT_core_list) + tmp164 := lang.Apply(v32, []any{v159}) + tmp165 := lang.Apply(tmp163, []any{sym_glojure_DOT_core_SLASH_get, v24, v146, tmp164}) + tmp160 = tmp165 + } else { + tmp166 := checkDerefVar(var_glojure_DOT_core_list) + tmp167 := lang.Apply(tmp166, []any{sym_glojure_DOT_core_SLASH_get, v24, v146}) + tmp160 = tmp167 + } + var v168 any = tmp160 + _ = v168 + var tmp170 any + tmp171 := checkDerefVar(var_glojure_DOT_core_ident_QMARK_) + tmp172 := lang.Apply(tmp171, []any{v141}) + if lang.IsTruthy(tmp172) { + tmp173 := checkDerefVar(var_glojure_DOT_core_conj) + tmp174 := lang.Apply(tmp173, []any{v130, v159, v168}) + tmp170 = tmp174 + } else { + tmp175 := lang.Apply(v8, []any{v130, v141, v168}) + tmp170 = tmp175 + } + var tmp169 any = tmp170 + tmp177 := checkDerefVar(var_glojure_DOT_core_next) + tmp178 := lang.Apply(tmp177, []any{v132}) + var tmp176 any = tmp178 + v130 = tmp169 + v132 = tmp176 + continue + } // end let + tmp133 = tmp136 + } else { + tmp133 = v130 + } + tmp33 = tmp133 + break + } + } // end let + tmp21 = tmp33 + } // end let + return tmp21 + }) + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4440), kw_column, int(20), kw_end_DASH_line, int(4485), kw_end_DASH_column, int(34)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v20 any = tmp19 + _ = v20 + var tmp21 any + tmp22 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp23 := lang.Apply(tmp22, []any{v10}) + if lang.IsTruthy(tmp23) { + tmp24 := checkDerefVar(var_glojure_DOT_core_conj) + tmp25 := checkDerefVar(var_glojure_DOT_core_conj) + tmp26 := lang.Apply(tmp25, []any{v9, v10}) + tmp27 := lang.Apply(tmp24, []any{tmp26, v11}) + tmp21 = tmp27 + } else { + var tmp28 any + tmp29 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp30 := lang.Apply(tmp29, []any{v10}) + if lang.IsTruthy(tmp30) { + tmp31 := lang.Apply(v16, []any{v9, v10, v11}) + tmp28 = tmp31 + } else { + var tmp32 any + tmp33 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp34 := lang.Apply(tmp33, []any{v10}) + if lang.IsTruthy(tmp34) { + tmp35 := lang.Apply(v20, []any{v9, v10, v11}) + tmp32 = tmp35 + } else { + var tmp36 any + if lang.IsTruthy(kw_else) { + tmp37 := checkDerefVar(var_glojure_DOT_core_str) + tmp38 := lang.Apply(tmp37, []any{"Unsupported binding form: ", v10}) + tmp39 := lang.Apply(errors5.New, []any{tmp38}) + panic(tmp39) + } else { + } + tmp32 = tmp36 + } + tmp28 = tmp32 + } + tmp21 = tmp28 + } + tmp12 = tmp21 + } // end let + return tmp12 + }) + v8 = tmp7 + _ = v8 + } + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4402), kw_column, int(12), kw_end_DASH_line, int(4490), kw_end_DASH_column, int(82)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v10 any = tmp9 + _ = v10 + // let binding "process-entry" + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v12 := args[0] + _ = v12 + v13 := args[1] + _ = v13 + tmp14 := checkDerefVar(var_glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v13}) + tmp16 := checkDerefVar(var_glojure_DOT_core_second) + tmp17 := lang.Apply(tmp16, []any{v13}) + tmp18 := lang.Apply(v10, []any{v12, tmp15, tmp17}) + return tmp18 + }) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4491), kw_column, int(23), kw_end_DASH_line, int(4491), kw_end_DASH_column, int(66)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v14 any = tmp13 + _ = v14 + var tmp15 any + tmp16 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + tmp17 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp18 := checkDerefVar(var_glojure_DOT_core_map) + tmp19 := checkDerefVar(var_glojure_DOT_core_first) + tmp20 := lang.Apply(tmp18, []any{tmp19, v6}) + tmp21 := lang.Apply(tmp16, []any{tmp17, tmp20}) + if lang.IsTruthy(tmp21) { + tmp15 = v2 + } else { + tmp22 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp23 := lang.NewVector() + tmp24 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4494), kw_column, int(30), kw_end_DASH_line, int(4494), kw_end_DASH_column, int(31)) + tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp26 := lang.Apply(tmp22, []any{v14, tmp25, v6}) + tmp15 = tmp26 + } + tmp3 = tmp15 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_destructure = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_destructure.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // extend + { + tmp0 := sym_extend.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_atype, sym__AMP_, sym_proto_PLUS_mmaps)), kw_doc, "Implementations of protocol methods can be provided using the extend construct:\n\n (extend AType\n AProtocol\n {:foo an-existing-fn\n :bar (fn [a b] ...)\n :baz (fn ([a]...) ([a b] ...)...)}\n BProtocol \n {...} \n ...)\n \n extend takes a type/class (or interface, see below), and one or more\n protocol + method map pairs. It will extend the polymorphism of the\n protocol's methods to call the supplied methods when an AType is\n provided as the first argument. \n\n Method maps are maps of the keyword-ized method names to ordinary\n fns. This facilitates easy reuse of existing fns and fn maps, for\n code reuse/mixins without derivation or composition. You can extend\n an interface to a protocol. This is primarily to facilitate interop\n with the host (e.g. Java) but opens the door to incidental multiple\n inheritance of implementation since a class can inherit from more\n than one interface, both of which extend the protocol. It is TBD how\n to specify which impl to use. You can extend a protocol on nil.\n\n If you are supplying the definitions explicitly (i.e. not reusing\n exsting functions or mixin maps), you may find it more convenient to\n use the extend-type or extend-protocol macros.\n\n Note that multiple independent extend clauses can exist for the same\n type, not all protocols need be defined in a single extend call.\n\n See also:\n extends?, satisfies?, extenders", kw_file, "glojure/core_deftype.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(116), kw_end_DASH_line, int(116))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + var tmp4 any + { // let + // let binding "seq_953" + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_partition) + tmp7 := lang.Apply(tmp6, []any{int64(2), v3}) + tmp8 := lang.Apply(tmp5, []any{tmp7}) + var v9 any = tmp8 + _ = v9 + // let binding "chunk_954" + var v10 any = nil + _ = v10 + // let binding "count_955" + var v11 any = int64(0) + _ = v11 + // let binding "i_956" + var v12 any = int64(0) + _ = v12 + for { + var tmp13 any + tmp14 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp15 := lang.Apply(tmp14, []any{v12, v11}) + if lang.IsTruthy(tmp15) { + var tmp16 any + { // let + // let binding "vec__957" + tmp17, _ := lang.FieldOrMethod(v10, "nth") + if reflect.TypeOf(tmp17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp18 := lang.Apply(tmp17, []any{v12}) + var v19 any = tmp18 + _ = v19 + // let binding "proto" + tmp20 := checkDerefVar(var_glojure_DOT_core_nth) + tmp21 := lang.Apply(tmp20, []any{v19, int64(0), nil}) + var v22 any = tmp21 + _ = v22 + // let binding "mmap" + tmp23 := checkDerefVar(var_glojure_DOT_core_nth) + tmp24 := lang.Apply(tmp23, []any{v19, int64(1), nil}) + var v25 any = tmp24 + _ = v25 + var tmp26 any + tmp27 := checkDerefVar(var_glojure_DOT_core_protocol_QMARK_) + tmp28 := lang.Apply(tmp27, []any{v22}) + if lang.IsTruthy(tmp28) { + } else { + tmp29 := checkDerefVar(var_glojure_DOT_core_str) + tmp30 := lang.Apply(tmp29, []any{v22, " is not a protocol"}) + tmp31 := lang.Apply(errors5.New, []any{tmp30}) + panic(tmp31) + } + _ = tmp26 + tmp32 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp33 lang.FnFunc + tmp33 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v34 := args[0] + _ = v34 + v35 := args[1] + _ = v35 + var tmp36 any + { // let + // let binding "vec__961" + var v37 any = v35 + _ = v37 + // let binding "k" + tmp38 := checkDerefVar(var_glojure_DOT_core_nth) + tmp39 := lang.Apply(tmp38, []any{v37, int64(0), nil}) + var v40 any = tmp39 + _ = v40 + // let binding "v" + tmp41 := checkDerefVar(var_glojure_DOT_core_nth) + tmp42 := lang.Apply(tmp41, []any{v37, int64(1), nil}) + var v43 any = tmp42 + _ = v43 + tmp44 := checkDerefVar(var_glojure_DOT_core_get_DASH_in) + tmp45 := checkDerefVar(var_glojure_DOT_core_deref) + tmp46 := lang.Apply(tmp45, []any{v22}) + tmp47 := lang.NewVector(kw_multis, v40) + tmp48 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(158), kw_column, int(33), kw_end_DASH_line, int(158), kw_end_DASH_column, int(43)) + tmp49, err := lang.WithMeta(tmp47, tmp48.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp50 := lang.Apply(tmp44, []any{tmp46, tmp49}) + var tmp51 lang.FnFunc + tmp51 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v52 := args[0] + _ = v52 + var v53 any = lang.NewList(args[1:]...) + _ = v53 + tmp54 := checkDerefVar(var_glojure_DOT_core_apply) + tmp55 := checkDerefVar(var_glojure_DOT_core_cons) + tmp56 := lang.Apply(tmp55, []any{v52, v53}) + tmp57 := lang.Apply(tmp54, []any{v43, tmp56}) + return tmp57 + } + }) + tmp52, _ := lang.FieldOrMethod(tmp50, "AddMethod") + if reflect.TypeOf(tmp52).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("AddMethod is not a function"))) + } + tmp53 := lang.Apply(tmp52, []any{v2, tmp51}) + tmp36 = tmp53 + } // end let + return tmp36 + }) + tmp34 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(156), kw_column, int(14), kw_end_DASH_line, int(160), kw_end_DASH_column, int(45)) + tmp35, err := lang.WithMeta(tmp33, tmp34.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp36 := lang.Apply(tmp32, []any{tmp35, nil, v25}) + _ = tmp36 + var tmp37 any = v9 + var tmp38 any = v10 + var tmp39 any = v11 + tmp41 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp42 := lang.Apply(tmp41, []any{v12}) + var tmp40 any = tmp42 + v9 = tmp37 + v10 = tmp38 + v11 = tmp39 + v12 = tmp40 + continue + } // end let + tmp13 = tmp16 + } else { + var tmp17 any + { // let + // let binding "temp__0__auto__" + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := lang.Apply(tmp18, []any{v9}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + var tmp22 any + { // let + // let binding "seq_953" + var v23 any = v20 + _ = v23 + var tmp24 any + tmp25 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp26 := lang.Apply(tmp25, []any{v23}) + if lang.IsTruthy(tmp26) { + var tmp27 any + { // let + // let binding "c__0__auto__" + tmp28 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp29 := lang.Apply(tmp28, []any{v23}) + var v30 any = tmp29 + _ = v30 + tmp32 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp33 := lang.Apply(tmp32, []any{v23}) + var tmp31 any = tmp33 + var tmp34 any = v30 + tmp36 := checkDerefVar(var_glojure_DOT_core_int) + tmp37 := checkDerefVar(var_glojure_DOT_core_count) + tmp38 := lang.Apply(tmp37, []any{v30}) + tmp39 := lang.Apply(tmp36, []any{tmp38}) + var tmp35 any = tmp39 + tmp41 := checkDerefVar(var_glojure_DOT_core_int) + tmp42 := lang.Apply(tmp41, []any{int64(0)}) + var tmp40 any = tmp42 + v9 = tmp31 + v10 = tmp34 + v11 = tmp35 + v12 = tmp40 + continue + } // end let + tmp24 = tmp27 + } else { + var tmp28 any + { // let + // let binding "vec__964" + tmp29 := checkDerefVar(var_glojure_DOT_core_first) + tmp30 := lang.Apply(tmp29, []any{v23}) + var v31 any = tmp30 + _ = v31 + // let binding "proto" + tmp32 := checkDerefVar(var_glojure_DOT_core_nth) + tmp33 := lang.Apply(tmp32, []any{v31, int64(0), nil}) + var v34 any = tmp33 + _ = v34 + // let binding "mmap" + tmp35 := checkDerefVar(var_glojure_DOT_core_nth) + tmp36 := lang.Apply(tmp35, []any{v31, int64(1), nil}) + var v37 any = tmp36 + _ = v37 + var tmp38 any + tmp39 := checkDerefVar(var_glojure_DOT_core_protocol_QMARK_) + tmp40 := lang.Apply(tmp39, []any{v34}) + if lang.IsTruthy(tmp40) { + } else { + tmp41 := checkDerefVar(var_glojure_DOT_core_str) + tmp42 := lang.Apply(tmp41, []any{v34, " is not a protocol"}) + tmp43 := lang.Apply(errors5.New, []any{tmp42}) + panic(tmp43) + } + _ = tmp38 + tmp44 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp45 lang.FnFunc + tmp45 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v46 := args[0] + _ = v46 + v47 := args[1] + _ = v47 + var tmp48 any + { // let + // let binding "vec__968" + var v49 any = v47 + _ = v49 + // let binding "k" + tmp50 := checkDerefVar(var_glojure_DOT_core_nth) + tmp51 := lang.Apply(tmp50, []any{v49, int64(0), nil}) + var v52 any = tmp51 + _ = v52 + // let binding "v" + tmp53 := checkDerefVar(var_glojure_DOT_core_nth) + tmp54 := lang.Apply(tmp53, []any{v49, int64(1), nil}) + var v55 any = tmp54 + _ = v55 + tmp56 := checkDerefVar(var_glojure_DOT_core_get_DASH_in) + tmp57 := checkDerefVar(var_glojure_DOT_core_deref) + tmp58 := lang.Apply(tmp57, []any{v34}) + tmp59 := lang.NewVector(kw_multis, v52) + tmp60 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(158), kw_column, int(33), kw_end_DASH_line, int(158), kw_end_DASH_column, int(43)) + tmp61, err := lang.WithMeta(tmp59, tmp60.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp62 := lang.Apply(tmp56, []any{tmp58, tmp61}) + var tmp63 lang.FnFunc + tmp63 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v64 := args[0] + _ = v64 + var v65 any = lang.NewList(args[1:]...) + _ = v65 + tmp66 := checkDerefVar(var_glojure_DOT_core_apply) + tmp67 := checkDerefVar(var_glojure_DOT_core_cons) + tmp68 := lang.Apply(tmp67, []any{v64, v65}) + tmp69 := lang.Apply(tmp66, []any{v55, tmp68}) + return tmp69 + } + }) + tmp64, _ := lang.FieldOrMethod(tmp62, "AddMethod") + if reflect.TypeOf(tmp64).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("AddMethod is not a function"))) + } + tmp65 := lang.Apply(tmp64, []any{v2, tmp63}) + tmp48 = tmp65 + } // end let + return tmp48 + }) + tmp46 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(156), kw_column, int(14), kw_end_DASH_line, int(160), kw_end_DASH_column, int(45)) + tmp47, err := lang.WithMeta(tmp45, tmp46.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp48 := lang.Apply(tmp44, []any{tmp47, nil, v37}) + _ = tmp48 + tmp50 := checkDerefVar(var_glojure_DOT_core_next) + tmp51 := lang.Apply(tmp50, []any{v23}) + var tmp49 any = tmp51 + var tmp52 any = nil + var tmp53 any = int64(0) + var tmp54 any = int64(0) + v9 = tmp49 + v10 = tmp52 + v11 = tmp53 + v12 = tmp54 + continue + } // end let + tmp24 = tmp28 + } + tmp22 = tmp24 + } // end let + tmp21 = tmp22 + } else { + } + tmp17 = tmp21 + } // end let + tmp13 = tmp17 + } + tmp4 = tmp13 + break + } + } // end let + return tmp4 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_extend = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_extend.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // for + { + tmp0 := sym_for.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_seq_DASH_exprs, sym_body_DASH_expr)), kw_doc, "List comprehension. Takes a vector of one or more\n binding-form/collection-expr pairs, each followed by zero or more\n modifiers, and yields a lazy sequence of evaluations of expr.\n Collections are iterated in a nested fashion, rightmost fastest,\n and nested coll-exprs can refer to bindings created in prior\n binding-forms. Supported modifiers are: :let [binding-form expr ...],\n :while test, :when test.\n\n (take 100 (for [x (range 100000000) y (range 1000000) :while (< y x)] [x y]))", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(11), kw_line, int(4646), kw_end_DASH_line, int(4646))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v4}) + if lang.IsTruthy(tmp8) { + } else { + tmp9 := checkDerefVar(var_glojure_DOT_core_str) + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp13 := checkDerefVar(var_glojure_DOT_core_meta) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(kw_line, []any{tmp14}) + tmp16 := lang.Apply(tmp9, []any{tmp11, " requires ", "a vector for its binding", " in ", tmp12, ":", tmp15}) + tmp17 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp16}) + panic(tmp17) + } + _ = tmp6 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_even_QMARK_) + tmp20 := checkDerefVar(var_glojure_DOT_core_count) + tmp21 := lang.Apply(tmp20, []any{v4}) + tmp22 := lang.Apply(tmp19, []any{tmp21}) + if lang.IsTruthy(tmp22) { + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp27 := checkDerefVar(var_glojure_DOT_core_meta) + tmp28 := lang.Apply(tmp27, []any{v2}) + tmp29 := lang.Apply(kw_line, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp25, " requires ", "an even number of forms in binding vector", " in ", tmp26, ":", tmp29}) + tmp31 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp31) + } + _ = tmp18 + var tmp32 any + { // let + // let binding "to-groups" + var tmp33 lang.FnFunc + tmp33 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v34 := args[0] + _ = v34 + tmp35 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp36 lang.FnFunc + tmp36 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v37 := args[0] + _ = v37 + v38 := args[1] + _ = v38 + var tmp39 any + { // let + // let binding "vec__715" + var v40 any = v38 + _ = v40 + // let binding "k" + tmp41 := checkDerefVar(var_glojure_DOT_core_nth) + tmp42 := lang.Apply(tmp41, []any{v40, int64(0), nil}) + var v43 any = tmp42 + _ = v43 + // let binding "v" + tmp44 := checkDerefVar(var_glojure_DOT_core_nth) + tmp45 := lang.Apply(tmp44, []any{v40, int64(1), nil}) + var v46 any = tmp45 + _ = v46 + var tmp47 any + tmp48 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp49 := lang.Apply(tmp48, []any{v43}) + if lang.IsTruthy(tmp49) { + tmp50 := checkDerefVar(var_glojure_DOT_core_conj) + tmp51 := checkDerefVar(var_glojure_DOT_core_pop) + tmp52 := lang.Apply(tmp51, []any{v37}) + tmp53 := checkDerefVar(var_glojure_DOT_core_conj) + tmp54 := checkDerefVar(var_glojure_DOT_core_peek) + tmp55 := lang.Apply(tmp54, []any{v37}) + tmp56 := lang.NewVector(v43, v46) + tmp57 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4664), kw_column, int(72), kw_end_DASH_line, int(4664), kw_end_DASH_column, int(76)) + tmp58, err := lang.WithMeta(tmp56, tmp57.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp59 := lang.Apply(tmp53, []any{tmp55, tmp58}) + tmp60 := lang.Apply(tmp50, []any{tmp52, tmp59}) + tmp47 = tmp60 + } else { + tmp61 := checkDerefVar(var_glojure_DOT_core_conj) + tmp62 := lang.NewVector(v43, v46) + tmp63 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4665), kw_column, int(46), kw_end_DASH_line, int(4665), kw_end_DASH_column, int(50)) + tmp64, err := lang.WithMeta(tmp62, tmp63.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp65 := lang.Apply(tmp61, []any{v37, tmp64}) + tmp47 = tmp65 + } + tmp39 = tmp47 + } // end let + return tmp39 + }) + tmp37 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4662), kw_column, int(30), kw_end_DASH_line, int(4665), kw_end_DASH_column, int(53)) + tmp38, err := lang.WithMeta(tmp36, tmp37.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp39 := lang.NewVector() + tmp40 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4666), kw_column, int(29), kw_end_DASH_line, int(4666), kw_end_DASH_column, int(30)) + tmp41, err := lang.WithMeta(tmp39, tmp40.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp42 := checkDerefVar(var_glojure_DOT_core_partition) + tmp43 := lang.Apply(tmp42, []any{int64(2), v34}) + tmp44 := lang.Apply(tmp35, []any{tmp38, tmp41, tmp43}) + return tmp44 + }) + tmp34 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4661), kw_column, int(19), kw_end_DASH_line, int(4666), kw_end_DASH_column, int(56)) + tmp35, err := lang.WithMeta(tmp33, tmp34.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v36 any = tmp35 + _ = v36 + // let binding "err" + var tmp37 lang.FnFunc + tmp37 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v38 any = lang.NewList(args[0:]...) + _ = v38 + tmp39 := checkDerefVar(var_glojure_DOT_core_apply) + tmp40 := checkDerefVar(var_glojure_DOT_core_str) + tmp41 := lang.Apply(tmp39, []any{tmp40, v38}) + tmp42 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp41}) + panic(tmp42) + } + }) + tmp38 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4667), kw_column, int(13), kw_end_DASH_line, int(4667), kw_end_DASH_column, int(125)) + tmp39, err := lang.WithMeta(tmp37, tmp38.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v40 any = tmp39 + _ = v40 + // let binding "emit-bind" + var tmp41 lang.FnFunc + { // function emit-bind + var v42 lang.FnFunc + tmp41 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v43 := args[0] + _ = v43 + var tmp44 any + { // let + // let binding "vec__719" + var v45 any = v43 + _ = v45 + // let binding "seq__720" + tmp46 := checkDerefVar(var_glojure_DOT_core_seq) + tmp47 := lang.Apply(tmp46, []any{v45}) + var v48 any = tmp47 + _ = v48 + // let binding "first__721" + tmp49 := checkDerefVar(var_glojure_DOT_core_first) + tmp50 := lang.Apply(tmp49, []any{v48}) + var v51 any = tmp50 + _ = v51 + // let binding "seq__720" + tmp52 := checkDerefVar(var_glojure_DOT_core_next) + tmp53 := lang.Apply(tmp52, []any{v48}) + var v54 any = tmp53 + _ = v54 + // let binding "vec__722" + var v55 any = v51 + _ = v55 + // let binding "seq__723" + tmp56 := checkDerefVar(var_glojure_DOT_core_seq) + tmp57 := lang.Apply(tmp56, []any{v55}) + var v58 any = tmp57 + _ = v58 + // let binding "first__724" + tmp59 := checkDerefVar(var_glojure_DOT_core_first) + tmp60 := lang.Apply(tmp59, []any{v58}) + var v61 any = tmp60 + _ = v61 + // let binding "seq__723" + tmp62 := checkDerefVar(var_glojure_DOT_core_next) + tmp63 := lang.Apply(tmp62, []any{v58}) + var v64 any = tmp63 + _ = v64 + // let binding "bind" + var v65 any = v61 + _ = v65 + // let binding "first__724" + tmp66 := checkDerefVar(var_glojure_DOT_core_first) + tmp67 := lang.Apply(tmp66, []any{v64}) + var v68 any = tmp67 + _ = v68 + // let binding "seq__723" + tmp69 := checkDerefVar(var_glojure_DOT_core_next) + tmp70 := lang.Apply(tmp69, []any{v64}) + var v71 any = tmp70 + _ = v71 + // let binding "expr" + var v72 any = v68 + _ = v72 + // let binding "mod-pairs" + var v73 any = v71 + _ = v73 + // let binding "vec__725" + var v74 any = v54 + _ = v74 + // let binding "vec__728" + tmp75 := checkDerefVar(var_glojure_DOT_core_nth) + tmp76 := lang.Apply(tmp75, []any{v74, int64(0), nil}) + var v77 any = tmp76 + _ = v77 + // let binding "_" + tmp78 := checkDerefVar(var_glojure_DOT_core_nth) + tmp79 := lang.Apply(tmp78, []any{v77, int64(0), nil}) + var v80 any = tmp79 + _ = v80 + // let binding "next-expr" + tmp81 := checkDerefVar(var_glojure_DOT_core_nth) + tmp82 := lang.Apply(tmp81, []any{v77, int64(1), nil}) + var v83 any = tmp82 + _ = v83 + // let binding "next-groups" + var v84 any = v74 + _ = v84 + var tmp85 any + { // let + // let binding "giter" + tmp86 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp87 := lang.Apply(tmp86, []any{"iter__"}) + var v88 any = tmp87 + _ = v88 + // let binding "gxs" + tmp89 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp90 := lang.Apply(tmp89, []any{"s__"}) + var v91 any = tmp90 + _ = v91 + // let binding "do-mod" + var tmp92 lang.FnFunc + { // function do-mod + var v93 lang.FnFunc + tmp92 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v94 := args[0] + _ = v94 + var tmp95 any + { // let + // let binding "vec__732" + var v96 any = v94 + _ = v96 + // let binding "seq__733" + tmp97 := checkDerefVar(var_glojure_DOT_core_seq) + tmp98 := lang.Apply(tmp97, []any{v96}) + var v99 any = tmp98 + _ = v99 + // let binding "first__734" + tmp100 := checkDerefVar(var_glojure_DOT_core_first) + tmp101 := lang.Apply(tmp100, []any{v99}) + var v102 any = tmp101 + _ = v102 + // let binding "seq__733" + tmp103 := checkDerefVar(var_glojure_DOT_core_next) + tmp104 := lang.Apply(tmp103, []any{v99}) + var v105 any = tmp104 + _ = v105 + // let binding "vec__735" + var v106 any = v102 + _ = v106 + // let binding "k" + tmp107 := checkDerefVar(var_glojure_DOT_core_nth) + tmp108 := lang.Apply(tmp107, []any{v106, int64(0), nil}) + var v109 any = tmp108 + _ = v109 + // let binding "v" + tmp110 := checkDerefVar(var_glojure_DOT_core_nth) + tmp111 := lang.Apply(tmp110, []any{v106, int64(1), nil}) + var v112 any = tmp111 + _ = v112 + // let binding "pair" + var v113 any = v106 + _ = v113 + // let binding "etc" + var v114 any = v105 + _ = v114 + var tmp115 any + tmp116 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp117 := lang.Apply(tmp116, []any{v109, kw_let}) + if lang.IsTruthy(tmp117) { + tmp118 := checkDerefVar(var_glojure_DOT_core_seq) + tmp119 := checkDerefVar(var_glojure_DOT_core_concat) + tmp120 := checkDerefVar(var_glojure_DOT_core_list) + tmp121 := lang.Apply(tmp120, []any{sym_glojure_DOT_core_SLASH_let}) + tmp122 := checkDerefVar(var_glojure_DOT_core_list) + tmp123 := lang.Apply(tmp122, []any{v112}) + tmp124 := checkDerefVar(var_glojure_DOT_core_list) + tmp125 := lang.Apply(v93, []any{v114}) + tmp126 := lang.Apply(tmp124, []any{tmp125}) + tmp127 := lang.Apply(tmp119, []any{tmp121, tmp123, tmp126}) + tmp128 := lang.Apply(tmp118, []any{tmp127}) + tmp115 = tmp128 + } else { + var tmp129 any + tmp130 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp131 := lang.Apply(tmp130, []any{v109, kw_while}) + if lang.IsTruthy(tmp131) { + tmp132 := checkDerefVar(var_glojure_DOT_core_seq) + tmp133 := checkDerefVar(var_glojure_DOT_core_concat) + tmp134 := checkDerefVar(var_glojure_DOT_core_list) + tmp135 := lang.Apply(tmp134, []any{sym_glojure_DOT_core_SLASH_when}) + tmp136 := checkDerefVar(var_glojure_DOT_core_list) + tmp137 := lang.Apply(tmp136, []any{v112}) + tmp138 := checkDerefVar(var_glojure_DOT_core_list) + tmp139 := lang.Apply(v93, []any{v114}) + tmp140 := lang.Apply(tmp138, []any{tmp139}) + tmp141 := lang.Apply(tmp133, []any{tmp135, tmp137, tmp140}) + tmp142 := lang.Apply(tmp132, []any{tmp141}) + tmp129 = tmp142 + } else { + var tmp143 any + tmp144 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp145 := lang.Apply(tmp144, []any{v109, kw_when}) + if lang.IsTruthy(tmp145) { + tmp146 := checkDerefVar(var_glojure_DOT_core_seq) + tmp147 := checkDerefVar(var_glojure_DOT_core_concat) + tmp148 := checkDerefVar(var_glojure_DOT_core_list) + tmp149 := lang.Apply(tmp148, []any{sym_if}) + tmp150 := checkDerefVar(var_glojure_DOT_core_list) + tmp151 := lang.Apply(tmp150, []any{v112}) + tmp152 := checkDerefVar(var_glojure_DOT_core_list) + tmp153 := lang.Apply(v93, []any{v114}) + tmp154 := lang.Apply(tmp152, []any{tmp153}) + tmp155 := checkDerefVar(var_glojure_DOT_core_list) + tmp156 := checkDerefVar(var_glojure_DOT_core_seq) + tmp157 := checkDerefVar(var_glojure_DOT_core_concat) + tmp158 := checkDerefVar(var_glojure_DOT_core_list) + tmp159 := lang.Apply(tmp158, []any{sym_recur}) + tmp160 := checkDerefVar(var_glojure_DOT_core_list) + tmp161 := checkDerefVar(var_glojure_DOT_core_seq) + tmp162 := checkDerefVar(var_glojure_DOT_core_concat) + tmp163 := checkDerefVar(var_glojure_DOT_core_list) + tmp164 := lang.Apply(tmp163, []any{sym_glojure_DOT_core_SLASH_rest}) + tmp165 := checkDerefVar(var_glojure_DOT_core_list) + tmp166 := lang.Apply(tmp165, []any{v91}) + tmp167 := lang.Apply(tmp162, []any{tmp164, tmp166}) + tmp168 := lang.Apply(tmp161, []any{tmp167}) + tmp169 := lang.Apply(tmp160, []any{tmp168}) + tmp170 := lang.Apply(tmp157, []any{tmp159, tmp169}) + tmp171 := lang.Apply(tmp156, []any{tmp170}) + tmp172 := lang.Apply(tmp155, []any{tmp171}) + tmp173 := lang.Apply(tmp147, []any{tmp149, tmp151, tmp154, tmp172}) + tmp174 := lang.Apply(tmp146, []any{tmp173}) + tmp143 = tmp174 + } else { + var tmp175 any + tmp176 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp177 := lang.Apply(tmp176, []any{v109}) + if lang.IsTruthy(tmp177) { + tmp178 := lang.Apply(v40, []any{"Invalid 'for' keyword ", v109}) + tmp175 = tmp178 + } else { + var tmp179 any + if lang.IsTruthy(v84) { + tmp180 := checkDerefVar(var_glojure_DOT_core_seq) + tmp181 := checkDerefVar(var_glojure_DOT_core_concat) + tmp182 := checkDerefVar(var_glojure_DOT_core_list) + tmp183 := lang.Apply(tmp182, []any{sym_glojure_DOT_core_SLASH_let}) + tmp184 := checkDerefVar(var_glojure_DOT_core_list) + tmp185 := checkDerefVar(var_glojure_DOT_core_apply) + tmp186 := checkDerefVar(var_glojure_DOT_core_vector) + tmp187 := checkDerefVar(var_glojure_DOT_core_seq) + tmp188 := checkDerefVar(var_glojure_DOT_core_concat) + tmp189 := checkDerefVar(var_glojure_DOT_core_list) + tmp190 := lang.Apply(tmp189, []any{sym_iterys__0__auto__}) + tmp191 := checkDerefVar(var_glojure_DOT_core_list) + tmp192 := lang.Apply(v42, []any{v84}) + tmp193 := lang.Apply(tmp191, []any{tmp192}) + tmp194 := checkDerefVar(var_glojure_DOT_core_list) + tmp195 := lang.Apply(tmp194, []any{sym_fs__1__auto__}) + tmp196 := checkDerefVar(var_glojure_DOT_core_list) + tmp197 := checkDerefVar(var_glojure_DOT_core_seq) + tmp198 := checkDerefVar(var_glojure_DOT_core_concat) + tmp199 := checkDerefVar(var_glojure_DOT_core_list) + tmp200 := lang.Apply(tmp199, []any{sym_glojure_DOT_core_SLASH_seq}) + tmp201 := checkDerefVar(var_glojure_DOT_core_list) + tmp202 := checkDerefVar(var_glojure_DOT_core_seq) + tmp203 := checkDerefVar(var_glojure_DOT_core_concat) + tmp204 := checkDerefVar(var_glojure_DOT_core_list) + tmp205 := lang.Apply(tmp204, []any{sym_iterys__0__auto__}) + tmp206 := checkDerefVar(var_glojure_DOT_core_list) + tmp207 := lang.Apply(tmp206, []any{v83}) + tmp208 := lang.Apply(tmp203, []any{tmp205, tmp207}) + tmp209 := lang.Apply(tmp202, []any{tmp208}) + tmp210 := lang.Apply(tmp201, []any{tmp209}) + tmp211 := lang.Apply(tmp198, []any{tmp200, tmp210}) + tmp212 := lang.Apply(tmp197, []any{tmp211}) + tmp213 := lang.Apply(tmp196, []any{tmp212}) + tmp214 := lang.Apply(tmp188, []any{tmp190, tmp193, tmp195, tmp213}) + tmp215 := lang.Apply(tmp187, []any{tmp214}) + tmp216 := lang.Apply(tmp185, []any{tmp186, tmp215}) + tmp217 := lang.Apply(tmp184, []any{tmp216}) + tmp218 := checkDerefVar(var_glojure_DOT_core_list) + tmp219 := checkDerefVar(var_glojure_DOT_core_seq) + tmp220 := checkDerefVar(var_glojure_DOT_core_concat) + tmp221 := checkDerefVar(var_glojure_DOT_core_list) + tmp222 := lang.Apply(tmp221, []any{sym_if}) + tmp223 := checkDerefVar(var_glojure_DOT_core_list) + tmp224 := lang.Apply(tmp223, []any{sym_fs__1__auto__}) + tmp225 := checkDerefVar(var_glojure_DOT_core_list) + tmp226 := checkDerefVar(var_glojure_DOT_core_seq) + tmp227 := checkDerefVar(var_glojure_DOT_core_concat) + tmp228 := checkDerefVar(var_glojure_DOT_core_list) + tmp229 := lang.Apply(tmp228, []any{sym_glojure_DOT_core_SLASH_concat}) + tmp230 := checkDerefVar(var_glojure_DOT_core_list) + tmp231 := lang.Apply(tmp230, []any{sym_fs__1__auto__}) + tmp232 := checkDerefVar(var_glojure_DOT_core_list) + tmp233 := checkDerefVar(var_glojure_DOT_core_seq) + tmp234 := checkDerefVar(var_glojure_DOT_core_concat) + tmp235 := checkDerefVar(var_glojure_DOT_core_list) + tmp236 := lang.Apply(tmp235, []any{v88}) + tmp237 := checkDerefVar(var_glojure_DOT_core_list) + tmp238 := checkDerefVar(var_glojure_DOT_core_seq) + tmp239 := checkDerefVar(var_glojure_DOT_core_concat) + tmp240 := checkDerefVar(var_glojure_DOT_core_list) + tmp241 := lang.Apply(tmp240, []any{sym_glojure_DOT_core_SLASH_rest}) + tmp242 := checkDerefVar(var_glojure_DOT_core_list) + tmp243 := lang.Apply(tmp242, []any{v91}) + tmp244 := lang.Apply(tmp239, []any{tmp241, tmp243}) + tmp245 := lang.Apply(tmp238, []any{tmp244}) + tmp246 := lang.Apply(tmp237, []any{tmp245}) + tmp247 := lang.Apply(tmp234, []any{tmp236, tmp246}) + tmp248 := lang.Apply(tmp233, []any{tmp247}) + tmp249 := lang.Apply(tmp232, []any{tmp248}) + tmp250 := lang.Apply(tmp227, []any{tmp229, tmp231, tmp249}) + tmp251 := lang.Apply(tmp226, []any{tmp250}) + tmp252 := lang.Apply(tmp225, []any{tmp251}) + tmp253 := checkDerefVar(var_glojure_DOT_core_list) + tmp254 := checkDerefVar(var_glojure_DOT_core_seq) + tmp255 := checkDerefVar(var_glojure_DOT_core_concat) + tmp256 := checkDerefVar(var_glojure_DOT_core_list) + tmp257 := lang.Apply(tmp256, []any{sym_recur}) + tmp258 := checkDerefVar(var_glojure_DOT_core_list) + tmp259 := checkDerefVar(var_glojure_DOT_core_seq) + tmp260 := checkDerefVar(var_glojure_DOT_core_concat) + tmp261 := checkDerefVar(var_glojure_DOT_core_list) + tmp262 := lang.Apply(tmp261, []any{sym_glojure_DOT_core_SLASH_rest}) + tmp263 := checkDerefVar(var_glojure_DOT_core_list) + tmp264 := lang.Apply(tmp263, []any{v91}) + tmp265 := lang.Apply(tmp260, []any{tmp262, tmp264}) + tmp266 := lang.Apply(tmp259, []any{tmp265}) + tmp267 := lang.Apply(tmp258, []any{tmp266}) + tmp268 := lang.Apply(tmp255, []any{tmp257, tmp267}) + tmp269 := lang.Apply(tmp254, []any{tmp268}) + tmp270 := lang.Apply(tmp253, []any{tmp269}) + tmp271 := lang.Apply(tmp220, []any{tmp222, tmp224, tmp252, tmp270}) + tmp272 := lang.Apply(tmp219, []any{tmp271}) + tmp273 := lang.Apply(tmp218, []any{tmp272}) + tmp274 := lang.Apply(tmp181, []any{tmp183, tmp217, tmp273}) + tmp275 := lang.Apply(tmp180, []any{tmp274}) + tmp179 = tmp275 + } else { + var tmp276 any + if lang.IsTruthy(kw_else) { + tmp277 := checkDerefVar(var_glojure_DOT_core_seq) + tmp278 := checkDerefVar(var_glojure_DOT_core_concat) + tmp279 := checkDerefVar(var_glojure_DOT_core_list) + tmp280 := lang.Apply(tmp279, []any{sym_glojure_DOT_core_SLASH_cons}) + tmp281 := checkDerefVar(var_glojure_DOT_core_list) + tmp282 := lang.Apply(tmp281, []any{v5}) + tmp283 := checkDerefVar(var_glojure_DOT_core_list) + tmp284 := checkDerefVar(var_glojure_DOT_core_seq) + tmp285 := checkDerefVar(var_glojure_DOT_core_concat) + tmp286 := checkDerefVar(var_glojure_DOT_core_list) + tmp287 := lang.Apply(tmp286, []any{v88}) + tmp288 := checkDerefVar(var_glojure_DOT_core_list) + tmp289 := checkDerefVar(var_glojure_DOT_core_seq) + tmp290 := checkDerefVar(var_glojure_DOT_core_concat) + tmp291 := checkDerefVar(var_glojure_DOT_core_list) + tmp292 := lang.Apply(tmp291, []any{sym_glojure_DOT_core_SLASH_rest}) + tmp293 := checkDerefVar(var_glojure_DOT_core_list) + tmp294 := lang.Apply(tmp293, []any{v91}) + tmp295 := lang.Apply(tmp290, []any{tmp292, tmp294}) + tmp296 := lang.Apply(tmp289, []any{tmp295}) + tmp297 := lang.Apply(tmp288, []any{tmp296}) + tmp298 := lang.Apply(tmp285, []any{tmp287, tmp297}) + tmp299 := lang.Apply(tmp284, []any{tmp298}) + tmp300 := lang.Apply(tmp283, []any{tmp299}) + tmp301 := lang.Apply(tmp278, []any{tmp280, tmp282, tmp300}) + tmp302 := lang.Apply(tmp277, []any{tmp301}) + tmp276 = tmp302 + } else { + } + tmp179 = tmp276 + } + tmp175 = tmp179 + } + tmp143 = tmp175 + } + tmp129 = tmp143 + } + tmp115 = tmp129 + } + tmp95 = tmp115 + } // end let + return tmp95 + }) + v93 = tmp92 + _ = v93 + } + tmp93 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4672), kw_column, int(34), kw_end_DASH_line, int(4687), kw_end_DASH_column, int(73)) + tmp94, err := lang.WithMeta(tmp92, tmp93.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v95 any = tmp94 + _ = v95 + var tmp96 any + if lang.IsTruthy(v84) { + tmp97 := checkDerefVar(var_glojure_DOT_core_seq) + tmp98 := checkDerefVar(var_glojure_DOT_core_concat) + tmp99 := checkDerefVar(var_glojure_DOT_core_list) + tmp100 := lang.Apply(tmp99, []any{sym_glojure_DOT_core_SLASH_fn}) + tmp101 := checkDerefVar(var_glojure_DOT_core_list) + tmp102 := lang.Apply(tmp101, []any{v88}) + tmp103 := checkDerefVar(var_glojure_DOT_core_list) + tmp104 := checkDerefVar(var_glojure_DOT_core_apply) + tmp105 := checkDerefVar(var_glojure_DOT_core_vector) + tmp106 := checkDerefVar(var_glojure_DOT_core_seq) + tmp107 := checkDerefVar(var_glojure_DOT_core_concat) + tmp108 := checkDerefVar(var_glojure_DOT_core_list) + tmp109 := lang.Apply(tmp108, []any{v91}) + tmp110 := lang.Apply(tmp107, []any{tmp109}) + tmp111 := lang.Apply(tmp106, []any{tmp110}) + tmp112 := lang.Apply(tmp104, []any{tmp105, tmp111}) + tmp113 := lang.Apply(tmp103, []any{tmp112}) + tmp114 := checkDerefVar(var_glojure_DOT_core_list) + tmp115 := checkDerefVar(var_glojure_DOT_core_seq) + tmp116 := checkDerefVar(var_glojure_DOT_core_concat) + tmp117 := checkDerefVar(var_glojure_DOT_core_list) + tmp118 := lang.Apply(tmp117, []any{sym_glojure_DOT_core_SLASH_lazy_DASH_seq}) + tmp119 := checkDerefVar(var_glojure_DOT_core_list) + tmp120 := checkDerefVar(var_glojure_DOT_core_seq) + tmp121 := checkDerefVar(var_glojure_DOT_core_concat) + tmp122 := checkDerefVar(var_glojure_DOT_core_list) + tmp123 := lang.Apply(tmp122, []any{sym_glojure_DOT_core_SLASH_loop}) + tmp124 := checkDerefVar(var_glojure_DOT_core_list) + tmp125 := checkDerefVar(var_glojure_DOT_core_apply) + tmp126 := checkDerefVar(var_glojure_DOT_core_vector) + tmp127 := checkDerefVar(var_glojure_DOT_core_seq) + tmp128 := checkDerefVar(var_glojure_DOT_core_concat) + tmp129 := checkDerefVar(var_glojure_DOT_core_list) + tmp130 := lang.Apply(tmp129, []any{v91}) + tmp131 := checkDerefVar(var_glojure_DOT_core_list) + tmp132 := lang.Apply(tmp131, []any{v91}) + tmp133 := lang.Apply(tmp128, []any{tmp130, tmp132}) + tmp134 := lang.Apply(tmp127, []any{tmp133}) + tmp135 := lang.Apply(tmp125, []any{tmp126, tmp134}) + tmp136 := lang.Apply(tmp124, []any{tmp135}) + tmp137 := checkDerefVar(var_glojure_DOT_core_list) + tmp138 := checkDerefVar(var_glojure_DOT_core_seq) + tmp139 := checkDerefVar(var_glojure_DOT_core_concat) + tmp140 := checkDerefVar(var_glojure_DOT_core_list) + tmp141 := lang.Apply(tmp140, []any{sym_glojure_DOT_core_SLASH_when_DASH_first}) + tmp142 := checkDerefVar(var_glojure_DOT_core_list) + tmp143 := checkDerefVar(var_glojure_DOT_core_apply) + tmp144 := checkDerefVar(var_glojure_DOT_core_vector) + tmp145 := checkDerefVar(var_glojure_DOT_core_seq) + tmp146 := checkDerefVar(var_glojure_DOT_core_concat) + tmp147 := checkDerefVar(var_glojure_DOT_core_list) + tmp148 := lang.Apply(tmp147, []any{v65}) + tmp149 := checkDerefVar(var_glojure_DOT_core_list) + tmp150 := lang.Apply(tmp149, []any{v91}) + tmp151 := lang.Apply(tmp146, []any{tmp148, tmp150}) + tmp152 := lang.Apply(tmp145, []any{tmp151}) + tmp153 := lang.Apply(tmp143, []any{tmp144, tmp152}) + tmp154 := lang.Apply(tmp142, []any{tmp153}) + tmp155 := checkDerefVar(var_glojure_DOT_core_list) + tmp156 := lang.Apply(v95, []any{v73}) + tmp157 := lang.Apply(tmp155, []any{tmp156}) + tmp158 := lang.Apply(tmp139, []any{tmp141, tmp154, tmp157}) + tmp159 := lang.Apply(tmp138, []any{tmp158}) + tmp160 := lang.Apply(tmp137, []any{tmp159}) + tmp161 := lang.Apply(tmp121, []any{tmp123, tmp136, tmp160}) + tmp162 := lang.Apply(tmp120, []any{tmp161}) + tmp163 := lang.Apply(tmp119, []any{tmp162}) + tmp164 := lang.Apply(tmp116, []any{tmp118, tmp163}) + tmp165 := lang.Apply(tmp115, []any{tmp164}) + tmp166 := lang.Apply(tmp114, []any{tmp165}) + tmp167 := lang.Apply(tmp98, []any{tmp100, tmp102, tmp113, tmp166}) + tmp168 := lang.Apply(tmp97, []any{tmp167}) + tmp96 = tmp168 + } else { + var tmp169 any + { // let + // let binding "gi" + tmp170 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp171 := lang.Apply(tmp170, []any{"i__"}) + var v172 any = tmp171 + _ = v172 + // let binding "gb" + tmp173 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp174 := lang.Apply(tmp173, []any{"b__"}) + var v175 any = tmp174 + _ = v175 + // let binding "do-cmod" + var tmp176 lang.FnFunc + { // function do-cmod + var v177 lang.FnFunc + tmp176 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v178 := args[0] + _ = v178 + var tmp179 any + { // let + // let binding "vec__739" + var v180 any = v178 + _ = v180 + // let binding "seq__740" + tmp181 := checkDerefVar(var_glojure_DOT_core_seq) + tmp182 := lang.Apply(tmp181, []any{v180}) + var v183 any = tmp182 + _ = v183 + // let binding "first__741" + tmp184 := checkDerefVar(var_glojure_DOT_core_first) + tmp185 := lang.Apply(tmp184, []any{v183}) + var v186 any = tmp185 + _ = v186 + // let binding "seq__740" + tmp187 := checkDerefVar(var_glojure_DOT_core_next) + tmp188 := lang.Apply(tmp187, []any{v183}) + var v189 any = tmp188 + _ = v189 + // let binding "vec__742" + var v190 any = v186 + _ = v190 + // let binding "k" + tmp191 := checkDerefVar(var_glojure_DOT_core_nth) + tmp192 := lang.Apply(tmp191, []any{v190, int64(0), nil}) + var v193 any = tmp192 + _ = v193 + // let binding "v" + tmp194 := checkDerefVar(var_glojure_DOT_core_nth) + tmp195 := lang.Apply(tmp194, []any{v190, int64(1), nil}) + var v196 any = tmp195 + _ = v196 + // let binding "pair" + var v197 any = v190 + _ = v197 + // let binding "etc" + var v198 any = v189 + _ = v198 + var tmp199 any + tmp200 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp201 := lang.Apply(tmp200, []any{v193, kw_let}) + if lang.IsTruthy(tmp201) { + tmp202 := checkDerefVar(var_glojure_DOT_core_seq) + tmp203 := checkDerefVar(var_glojure_DOT_core_concat) + tmp204 := checkDerefVar(var_glojure_DOT_core_list) + tmp205 := lang.Apply(tmp204, []any{sym_glojure_DOT_core_SLASH_let}) + tmp206 := checkDerefVar(var_glojure_DOT_core_list) + tmp207 := lang.Apply(tmp206, []any{v196}) + tmp208 := checkDerefVar(var_glojure_DOT_core_list) + tmp209 := lang.Apply(v177, []any{v198}) + tmp210 := lang.Apply(tmp208, []any{tmp209}) + tmp211 := lang.Apply(tmp203, []any{tmp205, tmp207, tmp210}) + tmp212 := lang.Apply(tmp202, []any{tmp211}) + tmp199 = tmp212 + } else { + var tmp213 any + tmp214 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp215 := lang.Apply(tmp214, []any{v193, kw_while}) + if lang.IsTruthy(tmp215) { + tmp216 := checkDerefVar(var_glojure_DOT_core_seq) + tmp217 := checkDerefVar(var_glojure_DOT_core_concat) + tmp218 := checkDerefVar(var_glojure_DOT_core_list) + tmp219 := lang.Apply(tmp218, []any{sym_glojure_DOT_core_SLASH_when}) + tmp220 := checkDerefVar(var_glojure_DOT_core_list) + tmp221 := lang.Apply(tmp220, []any{v196}) + tmp222 := checkDerefVar(var_glojure_DOT_core_list) + tmp223 := lang.Apply(v177, []any{v198}) + tmp224 := lang.Apply(tmp222, []any{tmp223}) + tmp225 := lang.Apply(tmp217, []any{tmp219, tmp221, tmp224}) + tmp226 := lang.Apply(tmp216, []any{tmp225}) + tmp213 = tmp226 + } else { + var tmp227 any + tmp228 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp229 := lang.Apply(tmp228, []any{v193, kw_when}) + if lang.IsTruthy(tmp229) { + tmp230 := checkDerefVar(var_glojure_DOT_core_seq) + tmp231 := checkDerefVar(var_glojure_DOT_core_concat) + tmp232 := checkDerefVar(var_glojure_DOT_core_list) + tmp233 := lang.Apply(tmp232, []any{sym_if}) + tmp234 := checkDerefVar(var_glojure_DOT_core_list) + tmp235 := lang.Apply(tmp234, []any{v196}) + tmp236 := checkDerefVar(var_glojure_DOT_core_list) + tmp237 := lang.Apply(v177, []any{v198}) + tmp238 := lang.Apply(tmp236, []any{tmp237}) + tmp239 := checkDerefVar(var_glojure_DOT_core_list) + tmp240 := checkDerefVar(var_glojure_DOT_core_seq) + tmp241 := checkDerefVar(var_glojure_DOT_core_concat) + tmp242 := checkDerefVar(var_glojure_DOT_core_list) + tmp243 := lang.Apply(tmp242, []any{sym_recur}) + tmp244 := checkDerefVar(var_glojure_DOT_core_list) + tmp245 := checkDerefVar(var_glojure_DOT_core_seq) + tmp246 := checkDerefVar(var_glojure_DOT_core_concat) + tmp247 := checkDerefVar(var_glojure_DOT_core_list) + tmp248 := lang.Apply(tmp247, []any{sym_glojure_DOT_core_SLASH_unchecked_DASH_inc}) + tmp249 := checkDerefVar(var_glojure_DOT_core_list) + tmp250 := lang.Apply(tmp249, []any{v172}) + tmp251 := lang.Apply(tmp246, []any{tmp248, tmp250}) + tmp252 := lang.Apply(tmp245, []any{tmp251}) + tmp253 := lang.Apply(tmp244, []any{tmp252}) + tmp254 := lang.Apply(tmp241, []any{tmp243, tmp253}) + tmp255 := lang.Apply(tmp240, []any{tmp254}) + tmp256 := lang.Apply(tmp239, []any{tmp255}) + tmp257 := lang.Apply(tmp231, []any{tmp233, tmp235, tmp238, tmp256}) + tmp258 := lang.Apply(tmp230, []any{tmp257}) + tmp227 = tmp258 + } else { + var tmp259 any + tmp260 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp261 := lang.Apply(tmp260, []any{v193}) + if lang.IsTruthy(tmp261) { + tmp262 := lang.Apply(v40, []any{"Invalid 'for' keyword ", v193}) + tmp259 = tmp262 + } else { + var tmp263 any + if lang.IsTruthy(kw_else) { + tmp264 := checkDerefVar(var_glojure_DOT_core_seq) + tmp265 := checkDerefVar(var_glojure_DOT_core_concat) + tmp266 := checkDerefVar(var_glojure_DOT_core_list) + tmp267 := lang.Apply(tmp266, []any{sym_do}) + tmp268 := checkDerefVar(var_glojure_DOT_core_list) + tmp269 := checkDerefVar(var_glojure_DOT_core_seq) + tmp270 := checkDerefVar(var_glojure_DOT_core_concat) + tmp271 := checkDerefVar(var_glojure_DOT_core_list) + tmp272 := lang.Apply(tmp271, []any{sym_glojure_DOT_core_SLASH_chunk_DASH_append}) + tmp273 := checkDerefVar(var_glojure_DOT_core_list) + tmp274 := lang.Apply(tmp273, []any{v175}) + tmp275 := checkDerefVar(var_glojure_DOT_core_list) + tmp276 := lang.Apply(tmp275, []any{v5}) + tmp277 := lang.Apply(tmp270, []any{tmp272, tmp274, tmp276}) + tmp278 := lang.Apply(tmp269, []any{tmp277}) + tmp279 := lang.Apply(tmp268, []any{tmp278}) + tmp280 := checkDerefVar(var_glojure_DOT_core_list) + tmp281 := checkDerefVar(var_glojure_DOT_core_seq) + tmp282 := checkDerefVar(var_glojure_DOT_core_concat) + tmp283 := checkDerefVar(var_glojure_DOT_core_list) + tmp284 := lang.Apply(tmp283, []any{sym_recur}) + tmp285 := checkDerefVar(var_glojure_DOT_core_list) + tmp286 := checkDerefVar(var_glojure_DOT_core_seq) + tmp287 := checkDerefVar(var_glojure_DOT_core_concat) + tmp288 := checkDerefVar(var_glojure_DOT_core_list) + tmp289 := lang.Apply(tmp288, []any{sym_glojure_DOT_core_SLASH_unchecked_DASH_inc}) + tmp290 := checkDerefVar(var_glojure_DOT_core_list) + tmp291 := lang.Apply(tmp290, []any{v172}) + tmp292 := lang.Apply(tmp287, []any{tmp289, tmp291}) + tmp293 := lang.Apply(tmp286, []any{tmp292}) + tmp294 := lang.Apply(tmp285, []any{tmp293}) + tmp295 := lang.Apply(tmp282, []any{tmp284, tmp294}) + tmp296 := lang.Apply(tmp281, []any{tmp295}) + tmp297 := lang.Apply(tmp280, []any{tmp296}) + tmp298 := lang.Apply(tmp265, []any{tmp267, tmp279, tmp297}) + tmp299 := lang.Apply(tmp264, []any{tmp298}) + tmp263 = tmp299 + } else { + } + tmp259 = tmp263 + } + tmp227 = tmp259 + } + tmp213 = tmp227 + } + tmp199 = tmp213 + } + tmp179 = tmp199 + } // end let + return tmp179 + }) + v177 = tmp176 + _ = v177 + } + tmp177 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4698), kw_column, int(39), kw_end_DASH_line, int(4710), kw_end_DASH_column, int(79)) + tmp178, err := lang.WithMeta(tmp176, tmp177.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v179 any = tmp178 + _ = v179 + tmp180 := checkDerefVar(var_glojure_DOT_core_seq) + tmp181 := checkDerefVar(var_glojure_DOT_core_concat) + tmp182 := checkDerefVar(var_glojure_DOT_core_list) + tmp183 := lang.Apply(tmp182, []any{sym_glojure_DOT_core_SLASH_fn}) + tmp184 := checkDerefVar(var_glojure_DOT_core_list) + tmp185 := lang.Apply(tmp184, []any{v88}) + tmp186 := checkDerefVar(var_glojure_DOT_core_list) + tmp187 := checkDerefVar(var_glojure_DOT_core_apply) + tmp188 := checkDerefVar(var_glojure_DOT_core_vector) + tmp189 := checkDerefVar(var_glojure_DOT_core_seq) + tmp190 := checkDerefVar(var_glojure_DOT_core_concat) + tmp191 := checkDerefVar(var_glojure_DOT_core_list) + tmp192 := lang.Apply(tmp191, []any{v91}) + tmp193 := lang.Apply(tmp190, []any{tmp192}) + tmp194 := lang.Apply(tmp189, []any{tmp193}) + tmp195 := lang.Apply(tmp187, []any{tmp188, tmp194}) + tmp196 := lang.Apply(tmp186, []any{tmp195}) + tmp197 := checkDerefVar(var_glojure_DOT_core_list) + tmp198 := checkDerefVar(var_glojure_DOT_core_seq) + tmp199 := checkDerefVar(var_glojure_DOT_core_concat) + tmp200 := checkDerefVar(var_glojure_DOT_core_list) + tmp201 := lang.Apply(tmp200, []any{sym_glojure_DOT_core_SLASH_lazy_DASH_seq}) + tmp202 := checkDerefVar(var_glojure_DOT_core_list) + tmp203 := checkDerefVar(var_glojure_DOT_core_seq) + tmp204 := checkDerefVar(var_glojure_DOT_core_concat) + tmp205 := checkDerefVar(var_glojure_DOT_core_list) + tmp206 := lang.Apply(tmp205, []any{sym_glojure_DOT_core_SLASH_loop}) + tmp207 := checkDerefVar(var_glojure_DOT_core_list) + tmp208 := checkDerefVar(var_glojure_DOT_core_apply) + tmp209 := checkDerefVar(var_glojure_DOT_core_vector) + tmp210 := checkDerefVar(var_glojure_DOT_core_seq) + tmp211 := checkDerefVar(var_glojure_DOT_core_concat) + tmp212 := checkDerefVar(var_glojure_DOT_core_list) + tmp213 := lang.Apply(tmp212, []any{v91}) + tmp214 := checkDerefVar(var_glojure_DOT_core_list) + tmp215 := lang.Apply(tmp214, []any{v91}) + tmp216 := lang.Apply(tmp211, []any{tmp213, tmp215}) + tmp217 := lang.Apply(tmp210, []any{tmp216}) + tmp218 := lang.Apply(tmp208, []any{tmp209, tmp217}) + tmp219 := lang.Apply(tmp207, []any{tmp218}) + tmp220 := checkDerefVar(var_glojure_DOT_core_list) + tmp221 := checkDerefVar(var_glojure_DOT_core_seq) + tmp222 := checkDerefVar(var_glojure_DOT_core_concat) + tmp223 := checkDerefVar(var_glojure_DOT_core_list) + tmp224 := lang.Apply(tmp223, []any{sym_glojure_DOT_core_SLASH_when_DASH_let}) + tmp225 := checkDerefVar(var_glojure_DOT_core_list) + tmp226 := checkDerefVar(var_glojure_DOT_core_apply) + tmp227 := checkDerefVar(var_glojure_DOT_core_vector) + tmp228 := checkDerefVar(var_glojure_DOT_core_seq) + tmp229 := checkDerefVar(var_glojure_DOT_core_concat) + tmp230 := checkDerefVar(var_glojure_DOT_core_list) + tmp231 := lang.Apply(tmp230, []any{v91}) + tmp232 := checkDerefVar(var_glojure_DOT_core_list) + tmp233 := checkDerefVar(var_glojure_DOT_core_seq) + tmp234 := checkDerefVar(var_glojure_DOT_core_concat) + tmp235 := checkDerefVar(var_glojure_DOT_core_list) + tmp236 := lang.Apply(tmp235, []any{sym_glojure_DOT_core_SLASH_seq}) + tmp237 := checkDerefVar(var_glojure_DOT_core_list) + tmp238 := lang.Apply(tmp237, []any{v91}) + tmp239 := lang.Apply(tmp234, []any{tmp236, tmp238}) + tmp240 := lang.Apply(tmp233, []any{tmp239}) + tmp241 := lang.Apply(tmp232, []any{tmp240}) + tmp242 := lang.Apply(tmp229, []any{tmp231, tmp241}) + tmp243 := lang.Apply(tmp228, []any{tmp242}) + tmp244 := lang.Apply(tmp226, []any{tmp227, tmp243}) + tmp245 := lang.Apply(tmp225, []any{tmp244}) + tmp246 := checkDerefVar(var_glojure_DOT_core_list) + tmp247 := checkDerefVar(var_glojure_DOT_core_seq) + tmp248 := checkDerefVar(var_glojure_DOT_core_concat) + tmp249 := checkDerefVar(var_glojure_DOT_core_list) + tmp250 := lang.Apply(tmp249, []any{sym_if}) + tmp251 := checkDerefVar(var_glojure_DOT_core_list) + tmp252 := checkDerefVar(var_glojure_DOT_core_seq) + tmp253 := checkDerefVar(var_glojure_DOT_core_concat) + tmp254 := checkDerefVar(var_glojure_DOT_core_list) + tmp255 := lang.Apply(tmp254, []any{sym_glojure_DOT_core_SLASH_chunked_DASH_seq_QMARK_}) + tmp256 := checkDerefVar(var_glojure_DOT_core_list) + tmp257 := lang.Apply(tmp256, []any{v91}) + tmp258 := lang.Apply(tmp253, []any{tmp255, tmp257}) + tmp259 := lang.Apply(tmp252, []any{tmp258}) + tmp260 := lang.Apply(tmp251, []any{tmp259}) + tmp261 := checkDerefVar(var_glojure_DOT_core_list) + tmp262 := checkDerefVar(var_glojure_DOT_core_seq) + tmp263 := checkDerefVar(var_glojure_DOT_core_concat) + tmp264 := checkDerefVar(var_glojure_DOT_core_list) + tmp265 := lang.Apply(tmp264, []any{sym_glojure_DOT_core_SLASH_let}) + tmp266 := checkDerefVar(var_glojure_DOT_core_list) + tmp267 := checkDerefVar(var_glojure_DOT_core_apply) + tmp268 := checkDerefVar(var_glojure_DOT_core_vector) + tmp269 := checkDerefVar(var_glojure_DOT_core_seq) + tmp270 := checkDerefVar(var_glojure_DOT_core_concat) + tmp271 := checkDerefVar(var_glojure_DOT_core_list) + tmp272 := lang.Apply(tmp271, []any{sym_c__0__auto__}) + tmp273 := checkDerefVar(var_glojure_DOT_core_list) + tmp274 := checkDerefVar(var_glojure_DOT_core_seq) + tmp275 := checkDerefVar(var_glojure_DOT_core_concat) + tmp276 := checkDerefVar(var_glojure_DOT_core_list) + tmp277 := lang.Apply(tmp276, []any{sym_glojure_DOT_core_SLASH_chunk_DASH_first}) + tmp278 := checkDerefVar(var_glojure_DOT_core_list) + tmp279 := lang.Apply(tmp278, []any{v91}) + tmp280 := lang.Apply(tmp275, []any{tmp277, tmp279}) + tmp281 := lang.Apply(tmp274, []any{tmp280}) + tmp282 := lang.Apply(tmp273, []any{tmp281}) + tmp283 := checkDerefVar(var_glojure_DOT_core_list) + tmp284 := lang.Apply(tmp283, []any{sym_size__1__auto__}) + tmp285 := checkDerefVar(var_glojure_DOT_core_list) + tmp286 := checkDerefVar(var_glojure_DOT_core_seq) + tmp287 := checkDerefVar(var_glojure_DOT_core_concat) + tmp288 := checkDerefVar(var_glojure_DOT_core_list) + tmp289 := lang.Apply(tmp288, []any{sym_glojure_DOT_core_SLASH_int}) + tmp290 := checkDerefVar(var_glojure_DOT_core_list) + tmp291 := checkDerefVar(var_glojure_DOT_core_seq) + tmp292 := checkDerefVar(var_glojure_DOT_core_concat) + tmp293 := checkDerefVar(var_glojure_DOT_core_list) + tmp294 := lang.Apply(tmp293, []any{sym_glojure_DOT_core_SLASH_count}) + tmp295 := checkDerefVar(var_glojure_DOT_core_list) + tmp296 := lang.Apply(tmp295, []any{sym_c__0__auto__}) + tmp297 := lang.Apply(tmp292, []any{tmp294, tmp296}) + tmp298 := lang.Apply(tmp291, []any{tmp297}) + tmp299 := lang.Apply(tmp290, []any{tmp298}) + tmp300 := lang.Apply(tmp287, []any{tmp289, tmp299}) + tmp301 := lang.Apply(tmp286, []any{tmp300}) + tmp302 := lang.Apply(tmp285, []any{tmp301}) + tmp303 := checkDerefVar(var_glojure_DOT_core_list) + tmp304 := lang.Apply(tmp303, []any{v175}) + tmp305 := checkDerefVar(var_glojure_DOT_core_list) + tmp306 := checkDerefVar(var_glojure_DOT_core_seq) + tmp307 := checkDerefVar(var_glojure_DOT_core_concat) + tmp308 := checkDerefVar(var_glojure_DOT_core_list) + tmp309 := lang.Apply(tmp308, []any{sym_glojure_DOT_core_SLASH_chunk_DASH_buffer}) + tmp310 := checkDerefVar(var_glojure_DOT_core_list) + tmp311 := lang.Apply(tmp310, []any{sym_size__1__auto__}) + tmp312 := lang.Apply(tmp307, []any{tmp309, tmp311}) + tmp313 := lang.Apply(tmp306, []any{tmp312}) + tmp314 := lang.Apply(tmp305, []any{tmp313}) + tmp315 := lang.Apply(tmp270, []any{tmp272, tmp282, tmp284, tmp302, tmp304, tmp314}) + tmp316 := lang.Apply(tmp269, []any{tmp315}) + tmp317 := lang.Apply(tmp267, []any{tmp268, tmp316}) + tmp318 := lang.Apply(tmp266, []any{tmp317}) + tmp319 := checkDerefVar(var_glojure_DOT_core_list) + tmp320 := checkDerefVar(var_glojure_DOT_core_seq) + tmp321 := checkDerefVar(var_glojure_DOT_core_concat) + tmp322 := checkDerefVar(var_glojure_DOT_core_list) + tmp323 := lang.Apply(tmp322, []any{sym_if}) + tmp324 := checkDerefVar(var_glojure_DOT_core_list) + tmp325 := checkDerefVar(var_glojure_DOT_core_seq) + tmp326 := checkDerefVar(var_glojure_DOT_core_concat) + tmp327 := checkDerefVar(var_glojure_DOT_core_list) + tmp328 := lang.Apply(tmp327, []any{sym_glojure_DOT_core_SLASH_loop}) + tmp329 := checkDerefVar(var_glojure_DOT_core_list) + tmp330 := checkDerefVar(var_glojure_DOT_core_apply) + tmp331 := checkDerefVar(var_glojure_DOT_core_vector) + tmp332 := checkDerefVar(var_glojure_DOT_core_seq) + tmp333 := checkDerefVar(var_glojure_DOT_core_concat) + tmp334 := checkDerefVar(var_glojure_DOT_core_list) + tmp335 := lang.Apply(tmp334, []any{v172}) + tmp336 := checkDerefVar(var_glojure_DOT_core_list) + tmp337 := checkDerefVar(var_glojure_DOT_core_seq) + tmp338 := checkDerefVar(var_glojure_DOT_core_concat) + tmp339 := checkDerefVar(var_glojure_DOT_core_list) + tmp340 := lang.Apply(tmp339, []any{sym_glojure_DOT_core_SLASH_int}) + tmp341 := checkDerefVar(var_glojure_DOT_core_list) + tmp342 := lang.Apply(tmp341, []any{int64(0)}) + tmp343 := lang.Apply(tmp338, []any{tmp340, tmp342}) + tmp344 := lang.Apply(tmp337, []any{tmp343}) + tmp345 := lang.Apply(tmp336, []any{tmp344}) + tmp346 := lang.Apply(tmp333, []any{tmp335, tmp345}) + tmp347 := lang.Apply(tmp332, []any{tmp346}) + tmp348 := lang.Apply(tmp330, []any{tmp331, tmp347}) + tmp349 := lang.Apply(tmp329, []any{tmp348}) + tmp350 := checkDerefVar(var_glojure_DOT_core_list) + tmp351 := checkDerefVar(var_glojure_DOT_core_seq) + tmp352 := checkDerefVar(var_glojure_DOT_core_concat) + tmp353 := checkDerefVar(var_glojure_DOT_core_list) + tmp354 := lang.Apply(tmp353, []any{sym_if}) + tmp355 := checkDerefVar(var_glojure_DOT_core_list) + tmp356 := checkDerefVar(var_glojure_DOT_core_seq) + tmp357 := checkDerefVar(var_glojure_DOT_core_concat) + tmp358 := checkDerefVar(var_glojure_DOT_core_list) + tmp359 := lang.Apply(tmp358, []any{sym_glojure_DOT_core_SLASH__LT_}) + tmp360 := checkDerefVar(var_glojure_DOT_core_list) + tmp361 := lang.Apply(tmp360, []any{v172}) + tmp362 := checkDerefVar(var_glojure_DOT_core_list) + tmp363 := lang.Apply(tmp362, []any{sym_size__1__auto__}) + tmp364 := lang.Apply(tmp357, []any{tmp359, tmp361, tmp363}) + tmp365 := lang.Apply(tmp356, []any{tmp364}) + tmp366 := lang.Apply(tmp355, []any{tmp365}) + tmp367 := checkDerefVar(var_glojure_DOT_core_list) + tmp368 := checkDerefVar(var_glojure_DOT_core_seq) + tmp369 := checkDerefVar(var_glojure_DOT_core_concat) + tmp370 := checkDerefVar(var_glojure_DOT_core_list) + tmp371 := lang.Apply(tmp370, []any{sym_glojure_DOT_core_SLASH_let}) + tmp372 := checkDerefVar(var_glojure_DOT_core_list) + tmp373 := checkDerefVar(var_glojure_DOT_core_apply) + tmp374 := checkDerefVar(var_glojure_DOT_core_vector) + tmp375 := checkDerefVar(var_glojure_DOT_core_seq) + tmp376 := checkDerefVar(var_glojure_DOT_core_concat) + tmp377 := checkDerefVar(var_glojure_DOT_core_list) + tmp378 := lang.Apply(tmp377, []any{v65}) + tmp379 := checkDerefVar(var_glojure_DOT_core_list) + tmp380 := checkDerefVar(var_glojure_DOT_core_seq) + tmp381 := checkDerefVar(var_glojure_DOT_core_concat) + tmp382 := checkDerefVar(var_glojure_DOT_core_list) + tmp383 := lang.Apply(tmp382, []any{sym__DOT_nth}) + tmp384 := checkDerefVar(var_glojure_DOT_core_list) + tmp385 := lang.Apply(tmp384, []any{sym_c__0__auto__}) + tmp386 := checkDerefVar(var_glojure_DOT_core_list) + tmp387 := lang.Apply(tmp386, []any{v172}) + tmp388 := lang.Apply(tmp381, []any{tmp383, tmp385, tmp387}) + tmp389 := lang.Apply(tmp380, []any{tmp388}) + tmp390 := lang.Apply(tmp379, []any{tmp389}) + tmp391 := lang.Apply(tmp376, []any{tmp378, tmp390}) + tmp392 := lang.Apply(tmp375, []any{tmp391}) + tmp393 := lang.Apply(tmp373, []any{tmp374, tmp392}) + tmp394 := lang.Apply(tmp372, []any{tmp393}) + tmp395 := checkDerefVar(var_glojure_DOT_core_list) + tmp396 := lang.Apply(v179, []any{v73}) + tmp397 := lang.Apply(tmp395, []any{tmp396}) + tmp398 := lang.Apply(tmp369, []any{tmp371, tmp394, tmp397}) + tmp399 := lang.Apply(tmp368, []any{tmp398}) + tmp400 := lang.Apply(tmp367, []any{tmp399}) + tmp401 := checkDerefVar(var_glojure_DOT_core_list) + tmp402 := lang.Apply(tmp401, []any{true}) + tmp403 := lang.Apply(tmp352, []any{tmp354, tmp366, tmp400, tmp402}) + tmp404 := lang.Apply(tmp351, []any{tmp403}) + tmp405 := lang.Apply(tmp350, []any{tmp404}) + tmp406 := lang.Apply(tmp326, []any{tmp328, tmp349, tmp405}) + tmp407 := lang.Apply(tmp325, []any{tmp406}) + tmp408 := lang.Apply(tmp324, []any{tmp407}) + tmp409 := checkDerefVar(var_glojure_DOT_core_list) + tmp410 := checkDerefVar(var_glojure_DOT_core_seq) + tmp411 := checkDerefVar(var_glojure_DOT_core_concat) + tmp412 := checkDerefVar(var_glojure_DOT_core_list) + tmp413 := lang.Apply(tmp412, []any{sym_glojure_DOT_core_SLASH_chunk_DASH_cons}) + tmp414 := checkDerefVar(var_glojure_DOT_core_list) + tmp415 := checkDerefVar(var_glojure_DOT_core_seq) + tmp416 := checkDerefVar(var_glojure_DOT_core_concat) + tmp417 := checkDerefVar(var_glojure_DOT_core_list) + tmp418 := lang.Apply(tmp417, []any{sym_glojure_DOT_core_SLASH_chunk}) + tmp419 := checkDerefVar(var_glojure_DOT_core_list) + tmp420 := lang.Apply(tmp419, []any{v175}) + tmp421 := lang.Apply(tmp416, []any{tmp418, tmp420}) + tmp422 := lang.Apply(tmp415, []any{tmp421}) + tmp423 := lang.Apply(tmp414, []any{tmp422}) + tmp424 := checkDerefVar(var_glojure_DOT_core_list) + tmp425 := checkDerefVar(var_glojure_DOT_core_seq) + tmp426 := checkDerefVar(var_glojure_DOT_core_concat) + tmp427 := checkDerefVar(var_glojure_DOT_core_list) + tmp428 := lang.Apply(tmp427, []any{v88}) + tmp429 := checkDerefVar(var_glojure_DOT_core_list) + tmp430 := checkDerefVar(var_glojure_DOT_core_seq) + tmp431 := checkDerefVar(var_glojure_DOT_core_concat) + tmp432 := checkDerefVar(var_glojure_DOT_core_list) + tmp433 := lang.Apply(tmp432, []any{sym_glojure_DOT_core_SLASH_chunk_DASH_rest}) + tmp434 := checkDerefVar(var_glojure_DOT_core_list) + tmp435 := lang.Apply(tmp434, []any{v91}) + tmp436 := lang.Apply(tmp431, []any{tmp433, tmp435}) + tmp437 := lang.Apply(tmp430, []any{tmp436}) + tmp438 := lang.Apply(tmp429, []any{tmp437}) + tmp439 := lang.Apply(tmp426, []any{tmp428, tmp438}) + tmp440 := lang.Apply(tmp425, []any{tmp439}) + tmp441 := lang.Apply(tmp424, []any{tmp440}) + tmp442 := lang.Apply(tmp411, []any{tmp413, tmp423, tmp441}) + tmp443 := lang.Apply(tmp410, []any{tmp442}) + tmp444 := lang.Apply(tmp409, []any{tmp443}) + tmp445 := checkDerefVar(var_glojure_DOT_core_list) + tmp446 := checkDerefVar(var_glojure_DOT_core_seq) + tmp447 := checkDerefVar(var_glojure_DOT_core_concat) + tmp448 := checkDerefVar(var_glojure_DOT_core_list) + tmp449 := lang.Apply(tmp448, []any{sym_glojure_DOT_core_SLASH_chunk_DASH_cons}) + tmp450 := checkDerefVar(var_glojure_DOT_core_list) + tmp451 := checkDerefVar(var_glojure_DOT_core_seq) + tmp452 := checkDerefVar(var_glojure_DOT_core_concat) + tmp453 := checkDerefVar(var_glojure_DOT_core_list) + tmp454 := lang.Apply(tmp453, []any{sym_glojure_DOT_core_SLASH_chunk}) + tmp455 := checkDerefVar(var_glojure_DOT_core_list) + tmp456 := lang.Apply(tmp455, []any{v175}) + tmp457 := lang.Apply(tmp452, []any{tmp454, tmp456}) + tmp458 := lang.Apply(tmp451, []any{tmp457}) + tmp459 := lang.Apply(tmp450, []any{tmp458}) + tmp460 := checkDerefVar(var_glojure_DOT_core_list) + tmp461 := lang.Apply(tmp460, []any{nil}) + tmp462 := lang.Apply(tmp447, []any{tmp449, tmp459, tmp461}) + tmp463 := lang.Apply(tmp446, []any{tmp462}) + tmp464 := lang.Apply(tmp445, []any{tmp463}) + tmp465 := lang.Apply(tmp321, []any{tmp323, tmp408, tmp444, tmp464}) + tmp466 := lang.Apply(tmp320, []any{tmp465}) + tmp467 := lang.Apply(tmp319, []any{tmp466}) + tmp468 := lang.Apply(tmp263, []any{tmp265, tmp318, tmp467}) + tmp469 := lang.Apply(tmp262, []any{tmp468}) + tmp470 := lang.Apply(tmp261, []any{tmp469}) + tmp471 := checkDerefVar(var_glojure_DOT_core_list) + tmp472 := checkDerefVar(var_glojure_DOT_core_seq) + tmp473 := checkDerefVar(var_glojure_DOT_core_concat) + tmp474 := checkDerefVar(var_glojure_DOT_core_list) + tmp475 := lang.Apply(tmp474, []any{sym_glojure_DOT_core_SLASH_let}) + tmp476 := checkDerefVar(var_glojure_DOT_core_list) + tmp477 := checkDerefVar(var_glojure_DOT_core_apply) + tmp478 := checkDerefVar(var_glojure_DOT_core_vector) + tmp479 := checkDerefVar(var_glojure_DOT_core_seq) + tmp480 := checkDerefVar(var_glojure_DOT_core_concat) + tmp481 := checkDerefVar(var_glojure_DOT_core_list) + tmp482 := lang.Apply(tmp481, []any{v65}) + tmp483 := checkDerefVar(var_glojure_DOT_core_list) + tmp484 := checkDerefVar(var_glojure_DOT_core_seq) + tmp485 := checkDerefVar(var_glojure_DOT_core_concat) + tmp486 := checkDerefVar(var_glojure_DOT_core_list) + tmp487 := lang.Apply(tmp486, []any{sym_glojure_DOT_core_SLASH_first}) + tmp488 := checkDerefVar(var_glojure_DOT_core_list) + tmp489 := lang.Apply(tmp488, []any{v91}) + tmp490 := lang.Apply(tmp485, []any{tmp487, tmp489}) + tmp491 := lang.Apply(tmp484, []any{tmp490}) + tmp492 := lang.Apply(tmp483, []any{tmp491}) + tmp493 := lang.Apply(tmp480, []any{tmp482, tmp492}) + tmp494 := lang.Apply(tmp479, []any{tmp493}) + tmp495 := lang.Apply(tmp477, []any{tmp478, tmp494}) + tmp496 := lang.Apply(tmp476, []any{tmp495}) + tmp497 := checkDerefVar(var_glojure_DOT_core_list) + tmp498 := lang.Apply(v95, []any{v73}) + tmp499 := lang.Apply(tmp497, []any{tmp498}) + tmp500 := lang.Apply(tmp473, []any{tmp475, tmp496, tmp499}) + tmp501 := lang.Apply(tmp472, []any{tmp500}) + tmp502 := lang.Apply(tmp471, []any{tmp501}) + tmp503 := lang.Apply(tmp248, []any{tmp250, tmp260, tmp470, tmp502}) + tmp504 := lang.Apply(tmp247, []any{tmp503}) + tmp505 := lang.Apply(tmp246, []any{tmp504}) + tmp506 := lang.Apply(tmp222, []any{tmp224, tmp245, tmp505}) + tmp507 := lang.Apply(tmp221, []any{tmp506}) + tmp508 := lang.Apply(tmp220, []any{tmp507}) + tmp509 := lang.Apply(tmp204, []any{tmp206, tmp219, tmp508}) + tmp510 := lang.Apply(tmp203, []any{tmp509}) + tmp511 := lang.Apply(tmp202, []any{tmp510}) + tmp512 := lang.Apply(tmp199, []any{tmp201, tmp511}) + tmp513 := lang.Apply(tmp198, []any{tmp512}) + tmp514 := lang.Apply(tmp197, []any{tmp513}) + tmp515 := lang.Apply(tmp181, []any{tmp183, tmp185, tmp196, tmp514}) + tmp516 := lang.Apply(tmp180, []any{tmp515}) + tmp169 = tmp516 + } // end let + tmp96 = tmp169 + } + tmp85 = tmp96 + } // end let + tmp44 = tmp85 + } // end let + return tmp44 + }) + v42 = tmp41 + _ = v42 + } + tmp42 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4668), kw_column, int(19), kw_end_DASH_line, int(4729), kw_end_DASH_column, int(68)) + tmp43, err := lang.WithMeta(tmp41, tmp42.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v44 any = tmp43 + _ = v44 + tmp45 := checkDerefVar(var_glojure_DOT_core_seq) + tmp46 := checkDerefVar(var_glojure_DOT_core_concat) + tmp47 := checkDerefVar(var_glojure_DOT_core_list) + tmp48 := lang.Apply(tmp47, []any{sym_glojure_DOT_core_SLASH_let}) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) + tmp50 := checkDerefVar(var_glojure_DOT_core_apply) + tmp51 := checkDerefVar(var_glojure_DOT_core_vector) + tmp52 := checkDerefVar(var_glojure_DOT_core_seq) + tmp53 := checkDerefVar(var_glojure_DOT_core_concat) + tmp54 := checkDerefVar(var_glojure_DOT_core_list) + tmp55 := lang.Apply(tmp54, []any{sym_iter__0__auto__}) + tmp56 := checkDerefVar(var_glojure_DOT_core_list) + tmp57 := lang.Apply(v36, []any{v4}) + tmp58 := lang.Apply(v44, []any{tmp57}) + tmp59 := lang.Apply(tmp56, []any{tmp58}) + tmp60 := lang.Apply(tmp53, []any{tmp55, tmp59}) + tmp61 := lang.Apply(tmp52, []any{tmp60}) + tmp62 := lang.Apply(tmp50, []any{tmp51, tmp61}) + tmp63 := lang.Apply(tmp49, []any{tmp62}) + tmp64 := checkDerefVar(var_glojure_DOT_core_list) + tmp65 := checkDerefVar(var_glojure_DOT_core_seq) + tmp66 := checkDerefVar(var_glojure_DOT_core_concat) + tmp67 := checkDerefVar(var_glojure_DOT_core_list) + tmp68 := lang.Apply(tmp67, []any{sym_iter__0__auto__}) + tmp69 := checkDerefVar(var_glojure_DOT_core_list) + tmp70 := checkDerefVar(var_glojure_DOT_core_second) + tmp71 := lang.Apply(tmp70, []any{v4}) + tmp72 := lang.Apply(tmp69, []any{tmp71}) + tmp73 := lang.Apply(tmp66, []any{tmp68, tmp72}) + tmp74 := lang.Apply(tmp65, []any{tmp73}) + tmp75 := lang.Apply(tmp64, []any{tmp74}) + tmp76 := lang.Apply(tmp46, []any{tmp48, tmp63, tmp75}) + tmp77 := lang.Apply(tmp45, []any{tmp76}) + tmp32 = tmp77 + } // end let + return tmp32 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_for = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_for.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // let + { + tmp0 := sym_let.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "binding => binding-form init-expr\n binding-form => name, or destructuring-form\n destructuring-form => map-destructure-form, or seq-destructure-form\n\n Evaluates the exprs in a lexical context in which the symbols in\n the binding-forms are bound to their respective init-exprs or parts\n therein.\n\n See https://glojure.org/reference/special_forms#binding-forms for\n more information about destructuring.", kw_forms, lang.NewVector(lang.NewList(sym_let, lang.NewVector(sym_bindings_STAR_), sym_exprs_STAR_)), kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(11), kw_line, int(4496), kw_end_DASH_line, int(4496), kw_special_DASH_form, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v4}) + if lang.IsTruthy(tmp8) { + } else { + tmp9 := checkDerefVar(var_glojure_DOT_core_str) + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp13 := checkDerefVar(var_glojure_DOT_core_meta) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(kw_line, []any{tmp14}) + tmp16 := lang.Apply(tmp9, []any{tmp11, " requires ", "a vector for its binding", " in ", tmp12, ":", tmp15}) + tmp17 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp16}) + panic(tmp17) + } + _ = tmp6 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_even_QMARK_) + tmp20 := checkDerefVar(var_glojure_DOT_core_count) + tmp21 := lang.Apply(tmp20, []any{v4}) + tmp22 := lang.Apply(tmp19, []any{tmp21}) + if lang.IsTruthy(tmp22) { + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp27 := checkDerefVar(var_glojure_DOT_core_meta) + tmp28 := lang.Apply(tmp27, []any{v2}) + tmp29 := lang.Apply(kw_line, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp25, " requires ", "an even number of forms in binding vector", " in ", tmp26, ":", tmp29}) + tmp31 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp31) + } + _ = tmp18 + tmp32 := checkDerefVar(var_glojure_DOT_core_seq) + tmp33 := checkDerefVar(var_glojure_DOT_core_concat) + tmp34 := checkDerefVar(var_glojure_DOT_core_list) + tmp35 := lang.Apply(tmp34, []any{sym_let_STAR_}) + tmp36 := checkDerefVar(var_glojure_DOT_core_list) + tmp37 := checkDerefVar(var_glojure_DOT_core_destructure) + tmp38 := lang.Apply(tmp37, []any{v4}) + tmp39 := lang.Apply(tmp36, []any{tmp38}) + tmp40 := lang.Apply(tmp33, []any{tmp35, tmp39, v5}) + tmp41 := lang.Apply(tmp32, []any{tmp40}) + return tmp41 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_let = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_let.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // loop + { + tmp0 := sym_loop.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "Evaluates the exprs in a lexical context in which the symbols in\n the binding-forms are bound to their respective init-exprs or parts\n therein. Acts as a recur target.", kw_forms, lang.NewVector(lang.NewList(sym_loop, lang.NewVector(sym_bindings_STAR_), sym_exprs_STAR_)), kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(11), kw_line, int(4597), kw_end_DASH_line, int(4597), kw_special_DASH_form, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v4}) + if lang.IsTruthy(tmp8) { + } else { + tmp9 := checkDerefVar(var_glojure_DOT_core_str) + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp13 := checkDerefVar(var_glojure_DOT_core_meta) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(kw_line, []any{tmp14}) + tmp16 := lang.Apply(tmp9, []any{tmp11, " requires ", "a vector for its binding", " in ", tmp12, ":", tmp15}) + tmp17 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp16}) + panic(tmp17) + } + _ = tmp6 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_even_QMARK_) + tmp20 := checkDerefVar(var_glojure_DOT_core_count) + tmp21 := lang.Apply(tmp20, []any{v4}) + tmp22 := lang.Apply(tmp19, []any{tmp21}) + if lang.IsTruthy(tmp22) { + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp27 := checkDerefVar(var_glojure_DOT_core_meta) + tmp28 := lang.Apply(tmp27, []any{v2}) + tmp29 := lang.Apply(kw_line, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp25, " requires ", "an even number of forms in binding vector", " in ", tmp26, ":", tmp29}) + tmp31 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp31) + } + _ = tmp18 + var tmp32 any + { // let + // let binding "db" + tmp33 := checkDerefVar(var_glojure_DOT_core_destructure) + tmp34 := lang.Apply(tmp33, []any{v4}) + var v35 any = tmp34 + _ = v35 + var tmp36 any + tmp37 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp38 := lang.Apply(tmp37, []any{v35, v4}) + if lang.IsTruthy(tmp38) { + tmp39 := checkDerefVar(var_glojure_DOT_core_seq) + tmp40 := checkDerefVar(var_glojure_DOT_core_concat) + tmp41 := checkDerefVar(var_glojure_DOT_core_list) + tmp42 := lang.Apply(tmp41, []any{sym_loop_STAR_}) + tmp43 := checkDerefVar(var_glojure_DOT_core_list) + tmp44 := lang.Apply(tmp43, []any{v4}) + tmp45 := lang.Apply(tmp40, []any{tmp42, tmp44, v5}) + tmp46 := lang.Apply(tmp39, []any{tmp45}) + tmp36 = tmp46 + } else { + var tmp47 any + { // let + // let binding "vs" + tmp48 := checkDerefVar(var_glojure_DOT_core_take_DASH_nth) + tmp49 := checkDerefVar(var_glojure_DOT_core_drop) + tmp50 := lang.Apply(tmp49, []any{int64(1), v4}) + tmp51 := lang.Apply(tmp48, []any{int64(2), tmp50}) + var v52 any = tmp51 + _ = v52 + // let binding "bs" + tmp53 := checkDerefVar(var_glojure_DOT_core_take_DASH_nth) + tmp54 := lang.Apply(tmp53, []any{int64(2), v4}) + var v55 any = tmp54 + _ = v55 + // let binding "gs" + tmp56 := checkDerefVar(var_glojure_DOT_core_map) + var tmp57 lang.FnFunc + tmp57 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v58 := args[0] + _ = v58 + var tmp59 any + tmp60 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp61 := lang.Apply(tmp60, []any{v58}) + if lang.IsTruthy(tmp61) { + tmp59 = v58 + } else { + tmp62 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp63 := lang.Apply(tmp62, nil) + tmp59 = tmp63 + } + return tmp59 + }) + tmp58 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4611), kw_column, int(23), kw_end_DASH_line, int(4611), kw_end_DASH_column, int(58)) + tmp59, err := lang.WithMeta(tmp57, tmp58.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp60 := lang.Apply(tmp56, []any{tmp59, v55}) + var v61 any = tmp60 + _ = v61 + // let binding "bfs" + tmp62 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp63 lang.FnFunc + tmp63 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v64 := args[0] + _ = v64 + v65 := args[1] + _ = v65 + var tmp66 any + { // let + // let binding "vec__708" + var v67 any = v65 + _ = v67 + // let binding "b" + tmp68 := checkDerefVar(var_glojure_DOT_core_nth) + tmp69 := lang.Apply(tmp68, []any{v67, int64(0), nil}) + var v70 any = tmp69 + _ = v70 + // let binding "v" + tmp71 := checkDerefVar(var_glojure_DOT_core_nth) + tmp72 := lang.Apply(tmp71, []any{v67, int64(1), nil}) + var v73 any = tmp72 + _ = v73 + // let binding "g" + tmp74 := checkDerefVar(var_glojure_DOT_core_nth) + tmp75 := lang.Apply(tmp74, []any{v67, int64(2), nil}) + var v76 any = tmp75 + _ = v76 + var tmp77 any + tmp78 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp79 := lang.Apply(tmp78, []any{v70}) + if lang.IsTruthy(tmp79) { + tmp80 := checkDerefVar(var_glojure_DOT_core_conj) + tmp81 := lang.Apply(tmp80, []any{v64, v76, v73}) + tmp77 = tmp81 + } else { + tmp82 := checkDerefVar(var_glojure_DOT_core_conj) + tmp83 := lang.Apply(tmp82, []any{v64, v76, v73, v70, v76}) + tmp77 = tmp83 + } + tmp66 = tmp77 + } // end let + return tmp66 + }) + tmp64 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4612), kw_column, int(28), kw_end_DASH_line, int(4615), kw_end_DASH_column, int(50)) + tmp65, err := lang.WithMeta(tmp63, tmp64.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp66 := lang.NewVector() + tmp67 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4616), kw_column, int(27), kw_end_DASH_line, int(4616), kw_end_DASH_column, int(28)) + tmp68, err := lang.WithMeta(tmp66, tmp67.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp69 := checkDerefVar(var_glojure_DOT_core_map) + tmp70 := checkDerefVar(var_glojure_DOT_core_vector) + tmp71 := lang.Apply(tmp69, []any{tmp70, v55, v52, v61}) + tmp72 := lang.Apply(tmp62, []any{tmp65, tmp68, tmp71}) + var v73 any = tmp72 + _ = v73 + tmp74 := checkDerefVar(var_glojure_DOT_core_seq) + tmp75 := checkDerefVar(var_glojure_DOT_core_concat) + tmp76 := checkDerefVar(var_glojure_DOT_core_list) + tmp77 := lang.Apply(tmp76, []any{sym_glojure_DOT_core_SLASH_let}) + tmp78 := checkDerefVar(var_glojure_DOT_core_list) + tmp79 := lang.Apply(tmp78, []any{v73}) + tmp80 := checkDerefVar(var_glojure_DOT_core_list) + tmp81 := checkDerefVar(var_glojure_DOT_core_seq) + tmp82 := checkDerefVar(var_glojure_DOT_core_concat) + tmp83 := checkDerefVar(var_glojure_DOT_core_list) + tmp84 := lang.Apply(tmp83, []any{sym_loop_STAR_}) + tmp85 := checkDerefVar(var_glojure_DOT_core_list) + tmp86 := checkDerefVar(var_glojure_DOT_core_vec) + tmp87 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp88 := lang.Apply(tmp87, []any{v61, v61}) + tmp89 := lang.Apply(tmp86, []any{tmp88}) + tmp90 := lang.Apply(tmp85, []any{tmp89}) + tmp91 := checkDerefVar(var_glojure_DOT_core_list) + tmp92 := checkDerefVar(var_glojure_DOT_core_seq) + tmp93 := checkDerefVar(var_glojure_DOT_core_concat) + tmp94 := checkDerefVar(var_glojure_DOT_core_list) + tmp95 := lang.Apply(tmp94, []any{sym_glojure_DOT_core_SLASH_let}) + tmp96 := checkDerefVar(var_glojure_DOT_core_list) + tmp97 := checkDerefVar(var_glojure_DOT_core_vec) + tmp98 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp99 := lang.Apply(tmp98, []any{v55, v61}) + tmp100 := lang.Apply(tmp97, []any{tmp99}) + tmp101 := lang.Apply(tmp96, []any{tmp100}) + tmp102 := lang.Apply(tmp93, []any{tmp95, tmp101, v5}) + tmp103 := lang.Apply(tmp92, []any{tmp102}) + tmp104 := lang.Apply(tmp91, []any{tmp103}) + tmp105 := lang.Apply(tmp82, []any{tmp84, tmp90, tmp104}) + tmp106 := lang.Apply(tmp81, []any{tmp105}) + tmp107 := lang.Apply(tmp80, []any{tmp106}) + tmp108 := lang.Apply(tmp75, []any{tmp77, tmp79, tmp107}) + tmp109 := lang.Apply(tmp74, []any{tmp108}) + tmp47 = tmp109 + } // end let + tmp36 = tmp47 + } + tmp32 = tmp36 + } // end let + return tmp32 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_loop = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_loop.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print-map + { + tmp0 := sym_print_DASH_map.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(252), kw_column, int(8), kw_end_DASH_line, int(252), kw_end_DASH_column, int(16), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_m, sym_print_DASH_one, sym_w)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_print_DASH_prefix_DASH_map) + tmp6 := lang.Apply(tmp5, []any{nil, v2, v3, v4}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_print_DASH_map = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_print_DASH_map.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // add-classpath + { + tmp0 := sym_add_DASH_classpath.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_url)), kw_doc, "DEPRECATED \n\n Adds the url (String or URL object) to the classpath per\n URLClassLoader.addURL", kw_file, "glojure/core.glj", kw_deprecated, "1.1", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(5176), kw_end_DASH_line, int(5176))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_println) + tmp4 := lang.Apply(tmp3, []any{"WARNING: add-classpath is deprecated"}) + _ = tmp4 + tmp5 := lang.Apply(nil, []any{v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_add_DASH_classpath = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_add_DASH_classpath.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // case + { + tmp0 := sym_case.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_e, sym__AMP_, sym_clauses)), kw_doc, "Takes an expression, and a set of clauses.\n\n Each clause can take the form of either:\n\n test-constant result-expr\n\n (test-constant1 ... test-constantN) result-expr\n\n The test-constants are not evaluated. They must be compile-time\n literals, and need not be quoted. If the expression is equal to a\n test-constant, the corresponding result-expr is returned. A single\n default expression can follow the clauses, and its value will be\n returned if no clause matches. If no default expression is provided\n and no clause matches, an IllegalArgumentException is thrown.\n\n Unlike cond and condp, case does a constant-time dispatch, the\n clauses are not considered sequentially. All manner of constant\n expressions are acceptable in case, including numbers, strings,\n symbols, keywords, and (Clojure) composites thereof. Note that since\n lists are used to group multiple constants that map to the same\n expression, a vector can be used to match a list if needed. The\n test-constants need not be all of the same type.", kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(11), kw_line, int(6712), kw_end_DASH_line, int(6712))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "ge" + tmp7 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp8 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp9 := lang.Apply(tmp8, nil) + tmp10 := reflect.TypeOf((*lang.Object)(nil)).Elem() + tmp11 := lang.NewMap(kw_tag, tmp10) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6738), kw_column, int(32), kw_end_DASH_line, int(6738), kw_end_DASH_column, int(84)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp14 := lang.Apply(tmp7, []any{tmp9, tmp13}) + var v15 any = tmp14 + _ = v15 + // let binding "default" + var tmp16 any + tmp17 := checkDerefVar(var_glojure_DOT_core_odd_QMARK_) + tmp18 := checkDerefVar(var_glojure_DOT_core_count) + tmp19 := lang.Apply(tmp18, []any{v5}) + tmp20 := lang.Apply(tmp17, []any{tmp19}) + if lang.IsTruthy(tmp20) { + tmp21 := checkDerefVar(var_glojure_DOT_core_last) + tmp22 := lang.Apply(tmp21, []any{v5}) + tmp16 = tmp22 + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_seq) + tmp24 := checkDerefVar(var_glojure_DOT_core_concat) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := lang.Apply(tmp25, []any{sym_throw}) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := checkDerefVar(var_glojure_DOT_core_seq) + tmp29 := checkDerefVar(var_glojure_DOT_core_concat) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := lang.Apply(tmp30, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_NewIllegalArgumentError}) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := checkDerefVar(var_glojure_DOT_core_seq) + tmp34 := checkDerefVar(var_glojure_DOT_core_concat) + tmp35 := checkDerefVar(var_glojure_DOT_core_list) + tmp36 := lang.Apply(tmp35, []any{sym_glojure_DOT_core_SLASH_str}) + tmp37 := checkDerefVar(var_glojure_DOT_core_list) + tmp38 := lang.Apply(tmp37, []any{"No matching clause: "}) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := lang.Apply(tmp39, []any{v15}) + tmp41 := lang.Apply(tmp34, []any{tmp36, tmp38, tmp40}) + tmp42 := lang.Apply(tmp33, []any{tmp41}) + tmp43 := lang.Apply(tmp32, []any{tmp42}) + tmp44 := lang.Apply(tmp29, []any{tmp31, tmp43}) + tmp45 := lang.Apply(tmp28, []any{tmp44}) + tmp46 := lang.Apply(tmp27, []any{tmp45}) + tmp47 := lang.Apply(tmp24, []any{tmp26, tmp46}) + tmp48 := lang.Apply(tmp23, []any{tmp47}) + tmp16 = tmp48 + } + var v49 any = tmp16 + _ = v49 + var tmp50 any + tmp51 := checkDerefVar(var_glojure_DOT_core__GT_) + tmp52 := checkDerefVar(var_glojure_DOT_core_count) + tmp53 := lang.Apply(tmp52, []any{v5}) + tmp54 := lang.Apply(tmp51, []any{int64(2), tmp53}) + if lang.IsTruthy(tmp54) { + tmp55 := checkDerefVar(var_glojure_DOT_core_seq) + tmp56 := checkDerefVar(var_glojure_DOT_core_concat) + tmp57 := checkDerefVar(var_glojure_DOT_core_list) + tmp58 := lang.Apply(tmp57, []any{sym_glojure_DOT_core_SLASH_let}) + tmp59 := checkDerefVar(var_glojure_DOT_core_list) + tmp60 := checkDerefVar(var_glojure_DOT_core_apply) + tmp61 := checkDerefVar(var_glojure_DOT_core_vector) + tmp62 := checkDerefVar(var_glojure_DOT_core_seq) + tmp63 := checkDerefVar(var_glojure_DOT_core_concat) + tmp64 := checkDerefVar(var_glojure_DOT_core_list) + tmp65 := lang.Apply(tmp64, []any{v15}) + tmp66 := checkDerefVar(var_glojure_DOT_core_list) + tmp67 := lang.Apply(tmp66, []any{v4}) + tmp68 := lang.Apply(tmp63, []any{tmp65, tmp67}) + tmp69 := lang.Apply(tmp62, []any{tmp68}) + tmp70 := lang.Apply(tmp60, []any{tmp61, tmp69}) + tmp71 := lang.Apply(tmp59, []any{tmp70}) + tmp72 := checkDerefVar(var_glojure_DOT_core_list) + tmp73 := lang.Apply(tmp72, []any{v49}) + tmp74 := lang.Apply(tmp56, []any{tmp58, tmp71, tmp73}) + tmp75 := lang.Apply(tmp55, []any{tmp74}) + tmp50 = tmp75 + } else { + var tmp76 any + { // let + // let binding "pairs" + tmp77 := checkDerefVar(var_glojure_DOT_core_partition) + tmp78 := lang.Apply(tmp77, []any{int64(2), v5}) + var v79 any = tmp78 + _ = v79 + // let binding "assoc-test" + var tmp80 lang.FnFunc + { // function assoc-test + var v81 lang.FnFunc + tmp80 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v82 := args[0] + _ = v82 + v83 := args[1] + _ = v83 + v84 := args[2] + _ = v84 + var tmp85 any + tmp86 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp87 := lang.Apply(tmp86, []any{v82, v83}) + if lang.IsTruthy(tmp87) { + tmp88 := checkDerefVar(var_glojure_DOT_core_str) + tmp89 := lang.Apply(tmp88, []any{"Duplicate case test constant: ", v83}) + tmp90 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp89}) + panic(tmp90) + } else { + tmp91 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp92 := lang.Apply(tmp91, []any{v82, v83, v84}) + tmp85 = tmp92 + } + return tmp85 + }) + v81 = tmp80 + _ = v81 + } + tmp81 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6745), kw_column, int(24), kw_end_DASH_line, int(6748), kw_end_DASH_column, int(48)) + tmp82, err := lang.WithMeta(tmp80, tmp81.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v83 any = tmp82 + _ = v83 + // let binding "pairs" + tmp84 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp85 lang.FnFunc + tmp85 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v86 := args[0] + _ = v86 + v87 := args[1] + _ = v87 + var tmp88 any + { // let + // let binding "vec__868" + var v89 any = v87 + _ = v89 + // let binding "test" + tmp90 := checkDerefVar(var_glojure_DOT_core_nth) + tmp91 := lang.Apply(tmp90, []any{v89, int64(0), nil}) + var v92 any = tmp91 + _ = v92 + // let binding "expr" + tmp93 := checkDerefVar(var_glojure_DOT_core_nth) + tmp94 := lang.Apply(tmp93, []any{v89, int64(1), nil}) + var v95 any = tmp94 + _ = v95 + var tmp96 any + tmp97 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp98 := lang.Apply(tmp97, []any{v92}) + if lang.IsTruthy(tmp98) { + tmp99 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp100 lang.FnFunc + tmp100 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v101 := args[0] + _ = v101 + v102 := args[1] + _ = v102 + tmp103 := lang.Apply(v83, []any{v101, v102, v95}) + return tmp103 + }) + tmp101 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6752), kw_column, int(37), kw_end_DASH_line, int(6752), kw_end_DASH_column, int(60)) + tmp102, err := lang.WithMeta(tmp100, tmp101.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp103 := lang.Apply(tmp99, []any{tmp102, v86, v92}) + tmp96 = tmp103 + } else { + tmp104 := lang.Apply(v83, []any{v86, v92, v95}) + tmp96 = tmp104 + } + tmp88 = tmp96 + } // end let + return tmp88 + }) + tmp86 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6750), kw_column, int(24), kw_end_DASH_line, int(6753), kw_end_DASH_column, int(53)) + tmp87, err := lang.WithMeta(tmp85, tmp86.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp88 := lang.NewMap() + tmp89 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6754), kw_column, int(24), kw_end_DASH_line, int(6754), kw_end_DASH_column, int(25)) + tmp90, err := lang.WithMeta(tmp88, tmp89.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp91 := lang.Apply(tmp84, []any{tmp87, tmp90, v79}) + var v92 any = tmp91 + _ = v92 + // let binding "tests" + tmp93 := checkDerefVar(var_glojure_DOT_core_keys) + tmp94 := lang.Apply(tmp93, []any{v92}) + var v95 any = tmp94 + _ = v95 + // let binding "thens" + tmp96 := checkDerefVar(var_glojure_DOT_core_vals) + tmp97 := lang.Apply(tmp96, []any{v92}) + var v98 any = tmp97 + _ = v98 + // let binding "mode" + var tmp99 any + tmp100 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + var tmp101 lang.FnFunc + tmp101 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v102 := args[0] + _ = v102 + var tmp103 any + { // let + // let binding "and__0__auto__" + tmp104 := checkDerefVar(var_glojure_DOT_core_integer_QMARK_) + tmp105 := lang.Apply(tmp104, []any{v102}) + var v106 any = tmp105 + _ = v106 + var tmp107 any + if lang.IsTruthy(v106) { + tmp108 := checkDerefVar(var_glojure_DOT_core__LT__EQ_) + tmp109 := lang.Apply(tmp108, []any{math4.MinInt, v102, math4.MaxInt}) + tmp107 = tmp109 + } else { + tmp107 = v106 + } + tmp103 = tmp107 + } // end let + return tmp103 + }) + tmp102 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6758), kw_column, int(28), kw_end_DASH_line, int(6758), kw_end_DASH_column, int(77)) + tmp103, err := lang.WithMeta(tmp101, tmp102.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp104 := lang.Apply(tmp100, []any{tmp103, v95}) + if lang.IsTruthy(tmp104) { + tmp99 = kw_ints + } else { + var tmp105 any + tmp106 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + tmp107 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp108 := lang.Apply(tmp106, []any{tmp107, v95}) + if lang.IsTruthy(tmp108) { + tmp105 = kw_identity + } else { + var tmp109 any + if lang.IsTruthy(kw_else) { + tmp109 = kw_hashes + } else { + } + tmp105 = tmp109 + } + tmp99 = tmp105 + } + var v110 any = tmp99 + _ = v110 + var tmp111 any + { // let + // let binding "pred__871" + tmp112 := checkDerefVar(var_glojure_DOT_core__EQ_) + var v113 any = tmp112 + _ = v113 + // let binding "expr__872" + var v114 any = v110 + _ = v114 + var tmp115 any + tmp116 := lang.Apply(v113, []any{kw_ints, v114}) + if lang.IsTruthy(tmp116) { + var tmp117 any + { // let + // let binding "vec__873" + tmp118 := checkDerefVar(var_glojure_DOT_core_prep_DASH_ints) + tmp119 := lang.Apply(tmp118, []any{v95, v98}) + var v120 any = tmp119 + _ = v120 + // let binding "shift" + tmp121 := checkDerefVar(var_glojure_DOT_core_nth) + tmp122 := lang.Apply(tmp121, []any{v120, int64(0), nil}) + var v123 any = tmp122 + _ = v123 + // let binding "mask" + tmp124 := checkDerefVar(var_glojure_DOT_core_nth) + tmp125 := lang.Apply(tmp124, []any{v120, int64(1), nil}) + var v126 any = tmp125 + _ = v126 + // let binding "imap" + tmp127 := checkDerefVar(var_glojure_DOT_core_nth) + tmp128 := lang.Apply(tmp127, []any{v120, int64(2), nil}) + var v129 any = tmp128 + _ = v129 + // let binding "switch-type" + tmp130 := checkDerefVar(var_glojure_DOT_core_nth) + tmp131 := lang.Apply(tmp130, []any{v120, int64(3), nil}) + var v132 any = tmp131 + _ = v132 + tmp133 := checkDerefVar(var_glojure_DOT_core_seq) + tmp134 := checkDerefVar(var_glojure_DOT_core_concat) + tmp135 := checkDerefVar(var_glojure_DOT_core_list) + tmp136 := lang.Apply(tmp135, []any{sym_glojure_DOT_core_SLASH_let}) + tmp137 := checkDerefVar(var_glojure_DOT_core_list) + tmp138 := checkDerefVar(var_glojure_DOT_core_apply) + tmp139 := checkDerefVar(var_glojure_DOT_core_vector) + tmp140 := checkDerefVar(var_glojure_DOT_core_seq) + tmp141 := checkDerefVar(var_glojure_DOT_core_concat) + tmp142 := checkDerefVar(var_glojure_DOT_core_list) + tmp143 := lang.Apply(tmp142, []any{v15}) + tmp144 := checkDerefVar(var_glojure_DOT_core_list) + tmp145 := lang.Apply(tmp144, []any{v4}) + tmp146 := lang.Apply(tmp141, []any{tmp143, tmp145}) + tmp147 := lang.Apply(tmp140, []any{tmp146}) + tmp148 := lang.Apply(tmp138, []any{tmp139, tmp147}) + tmp149 := lang.Apply(tmp137, []any{tmp148}) + tmp150 := checkDerefVar(var_glojure_DOT_core_list) + tmp151 := checkDerefVar(var_glojure_DOT_core_seq) + tmp152 := checkDerefVar(var_glojure_DOT_core_concat) + tmp153 := checkDerefVar(var_glojure_DOT_core_list) + tmp154 := lang.Apply(tmp153, []any{sym_case_STAR_}) + tmp155 := checkDerefVar(var_glojure_DOT_core_list) + tmp156 := lang.Apply(tmp155, []any{v15}) + tmp157 := checkDerefVar(var_glojure_DOT_core_list) + tmp158 := lang.Apply(tmp157, []any{v123}) + tmp159 := checkDerefVar(var_glojure_DOT_core_list) + tmp160 := lang.Apply(tmp159, []any{v126}) + tmp161 := checkDerefVar(var_glojure_DOT_core_list) + tmp162 := lang.Apply(tmp161, []any{v49}) + tmp163 := checkDerefVar(var_glojure_DOT_core_list) + tmp164 := lang.Apply(tmp163, []any{v129}) + tmp165 := checkDerefVar(var_glojure_DOT_core_list) + tmp166 := lang.Apply(tmp165, []any{v132}) + tmp167 := checkDerefVar(var_glojure_DOT_core_list) + tmp168 := lang.Apply(tmp167, []any{kw_int}) + tmp169 := lang.Apply(tmp152, []any{tmp154, tmp156, tmp158, tmp160, tmp162, tmp164, tmp166, tmp168}) + tmp170 := lang.Apply(tmp151, []any{tmp169}) + tmp171 := lang.Apply(tmp150, []any{tmp170}) + tmp172 := lang.Apply(tmp134, []any{tmp136, tmp149, tmp171}) + tmp173 := lang.Apply(tmp133, []any{tmp172}) + tmp117 = tmp173 + } // end let + tmp115 = tmp117 + } else { + var tmp118 any + tmp119 := lang.Apply(v113, []any{kw_hashes, v114}) + if lang.IsTruthy(tmp119) { + var tmp120 any + { // let + // let binding "vec__876" + tmp121 := checkDerefVar(var_glojure_DOT_core_prep_DASH_hashes) + tmp122 := lang.Apply(tmp121, []any{v15, v49, v95, v98}) + var v123 any = tmp122 + _ = v123 + // let binding "shift" + tmp124 := checkDerefVar(var_glojure_DOT_core_nth) + tmp125 := lang.Apply(tmp124, []any{v123, int64(0), nil}) + var v126 any = tmp125 + _ = v126 + // let binding "mask" + tmp127 := checkDerefVar(var_glojure_DOT_core_nth) + tmp128 := lang.Apply(tmp127, []any{v123, int64(1), nil}) + var v129 any = tmp128 + _ = v129 + // let binding "imap" + tmp130 := checkDerefVar(var_glojure_DOT_core_nth) + tmp131 := lang.Apply(tmp130, []any{v123, int64(2), nil}) + var v132 any = tmp131 + _ = v132 + // let binding "switch-type" + tmp133 := checkDerefVar(var_glojure_DOT_core_nth) + tmp134 := lang.Apply(tmp133, []any{v123, int64(3), nil}) + var v135 any = tmp134 + _ = v135 + // let binding "skip-check" + tmp136 := checkDerefVar(var_glojure_DOT_core_nth) + tmp137 := lang.Apply(tmp136, []any{v123, int64(4), nil}) + var v138 any = tmp137 + _ = v138 + tmp139 := checkDerefVar(var_glojure_DOT_core_seq) + tmp140 := checkDerefVar(var_glojure_DOT_core_concat) + tmp141 := checkDerefVar(var_glojure_DOT_core_list) + tmp142 := lang.Apply(tmp141, []any{sym_glojure_DOT_core_SLASH_let}) + tmp143 := checkDerefVar(var_glojure_DOT_core_list) + tmp144 := checkDerefVar(var_glojure_DOT_core_apply) + tmp145 := checkDerefVar(var_glojure_DOT_core_vector) + tmp146 := checkDerefVar(var_glojure_DOT_core_seq) + tmp147 := checkDerefVar(var_glojure_DOT_core_concat) + tmp148 := checkDerefVar(var_glojure_DOT_core_list) + tmp149 := lang.Apply(tmp148, []any{v15}) + tmp150 := checkDerefVar(var_glojure_DOT_core_list) + tmp151 := lang.Apply(tmp150, []any{v4}) + tmp152 := lang.Apply(tmp147, []any{tmp149, tmp151}) + tmp153 := lang.Apply(tmp146, []any{tmp152}) + tmp154 := lang.Apply(tmp144, []any{tmp145, tmp153}) + tmp155 := lang.Apply(tmp143, []any{tmp154}) + tmp156 := checkDerefVar(var_glojure_DOT_core_list) + tmp157 := checkDerefVar(var_glojure_DOT_core_seq) + tmp158 := checkDerefVar(var_glojure_DOT_core_concat) + tmp159 := checkDerefVar(var_glojure_DOT_core_list) + tmp160 := lang.Apply(tmp159, []any{sym_case_STAR_}) + tmp161 := checkDerefVar(var_glojure_DOT_core_list) + tmp162 := lang.Apply(tmp161, []any{v15}) + tmp163 := checkDerefVar(var_glojure_DOT_core_list) + tmp164 := lang.Apply(tmp163, []any{v126}) + tmp165 := checkDerefVar(var_glojure_DOT_core_list) + tmp166 := lang.Apply(tmp165, []any{v129}) + tmp167 := checkDerefVar(var_glojure_DOT_core_list) + tmp168 := lang.Apply(tmp167, []any{v49}) + tmp169 := checkDerefVar(var_glojure_DOT_core_list) + tmp170 := lang.Apply(tmp169, []any{v132}) + tmp171 := checkDerefVar(var_glojure_DOT_core_list) + tmp172 := lang.Apply(tmp171, []any{v135}) + tmp173 := checkDerefVar(var_glojure_DOT_core_list) + tmp174 := lang.Apply(tmp173, []any{kw_hash_DASH_equiv}) + tmp175 := checkDerefVar(var_glojure_DOT_core_list) + tmp176 := lang.Apply(tmp175, []any{v138}) + tmp177 := lang.Apply(tmp158, []any{tmp160, tmp162, tmp164, tmp166, tmp168, tmp170, tmp172, tmp174, tmp176}) + tmp178 := lang.Apply(tmp157, []any{tmp177}) + tmp179 := lang.Apply(tmp156, []any{tmp178}) + tmp180 := lang.Apply(tmp140, []any{tmp142, tmp155, tmp179}) + tmp181 := lang.Apply(tmp139, []any{tmp180}) + tmp120 = tmp181 + } // end let + tmp118 = tmp120 + } else { + var tmp121 any + tmp122 := lang.Apply(v113, []any{kw_identity, v114}) + if lang.IsTruthy(tmp122) { + var tmp123 any + { // let + // let binding "vec__879" + tmp124 := checkDerefVar(var_glojure_DOT_core_prep_DASH_hashes) + tmp125 := lang.Apply(tmp124, []any{v15, v49, v95, v98}) + var v126 any = tmp125 + _ = v126 + // let binding "shift" + tmp127 := checkDerefVar(var_glojure_DOT_core_nth) + tmp128 := lang.Apply(tmp127, []any{v126, int64(0), nil}) + var v129 any = tmp128 + _ = v129 + // let binding "mask" + tmp130 := checkDerefVar(var_glojure_DOT_core_nth) + tmp131 := lang.Apply(tmp130, []any{v126, int64(1), nil}) + var v132 any = tmp131 + _ = v132 + // let binding "imap" + tmp133 := checkDerefVar(var_glojure_DOT_core_nth) + tmp134 := lang.Apply(tmp133, []any{v126, int64(2), nil}) + var v135 any = tmp134 + _ = v135 + // let binding "switch-type" + tmp136 := checkDerefVar(var_glojure_DOT_core_nth) + tmp137 := lang.Apply(tmp136, []any{v126, int64(3), nil}) + var v138 any = tmp137 + _ = v138 + // let binding "skip-check" + tmp139 := checkDerefVar(var_glojure_DOT_core_nth) + tmp140 := lang.Apply(tmp139, []any{v126, int64(4), nil}) + var v141 any = tmp140 + _ = v141 + tmp142 := checkDerefVar(var_glojure_DOT_core_seq) + tmp143 := checkDerefVar(var_glojure_DOT_core_concat) + tmp144 := checkDerefVar(var_glojure_DOT_core_list) + tmp145 := lang.Apply(tmp144, []any{sym_glojure_DOT_core_SLASH_let}) + tmp146 := checkDerefVar(var_glojure_DOT_core_list) + tmp147 := checkDerefVar(var_glojure_DOT_core_apply) + tmp148 := checkDerefVar(var_glojure_DOT_core_vector) + tmp149 := checkDerefVar(var_glojure_DOT_core_seq) + tmp150 := checkDerefVar(var_glojure_DOT_core_concat) + tmp151 := checkDerefVar(var_glojure_DOT_core_list) + tmp152 := lang.Apply(tmp151, []any{v15}) + tmp153 := checkDerefVar(var_glojure_DOT_core_list) + tmp154 := lang.Apply(tmp153, []any{v4}) + tmp155 := lang.Apply(tmp150, []any{tmp152, tmp154}) + tmp156 := lang.Apply(tmp149, []any{tmp155}) + tmp157 := lang.Apply(tmp147, []any{tmp148, tmp156}) + tmp158 := lang.Apply(tmp146, []any{tmp157}) + tmp159 := checkDerefVar(var_glojure_DOT_core_list) + tmp160 := checkDerefVar(var_glojure_DOT_core_seq) + tmp161 := checkDerefVar(var_glojure_DOT_core_concat) + tmp162 := checkDerefVar(var_glojure_DOT_core_list) + tmp163 := lang.Apply(tmp162, []any{sym_case_STAR_}) + tmp164 := checkDerefVar(var_glojure_DOT_core_list) + tmp165 := lang.Apply(tmp164, []any{v15}) + tmp166 := checkDerefVar(var_glojure_DOT_core_list) + tmp167 := lang.Apply(tmp166, []any{v129}) + tmp168 := checkDerefVar(var_glojure_DOT_core_list) + tmp169 := lang.Apply(tmp168, []any{v132}) + tmp170 := checkDerefVar(var_glojure_DOT_core_list) + tmp171 := lang.Apply(tmp170, []any{v49}) + tmp172 := checkDerefVar(var_glojure_DOT_core_list) + tmp173 := lang.Apply(tmp172, []any{v135}) + tmp174 := checkDerefVar(var_glojure_DOT_core_list) + tmp175 := lang.Apply(tmp174, []any{v138}) + tmp176 := checkDerefVar(var_glojure_DOT_core_list) + tmp177 := lang.Apply(tmp176, []any{kw_hash_DASH_identity}) + tmp178 := checkDerefVar(var_glojure_DOT_core_list) + tmp179 := lang.Apply(tmp178, []any{v141}) + tmp180 := lang.Apply(tmp161, []any{tmp163, tmp165, tmp167, tmp169, tmp171, tmp173, tmp175, tmp177, tmp179}) + tmp181 := lang.Apply(tmp160, []any{tmp180}) + tmp182 := lang.Apply(tmp159, []any{tmp181}) + tmp183 := lang.Apply(tmp143, []any{tmp145, tmp158, tmp182}) + tmp184 := lang.Apply(tmp142, []any{tmp183}) + tmp123 = tmp184 + } // end let + tmp121 = tmp123 + } else { + tmp124 := checkDerefVar(var_glojure_DOT_core_str) + tmp125 := lang.Apply(tmp124, []any{"No matching clause: ", v114}) + tmp126 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp125}) + panic(tmp126) + } + tmp118 = tmp121 + } + tmp115 = tmp118 + } + tmp111 = tmp115 + } // end let + tmp76 = tmp111 + } // end let + tmp50 = tmp76 + } + tmp6 = tmp50 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_case = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_case.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // cat + { + tmp0 := sym_cat.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_rf)), kw_doc, "A transducer which concatenates the contents of each input, which must be a\n collection, into the reduction.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(7645), kw_end_DASH_line, int(7645))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "rrf" + tmp4 := checkDerefVar(var_glojure_DOT_core_preserving_DASH_reduced) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp8 := lang.Apply(v2, nil) + return tmp8 + case 1: + v8 := args[0] + _ = v8 + tmp9 := lang.Apply(v2, []any{v8}) + return tmp9 + case 2: + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_reduce) + tmp11 := lang.Apply(tmp10, []any{v6, v8, v9}) + return tmp11 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7651), kw_column, int(5), kw_end_DASH_line, int(7655), kw_end_DASH_column, int(36)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp3 = tmp9 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_cat = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_cat.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // mapcat + { + tmp0 := sym_mapcat.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym__AMP_, sym_colls)), kw_doc, "Returns the result of applying concat to the result of applying map\n to f and colls. Thus function f should return a collection. Returns\n a transducer when no collections are provided", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(2775), kw_end_DASH_line, int(2775))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_comp) + tmp4 := checkDerefVar(var_glojure_DOT_core_map) + tmp5 := lang.Apply(tmp4, []any{v2}) + tmp6 := checkDerefVar(var_glojure_DOT_core_cat) + tmp7 := lang.Apply(tmp3, []any{tmp5, tmp6}) + return tmp7 + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_apply) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_map) + tmp8 := lang.Apply(tmp6, []any{tmp7, v2, v3}) + tmp9 := lang.Apply(tmp4, []any{tmp5, tmp8}) + return tmp9 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_mapcat = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_mapcat.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // merge-hash-collisions + { + tmp0 := sym_merge_DASH_hash_DASH_collisions.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_expr_DASH_sym, sym_default, sym_tests, sym_thens)), kw_doc, "Takes a case expression, default expression, and a sequence of test constants\n and a corresponding sequence of then expressions. Returns a tuple of\n [tests thens skip-check-set] where no tests have the same hash. Each set of\n input test constants with the same hash is replaced with a single test\n constant (the case int), and their respective thens are combined into:\n (condp = expr\n test-1 then-1\n ...\n test-n then-n\n default).\n The skip-check is a set of case ints for which post-switch equivalence\n checking must not be done (the cases holding the above condp thens).", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(28), kw_column, int(8), kw_line, int(6647), kw_end_DASH_line, int(6647), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var tmp6 any + { // let + // let binding "buckets" + var tmp7 any + { // let + // let binding "m" + tmp8 := lang.NewMap() + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6661), kw_column, int(26), kw_end_DASH_line, int(6661), kw_end_DASH_column, int(27)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v11 any = tmp10 + _ = v11 + // let binding "ks" + var v12 any = v4 + _ = v12 + // let binding "vs" + var v13 any = v5 + _ = v13 + for { + var tmp14 any + var tmp15 any + { // let + // let binding "and__0__auto__" + var v16 any = v12 + _ = v16 + var tmp17 any + if lang.IsTruthy(v16) { + tmp17 = v13 + } else { + tmp17 = v16 + } + tmp15 = tmp17 + } // end let + if lang.IsTruthy(tmp15) { + tmp17 := checkDerefVar(var_glojure_DOT_core_update) + tmp18 := checkDerefVar(var_glojure_DOT_core_first) + tmp19 := lang.Apply(tmp18, []any{v12}) + tmp20 := lang.Apply(lang.Hash, []any{tmp19}) + tmp21 := checkDerefVar(var_glojure_DOT_core_fnil) + tmp22 := checkDerefVar(var_glojure_DOT_core_conj) + tmp23 := lang.NewVector() + tmp24 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6664), kw_column, int(102), kw_end_DASH_line, int(6664), kw_end_DASH_column, int(103)) + tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp26 := lang.Apply(tmp21, []any{tmp22, tmp25}) + tmp27 := checkDerefVar(var_glojure_DOT_core_first) + tmp28 := lang.Apply(tmp27, []any{v12}) + tmp29 := checkDerefVar(var_glojure_DOT_core_first) + tmp30 := lang.Apply(tmp29, []any{v13}) + tmp31 := lang.NewVector(tmp28, tmp30) + tmp32 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6664), kw_column, int(106), kw_end_DASH_line, int(6664), kw_end_DASH_column, int(128)) + tmp33, err := lang.WithMeta(tmp31, tmp32.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp34 := lang.Apply(tmp17, []any{v11, tmp20, tmp26, tmp33}) + var tmp16 any = tmp34 + tmp36 := checkDerefVar(var_glojure_DOT_core_next) + tmp37 := lang.Apply(tmp36, []any{v12}) + var tmp35 any = tmp37 + tmp39 := checkDerefVar(var_glojure_DOT_core_next) + tmp40 := lang.Apply(tmp39, []any{v13}) + var tmp38 any = tmp40 + v11 = tmp16 + v12 = tmp35 + v13 = tmp38 + continue + } else { + tmp14 = v11 + } + tmp7 = tmp14 + break + } + } // end let + var v8 any = tmp7 + _ = v8 + // let binding "assoc-multi" + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + v12 := args[2] + _ = v12 + var tmp13 any + { // let + // let binding "testexprs" + tmp14 := checkDerefVar(var_glojure_DOT_core_mapcat) + var tmp15 lang.FnFunc + tmp15 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v16 := args[0] + _ = v16 + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_first) + tmp19 := lang.Apply(tmp18, []any{v16}) + tmp20 := lang.Apply(tmp17, []any{sym_quote, tmp19}) + tmp21 := checkDerefVar(var_glojure_DOT_core_second) + tmp22 := lang.Apply(tmp21, []any{v16}) + tmp23 := lang.NewVector(tmp20, tmp22) + tmp24 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6668), kw_column, int(56), kw_end_DASH_line, int(6668), kw_end_DASH_column, int(93)) + tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp25 + }) + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6668), kw_column, int(47), kw_end_DASH_line, int(6668), kw_end_DASH_column, int(94)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp18 := lang.Apply(tmp14, []any{tmp17, v12}) + var v19 any = tmp18 + _ = v19 + // let binding "expr" + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{sym_glojure_DOT_core_SLASH_condp}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{sym_glojure_DOT_core_SLASH__EQ_}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v2}) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := lang.Apply(tmp28, []any{v3}) + tmp30 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27, v19, tmp29}) + tmp31 := lang.Apply(tmp20, []any{tmp30}) + var v32 any = tmp31 + _ = v32 + tmp33 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp34 := lang.Apply(tmp33, []any{v10, v11, v32}) + tmp13 = tmp34 + } // end let + return tmp13 + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6667), kw_column, int(21), kw_end_DASH_line, int(6670), kw_end_DASH_column, int(42)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v12 any = tmp11 + _ = v12 + // let binding "hmap" + tmp13 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v15 := args[0] + _ = v15 + v16 := args[1] + _ = v16 + var tmp17 any + { // let + // let binding "vec__855" + var v18 any = v16 + _ = v18 + // let binding "h" + tmp19 := checkDerefVar(var_glojure_DOT_core_nth) + tmp20 := lang.Apply(tmp19, []any{v18, int64(0), nil}) + var v21 any = tmp20 + _ = v21 + // let binding "bucket" + tmp22 := checkDerefVar(var_glojure_DOT_core_nth) + tmp23 := lang.Apply(tmp22, []any{v18, int64(1), nil}) + var v24 any = tmp23 + _ = v24 + var tmp25 any + tmp26 := checkDerefVar(var_glojure_DOT_core__EQ__EQ_) + tmp27 := checkDerefVar(var_glojure_DOT_core_count) + tmp28 := lang.Apply(tmp27, []any{v24}) + tmp29 := lang.Apply(tmp26, []any{int64(1), tmp28}) + if lang.IsTruthy(tmp29) { + tmp30 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp31 := checkDerefVar(var_glojure_DOT_core_ffirst) + tmp32 := lang.Apply(tmp31, []any{v24}) + tmp33 := checkDerefVar(var_glojure_DOT_core_second) + tmp34 := checkDerefVar(var_glojure_DOT_core_first) + tmp35 := lang.Apply(tmp34, []any{v24}) + tmp36 := lang.Apply(tmp33, []any{tmp35}) + tmp37 := lang.Apply(tmp30, []any{v15, tmp32, tmp36}) + tmp25 = tmp37 + } else { + tmp38 := lang.Apply(v12, []any{v15, v21, v24}) + tmp25 = tmp38 + } + tmp17 = tmp25 + } // end let + return tmp17 + }) + tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6672), kw_column, int(16), kw_end_DASH_line, int(6675), kw_end_DASH_column, int(45)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp17 := lang.NewMap() + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6676), kw_column, int(16), kw_end_DASH_line, int(6676), kw_end_DASH_column, int(17)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp20 := lang.Apply(tmp13, []any{tmp16, tmp19, v8}) + var v21 any = tmp20 + _ = v21 + // let binding "skip-check" + tmp22 := checkDerefVar(var_glojure_DOT_core_into1) + tmp23 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp24 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6680), kw_column, int(29), kw_end_DASH_line, int(6680), kw_end_DASH_column, int(31)) + tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp26 := checkDerefVar(var_glojure_DOT_core_map) + tmp27 := checkDerefVar(var_glojure_DOT_core_first) + tmp28 := checkDerefVar(var_glojure_DOT_core_filter) + var tmp29 lang.FnFunc + tmp29 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v30 := args[0] + _ = v30 + tmp31 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp32 := checkDerefVar(var_glojure_DOT_core_count) + tmp33 := checkDerefVar(var_glojure_DOT_core_second) + tmp34 := lang.Apply(tmp33, []any{v30}) + tmp35 := lang.Apply(tmp32, []any{tmp34}) + tmp36 := lang.Apply(tmp31, []any{int64(1), tmp35}) + return tmp36 + }) + tmp30 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6678), kw_column, int(30), kw_end_DASH_line, int(6678), kw_end_DASH_column, int(54)) + tmp31, err := lang.WithMeta(tmp29, tmp30.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp32 := lang.Apply(tmp28, []any{tmp31, v8}) + tmp33 := lang.Apply(tmp26, []any{tmp27, tmp32}) + tmp34 := lang.Apply(tmp22, []any{tmp25, tmp33}) + var v35 any = tmp34 + _ = v35 + tmp36 := checkDerefVar(var_glojure_DOT_core_keys) + tmp37 := lang.Apply(tmp36, []any{v21}) + tmp38 := checkDerefVar(var_glojure_DOT_core_vals) + tmp39 := lang.Apply(tmp38, []any{v21}) + tmp40 := lang.NewVector(tmp37, tmp39, v35) + tmp41 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6681), kw_column, int(5), kw_end_DASH_line, int(6681), kw_end_DASH_column, int(40)) + tmp42, err := lang.WithMeta(tmp40, tmp41.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp6 = tmp42 + } // end let + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_merge_DASH_hash_DASH_collisions = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_merge_DASH_hash_DASH_collisions.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // prep-hashes + { + tmp0 := sym_prep_DASH_hashes.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_expr_DASH_sym, sym_default, sym_tests, sym_thens)), kw_doc, "Takes a sequence of test constants and a corresponding sequence of then\n expressions. Returns a tuple of [shift mask case-map switch-type skip-check]\n where case-map is a map of int case values to [test then] tuples, switch-type\n is either :sparse or :compact, and skip-check is a set of case ints for which\n post-switch equivalence checking must not be done (occurs with hash\n collisions).", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(8), kw_line, int(6683), kw_end_DASH_line, int(6683), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var tmp6 any + { // let + // let binding "hashcode" + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v8 := args[0] + _ = v8 + tmp9 := lang.Apply(lang.Hash, []any{v8}) + return tmp9 + }) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6691), kw_column, int(18), kw_end_DASH_line, int(6691), kw_end_DASH_column, int(66)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v10 any = tmp9 + _ = v10 + // let binding "hashes" + tmp11 := checkDerefVar(var_glojure_DOT_core_into1) + tmp12 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6692), kw_column, int(23), kw_end_DASH_line, int(6692), kw_end_DASH_column, int(25)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp15 := checkDerefVar(var_glojure_DOT_core_map) + tmp16 := lang.Apply(tmp15, []any{v10, v4}) + tmp17 := lang.Apply(tmp11, []any{tmp14, tmp16}) + var v18 any = tmp17 + _ = v18 + var tmp19 any + tmp20 := checkDerefVar(var_glojure_DOT_core__EQ__EQ_) + tmp21 := checkDerefVar(var_glojure_DOT_core_count) + tmp22 := lang.Apply(tmp21, []any{v4}) + tmp23 := checkDerefVar(var_glojure_DOT_core_count) + tmp24 := lang.Apply(tmp23, []any{v18}) + tmp25 := lang.Apply(tmp20, []any{tmp22, tmp24}) + if lang.IsTruthy(tmp25) { + var tmp26 any + tmp27 := checkDerefVar(var_glojure_DOT_core_fits_DASH_table_QMARK_) + tmp28 := lang.Apply(tmp27, []any{v18}) + if lang.IsTruthy(tmp28) { + tmp29 := checkDerefVar(var_glojure_DOT_core_case_DASH_map) + tmp30 := checkDerefVar(var_glojure_DOT_core_identity) + tmp31 := lang.Apply(tmp29, []any{v10, tmp30, v4, v5}) + tmp32 := lang.NewVector(int64(0), int64(0), tmp31, kw_compact) + tmp33 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6696), kw_column, int(9), kw_end_DASH_line, int(6696), kw_end_DASH_column, int(63)) + tmp34, err := lang.WithMeta(tmp32, tmp33.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp26 = tmp34 + } else { + var tmp35 any + { // let + // let binding "vec__858" + var tmp36 any + { // let + // let binding "or__0__auto__" + tmp37 := checkDerefVar(var_glojure_DOT_core_maybe_DASH_min_DASH_hash) + tmp38 := lang.Apply(tmp37, []any{v18}) + var v39 any = tmp38 + _ = v39 + var tmp40 any + if lang.IsTruthy(v39) { + tmp40 = v39 + } else { + tmp41 := lang.NewVector(int64(0), int64(0)) + tmp42 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6697), kw_column, int(56), kw_end_DASH_line, int(6697), kw_end_DASH_column, int(60)) + tmp43, err := lang.WithMeta(tmp41, tmp42.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp40 = tmp43 + } + tmp36 = tmp40 + } // end let + var v37 any = tmp36 + _ = v37 + // let binding "shift" + tmp38 := checkDerefVar(var_glojure_DOT_core_nth) + tmp39 := lang.Apply(tmp38, []any{v37, int64(0), nil}) + var v40 any = tmp39 + _ = v40 + // let binding "mask" + tmp41 := checkDerefVar(var_glojure_DOT_core_nth) + tmp42 := lang.Apply(tmp41, []any{v37, int64(1), nil}) + var v43 any = tmp42 + _ = v43 + var tmp44 any + tmp45 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) + tmp46 := lang.Apply(tmp45, []any{v43}) + if lang.IsTruthy(tmp46) { + tmp47 := checkDerefVar(var_glojure_DOT_core_case_DASH_map) + tmp48 := checkDerefVar(var_glojure_DOT_core_identity) + tmp49 := lang.Apply(tmp47, []any{v10, tmp48, v4, v5}) + tmp50 := lang.NewVector(int64(0), int64(0), tmp49, kw_sparse) + tmp51 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6700), kw_column, int(13), kw_end_DASH_line, int(6700), kw_end_DASH_column, int(66)) + tmp52, err := lang.WithMeta(tmp50, tmp51.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp44 = tmp52 + } else { + tmp53 := checkDerefVar(var_glojure_DOT_core_case_DASH_map) + var tmp54 lang.FnFunc + tmp54 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v55 := args[0] + _ = v55 + tmp56 := checkDerefVar(var_glojure_DOT_core_shift_DASH_mask) + tmp57 := lang.Apply(v10, []any{v55}) + tmp58 := lang.Apply(tmp56, []any{v40, v43, tmp57}) + return tmp58 + }) + tmp55 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6702), kw_column, int(35), kw_end_DASH_line, int(6702), kw_end_DASH_column, int(71)) + tmp56, err := lang.WithMeta(tmp54, tmp55.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp57 := checkDerefVar(var_glojure_DOT_core_identity) + tmp58 := lang.Apply(tmp53, []any{tmp56, tmp57, v4, v5}) + tmp59 := lang.NewVector(v40, v43, tmp58, kw_compact) + tmp60 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6702), kw_column, int(13), kw_end_DASH_line, int(6702), kw_end_DASH_column, int(103)) + tmp61, err := lang.WithMeta(tmp59, tmp60.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp44 = tmp61 + } + tmp35 = tmp44 + } // end let + tmp26 = tmp35 + } + tmp19 = tmp26 + } else { + var tmp36 any + { // let + // let binding "vec__861" + tmp37 := checkDerefVar(var_glojure_DOT_core_merge_DASH_hash_DASH_collisions) + tmp38 := lang.Apply(tmp37, []any{v2, v3, v4, v5}) + var v39 any = tmp38 + _ = v39 + // let binding "tests" + tmp40 := checkDerefVar(var_glojure_DOT_core_nth) + tmp41 := lang.Apply(tmp40, []any{v39, int64(0), nil}) + var v42 any = tmp41 + _ = v42 + // let binding "thens" + tmp43 := checkDerefVar(var_glojure_DOT_core_nth) + tmp44 := lang.Apply(tmp43, []any{v39, int64(1), nil}) + var v45 any = tmp44 + _ = v45 + // let binding "skip-check" + tmp46 := checkDerefVar(var_glojure_DOT_core_nth) + tmp47 := lang.Apply(tmp46, []any{v39, int64(2), nil}) + var v48 any = tmp47 + _ = v48 + // let binding "vec__864" + tmp49 := checkDerefVar(var_glojure_DOT_core_prep_DASH_hashes) + tmp50 := lang.Apply(tmp49, []any{v2, v3, v42, v45}) + var v51 any = tmp50 + _ = v51 + // let binding "shift" + tmp52 := checkDerefVar(var_glojure_DOT_core_nth) + tmp53 := lang.Apply(tmp52, []any{v51, int64(0), nil}) + var v54 any = tmp53 + _ = v54 + // let binding "mask" + tmp55 := checkDerefVar(var_glojure_DOT_core_nth) + tmp56 := lang.Apply(tmp55, []any{v51, int64(1), nil}) + var v57 any = tmp56 + _ = v57 + // let binding "case-map" + tmp58 := checkDerefVar(var_glojure_DOT_core_nth) + tmp59 := lang.Apply(tmp58, []any{v51, int64(2), nil}) + var v60 any = tmp59 + _ = v60 + // let binding "switch-type" + tmp61 := checkDerefVar(var_glojure_DOT_core_nth) + tmp62 := lang.Apply(tmp61, []any{v51, int64(3), nil}) + var v63 any = tmp62 + _ = v63 + // let binding "skip-check" + var tmp64 any + tmp65 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) + tmp66 := lang.Apply(tmp65, []any{v57}) + if lang.IsTruthy(tmp66) { + tmp64 = v48 + } else { + tmp67 := checkDerefVar(var_glojure_DOT_core_into1) + tmp68 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp69 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6708), kw_column, int(33), kw_end_DASH_line, int(6708), kw_end_DASH_column, int(35)) + tmp70, err := lang.WithMeta(tmp68, tmp69.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp71 := checkDerefVar(var_glojure_DOT_core_map) + var tmp72 lang.FnFunc + tmp72 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v73 := args[0] + _ = v73 + tmp74 := checkDerefVar(var_glojure_DOT_core_shift_DASH_mask) + tmp75 := lang.Apply(tmp74, []any{v54, v57, v73}) + return tmp75 + }) + tmp73 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6708), kw_column, int(42), kw_end_DASH_line, int(6708), kw_end_DASH_column, int(67)) + tmp74, err := lang.WithMeta(tmp72, tmp73.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp75 := lang.Apply(tmp71, []any{tmp74, v48}) + tmp76 := lang.Apply(tmp67, []any{tmp70, tmp75}) + tmp64 = tmp76 + } + var v77 any = tmp64 + _ = v77 + tmp78 := lang.NewVector(v54, v57, v60, v63, v77) + tmp79 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6709), kw_column, int(9), kw_end_DASH_line, int(6709), kw_end_DASH_column, int(52)) + tmp80, err := lang.WithMeta(tmp78, tmp79.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp36 = tmp80 + } // end let + tmp19 = tmp36 + } + tmp6 = tmp19 + } // end let + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_prep_DASH_hashes = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_prep_DASH_hashes.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // tree-seq + { + tmp0 := sym_tree_DASH_seq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_branch_QMARK_, sym_children, sym_root)), kw_doc, "Returns a lazy sequence of the nodes in a tree, via a depth-first walk.\n branch? must be a fn of one arg that returns true if passed a node\n that can have children (but may not). children must be a fn of one\n arg that returns a sequence of the children. Will only be called on\n nodes for which branch? returns true. Root is the root node of the\n tree.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(4955), kw_end_DASH_line, int(4955))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + { // let + // let binding "walk" + var tmp6 lang.FnFunc + { // function walk + var v7 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v8 := args[0] + _ = v8 + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp10 := checkDerefVar(var_glojure_DOT_core_cons) + var tmp11 any + tmp12 := lang.Apply(v2, []any{v8}) + if lang.IsTruthy(tmp12) { + tmp13 := checkDerefVar(var_glojure_DOT_core_mapcat) + tmp14 := lang.Apply(v3, []any{v8}) + tmp15 := lang.Apply(tmp13, []any{v7, tmp14}) + tmp11 = tmp15 + } else { + } + tmp16 := lang.Apply(tmp10, []any{v8, tmp11}) + return tmp16 + }) + tmp10 := lang.Apply(lang.NewLazySeq, []any{tmp9}) + return tmp10 + }) + v7 = tmp6 + _ = v7 + } + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4965), kw_column, int(15), kw_end_DASH_line, int(4969), kw_end_DASH_column, int(53)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v9 any = tmp8 + _ = v9 + tmp10 := lang.Apply(v9, []any{v4}) + tmp5 = tmp10 + } // end let + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_tree_DASH_seq = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_tree_DASH_seq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // xml-seq + { + tmp0 := sym_xml_DASH_seq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_root)), kw_doc, "A tree seq on the xml elements as per xml/parse", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4982), kw_end_DASH_line, int(4982))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_tree_DASH_seq) + tmp4 := checkDerefVar(var_glojure_DOT_core_complement) + tmp5 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp6 := lang.Apply(tmp4, []any{tmp5}) + tmp7 := checkDerefVar(var_glojure_DOT_core_comp) + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := lang.Apply(tmp7, []any{tmp8, kw_content}) + tmp10 := lang.Apply(tmp3, []any{tmp6, tmp9, v2}) + return tmp10 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_xml_DASH_seq = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_xml_DASH_seq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // emit-extend-type + { + tmp0 := sym_emit_DASH_extend_DASH_type.WithMeta(lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(175), kw_column, int(8), kw_end_DASH_line, int(175), kw_end_DASH_column, int(23), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_c, sym_specs)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "impls" + tmp5 := checkDerefVar(var_glojure_DOT_core_parse_DASH_impls) + tmp6 := lang.Apply(tmp5, []any{v3}) + var v7 any = tmp6 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_extend}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v2}) + tmp14 := checkDerefVar(var_glojure_DOT_core_mapcat) + tmp15 := checkDerefVar(var_glojure_DOT_core_partial) + tmp16 := checkDerefVar(var_glojure_DOT_core_emit_DASH_hinted_DASH_impl) + tmp17 := lang.Apply(tmp15, []any{tmp16, v2}) + tmp18 := lang.Apply(tmp14, []any{tmp17, v7}) + tmp19 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp18}) + tmp20 := lang.Apply(tmp8, []any{tmp19}) + tmp4 = tmp20 + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_emit_DASH_extend_DASH_type = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_emit_DASH_extend_DASH_type.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // extend-type + { + tmp0 := sym_extend_DASH_type.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_t, sym__AMP_, sym_specs)), kw_doc, "A macro that expands into an extend call. Useful when you are\n supplying the definitions explicitly inline, extend-type\n automatically creates the maps required by extend. Propagates the\n class as a type hint on the first argument of all fns.\n\n (extend-type MyType \n Countable\n (cnt [c] ...)\n Foo\n (bar [x y] ...)\n (baz ([x] ...) ([x y & zs] ...)))\n\n expands into:\n\n (extend MyType\n Countable\n {:cnt (fn [c] ...)}\n Foo\n {:baz (fn ([x] ...) ([x y & zs] ...))\n :bar (fn [x y] ...)})", kw_file, "glojure/core_deftype.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(11), kw_line, int(180), kw_end_DASH_line, int(180))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_emit_DASH_extend_DASH_type) + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_extend_DASH_type = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_extend_DASH_type.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // file-seq + { + tmp0 := sym_file_DASH_seq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_dir)), kw_doc, "A tree seq on java.io.Files", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(4972), kw_end_DASH_line, int(4972))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_tree_DASH_seq) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v5 := args[0] + _ = v5 + tmp6, _ := lang.FieldOrMethod(v5, "isDirectory") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("isDirectory is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{}) + return tmp7 + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4978), kw_column, int(6), kw_end_DASH_line, int(4978), kw_end_DASH_column, int(47)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v8 := args[0] + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_seq) + tmp10, _ := lang.FieldOrMethod(v8, "listFiles") + if reflect.TypeOf(tmp10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("listFiles is not a function"))) + } + tmp11 := lang.Apply(tmp10, []any{}) + tmp12 := lang.Apply(tmp9, []any{tmp11}) + return tmp12 + }) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4979), kw_column, int(6), kw_end_DASH_line, int(4979), kw_end_DASH_column, int(51)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp10 := lang.Apply(tmp3, []any{tmp6, tmp9, v2}) + return tmp10 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_file_DASH_seq = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_file_DASH_seq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // flatten + { + tmp0 := sym_flatten.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Takes any nested combination of sequential things (lists, vectors,\n etc.) and returns their contents as a single, flat lazy sequence.\n (flatten nil) returns an empty sequence.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(7118), kw_end_DASH_line, int(7118))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_filter) + tmp4 := checkDerefVar(var_glojure_DOT_core_complement) + tmp5 := checkDerefVar(var_glojure_DOT_core_sequential_QMARK_) + tmp6 := lang.Apply(tmp4, []any{tmp5}) + tmp7 := checkDerefVar(var_glojure_DOT_core_rest) + tmp8 := checkDerefVar(var_glojure_DOT_core_tree_DASH_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_sequential_QMARK_) + tmp10 := checkDerefVar(var_glojure_DOT_core_seq) + tmp11 := lang.Apply(tmp8, []any{tmp9, tmp10, v2}) + tmp12 := lang.Apply(tmp7, []any{tmp11}) + tmp13 := lang.Apply(tmp3, []any{tmp6, tmp12}) + return tmp13 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_flatten = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_flatten.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // compile + { + tmp0 := sym_compile.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_lib)), kw_doc, "Compiles the namespace named by the symbol lib into a set of\n classfiles. The source for the lib must be in a proper\n classpath-relative directory. The output files will go into the\n directory specified by *compile-path*, and that directory too must\n be in the classpath.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(6114), kw_end_DASH_line, int(6114))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + tmp4 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp5 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp6 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_compile_DASH_files_STAR_) + tmp7 := lang.Apply(tmp5, []any{tmp6, true}) + tmp8 := lang.Apply(tmp4, []any{tmp7}) + _ = tmp8 + var tmp9 any + func() { + defer func() { + tmp10 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp11 := lang.Apply(tmp10, nil) + _ = tmp11 + }() + tmp12 := checkDerefVar(var_glojure_DOT_core_load_DASH_one) + tmp13 := lang.Apply(tmp12, []any{v2, true, true}) + tmp9 = tmp13 + }() + tmp3 = tmp9 + } // end let + _ = tmp3 + return v2 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_compile = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_compile.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // derive + { + tmp0 := sym_derive.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_tag, sym_parent), lang.NewVector(sym_h, sym_tag, sym_parent)), kw_doc, "Establishes a parent/child relationship between parent and\n tag. Parent must be a namespace-qualified symbol or keyword and\n child can be either a namespace-qualified symbol or keyword or a\n class. h must be a hierarchy obtained from make-hierarchy, if not\n supplied defaults to, and modifies, the global hierarchy.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(5605), kw_end_DASH_line, int(5605))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_alter_DASH_var_DASH_root) + tmp5 := lang.InternVarName(sym_glojure_DOT_core, sym_global_DASH_hierarchy) + tmp6 := checkDerefVar(var_glojure_DOT_core_derive) + tmp7 := lang.Apply(tmp4, []any{tmp5, tmp6, v2, v3}) + _ = tmp7 + return nil + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + { // let + // let binding "tp" + tmp6 := lang.Apply(kw_parents, []any{v2}) + var v7 any = tmp6 + _ = v7 + // let binding "td" + tmp8 := lang.Apply(kw_descendants, []any{v2}) + var v9 any = tmp8 + _ = v9 + // let binding "ta" + tmp10 := lang.Apply(kw_ancestors, []any{v2}) + var v11 any = tmp10 + _ = v11 + // let binding "tf" + var tmp12 lang.FnFunc + tmp12 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 5) + v13 := args[0] + _ = v13 + v14 := args[1] + _ = v14 + v15 := args[2] + _ = v15 + v16 := args[3] + _ = v16 + v17 := args[4] + _ = v17 + tmp18 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp19 lang.FnFunc + tmp19 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v20 := args[0] + _ = v20 + v21 := args[1] + _ = v21 + tmp22 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp23 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp24 := checkDerefVar(var_glojure_DOT_core_conj) + tmp25 := checkDerefVar(var_glojure_DOT_core_get) + tmp26 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp27 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5628), kw_column, int(61), kw_end_DASH_line, int(5628), kw_end_DASH_column, int(63)) + tmp28, err := lang.WithMeta(tmp26, tmp27.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp29 := lang.Apply(tmp25, []any{v17, v21, tmp28}) + tmp30 := checkDerefVar(var_glojure_DOT_core_cons) + tmp31 := lang.Apply(v17, []any{v16}) + tmp32 := lang.Apply(tmp30, []any{v16, tmp31}) + tmp33 := lang.Apply(tmp23, []any{tmp24, tmp29, tmp32}) + tmp34 := lang.Apply(tmp22, []any{v20, v21, tmp33}) + return tmp34 + }) + tmp20 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5626), kw_column, int(24), kw_end_DASH_line, int(5628), kw_end_DASH_column, int(98)) + tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp22 := checkDerefVar(var_glojure_DOT_core_cons) + tmp23 := lang.Apply(v15, []any{v14}) + tmp24 := lang.Apply(tmp22, []any{v14, tmp23}) + tmp25 := lang.Apply(tmp18, []any{tmp21, v13, tmp24}) + return tmp25 + }) + tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5625), kw_column, int(13), kw_end_DASH_line, int(5629), kw_end_DASH_column, int(56)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v15 any = tmp14 + _ = v15 + var tmp16 any + { // let + // let binding "or__0__auto__" + var tmp17 any + tmp18 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp19 := lang.Apply(v7, []any{v3}) + tmp20 := lang.Apply(tmp18, []any{tmp19, v4}) + if lang.IsTruthy(tmp20) { + } else { + var tmp21 any + tmp22 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp23 := lang.Apply(v11, []any{v3}) + tmp24 := lang.Apply(tmp22, []any{tmp23, v4}) + if lang.IsTruthy(tmp24) { + tmp25 := checkDerefVar(var_glojure_DOT_core_print_DASH_str) + tmp26 := lang.Apply(tmp25, []any{v3, "already has", v4, "as ancestor"}) + tmp27 := lang.Apply(lang.NewError, []any{tmp26}) + panic(tmp27) + } else { + } + _ = tmp21 + var tmp28 any + tmp29 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp30 := lang.Apply(v11, []any{v4}) + tmp31 := lang.Apply(tmp29, []any{tmp30, v3}) + if lang.IsTruthy(tmp31) { + tmp32 := checkDerefVar(var_glojure_DOT_core_print_DASH_str) + tmp33 := lang.Apply(tmp32, []any{"Cyclic derivation:", v4, "has", v3, "as ancestor"}) + tmp34 := lang.Apply(lang.NewError, []any{tmp33}) + panic(tmp34) + } else { + } + _ = tmp28 + tmp35 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp36 := lang.Apply(kw_parents, []any{v2}) + tmp37 := checkDerefVar(var_glojure_DOT_core_conj) + tmp38 := checkDerefVar(var_glojure_DOT_core_get) + tmp39 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp40 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5636), kw_column, int(61), kw_end_DASH_line, int(5636), kw_end_DASH_column, int(63)) + tmp41, err := lang.WithMeta(tmp39, tmp40.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp42 := lang.Apply(tmp38, []any{v7, v3, tmp41}) + tmp43 := lang.Apply(tmp37, []any{tmp42, v4}) + tmp44 := lang.Apply(tmp35, []any{tmp36, v3, tmp43}) + tmp45 := lang.Apply(kw_ancestors, []any{v2}) + tmp46 := lang.Apply(v15, []any{tmp45, v3, v9, v4, v11}) + tmp47 := lang.Apply(kw_descendants, []any{v2}) + tmp48 := lang.Apply(v15, []any{tmp47, v4, v11, v3, v9}) + tmp49 := lang.NewMap(kw_parents, tmp44, kw_ancestors, tmp46, kw_descendants, tmp48) + tmp50 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5636), kw_column, int(9), kw_end_DASH_line, int(5638), kw_end_DASH_column, int(61)) + tmp51, err := lang.WithMeta(tmp49, tmp50.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp17 = tmp51 + } + var v52 any = tmp17 + _ = v52 + var tmp53 any + if lang.IsTruthy(v52) { + tmp53 = v52 + } else { + tmp53 = v2 + } + tmp16 = tmp53 + } // end let + tmp5 = tmp16 + } // end let + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_derive = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_derive.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // underive + { + tmp0 := sym_underive.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_tag, sym_parent), lang.NewVector(sym_h, sym_tag, sym_parent)), kw_doc, "Removes a parent/child relationship between parent and\n tag. h must be a hierarchy obtained from make-hierarchy, if not\n supplied defaults to, and modifies, the global hierarchy.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(5643), kw_end_DASH_line, int(5643))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_alter_DASH_var_DASH_root) + tmp5 := lang.InternVarName(sym_glojure_DOT_core, sym_global_DASH_hierarchy) + tmp6 := checkDerefVar(var_glojure_DOT_core_underive) + tmp7 := lang.Apply(tmp4, []any{tmp5, tmp6, v2, v3}) + _ = tmp7 + return nil + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + { // let + // let binding "parentMap" + tmp6 := lang.Apply(kw_parents, []any{v2}) + var v7 any = tmp6 + _ = v7 + // let binding "childsParents" + var tmp8 any + tmp9 := lang.Apply(v7, []any{v3}) + if lang.IsTruthy(tmp9) { + tmp10 := checkDerefVar(var_glojure_DOT_core_disj) + tmp11 := lang.Apply(v7, []any{v3}) + tmp12 := lang.Apply(tmp10, []any{tmp11, v4}) + tmp8 = tmp12 + } else { + tmp13 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5652), kw_column, int(36), kw_end_DASH_line, int(5652), kw_end_DASH_column, int(38)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp8 = tmp15 + } + var v16 any = tmp8 + _ = v16 + // let binding "newParents" + var tmp17 any + tmp18 := checkDerefVar(var_glojure_DOT_core_not_DASH_empty) + tmp19 := lang.Apply(tmp18, []any{v16}) + if lang.IsTruthy(tmp19) { + tmp20 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp21 := lang.Apply(tmp20, []any{v7, v3, v16}) + tmp17 = tmp21 + } else { + tmp22 := checkDerefVar(var_glojure_DOT_core_dissoc) + tmp23 := lang.Apply(tmp22, []any{v7, v3}) + tmp17 = tmp23 + } + var v24 any = tmp17 + _ = v24 + // let binding "deriv-seq" + tmp25 := checkDerefVar(var_glojure_DOT_core_flatten) + tmp26 := checkDerefVar(var_glojure_DOT_core_map) + var tmp27 lang.FnFunc + tmp27 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v28 := args[0] + _ = v28 + tmp29 := checkDerefVar(var_glojure_DOT_core_cons) + tmp30 := checkDerefVar(var_glojure_DOT_core_key) + tmp31 := lang.Apply(tmp30, []any{v28}) + tmp32 := checkDerefVar(var_glojure_DOT_core_interpose) + tmp33 := checkDerefVar(var_glojure_DOT_core_key) + tmp34 := lang.Apply(tmp33, []any{v28}) + tmp35 := checkDerefVar(var_glojure_DOT_core_val) + tmp36 := lang.Apply(tmp35, []any{v28}) + tmp37 := lang.Apply(tmp32, []any{tmp34, tmp36}) + tmp38 := lang.Apply(tmp29, []any{tmp31, tmp37}) + return tmp38 + }) + tmp28 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5656), kw_column, int(28), kw_end_DASH_line, int(5656), kw_end_DASH_column, int(70)) + tmp29, err := lang.WithMeta(tmp27, tmp28.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp30 := checkDerefVar(var_glojure_DOT_core_seq) + tmp31 := lang.Apply(tmp30, []any{v24}) + tmp32 := lang.Apply(tmp26, []any{tmp29, tmp31}) + tmp33 := lang.Apply(tmp25, []any{tmp32}) + var v34 any = tmp33 + _ = v34 + var tmp35 any + tmp36 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp37 := lang.Apply(v7, []any{v3}) + tmp38 := lang.Apply(tmp36, []any{tmp37, v4}) + if lang.IsTruthy(tmp38) { + tmp39 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp40 lang.FnFunc + tmp40 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v41 := args[0] + _ = v41 + v42 := args[1] + _ = v42 + tmp43 := checkDerefVar(var_glojure_DOT_core_apply) + tmp44 := checkDerefVar(var_glojure_DOT_core_derive) + tmp45 := lang.Apply(tmp43, []any{tmp44, v41, v42}) + return tmp45 + }) + tmp41 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5659), kw_column, int(11), kw_end_DASH_line, int(5659), kw_end_DASH_column, int(31)) + tmp42, err := lang.WithMeta(tmp40, tmp41.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp43 := checkDerefVar(var_glojure_DOT_core_make_DASH_hierarchy) + tmp44 := lang.Apply(tmp43, nil) + tmp45 := checkDerefVar(var_glojure_DOT_core_partition) + tmp46 := lang.Apply(tmp45, []any{int64(2), v34}) + tmp47 := lang.Apply(tmp39, []any{tmp42, tmp44, tmp46}) + tmp35 = tmp47 + } else { + tmp35 = v2 + } + tmp5 = tmp35 + } // end let + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_underive = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_underive.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // filterv + { + tmp0 := sym_filterv.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns a vector of the items in coll for which\n (pred item) returns logical true. pred must be free of side-effects.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.4", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(6961), kw_end_DASH_line, int(6961))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp5 := checkDerefVar(var_glojure_DOT_core_reduce) + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + var tmp9 any + tmp10 := lang.Apply(v2, []any{v8}) + if lang.IsTruthy(tmp10) { + tmp11 := checkDerefVar(var_glojure_DOT_core_conj_BANG_) + tmp12 := lang.Apply(tmp11, []any{v7, v8}) + tmp9 = tmp12 + } else { + tmp9 = v7 + } + return tmp9 + }) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6967), kw_column, int(15), kw_end_DASH_line, int(6967), kw_end_DASH_column, int(52)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp9 := checkDerefVar(var_glojure_DOT_core_transient) + tmp10 := lang.NewVector() + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6968), kw_column, int(26), kw_end_DASH_line, int(6968), kw_end_DASH_column, int(27)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := lang.Apply(tmp9, []any{tmp12}) + tmp14 := lang.Apply(tmp5, []any{tmp8, tmp13, v3}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_filterv = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_filterv.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // flush + { + tmp0 := sym_flush.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Flushes the output stream that is the current value of\n *out*", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3706), kw_end_DASH_line, int(3706))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp2 := checkDerefVar(var_glojure_DOT_core__STAR_out_STAR_) + tmp3, _ := lang.FieldOrMethod(tmp2, "Sync") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Sync is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{}) + _ = tmp4 + return nil + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_flush = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_flush.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // frequencies + { + tmp0 := sym_frequencies.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a map from distinct items in coll to the number of times\n they appear.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(7185), kw_end_DASH_line, int(7185))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp4 := checkDerefVar(var_glojure_DOT_core_reduce) + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_assoc_BANG_) + tmp9 := checkDerefVar(var_glojure_DOT_core_inc) + tmp10 := checkDerefVar(var_glojure_DOT_core_get) + tmp11 := lang.Apply(tmp10, []any{v6, v7, int64(0)}) + tmp12 := lang.Apply(tmp9, []any{tmp11}) + tmp13 := lang.Apply(tmp8, []any{v6, v7, tmp12}) + return tmp13 + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7192), kw_column, int(12), kw_end_DASH_line, int(7193), kw_end_DASH_column, int(54)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp8 := checkDerefVar(var_glojure_DOT_core_transient) + tmp9 := lang.NewMap() + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7194), kw_column, int(23), kw_end_DASH_line, int(7194), kw_end_DASH_column, int(24)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp12 := lang.Apply(tmp8, []any{tmp11}) + tmp13 := lang.Apply(tmp4, []any{tmp7, tmp12, v2}) + tmp14 := lang.Apply(tmp3, []any{tmp13}) + return tmp14 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_frequencies = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_frequencies.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // group-by + { + tmp0 := sym_group_DASH_by.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_coll)), kw_doc, "Returns a map of the elements of coll keyed by the result of\n f on each element. The value at each key will be a vector of the\n corresponding elements, in the order they appeared in coll.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(7128), kw_end_DASH_line, int(7128))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp5 := checkDerefVar(var_glojure_DOT_core_reduce) + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + var tmp9 any + { // let + // let binding "k" + tmp10 := lang.Apply(v2, []any{v8}) + var v11 any = tmp10 + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_assoc_BANG_) + tmp13 := checkDerefVar(var_glojure_DOT_core_conj) + tmp14 := checkDerefVar(var_glojure_DOT_core_get) + tmp15 := lang.NewVector() + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7139), kw_column, int(40), kw_end_DASH_line, int(7139), kw_end_DASH_column, int(41)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp18 := lang.Apply(tmp14, []any{v7, v11, tmp17}) + tmp19 := lang.Apply(tmp13, []any{tmp18, v8}) + tmp20 := lang.Apply(tmp12, []any{v7, v11, tmp19}) + tmp9 = tmp20 + } // end let + return tmp9 + }) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7137), kw_column, int(5), kw_end_DASH_line, int(7139), kw_end_DASH_column, int(48)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp9 := checkDerefVar(var_glojure_DOT_core_transient) + tmp10 := lang.NewMap() + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7140), kw_column, int(16), kw_end_DASH_line, int(7140), kw_end_DASH_column, int(17)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := lang.Apply(tmp9, []any{tmp12}) + tmp14 := lang.Apply(tmp5, []any{tmp8, tmp13, v3}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_group_DASH_by = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_group_DASH_by.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // into + { + tmp0 := sym_into.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_to), lang.NewVector(sym_to, sym_from), lang.NewVector(sym_to, sym_xform, sym_from)), kw_doc, "Returns a new coll consisting of to with all of the items of\n from conjoined. A transducer may be supplied.\n (into x) returns x. (into) returns [].", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(6922), kw_end_DASH_line, int(6922))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp2 := lang.NewVector() + tmp3 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6928), kw_column, int(7), kw_end_DASH_line, int(6928), kw_end_DASH_column, int(8)) + tmp4, err := lang.WithMeta(tmp2, tmp3.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp4 + case 1: + v2 := args[0] + _ = v2 + return v2 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp6 := reflect.TypeOf((*lang.IEditableCollection)(nil)).Elem() + tmp7 := lang.Apply(tmp5, []any{tmp6, v2}) + if lang.IsTruthy(tmp7) { + tmp8 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp9 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp10 := checkDerefVar(var_glojure_DOT_core_reduce) + tmp11 := checkDerefVar(var_glojure_DOT_core_conj_BANG_) + tmp12 := checkDerefVar(var_glojure_DOT_core_transient) + tmp13 := lang.Apply(tmp12, []any{v2}) + tmp14 := lang.Apply(tmp10, []any{tmp11, tmp13, v3}) + tmp15 := lang.Apply(tmp9, []any{tmp14}) + tmp16 := checkDerefVar(var_glojure_DOT_core_meta) + tmp17 := lang.Apply(tmp16, []any{v2}) + tmp18 := lang.Apply(tmp8, []any{tmp15, tmp17}) + tmp4 = tmp18 + } else { + tmp19 := checkDerefVar(var_glojure_DOT_core_reduce) + tmp20 := checkDerefVar(var_glojure_DOT_core_conj) + tmp21 := lang.Apply(tmp19, []any{tmp20, v2, v3}) + tmp4 = tmp21 + } + return tmp4 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp7 := reflect.TypeOf((*lang.IEditableCollection)(nil)).Elem() + tmp8 := lang.Apply(tmp6, []any{tmp7, v2}) + if lang.IsTruthy(tmp8) { + var tmp9 any + { // let + // let binding "tm" + tmp10 := checkDerefVar(var_glojure_DOT_core_meta) + tmp11 := lang.Apply(tmp10, []any{v2}) + var v12 any = tmp11 + _ = v12 + // let binding "rf" + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v14 := args[0] + _ = v14 + tmp15 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp16 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp17 := lang.Apply(tmp16, []any{v14}) + tmp18 := lang.Apply(tmp15, []any{tmp17, v12}) + return tmp18 + case 2: + v14 := args[0] + _ = v14 + v15 := args[1] + _ = v15 + tmp16 := checkDerefVar(var_glojure_DOT_core_conj_BANG_) + tmp17 := lang.Apply(tmp16, []any{v14, v15}) + return tmp17 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6937), kw_column, int(17), kw_end_DASH_line, int(6939), kw_end_DASH_column, int(44)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v16 any = tmp15 + _ = v16 + tmp17 := checkDerefVar(var_glojure_DOT_core_transduce) + tmp18 := checkDerefVar(var_glojure_DOT_core_transient) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp17, []any{v3, v16, tmp19, v4}) + tmp9 = tmp20 + } // end let + tmp5 = tmp9 + } else { + tmp10 := checkDerefVar(var_glojure_DOT_core_transduce) + tmp11 := checkDerefVar(var_glojure_DOT_core_conj) + tmp12 := lang.Apply(tmp10, []any{v3, tmp11, v2, v4}) + tmp5 = tmp12 + } + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_into = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_into.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // partitionv + { + tmp0 := sym_partitionv.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n, sym_coll), lang.NewVector(sym_n, sym_step, sym_coll), lang.NewVector(sym_n, sym_step, sym_pad, sym_coll)), kw_doc, "Returns a lazy sequence of vectors of n items each, at offsets step\n apart. If step is not supplied, defaults to n, i.e. the partitions\n do not overlap. If a pad collection is supplied, use its elements as\n necessary to complete last partition upto n items. In case there are\n not enough padding elements, return a partition with less than n items.", kw_file, "glojure/core.glj", kw_added, "1.12", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(7262), kw_end_DASH_line, int(7262))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_partitionv) + tmp5 := lang.Apply(tmp4, []any{v2, v2, v3}) + return tmp5 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp6 any + { // let + // let binding "temp__0__auto__" + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := lang.Apply(tmp7, []any{v4}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + var tmp11 any + { // let + // let binding "s" + var v12 any = v9 + _ = v12 + var tmp13 any + { // let + // let binding "p" + tmp14 := checkDerefVar(var_glojure_DOT_core_into) + tmp15 := lang.NewVector() + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7274), kw_column, int(22), kw_end_DASH_line, int(7274), kw_end_DASH_column, int(23)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp18 := checkDerefVar(var_glojure_DOT_core_take) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp14, []any{tmp17, tmp19, v12}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + tmp23 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp24 := checkDerefVar(var_glojure_DOT_core_count) + tmp25 := lang.Apply(tmp24, []any{v21}) + tmp26 := lang.Apply(tmp23, []any{v2, tmp25}) + if lang.IsTruthy(tmp26) { + tmp27 := checkDerefVar(var_glojure_DOT_core_cons) + tmp28 := checkDerefVar(var_glojure_DOT_core_partitionv) + tmp29 := checkDerefVar(var_glojure_DOT_core_nthrest) + tmp30 := lang.Apply(tmp29, []any{v12, v3}) + tmp31 := lang.Apply(tmp28, []any{v2, v3, tmp30}) + tmp32 := lang.Apply(tmp27, []any{v21, tmp31}) + tmp22 = tmp32 + } else { + } + tmp13 = tmp22 + } // end let + tmp11 = tmp13 + } // end let + tmp10 = tmp11 + } else { + } + tmp6 = tmp10 + } // end let + return tmp6 + }) + tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) + return tmp6 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp7 any + { // let + // let binding "temp__0__auto__" + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := lang.Apply(tmp8, []any{v5}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + if lang.IsTruthy(v10) { + var tmp12 any + { // let + // let binding "s" + var v13 any = v10 + _ = v13 + var tmp14 any + { // let + // let binding "p" + tmp15 := checkDerefVar(var_glojure_DOT_core_into) + tmp16 := lang.NewVector() + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7280), kw_column, int(22), kw_end_DASH_line, int(7280), kw_end_DASH_column, int(23)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp19 := checkDerefVar(var_glojure_DOT_core_take) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := lang.Apply(tmp15, []any{tmp18, tmp20, v13}) + var v22 any = tmp21 + _ = v22 + var tmp23 any + tmp24 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp25 := checkDerefVar(var_glojure_DOT_core_count) + tmp26 := lang.Apply(tmp25, []any{v22}) + tmp27 := lang.Apply(tmp24, []any{v2, tmp26}) + if lang.IsTruthy(tmp27) { + tmp28 := checkDerefVar(var_glojure_DOT_core_cons) + tmp29 := checkDerefVar(var_glojure_DOT_core_partitionv) + tmp30 := checkDerefVar(var_glojure_DOT_core_nthrest) + tmp31 := lang.Apply(tmp30, []any{v13, v3}) + tmp32 := lang.Apply(tmp29, []any{v2, v3, v4, tmp31}) + tmp33 := lang.Apply(tmp28, []any{v22, tmp32}) + tmp23 = tmp33 + } else { + tmp34 := checkDerefVar(var_glojure_DOT_core_list) + tmp35 := checkDerefVar(var_glojure_DOT_core_into) + tmp36 := lang.NewVector() + tmp37 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7283), kw_column, int(24), kw_end_DASH_line, int(7283), kw_end_DASH_column, int(25)) + tmp38, err := lang.WithMeta(tmp36, tmp37.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp39 := checkDerefVar(var_glojure_DOT_core_take) + tmp40 := lang.Apply(tmp39, []any{v2}) + tmp41 := checkDerefVar(var_glojure_DOT_core_concat) + tmp42 := lang.Apply(tmp41, []any{v22, v4}) + tmp43 := lang.Apply(tmp35, []any{tmp38, tmp40, tmp42}) + tmp44 := lang.Apply(tmp34, []any{tmp43}) + tmp23 = tmp44 + } + tmp14 = tmp23 + } // end let + tmp12 = tmp14 + } // end let + tmp11 = tmp12 + } else { + } + tmp7 = tmp11 + } // end let + return tmp7 + }) + tmp7 := lang.Apply(lang.NewLazySeq, []any{tmp6}) + return tmp7 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_partitionv = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_partitionv.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // partitionv-all + { + tmp0 := sym_partitionv_DASH_all.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n), lang.NewVector(sym_n, sym_coll), lang.NewVector(sym_n, sym_step, sym_coll)), kw_doc, "Returns a lazy sequence of vector partitions, but may include\n partitions with fewer than n items at the end.\n Returns a stateful transducer when no collection is provided.", kw_file, "glojure/core.glj", kw_added, "1.12", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(7285), kw_end_DASH_line, int(7285))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_partition_DASH_all) + tmp4 := lang.Apply(tmp3, []any{v2}) + return tmp4 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_partitionv_DASH_all) + tmp5 := lang.Apply(tmp4, []any{v2, v2, v3}) + return tmp5 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp6 any + { // let + // let binding "temp__0__auto__" + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := lang.Apply(tmp7, []any{v4}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + var tmp11 any + { // let + // let binding "s" + var v12 any = v9 + _ = v12 + var tmp13 any + { // let + // let binding "seg" + tmp14 := checkDerefVar(var_glojure_DOT_core_into) + tmp15 := lang.NewVector() + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7297), kw_column, int(24), kw_end_DASH_line, int(7297), kw_end_DASH_column, int(25)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp18 := checkDerefVar(var_glojure_DOT_core_take) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp14, []any{tmp17, tmp19, v4}) + var v21 any = tmp20 + _ = v21 + tmp22 := checkDerefVar(var_glojure_DOT_core_cons) + tmp23 := checkDerefVar(var_glojure_DOT_core_partitionv_DASH_all) + tmp24 := checkDerefVar(var_glojure_DOT_core_drop) + tmp25 := lang.Apply(tmp24, []any{v3, v12}) + tmp26 := lang.Apply(tmp23, []any{v2, v3, tmp25}) + tmp27 := lang.Apply(tmp22, []any{v21, tmp26}) + tmp13 = tmp27 + } // end let + tmp11 = tmp13 + } // end let + tmp10 = tmp11 + } else { + } + tmp6 = tmp10 + } // end let + return tmp6 + }) + tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_partitionv_DASH_all = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_partitionv_DASH_all.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // splitv-at + { + tmp0 := sym_splitv_DASH_at.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n, sym_coll)), kw_doc, "Returns a vector of [(into [] (take n) coll) (drop n coll)]", kw_file, "glojure/core.glj", kw_added, "1.12", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(7256), kw_end_DASH_line, int(7256))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_into) + tmp5 := lang.NewVector() + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7260), kw_column, int(10), kw_end_DASH_line, int(7260), kw_end_DASH_column, int(11)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp8 := checkDerefVar(var_glojure_DOT_core_take) + tmp9 := lang.Apply(tmp8, []any{v2}) + tmp10 := lang.Apply(tmp4, []any{tmp7, tmp9, v3}) + tmp11 := checkDerefVar(var_glojure_DOT_core_drop) + tmp12 := lang.Apply(tmp11, []any{v2, v3}) + tmp13 := lang.NewVector(tmp10, tmp12) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7260), kw_column, int(3), kw_end_DASH_line, int(7260), kw_end_DASH_column, int(41)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp15 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_splitv_DASH_at = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_splitv_DASH_at.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // iteration + { + tmp0 := sym_iteration.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_step, sym__AMP_, lang.NewMap(kw_keys, lang.NewVector(sym_somef, sym_vf, sym_kf, sym_initk), kw_or, lang.NewMap(sym_vf, sym_identity, sym_kf, sym_identity, sym_somef, sym_some_QMARK_, sym_initk, nil)))), kw_doc, "Creates a seqable/reducible via repeated calls to step,\n a function of some (continuation token) 'k'. The first call to step\n will be passed initk, returning 'ret'. Iff (somef ret) is true,\n (vf ret) will be included in the iteration, else iteration will\n terminate and vf/kf will not be called. If (kf ret) is non-nil it\n will be passed to the next step call, else iteration will terminate.\n\n This can be used e.g. to consume APIs that return paginated or batched data.\n\n step - (possibly impure) fn of 'k' -> 'ret'\n\n :somef - fn of 'ret' -> logical true/false, default 'some?'\n :vf - fn of 'ret' -> 'v', a value produced by the iteration, default 'identity'\n :kf - fn of 'ret' -> 'next-k' or nil (signaling 'do not continue'), default 'identity'\n :initk - the first value passed to step, default 'nil'\n\n It is presumed that step with non-initk is unreproducible/non-idempotent.\n If step with initk is unreproducible it is on the consumer to not consume twice.", kw_file, "glojure/core.glj", kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(7716), kw_end_DASH_line, int(7716))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + var tmp4 any + { // let + // let binding "map__683" + var v5 any = v3 + _ = v5 + // let binding "map__683" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v5}) + if lang.IsTruthy(tmp8) { + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_next) + tmp11 := lang.Apply(tmp10, []any{v5}) + if lang.IsTruthy(tmp11) { + tmp12 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) + tmp13 := lang.Apply(tmp12, []any{v5}) + tmp14 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{tmp13}) + tmp9 = tmp14 + } else { + var tmp15 any + tmp16 := checkDerefVar(var_glojure_DOT_core_seq) + tmp17 := lang.Apply(tmp16, []any{v5}) + if lang.IsTruthy(tmp17) { + tmp18 := checkDerefVar(var_glojure_DOT_core_first) + tmp19 := lang.Apply(tmp18, []any{v5}) + tmp15 = tmp19 + } else { + } + tmp9 = tmp15 + } + tmp6 = tmp9 + } else { + tmp6 = v5 + } + var v20 any = tmp6 + _ = v20 + // let binding "somef" + tmp21 := checkDerefVar(var_glojure_DOT_core_get) + tmp22 := checkDerefVar(var_glojure_DOT_core_some_QMARK_) + tmp23 := lang.Apply(tmp21, []any{v20, kw_somef, tmp22}) + var v24 any = tmp23 + _ = v24 + // let binding "vf" + tmp25 := checkDerefVar(var_glojure_DOT_core_get) + tmp26 := checkDerefVar(var_glojure_DOT_core_identity) + tmp27 := lang.Apply(tmp25, []any{v20, kw_vf, tmp26}) + var v28 any = tmp27 + _ = v28 + // let binding "kf" + tmp29 := checkDerefVar(var_glojure_DOT_core_get) + tmp30 := checkDerefVar(var_glojure_DOT_core_identity) + tmp31 := lang.Apply(tmp29, []any{v20, kw_kf, tmp30}) + var v32 any = tmp31 + _ = v32 + // let binding "initk" + tmp33 := checkDerefVar(var_glojure_DOT_core_get) + tmp34 := lang.Apply(tmp33, []any{v20, kw_initk, nil}) + var v35 any = tmp34 + _ = v35 + tmp36 := checkDerefVar(var_glojure_DOT_core_seq) + tmp37 := lang.NewVector(nil) + tmp38 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7743), kw_column, int(9), kw_end_DASH_line, int(7743), kw_end_DASH_column, int(11)) + tmp39, err := lang.WithMeta(tmp37, tmp38.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var tmp40 lang.FnFunc + { // function next + var v41 lang.FnFunc + tmp40 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v42 := args[0] + _ = v42 + var tmp43 any + tmp44 := lang.Apply(v24, []any{v42}) + if lang.IsTruthy(tmp44) { + tmp45 := checkDerefVar(var_glojure_DOT_core_cons) + tmp46 := lang.Apply(v28, []any{v42}) + var tmp47 any + { // let + // let binding "temp__0__auto__" + tmp48 := lang.Apply(v32, []any{v42}) + var v49 any = tmp48 + _ = v49 + var tmp50 any + tmp51 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp52 := lang.Apply(tmp51, []any{v49}) + if lang.IsTruthy(tmp52) { + } else { + var tmp53 any + { // let + // let binding "k" + var v54 any = v49 + _ = v54 + var tmp55 lang.FnFunc + tmp55 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp56 := lang.Apply(v2, []any{v54}) + tmp57 := lang.Apply(v41, []any{tmp56}) + return tmp57 + }) + tmp56 := lang.Apply(lang.NewLazySeq, []any{tmp55}) + tmp53 = tmp56 + } // end let + tmp50 = tmp53 + } + tmp47 = tmp50 + } // end let + tmp48 := lang.Apply(tmp45, []any{tmp46, tmp47}) + tmp43 = tmp48 + } else { + } + return tmp43 + }) + v41 = tmp40 + _ = v41 + } + tmp41 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7744), kw_column, int(10), kw_end_DASH_line, int(7748), kw_end_DASH_column, int(51)) + tmp42, err := lang.WithMeta(tmp40, tmp41.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp43 := lang.Apply(v2, []any{v35}) + tmp44 := lang.Apply(tmp42, []any{tmp43}) + tmp45 := lang.Apply(tmp36, []any{tmp39, tmp44}) + tmp46 := reflect.TypeOf((*lang.IReduceInit)(nil)).Elem() + tmp47 := checkDerefVar(var_glojure_DOT_core_reduce) + tmp48 := lang.NewVector(nil, nil, nil) + tmp49 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7751), kw_column, int(12), kw_end_DASH_line, int(7751), kw_end_DASH_column, int(22)) + tmp50, err := lang.WithMeta(tmp48, tmp49.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var tmp51 any + { // let + // let binding "acc" + var v52 any = nil + _ = v52 + // let binding "ret" + tmp53 := lang.Apply(v2, []any{v35}) + var v54 any = tmp53 + _ = v54 + for { + var tmp55 any + tmp56 := lang.Apply(v24, []any{v54}) + if lang.IsTruthy(tmp56) { + var tmp57 any + { // let + // let binding "acc" + tmp58 := lang.Apply(v28, []any{v54}) + tmp59 := lang.Apply(nil, []any{v52, tmp58}) + var v60 any = tmp59 + _ = v60 + var tmp61 any + tmp62 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) + tmp63 := lang.Apply(tmp62, []any{v60}) + if lang.IsTruthy(tmp63) { + tmp64 := checkDerefVar(var_glojure_DOT_core_deref) + tmp65 := lang.Apply(tmp64, []any{v60}) + tmp61 = tmp65 + } else { + var tmp66 any + { // let + // let binding "temp__0__auto__" + tmp67 := lang.Apply(v32, []any{v54}) + var v68 any = tmp67 + _ = v68 + var tmp69 any + tmp70 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp71 := lang.Apply(tmp70, []any{v68}) + if lang.IsTruthy(tmp71) { + tmp69 = v60 + } else { + var tmp72 any + { // let + // let binding "k" + var v73 any = v68 + _ = v73 + var tmp74 any = v60 + tmp76 := lang.Apply(v2, []any{v73}) + var tmp75 any = tmp76 + v52 = tmp74 + v54 = tmp75 + continue + } // end let + tmp69 = tmp72 + } + tmp66 = tmp69 + } // end let + tmp61 = tmp66 + } + tmp57 = tmp61 + } // end let + tmp55 = tmp57 + } else { + tmp55 = v52 + } + tmp51 = tmp55 + break + } + } // end let + tmp52 := lang.Apply(tmp47, []any{tmp50, tmp51}) + tmp53 := lang.Apply(nil, []any{nil, tmp45, tmp46, tmp52}) + tmp4 = tmp53 + } // end let + return tmp4 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_iteration = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_iteration.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // load + { + tmp0 := sym_load.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_paths)), kw_doc, "Loads Clojure code from resources in classpath. A path is interpreted as\n classpath-relative if it begins with a slash or relative to the root\n directory for the current namespace otherwise.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_redef, true, kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(6095), kw_end_DASH_line, int(6095))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + var tmp3 any + { // let + // let binding "seq_824" + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + // let binding "chunk_825" + var v7 any = nil + _ = v7 + // let binding "count_826" + var v8 any = int64(0) + _ = v8 + // let binding "i_827" + var v9 any = int64(0) + _ = v9 + for { + var tmp10 any + tmp11 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp12 := lang.Apply(tmp11, []any{v9, v8}) + if lang.IsTruthy(tmp12) { + var tmp13 any + { // let + // let binding "path" + tmp14, _ := lang.FieldOrMethod(v7, "nth") + if reflect.TypeOf(tmp14).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp15 := lang.Apply(tmp14, []any{v9}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + { // let + // let binding "path" + var tmp18 any + tmp19 := lang.Apply(strings8.HasPrefix, []any{v16, "/"}) + if lang.IsTruthy(tmp19) { + tmp18 = v16 + } else { + tmp20 := checkDerefVar(var_glojure_DOT_core_str) + tmp21 := checkDerefVar(var_glojure_DOT_core_root_DASH_directory) + tmp22 := checkDerefVar(var_glojure_DOT_core_ns_DASH_name) + tmp23 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp24 := lang.Apply(tmp22, []any{tmp23}) + tmp25 := lang.Apply(tmp21, []any{tmp24}) + tmp26 := lang.Apply(tmp20, []any{tmp25, lang.NewChar(47), v16}) + tmp18 = tmp26 + } + var v27 any = tmp18 + _ = v27 + var tmp28 any + tmp29 := checkDerefVar(var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_) + if lang.IsTruthy(tmp29) { + tmp30 := checkDerefVar(var_glojure_DOT_core_printf) + tmp31 := lang.Apply(tmp30, []any{"(glojure.core/load \"%s\")\n", v27}) + _ = tmp31 + tmp32 := checkDerefVar(var_glojure_DOT_core_flush) + tmp33 := lang.Apply(tmp32, nil) + tmp28 = tmp33 + } else { + } + _ = tmp28 + tmp34 := checkDerefVar(var_glojure_DOT_core_check_DASH_cyclic_DASH_dependency) + tmp35 := lang.Apply(tmp34, []any{v27}) + _ = tmp35 + var tmp36 any + tmp37 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp38 := checkDerefVar(var_glojure_DOT_core_first) + tmp39 := checkDerefVar(var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_) + tmp40 := lang.Apply(tmp38, []any{tmp39}) + tmp41 := lang.Apply(tmp37, []any{v27, tmp40}) + if lang.IsTruthy(tmp41) { + } else { + var tmp42 any + { // let + tmp43 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp44 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp45 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_pending_DASH_paths_STAR_) + tmp46 := checkDerefVar(var_glojure_DOT_core_conj) + tmp47 := checkDerefVar(var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_) + tmp48 := lang.Apply(tmp46, []any{tmp47, v27}) + tmp49 := lang.Apply(tmp44, []any{tmp45, tmp48}) + tmp50 := lang.Apply(tmp43, []any{tmp49}) + _ = tmp50 + var tmp51 any + func() { + defer func() { + tmp52 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp53 := lang.Apply(tmp52, nil) + _ = tmp53 + }() + tmp54 := lang.Apply(strings8.TrimPrefix, []any{v27, "/"}) + tmp55, _ := lang.FieldOrMethod(runtime.RT, "Load") + if reflect.TypeOf(tmp55).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Load is not a function"))) + } + tmp56 := lang.Apply(tmp55, []any{tmp54}) + tmp51 = tmp56 + }() + tmp42 = tmp51 + } // end let + tmp36 = tmp42 + } + tmp17 = tmp36 + } // end let + _ = tmp17 + var tmp18 any = v6 + var tmp19 any = v7 + var tmp20 any = v8 + tmp22 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp23 := lang.Apply(tmp22, []any{v9}) + var tmp21 any = tmp23 + v6 = tmp18 + v7 = tmp19 + v8 = tmp20 + v9 = tmp21 + continue + } // end let + tmp10 = tmp13 + } else { + var tmp14 any + { // let + // let binding "temp__0__auto__" + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := lang.Apply(tmp15, []any{v6}) + var v17 any = tmp16 + _ = v17 + var tmp18 any + if lang.IsTruthy(v17) { + var tmp19 any + { // let + // let binding "seq_824" + var v20 any = v17 + _ = v20 + var tmp21 any + tmp22 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp23 := lang.Apply(tmp22, []any{v20}) + if lang.IsTruthy(tmp23) { + var tmp24 any + { // let + // let binding "c__0__auto__" + tmp25 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp26 := lang.Apply(tmp25, []any{v20}) + var v27 any = tmp26 + _ = v27 + tmp29 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp30 := lang.Apply(tmp29, []any{v20}) + var tmp28 any = tmp30 + var tmp31 any = v27 + tmp33 := checkDerefVar(var_glojure_DOT_core_int) + tmp34 := checkDerefVar(var_glojure_DOT_core_count) + tmp35 := lang.Apply(tmp34, []any{v27}) + tmp36 := lang.Apply(tmp33, []any{tmp35}) + var tmp32 any = tmp36 + tmp38 := checkDerefVar(var_glojure_DOT_core_int) + tmp39 := lang.Apply(tmp38, []any{int64(0)}) + var tmp37 any = tmp39 + v6 = tmp28 + v7 = tmp31 + v8 = tmp32 + v9 = tmp37 + continue + } // end let + tmp21 = tmp24 + } else { + var tmp25 any + { // let + // let binding "path" + tmp26 := checkDerefVar(var_glojure_DOT_core_first) + tmp27 := lang.Apply(tmp26, []any{v20}) + var v28 any = tmp27 + _ = v28 + var tmp29 any + { // let + // let binding "path" + var tmp30 any + tmp31 := lang.Apply(strings8.HasPrefix, []any{v28, "/"}) + if lang.IsTruthy(tmp31) { + tmp30 = v28 + } else { + tmp32 := checkDerefVar(var_glojure_DOT_core_str) + tmp33 := checkDerefVar(var_glojure_DOT_core_root_DASH_directory) + tmp34 := checkDerefVar(var_glojure_DOT_core_ns_DASH_name) + tmp35 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp36 := lang.Apply(tmp34, []any{tmp35}) + tmp37 := lang.Apply(tmp33, []any{tmp36}) + tmp38 := lang.Apply(tmp32, []any{tmp37, lang.NewChar(47), v28}) + tmp30 = tmp38 + } + var v39 any = tmp30 + _ = v39 + var tmp40 any + tmp41 := checkDerefVar(var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_) + if lang.IsTruthy(tmp41) { + tmp42 := checkDerefVar(var_glojure_DOT_core_printf) + tmp43 := lang.Apply(tmp42, []any{"(glojure.core/load \"%s\")\n", v39}) + _ = tmp43 + tmp44 := checkDerefVar(var_glojure_DOT_core_flush) + tmp45 := lang.Apply(tmp44, nil) + tmp40 = tmp45 + } else { + } + _ = tmp40 + tmp46 := checkDerefVar(var_glojure_DOT_core_check_DASH_cyclic_DASH_dependency) + tmp47 := lang.Apply(tmp46, []any{v39}) + _ = tmp47 + var tmp48 any + tmp49 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp50 := checkDerefVar(var_glojure_DOT_core_first) + tmp51 := checkDerefVar(var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_) + tmp52 := lang.Apply(tmp50, []any{tmp51}) + tmp53 := lang.Apply(tmp49, []any{v39, tmp52}) + if lang.IsTruthy(tmp53) { + } else { + var tmp54 any + { // let + tmp55 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp56 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp57 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_pending_DASH_paths_STAR_) + tmp58 := checkDerefVar(var_glojure_DOT_core_conj) + tmp59 := checkDerefVar(var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_) + tmp60 := lang.Apply(tmp58, []any{tmp59, v39}) + tmp61 := lang.Apply(tmp56, []any{tmp57, tmp60}) + tmp62 := lang.Apply(tmp55, []any{tmp61}) + _ = tmp62 + var tmp63 any + func() { + defer func() { + tmp64 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp65 := lang.Apply(tmp64, nil) + _ = tmp65 + }() + tmp66 := lang.Apply(strings8.TrimPrefix, []any{v39, "/"}) + tmp67, _ := lang.FieldOrMethod(runtime.RT, "Load") + if reflect.TypeOf(tmp67).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Load is not a function"))) + } + tmp68 := lang.Apply(tmp67, []any{tmp66}) + tmp63 = tmp68 + }() + tmp54 = tmp63 + } // end let + tmp48 = tmp54 + } + tmp29 = tmp48 + } // end let + _ = tmp29 + tmp31 := checkDerefVar(var_glojure_DOT_core_next) + tmp32 := lang.Apply(tmp31, []any{v20}) + var tmp30 any = tmp32 + var tmp33 any = nil + var tmp34 any = int64(0) + var tmp35 any = int64(0) + v6 = tmp30 + v7 = tmp33 + v8 = tmp34 + v9 = tmp35 + continue + } // end let + tmp21 = tmp25 + } + tmp19 = tmp21 + } // end let + tmp18 = tmp19 + } else { + } + tmp14 = tmp18 + } // end let + tmp10 = tmp14 + } + tmp3 = tmp10 + break + } + } // end let + return tmp3 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_load = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_load.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // load-one + { + tmp0 := sym_load_DASH_one.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_lib, sym_need_DASH_ns, sym_require)), kw_doc, "Loads a lib given its name. If need-ns, ensures that the associated\n namespace exists after loading. If require, records the load so any\n duplicate loads can be skipped.", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(8), kw_line, int(5879), kw_end_DASH_line, int(5879), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_load) + tmp6 := checkDerefVar(var_glojure_DOT_core_root_DASH_resource) + tmp7 := lang.Apply(tmp6, []any{v2}) + tmp8 := lang.Apply(tmp5, []any{tmp7}) + _ = tmp8 + tmp9 := checkDerefVar(var_glojure_DOT_core_throw_DASH_if) + var tmp10 any + { // let + // let binding "and__0__auto__" + var v11 any = v3 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + tmp13 := checkDerefVar(var_glojure_DOT_core_not) + tmp14 := checkDerefVar(var_glojure_DOT_core_find_DASH_ns) + tmp15 := lang.Apply(tmp14, []any{v2}) + tmp16 := lang.Apply(tmp13, []any{tmp15}) + tmp12 = tmp16 + } else { + tmp12 = v11 + } + tmp10 = tmp12 + } // end let + tmp11 := checkDerefVar(var_glojure_DOT_core_root_DASH_resource) + tmp12 := lang.Apply(tmp11, []any{v2}) + tmp13 := lang.Apply(tmp9, []any{tmp10, "namespace '%s' not found after loading '%s'", v2, tmp12}) + _ = tmp13 + var tmp14 any + if lang.IsTruthy(v4) { + var tmp15 lang.FnFunc + tmp15 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp16 := checkDerefVar(var_glojure_DOT_core_commute) + tmp17 := checkDerefVar(var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_) + tmp18 := checkDerefVar(var_glojure_DOT_core_conj) + tmp19 := lang.Apply(tmp16, []any{tmp17, tmp18, v2}) + return tmp19 + }) + tmp16, _ := lang.FieldOrMethod(lang.LockingTransaction, "RunInTransaction") + if reflect.TypeOf(tmp16).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("RunInTransaction is not a function"))) + } + tmp17 := lang.Apply(tmp16, []any{tmp15}) + tmp14 = tmp17 + } else { + } + return tmp14 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_load_DASH_one = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_load_DASH_one.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // load-all + { + tmp0 := sym_load_DASH_all.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_lib, sym_need_DASH_ns, sym_require)), kw_doc, "Loads a lib given its name and forces a load of any libs it directly or\n indirectly loads. If need-ns, ensures that the associated namespace\n exists after loading. If require, records the load so any duplicate loads\n can be skipped.", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(8), kw_line, int(5892), kw_end_DASH_line, int(5892), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp6 := checkDerefVar(var_glojure_DOT_core_commute) + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_) + var tmp8 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v9 := args[0] + _ = v9 + v10 := args[1] + _ = v10 + tmp11 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp12 := checkDerefVar(var_glojure_DOT_core_conj) + tmp13 := lang.Apply(tmp11, []any{tmp12, v9, v10}) + return tmp13 + }) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5899), kw_column, int(27), kw_end_DASH_line, int(5899), kw_end_DASH_column, int(47)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var tmp11 any + { // let + tmp12 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp13 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp14 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_loaded_DASH_libs_STAR_) + tmp15 := checkDerefVar(var_glojure_DOT_core_ref) + tmp16 := checkDerefVar(var_glojure_DOT_core_sorted_DASH_set) + tmp17 := lang.Apply(tmp16, nil) + tmp18 := lang.Apply(tmp15, []any{tmp17}) + tmp19 := lang.Apply(tmp13, []any{tmp14, tmp18}) + tmp20 := lang.Apply(tmp12, []any{tmp19}) + _ = tmp20 + var tmp21 any + func() { + defer func() { + tmp22 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp23 := lang.Apply(tmp22, nil) + _ = tmp23 + }() + tmp24 := checkDerefVar(var_glojure_DOT_core_load_DASH_one) + tmp25 := lang.Apply(tmp24, []any{v2, v3, v4}) + _ = tmp25 + tmp26 := checkDerefVar(var_glojure_DOT_core_deref) + tmp27 := checkDerefVar(var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_) + tmp28 := lang.Apply(tmp26, []any{tmp27}) + tmp21 = tmp28 + }() + tmp11 = tmp21 + } // end let + tmp12 := lang.Apply(tmp6, []any{tmp7, tmp10, tmp11}) + return tmp12 + }) + tmp6, _ := lang.FieldOrMethod(lang.LockingTransaction, "RunInTransaction") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("RunInTransaction is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{tmp5}) + return tmp7 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_load_DASH_all = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_load_DASH_all.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // load-data-reader-file + { + tmp0 := sym_load_DASH_data_DASH_reader_DASH_file.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7836), kw_column, int(8), kw_end_DASH_line, int(7836), kw_end_DASH_column, int(28), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_mappings, sym_url)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "rdr" + tmp5, ok := lang.FieldOrMethod(v3, "openStream") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "openStream"))) + } + var tmp6 any + switch reflect.TypeOf(tmp5).Kind() { + case reflect.Func: + tmp6 = lang.Apply(tmp5, nil) + default: + tmp6 = tmp5 + } + tmp7 := lang.Apply(nil, []any{tmp6, "UTF-8"}) + tmp8 := lang.Apply(nil, []any{tmp7}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + func() { + defer func() { + tmp11, ok := lang.FieldOrMethod(v9, "close") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v9, "close"))) + } + var tmp12 any + switch reflect.TypeOf(tmp11).Kind() { + case reflect.Func: + tmp12 = lang.Apply(tmp11, nil) + default: + tmp12 = tmp11 + } + _ = tmp12 + }() + var tmp13 any + { // let + tmp14 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp15 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp16 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_file_STAR_) + tmp17, ok := lang.FieldOrMethod(v3, "getFile") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getFile"))) + } + var tmp18 any + switch reflect.TypeOf(tmp17).Kind() { + case reflect.Func: + tmp18 = lang.Apply(tmp17, nil) + default: + tmp18 = tmp17 + } + tmp19 := lang.Apply(tmp15, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp14, []any{tmp19}) + _ = tmp20 + var tmp21 any + func() { + defer func() { + tmp22 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp23 := lang.Apply(tmp22, nil) + _ = tmp23 + }() + var tmp24 any + { // let + // let binding "read-opts" + var tmp25 any + tmp26, ok := lang.FieldOrMethod(v3, "getPath") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getPath"))) + } + var tmp27 any + switch reflect.TypeOf(tmp26).Kind() { + case reflect.Func: + tmp27 = lang.Apply(tmp26, nil) + default: + tmp27 = tmp26 + } + tmp28, _ := lang.FieldOrMethod(tmp27, "endsWith") + if reflect.TypeOf(tmp28).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("endsWith is not a function"))) + } + tmp29 := lang.Apply(tmp28, []any{"cljc"}) + if lang.IsTruthy(tmp29) { + tmp30 := lang.NewMap(kw_eof, nil, kw_read_DASH_cond, kw_allow) + tmp31 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7842), kw_column, int(25), kw_end_DASH_line, int(7842), kw_end_DASH_column, int(52)) + tmp32, err := lang.WithMeta(tmp30, tmp31.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp25 = tmp32 + } else { + tmp33 := lang.NewMap(kw_eof, nil) + tmp34 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7843), kw_column, int(25), kw_end_DASH_line, int(7843), kw_end_DASH_column, int(34)) + tmp35, err := lang.WithMeta(tmp33, tmp34.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp25 = tmp35 + } + var v36 any = tmp25 + _ = v36 + // let binding "new-mappings" + tmp37 := checkDerefVar(var_glojure_DOT_core_read) + tmp38 := lang.Apply(tmp37, []any{v36, v9}) + var v39 any = tmp38 + _ = v39 + var tmp40 any + tmp41 := checkDerefVar(var_glojure_DOT_core_not) + tmp42 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp43 := lang.Apply(tmp42, []any{v39}) + tmp44 := lang.Apply(tmp41, []any{tmp43}) + if lang.IsTruthy(tmp44) { + tmp45 := checkDerefVar(var_glojure_DOT_core_ex_DASH_info) + tmp46 := checkDerefVar(var_glojure_DOT_core_str) + tmp47 := lang.Apply(tmp46, []any{"Not a valid data-reader map"}) + tmp48 := lang.NewMap(kw_url, v3) + tmp49 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7847), kw_column, int(27), kw_end_DASH_line, int(7847), kw_end_DASH_column, int(36)) + tmp50, err := lang.WithMeta(tmp48, tmp49.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp51 := lang.Apply(tmp45, []any{tmp47, tmp50}) + panic(tmp51) + } else { + } + _ = tmp40 + tmp52 := checkDerefVar(var_glojure_DOT_core_reduce) + var tmp53 lang.FnFunc + tmp53 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v54 := args[0] + _ = v54 + v55 := args[1] + _ = v55 + var tmp56 any + { // let + // let binding "vec__685" + var v57 any = v55 + _ = v57 + // let binding "k" + tmp58 := checkDerefVar(var_glojure_DOT_core_nth) + tmp59 := lang.Apply(tmp58, []any{v57, int64(0), nil}) + var v60 any = tmp59 + _ = v60 + // let binding "v" + tmp61 := checkDerefVar(var_glojure_DOT_core_nth) + tmp62 := lang.Apply(tmp61, []any{v57, int64(1), nil}) + var v63 any = tmp62 + _ = v63 + var tmp64 any + tmp65 := checkDerefVar(var_glojure_DOT_core_not) + tmp66 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp67 := lang.Apply(tmp66, []any{v60}) + tmp68 := lang.Apply(tmp65, []any{tmp67}) + if lang.IsTruthy(tmp68) { + tmp69 := checkDerefVar(var_glojure_DOT_core_ex_DASH_info) + tmp70 := checkDerefVar(var_glojure_DOT_core_str) + tmp71 := lang.Apply(tmp70, []any{"Invalid form in data-reader file"}) + tmp72 := lang.NewMap(kw_url, v3, kw_form, v60) + tmp73 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7852), kw_column, int(30), kw_end_DASH_line, int(7853), kw_end_DASH_column, int(38)) + tmp74, err := lang.WithMeta(tmp72, tmp73.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp75 := lang.Apply(tmp69, []any{tmp71, tmp74}) + panic(tmp75) + } else { + } + _ = tmp64 + var tmp76 any + { // let + // let binding "v-var" + tmp77 := checkDerefVar(var_glojure_DOT_core_data_DASH_reader_DASH_var) + tmp78 := lang.Apply(tmp77, []any{v63}) + var v79 any = tmp78 + _ = v79 + var tmp80 any + var tmp81 any + { // let + // let binding "and__0__auto__" + tmp82 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp83 := lang.Apply(tmp82, []any{v2, v60}) + var v84 any = tmp83 + _ = v84 + var tmp85 any + if lang.IsTruthy(v84) { + tmp86 := checkDerefVar(var_glojure_DOT_core_not_EQ_) + tmp87 := lang.Apply(v2, []any{v60}) + tmp88 := lang.Apply(tmp86, []any{tmp87, v79}) + tmp85 = tmp88 + } else { + tmp85 = v84 + } + tmp81 = tmp85 + } // end let + if lang.IsTruthy(tmp81) { + tmp82 := checkDerefVar(var_glojure_DOT_core_ex_DASH_info) + tmp83 := lang.NewMap(kw_url, v3, kw_conflict, v60, kw_mappings, v54) + tmp84 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7858), kw_column, int(32), kw_end_DASH_line, int(7860), kw_end_DASH_column, int(44)) + tmp85, err := lang.WithMeta(tmp83, tmp84.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp86 := lang.Apply(tmp82, []any{"Conflicting data-reader mapping", tmp85}) + panic(tmp86) + } else { + } + _ = tmp80 + tmp87 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp88 := lang.Apply(tmp87, []any{v54, v60, v79}) + tmp76 = tmp88 + } // end let + tmp56 = tmp76 + } // end let + return tmp56 + }) + tmp54 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7849), kw_column, int(10), kw_end_DASH_line, int(7861), kw_end_DASH_column, int(32)) + tmp55, err := lang.WithMeta(tmp53, tmp54.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp56 := lang.Apply(tmp52, []any{tmp55, v2, v39}) + tmp24 = tmp56 + } // end let + tmp21 = tmp24 + }() + tmp13 = tmp21 + } // end let + tmp10 = tmp13 + }() + tmp4 = tmp10 + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_load_DASH_data_DASH_reader_DASH_file = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_load_DASH_data_DASH_reader_DASH_file.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // load-data-readers + { + tmp0 := sym_load_DASH_data_DASH_readers.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7865), kw_column, int(8), kw_end_DASH_line, int(7865), kw_end_DASH_column, int(24), kw_private, true, kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp2 := checkDerefVar(var_glojure_DOT_core_alter_DASH_var_DASH_root) + tmp3 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_data_DASH_readers_STAR_) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v5 := args[0] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_reduce) + tmp7 := checkDerefVar(var_glojure_DOT_core_load_DASH_data_DASH_reader_DASH_file) + tmp8 := checkDerefVar(var_glojure_DOT_core_data_DASH_reader_DASH_urls) + tmp9 := lang.Apply(tmp8, nil) + tmp10 := lang.Apply(tmp6, []any{tmp7, v5, tmp9}) + return tmp10 + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7867), kw_column, int(19), kw_end_DASH_line, int(7869), kw_end_DASH_column, int(57)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp7 := lang.Apply(tmp2, []any{tmp3, tmp6}) + return tmp7 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_load_DASH_data_DASH_readers = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_load_DASH_data_DASH_readers.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // load-lib + { + tmp0 := sym_load_DASH_lib.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_prefix, sym_lib, sym__AMP_, sym_options)), kw_doc, "Loads a lib with options", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(8), kw_line, int(5904), kw_end_DASH_line, int(5904), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_throw_DASH_if) + var tmp6 any + { // let + // let binding "and__0__auto__" + var v7 any = v2 + _ = v7 + var tmp8 any + if lang.IsTruthy(v7) { + tmp9 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp10 := checkDerefVar(var_glojure_DOT_core_name) + tmp11 := lang.Apply(tmp10, []any{v3}) + tmp12 := checkDerefVar(var_glojure_DOT_core_int) + tmp13 := lang.Apply(tmp12, []any{lang.NewChar(46)}) + tmp14 := lang.Apply(strings8.Index, []any{tmp11, tmp13}) + tmp15 := lang.Apply(tmp9, []any{tmp14}) + tmp8 = tmp15 + } else { + tmp8 = v7 + } + tmp6 = tmp8 + } // end let + tmp7 := checkDerefVar(var_glojure_DOT_core_name) + tmp8 := lang.Apply(tmp7, []any{v3}) + tmp9 := lang.Apply(tmp5, []any{tmp6, "Found lib name '%s' containing period with prefix '%s'. lib names inside prefix lists must not contain periods", tmp8, v2}) + _ = tmp9 + var tmp10 any + { // let + // let binding "lib" + var tmp11 any + if lang.IsTruthy(v2) { + tmp12 := checkDerefVar(var_glojure_DOT_core_symbol) + tmp13 := checkDerefVar(var_glojure_DOT_core_str) + tmp14 := lang.Apply(tmp13, []any{v2, lang.NewChar(46), v3}) + tmp15 := lang.Apply(tmp12, []any{tmp14}) + tmp11 = tmp15 + } else { + tmp11 = v3 + } + var v16 any = tmp11 + _ = v16 + // let binding "opts" + tmp17 := checkDerefVar(var_glojure_DOT_core_apply) + tmp18 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp19 := lang.Apply(tmp17, []any{tmp18, v4}) + var v20 any = tmp19 + _ = v20 + // let binding "map__801" + var v21 any = v20 + _ = v21 + // let binding "map__801" + var tmp22 any + tmp23 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp24 := lang.Apply(tmp23, []any{v21}) + if lang.IsTruthy(tmp24) { + var tmp25 any + tmp26 := checkDerefVar(var_glojure_DOT_core_next) + tmp27 := lang.Apply(tmp26, []any{v21}) + if lang.IsTruthy(tmp27) { + tmp28 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) + tmp29 := lang.Apply(tmp28, []any{v21}) + tmp30 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{tmp29}) + tmp25 = tmp30 + } else { + var tmp31 any + tmp32 := checkDerefVar(var_glojure_DOT_core_seq) + tmp33 := lang.Apply(tmp32, []any{v21}) + if lang.IsTruthy(tmp33) { + tmp34 := checkDerefVar(var_glojure_DOT_core_first) + tmp35 := lang.Apply(tmp34, []any{v21}) + tmp31 = tmp35 + } else { + } + tmp25 = tmp31 + } + tmp22 = tmp25 + } else { + tmp22 = v21 + } + var v36 any = tmp22 + _ = v36 + // let binding "as" + tmp37 := checkDerefVar(var_glojure_DOT_core_get) + tmp38 := lang.Apply(tmp37, []any{v36, kw_as}) + var v39 any = tmp38 + _ = v39 + // let binding "reload" + tmp40 := checkDerefVar(var_glojure_DOT_core_get) + tmp41 := lang.Apply(tmp40, []any{v36, kw_reload}) + var v42 any = tmp41 + _ = v42 + // let binding "reload-all" + tmp43 := checkDerefVar(var_glojure_DOT_core_get) + tmp44 := lang.Apply(tmp43, []any{v36, kw_reload_DASH_all}) + var v45 any = tmp44 + _ = v45 + // let binding "require" + tmp46 := checkDerefVar(var_glojure_DOT_core_get) + tmp47 := lang.Apply(tmp46, []any{v36, kw_require}) + var v48 any = tmp47 + _ = v48 + // let binding "use" + tmp49 := checkDerefVar(var_glojure_DOT_core_get) + tmp50 := lang.Apply(tmp49, []any{v36, kw_use}) + var v51 any = tmp50 + _ = v51 + // let binding "verbose" + tmp52 := checkDerefVar(var_glojure_DOT_core_get) + tmp53 := lang.Apply(tmp52, []any{v36, kw_verbose}) + var v54 any = tmp53 + _ = v54 + // let binding "as-alias" + tmp55 := checkDerefVar(var_glojure_DOT_core_get) + tmp56 := lang.Apply(tmp55, []any{v36, kw_as_DASH_alias}) + var v57 any = tmp56 + _ = v57 + // let binding "loaded" + tmp58 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp59 := checkDerefVar(var_glojure_DOT_core_deref) + tmp60 := checkDerefVar(var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_) + tmp61 := lang.Apply(tmp59, []any{tmp60}) + tmp62 := lang.Apply(tmp58, []any{tmp61, v16}) + var v63 any = tmp62 + _ = v63 + // let binding "need-ns" + var tmp64 any + { // let + // let binding "or__0__auto__" + var v65 any = v39 + _ = v65 + var tmp66 any + if lang.IsTruthy(v65) { + tmp66 = v65 + } else { + tmp66 = v51 + } + tmp64 = tmp66 + } // end let + var v65 any = tmp64 + _ = v65 + // let binding "load" + var tmp66 any + if lang.IsTruthy(v45) { + tmp67 := checkDerefVar(var_glojure_DOT_core_load_DASH_all) + tmp66 = tmp67 + } else { + var tmp68 any + if lang.IsTruthy(v42) { + tmp69 := checkDerefVar(var_glojure_DOT_core_load_DASH_one) + tmp68 = tmp69 + } else { + var tmp70 any + tmp71 := checkDerefVar(var_glojure_DOT_core_not) + tmp72 := lang.Apply(tmp71, []any{v63}) + if lang.IsTruthy(tmp72) { + var tmp73 any + if lang.IsTruthy(v65) { + tmp74 := checkDerefVar(var_glojure_DOT_core_load_DASH_one) + tmp73 = tmp74 + } else { + var tmp75 any + if lang.IsTruthy(v57) { + var tmp76 lang.FnFunc + tmp76 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v77 := args[0] + _ = v77 + v78 := args[1] + _ = v78 + v79 := args[2] + _ = v79 + tmp80 := checkDerefVar(var_glojure_DOT_core_create_DASH_ns) + tmp81 := lang.Apply(tmp80, []any{v77}) + return tmp81 + }) + tmp77 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5918), kw_column, int(48), kw_end_DASH_line, int(5918), kw_end_DASH_column, int(88)) + tmp78, err := lang.WithMeta(tmp76, tmp77.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp75 = tmp78 + } else { + var tmp79 any + if lang.IsTruthy(kw_else) { + tmp80 := checkDerefVar(var_glojure_DOT_core_load_DASH_one) + tmp79 = tmp80 + } else { + } + tmp75 = tmp79 + } + tmp73 = tmp75 + } + tmp70 = tmp73 + } else { + } + tmp68 = tmp70 + } + tmp66 = tmp68 + } + var v81 any = tmp66 + _ = v81 + // let binding "filter-opts" + tmp82 := checkDerefVar(var_glojure_DOT_core_select_DASH_keys) + tmp83 := lang.Apply(tmp82, []any{v20, lang.NewList(kw_exclude, kw_only, kw_rename, kw_refer)}) + var v84 any = tmp83 + _ = v84 + // let binding "undefined-on-entry" + tmp85 := checkDerefVar(var_glojure_DOT_core_not) + tmp86 := checkDerefVar(var_glojure_DOT_core_find_DASH_ns) + tmp87 := lang.Apply(tmp86, []any{v16}) + tmp88 := lang.Apply(tmp85, []any{tmp87}) + var v89 any = tmp88 + _ = v89 + var tmp90 any + { // let + tmp91 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp92 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp93 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_loading_DASH_verbosely_STAR_) + var tmp94 any + { // let + // let binding "or__0__auto__" + tmp95 := checkDerefVar(var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_) + var v96 any = tmp95 + _ = v96 + var tmp97 any + if lang.IsTruthy(v96) { + tmp97 = v96 + } else { + tmp97 = v54 + } + tmp94 = tmp97 + } // end let + tmp95 := lang.Apply(tmp92, []any{tmp93, tmp94}) + tmp96 := lang.Apply(tmp91, []any{tmp95}) + _ = tmp96 + var tmp97 any + func() { + defer func() { + tmp98 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp99 := lang.Apply(tmp98, nil) + _ = tmp99 + }() + var tmp100 any + if lang.IsTruthy(v81) { + var tmp101 any + func() { + defer func() { + if r := recover(); r != nil { + if lang.CatchMatches(r, lang.Builtins["any"]) { + v102 := r + _ = v102 + var tmp103 any + if lang.IsTruthy(v89) { + tmp104 := checkDerefVar(var_glojure_DOT_core_remove_DASH_ns) + tmp105 := lang.Apply(tmp104, []any{v16}) + tmp103 = tmp105 + } else { + } + _ = tmp103 + panic(v102) + } else { + panic(r) + } + } + }() + tmp102 := lang.Apply(v81, []any{v16, v65, v48}) + tmp101 = tmp102 + }() + tmp100 = tmp101 + } else { + tmp103 := checkDerefVar(var_glojure_DOT_core_throw_DASH_if) + var tmp104 any + { // let + // let binding "and__0__auto__" + var v105 any = v65 + _ = v105 + var tmp106 any + if lang.IsTruthy(v105) { + tmp107 := checkDerefVar(var_glojure_DOT_core_not) + tmp108 := checkDerefVar(var_glojure_DOT_core_find_DASH_ns) + tmp109 := lang.Apply(tmp108, []any{v16}) + tmp110 := lang.Apply(tmp107, []any{tmp109}) + tmp106 = tmp110 + } else { + tmp106 = v105 + } + tmp104 = tmp106 + } // end let + tmp105 := lang.Apply(tmp103, []any{tmp104, "namespace '%s' not found", v16}) + tmp100 = tmp105 + } + _ = tmp100 + var tmp106 any + var tmp107 any + { // let + // let binding "and__0__auto__" + var v108 any = v65 + _ = v108 + var tmp109 any + if lang.IsTruthy(v108) { + tmp110 := checkDerefVar(var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_) + tmp109 = tmp110 + } else { + tmp109 = v108 + } + tmp107 = tmp109 + } // end let + if lang.IsTruthy(tmp107) { + tmp108 := checkDerefVar(var_glojure_DOT_core_printf) + tmp109 := checkDerefVar(var_glojure_DOT_core_ns_DASH_name) + tmp110 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp111 := lang.Apply(tmp109, []any{tmp110}) + tmp112 := lang.Apply(tmp108, []any{"(glojure.core/in-ns '%s)\n", tmp111}) + tmp106 = tmp112 + } else { + } + _ = tmp106 + var tmp113 any + if lang.IsTruthy(v39) { + var tmp114 any + tmp115 := checkDerefVar(var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_) + if lang.IsTruthy(tmp115) { + tmp116 := checkDerefVar(var_glojure_DOT_core_printf) + tmp117 := lang.Apply(tmp116, []any{"(glojure.core/alias '%s '%s)\n", v39, v16}) + tmp114 = tmp117 + } else { + } + _ = tmp114 + tmp118 := checkDerefVar(var_glojure_DOT_core_alias) + tmp119 := lang.Apply(tmp118, []any{v39, v16}) + tmp113 = tmp119 + } else { + } + _ = tmp113 + var tmp120 any + if lang.IsTruthy(v57) { + var tmp121 any + tmp122 := checkDerefVar(var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_) + if lang.IsTruthy(tmp122) { + tmp123 := checkDerefVar(var_glojure_DOT_core_printf) + tmp124 := lang.Apply(tmp123, []any{"(glojure.core/alias '%s '%s)\n", v57, v16}) + tmp121 = tmp124 + } else { + } + _ = tmp121 + tmp125 := checkDerefVar(var_glojure_DOT_core_alias) + tmp126 := lang.Apply(tmp125, []any{v57, v16}) + tmp120 = tmp126 + } else { + } + _ = tmp120 + var tmp127 any + var tmp128 any + { // let + // let binding "or__0__auto__" + var v129 any = v51 + _ = v129 + var tmp130 any + if lang.IsTruthy(v129) { + tmp130 = v129 + } else { + tmp131 := lang.Apply(kw_refer, []any{v84}) + tmp130 = tmp131 + } + tmp128 = tmp130 + } // end let + if lang.IsTruthy(tmp128) { + var tmp129 any + tmp130 := checkDerefVar(var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_) + if lang.IsTruthy(tmp130) { + tmp131 := checkDerefVar(var_glojure_DOT_core_printf) + tmp132 := lang.Apply(tmp131, []any{"(glojure.core/refer '%s", v16}) + _ = tmp132 + var tmp133 any + { // let + // let binding "seq_802" + tmp134 := checkDerefVar(var_glojure_DOT_core_seq) + tmp135 := lang.Apply(tmp134, []any{v84}) + var v136 any = tmp135 + _ = v136 + // let binding "chunk_803" + var v137 any = nil + _ = v137 + // let binding "count_804" + var v138 any = int64(0) + _ = v138 + // let binding "i_805" + var v139 any = int64(0) + _ = v139 + for { + var tmp140 any + tmp141 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp142 := lang.Apply(tmp141, []any{v139, v138}) + if lang.IsTruthy(tmp142) { + var tmp143 any + { // let + // let binding "opt" + tmp144, _ := lang.FieldOrMethod(v137, "nth") + if reflect.TypeOf(tmp144).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp145 := lang.Apply(tmp144, []any{v139}) + var v146 any = tmp145 + _ = v146 + tmp147 := checkDerefVar(var_glojure_DOT_core_printf) + tmp148 := checkDerefVar(var_glojure_DOT_core_key) + tmp149 := lang.Apply(tmp148, []any{v146}) + tmp150 := checkDerefVar(var_glojure_DOT_core_print_DASH_str) + tmp151 := checkDerefVar(var_glojure_DOT_core_val) + tmp152 := lang.Apply(tmp151, []any{v146}) + tmp153 := lang.Apply(tmp150, []any{tmp152}) + tmp154 := lang.Apply(tmp147, []any{" %s '%s", tmp149, tmp153}) + _ = tmp154 + var tmp155 any = v136 + var tmp156 any = v137 + var tmp157 any = v138 + tmp159 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp160 := lang.Apply(tmp159, []any{v139}) + var tmp158 any = tmp160 + v136 = tmp155 + v137 = tmp156 + v138 = tmp157 + v139 = tmp158 + continue + } // end let + tmp140 = tmp143 + } else { + var tmp144 any + { // let + // let binding "temp__0__auto__" + tmp145 := checkDerefVar(var_glojure_DOT_core_seq) + tmp146 := lang.Apply(tmp145, []any{v136}) + var v147 any = tmp146 + _ = v147 + var tmp148 any + if lang.IsTruthy(v147) { + var tmp149 any + { // let + // let binding "seq_802" + var v150 any = v147 + _ = v150 + var tmp151 any + tmp152 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp153 := lang.Apply(tmp152, []any{v150}) + if lang.IsTruthy(tmp153) { + var tmp154 any + { // let + // let binding "c__0__auto__" + tmp155 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp156 := lang.Apply(tmp155, []any{v150}) + var v157 any = tmp156 + _ = v157 + tmp159 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp160 := lang.Apply(tmp159, []any{v150}) + var tmp158 any = tmp160 + var tmp161 any = v157 + tmp163 := checkDerefVar(var_glojure_DOT_core_int) + tmp164 := checkDerefVar(var_glojure_DOT_core_count) + tmp165 := lang.Apply(tmp164, []any{v157}) + tmp166 := lang.Apply(tmp163, []any{tmp165}) + var tmp162 any = tmp166 + tmp168 := checkDerefVar(var_glojure_DOT_core_int) + tmp169 := lang.Apply(tmp168, []any{int64(0)}) + var tmp167 any = tmp169 + v136 = tmp158 + v137 = tmp161 + v138 = tmp162 + v139 = tmp167 + continue + } // end let + tmp151 = tmp154 + } else { + var tmp155 any + { // let + // let binding "opt" + tmp156 := checkDerefVar(var_glojure_DOT_core_first) + tmp157 := lang.Apply(tmp156, []any{v150}) + var v158 any = tmp157 + _ = v158 + tmp159 := checkDerefVar(var_glojure_DOT_core_printf) + tmp160 := checkDerefVar(var_glojure_DOT_core_key) + tmp161 := lang.Apply(tmp160, []any{v158}) + tmp162 := checkDerefVar(var_glojure_DOT_core_print_DASH_str) + tmp163 := checkDerefVar(var_glojure_DOT_core_val) + tmp164 := lang.Apply(tmp163, []any{v158}) + tmp165 := lang.Apply(tmp162, []any{tmp164}) + tmp166 := lang.Apply(tmp159, []any{" %s '%s", tmp161, tmp165}) + _ = tmp166 + tmp168 := checkDerefVar(var_glojure_DOT_core_next) + tmp169 := lang.Apply(tmp168, []any{v150}) + var tmp167 any = tmp169 + var tmp170 any = nil + var tmp171 any = int64(0) + var tmp172 any = int64(0) + v136 = tmp167 + v137 = tmp170 + v138 = tmp171 + v139 = tmp172 + continue + } // end let + tmp151 = tmp155 + } + tmp149 = tmp151 + } // end let + tmp148 = tmp149 + } else { + } + tmp144 = tmp148 + } // end let + tmp140 = tmp144 + } + tmp133 = tmp140 + break + } + } // end let + _ = tmp133 + tmp134 := checkDerefVar(var_glojure_DOT_core_printf) + tmp135 := lang.Apply(tmp134, []any{")\n"}) + tmp129 = tmp135 + } else { + } + _ = tmp129 + tmp136 := checkDerefVar(var_glojure_DOT_core_apply) + tmp137 := checkDerefVar(var_glojure_DOT_core_refer) + tmp138 := checkDerefVar(var_glojure_DOT_core_mapcat) + tmp139 := checkDerefVar(var_glojure_DOT_core_seq) + tmp140 := lang.Apply(tmp138, []any{tmp139, v84}) + tmp141 := lang.Apply(tmp136, []any{tmp137, v16, tmp140}) + tmp127 = tmp141 + } else { + } + tmp97 = tmp127 + }() + tmp90 = tmp97 + } // end let + tmp10 = tmp90 + } // end let + return tmp10 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_load_DASH_lib = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_load_DASH_lib.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // load-libs + { + tmp0 := sym_load_DASH_libs.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_args)), kw_doc, "Loads libs, interpreting libspecs, prefix lists, and flags for\n forwarding to load-lib", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(8), kw_line, int(5951), kw_end_DASH_line, int(5951), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + var tmp3 any + { // let + // let binding "flags" + tmp4 := checkDerefVar(var_glojure_DOT_core_filter) + tmp5 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp6 := lang.Apply(tmp4, []any{tmp5, v2}) + var v7 any = tmp6 + _ = v7 + // let binding "opts" + tmp8 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp9 := checkDerefVar(var_glojure_DOT_core_repeat) + tmp10 := lang.Apply(tmp9, []any{true}) + tmp11 := lang.Apply(tmp8, []any{v7, tmp10}) + var v12 any = tmp11 + _ = v12 + // let binding "args" + tmp13 := checkDerefVar(var_glojure_DOT_core_filter) + tmp14 := checkDerefVar(var_glojure_DOT_core_complement) + tmp15 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp16 := lang.Apply(tmp14, []any{tmp15}) + tmp17 := lang.Apply(tmp13, []any{tmp16, v2}) + var v18 any = tmp17 + _ = v18 + var tmp19 any + { // let + // let binding "supported" + tmp20 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{kw_as, kw_reload, kw_reload_DASH_all, kw_require, kw_use, kw_verbose, kw_refer, kw_as_DASH_alias})) + tmp21 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5959), kw_column, int(21), kw_end_DASH_line, int(5959), kw_end_DASH_column, int(86)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v23 any = tmp22 + _ = v23 + // let binding "unsupported" + tmp24 := checkDerefVar(var_glojure_DOT_core_seq) + tmp25 := checkDerefVar(var_glojure_DOT_core_remove) + tmp26 := lang.Apply(tmp25, []any{v23, v7}) + tmp27 := lang.Apply(tmp24, []any{tmp26}) + var v28 any = tmp27 + _ = v28 + tmp29 := checkDerefVar(var_glojure_DOT_core_throw_DASH_if) + tmp30 := checkDerefVar(var_glojure_DOT_core_apply) + tmp31 := checkDerefVar(var_glojure_DOT_core_str) + tmp32 := checkDerefVar(var_glojure_DOT_core_interpose) + tmp33 := lang.Apply(tmp32, []any{lang.NewChar(44), v28}) + tmp34 := lang.Apply(tmp30, []any{tmp31, "Unsupported option(s) supplied: ", tmp33}) + tmp35 := lang.Apply(tmp29, []any{v28, tmp34}) + tmp19 = tmp35 + } // end let + _ = tmp19 + tmp20 := checkDerefVar(var_glojure_DOT_core_throw_DASH_if) + tmp21 := checkDerefVar(var_glojure_DOT_core_not) + tmp22 := checkDerefVar(var_glojure_DOT_core_seq) + tmp23 := lang.Apply(tmp22, []any{v18}) + tmp24 := lang.Apply(tmp21, []any{tmp23}) + tmp25 := lang.Apply(tmp20, []any{tmp24, "Nothing specified to load"}) + _ = tmp25 + var tmp26 any + { // let + // let binding "seq_806" + tmp27 := checkDerefVar(var_glojure_DOT_core_seq) + tmp28 := lang.Apply(tmp27, []any{v18}) + var v29 any = tmp28 + _ = v29 + // let binding "chunk_807" + var v30 any = nil + _ = v30 + // let binding "count_808" + var v31 any = int64(0) + _ = v31 + // let binding "i_809" + var v32 any = int64(0) + _ = v32 + for { + var tmp33 any + tmp34 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp35 := lang.Apply(tmp34, []any{v32, v31}) + if lang.IsTruthy(tmp35) { + var tmp36 any + { // let + // let binding "arg" + tmp37, _ := lang.FieldOrMethod(v30, "nth") + if reflect.TypeOf(tmp37).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp38 := lang.Apply(tmp37, []any{v32}) + var v39 any = tmp38 + _ = v39 + var tmp40 any + tmp41 := checkDerefVar(var_glojure_DOT_core_libspec_QMARK_) + tmp42 := lang.Apply(tmp41, []any{v39}) + if lang.IsTruthy(tmp42) { + tmp43 := checkDerefVar(var_glojure_DOT_core_apply) + tmp44 := checkDerefVar(var_glojure_DOT_core_load_DASH_lib) + tmp45 := checkDerefVar(var_glojure_DOT_core_prependss) + tmp46 := lang.Apply(tmp45, []any{v39, v12}) + tmp47 := lang.Apply(tmp43, []any{tmp44, nil, tmp46}) + tmp40 = tmp47 + } else { + var tmp48 any + { // let + // let binding "vec__810" + var v49 any = v39 + _ = v49 + // let binding "seq__811" + tmp50 := checkDerefVar(var_glojure_DOT_core_seq) + tmp51 := lang.Apply(tmp50, []any{v49}) + var v52 any = tmp51 + _ = v52 + // let binding "first__812" + tmp53 := checkDerefVar(var_glojure_DOT_core_first) + tmp54 := lang.Apply(tmp53, []any{v52}) + var v55 any = tmp54 + _ = v55 + // let binding "seq__811" + tmp56 := checkDerefVar(var_glojure_DOT_core_next) + tmp57 := lang.Apply(tmp56, []any{v52}) + var v58 any = tmp57 + _ = v58 + // let binding "prefix" + var v59 any = v55 + _ = v59 + // let binding "args" + var v60 any = v58 + _ = v60 + tmp61 := checkDerefVar(var_glojure_DOT_core_throw_DASH_if) + tmp62 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp63 := lang.Apply(tmp62, []any{v59}) + tmp64 := lang.Apply(tmp61, []any{tmp63, "prefix cannot be nil"}) + _ = tmp64 + var tmp65 any + { // let + // let binding "seq_813" + tmp66 := checkDerefVar(var_glojure_DOT_core_seq) + tmp67 := lang.Apply(tmp66, []any{v60}) + var v68 any = tmp67 + _ = v68 + // let binding "chunk_814" + var v69 any = nil + _ = v69 + // let binding "count_815" + var v70 any = int64(0) + _ = v70 + // let binding "i_816" + var v71 any = int64(0) + _ = v71 + for { + var tmp72 any + tmp73 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp74 := lang.Apply(tmp73, []any{v71, v70}) + if lang.IsTruthy(tmp74) { + var tmp75 any + { // let + // let binding "arg" + tmp76, _ := lang.FieldOrMethod(v69, "nth") + if reflect.TypeOf(tmp76).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp77 := lang.Apply(tmp76, []any{v71}) + var v78 any = tmp77 + _ = v78 + tmp79 := checkDerefVar(var_glojure_DOT_core_apply) + tmp80 := checkDerefVar(var_glojure_DOT_core_load_DASH_lib) + tmp81 := checkDerefVar(var_glojure_DOT_core_prependss) + tmp82 := lang.Apply(tmp81, []any{v78, v12}) + tmp83 := lang.Apply(tmp79, []any{tmp80, v59, tmp82}) + _ = tmp83 + var tmp84 any = v68 + var tmp85 any = v69 + var tmp86 any = v70 + tmp88 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp89 := lang.Apply(tmp88, []any{v71}) + var tmp87 any = tmp89 + v68 = tmp84 + v69 = tmp85 + v70 = tmp86 + v71 = tmp87 + continue + } // end let + tmp72 = tmp75 + } else { + var tmp76 any + { // let + // let binding "temp__0__auto__" + tmp77 := checkDerefVar(var_glojure_DOT_core_seq) + tmp78 := lang.Apply(tmp77, []any{v68}) + var v79 any = tmp78 + _ = v79 + var tmp80 any + if lang.IsTruthy(v79) { + var tmp81 any + { // let + // let binding "seq_813" + var v82 any = v79 + _ = v82 + var tmp83 any + tmp84 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp85 := lang.Apply(tmp84, []any{v82}) + if lang.IsTruthy(tmp85) { + var tmp86 any + { // let + // let binding "c__0__auto__" + tmp87 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp88 := lang.Apply(tmp87, []any{v82}) + var v89 any = tmp88 + _ = v89 + tmp91 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp92 := lang.Apply(tmp91, []any{v82}) + var tmp90 any = tmp92 + var tmp93 any = v89 + tmp95 := checkDerefVar(var_glojure_DOT_core_int) + tmp96 := checkDerefVar(var_glojure_DOT_core_count) + tmp97 := lang.Apply(tmp96, []any{v89}) + tmp98 := lang.Apply(tmp95, []any{tmp97}) + var tmp94 any = tmp98 + tmp100 := checkDerefVar(var_glojure_DOT_core_int) + tmp101 := lang.Apply(tmp100, []any{int64(0)}) + var tmp99 any = tmp101 + v68 = tmp90 + v69 = tmp93 + v70 = tmp94 + v71 = tmp99 + continue + } // end let + tmp83 = tmp86 + } else { + var tmp87 any + { // let + // let binding "arg" + tmp88 := checkDerefVar(var_glojure_DOT_core_first) + tmp89 := lang.Apply(tmp88, []any{v82}) + var v90 any = tmp89 + _ = v90 + tmp91 := checkDerefVar(var_glojure_DOT_core_apply) + tmp92 := checkDerefVar(var_glojure_DOT_core_load_DASH_lib) + tmp93 := checkDerefVar(var_glojure_DOT_core_prependss) + tmp94 := lang.Apply(tmp93, []any{v90, v12}) + tmp95 := lang.Apply(tmp91, []any{tmp92, v59, tmp94}) + _ = tmp95 + tmp97 := checkDerefVar(var_glojure_DOT_core_next) + tmp98 := lang.Apply(tmp97, []any{v82}) + var tmp96 any = tmp98 + var tmp99 any = nil + var tmp100 any = int64(0) + var tmp101 any = int64(0) + v68 = tmp96 + v69 = tmp99 + v70 = tmp100 + v71 = tmp101 + continue + } // end let + tmp83 = tmp87 + } + tmp81 = tmp83 + } // end let + tmp80 = tmp81 + } else { + } + tmp76 = tmp80 + } // end let + tmp72 = tmp76 + } + tmp65 = tmp72 + break + } + } // end let + tmp48 = tmp65 + } // end let + tmp40 = tmp48 + } + _ = tmp40 + var tmp49 any = v29 + var tmp50 any = v30 + var tmp51 any = v31 + tmp53 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp54 := lang.Apply(tmp53, []any{v32}) + var tmp52 any = tmp54 + v29 = tmp49 + v30 = tmp50 + v31 = tmp51 + v32 = tmp52 + continue + } // end let + tmp33 = tmp36 + } else { + var tmp37 any + { // let + // let binding "temp__0__auto__" + tmp38 := checkDerefVar(var_glojure_DOT_core_seq) + tmp39 := lang.Apply(tmp38, []any{v29}) + var v40 any = tmp39 + _ = v40 + var tmp41 any + if lang.IsTruthy(v40) { + var tmp42 any + { // let + // let binding "seq_806" + var v43 any = v40 + _ = v43 + var tmp44 any + tmp45 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp46 := lang.Apply(tmp45, []any{v43}) + if lang.IsTruthy(tmp46) { + var tmp47 any + { // let + // let binding "c__0__auto__" + tmp48 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp49 := lang.Apply(tmp48, []any{v43}) + var v50 any = tmp49 + _ = v50 + tmp52 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp53 := lang.Apply(tmp52, []any{v43}) + var tmp51 any = tmp53 + var tmp54 any = v50 + tmp56 := checkDerefVar(var_glojure_DOT_core_int) + tmp57 := checkDerefVar(var_glojure_DOT_core_count) + tmp58 := lang.Apply(tmp57, []any{v50}) + tmp59 := lang.Apply(tmp56, []any{tmp58}) + var tmp55 any = tmp59 + tmp61 := checkDerefVar(var_glojure_DOT_core_int) + tmp62 := lang.Apply(tmp61, []any{int64(0)}) + var tmp60 any = tmp62 + v29 = tmp51 + v30 = tmp54 + v31 = tmp55 + v32 = tmp60 + continue + } // end let + tmp44 = tmp47 + } else { + var tmp48 any + { // let + // let binding "arg" + tmp49 := checkDerefVar(var_glojure_DOT_core_first) + tmp50 := lang.Apply(tmp49, []any{v43}) + var v51 any = tmp50 + _ = v51 + var tmp52 any + tmp53 := checkDerefVar(var_glojure_DOT_core_libspec_QMARK_) + tmp54 := lang.Apply(tmp53, []any{v51}) + if lang.IsTruthy(tmp54) { + tmp55 := checkDerefVar(var_glojure_DOT_core_apply) + tmp56 := checkDerefVar(var_glojure_DOT_core_load_DASH_lib) + tmp57 := checkDerefVar(var_glojure_DOT_core_prependss) + tmp58 := lang.Apply(tmp57, []any{v51, v12}) + tmp59 := lang.Apply(tmp55, []any{tmp56, nil, tmp58}) + tmp52 = tmp59 + } else { + var tmp60 any + { // let + // let binding "vec__817" + var v61 any = v51 + _ = v61 + // let binding "seq__818" + tmp62 := checkDerefVar(var_glojure_DOT_core_seq) + tmp63 := lang.Apply(tmp62, []any{v61}) + var v64 any = tmp63 + _ = v64 + // let binding "first__819" + tmp65 := checkDerefVar(var_glojure_DOT_core_first) + tmp66 := lang.Apply(tmp65, []any{v64}) + var v67 any = tmp66 + _ = v67 + // let binding "seq__818" + tmp68 := checkDerefVar(var_glojure_DOT_core_next) + tmp69 := lang.Apply(tmp68, []any{v64}) + var v70 any = tmp69 + _ = v70 + // let binding "prefix" + var v71 any = v67 + _ = v71 + // let binding "args" + var v72 any = v70 + _ = v72 + tmp73 := checkDerefVar(var_glojure_DOT_core_throw_DASH_if) + tmp74 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp75 := lang.Apply(tmp74, []any{v71}) + tmp76 := lang.Apply(tmp73, []any{tmp75, "prefix cannot be nil"}) + _ = tmp76 + var tmp77 any + { // let + // let binding "seq_820" + tmp78 := checkDerefVar(var_glojure_DOT_core_seq) + tmp79 := lang.Apply(tmp78, []any{v72}) + var v80 any = tmp79 + _ = v80 + // let binding "chunk_821" + var v81 any = nil + _ = v81 + // let binding "count_822" + var v82 any = int64(0) + _ = v82 + // let binding "i_823" + var v83 any = int64(0) + _ = v83 + for { + var tmp84 any + tmp85 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp86 := lang.Apply(tmp85, []any{v83, v82}) + if lang.IsTruthy(tmp86) { + var tmp87 any + { // let + // let binding "arg" + tmp88, _ := lang.FieldOrMethod(v81, "nth") + if reflect.TypeOf(tmp88).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp89 := lang.Apply(tmp88, []any{v83}) + var v90 any = tmp89 + _ = v90 + tmp91 := checkDerefVar(var_glojure_DOT_core_apply) + tmp92 := checkDerefVar(var_glojure_DOT_core_load_DASH_lib) + tmp93 := checkDerefVar(var_glojure_DOT_core_prependss) + tmp94 := lang.Apply(tmp93, []any{v90, v12}) + tmp95 := lang.Apply(tmp91, []any{tmp92, v71, tmp94}) + _ = tmp95 + var tmp96 any = v80 + var tmp97 any = v81 + var tmp98 any = v82 + tmp100 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp101 := lang.Apply(tmp100, []any{v83}) + var tmp99 any = tmp101 + v80 = tmp96 + v81 = tmp97 + v82 = tmp98 + v83 = tmp99 + continue + } // end let + tmp84 = tmp87 + } else { + var tmp88 any + { // let + // let binding "temp__0__auto__" + tmp89 := checkDerefVar(var_glojure_DOT_core_seq) + tmp90 := lang.Apply(tmp89, []any{v80}) + var v91 any = tmp90 + _ = v91 + var tmp92 any + if lang.IsTruthy(v91) { + var tmp93 any + { // let + // let binding "seq_820" + var v94 any = v91 + _ = v94 + var tmp95 any + tmp96 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp97 := lang.Apply(tmp96, []any{v94}) + if lang.IsTruthy(tmp97) { + var tmp98 any + { // let + // let binding "c__0__auto__" + tmp99 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp100 := lang.Apply(tmp99, []any{v94}) + var v101 any = tmp100 + _ = v101 + tmp103 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp104 := lang.Apply(tmp103, []any{v94}) + var tmp102 any = tmp104 + var tmp105 any = v101 + tmp107 := checkDerefVar(var_glojure_DOT_core_int) + tmp108 := checkDerefVar(var_glojure_DOT_core_count) + tmp109 := lang.Apply(tmp108, []any{v101}) + tmp110 := lang.Apply(tmp107, []any{tmp109}) + var tmp106 any = tmp110 + tmp112 := checkDerefVar(var_glojure_DOT_core_int) + tmp113 := lang.Apply(tmp112, []any{int64(0)}) + var tmp111 any = tmp113 + v80 = tmp102 + v81 = tmp105 + v82 = tmp106 + v83 = tmp111 + continue + } // end let + tmp95 = tmp98 + } else { + var tmp99 any + { // let + // let binding "arg" + tmp100 := checkDerefVar(var_glojure_DOT_core_first) + tmp101 := lang.Apply(tmp100, []any{v94}) + var v102 any = tmp101 + _ = v102 + tmp103 := checkDerefVar(var_glojure_DOT_core_apply) + tmp104 := checkDerefVar(var_glojure_DOT_core_load_DASH_lib) + tmp105 := checkDerefVar(var_glojure_DOT_core_prependss) + tmp106 := lang.Apply(tmp105, []any{v102, v12}) + tmp107 := lang.Apply(tmp103, []any{tmp104, v71, tmp106}) + _ = tmp107 + tmp109 := checkDerefVar(var_glojure_DOT_core_next) + tmp110 := lang.Apply(tmp109, []any{v94}) + var tmp108 any = tmp110 + var tmp111 any = nil + var tmp112 any = int64(0) + var tmp113 any = int64(0) + v80 = tmp108 + v81 = tmp111 + v82 = tmp112 + v83 = tmp113 + continue + } // end let + tmp95 = tmp99 + } + tmp93 = tmp95 + } // end let + tmp92 = tmp93 + } else { + } + tmp88 = tmp92 + } // end let + tmp84 = tmp88 + } + tmp77 = tmp84 + break + } + } // end let + tmp60 = tmp77 + } // end let + tmp52 = tmp60 + } + _ = tmp52 + tmp62 := checkDerefVar(var_glojure_DOT_core_next) + tmp63 := lang.Apply(tmp62, []any{v43}) + var tmp61 any = tmp63 + var tmp64 any = nil + var tmp65 any = int64(0) + var tmp66 any = int64(0) + v29 = tmp61 + v30 = tmp64 + v31 = tmp65 + v32 = tmp66 + continue + } // end let + tmp44 = tmp48 + } + tmp42 = tmp44 + } // end let + tmp41 = tmp42 + } else { + } + tmp37 = tmp41 + } // end let + tmp33 = tmp37 + } + tmp26 = tmp33 + break + } + } // end let + tmp3 = tmp26 + } // end let + return tmp3 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_load_DASH_libs = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_load_DASH_libs.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // require + { + tmp0 := sym_require.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_args)), kw_doc, "Loads libs, skipping any that are already loaded. Each argument is\n either a libspec that identifies a lib, a prefix list that identifies\n multiple libs whose names share a common prefix, or a flag that modifies\n how all the identified libs are loaded. Use :require in the ns macro\n in preference to calling this directly.\n\n Libs\n\n A 'lib' is a named set of resources in classpath whose contents define a\n library of Clojure code. Lib names are symbols and each lib is associated\n with a Clojure namespace and a Java package that share its name. A lib's\n name also locates its root directory within classpath using Java's\n package name to classpath-relative path mapping. All resources in a lib\n should be contained in the directory structure under its root directory.\n All definitions a lib makes should be in its associated namespace.\n\n 'require loads a lib by loading its root resource. The root resource path\n is derived from the lib name in the following manner:\n Consider a lib named by the symbol 'x.y.z; it has the root directory\n /x/y/, and its root resource is /x/y/z.clj, or\n /x/y/z.cljc if /x/y/z.clj does not exist. The\n root resource should contain code to create the lib's\n namespace (usually by using the ns macro) and load any additional\n lib resources.\n\n Libspecs\n\n A libspec is a lib name or a vector containing a lib name followed by\n options expressed as sequential keywords and arguments.\n\n Recognized options:\n :as takes a symbol as its argument and makes that symbol an alias to the\n lib's namespace in the current namespace.\n :as-alias takes a symbol as its argument and aliases like :as, however\n the lib will not be loaded. If the lib has not been loaded, a new\n empty namespace will be created (as with create-ns).\n :refer takes a list of symbols to refer from the namespace or the :all\n keyword to bring in all public vars.\n\n Prefix Lists\n\n It's common for Clojure code to depend on several libs whose names have\n the same prefix. When specifying libs, prefix lists can be used to reduce\n repetition. A prefix list contains the shared prefix followed by libspecs\n with the shared prefix removed from the lib names. After removing the\n prefix, the names that remain must not contain any periods.\n\n Flags\n\n A flag is a keyword.\n Recognized flags: :reload, :reload-all, :verbose\n :reload forces loading of all the identified libs even if they are\n already loaded (has no effect on libspecs using :as-alias)\n :reload-all implies :reload and also forces loading of all libs that the\n identified libs directly or indirectly load via require or use\n (has no effect on libspecs using :as-alias)\n :verbose triggers printing information about each load, alias, and refer\n\n Example:\n\n The following would load the libraries glojure.zip and glojure.set\n abbreviated as 's'.\n\n (require '(glojure zip [set :as s]))", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(5989), kw_end_DASH_line, int(5989))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_apply) + tmp4 := checkDerefVar(var_glojure_DOT_core_load_DASH_libs) + tmp5 := lang.Apply(tmp3, []any{tmp4, kw_require, v2}) + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_require = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_require.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // serialized-require + { + tmp0 := sym_serialized_DASH_require.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_args)), kw_doc, "Like 'require', but serializes loading.\n Interim function preferred over 'require' for known asynchronous loads.\n Future changes may make these equivalent.", kw_file, "glojure/core.glj", kw_added, "1.10", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(25), kw_column, int(8), kw_line, int(6059), kw_end_DASH_line, int(6059), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + var tmp3 any + { // let + // let binding "lockee__0__auto__" + var v4 any = nil + _ = v4 + var tmp5 any + func() { + var tmp6 any + { // let + // let binding "locklocal__1__auto__" + var v7 any = v4 + _ = v7 + tmp8 := lang.Apply(nil, []any{v7}) + _ = tmp8 + var tmp9 any + func() { + defer func() { + tmp10 := lang.Apply(nil, []any{v7}) + _ = tmp10 + }() + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + tmp12 := checkDerefVar(var_glojure_DOT_core_require) + tmp13 := lang.Apply(tmp11, []any{tmp12, v2}) + tmp9 = tmp13 + }() + tmp6 = tmp9 + } // end let + tmp5 = tmp6 + }() + tmp3 = tmp5 + } // end let + return tmp3 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_serialized_DASH_require = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_serialized_DASH_require.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // use + { + tmp0 := sym_use.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_args)), kw_doc, "Like 'require, but also refers to each lib's namespace using\n glojure.core/refer. Use :use in the ns macro in preference to calling\n this directly.\n\n 'use accepts additional options in libspecs: :exclude, :only, :rename.\n The arguments and semantics for :exclude, :only, and :rename are the same\n as those documented for glojure.core/refer.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(6079), kw_end_DASH_line, int(6079))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_apply) + tmp4 := checkDerefVar(var_glojure_DOT_core_load_DASH_libs) + tmp5 := lang.Apply(tmp3, []any{tmp4, kw_require, kw_use, v2}) + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_use = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_use.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // requiring-resolve + { + tmp0 := sym_requiring_DASH_resolve.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_sym)), kw_doc, "Resolves namespace-qualified sym per 'resolve'. If initial resolve\nfails, attempts to require sym's namespace and retries.", kw_file, "glojure/core.glj", kw_added, "1.10", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(7), kw_line, int(6068), kw_end_DASH_line, int(6068))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_qualified_DASH_symbol_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + var tmp6 any + { // let + // let binding "or__0__auto__" + tmp7 := checkDerefVar(var_glojure_DOT_core_resolve) + tmp8 := lang.Apply(tmp7, []any{v2}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + tmp10 = v9 + } else { + tmp11 := checkDerefVar(var_glojure_DOT_core_serialized_DASH_require) + tmp12 := checkDerefVar(var_glojure_DOT_core_symbol) + tmp13 := checkDerefVar(var_glojure_DOT_core_namespace) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(tmp12, []any{tmp14}) + tmp16 := lang.Apply(tmp11, []any{tmp15}) + _ = tmp16 + tmp17 := checkDerefVar(var_glojure_DOT_core_resolve) + tmp18 := lang.Apply(tmp17, []any{v2}) + tmp10 = tmp18 + } + tmp6 = tmp10 + } // end let + tmp3 = tmp6 + } else { + tmp7 := checkDerefVar(var_glojure_DOT_core_str) + tmp8 := lang.Apply(tmp7, []any{"Not a qualified symbol: ", v2}) + tmp9 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp8}) + panic(tmp9) + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_requiring_DASH_resolve = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_requiring_DASH_resolve.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // mapv + { + tmp0 := sym_mapv.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_coll), lang.NewVector(sym_f, sym_c1, sym_c2), lang.NewVector(sym_f, sym_c1, sym_c2, sym_c3), lang.NewVector(sym_f, sym_c1, sym_c2, sym_c3, sym__AMP_, sym_colls)), kw_doc, "Returns a vector consisting of the result of applying f to the\n set of first items of each coll, followed by applying f to the set\n of second items in each coll, until any one of the colls is\n exhausted. Any remaining items in other colls are ignored. Function\n f should accept number-of-colls arguments.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.4", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(6943), kw_end_DASH_line, int(6943))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp5 := checkDerefVar(var_glojure_DOT_core_reduce) + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_conj_BANG_) + tmp10 := lang.Apply(v2, []any{v8}) + tmp11 := lang.Apply(tmp9, []any{v7, tmp10}) + return tmp11 + }) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6952), kw_column, int(18), kw_end_DASH_line, int(6952), kw_end_DASH_column, int(43)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp9 := checkDerefVar(var_glojure_DOT_core_transient) + tmp10 := lang.NewVector() + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6952), kw_column, int(56), kw_end_DASH_line, int(6952), kw_end_DASH_column, int(57)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := lang.Apply(tmp9, []any{tmp12}) + tmp14 := lang.Apply(tmp5, []any{tmp8, tmp13, v3}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_into) + tmp6 := lang.NewVector() + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6955), kw_column, int(12), kw_end_DASH_line, int(6955), kw_end_DASH_column, int(13)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp9 := checkDerefVar(var_glojure_DOT_core_map) + tmp10 := lang.Apply(tmp9, []any{v2, v3, v4}) + tmp11 := lang.Apply(tmp5, []any{tmp8, tmp10}) + return tmp11 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_into) + tmp7 := lang.NewVector() + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6957), kw_column, int(12), kw_end_DASH_line, int(6957), kw_end_DASH_column, int(13)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp10 := checkDerefVar(var_glojure_DOT_core_map) + tmp11 := lang.Apply(tmp10, []any{v2, v3, v4, v5}) + tmp12 := lang.Apply(tmp6, []any{tmp9, tmp11}) + return tmp12 + default: + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var v6 any = lang.NewList(args[4:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_into) + tmp8 := lang.NewVector() + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6959), kw_column, int(12), kw_end_DASH_line, int(6959), kw_end_DASH_column, int(13)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + tmp12 := checkDerefVar(var_glojure_DOT_core_map) + tmp13 := lang.Apply(tmp11, []any{tmp12, v2, v3, v4, v5, v6}) + tmp14 := lang.Apply(tmp7, []any{tmp10, tmp13}) + return tmp14 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_mapv = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_mapv.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // newline + { + tmp0 := sym_newline.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Writes a platform-specific newline to *out*", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(3698), kw_end_DASH_line, int(3698))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp2 := checkDerefVar(var_glojure_DOT_core__STAR_out_STAR_) + tmp3 := checkDerefVar(var_glojure_DOT_core_system_DASH_newline) + tmp4 := lang.Apply(lang.AppendWriter, []any{tmp2, tmp3}) + _ = tmp4 + return nil + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_newline = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_newline.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // normalize-slurp-opts + { + tmp0 := sym_normalize_DASH_slurp_DASH_opts.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6974), kw_column, int(8), kw_end_DASH_line, int(6974), kw_end_DASH_column, int(27), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_opts)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_first) + tmp6 := lang.Apply(tmp5, []any{v2}) + tmp7 := lang.Apply(tmp4, []any{tmp6}) + if lang.IsTruthy(tmp7) { + tmp8 := checkDerefVar(var_glojure_DOT_core_println) + tmp9 := lang.Apply(tmp8, []any{"WARNING: (slurp f enc) is deprecated, use (slurp f :encoding enc)."}) + _ = tmp9 + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := lang.NewVector(kw_encoding, tmp11) + tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6979), kw_column, int(7), kw_end_DASH_line, int(6979), kw_end_DASH_column, int(30)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp3 = tmp14 + } else { + tmp3 = v2 + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_normalize_DASH_slurp_DASH_opts = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_normalize_DASH_slurp_DASH_opts.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // pr + { + tmp0 := sym_pr.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_x), lang.NewVector(sym_x, sym__AMP_, sym_more)), kw_doc, "Prints the object(s) to the output stream that is the current value\n of *out*. Prints the object(s), separated by spaces if there is\n more than one. By default, pr and prn print in a way that objects\n can be read by the reader", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(7), kw_line, int(3678), kw_end_DASH_line, int(3678), kw_dynamic, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return nil + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) + tmp4 := checkDerefVar(var_glojure_DOT_core__STAR_out_STAR_) + tmp5 := lang.Apply(tmp3, []any{v2, tmp4}) + return tmp5 + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + recur_loop_2211: + tmp4 := checkDerefVar(var_glojure_DOT_core_pr) + tmp5 := lang.Apply(tmp4, []any{v2}) + _ = tmp5 + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_out_STAR_) + tmp7 := lang.Apply(lang.AppendWriter, []any{tmp6, lang.NewChar(32)}) + _ = tmp7 + var tmp8 any + { // let + // let binding "temp__0__auto__" + tmp9 := checkDerefVar(var_glojure_DOT_core_next) + tmp10 := lang.Apply(tmp9, []any{v3}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + var tmp13 any + { // let + // let binding "nmore" + var v14 any = v11 + _ = v14 + tmp16 := checkDerefVar(var_glojure_DOT_core_first) + tmp17 := lang.Apply(tmp16, []any{v3}) + var tmp15 any = tmp17 + var tmp18 any = v14 + v2 = tmp15 + v3 = tmp18 + goto recur_loop_2211 + } // end let + tmp12 = tmp13 + } else { + tmp14 := checkDerefVar(var_glojure_DOT_core_apply) + tmp15 := checkDerefVar(var_glojure_DOT_core_pr) + tmp16 := lang.Apply(tmp14, []any{tmp15, v3}) + tmp12 = tmp16 + } + tmp8 = tmp12 + } // end let + return tmp8 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_pr = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_pr.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // pr-str + { + tmp1 := reflect.TypeOf("") + tmp0 := sym_pr_DASH_str.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_xs)), kw_doc, "pr to a string, returning it", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(4758), kw_end_DASH_line, int(4758))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v3 any = lang.NewList(args[0:]...) + _ = v3 + var tmp4 any + { // let + // let binding "s__0__auto__" + var v5 any = "unimplemented: new with non-constant class type" + _ = v5 + var tmp6 any + { // let + tmp7 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp8 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp9 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) + tmp10 := lang.Apply(tmp8, []any{tmp9, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp10}) + _ = tmp11 + var tmp12 any + func() { + defer func() { + tmp13 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp14 := lang.Apply(tmp13, nil) + _ = tmp14 + }() + tmp15 := checkDerefVar(var_glojure_DOT_core_apply) + tmp16 := checkDerefVar(var_glojure_DOT_core_pr) + tmp17 := lang.Apply(tmp15, []any{tmp16, v3}) + _ = tmp17 + tmp18 := checkDerefVar(var_glojure_DOT_core_str) + tmp19 := lang.Apply(tmp18, []any{v5}) + tmp12 = tmp19 + }() + tmp6 = tmp12 + } // end let + tmp4 = tmp6 + } // end let + return tmp4 + } + }) + tmp3 := reflect.TypeOf("") + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_pr_DASH_str = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_pr_DASH_str.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print + { + tmp0 := sym_print.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_more)), kw_doc, "Prints the object(s) to the output stream that is the current value\n of *out*. print and println produce output for human consumption.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3725), kw_end_DASH_line, int(3725))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + var tmp3 any + { // let + tmp4 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp5 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp6 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_print_DASH_readably_STAR_) + tmp7 := lang.Apply(tmp5, []any{tmp6, nil}) + tmp8 := lang.Apply(tmp4, []any{tmp7}) + _ = tmp8 + var tmp9 any + func() { + defer func() { + tmp10 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp11 := lang.Apply(tmp10, nil) + _ = tmp11 + }() + tmp12 := checkDerefVar(var_glojure_DOT_core_apply) + tmp13 := checkDerefVar(var_glojure_DOT_core_pr) + tmp14 := lang.Apply(tmp12, []any{tmp13, v2}) + tmp9 = tmp14 + }() + tmp3 = tmp9 + } // end let + return tmp3 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_print = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_print.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print-str + { + tmp1 := reflect.TypeOf("") + tmp0 := sym_print_DASH_str.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_xs)), kw_doc, "print to a string, returning it", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(4776), kw_end_DASH_line, int(4776))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v3 any = lang.NewList(args[0:]...) + _ = v3 + var tmp4 any + { // let + // let binding "s__0__auto__" + var v5 any = "unimplemented: new with non-constant class type" + _ = v5 + var tmp6 any + { // let + tmp7 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp8 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp9 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) + tmp10 := lang.Apply(tmp8, []any{tmp9, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp10}) + _ = tmp11 + var tmp12 any + func() { + defer func() { + tmp13 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp14 := lang.Apply(tmp13, nil) + _ = tmp14 + }() + tmp15 := checkDerefVar(var_glojure_DOT_core_apply) + tmp16 := checkDerefVar(var_glojure_DOT_core_print) + tmp17 := lang.Apply(tmp15, []any{tmp16, v3}) + _ = tmp17 + tmp18 := checkDerefVar(var_glojure_DOT_core_str) + tmp19 := lang.Apply(tmp18, []any{v5}) + tmp12 = tmp19 + }() + tmp6 = tmp12 + } // end let + tmp4 = tmp6 + } // end let + return tmp4 + } + }) + tmp3 := reflect.TypeOf("") + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_print_DASH_str = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_print_DASH_str.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // printf + { + tmp0 := sym_printf.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_fmt, sym__AMP_, sym_args)), kw_doc, "Prints formatted output, as per format", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(5725), kw_end_DASH_line, int(5725))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_print) + tmp5 := checkDerefVar(var_glojure_DOT_core_apply) + tmp6 := checkDerefVar(var_glojure_DOT_core_format) + tmp7 := lang.Apply(tmp5, []any{tmp6, v2, v3}) + tmp8 := lang.Apply(tmp4, []any{tmp7}) + return tmp8 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_printf = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_printf.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // prn + { + tmp0 := sym_prn.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_more)), kw_doc, "Same as pr followed by (newline). Observes *flush-on-newline*", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(3715), kw_end_DASH_line, int(3715))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_apply) + tmp4 := checkDerefVar(var_glojure_DOT_core_pr) + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + _ = tmp5 + tmp6 := checkDerefVar(var_glojure_DOT_core_newline) + tmp7 := lang.Apply(tmp6, nil) + _ = tmp7 + var tmp8 any + tmp9 := checkDerefVar(var_glojure_DOT_core__STAR_flush_DASH_on_DASH_newline_STAR_) + if lang.IsTruthy(tmp9) { + tmp10 := checkDerefVar(var_glojure_DOT_core_flush) + tmp11 := lang.Apply(tmp10, nil) + tmp8 = tmp11 + } else { + } + return tmp8 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_prn = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_prn.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // prn-str + { + tmp1 := reflect.TypeOf("") + tmp0 := sym_prn_DASH_str.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_xs)), kw_doc, "prn to a string, returning it", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4767), kw_end_DASH_line, int(4767))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v3 any = lang.NewList(args[0:]...) + _ = v3 + var tmp4 any + { // let + // let binding "s__0__auto__" + var v5 any = "unimplemented: new with non-constant class type" + _ = v5 + var tmp6 any + { // let + tmp7 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp8 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp9 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) + tmp10 := lang.Apply(tmp8, []any{tmp9, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp10}) + _ = tmp11 + var tmp12 any + func() { + defer func() { + tmp13 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp14 := lang.Apply(tmp13, nil) + _ = tmp14 + }() + tmp15 := checkDerefVar(var_glojure_DOT_core_apply) + tmp16 := checkDerefVar(var_glojure_DOT_core_prn) + tmp17 := lang.Apply(tmp15, []any{tmp16, v3}) + _ = tmp17 + tmp18 := checkDerefVar(var_glojure_DOT_core_str) + tmp19 := lang.Apply(tmp18, []any{v5}) + tmp12 = tmp19 + }() + tmp6 = tmp12 + } // end let + tmp4 = tmp6 + } // end let + return tmp4 + } + }) + tmp3 := reflect.TypeOf("") + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_prn_DASH_str = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_prn_DASH_str.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // println + { + tmp0 := sym_println.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_more)), kw_doc, "Same as print followed by (newline)", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(3734), kw_end_DASH_line, int(3734))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + var tmp3 any + { // let + tmp4 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp5 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp6 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_print_DASH_readably_STAR_) + tmp7 := lang.Apply(tmp5, []any{tmp6, nil}) + tmp8 := lang.Apply(tmp4, []any{tmp7}) + _ = tmp8 + var tmp9 any + func() { + defer func() { + tmp10 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp11 := lang.Apply(tmp10, nil) + _ = tmp11 + }() + tmp12 := checkDerefVar(var_glojure_DOT_core_apply) + tmp13 := checkDerefVar(var_glojure_DOT_core_prn) + tmp14 := lang.Apply(tmp12, []any{tmp13, v2}) + tmp9 = tmp14 + }() + tmp3 = tmp9 + } // end let + return tmp3 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_println = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_println.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // println-str + { + tmp1 := reflect.TypeOf("") + tmp0 := sym_println_DASH_str.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_xs)), kw_doc, "println to a string, returning it", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(4785), kw_end_DASH_line, int(4785))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v3 any = lang.NewList(args[0:]...) + _ = v3 + var tmp4 any + { // let + // let binding "s__0__auto__" + var v5 any = "unimplemented: new with non-constant class type" + _ = v5 + var tmp6 any + { // let + tmp7 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp8 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp9 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) + tmp10 := lang.Apply(tmp8, []any{tmp9, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp10}) + _ = tmp11 + var tmp12 any + func() { + defer func() { + tmp13 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp14 := lang.Apply(tmp13, nil) + _ = tmp14 + }() + tmp15 := checkDerefVar(var_glojure_DOT_core_apply) + tmp16 := checkDerefVar(var_glojure_DOT_core_println) + tmp17 := lang.Apply(tmp15, []any{tmp16, v3}) + _ = tmp17 + tmp18 := checkDerefVar(var_glojure_DOT_core_str) + tmp19 := lang.Apply(tmp18, []any{v5}) + tmp12 = tmp19 + }() + tmp6 = tmp12 + } // end let + tmp4 = tmp6 + } // end let + return tmp4 + } + }) + tmp3 := reflect.TypeOf("") + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_println_DASH_str = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_println_DASH_str.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // pr-on + { + tmp0 := sym_pr_DASH_on.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_w)), kw_static, true, kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3669), kw_end_DASH_line, int(3669), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_dup_STAR_) + if lang.IsTruthy(tmp5) { + tmp6 := checkDerefVar(var_glojure_DOT_core_print_DASH_dup) + tmp7 := lang.Apply(tmp6, []any{v2, v3}) + tmp4 = tmp7 + } else { + tmp8 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp9 := lang.Apply(tmp8, []any{v2, v3}) + tmp4 = tmp9 + } + _ = tmp4 + return nil + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_pr_DASH_on = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_pr_DASH_on.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print-meta + { + tmp0 := sym_print_DASH_meta.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(70), kw_column, int(8), kw_end_DASH_line, int(70), kw_end_DASH_column, int(17), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_o, sym_w)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "temp__0__auto__" + tmp5 := checkDerefVar(var_glojure_DOT_core_meta) + tmp6 := lang.Apply(tmp5, []any{v2}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + if lang.IsTruthy(v7) { + var tmp9 any + { // let + // let binding "m" + var v10 any = v7 + _ = v10 + var tmp11 any + var tmp12 any + { // let + // let binding "and__0__auto__" + tmp13 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp14 := checkDerefVar(var_glojure_DOT_core_count) + tmp15 := lang.Apply(tmp14, []any{v10}) + tmp16 := lang.Apply(tmp13, []any{tmp15}) + var v17 any = tmp16 + _ = v17 + var tmp18 any + if lang.IsTruthy(v17) { + var tmp19 any + { // let + // let binding "or__0__auto__" + tmp20 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_dup_STAR_) + var v21 any = tmp20 + _ = v21 + var tmp22 any + if lang.IsTruthy(v21) { + tmp22 = v21 + } else { + var tmp23 any + { // let + // let binding "and__0__auto__" + tmp24 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_meta_STAR_) + var v25 any = tmp24 + _ = v25 + var tmp26 any + if lang.IsTruthy(v25) { + tmp27 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_readably_STAR_) + tmp26 = tmp27 + } else { + tmp26 = v25 + } + tmp23 = tmp26 + } // end let + tmp22 = tmp23 + } + tmp19 = tmp22 + } // end let + tmp18 = tmp19 + } else { + tmp18 = v17 + } + tmp12 = tmp18 + } // end let + if lang.IsTruthy(tmp12) { + tmp13 := lang.Apply(lang.WriteWriter, []any{v3, "^"}) + _ = tmp13 + var tmp14 any + var tmp15 any + { // let + // let binding "and__0__auto__" + tmp16 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp17 := checkDerefVar(var_glojure_DOT_core_count) + tmp18 := lang.Apply(tmp17, []any{v10}) + tmp19 := lang.Apply(tmp16, []any{tmp18, int64(1)}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + tmp22 := lang.Apply(kw_tag, []any{v10}) + tmp21 = tmp22 + } else { + tmp21 = v20 + } + tmp15 = tmp21 + } // end let + if lang.IsTruthy(tmp15) { + tmp16 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) + tmp17 := lang.Apply(kw_tag, []any{v10}) + tmp18 := lang.Apply(tmp16, []any{tmp17, v3}) + tmp14 = tmp18 + } else { + tmp19 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) + tmp20 := lang.Apply(tmp19, []any{v10, v3}) + tmp14 = tmp20 + } + _ = tmp14 + tmp21 := lang.Apply(lang.WriteWriter, []any{v3, " "}) + tmp11 = tmp21 + } else { + } + tmp9 = tmp11 + } // end let + tmp8 = tmp9 + } else { + } + tmp4 = tmp8 + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_print_DASH_meta = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_print_DASH_meta.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print-simple + { + tmp0 := sym_print_DASH_simple.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(81), kw_column, int(7), kw_end_DASH_line, int(81), kw_end_DASH_column, int(18), kw_arglists, lang.NewList(lang.NewVector(sym_o, sym_w)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + _ = tmp5 + tmp6 := checkDerefVar(var_glojure_DOT_core_str) + tmp7 := lang.Apply(tmp6, []any{v2}) + tmp8 := lang.Apply(lang.WriteWriter, []any{v3, tmp7}) + return tmp8 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_print_DASH_simple = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_print_DASH_simple.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print-dup + { + tmp0 := sym_print_DASH_dup.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3667), kw_column, int(11), kw_end_DASH_line, int(3667), kw_end_DASH_column, int(19), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_class) + tmp6 := lang.Apply(tmp5, []any{v3}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3667), kw_column, int(21), kw_end_DASH_line, int(3667), kw_end_DASH_column, int(45))).(lang.FnFunc) + tmp1 := lang.NewMultiFn("print-dup", tmp2, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + }) + tmp1.AddMethod(nil, tmp3) + tmp4 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp9 := lang.Apply(tmp8, []any{v6, v7}) + return tmp9 + }) + tmp1.AddMethod(tmp4, tmp5) + tmp6 := reflect.TypeOf((*lang.IPersistentList)(nil)).Elem() + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp11 := lang.Apply(tmp10, []any{v8, v9}) + return tmp11 + }) + tmp1.AddMethod(tmp6, tmp7) + tmp8 := reflect.TypeOf((*lang.Symbol)(nil)) + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp13 := lang.Apply(tmp12, []any{v10, v11}) + return tmp13 + }) + tmp1.AddMethod(tmp8, tmp9) + tmp10 := reflect.TypeOf((*lang.IRecord)(nil)).Elem() + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v12 := args[0] + _ = v12 + v13 := args[1] + _ = v13 + tmp14 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) + tmp15 := lang.Apply(tmp14, []any{v12, v13}) + _ = tmp15 + tmp16 := lang.Apply(lang.WriteWriter, []any{v13, "#"}) + _ = tmp16 + tmp17 := checkDerefVar(var_glojure_DOT_core_class) + tmp18 := lang.Apply(tmp17, []any{v12}) + tmp19, ok := lang.FieldOrMethod(tmp18, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp18, "Name"))) + } + var tmp20 any + switch reflect.TypeOf(tmp19).Kind() { + case reflect.Func: + tmp20 = lang.Apply(tmp19, nil) + default: + tmp20 = tmp19 + } + tmp21 := lang.Apply(lang.WriteWriter, []any{v13, tmp20}) + _ = tmp21 + var tmp22 any + tmp23 := checkDerefVar(var_glojure_DOT_core__STAR_verbose_DASH_defrecords_STAR_) + if lang.IsTruthy(tmp23) { + tmp24 := checkDerefVar(var_glojure_DOT_core_print_DASH_map) + tmp25 := checkDerefVar(var_glojure_DOT_core_print_DASH_dup) + tmp26 := lang.Apply(tmp24, []any{v12, tmp25, v13}) + tmp22 = tmp26 + } else { + tmp27 := checkDerefVar(var_glojure_DOT_core_print_DASH_sequential) + tmp28 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) + tmp29 := checkDerefVar(var_glojure_DOT_core_vals) + tmp30 := lang.Apply(tmp29, []any{v12}) + tmp31 := lang.Apply(tmp27, []any{"[", tmp28, ", ", "]", tmp30, v13}) + tmp22 = tmp31 + } + return tmp22 + }) + tmp1.AddMethod(tmp10, tmp11) + tmp12 := reflect.TypeOf((*lang.Set)(nil)) + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v14 := args[0] + _ = v14 + v15 := args[1] + _ = v15 + tmp16 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp17 := lang.Apply(tmp16, []any{v14, v15}) + return tmp17 + }) + tmp1.AddMethod(tmp12, tmp13) + tmp14 := reflect.TypeOf((*lang.PersistentHashMap)(nil)) + var tmp15 lang.FnFunc + tmp15 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v16 := args[0] + _ = v16 + v17 := args[1] + _ = v17 + tmp18 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp19 := lang.Apply(tmp18, []any{v16, v17}) + return tmp19 + }) + tmp1.AddMethod(tmp14, tmp15) + tmp16 := reflect.TypeOf(int64(0)) + var tmp17 lang.FnFunc + tmp17 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v18 := args[0] + _ = v18 + v19 := args[1] + _ = v19 + tmp20 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp21 := lang.Apply(tmp20, []any{v18, v19}) + return tmp21 + }) + tmp1.AddMethod(tmp16, tmp17) + tmp18 := reflect.TypeOf((*lang.Vector)(nil)) + var tmp19 lang.FnFunc + tmp19 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v20 := args[0] + _ = v20 + v21 := args[1] + _ = v21 + tmp22 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp23 := lang.Apply(tmp22, []any{v20, v21}) + return tmp23 + }) + tmp1.AddMethod(tmp18, tmp19) + tmp20 := reflect.TypeOf(float64(0)) + var tmp21 lang.FnFunc + tmp21 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v22 := args[0] + _ = v22 + v23 := args[1] + _ = v23 + tmp24 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp25 := lang.Apply(tmp24, []any{v22, v23}) + return tmp25 + }) + tmp1.AddMethod(tmp20, tmp21) + tmp22 := reflect.TypeOf("") + var tmp23 lang.FnFunc + tmp23 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v24 := args[0] + _ = v24 + v25 := args[1] + _ = v25 + tmp26 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp27 := lang.Apply(tmp26, []any{v24, v25}) + return tmp27 + }) + tmp1.AddMethod(tmp22, tmp23) + tmp24 := reflect.TypeOf((*lang.IPersistentCollection)(nil)).Elem() + var tmp25 lang.FnFunc + tmp25 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v26 := args[0] + _ = v26 + v27 := args[1] + _ = v27 + tmp28 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) + tmp29 := lang.Apply(tmp28, []any{v26, v27}) + _ = tmp29 + tmp30 := lang.Apply(lang.WriteWriter, []any{v27, "#=("}) + _ = tmp30 + tmp31 := checkDerefVar(var_glojure_DOT_core_class) + tmp32 := lang.Apply(tmp31, []any{v26}) + tmp33, ok := lang.FieldOrMethod(tmp32, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp32, "Name"))) + } + var tmp34 any + switch reflect.TypeOf(tmp33).Kind() { + case reflect.Func: + tmp34 = lang.Apply(tmp33, nil) + default: + tmp34 = tmp33 + } + tmp35 := lang.Apply(lang.WriteWriter, []any{v27, tmp34}) + _ = tmp35 + tmp36 := lang.Apply(lang.WriteWriter, []any{v27, "/create "}) + _ = tmp36 + tmp37 := checkDerefVar(var_glojure_DOT_core_print_DASH_sequential) + tmp38 := checkDerefVar(var_glojure_DOT_core_print_DASH_dup) + tmp39 := lang.Apply(tmp37, []any{"[", tmp38, " ", "]", v26, v27}) + _ = tmp39 + tmp40 := lang.Apply(lang.WriteWriter, []any{v27, ")"}) + return tmp40 + }) + tmp1.AddMethod(tmp24, tmp25) + tmp26 := reflect.TypeOf(int32(0)) + var tmp27 lang.FnFunc + tmp27 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v28 := args[0] + _ = v28 + v29 := args[1] + _ = v29 + tmp30 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp31 := lang.Apply(tmp30, []any{v28, v29}) + return tmp31 + }) + tmp1.AddMethod(tmp26, tmp27) + tmp28 := reflect.TypeOf((*lang.IPersistentMap)(nil)).Elem() + var tmp29 lang.FnFunc + tmp29 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v30 := args[0] + _ = v30 + v31 := args[1] + _ = v31 + tmp32 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) + tmp33 := lang.Apply(tmp32, []any{v30, v31}) + _ = tmp33 + tmp34 := lang.Apply(lang.WriteWriter, []any{v31, "#=("}) + _ = tmp34 + tmp35 := checkDerefVar(var_glojure_DOT_core_class) + tmp36 := lang.Apply(tmp35, []any{v30}) + tmp37, ok := lang.FieldOrMethod(tmp36, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp36, "Name"))) + } + var tmp38 any + switch reflect.TypeOf(tmp37).Kind() { + case reflect.Func: + tmp38 = lang.Apply(tmp37, nil) + default: + tmp38 = tmp37 + } + tmp39 := lang.Apply(lang.WriteWriter, []any{v31, tmp38}) + _ = tmp39 + tmp40 := lang.Apply(lang.WriteWriter, []any{v31, "/create "}) + _ = tmp40 + tmp41 := checkDerefVar(var_glojure_DOT_core_print_DASH_map) + tmp42 := checkDerefVar(var_glojure_DOT_core_print_DASH_dup) + tmp43 := lang.Apply(tmp41, []any{v30, tmp42, v31}) + _ = tmp43 + tmp44 := lang.Apply(lang.WriteWriter, []any{v31, ")"}) + return tmp44 + }) + tmp1.AddMethod(tmp28, tmp29) + tmp30 := reflect.TypeOf((*lang.Namespace)(nil)) + var tmp31 lang.FnFunc + tmp31 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v32 := args[0] + _ = v32 + v33 := args[1] + _ = v33 + tmp34 := lang.Apply(lang.WriteWriter, []any{v33, "#=(find-ns "}) + _ = tmp34 + tmp35 := checkDerefVar(var_glojure_DOT_core_print_DASH_dup) + tmp36, ok := lang.FieldOrMethod(v32, "name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v32, "name"))) + } + var tmp37 any + switch reflect.TypeOf(tmp36).Kind() { + case reflect.Func: + tmp37 = lang.Apply(tmp36, nil) + default: + tmp37 = tmp36 + } + tmp38 := lang.Apply(tmp35, []any{tmp37, v33}) + _ = tmp38 + tmp39 := lang.Apply(lang.WriteWriter, []any{v33, ")"}) + return tmp39 + }) + tmp1.AddMethod(tmp30, tmp31) + tmp32 := reflect.TypeOf(false) + var tmp33 lang.FnFunc + tmp33 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v34 := args[0] + _ = v34 + v35 := args[1] + _ = v35 + tmp36 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp37 := lang.Apply(tmp36, []any{v34, v35}) + return tmp37 + }) + tmp1.AddMethod(tmp32, tmp33) + tmp34 := reflect.TypeOf((*regexp12.Regexp)(nil)) + var tmp35 lang.FnFunc + tmp35 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v36 := args[0] + _ = v36 + v37 := args[1] + _ = v37 + tmp38 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp39 := lang.Apply(tmp38, []any{v36, v37}) + return tmp39 + }) + tmp1.AddMethod(tmp34, tmp35) + tmp36 := reflect.TypeOf((*lang.Ratio)(nil)) + var tmp37 lang.FnFunc + tmp37 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v38 := args[0] + _ = v38 + v39 := args[1] + _ = v39 + tmp40 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp41 := lang.Apply(tmp40, []any{v38, v39}) + return tmp41 + }) + tmp1.AddMethod(tmp36, tmp37) + tmp38 := reflect.TypeOf((*lang.Var)(nil)) + var tmp39 lang.FnFunc + tmp39 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v40 := args[0] + _ = v40 + v41 := args[1] + _ = v41 + tmp42 := checkDerefVar(var_glojure_DOT_core_str) + tmp43, ok := lang.FieldOrMethod(v40, "Namespace") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v40, "Namespace"))) + } + var tmp44 any + switch reflect.TypeOf(tmp43).Kind() { + case reflect.Func: + tmp44 = lang.Apply(tmp43, nil) + default: + tmp44 = tmp43 + } + tmp45, ok := lang.FieldOrMethod(tmp44, "name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp44, "name"))) + } + var tmp46 any + switch reflect.TypeOf(tmp45).Kind() { + case reflect.Func: + tmp46 = lang.Apply(tmp45, nil) + default: + tmp46 = tmp45 + } + tmp47, ok := lang.FieldOrMethod(v40, "sym") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v40, "sym"))) + } + var tmp48 any + switch reflect.TypeOf(tmp47).Kind() { + case reflect.Func: + tmp48 = lang.Apply(tmp47, nil) + default: + tmp48 = tmp47 + } + tmp49 := lang.Apply(tmp42, []any{"#=(var ", tmp46, "/", tmp48, ")"}) + tmp50 := lang.Apply(lang.WriteWriter, []any{v41, tmp49}) + return tmp50 + }) + tmp1.AddMethod(tmp38, tmp39) + tmp40 := reflect.TypeOf((*lang.BigDecimal)(nil)) + var tmp41 lang.FnFunc + tmp41 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v42 := args[0] + _ = v42 + v43 := args[1] + _ = v43 + tmp44 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp45 := lang.Apply(tmp44, []any{v42, v43}) + return tmp45 + }) + tmp1.AddMethod(tmp40, tmp41) + tmp42 := reflect.TypeOf((*lang.BigInt)(nil)) + var tmp43 lang.FnFunc + tmp43 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v44 := args[0] + _ = v44 + v45 := args[1] + _ = v45 + tmp46 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp47 := lang.Apply(tmp46, []any{v44, v45}) + return tmp47 + }) + tmp1.AddMethod(tmp42, tmp43) + tmp44 := reflect.TypeOf((*runtime.Fn)(nil)) + var tmp45 lang.FnFunc + tmp45 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v46 := args[0] + _ = v46 + v47 := args[1] + _ = v47 + tmp48 := checkDerefVar(var_glojure_DOT_core_print_DASH_ctor) + var tmp49 lang.FnFunc + tmp49 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v50 := args[0] + _ = v50 + v51 := args[1] + _ = v51 + return nil + }) + tmp50 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(167), kw_column, int(17), kw_end_DASH_line, int(167), kw_end_DASH_column, int(26)) + tmp51, err := lang.WithMeta(tmp49, tmp50.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp52 := lang.Apply(tmp48, []any{v46, tmp51, v47}) + return tmp52 + }) + tmp1.AddMethod(tmp44, tmp45) + tmp46 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() + var tmp47 lang.FnFunc + tmp47 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v48 := args[0] + _ = v48 + v49 := args[1] + _ = v49 + tmp50 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp51 := lang.Apply(tmp50, []any{v48, v49}) + return tmp51 + }) + tmp1.AddMethod(tmp46, tmp47) + tmp48 := reflect.TypeOf((*lang.IPersistentCollection)(nil)).Elem() + tmp49 := reflect.TypeOf((*runtime.Fn)(nil)) + tmp1.PreferMethod(tmp48, tmp49) + tmp50 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() + tmp51 := reflect.TypeOf((*lang.IPersistentCollection)(nil)).Elem() + tmp1.PreferMethod(tmp50, tmp51) + tmp52 := reflect.TypeOf((*lang.IRecord)(nil)).Elem() + tmp53 := reflect.TypeOf((*lang.IPersistentMap)(nil)).Elem() + tmp1.PreferMethod(tmp52, tmp53) + tmp54 := reflect.TypeOf((*lang.IRecord)(nil)).Elem() + tmp55 := reflect.TypeOf((*lang.IPersistentCollection)(nil)).Elem() + tmp1.PreferMethod(tmp54, tmp55) + var_glojure_DOT_core_print_DASH_dup = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_print_DASH_dup.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print-method + { + tmp0 := sym_print_DASH_method.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3664), kw_column, int(11), kw_end_DASH_line, int(3664), kw_end_DASH_column, int(22), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 any + { // let + // let binding "t" + tmp6 := checkDerefVar(var_glojure_DOT_core_get) + tmp7 := checkDerefVar(var_glojure_DOT_core_meta) + tmp8 := lang.Apply(tmp7, []any{v3}) + tmp9 := lang.Apply(tmp6, []any{tmp8, kw_type}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp13 := lang.Apply(tmp12, []any{v10}) + if lang.IsTruthy(tmp13) { + tmp11 = v10 + } else { + tmp14 := checkDerefVar(var_glojure_DOT_core_class) + tmp15 := lang.Apply(tmp14, []any{v3}) + tmp11 = tmp15 + } + tmp5 = tmp11 + } // end let + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3664), kw_column, int(24), kw_end_DASH_line, int(3666), kw_end_DASH_column, int(58))).(lang.FnFunc) + tmp1 := lang.NewMultiFn("print-method", tmp2, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6 := lang.Apply(lang.WriteWriter, []any{v5, "nil"}) + return tmp6 + }) + tmp1.AddMethod(nil, tmp3) + tmp4 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_str) + tmp9 := lang.Apply(tmp8, []any{v6}) + tmp10 := lang.Apply(lang.WriteWriter, []any{v7, tmp9}) + return tmp10 + }) + tmp1.AddMethod(tmp4, tmp5) + tmp6 := reflect.TypeOf(uint32(0)) + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_str) + tmp11 := lang.Apply(tmp10, []any{v8}) + tmp12, _ := lang.FieldOrMethod(v9, "write") + if reflect.TypeOf(tmp12).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + } + tmp13 := lang.Apply(tmp12, []any{tmp11}) + return tmp13 + }) + tmp1.AddMethod(tmp6, tmp7) + tmp8 := reflect.TypeOf((*lang.Symbol)(nil)) + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_print_DASH_simple) + tmp13 := lang.Apply(tmp12, []any{v10, v11}) + return tmp13 + }) + tmp1.AddMethod(tmp8, tmp9) + tmp10 := reflect.TypeOf((*lang.IRecord)(nil)).Elem() + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v12 := args[0] + _ = v12 + v13 := args[1] + _ = v13 + tmp14 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) + tmp15 := lang.Apply(tmp14, []any{v12, v13}) + _ = tmp15 + tmp16 := lang.Apply(lang.WriteWriter, []any{v13, "#"}) + _ = tmp16 + tmp17 := checkDerefVar(var_glojure_DOT_core_class) + tmp18 := lang.Apply(tmp17, []any{v12}) + tmp19, ok := lang.FieldOrMethod(tmp18, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp18, "Name"))) + } + var tmp20 any + switch reflect.TypeOf(tmp19).Kind() { + case reflect.Func: + tmp20 = lang.Apply(tmp19, nil) + default: + tmp20 = tmp19 + } + tmp21 := lang.Apply(lang.WriteWriter, []any{v13, tmp20}) + _ = tmp21 + tmp22 := checkDerefVar(var_glojure_DOT_core_print_DASH_map) + tmp23 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) + tmp24 := lang.Apply(tmp22, []any{v12, tmp23, v13}) + return tmp24 + }) + tmp1.AddMethod(tmp10, tmp11) + tmp12 := reflect.TypeOf(uint(0)) + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v14 := args[0] + _ = v14 + v15 := args[1] + _ = v15 + tmp16 := checkDerefVar(var_glojure_DOT_core_str) + tmp17 := lang.Apply(tmp16, []any{v14}) + tmp18, _ := lang.FieldOrMethod(v15, "write") + if reflect.TypeOf(tmp18).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + } + tmp19 := lang.Apply(tmp18, []any{tmp17}) + return tmp19 + }) + tmp1.AddMethod(tmp12, tmp13) + tmp14 := reflect.TypeOf(int64(0)) + var tmp15 lang.FnFunc + tmp15 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v16 := args[0] + _ = v16 + v17 := args[1] + _ = v17 + tmp18 := checkDerefVar(var_glojure_DOT_core_str) + tmp19 := lang.Apply(tmp18, []any{v16}) + tmp20, _ := lang.FieldOrMethod(v17, "write") + if reflect.TypeOf(tmp20).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + } + tmp21 := lang.Apply(tmp20, []any{tmp19}) + return tmp21 + }) + tmp1.AddMethod(tmp14, tmp15) + var tmp16 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v17 := args[0] + _ = v17 + v18 := args[1] + _ = v18 + var tmp19 any + tmp20 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp21 := reflect.TypeOf((*lang.IObj)(nil)).Elem() + tmp22 := lang.Apply(tmp20, []any{tmp21, v17}) + if lang.IsTruthy(tmp22) { + tmp23 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp24 := checkDerefVar(var_glojure_DOT_core_vary_DASH_meta) + var tmp25 lang.FnFunc + tmp25 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v26 := args[0] + _ = v26 + tmp27 := checkDerefVar(var_glojure_DOT_core_dissoc) + tmp28 := lang.Apply(tmp27, []any{v26, kw_type}) + return tmp28 + }) + tmp26 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(87), kw_column, int(32), kw_end_DASH_line, int(87), kw_end_DASH_column, int(48)) + tmp27, err := lang.WithMeta(tmp25, tmp26.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp28 := lang.Apply(tmp24, []any{v17, tmp27}) + tmp29 := lang.Apply(tmp23, []any{tmp28, v18}) + tmp19 = tmp29 + } else { + tmp30 := checkDerefVar(var_glojure_DOT_core_print_DASH_simple) + tmp31 := lang.Apply(tmp30, []any{v17, v18}) + tmp19 = tmp31 + } + return tmp19 + }) + tmp1.AddMethod(kw_default, tmp16) + tmp17 := reflect.TypeOf(float64(0)) + var tmp18 lang.FnFunc + tmp18 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v19 := args[0] + _ = v19 + v20 := args[1] + _ = v20 + var tmp21 any + tmp22 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp23 := lang.Apply(math4.Inf, []any{int64(1)}) + tmp24 := lang.Apply(tmp22, []any{tmp23, v19}) + if lang.IsTruthy(tmp24) { + tmp25 := lang.Apply(lang.WriteWriter, []any{v20, "##Inf"}) + tmp21 = tmp25 + } else { + var tmp26 any + tmp27 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp28 := lang.Apply(math4.Inf, []any{int64(-1)}) + tmp29 := lang.Apply(tmp27, []any{tmp28, v19}) + if lang.IsTruthy(tmp29) { + tmp30 := lang.Apply(lang.WriteWriter, []any{v20, "##-Inf"}) + tmp26 = tmp30 + } else { + var tmp31 any + tmp32 := lang.Apply(math4.IsNaN, []any{v19}) + if lang.IsTruthy(tmp32) { + tmp33 := lang.Apply(lang.WriteWriter, []any{v20, "##NaN"}) + tmp31 = tmp33 + } else { + var tmp34 any + if lang.IsTruthy(kw_else) { + tmp35 := checkDerefVar(var_glojure_DOT_core_str) + tmp36 := lang.Apply(tmp35, []any{v19}) + tmp37 := lang.Apply(lang.WriteWriter, []any{v20, tmp36}) + tmp34 = tmp37 + } else { + } + tmp31 = tmp34 + } + tmp26 = tmp31 + } + tmp21 = tmp26 + } + return tmp21 + }) + tmp1.AddMethod(tmp17, tmp18) + tmp19 := reflect.TypeOf("") + var tmp20 lang.FnFunc + tmp20 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v21 := args[0] + _ = v21 + v22 := args[1] + _ = v22 + var tmp23 any + var tmp24 any + { // let + // let binding "or__0__auto__" + tmp25 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_dup_STAR_) + var v26 any = tmp25 + _ = v26 + var tmp27 any + if lang.IsTruthy(v26) { + tmp27 = v26 + } else { + tmp28 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_readably_STAR_) + tmp27 = tmp28 + } + tmp24 = tmp27 + } // end let + if lang.IsTruthy(tmp24) { + tmp25 := lang.Apply(lang.AppendWriter, []any{v22, lang.NewChar(34)}) + _ = tmp25 + var tmp26 any + { // let + // let binding "n__0__auto__" + tmp27 := checkDerefVar(var_glojure_DOT_core_long) + tmp28 := checkDerefVar(var_glojure_DOT_core_count) + tmp29 := lang.Apply(tmp28, []any{v21}) + tmp30 := lang.Apply(tmp27, []any{tmp29}) + var v31 any = tmp30 + _ = v31 + var tmp32 any + { // let + // let binding "n" + var v33 any = int64(0) + _ = v33 + for { + var tmp34 any + tmp35 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp36 := lang.Apply(tmp35, []any{v33, v31}) + if lang.IsTruthy(tmp36) { + var tmp37 any + { // let + // let binding "c" + tmp38 := lang.Apply(lang.CharAt, []any{v21, v33}) + var v39 any = tmp38 + _ = v39 + // let binding "e" + tmp40 := checkDerefVar(var_glojure_DOT_core_char_DASH_escape_DASH_string) + tmp41 := lang.Apply(tmp40, []any{v39}) + var v42 any = tmp41 + _ = v42 + var tmp43 any + if lang.IsTruthy(v42) { + tmp44 := lang.Apply(lang.WriteWriter, []any{v22, v42}) + tmp43 = tmp44 + } else { + tmp45 := lang.Apply(lang.AppendWriter, []any{v22, v39}) + tmp43 = tmp45 + } + tmp37 = tmp43 + } // end let + _ = tmp37 + tmp39 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp40 := lang.Apply(tmp39, []any{v33}) + var tmp38 any = tmp40 + v33 = tmp38 + continue + } else { + } + tmp32 = tmp34 + break + } + } // end let + tmp26 = tmp32 + } // end let + _ = tmp26 + tmp27 := lang.Apply(lang.AppendWriter, []any{v22, lang.NewChar(34)}) + tmp23 = tmp27 + } else { + tmp28 := lang.Apply(lang.WriteWriter, []any{v22, v21}) + tmp23 = tmp28 + } + _ = tmp23 + return nil + }) + tmp1.AddMethod(tmp19, tmp20) + tmp21 := reflect.TypeOf(int32(0)) + var tmp22 lang.FnFunc + tmp22 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v23 := args[0] + _ = v23 + v24 := args[1] + _ = v24 + var tmp25 any + var tmp26 any + { // let + // let binding "or__0__auto__" + tmp27 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_dup_STAR_) + var v28 any = tmp27 + _ = v28 + var tmp29 any + if lang.IsTruthy(v28) { + tmp29 = v28 + } else { + tmp30 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_readably_STAR_) + tmp29 = tmp30 + } + tmp26 = tmp29 + } // end let + if lang.IsTruthy(tmp26) { + tmp27 := lang.Apply(lang.AppendWriter, []any{v24, lang.NewChar(92)}) + _ = tmp27 + var tmp28 any + { // let + // let binding "n" + tmp29 := checkDerefVar(var_glojure_DOT_core_char_DASH_name_DASH_string) + tmp30 := lang.Apply(tmp29, []any{v23}) + var v31 any = tmp30 + _ = v31 + var tmp32 any + if lang.IsTruthy(v31) { + tmp33 := lang.Apply(lang.WriteWriter, []any{v24, v31}) + tmp32 = tmp33 + } else { + tmp34 := lang.Apply(lang.AppendWriter, []any{v24, v23}) + tmp32 = tmp34 + } + tmp28 = tmp32 + } // end let + tmp25 = tmp28 + } else { + tmp29 := lang.Apply(lang.AppendWriter, []any{v24, v23}) + tmp25 = tmp29 + } + _ = tmp25 + return nil + }) + tmp1.AddMethod(tmp21, tmp22) + tmp23 := reflect.TypeOf((*lang.IPersistentMap)(nil)).Elem() + var tmp24 lang.FnFunc + tmp24 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v25 := args[0] + _ = v25 + v26 := args[1] + _ = v26 + tmp27 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) + tmp28 := lang.Apply(tmp27, []any{v25, v26}) + _ = tmp28 + var tmp29 any + { // let + // let binding "vec__925" + tmp30 := checkDerefVar(var_glojure_DOT_core_lift_DASH_ns) + tmp31 := lang.Apply(tmp30, []any{v25}) + var v32 any = tmp31 + _ = v32 + // let binding "ns" + tmp33 := checkDerefVar(var_glojure_DOT_core_nth) + tmp34 := lang.Apply(tmp33, []any{v32, int64(0), nil}) + var v35 any = tmp34 + _ = v35 + // let binding "lift-kvs" + tmp36 := checkDerefVar(var_glojure_DOT_core_nth) + tmp37 := lang.Apply(tmp36, []any{v32, int64(1), nil}) + var v38 any = tmp37 + _ = v38 + var tmp39 any + if lang.IsTruthy(v35) { + tmp40 := checkDerefVar(var_glojure_DOT_core_print_DASH_prefix_DASH_map) + tmp41 := checkDerefVar(var_glojure_DOT_core_str) + tmp42 := lang.Apply(tmp41, []any{"#:", v35}) + tmp43 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) + tmp44 := lang.Apply(tmp40, []any{tmp42, v38, tmp43, v26}) + tmp39 = tmp44 + } else { + tmp45 := checkDerefVar(var_glojure_DOT_core_print_DASH_map) + tmp46 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) + tmp47 := lang.Apply(tmp45, []any{v25, tmp46, v26}) + tmp39 = tmp47 + } + tmp29 = tmp39 + } // end let + return tmp29 + }) + tmp1.AddMethod(tmp23, tmp24) + tmp25 := reflect.TypeOf((*lang.IPersistentVector)(nil)).Elem() + var tmp26 lang.FnFunc + tmp26 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v27 := args[0] + _ = v27 + v28 := args[1] + _ = v28 + tmp29 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) + tmp30 := lang.Apply(tmp29, []any{v27, v28}) + _ = tmp30 + tmp31 := checkDerefVar(var_glojure_DOT_core_print_DASH_sequential) + tmp32 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) + tmp33 := lang.Apply(tmp31, []any{"[", tmp32, " ", "]", v27, v28}) + return tmp33 + }) + tmp1.AddMethod(tmp25, tmp26) + tmp27 := reflect.TypeOf((*lang.IPersistentSet)(nil)).Elem() + var tmp28 lang.FnFunc + tmp28 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v29 := args[0] + _ = v29 + v30 := args[1] + _ = v30 + tmp31 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) + tmp32 := lang.Apply(tmp31, []any{v29, v30}) + _ = tmp32 + tmp33 := checkDerefVar(var_glojure_DOT_core_print_DASH_sequential) + tmp34 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) + tmp35 := checkDerefVar(var_glojure_DOT_core_seq) + tmp36 := lang.Apply(tmp35, []any{v29}) + tmp37 := lang.Apply(tmp33, []any{"#{", tmp34, " ", "}", tmp36, v30}) + return tmp37 + }) + tmp1.AddMethod(tmp27, tmp28) + tmp29 := reflect.TypeOf(uint8(0)) + var tmp30 lang.FnFunc + tmp30 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v31 := args[0] + _ = v31 + v32 := args[1] + _ = v32 + tmp33 := checkDerefVar(var_glojure_DOT_core_str) + tmp34 := lang.Apply(tmp33, []any{v31}) + tmp35, _ := lang.FieldOrMethod(v32, "write") + if reflect.TypeOf(tmp35).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + } + tmp36 := lang.Apply(tmp35, []any{tmp34}) + return tmp36 + }) + tmp1.AddMethod(tmp29, tmp30) + tmp31 := reflect.TypeOf((*lang.IDeref)(nil)).Elem() + var tmp32 lang.FnFunc + tmp32 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v33 := args[0] + _ = v33 + v34 := args[1] + _ = v34 + tmp35 := checkDerefVar(var_glojure_DOT_core_print_DASH_tagged_DASH_object) + tmp36 := checkDerefVar(var_glojure_DOT_core_deref_DASH_as_DASH_map) + tmp37 := lang.Apply(tmp36, []any{v33}) + tmp38 := lang.Apply(tmp35, []any{v33, tmp37, v34}) + return tmp38 + }) + tmp1.AddMethod(tmp31, tmp32) + tmp33 := reflect.TypeOf(false) + var tmp34 lang.FnFunc + tmp34 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v35 := args[0] + _ = v35 + v36 := args[1] + _ = v36 + tmp37 := checkDerefVar(var_glojure_DOT_core_str) + tmp38 := lang.Apply(tmp37, []any{v35}) + tmp39 := lang.Apply(lang.WriteWriter, []any{v36, tmp38}) + return tmp39 + }) + tmp1.AddMethod(tmp33, tmp34) + tmp35 := reflect.TypeOf((*lang.Object)(nil)).Elem() + var tmp36 lang.FnFunc + tmp36 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v37 := args[0] + _ = v37 + v38 := args[1] + _ = v38 + tmp39 := checkDerefVar(var_glojure_DOT_core_print_DASH_object) + tmp40 := lang.Apply(tmp39, []any{v37, v38}) + return tmp40 + }) + tmp1.AddMethod(tmp35, tmp36) + tmp37 := reflect.TypeOf(int(0)) + var tmp38 lang.FnFunc + tmp38 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v39 := args[0] + _ = v39 + v40 := args[1] + _ = v40 + tmp41 := checkDerefVar(var_glojure_DOT_core_str) + tmp42 := lang.Apply(tmp41, []any{v39}) + tmp43, _ := lang.FieldOrMethod(v40, "write") + if reflect.TypeOf(tmp43).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + } + tmp44 := lang.Apply(tmp43, []any{tmp42}) + return tmp44 + }) + tmp1.AddMethod(tmp37, tmp38) + tmp39 := reflect.TypeOf((*regexp12.Regexp)(nil)) + var tmp40 lang.FnFunc + tmp40 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v41 := args[0] + _ = v41 + v42 := args[1] + _ = v42 + tmp43 := lang.Apply(lang.WriteWriter, []any{v42, "#\""}) + _ = tmp43 + var tmp44 any + { // let + // let binding "G__931" + tmp45 := checkDerefVar(var_glojure_DOT_core_seq) + tmp46, ok := lang.FieldOrMethod(v41, "String") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v41, "String"))) + } + var tmp47 any + switch reflect.TypeOf(tmp46).Kind() { + case reflect.Func: + tmp47 = lang.Apply(tmp46, nil) + default: + tmp47 = tmp46 + } + tmp48 := lang.Apply(tmp45, []any{tmp47}) + var v49 any = tmp48 + _ = v49 + // let binding "vec__932" + var v50 any = v49 + _ = v50 + // let binding "seq__933" + tmp51 := checkDerefVar(var_glojure_DOT_core_seq) + tmp52 := lang.Apply(tmp51, []any{v50}) + var v53 any = tmp52 + _ = v53 + // let binding "first__934" + tmp54 := checkDerefVar(var_glojure_DOT_core_first) + tmp55 := lang.Apply(tmp54, []any{v53}) + var v56 any = tmp55 + _ = v56 + // let binding "seq__933" + tmp57 := checkDerefVar(var_glojure_DOT_core_next) + tmp58 := lang.Apply(tmp57, []any{v53}) + var v59 any = tmp58 + _ = v59 + // let binding "c" + var v60 any = v56 + _ = v60 + // let binding "r" + var v61 any = v59 + _ = v61 + // let binding "s" + var v62 any = v50 + _ = v62 + // let binding "qmode" + var v63 any = false + _ = v63 + var tmp64 any + { // let + // let binding "G__931" + var v65 any = v49 + _ = v65 + // let binding "qmode" + var v66 any = v63 + _ = v66 + for { + var tmp67 any + { // let + // let binding "vec__935" + var v68 any = v65 + _ = v68 + // let binding "seq__936" + tmp69 := checkDerefVar(var_glojure_DOT_core_seq) + tmp70 := lang.Apply(tmp69, []any{v68}) + var v71 any = tmp70 + _ = v71 + // let binding "first__937" + tmp72 := checkDerefVar(var_glojure_DOT_core_first) + tmp73 := lang.Apply(tmp72, []any{v71}) + var v74 any = tmp73 + _ = v74 + // let binding "seq__936" + tmp75 := checkDerefVar(var_glojure_DOT_core_next) + tmp76 := lang.Apply(tmp75, []any{v71}) + var v77 any = tmp76 + _ = v77 + // let binding "c" + var v78 any = v74 + _ = v78 + // let binding "r" + var v79 any = v77 + _ = v79 + // let binding "s" + var v80 any = v68 + _ = v80 + // let binding "qmode" + var v81 any = v66 + _ = v81 + var tmp82 any + if lang.IsTruthy(v80) { + var tmp83 any + tmp84 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp85 := lang.Apply(tmp84, []any{v78, lang.NewChar(92)}) + if lang.IsTruthy(tmp85) { + var tmp86 any + { // let + // let binding "vec__938" + var v87 any = v79 + _ = v87 + // let binding "seq__939" + tmp88 := checkDerefVar(var_glojure_DOT_core_seq) + tmp89 := lang.Apply(tmp88, []any{v87}) + var v90 any = tmp89 + _ = v90 + // let binding "first__940" + tmp91 := checkDerefVar(var_glojure_DOT_core_first) + tmp92 := lang.Apply(tmp91, []any{v90}) + var v93 any = tmp92 + _ = v93 + // let binding "seq__939" + tmp94 := checkDerefVar(var_glojure_DOT_core_next) + tmp95 := lang.Apply(tmp94, []any{v90}) + var v96 any = tmp95 + _ = v96 + // let binding "c2" + var v97 any = v93 + _ = v97 + // let binding "r2" + var v98 any = v96 + _ = v98 + tmp99 := lang.Apply(lang.AppendWriter, []any{v42, lang.NewChar(92)}) + _ = tmp99 + tmp100 := lang.Apply(lang.AppendWriter, []any{v42, v97}) + _ = tmp100 + var tmp101 any + if lang.IsTruthy(v81) { + var tmp102 any = v98 + tmp104 := checkDerefVar(var_glojure_DOT_core_not_EQ_) + tmp105 := lang.Apply(tmp104, []any{v97, lang.NewChar(69)}) + var tmp103 any = tmp105 + v65 = tmp102 + v66 = tmp103 + continue + } else { + var tmp106 any = v98 + tmp108 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp109 := lang.Apply(tmp108, []any{v97, lang.NewChar(81)}) + var tmp107 any = tmp109 + v65 = tmp106 + v66 = tmp107 + continue + } + tmp86 = tmp101 + } // end let + tmp83 = tmp86 + } else { + var tmp87 any + tmp88 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp89 := lang.Apply(tmp88, []any{v78, lang.NewChar(34)}) + if lang.IsTruthy(tmp89) { + var tmp90 any + if lang.IsTruthy(v81) { + tmp91 := lang.Apply(lang.WriteWriter, []any{v42, "\\E\\\"\\Q"}) + tmp90 = tmp91 + } else { + tmp92 := lang.Apply(lang.WriteWriter, []any{v42, "\\\""}) + tmp90 = tmp92 + } + _ = tmp90 + var tmp93 any = v79 + var tmp94 any = v81 + v65 = tmp93 + v66 = tmp94 + continue + } else { + var tmp95 any + if lang.IsTruthy(kw_else) { + tmp96 := lang.Apply(lang.AppendWriter, []any{v42, v78}) + _ = tmp96 + var tmp97 any = v79 + var tmp98 any = v81 + v65 = tmp97 + v66 = tmp98 + continue + } else { + } + tmp87 = tmp95 + } + tmp83 = tmp87 + } + tmp82 = tmp83 + } else { + } + tmp67 = tmp82 + } // end let + tmp64 = tmp67 + break + } + } // end let + tmp44 = tmp64 + } // end let + _ = tmp44 + tmp45 := lang.Apply(lang.AppendWriter, []any{v42, lang.NewChar(34)}) + return tmp45 + }) + tmp1.AddMethod(tmp39, tmp40) + tmp41 := reflect.TypeOf(int32(0)) + var tmp42 lang.FnFunc + tmp42 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v43 := args[0] + _ = v43 + v44 := args[1] + _ = v44 + tmp45 := checkDerefVar(var_glojure_DOT_core_str) + tmp46 := lang.Apply(tmp45, []any{v43}) + tmp47, _ := lang.FieldOrMethod(v44, "write") + if reflect.TypeOf(tmp47).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + } + tmp48 := lang.Apply(tmp47, []any{tmp46}) + return tmp48 + }) + tmp1.AddMethod(tmp41, tmp42) + tmp43 := reflect.TypeOf((*lang.Ratio)(nil)) + var tmp44 lang.FnFunc + tmp44 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v45 := args[0] + _ = v45 + v46 := args[1] + _ = v46 + tmp47 := checkDerefVar(var_glojure_DOT_core_str) + tmp48 := lang.Apply(tmp47, []any{v45}) + tmp49, _ := lang.FieldOrMethod(v46, "write") + if reflect.TypeOf(tmp49).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + } + tmp50 := lang.Apply(tmp49, []any{tmp48}) + return tmp50 + }) + tmp1.AddMethod(tmp43, tmp44) + tmp45 := reflect.TypeOf(float32(0)) + var tmp46 lang.FnFunc + tmp46 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v47 := args[0] + _ = v47 + v48 := args[1] + _ = v48 + var tmp49 any + tmp50 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp51 := lang.Apply(math4.Inf, []any{int64(1)}) + tmp52 := lang.Apply(lang.Builtins["float32"], []any{tmp51}) + tmp53 := lang.Apply(tmp50, []any{tmp52, v47}) + if lang.IsTruthy(tmp53) { + tmp54 := lang.Apply(lang.WriteWriter, []any{v48, "##Inf"}) + tmp49 = tmp54 + } else { + var tmp55 any + tmp56 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp57 := lang.Apply(math4.Inf, []any{int64(-1)}) + tmp58 := lang.Apply(lang.Builtins["float32"], []any{tmp57}) + tmp59 := lang.Apply(tmp56, []any{tmp58, v47}) + if lang.IsTruthy(tmp59) { + tmp60 := lang.Apply(lang.WriteWriter, []any{v48, "##-Inf"}) + tmp55 = tmp60 + } else { + var tmp61 any + tmp62 := lang.Apply(math4.IsNaN, []any{v47}) + if lang.IsTruthy(tmp62) { + tmp63 := lang.Apply(lang.WriteWriter, []any{v48, "##NaN"}) + tmp61 = tmp63 + } else { + var tmp64 any + if lang.IsTruthy(kw_else) { + tmp65 := checkDerefVar(var_glojure_DOT_core_str) + tmp66 := lang.Apply(tmp65, []any{v47}) + tmp67 := lang.Apply(lang.WriteWriter, []any{v48, tmp66}) + tmp64 = tmp67 + } else { + } + tmp61 = tmp64 + } + tmp55 = tmp61 + } + tmp49 = tmp55 + } + return tmp49 + }) + tmp1.AddMethod(tmp45, tmp46) + tmp47 := reflect.TypeOf(int16(0)) + var tmp48 lang.FnFunc + tmp48 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v49 := args[0] + _ = v49 + v50 := args[1] + _ = v50 + tmp51 := checkDerefVar(var_glojure_DOT_core_str) + tmp52 := lang.Apply(tmp51, []any{v49}) + tmp53, _ := lang.FieldOrMethod(v50, "write") + if reflect.TypeOf(tmp53).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + } + tmp54 := lang.Apply(tmp53, []any{tmp52}) + return tmp54 + }) + tmp1.AddMethod(tmp47, tmp48) + tmp49 := reflect.TypeOf((*lang.Var)(nil)) + var tmp50 lang.FnFunc + tmp50 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v51 := args[0] + _ = v51 + v52 := args[1] + _ = v52 + tmp53 := checkDerefVar(var_glojure_DOT_core_print_DASH_simple) + tmp54 := lang.Apply(tmp53, []any{v51, v52}) + return tmp54 + }) + tmp1.AddMethod(tmp49, tmp50) + tmp51 := reflect.TypeOf(int8(0)) + var tmp52 lang.FnFunc + tmp52 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v53 := args[0] + _ = v53 + v54 := args[1] + _ = v54 + tmp55 := checkDerefVar(var_glojure_DOT_core_str) + tmp56 := lang.Apply(tmp55, []any{v53}) + tmp57, _ := lang.FieldOrMethod(v54, "write") + if reflect.TypeOf(tmp57).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + } + tmp58 := lang.Apply(tmp57, []any{tmp56}) + return tmp58 + }) + tmp1.AddMethod(tmp51, tmp52) + tmp53 := reflect.TypeOf(uint16(0)) + var tmp54 lang.FnFunc + tmp54 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v55 := args[0] + _ = v55 + v56 := args[1] + _ = v56 + tmp57 := checkDerefVar(var_glojure_DOT_core_str) + tmp58 := lang.Apply(tmp57, []any{v55}) + tmp59, _ := lang.FieldOrMethod(v56, "write") + if reflect.TypeOf(tmp59).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + } + tmp60 := lang.Apply(tmp59, []any{tmp58}) + return tmp60 + }) + tmp1.AddMethod(tmp53, tmp54) + tmp55 := reflect.TypeOf(uint64(0)) + var tmp56 lang.FnFunc + tmp56 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v57 := args[0] + _ = v57 + v58 := args[1] + _ = v58 + tmp59 := checkDerefVar(var_glojure_DOT_core_str) + tmp60 := lang.Apply(tmp59, []any{v57}) + tmp61, _ := lang.FieldOrMethod(v58, "write") + if reflect.TypeOf(tmp61).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + } + tmp62 := lang.Apply(tmp61, []any{tmp60}) + return tmp62 + }) + tmp1.AddMethod(tmp55, tmp56) + tmp57 := reflect.TypeOf((*lang.BigDecimal)(nil)) + var tmp58 lang.FnFunc + tmp58 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v59 := args[0] + _ = v59 + v60 := args[1] + _ = v60 + tmp61 := checkDerefVar(var_glojure_DOT_core_str) + tmp62 := lang.Apply(tmp61, []any{v59}) + tmp63 := lang.Apply(lang.WriteWriter, []any{v60, tmp62}) + _ = tmp63 + tmp64 := lang.Apply(lang.WriteWriter, []any{v60, "M"}) + return tmp64 + }) + tmp1.AddMethod(tmp57, tmp58) + tmp59 := reflect.TypeOf((*lang.BigInt)(nil)) + var tmp60 lang.FnFunc + tmp60 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v61 := args[0] + _ = v61 + v62 := args[1] + _ = v62 + tmp63 := checkDerefVar(var_glojure_DOT_core_str) + tmp64 := lang.Apply(tmp63, []any{v61}) + tmp65 := lang.Apply(lang.WriteWriter, []any{v62, tmp64}) + _ = tmp65 + tmp66 := lang.Apply(lang.WriteWriter, []any{v62, "N"}) + return tmp66 + }) + tmp1.AddMethod(tmp59, tmp60) + tmp61 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() + var tmp62 lang.FnFunc + tmp62 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v63 := args[0] + _ = v63 + v64 := args[1] + _ = v64 + tmp65 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) + tmp66 := lang.Apply(tmp65, []any{v63, v64}) + _ = tmp66 + tmp67 := checkDerefVar(var_glojure_DOT_core_print_DASH_sequential) + tmp68 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) + tmp69 := lang.Apply(tmp67, []any{"(", tmp68, " ", ")", v63, v64}) + return tmp69 + }) + tmp1.AddMethod(tmp61, tmp62) + tmp63 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() + tmp64 := reflect.TypeOf((*lang.IPersistentCollection)(nil)).Elem() + tmp1.PreferMethod(tmp63, tmp64) + tmp65 := reflect.TypeOf((*lang.IRecord)(nil)).Elem() + tmp66 := reflect.TypeOf((*lang.IPersistentMap)(nil)).Elem() + tmp1.PreferMethod(tmp65, tmp66) + var_glojure_DOT_core_print_DASH_method = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_print_DASH_method.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print-tagged-object + { + tmp0 := sym_print_DASH_tagged_DASH_object.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(102), kw_column, int(8), kw_end_DASH_line, int(102), kw_end_DASH_column, int(26), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_o, sym_rep, sym_w)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp7 := reflect.TypeOf((*lang.IMeta)(nil)).Elem() + tmp8 := lang.Apply(tmp6, []any{tmp7, v2}) + if lang.IsTruthy(tmp8) { + tmp9 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) + tmp10 := lang.Apply(tmp9, []any{v2, v4}) + tmp5 = tmp10 + } else { + } + _ = tmp5 + tmp11 := lang.Apply(lang.WriteWriter, []any{v4, "#object["}) + _ = tmp11 + var tmp12 any + { // let + // let binding "c" + tmp13 := checkDerefVar(var_glojure_DOT_core_class) + tmp14 := lang.Apply(tmp13, []any{v2}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + if lang.IsTruthy(false) { + tmp17 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp18, ok := lang.FieldOrMethod(v15, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v15, "Name"))) + } + var tmp19 any + switch reflect.TypeOf(tmp18).Kind() { + case reflect.Func: + tmp19 = lang.Apply(tmp18, nil) + default: + tmp19 = tmp18 + } + tmp20 := lang.Apply(tmp17, []any{tmp19, v4}) + tmp16 = tmp20 + } else { + tmp21, ok := lang.FieldOrMethod(v15, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v15, "Name"))) + } + var tmp22 any + switch reflect.TypeOf(tmp21).Kind() { + case reflect.Func: + tmp22 = lang.Apply(tmp21, nil) + default: + tmp22 = tmp21 + } + tmp23 := lang.Apply(lang.WriteWriter, []any{v4, tmp22}) + tmp16 = tmp23 + } + tmp12 = tmp16 + } // end let + _ = tmp12 + tmp13 := lang.Apply(lang.WriteWriter, []any{v4, " "}) + _ = tmp13 + tmp14 := checkDerefVar(var_glojure_DOT_core_format) + tmp15 := lang.Apply(lang.IdentityHash, []any{v2}) + tmp16 := lang.Apply(tmp14, []any{"0x%x ", tmp15}) + tmp17 := lang.Apply(lang.WriteWriter, []any{v4, tmp16}) + _ = tmp17 + tmp18 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp19 := lang.Apply(tmp18, []any{v3, v4}) + _ = tmp19 + tmp20 := lang.Apply(lang.WriteWriter, []any{v4, "]"}) + return tmp20 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_print_DASH_tagged_DASH_object = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_print_DASH_tagged_DASH_object.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print-throwable + { + tmp0 := sym_print_DASH_throwable.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(478), kw_column, int(8), kw_end_DASH_line, int(478), kw_end_DASH_column, int(22), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_o, sym_w)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := lang.Apply(lang.WriteWriter, []any{v3, "#error {\n :cause "}) + _ = tmp4 + var tmp5 any + { // let + // let binding "map__944" + tmp6 := checkDerefVar(var_glojure_DOT_core_Throwable_DASH__GT_map) + tmp7 := lang.Apply(tmp6, []any{v2}) + var v8 any = tmp7 + _ = v8 + // let binding "map__944" + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp11 := lang.Apply(tmp10, []any{v8}) + if lang.IsTruthy(tmp11) { + var tmp12 any + tmp13 := checkDerefVar(var_glojure_DOT_core_next) + tmp14 := lang.Apply(tmp13, []any{v8}) + if lang.IsTruthy(tmp14) { + tmp15 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) + tmp16 := lang.Apply(tmp15, []any{v8}) + tmp17 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{tmp16}) + tmp12 = tmp17 + } else { + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_seq) + tmp20 := lang.Apply(tmp19, []any{v8}) + if lang.IsTruthy(tmp20) { + tmp21 := checkDerefVar(var_glojure_DOT_core_first) + tmp22 := lang.Apply(tmp21, []any{v8}) + tmp18 = tmp22 + } else { + } + tmp12 = tmp18 + } + tmp9 = tmp12 + } else { + tmp9 = v8 + } + var v23 any = tmp9 + _ = v23 + // let binding "cause" + tmp24 := checkDerefVar(var_glojure_DOT_core_get) + tmp25 := lang.Apply(tmp24, []any{v23, kw_cause}) + var v26 any = tmp25 + _ = v26 + // let binding "data" + tmp27 := checkDerefVar(var_glojure_DOT_core_get) + tmp28 := lang.Apply(tmp27, []any{v23, kw_data}) + var v29 any = tmp28 + _ = v29 + // let binding "via" + tmp30 := checkDerefVar(var_glojure_DOT_core_get) + tmp31 := lang.Apply(tmp30, []any{v23, kw_via}) + var v32 any = tmp31 + _ = v32 + // let binding "trace" + tmp33 := checkDerefVar(var_glojure_DOT_core_get) + tmp34 := lang.Apply(tmp33, []any{v23, kw_trace}) + var v35 any = tmp34 + _ = v35 + // let binding "print-via" + var tmp36 lang.FnFunc + tmp36 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v37 := args[0] + _ = v37 + tmp38 := lang.Apply(lang.WriteWriter, []any{v3, "{:type "}) + _ = tmp38 + tmp39 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp40 := lang.Apply(kw_type, []any{v37}) + tmp41 := lang.Apply(tmp39, []any{tmp40, v3}) + _ = tmp41 + tmp42 := lang.Apply(lang.WriteWriter, []any{v3, "\n :message "}) + _ = tmp42 + tmp43 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp44 := lang.Apply(kw_message, []any{v37}) + tmp45 := lang.Apply(tmp43, []any{tmp44, v3}) + _ = tmp45 + var tmp46 any + { // let + // let binding "temp__0__auto__" + tmp47 := lang.Apply(kw_data, []any{v37}) + var v48 any = tmp47 + _ = v48 + var tmp49 any + if lang.IsTruthy(v48) { + var tmp50 any + { // let + // let binding "data" + var v51 any = v48 + _ = v51 + tmp52 := lang.Apply(lang.WriteWriter, []any{v3, "\n :data "}) + _ = tmp52 + tmp53 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp54 := lang.Apply(tmp53, []any{v51, v3}) + tmp50 = tmp54 + } // end let + tmp49 = tmp50 + } else { + } + tmp46 = tmp49 + } // end let + _ = tmp46 + var tmp47 any + { // let + // let binding "temp__0__auto__" + tmp48 := lang.Apply(kw_at, []any{v37}) + var v49 any = tmp48 + _ = v49 + var tmp50 any + if lang.IsTruthy(v49) { + var tmp51 any + { // let + // let binding "at" + var v52 any = v49 + _ = v52 + tmp53 := lang.Apply(lang.WriteWriter, []any{v3, "\n :at "}) + _ = tmp53 + tmp54 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp55 := lang.Apply(kw_at, []any{v37}) + tmp56 := lang.Apply(tmp54, []any{tmp55, v3}) + tmp51 = tmp56 + } // end let + tmp50 = tmp51 + } else { + } + tmp47 = tmp50 + } // end let + _ = tmp47 + tmp48 := lang.Apply(lang.WriteWriter, []any{v3, "}"}) + return tmp48 + }) + tmp37 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(481), kw_column, int(19), kw_end_DASH_line, int(491), kw_end_DASH_column, int(73)) + tmp38, err := lang.WithMeta(tmp36, tmp37.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v39 any = tmp38 + _ = v39 + tmp40 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp41 := lang.Apply(tmp40, []any{v26, v3}) + _ = tmp41 + var tmp42 any + if lang.IsTruthy(v29) { + tmp43 := lang.Apply(lang.WriteWriter, []any{v3, "\n :data "}) + _ = tmp43 + tmp44 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp45 := lang.Apply(tmp44, []any{v29, v3}) + tmp42 = tmp45 + } else { + } + _ = tmp42 + var tmp46 any + if lang.IsTruthy(v32) { + tmp47 := lang.Apply(lang.WriteWriter, []any{v3, "\n :via\n ["}) + _ = tmp47 + var tmp48 any + { // let + // let binding "temp__0__auto__" + tmp49 := checkDerefVar(var_glojure_DOT_core_first) + tmp50 := lang.Apply(tmp49, []any{v32}) + var v51 any = tmp50 + _ = v51 + var tmp52 any + if lang.IsTruthy(v51) { + var tmp53 any + { // let + // let binding "fv" + var v54 any = v51 + _ = v54 + tmp55 := lang.Apply(v39, []any{v54}) + _ = tmp55 + var tmp56 any + { // let + // let binding "seq_945" + tmp57 := checkDerefVar(var_glojure_DOT_core_seq) + tmp58 := checkDerefVar(var_glojure_DOT_core_rest) + tmp59 := lang.Apply(tmp58, []any{v32}) + tmp60 := lang.Apply(tmp57, []any{tmp59}) + var v61 any = tmp60 + _ = v61 + // let binding "chunk_946" + var v62 any = nil + _ = v62 + // let binding "count_947" + var v63 any = int64(0) + _ = v63 + // let binding "i_948" + var v64 any = int64(0) + _ = v64 + for { + var tmp65 any + tmp66 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp67 := lang.Apply(tmp66, []any{v64, v63}) + if lang.IsTruthy(tmp67) { + var tmp68 any + { // let + // let binding "v" + tmp69, _ := lang.FieldOrMethod(v62, "nth") + if reflect.TypeOf(tmp69).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp70 := lang.Apply(tmp69, []any{v64}) + var v71 any = tmp70 + _ = v71 + tmp72 := lang.Apply(lang.WriteWriter, []any{v3, "\n "}) + _ = tmp72 + tmp73 := lang.Apply(v39, []any{v71}) + _ = tmp73 + var tmp74 any = v61 + var tmp75 any = v62 + var tmp76 any = v63 + tmp78 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp79 := lang.Apply(tmp78, []any{v64}) + var tmp77 any = tmp79 + v61 = tmp74 + v62 = tmp75 + v63 = tmp76 + v64 = tmp77 + continue + } // end let + tmp65 = tmp68 + } else { + var tmp69 any + { // let + // let binding "temp__0__auto__" + tmp70 := checkDerefVar(var_glojure_DOT_core_seq) + tmp71 := lang.Apply(tmp70, []any{v61}) + var v72 any = tmp71 + _ = v72 + var tmp73 any + if lang.IsTruthy(v72) { + var tmp74 any + { // let + // let binding "seq_945" + var v75 any = v72 + _ = v75 + var tmp76 any + tmp77 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp78 := lang.Apply(tmp77, []any{v75}) + if lang.IsTruthy(tmp78) { + var tmp79 any + { // let + // let binding "c__0__auto__" + tmp80 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp81 := lang.Apply(tmp80, []any{v75}) + var v82 any = tmp81 + _ = v82 + tmp84 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp85 := lang.Apply(tmp84, []any{v75}) + var tmp83 any = tmp85 + var tmp86 any = v82 + tmp88 := checkDerefVar(var_glojure_DOT_core_int) + tmp89 := checkDerefVar(var_glojure_DOT_core_count) + tmp90 := lang.Apply(tmp89, []any{v82}) + tmp91 := lang.Apply(tmp88, []any{tmp90}) + var tmp87 any = tmp91 + tmp93 := checkDerefVar(var_glojure_DOT_core_int) + tmp94 := lang.Apply(tmp93, []any{int64(0)}) + var tmp92 any = tmp94 + v61 = tmp83 + v62 = tmp86 + v63 = tmp87 + v64 = tmp92 + continue + } // end let + tmp76 = tmp79 + } else { + var tmp80 any + { // let + // let binding "v" + tmp81 := checkDerefVar(var_glojure_DOT_core_first) + tmp82 := lang.Apply(tmp81, []any{v75}) + var v83 any = tmp82 + _ = v83 + tmp84 := lang.Apply(lang.WriteWriter, []any{v3, "\n "}) + _ = tmp84 + tmp85 := lang.Apply(v39, []any{v83}) + _ = tmp85 + tmp87 := checkDerefVar(var_glojure_DOT_core_next) + tmp88 := lang.Apply(tmp87, []any{v75}) + var tmp86 any = tmp88 + var tmp89 any = nil + var tmp90 any = int64(0) + var tmp91 any = int64(0) + v61 = tmp86 + v62 = tmp89 + v63 = tmp90 + v64 = tmp91 + continue + } // end let + tmp76 = tmp80 + } + tmp74 = tmp76 + } // end let + tmp73 = tmp74 + } else { + } + tmp69 = tmp73 + } // end let + tmp65 = tmp69 + } + tmp56 = tmp65 + break + } + } // end let + tmp53 = tmp56 + } // end let + tmp52 = tmp53 + } else { + } + tmp48 = tmp52 + } // end let + _ = tmp48 + tmp49 := lang.Apply(lang.WriteWriter, []any{v3, "]"}) + tmp46 = tmp49 + } else { + } + _ = tmp46 + var tmp50 any + if lang.IsTruthy(v35) { + tmp51 := lang.Apply(lang.WriteWriter, []any{v3, "\n :trace\n ["}) + _ = tmp51 + var tmp52 any + { // let + // let binding "temp__0__auto__" + tmp53 := checkDerefVar(var_glojure_DOT_core_first) + tmp54 := lang.Apply(tmp53, []any{v35}) + var v55 any = tmp54 + _ = v55 + var tmp56 any + if lang.IsTruthy(v55) { + var tmp57 any + { // let + // let binding "ft" + var v58 any = v55 + _ = v58 + tmp59 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp60 := lang.Apply(tmp59, []any{v58, v3}) + _ = tmp60 + var tmp61 any + { // let + // let binding "seq_949" + tmp62 := checkDerefVar(var_glojure_DOT_core_seq) + tmp63 := checkDerefVar(var_glojure_DOT_core_rest) + tmp64 := lang.Apply(tmp63, []any{v35}) + tmp65 := lang.Apply(tmp62, []any{tmp64}) + var v66 any = tmp65 + _ = v66 + // let binding "chunk_950" + var v67 any = nil + _ = v67 + // let binding "count_951" + var v68 any = int64(0) + _ = v68 + // let binding "i_952" + var v69 any = int64(0) + _ = v69 + for { + var tmp70 any + tmp71 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp72 := lang.Apply(tmp71, []any{v69, v68}) + if lang.IsTruthy(tmp72) { + var tmp73 any + { // let + // let binding "t" + tmp74, _ := lang.FieldOrMethod(v67, "nth") + if reflect.TypeOf(tmp74).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp75 := lang.Apply(tmp74, []any{v69}) + var v76 any = tmp75 + _ = v76 + tmp77 := lang.Apply(lang.WriteWriter, []any{v3, "\n "}) + _ = tmp77 + tmp78 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp79 := lang.Apply(tmp78, []any{v76, v3}) + _ = tmp79 + var tmp80 any = v66 + var tmp81 any = v67 + var tmp82 any = v68 + tmp84 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp85 := lang.Apply(tmp84, []any{v69}) + var tmp83 any = tmp85 + v66 = tmp80 + v67 = tmp81 + v68 = tmp82 + v69 = tmp83 + continue + } // end let + tmp70 = tmp73 + } else { + var tmp74 any + { // let + // let binding "temp__0__auto__" + tmp75 := checkDerefVar(var_glojure_DOT_core_seq) + tmp76 := lang.Apply(tmp75, []any{v66}) + var v77 any = tmp76 + _ = v77 + var tmp78 any + if lang.IsTruthy(v77) { + var tmp79 any + { // let + // let binding "seq_949" + var v80 any = v77 + _ = v80 + var tmp81 any + tmp82 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp83 := lang.Apply(tmp82, []any{v80}) + if lang.IsTruthy(tmp83) { + var tmp84 any + { // let + // let binding "c__0__auto__" + tmp85 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp86 := lang.Apply(tmp85, []any{v80}) + var v87 any = tmp86 + _ = v87 + tmp89 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp90 := lang.Apply(tmp89, []any{v80}) + var tmp88 any = tmp90 + var tmp91 any = v87 + tmp93 := checkDerefVar(var_glojure_DOT_core_int) + tmp94 := checkDerefVar(var_glojure_DOT_core_count) + tmp95 := lang.Apply(tmp94, []any{v87}) + tmp96 := lang.Apply(tmp93, []any{tmp95}) + var tmp92 any = tmp96 + tmp98 := checkDerefVar(var_glojure_DOT_core_int) + tmp99 := lang.Apply(tmp98, []any{int64(0)}) + var tmp97 any = tmp99 + v66 = tmp88 + v67 = tmp91 + v68 = tmp92 + v69 = tmp97 + continue + } // end let + tmp81 = tmp84 + } else { + var tmp85 any + { // let + // let binding "t" + tmp86 := checkDerefVar(var_glojure_DOT_core_first) + tmp87 := lang.Apply(tmp86, []any{v80}) + var v88 any = tmp87 + _ = v88 + tmp89 := lang.Apply(lang.WriteWriter, []any{v3, "\n "}) + _ = tmp89 + tmp90 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp91 := lang.Apply(tmp90, []any{v88, v3}) + _ = tmp91 + tmp93 := checkDerefVar(var_glojure_DOT_core_next) + tmp94 := lang.Apply(tmp93, []any{v80}) + var tmp92 any = tmp94 + var tmp95 any = nil + var tmp96 any = int64(0) + var tmp97 any = int64(0) + v66 = tmp92 + v67 = tmp95 + v68 = tmp96 + v69 = tmp97 + continue + } // end let + tmp81 = tmp85 + } + tmp79 = tmp81 + } // end let + tmp78 = tmp79 + } else { + } + tmp74 = tmp78 + } // end let + tmp70 = tmp74 + } + tmp61 = tmp70 + break + } + } // end let + tmp57 = tmp61 + } // end let + tmp56 = tmp57 + } else { + } + tmp52 = tmp56 + } // end let + _ = tmp52 + tmp53 := lang.Apply(lang.WriteWriter, []any{v3, "]"}) + tmp50 = tmp53 + } else { + } + tmp5 = tmp50 + } // end let + _ = tmp5 + tmp6 := lang.Apply(lang.WriteWriter, []any{v3, "}"}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_print_DASH_throwable = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_print_DASH_throwable.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print-object + { + tmp0 := sym_print_DASH_object.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(115), kw_column, int(8), kw_end_DASH_line, int(115), kw_end_DASH_column, int(19), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_o, sym_w)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_print_DASH_tagged_DASH_object) + tmp5 := checkDerefVar(var_glojure_DOT_core_str) + tmp6 := lang.Apply(tmp5, []any{v2}) + tmp7 := lang.Apply(tmp4, []any{v2, tmp6, v3}) + return tmp7 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_print_DASH_object = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_print_DASH_object.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // read + { + tmp0 := sym_read.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_stream), lang.NewVector(sym_stream, sym_eof_DASH_error_QMARK_, sym_eof_DASH_value), lang.NewVector(sym_stream, sym_eof_DASH_error_QMARK_, sym_eof_DASH_value, sym_recursive_QMARK_), lang.NewVector(sym_opts, sym_stream)), kw_doc, "Reads the next object from stream, which must be an instance of\n java.io.PushbackReader or some derivee. stream defaults to the\n current value of *in*.\n\n Opts is a persistent map with valid keys:\n :read-cond - :allow to process reader conditionals, or\n :preserve to keep all branches\n :features - persistent set of feature keywords for reader conditionals\n :eof - on eof, return value unless :eofthrow, then throw.\n if not specified, will throw\n\n Note that read can execute code (controlled by *read-eval*),\n and as such should be used only with trusted sources.\n\n For data structure interop use glojure.edn/read", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3742), kw_end_DASH_line, int(3742))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp2 := checkDerefVar(var_glojure_DOT_core_read) + tmp3 := checkDerefVar(var_glojure_DOT_core__STAR_in_STAR_) + tmp4 := lang.Apply(tmp2, []any{tmp3}) + return tmp4 + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_read) + tmp4 := lang.Apply(tmp3, []any{v2, true, nil}) + return tmp4 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_read) + tmp6 := lang.Apply(tmp5, []any{v2, v3, v4, false}) + return tmp6 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_boolean) + tmp7 := lang.Apply(tmp6, []any{v3}) + tmp8, _ := lang.FieldOrMethod(nil, "read") + if reflect.TypeOf(tmp8).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("read is not a function"))) + } + tmp9 := lang.Apply(tmp8, []any{v2, tmp7, v4, v5}) + return tmp9 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(nil, "read") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("read is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3, v2}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_read = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_read.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // read-line + { + tmp0 := sym_read_DASH_line.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Reads the next line from stream that is the current value of *in* .", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(3797), kw_end_DASH_line, int(3797))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp2 any + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := checkDerefVar(var_glojure_DOT_core__STAR_in_STAR_) + tmp5 := lang.Apply(tmp3, []any{nil, tmp4}) + if lang.IsTruthy(tmp5) { + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_in_STAR_) + tmp7, ok := lang.FieldOrMethod(tmp6, "readLine") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp6, "readLine"))) + } + var tmp8 any + switch reflect.TypeOf(tmp7).Kind() { + case reflect.Func: + tmp8 = lang.Apply(tmp7, nil) + default: + tmp8 = tmp7 + } + tmp2 = tmp8 + } else { + tmp9 := checkDerefVar(var_glojure_DOT_core__STAR_in_STAR_) + tmp10, ok := lang.FieldOrMethod(tmp9, "readLine") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp9, "readLine"))) + } + var tmp11 any + switch reflect.TypeOf(tmp10).Kind() { + case reflect.Func: + tmp11 = lang.Apply(tmp10, nil) + default: + tmp11 = tmp10 + } + tmp2 = tmp11 + } + return tmp2 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_read_DASH_line = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_read_DASH_line.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // read+string + { + tmp0 := sym_read_PLUS_string.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_stream), lang.NewVector(sym_stream, sym_eof_DASH_error_QMARK_, sym_eof_DASH_value), lang.NewVector(sym_stream, sym_eof_DASH_error_QMARK_, sym_eof_DASH_value, sym_recursive_QMARK_), lang.NewVector(sym_opts, sym_stream)), kw_doc, "Like read, and taking the same args. stream must be a LineNumberingPushbackReader.\n Returns a vector containing the object read and the (whitespace-trimmed) string read.", kw_file, "glojure/core.glj", kw_added, "1.10", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(3771), kw_end_DASH_line, int(3771))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp2 := checkDerefVar(var_glojure_DOT_core_read_PLUS_string) + tmp3 := checkDerefVar(var_glojure_DOT_core__STAR_in_STAR_) + tmp4 := lang.Apply(tmp2, []any{tmp3}) + return tmp4 + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_read_PLUS_string) + tmp4 := lang.Apply(tmp3, []any{v2, true, nil}) + return tmp4 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_read_PLUS_string) + tmp6 := lang.Apply(tmp5, []any{v2, v3, v4, false}) + return tmp6 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var tmp6 any + func() { + defer func() { + if r := recover(); r != nil { + if lang.CatchMatches(r, lang.Throwable) { + v7 := r + _ = v7 + tmp8, ok := lang.FieldOrMethod(v2, "getString") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getString"))) + } + var tmp9 any + switch reflect.TypeOf(tmp8).Kind() { + case reflect.Func: + tmp9 = lang.Apply(tmp8, nil) + default: + tmp9 = tmp8 + } + _ = tmp9 + panic(v7) + } else { + panic(r) + } + } + }() + tmp7, ok := lang.FieldOrMethod(v2, "captureString") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "captureString"))) + } + var tmp8 any + switch reflect.TypeOf(tmp7).Kind() { + case reflect.Func: + tmp8 = lang.Apply(tmp7, nil) + default: + tmp8 = tmp7 + } + _ = tmp8 + var tmp9 any + { // let + // let binding "o" + tmp10 := checkDerefVar(var_glojure_DOT_core_read) + tmp11 := lang.Apply(tmp10, []any{v2, v3, v4, v5}) + var v12 any = tmp11 + _ = v12 + // let binding "s" + tmp13, ok := lang.FieldOrMethod(v2, "getString") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getString"))) + } + var tmp14 any + switch reflect.TypeOf(tmp13).Kind() { + case reflect.Func: + tmp14 = lang.Apply(tmp13, nil) + default: + tmp14 = tmp13 + } + tmp15, ok := lang.FieldOrMethod(tmp14, "trim") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp14, "trim"))) + } + var tmp16 any + switch reflect.TypeOf(tmp15).Kind() { + case reflect.Func: + tmp16 = lang.Apply(tmp15, nil) + default: + tmp16 = tmp15 + } + var v17 any = tmp16 + _ = v17 + tmp18 := lang.NewVector(v12, v17) + tmp19 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3783), kw_column, int(8), kw_end_DASH_line, int(3783), kw_end_DASH_column, int(12)) + tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp9 = tmp20 + } // end let + tmp6 = tmp9 + }() + return tmp6 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + func() { + defer func() { + if r := recover(); r != nil { + if lang.CatchMatches(r, lang.Throwable) { + v5 := r + _ = v5 + tmp6, ok := lang.FieldOrMethod(v3, "getString") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getString"))) + } + var tmp7 any + switch reflect.TypeOf(tmp6).Kind() { + case reflect.Func: + tmp7 = lang.Apply(tmp6, nil) + default: + tmp7 = tmp6 + } + _ = tmp7 + panic(v5) + } else { + panic(r) + } + } + }() + tmp5, ok := lang.FieldOrMethod(v3, "captureString") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "captureString"))) + } + var tmp6 any + switch reflect.TypeOf(tmp5).Kind() { + case reflect.Func: + tmp6 = lang.Apply(tmp5, nil) + default: + tmp6 = tmp5 + } + _ = tmp6 + var tmp7 any + { // let + // let binding "o" + tmp8 := checkDerefVar(var_glojure_DOT_core_read) + tmp9 := lang.Apply(tmp8, []any{v2, v3}) + var v10 any = tmp9 + _ = v10 + // let binding "s" + tmp11, ok := lang.FieldOrMethod(v3, "getString") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getString"))) + } + var tmp12 any + switch reflect.TypeOf(tmp11).Kind() { + case reflect.Func: + tmp12 = lang.Apply(tmp11, nil) + default: + tmp12 = tmp11 + } + tmp13, ok := lang.FieldOrMethod(tmp12, "trim") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp12, "trim"))) + } + var tmp14 any + switch reflect.TypeOf(tmp13).Kind() { + case reflect.Func: + tmp14 = lang.Apply(tmp13, nil) + default: + tmp14 = tmp13 + } + var v15 any = tmp14 + _ = v15 + tmp16 := lang.NewVector(v10, v15) + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3792), kw_column, int(8), kw_end_DASH_line, int(3792), kw_end_DASH_column, int(12)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp7 = tmp18 + } // end let + tmp4 = tmp7 + }() + return tmp4 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_read_PLUS_string = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_read_PLUS_string.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reduce + { + tmp0 := sym_reduce.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_coll), lang.NewVector(sym_f, sym_val, sym_coll)), kw_doc, "f should be a function of 2 arguments. If val is not supplied,\n returns the result of applying f to the first 2 items in coll, then\n applying f to that result and the 3rd item, etc. If coll contains no\n items, f must accept no arguments as well, and reduce returns the\n result of calling f with no arguments. If coll has only 1 item, it\n is returned and f is not called. If val is supplied, returns the\n result of applying f to val and the first item in coll, then\n applying f to that result and the 2nd item, etc. If coll contains no\n items, returns val and f is not called.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(6860), kw_end_DASH_line, int(6860))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp6 := reflect.TypeOf((*lang.IReduce)(nil)).Elem() + tmp7 := lang.Apply(tmp5, []any{tmp6, v3}) + if lang.IsTruthy(tmp7) { + tmp8, _ := lang.FieldOrMethod(v3, "Reduce") + if reflect.TypeOf(tmp8).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Reduce is not a function"))) + } + tmp9 := lang.Apply(tmp8, []any{v2}) + tmp4 = tmp9 + } else { + tmp10 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_coll_DASH_reduce) + tmp11 := lang.Apply(tmp10, []any{v3, v2}) + tmp4 = tmp11 + } + return tmp4 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp7 := reflect.TypeOf((*lang.IReduceInit)(nil)).Elem() + tmp8 := lang.Apply(tmp6, []any{tmp7, v4}) + if lang.IsTruthy(tmp8) { + tmp9, _ := lang.FieldOrMethod(v4, "ReduceInit") + if reflect.TypeOf(tmp9).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) + } + tmp10 := lang.Apply(tmp9, []any{v2, v3}) + tmp5 = tmp10 + } else { + tmp11 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_coll_DASH_reduce) + tmp12 := lang.Apply(tmp11, []any{v4, v2, v3}) + tmp5 = tmp12 + } + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_reduce = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_reduce.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // run! + { + tmp0 := sym_run_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_proc, sym_coll)), kw_doc, "Runs the supplied procedure (via reduce), for purposes of side\n effects, on successive items in the collection. Returns nil", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(7708), kw_end_DASH_line, int(7708))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_reduce) + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + tmp8 := lang.Apply(v2, []any{v7}) + return tmp8 + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7713), kw_column, int(11), kw_end_DASH_line, int(7713), kw_end_DASH_column, int(20)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp8 := lang.Apply(tmp4, []any{tmp7, nil, v3}) + _ = tmp8 + return nil + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_run_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_run_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reduce-kv + { + tmp0 := sym_reduce_DASH_kv.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_init, sym_coll)), kw_doc, "Reduces an associative collection. f should be a function of 3\n arguments. Returns the result of applying f to init, the first key\n and the first value in coll, then applying f to that result and the\n 2nd key and value, etc. If coll contains no entries, returns init\n and f is not called. Note that reduce-kv is supported on vectors,\n where the keys will be the ordinals.", kw_file, "glojure/core.glj", kw_added, "1.4", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(6882), kw_end_DASH_line, int(6882))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_kv_DASH_reduce) + tmp6 := lang.Apply(tmp5, []any{v4, v2, v3}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_reduce_DASH_kv = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_reduce_DASH_kv.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // update-keys + { + tmp0 := sym_update_DASH_keys.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m, sym_f)), kw_doc, "m f => {(f k) v ...}\n\n Given a map m and a function f of 1-argument, returns a new map whose\n keys are the result of applying f to the keys of m, mapped to the\n corresponding values of m.\n f must return a unique key for each key of m, else the behavior is undefined.", kw_file, "glojure/core.glj", kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(7906), kw_end_DASH_line, int(7906))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "ret" + tmp5 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp6 := checkDerefVar(var_glojure_DOT_core_reduce_DASH_kv) + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + v10 := args[2] + _ = v10 + tmp11 := checkDerefVar(var_glojure_DOT_core_assoc_BANG_) + tmp12 := lang.Apply(v3, []any{v9}) + tmp13 := lang.Apply(tmp11, []any{v8, tmp12, v10}) + return tmp13 + }) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7916), kw_column, int(25), kw_end_DASH_line, int(7916), kw_end_DASH_column, int(59)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp10 := checkDerefVar(var_glojure_DOT_core_transient) + tmp11 := lang.NewMap() + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7917), kw_column, int(36), kw_end_DASH_line, int(7917), kw_end_DASH_column, int(37)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp14 := lang.Apply(tmp10, []any{tmp13}) + tmp15 := lang.Apply(tmp6, []any{tmp9, tmp14, v2}) + tmp16 := lang.Apply(tmp5, []any{tmp15}) + var v17 any = tmp16 + _ = v17 + tmp18 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp19 := checkDerefVar(var_glojure_DOT_core_meta) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := lang.Apply(tmp18, []any{v17, tmp20}) + tmp4 = tmp21 + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_update_DASH_keys = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_update_DASH_keys.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // update-vals + { + tmp0 := sym_update_DASH_vals.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m, sym_f)), kw_doc, "m f => {k (f v) ...}\n\n Given a map m and a function f of 1-argument, returns a new map where the keys of m\n are mapped to result of applying f to the corresponding values of m.", kw_file, "glojure/core.glj", kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(7890), kw_end_DASH_line, int(7890))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp5 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp6 := checkDerefVar(var_glojure_DOT_core_reduce_DASH_kv) + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + v10 := args[2] + _ = v10 + tmp11 := checkDerefVar(var_glojure_DOT_core_assoc_BANG_) + tmp12 := lang.Apply(v3, []any{v10}) + tmp13 := lang.Apply(tmp11, []any{v8, v9, tmp12}) + return tmp13 + }) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7899), kw_column, int(17), kw_end_DASH_line, int(7899), kw_end_DASH_column, int(51)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var tmp10 any + tmp11 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp12 := reflect.TypeOf((*lang.IEditableCollection)(nil)).Elem() + tmp13 := lang.Apply(tmp11, []any{tmp12, v2}) + if lang.IsTruthy(tmp13) { + tmp14 := checkDerefVar(var_glojure_DOT_core_transient) + tmp15 := lang.Apply(tmp14, []any{v2}) + tmp10 = tmp15 + } else { + tmp16 := checkDerefVar(var_glojure_DOT_core_transient) + tmp17 := lang.NewMap() + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7902), kw_column, int(30), kw_end_DASH_line, int(7902), kw_end_DASH_column, int(31)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp20 := lang.Apply(tmp16, []any{tmp19}) + tmp10 = tmp20 + } + tmp21 := lang.Apply(tmp6, []any{tmp9, tmp10, v2}) + tmp22 := lang.Apply(tmp5, []any{tmp21}) + tmp23 := checkDerefVar(var_glojure_DOT_core_meta) + tmp24 := lang.Apply(tmp23, []any{v2}) + tmp25 := lang.Apply(tmp4, []any{tmp22, tmp24}) + return tmp25 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_update_DASH_vals = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_update_DASH_vals.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // slurp + { + tmp1 := reflect.TypeOf("") + tmp0 := sym_slurp.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_f, sym__AMP_, sym_opts)), kw_doc, "Opens a reader on f and reads all its contents, returning a string.\n See glojure.java.io/reader for a complete list of supported arguments.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(6982), kw_end_DASH_line, int(6982))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v3 := args[0] + _ = v3 + var v4 any = lang.NewList(args[1:]...) + _ = v4 + var tmp5 any + { // let + // let binding "opts" + tmp6 := checkDerefVar(var_glojure_DOT_core_normalize_DASH_slurp_DASH_opts) + tmp7 := lang.Apply(tmp6, []any{v4}) + var v8 any = tmp7 + _ = v8 + // let binding "sw" + var v9 any = "unimplemented: new with non-constant class type" + _ = v9 + var tmp10 any + { // let + // let binding "r" + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + tmp12 := checkDerefVar(var_glojure_DOT_go_DOT_io_reader) + tmp13 := lang.Apply(tmp11, []any{tmp12, v3, v8}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + func() { + defer func() { + tmp16, ok := lang.FieldOrMethod(v14, "close") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v14, "close"))) + } + var tmp17 any + switch reflect.TypeOf(tmp16).Kind() { + case reflect.Func: + tmp17 = lang.Apply(tmp16, nil) + default: + tmp17 = tmp16 + } + _ = tmp17 + }() + tmp18 := checkDerefVar(var_glojure_DOT_go_DOT_io_copy) + tmp19 := lang.Apply(tmp18, []any{v14, v9}) + _ = tmp19 + tmp20 := lang.Apply(lang.ToString, []any{v9}) + tmp15 = tmp20 + }() + tmp10 = tmp15 + } // end let + tmp5 = tmp10 + } // end let + return tmp5 + } + }) + tmp3 := reflect.TypeOf("") + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_slurp = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_slurp.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // transduce + { + tmp0 := sym_transduce.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xform, sym_f, sym_coll), lang.NewVector(sym_xform, sym_f, sym_init, sym_coll)), kw_doc, "reduce with a transformation of f (xf). If init is not\n supplied, (f) will be called to produce it. f should be a reducing\n step function that accepts both 1 and 2 arguments, if it accepts\n only 2 you can add the arity-1 with 'completing'. Returns the result\n of applying (the transformed) xf to init and the first item in coll,\n then applying xf to that result and the 2nd item, etc. If coll\n contains no items, returns init and f is not called. Note that\n certain transforms may inject or skip items.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(6905), kw_end_DASH_line, int(6905))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_transduce) + tmp6 := lang.Apply(v3, nil) + tmp7 := lang.Apply(tmp5, []any{v2, v3, tmp6, v4}) + return tmp7 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var tmp6 any + { // let + // let binding "f" + tmp7 := lang.Apply(v2, []any{v3}) + var v8 any = tmp7 + _ = v8 + // let binding "ret" + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp11 := reflect.TypeOf((*lang.IReduceInit)(nil)).Elem() + tmp12 := lang.Apply(tmp10, []any{tmp11, v5}) + if lang.IsTruthy(tmp12) { + tmp13, _ := lang.FieldOrMethod(v5, "ReduceInit") + if reflect.TypeOf(tmp13).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) + } + tmp14 := lang.Apply(tmp13, []any{v8, v4}) + tmp9 = tmp14 + } else { + tmp15 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_coll_DASH_reduce) + tmp16 := lang.Apply(tmp15, []any{v5, v8, v4}) + tmp9 = tmp16 + } + var v17 any = tmp9 + _ = v17 + tmp18 := lang.Apply(v8, []any{v17}) + tmp6 = tmp18 + } // end let + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_transduce = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_transduce.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } +} diff --git a/pkg/stdlib/glojure/core_print/loader.go b/pkg/stdlib/glojure/core_print/loader.go new file mode 100644 index 00000000..483d1311 --- /dev/null +++ b/pkg/stdlib/glojure/core_print/loader.go @@ -0,0 +1,56233 @@ +// Code generated by glojure codegen. DO NOT EDIT. + +package core + +import ( + errors5 "errors" + fmt "fmt" + lang "github.com/glojurelang/glojure/pkg/lang" + runtime "github.com/glojurelang/glojure/pkg/runtime" + uuid10 "github.com/google/uuid" + math4 "math" + big6 "math/big" + rand13 "math/rand" + url14 "net/url" + reflect "reflect" + regexp12 "regexp" + runtime11 "runtime" + strconv9 "strconv" + strings8 "strings" + time7 "time" +) + +func init() { + runtime.RegisterNSLoader("glojure/core", LoadNS) +} + +func checkDerefVar(v *lang.Var) any { + if v.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) + } + return v.Get() +} + +func checkArity(args []any, expected int) { + if len(args) != expected { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + +// LoadNS initializes the namespace "glojure.core" +func LoadNS() { + sym__PCT_ := lang.NewSymbol("%") + sym__AMP_ := lang.NewSymbol("&") + sym__AMP_env := lang.NewSymbol("&env") + sym__AMP_form := lang.NewSymbol("&form") + sym__STAR_ := lang.NewSymbol("*") + sym__STAR__TICK_ := lang.NewSymbol("*'") + sym__STAR_1 := lang.NewSymbol("*1") + sym__STAR_2 := lang.NewSymbol("*2") + sym__STAR_3 := lang.NewSymbol("*3") + sym__STAR_agent_STAR_ := lang.NewSymbol("*agent*") + sym__STAR_assert_STAR_ := lang.NewSymbol("*assert*") + sym__STAR_command_DASH_line_DASH_args_STAR_ := lang.NewSymbol("*command-line-args*") + sym__STAR_compile_DASH_files_STAR_ := lang.NewSymbol("*compile-files*") + sym__STAR_compile_DASH_path_STAR_ := lang.NewSymbol("*compile-path*") + sym__STAR_compiler_DASH_options_STAR_ := lang.NewSymbol("*compiler-options*") + sym__STAR_data_DASH_readers_STAR_ := lang.NewSymbol("*data-readers*") + sym__STAR_default_DASH_data_DASH_reader_DASH_fn_STAR_ := lang.NewSymbol("*default-data-reader-fn*") + sym__STAR_e := lang.NewSymbol("*e") + sym__STAR_err_STAR_ := lang.NewSymbol("*err*") + sym__STAR_file_STAR_ := lang.NewSymbol("*file*") + sym__STAR_flush_DASH_on_DASH_newline_STAR_ := lang.NewSymbol("*flush-on-newline*") + sym__STAR_in_STAR_ := lang.NewSymbol("*in*") + sym__STAR_loaded_DASH_libs_STAR_ := lang.NewSymbol("*loaded-libs*") + sym__STAR_loading_DASH_verbosely_STAR_ := lang.NewSymbol("*loading-verbosely*") + sym__STAR_ns_STAR_ := lang.NewSymbol("*ns*") + sym__STAR_out_STAR_ := lang.NewSymbol("*out*") + sym__STAR_pending_DASH_paths_STAR_ := lang.NewSymbol("*pending-paths*") + sym__STAR_print_DASH_dup_STAR_ := lang.NewSymbol("*print-dup*") + sym__STAR_print_DASH_length_STAR_ := lang.NewSymbol("*print-length*") + sym__STAR_print_DASH_level_STAR_ := lang.NewSymbol("*print-level*") + sym__STAR_print_DASH_meta_STAR_ := lang.NewSymbol("*print-meta*") + sym__STAR_print_DASH_namespace_DASH_maps_STAR_ := lang.NewSymbol("*print-namespace-maps*") + sym__STAR_print_DASH_readably_STAR_ := lang.NewSymbol("*print-readably*") + sym__STAR_read_DASH_eval_STAR_ := lang.NewSymbol("*read-eval*") + sym__STAR_repl_STAR_ := lang.NewSymbol("*repl*") + sym__STAR_unchecked_DASH_math_STAR_ := lang.NewSymbol("*unchecked-math*") + sym__STAR_verbose_DASH_defrecords_STAR_ := lang.NewSymbol("*verbose-defrecords*") + sym__STAR_warn_DASH_on_DASH_reflection_STAR_ := lang.NewSymbol("*warn-on-reflection*") + sym__PLUS_ := lang.NewSymbol("+") + sym__PLUS__TICK_ := lang.NewSymbol("+'") + sym__DASH_ := lang.NewSymbol("-") + sym__DASH__TICK_ := lang.NewSymbol("-'") + sym__DASH__GT_ := lang.NewSymbol("->") + sym__DASH__GT__GT_ := lang.NewSymbol("->>") + sym__DASH_protocols := lang.NewSymbol("-protocols") + sym__DOT_ := lang.NewSymbol(".") + sym__DOT__DOT_ := lang.NewSymbol("..") + sym__DOT_Deref := lang.NewSymbol(".Deref") + sym__DOT_Equals := lang.NewSymbol(".Equals") + sym__DOT_HasRoot := lang.NewSymbol(".HasRoot") + sym__DOT_ResetMeta := lang.NewSymbol(".ResetMeta") + sym__DOT_UnixNano := lang.NewSymbol(".UnixNano") + sym__DOT_nth := lang.NewSymbol(".nth") + sym__DOT_reset := lang.NewSymbol(".reset") + sym__SLASH_ := lang.NewSymbol("/") + sym__LT_ := lang.NewSymbol("<") + sym__LT__EQ_ := lang.NewSymbol("<=") + sym__EQ_ := lang.NewSymbol("=") + sym__EQ__EQ_ := lang.NewSymbol("==") + sym__GT_ := lang.NewSymbol(">") + sym__GT_0_QMARK_ := lang.NewSymbol(">0?") + sym__GT_1_QMARK_ := lang.NewSymbol(">1?") + sym__GT__EQ_ := lang.NewSymbol(">=") + sym_CollReduce := lang.NewSymbol("CollReduce") + sym_Datafiable := lang.NewSymbol("Datafiable") + sym_Double_SLASH_isInfinite := lang.NewSymbol("Double/isInfinite") + sym_IKVReduce := lang.NewSymbol("IKVReduce") + sym_InternalReduce := lang.NewSymbol("InternalReduce") + sym_NaN_QMARK_ := lang.NewSymbol("NaN?") + sym_Navigable := lang.NewSymbol("Navigable") + sym_SetMacro := lang.NewSymbol("SetMacro") + sym_StackTraceElement_DASH__GT_vec := lang.NewSymbol("StackTraceElement->vec") + sym_Throwable_DASH__GT_map := lang.NewSymbol("Throwable->map") + sym_a := lang.NewSymbol("a") + sym_a__0__auto__ := lang.NewSymbol("a__0__auto__") + sym_abs := lang.NewSymbol("abs") + sym_accessor := lang.NewSymbol("accessor") + sym_aclone := lang.NewSymbol("aclone") + sym_add := lang.NewSymbol("add") + sym_add_DASH_classpath := lang.NewSymbol("add-classpath") + sym_add_DASH_doc_DASH_and_DASH_meta := lang.NewSymbol("add-doc-and-meta") + sym_add_DASH_watch := lang.NewSymbol("add-watch") + sym_addP := lang.NewSymbol("addP") + sym_agent := lang.NewSymbol("agent") + sym_agent_DASH_error := lang.NewSymbol("agent-error") + sym_agent_DASH_errors := lang.NewSymbol("agent-errors") + sym_agents := lang.NewSymbol("agents") + sym_aget := lang.NewSymbol("aget") + sym_alength := lang.NewSymbol("alength") + sym_alias := lang.NewSymbol("alias") + sym_all_DASH_ns := lang.NewSymbol("all-ns") + sym_alter := lang.NewSymbol("alter") + sym_alter_DASH_meta_BANG_ := lang.NewSymbol("alter-meta!") + sym_alter_DASH_var_DASH_root := lang.NewSymbol("alter-var-root") + sym_amap := lang.NewSymbol("amap") + sym_ancestors := lang.NewSymbol("ancestors") + sym_and := lang.NewSymbol("and") + sym_andNot := lang.NewSymbol("andNot") + sym_and__0__auto__ := lang.NewSymbol("and__0__auto__") + sym_any_QMARK_ := lang.NewSymbol("any?") + sym_apply := lang.NewSymbol("apply") + sym_areduce := lang.NewSymbol("areduce") + sym_arg1 := lang.NewSymbol("arg1") + sym_arg2 := lang.NewSymbol("arg2") + sym_arg3 := lang.NewSymbol("arg3") + sym_arglist := lang.NewSymbol("arglist") + sym_args := lang.NewSymbol("args") + sym_array := lang.NewSymbol("array") + sym_array_DASH_map := lang.NewSymbol("array-map") + sym_array__0__auto__ := lang.NewSymbol("array__0__auto__") + sym_as_DASH__GT_ := lang.NewSymbol("as->") + sym_aseq := lang.NewSymbol("aseq") + sym_aset := lang.NewSymbol("aset") + sym_aset_DASH_boolean := lang.NewSymbol("aset-boolean") + sym_aset_DASH_byte := lang.NewSymbol("aset-byte") + sym_aset_DASH_char := lang.NewSymbol("aset-char") + sym_aset_DASH_double := lang.NewSymbol("aset-double") + sym_aset_DASH_float := lang.NewSymbol("aset-float") + sym_aset_DASH_int := lang.NewSymbol("aset-int") + sym_aset_DASH_long := lang.NewSymbol("aset-long") + sym_aset_DASH_short := lang.NewSymbol("aset-short") + sym_assert := lang.NewSymbol("assert") + sym_assert_DASH_args := lang.NewSymbol("assert-args") + sym_assert_DASH_valid_DASH_fdecl := lang.NewSymbol("assert-valid-fdecl") + sym_assoc := lang.NewSymbol("assoc") + sym_assoc_BANG_ := lang.NewSymbol("assoc!") + sym_assoc_DASH_in := lang.NewSymbol("assoc-in") + sym_associative_QMARK_ := lang.NewSymbol("associative?") + sym_atom := lang.NewSymbol("atom") + sym_attr_DASH_map_QMARK_ := lang.NewSymbol("attr-map?") + sym_atype := lang.NewSymbol("atype") + sym_await := lang.NewSymbol("await") + sym_await_DASH_for := lang.NewSymbol("await-for") + sym_await1 := lang.NewSymbol("await1") + sym_b := lang.NewSymbol("b") + sym_bases := lang.NewSymbol("bases") + sym_begin := lang.NewSymbol("begin") + sym_bigdec := lang.NewSymbol("bigdec") + sym_bigint := lang.NewSymbol("bigint") + sym_biginteger := lang.NewSymbol("biginteger") + sym_binding := lang.NewSymbol("binding") + sym_binding_DASH_conveyor_DASH_fn := lang.NewSymbol("binding-conveyor-fn") + sym_binding_DASH_map := lang.NewSymbol("binding-map") + sym_bindings := lang.NewSymbol("bindings") + sym_bindings_STAR_ := lang.NewSymbol("bindings*") + sym_bit_DASH_and := lang.NewSymbol("bit-and") + sym_bit_DASH_and_DASH_not := lang.NewSymbol("bit-and-not") + sym_bit_DASH_clear := lang.NewSymbol("bit-clear") + sym_bit_DASH_flip := lang.NewSymbol("bit-flip") + sym_bit_DASH_not := lang.NewSymbol("bit-not") + sym_bit_DASH_or := lang.NewSymbol("bit-or") + sym_bit_DASH_set := lang.NewSymbol("bit-set") + sym_bit_DASH_shift_DASH_left := lang.NewSymbol("bit-shift-left") + sym_bit_DASH_shift_DASH_right := lang.NewSymbol("bit-shift-right") + sym_bit_DASH_test := lang.NewSymbol("bit-test") + sym_bit_DASH_xor := lang.NewSymbol("bit-xor") + sym_body := lang.NewSymbol("body") + sym_body_DASH_expr := lang.NewSymbol("body-expr") + sym_boolean := lang.NewSymbol("boolean") + sym_boolean_DASH_array := lang.NewSymbol("boolean-array") + sym_boolean_QMARK_ := lang.NewSymbol("boolean?") + sym_booleans := lang.NewSymbol("booleans") + sym_bound_DASH_fn := lang.NewSymbol("bound-fn") + sym_bound_DASH_fn_STAR_ := lang.NewSymbol("bound-fn*") + sym_bound_QMARK_ := lang.NewSymbol("bound?") + sym_bounded_DASH_count := lang.NewSymbol("bounded-count") + sym_branch_QMARK_ := lang.NewSymbol("branch?") + sym_butlast := lang.NewSymbol("butlast") + sym_byte := lang.NewSymbol("byte") + sym_byte_DASH_array := lang.NewSymbol("byte-array") + sym_byteCast := lang.NewSymbol("byteCast") + sym_bytes := lang.NewSymbol("bytes") + sym_bytes_QMARK_ := lang.NewSymbol("bytes?") + sym_c := lang.NewSymbol("c") + sym_c1 := lang.NewSymbol("c1") + sym_c2 := lang.NewSymbol("c2") + sym_c3 := lang.NewSymbol("c3") + sym_c__0__auto__ := lang.NewSymbol("c__0__auto__") + sym_capacity := lang.NewSymbol("capacity") + sym_case := lang.NewSymbol("case") + sym_case_STAR_ := lang.NewSymbol("case*") + sym_case_DASH_f := lang.NewSymbol("case-f") + sym_case_DASH_map := lang.NewSymbol("case-map") + sym_cast := lang.NewSymbol("cast") + sym_cat := lang.NewSymbol("cat") + sym_cause := lang.NewSymbol("cause") + sym_cf := lang.NewSymbol("cf") + sym_char := lang.NewSymbol("char") + sym_char_DASH_array := lang.NewSymbol("char-array") + sym_char_DASH_escape_DASH_string := lang.NewSymbol("char-escape-string") + sym_char_DASH_name_DASH_string := lang.NewSymbol("char-name-string") + sym_char_QMARK_ := lang.NewSymbol("char?") + sym_charCast := lang.NewSymbol("charCast") + sym_chars := lang.NewSymbol("chars") + sym_check_DASH_cyclic_DASH_dependency := lang.NewSymbol("check-cyclic-dependency") + sym_check_DASH_valid_DASH_options := lang.NewSymbol("check-valid-options") + sym_child := lang.NewSymbol("child") + sym_children := lang.NewSymbol("children") + sym_chunk := lang.NewSymbol("chunk") + sym_chunk_DASH_append := lang.NewSymbol("chunk-append") + sym_chunk_DASH_buffer := lang.NewSymbol("chunk-buffer") + sym_chunk_DASH_cons := lang.NewSymbol("chunk-cons") + sym_chunk_DASH_first := lang.NewSymbol("chunk-first") + sym_chunk_DASH_next := lang.NewSymbol("chunk-next") + sym_chunk_DASH_rest := lang.NewSymbol("chunk-rest") + sym_chunked_DASH_seq_QMARK_ := lang.NewSymbol("chunked-seq?") + sym_class := lang.NewSymbol("class") + sym_class_DASH_name := lang.NewSymbol("class-name") + sym_class_QMARK_ := lang.NewSymbol("class?") + sym_clauses := lang.NewSymbol("clauses") + sym_clear_DASH_agent_DASH_errors := lang.NewSymbol("clear-agent-errors") + sym_close := lang.NewSymbol("close") + sym_coerce := lang.NewSymbol("coerce") + sym_coll := lang.NewSymbol("coll") + sym_coll_DASH_reduce := lang.NewSymbol("coll-reduce") + sym_coll_QMARK_ := lang.NewSymbol("coll?") + sym_colls := lang.NewSymbol("colls") + sym_comment := lang.NewSymbol("comment") + sym_commute := lang.NewSymbol("commute") + sym_comp := lang.NewSymbol("comp") + sym_comparator := lang.NewSymbol("comparator") + sym_compare := lang.NewSymbol("compare") + sym_compare_DASH_and_DASH_set_BANG_ := lang.NewSymbol("compare-and-set!") + sym_compile := lang.NewSymbol("compile") + sym_complement := lang.NewSymbol("complement") + sym_completing := lang.NewSymbol("completing") + sym_concat := lang.NewSymbol("concat") + sym_cond := lang.NewSymbol("cond") + sym_cond_DASH__GT_ := lang.NewSymbol("cond->") + sym_cond_DASH__GT__GT_ := lang.NewSymbol("cond->>") + sym_condp := lang.NewSymbol("condp") + sym_conj := lang.NewSymbol("conj") + sym_conj_BANG_ := lang.NewSymbol("conj!") + sym_cons := lang.NewSymbol("cons") + sym_constantly := lang.NewSymbol("constantly") + sym_contains_QMARK_ := lang.NewSymbol("contains?") + sym_content := lang.NewSymbol("content") + sym_copy := lang.NewSymbol("copy") + sym_count := lang.NewSymbol("count") + sym_counted_QMARK_ := lang.NewSymbol("counted?") + sym_create := lang.NewSymbol("create") + sym_create_DASH_ns := lang.NewSymbol("create-ns") + sym_create_DASH_struct := lang.NewSymbol("create-struct") + sym_cycle := lang.NewSymbol("cycle") + sym_d := lang.NewSymbol("d") + sym_data_DASH_reader_DASH_urls := lang.NewSymbol("data-reader-urls") + sym_data_DASH_reader_DASH_var := lang.NewSymbol("data-reader-var") + sym_datafy := lang.NewSymbol("datafy") + sym_dec := lang.NewSymbol("dec") + sym_dec_TICK_ := lang.NewSymbol("dec'") + sym_decimal_QMARK_ := lang.NewSymbol("decimal?") + sym_decl := lang.NewSymbol("decl") + sym_declare := lang.NewSymbol("declare") + sym_decls := lang.NewSymbol("decls") + sym_dedupe := lang.NewSymbol("dedupe") + sym_def := lang.NewSymbol("def") + sym_def_DASH_aset := lang.NewSymbol("def-aset") + sym_default := lang.NewSymbol("default") + sym_definline := lang.NewSymbol("definline") + sym_defmacro := lang.NewSymbol("defmacro") + sym_defmethod := lang.NewSymbol("defmethod") + sym_defmulti := lang.NewSymbol("defmulti") + sym_defn := lang.NewSymbol("defn") + sym_defn_DASH_ := lang.NewSymbol("defn-") + sym_defonce := lang.NewSymbol("defonce") + sym_defprotocol := lang.NewSymbol("defprotocol") + sym_defstruct := lang.NewSymbol("defstruct") + sym_delay := lang.NewSymbol("delay") + sym_delay_QMARK_ := lang.NewSymbol("delay?") + sym_deliver := lang.NewSymbol("deliver") + sym_denominator := lang.NewSymbol("denominator") + sym_deref := lang.NewSymbol("deref") + sym_deref_DASH_as_DASH_map := lang.NewSymbol("deref-as-map") + sym_deref_DASH_future := lang.NewSymbol("deref-future") + sym_derive := lang.NewSymbol("derive") + sym_descendants := lang.NewSymbol("descendants") + sym_destructure := lang.NewSymbol("destructure") + sym_dim := lang.NewSymbol("dim") + sym_dir := lang.NewSymbol("dir") + sym_disj := lang.NewSymbol("disj") + sym_disj_BANG_ := lang.NewSymbol("disj!") + sym_dispatch_DASH_fn := lang.NewSymbol("dispatch-fn") + sym_dispatch_DASH_val := lang.NewSymbol("dispatch-val") + sym_dispatch_DASH_val_DASH_x := lang.NewSymbol("dispatch-val-x") + sym_dispatch_DASH_val_DASH_y := lang.NewSymbol("dispatch-val-y") + sym_dissoc := lang.NewSymbol("dissoc") + sym_dissoc_BANG_ := lang.NewSymbol("dissoc!") + sym_distinct := lang.NewSymbol("distinct") + sym_distinct_QMARK_ := lang.NewSymbol("distinct?") + sym_div := lang.NewSymbol("div") + sym_divide := lang.NewSymbol("divide") + sym_do := lang.NewSymbol("do") + sym_doall := lang.NewSymbol("doall") + sym_doc_DASH_string_QMARK_ := lang.NewSymbol("doc-string?") + sym_docstring := lang.NewSymbol("docstring") + sym_docstring_QMARK_ := lang.NewSymbol("docstring?") + sym_dorun := lang.NewSymbol("dorun") + sym_doseq := lang.NewSymbol("doseq") + sym_dosync := lang.NewSymbol("dosync") + sym_dotimes := lang.NewSymbol("dotimes") + sym_doto := lang.NewSymbol("doto") + sym_double := lang.NewSymbol("double") + sym_double_DASH_array := lang.NewSymbol("double-array") + sym_double_QMARK_ := lang.NewSymbol("double?") + sym_doubles := lang.NewSymbol("doubles") + sym_drop := lang.NewSymbol("drop") + sym_drop_DASH_last := lang.NewSymbol("drop-last") + sym_drop_DASH_while := lang.NewSymbol("drop-while") + sym_e := lang.NewSymbol("e") + sym_elide_DASH_top_DASH_frames := lang.NewSymbol("elide-top-frames") + sym_else := lang.NewSymbol("else") + sym_emit_DASH_extend_DASH_protocol := lang.NewSymbol("emit-extend-protocol") + sym_emit_DASH_extend_DASH_type := lang.NewSymbol("emit-extend-type") + sym_emit_DASH_hinted_DASH_impl := lang.NewSymbol("emit-hinted-impl") + sym_empty := lang.NewSymbol("empty") + sym_empty_QMARK_ := lang.NewSymbol("empty?") + sym_end := lang.NewSymbol("end") + sym_end_DASH_key := lang.NewSymbol("end-key") + sym_end_DASH_test := lang.NewSymbol("end-test") + sym_ensure := lang.NewSymbol("ensure") + sym_ensure_DASH_reduced := lang.NewSymbol("ensure-reduced") + sym_enumeration_DASH_seq := lang.NewSymbol("enumeration-seq") + sym_env := lang.NewSymbol("env") + sym_eof_DASH_error_QMARK_ := lang.NewSymbol("eof-error?") + sym_eof_DASH_value := lang.NewSymbol("eof-value") + sym_error_DASH_handler := lang.NewSymbol("error-handler") + sym_error_DASH_mode := lang.NewSymbol("error-mode") + sym_eval := lang.NewSymbol("eval") + sym_even_QMARK_ := lang.NewSymbol("even?") + sym_every_DASH_pred := lang.NewSymbol("every-pred") + sym_every_QMARK_ := lang.NewSymbol("every?") + sym_ex := lang.NewSymbol("ex") + sym_ex_DASH_cause := lang.NewSymbol("ex-cause") + sym_ex_DASH_data := lang.NewSymbol("ex-data") + sym_ex_DASH_info := lang.NewSymbol("ex-info") + sym_ex_DASH_message := lang.NewSymbol("ex-message") + sym_executor := lang.NewSymbol("executor") + sym_expr := lang.NewSymbol("expr") + sym_expr_DASH_sym := lang.NewSymbol("expr-sym") + sym_exprs := lang.NewSymbol("exprs") + sym_exprs_STAR_ := lang.NewSymbol("exprs*") + sym_extend := lang.NewSymbol("extend") + sym_extend_DASH_protocol := lang.NewSymbol("extend-protocol") + sym_extend_DASH_type := lang.NewSymbol("extend-type") + sym_f := lang.NewSymbol("f") + sym_false_QMARK_ := lang.NewSymbol("false?") + sym_ffirst := lang.NewSymbol("ffirst") + sym_file_DASH_seq := lang.NewSymbol("file-seq") + sym_filter := lang.NewSymbol("filter") + sym_filter_DASH_key := lang.NewSymbol("filter-key") + sym_filters := lang.NewSymbol("filters") + sym_filterv := lang.NewSymbol("filterv") + sym_finally := lang.NewSymbol("finally") + sym_find := lang.NewSymbol("find") + sym_find_DASH_keyword := lang.NewSymbol("find-keyword") + sym_find_DASH_ns := lang.NewSymbol("find-ns") + sym_find_DASH_var := lang.NewSymbol("find-var") + sym_first := lang.NewSymbol("first") + sym_fits_DASH_table_QMARK_ := lang.NewSymbol("fits-table?") + sym_flags_DASH_ignored_DASH_for_DASH_now := lang.NewSymbol("flags-ignored-for-now") + sym_flatten := lang.NewSymbol("flatten") + sym_float := lang.NewSymbol("float") + sym_float_DASH_array := lang.NewSymbol("float-array") + sym_float_QMARK_ := lang.NewSymbol("float?") + sym_floatCast := lang.NewSymbol("floatCast") + sym_floats := lang.NewSymbol("floats") + sym_flush := lang.NewSymbol("flush") + sym_fmt := lang.NewSymbol("fmt") + sym_fn := lang.NewSymbol("fn") + sym_fn_STAR_ := lang.NewSymbol("fn*") + sym_fn_DASH_tail := lang.NewSymbol("fn-tail") + sym_fn_QMARK_ := lang.NewSymbol("fn?") + sym_fnext := lang.NewSymbol("fnext") + sym_fnil := lang.NewSymbol("fnil") + sym_fns := lang.NewSymbol("fns") + sym_fnspecs := lang.NewSymbol("fnspecs") + sym_fnspecs_STAR_ := lang.NewSymbol("fnspecs*") + sym_fntail := lang.NewSymbol("fntail") + sym_for := lang.NewSymbol("for") + sym_force := lang.NewSymbol("force") + sym_form := lang.NewSymbol("form") + sym_format := lang.NewSymbol("format") + sym_forms := lang.NewSymbol("forms") + sym_frequencies := lang.NewSymbol("frequencies") + sym_from := lang.NewSymbol("from") + sym_fs := lang.NewSymbol("fs") + sym_fs__1__auto__ := lang.NewSymbol("fs__1__auto__") + sym_fun := lang.NewSymbol("fun") + sym_func := lang.NewSymbol("func") + sym_fut := lang.NewSymbol("fut") + sym_future := lang.NewSymbol("future") + sym_future_DASH_call := lang.NewSymbol("future-call") + sym_future_DASH_cancel := lang.NewSymbol("future-cancel") + sym_future_DASH_cancelled_QMARK_ := lang.NewSymbol("future-cancelled?") + sym_future_DASH_done_QMARK_ := lang.NewSymbol("future-done?") + sym_future_QMARK_ := lang.NewSymbol("future?") + sym_g := lang.NewSymbol("g") + sym_gen_DASH_class := lang.NewSymbol("gen-class") + sym_gensym := lang.NewSymbol("gensym") + sym_get := lang.NewSymbol("get") + sym_get_DASH_in := lang.NewSymbol("get-in") + sym_get_DASH_method := lang.NewSymbol("get-method") + sym_get_DASH_thread_DASH_bindings := lang.NewSymbol("get-thread-bindings") + sym_get_DASH_validator := lang.NewSymbol("get-validator") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT__STAR_MultiFn := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.*MultiFn") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT__STAR_Var := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.*Var") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Abs := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Abs") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_FindNamespace := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.FindNamespace") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_ISeq := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.ISeq") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Identical := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Identical") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Import := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Import") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_IsReduced := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.IsReduced") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_LockingTransaction := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.LockingTransaction") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_NewIllegalArgumentError := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewIllegalArgumentError") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_NewLazySeq := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewLazySeq") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_NewMultiFn := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewMultiFn") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_NewPersistentArrayMapAsIfByAssoc := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.NewPersistentArrayMapAsIfByAssoc") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Numbers") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_PopThreadBindings := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.PopThreadBindings") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_PushThreadBindings := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.PushThreadBindings") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Volatile := lang.NewSymbol("github.com$glojurelang$glojure$pkg$lang.Volatile") + sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT := lang.NewSymbol("github.com$glojurelang$glojure$pkg$runtime.RT") + sym_global_DASH_hierarchy := lang.NewSymbol("global-hierarchy") + sym_glojure_DOT_core := lang.NewSymbol("glojure.core") + sym_glojure_DOT_core_DOT_protocols := lang.NewSymbol("glojure.core.protocols") + sym_glojure_DOT_core_SLASH__STAR_in_STAR_ := lang.NewSymbol("glojure.core/*in*") + sym_glojure_DOT_core_SLASH__STAR_loaded_DASH_libs_STAR_ := lang.NewSymbol("glojure.core/*loaded-libs*") + sym_glojure_DOT_core_SLASH__STAR_math_DASH_context_STAR_ := lang.NewSymbol("glojure.core/*math-context*") + sym_glojure_DOT_core_SLASH__STAR_out_STAR_ := lang.NewSymbol("glojure.core/*out*") + sym_glojure_DOT_core_SLASH__DASH_ := lang.NewSymbol("glojure.core/-") + sym_glojure_DOT_core_SLASH__DASH__GT_ := lang.NewSymbol("glojure.core/->") + sym_glojure_DOT_core_SLASH__DASH__GT__GT_ := lang.NewSymbol("glojure.core/->>") + sym_glojure_DOT_core_SLASH__DASH_protocols := lang.NewSymbol("glojure.core/-protocols") + sym_glojure_DOT_core_SLASH__SLASH_ := lang.NewSymbol("glojure.core//") + sym_glojure_DOT_core_SLASH__LT_ := lang.NewSymbol("glojure.core/<") + sym_glojure_DOT_core_SLASH__EQ_ := lang.NewSymbol("glojure.core/=") + sym_glojure_DOT_core_SLASH_Aclone := lang.NewSymbol("glojure.core/Aclone") + sym_glojure_DOT_core_SLASH_AddMethod := lang.NewSymbol("glojure.core/AddMethod") + sym_glojure_DOT_core_SLASH_Aget := lang.NewSymbol("glojure.core/Aget") + sym_glojure_DOT_core_SLASH_Alength := lang.NewSymbol("glojure.core/Alength") + sym_glojure_DOT_core_SLASH_Array := lang.NewSymbol("glojure.core/Array") + sym_glojure_DOT_core_SLASH_Aset := lang.NewSymbol("glojure.core/Aset") + sym_glojure_DOT_core_SLASH_AssertionError := lang.NewSymbol("glojure.core/AssertionError") + sym_glojure_DOT_core_SLASH_BooleanArray := lang.NewSymbol("glojure.core/BooleanArray") + sym_glojure_DOT_core_SLASH_BooleanCast := lang.NewSymbol("glojure.core/BooleanCast") + sym_glojure_DOT_core_SLASH_Booleans := lang.NewSymbol("glojure.core/Booleans") + sym_glojure_DOT_core_SLASH_ByteArray := lang.NewSymbol("glojure.core/ByteArray") + sym_glojure_DOT_core_SLASH_Bytes := lang.NewSymbol("glojure.core/Bytes") + sym_glojure_DOT_core_SLASH_CharArray := lang.NewSymbol("glojure.core/CharArray") + sym_glojure_DOT_core_SLASH_Chars := lang.NewSymbol("glojure.core/Chars") + sym_glojure_DOT_core_SLASH_Count := lang.NewSymbol("glojure.core/Count") + sym_glojure_DOT_core_SLASH_DecP := lang.NewSymbol("glojure.core/DecP") + sym_glojure_DOT_core_SLASH_DoubleArray := lang.NewSymbol("glojure.core/DoubleArray") + sym_glojure_DOT_core_SLASH_DoubleCast := lang.NewSymbol("glojure.core/DoubleCast") + sym_glojure_DOT_core_SLASH_Doubles := lang.NewSymbol("glojure.core/Doubles") + sym_glojure_DOT_core_SLASH_Equiv := lang.NewSymbol("glojure.core/Equiv") + sym_glojure_DOT_core_SLASH_FloatArray := lang.NewSymbol("glojure.core/FloatArray") + sym_glojure_DOT_core_SLASH_Floats := lang.NewSymbol("glojure.core/Floats") + sym_glojure_DOT_core_SLASH_Get := lang.NewSymbol("glojure.core/Get") + sym_glojure_DOT_core_SLASH_Gt := lang.NewSymbol("glojure.core/Gt") + sym_glojure_DOT_core_SLASH_Gte := lang.NewSymbol("glojure.core/Gte") + sym_glojure_DOT_core_SLASH_IllegalStateException := lang.NewSymbol("glojure.core/IllegalStateException") + sym_glojure_DOT_core_SLASH_IncP := lang.NewSymbol("glojure.core/IncP") + sym_glojure_DOT_core_SLASH_IntArray := lang.NewSymbol("glojure.core/IntArray") + sym_glojure_DOT_core_SLASH_Ints := lang.NewSymbol("glojure.core/Ints") + sym_glojure_DOT_core_SLASH_IsNeg := lang.NewSymbol("glojure.core/IsNeg") + sym_glojure_DOT_core_SLASH_IsPos := lang.NewSymbol("glojure.core/IsPos") + sym_glojure_DOT_core_SLASH_IsZero := lang.NewSymbol("glojure.core/IsZero") + sym_glojure_DOT_core_SLASH_LongArray := lang.NewSymbol("glojure.core/LongArray") + sym_glojure_DOT_core_SLASH_LongCast := lang.NewSymbol("glojure.core/LongCast") + sym_glojure_DOT_core_SLASH_Longs := lang.NewSymbol("glojure.core/Longs") + sym_glojure_DOT_core_SLASH_Lt := lang.NewSymbol("glojure.core/Lt") + sym_glojure_DOT_core_SLASH_Lte := lang.NewSymbol("glojure.core/Lte") + sym_glojure_DOT_core_SLASH_Not := lang.NewSymbol("glojure.core/Not") + sym_glojure_DOT_core_SLASH_Nth := lang.NewSymbol("glojure.core/Nth") + sym_glojure_DOT_core_SLASH_Num := lang.NewSymbol("glojure.core/Num") + sym_glojure_DOT_core_SLASH_Object_array := lang.NewSymbol("glojure.core/Object_array") + sym_glojure_DOT_core_SLASH_Quotient := lang.NewSymbol("glojure.core/Quotient") + sym_glojure_DOT_core_SLASH_Remainder := lang.NewSymbol("glojure.core/Remainder") + sym_glojure_DOT_core_SLASH_RunInTransaction := lang.NewSymbol("glojure.core/RunInTransaction") + sym_glojure_DOT_core_SLASH_ShiftLeft := lang.NewSymbol("glojure.core/ShiftLeft") + sym_glojure_DOT_core_SLASH_ShiftRight := lang.NewSymbol("glojure.core/ShiftRight") + sym_glojure_DOT_core_SLASH_ShortArray := lang.NewSymbol("glojure.core/ShortArray") + sym_glojure_DOT_core_SLASH_Shorts := lang.NewSymbol("glojure.core/Shorts") + sym_glojure_DOT_core_SLASH_UncheckedAdd := lang.NewSymbol("glojure.core/UncheckedAdd") + sym_glojure_DOT_core_SLASH_UncheckedByteCast := lang.NewSymbol("glojure.core/UncheckedByteCast") + sym_glojure_DOT_core_SLASH_UncheckedCharCast := lang.NewSymbol("glojure.core/UncheckedCharCast") + sym_glojure_DOT_core_SLASH_UncheckedDec := lang.NewSymbol("glojure.core/UncheckedDec") + sym_glojure_DOT_core_SLASH_UncheckedDoubleCast := lang.NewSymbol("glojure.core/UncheckedDoubleCast") + sym_glojure_DOT_core_SLASH_UncheckedFloatCast := lang.NewSymbol("glojure.core/UncheckedFloatCast") + sym_glojure_DOT_core_SLASH_UncheckedIntCast := lang.NewSymbol("glojure.core/UncheckedIntCast") + sym_glojure_DOT_core_SLASH_UncheckedIntDivide := lang.NewSymbol("glojure.core/UncheckedIntDivide") + sym_glojure_DOT_core_SLASH_UncheckedLongCast := lang.NewSymbol("glojure.core/UncheckedLongCast") + sym_glojure_DOT_core_SLASH_UncheckedShortCast := lang.NewSymbol("glojure.core/UncheckedShortCast") + sym_glojure_DOT_core_SLASH_Unchecked_inc := lang.NewSymbol("glojure.core/Unchecked_inc") + sym_glojure_DOT_core_SLASH_Unchecked_int_add := lang.NewSymbol("glojure.core/Unchecked_int_add") + sym_glojure_DOT_core_SLASH_Unchecked_int_dec := lang.NewSymbol("glojure.core/Unchecked_int_dec") + sym_glojure_DOT_core_SLASH_Unchecked_int_inc := lang.NewSymbol("glojure.core/Unchecked_int_inc") + sym_glojure_DOT_core_SLASH_Unchecked_int_multiply := lang.NewSymbol("glojure.core/Unchecked_int_multiply") + sym_glojure_DOT_core_SLASH_Unchecked_int_negate := lang.NewSymbol("glojure.core/Unchecked_int_negate") + sym_glojure_DOT_core_SLASH_Unchecked_int_remainder := lang.NewSymbol("glojure.core/Unchecked_int_remainder") + sym_glojure_DOT_core_SLASH_Unchecked_int_subtract := lang.NewSymbol("glojure.core/Unchecked_int_subtract") + sym_glojure_DOT_core_SLASH_Unchecked_minus := lang.NewSymbol("glojure.core/Unchecked_minus") + sym_glojure_DOT_core_SLASH_Unchecked_multiply := lang.NewSymbol("glojure.core/Unchecked_multiply") + sym_glojure_DOT_core_SLASH_UnsignedShiftRight := lang.NewSymbol("glojure.core/UnsignedShiftRight") + sym_glojure_DOT_core_SLASH_aclone := lang.NewSymbol("glojure.core/aclone") + sym_glojure_DOT_core_SLASH_aget := lang.NewSymbol("glojure.core/aget") + sym_glojure_DOT_core_SLASH_alength := lang.NewSymbol("glojure.core/alength") + sym_glojure_DOT_core_SLASH_alter_DASH_meta_BANG_ := lang.NewSymbol("glojure.core/alter-meta!") + sym_glojure_DOT_core_SLASH_and := lang.NewSymbol("glojure.core/and") + sym_glojure_DOT_core_SLASH_apply := lang.NewSymbol("glojure.core/apply") + sym_glojure_DOT_core_SLASH_args := lang.NewSymbol("glojure.core/args") + sym_glojure_DOT_core_SLASH_aset := lang.NewSymbol("glojure.core/aset") + sym_glojure_DOT_core_SLASH_assert := lang.NewSymbol("glojure.core/assert") + sym_glojure_DOT_core_SLASH_assert_DASH_args := lang.NewSymbol("glojure.core/assert-args") + sym_glojure_DOT_core_SLASH_assoc := lang.NewSymbol("glojure.core/assoc") + sym_glojure_DOT_core_SLASH_assoc_DASH_in := lang.NewSymbol("glojure.core/assoc-in") + sym_glojure_DOT_core_SLASH_atom := lang.NewSymbol("glojure.core/atom") + sym_glojure_DOT_core_SLASH_binding := lang.NewSymbol("glojure.core/binding") + sym_glojure_DOT_core_SLASH_bound_DASH_fn_STAR_ := lang.NewSymbol("glojure.core/bound-fn*") + sym_glojure_DOT_core_SLASH_c := lang.NewSymbol("glojure.core/c") + sym_glojure_DOT_core_SLASH_chunk := lang.NewSymbol("glojure.core/chunk") + sym_glojure_DOT_core_SLASH_chunk_DASH_append := lang.NewSymbol("glojure.core/chunk-append") + sym_glojure_DOT_core_SLASH_chunk_DASH_buffer := lang.NewSymbol("glojure.core/chunk-buffer") + sym_glojure_DOT_core_SLASH_chunk_DASH_cons := lang.NewSymbol("glojure.core/chunk-cons") + sym_glojure_DOT_core_SLASH_chunk_DASH_first := lang.NewSymbol("glojure.core/chunk-first") + sym_glojure_DOT_core_SLASH_chunk_DASH_rest := lang.NewSymbol("glojure.core/chunk-rest") + sym_glojure_DOT_core_SLASH_chunked_DASH_seq_QMARK_ := lang.NewSymbol("glojure.core/chunked-seq?") + sym_glojure_DOT_core_SLASH_class := lang.NewSymbol("glojure.core/class") + sym_glojure_DOT_core_SLASH_commute := lang.NewSymbol("glojure.core/commute") + sym_glojure_DOT_core_SLASH_compare := lang.NewSymbol("glojure.core/compare") + sym_glojure_DOT_core_SLASH_concat := lang.NewSymbol("glojure.core/concat") + sym_glojure_DOT_core_SLASH_cond := lang.NewSymbol("glojure.core/cond") + sym_glojure_DOT_core_SLASH_condp := lang.NewSymbol("glojure.core/condp") + sym_glojure_DOT_core_SLASH_conj := lang.NewSymbol("glojure.core/conj") + sym_glojure_DOT_core_SLASH_cons := lang.NewSymbol("glojure.core/cons") + sym_glojure_DOT_core_SLASH_count := lang.NewSymbol("glojure.core/count") + sym_glojure_DOT_core_SLASH_create_DASH_struct := lang.NewSymbol("glojure.core/create-struct") + sym_glojure_DOT_core_SLASH_defmulti := lang.NewSymbol("glojure.core/defmulti") + sym_glojure_DOT_core_SLASH_defn := lang.NewSymbol("glojure.core/defn") + sym_glojure_DOT_core_SLASH_deref := lang.NewSymbol("glojure.core/deref") + sym_glojure_DOT_core_SLASH_dosync := lang.NewSymbol("glojure.core/dosync") + sym_glojure_DOT_core_SLASH_double := lang.NewSymbol("glojure.core/double") + sym_glojure_DOT_core_SLASH_equiv := lang.NewSymbol("glojure.core/equiv") + sym_glojure_DOT_core_SLASH_extend := lang.NewSymbol("glojure.core/extend") + sym_glojure_DOT_core_SLASH_extend_DASH_type := lang.NewSymbol("glojure.core/extend-type") + sym_glojure_DOT_core_SLASH_first := lang.NewSymbol("glojure.core/first") + sym_glojure_DOT_core_SLASH_fn := lang.NewSymbol("glojure.core/fn") + sym_glojure_DOT_core_SLASH_future_DASH_call := lang.NewSymbol("glojure.core/future-call") + sym_glojure_DOT_core_SLASH_gen_DASH_class := lang.NewSymbol("glojure.core/gen-class") + sym_glojure_DOT_core_SLASH_get := lang.NewSymbol("glojure.core/get") + sym_glojure_DOT_core_SLASH_hash_DASH_map := lang.NewSymbol("glojure.core/hash-map") + sym_glojure_DOT_core_SLASH_i := lang.NewSymbol("glojure.core/i") + sym_glojure_DOT_core_SLASH_identical := lang.NewSymbol("glojure.core/identical") + sym_glojure_DOT_core_SLASH_if_DASH_let := lang.NewSymbol("glojure.core/if-let") + sym_glojure_DOT_core_SLASH_if_DASH_not := lang.NewSymbol("glojure.core/if-not") + sym_glojure_DOT_core_SLASH_if_DASH_some := lang.NewSymbol("glojure.core/if-some") + sym_glojure_DOT_core_SLASH_in_DASH_ns := lang.NewSymbol("glojure.core/in-ns") + sym_glojure_DOT_core_SLASH_instance_QMARK_ := lang.NewSymbol("glojure.core/instance?") + sym_glojure_DOT_core_SLASH_int := lang.NewSymbol("glojure.core/int") + sym_glojure_DOT_core_SLASH_keyword := lang.NewSymbol("glojure.core/keyword") + sym_glojure_DOT_core_SLASH_lazy_DASH_seq := lang.NewSymbol("glojure.core/lazy-seq") + sym_glojure_DOT_core_SLASH_let := lang.NewSymbol("glojure.core/let") + sym_glojure_DOT_core_SLASH_long := lang.NewSymbol("glojure.core/long") + sym_glojure_DOT_core_SLASH_loop := lang.NewSymbol("glojure.core/loop") + sym_glojure_DOT_core_SLASH_merge := lang.NewSymbol("glojure.core/merge") + sym_glojure_DOT_core_SLASH_meta := lang.NewSymbol("glojure.core/meta") + sym_glojure_DOT_core_SLASH_next := lang.NewSymbol("glojure.core/next") + sym_glojure_DOT_core_SLASH_nf := lang.NewSymbol("glojure.core/nf") + sym_glojure_DOT_core_SLASH_nil_QMARK_ := lang.NewSymbol("glojure.core/nil?") + sym_glojure_DOT_core_SLASH_not := lang.NewSymbol("glojure.core/not") + sym_glojure_DOT_core_SLASH_nth := lang.NewSymbol("glojure.core/nth") + sym_glojure_DOT_core_SLASH_or := lang.NewSymbol("glojure.core/or") + sym_glojure_DOT_core_SLASH_pcalls := lang.NewSymbol("glojure.core/pcalls") + sym_glojure_DOT_core_SLASH_pop_DASH_thread_DASH_bindings := lang.NewSymbol("glojure.core/pop-thread-bindings") + sym_glojure_DOT_core_SLASH_pr_DASH_str := lang.NewSymbol("glojure.core/pr-str") + sym_glojure_DOT_core_SLASH_prn := lang.NewSymbol("glojure.core/prn") + sym_glojure_DOT_core_SLASH_push_DASH_thread_DASH_bindings := lang.NewSymbol("glojure.core/push-thread-bindings") + sym_glojure_DOT_core_SLASH_refer := lang.NewSymbol("glojure.core/refer") + sym_glojure_DOT_core_SLASH_rest := lang.NewSymbol("glojure.core/rest") + sym_glojure_DOT_core_SLASH_seq := lang.NewSymbol("glojure.core/seq") + sym_glojure_DOT_core_SLASH_seq_QMARK_ := lang.NewSymbol("glojure.core/seq?") + sym_glojure_DOT_core_SLASH_str := lang.NewSymbol("glojure.core/str") + sym_glojure_DOT_core_SLASH_swap_BANG_ := lang.NewSymbol("glojure.core/swap!") + sym_glojure_DOT_core_SLASH_sync := lang.NewSymbol("glojure.core/sync") + sym_glojure_DOT_core_SLASH_to_DASH_array := lang.NewSymbol("glojure.core/to-array") + sym_glojure_DOT_core_SLASH_unchecked_DASH_inc := lang.NewSymbol("glojure.core/unchecked-inc") + sym_glojure_DOT_core_SLASH_unchecked_DASH_inc_DASH_int := lang.NewSymbol("glojure.core/unchecked-inc-int") + sym_glojure_DOT_core_SLASH_unquote := lang.NewSymbol("glojure.core/unquote") + sym_glojure_DOT_core_SLASH_unquote_DASH_splicing := lang.NewSymbol("glojure.core/unquote-splicing") + sym_glojure_DOT_core_SLASH_when := lang.NewSymbol("glojure.core/when") + sym_glojure_DOT_core_SLASH_when_DASH_first := lang.NewSymbol("glojure.core/when-first") + sym_glojure_DOT_core_SLASH_when_DASH_let := lang.NewSymbol("glojure.core/when-let") + sym_glojure_DOT_core_SLASH_when_DASH_not := lang.NewSymbol("glojure.core/when-not") + sym_glojure_DOT_core_SLASH_with_DASH_bindings_STAR_ := lang.NewSymbol("glojure.core/with-bindings*") + sym_glojure_DOT_core_SLASH_with_DASH_loading_DASH_context := lang.NewSymbol("glojure.core/with-loading-context") + sym_glojure_DOT_core_SLASH_with_DASH_open := lang.NewSymbol("glojure.core/with-open") + sym_glojure_DOT_core_SLASH_with_DASH_redefs_DASH_fn := lang.NewSymbol("glojure.core/with-redefs-fn") + sym_glojure_DOT_go_DOT_io := lang.NewSymbol("glojure.go.io") + sym_glojure_DOT_lang_DOT_Delay := lang.NewSymbol("glojure.lang.Delay") + sym_glojure_DOT_lang_DOT_IChunk := lang.NewSymbol("glojure.lang.IChunk") + sym_glojure_DOT_lang_DOT_LineNumberingPushbackReader_DOT_ := lang.NewSymbol("glojure.lang.LineNumberingPushbackReader.") + sym_glojure_DOT_lang_DOT_LockingTransaction_SLASH_isRunning := lang.NewSymbol("glojure.lang.LockingTransaction/isRunning") + sym_glojure_DOT_lang_DOT_PersistentArrayMap_SLASH_EMPTY := lang.NewSymbol("glojure.lang.PersistentArrayMap/EMPTY") + sym_glojure_DOT_lang_DOT_Util := lang.NewSymbol("glojure.lang.Util") + sym_glojure_DOT_string := lang.NewSymbol("glojure.string") + sym_group_DASH_by := lang.NewSymbol("group-by") + sym_h := lang.NewSymbol("h") + sym_halt_DASH_when := lang.NewSymbol("halt-when") + sym_handler_DASH_fn := lang.NewSymbol("handler-fn") + sym_hash := lang.NewSymbol("hash") + sym_hash_DASH_basis := lang.NewSymbol("hash-basis") + sym_hash_DASH_map := lang.NewSymbol("hash-map") + sym_hash_DASH_ordered_DASH_coll := lang.NewSymbol("hash-ordered-coll") + sym_hash_DASH_set := lang.NewSymbol("hash-set") + sym_hash_DASH_unordered_DASH_coll := lang.NewSymbol("hash-unordered-coll") + sym_hashes := lang.NewSymbol("hashes") + sym_ident_QMARK_ := lang.NewSymbol("ident?") + sym_identical_QMARK_ := lang.NewSymbol("identical?") + sym_identity := lang.NewSymbol("identity") + sym_idx := lang.NewSymbol("idx") + sym_idx2 := lang.NewSymbol("idx2") + sym_idx2__3__auto__ := lang.NewSymbol("idx2__3__auto__") + sym_idx__1__auto__ := lang.NewSymbol("idx__1__auto__") + sym_idxs := lang.NewSymbol("idxs") + sym_idxv := lang.NewSymbol("idxv") + sym_idxv__4__auto__ := lang.NewSymbol("idxv__4__auto__") + sym_if := lang.NewSymbol("if") + sym_if_DASH_let := lang.NewSymbol("if-let") + sym_if_DASH_not := lang.NewSymbol("if-not") + sym_if_DASH_some := lang.NewSymbol("if-some") + sym_ifn_QMARK_ := lang.NewSymbol("ifn?") + sym_import := lang.NewSymbol("import") + sym_import_DASH_symbols_DASH_or_DASH_lists := lang.NewSymbol("import-symbols-or-lists") + sym_inc := lang.NewSymbol("inc") + sym_inc_TICK_ := lang.NewSymbol("inc'") + sym_index := lang.NewSymbol("index") + sym_indexed_QMARK_ := lang.NewSymbol("indexed?") + sym_infinite_QMARK_ := lang.NewSymbol("infinite?") + sym_init := lang.NewSymbol("init") + sym_init_DASH_val_DASH_or_DASH_seq := lang.NewSymbol("init-val-or-seq") + sym_initk := lang.NewSymbol("initk") + sym_inits := lang.NewSymbol("inits") + sym_inst := lang.NewSymbol("inst") + sym_inst_DASH_ms := lang.NewSymbol("inst-ms") + sym_inst_QMARK_ := lang.NewSymbol("inst?") + sym_instance_QMARK_ := lang.NewSymbol("instance?") + sym_int := lang.NewSymbol("int") + sym_int_DASH_array := lang.NewSymbol("int-array") + sym_int_QMARK_ := lang.NewSymbol("int?") + sym_intCast := lang.NewSymbol("intCast") + sym_integer_QMARK_ := lang.NewSymbol("integer?") + sym_interface_DASH_or_DASH_naive_DASH_reduce := lang.NewSymbol("interface-or-naive-reduce") + sym_interleave := lang.NewSymbol("interleave") + sym_intern := lang.NewSymbol("intern") + sym_internal_DASH_reduce := lang.NewSymbol("internal-reduce") + sym_interpose := lang.NewSymbol("interpose") + sym_into := lang.NewSymbol("into") + sym_into_DASH_array := lang.NewSymbol("into-array") + sym_into1 := lang.NewSymbol("into1") + sym_ints := lang.NewSymbol("ints") + sym_io_BANG_ := lang.NewSymbol("io!") + sym_iref := lang.NewSymbol("iref") + sym_isa_QMARK_ := lang.NewSymbol("isa?") + sym_items := lang.NewSymbol("items") + sym_iter := lang.NewSymbol("iter") + sym_iter__0__auto__ := lang.NewSymbol("iter__0__auto__") + sym_iterate := lang.NewSymbol("iterate") + sym_iteration := lang.NewSymbol("iteration") + sym_iterator_DASH_seq := lang.NewSymbol("iterator-seq") + sym_iterys__0__auto__ := lang.NewSymbol("iterys__0__auto__") + sym_java_DOT_io_DOT_StringReader_DOT_ := lang.NewSymbol("java.io.StringReader.") + sym_java_DOT_math_DOT_MathContext_DOT_ := lang.NewSymbol("java.math.MathContext.") + sym_java_DOT_math_DOT_RoundingMode := lang.NewSymbol("java.math.RoundingMode") + sym_juxt := lang.NewSymbol("juxt") + sym_k := lang.NewSymbol("k") + sym_keep := lang.NewSymbol("keep") + sym_keep_DASH_indexed := lang.NewSymbol("keep-indexed") + sym_key := lang.NewSymbol("key") + sym_keyfn := lang.NewSymbol("keyfn") + sym_keys := lang.NewSymbol("keys") + sym_keyseq := lang.NewSymbol("keyseq") + sym_keyvals := lang.NewSymbol("keyvals") + sym_keyword := lang.NewSymbol("keyword") + sym_keyword_QMARK_ := lang.NewSymbol("keyword?") + sym_kf := lang.NewSymbol("kf") + sym_ks := lang.NewSymbol("ks") + sym_kv_DASH_reduce := lang.NewSymbol("kv-reduce") + sym_kvs := lang.NewSymbol("kvs") + sym_l__1__auto__ := lang.NewSymbol("l__1__auto__") + sym_last := lang.NewSymbol("last") + sym_lazy_DASH_cat := lang.NewSymbol("lazy-cat") + sym_lazy_DASH_seq := lang.NewSymbol("lazy-seq") + sym_len := lang.NewSymbol("len") + sym_let := lang.NewSymbol("let") + sym_let_STAR_ := lang.NewSymbol("let*") + sym_letfn := lang.NewSymbol("letfn") + sym_letfn_STAR_ := lang.NewSymbol("letfn*") + sym_lib := lang.NewSymbol("lib") + sym_libspec_QMARK_ := lang.NewSymbol("libspec?") + sym_lift_DASH_ns := lang.NewSymbol("lift-ns") + sym_line_DASH_seq := lang.NewSymbol("line-seq") + sym_list := lang.NewSymbol("list") + sym_list_STAR_ := lang.NewSymbol("list*") + sym_list_QMARK_ := lang.NewSymbol("list?") + sym_load := lang.NewSymbol("load") + sym_load_DASH_all := lang.NewSymbol("load-all") + sym_load_DASH_data_DASH_reader_DASH_file := lang.NewSymbol("load-data-reader-file") + sym_load_DASH_data_DASH_readers := lang.NewSymbol("load-data-readers") + sym_load_DASH_file := lang.NewSymbol("load-file") + sym_load_DASH_lib := lang.NewSymbol("load-lib") + sym_load_DASH_libs := lang.NewSymbol("load-libs") + sym_load_DASH_one := lang.NewSymbol("load-one") + sym_load_DASH_reader := lang.NewSymbol("load-reader") + sym_load_DASH_string := lang.NewSymbol("load-string") + sym_loaded_DASH_libs := lang.NewSymbol("loaded-libs") + sym_loading__0__auto__ := lang.NewSymbol("loading__0__auto__") + sym_lockee__0__auto__ := lang.NewSymbol("lockee__0__auto__") + sym_locking := lang.NewSymbol("locking") + sym_locklocal__1__auto__ := lang.NewSymbol("locklocal__1__auto__") + sym_long := lang.NewSymbol("long") + sym_long_DASH_array := lang.NewSymbol("long-array") + sym_longs := lang.NewSymbol("longs") + sym_loop := lang.NewSymbol("loop") + sym_loop_STAR_ := lang.NewSymbol("loop*") + sym_m := lang.NewSymbol("m") + sym_macroexpand := lang.NewSymbol("macroexpand") + sym_macroexpand_DASH_1 := lang.NewSymbol("macroexpand-1") + sym_make_DASH_array := lang.NewSymbol("make-array") + sym_make_DASH_hierarchy := lang.NewSymbol("make-hierarchy") + sym_map := lang.NewSymbol("map") + sym_map_DASH_entry_QMARK_ := lang.NewSymbol("map-entry?") + sym_map_DASH_indexed := lang.NewSymbol("map-indexed") + sym_map_QMARK_ := lang.NewSymbol("map?") + sym_mapcat := lang.NewSymbol("mapcat") + sym_mappings := lang.NewSymbol("mappings") + sym_maps := lang.NewSymbol("maps") + sym_mapv := lang.NewSymbol("mapv") + sym_mask := lang.NewSymbol("mask") + sym_math_DOT_IsNaN := lang.NewSymbol("math.IsNaN") + sym_max := lang.NewSymbol("max") + sym_max_DASH_key := lang.NewSymbol("max-key") + sym_max_DASH_mask_DASH_bits := lang.NewSymbol("max-mask-bits") + sym_max_DASH_switch_DASH_table_DASH_size := lang.NewSymbol("max-switch-table-size") + sym_maybe_DASH_destructured := lang.NewSymbol("maybe-destructured") + sym_maybe_DASH_min_DASH_hash := lang.NewSymbol("maybe-min-hash") + sym_maybe_DASH_p := lang.NewSymbol("maybe-p") + sym_memfn := lang.NewSymbol("memfn") + sym_memoize := lang.NewSymbol("memoize") + sym_merge := lang.NewSymbol("merge") + sym_merge_DASH_hash_DASH_collisions := lang.NewSymbol("merge-hash-collisions") + sym_merge_DASH_with := lang.NewSymbol("merge-with") + sym_message := lang.NewSymbol("message") + sym_meta := lang.NewSymbol("meta") + sym_metadata_DASH_map := lang.NewSymbol("metadata-map") + sym_method := lang.NewSymbol("method") + sym_methods := lang.NewSymbol("methods") + sym_min := lang.NewSymbol("min") + sym_min_DASH_key := lang.NewSymbol("min-key") + sym_minus := lang.NewSymbol("minus") + sym_minusP := lang.NewSymbol("minusP") + sym_mix_DASH_collection_DASH_hash := lang.NewSymbol("mix-collection-hash") + sym_mk_DASH_bound_DASH_fn := lang.NewSymbol("mk-bound-fn") + sym_mod := lang.NewSymbol("mod") + sym_mode_DASH_keyword := lang.NewSymbol("mode-keyword") + sym_monitor_DASH_enter := lang.NewSymbol("monitor-enter") + sym_monitor_DASH_exit := lang.NewSymbol("monitor-exit") + sym_more := lang.NewSymbol("more") + sym_more_DASH_dims := lang.NewSymbol("more-dims") + sym_msg := lang.NewSymbol("msg") + sym_multifn := lang.NewSymbol("multifn") + sym_multiply := lang.NewSymbol("multiply") + sym_multiplyP := lang.NewSymbol("multiplyP") + sym_n := lang.NewSymbol("n") + sym_n_DASH_or_DASH_q := lang.NewSymbol("n-or-q") + sym_n__0__auto__ := lang.NewSymbol("n__0__auto__") + sym_name := lang.NewSymbol("name") + sym_name_DASH_vals_DASH_vec := lang.NewSymbol("name-vals-vec") + sym_name_QMARK_ := lang.NewSymbol("name?") + sym_named := lang.NewSymbol("named") + sym_names := lang.NewSymbol("names") + sym_namespace := lang.NewSymbol("namespace") + sym_namespace_DASH_sym := lang.NewSymbol("namespace-sym") + sym_nary_DASH_inline := lang.NewSymbol("nary-inline") + sym_nat_DASH_int_QMARK_ := lang.NewSymbol("nat-int?") + sym_nav := lang.NewSymbol("nav") + sym_need_DASH_ns := lang.NewSymbol("need-ns") + sym_neg_DASH_int_QMARK_ := lang.NewSymbol("neg-int?") + sym_neg_QMARK_ := lang.NewSymbol("neg?") + sym_new := lang.NewSymbol("new") + sym_new_DASH_state := lang.NewSymbol("new-state") + sym_newline := lang.NewSymbol("newline") + sym_newval := lang.NewSymbol("newval") + sym_next := lang.NewSymbol("next") + sym_nfirst := lang.NewSymbol("nfirst") + sym_nil_QMARK_ := lang.NewSymbol("nil?") + sym_nnext := lang.NewSymbol("nnext") + sym_normalize_DASH_slurp_DASH_opts := lang.NewSymbol("normalize-slurp-opts") + sym_not := lang.NewSymbol("not") + sym_not_DASH_any_QMARK_ := lang.NewSymbol("not-any?") + sym_not_DASH_empty := lang.NewSymbol("not-empty") + sym_not_DASH_every_QMARK_ := lang.NewSymbol("not-every?") + sym_not_DASH_found := lang.NewSymbol("not-found") + sym_not_EQ_ := lang.NewSymbol("not=") + sym_ns := lang.NewSymbol("ns") + sym_ns_DASH_aliases := lang.NewSymbol("ns-aliases") + sym_ns_DASH_imports := lang.NewSymbol("ns-imports") + sym_ns_DASH_interns := lang.NewSymbol("ns-interns") + sym_ns_DASH_map := lang.NewSymbol("ns-map") + sym_ns_DASH_name := lang.NewSymbol("ns-name") + sym_ns_DASH_publics := lang.NewSymbol("ns-publics") + sym_ns_DASH_refers := lang.NewSymbol("ns-refers") + sym_ns_DASH_resolve := lang.NewSymbol("ns-resolve") + sym_ns_DASH_sym := lang.NewSymbol("ns-sym") + sym_ns_DASH_unalias := lang.NewSymbol("ns-unalias") + sym_ns_DASH_unmap := lang.NewSymbol("ns-unmap") + sym_nth := lang.NewSymbol("nth") + sym_nthnext := lang.NewSymbol("nthnext") + sym_nthrest := lang.NewSymbol("nthrest") + sym_num := lang.NewSymbol("num") + sym_number_QMARK_ := lang.NewSymbol("number?") + sym_numerator := lang.NewSymbol("numerator") + sym_o := lang.NewSymbol("o") + sym_obj := lang.NewSymbol("obj") + sym_object_DASH_array := lang.NewSymbol("object-array") + sym_odd_QMARK_ := lang.NewSymbol("odd?") + sym_oldform := lang.NewSymbol("oldform") + sym_oldval := lang.NewSymbol("oldval") + sym_op := lang.NewSymbol("op") + sym_options := lang.NewSymbol("options") + sym_opts := lang.NewSymbol("opts") + sym_opts_PLUS_sigs := lang.NewSymbol("opts+sigs") + sym_or := lang.NewSymbol("or") + sym_or__0__auto__ := lang.NewSymbol("or__0__auto__") + sym_p := lang.NewSymbol("p") + sym_p1 := lang.NewSymbol("p1") + sym_p2 := lang.NewSymbol("p2") + sym_p3 := lang.NewSymbol("p3") + sym_p__0__auto__ := lang.NewSymbol("p__0__auto__") + sym_pad := lang.NewSymbol("pad") + sym_pairs := lang.NewSymbol("pairs") + sym_params := lang.NewSymbol("params") + sym_params_STAR_ := lang.NewSymbol("params*") + sym_parent := lang.NewSymbol("parent") + sym_parents := lang.NewSymbol("parents") + sym_parse_DASH_boolean := lang.NewSymbol("parse-boolean") + sym_parse_DASH_double := lang.NewSymbol("parse-double") + sym_parse_DASH_impls := lang.NewSymbol("parse-impls") + sym_parse_DASH_long := lang.NewSymbol("parse-long") + sym_parse_DASH_uuid := lang.NewSymbol("parse-uuid") + sym_parsing_DASH_err := lang.NewSymbol("parsing-err") + sym_partial := lang.NewSymbol("partial") + sym_partition := lang.NewSymbol("partition") + sym_partition_DASH_all := lang.NewSymbol("partition-all") + sym_partition_DASH_by := lang.NewSymbol("partition-by") + sym_partitionv := lang.NewSymbol("partitionv") + sym_partitionv_DASH_all := lang.NewSymbol("partitionv-all") + sym_path := lang.NewSymbol("path") + sym_paths := lang.NewSymbol("paths") + sym_pcalls := lang.NewSymbol("pcalls") + sym_peek := lang.NewSymbol("peek") + sym_persistent_BANG_ := lang.NewSymbol("persistent!") + sym_pmap := lang.NewSymbol("pmap") + sym_pop := lang.NewSymbol("pop") + sym_pop_BANG_ := lang.NewSymbol("pop!") + sym_pop_DASH_thread_DASH_bindings := lang.NewSymbol("pop-thread-bindings") + sym_pos_DASH_int_QMARK_ := lang.NewSymbol("pos-int?") + sym_pos_QMARK_ := lang.NewSymbol("pos?") + sym_pr := lang.NewSymbol("pr") + sym_pr_DASH_on := lang.NewSymbol("pr-on") + sym_pr_DASH_str := lang.NewSymbol("pr-str") + sym_precision := lang.NewSymbol("precision") + sym_pred := lang.NewSymbol("pred") + sym_prefer_DASH_method := lang.NewSymbol("prefer-method") + sym_prefers := lang.NewSymbol("prefers") + sym_prefix := lang.NewSymbol("prefix") + sym_prefix_DASH_string := lang.NewSymbol("prefix-string") + sym_prep_DASH_hashes := lang.NewSymbol("prep-hashes") + sym_prep_DASH_ints := lang.NewSymbol("prep-ints") + sym_prependss := lang.NewSymbol("prependss") + sym_prepost_DASH_map_QMARK_ := lang.NewSymbol("prepost-map?") + sym_preserving_DASH_reduced := lang.NewSymbol("preserving-reduced") + sym_print := lang.NewSymbol("print") + sym_print_DASH_args := lang.NewSymbol("print-args") + sym_print_DASH_ctor := lang.NewSymbol("print-ctor") + sym_print_DASH_dup := lang.NewSymbol("print-dup") + sym_print_DASH_initialized := lang.NewSymbol("print-initialized") + sym_print_DASH_map := lang.NewSymbol("print-map") + sym_print_DASH_meta := lang.NewSymbol("print-meta") + sym_print_DASH_method := lang.NewSymbol("print-method") + sym_print_DASH_object := lang.NewSymbol("print-object") + sym_print_DASH_one := lang.NewSymbol("print-one") + sym_print_DASH_prefix_DASH_map := lang.NewSymbol("print-prefix-map") + sym_print_DASH_sequential := lang.NewSymbol("print-sequential") + sym_print_DASH_simple := lang.NewSymbol("print-simple") + sym_print_DASH_str := lang.NewSymbol("print-str") + sym_print_DASH_tagged_DASH_object := lang.NewSymbol("print-tagged-object") + sym_print_DASH_throwable := lang.NewSymbol("print-throwable") + sym_printf := lang.NewSymbol("printf") + sym_println := lang.NewSymbol("println") + sym_println_DASH_str := lang.NewSymbol("println-str") + sym_prn := lang.NewSymbol("prn") + sym_prn_DASH_str := lang.NewSymbol("prn-str") + sym_prob := lang.NewSymbol("prob") + sym_proc := lang.NewSymbol("proc") + sym_promise := lang.NewSymbol("promise") + sym_proto_PLUS_mmaps := lang.NewSymbol("proto+mmaps") + sym_protocol_QMARK_ := lang.NewSymbol("protocol?") + sym_ps := lang.NewSymbol("ps") + sym_push_DASH_thread_DASH_bindings := lang.NewSymbol("push-thread-bindings") + sym_pvalues := lang.NewSymbol("pvalues") + sym_qualified_DASH_ident_QMARK_ := lang.NewSymbol("qualified-ident?") + sym_qualified_DASH_keyword_QMARK_ := lang.NewSymbol("qualified-keyword?") + sym_qualified_DASH_symbol_QMARK_ := lang.NewSymbol("qualified-symbol?") + sym_quot := lang.NewSymbol("quot") + sym_quote := lang.NewSymbol("quote") + sym_r := lang.NewSymbol("r") + sym_rand := lang.NewSymbol("rand") + sym_rand_DASH_int := lang.NewSymbol("rand-int") + sym_rand_DASH_nth := lang.NewSymbol("rand-nth") + sym_random_DASH_sample := lang.NewSymbol("random-sample") + sym_random_DASH_uuid := lang.NewSymbol("random-uuid") + sym_range := lang.NewSymbol("range") + sym_ratio_QMARK_ := lang.NewSymbol("ratio?") + sym_rational_QMARK_ := lang.NewSymbol("rational?") + sym_rationalize := lang.NewSymbol("rationalize") + sym_rdr := lang.NewSymbol("rdr") + sym_re := lang.NewSymbol("re") + sym_re_DASH_find := lang.NewSymbol("re-find") + sym_re_DASH_groups := lang.NewSymbol("re-groups") + sym_re_DASH_matcher := lang.NewSymbol("re-matcher") + sym_re_DASH_matches := lang.NewSymbol("re-matches") + sym_re_DASH_pattern := lang.NewSymbol("re-pattern") + sym_re_DASH_seq := lang.NewSymbol("re-seq") + sym_read := lang.NewSymbol("read") + sym_read_PLUS_string := lang.NewSymbol("read+string") + sym_read_DASH_line := lang.NewSymbol("read-line") + sym_read_DASH_string := lang.NewSymbol("read-string") + sym_reader := lang.NewSymbol("reader") + sym_reader_DASH_conditional := lang.NewSymbol("reader-conditional") + sym_reader_DASH_conditional_QMARK_ := lang.NewSymbol("reader-conditional?") + sym_realized_QMARK_ := lang.NewSymbol("realized?") + sym_recur := lang.NewSymbol("recur") + sym_recursive_QMARK_ := lang.NewSymbol("recursive?") + sym_reduce := lang.NewSymbol("reduce") + sym_reduce_DASH_kv := lang.NewSymbol("reduce-kv") + sym_reduce1 := lang.NewSymbol("reduce1") + sym_reduced := lang.NewSymbol("reduced") + sym_reduced_QMARK_ := lang.NewSymbol("reduced?") + sym_reductions := lang.NewSymbol("reductions") + sym_ref := lang.NewSymbol("ref") + sym_ref_DASH_history_DASH_count := lang.NewSymbol("ref-history-count") + sym_ref_DASH_max_DASH_history := lang.NewSymbol("ref-max-history") + sym_ref_DASH_min_DASH_history := lang.NewSymbol("ref-min-history") + sym_ref_DASH_set := lang.NewSymbol("ref-set") + sym_refer := lang.NewSymbol("refer") + sym_refer_DASH_glojure := lang.NewSymbol("refer-glojure") + sym_reference := lang.NewSymbol("reference") + sym_references_STAR_ := lang.NewSymbol("references*") + sym_release_DASH_pending_DASH_sends := lang.NewSymbol("release-pending-sends") + sym_rem := lang.NewSymbol("rem") + sym_remove := lang.NewSymbol("remove") + sym_remove_DASH_all_DASH_methods := lang.NewSymbol("remove-all-methods") + sym_remove_DASH_method := lang.NewSymbol("remove-method") + sym_remove_DASH_ns := lang.NewSymbol("remove-ns") + sym_remove_DASH_tap := lang.NewSymbol("remove-tap") + sym_remove_DASH_watch := lang.NewSymbol("remove-watch") + sym_rep := lang.NewSymbol("rep") + sym_repeat := lang.NewSymbol("repeat") + sym_repeatedly := lang.NewSymbol("repeatedly") + sym_replace := lang.NewSymbol("replace") + sym_replicate := lang.NewSymbol("replicate") + sym_require := lang.NewSymbol("require") + sym_requiring_DASH_resolve := lang.NewSymbol("requiring-resolve") + sym_reset_BANG_ := lang.NewSymbol("reset!") + sym_reset_DASH_meta_BANG_ := lang.NewSymbol("reset-meta!") + sym_reset_DASH_vals_BANG_ := lang.NewSymbol("reset-vals!") + sym_resolve := lang.NewSymbol("resolve") + sym_rest := lang.NewSymbol("rest") + sym_restart_DASH_agent := lang.NewSymbol("restart-agent") + sym_resultset_DASH_seq := lang.NewSymbol("resultset-seq") + sym_ret := lang.NewSymbol("ret") + sym_ret__1__auto__ := lang.NewSymbol("ret__1__auto__") + sym_retf := lang.NewSymbol("retf") + sym_rev := lang.NewSymbol("rev") + sym_reverse := lang.NewSymbol("reverse") + sym_reversible_QMARK_ := lang.NewSymbol("reversible?") + sym_rf := lang.NewSymbol("rf") + sym_root := lang.NewSymbol("root") + sym_root_DASH_directory := lang.NewSymbol("root-directory") + sym_root_DASH_resource := lang.NewSymbol("root-resource") + sym_rs := lang.NewSymbol("rs") + sym_rseq := lang.NewSymbol("rseq") + sym_rsubseq := lang.NewSymbol("rsubseq") + sym_run_BANG_ := lang.NewSymbol("run!") + sym_s := lang.NewSymbol("s") + sym_s__0__auto__ := lang.NewSymbol("s__0__auto__") + sym_sc := lang.NewSymbol("sc") + sym_second := lang.NewSymbol("second") + sym_select_DASH_keys := lang.NewSymbol("select-keys") + sym_send := lang.NewSymbol("send") + sym_send_DASH_off := lang.NewSymbol("send-off") + sym_send_DASH_via := lang.NewSymbol("send-via") + sym_sep := lang.NewSymbol("sep") + sym_seq := lang.NewSymbol("seq") + sym_seq_DASH_exprs := lang.NewSymbol("seq-exprs") + sym_seq_DASH_reduce := lang.NewSymbol("seq-reduce") + sym_seq_DASH_to_DASH_map_DASH_for_DASH_destructuring := lang.NewSymbol("seq-to-map-for-destructuring") + sym_seq_QMARK_ := lang.NewSymbol("seq?") + sym_seqable_QMARK_ := lang.NewSymbol("seqable?") + sym_seque := lang.NewSymbol("seque") + sym_sequence := lang.NewSymbol("sequence") + sym_sequential_QMARK_ := lang.NewSymbol("sequential?") + sym_serialized_DASH_require := lang.NewSymbol("serialized-require") + sym_set := lang.NewSymbol("set") + sym_set_DASH_agent_DASH_send_DASH_executor_BANG_ := lang.NewSymbol("set-agent-send-executor!") + sym_set_DASH_agent_DASH_send_DASH_off_DASH_executor_BANG_ := lang.NewSymbol("set-agent-send-off-executor!") + sym_set_DASH_error_DASH_handler_BANG_ := lang.NewSymbol("set-error-handler!") + sym_set_DASH_error_DASH_mode_BANG_ := lang.NewSymbol("set-error-mode!") + sym_set_DASH_validator_BANG_ := lang.NewSymbol("set-validator!") + sym_set_QMARK_ := lang.NewSymbol("set?") + sym_setDynamic := lang.NewSymbol("setDynamic") + sym_setup_DASH_reference := lang.NewSymbol("setup-reference") + sym_shift := lang.NewSymbol("shift") + sym_shift_DASH_mask := lang.NewSymbol("shift-mask") + sym_short := lang.NewSymbol("short") + sym_short_DASH_array := lang.NewSymbol("short-array") + sym_shortCast := lang.NewSymbol("shortCast") + sym_shorts := lang.NewSymbol("shorts") + sym_shuffle := lang.NewSymbol("shuffle") + sym_shutdown_DASH_agents := lang.NewSymbol("shutdown-agents") + sym_sigs := lang.NewSymbol("sigs") + sym_simple_DASH_ident_QMARK_ := lang.NewSymbol("simple-ident?") + sym_simple_DASH_keyword_QMARK_ := lang.NewSymbol("simple-keyword?") + sym_simple_DASH_symbol_QMARK_ := lang.NewSymbol("simple-symbol?") + sym_size := lang.NewSymbol("size") + sym_size_DASH_or_DASH_seq := lang.NewSymbol("size-or-seq") + sym_size__1__auto__ := lang.NewSymbol("size__1__auto__") + sym_slurp := lang.NewSymbol("slurp") + sym_smap := lang.NewSymbol("smap") + sym_some := lang.NewSymbol("some") + sym_some_DASH__GT_ := lang.NewSymbol("some->") + sym_some_DASH__GT__GT_ := lang.NewSymbol("some->>") + sym_some_DASH_fn := lang.NewSymbol("some-fn") + sym_some_QMARK_ := lang.NewSymbol("some?") + sym_somef := lang.NewSymbol("somef") + sym_sort := lang.NewSymbol("sort") + sym_sort_DASH_by := lang.NewSymbol("sort-by") + sym_sorted_DASH_map := lang.NewSymbol("sorted-map") + sym_sorted_DASH_map_DASH_by := lang.NewSymbol("sorted-map-by") + sym_sorted_DASH_set := lang.NewSymbol("sorted-set") + sym_sorted_DASH_set_DASH_by := lang.NewSymbol("sorted-set-by") + sym_sorted_QMARK_ := lang.NewSymbol("sorted?") + sym_special_DASH_symbol_QMARK_ := lang.NewSymbol("special-symbol?") + sym_specs := lang.NewSymbol("specs") + sym_spit := lang.NewSymbol("spit") + sym_splicing_QMARK_ := lang.NewSymbol("splicing?") + sym_split_DASH_at := lang.NewSymbol("split-at") + sym_split_DASH_with := lang.NewSymbol("split-with") + sym_splitv_DASH_at := lang.NewSymbol("splitv-at") + sym_spread := lang.NewSymbol("spread") + sym_start := lang.NewSymbol("start") + sym_start_DASH_key := lang.NewSymbol("start-key") + sym_start_DASH_test := lang.NewSymbol("start-test") + sym_start__0__auto__ := lang.NewSymbol("start__0__auto__") + sym_state := lang.NewSymbol("state") + sym_step := lang.NewSymbol("step") + sym_str := lang.NewSymbol("str") + sym_stream := lang.NewSymbol("stream") + sym_stream_DASH_into_BANG_ := lang.NewSymbol("stream-into!") + sym_stream_DASH_reduce_BANG_ := lang.NewSymbol("stream-reduce!") + sym_stream_DASH_seq_BANG_ := lang.NewSymbol("stream-seq!") + sym_stream_DASH_transduce_BANG_ := lang.NewSymbol("stream-transduce!") + sym_string_QMARK_ := lang.NewSymbol("string?") + sym_strings_DOT_Builder := lang.NewSymbol("strings.Builder") + sym_strip_DASH_ns := lang.NewSymbol("strip-ns") + sym_struct := lang.NewSymbol("struct") + sym_struct_DASH_map := lang.NewSymbol("struct-map") + sym_subs := lang.NewSymbol("subs") + sym_subseq := lang.NewSymbol("subseq") + sym_subvec := lang.NewSymbol("subvec") + sym_supers := lang.NewSymbol("supers") + sym_swap_BANG_ := lang.NewSymbol("swap!") + sym_swap_DASH_vals_BANG_ := lang.NewSymbol("swap-vals!") + sym_sym := lang.NewSymbol("sym") + sym_symbol := lang.NewSymbol("symbol") + sym_symbol_QMARK_ := lang.NewSymbol("symbol?") + sym_sync := lang.NewSymbol("sync") + sym_system_DASH_newline := lang.NewSymbol("system-newline") + sym_t := lang.NewSymbol("t") + sym_tag := lang.NewSymbol("tag") + sym_tagged_DASH_literal := lang.NewSymbol("tagged-literal") + sym_tagged_DASH_literal_QMARK_ := lang.NewSymbol("tagged-literal?") + sym_take := lang.NewSymbol("take") + sym_take_DASH_last := lang.NewSymbol("take-last") + sym_take_DASH_nth := lang.NewSymbol("take-nth") + sym_take_DASH_while := lang.NewSymbol("take-while") + sym_tapset := lang.NewSymbol("tapset") + sym_temp__0__auto__ := lang.NewSymbol("temp__0__auto__") + sym_test := lang.NewSymbol("test") + sym_test_DASH_f := lang.NewSymbol("test-f") + sym_tests := lang.NewSymbol("tests") + sym_the_DASH_ns := lang.NewSymbol("the-ns") + sym_then := lang.NewSymbol("then") + sym_thens := lang.NewSymbol("thens") + sym_this := lang.NewSymbol("this") + sym_thread_DASH_bound_QMARK_ := lang.NewSymbol("thread-bound?") + sym_throw := lang.NewSymbol("throw") + sym_throw_DASH_if := lang.NewSymbol("throw-if") + sym_time := lang.NewSymbol("time") + sym_time_DOT_Now := lang.NewSymbol("time.Now") + sym_timeout_DASH_ms := lang.NewSymbol("timeout-ms") + sym_timeout_DASH_val := lang.NewSymbol("timeout-val") + sym_to := lang.NewSymbol("to") + sym_to_DASH_array := lang.NewSymbol("to-array") + sym_to_DASH_array_DASH_2d := lang.NewSymbol("to-array-2d") + sym_trampoline := lang.NewSymbol("trampoline") + sym_transduce := lang.NewSymbol("transduce") + sym_transient := lang.NewSymbol("transient") + sym_tree_DASH_seq := lang.NewSymbol("tree-seq") + sym_true_QMARK_ := lang.NewSymbol("true?") + sym_try := lang.NewSymbol("try") + sym_type := lang.NewSymbol("type") + sym_unchecked_DASH_add := lang.NewSymbol("unchecked-add") + sym_unchecked_DASH_add_DASH_int := lang.NewSymbol("unchecked-add-int") + sym_unchecked_DASH_byte := lang.NewSymbol("unchecked-byte") + sym_unchecked_DASH_char := lang.NewSymbol("unchecked-char") + sym_unchecked_DASH_dec := lang.NewSymbol("unchecked-dec") + sym_unchecked_DASH_dec_DASH_int := lang.NewSymbol("unchecked-dec-int") + sym_unchecked_DASH_divide_DASH_int := lang.NewSymbol("unchecked-divide-int") + sym_unchecked_DASH_double := lang.NewSymbol("unchecked-double") + sym_unchecked_DASH_float := lang.NewSymbol("unchecked-float") + sym_unchecked_DASH_inc := lang.NewSymbol("unchecked-inc") + sym_unchecked_DASH_inc_DASH_int := lang.NewSymbol("unchecked-inc-int") + sym_unchecked_DASH_int := lang.NewSymbol("unchecked-int") + sym_unchecked_DASH_long := lang.NewSymbol("unchecked-long") + sym_unchecked_DASH_multiply := lang.NewSymbol("unchecked-multiply") + sym_unchecked_DASH_multiply_DASH_int := lang.NewSymbol("unchecked-multiply-int") + sym_unchecked_DASH_negate := lang.NewSymbol("unchecked-negate") + sym_unchecked_DASH_negate_DASH_int := lang.NewSymbol("unchecked-negate-int") + sym_unchecked_DASH_op := lang.NewSymbol("unchecked-op") + sym_unchecked_DASH_remainder_DASH_int := lang.NewSymbol("unchecked-remainder-int") + sym_unchecked_DASH_short := lang.NewSymbol("unchecked-short") + sym_unchecked_DASH_subtract := lang.NewSymbol("unchecked-subtract") + sym_unchecked_DASH_subtract_DASH_int := lang.NewSymbol("unchecked-subtract-int") + sym_uncheckedByteCast := lang.NewSymbol("uncheckedByteCast") + sym_uncheckedCharCast := lang.NewSymbol("uncheckedCharCast") + sym_uncheckedFloatCast := lang.NewSymbol("uncheckedFloatCast") + sym_uncheckedIntCast := lang.NewSymbol("uncheckedIntCast") + sym_uncheckedShortCast := lang.NewSymbol("uncheckedShortCast") + sym_unchecked_add := lang.NewSymbol("unchecked_add") + sym_unchecked_dec := lang.NewSymbol("unchecked_dec") + sym_unchecked_inc := lang.NewSymbol("unchecked_inc") + sym_unchecked_minus := lang.NewSymbol("unchecked_minus") + sym_unchecked_multiply := lang.NewSymbol("unchecked_multiply") + sym_underive := lang.NewSymbol("underive") + sym_unquote := lang.NewSymbol("unquote") + sym_unquote_DASH_splicing := lang.NewSymbol("unquote-splicing") + sym_unreduced := lang.NewSymbol("unreduced") + sym_unsigned_DASH_bit_DASH_shift_DASH_right := lang.NewSymbol("unsigned-bit-shift-right") + sym_update := lang.NewSymbol("update") + sym_update_DASH_in := lang.NewSymbol("update-in") + sym_update_DASH_keys := lang.NewSymbol("update-keys") + sym_update_DASH_vals := lang.NewSymbol("update-vals") + sym_uri_QMARK_ := lang.NewSymbol("uri?") + sym_url := lang.NewSymbol("url") + sym_use := lang.NewSymbol("use") + sym_user := lang.NewSymbol("user") + sym_uuid_QMARK_ := lang.NewSymbol("uuid?") + sym_v := lang.NewSymbol("v") + sym_v__0__auto__ := lang.NewSymbol("v__0__auto__") + sym_val := lang.NewSymbol("val") + sym_val__2__auto__ := lang.NewSymbol("val__2__auto__") + sym_valid_DASH_keys := lang.NewSymbol("valid-keys") + sym_validator_DASH_fn := lang.NewSymbol("validator-fn") + sym_vals := lang.NewSymbol("vals") + sym_value := lang.NewSymbol("value") + sym_var := lang.NewSymbol("var") + sym_var_DASH_get := lang.NewSymbol("var-get") + sym_var_DASH_set := lang.NewSymbol("var-set") + sym_var_QMARK_ := lang.NewSymbol("var?") + sym_vars := lang.NewSymbol("vars") + sym_vary_DASH_meta := lang.NewSymbol("vary-meta") + sym_vec := lang.NewSymbol("vec") + sym_vector := lang.NewSymbol("vector") + sym_vector_QMARK_ := lang.NewSymbol("vector?") + sym_vf := lang.NewSymbol("vf") + sym_vol := lang.NewSymbol("vol") + sym_volatile_BANG_ := lang.NewSymbol("volatile!") + sym_volatile_QMARK_ := lang.NewSymbol("volatile?") + sym_vreset_BANG_ := lang.NewSymbol("vreset!") + sym_vswap_BANG_ := lang.NewSymbol("vswap!") + sym_w := lang.NewSymbol("w") + sym_when := lang.NewSymbol("when") + sym_when_DASH_first := lang.NewSymbol("when-first") + sym_when_DASH_let := lang.NewSymbol("when-let") + sym_when_DASH_not := lang.NewSymbol("when-not") + sym_when_DASH_some := lang.NewSymbol("when-some") + sym_while := lang.NewSymbol("while") + sym_with_DASH_bindings := lang.NewSymbol("with-bindings") + sym_with_DASH_bindings_STAR_ := lang.NewSymbol("with-bindings*") + sym_with_DASH_in_DASH_str := lang.NewSymbol("with-in-str") + sym_with_DASH_loading_DASH_context := lang.NewSymbol("with-loading-context") + sym_with_DASH_local_DASH_vars := lang.NewSymbol("with-local-vars") + sym_with_DASH_meta := lang.NewSymbol("with-meta") + sym_with_DASH_open := lang.NewSymbol("with-open") + sym_with_DASH_out_DASH_str := lang.NewSymbol("with-out-str") + sym_with_DASH_precision := lang.NewSymbol("with-precision") + sym_with_DASH_redefs := lang.NewSymbol("with-redefs") + sym_with_DASH_redefs_DASH_fn := lang.NewSymbol("with-redefs-fn") + sym_x := lang.NewSymbol("x") + sym_xform := lang.NewSymbol("xform") + sym_xml_DASH_seq := lang.NewSymbol("xml-seq") + sym_xor := lang.NewSymbol("xor") + sym_xs := lang.NewSymbol("xs") + sym_xs__0__auto__ := lang.NewSymbol("xs__0__auto__") + sym_y := lang.NewSymbol("y") + sym_ys := lang.NewSymbol("ys") + sym_z := lang.NewSymbol("z") + sym_zero_QMARK_ := lang.NewSymbol("zero?") + sym_zipmap := lang.NewSymbol("zipmap") + sym_zs := lang.NewSymbol("zs") + kw__GT__GT_ := lang.NewKeyword(">>") + kw_added := lang.NewKeyword("added") + kw_all := lang.NewKeyword("all") + kw_allow := lang.NewKeyword("allow") + kw_ancestors := lang.NewKeyword("ancestors") + kw_arglists := lang.NewKeyword("arglists") + kw_as := lang.NewKeyword("as") + kw_as_DASH_alias := lang.NewKeyword("as-alias") + kw_at := lang.NewKeyword("at") + kw_cause := lang.NewKeyword("cause") + kw_clear_DASH_actions := lang.NewKeyword("clear-actions") + kw_coll_DASH_reduce := lang.NewKeyword("coll-reduce") + kw_column := lang.NewKeyword("column") + kw_compact := lang.NewKeyword("compact") + kw_conflict := lang.NewKeyword("conflict") + kw_content := lang.NewKeyword("content") + kw_continue := lang.NewKeyword("continue") + kw_data := lang.NewKeyword("data") + kw_datafy := lang.NewKeyword("datafy") + kw_declared := lang.NewKeyword("declared") + kw_default := lang.NewKeyword("default") + kw_deprecated := lang.NewKeyword("deprecated") + kw_descendants := lang.NewKeyword("descendants") + kw_doc := lang.NewKeyword("doc") + kw_dynamic := lang.NewKeyword("dynamic") + kw_else := lang.NewKeyword("else") + kw_encoding := lang.NewKeyword("encoding") + kw_end_DASH_column := lang.NewKeyword("end-column") + kw_end_DASH_line := lang.NewKeyword("end-line") + kw_eof := lang.NewKeyword("eof") + kw_error_DASH_handler := lang.NewKeyword("error-handler") + kw_error_DASH_mode := lang.NewKeyword("error-mode") + kw_exclude := lang.NewKeyword("exclude") + kw_fail := lang.NewKeyword("fail") + kw_failed := lang.NewKeyword("failed") + kw_file := lang.NewKeyword("file") + kw_form := lang.NewKeyword("form") + kw_forms := lang.NewKeyword("forms") + kw_gen_DASH_class := lang.NewKeyword("gen-class") + kw_glojure_DOT_core_SLASH_halt := lang.NewKeyword("glojure.core/halt") + kw_glojure_DOT_core_SLASH_none := lang.NewKeyword("glojure.core/none") + kw_glojure_DOT_error_SLASH_phase := lang.NewKeyword("glojure.error/phase") + kw_hash_DASH_equiv := lang.NewKeyword("hash-equiv") + kw_hash_DASH_identity := lang.NewKeyword("hash-identity") + kw_hashes := lang.NewKeyword("hashes") + kw_hierarchy := lang.NewKeyword("hierarchy") + kw_identity := lang.NewKeyword("identity") + kw_impl_DASH_ns := lang.NewKeyword("impl-ns") + kw_initk := lang.NewKeyword("initk") + kw_inline := lang.NewKeyword("inline") + kw_inline_DASH_arities := lang.NewKeyword("inline-arities") + kw_int := lang.NewKeyword("int") + kw_internal_DASH_reduce := lang.NewKeyword("internal-reduce") + kw_ints := lang.NewKeyword("ints") + kw_keys := lang.NewKeyword("keys") + kw_kf := lang.NewKeyword("kf") + kw_kv_DASH_reduce := lang.NewKeyword("kv-reduce") + kw_let := lang.NewKeyword("let") + kw_line := lang.NewKeyword("line") + kw_macro := lang.NewKeyword("macro") + kw_main := lang.NewKeyword("main") + kw_mappings := lang.NewKeyword("mappings") + kw_max_DASH_history := lang.NewKeyword("max-history") + kw_message := lang.NewKeyword("message") + kw_meta := lang.NewKeyword("meta") + kw_min_DASH_history := lang.NewKeyword("min-history") + kw_multis := lang.NewKeyword("multis") + kw_name := lang.NewKeyword("name") + kw_nav := lang.NewKeyword("nav") + kw_no_DASH_test := lang.NewKeyword("no-test") + kw_ns := lang.NewKeyword("ns") + kw_ok := lang.NewKeyword("ok") + kw_on_DASH_interface := lang.NewKeyword("on-interface") + kw_only := lang.NewKeyword("only") + kw_or := lang.NewKeyword("or") + kw_parents := lang.NewKeyword("parents") + kw_pending := lang.NewKeyword("pending") + kw_phase := lang.NewKeyword("phase") + kw_post := lang.NewKeyword("post") + kw_pre := lang.NewKeyword("pre") + kw_private := lang.NewKeyword("private") + kw_read_DASH_cond := lang.NewKeyword("read-cond") + kw_ready := lang.NewKeyword("ready") + kw_redef := lang.NewKeyword("redef") + kw_refer := lang.NewKeyword("refer") + kw_refer_DASH_glojure := lang.NewKeyword("refer-glojure") + kw_reload := lang.NewKeyword("reload") + kw_reload_DASH_all := lang.NewKeyword("reload-all") + kw_rename := lang.NewKeyword("rename") + kw_require := lang.NewKeyword("require") + kw_rettag := lang.NewKeyword("rettag") + kw_rounding := lang.NewKeyword("rounding") + kw_sigs := lang.NewKeyword("sigs") + kw_somef := lang.NewKeyword("somef") + kw_sparse := lang.NewKeyword("sparse") + kw_special_DASH_form := lang.NewKeyword("special-form") + kw_static := lang.NewKeyword("static") + kw_status := lang.NewKeyword("status") + kw_tag := lang.NewKeyword("tag") + kw_test := lang.NewKeyword("test") + kw_trace := lang.NewKeyword("trace") + kw_type := lang.NewKeyword("type") + kw_url := lang.NewKeyword("url") + kw_use := lang.NewKeyword("use") + kw_val := lang.NewKeyword("val") + kw_validator := lang.NewKeyword("validator") + kw_verbose := lang.NewKeyword("verbose") + kw_vf := lang.NewKeyword("vf") + kw_via := lang.NewKeyword("via") + kw_when := lang.NewKeyword("when") + kw_while := lang.NewKeyword("while") + // var glojure.core.protocols/coll-reduce + var_glojure_DOT_core_DOT_protocols_coll_DASH_reduce := lang.InternVarName(sym_glojure_DOT_core_DOT_protocols, sym_coll_DASH_reduce) + // var glojure.core.protocols/interface-or-naive-reduce + var_glojure_DOT_core_DOT_protocols_interface_DASH_or_DASH_naive_DASH_reduce := lang.InternVarName(sym_glojure_DOT_core_DOT_protocols, sym_interface_DASH_or_DASH_naive_DASH_reduce) + // var glojure.core.protocols/kv-reduce + var_glojure_DOT_core_DOT_protocols_kv_DASH_reduce := lang.InternVarName(sym_glojure_DOT_core_DOT_protocols, sym_kv_DASH_reduce) + // var glojure.core.protocols/seq-reduce + var_glojure_DOT_core_DOT_protocols_seq_DASH_reduce := lang.InternVarName(sym_glojure_DOT_core_DOT_protocols, sym_seq_DASH_reduce) + // var glojure.core/NaN? + var_glojure_DOT_core_NaN_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_NaN_QMARK_) + // var glojure.core/StackTraceElement->vec + var_glojure_DOT_core_StackTraceElement_DASH__GT_vec := lang.InternVarName(sym_glojure_DOT_core, sym_StackTraceElement_DASH__GT_vec) + // var glojure.core/Throwable->map + var_glojure_DOT_core_Throwable_DASH__GT_map := lang.InternVarName(sym_glojure_DOT_core, sym_Throwable_DASH__GT_map) + // var glojure.core/- + var_glojure_DOT_core__DASH_ := lang.InternVarName(sym_glojure_DOT_core, sym__DASH_) + // var glojure.core/-> + var_glojure_DOT_core__DASH__GT_ := lang.InternVarName(sym_glojure_DOT_core, sym__DASH__GT_) + // var glojure.core/->> + var_glojure_DOT_core__DASH__GT__GT_ := lang.InternVarName(sym_glojure_DOT_core, sym__DASH__GT__GT_) + // var glojure.core/-' + var_glojure_DOT_core__DASH__TICK_ := lang.InternVarName(sym_glojure_DOT_core, sym__DASH__TICK_) + // var glojure.core/-protocols + var_glojure_DOT_core__DASH_protocols := lang.InternVarName(sym_glojure_DOT_core, sym__DASH_protocols) + // var glojure.core/.. + var_glojure_DOT_core__DOT__DOT_ := lang.InternVarName(sym_glojure_DOT_core, sym__DOT__DOT_) + // var glojure.core/= + var_glojure_DOT_core__EQ_ := lang.InternVarName(sym_glojure_DOT_core, sym__EQ_) + // var glojure.core/== + var_glojure_DOT_core__EQ__EQ_ := lang.InternVarName(sym_glojure_DOT_core, sym__EQ__EQ_) + // var glojure.core/> + var_glojure_DOT_core__GT_ := lang.InternVarName(sym_glojure_DOT_core, sym__GT_) + // var glojure.core/>0? + var_glojure_DOT_core__GT_0_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym__GT_0_QMARK_) + // var glojure.core/>1? + var_glojure_DOT_core__GT_1_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym__GT_1_QMARK_) + // var glojure.core/>= + var_glojure_DOT_core__GT__EQ_ := lang.InternVarName(sym_glojure_DOT_core, sym__GT__EQ_) + // var glojure.core/< + var_glojure_DOT_core__LT_ := lang.InternVarName(sym_glojure_DOT_core, sym__LT_) + // var glojure.core/<= + var_glojure_DOT_core__LT__EQ_ := lang.InternVarName(sym_glojure_DOT_core, sym__LT__EQ_) + // var glojure.core/+ + var_glojure_DOT_core__PLUS_ := lang.InternVarName(sym_glojure_DOT_core, sym__PLUS_) + // var glojure.core/+' + var_glojure_DOT_core__PLUS__TICK_ := lang.InternVarName(sym_glojure_DOT_core, sym__PLUS__TICK_) + // var glojure.core// + var_glojure_DOT_core__SLASH_ := lang.InternVarName(sym_glojure_DOT_core, sym__SLASH_) + // var glojure.core/* + var_glojure_DOT_core__STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_) + // var glojure.core/*1 + var_glojure_DOT_core__STAR_1 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_1) + // var glojure.core/*2 + var_glojure_DOT_core__STAR_2 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_2) + // var glojure.core/*3 + var_glojure_DOT_core__STAR_3 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_3) + // var glojure.core/*' + var_glojure_DOT_core__STAR__TICK_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR__TICK_) + // var glojure.core/*agent* + var_glojure_DOT_core__STAR_agent_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_agent_STAR_) + // var glojure.core/*assert* + var_glojure_DOT_core__STAR_assert_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_assert_STAR_) + // var glojure.core/*command-line-args* + var_glojure_DOT_core__STAR_command_DASH_line_DASH_args_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_command_DASH_line_DASH_args_STAR_) + // var glojure.core/*compile-files* + var_glojure_DOT_core__STAR_compile_DASH_files_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_compile_DASH_files_STAR_) + // var glojure.core/*compile-path* + var_glojure_DOT_core__STAR_compile_DASH_path_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_compile_DASH_path_STAR_) + // var glojure.core/*compiler-options* + var_glojure_DOT_core__STAR_compiler_DASH_options_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_compiler_DASH_options_STAR_) + // var glojure.core/*data-readers* + var_glojure_DOT_core__STAR_data_DASH_readers_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_data_DASH_readers_STAR_) + // var glojure.core/*default-data-reader-fn* + var_glojure_DOT_core__STAR_default_DASH_data_DASH_reader_DASH_fn_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_default_DASH_data_DASH_reader_DASH_fn_STAR_) + // var glojure.core/*e + var_glojure_DOT_core__STAR_e := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_e) + // var glojure.core/*err* + var_glojure_DOT_core__STAR_err_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_err_STAR_) + // var glojure.core/*file* + var_glojure_DOT_core__STAR_file_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_file_STAR_) + // var glojure.core/*flush-on-newline* + var_glojure_DOT_core__STAR_flush_DASH_on_DASH_newline_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_flush_DASH_on_DASH_newline_STAR_) + // var glojure.core/*in* + var_glojure_DOT_core__STAR_in_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_in_STAR_) + // var glojure.core/*loaded-libs* + var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_loaded_DASH_libs_STAR_) + // var glojure.core/*loading-verbosely* + var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_loading_DASH_verbosely_STAR_) + // var glojure.core/*ns* + var_glojure_DOT_core__STAR_ns_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_ns_STAR_) + // var glojure.core/*out* + var_glojure_DOT_core__STAR_out_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) + // var glojure.core/*pending-paths* + var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_pending_DASH_paths_STAR_) + // var glojure.core/*print-dup* + var_glojure_DOT_core__STAR_print_DASH_dup_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_print_DASH_dup_STAR_) + // var glojure.core/*print-length* + var_glojure_DOT_core__STAR_print_DASH_length_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_print_DASH_length_STAR_) + // var glojure.core/*print-level* + var_glojure_DOT_core__STAR_print_DASH_level_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_print_DASH_level_STAR_) + // var glojure.core/*print-meta* + var_glojure_DOT_core__STAR_print_DASH_meta_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_print_DASH_meta_STAR_) + // var glojure.core/*print-namespace-maps* + var_glojure_DOT_core__STAR_print_DASH_namespace_DASH_maps_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_print_DASH_namespace_DASH_maps_STAR_) + // var glojure.core/*print-readably* + var_glojure_DOT_core__STAR_print_DASH_readably_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_print_DASH_readably_STAR_) + // var glojure.core/*read-eval* + var_glojure_DOT_core__STAR_read_DASH_eval_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_read_DASH_eval_STAR_) + // var glojure.core/*repl* + var_glojure_DOT_core__STAR_repl_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_repl_STAR_) + // var glojure.core/*unchecked-math* + var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_unchecked_DASH_math_STAR_) + // var glojure.core/*verbose-defrecords* + var_glojure_DOT_core__STAR_verbose_DASH_defrecords_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_verbose_DASH_defrecords_STAR_) + // var glojure.core/*warn-on-reflection* + var_glojure_DOT_core__STAR_warn_DASH_on_DASH_reflection_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_warn_DASH_on_DASH_reflection_STAR_) + // var glojure.core/abs + var_glojure_DOT_core_abs := lang.InternVarName(sym_glojure_DOT_core, sym_abs) + // var glojure.core/accessor + var_glojure_DOT_core_accessor := lang.InternVarName(sym_glojure_DOT_core, sym_accessor) + // var glojure.core/aclone + var_glojure_DOT_core_aclone := lang.InternVarName(sym_glojure_DOT_core, sym_aclone) + // var glojure.core/add-classpath + var_glojure_DOT_core_add_DASH_classpath := lang.InternVarName(sym_glojure_DOT_core, sym_add_DASH_classpath) + // var glojure.core/add-doc-and-meta + var_glojure_DOT_core_add_DASH_doc_DASH_and_DASH_meta := lang.InternVarName(sym_glojure_DOT_core, sym_add_DASH_doc_DASH_and_DASH_meta) + // var glojure.core/add-watch + var_glojure_DOT_core_add_DASH_watch := lang.InternVarName(sym_glojure_DOT_core, sym_add_DASH_watch) + // var glojure.core/agent + var_glojure_DOT_core_agent := lang.InternVarName(sym_glojure_DOT_core, sym_agent) + // var glojure.core/agent-error + var_glojure_DOT_core_agent_DASH_error := lang.InternVarName(sym_glojure_DOT_core, sym_agent_DASH_error) + // var glojure.core/agent-errors + var_glojure_DOT_core_agent_DASH_errors := lang.InternVarName(sym_glojure_DOT_core, sym_agent_DASH_errors) + // var glojure.core/aget + var_glojure_DOT_core_aget := lang.InternVarName(sym_glojure_DOT_core, sym_aget) + // var glojure.core/alength + var_glojure_DOT_core_alength := lang.InternVarName(sym_glojure_DOT_core, sym_alength) + // var glojure.core/alias + var_glojure_DOT_core_alias := lang.InternVarName(sym_glojure_DOT_core, sym_alias) + // var glojure.core/all-ns + var_glojure_DOT_core_all_DASH_ns := lang.InternVarName(sym_glojure_DOT_core, sym_all_DASH_ns) + // var glojure.core/alter + var_glojure_DOT_core_alter := lang.InternVarName(sym_glojure_DOT_core, sym_alter) + // var glojure.core/alter-meta! + var_glojure_DOT_core_alter_DASH_meta_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_alter_DASH_meta_BANG_) + // var glojure.core/alter-var-root + var_glojure_DOT_core_alter_DASH_var_DASH_root := lang.InternVarName(sym_glojure_DOT_core, sym_alter_DASH_var_DASH_root) + // var glojure.core/amap + var_glojure_DOT_core_amap := lang.InternVarName(sym_glojure_DOT_core, sym_amap) + // var glojure.core/ancestors + var_glojure_DOT_core_ancestors := lang.InternVarName(sym_glojure_DOT_core, sym_ancestors) + // var glojure.core/and + var_glojure_DOT_core_and := lang.InternVarName(sym_glojure_DOT_core, sym_and) + // var glojure.core/any? + var_glojure_DOT_core_any_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_any_QMARK_) + // var glojure.core/apply + var_glojure_DOT_core_apply := lang.InternVarName(sym_glojure_DOT_core, sym_apply) + // var glojure.core/areduce + var_glojure_DOT_core_areduce := lang.InternVarName(sym_glojure_DOT_core, sym_areduce) + // var glojure.core/array + var_glojure_DOT_core_array := lang.InternVarName(sym_glojure_DOT_core, sym_array) + // var glojure.core/array-map + var_glojure_DOT_core_array_DASH_map := lang.InternVarName(sym_glojure_DOT_core, sym_array_DASH_map) + // var glojure.core/as-> + var_glojure_DOT_core_as_DASH__GT_ := lang.InternVarName(sym_glojure_DOT_core, sym_as_DASH__GT_) + // var glojure.core/aset + var_glojure_DOT_core_aset := lang.InternVarName(sym_glojure_DOT_core, sym_aset) + // var glojure.core/aset-boolean + var_glojure_DOT_core_aset_DASH_boolean := lang.InternVarName(sym_glojure_DOT_core, sym_aset_DASH_boolean) + // var glojure.core/aset-byte + var_glojure_DOT_core_aset_DASH_byte := lang.InternVarName(sym_glojure_DOT_core, sym_aset_DASH_byte) + // var glojure.core/aset-char + var_glojure_DOT_core_aset_DASH_char := lang.InternVarName(sym_glojure_DOT_core, sym_aset_DASH_char) + // var glojure.core/aset-double + var_glojure_DOT_core_aset_DASH_double := lang.InternVarName(sym_glojure_DOT_core, sym_aset_DASH_double) + // var glojure.core/aset-float + var_glojure_DOT_core_aset_DASH_float := lang.InternVarName(sym_glojure_DOT_core, sym_aset_DASH_float) + // var glojure.core/aset-int + var_glojure_DOT_core_aset_DASH_int := lang.InternVarName(sym_glojure_DOT_core, sym_aset_DASH_int) + // var glojure.core/aset-long + var_glojure_DOT_core_aset_DASH_long := lang.InternVarName(sym_glojure_DOT_core, sym_aset_DASH_long) + // var glojure.core/aset-short + var_glojure_DOT_core_aset_DASH_short := lang.InternVarName(sym_glojure_DOT_core, sym_aset_DASH_short) + // var glojure.core/assert + var_glojure_DOT_core_assert := lang.InternVarName(sym_glojure_DOT_core, sym_assert) + // var glojure.core/assert-args + var_glojure_DOT_core_assert_DASH_args := lang.InternVarName(sym_glojure_DOT_core, sym_assert_DASH_args) + // var glojure.core/assert-valid-fdecl + var_glojure_DOT_core_assert_DASH_valid_DASH_fdecl := lang.InternVarName(sym_glojure_DOT_core, sym_assert_DASH_valid_DASH_fdecl) + // var glojure.core/assoc + var_glojure_DOT_core_assoc := lang.InternVarName(sym_glojure_DOT_core, sym_assoc) + // var glojure.core/assoc! + var_glojure_DOT_core_assoc_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_assoc_BANG_) + // var glojure.core/assoc-in + var_glojure_DOT_core_assoc_DASH_in := lang.InternVarName(sym_glojure_DOT_core, sym_assoc_DASH_in) + // var glojure.core/associative? + var_glojure_DOT_core_associative_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_associative_QMARK_) + // var glojure.core/atom + var_glojure_DOT_core_atom := lang.InternVarName(sym_glojure_DOT_core, sym_atom) + // var glojure.core/await + var_glojure_DOT_core_await := lang.InternVarName(sym_glojure_DOT_core, sym_await) + // var glojure.core/await1 + var_glojure_DOT_core_await1 := lang.InternVarName(sym_glojure_DOT_core, sym_await1) + // var glojure.core/await-for + var_glojure_DOT_core_await_DASH_for := lang.InternVarName(sym_glojure_DOT_core, sym_await_DASH_for) + // var glojure.core/bases + var_glojure_DOT_core_bases := lang.InternVarName(sym_glojure_DOT_core, sym_bases) + // var glojure.core/bigdec + var_glojure_DOT_core_bigdec := lang.InternVarName(sym_glojure_DOT_core, sym_bigdec) + // var glojure.core/bigint + var_glojure_DOT_core_bigint := lang.InternVarName(sym_glojure_DOT_core, sym_bigint) + // var glojure.core/biginteger + var_glojure_DOT_core_biginteger := lang.InternVarName(sym_glojure_DOT_core, sym_biginteger) + // var glojure.core/binding + var_glojure_DOT_core_binding := lang.InternVarName(sym_glojure_DOT_core, sym_binding) + // var glojure.core/binding-conveyor-fn + var_glojure_DOT_core_binding_DASH_conveyor_DASH_fn := lang.InternVarName(sym_glojure_DOT_core, sym_binding_DASH_conveyor_DASH_fn) + // var glojure.core/bit-and + var_glojure_DOT_core_bit_DASH_and := lang.InternVarName(sym_glojure_DOT_core, sym_bit_DASH_and) + // var glojure.core/bit-and-not + var_glojure_DOT_core_bit_DASH_and_DASH_not := lang.InternVarName(sym_glojure_DOT_core, sym_bit_DASH_and_DASH_not) + // var glojure.core/bit-clear + var_glojure_DOT_core_bit_DASH_clear := lang.InternVarName(sym_glojure_DOT_core, sym_bit_DASH_clear) + // var glojure.core/bit-flip + var_glojure_DOT_core_bit_DASH_flip := lang.InternVarName(sym_glojure_DOT_core, sym_bit_DASH_flip) + // var glojure.core/bit-not + var_glojure_DOT_core_bit_DASH_not := lang.InternVarName(sym_glojure_DOT_core, sym_bit_DASH_not) + // var glojure.core/bit-or + var_glojure_DOT_core_bit_DASH_or := lang.InternVarName(sym_glojure_DOT_core, sym_bit_DASH_or) + // var glojure.core/bit-set + var_glojure_DOT_core_bit_DASH_set := lang.InternVarName(sym_glojure_DOT_core, sym_bit_DASH_set) + // var glojure.core/bit-shift-left + var_glojure_DOT_core_bit_DASH_shift_DASH_left := lang.InternVarName(sym_glojure_DOT_core, sym_bit_DASH_shift_DASH_left) + // var glojure.core/bit-shift-right + var_glojure_DOT_core_bit_DASH_shift_DASH_right := lang.InternVarName(sym_glojure_DOT_core, sym_bit_DASH_shift_DASH_right) + // var glojure.core/bit-test + var_glojure_DOT_core_bit_DASH_test := lang.InternVarName(sym_glojure_DOT_core, sym_bit_DASH_test) + // var glojure.core/bit-xor + var_glojure_DOT_core_bit_DASH_xor := lang.InternVarName(sym_glojure_DOT_core, sym_bit_DASH_xor) + // var glojure.core/boolean + var_glojure_DOT_core_boolean := lang.InternVarName(sym_glojure_DOT_core, sym_boolean) + // var glojure.core/boolean-array + var_glojure_DOT_core_boolean_DASH_array := lang.InternVarName(sym_glojure_DOT_core, sym_boolean_DASH_array) + // var glojure.core/boolean? + var_glojure_DOT_core_boolean_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_boolean_QMARK_) + // var glojure.core/booleans + var_glojure_DOT_core_booleans := lang.InternVarName(sym_glojure_DOT_core, sym_booleans) + // var glojure.core/bound-fn + var_glojure_DOT_core_bound_DASH_fn := lang.InternVarName(sym_glojure_DOT_core, sym_bound_DASH_fn) + // var glojure.core/bound-fn* + var_glojure_DOT_core_bound_DASH_fn_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym_bound_DASH_fn_STAR_) + // var glojure.core/bound? + var_glojure_DOT_core_bound_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_bound_QMARK_) + // var glojure.core/bounded-count + var_glojure_DOT_core_bounded_DASH_count := lang.InternVarName(sym_glojure_DOT_core, sym_bounded_DASH_count) + // var glojure.core/butlast + var_glojure_DOT_core_butlast := lang.InternVarName(sym_glojure_DOT_core, sym_butlast) + // var glojure.core/byte + var_glojure_DOT_core_byte := lang.InternVarName(sym_glojure_DOT_core, sym_byte) + // var glojure.core/byte-array + var_glojure_DOT_core_byte_DASH_array := lang.InternVarName(sym_glojure_DOT_core, sym_byte_DASH_array) + // var glojure.core/bytes + var_glojure_DOT_core_bytes := lang.InternVarName(sym_glojure_DOT_core, sym_bytes) + // var glojure.core/bytes? + var_glojure_DOT_core_bytes_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_bytes_QMARK_) + // var glojure.core/case + var_glojure_DOT_core_case := lang.InternVarName(sym_glojure_DOT_core, sym_case) + // var glojure.core/case-map + var_glojure_DOT_core_case_DASH_map := lang.InternVarName(sym_glojure_DOT_core, sym_case_DASH_map) + // var glojure.core/cast + var_glojure_DOT_core_cast := lang.InternVarName(sym_glojure_DOT_core, sym_cast) + // var glojure.core/cat + var_glojure_DOT_core_cat := lang.InternVarName(sym_glojure_DOT_core, sym_cat) + // var glojure.core/char + var_glojure_DOT_core_char := lang.InternVarName(sym_glojure_DOT_core, sym_char) + // var glojure.core/char-array + var_glojure_DOT_core_char_DASH_array := lang.InternVarName(sym_glojure_DOT_core, sym_char_DASH_array) + // var glojure.core/char-escape-string + var_glojure_DOT_core_char_DASH_escape_DASH_string := lang.InternVarName(sym_glojure_DOT_core, sym_char_DASH_escape_DASH_string) + // var glojure.core/char-name-string + var_glojure_DOT_core_char_DASH_name_DASH_string := lang.InternVarName(sym_glojure_DOT_core, sym_char_DASH_name_DASH_string) + // var glojure.core/char? + var_glojure_DOT_core_char_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_char_QMARK_) + // var glojure.core/chars + var_glojure_DOT_core_chars := lang.InternVarName(sym_glojure_DOT_core, sym_chars) + // var glojure.core/check-cyclic-dependency + var_glojure_DOT_core_check_DASH_cyclic_DASH_dependency := lang.InternVarName(sym_glojure_DOT_core, sym_check_DASH_cyclic_DASH_dependency) + // var glojure.core/check-valid-options + var_glojure_DOT_core_check_DASH_valid_DASH_options := lang.InternVarName(sym_glojure_DOT_core, sym_check_DASH_valid_DASH_options) + // var glojure.core/chunk + var_glojure_DOT_core_chunk := lang.InternVarName(sym_glojure_DOT_core, sym_chunk) + // var glojure.core/chunk-append + var_glojure_DOT_core_chunk_DASH_append := lang.InternVarName(sym_glojure_DOT_core, sym_chunk_DASH_append) + // var glojure.core/chunk-buffer + var_glojure_DOT_core_chunk_DASH_buffer := lang.InternVarName(sym_glojure_DOT_core, sym_chunk_DASH_buffer) + // var glojure.core/chunk-cons + var_glojure_DOT_core_chunk_DASH_cons := lang.InternVarName(sym_glojure_DOT_core, sym_chunk_DASH_cons) + // var glojure.core/chunk-first + var_glojure_DOT_core_chunk_DASH_first := lang.InternVarName(sym_glojure_DOT_core, sym_chunk_DASH_first) + // var glojure.core/chunk-next + var_glojure_DOT_core_chunk_DASH_next := lang.InternVarName(sym_glojure_DOT_core, sym_chunk_DASH_next) + // var glojure.core/chunk-rest + var_glojure_DOT_core_chunk_DASH_rest := lang.InternVarName(sym_glojure_DOT_core, sym_chunk_DASH_rest) + // var glojure.core/chunked-seq? + var_glojure_DOT_core_chunked_DASH_seq_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_chunked_DASH_seq_QMARK_) + // var glojure.core/class + var_glojure_DOT_core_class := lang.InternVarName(sym_glojure_DOT_core, sym_class) + // var glojure.core/class? + var_glojure_DOT_core_class_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_class_QMARK_) + // var glojure.core/clear-agent-errors + var_glojure_DOT_core_clear_DASH_agent_DASH_errors := lang.InternVarName(sym_glojure_DOT_core, sym_clear_DASH_agent_DASH_errors) + // var glojure.core/coll? + var_glojure_DOT_core_coll_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_coll_QMARK_) + // var glojure.core/comment + var_glojure_DOT_core_comment := lang.InternVarName(sym_glojure_DOT_core, sym_comment) + // var glojure.core/commute + var_glojure_DOT_core_commute := lang.InternVarName(sym_glojure_DOT_core, sym_commute) + // var glojure.core/comp + var_glojure_DOT_core_comp := lang.InternVarName(sym_glojure_DOT_core, sym_comp) + // var glojure.core/comparator + var_glojure_DOT_core_comparator := lang.InternVarName(sym_glojure_DOT_core, sym_comparator) + // var glojure.core/compare + var_glojure_DOT_core_compare := lang.InternVarName(sym_glojure_DOT_core, sym_compare) + // var glojure.core/compare-and-set! + var_glojure_DOT_core_compare_DASH_and_DASH_set_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_compare_DASH_and_DASH_set_BANG_) + // var glojure.core/compile + var_glojure_DOT_core_compile := lang.InternVarName(sym_glojure_DOT_core, sym_compile) + // var glojure.core/complement + var_glojure_DOT_core_complement := lang.InternVarName(sym_glojure_DOT_core, sym_complement) + // var glojure.core/completing + var_glojure_DOT_core_completing := lang.InternVarName(sym_glojure_DOT_core, sym_completing) + // var glojure.core/concat + var_glojure_DOT_core_concat := lang.InternVarName(sym_glojure_DOT_core, sym_concat) + // var glojure.core/cond + var_glojure_DOT_core_cond := lang.InternVarName(sym_glojure_DOT_core, sym_cond) + // var glojure.core/cond-> + var_glojure_DOT_core_cond_DASH__GT_ := lang.InternVarName(sym_glojure_DOT_core, sym_cond_DASH__GT_) + // var glojure.core/cond->> + var_glojure_DOT_core_cond_DASH__GT__GT_ := lang.InternVarName(sym_glojure_DOT_core, sym_cond_DASH__GT__GT_) + // var glojure.core/condp + var_glojure_DOT_core_condp := lang.InternVarName(sym_glojure_DOT_core, sym_condp) + // var glojure.core/conj + var_glojure_DOT_core_conj := lang.InternVarName(sym_glojure_DOT_core, sym_conj) + // var glojure.core/conj! + var_glojure_DOT_core_conj_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_conj_BANG_) + // var glojure.core/cons + var_glojure_DOT_core_cons := lang.InternVarName(sym_glojure_DOT_core, sym_cons) + // var glojure.core/constantly + var_glojure_DOT_core_constantly := lang.InternVarName(sym_glojure_DOT_core, sym_constantly) + // var glojure.core/contains? + var_glojure_DOT_core_contains_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_contains_QMARK_) + // var glojure.core/count + var_glojure_DOT_core_count := lang.InternVarName(sym_glojure_DOT_core, sym_count) + // var glojure.core/counted? + var_glojure_DOT_core_counted_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_counted_QMARK_) + // var glojure.core/create-ns + var_glojure_DOT_core_create_DASH_ns := lang.InternVarName(sym_glojure_DOT_core, sym_create_DASH_ns) + // var glojure.core/create-struct + var_glojure_DOT_core_create_DASH_struct := lang.InternVarName(sym_glojure_DOT_core, sym_create_DASH_struct) + // var glojure.core/cycle + var_glojure_DOT_core_cycle := lang.InternVarName(sym_glojure_DOT_core, sym_cycle) + // var glojure.core/data-reader-urls + var_glojure_DOT_core_data_DASH_reader_DASH_urls := lang.InternVarName(sym_glojure_DOT_core, sym_data_DASH_reader_DASH_urls) + // var glojure.core/data-reader-var + var_glojure_DOT_core_data_DASH_reader_DASH_var := lang.InternVarName(sym_glojure_DOT_core, sym_data_DASH_reader_DASH_var) + // var glojure.core/dec + var_glojure_DOT_core_dec := lang.InternVarName(sym_glojure_DOT_core, sym_dec) + // var glojure.core/dec' + var_glojure_DOT_core_dec_TICK_ := lang.InternVarName(sym_glojure_DOT_core, sym_dec_TICK_) + // var glojure.core/decimal? + var_glojure_DOT_core_decimal_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_decimal_QMARK_) + // var glojure.core/declare + var_glojure_DOT_core_declare := lang.InternVarName(sym_glojure_DOT_core, sym_declare) + // var glojure.core/dedupe + var_glojure_DOT_core_dedupe := lang.InternVarName(sym_glojure_DOT_core, sym_dedupe) + // var glojure.core/def-aset + var_glojure_DOT_core_def_DASH_aset := lang.InternVarName(sym_glojure_DOT_core, sym_def_DASH_aset) + // var glojure.core/definline + var_glojure_DOT_core_definline := lang.InternVarName(sym_glojure_DOT_core, sym_definline) + // var glojure.core/defmacro + var_glojure_DOT_core_defmacro := lang.InternVarName(sym_glojure_DOT_core, sym_defmacro) + // var glojure.core/defmethod + var_glojure_DOT_core_defmethod := lang.InternVarName(sym_glojure_DOT_core, sym_defmethod) + // var glojure.core/defmulti + var_glojure_DOT_core_defmulti := lang.InternVarName(sym_glojure_DOT_core, sym_defmulti) + // var glojure.core/defn + var_glojure_DOT_core_defn := lang.InternVarName(sym_glojure_DOT_core, sym_defn) + // var glojure.core/defn- + var_glojure_DOT_core_defn_DASH_ := lang.InternVarName(sym_glojure_DOT_core, sym_defn_DASH_) + // var glojure.core/defonce + var_glojure_DOT_core_defonce := lang.InternVarName(sym_glojure_DOT_core, sym_defonce) + // var glojure.core/defprotocol + var_glojure_DOT_core_defprotocol := lang.InternVarName(sym_glojure_DOT_core, sym_defprotocol) + // var glojure.core/defstruct + var_glojure_DOT_core_defstruct := lang.InternVarName(sym_glojure_DOT_core, sym_defstruct) + // var glojure.core/delay + var_glojure_DOT_core_delay := lang.InternVarName(sym_glojure_DOT_core, sym_delay) + // var glojure.core/delay? + var_glojure_DOT_core_delay_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_delay_QMARK_) + // var glojure.core/deliver + var_glojure_DOT_core_deliver := lang.InternVarName(sym_glojure_DOT_core, sym_deliver) + // var glojure.core/denominator + var_glojure_DOT_core_denominator := lang.InternVarName(sym_glojure_DOT_core, sym_denominator) + // var glojure.core/deref + var_glojure_DOT_core_deref := lang.InternVarName(sym_glojure_DOT_core, sym_deref) + // var glojure.core/deref-as-map + var_glojure_DOT_core_deref_DASH_as_DASH_map := lang.InternVarName(sym_glojure_DOT_core, sym_deref_DASH_as_DASH_map) + // var glojure.core/deref-future + var_glojure_DOT_core_deref_DASH_future := lang.InternVarName(sym_glojure_DOT_core, sym_deref_DASH_future) + // var glojure.core/derive + var_glojure_DOT_core_derive := lang.InternVarName(sym_glojure_DOT_core, sym_derive) + // var glojure.core/descendants + var_glojure_DOT_core_descendants := lang.InternVarName(sym_glojure_DOT_core, sym_descendants) + // var glojure.core/destructure + var_glojure_DOT_core_destructure := lang.InternVarName(sym_glojure_DOT_core, sym_destructure) + // var glojure.core/disj + var_glojure_DOT_core_disj := lang.InternVarName(sym_glojure_DOT_core, sym_disj) + // var glojure.core/disj! + var_glojure_DOT_core_disj_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_disj_BANG_) + // var glojure.core/dissoc + var_glojure_DOT_core_dissoc := lang.InternVarName(sym_glojure_DOT_core, sym_dissoc) + // var glojure.core/dissoc! + var_glojure_DOT_core_dissoc_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_dissoc_BANG_) + // var glojure.core/distinct + var_glojure_DOT_core_distinct := lang.InternVarName(sym_glojure_DOT_core, sym_distinct) + // var glojure.core/distinct? + var_glojure_DOT_core_distinct_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_distinct_QMARK_) + // var glojure.core/doall + var_glojure_DOT_core_doall := lang.InternVarName(sym_glojure_DOT_core, sym_doall) + // var glojure.core/dorun + var_glojure_DOT_core_dorun := lang.InternVarName(sym_glojure_DOT_core, sym_dorun) + // var glojure.core/doseq + var_glojure_DOT_core_doseq := lang.InternVarName(sym_glojure_DOT_core, sym_doseq) + // var glojure.core/dosync + var_glojure_DOT_core_dosync := lang.InternVarName(sym_glojure_DOT_core, sym_dosync) + // var glojure.core/dotimes + var_glojure_DOT_core_dotimes := lang.InternVarName(sym_glojure_DOT_core, sym_dotimes) + // var glojure.core/doto + var_glojure_DOT_core_doto := lang.InternVarName(sym_glojure_DOT_core, sym_doto) + // var glojure.core/double + var_glojure_DOT_core_double := lang.InternVarName(sym_glojure_DOT_core, sym_double) + // var glojure.core/double-array + var_glojure_DOT_core_double_DASH_array := lang.InternVarName(sym_glojure_DOT_core, sym_double_DASH_array) + // var glojure.core/double? + var_glojure_DOT_core_double_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_double_QMARK_) + // var glojure.core/doubles + var_glojure_DOT_core_doubles := lang.InternVarName(sym_glojure_DOT_core, sym_doubles) + // var glojure.core/drop + var_glojure_DOT_core_drop := lang.InternVarName(sym_glojure_DOT_core, sym_drop) + // var glojure.core/drop-last + var_glojure_DOT_core_drop_DASH_last := lang.InternVarName(sym_glojure_DOT_core, sym_drop_DASH_last) + // var glojure.core/drop-while + var_glojure_DOT_core_drop_DASH_while := lang.InternVarName(sym_glojure_DOT_core, sym_drop_DASH_while) + // var glojure.core/elide-top-frames + var_glojure_DOT_core_elide_DASH_top_DASH_frames := lang.InternVarName(sym_glojure_DOT_core, sym_elide_DASH_top_DASH_frames) + // var glojure.core/emit-extend-protocol + var_glojure_DOT_core_emit_DASH_extend_DASH_protocol := lang.InternVarName(sym_glojure_DOT_core, sym_emit_DASH_extend_DASH_protocol) + // var glojure.core/emit-extend-type + var_glojure_DOT_core_emit_DASH_extend_DASH_type := lang.InternVarName(sym_glojure_DOT_core, sym_emit_DASH_extend_DASH_type) + // var glojure.core/emit-hinted-impl + var_glojure_DOT_core_emit_DASH_hinted_DASH_impl := lang.InternVarName(sym_glojure_DOT_core, sym_emit_DASH_hinted_DASH_impl) + // var glojure.core/empty + var_glojure_DOT_core_empty := lang.InternVarName(sym_glojure_DOT_core, sym_empty) + // var glojure.core/empty? + var_glojure_DOT_core_empty_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_empty_QMARK_) + // var glojure.core/ensure + var_glojure_DOT_core_ensure := lang.InternVarName(sym_glojure_DOT_core, sym_ensure) + // var glojure.core/ensure-reduced + var_glojure_DOT_core_ensure_DASH_reduced := lang.InternVarName(sym_glojure_DOT_core, sym_ensure_DASH_reduced) + // var glojure.core/enumeration-seq + var_glojure_DOT_core_enumeration_DASH_seq := lang.InternVarName(sym_glojure_DOT_core, sym_enumeration_DASH_seq) + // var glojure.core/error-handler + var_glojure_DOT_core_error_DASH_handler := lang.InternVarName(sym_glojure_DOT_core, sym_error_DASH_handler) + // var glojure.core/error-mode + var_glojure_DOT_core_error_DASH_mode := lang.InternVarName(sym_glojure_DOT_core, sym_error_DASH_mode) + // var glojure.core/eval + var_glojure_DOT_core_eval := lang.InternVarName(sym_glojure_DOT_core, sym_eval) + // var glojure.core/even? + var_glojure_DOT_core_even_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_even_QMARK_) + // var glojure.core/every-pred + var_glojure_DOT_core_every_DASH_pred := lang.InternVarName(sym_glojure_DOT_core, sym_every_DASH_pred) + // var glojure.core/every? + var_glojure_DOT_core_every_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_every_QMARK_) + // var glojure.core/ex-cause + var_glojure_DOT_core_ex_DASH_cause := lang.InternVarName(sym_glojure_DOT_core, sym_ex_DASH_cause) + // var glojure.core/ex-data + var_glojure_DOT_core_ex_DASH_data := lang.InternVarName(sym_glojure_DOT_core, sym_ex_DASH_data) + // var glojure.core/ex-info + var_glojure_DOT_core_ex_DASH_info := lang.InternVarName(sym_glojure_DOT_core, sym_ex_DASH_info) + // var glojure.core/ex-message + var_glojure_DOT_core_ex_DASH_message := lang.InternVarName(sym_glojure_DOT_core, sym_ex_DASH_message) + // var glojure.core/extend + var_glojure_DOT_core_extend := lang.InternVarName(sym_glojure_DOT_core, sym_extend) + // var glojure.core/extend-protocol + var_glojure_DOT_core_extend_DASH_protocol := lang.InternVarName(sym_glojure_DOT_core, sym_extend_DASH_protocol) + // var glojure.core/extend-type + var_glojure_DOT_core_extend_DASH_type := lang.InternVarName(sym_glojure_DOT_core, sym_extend_DASH_type) + // var glojure.core/false? + var_glojure_DOT_core_false_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_false_QMARK_) + // var glojure.core/ffirst + var_glojure_DOT_core_ffirst := lang.InternVarName(sym_glojure_DOT_core, sym_ffirst) + // var glojure.core/file-seq + var_glojure_DOT_core_file_DASH_seq := lang.InternVarName(sym_glojure_DOT_core, sym_file_DASH_seq) + // var glojure.core/filter + var_glojure_DOT_core_filter := lang.InternVarName(sym_glojure_DOT_core, sym_filter) + // var glojure.core/filter-key + var_glojure_DOT_core_filter_DASH_key := lang.InternVarName(sym_glojure_DOT_core, sym_filter_DASH_key) + // var glojure.core/filterv + var_glojure_DOT_core_filterv := lang.InternVarName(sym_glojure_DOT_core, sym_filterv) + // var glojure.core/find + var_glojure_DOT_core_find := lang.InternVarName(sym_glojure_DOT_core, sym_find) + // var glojure.core/find-keyword + var_glojure_DOT_core_find_DASH_keyword := lang.InternVarName(sym_glojure_DOT_core, sym_find_DASH_keyword) + // var glojure.core/find-ns + var_glojure_DOT_core_find_DASH_ns := lang.InternVarName(sym_glojure_DOT_core, sym_find_DASH_ns) + // var glojure.core/find-var + var_glojure_DOT_core_find_DASH_var := lang.InternVarName(sym_glojure_DOT_core, sym_find_DASH_var) + // var glojure.core/first + var_glojure_DOT_core_first := lang.InternVarName(sym_glojure_DOT_core, sym_first) + // var glojure.core/fits-table? + var_glojure_DOT_core_fits_DASH_table_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_fits_DASH_table_QMARK_) + // var glojure.core/flatten + var_glojure_DOT_core_flatten := lang.InternVarName(sym_glojure_DOT_core, sym_flatten) + // var glojure.core/float + var_glojure_DOT_core_float := lang.InternVarName(sym_glojure_DOT_core, sym_float) + // var glojure.core/float-array + var_glojure_DOT_core_float_DASH_array := lang.InternVarName(sym_glojure_DOT_core, sym_float_DASH_array) + // var glojure.core/float? + var_glojure_DOT_core_float_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_float_QMARK_) + // var glojure.core/floats + var_glojure_DOT_core_floats := lang.InternVarName(sym_glojure_DOT_core, sym_floats) + // var glojure.core/flush + var_glojure_DOT_core_flush := lang.InternVarName(sym_glojure_DOT_core, sym_flush) + // var glojure.core/fn + var_glojure_DOT_core_fn := lang.InternVarName(sym_glojure_DOT_core, sym_fn) + // var glojure.core/fn? + var_glojure_DOT_core_fn_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_fn_QMARK_) + // var glojure.core/fnext + var_glojure_DOT_core_fnext := lang.InternVarName(sym_glojure_DOT_core, sym_fnext) + // var glojure.core/fnil + var_glojure_DOT_core_fnil := lang.InternVarName(sym_glojure_DOT_core, sym_fnil) + // var glojure.core/for + var_glojure_DOT_core_for := lang.InternVarName(sym_glojure_DOT_core, sym_for) + // var glojure.core/force + var_glojure_DOT_core_force := lang.InternVarName(sym_glojure_DOT_core, sym_force) + // var glojure.core/format + var_glojure_DOT_core_format := lang.InternVarName(sym_glojure_DOT_core, sym_format) + // var glojure.core/frequencies + var_glojure_DOT_core_frequencies := lang.InternVarName(sym_glojure_DOT_core, sym_frequencies) + // var glojure.core/future + var_glojure_DOT_core_future := lang.InternVarName(sym_glojure_DOT_core, sym_future) + // var glojure.core/future-call + var_glojure_DOT_core_future_DASH_call := lang.InternVarName(sym_glojure_DOT_core, sym_future_DASH_call) + // var glojure.core/future-cancel + var_glojure_DOT_core_future_DASH_cancel := lang.InternVarName(sym_glojure_DOT_core, sym_future_DASH_cancel) + // var glojure.core/future-cancelled? + var_glojure_DOT_core_future_DASH_cancelled_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_future_DASH_cancelled_QMARK_) + // var glojure.core/future-done? + var_glojure_DOT_core_future_DASH_done_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_future_DASH_done_QMARK_) + // var glojure.core/future? + var_glojure_DOT_core_future_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_future_QMARK_) + // var glojure.core/gen-class + var_glojure_DOT_core_gen_DASH_class := lang.InternVarName(sym_glojure_DOT_core, sym_gen_DASH_class) + // var glojure.core/gensym + var_glojure_DOT_core_gensym := lang.InternVarName(sym_glojure_DOT_core, sym_gensym) + // var glojure.core/get + var_glojure_DOT_core_get := lang.InternVarName(sym_glojure_DOT_core, sym_get) + // var glojure.core/get-in + var_glojure_DOT_core_get_DASH_in := lang.InternVarName(sym_glojure_DOT_core, sym_get_DASH_in) + // var glojure.core/get-method + var_glojure_DOT_core_get_DASH_method := lang.InternVarName(sym_glojure_DOT_core, sym_get_DASH_method) + // var glojure.core/get-thread-bindings + var_glojure_DOT_core_get_DASH_thread_DASH_bindings := lang.InternVarName(sym_glojure_DOT_core, sym_get_DASH_thread_DASH_bindings) + // var glojure.core/get-validator + var_glojure_DOT_core_get_DASH_validator := lang.InternVarName(sym_glojure_DOT_core, sym_get_DASH_validator) + // var glojure.core/global-hierarchy + var_glojure_DOT_core_global_DASH_hierarchy := lang.InternVarName(sym_glojure_DOT_core, sym_global_DASH_hierarchy) + // var glojure.core/group-by + var_glojure_DOT_core_group_DASH_by := lang.InternVarName(sym_glojure_DOT_core, sym_group_DASH_by) + // var glojure.core/halt-when + var_glojure_DOT_core_halt_DASH_when := lang.InternVarName(sym_glojure_DOT_core, sym_halt_DASH_when) + // var glojure.core/hash + var_glojure_DOT_core_hash := lang.InternVarName(sym_glojure_DOT_core, sym_hash) + // var glojure.core/hash-map + var_glojure_DOT_core_hash_DASH_map := lang.InternVarName(sym_glojure_DOT_core, sym_hash_DASH_map) + // var glojure.core/hash-ordered-coll + var_glojure_DOT_core_hash_DASH_ordered_DASH_coll := lang.InternVarName(sym_glojure_DOT_core, sym_hash_DASH_ordered_DASH_coll) + // var glojure.core/hash-set + var_glojure_DOT_core_hash_DASH_set := lang.InternVarName(sym_glojure_DOT_core, sym_hash_DASH_set) + // var glojure.core/hash-unordered-coll + var_glojure_DOT_core_hash_DASH_unordered_DASH_coll := lang.InternVarName(sym_glojure_DOT_core, sym_hash_DASH_unordered_DASH_coll) + // var glojure.core/ident? + var_glojure_DOT_core_ident_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_ident_QMARK_) + // var glojure.core/identical? + var_glojure_DOT_core_identical_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_identical_QMARK_) + // var glojure.core/identity + var_glojure_DOT_core_identity := lang.InternVarName(sym_glojure_DOT_core, sym_identity) + // var glojure.core/if-let + var_glojure_DOT_core_if_DASH_let := lang.InternVarName(sym_glojure_DOT_core, sym_if_DASH_let) + // var glojure.core/if-not + var_glojure_DOT_core_if_DASH_not := lang.InternVarName(sym_glojure_DOT_core, sym_if_DASH_not) + // var glojure.core/if-some + var_glojure_DOT_core_if_DASH_some := lang.InternVarName(sym_glojure_DOT_core, sym_if_DASH_some) + // var glojure.core/ifn? + var_glojure_DOT_core_ifn_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_ifn_QMARK_) + // var glojure.core/import + var_glojure_DOT_core_import := lang.InternVarName(sym_glojure_DOT_core, sym_import) + // var glojure.core/inc + var_glojure_DOT_core_inc := lang.InternVarName(sym_glojure_DOT_core, sym_inc) + // var glojure.core/inc' + var_glojure_DOT_core_inc_TICK_ := lang.InternVarName(sym_glojure_DOT_core, sym_inc_TICK_) + // var glojure.core/indexed? + var_glojure_DOT_core_indexed_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_indexed_QMARK_) + // var glojure.core/infinite? + var_glojure_DOT_core_infinite_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_infinite_QMARK_) + // var glojure.core/inst-ms + var_glojure_DOT_core_inst_DASH_ms := lang.InternVarName(sym_glojure_DOT_core, sym_inst_DASH_ms) + // var glojure.core/inst? + var_glojure_DOT_core_inst_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_inst_QMARK_) + // var glojure.core/instance? + var_glojure_DOT_core_instance_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_instance_QMARK_) + // var glojure.core/int + var_glojure_DOT_core_int := lang.InternVarName(sym_glojure_DOT_core, sym_int) + // var glojure.core/int-array + var_glojure_DOT_core_int_DASH_array := lang.InternVarName(sym_glojure_DOT_core, sym_int_DASH_array) + // var glojure.core/int? + var_glojure_DOT_core_int_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_int_QMARK_) + // var glojure.core/integer? + var_glojure_DOT_core_integer_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_integer_QMARK_) + // var glojure.core/interleave + var_glojure_DOT_core_interleave := lang.InternVarName(sym_glojure_DOT_core, sym_interleave) + // var glojure.core/intern + var_glojure_DOT_core_intern := lang.InternVarName(sym_glojure_DOT_core, sym_intern) + // var glojure.core/interpose + var_glojure_DOT_core_interpose := lang.InternVarName(sym_glojure_DOT_core, sym_interpose) + // var glojure.core/into + var_glojure_DOT_core_into := lang.InternVarName(sym_glojure_DOT_core, sym_into) + // var glojure.core/into1 + var_glojure_DOT_core_into1 := lang.InternVarName(sym_glojure_DOT_core, sym_into1) + // var glojure.core/into-array + var_glojure_DOT_core_into_DASH_array := lang.InternVarName(sym_glojure_DOT_core, sym_into_DASH_array) + // var glojure.core/ints + var_glojure_DOT_core_ints := lang.InternVarName(sym_glojure_DOT_core, sym_ints) + // var glojure.core/io! + var_glojure_DOT_core_io_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_io_BANG_) + // var glojure.core/isa? + var_glojure_DOT_core_isa_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_isa_QMARK_) + // var glojure.core/iterate + var_glojure_DOT_core_iterate := lang.InternVarName(sym_glojure_DOT_core, sym_iterate) + // var glojure.core/iteration + var_glojure_DOT_core_iteration := lang.InternVarName(sym_glojure_DOT_core, sym_iteration) + // var glojure.core/iterator-seq + var_glojure_DOT_core_iterator_DASH_seq := lang.InternVarName(sym_glojure_DOT_core, sym_iterator_DASH_seq) + // var glojure.core/juxt + var_glojure_DOT_core_juxt := lang.InternVarName(sym_glojure_DOT_core, sym_juxt) + // var glojure.core/keep + var_glojure_DOT_core_keep := lang.InternVarName(sym_glojure_DOT_core, sym_keep) + // var glojure.core/keep-indexed + var_glojure_DOT_core_keep_DASH_indexed := lang.InternVarName(sym_glojure_DOT_core, sym_keep_DASH_indexed) + // var glojure.core/key + var_glojure_DOT_core_key := lang.InternVarName(sym_glojure_DOT_core, sym_key) + // var glojure.core/keys + var_glojure_DOT_core_keys := lang.InternVarName(sym_glojure_DOT_core, sym_keys) + // var glojure.core/keyword + var_glojure_DOT_core_keyword := lang.InternVarName(sym_glojure_DOT_core, sym_keyword) + // var glojure.core/keyword? + var_glojure_DOT_core_keyword_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_keyword_QMARK_) + // var glojure.core/last + var_glojure_DOT_core_last := lang.InternVarName(sym_glojure_DOT_core, sym_last) + // var glojure.core/lazy-cat + var_glojure_DOT_core_lazy_DASH_cat := lang.InternVarName(sym_glojure_DOT_core, sym_lazy_DASH_cat) + // var glojure.core/lazy-seq + var_glojure_DOT_core_lazy_DASH_seq := lang.InternVarName(sym_glojure_DOT_core, sym_lazy_DASH_seq) + // var glojure.core/let + var_glojure_DOT_core_let := lang.InternVarName(sym_glojure_DOT_core, sym_let) + // var glojure.core/letfn + var_glojure_DOT_core_letfn := lang.InternVarName(sym_glojure_DOT_core, sym_letfn) + // var glojure.core/libspec? + var_glojure_DOT_core_libspec_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_libspec_QMARK_) + // var glojure.core/lift-ns + var_glojure_DOT_core_lift_DASH_ns := lang.InternVarName(sym_glojure_DOT_core, sym_lift_DASH_ns) + // var glojure.core/line-seq + var_glojure_DOT_core_line_DASH_seq := lang.InternVarName(sym_glojure_DOT_core, sym_line_DASH_seq) + // var glojure.core/list + var_glojure_DOT_core_list := lang.InternVarName(sym_glojure_DOT_core, sym_list) + // var glojure.core/list? + var_glojure_DOT_core_list_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_list_QMARK_) + // var glojure.core/list* + var_glojure_DOT_core_list_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym_list_STAR_) + // var glojure.core/load + var_glojure_DOT_core_load := lang.InternVarName(sym_glojure_DOT_core, sym_load) + // var glojure.core/load-all + var_glojure_DOT_core_load_DASH_all := lang.InternVarName(sym_glojure_DOT_core, sym_load_DASH_all) + // var glojure.core/load-data-reader-file + var_glojure_DOT_core_load_DASH_data_DASH_reader_DASH_file := lang.InternVarName(sym_glojure_DOT_core, sym_load_DASH_data_DASH_reader_DASH_file) + // var glojure.core/load-data-readers + var_glojure_DOT_core_load_DASH_data_DASH_readers := lang.InternVarName(sym_glojure_DOT_core, sym_load_DASH_data_DASH_readers) + // var glojure.core/load-file + var_glojure_DOT_core_load_DASH_file := lang.InternVarName(sym_glojure_DOT_core, sym_load_DASH_file) + // var glojure.core/load-lib + var_glojure_DOT_core_load_DASH_lib := lang.InternVarName(sym_glojure_DOT_core, sym_load_DASH_lib) + // var glojure.core/load-libs + var_glojure_DOT_core_load_DASH_libs := lang.InternVarName(sym_glojure_DOT_core, sym_load_DASH_libs) + // var glojure.core/load-one + var_glojure_DOT_core_load_DASH_one := lang.InternVarName(sym_glojure_DOT_core, sym_load_DASH_one) + // var glojure.core/load-reader + var_glojure_DOT_core_load_DASH_reader := lang.InternVarName(sym_glojure_DOT_core, sym_load_DASH_reader) + // var glojure.core/load-string + var_glojure_DOT_core_load_DASH_string := lang.InternVarName(sym_glojure_DOT_core, sym_load_DASH_string) + // var glojure.core/loaded-libs + var_glojure_DOT_core_loaded_DASH_libs := lang.InternVarName(sym_glojure_DOT_core, sym_loaded_DASH_libs) + // var glojure.core/locking + var_glojure_DOT_core_locking := lang.InternVarName(sym_glojure_DOT_core, sym_locking) + // var glojure.core/long + var_glojure_DOT_core_long := lang.InternVarName(sym_glojure_DOT_core, sym_long) + // var glojure.core/long-array + var_glojure_DOT_core_long_DASH_array := lang.InternVarName(sym_glojure_DOT_core, sym_long_DASH_array) + // var glojure.core/longs + var_glojure_DOT_core_longs := lang.InternVarName(sym_glojure_DOT_core, sym_longs) + // var glojure.core/loop + var_glojure_DOT_core_loop := lang.InternVarName(sym_glojure_DOT_core, sym_loop) + // var glojure.core/macroexpand + var_glojure_DOT_core_macroexpand := lang.InternVarName(sym_glojure_DOT_core, sym_macroexpand) + // var glojure.core/macroexpand-1 + var_glojure_DOT_core_macroexpand_DASH_1 := lang.InternVarName(sym_glojure_DOT_core, sym_macroexpand_DASH_1) + // var glojure.core/make-array + var_glojure_DOT_core_make_DASH_array := lang.InternVarName(sym_glojure_DOT_core, sym_make_DASH_array) + // var glojure.core/make-hierarchy + var_glojure_DOT_core_make_DASH_hierarchy := lang.InternVarName(sym_glojure_DOT_core, sym_make_DASH_hierarchy) + // var glojure.core/map + var_glojure_DOT_core_map := lang.InternVarName(sym_glojure_DOT_core, sym_map) + // var glojure.core/map-entry? + var_glojure_DOT_core_map_DASH_entry_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_map_DASH_entry_QMARK_) + // var glojure.core/map-indexed + var_glojure_DOT_core_map_DASH_indexed := lang.InternVarName(sym_glojure_DOT_core, sym_map_DASH_indexed) + // var glojure.core/map? + var_glojure_DOT_core_map_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_map_QMARK_) + // var glojure.core/mapcat + var_glojure_DOT_core_mapcat := lang.InternVarName(sym_glojure_DOT_core, sym_mapcat) + // var glojure.core/mapv + var_glojure_DOT_core_mapv := lang.InternVarName(sym_glojure_DOT_core, sym_mapv) + // var glojure.core/max + var_glojure_DOT_core_max := lang.InternVarName(sym_glojure_DOT_core, sym_max) + // var glojure.core/max-key + var_glojure_DOT_core_max_DASH_key := lang.InternVarName(sym_glojure_DOT_core, sym_max_DASH_key) + // var glojure.core/max-mask-bits + var_glojure_DOT_core_max_DASH_mask_DASH_bits := lang.InternVarName(sym_glojure_DOT_core, sym_max_DASH_mask_DASH_bits) + // var glojure.core/max-switch-table-size + var_glojure_DOT_core_max_DASH_switch_DASH_table_DASH_size := lang.InternVarName(sym_glojure_DOT_core, sym_max_DASH_switch_DASH_table_DASH_size) + // var glojure.core/maybe-destructured + var_glojure_DOT_core_maybe_DASH_destructured := lang.InternVarName(sym_glojure_DOT_core, sym_maybe_DASH_destructured) + // var glojure.core/maybe-min-hash + var_glojure_DOT_core_maybe_DASH_min_DASH_hash := lang.InternVarName(sym_glojure_DOT_core, sym_maybe_DASH_min_DASH_hash) + // var glojure.core/memfn + var_glojure_DOT_core_memfn := lang.InternVarName(sym_glojure_DOT_core, sym_memfn) + // var glojure.core/memoize + var_glojure_DOT_core_memoize := lang.InternVarName(sym_glojure_DOT_core, sym_memoize) + // var glojure.core/merge + var_glojure_DOT_core_merge := lang.InternVarName(sym_glojure_DOT_core, sym_merge) + // var glojure.core/merge-hash-collisions + var_glojure_DOT_core_merge_DASH_hash_DASH_collisions := lang.InternVarName(sym_glojure_DOT_core, sym_merge_DASH_hash_DASH_collisions) + // var glojure.core/merge-with + var_glojure_DOT_core_merge_DASH_with := lang.InternVarName(sym_glojure_DOT_core, sym_merge_DASH_with) + // var glojure.core/meta + var_glojure_DOT_core_meta := lang.InternVarName(sym_glojure_DOT_core, sym_meta) + // var glojure.core/methods + var_glojure_DOT_core_methods := lang.InternVarName(sym_glojure_DOT_core, sym_methods) + // var glojure.core/min + var_glojure_DOT_core_min := lang.InternVarName(sym_glojure_DOT_core, sym_min) + // var glojure.core/min-key + var_glojure_DOT_core_min_DASH_key := lang.InternVarName(sym_glojure_DOT_core, sym_min_DASH_key) + // var glojure.core/mix-collection-hash + var_glojure_DOT_core_mix_DASH_collection_DASH_hash := lang.InternVarName(sym_glojure_DOT_core, sym_mix_DASH_collection_DASH_hash) + // var glojure.core/mk-bound-fn + var_glojure_DOT_core_mk_DASH_bound_DASH_fn := lang.InternVarName(sym_glojure_DOT_core, sym_mk_DASH_bound_DASH_fn) + // var glojure.core/mod + var_glojure_DOT_core_mod := lang.InternVarName(sym_glojure_DOT_core, sym_mod) + // var glojure.core/name + var_glojure_DOT_core_name := lang.InternVarName(sym_glojure_DOT_core, sym_name) + // var glojure.core/namespace + var_glojure_DOT_core_namespace := lang.InternVarName(sym_glojure_DOT_core, sym_namespace) + // var glojure.core/nary-inline + var_glojure_DOT_core_nary_DASH_inline := lang.InternVarName(sym_glojure_DOT_core, sym_nary_DASH_inline) + // var glojure.core/nat-int? + var_glojure_DOT_core_nat_DASH_int_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_nat_DASH_int_QMARK_) + // var glojure.core/neg-int? + var_glojure_DOT_core_neg_DASH_int_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_neg_DASH_int_QMARK_) + // var glojure.core/neg? + var_glojure_DOT_core_neg_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_neg_QMARK_) + // var glojure.core/newline + var_glojure_DOT_core_newline := lang.InternVarName(sym_glojure_DOT_core, sym_newline) + // var glojure.core/next + var_glojure_DOT_core_next := lang.InternVarName(sym_glojure_DOT_core, sym_next) + // var glojure.core/nfirst + var_glojure_DOT_core_nfirst := lang.InternVarName(sym_glojure_DOT_core, sym_nfirst) + // var glojure.core/nil? + var_glojure_DOT_core_nil_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_nil_QMARK_) + // var glojure.core/nnext + var_glojure_DOT_core_nnext := lang.InternVarName(sym_glojure_DOT_core, sym_nnext) + // var glojure.core/normalize-slurp-opts + var_glojure_DOT_core_normalize_DASH_slurp_DASH_opts := lang.InternVarName(sym_glojure_DOT_core, sym_normalize_DASH_slurp_DASH_opts) + // var glojure.core/not + var_glojure_DOT_core_not := lang.InternVarName(sym_glojure_DOT_core, sym_not) + // var glojure.core/not-any? + var_glojure_DOT_core_not_DASH_any_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_not_DASH_any_QMARK_) + // var glojure.core/not-empty + var_glojure_DOT_core_not_DASH_empty := lang.InternVarName(sym_glojure_DOT_core, sym_not_DASH_empty) + // var glojure.core/not-every? + var_glojure_DOT_core_not_DASH_every_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_not_DASH_every_QMARK_) + // var glojure.core/not= + var_glojure_DOT_core_not_EQ_ := lang.InternVarName(sym_glojure_DOT_core, sym_not_EQ_) + // var glojure.core/ns + var_glojure_DOT_core_ns := lang.InternVarName(sym_glojure_DOT_core, sym_ns) + // var glojure.core/ns-aliases + var_glojure_DOT_core_ns_DASH_aliases := lang.InternVarName(sym_glojure_DOT_core, sym_ns_DASH_aliases) + // var glojure.core/ns-imports + var_glojure_DOT_core_ns_DASH_imports := lang.InternVarName(sym_glojure_DOT_core, sym_ns_DASH_imports) + // var glojure.core/ns-interns + var_glojure_DOT_core_ns_DASH_interns := lang.InternVarName(sym_glojure_DOT_core, sym_ns_DASH_interns) + // var glojure.core/ns-map + var_glojure_DOT_core_ns_DASH_map := lang.InternVarName(sym_glojure_DOT_core, sym_ns_DASH_map) + // var glojure.core/ns-name + var_glojure_DOT_core_ns_DASH_name := lang.InternVarName(sym_glojure_DOT_core, sym_ns_DASH_name) + // var glojure.core/ns-publics + var_glojure_DOT_core_ns_DASH_publics := lang.InternVarName(sym_glojure_DOT_core, sym_ns_DASH_publics) + // var glojure.core/ns-refers + var_glojure_DOT_core_ns_DASH_refers := lang.InternVarName(sym_glojure_DOT_core, sym_ns_DASH_refers) + // var glojure.core/ns-resolve + var_glojure_DOT_core_ns_DASH_resolve := lang.InternVarName(sym_glojure_DOT_core, sym_ns_DASH_resolve) + // var glojure.core/ns-unalias + var_glojure_DOT_core_ns_DASH_unalias := lang.InternVarName(sym_glojure_DOT_core, sym_ns_DASH_unalias) + // var glojure.core/ns-unmap + var_glojure_DOT_core_ns_DASH_unmap := lang.InternVarName(sym_glojure_DOT_core, sym_ns_DASH_unmap) + // var glojure.core/nth + var_glojure_DOT_core_nth := lang.InternVarName(sym_glojure_DOT_core, sym_nth) + // var glojure.core/nthnext + var_glojure_DOT_core_nthnext := lang.InternVarName(sym_glojure_DOT_core, sym_nthnext) + // var glojure.core/nthrest + var_glojure_DOT_core_nthrest := lang.InternVarName(sym_glojure_DOT_core, sym_nthrest) + // var glojure.core/num + var_glojure_DOT_core_num := lang.InternVarName(sym_glojure_DOT_core, sym_num) + // var glojure.core/number? + var_glojure_DOT_core_number_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_number_QMARK_) + // var glojure.core/numerator + var_glojure_DOT_core_numerator := lang.InternVarName(sym_glojure_DOT_core, sym_numerator) + // var glojure.core/object-array + var_glojure_DOT_core_object_DASH_array := lang.InternVarName(sym_glojure_DOT_core, sym_object_DASH_array) + // var glojure.core/odd? + var_glojure_DOT_core_odd_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_odd_QMARK_) + // var glojure.core/or + var_glojure_DOT_core_or := lang.InternVarName(sym_glojure_DOT_core, sym_or) + // var glojure.core/parents + var_glojure_DOT_core_parents := lang.InternVarName(sym_glojure_DOT_core, sym_parents) + // var glojure.core/parse-boolean + var_glojure_DOT_core_parse_DASH_boolean := lang.InternVarName(sym_glojure_DOT_core, sym_parse_DASH_boolean) + // var glojure.core/parse-double + var_glojure_DOT_core_parse_DASH_double := lang.InternVarName(sym_glojure_DOT_core, sym_parse_DASH_double) + // var glojure.core/parse-impls + var_glojure_DOT_core_parse_DASH_impls := lang.InternVarName(sym_glojure_DOT_core, sym_parse_DASH_impls) + // var glojure.core/parse-long + var_glojure_DOT_core_parse_DASH_long := lang.InternVarName(sym_glojure_DOT_core, sym_parse_DASH_long) + // var glojure.core/parse-uuid + var_glojure_DOT_core_parse_DASH_uuid := lang.InternVarName(sym_glojure_DOT_core, sym_parse_DASH_uuid) + // var glojure.core/parsing-err + var_glojure_DOT_core_parsing_DASH_err := lang.InternVarName(sym_glojure_DOT_core, sym_parsing_DASH_err) + // var glojure.core/partial + var_glojure_DOT_core_partial := lang.InternVarName(sym_glojure_DOT_core, sym_partial) + // var glojure.core/partition + var_glojure_DOT_core_partition := lang.InternVarName(sym_glojure_DOT_core, sym_partition) + // var glojure.core/partition-all + var_glojure_DOT_core_partition_DASH_all := lang.InternVarName(sym_glojure_DOT_core, sym_partition_DASH_all) + // var glojure.core/partition-by + var_glojure_DOT_core_partition_DASH_by := lang.InternVarName(sym_glojure_DOT_core, sym_partition_DASH_by) + // var glojure.core/partitionv + var_glojure_DOT_core_partitionv := lang.InternVarName(sym_glojure_DOT_core, sym_partitionv) + // var glojure.core/partitionv-all + var_glojure_DOT_core_partitionv_DASH_all := lang.InternVarName(sym_glojure_DOT_core, sym_partitionv_DASH_all) + // var glojure.core/pcalls + var_glojure_DOT_core_pcalls := lang.InternVarName(sym_glojure_DOT_core, sym_pcalls) + // var glojure.core/peek + var_glojure_DOT_core_peek := lang.InternVarName(sym_glojure_DOT_core, sym_peek) + // var glojure.core/persistent! + var_glojure_DOT_core_persistent_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_persistent_BANG_) + // var glojure.core/pmap + var_glojure_DOT_core_pmap := lang.InternVarName(sym_glojure_DOT_core, sym_pmap) + // var glojure.core/pop + var_glojure_DOT_core_pop := lang.InternVarName(sym_glojure_DOT_core, sym_pop) + // var glojure.core/pop! + var_glojure_DOT_core_pop_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_pop_BANG_) + // var glojure.core/pop-thread-bindings + var_glojure_DOT_core_pop_DASH_thread_DASH_bindings := lang.InternVarName(sym_glojure_DOT_core, sym_pop_DASH_thread_DASH_bindings) + // var glojure.core/pos-int? + var_glojure_DOT_core_pos_DASH_int_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_pos_DASH_int_QMARK_) + // var glojure.core/pos? + var_glojure_DOT_core_pos_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_pos_QMARK_) + // var glojure.core/pr + var_glojure_DOT_core_pr := lang.InternVarName(sym_glojure_DOT_core, sym_pr) + // var glojure.core/pr-on + var_glojure_DOT_core_pr_DASH_on := lang.InternVarName(sym_glojure_DOT_core, sym_pr_DASH_on) + // var glojure.core/pr-str + var_glojure_DOT_core_pr_DASH_str := lang.InternVarName(sym_glojure_DOT_core, sym_pr_DASH_str) + // var glojure.core/prefer-method + var_glojure_DOT_core_prefer_DASH_method := lang.InternVarName(sym_glojure_DOT_core, sym_prefer_DASH_method) + // var glojure.core/prefers + var_glojure_DOT_core_prefers := lang.InternVarName(sym_glojure_DOT_core, sym_prefers) + // var glojure.core/prep-hashes + var_glojure_DOT_core_prep_DASH_hashes := lang.InternVarName(sym_glojure_DOT_core, sym_prep_DASH_hashes) + // var glojure.core/prep-ints + var_glojure_DOT_core_prep_DASH_ints := lang.InternVarName(sym_glojure_DOT_core, sym_prep_DASH_ints) + // var glojure.core/prependss + var_glojure_DOT_core_prependss := lang.InternVarName(sym_glojure_DOT_core, sym_prependss) + // var glojure.core/preserving-reduced + var_glojure_DOT_core_preserving_DASH_reduced := lang.InternVarName(sym_glojure_DOT_core, sym_preserving_DASH_reduced) + // var glojure.core/print + var_glojure_DOT_core_print := lang.InternVarName(sym_glojure_DOT_core, sym_print) + // var glojure.core/print-ctor + var_glojure_DOT_core_print_DASH_ctor := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_ctor) + // var glojure.core/print-dup + var_glojure_DOT_core_print_DASH_dup := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_dup) + // var glojure.core/print-initialized + var_glojure_DOT_core_print_DASH_initialized := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_initialized) + // var glojure.core/print-map + var_glojure_DOT_core_print_DASH_map := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_map) + // var glojure.core/print-meta + var_glojure_DOT_core_print_DASH_meta := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_meta) + // var glojure.core/print-method + var_glojure_DOT_core_print_DASH_method := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_method) + // var glojure.core/print-object + var_glojure_DOT_core_print_DASH_object := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_object) + // var glojure.core/print-prefix-map + var_glojure_DOT_core_print_DASH_prefix_DASH_map := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_prefix_DASH_map) + // var glojure.core/print-sequential + var_glojure_DOT_core_print_DASH_sequential := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_sequential) + // var glojure.core/print-simple + var_glojure_DOT_core_print_DASH_simple := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_simple) + // var glojure.core/print-str + var_glojure_DOT_core_print_DASH_str := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_str) + // var glojure.core/print-tagged-object + var_glojure_DOT_core_print_DASH_tagged_DASH_object := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_tagged_DASH_object) + // var glojure.core/print-throwable + var_glojure_DOT_core_print_DASH_throwable := lang.InternVarName(sym_glojure_DOT_core, sym_print_DASH_throwable) + // var glojure.core/printf + var_glojure_DOT_core_printf := lang.InternVarName(sym_glojure_DOT_core, sym_printf) + // var glojure.core/println + var_glojure_DOT_core_println := lang.InternVarName(sym_glojure_DOT_core, sym_println) + // var glojure.core/println-str + var_glojure_DOT_core_println_DASH_str := lang.InternVarName(sym_glojure_DOT_core, sym_println_DASH_str) + // var glojure.core/prn + var_glojure_DOT_core_prn := lang.InternVarName(sym_glojure_DOT_core, sym_prn) + // var glojure.core/prn-str + var_glojure_DOT_core_prn_DASH_str := lang.InternVarName(sym_glojure_DOT_core, sym_prn_DASH_str) + // var glojure.core/promise + var_glojure_DOT_core_promise := lang.InternVarName(sym_glojure_DOT_core, sym_promise) + // var glojure.core/protocol? + var_glojure_DOT_core_protocol_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_protocol_QMARK_) + // var glojure.core/push-thread-bindings + var_glojure_DOT_core_push_DASH_thread_DASH_bindings := lang.InternVarName(sym_glojure_DOT_core, sym_push_DASH_thread_DASH_bindings) + // var glojure.core/pvalues + var_glojure_DOT_core_pvalues := lang.InternVarName(sym_glojure_DOT_core, sym_pvalues) + // var glojure.core/qualified-ident? + var_glojure_DOT_core_qualified_DASH_ident_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_qualified_DASH_ident_QMARK_) + // var glojure.core/qualified-keyword? + var_glojure_DOT_core_qualified_DASH_keyword_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_qualified_DASH_keyword_QMARK_) + // var glojure.core/qualified-symbol? + var_glojure_DOT_core_qualified_DASH_symbol_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_qualified_DASH_symbol_QMARK_) + // var glojure.core/quot + var_glojure_DOT_core_quot := lang.InternVarName(sym_glojure_DOT_core, sym_quot) + // var glojure.core/rand + var_glojure_DOT_core_rand := lang.InternVarName(sym_glojure_DOT_core, sym_rand) + // var glojure.core/rand-int + var_glojure_DOT_core_rand_DASH_int := lang.InternVarName(sym_glojure_DOT_core, sym_rand_DASH_int) + // var glojure.core/rand-nth + var_glojure_DOT_core_rand_DASH_nth := lang.InternVarName(sym_glojure_DOT_core, sym_rand_DASH_nth) + // var glojure.core/random-sample + var_glojure_DOT_core_random_DASH_sample := lang.InternVarName(sym_glojure_DOT_core, sym_random_DASH_sample) + // var glojure.core/random-uuid + var_glojure_DOT_core_random_DASH_uuid := lang.InternVarName(sym_glojure_DOT_core, sym_random_DASH_uuid) + // var glojure.core/range + var_glojure_DOT_core_range := lang.InternVarName(sym_glojure_DOT_core, sym_range) + // var glojure.core/ratio? + var_glojure_DOT_core_ratio_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_ratio_QMARK_) + // var glojure.core/rational? + var_glojure_DOT_core_rational_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_rational_QMARK_) + // var glojure.core/rationalize + var_glojure_DOT_core_rationalize := lang.InternVarName(sym_glojure_DOT_core, sym_rationalize) + // var glojure.core/re-find + var_glojure_DOT_core_re_DASH_find := lang.InternVarName(sym_glojure_DOT_core, sym_re_DASH_find) + // var glojure.core/re-groups + var_glojure_DOT_core_re_DASH_groups := lang.InternVarName(sym_glojure_DOT_core, sym_re_DASH_groups) + // var glojure.core/re-matcher + var_glojure_DOT_core_re_DASH_matcher := lang.InternVarName(sym_glojure_DOT_core, sym_re_DASH_matcher) + // var glojure.core/re-matches + var_glojure_DOT_core_re_DASH_matches := lang.InternVarName(sym_glojure_DOT_core, sym_re_DASH_matches) + // var glojure.core/re-pattern + var_glojure_DOT_core_re_DASH_pattern := lang.InternVarName(sym_glojure_DOT_core, sym_re_DASH_pattern) + // var glojure.core/re-seq + var_glojure_DOT_core_re_DASH_seq := lang.InternVarName(sym_glojure_DOT_core, sym_re_DASH_seq) + // var glojure.core/read + var_glojure_DOT_core_read := lang.InternVarName(sym_glojure_DOT_core, sym_read) + // var glojure.core/read-line + var_glojure_DOT_core_read_DASH_line := lang.InternVarName(sym_glojure_DOT_core, sym_read_DASH_line) + // var glojure.core/read-string + var_glojure_DOT_core_read_DASH_string := lang.InternVarName(sym_glojure_DOT_core, sym_read_DASH_string) + // var glojure.core/read+string + var_glojure_DOT_core_read_PLUS_string := lang.InternVarName(sym_glojure_DOT_core, sym_read_PLUS_string) + // var glojure.core/reader-conditional + var_glojure_DOT_core_reader_DASH_conditional := lang.InternVarName(sym_glojure_DOT_core, sym_reader_DASH_conditional) + // var glojure.core/reader-conditional? + var_glojure_DOT_core_reader_DASH_conditional_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_reader_DASH_conditional_QMARK_) + // var glojure.core/realized? + var_glojure_DOT_core_realized_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_realized_QMARK_) + // var glojure.core/reduce + var_glojure_DOT_core_reduce := lang.InternVarName(sym_glojure_DOT_core, sym_reduce) + // var glojure.core/reduce1 + var_glojure_DOT_core_reduce1 := lang.InternVarName(sym_glojure_DOT_core, sym_reduce1) + // var glojure.core/reduce-kv + var_glojure_DOT_core_reduce_DASH_kv := lang.InternVarName(sym_glojure_DOT_core, sym_reduce_DASH_kv) + // var glojure.core/reduced + var_glojure_DOT_core_reduced := lang.InternVarName(sym_glojure_DOT_core, sym_reduced) + // var glojure.core/reduced? + var_glojure_DOT_core_reduced_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_reduced_QMARK_) + // var glojure.core/reductions + var_glojure_DOT_core_reductions := lang.InternVarName(sym_glojure_DOT_core, sym_reductions) + // var glojure.core/ref + var_glojure_DOT_core_ref := lang.InternVarName(sym_glojure_DOT_core, sym_ref) + // var glojure.core/ref-history-count + var_glojure_DOT_core_ref_DASH_history_DASH_count := lang.InternVarName(sym_glojure_DOT_core, sym_ref_DASH_history_DASH_count) + // var glojure.core/ref-max-history + var_glojure_DOT_core_ref_DASH_max_DASH_history := lang.InternVarName(sym_glojure_DOT_core, sym_ref_DASH_max_DASH_history) + // var glojure.core/ref-min-history + var_glojure_DOT_core_ref_DASH_min_DASH_history := lang.InternVarName(sym_glojure_DOT_core, sym_ref_DASH_min_DASH_history) + // var glojure.core/ref-set + var_glojure_DOT_core_ref_DASH_set := lang.InternVarName(sym_glojure_DOT_core, sym_ref_DASH_set) + // var glojure.core/refer + var_glojure_DOT_core_refer := lang.InternVarName(sym_glojure_DOT_core, sym_refer) + // var glojure.core/refer-glojure + var_glojure_DOT_core_refer_DASH_glojure := lang.InternVarName(sym_glojure_DOT_core, sym_refer_DASH_glojure) + // var glojure.core/release-pending-sends + var_glojure_DOT_core_release_DASH_pending_DASH_sends := lang.InternVarName(sym_glojure_DOT_core, sym_release_DASH_pending_DASH_sends) + // var glojure.core/rem + var_glojure_DOT_core_rem := lang.InternVarName(sym_glojure_DOT_core, sym_rem) + // var glojure.core/remove + var_glojure_DOT_core_remove := lang.InternVarName(sym_glojure_DOT_core, sym_remove) + // var glojure.core/remove-all-methods + var_glojure_DOT_core_remove_DASH_all_DASH_methods := lang.InternVarName(sym_glojure_DOT_core, sym_remove_DASH_all_DASH_methods) + // var glojure.core/remove-method + var_glojure_DOT_core_remove_DASH_method := lang.InternVarName(sym_glojure_DOT_core, sym_remove_DASH_method) + // var glojure.core/remove-ns + var_glojure_DOT_core_remove_DASH_ns := lang.InternVarName(sym_glojure_DOT_core, sym_remove_DASH_ns) + // var glojure.core/remove-tap + var_glojure_DOT_core_remove_DASH_tap := lang.InternVarName(sym_glojure_DOT_core, sym_remove_DASH_tap) + // var glojure.core/remove-watch + var_glojure_DOT_core_remove_DASH_watch := lang.InternVarName(sym_glojure_DOT_core, sym_remove_DASH_watch) + // var glojure.core/repeat + var_glojure_DOT_core_repeat := lang.InternVarName(sym_glojure_DOT_core, sym_repeat) + // var glojure.core/repeatedly + var_glojure_DOT_core_repeatedly := lang.InternVarName(sym_glojure_DOT_core, sym_repeatedly) + // var glojure.core/replace + var_glojure_DOT_core_replace := lang.InternVarName(sym_glojure_DOT_core, sym_replace) + // var glojure.core/replicate + var_glojure_DOT_core_replicate := lang.InternVarName(sym_glojure_DOT_core, sym_replicate) + // var glojure.core/require + var_glojure_DOT_core_require := lang.InternVarName(sym_glojure_DOT_core, sym_require) + // var glojure.core/requiring-resolve + var_glojure_DOT_core_requiring_DASH_resolve := lang.InternVarName(sym_glojure_DOT_core, sym_requiring_DASH_resolve) + // var glojure.core/reset! + var_glojure_DOT_core_reset_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_reset_BANG_) + // var glojure.core/reset-meta! + var_glojure_DOT_core_reset_DASH_meta_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_reset_DASH_meta_BANG_) + // var glojure.core/reset-vals! + var_glojure_DOT_core_reset_DASH_vals_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_reset_DASH_vals_BANG_) + // var glojure.core/resolve + var_glojure_DOT_core_resolve := lang.InternVarName(sym_glojure_DOT_core, sym_resolve) + // var glojure.core/rest + var_glojure_DOT_core_rest := lang.InternVarName(sym_glojure_DOT_core, sym_rest) + // var glojure.core/restart-agent + var_glojure_DOT_core_restart_DASH_agent := lang.InternVarName(sym_glojure_DOT_core, sym_restart_DASH_agent) + // var glojure.core/resultset-seq + var_glojure_DOT_core_resultset_DASH_seq := lang.InternVarName(sym_glojure_DOT_core, sym_resultset_DASH_seq) + // var glojure.core/reverse + var_glojure_DOT_core_reverse := lang.InternVarName(sym_glojure_DOT_core, sym_reverse) + // var glojure.core/reversible? + var_glojure_DOT_core_reversible_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_reversible_QMARK_) + // var glojure.core/root-directory + var_glojure_DOT_core_root_DASH_directory := lang.InternVarName(sym_glojure_DOT_core, sym_root_DASH_directory) + // var glojure.core/root-resource + var_glojure_DOT_core_root_DASH_resource := lang.InternVarName(sym_glojure_DOT_core, sym_root_DASH_resource) + // var glojure.core/rseq + var_glojure_DOT_core_rseq := lang.InternVarName(sym_glojure_DOT_core, sym_rseq) + // var glojure.core/rsubseq + var_glojure_DOT_core_rsubseq := lang.InternVarName(sym_glojure_DOT_core, sym_rsubseq) + // var glojure.core/run! + var_glojure_DOT_core_run_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_run_BANG_) + // var glojure.core/second + var_glojure_DOT_core_second := lang.InternVarName(sym_glojure_DOT_core, sym_second) + // var glojure.core/select-keys + var_glojure_DOT_core_select_DASH_keys := lang.InternVarName(sym_glojure_DOT_core, sym_select_DASH_keys) + // var glojure.core/send + var_glojure_DOT_core_send := lang.InternVarName(sym_glojure_DOT_core, sym_send) + // var glojure.core/send-off + var_glojure_DOT_core_send_DASH_off := lang.InternVarName(sym_glojure_DOT_core, sym_send_DASH_off) + // var glojure.core/send-via + var_glojure_DOT_core_send_DASH_via := lang.InternVarName(sym_glojure_DOT_core, sym_send_DASH_via) + // var glojure.core/seq + var_glojure_DOT_core_seq := lang.InternVarName(sym_glojure_DOT_core, sym_seq) + // var glojure.core/seq-to-map-for-destructuring + var_glojure_DOT_core_seq_DASH_to_DASH_map_DASH_for_DASH_destructuring := lang.InternVarName(sym_glojure_DOT_core, sym_seq_DASH_to_DASH_map_DASH_for_DASH_destructuring) + // var glojure.core/seq? + var_glojure_DOT_core_seq_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_seq_QMARK_) + // var glojure.core/seqable? + var_glojure_DOT_core_seqable_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_seqable_QMARK_) + // var glojure.core/seque + var_glojure_DOT_core_seque := lang.InternVarName(sym_glojure_DOT_core, sym_seque) + // var glojure.core/sequence + var_glojure_DOT_core_sequence := lang.InternVarName(sym_glojure_DOT_core, sym_sequence) + // var glojure.core/sequential? + var_glojure_DOT_core_sequential_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_sequential_QMARK_) + // var glojure.core/serialized-require + var_glojure_DOT_core_serialized_DASH_require := lang.InternVarName(sym_glojure_DOT_core, sym_serialized_DASH_require) + // var glojure.core/set + var_glojure_DOT_core_set := lang.InternVarName(sym_glojure_DOT_core, sym_set) + // var glojure.core/set-agent-send-executor! + var_glojure_DOT_core_set_DASH_agent_DASH_send_DASH_executor_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_set_DASH_agent_DASH_send_DASH_executor_BANG_) + // var glojure.core/set-agent-send-off-executor! + var_glojure_DOT_core_set_DASH_agent_DASH_send_DASH_off_DASH_executor_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_set_DASH_agent_DASH_send_DASH_off_DASH_executor_BANG_) + // var glojure.core/set-error-handler! + var_glojure_DOT_core_set_DASH_error_DASH_handler_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_set_DASH_error_DASH_handler_BANG_) + // var glojure.core/set-error-mode! + var_glojure_DOT_core_set_DASH_error_DASH_mode_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_set_DASH_error_DASH_mode_BANG_) + // var glojure.core/set-validator! + var_glojure_DOT_core_set_DASH_validator_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_set_DASH_validator_BANG_) + // var glojure.core/set? + var_glojure_DOT_core_set_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_set_QMARK_) + // var glojure.core/setup-reference + var_glojure_DOT_core_setup_DASH_reference := lang.InternVarName(sym_glojure_DOT_core, sym_setup_DASH_reference) + // var glojure.core/shift-mask + var_glojure_DOT_core_shift_DASH_mask := lang.InternVarName(sym_glojure_DOT_core, sym_shift_DASH_mask) + // var glojure.core/short + var_glojure_DOT_core_short := lang.InternVarName(sym_glojure_DOT_core, sym_short) + // var glojure.core/short-array + var_glojure_DOT_core_short_DASH_array := lang.InternVarName(sym_glojure_DOT_core, sym_short_DASH_array) + // var glojure.core/shorts + var_glojure_DOT_core_shorts := lang.InternVarName(sym_glojure_DOT_core, sym_shorts) + // var glojure.core/shuffle + var_glojure_DOT_core_shuffle := lang.InternVarName(sym_glojure_DOT_core, sym_shuffle) + // var glojure.core/shutdown-agents + var_glojure_DOT_core_shutdown_DASH_agents := lang.InternVarName(sym_glojure_DOT_core, sym_shutdown_DASH_agents) + // var glojure.core/sigs + var_glojure_DOT_core_sigs := lang.InternVarName(sym_glojure_DOT_core, sym_sigs) + // var glojure.core/simple-ident? + var_glojure_DOT_core_simple_DASH_ident_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_simple_DASH_ident_QMARK_) + // var glojure.core/simple-keyword? + var_glojure_DOT_core_simple_DASH_keyword_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_simple_DASH_keyword_QMARK_) + // var glojure.core/simple-symbol? + var_glojure_DOT_core_simple_DASH_symbol_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_simple_DASH_symbol_QMARK_) + // var glojure.core/slurp + var_glojure_DOT_core_slurp := lang.InternVarName(sym_glojure_DOT_core, sym_slurp) + // var glojure.core/some + var_glojure_DOT_core_some := lang.InternVarName(sym_glojure_DOT_core, sym_some) + // var glojure.core/some-> + var_glojure_DOT_core_some_DASH__GT_ := lang.InternVarName(sym_glojure_DOT_core, sym_some_DASH__GT_) + // var glojure.core/some->> + var_glojure_DOT_core_some_DASH__GT__GT_ := lang.InternVarName(sym_glojure_DOT_core, sym_some_DASH__GT__GT_) + // var glojure.core/some-fn + var_glojure_DOT_core_some_DASH_fn := lang.InternVarName(sym_glojure_DOT_core, sym_some_DASH_fn) + // var glojure.core/some? + var_glojure_DOT_core_some_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_some_QMARK_) + // var glojure.core/sort + var_glojure_DOT_core_sort := lang.InternVarName(sym_glojure_DOT_core, sym_sort) + // var glojure.core/sort-by + var_glojure_DOT_core_sort_DASH_by := lang.InternVarName(sym_glojure_DOT_core, sym_sort_DASH_by) + // var glojure.core/sorted-map + var_glojure_DOT_core_sorted_DASH_map := lang.InternVarName(sym_glojure_DOT_core, sym_sorted_DASH_map) + // var glojure.core/sorted-map-by + var_glojure_DOT_core_sorted_DASH_map_DASH_by := lang.InternVarName(sym_glojure_DOT_core, sym_sorted_DASH_map_DASH_by) + // var glojure.core/sorted-set + var_glojure_DOT_core_sorted_DASH_set := lang.InternVarName(sym_glojure_DOT_core, sym_sorted_DASH_set) + // var glojure.core/sorted-set-by + var_glojure_DOT_core_sorted_DASH_set_DASH_by := lang.InternVarName(sym_glojure_DOT_core, sym_sorted_DASH_set_DASH_by) + // var glojure.core/sorted? + var_glojure_DOT_core_sorted_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_sorted_QMARK_) + // var glojure.core/special-symbol? + var_glojure_DOT_core_special_DASH_symbol_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_special_DASH_symbol_QMARK_) + // var glojure.core/spit + var_glojure_DOT_core_spit := lang.InternVarName(sym_glojure_DOT_core, sym_spit) + // var glojure.core/split-at + var_glojure_DOT_core_split_DASH_at := lang.InternVarName(sym_glojure_DOT_core, sym_split_DASH_at) + // var glojure.core/split-with + var_glojure_DOT_core_split_DASH_with := lang.InternVarName(sym_glojure_DOT_core, sym_split_DASH_with) + // var glojure.core/splitv-at + var_glojure_DOT_core_splitv_DASH_at := lang.InternVarName(sym_glojure_DOT_core, sym_splitv_DASH_at) + // var glojure.core/spread + var_glojure_DOT_core_spread := lang.InternVarName(sym_glojure_DOT_core, sym_spread) + // var glojure.core/str + var_glojure_DOT_core_str := lang.InternVarName(sym_glojure_DOT_core, sym_str) + // var glojure.core/stream-into! + var_glojure_DOT_core_stream_DASH_into_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_stream_DASH_into_BANG_) + // var glojure.core/stream-reduce! + var_glojure_DOT_core_stream_DASH_reduce_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_stream_DASH_reduce_BANG_) + // var glojure.core/stream-seq! + var_glojure_DOT_core_stream_DASH_seq_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_stream_DASH_seq_BANG_) + // var glojure.core/stream-transduce! + var_glojure_DOT_core_stream_DASH_transduce_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_stream_DASH_transduce_BANG_) + // var glojure.core/string? + var_glojure_DOT_core_string_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_string_QMARK_) + // var glojure.core/strip-ns + var_glojure_DOT_core_strip_DASH_ns := lang.InternVarName(sym_glojure_DOT_core, sym_strip_DASH_ns) + // var glojure.core/struct + var_glojure_DOT_core_struct := lang.InternVarName(sym_glojure_DOT_core, sym_struct) + // var glojure.core/struct-map + var_glojure_DOT_core_struct_DASH_map := lang.InternVarName(sym_glojure_DOT_core, sym_struct_DASH_map) + // var glojure.core/subs + var_glojure_DOT_core_subs := lang.InternVarName(sym_glojure_DOT_core, sym_subs) + // var glojure.core/subseq + var_glojure_DOT_core_subseq := lang.InternVarName(sym_glojure_DOT_core, sym_subseq) + // var glojure.core/subvec + var_glojure_DOT_core_subvec := lang.InternVarName(sym_glojure_DOT_core, sym_subvec) + // var glojure.core/supers + var_glojure_DOT_core_supers := lang.InternVarName(sym_glojure_DOT_core, sym_supers) + // var glojure.core/swap! + var_glojure_DOT_core_swap_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_swap_BANG_) + // var glojure.core/swap-vals! + var_glojure_DOT_core_swap_DASH_vals_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_swap_DASH_vals_BANG_) + // var glojure.core/symbol + var_glojure_DOT_core_symbol := lang.InternVarName(sym_glojure_DOT_core, sym_symbol) + // var glojure.core/symbol? + var_glojure_DOT_core_symbol_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_symbol_QMARK_) + // var glojure.core/sync + var_glojure_DOT_core_sync := lang.InternVarName(sym_glojure_DOT_core, sym_sync) + // var glojure.core/system-newline + var_glojure_DOT_core_system_DASH_newline := lang.InternVarName(sym_glojure_DOT_core, sym_system_DASH_newline) + // var glojure.core/tagged-literal + var_glojure_DOT_core_tagged_DASH_literal := lang.InternVarName(sym_glojure_DOT_core, sym_tagged_DASH_literal) + // var glojure.core/tagged-literal? + var_glojure_DOT_core_tagged_DASH_literal_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_tagged_DASH_literal_QMARK_) + // var glojure.core/take + var_glojure_DOT_core_take := lang.InternVarName(sym_glojure_DOT_core, sym_take) + // var glojure.core/take-last + var_glojure_DOT_core_take_DASH_last := lang.InternVarName(sym_glojure_DOT_core, sym_take_DASH_last) + // var glojure.core/take-nth + var_glojure_DOT_core_take_DASH_nth := lang.InternVarName(sym_glojure_DOT_core, sym_take_DASH_nth) + // var glojure.core/take-while + var_glojure_DOT_core_take_DASH_while := lang.InternVarName(sym_glojure_DOT_core, sym_take_DASH_while) + // var glojure.core/tapset + var_glojure_DOT_core_tapset := lang.InternVarName(sym_glojure_DOT_core, sym_tapset) + // var glojure.core/test + var_glojure_DOT_core_test := lang.InternVarName(sym_glojure_DOT_core, sym_test) + // var glojure.core/the-ns + var_glojure_DOT_core_the_DASH_ns := lang.InternVarName(sym_glojure_DOT_core, sym_the_DASH_ns) + // var glojure.core/thread-bound? + var_glojure_DOT_core_thread_DASH_bound_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_thread_DASH_bound_QMARK_) + // var glojure.core/throw-if + var_glojure_DOT_core_throw_DASH_if := lang.InternVarName(sym_glojure_DOT_core, sym_throw_DASH_if) + // var glojure.core/time + var_glojure_DOT_core_time := lang.InternVarName(sym_glojure_DOT_core, sym_time) + // var glojure.core/to-array + var_glojure_DOT_core_to_DASH_array := lang.InternVarName(sym_glojure_DOT_core, sym_to_DASH_array) + // var glojure.core/to-array-2d + var_glojure_DOT_core_to_DASH_array_DASH_2d := lang.InternVarName(sym_glojure_DOT_core, sym_to_DASH_array_DASH_2d) + // var glojure.core/trampoline + var_glojure_DOT_core_trampoline := lang.InternVarName(sym_glojure_DOT_core, sym_trampoline) + // var glojure.core/transduce + var_glojure_DOT_core_transduce := lang.InternVarName(sym_glojure_DOT_core, sym_transduce) + // var glojure.core/transient + var_glojure_DOT_core_transient := lang.InternVarName(sym_glojure_DOT_core, sym_transient) + // var glojure.core/tree-seq + var_glojure_DOT_core_tree_DASH_seq := lang.InternVarName(sym_glojure_DOT_core, sym_tree_DASH_seq) + // var glojure.core/true? + var_glojure_DOT_core_true_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_true_QMARK_) + // var glojure.core/type + var_glojure_DOT_core_type := lang.InternVarName(sym_glojure_DOT_core, sym_type) + // var glojure.core/unchecked-add + var_glojure_DOT_core_unchecked_DASH_add := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_add) + // var glojure.core/unchecked-add-int + var_glojure_DOT_core_unchecked_DASH_add_DASH_int := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_add_DASH_int) + // var glojure.core/unchecked-byte + var_glojure_DOT_core_unchecked_DASH_byte := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_byte) + // var glojure.core/unchecked-char + var_glojure_DOT_core_unchecked_DASH_char := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_char) + // var glojure.core/unchecked-dec + var_glojure_DOT_core_unchecked_DASH_dec := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_dec) + // var glojure.core/unchecked-dec-int + var_glojure_DOT_core_unchecked_DASH_dec_DASH_int := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_dec_DASH_int) + // var glojure.core/unchecked-divide-int + var_glojure_DOT_core_unchecked_DASH_divide_DASH_int := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_divide_DASH_int) + // var glojure.core/unchecked-double + var_glojure_DOT_core_unchecked_DASH_double := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_double) + // var glojure.core/unchecked-float + var_glojure_DOT_core_unchecked_DASH_float := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_float) + // var glojure.core/unchecked-inc + var_glojure_DOT_core_unchecked_DASH_inc := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_inc) + // var glojure.core/unchecked-inc-int + var_glojure_DOT_core_unchecked_DASH_inc_DASH_int := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_inc_DASH_int) + // var glojure.core/unchecked-int + var_glojure_DOT_core_unchecked_DASH_int := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_int) + // var glojure.core/unchecked-long + var_glojure_DOT_core_unchecked_DASH_long := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_long) + // var glojure.core/unchecked-multiply + var_glojure_DOT_core_unchecked_DASH_multiply := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_multiply) + // var glojure.core/unchecked-multiply-int + var_glojure_DOT_core_unchecked_DASH_multiply_DASH_int := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_multiply_DASH_int) + // var glojure.core/unchecked-negate + var_glojure_DOT_core_unchecked_DASH_negate := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_negate) + // var glojure.core/unchecked-negate-int + var_glojure_DOT_core_unchecked_DASH_negate_DASH_int := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_negate_DASH_int) + // var glojure.core/unchecked-remainder-int + var_glojure_DOT_core_unchecked_DASH_remainder_DASH_int := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_remainder_DASH_int) + // var glojure.core/unchecked-short + var_glojure_DOT_core_unchecked_DASH_short := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_short) + // var glojure.core/unchecked-subtract + var_glojure_DOT_core_unchecked_DASH_subtract := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_subtract) + // var glojure.core/unchecked-subtract-int + var_glojure_DOT_core_unchecked_DASH_subtract_DASH_int := lang.InternVarName(sym_glojure_DOT_core, sym_unchecked_DASH_subtract_DASH_int) + // var glojure.core/underive + var_glojure_DOT_core_underive := lang.InternVarName(sym_glojure_DOT_core, sym_underive) + // var glojure.core/unquote + var_glojure_DOT_core_unquote := lang.InternVarName(sym_glojure_DOT_core, sym_unquote) + // var glojure.core/unquote-splicing + var_glojure_DOT_core_unquote_DASH_splicing := lang.InternVarName(sym_glojure_DOT_core, sym_unquote_DASH_splicing) + // var glojure.core/unreduced + var_glojure_DOT_core_unreduced := lang.InternVarName(sym_glojure_DOT_core, sym_unreduced) + // var glojure.core/unsigned-bit-shift-right + var_glojure_DOT_core_unsigned_DASH_bit_DASH_shift_DASH_right := lang.InternVarName(sym_glojure_DOT_core, sym_unsigned_DASH_bit_DASH_shift_DASH_right) + // var glojure.core/update + var_glojure_DOT_core_update := lang.InternVarName(sym_glojure_DOT_core, sym_update) + // var glojure.core/update-in + var_glojure_DOT_core_update_DASH_in := lang.InternVarName(sym_glojure_DOT_core, sym_update_DASH_in) + // var glojure.core/update-keys + var_glojure_DOT_core_update_DASH_keys := lang.InternVarName(sym_glojure_DOT_core, sym_update_DASH_keys) + // var glojure.core/update-vals + var_glojure_DOT_core_update_DASH_vals := lang.InternVarName(sym_glojure_DOT_core, sym_update_DASH_vals) + // var glojure.core/uri? + var_glojure_DOT_core_uri_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_uri_QMARK_) + // var glojure.core/use + var_glojure_DOT_core_use := lang.InternVarName(sym_glojure_DOT_core, sym_use) + // var glojure.core/uuid? + var_glojure_DOT_core_uuid_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_uuid_QMARK_) + // var glojure.core/val + var_glojure_DOT_core_val := lang.InternVarName(sym_glojure_DOT_core, sym_val) + // var glojure.core/vals + var_glojure_DOT_core_vals := lang.InternVarName(sym_glojure_DOT_core, sym_vals) + // var glojure.core/var-get + var_glojure_DOT_core_var_DASH_get := lang.InternVarName(sym_glojure_DOT_core, sym_var_DASH_get) + // var glojure.core/var-set + var_glojure_DOT_core_var_DASH_set := lang.InternVarName(sym_glojure_DOT_core, sym_var_DASH_set) + // var glojure.core/var? + var_glojure_DOT_core_var_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_var_QMARK_) + // var glojure.core/vary-meta + var_glojure_DOT_core_vary_DASH_meta := lang.InternVarName(sym_glojure_DOT_core, sym_vary_DASH_meta) + // var glojure.core/vec + var_glojure_DOT_core_vec := lang.InternVarName(sym_glojure_DOT_core, sym_vec) + // var glojure.core/vector + var_glojure_DOT_core_vector := lang.InternVarName(sym_glojure_DOT_core, sym_vector) + // var glojure.core/vector? + var_glojure_DOT_core_vector_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_vector_QMARK_) + // var glojure.core/volatile! + var_glojure_DOT_core_volatile_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_volatile_BANG_) + // var glojure.core/volatile? + var_glojure_DOT_core_volatile_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_volatile_QMARK_) + // var glojure.core/vreset! + var_glojure_DOT_core_vreset_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_vreset_BANG_) + // var glojure.core/vswap! + var_glojure_DOT_core_vswap_BANG_ := lang.InternVarName(sym_glojure_DOT_core, sym_vswap_BANG_) + // var glojure.core/when + var_glojure_DOT_core_when := lang.InternVarName(sym_glojure_DOT_core, sym_when) + // var glojure.core/when-first + var_glojure_DOT_core_when_DASH_first := lang.InternVarName(sym_glojure_DOT_core, sym_when_DASH_first) + // var glojure.core/when-let + var_glojure_DOT_core_when_DASH_let := lang.InternVarName(sym_glojure_DOT_core, sym_when_DASH_let) + // var glojure.core/when-not + var_glojure_DOT_core_when_DASH_not := lang.InternVarName(sym_glojure_DOT_core, sym_when_DASH_not) + // var glojure.core/when-some + var_glojure_DOT_core_when_DASH_some := lang.InternVarName(sym_glojure_DOT_core, sym_when_DASH_some) + // var glojure.core/while + var_glojure_DOT_core_while := lang.InternVarName(sym_glojure_DOT_core, sym_while) + // var glojure.core/with-bindings + var_glojure_DOT_core_with_DASH_bindings := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_bindings) + // var glojure.core/with-bindings* + var_glojure_DOT_core_with_DASH_bindings_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_bindings_STAR_) + // var glojure.core/with-in-str + var_glojure_DOT_core_with_DASH_in_DASH_str := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_in_DASH_str) + // var glojure.core/with-loading-context + var_glojure_DOT_core_with_DASH_loading_DASH_context := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_loading_DASH_context) + // var glojure.core/with-local-vars + var_glojure_DOT_core_with_DASH_local_DASH_vars := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_local_DASH_vars) + // var glojure.core/with-meta + var_glojure_DOT_core_with_DASH_meta := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_meta) + // var glojure.core/with-open + var_glojure_DOT_core_with_DASH_open := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_open) + // var glojure.core/with-out-str + var_glojure_DOT_core_with_DASH_out_DASH_str := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_out_DASH_str) + // var glojure.core/with-precision + var_glojure_DOT_core_with_DASH_precision := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_precision) + // var glojure.core/with-redefs + var_glojure_DOT_core_with_DASH_redefs := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_redefs) + // var glojure.core/with-redefs-fn + var_glojure_DOT_core_with_DASH_redefs_DASH_fn := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_redefs_DASH_fn) + // var glojure.core/xml-seq + var_glojure_DOT_core_xml_DASH_seq := lang.InternVarName(sym_glojure_DOT_core, sym_xml_DASH_seq) + // var glojure.core/zero? + var_glojure_DOT_core_zero_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_zero_QMARK_) + // var glojure.core/zipmap + var_glojure_DOT_core_zipmap := lang.InternVarName(sym_glojure_DOT_core, sym_zipmap) + // var glojure.go.io/copy + var_glojure_DOT_go_DOT_io_copy := lang.InternVarName(sym_glojure_DOT_go_DOT_io, sym_copy) + // var glojure.go.io/reader + var_glojure_DOT_go_DOT_io_reader := lang.InternVarName(sym_glojure_DOT_go_DOT_io, sym_reader) + // reference fmt to avoid unused import error + _ = fmt.Printf + // reference reflect to avoid unused import error + _ = reflect.TypeOf + ns := lang.FindOrCreateNamespace(sym_glojure_DOT_core) + _ = ns + var closed0 any + { + closed0 = sym_unchecked_multiply + } + var closed1 any + { + closed1 = sym_multiply + } + var closed10 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + tmp3, _ := lang.FieldOrMethod(v1, "Reduce") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Reduce is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{v2}) + return tmp4 + case 3: + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + v3 := args[2] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v1, "ReduceInit") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + closed10 = tmp0 + } + var closed13 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + v3 := args[2] + _ = v3 + return v3 + }) + closed13 = tmp0 + } + var closed16 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v1 := args[0] + _ = v1 + return nil + }) + closed16 = tmp0 + } + var closed17 any + { + closed17 = sym_divide + } + var closed18 any + { + closed18 = sym_and + } + var closed19 any + { + closed19 = sym_andNot + } + var closed2 any + { + closed2 = sym_multiplyP + } + var closed20 any + { + closed20 = sym_or + } + var closed21 any + { + closed21 = sym_xor + } + var closed22 any + { + closed22 = sym_max + } + var closed23 any + { + closed23 = sym_min + } + var closed24 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v1 := args[0] + _ = v1 + var tmp2 any + if lang.IsTruthy(v1) { + tmp2 = false + } else { + tmp2 = true + } + return tmp2 + }) + tmp1 := reflect.TypeOf(false) + tmp0 = tmp0.WithMeta(lang.NewMap(kw_rettag, tmp1)).(lang.FnFunc) + closed24 = tmp0 + } + var closed3 any + { + closed3 = sym_unchecked_add + } + var closed4 any + { + closed4 = sym_add + } + var closed5 any + { + closed5 = sym_addP + } + var closed6 any + { + closed6 = sym_unchecked_minus + } + var closed7 any + { + closed7 = sym_minus + } + var closed8 any + { + closed8 = sym_minusP + } + var closed9 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + tmp3 := lang.Apply(v2, nil) + return tmp3 + case 3: + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + v3 := args[2] + _ = v3 + return v3 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + closed9 = tmp0 + } + // >0? + { + tmp0 := sym__GT_0_QMARK_.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(963), kw_column, int(7), kw_end_DASH_line, int(963), kw_end_DASH_column, int(19), kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{nil, int64(0)}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__GT_0_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__GT_0_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // >1? + { + tmp0 := sym__GT_1_QMARK_.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(962), kw_column, int(7), kw_end_DASH_line, int(962), kw_end_DASH_column, int(19), kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{nil, int64(1)}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__GT_1_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__GT_1_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *1 + { + tmp0 := sym__STAR_1.WithMeta(lang.NewMap()).(*lang.Symbol) + var_glojure_DOT_core__STAR_1 = ns.Intern(tmp0) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *2 + { + tmp0 := sym__STAR_2.WithMeta(lang.NewMap()).(*lang.Symbol) + var_glojure_DOT_core__STAR_2 = ns.Intern(tmp0) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *3 + { + tmp0 := sym__STAR_3.WithMeta(lang.NewMap()).(*lang.Symbol) + var_glojure_DOT_core__STAR_3 = ns.Intern(tmp0) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *agent* + { + tmp0 := sym__STAR_agent_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_agent_STAR_ = ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_agent_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *assert* + { + tmp0 := sym__STAR_assert_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "When set to logical false, 'assert' will omit assertion checks in\n compiled code. Defaults to true.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_assert_STAR_ = ns.InternWithValue(tmp0, false, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_assert_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *command-line-args* + { + tmp0 := sym__STAR_command_DASH_line_DASH_args_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "A sequence of the supplied command line arguments, or nil if\n none were supplied", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_command_DASH_line_DASH_args_STAR_ = ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_command_DASH_line_DASH_args_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *compile-files* + { + tmp0 := sym__STAR_compile_DASH_files_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "Set to true when compiling files, false otherwise.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_compile_DASH_files_STAR_ = ns.InternWithValue(tmp0, true, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_compile_DASH_files_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *compile-path* + { + tmp0 := sym__STAR_compile_DASH_path_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "Specifies the directory where 'compile' will write out .class\n files. This directory must be in the classpath for 'compile' to\n work.\n\n Defaults to \"classes\"", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_compile_DASH_path_STAR_ = ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_compile_DASH_path_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *compiler-options* + { + tmp0 := sym__STAR_compiler_DASH_options_STAR_.WithMeta(lang.NewMap(kw_added, "1.4", kw_doc, "A map of keys to options.\n Note, when binding dynamically make sure to merge with previous value.\n Supported options:\n :elide-meta - a collection of metadata keys to elide during compilation.\n :disable-locals-clearing - set to true to disable clearing, useful for using a debugger\n :direct-linking - set to true to use direct static invocation of functions, rather than vars\n Note that call sites compiled with direct linking will not be affected by var redefinition.\n Use ^:redef (or ^:dynamic) on a var to prevent direct linking and allow redefinition.\n See https://glojure.org/reference/compilation for more information.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_compiler_DASH_options_STAR_ = ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_compiler_DASH_options_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *data-readers* + { + tmp0 := sym__STAR_data_DASH_readers_STAR_.WithMeta(lang.NewMap(kw_doc, "Map from reader tag symbols to data reader Vars.\n\n When Clojure starts, it searches for files named 'data_readers.clj'\n and 'data_readers.cljc' at the root of the classpath. Each such file\n must contain a literal map of symbols, like this:\n\n {foo/bar my.project.foo/bar\n foo/baz my.project/baz}\n\n The first symbol in each pair is a tag that will be recognized by\n the Clojure reader. The second symbol in the pair is the\n fully-qualified name of a Var which will be invoked by the reader to\n parse the form following the tag. For example, given the\n data_readers.clj file above, the Clojure reader would parse this\n form:\n\n #foo/bar [1 2 3]\n\n by invoking the Var #'my.project.foo/bar on the vector [1 2 3]. The\n data reader function is invoked on the form AFTER it has been read\n as a normal Clojure data structure by the reader.\n\n Reader tags without namespace qualifiers are reserved for\n Clojure. Default reader tags are defined in\n glojure.core/default-data-readers but may be overridden in\n data_readers.clj, data_readers.cljc, or by rebinding this Var.", kw_file, "glojure/core.glj", kw_added, "1.4", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(49), kw_column, int(6), kw_line, int(7794), kw_end_DASH_line, int(7794), kw_dynamic, true)).(*lang.Symbol) + var_glojure_DOT_core__STAR_data_DASH_readers_STAR_ = ns.InternWithValue(tmp0, lang.NewMap(), true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_data_DASH_readers_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *default-data-reader-fn* + { + tmp0 := sym__STAR_default_DASH_data_DASH_reader_DASH_fn_STAR_.WithMeta(lang.NewMap(kw_doc, "When no data reader is found for a tag and *default-data-reader-fn*\n is non-nil, it will be called with two arguments,\n the tag and the value. If *default-data-reader-fn* is nil (the\n default), an exception will be thrown for the unknown tag.", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(59), kw_column, int(6), kw_line, int(7823), kw_end_DASH_line, int(7823), kw_dynamic, true)).(*lang.Symbol) + var_glojure_DOT_core__STAR_default_DASH_data_DASH_reader_DASH_fn_STAR_ = ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_default_DASH_data_DASH_reader_DASH_fn_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *e + { + tmp0 := sym__STAR_e.WithMeta(lang.NewMap()).(*lang.Symbol) + var_glojure_DOT_core__STAR_e = ns.Intern(tmp0) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_e.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *err* + { + tmp0 := sym__STAR_err_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "A java.io.Writer object representing standard error for print operations.\n\n Defaults to System/err, wrapped in a PrintWriter", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_err_STAR_ = ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_err_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *file* + { + tmp0 := sym__STAR_file_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "The path of the file being evaluated, as a String.\n\n When there is no file, e.g. in the REPL, the value is not defined.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_file_STAR_ = ns.InternWithValue(tmp0, "NO_SOURCE_FILE", true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_file_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *flush-on-newline* + { + tmp0 := sym__STAR_flush_DASH_on_DASH_newline_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "When set to true, output will be flushed whenever a newline is printed.\n\n Defaults to true.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_flush_DASH_on_DASH_newline_STAR_ = ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_flush_DASH_on_DASH_newline_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *loaded-libs* + { + tmp0 := sym__STAR_loaded_DASH_libs_STAR_.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core.glj", kw_line, int(5817), kw_column, int(10), kw_end_DASH_line, int(5820), kw_end_DASH_column, int(15), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + tmp1 := lang.NewRef(lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{sym_glojure_DOT_core_DOT_protocols, sym_glojure_DOT_string, sym_glojure_DOT_go_DOT_io, sym_user}))) + var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *loading-verbosely* + { + tmp0 := sym__STAR_loading_DASH_verbosely_STAR_.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core.glj", kw_line, int(5827), kw_column, int(10), kw_end_DASH_line, int(5830), kw_end_DASH_column, int(21), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_ = ns.InternWithValue(tmp0, false, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *ns* + { + tmp0 := sym__STAR_ns_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "A glojure.lang.Namespace object representing the current namespace.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_ns_STAR_ = ns.InternWithValue(tmp0, lang.FindOrCreateNamespace(sym_glojure_DOT_core), true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_ns_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *pending-paths* + { + tmp0 := sym__STAR_pending_DASH_paths_STAR_.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core.glj", kw_line, int(5822), kw_column, int(10), kw_end_DASH_line, int(5825), kw_end_DASH_column, int(17), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_ = ns.InternWithValue(tmp0, lang.NewList("/glojure/core_print", "/glojure/core"), true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *print-dup* + { + tmp0 := sym__STAR_print_DASH_dup_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "When set to logical true, objects will be printed in a way that preserves\n their type when read in later.\n\n Defaults to false.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_print_DASH_dup_STAR_ = ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_print_DASH_dup_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *print-length* + { + tmp0 := sym__STAR_print_DASH_length_STAR_.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core_print.glj", kw_line, int(14), kw_column, int(6), kw_end_DASH_line, int(23), kw_end_DASH_column, int(15), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_print_DASH_length_STAR_ = ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_print_DASH_length_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *print-level* + { + tmp0 := sym__STAR_print_DASH_level_STAR_.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core_print.glj", kw_line, int(25), kw_column, int(6), kw_end_DASH_line, int(35), kw_end_DASH_column, int(14), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_print_DASH_level_STAR_ = ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_print_DASH_level_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *print-meta* + { + tmp0 := sym__STAR_print_DASH_meta_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "If set to logical true, when printing an object, its metadata will also\n be printed in a form that can be read back by the reader.\n\n Defaults to false.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_print_DASH_meta_STAR_ = ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_print_DASH_meta_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *print-namespace-maps* + { + tmp0 := sym__STAR_print_DASH_namespace_DASH_maps_STAR_.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core_print.glj", kw_line, int(39), kw_column, int(6), kw_end_DASH_line, int(44), kw_end_DASH_column, int(23), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_print_DASH_namespace_DASH_maps_STAR_ = ns.InternWithValue(tmp0, false, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_print_DASH_namespace_DASH_maps_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *print-readably* + { + tmp0 := sym__STAR_print_DASH_readably_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "When set to logical false, strings and characters will be printed with\n non-alphanumeric characters converted to the appropriate escape sequences.\n\n Defaults to true", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_print_DASH_readably_STAR_ = ns.InternWithValue(tmp0, true, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_print_DASH_readably_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *read-eval* + { + tmp0 := sym__STAR_read_DASH_eval_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "Defaults to true (or value specified by system property, see below)\n ***This setting implies that the full power of the reader is in play,\n including syntax that can cause code to execute. It should never be\n used with untrusted sources. See also: glojure.edn/read.***\n\n When set to logical false in the thread-local binding,\n the eval reader (#=) and record/type literal syntax are disabled in read/load.\n Example (will fail): (binding [*read-eval* false] (read-string \"#=(* 2 21)\"))\n\n The default binding can be controlled by the system property\n 'glojure.read.eval' System properties can be set on the command line\n like this:\n\n java -Dglojure.read.eval=false ...\n\n The system property can also be set to 'unknown' via\n -Dglojure.read.eval=unknown, in which case the default binding\n is :unknown and all reads will fail in contexts where *read-eval*\n has not been explicitly bound to either true or false. This setting\n can be a useful diagnostic tool to ensure that all of your reads\n occur in considered contexts. You can also accomplish this in a\n particular scope by binding *read-eval* to :unknown\n ", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_read_DASH_eval_STAR_ = ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_read_DASH_eval_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *repl* + { + tmp0 := sym__STAR_repl_STAR_.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core.glj", kw_line, int(6288), kw_column, int(6), kw_end_DASH_line, int(6291), kw_end_DASH_column, int(8), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_repl_STAR_ = ns.InternWithValue(tmp0, false, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_repl_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *unchecked-math* + { + tmp0 := sym__STAR_unchecked_DASH_math_STAR_.WithMeta(lang.NewMap(kw_added, "1.3", kw_doc, "While bound to true, compilations of +, -, *, inc, dec and the\n coercions will be done without overflow checks. While bound\n to :warn-on-boxed, same behavior as true, and a warning is emitted\n when compilation uses boxed math. Default: false.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_ = ns.InternWithValue(tmp0, false, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *verbose-defrecords* + { + tmp0 := sym__STAR_verbose_DASH_defrecords_STAR_.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core_print.glj", kw_line, int(37), kw_column, int(6), kw_end_DASH_line, int(37), kw_end_DASH_column, int(35), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_verbose_DASH_defrecords_STAR_ = ns.InternWithValue(tmp0, false, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_verbose_DASH_defrecords_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *warn-on-reflection* + { + tmp0 := sym__STAR_warn_DASH_on_DASH_reflection_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "When set to true, the compiler will emit warnings when reflection is\n needed to resolve Java method calls or field accesses.\n\n Defaults to false.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core__STAR_warn_DASH_on_DASH_reflection_STAR_ = ns.InternWithValue(tmp0, true, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_warn_DASH_on_DASH_reflection_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // accessor + { + tmp0 := sym_accessor.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s, sym_key)), kw_doc, "Returns a fn that, given an instance of a structmap with the basis,\n returns the value at the key. The key must be in the basis. The\n returned function should be (slightly) more efficient than using\n get, but such use of accessors should be limited to known\n performance-critical areas.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(4070), kw_end_DASH_line, int(4070))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(nil, "getAccessor") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getAccessor is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_accessor = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_accessor.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // add-watch + { + tmp0 := sym_add_DASH_watch.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_reference, sym_key, sym_fn)), kw_doc, "Adds a watch function to an agent/atom/var/ref reference. The watch\n fn must be a fn of 4 args: a key, the reference, its old-state, its\n new-state. Whenever the reference's state might have been changed,\n any registered watches will have their functions called. The watch fn\n will be called synchronously, on the agent's thread if an agent,\n before any pending sends if agent or ref. Note that an atom's or\n ref's state may have changed again prior to the fn call, so use\n old/new-state rather than derefing the reference. Note also that watch\n fns may be called from multiple threads simultaneously. Var watchers\n are triggered only by root binding changes, not thread-local\n set!s. Keys must be unique per reference, and can be used to remove\n the watch with remove-watch, but are otherwise considered opaque by\n the watch mechanism.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(2142), kw_end_DASH_line, int(2142))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5, _ := lang.FieldOrMethod(v2, "addWatch") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("addWatch is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_add_DASH_watch = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_add_DASH_watch.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // agent-error + { + tmp0 := sym_agent_DASH_error.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a)), kw_doc, "Returns the exception thrown during an asynchronous action of the\n agent if the agent is failed. Returns nil if the agent is not\n failed.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(2167), kw_end_DASH_line, int(2167))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "getError") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getError"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_agent_DASH_error = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_agent_DASH_error.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // all-ns + { + tmp0 := sym_all_DASH_ns.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Returns a sequence of all namespaces.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(4146), kw_end_DASH_line, int(4146))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp2 := lang.Apply(nil, nil) + return tmp2 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_all_DASH_ns = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_all_DASH_ns.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // alter + { + tmp0 := sym_alter.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ref, sym_fun, sym__AMP_, sym_args)), kw_doc, "Must be called in a transaction. Sets the in-transaction-value of\n ref to:\n\n (apply fun in-transaction-value-of-ref args)\n\n and returns the in-transaction-value of ref.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(2435), kw_end_DASH_line, int(2435))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5, _ := lang.FieldOrMethod(v2, "alter") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("alter is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_alter = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_alter.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // alter-meta! + { + tmp0 := sym_alter_DASH_meta_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_iref, sym_f, sym__AMP_, sym_args)), kw_doc, "Atomically sets the metadata for a namespace/var/ref/agent/atom to be:\n\n (apply f its-current-meta args)\n\n f must be free of side-effects", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(2398), kw_end_DASH_line, int(2398))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5, _ := lang.FieldOrMethod(v2, "AlterMeta") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("AlterMeta is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_alter_DASH_meta_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_alter_DASH_meta_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // alter-var-root + { + tmp0 := sym_alter_DASH_var_DASH_root.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_v, sym_f, sym__AMP_, sym_args)), kw_doc, "Atomically alters the root binding of var v by applying f to its\n current value plus any args", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(5484), kw_end_DASH_line, int(5484))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5, _ := lang.FieldOrMethod(v2, "alterRoot") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("alterRoot is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_alter_DASH_var_DASH_root = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_alter_DASH_var_DASH_root.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // any? + { + tmp1 := reflect.TypeOf(false) + tmp0 := sym_any_QMARK_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true given any argument.", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(537), kw_end_DASH_line, int(537))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + return true + }) + tmp3 := reflect.TypeOf(false) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_any_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_any_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // assert-valid-fdecl + { + tmp0 := sym_assert_DASH_valid_DASH_fdecl.WithMeta(lang.NewMap(kw_private, true, kw_dynamic, true, kw_file, "glojure/core.glj", kw_line, int(219), kw_column, int(6), kw_end_DASH_line, int(220), kw_end_DASH_column, int(20), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + return nil + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(220), kw_column, int(22), kw_end_DASH_line, int(220), kw_end_DASH_column, int(33))).(lang.FnFunc) + var_glojure_DOT_core_assert_DASH_valid_DASH_fdecl = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_assert_DASH_valid_DASH_fdecl.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bit-clear + { + tmp0 := sym_bit_DASH_clear.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_n)), kw_doc, "Clear bit at index n", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(1336), kw_end_DASH_line, int(1336))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "ClearBit") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ClearBit is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bit_DASH_clear = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bit_DASH_clear.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bit-flip + { + tmp0 := sym_bit_DASH_flip.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_n)), kw_doc, "Flip bit at index n", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(1348), kw_end_DASH_line, int(1348))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "FlipBit") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("FlipBit is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bit_DASH_flip = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bit_DASH_flip.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bit-set + { + tmp0 := sym_bit_DASH_set.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_n)), kw_doc, "Set bit at index n", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(1342), kw_end_DASH_line, int(1342))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "SetBit") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("SetBit is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bit_DASH_set = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bit_DASH_set.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bit-test + { + tmp0 := sym_bit_DASH_test.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_n)), kw_doc, "Test bit at index n", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(1354), kw_end_DASH_line, int(1354))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "TestBit") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("TestBit is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bit_DASH_test = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bit_DASH_test.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // cast + { + tmp0 := sym_cast.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_c, sym_x)), kw_doc, "Throws a ClassCastException if x is not a c, else returns x.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(345), kw_end_DASH_line, int(345))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "cast") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("cast is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_cast = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_cast.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // char-escape-string + { + tmp1 := reflect.TypeOf("") + tmp0 := sym_char_DASH_escape_DASH_string.WithMeta(lang.NewMap(kw_tag, tmp1, kw_doc, "Returns escape string for char or nil if none", kw_file, "glojure/core_print.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(6), kw_line, int(214), kw_end_DASH_line, int(217))).(*lang.Symbol) + var_glojure_DOT_core_char_DASH_escape_DASH_string = ns.InternWithValue(tmp0, lang.NewMap(lang.NewChar(10), "\\n", lang.NewChar(9), "\\t", lang.NewChar(13), "\\r", lang.NewChar(34), "\\\"", lang.NewChar(92), "\\\\", lang.NewChar(12), "\\f", lang.NewChar(8), "\\b"), true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_char_DASH_escape_DASH_string.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // char-name-string + { + tmp1 := reflect.TypeOf("") + tmp0 := sym_char_DASH_name_DASH_string.WithMeta(lang.NewMap(kw_tag, tmp1, kw_doc, "Returns name string for char or nil if none", kw_file, "glojure/core_print.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(6), kw_line, int(335), kw_end_DASH_line, int(338))).(*lang.Symbol) + var_glojure_DOT_core_char_DASH_name_DASH_string = ns.InternWithValue(tmp0, lang.NewMap(lang.NewChar(10), "newline", lang.NewChar(9), "tab", lang.NewChar(32), "space", lang.NewChar(8), "backspace", lang.NewChar(12), "formfeed", lang.NewChar(13), "return"), true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_char_DASH_name_DASH_string.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // chunk + { + tmp0 := sym_chunk.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(691), kw_column, int(7), kw_end_DASH_line, int(691), kw_end_DASH_column, int(41), kw_arglists, lang.NewList(lang.NewVector(sym_b)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "chunk") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "chunk"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_chunk = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_chunk.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // chunk-append + { + tmp0 := sym_chunk_DASH_append.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(688), kw_column, int(7), kw_end_DASH_line, int(688), kw_end_DASH_column, int(27), kw_arglists, lang.NewList(lang.NewVector(sym_b, sym_x)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "add") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_chunk_DASH_append = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_chunk_DASH_append.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // chunk-buffer + { + tmp0 := sym_chunk_DASH_buffer.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(685), kw_column, int(7), kw_end_DASH_line, int(685), kw_end_DASH_column, int(53), kw_arglists, lang.NewList(lang.NewVector(sym_capacity)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(lang.NewChunkBuffer, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_chunk_DASH_buffer = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_chunk_DASH_buffer.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // chunk-cons + { + tmp0 := sym_chunk_DASH_cons.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(703), kw_column, int(7), kw_end_DASH_line, int(703), kw_end_DASH_column, int(25), kw_arglists, lang.NewList(lang.NewVector(sym_chunk, sym_rest)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + tmp5 := lang.Apply(lang.Count, []any{v2}) + tmp6 := lang.Apply(lang.IsZero, []any{tmp5}) + if lang.IsTruthy(tmp6) { + tmp4 = v3 + } else { + tmp7 := lang.Apply(lang.NewChunkedCons, []any{v2, v3}) + tmp4 = tmp7 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_chunk_DASH_cons = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_chunk_DASH_cons.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // chunk-first + { + tmp0 := sym_chunk_DASH_first.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(694), kw_column, int(7), kw_end_DASH_line, int(694), kw_end_DASH_column, int(48), kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "chunkedFirst") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "chunkedFirst"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_chunk_DASH_first = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_chunk_DASH_first.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // chunk-next + { + tmp0 := sym_chunk_DASH_next.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(700), kw_column, int(7), kw_end_DASH_line, int(700), kw_end_DASH_column, int(71), kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "chunkedNext") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "chunkedNext"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_chunk_DASH_next = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_chunk_DASH_next.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // chunk-rest + { + tmp0 := sym_chunk_DASH_rest.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(697), kw_column, int(7), kw_end_DASH_line, int(697), kw_end_DASH_column, int(71), kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "chunkedMore") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "chunkedMore"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_chunk_DASH_rest = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_chunk_DASH_rest.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // comment + { + tmp0 := sym_comment.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_body)), kw_doc, "Ignores body, yields nil", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(4733), kw_end_DASH_line, int(4733))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + return nil + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_comment = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_comment.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // commute + { + tmp0 := sym_commute.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ref, sym_fun, sym__AMP_, sym_args)), kw_doc, "Must be called in a transaction. Sets the in-transaction-value of\n ref to:\n\n (apply fun in-transaction-value-of-ref args)\n\n and returns the in-transaction-value of ref.\n\n At the commit point of the transaction, sets the value of ref to be:\n\n (apply fun most-recently-committed-value-of-ref args)\n\n Thus fun should be commutative, or, failing that, you must accept\n last-one-in-wins behavior. commute allows for more concurrency than\n ref-set.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(2414), kw_end_DASH_line, int(2414))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5, _ := lang.FieldOrMethod(v2, "Commute") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Commute is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_commute = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_commute.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // comparator + { + tmp0 := sym_comparator.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred)), kw_doc, "Returns an implementation of java.util.Comparator based upon pred.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(3077), kw_end_DASH_line, int(3077))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var tmp6 any + tmp7 := lang.Apply(v2, []any{v4, v5}) + if lang.IsTruthy(tmp7) { + tmp6 = int64(-1) + } else { + var tmp8 any + tmp9 := lang.Apply(v2, []any{v5, v4}) + if lang.IsTruthy(tmp9) { + tmp8 = int64(1) + } else { + var tmp10 any + if lang.IsTruthy(kw_else) { + tmp10 = int64(0) + } else { + } + tmp8 = tmp10 + } + tmp6 = tmp8 + } + return tmp6 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3082), kw_column, int(5), kw_end_DASH_line, int(3083), kw_end_DASH_column, int(48)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_comparator = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_comparator.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // compare-and-set! + { + tmp0 := sym_compare_DASH_and_DASH_set_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_atom, sym_oldval, sym_newval)), kw_doc, "Atomically sets the value of atom to newval if and only if the\n current value of the atom is identical to oldval. Returns true if\n set happened, else false", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(22), kw_column, int(7), kw_line, int(2360), kw_end_DASH_line, int(2360))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5, _ := lang.FieldOrMethod(v2, "compareAndSet") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("compareAndSet is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_compare_DASH_and_DASH_set_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_compare_DASH_and_DASH_set_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // cons + { + tmp0 := sym_cons.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_seq)), kw_doc, "Returns a new seq where x is the first element and seq is\n the rest.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(5), kw_column, int(2), kw_line, int(21), kw_end_DASH_line, int(27))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function cons + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(lang.NewCons, []any{v3, v4}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(27), kw_column, int(7), kw_end_DASH_line, int(27), kw_end_DASH_column, int(89))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_cons = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_cons.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // constantly + { + tmp0 := sym_constantly.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns a function that takes any number of arguments and returns x.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(1440), kw_end_DASH_line, int(1440))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v4 any = lang.NewList(args[0:]...) + _ = v4 + return v2 + } + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(1444), kw_column, int(7), kw_end_DASH_line, int(1444), kw_end_DASH_column, int(21)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_constantly = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_constantly.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // contains? + { + tmp0 := sym_contains_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll, sym_key)), kw_doc, "Returns true if key is present in the given collection, otherwise\n returns false. Note that for numerically indexed collections like\n vectors and Java arrays, this tests if the numeric key is within the\n range of indexes. 'contains?' operates constant or logarithmic time;\n it will not perform a linear search for a value. See also 'some'.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(1479), kw_end_DASH_line, int(1479))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(runtime.RT, "Contains") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Contains is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_contains_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_contains_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // create-ns + { + tmp0 := sym_create_DASH_ns.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_sym)), kw_doc, "Create a new namespace named by the symbol if one doesn't already\n exist, returns it or the already-existing namespace of the same\n name.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(4131), kw_end_DASH_line, int(4131))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(nil, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_create_DASH_ns = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_create_DASH_ns.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // create-struct + { + tmp0 := sym_create_DASH_struct.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_keys)), kw_doc, "Returns a structure basis object.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(4037), kw_end_DASH_line, int(4037))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + tmp3 := lang.Apply(lang.CreatePersistentStructMapSlotMap, []any{v2}) + return tmp3 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_create_DASH_struct = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_create_DASH_struct.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // data-reader-urls + { + tmp0 := sym_data_DASH_reader_DASH_urls.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7830), kw_column, int(8), kw_end_DASH_line, int(7830), kw_end_DASH_column, int(23), kw_private, true, kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + return lang.NewList() + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_data_DASH_reader_DASH_urls = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_data_DASH_reader_DASH_urls.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // deliver + { + tmp0 := sym_deliver.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_promise, sym_val)), kw_doc, "Delivers the supplied value to the promise, releasing any pending\n derefs. A subsequent call to deliver on a promise will have no effect.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(7109), kw_end_DASH_line, int(7109))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := lang.Apply(v2, []any{v3}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_deliver = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_deliver.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // denominator + { + tmp1 := reflect.TypeOf((*big6.Int)(nil)) + tmp0 := sym_denominator.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_r)), kw_doc, "Returns the denominator part of a Ratio.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(3591), kw_end_DASH_line, int(3591))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, ok := lang.FieldOrMethod(v3, "denominator") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "denominator"))) + } + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { + case reflect.Func: + tmp5 = lang.Apply(tmp4, nil) + default: + tmp5 = tmp4 + } + return tmp5 + }) + tmp3 := reflect.TypeOf((*big6.Int)(nil)) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_denominator = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_denominator.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // deref-future + { + tmp0 := sym_deref_DASH_future.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(2296), kw_column, int(7), kw_end_DASH_line, int(2296), kw_end_DASH_column, int(28), kw_arglists, lang.NewList(lang.NewVector(sym_fut), lang.NewVector(sym_fut, sym_timeout_DASH_ms, sym_timeout_DASH_val)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "Get") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "Get"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + func() { + defer func() { + if r := recover(); r != nil { + tmp6 := reflect.TypeOf((*lang.TimeoutError)(nil)).Elem() + if lang.CatchMatches(r, tmp6) { + v7 := r + _ = v7 + tmp5 = v4 + } else { + panic(r) + } + } + }() + tmp7, _ := lang.FieldOrMethod(v2, "Get") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Get is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v3, time7.Millisecond}) + tmp5 = tmp8 + }() + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_deref_DASH_future = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_deref_DASH_future.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ensure + { + tmp0 := sym_ensure.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ref)), kw_doc, "Must be called in a transaction. Protects the ref from modification\n by other transactions. Returns the in-transaction-value of\n ref. Allows for more concurrency than (ref-set ref @ref)", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(2480), kw_end_DASH_line, int(2480))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(v2, "touch") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("touch is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{}) + _ = tmp4 + tmp5, _ := lang.FieldOrMethod(v2, "deref") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("deref is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ensure = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ensure.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // enumeration-seq + { + tmp0 := sym_enumeration_DASH_seq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_e)), kw_doc, "Returns a seq on a java.util.Enumeration", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(5710), kw_end_DASH_line, int(5710))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(nil, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_enumeration_DASH_seq = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_enumeration_DASH_seq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // error-handler + { + tmp0 := sym_error_DASH_handler.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a)), kw_doc, "Returns the error-handler of agent a, or nil if there is none.\n See set-error-handler!", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(2202), kw_end_DASH_line, int(2202))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "getErrorHandler") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getErrorHandler"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_error_DASH_handler = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_error_DASH_handler.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // error-mode + { + tmp0 := sym_error_DASH_mode.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a)), kw_doc, "Returns the error-mode of agent a. See set-error-mode!", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(2227), kw_end_DASH_line, int(2227))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "getErrorMode") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getErrorMode"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_error_DASH_mode = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_error_DASH_mode.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // eval + { + tmp0 := sym_eval.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_form)), kw_doc, "Evaluates the form data structure (not text!) and returns the result.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3203), kw_end_DASH_line, int(3203))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(runtime.Compiler, "Eval") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Eval is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_eval = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_eval.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // false? + { + tmp1 := reflect.TypeOf(false) + tmp0 := sym_false_QMARK_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x is the value false, false otherwise.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(504), kw_end_DASH_line, int(504))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.Identical, []any{v3, false}) + return tmp4 + }) + tmp3 := reflect.TypeOf(false) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_false_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_false_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // find + { + tmp0 := sym_find.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_map, sym_key)), kw_doc, "Returns the map entry for key, or nil if key not present.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1530), kw_end_DASH_line, int(1530))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(runtime.RT, "Find") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Find is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_find = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_find.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // find-ns + { + tmp0 := sym_find_DASH_ns.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_sym)), kw_doc, "Returns the namespace named by the symbol or nil if it doesn't exist.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4125), kw_end_DASH_line, int(4125))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(lang.FindNamespace, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_find_DASH_ns = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_find_DASH_ns.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // find-var + { + tmp0 := sym_find_DASH_var.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_sym)), kw_doc, "Returns the global var named by the namespace-qualified symbol, or\n nil if no var with that name.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(2013), kw_end_DASH_line, int(2013))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(runtime.RT, "FindVar") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("FindVar is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_find_DASH_var = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_find_DASH_var.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // first + { + tmp0 := sym_first.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns the first item in the collection. Calls seq on its\n argument. If coll is nil, returns nil.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(6), kw_column, int(2), kw_line, int(47), kw_end_DASH_line, int(52))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function first + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.First, []any{v3}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(52), kw_column, int(8), kw_end_DASH_line, int(52), kw_end_DASH_column, int(86))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_first = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_first.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // force + { + tmp0 := sym_force.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "If x is a Delay, returns the (possibly cached) value of its expression, else returns x", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(754), kw_end_DASH_line, int(754))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(nil, "force") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("force is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_force = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_force.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // future-cancel + { + tmp0 := sym_future_DASH_cancel.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f)), kw_doc, "Cancels the future, if possible.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(7019), kw_end_DASH_line, int(7019))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(v2, "cancel") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("cancel is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{true}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_future_DASH_cancel = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_future_DASH_cancel.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // future-cancelled? + { + tmp0 := sym_future_DASH_cancelled_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f)), kw_doc, "Returns true if future f is cancelled", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(7), kw_line, int(7025), kw_end_DASH_line, int(7025))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "isCancelled") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "isCancelled"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_future_DASH_cancelled_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_future_DASH_cancelled_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // future-done? + { + tmp0 := sym_future_DASH_done_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f)), kw_doc, "Returns true if future f is done", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(6538), kw_end_DASH_line, int(6538))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "isDone") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "isDone"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_future_DASH_done_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_future_DASH_done_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // gen-class + { + tmp0 := sym_gen_DASH_class.WithMeta(lang.NewMap()).(*lang.Symbol) + var_glojure_DOT_core_gen_DASH_class = ns.Intern(tmp0) + if tmp0.Meta() != nil { + var_glojure_DOT_core_gen_DASH_class.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // get-method + { + tmp0 := sym_get_DASH_method.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_multifn, sym_dispatch_DASH_val)), kw_doc, "Given a multimethod and a dispatch value, returns the dispatch fn\n that would apply to that value, or nil if none apply and no default", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(1815), kw_end_DASH_line, int(1815))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "getMethod") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getMethod is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_get_DASH_method = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_get_DASH_method.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // get-thread-bindings + { + tmp0 := sym_get_DASH_thread_DASH_bindings.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Get a map with the Var/value pairs which is currently in effect for the\n current thread.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(25), kw_column, int(7), kw_line, int(1937), kw_end_DASH_line, int(1937))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp2 := lang.Apply(nil, nil) + return tmp2 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_get_DASH_thread_DASH_bindings = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_get_DASH_thread_DASH_bindings.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // get-validator + { + tmp0 := sym_get_DASH_validator.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_iref)), kw_doc, "Gets the validator-fn for a var/ref/agent/atom.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(2392), kw_end_DASH_line, int(2392))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(v2, "getValidator") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getValidator is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_get_DASH_validator = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_get_DASH_validator.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // global-hierarchy + { + tmp0 := sym_global_DASH_hierarchy.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(5513), kw_column, int(6), kw_end_DASH_line, int(5514), kw_end_DASH_column, int(21), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core_global_DASH_hierarchy = ns.InternWithValue(tmp0, lang.NewMap(kw_parents, lang.NewMap(), kw_descendants, lang.NewMap(), kw_ancestors, lang.NewMap()), true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_global_DASH_hierarchy.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // hash + { + tmp0 := sym_hash.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns the hash code of its argument. Note this is the hash code\n consistent with =, and thus is different than .hashCode for Integer,\n Short, Byte and Clojure collections.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(5189), kw_end_DASH_line, int(5189))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(lang.HashEq, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_hash = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_hash.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // hash-map + { + tmp0 := sym_hash_DASH_map.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym__AMP_, sym_keyvals)), kw_doc, "keyval => key val\n Returns a new hash map with supplied mappings. If any keys are\n equal, they are handled as if by repeated uses of assoc.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(378), kw_end_DASH_line, int(378))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp2 := lang.NewMap() + tmp3 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(384), kw_column, int(7), kw_end_DASH_line, int(384), kw_end_DASH_column, int(8)) + tmp4, err := lang.WithMeta(tmp2, tmp3.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp4 + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + tmp3 := lang.Apply(lang.CreatePersistentHashMap, []any{v2}) + return tmp3 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_hash_DASH_map = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_hash_DASH_map.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // hash-ordered-coll + { + tmp0 := sym_hash_DASH_ordered_DASH_coll.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns the hash code, consistent with =, for an external ordered\n collection implementing Iterable.\n See http://glojure.org/data_structures#hash for full algorithms.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.6", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(7), kw_line, int(5210), kw_end_DASH_line, int(5210))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(nil, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_hash_DASH_ordered_DASH_coll = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_hash_DASH_ordered_DASH_coll.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // hash-set + { + tmp0 := sym_hash_DASH_set.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym__AMP_, sym_keys)), kw_doc, "Returns a new hash set with supplied keys. Any equal keys are\n handled as if by repeated uses of conj.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(388), kw_end_DASH_line, int(388))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp2 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp3 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(393), kw_column, int(7), kw_end_DASH_line, int(393), kw_end_DASH_column, int(9)) + tmp4, err := lang.WithMeta(tmp2, tmp3.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp4 + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + tmp3 := lang.Apply(nil, []any{v2}) + return tmp3 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_hash_DASH_set = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_hash_DASH_set.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // hash-unordered-coll + { + tmp0 := sym_hash_DASH_unordered_DASH_coll.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns the hash code, consistent with =, for an external unordered\n collection implementing Iterable. For maps, the iterator should\n return map entries whose hash is computed as\n (hash-ordered-coll [k v]).\n See http://glojure.org/data_structures#hash for full algorithms.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.6", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(25), kw_column, int(7), kw_line, int(5219), kw_end_DASH_line, int(5219))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(nil, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_hash_DASH_unordered_DASH_coll = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_hash_DASH_unordered_DASH_coll.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // identity + { + tmp0 := sym_identity.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns its argument.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(1446), kw_end_DASH_line, int(1446))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + return v2 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_identity = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_identity.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // inst-ms + { + tmp0 := sym_inst_DASH_ms.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_inst)), kw_doc, "Return the number of milliseconds since January 1, 1970, 00:00:00 GMT", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(6831), kw_end_DASH_line, int(6831))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(nil, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_inst_DASH_ms = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_inst_DASH_ms.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // inst? + { + tmp0 := sym_inst_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x satisfies Inst", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(6837), kw_end_DASH_line, int(6837))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + return nil + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_inst_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_inst_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // instance? + { + tmp0 := sym_instance_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_c, sym_x)), kw_doc, "Evaluates x and tests if it is an instance of the type\n t. Returns true or false", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(2), kw_line, int(139), kw_end_DASH_line, int(143))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function instance? + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(lang.HasType, []any{v3, v4}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(143), kw_column, int(12), kw_end_DASH_line, int(143), kw_end_DASH_column, int(85))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_instance_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_instance_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // int? + { + tmp0 := sym_int_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a fixed precision integer", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1395), kw_end_DASH_line, int(1395))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "or__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := lang.Apply(tmp4, []any{lang.Builtins["int64"], v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + tmp7 = v6 + } else { + var tmp8 any + { // let + // let binding "or__0__auto__" + tmp9 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp10 := lang.Apply(tmp9, []any{nil, v2}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + tmp12 = v11 + } else { + var tmp13 any + { // let + // let binding "or__0__auto__" + tmp14 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp15 := lang.Apply(tmp14, []any{nil, v2}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + if lang.IsTruthy(v16) { + tmp17 = v16 + } else { + tmp18 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp19 := lang.Apply(tmp18, []any{nil, v2}) + tmp17 = tmp19 + } + tmp13 = tmp17 + } // end let + tmp12 = tmp13 + } + tmp8 = tmp12 + } // end let + tmp7 = tmp8 + } + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_int_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_int_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // integer? + { + tmp0 := sym_integer_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_doc, "Returns true if n is an integer", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(1379), kw_end_DASH_line, int(1379))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(lang.IsInteger, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_integer_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_integer_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // iterate + { + tmp0 := sym_iterate.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_x)), kw_doc, "Returns a lazy (infinite!) sequence of x, (f x), (f (f x)) etc.\n f must be free of side-effects", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(3011), kw_end_DASH_line, int(3011))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := lang.Apply(nil, []any{v2, v3}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_iterate = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_iterate.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // iterator-seq + { + tmp0 := sym_iterator_DASH_seq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_iter)), kw_doc, "Returns a seq on a java.util.Iterator. Note that most collections\n providing iterators implement Iterable and thus support seq directly.\n Seqs cache values, thus iterator-seq should not be used on any\n iterator that repeatedly returns the same mutable object.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(5700), kw_end_DASH_line, int(5700))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(nil, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_iterator_DASH_seq = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_iterator_DASH_seq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // key + { + tmp0 := sym_key.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_e)), kw_doc, "Returns the key of the map entry.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(1563), kw_end_DASH_line, int(1563))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(v2, "GetKey") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("GetKey is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_key = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_key.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // keys + { + tmp0 := sym_keys.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_map)), kw_doc, "Returns a sequence of the map's keys, in the same order as (seq map).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1551), kw_end_DASH_line, int(1551))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(lang.Keys, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_keys = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_keys.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // keyword? + { + tmp0 := sym_keyword_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a Keyword", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(563), kw_end_DASH_line, int(563))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_keyword_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_keyword_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // line-seq + { + tmp0 := sym_line_DASH_seq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_rdr)), kw_doc, "Returns the lines of text from rdr as a lazy sequence of strings.\n rdr must implement java.io.BufferedReader.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(3068), kw_end_DASH_line, int(3068))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "temp__0__auto__" + tmp4, ok := lang.FieldOrMethod(v2, "readLine") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "readLine"))) + } + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { + case reflect.Func: + tmp5 = lang.Apply(tmp4, nil) + default: + tmp5 = tmp4 + } + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + var tmp8 any + { // let + // let binding "line" + var v9 any = v6 + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_cons) + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp12 := checkDerefVar(var_glojure_DOT_core_line_DASH_seq) + tmp13 := lang.Apply(tmp12, []any{v2}) + return tmp13 + }) + tmp12 := lang.Apply(lang.NewLazySeq, []any{tmp11}) + tmp13 := lang.Apply(tmp10, []any{v9, tmp12}) + tmp8 = tmp13 + } // end let + tmp7 = tmp8 + } else { + } + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_line_DASH_seq = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_line_DASH_seq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // list + { + tmp0 := sym_list.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_items)), kw_doc, "Creates a new list containing the items.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(6), kw_column, int(2), kw_line, int(15), kw_end_DASH_line, int(18))).(*lang.Symbol) + var_glojure_DOT_core_list = ns.InternWithValue(tmp0, lang.NewList, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_list.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // list? + { + tmp0 := sym_list_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x implements IPersistentList", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(6198), kw_end_DASH_line, int(6198))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*lang.IPersistentList)(nil)).Elem() + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_list_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_list_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // load-file + { + tmp0 := sym_load_DASH_file.WithMeta(lang.NewMap(kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core_load_DASH_file = ns.InternWithValue(tmp0, nil, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_load_DASH_file.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // load-reader + { + tmp0 := sym_load_DASH_reader.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_rdr)), kw_doc, "Sequentially read and evaluate the set of forms contained in the\n stream/file", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(4081), kw_end_DASH_line, int(4081))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(runtime.Compiler, "load") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("load is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_load_DASH_reader = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_load_DASH_reader.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // load-string + { + tmp0 := sym_load_DASH_string.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_doc, "Sequentially read and evaluate the set of forms contained in the\n string", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(4088), kw_end_DASH_line, int(4088))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "rdr" + tmp4 := lang.Apply(nil, []any{v2}) + tmp5 := lang.Apply(nil, []any{tmp4}) + var v6 any = tmp5 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_load_DASH_reader) + tmp8 := lang.Apply(tmp7, []any{v6}) + tmp3 = tmp8 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_load_DASH_string = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_load_DASH_string.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // macroexpand-1 + { + tmp0 := sym_macroexpand_DASH_1.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_form)), kw_doc, "If form represents a macro form, returns its expansion,\n else returns form.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(4017), kw_end_DASH_line, int(4017))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(runtime.Compiler, "macroexpand1") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("macroexpand1 is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_macroexpand_DASH_1 = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_macroexpand_DASH_1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // make-hierarchy + { + tmp0 := sym_make_DASH_hierarchy.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Creates a hierarchy object for use with derive, isa? etc.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(5507), kw_end_DASH_line, int(5507))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp2 := lang.NewMap() + tmp3 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5511), kw_column, int(16), kw_end_DASH_line, int(5511), kw_end_DASH_column, int(17)) + tmp4, err := lang.WithMeta(tmp2, tmp3.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp5 := lang.NewMap() + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5511), kw_column, int(32), kw_end_DASH_line, int(5511), kw_end_DASH_column, int(33)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp8 := lang.NewMap() + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5511), kw_column, int(46), kw_end_DASH_line, int(5511), kw_end_DASH_column, int(47)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp11 := lang.NewMap(kw_parents, tmp4, kw_descendants, tmp7, kw_ancestors, tmp10) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5511), kw_column, int(6), kw_end_DASH_line, int(5511), kw_end_DASH_column, int(48)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp13 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_make_DASH_hierarchy = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_make_DASH_hierarchy.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // map-entry? + { + tmp0 := sym_map_DASH_entry_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a map entry", kw_file, "glojure/core.glj", kw_added, "1.8", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(1473), kw_end_DASH_line, int(1473))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*lang.MapEntry)(nil)).Elem() + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_map_DASH_entry_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_map_DASH_entry_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // map? + { + tmp0 := sym_map_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x implements IPersistentMap", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(5), kw_column, int(2), kw_line, int(167), kw_end_DASH_line, int(171))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function map? + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := reflect.TypeOf((*lang.IPersistentMap)(nil)).Elem() + tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(171), kw_column, int(7), kw_end_DASH_line, int(171), kw_end_DASH_column, int(97))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_map_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_map_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // max-mask-bits + { + tmp0 := sym_max_DASH_mask_DASH_bits.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(6601), kw_column, int(6), kw_end_DASH_line, int(6601), kw_end_DASH_column, int(28), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core_max_DASH_mask_DASH_bits = ns.InternWithValue(tmp0, int64(13), true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_max_DASH_mask_DASH_bits.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // max-switch-table-size + { + tmp0 := sym_max_DASH_switch_DASH_table_DASH_size.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(6602), kw_column, int(6), kw_end_DASH_line, int(6602), kw_end_DASH_column, int(36), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core_max_DASH_switch_DASH_table_DASH_size = ns.InternWithValue(tmp0, int64(8192), true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_max_DASH_switch_DASH_table_DASH_size.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // meta + { + tmp0 := sym_meta.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_obj)), kw_doc, "Returns the metadata of obj, returns nil if there is no metadata.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(5), kw_column, int(2), kw_line, int(202), kw_end_DASH_line, int(206))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function meta + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp6 := reflect.TypeOf((*lang.IMeta)(nil)).Elem() + tmp7 := lang.Apply(tmp5, []any{tmp6, v3}) + if lang.IsTruthy(tmp7) { + tmp8, ok := lang.FieldOrMethod(v3, "Meta") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "Meta"))) + } + var tmp9 any + switch reflect.TypeOf(tmp8).Kind() { + case reflect.Func: + tmp9 = lang.Apply(tmp8, nil) + default: + tmp9 = tmp8 + } + tmp4 = tmp9 + } else { + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(206), kw_column, int(7), kw_end_DASH_line, int(208), kw_end_DASH_column, int(21))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_meta = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_meta.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // methods + { + tmp0 := sym_methods.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_multifn)), kw_doc, "Given a multimethod, returns a map of dispatch values -> dispatch fns", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(1809), kw_end_DASH_line, int(1809))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "getMethodTable") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getMethodTable"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_methods = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_methods.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // mix-collection-hash + { + tmp0 := sym_mix_DASH_collection_DASH_hash.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_hash_DASH_basis, sym_count)), kw_doc, "Mix final collection hash for ordered or unordered collections.\n hash-basis is the combined collection hash, count is the number\n of elements included in the basis. Note this is the hash code\n consistent with =, different from .hashCode.\n See http://glojure.org/data_structures#hash for full algorithms.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.6", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(25), kw_column, int(7), kw_line, int(5199), kw_end_DASH_line, int(5199))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := lang.Apply(nil, []any{v2, v3}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_mix_DASH_collection_DASH_hash = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_mix_DASH_collection_DASH_hash.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // mk-bound-fn + { + tmp0 := sym_mk_DASH_bound_DASH_fn.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5127), kw_column, int(7), kw_end_DASH_line, int(5127), kw_end_DASH_column, int(17), kw_arglists, lang.NewList(lang.NewVector(sym_sc, sym_test, sym_key)), kw_private, true, kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v6 := args[0] + _ = v6 + tmp7, ok := lang.FieldOrMethod(v2, "comparator") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "comparator"))) + } + var tmp8 any + switch reflect.TypeOf(tmp7).Kind() { + case reflect.Func: + tmp8 = lang.Apply(tmp7, nil) + default: + tmp8 = tmp7 + } + tmp9, _ := lang.FieldOrMethod(v2, "entryKey") + if reflect.TypeOf(tmp9).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("entryKey is not a function"))) + } + tmp10 := lang.Apply(tmp9, []any{v6}) + tmp11, _ := lang.FieldOrMethod(tmp8, "compare") + if reflect.TypeOf(tmp11).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("compare is not a function"))) + } + tmp12 := lang.Apply(tmp11, []any{tmp10, v4}) + tmp13 := lang.Apply(v3, []any{tmp12, int64(0)}) + return tmp13 + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5130), kw_column, int(3), kw_end_DASH_line, int(5131), kw_end_DASH_column, int(64)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp7 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_mk_DASH_bound_DASH_fn = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_mk_DASH_bound_DASH_fn.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // namespace + { + tmp1 := reflect.TypeOf("") + tmp0 := sym_namespace.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns the namespace String of a symbol or keyword, or nil if not present.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(1593), kw_end_DASH_line, int(1593))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v3, "Namespace") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Namespace is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{}) + return tmp5 + }) + tmp3 := reflect.TypeOf("") + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_namespace = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_namespace.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // next + { + tmp1 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() + tmp0 := sym_next.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a seq of the items after the first. Calls seq on its\n argument. If there are no more items, returns nil.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(5), kw_column, int(2), kw_line, int(55), kw_end_DASH_line, int(61))).(*lang.Symbol) + var tmp2 lang.FnFunc + { // function next + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + tmp5 := lang.Apply(lang.Next, []any{v4}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(61), kw_column, int(7), kw_end_DASH_line, int(61), kw_end_DASH_column, int(77))).(lang.FnFunc) + v3 = tmp2 + _ = v3 + } + var_glojure_DOT_core_next = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_next.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // nfirst + { + tmp0 := sym_nfirst.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Same as (next (first x))", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(2), kw_line, int(105), kw_end_DASH_line, int(109))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function nfirst + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_next) + tmp5 := checkDerefVar(var_glojure_DOT_core_first) + tmp6 := lang.Apply(tmp5, []any{v3}) + tmp7 := lang.Apply(tmp4, []any{tmp6}) + return tmp7 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(109), kw_column, int(9), kw_end_DASH_line, int(109), kw_end_DASH_column, int(49))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_nfirst = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_nfirst.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // nil? + { + tmp1 := reflect.TypeOf(false) + var tmp2 lang.FnFunc + { // function nil?__inliner + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_list) + tmp6 := lang.Apply(tmp5, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Identical, v4, nil}) + return tmp6 + }) + v3 = tmp2 + _ = v3 + } + tmp0 := sym_nil_QMARK_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp2, kw_doc, "Returns true if x is nil, false otherwise.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(435), kw_end_DASH_line, int(435))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + tmp5 := lang.Apply(lang.IsNil, []any{v4}) + return tmp5 + }) + tmp4 := reflect.TypeOf(false) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, tmp4)).(lang.FnFunc) + var_glojure_DOT_core_nil_QMARK_ = ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_nil_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // nnext + { + tmp0 := sym_nnext.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Same as (next (next x))", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(6), kw_column, int(2), kw_line, int(119), kw_end_DASH_line, int(123))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function nnext + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_next) + tmp5 := checkDerefVar(var_glojure_DOT_core_next) + tmp6 := lang.Apply(tmp5, []any{v3}) + tmp7 := lang.Apply(tmp4, []any{tmp6}) + return tmp7 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(123), kw_column, int(8), kw_end_DASH_line, int(123), kw_end_DASH_column, int(46))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_nnext = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_nnext.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // not + { + tmp1 := reflect.TypeOf(false) + tmp0 := sym_not.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x is logical false, false otherwise.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(523), kw_end_DASH_line, int(523))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + var tmp4 any + if lang.IsTruthy(v3) { + tmp4 = false + } else { + tmp4 = true + } + return tmp4 + }) + tmp3 := reflect.TypeOf(false) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_not = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_not.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // number? + { + tmp0 := sym_number_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x is a Number", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(3560), kw_end_DASH_line, int(3560))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(lang.IsNumber, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_number_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_number_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // numerator + { + tmp1 := reflect.TypeOf((*big6.Int)(nil)) + tmp0 := sym_numerator.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_r)), kw_doc, "Returns the numerator part of a Ratio.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(3583), kw_end_DASH_line, int(3583))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, ok := lang.FieldOrMethod(v3, "numerator") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "numerator"))) + } + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { + case reflect.Func: + tmp5 = lang.Apply(tmp4, nil) + default: + tmp5 = tmp4 + } + return tmp5 + }) + tmp3 := reflect.TypeOf((*big6.Int)(nil)) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_numerator = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_numerator.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // peek + { + tmp0 := sym_peek.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "For a list or queue, same as first, for a vector, same as, but much\n more efficient than, last. If the collection is empty, returns nil.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1455), kw_end_DASH_line, int(1455))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(runtime.RT, "Peek") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Peek is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_peek = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_peek.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // persistent! + { + tmp0 := sym_persistent_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a new, persistent version of the transient collection, in\n constant time. The transient collection cannot be used after this\n call, any such use will throw an exception.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(3350), kw_end_DASH_line, int(3350))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "Persistent") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "Persistent"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_persistent_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_persistent_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // pop + { + tmp0 := sym_pop.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "For a list or queue, returns a new list/queue without the first\n item, for a vector, returns a new vector without the last item. If\n the collection is empty, throws an exception. Note - not the same\n as next/butlast.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(1462), kw_end_DASH_line, int(1462))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(runtime.RT, "Pop") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Pop is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_pop = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_pop.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // pop! + { + tmp0 := sym_pop_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Removes the last item from a transient vector. If\n the collection is empty, throws an exception. Returns coll", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3393), kw_end_DASH_line, int(3393))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "pop") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "pop"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_pop_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_pop_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // pop-thread-bindings + { + tmp0 := sym_pop_DASH_thread_DASH_bindings.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Pop one set of bindings pushed with push-binding before. It is an error to\n pop bindings without pushing before.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(25), kw_column, int(7), kw_line, int(1929), kw_end_DASH_line, int(1929))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp2 := lang.Apply(lang.PopThreadBindings, nil) + return tmp2 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_pop_DASH_thread_DASH_bindings = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_pop_DASH_thread_DASH_bindings.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // prefer-method + { + tmp0 := sym_prefer_DASH_method.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_multifn, sym_dispatch_DASH_val_DASH_x, sym_dispatch_DASH_val_DASH_y)), kw_doc, "Causes the multimethod to prefer matches of dispatch-val-x over dispatch-val-y \n when there is a conflict", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(1801), kw_end_DASH_line, int(1801))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5, _ := lang.FieldOrMethod(v2, "PreferMethod") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("PreferMethod is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_prefer_DASH_method = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_prefer_DASH_method.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // prefers + { + tmp0 := sym_prefers.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_multifn)), kw_doc, "Given a multimethod, returns a map of preferred value -> set of other values", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(1822), kw_end_DASH_line, int(1822))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "getPreferTable") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getPreferTable"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_prefers = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_prefers.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print-initialized + { + tmp0 := sym_print_DASH_initialized.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core_print.glj", kw_line, int(520), kw_column, int(6), kw_end_DASH_line, int(520), kw_end_DASH_column, int(39), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core_print_DASH_initialized = ns.InternWithValue(tmp0, true, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_print_DASH_initialized.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // push-thread-bindings + { + tmp0 := sym_push_DASH_thread_DASH_bindings.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_bindings)), kw_doc, "WARNING: This is a low-level function. Prefer high-level macros like\n binding where ever possible.\n\n Takes a map of Var/value pairs. Binds each Var to the associated value for\n the current thread. Each call *MUST* be accompanied by a matching call to\n pop-thread-bindings wrapped in a try-finally!\n \n (push-thread-bindings bindings)\n (try\n ...\n (finally\n (pop-thread-bindings)))", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(26), kw_column, int(7), kw_line, int(1911), kw_end_DASH_line, int(1911))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(lang.PushThreadBindings, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_push_DASH_thread_DASH_bindings = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_push_DASH_thread_DASH_bindings.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // random-uuid + { + tmp0 := sym_random_DASH_uuid.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Returns a pseudo-randomly generated java.util.UUID instance (i.e. type 4).\n\n See: https://docs.oracle.com/javase/8/docs/api/java/util/UUID.html#randomUUID--", kw_file, "glojure/core.glj", kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(6852), kw_end_DASH_line, int(6852))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp2 := lang.Apply(uuid10.NewV7, nil) + return tmp2 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_random_DASH_uuid = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_random_DASH_uuid.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ratio? + { + tmp0 := sym_ratio_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_doc, "Returns true if n is a Ratio", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(3577), kw_end_DASH_line, int(3577))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*lang.Ratio)(nil)) + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ratio_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ratio_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // rationalize + { + tmp0 := sym_rationalize.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_num)), kw_doc, "returns the rational value of num", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(1282), kw_end_DASH_line, int(1282))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(lang.Numbers, "Rationalize") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Rationalize is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_rationalize = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_rationalize.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // re-matcher + { + tmp1 := reflect.TypeOf((*lang.RegexpMatcher)(nil)) + tmp0 := sym_re_DASH_matcher.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_re, sym_s)), kw_doc, "Returns an instance of java.util.regex.Matcher, for use, e.g. in\n re-find.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4873), kw_end_DASH_line, int(4873))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(lang.NewRegexpMatcher, []any{v3, v4}) + return tmp5 + }) + tmp3 := reflect.TypeOf((*lang.RegexpMatcher)(nil)) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_re_DASH_matcher = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_re_DASH_matcher.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // re-pattern + { + tmp1 := reflect.TypeOf((*regexp12.Regexp)(nil)) + tmp0 := sym_re_DASH_pattern.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_doc, "Returns an instance of java.util.regex.Pattern, for use, e.g. in\n re-matcher.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4863), kw_end_DASH_line, int(4863))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp6 := reflect.TypeOf((*regexp12.Regexp)(nil)) + tmp7 := lang.Apply(tmp5, []any{tmp6, v3}) + if lang.IsTruthy(tmp7) { + tmp4 = v3 + } else { + tmp8 := lang.Apply(regexp12.MustCompile, []any{v3}) + tmp4 = tmp8 + } + return tmp4 + }) + tmp3 := reflect.TypeOf((*regexp12.Regexp)(nil)) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_re_DASH_pattern = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_re_DASH_pattern.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // read-string + { + tmp0 := sym_read_DASH_string.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s), lang.NewVector(sym_opts, sym_s)), kw_doc, "Reads one object from the string s. Optionally include reader\n options, as specified in read.\n\n Note that read-string can execute code (controlled by *read-eval*),\n and as such should be used only with trusted sources.\n\n For data structure interop use glojure.edn/read-string", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(3806), kw_end_DASH_line, int(3806))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(runtime.RTReadString, []any{v2}) + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := lang.Apply(runtime.RTReadString, []any{v3, v2}) + return tmp4 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_read_DASH_string = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_read_DASH_string.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reader-conditional + { + tmp0 := sym_reader_DASH_conditional.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_form, sym_splicing_QMARK_)), kw_doc, "Construct a data representation of a reader conditional.\n If true, splicing? indicates read-cond-splicing.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(24), kw_column, int(7), kw_line, int(7782), kw_end_DASH_line, int(7782))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := lang.Apply(nil, []any{v2, v3}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_reader_DASH_conditional = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_reader_DASH_conditional.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reader-conditional? + { + tmp0 := sym_reader_DASH_conditional_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_value)), kw_doc, "Return true if the value is the data representation of a reader conditional", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(25), kw_column, int(7), kw_line, int(7776), kw_end_DASH_line, int(7776))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := lang.Apply(tmp3, []any{nil, v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_reader_DASH_conditional_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_reader_DASH_conditional_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // realized? + { + tmp0 := sym_realized_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if a value has been produced for a promise, delay, future or lazy sequence.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(7559), kw_end_DASH_line, int(7559))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "isRealized") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "isRealized"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_realized_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_realized_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reduced + { + tmp0 := sym_reduced.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Wraps x in a way such that a reduce will terminate with the value x", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(2828), kw_end_DASH_line, int(2828))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(lang.NewReduced, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_reduced = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_reduced.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ref-history-count + { + tmp0 := sym_ref_DASH_history_DASH_count.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ref)), kw_doc, "Returns the history count of a ref", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(7), kw_line, int(2455), kw_end_DASH_line, int(2455))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "getHistoryCount") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getHistoryCount"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ref_DASH_history_DASH_count = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ref_DASH_history_DASH_count.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ref-max-history + { + tmp0 := sym_ref_DASH_max_DASH_history.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ref), lang.NewVector(sym_ref, sym_n)), kw_doc, "Gets the max-history of a ref, or sets it and returns the ref", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(2471), kw_end_DASH_line, int(2471))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "getMaxHistory") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getMaxHistory"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "setMaxHistory") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMaxHistory is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ref_DASH_max_DASH_history = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ref_DASH_max_DASH_history.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ref-min-history + { + tmp0 := sym_ref_DASH_min_DASH_history.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ref), lang.NewVector(sym_ref, sym_n)), kw_doc, "Gets the min-history of a ref, or sets it and returns the ref", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(2462), kw_end_DASH_line, int(2462))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "getMinHistory") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getMinHistory"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "setMinHistory") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMinHistory is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ref_DASH_min_DASH_history = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ref_DASH_min_DASH_history.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ref-set + { + tmp0 := sym_ref_DASH_set.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ref, sym_val)), kw_doc, "Must be called in a transaction. Sets the value of ref.\n Returns val.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(2447), kw_end_DASH_line, int(2447))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "set") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("set is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ref_DASH_set = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ref_DASH_set.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // release-pending-sends + { + tmp0 := sym_release_DASH_pending_DASH_sends.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Normally, actions sent directly or indirectly during another action\n are held until the action completes (changes the agent's\n state). This function can be used to dispatch any pending sent\n actions immediately. This has no impact on actions sent during a\n transaction, which are still held until commit. If no action is\n occurring, does nothing. Returns the number of actions dispatched.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(27), kw_column, int(7), kw_line, int(2131), kw_end_DASH_line, int(2131))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp2 := lang.Apply(nil, nil) + return tmp2 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_release_DASH_pending_DASH_sends = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_release_DASH_pending_DASH_sends.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // remove-all-methods + { + tmp0 := sym_remove_DASH_all_DASH_methods.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_multifn)), kw_doc, "Removes all of the methods of multimethod.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(24), kw_column, int(7), kw_line, int(1787), kw_end_DASH_line, int(1787))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "reset") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "reset"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_remove_DASH_all_DASH_methods = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_remove_DASH_all_DASH_methods.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // remove-method + { + tmp0 := sym_remove_DASH_method.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_multifn, sym_dispatch_DASH_val)), kw_doc, "Removes the method of multimethod associated with dispatch-value.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(1794), kw_end_DASH_line, int(1794))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "removeMethod") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("removeMethod is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_remove_DASH_method = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_remove_DASH_method.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // remove-ns + { + tmp0 := sym_remove_DASH_ns.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_sym)), kw_doc, "Removes the namespace named by the symbol. Use with caution.\n Cannot be used to remove the glojure namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(4139), kw_end_DASH_line, int(4139))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(lang.RemoveNamespace, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_remove_DASH_ns = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_remove_DASH_ns.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // remove-watch + { + tmp0 := sym_remove_DASH_watch.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_reference, sym_key)), kw_doc, "Removes a watch (set by add-watch) from a reference", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(2160), kw_end_DASH_line, int(2160))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "removeWatch") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("removeWatch is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_remove_DASH_watch = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_remove_DASH_watch.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // repeat + { + tmp0 := sym_repeat.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_n, sym_x)), kw_doc, "Returns a lazy (infinite!, or length n if supplied) sequence of xs.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(2997), kw_end_DASH_line, int(2997))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(lang.NewRepeat, []any{v2}) + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := lang.Apply(lang.NewRepeatN, []any{v2, v3}) + return tmp4 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_repeat = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_repeat.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reset! + { + tmp0 := sym_reset_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_atom, sym_newval)), kw_doc, "Sets the value of atom to newval without regard for the\n current value. Returns newval.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(2368), kw_end_DASH_line, int(2368))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "reset") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_reset_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_reset_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reset-meta! + { + tmp0 := sym_reset_DASH_meta_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_iref, sym_metadata_DASH_map)), kw_doc, "Atomically resets the metadata for a namespace/var/ref/agent/atom", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(2408), kw_end_DASH_line, int(2408))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "ResetMeta") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ResetMeta is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_reset_DASH_meta_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_reset_DASH_meta_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reset-vals! + { + tmp0 := sym_reset_DASH_vals_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_atom, sym_newval)), kw_doc, "Sets the value of atom to newval. Returns [old new], the value of the\n atom before and after the reset.", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(2375), kw_end_DASH_line, int(2375))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "resetVals") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("resetVals is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_reset_DASH_vals_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_reset_DASH_vals_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // rest + { + tmp1 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() + tmp0 := sym_rest.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a possibly empty seq of the items after the first. Calls seq on its\n argument.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(5), kw_column, int(2), kw_line, int(64), kw_end_DASH_line, int(70))).(*lang.Symbol) + var tmp2 lang.FnFunc + { // function rest + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + tmp5 := lang.Apply(lang.Rest, []any{v4}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(70), kw_column, int(7), kw_end_DASH_line, int(70), kw_end_DASH_column, int(77))).(lang.FnFunc) + v3 = tmp2 + _ = v3 + } + var_glojure_DOT_core_rest = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_rest.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reversible? + { + tmp0 := sym_reversible_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns true if coll implements Reversible", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(6257), kw_end_DASH_line, int(6257))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := lang.Apply(tmp3, []any{nil, v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_reversible_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_reversible_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // rseq + { + tmp0 := sym_rseq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_rev)), kw_doc, "Returns, in constant time, a seq of the items in rev (which\n can be a vector or sorted-map), in reverse order. If rev is empty returns nil", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1577), kw_end_DASH_line, int(1577))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(v2, "rseq") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("rseq is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_rseq = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_rseq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // second + { + tmp0 := sym_second.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Same as (first (next x))", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(2), kw_line, int(91), kw_end_DASH_line, int(95))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function second + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_first) + tmp5 := checkDerefVar(var_glojure_DOT_core_next) + tmp6 := lang.Apply(tmp5, []any{v3}) + tmp7 := lang.Apply(tmp4, []any{tmp6}) + return tmp7 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(95), kw_column, int(9), kw_end_DASH_line, int(95), kw_end_DASH_column, int(49))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_second = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_second.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // seq + { + tmp1 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() + tmp0 := sym_seq.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a seq on the collection. If the collection is\n empty, returns nil. (seq nil) returns nil. seq also works on\n Strings, native Java arrays (of reference types) and any objects\n that implement Iterable. Note that seqs cache values, thus seq\n should not be used on any Iterable whose iterator repeatedly\n returns the same mutable object.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(4), kw_column, int(2), kw_line, int(126), kw_end_DASH_line, int(136))).(*lang.Symbol) + var tmp2 lang.FnFunc + { // function seq + var v3 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + tmp5 := lang.Apply(lang.Seq, []any{v4}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(136), kw_column, int(6), kw_end_DASH_line, int(136), kw_end_DASH_column, int(126))).(lang.FnFunc) + v3 = tmp2 + _ = v3 + } + var_glojure_DOT_core_seq = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_seq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // seq? + { + tmp0 := sym_seq_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x implements ISeq", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(5), kw_column, int(2), kw_line, int(146), kw_end_DASH_line, int(150))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function seq? + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() + tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(150), kw_column, int(7), kw_end_DASH_line, int(150), kw_end_DASH_column, int(87))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_seq_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_seq_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // seqable? + { + tmp0 := sym_seqable_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if the seq function is supported for x", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(6204), kw_end_DASH_line, int(6204))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(nil, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_seqable_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_seqable_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // sequential? + { + tmp0 := sym_sequential_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns true if coll implements Sequential", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(6229), kw_end_DASH_line, int(6229))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*lang.Sequential)(nil)).Elem() + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_sequential_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_sequential_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // set-agent-send-executor! + { + tmp0 := sym_set_DASH_agent_DASH_send_DASH_executor_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_executor)), kw_doc, "Sets the ExecutorService to be used by send", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(30), kw_column, int(7), kw_line, int(2087), kw_end_DASH_line, int(2087))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + return nil + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_set_DASH_agent_DASH_send_DASH_executor_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_set_DASH_agent_DASH_send_DASH_executor_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // set-agent-send-off-executor! + { + tmp0 := sym_set_DASH_agent_DASH_send_DASH_off_DASH_executor_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_executor)), kw_doc, "Sets the ExecutorService to be used by send-off", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(34), kw_column, int(7), kw_line, int(2093), kw_end_DASH_line, int(2093))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + return nil + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_set_DASH_agent_DASH_send_DASH_off_DASH_executor_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_set_DASH_agent_DASH_send_DASH_off_DASH_executor_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // set-error-handler! + { + tmp0 := sym_set_DASH_error_DASH_handler_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a, sym_handler_DASH_fn)), kw_doc, "Sets the error-handler of agent a to handler-fn. If an action\n being run by the agent throws an exception or doesn't pass the\n validator fn, handler-fn will be called with two arguments: the\n agent and the exception.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(24), kw_column, int(7), kw_line, int(2192), kw_end_DASH_line, int(2192))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "setErrorHandler") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorHandler is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_set_DASH_error_DASH_handler_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_set_DASH_error_DASH_handler_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // set-error-mode! + { + tmp0 := sym_set_DASH_error_DASH_mode_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a, sym_mode_DASH_keyword)), kw_doc, "Sets the error-mode of agent a to mode-keyword, which must be\n either :fail or :continue. If an action being run by the agent\n throws an exception or doesn't pass the validator fn, an\n error-handler may be called (see set-error-handler!), after which,\n if the mode is :continue, the agent will continue as if neither the\n action that caused the error nor the error itself ever happened.\n \n If the mode is :fail, the agent will become failed and will stop\n accepting new 'send' and 'send-off' actions, and any previously\n queued actions will be held until a 'restart-agent'. Deref will\n still work, returning the state of the agent before the error.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(2210), kw_end_DASH_line, int(2210))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "setErrorMode") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorMode is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_set_DASH_error_DASH_mode_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_set_DASH_error_DASH_mode_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // set-validator! + { + tmp0 := sym_set_DASH_validator_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_iref, sym_validator_DASH_fn)), kw_doc, "Sets the validator-fn for a var/ref/agent/atom. validator-fn must be nil or a\n side-effect-free fn of one argument, which will be passed the intended\n new state on any state change. If the new state is unacceptable, the\n validator-fn should return false or throw an exception. If the current state (root\n value if var) is not acceptable to the new validator, an exception\n will be thrown and the validator will not be changed.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(2381), kw_end_DASH_line, int(2381))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "setValidator") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setValidator is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_set_DASH_validator_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_set_DASH_validator_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // set? + { + tmp0 := sym_set_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x implements IPersistentSet", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(4098), kw_end_DASH_line, int(4098))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*lang.IPersistentSet)(nil)).Elem() + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_set_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_set_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // shutdown-agents + { + tmp0 := sym_shutdown_DASH_agents.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Initiates a shutdown of the thread pools that back the agent\n system. Running actions will complete, but no new actions will be\n accepted", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(2252), kw_end_DASH_line, int(2252))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp2 := lang.Apply(lang.ShutdownAgents, nil) + return tmp2 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_shutdown_DASH_agents = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_shutdown_DASH_agents.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // simple-keyword? + { + tmp0 := sym_simple_DASH_keyword_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a keyword without a namespace", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(1633), kw_end_DASH_line, int(1633))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "and__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + tmp8 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp9 := checkDerefVar(var_glojure_DOT_core_namespace) + tmp10 := lang.Apply(tmp9, []any{v2}) + tmp11 := lang.Apply(tmp8, []any{tmp10}) + tmp7 = tmp11 + } else { + tmp7 = v6 + } + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_simple_DASH_keyword_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_simple_DASH_keyword_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // some + { + tmp0 := sym_some.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns the first logical true value of (pred x) for any x in coll,\n else nil. One common idiom is to use a set as pred, for example\n this will return :fred if :fred is in the sequence, otherwise nil:\n (some #{:fred} coll)", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(2684), kw_end_DASH_line, int(2684))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + recur_loop_2021: + var tmp4 any + { // let + // let binding "temp__0__auto__" + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := lang.Apply(tmp5, []any{v3}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + if lang.IsTruthy(v7) { + var tmp9 any + { // let + // let binding "s" + var v10 any = v7 + _ = v10 + var tmp11 any + { // let + // let binding "or__0__auto__" + tmp12 := checkDerefVar(var_glojure_DOT_core_first) + tmp13 := lang.Apply(tmp12, []any{v10}) + tmp14 := lang.Apply(v2, []any{tmp13}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + if lang.IsTruthy(v15) { + tmp16 = v15 + } else { + var tmp17 any = v2 + tmp19 := checkDerefVar(var_glojure_DOT_core_next) + tmp20 := lang.Apply(tmp19, []any{v10}) + var tmp18 any = tmp20 + v2 = tmp17 + v3 = tmp18 + goto recur_loop_2021 + } + tmp11 = tmp16 + } // end let + tmp9 = tmp11 + } // end let + tmp8 = tmp9 + } else { + } + tmp4 = tmp8 + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_some = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_some.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // some? + { + tmp1 := reflect.TypeOf(false) + tmp0 := sym_some_QMARK_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x is not nil, false otherwise.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.6", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(530), kw_end_DASH_line, int(530))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_not) + tmp5 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + tmp7 := lang.Apply(tmp4, []any{tmp6}) + return tmp7 + }) + tmp3 := reflect.TypeOf(false) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_some_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_some_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // sorted-map + { + tmp0 := sym_sorted_DASH_map.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_keyvals)), kw_doc, "keyval => key val\n Returns a new sorted map with supplied mappings. If any keys are\n equal, they are handled as if by repeated uses of assoc.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(397), kw_end_DASH_line, int(397))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + tmp3 := lang.Apply(lang.CreatePersistentTreeMap, []any{v2}) + return tmp3 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_sorted_DASH_map = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_sorted_DASH_map.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // sorted-map-by + { + tmp0 := sym_sorted_DASH_map_DASH_by.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_comparator, sym__AMP_, sym_keyvals)), kw_doc, "keyval => key val\n Returns a new sorted map with supplied mappings, using the supplied\n comparator. If any keys are equal, they are handled as if by\n repeated uses of assoc.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(406), kw_end_DASH_line, int(406))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + tmp4 := lang.Apply(nil, []any{v2, v3}) + return tmp4 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_sorted_DASH_map_DASH_by = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_sorted_DASH_map_DASH_by.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // sorted-set + { + tmp0 := sym_sorted_DASH_set.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_keys)), kw_doc, "Returns a new sorted set with supplied keys. Any equal keys are\n handled as if by repeated uses of conj.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(416), kw_end_DASH_line, int(416))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + tmp3 := lang.Apply(lang.CreatePersistentTreeSet, []any{v2}) + return tmp3 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_sorted_DASH_set = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_sorted_DASH_set.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // sorted-set-by + { + tmp0 := sym_sorted_DASH_set_DASH_by.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_comparator, sym__AMP_, sym_keys)), kw_doc, "Returns a new sorted set with supplied keys, using the supplied\n comparator. Any equal keys are handled as if by repeated uses of\n conj.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(424), kw_end_DASH_line, int(424))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + tmp4 := lang.Apply(lang.CreatePersistentTreeSetWithComparator, []any{v2, v3}) + return tmp4 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_sorted_DASH_set_DASH_by = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_sorted_DASH_set_DASH_by.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // sorted? + { + tmp0 := sym_sorted_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns true if coll implements Sorted", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(6235), kw_end_DASH_line, int(6235))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := lang.Apply(tmp3, []any{nil, v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_sorted_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_sorted_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // special-symbol? + { + tmp0 := sym_special_DASH_symbol_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_doc, "Returns true if s names a special form", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(4992), kw_end_DASH_line, int(4992))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp4, ok := lang.FieldOrMethod(runtime.Compiler, "specials") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", runtime.Compiler, "specials"))) + } + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { + case reflect.Func: + tmp5 = lang.Apply(tmp4, nil) + default: + tmp5 = tmp4 + } + tmp6 := lang.Apply(tmp3, []any{tmp5, v2}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_special_DASH_symbol_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_special_DASH_symbol_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // spread + { + tmp0 := sym_spread.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_arglist)), kw_static, true, kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(632), kw_end_DASH_line, int(632), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + } else { + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp8 := checkDerefVar(var_glojure_DOT_core_next) + tmp9 := lang.Apply(tmp8, []any{v2}) + tmp10 := lang.Apply(tmp7, []any{tmp9}) + if lang.IsTruthy(tmp10) { + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_first) + tmp13 := lang.Apply(tmp12, []any{v2}) + tmp14 := lang.Apply(tmp11, []any{tmp13}) + tmp6 = tmp14 + } else { + var tmp15 any + if lang.IsTruthy(kw_else) { + tmp16 := checkDerefVar(var_glojure_DOT_core_cons) + tmp17 := checkDerefVar(var_glojure_DOT_core_first) + tmp18 := lang.Apply(tmp17, []any{v2}) + tmp19 := checkDerefVar(var_glojure_DOT_core_spread) + tmp20 := checkDerefVar(var_glojure_DOT_core_next) + tmp21 := lang.Apply(tmp20, []any{v2}) + tmp22 := lang.Apply(tmp19, []any{tmp21}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp22}) + tmp15 = tmp23 + } else { + } + tmp6 = tmp15 + } + tmp3 = tmp6 + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_spread = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_spread.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // str + { + tmp1 := reflect.TypeOf("") + tmp0 := sym_str.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_x), lang.NewVector(sym_x, sym__AMP_, sym_ys)), kw_doc, "With no args, returns the empty string. With one arg x, returns\n x.toString(). (str nil) returns the empty string. With more than\n one arg, returns the concatenation of the str values of the args.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(543), kw_end_DASH_line, int(543))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return "" + case 1: + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + tmp4 = "" + } else { + tmp7 := lang.Apply(lang.ToString, []any{v3}) + tmp4 = tmp7 + } + return tmp4 + default: + checkArity(args, 1) + v3 := args[0] + _ = v3 + var v4 any = lang.NewList(args[1:]...) + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + recur_loop_1614: + var tmp8 any + if lang.IsTruthy(v7) { + tmp10 := checkDerefVar(var_glojure_DOT_core_str) + tmp11 := checkDerefVar(var_glojure_DOT_core_first) + tmp12 := lang.Apply(tmp11, []any{v7}) + tmp13 := lang.Apply(tmp10, []any{tmp12}) + tmp14, _ := lang.FieldOrMethod(v6, "WriteString") + if reflect.TypeOf(tmp14).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("WriteString is not a function"))) + } + tmp15 := lang.Apply(tmp14, []any{tmp13}) + _ = tmp15 + var tmp9 any = v6 + tmp17 := checkDerefVar(var_glojure_DOT_core_next) + tmp18 := lang.Apply(tmp17, []any{v7}) + var tmp16 any = tmp18 + v6 = tmp9 + v7 = tmp16 + goto recur_loop_1614 + } else { + tmp19, ok := lang.FieldOrMethod(v6, "String") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "String"))) + } + var tmp20 any + switch reflect.TypeOf(tmp19).Kind() { + case reflect.Func: + tmp20 = lang.Apply(tmp19, nil) + default: + tmp20 = tmp19 + } + tmp8 = tmp20 + } + return tmp8 + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(554), kw_column, int(7), kw_end_DASH_line, int(554), kw_end_DASH_column, int(127)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp8 := checkDerefVar(var_glojure_DOT_core_cons) + tmp9 := lang.Apply(tmp8, []any{v3, v4}) + tmp10 := lang.Apply(tmp7, []any{"unimplemented: new with non-constant class type", tmp9}) + return tmp10 + } + }) + tmp3 := reflect.TypeOf("") + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_str = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_str.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // stream-reduce! + { + tmp0 := sym_stream_DASH_reduce_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_s), lang.NewVector(sym_f, sym_init, sym_s)), kw_doc, "Works like reduce but takes a java.util.stream.BaseStream as its source.\n Honors 'reduced', is a terminal operation on the stream", kw_file, "glojure/core.glj", kw_added, "1.12", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(6784), kw_end_DASH_line, int(6784))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, ok := lang.FieldOrMethod(v3, "iterator") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "iterator"))) + } + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { + case reflect.Func: + tmp5 = lang.Apply(tmp4, nil) + default: + tmp5 = tmp4 + } + tmp6 := lang.Apply(nil, []any{tmp5, v2}) + return tmp6 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5, ok := lang.FieldOrMethod(v4, "iterator") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "iterator"))) + } + var tmp6 any + switch reflect.TypeOf(tmp5).Kind() { + case reflect.Func: + tmp6 = lang.Apply(tmp5, nil) + default: + tmp6 = tmp5 + } + tmp7 := lang.Apply(nil, []any{tmp6, v2, v3}) + return tmp7 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_stream_DASH_reduce_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_stream_DASH_reduce_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // stream-seq! + { + tmp0 := sym_stream_DASH_seq_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_stream)), kw_doc, "Takes a java.util.stream.BaseStream instance s and returns a seq of its\n contents. This is a terminal operation on the stream.", kw_file, "glojure/core.glj", kw_added, "1.12", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(6793), kw_end_DASH_line, int(6793))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_iterator_DASH_seq) + tmp4, ok := lang.FieldOrMethod(v2, "iterator") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "iterator"))) + } + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { + case reflect.Func: + tmp5 = lang.Apply(tmp4, nil) + default: + tmp5 = tmp4 + } + tmp6 := lang.Apply(tmp3, []any{tmp5}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_stream_DASH_seq_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_stream_DASH_seq_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // stream-transduce! + { + tmp0 := sym_stream_DASH_transduce_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xform, sym_f, sym_stream), lang.NewVector(sym_xform, sym_f, sym_init, sym_stream)), kw_doc, "Works like transduce but takes a java.util.stream.BaseStream as its source.\n This is a terminal operation on the stream.", kw_file, "glojure/core.glj", kw_added, "1.12", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(7), kw_line, int(6800), kw_end_DASH_line, int(6800))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_stream_DASH_transduce_BANG_) + tmp6 := lang.Apply(v3, nil) + tmp7 := lang.Apply(tmp5, []any{v2, v3, tmp6, v4}) + return tmp7 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var tmp6 any + { // let + // let binding "f" + tmp7 := lang.Apply(v2, []any{v3}) + var v8 any = tmp7 + _ = v8 + // let binding "ret" + tmp9 := checkDerefVar(var_glojure_DOT_core_stream_DASH_reduce_BANG_) + tmp10 := lang.Apply(tmp9, []any{v8, v4, v5}) + var v11 any = tmp10 + _ = v11 + tmp12 := lang.Apply(v8, []any{v11}) + tmp6 = tmp12 + } // end let + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_stream_DASH_transduce_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_stream_DASH_transduce_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // string? + { + tmp0 := sym_string_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a String", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(2), kw_line, int(160), kw_end_DASH_line, int(164))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function string? + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := lang.Apply(tmp4, []any{lang.Builtins["string"], v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(164), kw_column, int(10), kw_end_DASH_line, int(164), kw_end_DASH_column, int(58))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_string_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_string_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // struct + { + tmp0 := sym_struct.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s, sym__AMP_, sym_vals)), kw_doc, "Returns a new structmap instance with the keys of the\n structure-basis. vals must be supplied for basis keys in order -\n where values are not supplied they will default to nil.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(4061), kw_end_DASH_line, int(4061))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + tmp4 := lang.Apply(lang.ConstructPersistentStructMap, []any{v2, v3}) + return tmp4 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_struct = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_struct.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // struct-map + { + tmp0 := sym_struct_DASH_map.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s, sym__AMP_, sym_inits)), kw_doc, "Returns a new structmap instance with the keys of the\n structure-basis. keyvals may contain all, some or none of the basis\n keys - where values are not supplied they will default to nil.\n keyvals can also contain keys not in the basis.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4051), kw_end_DASH_line, int(4051))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + tmp4 := lang.Apply(lang.CreatePersistentStructMap, []any{v2, v3}) + return tmp4 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_struct_DASH_map = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_struct_DASH_map.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // subs + { + tmp0 := sym_subs.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s, sym_start), lang.NewVector(sym_s, sym_start, sym_end)), kw_doc, "Returns the substring of s beginning at start inclusive, and ending\n at end (defaults to length of string), exclusive.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(5005), kw_end_DASH_line, int(5005))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := lang.Apply(lang.Builtins["slice"], []any{v2, v3}) + return tmp4 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := lang.Apply(lang.Builtins["slice"], []any{v2, v3, v4}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_subs = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_subs.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // swap! + { + tmp0 := sym_swap_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_atom, sym_f, sym__AMP_, sym_args)), kw_doc, "Atomically swaps the value of atom to be:\n (apply f current-value-of-atom args). Note that f may be called\n multiple times, and thus should be free of side effects. Returns\n the value that was swapped in.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(2343), kw_end_DASH_line, int(2343))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5, _ := lang.FieldOrMethod(v2, "swap") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("swap is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_swap_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_swap_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // swap-vals! + { + tmp0 := sym_swap_DASH_vals_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_atom, sym_f, sym__AMP_, sym_args)), kw_doc, "Atomically swaps the value of atom to be:\n (apply f current-value-of-atom args). Note that f may be called\n multiple times, and thus should be free of side effects.\n Returns [old new], the value of the atom before and after the swap.", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(2352), kw_end_DASH_line, int(2352))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5, _ := lang.FieldOrMethod(v2, "swapVals") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("swapVals is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_swap_DASH_vals_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_swap_DASH_vals_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // symbol? + { + tmp0 := sym_symbol_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a Symbol", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(557), kw_end_DASH_line, int(557))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*lang.Symbol)(nil)) + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_symbol_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_symbol_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // system-newline + { + tmp0 := sym_system_DASH_newline.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(3695), kw_column, int(6), kw_end_DASH_line, int(3695), kw_end_DASH_column, int(40), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core_system_DASH_newline = ns.InternWithValue(tmp0, "\n", true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_system_DASH_newline.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // tagged-literal + { + tmp0 := sym_tagged_DASH_literal.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_tag, sym_form)), kw_doc, "Construct a data representation of a tagged literal from a\n tag symbol and a form.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(7769), kw_end_DASH_line, int(7769))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := lang.Apply(nil, []any{v2, v3}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_tagged_DASH_literal = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_tagged_DASH_literal.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // tagged-literal? + { + tmp0 := sym_tagged_DASH_literal_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_value)), kw_doc, "Return true if the value is the data representation of a tagged literal", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(7763), kw_end_DASH_line, int(7763))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := lang.Apply(tmp3, []any{nil, v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_tagged_DASH_literal_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_tagged_DASH_literal_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // take-while + { + tmp0 := sym_take_DASH_while.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred), lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns a lazy sequence of successive items from coll while\n (pred item) returns logical true. pred must be free of side-effects.\n Returns a transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(2880), kw_end_DASH_line, int(2880))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp6 := lang.Apply(v4, nil) + return tmp6 + case 1: + v6 := args[0] + _ = v6 + tmp7 := lang.Apply(v4, []any{v6}) + return tmp7 + case 2: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + var tmp8 any + tmp9 := lang.Apply(v2, []any{v7}) + if lang.IsTruthy(tmp9) { + tmp10 := lang.Apply(v4, []any{v6, v7}) + tmp8 = tmp10 + } else { + tmp11 := checkDerefVar(var_glojure_DOT_core_reduced) + tmp12 := lang.Apply(tmp11, []any{v6}) + tmp8 = tmp12 + } + return tmp8 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2888), kw_column, int(8), kw_end_DASH_line, int(2894), kw_end_DASH_column, int(33)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp7 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2887), kw_column, int(6), kw_end_DASH_line, int(2894), kw_end_DASH_column, int(34)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp5 any + { // let + // let binding "temp__0__auto__" + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := lang.Apply(tmp6, []any{v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + var tmp10 any + { // let + // let binding "s" + var v11 any = v8 + _ = v11 + var tmp12 any + tmp13 := checkDerefVar(var_glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v11}) + tmp15 := lang.Apply(v2, []any{tmp14}) + if lang.IsTruthy(tmp15) { + tmp16 := checkDerefVar(var_glojure_DOT_core_cons) + tmp17 := checkDerefVar(var_glojure_DOT_core_first) + tmp18 := lang.Apply(tmp17, []any{v11}) + tmp19 := checkDerefVar(var_glojure_DOT_core_take_DASH_while) + tmp20 := checkDerefVar(var_glojure_DOT_core_rest) + tmp21 := lang.Apply(tmp20, []any{v11}) + tmp22 := lang.Apply(tmp19, []any{v2, tmp21}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp22}) + tmp12 = tmp23 + } else { + } + tmp10 = tmp12 + } // end let + tmp9 = tmp10 + } else { + } + tmp5 = tmp9 + } // end let + return tmp5 + }) + tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_take_DASH_while = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_take_DASH_while.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // tapset + { + tmp0 := sym_tapset.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(7882), kw_column, int(10), kw_end_DASH_line, int(7882), kw_end_DASH_column, int(25), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + tmp1 := lang.NewAtom(lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{}))) + var_glojure_DOT_core_tapset = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_tapset.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // test + { + tmp0 := sym_test.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_v)), kw_doc, "test [v] finds fn at key :test in var metadata and calls it,\n presuming failure will throw exception", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(4853), kw_end_DASH_line, int(4853))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "f" + tmp4 := checkDerefVar(var_glojure_DOT_core_meta) + tmp5 := lang.Apply(tmp4, []any{v2}) + tmp6 := lang.Apply(kw_test, []any{tmp5}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + if lang.IsTruthy(v7) { + tmp9 := lang.Apply(v7, nil) + _ = tmp9 + tmp8 = kw_ok + } else { + tmp8 = kw_no_DASH_test + } + tmp3 = tmp8 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_test = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_test.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // the-ns + { + tmp0 := sym_the_DASH_ns.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "If passed a namespace, returns it. Else, when passed a symbol,\n returns the namespace named by it, throwing an exception if not\n found.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(4152), kw_end_DASH_line, int(4152))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := reflect.TypeOf((*lang.Namespace)(nil)) + tmp6 := lang.Apply(tmp4, []any{tmp5, v2}) + if lang.IsTruthy(tmp6) { + tmp3 = v2 + } else { + var tmp7 any + { // let + // let binding "or__0__auto__" + tmp8 := checkDerefVar(var_glojure_DOT_core_find_DASH_ns) + tmp9 := lang.Apply(tmp8, []any{v2}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + if lang.IsTruthy(v10) { + tmp11 = v10 + } else { + tmp12 := checkDerefVar(var_glojure_DOT_core_str) + tmp13 := lang.Apply(tmp12, []any{"No namespace: ", v2, " found"}) + tmp14 := lang.Apply(lang.NewError, []any{tmp13}) + panic(tmp14) + } + tmp7 = tmp11 + } // end let + tmp3 = tmp7 + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_the_DASH_ns = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_the_DASH_ns.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // to-array + { + tmp0 := sym_to_DASH_array.WithMeta(lang.NewMap(kw_tag, "[Ljava.lang.Object;", kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns an array of Objects containing the contents of coll, which\n can be any Collection. Maps to java.util.Collection.toArray().", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(337), kw_end_DASH_line, int(337))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(runtime.RT, "ToArray") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ToArray is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, "[Ljava.lang.Object;")).(lang.FnFunc) + var_glojure_DOT_core_to_DASH_array = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_to_DASH_array.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // transient + { + tmp0 := sym_transient.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a new, transient version of the collection, in constant time.\n\n Transients support a parallel set of 'changing' operations, with similar names\n followed by ! - assoc!, conj! etc. These do the same things as their persistent\n counterparts except the return values are themselves transient.\n\n Note in particular that transients are not designed to be bashed in-place. You\n must capture and use the return value in the next call. In this way, they support\n the same code structure as the functional persistent code they replace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(3335), kw_end_DASH_line, int(3335))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, ok := lang.FieldOrMethod(v2, "AsTransient") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "AsTransient"))) + } + var tmp4 any + switch reflect.TypeOf(tmp3).Kind() { + case reflect.Func: + tmp4 = lang.Apply(tmp3, nil) + default: + tmp4 = tmp3 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_transient = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_transient.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // true? + { + tmp1 := reflect.TypeOf(false) + tmp0 := sym_true_QMARK_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x is the value true, false otherwise.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(511), kw_end_DASH_line, int(511))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.Identical, []any{v3, true}) + return tmp4 + }) + tmp3 := reflect.TypeOf(false) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_true_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_true_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unquote + { + tmp0 := sym_unquote.WithMeta(lang.NewMap()).(*lang.Symbol) + var_glojure_DOT_core_unquote = ns.Intern(tmp0) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unquote.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unquote-splicing + { + tmp0 := sym_unquote_DASH_splicing.WithMeta(lang.NewMap()).(*lang.Symbol) + var_glojure_DOT_core_unquote_DASH_splicing = ns.Intern(tmp0) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unquote_DASH_splicing.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // uri? + { + tmp0 := sym_uri_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a java.net.URI", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(7877), kw_end_DASH_line, int(7877))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*url14.URL)(nil)).Elem() + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_uri_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_uri_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // uuid? + { + tmp0 := sym_uuid_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a java.util.UUID", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(6847), kw_end_DASH_line, int(6847))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf([16]uint8{}) + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_uuid_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_uuid_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // val + { + tmp0 := sym_val.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_e)), kw_doc, "Returns the value in the map entry.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(1570), kw_end_DASH_line, int(1570))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(v2, "GetValue") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("GetValue is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_val = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_val.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // vals + { + tmp0 := sym_vals.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_map)), kw_doc, "Returns a sequence of the map's values, in the same order as (seq map).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1557), kw_end_DASH_line, int(1557))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(lang.Vals, []any{v2}) + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_vals = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_vals.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // var-get + { + tmp0 := sym_var_DASH_get.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Gets the value in the var object", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4326), kw_end_DASH_line, int(4326))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3, _ := lang.FieldOrMethod(v2, "Get") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Get is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_var_DASH_get = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_var_DASH_get.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // var-set + { + tmp0 := sym_var_DASH_set.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_val)), kw_doc, "Sets the value in the var object to val. The var must be\n thread-locally bound.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4332), kw_end_DASH_line, int(4332))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "Set") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Set is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_var_DASH_set = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_var_DASH_set.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // var? + { + tmp0 := sym_var_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_v)), kw_doc, "Returns true if v is of type glojure.lang.Var", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(4999), kw_end_DASH_line, int(4999))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*lang.Var)(nil)) + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_var_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_var_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // vector + { + tmp0 := sym_vector.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_a), lang.NewVector(sym_a, sym_b), lang.NewVector(sym_a, sym_b, sym_c), lang.NewVector(sym_a, sym_b, sym_c, sym_d), lang.NewVector(sym_a, sym_b, sym_c, sym_d, sym_e), lang.NewVector(sym_a, sym_b, sym_c, sym_d, sym_e, sym_f), lang.NewVector(sym_a, sym_b, sym_c, sym_d, sym_e, sym_f, sym__AMP_, sym_args)), kw_doc, "Creates a new vector containing the args.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(352), kw_end_DASH_line, int(352))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp2 := lang.NewVector() + tmp3 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(356), kw_column, int(7), kw_end_DASH_line, int(356), kw_end_DASH_column, int(8)) + tmp4, err := lang.WithMeta(tmp2, tmp3.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp4 + case 1: + v2 := args[0] + _ = v2 + tmp3 := lang.NewVector(v2) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(357), kw_column, int(8), kw_end_DASH_line, int(357), kw_end_DASH_column, int(10)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := lang.NewVector(v2, v3) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(358), kw_column, int(10), kw_end_DASH_line, int(358), kw_end_DASH_column, int(14)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := lang.NewVector(v2, v3, v4) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(359), kw_column, int(12), kw_end_DASH_line, int(359), kw_end_DASH_column, int(18)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp7 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + tmp6 := lang.NewVector(v2, v3, v4, v5) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(360), kw_column, int(14), kw_end_DASH_line, int(360), kw_end_DASH_column, int(22)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp8 + case 5: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + tmp7 := lang.NewVector(v2, v3, v4, v5, v6) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(361), kw_column, int(15), kw_end_DASH_line, int(361), kw_end_DASH_column, int(25)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp9 + case 6: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + v7 := args[5] + _ = v7 + tmp8 := lang.NewVector(v2, v3, v4, v5, v6, v7) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(362), kw_column, int(17), kw_end_DASH_line, int(362), kw_end_DASH_column, int(29)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp10 + default: + checkArity(args, 6) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + v7 := args[5] + _ = v7 + var v8 any = lang.NewList(args[6:]...) + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_cons) + tmp10 := checkDerefVar(var_glojure_DOT_core_cons) + tmp11 := checkDerefVar(var_glojure_DOT_core_cons) + tmp12 := checkDerefVar(var_glojure_DOT_core_cons) + tmp13 := checkDerefVar(var_glojure_DOT_core_cons) + tmp14 := checkDerefVar(var_glojure_DOT_core_cons) + tmp15 := lang.Apply(tmp14, []any{v7, v8}) + tmp16 := lang.Apply(tmp13, []any{v6, tmp15}) + tmp17 := lang.Apply(tmp12, []any{v5, tmp16}) + tmp18 := lang.Apply(tmp11, []any{v4, tmp17}) + tmp19 := lang.Apply(tmp10, []any{v3, tmp18}) + tmp20 := lang.Apply(tmp9, []any{v2, tmp19}) + tmp21 := lang.Apply(lang.CreateLazilyPersistentVector, []any{tmp20}) + return tmp21 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_vector = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_vector.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // vector? + { + tmp0 := sym_vector_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x implements IPersistentVector", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(2), kw_line, int(174), kw_end_DASH_line, int(178))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function vector? + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := reflect.TypeOf((*lang.IPersistentVector)(nil)).Elem() + tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(178), kw_column, int(10), kw_end_DASH_line, int(178), kw_end_DASH_column, int(106))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_vector_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_vector_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // volatile! + { + tmp1 := reflect.TypeOf((*lang.Volatile)(nil)).Elem() + tmp0 := sym_volatile_BANG_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_val)), kw_doc, "Creates and returns a Volatile with an initial value of val.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(2517), kw_end_DASH_line, int(2517))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.NewVolatile, []any{v3}) + return tmp4 + }) + tmp3 := reflect.TypeOf((*lang.Volatile)(nil)).Elem() + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_volatile_BANG_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_volatile_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // volatile? + { + tmp0 := sym_volatile_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x is a volatile.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(2540), kw_end_DASH_line, int(2540))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*lang.Volatile)(nil)).Elem() + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_volatile_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_volatile_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // vreset! + { + tmp0 := sym_vreset_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_vol, sym_newval)), kw_doc, "Sets the value of volatile to newval without regard for the\n current value. Returns newval.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(2524), kw_end_DASH_line, int(2524))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "reset") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_vreset_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_vreset_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // when + { + tmp0 := sym_when.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_test, sym__AMP_, sym_body)), kw_doc, "Evaluates test. If logical true, evaluates body in an implicit do.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(11), kw_line, int(492), kw_end_DASH_line, int(492))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := checkDerefVar(var_glojure_DOT_core_cons) + tmp8 := lang.Apply(tmp7, []any{sym_do, v5}) + tmp9 := lang.Apply(tmp6, []any{sym_if, v4, tmp8}) + return tmp9 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_when = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_when.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // when-not + { + tmp0 := sym_when_DASH_not.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_test, sym__AMP_, sym_body)), kw_doc, "Evaluates test. If logical false, evaluates body in an implicit do.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(11), kw_line, int(498), kw_end_DASH_line, int(498))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := checkDerefVar(var_glojure_DOT_core_cons) + tmp8 := lang.Apply(tmp7, []any{sym_do, v5}) + tmp9 := lang.Apply(tmp6, []any{sym_if, v4, nil, tmp8}) + return tmp9 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_when_DASH_not = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_when_DASH_not.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // with-meta + { + tmp0 := sym_with_DASH_meta.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_obj, sym_m)), kw_doc, "Returns an object of the same type and value as obj, with\n map m as its metadata.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(2), kw_line, int(211), kw_end_DASH_line, int(216))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function with-meta + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(v3, "WithMeta") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("WithMeta is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v4}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(216), kw_column, int(12), kw_end_DASH_line, int(217), kw_end_DASH_column, int(32))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_with_DASH_meta = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_with_DASH_meta.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + var closed25 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + recur_loop_2021: + var tmp3 any + { // let + // let binding "temp__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + var tmp8 any + { // let + // let binding "s" + var v9 any = v6 + _ = v9 + var tmp10 any + { // let + // let binding "or__0__auto__" + tmp11 := checkDerefVar(var_glojure_DOT_core_first) + tmp12 := lang.Apply(tmp11, []any{v9}) + tmp13 := lang.Apply(v1, []any{tmp12}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + tmp15 = v14 + } else { + var tmp16 any = v1 + tmp18 := checkDerefVar(var_glojure_DOT_core_next) + tmp19 := lang.Apply(tmp18, []any{v9}) + var tmp17 any = tmp19 + v1 = tmp16 + v2 = tmp17 + goto recur_loop_2021 + } + tmp10 = tmp15 + } // end let + tmp8 = tmp10 + } // end let + tmp7 = tmp8 + } else { + } + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp0 = tmp0.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + closed25 = tmp0 + } + var closed26 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + recur_loop_2020: + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := lang.Apply(tmp5, []any{v2}) + tmp7 := lang.Apply(tmp4, []any{tmp6}) + if lang.IsTruthy(tmp7) { + tmp3 = true + } else { + var tmp8 any + tmp9 := checkDerefVar(var_glojure_DOT_core_first) + tmp10 := lang.Apply(tmp9, []any{v2}) + tmp11 := lang.Apply(v1, []any{tmp10}) + if lang.IsTruthy(tmp11) { + var tmp12 any = v1 + tmp14 := checkDerefVar(var_glojure_DOT_core_next) + tmp15 := lang.Apply(tmp14, []any{v2}) + var tmp13 any = tmp15 + v1 = tmp12 + v2 = tmp13 + goto recur_loop_2020 + } else { + var tmp16 any + if lang.IsTruthy(kw_else) { + tmp16 = false + } else { + } + tmp8 = tmp16 + } + tmp3 = tmp8 + } + return tmp3 + }) + tmp1 := reflect.TypeOf(false) + tmp0 = tmp0.WithMeta(lang.NewMap(kw_rettag, tmp1)).(lang.FnFunc) + closed26 = tmp0 + } + // agent-errors + { + tmp0 := sym_agent_DASH_errors.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a)), kw_doc, "DEPRECATED: Use 'agent-error' instead.\n Returns a sequence of the exceptions thrown during asynchronous\n actions of the agent.", kw_file, "glojure/core.glj", kw_deprecated, "1.2", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(2234), kw_end_DASH_line, int(2234))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "temp__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_agent_DASH_error) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + var tmp8 any + { // let + // let binding "e" + var v9 any = v6 + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{v9}) + tmp8 = tmp11 + } // end let + tmp7 = tmp8 + } else { + } + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_agent_DASH_errors = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_agent_DASH_errors.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // alias + { + tmp0 := sym_alias.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_alias, sym_namespace_DASH_sym)), kw_doc, "Add an alias in the current namespace to another\n namespace. Arguments are two symbols: the alias to be used, and\n the symbolic name of the target namespace. Use :as in the ns macro in preference\n to calling this directly.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(4263), kw_end_DASH_line, int(4263))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp5 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) + tmp6 := lang.Apply(tmp5, []any{v3}) + tmp7, _ := lang.FieldOrMethod(tmp4, "AddAlias") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("AddAlias is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v2, tmp6}) + return tmp8 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_alias = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_alias.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // assoc + { + tmp0 := sym_assoc.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_map, sym_key, sym_val), lang.NewVector(sym_map, sym_key, sym_val, sym__AMP_, sym_kvs)), kw_doc, "assoc[iate]. When applied to a map, returns a new map of the\n same (hashed/sorted) type, that contains the mapping of key(s) to\n val(s). When applied to a vector, returns a new vector that\n contains val at index. Note - index must be <= (count vector).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(6), kw_column, int(2), kw_line, int(181), kw_end_DASH_line, int(188))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function assoc + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6 := lang.Apply(lang.Assoc, []any{v3, v4, v5}) + return tmp6 + default: + checkArity(args, 3) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + recur_loop_1564: + var tmp7 any + { // let + // let binding "ret" + tmp8 := lang.Apply(lang.Assoc, []any{v3, v4, v5}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v6) { + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core_next) + tmp13 := lang.Apply(tmp12, []any{v6}) + if lang.IsTruthy(tmp13) { + var tmp14 any = v9 + tmp16 := checkDerefVar(var_glojure_DOT_core_first) + tmp17 := lang.Apply(tmp16, []any{v6}) + var tmp15 any = tmp17 + tmp19 := checkDerefVar(var_glojure_DOT_core_second) + tmp20 := lang.Apply(tmp19, []any{v6}) + var tmp18 any = tmp20 + tmp22 := checkDerefVar(var_glojure_DOT_core_nnext) + tmp23 := lang.Apply(tmp22, []any{v6}) + var tmp21 any = tmp23 + v3 = tmp14 + v4 = tmp15 + v5 = tmp18 + v6 = tmp21 + goto recur_loop_1564 + } else { + tmp24 := lang.Apply(lang.NewIllegalArgumentError, []any{"assoc expects even number of arguments after map/vector, found odd number"}) + panic(tmp24) + } + tmp10 = tmp11 + } else { + tmp10 = v9 + } + tmp7 = tmp10 + } // end let + return tmp7 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(189), kw_column, int(2), kw_end_DASH_line, int(198), kw_end_DASH_column, int(15))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_assoc = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_assoc.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // assoc! + { + tmp0 := sym_assoc_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll, sym_key, sym_val), lang.NewVector(sym_coll, sym_key, sym_val, sym__AMP_, sym_kvs)), kw_doc, "When applied to a transient map, adds mapping of key(s) to\n val(s). When applied to a transient vector, sets the val at index.\n Note - index must be <= (count vector). Returns coll.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(3369), kw_end_DASH_line, int(3369))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5, _ := lang.FieldOrMethod(v2, "Assoc") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Assoc is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + recur_loop_2149: + var tmp6 any + { // let + // let binding "ret" + tmp7, _ := lang.FieldOrMethod(v2, "Assoc") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Assoc is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v3, v4}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v5) { + var tmp11 any = v9 + tmp13 := checkDerefVar(var_glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v5}) + var tmp12 any = tmp14 + tmp16 := checkDerefVar(var_glojure_DOT_core_second) + tmp17 := lang.Apply(tmp16, []any{v5}) + var tmp15 any = tmp17 + tmp19 := checkDerefVar(var_glojure_DOT_core_nnext) + tmp20 := lang.Apply(tmp19, []any{v5}) + var tmp18 any = tmp20 + v2 = tmp11 + v3 = tmp12 + v4 = tmp15 + v5 = tmp18 + goto recur_loop_2149 + } else { + tmp10 = v9 + } + tmp6 = tmp10 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_assoc_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_assoc_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // associative? + { + tmp0 := sym_associative_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns true if coll implements Associative", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(6223), kw_end_DASH_line, int(6223))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := lang.Apply(tmp3, []any{nil, v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_associative_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_associative_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bases + { + tmp0 := sym_bases.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_c)), kw_doc, "Returns the immediate superclass and direct interfaces of c, if any", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(5522), kw_end_DASH_line, int(5522))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + if lang.IsTruthy(v2) { + var tmp4 any + { // let + // let binding "i" + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := lang.Apply(tmp5, []any{nil}) + var v7 any = tmp6 + _ = v7 + // let binding "s" + var v8 any = nil + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + tmp10 := checkDerefVar(var_glojure_DOT_core_cons) + tmp11 := lang.Apply(tmp10, []any{v8, v7}) + tmp9 = tmp11 + } else { + tmp9 = v7 + } + tmp4 = tmp9 + } // end let + tmp3 = tmp4 + } else { + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bases = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bases.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // boolean? + { + tmp0 := sym_boolean_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a Boolean", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(518), kw_end_DASH_line, int(518))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := lang.Apply(tmp3, []any{lang.Builtins["bool"], v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_boolean_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_boolean_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // char? + { + tmp0 := sym_char_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a Character", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(6), kw_column, int(2), kw_line, int(153), kw_end_DASH_line, int(157))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function char? + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := reflect.TypeOf(int32(0)) + tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(157), kw_column, int(8), kw_end_DASH_line, int(157), kw_end_DASH_column, int(89))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_char_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_char_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // chunked-seq? + { + tmp0 := sym_chunked_DASH_seq_QMARK_.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(708), kw_column, int(7), kw_end_DASH_line, int(708), kw_end_DASH_column, int(27), kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*lang.IChunkedSeq)(nil)).Elem() + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_chunked_DASH_seq_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_chunked_DASH_seq_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // class + { + tmp0 := sym_class.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns the Class of x", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3461), kw_end_DASH_line, int(3461))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + tmp3 = v2 + } else { + tmp6 := lang.Apply(lang.TypeOf, []any{v2}) + tmp3 = tmp6 + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_class = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_class.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // class? + { + tmp0 := sym_class_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x is an instance of Class", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(5465), kw_end_DASH_line, int(5465))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*reflect.Type)(nil)).Elem() + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_class_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_class_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // coll? + { + tmp0 := sym_coll_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x implements IPersistentCollection", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(6192), kw_end_DASH_line, int(6192))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*lang.IPersistentCollection)(nil)).Elem() + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_coll_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_coll_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // completing + { + tmp0 := sym_completing.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_cf)), kw_doc, "Takes a reducing function f of 2 args and returns a fn suitable for\n transduce by adding an arity-1 signature that calls cf (default -\n identity) on the result argument.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(6893), kw_end_DASH_line, int(6893))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_completing) + tmp4 := checkDerefVar(var_glojure_DOT_core_identity) + tmp5 := lang.Apply(tmp3, []any{v2, tmp4}) + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp5 := lang.Apply(v2, nil) + return tmp5 + case 1: + v5 := args[0] + _ = v5 + tmp6 := lang.Apply(v3, []any{v5}) + return tmp6 + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + tmp7 := lang.Apply(v2, []any{v5, v6}) + return tmp7 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6900), kw_column, int(6), kw_end_DASH_line, int(6903), kw_end_DASH_column, int(23)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_completing = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_completing.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // concat + { + tmp0 := sym_concat.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_zs)), kw_doc, "Returns a lazy seq representing the concatenation of the elements in the supplied colls.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(711), kw_end_DASH_line, int(711))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + return nil + }) + tmp3 := lang.Apply(lang.NewLazySeq, []any{tmp2}) + return tmp3 + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + return v2 + }) + tmp4 := lang.Apply(lang.NewLazySeq, []any{tmp3}) + return tmp4 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp5 any + { // let + // let binding "s" + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := lang.Apply(tmp6, []any{v2}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + var tmp10 any + tmp11 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp12 := lang.Apply(tmp11, []any{v8}) + if lang.IsTruthy(tmp12) { + tmp13 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_cons) + tmp14 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp15 := lang.Apply(tmp14, []any{v8}) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp18 := lang.Apply(tmp17, []any{v8}) + tmp19 := lang.Apply(tmp16, []any{tmp18, v3}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp19}) + tmp10 = tmp20 + } else { + tmp21 := checkDerefVar(var_glojure_DOT_core_cons) + tmp22 := checkDerefVar(var_glojure_DOT_core_first) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_concat) + tmp25 := checkDerefVar(var_glojure_DOT_core_rest) + tmp26 := lang.Apply(tmp25, []any{v8}) + tmp27 := lang.Apply(tmp24, []any{tmp26, v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp27}) + tmp10 = tmp28 + } + tmp9 = tmp10 + } else { + tmp9 = v3 + } + tmp5 = tmp9 + } // end let + return tmp5 + }) + tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) + return tmp5 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "cat" + var tmp6 lang.FnFunc + { // function cat + var v7 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp11 any + { // let + // let binding "xys" + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := lang.Apply(tmp12, []any{v8}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + var tmp16 any + tmp17 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp18 := lang.Apply(tmp17, []any{v14}) + if lang.IsTruthy(tmp18) { + tmp19 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_cons) + tmp20 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp21 := lang.Apply(tmp20, []any{v14}) + tmp22 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp23 := lang.Apply(tmp22, []any{v14}) + tmp24 := lang.Apply(v7, []any{tmp23, v9}) + tmp25 := lang.Apply(tmp19, []any{tmp21, tmp24}) + tmp16 = tmp25 + } else { + tmp26 := checkDerefVar(var_glojure_DOT_core_cons) + tmp27 := checkDerefVar(var_glojure_DOT_core_first) + tmp28 := lang.Apply(tmp27, []any{v14}) + tmp29 := checkDerefVar(var_glojure_DOT_core_rest) + tmp30 := lang.Apply(tmp29, []any{v14}) + tmp31 := lang.Apply(v7, []any{tmp30, v9}) + tmp32 := lang.Apply(tmp26, []any{tmp28, tmp31}) + tmp16 = tmp32 + } + tmp15 = tmp16 + } else { + var tmp33 any + if lang.IsTruthy(v9) { + tmp34 := checkDerefVar(var_glojure_DOT_core_first) + tmp35 := lang.Apply(tmp34, []any{v9}) + tmp36 := checkDerefVar(var_glojure_DOT_core_next) + tmp37 := lang.Apply(tmp36, []any{v9}) + tmp38 := lang.Apply(v7, []any{tmp35, tmp37}) + tmp33 = tmp38 + } else { + } + tmp15 = tmp33 + } + tmp11 = tmp15 + } // end let + return tmp11 + }) + tmp11 := lang.Apply(lang.NewLazySeq, []any{tmp10}) + return tmp11 + }) + v7 = tmp6 + _ = v7 + } + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(726), kw_column, int(16), kw_end_DASH_line, int(735), kw_end_DASH_column, int(56)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v9 any = tmp8 + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_concat) + tmp11 := lang.Apply(tmp10, []any{v2, v3}) + tmp12 := lang.Apply(v9, []any{tmp11, v4}) + tmp5 = tmp12 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_concat = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_concat.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // cond + { + tmp0 := sym_cond.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_clauses)), kw_doc, "Takes a set of test/expr pairs. It evaluates each test one at a\n time. If a test returns logical true, cond evaluates and returns\n the value of the corresponding expr and doesn't evaluate any of the\n other tests or exprs. (cond) returns nil.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(11), kw_line, int(569), kw_end_DASH_line, int(569))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + if lang.IsTruthy(v4) { + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := checkDerefVar(var_glojure_DOT_core_first) + tmp8 := lang.Apply(tmp7, []any{v4}) + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_next) + tmp11 := lang.Apply(tmp10, []any{v4}) + if lang.IsTruthy(tmp11) { + tmp12 := checkDerefVar(var_glojure_DOT_core_second) + tmp13 := lang.Apply(tmp12, []any{v4}) + tmp9 = tmp13 + } else { + tmp14 := lang.Apply(lang.NewIllegalArgumentError, []any{"cond requires an even number of forms"}) + panic(tmp14) + } + tmp15 := checkDerefVar(var_glojure_DOT_core_cons) + tmp16 := checkDerefVar(var_glojure_DOT_core_next) + tmp17 := checkDerefVar(var_glojure_DOT_core_next) + tmp18 := lang.Apply(tmp17, []any{v4}) + tmp19 := lang.Apply(tmp16, []any{tmp18}) + tmp20 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_cond, tmp19}) + tmp21 := lang.Apply(tmp6, []any{sym_if, tmp8, tmp9, tmp20}) + tmp5 = tmp21 + } else { + } + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_cond = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_cond.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // conj + { + tmp0 := sym_conj.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_coll), lang.NewVector(sym_coll, sym_x), lang.NewVector(sym_coll, sym_x, sym__AMP_, sym_xs)), kw_doc, "conj[oin]. Returns a new collection with the xs\n 'added'. (conj nil item) returns (item).\n (conj coll) returns coll. (conj) returns [].\n The 'addition' may happen at different 'places' depending\n on the concrete type.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(5), kw_column, int(2), kw_line, int(73), kw_end_DASH_line, int(81))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function conj + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp3 := lang.NewVector() + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(82), kw_column, int(13), kw_end_DASH_line, int(82), kw_end_DASH_column, int(14)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 1: + v3 := args[0] + _ = v3 + return v3 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(lang.Conj, []any{v3, v4}) + return tmp5 + default: + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + recur_loop_1550: + var tmp6 any + if lang.IsTruthy(v5) { + tmp8 := lang.Apply(lang.Conj, []any{v3, v4}) + var tmp7 any = tmp8 + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v5}) + var tmp9 any = tmp11 + tmp13 := checkDerefVar(var_glojure_DOT_core_next) + tmp14 := lang.Apply(tmp13, []any{v5}) + var tmp12 any = tmp14 + v3 = tmp7 + v4 = tmp9 + v5 = tmp12 + goto recur_loop_1550 + } else { + tmp15 := lang.Apply(lang.Conj, []any{v3, v4}) + tmp6 = tmp15 + } + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(81), kw_column, int(7), kw_end_DASH_line, int(88), kw_end_DASH_column, int(67))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_conj = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_conj.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // conj! + { + tmp0 := sym_conj_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_coll), lang.NewVector(sym_coll, sym_x)), kw_doc, "Adds x to the transient collection, and return coll. The 'addition'\n may happen at different 'places' depending on the concrete type.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3359), kw_end_DASH_line, int(3359))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp2 := checkDerefVar(var_glojure_DOT_core_transient) + tmp3 := lang.NewVector() + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3364), kw_column, int(18), kw_end_DASH_line, int(3364), kw_end_DASH_column, int(19)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp6 := lang.Apply(tmp2, []any{tmp5}) + return tmp6 + case 1: + v2 := args[0] + _ = v2 + return v2 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "Conj") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Conj is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_conj_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_conj_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // count + { + var tmp1 lang.FnFunc + { // function count__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Count}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_count.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_inline, tmp1, kw_doc, "Returns the number of items in the collection. (count nil) returns\n 0. Also works on strings, arrays, and Java Collections and Maps", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(867), kw_end_DASH_line, int(867))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.Count, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_count = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_count.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // counted? + { + tmp0 := sym_counted_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns true if coll implements count in constant time", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(6241), kw_end_DASH_line, int(6241))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*lang.Counted)(nil)).Elem() + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_counted_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_counted_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // cycle + { + tmp0 := sym_cycle.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a lazy (infinite!) sequence of repetitions of the items in coll.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(2977), kw_end_DASH_line, int(2977))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_seq) + tmp4 := lang.Apply(tmp3, []any{v2}) + tmp5 := lang.Apply(lang.NewCycle, []any{tmp4}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_cycle = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_cycle.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // dec + { + var tmp1 lang.FnFunc + { // function dec__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp15) { + tmp14 = sym_unchecked_dec + } else { + tmp14 = sym_dec + } + tmp16 := lang.Apply(tmp13, []any{tmp14}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := lang.Apply(tmp12, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp11, []any{tmp19}) + tmp21 := lang.Apply(tmp10, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_dec.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns a number one less than num. Does not auto-promote\n longs, will throw on overflow. See also: dec'", kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(1147), kw_end_DASH_line, int(1147))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Dec") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Dec is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_dec = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_dec.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // dec' + { + var tmp1 lang.FnFunc + { // function dec'__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_DecP}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_dec_TICK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns a number one less than num. Supports arbitrary precision.\n See also: dec", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1140), kw_end_DASH_line, int(1140))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "DecP") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("DecP is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_dec_TICK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_dec_TICK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // decimal? + { + tmp0 := sym_decimal_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_doc, "Returns true if n is a BigDecimal", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(3599), kw_end_DASH_line, int(3599))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*lang.BigDecimal)(nil)) + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_decimal_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_decimal_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // defmethod + { + tmp0 := sym_defmethod.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_multifn, sym_dispatch_DASH_val, sym__AMP_, sym_fn_DASH_tail)), kw_doc, "Creates and installs a new method of multimethod associated with dispatch-value. ", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(11), kw_line, int(1781), kw_end_DASH_line, int(1781))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var v6 any = lang.NewList(args[4:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp13 := lang.NewMap(kw_tag, sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT__STAR_MultiFn) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(1785), kw_column, int(27), kw_end_DASH_line, int(1785), kw_end_DASH_column, int(82)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp16 := lang.Apply(tmp12, []any{v4, tmp15}) + tmp17 := lang.Apply(tmp11, []any{tmp16}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{sym_glojure_DOT_core_SLASH_AddMethod}) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{v5}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := checkDerefVar(var_glojure_DOT_core_seq) + tmp24 := checkDerefVar(var_glojure_DOT_core_concat) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := lang.Apply(tmp25, []any{sym_glojure_DOT_core_SLASH_fn}) + tmp27 := lang.Apply(tmp24, []any{tmp26, v6}) + tmp28 := lang.Apply(tmp23, []any{tmp27}) + tmp29 := lang.Apply(tmp22, []any{tmp28}) + tmp30 := lang.Apply(tmp8, []any{tmp10, tmp17, tmp19, tmp21, tmp29}) + tmp31 := lang.Apply(tmp7, []any{tmp30}) + return tmp31 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_defmethod = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_defmethod.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // defstruct + { + tmp0 := sym_defstruct.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym__AMP_, sym_keys)), kw_doc, "Same as (def name (create-struct keys...))", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(11), kw_line, int(4044), kw_end_DASH_line, int(4044))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_def}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{v4}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_create_DASH_struct}) + tmp17 := lang.Apply(tmp14, []any{tmp16, v5}) + tmp18 := lang.Apply(tmp13, []any{tmp17}) + tmp19 := lang.Apply(tmp12, []any{tmp18}) + tmp20 := lang.Apply(tmp7, []any{tmp9, tmp11, tmp19}) + tmp21 := lang.Apply(tmp6, []any{tmp20}) + return tmp21 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_defstruct = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_defstruct.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // delay? + { + tmp0 := sym_delay_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "returns true if x is a Delay created with delay", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(748), kw_end_DASH_line, int(748))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := lang.Apply(tmp3, []any{nil, v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_delay_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_delay_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // deref + { + tmp0 := sym_deref.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ref), lang.NewVector(sym_ref, sym_timeout_DASH_ms, sym_timeout_DASH_val)), kw_doc, "Also reader macro: @ref/@agent/@var/@atom/@delay/@future/@promise. Within a transaction,\n returns the in-transaction-value of ref, else returns the\n most-recently-committed value of ref. When applied to a var, agent\n or atom, returns its current state. When applied to a delay, forces\n it if not already forced. When applied to a future, will block if\n computation not complete. When applied to a promise, will block\n until a value is delivered. The variant taking a timeout can be\n used for blocking references (futures and promises), and will return\n timeout-val if the timeout (in milliseconds) is reached before a\n value is available. See also - realized?.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(2304), kw_end_DASH_line, int(2304))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := reflect.TypeOf((*lang.IDeref)(nil)).Elem() + tmp6 := lang.Apply(tmp4, []any{tmp5, v2}) + if lang.IsTruthy(tmp6) { + tmp7, ok := lang.FieldOrMethod(v2, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "Deref"))) + } + var tmp8 any + switch reflect.TypeOf(tmp7).Kind() { + case reflect.Func: + tmp8 = lang.Apply(tmp7, nil) + default: + tmp8 = tmp7 + } + tmp3 = tmp8 + } else { + tmp9 := checkDerefVar(var_glojure_DOT_core_deref_DASH_future) + tmp10 := lang.Apply(tmp9, []any{v2}) + tmp3 = tmp10 + } + return tmp3 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp7 := reflect.TypeOf((*lang.IBlockingDeref)(nil)).Elem() + tmp8 := lang.Apply(tmp6, []any{tmp7, v2}) + if lang.IsTruthy(tmp8) { + tmp9, _ := lang.FieldOrMethod(v2, "DerefWithTimeout") + if reflect.TypeOf(tmp9).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("DerefWithTimeout is not a function"))) + } + tmp10 := lang.Apply(tmp9, []any{v3, v4}) + tmp5 = tmp10 + } else { + tmp11 := checkDerefVar(var_glojure_DOT_core_deref_DASH_future) + tmp12 := lang.Apply(tmp11, []any{v2, v3, v4}) + tmp5 = tmp12 + } + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_deref = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_deref.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // disj + { + tmp0 := sym_disj.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_set), lang.NewVector(sym_set, sym_key), lang.NewVector(sym_set, sym_key, sym__AMP_, sym_ks)), kw_doc, "disj[oin]. Returns a new set of the same (hashed/sorted) type, that\n does not contain key(s).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1514), kw_end_DASH_line, int(1514))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + return v2 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + if lang.IsTruthy(v2) { + tmp5, _ := lang.FieldOrMethod(v2, "Disjoin") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Disjoin is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3}) + tmp4 = tmp6 + } else { + } + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + recur_loop_1844: + var tmp5 any + if lang.IsTruthy(v2) { + var tmp6 any + { // let + // let binding "ret" + tmp7 := checkDerefVar(var_glojure_DOT_core_disj) + tmp8 := lang.Apply(tmp7, []any{v2, v3}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v4) { + var tmp11 any = v9 + tmp13 := checkDerefVar(var_glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v4}) + var tmp12 any = tmp14 + tmp16 := checkDerefVar(var_glojure_DOT_core_next) + tmp17 := lang.Apply(tmp16, []any{v4}) + var tmp15 any = tmp17 + v2 = tmp11 + v3 = tmp12 + v4 = tmp15 + goto recur_loop_1844 + } else { + tmp10 = v9 + } + tmp6 = tmp10 + } // end let + tmp5 = tmp6 + } else { + } + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_disj = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_disj.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // disj! + { + tmp0 := sym_disj_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_set), lang.NewVector(sym_set, sym_key), lang.NewVector(sym_set, sym_key, sym__AMP_, sym_ks)), kw_doc, "disj[oin]. Returns a transient set of the same (hashed/sorted) type, that\n does not contain key(s).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3401), kw_end_DASH_line, int(3401))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + return v2 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "Disjoin") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Disjoin is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + recur_loop_2155: + var tmp5 any + { // let + // let binding "ret" + tmp6, _ := lang.FieldOrMethod(v2, "Disjoin") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Disjoin is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v4) { + var tmp10 any = v8 + tmp12 := checkDerefVar(var_glojure_DOT_core_first) + tmp13 := lang.Apply(tmp12, []any{v4}) + var tmp11 any = tmp13 + tmp15 := checkDerefVar(var_glojure_DOT_core_next) + tmp16 := lang.Apply(tmp15, []any{v4}) + var tmp14 any = tmp16 + v2 = tmp10 + v3 = tmp11 + v4 = tmp14 + goto recur_loop_2155 + } else { + tmp9 = v8 + } + tmp5 = tmp9 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_disj_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_disj_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // dissoc + { + tmp0 := sym_dissoc.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_map), lang.NewVector(sym_map, sym_key), lang.NewVector(sym_map, sym_key, sym__AMP_, sym_ks)), kw_doc, "dissoc[iate]. Returns a new map of the same (hashed/sorted) type,\n that does not contain a mapping for key(s).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(1500), kw_end_DASH_line, int(1500))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + return v2 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(runtime.RT, "Dissoc") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Dissoc is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + return tmp5 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + recur_loop_1841: + var tmp5 any + { // let + // let binding "ret" + tmp6 := checkDerefVar(var_glojure_DOT_core_dissoc) + tmp7 := lang.Apply(tmp6, []any{v2, v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v4) { + var tmp10 any = v8 + tmp12 := checkDerefVar(var_glojure_DOT_core_first) + tmp13 := lang.Apply(tmp12, []any{v4}) + var tmp11 any = tmp13 + tmp15 := checkDerefVar(var_glojure_DOT_core_next) + tmp16 := lang.Apply(tmp15, []any{v4}) + var tmp14 any = tmp16 + v2 = tmp10 + v3 = tmp11 + v4 = tmp14 + goto recur_loop_1841 + } else { + tmp9 = v8 + } + tmp5 = tmp9 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_dissoc = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_dissoc.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // dissoc! + { + tmp0 := sym_dissoc_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_map, sym_key), lang.NewVector(sym_map, sym_key, sym__AMP_, sym_ks)), kw_doc, "Returns a transient map that doesn't contain a mapping for key(s).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(3382), kw_end_DASH_line, int(3382))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v2, "without") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("without is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + recur_loop_2151: + var tmp5 any + { // let + // let binding "ret" + tmp6, _ := lang.FieldOrMethod(v2, "without") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("without is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v4) { + var tmp10 any = v8 + tmp12 := checkDerefVar(var_glojure_DOT_core_first) + tmp13 := lang.Apply(tmp12, []any{v4}) + var tmp11 any = tmp13 + tmp15 := checkDerefVar(var_glojure_DOT_core_next) + tmp16 := lang.Apply(tmp15, []any{v4}) + var tmp14 any = tmp16 + v2 = tmp10 + v3 = tmp11 + v4 = tmp14 + goto recur_loop_2151 + } else { + tmp9 = v8 + } + tmp5 = tmp9 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_dissoc_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_dissoc_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // dosync + { + tmp0 := sym_dosync.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_exprs)), kw_doc, "Runs the exprs (in an implicit do) in a transaction that encompasses\n exprs and any nested calls. Starts a transaction if none is already\n running on this thread. Any uncaught exception will abort the\n transaction and flow out of dosync. The exprs may be run more than\n once, but any effects on Refs will be atomic.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(11), kw_line, int(5100), kw_end_DASH_line, int(5100))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym_glojure_DOT_core_SLASH_sync}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{nil}) + tmp11 := lang.Apply(tmp6, []any{tmp8, tmp10, v4}) + tmp12 := lang.Apply(tmp5, []any{tmp11}) + return tmp12 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_dosync = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_dosync.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // double + { + var tmp1 lang.FnFunc + { // function double__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_DoubleCast}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_double.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to double", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(3493), kw_end_DASH_line, int(3493))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.AsFloat64, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_double = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_double.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // double-array + { + var tmp1 lang.FnFunc + { // function double-array__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_DoubleArray}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_unquote_DASH_splicing}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_glojure_DOT_core_SLASH_args}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + } + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_double_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_size_DASH_or_DASH_seq), lang.NewVector(sym_size, sym_init_DASH_val_DASH_or_DASH_seq)), kw_inline, tmp1, kw_doc, "Creates an array of doubles", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(5341), kw_end_DASH_line, int(5341))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "DoubleArray") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("DoubleArray is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "DoubleArrayInit") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("DoubleArrayInit is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_double_DASH_array = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_double_DASH_array.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // double? + { + tmp0 := sym_double_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a Double", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(1421), kw_end_DASH_line, int(1421))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := lang.Apply(tmp3, []any{lang.Builtins["float64"], v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_double_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_double_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // doubles + { + var tmp1 lang.FnFunc + { // function doubles + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Doubles}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_doubles.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xs)), kw_inline, tmp1, kw_doc, "Casts to double[]", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(12), kw_line, int(5402), kw_end_DASH_line, int(5402))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Doubles") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Doubles is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_doubles = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_doubles.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // drop-while + { + tmp0 := sym_drop_DASH_while.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred), lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns a lazy sequence of the items in coll starting from the\n first item for which (pred item) returns logical false. Returns a\n stateful transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(2950), kw_end_DASH_line, int(2950))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 any + { // let + // let binding "dv" + tmp6 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) + tmp7 := lang.Apply(tmp6, []any{true}) + var v8 any = tmp7 + _ = v8 + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp10 := lang.Apply(v4, nil) + return tmp10 + case 1: + v10 := args[0] + _ = v10 + tmp11 := lang.Apply(v4, []any{v10}) + return tmp11 + case 2: + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + var tmp12 any + { // let + // let binding "drop?" + tmp13 := checkDerefVar(var_glojure_DOT_core_deref) + tmp14 := lang.Apply(tmp13, []any{v8}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + var tmp17 any + { // let + // let binding "and__0__auto__" + var v18 any = v15 + _ = v18 + var tmp19 any + if lang.IsTruthy(v18) { + tmp20 := lang.Apply(v2, []any{v11}) + tmp19 = tmp20 + } else { + tmp19 = v18 + } + tmp17 = tmp19 + } // end let + if lang.IsTruthy(tmp17) { + tmp16 = v10 + } else { + tmp18 := checkDerefVar(var_glojure_DOT_core_vreset_BANG_) + tmp19 := lang.Apply(tmp18, []any{v8, nil}) + _ = tmp19 + tmp20 := lang.Apply(v4, []any{v10, v11}) + tmp16 = tmp20 + } + tmp12 = tmp16 + } // end let + return tmp12 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2959), kw_column, int(10), kw_end_DASH_line, int(2968), kw_end_DASH_column, int(42)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp5 = tmp11 + } // end let + return tmp5 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2957), kw_column, int(6), kw_end_DASH_line, int(2968), kw_end_DASH_column, int(44)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "step" + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + recur_loop_2092: + var tmp8 any + { // let + // let binding "s" + tmp9 := checkDerefVar(var_glojure_DOT_core_seq) + tmp10 := lang.Apply(tmp9, []any{v7}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + var tmp13 any + { // let + // let binding "and__0__auto__" + var v14 any = v11 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + tmp16 := checkDerefVar(var_glojure_DOT_core_first) + tmp17 := lang.Apply(tmp16, []any{v11}) + tmp18 := lang.Apply(v6, []any{tmp17}) + tmp15 = tmp18 + } else { + tmp15 = v14 + } + tmp13 = tmp15 + } // end let + if lang.IsTruthy(tmp13) { + var tmp14 any = v6 + tmp16 := checkDerefVar(var_glojure_DOT_core_rest) + tmp17 := lang.Apply(tmp16, []any{v11}) + var tmp15 any = tmp17 + v6 = tmp14 + v7 = tmp15 + goto recur_loop_2092 + } else { + tmp12 = v11 + } + tmp8 = tmp12 + } // end let + return tmp8 + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2970), kw_column, int(17), kw_end_DASH_line, int(2974), kw_end_DASH_column, int(26)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v8 any = tmp7 + _ = v8 + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp10 := lang.Apply(v8, []any{v2, v3}) + return tmp10 + }) + tmp10 := lang.Apply(lang.NewLazySeq, []any{tmp9}) + tmp4 = tmp10 + } // end let + return tmp4 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_drop_DASH_while = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_drop_DASH_while.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // empty + { + tmp0 := sym_empty.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns an empty collection of the same category as coll, or nil", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(5265), kw_end_DASH_line, int(5265))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := reflect.TypeOf((*lang.IPersistentCollection)(nil)).Elem() + tmp6 := lang.Apply(tmp4, []any{tmp5, v2}) + if lang.IsTruthy(tmp6) { + tmp7, ok := lang.FieldOrMethod(v2, "empty") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "empty"))) + } + var tmp8 any + switch reflect.TypeOf(tmp7).Kind() { + case reflect.Func: + tmp8 = lang.Apply(tmp7, nil) + default: + tmp8 = tmp7 + } + tmp3 = tmp8 + } else { + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_empty = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_empty.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // every? + { + tmp1 := reflect.TypeOf(false) + tmp0 := sym_every_QMARK_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns true if (pred x) is logical true for every x in coll, else\n false.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(2664), kw_end_DASH_line, int(2664))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + recur_loop_2020: + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := lang.Apply(tmp7, []any{v4}) + tmp9 := lang.Apply(tmp6, []any{tmp8}) + if lang.IsTruthy(tmp9) { + tmp5 = true + } else { + var tmp10 any + tmp11 := checkDerefVar(var_glojure_DOT_core_first) + tmp12 := lang.Apply(tmp11, []any{v4}) + tmp13 := lang.Apply(v3, []any{tmp12}) + if lang.IsTruthy(tmp13) { + var tmp14 any = v3 + tmp16 := checkDerefVar(var_glojure_DOT_core_next) + tmp17 := lang.Apply(tmp16, []any{v4}) + var tmp15 any = tmp17 + v3 = tmp14 + v4 = tmp15 + goto recur_loop_2020 + } else { + var tmp18 any + if lang.IsTruthy(kw_else) { + tmp18 = false + } else { + } + tmp10 = tmp18 + } + tmp5 = tmp10 + } + return tmp5 + }) + tmp3 := reflect.TypeOf(false) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_every_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_every_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ex-cause + { + tmp0 := sym_ex_DASH_cause.WithMeta(lang.NewMap(kw_tag, nil, kw_arglists, lang.NewList(lang.NewVector(sym_ex)), kw_doc, "Returns the cause of ex if ex is a Throwable.\n Otherwise returns nil.", kw_file, "glojure/core.glj", kw_added, "1.10", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(4828), kw_end_DASH_line, int(4828))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := lang.Apply(tmp4, []any{lang.Throwable, v2}) + if lang.IsTruthy(tmp5) { + tmp6, ok := lang.FieldOrMethod(v2, "getCause") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getCause"))) + } + var tmp7 any + switch reflect.TypeOf(tmp6).Kind() { + case reflect.Func: + tmp7 = lang.Apply(tmp6, nil) + default: + tmp7 = tmp6 + } + tmp3 = tmp7 + } else { + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ex_DASH_cause = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ex_DASH_cause.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ex-data + { + tmp0 := sym_ex_DASH_data.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ex)), kw_doc, "Returns exception data (a map) if ex is an IExceptionInfo.\n Otherwise returns nil.", kw_file, "glojure/core.glj", kw_added, "1.4", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4812), kw_end_DASH_line, int(4812))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := lang.Apply(tmp4, []any{nil, v2}) + if lang.IsTruthy(tmp5) { + tmp6, ok := lang.FieldOrMethod(v2, "getData") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getData"))) + } + var tmp7 any + switch reflect.TypeOf(tmp6).Kind() { + case reflect.Func: + tmp7 = lang.Apply(tmp6, nil) + default: + tmp7 = tmp6 + } + tmp3 = tmp7 + } else { + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ex_DASH_data = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ex_DASH_data.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ex-message + { + tmp0 := sym_ex_DASH_message.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ex)), kw_doc, "Returns the message attached to ex if ex is a Throwable.\n Otherwise returns nil.", kw_file, "glojure/core.glj", kw_added, "1.10", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4820), kw_end_DASH_line, int(4820))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := lang.Apply(tmp4, []any{lang.Throwable, v2}) + if lang.IsTruthy(tmp5) { + tmp6, ok := lang.FieldOrMethod(v2, "getMessage") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getMessage"))) + } + var tmp7 any + switch reflect.TypeOf(tmp6).Kind() { + case reflect.Func: + tmp7 = lang.Apply(tmp6, nil) + default: + tmp7 = tmp6 + } + tmp3 = tmp7 + } else { + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ex_DASH_message = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ex_DASH_message.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ffirst + { + tmp0 := sym_ffirst.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Same as (first (first x))", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(2), kw_line, int(98), kw_end_DASH_line, int(102))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function ffirst + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_first) + tmp5 := checkDerefVar(var_glojure_DOT_core_first) + tmp6 := lang.Apply(tmp5, []any{v3}) + tmp7 := lang.Apply(tmp4, []any{tmp6}) + return tmp7 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(102), kw_column, int(9), kw_end_DASH_line, int(102), kw_end_DASH_column, int(50))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_ffirst = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ffirst.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // filter-key + { + tmp0 := sym_filter_DASH_key.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_keyfn, sym_pred, sym_amap)), kw_static, true, kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(4115), kw_end_DASH_line, int(4117), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + { // let + // let binding "ret" + tmp6 := lang.NewMap() + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4118), kw_column, int(16), kw_end_DASH_line, int(4118), kw_end_DASH_column, int(17)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v9 any = tmp8 + _ = v9 + // let binding "es" + tmp10 := checkDerefVar(var_glojure_DOT_core_seq) + tmp11 := lang.Apply(tmp10, []any{v4}) + var v12 any = tmp11 + _ = v12 + for { + var tmp13 any + if lang.IsTruthy(v12) { + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core_first) + tmp16 := lang.Apply(tmp15, []any{v12}) + tmp17 := lang.Apply(v2, []any{tmp16}) + tmp18 := lang.Apply(v3, []any{tmp17}) + if lang.IsTruthy(tmp18) { + tmp20 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp21 := checkDerefVar(var_glojure_DOT_core_key) + tmp22 := checkDerefVar(var_glojure_DOT_core_first) + tmp23 := lang.Apply(tmp22, []any{v12}) + tmp24 := lang.Apply(tmp21, []any{tmp23}) + tmp25 := checkDerefVar(var_glojure_DOT_core_val) + tmp26 := checkDerefVar(var_glojure_DOT_core_first) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp25, []any{tmp27}) + tmp29 := lang.Apply(tmp20, []any{v9, tmp24, tmp28}) + var tmp19 any = tmp29 + tmp31 := checkDerefVar(var_glojure_DOT_core_next) + tmp32 := lang.Apply(tmp31, []any{v12}) + var tmp30 any = tmp32 + v9 = tmp19 + v12 = tmp30 + continue + } else { + var tmp33 any = v9 + tmp35 := checkDerefVar(var_glojure_DOT_core_next) + tmp36 := lang.Apply(tmp35, []any{v12}) + var tmp34 any = tmp36 + v9 = tmp33 + v12 = tmp34 + continue + } + tmp13 = tmp14 + } else { + tmp13 = v9 + } + tmp5 = tmp13 + break + } + } // end let + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_filter_DASH_key = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_filter_DASH_key.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // find-keyword + { + tmp1 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() + tmp0 := sym_find_DASH_keyword.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_name), lang.NewVector(sym_ns, sym_name)), kw_doc, "Returns a Keyword with the given namespace and name if one already\n exists. This function will not intern a new keyword. If the keyword\n has not already been interned, it will return nil. Do not use :\n in the keyword strings, it will be added automatically.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(618), kw_end_DASH_line, int(618))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + tmp4 = v3 + } else { + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp9 := lang.Apply(tmp8, []any{v3}) + if lang.IsTruthy(tmp9) { + tmp10 := lang.Apply(nil, []any{v3}) + tmp7 = tmp10 + } else { + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp13 := lang.Apply(tmp12, []any{v3}) + if lang.IsTruthy(tmp13) { + tmp14 := lang.Apply(nil, []any{v3}) + tmp11 = tmp14 + } else { + } + tmp7 = tmp11 + } + tmp4 = tmp7 + } + return tmp4 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(nil, []any{v3, v4}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp3 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_find_DASH_keyword = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_find_DASH_keyword.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // float + { + var tmp1 lang.FnFunc + { // function float__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp15) { + tmp14 = sym_uncheckedFloatCast + } else { + tmp14 = sym_floatCast + } + tmp16 := lang.Apply(tmp13, []any{tmp14}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := lang.Apply(tmp12, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp11, []any{tmp19}) + tmp21 := lang.Apply(tmp10, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_float.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to float", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3487), kw_end_DASH_line, int(3487))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.FloatCast, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_float = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_float.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // float-array + { + var tmp1 lang.FnFunc + { // function float-array__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_FloatArray}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_unquote_DASH_splicing}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_glojure_DOT_core_SLASH_args}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + } + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_float_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_size_DASH_or_DASH_seq), lang.NewVector(sym_size, sym_init_DASH_val_DASH_or_DASH_seq)), kw_inline, tmp1, kw_doc, "Creates an array of floats", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(5301), kw_end_DASH_line, int(5301))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "FloatArray") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("FloatArray is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "FloatArrayInit") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("FloatArrayInit is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_float_DASH_array = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_float_DASH_array.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // float? + { + tmp0 := sym_float_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_doc, "Returns true if n is a floating point number", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(3605), kw_end_DASH_line, int(3605))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "or__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := lang.Apply(tmp4, []any{lang.Builtins["float64"], v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + tmp7 = v6 + } else { + tmp8 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp9 := lang.Apply(tmp8, []any{lang.Builtins["float32"], v2}) + tmp7 = tmp9 + } + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_float_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_float_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // floats + { + var tmp1 lang.FnFunc + { // function floats + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Floats}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_floats.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xs)), kw_inline, tmp1, kw_doc, "Casts to float[]", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(12), kw_line, int(5392), kw_end_DASH_line, int(5392))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Floats") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Floats is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_floats = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_floats.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // fn? + { + tmp0 := sym_fn_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x implements Fn, i.e. is an object created via fn.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(6216), kw_end_DASH_line, int(6216))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := reflect.TypeOf((*runtime.Fn)(nil)) + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_fn_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_fn_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // fnext + { + tmp0 := sym_fnext.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Same as (first (next x))", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(6), kw_column, int(2), kw_line, int(112), kw_end_DASH_line, int(116))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function fnext + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_first) + tmp5 := checkDerefVar(var_glojure_DOT_core_next) + tmp6 := lang.Apply(tmp5, []any{v3}) + tmp7 := lang.Apply(tmp4, []any{tmp6}) + return tmp7 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(116), kw_column, int(8), kw_end_DASH_line, int(116), kw_end_DASH_column, int(47))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_fnext = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_fnext.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // future? + { + tmp0 := sym_future_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x is a future", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(6532), kw_end_DASH_line, int(6532))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := lang.Apply(tmp3, []any{nil, v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_future_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_future_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // gensym + { + tmp0 := sym_gensym.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_prefix_DASH_string)), kw_doc, "Returns a new symbol with a unique name. If a prefix string is\n supplied, the name is prefix# where # is some unique number. If\n prefix is not supplied, the prefix is 'G__'.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(599), kw_end_DASH_line, int(599))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp2 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp3 := lang.Apply(tmp2, []any{"G__"}) + return tmp3 + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_str) + tmp4 := checkDerefVar(var_glojure_DOT_core_str) + tmp5, _ := lang.FieldOrMethod(runtime.RT, "NextID") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("NextID is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{}) + tmp7 := lang.Apply(tmp4, []any{tmp6}) + tmp8 := lang.Apply(tmp3, []any{v2, tmp7}) + tmp9 := lang.Apply(lang.NewSymbol, []any{tmp8}) + return tmp9 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_gensym = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_gensym.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // get + { + var tmp1 lang.FnFunc + { // function get__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym__DOT_}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_Get}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v4}) + tmp21 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp20, v5}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp12, []any{tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp9, tmp11, tmp23}) + tmp25 := lang.Apply(tmp6, []any{tmp24}) + return tmp25 + } + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_get.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_map, sym_key), lang.NewVector(sym_map, sym_key, sym_not_DASH_found)), kw_inline, tmp1, kw_doc, "Returns the value mapped to key, not-found or nil if key not present\n in associative collection, set, string, array, or ILookup instance.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2), int64(3)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(1489), kw_end_DASH_line, int(1489))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(lang.Get, []any{v3, v4}) + return tmp5 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6 := lang.Apply(lang.GetDefault, []any{v3, v4, v5}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_get = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_get.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // halt-when + { + tmp0 := sym_halt_DASH_when.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred), lang.NewVector(sym_pred, sym_retf)), kw_doc, "Returns a transducer that ends transduction when pred returns true\n for an input. When retf is supplied it must be a fn of 2 arguments -\n it will be passed the (completed) result so far and the input that\n triggered the predicate, and its return value (if it does not throw\n an exception) will be the return value of the transducer. If retf\n is not supplied, the input that triggered the predicate will be\n returned. If the predicate never returns true the transduction is\n unaffected.", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(7657), kw_end_DASH_line, int(7657))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_halt_DASH_when) + tmp4 := lang.Apply(tmp3, []any{v2, nil}) + return tmp4 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v5 := args[0] + _ = v5 + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp7 := lang.Apply(v5, nil) + return tmp7 + case 1: + v7 := args[0] + _ = v7 + var tmp8 any + var tmp9 any + { // let + // let binding "and__0__auto__" + tmp10 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp11 := lang.Apply(tmp10, []any{v7}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + tmp14 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp15 := lang.Apply(tmp14, []any{v7, kw_glojure_DOT_core_SLASH_halt}) + tmp13 = tmp15 + } else { + tmp13 = v12 + } + tmp9 = tmp13 + } // end let + if lang.IsTruthy(tmp9) { + tmp10 := lang.Apply(kw_glojure_DOT_core_SLASH_halt, []any{v7}) + tmp8 = tmp10 + } else { + tmp11 := lang.Apply(v5, []any{v7}) + tmp8 = tmp11 + } + return tmp8 + case 2: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + var tmp9 any + tmp10 := lang.Apply(v2, []any{v8}) + if lang.IsTruthy(tmp10) { + tmp11 := checkDerefVar(var_glojure_DOT_core_reduced) + var tmp12 any + if lang.IsTruthy(v3) { + tmp13 := lang.Apply(v5, []any{v7}) + tmp14 := lang.Apply(v3, []any{tmp13, v8}) + tmp12 = tmp14 + } else { + tmp12 = v8 + } + tmp15 := lang.NewMap(kw_glojure_DOT_core_SLASH_halt, tmp12) + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7678), kw_column, int(24), kw_end_DASH_line, int(7678), kw_end_DASH_column, int(72)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp9 = tmp18 + } else { + tmp19 := lang.Apply(v5, []any{v7, v8}) + tmp9 = tmp19 + } + return tmp9 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7670), kw_column, int(8), kw_end_DASH_line, int(7679), kw_end_DASH_column, int(34)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp8 + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7669), kw_column, int(6), kw_end_DASH_line, int(7679), kw_end_DASH_column, int(35)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_halt_DASH_when = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_halt_DASH_when.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ident? + { + tmp0 := sym_ident_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a symbol or keyword", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(1608), kw_end_DASH_line, int(1608))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "or__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + tmp7 = v6 + } else { + tmp8 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp9 := lang.Apply(tmp8, []any{v2}) + tmp7 = tmp9 + } + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ident_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ident_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // identical? + { + var tmp1 lang.FnFunc + { // function identical?__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_lang_DOT_Util}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_glojure_DOT_core_SLASH_identical}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{v3}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v4}) + tmp17 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp12, tmp14, tmp16}) + tmp18 := lang.Apply(tmp5, []any{tmp17}) + return tmp18 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_identical_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Tests if 2 arguments are the same object", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(768), kw_end_DASH_line, int(768))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(lang.Identical, []any{v3, v4}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_identical_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_identical_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // if-not + { + tmp0 := sym_if_DASH_not.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_test, sym_then), lang.NewVector(sym_test, sym_then, sym_else)), kw_doc, "Evaluates test. If logical false, evaluates and returns then expr, \n otherwise else expr, if supplied, else nil.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(11), kw_line, int(760), kw_end_DASH_line, int(760))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_if_DASH_not}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{v4}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v5}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{nil}) + tmp16 := lang.Apply(tmp7, []any{tmp9, tmp11, tmp13, tmp15}) + tmp17 := lang.Apply(tmp6, []any{tmp16}) + return tmp17 + case 5: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_if}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_not}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v4}) + tmp18 := lang.Apply(tmp13, []any{tmp15, tmp17}) + tmp19 := lang.Apply(tmp12, []any{tmp18}) + tmp20 := lang.Apply(tmp11, []any{tmp19}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v5}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := lang.Apply(tmp23, []any{v6}) + tmp25 := lang.Apply(tmp8, []any{tmp10, tmp20, tmp22, tmp24}) + tmp26 := lang.Apply(tmp7, []any{tmp25}) + return tmp26 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_if_DASH_not = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_if_DASH_not.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ifn? + { + tmp0 := sym_ifn_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x implements IFn. Note that many data structures\n (e.g. sets and maps) implement IFn", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(6209), kw_end_DASH_line, int(6209))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := lang.Apply(tmp3, []any{nil, v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ifn_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ifn_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // inc + { + var tmp1 lang.FnFunc + { // function inc__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp15) { + tmp14 = sym_unchecked_inc + } else { + tmp14 = sym_inc + } + tmp16 := lang.Apply(tmp13, []any{tmp14}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := lang.Apply(tmp12, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp11, []any{tmp19}) + tmp21 := lang.Apply(tmp10, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_inc.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns a number one greater than num. Does not auto-promote\n longs, will throw on overflow. See also: inc'", kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(915), kw_end_DASH_line, int(915))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Inc") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Inc is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_inc = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_inc.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // inc' + { + var tmp1 lang.FnFunc + { // function inc'__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_IncP}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_inc_TICK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns a number one greater than num. Supports arbitrary precision.\n See also: inc", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(908), kw_end_DASH_line, int(908))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "IncP") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("IncP is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_inc_TICK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_inc_TICK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // indexed? + { + tmp0 := sym_indexed_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Return true if coll implements Indexed, indicating efficient lookup by index", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(6263), kw_end_DASH_line, int(6263))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := lang.Apply(tmp3, []any{nil, v2}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_indexed_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_indexed_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // infinite? + { + var tmp1 lang.FnFunc + { // function infinite?__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym_Double_SLASH_isInfinite}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{v3}) + tmp10 := lang.Apply(tmp5, []any{tmp7, tmp9}) + tmp11 := lang.Apply(tmp4, []any{tmp10}) + return tmp11 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_infinite_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_num)), kw_inline, tmp1, kw_doc, "Returns true if num is negative or positive infinity, else false", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1)})), kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(7977), kw_end_DASH_line, int(7977))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(nil, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_infinite_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_infinite_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // int + { + var tmp1 lang.FnFunc + { // function int__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp15) { + tmp14 = sym_uncheckedIntCast + } else { + tmp14 = sym_intCast + } + tmp16 := lang.Apply(tmp13, []any{tmp14}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := lang.Apply(tmp12, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp11, []any{tmp19}) + tmp21 := lang.Apply(tmp10, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to int", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(875), kw_end_DASH_line, int(875))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(runtime.RT, "IntCast") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("IntCast is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_int = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_int.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // int-array + { + var tmp1 lang.FnFunc + { // function int-array__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_IntArray}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_unquote_DASH_splicing}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_glojure_DOT_core_SLASH_args}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + } + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_int_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_size_DASH_or_DASH_seq), lang.NewVector(sym_size, sym_init_DASH_val_DASH_or_DASH_seq)), kw_inline, tmp1, kw_doc, "Creates an array of ints", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(5356), kw_end_DASH_line, int(5356))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "IntArray") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("IntArray is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "IntArrayInit") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("IntArrayInit is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_int_DASH_array = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_int_DASH_array.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // intern + { + tmp0 := sym_intern.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns, sym_name), lang.NewVector(sym_ns, sym_name, sym_val)), kw_doc, "Finds or creates a var named by the symbol name in the namespace\n ns (which can be a symbol or a namespace), setting its root binding\n to val if supplied. The namespace must exist. The var will adopt any\n metadata from the name symbol. Returns the var.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(6311), kw_end_DASH_line, int(6311))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "v" + tmp5 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) + tmp6 := lang.Apply(tmp5, []any{v2}) + tmp7 := lang.Apply(nil, []any{tmp6, v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_meta) + tmp11 := lang.Apply(tmp10, []any{v3}) + if lang.IsTruthy(tmp11) { + tmp12 := checkDerefVar(var_glojure_DOT_core_meta) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14, _ := lang.FieldOrMethod(v8, "setMeta") + if reflect.TypeOf(tmp14).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMeta is not a function"))) + } + tmp15 := lang.Apply(tmp14, []any{tmp13}) + tmp9 = tmp15 + } else { + } + _ = tmp9 + tmp4 = v8 + } // end let + return tmp4 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + { // let + // let binding "v" + tmp6 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) + tmp7 := lang.Apply(tmp6, []any{v2}) + tmp8 := lang.Apply(nil, []any{tmp7, v3, v4}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + tmp11 := checkDerefVar(var_glojure_DOT_core_meta) + tmp12 := lang.Apply(tmp11, []any{v3}) + if lang.IsTruthy(tmp12) { + tmp13 := checkDerefVar(var_glojure_DOT_core_meta) + tmp14 := lang.Apply(tmp13, []any{v3}) + tmp15, _ := lang.FieldOrMethod(v9, "setMeta") + if reflect.TypeOf(tmp15).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMeta is not a function"))) + } + tmp16 := lang.Apply(tmp15, []any{tmp14}) + tmp10 = tmp16 + } else { + } + _ = tmp10 + tmp5 = v9 + } // end let + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_intern = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_intern.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // into-array + { + tmp0 := sym_into_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_aseq), lang.NewVector(sym_type, sym_aseq)), kw_doc, "Returns an array with components set to the values in aseq. The array's\n component type is type if provided, or the type of the first value in\n aseq if present, or Object. All values in aseq must be compatible with\n the component type. Class objects for the primitive types can be obtained\n using, e.g., Integer/TYPE.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(3444), kw_end_DASH_line, int(3444))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_seq) + tmp4 := lang.Apply(tmp3, []any{v2}) + tmp5 := lang.Apply(nil, []any{tmp4}) + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := lang.Apply(tmp4, []any{v3}) + tmp6 := lang.Apply(nil, []any{v2, tmp5}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_into_DASH_array = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_into_DASH_array.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ints + { + var tmp1 lang.FnFunc + { // function ints + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Ints}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_ints.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xs)), kw_inline, tmp1, kw_doc, "Casts to int[]", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(12), kw_line, int(5397), kw_end_DASH_line, int(5397))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Ints") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Ints is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ints = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ints.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // io! + { + tmp0 := sym_io_BANG_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_body)), kw_doc, "If an io! block occurs in a transaction, throws an\n IllegalStateException, else runs body in an implicit do. If the\n first expression in body is a literal string, will use that as the\n exception message.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(11), kw_line, int(2504), kw_end_DASH_line, int(2504))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "message" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp8 := checkDerefVar(var_glojure_DOT_core_first) + tmp9 := lang.Apply(tmp8, []any{v4}) + tmp10 := lang.Apply(tmp7, []any{tmp9}) + if lang.IsTruthy(tmp10) { + tmp11 := checkDerefVar(var_glojure_DOT_core_first) + tmp12 := lang.Apply(tmp11, []any{v4}) + tmp6 = tmp12 + } else { + } + var v13 any = tmp6 + _ = v13 + // let binding "body" + var tmp14 any + if lang.IsTruthy(v13) { + tmp15 := checkDerefVar(var_glojure_DOT_core_next) + tmp16 := lang.Apply(tmp15, []any{v4}) + tmp14 = tmp16 + } else { + tmp14 = v4 + } + var v17 any = tmp14 + _ = v17 + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{sym_if}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := checkDerefVar(var_glojure_DOT_core_seq) + tmp24 := checkDerefVar(var_glojure_DOT_core_concat) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := lang.Apply(tmp25, []any{sym_glojure_DOT_lang_DOT_LockingTransaction_SLASH_isRunning}) + tmp27 := lang.Apply(tmp24, []any{tmp26}) + tmp28 := lang.Apply(tmp23, []any{tmp27}) + tmp29 := lang.Apply(tmp22, []any{tmp28}) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := checkDerefVar(var_glojure_DOT_core_seq) + tmp32 := checkDerefVar(var_glojure_DOT_core_concat) + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{sym_throw}) + tmp35 := checkDerefVar(var_glojure_DOT_core_list) + tmp36 := checkDerefVar(var_glojure_DOT_core_seq) + tmp37 := checkDerefVar(var_glojure_DOT_core_concat) + tmp38 := checkDerefVar(var_glojure_DOT_core_list) + tmp39 := lang.Apply(tmp38, []any{sym_new}) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{sym_glojure_DOT_core_SLASH_IllegalStateException}) + tmp42 := checkDerefVar(var_glojure_DOT_core_list) + var tmp43 any + { // let + // let binding "or__0__auto__" + var v44 any = v13 + _ = v44 + var tmp45 any + if lang.IsTruthy(v44) { + tmp45 = v44 + } else { + tmp45 = "I/O in transaction" + } + tmp43 = tmp45 + } // end let + tmp44 := lang.Apply(tmp42, []any{tmp43}) + tmp45 := lang.Apply(tmp37, []any{tmp39, tmp41, tmp44}) + tmp46 := lang.Apply(tmp36, []any{tmp45}) + tmp47 := lang.Apply(tmp35, []any{tmp46}) + tmp48 := lang.Apply(tmp32, []any{tmp34, tmp47}) + tmp49 := lang.Apply(tmp31, []any{tmp48}) + tmp50 := lang.Apply(tmp30, []any{tmp49}) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := checkDerefVar(var_glojure_DOT_core_seq) + tmp53 := checkDerefVar(var_glojure_DOT_core_concat) + tmp54 := checkDerefVar(var_glojure_DOT_core_list) + tmp55 := lang.Apply(tmp54, []any{sym_do}) + tmp56 := lang.Apply(tmp53, []any{tmp55, v17}) + tmp57 := lang.Apply(tmp52, []any{tmp56}) + tmp58 := lang.Apply(tmp51, []any{tmp57}) + tmp59 := lang.Apply(tmp19, []any{tmp21, tmp29, tmp50, tmp58}) + tmp60 := lang.Apply(tmp18, []any{tmp59}) + tmp5 = tmp60 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_io_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_io_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // keep-indexed + { + tmp0 := sym_keep_DASH_indexed.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_coll)), kw_doc, "Returns a lazy sequence of the non-nil results of (f index item). Note,\n this means false return values will be included. f must be free of\n side-effects. Returns a stateful transducer when no collection is\n provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(7372), kw_end_DASH_line, int(7372))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 any + { // let + // let binding "iv" + tmp6 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) + tmp7 := lang.Apply(tmp6, []any{int64(-1)}) + var v8 any = tmp7 + _ = v8 + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp10 := lang.Apply(v4, nil) + return tmp10 + case 1: + v10 := args[0] + _ = v10 + tmp11 := lang.Apply(v4, []any{v10}) + return tmp11 + case 2: + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + var tmp12 any + { // let + // let binding "i" + tmp13 := checkDerefVar(var_glojure_DOT_core_inc) + tmp14, ok := lang.FieldOrMethod(v8, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "Deref"))) + } + var tmp15 any + switch reflect.TypeOf(tmp14).Kind() { + case reflect.Func: + tmp15 = lang.Apply(tmp14, nil) + default: + tmp15 = tmp14 + } + tmp16 := lang.Apply(tmp13, []any{tmp15}) + tmp17, _ := lang.FieldOrMethod(v8, "reset") + if reflect.TypeOf(tmp17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) + } + tmp18 := lang.Apply(tmp17, []any{tmp16}) + var v19 any = tmp18 + _ = v19 + // let binding "v" + tmp20 := lang.Apply(v2, []any{v19, v11}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + tmp23 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp24 := lang.Apply(tmp23, []any{v21}) + if lang.IsTruthy(tmp24) { + tmp22 = v10 + } else { + tmp25 := lang.Apply(v4, []any{v10, v21}) + tmp22 = tmp25 + } + tmp12 = tmp22 + } // end let + return tmp12 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7382), kw_column, int(8), kw_end_DASH_line, int(7390), kw_end_DASH_column, int(33)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp5 = tmp11 + } // end let + return tmp5 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7380), kw_column, int(4), kw_end_DASH_line, int(7390), kw_end_DASH_column, int(35)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + return nil + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_keep_DASH_indexed = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_keep_DASH_indexed.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // keyword + { + tmp1 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() + tmp0 := sym_keyword.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_name), lang.NewVector(sym_ns, sym_name)), kw_doc, "Returns a Keyword with the given namespace and name. Do not use :\n in the keyword strings, it will be added automatically.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(609), kw_end_DASH_line, int(609))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + tmp4 = v3 + } else { + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp9 := lang.Apply(tmp8, []any{v3}) + if lang.IsTruthy(tmp9) { + tmp10 := lang.Apply(lang.InternKeywordSymbol, []any{v3}) + tmp7 = tmp10 + } else { + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp13 := lang.Apply(tmp12, []any{v3}) + if lang.IsTruthy(tmp13) { + tmp14 := lang.Apply(lang.InternKeywordString, []any{v3}) + tmp11 = tmp14 + } else { + } + tmp7 = tmp11 + } + tmp4 = tmp7 + } + return tmp4 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(lang.InternKeyword, []any{v3, v4}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp3 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_keyword = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_keyword.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // last + { + tmp0 := sym_last.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Return the last item in coll, in linear time", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(5), kw_column, int(2), kw_line, int(262), kw_end_DASH_line, int(266))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function last + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + recur_loop_1572: + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_next) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + tmp8 := checkDerefVar(var_glojure_DOT_core_next) + tmp9 := lang.Apply(tmp8, []any{v3}) + var tmp7 any = tmp9 + v3 = tmp7 + goto recur_loop_1572 + } else { + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v3}) + tmp4 = tmp11 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(266), kw_column, int(7), kw_end_DASH_line, int(269), kw_end_DASH_column, int(21))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_last = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_last.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // libspec? + { + tmp0 := sym_libspec_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns true if x is a libspec", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(8), kw_line, int(5848), kw_end_DASH_line, int(5848), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "or__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + tmp7 = v6 + } else { + var tmp8 any + { // let + // let binding "and__0__auto__" + tmp9 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp10 := lang.Apply(tmp9, []any{v2}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + var tmp13 any + { // let + // let binding "or__0__auto__" + tmp14 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp15 := checkDerefVar(var_glojure_DOT_core_second) + tmp16 := lang.Apply(tmp15, []any{v2}) + tmp17 := lang.Apply(tmp14, []any{tmp16}) + var v18 any = tmp17 + _ = v18 + var tmp19 any + if lang.IsTruthy(v18) { + tmp19 = v18 + } else { + tmp20 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp21 := checkDerefVar(var_glojure_DOT_core_second) + tmp22 := lang.Apply(tmp21, []any{v2}) + tmp23 := lang.Apply(tmp20, []any{tmp22}) + tmp19 = tmp23 + } + tmp13 = tmp19 + } // end let + tmp12 = tmp13 + } else { + tmp12 = v11 + } + tmp8 = tmp12 + } // end let + tmp7 = tmp8 + } + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_libspec_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_libspec_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // list* + { + tmp0 := sym_list_STAR_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_args), lang.NewVector(sym_a, sym_args), lang.NewVector(sym_a, sym_b, sym_args), lang.NewVector(sym_a, sym_b, sym_c, sym_args), lang.NewVector(sym_a, sym_b, sym_c, sym_d, sym__AMP_, sym_more)), kw_doc, "Creates a new seq containing the items prepended to the rest, the\n last of which will be treated as a sequence.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(641), kw_end_DASH_line, int(641))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_seq) + tmp4 := lang.Apply(tmp3, []any{v2}) + return tmp4 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_cons) + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + return tmp5 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_cons) + tmp6 := checkDerefVar(var_glojure_DOT_core_cons) + tmp7 := lang.Apply(tmp6, []any{v3, v4}) + tmp8 := lang.Apply(tmp5, []any{v2, tmp7}) + return tmp8 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_cons) + tmp7 := checkDerefVar(var_glojure_DOT_core_cons) + tmp8 := checkDerefVar(var_glojure_DOT_core_cons) + tmp9 := lang.Apply(tmp8, []any{v4, v5}) + tmp10 := lang.Apply(tmp7, []any{v3, tmp9}) + tmp11 := lang.Apply(tmp6, []any{v2, tmp10}) + return tmp11 + default: + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var v6 any = lang.NewList(args[4:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_cons) + tmp8 := checkDerefVar(var_glojure_DOT_core_cons) + tmp9 := checkDerefVar(var_glojure_DOT_core_cons) + tmp10 := checkDerefVar(var_glojure_DOT_core_cons) + tmp11 := checkDerefVar(var_glojure_DOT_core_spread) + tmp12 := lang.Apply(tmp11, []any{v6}) + tmp13 := lang.Apply(tmp10, []any{v5, tmp12}) + tmp14 := lang.Apply(tmp9, []any{v4, tmp13}) + tmp15 := lang.Apply(tmp8, []any{v3, tmp14}) + tmp16 := lang.Apply(tmp7, []any{v2, tmp15}) + return tmp16 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_list_STAR_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_list_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // loaded-libs + { + tmp0 := sym_loaded_DASH_libs.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Returns a sorted set of symbols naming the currently loaded libs", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(6090), kw_end_DASH_line, int(6090))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp2 := checkDerefVar(var_glojure_DOT_core_deref) + tmp3 := checkDerefVar(var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_) + tmp4 := lang.Apply(tmp2, []any{tmp3}) + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_loaded_DASH_libs = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_loaded_DASH_libs.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // long + { + var tmp1 lang.FnFunc + { // function long__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_LongCast}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_long.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to long", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3481), kw_end_DASH_line, int(3481))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.LongCast, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_long = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_long.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // long-array + { + var tmp1 lang.FnFunc + { // function long-array__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_LongArray}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_unquote_DASH_splicing}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_glojure_DOT_core_SLASH_args}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + } + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_long_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_size_DASH_or_DASH_seq), lang.NewVector(sym_size, sym_init_DASH_val_DASH_or_DASH_seq)), kw_inline, tmp1, kw_doc, "Creates an array of longs", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(5364), kw_end_DASH_line, int(5364))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "LongArray") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("LongArray is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "LongArrayInit") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("LongArrayInit is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_long_DASH_array = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_long_DASH_array.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // longs + { + var tmp1 lang.FnFunc + { // function longs + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Longs}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_longs.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xs)), kw_inline, tmp1, kw_doc, "Casts to long[]", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(12), kw_line, int(5407), kw_end_DASH_line, int(5407))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Longs") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Longs is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_longs = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_longs.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // macroexpand + { + tmp0 := sym_macroexpand.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_form)), kw_doc, "Repeatedly calls macroexpand-1 on form until it no longer\n represents a macro form, then returns it. Note neither\n macroexpand-1 nor macroexpand expand macros in subforms.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(4025), kw_end_DASH_line, int(4025))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "ex" + tmp4 := checkDerefVar(var_glojure_DOT_core_macroexpand_DASH_1) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core_identical_QMARK_) + tmp9 := lang.Apply(tmp8, []any{v6, v2}) + if lang.IsTruthy(tmp9) { + tmp7 = v2 + } else { + tmp10 := checkDerefVar(var_glojure_DOT_core_macroexpand) + tmp11 := lang.Apply(tmp10, []any{v6}) + tmp7 = tmp11 + } + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_macroexpand = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_macroexpand.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // map-indexed + { + tmp0 := sym_map_DASH_indexed.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_coll)), kw_doc, "Returns a lazy sequence consisting of the result of applying f to 0\n and the first item of coll, followed by applying f to 1 and the second\n item in coll, etc, until coll is exhausted. Thus function f should\n accept 2 arguments, index and item. Returns a stateful transducer when\n no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(7309), kw_end_DASH_line, int(7309))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 any + { // let + // let binding "i" + tmp6 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) + tmp7 := lang.Apply(tmp6, []any{int64(-1)}) + var v8 any = tmp7 + _ = v8 + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp10 := lang.Apply(v4, nil) + return tmp10 + case 1: + v10 := args[0] + _ = v10 + tmp11 := lang.Apply(v4, []any{v10}) + return tmp11 + case 2: + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_inc) + tmp13, ok := lang.FieldOrMethod(v8, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "Deref"))) + } + var tmp14 any + switch reflect.TypeOf(tmp13).Kind() { + case reflect.Func: + tmp14 = lang.Apply(tmp13, nil) + default: + tmp14 = tmp13 + } + tmp15 := lang.Apply(tmp12, []any{tmp14}) + tmp16, _ := lang.FieldOrMethod(v8, "reset") + if reflect.TypeOf(tmp16).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) + } + tmp17 := lang.Apply(tmp16, []any{tmp15}) + tmp18 := lang.Apply(v2, []any{tmp17, v11}) + tmp19 := lang.Apply(v4, []any{v10, tmp18}) + return tmp19 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7320), kw_column, int(8), kw_end_DASH_line, int(7324), kw_end_DASH_column, int(48)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp5 = tmp11 + } // end let + return tmp5 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7318), kw_column, int(4), kw_end_DASH_line, int(7324), kw_end_DASH_column, int(50)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + return nil + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_map_DASH_indexed = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_map_DASH_indexed.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // maybe-destructured + { + tmp0 := sym_maybe_DASH_destructured.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(4514), kw_column, int(7), kw_end_DASH_line, int(4515), kw_end_DASH_column, int(20), kw_arglists, lang.NewList(lang.NewVector(sym_params, sym_body)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + tmp6 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp7 := lang.Apply(tmp5, []any{tmp6, v2}) + if lang.IsTruthy(tmp7) { + tmp8 := checkDerefVar(var_glojure_DOT_core_cons) + tmp9 := lang.Apply(tmp8, []any{v2, v3}) + tmp4 = tmp9 + } else { + var tmp10 any + { // let + // let binding "params" + var v11 any = v2 + _ = v11 + // let binding "new-params" + tmp12 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp13 := lang.NewVector() + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4520), kw_column, int(34), kw_end_DASH_line, int(4520), kw_end_DASH_column, int(35)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp16 := checkDerefVar(var_glojure_DOT_core_meta) + tmp17 := lang.Apply(tmp16, []any{v11}) + tmp18 := lang.Apply(tmp12, []any{tmp15, tmp17}) + var v19 any = tmp18 + _ = v19 + // let binding "lets" + tmp20 := lang.NewVector() + tmp21 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4521), kw_column, int(17), kw_end_DASH_line, int(4521), kw_end_DASH_column, int(18)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v23 any = tmp22 + _ = v23 + for { + var tmp24 any + if lang.IsTruthy(v11) { + var tmp25 any + tmp26 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp27 := checkDerefVar(var_glojure_DOT_core_first) + tmp28 := lang.Apply(tmp27, []any{v11}) + tmp29 := lang.Apply(tmp26, []any{tmp28}) + if lang.IsTruthy(tmp29) { + tmp31 := checkDerefVar(var_glojure_DOT_core_next) + tmp32 := lang.Apply(tmp31, []any{v11}) + var tmp30 any = tmp32 + tmp34 := checkDerefVar(var_glojure_DOT_core_conj) + tmp35 := checkDerefVar(var_glojure_DOT_core_first) + tmp36 := lang.Apply(tmp35, []any{v11}) + tmp37 := lang.Apply(tmp34, []any{v19, tmp36}) + var tmp33 any = tmp37 + var tmp38 any = v23 + v11 = tmp30 + v19 = tmp33 + v23 = tmp38 + continue + } else { + var tmp39 any + { // let + // let binding "gparam" + tmp40 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp41 := lang.Apply(tmp40, []any{"p__"}) + var v42 any = tmp41 + _ = v42 + tmp44 := checkDerefVar(var_glojure_DOT_core_next) + tmp45 := lang.Apply(tmp44, []any{v11}) + var tmp43 any = tmp45 + tmp47 := checkDerefVar(var_glojure_DOT_core_conj) + tmp48 := lang.Apply(tmp47, []any{v19, v42}) + var tmp46 any = tmp48 + tmp50 := checkDerefVar(var_glojure_DOT_core_conj) + tmp51 := checkDerefVar(var_glojure_DOT_core_conj) + tmp52 := checkDerefVar(var_glojure_DOT_core_first) + tmp53 := lang.Apply(tmp52, []any{v11}) + tmp54 := lang.Apply(tmp51, []any{v23, tmp53}) + tmp55 := lang.Apply(tmp50, []any{tmp54, v42}) + var tmp49 any = tmp55 + v11 = tmp43 + v19 = tmp46 + v23 = tmp49 + continue + } // end let + tmp25 = tmp39 + } + tmp24 = tmp25 + } else { + tmp40 := checkDerefVar(var_glojure_DOT_core_seq) + tmp41 := checkDerefVar(var_glojure_DOT_core_concat) + tmp42 := checkDerefVar(var_glojure_DOT_core_list) + tmp43 := lang.Apply(tmp42, []any{v19}) + tmp44 := checkDerefVar(var_glojure_DOT_core_list) + tmp45 := checkDerefVar(var_glojure_DOT_core_seq) + tmp46 := checkDerefVar(var_glojure_DOT_core_concat) + tmp47 := checkDerefVar(var_glojure_DOT_core_list) + tmp48 := lang.Apply(tmp47, []any{sym_glojure_DOT_core_SLASH_let}) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) + tmp50 := lang.Apply(tmp49, []any{v23}) + tmp51 := lang.Apply(tmp46, []any{tmp48, tmp50, v3}) + tmp52 := lang.Apply(tmp45, []any{tmp51}) + tmp53 := lang.Apply(tmp44, []any{tmp52}) + tmp54 := lang.Apply(tmp41, []any{tmp43, tmp53}) + tmp55 := lang.Apply(tmp40, []any{tmp54}) + tmp24 = tmp55 + } + tmp10 = tmp24 + break + } + } // end let + tmp4 = tmp10 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_maybe_DASH_destructured = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_maybe_DASH_destructured.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // name + { + tmp1 := reflect.TypeOf("") + tmp0 := sym_name.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns the name String of a string, symbol or keyword.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1585), kw_end_DASH_line, int(1585))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + tmp4 = v3 + } else { + tmp7, _ := lang.FieldOrMethod(v3, "Name") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Name is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{}) + tmp4 = tmp8 + } + return tmp4 + }) + tmp3 := reflect.TypeOf("") + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_name = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_name.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // neg? + { + var tmp1 lang.FnFunc + { // function neg?__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_IsNeg}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_neg_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_num)), kw_inline, tmp1, kw_doc, "Returns true if num is less than zero, else false", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1259), kw_end_DASH_line, int(1259))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "IsNeg") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("IsNeg is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_neg_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_neg_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // not-empty + { + tmp0 := sym_not_DASH_empty.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "If coll is empty, returns nil, else coll", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(5516), kw_end_DASH_line, int(5516))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + tmp3 = v2 + } else { + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_not_DASH_empty = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_not_DASH_empty.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ns-aliases + { + tmp0 := sym_ns_DASH_aliases.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns)), kw_doc, "Returns a map of the aliases for the namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4273), kw_end_DASH_line, int(4273))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) + tmp4 := lang.Apply(tmp3, []any{v2}) + tmp5, ok := lang.FieldOrMethod(tmp4, "getAliases") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp4, "getAliases"))) + } + var tmp6 any + switch reflect.TypeOf(tmp5).Kind() { + case reflect.Func: + tmp6 = lang.Apply(tmp5, nil) + default: + tmp6 = tmp5 + } + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ns_DASH_aliases = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ns_DASH_aliases.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ns-map + { + tmp0 := sym_ns_DASH_map.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns)), kw_doc, "Returns a map of all the mappings for the namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(4170), kw_end_DASH_line, int(4170))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) + tmp4 := lang.Apply(tmp3, []any{v2}) + tmp5, ok := lang.FieldOrMethod(tmp4, "Mappings") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp4, "Mappings"))) + } + var tmp6 any + switch reflect.TypeOf(tmp5).Kind() { + case reflect.Func: + tmp6 = lang.Apply(tmp5, nil) + default: + tmp6 = tmp5 + } + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ns_DASH_map = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ns_DASH_map.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ns-name + { + tmp0 := sym_ns_DASH_name.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns)), kw_doc, "Returns the name of the namespace, a symbol.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4163), kw_end_DASH_line, int(4163))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) + tmp4 := lang.Apply(tmp3, []any{v2}) + tmp5, ok := lang.FieldOrMethod(tmp4, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp4, "Name"))) + } + var tmp6 any + switch reflect.TypeOf(tmp5).Kind() { + case reflect.Func: + tmp6 = lang.Apply(tmp5, nil) + default: + tmp6 = tmp5 + } + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ns_DASH_name = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ns_DASH_name.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ns-resolve + { + tmp0 := sym_ns_DASH_resolve.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns, sym_sym), lang.NewVector(sym_ns, sym_env, sym_sym)), kw_doc, "Returns the var or Class to which a symbol will be resolved in the\n namespace (unless found in the environment), else nil. Note that\n if the symbol is fully qualified, the var/Class to which it resolves\n need not be present in the namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4358), kw_end_DASH_line, int(4358))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_ns_DASH_resolve) + tmp5 := lang.Apply(tmp4, []any{v2, nil, v3}) + return tmp5 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp7 := lang.Apply(tmp6, []any{v3, v4}) + if lang.IsTruthy(tmp7) { + } else { + tmp8 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) + tmp9 := lang.Apply(tmp8, []any{v2}) + tmp10, _ := lang.FieldOrMethod(runtime.Compiler, "maybeResolveIn") + if reflect.TypeOf(tmp10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("maybeResolveIn is not a function"))) + } + tmp11 := lang.Apply(tmp10, []any{tmp9, v4}) + tmp5 = tmp11 + } + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ns_DASH_resolve = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ns_DASH_resolve.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ns-unalias + { + tmp0 := sym_ns_DASH_unalias.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns, sym_sym)), kw_doc, "Removes the alias for the symbol from the namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4280), kw_end_DASH_line, int(4280))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) + tmp5 := lang.Apply(tmp4, []any{v2}) + tmp6, _ := lang.FieldOrMethod(tmp5, "removeAlias") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("removeAlias is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v3}) + return tmp7 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ns_DASH_unalias = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ns_DASH_unalias.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ns-unmap + { + tmp0 := sym_ns_DASH_unmap.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns, sym_sym)), kw_doc, "Removes the mappings for the symbol from the namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(4177), kw_end_DASH_line, int(4177))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) + tmp5 := lang.Apply(tmp4, []any{v2}) + tmp6, _ := lang.FieldOrMethod(tmp5, "unmap") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unmap is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v3}) + return tmp7 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ns_DASH_unmap = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ns_DASH_unmap.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // nth + { + var tmp1 lang.FnFunc + { // function nth__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym__DOT_}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_Nth}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{sym_glojure_DOT_core_SLASH_unquote}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{sym_glojure_DOT_core_SLASH_c}) + tmp24 := lang.Apply(tmp19, []any{tmp21, tmp23}) + tmp25 := lang.Apply(tmp18, []any{tmp24}) + tmp26 := lang.Apply(tmp17, []any{tmp25}) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := checkDerefVar(var_glojure_DOT_core_seq) + tmp29 := checkDerefVar(var_glojure_DOT_core_concat) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := lang.Apply(tmp30, []any{sym_glojure_DOT_core_SLASH_unquote}) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := lang.Apply(tmp32, []any{sym_glojure_DOT_core_SLASH_i}) + tmp34 := lang.Apply(tmp29, []any{tmp31, tmp33}) + tmp35 := lang.Apply(tmp28, []any{tmp34}) + tmp36 := lang.Apply(tmp27, []any{tmp35}) + tmp37 := checkDerefVar(var_glojure_DOT_core_list) + tmp38 := checkDerefVar(var_glojure_DOT_core_seq) + tmp39 := checkDerefVar(var_glojure_DOT_core_concat) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{sym_glojure_DOT_core_SLASH_unquote_DASH_splicing}) + tmp42 := checkDerefVar(var_glojure_DOT_core_list) + tmp43 := lang.Apply(tmp42, []any{sym_glojure_DOT_core_SLASH_nf}) + tmp44 := lang.Apply(tmp39, []any{tmp41, tmp43}) + tmp45 := lang.Apply(tmp38, []any{tmp44}) + tmp46 := lang.Apply(tmp37, []any{tmp45}) + tmp47 := lang.Apply(tmp14, []any{tmp16, tmp26, tmp36, tmp46}) + tmp48 := lang.Apply(tmp13, []any{tmp47}) + tmp49 := lang.Apply(tmp12, []any{tmp48}) + tmp50 := lang.Apply(tmp7, []any{tmp9, tmp11, tmp49}) + tmp51 := lang.Apply(tmp6, []any{tmp50}) + return tmp51 + } + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_nth.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll, sym_index), lang.NewVector(sym_coll, sym_index, sym_not_DASH_found)), kw_inline, tmp1, kw_doc, "Returns the value at the index. get returns nil if index out of\n bounds, nth throws an exception unless not-found is supplied. nth\n also works for strings, Java arrays, regex Matchers and Lists, and,\n in O(n) time, for sequences.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2), int64(3)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(882), kw_end_DASH_line, int(882))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(runtime.RT, "Nth") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Nth is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6, _ := lang.FieldOrMethod(runtime.RT, "NthDefault") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("NthDefault is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v3, v4, v5}) + return tmp7 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_nth = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_nth.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // num + { + var tmp1 lang.FnFunc + { // function num__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Num}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_num.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to Number", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(3474), kw_end_DASH_line, int(3474))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Num") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Num is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_num = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_num.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // object-array + { + var tmp1 lang.FnFunc + { // function object-array__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Object_array}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_object_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_size_DASH_or_DASH_seq)), kw_inline, tmp1, kw_doc, "Creates an array of objects", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1)})), kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(5349), kw_end_DASH_line, int(5349))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(runtime.RT, "Object_array") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Object_array is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_object_DASH_array = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_object_DASH_array.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // parse-impls + { + tmp0 := sym_parse_DASH_impls.WithMeta(lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(13), kw_column, int(8), kw_end_DASH_line, int(13), kw_end_DASH_column, int(18), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_specs)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "ret" + tmp4 := lang.NewMap() + tmp5 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(14), kw_column, int(14), kw_end_DASH_line, int(14), kw_end_DASH_column, int(15)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v7 any = tmp6 + _ = v7 + // let binding "s" + var v8 any = v2 + _ = v8 + for { + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_seq) + tmp11 := lang.Apply(tmp10, []any{v8}) + if lang.IsTruthy(tmp11) { + tmp13 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp14 := checkDerefVar(var_glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v8}) + tmp16 := checkDerefVar(var_glojure_DOT_core_take_DASH_while) + tmp17 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp18 := checkDerefVar(var_glojure_DOT_core_next) + tmp19 := lang.Apply(tmp18, []any{v8}) + tmp20 := lang.Apply(tmp16, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp13, []any{v7, tmp15, tmp20}) + var tmp12 any = tmp21 + tmp23 := checkDerefVar(var_glojure_DOT_core_drop_DASH_while) + tmp24 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp25 := checkDerefVar(var_glojure_DOT_core_next) + tmp26 := lang.Apply(tmp25, []any{v8}) + tmp27 := lang.Apply(tmp23, []any{tmp24, tmp26}) + var tmp22 any = tmp27 + v7 = tmp12 + v8 = tmp22 + continue + } else { + tmp9 = v7 + } + tmp3 = tmp9 + break + } + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_parse_DASH_impls = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_parse_DASH_impls.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // parse-uuid + { + tmp0 := sym_parse_DASH_uuid.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_doc, "Parse a string representing a UUID and return a java.util.UUID instance,\n or nil if parse fails.\n\n Grammar: https://docs.oracle.com/javase/8/docs/api/java/util/UUID.html#toString--", kw_file, "glojure/core.glj", kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(7946), kw_end_DASH_line, int(7946))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + func() { + defer func() { + if r := recover(); r != nil { + tmp4 := reflect.TypeOf((*lang.IllegalArgumentError)(nil)) + if lang.CatchMatches(r, tmp4) { + v5 := r + _ = v5 + } else { + panic(r) + } + } + }() + var tmp5 any + { // let + // let binding "vec__688" + tmp6 := lang.Apply(uuid10.Parse, []any{v2}) + var v7 any = tmp6 + _ = v7 + // let binding "uuid" + tmp8 := checkDerefVar(var_glojure_DOT_core_nth) + tmp9 := lang.Apply(tmp8, []any{v7, int64(0), nil}) + var v10 any = tmp9 + _ = v10 + // let binding "err" + tmp11 := checkDerefVar(var_glojure_DOT_core_nth) + tmp12 := lang.Apply(tmp11, []any{v7, int64(1), nil}) + var v13 any = tmp12 + _ = v13 + var tmp14 any + if lang.IsTruthy(v13) { + tmp15 := checkDerefVar(var_glojure_DOT_core_str) + tmp16 := lang.Apply(tmp15, []any{"Error parsing UUID: ", v13}) + tmp17 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp16}) + panic(tmp17) + } else { + tmp14 = v10 + } + tmp5 = tmp14 + } // end let + tmp3 = tmp5 + }() + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_parse_DASH_uuid = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_parse_DASH_uuid.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // parsing-err + { + tmp0 := sym_parsing_DASH_err.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_val)), kw_doc, "Construct message for parsing for non-string parsing error", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(8), kw_line, int(7921), kw_end_DASH_line, int(7921), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_str) + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v2}) + if lang.IsTruthy(tmp6) { + tmp4 = "nil" + } else { + tmp7 := checkDerefVar(var_glojure_DOT_core_class) + tmp8 := lang.Apply(tmp7, []any{v2}) + tmp9, ok := lang.FieldOrMethod(tmp8, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp8, "Name"))) + } + var tmp10 any + switch reflect.TypeOf(tmp9).Kind() { + case reflect.Func: + tmp10 = lang.Apply(tmp9, nil) + default: + tmp10 = tmp9 + } + tmp4 = tmp10 + } + tmp11 := lang.Apply(tmp3, []any{"Expected string, got ", tmp4}) + return tmp11 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_parsing_DASH_err = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_parsing_DASH_err.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // pos? + { + var tmp1 lang.FnFunc + { // function pos?__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_IsPos}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_pos_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_num)), kw_inline, tmp1, kw_doc, "Returns true if num is greater than zero, else false", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1252), kw_end_DASH_line, int(1252))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "IsPos") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("IsPos is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_pos_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_pos_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // prependss + { + tmp0 := sym_prependss.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_coll)), kw_doc, "Prepends a symbol or a seq to coll", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(8), kw_line, int(5857), kw_end_DASH_line, int(5857), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v2}) + if lang.IsTruthy(tmp6) { + tmp7 := checkDerefVar(var_glojure_DOT_core_cons) + tmp8 := lang.Apply(tmp7, []any{v2, v3}) + tmp4 = tmp8 + } else { + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := lang.Apply(tmp9, []any{v2, v3}) + tmp4 = tmp10 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_prependss = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_prependss.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print-ctor + { + tmp0 := sym_print_DASH_ctor.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(95), kw_column, int(7), kw_end_DASH_line, int(95), kw_end_DASH_column, int(16), kw_arglists, lang.NewList(lang.NewVector(sym_o, sym_print_DASH_args, sym_w)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := lang.Apply(lang.WriteWriter, []any{v4, "#=("}) + _ = tmp5 + tmp6 := checkDerefVar(var_glojure_DOT_core_class) + tmp7 := lang.Apply(tmp6, []any{v2}) + tmp8, ok := lang.FieldOrMethod(tmp7, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp7, "Name"))) + } + var tmp9 any + switch reflect.TypeOf(tmp8).Kind() { + case reflect.Func: + tmp9 = lang.Apply(tmp8, nil) + default: + tmp9 = tmp8 + } + tmp10 := lang.Apply(lang.WriteWriter, []any{v4, tmp9}) + _ = tmp10 + tmp11 := lang.Apply(lang.WriteWriter, []any{v4, ". "}) + _ = tmp11 + tmp12 := lang.Apply(v3, []any{v2, v4}) + _ = tmp12 + tmp13 := lang.Apply(lang.WriteWriter, []any{v4, ")"}) + return tmp13 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_print_DASH_ctor = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_print_DASH_ctor.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // quot + { + var tmp1 lang.FnFunc + { // function quot__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Quotient}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_quot.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_num, sym_div)), kw_inline, tmp1, kw_doc, "quot[ient] of dividing numerator by denominator.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1266), kw_end_DASH_line, int(1266))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Quotient") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Quotient is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_quot = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_quot.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // range + { + tmp0 := sym_range.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_end), lang.NewVector(sym_start, sym_end), lang.NewVector(sym_start, sym_end, sym_step)), kw_doc, "Returns a lazy seq of nums from start (inclusive) to end\n (exclusive), by step, where start defaults to 0, step to 1, and end to\n infinity. When step is equal to 0, returns an infinite sequence of\n start. When start is equal to end, returns empty list.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3018), kw_end_DASH_line, int(3018))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp2 := checkDerefVar(var_glojure_DOT_core_iterate) + tmp3 := checkDerefVar(var_glojure_DOT_core_inc_TICK_) + tmp4 := lang.Apply(tmp2, []any{tmp3, int64(0)}) + return tmp4 + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + tmp6 := lang.Apply(lang.NewLongRange, []any{int64(0), v2, int64(1)}) + tmp3 = tmp6 + } else { + tmp7 := lang.Apply(lang.NewRange, []any{int64(0), v2, int64(1)}) + tmp3 = tmp7 + } + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + var tmp5 any + { // let + // let binding "and__0__auto__" + tmp6 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) + tmp7 := lang.Apply(tmp6, []any{v2}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + tmp10 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) + tmp11 := lang.Apply(tmp10, []any{v3}) + tmp9 = tmp11 + } else { + tmp9 = v8 + } + tmp5 = tmp9 + } // end let + if lang.IsTruthy(tmp5) { + tmp6 := lang.Apply(lang.NewLongRange, []any{v2, v3, int64(1)}) + tmp4 = tmp6 + } else { + tmp7 := lang.Apply(lang.NewRange, []any{v2, v3, int64(1)}) + tmp4 = tmp7 + } + return tmp4 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + var tmp6 any + { // let + // let binding "and__0__auto__" + tmp7 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v2}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + var tmp11 any + { // let + // let binding "and__0__auto__" + tmp12 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) + tmp13 := lang.Apply(tmp12, []any{v3}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + tmp16 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) + tmp17 := lang.Apply(tmp16, []any{v4}) + tmp15 = tmp17 + } else { + tmp15 = v14 + } + tmp11 = tmp15 + } // end let + tmp10 = tmp11 + } else { + tmp10 = v9 + } + tmp6 = tmp10 + } // end let + if lang.IsTruthy(tmp6) { + tmp7 := lang.Apply(lang.NewLongRange, []any{v2, v3, v4}) + tmp5 = tmp7 + } else { + tmp8 := lang.Apply(lang.NewRange, []any{v2, v3, v4}) + tmp5 = tmp8 + } + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_range = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_range.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // rational? + { + tmp0 := sym_rational_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_doc, "Returns true if n is a rational number", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(3613), kw_end_DASH_line, int(3613))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "or__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_integer_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + tmp7 = v6 + } else { + var tmp8 any + { // let + // let binding "or__0__auto__" + tmp9 := checkDerefVar(var_glojure_DOT_core_ratio_QMARK_) + tmp10 := lang.Apply(tmp9, []any{v2}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + tmp12 = v11 + } else { + tmp13 := checkDerefVar(var_glojure_DOT_core_decimal_QMARK_) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp12 = tmp14 + } + tmp8 = tmp12 + } // end let + tmp7 = tmp8 + } + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_rational_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_rational_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reduce1 + { + tmp0 := sym_reduce1.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(923), kw_column, int(7), kw_end_DASH_line, int(924), kw_end_DASH_column, int(9), kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_coll), lang.NewVector(sym_f, sym_val, sym_coll)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "s" + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := lang.Apply(tmp5, []any{v3}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + if lang.IsTruthy(v7) { + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v7}) + tmp12 := checkDerefVar(var_glojure_DOT_core_next) + tmp13 := lang.Apply(tmp12, []any{v7}) + tmp14 := lang.Apply(tmp9, []any{v2, tmp11, tmp13}) + tmp8 = tmp14 + } else { + tmp15 := lang.Apply(v2, nil) + tmp8 = tmp15 + } + tmp4 = tmp8 + } // end let + return tmp4 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + recur_loop_1696: + var tmp5 any + { // let + // let binding "s" + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := lang.Apply(tmp6, []any{v4}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + var tmp10 any + tmp11 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp12 := lang.Apply(tmp11, []any{v8}) + if lang.IsTruthy(tmp12) { + var tmp13 any = v2 + tmp15 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp16 := lang.Apply(tmp15, []any{v8}) + tmp17, _ := lang.FieldOrMethod(tmp16, "ReduceInit") + if reflect.TypeOf(tmp17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) + } + tmp18 := lang.Apply(tmp17, []any{v2, v3}) + var tmp14 any = tmp18 + tmp20 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_next) + tmp21 := lang.Apply(tmp20, []any{v8}) + var tmp19 any = tmp21 + v2 = tmp13 + v3 = tmp14 + v4 = tmp19 + goto recur_loop_1696 + } else { + var tmp22 any = v2 + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v8}) + tmp26 := lang.Apply(v2, []any{v3, tmp25}) + var tmp23 any = tmp26 + tmp28 := checkDerefVar(var_glojure_DOT_core_next) + tmp29 := lang.Apply(tmp28, []any{v8}) + var tmp27 any = tmp29 + v2 = tmp22 + v3 = tmp23 + v4 = tmp27 + goto recur_loop_1696 + } + tmp9 = tmp10 + } else { + tmp9 = v3 + } + tmp5 = tmp9 + } // end let + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_reduce1 = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_reduce1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reduced? + { + var tmp1 lang.FnFunc + { // function reduced?__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_IsReduced}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{v3}) + tmp10 := lang.Apply(tmp5, []any{tmp7, tmp9}) + tmp11 := lang.Apply(tmp4, []any{tmp10}) + return tmp11 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_reduced_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns true if x is the result of a call to reduced", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1)})), kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(2834), kw_end_DASH_line, int(2834))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.IsReduced, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_reduced_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_reduced_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reductions + { + tmp0 := sym_reductions.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_coll), lang.NewVector(sym_f, sym_init, sym_coll)), kw_doc, "Returns a lazy seq of the intermediate values of the reduction (as\n per reduce) of coll by f, starting with init.", kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(7196), kw_end_DASH_line, int(7196))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp5 any + { // let + // let binding "temp__0__auto__" + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := lang.Apply(tmp6, []any{v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + var tmp10 any + { // let + // let binding "s" + var v11 any = v8 + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_reductions) + tmp13 := checkDerefVar(var_glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v11}) + tmp15 := checkDerefVar(var_glojure_DOT_core_rest) + tmp16 := lang.Apply(tmp15, []any{v11}) + tmp17 := lang.Apply(tmp12, []any{v2, tmp14, tmp16}) + tmp10 = tmp17 + } // end let + tmp9 = tmp10 + } else { + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(v2, nil) + tmp13 := lang.Apply(tmp11, []any{tmp12}) + tmp9 = tmp13 + } + tmp5 = tmp9 + } // end let + return tmp5 + }) + tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) + return tmp5 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) + tmp7 := lang.Apply(tmp6, []any{v3}) + if lang.IsTruthy(tmp7) { + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := checkDerefVar(var_glojure_DOT_core_deref) + tmp10 := lang.Apply(tmp9, []any{v3}) + tmp11 := lang.Apply(tmp8, []any{tmp10}) + tmp5 = tmp11 + } else { + tmp12 := checkDerefVar(var_glojure_DOT_core_cons) + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp14 any + { // let + // let binding "temp__0__auto__" + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := lang.Apply(tmp15, []any{v4}) + var v17 any = tmp16 + _ = v17 + var tmp18 any + if lang.IsTruthy(v17) { + var tmp19 any + { // let + // let binding "s" + var v20 any = v17 + _ = v20 + tmp21 := checkDerefVar(var_glojure_DOT_core_reductions) + tmp22 := checkDerefVar(var_glojure_DOT_core_first) + tmp23 := lang.Apply(tmp22, []any{v20}) + tmp24 := lang.Apply(v2, []any{v3, tmp23}) + tmp25 := checkDerefVar(var_glojure_DOT_core_rest) + tmp26 := lang.Apply(tmp25, []any{v20}) + tmp27 := lang.Apply(tmp21, []any{v2, tmp24, tmp26}) + tmp19 = tmp27 + } // end let + tmp18 = tmp19 + } else { + } + tmp14 = tmp18 + } // end let + return tmp14 + }) + tmp14 := lang.Apply(lang.NewLazySeq, []any{tmp13}) + tmp15 := lang.Apply(tmp12, []any{v3, tmp14}) + tmp5 = tmp15 + } + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_reductions = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_reductions.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // refer-glojure + { + tmp0 := sym_refer_DASH_glojure.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_filters)), kw_doc, "Same as (refer 'glojure.core )", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(11), kw_line, int(5800), kw_end_DASH_line, int(5800))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym_glojure_DOT_core_SLASH_refer}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := checkDerefVar(var_glojure_DOT_core_seq) + tmp11 := checkDerefVar(var_glojure_DOT_core_concat) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_quote}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core}) + tmp16 := lang.Apply(tmp11, []any{tmp13, tmp15}) + tmp17 := lang.Apply(tmp10, []any{tmp16}) + tmp18 := lang.Apply(tmp9, []any{tmp17}) + tmp19 := lang.Apply(tmp6, []any{tmp8, tmp18, v4}) + tmp20 := lang.Apply(tmp5, []any{tmp19}) + return tmp20 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_refer_DASH_glojure = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_refer_DASH_glojure.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // rem + { + var tmp1 lang.FnFunc + { // function rem__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Remainder}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_rem.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_num, sym_div)), kw_inline, tmp1, kw_doc, "remainder of dividing numerator by denominator.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(1274), kw_end_DASH_line, int(1274))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Remainder") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Remainder is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_rem = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_rem.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // remove-tap + { + tmp0 := sym_remove_DASH_tap.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f)), kw_doc, "Remove f from the tap set.", kw_file, "glojure/core.glj", kw_added, "1.10", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(7883), kw_end_DASH_line, int(7883))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_swap_BANG_) + tmp4 := checkDerefVar(var_glojure_DOT_core_tapset) + tmp5 := checkDerefVar(var_glojure_DOT_core_disj) + tmp6 := lang.Apply(tmp3, []any{tmp4, tmp5, v2}) + _ = tmp6 + return nil + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_remove_DASH_tap = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_remove_DASH_tap.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // resolve + { + tmp0 := sym_resolve.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_sym), lang.NewVector(sym_env, sym_sym)), kw_doc, "same as (ns-resolve *ns* symbol) or (ns-resolve *ns* &env symbol)", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4371), kw_end_DASH_line, int(4371))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_ns_DASH_resolve) + tmp4 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_ns_DASH_resolve) + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp6 := lang.Apply(tmp4, []any{tmp5, v2, v3}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_resolve = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_resolve.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reverse + { + tmp0 := sym_reverse.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a seq of the items in coll in reverse order. Not lazy.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(940), kw_end_DASH_line, int(940))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp4 := checkDerefVar(var_glojure_DOT_core_conj) + tmp5 := lang.Apply(tmp3, []any{tmp4, lang.NewList(), v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_reverse = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_reverse.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // root-resource + { + tmp1 := reflect.TypeOf("") + tmp0 := sym_root_DASH_resource.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_lib)), kw_doc, "Returns the root directory path for a lib", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(8), kw_line, int(5864), kw_end_DASH_line, int(5864), kw_private, true)).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_str) + tmp5 := checkDerefVar(var_glojure_DOT_core_name) + tmp6 := lang.Apply(tmp5, []any{v3}) + tmp7 := lang.Apply(strings8.ReplaceAll, []any{tmp6, "-", "_"}) + tmp8 := lang.Apply(strings8.ReplaceAll, []any{tmp7, ".", "/"}) + tmp9 := lang.Apply(tmp4, []any{lang.NewChar(47), tmp8}) + return tmp9 + }) + tmp3 := reflect.TypeOf("") + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_root_DASH_resource = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_root_DASH_resource.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // select-keys + { + tmp0 := sym_select_DASH_keys.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_map, sym_keyseq)), kw_doc, "Returns a map containing only those entries in map whose key is in keys", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(1536), kw_end_DASH_line, int(1536))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "ret" + tmp5 := lang.NewMap() + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(1541), kw_column, int(16), kw_end_DASH_line, int(1541), kw_end_DASH_column, int(17)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v8 any = tmp7 + _ = v8 + // let binding "keys" + tmp9 := checkDerefVar(var_glojure_DOT_core_seq) + tmp10 := lang.Apply(tmp9, []any{v3}) + var v11 any = tmp10 + _ = v11 + for { + var tmp12 any + if lang.IsTruthy(v11) { + var tmp13 any + { // let + // let binding "entry" + tmp14 := checkDerefVar(var_glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v11}) + tmp16, _ := lang.FieldOrMethod(runtime.RT, "Find") + if reflect.TypeOf(tmp16).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Find is not a function"))) + } + tmp17 := lang.Apply(tmp16, []any{v2, tmp15}) + var v18 any = tmp17 + _ = v18 + var tmp20 any + if lang.IsTruthy(v18) { + tmp21 := checkDerefVar(var_glojure_DOT_core_conj) + tmp22 := lang.Apply(tmp21, []any{v8, v18}) + tmp20 = tmp22 + } else { + tmp20 = v8 + } + var tmp19 any = tmp20 + tmp24 := checkDerefVar(var_glojure_DOT_core_next) + tmp25 := lang.Apply(tmp24, []any{v11}) + var tmp23 any = tmp25 + v8 = tmp19 + v11 = tmp23 + continue + } // end let + tmp12 = tmp13 + } else { + tmp14 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp15 := checkDerefVar(var_glojure_DOT_core_meta) + tmp16 := lang.Apply(tmp15, []any{v2}) + tmp17 := lang.Apply(tmp14, []any{v8, tmp16}) + tmp12 = tmp17 + } + tmp4 = tmp12 + break + } + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_select_DASH_keys = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_select_DASH_keys.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // seq-to-map-for-destructuring + { + tmp0 := sym_seq_DASH_to_DASH_map_DASH_for_DASH_destructuring.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_doc, "Builds a map from a seq as described in\n https://glojure.org/reference/special_forms#keyword-arguments", kw_file, "glojure/core.glj", kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(34), kw_column, int(7), kw_line, int(4390), kw_end_DASH_line, int(4390))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_next) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + tmp6 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) + tmp7 := lang.Apply(tmp6, []any{v2}) + tmp8 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{tmp7}) + tmp3 = tmp8 + } else { + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_seq) + tmp11 := lang.Apply(tmp10, []any{v2}) + if lang.IsTruthy(tmp11) { + tmp12 := checkDerefVar(var_glojure_DOT_core_first) + tmp13 := lang.Apply(tmp12, []any{v2}) + tmp9 = tmp13 + } else { + } + tmp3 = tmp9 + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_seq_DASH_to_DASH_map_DASH_for_DASH_destructuring = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_seq_DASH_to_DASH_map_DASH_for_DASH_destructuring.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // set + { + tmp0 := sym_set.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a set of the distinct elements of coll.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(4104), kw_end_DASH_line, int(4104))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_set_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + tmp6 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp7 := lang.Apply(tmp6, []any{v2, nil}) + tmp3 = tmp7 + } else { + var tmp8 any + tmp9 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp10 := reflect.TypeOf((*lang.IReduceInit)(nil)).Elem() + tmp11 := lang.Apply(tmp9, []any{tmp10, v2}) + if lang.IsTruthy(tmp11) { + tmp12 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp13 := checkDerefVar(var_glojure_DOT_core_conj_BANG_) + tmp14 := checkDerefVar(var_glojure_DOT_core_transient) + tmp15 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4112), kw_column, int(108), kw_end_DASH_line, int(4112), kw_end_DASH_column, int(110)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp18 := lang.Apply(tmp14, []any{tmp17}) + tmp19, _ := lang.FieldOrMethod(v2, "ReduceInit") + if reflect.TypeOf(tmp19).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) + } + tmp20 := lang.Apply(tmp19, []any{tmp13, tmp18}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp8 = tmp21 + } else { + tmp22 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp23 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp24 := checkDerefVar(var_glojure_DOT_core_conj_BANG_) + tmp25 := checkDerefVar(var_glojure_DOT_core_transient) + tmp26 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp27 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4113), kw_column, int(46), kw_end_DASH_line, int(4113), kw_end_DASH_column, int(48)) + tmp28, err := lang.WithMeta(tmp26, tmp27.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp29 := lang.Apply(tmp25, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp24, tmp29, v2}) + tmp31 := lang.Apply(tmp22, []any{tmp30}) + tmp8 = tmp31 + } + tmp3 = tmp8 + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_set = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_set.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // short + { + var tmp1 lang.FnFunc + { // function short__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp15) { + tmp14 = sym_uncheckedShortCast + } else { + tmp14 = sym_shortCast + } + tmp16 := lang.Apply(tmp13, []any{tmp14}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := lang.Apply(tmp12, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp11, []any{tmp19}) + tmp21 := lang.Apply(tmp10, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_short.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to short", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3499), kw_end_DASH_line, int(3499))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.ShortCast, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_short = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_short.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // short-array + { + var tmp1 lang.FnFunc + { // function short-array__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_ShortArray}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_unquote_DASH_splicing}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_glojure_DOT_core_SLASH_args}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + } + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_short_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_size_DASH_or_DASH_seq), lang.NewVector(sym_size, sym_init_DASH_val_DASH_or_DASH_seq)), kw_inline, tmp1, kw_doc, "Creates an array of shorts", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(5333), kw_end_DASH_line, int(5333))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "ShortArray") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ShortArray is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "ShortArrayInit") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ShortArrayInit is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_short_DASH_array = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_short_DASH_array.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // shorts + { + var tmp1 lang.FnFunc + { // function shorts + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Shorts}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_shorts.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xs)), kw_inline, tmp1, kw_doc, "Casts to shorts[]", kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(12), kw_line, int(5387), kw_end_DASH_line, int(5387))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Shorts") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Shorts is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_shorts = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_shorts.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // shuffle + { + tmp0 := sym_shuffle.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Return a random permutation of coll", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(7300), kw_end_DASH_line, int(7300))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "al" + tmp4 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) + tmp5 := lang.Apply(tmp4, []any{v2}) + tmp6 := lang.Apply(lang.NewArrayList, []any{tmp5}) + var v7 any = tmp6 + _ = v7 + tmp8 := lang.Apply(nil, []any{v7}) + _ = tmp8 + tmp9, ok := lang.FieldOrMethod(v7, "toArray") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "toArray"))) + } + var tmp10 any + switch reflect.TypeOf(tmp9).Kind() { + case reflect.Func: + tmp10 = lang.Apply(tmp9, nil) + default: + tmp10 = tmp9 + } + tmp11 := lang.Apply(nil, []any{tmp10}) + tmp3 = tmp11 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_shuffle = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_shuffle.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // sigs + { + tmp0 := sym_sigs.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(223), kw_column, int(2), kw_end_DASH_line, int(224), kw_end_DASH_column, int(5), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_assert_DASH_valid_DASH_fdecl) + tmp4 := lang.Apply(tmp3, []any{v2}) + _ = tmp4 + var tmp5 any + { // let + // let binding "asig" + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v7 := args[0] + _ = v7 + var tmp8 any + { // let + // let binding "arglist" + tmp9 := checkDerefVar(var_glojure_DOT_core_first) + tmp10 := lang.Apply(tmp9, []any{v7}) + var v11 any = tmp10 + _ = v11 + // let binding "arglist" + var tmp12 any + tmp13 := checkDerefVar(var_glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v11}) + tmp15 := lang.Apply(lang.Equals, []any{sym__AMP_form, tmp14}) + if lang.IsTruthy(tmp15) { + tmp16 := lang.Apply(lang.Count, []any{v11}) + tmp17 := lang.Apply(lang.Subvec, []any{v11, int64(2), tmp16}) + tmp12 = tmp17 + } else { + tmp12 = v11 + } + var v18 any = tmp12 + _ = v18 + // let binding "body" + tmp19 := checkDerefVar(var_glojure_DOT_core_next) + tmp20 := lang.Apply(tmp19, []any{v7}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + tmp23 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v21}) + tmp26 := lang.Apply(tmp23, []any{tmp25}) + if lang.IsTruthy(tmp26) { + var tmp27 any + tmp28 := checkDerefVar(var_glojure_DOT_core_next) + tmp29 := lang.Apply(tmp28, []any{v21}) + if lang.IsTruthy(tmp29) { + tmp30 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp31 := checkDerefVar(var_glojure_DOT_core_conj) + var tmp32 any + tmp33 := checkDerefVar(var_glojure_DOT_core_meta) + tmp34 := lang.Apply(tmp33, []any{v18}) + if lang.IsTruthy(tmp34) { + tmp35 := checkDerefVar(var_glojure_DOT_core_meta) + tmp36 := lang.Apply(tmp35, []any{v18}) + tmp32 = tmp36 + } else { + tmp37 := lang.NewMap() + tmp38 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(237), kw_column, int(77), kw_end_DASH_line, int(237), kw_end_DASH_column, int(78)) + tmp39, err := lang.WithMeta(tmp37, tmp38.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp32 = tmp39 + } + tmp40 := checkDerefVar(var_glojure_DOT_core_first) + tmp41 := lang.Apply(tmp40, []any{v21}) + tmp42 := lang.Apply(tmp31, []any{tmp32, tmp41}) + tmp43 := lang.Apply(tmp30, []any{v18, tmp42}) + tmp27 = tmp43 + } else { + tmp27 = v18 + } + tmp22 = tmp27 + } else { + tmp22 = v18 + } + tmp8 = tmp22 + } // end let + return tmp8 + }) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(228), kw_column, int(10), kw_end_DASH_line, int(239), kw_end_DASH_column, int(25)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v9 any = tmp8 + _ = v9 + // let binding "resolve-tag" + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v11 := args[0] + _ = v11 + var tmp12 any + { // let + // let binding "m" + tmp13 := checkDerefVar(var_glojure_DOT_core_meta) + tmp14 := lang.Apply(tmp13, []any{v11}) + var v15 any = tmp14 + _ = v15 + // let binding "tag" + tmp16 := lang.Apply(kw_tag, []any{v15}) + var v17 any = tmp16 + _ = v17 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp20 := reflect.TypeOf((*lang.Symbol)(nil)) + tmp21 := lang.Apply(tmp19, []any{tmp20, v17}) + if lang.IsTruthy(tmp21) { + var tmp22 any + tmp23, ok := lang.FieldOrMethod(v17, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v17, "Name"))) + } + var tmp24 any + switch reflect.TypeOf(tmp23).Kind() { + case reflect.Func: + tmp24 = lang.Apply(tmp23, nil) + default: + tmp24 = tmp23 + } + tmp25 := lang.Apply(strings8.Index, []any{tmp24, "."}) + tmp26 := lang.Apply(lang.Equiv, []any{tmp25, int64(-1)}) + if lang.IsTruthy(tmp26) { + var tmp27 any + tmp28 := lang.Apply(lang.Equals, []any{nil, nil}) + if lang.IsTruthy(tmp28) { + var tmp29 any + { // let + // let binding "c" + var v30 any = nil + _ = v30 + var tmp31 any + if lang.IsTruthy(v30) { + tmp32 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp33 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp34, ok := lang.FieldOrMethod(v30, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v30, "Name"))) + } + var tmp35 any + switch reflect.TypeOf(tmp34).Kind() { + case reflect.Func: + tmp35 = lang.Apply(tmp34, nil) + default: + tmp35 = tmp34 + } + tmp36 := lang.Apply(lang.NewSymbol, []any{tmp35}) + tmp37 := lang.Apply(tmp33, []any{v15, kw_tag, tmp36}) + tmp38 := lang.Apply(tmp32, []any{v11, tmp37}) + tmp31 = tmp38 + } else { + tmp31 = v11 + } + tmp29 = tmp31 + } // end let + tmp27 = tmp29 + } else { + tmp27 = v11 + } + tmp22 = tmp27 + } else { + tmp22 = v11 + } + tmp18 = tmp22 + } else { + tmp18 = v11 + } + tmp12 = tmp18 + } // end let + return tmp12 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(240), kw_column, int(22), kw_end_DASH_line, int(252), kw_end_DASH_column, int(37)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v13 any = tmp12 + _ = v13 + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp16 := checkDerefVar(var_glojure_DOT_core_first) + tmp17 := lang.Apply(tmp16, []any{v2}) + tmp18 := lang.Apply(tmp15, []any{tmp17}) + if lang.IsTruthy(tmp18) { + var tmp19 any + { // let + // let binding "ret" + tmp20 := lang.NewVector() + tmp21 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(254), kw_column, int(19), kw_end_DASH_line, int(254), kw_end_DASH_column, int(20)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v23 any = tmp22 + _ = v23 + // let binding "fdecls" + var v24 any = v2 + _ = v24 + for { + var tmp25 any + if lang.IsTruthy(v24) { + tmp27 := checkDerefVar(var_glojure_DOT_core_conj) + tmp28 := checkDerefVar(var_glojure_DOT_core_first) + tmp29 := lang.Apply(tmp28, []any{v24}) + tmp30 := lang.Apply(v9, []any{tmp29}) + tmp31 := lang.Apply(v13, []any{tmp30}) + tmp32 := lang.Apply(tmp27, []any{v23, tmp31}) + var tmp26 any = tmp32 + tmp34 := checkDerefVar(var_glojure_DOT_core_next) + tmp35 := lang.Apply(tmp34, []any{v24}) + var tmp33 any = tmp35 + v23 = tmp26 + v24 = tmp33 + continue + } else { + tmp36 := checkDerefVar(var_glojure_DOT_core_seq) + tmp37 := lang.Apply(tmp36, []any{v23}) + tmp25 = tmp37 + } + tmp19 = tmp25 + break + } + } // end let + tmp14 = tmp19 + } else { + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(v9, []any{v2}) + tmp22 := lang.Apply(v13, []any{tmp21}) + tmp23 := lang.Apply(tmp20, []any{tmp22}) + tmp14 = tmp23 + } + tmp5 = tmp14 + } // end let + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(225), kw_column, int(2), kw_end_DASH_line, int(258), kw_end_DASH_column, int(43))).(lang.FnFunc) + var_glojure_DOT_core_sigs = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_sigs.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // simple-ident? + { + tmp0 := sym_simple_DASH_ident_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a symbol or keyword without a namespace", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(1613), kw_end_DASH_line, int(1613))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "and__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_ident_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + tmp8 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp9 := checkDerefVar(var_glojure_DOT_core_namespace) + tmp10 := lang.Apply(tmp9, []any{v2}) + tmp11 := lang.Apply(tmp8, []any{tmp10}) + tmp7 = tmp11 + } else { + tmp7 = v6 + } + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_simple_DASH_ident_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_simple_DASH_ident_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // simple-symbol? + { + tmp0 := sym_simple_DASH_symbol_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a symbol without a namespace", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(1623), kw_end_DASH_line, int(1623))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "and__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + tmp8 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp9 := checkDerefVar(var_glojure_DOT_core_namespace) + tmp10 := lang.Apply(tmp9, []any{v2}) + tmp11 := lang.Apply(tmp8, []any{tmp10}) + tmp7 = tmp11 + } else { + tmp7 = v6 + } + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_simple_DASH_symbol_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_simple_DASH_symbol_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // some-fn + { + tmp0 := sym_some_DASH_fn.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_p), lang.NewVector(sym_p1, sym_p2), lang.NewVector(sym_p1, sym_p2, sym_p3), lang.NewVector(sym_p1, sym_p2, sym_p3, sym__AMP_, sym_ps)), kw_doc, "Takes a set of predicates and returns a function f that returns the first logical true value\n returned by one of its composing predicates against any of its arguments, else it returns\n logical false. Note that f is short-circuiting in that it will stop execution on the first\n argument that triggers a logical true result against the original predicates.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(7462), kw_end_DASH_line, int(7462))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + { // function sp1 + var v4 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return nil + case 1: + v5 := args[0] + _ = v5 + tmp6 := lang.Apply(v2, []any{v5}) + return tmp6 + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + var tmp7 any + { // let + // let binding "or__0__auto__" + tmp8 := lang.Apply(v2, []any{v5}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + tmp10 = v9 + } else { + tmp11 := lang.Apply(v2, []any{v6}) + tmp10 = tmp11 + } + tmp7 = tmp10 + } // end let + return tmp7 + case 3: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := args[2] + _ = v7 + var tmp8 any + { // let + // let binding "or__0__auto__" + tmp9 := lang.Apply(v2, []any{v5}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + if lang.IsTruthy(v10) { + tmp11 = v10 + } else { + var tmp12 any + { // let + // let binding "or__0__auto__" + tmp13 := lang.Apply(v2, []any{v6}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + tmp15 = v14 + } else { + tmp16 := lang.Apply(v2, []any{v7}) + tmp15 = tmp16 + } + tmp12 = tmp15 + } // end let + tmp11 = tmp12 + } + tmp8 = tmp11 + } // end let + return tmp8 + default: + checkArity(args, 3) + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := args[2] + _ = v7 + var v8 any = lang.NewList(args[3:]...) + _ = v8 + var tmp9 any + { // let + // let binding "or__0__auto__" + tmp10 := lang.Apply(v4, []any{v5, v6, v7}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + tmp12 = v11 + } else { + tmp13 := checkDerefVar(var_glojure_DOT_core_some) + tmp14 := lang.Apply(tmp13, []any{v2, v8}) + tmp12 = tmp14 + } + tmp9 = tmp12 + } // end let + return tmp9 + } + }) + v4 = tmp3 + _ = v4 + } + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7469), kw_column, int(6), kw_end_DASH_line, int(7475), kw_end_DASH_column, int(43)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + { // function sp2 + var v5 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return nil + case 1: + v6 := args[0] + _ = v6 + var tmp7 any + { // let + // let binding "or__0__auto__" + tmp8 := lang.Apply(v2, []any{v6}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + tmp10 = v9 + } else { + tmp11 := lang.Apply(v3, []any{v6}) + tmp10 = tmp11 + } + tmp7 = tmp10 + } // end let + return tmp7 + case 2: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + var tmp8 any + { // let + // let binding "or__0__auto__" + tmp9 := lang.Apply(v2, []any{v6}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + if lang.IsTruthy(v10) { + tmp11 = v10 + } else { + var tmp12 any + { // let + // let binding "or__0__auto__" + tmp13 := lang.Apply(v2, []any{v7}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + tmp15 = v14 + } else { + var tmp16 any + { // let + // let binding "or__0__auto__" + tmp17 := lang.Apply(v3, []any{v6}) + var v18 any = tmp17 + _ = v18 + var tmp19 any + if lang.IsTruthy(v18) { + tmp19 = v18 + } else { + tmp20 := lang.Apply(v3, []any{v7}) + tmp19 = tmp20 + } + tmp16 = tmp19 + } // end let + tmp15 = tmp16 + } + tmp12 = tmp15 + } // end let + tmp11 = tmp12 + } + tmp8 = tmp11 + } // end let + return tmp8 + case 3: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + var tmp9 any + { // let + // let binding "or__0__auto__" + tmp10 := lang.Apply(v2, []any{v6}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + tmp12 = v11 + } else { + var tmp13 any + { // let + // let binding "or__0__auto__" + tmp14 := lang.Apply(v2, []any{v7}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + if lang.IsTruthy(v15) { + tmp16 = v15 + } else { + var tmp17 any + { // let + // let binding "or__0__auto__" + tmp18 := lang.Apply(v2, []any{v8}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + tmp20 = v19 + } else { + var tmp21 any + { // let + // let binding "or__0__auto__" + tmp22 := lang.Apply(v3, []any{v6}) + var v23 any = tmp22 + _ = v23 + var tmp24 any + if lang.IsTruthy(v23) { + tmp24 = v23 + } else { + var tmp25 any + { // let + // let binding "or__0__auto__" + tmp26 := lang.Apply(v3, []any{v7}) + var v27 any = tmp26 + _ = v27 + var tmp28 any + if lang.IsTruthy(v27) { + tmp28 = v27 + } else { + tmp29 := lang.Apply(v3, []any{v8}) + tmp28 = tmp29 + } + tmp25 = tmp28 + } // end let + tmp24 = tmp25 + } + tmp21 = tmp24 + } // end let + tmp20 = tmp21 + } + tmp17 = tmp20 + } // end let + tmp16 = tmp17 + } + tmp13 = tmp16 + } // end let + tmp12 = tmp13 + } + tmp9 = tmp12 + } // end let + return tmp9 + default: + checkArity(args, 3) + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + var v9 any = lang.NewList(args[3:]...) + _ = v9 + var tmp10 any + { // let + // let binding "or__0__auto__" + tmp11 := lang.Apply(v5, []any{v6, v7, v8}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + tmp13 = v12 + } else { + tmp14 := checkDerefVar(var_glojure_DOT_core_some) + var tmp15 lang.FnFunc + tmp15 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v16 := args[0] + _ = v16 + var tmp17 any + { // let + // let binding "or__0__auto__" + tmp18 := lang.Apply(v2, []any{v16}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + tmp20 = v19 + } else { + tmp21 := lang.Apply(v3, []any{v16}) + tmp20 = tmp21 + } + tmp17 = tmp20 + } // end let + return tmp17 + }) + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7483), kw_column, int(34), kw_end_DASH_line, int(7483), kw_end_DASH_column, int(52)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp18 := lang.Apply(tmp14, []any{tmp17, v9}) + tmp13 = tmp18 + } + tmp10 = tmp13 + } // end let + return tmp10 + } + }) + v5 = tmp4 + _ = v5 + } + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7477), kw_column, int(6), kw_end_DASH_line, int(7483), kw_end_DASH_column, int(61)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 lang.FnFunc + { // function sp3 + var v6 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return nil + case 1: + v7 := args[0] + _ = v7 + var tmp8 any + { // let + // let binding "or__0__auto__" + tmp9 := lang.Apply(v2, []any{v7}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + if lang.IsTruthy(v10) { + tmp11 = v10 + } else { + var tmp12 any + { // let + // let binding "or__0__auto__" + tmp13 := lang.Apply(v3, []any{v7}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + tmp15 = v14 + } else { + tmp16 := lang.Apply(v4, []any{v7}) + tmp15 = tmp16 + } + tmp12 = tmp15 + } // end let + tmp11 = tmp12 + } + tmp8 = tmp11 + } // end let + return tmp8 + case 2: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + var tmp9 any + { // let + // let binding "or__0__auto__" + tmp10 := lang.Apply(v2, []any{v7}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + tmp12 = v11 + } else { + var tmp13 any + { // let + // let binding "or__0__auto__" + tmp14 := lang.Apply(v2, []any{v8}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + if lang.IsTruthy(v15) { + tmp16 = v15 + } else { + var tmp17 any + { // let + // let binding "or__0__auto__" + tmp18 := lang.Apply(v3, []any{v7}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + tmp20 = v19 + } else { + var tmp21 any + { // let + // let binding "or__0__auto__" + tmp22 := lang.Apply(v3, []any{v8}) + var v23 any = tmp22 + _ = v23 + var tmp24 any + if lang.IsTruthy(v23) { + tmp24 = v23 + } else { + var tmp25 any + { // let + // let binding "or__0__auto__" + tmp26 := lang.Apply(v4, []any{v7}) + var v27 any = tmp26 + _ = v27 + var tmp28 any + if lang.IsTruthy(v27) { + tmp28 = v27 + } else { + tmp29 := lang.Apply(v4, []any{v8}) + tmp28 = tmp29 + } + tmp25 = tmp28 + } // end let + tmp24 = tmp25 + } + tmp21 = tmp24 + } // end let + tmp20 = tmp21 + } + tmp17 = tmp20 + } // end let + tmp16 = tmp17 + } + tmp13 = tmp16 + } // end let + tmp12 = tmp13 + } + tmp9 = tmp12 + } // end let + return tmp9 + case 3: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + var tmp10 any + { // let + // let binding "or__0__auto__" + tmp11 := lang.Apply(v2, []any{v7}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + tmp13 = v12 + } else { + var tmp14 any + { // let + // let binding "or__0__auto__" + tmp15 := lang.Apply(v2, []any{v8}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + if lang.IsTruthy(v16) { + tmp17 = v16 + } else { + var tmp18 any + { // let + // let binding "or__0__auto__" + tmp19 := lang.Apply(v2, []any{v9}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + tmp21 = v20 + } else { + var tmp22 any + { // let + // let binding "or__0__auto__" + tmp23 := lang.Apply(v3, []any{v7}) + var v24 any = tmp23 + _ = v24 + var tmp25 any + if lang.IsTruthy(v24) { + tmp25 = v24 + } else { + var tmp26 any + { // let + // let binding "or__0__auto__" + tmp27 := lang.Apply(v3, []any{v8}) + var v28 any = tmp27 + _ = v28 + var tmp29 any + if lang.IsTruthy(v28) { + tmp29 = v28 + } else { + var tmp30 any + { // let + // let binding "or__0__auto__" + tmp31 := lang.Apply(v3, []any{v9}) + var v32 any = tmp31 + _ = v32 + var tmp33 any + if lang.IsTruthy(v32) { + tmp33 = v32 + } else { + var tmp34 any + { // let + // let binding "or__0__auto__" + tmp35 := lang.Apply(v4, []any{v7}) + var v36 any = tmp35 + _ = v36 + var tmp37 any + if lang.IsTruthy(v36) { + tmp37 = v36 + } else { + var tmp38 any + { // let + // let binding "or__0__auto__" + tmp39 := lang.Apply(v4, []any{v8}) + var v40 any = tmp39 + _ = v40 + var tmp41 any + if lang.IsTruthy(v40) { + tmp41 = v40 + } else { + tmp42 := lang.Apply(v4, []any{v9}) + tmp41 = tmp42 + } + tmp38 = tmp41 + } // end let + tmp37 = tmp38 + } + tmp34 = tmp37 + } // end let + tmp33 = tmp34 + } + tmp30 = tmp33 + } // end let + tmp29 = tmp30 + } + tmp26 = tmp29 + } // end let + tmp25 = tmp26 + } + tmp22 = tmp25 + } // end let + tmp21 = tmp22 + } + tmp18 = tmp21 + } // end let + tmp17 = tmp18 + } + tmp14 = tmp17 + } // end let + tmp13 = tmp14 + } + tmp10 = tmp13 + } // end let + return tmp10 + default: + checkArity(args, 3) + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + var v10 any = lang.NewList(args[3:]...) + _ = v10 + var tmp11 any + { // let + // let binding "or__0__auto__" + tmp12 := lang.Apply(v6, []any{v7, v8, v9}) + var v13 any = tmp12 + _ = v13 + var tmp14 any + if lang.IsTruthy(v13) { + tmp14 = v13 + } else { + tmp15 := checkDerefVar(var_glojure_DOT_core_some) + var tmp16 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v17 := args[0] + _ = v17 + var tmp18 any + { // let + // let binding "or__0__auto__" + tmp19 := lang.Apply(v2, []any{v17}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + tmp21 = v20 + } else { + var tmp22 any + { // let + // let binding "or__0__auto__" + tmp23 := lang.Apply(v3, []any{v17}) + var v24 any = tmp23 + _ = v24 + var tmp25 any + if lang.IsTruthy(v24) { + tmp25 = v24 + } else { + tmp26 := lang.Apply(v4, []any{v17}) + tmp25 = tmp26 + } + tmp22 = tmp25 + } // end let + tmp21 = tmp22 + } + tmp18 = tmp21 + } // end let + return tmp18 + }) + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7491), kw_column, int(34), kw_end_DASH_line, int(7491), kw_end_DASH_column, int(59)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp19 := lang.Apply(tmp15, []any{tmp18, v10}) + tmp14 = tmp19 + } + tmp11 = tmp14 + } // end let + return tmp11 + } + }) + v6 = tmp5 + _ = v6 + } + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7485), kw_column, int(6), kw_end_DASH_line, int(7491), kw_end_DASH_column, int(68)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp7 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "ps" + tmp7 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp8 := lang.Apply(tmp7, []any{v2, v3, v4, v5}) + var v9 any = tmp8 + _ = v9 + var tmp10 lang.FnFunc + { // function spn + var v11 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return nil + case 1: + v12 := args[0] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_some) + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v15 := args[0] + _ = v15 + tmp16 := lang.Apply(v15, []any{v12}) + return tmp16 + }) + tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7496), kw_column, int(21), kw_end_DASH_line, int(7496), kw_end_DASH_column, int(26)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp17 := lang.Apply(tmp13, []any{tmp16, v9}) + return tmp17 + case 2: + v12 := args[0] + _ = v12 + v13 := args[1] + _ = v13 + tmp14 := checkDerefVar(var_glojure_DOT_core_some) + var tmp15 lang.FnFunc + tmp15 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v16 := args[0] + _ = v16 + var tmp17 any + { // let + // let binding "or__0__auto__" + tmp18 := lang.Apply(v16, []any{v12}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + tmp20 = v19 + } else { + tmp21 := lang.Apply(v16, []any{v13}) + tmp20 = tmp21 + } + tmp17 = tmp20 + } // end let + return tmp17 + }) + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7497), kw_column, int(23), kw_end_DASH_line, int(7497), kw_end_DASH_column, int(39)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp18 := lang.Apply(tmp14, []any{tmp17, v9}) + return tmp18 + case 3: + v12 := args[0] + _ = v12 + v13 := args[1] + _ = v13 + v14 := args[2] + _ = v14 + tmp15 := checkDerefVar(var_glojure_DOT_core_some) + var tmp16 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v17 := args[0] + _ = v17 + var tmp18 any + { // let + // let binding "or__0__auto__" + tmp19 := lang.Apply(v17, []any{v12}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + tmp21 = v20 + } else { + var tmp22 any + { // let + // let binding "or__0__auto__" + tmp23 := lang.Apply(v17, []any{v13}) + var v24 any = tmp23 + _ = v24 + var tmp25 any + if lang.IsTruthy(v24) { + tmp25 = v24 + } else { + tmp26 := lang.Apply(v17, []any{v14}) + tmp25 = tmp26 + } + tmp22 = tmp25 + } // end let + tmp21 = tmp22 + } + tmp18 = tmp21 + } // end let + return tmp18 + }) + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7498), kw_column, int(25), kw_end_DASH_line, int(7498), kw_end_DASH_column, int(47)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp19 := lang.Apply(tmp15, []any{tmp18, v9}) + return tmp19 + default: + checkArity(args, 3) + v12 := args[0] + _ = v12 + v13 := args[1] + _ = v13 + v14 := args[2] + _ = v14 + var v15 any = lang.NewList(args[3:]...) + _ = v15 + var tmp16 any + { // let + // let binding "or__0__auto__" + tmp17 := lang.Apply(v11, []any{v12, v13, v14}) + var v18 any = tmp17 + _ = v18 + var tmp19 any + if lang.IsTruthy(v18) { + tmp19 = v18 + } else { + tmp20 := checkDerefVar(var_glojure_DOT_core_some) + var tmp21 lang.FnFunc + tmp21 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v22 := args[0] + _ = v22 + tmp23 := checkDerefVar(var_glojure_DOT_core_some) + tmp24 := lang.Apply(tmp23, []any{v22, v15}) + return tmp24 + }) + tmp22 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7500), kw_column, int(36), kw_end_DASH_line, int(7500), kw_end_DASH_column, int(49)) + tmp23, err := lang.WithMeta(tmp21, tmp22.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp24 := lang.Apply(tmp20, []any{tmp23, v9}) + tmp19 = tmp24 + } + tmp16 = tmp19 + } // end let + return tmp16 + } + }) + v11 = tmp10 + _ = v11 + } + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7494), kw_column, int(8), kw_end_DASH_line, int(7500), kw_end_DASH_column, int(56)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp6 = tmp12 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_some_DASH_fn = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_some_DASH_fn.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // split-with + { + tmp0 := sym_split_DASH_with.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns a vector of [(take-while pred coll) (drop-while pred coll)]", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(2990), kw_end_DASH_line, int(2990))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_take_DASH_while) + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + tmp6 := checkDerefVar(var_glojure_DOT_core_drop_DASH_while) + tmp7 := lang.Apply(tmp6, []any{v2, v3}) + tmp8 := lang.NewVector(tmp5, tmp7) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2995), kw_column, int(5), kw_end_DASH_line, int(2995), kw_end_DASH_column, int(51)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp10 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_split_DASH_with = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_split_DASH_with.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // stream-into! + { + tmp0 := sym_stream_DASH_into_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_to, sym_stream), lang.NewVector(sym_to, sym_xform, sym_stream)), kw_doc, "Returns a new coll consisting of coll with all of the items of the\n stream conjoined. This is a terminal operation on the stream.", kw_file, "glojure/core.glj", kw_added, "1.12", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(6810), kw_end_DASH_line, int(6810))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp6 := reflect.TypeOf((*lang.IEditableCollection)(nil)).Elem() + tmp7 := lang.Apply(tmp5, []any{tmp6, v2}) + if lang.IsTruthy(tmp7) { + tmp8 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp9 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp10 := checkDerefVar(var_glojure_DOT_core_stream_DASH_reduce_BANG_) + tmp11 := checkDerefVar(var_glojure_DOT_core_conj_BANG_) + tmp12 := checkDerefVar(var_glojure_DOT_core_transient) + tmp13 := lang.Apply(tmp12, []any{v2}) + tmp14 := lang.Apply(tmp10, []any{tmp11, tmp13, v3}) + tmp15 := lang.Apply(tmp9, []any{tmp14}) + tmp16 := checkDerefVar(var_glojure_DOT_core_meta) + tmp17 := lang.Apply(tmp16, []any{v2}) + tmp18 := lang.Apply(tmp8, []any{tmp15, tmp17}) + tmp4 = tmp18 + } else { + tmp19 := checkDerefVar(var_glojure_DOT_core_stream_DASH_reduce_BANG_) + tmp20 := checkDerefVar(var_glojure_DOT_core_conj) + tmp21 := lang.Apply(tmp19, []any{tmp20, v2, v3}) + tmp4 = tmp21 + } + return tmp4 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp7 := reflect.TypeOf((*lang.IEditableCollection)(nil)).Elem() + tmp8 := lang.Apply(tmp6, []any{tmp7, v2}) + if lang.IsTruthy(tmp8) { + tmp9 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp10 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp11 := checkDerefVar(var_glojure_DOT_core_stream_DASH_transduce_BANG_) + tmp12 := checkDerefVar(var_glojure_DOT_core_conj_BANG_) + tmp13 := checkDerefVar(var_glojure_DOT_core_transient) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(tmp11, []any{v3, tmp12, tmp14, v4}) + tmp16 := lang.Apply(tmp10, []any{tmp15}) + tmp17 := checkDerefVar(var_glojure_DOT_core_meta) + tmp18 := lang.Apply(tmp17, []any{v2}) + tmp19 := lang.Apply(tmp9, []any{tmp16, tmp18}) + tmp5 = tmp19 + } else { + tmp20 := checkDerefVar(var_glojure_DOT_core_stream_DASH_transduce_BANG_) + tmp21 := checkDerefVar(var_glojure_DOT_core_conj) + tmp22 := lang.Apply(tmp20, []any{v3, tmp21, v2, v4}) + tmp5 = tmp22 + } + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_stream_DASH_into_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_stream_DASH_into_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // subvec + { + tmp0 := sym_subvec.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_v, sym_start), lang.NewVector(sym_v, sym_start, sym_end)), kw_doc, "Returns a persistent vector of the items in vector from\n start (inclusive) to end (exclusive). If end is not supplied,\n defaults to (count vector). This operation is O(1) and very fast, as\n the resulting vector shares structure with the original and no\n trimming is done.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(3819), kw_end_DASH_line, int(3819))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_subvec) + tmp5 := checkDerefVar(var_glojure_DOT_core_count) + tmp6 := lang.Apply(tmp5, []any{v2}) + tmp7 := lang.Apply(tmp4, []any{v2, v3, tmp6}) + return tmp7 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5, _ := lang.FieldOrMethod(runtime.RT, "Subvec") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Subvec is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v2, v3, v4}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_subvec = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_subvec.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // symbol + { + tmp1 := reflect.TypeOf((*lang.Symbol)(nil)) + tmp0 := sym_symbol.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_name), lang.NewVector(sym_ns, sym_name)), kw_doc, "Returns a Symbol with the given namespace and name. Arity-1 works\n on strings, keywords, and vars.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(584), kw_end_DASH_line, int(584))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + tmp4 = v3 + } else { + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp9 := lang.Apply(tmp8, []any{lang.Builtins["string"], v3}) + if lang.IsTruthy(tmp9) { + tmp10 := lang.Apply(lang.NewSymbol, []any{v3}) + tmp7 = tmp10 + } else { + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp13 := reflect.TypeOf((*lang.Var)(nil)) + tmp14 := lang.Apply(tmp12, []any{tmp13, v3}) + if lang.IsTruthy(tmp14) { + tmp15, ok := lang.FieldOrMethod(v3, "toSymbol") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "toSymbol"))) + } + var tmp16 any + switch reflect.TypeOf(tmp15).Kind() { + case reflect.Func: + tmp16 = lang.Apply(tmp15, nil) + default: + tmp16 = tmp15 + } + tmp11 = tmp16 + } else { + var tmp17 any + tmp18 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp19 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() + tmp20 := lang.Apply(tmp18, []any{tmp19, v3}) + if lang.IsTruthy(tmp20) { + tmp21, ok := lang.FieldOrMethod(v3, "sym") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "sym"))) + } + var tmp22 any + switch reflect.TypeOf(tmp21).Kind() { + case reflect.Func: + tmp22 = lang.Apply(tmp21, nil) + default: + tmp22 = tmp21 + } + tmp17 = tmp22 + } else { + var tmp23 any + if lang.IsTruthy(kw_else) { + tmp24 := lang.Apply(lang.NewIllegalArgumentError, []any{"no conversion to symbol"}) + panic(tmp24) + } else { + } + tmp17 = tmp23 + } + tmp11 = tmp17 + } + tmp7 = tmp11 + } + tmp4 = tmp7 + } + return tmp4 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(lang.InternSymbol, []any{v3, v4}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp3 := reflect.TypeOf((*lang.Symbol)(nil)) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_symbol = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_symbol.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // thread-bound? + { + tmp0 := sym_thread_DASH_bound_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_vars)), kw_doc, "Returns true if all of the vars provided as arguments have thread-local bindings.\n Implies that set!'ing the provided vars will succeed. Returns true if no vars are provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(5499), kw_end_DASH_line, int(5499))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v5 := args[0] + _ = v5 + tmp6, ok := lang.FieldOrMethod(v5, "getThreadBinding") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "getThreadBinding"))) + } + var tmp7 any + switch reflect.TypeOf(tmp6).Kind() { + case reflect.Func: + tmp7 = lang.Apply(tmp6, nil) + default: + tmp7 = tmp6 + } + return tmp7 + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5505), kw_column, int(11), kw_end_DASH_line, int(5505), kw_end_DASH_column, int(78)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp7 := lang.Apply(tmp3, []any{tmp6, v2}) + return tmp7 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_thread_DASH_bound_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_thread_DASH_bound_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // type + { + tmp0 := sym_type.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Returns the :type metadata of x, or its Class if none", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3467), kw_end_DASH_line, int(3467))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "or__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_get) + tmp5 := checkDerefVar(var_glojure_DOT_core_meta) + tmp6 := lang.Apply(tmp5, []any{v2}) + tmp7 := lang.Apply(tmp4, []any{tmp6, kw_type}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + tmp9 = v8 + } else { + tmp10 := checkDerefVar(var_glojure_DOT_core_class) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp9 = tmp11 + } + tmp3 = tmp9 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_type = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_type.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-add + { + var tmp1 lang.FnFunc + { // function unchecked-add__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_UncheckedAdd}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_add.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Returns the sum of x and y, both long.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(1203), kw_end_DASH_line, int(1203))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedAdd") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedAdd is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_add = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_add.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-add-int + { + var tmp1 lang.FnFunc + { // function unchecked-add-int__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_add}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_add_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Returns the sum of x and y, both int.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(7), kw_line, int(1196), kw_end_DASH_line, int(1196))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_add") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_add is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_add_DASH_int = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_add_DASH_int.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-byte + { + var tmp1 lang.FnFunc + { // function unchecked-byte__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedByteCast}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_byte.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to byte. Subject to rounding or truncation.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(3517), kw_end_DASH_line, int(3517))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.UncheckedByteCast, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_byte = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_byte.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-char + { + var tmp1 lang.FnFunc + { // function unchecked-char__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedCharCast}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_char.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to char. Subject to rounding or truncation.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(3529), kw_end_DASH_line, int(3529))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(runtime.RT, "UncheckedCharCast") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedCharCast is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_char = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_char.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-dec + { + var tmp1 lang.FnFunc + { // function unchecked-dec__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedDec}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_dec.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns a number one less than x, a long.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(1175), kw_end_DASH_line, int(1175))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedDec") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedDec is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_dec = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_dec.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-dec-int + { + var tmp1 lang.FnFunc + { // function unchecked-dec-int__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_dec}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_dec_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns a number one less than x, an int.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(7), kw_line, int(1168), kw_end_DASH_line, int(1168))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_dec") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_dec is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_dec_DASH_int = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_dec_DASH_int.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-divide-int + { + var tmp1 lang.FnFunc + { // function unchecked-divide-int__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_UncheckedIntDivide}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_divide_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Returns the division of x by y, both int.\n Note - uses a primitive operator subject to truncation.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(26), kw_column, int(7), kw_line, int(1238), kw_end_DASH_line, int(1238))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedIntDivide") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedIntDivide is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_divide_DASH_int = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_divide_DASH_int.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-double + { + var tmp1 lang.FnFunc + { // function unchecked-double__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedDoubleCast}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_double.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to double. Subject to rounding.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(22), kw_column, int(7), kw_line, int(3553), kw_end_DASH_line, int(3553))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.AsFloat64, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_double = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_double.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-float + { + var tmp1 lang.FnFunc + { // function unchecked-float__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedFloatCast}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_float.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to float. Subject to rounding.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(3547), kw_end_DASH_line, int(3547))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.UncheckedFloatCast, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_float = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_float.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-inc + { + var tmp1 lang.FnFunc + { // function unchecked-inc__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Unchecked_inc}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_inc.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns a number one greater than x, a long.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(1161), kw_end_DASH_line, int(1161))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_inc") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_inc is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_inc = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_inc.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-inc-int + { + var tmp1 lang.FnFunc + { // function unchecked-inc-int__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_inc}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_inc_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns a number one greater than x, an int.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(7), kw_line, int(1154), kw_end_DASH_line, int(1154))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_inc") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_inc is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_inc_DASH_int = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_inc_DASH_int.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-int + { + var tmp1 lang.FnFunc + { // function unchecked-int__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedIntCast}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to int. Subject to rounding or truncation.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(3535), kw_end_DASH_line, int(3535))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.UncheckedIntCast, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_int = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_int.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-long + { + var tmp1 lang.FnFunc + { // function unchecked-long__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedLongCast}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_long.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to long. Subject to rounding or truncation.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(3541), kw_end_DASH_line, int(3541))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.UncheckedLongCast, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_long = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_long.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-multiply + { + var tmp1 lang.FnFunc + { // function unchecked-multiply__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_multiply}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_multiply.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Returns the product of x and y, both long.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(24), kw_column, int(7), kw_line, int(1231), kw_end_DASH_line, int(1231))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_multiply") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_multiply is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_multiply = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_multiply.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-multiply-int + { + var tmp1 lang.FnFunc + { // function unchecked-multiply-int__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_multiply}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_multiply_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Returns the product of x and y, both int.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(28), kw_column, int(7), kw_line, int(1224), kw_end_DASH_line, int(1224))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_multiply") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_multiply is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_multiply_DASH_int = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_multiply_DASH_int.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-negate + { + var tmp1 lang.FnFunc + { // function unchecked-negate__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Unchecked_minus}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_negate.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns the negation of x, a long.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(22), kw_column, int(7), kw_line, int(1189), kw_end_DASH_line, int(1189))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_negate") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_negate is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_negate = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_negate.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-negate-int + { + var tmp1 lang.FnFunc + { // function unchecked-negate-int__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_negate}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_negate_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Returns the negation of x, an int.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(26), kw_column, int(7), kw_line, int(1182), kw_end_DASH_line, int(1182))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_negate") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_negate is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_negate_DASH_int = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_negate_DASH_int.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-remainder-int + { + var tmp1 lang.FnFunc + { // function unchecked-remainder-int__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_remainder}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_remainder_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Returns the remainder of division of x by y, both int.\n Note - uses a primitive operator subject to truncation.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(29), kw_column, int(7), kw_line, int(1245), kw_end_DASH_line, int(1245))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_remainder") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_remainder is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_remainder_DASH_int = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_remainder_DASH_int.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-short + { + var tmp1 lang.FnFunc + { // function unchecked-short__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedShortCast}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_short.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to short. Subject to rounding or truncation.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(3523), kw_end_DASH_line, int(3523))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.UncheckedShortCast, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_short = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_short.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-subtract + { + var tmp1 lang.FnFunc + { // function unchecked-subtract__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_minus}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_subtract.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Returns the difference of x and y, both long.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(24), kw_column, int(7), kw_line, int(1217), kw_end_DASH_line, int(1217))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_minus") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_minus is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_subtract = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_subtract.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unchecked-subtract-int + { + var tmp1 lang.FnFunc + { // function unchecked-subtract-int__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_subtract}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unchecked_DASH_subtract_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Returns the difference of x and y, both int.\n Note - uses a primitive operator subject to overflow.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(28), kw_column, int(7), kw_line, int(1210), kw_end_DASH_line, int(1210))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_subtract") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_subtract is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unchecked_DASH_subtract_DASH_int = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unchecked_DASH_subtract_DASH_int.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unreduced + { + tmp0 := sym_unreduced.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "If x is reduced?, returns (deref x), else returns x", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(2847), kw_end_DASH_line, int(2847))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + tmp6 := checkDerefVar(var_glojure_DOT_core_deref) + tmp7 := lang.Apply(tmp6, []any{v2}) + tmp3 = tmp7 + } else { + tmp3 = v2 + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unreduced = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unreduced.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // unsigned-bit-shift-right + { + var tmp1 lang.FnFunc + { // function unsigned-bit-shift-right__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_UnsignedShiftRight}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_unsigned_DASH_bit_DASH_shift_DASH_right.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_n)), kw_inline, tmp1, kw_doc, "Bitwise shift right, without sign-extension.", kw_file, "glojure/core.glj", kw_added, "1.6", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(30), kw_column, int(7), kw_line, int(1373), kw_end_DASH_line, int(1373))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "UnsignedShiftRight") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("UnsignedShiftRight is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_unsigned_DASH_bit_DASH_shift_DASH_right = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_unsigned_DASH_bit_DASH_shift_DASH_right.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // vec + { + tmp0 := sym_vec.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Creates a new vector containing the contents of coll. Java arrays\n will be aliased and should not be modified.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(366), kw_end_DASH_line, int(366))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp8 := reflect.TypeOf((*lang.IObj)(nil)).Elem() + tmp9 := lang.Apply(tmp7, []any{tmp8, v2}) + if lang.IsTruthy(tmp9) { + tmp10 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp11 := lang.Apply(tmp10, []any{v2, nil}) + tmp6 = tmp11 + } else { + tmp12 := lang.Apply(lang.CreateLazilyPersistentVector, []any{v2}) + tmp6 = tmp12 + } + tmp3 = tmp6 + } else { + tmp13 := lang.Apply(lang.CreateLazilyPersistentVector, []any{v2}) + tmp3 = tmp13 + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_vec = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_vec.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // vswap! + { + tmp0 := sym_vswap_BANG_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_vol, sym_f, sym__AMP_, sym_args)), kw_doc, "Non-atomically swaps the value of the volatile as if:\n (apply f current-value-of-vol args). Returns the value that\n was swapped in.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(11), kw_line, int(2531), kw_end_DASH_line, int(2531))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var v6 any = lang.NewList(args[4:]...) + _ = v6 + var tmp7 any + { // let + // let binding "v" + tmp8 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp9 := lang.NewMap(kw_tag, sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Volatile) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2537), kw_column, int(26), kw_end_DASH_line, int(2537), kw_end_DASH_column, int(81)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp12 := lang.Apply(tmp8, []any{v4, tmp11}) + var v13 any = tmp12 + _ = v13 + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{sym__DOT_reset}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v13}) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := checkDerefVar(var_glojure_DOT_core_seq) + tmp22 := checkDerefVar(var_glojure_DOT_core_concat) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := lang.Apply(tmp23, []any{v5}) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := checkDerefVar(var_glojure_DOT_core_seq) + tmp27 := checkDerefVar(var_glojure_DOT_core_concat) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := lang.Apply(tmp28, []any{sym__DOT_Deref}) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := lang.Apply(tmp30, []any{v13}) + tmp32 := lang.Apply(tmp27, []any{tmp29, tmp31}) + tmp33 := lang.Apply(tmp26, []any{tmp32}) + tmp34 := lang.Apply(tmp25, []any{tmp33}) + tmp35 := lang.Apply(tmp22, []any{tmp24, tmp34, v6}) + tmp36 := lang.Apply(tmp21, []any{tmp35}) + tmp37 := lang.Apply(tmp20, []any{tmp36}) + tmp38 := lang.Apply(tmp15, []any{tmp17, tmp19, tmp37}) + tmp39 := lang.Apply(tmp14, []any{tmp38}) + tmp7 = tmp39 + } // end let + return tmp7 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_vswap_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_vswap_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // zero? + { + var tmp1 lang.FnFunc + { // function zero?__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_IsZero}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_zero_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_num)), kw_inline, tmp1, kw_doc, "Returns true if num is zero, else false", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(860), kw_end_DASH_line, int(860))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "IsZero") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("IsZero is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_zero_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_zero_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // zipmap + { + tmp0 := sym_zipmap.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_keys, sym_vals)), kw_doc, "Returns a map with the keys mapped to the corresponding vals.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(6583), kw_end_DASH_line, int(6583))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "map" + tmp5 := checkDerefVar(var_glojure_DOT_core_transient) + tmp6 := lang.NewMap() + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6588), kw_column, int(27), kw_end_DASH_line, int(6588), kw_end_DASH_column, int(28)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp9 := lang.Apply(tmp5, []any{tmp8}) + var v10 any = tmp9 + _ = v10 + // let binding "ks" + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := lang.Apply(tmp11, []any{v2}) + var v13 any = tmp12 + _ = v13 + // let binding "vs" + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := lang.Apply(tmp14, []any{v3}) + var v16 any = tmp15 + _ = v16 + for { + var tmp17 any + var tmp18 any + { // let + // let binding "and__0__auto__" + var v19 any = v13 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + tmp20 = v16 + } else { + tmp20 = v19 + } + tmp18 = tmp20 + } // end let + if lang.IsTruthy(tmp18) { + tmp20 := checkDerefVar(var_glojure_DOT_core_assoc_BANG_) + tmp21 := checkDerefVar(var_glojure_DOT_core_first) + tmp22 := lang.Apply(tmp21, []any{v13}) + tmp23 := checkDerefVar(var_glojure_DOT_core_first) + tmp24 := lang.Apply(tmp23, []any{v16}) + tmp25 := lang.Apply(tmp20, []any{v10, tmp22, tmp24}) + var tmp19 any = tmp25 + tmp27 := checkDerefVar(var_glojure_DOT_core_next) + tmp28 := lang.Apply(tmp27, []any{v13}) + var tmp26 any = tmp28 + tmp30 := checkDerefVar(var_glojure_DOT_core_next) + tmp31 := lang.Apply(tmp30, []any{v16}) + var tmp29 any = tmp31 + v10 = tmp19 + v13 = tmp26 + v16 = tmp29 + continue + } else { + tmp32 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp33 := lang.Apply(tmp32, []any{v10}) + tmp17 = tmp33 + } + tmp4 = tmp17 + break + } + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_zipmap = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_zipmap.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // NaN? + { + var tmp1 lang.FnFunc + { // function NaN?__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym_math_DOT_IsNaN}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{v3}) + tmp10 := lang.Apply(tmp5, []any{tmp7, tmp9}) + tmp11 := lang.Apply(tmp4, []any{tmp10}) + return tmp11 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_NaN_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_num)), kw_inline, tmp1, kw_doc, "Returns true if num is NaN, else false", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1)})), kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(7968), kw_end_DASH_line, int(7968))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(math4.IsNaN, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_NaN_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_NaN_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // StackTraceElement->vec + { + tmp0 := sym_StackTraceElement_DASH__GT_vec.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_o)), kw_doc, "Constructs a data representation for a StackTraceElement: [class method file line]", kw_file, "glojure/core_print.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(28), kw_column, int(7), kw_line, int(436), kw_end_DASH_line, int(436))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_symbol) + tmp4, ok := lang.FieldOrMethod(v2, "getClassName") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getClassName"))) + } + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { + case reflect.Func: + tmp5 = lang.Apply(tmp4, nil) + default: + tmp5 = tmp4 + } + tmp6 := lang.Apply(tmp3, []any{tmp5}) + tmp7 := checkDerefVar(var_glojure_DOT_core_symbol) + tmp8, ok := lang.FieldOrMethod(v2, "getMethodName") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getMethodName"))) + } + var tmp9 any + switch reflect.TypeOf(tmp8).Kind() { + case reflect.Func: + tmp9 = lang.Apply(tmp8, nil) + default: + tmp9 = tmp8 + } + tmp10 := lang.Apply(tmp7, []any{tmp9}) + tmp11, ok := lang.FieldOrMethod(v2, "getFileName") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getFileName"))) + } + var tmp12 any + switch reflect.TypeOf(tmp11).Kind() { + case reflect.Func: + tmp12 = lang.Apply(tmp11, nil) + default: + tmp12 = tmp11 + } + tmp13, ok := lang.FieldOrMethod(v2, "getLineNumber") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getLineNumber"))) + } + var tmp14 any + switch reflect.TypeOf(tmp13).Kind() { + case reflect.Func: + tmp14 = lang.Apply(tmp13, nil) + default: + tmp14 = tmp13 + } + tmp15 := lang.NewVector(tmp6, tmp10, tmp12, tmp14) + tmp16 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(440), kw_column, int(3), kw_end_DASH_line, int(440), kw_end_DASH_column, int(94)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp17 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_StackTraceElement_DASH__GT_vec = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_StackTraceElement_DASH__GT_vec.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // -> + { + tmp0 := sym__DASH__GT_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_x, sym__AMP_, sym_forms)), kw_doc, "Threads the expr through the forms. Inserts x as the\n second item in the first form, making a list of it if it is not a\n list already. If there are more forms, inserts the first form as the\n second item in second form, etc.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(11), kw_line, int(1675), kw_end_DASH_line, int(1675))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "x" + var v7 any = v4 + _ = v7 + // let binding "forms" + var v8 any = v5 + _ = v8 + for { + var tmp9 any + if lang.IsTruthy(v8) { + var tmp10 any + { // let + // let binding "form" + tmp11 := checkDerefVar(var_glojure_DOT_core_first) + tmp12 := lang.Apply(tmp11, []any{v8}) + var v13 any = tmp12 + _ = v13 + // let binding "threaded" + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp16 := lang.Apply(tmp15, []any{v13}) + if lang.IsTruthy(tmp16) { + tmp17 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := checkDerefVar(var_glojure_DOT_core_first) + tmp22 := lang.Apply(tmp21, []any{v13}) + tmp23 := lang.Apply(tmp20, []any{tmp22}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v7}) + tmp26 := checkDerefVar(var_glojure_DOT_core_next) + tmp27 := lang.Apply(tmp26, []any{v13}) + tmp28 := lang.Apply(tmp19, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp18, []any{tmp28}) + tmp30 := checkDerefVar(var_glojure_DOT_core_meta) + tmp31 := lang.Apply(tmp30, []any{v13}) + tmp32 := lang.Apply(tmp17, []any{tmp29, tmp31}) + tmp14 = tmp32 + } else { + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{v13, v7}) + tmp14 = tmp34 + } + var v35 any = tmp14 + _ = v35 + var tmp36 any = v35 + tmp38 := checkDerefVar(var_glojure_DOT_core_next) + tmp39 := lang.Apply(tmp38, []any{v8}) + var tmp37 any = tmp39 + v7 = tmp36 + v8 = tmp37 + continue + } // end let + tmp9 = tmp10 + } else { + tmp9 = v7 + } + tmp6 = tmp9 + break + } + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__DASH__GT_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__DASH__GT_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ->> + { + tmp0 := sym__DASH__GT__GT_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_x, sym__AMP_, sym_forms)), kw_doc, "Threads the expr through the forms. Inserts x as the\n last item in the first form, making a list of it if it is not a\n list already. If there are more forms, inserts the first form as the\n last item in second form, etc.", kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(11), kw_line, int(1691), kw_end_DASH_line, int(1691))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "x" + var v7 any = v4 + _ = v7 + // let binding "forms" + var v8 any = v5 + _ = v8 + for { + var tmp9 any + if lang.IsTruthy(v8) { + var tmp10 any + { // let + // let binding "form" + tmp11 := checkDerefVar(var_glojure_DOT_core_first) + tmp12 := lang.Apply(tmp11, []any{v8}) + var v13 any = tmp12 + _ = v13 + // let binding "threaded" + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp16 := lang.Apply(tmp15, []any{v13}) + if lang.IsTruthy(tmp16) { + tmp17 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := checkDerefVar(var_glojure_DOT_core_first) + tmp22 := lang.Apply(tmp21, []any{v13}) + tmp23 := lang.Apply(tmp20, []any{tmp22}) + tmp24 := checkDerefVar(var_glojure_DOT_core_next) + tmp25 := lang.Apply(tmp24, []any{v13}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v7}) + tmp28 := lang.Apply(tmp19, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp18, []any{tmp28}) + tmp30 := checkDerefVar(var_glojure_DOT_core_meta) + tmp31 := lang.Apply(tmp30, []any{v13}) + tmp32 := lang.Apply(tmp17, []any{tmp29, tmp31}) + tmp14 = tmp32 + } else { + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{v13, v7}) + tmp14 = tmp34 + } + var v35 any = tmp14 + _ = v35 + var tmp36 any = v35 + tmp38 := checkDerefVar(var_glojure_DOT_core_next) + tmp39 := lang.Apply(tmp38, []any{v8}) + var tmp37 any = tmp39 + v7 = tmp36 + v8 = tmp37 + continue + } // end let + tmp9 = tmp10 + } else { + tmp9 = v7 + } + tmp6 = tmp9 + break + } + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__DASH__GT__GT_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__DASH__GT__GT_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // .. + { + tmp0 := sym__DOT__DOT_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_form), lang.NewVector(sym_x, sym_form, sym__AMP_, sym_more)), kw_doc, "form => fieldName-symbol or (instanceMethodName-symbol args*)\n\n Expands into a member access (.) of the first member on the first\n argument, followed by the next member on the result, etc. For\n instance:\n\n (.. System (getProperties) (get \"os.name\"))\n\n expands to:\n\n (. (. System (getProperties)) (get \"os.name\"))\n\n but is easier to write, read, and understand.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(11), kw_line, int(1657), kw_end_DASH_line, int(1657))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym__DOT_}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{v4}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v5}) + tmp14 := lang.Apply(tmp7, []any{tmp9, tmp11, tmp13}) + tmp15 := lang.Apply(tmp6, []any{tmp14}) + return tmp15 + default: + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var v6 any = lang.NewList(args[4:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym__DOT_}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v4}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v5}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp22, v6}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + return tmp24 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__DOT__DOT_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__DOT__DOT_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // = + { + var tmp1 lang.FnFunc + { // function =__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_lang_DOT_Util}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_glojure_DOT_core_SLASH_equiv}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{v3}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v4}) + tmp17 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp12, tmp14, tmp16}) + tmp18 := lang.Apply(tmp5, []any{tmp17}) + return tmp18 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym__EQ_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Equality. Returns true if x equals y, false if not. Same as\n Java x.equals(y) except it also works for nil, and compares\n numbers and collections in a type-independent manner. Clojure's immutable data\n structures define equals() (and thus =) as a value, not an identity,\n comparison.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(7), kw_line, int(776), kw_end_DASH_line, int(776))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + return true + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(lang.Equiv, []any{v3, v4}) + return tmp5 + default: + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + recur_loop_1666: + var tmp6 any + tmp7 := lang.Apply(lang.Equiv, []any{v3, v4}) + if lang.IsTruthy(tmp7) { + var tmp8 any + tmp9 := checkDerefVar(var_glojure_DOT_core_next) + tmp10 := lang.Apply(tmp9, []any{v5}) + if lang.IsTruthy(tmp10) { + var tmp11 any = v4 + tmp13 := checkDerefVar(var_glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v5}) + var tmp12 any = tmp14 + tmp16 := checkDerefVar(var_glojure_DOT_core_next) + tmp17 := lang.Apply(tmp16, []any{v5}) + var tmp15 any = tmp17 + v3 = tmp11 + v4 = tmp12 + v5 = tmp15 + goto recur_loop_1666 + } else { + tmp18 := checkDerefVar(var_glojure_DOT_core_first) + tmp19 := lang.Apply(tmp18, []any{v5}) + tmp20 := lang.Apply(lang.Equiv, []any{v4, tmp19}) + tmp8 = tmp20 + } + tmp6 = tmp8 + } else { + tmp6 = false + } + return tmp6 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__EQ_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__EQ_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // == + { + var tmp1 lang.FnFunc + { // function ==__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Equiv}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym__EQ__EQ_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns non-nil if nums all have the equivalent\n value (type-independent), otherwise false", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(7), kw_line, int(1093), kw_end_DASH_line, int(1093))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + return true + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Equiv") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Equiv is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + default: + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + recur_loop_1746: + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__EQ__EQ_) + tmp8 := lang.Apply(tmp7, []any{v3, v4}) + if lang.IsTruthy(tmp8) { + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_next) + tmp11 := lang.Apply(tmp10, []any{v5}) + if lang.IsTruthy(tmp11) { + var tmp12 any = v4 + tmp14 := checkDerefVar(var_glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v5}) + var tmp13 any = tmp15 + tmp17 := checkDerefVar(var_glojure_DOT_core_next) + tmp18 := lang.Apply(tmp17, []any{v5}) + var tmp16 any = tmp18 + v3 = tmp12 + v4 = tmp13 + v5 = tmp16 + goto recur_loop_1746 + } else { + tmp19 := checkDerefVar(var_glojure_DOT_core__EQ__EQ_) + tmp20 := checkDerefVar(var_glojure_DOT_core_first) + tmp21 := lang.Apply(tmp20, []any{v5}) + tmp22 := lang.Apply(tmp19, []any{v4, tmp21}) + tmp9 = tmp22 + } + tmp6 = tmp9 + } else { + tmp6 = false + } + return tmp6 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__EQ__EQ_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__EQ__EQ_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // > + { + var tmp1 lang.FnFunc + { // function >__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Gt}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym__GT_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns non-nil if nums are in monotonically decreasing order,\n otherwise false.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(7), kw_line, int(1063), kw_end_DASH_line, int(1063))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + return true + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + default: + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + recur_loop_1738: + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__GT_) + tmp8 := lang.Apply(tmp7, []any{v3, v4}) + if lang.IsTruthy(tmp8) { + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_next) + tmp11 := lang.Apply(tmp10, []any{v5}) + if lang.IsTruthy(tmp11) { + var tmp12 any = v4 + tmp14 := checkDerefVar(var_glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v5}) + var tmp13 any = tmp15 + tmp17 := checkDerefVar(var_glojure_DOT_core_next) + tmp18 := lang.Apply(tmp17, []any{v5}) + var tmp16 any = tmp18 + v3 = tmp12 + v4 = tmp13 + v5 = tmp16 + goto recur_loop_1738 + } else { + tmp19 := checkDerefVar(var_glojure_DOT_core__GT_) + tmp20 := checkDerefVar(var_glojure_DOT_core_first) + tmp21 := lang.Apply(tmp20, []any{v5}) + tmp22 := lang.Apply(tmp19, []any{v4, tmp21}) + tmp9 = tmp22 + } + tmp6 = tmp9 + } else { + tmp6 = false + } + return tmp6 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__GT_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__GT_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // >= + { + var tmp1 lang.FnFunc + { // function >=__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Gte}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym__GT__EQ_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns non-nil if nums are in monotonically non-increasing order,\n otherwise false.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(7), kw_line, int(1078), kw_end_DASH_line, int(1078))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + return true + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Gte") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gte is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + default: + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + recur_loop_1742: + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__GT__EQ_) + tmp8 := lang.Apply(tmp7, []any{v3, v4}) + if lang.IsTruthy(tmp8) { + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_next) + tmp11 := lang.Apply(tmp10, []any{v5}) + if lang.IsTruthy(tmp11) { + var tmp12 any = v4 + tmp14 := checkDerefVar(var_glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v5}) + var tmp13 any = tmp15 + tmp17 := checkDerefVar(var_glojure_DOT_core_next) + tmp18 := lang.Apply(tmp17, []any{v5}) + var tmp16 any = tmp18 + v3 = tmp12 + v4 = tmp13 + v5 = tmp16 + goto recur_loop_1742 + } else { + tmp19 := checkDerefVar(var_glojure_DOT_core__GT__EQ_) + tmp20 := checkDerefVar(var_glojure_DOT_core_first) + tmp21 := lang.Apply(tmp20, []any{v5}) + tmp22 := lang.Apply(tmp19, []any{v4, tmp21}) + tmp9 = tmp22 + } + tmp6 = tmp9 + } else { + tmp6 = false + } + return tmp6 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__GT__EQ_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__GT__EQ_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // < + { + var tmp1 lang.FnFunc + { // function <__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Lt}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym__LT_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns non-nil if nums are in monotonically increasing order,\n otherwise false.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(7), kw_line, int(893), kw_end_DASH_line, int(893))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + return true + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Lt") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Lt is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + default: + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + recur_loop_1690: + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp8 := lang.Apply(tmp7, []any{v3, v4}) + if lang.IsTruthy(tmp8) { + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_next) + tmp11 := lang.Apply(tmp10, []any{v5}) + if lang.IsTruthy(tmp11) { + var tmp12 any = v4 + tmp14 := checkDerefVar(var_glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v5}) + var tmp13 any = tmp15 + tmp17 := checkDerefVar(var_glojure_DOT_core_next) + tmp18 := lang.Apply(tmp17, []any{v5}) + var tmp16 any = tmp18 + v3 = tmp12 + v4 = tmp13 + v5 = tmp16 + goto recur_loop_1690 + } else { + tmp19 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp20 := checkDerefVar(var_glojure_DOT_core_first) + tmp21 := lang.Apply(tmp20, []any{v5}) + tmp22 := lang.Apply(tmp19, []any{v4, tmp21}) + tmp9 = tmp22 + } + tmp6 = tmp9 + } else { + tmp6 = false + } + return tmp6 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__LT_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__LT_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // <= + { + var tmp1 lang.FnFunc + { // function <=__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Lte}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym__LT__EQ_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns non-nil if nums are in monotonically non-decreasing order,\n otherwise false.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(7), kw_line, int(1048), kw_end_DASH_line, int(1048))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + return true + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Lte") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Lte is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + default: + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + recur_loop_1734: + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__LT__EQ_) + tmp8 := lang.Apply(tmp7, []any{v3, v4}) + if lang.IsTruthy(tmp8) { + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_next) + tmp11 := lang.Apply(tmp10, []any{v5}) + if lang.IsTruthy(tmp11) { + var tmp12 any = v4 + tmp14 := checkDerefVar(var_glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v5}) + var tmp13 any = tmp15 + tmp17 := checkDerefVar(var_glojure_DOT_core_next) + tmp18 := lang.Apply(tmp17, []any{v5}) + var tmp16 any = tmp18 + v3 = tmp12 + v4 = tmp13 + v5 = tmp16 + goto recur_loop_1734 + } else { + tmp19 := checkDerefVar(var_glojure_DOT_core__LT__EQ_) + tmp20 := checkDerefVar(var_glojure_DOT_core_first) + tmp21 := lang.Apply(tmp20, []any{v5}) + tmp22 := lang.Apply(tmp19, []any{v4, tmp21}) + tmp9 = tmp22 + } + tmp6 = tmp9 + } else { + tmp6 = false + } + return tmp6 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__LT__EQ_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__LT__EQ_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // + + { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed3 + } else { + tmp4 = closed4 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed3 + } else { + tmp5 = closed4 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed3 + } else { + tmp6 = closed4 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym__PLUS_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns the sum of nums. (+) returns 0. Does not auto-promote\n longs, will throw on overflow. See also: +'", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(7), kw_line, int(977), kw_end_DASH_line, int(977))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return int64(0) + case 1: + v4 := args[0] + _ = v4 + tmp5 := lang.Apply(lang.MustAsNumber, []any{v4}) + return tmp5 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Add") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Add is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp8 := checkDerefVar(var_glojure_DOT_core__PLUS_) + tmp9 := checkDerefVar(var_glojure_DOT_core__PLUS_) + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) + return tmp11 + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__PLUS_ = ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__PLUS_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // +' + { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed5 + } else { + tmp4 = closed5 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed5 + } else { + tmp5 = closed5 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed5 + } else { + tmp6 = closed5 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym__PLUS__TICK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns the sum of nums. (+') returns 0. Supports arbitrary precision.\n See also: +", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(7), kw_line, int(965), kw_end_DASH_line, int(965))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return int64(0) + case 1: + v4 := args[0] + _ = v4 + tmp5 := lang.Apply(lang.MustAsNumber, []any{v4}) + return tmp5 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "AddP") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("AddP is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp8 := checkDerefVar(var_glojure_DOT_core__PLUS__TICK_) + tmp9 := checkDerefVar(var_glojure_DOT_core__PLUS__TICK_) + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) + return tmp11 + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__PLUS__TICK_ = ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__PLUS__TICK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // / + { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed17 + } else { + tmp4 = closed17 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed17 + } else { + tmp5 = closed17 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed17 + } else { + tmp6 = closed17 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym__SLASH_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "If no denominators are supplied, returns 1/numerator,\n else returns numerator divided by all of the denominators.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(7), kw_line, int(1013), kw_end_DASH_line, int(1013))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core__SLASH_) + tmp6 := lang.Apply(tmp5, []any{int64(1), v4}) + return tmp6 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Divide") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Divide is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp8 := checkDerefVar(var_glojure_DOT_core__SLASH_) + tmp9 := checkDerefVar(var_glojure_DOT_core__SLASH_) + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) + return tmp11 + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__SLASH_ = ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__SLASH_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // * + { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed0 + } else { + tmp4 = closed1 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed0 + } else { + tmp5 = closed1 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed0 + } else { + tmp6 = closed1 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym__STAR_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns the product of nums. (*) returns 1. Does not auto-promote\n longs, will throw on overflow. See also: *'", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(7), kw_line, int(1001), kw_end_DASH_line, int(1001))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return int64(1) + case 1: + v4 := args[0] + _ = v4 + tmp5 := lang.Apply(lang.MustAsNumber, []any{v4}) + return tmp5 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Multiply") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Multiply is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp8 := checkDerefVar(var_glojure_DOT_core__STAR_) + tmp9 := checkDerefVar(var_glojure_DOT_core__STAR_) + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) + return tmp11 + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__STAR_ = ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // *' + { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed2 + } else { + tmp4 = closed2 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed2 + } else { + tmp5 = closed2 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed2 + } else { + tmp6 = closed2 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym__STAR__TICK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns the product of nums. (*') returns 1. Supports arbitrary precision.\n See also: *", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(7), kw_line, int(989), kw_end_DASH_line, int(989))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return int64(1) + case 1: + v4 := args[0] + _ = v4 + tmp5 := lang.Apply(lang.MustAsNumber, []any{v4}) + return tmp5 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "MultiplyP") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("MultiplyP is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp8 := checkDerefVar(var_glojure_DOT_core__STAR__TICK_) + tmp9 := checkDerefVar(var_glojure_DOT_core__STAR__TICK_) + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) + return tmp11 + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__STAR__TICK_ = ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__STAR__TICK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // abs + { + var tmp1 lang.FnFunc + { // function abs__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Abs}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{v3}) + tmp10 := lang.Apply(tmp5, []any{tmp7, tmp9}) + tmp11 := lang.Apply(tmp4, []any{tmp10}) + return tmp11 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_abs.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a)), kw_inline, tmp1, kw_doc, "Returns the absolute value of a.\n If a is Long/MIN_VALUE => Long/MIN_VALUE\n If a is a double and zero => +0.0\n If a is a double and ##Inf or ##-Inf => ##Inf\n If a is a double and ##NaN => ##NaN", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1)})), kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(1128), kw_end_DASH_line, int(1128))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.Abs, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_abs = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_abs.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // aclone + { + var tmp1 lang.FnFunc + { // function aclone__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Aclone}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_aclone.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array)), kw_inline, tmp1, kw_doc, "Returns a clone of the Java array. Works on arrays of known\n types.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(3904), kw_end_DASH_line, int(3904))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(runtime.RT, "Aclone") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Aclone is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_aclone = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_aclone.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // add-doc-and-meta + { + tmp0 := sym_add_DASH_doc_DASH_and_DASH_meta.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym_docstring, sym_meta)), kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(26), kw_column, int(11), kw_line, int(6400), kw_end_DASH_line, int(6400), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 5) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_core_SLASH_alter_DASH_meta_BANG_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_var}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v4}) + tmp18 := lang.Apply(tmp13, []any{tmp15, tmp17}) + tmp19 := lang.Apply(tmp12, []any{tmp18}) + tmp20 := lang.Apply(tmp11, []any{tmp19}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{sym_glojure_DOT_core_SLASH_merge}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_seq) + tmp25 := checkDerefVar(var_glojure_DOT_core_concat) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{sym_glojure_DOT_core_SLASH_assoc}) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := lang.Apply(tmp28, []any{v6}) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := lang.Apply(tmp30, []any{kw_doc}) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := lang.Apply(tmp32, []any{v5}) + tmp34 := lang.Apply(tmp25, []any{tmp27, tmp29, tmp31, tmp33}) + tmp35 := lang.Apply(tmp24, []any{tmp34}) + tmp36 := lang.Apply(tmp23, []any{tmp35}) + tmp37 := lang.Apply(tmp8, []any{tmp10, tmp20, tmp22, tmp36}) + tmp38 := lang.Apply(tmp7, []any{tmp37}) + return tmp38 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_add_DASH_doc_DASH_and_DASH_meta = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_add_DASH_doc_DASH_and_DASH_meta.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // alength + { + var tmp1 lang.FnFunc + { // function alength__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Alength}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_alength.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array)), kw_inline, tmp1, kw_doc, "Returns the length of the Java array. Works on arrays of all\n types.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(3897), kw_end_DASH_line, int(3897))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(runtime.RT, "Alength") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Alength is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_alength = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_alength.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // apply + { + tmp0 := sym_apply.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_args), lang.NewVector(sym_f, sym_x, sym_args), lang.NewVector(sym_f, sym_x, sym_y, sym_args), lang.NewVector(sym_f, sym_x, sym_y, sym_z, sym_args), lang.NewVector(sym_f, sym_a, sym_b, sym_c, sym_d, sym__AMP_, sym_args)), kw_doc, "Applies fn f to the argument list formed by prepending intervening arguments to args.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(653), kw_end_DASH_line, int(653))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := lang.Apply(tmp4, []any{v3}) + tmp6 := lang.Apply(lang.Apply, []any{v2, tmp5}) + return tmp6 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + tmp7 := lang.Apply(lang.Apply, []any{v2, tmp6}) + return tmp7 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp7 := lang.Apply(tmp6, []any{v3, v4, v5}) + tmp8 := lang.Apply(lang.Apply, []any{v2, tmp7}) + return tmp8 + case 5: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp8 := lang.Apply(tmp7, []any{v3, v4, v5, v6}) + tmp9 := lang.Apply(lang.Apply, []any{v2, tmp8}) + return tmp9 + default: + checkArity(args, 5) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + var v7 any = lang.NewList(args[5:]...) + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_cons) + tmp9 := checkDerefVar(var_glojure_DOT_core_cons) + tmp10 := checkDerefVar(var_glojure_DOT_core_cons) + tmp11 := checkDerefVar(var_glojure_DOT_core_cons) + tmp12 := checkDerefVar(var_glojure_DOT_core_spread) + tmp13 := lang.Apply(tmp12, []any{v7}) + tmp14 := lang.Apply(tmp11, []any{v6, tmp13}) + tmp15 := lang.Apply(tmp10, []any{v5, tmp14}) + tmp16 := lang.Apply(tmp9, []any{v4, tmp15}) + tmp17 := lang.Apply(tmp8, []any{v3, tmp16}) + tmp18 := lang.Apply(lang.Apply, []any{v2, tmp17}) + return tmp18 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_apply = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_apply.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // areduce + { + tmp0 := sym_areduce.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_a, sym_idx, sym_ret, sym_init, sym_expr)), kw_doc, "Reduces an expression across an array a, using an index named idx,\n and return value named ret, initialized to init, setting ret to the \n evaluation of expr at each step, returning ret.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(5289), kw_end_DASH_line, int(5289))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 7) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + v7 := args[5] + _ = v7 + v8 := args[6] + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_seq) + tmp10 := checkDerefVar(var_glojure_DOT_core_concat) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_glojure_DOT_core_SLASH_let}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_apply) + tmp15 := checkDerefVar(var_glojure_DOT_core_vector) + tmp16 := checkDerefVar(var_glojure_DOT_core_seq) + tmp17 := checkDerefVar(var_glojure_DOT_core_concat) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{sym_a__0__auto__}) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{v4}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{sym_l__1__auto__}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := checkDerefVar(var_glojure_DOT_core_seq) + tmp26 := checkDerefVar(var_glojure_DOT_core_concat) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{sym_glojure_DOT_core_SLASH_alength}) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{sym_a__0__auto__}) + tmp31 := lang.Apply(tmp26, []any{tmp28, tmp30}) + tmp32 := lang.Apply(tmp25, []any{tmp31}) + tmp33 := lang.Apply(tmp24, []any{tmp32}) + tmp34 := lang.Apply(tmp17, []any{tmp19, tmp21, tmp23, tmp33}) + tmp35 := lang.Apply(tmp16, []any{tmp34}) + tmp36 := lang.Apply(tmp14, []any{tmp15, tmp35}) + tmp37 := lang.Apply(tmp13, []any{tmp36}) + tmp38 := checkDerefVar(var_glojure_DOT_core_list) + tmp39 := checkDerefVar(var_glojure_DOT_core_seq) + tmp40 := checkDerefVar(var_glojure_DOT_core_concat) + tmp41 := checkDerefVar(var_glojure_DOT_core_list) + tmp42 := lang.Apply(tmp41, []any{sym_glojure_DOT_core_SLASH_loop}) + tmp43 := checkDerefVar(var_glojure_DOT_core_list) + tmp44 := checkDerefVar(var_glojure_DOT_core_apply) + tmp45 := checkDerefVar(var_glojure_DOT_core_vector) + tmp46 := checkDerefVar(var_glojure_DOT_core_seq) + tmp47 := checkDerefVar(var_glojure_DOT_core_concat) + tmp48 := checkDerefVar(var_glojure_DOT_core_list) + tmp49 := lang.Apply(tmp48, []any{v5}) + tmp50 := checkDerefVar(var_glojure_DOT_core_list) + tmp51 := lang.Apply(tmp50, []any{int64(0)}) + tmp52 := checkDerefVar(var_glojure_DOT_core_list) + tmp53 := lang.Apply(tmp52, []any{v6}) + tmp54 := checkDerefVar(var_glojure_DOT_core_list) + tmp55 := lang.Apply(tmp54, []any{v7}) + tmp56 := lang.Apply(tmp47, []any{tmp49, tmp51, tmp53, tmp55}) + tmp57 := lang.Apply(tmp46, []any{tmp56}) + tmp58 := lang.Apply(tmp44, []any{tmp45, tmp57}) + tmp59 := lang.Apply(tmp43, []any{tmp58}) + tmp60 := checkDerefVar(var_glojure_DOT_core_list) + tmp61 := checkDerefVar(var_glojure_DOT_core_seq) + tmp62 := checkDerefVar(var_glojure_DOT_core_concat) + tmp63 := checkDerefVar(var_glojure_DOT_core_list) + tmp64 := lang.Apply(tmp63, []any{sym_if}) + tmp65 := checkDerefVar(var_glojure_DOT_core_list) + tmp66 := checkDerefVar(var_glojure_DOT_core_seq) + tmp67 := checkDerefVar(var_glojure_DOT_core_concat) + tmp68 := checkDerefVar(var_glojure_DOT_core_list) + tmp69 := lang.Apply(tmp68, []any{sym_glojure_DOT_core_SLASH__LT_}) + tmp70 := checkDerefVar(var_glojure_DOT_core_list) + tmp71 := lang.Apply(tmp70, []any{v5}) + tmp72 := checkDerefVar(var_glojure_DOT_core_list) + tmp73 := lang.Apply(tmp72, []any{sym_l__1__auto__}) + tmp74 := lang.Apply(tmp67, []any{tmp69, tmp71, tmp73}) + tmp75 := lang.Apply(tmp66, []any{tmp74}) + tmp76 := lang.Apply(tmp65, []any{tmp75}) + tmp77 := checkDerefVar(var_glojure_DOT_core_list) + tmp78 := checkDerefVar(var_glojure_DOT_core_seq) + tmp79 := checkDerefVar(var_glojure_DOT_core_concat) + tmp80 := checkDerefVar(var_glojure_DOT_core_list) + tmp81 := lang.Apply(tmp80, []any{sym_recur}) + tmp82 := checkDerefVar(var_glojure_DOT_core_list) + tmp83 := checkDerefVar(var_glojure_DOT_core_seq) + tmp84 := checkDerefVar(var_glojure_DOT_core_concat) + tmp85 := checkDerefVar(var_glojure_DOT_core_list) + tmp86 := lang.Apply(tmp85, []any{sym_glojure_DOT_core_SLASH_unchecked_DASH_inc_DASH_int}) + tmp87 := checkDerefVar(var_glojure_DOT_core_list) + tmp88 := lang.Apply(tmp87, []any{v5}) + tmp89 := lang.Apply(tmp84, []any{tmp86, tmp88}) + tmp90 := lang.Apply(tmp83, []any{tmp89}) + tmp91 := lang.Apply(tmp82, []any{tmp90}) + tmp92 := checkDerefVar(var_glojure_DOT_core_list) + tmp93 := lang.Apply(tmp92, []any{v8}) + tmp94 := lang.Apply(tmp79, []any{tmp81, tmp91, tmp93}) + tmp95 := lang.Apply(tmp78, []any{tmp94}) + tmp96 := lang.Apply(tmp77, []any{tmp95}) + tmp97 := checkDerefVar(var_glojure_DOT_core_list) + tmp98 := lang.Apply(tmp97, []any{v6}) + tmp99 := lang.Apply(tmp62, []any{tmp64, tmp76, tmp96, tmp98}) + tmp100 := lang.Apply(tmp61, []any{tmp99}) + tmp101 := lang.Apply(tmp60, []any{tmp100}) + tmp102 := lang.Apply(tmp40, []any{tmp42, tmp59, tmp101}) + tmp103 := lang.Apply(tmp39, []any{tmp102}) + tmp104 := lang.Apply(tmp38, []any{tmp103}) + tmp105 := lang.Apply(tmp10, []any{tmp12, tmp37, tmp104}) + tmp106 := lang.Apply(tmp9, []any{tmp105}) + return tmp106 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_areduce = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_areduce.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // array + { + tmp0 := sym_array.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(3457), kw_column, int(7), kw_end_DASH_line, int(3458), kw_end_DASH_column, int(7), kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_items)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_into_DASH_array) + tmp4 := lang.Apply(tmp3, []any{v2}) + return tmp4 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_array = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_array.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // assert + { + tmp0 := sym_assert.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_message)), kw_doc, "Evaluates expression x and throws an AssertionError with optional\n message if x does not evaluate to logical true.\n\n Assertion checks are omitted from compiled code if '*assert*' is\n false.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(11), kw_line, int(4837), kw_end_DASH_line, int(4837))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_assert_STAR_) + if lang.IsTruthy(tmp6) { + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_core_SLASH_when_DASH_not}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{v4}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{sym_throw}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := checkDerefVar(var_glojure_DOT_core_seq) + tmp20 := checkDerefVar(var_glojure_DOT_core_concat) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{sym_new}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := lang.Apply(tmp23, []any{sym_glojure_DOT_core_SLASH_AssertionError}) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := checkDerefVar(var_glojure_DOT_core_seq) + tmp27 := checkDerefVar(var_glojure_DOT_core_concat) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := lang.Apply(tmp28, []any{sym_glojure_DOT_core_SLASH_str}) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := lang.Apply(tmp30, []any{"Assert failed: "}) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := checkDerefVar(var_glojure_DOT_core_seq) + tmp34 := checkDerefVar(var_glojure_DOT_core_concat) + tmp35 := checkDerefVar(var_glojure_DOT_core_list) + tmp36 := lang.Apply(tmp35, []any{sym_glojure_DOT_core_SLASH_pr_DASH_str}) + tmp37 := checkDerefVar(var_glojure_DOT_core_list) + tmp38 := checkDerefVar(var_glojure_DOT_core_seq) + tmp39 := checkDerefVar(var_glojure_DOT_core_concat) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{sym_quote}) + tmp42 := checkDerefVar(var_glojure_DOT_core_list) + tmp43 := lang.Apply(tmp42, []any{v4}) + tmp44 := lang.Apply(tmp39, []any{tmp41, tmp43}) + tmp45 := lang.Apply(tmp38, []any{tmp44}) + tmp46 := lang.Apply(tmp37, []any{tmp45}) + tmp47 := lang.Apply(tmp34, []any{tmp36, tmp46}) + tmp48 := lang.Apply(tmp33, []any{tmp47}) + tmp49 := lang.Apply(tmp32, []any{tmp48}) + tmp50 := lang.Apply(tmp27, []any{tmp29, tmp31, tmp49}) + tmp51 := lang.Apply(tmp26, []any{tmp50}) + tmp52 := lang.Apply(tmp25, []any{tmp51}) + tmp53 := lang.Apply(tmp20, []any{tmp22, tmp24, tmp52}) + tmp54 := lang.Apply(tmp19, []any{tmp53}) + tmp55 := lang.Apply(tmp18, []any{tmp54}) + tmp56 := lang.Apply(tmp15, []any{tmp17, tmp55}) + tmp57 := lang.Apply(tmp14, []any{tmp56}) + tmp58 := lang.Apply(tmp13, []any{tmp57}) + tmp59 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp58}) + tmp60 := lang.Apply(tmp7, []any{tmp59}) + tmp5 = tmp60 + } else { + } + return tmp5 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_assert_STAR_) + if lang.IsTruthy(tmp7) { + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_when_DASH_not}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v4}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_throw}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{sym_new}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{sym_glojure_DOT_core_SLASH_AssertionError}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := checkDerefVar(var_glojure_DOT_core_seq) + tmp28 := checkDerefVar(var_glojure_DOT_core_concat) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{sym_glojure_DOT_core_SLASH_str}) + tmp31 := checkDerefVar(var_glojure_DOT_core_list) + tmp32 := lang.Apply(tmp31, []any{"Assert failed: "}) + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{v5}) + tmp35 := checkDerefVar(var_glojure_DOT_core_list) + tmp36 := lang.Apply(tmp35, []any{"\n"}) + tmp37 := checkDerefVar(var_glojure_DOT_core_list) + tmp38 := checkDerefVar(var_glojure_DOT_core_seq) + tmp39 := checkDerefVar(var_glojure_DOT_core_concat) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{sym_glojure_DOT_core_SLASH_pr_DASH_str}) + tmp42 := checkDerefVar(var_glojure_DOT_core_list) + tmp43 := checkDerefVar(var_glojure_DOT_core_seq) + tmp44 := checkDerefVar(var_glojure_DOT_core_concat) + tmp45 := checkDerefVar(var_glojure_DOT_core_list) + tmp46 := lang.Apply(tmp45, []any{sym_quote}) + tmp47 := checkDerefVar(var_glojure_DOT_core_list) + tmp48 := lang.Apply(tmp47, []any{v4}) + tmp49 := lang.Apply(tmp44, []any{tmp46, tmp48}) + tmp50 := lang.Apply(tmp43, []any{tmp49}) + tmp51 := lang.Apply(tmp42, []any{tmp50}) + tmp52 := lang.Apply(tmp39, []any{tmp41, tmp51}) + tmp53 := lang.Apply(tmp38, []any{tmp52}) + tmp54 := lang.Apply(tmp37, []any{tmp53}) + tmp55 := lang.Apply(tmp28, []any{tmp30, tmp32, tmp34, tmp36, tmp54}) + tmp56 := lang.Apply(tmp27, []any{tmp55}) + tmp57 := lang.Apply(tmp26, []any{tmp56}) + tmp58 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp57}) + tmp59 := lang.Apply(tmp20, []any{tmp58}) + tmp60 := lang.Apply(tmp19, []any{tmp59}) + tmp61 := lang.Apply(tmp16, []any{tmp18, tmp60}) + tmp62 := lang.Apply(tmp15, []any{tmp61}) + tmp63 := lang.Apply(tmp14, []any{tmp62}) + tmp64 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp63}) + tmp65 := lang.Apply(tmp8, []any{tmp64}) + tmp6 = tmp65 + } else { + } + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_assert = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_assert.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // assert-args + { + tmp0 := sym_assert_DASH_args.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_pairs)), kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(38), kw_column, int(11), kw_line, int(1830), kw_end_DASH_line, int(1830), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym_do}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := checkDerefVar(var_glojure_DOT_core_seq) + tmp11 := checkDerefVar(var_glojure_DOT_core_concat) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_glojure_DOT_core_SLASH_when_DASH_not}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_first) + tmp16 := lang.Apply(tmp15, []any{v4}) + tmp17 := lang.Apply(tmp14, []any{tmp16}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := checkDerefVar(var_glojure_DOT_core_seq) + tmp20 := checkDerefVar(var_glojure_DOT_core_concat) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{sym_throw}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_seq) + tmp25 := checkDerefVar(var_glojure_DOT_core_concat) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_NewIllegalArgumentError}) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := checkDerefVar(var_glojure_DOT_core_seq) + tmp30 := checkDerefVar(var_glojure_DOT_core_concat) + tmp31 := checkDerefVar(var_glojure_DOT_core_list) + tmp32 := lang.Apply(tmp31, []any{sym_glojure_DOT_core_SLASH_str}) + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := checkDerefVar(var_glojure_DOT_core_seq) + tmp35 := checkDerefVar(var_glojure_DOT_core_concat) + tmp36 := checkDerefVar(var_glojure_DOT_core_list) + tmp37 := lang.Apply(tmp36, []any{sym_glojure_DOT_core_SLASH_first}) + tmp38 := checkDerefVar(var_glojure_DOT_core_list) + tmp39 := lang.Apply(tmp38, []any{sym__AMP_form}) + tmp40 := lang.Apply(tmp35, []any{tmp37, tmp39}) + tmp41 := lang.Apply(tmp34, []any{tmp40}) + tmp42 := lang.Apply(tmp33, []any{tmp41}) + tmp43 := checkDerefVar(var_glojure_DOT_core_list) + tmp44 := lang.Apply(tmp43, []any{" requires "}) + tmp45 := checkDerefVar(var_glojure_DOT_core_list) + tmp46 := checkDerefVar(var_glojure_DOT_core_second) + tmp47 := lang.Apply(tmp46, []any{v4}) + tmp48 := lang.Apply(tmp45, []any{tmp47}) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) + tmp50 := lang.Apply(tmp49, []any{" in "}) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := lang.Apply(tmp51, []any{sym__STAR_ns_STAR_}) + tmp53 := checkDerefVar(var_glojure_DOT_core_list) + tmp54 := lang.Apply(tmp53, []any{":"}) + tmp55 := checkDerefVar(var_glojure_DOT_core_list) + tmp56 := checkDerefVar(var_glojure_DOT_core_seq) + tmp57 := checkDerefVar(var_glojure_DOT_core_concat) + tmp58 := checkDerefVar(var_glojure_DOT_core_list) + tmp59 := lang.Apply(tmp58, []any{kw_line}) + tmp60 := checkDerefVar(var_glojure_DOT_core_list) + tmp61 := checkDerefVar(var_glojure_DOT_core_seq) + tmp62 := checkDerefVar(var_glojure_DOT_core_concat) + tmp63 := checkDerefVar(var_glojure_DOT_core_list) + tmp64 := lang.Apply(tmp63, []any{sym_glojure_DOT_core_SLASH_meta}) + tmp65 := checkDerefVar(var_glojure_DOT_core_list) + tmp66 := lang.Apply(tmp65, []any{sym__AMP_form}) + tmp67 := lang.Apply(tmp62, []any{tmp64, tmp66}) + tmp68 := lang.Apply(tmp61, []any{tmp67}) + tmp69 := lang.Apply(tmp60, []any{tmp68}) + tmp70 := lang.Apply(tmp57, []any{tmp59, tmp69}) + tmp71 := lang.Apply(tmp56, []any{tmp70}) + tmp72 := lang.Apply(tmp55, []any{tmp71}) + tmp73 := lang.Apply(tmp30, []any{tmp32, tmp42, tmp44, tmp48, tmp50, tmp52, tmp54, tmp72}) + tmp74 := lang.Apply(tmp29, []any{tmp73}) + tmp75 := lang.Apply(tmp28, []any{tmp74}) + tmp76 := lang.Apply(tmp25, []any{tmp27, tmp75}) + tmp77 := lang.Apply(tmp24, []any{tmp76}) + tmp78 := lang.Apply(tmp23, []any{tmp77}) + tmp79 := lang.Apply(tmp20, []any{tmp22, tmp78}) + tmp80 := lang.Apply(tmp19, []any{tmp79}) + tmp81 := lang.Apply(tmp18, []any{tmp80}) + tmp82 := lang.Apply(tmp11, []any{tmp13, tmp17, tmp81}) + tmp83 := lang.Apply(tmp10, []any{tmp82}) + tmp84 := lang.Apply(tmp9, []any{tmp83}) + tmp85 := checkDerefVar(var_glojure_DOT_core_list) + var tmp86 any + { // let + // let binding "more" + tmp87 := checkDerefVar(var_glojure_DOT_core_nnext) + tmp88 := lang.Apply(tmp87, []any{v4}) + var v89 any = tmp88 + _ = v89 + var tmp90 any + if lang.IsTruthy(v89) { + tmp91 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp92 := lang.Apply(tmp91, []any{sym_glojure_DOT_core_SLASH_assert_DASH_args, v89}) + tmp90 = tmp92 + } else { + } + tmp86 = tmp90 + } // end let + tmp87 := lang.Apply(tmp85, []any{tmp86}) + tmp88 := lang.Apply(tmp6, []any{tmp8, tmp84, tmp87}) + tmp89 := lang.Apply(tmp5, []any{tmp88}) + return tmp89 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_assert_DASH_args = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_assert_DASH_args.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // assoc-in + { + tmp0 := sym_assoc_DASH_in.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m, lang.NewVector(sym_k, sym__AMP_, sym_ks), sym_v)), kw_doc, "Associates a value in a nested associative structure, where ks is a\n sequence of keys and v is the new value and returns a new nested structure.\n If any levels do not exist, hash-maps will be created.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(6147), kw_end_DASH_line, int(6147))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + { // let + // let binding "vec__829" + var v6 any = v3 + _ = v6 + // let binding "seq__830" + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := lang.Apply(tmp7, []any{v6}) + var v9 any = tmp8 + _ = v9 + // let binding "first__831" + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v9}) + var v12 any = tmp11 + _ = v12 + // let binding "seq__830" + tmp13 := checkDerefVar(var_glojure_DOT_core_next) + tmp14 := lang.Apply(tmp13, []any{v9}) + var v15 any = tmp14 + _ = v15 + // let binding "k" + var v16 any = v12 + _ = v16 + // let binding "ks" + var v17 any = v15 + _ = v17 + var tmp18 any + if lang.IsTruthy(v17) { + tmp19 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp20 := checkDerefVar(var_glojure_DOT_core_assoc_DASH_in) + tmp21 := checkDerefVar(var_glojure_DOT_core_get) + tmp22 := lang.Apply(tmp21, []any{v2, v16}) + tmp23 := lang.Apply(tmp20, []any{tmp22, v17, v4}) + tmp24 := lang.Apply(tmp19, []any{v2, v16, tmp23}) + tmp18 = tmp24 + } else { + tmp25 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp26 := lang.Apply(tmp25, []any{v2, v16, v4}) + tmp18 = tmp26 + } + tmp5 = tmp18 + } // end let + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_assoc_DASH_in = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_assoc_DASH_in.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bigdec + { + tmp1 := reflect.TypeOf((*lang.BigDecimal)(nil)) + tmp0 := sym_bigdec.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Coerce to BigDecimal", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(3648), kw_end_DASH_line, int(3648))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_decimal_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + tmp4 = v3 + } else { + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core_float_QMARK_) + tmp9 := lang.Apply(tmp8, []any{v3}) + if lang.IsTruthy(tmp9) { + tmp10 := checkDerefVar(var_glojure_DOT_core_double) + tmp11 := lang.Apply(tmp10, []any{v3}) + tmp12 := lang.Apply(lang.NewBigDecimalFromFloat64, []any{tmp11}) + tmp7 = tmp12 + } else { + var tmp13 any + tmp14 := checkDerefVar(var_glojure_DOT_core_ratio_QMARK_) + tmp15 := lang.Apply(tmp14, []any{v3}) + if lang.IsTruthy(tmp15) { + tmp16 := checkDerefVar(var_glojure_DOT_core__SLASH_) + tmp17 := lang.Apply(lang.NewBigDecimalFromRatio, []any{v3}) + tmp18, ok := lang.FieldOrMethod(v3, "denominator") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "denominator"))) + } + var tmp19 any + switch reflect.TypeOf(tmp18).Kind() { + case reflect.Func: + tmp19 = lang.Apply(tmp18, nil) + default: + tmp19 = tmp18 + } + tmp20 := lang.Apply(tmp16, []any{tmp17, tmp19}) + tmp13 = tmp20 + } else { + var tmp21 any + tmp22 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp23 := reflect.TypeOf((*lang.BigInt)(nil)) + tmp24 := lang.Apply(tmp22, []any{tmp23, v3}) + if lang.IsTruthy(tmp24) { + tmp25, ok := lang.FieldOrMethod(v3, "toBigDecimal") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "toBigDecimal"))) + } + var tmp26 any + switch reflect.TypeOf(tmp25).Kind() { + case reflect.Func: + tmp26 = lang.Apply(tmp25, nil) + default: + tmp26 = tmp25 + } + tmp21 = tmp26 + } else { + var tmp27 any + tmp28 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp29 := reflect.TypeOf((*big6.Int)(nil)) + tmp30 := lang.Apply(tmp28, []any{tmp29, v3}) + if lang.IsTruthy(tmp30) { + tmp31 := lang.Apply(lang.NewBigDecimal, []any{v3}) + tmp27 = tmp31 + } else { + var tmp32 any + tmp33 := checkDerefVar(var_glojure_DOT_core_number_QMARK_) + tmp34 := lang.Apply(tmp33, []any{v3}) + if lang.IsTruthy(tmp34) { + tmp35 := checkDerefVar(var_glojure_DOT_core_long) + tmp36 := lang.Apply(tmp35, []any{v3}) + tmp37 := lang.Apply(lang.NewBigDecimalFromInt64, []any{tmp36}) + tmp32 = tmp37 + } else { + var tmp38 any + if lang.IsTruthy(kw_else) { + tmp39 := lang.Apply(lang.NewBigDecimal, []any{v3}) + tmp38 = tmp39 + } else { + } + tmp32 = tmp38 + } + tmp27 = tmp32 + } + tmp21 = tmp27 + } + tmp13 = tmp21 + } + tmp7 = tmp13 + } + tmp4 = tmp7 + } + return tmp4 + }) + tmp3 := reflect.TypeOf((*lang.BigDecimal)(nil)) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_bigdec = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bigdec.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bigint + { + tmp1 := reflect.TypeOf((*lang.BigInt)(nil)) + tmp0 := sym_bigint.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Coerce to BigInt", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(3620), kw_end_DASH_line, int(3620))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp6 := reflect.TypeOf((*lang.BigInt)(nil)) + tmp7 := lang.Apply(tmp5, []any{tmp6, v3}) + if lang.IsTruthy(tmp7) { + tmp4 = v3 + } else { + var tmp8 any + tmp9 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp10 := reflect.TypeOf((*big6.Int)(nil)) + tmp11 := lang.Apply(tmp9, []any{tmp10, v3}) + if lang.IsTruthy(tmp11) { + tmp12 := lang.Apply(lang.NewBigIntFromGoBigInt, []any{v3}) + tmp8 = tmp12 + } else { + var tmp13 any + tmp14 := checkDerefVar(var_glojure_DOT_core_decimal_QMARK_) + tmp15 := lang.Apply(tmp14, []any{v3}) + if lang.IsTruthy(tmp15) { + tmp16 := checkDerefVar(var_glojure_DOT_core_bigint) + tmp17, ok := lang.FieldOrMethod(v3, "toBigInteger") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "toBigInteger"))) + } + var tmp18 any + switch reflect.TypeOf(tmp17).Kind() { + case reflect.Func: + tmp18 = lang.Apply(tmp17, nil) + default: + tmp18 = tmp17 + } + tmp19 := lang.Apply(tmp16, []any{tmp18}) + tmp13 = tmp19 + } else { + var tmp20 any + tmp21 := checkDerefVar(var_glojure_DOT_core_float_QMARK_) + tmp22 := lang.Apply(tmp21, []any{v3}) + if lang.IsTruthy(tmp22) { + tmp23 := checkDerefVar(var_glojure_DOT_core_bigint) + tmp24 := checkDerefVar(var_glojure_DOT_core_double) + tmp25 := lang.Apply(tmp24, []any{v3}) + tmp26 := lang.Apply(lang.NewBigDecimalFromFloat64, []any{tmp25}) + tmp27 := lang.Apply(tmp23, []any{tmp26}) + tmp20 = tmp27 + } else { + var tmp28 any + tmp29 := checkDerefVar(var_glojure_DOT_core_ratio_QMARK_) + tmp30 := lang.Apply(tmp29, []any{v3}) + if lang.IsTruthy(tmp30) { + tmp31 := checkDerefVar(var_glojure_DOT_core_bigint) + tmp32, ok := lang.FieldOrMethod(v3, "bigIntegerValue") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "bigIntegerValue"))) + } + var tmp33 any + switch reflect.TypeOf(tmp32).Kind() { + case reflect.Func: + tmp33 = lang.Apply(tmp32, nil) + default: + tmp33 = tmp32 + } + tmp34 := lang.Apply(tmp31, []any{tmp33}) + tmp28 = tmp34 + } else { + var tmp35 any + tmp36 := checkDerefVar(var_glojure_DOT_core_number_QMARK_) + tmp37 := lang.Apply(tmp36, []any{v3}) + if lang.IsTruthy(tmp37) { + tmp38 := checkDerefVar(var_glojure_DOT_core_long) + tmp39 := lang.Apply(tmp38, []any{v3}) + tmp40 := lang.Apply(lang.NewBigIntFromInt64, []any{tmp39}) + tmp35 = tmp40 + } else { + var tmp41 any + if lang.IsTruthy(kw_else) { + tmp42 := checkDerefVar(var_glojure_DOT_core_bigint) + tmp43 := lang.Apply(lang.NewBigInt, []any{v3}) + tmp44 := lang.Apply(tmp42, []any{tmp43}) + tmp41 = tmp44 + } else { + } + tmp35 = tmp41 + } + tmp28 = tmp35 + } + tmp20 = tmp28 + } + tmp13 = tmp20 + } + tmp8 = tmp13 + } + tmp4 = tmp8 + } + return tmp4 + }) + tmp3 := reflect.TypeOf((*lang.BigInt)(nil)) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_bigint = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bigint.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // biginteger + { + tmp1 := reflect.TypeOf((*big6.Int)(nil)) + tmp0 := sym_biginteger.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Coerce to BigInteger", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(3634), kw_end_DASH_line, int(3634))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp6 := reflect.TypeOf((*big6.Int)(nil)) + tmp7 := lang.Apply(tmp5, []any{tmp6, v3}) + if lang.IsTruthy(tmp7) { + tmp4 = v3 + } else { + var tmp8 any + tmp9 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp10 := reflect.TypeOf((*lang.BigInt)(nil)) + tmp11 := lang.Apply(tmp9, []any{tmp10, v3}) + if lang.IsTruthy(tmp11) { + tmp12, ok := lang.FieldOrMethod(v3, "toBigInteger") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "toBigInteger"))) + } + var tmp13 any + switch reflect.TypeOf(tmp12).Kind() { + case reflect.Func: + tmp13 = lang.Apply(tmp12, nil) + default: + tmp13 = tmp12 + } + tmp8 = tmp13 + } else { + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core_decimal_QMARK_) + tmp16 := lang.Apply(tmp15, []any{v3}) + if lang.IsTruthy(tmp16) { + tmp17, ok := lang.FieldOrMethod(v3, "toBigInteger") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "toBigInteger"))) + } + var tmp18 any + switch reflect.TypeOf(tmp17).Kind() { + case reflect.Func: + tmp18 = lang.Apply(tmp17, nil) + default: + tmp18 = tmp17 + } + tmp14 = tmp18 + } else { + var tmp19 any + tmp20 := checkDerefVar(var_glojure_DOT_core_float_QMARK_) + tmp21 := lang.Apply(tmp20, []any{v3}) + if lang.IsTruthy(tmp21) { + tmp22 := checkDerefVar(var_glojure_DOT_core_double) + tmp23 := lang.Apply(tmp22, []any{v3}) + tmp24 := lang.Apply(lang.NewBigDecimalFromFloat64, []any{tmp23}) + tmp25, ok := lang.FieldOrMethod(tmp24, "toBigInteger") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp24, "toBigInteger"))) + } + var tmp26 any + switch reflect.TypeOf(tmp25).Kind() { + case reflect.Func: + tmp26 = lang.Apply(tmp25, nil) + default: + tmp26 = tmp25 + } + tmp19 = tmp26 + } else { + var tmp27 any + tmp28 := checkDerefVar(var_glojure_DOT_core_ratio_QMARK_) + tmp29 := lang.Apply(tmp28, []any{v3}) + if lang.IsTruthy(tmp29) { + tmp30, ok := lang.FieldOrMethod(v3, "bigIntegerValue") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "bigIntegerValue"))) + } + var tmp31 any + switch reflect.TypeOf(tmp30).Kind() { + case reflect.Func: + tmp31 = lang.Apply(tmp30, nil) + default: + tmp31 = tmp30 + } + tmp27 = tmp31 + } else { + var tmp32 any + tmp33 := checkDerefVar(var_glojure_DOT_core_number_QMARK_) + tmp34 := lang.Apply(tmp33, []any{v3}) + if lang.IsTruthy(tmp34) { + tmp35 := checkDerefVar(var_glojure_DOT_core_long) + tmp36 := lang.Apply(tmp35, []any{v3}) + tmp37 := lang.Apply(big6.NewInt, []any{tmp36}) + tmp32 = tmp37 + } else { + var tmp38 any + if lang.IsTruthy(kw_else) { + tmp39 := lang.Apply(lang.NewBigInt, []any{v3}) + tmp38 = tmp39 + } else { + } + tmp32 = tmp38 + } + tmp27 = tmp32 + } + tmp19 = tmp27 + } + tmp14 = tmp19 + } + tmp8 = tmp14 + } + tmp4 = tmp8 + } + return tmp4 + }) + tmp3 := reflect.TypeOf((*big6.Int)(nil)) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_biginteger = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_biginteger.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // binding-conveyor-fn + { + tmp0 := sym_binding_DASH_conveyor_DASH_fn.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f)), kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(25), kw_column, int(7), kw_line, int(2020), kw_end_DASH_line, int(2020), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "frame" + tmp4 := lang.Apply(lang.CloneThreadBindingFrame, nil) + var v5 any = tmp4 + _ = v5 + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp7 := lang.Apply(lang.ResetThreadBindingFrame, []any{v5}) + _ = tmp7 + tmp8 := lang.Apply(v2, nil) + return tmp8 + case 1: + v7 := args[0] + _ = v7 + tmp8 := lang.Apply(lang.ResetThreadBindingFrame, []any{v5}) + _ = tmp8 + tmp9 := lang.Apply(v2, []any{v7}) + return tmp9 + case 2: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + tmp9 := lang.Apply(lang.ResetThreadBindingFrame, []any{v5}) + _ = tmp9 + tmp10 := lang.Apply(v2, []any{v7, v8}) + return tmp10 + case 3: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + tmp10 := lang.Apply(lang.ResetThreadBindingFrame, []any{v5}) + _ = tmp10 + tmp11 := lang.Apply(v2, []any{v7, v8, v9}) + return tmp11 + default: + checkArity(args, 3) + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + var v10 any = lang.NewList(args[3:]...) + _ = v10 + tmp11 := lang.Apply(lang.ResetThreadBindingFrame, []any{v5}) + _ = tmp11 + tmp12 := checkDerefVar(var_glojure_DOT_core_apply) + tmp13 := lang.Apply(tmp12, []any{v2, v7, v8, v9, v10}) + return tmp13 + } + }) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2025), kw_column, int(5), kw_end_DASH_line, int(2040), kw_end_DASH_column, int(31)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp3 = tmp8 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_binding_DASH_conveyor_DASH_fn = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_binding_DASH_conveyor_DASH_fn.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bit-and + { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed18 + } else { + tmp4 = closed18 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed18 + } else { + tmp5 = closed18 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed18 + } else { + tmp6 = closed18 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym_bit_DASH_and.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Bitwise and", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(1298), kw_end_DASH_line, int(1298))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "And") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("And is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp8 := checkDerefVar(var_glojure_DOT_core_bit_DASH_and) + tmp9 := checkDerefVar(var_glojure_DOT_core_bit_DASH_and) + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) + return tmp11 + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bit_DASH_and = ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bit_DASH_and.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bit-and-not + { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed19 + } else { + tmp4 = closed19 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed19 + } else { + tmp5 = closed19 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed19 + } else { + tmp6 = closed19 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym_bit_DASH_and_DASH_not.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Bitwise and with complement", kw_static, true, kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(1325), kw_end_DASH_line, int(1325))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "AndNot") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("AndNot is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp8 := checkDerefVar(var_glojure_DOT_core_bit_DASH_and_DASH_not) + tmp9 := checkDerefVar(var_glojure_DOT_core_bit_DASH_and_DASH_not) + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) + return tmp11 + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bit_DASH_and_DASH_not = ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bit_DASH_and_DASH_not.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bit-not + { + var tmp1 lang.FnFunc + { // function bit-not__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Not}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_bit_DASH_not.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Bitwise complement", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(1291), kw_end_DASH_line, int(1291))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Not") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Not is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bit_DASH_not = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bit_DASH_not.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bit-or + { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed20 + } else { + tmp4 = closed20 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed20 + } else { + tmp5 = closed20 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed20 + } else { + tmp6 = closed20 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym_bit_DASH_or.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Bitwise or", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(1307), kw_end_DASH_line, int(1307))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Or") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Or is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp8 := checkDerefVar(var_glojure_DOT_core_bit_DASH_or) + tmp9 := checkDerefVar(var_glojure_DOT_core_bit_DASH_or) + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) + return tmp11 + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bit_DASH_or = ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bit_DASH_or.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bit-shift-left + { + var tmp1 lang.FnFunc + { // function bit-shift-left__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_ShiftLeft}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_bit_DASH_shift_DASH_left.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_n)), kw_inline, tmp1, kw_doc, "Bitwise shift left", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(1361), kw_end_DASH_line, int(1361))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "ShiftLeft") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ShiftLeft is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bit_DASH_shift_DASH_left = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bit_DASH_shift_DASH_left.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bit-shift-right + { + var tmp1 lang.FnFunc + { // function bit-shift-right__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_ShiftRight}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp22}) + tmp24 := lang.Apply(tmp5, []any{tmp23}) + return tmp24 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_bit_DASH_shift_DASH_right.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_n)), kw_inline, tmp1, kw_doc, "Bitwise shift right", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(1367), kw_end_DASH_line, int(1367))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "ShiftRight") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ShiftRight is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bit_DASH_shift_DASH_right = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bit_DASH_shift_DASH_right.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bit-xor + { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed21 + } else { + tmp4 = closed21 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed21 + } else { + tmp5 = closed21 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed21 + } else { + tmp6 = closed21 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym_bit_DASH_xor.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Bitwise exclusive or", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(1316), kw_end_DASH_line, int(1316))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Xor") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Xor is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp8 := checkDerefVar(var_glojure_DOT_core_bit_DASH_xor) + tmp9 := checkDerefVar(var_glojure_DOT_core_bit_DASH_xor) + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) + return tmp11 + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bit_DASH_xor = ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bit_DASH_xor.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // boolean + { + var tmp1 lang.FnFunc + { // function boolean__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_BooleanCast}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp17}) + tmp19 := lang.Apply(tmp10, []any{tmp18}) + tmp20 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp19}) + tmp21 := lang.Apply(tmp4, []any{tmp20}) + return tmp21 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_boolean.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to boolean", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(1601), kw_end_DASH_line, int(1601))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(runtime.RT, "BooleanCast") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("BooleanCast is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_boolean = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_boolean.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // boolean-array + { + var tmp1 lang.FnFunc + { // function boolean-array__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_BooleanArray}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_unquote_DASH_splicing}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_glojure_DOT_core_SLASH_args}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + } + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_boolean_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_size_DASH_or_DASH_seq), lang.NewVector(sym_size, sym_init_DASH_val_DASH_or_DASH_seq)), kw_inline, tmp1, kw_doc, "Creates an array of booleans", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(5309), kw_end_DASH_line, int(5309))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "BooleanArray") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("BooleanArray is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "BooleanArrayInit") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("BooleanArrayInit is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_boolean_DASH_array = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_boolean_DASH_array.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // booleans + { + var tmp1 lang.FnFunc + { // function booleans + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Booleans}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_booleans.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xs)), kw_inline, tmp1, kw_doc, "Casts to boolean[]", kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(12), kw_line, int(5372), kw_end_DASH_line, int(5372))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Booleans") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Booleans is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_booleans = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_booleans.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bound-fn + { + tmp0 := sym_bound_DASH_fn.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_fntail)), kw_doc, "Returns a function defined by the given fntail, which will install the\n same bindings in effect as in the thread at the time bound-fn was called.\n This may be used to define a helper function which runs on a different\n thread, but needs the same bindings in place.", kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(11), kw_line, int(2004), kw_end_DASH_line, int(2004))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym_glojure_DOT_core_SLASH_bound_DASH_fn_STAR_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := checkDerefVar(var_glojure_DOT_core_seq) + tmp11 := checkDerefVar(var_glojure_DOT_core_concat) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_glojure_DOT_core_SLASH_fn}) + tmp14 := lang.Apply(tmp11, []any{tmp13, v4}) + tmp15 := lang.Apply(tmp10, []any{tmp14}) + tmp16 := lang.Apply(tmp9, []any{tmp15}) + tmp17 := lang.Apply(tmp6, []any{tmp8, tmp16}) + tmp18 := lang.Apply(tmp5, []any{tmp17}) + return tmp18 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bound_DASH_fn = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bound_DASH_fn.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bound? + { + tmp0 := sym_bound_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_vars)), kw_doc, "Returns true if all of the vars provided as arguments have any bound value, root or thread-local.\n Implies that deref'ing the provided vars will succeed. Returns true if no vars are provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(5491), kw_end_DASH_line, int(5491))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v5 := args[0] + _ = v5 + tmp6, ok := lang.FieldOrMethod(v5, "isBound") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "isBound"))) + } + var tmp7 any + switch reflect.TypeOf(tmp6).Kind() { + case reflect.Func: + tmp7 = lang.Apply(tmp6, nil) + default: + tmp7 = tmp6 + } + return tmp7 + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5497), kw_column, int(11), kw_end_DASH_line, int(5497), kw_end_DASH_column, int(69)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp7 := lang.Apply(tmp3, []any{tmp6, v2}) + return tmp7 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bound_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bound_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bounded-count + { + tmp0 := sym_bounded_DASH_count.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n, sym_coll)), kw_doc, "If coll is counted? returns its count, else will count at most the first n\n elements of coll using its seq", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(7410), kw_end_DASH_line, int(7410))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_counted_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + tmp7 := checkDerefVar(var_glojure_DOT_core_count) + tmp8 := lang.Apply(tmp7, []any{v3}) + tmp4 = tmp8 + } else { + var tmp9 any + { // let + // let binding "i" + var v10 any = int64(0) + _ = v10 + // let binding "s" + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := lang.Apply(tmp11, []any{v3}) + var v13 any = tmp12 + _ = v13 + for { + var tmp14 any + var tmp15 any + { // let + // let binding "and__0__auto__" + var v16 any = v13 + _ = v16 + var tmp17 any + if lang.IsTruthy(v16) { + tmp18 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp19 := lang.Apply(tmp18, []any{v10, v2}) + tmp17 = tmp19 + } else { + tmp17 = v16 + } + tmp15 = tmp17 + } // end let + if lang.IsTruthy(tmp15) { + tmp17 := checkDerefVar(var_glojure_DOT_core_inc) + tmp18 := lang.Apply(tmp17, []any{v10}) + var tmp16 any = tmp18 + tmp20 := checkDerefVar(var_glojure_DOT_core_next) + tmp21 := lang.Apply(tmp20, []any{v13}) + var tmp19 any = tmp21 + v10 = tmp16 + v13 = tmp19 + continue + } else { + tmp14 = v10 + } + tmp9 = tmp14 + break + } + } // end let + tmp4 = tmp9 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bounded_DASH_count = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bounded_DASH_count.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // butlast + { + tmp0 := sym_butlast.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Return a seq of all but the last item in coll, in linear time", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(2), kw_line, int(272), kw_end_DASH_line, int(276))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function butlast + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + var tmp4 any + { // let + // let binding "ret" + tmp5 := lang.NewVector() + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(277), kw_column, int(23), kw_end_DASH_line, int(277), kw_end_DASH_column, int(24)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v8 any = tmp7 + _ = v8 + // let binding "s" + var v9 any = v3 + _ = v9 + for { + var tmp10 any + tmp11 := checkDerefVar(var_glojure_DOT_core_next) + tmp12 := lang.Apply(tmp11, []any{v9}) + if lang.IsTruthy(tmp12) { + tmp14 := checkDerefVar(var_glojure_DOT_core_conj) + tmp15 := checkDerefVar(var_glojure_DOT_core_first) + tmp16 := lang.Apply(tmp15, []any{v9}) + tmp17 := lang.Apply(tmp14, []any{v8, tmp16}) + var tmp13 any = tmp17 + tmp19 := checkDerefVar(var_glojure_DOT_core_next) + tmp20 := lang.Apply(tmp19, []any{v9}) + var tmp18 any = tmp20 + v8 = tmp13 + v9 = tmp18 + continue + } else { + tmp21 := checkDerefVar(var_glojure_DOT_core_seq) + tmp22 := lang.Apply(tmp21, []any{v8}) + tmp10 = tmp22 + } + tmp4 = tmp10 + break + } + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(276), kw_column, int(10), kw_end_DASH_line, int(280), kw_end_DASH_column, int(27))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_butlast = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_butlast.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // byte + { + var tmp1 lang.FnFunc + { // function byte__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp15) { + tmp14 = sym_uncheckedByteCast + } else { + tmp14 = sym_byteCast + } + tmp16 := lang.Apply(tmp13, []any{tmp14}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := lang.Apply(tmp12, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp11, []any{tmp19}) + tmp21 := lang.Apply(tmp10, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_byte.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to byte", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3505), kw_end_DASH_line, int(3505))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(lang.ByteCast, []any{v3}) + return tmp4 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_byte = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_byte.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // byte-array + { + var tmp1 lang.FnFunc + { // function byte-array__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_ByteArray}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_unquote_DASH_splicing}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_glojure_DOT_core_SLASH_args}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + } + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_byte_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_size_DASH_or_DASH_seq), lang.NewVector(sym_size, sym_init_DASH_val_DASH_or_DASH_seq)), kw_inline, tmp1, kw_doc, "Creates an array of bytes", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(5317), kw_end_DASH_line, int(5317))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "ByteArray") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ByteArray is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "ByteArrayInit") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ByteArrayInit is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_byte_DASH_array = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_byte_DASH_array.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bytes + { + var tmp1 lang.FnFunc + { // function bytes + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Bytes}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_bytes.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xs)), kw_inline, tmp1, kw_doc, "Casts to bytes[]", kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(12), kw_line, int(5377), kw_end_DASH_line, int(5377))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Bytes") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Bytes is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bytes = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bytes.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bytes? + { + tmp0 := sym_bytes_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a byte array", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(5412), kw_end_DASH_line, int(5412))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + tmp3 = false + } else { + tmp6 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp7 := checkDerefVar(var_glojure_DOT_core_class) + tmp8 := lang.Apply(tmp7, []any{v2}) + tmp9, ok := lang.FieldOrMethod(tmp8, "getComponentType") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp8, "getComponentType"))) + } + var tmp10 any + switch reflect.TypeOf(tmp9).Kind() { + case reflect.Func: + tmp10 = lang.Apply(tmp9, nil) + default: + tmp10 = tmp9 + } + tmp11 := lang.Apply(tmp6, []any{tmp10, nil}) + tmp3 = tmp11 + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bytes_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bytes_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // char + { + var tmp1 lang.FnFunc + { // function char__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp15) { + tmp14 = sym_uncheckedCharCast + } else { + tmp14 = sym_charCast + } + tmp16 := lang.Apply(tmp13, []any{tmp14}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := lang.Apply(tmp12, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp11, []any{tmp19}) + tmp21 := lang.Apply(tmp10, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_char.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_inline, tmp1, kw_doc, "Coerce to char", kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3511), kw_end_DASH_line, int(3511))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(runtime.RT, "CharCast") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("CharCast is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_char = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_char.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // char-array + { + var tmp1 lang.FnFunc + { // function char-array__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v3 any = lang.NewList(args[0:]...) + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_CharArray}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_unquote_DASH_splicing}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_glojure_DOT_core_SLASH_args}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp19}) + tmp21 := lang.Apply(tmp12, []any{tmp20}) + tmp22 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp21}) + tmp23 := lang.Apply(tmp4, []any{tmp22}) + return tmp23 + } + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_char_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_size_DASH_or_DASH_seq), lang.NewVector(sym_size, sym_init_DASH_val_DASH_or_DASH_seq)), kw_inline, tmp1, kw_doc, "Creates an array of chars", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(1), int64(2)})), kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(5325), kw_end_DASH_line, int(5325))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "CharArray") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("CharArray is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "CharArrayInit") + if reflect.TypeOf(tmp5).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("CharArrayInit is not a function"))) + } + tmp6 := lang.Apply(tmp5, []any{v3, v4}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_char_DASH_array = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_char_DASH_array.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // chars + { + var tmp1 lang.FnFunc + { // function chars + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_list) + tmp7 := lang.Apply(tmp6, []any{sym__DOT_}) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Chars}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_chars.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xs)), kw_inline, tmp1, kw_doc, "Casts to chars[]", kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(12), kw_line, int(5382), kw_end_DASH_line, int(5382))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Chars") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Chars is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_chars = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_chars.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // comp + { + tmp0 := sym_comp.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_f), lang.NewVector(sym_f, sym_g), lang.NewVector(sym_f, sym_g, sym__AMP_, sym_fs)), kw_doc, "Takes a set of functions and returns a fn that is the composition\n of those fns. The returned fn takes a variable number of args,\n applies the rightmost of fns to the args, the next\n fn (right-to-left) to the result, etc.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(2549), kw_end_DASH_line, int(2549))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp2 := checkDerefVar(var_glojure_DOT_core_identity) + return tmp2 + case 1: + v2 := args[0] + _ = v2 + return v2 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp5 := lang.Apply(v3, nil) + tmp6 := lang.Apply(v2, []any{tmp5}) + return tmp6 + case 1: + v5 := args[0] + _ = v5 + tmp6 := lang.Apply(v3, []any{v5}) + tmp7 := lang.Apply(v2, []any{tmp6}) + return tmp7 + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + tmp7 := lang.Apply(v3, []any{v5, v6}) + tmp8 := lang.Apply(v2, []any{tmp7}) + return tmp8 + case 3: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := args[2] + _ = v7 + tmp8 := lang.Apply(v3, []any{v5, v6, v7}) + tmp9 := lang.Apply(v2, []any{tmp8}) + return tmp9 + default: + checkArity(args, 3) + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := args[2] + _ = v7 + var v8 any = lang.NewList(args[3:]...) + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_apply) + tmp10 := lang.Apply(tmp9, []any{v3, v5, v6, v7, v8}) + tmp11 := lang.Apply(v2, []any{tmp10}) + return tmp11 + } + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2559), kw_column, int(6), kw_end_DASH_line, int(2564), kw_end_DASH_column, int(49)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp6 := checkDerefVar(var_glojure_DOT_core_comp) + tmp7 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp8 := lang.Apply(tmp7, []any{v2, v3, v4}) + tmp9 := lang.Apply(tmp5, []any{tmp6, tmp8}) + return tmp9 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_comp = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_comp.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // compare + { + var tmp1 lang.FnFunc + { // function compare__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_lang_DOT_Util}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_glojure_DOT_core_SLASH_compare}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{v3}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{v4}) + tmp17 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp12, tmp14, tmp16}) + tmp18 := lang.Apply(tmp5, []any{tmp17}) + return tmp18 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_compare.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_y)), kw_inline, tmp1, kw_doc, "Comparator. Returns a negative number, zero, or a positive number\n when x is logically 'less than', 'equal to', or 'greater than'\n y. Same as Java x.compareTo(y) except it also works for nil, and\n compares numbers and collections in a type-independent manner. x\n must implement Comparable", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(824), kw_end_DASH_line, int(824))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(lang.Compare, []any{v3, v4}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_compare = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_compare.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // complement + { + tmp0 := sym_complement.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f)), kw_doc, "Takes a fn f and returns a fn that takes the same arguments as f,\n has the same effects, if any, and returns the opposite truth value.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(1428), kw_end_DASH_line, int(1428))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp4 := checkDerefVar(var_glojure_DOT_core_not) + tmp5 := lang.Apply(v2, nil) + tmp6 := lang.Apply(tmp4, []any{tmp5}) + return tmp6 + case 1: + v4 := args[0] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_not) + tmp6 := lang.Apply(v2, []any{v4}) + tmp7 := lang.Apply(tmp5, []any{tmp6}) + return tmp7 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_not) + tmp7 := lang.Apply(v2, []any{v4, v5}) + tmp8 := lang.Apply(tmp6, []any{tmp7}) + return tmp8 + default: + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_not) + tmp8 := checkDerefVar(var_glojure_DOT_core_apply) + tmp9 := lang.Apply(tmp8, []any{v2, v4, v5, v6}) + tmp10 := lang.Apply(tmp7, []any{tmp9}) + return tmp10 + } + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(1434), kw_column, int(3), kw_end_DASH_line, int(1438), kw_end_DASH_column, int(40)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_complement = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_complement.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // data-reader-var + { + tmp0 := sym_data_DASH_reader_DASH_var.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7832), kw_column, int(8), kw_end_DASH_line, int(7832), kw_end_DASH_column, int(22), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_sym)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_intern) + tmp4 := checkDerefVar(var_glojure_DOT_core_create_DASH_ns) + tmp5 := checkDerefVar(var_glojure_DOT_core_symbol) + tmp6 := checkDerefVar(var_glojure_DOT_core_namespace) + tmp7 := lang.Apply(tmp6, []any{v2}) + tmp8 := lang.Apply(tmp5, []any{tmp7}) + tmp9 := lang.Apply(tmp4, []any{tmp8}) + tmp10 := checkDerefVar(var_glojure_DOT_core_symbol) + tmp11 := checkDerefVar(var_glojure_DOT_core_name) + tmp12 := lang.Apply(tmp11, []any{v2}) + tmp13 := lang.Apply(tmp10, []any{tmp12}) + tmp14 := lang.Apply(tmp3, []any{tmp9, tmp13}) + return tmp14 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_data_DASH_reader_DASH_var = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_data_DASH_reader_DASH_var.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // def-aset + { + tmp0 := sym_def_DASH_aset.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym_method, sym_coerce)), kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(3), kw_line, int(3935), kw_end_DASH_line, int(3936), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 5) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_core_SLASH_defn}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{v4}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_apply) + tmp15 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp16 := checkDerefVar(var_glojure_DOT_core_seq) + tmp17 := checkDerefVar(var_glojure_DOT_core_concat) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{kw_arglists}) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := checkDerefVar(var_glojure_DOT_core_seq) + tmp22 := checkDerefVar(var_glojure_DOT_core_concat) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := lang.Apply(tmp23, []any{sym_quote}) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := checkDerefVar(var_glojure_DOT_core_seq) + tmp27 := checkDerefVar(var_glojure_DOT_core_concat) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := checkDerefVar(var_glojure_DOT_core_apply) + tmp30 := checkDerefVar(var_glojure_DOT_core_vector) + tmp31 := checkDerefVar(var_glojure_DOT_core_seq) + tmp32 := checkDerefVar(var_glojure_DOT_core_concat) + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{sym_array}) + tmp35 := checkDerefVar(var_glojure_DOT_core_list) + tmp36 := lang.Apply(tmp35, []any{sym_idx}) + tmp37 := checkDerefVar(var_glojure_DOT_core_list) + tmp38 := lang.Apply(tmp37, []any{sym_val}) + tmp39 := lang.Apply(tmp32, []any{tmp34, tmp36, tmp38}) + tmp40 := lang.Apply(tmp31, []any{tmp39}) + tmp41 := lang.Apply(tmp29, []any{tmp30, tmp40}) + tmp42 := lang.Apply(tmp28, []any{tmp41}) + tmp43 := checkDerefVar(var_glojure_DOT_core_list) + tmp44 := checkDerefVar(var_glojure_DOT_core_apply) + tmp45 := checkDerefVar(var_glojure_DOT_core_vector) + tmp46 := checkDerefVar(var_glojure_DOT_core_seq) + tmp47 := checkDerefVar(var_glojure_DOT_core_concat) + tmp48 := checkDerefVar(var_glojure_DOT_core_list) + tmp49 := lang.Apply(tmp48, []any{sym_array}) + tmp50 := checkDerefVar(var_glojure_DOT_core_list) + tmp51 := lang.Apply(tmp50, []any{sym_idx}) + tmp52 := checkDerefVar(var_glojure_DOT_core_list) + tmp53 := lang.Apply(tmp52, []any{sym_idx2}) + tmp54 := checkDerefVar(var_glojure_DOT_core_list) + tmp55 := lang.Apply(tmp54, []any{sym__AMP_}) + tmp56 := checkDerefVar(var_glojure_DOT_core_list) + tmp57 := lang.Apply(tmp56, []any{sym_idxv}) + tmp58 := lang.Apply(tmp47, []any{tmp49, tmp51, tmp53, tmp55, tmp57}) + tmp59 := lang.Apply(tmp46, []any{tmp58}) + tmp60 := lang.Apply(tmp44, []any{tmp45, tmp59}) + tmp61 := lang.Apply(tmp43, []any{tmp60}) + tmp62 := lang.Apply(tmp27, []any{tmp42, tmp61}) + tmp63 := lang.Apply(tmp26, []any{tmp62}) + tmp64 := lang.Apply(tmp25, []any{tmp63}) + tmp65 := lang.Apply(tmp22, []any{tmp24, tmp64}) + tmp66 := lang.Apply(tmp21, []any{tmp65}) + tmp67 := lang.Apply(tmp20, []any{tmp66}) + tmp68 := lang.Apply(tmp17, []any{tmp19, tmp67}) + tmp69 := lang.Apply(tmp16, []any{tmp68}) + tmp70 := lang.Apply(tmp14, []any{tmp15, tmp69}) + tmp71 := lang.Apply(tmp13, []any{tmp70}) + tmp72 := checkDerefVar(var_glojure_DOT_core_list) + tmp73 := checkDerefVar(var_glojure_DOT_core_seq) + tmp74 := checkDerefVar(var_glojure_DOT_core_concat) + tmp75 := checkDerefVar(var_glojure_DOT_core_list) + tmp76 := checkDerefVar(var_glojure_DOT_core_apply) + tmp77 := checkDerefVar(var_glojure_DOT_core_vector) + tmp78 := checkDerefVar(var_glojure_DOT_core_seq) + tmp79 := checkDerefVar(var_glojure_DOT_core_concat) + tmp80 := checkDerefVar(var_glojure_DOT_core_list) + tmp81 := lang.Apply(tmp80, []any{sym_array__0__auto__}) + tmp82 := checkDerefVar(var_glojure_DOT_core_list) + tmp83 := lang.Apply(tmp82, []any{sym_idx__1__auto__}) + tmp84 := checkDerefVar(var_glojure_DOT_core_list) + tmp85 := lang.Apply(tmp84, []any{sym_val__2__auto__}) + tmp86 := lang.Apply(tmp79, []any{tmp81, tmp83, tmp85}) + tmp87 := lang.Apply(tmp78, []any{tmp86}) + tmp88 := lang.Apply(tmp76, []any{tmp77, tmp87}) + tmp89 := lang.Apply(tmp75, []any{tmp88}) + tmp90 := checkDerefVar(var_glojure_DOT_core_list) + tmp91 := checkDerefVar(var_glojure_DOT_core_seq) + tmp92 := checkDerefVar(var_glojure_DOT_core_concat) + tmp93 := checkDerefVar(var_glojure_DOT_core_list) + tmp94 := lang.Apply(tmp93, []any{sym__DOT_}) + tmp95 := checkDerefVar(var_glojure_DOT_core_list) + tmp96 := lang.Apply(tmp95, []any{sym_glojure_DOT_core_SLASH_Array}) + tmp97 := checkDerefVar(var_glojure_DOT_core_list) + tmp98 := checkDerefVar(var_glojure_DOT_core_seq) + tmp99 := checkDerefVar(var_glojure_DOT_core_concat) + tmp100 := checkDerefVar(var_glojure_DOT_core_list) + tmp101 := lang.Apply(tmp100, []any{v5}) + tmp102 := checkDerefVar(var_glojure_DOT_core_list) + tmp103 := lang.Apply(tmp102, []any{sym_array__0__auto__}) + tmp104 := checkDerefVar(var_glojure_DOT_core_list) + tmp105 := lang.Apply(tmp104, []any{sym_idx__1__auto__}) + tmp106 := checkDerefVar(var_glojure_DOT_core_list) + tmp107 := checkDerefVar(var_glojure_DOT_core_seq) + tmp108 := checkDerefVar(var_glojure_DOT_core_concat) + tmp109 := checkDerefVar(var_glojure_DOT_core_list) + tmp110 := lang.Apply(tmp109, []any{v6}) + tmp111 := checkDerefVar(var_glojure_DOT_core_list) + tmp112 := lang.Apply(tmp111, []any{sym_val__2__auto__}) + tmp113 := lang.Apply(tmp108, []any{tmp110, tmp112}) + tmp114 := lang.Apply(tmp107, []any{tmp113}) + tmp115 := lang.Apply(tmp106, []any{tmp114}) + tmp116 := lang.Apply(tmp99, []any{tmp101, tmp103, tmp105, tmp115}) + tmp117 := lang.Apply(tmp98, []any{tmp116}) + tmp118 := lang.Apply(tmp97, []any{tmp117}) + tmp119 := lang.Apply(tmp92, []any{tmp94, tmp96, tmp118}) + tmp120 := lang.Apply(tmp91, []any{tmp119}) + tmp121 := lang.Apply(tmp90, []any{tmp120}) + tmp122 := checkDerefVar(var_glojure_DOT_core_list) + tmp123 := lang.Apply(tmp122, []any{sym_val__2__auto__}) + tmp124 := lang.Apply(tmp74, []any{tmp89, tmp121, tmp123}) + tmp125 := lang.Apply(tmp73, []any{tmp124}) + tmp126 := lang.Apply(tmp72, []any{tmp125}) + tmp127 := checkDerefVar(var_glojure_DOT_core_list) + tmp128 := checkDerefVar(var_glojure_DOT_core_seq) + tmp129 := checkDerefVar(var_glojure_DOT_core_concat) + tmp130 := checkDerefVar(var_glojure_DOT_core_list) + tmp131 := checkDerefVar(var_glojure_DOT_core_apply) + tmp132 := checkDerefVar(var_glojure_DOT_core_vector) + tmp133 := checkDerefVar(var_glojure_DOT_core_seq) + tmp134 := checkDerefVar(var_glojure_DOT_core_concat) + tmp135 := checkDerefVar(var_glojure_DOT_core_list) + tmp136 := lang.Apply(tmp135, []any{sym_array__0__auto__}) + tmp137 := checkDerefVar(var_glojure_DOT_core_list) + tmp138 := lang.Apply(tmp137, []any{sym_idx__1__auto__}) + tmp139 := checkDerefVar(var_glojure_DOT_core_list) + tmp140 := lang.Apply(tmp139, []any{sym_idx2__3__auto__}) + tmp141 := checkDerefVar(var_glojure_DOT_core_list) + tmp142 := lang.Apply(tmp141, []any{sym__AMP_}) + tmp143 := checkDerefVar(var_glojure_DOT_core_list) + tmp144 := lang.Apply(tmp143, []any{sym_idxv__4__auto__}) + tmp145 := lang.Apply(tmp134, []any{tmp136, tmp138, tmp140, tmp142, tmp144}) + tmp146 := lang.Apply(tmp133, []any{tmp145}) + tmp147 := lang.Apply(tmp131, []any{tmp132, tmp146}) + tmp148 := lang.Apply(tmp130, []any{tmp147}) + tmp149 := checkDerefVar(var_glojure_DOT_core_list) + tmp150 := checkDerefVar(var_glojure_DOT_core_seq) + tmp151 := checkDerefVar(var_glojure_DOT_core_concat) + tmp152 := checkDerefVar(var_glojure_DOT_core_list) + tmp153 := lang.Apply(tmp152, []any{sym_glojure_DOT_core_SLASH_apply}) + tmp154 := checkDerefVar(var_glojure_DOT_core_list) + tmp155 := lang.Apply(tmp154, []any{v4}) + tmp156 := checkDerefVar(var_glojure_DOT_core_list) + tmp157 := checkDerefVar(var_glojure_DOT_core_seq) + tmp158 := checkDerefVar(var_glojure_DOT_core_concat) + tmp159 := checkDerefVar(var_glojure_DOT_core_list) + tmp160 := lang.Apply(tmp159, []any{sym_glojure_DOT_core_SLASH_aget}) + tmp161 := checkDerefVar(var_glojure_DOT_core_list) + tmp162 := lang.Apply(tmp161, []any{sym_array__0__auto__}) + tmp163 := checkDerefVar(var_glojure_DOT_core_list) + tmp164 := lang.Apply(tmp163, []any{sym_idx__1__auto__}) + tmp165 := lang.Apply(tmp158, []any{tmp160, tmp162, tmp164}) + tmp166 := lang.Apply(tmp157, []any{tmp165}) + tmp167 := lang.Apply(tmp156, []any{tmp166}) + tmp168 := checkDerefVar(var_glojure_DOT_core_list) + tmp169 := lang.Apply(tmp168, []any{sym_idx2__3__auto__}) + tmp170 := checkDerefVar(var_glojure_DOT_core_list) + tmp171 := lang.Apply(tmp170, []any{sym_idxv__4__auto__}) + tmp172 := lang.Apply(tmp151, []any{tmp153, tmp155, tmp167, tmp169, tmp171}) + tmp173 := lang.Apply(tmp150, []any{tmp172}) + tmp174 := lang.Apply(tmp149, []any{tmp173}) + tmp175 := lang.Apply(tmp129, []any{tmp148, tmp174}) + tmp176 := lang.Apply(tmp128, []any{tmp175}) + tmp177 := lang.Apply(tmp127, []any{tmp176}) + tmp178 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp71, tmp126, tmp177}) + tmp179 := lang.Apply(tmp7, []any{tmp178}) + return tmp179 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_def_DASH_aset = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_def_DASH_aset.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // definline + { + tmp0 := sym_definline.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym__AMP_, sym_decl)), kw_doc, "Experimental - like defmacro, except defines a named function whose\n body is the expansion, calls to which may be expanded inline as if\n it were a macro. Cannot be used with variadic (&) args.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(11), kw_line, int(5253), kw_end_DASH_line, int(5253))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "vec__771" + tmp7 := checkDerefVar(var_glojure_DOT_core_split_DASH_with) + tmp8 := checkDerefVar(var_glojure_DOT_core_comp) + tmp9 := checkDerefVar(var_glojure_DOT_core_not) + tmp10 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp11 := lang.Apply(tmp8, []any{tmp9, tmp10}) + tmp12 := lang.Apply(tmp7, []any{tmp11, v5}) + var v13 any = tmp12 + _ = v13 + // let binding "pre-args" + tmp14 := checkDerefVar(var_glojure_DOT_core_nth) + tmp15 := lang.Apply(tmp14, []any{v13, int64(0), nil}) + var v16 any = tmp15 + _ = v16 + // let binding "vec__774" + tmp17 := checkDerefVar(var_glojure_DOT_core_nth) + tmp18 := lang.Apply(tmp17, []any{v13, int64(1), nil}) + var v19 any = tmp18 + _ = v19 + // let binding "args" + tmp20 := checkDerefVar(var_glojure_DOT_core_nth) + tmp21 := lang.Apply(tmp20, []any{v19, int64(0), nil}) + var v22 any = tmp21 + _ = v22 + // let binding "expr" + tmp23 := checkDerefVar(var_glojure_DOT_core_nth) + tmp24 := lang.Apply(tmp23, []any{v19, int64(1), nil}) + var v25 any = tmp24 + _ = v25 + tmp26 := checkDerefVar(var_glojure_DOT_core_seq) + tmp27 := checkDerefVar(var_glojure_DOT_core_concat) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := lang.Apply(tmp28, []any{sym_do}) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := checkDerefVar(var_glojure_DOT_core_seq) + tmp32 := checkDerefVar(var_glojure_DOT_core_concat) + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{sym_glojure_DOT_core_SLASH_defn}) + tmp35 := checkDerefVar(var_glojure_DOT_core_list) + tmp36 := lang.Apply(tmp35, []any{v4}) + tmp37 := checkDerefVar(var_glojure_DOT_core_list) + tmp38 := lang.Apply(tmp37, []any{v22}) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := checkDerefVar(var_glojure_DOT_core_apply) + tmp41 := checkDerefVar(var_glojure_DOT_core_eval) + tmp42 := checkDerefVar(var_glojure_DOT_core_list) + tmp43 := lang.Apply(tmp42, []any{sym_glojure_DOT_core_SLASH_fn, v22, v25}) + tmp44 := lang.Apply(tmp41, []any{tmp43}) + tmp45 := lang.Apply(tmp40, []any{tmp44, v22}) + tmp46 := lang.Apply(tmp39, []any{tmp45}) + tmp47 := lang.Apply(tmp32, []any{tmp34, tmp36, v16, tmp38, tmp46}) + tmp48 := lang.Apply(tmp31, []any{tmp47}) + tmp49 := lang.Apply(tmp30, []any{tmp48}) + tmp50 := checkDerefVar(var_glojure_DOT_core_list) + tmp51 := checkDerefVar(var_glojure_DOT_core_seq) + tmp52 := checkDerefVar(var_glojure_DOT_core_concat) + tmp53 := checkDerefVar(var_glojure_DOT_core_list) + tmp54 := lang.Apply(tmp53, []any{sym_glojure_DOT_core_SLASH_alter_DASH_meta_BANG_}) + tmp55 := checkDerefVar(var_glojure_DOT_core_list) + tmp56 := checkDerefVar(var_glojure_DOT_core_seq) + tmp57 := checkDerefVar(var_glojure_DOT_core_concat) + tmp58 := checkDerefVar(var_glojure_DOT_core_list) + tmp59 := lang.Apply(tmp58, []any{sym_var}) + tmp60 := checkDerefVar(var_glojure_DOT_core_list) + tmp61 := lang.Apply(tmp60, []any{v4}) + tmp62 := lang.Apply(tmp57, []any{tmp59, tmp61}) + tmp63 := lang.Apply(tmp56, []any{tmp62}) + tmp64 := lang.Apply(tmp55, []any{tmp63}) + tmp65 := checkDerefVar(var_glojure_DOT_core_list) + tmp66 := lang.Apply(tmp65, []any{sym_glojure_DOT_core_SLASH_assoc}) + tmp67 := checkDerefVar(var_glojure_DOT_core_list) + tmp68 := lang.Apply(tmp67, []any{kw_inline}) + tmp69 := checkDerefVar(var_glojure_DOT_core_list) + tmp70 := checkDerefVar(var_glojure_DOT_core_seq) + tmp71 := checkDerefVar(var_glojure_DOT_core_concat) + tmp72 := checkDerefVar(var_glojure_DOT_core_list) + tmp73 := lang.Apply(tmp72, []any{sym_glojure_DOT_core_SLASH_fn}) + tmp74 := checkDerefVar(var_glojure_DOT_core_list) + tmp75 := lang.Apply(tmp74, []any{v4}) + tmp76 := checkDerefVar(var_glojure_DOT_core_list) + tmp77 := lang.Apply(tmp76, []any{v22}) + tmp78 := checkDerefVar(var_glojure_DOT_core_list) + tmp79 := lang.Apply(tmp78, []any{v25}) + tmp80 := lang.Apply(tmp71, []any{tmp73, tmp75, tmp77, tmp79}) + tmp81 := lang.Apply(tmp70, []any{tmp80}) + tmp82 := lang.Apply(tmp69, []any{tmp81}) + tmp83 := lang.Apply(tmp52, []any{tmp54, tmp64, tmp66, tmp68, tmp82}) + tmp84 := lang.Apply(tmp51, []any{tmp83}) + tmp85 := lang.Apply(tmp50, []any{tmp84}) + tmp86 := checkDerefVar(var_glojure_DOT_core_list) + tmp87 := checkDerefVar(var_glojure_DOT_core_seq) + tmp88 := checkDerefVar(var_glojure_DOT_core_concat) + tmp89 := checkDerefVar(var_glojure_DOT_core_list) + tmp90 := lang.Apply(tmp89, []any{sym_var}) + tmp91 := checkDerefVar(var_glojure_DOT_core_list) + tmp92 := lang.Apply(tmp91, []any{v4}) + tmp93 := lang.Apply(tmp88, []any{tmp90, tmp92}) + tmp94 := lang.Apply(tmp87, []any{tmp93}) + tmp95 := lang.Apply(tmp86, []any{tmp94}) + tmp96 := lang.Apply(tmp27, []any{tmp29, tmp49, tmp85, tmp95}) + tmp97 := lang.Apply(tmp26, []any{tmp96}) + tmp6 = tmp97 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_definline = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_definline.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // defmacro + { + tmp0 := sym_defmacro.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym_doc_DASH_string_QMARK_, sym_attr_DASH_map_QMARK_, lang.NewVector(sym_params_STAR_), sym_body), lang.NewVector(sym_name, sym_doc_DASH_string_QMARK_, sym_attr_DASH_map_QMARK_, lang.NewList(lang.NewVector(sym_params_STAR_), sym_body), sym__PLUS_, sym_attr_DASH_map_QMARK_)), kw_doc, "Like defn, but the resulting function name is declared as a\n macro and will be used as a macro by the compiler when it is\n called.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(2), kw_line, int(445), kw_end_DASH_line, int(451))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "prefix" + var tmp7 any + { // let + // let binding "p" + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{v4}) + var v10 any = tmp9 + _ = v10 + // let binding "args" + var v11 any = v5 + _ = v11 + for { + var tmp12 any + { // let + // let binding "f" + tmp13 := checkDerefVar(var_glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v11}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + tmp17 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp18 := lang.Apply(tmp17, []any{v15}) + if lang.IsTruthy(tmp18) { + tmp20 := checkDerefVar(var_glojure_DOT_core_cons) + tmp21 := lang.Apply(tmp20, []any{v15, v10}) + var tmp19 any = tmp21 + tmp23 := checkDerefVar(var_glojure_DOT_core_next) + tmp24 := lang.Apply(tmp23, []any{v11}) + var tmp22 any = tmp24 + v10 = tmp19 + v11 = tmp22 + continue + } else { + var tmp25 any + tmp26 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp27 := lang.Apply(tmp26, []any{v15}) + if lang.IsTruthy(tmp27) { + tmp29 := checkDerefVar(var_glojure_DOT_core_cons) + tmp30 := lang.Apply(tmp29, []any{v15, v10}) + var tmp28 any = tmp30 + tmp32 := checkDerefVar(var_glojure_DOT_core_next) + tmp33 := lang.Apply(tmp32, []any{v11}) + var tmp31 any = tmp33 + v10 = tmp28 + v11 = tmp31 + continue + } else { + tmp25 = v10 + } + tmp16 = tmp25 + } + tmp12 = tmp16 + } // end let + tmp7 = tmp12 + break + } + } // end let + var v8 any = tmp7 + _ = v8 + // let binding "fdecl" + var tmp9 any + { // let + // let binding "fd" + var v10 any = v5 + _ = v10 + for { + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp13 := checkDerefVar(var_glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v10}) + tmp15 := lang.Apply(tmp12, []any{tmp14}) + if lang.IsTruthy(tmp15) { + tmp17 := checkDerefVar(var_glojure_DOT_core_next) + tmp18 := lang.Apply(tmp17, []any{v10}) + var tmp16 any = tmp18 + v10 = tmp16 + continue + } else { + var tmp19 any + tmp20 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp21 := checkDerefVar(var_glojure_DOT_core_first) + tmp22 := lang.Apply(tmp21, []any{v10}) + tmp23 := lang.Apply(tmp20, []any{tmp22}) + if lang.IsTruthy(tmp23) { + tmp25 := checkDerefVar(var_glojure_DOT_core_next) + tmp26 := lang.Apply(tmp25, []any{v10}) + var tmp24 any = tmp26 + v10 = tmp24 + continue + } else { + tmp19 = v10 + } + tmp11 = tmp19 + } + tmp9 = tmp11 + break + } + } // end let + var v10 any = tmp9 + _ = v10 + // let binding "fdecl" + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp13 := checkDerefVar(var_glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v10}) + tmp15 := lang.Apply(tmp12, []any{tmp14}) + if lang.IsTruthy(tmp15) { + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v10}) + tmp11 = tmp17 + } else { + tmp11 = v10 + } + var v18 any = tmp11 + _ = v18 + // let binding "add-implicit-args" + var tmp19 lang.FnFunc + tmp19 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v20 := args[0] + _ = v20 + var tmp21 any + { // let + // let binding "args" + tmp22 := checkDerefVar(var_glojure_DOT_core_first) + tmp23 := lang.Apply(tmp22, []any{v20}) + var v24 any = tmp23 + _ = v24 + tmp25 := checkDerefVar(var_glojure_DOT_core_cons) + tmp26 := checkDerefVar(var_glojure_DOT_core_vec) + tmp27 := checkDerefVar(var_glojure_DOT_core_cons) + tmp28 := checkDerefVar(var_glojure_DOT_core_cons) + tmp29 := lang.Apply(tmp28, []any{sym__AMP_env, v24}) + tmp30 := lang.Apply(tmp27, []any{sym__AMP_form, tmp29}) + tmp31 := lang.Apply(tmp26, []any{tmp30}) + tmp32 := checkDerefVar(var_glojure_DOT_core_next) + tmp33 := lang.Apply(tmp32, []any{v20}) + tmp34 := lang.Apply(tmp25, []any{tmp31, tmp33}) + tmp21 = tmp34 + } // end let + return tmp21 + }) + tmp20 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(469), kw_column, int(38), kw_end_DASH_line, int(471), kw_end_DASH_column, int(87)) + tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v22 any = tmp21 + _ = v22 + // let binding "add-args" + var tmp23 lang.FnFunc + tmp23 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v24 := args[0] + _ = v24 + v25 := args[1] + _ = v25 + recur_loop_1601: + var tmp26 any + tmp27 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp28 := lang.Apply(tmp27, []any{v25}) + if lang.IsTruthy(tmp28) { + tmp26 = v24 + } else { + var tmp29 any + { // let + // let binding "d" + tmp30 := checkDerefVar(var_glojure_DOT_core_first) + tmp31 := lang.Apply(tmp30, []any{v25}) + var v32 any = tmp31 + _ = v32 + var tmp33 any + tmp34 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp35 := lang.Apply(tmp34, []any{v32}) + if lang.IsTruthy(tmp35) { + tmp36 := checkDerefVar(var_glojure_DOT_core_conj) + tmp37 := lang.Apply(tmp36, []any{v24, v32}) + tmp33 = tmp37 + } else { + tmp39 := checkDerefVar(var_glojure_DOT_core_conj) + tmp40 := lang.Apply(v22, []any{v32}) + tmp41 := lang.Apply(tmp39, []any{v24, tmp40}) + var tmp38 any = tmp41 + tmp43 := checkDerefVar(var_glojure_DOT_core_next) + tmp44 := lang.Apply(tmp43, []any{v25}) + var tmp42 any = tmp44 + v24 = tmp38 + v25 = tmp42 + goto recur_loop_1601 + } + tmp29 = tmp33 + } // end let + tmp26 = tmp29 + } + return tmp26 + }) + tmp24 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(472), kw_column, int(29), kw_end_DASH_line, int(478), kw_end_DASH_column, int(90)) + tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v26 any = tmp25 + _ = v26 + // let binding "fdecl" + tmp27 := checkDerefVar(var_glojure_DOT_core_seq) + tmp28 := lang.NewVector() + tmp29 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(479), kw_column, int(41), kw_end_DASH_line, int(479), kw_end_DASH_column, int(42)) + tmp30, err := lang.WithMeta(tmp28, tmp29.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp31 := lang.Apply(v26, []any{tmp30, v18}) + tmp32 := lang.Apply(tmp27, []any{tmp31}) + var v33 any = tmp32 + _ = v33 + // let binding "decl" + var tmp34 any + { // let + // let binding "p" + var v35 any = v8 + _ = v35 + // let binding "d" + var v36 any = v33 + _ = v36 + for { + var tmp37 any + if lang.IsTruthy(v35) { + tmp39 := checkDerefVar(var_glojure_DOT_core_next) + tmp40 := lang.Apply(tmp39, []any{v35}) + var tmp38 any = tmp40 + tmp42 := checkDerefVar(var_glojure_DOT_core_cons) + tmp43 := checkDerefVar(var_glojure_DOT_core_first) + tmp44 := lang.Apply(tmp43, []any{v35}) + tmp45 := lang.Apply(tmp42, []any{tmp44, v36}) + var tmp41 any = tmp45 + v35 = tmp38 + v36 = tmp41 + continue + } else { + tmp37 = v36 + } + tmp34 = tmp37 + break + } + } // end let + var v35 any = tmp34 + _ = v35 + tmp36 := checkDerefVar(var_glojure_DOT_core_list) + tmp37 := checkDerefVar(var_glojure_DOT_core_cons) + tmp38 := lang.Apply(tmp37, []any{sym_glojure_DOT_core_SLASH_defn, v35}) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{sym_var, v4}) + tmp42 := lang.Apply(tmp39, []any{sym__DOT_, tmp41, lang.NewList(sym_SetMacro)}) + tmp43 := checkDerefVar(var_glojure_DOT_core_list) + tmp44 := lang.Apply(tmp43, []any{sym_var, v4}) + tmp45 := lang.Apply(tmp36, []any{sym_do, tmp38, tmp42, tmp44}) + tmp6 = tmp45 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(451), kw_column, int(11), kw_end_DASH_line, int(487), kw_end_DASH_column, int(40))).(lang.FnFunc) + var_glojure_DOT_core_defmacro = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_defmacro.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // defn + { + tmp0 := sym_defn.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym_doc_DASH_string_QMARK_, sym_attr_DASH_map_QMARK_, lang.NewVector(sym_params_STAR_), sym_prepost_DASH_map_QMARK_, sym_body), lang.NewVector(sym_name, sym_doc_DASH_string_QMARK_, sym_attr_DASH_map_QMARK_, lang.NewList(lang.NewVector(sym_params_STAR_), sym_prepost_DASH_map_QMARK_, sym_body), sym__PLUS_, sym_attr_DASH_map_QMARK_)), kw_doc, "Same as (def name (fn [params* ] exprs*)) or (def\n name (fn ([params* ] exprs*)+)) with any doc-string or attrs added\n to the var metadata. prepost-map defines a map with optional keys\n :pre and :post that contain collections of pre or post conditions.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(5), kw_column, int(2), kw_line, int(284), kw_end_DASH_line, int(291))).(*lang.Symbol) + var tmp1 lang.FnFunc + { // function defn + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp9 := reflect.TypeOf((*lang.Symbol)(nil)) + tmp10 := lang.Apply(tmp8, []any{tmp9, v5}) + if lang.IsTruthy(tmp10) { + } else { + tmp11 := lang.Apply(lang.NewIllegalArgumentError, []any{"First argument to defn must be a symbol"}) + panic(tmp11) + } + _ = tmp7 + var tmp12 any + { // let + // let binding "m" + var tmp13 any + tmp14 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp15 := checkDerefVar(var_glojure_DOT_core_first) + tmp16 := lang.Apply(tmp15, []any{v6}) + tmp17 := lang.Apply(tmp14, []any{tmp16}) + if lang.IsTruthy(tmp17) { + tmp18 := checkDerefVar(var_glojure_DOT_core_first) + tmp19 := lang.Apply(tmp18, []any{v6}) + tmp20 := lang.NewMap(kw_doc, tmp19) + tmp21 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(297), kw_column, int(19), kw_end_DASH_line, int(297), kw_end_DASH_column, int(38)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 = tmp22 + } else { + tmp23 := lang.NewMap() + tmp24 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(298), kw_column, int(19), kw_end_DASH_line, int(298), kw_end_DASH_column, int(20)) + tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 = tmp25 + } + var v26 any = tmp13 + _ = v26 + // let binding "fdecl" + var tmp27 any + tmp28 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp29 := checkDerefVar(var_glojure_DOT_core_first) + tmp30 := lang.Apply(tmp29, []any{v6}) + tmp31 := lang.Apply(tmp28, []any{tmp30}) + if lang.IsTruthy(tmp31) { + tmp32 := checkDerefVar(var_glojure_DOT_core_next) + tmp33 := lang.Apply(tmp32, []any{v6}) + tmp27 = tmp33 + } else { + tmp27 = v6 + } + var v34 any = tmp27 + _ = v34 + // let binding "m" + var tmp35 any + tmp36 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp37 := checkDerefVar(var_glojure_DOT_core_first) + tmp38 := lang.Apply(tmp37, []any{v34}) + tmp39 := lang.Apply(tmp36, []any{tmp38}) + if lang.IsTruthy(tmp39) { + tmp40 := checkDerefVar(var_glojure_DOT_core_conj) + tmp41 := checkDerefVar(var_glojure_DOT_core_first) + tmp42 := lang.Apply(tmp41, []any{v34}) + tmp43 := lang.Apply(tmp40, []any{v26, tmp42}) + tmp35 = tmp43 + } else { + tmp35 = v26 + } + var v44 any = tmp35 + _ = v44 + // let binding "fdecl" + var tmp45 any + tmp46 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp47 := checkDerefVar(var_glojure_DOT_core_first) + tmp48 := lang.Apply(tmp47, []any{v34}) + tmp49 := lang.Apply(tmp46, []any{tmp48}) + if lang.IsTruthy(tmp49) { + tmp50 := checkDerefVar(var_glojure_DOT_core_next) + tmp51 := lang.Apply(tmp50, []any{v34}) + tmp45 = tmp51 + } else { + tmp45 = v34 + } + var v52 any = tmp45 + _ = v52 + // let binding "fdecl" + var tmp53 any + tmp54 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp55 := checkDerefVar(var_glojure_DOT_core_first) + tmp56 := lang.Apply(tmp55, []any{v52}) + tmp57 := lang.Apply(tmp54, []any{tmp56}) + if lang.IsTruthy(tmp57) { + tmp58 := checkDerefVar(var_glojure_DOT_core_list) + tmp59 := lang.Apply(tmp58, []any{v52}) + tmp53 = tmp59 + } else { + tmp53 = v52 + } + var v60 any = tmp53 + _ = v60 + // let binding "m" + var tmp61 any + tmp62 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp63 := checkDerefVar(var_glojure_DOT_core_last) + tmp64 := lang.Apply(tmp63, []any{v60}) + tmp65 := lang.Apply(tmp62, []any{tmp64}) + if lang.IsTruthy(tmp65) { + tmp66 := checkDerefVar(var_glojure_DOT_core_conj) + tmp67 := checkDerefVar(var_glojure_DOT_core_last) + tmp68 := lang.Apply(tmp67, []any{v60}) + tmp69 := lang.Apply(tmp66, []any{v44, tmp68}) + tmp61 = tmp69 + } else { + tmp61 = v44 + } + var v70 any = tmp61 + _ = v70 + // let binding "fdecl" + var tmp71 any + tmp72 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp73 := checkDerefVar(var_glojure_DOT_core_last) + tmp74 := lang.Apply(tmp73, []any{v60}) + tmp75 := lang.Apply(tmp72, []any{tmp74}) + if lang.IsTruthy(tmp75) { + tmp76 := checkDerefVar(var_glojure_DOT_core_butlast) + tmp77 := lang.Apply(tmp76, []any{v60}) + tmp71 = tmp77 + } else { + tmp71 = v60 + } + var v78 any = tmp71 + _ = v78 + // let binding "m" + tmp79 := checkDerefVar(var_glojure_DOT_core_conj) + tmp80 := checkDerefVar(var_glojure_DOT_core_list) + tmp81 := checkDerefVar(var_glojure_DOT_core_sigs) + tmp82 := lang.Apply(tmp81, []any{v78}) + tmp83 := lang.Apply(tmp80, []any{sym_quote, tmp82}) + tmp84 := lang.NewMap(kw_arglists, tmp83) + tmp85 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(317), kw_column, int(23), kw_end_DASH_line, int(317), kw_end_DASH_column, int(60)) + tmp86, err := lang.WithMeta(tmp84, tmp85.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp87 := lang.Apply(tmp79, []any{tmp86, v70}) + var v88 any = tmp87 + _ = v88 + // let binding "m" + var tmp89 any + { // let + // let binding "inline" + tmp90 := lang.Apply(kw_inline, []any{v88}) + var v91 any = tmp90 + _ = v91 + // let binding "ifn" + tmp92 := checkDerefVar(var_glojure_DOT_core_first) + tmp93 := lang.Apply(tmp92, []any{v91}) + var v94 any = tmp93 + _ = v94 + // let binding "iname" + tmp95 := checkDerefVar(var_glojure_DOT_core_second) + tmp96 := lang.Apply(tmp95, []any{v91}) + var v97 any = tmp96 + _ = v97 + var tmp98 any + var tmp99 any + tmp100 := lang.Apply(lang.Equiv, []any{sym_fn, v94}) + if lang.IsTruthy(tmp100) { + var tmp101 any + tmp102 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp103 := reflect.TypeOf((*lang.Symbol)(nil)) + tmp104 := lang.Apply(tmp102, []any{tmp103, v97}) + if lang.IsTruthy(tmp104) { + tmp101 = false + } else { + tmp101 = true + } + tmp99 = tmp101 + } else { + } + if lang.IsTruthy(tmp99) { + tmp105 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp106 := checkDerefVar(var_glojure_DOT_core_cons) + tmp107 := checkDerefVar(var_glojure_DOT_core_cons) + tmp108, ok := lang.FieldOrMethod(v5, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "Name"))) + } + var tmp109 any + switch reflect.TypeOf(tmp108).Kind() { + case reflect.Func: + tmp109 = lang.Apply(tmp108, nil) + default: + tmp109 = tmp108 + } + tmp110 := lang.Apply(lang.ConcatStrings, []any{tmp109, "__inliner"}) + tmp111 := lang.Apply(lang.NewSymbol, []any{tmp110}) + tmp112 := checkDerefVar(var_glojure_DOT_core_next) + tmp113 := lang.Apply(tmp112, []any{v91}) + tmp114 := lang.Apply(tmp107, []any{tmp111, tmp113}) + tmp115 := lang.Apply(tmp106, []any{v94, tmp114}) + tmp116 := lang.Apply(tmp105, []any{v88, kw_inline, tmp115}) + tmp98 = tmp116 + } else { + tmp98 = v88 + } + tmp89 = tmp98 + } // end let + var v90 any = tmp89 + _ = v90 + // let binding "m" + tmp91 := checkDerefVar(var_glojure_DOT_core_conj) + var tmp92 any + tmp93 := checkDerefVar(var_glojure_DOT_core_meta) + tmp94 := lang.Apply(tmp93, []any{v5}) + if lang.IsTruthy(tmp94) { + tmp95 := checkDerefVar(var_glojure_DOT_core_meta) + tmp96 := lang.Apply(tmp95, []any{v5}) + tmp92 = tmp96 + } else { + tmp97 := lang.NewMap() + tmp98 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(328), kw_column, int(51), kw_end_DASH_line, int(328), kw_end_DASH_column, int(52)) + tmp99, err := lang.WithMeta(tmp97, tmp98.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp92 = tmp99 + } + tmp100 := lang.Apply(tmp91, []any{tmp92, v90}) + var v101 any = tmp100 + _ = v101 + tmp102 := checkDerefVar(var_glojure_DOT_core_list) + tmp103 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp104 := lang.Apply(tmp103, []any{v5, v101}) + tmp105 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp106 := checkDerefVar(var_glojure_DOT_core_cons) + tmp107 := lang.Apply(tmp106, []any{sym_glojure_DOT_core_SLASH_fn, v78}) + tmp108 := lang.Apply(kw_tag, []any{v101}) + tmp109 := lang.NewMap(kw_rettag, tmp108) + tmp110 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(333), kw_column, int(37), kw_end_DASH_line, int(333), kw_end_DASH_column, int(54)) + tmp111, err := lang.WithMeta(tmp109, tmp110.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp112 := lang.Apply(tmp105, []any{tmp107, tmp111}) + tmp113 := lang.Apply(tmp102, []any{sym_def, tmp104, tmp112}) + tmp12 = tmp113 + } // end let + return tmp12 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(291), kw_column, int(7), kw_end_DASH_line, int(333), kw_end_DASH_column, int(58))).(lang.FnFunc) + v2 = tmp1 + _ = v2 + } + var_glojure_DOT_core_defn = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_defn.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // defn- + { + tmp0 := sym_defn_DASH_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym__AMP_, sym_decls)), kw_doc, "same as defn, yielding non-public def", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(11), kw_line, int(4949), kw_end_DASH_line, int(4949))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp7 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp8 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp9 := checkDerefVar(var_glojure_DOT_core_meta) + tmp10 := lang.Apply(tmp9, []any{v4}) + tmp11 := lang.Apply(tmp8, []any{tmp10, kw_private, true}) + tmp12 := lang.Apply(tmp7, []any{v4, tmp11}) + tmp13 := lang.Apply(tmp6, []any{sym_glojure_DOT_core_SLASH_defn, tmp12, v5}) + return tmp13 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_defn_DASH_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_defn_DASH_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // defonce + { + tmp0 := sym_defonce.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym_expr)), kw_doc, "defs name to have the root value of the expr iff the named var has no root value,\n else expr is unevaluated", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(5806), kw_end_DASH_line, int(5806))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_let}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + tmp12 := checkDerefVar(var_glojure_DOT_core_vector) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_v__0__auto__}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{sym_def}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v4}) + tmp24 := lang.Apply(tmp19, []any{tmp21, tmp23}) + tmp25 := lang.Apply(tmp18, []any{tmp24}) + tmp26 := lang.Apply(tmp17, []any{tmp25}) + tmp27 := lang.Apply(tmp14, []any{tmp16, tmp26}) + tmp28 := lang.Apply(tmp13, []any{tmp27}) + tmp29 := lang.Apply(tmp11, []any{tmp12, tmp28}) + tmp30 := lang.Apply(tmp10, []any{tmp29}) + tmp31 := checkDerefVar(var_glojure_DOT_core_list) + tmp32 := checkDerefVar(var_glojure_DOT_core_seq) + tmp33 := checkDerefVar(var_glojure_DOT_core_concat) + tmp34 := checkDerefVar(var_glojure_DOT_core_list) + tmp35 := lang.Apply(tmp34, []any{sym_glojure_DOT_core_SLASH_when_DASH_not}) + tmp36 := checkDerefVar(var_glojure_DOT_core_list) + tmp37 := checkDerefVar(var_glojure_DOT_core_seq) + tmp38 := checkDerefVar(var_glojure_DOT_core_concat) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := lang.Apply(tmp39, []any{sym__DOT_HasRoot}) + tmp41 := checkDerefVar(var_glojure_DOT_core_list) + tmp42 := lang.Apply(tmp41, []any{sym_v__0__auto__}) + tmp43 := lang.Apply(tmp38, []any{tmp40, tmp42}) + tmp44 := lang.Apply(tmp37, []any{tmp43}) + tmp45 := lang.Apply(tmp36, []any{tmp44}) + tmp46 := checkDerefVar(var_glojure_DOT_core_list) + tmp47 := checkDerefVar(var_glojure_DOT_core_seq) + tmp48 := checkDerefVar(var_glojure_DOT_core_concat) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) + tmp50 := lang.Apply(tmp49, []any{sym_def}) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := lang.Apply(tmp51, []any{v4}) + tmp53 := checkDerefVar(var_glojure_DOT_core_list) + tmp54 := lang.Apply(tmp53, []any{v5}) + tmp55 := lang.Apply(tmp48, []any{tmp50, tmp52, tmp54}) + tmp56 := lang.Apply(tmp47, []any{tmp55}) + tmp57 := lang.Apply(tmp46, []any{tmp56}) + tmp58 := lang.Apply(tmp33, []any{tmp35, tmp45, tmp57}) + tmp59 := lang.Apply(tmp32, []any{tmp58}) + tmp60 := lang.Apply(tmp31, []any{tmp59}) + tmp61 := lang.Apply(tmp7, []any{tmp9, tmp30, tmp60}) + tmp62 := lang.Apply(tmp6, []any{tmp61}) + return tmp62 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_defonce = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_defonce.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // delay + { + tmp0 := sym_delay.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_body)), kw_doc, "Takes a body of expressions and yields a Delay object that will\n invoke the body only the first time it is forced (with force or deref/@), and\n will cache the result and return it on all subsequent force\n calls. See also - realized?", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(11), kw_line, int(739), kw_end_DASH_line, int(739))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_list) + tmp6 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp7 := lang.NewVector() + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(746), kw_column, int(62), kw_end_DASH_line, int(746), kw_end_DASH_column, int(63)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp10 := lang.Apply(tmp6, []any{sym_fn_STAR_, tmp9, v4}) + tmp11 := lang.Apply(tmp5, []any{sym_new, sym_glojure_DOT_lang_DOT_Delay, tmp10}) + return tmp11 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_delay = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_delay.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // deref-as-map + { + tmp0 := sym_deref_DASH_as_DASH_map.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(408), kw_column, int(8), kw_end_DASH_line, int(408), kw_end_DASH_column, int(19), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_o)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "pending" + var tmp4 any + { // let + // let binding "and__0__auto__" + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp6 := reflect.TypeOf((*lang.IPending)(nil)).Elem() + tmp7 := lang.Apply(tmp5, []any{tmp6, v2}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + tmp10 := checkDerefVar(var_glojure_DOT_core_not) + tmp11, ok := lang.FieldOrMethod(v2, "isRealized") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "isRealized"))) + } + var tmp12 any + switch reflect.TypeOf(tmp11).Kind() { + case reflect.Func: + tmp12 = lang.Apply(tmp11, nil) + default: + tmp12 = tmp11 + } + tmp13 := lang.Apply(tmp10, []any{tmp12}) + tmp9 = tmp13 + } else { + tmp9 = v8 + } + tmp4 = tmp9 + } // end let + var v5 any = tmp4 + _ = v5 + // let binding "vec__941" + var tmp6 any + if lang.IsTruthy(v5) { + } else { + var tmp7 any + func() { + defer func() { + if r := recover(); r != nil { + if lang.CatchMatches(r, lang.Throwable) { + v8 := r + _ = v8 + tmp9 := lang.NewVector(true, v8) + tmp10 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(415), kw_column, int(18), kw_end_DASH_line, int(415), kw_end_DASH_column, int(25)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp7 = tmp11 + } else { + panic(r) + } + } + }() + tmp8 := checkDerefVar(var_glojure_DOT_core_deref) + tmp9 := lang.Apply(tmp8, []any{v2}) + tmp10 := lang.NewVector(false, tmp9) + tmp11 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(413), kw_column, int(16), kw_end_DASH_line, int(413), kw_end_DASH_column, int(32)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp7 = tmp12 + }() + tmp6 = tmp7 + } + var v13 any = tmp6 + _ = v13 + // let binding "ex" + tmp14 := checkDerefVar(var_glojure_DOT_core_nth) + tmp15 := lang.Apply(tmp14, []any{v13, int64(0), nil}) + var v16 any = tmp15 + _ = v16 + // let binding "val" + tmp17 := checkDerefVar(var_glojure_DOT_core_nth) + tmp18 := lang.Apply(tmp17, []any{v13, int64(1), nil}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + var tmp21 any + { // let + // let binding "or__0__auto__" + var v22 any = v16 + _ = v22 + var tmp23 any + if lang.IsTruthy(v22) { + tmp23 = v22 + } else { + var tmp24 any + { // let + // let binding "and__0__auto__" + tmp25 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp26 := reflect.TypeOf((*lang.Agent)(nil)) + tmp27 := lang.Apply(tmp25, []any{tmp26, v2}) + var v28 any = tmp27 + _ = v28 + var tmp29 any + if lang.IsTruthy(v28) { + tmp30 := checkDerefVar(var_glojure_DOT_core_agent_DASH_error) + tmp31 := lang.Apply(tmp30, []any{v2}) + tmp29 = tmp31 + } else { + tmp29 = v28 + } + tmp24 = tmp29 + } // end let + tmp23 = tmp24 + } + tmp21 = tmp23 + } // end let + if lang.IsTruthy(tmp21) { + tmp20 = kw_failed + } else { + var tmp22 any + if lang.IsTruthy(v5) { + tmp22 = kw_pending + } else { + var tmp23 any + if lang.IsTruthy(kw_else) { + tmp23 = kw_ready + } else { + } + tmp22 = tmp23 + } + tmp20 = tmp22 + } + tmp24 := lang.NewMap(kw_status, tmp20, kw_val, v19) + tmp25 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(416), kw_column, int(5), kw_end_DASH_line, int(429), kw_end_DASH_column, int(14)) + tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp3 = tmp26 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_deref_DASH_as_DASH_map = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_deref_DASH_as_DASH_map.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // descendants + { + tmp0 := sym_descendants.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_tag), lang.NewVector(sym_h, sym_tag)), kw_doc, "Returns the immediate and indirect children of tag, through a\n relationship established via derive. h must be a hierarchy obtained\n from make-hierarchy, if not supplied defaults to the global\n hierarchy. Note: does not work on Java type inheritance\n relationships.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(5593), kw_end_DASH_line, int(5593))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_descendants) + tmp4 := checkDerefVar(var_glojure_DOT_core_global_DASH_hierarchy) + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_class_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + tmp7 := lang.Apply(lang.NewUnsupportedOperationError, []any{"Can't get descendants of classes"}) + panic(tmp7) + } else { + tmp8 := checkDerefVar(var_glojure_DOT_core_not_DASH_empty) + tmp9 := checkDerefVar(var_glojure_DOT_core_get) + tmp10 := lang.Apply(kw_descendants, []any{v2}) + tmp11 := lang.Apply(tmp9, []any{tmp10, v3}) + tmp12 := lang.Apply(tmp8, []any{tmp11}) + tmp4 = tmp12 + } + return tmp4 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_descendants = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_descendants.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // distinct + { + tmp0 := sym_distinct.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_coll)), kw_doc, "Returns a lazy sequence of the elements of coll with duplicates removed.\n Returns a stateful transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(5053), kw_end_DASH_line, int(5053))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + var tmp4 any + { // let + // let binding "seen" + tmp5 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) + tmp6 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5060), kw_column, int(28), kw_end_DASH_line, int(5060), kw_end_DASH_column, int(30)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp9 := lang.Apply(tmp5, []any{tmp8}) + var v10 any = tmp9 + _ = v10 + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp12 := lang.Apply(v3, nil) + return tmp12 + case 1: + v12 := args[0] + _ = v12 + tmp13 := lang.Apply(v3, []any{v12}) + return tmp13 + case 2: + v12 := args[0] + _ = v12 + v13 := args[1] + _ = v13 + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp16 := checkDerefVar(var_glojure_DOT_core_deref) + tmp17 := lang.Apply(tmp16, []any{v10}) + tmp18 := lang.Apply(tmp15, []any{tmp17, v13}) + if lang.IsTruthy(tmp18) { + tmp14 = v12 + } else { + tmp19 := checkDerefVar(var_glojure_DOT_core_conj) + tmp20, ok := lang.FieldOrMethod(v10, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v10, "Deref"))) + } + var tmp21 any + switch reflect.TypeOf(tmp20).Kind() { + case reflect.Func: + tmp21 = lang.Apply(tmp20, nil) + default: + tmp21 = tmp20 + } + tmp22 := lang.Apply(tmp19, []any{tmp21, v13}) + tmp23, _ := lang.FieldOrMethod(v10, "reset") + if reflect.TypeOf(tmp23).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) + } + tmp24 := lang.Apply(tmp23, []any{tmp22}) + _ = tmp24 + tmp25 := lang.Apply(v3, []any{v12, v13}) + tmp14 = tmp25 + } + return tmp14 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5061), kw_column, int(8), kw_end_DASH_line, int(5068), kw_end_DASH_column, int(37)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp4 = tmp13 + } // end let + return tmp4 + }) + tmp3 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5059), kw_column, int(4), kw_end_DASH_line, int(5068), kw_end_DASH_column, int(39)) + tmp4, err := lang.WithMeta(tmp2, tmp3.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp4 + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "step" + var tmp4 lang.FnFunc + { // function step + var v5 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + var tmp8 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + recur_loop_2417: + var tmp12 any + { // let + // let binding "vec__753" + var v13 any = v10 + _ = v13 + // let binding "f" + tmp14 := checkDerefVar(var_glojure_DOT_core_nth) + tmp15 := lang.Apply(tmp14, []any{v13, int64(0), nil}) + var v16 any = tmp15 + _ = v16 + // let binding "xs" + var v17 any = v13 + _ = v17 + var tmp18 any + { // let + // let binding "temp__0__auto__" + tmp19 := checkDerefVar(var_glojure_DOT_core_seq) + tmp20 := lang.Apply(tmp19, []any{v17}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + if lang.IsTruthy(v21) { + var tmp23 any + { // let + // let binding "s" + var v24 any = v21 + _ = v24 + var tmp25 any + tmp26 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp27 := lang.Apply(tmp26, []any{v11, v16}) + if lang.IsTruthy(tmp27) { + tmp29 := checkDerefVar(var_glojure_DOT_core_rest) + tmp30 := lang.Apply(tmp29, []any{v24}) + var tmp28 any = tmp30 + var tmp31 any = v11 + v10 = tmp28 + v11 = tmp31 + goto recur_loop_2417 + } else { + tmp32 := checkDerefVar(var_glojure_DOT_core_cons) + tmp33 := checkDerefVar(var_glojure_DOT_core_rest) + tmp34 := lang.Apply(tmp33, []any{v24}) + tmp35 := checkDerefVar(var_glojure_DOT_core_conj) + tmp36 := lang.Apply(tmp35, []any{v11, v16}) + tmp37 := lang.Apply(v5, []any{tmp34, tmp36}) + tmp38 := lang.Apply(tmp32, []any{v16, tmp37}) + tmp25 = tmp38 + } + tmp23 = tmp25 + } // end let + tmp22 = tmp23 + } else { + } + tmp18 = tmp22 + } // end let + tmp12 = tmp18 + } // end let + return tmp12 + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5072), kw_column, int(20), kw_end_DASH_line, int(5076), kw_end_DASH_column, int(66)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp12 := lang.Apply(tmp11, []any{v6, v7}) + return tmp12 + }) + tmp9 := lang.Apply(lang.NewLazySeq, []any{tmp8}) + return tmp9 + }) + v5 = tmp4 + _ = v5 + } + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5070), kw_column, int(15), kw_end_DASH_line, int(5077), kw_end_DASH_column, int(29)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v7 any = tmp6 + _ = v7 + tmp8 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5078), kw_column, int(17), kw_end_DASH_line, int(5078), kw_end_DASH_column, int(19)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp11 := lang.Apply(v7, []any{v2, tmp10}) + tmp3 = tmp11 + } // end let + return tmp3 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_distinct = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_distinct.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // dorun + { + tmp0 := sym_dorun.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll), lang.NewVector(sym_n, sym_coll)), kw_doc, "When lazy sequences are produced via functions that have side\n effects, any effects other than those needed to produce the first\n element in the seq do not occur until the seq is consumed. dorun can\n be used to force any effects. Walks through the successive nexts of\n the seq, does not retain the head and returns nil.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3116), kw_end_DASH_line, int(3116))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + recur_loop_2119: + var tmp3 any + { // let + // let binding "temp__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + var tmp8 any + { // let + // let binding "s" + var v9 any = v6 + _ = v9 + tmp11 := checkDerefVar(var_glojure_DOT_core_next) + tmp12 := lang.Apply(tmp11, []any{v9}) + var tmp10 any = tmp12 + v2 = tmp10 + goto recur_loop_2119 + } // end let + tmp7 = tmp8 + } else { + } + tmp3 = tmp7 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + recur_loop_2120: + var tmp4 any + var tmp5 any + { // let + // let binding "and__0__auto__" + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := lang.Apply(tmp6, []any{v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + tmp10 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp9 = tmp11 + } else { + tmp9 = v8 + } + tmp5 = tmp9 + } // end let + if lang.IsTruthy(tmp5) { + tmp7 := checkDerefVar(var_glojure_DOT_core_dec) + tmp8 := lang.Apply(tmp7, []any{v2}) + var tmp6 any = tmp8 + tmp10 := checkDerefVar(var_glojure_DOT_core_next) + tmp11 := lang.Apply(tmp10, []any{v3}) + var tmp9 any = tmp11 + v2 = tmp6 + v3 = tmp9 + goto recur_loop_2120 + } else { + } + return tmp4 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_dorun = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_dorun.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // dotimes + { + tmp0 := sym_dotimes.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "bindings => name n\n\n Repeatedly executes body (presumably for side-effects) with name\n bound to integers from 0 through n-1.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(3306), kw_end_DASH_line, int(3306))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v4}) + if lang.IsTruthy(tmp8) { + } else { + tmp9 := checkDerefVar(var_glojure_DOT_core_str) + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp13 := checkDerefVar(var_glojure_DOT_core_meta) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(kw_line, []any{tmp14}) + tmp16 := lang.Apply(tmp9, []any{tmp11, " requires ", "a vector for its binding", " in ", tmp12, ":", tmp15}) + tmp17 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp16}) + panic(tmp17) + } + _ = tmp6 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp20 := checkDerefVar(var_glojure_DOT_core_count) + tmp21 := lang.Apply(tmp20, []any{v4}) + tmp22 := lang.Apply(tmp19, []any{int64(2), tmp21}) + if lang.IsTruthy(tmp22) { + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp27 := checkDerefVar(var_glojure_DOT_core_meta) + tmp28 := lang.Apply(tmp27, []any{v2}) + tmp29 := lang.Apply(kw_line, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp25, " requires ", "exactly 2 forms in binding vector", " in ", tmp26, ":", tmp29}) + tmp31 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp31) + } + _ = tmp18 + var tmp32 any + { // let + // let binding "i" + tmp33 := checkDerefVar(var_glojure_DOT_core_first) + tmp34 := lang.Apply(tmp33, []any{v4}) + var v35 any = tmp34 + _ = v35 + // let binding "n" + tmp36 := checkDerefVar(var_glojure_DOT_core_second) + tmp37 := lang.Apply(tmp36, []any{v4}) + var v38 any = tmp37 + _ = v38 + tmp39 := checkDerefVar(var_glojure_DOT_core_seq) + tmp40 := checkDerefVar(var_glojure_DOT_core_concat) + tmp41 := checkDerefVar(var_glojure_DOT_core_list) + tmp42 := lang.Apply(tmp41, []any{sym_glojure_DOT_core_SLASH_let}) + tmp43 := checkDerefVar(var_glojure_DOT_core_list) + tmp44 := checkDerefVar(var_glojure_DOT_core_apply) + tmp45 := checkDerefVar(var_glojure_DOT_core_vector) + tmp46 := checkDerefVar(var_glojure_DOT_core_seq) + tmp47 := checkDerefVar(var_glojure_DOT_core_concat) + tmp48 := checkDerefVar(var_glojure_DOT_core_list) + tmp49 := lang.Apply(tmp48, []any{sym_n__0__auto__}) + tmp50 := checkDerefVar(var_glojure_DOT_core_list) + tmp51 := checkDerefVar(var_glojure_DOT_core_seq) + tmp52 := checkDerefVar(var_glojure_DOT_core_concat) + tmp53 := checkDerefVar(var_glojure_DOT_core_list) + tmp54 := lang.Apply(tmp53, []any{sym_glojure_DOT_core_SLASH_long}) + tmp55 := checkDerefVar(var_glojure_DOT_core_list) + tmp56 := lang.Apply(tmp55, []any{v38}) + tmp57 := lang.Apply(tmp52, []any{tmp54, tmp56}) + tmp58 := lang.Apply(tmp51, []any{tmp57}) + tmp59 := lang.Apply(tmp50, []any{tmp58}) + tmp60 := lang.Apply(tmp47, []any{tmp49, tmp59}) + tmp61 := lang.Apply(tmp46, []any{tmp60}) + tmp62 := lang.Apply(tmp44, []any{tmp45, tmp61}) + tmp63 := lang.Apply(tmp43, []any{tmp62}) + tmp64 := checkDerefVar(var_glojure_DOT_core_list) + tmp65 := checkDerefVar(var_glojure_DOT_core_seq) + tmp66 := checkDerefVar(var_glojure_DOT_core_concat) + tmp67 := checkDerefVar(var_glojure_DOT_core_list) + tmp68 := lang.Apply(tmp67, []any{sym_glojure_DOT_core_SLASH_loop}) + tmp69 := checkDerefVar(var_glojure_DOT_core_list) + tmp70 := checkDerefVar(var_glojure_DOT_core_apply) + tmp71 := checkDerefVar(var_glojure_DOT_core_vector) + tmp72 := checkDerefVar(var_glojure_DOT_core_seq) + tmp73 := checkDerefVar(var_glojure_DOT_core_concat) + tmp74 := checkDerefVar(var_glojure_DOT_core_list) + tmp75 := lang.Apply(tmp74, []any{v35}) + tmp76 := checkDerefVar(var_glojure_DOT_core_list) + tmp77 := lang.Apply(tmp76, []any{int64(0)}) + tmp78 := lang.Apply(tmp73, []any{tmp75, tmp77}) + tmp79 := lang.Apply(tmp72, []any{tmp78}) + tmp80 := lang.Apply(tmp70, []any{tmp71, tmp79}) + tmp81 := lang.Apply(tmp69, []any{tmp80}) + tmp82 := checkDerefVar(var_glojure_DOT_core_list) + tmp83 := checkDerefVar(var_glojure_DOT_core_seq) + tmp84 := checkDerefVar(var_glojure_DOT_core_concat) + tmp85 := checkDerefVar(var_glojure_DOT_core_list) + tmp86 := lang.Apply(tmp85, []any{sym_glojure_DOT_core_SLASH_when}) + tmp87 := checkDerefVar(var_glojure_DOT_core_list) + tmp88 := checkDerefVar(var_glojure_DOT_core_seq) + tmp89 := checkDerefVar(var_glojure_DOT_core_concat) + tmp90 := checkDerefVar(var_glojure_DOT_core_list) + tmp91 := lang.Apply(tmp90, []any{sym_glojure_DOT_core_SLASH__LT_}) + tmp92 := checkDerefVar(var_glojure_DOT_core_list) + tmp93 := lang.Apply(tmp92, []any{v35}) + tmp94 := checkDerefVar(var_glojure_DOT_core_list) + tmp95 := lang.Apply(tmp94, []any{sym_n__0__auto__}) + tmp96 := lang.Apply(tmp89, []any{tmp91, tmp93, tmp95}) + tmp97 := lang.Apply(tmp88, []any{tmp96}) + tmp98 := lang.Apply(tmp87, []any{tmp97}) + tmp99 := checkDerefVar(var_glojure_DOT_core_list) + tmp100 := checkDerefVar(var_glojure_DOT_core_seq) + tmp101 := checkDerefVar(var_glojure_DOT_core_concat) + tmp102 := checkDerefVar(var_glojure_DOT_core_list) + tmp103 := lang.Apply(tmp102, []any{sym_recur}) + tmp104 := checkDerefVar(var_glojure_DOT_core_list) + tmp105 := checkDerefVar(var_glojure_DOT_core_seq) + tmp106 := checkDerefVar(var_glojure_DOT_core_concat) + tmp107 := checkDerefVar(var_glojure_DOT_core_list) + tmp108 := lang.Apply(tmp107, []any{sym_glojure_DOT_core_SLASH_unchecked_DASH_inc}) + tmp109 := checkDerefVar(var_glojure_DOT_core_list) + tmp110 := lang.Apply(tmp109, []any{v35}) + tmp111 := lang.Apply(tmp106, []any{tmp108, tmp110}) + tmp112 := lang.Apply(tmp105, []any{tmp111}) + tmp113 := lang.Apply(tmp104, []any{tmp112}) + tmp114 := lang.Apply(tmp101, []any{tmp103, tmp113}) + tmp115 := lang.Apply(tmp100, []any{tmp114}) + tmp116 := lang.Apply(tmp99, []any{tmp115}) + tmp117 := lang.Apply(tmp84, []any{tmp86, tmp98, v5, tmp116}) + tmp118 := lang.Apply(tmp83, []any{tmp117}) + tmp119 := lang.Apply(tmp82, []any{tmp118}) + tmp120 := lang.Apply(tmp66, []any{tmp68, tmp81, tmp119}) + tmp121 := lang.Apply(tmp65, []any{tmp120}) + tmp122 := lang.Apply(tmp64, []any{tmp121}) + tmp123 := lang.Apply(tmp40, []any{tmp42, tmp63, tmp122}) + tmp124 := lang.Apply(tmp39, []any{tmp123}) + tmp32 = tmp124 + } // end let + return tmp32 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_dotimes = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_dotimes.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // drop + { + tmp0 := sym_drop.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n), lang.NewVector(sym_n, sym_coll)), kw_doc, "Returns a laziness-preserving sequence of all but the first n items in coll.\n Returns a stateful transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(2901), kw_end_DASH_line, int(2901))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 any + { // let + // let binding "nv" + tmp6 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) + tmp7 := lang.Apply(tmp6, []any{v2}) + var v8 any = tmp7 + _ = v8 + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp10 := lang.Apply(v4, nil) + return tmp10 + case 1: + v10 := args[0] + _ = v10 + tmp11 := lang.Apply(v4, []any{v10}) + return tmp11 + case 2: + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + var tmp12 any + { // let + // let binding "n" + tmp13 := checkDerefVar(var_glojure_DOT_core_deref) + tmp14 := lang.Apply(tmp13, []any{v8}) + var v15 any = tmp14 + _ = v15 + tmp16 := checkDerefVar(var_glojure_DOT_core_dec) + tmp17, ok := lang.FieldOrMethod(v8, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "Deref"))) + } + var tmp18 any + switch reflect.TypeOf(tmp17).Kind() { + case reflect.Func: + tmp18 = lang.Apply(tmp17, nil) + default: + tmp18 = tmp17 + } + tmp19 := lang.Apply(tmp16, []any{tmp18}) + tmp20, _ := lang.FieldOrMethod(v8, "reset") + if reflect.TypeOf(tmp20).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) + } + tmp21 := lang.Apply(tmp20, []any{tmp19}) + _ = tmp21 + var tmp22 any + tmp23 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp24 := lang.Apply(tmp23, []any{v15}) + if lang.IsTruthy(tmp24) { + tmp22 = v10 + } else { + tmp25 := lang.Apply(v4, []any{v10, v11}) + tmp22 = tmp25 + } + tmp12 = tmp22 + } // end let + return tmp12 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2909), kw_column, int(10), kw_end_DASH_line, int(2917), kw_end_DASH_column, int(39)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp5 = tmp11 + } // end let + return tmp5 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2907), kw_column, int(6), kw_end_DASH_line, int(2917), kw_end_DASH_column, int(41)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp6 := reflect.TypeOf((*lang.IDrop)(nil)).Elem() + tmp7 := lang.Apply(tmp5, []any{tmp6, v3}) + if lang.IsTruthy(tmp7) { + var tmp8 any + { // let + // let binding "or__0__auto__" + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp11 := lang.Apply(tmp10, []any{v2}) + if lang.IsTruthy(tmp11) { + var tmp12 any + tmp13 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) + tmp14 := lang.Apply(tmp13, []any{v2}) + if lang.IsTruthy(tmp14) { + tmp12 = v2 + } else { + tmp15 := lang.Apply(nil, []any{v2}) + tmp12 = tmp15 + } + tmp16, _ := lang.FieldOrMethod(v3, "drop") + if reflect.TypeOf(tmp16).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("drop is not a function"))) + } + tmp17 := lang.Apply(tmp16, []any{tmp12}) + tmp9 = tmp17 + } else { + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := lang.Apply(tmp18, []any{v3}) + tmp9 = tmp19 + } + var v20 any = tmp9 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + tmp21 = v20 + } else { + tmp21 = lang.NewList() + } + tmp8 = tmp21 + } // end let + tmp4 = tmp8 + } else { + var tmp9 any + { // let + // let binding "step" + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + recur_loop_2079: + var tmp13 any + { // let + // let binding "s" + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := lang.Apply(tmp14, []any{v12}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + var tmp18 any + { // let + // let binding "and__0__auto__" + tmp19 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp20 := lang.Apply(tmp19, []any{v11}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + if lang.IsTruthy(v21) { + tmp22 = v16 + } else { + tmp22 = v21 + } + tmp18 = tmp22 + } // end let + if lang.IsTruthy(tmp18) { + tmp20 := checkDerefVar(var_glojure_DOT_core_dec) + tmp21 := lang.Apply(tmp20, []any{v11}) + var tmp19 any = tmp21 + tmp23 := checkDerefVar(var_glojure_DOT_core_rest) + tmp24 := lang.Apply(tmp23, []any{v16}) + var tmp22 any = tmp24 + v11 = tmp19 + v12 = tmp22 + goto recur_loop_2079 + } else { + tmp17 = v16 + } + tmp13 = tmp17 + } // end let + return tmp13 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2925), kw_column, int(19), kw_end_DASH_line, int(2929), kw_end_DASH_column, int(28)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v13 any = tmp12 + _ = v13 + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp15 := lang.Apply(v13, []any{v2, v3}) + return tmp15 + }) + tmp15 := lang.Apply(lang.NewLazySeq, []any{tmp14}) + tmp9 = tmp15 + } // end let + tmp4 = tmp9 + } + return tmp4 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_drop = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_drop.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // elide-top-frames + { + tmp0 := sym_elide_DASH_top_DASH_frames.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(4794), kw_column, int(7), kw_end_DASH_line, int(4794), kw_end_DASH_column, int(32), kw_arglists, lang.NewList(lang.NewVector(sym_ex, sym_class_DASH_name)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "tr" + tmp5, ok := lang.FieldOrMethod(v2, "getStackTrace") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getStackTrace"))) + } + var tmp6 any + switch reflect.TypeOf(tmp5).Kind() { + case reflect.Func: + tmp6 = lang.Apply(tmp5, nil) + default: + tmp6 = tmp5 + } + var v7 any = tmp6 + _ = v7 + var tmp8 any + { // let + // let binding "G__745" + var v9 any = v2 + _ = v9 + var tmp10 any + if lang.IsTruthy(v7) { + tmp11 := checkDerefVar(var_glojure_DOT_core_into_DASH_array) + tmp12 := checkDerefVar(var_glojure_DOT_core_drop_DASH_while) + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v14 := args[0] + _ = v14 + tmp15 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp16, ok := lang.FieldOrMethod(v14, "getClassName") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v14, "getClassName"))) + } + var tmp17 any + switch reflect.TypeOf(tmp16).Kind() { + case reflect.Func: + tmp17 = lang.Apply(tmp16, nil) + default: + tmp17 = tmp16 + } + tmp18 := lang.Apply(tmp15, []any{v3, tmp17}) + return tmp18 + }) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4801), kw_column, int(25), kw_end_DASH_line, int(4801), kw_end_DASH_column, int(77)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp16 := lang.Apply(tmp12, []any{tmp15, v7}) + tmp17 := lang.Apply(tmp11, []any{nil, tmp16}) + tmp10 = tmp17 + } else { + } + tmp18, _ := lang.FieldOrMethod(v9, "setStackTrace") + if reflect.TypeOf(tmp18).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setStackTrace is not a function"))) + } + tmp19 := lang.Apply(tmp18, []any{tmp10}) + _ = tmp19 + tmp8 = v9 + } // end let + tmp4 = tmp8 + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_elide_DASH_top_DASH_frames = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_elide_DASH_top_DASH_frames.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // empty? + { + tmp0 := sym_empty_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns true if coll has no items. To check the emptiness of a seq,\n please use the idiom (seq x) rather than (not (empty? x))", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(6247), kw_end_DASH_line, int(6247))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_counted_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + tmp6 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) + tmp7 := checkDerefVar(var_glojure_DOT_core_count) + tmp8 := lang.Apply(tmp7, []any{v2}) + tmp9 := lang.Apply(tmp6, []any{tmp8}) + tmp3 = tmp9 + } else { + tmp10 := checkDerefVar(var_glojure_DOT_core_not) + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := lang.Apply(tmp11, []any{v2}) + tmp13 := lang.Apply(tmp10, []any{tmp12}) + tmp3 = tmp13 + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_empty_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_empty_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ensure-reduced + { + tmp0 := sym_ensure_DASH_reduced.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "If x is already reduced?, returns it, else returns (reduced x)", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(2841), kw_end_DASH_line, int(2841))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + tmp3 = v2 + } else { + tmp6 := checkDerefVar(var_glojure_DOT_core_reduced) + tmp7 := lang.Apply(tmp6, []any{v2}) + tmp3 = tmp7 + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ensure_DASH_reduced = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ensure_DASH_reduced.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // even? + { + tmp0 := sym_even_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_doc, "Returns true if n is even, throws an exception if n is not an integer", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(1381), kw_end_DASH_line, int(1381))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_integer_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + tmp6 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) + tmp7 := checkDerefVar(var_glojure_DOT_core_bit_DASH_and) + tmp8 := lang.Apply(lang.UncheckedLongCast, []any{v2}) + tmp9 := lang.Apply(tmp7, []any{tmp8, int64(1)}) + tmp10 := lang.Apply(tmp6, []any{tmp9}) + tmp3 = tmp10 + } else { + tmp11 := checkDerefVar(var_glojure_DOT_core_str) + tmp12 := lang.Apply(tmp11, []any{"Argument must be an integer: ", v2}) + tmp13 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp12}) + panic(tmp13) + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_even_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_even_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // every-pred + { + tmp0 := sym_every_DASH_pred.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_p), lang.NewVector(sym_p1, sym_p2), lang.NewVector(sym_p1, sym_p2, sym_p3), lang.NewVector(sym_p1, sym_p2, sym_p3, sym__AMP_, sym_ps)), kw_doc, "Takes a set of predicates and returns a function f that returns true if all of its\n composing predicates return a logical true value against all of its arguments, else it returns\n false. Note that f is short-circuiting in that it will stop execution on the first\n argument that triggers a logical false result against the original predicates.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(7422), kw_end_DASH_line, int(7422))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + { // function ep1 + var v4 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return true + case 1: + v5 := args[0] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_boolean) + tmp7 := lang.Apply(v2, []any{v5}) + tmp8 := lang.Apply(tmp6, []any{tmp7}) + return tmp8 + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp8 any + { // let + // let binding "and__0__auto__" + tmp9 := lang.Apply(v2, []any{v5}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + if lang.IsTruthy(v10) { + tmp12 := lang.Apply(v2, []any{v6}) + tmp11 = tmp12 + } else { + tmp11 = v10 + } + tmp8 = tmp11 + } // end let + tmp9 := lang.Apply(tmp7, []any{tmp8}) + return tmp9 + case 3: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := args[2] + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp9 any + { // let + // let binding "and__0__auto__" + tmp10 := lang.Apply(v2, []any{v5}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + var tmp13 any + { // let + // let binding "and__0__auto__" + tmp14 := lang.Apply(v2, []any{v6}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + if lang.IsTruthy(v15) { + tmp17 := lang.Apply(v2, []any{v7}) + tmp16 = tmp17 + } else { + tmp16 = v15 + } + tmp13 = tmp16 + } // end let + tmp12 = tmp13 + } else { + tmp12 = v11 + } + tmp9 = tmp12 + } // end let + tmp10 := lang.Apply(tmp8, []any{tmp9}) + return tmp10 + default: + checkArity(args, 3) + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := args[2] + _ = v7 + var v8 any = lang.NewList(args[3:]...) + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp10 any + { // let + // let binding "and__0__auto__" + tmp11 := lang.Apply(v4, []any{v5, v6, v7}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + tmp14 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + tmp15 := lang.Apply(tmp14, []any{v2, v8}) + tmp13 = tmp15 + } else { + tmp13 = v12 + } + tmp10 = tmp13 + } // end let + tmp11 := lang.Apply(tmp9, []any{tmp10}) + return tmp11 + } + }) + v4 = tmp3 + _ = v4 + } + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7429), kw_column, int(6), kw_end_DASH_line, int(7435), kw_end_DASH_column, int(56)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + { // function ep2 + var v5 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return true + case 1: + v6 := args[0] + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp8 any + { // let + // let binding "and__0__auto__" + tmp9 := lang.Apply(v2, []any{v6}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + if lang.IsTruthy(v10) { + tmp12 := lang.Apply(v3, []any{v6}) + tmp11 = tmp12 + } else { + tmp11 = v10 + } + tmp8 = tmp11 + } // end let + tmp9 := lang.Apply(tmp7, []any{tmp8}) + return tmp9 + case 2: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp9 any + { // let + // let binding "and__0__auto__" + tmp10 := lang.Apply(v2, []any{v6}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + var tmp13 any + { // let + // let binding "and__0__auto__" + tmp14 := lang.Apply(v2, []any{v7}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + if lang.IsTruthy(v15) { + var tmp17 any + { // let + // let binding "and__0__auto__" + tmp18 := lang.Apply(v3, []any{v6}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + tmp21 := lang.Apply(v3, []any{v7}) + tmp20 = tmp21 + } else { + tmp20 = v19 + } + tmp17 = tmp20 + } // end let + tmp16 = tmp17 + } else { + tmp16 = v15 + } + tmp13 = tmp16 + } // end let + tmp12 = tmp13 + } else { + tmp12 = v11 + } + tmp9 = tmp12 + } // end let + tmp10 := lang.Apply(tmp8, []any{tmp9}) + return tmp10 + case 3: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp10 any + { // let + // let binding "and__0__auto__" + tmp11 := lang.Apply(v2, []any{v6}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + var tmp14 any + { // let + // let binding "and__0__auto__" + tmp15 := lang.Apply(v2, []any{v7}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + if lang.IsTruthy(v16) { + var tmp18 any + { // let + // let binding "and__0__auto__" + tmp19 := lang.Apply(v2, []any{v8}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + var tmp22 any + { // let + // let binding "and__0__auto__" + tmp23 := lang.Apply(v3, []any{v6}) + var v24 any = tmp23 + _ = v24 + var tmp25 any + if lang.IsTruthy(v24) { + var tmp26 any + { // let + // let binding "and__0__auto__" + tmp27 := lang.Apply(v3, []any{v7}) + var v28 any = tmp27 + _ = v28 + var tmp29 any + if lang.IsTruthy(v28) { + tmp30 := lang.Apply(v3, []any{v8}) + tmp29 = tmp30 + } else { + tmp29 = v28 + } + tmp26 = tmp29 + } // end let + tmp25 = tmp26 + } else { + tmp25 = v24 + } + tmp22 = tmp25 + } // end let + tmp21 = tmp22 + } else { + tmp21 = v20 + } + tmp18 = tmp21 + } // end let + tmp17 = tmp18 + } else { + tmp17 = v16 + } + tmp14 = tmp17 + } // end let + tmp13 = tmp14 + } else { + tmp13 = v12 + } + tmp10 = tmp13 + } // end let + tmp11 := lang.Apply(tmp9, []any{tmp10}) + return tmp11 + default: + checkArity(args, 3) + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + var v9 any = lang.NewList(args[3:]...) + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp11 any + { // let + // let binding "and__0__auto__" + tmp12 := lang.Apply(v5, []any{v6, v7, v8}) + var v13 any = tmp12 + _ = v13 + var tmp14 any + if lang.IsTruthy(v13) { + tmp15 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + var tmp16 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v17 := args[0] + _ = v17 + var tmp18 any + { // let + // let binding "and__0__auto__" + tmp19 := lang.Apply(v2, []any{v17}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + tmp22 := lang.Apply(v3, []any{v17}) + tmp21 = tmp22 + } else { + tmp21 = v20 + } + tmp18 = tmp21 + } // end let + return tmp18 + }) + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7443), kw_column, int(46), kw_end_DASH_line, int(7443), kw_end_DASH_column, int(65)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp19 := lang.Apply(tmp15, []any{tmp18, v9}) + tmp14 = tmp19 + } else { + tmp14 = v13 + } + tmp11 = tmp14 + } // end let + tmp12 := lang.Apply(tmp10, []any{tmp11}) + return tmp12 + } + }) + v5 = tmp4 + _ = v5 + } + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7437), kw_column, int(6), kw_end_DASH_line, int(7443), kw_end_DASH_column, int(75)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 lang.FnFunc + { // function ep3 + var v6 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return true + case 1: + v7 := args[0] + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp9 any + { // let + // let binding "and__0__auto__" + tmp10 := lang.Apply(v2, []any{v7}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + var tmp13 any + { // let + // let binding "and__0__auto__" + tmp14 := lang.Apply(v3, []any{v7}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + if lang.IsTruthy(v15) { + tmp17 := lang.Apply(v4, []any{v7}) + tmp16 = tmp17 + } else { + tmp16 = v15 + } + tmp13 = tmp16 + } // end let + tmp12 = tmp13 + } else { + tmp12 = v11 + } + tmp9 = tmp12 + } // end let + tmp10 := lang.Apply(tmp8, []any{tmp9}) + return tmp10 + case 2: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp10 any + { // let + // let binding "and__0__auto__" + tmp11 := lang.Apply(v2, []any{v7}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + var tmp14 any + { // let + // let binding "and__0__auto__" + tmp15 := lang.Apply(v2, []any{v8}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + if lang.IsTruthy(v16) { + var tmp18 any + { // let + // let binding "and__0__auto__" + tmp19 := lang.Apply(v3, []any{v7}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + var tmp22 any + { // let + // let binding "and__0__auto__" + tmp23 := lang.Apply(v3, []any{v8}) + var v24 any = tmp23 + _ = v24 + var tmp25 any + if lang.IsTruthy(v24) { + var tmp26 any + { // let + // let binding "and__0__auto__" + tmp27 := lang.Apply(v4, []any{v7}) + var v28 any = tmp27 + _ = v28 + var tmp29 any + if lang.IsTruthy(v28) { + tmp30 := lang.Apply(v4, []any{v8}) + tmp29 = tmp30 + } else { + tmp29 = v28 + } + tmp26 = tmp29 + } // end let + tmp25 = tmp26 + } else { + tmp25 = v24 + } + tmp22 = tmp25 + } // end let + tmp21 = tmp22 + } else { + tmp21 = v20 + } + tmp18 = tmp21 + } // end let + tmp17 = tmp18 + } else { + tmp17 = v16 + } + tmp14 = tmp17 + } // end let + tmp13 = tmp14 + } else { + tmp13 = v12 + } + tmp10 = tmp13 + } // end let + tmp11 := lang.Apply(tmp9, []any{tmp10}) + return tmp11 + case 3: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp11 any + { // let + // let binding "and__0__auto__" + tmp12 := lang.Apply(v2, []any{v7}) + var v13 any = tmp12 + _ = v13 + var tmp14 any + if lang.IsTruthy(v13) { + var tmp15 any + { // let + // let binding "and__0__auto__" + tmp16 := lang.Apply(v2, []any{v8}) + var v17 any = tmp16 + _ = v17 + var tmp18 any + if lang.IsTruthy(v17) { + var tmp19 any + { // let + // let binding "and__0__auto__" + tmp20 := lang.Apply(v2, []any{v9}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + if lang.IsTruthy(v21) { + var tmp23 any + { // let + // let binding "and__0__auto__" + tmp24 := lang.Apply(v3, []any{v7}) + var v25 any = tmp24 + _ = v25 + var tmp26 any + if lang.IsTruthy(v25) { + var tmp27 any + { // let + // let binding "and__0__auto__" + tmp28 := lang.Apply(v3, []any{v8}) + var v29 any = tmp28 + _ = v29 + var tmp30 any + if lang.IsTruthy(v29) { + var tmp31 any + { // let + // let binding "and__0__auto__" + tmp32 := lang.Apply(v3, []any{v9}) + var v33 any = tmp32 + _ = v33 + var tmp34 any + if lang.IsTruthy(v33) { + var tmp35 any + { // let + // let binding "and__0__auto__" + tmp36 := lang.Apply(v4, []any{v7}) + var v37 any = tmp36 + _ = v37 + var tmp38 any + if lang.IsTruthy(v37) { + var tmp39 any + { // let + // let binding "and__0__auto__" + tmp40 := lang.Apply(v4, []any{v8}) + var v41 any = tmp40 + _ = v41 + var tmp42 any + if lang.IsTruthy(v41) { + tmp43 := lang.Apply(v4, []any{v9}) + tmp42 = tmp43 + } else { + tmp42 = v41 + } + tmp39 = tmp42 + } // end let + tmp38 = tmp39 + } else { + tmp38 = v37 + } + tmp35 = tmp38 + } // end let + tmp34 = tmp35 + } else { + tmp34 = v33 + } + tmp31 = tmp34 + } // end let + tmp30 = tmp31 + } else { + tmp30 = v29 + } + tmp27 = tmp30 + } // end let + tmp26 = tmp27 + } else { + tmp26 = v25 + } + tmp23 = tmp26 + } // end let + tmp22 = tmp23 + } else { + tmp22 = v21 + } + tmp19 = tmp22 + } // end let + tmp18 = tmp19 + } else { + tmp18 = v17 + } + tmp15 = tmp18 + } // end let + tmp14 = tmp15 + } else { + tmp14 = v13 + } + tmp11 = tmp14 + } // end let + tmp12 := lang.Apply(tmp10, []any{tmp11}) + return tmp12 + default: + checkArity(args, 3) + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + var v10 any = lang.NewList(args[3:]...) + _ = v10 + tmp11 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp12 any + { // let + // let binding "and__0__auto__" + tmp13 := lang.Apply(v6, []any{v7, v8, v9}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + tmp16 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + var tmp17 lang.FnFunc + tmp17 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v18 := args[0] + _ = v18 + var tmp19 any + { // let + // let binding "and__0__auto__" + tmp20 := lang.Apply(v2, []any{v18}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + if lang.IsTruthy(v21) { + var tmp23 any + { // let + // let binding "and__0__auto__" + tmp24 := lang.Apply(v3, []any{v18}) + var v25 any = tmp24 + _ = v25 + var tmp26 any + if lang.IsTruthy(v25) { + tmp27 := lang.Apply(v4, []any{v18}) + tmp26 = tmp27 + } else { + tmp26 = v25 + } + tmp23 = tmp26 + } // end let + tmp22 = tmp23 + } else { + tmp22 = v21 + } + tmp19 = tmp22 + } // end let + return tmp19 + }) + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7451), kw_column, int(46), kw_end_DASH_line, int(7451), kw_end_DASH_column, int(72)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp20 := lang.Apply(tmp16, []any{tmp19, v10}) + tmp15 = tmp20 + } else { + tmp15 = v14 + } + tmp12 = tmp15 + } // end let + tmp13 := lang.Apply(tmp11, []any{tmp12}) + return tmp13 + } + }) + v6 = tmp5 + _ = v6 + } + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7445), kw_column, int(6), kw_end_DASH_line, int(7451), kw_end_DASH_column, int(82)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp7 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "ps" + tmp7 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp8 := lang.Apply(tmp7, []any{v2, v3, v4, v5}) + var v9 any = tmp8 + _ = v9 + var tmp10 lang.FnFunc + { // function epn + var v11 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return true + case 1: + v12 := args[0] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v15 := args[0] + _ = v15 + tmp16 := lang.Apply(v15, []any{v12}) + return tmp16 + }) + tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7456), kw_column, int(23), kw_end_DASH_line, int(7456), kw_end_DASH_column, int(28)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp17 := lang.Apply(tmp13, []any{tmp16, v9}) + return tmp17 + case 2: + v12 := args[0] + _ = v12 + v13 := args[1] + _ = v13 + tmp14 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + var tmp15 lang.FnFunc + tmp15 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v16 := args[0] + _ = v16 + var tmp17 any + { // let + // let binding "and__0__auto__" + tmp18 := lang.Apply(v16, []any{v12}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + tmp21 := lang.Apply(v16, []any{v13}) + tmp20 = tmp21 + } else { + tmp20 = v19 + } + tmp17 = tmp20 + } // end let + return tmp17 + }) + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7457), kw_column, int(25), kw_end_DASH_line, int(7457), kw_end_DASH_column, int(42)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp18 := lang.Apply(tmp14, []any{tmp17, v9}) + return tmp18 + case 3: + v12 := args[0] + _ = v12 + v13 := args[1] + _ = v13 + v14 := args[2] + _ = v14 + tmp15 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + var tmp16 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v17 := args[0] + _ = v17 + var tmp18 any + { // let + // let binding "and__0__auto__" + tmp19 := lang.Apply(v17, []any{v12}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + var tmp22 any + { // let + // let binding "and__0__auto__" + tmp23 := lang.Apply(v17, []any{v13}) + var v24 any = tmp23 + _ = v24 + var tmp25 any + if lang.IsTruthy(v24) { + tmp26 := lang.Apply(v17, []any{v14}) + tmp25 = tmp26 + } else { + tmp25 = v24 + } + tmp22 = tmp25 + } // end let + tmp21 = tmp22 + } else { + tmp21 = v20 + } + tmp18 = tmp21 + } // end let + return tmp18 + }) + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7458), kw_column, int(27), kw_end_DASH_line, int(7458), kw_end_DASH_column, int(50)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp19 := lang.Apply(tmp15, []any{tmp18, v9}) + return tmp19 + default: + checkArity(args, 3) + v12 := args[0] + _ = v12 + v13 := args[1] + _ = v13 + v14 := args[2] + _ = v14 + var v15 any = lang.NewList(args[3:]...) + _ = v15 + tmp16 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp17 any + { // let + // let binding "and__0__auto__" + tmp18 := lang.Apply(v11, []any{v12, v13, v14}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + tmp21 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + var tmp22 lang.FnFunc + tmp22 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v23 := args[0] + _ = v23 + tmp24 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + tmp25 := lang.Apply(tmp24, []any{v23, v15}) + return tmp25 + }) + tmp23 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7460), kw_column, int(48), kw_end_DASH_line, int(7460), kw_end_DASH_column, int(63)) + tmp24, err := lang.WithMeta(tmp22, tmp23.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp25 := lang.Apply(tmp21, []any{tmp24, v9}) + tmp20 = tmp25 + } else { + tmp20 = v19 + } + tmp17 = tmp20 + } // end let + tmp18 := lang.Apply(tmp16, []any{tmp17}) + return tmp18 + } + }) + v11 = tmp10 + _ = v11 + } + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7454), kw_column, int(8), kw_end_DASH_line, int(7460), kw_end_DASH_column, int(71)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp6 = tmp12 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_every_DASH_pred = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_every_DASH_pred.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ex-info + { + tmp0 := sym_ex_DASH_info.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_msg, sym_map), lang.NewVector(sym_msg, sym_map, sym_cause)), kw_doc, "Create an instance of ExceptionInfo, a RuntimeException subclass\n that carries a map of additional data.", kw_file, "glojure/core.glj", kw_added, "1.4", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4803), kw_end_DASH_line, int(4803))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_elide_DASH_top_DASH_frames) + tmp5 := lang.Apply(nil, []any{v2, v3}) + tmp6 := lang.Apply(tmp4, []any{tmp5, "glojure.core$ex_info"}) + return tmp6 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_elide_DASH_top_DASH_frames) + tmp6 := lang.Apply(nil, []any{v2, v3, v4}) + tmp7 := lang.Apply(tmp5, []any{tmp6, "glojure.core$ex_info"}) + return tmp7 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ex_DASH_info = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ex_DASH_info.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // filter + { + tmp0 := sym_filter.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred), lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns a lazy sequence of the items in coll for which\n (pred item) returns logical true. pred must be free of side-effects.\n Returns a transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(2785), kw_end_DASH_line, int(2785))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp6 := lang.Apply(v4, nil) + return tmp6 + case 1: + v6 := args[0] + _ = v6 + tmp7 := lang.Apply(v4, []any{v6}) + return tmp7 + case 2: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + var tmp8 any + tmp9 := lang.Apply(v2, []any{v7}) + if lang.IsTruthy(tmp9) { + tmp10 := lang.Apply(v4, []any{v6, v7}) + tmp8 = tmp10 + } else { + tmp8 = v6 + } + return tmp8 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2793), kw_column, int(7), kw_end_DASH_line, int(2799), kw_end_DASH_column, int(22)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp7 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2792), kw_column, int(5), kw_end_DASH_line, int(2799), kw_end_DASH_column, int(23)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp5 any + { // let + // let binding "temp__0__auto__" + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := lang.Apply(tmp6, []any{v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + var tmp10 any + { // let + // let binding "s" + var v11 any = v8 + _ = v11 + var tmp12 any + tmp13 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp14 := lang.Apply(tmp13, []any{v11}) + if lang.IsTruthy(tmp14) { + var tmp15 any + { // let + // let binding "c" + tmp16 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp17 := lang.Apply(tmp16, []any{v11}) + var v18 any = tmp17 + _ = v18 + // let binding "size" + tmp19 := checkDerefVar(var_glojure_DOT_core_count) + tmp20 := lang.Apply(tmp19, []any{v18}) + var v21 any = tmp20 + _ = v21 + // let binding "b" + tmp22 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_buffer) + tmp23 := lang.Apply(tmp22, []any{v21}) + var v24 any = tmp23 + _ = v24 + var tmp25 any + { // let + // let binding "n__0__auto__" + tmp26 := lang.Apply(lang.LongCast, []any{v21}) + var v27 any = tmp26 + _ = v27 + var tmp28 any + { // let + // let binding "i" + var v29 any = int64(0) + _ = v29 + for { + var tmp30 any + tmp31 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp32 := lang.Apply(tmp31, []any{v29, v27}) + if lang.IsTruthy(tmp32) { + var tmp33 any + { // let + // let binding "v" + tmp34, _ := lang.FieldOrMethod(v18, "nth") + if reflect.TypeOf(tmp34).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp35 := lang.Apply(tmp34, []any{v29}) + var v36 any = tmp35 + _ = v36 + var tmp37 any + tmp38 := lang.Apply(v2, []any{v36}) + if lang.IsTruthy(tmp38) { + tmp39 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_append) + tmp40 := lang.Apply(tmp39, []any{v24, v36}) + tmp37 = tmp40 + } else { + } + tmp33 = tmp37 + } // end let + _ = tmp33 + tmp35 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp36 := lang.Apply(tmp35, []any{v29}) + var tmp34 any = tmp36 + v29 = tmp34 + continue + } else { + } + tmp28 = tmp30 + break + } + } // end let + tmp25 = tmp28 + } // end let + _ = tmp25 + tmp26 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_cons) + tmp27 := checkDerefVar(var_glojure_DOT_core_chunk) + tmp28 := lang.Apply(tmp27, []any{v24}) + tmp29 := checkDerefVar(var_glojure_DOT_core_filter) + tmp30 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp31 := lang.Apply(tmp30, []any{v11}) + tmp32 := lang.Apply(tmp29, []any{v2, tmp31}) + tmp33 := lang.Apply(tmp26, []any{tmp28, tmp32}) + tmp15 = tmp33 + } // end let + tmp12 = tmp15 + } else { + var tmp16 any + { // let + // let binding "f" + tmp17 := checkDerefVar(var_glojure_DOT_core_first) + tmp18 := lang.Apply(tmp17, []any{v11}) + var v19 any = tmp18 + _ = v19 + // let binding "r" + tmp20 := checkDerefVar(var_glojure_DOT_core_rest) + tmp21 := lang.Apply(tmp20, []any{v11}) + var v22 any = tmp21 + _ = v22 + var tmp23 any + tmp24 := lang.Apply(v2, []any{v19}) + if lang.IsTruthy(tmp24) { + tmp25 := checkDerefVar(var_glojure_DOT_core_cons) + tmp26 := checkDerefVar(var_glojure_DOT_core_filter) + tmp27 := lang.Apply(tmp26, []any{v2, v22}) + tmp28 := lang.Apply(tmp25, []any{v19, tmp27}) + tmp23 = tmp28 + } else { + tmp29 := checkDerefVar(var_glojure_DOT_core_filter) + tmp30 := lang.Apply(tmp29, []any{v2, v22}) + tmp23 = tmp30 + } + tmp16 = tmp23 + } // end let + tmp12 = tmp16 + } + tmp10 = tmp12 + } // end let + tmp9 = tmp10 + } else { + } + tmp5 = tmp9 + } // end let + return tmp5 + }) + tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_filter = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_filter.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // fnil + { + tmp0 := sym_fnil.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_x), lang.NewVector(sym_f, sym_x, sym_y), lang.NewVector(sym_f, sym_x, sym_y, sym_z)), kw_doc, "Takes a function f, and returns a function that calls f, replacing\n a nil first argument to f with the supplied value x. Higher arity\n versions can replace arguments in the second and third\n positions (y, z). Note that the function f can take any number of\n arguments, not just the one(s) being nil-patched.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(6558), kw_end_DASH_line, int(6558))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v5 := args[0] + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v5}) + if lang.IsTruthy(tmp8) { + tmp6 = v3 + } else { + tmp6 = v5 + } + tmp9 := lang.Apply(v2, []any{tmp6}) + return tmp9 + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp9 := lang.Apply(tmp8, []any{v5}) + if lang.IsTruthy(tmp9) { + tmp7 = v3 + } else { + tmp7 = v5 + } + tmp10 := lang.Apply(v2, []any{tmp7, v6}) + return tmp10 + case 3: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := args[2] + _ = v7 + var tmp8 any + tmp9 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp10 := lang.Apply(tmp9, []any{v5}) + if lang.IsTruthy(tmp10) { + tmp8 = v3 + } else { + tmp8 = v5 + } + tmp11 := lang.Apply(v2, []any{tmp8, v6, v7}) + return tmp11 + default: + checkArity(args, 3) + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := args[2] + _ = v7 + var v8 any = lang.NewList(args[3:]...) + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_apply) + var tmp10 any + tmp11 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp12 := lang.Apply(tmp11, []any{v5}) + if lang.IsTruthy(tmp12) { + tmp10 = v3 + } else { + tmp10 = v5 + } + tmp13 := lang.Apply(tmp9, []any{v2, tmp10, v6, v7, v8}) + return tmp13 + } + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6567), kw_column, int(4), kw_end_DASH_line, int(6571), kw_end_DASH_column, int(55)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + var tmp8 any + tmp9 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp10 := lang.Apply(tmp9, []any{v6}) + if lang.IsTruthy(tmp10) { + tmp8 = v3 + } else { + tmp8 = v6 + } + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp13 := lang.Apply(tmp12, []any{v7}) + if lang.IsTruthy(tmp13) { + tmp11 = v4 + } else { + tmp11 = v7 + } + tmp14 := lang.Apply(v2, []any{tmp8, tmp11}) + return tmp14 + case 3: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp11 := lang.Apply(tmp10, []any{v6}) + if lang.IsTruthy(tmp11) { + tmp9 = v3 + } else { + tmp9 = v6 + } + var tmp12 any + tmp13 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp14 := lang.Apply(tmp13, []any{v7}) + if lang.IsTruthy(tmp14) { + tmp12 = v4 + } else { + tmp12 = v7 + } + tmp15 := lang.Apply(v2, []any{tmp9, tmp12, v8}) + return tmp15 + default: + checkArity(args, 3) + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + var v9 any = lang.NewList(args[3:]...) + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_apply) + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp13 := lang.Apply(tmp12, []any{v6}) + if lang.IsTruthy(tmp13) { + tmp11 = v3 + } else { + tmp11 = v6 + } + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp16 := lang.Apply(tmp15, []any{v7}) + if lang.IsTruthy(tmp16) { + tmp14 = v4 + } else { + tmp14 = v7 + } + tmp17 := lang.Apply(tmp10, []any{v2, tmp11, tmp14, v8, v9}) + return tmp17 + } + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6573), kw_column, int(4), kw_end_DASH_line, int(6576), kw_end_DASH_column, int(71)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp7 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp11 := lang.Apply(tmp10, []any{v7}) + if lang.IsTruthy(tmp11) { + tmp9 = v3 + } else { + tmp9 = v7 + } + var tmp12 any + tmp13 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp14 := lang.Apply(tmp13, []any{v8}) + if lang.IsTruthy(tmp14) { + tmp12 = v4 + } else { + tmp12 = v8 + } + tmp15 := lang.Apply(v2, []any{tmp9, tmp12}) + return tmp15 + case 3: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + var tmp10 any + tmp11 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp12 := lang.Apply(tmp11, []any{v7}) + if lang.IsTruthy(tmp12) { + tmp10 = v3 + } else { + tmp10 = v7 + } + var tmp13 any + tmp14 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp15 := lang.Apply(tmp14, []any{v8}) + if lang.IsTruthy(tmp15) { + tmp13 = v4 + } else { + tmp13 = v8 + } + var tmp16 any + tmp17 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp18 := lang.Apply(tmp17, []any{v9}) + if lang.IsTruthy(tmp18) { + tmp16 = v5 + } else { + tmp16 = v9 + } + tmp19 := lang.Apply(v2, []any{tmp10, tmp13, tmp16}) + return tmp19 + default: + checkArity(args, 3) + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + var v10 any = lang.NewList(args[3:]...) + _ = v10 + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + var tmp12 any + tmp13 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp14 := lang.Apply(tmp13, []any{v7}) + if lang.IsTruthy(tmp14) { + tmp12 = v3 + } else { + tmp12 = v7 + } + var tmp15 any + tmp16 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp17 := lang.Apply(tmp16, []any{v8}) + if lang.IsTruthy(tmp17) { + tmp15 = v4 + } else { + tmp15 = v8 + } + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp20 := lang.Apply(tmp19, []any{v9}) + if lang.IsTruthy(tmp20) { + tmp18 = v5 + } else { + tmp18 = v9 + } + tmp21 := lang.Apply(tmp11, []any{v2, tmp12, tmp15, tmp18, v10}) + return tmp21 + } + }) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6578), kw_column, int(4), kw_end_DASH_line, int(6581), kw_end_DASH_column, int(87)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp8 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_fnil = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_fnil.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // format + { + tmp0 := sym_format.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_fmt, sym__AMP_, sym_args)), kw_doc, "Formats a string using java.lang.String.format, see java.util.Formatter for format\n string syntax", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(5717), kw_end_DASH_line, int(5717))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_apply) + tmp5 := lang.Apply(tmp4, []any{fmt.Sprintf, v2, v3}) + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_format = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_format.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // future + { + tmp0 := sym_future.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_body)), kw_doc, "Takes a body of expressions and yields a future object that will\n invoke the body in another thread, and will cache the result and\n return it on all subsequent calls to deref/@. If the computation has\n not yet finished, calls to deref/@ will block, unless the variant of\n deref with timeout is used. See also - realized?.", kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(11), kw_line, int(7009), kw_end_DASH_line, int(7009))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym_glojure_DOT_core_SLASH_future_DASH_call}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := checkDerefVar(var_glojure_DOT_core_seq) + tmp11 := checkDerefVar(var_glojure_DOT_core_concat) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_fn_STAR_}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_apply) + tmp16 := checkDerefVar(var_glojure_DOT_core_vector) + tmp17 := checkDerefVar(var_glojure_DOT_core_seq) + tmp18 := checkDerefVar(var_glojure_DOT_core_concat) + tmp19 := lang.Apply(tmp18, nil) + tmp20 := lang.Apply(tmp17, []any{tmp19}) + tmp21 := lang.Apply(tmp15, []any{tmp16, tmp20}) + tmp22 := lang.Apply(tmp14, []any{tmp21}) + tmp23 := lang.Apply(tmp11, []any{tmp13, tmp22, v4}) + tmp24 := lang.Apply(tmp10, []any{tmp23}) + tmp25 := lang.Apply(tmp9, []any{tmp24}) + tmp26 := lang.Apply(tmp6, []any{tmp8, tmp25}) + tmp27 := lang.Apply(tmp5, []any{tmp26}) + return tmp27 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_future = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_future.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // future-call + { + tmp0 := sym_future_DASH_call.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f)), kw_doc, "Takes a function of no args and yields a future object that will\n invoke the function in another thread, and will cache the result and\n return it on all subsequent calls to deref/@. If the computation has\n not yet finished, calls to deref/@ will block, unless the variant\n of deref with timeout is used. See also - realized?.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(7003), kw_end_DASH_line, int(7003))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "f" + tmp4 := checkDerefVar(var_glojure_DOT_core_binding_DASH_conveyor_DASH_fn) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + // let binding "fut" + tmp7 := lang.Apply(lang.AgentSubmit, []any{v6}) + var v8 any = tmp7 + _ = v8 + tmp3 = v8 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_future_DASH_call = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_future_DASH_call.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // get-in + { + tmp0 := sym_get_DASH_in.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m, sym_ks), lang.NewVector(sym_m, sym_ks, sym_not_DASH_found)), kw_doc, "Returns the value in a nested associative structure,\n where ks is a sequence of keys. Returns nil if the key\n is not present, or the not-found value if supplied.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(6128), kw_end_DASH_line, int(6128))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp5 := checkDerefVar(var_glojure_DOT_core_get) + tmp6 := lang.Apply(tmp4, []any{tmp5, v2, v3}) + return tmp6 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + { // let + // let binding "sentinel" + tmp6 := lang.Apply(reflect.StructOf, []any{nil}) + tmp7 := lang.Apply(reflect.New, []any{tmp6}) + tmp8, ok := lang.FieldOrMethod(tmp7, "Interface") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp7, "Interface"))) + } + var tmp9 any + switch reflect.TypeOf(tmp8).Kind() { + case reflect.Func: + tmp9 = lang.Apply(tmp8, nil) + default: + tmp9 = tmp8 + } + var v10 any = tmp9 + _ = v10 + // let binding "m" + var v11 any = v2 + _ = v11 + // let binding "ks" + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := lang.Apply(tmp12, []any{v3}) + var v14 any = tmp13 + _ = v14 + for { + var tmp15 any + if lang.IsTruthy(v14) { + var tmp16 any + { // let + // let binding "m" + tmp17 := checkDerefVar(var_glojure_DOT_core_get) + tmp18 := checkDerefVar(var_glojure_DOT_core_first) + tmp19 := lang.Apply(tmp18, []any{v14}) + tmp20 := lang.Apply(tmp17, []any{v11, tmp19, v10}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + tmp23 := checkDerefVar(var_glojure_DOT_core_identical_QMARK_) + tmp24 := lang.Apply(tmp23, []any{v10, v21}) + if lang.IsTruthy(tmp24) { + tmp22 = v4 + } else { + var tmp25 any = v10 + var tmp26 any = v21 + tmp28 := checkDerefVar(var_glojure_DOT_core_next) + tmp29 := lang.Apply(tmp28, []any{v14}) + var tmp27 any = tmp29 + v10 = tmp25 + v11 = tmp26 + v14 = tmp27 + continue + } + tmp16 = tmp22 + } // end let + tmp15 = tmp16 + } else { + tmp15 = v11 + } + tmp5 = tmp15 + break + } + } // end let + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_get_DASH_in = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_get_DASH_in.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // if-let + { + tmp0 := sym_if_DASH_let.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym_then), lang.NewVector(sym_bindings, sym_then, sym_else, sym__AMP_, sym_oldform)), kw_doc, "bindings => binding-form test\n\n If test is true, evaluates then with binding-form bound to the value of \n test, if not, yields else", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(11), kw_line, int(1839), kw_end_DASH_line, int(1839))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_if_DASH_let}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{v4}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v5}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{nil}) + tmp16 := lang.Apply(tmp7, []any{tmp9, tmp11, tmp13, tmp15}) + tmp17 := lang.Apply(tmp6, []any{tmp16}) + return tmp17 + default: + checkArity(args, 5) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + var v7 any = lang.NewList(args[5:]...) + _ = v7 + var tmp8 any + tmp9 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp10 := lang.Apply(tmp9, []any{v4}) + if lang.IsTruthy(tmp10) { + } else { + tmp11 := checkDerefVar(var_glojure_DOT_core_str) + tmp12 := checkDerefVar(var_glojure_DOT_core_first) + tmp13 := lang.Apply(tmp12, []any{v2}) + tmp14 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp15 := checkDerefVar(var_glojure_DOT_core_meta) + tmp16 := lang.Apply(tmp15, []any{v2}) + tmp17 := lang.Apply(kw_line, []any{tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp13, " requires ", "a vector for its binding", " in ", tmp14, ":", tmp17}) + tmp19 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp18}) + panic(tmp19) + } + _ = tmp8 + var tmp20 any + tmp21 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp22 := lang.Apply(tmp21, []any{v7}) + if lang.IsTruthy(tmp22) { + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp27 := checkDerefVar(var_glojure_DOT_core_meta) + tmp28 := lang.Apply(tmp27, []any{v2}) + tmp29 := lang.Apply(kw_line, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp25, " requires ", "1 or 2 forms after binding vector", " in ", tmp26, ":", tmp29}) + tmp31 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp31) + } + _ = tmp20 + var tmp32 any + tmp33 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp34 := checkDerefVar(var_glojure_DOT_core_count) + tmp35 := lang.Apply(tmp34, []any{v4}) + tmp36 := lang.Apply(tmp33, []any{int64(2), tmp35}) + if lang.IsTruthy(tmp36) { + } else { + tmp37 := checkDerefVar(var_glojure_DOT_core_str) + tmp38 := checkDerefVar(var_glojure_DOT_core_first) + tmp39 := lang.Apply(tmp38, []any{v2}) + tmp40 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp41 := checkDerefVar(var_glojure_DOT_core_meta) + tmp42 := lang.Apply(tmp41, []any{v2}) + tmp43 := lang.Apply(kw_line, []any{tmp42}) + tmp44 := lang.Apply(tmp37, []any{tmp39, " requires ", "exactly 2 forms in binding vector", " in ", tmp40, ":", tmp43}) + tmp45 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp44}) + panic(tmp45) + } + _ = tmp32 + var tmp46 any + { // let + // let binding "form" + tmp47 := lang.Apply(v4, []any{int64(0)}) + var v48 any = tmp47 + _ = v48 + // let binding "tst" + tmp49 := lang.Apply(v4, []any{int64(1)}) + var v50 any = tmp49 + _ = v50 + tmp51 := checkDerefVar(var_glojure_DOT_core_seq) + tmp52 := checkDerefVar(var_glojure_DOT_core_concat) + tmp53 := checkDerefVar(var_glojure_DOT_core_list) + tmp54 := lang.Apply(tmp53, []any{sym_glojure_DOT_core_SLASH_let}) + tmp55 := checkDerefVar(var_glojure_DOT_core_list) + tmp56 := checkDerefVar(var_glojure_DOT_core_apply) + tmp57 := checkDerefVar(var_glojure_DOT_core_vector) + tmp58 := checkDerefVar(var_glojure_DOT_core_seq) + tmp59 := checkDerefVar(var_glojure_DOT_core_concat) + tmp60 := checkDerefVar(var_glojure_DOT_core_list) + tmp61 := lang.Apply(tmp60, []any{sym_temp__0__auto__}) + tmp62 := checkDerefVar(var_glojure_DOT_core_list) + tmp63 := lang.Apply(tmp62, []any{v50}) + tmp64 := lang.Apply(tmp59, []any{tmp61, tmp63}) + tmp65 := lang.Apply(tmp58, []any{tmp64}) + tmp66 := lang.Apply(tmp56, []any{tmp57, tmp65}) + tmp67 := lang.Apply(tmp55, []any{tmp66}) + tmp68 := checkDerefVar(var_glojure_DOT_core_list) + tmp69 := checkDerefVar(var_glojure_DOT_core_seq) + tmp70 := checkDerefVar(var_glojure_DOT_core_concat) + tmp71 := checkDerefVar(var_glojure_DOT_core_list) + tmp72 := lang.Apply(tmp71, []any{sym_if}) + tmp73 := checkDerefVar(var_glojure_DOT_core_list) + tmp74 := lang.Apply(tmp73, []any{sym_temp__0__auto__}) + tmp75 := checkDerefVar(var_glojure_DOT_core_list) + tmp76 := checkDerefVar(var_glojure_DOT_core_seq) + tmp77 := checkDerefVar(var_glojure_DOT_core_concat) + tmp78 := checkDerefVar(var_glojure_DOT_core_list) + tmp79 := lang.Apply(tmp78, []any{sym_glojure_DOT_core_SLASH_let}) + tmp80 := checkDerefVar(var_glojure_DOT_core_list) + tmp81 := checkDerefVar(var_glojure_DOT_core_apply) + tmp82 := checkDerefVar(var_glojure_DOT_core_vector) + tmp83 := checkDerefVar(var_glojure_DOT_core_seq) + tmp84 := checkDerefVar(var_glojure_DOT_core_concat) + tmp85 := checkDerefVar(var_glojure_DOT_core_list) + tmp86 := lang.Apply(tmp85, []any{v48}) + tmp87 := checkDerefVar(var_glojure_DOT_core_list) + tmp88 := lang.Apply(tmp87, []any{sym_temp__0__auto__}) + tmp89 := lang.Apply(tmp84, []any{tmp86, tmp88}) + tmp90 := lang.Apply(tmp83, []any{tmp89}) + tmp91 := lang.Apply(tmp81, []any{tmp82, tmp90}) + tmp92 := lang.Apply(tmp80, []any{tmp91}) + tmp93 := checkDerefVar(var_glojure_DOT_core_list) + tmp94 := lang.Apply(tmp93, []any{v5}) + tmp95 := lang.Apply(tmp77, []any{tmp79, tmp92, tmp94}) + tmp96 := lang.Apply(tmp76, []any{tmp95}) + tmp97 := lang.Apply(tmp75, []any{tmp96}) + tmp98 := checkDerefVar(var_glojure_DOT_core_list) + tmp99 := lang.Apply(tmp98, []any{v6}) + tmp100 := lang.Apply(tmp70, []any{tmp72, tmp74, tmp97, tmp99}) + tmp101 := lang.Apply(tmp69, []any{tmp100}) + tmp102 := lang.Apply(tmp68, []any{tmp101}) + tmp103 := lang.Apply(tmp52, []any{tmp54, tmp67, tmp102}) + tmp104 := lang.Apply(tmp51, []any{tmp103}) + tmp46 = tmp104 + } // end let + return tmp46 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_if_DASH_let = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_if_DASH_let.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // if-some + { + tmp0 := sym_if_DASH_some.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym_then), lang.NewVector(sym_bindings, sym_then, sym_else, sym__AMP_, sym_oldform)), kw_doc, "bindings => binding-form test\n\n If test is not nil, evaluates then with binding-form bound to the\n value of test, if not, yields else", kw_file, "glojure/core.glj", kw_added, "1.6", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(1874), kw_end_DASH_line, int(1874))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_if_DASH_some}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{v4}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v5}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{nil}) + tmp16 := lang.Apply(tmp7, []any{tmp9, tmp11, tmp13, tmp15}) + tmp17 := lang.Apply(tmp6, []any{tmp16}) + return tmp17 + default: + checkArity(args, 5) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + var v7 any = lang.NewList(args[5:]...) + _ = v7 + var tmp8 any + tmp9 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp10 := lang.Apply(tmp9, []any{v4}) + if lang.IsTruthy(tmp10) { + } else { + tmp11 := checkDerefVar(var_glojure_DOT_core_str) + tmp12 := checkDerefVar(var_glojure_DOT_core_first) + tmp13 := lang.Apply(tmp12, []any{v2}) + tmp14 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp15 := checkDerefVar(var_glojure_DOT_core_meta) + tmp16 := lang.Apply(tmp15, []any{v2}) + tmp17 := lang.Apply(kw_line, []any{tmp16}) + tmp18 := lang.Apply(tmp11, []any{tmp13, " requires ", "a vector for its binding", " in ", tmp14, ":", tmp17}) + tmp19 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp18}) + panic(tmp19) + } + _ = tmp8 + var tmp20 any + tmp21 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp22 := lang.Apply(tmp21, []any{v7}) + if lang.IsTruthy(tmp22) { + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp27 := checkDerefVar(var_glojure_DOT_core_meta) + tmp28 := lang.Apply(tmp27, []any{v2}) + tmp29 := lang.Apply(kw_line, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp25, " requires ", "1 or 2 forms after binding vector", " in ", tmp26, ":", tmp29}) + tmp31 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp31) + } + _ = tmp20 + var tmp32 any + tmp33 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp34 := checkDerefVar(var_glojure_DOT_core_count) + tmp35 := lang.Apply(tmp34, []any{v4}) + tmp36 := lang.Apply(tmp33, []any{int64(2), tmp35}) + if lang.IsTruthy(tmp36) { + } else { + tmp37 := checkDerefVar(var_glojure_DOT_core_str) + tmp38 := checkDerefVar(var_glojure_DOT_core_first) + tmp39 := lang.Apply(tmp38, []any{v2}) + tmp40 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp41 := checkDerefVar(var_glojure_DOT_core_meta) + tmp42 := lang.Apply(tmp41, []any{v2}) + tmp43 := lang.Apply(kw_line, []any{tmp42}) + tmp44 := lang.Apply(tmp37, []any{tmp39, " requires ", "exactly 2 forms in binding vector", " in ", tmp40, ":", tmp43}) + tmp45 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp44}) + panic(tmp45) + } + _ = tmp32 + var tmp46 any + { // let + // let binding "form" + tmp47 := lang.Apply(v4, []any{int64(0)}) + var v48 any = tmp47 + _ = v48 + // let binding "tst" + tmp49 := lang.Apply(v4, []any{int64(1)}) + var v50 any = tmp49 + _ = v50 + tmp51 := checkDerefVar(var_glojure_DOT_core_seq) + tmp52 := checkDerefVar(var_glojure_DOT_core_concat) + tmp53 := checkDerefVar(var_glojure_DOT_core_list) + tmp54 := lang.Apply(tmp53, []any{sym_glojure_DOT_core_SLASH_let}) + tmp55 := checkDerefVar(var_glojure_DOT_core_list) + tmp56 := checkDerefVar(var_glojure_DOT_core_apply) + tmp57 := checkDerefVar(var_glojure_DOT_core_vector) + tmp58 := checkDerefVar(var_glojure_DOT_core_seq) + tmp59 := checkDerefVar(var_glojure_DOT_core_concat) + tmp60 := checkDerefVar(var_glojure_DOT_core_list) + tmp61 := lang.Apply(tmp60, []any{sym_temp__0__auto__}) + tmp62 := checkDerefVar(var_glojure_DOT_core_list) + tmp63 := lang.Apply(tmp62, []any{v50}) + tmp64 := lang.Apply(tmp59, []any{tmp61, tmp63}) + tmp65 := lang.Apply(tmp58, []any{tmp64}) + tmp66 := lang.Apply(tmp56, []any{tmp57, tmp65}) + tmp67 := lang.Apply(tmp55, []any{tmp66}) + tmp68 := checkDerefVar(var_glojure_DOT_core_list) + tmp69 := checkDerefVar(var_glojure_DOT_core_seq) + tmp70 := checkDerefVar(var_glojure_DOT_core_concat) + tmp71 := checkDerefVar(var_glojure_DOT_core_list) + tmp72 := lang.Apply(tmp71, []any{sym_if}) + tmp73 := checkDerefVar(var_glojure_DOT_core_list) + tmp74 := checkDerefVar(var_glojure_DOT_core_seq) + tmp75 := checkDerefVar(var_glojure_DOT_core_concat) + tmp76 := checkDerefVar(var_glojure_DOT_core_list) + tmp77 := lang.Apply(tmp76, []any{sym_glojure_DOT_core_SLASH_nil_QMARK_}) + tmp78 := checkDerefVar(var_glojure_DOT_core_list) + tmp79 := lang.Apply(tmp78, []any{sym_temp__0__auto__}) + tmp80 := lang.Apply(tmp75, []any{tmp77, tmp79}) + tmp81 := lang.Apply(tmp74, []any{tmp80}) + tmp82 := lang.Apply(tmp73, []any{tmp81}) + tmp83 := checkDerefVar(var_glojure_DOT_core_list) + tmp84 := lang.Apply(tmp83, []any{v6}) + tmp85 := checkDerefVar(var_glojure_DOT_core_list) + tmp86 := checkDerefVar(var_glojure_DOT_core_seq) + tmp87 := checkDerefVar(var_glojure_DOT_core_concat) + tmp88 := checkDerefVar(var_glojure_DOT_core_list) + tmp89 := lang.Apply(tmp88, []any{sym_glojure_DOT_core_SLASH_let}) + tmp90 := checkDerefVar(var_glojure_DOT_core_list) + tmp91 := checkDerefVar(var_glojure_DOT_core_apply) + tmp92 := checkDerefVar(var_glojure_DOT_core_vector) + tmp93 := checkDerefVar(var_glojure_DOT_core_seq) + tmp94 := checkDerefVar(var_glojure_DOT_core_concat) + tmp95 := checkDerefVar(var_glojure_DOT_core_list) + tmp96 := lang.Apply(tmp95, []any{v48}) + tmp97 := checkDerefVar(var_glojure_DOT_core_list) + tmp98 := lang.Apply(tmp97, []any{sym_temp__0__auto__}) + tmp99 := lang.Apply(tmp94, []any{tmp96, tmp98}) + tmp100 := lang.Apply(tmp93, []any{tmp99}) + tmp101 := lang.Apply(tmp91, []any{tmp92, tmp100}) + tmp102 := lang.Apply(tmp90, []any{tmp101}) + tmp103 := checkDerefVar(var_glojure_DOT_core_list) + tmp104 := lang.Apply(tmp103, []any{v5}) + tmp105 := lang.Apply(tmp87, []any{tmp89, tmp102, tmp104}) + tmp106 := lang.Apply(tmp86, []any{tmp105}) + tmp107 := lang.Apply(tmp85, []any{tmp106}) + tmp108 := lang.Apply(tmp70, []any{tmp72, tmp82, tmp84, tmp107}) + tmp109 := lang.Apply(tmp69, []any{tmp108}) + tmp110 := lang.Apply(tmp68, []any{tmp109}) + tmp111 := lang.Apply(tmp52, []any{tmp54, tmp67, tmp110}) + tmp112 := lang.Apply(tmp51, []any{tmp111}) + tmp46 = tmp112 + } // end let + return tmp46 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_if_DASH_some = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_if_DASH_some.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // into1 + { + tmp0 := sym_into1.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_to, sym_from)), kw_doc, "Returns a new coll consisting of to-coll with all of the items of\n from-coll conjoined.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(3416), kw_end_DASH_line, int(3416), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp6 := reflect.TypeOf((*lang.IEditableCollection)(nil)).Elem() + tmp7 := lang.Apply(tmp5, []any{tmp6, v2}) + if lang.IsTruthy(tmp7) { + tmp8 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp10 := checkDerefVar(var_glojure_DOT_core_conj_BANG_) + tmp11 := checkDerefVar(var_glojure_DOT_core_transient) + tmp12 := lang.Apply(tmp11, []any{v2}) + tmp13 := lang.Apply(tmp9, []any{tmp10, tmp12, v3}) + tmp14 := lang.Apply(tmp8, []any{tmp13}) + tmp4 = tmp14 + } else { + tmp15 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp16 := checkDerefVar(var_glojure_DOT_core_conj) + tmp17 := lang.Apply(tmp15, []any{tmp16, v2, v3}) + tmp4 = tmp17 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_into1 = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_into1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // juxt + { + tmp0 := sym_juxt.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_g), lang.NewVector(sym_f, sym_g, sym_h), lang.NewVector(sym_f, sym_g, sym_h, sym__AMP_, sym_fs)), kw_doc, "Takes a set of functions and returns a fn that is the juxtaposition\n of those fns. The returned fn takes a variable number of args, and\n returns a vector containing the result of applying each fn to the\n args (left-to-right).\n ((juxt a b c) x) => [(a x) (b x) (c x)]", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(2568), kw_end_DASH_line, int(2568))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp4 := lang.Apply(v2, nil) + tmp5 := lang.NewVector(tmp4) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2578), kw_column, int(12), kw_end_DASH_line, int(2578), kw_end_DASH_column, int(16)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp7 + case 1: + v4 := args[0] + _ = v4 + tmp5 := lang.Apply(v2, []any{v4}) + tmp6 := lang.NewVector(tmp5) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2579), kw_column, int(13), kw_end_DASH_line, int(2579), kw_end_DASH_column, int(19)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp8 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6 := lang.Apply(v2, []any{v4, v5}) + tmp7 := lang.NewVector(tmp6) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2580), kw_column, int(15), kw_end_DASH_line, int(2580), kw_end_DASH_column, int(23)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp9 + case 3: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := args[2] + _ = v6 + tmp7 := lang.Apply(v2, []any{v4, v5, v6}) + tmp8 := lang.NewVector(tmp7) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2581), kw_column, int(17), kw_end_DASH_line, int(2581), kw_end_DASH_column, int(27)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp10 + default: + checkArity(args, 3) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + v6 := args[2] + _ = v6 + var v7 any = lang.NewList(args[3:]...) + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_apply) + tmp9 := lang.Apply(tmp8, []any{v2, v4, v5, v6, v7}) + tmp10 := lang.NewVector(tmp9) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2582), kw_column, int(24), kw_end_DASH_line, int(2582), kw_end_DASH_column, int(45)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp12 + } + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2577), kw_column, int(6), kw_end_DASH_line, int(2582), kw_end_DASH_column, int(47)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp5 := lang.Apply(v2, nil) + tmp6 := lang.Apply(v3, nil) + tmp7 := lang.NewVector(tmp5, tmp6) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2585), kw_column, int(12), kw_end_DASH_line, int(2585), kw_end_DASH_column, int(20)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp9 + case 1: + v5 := args[0] + _ = v5 + tmp6 := lang.Apply(v2, []any{v5}) + tmp7 := lang.Apply(v3, []any{v5}) + tmp8 := lang.NewVector(tmp6, tmp7) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2586), kw_column, int(13), kw_end_DASH_line, int(2586), kw_end_DASH_column, int(25)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp10 + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + tmp7 := lang.Apply(v2, []any{v5, v6}) + tmp8 := lang.Apply(v3, []any{v5, v6}) + tmp9 := lang.NewVector(tmp7, tmp8) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2587), kw_column, int(15), kw_end_DASH_line, int(2587), kw_end_DASH_column, int(31)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp11 + case 3: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := args[2] + _ = v7 + tmp8 := lang.Apply(v2, []any{v5, v6, v7}) + tmp9 := lang.Apply(v3, []any{v5, v6, v7}) + tmp10 := lang.NewVector(tmp8, tmp9) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2588), kw_column, int(17), kw_end_DASH_line, int(2588), kw_end_DASH_column, int(37)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp12 + default: + checkArity(args, 3) + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := args[2] + _ = v7 + var v8 any = lang.NewList(args[3:]...) + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_apply) + tmp10 := lang.Apply(tmp9, []any{v2, v5, v6, v7, v8}) + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + tmp12 := lang.Apply(tmp11, []any{v3, v5, v6, v7, v8}) + tmp13 := lang.NewVector(tmp10, tmp12) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2589), kw_column, int(24), kw_end_DASH_line, int(2589), kw_end_DASH_column, int(66)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp15 + } + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2584), kw_column, int(6), kw_end_DASH_line, int(2589), kw_end_DASH_column, int(68)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp6 := lang.Apply(v2, nil) + tmp7 := lang.Apply(v3, nil) + tmp8 := lang.Apply(v4, nil) + tmp9 := lang.NewVector(tmp6, tmp7, tmp8) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2592), kw_column, int(12), kw_end_DASH_line, int(2592), kw_end_DASH_column, int(24)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp11 + case 1: + v6 := args[0] + _ = v6 + tmp7 := lang.Apply(v2, []any{v6}) + tmp8 := lang.Apply(v3, []any{v6}) + tmp9 := lang.Apply(v4, []any{v6}) + tmp10 := lang.NewVector(tmp7, tmp8, tmp9) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2593), kw_column, int(13), kw_end_DASH_line, int(2593), kw_end_DASH_column, int(31)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp12 + case 2: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + tmp8 := lang.Apply(v2, []any{v6, v7}) + tmp9 := lang.Apply(v3, []any{v6, v7}) + tmp10 := lang.Apply(v4, []any{v6, v7}) + tmp11 := lang.NewVector(tmp8, tmp9, tmp10) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2594), kw_column, int(15), kw_end_DASH_line, int(2594), kw_end_DASH_column, int(39)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp13 + case 3: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + tmp9 := lang.Apply(v2, []any{v6, v7, v8}) + tmp10 := lang.Apply(v3, []any{v6, v7, v8}) + tmp11 := lang.Apply(v4, []any{v6, v7, v8}) + tmp12 := lang.NewVector(tmp9, tmp10, tmp11) + tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2595), kw_column, int(17), kw_end_DASH_line, int(2595), kw_end_DASH_column, int(47)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp14 + default: + checkArity(args, 3) + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + var v9 any = lang.NewList(args[3:]...) + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_apply) + tmp11 := lang.Apply(tmp10, []any{v2, v6, v7, v8, v9}) + tmp12 := checkDerefVar(var_glojure_DOT_core_apply) + tmp13 := lang.Apply(tmp12, []any{v3, v6, v7, v8, v9}) + tmp14 := checkDerefVar(var_glojure_DOT_core_apply) + tmp15 := lang.Apply(tmp14, []any{v4, v6, v7, v8, v9}) + tmp16 := lang.NewVector(tmp11, tmp13, tmp15) + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2596), kw_column, int(24), kw_end_DASH_line, int(2596), kw_end_DASH_column, int(87)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp18 + } + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2591), kw_column, int(6), kw_end_DASH_line, int(2596), kw_end_DASH_column, int(89)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp7 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "fs" + tmp7 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp8 := lang.Apply(tmp7, []any{v2, v3, v4, v5}) + var v9 any = tmp8 + _ = v9 + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp11 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp12 lang.FnFunc + tmp12 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v13 := args[0] + _ = v13 + v14 := args[1] + _ = v14 + tmp15 := checkDerefVar(var_glojure_DOT_core_conj) + tmp16 := lang.Apply(v14, nil) + tmp17 := lang.Apply(tmp15, []any{v13, tmp16}) + return tmp17 + }) + tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2600), kw_column, int(23), kw_end_DASH_line, int(2600), kw_end_DASH_column, int(37)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp15 := lang.NewVector() + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2600), kw_column, int(39), kw_end_DASH_line, int(2600), kw_end_DASH_column, int(40)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp18 := lang.Apply(tmp11, []any{tmp14, tmp17, v9}) + return tmp18 + case 1: + v11 := args[0] + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v14 := args[0] + _ = v14 + v15 := args[1] + _ = v15 + tmp16 := checkDerefVar(var_glojure_DOT_core_conj) + tmp17 := lang.Apply(v15, []any{v11}) + tmp18 := lang.Apply(tmp16, []any{v14, tmp17}) + return tmp18 + }) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2601), kw_column, int(24), kw_end_DASH_line, int(2601), kw_end_DASH_column, int(40)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp16 := lang.NewVector() + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2601), kw_column, int(42), kw_end_DASH_line, int(2601), kw_end_DASH_column, int(43)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp19 := lang.Apply(tmp12, []any{tmp15, tmp18, v9}) + return tmp19 + case 2: + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v15 := args[0] + _ = v15 + v16 := args[1] + _ = v16 + tmp17 := checkDerefVar(var_glojure_DOT_core_conj) + tmp18 := lang.Apply(v16, []any{v11, v12}) + tmp19 := lang.Apply(tmp17, []any{v15, tmp18}) + return tmp19 + }) + tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2602), kw_column, int(26), kw_end_DASH_line, int(2602), kw_end_DASH_column, int(44)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp17 := lang.NewVector() + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2602), kw_column, int(46), kw_end_DASH_line, int(2602), kw_end_DASH_column, int(47)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp20 := lang.Apply(tmp13, []any{tmp16, tmp19, v9}) + return tmp20 + case 3: + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + v13 := args[2] + _ = v13 + tmp14 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp15 lang.FnFunc + tmp15 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v16 := args[0] + _ = v16 + v17 := args[1] + _ = v17 + tmp18 := checkDerefVar(var_glojure_DOT_core_conj) + tmp19 := lang.Apply(v17, []any{v11, v12, v13}) + tmp20 := lang.Apply(tmp18, []any{v16, tmp19}) + return tmp20 + }) + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2603), kw_column, int(28), kw_end_DASH_line, int(2603), kw_end_DASH_column, int(48)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp18 := lang.NewVector() + tmp19 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2603), kw_column, int(50), kw_end_DASH_line, int(2603), kw_end_DASH_column, int(51)) + tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp21 := lang.Apply(tmp14, []any{tmp17, tmp20, v9}) + return tmp21 + default: + checkArity(args, 3) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + v13 := args[2] + _ = v13 + var v14 any = lang.NewList(args[3:]...) + _ = v14 + tmp15 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp16 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v17 := args[0] + _ = v17 + v18 := args[1] + _ = v18 + tmp19 := checkDerefVar(var_glojure_DOT_core_conj) + tmp20 := checkDerefVar(var_glojure_DOT_core_apply) + tmp21 := lang.Apply(tmp20, []any{v18, v11, v12, v13, v14}) + tmp22 := lang.Apply(tmp19, []any{v17, tmp21}) + return tmp22 + }) + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2604), kw_column, int(35), kw_end_DASH_line, int(2604), kw_end_DASH_column, int(66)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp19 := lang.NewVector() + tmp20 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2604), kw_column, int(68), kw_end_DASH_line, int(2604), kw_end_DASH_column, int(69)) + tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp22 := lang.Apply(tmp15, []any{tmp18, tmp21, v9}) + return tmp22 + } + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2599), kw_column, int(8), kw_end_DASH_line, int(2604), kw_end_DASH_column, int(75)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp6 = tmp12 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_juxt = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_juxt.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // keep + { + tmp0 := sym_keep.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_coll)), kw_doc, "Returns a lazy sequence of the non-nil results of (f item). Note,\n this means false return values will be included. f must be free of\n side-effects. Returns a transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(7339), kw_end_DASH_line, int(7339))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp6 := lang.Apply(v4, nil) + return tmp6 + case 1: + v6 := args[0] + _ = v6 + tmp7 := lang.Apply(v4, []any{v6}) + return tmp7 + case 2: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + var tmp8 any + { // let + // let binding "v" + tmp9 := lang.Apply(v2, []any{v7}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp13 := lang.Apply(tmp12, []any{v10}) + if lang.IsTruthy(tmp13) { + tmp11 = v6 + } else { + tmp14 := lang.Apply(v4, []any{v6, v10}) + tmp11 = tmp14 + } + tmp8 = tmp11 + } // end let + return tmp8 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7347), kw_column, int(6), kw_end_DASH_line, int(7354), kw_end_DASH_column, int(31)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp7 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7346), kw_column, int(4), kw_end_DASH_line, int(7354), kw_end_DASH_column, int(32)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp5 any + { // let + // let binding "temp__0__auto__" + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := lang.Apply(tmp6, []any{v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + var tmp10 any + { // let + // let binding "s" + var v11 any = v8 + _ = v11 + var tmp12 any + tmp13 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp14 := lang.Apply(tmp13, []any{v11}) + if lang.IsTruthy(tmp14) { + var tmp15 any + { // let + // let binding "c" + tmp16 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp17 := lang.Apply(tmp16, []any{v11}) + var v18 any = tmp17 + _ = v18 + // let binding "size" + tmp19 := checkDerefVar(var_glojure_DOT_core_count) + tmp20 := lang.Apply(tmp19, []any{v18}) + var v21 any = tmp20 + _ = v21 + // let binding "b" + tmp22 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_buffer) + tmp23 := lang.Apply(tmp22, []any{v21}) + var v24 any = tmp23 + _ = v24 + var tmp25 any + { // let + // let binding "n__0__auto__" + tmp26 := checkDerefVar(var_glojure_DOT_core_long) + tmp27 := lang.Apply(tmp26, []any{v21}) + var v28 any = tmp27 + _ = v28 + var tmp29 any + { // let + // let binding "i" + var v30 any = int64(0) + _ = v30 + for { + var tmp31 any + tmp32 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp33 := lang.Apply(tmp32, []any{v30, v28}) + if lang.IsTruthy(tmp33) { + var tmp34 any + { // let + // let binding "x" + tmp35, _ := lang.FieldOrMethod(v18, "nth") + if reflect.TypeOf(tmp35).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp36 := lang.Apply(tmp35, []any{v30}) + tmp37 := lang.Apply(v2, []any{tmp36}) + var v38 any = tmp37 + _ = v38 + var tmp39 any + tmp40 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp41 := lang.Apply(tmp40, []any{v38}) + if lang.IsTruthy(tmp41) { + } else { + tmp42 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_append) + tmp43 := lang.Apply(tmp42, []any{v24, v38}) + tmp39 = tmp43 + } + tmp34 = tmp39 + } // end let + _ = tmp34 + tmp36 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp37 := lang.Apply(tmp36, []any{v30}) + var tmp35 any = tmp37 + v30 = tmp35 + continue + } else { + } + tmp29 = tmp31 + break + } + } // end let + tmp25 = tmp29 + } // end let + _ = tmp25 + tmp26 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_cons) + tmp27 := checkDerefVar(var_glojure_DOT_core_chunk) + tmp28 := lang.Apply(tmp27, []any{v24}) + tmp29 := checkDerefVar(var_glojure_DOT_core_keep) + tmp30 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp31 := lang.Apply(tmp30, []any{v11}) + tmp32 := lang.Apply(tmp29, []any{v2, tmp31}) + tmp33 := lang.Apply(tmp26, []any{tmp28, tmp32}) + tmp15 = tmp33 + } // end let + tmp12 = tmp15 + } else { + var tmp16 any + { // let + // let binding "x" + tmp17 := checkDerefVar(var_glojure_DOT_core_first) + tmp18 := lang.Apply(tmp17, []any{v11}) + tmp19 := lang.Apply(v2, []any{tmp18}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + tmp22 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp23 := lang.Apply(tmp22, []any{v20}) + if lang.IsTruthy(tmp23) { + tmp24 := checkDerefVar(var_glojure_DOT_core_keep) + tmp25 := checkDerefVar(var_glojure_DOT_core_rest) + tmp26 := lang.Apply(tmp25, []any{v11}) + tmp27 := lang.Apply(tmp24, []any{v2, tmp26}) + tmp21 = tmp27 + } else { + tmp28 := checkDerefVar(var_glojure_DOT_core_cons) + tmp29 := checkDerefVar(var_glojure_DOT_core_keep) + tmp30 := checkDerefVar(var_glojure_DOT_core_rest) + tmp31 := lang.Apply(tmp30, []any{v11}) + tmp32 := lang.Apply(tmp29, []any{v2, tmp31}) + tmp33 := lang.Apply(tmp28, []any{v20, tmp32}) + tmp21 = tmp33 + } + tmp16 = tmp21 + } // end let + tmp12 = tmp16 + } + tmp10 = tmp12 + } // end let + tmp9 = tmp10 + } else { + } + tmp5 = tmp9 + } // end let + return tmp5 + }) + tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_keep = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_keep.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // lazy-seq + { + tmp0 := sym_lazy_DASH_seq.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_body)), kw_doc, "Takes a body of expressions that returns an ISeq or nil, and yields\n a Seqable object that will invoke the body only the first time seq\n is called, and will cache the result and return it on all subsequent\n seq calls. See also - realized?", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(11), kw_line, int(676), kw_end_DASH_line, int(676))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_list) + tmp6 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp7 := lang.NewVector() + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(683), kw_column, int(101), kw_end_DASH_line, int(683), kw_end_DASH_column, int(102)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp10 := lang.Apply(tmp6, []any{sym_fn_STAR_, tmp9, v4}) + tmp11 := lang.Apply(tmp5, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_NewLazySeq, tmp10}) + return tmp11 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_lazy_DASH_seq = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_lazy_DASH_seq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // locking + { + tmp0 := sym_locking.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_x, sym__AMP_, sym_body)), kw_doc, "Executes exprs in an implicit do, while holding the monitor of x.\n Will release the monitor of x in all circumstances.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(1643), kw_end_DASH_line, int(1643))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_let}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + tmp12 := checkDerefVar(var_glojure_DOT_core_vector) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_lockee__0__auto__}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v4}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp19}) + tmp21 := lang.Apply(tmp11, []any{tmp12, tmp20}) + tmp22 := lang.Apply(tmp10, []any{tmp21}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_seq) + tmp25 := checkDerefVar(var_glojure_DOT_core_concat) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{sym_try}) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := checkDerefVar(var_glojure_DOT_core_seq) + tmp30 := checkDerefVar(var_glojure_DOT_core_concat) + tmp31 := checkDerefVar(var_glojure_DOT_core_list) + tmp32 := lang.Apply(tmp31, []any{sym_glojure_DOT_core_SLASH_let}) + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := checkDerefVar(var_glojure_DOT_core_apply) + tmp35 := checkDerefVar(var_glojure_DOT_core_vector) + tmp36 := checkDerefVar(var_glojure_DOT_core_seq) + tmp37 := checkDerefVar(var_glojure_DOT_core_concat) + tmp38 := checkDerefVar(var_glojure_DOT_core_list) + tmp39 := lang.Apply(tmp38, []any{sym_locklocal__1__auto__}) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{sym_lockee__0__auto__}) + tmp42 := lang.Apply(tmp37, []any{tmp39, tmp41}) + tmp43 := lang.Apply(tmp36, []any{tmp42}) + tmp44 := lang.Apply(tmp34, []any{tmp35, tmp43}) + tmp45 := lang.Apply(tmp33, []any{tmp44}) + tmp46 := checkDerefVar(var_glojure_DOT_core_list) + tmp47 := checkDerefVar(var_glojure_DOT_core_seq) + tmp48 := checkDerefVar(var_glojure_DOT_core_concat) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) + tmp50 := lang.Apply(tmp49, []any{sym_monitor_DASH_enter}) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := lang.Apply(tmp51, []any{sym_locklocal__1__auto__}) + tmp53 := lang.Apply(tmp48, []any{tmp50, tmp52}) + tmp54 := lang.Apply(tmp47, []any{tmp53}) + tmp55 := lang.Apply(tmp46, []any{tmp54}) + tmp56 := checkDerefVar(var_glojure_DOT_core_list) + tmp57 := checkDerefVar(var_glojure_DOT_core_seq) + tmp58 := checkDerefVar(var_glojure_DOT_core_concat) + tmp59 := checkDerefVar(var_glojure_DOT_core_list) + tmp60 := lang.Apply(tmp59, []any{sym_try}) + tmp61 := checkDerefVar(var_glojure_DOT_core_list) + tmp62 := checkDerefVar(var_glojure_DOT_core_seq) + tmp63 := checkDerefVar(var_glojure_DOT_core_concat) + tmp64 := checkDerefVar(var_glojure_DOT_core_list) + tmp65 := lang.Apply(tmp64, []any{sym_finally}) + tmp66 := checkDerefVar(var_glojure_DOT_core_list) + tmp67 := checkDerefVar(var_glojure_DOT_core_seq) + tmp68 := checkDerefVar(var_glojure_DOT_core_concat) + tmp69 := checkDerefVar(var_glojure_DOT_core_list) + tmp70 := lang.Apply(tmp69, []any{sym_monitor_DASH_exit}) + tmp71 := checkDerefVar(var_glojure_DOT_core_list) + tmp72 := lang.Apply(tmp71, []any{sym_locklocal__1__auto__}) + tmp73 := lang.Apply(tmp68, []any{tmp70, tmp72}) + tmp74 := lang.Apply(tmp67, []any{tmp73}) + tmp75 := lang.Apply(tmp66, []any{tmp74}) + tmp76 := lang.Apply(tmp63, []any{tmp65, tmp75}) + tmp77 := lang.Apply(tmp62, []any{tmp76}) + tmp78 := lang.Apply(tmp61, []any{tmp77}) + tmp79 := lang.Apply(tmp58, []any{tmp60, v5, tmp78}) + tmp80 := lang.Apply(tmp57, []any{tmp79}) + tmp81 := lang.Apply(tmp56, []any{tmp80}) + tmp82 := lang.Apply(tmp30, []any{tmp32, tmp45, tmp55, tmp81}) + tmp83 := lang.Apply(tmp29, []any{tmp82}) + tmp84 := lang.Apply(tmp28, []any{tmp83}) + tmp85 := lang.Apply(tmp25, []any{tmp27, tmp84}) + tmp86 := lang.Apply(tmp24, []any{tmp85}) + tmp87 := lang.Apply(tmp23, []any{tmp86}) + tmp88 := lang.Apply(tmp7, []any{tmp9, tmp22, tmp87}) + tmp89 := lang.Apply(tmp6, []any{tmp88}) + return tmp89 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_locking = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_locking.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // map + { + tmp0 := sym_map.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_coll), lang.NewVector(sym_f, sym_c1, sym_c2), lang.NewVector(sym_f, sym_c1, sym_c2, sym_c3), lang.NewVector(sym_f, sym_c1, sym_c2, sym_c3, sym__AMP_, sym_colls)), kw_doc, "Returns a lazy sequence consisting of the result of applying f to\n the set of first items of each coll, followed by applying f to the\n set of second items in each coll, until any one of the colls is\n exhausted. Any remaining items in other colls are ignored. Function\n f should accept number-of-colls arguments. Returns a transducer when\n no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(2719), kw_end_DASH_line, int(2719))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp6 := lang.Apply(v4, nil) + return tmp6 + case 1: + v6 := args[0] + _ = v6 + tmp7 := lang.Apply(v4, []any{v6}) + return tmp7 + case 2: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + tmp8 := lang.Apply(v2, []any{v7}) + tmp9 := lang.Apply(v4, []any{v6, tmp8}) + return tmp9 + default: + checkArity(args, 2) + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + var v8 any = lang.NewList(args[2:]...) + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_apply) + tmp10 := lang.Apply(tmp9, []any{v2, v7, v8}) + tmp11 := lang.Apply(v4, []any{v6, tmp10}) + return tmp11 + } + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2730), kw_column, int(7), kw_end_DASH_line, int(2736), kw_end_DASH_column, int(47)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp7 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2729), kw_column, int(5), kw_end_DASH_line, int(2736), kw_end_DASH_column, int(48)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp5 any + { // let + // let binding "temp__0__auto__" + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := lang.Apply(tmp6, []any{v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + var tmp10 any + { // let + // let binding "s" + var v11 any = v8 + _ = v11 + var tmp12 any + tmp13 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp14 := lang.Apply(tmp13, []any{v11}) + if lang.IsTruthy(tmp14) { + var tmp15 any + { // let + // let binding "c" + tmp16 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp17 := lang.Apply(tmp16, []any{v11}) + var v18 any = tmp17 + _ = v18 + // let binding "size" + tmp19 := checkDerefVar(var_glojure_DOT_core_int) + tmp20 := checkDerefVar(var_glojure_DOT_core_count) + tmp21 := lang.Apply(tmp20, []any{v18}) + tmp22 := lang.Apply(tmp19, []any{tmp21}) + var v23 any = tmp22 + _ = v23 + // let binding "b" + tmp24 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_buffer) + tmp25 := lang.Apply(tmp24, []any{v23}) + var v26 any = tmp25 + _ = v26 + var tmp27 any + { // let + // let binding "n__0__auto__" + tmp28 := lang.Apply(lang.LongCast, []any{v23}) + var v29 any = tmp28 + _ = v29 + var tmp30 any + { // let + // let binding "i" + var v31 any = int64(0) + _ = v31 + for { + var tmp32 any + tmp33 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp34 := lang.Apply(tmp33, []any{v31, v29}) + if lang.IsTruthy(tmp34) { + tmp35 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_append) + tmp36, _ := lang.FieldOrMethod(v18, "nth") + if reflect.TypeOf(tmp36).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp37 := lang.Apply(tmp36, []any{v31}) + tmp38 := lang.Apply(v2, []any{tmp37}) + tmp39 := lang.Apply(tmp35, []any{v26, tmp38}) + _ = tmp39 + tmp41 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp42 := lang.Apply(tmp41, []any{v31}) + var tmp40 any = tmp42 + v31 = tmp40 + continue + } else { + } + tmp30 = tmp32 + break + } + } // end let + tmp27 = tmp30 + } // end let + _ = tmp27 + tmp28 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_cons) + tmp29 := checkDerefVar(var_glojure_DOT_core_chunk) + tmp30 := lang.Apply(tmp29, []any{v26}) + tmp31 := checkDerefVar(var_glojure_DOT_core_map) + tmp32 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp33 := lang.Apply(tmp32, []any{v11}) + tmp34 := lang.Apply(tmp31, []any{v2, tmp33}) + tmp35 := lang.Apply(tmp28, []any{tmp30, tmp34}) + tmp15 = tmp35 + } // end let + tmp12 = tmp15 + } else { + tmp16 := checkDerefVar(var_glojure_DOT_core_cons) + tmp17 := checkDerefVar(var_glojure_DOT_core_first) + tmp18 := lang.Apply(tmp17, []any{v11}) + tmp19 := lang.Apply(v2, []any{tmp18}) + tmp20 := checkDerefVar(var_glojure_DOT_core_map) + tmp21 := checkDerefVar(var_glojure_DOT_core_rest) + tmp22 := lang.Apply(tmp21, []any{v11}) + tmp23 := lang.Apply(tmp20, []any{v2, tmp22}) + tmp24 := lang.Apply(tmp16, []any{tmp19, tmp23}) + tmp12 = tmp24 + } + tmp10 = tmp12 + } // end let + tmp9 = tmp10 + } else { + } + tmp5 = tmp9 + } // end let + return tmp5 + }) + tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) + return tmp5 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp6 any + { // let + // let binding "s1" + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := lang.Apply(tmp7, []any{v3}) + var v9 any = tmp8 + _ = v9 + // let binding "s2" + tmp10 := checkDerefVar(var_glojure_DOT_core_seq) + tmp11 := lang.Apply(tmp10, []any{v4}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + var tmp14 any + { // let + // let binding "and__0__auto__" + var v15 any = v9 + _ = v15 + var tmp16 any + if lang.IsTruthy(v15) { + tmp16 = v12 + } else { + tmp16 = v15 + } + tmp14 = tmp16 + } // end let + if lang.IsTruthy(tmp14) { + tmp15 := checkDerefVar(var_glojure_DOT_core_cons) + tmp16 := checkDerefVar(var_glojure_DOT_core_first) + tmp17 := lang.Apply(tmp16, []any{v9}) + tmp18 := checkDerefVar(var_glojure_DOT_core_first) + tmp19 := lang.Apply(tmp18, []any{v12}) + tmp20 := lang.Apply(v2, []any{tmp17, tmp19}) + tmp21 := checkDerefVar(var_glojure_DOT_core_map) + tmp22 := checkDerefVar(var_glojure_DOT_core_rest) + tmp23 := lang.Apply(tmp22, []any{v9}) + tmp24 := checkDerefVar(var_glojure_DOT_core_rest) + tmp25 := lang.Apply(tmp24, []any{v12}) + tmp26 := lang.Apply(tmp21, []any{v2, tmp23, tmp25}) + tmp27 := lang.Apply(tmp15, []any{tmp20, tmp26}) + tmp13 = tmp27 + } else { + } + tmp6 = tmp13 + } // end let + return tmp6 + }) + tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) + return tmp6 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp7 any + { // let + // let binding "s1" + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := lang.Apply(tmp8, []any{v3}) + var v10 any = tmp9 + _ = v10 + // let binding "s2" + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := lang.Apply(tmp11, []any{v4}) + var v13 any = tmp12 + _ = v13 + // let binding "s3" + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := lang.Apply(tmp14, []any{v5}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + var tmp18 any + { // let + // let binding "and__0__auto__" + var v19 any = v10 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + var tmp21 any + { // let + // let binding "and__0__auto__" + var v22 any = v13 + _ = v22 + var tmp23 any + if lang.IsTruthy(v22) { + tmp23 = v16 + } else { + tmp23 = v22 + } + tmp21 = tmp23 + } // end let + tmp20 = tmp21 + } else { + tmp20 = v19 + } + tmp18 = tmp20 + } // end let + if lang.IsTruthy(tmp18) { + tmp19 := checkDerefVar(var_glojure_DOT_core_cons) + tmp20 := checkDerefVar(var_glojure_DOT_core_first) + tmp21 := lang.Apply(tmp20, []any{v10}) + tmp22 := checkDerefVar(var_glojure_DOT_core_first) + tmp23 := lang.Apply(tmp22, []any{v13}) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v16}) + tmp26 := lang.Apply(v2, []any{tmp21, tmp23, tmp25}) + tmp27 := checkDerefVar(var_glojure_DOT_core_map) + tmp28 := checkDerefVar(var_glojure_DOT_core_rest) + tmp29 := lang.Apply(tmp28, []any{v10}) + tmp30 := checkDerefVar(var_glojure_DOT_core_rest) + tmp31 := lang.Apply(tmp30, []any{v13}) + tmp32 := checkDerefVar(var_glojure_DOT_core_rest) + tmp33 := lang.Apply(tmp32, []any{v16}) + tmp34 := lang.Apply(tmp27, []any{v2, tmp29, tmp31, tmp33}) + tmp35 := lang.Apply(tmp19, []any{tmp26, tmp34}) + tmp17 = tmp35 + } else { + } + tmp7 = tmp17 + } // end let + return tmp7 + }) + tmp7 := lang.Apply(lang.NewLazySeq, []any{tmp6}) + return tmp7 + default: + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var v6 any = lang.NewList(args[4:]...) + _ = v6 + var tmp7 any + { // let + // let binding "step" + var tmp8 lang.FnFunc + { // function step + var v9 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v10 := args[0] + _ = v10 + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp12 any + { // let + // let binding "ss" + tmp13 := checkDerefVar(var_glojure_DOT_core_map) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := lang.Apply(tmp13, []any{tmp14, v10}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + tmp18 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + tmp19 := checkDerefVar(var_glojure_DOT_core_identity) + tmp20 := lang.Apply(tmp18, []any{tmp19, v16}) + if lang.IsTruthy(tmp20) { + tmp21 := checkDerefVar(var_glojure_DOT_core_cons) + tmp22 := checkDerefVar(var_glojure_DOT_core_map) + tmp23 := checkDerefVar(var_glojure_DOT_core_first) + tmp24 := lang.Apply(tmp22, []any{tmp23, v16}) + tmp25 := checkDerefVar(var_glojure_DOT_core_map) + tmp26 := checkDerefVar(var_glojure_DOT_core_rest) + tmp27 := lang.Apply(tmp25, []any{tmp26, v16}) + tmp28 := lang.Apply(v9, []any{tmp27}) + tmp29 := lang.Apply(tmp21, []any{tmp24, tmp28}) + tmp17 = tmp29 + } else { + } + tmp12 = tmp17 + } // end let + return tmp12 + }) + tmp12 := lang.Apply(lang.NewLazySeq, []any{tmp11}) + return tmp12 + }) + v9 = tmp8 + _ = v9 + } + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2761), kw_column, int(15), kw_end_DASH_line, int(2765), kw_end_DASH_column, int(68)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v11 any = tmp10 + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_map) + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v14 := args[0] + _ = v14 + tmp15 := checkDerefVar(var_glojure_DOT_core_apply) + tmp16 := lang.Apply(tmp15, []any{v2, v14}) + return tmp16 + }) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2766), kw_column, int(11), kw_end_DASH_line, int(2766), kw_end_DASH_column, int(22)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp16 := checkDerefVar(var_glojure_DOT_core_conj) + tmp17 := lang.Apply(tmp16, []any{v6, v5, v4, v3}) + tmp18 := lang.Apply(v11, []any{tmp17}) + tmp19 := lang.Apply(tmp12, []any{tmp15, tmp18}) + tmp7 = tmp19 + } // end let + return tmp7 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_map = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_map.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // max + { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed22 + } else { + tmp4 = closed22 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed22 + } else { + tmp5 = closed22 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed22 + } else { + tmp6 = closed22 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym_max.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns the greatest of the nums.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(1108), kw_end_DASH_line, int(1108))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + return v4 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Max") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Max is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp8 := checkDerefVar(var_glojure_DOT_core_max) + tmp9 := checkDerefVar(var_glojure_DOT_core_max) + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) + return tmp11 + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_max = ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_max.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // max-key + { + tmp0 := sym_max_DASH_key.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_k, sym_x), lang.NewVector(sym_k, sym_x, sym_y), lang.NewVector(sym_k, sym_x, sym_y, sym__AMP_, sym_more)), kw_doc, "Returns the x for which (k x), a number, is greatest.\n\n If there are multiple such xs, the last one is returned.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(5013), kw_end_DASH_line, int(5013))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + return v3 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__GT_) + tmp7 := lang.Apply(v2, []any{v3}) + tmp8 := lang.Apply(v2, []any{v4}) + tmp9 := lang.Apply(tmp6, []any{tmp7, tmp8}) + if lang.IsTruthy(tmp9) { + tmp5 = v3 + } else { + tmp5 = v4 + } + return tmp5 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "kx" + tmp7 := lang.Apply(v2, []any{v3}) + var v8 any = tmp7 + _ = v8 + // let binding "ky" + tmp9 := lang.Apply(v2, []any{v4}) + var v10 any = tmp9 + _ = v10 + // let binding "vec__746" + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core__GT_) + tmp13 := lang.Apply(tmp12, []any{v8, v10}) + if lang.IsTruthy(tmp13) { + tmp14 := lang.NewVector(v3, v8) + tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5023), kw_column, int(31), kw_end_DASH_line, int(5023), kw_end_DASH_column, int(36)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp11 = tmp16 + } else { + tmp17 := lang.NewVector(v4, v10) + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5023), kw_column, int(38), kw_end_DASH_line, int(5023), kw_end_DASH_column, int(43)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp11 = tmp19 + } + var v20 any = tmp11 + _ = v20 + // let binding "v" + tmp21 := checkDerefVar(var_glojure_DOT_core_nth) + tmp22 := lang.Apply(tmp21, []any{v20, int64(0), nil}) + var v23 any = tmp22 + _ = v23 + // let binding "kv" + tmp24 := checkDerefVar(var_glojure_DOT_core_nth) + tmp25 := lang.Apply(tmp24, []any{v20, int64(1), nil}) + var v26 any = tmp25 + _ = v26 + var tmp27 any + { // let + // let binding "v" + var v28 any = v23 + _ = v28 + // let binding "kv" + var v29 any = v26 + _ = v29 + // let binding "more" + var v30 any = v5 + _ = v30 + for { + var tmp31 any + if lang.IsTruthy(v30) { + var tmp32 any + { // let + // let binding "w" + tmp33 := checkDerefVar(var_glojure_DOT_core_first) + tmp34 := lang.Apply(tmp33, []any{v30}) + var v35 any = tmp34 + _ = v35 + // let binding "kw" + tmp36 := lang.Apply(v2, []any{v35}) + var v37 any = tmp36 + _ = v37 + var tmp38 any + tmp39 := checkDerefVar(var_glojure_DOT_core__GT__EQ_) + tmp40 := lang.Apply(tmp39, []any{v37, v29}) + if lang.IsTruthy(tmp40) { + var tmp41 any = v35 + var tmp42 any = v37 + tmp44 := checkDerefVar(var_glojure_DOT_core_next) + tmp45 := lang.Apply(tmp44, []any{v30}) + var tmp43 any = tmp45 + v28 = tmp41 + v29 = tmp42 + v30 = tmp43 + continue + } else { + var tmp46 any = v28 + var tmp47 any = v29 + tmp49 := checkDerefVar(var_glojure_DOT_core_next) + tmp50 := lang.Apply(tmp49, []any{v30}) + var tmp48 any = tmp50 + v28 = tmp46 + v29 = tmp47 + v30 = tmp48 + continue + } + tmp32 = tmp38 + } // end let + tmp31 = tmp32 + } else { + tmp31 = v28 + } + tmp27 = tmp31 + break + } + } // end let + tmp6 = tmp27 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_max_DASH_key = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_max_DASH_key.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // memfn + { + tmp0 := sym_memfn.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym__AMP_, sym_args)), kw_doc, "Expands into code that creates a fn that expects to be passed an\n object and any args and calls the named instance method on the\n object passing the args. Use when you want to treat a Java method as\n a first-class fn. name may be type-hinted with the method receiver's\n type in order to avoid reflective calls.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(11), kw_line, int(3872), kw_end_DASH_line, int(3872))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "t" + tmp7 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp8 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp9 := lang.Apply(tmp8, []any{"target"}) + tmp10 := checkDerefVar(var_glojure_DOT_core_meta) + tmp11 := lang.Apply(tmp10, []any{v4}) + tmp12 := lang.Apply(tmp7, []any{tmp9, tmp11}) + var v13 any = tmp12 + _ = v13 + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{sym_glojure_DOT_core_SLASH_fn}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := checkDerefVar(var_glojure_DOT_core_apply) + tmp20 := checkDerefVar(var_glojure_DOT_core_vector) + tmp21 := checkDerefVar(var_glojure_DOT_core_seq) + tmp22 := checkDerefVar(var_glojure_DOT_core_concat) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := lang.Apply(tmp23, []any{v13}) + tmp25 := lang.Apply(tmp22, []any{tmp24, v5}) + tmp26 := lang.Apply(tmp21, []any{tmp25}) + tmp27 := lang.Apply(tmp19, []any{tmp20, tmp26}) + tmp28 := lang.Apply(tmp18, []any{tmp27}) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := checkDerefVar(var_glojure_DOT_core_seq) + tmp31 := checkDerefVar(var_glojure_DOT_core_concat) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := lang.Apply(tmp32, []any{sym__DOT_}) + tmp34 := checkDerefVar(var_glojure_DOT_core_list) + tmp35 := lang.Apply(tmp34, []any{v13}) + tmp36 := checkDerefVar(var_glojure_DOT_core_list) + tmp37 := checkDerefVar(var_glojure_DOT_core_seq) + tmp38 := checkDerefVar(var_glojure_DOT_core_concat) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := lang.Apply(tmp39, []any{v4}) + tmp41 := lang.Apply(tmp38, []any{tmp40, v5}) + tmp42 := lang.Apply(tmp37, []any{tmp41}) + tmp43 := lang.Apply(tmp36, []any{tmp42}) + tmp44 := lang.Apply(tmp31, []any{tmp33, tmp35, tmp43}) + tmp45 := lang.Apply(tmp30, []any{tmp44}) + tmp46 := lang.Apply(tmp29, []any{tmp45}) + tmp47 := lang.Apply(tmp15, []any{tmp17, tmp28, tmp46}) + tmp48 := lang.Apply(tmp14, []any{tmp47}) + tmp6 = tmp48 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_memfn = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_memfn.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // merge + { + tmp0 := sym_merge.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_maps)), kw_doc, "Returns a map that consists of the rest of the maps conj-ed onto\n the first. If a key occurs in more than one map, the mapping from\n the latter (left-to-right) will be the mapping in the result.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3040), kw_end_DASH_line, int(3040))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_some) + tmp5 := checkDerefVar(var_glojure_DOT_core_identity) + tmp6 := lang.Apply(tmp4, []any{tmp5, v2}) + if lang.IsTruthy(tmp6) { + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp8 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v9 := args[0] + _ = v9 + v10 := args[1] + _ = v10 + tmp11 := checkDerefVar(var_glojure_DOT_core_conj) + var tmp12 any + { // let + // let binding "or__0__auto__" + var v13 any = v9 + _ = v13 + var tmp14 any + if lang.IsTruthy(v13) { + tmp14 = v13 + } else { + tmp15 := lang.NewMap() + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3048), kw_column, int(28), kw_end_DASH_line, int(3048), kw_end_DASH_column, int(29)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp14 = tmp17 + } + tmp12 = tmp14 + } // end let + tmp13 := lang.Apply(tmp11, []any{tmp12, v10}) + return tmp13 + }) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3048), kw_column, int(14), kw_end_DASH_line, int(3048), kw_end_DASH_column, int(34)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp11 := lang.Apply(tmp7, []any{tmp10, v2}) + tmp3 = tmp11 + } else { + } + return tmp3 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_merge = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_merge.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // merge-with + { + tmp0 := sym_merge_DASH_with.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym__AMP_, sym_maps)), kw_doc, "Returns a map that consists of the rest of the maps conj-ed onto\n the first. If a key occurs in more than one map, the mapping(s)\n from the latter (left-to-right) will be combined with the mapping in\n the result by calling (f val-in-result val-in-latter).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(3050), kw_end_DASH_line, int(3050))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_some) + tmp6 := checkDerefVar(var_glojure_DOT_core_identity) + tmp7 := lang.Apply(tmp5, []any{tmp6, v3}) + if lang.IsTruthy(tmp7) { + var tmp8 any + { // let + // let binding "merge-entry" + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + var tmp12 any + { // let + // let binding "k" + tmp13 := checkDerefVar(var_glojure_DOT_core_key) + tmp14 := lang.Apply(tmp13, []any{v11}) + var v15 any = tmp14 + _ = v15 + // let binding "v" + tmp16 := checkDerefVar(var_glojure_DOT_core_val) + tmp17 := lang.Apply(tmp16, []any{v11}) + var v18 any = tmp17 + _ = v18 + var tmp19 any + tmp20 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp21 := lang.Apply(tmp20, []any{v10, v15}) + if lang.IsTruthy(tmp21) { + tmp22 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp23 := checkDerefVar(var_glojure_DOT_core_get) + tmp24 := lang.Apply(tmp23, []any{v10, v15}) + tmp25 := lang.Apply(v2, []any{tmp24, v18}) + tmp26 := lang.Apply(tmp22, []any{v10, v15, tmp25}) + tmp19 = tmp26 + } else { + tmp27 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp28 := lang.Apply(tmp27, []any{v10, v15, v18}) + tmp19 = tmp28 + } + tmp12 = tmp19 + } // end let + return tmp12 + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3059), kw_column, int(23), kw_end_DASH_line, int(3063), kw_end_DASH_column, int(23)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v12 any = tmp11 + _ = v12 + // let binding "merge2" + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v14 := args[0] + _ = v14 + v15 := args[1] + _ = v15 + tmp16 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp17 any + { // let + // let binding "or__0__auto__" + var v18 any = v14 + _ = v18 + var tmp19 any + if lang.IsTruthy(v18) { + tmp19 = v18 + } else { + tmp20 := lang.NewMap() + tmp21 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3065), kw_column, int(34), kw_end_DASH_line, int(3065), kw_end_DASH_column, int(35)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp19 = tmp22 + } + tmp17 = tmp19 + } // end let + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := lang.Apply(tmp18, []any{v15}) + tmp20 := lang.Apply(tmp16, []any{v12, tmp17, tmp19}) + return tmp20 + }) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3064), kw_column, int(18), kw_end_DASH_line, int(3065), kw_end_DASH_column, int(47)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v16 any = tmp15 + _ = v16 + tmp17 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp18 := lang.Apply(tmp17, []any{v16, v3}) + tmp8 = tmp18 + } // end let + tmp4 = tmp8 + } else { + } + return tmp4 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_merge_DASH_with = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_merge_DASH_with.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // min + { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed23 + } else { + tmp4 = closed23 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed23 + } else { + tmp5 = closed23 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed23 + } else { + tmp6 = closed23 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym_min.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "Returns the least of the nums.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(1118), kw_end_DASH_line, int(1118))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + return v4 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Min") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Min is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp8 := checkDerefVar(var_glojure_DOT_core_min) + tmp9 := checkDerefVar(var_glojure_DOT_core_min) + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) + return tmp11 + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_min = ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_min.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // min-key + { + tmp0 := sym_min_DASH_key.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_k, sym_x), lang.NewVector(sym_k, sym_x, sym_y), lang.NewVector(sym_k, sym_x, sym_y, sym__AMP_, sym_more)), kw_doc, "Returns the x for which (k x), a number, is least.\n\n If there are multiple such xs, the last one is returned.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(5033), kw_end_DASH_line, int(5033))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + return v3 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp7 := lang.Apply(v2, []any{v3}) + tmp8 := lang.Apply(v2, []any{v4}) + tmp9 := lang.Apply(tmp6, []any{tmp7, tmp8}) + if lang.IsTruthy(tmp9) { + tmp5 = v3 + } else { + tmp5 = v4 + } + return tmp5 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "kx" + tmp7 := lang.Apply(v2, []any{v3}) + var v8 any = tmp7 + _ = v8 + // let binding "ky" + tmp9 := lang.Apply(v2, []any{v4}) + var v10 any = tmp9 + _ = v10 + // let binding "vec__749" + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp13 := lang.Apply(tmp12, []any{v8, v10}) + if lang.IsTruthy(tmp13) { + tmp14 := lang.NewVector(v3, v8) + tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5043), kw_column, int(31), kw_end_DASH_line, int(5043), kw_end_DASH_column, int(36)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp11 = tmp16 + } else { + tmp17 := lang.NewVector(v4, v10) + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5043), kw_column, int(38), kw_end_DASH_line, int(5043), kw_end_DASH_column, int(43)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp11 = tmp19 + } + var v20 any = tmp11 + _ = v20 + // let binding "v" + tmp21 := checkDerefVar(var_glojure_DOT_core_nth) + tmp22 := lang.Apply(tmp21, []any{v20, int64(0), nil}) + var v23 any = tmp22 + _ = v23 + // let binding "kv" + tmp24 := checkDerefVar(var_glojure_DOT_core_nth) + tmp25 := lang.Apply(tmp24, []any{v20, int64(1), nil}) + var v26 any = tmp25 + _ = v26 + var tmp27 any + { // let + // let binding "v" + var v28 any = v23 + _ = v28 + // let binding "kv" + var v29 any = v26 + _ = v29 + // let binding "more" + var v30 any = v5 + _ = v30 + for { + var tmp31 any + if lang.IsTruthy(v30) { + var tmp32 any + { // let + // let binding "w" + tmp33 := checkDerefVar(var_glojure_DOT_core_first) + tmp34 := lang.Apply(tmp33, []any{v30}) + var v35 any = tmp34 + _ = v35 + // let binding "kw" + tmp36 := lang.Apply(v2, []any{v35}) + var v37 any = tmp36 + _ = v37 + var tmp38 any + tmp39 := checkDerefVar(var_glojure_DOT_core__LT__EQ_) + tmp40 := lang.Apply(tmp39, []any{v37, v29}) + if lang.IsTruthy(tmp40) { + var tmp41 any = v35 + var tmp42 any = v37 + tmp44 := checkDerefVar(var_glojure_DOT_core_next) + tmp45 := lang.Apply(tmp44, []any{v30}) + var tmp43 any = tmp45 + v28 = tmp41 + v29 = tmp42 + v30 = tmp43 + continue + } else { + var tmp46 any = v28 + var tmp47 any = v29 + tmp49 := checkDerefVar(var_glojure_DOT_core_next) + tmp50 := lang.Apply(tmp49, []any{v30}) + var tmp48 any = tmp50 + v28 = tmp46 + v29 = tmp47 + v30 = tmp48 + continue + } + tmp32 = tmp38 + } // end let + tmp31 = tmp32 + } else { + tmp31 = v28 + } + tmp27 = tmp31 + break + } + } // end let + tmp6 = tmp27 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_min_DASH_key = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_min_DASH_key.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // mod + { + tmp0 := sym_mod.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_num, sym_div)), kw_doc, "Modulus of num and div. Truncates toward negative infinity.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(3567), kw_end_DASH_line, int(3567))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "m" + tmp5 := checkDerefVar(var_glojure_DOT_core_rem) + tmp6 := lang.Apply(tmp5, []any{v2, v3}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + var tmp9 any + { // let + // let binding "or__0__auto__" + tmp10 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) + tmp11 := lang.Apply(tmp10, []any{v7}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + tmp13 = v12 + } else { + tmp14 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp15 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp16 := lang.Apply(tmp15, []any{v2}) + tmp17 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp13 = tmp19 + } + tmp9 = tmp13 + } // end let + if lang.IsTruthy(tmp9) { + tmp8 = v7 + } else { + tmp10 := checkDerefVar(var_glojure_DOT_core__PLUS_) + tmp11 := lang.Apply(tmp10, []any{v7, v3}) + tmp8 = tmp11 + } + tmp4 = tmp8 + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_mod = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_mod.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // nary-inline + { + tmp0 := sym_nary_DASH_inline.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(948), kw_column, int(7), kw_end_DASH_line, int(948), kw_end_DASH_column, int(27), kw_arglists, lang.NewList(lang.NewVector(sym_op), lang.NewVector(sym_op, sym_unchecked_DASH_op)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_nary_DASH_inline) + tmp4 := lang.Apply(tmp3, []any{v2, v2}) + return tmp4 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v5 := args[0] + _ = v5 + var tmp6 any + { // let + // let binding "op" + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp8) { + tmp7 = v3 + } else { + tmp7 = v2 + } + var v9 any = tmp7 + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_seq) + tmp11 := checkDerefVar(var_glojure_DOT_core_concat) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym__DOT_}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := checkDerefVar(var_glojure_DOT_core_seq) + tmp18 := checkDerefVar(var_glojure_DOT_core_concat) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v9}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v5}) + tmp23 := lang.Apply(tmp18, []any{tmp20, tmp22}) + tmp24 := lang.Apply(tmp17, []any{tmp23}) + tmp25 := lang.Apply(tmp16, []any{tmp24}) + tmp26 := lang.Apply(tmp11, []any{tmp13, tmp15, tmp25}) + tmp27 := lang.Apply(tmp10, []any{tmp26}) + tmp6 = tmp27 + } // end let + return tmp6 + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + var tmp7 any + { // let + // let binding "op" + var tmp8 any + tmp9 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp9) { + tmp8 = v3 + } else { + tmp8 = v2 + } + var v10 any = tmp8 + _ = v10 + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym__DOT_}) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{v10}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v5}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v6}) + tmp26 := lang.Apply(tmp19, []any{tmp21, tmp23, tmp25}) + tmp27 := lang.Apply(tmp18, []any{tmp26}) + tmp28 := lang.Apply(tmp17, []any{tmp27}) + tmp29 := lang.Apply(tmp12, []any{tmp14, tmp16, tmp28}) + tmp30 := lang.Apply(tmp11, []any{tmp29}) + tmp7 = tmp30 + } // end let + return tmp7 + default: + checkArity(args, 2) + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + var v7 any = lang.NewList(args[2:]...) + _ = v7 + var tmp8 any + { // let + // let binding "op" + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp10) { + tmp9 = v3 + } else { + tmp9 = v2 + } + var v11 any = tmp9 + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v14 := args[0] + _ = v14 + v15 := args[1] + _ = v15 + tmp16 := checkDerefVar(var_glojure_DOT_core_seq) + tmp17 := checkDerefVar(var_glojure_DOT_core_concat) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{sym__DOT_}) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := checkDerefVar(var_glojure_DOT_core_seq) + tmp24 := checkDerefVar(var_glojure_DOT_core_concat) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := lang.Apply(tmp25, []any{v11}) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{v14}) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{v15}) + tmp31 := lang.Apply(tmp24, []any{tmp26, tmp28, tmp30}) + tmp32 := lang.Apply(tmp23, []any{tmp31}) + tmp33 := lang.Apply(tmp22, []any{tmp32}) + tmp34 := lang.Apply(tmp17, []any{tmp19, tmp21, tmp33}) + tmp35 := lang.Apply(tmp16, []any{tmp34}) + return tmp35 + }) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp16 := checkDerefVar(var_glojure_DOT_core_seq) + tmp17 := checkDerefVar(var_glojure_DOT_core_concat) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{sym__DOT_}) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := checkDerefVar(var_glojure_DOT_core_seq) + tmp24 := checkDerefVar(var_glojure_DOT_core_concat) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := lang.Apply(tmp25, []any{v11}) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{v5}) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{v6}) + tmp31 := lang.Apply(tmp24, []any{tmp26, tmp28, tmp30}) + tmp32 := lang.Apply(tmp23, []any{tmp31}) + tmp33 := lang.Apply(tmp22, []any{tmp32}) + tmp34 := lang.Apply(tmp17, []any{tmp19, tmp21, tmp33}) + tmp35 := lang.Apply(tmp16, []any{tmp34}) + tmp36 := lang.Apply(tmp12, []any{tmp15, tmp35, v7}) + tmp8 = tmp36 + } // end let + return tmp8 + } + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_nary_DASH_inline = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_nary_DASH_inline.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // nat-int? + { + tmp0 := sym_nat_DASH_int_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a non-negative fixed precision integer", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(1415), kw_end_DASH_line, int(1415))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "and__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + tmp8 := checkDerefVar(var_glojure_DOT_core_not) + tmp9 := checkDerefVar(var_glojure_DOT_core_neg_QMARK_) + tmp10 := lang.Apply(tmp9, []any{v2}) + tmp11 := lang.Apply(tmp8, []any{tmp10}) + tmp7 = tmp11 + } else { + tmp7 = v6 + } + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_nat_DASH_int_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_nat_DASH_int_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // neg-int? + { + tmp0 := sym_neg_DASH_int_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a negative fixed precision integer", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(1409), kw_end_DASH_line, int(1409))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "and__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + tmp8 := checkDerefVar(var_glojure_DOT_core_neg_QMARK_) + tmp9 := lang.Apply(tmp8, []any{v2}) + tmp7 = tmp9 + } else { + tmp7 = v6 + } + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_neg_DASH_int_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_neg_DASH_int_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // not-any? + { + tmp1 := reflect.TypeOf(false) + tmp0 := sym_not_DASH_any_QMARK_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns false if (pred x) is logical true for any x in coll,\n else true.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(2), kw_line, int(2696), kw_end_DASH_line, int(2701))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp3 := lang.Apply(closed25, nil) + tmp4 := lang.Apply(closed24, []any{tmp3}) + return tmp4 + case 1: + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(closed25, []any{v3}) + tmp5 := lang.Apply(closed24, []any{tmp4}) + return tmp5 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(closed25, []any{v3, v4}) + tmp6 := lang.Apply(closed24, []any{tmp5}) + return tmp6 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6 := lang.Apply(closed25, []any{v3, v4, v5}) + tmp7 := lang.Apply(closed24, []any{tmp6}) + return tmp7 + default: + checkArity(args, 3) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_apply) + tmp8 := lang.Apply(tmp7, []any{closed25, v3, v4, v5, v6}) + tmp9 := lang.Apply(closed24, []any{tmp8}) + return tmp9 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2559), kw_column, int(6), kw_end_DASH_line, int(2564), kw_end_DASH_column, int(49))).(lang.FnFunc) + var_glojure_DOT_core_not_DASH_any_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_not_DASH_any_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // not-every? + { + tmp1 := reflect.TypeOf(false) + tmp0 := sym_not_DASH_every_QMARK_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns false if (pred x) is logical true for every x in\n coll, else true.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(2), kw_line, int(2677), kw_end_DASH_line, int(2682))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp3 := lang.Apply(closed26, nil) + tmp4 := lang.Apply(closed24, []any{tmp3}) + return tmp4 + case 1: + v3 := args[0] + _ = v3 + tmp4 := lang.Apply(closed26, []any{v3}) + tmp5 := lang.Apply(closed24, []any{tmp4}) + return tmp5 + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(closed26, []any{v3, v4}) + tmp6 := lang.Apply(closed24, []any{tmp5}) + return tmp6 + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6 := lang.Apply(closed26, []any{v3, v4, v5}) + tmp7 := lang.Apply(closed24, []any{tmp6}) + return tmp7 + default: + checkArity(args, 3) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_apply) + tmp8 := lang.Apply(tmp7, []any{closed26, v3, v4, v5, v6}) + tmp9 := lang.Apply(closed24, []any{tmp8}) + return tmp9 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2559), kw_column, int(6), kw_end_DASH_line, int(2564), kw_end_DASH_column, int(49))).(lang.FnFunc) + var_glojure_DOT_core_not_DASH_every_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_not_DASH_every_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // not= + { + tmp1 := reflect.TypeOf(false) + tmp0 := sym_not_EQ_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_doc, "Same as (not (= obj1 obj2))", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(812), kw_end_DASH_line, int(812))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + return false + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_not) + tmp6 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp7 := lang.Apply(tmp6, []any{v3, v4}) + tmp8 := lang.Apply(tmp5, []any{tmp7}) + return tmp8 + default: + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_not) + tmp7 := checkDerefVar(var_glojure_DOT_core_apply) + tmp8 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp9 := lang.Apply(tmp7, []any{tmp8, v3, v4, v5}) + tmp10 := lang.Apply(tmp6, []any{tmp9}) + return tmp10 + } + }) + tmp3 := reflect.TypeOf(false) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_not_EQ_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_not_EQ_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ns-interns + { + tmp0 := sym_ns_DASH_interns.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns)), kw_doc, "Returns a map of the intern mappings for the namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4206), kw_end_DASH_line, int(4206))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "ns" + tmp4 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_filter_DASH_key) + tmp8 := checkDerefVar(var_glojure_DOT_core_val) + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v10 := args[0] + _ = v10 + var tmp11 any + { // let + // let binding "and__0__auto__" + tmp12 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp13 := reflect.TypeOf((*lang.Var)(nil)) + tmp14 := lang.Apply(tmp12, []any{tmp13, v10}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + if lang.IsTruthy(v15) { + tmp17 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp18, ok := lang.FieldOrMethod(v10, "Namespace") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v10, "Namespace"))) + } + var tmp19 any + switch reflect.TypeOf(tmp18).Kind() { + case reflect.Func: + tmp19 = lang.Apply(tmp18, nil) + default: + tmp19 = tmp18 + } + tmp20 := lang.Apply(tmp17, []any{v6, tmp19}) + tmp16 = tmp20 + } else { + tmp16 = v15 + } + tmp11 = tmp16 + } // end let + return tmp11 + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4212), kw_column, int(21), kw_end_DASH_line, int(4213), kw_end_DASH_column, int(56)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp12 := checkDerefVar(var_glojure_DOT_core_ns_DASH_map) + tmp13 := lang.Apply(tmp12, []any{v6}) + tmp14 := lang.Apply(tmp7, []any{tmp8, tmp11, tmp13}) + tmp3 = tmp14 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ns_DASH_interns = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ns_DASH_interns.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ns-publics + { + tmp0 := sym_ns_DASH_publics.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns)), kw_doc, "Returns a map of the public intern mappings for the namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4188), kw_end_DASH_line, int(4188))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "ns" + tmp4 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_filter_DASH_key) + tmp8 := checkDerefVar(var_glojure_DOT_core_val) + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v10 := args[0] + _ = v10 + var tmp11 any + { // let + // let binding "and__0__auto__" + tmp12 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp13 := reflect.TypeOf((*lang.Var)(nil)) + tmp14 := lang.Apply(tmp12, []any{tmp13, v10}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + if lang.IsTruthy(v15) { + var tmp17 any + { // let + // let binding "and__0__auto__" + tmp18 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp19, ok := lang.FieldOrMethod(v10, "Namespace") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v10, "Namespace"))) + } + var tmp20 any + switch reflect.TypeOf(tmp19).Kind() { + case reflect.Func: + tmp20 = lang.Apply(tmp19, nil) + default: + tmp20 = tmp19 + } + tmp21 := lang.Apply(tmp18, []any{v6, tmp20}) + var v22 any = tmp21 + _ = v22 + var tmp23 any + if lang.IsTruthy(v22) { + tmp24, ok := lang.FieldOrMethod(v10, "IsPublic") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v10, "IsPublic"))) + } + var tmp25 any + switch reflect.TypeOf(tmp24).Kind() { + case reflect.Func: + tmp25 = lang.Apply(tmp24, nil) + default: + tmp25 = tmp24 + } + tmp23 = tmp25 + } else { + tmp23 = v22 + } + tmp17 = tmp23 + } // end let + tmp16 = tmp17 + } else { + tmp16 = v15 + } + tmp11 = tmp16 + } // end let + return tmp11 + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4194), kw_column, int(21), kw_end_DASH_line, int(4196), kw_end_DASH_column, int(48)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp12 := checkDerefVar(var_glojure_DOT_core_ns_DASH_map) + tmp13 := lang.Apply(tmp12, []any{v6}) + tmp14 := lang.Apply(tmp7, []any{tmp8, tmp11, tmp13}) + tmp3 = tmp14 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ns_DASH_publics = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ns_DASH_publics.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ns-refers + { + tmp0 := sym_ns_DASH_refers.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns)), kw_doc, "Returns a map of the refer mappings for the namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(4253), kw_end_DASH_line, int(4253))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "ns" + tmp4 := checkDerefVar(var_glojure_DOT_core_the_DASH_ns) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_filter_DASH_key) + tmp8 := checkDerefVar(var_glojure_DOT_core_val) + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v10 := args[0] + _ = v10 + var tmp11 any + { // let + // let binding "and__0__auto__" + tmp12 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp13 := reflect.TypeOf((*lang.Var)(nil)) + tmp14 := lang.Apply(tmp12, []any{tmp13, v10}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + if lang.IsTruthy(v15) { + tmp17 := checkDerefVar(var_glojure_DOT_core_not_EQ_) + tmp18, ok := lang.FieldOrMethod(v10, "Namespace") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v10, "Namespace"))) + } + var tmp19 any + switch reflect.TypeOf(tmp18).Kind() { + case reflect.Func: + tmp19 = lang.Apply(tmp18, nil) + default: + tmp19 = tmp18 + } + tmp20 := lang.Apply(tmp17, []any{v6, tmp19}) + tmp16 = tmp20 + } else { + tmp16 = v15 + } + tmp11 = tmp16 + } // end let + return tmp11 + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4259), kw_column, int(21), kw_end_DASH_line, int(4260), kw_end_DASH_column, int(59)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp12 := checkDerefVar(var_glojure_DOT_core_ns_DASH_map) + tmp13 := lang.Apply(tmp12, []any{v6}) + tmp14 := lang.Apply(tmp7, []any{tmp8, tmp11, tmp13}) + tmp3 = tmp14 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ns_DASH_refers = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ns_DASH_refers.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // nthnext + { + tmp0 := sym_nthnext.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll, sym_n)), kw_doc, "Returns the nth next of coll, (seq coll) when n is 0.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(3147), kw_end_DASH_line, int(3147))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp6 := reflect.TypeOf((*lang.IDrop)(nil)).Elem() + tmp7 := lang.Apply(tmp5, []any{tmp6, v2}) + if lang.IsTruthy(tmp7) { + var tmp8 any + tmp9 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp10 := lang.Apply(tmp9, []any{v3}) + if lang.IsTruthy(tmp10) { + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) + tmp13 := lang.Apply(tmp12, []any{v3}) + if lang.IsTruthy(tmp13) { + tmp11 = v3 + } else { + tmp14 := lang.Apply(nil, []any{v3}) + tmp11 = tmp14 + } + tmp15, _ := lang.FieldOrMethod(v2, "drop") + if reflect.TypeOf(tmp15).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("drop is not a function"))) + } + tmp16 := lang.Apply(tmp15, []any{tmp11}) + tmp8 = tmp16 + } else { + tmp17 := checkDerefVar(var_glojure_DOT_core_seq) + tmp18 := lang.Apply(tmp17, []any{v2}) + tmp8 = tmp18 + } + tmp4 = tmp8 + } else { + var tmp19 any + { // let + // let binding "n" + var v20 any = v3 + _ = v20 + // let binding "xs" + tmp21 := checkDerefVar(var_glojure_DOT_core_seq) + tmp22 := lang.Apply(tmp21, []any{v2}) + var v23 any = tmp22 + _ = v23 + for { + var tmp24 any + var tmp25 any + { // let + // let binding "and__0__auto__" + var v26 any = v23 + _ = v26 + var tmp27 any + if lang.IsTruthy(v26) { + tmp28 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp29 := lang.Apply(tmp28, []any{v20}) + tmp27 = tmp29 + } else { + tmp27 = v26 + } + tmp25 = tmp27 + } // end let + if lang.IsTruthy(tmp25) { + tmp27 := checkDerefVar(var_glojure_DOT_core_dec) + tmp28 := lang.Apply(tmp27, []any{v20}) + var tmp26 any = tmp28 + tmp30 := checkDerefVar(var_glojure_DOT_core_next) + tmp31 := lang.Apply(tmp30, []any{v23}) + var tmp29 any = tmp31 + v20 = tmp26 + v23 = tmp29 + continue + } else { + tmp24 = v23 + } + tmp19 = tmp24 + break + } + } // end let + tmp4 = tmp19 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_nthnext = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_nthnext.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // nthrest + { + tmp0 := sym_nthrest.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll, sym_n)), kw_doc, "Returns the nth rest of coll, coll when n is 0.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(3161), kw_end_DASH_line, int(3161))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + var tmp7 any + { // let + // let binding "or__0__auto__" + var tmp8 any + tmp9 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp10 := reflect.TypeOf((*lang.IDrop)(nil)).Elem() + tmp11 := lang.Apply(tmp9, []any{tmp10, v2}) + if lang.IsTruthy(tmp11) { + var tmp12 any + tmp13 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) + tmp14 := lang.Apply(tmp13, []any{v3}) + if lang.IsTruthy(tmp14) { + tmp12 = v3 + } else { + tmp15 := lang.Apply(nil, []any{v3}) + tmp12 = tmp15 + } + tmp16, _ := lang.FieldOrMethod(v2, "drop") + if reflect.TypeOf(tmp16).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("drop is not a function"))) + } + tmp17 := lang.Apply(tmp16, []any{tmp12}) + tmp8 = tmp17 + } else { + var tmp18 any + { // let + // let binding "n" + var v19 any = v3 + _ = v19 + // let binding "xs" + var v20 any = v2 + _ = v20 + for { + var tmp21 any + { // let + // let binding "temp__0__auto__" + var tmp22 any + { // let + // let binding "and__0__auto__" + tmp23 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp24 := lang.Apply(tmp23, []any{v19}) + var v25 any = tmp24 + _ = v25 + var tmp26 any + if lang.IsTruthy(v25) { + tmp27 := checkDerefVar(var_glojure_DOT_core_seq) + tmp28 := lang.Apply(tmp27, []any{v20}) + tmp26 = tmp28 + } else { + tmp26 = v25 + } + tmp22 = tmp26 + } // end let + var v23 any = tmp22 + _ = v23 + var tmp24 any + if lang.IsTruthy(v23) { + var tmp25 any + { // let + // let binding "xs" + var v26 any = v23 + _ = v26 + tmp28 := checkDerefVar(var_glojure_DOT_core_dec) + tmp29 := lang.Apply(tmp28, []any{v19}) + var tmp27 any = tmp29 + tmp31 := checkDerefVar(var_glojure_DOT_core_rest) + tmp32 := lang.Apply(tmp31, []any{v26}) + var tmp30 any = tmp32 + v19 = tmp27 + v20 = tmp30 + continue + } // end let + tmp24 = tmp25 + } else { + tmp26 := checkDerefVar(var_glojure_DOT_core_seq) + tmp27 := lang.Apply(tmp26, []any{v20}) + tmp24 = tmp27 + } + tmp21 = tmp24 + } // end let + tmp18 = tmp21 + break + } + } // end let + tmp8 = tmp18 + } + var v19 any = tmp8 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + tmp20 = v19 + } else { + tmp20 = lang.NewList() + } + tmp7 = tmp20 + } // end let + tmp4 = tmp7 + } else { + tmp4 = v2 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_nthrest = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_nthrest.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // odd? + { + tmp0 := sym_odd_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_doc, "Returns true if n is odd, throws an exception if n is not an integer", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(1389), kw_end_DASH_line, int(1389))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_not) + tmp4 := checkDerefVar(var_glojure_DOT_core_even_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + tmp6 := lang.Apply(tmp3, []any{tmp5}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_odd_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_odd_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // or + { + tmp0 := sym_or.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_x), lang.NewVector(sym_x, sym__AMP_, sym_next)), kw_doc, "Evaluates exprs one at a time, from left to right. If a form\n returns a logical true value, or returns that value and doesn't\n evaluate any of the other expressions, otherwise it returns the\n value of the last expression. (or) returns nil.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(11), kw_line, int(847), kw_end_DASH_line, int(847))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + return nil + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + return v4 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_let}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + tmp12 := checkDerefVar(var_glojure_DOT_core_vector) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_or__0__auto__}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v4}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp19}) + tmp21 := lang.Apply(tmp11, []any{tmp12, tmp20}) + tmp22 := lang.Apply(tmp10, []any{tmp21}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_seq) + tmp25 := checkDerefVar(var_glojure_DOT_core_concat) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{sym_if}) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := lang.Apply(tmp28, []any{sym_or__0__auto__}) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := lang.Apply(tmp30, []any{sym_or__0__auto__}) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := checkDerefVar(var_glojure_DOT_core_seq) + tmp34 := checkDerefVar(var_glojure_DOT_core_concat) + tmp35 := checkDerefVar(var_glojure_DOT_core_list) + tmp36 := lang.Apply(tmp35, []any{sym_glojure_DOT_core_SLASH_or}) + tmp37 := lang.Apply(tmp34, []any{tmp36, v5}) + tmp38 := lang.Apply(tmp33, []any{tmp37}) + tmp39 := lang.Apply(tmp32, []any{tmp38}) + tmp40 := lang.Apply(tmp25, []any{tmp27, tmp29, tmp31, tmp39}) + tmp41 := lang.Apply(tmp24, []any{tmp40}) + tmp42 := lang.Apply(tmp23, []any{tmp41}) + tmp43 := lang.Apply(tmp7, []any{tmp9, tmp22, tmp42}) + tmp44 := lang.Apply(tmp6, []any{tmp43}) + return tmp44 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_or = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_or.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // parents + { + tmp0 := sym_parents.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_tag), lang.NewVector(sym_h, sym_tag)), kw_doc, "Returns the immediate parents of tag, either via a Java type\n inheritance relationship or a relationship established via derive. h\n must be a hierarchy obtained from make-hierarchy, if not supplied\n defaults to the global hierarchy", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(5564), kw_end_DASH_line, int(5564))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_parents) + tmp4 := checkDerefVar(var_glojure_DOT_core_global_DASH_hierarchy) + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_not_DASH_empty) + var tmp5 any + { // let + // let binding "tp" + tmp6 := checkDerefVar(var_glojure_DOT_core_get) + tmp7 := lang.Apply(kw_parents, []any{v2}) + tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + tmp11 := checkDerefVar(var_glojure_DOT_core_class_QMARK_) + tmp12 := lang.Apply(tmp11, []any{v3}) + if lang.IsTruthy(tmp12) { + tmp13 := checkDerefVar(var_glojure_DOT_core_into1) + tmp14 := checkDerefVar(var_glojure_DOT_core_set) + tmp15 := checkDerefVar(var_glojure_DOT_core_bases) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp14, []any{tmp16}) + tmp18 := lang.Apply(tmp13, []any{tmp17, v9}) + tmp10 = tmp18 + } else { + tmp10 = v9 + } + tmp5 = tmp10 + } // end let + tmp6 := lang.Apply(tmp4, []any{tmp5}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_parents = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_parents.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // parse-boolean + { + tmp0 := sym_parse_DASH_boolean.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_doc, "Parse strings \"true\" or \"false\" and return a boolean, or nil if invalid", kw_file, "glojure/core.glj", kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(7957), kw_end_DASH_line, int(7957))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + var tmp6 any + { // let + // let binding "G__691" + var v7 any = v2 + _ = v7 + } // end let + tmp3 = tmp6 + } else { + tmp7 := checkDerefVar(var_glojure_DOT_core_parsing_DASH_err) + tmp8 := lang.Apply(tmp7, []any{v2}) + tmp9 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp8}) + panic(tmp9) + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_parse_DASH_boolean = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_parse_DASH_boolean.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // parse-double + { + tmp0 := sym_parse_DASH_double.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_doc, "Parse string with floating point components and return a Double value,\n or nil if parse fails.\n\n Grammar: https://docs.oracle.com/javase/8/docs/api/java/lang/Double.html#valueOf-java.lang.String-", kw_file, "glojure/core.glj", kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(7935), kw_end_DASH_line, int(7935))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + var tmp6 any + { // let + // let binding "result__3649__auto__" + tmp7 := lang.Apply(strconv9.ParseFloat, []any{v2, int64(64)}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + tmp10 := lang.Apply(v8, []any{int64(1)}) + if lang.IsTruthy(tmp10) { + } else { + tmp11 := lang.Apply(v8, []any{int64(0)}) + tmp9 = tmp11 + } + tmp6 = tmp9 + } // end let + tmp3 = tmp6 + } else { + tmp7 := checkDerefVar(var_glojure_DOT_core_parsing_DASH_err) + tmp8 := lang.Apply(tmp7, []any{v2}) + tmp9 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp8}) + panic(tmp9) + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_parse_DASH_double = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_parse_DASH_double.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // parse-long + { + tmp0 := sym_parse_DASH_long.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s)), kw_doc, "Parse string of decimal digits with optional leading -/+ and return a\n Long value, or nil if parse fails", kw_file, "glojure/core.glj", kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(7926), kw_end_DASH_line, int(7926))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + var tmp6 any + { // let + // let binding "result__3648__auto__" + tmp7 := lang.Apply(strconv9.ParseInt, []any{v2, int64(10), int64(64)}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + tmp10 := lang.Apply(v8, []any{int64(1)}) + if lang.IsTruthy(tmp10) { + } else { + tmp11 := lang.Apply(v8, []any{int64(0)}) + tmp9 = tmp11 + } + tmp6 = tmp9 + } // end let + tmp3 = tmp6 + } else { + tmp7 := checkDerefVar(var_glojure_DOT_core_parsing_DASH_err) + tmp8 := lang.Apply(tmp7, []any{v2}) + tmp9 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp8}) + panic(tmp9) + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_parse_DASH_long = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_parse_DASH_long.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // partial + { + tmp0 := sym_partial.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_arg1), lang.NewVector(sym_f, sym_arg1, sym_arg2), lang.NewVector(sym_f, sym_arg1, sym_arg2, sym_arg3), lang.NewVector(sym_f, sym_arg1, sym_arg2, sym_arg3, sym__AMP_, sym_more)), kw_doc, "Takes a function f and fewer than the normal arguments to f, and\n returns a fn that takes a variable number of additional args. When\n called, the returned function calls f with args + additional args.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(2606), kw_end_DASH_line, int(2606))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + return v2 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp5 := lang.Apply(v2, []any{v3}) + return tmp5 + case 1: + v5 := args[0] + _ = v5 + tmp6 := lang.Apply(v2, []any{v3, v5}) + return tmp6 + case 2: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + tmp7 := lang.Apply(v2, []any{v3, v5, v6}) + return tmp7 + case 3: + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := args[2] + _ = v7 + tmp8 := lang.Apply(v2, []any{v3, v5, v6, v7}) + return tmp8 + default: + checkArity(args, 3) + v5 := args[0] + _ = v5 + v6 := args[1] + _ = v6 + v7 := args[2] + _ = v7 + var v8 any = lang.NewList(args[3:]...) + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_apply) + tmp10 := lang.Apply(tmp9, []any{v2, v3, v5, v6, v7, v8}) + return tmp10 + } + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2614), kw_column, int(4), kw_end_DASH_line, int(2619), kw_end_DASH_column, int(48)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp6 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp6 := lang.Apply(v2, []any{v3, v4}) + return tmp6 + case 1: + v6 := args[0] + _ = v6 + tmp7 := lang.Apply(v2, []any{v3, v4, v6}) + return tmp7 + case 2: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + tmp8 := lang.Apply(v2, []any{v3, v4, v6, v7}) + return tmp8 + case 3: + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + tmp9 := lang.Apply(v2, []any{v3, v4, v6, v7, v8}) + return tmp9 + default: + checkArity(args, 3) + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + v8 := args[2] + _ = v8 + var v9 any = lang.NewList(args[3:]...) + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_apply) + tmp11 := lang.Apply(tmp10, []any{v2, v3, v4, v6, v7, v8, v9}) + return tmp11 + } + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2621), kw_column, int(4), kw_end_DASH_line, int(2626), kw_end_DASH_column, int(53)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp7 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp7 := lang.Apply(v2, []any{v3, v4, v5}) + return tmp7 + case 1: + v7 := args[0] + _ = v7 + tmp8 := lang.Apply(v2, []any{v3, v4, v5, v7}) + return tmp8 + case 2: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + tmp9 := lang.Apply(v2, []any{v3, v4, v5, v7, v8}) + return tmp9 + case 3: + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + tmp10 := lang.Apply(v2, []any{v3, v4, v5, v7, v8, v9}) + return tmp10 + default: + checkArity(args, 3) + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + v9 := args[2] + _ = v9 + var v10 any = lang.NewList(args[3:]...) + _ = v10 + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + tmp12 := lang.Apply(tmp11, []any{v2, v3, v4, v5, v7, v8, v9, v10}) + return tmp12 + } + }) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2628), kw_column, int(4), kw_end_DASH_line, int(2633), kw_end_DASH_column, int(58)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp8 + default: + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var v6 any = lang.NewList(args[4:]...) + _ = v6 + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v8 any = lang.NewList(args[0:]...) + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_apply) + tmp10 := checkDerefVar(var_glojure_DOT_core_concat) + tmp11 := lang.Apply(tmp10, []any{v6, v8}) + tmp12 := lang.Apply(tmp9, []any{v2, v3, v4, v5, tmp11}) + return tmp12 + } + }) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2635), kw_column, int(4), kw_end_DASH_line, int(2635), kw_end_DASH_column, int(60)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp9 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_partial = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_partial.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // partition-by + { + tmp0 := sym_partition_DASH_by.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_coll)), kw_doc, "Applies f to each value in coll, splitting it each time f returns a\n new value. Returns a lazy seq of partitions. Returns a stateful\n transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(7142), kw_end_DASH_line, int(7142))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 any + { // let + // let binding "a" + var v6 any = "unimplemented: new with non-constant class type" + _ = v6 + // let binding "pv" + tmp7 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) + tmp8 := lang.Apply(tmp7, []any{kw_glojure_DOT_core_SLASH_none}) + var v9 any = tmp8 + _ = v9 + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp11 := lang.Apply(v4, nil) + return tmp11 + case 1: + v11 := args[0] + _ = v11 + var tmp12 any + { // let + // let binding "result" + var tmp13 any + tmp14, ok := lang.FieldOrMethod(v6, "isEmpty") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "isEmpty"))) + } + var tmp15 any + switch reflect.TypeOf(tmp14).Kind() { + case reflect.Func: + tmp15 = lang.Apply(tmp14, nil) + default: + tmp15 = tmp14 + } + if lang.IsTruthy(tmp15) { + tmp13 = v11 + } else { + var tmp16 any + { // let + // let binding "v" + tmp17 := checkDerefVar(var_glojure_DOT_core_vec) + tmp18, ok := lang.FieldOrMethod(v6, "toArray") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "toArray"))) + } + var tmp19 any + switch reflect.TypeOf(tmp18).Kind() { + case reflect.Func: + tmp19 = lang.Apply(tmp18, nil) + default: + tmp19 = tmp18 + } + tmp20 := lang.Apply(tmp17, []any{tmp19}) + var v21 any = tmp20 + _ = v21 + tmp22, ok := lang.FieldOrMethod(v6, "clear") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "clear"))) + } + var tmp23 any + switch reflect.TypeOf(tmp22).Kind() { + case reflect.Func: + tmp23 = lang.Apply(tmp22, nil) + default: + tmp23 = tmp22 + } + _ = tmp23 + tmp24 := checkDerefVar(var_glojure_DOT_core_unreduced) + tmp25 := lang.Apply(v4, []any{v11, v21}) + tmp26 := lang.Apply(tmp24, []any{tmp25}) + tmp16 = tmp26 + } // end let + tmp13 = tmp16 + } + var v17 any = tmp13 + _ = v17 + tmp18 := lang.Apply(v4, []any{v17}) + tmp12 = tmp18 + } // end let + return tmp12 + case 2: + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + var tmp13 any + { // let + // let binding "pval" + tmp14 := checkDerefVar(var_glojure_DOT_core_deref) + tmp15 := lang.Apply(tmp14, []any{v9}) + var v16 any = tmp15 + _ = v16 + // let binding "val" + tmp17 := lang.Apply(v2, []any{v12}) + var v18 any = tmp17 + _ = v18 + tmp19 := checkDerefVar(var_glojure_DOT_core_vreset_BANG_) + tmp20 := lang.Apply(tmp19, []any{v9, v18}) + _ = tmp20 + var tmp21 any + var tmp22 any + { // let + // let binding "or__0__auto__" + tmp23 := checkDerefVar(var_glojure_DOT_core_identical_QMARK_) + tmp24 := lang.Apply(tmp23, []any{v16, kw_glojure_DOT_core_SLASH_none}) + var v25 any = tmp24 + _ = v25 + var tmp26 any + if lang.IsTruthy(v25) { + tmp26 = v25 + } else { + tmp27 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp28 := lang.Apply(tmp27, []any{v18, v16}) + tmp26 = tmp28 + } + tmp22 = tmp26 + } // end let + if lang.IsTruthy(tmp22) { + tmp23, _ := lang.FieldOrMethod(v6, "add") + if reflect.TypeOf(tmp23).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) + } + tmp24 := lang.Apply(tmp23, []any{v12}) + _ = tmp24 + tmp21 = v11 + } else { + var tmp25 any + { // let + // let binding "v" + tmp26 := checkDerefVar(var_glojure_DOT_core_vec) + tmp27, ok := lang.FieldOrMethod(v6, "toArray") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "toArray"))) + } + var tmp28 any + switch reflect.TypeOf(tmp27).Kind() { + case reflect.Func: + tmp28 = lang.Apply(tmp27, nil) + default: + tmp28 = tmp27 + } + tmp29 := lang.Apply(tmp26, []any{tmp28}) + var v30 any = tmp29 + _ = v30 + tmp31, ok := lang.FieldOrMethod(v6, "clear") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "clear"))) + } + var tmp32 any + switch reflect.TypeOf(tmp31).Kind() { + case reflect.Func: + tmp32 = lang.Apply(tmp31, nil) + default: + tmp32 = tmp31 + } + _ = tmp32 + var tmp33 any + { // let + // let binding "ret" + tmp34 := lang.Apply(v4, []any{v11, v30}) + var v35 any = tmp34 + _ = v35 + var tmp36 any + tmp37 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) + tmp38 := lang.Apply(tmp37, []any{v35}) + if lang.IsTruthy(tmp38) { + } else { + tmp39, _ := lang.FieldOrMethod(v6, "add") + if reflect.TypeOf(tmp39).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) + } + tmp40 := lang.Apply(tmp39, []any{v12}) + tmp36 = tmp40 + } + _ = tmp36 + tmp33 = v35 + } // end let + tmp25 = tmp33 + } // end let + tmp21 = tmp25 + } + tmp13 = tmp21 + } // end let + return tmp13 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7152), kw_column, int(7), kw_end_DASH_line, int(7176), kw_end_DASH_column, int(28)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp5 = tmp12 + } // end let + return tmp5 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7149), kw_column, int(3), kw_end_DASH_line, int(7176), kw_end_DASH_column, int(30)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp5 any + { // let + // let binding "temp__0__auto__" + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := lang.Apply(tmp6, []any{v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + var tmp10 any + { // let + // let binding "s" + var v11 any = v8 + _ = v11 + var tmp12 any + { // let + // let binding "fst" + tmp13 := checkDerefVar(var_glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v11}) + var v15 any = tmp14 + _ = v15 + // let binding "fv" + tmp16 := lang.Apply(v2, []any{v15}) + var v17 any = tmp16 + _ = v17 + // let binding "run" + tmp18 := checkDerefVar(var_glojure_DOT_core_cons) + tmp19 := checkDerefVar(var_glojure_DOT_core_take_DASH_while) + var tmp20 lang.FnFunc + tmp20 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v21 := args[0] + _ = v21 + tmp22 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp23 := lang.Apply(v2, []any{v21}) + tmp24 := lang.Apply(tmp22, []any{v17, tmp23}) + return tmp24 + }) + tmp21 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7182), kw_column, int(41), kw_end_DASH_line, int(7182), kw_end_DASH_column, int(53)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp23 := checkDerefVar(var_glojure_DOT_core_next) + tmp24 := lang.Apply(tmp23, []any{v11}) + tmp25 := lang.Apply(tmp19, []any{tmp22, tmp24}) + tmp26 := lang.Apply(tmp18, []any{v15, tmp25}) + var v27 any = tmp26 + _ = v27 + tmp28 := checkDerefVar(var_glojure_DOT_core_cons) + tmp29 := checkDerefVar(var_glojure_DOT_core_partition_DASH_by) + var tmp30 lang.FnFunc + tmp30 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp31 := checkDerefVar(var_glojure_DOT_core_drop) + tmp32 := checkDerefVar(var_glojure_DOT_core_count) + tmp33 := lang.Apply(tmp32, []any{v27}) + tmp34 := lang.Apply(tmp31, []any{tmp33, v11}) + return tmp34 + }) + tmp31 := lang.Apply(lang.NewLazySeq, []any{tmp30}) + tmp32 := lang.Apply(tmp29, []any{v2, tmp31}) + tmp33 := lang.Apply(tmp28, []any{v27, tmp32}) + tmp12 = tmp33 + } // end let + tmp10 = tmp12 + } // end let + tmp9 = tmp10 + } else { + } + tmp5 = tmp9 + } // end let + return tmp5 + }) + tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_partition_DASH_by = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_partition_DASH_by.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // pmap + { + tmp0 := sym_pmap.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_coll), lang.NewVector(sym_f, sym_coll, sym__AMP_, sym_colls)), kw_doc, "Like map, except f is applied in parallel. Semi-lazy in that the\n parallel computation stays ahead of the consumption, but doesn't\n realize the entire result unless required. Only useful for\n computationally intensive functions where the time of f dominates\n the coordination overhead.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(7031), kw_end_DASH_line, int(7031))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "n" + tmp5 := checkDerefVar(var_glojure_DOT_core__PLUS_) + tmp6 := lang.Apply(runtime11.NumCPU, nil) + tmp7 := lang.Apply(tmp5, []any{int64(2), tmp6}) + var v8 any = tmp7 + _ = v8 + // let binding "rets" + tmp9 := checkDerefVar(var_glojure_DOT_core_map) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v11 := args[0] + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_future_DASH_call) + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp14 := lang.Apply(v2, []any{v11}) + return tmp14 + }) + tmp14 := lang.Apply(tmp12, []any{tmp13}) + return tmp14 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7041), kw_column, int(20), kw_end_DASH_line, int(7041), kw_end_DASH_column, int(34)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := lang.Apply(tmp9, []any{tmp12, v3}) + var v14 any = tmp13 + _ = v14 + // let binding "step" + var tmp15 lang.FnFunc + { // function step + var v16 lang.FnFunc + tmp15 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v17 := args[0] + _ = v17 + v18 := args[1] + _ = v18 + var tmp19 any + { // let + // let binding "vec__661" + var v20 any = v17 + _ = v20 + // let binding "seq__662" + tmp21 := checkDerefVar(var_glojure_DOT_core_seq) + tmp22 := lang.Apply(tmp21, []any{v20}) + var v23 any = tmp22 + _ = v23 + // let binding "first__663" + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v23}) + var v26 any = tmp25 + _ = v26 + // let binding "seq__662" + tmp27 := checkDerefVar(var_glojure_DOT_core_next) + tmp28 := lang.Apply(tmp27, []any{v23}) + var v29 any = tmp28 + _ = v29 + // let binding "x" + var v30 any = v26 + _ = v30 + // let binding "xs" + var v31 any = v29 + _ = v31 + // let binding "vs" + var v32 any = v20 + _ = v32 + var tmp33 lang.FnFunc + tmp33 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp34 any + { // let + // let binding "temp__0__auto__" + tmp35 := checkDerefVar(var_glojure_DOT_core_seq) + tmp36 := lang.Apply(tmp35, []any{v18}) + var v37 any = tmp36 + _ = v37 + var tmp38 any + if lang.IsTruthy(v37) { + var tmp39 any + { // let + // let binding "s" + var v40 any = v37 + _ = v40 + tmp41 := checkDerefVar(var_glojure_DOT_core_cons) + tmp42 := checkDerefVar(var_glojure_DOT_core_deref) + tmp43 := lang.Apply(tmp42, []any{v30}) + tmp44 := checkDerefVar(var_glojure_DOT_core_rest) + tmp45 := lang.Apply(tmp44, []any{v40}) + tmp46 := lang.Apply(v16, []any{v31, tmp45}) + tmp47 := lang.Apply(tmp41, []any{tmp43, tmp46}) + tmp39 = tmp47 + } // end let + tmp38 = tmp39 + } else { + tmp40 := checkDerefVar(var_glojure_DOT_core_map) + tmp41 := checkDerefVar(var_glojure_DOT_core_deref) + tmp42 := lang.Apply(tmp40, []any{tmp41, v32}) + tmp38 = tmp42 + } + tmp34 = tmp38 + } // end let + return tmp34 + }) + tmp34 := lang.Apply(lang.NewLazySeq, []any{tmp33}) + tmp19 = tmp34 + } // end let + return tmp19 + }) + v16 = tmp15 + _ = v16 + } + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7042), kw_column, int(15), kw_end_DASH_line, int(7046), kw_end_DASH_column, int(36)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v18 any = tmp17 + _ = v18 + tmp19 := checkDerefVar(var_glojure_DOT_core_drop) + tmp20 := lang.Apply(tmp19, []any{v8, v14}) + tmp21 := lang.Apply(v18, []any{v14, tmp20}) + tmp4 = tmp21 + } // end let + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "step" + var tmp6 lang.FnFunc + { // function step + var v7 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v8 := args[0] + _ = v8 + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp10 any + { // let + // let binding "ss" + tmp11 := checkDerefVar(var_glojure_DOT_core_map) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := lang.Apply(tmp11, []any{tmp12, v8}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + tmp16 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + tmp17 := checkDerefVar(var_glojure_DOT_core_identity) + tmp18 := lang.Apply(tmp16, []any{tmp17, v14}) + if lang.IsTruthy(tmp18) { + tmp19 := checkDerefVar(var_glojure_DOT_core_cons) + tmp20 := checkDerefVar(var_glojure_DOT_core_map) + tmp21 := checkDerefVar(var_glojure_DOT_core_first) + tmp22 := lang.Apply(tmp20, []any{tmp21, v14}) + tmp23 := checkDerefVar(var_glojure_DOT_core_map) + tmp24 := checkDerefVar(var_glojure_DOT_core_rest) + tmp25 := lang.Apply(tmp23, []any{tmp24, v14}) + tmp26 := lang.Apply(v7, []any{tmp25}) + tmp27 := lang.Apply(tmp19, []any{tmp22, tmp26}) + tmp15 = tmp27 + } else { + } + tmp10 = tmp15 + } // end let + return tmp10 + }) + tmp10 := lang.Apply(lang.NewLazySeq, []any{tmp9}) + return tmp10 + }) + v7 = tmp6 + _ = v7 + } + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7049), kw_column, int(15), kw_end_DASH_line, int(7053), kw_end_DASH_column, int(67)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v9 any = tmp8 + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_pmap) + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v12 := args[0] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_apply) + tmp14 := lang.Apply(tmp13, []any{v2, v12}) + return tmp14 + }) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7054), kw_column, int(12), kw_end_DASH_line, int(7054), kw_end_DASH_column, int(23)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp14 := checkDerefVar(var_glojure_DOT_core_cons) + tmp15 := lang.Apply(tmp14, []any{v3, v4}) + tmp16 := lang.Apply(v9, []any{tmp15}) + tmp17 := lang.Apply(tmp10, []any{tmp13, tmp16}) + tmp5 = tmp17 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_pmap = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_pmap.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // pos-int? + { + tmp0 := sym_pos_DASH_int_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a positive fixed precision integer", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(1403), kw_end_DASH_line, int(1403))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "and__0__auto__" + tmp4 := checkDerefVar(var_glojure_DOT_core_int_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + if lang.IsTruthy(v6) { + tmp8 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp9 := lang.Apply(tmp8, []any{v2}) + tmp7 = tmp9 + } else { + tmp7 = v6 + } + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_pos_DASH_int_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_pos_DASH_int_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // preserving-reduced + { + tmp0 := sym_preserving_DASH_reduced.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(7638), kw_column, int(7), kw_end_DASH_line, int(7638), kw_end_DASH_column, int(34), kw_arglists, lang.NewList(lang.NewVector(sym_rf)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var tmp6 any + { // let + // let binding "ret" + tmp7 := lang.Apply(v2, []any{v4, v5}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) + tmp11 := lang.Apply(tmp10, []any{v8}) + if lang.IsTruthy(tmp11) { + tmp12 := checkDerefVar(var_glojure_DOT_core_reduced) + tmp13 := lang.Apply(tmp12, []any{v8}) + tmp9 = tmp13 + } else { + tmp9 = v8 + } + tmp6 = tmp9 + } // end let + return tmp6 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7640), kw_column, int(3), kw_end_DASH_line, int(7643), kw_end_DASH_column, int(12)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_preserving_DASH_reduced = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_preserving_DASH_reduced.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print-sequential + { + tmp0 := sym_print_DASH_sequential.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(46), kw_column, int(8), kw_end_DASH_line, int(46), kw_end_DASH_column, int(23), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_begin, sym_print_DASH_one, sym_sep, sym_end, sym_sequence, sym_w)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 6) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + v7 := args[5] + _ = v7 + var tmp8 any + { // let + tmp9 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp10 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp11 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_print_DASH_level_STAR_) + var tmp12 any + { // let + // let binding "and__0__auto__" + tmp13 := checkDerefVar(var_glojure_DOT_core_not) + tmp14 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_dup_STAR_) + tmp15 := lang.Apply(tmp13, []any{tmp14}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + if lang.IsTruthy(v16) { + var tmp18 any + { // let + // let binding "and__0__auto__" + tmp19 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_level_STAR_) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + tmp22 := checkDerefVar(var_glojure_DOT_core_dec) + tmp23 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_level_STAR_) + tmp24 := lang.Apply(tmp22, []any{tmp23}) + tmp21 = tmp24 + } else { + tmp21 = v20 + } + tmp18 = tmp21 + } // end let + tmp17 = tmp18 + } else { + tmp17 = v16 + } + tmp12 = tmp17 + } // end let + tmp13 := lang.Apply(tmp10, []any{tmp11, tmp12}) + tmp14 := lang.Apply(tmp9, []any{tmp13}) + _ = tmp14 + var tmp15 any + func() { + defer func() { + tmp16 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp17 := lang.Apply(tmp16, nil) + _ = tmp17 + }() + var tmp18 any + var tmp19 any + { // let + // let binding "and__0__auto__" + tmp20 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_level_STAR_) + var v21 any = tmp20 + _ = v21 + var tmp22 any + if lang.IsTruthy(v21) { + tmp23 := checkDerefVar(var_glojure_DOT_core_neg_QMARK_) + tmp24 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_level_STAR_) + tmp25 := lang.Apply(tmp23, []any{tmp24}) + tmp22 = tmp25 + } else { + tmp22 = v21 + } + tmp19 = tmp22 + } // end let + if lang.IsTruthy(tmp19) { + tmp20 := lang.Apply(lang.WriteWriter, []any{v7, "#"}) + tmp18 = tmp20 + } else { + tmp21 := lang.Apply(lang.WriteWriter, []any{v7, v2}) + _ = tmp21 + var tmp22 any + { // let + // let binding "temp__0__auto__" + tmp23 := checkDerefVar(var_glojure_DOT_core_seq) + tmp24 := lang.Apply(tmp23, []any{v6}) + var v25 any = tmp24 + _ = v25 + var tmp26 any + if lang.IsTruthy(v25) { + var tmp27 any + { // let + // let binding "xs" + var v28 any = v25 + _ = v28 + var tmp29 any + var tmp30 any + { // let + // let binding "and__0__auto__" + tmp31 := checkDerefVar(var_glojure_DOT_core_not) + tmp32 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_dup_STAR_) + tmp33 := lang.Apply(tmp31, []any{tmp32}) + var v34 any = tmp33 + _ = v34 + var tmp35 any + if lang.IsTruthy(v34) { + tmp36 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_length_STAR_) + tmp35 = tmp36 + } else { + tmp35 = v34 + } + tmp30 = tmp35 + } // end let + if lang.IsTruthy(tmp30) { + var tmp31 any + { // let + // let binding "G__885" + var v32 any = v28 + _ = v32 + // let binding "vec__886" + var v33 any = v32 + _ = v33 + // let binding "seq__887" + tmp34 := checkDerefVar(var_glojure_DOT_core_seq) + tmp35 := lang.Apply(tmp34, []any{v33}) + var v36 any = tmp35 + _ = v36 + // let binding "first__888" + tmp37 := checkDerefVar(var_glojure_DOT_core_first) + tmp38 := lang.Apply(tmp37, []any{v36}) + var v39 any = tmp38 + _ = v39 + // let binding "seq__887" + tmp40 := checkDerefVar(var_glojure_DOT_core_next) + tmp41 := lang.Apply(tmp40, []any{v36}) + var v42 any = tmp41 + _ = v42 + // let binding "x" + var v43 any = v39 + _ = v43 + // let binding "xs" + var v44 any = v42 + _ = v44 + // let binding "print-length" + tmp45 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_length_STAR_) + var v46 any = tmp45 + _ = v46 + var tmp47 any + { // let + // let binding "G__885" + var v48 any = v32 + _ = v48 + // let binding "print-length" + var v49 any = v46 + _ = v49 + for { + var tmp50 any + { // let + // let binding "vec__889" + var v51 any = v48 + _ = v51 + // let binding "seq__890" + tmp52 := checkDerefVar(var_glojure_DOT_core_seq) + tmp53 := lang.Apply(tmp52, []any{v51}) + var v54 any = tmp53 + _ = v54 + // let binding "first__891" + tmp55 := checkDerefVar(var_glojure_DOT_core_first) + tmp56 := lang.Apply(tmp55, []any{v54}) + var v57 any = tmp56 + _ = v57 + // let binding "seq__890" + tmp58 := checkDerefVar(var_glojure_DOT_core_next) + tmp59 := lang.Apply(tmp58, []any{v54}) + var v60 any = tmp59 + _ = v60 + // let binding "x" + var v61 any = v57 + _ = v61 + // let binding "xs" + var v62 any = v60 + _ = v62 + // let binding "print-length" + var v63 any = v49 + _ = v63 + var tmp64 any + tmp65 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) + tmp66 := lang.Apply(tmp65, []any{v63}) + if lang.IsTruthy(tmp66) { + tmp67 := lang.Apply(lang.WriteWriter, []any{v7, "..."}) + tmp64 = tmp67 + } else { + tmp68 := lang.Apply(v3, []any{v61, v7}) + _ = tmp68 + var tmp69 any + if lang.IsTruthy(v62) { + tmp70 := lang.Apply(lang.WriteWriter, []any{v7, v4}) + _ = tmp70 + var tmp71 any = v62 + tmp73 := checkDerefVar(var_glojure_DOT_core_dec) + tmp74 := lang.Apply(tmp73, []any{v63}) + var tmp72 any = tmp74 + v48 = tmp71 + v49 = tmp72 + continue + } else { + } + tmp64 = tmp69 + } + tmp50 = tmp64 + } // end let + tmp47 = tmp50 + break + } + } // end let + tmp31 = tmp47 + } // end let + tmp29 = tmp31 + } else { + var tmp32 any + { // let + // let binding "G__895" + var v33 any = v28 + _ = v33 + // let binding "vec__896" + var v34 any = v33 + _ = v34 + // let binding "seq__897" + tmp35 := checkDerefVar(var_glojure_DOT_core_seq) + tmp36 := lang.Apply(tmp35, []any{v34}) + var v37 any = tmp36 + _ = v37 + // let binding "first__898" + tmp38 := checkDerefVar(var_glojure_DOT_core_first) + tmp39 := lang.Apply(tmp38, []any{v37}) + var v40 any = tmp39 + _ = v40 + // let binding "seq__897" + tmp41 := checkDerefVar(var_glojure_DOT_core_next) + tmp42 := lang.Apply(tmp41, []any{v37}) + var v43 any = tmp42 + _ = v43 + // let binding "x" + var v44 any = v40 + _ = v44 + // let binding "xs" + var v45 any = v43 + _ = v45 + var tmp46 any + { // let + // let binding "G__895" + var v47 any = v33 + _ = v47 + for { + var tmp48 any + { // let + // let binding "vec__899" + var v49 any = v47 + _ = v49 + // let binding "seq__900" + tmp50 := checkDerefVar(var_glojure_DOT_core_seq) + tmp51 := lang.Apply(tmp50, []any{v49}) + var v52 any = tmp51 + _ = v52 + // let binding "first__901" + tmp53 := checkDerefVar(var_glojure_DOT_core_first) + tmp54 := lang.Apply(tmp53, []any{v52}) + var v55 any = tmp54 + _ = v55 + // let binding "seq__900" + tmp56 := checkDerefVar(var_glojure_DOT_core_next) + tmp57 := lang.Apply(tmp56, []any{v52}) + var v58 any = tmp57 + _ = v58 + // let binding "x" + var v59 any = v55 + _ = v59 + // let binding "xs" + var v60 any = v58 + _ = v60 + tmp61 := lang.Apply(v3, []any{v59, v7}) + _ = tmp61 + var tmp62 any + if lang.IsTruthy(v60) { + tmp63 := lang.Apply(lang.WriteWriter, []any{v7, v4}) + _ = tmp63 + var tmp64 any = v60 + v47 = tmp64 + continue + } else { + } + tmp48 = tmp62 + } // end let + tmp46 = tmp48 + break + } + } // end let + tmp32 = tmp46 + } // end let + tmp29 = tmp32 + } + tmp27 = tmp29 + } // end let + tmp26 = tmp27 + } else { + } + tmp22 = tmp26 + } // end let + _ = tmp22 + tmp23 := lang.Apply(lang.WriteWriter, []any{v7, v5}) + tmp18 = tmp23 + } + tmp15 = tmp18 + }() + tmp8 = tmp15 + } // end let + return tmp8 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_print_DASH_sequential = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_print_DASH_sequential.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // protocol? + { + tmp0 := sym_protocol_QMARK_.WithMeta(lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(110), kw_column, int(8), kw_end_DASH_line, int(110), kw_end_DASH_column, int(16), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_maybe_DASH_p)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp5 := reflect.TypeOf((*lang.IAtom)(nil)).Elem() + tmp6 := lang.Apply(tmp4, []any{tmp5, v2}) + if lang.IsTruthy(tmp6) { + tmp7 := checkDerefVar(var_glojure_DOT_core_boolean) + tmp8 := checkDerefVar(var_glojure_DOT_core_deref) + tmp9 := lang.Apply(tmp8, []any{v2}) + tmp10 := lang.Apply(kw_on_DASH_interface, []any{tmp9}) + tmp11 := lang.Apply(tmp7, []any{tmp10}) + tmp3 = tmp11 + } else { + tmp3 = false + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_protocol_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_protocol_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // pvalues + { + tmp0 := sym_pvalues.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_exprs)), kw_doc, "Returns a lazy sequence of the values of the exprs, which are\n evaluated in parallel", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(7063), kw_end_DASH_line, int(7063))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym_glojure_DOT_core_SLASH_pcalls}) + tmp9 := checkDerefVar(var_glojure_DOT_core_map) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v11 := args[0] + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.NewVector() + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7069), kw_column, int(30), kw_end_DASH_line, int(7069), kw_end_DASH_column, int(31)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp16 := lang.Apply(tmp12, []any{sym_glojure_DOT_core_SLASH_fn, tmp15, v11}) + return tmp16 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7069), kw_column, int(19), kw_end_DASH_line, int(7069), kw_end_DASH_column, int(34)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := lang.Apply(tmp9, []any{tmp12, v4}) + tmp14 := lang.Apply(tmp6, []any{tmp8, tmp13}) + tmp15 := lang.Apply(tmp5, []any{tmp14}) + return tmp15 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_pvalues = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_pvalues.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // qualified-ident? + { + tmp0 := sym_qualified_DASH_ident_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a symbol or keyword with a namespace", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(22), kw_column, int(7), kw_line, int(1618), kw_end_DASH_line, int(1618))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp4 any + { // let + // let binding "and__0__auto__" + tmp5 := checkDerefVar(var_glojure_DOT_core_ident_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v2}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + if lang.IsTruthy(v7) { + var tmp9 any + { // let + // let binding "and__0__auto__" + tmp10 := checkDerefVar(var_glojure_DOT_core_namespace) + tmp11 := lang.Apply(tmp10, []any{v2}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + tmp13 = true + } else { + tmp13 = v12 + } + tmp9 = tmp13 + } // end let + tmp8 = tmp9 + } else { + tmp8 = v7 + } + tmp4 = tmp8 + } // end let + tmp5 := lang.Apply(tmp3, []any{tmp4}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_qualified_DASH_ident_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_qualified_DASH_ident_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // qualified-keyword? + { + tmp0 := sym_qualified_DASH_keyword_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a keyword with a namespace", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(24), kw_column, int(7), kw_line, int(1638), kw_end_DASH_line, int(1638))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp4 any + { // let + // let binding "and__0__auto__" + tmp5 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v2}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + if lang.IsTruthy(v7) { + var tmp9 any + { // let + // let binding "and__0__auto__" + tmp10 := checkDerefVar(var_glojure_DOT_core_namespace) + tmp11 := lang.Apply(tmp10, []any{v2}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + tmp13 = true + } else { + tmp13 = v12 + } + tmp9 = tmp13 + } // end let + tmp8 = tmp9 + } else { + tmp8 = v7 + } + tmp4 = tmp8 + } // end let + tmp5 := lang.Apply(tmp3, []any{tmp4}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_qualified_DASH_keyword_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_qualified_DASH_keyword_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // qualified-symbol? + { + tmp0 := sym_qualified_DASH_symbol_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Return true if x is a symbol with a namespace", kw_file, "glojure/core.glj", kw_added, "1.9", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(7), kw_line, int(1628), kw_end_DASH_line, int(1628))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_boolean) + var tmp4 any + { // let + // let binding "and__0__auto__" + tmp5 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v2}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + if lang.IsTruthy(v7) { + var tmp9 any + { // let + // let binding "and__0__auto__" + tmp10 := checkDerefVar(var_glojure_DOT_core_namespace) + tmp11 := lang.Apply(tmp10, []any{v2}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + tmp13 = true + } else { + tmp13 = v12 + } + tmp9 = tmp13 + } // end let + tmp8 = tmp9 + } else { + tmp8 = v7 + } + tmp4 = tmp8 + } // end let + tmp5 := lang.Apply(tmp3, []any{tmp4}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_qualified_DASH_symbol_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_qualified_DASH_symbol_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // rand + { + tmp0 := sym_rand.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_n)), kw_doc, "Returns a random floating point number between 0 (inclusive) and\n n (default 1) (exclusive).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(4935), kw_end_DASH_line, int(4935))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp2 := lang.Apply(rand13.Float64, nil) + return tmp2 + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core__STAR_) + tmp4 := checkDerefVar(var_glojure_DOT_core_rand) + tmp5 := lang.Apply(tmp4, nil) + tmp6 := lang.Apply(tmp3, []any{v2, tmp5}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_rand = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_rand.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // rand-int + { + tmp0 := sym_rand_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n)), kw_doc, "Returns a random integer between 0 (inclusive) and n (exclusive).", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(4943), kw_end_DASH_line, int(4943))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_int) + tmp4 := checkDerefVar(var_glojure_DOT_core_rand) + tmp5 := lang.Apply(tmp4, []any{v2}) + tmp6 := lang.Apply(tmp3, []any{tmp5}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_rand_DASH_int = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_rand_DASH_int.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // rand-nth + { + tmp0 := sym_rand_DASH_nth.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Return a random element of the (sequential) collection. Will have\n the same performance characteristics as nth for the given\n collection.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(7213), kw_end_DASH_line, int(7213))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_nth) + tmp4 := checkDerefVar(var_glojure_DOT_core_rand_DASH_int) + tmp5 := checkDerefVar(var_glojure_DOT_core_count) + tmp6 := lang.Apply(tmp5, []any{v2}) + tmp7 := lang.Apply(tmp4, []any{tmp6}) + tmp8 := lang.Apply(tmp3, []any{v2, tmp7}) + return tmp8 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_rand_DASH_nth = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_rand_DASH_nth.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // random-sample + { + tmp0 := sym_random_DASH_sample.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_prob), lang.NewVector(sym_prob, sym_coll)), kw_doc, "Returns items from coll with random probability of prob (0.0 -\n 1.0). Returns a transducer when no collection is provided.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(7699), kw_end_DASH_line, int(7699))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_filter) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v5 := args[0] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp7 := checkDerefVar(var_glojure_DOT_core_rand) + tmp8 := lang.Apply(tmp7, nil) + tmp9 := lang.Apply(tmp6, []any{tmp8, v2}) + return tmp9 + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7704), kw_column, int(14), kw_end_DASH_line, int(7704), kw_end_DASH_column, int(37)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp7 := lang.Apply(tmp3, []any{tmp6}) + return tmp7 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_filter) + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v6 := args[0] + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp8 := checkDerefVar(var_glojure_DOT_core_rand) + tmp9 := lang.Apply(tmp8, nil) + tmp10 := lang.Apply(tmp7, []any{tmp9, v2}) + return tmp10 + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7706), kw_column, int(14), kw_end_DASH_line, int(7706), kw_end_DASH_column, int(37)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp8 := lang.Apply(tmp4, []any{tmp7, v3}) + return tmp8 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_random_DASH_sample = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_random_DASH_sample.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // re-groups + { + tmp0 := sym_re_DASH_groups.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m)), kw_doc, "Returns the groups from the most recent match/find. If there are no\n nested groups, returns a string of the entire match. If there are\n nested groups, returns a vector of the groups, the first element\n being the entire match.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(4882), kw_end_DASH_line, int(4882))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "gc" + tmp4, _ := lang.FieldOrMethod(v2, "groupCount") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("groupCount is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) + tmp9 := lang.Apply(tmp8, []any{v6}) + if lang.IsTruthy(tmp9) { + tmp10, _ := lang.FieldOrMethod(v2, "group") + if reflect.TypeOf(tmp10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("group is not a function"))) + } + tmp11 := lang.Apply(tmp10, []any{}) + tmp7 = tmp11 + } else { + var tmp12 any + { // let + // let binding "ret" + tmp13 := lang.NewVector() + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4893), kw_column, int(20), kw_end_DASH_line, int(4893), kw_end_DASH_column, int(21)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v16 any = tmp15 + _ = v16 + // let binding "c" + var v17 any = int64(0) + _ = v17 + for { + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core__LT__EQ_) + tmp20 := lang.Apply(tmp19, []any{v17, v6}) + if lang.IsTruthy(tmp20) { + tmp22 := checkDerefVar(var_glojure_DOT_core_conj) + tmp23, _ := lang.FieldOrMethod(v2, "groupInt") + if reflect.TypeOf(tmp23).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("groupInt is not a function"))) + } + tmp24 := lang.Apply(tmp23, []any{v17}) + tmp25 := lang.Apply(tmp22, []any{v16, tmp24}) + var tmp21 any = tmp25 + tmp27 := checkDerefVar(var_glojure_DOT_core_inc) + tmp28 := lang.Apply(tmp27, []any{v17}) + var tmp26 any = tmp28 + v16 = tmp21 + v17 = tmp26 + continue + } else { + tmp18 = v16 + } + tmp12 = tmp18 + break + } + } // end let + tmp7 = tmp12 + } + tmp3 = tmp7 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_re_DASH_groups = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_re_DASH_groups.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // re-matches + { + tmp0 := sym_re_DASH_matches.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_re, sym_s)), kw_doc, "Returns the match, if any, of string to pattern, using\n java.util.regex.Matcher.matches(). Uses re-groups to return the\n groups.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4910), kw_end_DASH_line, int(4910))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "m" + tmp5 := checkDerefVar(var_glojure_DOT_core_re_DASH_matcher) + tmp6 := lang.Apply(tmp5, []any{v2, v3}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + tmp9, _ := lang.FieldOrMethod(v7, "matches") + if reflect.TypeOf(tmp9).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("matches is not a function"))) + } + tmp10 := lang.Apply(tmp9, []any{}) + if lang.IsTruthy(tmp10) { + tmp11 := checkDerefVar(var_glojure_DOT_core_re_DASH_groups) + tmp12 := lang.Apply(tmp11, []any{v7}) + tmp8 = tmp12 + } else { + } + tmp4 = tmp8 + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_re_DASH_matches = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_re_DASH_matches.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // re-seq + { + tmp0 := sym_re_DASH_seq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_re, sym_s)), kw_doc, "Returns a lazy sequence of successive matches of pattern in string,\n using java.util.regex.Matcher.find(), each such match processed with\n re-groups.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(4898), kw_end_DASH_line, int(4898))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "m" + tmp5 := checkDerefVar(var_glojure_DOT_core_re_DASH_matcher) + tmp6 := lang.Apply(tmp5, []any{v2, v3}) + var v7 any = tmp6 + _ = v7 + var tmp8 lang.FnFunc + { // function step + var v9 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp10 any + tmp11, _ := lang.FieldOrMethod(v7, "find") + if reflect.TypeOf(tmp11).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("find is not a function"))) + } + tmp12 := lang.Apply(tmp11, []any{}) + if lang.IsTruthy(tmp12) { + tmp13 := checkDerefVar(var_glojure_DOT_core_cons) + tmp14 := checkDerefVar(var_glojure_DOT_core_re_DASH_groups) + tmp15 := lang.Apply(tmp14, []any{v7}) + var tmp16 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp17 := lang.Apply(v9, nil) + return tmp17 + }) + tmp17 := lang.Apply(lang.NewLazySeq, []any{tmp16}) + tmp18 := lang.Apply(tmp13, []any{tmp15, tmp17}) + tmp10 = tmp18 + } else { + } + return tmp10 + }) + v9 = tmp8 + _ = v9 + } + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4906), kw_column, int(6), kw_end_DASH_line, int(4908), kw_end_DASH_column, int(49)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp11 := lang.Apply(tmp10, nil) + tmp4 = tmp11 + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_re_DASH_seq = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_re_DASH_seq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // refer + { + tmp0 := sym_refer.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns_DASH_sym, sym__AMP_, sym_filters)), kw_doc, "refers to all public vars of ns, subject to filters.\n filters can include at most one each of:\n\n :exclude list-of-symbols\n :only list-of-symbols\n :rename map-of-fromsymbol-tosymbol\n\n For each public interned var in the namespace named by the symbol,\n adds a mapping from the name of the var to the var to the current\n namespace. Throws an exception if name is already mapped to\n something else in the current namespace. Filters can be used to\n select a subset, via inclusion or exclusion, or to provide a mapping\n to a symbol different from the var's name, in order to prevent\n clashes. Use :use in the ns macro in preference to calling this directly.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(4216), kw_end_DASH_line, int(4216))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + var tmp4 any + { // let + // let binding "ns" + var tmp5 any + { // let + // let binding "or__0__auto__" + tmp6 := checkDerefVar(var_glojure_DOT_core_find_DASH_ns) + tmp7 := lang.Apply(tmp6, []any{v2}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + tmp9 = v8 + } else { + tmp10 := checkDerefVar(var_glojure_DOT_core_str) + tmp11 := lang.Apply(tmp10, []any{"No namespace: ", v2}) + tmp12 := lang.Apply(errors5.New, []any{tmp11}) + panic(tmp12) + } + tmp5 = tmp9 + } // end let + var v6 any = tmp5 + _ = v6 + // let binding "fs" + tmp7 := checkDerefVar(var_glojure_DOT_core_apply) + tmp8 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp9 := lang.Apply(tmp7, []any{tmp8, v3}) + var v10 any = tmp9 + _ = v10 + // let binding "nspublics" + tmp11 := checkDerefVar(var_glojure_DOT_core_ns_DASH_publics) + tmp12 := lang.Apply(tmp11, []any{v6}) + var v13 any = tmp12 + _ = v13 + // let binding "rename" + var tmp14 any + { // let + // let binding "or__0__auto__" + tmp15 := lang.Apply(kw_rename, []any{v10}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + if lang.IsTruthy(v16) { + tmp17 = v16 + } else { + tmp18 := lang.NewMap() + tmp19 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4236), kw_column, int(35), kw_end_DASH_line, int(4236), kw_end_DASH_column, int(36)) + tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp17 = tmp20 + } + tmp14 = tmp17 + } // end let + var v15 any = tmp14 + _ = v15 + // let binding "exclude" + tmp16 := checkDerefVar(var_glojure_DOT_core_set) + tmp17 := lang.Apply(kw_exclude, []any{v10}) + tmp18 := lang.Apply(tmp16, []any{tmp17}) + var v19 any = tmp18 + _ = v19 + // let binding "to-do" + var tmp20 any + tmp21 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp22 := lang.Apply(kw_refer, []any{v10}) + tmp23 := lang.Apply(tmp21, []any{kw_all, tmp22}) + if lang.IsTruthy(tmp23) { + tmp24 := checkDerefVar(var_glojure_DOT_core_keys) + tmp25 := lang.Apply(tmp24, []any{v13}) + tmp20 = tmp25 + } else { + var tmp26 any + { // let + // let binding "or__0__auto__" + tmp27 := lang.Apply(kw_refer, []any{v10}) + var v28 any = tmp27 + _ = v28 + var tmp29 any + if lang.IsTruthy(v28) { + tmp29 = v28 + } else { + var tmp30 any + { // let + // let binding "or__0__auto__" + tmp31 := lang.Apply(kw_only, []any{v10}) + var v32 any = tmp31 + _ = v32 + var tmp33 any + if lang.IsTruthy(v32) { + tmp33 = v32 + } else { + tmp34 := checkDerefVar(var_glojure_DOT_core_keys) + tmp35 := lang.Apply(tmp34, []any{v13}) + tmp33 = tmp35 + } + tmp30 = tmp33 + } // end let + tmp29 = tmp30 + } + tmp26 = tmp29 + } // end let + tmp20 = tmp26 + } + var v27 any = tmp20 + _ = v27 + var tmp28 any + var tmp29 any + { // let + // let binding "and__0__auto__" + var v30 any = v27 + _ = v30 + var tmp31 any + if lang.IsTruthy(v30) { + tmp32 := checkDerefVar(var_glojure_DOT_core_not) + tmp33 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp34 := reflect.TypeOf((*lang.Sequential)(nil)).Elem() + tmp35 := lang.Apply(tmp33, []any{tmp34, v27}) + tmp36 := lang.Apply(tmp32, []any{tmp35}) + tmp31 = tmp36 + } else { + tmp31 = v30 + } + tmp29 = tmp31 + } // end let + if lang.IsTruthy(tmp29) { + tmp30 := lang.Apply(errors5.New, []any{":only/:refer value must be a sequential collection of symbols"}) + panic(tmp30) + } else { + } + _ = tmp28 + var tmp31 any + { // let + // let binding "seq_700" + tmp32 := checkDerefVar(var_glojure_DOT_core_seq) + tmp33 := lang.Apply(tmp32, []any{v27}) + var v34 any = tmp33 + _ = v34 + // let binding "chunk_701" + var v35 any = nil + _ = v35 + // let binding "count_702" + var v36 any = int64(0) + _ = v36 + // let binding "i_703" + var v37 any = int64(0) + _ = v37 + for { + var tmp38 any + tmp39 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp40 := lang.Apply(tmp39, []any{v37, v36}) + if lang.IsTruthy(tmp40) { + var tmp41 any + { // let + // let binding "sym" + tmp42, _ := lang.FieldOrMethod(v35, "nth") + if reflect.TypeOf(tmp42).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp43 := lang.Apply(tmp42, []any{v37}) + var v44 any = tmp43 + _ = v44 + var tmp45 any + tmp46 := lang.Apply(v19, []any{v44}) + if lang.IsTruthy(tmp46) { + } else { + var tmp47 any + { // let + // let binding "v" + tmp48 := lang.Apply(v13, []any{v44}) + var v49 any = tmp48 + _ = v49 + var tmp50 any + if lang.IsTruthy(v49) { + } else { + panic("unimplemented: new with non-constant class type") + } + _ = tmp50 + tmp51 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + var tmp52 any + { // let + // let binding "or__0__auto__" + tmp53 := lang.Apply(v15, []any{v44}) + var v54 any = tmp53 + _ = v54 + var tmp55 any + if lang.IsTruthy(v54) { + tmp55 = v54 + } else { + tmp55 = v44 + } + tmp52 = tmp55 + } // end let + tmp53, _ := lang.FieldOrMethod(tmp51, "Refer") + if reflect.TypeOf(tmp53).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Refer is not a function"))) + } + tmp54 := lang.Apply(tmp53, []any{tmp52, v49}) + tmp47 = tmp54 + } // end let + tmp45 = tmp47 + } + _ = tmp45 + var tmp48 any = v34 + var tmp49 any = v35 + var tmp50 any = v36 + tmp52 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp53 := lang.Apply(tmp52, []any{v37}) + var tmp51 any = tmp53 + v34 = tmp48 + v35 = tmp49 + v36 = tmp50 + v37 = tmp51 + continue + } // end let + tmp38 = tmp41 + } else { + var tmp42 any + { // let + // let binding "temp__0__auto__" + tmp43 := checkDerefVar(var_glojure_DOT_core_seq) + tmp44 := lang.Apply(tmp43, []any{v34}) + var v45 any = tmp44 + _ = v45 + var tmp46 any + if lang.IsTruthy(v45) { + var tmp47 any + { // let + // let binding "seq_700" + var v48 any = v45 + _ = v48 + var tmp49 any + tmp50 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp51 := lang.Apply(tmp50, []any{v48}) + if lang.IsTruthy(tmp51) { + var tmp52 any + { // let + // let binding "c__0__auto__" + tmp53 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp54 := lang.Apply(tmp53, []any{v48}) + var v55 any = tmp54 + _ = v55 + tmp57 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp58 := lang.Apply(tmp57, []any{v48}) + var tmp56 any = tmp58 + var tmp59 any = v55 + tmp61 := checkDerefVar(var_glojure_DOT_core_int) + tmp62 := checkDerefVar(var_glojure_DOT_core_count) + tmp63 := lang.Apply(tmp62, []any{v55}) + tmp64 := lang.Apply(tmp61, []any{tmp63}) + var tmp60 any = tmp64 + tmp66 := checkDerefVar(var_glojure_DOT_core_int) + tmp67 := lang.Apply(tmp66, []any{int64(0)}) + var tmp65 any = tmp67 + v34 = tmp56 + v35 = tmp59 + v36 = tmp60 + v37 = tmp65 + continue + } // end let + tmp49 = tmp52 + } else { + var tmp53 any + { // let + // let binding "sym" + tmp54 := checkDerefVar(var_glojure_DOT_core_first) + tmp55 := lang.Apply(tmp54, []any{v48}) + var v56 any = tmp55 + _ = v56 + var tmp57 any + tmp58 := lang.Apply(v19, []any{v56}) + if lang.IsTruthy(tmp58) { + } else { + var tmp59 any + { // let + // let binding "v" + tmp60 := lang.Apply(v13, []any{v56}) + var v61 any = tmp60 + _ = v61 + var tmp62 any + if lang.IsTruthy(v61) { + } else { + panic("unimplemented: new with non-constant class type") + } + _ = tmp62 + tmp63 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + var tmp64 any + { // let + // let binding "or__0__auto__" + tmp65 := lang.Apply(v15, []any{v56}) + var v66 any = tmp65 + _ = v66 + var tmp67 any + if lang.IsTruthy(v66) { + tmp67 = v66 + } else { + tmp67 = v56 + } + tmp64 = tmp67 + } // end let + tmp65, _ := lang.FieldOrMethod(tmp63, "Refer") + if reflect.TypeOf(tmp65).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Refer is not a function"))) + } + tmp66 := lang.Apply(tmp65, []any{tmp64, v61}) + tmp59 = tmp66 + } // end let + tmp57 = tmp59 + } + _ = tmp57 + tmp61 := checkDerefVar(var_glojure_DOT_core_next) + tmp62 := lang.Apply(tmp61, []any{v48}) + var tmp60 any = tmp62 + var tmp63 any = nil + var tmp64 any = int64(0) + var tmp65 any = int64(0) + v34 = tmp60 + v35 = tmp63 + v36 = tmp64 + v37 = tmp65 + continue + } // end let + tmp49 = tmp53 + } + tmp47 = tmp49 + } // end let + tmp46 = tmp47 + } else { + } + tmp42 = tmp46 + } // end let + tmp38 = tmp42 + } + tmp31 = tmp38 + break + } + } // end let + tmp4 = tmp31 + } // end let + return tmp4 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_refer = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_refer.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // remove + { + tmp0 := sym_remove.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred), lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns a lazy sequence of the items in coll for which\n (pred item) returns logical false. pred must be free of side-effects.\n Returns a transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(2818), kw_end_DASH_line, int(2818))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_filter) + tmp4 := checkDerefVar(var_glojure_DOT_core_complement) + tmp5 := lang.Apply(tmp4, []any{v2}) + tmp6 := lang.Apply(tmp3, []any{tmp5}) + return tmp6 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_filter) + tmp5 := checkDerefVar(var_glojure_DOT_core_complement) + tmp6 := lang.Apply(tmp5, []any{v2}) + tmp7 := lang.Apply(tmp4, []any{tmp6, v3}) + return tmp7 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_remove = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_remove.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // replace + { + tmp0 := sym_replace.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_smap), lang.NewVector(sym_smap, sym_coll)), kw_doc, "Given a map of replacement pairs and a vector/collection, returns a\n vector/seq with any elements = a key in smap replaced with the\n corresponding val in smap. Returns a transducer when no collection\n is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(5082), kw_end_DASH_line, int(5082))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_map) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v5 := args[0] + _ = v5 + var tmp6 any + { // let + // let binding "temp__0__auto__" + tmp7 := checkDerefVar(var_glojure_DOT_core_find) + tmp8 := lang.Apply(tmp7, []any{v2, v5}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + var tmp11 any + { // let + // let binding "e" + var v12 any = v9 + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_val) + tmp14 := lang.Apply(tmp13, []any{v12}) + tmp11 = tmp14 + } // end let + tmp10 = tmp11 + } else { + tmp10 = v5 + } + tmp6 = tmp10 + } // end let + return tmp6 + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5090), kw_column, int(11), kw_end_DASH_line, int(5090), kw_end_DASH_column, int(47)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp7 := lang.Apply(tmp3, []any{tmp6}) + return tmp7 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp8 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v9 := args[0] + _ = v9 + v10 := args[1] + _ = v10 + var tmp11 any + { // let + // let binding "temp__0__auto__" + tmp12 := checkDerefVar(var_glojure_DOT_core_find) + tmp13 := checkDerefVar(var_glojure_DOT_core_nth) + tmp14 := lang.Apply(tmp13, []any{v9, v10}) + tmp15 := lang.Apply(tmp12, []any{v2, tmp14}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + if lang.IsTruthy(v16) { + var tmp18 any + { // let + // let binding "e" + var v19 any = v16 + _ = v19 + tmp20 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp21 := checkDerefVar(var_glojure_DOT_core_val) + tmp22 := lang.Apply(tmp21, []any{v19}) + tmp23 := lang.Apply(tmp20, []any{v9, v10, tmp22}) + tmp18 = tmp23 + } // end let + tmp17 = tmp18 + } else { + tmp17 = v9 + } + tmp11 = tmp17 + } // end let + return tmp11 + }) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5093), kw_column, int(17), kw_end_DASH_line, int(5096), kw_end_DASH_column, int(23)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp11 := checkDerefVar(var_glojure_DOT_core_range) + tmp12 := checkDerefVar(var_glojure_DOT_core_count) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(tmp11, []any{tmp13}) + tmp15 := lang.Apply(tmp7, []any{tmp10, v3, tmp14}) + tmp4 = tmp15 + } else { + tmp16 := checkDerefVar(var_glojure_DOT_core_map) + var tmp17 lang.FnFunc + tmp17 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v18 := args[0] + _ = v18 + var tmp19 any + { // let + // let binding "temp__0__auto__" + tmp20 := checkDerefVar(var_glojure_DOT_core_find) + tmp21 := lang.Apply(tmp20, []any{v2, v18}) + var v22 any = tmp21 + _ = v22 + var tmp23 any + if lang.IsTruthy(v22) { + var tmp24 any + { // let + // let binding "e" + var v25 any = v22 + _ = v25 + tmp26 := checkDerefVar(var_glojure_DOT_core_val) + tmp27 := lang.Apply(tmp26, []any{v25}) + tmp24 = tmp27 + } // end let + tmp23 = tmp24 + } else { + tmp23 = v18 + } + tmp19 = tmp23 + } // end let + return tmp19 + }) + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5098), kw_column, int(13), kw_end_DASH_line, int(5098), kw_end_DASH_column, int(49)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp20 := lang.Apply(tmp16, []any{tmp19, v3}) + tmp4 = tmp20 + } + return tmp4 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_replace = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_replace.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // restart-agent + { + tmp0 := sym_restart_DASH_agent.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a, sym_new_DASH_state, sym__AMP_, sym_options)), kw_doc, "When an agent is failed, changes the agent state to new-state and\n then un-fails the agent so that sends are allowed again. If\n a :clear-actions true option is given, any actions queued on the\n agent that were being held while it was failed will be discarded,\n otherwise those held actions will proceed. The new-state must pass\n the validator if any, or restart will throw an exception and the\n agent will remain failed with its old state and error. Watchers, if\n any, will NOT be notified of the new state. Throws an exception if\n the agent is not failed.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(2175), kw_end_DASH_line, int(2175))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "opts" + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp8 := lang.Apply(tmp6, []any{tmp7, v4}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + tmp11 := lang.Apply(kw_clear_DASH_actions, []any{v9}) + if lang.IsTruthy(tmp11) { + tmp10 = true + } else { + tmp10 = false + } + tmp12, _ := lang.FieldOrMethod(v2, "restart") + if reflect.TypeOf(tmp12).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("restart is not a function"))) + } + tmp13 := lang.Apply(tmp12, []any{v3, tmp10}) + tmp5 = tmp13 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_restart_DASH_agent = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_restart_DASH_agent.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // root-directory + { + tmp0 := sym_root_DASH_directory.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_lib)), kw_doc, "Returns the root resource path for a lib", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(8), kw_line, int(5871), kw_end_DASH_line, int(5871), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "d" + tmp4 := checkDerefVar(var_glojure_DOT_core_root_DASH_resource) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_subs) + tmp8 := lang.Apply(strings8.LastIndex, []any{v6, "/"}) + tmp9 := lang.Apply(tmp7, []any{v6, int64(0), tmp8}) + tmp3 = tmp9 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_root_DASH_directory = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_root_DASH_directory.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // rsubseq + { + tmp0 := sym_rsubseq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_sc, sym_test, sym_key), lang.NewVector(sym_sc, sym_start_DASH_test, sym_start_DASH_key, sym_end_DASH_test, sym_end_DASH_key)), kw_doc, "sc must be a sorted collection, test(s) one of <, <=, > or\n >=. Returns a reverse seq of those entries with keys ek for\n which (test (.. sc comparator (compare ek key)) 0) is true", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(5150), kw_end_DASH_line, int(5150))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + { // let + // let binding "include" + tmp6 := checkDerefVar(var_glojure_DOT_core_mk_DASH_bound_DASH_fn) + tmp7 := lang.Apply(tmp6, []any{v2, v3, v4}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp11 := checkDerefVar(var_glojure_DOT_core__LT__EQ_) + tmp12 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{tmp10, tmp11})) + tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5158), kw_column, int(11), kw_end_DASH_line, int(5158), kw_end_DASH_column, int(17)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp15 := lang.Apply(tmp14, []any{v3}) + if lang.IsTruthy(tmp15) { + var tmp16 any + { // let + // let binding "temp__0__auto__" + tmp17, _ := lang.FieldOrMethod(v2, "seqFrom") + if reflect.TypeOf(tmp17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("seqFrom is not a function"))) + } + tmp18 := lang.Apply(tmp17, []any{v4, false}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + var tmp21 any + { // let + // let binding "vec__765" + var v22 any = v19 + _ = v22 + // let binding "e" + tmp23 := checkDerefVar(var_glojure_DOT_core_nth) + tmp24 := lang.Apply(tmp23, []any{v22, int64(0), nil}) + var v25 any = tmp24 + _ = v25 + // let binding "s" + var v26 any = v22 + _ = v26 + var tmp27 any + tmp28 := lang.Apply(v8, []any{v25}) + if lang.IsTruthy(tmp28) { + tmp27 = v26 + } else { + tmp29 := checkDerefVar(var_glojure_DOT_core_next) + tmp30 := lang.Apply(tmp29, []any{v26}) + tmp27 = tmp30 + } + tmp21 = tmp27 + } // end let + tmp20 = tmp21 + } else { + } + tmp16 = tmp20 + } // end let + tmp9 = tmp16 + } else { + tmp17 := checkDerefVar(var_glojure_DOT_core_take_DASH_while) + tmp18, _ := lang.FieldOrMethod(v2, "seq") + if reflect.TypeOf(tmp18).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("seq is not a function"))) + } + tmp19 := lang.Apply(tmp18, []any{false}) + tmp20 := lang.Apply(tmp17, []any{v8, tmp19}) + tmp9 = tmp20 + } + tmp5 = tmp9 + } // end let + return tmp5 + case 5: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + var tmp7 any + { // let + // let binding "temp__0__auto__" + tmp8, _ := lang.FieldOrMethod(v2, "seqFrom") + if reflect.TypeOf(tmp8).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("seqFrom is not a function"))) + } + tmp9 := lang.Apply(tmp8, []any{v6, false}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + if lang.IsTruthy(v10) { + var tmp12 any + { // let + // let binding "vec__768" + var v13 any = v10 + _ = v13 + // let binding "e" + tmp14 := checkDerefVar(var_glojure_DOT_core_nth) + tmp15 := lang.Apply(tmp14, []any{v13, int64(0), nil}) + var v16 any = tmp15 + _ = v16 + // let binding "s" + var v17 any = v13 + _ = v17 + tmp18 := checkDerefVar(var_glojure_DOT_core_take_DASH_while) + tmp19 := checkDerefVar(var_glojure_DOT_core_mk_DASH_bound_DASH_fn) + tmp20 := lang.Apply(tmp19, []any{v2, v3, v4}) + var tmp21 any + tmp22 := checkDerefVar(var_glojure_DOT_core_mk_DASH_bound_DASH_fn) + tmp23 := lang.Apply(tmp22, []any{v2, v5, v6}) + tmp24 := lang.Apply(tmp23, []any{v16}) + if lang.IsTruthy(tmp24) { + tmp21 = v17 + } else { + tmp25 := checkDerefVar(var_glojure_DOT_core_next) + tmp26 := lang.Apply(tmp25, []any{v17}) + tmp21 = tmp26 + } + tmp27 := lang.Apply(tmp18, []any{tmp20, tmp21}) + tmp12 = tmp27 + } // end let + tmp11 = tmp12 + } else { + } + tmp7 = tmp11 + } // end let + return tmp7 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_rsubseq = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_rsubseq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // send-via + { + tmp0 := sym_send_DASH_via.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_executor, sym_a, sym_f, sym__AMP_, sym_args)), kw_doc, "Dispatch an action to an agent. Returns the agent immediately.\n Subsequently, in a thread supplied by executor, the state of the agent\n will be set to the value of:\n\n (apply action-fn state-of-agent args)", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(2099), kw_end_DASH_line, int(2099))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + tmp7 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp8 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp9 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_agent_STAR_) + tmp10 := lang.Apply(tmp8, []any{tmp9, v3}) + tmp11 := lang.Apply(tmp7, []any{tmp10}) + _ = tmp11 + var tmp12 any + func() { + defer func() { + tmp13 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp14 := lang.Apply(tmp13, nil) + _ = tmp14 + }() + tmp15 := checkDerefVar(var_glojure_DOT_core_binding_DASH_conveyor_DASH_fn) + tmp16 := lang.Apply(tmp15, []any{v4}) + tmp12 = tmp16 + }() + tmp6 = tmp12 + } // end let + tmp7, _ := lang.FieldOrMethod(v3, "dispatch") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("dispatch is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{tmp6, v5, v2}) + return tmp8 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_send_DASH_via = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_send_DASH_via.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // sequence + { + tmp0 := sym_sequence.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll), lang.NewVector(sym_xform, sym_coll), lang.NewVector(sym_xform, sym_coll, sym__AMP_, sym_colls)), kw_doc, "Coerces coll to a (possibly empty) sequence, if it is not already\n one. Will not force a lazy seq. (sequence nil) yields (), When a\n transducer is supplied, returns a lazy sequence of applications of\n the transform to the items in coll(s), i.e. to the set of first\n items of each coll, followed by the set of second\n items in each coll, until any one of the colls is exhausted. Any\n remaining items in other colls are ignored. The transform should accept\n number-of-colls arguments", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(2639), kw_end_DASH_line, int(2639))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + tmp3 = v2 + } else { + var tmp6 any + { // let + // let binding "or__0__auto__" + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := lang.Apply(tmp7, []any{v2}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + tmp10 = v9 + } else { + tmp10 = lang.NewList() + } + tmp6 = tmp10 + } // end let + tmp3 = tmp6 + } + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "or__0__auto__" + tmp5 := lang.Apply(nil, []any{v3}) + tmp6 := lang.Apply(nil, []any{v2, tmp5}) + tmp7 := lang.Apply(nil, []any{tmp6}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + tmp9 = v8 + } else { + tmp9 = lang.NewList() + } + tmp4 = tmp9 + } // end let + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "or__0__auto__" + tmp6 := checkDerefVar(var_glojure_DOT_core_map) + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v8 := args[0] + _ = v8 + tmp9 := lang.Apply(nil, []any{v8}) + return tmp9 + }) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2661), kw_column, int(17), kw_end_DASH_line, int(2661), kw_end_DASH_column, int(41)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp10 := checkDerefVar(var_glojure_DOT_core_cons) + tmp11 := lang.Apply(tmp10, []any{v3, v4}) + tmp12 := lang.Apply(tmp6, []any{tmp9, tmp11}) + tmp13 := lang.Apply(nil, []any{v2, tmp12}) + tmp14 := lang.Apply(nil, []any{tmp13}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + if lang.IsTruthy(v15) { + tmp16 = v15 + } else { + tmp16 = lang.NewList() + } + tmp5 = tmp16 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_sequence = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_sequence.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // setup-reference + { + tmp0 := sym_setup_DASH_reference.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(2043), kw_column, int(7), kw_end_DASH_line, int(2044), kw_end_DASH_column, int(17), kw_arglists, lang.NewList(lang.NewVector(sym_r, sym_options)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "opts" + tmp5 := checkDerefVar(var_glojure_DOT_core_apply) + tmp6 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp7 := lang.Apply(tmp5, []any{tmp6, v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + tmp10 := lang.Apply(kw_meta, []any{v8}) + if lang.IsTruthy(tmp10) { + tmp11 := lang.Apply(kw_meta, []any{v8}) + tmp12, _ := lang.FieldOrMethod(v2, "ResetMeta") + if reflect.TypeOf(tmp12).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ResetMeta is not a function"))) + } + tmp13 := lang.Apply(tmp12, []any{tmp11}) + tmp9 = tmp13 + } else { + } + _ = tmp9 + var tmp14 any + tmp15 := lang.Apply(kw_validator, []any{v8}) + if lang.IsTruthy(tmp15) { + tmp16 := lang.Apply(kw_validator, []any{v8}) + tmp17, _ := lang.FieldOrMethod(v2, "setValidator") + if reflect.TypeOf(tmp17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setValidator is not a function"))) + } + tmp18 := lang.Apply(tmp17, []any{tmp16}) + tmp14 = tmp18 + } else { + } + _ = tmp14 + tmp4 = v2 + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_setup_DASH_reference = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_setup_DASH_reference.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // shift-mask + { + tmp0 := sym_shift_DASH_mask.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6598), kw_column, int(8), kw_end_DASH_line, int(6598), kw_end_DASH_column, int(17), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_shift, sym_mask, sym_x)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_bit_DASH_and) + tmp6 := checkDerefVar(var_glojure_DOT_core_bit_DASH_shift_DASH_right) + tmp7 := lang.Apply(tmp6, []any{v4, v2}) + tmp8 := lang.Apply(tmp5, []any{tmp7, v3}) + return tmp8 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_shift_DASH_mask = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_shift_DASH_mask.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // sort + { + tmp0 := sym_sort.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll), lang.NewVector(sym_comp, sym_coll)), kw_doc, "Returns a sorted sequence of the items in coll. If no comparator is\n supplied, uses compare. comparator must implement\n java.util.Comparator. Guaranteed to be stable: equal elements will\n not be reordered. If coll is a Java array, it will be modified. To\n avoid this, sort a copy of the array.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3085), kw_end_DASH_line, int(3085))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_sort) + tmp4 := checkDerefVar(var_glojure_DOT_core_compare) + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := lang.Apply(tmp5, []any{v3}) + if lang.IsTruthy(tmp6) { + var tmp7 any + { // let + // let binding "a" + tmp8 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) + tmp9 := lang.Apply(tmp8, []any{v3}) + var v10 any = tmp9 + _ = v10 + tmp11 := lang.Apply(lang.SortSlice, []any{v10, v2}) + _ = tmp11 + tmp12 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := lang.Apply(tmp13, []any{v10}) + tmp15 := checkDerefVar(var_glojure_DOT_core_meta) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) + tmp7 = tmp17 + } // end let + tmp4 = tmp7 + } else { + tmp4 = lang.NewList() + } + return tmp4 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_sort = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_sort.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // sort-by + { + tmp0 := sym_sort_DASH_by.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_keyfn, sym_coll), lang.NewVector(sym_keyfn, sym_comp, sym_coll)), kw_doc, "Returns a sorted sequence of the items in coll, where the sort\n order is determined by comparing (keyfn item). If no comparator is\n supplied, uses compare. comparator must implement\n java.util.Comparator. Guaranteed to be stable: equal elements will\n not be reordered. If coll is a Java array, it will be modified. To\n avoid this, sort a copy of the array.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(3102), kw_end_DASH_line, int(3102))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_sort_DASH_by) + tmp5 := checkDerefVar(var_glojure_DOT_core_compare) + tmp6 := lang.Apply(tmp4, []any{v2, tmp5, v3}) + return tmp6 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_sort) + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + tmp9 := lang.Apply(v2, []any{v7}) + tmp10 := lang.Apply(v2, []any{v8}) + tmp11 := lang.Apply(v3, []any{tmp9, tmp10}) + return tmp11 + }) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3114), kw_column, int(10), kw_end_DASH_line, int(3114), kw_end_DASH_column, int(46)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp9 := lang.Apply(tmp5, []any{tmp8, v4}) + return tmp9 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_sort_DASH_by = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_sort_DASH_by.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // spit + { + tmp0 := sym_spit.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_content, sym__AMP_, sym_options)), kw_doc, "Opposite of slurp. Opens f with writer, writes content, then\n closes f. Options passed to glojure.java.io/writer.", kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(6994), kw_end_DASH_line, int(6994))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "w" + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := lang.Apply(tmp6, []any{nil, v2, v4}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + func() { + defer func() { + tmp10, ok := lang.FieldOrMethod(v8, "close") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "close"))) + } + var tmp11 any + switch reflect.TypeOf(tmp10).Kind() { + case reflect.Func: + tmp11 = lang.Apply(tmp10, nil) + default: + tmp11 = tmp10 + } + _ = tmp11 + }() + tmp12 := checkDerefVar(var_glojure_DOT_core_str) + tmp13 := lang.Apply(tmp12, []any{v3}) + tmp14 := lang.Apply(lang.WriteWriter, []any{v8, tmp13}) + tmp9 = tmp14 + }() + tmp5 = tmp9 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_spit = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_spit.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // strip-ns + { + tmp0 := sym_strip_DASH_ns.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(255), kw_column, int(8), kw_end_DASH_line, int(255), kw_end_DASH_column, int(15), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_named)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + tmp6 := checkDerefVar(var_glojure_DOT_core_symbol) + tmp7 := checkDerefVar(var_glojure_DOT_core_name) + tmp8 := lang.Apply(tmp7, []any{v2}) + tmp9 := lang.Apply(tmp6, []any{nil, tmp8}) + tmp3 = tmp9 + } else { + tmp10 := checkDerefVar(var_glojure_DOT_core_keyword) + tmp11 := checkDerefVar(var_glojure_DOT_core_name) + tmp12 := lang.Apply(tmp11, []any{v2}) + tmp13 := lang.Apply(tmp10, []any{nil, tmp12}) + tmp3 = tmp13 + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_strip_DASH_ns = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_strip_DASH_ns.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // subseq + { + tmp0 := sym_subseq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_sc, sym_test, sym_key), lang.NewVector(sym_sc, sym_start_DASH_test, sym_start_DASH_key, sym_end_DASH_test, sym_end_DASH_key)), kw_doc, "sc must be a sorted collection, test(s) one of <, <=, > or\n >=. Returns a seq of those entries with keys ek for\n which (test (.. sc comparator (compare ek key)) 0) is true", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(5133), kw_end_DASH_line, int(5133))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + { // let + // let binding "include" + tmp6 := checkDerefVar(var_glojure_DOT_core_mk_DASH_bound_DASH_fn) + tmp7 := lang.Apply(tmp6, []any{v2, v3, v4}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core__GT_) + tmp11 := checkDerefVar(var_glojure_DOT_core__GT__EQ_) + tmp12 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{tmp10, tmp11})) + tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5141), kw_column, int(11), kw_end_DASH_line, int(5141), kw_end_DASH_column, int(17)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp15 := lang.Apply(tmp14, []any{v3}) + if lang.IsTruthy(tmp15) { + var tmp16 any + { // let + // let binding "temp__0__auto__" + tmp17, _ := lang.FieldOrMethod(v2, "seqFrom") + if reflect.TypeOf(tmp17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("seqFrom is not a function"))) + } + tmp18 := lang.Apply(tmp17, []any{v4, true}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + var tmp21 any + { // let + // let binding "vec__759" + var v22 any = v19 + _ = v22 + // let binding "e" + tmp23 := checkDerefVar(var_glojure_DOT_core_nth) + tmp24 := lang.Apply(tmp23, []any{v22, int64(0), nil}) + var v25 any = tmp24 + _ = v25 + // let binding "s" + var v26 any = v22 + _ = v26 + var tmp27 any + tmp28 := lang.Apply(v8, []any{v25}) + if lang.IsTruthy(tmp28) { + tmp27 = v26 + } else { + tmp29 := checkDerefVar(var_glojure_DOT_core_next) + tmp30 := lang.Apply(tmp29, []any{v26}) + tmp27 = tmp30 + } + tmp21 = tmp27 + } // end let + tmp20 = tmp21 + } else { + } + tmp16 = tmp20 + } // end let + tmp9 = tmp16 + } else { + tmp17 := checkDerefVar(var_glojure_DOT_core_take_DASH_while) + tmp18, _ := lang.FieldOrMethod(v2, "seq") + if reflect.TypeOf(tmp18).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("seq is not a function"))) + } + tmp19 := lang.Apply(tmp18, []any{true}) + tmp20 := lang.Apply(tmp17, []any{v8, tmp19}) + tmp9 = tmp20 + } + tmp5 = tmp9 + } // end let + return tmp5 + case 5: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + var tmp7 any + { // let + // let binding "temp__0__auto__" + tmp8, _ := lang.FieldOrMethod(v2, "seqFrom") + if reflect.TypeOf(tmp8).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("seqFrom is not a function"))) + } + tmp9 := lang.Apply(tmp8, []any{v4, true}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + if lang.IsTruthy(v10) { + var tmp12 any + { // let + // let binding "vec__762" + var v13 any = v10 + _ = v13 + // let binding "e" + tmp14 := checkDerefVar(var_glojure_DOT_core_nth) + tmp15 := lang.Apply(tmp14, []any{v13, int64(0), nil}) + var v16 any = tmp15 + _ = v16 + // let binding "s" + var v17 any = v13 + _ = v17 + tmp18 := checkDerefVar(var_glojure_DOT_core_take_DASH_while) + tmp19 := checkDerefVar(var_glojure_DOT_core_mk_DASH_bound_DASH_fn) + tmp20 := lang.Apply(tmp19, []any{v2, v5, v6}) + var tmp21 any + tmp22 := checkDerefVar(var_glojure_DOT_core_mk_DASH_bound_DASH_fn) + tmp23 := lang.Apply(tmp22, []any{v2, v3, v4}) + tmp24 := lang.Apply(tmp23, []any{v16}) + if lang.IsTruthy(tmp24) { + tmp21 = v17 + } else { + tmp25 := checkDerefVar(var_glojure_DOT_core_next) + tmp26 := lang.Apply(tmp25, []any{v17}) + tmp21 = tmp26 + } + tmp27 := lang.Apply(tmp18, []any{tmp20, tmp21}) + tmp12 = tmp27 + } // end let + tmp11 = tmp12 + } else { + } + tmp7 = tmp11 + } // end let + return tmp7 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_subseq = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_subseq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // supers + { + tmp0 := sym_supers.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_class)), kw_doc, "Returns the immediate and indirect superclasses and interfaces of c, if any", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(5532), kw_end_DASH_line, int(5532))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "ret" + tmp4 := checkDerefVar(var_glojure_DOT_core_set) + tmp5 := checkDerefVar(var_glojure_DOT_core_bases) + tmp6 := lang.Apply(tmp5, []any{v2}) + tmp7 := lang.Apply(tmp4, []any{tmp6}) + var v8 any = tmp7 + _ = v8 + // let binding "cs" + var v9 any = v8 + _ = v9 + for { + var tmp10 any + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := lang.Apply(tmp11, []any{v9}) + if lang.IsTruthy(tmp12) { + var tmp13 any + { // let + // let binding "c" + tmp14 := checkDerefVar(var_glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v9}) + var v16 any = tmp15 + _ = v16 + // let binding "bs" + tmp17 := checkDerefVar(var_glojure_DOT_core_bases) + tmp18 := lang.Apply(tmp17, []any{v16}) + var v19 any = tmp18 + _ = v19 + tmp21 := checkDerefVar(var_glojure_DOT_core_into1) + tmp22 := lang.Apply(tmp21, []any{v8, v19}) + var tmp20 any = tmp22 + tmp24 := checkDerefVar(var_glojure_DOT_core_into1) + tmp25 := checkDerefVar(var_glojure_DOT_core_disj) + tmp26 := lang.Apply(tmp25, []any{v9, v16}) + tmp27 := lang.Apply(tmp24, []any{tmp26, v19}) + var tmp23 any = tmp27 + v8 = tmp20 + v9 = tmp23 + continue + } // end let + tmp10 = tmp13 + } else { + tmp14 := checkDerefVar(var_glojure_DOT_core_not_DASH_empty) + tmp15 := lang.Apply(tmp14, []any{v8}) + tmp10 = tmp15 + } + tmp3 = tmp10 + break + } + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_supers = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_supers.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // sync + { + tmp0 := sym_sync.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_flags_DASH_ignored_DASH_for_DASH_now, sym__AMP_, sym_body)), kw_doc, "transaction-flags => TBD, pass nil for now\n\n Runs the exprs (in an implicit do) in a transaction that encompasses\n exprs and any nested calls. Starts a transaction if none is already\n running on this thread. Any uncaught exception will abort the\n transaction and flow out of sync. The exprs may be run more than\n once, but any effects on Refs will be atomic.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(11), kw_line, int(2490), kw_end_DASH_line, int(2490))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym__DOT_}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_LockingTransaction}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_RunInTransaction}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{sym_glojure_DOT_core_SLASH_fn}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := checkDerefVar(var_glojure_DOT_core_apply) + tmp24 := checkDerefVar(var_glojure_DOT_core_vector) + tmp25 := checkDerefVar(var_glojure_DOT_core_seq) + tmp26 := checkDerefVar(var_glojure_DOT_core_concat) + tmp27 := lang.Apply(tmp26, nil) + tmp28 := lang.Apply(tmp25, []any{tmp27}) + tmp29 := lang.Apply(tmp23, []any{tmp24, tmp28}) + tmp30 := lang.Apply(tmp22, []any{tmp29}) + tmp31 := lang.Apply(tmp19, []any{tmp21, tmp30, v5}) + tmp32 := lang.Apply(tmp18, []any{tmp31}) + tmp33 := lang.Apply(tmp17, []any{tmp32}) + tmp34 := lang.Apply(tmp14, []any{tmp16, tmp33}) + tmp35 := lang.Apply(tmp13, []any{tmp34}) + tmp36 := lang.Apply(tmp12, []any{tmp35}) + tmp37 := lang.Apply(tmp7, []any{tmp9, tmp11, tmp36}) + tmp38 := lang.Apply(tmp6, []any{tmp37}) + return tmp38 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_sync = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_sync.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // take + { + tmp0 := sym_take.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n), lang.NewVector(sym_n, sym_coll)), kw_doc, "Returns a lazy sequence of the first n items in coll, or all items if\n there are fewer than n. Returns a stateful transducer when\n no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(2853), kw_end_DASH_line, int(2853))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 any + { // let + // let binding "nv" + tmp6 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) + tmp7 := lang.Apply(tmp6, []any{v2}) + var v8 any = tmp7 + _ = v8 + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp10 := lang.Apply(v4, nil) + return tmp10 + case 1: + v10 := args[0] + _ = v10 + tmp11 := lang.Apply(v4, []any{v10}) + return tmp11 + case 2: + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + var tmp12 any + { // let + // let binding "n" + tmp13 := checkDerefVar(var_glojure_DOT_core_deref) + tmp14 := lang.Apply(tmp13, []any{v8}) + var v15 any = tmp14 + _ = v15 + // let binding "nn" + tmp16 := checkDerefVar(var_glojure_DOT_core_dec) + tmp17, ok := lang.FieldOrMethod(v8, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "Deref"))) + } + var tmp18 any + switch reflect.TypeOf(tmp17).Kind() { + case reflect.Func: + tmp18 = lang.Apply(tmp17, nil) + default: + tmp18 = tmp17 + } + tmp19 := lang.Apply(tmp16, []any{tmp18}) + tmp20, _ := lang.FieldOrMethod(v8, "reset") + if reflect.TypeOf(tmp20).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) + } + tmp21 := lang.Apply(tmp20, []any{tmp19}) + var v22 any = tmp21 + _ = v22 + // let binding "result" + var tmp23 any + tmp24 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp25 := lang.Apply(tmp24, []any{v15}) + if lang.IsTruthy(tmp25) { + tmp26 := lang.Apply(v4, []any{v10, v11}) + tmp23 = tmp26 + } else { + tmp23 = v10 + } + var v27 any = tmp23 + _ = v27 + var tmp28 any + tmp29 := checkDerefVar(var_glojure_DOT_core_not) + tmp30 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp31 := lang.Apply(tmp30, []any{v22}) + tmp32 := lang.Apply(tmp29, []any{tmp31}) + if lang.IsTruthy(tmp32) { + tmp33 := checkDerefVar(var_glojure_DOT_core_ensure_DASH_reduced) + tmp34 := lang.Apply(tmp33, []any{v27}) + tmp28 = tmp34 + } else { + tmp28 = v27 + } + tmp12 = tmp28 + } // end let + return tmp12 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2862), kw_column, int(10), kw_end_DASH_line, int(2873), kw_end_DASH_column, int(28)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp5 = tmp11 + } // end let + return tmp5 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2860), kw_column, int(6), kw_end_DASH_line, int(2873), kw_end_DASH_column, int(30)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp7 := lang.Apply(tmp6, []any{v2}) + if lang.IsTruthy(tmp7) { + var tmp8 any + { // let + // let binding "temp__0__auto__" + tmp9 := checkDerefVar(var_glojure_DOT_core_seq) + tmp10 := lang.Apply(tmp9, []any{v3}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + var tmp13 any + { // let + // let binding "s" + var v14 any = v11 + _ = v14 + tmp15 := checkDerefVar(var_glojure_DOT_core_cons) + tmp16 := checkDerefVar(var_glojure_DOT_core_first) + tmp17 := lang.Apply(tmp16, []any{v14}) + tmp18 := checkDerefVar(var_glojure_DOT_core_take) + tmp19 := checkDerefVar(var_glojure_DOT_core_dec) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(var_glojure_DOT_core_rest) + tmp22 := lang.Apply(tmp21, []any{v14}) + tmp23 := lang.Apply(tmp18, []any{tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp17, tmp23}) + tmp13 = tmp24 + } // end let + tmp12 = tmp13 + } else { + } + tmp8 = tmp12 + } // end let + tmp5 = tmp8 + } else { + } + return tmp5 + }) + tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_take = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_take.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // take-last + { + tmp0 := sym_take_DASH_last.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n, sym_coll)), kw_doc, "Returns a seq of the last n items in coll. Depending on the type\n of coll may be no better than linear time. For vectors, see also subvec.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(2939), kw_end_DASH_line, int(2939))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "s" + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := lang.Apply(tmp5, []any{v3}) + var v7 any = tmp6 + _ = v7 + // let binding "lead" + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_drop) + tmp10 := lang.Apply(tmp9, []any{v2, v3}) + tmp11 := lang.Apply(tmp8, []any{tmp10}) + var v12 any = tmp11 + _ = v12 + for { + var tmp13 any + if lang.IsTruthy(v12) { + tmp15 := checkDerefVar(var_glojure_DOT_core_next) + tmp16 := lang.Apply(tmp15, []any{v7}) + var tmp14 any = tmp16 + tmp18 := checkDerefVar(var_glojure_DOT_core_next) + tmp19 := lang.Apply(tmp18, []any{v12}) + var tmp17 any = tmp19 + v7 = tmp14 + v12 = tmp17 + continue + } else { + tmp13 = v7 + } + tmp4 = tmp13 + break + } + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_take_DASH_last = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_take_DASH_last.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // take-nth + { + tmp0 := sym_take_DASH_nth.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n), lang.NewVector(sym_n, sym_coll)), kw_doc, "Returns a lazy seq of every nth item in coll. Returns a stateful\n transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(4287), kw_end_DASH_line, int(4287))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 any + { // let + // let binding "iv" + tmp6 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) + tmp7 := lang.Apply(tmp6, []any{int64(-1)}) + var v8 any = tmp7 + _ = v8 + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp10 := lang.Apply(v4, nil) + return tmp10 + case 1: + v10 := args[0] + _ = v10 + tmp11 := lang.Apply(v4, []any{v10}) + return tmp11 + case 2: + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + var tmp12 any + { // let + // let binding "i" + tmp13 := checkDerefVar(var_glojure_DOT_core_inc) + tmp14, ok := lang.FieldOrMethod(v8, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "Deref"))) + } + var tmp15 any + switch reflect.TypeOf(tmp14).Kind() { + case reflect.Func: + tmp15 = lang.Apply(tmp14, nil) + default: + tmp15 = tmp14 + } + tmp16 := lang.Apply(tmp13, []any{tmp15}) + tmp17, _ := lang.FieldOrMethod(v8, "reset") + if reflect.TypeOf(tmp17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) + } + tmp18 := lang.Apply(tmp17, []any{tmp16}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + tmp21 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) + tmp22 := checkDerefVar(var_glojure_DOT_core_rem) + tmp23 := lang.Apply(tmp22, []any{v19, v2}) + tmp24 := lang.Apply(tmp21, []any{tmp23}) + if lang.IsTruthy(tmp24) { + tmp25 := lang.Apply(v4, []any{v10, v11}) + tmp20 = tmp25 + } else { + tmp20 = v10 + } + tmp12 = tmp20 + } // end let + return tmp12 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4295), kw_column, int(10), kw_end_DASH_line, int(4302), kw_end_DASH_column, int(28)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp5 = tmp11 + } // end let + return tmp5 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4293), kw_column, int(6), kw_end_DASH_line, int(4302), kw_end_DASH_column, int(30)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp5 any + { // let + // let binding "temp__0__auto__" + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := lang.Apply(tmp6, []any{v3}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + var tmp10 any + { // let + // let binding "s" + var v11 any = v8 + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_cons) + tmp13 := checkDerefVar(var_glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v11}) + tmp15 := checkDerefVar(var_glojure_DOT_core_take_DASH_nth) + tmp16 := checkDerefVar(var_glojure_DOT_core_drop) + tmp17 := lang.Apply(tmp16, []any{v2, v11}) + tmp18 := lang.Apply(tmp15, []any{v2, tmp17}) + tmp19 := lang.Apply(tmp12, []any{tmp14, tmp18}) + tmp10 = tmp19 + } // end let + tmp9 = tmp10 + } else { + } + tmp5 = tmp9 + } // end let + return tmp5 + }) + tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_take_DASH_nth = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_take_DASH_nth.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // throw-if + { + tmp0 := sym_throw_DASH_if.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred, sym_fmt, sym__AMP_, sym_args)), kw_doc, "Throws a CompilerException with a message if pred is true", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(8), kw_line, int(5832), kw_end_DASH_line, int(5832), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + if lang.IsTruthy(v2) { + var tmp6 any + { // let + // let binding "message" + tmp7 := checkDerefVar(var_glojure_DOT_core_apply) + tmp8 := checkDerefVar(var_glojure_DOT_core_format) + tmp9 := lang.Apply(tmp7, []any{tmp8, v3, v4}) + var v10 any = tmp9 + _ = v10 + // let binding "exception" + tmp11 := lang.Apply(lang.NewError, []any{v10}) + var v12 any = tmp11 + _ = v12 + // let binding "raw-trace" + tmp13, ok := lang.FieldOrMethod(v12, "getStackTrace") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v12, "getStackTrace"))) + } + var tmp14 any + switch reflect.TypeOf(tmp13).Kind() { + case reflect.Func: + tmp14 = lang.Apply(tmp13, nil) + default: + tmp14 = tmp13 + } + var v15 any = tmp14 + _ = v15 + // let binding "boring?" + var tmp16 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v17 := args[0] + _ = v17 + tmp18 := checkDerefVar(var_glojure_DOT_core_not_EQ_) + tmp19, ok := lang.FieldOrMethod(v17, "getMethodName") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v17, "getMethodName"))) + } + var tmp20 any + switch reflect.TypeOf(tmp19).Kind() { + case reflect.Func: + tmp20 = lang.Apply(tmp19, nil) + default: + tmp20 = tmp19 + } + tmp21 := lang.Apply(tmp18, []any{tmp20, "doInvoke"}) + return tmp21 + }) + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5839), kw_column, int(19), kw_end_DASH_line, int(5839), kw_end_DASH_column, int(74)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v19 any = tmp18 + _ = v19 + // let binding "trace" + tmp20 := checkDerefVar(var_glojure_DOT_core_into_DASH_array) + tmp21 := checkDerefVar(var_glojure_DOT_core_drop) + tmp22 := checkDerefVar(var_glojure_DOT_core_drop_DASH_while) + tmp23 := lang.Apply(tmp22, []any{v19, v15}) + tmp24 := lang.Apply(tmp21, []any{int64(2), tmp23}) + tmp25 := lang.Apply(tmp20, []any{nil, tmp24}) + var v26 any = tmp25 + _ = v26 + tmp27, _ := lang.FieldOrMethod(v12, "setStackTrace") + if reflect.TypeOf(tmp27).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setStackTrace is not a function"))) + } + tmp28 := lang.Apply(tmp27, []any{v26}) + _ = tmp28 + tmp29 := checkDerefVar(var_glojure_DOT_core__STAR_file_STAR_) + tmp30, ok := lang.FieldOrMethod(nil, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "Deref"))) + } + var tmp31 any + switch reflect.TypeOf(tmp30).Kind() { + case reflect.Func: + tmp31 = lang.Apply(tmp30, nil) + default: + tmp31 = tmp30 + } + tmp32, ok := lang.FieldOrMethod(nil, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "Deref"))) + } + var tmp33 any + switch reflect.TypeOf(tmp32).Kind() { + case reflect.Func: + tmp33 = lang.Apply(tmp32, nil) + default: + tmp33 = tmp32 + } + tmp34 := lang.Apply(lang.NewCompilerError, []any{tmp29, tmp31, tmp33, v12}) + panic(tmp34) + } // end let + tmp5 = tmp6 + } else { + } + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_throw_DASH_if = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_throw_DASH_if.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // time + { + tmp0 := sym_time.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_expr)), kw_doc, "Evaluates expr and prints the time it took. Returns the value of\n expr.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(11), kw_line, int(3885), kw_end_DASH_line, int(3885))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym_glojure_DOT_core_SLASH_let}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := checkDerefVar(var_glojure_DOT_core_apply) + tmp11 := checkDerefVar(var_glojure_DOT_core_vector) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_start__0__auto__}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := checkDerefVar(var_glojure_DOT_core_seq) + tmp18 := checkDerefVar(var_glojure_DOT_core_concat) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{sym__DOT_UnixNano}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := checkDerefVar(var_glojure_DOT_core_seq) + tmp23 := checkDerefVar(var_glojure_DOT_core_concat) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{sym_time_DOT_Now}) + tmp26 := lang.Apply(tmp23, []any{tmp25}) + tmp27 := lang.Apply(tmp22, []any{tmp26}) + tmp28 := lang.Apply(tmp21, []any{tmp27}) + tmp29 := lang.Apply(tmp18, []any{tmp20, tmp28}) + tmp30 := lang.Apply(tmp17, []any{tmp29}) + tmp31 := lang.Apply(tmp16, []any{tmp30}) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := lang.Apply(tmp32, []any{sym_ret__1__auto__}) + tmp34 := checkDerefVar(var_glojure_DOT_core_list) + tmp35 := lang.Apply(tmp34, []any{v4}) + tmp36 := lang.Apply(tmp13, []any{tmp15, tmp31, tmp33, tmp35}) + tmp37 := lang.Apply(tmp12, []any{tmp36}) + tmp38 := lang.Apply(tmp10, []any{tmp11, tmp37}) + tmp39 := lang.Apply(tmp9, []any{tmp38}) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := checkDerefVar(var_glojure_DOT_core_seq) + tmp42 := checkDerefVar(var_glojure_DOT_core_concat) + tmp43 := checkDerefVar(var_glojure_DOT_core_list) + tmp44 := lang.Apply(tmp43, []any{sym_glojure_DOT_core_SLASH_prn}) + tmp45 := checkDerefVar(var_glojure_DOT_core_list) + tmp46 := checkDerefVar(var_glojure_DOT_core_seq) + tmp47 := checkDerefVar(var_glojure_DOT_core_concat) + tmp48 := checkDerefVar(var_glojure_DOT_core_list) + tmp49 := lang.Apply(tmp48, []any{sym_glojure_DOT_core_SLASH_str}) + tmp50 := checkDerefVar(var_glojure_DOT_core_list) + tmp51 := lang.Apply(tmp50, []any{"Elapsed time: "}) + tmp52 := checkDerefVar(var_glojure_DOT_core_list) + tmp53 := checkDerefVar(var_glojure_DOT_core_seq) + tmp54 := checkDerefVar(var_glojure_DOT_core_concat) + tmp55 := checkDerefVar(var_glojure_DOT_core_list) + tmp56 := lang.Apply(tmp55, []any{sym_glojure_DOT_core_SLASH__SLASH_}) + tmp57 := checkDerefVar(var_glojure_DOT_core_list) + tmp58 := checkDerefVar(var_glojure_DOT_core_seq) + tmp59 := checkDerefVar(var_glojure_DOT_core_concat) + tmp60 := checkDerefVar(var_glojure_DOT_core_list) + tmp61 := lang.Apply(tmp60, []any{sym_glojure_DOT_core_SLASH_double}) + tmp62 := checkDerefVar(var_glojure_DOT_core_list) + tmp63 := checkDerefVar(var_glojure_DOT_core_seq) + tmp64 := checkDerefVar(var_glojure_DOT_core_concat) + tmp65 := checkDerefVar(var_glojure_DOT_core_list) + tmp66 := lang.Apply(tmp65, []any{sym_glojure_DOT_core_SLASH__DASH_}) + tmp67 := checkDerefVar(var_glojure_DOT_core_list) + tmp68 := checkDerefVar(var_glojure_DOT_core_seq) + tmp69 := checkDerefVar(var_glojure_DOT_core_concat) + tmp70 := checkDerefVar(var_glojure_DOT_core_list) + tmp71 := lang.Apply(tmp70, []any{sym__DOT_UnixNano}) + tmp72 := checkDerefVar(var_glojure_DOT_core_list) + tmp73 := checkDerefVar(var_glojure_DOT_core_seq) + tmp74 := checkDerefVar(var_glojure_DOT_core_concat) + tmp75 := checkDerefVar(var_glojure_DOT_core_list) + tmp76 := lang.Apply(tmp75, []any{sym_time_DOT_Now}) + tmp77 := lang.Apply(tmp74, []any{tmp76}) + tmp78 := lang.Apply(tmp73, []any{tmp77}) + tmp79 := lang.Apply(tmp72, []any{tmp78}) + tmp80 := lang.Apply(tmp69, []any{tmp71, tmp79}) + tmp81 := lang.Apply(tmp68, []any{tmp80}) + tmp82 := lang.Apply(tmp67, []any{tmp81}) + tmp83 := checkDerefVar(var_glojure_DOT_core_list) + tmp84 := lang.Apply(tmp83, []any{sym_start__0__auto__}) + tmp85 := lang.Apply(tmp64, []any{tmp66, tmp82, tmp84}) + tmp86 := lang.Apply(tmp63, []any{tmp85}) + tmp87 := lang.Apply(tmp62, []any{tmp86}) + tmp88 := lang.Apply(tmp59, []any{tmp61, tmp87}) + tmp89 := lang.Apply(tmp58, []any{tmp88}) + tmp90 := lang.Apply(tmp57, []any{tmp89}) + tmp91 := checkDerefVar(var_glojure_DOT_core_list) + tmp92 := lang.Apply(tmp91, []any{float64(1e+06)}) + tmp93 := lang.Apply(tmp54, []any{tmp56, tmp90, tmp92}) + tmp94 := lang.Apply(tmp53, []any{tmp93}) + tmp95 := lang.Apply(tmp52, []any{tmp94}) + tmp96 := checkDerefVar(var_glojure_DOT_core_list) + tmp97 := lang.Apply(tmp96, []any{" msecs"}) + tmp98 := lang.Apply(tmp47, []any{tmp49, tmp51, tmp95, tmp97}) + tmp99 := lang.Apply(tmp46, []any{tmp98}) + tmp100 := lang.Apply(tmp45, []any{tmp99}) + tmp101 := lang.Apply(tmp42, []any{tmp44, tmp100}) + tmp102 := lang.Apply(tmp41, []any{tmp101}) + tmp103 := lang.Apply(tmp40, []any{tmp102}) + tmp104 := checkDerefVar(var_glojure_DOT_core_list) + tmp105 := lang.Apply(tmp104, []any{sym_ret__1__auto__}) + tmp106 := lang.Apply(tmp6, []any{tmp8, tmp39, tmp103, tmp105}) + tmp107 := lang.Apply(tmp5, []any{tmp106}) + return tmp107 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_time = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_time.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // trampoline + { + tmp0 := sym_trampoline.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym__AMP_, sym_args)), kw_doc, "trampoline can be used to convert algorithms requiring mutual\n recursion without stack consumption. Calls f with supplied args, if\n any. If f returns a fn, calls that fn with no arguments, and\n continues to repeat, until the return value is not a fn, then\n returns that non-fn value. Note that if you want to return a fn as a\n final value, you must wrap it in some data structure and unpack it\n after trampoline returns.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(6293), kw_end_DASH_line, int(6293))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + recur_loop_2613: + var tmp3 any + { // let + // let binding "ret" + tmp4 := lang.Apply(v2, nil) + var v5 any = tmp4 + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_fn_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v5}) + if lang.IsTruthy(tmp8) { + var tmp9 any = v5 + v2 = tmp9 + goto recur_loop_2613 + } else { + tmp6 = v5 + } + tmp3 = tmp6 + } // end let + return tmp3 + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_trampoline) + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := lang.Apply(tmp6, []any{v2, v3}) + return tmp7 + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6309), kw_column, int(18), kw_end_DASH_line, int(6309), kw_end_DASH_column, int(32)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp8 := lang.Apply(tmp4, []any{tmp7}) + return tmp8 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_trampoline = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_trampoline.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // update + { + tmp0 := sym_update.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m, sym_k, sym_f), lang.NewVector(sym_m, sym_k, sym_f, sym_x), lang.NewVector(sym_m, sym_k, sym_f, sym_x, sym_y), lang.NewVector(sym_m, sym_k, sym_f, sym_x, sym_y, sym_z), lang.NewVector(sym_m, sym_k, sym_f, sym_x, sym_y, sym_z, sym__AMP_, sym_more)), kw_doc, "'Updates' a value in an associative structure, where k is a\n key and f is a function that will take the old value\n and any supplied args and return the new value, and returns a new\n structure. If the key does not exist, nil is passed as the old value.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(6174), kw_end_DASH_line, int(6174))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp6 := checkDerefVar(var_glojure_DOT_core_get) + tmp7 := lang.Apply(tmp6, []any{v2, v3}) + tmp8 := lang.Apply(v4, []any{tmp7}) + tmp9 := lang.Apply(tmp5, []any{v2, v3, tmp8}) + return tmp9 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp7 := checkDerefVar(var_glojure_DOT_core_get) + tmp8 := lang.Apply(tmp7, []any{v2, v3}) + tmp9 := lang.Apply(v4, []any{tmp8, v5}) + tmp10 := lang.Apply(tmp6, []any{v2, v3, tmp9}) + return tmp10 + case 5: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp8 := checkDerefVar(var_glojure_DOT_core_get) + tmp9 := lang.Apply(tmp8, []any{v2, v3}) + tmp10 := lang.Apply(v4, []any{tmp9, v5, v6}) + tmp11 := lang.Apply(tmp7, []any{v2, v3, tmp10}) + return tmp11 + case 6: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + v7 := args[5] + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp9 := checkDerefVar(var_glojure_DOT_core_get) + tmp10 := lang.Apply(tmp9, []any{v2, v3}) + tmp11 := lang.Apply(v4, []any{tmp10, v5, v6, v7}) + tmp12 := lang.Apply(tmp8, []any{v2, v3, tmp11}) + return tmp12 + default: + checkArity(args, 6) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + v7 := args[5] + _ = v7 + var v8 any = lang.NewList(args[6:]...) + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp10 := checkDerefVar(var_glojure_DOT_core_apply) + tmp11 := checkDerefVar(var_glojure_DOT_core_get) + tmp12 := lang.Apply(tmp11, []any{v2, v3}) + tmp13 := lang.Apply(tmp10, []any{v4, tmp12, v5, v6, v7, v8}) + tmp14 := lang.Apply(tmp9, []any{v2, v3, tmp13}) + return tmp14 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_update = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_update.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // update-in + { + tmp0 := sym_update_DASH_in.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m, sym_ks, sym_f, sym__AMP_, sym_args)), kw_doc, "'Updates' a value in a nested associative structure, where ks is a\n sequence of keys and f is a function that will take the old value\n and any supplied args and return the new value, and returns a new\n nested structure. If any levels do not exist, hash-maps will be\n created.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(6158), kw_end_DASH_line, int(6158))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "up" + var tmp7 lang.FnFunc + { // function up + var v8 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 4) + v9 := args[0] + _ = v9 + v10 := args[1] + _ = v10 + v11 := args[2] + _ = v11 + v12 := args[3] + _ = v12 + var tmp13 any + { // let + // let binding "vec__832" + var v14 any = v10 + _ = v14 + // let binding "seq__833" + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := lang.Apply(tmp15, []any{v14}) + var v17 any = tmp16 + _ = v17 + // let binding "first__834" + tmp18 := checkDerefVar(var_glojure_DOT_core_first) + tmp19 := lang.Apply(tmp18, []any{v17}) + var v20 any = tmp19 + _ = v20 + // let binding "seq__833" + tmp21 := checkDerefVar(var_glojure_DOT_core_next) + tmp22 := lang.Apply(tmp21, []any{v17}) + var v23 any = tmp22 + _ = v23 + // let binding "k" + var v24 any = v20 + _ = v24 + // let binding "ks" + var v25 any = v23 + _ = v25 + var tmp26 any + if lang.IsTruthy(v25) { + tmp27 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp28 := checkDerefVar(var_glojure_DOT_core_get) + tmp29 := lang.Apply(tmp28, []any{v9, v24}) + tmp30 := lang.Apply(v8, []any{tmp29, v25, v11, v12}) + tmp31 := lang.Apply(tmp27, []any{v9, v24, tmp30}) + tmp26 = tmp31 + } else { + tmp32 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp33 := checkDerefVar(var_glojure_DOT_core_apply) + tmp34 := checkDerefVar(var_glojure_DOT_core_get) + tmp35 := lang.Apply(tmp34, []any{v9, v24}) + tmp36 := lang.Apply(tmp33, []any{v11, tmp35, v12}) + tmp37 := lang.Apply(tmp32, []any{v9, v24, tmp36}) + tmp26 = tmp37 + } + tmp13 = tmp26 + } // end let + return tmp13 + }) + v8 = tmp7 + _ = v8 + } + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6167), kw_column, int(15), kw_end_DASH_line, int(6171), kw_end_DASH_column, int(59)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v10 any = tmp9 + _ = v10 + tmp11 := lang.Apply(v10, []any{v2, v3, v4, v5}) + tmp6 = tmp11 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_update_DASH_in = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_update_DASH_in.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // vary-meta + { + tmp0 := sym_vary_DASH_meta.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_obj, sym_f, sym__AMP_, sym_args)), kw_doc, "Returns an object of the same type and value as obj, with\n (apply f (meta obj) args) as its metadata.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(668), kw_end_DASH_line, int(668))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_meta) + tmp8 := lang.Apply(tmp7, []any{v2}) + tmp9 := lang.Apply(tmp6, []any{v3, tmp8, v4}) + tmp10 := lang.Apply(tmp5, []any{v2, tmp9}) + return tmp10 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_vary_DASH_meta = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_vary_DASH_meta.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // when-first + { + tmp0 := sym_when_DASH_first.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "bindings => x xs\n\n Roughly the same as (when (seq xs) (let [x (first xs)] body)) but xs is evaluated only once", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(11), kw_line, int(4622), kw_end_DASH_line, int(4622))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v4}) + if lang.IsTruthy(tmp8) { + } else { + tmp9 := checkDerefVar(var_glojure_DOT_core_str) + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp13 := checkDerefVar(var_glojure_DOT_core_meta) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(kw_line, []any{tmp14}) + tmp16 := lang.Apply(tmp9, []any{tmp11, " requires ", "a vector for its binding", " in ", tmp12, ":", tmp15}) + tmp17 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp16}) + panic(tmp17) + } + _ = tmp6 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp20 := checkDerefVar(var_glojure_DOT_core_count) + tmp21 := lang.Apply(tmp20, []any{v4}) + tmp22 := lang.Apply(tmp19, []any{int64(2), tmp21}) + if lang.IsTruthy(tmp22) { + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp27 := checkDerefVar(var_glojure_DOT_core_meta) + tmp28 := lang.Apply(tmp27, []any{v2}) + tmp29 := lang.Apply(kw_line, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp25, " requires ", "exactly 2 forms in binding vector", " in ", tmp26, ":", tmp29}) + tmp31 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp31) + } + _ = tmp18 + var tmp32 any + { // let + // let binding "vec__711" + var v33 any = v4 + _ = v33 + // let binding "x" + tmp34 := checkDerefVar(var_glojure_DOT_core_nth) + tmp35 := lang.Apply(tmp34, []any{v33, int64(0), nil}) + var v36 any = tmp35 + _ = v36 + // let binding "xs" + tmp37 := checkDerefVar(var_glojure_DOT_core_nth) + tmp38 := lang.Apply(tmp37, []any{v33, int64(1), nil}) + var v39 any = tmp38 + _ = v39 + tmp40 := checkDerefVar(var_glojure_DOT_core_seq) + tmp41 := checkDerefVar(var_glojure_DOT_core_concat) + tmp42 := checkDerefVar(var_glojure_DOT_core_list) + tmp43 := lang.Apply(tmp42, []any{sym_glojure_DOT_core_SLASH_when_DASH_let}) + tmp44 := checkDerefVar(var_glojure_DOT_core_list) + tmp45 := checkDerefVar(var_glojure_DOT_core_apply) + tmp46 := checkDerefVar(var_glojure_DOT_core_vector) + tmp47 := checkDerefVar(var_glojure_DOT_core_seq) + tmp48 := checkDerefVar(var_glojure_DOT_core_concat) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) + tmp50 := lang.Apply(tmp49, []any{sym_xs__0__auto__}) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := checkDerefVar(var_glojure_DOT_core_seq) + tmp53 := checkDerefVar(var_glojure_DOT_core_concat) + tmp54 := checkDerefVar(var_glojure_DOT_core_list) + tmp55 := lang.Apply(tmp54, []any{sym_glojure_DOT_core_SLASH_seq}) + tmp56 := checkDerefVar(var_glojure_DOT_core_list) + tmp57 := lang.Apply(tmp56, []any{v39}) + tmp58 := lang.Apply(tmp53, []any{tmp55, tmp57}) + tmp59 := lang.Apply(tmp52, []any{tmp58}) + tmp60 := lang.Apply(tmp51, []any{tmp59}) + tmp61 := lang.Apply(tmp48, []any{tmp50, tmp60}) + tmp62 := lang.Apply(tmp47, []any{tmp61}) + tmp63 := lang.Apply(tmp45, []any{tmp46, tmp62}) + tmp64 := lang.Apply(tmp44, []any{tmp63}) + tmp65 := checkDerefVar(var_glojure_DOT_core_list) + tmp66 := checkDerefVar(var_glojure_DOT_core_seq) + tmp67 := checkDerefVar(var_glojure_DOT_core_concat) + tmp68 := checkDerefVar(var_glojure_DOT_core_list) + tmp69 := lang.Apply(tmp68, []any{sym_glojure_DOT_core_SLASH_let}) + tmp70 := checkDerefVar(var_glojure_DOT_core_list) + tmp71 := checkDerefVar(var_glojure_DOT_core_apply) + tmp72 := checkDerefVar(var_glojure_DOT_core_vector) + tmp73 := checkDerefVar(var_glojure_DOT_core_seq) + tmp74 := checkDerefVar(var_glojure_DOT_core_concat) + tmp75 := checkDerefVar(var_glojure_DOT_core_list) + tmp76 := lang.Apply(tmp75, []any{v36}) + tmp77 := checkDerefVar(var_glojure_DOT_core_list) + tmp78 := checkDerefVar(var_glojure_DOT_core_seq) + tmp79 := checkDerefVar(var_glojure_DOT_core_concat) + tmp80 := checkDerefVar(var_glojure_DOT_core_list) + tmp81 := lang.Apply(tmp80, []any{sym_glojure_DOT_core_SLASH_first}) + tmp82 := checkDerefVar(var_glojure_DOT_core_list) + tmp83 := lang.Apply(tmp82, []any{sym_xs__0__auto__}) + tmp84 := lang.Apply(tmp79, []any{tmp81, tmp83}) + tmp85 := lang.Apply(tmp78, []any{tmp84}) + tmp86 := lang.Apply(tmp77, []any{tmp85}) + tmp87 := lang.Apply(tmp74, []any{tmp76, tmp86}) + tmp88 := lang.Apply(tmp73, []any{tmp87}) + tmp89 := lang.Apply(tmp71, []any{tmp72, tmp88}) + tmp90 := lang.Apply(tmp70, []any{tmp89}) + tmp91 := lang.Apply(tmp67, []any{tmp69, tmp90, v5}) + tmp92 := lang.Apply(tmp66, []any{tmp91}) + tmp93 := lang.Apply(tmp65, []any{tmp92}) + tmp94 := lang.Apply(tmp41, []any{tmp43, tmp64, tmp93}) + tmp95 := lang.Apply(tmp40, []any{tmp94}) + tmp32 = tmp95 + } // end let + return tmp32 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_when_DASH_first = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_when_DASH_first.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // when-let + { + tmp0 := sym_when_DASH_let.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "bindings => binding-form test\n\n When test is true, evaluates body with binding-form bound to the value of test", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(11), kw_line, int(1859), kw_end_DASH_line, int(1859))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v4}) + if lang.IsTruthy(tmp8) { + } else { + tmp9 := checkDerefVar(var_glojure_DOT_core_str) + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp13 := checkDerefVar(var_glojure_DOT_core_meta) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(kw_line, []any{tmp14}) + tmp16 := lang.Apply(tmp9, []any{tmp11, " requires ", "a vector for its binding", " in ", tmp12, ":", tmp15}) + tmp17 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp16}) + panic(tmp17) + } + _ = tmp6 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp20 := checkDerefVar(var_glojure_DOT_core_count) + tmp21 := lang.Apply(tmp20, []any{v4}) + tmp22 := lang.Apply(tmp19, []any{int64(2), tmp21}) + if lang.IsTruthy(tmp22) { + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp27 := checkDerefVar(var_glojure_DOT_core_meta) + tmp28 := lang.Apply(tmp27, []any{v2}) + tmp29 := lang.Apply(kw_line, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp25, " requires ", "exactly 2 forms in binding vector", " in ", tmp26, ":", tmp29}) + tmp31 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp31) + } + _ = tmp18 + var tmp32 any + { // let + // let binding "form" + tmp33 := lang.Apply(v4, []any{int64(0)}) + var v34 any = tmp33 + _ = v34 + // let binding "tst" + tmp35 := lang.Apply(v4, []any{int64(1)}) + var v36 any = tmp35 + _ = v36 + tmp37 := checkDerefVar(var_glojure_DOT_core_seq) + tmp38 := checkDerefVar(var_glojure_DOT_core_concat) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := lang.Apply(tmp39, []any{sym_glojure_DOT_core_SLASH_let}) + tmp41 := checkDerefVar(var_glojure_DOT_core_list) + tmp42 := checkDerefVar(var_glojure_DOT_core_apply) + tmp43 := checkDerefVar(var_glojure_DOT_core_vector) + tmp44 := checkDerefVar(var_glojure_DOT_core_seq) + tmp45 := checkDerefVar(var_glojure_DOT_core_concat) + tmp46 := checkDerefVar(var_glojure_DOT_core_list) + tmp47 := lang.Apply(tmp46, []any{sym_temp__0__auto__}) + tmp48 := checkDerefVar(var_glojure_DOT_core_list) + tmp49 := lang.Apply(tmp48, []any{v36}) + tmp50 := lang.Apply(tmp45, []any{tmp47, tmp49}) + tmp51 := lang.Apply(tmp44, []any{tmp50}) + tmp52 := lang.Apply(tmp42, []any{tmp43, tmp51}) + tmp53 := lang.Apply(tmp41, []any{tmp52}) + tmp54 := checkDerefVar(var_glojure_DOT_core_list) + tmp55 := checkDerefVar(var_glojure_DOT_core_seq) + tmp56 := checkDerefVar(var_glojure_DOT_core_concat) + tmp57 := checkDerefVar(var_glojure_DOT_core_list) + tmp58 := lang.Apply(tmp57, []any{sym_glojure_DOT_core_SLASH_when}) + tmp59 := checkDerefVar(var_glojure_DOT_core_list) + tmp60 := lang.Apply(tmp59, []any{sym_temp__0__auto__}) + tmp61 := checkDerefVar(var_glojure_DOT_core_list) + tmp62 := checkDerefVar(var_glojure_DOT_core_seq) + tmp63 := checkDerefVar(var_glojure_DOT_core_concat) + tmp64 := checkDerefVar(var_glojure_DOT_core_list) + tmp65 := lang.Apply(tmp64, []any{sym_glojure_DOT_core_SLASH_let}) + tmp66 := checkDerefVar(var_glojure_DOT_core_list) + tmp67 := checkDerefVar(var_glojure_DOT_core_apply) + tmp68 := checkDerefVar(var_glojure_DOT_core_vector) + tmp69 := checkDerefVar(var_glojure_DOT_core_seq) + tmp70 := checkDerefVar(var_glojure_DOT_core_concat) + tmp71 := checkDerefVar(var_glojure_DOT_core_list) + tmp72 := lang.Apply(tmp71, []any{v34}) + tmp73 := checkDerefVar(var_glojure_DOT_core_list) + tmp74 := lang.Apply(tmp73, []any{sym_temp__0__auto__}) + tmp75 := lang.Apply(tmp70, []any{tmp72, tmp74}) + tmp76 := lang.Apply(tmp69, []any{tmp75}) + tmp77 := lang.Apply(tmp67, []any{tmp68, tmp76}) + tmp78 := lang.Apply(tmp66, []any{tmp77}) + tmp79 := lang.Apply(tmp63, []any{tmp65, tmp78, v5}) + tmp80 := lang.Apply(tmp62, []any{tmp79}) + tmp81 := lang.Apply(tmp61, []any{tmp80}) + tmp82 := lang.Apply(tmp56, []any{tmp58, tmp60, tmp81}) + tmp83 := lang.Apply(tmp55, []any{tmp82}) + tmp84 := lang.Apply(tmp54, []any{tmp83}) + tmp85 := lang.Apply(tmp38, []any{tmp40, tmp53, tmp84}) + tmp86 := lang.Apply(tmp37, []any{tmp85}) + tmp32 = tmp86 + } // end let + return tmp32 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_when_DASH_let = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_when_DASH_let.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // when-some + { + tmp0 := sym_when_DASH_some.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "bindings => binding-form test\n\n When test is not nil, evaluates body with binding-form bound to the\n value of test", kw_file, "glojure/core.glj", kw_added, "1.6", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(11), kw_line, int(1894), kw_end_DASH_line, int(1894))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v4}) + if lang.IsTruthy(tmp8) { + } else { + tmp9 := checkDerefVar(var_glojure_DOT_core_str) + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp13 := checkDerefVar(var_glojure_DOT_core_meta) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(kw_line, []any{tmp14}) + tmp16 := lang.Apply(tmp9, []any{tmp11, " requires ", "a vector for its binding", " in ", tmp12, ":", tmp15}) + tmp17 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp16}) + panic(tmp17) + } + _ = tmp6 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp20 := checkDerefVar(var_glojure_DOT_core_count) + tmp21 := lang.Apply(tmp20, []any{v4}) + tmp22 := lang.Apply(tmp19, []any{int64(2), tmp21}) + if lang.IsTruthy(tmp22) { + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp27 := checkDerefVar(var_glojure_DOT_core_meta) + tmp28 := lang.Apply(tmp27, []any{v2}) + tmp29 := lang.Apply(kw_line, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp25, " requires ", "exactly 2 forms in binding vector", " in ", tmp26, ":", tmp29}) + tmp31 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp31) + } + _ = tmp18 + var tmp32 any + { // let + // let binding "form" + tmp33 := lang.Apply(v4, []any{int64(0)}) + var v34 any = tmp33 + _ = v34 + // let binding "tst" + tmp35 := lang.Apply(v4, []any{int64(1)}) + var v36 any = tmp35 + _ = v36 + tmp37 := checkDerefVar(var_glojure_DOT_core_seq) + tmp38 := checkDerefVar(var_glojure_DOT_core_concat) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := lang.Apply(tmp39, []any{sym_glojure_DOT_core_SLASH_let}) + tmp41 := checkDerefVar(var_glojure_DOT_core_list) + tmp42 := checkDerefVar(var_glojure_DOT_core_apply) + tmp43 := checkDerefVar(var_glojure_DOT_core_vector) + tmp44 := checkDerefVar(var_glojure_DOT_core_seq) + tmp45 := checkDerefVar(var_glojure_DOT_core_concat) + tmp46 := checkDerefVar(var_glojure_DOT_core_list) + tmp47 := lang.Apply(tmp46, []any{sym_temp__0__auto__}) + tmp48 := checkDerefVar(var_glojure_DOT_core_list) + tmp49 := lang.Apply(tmp48, []any{v36}) + tmp50 := lang.Apply(tmp45, []any{tmp47, tmp49}) + tmp51 := lang.Apply(tmp44, []any{tmp50}) + tmp52 := lang.Apply(tmp42, []any{tmp43, tmp51}) + tmp53 := lang.Apply(tmp41, []any{tmp52}) + tmp54 := checkDerefVar(var_glojure_DOT_core_list) + tmp55 := checkDerefVar(var_glojure_DOT_core_seq) + tmp56 := checkDerefVar(var_glojure_DOT_core_concat) + tmp57 := checkDerefVar(var_glojure_DOT_core_list) + tmp58 := lang.Apply(tmp57, []any{sym_if}) + tmp59 := checkDerefVar(var_glojure_DOT_core_list) + tmp60 := checkDerefVar(var_glojure_DOT_core_seq) + tmp61 := checkDerefVar(var_glojure_DOT_core_concat) + tmp62 := checkDerefVar(var_glojure_DOT_core_list) + tmp63 := lang.Apply(tmp62, []any{sym_glojure_DOT_core_SLASH_nil_QMARK_}) + tmp64 := checkDerefVar(var_glojure_DOT_core_list) + tmp65 := lang.Apply(tmp64, []any{sym_temp__0__auto__}) + tmp66 := lang.Apply(tmp61, []any{tmp63, tmp65}) + tmp67 := lang.Apply(tmp60, []any{tmp66}) + tmp68 := lang.Apply(tmp59, []any{tmp67}) + tmp69 := checkDerefVar(var_glojure_DOT_core_list) + tmp70 := lang.Apply(tmp69, []any{nil}) + tmp71 := checkDerefVar(var_glojure_DOT_core_list) + tmp72 := checkDerefVar(var_glojure_DOT_core_seq) + tmp73 := checkDerefVar(var_glojure_DOT_core_concat) + tmp74 := checkDerefVar(var_glojure_DOT_core_list) + tmp75 := lang.Apply(tmp74, []any{sym_glojure_DOT_core_SLASH_let}) + tmp76 := checkDerefVar(var_glojure_DOT_core_list) + tmp77 := checkDerefVar(var_glojure_DOT_core_apply) + tmp78 := checkDerefVar(var_glojure_DOT_core_vector) + tmp79 := checkDerefVar(var_glojure_DOT_core_seq) + tmp80 := checkDerefVar(var_glojure_DOT_core_concat) + tmp81 := checkDerefVar(var_glojure_DOT_core_list) + tmp82 := lang.Apply(tmp81, []any{v34}) + tmp83 := checkDerefVar(var_glojure_DOT_core_list) + tmp84 := lang.Apply(tmp83, []any{sym_temp__0__auto__}) + tmp85 := lang.Apply(tmp80, []any{tmp82, tmp84}) + tmp86 := lang.Apply(tmp79, []any{tmp85}) + tmp87 := lang.Apply(tmp77, []any{tmp78, tmp86}) + tmp88 := lang.Apply(tmp76, []any{tmp87}) + tmp89 := lang.Apply(tmp73, []any{tmp75, tmp88, v5}) + tmp90 := lang.Apply(tmp72, []any{tmp89}) + tmp91 := lang.Apply(tmp71, []any{tmp90}) + tmp92 := lang.Apply(tmp56, []any{tmp58, tmp68, tmp70, tmp91}) + tmp93 := lang.Apply(tmp55, []any{tmp92}) + tmp94 := lang.Apply(tmp54, []any{tmp93}) + tmp95 := lang.Apply(tmp38, []any{tmp40, tmp53, tmp94}) + tmp96 := lang.Apply(tmp37, []any{tmp95}) + tmp32 = tmp96 + } // end let + return tmp32 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_when_DASH_some = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_when_DASH_some.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // while + { + tmp0 := sym_while.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_test, sym__AMP_, sym_body)), kw_doc, "Repeatedly executes body while test expression is true. Presumes\n some side-effect will cause test to become false/nil. Returns nil", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(11), kw_line, int(6327), kw_end_DASH_line, int(6327))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_loop}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + tmp12 := checkDerefVar(var_glojure_DOT_core_vector) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := lang.Apply(tmp14, nil) + tmp16 := lang.Apply(tmp13, []any{tmp15}) + tmp17 := lang.Apply(tmp11, []any{tmp12, tmp16}) + tmp18 := lang.Apply(tmp10, []any{tmp17}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{sym_glojure_DOT_core_SLASH_when}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v4}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := checkDerefVar(var_glojure_DOT_core_seq) + tmp28 := checkDerefVar(var_glojure_DOT_core_concat) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{sym_recur}) + tmp31 := lang.Apply(tmp28, []any{tmp30}) + tmp32 := lang.Apply(tmp27, []any{tmp31}) + tmp33 := lang.Apply(tmp26, []any{tmp32}) + tmp34 := lang.Apply(tmp21, []any{tmp23, tmp25, v5, tmp33}) + tmp35 := lang.Apply(tmp20, []any{tmp34}) + tmp36 := lang.Apply(tmp19, []any{tmp35}) + tmp37 := lang.Apply(tmp7, []any{tmp9, tmp18, tmp36}) + tmp38 := lang.Apply(tmp6, []any{tmp37}) + return tmp38 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_while = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_while.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // with-bindings + { + tmp0 := sym_with_DASH_bindings.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_binding_DASH_map, sym__AMP_, sym_body)), kw_doc, "Takes a map of Var/value pairs. Installs for the given Vars the associated\n values as thread-local bindings. Then executes body. Pops the installed\n bindings after body was evaluated. Returns the value of body.", kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(11), kw_line, int(1984), kw_end_DASH_line, int(1984))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_with_DASH_bindings_STAR_}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{v4}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_fn}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_apply) + tmp19 := checkDerefVar(var_glojure_DOT_core_vector) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := lang.Apply(tmp21, nil) + tmp23 := lang.Apply(tmp20, []any{tmp22}) + tmp24 := lang.Apply(tmp18, []any{tmp19, tmp23}) + tmp25 := lang.Apply(tmp17, []any{tmp24}) + tmp26 := lang.Apply(tmp14, []any{tmp16, tmp25, v5}) + tmp27 := lang.Apply(tmp13, []any{tmp26}) + tmp28 := lang.Apply(tmp12, []any{tmp27}) + tmp29 := lang.Apply(tmp7, []any{tmp9, tmp11, tmp28}) + tmp30 := lang.Apply(tmp6, []any{tmp29}) + return tmp30 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_with_DASH_bindings = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_with_DASH_bindings.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // with-bindings* + { + tmp0 := sym_with_DASH_bindings_STAR_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_binding_DASH_map, sym_f, sym__AMP_, sym_args)), kw_doc, "Takes a map of Var/value pairs. Installs for the given Vars the associated\n values as thread-local bindings. Then calls f with the supplied arguments.\n Pops the installed bindings after f returned. Returns whatever f returns.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(1971), kw_end_DASH_line, int(1971))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp6 := lang.Apply(tmp5, []any{v2}) + _ = tmp6 + var tmp7 any + func() { + defer func() { + tmp8 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp9 := lang.Apply(tmp8, nil) + _ = tmp9 + }() + tmp10 := checkDerefVar(var_glojure_DOT_core_apply) + tmp11 := lang.Apply(tmp10, []any{v3, v4}) + tmp7 = tmp11 + }() + return tmp7 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_with_DASH_bindings_STAR_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_with_DASH_bindings_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // with-in-str + { + tmp0 := sym_with_DASH_in_DASH_str.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_s, sym__AMP_, sym_body)), kw_doc, "Evaluates body in a context in which *in* is bound to a fresh\n StringReader initialized with the string s.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(11), kw_line, int(4749), kw_end_DASH_line, int(4749))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_with_DASH_open}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + tmp12 := checkDerefVar(var_glojure_DOT_core_vector) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_s__0__auto__}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{sym_glojure_DOT_core_SLASH__DASH__GT_}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := checkDerefVar(var_glojure_DOT_core_seq) + tmp24 := checkDerefVar(var_glojure_DOT_core_concat) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := lang.Apply(tmp25, []any{sym_java_DOT_io_DOT_StringReader_DOT_}) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{v4}) + tmp29 := lang.Apply(tmp24, []any{tmp26, tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp29}) + tmp31 := lang.Apply(tmp22, []any{tmp30}) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := lang.Apply(tmp32, []any{sym_glojure_DOT_lang_DOT_LineNumberingPushbackReader_DOT_}) + tmp34 := lang.Apply(tmp19, []any{tmp21, tmp31, tmp33}) + tmp35 := lang.Apply(tmp18, []any{tmp34}) + tmp36 := lang.Apply(tmp17, []any{tmp35}) + tmp37 := lang.Apply(tmp14, []any{tmp16, tmp36}) + tmp38 := lang.Apply(tmp13, []any{tmp37}) + tmp39 := lang.Apply(tmp11, []any{tmp12, tmp38}) + tmp40 := lang.Apply(tmp10, []any{tmp39}) + tmp41 := checkDerefVar(var_glojure_DOT_core_list) + tmp42 := checkDerefVar(var_glojure_DOT_core_seq) + tmp43 := checkDerefVar(var_glojure_DOT_core_concat) + tmp44 := checkDerefVar(var_glojure_DOT_core_list) + tmp45 := lang.Apply(tmp44, []any{sym_glojure_DOT_core_SLASH_binding}) + tmp46 := checkDerefVar(var_glojure_DOT_core_list) + tmp47 := checkDerefVar(var_glojure_DOT_core_apply) + tmp48 := checkDerefVar(var_glojure_DOT_core_vector) + tmp49 := checkDerefVar(var_glojure_DOT_core_seq) + tmp50 := checkDerefVar(var_glojure_DOT_core_concat) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := lang.Apply(tmp51, []any{sym_glojure_DOT_core_SLASH__STAR_in_STAR_}) + tmp53 := checkDerefVar(var_glojure_DOT_core_list) + tmp54 := lang.Apply(tmp53, []any{sym_s__0__auto__}) + tmp55 := lang.Apply(tmp50, []any{tmp52, tmp54}) + tmp56 := lang.Apply(tmp49, []any{tmp55}) + tmp57 := lang.Apply(tmp47, []any{tmp48, tmp56}) + tmp58 := lang.Apply(tmp46, []any{tmp57}) + tmp59 := lang.Apply(tmp43, []any{tmp45, tmp58, v5}) + tmp60 := lang.Apply(tmp42, []any{tmp59}) + tmp61 := lang.Apply(tmp41, []any{tmp60}) + tmp62 := lang.Apply(tmp7, []any{tmp9, tmp40, tmp61}) + tmp63 := lang.Apply(tmp6, []any{tmp62}) + return tmp63 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_with_DASH_in_DASH_str = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_with_DASH_in_DASH_str.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // with-loading-context + { + tmp0 := sym_with_DASH_loading_DASH_context.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5734), kw_column, int(11), kw_end_DASH_line, int(5734), kw_end_DASH_column, int(30), kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_body)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_macro, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_fn}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_loading__0__auto__}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_apply) + tmp16 := checkDerefVar(var_glojure_DOT_core_vector) + tmp17 := checkDerefVar(var_glojure_DOT_core_seq) + tmp18 := checkDerefVar(var_glojure_DOT_core_concat) + tmp19 := lang.Apply(tmp18, nil) + tmp20 := lang.Apply(tmp17, []any{tmp19}) + tmp21 := lang.Apply(tmp15, []any{tmp16, tmp20}) + tmp22 := lang.Apply(tmp14, []any{tmp21}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_seq) + tmp25 := checkDerefVar(var_glojure_DOT_core_concat) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_PushThreadBindings}) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := checkDerefVar(var_glojure_DOT_core_apply) + tmp30 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp31 := checkDerefVar(var_glojure_DOT_core_seq) + tmp32 := checkDerefVar(var_glojure_DOT_core_concat) + tmp33 := lang.Apply(tmp32, nil) + tmp34 := lang.Apply(tmp31, []any{tmp33}) + tmp35 := lang.Apply(tmp29, []any{tmp30, tmp34}) + tmp36 := lang.Apply(tmp28, []any{tmp35}) + tmp37 := lang.Apply(tmp25, []any{tmp27, tmp36}) + tmp38 := lang.Apply(tmp24, []any{tmp37}) + tmp39 := lang.Apply(tmp23, []any{tmp38}) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := checkDerefVar(var_glojure_DOT_core_seq) + tmp42 := checkDerefVar(var_glojure_DOT_core_concat) + tmp43 := checkDerefVar(var_glojure_DOT_core_list) + tmp44 := lang.Apply(tmp43, []any{sym_try}) + tmp45 := checkDerefVar(var_glojure_DOT_core_list) + tmp46 := checkDerefVar(var_glojure_DOT_core_seq) + tmp47 := checkDerefVar(var_glojure_DOT_core_concat) + tmp48 := checkDerefVar(var_glojure_DOT_core_list) + tmp49 := lang.Apply(tmp48, []any{sym_finally}) + tmp50 := checkDerefVar(var_glojure_DOT_core_list) + tmp51 := checkDerefVar(var_glojure_DOT_core_seq) + tmp52 := checkDerefVar(var_glojure_DOT_core_concat) + tmp53 := checkDerefVar(var_glojure_DOT_core_list) + tmp54 := lang.Apply(tmp53, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_PopThreadBindings}) + tmp55 := lang.Apply(tmp52, []any{tmp54}) + tmp56 := lang.Apply(tmp51, []any{tmp55}) + tmp57 := lang.Apply(tmp50, []any{tmp56}) + tmp58 := lang.Apply(tmp47, []any{tmp49, tmp57}) + tmp59 := lang.Apply(tmp46, []any{tmp58}) + tmp60 := lang.Apply(tmp45, []any{tmp59}) + tmp61 := lang.Apply(tmp42, []any{tmp44, v4, tmp60}) + tmp62 := lang.Apply(tmp41, []any{tmp61}) + tmp63 := lang.Apply(tmp40, []any{tmp62}) + tmp64 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp22, tmp39, tmp63}) + tmp65 := lang.Apply(tmp8, []any{tmp64}) + tmp66 := lang.Apply(tmp7, []any{tmp65}) + tmp67 := lang.Apply(tmp6, []any{tmp66}) + tmp68 := lang.Apply(tmp5, []any{tmp67}) + return tmp68 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_with_DASH_loading_DASH_context = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_with_DASH_loading_DASH_context.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // with-open + { + tmp0 := sym_with_DASH_open.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "bindings => [name init ...]\n\n Evaluates body in a try expression with names bound to the values\n of the inits, and a finally clause that calls (.close name) on each\n name in reverse order.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(11), kw_line, int(3832), kw_end_DASH_line, int(3832))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v4}) + if lang.IsTruthy(tmp8) { + } else { + tmp9 := checkDerefVar(var_glojure_DOT_core_str) + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp13 := checkDerefVar(var_glojure_DOT_core_meta) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(kw_line, []any{tmp14}) + tmp16 := lang.Apply(tmp9, []any{tmp11, " requires ", "a vector for its binding", " in ", tmp12, ":", tmp15}) + tmp17 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp16}) + panic(tmp17) + } + _ = tmp6 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_even_QMARK_) + tmp20 := checkDerefVar(var_glojure_DOT_core_count) + tmp21 := lang.Apply(tmp20, []any{v4}) + tmp22 := lang.Apply(tmp19, []any{tmp21}) + if lang.IsTruthy(tmp22) { + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp27 := checkDerefVar(var_glojure_DOT_core_meta) + tmp28 := lang.Apply(tmp27, []any{v2}) + tmp29 := lang.Apply(kw_line, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp25, " requires ", "an even number of forms in binding vector", " in ", tmp26, ":", tmp29}) + tmp31 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp31) + } + _ = tmp18 + var tmp32 any + tmp33 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp34 := checkDerefVar(var_glojure_DOT_core_count) + tmp35 := lang.Apply(tmp34, []any{v4}) + tmp36 := lang.Apply(tmp33, []any{tmp35, int64(0)}) + if lang.IsTruthy(tmp36) { + tmp37 := checkDerefVar(var_glojure_DOT_core_seq) + tmp38 := checkDerefVar(var_glojure_DOT_core_concat) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := lang.Apply(tmp39, []any{sym_do}) + tmp41 := lang.Apply(tmp38, []any{tmp40, v5}) + tmp42 := lang.Apply(tmp37, []any{tmp41}) + tmp32 = tmp42 + } else { + var tmp43 any + tmp44 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp45 := lang.Apply(v4, []any{int64(0)}) + tmp46 := lang.Apply(tmp44, []any{tmp45}) + if lang.IsTruthy(tmp46) { + tmp47 := checkDerefVar(var_glojure_DOT_core_seq) + tmp48 := checkDerefVar(var_glojure_DOT_core_concat) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) + tmp50 := lang.Apply(tmp49, []any{sym_glojure_DOT_core_SLASH_let}) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := checkDerefVar(var_glojure_DOT_core_subvec) + tmp53 := lang.Apply(tmp52, []any{v4, int64(0), int64(2)}) + tmp54 := lang.Apply(tmp51, []any{tmp53}) + tmp55 := checkDerefVar(var_glojure_DOT_core_list) + tmp56 := checkDerefVar(var_glojure_DOT_core_seq) + tmp57 := checkDerefVar(var_glojure_DOT_core_concat) + tmp58 := checkDerefVar(var_glojure_DOT_core_list) + tmp59 := lang.Apply(tmp58, []any{sym_try}) + tmp60 := checkDerefVar(var_glojure_DOT_core_list) + tmp61 := checkDerefVar(var_glojure_DOT_core_seq) + tmp62 := checkDerefVar(var_glojure_DOT_core_concat) + tmp63 := checkDerefVar(var_glojure_DOT_core_list) + tmp64 := lang.Apply(tmp63, []any{sym_glojure_DOT_core_SLASH_with_DASH_open}) + tmp65 := checkDerefVar(var_glojure_DOT_core_list) + tmp66 := checkDerefVar(var_glojure_DOT_core_subvec) + tmp67 := lang.Apply(tmp66, []any{v4, int64(2)}) + tmp68 := lang.Apply(tmp65, []any{tmp67}) + tmp69 := lang.Apply(tmp62, []any{tmp64, tmp68, v5}) + tmp70 := lang.Apply(tmp61, []any{tmp69}) + tmp71 := lang.Apply(tmp60, []any{tmp70}) + tmp72 := checkDerefVar(var_glojure_DOT_core_list) + tmp73 := checkDerefVar(var_glojure_DOT_core_seq) + tmp74 := checkDerefVar(var_glojure_DOT_core_concat) + tmp75 := checkDerefVar(var_glojure_DOT_core_list) + tmp76 := lang.Apply(tmp75, []any{sym_finally}) + tmp77 := checkDerefVar(var_glojure_DOT_core_list) + tmp78 := checkDerefVar(var_glojure_DOT_core_seq) + tmp79 := checkDerefVar(var_glojure_DOT_core_concat) + tmp80 := checkDerefVar(var_glojure_DOT_core_list) + tmp81 := lang.Apply(tmp80, []any{sym__DOT_}) + tmp82 := checkDerefVar(var_glojure_DOT_core_list) + tmp83 := lang.Apply(v4, []any{int64(0)}) + tmp84 := lang.Apply(tmp82, []any{tmp83}) + tmp85 := checkDerefVar(var_glojure_DOT_core_list) + tmp86 := lang.Apply(tmp85, []any{sym_close}) + tmp87 := lang.Apply(tmp79, []any{tmp81, tmp84, tmp86}) + tmp88 := lang.Apply(tmp78, []any{tmp87}) + tmp89 := lang.Apply(tmp77, []any{tmp88}) + tmp90 := lang.Apply(tmp74, []any{tmp76, tmp89}) + tmp91 := lang.Apply(tmp73, []any{tmp90}) + tmp92 := lang.Apply(tmp72, []any{tmp91}) + tmp93 := lang.Apply(tmp57, []any{tmp59, tmp71, tmp92}) + tmp94 := lang.Apply(tmp56, []any{tmp93}) + tmp95 := lang.Apply(tmp55, []any{tmp94}) + tmp96 := lang.Apply(tmp48, []any{tmp50, tmp54, tmp95}) + tmp97 := lang.Apply(tmp47, []any{tmp96}) + tmp43 = tmp97 + } else { + var tmp98 any + if lang.IsTruthy(kw_else) { + tmp99 := lang.Apply(lang.NewIllegalArgumentError, []any{"with-open only allows Symbols in bindings"}) + panic(tmp99) + } else { + } + tmp43 = tmp98 + } + tmp32 = tmp43 + } + return tmp32 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_with_DASH_open = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_with_DASH_open.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // with-out-str + { + tmp0 := sym_with_DASH_out_DASH_str.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_body)), kw_doc, "Evaluates exprs in a context in which *out* is bound to a fresh\n StringWriter. Returns the string created by any nested printing\n calls.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(22), kw_column, int(11), kw_line, int(4738), kw_end_DASH_line, int(4738))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym_glojure_DOT_core_SLASH_let}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := checkDerefVar(var_glojure_DOT_core_apply) + tmp11 := checkDerefVar(var_glojure_DOT_core_vector) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_s__0__auto__}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := checkDerefVar(var_glojure_DOT_core_seq) + tmp18 := checkDerefVar(var_glojure_DOT_core_concat) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{sym_new}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{sym_strings_DOT_Builder}) + tmp23 := lang.Apply(tmp18, []any{tmp20, tmp22}) + tmp24 := lang.Apply(tmp17, []any{tmp23}) + tmp25 := lang.Apply(tmp16, []any{tmp24}) + tmp26 := lang.Apply(tmp13, []any{tmp15, tmp25}) + tmp27 := lang.Apply(tmp12, []any{tmp26}) + tmp28 := lang.Apply(tmp10, []any{tmp11, tmp27}) + tmp29 := lang.Apply(tmp9, []any{tmp28}) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := checkDerefVar(var_glojure_DOT_core_seq) + tmp32 := checkDerefVar(var_glojure_DOT_core_concat) + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{sym_glojure_DOT_core_SLASH_binding}) + tmp35 := checkDerefVar(var_glojure_DOT_core_list) + tmp36 := checkDerefVar(var_glojure_DOT_core_apply) + tmp37 := checkDerefVar(var_glojure_DOT_core_vector) + tmp38 := checkDerefVar(var_glojure_DOT_core_seq) + tmp39 := checkDerefVar(var_glojure_DOT_core_concat) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{sym_glojure_DOT_core_SLASH__STAR_out_STAR_}) + tmp42 := checkDerefVar(var_glojure_DOT_core_list) + tmp43 := lang.Apply(tmp42, []any{sym_s__0__auto__}) + tmp44 := lang.Apply(tmp39, []any{tmp41, tmp43}) + tmp45 := lang.Apply(tmp38, []any{tmp44}) + tmp46 := lang.Apply(tmp36, []any{tmp37, tmp45}) + tmp47 := lang.Apply(tmp35, []any{tmp46}) + tmp48 := checkDerefVar(var_glojure_DOT_core_list) + tmp49 := checkDerefVar(var_glojure_DOT_core_seq) + tmp50 := checkDerefVar(var_glojure_DOT_core_concat) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := lang.Apply(tmp51, []any{sym_glojure_DOT_core_SLASH_str}) + tmp53 := checkDerefVar(var_glojure_DOT_core_list) + tmp54 := lang.Apply(tmp53, []any{sym_s__0__auto__}) + tmp55 := lang.Apply(tmp50, []any{tmp52, tmp54}) + tmp56 := lang.Apply(tmp49, []any{tmp55}) + tmp57 := lang.Apply(tmp48, []any{tmp56}) + tmp58 := lang.Apply(tmp32, []any{tmp34, tmp47, v4, tmp57}) + tmp59 := lang.Apply(tmp31, []any{tmp58}) + tmp60 := lang.Apply(tmp30, []any{tmp59}) + tmp61 := lang.Apply(tmp6, []any{tmp8, tmp29, tmp60}) + tmp62 := lang.Apply(tmp5, []any{tmp61}) + return tmp62 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_with_DASH_out_DASH_str = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_with_DASH_out_DASH_str.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // with-precision + { + tmp0 := sym_with_DASH_precision.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_precision, sym__AMP_, sym_exprs)), kw_doc, "Sets the precision and rounding mode to be used for BigDecimal operations.\n\n Usage: (with-precision 10 (/ 1M 3))\n or: (with-precision 10 :rounding HALF_DOWN (/ 1M 3))\n\n The rounding mode is one of CEILING, FLOOR, HALF_UP, HALF_DOWN,\n HALF_EVEN, UP, DOWN and UNNECESSARY; it defaults to HALF_UP.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(24), kw_column, int(11), kw_line, int(5110), kw_end_DASH_line, int(5110))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "vec__756" + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp9 := checkDerefVar(var_glojure_DOT_core_first) + tmp10 := lang.Apply(tmp9, []any{v5}) + tmp11 := lang.Apply(tmp8, []any{tmp10, kw_rounding}) + if lang.IsTruthy(tmp11) { + tmp12 := checkDerefVar(var_glojure_DOT_core_next) + tmp13 := checkDerefVar(var_glojure_DOT_core_next) + tmp14 := lang.Apply(tmp13, []any{v5}) + tmp15 := lang.Apply(tmp12, []any{tmp14}) + tmp16 := checkDerefVar(var_glojure_DOT_core_seq) + tmp17 := checkDerefVar(var_glojure_DOT_core_concat) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := checkDerefVar(var_glojure_DOT_core_seq) + tmp20 := checkDerefVar(var_glojure_DOT_core_concat) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{sym__DOT_}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := lang.Apply(tmp23, []any{sym_java_DOT_math_DOT_RoundingMode}) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := checkDerefVar(var_glojure_DOT_core_second) + tmp27 := lang.Apply(tmp26, []any{v5}) + tmp28 := lang.Apply(tmp25, []any{tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp22, tmp24, tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp18, []any{tmp30}) + tmp32 := lang.Apply(tmp17, []any{tmp31}) + tmp33 := lang.Apply(tmp16, []any{tmp32}) + tmp34 := lang.NewVector(tmp15, tmp33) + tmp35 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5121), kw_column, int(23), kw_end_DASH_line, int(5122), kw_end_DASH_column, int(69)) + tmp36, err := lang.WithMeta(tmp34, tmp35.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp7 = tmp36 + } else { + tmp37 := lang.NewVector(v5, nil) + tmp38 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5123), kw_column, int(23), kw_end_DASH_line, int(5123), kw_end_DASH_column, int(33)) + tmp39, err := lang.WithMeta(tmp37, tmp38.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp7 = tmp39 + } + var v40 any = tmp7 + _ = v40 + // let binding "body" + tmp41 := checkDerefVar(var_glojure_DOT_core_nth) + tmp42 := lang.Apply(tmp41, []any{v40, int64(0), nil}) + var v43 any = tmp42 + _ = v43 + // let binding "rm" + tmp44 := checkDerefVar(var_glojure_DOT_core_nth) + tmp45 := lang.Apply(tmp44, []any{v40, int64(1), nil}) + var v46 any = tmp45 + _ = v46 + tmp47 := checkDerefVar(var_glojure_DOT_core_seq) + tmp48 := checkDerefVar(var_glojure_DOT_core_concat) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) + tmp50 := lang.Apply(tmp49, []any{sym_glojure_DOT_core_SLASH_binding}) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := checkDerefVar(var_glojure_DOT_core_apply) + tmp53 := checkDerefVar(var_glojure_DOT_core_vector) + tmp54 := checkDerefVar(var_glojure_DOT_core_seq) + tmp55 := checkDerefVar(var_glojure_DOT_core_concat) + tmp56 := checkDerefVar(var_glojure_DOT_core_list) + tmp57 := lang.Apply(tmp56, []any{sym_glojure_DOT_core_SLASH__STAR_math_DASH_context_STAR_}) + tmp58 := checkDerefVar(var_glojure_DOT_core_list) + tmp59 := checkDerefVar(var_glojure_DOT_core_seq) + tmp60 := checkDerefVar(var_glojure_DOT_core_concat) + tmp61 := checkDerefVar(var_glojure_DOT_core_list) + tmp62 := lang.Apply(tmp61, []any{sym_java_DOT_math_DOT_MathContext_DOT_}) + tmp63 := checkDerefVar(var_glojure_DOT_core_list) + tmp64 := lang.Apply(tmp63, []any{v4}) + tmp65 := lang.Apply(tmp60, []any{tmp62, tmp64, v46}) + tmp66 := lang.Apply(tmp59, []any{tmp65}) + tmp67 := lang.Apply(tmp58, []any{tmp66}) + tmp68 := lang.Apply(tmp55, []any{tmp57, tmp67}) + tmp69 := lang.Apply(tmp54, []any{tmp68}) + tmp70 := lang.Apply(tmp52, []any{tmp53, tmp69}) + tmp71 := lang.Apply(tmp51, []any{tmp70}) + tmp72 := lang.Apply(tmp48, []any{tmp50, tmp71, v43}) + tmp73 := lang.Apply(tmp47, []any{tmp72}) + tmp6 = tmp73 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_with_DASH_precision = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_with_DASH_precision.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // with-redefs + { + tmp0 := sym_with_DASH_redefs.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "binding => var-symbol temp-value-expr\n\n Temporarily redefines Vars while executing the body. The\n temp-value-exprs will be evaluated and each resulting value will\n replace in parallel the root value of its Var. After the body is\n executed, the root values of all the Vars will be set back to their\n old values. These temporary changes will be visible in all threads.\n Useful for mocking out functions during testing.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(11), kw_line, int(7544), kw_end_DASH_line, int(7544))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_with_DASH_redefs_DASH_fn}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_zipmap) + tmp12 := checkDerefVar(var_glojure_DOT_core_map) + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v14 := args[0] + _ = v14 + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_var, v14}) + return tmp16 + }) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7555), kw_column, int(34), kw_end_DASH_line, int(7555), kw_end_DASH_column, int(47)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp16 := checkDerefVar(var_glojure_DOT_core_take_DASH_nth) + tmp17 := lang.Apply(tmp16, []any{int64(2), v4}) + tmp18 := lang.Apply(tmp12, []any{tmp15, tmp17}) + tmp19 := checkDerefVar(var_glojure_DOT_core_take_DASH_nth) + tmp20 := checkDerefVar(var_glojure_DOT_core_next) + tmp21 := lang.Apply(tmp20, []any{v4}) + tmp22 := lang.Apply(tmp19, []any{int64(2), tmp21}) + tmp23 := lang.Apply(tmp11, []any{tmp18, tmp22}) + tmp24 := lang.Apply(tmp10, []any{tmp23}) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := checkDerefVar(var_glojure_DOT_core_seq) + tmp27 := checkDerefVar(var_glojure_DOT_core_concat) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := lang.Apply(tmp28, []any{sym_glojure_DOT_core_SLASH_fn}) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := checkDerefVar(var_glojure_DOT_core_apply) + tmp32 := checkDerefVar(var_glojure_DOT_core_vector) + tmp33 := checkDerefVar(var_glojure_DOT_core_seq) + tmp34 := checkDerefVar(var_glojure_DOT_core_concat) + tmp35 := lang.Apply(tmp34, nil) + tmp36 := lang.Apply(tmp33, []any{tmp35}) + tmp37 := lang.Apply(tmp31, []any{tmp32, tmp36}) + tmp38 := lang.Apply(tmp30, []any{tmp37}) + tmp39 := lang.Apply(tmp27, []any{tmp29, tmp38, v5}) + tmp40 := lang.Apply(tmp26, []any{tmp39}) + tmp41 := lang.Apply(tmp25, []any{tmp40}) + tmp42 := lang.Apply(tmp7, []any{tmp9, tmp24, tmp41}) + tmp43 := lang.Apply(tmp6, []any{tmp42}) + return tmp43 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_with_DASH_redefs = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_with_DASH_redefs.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // with-redefs-fn + { + tmp0 := sym_with_DASH_redefs_DASH_fn.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_binding_DASH_map, sym_func)), kw_doc, "Temporarily redefines Vars during a call to func. Each val of\n binding-map will replace the root value of its key which must be\n a Var. After func is called with no args, the root values of all\n the Vars will be set back to their old values. These temporary\n changes will be visible in all threads. Useful for mocking out\n functions during testing.", kw_file, "glojure/core.glj", kw_added, "1.3", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(7524), kw_end_DASH_line, int(7524))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "root-bind" + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v6 := args[0] + _ = v6 + var tmp7 any + { // let + // let binding "seq_664" + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := lang.Apply(tmp8, []any{v6}) + var v10 any = tmp9 + _ = v10 + // let binding "chunk_665" + var v11 any = nil + _ = v11 + // let binding "count_666" + var v12 any = int64(0) + _ = v12 + // let binding "i_667" + var v13 any = int64(0) + _ = v13 + for { + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp16 := lang.Apply(tmp15, []any{v13, v12}) + if lang.IsTruthy(tmp16) { + var tmp17 any + { // let + // let binding "vec__668" + tmp18, _ := lang.FieldOrMethod(v11, "nth") + if reflect.TypeOf(tmp18).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp19 := lang.Apply(tmp18, []any{v13}) + var v20 any = tmp19 + _ = v20 + // let binding "a-var" + tmp21 := checkDerefVar(var_glojure_DOT_core_nth) + tmp22 := lang.Apply(tmp21, []any{v20, int64(0), nil}) + var v23 any = tmp22 + _ = v23 + // let binding "a-val" + tmp24 := checkDerefVar(var_glojure_DOT_core_nth) + tmp25 := lang.Apply(tmp24, []any{v20, int64(1), nil}) + var v26 any = tmp25 + _ = v26 + tmp27, _ := lang.FieldOrMethod(v23, "bindRoot") + if reflect.TypeOf(tmp27).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("bindRoot is not a function"))) + } + tmp28 := lang.Apply(tmp27, []any{v26}) + _ = tmp28 + var tmp29 any = v10 + var tmp30 any = v11 + var tmp31 any = v12 + tmp33 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp34 := lang.Apply(tmp33, []any{v13}) + var tmp32 any = tmp34 + v10 = tmp29 + v11 = tmp30 + v12 = tmp31 + v13 = tmp32 + continue + } // end let + tmp14 = tmp17 + } else { + var tmp18 any + { // let + // let binding "temp__0__auto__" + tmp19 := checkDerefVar(var_glojure_DOT_core_seq) + tmp20 := lang.Apply(tmp19, []any{v10}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + if lang.IsTruthy(v21) { + var tmp23 any + { // let + // let binding "seq_664" + var v24 any = v21 + _ = v24 + var tmp25 any + tmp26 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp27 := lang.Apply(tmp26, []any{v24}) + if lang.IsTruthy(tmp27) { + var tmp28 any + { // let + // let binding "c__0__auto__" + tmp29 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp30 := lang.Apply(tmp29, []any{v24}) + var v31 any = tmp30 + _ = v31 + tmp33 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp34 := lang.Apply(tmp33, []any{v24}) + var tmp32 any = tmp34 + var tmp35 any = v31 + tmp37 := checkDerefVar(var_glojure_DOT_core_int) + tmp38 := checkDerefVar(var_glojure_DOT_core_count) + tmp39 := lang.Apply(tmp38, []any{v31}) + tmp40 := lang.Apply(tmp37, []any{tmp39}) + var tmp36 any = tmp40 + tmp42 := checkDerefVar(var_glojure_DOT_core_int) + tmp43 := lang.Apply(tmp42, []any{int64(0)}) + var tmp41 any = tmp43 + v10 = tmp32 + v11 = tmp35 + v12 = tmp36 + v13 = tmp41 + continue + } // end let + tmp25 = tmp28 + } else { + var tmp29 any + { // let + // let binding "vec__671" + tmp30 := checkDerefVar(var_glojure_DOT_core_first) + tmp31 := lang.Apply(tmp30, []any{v24}) + var v32 any = tmp31 + _ = v32 + // let binding "a-var" + tmp33 := checkDerefVar(var_glojure_DOT_core_nth) + tmp34 := lang.Apply(tmp33, []any{v32, int64(0), nil}) + var v35 any = tmp34 + _ = v35 + // let binding "a-val" + tmp36 := checkDerefVar(var_glojure_DOT_core_nth) + tmp37 := lang.Apply(tmp36, []any{v32, int64(1), nil}) + var v38 any = tmp37 + _ = v38 + tmp39, _ := lang.FieldOrMethod(v35, "bindRoot") + if reflect.TypeOf(tmp39).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("bindRoot is not a function"))) + } + tmp40 := lang.Apply(tmp39, []any{v38}) + _ = tmp40 + tmp42 := checkDerefVar(var_glojure_DOT_core_next) + tmp43 := lang.Apply(tmp42, []any{v24}) + var tmp41 any = tmp43 + var tmp44 any = nil + var tmp45 any = int64(0) + var tmp46 any = int64(0) + v10 = tmp41 + v11 = tmp44 + v12 = tmp45 + v13 = tmp46 + continue + } // end let + tmp25 = tmp29 + } + tmp23 = tmp25 + } // end let + tmp22 = tmp23 + } else { + } + tmp18 = tmp22 + } // end let + tmp14 = tmp18 + } + tmp7 = tmp14 + break + } + } // end let + return tmp7 + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7533), kw_column, int(19), kw_end_DASH_line, int(7535), kw_end_DASH_column, int(93)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v8 any = tmp7 + _ = v8 + // let binding "old-vals" + tmp9 := checkDerefVar(var_glojure_DOT_core_zipmap) + tmp10 := checkDerefVar(var_glojure_DOT_core_keys) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := checkDerefVar(var_glojure_DOT_core_map) + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v14 := args[0] + _ = v14 + tmp15, ok := lang.FieldOrMethod(v14, "getRawRoot") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v14, "getRawRoot"))) + } + var tmp16 any + switch reflect.TypeOf(tmp15).Kind() { + case reflect.Func: + tmp16 = lang.Apply(tmp15, nil) + default: + tmp16 = tmp15 + } + return tmp16 + }) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7537), kw_column, int(31), kw_end_DASH_line, int(7537), kw_end_DASH_column, int(92)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp16 := checkDerefVar(var_glojure_DOT_core_keys) + tmp17 := lang.Apply(tmp16, []any{v2}) + tmp18 := lang.Apply(tmp12, []any{tmp15, tmp17}) + tmp19 := lang.Apply(tmp9, []any{tmp11, tmp18}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + func() { + defer func() { + tmp22 := lang.Apply(v8, []any{v20}) + _ = tmp22 + }() + tmp23 := lang.Apply(v8, []any{v2}) + _ = tmp23 + tmp24 := lang.Apply(v3, nil) + tmp21 = tmp24 + }() + tmp4 = tmp21 + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_with_DASH_redefs_DASH_fn = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_with_DASH_redefs_DASH_fn.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // - + { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed6 + } else { + tmp4 = closed7 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed6 + } else { + tmp5 = closed7 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed6 + } else { + tmp6 = closed7 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(0)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym__DASH_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "If no ys are supplied, returns the negation of x, else subtracts\n the ys from x and returns the result. Does not auto-promote\n longs, will throw on overflow. See also: -'", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(7), kw_column, int(7), kw_line, int(1036), kw_end_DASH_line, int(1036))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_) + tmp6 := lang.Apply(tmp5, []any{int64(-1), v4}) + return tmp6 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Minus") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Minus is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp8 := checkDerefVar(var_glojure_DOT_core__DASH_) + tmp9 := checkDerefVar(var_glojure_DOT_core__DASH_) + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) + return tmp11 + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__DASH_ = ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__DASH_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // -' + { + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "op" + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp5) { + tmp4 = closed8 + } else { + tmp4 = closed8 + } + var v6 any = tmp4 + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym__DOT_}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := lang.Apply(tmp11, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v6}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp15, []any{tmp17, tmp19}) + tmp21 := lang.Apply(tmp14, []any{tmp20}) + tmp22 := lang.Apply(tmp13, []any{tmp21}) + tmp23 := lang.Apply(tmp8, []any{tmp10, tmp12, tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp23}) + tmp3 = tmp24 + } // end let + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "op" + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp6) { + tmp5 = closed8 + } else { + tmp5 = closed8 + } + var v7 any = tmp5 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym__DOT_}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v7}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v3}) + tmp23 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22}) + tmp24 := lang.Apply(tmp15, []any{tmp23}) + tmp25 := lang.Apply(tmp14, []any{tmp24}) + tmp26 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp25}) + tmp27 := lang.Apply(tmp8, []any{tmp26}) + tmp4 = tmp27 + } // end let + return tmp4 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "op" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) + if lang.IsTruthy(tmp7) { + tmp6 = closed8 + } else { + tmp6 = closed8 + } + var v8 any = tmp6 + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v11}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v12}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + return tmp32 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(959), kw_column, int(14), kw_end_DASH_line, int(959), kw_end_DASH_column, int(88)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym__DOT_}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v8}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v3}) + tmp28 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27}) + tmp29 := lang.Apply(tmp20, []any{tmp28}) + tmp30 := lang.Apply(tmp19, []any{tmp29}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp9, []any{tmp12, tmp32, v4}) + tmp5 = tmp33 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(951), kw_column, int(6), kw_end_DASH_line, int(960), kw_end_DASH_column, int(86))).(lang.FnFunc) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{nil, int64(0)}) + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + tmp0 := sym__DASH__TICK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_inline, tmp1, kw_doc, "If no ys are supplied, returns the negation of x, else subtracts\n the ys from x and returns the result. Supports arbitrary precision.\n See also: -", kw_file, "glojure/core.glj", kw_inline_DASH_arities, tmp2, kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(7), kw_line, int(1024), kw_end_DASH_line, int(1024))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v4 := args[0] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR__TICK_) + tmp6 := lang.Apply(tmp5, []any{int64(-1), v4}) + return tmp6 + case 2: + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "MinusP") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("MinusP is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + default: + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + var v6 any = lang.NewList(args[2:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp8 := checkDerefVar(var_glojure_DOT_core__DASH__TICK_) + tmp9 := checkDerefVar(var_glojure_DOT_core__DASH__TICK_) + tmp10 := lang.Apply(tmp9, []any{v4, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v6}) + return tmp11 + } + }) + tmp3 = tmp3.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core__DASH__TICK_ = ns.InternWithValue(tmp0, tmp3, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__DASH__TICK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // agent + { + tmp0 := sym_agent.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_state, sym__AMP_, sym_options)), kw_doc, "Creates and returns an agent with an initial value of state and\n zero or more options (in any order):\n\n :meta metadata-map\n\n :validator validate-fn\n\n :error-handler handler-fn\n\n :error-mode mode-keyword\n\n If metadata-map is supplied, it will become the metadata on the\n agent. validate-fn must be nil or a side-effect-free fn of one\n argument, which will be passed the intended new state on any state\n change. If the new state is unacceptable, the validate-fn should\n return false or throw an exception. handler-fn is called if an\n action throws an exception or if validate-fn rejects a new state --\n see set-error-handler! for details. The mode-keyword may be either\n :continue (the default if an error-handler is given) or :fail (the\n default if no error-handler is given) -- see set-error-mode! for\n details.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(2052), kw_end_DASH_line, int(2052))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + var tmp4 any + { // let + // let binding "a" + var v5 any = "unimplemented: new with non-constant class type" + _ = v5 + // let binding "opts" + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) + var v9 any = tmp8 + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_setup_DASH_reference) + tmp11 := lang.Apply(tmp10, []any{v5, v3}) + _ = tmp11 + var tmp12 any + tmp13 := lang.Apply(kw_error_DASH_handler, []any{v9}) + if lang.IsTruthy(tmp13) { + tmp14 := lang.Apply(kw_error_DASH_handler, []any{v9}) + tmp15, _ := lang.FieldOrMethod(v5, "setErrorHandler") + if reflect.TypeOf(tmp15).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorHandler is not a function"))) + } + tmp16 := lang.Apply(tmp15, []any{tmp14}) + tmp12 = tmp16 + } else { + } + _ = tmp12 + var tmp17 any + { // let + // let binding "or__0__auto__" + tmp18 := lang.Apply(kw_error_DASH_mode, []any{v9}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + tmp20 = v19 + } else { + var tmp21 any + tmp22 := lang.Apply(kw_error_DASH_handler, []any{v9}) + if lang.IsTruthy(tmp22) { + tmp21 = kw_continue + } else { + tmp21 = kw_fail + } + tmp20 = tmp21 + } + tmp17 = tmp20 + } // end let + tmp18, _ := lang.FieldOrMethod(v5, "setErrorMode") + if reflect.TypeOf(tmp18).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorMode is not a function"))) + } + tmp19 := lang.Apply(tmp18, []any{tmp17}) + _ = tmp19 + tmp4 = v5 + } // end let + return tmp4 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_agent = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_agent.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // aget + { + var tmp1 lang.FnFunc + { // function aget__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym__DOT_}) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Aget}) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := checkDerefVar(var_glojure_DOT_core_seq) + tmp20 := checkDerefVar(var_glojure_DOT_core_concat) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{sym_glojure_DOT_core_SLASH_int}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := lang.Apply(tmp23, []any{v4}) + tmp25 := lang.Apply(tmp20, []any{tmp22, tmp24}) + tmp26 := lang.Apply(tmp19, []any{tmp25}) + tmp27 := lang.Apply(tmp18, []any{tmp26}) + tmp28 := lang.Apply(tmp13, []any{tmp15, tmp17, tmp27}) + tmp29 := lang.Apply(tmp12, []any{tmp28}) + tmp30 := lang.Apply(tmp11, []any{tmp29}) + tmp31 := lang.Apply(tmp6, []any{tmp8, tmp10, tmp30}) + tmp32 := lang.Apply(tmp5, []any{tmp31}) + return tmp32 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_aget.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx), lang.NewVector(sym_array, sym_idx, sym__AMP_, sym_idxs)), kw_inline, tmp1, kw_doc, "Returns the value at the index/indices. Works on Java arrays of all\n types.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(2)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3911), kw_end_DASH_line, int(3911))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := lang.Apply(lang.Get, []any{v3, v4}) + return tmp5 + default: + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_aget) + tmp8 := checkDerefVar(var_glojure_DOT_core_aget) + tmp9 := lang.Apply(tmp8, []any{v3, v4}) + tmp10 := lang.Apply(tmp6, []any{tmp7, tmp9, v5}) + return tmp10 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_aget = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_aget.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // amap + { + tmp0 := sym_amap.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_a, sym_idx, sym_ret, sym_expr)), kw_doc, "Maps an expression across an array a, using an index named idx, and\n return value named ret, initialized to a clone of a, then setting \n each element of ret to the evaluation of expr, returning the new \n array ret.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(11), kw_line, int(5273), kw_end_DASH_line, int(5273))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 6) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + v6 := args[4] + _ = v6 + v7 := args[5] + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_let}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_apply) + tmp14 := checkDerefVar(var_glojure_DOT_core_vector) + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := checkDerefVar(var_glojure_DOT_core_concat) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{sym_a__0__auto__}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v4}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{sym_l__1__auto__}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_seq) + tmp25 := checkDerefVar(var_glojure_DOT_core_concat) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{sym_glojure_DOT_core_SLASH_alength}) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := lang.Apply(tmp28, []any{sym_a__0__auto__}) + tmp30 := lang.Apply(tmp25, []any{tmp27, tmp29}) + tmp31 := lang.Apply(tmp24, []any{tmp30}) + tmp32 := lang.Apply(tmp23, []any{tmp31}) + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{v6}) + tmp35 := checkDerefVar(var_glojure_DOT_core_list) + tmp36 := checkDerefVar(var_glojure_DOT_core_seq) + tmp37 := checkDerefVar(var_glojure_DOT_core_concat) + tmp38 := checkDerefVar(var_glojure_DOT_core_list) + tmp39 := lang.Apply(tmp38, []any{sym_glojure_DOT_core_SLASH_aclone}) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{sym_a__0__auto__}) + tmp42 := lang.Apply(tmp37, []any{tmp39, tmp41}) + tmp43 := lang.Apply(tmp36, []any{tmp42}) + tmp44 := lang.Apply(tmp35, []any{tmp43}) + tmp45 := lang.Apply(tmp16, []any{tmp18, tmp20, tmp22, tmp32, tmp34, tmp44}) + tmp46 := lang.Apply(tmp15, []any{tmp45}) + tmp47 := lang.Apply(tmp13, []any{tmp14, tmp46}) + tmp48 := lang.Apply(tmp12, []any{tmp47}) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) + tmp50 := checkDerefVar(var_glojure_DOT_core_seq) + tmp51 := checkDerefVar(var_glojure_DOT_core_concat) + tmp52 := checkDerefVar(var_glojure_DOT_core_list) + tmp53 := lang.Apply(tmp52, []any{sym_glojure_DOT_core_SLASH_loop}) + tmp54 := checkDerefVar(var_glojure_DOT_core_list) + tmp55 := checkDerefVar(var_glojure_DOT_core_apply) + tmp56 := checkDerefVar(var_glojure_DOT_core_vector) + tmp57 := checkDerefVar(var_glojure_DOT_core_seq) + tmp58 := checkDerefVar(var_glojure_DOT_core_concat) + tmp59 := checkDerefVar(var_glojure_DOT_core_list) + tmp60 := lang.Apply(tmp59, []any{v5}) + tmp61 := checkDerefVar(var_glojure_DOT_core_list) + tmp62 := lang.Apply(tmp61, []any{int64(0)}) + tmp63 := lang.Apply(tmp58, []any{tmp60, tmp62}) + tmp64 := lang.Apply(tmp57, []any{tmp63}) + tmp65 := lang.Apply(tmp55, []any{tmp56, tmp64}) + tmp66 := lang.Apply(tmp54, []any{tmp65}) + tmp67 := checkDerefVar(var_glojure_DOT_core_list) + tmp68 := checkDerefVar(var_glojure_DOT_core_seq) + tmp69 := checkDerefVar(var_glojure_DOT_core_concat) + tmp70 := checkDerefVar(var_glojure_DOT_core_list) + tmp71 := lang.Apply(tmp70, []any{sym_if}) + tmp72 := checkDerefVar(var_glojure_DOT_core_list) + tmp73 := checkDerefVar(var_glojure_DOT_core_seq) + tmp74 := checkDerefVar(var_glojure_DOT_core_concat) + tmp75 := checkDerefVar(var_glojure_DOT_core_list) + tmp76 := lang.Apply(tmp75, []any{sym_glojure_DOT_core_SLASH__LT_}) + tmp77 := checkDerefVar(var_glojure_DOT_core_list) + tmp78 := lang.Apply(tmp77, []any{v5}) + tmp79 := checkDerefVar(var_glojure_DOT_core_list) + tmp80 := lang.Apply(tmp79, []any{sym_l__1__auto__}) + tmp81 := lang.Apply(tmp74, []any{tmp76, tmp78, tmp80}) + tmp82 := lang.Apply(tmp73, []any{tmp81}) + tmp83 := lang.Apply(tmp72, []any{tmp82}) + tmp84 := checkDerefVar(var_glojure_DOT_core_list) + tmp85 := checkDerefVar(var_glojure_DOT_core_seq) + tmp86 := checkDerefVar(var_glojure_DOT_core_concat) + tmp87 := checkDerefVar(var_glojure_DOT_core_list) + tmp88 := lang.Apply(tmp87, []any{sym_do}) + tmp89 := checkDerefVar(var_glojure_DOT_core_list) + tmp90 := checkDerefVar(var_glojure_DOT_core_seq) + tmp91 := checkDerefVar(var_glojure_DOT_core_concat) + tmp92 := checkDerefVar(var_glojure_DOT_core_list) + tmp93 := lang.Apply(tmp92, []any{sym_glojure_DOT_core_SLASH_aset}) + tmp94 := checkDerefVar(var_glojure_DOT_core_list) + tmp95 := lang.Apply(tmp94, []any{v6}) + tmp96 := checkDerefVar(var_glojure_DOT_core_list) + tmp97 := lang.Apply(tmp96, []any{v5}) + tmp98 := checkDerefVar(var_glojure_DOT_core_list) + tmp99 := lang.Apply(tmp98, []any{v7}) + tmp100 := lang.Apply(tmp91, []any{tmp93, tmp95, tmp97, tmp99}) + tmp101 := lang.Apply(tmp90, []any{tmp100}) + tmp102 := lang.Apply(tmp89, []any{tmp101}) + tmp103 := checkDerefVar(var_glojure_DOT_core_list) + tmp104 := checkDerefVar(var_glojure_DOT_core_seq) + tmp105 := checkDerefVar(var_glojure_DOT_core_concat) + tmp106 := checkDerefVar(var_glojure_DOT_core_list) + tmp107 := lang.Apply(tmp106, []any{sym_recur}) + tmp108 := checkDerefVar(var_glojure_DOT_core_list) + tmp109 := checkDerefVar(var_glojure_DOT_core_seq) + tmp110 := checkDerefVar(var_glojure_DOT_core_concat) + tmp111 := checkDerefVar(var_glojure_DOT_core_list) + tmp112 := lang.Apply(tmp111, []any{sym_glojure_DOT_core_SLASH_unchecked_DASH_inc}) + tmp113 := checkDerefVar(var_glojure_DOT_core_list) + tmp114 := lang.Apply(tmp113, []any{v5}) + tmp115 := lang.Apply(tmp110, []any{tmp112, tmp114}) + tmp116 := lang.Apply(tmp109, []any{tmp115}) + tmp117 := lang.Apply(tmp108, []any{tmp116}) + tmp118 := lang.Apply(tmp105, []any{tmp107, tmp117}) + tmp119 := lang.Apply(tmp104, []any{tmp118}) + tmp120 := lang.Apply(tmp103, []any{tmp119}) + tmp121 := lang.Apply(tmp86, []any{tmp88, tmp102, tmp120}) + tmp122 := lang.Apply(tmp85, []any{tmp121}) + tmp123 := lang.Apply(tmp84, []any{tmp122}) + tmp124 := checkDerefVar(var_glojure_DOT_core_list) + tmp125 := lang.Apply(tmp124, []any{v6}) + tmp126 := lang.Apply(tmp69, []any{tmp71, tmp83, tmp123, tmp125}) + tmp127 := lang.Apply(tmp68, []any{tmp126}) + tmp128 := lang.Apply(tmp67, []any{tmp127}) + tmp129 := lang.Apply(tmp51, []any{tmp53, tmp66, tmp128}) + tmp130 := lang.Apply(tmp50, []any{tmp129}) + tmp131 := lang.Apply(tmp49, []any{tmp130}) + tmp132 := lang.Apply(tmp9, []any{tmp11, tmp48, tmp131}) + tmp133 := lang.Apply(tmp8, []any{tmp132}) + return tmp133 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_amap = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_amap.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ancestors + { + tmp0 := sym_ancestors.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_tag), lang.NewVector(sym_h, sym_tag)), kw_doc, "Returns the immediate and indirect parents of tag, either via a Java type\n inheritance relationship or a relationship established via derive. h\n must be a hierarchy obtained from make-hierarchy, if not supplied\n defaults to the global hierarchy", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(5577), kw_end_DASH_line, int(5577))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_ancestors) + tmp4 := checkDerefVar(var_glojure_DOT_core_global_DASH_hierarchy) + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_not_DASH_empty) + var tmp5 any + { // let + // let binding "ta" + tmp6 := checkDerefVar(var_glojure_DOT_core_get) + tmp7 := lang.Apply(kw_ancestors, []any{v2}) + tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + tmp11 := checkDerefVar(var_glojure_DOT_core_class_QMARK_) + tmp12 := lang.Apply(tmp11, []any{v3}) + if lang.IsTruthy(tmp12) { + var tmp13 any + { // let + // let binding "superclasses" + tmp14 := checkDerefVar(var_glojure_DOT_core_set) + tmp15 := checkDerefVar(var_glojure_DOT_core_supers) + tmp16 := lang.Apply(tmp15, []any{v3}) + tmp17 := lang.Apply(tmp14, []any{tmp16}) + var v18 any = tmp17 + _ = v18 + tmp19 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp20 := checkDerefVar(var_glojure_DOT_core_into1) + tmp21 := checkDerefVar(var_glojure_DOT_core_cons) + tmp22 := checkDerefVar(var_glojure_DOT_core_map) + var tmp23 lang.FnFunc + tmp23 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v24 := args[0] + _ = v24 + tmp25 := checkDerefVar(var_glojure_DOT_core_get) + tmp26 := lang.Apply(kw_ancestors, []any{v2}) + tmp27 := lang.Apply(tmp25, []any{tmp26, v24}) + return tmp27 + }) + tmp24 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5590), kw_column, int(32), kw_end_DASH_line, int(5590), kw_end_DASH_column, int(54)) + tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp26 := lang.Apply(tmp22, []any{tmp25, v18}) + tmp27 := lang.Apply(tmp21, []any{v9, tmp26}) + tmp28 := lang.Apply(tmp19, []any{tmp20, v18, tmp27}) + tmp13 = tmp28 + } // end let + tmp10 = tmp13 + } else { + tmp10 = v9 + } + tmp5 = tmp10 + } // end let + tmp6 := lang.Apply(tmp4, []any{tmp5}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ancestors = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ancestors.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // and + { + tmp0 := sym_and.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_x), lang.NewVector(sym_x, sym__AMP_, sym_next)), kw_doc, "Evaluates exprs one at a time, from left to right. If a form\n returns logical false (nil or false), and returns that value and\n doesn't evaluate any of the other expressions, otherwise it returns\n the value of the last expr. (and) returns true.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(11), kw_line, int(835), kw_end_DASH_line, int(835))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + return true + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + return v4 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_let}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + tmp12 := checkDerefVar(var_glojure_DOT_core_vector) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_and__0__auto__}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v4}) + tmp19 := lang.Apply(tmp14, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp19}) + tmp21 := lang.Apply(tmp11, []any{tmp12, tmp20}) + tmp22 := lang.Apply(tmp10, []any{tmp21}) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := checkDerefVar(var_glojure_DOT_core_seq) + tmp25 := checkDerefVar(var_glojure_DOT_core_concat) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{sym_if}) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := lang.Apply(tmp28, []any{sym_and__0__auto__}) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := checkDerefVar(var_glojure_DOT_core_seq) + tmp32 := checkDerefVar(var_glojure_DOT_core_concat) + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{sym_glojure_DOT_core_SLASH_and}) + tmp35 := lang.Apply(tmp32, []any{tmp34, v5}) + tmp36 := lang.Apply(tmp31, []any{tmp35}) + tmp37 := lang.Apply(tmp30, []any{tmp36}) + tmp38 := checkDerefVar(var_glojure_DOT_core_list) + tmp39 := lang.Apply(tmp38, []any{sym_and__0__auto__}) + tmp40 := lang.Apply(tmp25, []any{tmp27, tmp29, tmp37, tmp39}) + tmp41 := lang.Apply(tmp24, []any{tmp40}) + tmp42 := lang.Apply(tmp23, []any{tmp41}) + tmp43 := lang.Apply(tmp7, []any{tmp9, tmp22, tmp42}) + tmp44 := lang.Apply(tmp6, []any{tmp43}) + return tmp44 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_and = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_and.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // array-map + { + tmp0 := sym_array_DASH_map.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym__AMP_, sym_keyvals)), kw_doc, "Constructs an array-map. If any keys are equal, they are handled as\n if by repeated uses of assoc.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(4378), kw_end_DASH_line, int(4378))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp2, ok := lang.FieldOrMethod(nil, "EMPTY") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "EMPTY"))) + } + var tmp3 any + switch reflect.TypeOf(tmp2).Kind() { + case reflect.Func: + tmp3 = lang.Apply(tmp2, nil) + default: + tmp3 = tmp2 + } + return tmp3 + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + var tmp3 any + { // let + // let binding "ary" + tmp4 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core_odd_QMARK_) + tmp9 := checkDerefVar(var_glojure_DOT_core_alength) + tmp10 := lang.Apply(tmp9, []any{v6}) + tmp11 := lang.Apply(tmp8, []any{tmp10}) + if lang.IsTruthy(tmp11) { + tmp12 := checkDerefVar(var_glojure_DOT_core_str) + tmp13 := checkDerefVar(var_glojure_DOT_core_last) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(tmp12, []any{"No value supplied for key: ", tmp14}) + tmp16 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp15}) + panic(tmp16) + } else { + tmp17 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{v6}) + tmp7 = tmp17 + } + tmp3 = tmp7 + } // end let + return tmp3 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_array_DASH_map = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_array_DASH_map.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // aset + { + var tmp1 lang.FnFunc + { // function aset__inliner + var v2 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym__DOT_}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_runtime_DOT_RT}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_glojure_DOT_core_SLASH_Aset}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{sym_glojure_DOT_core_SLASH_int}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{v4}) + tmp26 := lang.Apply(tmp21, []any{tmp23, tmp25}) + tmp27 := lang.Apply(tmp20, []any{tmp26}) + tmp28 := lang.Apply(tmp19, []any{tmp27}) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{v5}) + tmp31 := lang.Apply(tmp14, []any{tmp16, tmp18, tmp28, tmp30}) + tmp32 := lang.Apply(tmp13, []any{tmp31}) + tmp33 := lang.Apply(tmp12, []any{tmp32}) + tmp34 := lang.Apply(tmp7, []any{tmp9, tmp11, tmp33}) + tmp35 := lang.Apply(tmp6, []any{tmp34}) + return tmp35 + }) + v2 = tmp1 + _ = v2 + } + tmp0 := sym_aset.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx, sym_val), lang.NewVector(sym_array, sym_idx, sym_idx2, sym__AMP_, sym_idxv)), kw_inline, tmp1, kw_doc, "Sets the value at the index/indices. Works on Java arrays of\n reference types. Returns val.", kw_file, "glojure/core.glj", kw_inline_DASH_arities, lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{int64(3)})), kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3922), kw_end_DASH_line, int(3922))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + tmp6 := lang.Apply(lang.SliceSet, []any{v3, v4, v5}) + _ = tmp6 + return v5 + default: + checkArity(args, 3) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + v5 := args[2] + _ = v5 + var v6 any = lang.NewList(args[3:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_apply) + tmp8 := checkDerefVar(var_glojure_DOT_core_aset) + tmp9 := checkDerefVar(var_glojure_DOT_core_aget) + tmp10 := lang.Apply(tmp9, []any{v3, v4}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10, v5, v6}) + return tmp11 + } + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_aset = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_aset.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // aset-boolean + { + tmp0 := sym_aset_DASH_boolean.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx, sym_val), lang.NewVector(sym_array, sym_idx, sym_idx2, sym__AMP_, sym_idxv)), kw_doc, "Sets the value at the index/indices. Works on arrays of boolean. Returns val.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(3), kw_line, int(3956), kw_end_DASH_line, int(3958))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_boolean) + tmp6 := lang.Apply(tmp5, []any{v4}) + tmp7, _ := lang.FieldOrMethod(nil, "setBoolean") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setBoolean is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v2, v3, tmp6}) + _ = tmp8 + return v4 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_boolean) + tmp8 := checkDerefVar(var_glojure_DOT_core_aget) + tmp9 := lang.Apply(tmp8, []any{v2, v3}) + tmp10 := lang.Apply(tmp6, []any{tmp7, tmp9, v4, v5}) + return tmp10 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_aset_DASH_boolean = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_aset_DASH_boolean.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // aset-byte + { + tmp0 := sym_aset_DASH_byte.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx, sym_val), lang.NewVector(sym_array, sym_idx, sym_idx2, sym__AMP_, sym_idxv)), kw_doc, "Sets the value at the index/indices. Works on arrays of byte. Returns val.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(3), kw_line, int(3976), kw_end_DASH_line, int(3978))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_byte) + tmp6 := lang.Apply(tmp5, []any{v4}) + tmp7, _ := lang.FieldOrMethod(nil, "setByte") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setByte is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v2, v3, tmp6}) + _ = tmp8 + return v4 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_byte) + tmp8 := checkDerefVar(var_glojure_DOT_core_aget) + tmp9 := lang.Apply(tmp8, []any{v2, v3}) + tmp10 := lang.Apply(tmp6, []any{tmp7, tmp9, v4, v5}) + return tmp10 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_aset_DASH_byte = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_aset_DASH_byte.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // aset-char + { + tmp0 := sym_aset_DASH_char.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx, sym_val), lang.NewVector(sym_array, sym_idx, sym_idx2, sym__AMP_, sym_idxv)), kw_doc, "Sets the value at the index/indices. Works on arrays of char. Returns val.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(3), kw_line, int(3981), kw_end_DASH_line, int(3983))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_char) + tmp6 := lang.Apply(tmp5, []any{v4}) + tmp7, _ := lang.FieldOrMethod(nil, "setChar") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setChar is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v2, v3, tmp6}) + _ = tmp8 + return v4 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_char) + tmp8 := checkDerefVar(var_glojure_DOT_core_aget) + tmp9 := lang.Apply(tmp8, []any{v2, v3}) + tmp10 := lang.Apply(tmp6, []any{tmp7, tmp9, v4, v5}) + return tmp10 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_aset_DASH_char = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_aset_DASH_char.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // aset-double + { + tmp0 := sym_aset_DASH_double.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx, sym_val), lang.NewVector(sym_array, sym_idx, sym_idx2, sym__AMP_, sym_idxv)), kw_doc, "Sets the value at the index/indices. Works on arrays of double. Returns val.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(3), kw_line, int(3966), kw_end_DASH_line, int(3968))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_double) + tmp6 := lang.Apply(tmp5, []any{v4}) + tmp7, _ := lang.FieldOrMethod(nil, "setDouble") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setDouble is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v2, v3, tmp6}) + _ = tmp8 + return v4 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_double) + tmp8 := checkDerefVar(var_glojure_DOT_core_aget) + tmp9 := lang.Apply(tmp8, []any{v2, v3}) + tmp10 := lang.Apply(tmp6, []any{tmp7, tmp9, v4, v5}) + return tmp10 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_aset_DASH_double = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_aset_DASH_double.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // aset-float + { + tmp0 := sym_aset_DASH_float.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx, sym_val), lang.NewVector(sym_array, sym_idx, sym_idx2, sym__AMP_, sym_idxv)), kw_doc, "Sets the value at the index/indices. Works on arrays of float. Returns val.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(3), kw_line, int(3961), kw_end_DASH_line, int(3963))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_float) + tmp6 := lang.Apply(tmp5, []any{v4}) + tmp7, _ := lang.FieldOrMethod(nil, "setFloat") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setFloat is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v2, v3, tmp6}) + _ = tmp8 + return v4 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_float) + tmp8 := checkDerefVar(var_glojure_DOT_core_aget) + tmp9 := lang.Apply(tmp8, []any{v2, v3}) + tmp10 := lang.Apply(tmp6, []any{tmp7, tmp9, v4, v5}) + return tmp10 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_aset_DASH_float = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_aset_DASH_float.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // aset-int + { + tmp0 := sym_aset_DASH_int.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx, sym_val), lang.NewVector(sym_array, sym_idx, sym_idx2, sym__AMP_, sym_idxv)), kw_doc, "Sets the value at the index/indices. Works on arrays of int. Returns val.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(3), kw_line, int(3946), kw_end_DASH_line, int(3948))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_int) + tmp6 := lang.Apply(tmp5, []any{v4}) + tmp7, _ := lang.FieldOrMethod(nil, "setInt") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setInt is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v2, v3, tmp6}) + _ = tmp8 + return v4 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_int) + tmp8 := checkDerefVar(var_glojure_DOT_core_aget) + tmp9 := lang.Apply(tmp8, []any{v2, v3}) + tmp10 := lang.Apply(tmp6, []any{tmp7, tmp9, v4, v5}) + return tmp10 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_aset_DASH_int = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_aset_DASH_int.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // aset-long + { + tmp0 := sym_aset_DASH_long.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx, sym_val), lang.NewVector(sym_array, sym_idx, sym_idx2, sym__AMP_, sym_idxv)), kw_doc, "Sets the value at the index/indices. Works on arrays of long. Returns val.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(3), kw_line, int(3951), kw_end_DASH_line, int(3953))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_long) + tmp6 := lang.Apply(tmp5, []any{v4}) + tmp7, _ := lang.FieldOrMethod(nil, "setLong") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setLong is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v2, v3, tmp6}) + _ = tmp8 + return v4 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_long) + tmp8 := checkDerefVar(var_glojure_DOT_core_aget) + tmp9 := lang.Apply(tmp8, []any{v2, v3}) + tmp10 := lang.Apply(tmp6, []any{tmp7, tmp9, v4, v5}) + return tmp10 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_aset_DASH_long = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_aset_DASH_long.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // aset-short + { + tmp0 := sym_aset_DASH_short.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_array, sym_idx, sym_val), lang.NewVector(sym_array, sym_idx, sym_idx2, sym__AMP_, sym_idxv)), kw_doc, "Sets the value at the index/indices. Works on arrays of short. Returns val.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(3), kw_line, int(3971), kw_end_DASH_line, int(3973))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_short) + tmp6 := lang.Apply(tmp5, []any{v4}) + tmp7, _ := lang.FieldOrMethod(nil, "setShort") + if reflect.TypeOf(tmp7).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setShort is not a function"))) + } + tmp8 := lang.Apply(tmp7, []any{v2, v3, tmp6}) + _ = tmp8 + return v4 + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_short) + tmp8 := checkDerefVar(var_glojure_DOT_core_aget) + tmp9 := lang.Apply(tmp8, []any{v2, v3}) + tmp10 := lang.Apply(tmp6, []any{tmp7, tmp9, v4, v5}) + return tmp10 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_aset_DASH_short = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_aset_DASH_short.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // atom + { + tmp0 := sym_atom.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym__AMP_, sym_options)), kw_doc, "Creates and returns an Atom with an initial value of x and zero or\n more options (in any order):\n\n :meta metadata-map\n\n :validator validate-fn\n\n If metadata-map is supplied, it will become the metadata on the\n atom. validate-fn must be nil or a side-effect-free fn of one\n argument, which will be passed the intended new state on any state\n change. If the new state is unacceptable, the validate-fn should\n return false or throw an exception.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(2325), kw_end_DASH_line, int(2325))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(lang.NewAtom, []any{v2}) + return tmp3 + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_setup_DASH_reference) + tmp5 := checkDerefVar(var_glojure_DOT_core_atom) + tmp6 := lang.Apply(tmp5, []any{v2}) + tmp7 := lang.Apply(tmp4, []any{tmp6, v3}) + return tmp7 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_atom = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_atom.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // binding + { + tmp0 := sym_binding.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "binding => var-symbol init-expr\n\n Creates new bindings for the (already-existing) vars, with the\n supplied initial values, executes the exprs in an implicit do, then\n re-establishes the bindings that existed before. The new bindings\n are made in parallel (unlike let); all init-exprs are evaluated\n before the vars are bound to their new values.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(1945), kw_end_DASH_line, int(1945))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v4}) + if lang.IsTruthy(tmp8) { + } else { + tmp9 := checkDerefVar(var_glojure_DOT_core_str) + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp13 := checkDerefVar(var_glojure_DOT_core_meta) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(kw_line, []any{tmp14}) + tmp16 := lang.Apply(tmp9, []any{tmp11, " requires ", "a vector for its binding", " in ", tmp12, ":", tmp15}) + tmp17 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp16}) + panic(tmp17) + } + _ = tmp6 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_even_QMARK_) + tmp20 := checkDerefVar(var_glojure_DOT_core_count) + tmp21 := lang.Apply(tmp20, []any{v4}) + tmp22 := lang.Apply(tmp19, []any{tmp21}) + if lang.IsTruthy(tmp22) { + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp27 := checkDerefVar(var_glojure_DOT_core_meta) + tmp28 := lang.Apply(tmp27, []any{v2}) + tmp29 := lang.Apply(kw_line, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp25, " requires ", "an even number of forms in binding vector", " in ", tmp26, ":", tmp29}) + tmp31 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp31) + } + _ = tmp18 + var tmp32 any + { // let + // let binding "var-ize" + var tmp33 lang.FnFunc + tmp33 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v34 := args[0] + _ = v34 + var tmp35 any + { // let + // let binding "ret" + tmp36 := lang.NewVector() + tmp37 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(1959), kw_column, int(30), kw_end_DASH_line, int(1959), kw_end_DASH_column, int(31)) + tmp38, err := lang.WithMeta(tmp36, tmp37.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v39 any = tmp38 + _ = v39 + // let binding "vvs" + tmp40 := checkDerefVar(var_glojure_DOT_core_seq) + tmp41 := lang.Apply(tmp40, []any{v34}) + var v42 any = tmp41 + _ = v42 + for { + var tmp43 any + if lang.IsTruthy(v42) { + tmp45 := checkDerefVar(var_glojure_DOT_core_conj) + tmp46 := checkDerefVar(var_glojure_DOT_core_conj) + tmp47 := checkDerefVar(var_glojure_DOT_core_seq) + tmp48 := checkDerefVar(var_glojure_DOT_core_concat) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) + tmp50 := lang.Apply(tmp49, []any{sym_var}) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := checkDerefVar(var_glojure_DOT_core_first) + tmp53 := lang.Apply(tmp52, []any{v42}) + tmp54 := lang.Apply(tmp51, []any{tmp53}) + tmp55 := lang.Apply(tmp48, []any{tmp50, tmp54}) + tmp56 := lang.Apply(tmp47, []any{tmp55}) + tmp57 := lang.Apply(tmp46, []any{v39, tmp56}) + tmp58 := checkDerefVar(var_glojure_DOT_core_second) + tmp59 := lang.Apply(tmp58, []any{v42}) + tmp60 := lang.Apply(tmp45, []any{tmp57, tmp59}) + var tmp44 any = tmp60 + tmp62 := checkDerefVar(var_glojure_DOT_core_next) + tmp63 := checkDerefVar(var_glojure_DOT_core_next) + tmp64 := lang.Apply(tmp63, []any{v42}) + tmp65 := lang.Apply(tmp62, []any{tmp64}) + var tmp61 any = tmp65 + v39 = tmp44 + v42 = tmp61 + continue + } else { + tmp66 := checkDerefVar(var_glojure_DOT_core_seq) + tmp67 := lang.Apply(tmp66, []any{v39}) + tmp43 = tmp67 + } + tmp35 = tmp43 + break + } + } // end let + return tmp35 + }) + tmp34 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(1958), kw_column, int(17), kw_end_DASH_line, int(1963), kw_end_DASH_column, int(34)) + tmp35, err := lang.WithMeta(tmp33, tmp34.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v36 any = tmp35 + _ = v36 + tmp37 := checkDerefVar(var_glojure_DOT_core_seq) + tmp38 := checkDerefVar(var_glojure_DOT_core_concat) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := lang.Apply(tmp39, []any{sym_glojure_DOT_core_SLASH_let}) + tmp41 := checkDerefVar(var_glojure_DOT_core_list) + tmp42 := checkDerefVar(var_glojure_DOT_core_apply) + tmp43 := checkDerefVar(var_glojure_DOT_core_vector) + tmp44 := checkDerefVar(var_glojure_DOT_core_seq) + tmp45 := checkDerefVar(var_glojure_DOT_core_concat) + tmp46 := lang.Apply(tmp45, nil) + tmp47 := lang.Apply(tmp44, []any{tmp46}) + tmp48 := lang.Apply(tmp42, []any{tmp43, tmp47}) + tmp49 := lang.Apply(tmp41, []any{tmp48}) + tmp50 := checkDerefVar(var_glojure_DOT_core_list) + tmp51 := checkDerefVar(var_glojure_DOT_core_seq) + tmp52 := checkDerefVar(var_glojure_DOT_core_concat) + tmp53 := checkDerefVar(var_glojure_DOT_core_list) + tmp54 := lang.Apply(tmp53, []any{sym_glojure_DOT_core_SLASH_push_DASH_thread_DASH_bindings}) + tmp55 := checkDerefVar(var_glojure_DOT_core_list) + tmp56 := checkDerefVar(var_glojure_DOT_core_seq) + tmp57 := checkDerefVar(var_glojure_DOT_core_concat) + tmp58 := checkDerefVar(var_glojure_DOT_core_list) + tmp59 := lang.Apply(tmp58, []any{sym_glojure_DOT_core_SLASH_hash_DASH_map}) + tmp60 := lang.Apply(v36, []any{v4}) + tmp61 := lang.Apply(tmp57, []any{tmp59, tmp60}) + tmp62 := lang.Apply(tmp56, []any{tmp61}) + tmp63 := lang.Apply(tmp55, []any{tmp62}) + tmp64 := lang.Apply(tmp52, []any{tmp54, tmp63}) + tmp65 := lang.Apply(tmp51, []any{tmp64}) + tmp66 := lang.Apply(tmp50, []any{tmp65}) + tmp67 := checkDerefVar(var_glojure_DOT_core_list) + tmp68 := checkDerefVar(var_glojure_DOT_core_seq) + tmp69 := checkDerefVar(var_glojure_DOT_core_concat) + tmp70 := checkDerefVar(var_glojure_DOT_core_list) + tmp71 := lang.Apply(tmp70, []any{sym_try}) + tmp72 := checkDerefVar(var_glojure_DOT_core_list) + tmp73 := checkDerefVar(var_glojure_DOT_core_seq) + tmp74 := checkDerefVar(var_glojure_DOT_core_concat) + tmp75 := checkDerefVar(var_glojure_DOT_core_list) + tmp76 := lang.Apply(tmp75, []any{sym_finally}) + tmp77 := checkDerefVar(var_glojure_DOT_core_list) + tmp78 := checkDerefVar(var_glojure_DOT_core_seq) + tmp79 := checkDerefVar(var_glojure_DOT_core_concat) + tmp80 := checkDerefVar(var_glojure_DOT_core_list) + tmp81 := lang.Apply(tmp80, []any{sym_glojure_DOT_core_SLASH_pop_DASH_thread_DASH_bindings}) + tmp82 := lang.Apply(tmp79, []any{tmp81}) + tmp83 := lang.Apply(tmp78, []any{tmp82}) + tmp84 := lang.Apply(tmp77, []any{tmp83}) + tmp85 := lang.Apply(tmp74, []any{tmp76, tmp84}) + tmp86 := lang.Apply(tmp73, []any{tmp85}) + tmp87 := lang.Apply(tmp72, []any{tmp86}) + tmp88 := lang.Apply(tmp69, []any{tmp71, v5, tmp87}) + tmp89 := lang.Apply(tmp68, []any{tmp88}) + tmp90 := lang.Apply(tmp67, []any{tmp89}) + tmp91 := lang.Apply(tmp38, []any{tmp40, tmp49, tmp66, tmp90}) + tmp92 := lang.Apply(tmp37, []any{tmp91}) + tmp32 = tmp92 + } // end let + return tmp32 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_binding = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_binding.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // bound-fn* + { + tmp0 := sym_bound_DASH_fn_STAR_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f)), kw_doc, "Returns a function, which will install the same bindings in effect as in\n the thread at the time bound-fn* was called and then call f with any given\n arguments. This may be used to define a helper function which runs on a\n different thread, but needs the same bindings in place.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(1992), kw_end_DASH_line, int(1992))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "bindings" + tmp4 := checkDerefVar(var_glojure_DOT_core_get_DASH_thread_DASH_bindings) + tmp5 := lang.Apply(tmp4, nil) + var v6 any = tmp5 + _ = v6 + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v8 any = lang.NewList(args[0:]...) + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_apply) + tmp10 := checkDerefVar(var_glojure_DOT_core_with_DASH_bindings_STAR_) + tmp11 := lang.Apply(tmp9, []any{tmp10, v6, v2, v8}) + return tmp11 + } + }) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2001), kw_column, int(5), kw_end_DASH_line, int(2002), kw_end_DASH_column, int(45)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp3 = tmp9 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_bound_DASH_fn_STAR_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_bound_DASH_fn_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // case-map + { + tmp0 := sym_case_DASH_map.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_case_DASH_f, sym_test_DASH_f, sym_tests, sym_thens)), kw_doc, "Transforms a sequence of test constants and a corresponding sequence of then\n expressions into a sorted map to be consumed by case*. The form of the map\n entries are {(case-f test) [(test-f test) then]}.", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(8), kw_line, int(6614), kw_end_DASH_line, int(6614), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_into1) + tmp7 := checkDerefVar(var_glojure_DOT_core_sorted_DASH_map) + tmp8 := lang.Apply(tmp7, nil) + tmp9 := checkDerefVar(var_glojure_DOT_core_zipmap) + tmp10 := checkDerefVar(var_glojure_DOT_core_map) + tmp11 := lang.Apply(tmp10, []any{v2, v4}) + tmp12 := checkDerefVar(var_glojure_DOT_core_map) + tmp13 := checkDerefVar(var_glojure_DOT_core_vector) + tmp14 := checkDerefVar(var_glojure_DOT_core_map) + tmp15 := lang.Apply(tmp14, []any{v3, v4}) + tmp16 := lang.Apply(tmp12, []any{tmp13, tmp15, v5}) + tmp17 := lang.Apply(tmp9, []any{tmp11, tmp16}) + tmp18 := lang.Apply(tmp6, []any{tmp8, tmp17}) + return tmp18 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_case_DASH_map = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_case_DASH_map.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // check-valid-options + { + tmp0 := sym_check_DASH_valid_DASH_options.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_options, sym__AMP_, sym_valid_DASH_keys)), kw_doc, "Throws an exception if the given option map contains keys not listed\n as valid, else returns nil.", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(35), kw_column, int(7), kw_line, int(1709), kw_end_DASH_line, int(1709), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_disj) + tmp8 := checkDerefVar(var_glojure_DOT_core_apply) + tmp9 := checkDerefVar(var_glojure_DOT_core_hash_DASH_set) + tmp10 := checkDerefVar(var_glojure_DOT_core_keys) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := lang.Apply(tmp8, []any{tmp9, tmp11}) + tmp13 := lang.Apply(tmp6, []any{tmp7, tmp12, v3}) + tmp14 := lang.Apply(tmp5, []any{tmp13}) + if lang.IsTruthy(tmp14) { + tmp15 := checkDerefVar(var_glojure_DOT_core_apply) + tmp16 := checkDerefVar(var_glojure_DOT_core_str) + tmp17 := checkDerefVar(var_glojure_DOT_core_first) + tmp18 := lang.Apply(tmp17, []any{v3}) + tmp19 := checkDerefVar(var_glojure_DOT_core_map) + var tmp20 lang.FnFunc + tmp20 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v21 := args[0] + _ = v21 + tmp22 := checkDerefVar(var_glojure_DOT_core_str) + tmp23 := lang.Apply(tmp22, []any{", ", v21}) + return tmp23 + }) + tmp21 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(1718), kw_column, int(16), kw_end_DASH_line, int(1718), kw_end_DASH_column, int(28)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp23 := checkDerefVar(var_glojure_DOT_core_rest) + tmp24 := lang.Apply(tmp23, []any{v3}) + tmp25 := lang.Apply(tmp19, []any{tmp22, tmp24}) + tmp26 := lang.Apply(tmp15, []any{tmp16, "Only these options are valid: ", tmp18, tmp25}) + tmp27 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp26}) + panic(tmp27) + } else { + } + return tmp4 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_check_DASH_valid_DASH_options = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_check_DASH_valid_DASH_options.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // clear-agent-errors + { + tmp0 := sym_clear_DASH_agent_DASH_errors.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a)), kw_doc, "DEPRECATED: Use 'restart-agent' instead.\n Clears any exceptions thrown during asynchronous actions of the\n agent, allowing subsequent actions to occur.", kw_file, "glojure/core.glj", kw_deprecated, "1.2", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(24), kw_column, int(7), kw_line, int(2244), kw_end_DASH_line, int(2244))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_restart_DASH_agent) + tmp4, ok := lang.FieldOrMethod(v2, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "Deref"))) + } + var tmp5 any + switch reflect.TypeOf(tmp4).Kind() { + case reflect.Func: + tmp5 = lang.Apply(tmp4, nil) + default: + tmp5 = tmp4 + } + tmp6 := lang.Apply(tmp3, []any{v2, tmp5}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_clear_DASH_agent_DASH_errors = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_clear_DASH_agent_DASH_errors.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // declare + { + tmp0 := sym_declare.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_names)), kw_doc, "defs the supplied var names with no bindings, useful for making forward declarations.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(2768), kw_end_DASH_line, int(2768))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym_do}) + tmp9 := checkDerefVar(var_glojure_DOT_core_map) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v11 := args[0] + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := checkDerefVar(var_glojure_DOT_core_vary_DASH_meta) + tmp14 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp15 := lang.Apply(tmp13, []any{v11, tmp14, kw_declared, true}) + tmp16 := lang.Apply(tmp12, []any{sym_def, tmp15}) + return tmp16 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2771), kw_column, int(25), kw_end_DASH_line, int(2771), kw_end_DASH_column, int(71)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := lang.Apply(tmp9, []any{tmp12, v4}) + tmp14 := lang.Apply(tmp6, []any{tmp8, tmp13}) + tmp15 := lang.Apply(tmp5, []any{tmp14}) + return tmp15 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_declare = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_declare.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // dedupe + { + tmp0 := sym_dedupe.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_coll)), kw_doc, "Returns a lazy sequence removing consecutive duplicates in coll.\n Returns a transducer when no collection is provided.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(7681), kw_end_DASH_line, int(7681))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v3 := args[0] + _ = v3 + var tmp4 any + { // let + // let binding "pv" + tmp5 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) + tmp6 := lang.Apply(tmp5, []any{kw_glojure_DOT_core_SLASH_none}) + var v7 any = tmp6 + _ = v7 + var tmp8 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp9 := lang.Apply(v3, nil) + return tmp9 + case 1: + v9 := args[0] + _ = v9 + tmp10 := lang.Apply(v3, []any{v9}) + return tmp10 + case 2: + v9 := args[0] + _ = v9 + v10 := args[1] + _ = v10 + var tmp11 any + { // let + // let binding "prior" + tmp12 := checkDerefVar(var_glojure_DOT_core_deref) + tmp13 := lang.Apply(tmp12, []any{v7}) + var v14 any = tmp13 + _ = v14 + tmp15 := checkDerefVar(var_glojure_DOT_core_vreset_BANG_) + tmp16 := lang.Apply(tmp15, []any{v7, v10}) + _ = tmp16 + var tmp17 any + tmp18 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp19 := lang.Apply(tmp18, []any{v14, v10}) + if lang.IsTruthy(tmp19) { + tmp17 = v9 + } else { + tmp20 := lang.Apply(v3, []any{v9, v10}) + tmp17 = tmp20 + } + tmp11 = tmp17 + } // end let + return tmp11 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7688), kw_column, int(8), kw_end_DASH_line, int(7696), kw_end_DASH_column, int(37)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp4 = tmp10 + } // end let + return tmp4 + }) + tmp3 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7686), kw_column, int(4), kw_end_DASH_line, int(7696), kw_end_DASH_column, int(39)) + tmp4, err := lang.WithMeta(tmp2, tmp3.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp4 + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_sequence) + tmp4 := checkDerefVar(var_glojure_DOT_core_dedupe) + tmp5 := lang.Apply(tmp4, nil) + tmp6 := lang.Apply(tmp3, []any{tmp5, v2}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_dedupe = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_dedupe.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // defmulti + { + tmp0 := sym_defmulti.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym_docstring_QMARK_, sym_attr_DASH_map_QMARK_, sym_dispatch_DASH_fn, sym__AMP_, sym_options)), kw_doc, "Creates a new multimethod with the associated dispatch function.\n The docstring and attr-map are optional.\n\n Options are key-value pairs and may be one of:\n\n :default\n\n The default dispatch value, defaults to :default\n\n :hierarchy\n\n The value used for hierarchical dispatch (e.g. ::square is-a ::shape)\n\n Hierarchies are type-like relationships that do not depend upon type\n inheritance. By default Clojure's multimethods dispatch off of a\n global hierarchy map. However, a hierarchy relationship can be\n created with the derive function used to augment the root ancestor\n created with make-hierarchy.\n\n Multimethods expect the value of the hierarchy option to be supplied as\n a reference type e.g. a var (i.e. via the Var-quote dispatch macro #'\n or the var special form).", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(11), kw_line, int(1723), kw_end_DASH_line, int(1723))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "docstring" + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp9 := checkDerefVar(var_glojure_DOT_core_first) + tmp10 := lang.Apply(tmp9, []any{v5}) + tmp11 := lang.Apply(tmp8, []any{tmp10}) + if lang.IsTruthy(tmp11) { + tmp12 := checkDerefVar(var_glojure_DOT_core_first) + tmp13 := lang.Apply(tmp12, []any{v5}) + tmp7 = tmp13 + } else { + } + var v14 any = tmp7 + _ = v14 + // let binding "options" + var tmp15 any + tmp16 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp17 := checkDerefVar(var_glojure_DOT_core_first) + tmp18 := lang.Apply(tmp17, []any{v5}) + tmp19 := lang.Apply(tmp16, []any{tmp18}) + if lang.IsTruthy(tmp19) { + tmp20 := checkDerefVar(var_glojure_DOT_core_next) + tmp21 := lang.Apply(tmp20, []any{v5}) + tmp15 = tmp21 + } else { + tmp15 = v5 + } + var v22 any = tmp15 + _ = v22 + // let binding "m" + var tmp23 any + tmp24 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp25 := checkDerefVar(var_glojure_DOT_core_first) + tmp26 := lang.Apply(tmp25, []any{v22}) + tmp27 := lang.Apply(tmp24, []any{tmp26}) + if lang.IsTruthy(tmp27) { + tmp28 := checkDerefVar(var_glojure_DOT_core_first) + tmp29 := lang.Apply(tmp28, []any{v22}) + tmp23 = tmp29 + } else { + tmp30 := lang.NewMap() + tmp31 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(1757), kw_column, int(23), kw_end_DASH_line, int(1757), kw_end_DASH_column, int(24)) + tmp32, err := lang.WithMeta(tmp30, tmp31.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp23 = tmp32 + } + var v33 any = tmp23 + _ = v33 + // let binding "options" + var tmp34 any + tmp35 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp36 := checkDerefVar(var_glojure_DOT_core_first) + tmp37 := lang.Apply(tmp36, []any{v22}) + tmp38 := lang.Apply(tmp35, []any{tmp37}) + if lang.IsTruthy(tmp38) { + tmp39 := checkDerefVar(var_glojure_DOT_core_next) + tmp40 := lang.Apply(tmp39, []any{v22}) + tmp34 = tmp40 + } else { + tmp34 = v22 + } + var v41 any = tmp34 + _ = v41 + // let binding "dispatch-fn" + tmp42 := checkDerefVar(var_glojure_DOT_core_first) + tmp43 := lang.Apply(tmp42, []any{v41}) + var v44 any = tmp43 + _ = v44 + // let binding "options" + tmp45 := checkDerefVar(var_glojure_DOT_core_next) + tmp46 := lang.Apply(tmp45, []any{v41}) + var v47 any = tmp46 + _ = v47 + // let binding "m" + var tmp48 any + if lang.IsTruthy(v14) { + tmp49 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp50 := lang.Apply(tmp49, []any{v33, kw_doc, v14}) + tmp48 = tmp50 + } else { + tmp48 = v33 + } + var v51 any = tmp48 + _ = v51 + // let binding "m" + var tmp52 any + tmp53 := checkDerefVar(var_glojure_DOT_core_meta) + tmp54 := lang.Apply(tmp53, []any{v4}) + if lang.IsTruthy(tmp54) { + tmp55 := checkDerefVar(var_glojure_DOT_core_conj) + tmp56 := checkDerefVar(var_glojure_DOT_core_meta) + tmp57 := lang.Apply(tmp56, []any{v4}) + tmp58 := lang.Apply(tmp55, []any{tmp57, v51}) + tmp52 = tmp58 + } else { + tmp52 = v51 + } + var v59 any = tmp52 + _ = v59 + // let binding "mm-name" + tmp60 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp61 := lang.Apply(tmp60, []any{v4, v59}) + var v62 any = tmp61 + _ = v62 + var tmp63 any + tmp64 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp65 := checkDerefVar(var_glojure_DOT_core_count) + tmp66 := lang.Apply(tmp65, []any{v47}) + tmp67 := lang.Apply(tmp64, []any{tmp66, int64(1)}) + if lang.IsTruthy(tmp67) { + tmp68 := lang.Apply(lang.NewError, []any{"The syntax for defmulti has changed. Example: (defmulti name dispatch-fn :default dispatch-value)"}) + panic(tmp68) + } else { + } + _ = tmp63 + var tmp69 any + { // let + // let binding "options" + tmp70 := checkDerefVar(var_glojure_DOT_core_apply) + tmp71 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp72 := lang.Apply(tmp70, []any{tmp71, v47}) + var v73 any = tmp72 + _ = v73 + // let binding "default" + tmp74 := checkDerefVar(var_glojure_DOT_core_get) + tmp75 := lang.Apply(tmp74, []any{v73, kw_default, kw_default}) + var v76 any = tmp75 + _ = v76 + // let binding "hierarchy" + tmp77 := checkDerefVar(var_glojure_DOT_core_get) + tmp78 := lang.InternVarName(sym_glojure_DOT_core, sym_global_DASH_hierarchy) + tmp79 := lang.Apply(tmp77, []any{v73, kw_hierarchy, tmp78}) + var v80 any = tmp79 + _ = v80 + tmp81 := checkDerefVar(var_glojure_DOT_core_check_DASH_valid_DASH_options) + tmp82 := lang.Apply(tmp81, []any{v73, kw_default, kw_hierarchy}) + _ = tmp82 + tmp83 := checkDerefVar(var_glojure_DOT_core_seq) + tmp84 := checkDerefVar(var_glojure_DOT_core_concat) + tmp85 := checkDerefVar(var_glojure_DOT_core_list) + tmp86 := lang.Apply(tmp85, []any{sym_glojure_DOT_core_SLASH_let}) + tmp87 := checkDerefVar(var_glojure_DOT_core_list) + tmp88 := checkDerefVar(var_glojure_DOT_core_apply) + tmp89 := checkDerefVar(var_glojure_DOT_core_vector) + tmp90 := checkDerefVar(var_glojure_DOT_core_seq) + tmp91 := checkDerefVar(var_glojure_DOT_core_concat) + tmp92 := checkDerefVar(var_glojure_DOT_core_list) + tmp93 := lang.Apply(tmp92, []any{sym_v__0__auto__}) + tmp94 := checkDerefVar(var_glojure_DOT_core_list) + tmp95 := checkDerefVar(var_glojure_DOT_core_seq) + tmp96 := checkDerefVar(var_glojure_DOT_core_concat) + tmp97 := checkDerefVar(var_glojure_DOT_core_list) + tmp98 := lang.Apply(tmp97, []any{sym_def}) + tmp99 := checkDerefVar(var_glojure_DOT_core_list) + tmp100 := lang.Apply(tmp99, []any{v62}) + tmp101 := lang.Apply(tmp96, []any{tmp98, tmp100}) + tmp102 := lang.Apply(tmp95, []any{tmp101}) + tmp103 := lang.Apply(tmp94, []any{tmp102}) + tmp104 := lang.Apply(tmp91, []any{tmp93, tmp103}) + tmp105 := lang.Apply(tmp90, []any{tmp104}) + tmp106 := lang.Apply(tmp88, []any{tmp89, tmp105}) + tmp107 := lang.Apply(tmp87, []any{tmp106}) + tmp108 := checkDerefVar(var_glojure_DOT_core_list) + tmp109 := checkDerefVar(var_glojure_DOT_core_seq) + tmp110 := checkDerefVar(var_glojure_DOT_core_concat) + tmp111 := checkDerefVar(var_glojure_DOT_core_list) + tmp112 := lang.Apply(tmp111, []any{sym_glojure_DOT_core_SLASH_when_DASH_not}) + tmp113 := checkDerefVar(var_glojure_DOT_core_list) + tmp114 := checkDerefVar(var_glojure_DOT_core_seq) + tmp115 := checkDerefVar(var_glojure_DOT_core_concat) + tmp116 := checkDerefVar(var_glojure_DOT_core_list) + tmp117 := lang.Apply(tmp116, []any{sym_glojure_DOT_core_SLASH_and}) + tmp118 := checkDerefVar(var_glojure_DOT_core_list) + tmp119 := checkDerefVar(var_glojure_DOT_core_seq) + tmp120 := checkDerefVar(var_glojure_DOT_core_concat) + tmp121 := checkDerefVar(var_glojure_DOT_core_list) + tmp122 := lang.Apply(tmp121, []any{sym__DOT_HasRoot}) + tmp123 := checkDerefVar(var_glojure_DOT_core_list) + tmp124 := lang.Apply(tmp123, []any{sym_v__0__auto__}) + tmp125 := lang.Apply(tmp120, []any{tmp122, tmp124}) + tmp126 := lang.Apply(tmp119, []any{tmp125}) + tmp127 := lang.Apply(tmp118, []any{tmp126}) + tmp128 := checkDerefVar(var_glojure_DOT_core_list) + tmp129 := checkDerefVar(var_glojure_DOT_core_seq) + tmp130 := checkDerefVar(var_glojure_DOT_core_concat) + tmp131 := checkDerefVar(var_glojure_DOT_core_list) + tmp132 := lang.Apply(tmp131, []any{sym_glojure_DOT_core_SLASH_instance_QMARK_}) + tmp133 := checkDerefVar(var_glojure_DOT_core_list) + tmp134 := lang.Apply(tmp133, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT__STAR_MultiFn}) + tmp135 := checkDerefVar(var_glojure_DOT_core_list) + tmp136 := checkDerefVar(var_glojure_DOT_core_seq) + tmp137 := checkDerefVar(var_glojure_DOT_core_concat) + tmp138 := checkDerefVar(var_glojure_DOT_core_list) + tmp139 := lang.Apply(tmp138, []any{sym_glojure_DOT_core_SLASH_deref}) + tmp140 := checkDerefVar(var_glojure_DOT_core_list) + tmp141 := lang.Apply(tmp140, []any{sym_v__0__auto__}) + tmp142 := lang.Apply(tmp137, []any{tmp139, tmp141}) + tmp143 := lang.Apply(tmp136, []any{tmp142}) + tmp144 := lang.Apply(tmp135, []any{tmp143}) + tmp145 := lang.Apply(tmp130, []any{tmp132, tmp134, tmp144}) + tmp146 := lang.Apply(tmp129, []any{tmp145}) + tmp147 := lang.Apply(tmp128, []any{tmp146}) + tmp148 := lang.Apply(tmp115, []any{tmp117, tmp127, tmp147}) + tmp149 := lang.Apply(tmp114, []any{tmp148}) + tmp150 := lang.Apply(tmp113, []any{tmp149}) + tmp151 := checkDerefVar(var_glojure_DOT_core_list) + tmp152 := checkDerefVar(var_glojure_DOT_core_seq) + tmp153 := checkDerefVar(var_glojure_DOT_core_concat) + tmp154 := checkDerefVar(var_glojure_DOT_core_list) + tmp155 := lang.Apply(tmp154, []any{sym_def}) + tmp156 := checkDerefVar(var_glojure_DOT_core_list) + tmp157 := lang.Apply(tmp156, []any{v62}) + tmp158 := checkDerefVar(var_glojure_DOT_core_list) + tmp159 := checkDerefVar(var_glojure_DOT_core_seq) + tmp160 := checkDerefVar(var_glojure_DOT_core_concat) + tmp161 := checkDerefVar(var_glojure_DOT_core_list) + tmp162 := lang.Apply(tmp161, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_NewMultiFn}) + tmp163 := checkDerefVar(var_glojure_DOT_core_list) + tmp164 := checkDerefVar(var_glojure_DOT_core_name) + tmp165 := lang.Apply(tmp164, []any{v62}) + tmp166 := lang.Apply(tmp163, []any{tmp165}) + tmp167 := checkDerefVar(var_glojure_DOT_core_list) + tmp168 := lang.Apply(tmp167, []any{v44}) + tmp169 := checkDerefVar(var_glojure_DOT_core_list) + tmp170 := lang.Apply(tmp169, []any{v76}) + tmp171 := checkDerefVar(var_glojure_DOT_core_list) + tmp172 := lang.Apply(tmp171, []any{v80}) + tmp173 := lang.Apply(tmp160, []any{tmp162, tmp166, tmp168, tmp170, tmp172}) + tmp174 := lang.Apply(tmp159, []any{tmp173}) + tmp175 := lang.Apply(tmp158, []any{tmp174}) + tmp176 := lang.Apply(tmp153, []any{tmp155, tmp157, tmp175}) + tmp177 := lang.Apply(tmp152, []any{tmp176}) + tmp178 := lang.Apply(tmp151, []any{tmp177}) + tmp179 := lang.Apply(tmp110, []any{tmp112, tmp150, tmp178}) + tmp180 := lang.Apply(tmp109, []any{tmp179}) + tmp181 := lang.Apply(tmp108, []any{tmp180}) + tmp182 := lang.Apply(tmp84, []any{tmp86, tmp107, tmp181}) + tmp183 := lang.Apply(tmp83, []any{tmp182}) + tmp69 = tmp183 + } // end let + tmp6 = tmp69 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_defmulti = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_defmulti.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // defprotocol + { + tmp0 := sym_defprotocol.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym__AMP_, sym_opts_PLUS_sigs)), kw_doc, "A protocol is a named set of named methods and their signatures:\n (defprotocol AProtocolName\n\n ;optional doc string\n \"A doc string for AProtocol abstraction\"\n\n ;options\n :extend-via-metadata true\n\n ;method signatures\n (bar [this a b] \"bar docs\")\n (baz [this a] [this a b] [this a b c] \"baz docs\"))\n\n No implementations are provided. Docs can be specified for the\n protocol overall and for each method. The above yields a set of\n polymorphic functions and a protocol object. All are\n namespace-qualified by the ns enclosing the definition The resulting\n functions dispatch on the type of their first argument, which is\n required and corresponds to the implicit target object ('this' in \n Java parlance). defprotocol is dynamic, has no special compile-time \n effect, and defines no new types or classes. Implementations of \n the protocol methods can be provided using extend.\n\n When :extend-via-metadata is true, values can extend protocols by\n adding metadata where keys are fully-qualified protocol function\n symbols and values are function implementations. Protocol\n implementations are checked first for direct definitions (defrecord,\n deftype, reify), then metadata definitions, then external\n extensions (extend, extend-type, extend-protocol)\n\n defprotocol will automatically generate a corresponding interface,\n with the same name as the protocol, i.e. given a protocol:\n my.ns/Protocol, an interface: my.ns.Protocol. The interface will\n have methods corresponding to the protocol functions, and the\n protocol will automatically work with instances of the interface.\n\n Note that you should not use this interface with deftype or\n reify, as they support the protocol directly:\n\n (defprotocol P \n (foo [this]) \n (bar-me [this] [this y]))\n\n (deftype Foo [a b c] \n P\n (foo [this] a)\n (bar-me [this] b)\n (bar-me [this y] (+ c y)))\n \n (bar-me (Foo. 1 2 3) 42)\n => 45\n\n (foo \n (let [x 42]\n (reify P \n (foo [this] 17)\n (bar-me [this] x)\n (bar-me [this y] x))))\n => 17", kw_file, "glojure/core_deftype.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(11), kw_line, int(28), kw_end_DASH_line, int(28))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "doc" + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp9 := checkDerefVar(var_glojure_DOT_core_first) + tmp10 := lang.Apply(tmp9, []any{v5}) + tmp11 := lang.Apply(tmp8, []any{tmp10}) + if lang.IsTruthy(tmp11) { + tmp12 := checkDerefVar(var_glojure_DOT_core_first) + tmp13 := lang.Apply(tmp12, []any{v5}) + tmp7 = tmp13 + } else { + } + var v14 any = tmp7 + _ = v14 + // let binding "opts+sigs" + var tmp15 any + if lang.IsTruthy(v14) { + tmp16 := checkDerefVar(var_glojure_DOT_core_rest) + tmp17 := lang.Apply(tmp16, []any{v5}) + tmp15 = tmp17 + } else { + tmp15 = v5 + } + var v18 any = tmp15 + _ = v18 + // let binding "opts" + tmp19 := checkDerefVar(var_glojure_DOT_core_take_DASH_while) + var tmp20 lang.FnFunc + tmp20 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v21 := args[0] + _ = v21 + tmp22 := checkDerefVar(var_glojure_DOT_core_not) + tmp23 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp24 := lang.Apply(tmp23, []any{v21}) + tmp25 := lang.Apply(tmp22, []any{tmp24}) + return tmp25 + }) + tmp21 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(92), kw_column, int(26), kw_end_DASH_line, int(92), kw_end_DASH_column, int(40)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp23 := lang.Apply(tmp19, []any{tmp22, v18}) + var v24 any = tmp23 + _ = v24 + // let binding "sigs" + tmp25 := checkDerefVar(var_glojure_DOT_core_drop_DASH_while) + var tmp26 lang.FnFunc + tmp26 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v27 := args[0] + _ = v27 + tmp28 := checkDerefVar(var_glojure_DOT_core_not) + tmp29 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp30 := lang.Apply(tmp29, []any{v27}) + tmp31 := lang.Apply(tmp28, []any{tmp30}) + return tmp31 + }) + tmp27 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(93), kw_column, int(26), kw_end_DASH_line, int(93), kw_end_DASH_column, int(40)) + tmp28, err := lang.WithMeta(tmp26, tmp27.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp29 := lang.Apply(tmp25, []any{tmp28, v18}) + var v30 any = tmp29 + _ = v30 + // let binding "opts" + var tmp31 any + tmp32 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp33 := lang.Apply(tmp32, []any{v30, v24}) + if lang.IsTruthy(tmp33) { + } else { + tmp31 = v24 + } + var v34 any = tmp31 + _ = v34 + tmp35 := checkDerefVar(var_glojure_DOT_core_seq) + tmp36 := checkDerefVar(var_glojure_DOT_core_concat) + tmp37 := checkDerefVar(var_glojure_DOT_core_list) + tmp38 := lang.Apply(tmp37, []any{sym_do}) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := checkDerefVar(var_glojure_DOT_core_seq) + tmp41 := checkDerefVar(var_glojure_DOT_core_concat) + tmp42 := checkDerefVar(var_glojure_DOT_core_list) + tmp43 := lang.Apply(tmp42, []any{sym_def}) + tmp44 := checkDerefVar(var_glojure_DOT_core_list) + tmp45 := lang.Apply(tmp44, []any{v4}) + tmp46 := checkDerefVar(var_glojure_DOT_core_list) + tmp47 := checkDerefVar(var_glojure_DOT_core_seq) + tmp48 := checkDerefVar(var_glojure_DOT_core_concat) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) + tmp50 := lang.Apply(tmp49, []any{sym_glojure_DOT_core_SLASH_atom}) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := checkDerefVar(var_glojure_DOT_core_apply) + tmp53 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp54 := checkDerefVar(var_glojure_DOT_core_seq) + tmp55 := checkDerefVar(var_glojure_DOT_core_concat) + tmp56 := checkDerefVar(var_glojure_DOT_core_list) + tmp57 := lang.Apply(tmp56, []any{kw_on_DASH_interface}) + tmp58 := checkDerefVar(var_glojure_DOT_core_list) + tmp59 := lang.Apply(tmp58, []any{true}) + tmp60 := checkDerefVar(var_glojure_DOT_core_list) + tmp61 := lang.Apply(tmp60, []any{kw_sigs}) + tmp62 := checkDerefVar(var_glojure_DOT_core_list) + tmp63 := checkDerefVar(var_glojure_DOT_core_seq) + tmp64 := checkDerefVar(var_glojure_DOT_core_concat) + tmp65 := checkDerefVar(var_glojure_DOT_core_list) + tmp66 := lang.Apply(tmp65, []any{sym_quote}) + tmp67 := checkDerefVar(var_glojure_DOT_core_list) + tmp68 := lang.Apply(tmp67, []any{v30}) + tmp69 := lang.Apply(tmp64, []any{tmp66, tmp68}) + tmp70 := lang.Apply(tmp63, []any{tmp69}) + tmp71 := lang.Apply(tmp62, []any{tmp70}) + tmp72 := checkDerefVar(var_glojure_DOT_core_list) + tmp73 := lang.Apply(tmp72, []any{kw_multis}) + tmp74 := checkDerefVar(var_glojure_DOT_core_list) + tmp75 := checkDerefVar(var_glojure_DOT_core_apply) + tmp76 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp77 := checkDerefVar(var_glojure_DOT_core_seq) + tmp78 := checkDerefVar(var_glojure_DOT_core_concat) + tmp79 := lang.Apply(tmp78, nil) + tmp80 := lang.Apply(tmp77, []any{tmp79}) + tmp81 := lang.Apply(tmp75, []any{tmp76, tmp80}) + tmp82 := lang.Apply(tmp74, []any{tmp81}) + tmp83 := lang.Apply(tmp55, []any{tmp57, tmp59, tmp61, tmp71, tmp73, tmp82}) + tmp84 := lang.Apply(tmp54, []any{tmp83}) + tmp85 := lang.Apply(tmp52, []any{tmp53, tmp84}) + tmp86 := lang.Apply(tmp51, []any{tmp85}) + tmp87 := lang.Apply(tmp48, []any{tmp50, tmp86}) + tmp88 := lang.Apply(tmp47, []any{tmp87}) + tmp89 := lang.Apply(tmp46, []any{tmp88}) + tmp90 := lang.Apply(tmp41, []any{tmp43, tmp45, tmp89}) + tmp91 := lang.Apply(tmp40, []any{tmp90}) + tmp92 := lang.Apply(tmp39, []any{tmp91}) + tmp93 := checkDerefVar(var_glojure_DOT_core_list) + tmp94 := checkDerefVar(var_glojure_DOT_core_seq) + tmp95 := checkDerefVar(var_glojure_DOT_core_concat) + tmp96 := checkDerefVar(var_glojure_DOT_core_list) + tmp97 := lang.Apply(tmp96, []any{sym_glojure_DOT_core_SLASH_swap_BANG_}) + tmp98 := checkDerefVar(var_glojure_DOT_core_list) + tmp99 := lang.Apply(tmp98, []any{sym_glojure_DOT_core_SLASH__DASH_protocols}) + tmp100 := checkDerefVar(var_glojure_DOT_core_list) + tmp101 := lang.Apply(tmp100, []any{sym_glojure_DOT_core_SLASH_assoc}) + tmp102 := checkDerefVar(var_glojure_DOT_core_list) + tmp103 := checkDerefVar(var_glojure_DOT_core_seq) + tmp104 := checkDerefVar(var_glojure_DOT_core_concat) + tmp105 := checkDerefVar(var_glojure_DOT_core_list) + tmp106 := lang.Apply(tmp105, []any{sym_quote}) + tmp107 := checkDerefVar(var_glojure_DOT_core_list) + tmp108 := lang.Apply(tmp107, []any{v4}) + tmp109 := lang.Apply(tmp104, []any{tmp106, tmp108}) + tmp110 := lang.Apply(tmp103, []any{tmp109}) + tmp111 := lang.Apply(tmp102, []any{tmp110}) + tmp112 := checkDerefVar(var_glojure_DOT_core_list) + tmp113 := lang.Apply(tmp112, []any{v4}) + tmp114 := lang.Apply(tmp95, []any{tmp97, tmp99, tmp101, tmp111, tmp113}) + tmp115 := lang.Apply(tmp94, []any{tmp114}) + tmp116 := lang.Apply(tmp93, []any{tmp115}) + tmp117 := checkDerefVar(var_glojure_DOT_core_map) + var tmp118 lang.FnFunc + tmp118 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v119 := args[0] + _ = v119 + tmp120 := checkDerefVar(var_glojure_DOT_core_seq) + tmp121 := checkDerefVar(var_glojure_DOT_core_concat) + tmp122 := checkDerefVar(var_glojure_DOT_core_list) + tmp123 := lang.Apply(tmp122, []any{sym_do}) + tmp124 := checkDerefVar(var_glojure_DOT_core_list) + tmp125 := checkDerefVar(var_glojure_DOT_core_seq) + tmp126 := checkDerefVar(var_glojure_DOT_core_concat) + tmp127 := checkDerefVar(var_glojure_DOT_core_list) + tmp128 := lang.Apply(tmp127, []any{sym_glojure_DOT_core_SLASH_defmulti}) + tmp129 := checkDerefVar(var_glojure_DOT_core_list) + tmp130 := checkDerefVar(var_glojure_DOT_core_first) + tmp131 := lang.Apply(tmp130, []any{v119}) + tmp132 := lang.Apply(tmp129, []any{tmp131}) + tmp133 := checkDerefVar(var_glojure_DOT_core_list) + tmp134 := checkDerefVar(var_glojure_DOT_core_seq) + tmp135 := checkDerefVar(var_glojure_DOT_core_concat) + tmp136 := checkDerefVar(var_glojure_DOT_core_list) + tmp137 := lang.Apply(tmp136, []any{sym_glojure_DOT_core_SLASH_fn}) + tmp138 := checkDerefVar(var_glojure_DOT_core_list) + tmp139 := checkDerefVar(var_glojure_DOT_core_apply) + tmp140 := checkDerefVar(var_glojure_DOT_core_vector) + tmp141 := checkDerefVar(var_glojure_DOT_core_seq) + tmp142 := checkDerefVar(var_glojure_DOT_core_concat) + tmp143 := checkDerefVar(var_glojure_DOT_core_list) + tmp144 := lang.Apply(tmp143, []any{sym_this}) + tmp145 := checkDerefVar(var_glojure_DOT_core_list) + tmp146 := lang.Apply(tmp145, []any{sym__AMP_}) + tmp147 := checkDerefVar(var_glojure_DOT_core_list) + tmp148 := lang.Apply(tmp147, []any{sym_args}) + tmp149 := lang.Apply(tmp142, []any{tmp144, tmp146, tmp148}) + tmp150 := lang.Apply(tmp141, []any{tmp149}) + tmp151 := lang.Apply(tmp139, []any{tmp140, tmp150}) + tmp152 := lang.Apply(tmp138, []any{tmp151}) + tmp153 := checkDerefVar(var_glojure_DOT_core_list) + tmp154 := checkDerefVar(var_glojure_DOT_core_seq) + tmp155 := checkDerefVar(var_glojure_DOT_core_concat) + tmp156 := checkDerefVar(var_glojure_DOT_core_list) + tmp157 := lang.Apply(tmp156, []any{sym_glojure_DOT_core_SLASH_class}) + tmp158 := checkDerefVar(var_glojure_DOT_core_list) + tmp159 := lang.Apply(tmp158, []any{sym_this}) + tmp160 := lang.Apply(tmp155, []any{tmp157, tmp159}) + tmp161 := lang.Apply(tmp154, []any{tmp160}) + tmp162 := lang.Apply(tmp153, []any{tmp161}) + tmp163 := lang.Apply(tmp135, []any{tmp137, tmp152, tmp162}) + tmp164 := lang.Apply(tmp134, []any{tmp163}) + tmp165 := lang.Apply(tmp133, []any{tmp164}) + tmp166 := lang.Apply(tmp126, []any{tmp128, tmp132, tmp165}) + tmp167 := lang.Apply(tmp125, []any{tmp166}) + tmp168 := lang.Apply(tmp124, []any{tmp167}) + tmp169 := checkDerefVar(var_glojure_DOT_core_list) + tmp170 := checkDerefVar(var_glojure_DOT_core_seq) + tmp171 := checkDerefVar(var_glojure_DOT_core_concat) + tmp172 := checkDerefVar(var_glojure_DOT_core_list) + tmp173 := lang.Apply(tmp172, []any{sym_glojure_DOT_core_SLASH_swap_BANG_}) + tmp174 := checkDerefVar(var_glojure_DOT_core_list) + tmp175 := lang.Apply(tmp174, []any{v4}) + tmp176 := checkDerefVar(var_glojure_DOT_core_list) + tmp177 := lang.Apply(tmp176, []any{sym_glojure_DOT_core_SLASH_assoc_DASH_in}) + tmp178 := checkDerefVar(var_glojure_DOT_core_list) + tmp179 := checkDerefVar(var_glojure_DOT_core_apply) + tmp180 := checkDerefVar(var_glojure_DOT_core_vector) + tmp181 := checkDerefVar(var_glojure_DOT_core_seq) + tmp182 := checkDerefVar(var_glojure_DOT_core_concat) + tmp183 := checkDerefVar(var_glojure_DOT_core_list) + tmp184 := lang.Apply(tmp183, []any{kw_multis}) + tmp185 := checkDerefVar(var_glojure_DOT_core_list) + tmp186 := checkDerefVar(var_glojure_DOT_core_seq) + tmp187 := checkDerefVar(var_glojure_DOT_core_concat) + tmp188 := checkDerefVar(var_glojure_DOT_core_list) + tmp189 := lang.Apply(tmp188, []any{sym_glojure_DOT_core_SLASH_keyword}) + tmp190 := checkDerefVar(var_glojure_DOT_core_list) + tmp191 := checkDerefVar(var_glojure_DOT_core_seq) + tmp192 := checkDerefVar(var_glojure_DOT_core_concat) + tmp193 := checkDerefVar(var_glojure_DOT_core_list) + tmp194 := lang.Apply(tmp193, []any{sym_quote}) + tmp195 := checkDerefVar(var_glojure_DOT_core_list) + tmp196 := checkDerefVar(var_glojure_DOT_core_first) + tmp197 := lang.Apply(tmp196, []any{v119}) + tmp198 := lang.Apply(tmp195, []any{tmp197}) + tmp199 := lang.Apply(tmp192, []any{tmp194, tmp198}) + tmp200 := lang.Apply(tmp191, []any{tmp199}) + tmp201 := lang.Apply(tmp190, []any{tmp200}) + tmp202 := lang.Apply(tmp187, []any{tmp189, tmp201}) + tmp203 := lang.Apply(tmp186, []any{tmp202}) + tmp204 := lang.Apply(tmp185, []any{tmp203}) + tmp205 := lang.Apply(tmp182, []any{tmp184, tmp204}) + tmp206 := lang.Apply(tmp181, []any{tmp205}) + tmp207 := lang.Apply(tmp179, []any{tmp180, tmp206}) + tmp208 := lang.Apply(tmp178, []any{tmp207}) + tmp209 := checkDerefVar(var_glojure_DOT_core_list) + tmp210 := checkDerefVar(var_glojure_DOT_core_first) + tmp211 := lang.Apply(tmp210, []any{v119}) + tmp212 := lang.Apply(tmp209, []any{tmp211}) + tmp213 := lang.Apply(tmp171, []any{tmp173, tmp175, tmp177, tmp208, tmp212}) + tmp214 := lang.Apply(tmp170, []any{tmp213}) + tmp215 := lang.Apply(tmp169, []any{tmp214}) + tmp216 := lang.Apply(tmp121, []any{tmp123, tmp168, tmp215}) + tmp217 := lang.Apply(tmp120, []any{tmp216}) + return tmp217 + }) + tmp119 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(102), kw_column, int(13), kw_end_DASH_line, int(104), kw_end_DASH_column, int(90)) + tmp120, err := lang.WithMeta(tmp118, tmp119.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp121 := lang.Apply(tmp117, []any{tmp120, v30}) + tmp122 := checkDerefVar(var_glojure_DOT_core_list) + tmp123 := checkDerefVar(var_glojure_DOT_core_seq) + tmp124 := checkDerefVar(var_glojure_DOT_core_concat) + tmp125 := checkDerefVar(var_glojure_DOT_core_list) + tmp126 := lang.Apply(tmp125, []any{sym_var}) + tmp127 := checkDerefVar(var_glojure_DOT_core_list) + tmp128 := lang.Apply(tmp127, []any{v4}) + tmp129 := lang.Apply(tmp124, []any{tmp126, tmp128}) + tmp130 := lang.Apply(tmp123, []any{tmp129}) + tmp131 := lang.Apply(tmp122, []any{tmp130}) + tmp132 := lang.Apply(tmp36, []any{tmp38, tmp92, tmp116, tmp121, tmp131}) + tmp133 := lang.Apply(tmp35, []any{tmp132}) + tmp6 = tmp133 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_defprotocol = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_defprotocol.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // distinct? + { + tmp1 := reflect.TypeOf(false) + tmp0 := sym_distinct_QMARK_.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym_y), lang.NewVector(sym_x, sym_y, sym__AMP_, sym_more)), kw_doc, "Returns true if no two of the arguments are =", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(5664), kw_end_DASH_line, int(5664))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v3 := args[0] + _ = v3 + return true + case 2: + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_not) + tmp6 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp7 := lang.Apply(tmp6, []any{v3, v4}) + tmp8 := lang.Apply(tmp5, []any{tmp7}) + return tmp8 + default: + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var v5 any = lang.NewList(args[2:]...) + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_not_EQ_) + tmp8 := lang.Apply(tmp7, []any{v3, v4}) + if lang.IsTruthy(tmp8) { + var tmp9 any + { // let + // let binding "s" + tmp10 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{v3, v4})) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5673), kw_column, int(15), kw_end_DASH_line, int(5673), kw_end_DASH_column, int(20)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v13 any = tmp12 + _ = v13 + // let binding "G__790" + var v14 any = v5 + _ = v14 + // let binding "vec__791" + var v15 any = v14 + _ = v15 + // let binding "seq__792" + tmp16 := checkDerefVar(var_glojure_DOT_core_seq) + tmp17 := lang.Apply(tmp16, []any{v15}) + var v18 any = tmp17 + _ = v18 + // let binding "first__793" + tmp19 := checkDerefVar(var_glojure_DOT_core_first) + tmp20 := lang.Apply(tmp19, []any{v18}) + var v21 any = tmp20 + _ = v21 + // let binding "seq__792" + tmp22 := checkDerefVar(var_glojure_DOT_core_next) + tmp23 := lang.Apply(tmp22, []any{v18}) + var v24 any = tmp23 + _ = v24 + // let binding "x" + var v25 any = v21 + _ = v25 + // let binding "etc" + var v26 any = v24 + _ = v26 + // let binding "xs" + var v27 any = v15 + _ = v27 + var tmp28 any + { // let + // let binding "s" + var v29 any = v13 + _ = v29 + // let binding "G__790" + var v30 any = v14 + _ = v30 + for { + var tmp31 any + { // let + // let binding "s" + var v32 any = v29 + _ = v32 + // let binding "vec__794" + var v33 any = v30 + _ = v33 + // let binding "seq__795" + tmp34 := checkDerefVar(var_glojure_DOT_core_seq) + tmp35 := lang.Apply(tmp34, []any{v33}) + var v36 any = tmp35 + _ = v36 + // let binding "first__796" + tmp37 := checkDerefVar(var_glojure_DOT_core_first) + tmp38 := lang.Apply(tmp37, []any{v36}) + var v39 any = tmp38 + _ = v39 + // let binding "seq__795" + tmp40 := checkDerefVar(var_glojure_DOT_core_next) + tmp41 := lang.Apply(tmp40, []any{v36}) + var v42 any = tmp41 + _ = v42 + // let binding "x" + var v43 any = v39 + _ = v43 + // let binding "etc" + var v44 any = v42 + _ = v44 + // let binding "xs" + var v45 any = v33 + _ = v45 + var tmp46 any + if lang.IsTruthy(v45) { + var tmp47 any + tmp48 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp49 := lang.Apply(tmp48, []any{v32, v43}) + if lang.IsTruthy(tmp49) { + tmp47 = false + } else { + tmp51 := checkDerefVar(var_glojure_DOT_core_conj) + tmp52 := lang.Apply(tmp51, []any{v32, v43}) + var tmp50 any = tmp52 + var tmp53 any = v44 + v29 = tmp50 + v30 = tmp53 + continue + } + tmp46 = tmp47 + } else { + tmp46 = true + } + tmp31 = tmp46 + } // end let + tmp28 = tmp31 + break + } + } // end let + tmp9 = tmp28 + } // end let + tmp6 = tmp9 + } else { + tmp6 = false + } + return tmp6 + } + }) + tmp3 := reflect.TypeOf(false) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_distinct_QMARK_ = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_distinct_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // doall + { + tmp0 := sym_doall.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll), lang.NewVector(sym_n, sym_coll)), kw_doc, "When lazy sequences are produced via functions that have side\n effects, any effects other than those needed to produce the first\n element in the seq do not occur until the seq is consumed. doall can\n be used to force any effects. Walks through the successive nexts of\n the seq, retains the head and returns it, thus causing the entire\n seq to reside in memory at one time.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3131), kw_end_DASH_line, int(3131))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_dorun) + tmp4 := lang.Apply(tmp3, []any{v2}) + _ = tmp4 + return v2 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_dorun) + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + _ = tmp5 + return v3 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_doall = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_doall.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // doseq + { + tmp0 := sym_doseq.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_seq_DASH_exprs, sym__AMP_, sym_body)), kw_doc, "Repeatedly executes body (presumably for side-effects) with\n bindings and filtering as provided by \"for\". Does not retain\n the head of the sequence. Returns nil.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(11), kw_line, int(3209), kw_end_DASH_line, int(3209))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v4}) + if lang.IsTruthy(tmp8) { + } else { + tmp9 := checkDerefVar(var_glojure_DOT_core_str) + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp13 := checkDerefVar(var_glojure_DOT_core_meta) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(kw_line, []any{tmp14}) + tmp16 := lang.Apply(tmp9, []any{tmp11, " requires ", "a vector for its binding", " in ", tmp12, ":", tmp15}) + tmp17 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp16}) + panic(tmp17) + } + _ = tmp6 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_even_QMARK_) + tmp20 := checkDerefVar(var_glojure_DOT_core_count) + tmp21 := lang.Apply(tmp20, []any{v4}) + tmp22 := lang.Apply(tmp19, []any{tmp21}) + if lang.IsTruthy(tmp22) { + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp27 := checkDerefVar(var_glojure_DOT_core_meta) + tmp28 := lang.Apply(tmp27, []any{v2}) + tmp29 := lang.Apply(kw_line, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp25, " requires ", "an even number of forms in binding vector", " in ", tmp26, ":", tmp29}) + tmp31 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp31) + } + _ = tmp18 + var tmp32 any + { // let + // let binding "step" + var tmp33 lang.FnFunc + { // function step + var v34 lang.FnFunc + tmp33 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v35 := args[0] + _ = v35 + v36 := args[1] + _ = v36 + var tmp37 any + tmp38 := checkDerefVar(var_glojure_DOT_core_not) + tmp39 := lang.Apply(tmp38, []any{v36}) + if lang.IsTruthy(tmp39) { + tmp40 := checkDerefVar(var_glojure_DOT_core_seq) + tmp41 := checkDerefVar(var_glojure_DOT_core_concat) + tmp42 := checkDerefVar(var_glojure_DOT_core_list) + tmp43 := lang.Apply(tmp42, []any{sym_do}) + tmp44 := lang.Apply(tmp41, []any{tmp43, v5}) + tmp45 := lang.Apply(tmp40, []any{tmp44}) + tmp46 := lang.NewVector(true, tmp45) + tmp47 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3220), kw_column, int(18), kw_end_DASH_line, int(3220), kw_end_DASH_column, int(36)) + tmp48, err := lang.WithMeta(tmp46, tmp47.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp37 = tmp48 + } else { + var tmp49 any + { // let + // let binding "k" + tmp50 := checkDerefVar(var_glojure_DOT_core_first) + tmp51 := lang.Apply(tmp50, []any{v36}) + var v52 any = tmp51 + _ = v52 + // let binding "v" + tmp53 := checkDerefVar(var_glojure_DOT_core_second) + tmp54 := lang.Apply(tmp53, []any{v36}) + var v55 any = tmp54 + _ = v55 + var tmp56 any + tmp57 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp58 := lang.Apply(tmp57, []any{v52}) + if lang.IsTruthy(tmp58) { + var tmp59 any + { // let + // let binding "steppair" + tmp60 := checkDerefVar(var_glojure_DOT_core_nnext) + tmp61 := lang.Apply(tmp60, []any{v36}) + tmp62 := lang.Apply(v34, []any{v35, tmp61}) + var v63 any = tmp62 + _ = v63 + // let binding "needrec" + tmp64 := lang.Apply(v63, []any{int64(0)}) + var v65 any = tmp64 + _ = v65 + // let binding "subform" + tmp66 := lang.Apply(v63, []any{int64(1)}) + var v67 any = tmp66 + _ = v67 + var tmp68 any + tmp69 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp70 := lang.Apply(tmp69, []any{v52, kw_let}) + if lang.IsTruthy(tmp70) { + tmp71 := checkDerefVar(var_glojure_DOT_core_seq) + tmp72 := checkDerefVar(var_glojure_DOT_core_concat) + tmp73 := checkDerefVar(var_glojure_DOT_core_list) + tmp74 := lang.Apply(tmp73, []any{sym_glojure_DOT_core_SLASH_let}) + tmp75 := checkDerefVar(var_glojure_DOT_core_list) + tmp76 := lang.Apply(tmp75, []any{v55}) + tmp77 := checkDerefVar(var_glojure_DOT_core_list) + tmp78 := lang.Apply(tmp77, []any{v67}) + tmp79 := lang.Apply(tmp72, []any{tmp74, tmp76, tmp78}) + tmp80 := lang.Apply(tmp71, []any{tmp79}) + tmp81 := lang.NewVector(v65, tmp80) + tmp82 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3228), kw_column, int(37), kw_end_DASH_line, int(3228), kw_end_DASH_column, int(64)) + tmp83, err := lang.WithMeta(tmp81, tmp82.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp68 = tmp83 + } else { + var tmp84 any + tmp85 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp86 := lang.Apply(tmp85, []any{v52, kw_while}) + if lang.IsTruthy(tmp86) { + tmp87 := checkDerefVar(var_glojure_DOT_core_seq) + tmp88 := checkDerefVar(var_glojure_DOT_core_concat) + tmp89 := checkDerefVar(var_glojure_DOT_core_list) + tmp90 := lang.Apply(tmp89, []any{sym_glojure_DOT_core_SLASH_when}) + tmp91 := checkDerefVar(var_glojure_DOT_core_list) + tmp92 := lang.Apply(tmp91, []any{v55}) + tmp93 := checkDerefVar(var_glojure_DOT_core_list) + tmp94 := lang.Apply(tmp93, []any{v67}) + var tmp95 any + if lang.IsTruthy(v65) { + tmp96 := lang.NewVector(v35) + tmp97 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3231), kw_column, int(65), kw_end_DASH_line, int(3231), kw_end_DASH_column, int(73)) + tmp98, err := lang.WithMeta(tmp96, tmp97.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp95 = tmp98 + } else { + } + tmp99 := lang.Apply(tmp88, []any{tmp90, tmp92, tmp94, tmp95}) + tmp100 := lang.Apply(tmp87, []any{tmp99}) + tmp101 := lang.NewVector(false, tmp100) + tmp102 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3229), kw_column, int(39), kw_end_DASH_line, int(3231), kw_end_DASH_column, int(76)) + tmp103, err := lang.WithMeta(tmp101, tmp102.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp84 = tmp103 + } else { + var tmp104 any + tmp105 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp106 := lang.Apply(tmp105, []any{v52, kw_when}) + if lang.IsTruthy(tmp106) { + tmp107 := checkDerefVar(var_glojure_DOT_core_seq) + tmp108 := checkDerefVar(var_glojure_DOT_core_concat) + tmp109 := checkDerefVar(var_glojure_DOT_core_list) + tmp110 := lang.Apply(tmp109, []any{sym_if}) + tmp111 := checkDerefVar(var_glojure_DOT_core_list) + tmp112 := lang.Apply(tmp111, []any{v55}) + tmp113 := checkDerefVar(var_glojure_DOT_core_list) + tmp114 := checkDerefVar(var_glojure_DOT_core_seq) + tmp115 := checkDerefVar(var_glojure_DOT_core_concat) + tmp116 := checkDerefVar(var_glojure_DOT_core_list) + tmp117 := lang.Apply(tmp116, []any{sym_do}) + tmp118 := checkDerefVar(var_glojure_DOT_core_list) + tmp119 := lang.Apply(tmp118, []any{v67}) + var tmp120 any + if lang.IsTruthy(v65) { + tmp121 := lang.NewVector(v35) + tmp122 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3235), kw_column, int(66), kw_end_DASH_line, int(3235), kw_end_DASH_column, int(74)) + tmp123, err := lang.WithMeta(tmp121, tmp122.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp120 = tmp123 + } else { + } + tmp124 := lang.Apply(tmp115, []any{tmp117, tmp119, tmp120}) + tmp125 := lang.Apply(tmp114, []any{tmp124}) + tmp126 := lang.Apply(tmp113, []any{tmp125}) + tmp127 := checkDerefVar(var_glojure_DOT_core_list) + tmp128 := lang.Apply(tmp127, []any{v35}) + tmp129 := lang.Apply(tmp108, []any{tmp110, tmp112, tmp126, tmp128}) + tmp130 := lang.Apply(tmp107, []any{tmp129}) + tmp131 := lang.NewVector(false, tmp130) + tmp132 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3232), kw_column, int(38), kw_end_DASH_line, int(3236), kw_end_DASH_column, int(57)) + tmp133, err := lang.WithMeta(tmp131, tmp132.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp104 = tmp133 + } else { + } + tmp84 = tmp104 + } + tmp68 = tmp84 + } + tmp59 = tmp68 + } // end let + tmp56 = tmp59 + } else { + var tmp60 any + { // let + // let binding "seq-" + tmp61 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp62 := lang.Apply(tmp61, []any{"seq_"}) + var v63 any = tmp62 + _ = v63 + // let binding "chunk-" + tmp64 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp65 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp66 := lang.Apply(tmp65, []any{"chunk_"}) + tmp67 := lang.NewMap(kw_tag, sym_glojure_DOT_lang_DOT_IChunk) + tmp68 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3239), kw_column, int(46), kw_end_DASH_line, int(3239), kw_end_DASH_column, int(72)) + tmp69, err := lang.WithMeta(tmp67, tmp68.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp70 := lang.Apply(tmp64, []any{tmp66, tmp69}) + var v71 any = tmp70 + _ = v71 + // let binding "count-" + tmp72 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp73 := lang.Apply(tmp72, []any{"count_"}) + var v74 any = tmp73 + _ = v74 + // let binding "i-" + tmp75 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp76 := lang.Apply(tmp75, []any{"i_"}) + var v77 any = tmp76 + _ = v77 + // let binding "recform" + tmp78 := checkDerefVar(var_glojure_DOT_core_seq) + tmp79 := checkDerefVar(var_glojure_DOT_core_concat) + tmp80 := checkDerefVar(var_glojure_DOT_core_list) + tmp81 := lang.Apply(tmp80, []any{sym_recur}) + tmp82 := checkDerefVar(var_glojure_DOT_core_list) + tmp83 := checkDerefVar(var_glojure_DOT_core_seq) + tmp84 := checkDerefVar(var_glojure_DOT_core_concat) + tmp85 := checkDerefVar(var_glojure_DOT_core_list) + tmp86 := lang.Apply(tmp85, []any{sym_glojure_DOT_core_SLASH_next}) + tmp87 := checkDerefVar(var_glojure_DOT_core_list) + tmp88 := lang.Apply(tmp87, []any{v63}) + tmp89 := lang.Apply(tmp84, []any{tmp86, tmp88}) + tmp90 := lang.Apply(tmp83, []any{tmp89}) + tmp91 := lang.Apply(tmp82, []any{tmp90}) + tmp92 := checkDerefVar(var_glojure_DOT_core_list) + tmp93 := lang.Apply(tmp92, []any{nil}) + tmp94 := checkDerefVar(var_glojure_DOT_core_list) + tmp95 := lang.Apply(tmp94, []any{int64(0)}) + tmp96 := checkDerefVar(var_glojure_DOT_core_list) + tmp97 := lang.Apply(tmp96, []any{int64(0)}) + tmp98 := lang.Apply(tmp79, []any{tmp81, tmp91, tmp93, tmp95, tmp97}) + tmp99 := lang.Apply(tmp78, []any{tmp98}) + var v100 any = tmp99 + _ = v100 + // let binding "steppair" + tmp101 := checkDerefVar(var_glojure_DOT_core_nnext) + tmp102 := lang.Apply(tmp101, []any{v36}) + tmp103 := lang.Apply(v34, []any{v100, tmp102}) + var v104 any = tmp103 + _ = v104 + // let binding "needrec" + tmp105 := lang.Apply(v104, []any{int64(0)}) + var v106 any = tmp105 + _ = v106 + // let binding "subform" + tmp107 := lang.Apply(v104, []any{int64(1)}) + var v108 any = tmp107 + _ = v108 + // let binding "recform-chunk" + tmp109 := checkDerefVar(var_glojure_DOT_core_seq) + tmp110 := checkDerefVar(var_glojure_DOT_core_concat) + tmp111 := checkDerefVar(var_glojure_DOT_core_list) + tmp112 := lang.Apply(tmp111, []any{sym_recur}) + tmp113 := checkDerefVar(var_glojure_DOT_core_list) + tmp114 := lang.Apply(tmp113, []any{v63}) + tmp115 := checkDerefVar(var_glojure_DOT_core_list) + tmp116 := lang.Apply(tmp115, []any{v71}) + tmp117 := checkDerefVar(var_glojure_DOT_core_list) + tmp118 := lang.Apply(tmp117, []any{v74}) + tmp119 := checkDerefVar(var_glojure_DOT_core_list) + tmp120 := checkDerefVar(var_glojure_DOT_core_seq) + tmp121 := checkDerefVar(var_glojure_DOT_core_concat) + tmp122 := checkDerefVar(var_glojure_DOT_core_list) + tmp123 := lang.Apply(tmp122, []any{sym_glojure_DOT_core_SLASH_unchecked_DASH_inc}) + tmp124 := checkDerefVar(var_glojure_DOT_core_list) + tmp125 := lang.Apply(tmp124, []any{v77}) + tmp126 := lang.Apply(tmp121, []any{tmp123, tmp125}) + tmp127 := lang.Apply(tmp120, []any{tmp126}) + tmp128 := lang.Apply(tmp119, []any{tmp127}) + tmp129 := lang.Apply(tmp110, []any{tmp112, tmp114, tmp116, tmp118, tmp128}) + tmp130 := lang.Apply(tmp109, []any{tmp129}) + var v131 any = tmp130 + _ = v131 + // let binding "steppair-chunk" + tmp132 := checkDerefVar(var_glojure_DOT_core_nnext) + tmp133 := lang.Apply(tmp132, []any{v36}) + tmp134 := lang.Apply(v34, []any{v131, tmp133}) + var v135 any = tmp134 + _ = v135 + // let binding "subform-chunk" + tmp136 := lang.Apply(v135, []any{int64(1)}) + var v137 any = tmp136 + _ = v137 + tmp138 := checkDerefVar(var_glojure_DOT_core_seq) + tmp139 := checkDerefVar(var_glojure_DOT_core_concat) + tmp140 := checkDerefVar(var_glojure_DOT_core_list) + tmp141 := lang.Apply(tmp140, []any{sym_glojure_DOT_core_SLASH_loop}) + tmp142 := checkDerefVar(var_glojure_DOT_core_list) + tmp143 := checkDerefVar(var_glojure_DOT_core_apply) + tmp144 := checkDerefVar(var_glojure_DOT_core_vector) + tmp145 := checkDerefVar(var_glojure_DOT_core_seq) + tmp146 := checkDerefVar(var_glojure_DOT_core_concat) + tmp147 := checkDerefVar(var_glojure_DOT_core_list) + tmp148 := lang.Apply(tmp147, []any{v63}) + tmp149 := checkDerefVar(var_glojure_DOT_core_list) + tmp150 := checkDerefVar(var_glojure_DOT_core_seq) + tmp151 := checkDerefVar(var_glojure_DOT_core_concat) + tmp152 := checkDerefVar(var_glojure_DOT_core_list) + tmp153 := lang.Apply(tmp152, []any{sym_glojure_DOT_core_SLASH_seq}) + tmp154 := checkDerefVar(var_glojure_DOT_core_list) + tmp155 := lang.Apply(tmp154, []any{v55}) + tmp156 := lang.Apply(tmp151, []any{tmp153, tmp155}) + tmp157 := lang.Apply(tmp150, []any{tmp156}) + tmp158 := lang.Apply(tmp149, []any{tmp157}) + tmp159 := checkDerefVar(var_glojure_DOT_core_list) + tmp160 := lang.Apply(tmp159, []any{v71}) + tmp161 := checkDerefVar(var_glojure_DOT_core_list) + tmp162 := lang.Apply(tmp161, []any{nil}) + tmp163 := checkDerefVar(var_glojure_DOT_core_list) + tmp164 := lang.Apply(tmp163, []any{v74}) + tmp165 := checkDerefVar(var_glojure_DOT_core_list) + tmp166 := lang.Apply(tmp165, []any{int64(0)}) + tmp167 := checkDerefVar(var_glojure_DOT_core_list) + tmp168 := lang.Apply(tmp167, []any{v77}) + tmp169 := checkDerefVar(var_glojure_DOT_core_list) + tmp170 := lang.Apply(tmp169, []any{int64(0)}) + tmp171 := lang.Apply(tmp146, []any{tmp148, tmp158, tmp160, tmp162, tmp164, tmp166, tmp168, tmp170}) + tmp172 := lang.Apply(tmp145, []any{tmp171}) + tmp173 := lang.Apply(tmp143, []any{tmp144, tmp172}) + tmp174 := lang.Apply(tmp142, []any{tmp173}) + tmp175 := checkDerefVar(var_glojure_DOT_core_list) + tmp176 := checkDerefVar(var_glojure_DOT_core_seq) + tmp177 := checkDerefVar(var_glojure_DOT_core_concat) + tmp178 := checkDerefVar(var_glojure_DOT_core_list) + tmp179 := lang.Apply(tmp178, []any{sym_if}) + tmp180 := checkDerefVar(var_glojure_DOT_core_list) + tmp181 := checkDerefVar(var_glojure_DOT_core_seq) + tmp182 := checkDerefVar(var_glojure_DOT_core_concat) + tmp183 := checkDerefVar(var_glojure_DOT_core_list) + tmp184 := lang.Apply(tmp183, []any{sym_glojure_DOT_core_SLASH__LT_}) + tmp185 := checkDerefVar(var_glojure_DOT_core_list) + tmp186 := lang.Apply(tmp185, []any{v77}) + tmp187 := checkDerefVar(var_glojure_DOT_core_list) + tmp188 := lang.Apply(tmp187, []any{v74}) + tmp189 := lang.Apply(tmp182, []any{tmp184, tmp186, tmp188}) + tmp190 := lang.Apply(tmp181, []any{tmp189}) + tmp191 := lang.Apply(tmp180, []any{tmp190}) + tmp192 := checkDerefVar(var_glojure_DOT_core_list) + tmp193 := checkDerefVar(var_glojure_DOT_core_seq) + tmp194 := checkDerefVar(var_glojure_DOT_core_concat) + tmp195 := checkDerefVar(var_glojure_DOT_core_list) + tmp196 := lang.Apply(tmp195, []any{sym_glojure_DOT_core_SLASH_let}) + tmp197 := checkDerefVar(var_glojure_DOT_core_list) + tmp198 := checkDerefVar(var_glojure_DOT_core_apply) + tmp199 := checkDerefVar(var_glojure_DOT_core_vector) + tmp200 := checkDerefVar(var_glojure_DOT_core_seq) + tmp201 := checkDerefVar(var_glojure_DOT_core_concat) + tmp202 := checkDerefVar(var_glojure_DOT_core_list) + tmp203 := lang.Apply(tmp202, []any{v52}) + tmp204 := checkDerefVar(var_glojure_DOT_core_list) + tmp205 := checkDerefVar(var_glojure_DOT_core_seq) + tmp206 := checkDerefVar(var_glojure_DOT_core_concat) + tmp207 := checkDerefVar(var_glojure_DOT_core_list) + tmp208 := lang.Apply(tmp207, []any{sym__DOT_nth}) + tmp209 := checkDerefVar(var_glojure_DOT_core_list) + tmp210 := lang.Apply(tmp209, []any{v71}) + tmp211 := checkDerefVar(var_glojure_DOT_core_list) + tmp212 := lang.Apply(tmp211, []any{v77}) + tmp213 := lang.Apply(tmp206, []any{tmp208, tmp210, tmp212}) + tmp214 := lang.Apply(tmp205, []any{tmp213}) + tmp215 := lang.Apply(tmp204, []any{tmp214}) + tmp216 := lang.Apply(tmp201, []any{tmp203, tmp215}) + tmp217 := lang.Apply(tmp200, []any{tmp216}) + tmp218 := lang.Apply(tmp198, []any{tmp199, tmp217}) + tmp219 := lang.Apply(tmp197, []any{tmp218}) + tmp220 := checkDerefVar(var_glojure_DOT_core_list) + tmp221 := lang.Apply(tmp220, []any{v137}) + var tmp222 any + if lang.IsTruthy(v106) { + tmp223 := lang.NewVector(v131) + tmp224 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3256), kw_column, int(48), kw_end_DASH_line, int(3256), kw_end_DASH_column, int(62)) + tmp225, err := lang.WithMeta(tmp223, tmp224.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp222 = tmp225 + } else { + } + tmp226 := lang.Apply(tmp194, []any{tmp196, tmp219, tmp221, tmp222}) + tmp227 := lang.Apply(tmp193, []any{tmp226}) + tmp228 := lang.Apply(tmp192, []any{tmp227}) + tmp229 := checkDerefVar(var_glojure_DOT_core_list) + tmp230 := checkDerefVar(var_glojure_DOT_core_seq) + tmp231 := checkDerefVar(var_glojure_DOT_core_concat) + tmp232 := checkDerefVar(var_glojure_DOT_core_list) + tmp233 := lang.Apply(tmp232, []any{sym_glojure_DOT_core_SLASH_when_DASH_let}) + tmp234 := checkDerefVar(var_glojure_DOT_core_list) + tmp235 := checkDerefVar(var_glojure_DOT_core_apply) + tmp236 := checkDerefVar(var_glojure_DOT_core_vector) + tmp237 := checkDerefVar(var_glojure_DOT_core_seq) + tmp238 := checkDerefVar(var_glojure_DOT_core_concat) + tmp239 := checkDerefVar(var_glojure_DOT_core_list) + tmp240 := lang.Apply(tmp239, []any{v63}) + tmp241 := checkDerefVar(var_glojure_DOT_core_list) + tmp242 := checkDerefVar(var_glojure_DOT_core_seq) + tmp243 := checkDerefVar(var_glojure_DOT_core_concat) + tmp244 := checkDerefVar(var_glojure_DOT_core_list) + tmp245 := lang.Apply(tmp244, []any{sym_glojure_DOT_core_SLASH_seq}) + tmp246 := checkDerefVar(var_glojure_DOT_core_list) + tmp247 := lang.Apply(tmp246, []any{v63}) + tmp248 := lang.Apply(tmp243, []any{tmp245, tmp247}) + tmp249 := lang.Apply(tmp242, []any{tmp248}) + tmp250 := lang.Apply(tmp241, []any{tmp249}) + tmp251 := lang.Apply(tmp238, []any{tmp240, tmp250}) + tmp252 := lang.Apply(tmp237, []any{tmp251}) + tmp253 := lang.Apply(tmp235, []any{tmp236, tmp252}) + tmp254 := lang.Apply(tmp234, []any{tmp253}) + tmp255 := checkDerefVar(var_glojure_DOT_core_list) + tmp256 := checkDerefVar(var_glojure_DOT_core_seq) + tmp257 := checkDerefVar(var_glojure_DOT_core_concat) + tmp258 := checkDerefVar(var_glojure_DOT_core_list) + tmp259 := lang.Apply(tmp258, []any{sym_if}) + tmp260 := checkDerefVar(var_glojure_DOT_core_list) + tmp261 := checkDerefVar(var_glojure_DOT_core_seq) + tmp262 := checkDerefVar(var_glojure_DOT_core_concat) + tmp263 := checkDerefVar(var_glojure_DOT_core_list) + tmp264 := lang.Apply(tmp263, []any{sym_glojure_DOT_core_SLASH_chunked_DASH_seq_QMARK_}) + tmp265 := checkDerefVar(var_glojure_DOT_core_list) + tmp266 := lang.Apply(tmp265, []any{v63}) + tmp267 := lang.Apply(tmp262, []any{tmp264, tmp266}) + tmp268 := lang.Apply(tmp261, []any{tmp267}) + tmp269 := lang.Apply(tmp260, []any{tmp268}) + tmp270 := checkDerefVar(var_glojure_DOT_core_list) + tmp271 := checkDerefVar(var_glojure_DOT_core_seq) + tmp272 := checkDerefVar(var_glojure_DOT_core_concat) + tmp273 := checkDerefVar(var_glojure_DOT_core_list) + tmp274 := lang.Apply(tmp273, []any{sym_glojure_DOT_core_SLASH_let}) + tmp275 := checkDerefVar(var_glojure_DOT_core_list) + tmp276 := checkDerefVar(var_glojure_DOT_core_apply) + tmp277 := checkDerefVar(var_glojure_DOT_core_vector) + tmp278 := checkDerefVar(var_glojure_DOT_core_seq) + tmp279 := checkDerefVar(var_glojure_DOT_core_concat) + tmp280 := checkDerefVar(var_glojure_DOT_core_list) + tmp281 := lang.Apply(tmp280, []any{sym_c__0__auto__}) + tmp282 := checkDerefVar(var_glojure_DOT_core_list) + tmp283 := checkDerefVar(var_glojure_DOT_core_seq) + tmp284 := checkDerefVar(var_glojure_DOT_core_concat) + tmp285 := checkDerefVar(var_glojure_DOT_core_list) + tmp286 := lang.Apply(tmp285, []any{sym_glojure_DOT_core_SLASH_chunk_DASH_first}) + tmp287 := checkDerefVar(var_glojure_DOT_core_list) + tmp288 := lang.Apply(tmp287, []any{v63}) + tmp289 := lang.Apply(tmp284, []any{tmp286, tmp288}) + tmp290 := lang.Apply(tmp283, []any{tmp289}) + tmp291 := lang.Apply(tmp282, []any{tmp290}) + tmp292 := lang.Apply(tmp279, []any{tmp281, tmp291}) + tmp293 := lang.Apply(tmp278, []any{tmp292}) + tmp294 := lang.Apply(tmp276, []any{tmp277, tmp293}) + tmp295 := lang.Apply(tmp275, []any{tmp294}) + tmp296 := checkDerefVar(var_glojure_DOT_core_list) + tmp297 := checkDerefVar(var_glojure_DOT_core_seq) + tmp298 := checkDerefVar(var_glojure_DOT_core_concat) + tmp299 := checkDerefVar(var_glojure_DOT_core_list) + tmp300 := lang.Apply(tmp299, []any{sym_recur}) + tmp301 := checkDerefVar(var_glojure_DOT_core_list) + tmp302 := checkDerefVar(var_glojure_DOT_core_seq) + tmp303 := checkDerefVar(var_glojure_DOT_core_concat) + tmp304 := checkDerefVar(var_glojure_DOT_core_list) + tmp305 := lang.Apply(tmp304, []any{sym_glojure_DOT_core_SLASH_chunk_DASH_rest}) + tmp306 := checkDerefVar(var_glojure_DOT_core_list) + tmp307 := lang.Apply(tmp306, []any{v63}) + tmp308 := lang.Apply(tmp303, []any{tmp305, tmp307}) + tmp309 := lang.Apply(tmp302, []any{tmp308}) + tmp310 := lang.Apply(tmp301, []any{tmp309}) + tmp311 := checkDerefVar(var_glojure_DOT_core_list) + tmp312 := lang.Apply(tmp311, []any{sym_c__0__auto__}) + tmp313 := checkDerefVar(var_glojure_DOT_core_list) + tmp314 := checkDerefVar(var_glojure_DOT_core_seq) + tmp315 := checkDerefVar(var_glojure_DOT_core_concat) + tmp316 := checkDerefVar(var_glojure_DOT_core_list) + tmp317 := lang.Apply(tmp316, []any{sym_glojure_DOT_core_SLASH_int}) + tmp318 := checkDerefVar(var_glojure_DOT_core_list) + tmp319 := checkDerefVar(var_glojure_DOT_core_seq) + tmp320 := checkDerefVar(var_glojure_DOT_core_concat) + tmp321 := checkDerefVar(var_glojure_DOT_core_list) + tmp322 := lang.Apply(tmp321, []any{sym_glojure_DOT_core_SLASH_count}) + tmp323 := checkDerefVar(var_glojure_DOT_core_list) + tmp324 := lang.Apply(tmp323, []any{sym_c__0__auto__}) + tmp325 := lang.Apply(tmp320, []any{tmp322, tmp324}) + tmp326 := lang.Apply(tmp319, []any{tmp325}) + tmp327 := lang.Apply(tmp318, []any{tmp326}) + tmp328 := lang.Apply(tmp315, []any{tmp317, tmp327}) + tmp329 := lang.Apply(tmp314, []any{tmp328}) + tmp330 := lang.Apply(tmp313, []any{tmp329}) + tmp331 := checkDerefVar(var_glojure_DOT_core_list) + tmp332 := checkDerefVar(var_glojure_DOT_core_seq) + tmp333 := checkDerefVar(var_glojure_DOT_core_concat) + tmp334 := checkDerefVar(var_glojure_DOT_core_list) + tmp335 := lang.Apply(tmp334, []any{sym_glojure_DOT_core_SLASH_int}) + tmp336 := checkDerefVar(var_glojure_DOT_core_list) + tmp337 := lang.Apply(tmp336, []any{int64(0)}) + tmp338 := lang.Apply(tmp333, []any{tmp335, tmp337}) + tmp339 := lang.Apply(tmp332, []any{tmp338}) + tmp340 := lang.Apply(tmp331, []any{tmp339}) + tmp341 := lang.Apply(tmp298, []any{tmp300, tmp310, tmp312, tmp330, tmp340}) + tmp342 := lang.Apply(tmp297, []any{tmp341}) + tmp343 := lang.Apply(tmp296, []any{tmp342}) + tmp344 := lang.Apply(tmp272, []any{tmp274, tmp295, tmp343}) + tmp345 := lang.Apply(tmp271, []any{tmp344}) + tmp346 := lang.Apply(tmp270, []any{tmp345}) + tmp347 := checkDerefVar(var_glojure_DOT_core_list) + tmp348 := checkDerefVar(var_glojure_DOT_core_seq) + tmp349 := checkDerefVar(var_glojure_DOT_core_concat) + tmp350 := checkDerefVar(var_glojure_DOT_core_list) + tmp351 := lang.Apply(tmp350, []any{sym_glojure_DOT_core_SLASH_let}) + tmp352 := checkDerefVar(var_glojure_DOT_core_list) + tmp353 := checkDerefVar(var_glojure_DOT_core_apply) + tmp354 := checkDerefVar(var_glojure_DOT_core_vector) + tmp355 := checkDerefVar(var_glojure_DOT_core_seq) + tmp356 := checkDerefVar(var_glojure_DOT_core_concat) + tmp357 := checkDerefVar(var_glojure_DOT_core_list) + tmp358 := lang.Apply(tmp357, []any{v52}) + tmp359 := checkDerefVar(var_glojure_DOT_core_list) + tmp360 := checkDerefVar(var_glojure_DOT_core_seq) + tmp361 := checkDerefVar(var_glojure_DOT_core_concat) + tmp362 := checkDerefVar(var_glojure_DOT_core_list) + tmp363 := lang.Apply(tmp362, []any{sym_glojure_DOT_core_SLASH_first}) + tmp364 := checkDerefVar(var_glojure_DOT_core_list) + tmp365 := lang.Apply(tmp364, []any{v63}) + tmp366 := lang.Apply(tmp361, []any{tmp363, tmp365}) + tmp367 := lang.Apply(tmp360, []any{tmp366}) + tmp368 := lang.Apply(tmp359, []any{tmp367}) + tmp369 := lang.Apply(tmp356, []any{tmp358, tmp368}) + tmp370 := lang.Apply(tmp355, []any{tmp369}) + tmp371 := lang.Apply(tmp353, []any{tmp354, tmp370}) + tmp372 := lang.Apply(tmp352, []any{tmp371}) + tmp373 := checkDerefVar(var_glojure_DOT_core_list) + tmp374 := lang.Apply(tmp373, []any{v108}) + var tmp375 any + if lang.IsTruthy(v106) { + tmp376 := lang.NewVector(v100) + tmp377 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3264), kw_column, int(52), kw_end_DASH_line, int(3264), kw_end_DASH_column, int(60)) + tmp378, err := lang.WithMeta(tmp376, tmp377.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp375 = tmp378 + } else { + } + tmp379 := lang.Apply(tmp349, []any{tmp351, tmp372, tmp374, tmp375}) + tmp380 := lang.Apply(tmp348, []any{tmp379}) + tmp381 := lang.Apply(tmp347, []any{tmp380}) + tmp382 := lang.Apply(tmp257, []any{tmp259, tmp269, tmp346, tmp381}) + tmp383 := lang.Apply(tmp256, []any{tmp382}) + tmp384 := lang.Apply(tmp255, []any{tmp383}) + tmp385 := lang.Apply(tmp231, []any{tmp233, tmp254, tmp384}) + tmp386 := lang.Apply(tmp230, []any{tmp385}) + tmp387 := lang.Apply(tmp229, []any{tmp386}) + tmp388 := lang.Apply(tmp177, []any{tmp179, tmp191, tmp228, tmp387}) + tmp389 := lang.Apply(tmp176, []any{tmp388}) + tmp390 := lang.Apply(tmp175, []any{tmp389}) + tmp391 := lang.Apply(tmp139, []any{tmp141, tmp174, tmp390}) + tmp392 := lang.Apply(tmp138, []any{tmp391}) + tmp393 := lang.NewVector(true, tmp392) + tmp394 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3250), kw_column, int(24), kw_end_DASH_line, int(3264), kw_end_DASH_column, int(67)) + tmp395, err := lang.WithMeta(tmp393, tmp394.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp60 = tmp395 + } // end let + tmp56 = tmp60 + } + tmp49 = tmp56 + } // end let + tmp37 = tmp49 + } + return tmp37 + }) + v34 = tmp33 + _ = v34 + } + tmp34 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3218), kw_column, int(14), kw_end_DASH_line, int(3264), kw_end_DASH_column, int(72)) + tmp35, err := lang.WithMeta(tmp33, tmp34.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v36 any = tmp35 + _ = v36 + tmp37 := checkDerefVar(var_glojure_DOT_core_nth) + tmp38 := checkDerefVar(var_glojure_DOT_core_seq) + tmp39 := lang.Apply(tmp38, []any{v4}) + tmp40 := lang.Apply(v36, []any{nil, tmp39}) + tmp41 := lang.Apply(tmp37, []any{tmp40, int64(1)}) + tmp32 = tmp41 + } // end let + return tmp32 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_doseq = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_doseq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // doto + { + tmp0 := sym_doto.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_x, sym__AMP_, sym_forms)), kw_doc, "Evaluates x then calls all of the methods and functions with the\n value of x supplied at the front of the given arguments. The forms\n are evaluated in order. Returns x.\n\n (doto (new java.util.HashMap) (.put \"a\" 1) (.put \"b\" 2))", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(11), kw_line, int(3853), kw_end_DASH_line, int(3853))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "gx" + tmp7 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp8 := lang.Apply(tmp7, nil) + var v9 any = tmp8 + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_seq) + tmp11 := checkDerefVar(var_glojure_DOT_core_concat) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_glojure_DOT_core_SLASH_let}) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := checkDerefVar(var_glojure_DOT_core_apply) + tmp16 := checkDerefVar(var_glojure_DOT_core_vector) + tmp17 := checkDerefVar(var_glojure_DOT_core_seq) + tmp18 := checkDerefVar(var_glojure_DOT_core_concat) + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{v9}) + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v4}) + tmp23 := lang.Apply(tmp18, []any{tmp20, tmp22}) + tmp24 := lang.Apply(tmp17, []any{tmp23}) + tmp25 := lang.Apply(tmp15, []any{tmp16, tmp24}) + tmp26 := lang.Apply(tmp14, []any{tmp25}) + tmp27 := checkDerefVar(var_glojure_DOT_core_map) + var tmp28 lang.FnFunc + tmp28 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v29 := args[0] + _ = v29 + tmp30 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + var tmp31 any + tmp32 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp33 := lang.Apply(tmp32, []any{v29}) + if lang.IsTruthy(tmp33) { + tmp34 := checkDerefVar(var_glojure_DOT_core_seq) + tmp35 := checkDerefVar(var_glojure_DOT_core_concat) + tmp36 := checkDerefVar(var_glojure_DOT_core_list) + tmp37 := checkDerefVar(var_glojure_DOT_core_first) + tmp38 := lang.Apply(tmp37, []any{v29}) + tmp39 := lang.Apply(tmp36, []any{tmp38}) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{v9}) + tmp42 := checkDerefVar(var_glojure_DOT_core_next) + tmp43 := lang.Apply(tmp42, []any{v29}) + tmp44 := lang.Apply(tmp35, []any{tmp39, tmp41, tmp43}) + tmp45 := lang.Apply(tmp34, []any{tmp44}) + tmp31 = tmp45 + } else { + tmp46 := checkDerefVar(var_glojure_DOT_core_seq) + tmp47 := checkDerefVar(var_glojure_DOT_core_concat) + tmp48 := checkDerefVar(var_glojure_DOT_core_list) + tmp49 := lang.Apply(tmp48, []any{v29}) + tmp50 := checkDerefVar(var_glojure_DOT_core_list) + tmp51 := lang.Apply(tmp50, []any{v9}) + tmp52 := lang.Apply(tmp47, []any{tmp49, tmp51}) + tmp53 := lang.Apply(tmp46, []any{tmp52}) + tmp31 = tmp53 + } + tmp54 := checkDerefVar(var_glojure_DOT_core_meta) + tmp55 := lang.Apply(tmp54, []any{v29}) + tmp56 := lang.Apply(tmp30, []any{tmp31, tmp55}) + return tmp56 + }) + tmp29 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3863), kw_column, int(17), kw_end_DASH_line, int(3868), kw_end_DASH_column, int(30)) + tmp30, err := lang.WithMeta(tmp28, tmp29.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp31 := lang.Apply(tmp27, []any{tmp30, v5}) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := lang.Apply(tmp32, []any{v9}) + tmp34 := lang.Apply(tmp11, []any{tmp13, tmp26, tmp31, tmp33}) + tmp35 := lang.Apply(tmp10, []any{tmp34}) + tmp6 = tmp35 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_doto = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_doto.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // drop-last + { + tmp0 := sym_drop_DASH_last.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll), lang.NewVector(sym_n, sym_coll)), kw_doc, "Return a lazy sequence of all but the last n (default 1) items in coll", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(2932), kw_end_DASH_line, int(2932))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_drop_DASH_last) + tmp4 := lang.Apply(tmp3, []any{int64(1), v2}) + return tmp4 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_map) + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + return v6 + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2937), kw_column, int(18), kw_end_DASH_line, int(2937), kw_end_DASH_column, int(29)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp8 := checkDerefVar(var_glojure_DOT_core_drop) + tmp9 := lang.Apply(tmp8, []any{v2, v3}) + tmp10 := lang.Apply(tmp4, []any{tmp7, v3, tmp9}) + return tmp10 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_drop_DASH_last = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_drop_DASH_last.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // emit-extend-protocol + { + tmp0 := sym_emit_DASH_extend_DASH_protocol.WithMeta(lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(205), kw_column, int(8), kw_end_DASH_line, int(205), kw_end_DASH_column, int(27), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_p, sym_specs)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "impls" + tmp5 := checkDerefVar(var_glojure_DOT_core_parse_DASH_impls) + tmp6 := lang.Apply(tmp5, []any{v3}) + var v7 any = tmp6 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_do}) + tmp12 := checkDerefVar(var_glojure_DOT_core_map) + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v14 := args[0] + _ = v14 + var tmp15 any + { // let + // let binding "vec__657" + var v16 any = v14 + _ = v16 + // let binding "t" + tmp17 := checkDerefVar(var_glojure_DOT_core_nth) + tmp18 := lang.Apply(tmp17, []any{v16, int64(0), nil}) + var v19 any = tmp18 + _ = v19 + // let binding "fs" + tmp20 := checkDerefVar(var_glojure_DOT_core_nth) + tmp21 := lang.Apply(tmp20, []any{v16, int64(1), nil}) + var v22 any = tmp21 + _ = v22 + tmp23 := checkDerefVar(var_glojure_DOT_core_seq) + tmp24 := checkDerefVar(var_glojure_DOT_core_concat) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := lang.Apply(tmp25, []any{sym_glojure_DOT_core_SLASH_extend_DASH_type}) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{v19}) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{v2}) + tmp31 := lang.Apply(tmp24, []any{tmp26, tmp28, tmp30, v22}) + tmp32 := lang.Apply(tmp23, []any{tmp31}) + tmp15 = tmp32 + } // end let + return tmp15 + }) + tmp14 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(208), kw_column, int(15), kw_end_DASH_line, int(209), kw_end_DASH_column, int(42)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp16 := lang.Apply(tmp12, []any{tmp15, v7}) + tmp17 := lang.Apply(tmp9, []any{tmp11, tmp16}) + tmp18 := lang.Apply(tmp8, []any{tmp17}) + tmp4 = tmp18 + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_emit_DASH_extend_DASH_protocol = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_emit_DASH_extend_DASH_protocol.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // emit-hinted-impl + { + tmp0 := sym_emit_DASH_hinted_DASH_impl.WithMeta(lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(163), kw_column, int(8), kw_end_DASH_line, int(163), kw_end_DASH_column, int(23), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_c, lang.NewVector(sym_p, sym_fs))), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "vec__646" + var v5 any = v3 + _ = v5 + // let binding "p" + tmp6 := checkDerefVar(var_glojure_DOT_core_nth) + tmp7 := lang.Apply(tmp6, []any{v5, int64(0), nil}) + var v8 any = tmp7 + _ = v8 + // let binding "fs" + tmp9 := checkDerefVar(var_glojure_DOT_core_nth) + tmp10 := lang.Apply(tmp9, []any{v5, int64(1), nil}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + { // let + // let binding "hint" + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v14 := args[0] + _ = v14 + var tmp15 any + { // let + // let binding "specs" + var tmp16 any + tmp17 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp18 := checkDerefVar(var_glojure_DOT_core_first) + tmp19 := lang.Apply(tmp18, []any{v14}) + tmp20 := lang.Apply(tmp17, []any{tmp19}) + if lang.IsTruthy(tmp20) { + tmp21 := checkDerefVar(var_glojure_DOT_core_list) + tmp22 := lang.Apply(tmp21, []any{v14}) + tmp16 = tmp22 + } else { + tmp16 = v14 + } + var v23 any = tmp16 + _ = v23 + tmp24 := checkDerefVar(var_glojure_DOT_core_map) + var tmp25 lang.FnFunc + tmp25 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v26 := args[0] + _ = v26 + var tmp27 any + { // let + // let binding "vec__650" + var v28 any = v26 + _ = v28 + // let binding "seq__651" + tmp29 := checkDerefVar(var_glojure_DOT_core_seq) + tmp30 := lang.Apply(tmp29, []any{v28}) + var v31 any = tmp30 + _ = v31 + // let binding "first__652" + tmp32 := checkDerefVar(var_glojure_DOT_core_first) + tmp33 := lang.Apply(tmp32, []any{v31}) + var v34 any = tmp33 + _ = v34 + // let binding "seq__651" + tmp35 := checkDerefVar(var_glojure_DOT_core_next) + tmp36 := lang.Apply(tmp35, []any{v31}) + var v37 any = tmp36 + _ = v37 + // let binding "vec__653" + var v38 any = v34 + _ = v38 + // let binding "seq__654" + tmp39 := checkDerefVar(var_glojure_DOT_core_seq) + tmp40 := lang.Apply(tmp39, []any{v38}) + var v41 any = tmp40 + _ = v41 + // let binding "first__655" + tmp42 := checkDerefVar(var_glojure_DOT_core_first) + tmp43 := lang.Apply(tmp42, []any{v41}) + var v44 any = tmp43 + _ = v44 + // let binding "seq__654" + tmp45 := checkDerefVar(var_glojure_DOT_core_next) + tmp46 := lang.Apply(tmp45, []any{v41}) + var v47 any = tmp46 + _ = v47 + // let binding "target" + var v48 any = v44 + _ = v48 + // let binding "args" + var v49 any = v47 + _ = v49 + // let binding "body" + var v50 any = v37 + _ = v50 + tmp51 := checkDerefVar(var_glojure_DOT_core_cons) + tmp52 := checkDerefVar(var_glojure_DOT_core_apply) + tmp53 := checkDerefVar(var_glojure_DOT_core_vector) + tmp54 := checkDerefVar(var_glojure_DOT_core_vary_DASH_meta) + tmp55 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp56 := lang.Apply(tmp54, []any{v48, tmp55, kw_tag, v2}) + tmp57 := lang.Apply(tmp52, []any{tmp53, tmp56, v49}) + tmp58 := lang.Apply(tmp51, []any{tmp57, v50}) + tmp27 = tmp58 + } // end let + return tmp27 + }) + tmp26 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(168), kw_column, int(23), kw_end_DASH_line, int(170), kw_end_DASH_column, int(36)) + tmp27, err := lang.WithMeta(tmp25, tmp26.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp28 := lang.Apply(tmp24, []any{tmp27, v23}) + tmp15 = tmp28 + } // end let + return tmp15 + }) + tmp14 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(164), kw_column, int(14), kw_end_DASH_line, int(171), kw_end_DASH_column, int(30)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v16 any = tmp15 + _ = v16 + tmp17 := checkDerefVar(var_glojure_DOT_core_zipmap) + tmp18 := checkDerefVar(var_glojure_DOT_core_map) + var tmp19 lang.FnFunc + tmp19 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v20 := args[0] + _ = v20 + tmp21 := checkDerefVar(var_glojure_DOT_core_keyword) + tmp22 := checkDerefVar(var_glojure_DOT_core_name) + tmp23 := checkDerefVar(var_glojure_DOT_core_first) + tmp24 := lang.Apply(tmp23, []any{v20}) + tmp25 := lang.Apply(tmp22, []any{tmp24}) + tmp26 := lang.Apply(tmp21, []any{tmp25}) + return tmp26 + }) + tmp20 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(172), kw_column, int(21), kw_end_DASH_line, int(172), kw_end_DASH_column, int(46)) + tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp22 := lang.Apply(tmp18, []any{tmp21, v11}) + tmp23 := checkDerefVar(var_glojure_DOT_core_map) + var tmp24 lang.FnFunc + tmp24 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v25 := args[0] + _ = v25 + tmp26 := checkDerefVar(var_glojure_DOT_core_cons) + tmp27 := checkDerefVar(var_glojure_DOT_core_drop) + tmp28 := lang.Apply(tmp27, []any{int64(1), v25}) + tmp29 := lang.Apply(v16, []any{tmp28}) + tmp30 := lang.Apply(tmp26, []any{sym_glojure_DOT_core_SLASH_fn, tmp29}) + return tmp30 + }) + tmp25 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(173), kw_column, int(21), kw_end_DASH_line, int(173), kw_end_DASH_column, int(49)) + tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp27 := lang.Apply(tmp23, []any{tmp26, v11}) + tmp28 := lang.Apply(tmp17, []any{tmp22, tmp27}) + tmp29 := lang.NewVector(v8, tmp28) + tmp30 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(172), kw_column, int(5), kw_end_DASH_line, int(173), kw_end_DASH_column, int(55)) + tmp31, err := lang.WithMeta(tmp29, tmp30.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp12 = tmp31 + } // end let + tmp4 = tmp12 + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_emit_DASH_hinted_DASH_impl = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_emit_DASH_hinted_DASH_impl.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // extend-protocol + { + tmp0 := sym_extend_DASH_protocol.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_p, sym__AMP_, sym_specs)), kw_doc, "Useful when you want to provide several implementations of the same\n protocol all at once. Takes a single protocol and the implementation\n of that protocol for one or more types.\n\n (extend-protocol Protocol\n AType\n (foo [x] ...)\n (bar [x y] ...)\n BType\n (foo [x] ...)\n (bar [x y] ...)\n AClass\n (foo [x] ...)\n (bar [x y] ...)\n nil\n (foo [x] ...)\n (bar [x y] ...))\n\n expands into:\n\n (do\n (clojure.core/extend-type AType Protocol \n (foo [x] ...) \n (bar [x y] ...))\n (clojure.core/extend-type BType Protocol \n (foo [x] ...) \n (bar [x y] ...))\n (clojure.core/extend-type AClass Protocol \n (foo [x] ...) \n (bar [x y] ...))\n (clojure.core/extend-type nil Protocol \n (foo [x] ...) \n (bar [x y] ...)))", kw_file, "glojure/core_deftype.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(25), kw_column, int(11), kw_line, int(212), kw_end_DASH_line, int(212))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_emit_DASH_extend_DASH_protocol) + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_extend_DASH_protocol = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_extend_DASH_protocol.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // fits-table? + { + tmp0 := sym_fits_DASH_table_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ints)), kw_doc, "Returns true if the collection of ints can fit within the\n max-table-switch-size, false otherwise.", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(8), kw_line, int(6625), kw_end_DASH_line, int(6625), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp4 := checkDerefVar(var_glojure_DOT_core__DASH_) + tmp5 := checkDerefVar(var_glojure_DOT_core_apply) + tmp6 := checkDerefVar(var_glojure_DOT_core_max) + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := lang.Apply(tmp7, []any{v2}) + tmp9 := lang.Apply(tmp5, []any{tmp6, tmp8}) + tmp10 := checkDerefVar(var_glojure_DOT_core_apply) + tmp11 := checkDerefVar(var_glojure_DOT_core_min) + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := lang.Apply(tmp12, []any{v2}) + tmp14 := lang.Apply(tmp10, []any{tmp11, tmp13}) + tmp15 := lang.Apply(tmp4, []any{tmp9, tmp14}) + tmp16 := checkDerefVar(var_glojure_DOT_core_max_DASH_switch_DASH_table_DASH_size) + tmp17 := lang.Apply(tmp3, []any{tmp15, tmp16}) + return tmp17 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_fits_DASH_table_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_fits_DASH_table_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // fn + { + tmp0 := sym_fn.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_sigs)), kw_doc, "params => positional-params*, or positional-params* & rest-param\n positional-param => binding-form\n rest-param => binding-form\n binding-form => name, or destructuring-form\n\n Defines a function.\n\n See https://glojure.org/reference/special_forms#fn for more information", kw_forms, lang.NewVector(lang.NewList(sym_fn, sym_name_QMARK_, lang.NewVector(sym_params_STAR_), sym_exprs_STAR_), lang.NewList(sym_fn, sym_name_QMARK_, lang.NewList(lang.NewVector(sym_params_STAR_), sym_exprs_STAR_), sym__PLUS_)), kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(11), kw_line, int(4533), kw_end_DASH_line, int(4533), kw_special_DASH_form, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "name" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp8 := checkDerefVar(var_glojure_DOT_core_first) + tmp9 := lang.Apply(tmp8, []any{v4}) + tmp10 := lang.Apply(tmp7, []any{tmp9}) + if lang.IsTruthy(tmp10) { + tmp11 := checkDerefVar(var_glojure_DOT_core_first) + tmp12 := lang.Apply(tmp11, []any{v4}) + tmp6 = tmp12 + } else { + } + var v13 any = tmp6 + _ = v13 + // let binding "sigs" + var tmp14 any + if lang.IsTruthy(v13) { + tmp15 := checkDerefVar(var_glojure_DOT_core_next) + tmp16 := lang.Apply(tmp15, []any{v4}) + tmp14 = tmp16 + } else { + tmp14 = v4 + } + var v17 any = tmp14 + _ = v17 + // let binding "sigs" + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp20 := checkDerefVar(var_glojure_DOT_core_first) + tmp21 := lang.Apply(tmp20, []any{v17}) + tmp22 := lang.Apply(tmp19, []any{tmp21}) + if lang.IsTruthy(tmp22) { + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := lang.Apply(tmp23, []any{v17}) + tmp18 = tmp24 + } else { + var tmp25 any + tmp26 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp27 := checkDerefVar(var_glojure_DOT_core_first) + tmp28 := lang.Apply(tmp27, []any{v17}) + tmp29 := lang.Apply(tmp26, []any{tmp28}) + if lang.IsTruthy(tmp29) { + tmp25 = v17 + } else { + var tmp30 any + tmp31 := checkDerefVar(var_glojure_DOT_core_seq) + tmp32 := lang.Apply(tmp31, []any{v17}) + if lang.IsTruthy(tmp32) { + tmp33 := checkDerefVar(var_glojure_DOT_core_str) + tmp34 := checkDerefVar(var_glojure_DOT_core_first) + tmp35 := lang.Apply(tmp34, []any{v17}) + tmp36 := lang.Apply(tmp33, []any{"Parameter declaration ", tmp35, " should be a vector"}) + tmp30 = tmp36 + } else { + tmp37 := checkDerefVar(var_glojure_DOT_core_str) + tmp38 := lang.Apply(tmp37, []any{"Parameter declaration missing"}) + tmp30 = tmp38 + } + tmp39 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp39) + } + tmp18 = tmp25 + } + var v40 any = tmp18 + _ = v40 + // let binding "psig" + var tmp41 lang.FnFunc + tmp41 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v42 := args[0] + _ = v42 + var tmp43 any + tmp44 := checkDerefVar(var_glojure_DOT_core_not) + tmp45 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp46 := lang.Apply(tmp45, []any{v42}) + tmp47 := lang.Apply(tmp44, []any{tmp46}) + if lang.IsTruthy(tmp47) { + tmp48 := checkDerefVar(var_glojure_DOT_core_str) + tmp49 := lang.Apply(tmp48, []any{"Invalid signature ", v42, " should be a list"}) + tmp50 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp49}) + panic(tmp50) + } else { + } + _ = tmp43 + var tmp51 any + { // let + // let binding "vec__704" + var v52 any = v42 + _ = v52 + // let binding "seq__705" + tmp53 := checkDerefVar(var_glojure_DOT_core_seq) + tmp54 := lang.Apply(tmp53, []any{v52}) + var v55 any = tmp54 + _ = v55 + // let binding "first__706" + tmp56 := checkDerefVar(var_glojure_DOT_core_first) + tmp57 := lang.Apply(tmp56, []any{v55}) + var v58 any = tmp57 + _ = v58 + // let binding "seq__705" + tmp59 := checkDerefVar(var_glojure_DOT_core_next) + tmp60 := lang.Apply(tmp59, []any{v55}) + var v61 any = tmp60 + _ = v61 + // let binding "params" + var v62 any = v58 + _ = v62 + // let binding "body" + var v63 any = v61 + _ = v63 + // let binding "_" + var tmp64 any + tmp65 := checkDerefVar(var_glojure_DOT_core_not) + tmp66 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp67 := lang.Apply(tmp66, []any{v62}) + tmp68 := lang.Apply(tmp65, []any{tmp67}) + if lang.IsTruthy(tmp68) { + var tmp69 any + tmp70 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp71 := checkDerefVar(var_glojure_DOT_core_first) + tmp72 := lang.Apply(tmp71, []any{v40}) + tmp73 := lang.Apply(tmp70, []any{tmp72}) + if lang.IsTruthy(tmp73) { + tmp74 := checkDerefVar(var_glojure_DOT_core_str) + tmp75 := lang.Apply(tmp74, []any{"Parameter declaration ", v62, " should be a vector"}) + tmp69 = tmp75 + } else { + tmp76 := checkDerefVar(var_glojure_DOT_core_str) + tmp77 := lang.Apply(tmp76, []any{"Invalid signature ", v42, " should be a list"}) + tmp69 = tmp77 + } + tmp78 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp69}) + panic(tmp78) + } else { + } + var v79 any = tmp64 + _ = v79 + // let binding "conds" + var tmp80 any + var tmp81 any + { // let + // let binding "and__0__auto__" + tmp82 := checkDerefVar(var_glojure_DOT_core_next) + tmp83 := lang.Apply(tmp82, []any{v63}) + var v84 any = tmp83 + _ = v84 + var tmp85 any + if lang.IsTruthy(v84) { + tmp86 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp87 := checkDerefVar(var_glojure_DOT_core_first) + tmp88 := lang.Apply(tmp87, []any{v63}) + tmp89 := lang.Apply(tmp86, []any{tmp88}) + tmp85 = tmp89 + } else { + tmp85 = v84 + } + tmp81 = tmp85 + } // end let + if lang.IsTruthy(tmp81) { + tmp82 := checkDerefVar(var_glojure_DOT_core_first) + tmp83 := lang.Apply(tmp82, []any{v63}) + tmp80 = tmp83 + } else { + } + var v84 any = tmp80 + _ = v84 + // let binding "body" + var tmp85 any + if lang.IsTruthy(v84) { + tmp86 := checkDerefVar(var_glojure_DOT_core_next) + tmp87 := lang.Apply(tmp86, []any{v63}) + tmp85 = tmp87 + } else { + tmp85 = v63 + } + var v88 any = tmp85 + _ = v88 + // let binding "conds" + var tmp89 any + { // let + // let binding "or__0__auto__" + var v90 any = v84 + _ = v90 + var tmp91 any + if lang.IsTruthy(v90) { + tmp91 = v90 + } else { + tmp92 := checkDerefVar(var_glojure_DOT_core_meta) + tmp93 := lang.Apply(tmp92, []any{v62}) + tmp91 = tmp93 + } + tmp89 = tmp91 + } // end let + var v90 any = tmp89 + _ = v90 + // let binding "pre" + tmp91 := lang.Apply(kw_pre, []any{v90}) + var v92 any = tmp91 + _ = v92 + // let binding "post" + tmp93 := lang.Apply(kw_post, []any{v90}) + var v94 any = tmp93 + _ = v94 + // let binding "body" + var tmp95 any + if lang.IsTruthy(v94) { + tmp96 := checkDerefVar(var_glojure_DOT_core_seq) + tmp97 := checkDerefVar(var_glojure_DOT_core_concat) + tmp98 := checkDerefVar(var_glojure_DOT_core_list) + tmp99 := checkDerefVar(var_glojure_DOT_core_seq) + tmp100 := checkDerefVar(var_glojure_DOT_core_concat) + tmp101 := checkDerefVar(var_glojure_DOT_core_list) + tmp102 := lang.Apply(tmp101, []any{sym_glojure_DOT_core_SLASH_let}) + tmp103 := checkDerefVar(var_glojure_DOT_core_list) + tmp104 := checkDerefVar(var_glojure_DOT_core_apply) + tmp105 := checkDerefVar(var_glojure_DOT_core_vector) + tmp106 := checkDerefVar(var_glojure_DOT_core_seq) + tmp107 := checkDerefVar(var_glojure_DOT_core_concat) + tmp108 := checkDerefVar(var_glojure_DOT_core_list) + tmp109 := lang.Apply(tmp108, []any{sym__PCT_}) + tmp110 := checkDerefVar(var_glojure_DOT_core_list) + var tmp111 any + tmp112 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp113 := checkDerefVar(var_glojure_DOT_core_count) + tmp114 := lang.Apply(tmp113, []any{v88}) + tmp115 := lang.Apply(tmp112, []any{int64(1), tmp114}) + if lang.IsTruthy(tmp115) { + tmp116 := checkDerefVar(var_glojure_DOT_core_seq) + tmp117 := checkDerefVar(var_glojure_DOT_core_concat) + tmp118 := checkDerefVar(var_glojure_DOT_core_list) + tmp119 := lang.Apply(tmp118, []any{sym_do}) + tmp120 := lang.Apply(tmp117, []any{tmp119, v88}) + tmp121 := lang.Apply(tmp116, []any{tmp120}) + tmp111 = tmp121 + } else { + tmp122 := checkDerefVar(var_glojure_DOT_core_first) + tmp123 := lang.Apply(tmp122, []any{v88}) + tmp111 = tmp123 + } + tmp124 := lang.Apply(tmp110, []any{tmp111}) + tmp125 := lang.Apply(tmp107, []any{tmp109, tmp124}) + tmp126 := lang.Apply(tmp106, []any{tmp125}) + tmp127 := lang.Apply(tmp104, []any{tmp105, tmp126}) + tmp128 := lang.Apply(tmp103, []any{tmp127}) + tmp129 := checkDerefVar(var_glojure_DOT_core_map) + var tmp130 lang.FnFunc + tmp130 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v131 := args[0] + _ = v131 + tmp132 := checkDerefVar(var_glojure_DOT_core_seq) + tmp133 := checkDerefVar(var_glojure_DOT_core_concat) + tmp134 := checkDerefVar(var_glojure_DOT_core_list) + tmp135 := lang.Apply(tmp134, []any{sym_glojure_DOT_core_SLASH_assert}) + tmp136 := checkDerefVar(var_glojure_DOT_core_list) + tmp137 := lang.Apply(tmp136, []any{v131}) + tmp138 := lang.Apply(tmp133, []any{tmp135, tmp137}) + tmp139 := lang.Apply(tmp132, []any{tmp138}) + return tmp139 + }) + tmp131 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4582), kw_column, int(41), kw_end_DASH_line, int(4582), kw_end_DASH_column, int(62)) + tmp132, err := lang.WithMeta(tmp130, tmp131.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp133 := lang.Apply(tmp129, []any{tmp132, v94}) + tmp134 := checkDerefVar(var_glojure_DOT_core_list) + tmp135 := lang.Apply(tmp134, []any{sym__PCT_}) + tmp136 := lang.Apply(tmp100, []any{tmp102, tmp128, tmp133, tmp135}) + tmp137 := lang.Apply(tmp99, []any{tmp136}) + tmp138 := lang.Apply(tmp98, []any{tmp137}) + tmp139 := lang.Apply(tmp97, []any{tmp138}) + tmp140 := lang.Apply(tmp96, []any{tmp139}) + tmp95 = tmp140 + } else { + tmp95 = v88 + } + var v141 any = tmp95 + _ = v141 + // let binding "body" + var tmp142 any + if lang.IsTruthy(v92) { + tmp143 := checkDerefVar(var_glojure_DOT_core_concat) + tmp144 := checkDerefVar(var_glojure_DOT_core_map) + var tmp145 lang.FnFunc + tmp145 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v146 := args[0] + _ = v146 + tmp147 := checkDerefVar(var_glojure_DOT_core_seq) + tmp148 := checkDerefVar(var_glojure_DOT_core_concat) + tmp149 := checkDerefVar(var_glojure_DOT_core_list) + tmp150 := lang.Apply(tmp149, []any{sym_glojure_DOT_core_SLASH_assert}) + tmp151 := checkDerefVar(var_glojure_DOT_core_list) + tmp152 := lang.Apply(tmp151, []any{v146}) + tmp153 := lang.Apply(tmp148, []any{tmp150, tmp152}) + tmp154 := lang.Apply(tmp147, []any{tmp153}) + return tmp154 + }) + tmp146 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4586), kw_column, int(44), kw_end_DASH_line, int(4586), kw_end_DASH_column, int(65)) + tmp147, err := lang.WithMeta(tmp145, tmp146.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp148 := lang.Apply(tmp144, []any{tmp147, v92}) + tmp149 := lang.Apply(tmp143, []any{tmp148, v141}) + tmp142 = tmp149 + } else { + tmp142 = v141 + } + var v150 any = tmp142 + _ = v150 + tmp151 := checkDerefVar(var_glojure_DOT_core_maybe_DASH_destructured) + tmp152 := lang.Apply(tmp151, []any{v62, v150}) + tmp51 = tmp152 + } // end let + return tmp51 + }) + tmp42 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4558), kw_column, int(16), kw_end_DASH_line, int(4589), kw_end_DASH_column, int(53)) + tmp43, err := lang.WithMeta(tmp41, tmp42.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v44 any = tmp43 + _ = v44 + // let binding "new-sigs" + tmp45 := checkDerefVar(var_glojure_DOT_core_map) + tmp46 := lang.Apply(tmp45, []any{v44, v40}) + var v47 any = tmp46 + _ = v47 + tmp48 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + var tmp49 any + if lang.IsTruthy(v13) { + tmp50 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp51 := lang.Apply(tmp50, []any{sym_fn_STAR_, v13, v47}) + tmp49 = tmp51 + } else { + tmp52 := checkDerefVar(var_glojure_DOT_core_cons) + tmp53 := lang.Apply(tmp52, []any{sym_fn_STAR_, v47}) + tmp49 = tmp53 + } + tmp54 := checkDerefVar(var_glojure_DOT_core_meta) + tmp55 := lang.Apply(tmp54, []any{v2}) + tmp56 := lang.Apply(tmp48, []any{tmp49, tmp55}) + tmp5 = tmp56 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_fn = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_fn.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // import + { + tmp0 := sym_import.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_import_DASH_symbols_DASH_or_DASH_lists)), kw_doc, "import-list => (package-symbol class-name-symbols*)\n\n For each name in class-name-symbols, adds a mapping from name to the\n class named by package.name to the current namespace. Use :import in the ns\n macro in preference to calling this directly.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(11), kw_line, int(3426), kw_end_DASH_line, int(3426))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "specs" + tmp6 := checkDerefVar(var_glojure_DOT_core_map) + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v8 := args[0] + _ = v8 + var tmp9 any + var tmp10 any + { // let + // let binding "and__0__auto__" + tmp11 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp12 := lang.Apply(tmp11, []any{v8}) + var v13 any = tmp12 + _ = v13 + var tmp14 any + if lang.IsTruthy(v13) { + tmp15 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp16 := checkDerefVar(var_glojure_DOT_core_first) + tmp17 := lang.Apply(tmp16, []any{v8}) + tmp18 := lang.Apply(tmp15, []any{sym_quote, tmp17}) + tmp14 = tmp18 + } else { + tmp14 = v13 + } + tmp10 = tmp14 + } // end let + if lang.IsTruthy(tmp10) { + tmp11 := checkDerefVar(var_glojure_DOT_core_second) + tmp12 := lang.Apply(tmp11, []any{v8}) + tmp9 = tmp12 + } else { + tmp9 = v8 + } + return tmp9 + }) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3434), kw_column, int(20), kw_end_DASH_line, int(3434), kw_end_DASH_column, int(73)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp10 := lang.Apply(tmp6, []any{tmp9, v4}) + var v11 any = tmp10 + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := checkDerefVar(var_glojure_DOT_core_concat) + tmp14 := checkDerefVar(var_glojure_DOT_core_list) + tmp15 := lang.Apply(tmp14, []any{sym_do}) + tmp16 := checkDerefVar(var_glojure_DOT_core_map) + var tmp17 lang.FnFunc + tmp17 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v18 := args[0] + _ = v18 + tmp19 := checkDerefVar(var_glojure_DOT_core_list) + tmp20 := lang.Apply(tmp19, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Import, v18}) + return tmp20 + }) + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3436), kw_column, int(17), kw_end_DASH_line, int(3436), kw_end_DASH_column, int(73)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp20 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp21 lang.FnFunc + tmp21 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v22 := args[0] + _ = v22 + v23 := args[1] + _ = v23 + var tmp24 any + tmp25 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp26 := lang.Apply(tmp25, []any{v23}) + if lang.IsTruthy(tmp26) { + tmp27 := checkDerefVar(var_glojure_DOT_core_conj) + tmp28 := checkDerefVar(var_glojure_DOT_core_name) + tmp29 := lang.Apply(tmp28, []any{v23}) + tmp30 := lang.Apply(tmp27, []any{v22, tmp29}) + tmp24 = tmp30 + } else { + var tmp31 any + { // let + // let binding "p" + tmp32 := checkDerefVar(var_glojure_DOT_core_first) + tmp33 := lang.Apply(tmp32, []any{v23}) + var v34 any = tmp33 + _ = v34 + // let binding "cs" + tmp35 := checkDerefVar(var_glojure_DOT_core_rest) + tmp36 := lang.Apply(tmp35, []any{v23}) + var v37 any = tmp36 + _ = v37 + tmp38 := checkDerefVar(var_glojure_DOT_core_into1) + tmp39 := checkDerefVar(var_glojure_DOT_core_map) + var tmp40 lang.FnFunc + tmp40 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v41 := args[0] + _ = v41 + tmp42 := checkDerefVar(var_glojure_DOT_core_str) + tmp43 := lang.Apply(tmp42, []any{v34, ".", v41}) + return tmp43 + }) + tmp41 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3441), kw_column, int(45), kw_end_DASH_line, int(3441), kw_end_DASH_column, int(58)) + tmp42, err := lang.WithMeta(tmp40, tmp41.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp43 := lang.Apply(tmp39, []any{tmp42, v37}) + tmp44 := lang.Apply(tmp38, []any{v22, tmp43}) + tmp31 = tmp44 + } // end let + tmp24 = tmp31 + } + return tmp24 + }) + tmp22 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3437), kw_column, int(26), kw_end_DASH_line, int(3441), kw_end_DASH_column, int(66)) + tmp23, err := lang.WithMeta(tmp21, tmp22.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp24 := lang.NewVector() + tmp25 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3442), kw_column, int(25), kw_end_DASH_line, int(3442), kw_end_DASH_column, int(26)) + tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp27 := lang.Apply(tmp20, []any{tmp23, tmp26, v11}) + tmp28 := lang.Apply(tmp16, []any{tmp19, tmp27}) + tmp29 := lang.Apply(tmp13, []any{tmp15, tmp28}) + tmp30 := lang.Apply(tmp12, []any{tmp29}) + tmp5 = tmp30 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_import = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_import.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // interleave + { + tmp0 := sym_interleave.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_c1), lang.NewVector(sym_c1, sym_c2), lang.NewVector(sym_c1, sym_c2, sym__AMP_, sym_colls)), kw_doc, "Returns a lazy seq of the first item in each coll, then the second etc.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4308), kw_end_DASH_line, int(4308))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return lang.NewList() + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + return v2 + }) + tmp4 := lang.Apply(lang.NewLazySeq, []any{tmp3}) + return tmp4 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp5 any + { // let + // let binding "s1" + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := lang.Apply(tmp6, []any{v2}) + var v8 any = tmp7 + _ = v8 + // let binding "s2" + tmp9 := checkDerefVar(var_glojure_DOT_core_seq) + tmp10 := lang.Apply(tmp9, []any{v3}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + var tmp13 any + { // let + // let binding "and__0__auto__" + var v14 any = v8 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + tmp15 = v11 + } else { + tmp15 = v14 + } + tmp13 = tmp15 + } // end let + if lang.IsTruthy(tmp13) { + tmp14 := checkDerefVar(var_glojure_DOT_core_cons) + tmp15 := checkDerefVar(var_glojure_DOT_core_first) + tmp16 := lang.Apply(tmp15, []any{v8}) + tmp17 := checkDerefVar(var_glojure_DOT_core_cons) + tmp18 := checkDerefVar(var_glojure_DOT_core_first) + tmp19 := lang.Apply(tmp18, []any{v11}) + tmp20 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp21 := checkDerefVar(var_glojure_DOT_core_rest) + tmp22 := lang.Apply(tmp21, []any{v8}) + tmp23 := checkDerefVar(var_glojure_DOT_core_rest) + tmp24 := lang.Apply(tmp23, []any{v11}) + tmp25 := lang.Apply(tmp20, []any{tmp22, tmp24}) + tmp26 := lang.Apply(tmp17, []any{tmp19, tmp25}) + tmp27 := lang.Apply(tmp14, []any{tmp16, tmp26}) + tmp12 = tmp27 + } else { + } + tmp5 = tmp12 + } // end let + return tmp5 + }) + tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) + return tmp5 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp6 any + { // let + // let binding "ss" + tmp7 := checkDerefVar(var_glojure_DOT_core_map) + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_conj) + tmp10 := lang.Apply(tmp9, []any{v4, v3, v2}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10}) + var v12 any = tmp11 + _ = v12 + var tmp13 any + tmp14 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + tmp15 := checkDerefVar(var_glojure_DOT_core_identity) + tmp16 := lang.Apply(tmp14, []any{tmp15, v12}) + if lang.IsTruthy(tmp16) { + tmp17 := checkDerefVar(var_glojure_DOT_core_concat) + tmp18 := checkDerefVar(var_glojure_DOT_core_map) + tmp19 := checkDerefVar(var_glojure_DOT_core_first) + tmp20 := lang.Apply(tmp18, []any{tmp19, v12}) + tmp21 := checkDerefVar(var_glojure_DOT_core_apply) + tmp22 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp23 := checkDerefVar(var_glojure_DOT_core_map) + tmp24 := checkDerefVar(var_glojure_DOT_core_rest) + tmp25 := lang.Apply(tmp23, []any{tmp24, v12}) + tmp26 := lang.Apply(tmp21, []any{tmp22, tmp25}) + tmp27 := lang.Apply(tmp17, []any{tmp20, tmp26}) + tmp13 = tmp27 + } else { + } + tmp6 = tmp13 + } // end let + return tmp6 + }) + tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_interleave = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_interleave.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // interpose + { + tmp0 := sym_interpose.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_sep), lang.NewVector(sym_sep, sym_coll)), kw_doc, "Returns a lazy seq of the elements of coll separated by sep.\n Returns a stateful transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(5230), kw_end_DASH_line, int(5230))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 any + { // let + // let binding "started" + tmp6 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) + tmp7 := lang.Apply(tmp6, []any{false}) + var v8 any = tmp7 + _ = v8 + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp10 := lang.Apply(v4, nil) + return tmp10 + case 1: + v10 := args[0] + _ = v10 + tmp11 := lang.Apply(v4, []any{v10}) + return tmp11 + case 2: + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + var tmp12 any + tmp13 := checkDerefVar(var_glojure_DOT_core_deref) + tmp14 := lang.Apply(tmp13, []any{v8}) + if lang.IsTruthy(tmp14) { + var tmp15 any + { // let + // let binding "sepr" + tmp16 := lang.Apply(v4, []any{v10, v2}) + var v17 any = tmp16 + _ = v17 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) + tmp20 := lang.Apply(tmp19, []any{v17}) + if lang.IsTruthy(tmp20) { + tmp18 = v17 + } else { + tmp21 := lang.Apply(v4, []any{v17, v11}) + tmp18 = tmp21 + } + tmp15 = tmp18 + } // end let + tmp12 = tmp15 + } else { + tmp16 := checkDerefVar(var_glojure_DOT_core_vreset_BANG_) + tmp17 := lang.Apply(tmp16, []any{v8, true}) + _ = tmp17 + tmp18 := lang.Apply(v4, []any{v10, v11}) + tmp12 = tmp18 + } + return tmp12 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5238), kw_column, int(8), kw_end_DASH_line, int(5249), kw_end_DASH_column, int(35)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp5 = tmp11 + } // end let + return tmp5 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5236), kw_column, int(4), kw_end_DASH_line, int(5249), kw_end_DASH_column, int(37)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_drop) + tmp5 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp6 := checkDerefVar(var_glojure_DOT_core_repeat) + tmp7 := lang.Apply(tmp6, []any{v2}) + tmp8 := lang.Apply(tmp5, []any{tmp7, v3}) + tmp9 := lang.Apply(tmp4, []any{int64(1), tmp8}) + return tmp9 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_interpose = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_interpose.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // isa? + { + tmp0 := sym_isa_QMARK_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_child, sym_parent), lang.NewVector(sym_h, sym_child, sym_parent)), kw_doc, "Returns true if (= child parent), or child is directly or indirectly derived from\n parent, either via a Java type inheritance relationship or a\n relationship established via derive. h must be a hierarchy obtained\n from make-hierarchy, if not supplied defaults to the global\n hierarchy", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(5543), kw_end_DASH_line, int(5543))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_isa_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_global_DASH_hierarchy) + tmp6 := lang.Apply(tmp4, []any{tmp5, v2, v3}) + return tmp6 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + { // let + // let binding "or__0__auto__" + tmp6 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp7 := lang.Apply(tmp6, []any{v3, v4}) + var v8 any = tmp7 + _ = v8 + var tmp9 any + if lang.IsTruthy(v8) { + tmp9 = v8 + } else { + var tmp10 any + { // let + // let binding "or__0__auto__" + var tmp11 any + { // let + // let binding "and__0__auto__" + tmp12 := checkDerefVar(var_glojure_DOT_core_class_QMARK_) + tmp13 := lang.Apply(tmp12, []any{v4}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + var tmp16 any + { // let + // let binding "and__0__auto__" + tmp17 := checkDerefVar(var_glojure_DOT_core_class_QMARK_) + tmp18 := lang.Apply(tmp17, []any{v3}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + tmp21, _ := lang.FieldOrMethod(v3, "AssignableTo") + if reflect.TypeOf(tmp21).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("AssignableTo is not a function"))) + } + tmp22 := lang.Apply(tmp21, []any{v4}) + tmp20 = tmp22 + } else { + tmp20 = v19 + } + tmp16 = tmp20 + } // end let + tmp15 = tmp16 + } else { + tmp15 = v14 + } + tmp11 = tmp15 + } // end let + var v12 any = tmp11 + _ = v12 + var tmp13 any + if lang.IsTruthy(v12) { + tmp13 = v12 + } else { + var tmp14 any + { // let + // let binding "or__0__auto__" + tmp15 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp16 := lang.Apply(kw_ancestors, []any{v2}) + tmp17 := lang.Apply(tmp16, []any{v3}) + tmp18 := lang.Apply(tmp15, []any{tmp17, v4}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + tmp20 = v19 + } else { + var tmp21 any + { // let + // let binding "or__0__auto__" + var tmp22 any + { // let + // let binding "and__0__auto__" + tmp23 := checkDerefVar(var_glojure_DOT_core_class_QMARK_) + tmp24 := lang.Apply(tmp23, []any{v3}) + var v25 any = tmp24 + _ = v25 + var tmp26 any + if lang.IsTruthy(v25) { + tmp27 := checkDerefVar(var_glojure_DOT_core_some) + var tmp28 lang.FnFunc + tmp28 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v29 := args[0] + _ = v29 + tmp30 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp31 := lang.Apply(kw_ancestors, []any{v2}) + tmp32 := lang.Apply(tmp31, []any{v29}) + tmp33 := lang.Apply(tmp30, []any{tmp32, v4}) + return tmp33 + }) + tmp29 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5556), kw_column, int(34), kw_end_DASH_line, int(5556), kw_end_DASH_column, int(71)) + tmp30, err := lang.WithMeta(tmp28, tmp29.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp31 := checkDerefVar(var_glojure_DOT_core_supers) + tmp32 := lang.Apply(tmp31, []any{v3}) + tmp33 := lang.Apply(tmp27, []any{tmp30, tmp32}) + tmp26 = tmp33 + } else { + tmp26 = v25 + } + tmp22 = tmp26 + } // end let + var v23 any = tmp22 + _ = v23 + var tmp24 any + if lang.IsTruthy(v23) { + tmp24 = v23 + } else { + var tmp25 any + { // let + // let binding "and__0__auto__" + tmp26 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp27 := lang.Apply(tmp26, []any{v4}) + var v28 any = tmp27 + _ = v28 + var tmp29 any + if lang.IsTruthy(v28) { + var tmp30 any + { // let + // let binding "and__0__auto__" + tmp31 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp32 := lang.Apply(tmp31, []any{v3}) + var v33 any = tmp32 + _ = v33 + var tmp34 any + if lang.IsTruthy(v33) { + var tmp35 any + { // let + // let binding "and__0__auto__" + tmp36 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp37 := checkDerefVar(var_glojure_DOT_core_count) + tmp38 := lang.Apply(tmp37, []any{v4}) + tmp39 := checkDerefVar(var_glojure_DOT_core_count) + tmp40 := lang.Apply(tmp39, []any{v3}) + tmp41 := lang.Apply(tmp36, []any{tmp38, tmp40}) + var v42 any = tmp41 + _ = v42 + var tmp43 any + if lang.IsTruthy(v42) { + var tmp44 any + { // let + // let binding "ret" + var v45 any = true + _ = v45 + // let binding "i" + var v46 any = int64(0) + _ = v46 + for { + var tmp47 any + var tmp48 any + { // let + // let binding "or__0__auto__" + tmp49 := checkDerefVar(var_glojure_DOT_core_not) + tmp50 := lang.Apply(tmp49, []any{v45}) + var v51 any = tmp50 + _ = v51 + var tmp52 any + if lang.IsTruthy(v51) { + tmp52 = v51 + } else { + tmp53 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp54 := checkDerefVar(var_glojure_DOT_core_count) + tmp55 := lang.Apply(tmp54, []any{v4}) + tmp56 := lang.Apply(tmp53, []any{v46, tmp55}) + tmp52 = tmp56 + } + tmp48 = tmp52 + } // end let + if lang.IsTruthy(tmp48) { + tmp47 = v45 + } else { + tmp50 := checkDerefVar(var_glojure_DOT_core_isa_QMARK_) + tmp51 := lang.Apply(v3, []any{v46}) + tmp52 := lang.Apply(v4, []any{v46}) + tmp53 := lang.Apply(tmp50, []any{v2, tmp51, tmp52}) + var tmp49 any = tmp53 + tmp55 := checkDerefVar(var_glojure_DOT_core_inc) + tmp56 := lang.Apply(tmp55, []any{v46}) + var tmp54 any = tmp56 + v45 = tmp49 + v46 = tmp54 + continue + } + tmp44 = tmp47 + break + } + } // end let + tmp43 = tmp44 + } else { + tmp43 = v42 + } + tmp35 = tmp43 + } // end let + tmp34 = tmp35 + } else { + tmp34 = v33 + } + tmp30 = tmp34 + } // end let + tmp29 = tmp30 + } else { + tmp29 = v28 + } + tmp25 = tmp29 + } // end let + tmp24 = tmp25 + } + tmp21 = tmp24 + } // end let + tmp20 = tmp21 + } + tmp14 = tmp20 + } // end let + tmp13 = tmp14 + } + tmp10 = tmp13 + } // end let + tmp9 = tmp10 + } + tmp5 = tmp9 + } // end let + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_isa_QMARK_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_isa_QMARK_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // lazy-cat + { + tmp0 := sym_lazy_DASH_cat.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_colls)), kw_doc, "Expands to code which yields a lazy sequence of the concatenation\n of the supplied colls. Each coll expr is not evaluated until it is\n needed. \n\n (lazy-cat xs ys zs) === (concat (lazy-seq xs) (lazy-seq ys) (lazy-seq zs))", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(11), kw_line, int(4636), kw_end_DASH_line, int(4636))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_concat) + tmp7 := checkDerefVar(var_glojure_DOT_core_list) + tmp8 := lang.Apply(tmp7, []any{sym_glojure_DOT_core_SLASH_concat}) + tmp9 := checkDerefVar(var_glojure_DOT_core_map) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v11 := args[0] + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{sym_glojure_DOT_core_SLASH_lazy_DASH_seq, v11}) + return tmp13 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4644), kw_column, int(19), kw_end_DASH_line, int(4644), kw_end_DASH_column, int(37)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := lang.Apply(tmp9, []any{tmp12, v4}) + tmp14 := lang.Apply(tmp6, []any{tmp8, tmp13}) + tmp15 := lang.Apply(tmp5, []any{tmp14}) + return tmp15 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_lazy_DASH_cat = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_lazy_DASH_cat.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // letfn + { + tmp0 := sym_letfn.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_fnspecs, sym__AMP_, sym_body)), kw_doc, "fnspec ==> (fname [params*] exprs) or (fname ([params*] exprs)+)\n\n Takes a vector of function specs and a body, and generates a set of\n bindings of functions to their names. All of the names are available\n in all of the definitions of the functions, as well as the body.", kw_forms, lang.NewVector(lang.NewList(sym_letfn, lang.NewVector(sym_fnspecs_STAR_), sym_exprs_STAR_)), kw_url, nil, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(11), kw_line, int(6545), kw_end_DASH_line, int(6545), kw_special_DASH_form, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + tmp8 := checkDerefVar(var_glojure_DOT_core_list) + tmp9 := lang.Apply(tmp8, []any{sym_letfn_STAR_}) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_vec) + tmp12 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp13 := checkDerefVar(var_glojure_DOT_core_map) + tmp14 := checkDerefVar(var_glojure_DOT_core_first) + tmp15 := lang.Apply(tmp13, []any{tmp14, v4}) + tmp16 := checkDerefVar(var_glojure_DOT_core_map) + var tmp17 lang.FnFunc + tmp17 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v18 := args[0] + _ = v18 + tmp19 := checkDerefVar(var_glojure_DOT_core_cons) + tmp20 := lang.Apply(tmp19, []any{sym_glojure_DOT_core_SLASH_fn, v18}) + return tmp20 + }) + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6555), kw_column, int(35), kw_end_DASH_line, int(6555), kw_end_DASH_column, int(47)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp20 := lang.Apply(tmp16, []any{tmp19, v4}) + tmp21 := lang.Apply(tmp12, []any{tmp15, tmp20}) + tmp22 := lang.Apply(tmp11, []any{tmp21}) + tmp23 := lang.Apply(tmp10, []any{tmp22}) + tmp24 := lang.Apply(tmp7, []any{tmp9, tmp23, v5}) + tmp25 := lang.Apply(tmp6, []any{tmp24}) + return tmp25 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_letfn = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_letfn.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // lift-ns + { + tmp0 := sym_lift_DASH_ns.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m)), kw_doc, "Returns [lifted-ns lifted-kvs] or nil if m can't be lifted.", kw_file, "glojure/core_print.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(8), kw_line, int(261), kw_end_DASH_line, int(261), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_namespace_DASH_maps_STAR_) + if lang.IsTruthy(tmp4) { + var tmp5 any + { // let + // let binding "ns" + var v6 any = nil + _ = v6 + // let binding "G__912" + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := lang.Apply(tmp7, []any{v2}) + var v9 any = tmp8 + _ = v9 + // let binding "vec__913" + var v10 any = v9 + _ = v10 + // let binding "seq__914" + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := lang.Apply(tmp11, []any{v10}) + var v13 any = tmp12 + _ = v13 + // let binding "first__915" + tmp14 := checkDerefVar(var_glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v13}) + var v16 any = tmp15 + _ = v16 + // let binding "seq__914" + tmp17 := checkDerefVar(var_glojure_DOT_core_next) + tmp18 := lang.Apply(tmp17, []any{v13}) + var v19 any = tmp18 + _ = v19 + // let binding "vec__916" + var v20 any = v16 + _ = v20 + // let binding "k" + tmp21 := checkDerefVar(var_glojure_DOT_core_nth) + tmp22 := lang.Apply(tmp21, []any{v20, int64(0), nil}) + var v23 any = tmp22 + _ = v23 + // let binding "v" + tmp24 := checkDerefVar(var_glojure_DOT_core_nth) + tmp25 := lang.Apply(tmp24, []any{v20, int64(1), nil}) + var v26 any = tmp25 + _ = v26 + // let binding "entry" + var v27 any = v20 + _ = v27 + // let binding "entries" + var v28 any = v19 + _ = v28 + // let binding "kvs" + tmp29 := lang.NewVector() + tmp30 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(267), kw_column, int(16), kw_end_DASH_line, int(267), kw_end_DASH_column, int(17)) + tmp31, err := lang.WithMeta(tmp29, tmp30.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v32 any = tmp31 + _ = v32 + var tmp33 any + { // let + // let binding "ns" + var v34 any = v6 + _ = v34 + // let binding "G__912" + var v35 any = v9 + _ = v35 + // let binding "kvs" + var v36 any = v32 + _ = v36 + for { + var tmp37 any + { // let + // let binding "ns" + var v38 any = v34 + _ = v38 + // let binding "vec__919" + var v39 any = v35 + _ = v39 + // let binding "seq__920" + tmp40 := checkDerefVar(var_glojure_DOT_core_seq) + tmp41 := lang.Apply(tmp40, []any{v39}) + var v42 any = tmp41 + _ = v42 + // let binding "first__921" + tmp43 := checkDerefVar(var_glojure_DOT_core_first) + tmp44 := lang.Apply(tmp43, []any{v42}) + var v45 any = tmp44 + _ = v45 + // let binding "seq__920" + tmp46 := checkDerefVar(var_glojure_DOT_core_next) + tmp47 := lang.Apply(tmp46, []any{v42}) + var v48 any = tmp47 + _ = v48 + // let binding "vec__922" + var v49 any = v45 + _ = v49 + // let binding "k" + tmp50 := checkDerefVar(var_glojure_DOT_core_nth) + tmp51 := lang.Apply(tmp50, []any{v49, int64(0), nil}) + var v52 any = tmp51 + _ = v52 + // let binding "v" + tmp53 := checkDerefVar(var_glojure_DOT_core_nth) + tmp54 := lang.Apply(tmp53, []any{v49, int64(1), nil}) + var v55 any = tmp54 + _ = v55 + // let binding "entry" + var v56 any = v49 + _ = v56 + // let binding "entries" + var v57 any = v48 + _ = v57 + // let binding "kvs" + var v58 any = v36 + _ = v58 + var tmp59 any + if lang.IsTruthy(v56) { + var tmp60 any + tmp61 := checkDerefVar(var_glojure_DOT_core_qualified_DASH_ident_QMARK_) + tmp62 := lang.Apply(tmp61, []any{v52}) + if lang.IsTruthy(tmp62) { + var tmp63 any + if lang.IsTruthy(v38) { + var tmp64 any + tmp65 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp66 := checkDerefVar(var_glojure_DOT_core_namespace) + tmp67 := lang.Apply(tmp66, []any{v52}) + tmp68 := lang.Apply(tmp65, []any{v38, tmp67}) + if lang.IsTruthy(tmp68) { + var tmp69 any = v38 + var tmp70 any = v57 + tmp72 := checkDerefVar(var_glojure_DOT_core_conj) + tmp73 := checkDerefVar(var_glojure_DOT_core_strip_DASH_ns) + tmp74 := lang.Apply(tmp73, []any{v52}) + tmp75 := lang.NewVector(tmp74, v55) + tmp76 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(272), kw_column, int(43), kw_end_DASH_line, int(272), kw_end_DASH_column, int(58)) + tmp77, err := lang.WithMeta(tmp75, tmp76.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp78 := lang.Apply(tmp72, []any{v58, tmp77}) + var tmp71 any = tmp78 + v34 = tmp69 + v35 = tmp70 + v36 = tmp71 + continue + } else { + } + tmp63 = tmp64 + } else { + var tmp79 any + { // let + // let binding "temp__0__auto__" + tmp80 := checkDerefVar(var_glojure_DOT_core_namespace) + tmp81 := lang.Apply(tmp80, []any{v52}) + var v82 any = tmp81 + _ = v82 + var tmp83 any + if lang.IsTruthy(v82) { + var tmp84 any + { // let + // let binding "new-ns" + var v85 any = v82 + _ = v85 + var tmp86 any = v85 + var tmp87 any = v57 + tmp89 := checkDerefVar(var_glojure_DOT_core_conj) + tmp90 := checkDerefVar(var_glojure_DOT_core_strip_DASH_ns) + tmp91 := lang.Apply(tmp90, []any{v52}) + tmp92 := lang.NewVector(tmp91, v55) + tmp93 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(274), kw_column, int(47), kw_end_DASH_line, int(274), kw_end_DASH_column, int(62)) + tmp94, err := lang.WithMeta(tmp92, tmp93.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp95 := lang.Apply(tmp89, []any{v58, tmp94}) + var tmp88 any = tmp95 + v34 = tmp86 + v35 = tmp87 + v36 = tmp88 + continue + } // end let + tmp83 = tmp84 + } else { + } + tmp79 = tmp83 + } // end let + tmp63 = tmp79 + } + tmp60 = tmp63 + } else { + } + tmp59 = tmp60 + } else { + tmp80 := lang.NewVector(v38, v58) + tmp81 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(275), kw_column, int(9), kw_end_DASH_line, int(275), kw_end_DASH_column, int(16)) + tmp82, err := lang.WithMeta(tmp80, tmp81.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp59 = tmp82 + } + tmp37 = tmp59 + } // end let + tmp33 = tmp37 + break + } + } // end let + tmp5 = tmp33 + } // end let + tmp3 = tmp5 + } else { + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_lift_DASH_ns = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_lift_DASH_ns.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // make-array + { + tmp0 := sym_make_DASH_array.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_type, sym_len), lang.NewVector(sym_type, sym_dim, sym__AMP_, sym_more_DASH_dims)), kw_doc, "Creates and returns an array of instances of the specified class of\n the specified dimension(s). Note that a class object is required.\n Class objects can be obtained by using their imported or\n fully-qualified name. Class objects for the primitive types can be\n obtained using, e.g., Integer/TYPE.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(3985), kw_end_DASH_line, int(3985))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_int) + tmp5 := lang.Apply(tmp4, []any{v3}) + tmp6, _ := lang.FieldOrMethod(nil, "newInstance") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("newInstance is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{v2, tmp5}) + return tmp7 + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + var tmp5 any + { // let + // let binding "dims" + tmp6 := checkDerefVar(var_glojure_DOT_core_cons) + tmp7 := lang.Apply(tmp6, []any{v3, v4}) + var v8 any = tmp7 + _ = v8 + // let binding "dimarray" + tmp9 := checkDerefVar(var_glojure_DOT_core_make_DASH_array) + tmp10, ok := lang.FieldOrMethod(nil, "TYPE") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "TYPE"))) + } + var tmp11 any + switch reflect.TypeOf(tmp10).Kind() { + case reflect.Func: + tmp11 = lang.Apply(tmp10, nil) + default: + tmp11 = tmp10 + } + tmp12 := checkDerefVar(var_glojure_DOT_core_count) + tmp13 := lang.Apply(tmp12, []any{v8}) + tmp14 := lang.Apply(tmp9, []any{tmp11, tmp13}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + { // let + // let binding "n__0__auto__" + tmp17 := checkDerefVar(var_glojure_DOT_core_long) + tmp18 := checkDerefVar(var_glojure_DOT_core_alength) + tmp19 := lang.Apply(tmp18, []any{v15}) + tmp20 := lang.Apply(tmp17, []any{tmp19}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + { // let + // let binding "i" + var v23 any = int64(0) + _ = v23 + for { + var tmp24 any + tmp25 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp26 := lang.Apply(tmp25, []any{v23, v21}) + if lang.IsTruthy(tmp26) { + tmp27 := checkDerefVar(var_glojure_DOT_core_aset_DASH_int) + tmp28 := checkDerefVar(var_glojure_DOT_core_nth) + tmp29 := lang.Apply(tmp28, []any{v8, v23}) + tmp30 := lang.Apply(tmp27, []any{v15, v23, tmp29}) + _ = tmp30 + tmp32 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp33 := lang.Apply(tmp32, []any{v23}) + var tmp31 any = tmp33 + v23 = tmp31 + continue + } else { + } + tmp22 = tmp24 + break + } + } // end let + tmp16 = tmp22 + } // end let + _ = tmp16 + tmp17, _ := lang.FieldOrMethod(nil, "newInstance") + if reflect.TypeOf(tmp17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("newInstance is not a function"))) + } + tmp18 := lang.Apply(tmp17, []any{v2, v15}) + tmp5 = tmp18 + } // end let + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_make_DASH_array = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_make_DASH_array.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // maybe-min-hash + { + tmp0 := sym_maybe_DASH_min_DASH_hash.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_hashes)), kw_doc, "takes a collection of hashes and returns [shift mask] or nil if none found", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(8), kw_line, int(6604), kw_end_DASH_line, int(6604), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_first) + tmp4 := checkDerefVar(var_glojure_DOT_core_filter) + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v6 := args[0] + _ = v6 + var tmp7 any + { // let + // let binding "vec__842" + var v8 any = v6 + _ = v8 + // let binding "s" + tmp9 := checkDerefVar(var_glojure_DOT_core_nth) + tmp10 := lang.Apply(tmp9, []any{v8, int64(0), nil}) + var v11 any = tmp10 + _ = v11 + // let binding "m" + tmp12 := checkDerefVar(var_glojure_DOT_core_nth) + tmp13 := lang.Apply(tmp12, []any{v8, int64(1), nil}) + var v14 any = tmp13 + _ = v14 + tmp15 := checkDerefVar(var_glojure_DOT_core_apply) + tmp16 := checkDerefVar(var_glojure_DOT_core_distinct_QMARK_) + tmp17 := checkDerefVar(var_glojure_DOT_core_map) + var tmp18 lang.FnFunc + tmp18 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v19 := args[0] + _ = v19 + tmp20 := checkDerefVar(var_glojure_DOT_core_shift_DASH_mask) + tmp21 := lang.Apply(tmp20, []any{v11, v14, v19}) + return tmp21 + }) + tmp19 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6609), kw_column, int(37), kw_end_DASH_line, int(6609), kw_end_DASH_column, int(55)) + tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp21 := lang.Apply(tmp17, []any{tmp20, v2}) + tmp22 := lang.Apply(tmp15, []any{tmp16, tmp21}) + tmp7 = tmp22 + } // end let + return tmp7 + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6608), kw_column, int(13), kw_end_DASH_line, int(6609), kw_end_DASH_column, int(65)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var tmp8 any + { // let + // let binding "iter__0__auto__" + var tmp9 lang.FnFunc + { // function iter__845 + var v10 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v11 := args[0] + _ = v11 + var tmp12 lang.FnFunc + tmp12 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp13 any + { // let + // let binding "s__846" + var v14 any = v11 + _ = v14 + for { + var tmp15 any + { // let + // let binding "temp__0__auto__" + tmp16 := checkDerefVar(var_glojure_DOT_core_seq) + tmp17 := lang.Apply(tmp16, []any{v14}) + var v18 any = tmp17 + _ = v18 + var tmp19 any + if lang.IsTruthy(v18) { + var tmp20 any + { // let + // let binding "xs__0__auto__" + var v21 any = v18 + _ = v21 + var tmp22 any + { // let + // let binding "mask" + tmp23 := checkDerefVar(var_glojure_DOT_core_first) + tmp24 := lang.Apply(tmp23, []any{v21}) + var v25 any = tmp24 + _ = v25 + var tmp26 any + { // let + // let binding "iterys__0__auto__" + var tmp27 lang.FnFunc + { // function iter__847 + var v28 lang.FnFunc + tmp27 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v29 := args[0] + _ = v29 + var tmp30 lang.FnFunc + tmp30 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp31 any + { // let + // let binding "s__848" + var v32 any = v29 + _ = v32 + for { + var tmp33 any + { // let + // let binding "temp__0__auto__" + tmp34 := checkDerefVar(var_glojure_DOT_core_seq) + tmp35 := lang.Apply(tmp34, []any{v32}) + var v36 any = tmp35 + _ = v36 + var tmp37 any + if lang.IsTruthy(v36) { + var tmp38 any + { // let + // let binding "s__848" + var v39 any = v36 + _ = v39 + var tmp40 any + tmp41 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp42 := lang.Apply(tmp41, []any{v39}) + if lang.IsTruthy(tmp42) { + var tmp43 any + { // let + // let binding "c__0__auto__" + tmp44 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp45 := lang.Apply(tmp44, []any{v39}) + var v46 any = tmp45 + _ = v46 + // let binding "size__1__auto__" + tmp47 := checkDerefVar(var_glojure_DOT_core_int) + tmp48 := checkDerefVar(var_glojure_DOT_core_count) + tmp49 := lang.Apply(tmp48, []any{v46}) + tmp50 := lang.Apply(tmp47, []any{tmp49}) + var v51 any = tmp50 + _ = v51 + // let binding "b__850" + tmp52 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_buffer) + tmp53 := lang.Apply(tmp52, []any{v51}) + var v54 any = tmp53 + _ = v54 + var tmp55 any + var tmp56 any + { // let + // let binding "i__849" + tmp57 := checkDerefVar(var_glojure_DOT_core_int) + tmp58 := lang.Apply(tmp57, []any{int64(0)}) + var v59 any = tmp58 + _ = v59 + for { + var tmp60 any + tmp61 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp62 := lang.Apply(tmp61, []any{v59, v51}) + if lang.IsTruthy(tmp62) { + var tmp63 any + { // let + // let binding "shift" + tmp64, _ := lang.FieldOrMethod(v46, "nth") + if reflect.TypeOf(tmp64).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp65 := lang.Apply(tmp64, []any{v59}) + var v66 any = tmp65 + _ = v66 + tmp67 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_append) + tmp68 := lang.NewVector(v66, v25) + tmp69 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6612), kw_column, int(15), kw_end_DASH_line, int(6612), kw_end_DASH_column, int(26)) + tmp70, err := lang.WithMeta(tmp68, tmp69.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp71 := lang.Apply(tmp67, []any{v54, tmp70}) + _ = tmp71 + tmp73 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp74 := lang.Apply(tmp73, []any{v59}) + var tmp72 any = tmp74 + v59 = tmp72 + continue + } // end let + tmp60 = tmp63 + } else { + tmp60 = true + } + tmp56 = tmp60 + break + } + } // end let + if lang.IsTruthy(tmp56) { + tmp57 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_cons) + tmp58 := checkDerefVar(var_glojure_DOT_core_chunk) + tmp59 := lang.Apply(tmp58, []any{v54}) + tmp60 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp61 := lang.Apply(tmp60, []any{v39}) + tmp62 := lang.Apply(v28, []any{tmp61}) + tmp63 := lang.Apply(tmp57, []any{tmp59, tmp62}) + tmp55 = tmp63 + } else { + tmp64 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_cons) + tmp65 := checkDerefVar(var_glojure_DOT_core_chunk) + tmp66 := lang.Apply(tmp65, []any{v54}) + tmp67 := lang.Apply(tmp64, []any{tmp66, nil}) + tmp55 = tmp67 + } + tmp43 = tmp55 + } // end let + tmp40 = tmp43 + } else { + var tmp44 any + { // let + // let binding "shift" + tmp45 := checkDerefVar(var_glojure_DOT_core_first) + tmp46 := lang.Apply(tmp45, []any{v39}) + var v47 any = tmp46 + _ = v47 + tmp48 := checkDerefVar(var_glojure_DOT_core_cons) + tmp49 := lang.NewVector(v47, v25) + tmp50 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6612), kw_column, int(15), kw_end_DASH_line, int(6612), kw_end_DASH_column, int(26)) + tmp51, err := lang.WithMeta(tmp49, tmp50.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp52 := checkDerefVar(var_glojure_DOT_core_rest) + tmp53 := lang.Apply(tmp52, []any{v39}) + tmp54 := lang.Apply(v28, []any{tmp53}) + tmp55 := lang.Apply(tmp48, []any{tmp51, tmp54}) + tmp44 = tmp55 + } // end let + tmp40 = tmp44 + } + tmp38 = tmp40 + } // end let + tmp37 = tmp38 + } else { + } + tmp33 = tmp37 + } // end let + tmp31 = tmp33 + break + } + } // end let + return tmp31 + }) + tmp31 := lang.Apply(lang.NewLazySeq, []any{tmp30}) + return tmp31 + }) + v28 = tmp27 + _ = v28 + } + var v28 any = tmp27 + _ = v28 + // let binding "fs__1__auto__" + tmp29 := checkDerefVar(var_glojure_DOT_core_seq) + tmp30 := checkDerefVar(var_glojure_DOT_core_range) + tmp31 := lang.Apply(tmp30, []any{int64(0), int64(31)}) + tmp32 := lang.Apply(v28, []any{tmp31}) + tmp33 := lang.Apply(tmp29, []any{tmp32}) + var v34 any = tmp33 + _ = v34 + var tmp35 any + if lang.IsTruthy(v34) { + tmp36 := checkDerefVar(var_glojure_DOT_core_concat) + tmp37 := checkDerefVar(var_glojure_DOT_core_rest) + tmp38 := lang.Apply(tmp37, []any{v14}) + tmp39 := lang.Apply(v10, []any{tmp38}) + tmp40 := lang.Apply(tmp36, []any{v34, tmp39}) + tmp35 = tmp40 + } else { + tmp42 := checkDerefVar(var_glojure_DOT_core_rest) + tmp43 := lang.Apply(tmp42, []any{v14}) + var tmp41 any = tmp43 + v14 = tmp41 + continue + } + tmp26 = tmp35 + } // end let + tmp22 = tmp26 + } // end let + tmp20 = tmp22 + } // end let + tmp19 = tmp20 + } else { + } + tmp15 = tmp19 + } // end let + tmp13 = tmp15 + break + } + } // end let + return tmp13 + }) + tmp13 := lang.Apply(lang.NewLazySeq, []any{tmp12}) + return tmp13 + }) + v10 = tmp9 + _ = v10 + } + var v10 any = tmp9 + _ = v10 + tmp11 := checkDerefVar(var_glojure_DOT_core_map) + var tmp12 lang.FnFunc + tmp12 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v13 := args[0] + _ = v13 + tmp14 := checkDerefVar(var_glojure_DOT_core_dec) + tmp15 := checkDerefVar(var_glojure_DOT_core_bit_DASH_shift_DASH_left) + tmp16 := lang.Apply(tmp15, []any{int64(1), v13}) + tmp17 := lang.Apply(tmp14, []any{tmp16}) + return tmp17 + }) + tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6610), kw_column, int(29), kw_end_DASH_line, int(6610), kw_end_DASH_column, int(55)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp15 := checkDerefVar(var_glojure_DOT_core_range) + tmp16 := checkDerefVar(var_glojure_DOT_core_inc) + tmp17 := checkDerefVar(var_glojure_DOT_core_max_DASH_mask_DASH_bits) + tmp18 := lang.Apply(tmp16, []any{tmp17}) + tmp19 := lang.Apply(tmp15, []any{int64(1), tmp18}) + tmp20 := lang.Apply(tmp11, []any{tmp14, tmp19}) + tmp21 := lang.Apply(v10, []any{tmp20}) + tmp8 = tmp21 + } // end let + tmp9 := lang.Apply(tmp4, []any{tmp7, tmp8}) + tmp10 := lang.Apply(tmp3, []any{tmp9}) + return tmp10 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_maybe_DASH_min_DASH_hash = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_maybe_DASH_min_DASH_hash.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // memoize + { + tmp0 := sym_memoize.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f)), kw_doc, "Returns a memoized version of a referentially transparent function. The\n memoized version of the function keeps a cache of the mapping from arguments\n to results and, when calls with the same arguments are repeated often, has\n higher performance at the expense of higher memory use.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(6337), kw_end_DASH_line, int(6337))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "mem" + tmp4 := checkDerefVar(var_glojure_DOT_core_atom) + tmp5 := lang.NewMap() + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6345), kw_column, int(19), kw_end_DASH_line, int(6345), kw_end_DASH_column, int(20)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp8 := lang.Apply(tmp4, []any{tmp7}) + var v9 any = tmp8 + _ = v9 + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v11 any = lang.NewList(args[0:]...) + _ = v11 + var tmp12 any + { // let + // let binding "temp__0__auto__" + tmp13 := checkDerefVar(var_glojure_DOT_core_find) + tmp14 := checkDerefVar(var_glojure_DOT_core_deref) + tmp15 := lang.Apply(tmp14, []any{v9}) + tmp16 := lang.Apply(tmp13, []any{tmp15, v11}) + var v17 any = tmp16 + _ = v17 + var tmp18 any + if lang.IsTruthy(v17) { + var tmp19 any + { // let + // let binding "e" + var v20 any = v17 + _ = v20 + tmp21 := checkDerefVar(var_glojure_DOT_core_val) + tmp22 := lang.Apply(tmp21, []any{v20}) + tmp19 = tmp22 + } // end let + tmp18 = tmp19 + } else { + var tmp20 any + { // let + // let binding "ret" + tmp21 := checkDerefVar(var_glojure_DOT_core_apply) + tmp22 := lang.Apply(tmp21, []any{v2, v11}) + var v23 any = tmp22 + _ = v23 + tmp24 := checkDerefVar(var_glojure_DOT_core_swap_BANG_) + tmp25 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp26 := lang.Apply(tmp24, []any{v9, tmp25, v11, v23}) + _ = tmp26 + tmp20 = v23 + } // end let + tmp18 = tmp20 + } + tmp12 = tmp18 + } // end let + return tmp12 + } + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6346), kw_column, int(5), kw_end_DASH_line, int(6351), kw_end_DASH_column, int(16)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp3 = tmp12 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_memoize = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_memoize.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ns + { + tmp0 := sym_ns.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name, sym_docstring_QMARK_, sym_attr_DASH_map_QMARK_, sym_references_STAR_)), kw_doc, "Sets *ns* to the namespace named by name (unevaluated), creating it\n if needed. references can be zero or more of: (:refer-glojure ...)\n (:require ...) (:use ...) (:import ...) (:load ...) (:gen-class)\n with the syntax of refer-glojure/require/use/import/load/gen-class\n respectively, except the arguments are unevaluated and need not be\n quoted. (:gen-class ...), when supplied, defaults to :name\n corresponding to the ns name, :main true, :impl-ns same as ns, and\n :init-impl-ns true. All options of gen-class are\n supported. The :gen-class directive is ignored when not\n compiling. If :gen-class is not supplied, when compiled only an\n nsname__init.class will be generated. If :refer-glojure is not used, a\n default (refer 'glojure.core) is used. Use of ns is preferred to\n individual calls to in-ns/require/use/import:\n\n (ns foo.bar\n (:refer-glojure :exclude [ancestors printf])\n (:require (glojure.contrib sql combinatorics))\n (:use (my.lib this that))\n (:import (java.util Date Timer Random)\n (java.sql Connection Statement)))", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(11), kw_line, int(5742), kw_end_DASH_line, int(5742))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "process-reference" + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v8 := args[0] + _ = v8 + var tmp9 any + { // let + // let binding "vec__798" + var v10 any = v8 + _ = v10 + // let binding "seq__799" + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := lang.Apply(tmp11, []any{v10}) + var v13 any = tmp12 + _ = v13 + // let binding "first__800" + tmp14 := checkDerefVar(var_glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v13}) + var v16 any = tmp15 + _ = v16 + // let binding "seq__799" + tmp17 := checkDerefVar(var_glojure_DOT_core_next) + tmp18 := lang.Apply(tmp17, []any{v13}) + var v19 any = tmp18 + _ = v19 + // let binding "kname" + var v20 any = v16 + _ = v20 + // let binding "args" + var v21 any = v19 + _ = v21 + tmp22 := checkDerefVar(var_glojure_DOT_core_seq) + tmp23 := checkDerefVar(var_glojure_DOT_core_concat) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := checkDerefVar(var_glojure_DOT_core_symbol) + tmp26 := checkDerefVar(var_glojure_DOT_core_name) + tmp27 := lang.Apply(tmp26, []any{v20}) + tmp28 := lang.Apply(tmp25, []any{"glojure.core", tmp27}) + tmp29 := lang.Apply(tmp24, []any{tmp28}) + tmp30 := checkDerefVar(var_glojure_DOT_core_map) + var tmp31 lang.FnFunc + tmp31 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v32 := args[0] + _ = v32 + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{sym_quote, v32}) + return tmp34 + }) + tmp32 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5769), kw_column, int(21), kw_end_DASH_line, int(5769), kw_end_DASH_column, int(36)) + tmp33, err := lang.WithMeta(tmp31, tmp32.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp34 := lang.Apply(tmp30, []any{tmp33, v21}) + tmp35 := lang.Apply(tmp23, []any{tmp29, tmp34}) + tmp36 := lang.Apply(tmp22, []any{tmp35}) + tmp9 = tmp36 + } // end let + return tmp9 + }) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5767), kw_column, int(9), kw_end_DASH_line, int(5769), kw_end_DASH_column, int(44)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v10 any = tmp9 + _ = v10 + // let binding "docstring" + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp13 := checkDerefVar(var_glojure_DOT_core_first) + tmp14 := lang.Apply(tmp13, []any{v5}) + tmp15 := lang.Apply(tmp12, []any{tmp14}) + if lang.IsTruthy(tmp15) { + tmp16 := checkDerefVar(var_glojure_DOT_core_first) + tmp17 := lang.Apply(tmp16, []any{v5}) + tmp11 = tmp17 + } else { + } + var v18 any = tmp11 + _ = v18 + // let binding "references" + var tmp19 any + if lang.IsTruthy(v18) { + tmp20 := checkDerefVar(var_glojure_DOT_core_next) + tmp21 := lang.Apply(tmp20, []any{v5}) + tmp19 = tmp21 + } else { + tmp19 = v5 + } + var v22 any = tmp19 + _ = v22 + // let binding "name" + var tmp23 any + if lang.IsTruthy(v18) { + tmp24 := checkDerefVar(var_glojure_DOT_core_vary_DASH_meta) + tmp25 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp26 := lang.Apply(tmp24, []any{v4, tmp25, kw_doc, v18}) + tmp23 = tmp26 + } else { + tmp23 = v4 + } + var v27 any = tmp23 + _ = v27 + // let binding "metadata" + var tmp28 any + tmp29 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp30 := checkDerefVar(var_glojure_DOT_core_first) + tmp31 := lang.Apply(tmp30, []any{v22}) + tmp32 := lang.Apply(tmp29, []any{tmp31}) + if lang.IsTruthy(tmp32) { + tmp33 := checkDerefVar(var_glojure_DOT_core_first) + tmp34 := lang.Apply(tmp33, []any{v22}) + tmp28 = tmp34 + } else { + } + var v35 any = tmp28 + _ = v35 + // let binding "references" + var tmp36 any + if lang.IsTruthy(v35) { + tmp37 := checkDerefVar(var_glojure_DOT_core_next) + tmp38 := lang.Apply(tmp37, []any{v22}) + tmp36 = tmp38 + } else { + tmp36 = v22 + } + var v39 any = tmp36 + _ = v39 + // let binding "name" + var tmp40 any + if lang.IsTruthy(v35) { + tmp41 := checkDerefVar(var_glojure_DOT_core_vary_DASH_meta) + tmp42 := checkDerefVar(var_glojure_DOT_core_merge) + tmp43 := lang.Apply(tmp41, []any{v27, tmp42, v35}) + tmp40 = tmp43 + } else { + tmp40 = v27 + } + var v44 any = tmp40 + _ = v44 + // let binding "gen-class-clause" + tmp45 := checkDerefVar(var_glojure_DOT_core_first) + tmp46 := checkDerefVar(var_glojure_DOT_core_filter) + var tmp47 lang.FnFunc + tmp47 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v48 := args[0] + _ = v48 + tmp49 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp50 := checkDerefVar(var_glojure_DOT_core_first) + tmp51 := lang.Apply(tmp50, []any{v48}) + tmp52 := lang.Apply(tmp49, []any{kw_gen_DASH_class, tmp51}) + return tmp52 + }) + tmp48 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5780), kw_column, int(41), kw_end_DASH_line, int(5780), kw_end_DASH_column, int(65)) + tmp49, err := lang.WithMeta(tmp47, tmp48.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp50 := lang.Apply(tmp46, []any{tmp49, v39}) + tmp51 := lang.Apply(tmp45, []any{tmp50}) + var v52 any = tmp51 + _ = v52 + // let binding "gen-class-call" + var tmp53 any + if lang.IsTruthy(v52) { + tmp54 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp55 := checkDerefVar(var_glojure_DOT_core_str) + tmp56 := lang.Apply(tmp55, []any{v44}) + tmp57, _ := lang.FieldOrMethod(tmp56, "replace") + if reflect.TypeOf(tmp57).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("replace is not a function"))) + } + tmp58 := lang.Apply(tmp57, []any{lang.NewChar(45), lang.NewChar(95)}) + tmp59 := checkDerefVar(var_glojure_DOT_core_next) + tmp60 := lang.Apply(tmp59, []any{v52}) + tmp61 := lang.Apply(tmp54, []any{sym_glojure_DOT_core_SLASH_gen_DASH_class, kw_name, tmp58, kw_impl_DASH_ns, v44, kw_main, true, tmp60}) + tmp53 = tmp61 + } else { + } + var v62 any = tmp53 + _ = v62 + // let binding "references" + tmp63 := checkDerefVar(var_glojure_DOT_core_remove) + var tmp64 lang.FnFunc + tmp64 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v65 := args[0] + _ = v65 + tmp66 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp67 := checkDerefVar(var_glojure_DOT_core_first) + tmp68 := lang.Apply(tmp67, []any{v65}) + tmp69 := lang.Apply(tmp66, []any{kw_gen_DASH_class, tmp68}) + return tmp69 + }) + tmp65 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5784), kw_column, int(28), kw_end_DASH_line, int(5784), kw_end_DASH_column, int(52)) + tmp66, err := lang.WithMeta(tmp64, tmp65.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp67 := lang.Apply(tmp63, []any{tmp66, v39}) + var v68 any = tmp67 + _ = v68 + // let binding "name-metadata" + tmp69 := checkDerefVar(var_glojure_DOT_core_meta) + tmp70 := lang.Apply(tmp69, []any{v44}) + var v71 any = tmp70 + _ = v71 + tmp72 := checkDerefVar(var_glojure_DOT_core_seq) + tmp73 := checkDerefVar(var_glojure_DOT_core_concat) + tmp74 := checkDerefVar(var_glojure_DOT_core_list) + tmp75 := lang.Apply(tmp74, []any{sym_do}) + tmp76 := checkDerefVar(var_glojure_DOT_core_list) + tmp77 := checkDerefVar(var_glojure_DOT_core_seq) + tmp78 := checkDerefVar(var_glojure_DOT_core_concat) + tmp79 := checkDerefVar(var_glojure_DOT_core_list) + tmp80 := lang.Apply(tmp79, []any{sym_glojure_DOT_core_SLASH_in_DASH_ns}) + tmp81 := checkDerefVar(var_glojure_DOT_core_list) + tmp82 := checkDerefVar(var_glojure_DOT_core_seq) + tmp83 := checkDerefVar(var_glojure_DOT_core_concat) + tmp84 := checkDerefVar(var_glojure_DOT_core_list) + tmp85 := lang.Apply(tmp84, []any{sym_quote}) + tmp86 := checkDerefVar(var_glojure_DOT_core_list) + tmp87 := lang.Apply(tmp86, []any{v44}) + tmp88 := lang.Apply(tmp83, []any{tmp85, tmp87}) + tmp89 := lang.Apply(tmp82, []any{tmp88}) + tmp90 := lang.Apply(tmp81, []any{tmp89}) + tmp91 := lang.Apply(tmp78, []any{tmp80, tmp90}) + tmp92 := lang.Apply(tmp77, []any{tmp91}) + tmp93 := lang.Apply(tmp76, []any{tmp92}) + var tmp94 any + if lang.IsTruthy(v71) { + tmp95 := checkDerefVar(var_glojure_DOT_core_seq) + tmp96 := checkDerefVar(var_glojure_DOT_core_concat) + tmp97 := checkDerefVar(var_glojure_DOT_core_list) + tmp98 := checkDerefVar(var_glojure_DOT_core_seq) + tmp99 := checkDerefVar(var_glojure_DOT_core_concat) + tmp100 := checkDerefVar(var_glojure_DOT_core_list) + tmp101 := lang.Apply(tmp100, []any{sym__DOT_ResetMeta}) + tmp102 := checkDerefVar(var_glojure_DOT_core_list) + tmp103 := checkDerefVar(var_glojure_DOT_core_seq) + tmp104 := checkDerefVar(var_glojure_DOT_core_concat) + tmp105 := checkDerefVar(var_glojure_DOT_core_list) + tmp106 := lang.Apply(tmp105, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_FindNamespace}) + tmp107 := checkDerefVar(var_glojure_DOT_core_list) + tmp108 := checkDerefVar(var_glojure_DOT_core_seq) + tmp109 := checkDerefVar(var_glojure_DOT_core_concat) + tmp110 := checkDerefVar(var_glojure_DOT_core_list) + tmp111 := lang.Apply(tmp110, []any{sym_quote}) + tmp112 := checkDerefVar(var_glojure_DOT_core_list) + tmp113 := lang.Apply(tmp112, []any{v44}) + tmp114 := lang.Apply(tmp109, []any{tmp111, tmp113}) + tmp115 := lang.Apply(tmp108, []any{tmp114}) + tmp116 := lang.Apply(tmp107, []any{tmp115}) + tmp117 := lang.Apply(tmp104, []any{tmp106, tmp116}) + tmp118 := lang.Apply(tmp103, []any{tmp117}) + tmp119 := lang.Apply(tmp102, []any{tmp118}) + tmp120 := checkDerefVar(var_glojure_DOT_core_list) + tmp121 := lang.Apply(tmp120, []any{v71}) + tmp122 := lang.Apply(tmp99, []any{tmp101, tmp119, tmp121}) + tmp123 := lang.Apply(tmp98, []any{tmp122}) + tmp124 := lang.Apply(tmp97, []any{tmp123}) + tmp125 := lang.Apply(tmp96, []any{tmp124}) + tmp126 := lang.Apply(tmp95, []any{tmp125}) + tmp94 = tmp126 + } else { + } + tmp127 := checkDerefVar(var_glojure_DOT_core_list) + tmp128 := checkDerefVar(var_glojure_DOT_core_seq) + tmp129 := checkDerefVar(var_glojure_DOT_core_concat) + tmp130 := checkDerefVar(var_glojure_DOT_core_list) + tmp131 := lang.Apply(tmp130, []any{sym_glojure_DOT_core_SLASH_with_DASH_loading_DASH_context}) + var tmp132 any + if lang.IsTruthy(v62) { + tmp133 := checkDerefVar(var_glojure_DOT_core_list) + tmp134 := lang.Apply(tmp133, []any{v62}) + tmp132 = tmp134 + } else { + } + var tmp135 any + var tmp136 any + { // let + // let binding "and__0__auto__" + tmp137 := checkDerefVar(var_glojure_DOT_core_not_EQ_) + tmp138 := lang.Apply(tmp137, []any{v44, sym_glojure_DOT_core}) + var v139 any = tmp138 + _ = v139 + var tmp140 any + if lang.IsTruthy(v139) { + tmp141 := checkDerefVar(var_glojure_DOT_core_not_DASH_any_QMARK_) + var tmp142 lang.FnFunc + tmp142 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v143 := args[0] + _ = v143 + tmp144 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp145 := checkDerefVar(var_glojure_DOT_core_first) + tmp146 := lang.Apply(tmp145, []any{v143}) + tmp147 := lang.Apply(tmp144, []any{kw_refer_DASH_glojure, tmp146}) + return tmp147 + }) + tmp143 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5793), kw_column, int(58), kw_end_DASH_line, int(5793), kw_end_DASH_column, int(86)) + tmp144, err := lang.WithMeta(tmp142, tmp143.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp145 := lang.Apply(tmp141, []any{tmp144, v68}) + tmp140 = tmp145 + } else { + tmp140 = v139 + } + tmp136 = tmp140 + } // end let + if lang.IsTruthy(tmp136) { + tmp137 := checkDerefVar(var_glojure_DOT_core_seq) + tmp138 := checkDerefVar(var_glojure_DOT_core_concat) + tmp139 := checkDerefVar(var_glojure_DOT_core_list) + tmp140 := checkDerefVar(var_glojure_DOT_core_seq) + tmp141 := checkDerefVar(var_glojure_DOT_core_concat) + tmp142 := checkDerefVar(var_glojure_DOT_core_list) + tmp143 := lang.Apply(tmp142, []any{sym_glojure_DOT_core_SLASH_refer}) + tmp144 := checkDerefVar(var_glojure_DOT_core_list) + tmp145 := checkDerefVar(var_glojure_DOT_core_seq) + tmp146 := checkDerefVar(var_glojure_DOT_core_concat) + tmp147 := checkDerefVar(var_glojure_DOT_core_list) + tmp148 := lang.Apply(tmp147, []any{sym_quote}) + tmp149 := checkDerefVar(var_glojure_DOT_core_list) + tmp150 := lang.Apply(tmp149, []any{sym_glojure_DOT_core}) + tmp151 := lang.Apply(tmp146, []any{tmp148, tmp150}) + tmp152 := lang.Apply(tmp145, []any{tmp151}) + tmp153 := lang.Apply(tmp144, []any{tmp152}) + tmp154 := lang.Apply(tmp141, []any{tmp143, tmp153}) + tmp155 := lang.Apply(tmp140, []any{tmp154}) + tmp156 := lang.Apply(tmp139, []any{tmp155}) + tmp157 := lang.Apply(tmp138, []any{tmp156}) + tmp158 := lang.Apply(tmp137, []any{tmp157}) + tmp135 = tmp158 + } else { + } + tmp159 := checkDerefVar(var_glojure_DOT_core_map) + tmp160 := lang.Apply(tmp159, []any{v10, v68}) + tmp161 := lang.Apply(tmp129, []any{tmp131, tmp132, tmp135, tmp160}) + tmp162 := lang.Apply(tmp128, []any{tmp161}) + tmp163 := lang.Apply(tmp127, []any{tmp162}) + tmp164 := checkDerefVar(var_glojure_DOT_core_list) + tmp165 := checkDerefVar(var_glojure_DOT_core_seq) + tmp166 := checkDerefVar(var_glojure_DOT_core_concat) + tmp167 := checkDerefVar(var_glojure_DOT_core_list) + tmp168 := lang.Apply(tmp167, []any{sym_if}) + tmp169 := checkDerefVar(var_glojure_DOT_core_list) + tmp170 := checkDerefVar(var_glojure_DOT_core_seq) + tmp171 := checkDerefVar(var_glojure_DOT_core_concat) + tmp172 := checkDerefVar(var_glojure_DOT_core_list) + tmp173 := lang.Apply(tmp172, []any{sym__DOT_Equals}) + tmp174 := checkDerefVar(var_glojure_DOT_core_list) + tmp175 := checkDerefVar(var_glojure_DOT_core_seq) + tmp176 := checkDerefVar(var_glojure_DOT_core_concat) + tmp177 := checkDerefVar(var_glojure_DOT_core_list) + tmp178 := lang.Apply(tmp177, []any{sym_quote}) + tmp179 := checkDerefVar(var_glojure_DOT_core_list) + tmp180 := lang.Apply(tmp179, []any{v44}) + tmp181 := lang.Apply(tmp176, []any{tmp178, tmp180}) + tmp182 := lang.Apply(tmp175, []any{tmp181}) + tmp183 := lang.Apply(tmp174, []any{tmp182}) + tmp184 := checkDerefVar(var_glojure_DOT_core_list) + tmp185 := checkDerefVar(var_glojure_DOT_core_seq) + tmp186 := checkDerefVar(var_glojure_DOT_core_concat) + tmp187 := checkDerefVar(var_glojure_DOT_core_list) + tmp188 := lang.Apply(tmp187, []any{sym_quote}) + tmp189 := checkDerefVar(var_glojure_DOT_core_list) + tmp190 := lang.Apply(tmp189, []any{sym_glojure_DOT_core}) + tmp191 := lang.Apply(tmp186, []any{tmp188, tmp190}) + tmp192 := lang.Apply(tmp185, []any{tmp191}) + tmp193 := lang.Apply(tmp184, []any{tmp192}) + tmp194 := lang.Apply(tmp171, []any{tmp173, tmp183, tmp193}) + tmp195 := lang.Apply(tmp170, []any{tmp194}) + tmp196 := lang.Apply(tmp169, []any{tmp195}) + tmp197 := checkDerefVar(var_glojure_DOT_core_list) + tmp198 := lang.Apply(tmp197, []any{nil}) + tmp199 := checkDerefVar(var_glojure_DOT_core_list) + tmp200 := checkDerefVar(var_glojure_DOT_core_seq) + tmp201 := checkDerefVar(var_glojure_DOT_core_concat) + tmp202 := checkDerefVar(var_glojure_DOT_core_list) + tmp203 := lang.Apply(tmp202, []any{sym_do}) + tmp204 := checkDerefVar(var_glojure_DOT_core_list) + tmp205 := checkDerefVar(var_glojure_DOT_core_seq) + tmp206 := checkDerefVar(var_glojure_DOT_core_concat) + tmp207 := checkDerefVar(var_glojure_DOT_core_list) + tmp208 := lang.Apply(tmp207, []any{sym_glojure_DOT_core_SLASH_dosync}) + tmp209 := checkDerefVar(var_glojure_DOT_core_list) + tmp210 := checkDerefVar(var_glojure_DOT_core_seq) + tmp211 := checkDerefVar(var_glojure_DOT_core_concat) + tmp212 := checkDerefVar(var_glojure_DOT_core_list) + tmp213 := lang.Apply(tmp212, []any{sym_glojure_DOT_core_SLASH_commute}) + tmp214 := checkDerefVar(var_glojure_DOT_core_list) + tmp215 := checkDerefVar(var_glojure_DOT_core_seq) + tmp216 := checkDerefVar(var_glojure_DOT_core_concat) + tmp217 := checkDerefVar(var_glojure_DOT_core_list) + tmp218 := lang.Apply(tmp217, []any{sym_glojure_DOT_core_SLASH_deref}) + tmp219 := checkDerefVar(var_glojure_DOT_core_list) + tmp220 := checkDerefVar(var_glojure_DOT_core_seq) + tmp221 := checkDerefVar(var_glojure_DOT_core_concat) + tmp222 := checkDerefVar(var_glojure_DOT_core_list) + tmp223 := lang.Apply(tmp222, []any{sym_var}) + tmp224 := checkDerefVar(var_glojure_DOT_core_list) + tmp225 := lang.Apply(tmp224, []any{sym_glojure_DOT_core_SLASH__STAR_loaded_DASH_libs_STAR_}) + tmp226 := lang.Apply(tmp221, []any{tmp223, tmp225}) + tmp227 := lang.Apply(tmp220, []any{tmp226}) + tmp228 := lang.Apply(tmp219, []any{tmp227}) + tmp229 := lang.Apply(tmp216, []any{tmp218, tmp228}) + tmp230 := lang.Apply(tmp215, []any{tmp229}) + tmp231 := lang.Apply(tmp214, []any{tmp230}) + tmp232 := checkDerefVar(var_glojure_DOT_core_list) + tmp233 := lang.Apply(tmp232, []any{sym_glojure_DOT_core_SLASH_conj}) + tmp234 := checkDerefVar(var_glojure_DOT_core_list) + tmp235 := checkDerefVar(var_glojure_DOT_core_seq) + tmp236 := checkDerefVar(var_glojure_DOT_core_concat) + tmp237 := checkDerefVar(var_glojure_DOT_core_list) + tmp238 := lang.Apply(tmp237, []any{sym_quote}) + tmp239 := checkDerefVar(var_glojure_DOT_core_list) + tmp240 := lang.Apply(tmp239, []any{v44}) + tmp241 := lang.Apply(tmp236, []any{tmp238, tmp240}) + tmp242 := lang.Apply(tmp235, []any{tmp241}) + tmp243 := lang.Apply(tmp234, []any{tmp242}) + tmp244 := lang.Apply(tmp211, []any{tmp213, tmp231, tmp233, tmp243}) + tmp245 := lang.Apply(tmp210, []any{tmp244}) + tmp246 := lang.Apply(tmp209, []any{tmp245}) + tmp247 := lang.Apply(tmp206, []any{tmp208, tmp246}) + tmp248 := lang.Apply(tmp205, []any{tmp247}) + tmp249 := lang.Apply(tmp204, []any{tmp248}) + tmp250 := checkDerefVar(var_glojure_DOT_core_list) + tmp251 := lang.Apply(tmp250, []any{nil}) + tmp252 := lang.Apply(tmp201, []any{tmp203, tmp249, tmp251}) + tmp253 := lang.Apply(tmp200, []any{tmp252}) + tmp254 := lang.Apply(tmp199, []any{tmp253}) + tmp255 := lang.Apply(tmp166, []any{tmp168, tmp196, tmp198, tmp254}) + tmp256 := lang.Apply(tmp165, []any{tmp255}) + tmp257 := lang.Apply(tmp164, []any{tmp256}) + tmp258 := lang.Apply(tmp73, []any{tmp75, tmp93, tmp94, tmp163, tmp257}) + tmp259 := lang.Apply(tmp72, []any{tmp258}) + tmp6 = tmp259 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ns = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ns.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ns-imports + { + tmp0 := sym_ns_DASH_imports.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_ns)), kw_doc, "Returns a map of the import mappings for the namespace.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(4199), kw_end_DASH_line, int(4199))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_filter_DASH_key) + tmp4 := checkDerefVar(var_glojure_DOT_core_val) + tmp5 := checkDerefVar(var_glojure_DOT_core_partial) + tmp6 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp7 := reflect.TypeOf((*reflect.Type)(nil)).Elem() + tmp8 := lang.Apply(tmp5, []any{tmp6, tmp7}) + tmp9 := checkDerefVar(var_glojure_DOT_core_ns_DASH_map) + tmp10 := lang.Apply(tmp9, []any{v2}) + tmp11 := lang.Apply(tmp3, []any{tmp4, tmp8, tmp10}) + return tmp11 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ns_DASH_imports = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ns_DASH_imports.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // partition + { + tmp0 := sym_partition.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n, sym_coll), lang.NewVector(sym_n, sym_step, sym_coll), lang.NewVector(sym_n, sym_step, sym_pad, sym_coll)), kw_doc, "Returns a lazy sequence of lists of n items each, at offsets step\n apart. If step is not supplied, defaults to n, i.e. the partitions\n do not overlap. If a pad collection is supplied, use its elements as\n necessary to complete last partition upto n items. In case there are\n not enough padding elements, return a partition with less than n items.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(3177), kw_end_DASH_line, int(3177))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_partition) + tmp5 := lang.Apply(tmp4, []any{v2, v2, v3}) + return tmp5 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp6 any + { // let + // let binding "temp__0__auto__" + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := lang.Apply(tmp7, []any{v4}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + var tmp11 any + { // let + // let binding "s" + var v12 any = v9 + _ = v12 + var tmp13 any + { // let + // let binding "p" + tmp14 := checkDerefVar(var_glojure_DOT_core_doall) + tmp15 := checkDerefVar(var_glojure_DOT_core_take) + tmp16 := lang.Apply(tmp15, []any{v2, v12}) + tmp17 := lang.Apply(tmp14, []any{tmp16}) + var v18 any = tmp17 + _ = v18 + var tmp19 any + tmp20 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp21 := checkDerefVar(var_glojure_DOT_core_count) + tmp22 := lang.Apply(tmp21, []any{v18}) + tmp23 := lang.Apply(tmp20, []any{v2, tmp22}) + if lang.IsTruthy(tmp23) { + tmp24 := checkDerefVar(var_glojure_DOT_core_cons) + tmp25 := checkDerefVar(var_glojure_DOT_core_partition) + tmp26 := checkDerefVar(var_glojure_DOT_core_nthrest) + tmp27 := lang.Apply(tmp26, []any{v12, v3}) + tmp28 := lang.Apply(tmp25, []any{v2, v3, tmp27}) + tmp29 := lang.Apply(tmp24, []any{v18, tmp28}) + tmp19 = tmp29 + } else { + } + tmp13 = tmp19 + } // end let + tmp11 = tmp13 + } // end let + tmp10 = tmp11 + } else { + } + tmp6 = tmp10 + } // end let + return tmp6 + }) + tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) + return tmp6 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp7 any + { // let + // let binding "temp__0__auto__" + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := lang.Apply(tmp8, []any{v5}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + if lang.IsTruthy(v10) { + var tmp12 any + { // let + // let binding "s" + var v13 any = v10 + _ = v13 + var tmp14 any + { // let + // let binding "p" + tmp15 := checkDerefVar(var_glojure_DOT_core_doall) + tmp16 := checkDerefVar(var_glojure_DOT_core_take) + tmp17 := lang.Apply(tmp16, []any{v2, v13}) + tmp18 := lang.Apply(tmp15, []any{tmp17}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + tmp21 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp22 := checkDerefVar(var_glojure_DOT_core_count) + tmp23 := lang.Apply(tmp22, []any{v19}) + tmp24 := lang.Apply(tmp21, []any{v2, tmp23}) + if lang.IsTruthy(tmp24) { + tmp25 := checkDerefVar(var_glojure_DOT_core_cons) + tmp26 := checkDerefVar(var_glojure_DOT_core_partition) + tmp27 := checkDerefVar(var_glojure_DOT_core_nthrest) + tmp28 := lang.Apply(tmp27, []any{v13, v3}) + tmp29 := lang.Apply(tmp26, []any{v2, v3, v4, tmp28}) + tmp30 := lang.Apply(tmp25, []any{v19, tmp29}) + tmp20 = tmp30 + } else { + tmp31 := checkDerefVar(var_glojure_DOT_core_list) + tmp32 := checkDerefVar(var_glojure_DOT_core_take) + tmp33 := checkDerefVar(var_glojure_DOT_core_concat) + tmp34 := lang.Apply(tmp33, []any{v19, v4}) + tmp35 := lang.Apply(tmp32, []any{v2, tmp34}) + tmp36 := lang.Apply(tmp31, []any{tmp35}) + tmp20 = tmp36 + } + tmp14 = tmp20 + } // end let + tmp12 = tmp14 + } // end let + tmp11 = tmp12 + } else { + } + tmp7 = tmp11 + } // end let + return tmp7 + }) + tmp7 := lang.Apply(lang.NewLazySeq, []any{tmp6}) + return tmp7 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_partition = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_partition.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // partition-all + { + tmp0 := sym_partition_DASH_all.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n), lang.NewVector(sym_n, sym_coll), lang.NewVector(sym_n, sym_step, sym_coll)), kw_doc, "Returns a lazy sequence of lists like partition, but may include\n partitions with fewer than n items at the end. Returns a stateful\n transducer when no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(7222), kw_end_DASH_line, int(7222))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 any + { // let + // let binding "a" + tmp6 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) + tmp7 := lang.Apply(tmp6, []any{v2}) + tmp8 := lang.Apply(lang.NewArrayList, []any{tmp7}) + var v9 any = tmp8 + _ = v9 + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp11 := lang.Apply(v4, nil) + return tmp11 + case 1: + v11 := args[0] + _ = v11 + var tmp12 any + { // let + // let binding "result" + var tmp13 any + tmp14, ok := lang.FieldOrMethod(v9, "isEmpty") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v9, "isEmpty"))) + } + var tmp15 any + switch reflect.TypeOf(tmp14).Kind() { + case reflect.Func: + tmp15 = lang.Apply(tmp14, nil) + default: + tmp15 = tmp14 + } + if lang.IsTruthy(tmp15) { + tmp13 = v11 + } else { + var tmp16 any + { // let + // let binding "v" + tmp17 := checkDerefVar(var_glojure_DOT_core_vec) + tmp18, ok := lang.FieldOrMethod(v9, "toArray") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v9, "toArray"))) + } + var tmp19 any + switch reflect.TypeOf(tmp18).Kind() { + case reflect.Func: + tmp19 = lang.Apply(tmp18, nil) + default: + tmp19 = tmp18 + } + tmp20 := lang.Apply(tmp17, []any{tmp19}) + var v21 any = tmp20 + _ = v21 + tmp22, ok := lang.FieldOrMethod(v9, "clear") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v9, "clear"))) + } + var tmp23 any + switch reflect.TypeOf(tmp22).Kind() { + case reflect.Func: + tmp23 = lang.Apply(tmp22, nil) + default: + tmp23 = tmp22 + } + _ = tmp23 + tmp24 := checkDerefVar(var_glojure_DOT_core_unreduced) + tmp25 := lang.Apply(v4, []any{v11, v21}) + tmp26 := lang.Apply(tmp24, []any{tmp25}) + tmp16 = tmp26 + } // end let + tmp13 = tmp16 + } + var v17 any = tmp13 + _ = v17 + tmp18 := lang.Apply(v4, []any{v17}) + tmp12 = tmp18 + } // end let + return tmp12 + case 2: + v11 := args[0] + _ = v11 + v12 := args[1] + _ = v12 + tmp13, _ := lang.FieldOrMethod(v9, "add") + if reflect.TypeOf(tmp13).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) + } + tmp14 := lang.Apply(tmp13, []any{v12}) + _ = tmp14 + var tmp15 any + tmp16 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp17, ok := lang.FieldOrMethod(v9, "size") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v9, "size"))) + } + var tmp18 any + switch reflect.TypeOf(tmp17).Kind() { + case reflect.Func: + tmp18 = lang.Apply(tmp17, nil) + default: + tmp18 = tmp17 + } + tmp19 := lang.Apply(tmp16, []any{v2, tmp18}) + if lang.IsTruthy(tmp19) { + var tmp20 any + { // let + // let binding "v" + tmp21 := checkDerefVar(var_glojure_DOT_core_vec) + tmp22, ok := lang.FieldOrMethod(v9, "toArray") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v9, "toArray"))) + } + var tmp23 any + switch reflect.TypeOf(tmp22).Kind() { + case reflect.Func: + tmp23 = lang.Apply(tmp22, nil) + default: + tmp23 = tmp22 + } + tmp24 := lang.Apply(tmp21, []any{tmp23}) + var v25 any = tmp24 + _ = v25 + tmp26, ok := lang.FieldOrMethod(v9, "clear") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v9, "clear"))) + } + var tmp27 any + switch reflect.TypeOf(tmp26).Kind() { + case reflect.Func: + tmp27 = lang.Apply(tmp26, nil) + default: + tmp27 = tmp26 + } + _ = tmp27 + tmp28 := lang.Apply(v4, []any{v11, v25}) + tmp20 = tmp28 + } // end let + tmp15 = tmp20 + } else { + tmp15 = v11 + } + return tmp15 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7231), kw_column, int(8), kw_end_DASH_line, int(7247), kw_end_DASH_column, int(23)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp5 = tmp12 + } // end let + return tmp5 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7229), kw_column, int(4), kw_end_DASH_line, int(7247), kw_end_DASH_column, int(25)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_partition_DASH_all) + tmp5 := lang.Apply(tmp4, []any{v2, v2, v3}) + return tmp5 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp6 any + { // let + // let binding "temp__0__auto__" + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := lang.Apply(tmp7, []any{v4}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + var tmp11 any + { // let + // let binding "s" + var v12 any = v9 + _ = v12 + var tmp13 any + { // let + // let binding "seg" + tmp14 := checkDerefVar(var_glojure_DOT_core_doall) + tmp15 := checkDerefVar(var_glojure_DOT_core_take) + tmp16 := lang.Apply(tmp15, []any{v2, v12}) + tmp17 := lang.Apply(tmp14, []any{tmp16}) + var v18 any = tmp17 + _ = v18 + tmp19 := checkDerefVar(var_glojure_DOT_core_cons) + tmp20 := checkDerefVar(var_glojure_DOT_core_partition_DASH_all) + tmp21 := checkDerefVar(var_glojure_DOT_core_nthrest) + tmp22 := lang.Apply(tmp21, []any{v12, v3}) + tmp23 := lang.Apply(tmp20, []any{v2, v3, tmp22}) + tmp24 := lang.Apply(tmp19, []any{v18, tmp23}) + tmp13 = tmp24 + } // end let + tmp11 = tmp13 + } // end let + tmp10 = tmp11 + } else { + } + tmp6 = tmp10 + } // end let + return tmp6 + }) + tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_partition_DASH_all = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_partition_DASH_all.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // pcalls + { + tmp0 := sym_pcalls.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_fns)), kw_doc, "Executes the no-arg fns in parallel, returning a lazy sequence of\n their values", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(7056), kw_end_DASH_line, int(7056))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_pmap) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v5 := args[0] + _ = v5 + tmp6 := lang.Apply(v5, nil) + return tmp6 + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7061), kw_column, int(17), kw_end_DASH_line, int(7061), kw_end_DASH_column, int(20)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp7 := lang.Apply(tmp3, []any{tmp6, v2}) + return tmp7 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_pcalls = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_pcalls.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // prep-ints + { + tmp0 := sym_prep_DASH_ints.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_tests, sym_thens)), kw_doc, "Takes a sequence of int-sized test constants and a corresponding sequence of\n then expressions. Returns a tuple of [shift mask case-map switch-type] where\n case-map is a map of int case values to [test then] tuples, and switch-type\n is either :sparse or :compact.", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(8), kw_line, int(6631), kw_end_DASH_line, int(6631), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_fits_DASH_table_QMARK_) + tmp6 := lang.Apply(tmp5, []any{v2}) + if lang.IsTruthy(tmp6) { + tmp7 := checkDerefVar(var_glojure_DOT_core_case_DASH_map) + tmp8 := checkDerefVar(var_glojure_DOT_core_int) + tmp9 := checkDerefVar(var_glojure_DOT_core_int) + tmp10 := lang.Apply(tmp7, []any{tmp8, tmp9, v2, v3}) + tmp11 := lang.NewVector(int64(0), int64(0), tmp10, kw_compact) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6639), kw_column, int(5), kw_end_DASH_line, int(6639), kw_end_DASH_column, int(49)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp4 = tmp13 + } else { + var tmp14 any + { // let + // let binding "vec__851" + var tmp15 any + { // let + // let binding "or__0__auto__" + tmp16 := checkDerefVar(var_glojure_DOT_core_maybe_DASH_min_DASH_hash) + tmp17 := checkDerefVar(var_glojure_DOT_core_map) + tmp18 := checkDerefVar(var_glojure_DOT_core_int) + tmp19 := lang.Apply(tmp17, []any{tmp18, v2}) + tmp20 := lang.Apply(tmp16, []any{tmp19}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + if lang.IsTruthy(v21) { + tmp22 = v21 + } else { + tmp23 := lang.NewVector(int64(0), int64(0)) + tmp24 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6640), kw_column, int(61), kw_end_DASH_line, int(6640), kw_end_DASH_column, int(65)) + tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp22 = tmp25 + } + tmp15 = tmp22 + } // end let + var v16 any = tmp15 + _ = v16 + // let binding "shift" + tmp17 := checkDerefVar(var_glojure_DOT_core_nth) + tmp18 := lang.Apply(tmp17, []any{v16, int64(0), nil}) + var v19 any = tmp18 + _ = v19 + // let binding "mask" + tmp20 := checkDerefVar(var_glojure_DOT_core_nth) + tmp21 := lang.Apply(tmp20, []any{v16, int64(1), nil}) + var v22 any = tmp21 + _ = v22 + var tmp23 any + tmp24 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) + tmp25 := lang.Apply(tmp24, []any{v22}) + if lang.IsTruthy(tmp25) { + tmp26 := checkDerefVar(var_glojure_DOT_core_case_DASH_map) + tmp27 := checkDerefVar(var_glojure_DOT_core_int) + tmp28 := checkDerefVar(var_glojure_DOT_core_int) + tmp29 := lang.Apply(tmp26, []any{tmp27, tmp28, v2, v3}) + tmp30 := lang.NewVector(int64(0), int64(0), tmp29, kw_sparse) + tmp31 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6643), kw_column, int(9), kw_end_DASH_line, int(6643), kw_end_DASH_column, int(52)) + tmp32, err := lang.WithMeta(tmp30, tmp31.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp23 = tmp32 + } else { + tmp33 := checkDerefVar(var_glojure_DOT_core_case_DASH_map) + var tmp34 lang.FnFunc + tmp34 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v35 := args[0] + _ = v35 + tmp36 := checkDerefVar(var_glojure_DOT_core_shift_DASH_mask) + tmp37 := checkDerefVar(var_glojure_DOT_core_int) + tmp38 := lang.Apply(tmp37, []any{v35}) + tmp39 := lang.Apply(tmp36, []any{v19, v22, tmp38}) + return tmp39 + }) + tmp35 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6645), kw_column, int(31), kw_end_DASH_line, int(6645), kw_end_DASH_column, int(62)) + tmp36, err := lang.WithMeta(tmp34, tmp35.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp37 := checkDerefVar(var_glojure_DOT_core_int) + tmp38 := lang.Apply(tmp33, []any{tmp36, tmp37, v2, v3}) + tmp39 := lang.NewVector(v19, v22, tmp38, kw_compact) + tmp40 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6645), kw_column, int(9), kw_end_DASH_line, int(6645), kw_end_DASH_column, int(89)) + tmp41, err := lang.WithMeta(tmp39, tmp40.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp23 = tmp41 + } + tmp14 = tmp23 + } // end let + tmp4 = tmp14 + } + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_prep_DASH_ints = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_prep_DASH_ints.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print-prefix-map + { + tmp0 := sym_print_DASH_prefix_DASH_map.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(243), kw_column, int(8), kw_end_DASH_line, int(243), kw_end_DASH_column, int(23), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_prefix, sym_kvs, sym_print_DASH_one, sym_w)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_print_DASH_sequential) + tmp7 := checkDerefVar(var_glojure_DOT_core_str) + tmp8 := lang.Apply(tmp7, []any{v2, "{"}) + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + var tmp12 any + { // let + // let binding "vec__903" + var v13 any = v10 + _ = v13 + // let binding "k" + tmp14 := checkDerefVar(var_glojure_DOT_core_nth) + tmp15 := lang.Apply(tmp14, []any{v13, int64(0), nil}) + var v16 any = tmp15 + _ = v16 + // let binding "v" + tmp17 := checkDerefVar(var_glojure_DOT_core_nth) + tmp18 := lang.Apply(tmp17, []any{v13, int64(1), nil}) + var v19 any = tmp18 + _ = v19 + tmp20 := lang.Apply(v4, []any{v16, v11}) + _ = tmp20 + tmp21 := lang.Apply(lang.AppendWriter, []any{v11, lang.NewChar(32)}) + _ = tmp21 + tmp22 := lang.Apply(v4, []any{v19, v11}) + tmp12 = tmp22 + } // end let + return tmp12 + }) + tmp10 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(246), kw_column, int(5), kw_end_DASH_line, int(247), kw_end_DASH_column, int(107)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp12 := lang.Apply(tmp6, []any{tmp8, tmp11, ", ", "}", v3, v5}) + return tmp12 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_print_DASH_prefix_DASH_map = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_print_DASH_prefix_DASH_map.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // promise + { + tmp0 := sym_promise.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Returns a promise object that can be read with deref/@, and set,\n once only, with deliver. Calls to deref/@ prior to delivery will\n block, unless the variant of deref with timeout is used. All\n subsequent derefs will return the same delivered value without\n blocking. See also - realized?.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(7078), kw_end_DASH_line, int(7078))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp2 any + { // let + // let binding "d" + tmp3 := lang.Apply(nil, []any{int64(1)}) + var v4 any = tmp3 + _ = v4 + // let binding "v" + tmp5 := checkDerefVar(var_glojure_DOT_core_atom) + tmp6 := lang.Apply(tmp5, []any{v4}) + var v7 any = tmp6 + _ = v7 + tmp8 := reflect.TypeOf((*lang.IDeref)(nil)).Elem() + tmp9 := checkDerefVar(var_glojure_DOT_core_deref) + tmp10 := lang.NewVector(nil) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7091), kw_column, int(15), kw_end_DASH_line, int(7091), kw_end_DASH_column, int(17)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13, ok := lang.FieldOrMethod(v4, "await") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "await"))) + } + var tmp14 any + switch reflect.TypeOf(tmp13).Kind() { + case reflect.Func: + tmp14 = lang.Apply(tmp13, nil) + default: + tmp14 = tmp13 + } + tmp15 := checkDerefVar(var_glojure_DOT_core_deref) + tmp16 := lang.Apply(tmp15, []any{v7}) + tmp17 := lang.Apply(tmp9, []any{tmp12, tmp14, tmp16}) + tmp18 := reflect.TypeOf((*lang.IBlockingDeref)(nil)).Elem() + tmp19 := checkDerefVar(var_glojure_DOT_core_deref) + tmp20 := lang.NewVector(nil, nil, nil) + tmp21 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7094), kw_column, int(9), kw_end_DASH_line, int(7094), kw_end_DASH_column, int(34)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var tmp23 any + tmp24, _ := lang.FieldOrMethod(v4, "await") + if reflect.TypeOf(tmp24).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) + } + tmp25 := lang.Apply(tmp24, []any{nil, time7.Millisecond}) + if lang.IsTruthy(tmp25) { + tmp26 := checkDerefVar(var_glojure_DOT_core_deref) + tmp27 := lang.Apply(tmp26, []any{v7}) + tmp23 = tmp27 + } else { + } + tmp28 := lang.Apply(tmp19, []any{tmp22, tmp23}) + tmp29 := reflect.TypeOf((*lang.IPending)(nil)).Elem() + tmp30 := lang.NewVector(nil) + tmp31 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7099), kw_column, int(19), kw_end_DASH_line, int(7099), kw_end_DASH_column, int(24)) + tmp32, err := lang.WithMeta(tmp30, tmp31.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp33 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) + tmp34, ok := lang.FieldOrMethod(v4, "getCount") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "getCount"))) + } + var tmp35 any + switch reflect.TypeOf(tmp34).Kind() { + case reflect.Func: + tmp35 = lang.Apply(tmp34, nil) + default: + tmp35 = tmp34 + } + tmp36 := lang.Apply(tmp33, []any{tmp35}) + tmp37 := lang.Apply(nil, []any{tmp32, tmp36}) + tmp38 := lang.NewVector(nil, nil) + tmp39 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7103), kw_column, int(7), kw_end_DASH_line, int(7103), kw_end_DASH_column, int(14)) + tmp40, err := lang.WithMeta(tmp38, tmp39.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var tmp41 any + var tmp42 any + { // let + // let binding "and__0__auto__" + tmp43 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp44, ok := lang.FieldOrMethod(v4, "getCount") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "getCount"))) + } + var tmp45 any + switch reflect.TypeOf(tmp44).Kind() { + case reflect.Func: + tmp45 = lang.Apply(tmp44, nil) + default: + tmp45 = tmp44 + } + tmp46 := lang.Apply(tmp43, []any{tmp45}) + var v47 any = tmp46 + _ = v47 + var tmp48 any + if lang.IsTruthy(v47) { + tmp49 := checkDerefVar(var_glojure_DOT_core_compare_DASH_and_DASH_set_BANG_) + tmp50 := lang.Apply(tmp49, []any{v7, v4, nil}) + tmp48 = tmp50 + } else { + tmp48 = v47 + } + tmp42 = tmp48 + } // end let + if lang.IsTruthy(tmp42) { + tmp43, ok := lang.FieldOrMethod(v4, "countDown") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "countDown"))) + } + var tmp44 any + switch reflect.TypeOf(tmp43).Kind() { + case reflect.Func: + tmp44 = lang.Apply(tmp43, nil) + default: + tmp44 = tmp43 + } + _ = tmp44 + } else { + } + tmp45 := lang.Apply(nil, []any{tmp40, tmp41}) + tmp46 := lang.Apply(nil, []any{tmp8, tmp17, tmp18, tmp28, tmp29, tmp37, nil, tmp45}) + tmp2 = tmp46 + } // end let + return tmp2 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_promise = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_promise.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // re-find + { + tmp0 := sym_re_DASH_find.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m), lang.NewVector(sym_re, sym_s)), kw_doc, "Returns the next regex match, if any, of string to pattern, using\n java.util.regex.Matcher.find(). Uses re-groups to return the\n groups.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4922), kw_end_DASH_line, int(4922))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 any + tmp4, _ := lang.FieldOrMethod(v2, "find") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("find is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{}) + if lang.IsTruthy(tmp5) { + tmp6 := checkDerefVar(var_glojure_DOT_core_re_DASH_groups) + tmp7 := lang.Apply(tmp6, []any{v2}) + tmp3 = tmp7 + } else { + } + return tmp3 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "m" + tmp5 := checkDerefVar(var_glojure_DOT_core_re_DASH_matcher) + tmp6 := lang.Apply(tmp5, []any{v2, v3}) + var v7 any = tmp6 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_re_DASH_find) + tmp9 := lang.Apply(tmp8, []any{v7}) + tmp4 = tmp9 + } // end let + return tmp4 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_re_DASH_find = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_re_DASH_find.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // ref + { + tmp0 := sym_ref.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x), lang.NewVector(sym_x, sym__AMP_, sym_options)), kw_doc, "Creates and returns a Ref with an initial value of x and zero or\n more options (in any order):\n\n :meta metadata-map\n\n :validator validate-fn\n\n :min-history (default 0)\n :max-history (default 10)\n\n If metadata-map is supplied, it will become the metadata on the\n ref. validate-fn must be nil or a side-effect-free fn of one\n argument, which will be passed the intended new state on any state\n change. If the new state is unacceptable, the validate-fn should\n return false or throw an exception. validate-fn will be called on\n transaction commit, when all refs have their final values.\n\n Normally refs accumulate history dynamically as needed to deal with\n read demands. If you know in advance you will need history you can\n set :min-history to ensure it will be available when first needed (instead\n of after a read fault). History is limited, and the limit can be set\n with :max-history.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(2260), kw_end_DASH_line, int(2260))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := lang.Apply(lang.NewRef, []any{v2}) + return tmp3 + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + var tmp4 any + { // let + // let binding "r" + tmp5 := checkDerefVar(var_glojure_DOT_core_setup_DASH_reference) + tmp6 := checkDerefVar(var_glojure_DOT_core_ref) + tmp7 := lang.Apply(tmp6, []any{v2}) + tmp8 := lang.Apply(tmp5, []any{tmp7, v3}) + var v9 any = tmp8 + _ = v9 + // let binding "opts" + tmp10 := checkDerefVar(var_glojure_DOT_core_apply) + tmp11 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp12 := lang.Apply(tmp10, []any{tmp11, v3}) + var v13 any = tmp12 + _ = v13 + var tmp14 any + tmp15 := lang.Apply(kw_max_DASH_history, []any{v13}) + if lang.IsTruthy(tmp15) { + tmp16 := lang.Apply(kw_max_DASH_history, []any{v13}) + tmp17, _ := lang.FieldOrMethod(v9, "setMaxHistory") + if reflect.TypeOf(tmp17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMaxHistory is not a function"))) + } + tmp18 := lang.Apply(tmp17, []any{tmp16}) + tmp14 = tmp18 + } else { + } + _ = tmp14 + var tmp19 any + tmp20 := lang.Apply(kw_min_DASH_history, []any{v13}) + if lang.IsTruthy(tmp20) { + tmp21 := lang.Apply(kw_min_DASH_history, []any{v13}) + tmp22, _ := lang.FieldOrMethod(v9, "setMinHistory") + if reflect.TypeOf(tmp22).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setMinHistory is not a function"))) + } + tmp23 := lang.Apply(tmp22, []any{tmp21}) + tmp19 = tmp23 + } else { + } + _ = tmp19 + tmp4 = v9 + } // end let + return tmp4 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_ref = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_ref.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // repeatedly + { + tmp0 := sym_repeatedly.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_n, sym_f)), kw_doc, "Takes a function of no args, presumably with side effects, and\n returns an infinite (or length n if supplied) lazy sequence of calls\n to it", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(5167), kw_end_DASH_line, int(5167))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp4 := checkDerefVar(var_glojure_DOT_core_cons) + tmp5 := lang.Apply(v2, nil) + tmp6 := checkDerefVar(var_glojure_DOT_core_repeatedly) + tmp7 := lang.Apply(tmp6, []any{v2}) + tmp8 := lang.Apply(tmp4, []any{tmp5, tmp7}) + return tmp8 + }) + tmp4 := lang.Apply(lang.NewLazySeq, []any{tmp3}) + return tmp4 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_take) + tmp5 := checkDerefVar(var_glojure_DOT_core_repeatedly) + tmp6 := lang.Apply(tmp5, []any{v3}) + tmp7 := lang.Apply(tmp4, []any{v2, tmp6}) + return tmp7 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_repeatedly = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_repeatedly.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // replicate + { + tmp0 := sym_replicate.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n, sym_x)), kw_doc, "DEPRECATED: Use 'repeat' instead.\n Returns a lazy seq of n xs.", kw_file, "glojure/core.glj", kw_deprecated, "1.3", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(3004), kw_end_DASH_line, int(3004))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_take) + tmp5 := checkDerefVar(var_glojure_DOT_core_repeat) + tmp6 := lang.Apply(tmp5, []any{v3}) + tmp7 := lang.Apply(tmp4, []any{v2, tmp6}) + return tmp7 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_replicate = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_replicate.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // resultset-seq + { + tmp0 := sym_resultset_DASH_seq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_rs)), kw_doc, "Creates and returns a lazy sequence of structmaps corresponding to\n the rows in the java.sql.ResultSet rs", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(5681), kw_end_DASH_line, int(5681))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "rsmeta" + tmp4, _ := lang.FieldOrMethod(v2, "getMetaData") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getMetaData is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{}) + var v6 any = tmp5 + _ = v6 + // let binding "idxs" + tmp7 := checkDerefVar(var_glojure_DOT_core_range) + tmp8 := checkDerefVar(var_glojure_DOT_core_inc) + tmp9, _ := lang.FieldOrMethod(v6, "getColumnCount") + if reflect.TypeOf(tmp9).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getColumnCount is not a function"))) + } + tmp10 := lang.Apply(tmp9, []any{}) + tmp11 := lang.Apply(tmp8, []any{tmp10}) + tmp12 := lang.Apply(tmp7, []any{int64(1), tmp11}) + var v13 any = tmp12 + _ = v13 + // let binding "keys" + tmp14 := checkDerefVar(var_glojure_DOT_core_map) + tmp15 := checkDerefVar(var_glojure_DOT_core_comp) + tmp16 := checkDerefVar(var_glojure_DOT_core_keyword) + var tmp17 lang.FnFunc + tmp17 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v18 := args[0] + _ = v18 + tmp19, ok := lang.FieldOrMethod(v18, "toLowerCase") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v18, "toLowerCase"))) + } + var tmp20 any + switch reflect.TypeOf(tmp19).Kind() { + case reflect.Func: + tmp20 = lang.Apply(tmp19, nil) + default: + tmp20 = tmp19 + } + return tmp20 + }) + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5688), kw_column, int(35), kw_end_DASH_line, int(5688), kw_end_DASH_column, int(62)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp20 := lang.Apply(tmp15, []any{tmp16, tmp19}) + tmp21 := checkDerefVar(var_glojure_DOT_core_map) + var tmp22 lang.FnFunc + tmp22 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v23 := args[0] + _ = v23 + tmp24, _ := lang.FieldOrMethod(v6, "getColumnLabel") + if reflect.TypeOf(tmp24).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getColumnLabel is not a function"))) + } + tmp25 := lang.Apply(tmp24, []any{v23}) + return tmp25 + }) + tmp23 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5689), kw_column, int(26), kw_end_DASH_line, int(5689), kw_end_DASH_column, int(63)) + tmp24, err := lang.WithMeta(tmp22, tmp23.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp25 := lang.Apply(tmp21, []any{tmp24, v13}) + tmp26 := lang.Apply(tmp14, []any{tmp20, tmp25}) + var v27 any = tmp26 + _ = v27 + // let binding "check-keys" + var tmp28 any + { // let + // let binding "or__0__auto__" + tmp29 := checkDerefVar(var_glojure_DOT_core_apply) + tmp30 := checkDerefVar(var_glojure_DOT_core_distinct_QMARK_) + tmp31 := lang.Apply(tmp29, []any{tmp30, v27}) + var v32 any = tmp31 + _ = v32 + var tmp33 any + if lang.IsTruthy(v32) { + tmp33 = v32 + } else { + tmp34 := lang.Apply(lang.NewError, []any{"ResultSet must have unique column labels"}) + panic(tmp34) + } + tmp28 = tmp33 + } // end let + var v29 any = tmp28 + _ = v29 + // let binding "row-struct" + tmp30 := checkDerefVar(var_glojure_DOT_core_apply) + tmp31 := checkDerefVar(var_glojure_DOT_core_create_DASH_struct) + tmp32 := lang.Apply(tmp30, []any{tmp31, v27}) + var v33 any = tmp32 + _ = v33 + // let binding "row-values" + var tmp34 lang.FnFunc + tmp34 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp35 := checkDerefVar(var_glojure_DOT_core_map) + var tmp36 lang.FnFunc + tmp36 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v37 := args[0] + _ = v37 + tmp38, _ := lang.FieldOrMethod(v2, "getObject") + if reflect.TypeOf(tmp38).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("getObject is not a function"))) + } + tmp39 := lang.Apply(tmp38, []any{v37}) + return tmp39 + }) + tmp37 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5694), kw_column, int(34), kw_end_DASH_line, int(5694), kw_end_DASH_column, int(71)) + tmp38, err := lang.WithMeta(tmp36, tmp37.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp39 := lang.Apply(tmp35, []any{tmp38, v13}) + return tmp39 + }) + tmp35 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5694), kw_column, int(22), kw_end_DASH_line, int(5694), kw_end_DASH_column, int(78)) + tmp36, err := lang.WithMeta(tmp34, tmp35.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v37 any = tmp36 + _ = v37 + // let binding "rows" + var tmp38 lang.FnFunc + { // function thisfn + var v39 lang.FnFunc + tmp38 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp40 any + tmp41, _ := lang.FieldOrMethod(v2, "next") + if reflect.TypeOf(tmp41).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("next is not a function"))) + } + tmp42 := lang.Apply(tmp41, []any{}) + if lang.IsTruthy(tmp42) { + tmp43 := checkDerefVar(var_glojure_DOT_core_cons) + tmp44 := checkDerefVar(var_glojure_DOT_core_apply) + tmp45 := checkDerefVar(var_glojure_DOT_core_struct) + tmp46 := lang.Apply(v37, nil) + tmp47 := lang.Apply(tmp44, []any{tmp45, v33, tmp46}) + var tmp48 lang.FnFunc + tmp48 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp49 := lang.Apply(v39, nil) + return tmp49 + }) + tmp49 := lang.Apply(lang.NewLazySeq, []any{tmp48}) + tmp50 := lang.Apply(tmp43, []any{tmp47, tmp49}) + tmp40 = tmp50 + } else { + } + return tmp40 + }) + v39 = tmp38 + _ = v39 + } + tmp39 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5695), kw_column, int(16), kw_end_DASH_line, int(5697), kw_end_DASH_column, int(86)) + tmp40, err := lang.WithMeta(tmp38, tmp39.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v41 any = tmp40 + _ = v41 + tmp42 := lang.Apply(v41, nil) + tmp3 = tmp42 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_resultset_DASH_seq = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_resultset_DASH_seq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // send + { + tmp0 := sym_send.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a, sym_f, sym__AMP_, sym_args)), kw_doc, "Dispatch an action to an agent. Returns the agent immediately.\n Subsequently, in a thread from a thread pool, the state of the agent\n will be set to the value of:\n\n (apply action-fn state-of-agent args)", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(2109), kw_end_DASH_line, int(2109))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_apply) + tmp6 := checkDerefVar(var_glojure_DOT_core_send_DASH_via) + tmp7 := lang.Apply(tmp5, []any{tmp6, nil, v2, v3, v4}) + return tmp7 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_send = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_send.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // send-off + { + tmp0 := sym_send_DASH_off.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_a, sym_f, sym__AMP_, sym_args)), kw_doc, "Dispatch a potentially blocking action to an agent. Returns the\n agent immediately. Subsequently, in a separate thread, the state of\n the agent will be set to the value of:\n\n (apply action-fn state-of-agent args)", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(2120), kw_end_DASH_line, int(2120))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_apply) + tmp6 := checkDerefVar(var_glojure_DOT_core_send_DASH_via) + tmp7 := lang.Apply(tmp5, []any{tmp6, nil, v2, v3, v4}) + return tmp7 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_send_DASH_off = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_send_DASH_off.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // seque + { + tmp0 := sym_seque.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s), lang.NewVector(sym_n_DASH_or_DASH_q, sym_s)), kw_doc, "Creates a queued seq on another (presumably lazy) seq s. The queued\n seq will produce a concrete seq in the background, and can get up to\n n items ahead of the consumer. n-or-q can be an integer n buffer\n size, or an instance of java.util.concurrent BlockingQueue. Note\n that reading from a seque can block if the reader gets ahead of the\n producer.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(5419), kw_end_DASH_line, int(5419))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_seque) + tmp4 := lang.Apply(tmp3, []any{int64(100), v2}) + return tmp4 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "q" + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp7 := lang.Apply(tmp6, []any{nil, v2}) + if lang.IsTruthy(tmp7) { + tmp5 = v2 + } else { + tmp8 := checkDerefVar(var_glojure_DOT_core_int) + tmp9 := lang.Apply(tmp8, []any{v2}) + tmp10 := lang.Apply(nil, []any{tmp9}) + tmp5 = tmp10 + } + var v11 any = tmp5 + _ = v11 + // let binding "NIL" + tmp12 := lang.Apply(reflect.StructOf, []any{nil}) + tmp13 := lang.Apply(reflect.New, []any{tmp12}) + tmp14, ok := lang.FieldOrMethod(tmp13, "Interface") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp13, "Interface"))) + } + var tmp15 any + switch reflect.TypeOf(tmp14).Kind() { + case reflect.Func: + tmp15 = lang.Apply(tmp14, nil) + default: + tmp15 = tmp14 + } + var v16 any = tmp15 + _ = v16 + // let binding "agt" + tmp17 := checkDerefVar(var_glojure_DOT_core_agent) + var tmp18 lang.FnFunc + tmp18 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + return v3 + }) + tmp19 := lang.Apply(lang.NewLazySeq, []any{tmp18}) + tmp20 := lang.Apply(tmp17, []any{tmp19}) + var v21 any = tmp20 + _ = v21 + // let binding "log-error" + var tmp22 lang.FnFunc + tmp22 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v23 := args[0] + _ = v23 + v24 := args[1] + _ = v24 + var tmp25 any + tmp26, _ := lang.FieldOrMethod(v23, "offer") + if reflect.TypeOf(tmp26).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("offer is not a function"))) + } + tmp27 := lang.Apply(tmp26, []any{v23}) + if lang.IsTruthy(tmp27) { + panic(v24) + } else { + tmp25 = v24 + } + return tmp25 + }) + tmp23 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5435), kw_column, int(20), kw_end_DASH_line, int(5438), kw_end_DASH_column, int(26)) + tmp24, err := lang.WithMeta(tmp22, tmp23.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v25 any = tmp24 + _ = v25 + // let binding "fill" + var tmp26 lang.FnFunc + tmp26 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v27 := args[0] + _ = v27 + var tmp28 any + if lang.IsTruthy(v27) { + var tmp29 any + tmp30 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp31 := lang.Apply(tmp30, []any{nil, v27}) + if lang.IsTruthy(tmp31) { + tmp32 := lang.Apply(v25, []any{v11, v27}) + tmp29 = tmp32 + } else { + var tmp33 any + func() { + defer func() { + if r := recover(); r != nil { + if lang.CatchMatches(r, lang.Builtins["any"]) { + v34 := r + _ = v34 + tmp35 := lang.Apply(v25, []any{v11, v34}) + tmp33 = tmp35 + } else { + panic(r) + } + } + }() + var tmp34 any + { // let + // let binding "G__780" + tmp35 := checkDerefVar(var_glojure_DOT_core_seq) + tmp36 := lang.Apply(tmp35, []any{v27}) + var v37 any = tmp36 + _ = v37 + // let binding "vec__781" + var v38 any = v37 + _ = v38 + // let binding "seq__782" + tmp39 := checkDerefVar(var_glojure_DOT_core_seq) + tmp40 := lang.Apply(tmp39, []any{v38}) + var v41 any = tmp40 + _ = v41 + // let binding "first__783" + tmp42 := checkDerefVar(var_glojure_DOT_core_first) + tmp43 := lang.Apply(tmp42, []any{v41}) + var v44 any = tmp43 + _ = v44 + // let binding "seq__782" + tmp45 := checkDerefVar(var_glojure_DOT_core_next) + tmp46 := lang.Apply(tmp45, []any{v41}) + var v47 any = tmp46 + _ = v47 + // let binding "x" + var v48 any = v44 + _ = v48 + // let binding "xs" + var v49 any = v47 + _ = v49 + // let binding "s" + var v50 any = v38 + _ = v50 + var tmp51 any + { // let + // let binding "G__780" + var v52 any = v37 + _ = v52 + for { + var tmp53 any + { // let + // let binding "vec__784" + var v54 any = v52 + _ = v54 + // let binding "seq__785" + tmp55 := checkDerefVar(var_glojure_DOT_core_seq) + tmp56 := lang.Apply(tmp55, []any{v54}) + var v57 any = tmp56 + _ = v57 + // let binding "first__786" + tmp58 := checkDerefVar(var_glojure_DOT_core_first) + tmp59 := lang.Apply(tmp58, []any{v57}) + var v60 any = tmp59 + _ = v60 + // let binding "seq__785" + tmp61 := checkDerefVar(var_glojure_DOT_core_next) + tmp62 := lang.Apply(tmp61, []any{v57}) + var v63 any = tmp62 + _ = v63 + // let binding "x" + var v64 any = v60 + _ = v64 + // let binding "xs" + var v65 any = v63 + _ = v65 + // let binding "s" + var v66 any = v54 + _ = v66 + var tmp67 any + if lang.IsTruthy(v66) { + var tmp68 any + var tmp69 any + tmp70 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp71 := lang.Apply(tmp70, []any{v64}) + if lang.IsTruthy(tmp71) { + tmp69 = v16 + } else { + tmp69 = v64 + } + tmp72, _ := lang.FieldOrMethod(v11, "offer") + if reflect.TypeOf(tmp72).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("offer is not a function"))) + } + tmp73 := lang.Apply(tmp72, []any{tmp69}) + if lang.IsTruthy(tmp73) { + var tmp74 any = v65 + v52 = tmp74 + continue + } else { + tmp68 = v66 + } + tmp67 = tmp68 + } else { + var tmp75 any + tmp76, _ := lang.FieldOrMethod(v11, "offer") + if reflect.TypeOf(tmp76).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("offer is not a function"))) + } + tmp77 := lang.Apply(tmp76, []any{v11}) + if lang.IsTruthy(tmp77) { + } else { + tmp75 = lang.NewList() + } + tmp67 = tmp75 + } + tmp53 = tmp67 + } // end let + tmp51 = tmp53 + break + } + } // end let + tmp34 = tmp51 + } // end let + tmp33 = tmp34 + }() + tmp29 = tmp33 + } + tmp28 = tmp29 + } else { + } + return tmp28 + }) + tmp27 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5439), kw_column, int(15), kw_end_DASH_line, int(5452), kw_end_DASH_column, int(44)) + tmp28, err := lang.WithMeta(tmp26, tmp27.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v29 any = tmp28 + _ = v29 + // let binding "drain" + var tmp30 lang.FnFunc + { // function drain + var v31 lang.FnFunc + tmp30 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp32 lang.FnFunc + tmp32 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp33 any + { // let + // let binding "x" + tmp34, ok := lang.FieldOrMethod(v11, "take") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v11, "take"))) + } + var tmp35 any + switch reflect.TypeOf(tmp34).Kind() { + case reflect.Func: + tmp35 = lang.Apply(tmp34, nil) + default: + tmp35 = tmp34 + } + var v36 any = tmp35 + _ = v36 + var tmp37 any + tmp38 := checkDerefVar(var_glojure_DOT_core_identical_QMARK_) + tmp39 := lang.Apply(tmp38, []any{v36, v11}) + if lang.IsTruthy(tmp39) { + tmp40 := checkDerefVar(var_glojure_DOT_core_deref) + tmp41 := lang.Apply(tmp40, []any{v21}) + _ = tmp41 + } else { + tmp42 := checkDerefVar(var_glojure_DOT_core_send_DASH_off) + tmp43 := lang.Apply(tmp42, []any{v21, v29}) + _ = tmp43 + tmp44 := checkDerefVar(var_glojure_DOT_core_release_DASH_pending_DASH_sends) + tmp45 := lang.Apply(tmp44, nil) + _ = tmp45 + tmp46 := checkDerefVar(var_glojure_DOT_core_cons) + var tmp47 any + tmp48 := checkDerefVar(var_glojure_DOT_core_identical_QMARK_) + tmp49 := lang.Apply(tmp48, []any{v36, v16}) + if lang.IsTruthy(tmp49) { + } else { + tmp47 = v36 + } + tmp50 := lang.Apply(v31, nil) + tmp51 := lang.Apply(tmp46, []any{tmp47, tmp50}) + tmp37 = tmp51 + } + tmp33 = tmp37 + } // end let + return tmp33 + }) + tmp33 := lang.Apply(lang.NewLazySeq, []any{tmp32}) + return tmp33 + }) + v31 = tmp30 + _ = v31 + } + tmp31 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5453), kw_column, int(16), kw_end_DASH_line, int(5461), kw_end_DASH_column, int(73)) + tmp32, err := lang.WithMeta(tmp30, tmp31.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v33 any = tmp32 + _ = v33 + tmp34 := checkDerefVar(var_glojure_DOT_core_send_DASH_off) + tmp35 := lang.Apply(tmp34, []any{v21, v29}) + _ = tmp35 + tmp36 := lang.Apply(v33, nil) + tmp4 = tmp36 + } // end let + return tmp4 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_seque = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_seque.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // some-> + { + tmp0 := sym_some_DASH__GT_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_expr, sym__AMP_, sym_forms)), kw_doc, "When expr is not nil, threads it into the first form (via ->),\n and when that result is not nil, through the next etc", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(11), kw_line, int(7610), kw_end_DASH_line, int(7610))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "g" + tmp7 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp8 := lang.Apply(tmp7, nil) + var v9 any = tmp8 + _ = v9 + // let binding "steps" + tmp10 := checkDerefVar(var_glojure_DOT_core_map) + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v12 := args[0] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_if}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{sym_glojure_DOT_core_SLASH_nil_QMARK_}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v9}) + tmp24 := lang.Apply(tmp19, []any{tmp21, tmp23}) + tmp25 := lang.Apply(tmp18, []any{tmp24}) + tmp26 := lang.Apply(tmp17, []any{tmp25}) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{nil}) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := checkDerefVar(var_glojure_DOT_core_seq) + tmp31 := checkDerefVar(var_glojure_DOT_core_concat) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := lang.Apply(tmp32, []any{sym_glojure_DOT_core_SLASH__DASH__GT_}) + tmp34 := checkDerefVar(var_glojure_DOT_core_list) + tmp35 := lang.Apply(tmp34, []any{v9}) + tmp36 := checkDerefVar(var_glojure_DOT_core_list) + tmp37 := lang.Apply(tmp36, []any{v12}) + tmp38 := lang.Apply(tmp31, []any{tmp33, tmp35, tmp37}) + tmp39 := lang.Apply(tmp30, []any{tmp38}) + tmp40 := lang.Apply(tmp29, []any{tmp39}) + tmp41 := lang.Apply(tmp14, []any{tmp16, tmp26, tmp28, tmp40}) + tmp42 := lang.Apply(tmp13, []any{tmp41}) + return tmp42 + }) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7616), kw_column, int(20), kw_end_DASH_line, int(7616), kw_end_DASH_column, int(64)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp14 := lang.Apply(tmp10, []any{tmp13, v5}) + var v15 any = tmp14 + _ = v15 + tmp16 := checkDerefVar(var_glojure_DOT_core_seq) + tmp17 := checkDerefVar(var_glojure_DOT_core_concat) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{sym_glojure_DOT_core_SLASH_let}) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := checkDerefVar(var_glojure_DOT_core_apply) + tmp22 := checkDerefVar(var_glojure_DOT_core_vector) + tmp23 := checkDerefVar(var_glojure_DOT_core_seq) + tmp24 := checkDerefVar(var_glojure_DOT_core_concat) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := lang.Apply(tmp25, []any{v9}) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{v4}) + tmp29 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp30 := checkDerefVar(var_glojure_DOT_core_repeat) + tmp31 := lang.Apply(tmp30, []any{v9}) + tmp32 := checkDerefVar(var_glojure_DOT_core_butlast) + tmp33 := lang.Apply(tmp32, []any{v15}) + tmp34 := lang.Apply(tmp29, []any{tmp31, tmp33}) + tmp35 := lang.Apply(tmp24, []any{tmp26, tmp28, tmp34}) + tmp36 := lang.Apply(tmp23, []any{tmp35}) + tmp37 := lang.Apply(tmp21, []any{tmp22, tmp36}) + tmp38 := lang.Apply(tmp20, []any{tmp37}) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + var tmp40 any + tmp41 := checkDerefVar(var_glojure_DOT_core_empty_QMARK_) + tmp42 := lang.Apply(tmp41, []any{v15}) + if lang.IsTruthy(tmp42) { + tmp40 = v9 + } else { + tmp43 := checkDerefVar(var_glojure_DOT_core_last) + tmp44 := lang.Apply(tmp43, []any{v15}) + tmp40 = tmp44 + } + tmp45 := lang.Apply(tmp39, []any{tmp40}) + tmp46 := lang.Apply(tmp17, []any{tmp19, tmp38, tmp45}) + tmp47 := lang.Apply(tmp16, []any{tmp46}) + tmp6 = tmp47 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_some_DASH__GT_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_some_DASH__GT_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // some->> + { + tmp0 := sym_some_DASH__GT__GT_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_expr, sym__AMP_, sym_forms)), kw_doc, "When expr is not nil, threads it into the first form (via ->>),\n and when that result is not nil, through the next etc", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(7624), kw_end_DASH_line, int(7624))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "g" + tmp7 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp8 := lang.Apply(tmp7, nil) + var v9 any = tmp8 + _ = v9 + // let binding "steps" + tmp10 := checkDerefVar(var_glojure_DOT_core_map) + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v12 := args[0] + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_seq) + tmp14 := checkDerefVar(var_glojure_DOT_core_concat) + tmp15 := checkDerefVar(var_glojure_DOT_core_list) + tmp16 := lang.Apply(tmp15, []any{sym_if}) + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{sym_glojure_DOT_core_SLASH_nil_QMARK_}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{v9}) + tmp24 := lang.Apply(tmp19, []any{tmp21, tmp23}) + tmp25 := lang.Apply(tmp18, []any{tmp24}) + tmp26 := lang.Apply(tmp17, []any{tmp25}) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{nil}) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := checkDerefVar(var_glojure_DOT_core_seq) + tmp31 := checkDerefVar(var_glojure_DOT_core_concat) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := lang.Apply(tmp32, []any{sym_glojure_DOT_core_SLASH__DASH__GT__GT_}) + tmp34 := checkDerefVar(var_glojure_DOT_core_list) + tmp35 := lang.Apply(tmp34, []any{v9}) + tmp36 := checkDerefVar(var_glojure_DOT_core_list) + tmp37 := lang.Apply(tmp36, []any{v12}) + tmp38 := lang.Apply(tmp31, []any{tmp33, tmp35, tmp37}) + tmp39 := lang.Apply(tmp30, []any{tmp38}) + tmp40 := lang.Apply(tmp29, []any{tmp39}) + tmp41 := lang.Apply(tmp14, []any{tmp16, tmp26, tmp28, tmp40}) + tmp42 := lang.Apply(tmp13, []any{tmp41}) + return tmp42 + }) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7630), kw_column, int(20), kw_end_DASH_line, int(7630), kw_end_DASH_column, int(65)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp14 := lang.Apply(tmp10, []any{tmp13, v5}) + var v15 any = tmp14 + _ = v15 + tmp16 := checkDerefVar(var_glojure_DOT_core_seq) + tmp17 := checkDerefVar(var_glojure_DOT_core_concat) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{sym_glojure_DOT_core_SLASH_let}) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := checkDerefVar(var_glojure_DOT_core_apply) + tmp22 := checkDerefVar(var_glojure_DOT_core_vector) + tmp23 := checkDerefVar(var_glojure_DOT_core_seq) + tmp24 := checkDerefVar(var_glojure_DOT_core_concat) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := lang.Apply(tmp25, []any{v9}) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{v4}) + tmp29 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp30 := checkDerefVar(var_glojure_DOT_core_repeat) + tmp31 := lang.Apply(tmp30, []any{v9}) + tmp32 := checkDerefVar(var_glojure_DOT_core_butlast) + tmp33 := lang.Apply(tmp32, []any{v15}) + tmp34 := lang.Apply(tmp29, []any{tmp31, tmp33}) + tmp35 := lang.Apply(tmp24, []any{tmp26, tmp28, tmp34}) + tmp36 := lang.Apply(tmp23, []any{tmp35}) + tmp37 := lang.Apply(tmp21, []any{tmp22, tmp36}) + tmp38 := lang.Apply(tmp20, []any{tmp37}) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + var tmp40 any + tmp41 := checkDerefVar(var_glojure_DOT_core_empty_QMARK_) + tmp42 := lang.Apply(tmp41, []any{v15}) + if lang.IsTruthy(tmp42) { + tmp40 = v9 + } else { + tmp43 := checkDerefVar(var_glojure_DOT_core_last) + tmp44 := lang.Apply(tmp43, []any{v15}) + tmp40 = tmp44 + } + tmp45 := lang.Apply(tmp39, []any{tmp40}) + tmp46 := lang.Apply(tmp17, []any{tmp19, tmp38, tmp45}) + tmp47 := lang.Apply(tmp16, []any{tmp46}) + tmp6 = tmp47 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_some_DASH__GT__GT_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_some_DASH__GT__GT_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // split-at + { + tmp0 := sym_split_DASH_at.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n, sym_coll)), kw_doc, "Returns a vector of [(take n coll) (drop n coll)]", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(2983), kw_end_DASH_line, int(2983))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_take) + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + tmp6 := checkDerefVar(var_glojure_DOT_core_drop) + tmp7 := lang.Apply(tmp6, []any{v2, v3}) + tmp8 := lang.NewVector(tmp5, tmp7) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2988), kw_column, int(5), kw_end_DASH_line, int(2988), kw_end_DASH_column, int(33)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp10 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_split_DASH_at = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_split_DASH_at.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // to-array-2d + { + tmp0 := sym_to_DASH_array_DASH_2d.WithMeta(lang.NewMap(kw_tag, "[[Ljava.lang.Object;", kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a (potentially-ragged) 2-dimensional array of Objects\n containing the contents of coll, which can be any Collection of any\n Collection.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(4002), kw_end_DASH_line, int(4002))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "ret" + tmp4 := checkDerefVar(var_glojure_DOT_core_make_DASH_array) + tmp5 := reflect.TypeOf((*reflect.Type)(nil)).Elem() + tmp6, _ := lang.FieldOrMethod(tmp5, "forName") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("forName is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{"[Ljava.lang.Object;"}) + tmp8, _ := lang.FieldOrMethod(v2, "size") + if reflect.TypeOf(tmp8).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("size is not a function"))) + } + tmp9 := lang.Apply(tmp8, []any{}) + tmp10 := lang.Apply(tmp4, []any{tmp7, tmp9}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + { // let + // let binding "i" + var v13 any = int64(0) + _ = v13 + // let binding "xs" + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := lang.Apply(tmp14, []any{v2}) + var v16 any = tmp15 + _ = v16 + for { + var tmp17 any + if lang.IsTruthy(v16) { + tmp18 := checkDerefVar(var_glojure_DOT_core_aset) + tmp19 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) + tmp20 := checkDerefVar(var_glojure_DOT_core_first) + tmp21 := lang.Apply(tmp20, []any{v16}) + tmp22 := lang.Apply(tmp19, []any{tmp21}) + tmp23 := lang.Apply(tmp18, []any{v11, v13, tmp22}) + _ = tmp23 + tmp25 := checkDerefVar(var_glojure_DOT_core_inc) + tmp26 := lang.Apply(tmp25, []any{v13}) + var tmp24 any = tmp26 + tmp28 := checkDerefVar(var_glojure_DOT_core_next) + tmp29 := lang.Apply(tmp28, []any{v16}) + var tmp27 any = tmp29 + v13 = tmp24 + v16 = tmp27 + continue + } else { + } + tmp12 = tmp17 + break + } + } // end let + _ = tmp12 + tmp3 = v11 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, "[[Ljava.lang.Object;")).(lang.FnFunc) + var_glojure_DOT_core_to_DASH_array_DASH_2d = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_to_DASH_array_DASH_2d.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // with-local-vars + { + tmp0 := sym_with_DASH_local_DASH_vars.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_name_DASH_vals_DASH_vec, sym__AMP_, sym_body)), kw_doc, "varbinding=> symbol init-expr\n\n Executes the exprs in a context in which the symbols are bound to\n vars with per-thread bindings to the init-exprs. The symbols refer\n to the var objects themselves, and must be accessed with var-get and\n var-set", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(25), kw_column, int(11), kw_line, int(4339), kw_end_DASH_line, int(4339))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v4}) + if lang.IsTruthy(tmp8) { + } else { + tmp9 := checkDerefVar(var_glojure_DOT_core_str) + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp13 := checkDerefVar(var_glojure_DOT_core_meta) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(kw_line, []any{tmp14}) + tmp16 := lang.Apply(tmp9, []any{tmp11, " requires ", "a vector for its binding", " in ", tmp12, ":", tmp15}) + tmp17 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp16}) + panic(tmp17) + } + _ = tmp6 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_even_QMARK_) + tmp20 := checkDerefVar(var_glojure_DOT_core_count) + tmp21 := lang.Apply(tmp20, []any{v4}) + tmp22 := lang.Apply(tmp19, []any{tmp21}) + if lang.IsTruthy(tmp22) { + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp27 := checkDerefVar(var_glojure_DOT_core_meta) + tmp28 := lang.Apply(tmp27, []any{v2}) + tmp29 := lang.Apply(kw_line, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp25, " requires ", "an even number of forms in binding vector", " in ", tmp26, ":", tmp29}) + tmp31 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp31) + } + _ = tmp18 + tmp32 := checkDerefVar(var_glojure_DOT_core_seq) + tmp33 := checkDerefVar(var_glojure_DOT_core_concat) + tmp34 := checkDerefVar(var_glojure_DOT_core_list) + tmp35 := lang.Apply(tmp34, []any{sym_glojure_DOT_core_SLASH_let}) + tmp36 := checkDerefVar(var_glojure_DOT_core_list) + tmp37 := checkDerefVar(var_glojure_DOT_core_apply) + tmp38 := checkDerefVar(var_glojure_DOT_core_vector) + tmp39 := checkDerefVar(var_glojure_DOT_core_seq) + tmp40 := checkDerefVar(var_glojure_DOT_core_concat) + tmp41 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp42 := checkDerefVar(var_glojure_DOT_core_take_DASH_nth) + tmp43 := lang.Apply(tmp42, []any{int64(2), v4}) + tmp44 := checkDerefVar(var_glojure_DOT_core_repeat) + tmp45 := lang.Apply(tmp44, []any{lang.NewList(sym__DOT__DOT_, sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT__STAR_Var, sym_create, sym_setDynamic)}) + tmp46 := lang.Apply(tmp41, []any{tmp43, tmp45}) + tmp47 := lang.Apply(tmp40, []any{tmp46}) + tmp48 := lang.Apply(tmp39, []any{tmp47}) + tmp49 := lang.Apply(tmp37, []any{tmp38, tmp48}) + tmp50 := lang.Apply(tmp36, []any{tmp49}) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := checkDerefVar(var_glojure_DOT_core_seq) + tmp53 := checkDerefVar(var_glojure_DOT_core_concat) + tmp54 := checkDerefVar(var_glojure_DOT_core_list) + tmp55 := lang.Apply(tmp54, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_PushThreadBindings}) + tmp56 := checkDerefVar(var_glojure_DOT_core_list) + tmp57 := checkDerefVar(var_glojure_DOT_core_apply) + tmp58 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp59 := checkDerefVar(var_glojure_DOT_core_seq) + tmp60 := checkDerefVar(var_glojure_DOT_core_concat) + tmp61 := lang.Apply(tmp60, nil) + tmp62 := lang.Apply(tmp59, []any{tmp61}) + tmp63 := lang.Apply(tmp57, []any{tmp58, tmp62}) + tmp64 := lang.Apply(tmp56, []any{tmp63}) + tmp65 := lang.Apply(tmp53, []any{tmp55, tmp64}) + tmp66 := lang.Apply(tmp52, []any{tmp65}) + tmp67 := lang.Apply(tmp51, []any{tmp66}) + tmp68 := checkDerefVar(var_glojure_DOT_core_list) + tmp69 := checkDerefVar(var_glojure_DOT_core_seq) + tmp70 := checkDerefVar(var_glojure_DOT_core_concat) + tmp71 := checkDerefVar(var_glojure_DOT_core_list) + tmp72 := lang.Apply(tmp71, []any{sym_try}) + tmp73 := checkDerefVar(var_glojure_DOT_core_list) + tmp74 := checkDerefVar(var_glojure_DOT_core_seq) + tmp75 := checkDerefVar(var_glojure_DOT_core_concat) + tmp76 := checkDerefVar(var_glojure_DOT_core_list) + tmp77 := lang.Apply(tmp76, []any{sym_finally}) + tmp78 := checkDerefVar(var_glojure_DOT_core_list) + tmp79 := checkDerefVar(var_glojure_DOT_core_seq) + tmp80 := checkDerefVar(var_glojure_DOT_core_concat) + tmp81 := checkDerefVar(var_glojure_DOT_core_list) + tmp82 := lang.Apply(tmp81, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_PopThreadBindings}) + tmp83 := lang.Apply(tmp80, []any{tmp82}) + tmp84 := lang.Apply(tmp79, []any{tmp83}) + tmp85 := lang.Apply(tmp78, []any{tmp84}) + tmp86 := lang.Apply(tmp75, []any{tmp77, tmp85}) + tmp87 := lang.Apply(tmp74, []any{tmp86}) + tmp88 := lang.Apply(tmp73, []any{tmp87}) + tmp89 := lang.Apply(tmp70, []any{tmp72, v5, tmp88}) + tmp90 := lang.Apply(tmp69, []any{tmp89}) + tmp91 := lang.Apply(tmp68, []any{tmp90}) + tmp92 := lang.Apply(tmp33, []any{tmp35, tmp50, tmp67, tmp91}) + tmp93 := lang.Apply(tmp32, []any{tmp92}) + return tmp93 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_with_DASH_local_DASH_vars = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_with_DASH_local_DASH_vars.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // Throwable->map + { + tmp0 := sym_Throwable_DASH__GT_map.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_o)), kw_doc, "Constructs a data representation for a Throwable with keys:\n :cause - root cause message\n :phase - error phase\n :via - cause chain, with cause keys:\n :type - exception class symbol\n :message - exception message\n :data - ex-data\n :at - top stack element\n :trace - root cause stack elements", kw_file, "glojure/core_print.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(442), kw_end_DASH_line, int(442))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "base" + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v5 := args[0] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_merge) + tmp7 := checkDerefVar(var_glojure_DOT_core_symbol) + tmp8 := checkDerefVar(var_glojure_DOT_core_class) + tmp9 := lang.Apply(tmp8, []any{v5}) + tmp10, ok := lang.FieldOrMethod(tmp9, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp9, "Name"))) + } + var tmp11 any + switch reflect.TypeOf(tmp10).Kind() { + case reflect.Func: + tmp11 = lang.Apply(tmp10, nil) + default: + tmp11 = tmp10 + } + tmp12 := lang.Apply(tmp7, []any{tmp11}) + tmp13 := lang.NewMap(kw_type, tmp12) + tmp14 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(455), kw_column, int(23), kw_end_DASH_line, int(455), kw_end_DASH_column, int(56)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var tmp16 any + { // let + // let binding "temp__0__auto__" + tmp17, ok := lang.FieldOrMethod(v5, "getLocalizedMessage") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "getLocalizedMessage"))) + } + var tmp18 any + switch reflect.TypeOf(tmp17).Kind() { + case reflect.Func: + tmp18 = lang.Apply(tmp17, nil) + default: + tmp18 = tmp17 + } + var v19 any = tmp18 + _ = v19 + var tmp20 any + if lang.IsTruthy(v19) { + var tmp21 any + { // let + // let binding "msg" + var v22 any = v19 + _ = v22 + tmp23 := lang.NewMap(kw_message, v22) + tmp24 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(457), kw_column, int(20), kw_end_DASH_line, int(457), kw_end_DASH_column, int(33)) + tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp21 = tmp25 + } // end let + tmp20 = tmp21 + } else { + } + tmp16 = tmp20 + } // end let + var tmp17 any + { // let + // let binding "temp__0__auto__" + tmp18 := checkDerefVar(var_glojure_DOT_core_ex_DASH_data) + tmp19 := lang.Apply(tmp18, []any{v5}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + var tmp22 any + { // let + // let binding "ed" + var v23 any = v20 + _ = v23 + tmp24 := lang.NewMap(kw_data, v23) + tmp25 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(459), kw_column, int(20), kw_end_DASH_line, int(459), kw_end_DASH_column, int(29)) + tmp26, err := lang.WithMeta(tmp24, tmp25.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp22 = tmp26 + } // end let + tmp21 = tmp22 + } else { + } + tmp17 = tmp21 + } // end let + var tmp18 any + { // let + // let binding "st" + tmp19, ok := lang.FieldOrMethod(v5, "getStackTrace") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v5, "getStackTrace"))) + } + var tmp20 any + switch reflect.TypeOf(tmp19).Kind() { + case reflect.Func: + tmp20 = lang.Apply(tmp19, nil) + default: + tmp20 = tmp19 + } + var v21 any = tmp20 + _ = v21 + var tmp22 any + tmp23 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp24 := checkDerefVar(var_glojure_DOT_core_alength) + tmp25 := lang.Apply(tmp24, []any{v21}) + tmp26 := lang.Apply(tmp23, []any{tmp25}) + if lang.IsTruthy(tmp26) { + tmp27 := checkDerefVar(var_glojure_DOT_core_StackTraceElement_DASH__GT_vec) + tmp28 := checkDerefVar(var_glojure_DOT_core_aget) + tmp29 := lang.Apply(tmp28, []any{v21, int64(0)}) + tmp30 := lang.Apply(tmp27, []any{tmp29}) + tmp31 := lang.NewMap(kw_at, tmp30) + tmp32 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(462), kw_column, int(22), kw_end_DASH_line, int(462), kw_end_DASH_column, int(63)) + tmp33, err := lang.WithMeta(tmp31, tmp32.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp22 = tmp33 + } else { + } + tmp18 = tmp22 + } // end let + tmp19 := lang.Apply(tmp6, []any{tmp15, tmp16, tmp17, tmp18}) + return tmp19 + }) + tmp5 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(454), kw_column, int(14), kw_end_DASH_line, int(462), kw_end_DASH_column, int(67)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v7 any = tmp6 + _ = v7 + // let binding "via" + var tmp8 any + { // let + // let binding "via" + tmp9 := lang.NewVector() + tmp10 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(463), kw_column, int(24), kw_end_DASH_line, int(463), kw_end_DASH_column, int(25)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v12 any = tmp11 + _ = v12 + // let binding "t" + var v13 any = v2 + _ = v13 + for { + var tmp14 any + if lang.IsTruthy(v13) { + tmp16 := checkDerefVar(var_glojure_DOT_core_conj) + tmp17 := lang.Apply(tmp16, []any{v12, v13}) + var tmp15 any = tmp17 + tmp19, ok := lang.FieldOrMethod(v13, "getCause") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v13, "getCause"))) + } + var tmp20 any + switch reflect.TypeOf(tmp19).Kind() { + case reflect.Func: + tmp20 = lang.Apply(tmp19, nil) + default: + tmp20 = tmp19 + } + var tmp18 any = tmp20 + v12 = tmp15 + v13 = tmp18 + continue + } else { + tmp14 = v12 + } + tmp8 = tmp14 + break + } + } // end let + var v9 any = tmp8 + _ = v9 + // let binding "root" + tmp10 := checkDerefVar(var_glojure_DOT_core_peek) + tmp11 := lang.Apply(tmp10, []any{v9}) + var v12 any = tmp11 + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_merge) + tmp14 := checkDerefVar(var_glojure_DOT_core_vec) + tmp15 := checkDerefVar(var_glojure_DOT_core_map) + tmp16 := lang.Apply(tmp15, []any{v7, v9}) + tmp17 := lang.Apply(tmp14, []any{tmp16}) + tmp18 := checkDerefVar(var_glojure_DOT_core_vec) + tmp19 := checkDerefVar(var_glojure_DOT_core_map) + tmp20 := checkDerefVar(var_glojure_DOT_core_StackTraceElement_DASH__GT_vec) + var tmp21 any + { // let + // let binding "or__0__auto__" + var v22 any = v12 + _ = v22 + var tmp23 any + if lang.IsTruthy(v22) { + tmp23 = v22 + } else { + tmp23 = v2 + } + tmp21 = tmp23 + } // end let + tmp22, ok := lang.FieldOrMethod(tmp21, "getStackTrace") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp21, "getStackTrace"))) + } + var tmp23 any + switch reflect.TypeOf(tmp22).Kind() { + case reflect.Func: + tmp23 = lang.Apply(tmp22, nil) + default: + tmp23 = tmp22 + } + tmp24 := lang.Apply(tmp19, []any{tmp20, tmp23}) + tmp25 := lang.Apply(tmp18, []any{tmp24}) + tmp26 := lang.NewMap(kw_via, tmp17, kw_trace, tmp25) + tmp27 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(468), kw_column, int(12), kw_end_DASH_line, int(470), kw_end_DASH_column, int(111)) + tmp28, err := lang.WithMeta(tmp26, tmp27.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var tmp29 any + { // let + // let binding "temp__0__auto__" + tmp30, ok := lang.FieldOrMethod(v12, "getLocalizedMessage") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v12, "getLocalizedMessage"))) + } + var tmp31 any + switch reflect.TypeOf(tmp30).Kind() { + case reflect.Func: + tmp31 = lang.Apply(tmp30, nil) + default: + tmp31 = tmp30 + } + var v32 any = tmp31 + _ = v32 + var tmp33 any + if lang.IsTruthy(v32) { + var tmp34 any + { // let + // let binding "root-msg" + var v35 any = v32 + _ = v35 + tmp36 := lang.NewMap(kw_cause, v35) + tmp37 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(472), kw_column, int(9), kw_end_DASH_line, int(472), kw_end_DASH_column, int(25)) + tmp38, err := lang.WithMeta(tmp36, tmp37.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp34 = tmp38 + } // end let + tmp33 = tmp34 + } else { + } + tmp29 = tmp33 + } // end let + var tmp30 any + { // let + // let binding "temp__0__auto__" + tmp31 := checkDerefVar(var_glojure_DOT_core_ex_DASH_data) + tmp32 := lang.Apply(tmp31, []any{v12}) + var v33 any = tmp32 + _ = v33 + var tmp34 any + if lang.IsTruthy(v33) { + var tmp35 any + { // let + // let binding "data" + var v36 any = v33 + _ = v36 + tmp37 := lang.NewMap(kw_data, v36) + tmp38 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(474), kw_column, int(9), kw_end_DASH_line, int(474), kw_end_DASH_column, int(20)) + tmp39, err := lang.WithMeta(tmp37, tmp38.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp35 = tmp39 + } // end let + tmp34 = tmp35 + } else { + } + tmp30 = tmp34 + } // end let + var tmp31 any + { // let + // let binding "temp__0__auto__" + tmp32 := checkDerefVar(var_glojure_DOT_core_ex_DASH_data) + tmp33 := lang.Apply(tmp32, []any{v2}) + tmp34 := lang.Apply(kw_glojure_DOT_error_SLASH_phase, []any{tmp33}) + var v35 any = tmp34 + _ = v35 + var tmp36 any + if lang.IsTruthy(v35) { + var tmp37 any + { // let + // let binding "phase" + var v38 any = v35 + _ = v38 + tmp39 := lang.NewMap(kw_phase, v38) + tmp40 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(476), kw_column, int(9), kw_end_DASH_line, int(476), kw_end_DASH_column, int(22)) + tmp41, err := lang.WithMeta(tmp39, tmp40.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp37 = tmp41 + } // end let + tmp36 = tmp37 + } else { + } + tmp31 = tmp36 + } // end let + tmp32 := lang.Apply(tmp13, []any{tmp28, tmp29, tmp30, tmp31}) + tmp3 = tmp32 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_Throwable_DASH__GT_map = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_Throwable_DASH__GT_map.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // as-> + { + tmp0 := sym_as_DASH__GT_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_expr, sym_name, sym__AMP_, sym_forms)), kw_doc, "Binds name to expr, evaluates the first form in the lexical context\n of that binding, then binds name to that result, repeating for each\n successive form, returning the result of the last form.", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(11), kw_line, int(7598), kw_end_DASH_line, int(7598))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var v6 any = lang.NewList(args[4:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := checkDerefVar(var_glojure_DOT_core_concat) + tmp9 := checkDerefVar(var_glojure_DOT_core_list) + tmp10 := lang.Apply(tmp9, []any{sym_glojure_DOT_core_SLASH_let}) + tmp11 := checkDerefVar(var_glojure_DOT_core_list) + tmp12 := checkDerefVar(var_glojure_DOT_core_apply) + tmp13 := checkDerefVar(var_glojure_DOT_core_vector) + tmp14 := checkDerefVar(var_glojure_DOT_core_seq) + tmp15 := checkDerefVar(var_glojure_DOT_core_concat) + tmp16 := checkDerefVar(var_glojure_DOT_core_list) + tmp17 := lang.Apply(tmp16, []any{v5}) + tmp18 := checkDerefVar(var_glojure_DOT_core_list) + tmp19 := lang.Apply(tmp18, []any{v4}) + tmp20 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp21 := checkDerefVar(var_glojure_DOT_core_repeat) + tmp22 := lang.Apply(tmp21, []any{v5}) + tmp23 := checkDerefVar(var_glojure_DOT_core_butlast) + tmp24 := lang.Apply(tmp23, []any{v6}) + tmp25 := lang.Apply(tmp20, []any{tmp22, tmp24}) + tmp26 := lang.Apply(tmp15, []any{tmp17, tmp19, tmp25}) + tmp27 := lang.Apply(tmp14, []any{tmp26}) + tmp28 := lang.Apply(tmp12, []any{tmp13, tmp27}) + tmp29 := lang.Apply(tmp11, []any{tmp28}) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + var tmp31 any + tmp32 := checkDerefVar(var_glojure_DOT_core_empty_QMARK_) + tmp33 := lang.Apply(tmp32, []any{v6}) + if lang.IsTruthy(tmp33) { + tmp31 = v5 + } else { + tmp34 := checkDerefVar(var_glojure_DOT_core_last) + tmp35 := lang.Apply(tmp34, []any{v6}) + tmp31 = tmp35 + } + tmp36 := lang.Apply(tmp30, []any{tmp31}) + tmp37 := lang.Apply(tmp8, []any{tmp10, tmp29, tmp36}) + tmp38 := lang.Apply(tmp7, []any{tmp37}) + return tmp38 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_as_DASH__GT_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_as_DASH__GT_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // await + { + tmp0 := sym_await.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_agents)), kw_doc, "Blocks the current thread (indefinitely!) until all actions\n dispatched thus far, from this thread or agent, to the agent(s) have\n occurred. Will block on failed agents. Will never return if\n a failed agent is restarted with :clear-actions true or shutdown-agents was called.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3267), kw_end_DASH_line, int(3267))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + var tmp3 any + tmp4 := lang.Apply(nil, nil) + if lang.IsTruthy(tmp4) { + panic("unimplemented: new with non-constant class type") + } else { + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_agent_STAR_) + if lang.IsTruthy(tmp6) { + tmp7 := lang.Apply(errors5.New, []any{"Can't await in agent action"}) + panic(tmp7) + } else { + } + _ = tmp5 + var tmp8 any + { // let + // let binding "latch" + var v9 any = "unimplemented: new with non-constant class type" + _ = v9 + // let binding "count-down" + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v11 := args[0] + _ = v11 + tmp12, _ := lang.FieldOrMethod(v9, "countDown") + if reflect.TypeOf(tmp12).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("countDown is not a function"))) + } + tmp13 := lang.Apply(tmp12, []any{}) + _ = tmp13 + return v11 + }) + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3279), kw_column, int(22), kw_end_DASH_line, int(3279), kw_end_DASH_column, int(61)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v13 any = tmp12 + _ = v13 + var tmp14 any + { // let + // let binding "seq_692" + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := lang.Apply(tmp15, []any{v2}) + var v17 any = tmp16 + _ = v17 + // let binding "chunk_693" + var v18 any = nil + _ = v18 + // let binding "count_694" + var v19 any = int64(0) + _ = v19 + // let binding "i_695" + var v20 any = int64(0) + _ = v20 + for { + var tmp21 any + tmp22 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp23 := lang.Apply(tmp22, []any{v20, v19}) + if lang.IsTruthy(tmp23) { + var tmp24 any + { // let + // let binding "agent" + tmp25, _ := lang.FieldOrMethod(v18, "nth") + if reflect.TypeOf(tmp25).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp26 := lang.Apply(tmp25, []any{v20}) + var v27 any = tmp26 + _ = v27 + tmp28 := checkDerefVar(var_glojure_DOT_core_send) + tmp29 := lang.Apply(tmp28, []any{v27, v13}) + _ = tmp29 + var tmp30 any = v17 + var tmp31 any = v18 + var tmp32 any = v19 + tmp34 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp35 := lang.Apply(tmp34, []any{v20}) + var tmp33 any = tmp35 + v17 = tmp30 + v18 = tmp31 + v19 = tmp32 + v20 = tmp33 + continue + } // end let + tmp21 = tmp24 + } else { + var tmp25 any + { // let + // let binding "temp__0__auto__" + tmp26 := checkDerefVar(var_glojure_DOT_core_seq) + tmp27 := lang.Apply(tmp26, []any{v17}) + var v28 any = tmp27 + _ = v28 + var tmp29 any + if lang.IsTruthy(v28) { + var tmp30 any + { // let + // let binding "seq_692" + var v31 any = v28 + _ = v31 + var tmp32 any + tmp33 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp34 := lang.Apply(tmp33, []any{v31}) + if lang.IsTruthy(tmp34) { + var tmp35 any + { // let + // let binding "c__0__auto__" + tmp36 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp37 := lang.Apply(tmp36, []any{v31}) + var v38 any = tmp37 + _ = v38 + tmp40 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp41 := lang.Apply(tmp40, []any{v31}) + var tmp39 any = tmp41 + var tmp42 any = v38 + tmp44 := checkDerefVar(var_glojure_DOT_core_int) + tmp45 := checkDerefVar(var_glojure_DOT_core_count) + tmp46 := lang.Apply(tmp45, []any{v38}) + tmp47 := lang.Apply(tmp44, []any{tmp46}) + var tmp43 any = tmp47 + tmp49 := checkDerefVar(var_glojure_DOT_core_int) + tmp50 := lang.Apply(tmp49, []any{int64(0)}) + var tmp48 any = tmp50 + v17 = tmp39 + v18 = tmp42 + v19 = tmp43 + v20 = tmp48 + continue + } // end let + tmp32 = tmp35 + } else { + var tmp36 any + { // let + // let binding "agent" + tmp37 := checkDerefVar(var_glojure_DOT_core_first) + tmp38 := lang.Apply(tmp37, []any{v31}) + var v39 any = tmp38 + _ = v39 + tmp40 := checkDerefVar(var_glojure_DOT_core_send) + tmp41 := lang.Apply(tmp40, []any{v39, v13}) + _ = tmp41 + tmp43 := checkDerefVar(var_glojure_DOT_core_next) + tmp44 := lang.Apply(tmp43, []any{v31}) + var tmp42 any = tmp44 + var tmp45 any = nil + var tmp46 any = int64(0) + var tmp47 any = int64(0) + v17 = tmp42 + v18 = tmp45 + v19 = tmp46 + v20 = tmp47 + continue + } // end let + tmp32 = tmp36 + } + tmp30 = tmp32 + } // end let + tmp29 = tmp30 + } else { + } + tmp25 = tmp29 + } // end let + tmp21 = tmp25 + } + tmp14 = tmp21 + break + } + } // end let + _ = tmp14 + tmp15, _ := lang.FieldOrMethod(v9, "await") + if reflect.TypeOf(tmp15).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) + } + tmp16 := lang.Apply(tmp15, []any{}) + tmp8 = tmp16 + } // end let + tmp3 = tmp8 + } + return tmp3 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_await = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_await.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // await1 + { + tmp0 := sym_await1.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(3284), kw_column, int(7), kw_end_DASH_line, int(3284), kw_end_DASH_column, int(21), kw_arglists, lang.NewList(lang.NewVector(sym_a)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp5, ok := lang.FieldOrMethod(v2, "getQueueCount") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getQueueCount"))) + } + var tmp6 any + switch reflect.TypeOf(tmp5).Kind() { + case reflect.Func: + tmp6 = lang.Apply(tmp5, nil) + default: + tmp6 = tmp5 + } + tmp7 := lang.Apply(tmp4, []any{tmp6}) + if lang.IsTruthy(tmp7) { + tmp8 := checkDerefVar(var_glojure_DOT_core_await) + tmp9 := lang.Apply(tmp8, []any{v2}) + tmp3 = tmp9 + } else { + } + _ = tmp3 + return v2 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_await1 = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_await1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // await-for + { + tmp0 := sym_await_DASH_for.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_timeout_DASH_ms, sym__AMP_, sym_agents)), kw_doc, "Blocks the current thread until all actions dispatched thus\n far (from this thread or agent) to the agents have occurred, or the\n timeout (in milliseconds) has elapsed. Returns logical false if\n returning due to timeout, logical true otherwise.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(3289), kw_end_DASH_line, int(3289))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + var tmp4 any + tmp5 := lang.Apply(nil, nil) + if lang.IsTruthy(tmp5) { + panic("unimplemented: new with non-constant class type") + } else { + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_agent_STAR_) + if lang.IsTruthy(tmp7) { + tmp8 := lang.Apply(errors5.New, []any{"Can't await in agent action"}) + panic(tmp8) + } else { + } + _ = tmp6 + var tmp9 any + { // let + // let binding "latch" + var v10 any = "unimplemented: new with non-constant class type" + _ = v10 + // let binding "count-down" + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v12 := args[0] + _ = v12 + tmp13, _ := lang.FieldOrMethod(v10, "countDown") + if reflect.TypeOf(tmp13).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("countDown is not a function"))) + } + tmp14 := lang.Apply(tmp13, []any{}) + _ = tmp14 + return v12 + }) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3301), kw_column, int(23), kw_end_DASH_line, int(3301), kw_end_DASH_column, int(62)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v14 any = tmp13 + _ = v14 + var tmp15 any + { // let + // let binding "seq_696" + tmp16 := checkDerefVar(var_glojure_DOT_core_seq) + tmp17 := lang.Apply(tmp16, []any{v3}) + var v18 any = tmp17 + _ = v18 + // let binding "chunk_697" + var v19 any = nil + _ = v19 + // let binding "count_698" + var v20 any = int64(0) + _ = v20 + // let binding "i_699" + var v21 any = int64(0) + _ = v21 + for { + var tmp22 any + tmp23 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp24 := lang.Apply(tmp23, []any{v21, v20}) + if lang.IsTruthy(tmp24) { + var tmp25 any + { // let + // let binding "agent" + tmp26, _ := lang.FieldOrMethod(v19, "nth") + if reflect.TypeOf(tmp26).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp27 := lang.Apply(tmp26, []any{v21}) + var v28 any = tmp27 + _ = v28 + tmp29 := checkDerefVar(var_glojure_DOT_core_send) + tmp30 := lang.Apply(tmp29, []any{v28, v14}) + _ = tmp30 + var tmp31 any = v18 + var tmp32 any = v19 + var tmp33 any = v20 + tmp35 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp36 := lang.Apply(tmp35, []any{v21}) + var tmp34 any = tmp36 + v18 = tmp31 + v19 = tmp32 + v20 = tmp33 + v21 = tmp34 + continue + } // end let + tmp22 = tmp25 + } else { + var tmp26 any + { // let + // let binding "temp__0__auto__" + tmp27 := checkDerefVar(var_glojure_DOT_core_seq) + tmp28 := lang.Apply(tmp27, []any{v18}) + var v29 any = tmp28 + _ = v29 + var tmp30 any + if lang.IsTruthy(v29) { + var tmp31 any + { // let + // let binding "seq_696" + var v32 any = v29 + _ = v32 + var tmp33 any + tmp34 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp35 := lang.Apply(tmp34, []any{v32}) + if lang.IsTruthy(tmp35) { + var tmp36 any + { // let + // let binding "c__0__auto__" + tmp37 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp38 := lang.Apply(tmp37, []any{v32}) + var v39 any = tmp38 + _ = v39 + tmp41 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp42 := lang.Apply(tmp41, []any{v32}) + var tmp40 any = tmp42 + var tmp43 any = v39 + tmp45 := checkDerefVar(var_glojure_DOT_core_int) + tmp46 := checkDerefVar(var_glojure_DOT_core_count) + tmp47 := lang.Apply(tmp46, []any{v39}) + tmp48 := lang.Apply(tmp45, []any{tmp47}) + var tmp44 any = tmp48 + tmp50 := checkDerefVar(var_glojure_DOT_core_int) + tmp51 := lang.Apply(tmp50, []any{int64(0)}) + var tmp49 any = tmp51 + v18 = tmp40 + v19 = tmp43 + v20 = tmp44 + v21 = tmp49 + continue + } // end let + tmp33 = tmp36 + } else { + var tmp37 any + { // let + // let binding "agent" + tmp38 := checkDerefVar(var_glojure_DOT_core_first) + tmp39 := lang.Apply(tmp38, []any{v32}) + var v40 any = tmp39 + _ = v40 + tmp41 := checkDerefVar(var_glojure_DOT_core_send) + tmp42 := lang.Apply(tmp41, []any{v40, v14}) + _ = tmp42 + tmp44 := checkDerefVar(var_glojure_DOT_core_next) + tmp45 := lang.Apply(tmp44, []any{v32}) + var tmp43 any = tmp45 + var tmp46 any = nil + var tmp47 any = int64(0) + var tmp48 any = int64(0) + v18 = tmp43 + v19 = tmp46 + v20 = tmp47 + v21 = tmp48 + continue + } // end let + tmp33 = tmp37 + } + tmp31 = tmp33 + } // end let + tmp30 = tmp31 + } else { + } + tmp26 = tmp30 + } // end let + tmp22 = tmp26 + } + tmp15 = tmp22 + break + } + } // end let + _ = tmp15 + tmp16, ok := lang.FieldOrMethod(nil, "MILLISECONDS") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "MILLISECONDS"))) + } + var tmp17 any + switch reflect.TypeOf(tmp16).Kind() { + case reflect.Func: + tmp17 = lang.Apply(tmp16, nil) + default: + tmp17 = tmp16 + } + tmp18, _ := lang.FieldOrMethod(v10, "await") + if reflect.TypeOf(tmp18).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) + } + tmp19 := lang.Apply(tmp18, []any{v2, tmp17}) + tmp9 = tmp19 + } // end let + tmp4 = tmp9 + } + return tmp4 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_await_DASH_for = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_await_DASH_for.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // check-cyclic-dependency + { + tmp0 := sym_check_DASH_cyclic_DASH_dependency.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_path)), kw_doc, "Detects and rejects non-trivial cyclic load dependencies. The\n exception message shows the dependency chain with the cycle\n highlighted. Ignores the trivial case of a file attempting to load\n itself because that can occur when a gen-class'd class loads its\n implementation.", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(30), kw_column, int(8), kw_line, int(5974), kw_end_DASH_line, int(5974), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_some) + tmp5 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{v2})) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5981), kw_column, int(15), kw_end_DASH_line, int(5981), kw_end_DASH_column, int(21)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp8 := checkDerefVar(var_glojure_DOT_core_rest) + tmp9 := checkDerefVar(var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_) + tmp10 := lang.Apply(tmp8, []any{tmp9}) + tmp11 := lang.Apply(tmp4, []any{tmp7, tmp10}) + if lang.IsTruthy(tmp11) { + var tmp12 any + { // let + // let binding "pending" + tmp13 := checkDerefVar(var_glojure_DOT_core_map) + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v15 := args[0] + _ = v15 + var tmp16 any + tmp17 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp18 := lang.Apply(tmp17, []any{v15, v2}) + if lang.IsTruthy(tmp18) { + tmp19 := checkDerefVar(var_glojure_DOT_core_str) + tmp20 := lang.Apply(tmp19, []any{"[ ", v15, " ]"}) + tmp16 = tmp20 + } else { + tmp16 = v15 + } + return tmp16 + }) + tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5982), kw_column, int(24), kw_end_DASH_line, int(5982), kw_end_DASH_column, int(59)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp17 := checkDerefVar(var_glojure_DOT_core_cons) + tmp18 := checkDerefVar(var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_) + tmp19 := lang.Apply(tmp17, []any{v2, tmp18}) + tmp20 := lang.Apply(tmp13, []any{tmp16, tmp19}) + var v21 any = tmp20 + _ = v21 + // let binding "chain" + tmp22 := checkDerefVar(var_glojure_DOT_core_apply) + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_interpose) + tmp25 := lang.Apply(tmp24, []any{"->", v21}) + tmp26 := lang.Apply(tmp22, []any{tmp23, tmp25}) + var v27 any = tmp26 + _ = v27 + tmp28 := checkDerefVar(var_glojure_DOT_core_throw_DASH_if) + tmp29 := lang.Apply(tmp28, []any{true, "Cyclic load dependency: %s", v27}) + tmp12 = tmp29 + } // end let + tmp3 = tmp12 + } else { + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_check_DASH_cyclic_DASH_dependency = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_check_DASH_cyclic_DASH_dependency.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // cond-> + { + tmp0 := sym_cond_DASH__GT_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_expr, sym__AMP_, sym_clauses)), kw_doc, "Takes an expression and a set of test/form pairs. Threads expr (via ->)\n through each form for which the corresponding test\n expression is true. Note that, unlike cond branching, cond-> threading does\n not short circuit after the first true test expression.", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(11), kw_line, int(7564), kw_end_DASH_line, int(7564))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "g" + tmp7 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp8 := lang.Apply(tmp7, nil) + var v9 any = tmp8 + _ = v9 + // let binding "steps" + tmp10 := checkDerefVar(var_glojure_DOT_core_map) + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v12 := args[0] + _ = v12 + var tmp13 any + { // let + // let binding "vec__675" + var v14 any = v12 + _ = v14 + // let binding "test" + tmp15 := checkDerefVar(var_glojure_DOT_core_nth) + tmp16 := lang.Apply(tmp15, []any{v14, int64(0), nil}) + var v17 any = tmp16 + _ = v17 + // let binding "step" + tmp18 := checkDerefVar(var_glojure_DOT_core_nth) + tmp19 := lang.Apply(tmp18, []any{v14, int64(1), nil}) + var v20 any = tmp19 + _ = v20 + tmp21 := checkDerefVar(var_glojure_DOT_core_seq) + tmp22 := checkDerefVar(var_glojure_DOT_core_concat) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := lang.Apply(tmp23, []any{sym_if}) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := lang.Apply(tmp25, []any{v17}) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := checkDerefVar(var_glojure_DOT_core_seq) + tmp29 := checkDerefVar(var_glojure_DOT_core_concat) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := lang.Apply(tmp30, []any{sym_glojure_DOT_core_SLASH__DASH__GT_}) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := lang.Apply(tmp32, []any{v9}) + tmp34 := checkDerefVar(var_glojure_DOT_core_list) + tmp35 := lang.Apply(tmp34, []any{v20}) + tmp36 := lang.Apply(tmp29, []any{tmp31, tmp33, tmp35}) + tmp37 := lang.Apply(tmp28, []any{tmp36}) + tmp38 := lang.Apply(tmp27, []any{tmp37}) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := lang.Apply(tmp39, []any{v9}) + tmp41 := lang.Apply(tmp22, []any{tmp24, tmp26, tmp38, tmp40}) + tmp42 := lang.Apply(tmp21, []any{tmp41}) + tmp13 = tmp42 + } // end let + return tmp13 + }) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7573), kw_column, int(20), kw_end_DASH_line, int(7573), kw_end_DASH_column, int(66)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp14 := checkDerefVar(var_glojure_DOT_core_partition) + tmp15 := lang.Apply(tmp14, []any{int64(2), v5}) + tmp16 := lang.Apply(tmp10, []any{tmp13, tmp15}) + var v17 any = tmp16 + _ = v17 + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{sym_glojure_DOT_core_SLASH_let}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := checkDerefVar(var_glojure_DOT_core_apply) + tmp24 := checkDerefVar(var_glojure_DOT_core_vector) + tmp25 := checkDerefVar(var_glojure_DOT_core_seq) + tmp26 := checkDerefVar(var_glojure_DOT_core_concat) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{v9}) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{v4}) + tmp31 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp32 := checkDerefVar(var_glojure_DOT_core_repeat) + tmp33 := lang.Apply(tmp32, []any{v9}) + tmp34 := checkDerefVar(var_glojure_DOT_core_butlast) + tmp35 := lang.Apply(tmp34, []any{v17}) + tmp36 := lang.Apply(tmp31, []any{tmp33, tmp35}) + tmp37 := lang.Apply(tmp26, []any{tmp28, tmp30, tmp36}) + tmp38 := lang.Apply(tmp25, []any{tmp37}) + tmp39 := lang.Apply(tmp23, []any{tmp24, tmp38}) + tmp40 := lang.Apply(tmp22, []any{tmp39}) + tmp41 := checkDerefVar(var_glojure_DOT_core_list) + var tmp42 any + tmp43 := checkDerefVar(var_glojure_DOT_core_empty_QMARK_) + tmp44 := lang.Apply(tmp43, []any{v17}) + if lang.IsTruthy(tmp44) { + tmp42 = v9 + } else { + tmp45 := checkDerefVar(var_glojure_DOT_core_last) + tmp46 := lang.Apply(tmp45, []any{v17}) + tmp42 = tmp46 + } + tmp47 := lang.Apply(tmp41, []any{tmp42}) + tmp48 := lang.Apply(tmp19, []any{tmp21, tmp40, tmp47}) + tmp49 := lang.Apply(tmp18, []any{tmp48}) + tmp6 = tmp49 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_cond_DASH__GT_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_cond_DASH__GT_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // cond->> + { + tmp0 := sym_cond_DASH__GT__GT_.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_expr, sym__AMP_, sym_clauses)), kw_doc, "Takes an expression and a set of test/form pairs. Threads expr (via ->>)\n through each form for which the corresponding test expression\n is true. Note that, unlike cond branching, cond->> threading does not short circuit\n after the first true test expression.", kw_file, "glojure/core.glj", kw_added, "1.5", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(7581), kw_end_DASH_line, int(7581))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "g" + tmp7 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp8 := lang.Apply(tmp7, nil) + var v9 any = tmp8 + _ = v9 + // let binding "steps" + tmp10 := checkDerefVar(var_glojure_DOT_core_map) + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v12 := args[0] + _ = v12 + var tmp13 any + { // let + // let binding "vec__679" + var v14 any = v12 + _ = v14 + // let binding "test" + tmp15 := checkDerefVar(var_glojure_DOT_core_nth) + tmp16 := lang.Apply(tmp15, []any{v14, int64(0), nil}) + var v17 any = tmp16 + _ = v17 + // let binding "step" + tmp18 := checkDerefVar(var_glojure_DOT_core_nth) + tmp19 := lang.Apply(tmp18, []any{v14, int64(1), nil}) + var v20 any = tmp19 + _ = v20 + tmp21 := checkDerefVar(var_glojure_DOT_core_seq) + tmp22 := checkDerefVar(var_glojure_DOT_core_concat) + tmp23 := checkDerefVar(var_glojure_DOT_core_list) + tmp24 := lang.Apply(tmp23, []any{sym_if}) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := lang.Apply(tmp25, []any{v17}) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := checkDerefVar(var_glojure_DOT_core_seq) + tmp29 := checkDerefVar(var_glojure_DOT_core_concat) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := lang.Apply(tmp30, []any{sym_glojure_DOT_core_SLASH__DASH__GT__GT_}) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := lang.Apply(tmp32, []any{v9}) + tmp34 := checkDerefVar(var_glojure_DOT_core_list) + tmp35 := lang.Apply(tmp34, []any{v20}) + tmp36 := lang.Apply(tmp29, []any{tmp31, tmp33, tmp35}) + tmp37 := lang.Apply(tmp28, []any{tmp36}) + tmp38 := lang.Apply(tmp27, []any{tmp37}) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := lang.Apply(tmp39, []any{v9}) + tmp41 := lang.Apply(tmp22, []any{tmp24, tmp26, tmp38, tmp40}) + tmp42 := lang.Apply(tmp21, []any{tmp41}) + tmp13 = tmp42 + } // end let + return tmp13 + }) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7590), kw_column, int(20), kw_end_DASH_line, int(7590), kw_end_DASH_column, int(67)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp14 := checkDerefVar(var_glojure_DOT_core_partition) + tmp15 := lang.Apply(tmp14, []any{int64(2), v5}) + tmp16 := lang.Apply(tmp10, []any{tmp13, tmp15}) + var v17 any = tmp16 + _ = v17 + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{sym_glojure_DOT_core_SLASH_let}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := checkDerefVar(var_glojure_DOT_core_apply) + tmp24 := checkDerefVar(var_glojure_DOT_core_vector) + tmp25 := checkDerefVar(var_glojure_DOT_core_seq) + tmp26 := checkDerefVar(var_glojure_DOT_core_concat) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{v9}) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{v4}) + tmp31 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp32 := checkDerefVar(var_glojure_DOT_core_repeat) + tmp33 := lang.Apply(tmp32, []any{v9}) + tmp34 := checkDerefVar(var_glojure_DOT_core_butlast) + tmp35 := lang.Apply(tmp34, []any{v17}) + tmp36 := lang.Apply(tmp31, []any{tmp33, tmp35}) + tmp37 := lang.Apply(tmp26, []any{tmp28, tmp30, tmp36}) + tmp38 := lang.Apply(tmp25, []any{tmp37}) + tmp39 := lang.Apply(tmp23, []any{tmp24, tmp38}) + tmp40 := lang.Apply(tmp22, []any{tmp39}) + tmp41 := checkDerefVar(var_glojure_DOT_core_list) + var tmp42 any + tmp43 := checkDerefVar(var_glojure_DOT_core_empty_QMARK_) + tmp44 := lang.Apply(tmp43, []any{v17}) + if lang.IsTruthy(tmp44) { + tmp42 = v9 + } else { + tmp45 := checkDerefVar(var_glojure_DOT_core_last) + tmp46 := lang.Apply(tmp45, []any{v17}) + tmp42 = tmp46 + } + tmp47 := lang.Apply(tmp41, []any{tmp42}) + tmp48 := lang.Apply(tmp19, []any{tmp21, tmp40, tmp47}) + tmp49 := lang.Apply(tmp18, []any{tmp48}) + tmp6 = tmp49 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_cond_DASH__GT__GT_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_cond_DASH__GT__GT_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // condp + { + tmp0 := sym_condp.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_pred, sym_expr, sym__AMP_, sym_clauses)), kw_doc, "Takes a binary predicate, an expression, and a set of clauses.\n Each clause can take the form of either:\n\n test-expr result-expr\n\n test-expr :>> result-fn\n\n Note :>> is an ordinary keyword.\n\n For each clause, (pred test-expr expr) is evaluated. If it returns\n logical true, the clause is a match. If a binary clause matches, the\n result-expr is returned, if a ternary clause matches, its result-fn,\n which must be a unary function, is called with the result of the\n predicate as its argument, the result of that call being the return\n value of condp. A single default expression can follow the clauses,\n and its value will be returned if no clause matches. If no default\n expression is provided and no clause matches, an\n IllegalArgumentException is thrown.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(11), kw_line, int(6353), kw_end_DASH_line, int(6353))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var v6 any = lang.NewList(args[4:]...) + _ = v6 + var tmp7 any + { // let + // let binding "gpred" + tmp8 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp9 := lang.Apply(tmp8, []any{"pred__"}) + var v10 any = tmp9 + _ = v10 + // let binding "gexpr" + tmp11 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp12 := lang.Apply(tmp11, []any{"expr__"}) + var v13 any = tmp12 + _ = v13 + // let binding "emit" + var tmp14 lang.FnFunc + { // function emit + var v15 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v16 := args[0] + _ = v16 + v17 := args[1] + _ = v17 + v18 := args[2] + _ = v18 + var tmp19 any + { // let + // let binding "vec__835" + tmp20 := checkDerefVar(var_glojure_DOT_core_split_DASH_at) + var tmp21 any + tmp22 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp23 := checkDerefVar(var_glojure_DOT_core_second) + tmp24 := lang.Apply(tmp23, []any{v18}) + tmp25 := lang.Apply(tmp22, []any{kw__GT__GT_, tmp24}) + if lang.IsTruthy(tmp25) { + tmp21 = int64(3) + } else { + tmp21 = int64(2) + } + tmp26 := lang.Apply(tmp20, []any{tmp21, v18}) + var v27 any = tmp26 + _ = v27 + // let binding "vec__838" + tmp28 := checkDerefVar(var_glojure_DOT_core_nth) + tmp29 := lang.Apply(tmp28, []any{v27, int64(0), nil}) + var v30 any = tmp29 + _ = v30 + // let binding "a" + tmp31 := checkDerefVar(var_glojure_DOT_core_nth) + tmp32 := lang.Apply(tmp31, []any{v30, int64(0), nil}) + var v33 any = tmp32 + _ = v33 + // let binding "b" + tmp34 := checkDerefVar(var_glojure_DOT_core_nth) + tmp35 := lang.Apply(tmp34, []any{v30, int64(1), nil}) + var v36 any = tmp35 + _ = v36 + // let binding "c" + tmp37 := checkDerefVar(var_glojure_DOT_core_nth) + tmp38 := lang.Apply(tmp37, []any{v30, int64(2), nil}) + var v39 any = tmp38 + _ = v39 + // let binding "clause" + var v40 any = v30 + _ = v40 + // let binding "more" + tmp41 := checkDerefVar(var_glojure_DOT_core_nth) + tmp42 := lang.Apply(tmp41, []any{v27, int64(1), nil}) + var v43 any = tmp42 + _ = v43 + // let binding "n" + tmp44 := checkDerefVar(var_glojure_DOT_core_count) + tmp45 := lang.Apply(tmp44, []any{v40}) + var v46 any = tmp45 + _ = v46 + var tmp47 any + tmp48 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp49 := lang.Apply(tmp48, []any{int64(0), v46}) + if lang.IsTruthy(tmp49) { + tmp50 := checkDerefVar(var_glojure_DOT_core_seq) + tmp51 := checkDerefVar(var_glojure_DOT_core_concat) + tmp52 := checkDerefVar(var_glojure_DOT_core_list) + tmp53 := lang.Apply(tmp52, []any{sym_throw}) + tmp54 := checkDerefVar(var_glojure_DOT_core_list) + tmp55 := checkDerefVar(var_glojure_DOT_core_seq) + tmp56 := checkDerefVar(var_glojure_DOT_core_concat) + tmp57 := checkDerefVar(var_glojure_DOT_core_list) + tmp58 := lang.Apply(tmp57, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_NewIllegalArgumentError}) + tmp59 := checkDerefVar(var_glojure_DOT_core_list) + tmp60 := checkDerefVar(var_glojure_DOT_core_seq) + tmp61 := checkDerefVar(var_glojure_DOT_core_concat) + tmp62 := checkDerefVar(var_glojure_DOT_core_list) + tmp63 := lang.Apply(tmp62, []any{sym_glojure_DOT_core_SLASH_str}) + tmp64 := checkDerefVar(var_glojure_DOT_core_list) + tmp65 := lang.Apply(tmp64, []any{"No matching clause: "}) + tmp66 := checkDerefVar(var_glojure_DOT_core_list) + tmp67 := lang.Apply(tmp66, []any{v17}) + tmp68 := lang.Apply(tmp61, []any{tmp63, tmp65, tmp67}) + tmp69 := lang.Apply(tmp60, []any{tmp68}) + tmp70 := lang.Apply(tmp59, []any{tmp69}) + tmp71 := lang.Apply(tmp56, []any{tmp58, tmp70}) + tmp72 := lang.Apply(tmp55, []any{tmp71}) + tmp73 := lang.Apply(tmp54, []any{tmp72}) + tmp74 := lang.Apply(tmp51, []any{tmp53, tmp73}) + tmp75 := lang.Apply(tmp50, []any{tmp74}) + tmp47 = tmp75 + } else { + var tmp76 any + tmp77 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp78 := lang.Apply(tmp77, []any{int64(1), v46}) + if lang.IsTruthy(tmp78) { + tmp76 = v33 + } else { + var tmp79 any + tmp80 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp81 := lang.Apply(tmp80, []any{int64(2), v46}) + if lang.IsTruthy(tmp81) { + tmp82 := checkDerefVar(var_glojure_DOT_core_seq) + tmp83 := checkDerefVar(var_glojure_DOT_core_concat) + tmp84 := checkDerefVar(var_glojure_DOT_core_list) + tmp85 := lang.Apply(tmp84, []any{sym_if}) + tmp86 := checkDerefVar(var_glojure_DOT_core_list) + tmp87 := checkDerefVar(var_glojure_DOT_core_seq) + tmp88 := checkDerefVar(var_glojure_DOT_core_concat) + tmp89 := checkDerefVar(var_glojure_DOT_core_list) + tmp90 := lang.Apply(tmp89, []any{v16}) + tmp91 := checkDerefVar(var_glojure_DOT_core_list) + tmp92 := lang.Apply(tmp91, []any{v33}) + tmp93 := checkDerefVar(var_glojure_DOT_core_list) + tmp94 := lang.Apply(tmp93, []any{v17}) + tmp95 := lang.Apply(tmp88, []any{tmp90, tmp92, tmp94}) + tmp96 := lang.Apply(tmp87, []any{tmp95}) + tmp97 := lang.Apply(tmp86, []any{tmp96}) + tmp98 := checkDerefVar(var_glojure_DOT_core_list) + tmp99 := lang.Apply(tmp98, []any{v36}) + tmp100 := checkDerefVar(var_glojure_DOT_core_list) + tmp101 := lang.Apply(v15, []any{v16, v17, v43}) + tmp102 := lang.Apply(tmp100, []any{tmp101}) + tmp103 := lang.Apply(tmp83, []any{tmp85, tmp97, tmp99, tmp102}) + tmp104 := lang.Apply(tmp82, []any{tmp103}) + tmp79 = tmp104 + } else { + var tmp105 any + if lang.IsTruthy(kw_else) { + tmp106 := checkDerefVar(var_glojure_DOT_core_seq) + tmp107 := checkDerefVar(var_glojure_DOT_core_concat) + tmp108 := checkDerefVar(var_glojure_DOT_core_list) + tmp109 := lang.Apply(tmp108, []any{sym_glojure_DOT_core_SLASH_if_DASH_let}) + tmp110 := checkDerefVar(var_glojure_DOT_core_list) + tmp111 := checkDerefVar(var_glojure_DOT_core_apply) + tmp112 := checkDerefVar(var_glojure_DOT_core_vector) + tmp113 := checkDerefVar(var_glojure_DOT_core_seq) + tmp114 := checkDerefVar(var_glojure_DOT_core_concat) + tmp115 := checkDerefVar(var_glojure_DOT_core_list) + tmp116 := lang.Apply(tmp115, []any{sym_p__0__auto__}) + tmp117 := checkDerefVar(var_glojure_DOT_core_list) + tmp118 := checkDerefVar(var_glojure_DOT_core_seq) + tmp119 := checkDerefVar(var_glojure_DOT_core_concat) + tmp120 := checkDerefVar(var_glojure_DOT_core_list) + tmp121 := lang.Apply(tmp120, []any{v16}) + tmp122 := checkDerefVar(var_glojure_DOT_core_list) + tmp123 := lang.Apply(tmp122, []any{v33}) + tmp124 := checkDerefVar(var_glojure_DOT_core_list) + tmp125 := lang.Apply(tmp124, []any{v17}) + tmp126 := lang.Apply(tmp119, []any{tmp121, tmp123, tmp125}) + tmp127 := lang.Apply(tmp118, []any{tmp126}) + tmp128 := lang.Apply(tmp117, []any{tmp127}) + tmp129 := lang.Apply(tmp114, []any{tmp116, tmp128}) + tmp130 := lang.Apply(tmp113, []any{tmp129}) + tmp131 := lang.Apply(tmp111, []any{tmp112, tmp130}) + tmp132 := lang.Apply(tmp110, []any{tmp131}) + tmp133 := checkDerefVar(var_glojure_DOT_core_list) + tmp134 := checkDerefVar(var_glojure_DOT_core_seq) + tmp135 := checkDerefVar(var_glojure_DOT_core_concat) + tmp136 := checkDerefVar(var_glojure_DOT_core_list) + tmp137 := lang.Apply(tmp136, []any{v39}) + tmp138 := checkDerefVar(var_glojure_DOT_core_list) + tmp139 := lang.Apply(tmp138, []any{sym_p__0__auto__}) + tmp140 := lang.Apply(tmp135, []any{tmp137, tmp139}) + tmp141 := lang.Apply(tmp134, []any{tmp140}) + tmp142 := lang.Apply(tmp133, []any{tmp141}) + tmp143 := checkDerefVar(var_glojure_DOT_core_list) + tmp144 := lang.Apply(v15, []any{v16, v17, v43}) + tmp145 := lang.Apply(tmp143, []any{tmp144}) + tmp146 := lang.Apply(tmp107, []any{tmp109, tmp132, tmp142, tmp145}) + tmp147 := lang.Apply(tmp106, []any{tmp146}) + tmp105 = tmp147 + } else { + } + tmp79 = tmp105 + } + tmp76 = tmp79 + } + tmp47 = tmp76 + } + tmp19 = tmp47 + } // end let + return tmp19 + }) + v15 = tmp14 + _ = v15 + } + tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6377), kw_column, int(14), kw_end_DASH_line, int(6389), kw_end_DASH_column, int(53)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v17 any = tmp16 + _ = v17 + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := checkDerefVar(var_glojure_DOT_core_concat) + tmp20 := checkDerefVar(var_glojure_DOT_core_list) + tmp21 := lang.Apply(tmp20, []any{sym_glojure_DOT_core_SLASH_let}) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := checkDerefVar(var_glojure_DOT_core_apply) + tmp24 := checkDerefVar(var_glojure_DOT_core_vector) + tmp25 := checkDerefVar(var_glojure_DOT_core_seq) + tmp26 := checkDerefVar(var_glojure_DOT_core_concat) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := lang.Apply(tmp27, []any{v10}) + tmp29 := checkDerefVar(var_glojure_DOT_core_list) + tmp30 := lang.Apply(tmp29, []any{v4}) + tmp31 := checkDerefVar(var_glojure_DOT_core_list) + tmp32 := lang.Apply(tmp31, []any{v13}) + tmp33 := checkDerefVar(var_glojure_DOT_core_list) + tmp34 := lang.Apply(tmp33, []any{v5}) + tmp35 := lang.Apply(tmp26, []any{tmp28, tmp30, tmp32, tmp34}) + tmp36 := lang.Apply(tmp25, []any{tmp35}) + tmp37 := lang.Apply(tmp23, []any{tmp24, tmp36}) + tmp38 := lang.Apply(tmp22, []any{tmp37}) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := lang.Apply(v17, []any{v10, v13, v6}) + tmp41 := lang.Apply(tmp39, []any{tmp40}) + tmp42 := lang.Apply(tmp19, []any{tmp21, tmp38, tmp41}) + tmp43 := lang.Apply(tmp18, []any{tmp42}) + tmp7 = tmp43 + } // end let + return tmp7 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_condp = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_condp.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // destructure + { + tmp0 := sym_destructure.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4400), kw_column, int(7), kw_end_DASH_line, int(4400), kw_end_DASH_column, int(17), kw_arglists, lang.NewList(lang.NewVector(sym_bindings)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "bents" + tmp4 := checkDerefVar(var_glojure_DOT_core_partition) + tmp5 := lang.Apply(tmp4, []any{int64(2), v2}) + var v6 any = tmp5 + _ = v6 + // let binding "pb" + var tmp7 lang.FnFunc + { // function pb + var v8 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v9 := args[0] + _ = v9 + v10 := args[1] + _ = v10 + v11 := args[2] + _ = v11 + var tmp12 any + { // let + // let binding "pvec" + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v14 := args[0] + _ = v14 + v15 := args[1] + _ = v15 + v16 := args[2] + _ = v16 + var tmp17 any + { // let + // let binding "gvec" + tmp18 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp19 := lang.Apply(tmp18, []any{"vec__"}) + var v20 any = tmp19 + _ = v20 + // let binding "gseq" + tmp21 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp22 := lang.Apply(tmp21, []any{"seq__"}) + var v23 any = tmp22 + _ = v23 + // let binding "gfirst" + tmp24 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp25 := lang.Apply(tmp24, []any{"first__"}) + var v26 any = tmp25 + _ = v26 + // let binding "has-rest" + tmp27 := checkDerefVar(var_glojure_DOT_core_some) + tmp28 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{sym__AMP_})) + tmp29 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4408), kw_column, int(43), kw_end_DASH_line, int(4408), kw_end_DASH_column, int(47)) + tmp30, err := lang.WithMeta(tmp28, tmp29.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp31 := lang.Apply(tmp27, []any{tmp30, v15}) + var v32 any = tmp31 + _ = v32 + var tmp33 any + { // let + // let binding "ret" + var tmp34 any + { // let + // let binding "ret" + tmp35 := checkDerefVar(var_glojure_DOT_core_conj) + tmp36 := lang.Apply(tmp35, []any{v14, v20, v16}) + var v37 any = tmp36 + _ = v37 + var tmp38 any + if lang.IsTruthy(v32) { + tmp39 := checkDerefVar(var_glojure_DOT_core_conj) + tmp40 := checkDerefVar(var_glojure_DOT_core_list) + tmp41 := lang.Apply(tmp40, []any{sym_glojure_DOT_core_SLASH_seq, v20}) + tmp42 := lang.Apply(tmp39, []any{v37, v23, tmp41}) + tmp38 = tmp42 + } else { + tmp38 = v37 + } + tmp34 = tmp38 + } // end let + var v35 any = tmp34 + _ = v35 + // let binding "n" + var v36 any = int64(0) + _ = v36 + // let binding "bs" + var v37 any = v15 + _ = v37 + // let binding "seen-rest?" + var v38 any = false + _ = v38 + for { + var tmp39 any + tmp40 := checkDerefVar(var_glojure_DOT_core_seq) + tmp41 := lang.Apply(tmp40, []any{v37}) + if lang.IsTruthy(tmp41) { + var tmp42 any + { // let + // let binding "firstb" + tmp43 := checkDerefVar(var_glojure_DOT_core_first) + tmp44 := lang.Apply(tmp43, []any{v37}) + var v45 any = tmp44 + _ = v45 + var tmp46 any + tmp47 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp48 := lang.Apply(tmp47, []any{v45, sym__AMP_}) + if lang.IsTruthy(tmp48) { + tmp50 := checkDerefVar(var_glojure_DOT_core_second) + tmp51 := lang.Apply(tmp50, []any{v37}) + tmp52 := lang.Apply(v8, []any{v35, tmp51, v23}) + var tmp49 any = tmp52 + var tmp53 any = v36 + tmp55 := checkDerefVar(var_glojure_DOT_core_nnext) + tmp56 := lang.Apply(tmp55, []any{v37}) + var tmp54 any = tmp56 + var tmp57 any = true + v35 = tmp49 + v36 = tmp53 + v37 = tmp54 + v38 = tmp57 + continue + } else { + var tmp58 any + tmp59 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp60 := lang.Apply(tmp59, []any{v45, kw_as}) + if lang.IsTruthy(tmp60) { + tmp61 := checkDerefVar(var_glojure_DOT_core_second) + tmp62 := lang.Apply(tmp61, []any{v37}) + tmp63 := lang.Apply(v8, []any{v35, tmp62, v20}) + tmp58 = tmp63 + } else { + var tmp64 any + if lang.IsTruthy(kw_else) { + var tmp65 any + if lang.IsTruthy(v38) { + tmp66 := lang.Apply(errors5.New, []any{"Unsupported binding form, only :as can follow & parameter"}) + panic(tmp66) + } else { + var tmp68 any + if lang.IsTruthy(v32) { + tmp69 := checkDerefVar(var_glojure_DOT_core_conj) + tmp70 := checkDerefVar(var_glojure_DOT_core_seq) + tmp71 := checkDerefVar(var_glojure_DOT_core_concat) + tmp72 := checkDerefVar(var_glojure_DOT_core_list) + tmp73 := lang.Apply(tmp72, []any{sym_glojure_DOT_core_SLASH_first}) + tmp74 := checkDerefVar(var_glojure_DOT_core_list) + tmp75 := lang.Apply(tmp74, []any{v23}) + tmp76 := lang.Apply(tmp71, []any{tmp73, tmp75}) + tmp77 := lang.Apply(tmp70, []any{tmp76}) + tmp78 := checkDerefVar(var_glojure_DOT_core_seq) + tmp79 := checkDerefVar(var_glojure_DOT_core_concat) + tmp80 := checkDerefVar(var_glojure_DOT_core_list) + tmp81 := lang.Apply(tmp80, []any{sym_glojure_DOT_core_SLASH_next}) + tmp82 := checkDerefVar(var_glojure_DOT_core_list) + tmp83 := lang.Apply(tmp82, []any{v23}) + tmp84 := lang.Apply(tmp79, []any{tmp81, tmp83}) + tmp85 := lang.Apply(tmp78, []any{tmp84}) + tmp86 := lang.Apply(tmp69, []any{v35, v26, tmp77, v23, tmp85}) + tmp68 = tmp86 + } else { + tmp68 = v35 + } + var tmp87 any + if lang.IsTruthy(v32) { + tmp87 = v26 + } else { + tmp88 := checkDerefVar(var_glojure_DOT_core_list) + tmp89 := lang.Apply(tmp88, []any{sym_glojure_DOT_core_SLASH_nth, v20, v36, nil}) + tmp87 = tmp89 + } + tmp90 := lang.Apply(v8, []any{tmp68, v45, tmp87}) + var tmp67 any = tmp90 + tmp92 := checkDerefVar(var_glojure_DOT_core_inc) + tmp93 := lang.Apply(tmp92, []any{v36}) + var tmp91 any = tmp93 + tmp95 := checkDerefVar(var_glojure_DOT_core_next) + tmp96 := lang.Apply(tmp95, []any{v37}) + var tmp94 any = tmp96 + var tmp97 any = v38 + v35 = tmp67 + v36 = tmp91 + v37 = tmp94 + v38 = tmp97 + continue + } + tmp64 = tmp65 + } else { + } + tmp58 = tmp64 + } + tmp46 = tmp58 + } + tmp42 = tmp46 + } // end let + tmp39 = tmp42 + } else { + tmp39 = v35 + } + tmp33 = tmp39 + break + } + } // end let + tmp17 = tmp33 + } // end let + return tmp17 + }) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4404), kw_column, int(20), kw_end_DASH_line, int(4438), kw_end_DASH_column, int(34)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v16 any = tmp15 + _ = v16 + // let binding "pmap" + var tmp17 lang.FnFunc + tmp17 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v18 := args[0] + _ = v18 + v19 := args[1] + _ = v19 + v20 := args[2] + _ = v20 + var tmp21 any + { // let + // let binding "gmap" + tmp22 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp23 := lang.Apply(tmp22, []any{"map__"}) + var v24 any = tmp23 + _ = v24 + // let binding "gmapseq" + tmp25 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp26 := lang.NewMap(kw_tag, sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_ISeq) + tmp27 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4442), kw_column, int(52), kw_end_DASH_line, int(4442), kw_end_DASH_column, int(103)) + tmp28, err := lang.WithMeta(tmp26, tmp27.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp29 := lang.Apply(tmp25, []any{v24, tmp28}) + var v30 any = tmp29 + _ = v30 + // let binding "defaults" + tmp31 := lang.Apply(kw_or, []any{v19}) + var v32 any = tmp31 + _ = v32 + var tmp33 any + { // let + // let binding "ret" + var tmp34 lang.FnFunc + tmp34 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v35 := args[0] + _ = v35 + var tmp36 any + tmp37 := lang.Apply(kw_as, []any{v19}) + if lang.IsTruthy(tmp37) { + tmp38 := checkDerefVar(var_glojure_DOT_core_conj) + tmp39 := lang.Apply(kw_as, []any{v19}) + tmp40 := lang.Apply(tmp38, []any{v35, tmp39, v24}) + tmp36 = tmp40 + } else { + tmp36 = v35 + } + return tmp36 + }) + tmp35 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4450), kw_column, int(40), kw_end_DASH_line, int(4453), kw_end_DASH_column, int(48)) + tmp36, err := lang.WithMeta(tmp34, tmp35.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp37 := checkDerefVar(var_glojure_DOT_core_conj) + tmp38 := checkDerefVar(var_glojure_DOT_core_conj) + tmp39 := checkDerefVar(var_glojure_DOT_core_conj) + tmp40 := checkDerefVar(var_glojure_DOT_core_conj) + tmp41 := lang.Apply(tmp40, []any{v18, v24}) + tmp42 := lang.Apply(tmp39, []any{tmp41, v20}) + tmp43 := lang.Apply(tmp38, []any{tmp42, v24}) + tmp44 := checkDerefVar(var_glojure_DOT_core_seq) + tmp45 := checkDerefVar(var_glojure_DOT_core_concat) + tmp46 := checkDerefVar(var_glojure_DOT_core_list) + tmp47 := lang.Apply(tmp46, []any{sym_if}) + tmp48 := checkDerefVar(var_glojure_DOT_core_list) + tmp49 := checkDerefVar(var_glojure_DOT_core_seq) + tmp50 := checkDerefVar(var_glojure_DOT_core_concat) + tmp51 := checkDerefVar(var_glojure_DOT_core_list) + tmp52 := lang.Apply(tmp51, []any{sym_glojure_DOT_core_SLASH_seq_QMARK_}) + tmp53 := checkDerefVar(var_glojure_DOT_core_list) + tmp54 := lang.Apply(tmp53, []any{v24}) + tmp55 := lang.Apply(tmp50, []any{tmp52, tmp54}) + tmp56 := lang.Apply(tmp49, []any{tmp55}) + tmp57 := lang.Apply(tmp48, []any{tmp56}) + tmp58 := checkDerefVar(var_glojure_DOT_core_list) + tmp59 := checkDerefVar(var_glojure_DOT_core_seq) + tmp60 := checkDerefVar(var_glojure_DOT_core_concat) + tmp61 := checkDerefVar(var_glojure_DOT_core_list) + tmp62 := lang.Apply(tmp61, []any{sym_if}) + tmp63 := checkDerefVar(var_glojure_DOT_core_list) + tmp64 := checkDerefVar(var_glojure_DOT_core_seq) + tmp65 := checkDerefVar(var_glojure_DOT_core_concat) + tmp66 := checkDerefVar(var_glojure_DOT_core_list) + tmp67 := lang.Apply(tmp66, []any{sym_glojure_DOT_core_SLASH_next}) + tmp68 := checkDerefVar(var_glojure_DOT_core_list) + tmp69 := lang.Apply(tmp68, []any{v30}) + tmp70 := lang.Apply(tmp65, []any{tmp67, tmp69}) + tmp71 := lang.Apply(tmp64, []any{tmp70}) + tmp72 := lang.Apply(tmp63, []any{tmp71}) + tmp73 := checkDerefVar(var_glojure_DOT_core_list) + tmp74 := checkDerefVar(var_glojure_DOT_core_seq) + tmp75 := checkDerefVar(var_glojure_DOT_core_concat) + tmp76 := checkDerefVar(var_glojure_DOT_core_list) + tmp77 := lang.Apply(tmp76, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_NewPersistentArrayMapAsIfByAssoc}) + tmp78 := checkDerefVar(var_glojure_DOT_core_list) + tmp79 := checkDerefVar(var_glojure_DOT_core_seq) + tmp80 := checkDerefVar(var_glojure_DOT_core_concat) + tmp81 := checkDerefVar(var_glojure_DOT_core_list) + tmp82 := lang.Apply(tmp81, []any{sym_glojure_DOT_core_SLASH_to_DASH_array}) + tmp83 := checkDerefVar(var_glojure_DOT_core_list) + tmp84 := lang.Apply(tmp83, []any{v30}) + tmp85 := lang.Apply(tmp80, []any{tmp82, tmp84}) + tmp86 := lang.Apply(tmp79, []any{tmp85}) + tmp87 := lang.Apply(tmp78, []any{tmp86}) + tmp88 := lang.Apply(tmp75, []any{tmp77, tmp87}) + tmp89 := lang.Apply(tmp74, []any{tmp88}) + tmp90 := lang.Apply(tmp73, []any{tmp89}) + tmp91 := checkDerefVar(var_glojure_DOT_core_list) + tmp92 := checkDerefVar(var_glojure_DOT_core_seq) + tmp93 := checkDerefVar(var_glojure_DOT_core_concat) + tmp94 := checkDerefVar(var_glojure_DOT_core_list) + tmp95 := lang.Apply(tmp94, []any{sym_if}) + tmp96 := checkDerefVar(var_glojure_DOT_core_list) + tmp97 := checkDerefVar(var_glojure_DOT_core_seq) + tmp98 := checkDerefVar(var_glojure_DOT_core_concat) + tmp99 := checkDerefVar(var_glojure_DOT_core_list) + tmp100 := lang.Apply(tmp99, []any{sym_glojure_DOT_core_SLASH_seq}) + tmp101 := checkDerefVar(var_glojure_DOT_core_list) + tmp102 := lang.Apply(tmp101, []any{v30}) + tmp103 := lang.Apply(tmp98, []any{tmp100, tmp102}) + tmp104 := lang.Apply(tmp97, []any{tmp103}) + tmp105 := lang.Apply(tmp96, []any{tmp104}) + tmp106 := checkDerefVar(var_glojure_DOT_core_list) + tmp107 := checkDerefVar(var_glojure_DOT_core_seq) + tmp108 := checkDerefVar(var_glojure_DOT_core_concat) + tmp109 := checkDerefVar(var_glojure_DOT_core_list) + tmp110 := lang.Apply(tmp109, []any{sym_glojure_DOT_core_SLASH_first}) + tmp111 := checkDerefVar(var_glojure_DOT_core_list) + tmp112 := lang.Apply(tmp111, []any{v30}) + tmp113 := lang.Apply(tmp108, []any{tmp110, tmp112}) + tmp114 := lang.Apply(tmp107, []any{tmp113}) + tmp115 := lang.Apply(tmp106, []any{tmp114}) + tmp116 := checkDerefVar(var_glojure_DOT_core_list) + tmp117 := lang.Apply(tmp116, []any{sym_glojure_DOT_lang_DOT_PersistentArrayMap_SLASH_EMPTY}) + tmp118 := lang.Apply(tmp93, []any{tmp95, tmp105, tmp115, tmp117}) + tmp119 := lang.Apply(tmp92, []any{tmp118}) + tmp120 := lang.Apply(tmp91, []any{tmp119}) + tmp121 := lang.Apply(tmp60, []any{tmp62, tmp72, tmp90, tmp120}) + tmp122 := lang.Apply(tmp59, []any{tmp121}) + tmp123 := lang.Apply(tmp58, []any{tmp122}) + tmp124 := checkDerefVar(var_glojure_DOT_core_list) + tmp125 := lang.Apply(tmp124, []any{v24}) + tmp126 := lang.Apply(tmp45, []any{tmp47, tmp57, tmp123, tmp125}) + tmp127 := lang.Apply(tmp44, []any{tmp126}) + tmp128 := lang.Apply(tmp37, []any{tmp43, tmp127}) + tmp129 := lang.Apply(tmp36, []any{tmp128}) + var v130 any = tmp129 + _ = v130 + // let binding "bes" + var tmp131 any + { // let + // let binding "transforms" + tmp132 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp133 lang.FnFunc + tmp133 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v134 := args[0] + _ = v134 + v135 := args[1] + _ = v135 + var tmp136 any + tmp137 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp138 := lang.Apply(tmp137, []any{v135}) + if lang.IsTruthy(tmp138) { + var tmp139 any + { // let + // let binding "mkns" + tmp140 := checkDerefVar(var_glojure_DOT_core_namespace) + tmp141 := lang.Apply(tmp140, []any{v135}) + var v142 any = tmp141 + _ = v142 + // let binding "mkn" + tmp143 := checkDerefVar(var_glojure_DOT_core_name) + tmp144 := lang.Apply(tmp143, []any{v135}) + var v145 any = tmp144 + _ = v145 + var tmp146 any + tmp147 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp148 := lang.Apply(tmp147, []any{v145, "keys"}) + if lang.IsTruthy(tmp148) { + tmp149 := checkDerefVar(var_glojure_DOT_core_assoc) + var tmp150 lang.FnFunc + tmp150 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v151 := args[0] + _ = v151 + tmp152 := checkDerefVar(var_glojure_DOT_core_keyword) + var tmp153 any + { // let + // let binding "or__0__auto__" + var v154 any = v142 + _ = v154 + var tmp155 any + if lang.IsTruthy(v154) { + tmp155 = v154 + } else { + tmp156 := checkDerefVar(var_glojure_DOT_core_namespace) + tmp157 := lang.Apply(tmp156, []any{v151}) + tmp155 = tmp157 + } + tmp153 = tmp155 + } // end let + tmp154 := checkDerefVar(var_glojure_DOT_core_name) + tmp155 := lang.Apply(tmp154, []any{v151}) + tmp156 := lang.Apply(tmp152, []any{tmp153, tmp155}) + return tmp156 + }) + tmp151 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4460), kw_column, int(93), kw_end_DASH_line, int(4460), kw_end_DASH_column, int(135)) + tmp152, err := lang.WithMeta(tmp150, tmp151.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp153 := lang.Apply(tmp149, []any{v134, v135, tmp152}) + tmp146 = tmp153 + } else { + var tmp154 any + tmp155 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp156 := lang.Apply(tmp155, []any{v145, "syms"}) + if lang.IsTruthy(tmp156) { + tmp157 := checkDerefVar(var_glojure_DOT_core_assoc) + var tmp158 lang.FnFunc + tmp158 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v159 := args[0] + _ = v159 + tmp160 := checkDerefVar(var_glojure_DOT_core_list) + tmp161 := checkDerefVar(var_glojure_DOT_core_symbol) + var tmp162 any + { // let + // let binding "or__0__auto__" + var v163 any = v142 + _ = v163 + var tmp164 any + if lang.IsTruthy(v163) { + tmp164 = v163 + } else { + tmp165 := checkDerefVar(var_glojure_DOT_core_namespace) + tmp166 := lang.Apply(tmp165, []any{v159}) + tmp164 = tmp166 + } + tmp162 = tmp164 + } // end let + tmp163 := checkDerefVar(var_glojure_DOT_core_name) + tmp164 := lang.Apply(tmp163, []any{v159}) + tmp165 := lang.Apply(tmp161, []any{tmp162, tmp164}) + tmp166 := lang.Apply(tmp160, []any{sym_quote, tmp165}) + return tmp166 + }) + tmp159 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4461), kw_column, int(93), kw_end_DASH_line, int(4461), kw_end_DASH_column, int(148)) + tmp160, err := lang.WithMeta(tmp158, tmp159.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp161 := lang.Apply(tmp157, []any{v134, v135, tmp160}) + tmp154 = tmp161 + } else { + var tmp162 any + tmp163 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp164 := lang.Apply(tmp163, []any{v145, "strs"}) + if lang.IsTruthy(tmp164) { + tmp165 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp166 := checkDerefVar(var_glojure_DOT_core_str) + tmp167 := lang.Apply(tmp165, []any{v134, v135, tmp166}) + tmp162 = tmp167 + } else { + var tmp168 any + if lang.IsTruthy(kw_else) { + tmp168 = v134 + } else { + } + tmp162 = tmp168 + } + tmp154 = tmp162 + } + tmp146 = tmp154 + } + tmp139 = tmp146 + } // end let + tmp136 = tmp139 + } else { + tmp136 = v134 + } + return tmp136 + }) + tmp134 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4456), kw_column, int(45), kw_end_DASH_line, int(4464), kw_end_DASH_column, int(60)) + tmp135, err := lang.WithMeta(tmp133, tmp134.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp136 := lang.NewMap() + tmp137 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4465), kw_column, int(45), kw_end_DASH_line, int(4465), kw_end_DASH_column, int(46)) + tmp138, err := lang.WithMeta(tmp136, tmp137.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp139 := checkDerefVar(var_glojure_DOT_core_keys) + tmp140 := lang.Apply(tmp139, []any{v19}) + tmp141 := lang.Apply(tmp132, []any{tmp135, tmp138, tmp140}) + var v142 any = tmp141 + _ = v142 + tmp143 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp144 lang.FnFunc + tmp144 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v145 := args[0] + _ = v145 + v146 := args[1] + _ = v146 + tmp147 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp148 lang.FnFunc + tmp148 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v149 := args[0] + _ = v149 + v150 := args[1] + _ = v150 + tmp151 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp152 := checkDerefVar(var_glojure_DOT_core_val) + tmp153 := lang.Apply(tmp152, []any{v146}) + tmp154 := lang.Apply(tmp153, []any{v150}) + tmp155 := lang.Apply(tmp151, []any{v149, v150, tmp154}) + return tmp155 + }) + tmp149 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4469), kw_column, int(52), kw_end_DASH_line, int(4469), kw_end_DASH_column, int(82)) + tmp150, err := lang.WithMeta(tmp148, tmp149.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp151 := checkDerefVar(var_glojure_DOT_core_dissoc) + tmp152 := checkDerefVar(var_glojure_DOT_core_key) + tmp153 := lang.Apply(tmp152, []any{v146}) + tmp154 := lang.Apply(tmp151, []any{v145, tmp153}) + tmp155 := checkDerefVar(var_glojure_DOT_core_key) + tmp156 := lang.Apply(tmp155, []any{v146}) + tmp157 := lang.Apply(tmp156, []any{v145}) + tmp158 := lang.Apply(tmp147, []any{tmp150, tmp154, tmp157}) + return tmp158 + }) + tmp145 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4468), kw_column, int(41), kw_end_DASH_line, int(4471), kw_end_DASH_column, int(70)) + tmp146, err := lang.WithMeta(tmp144, tmp145.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp147 := checkDerefVar(var_glojure_DOT_core_dissoc) + tmp148 := lang.Apply(tmp147, []any{v19, kw_as, kw_or}) + tmp149 := lang.Apply(tmp143, []any{tmp146, tmp148, v142}) + tmp131 = tmp149 + } // end let + var v132 any = tmp131 + _ = v132 + for { + var tmp133 any + tmp134 := checkDerefVar(var_glojure_DOT_core_seq) + tmp135 := lang.Apply(tmp134, []any{v132}) + if lang.IsTruthy(tmp135) { + var tmp136 any + { // let + // let binding "bb" + tmp137 := checkDerefVar(var_glojure_DOT_core_key) + tmp138 := checkDerefVar(var_glojure_DOT_core_first) + tmp139 := lang.Apply(tmp138, []any{v132}) + tmp140 := lang.Apply(tmp137, []any{tmp139}) + var v141 any = tmp140 + _ = v141 + // let binding "bk" + tmp142 := checkDerefVar(var_glojure_DOT_core_val) + tmp143 := checkDerefVar(var_glojure_DOT_core_first) + tmp144 := lang.Apply(tmp143, []any{v132}) + tmp145 := lang.Apply(tmp142, []any{tmp144}) + var v146 any = tmp145 + _ = v146 + // let binding "local" + var tmp147 any + tmp148 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp149 := reflect.TypeOf((*lang.Named)(nil)).Elem() + tmp150 := lang.Apply(tmp148, []any{tmp149, v141}) + if lang.IsTruthy(tmp150) { + tmp151 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp152 := checkDerefVar(var_glojure_DOT_core_symbol) + tmp153 := checkDerefVar(var_glojure_DOT_core_name) + tmp154 := lang.Apply(tmp153, []any{v141}) + tmp155 := lang.Apply(tmp152, []any{nil, tmp154}) + tmp156 := checkDerefVar(var_glojure_DOT_core_meta) + tmp157 := lang.Apply(tmp156, []any{v141}) + tmp158 := lang.Apply(tmp151, []any{tmp155, tmp157}) + tmp147 = tmp158 + } else { + tmp147 = v141 + } + var v159 any = tmp147 + _ = v159 + // let binding "bv" + var tmp160 any + tmp161 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp162 := lang.Apply(tmp161, []any{v32, v159}) + if lang.IsTruthy(tmp162) { + tmp163 := checkDerefVar(var_glojure_DOT_core_list) + tmp164 := lang.Apply(v32, []any{v159}) + tmp165 := lang.Apply(tmp163, []any{sym_glojure_DOT_core_SLASH_get, v24, v146, tmp164}) + tmp160 = tmp165 + } else { + tmp166 := checkDerefVar(var_glojure_DOT_core_list) + tmp167 := lang.Apply(tmp166, []any{sym_glojure_DOT_core_SLASH_get, v24, v146}) + tmp160 = tmp167 + } + var v168 any = tmp160 + _ = v168 + var tmp170 any + tmp171 := checkDerefVar(var_glojure_DOT_core_ident_QMARK_) + tmp172 := lang.Apply(tmp171, []any{v141}) + if lang.IsTruthy(tmp172) { + tmp173 := checkDerefVar(var_glojure_DOT_core_conj) + tmp174 := lang.Apply(tmp173, []any{v130, v159, v168}) + tmp170 = tmp174 + } else { + tmp175 := lang.Apply(v8, []any{v130, v141, v168}) + tmp170 = tmp175 + } + var tmp169 any = tmp170 + tmp177 := checkDerefVar(var_glojure_DOT_core_next) + tmp178 := lang.Apply(tmp177, []any{v132}) + var tmp176 any = tmp178 + v130 = tmp169 + v132 = tmp176 + continue + } // end let + tmp133 = tmp136 + } else { + tmp133 = v130 + } + tmp33 = tmp133 + break + } + } // end let + tmp21 = tmp33 + } // end let + return tmp21 + }) + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4440), kw_column, int(20), kw_end_DASH_line, int(4485), kw_end_DASH_column, int(34)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v20 any = tmp19 + _ = v20 + var tmp21 any + tmp22 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp23 := lang.Apply(tmp22, []any{v10}) + if lang.IsTruthy(tmp23) { + tmp24 := checkDerefVar(var_glojure_DOT_core_conj) + tmp25 := checkDerefVar(var_glojure_DOT_core_conj) + tmp26 := lang.Apply(tmp25, []any{v9, v10}) + tmp27 := lang.Apply(tmp24, []any{tmp26, v11}) + tmp21 = tmp27 + } else { + var tmp28 any + tmp29 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp30 := lang.Apply(tmp29, []any{v10}) + if lang.IsTruthy(tmp30) { + tmp31 := lang.Apply(v16, []any{v9, v10, v11}) + tmp28 = tmp31 + } else { + var tmp32 any + tmp33 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp34 := lang.Apply(tmp33, []any{v10}) + if lang.IsTruthy(tmp34) { + tmp35 := lang.Apply(v20, []any{v9, v10, v11}) + tmp32 = tmp35 + } else { + var tmp36 any + if lang.IsTruthy(kw_else) { + tmp37 := checkDerefVar(var_glojure_DOT_core_str) + tmp38 := lang.Apply(tmp37, []any{"Unsupported binding form: ", v10}) + tmp39 := lang.Apply(errors5.New, []any{tmp38}) + panic(tmp39) + } else { + } + tmp32 = tmp36 + } + tmp28 = tmp32 + } + tmp21 = tmp28 + } + tmp12 = tmp21 + } // end let + return tmp12 + }) + v8 = tmp7 + _ = v8 + } + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4402), kw_column, int(12), kw_end_DASH_line, int(4490), kw_end_DASH_column, int(82)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v10 any = tmp9 + _ = v10 + // let binding "process-entry" + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v12 := args[0] + _ = v12 + v13 := args[1] + _ = v13 + tmp14 := checkDerefVar(var_glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v13}) + tmp16 := checkDerefVar(var_glojure_DOT_core_second) + tmp17 := lang.Apply(tmp16, []any{v13}) + tmp18 := lang.Apply(v10, []any{v12, tmp15, tmp17}) + return tmp18 + }) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4491), kw_column, int(23), kw_end_DASH_line, int(4491), kw_end_DASH_column, int(66)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v14 any = tmp13 + _ = v14 + var tmp15 any + tmp16 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + tmp17 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp18 := checkDerefVar(var_glojure_DOT_core_map) + tmp19 := checkDerefVar(var_glojure_DOT_core_first) + tmp20 := lang.Apply(tmp18, []any{tmp19, v6}) + tmp21 := lang.Apply(tmp16, []any{tmp17, tmp20}) + if lang.IsTruthy(tmp21) { + tmp15 = v2 + } else { + tmp22 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp23 := lang.NewVector() + tmp24 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4494), kw_column, int(30), kw_end_DASH_line, int(4494), kw_end_DASH_column, int(31)) + tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp26 := lang.Apply(tmp22, []any{v14, tmp25, v6}) + tmp15 = tmp26 + } + tmp3 = tmp15 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_destructure = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_destructure.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // extend + { + tmp0 := sym_extend.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_atype, sym__AMP_, sym_proto_PLUS_mmaps)), kw_doc, "Implementations of protocol methods can be provided using the extend construct:\n\n (extend AType\n AProtocol\n {:foo an-existing-fn\n :bar (fn [a b] ...)\n :baz (fn ([a]...) ([a b] ...)...)}\n BProtocol \n {...} \n ...)\n \n extend takes a type/class (or interface, see below), and one or more\n protocol + method map pairs. It will extend the polymorphism of the\n protocol's methods to call the supplied methods when an AType is\n provided as the first argument. \n\n Method maps are maps of the keyword-ized method names to ordinary\n fns. This facilitates easy reuse of existing fns and fn maps, for\n code reuse/mixins without derivation or composition. You can extend\n an interface to a protocol. This is primarily to facilitate interop\n with the host (e.g. Java) but opens the door to incidental multiple\n inheritance of implementation since a class can inherit from more\n than one interface, both of which extend the protocol. It is TBD how\n to specify which impl to use. You can extend a protocol on nil.\n\n If you are supplying the definitions explicitly (i.e. not reusing\n exsting functions or mixin maps), you may find it more convenient to\n use the extend-type or extend-protocol macros.\n\n Note that multiple independent extend clauses can exist for the same\n type, not all protocols need be defined in a single extend call.\n\n See also:\n extends?, satisfies?, extenders", kw_file, "glojure/core_deftype.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(116), kw_end_DASH_line, int(116))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + var tmp4 any + { // let + // let binding "seq_627" + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := checkDerefVar(var_glojure_DOT_core_partition) + tmp7 := lang.Apply(tmp6, []any{int64(2), v3}) + tmp8 := lang.Apply(tmp5, []any{tmp7}) + var v9 any = tmp8 + _ = v9 + // let binding "chunk_628" + var v10 any = nil + _ = v10 + // let binding "count_629" + var v11 any = int64(0) + _ = v11 + // let binding "i_630" + var v12 any = int64(0) + _ = v12 + for { + var tmp13 any + tmp14 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp15 := lang.Apply(tmp14, []any{v12, v11}) + if lang.IsTruthy(tmp15) { + var tmp16 any + { // let + // let binding "vec__631" + tmp17, _ := lang.FieldOrMethod(v10, "nth") + if reflect.TypeOf(tmp17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp18 := lang.Apply(tmp17, []any{v12}) + var v19 any = tmp18 + _ = v19 + // let binding "proto" + tmp20 := checkDerefVar(var_glojure_DOT_core_nth) + tmp21 := lang.Apply(tmp20, []any{v19, int64(0), nil}) + var v22 any = tmp21 + _ = v22 + // let binding "mmap" + tmp23 := checkDerefVar(var_glojure_DOT_core_nth) + tmp24 := lang.Apply(tmp23, []any{v19, int64(1), nil}) + var v25 any = tmp24 + _ = v25 + var tmp26 any + tmp27 := checkDerefVar(var_glojure_DOT_core_protocol_QMARK_) + tmp28 := lang.Apply(tmp27, []any{v22}) + if lang.IsTruthy(tmp28) { + } else { + tmp29 := checkDerefVar(var_glojure_DOT_core_str) + tmp30 := lang.Apply(tmp29, []any{v22, " is not a protocol"}) + tmp31 := lang.Apply(errors5.New, []any{tmp30}) + panic(tmp31) + } + _ = tmp26 + tmp32 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp33 lang.FnFunc + tmp33 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v34 := args[0] + _ = v34 + v35 := args[1] + _ = v35 + var tmp36 any + { // let + // let binding "vec__635" + var v37 any = v35 + _ = v37 + // let binding "k" + tmp38 := checkDerefVar(var_glojure_DOT_core_nth) + tmp39 := lang.Apply(tmp38, []any{v37, int64(0), nil}) + var v40 any = tmp39 + _ = v40 + // let binding "v" + tmp41 := checkDerefVar(var_glojure_DOT_core_nth) + tmp42 := lang.Apply(tmp41, []any{v37, int64(1), nil}) + var v43 any = tmp42 + _ = v43 + tmp44 := checkDerefVar(var_glojure_DOT_core_get_DASH_in) + tmp45 := checkDerefVar(var_glojure_DOT_core_deref) + tmp46 := lang.Apply(tmp45, []any{v22}) + tmp47 := lang.NewVector(kw_multis, v40) + tmp48 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(158), kw_column, int(33), kw_end_DASH_line, int(158), kw_end_DASH_column, int(43)) + tmp49, err := lang.WithMeta(tmp47, tmp48.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp50 := lang.Apply(tmp44, []any{tmp46, tmp49}) + var tmp51 lang.FnFunc + tmp51 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v52 := args[0] + _ = v52 + var v53 any = lang.NewList(args[1:]...) + _ = v53 + tmp54 := checkDerefVar(var_glojure_DOT_core_apply) + tmp55 := checkDerefVar(var_glojure_DOT_core_cons) + tmp56 := lang.Apply(tmp55, []any{v52, v53}) + tmp57 := lang.Apply(tmp54, []any{v43, tmp56}) + return tmp57 + } + }) + tmp52, _ := lang.FieldOrMethod(tmp50, "AddMethod") + if reflect.TypeOf(tmp52).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("AddMethod is not a function"))) + } + tmp53 := lang.Apply(tmp52, []any{v2, tmp51}) + tmp36 = tmp53 + } // end let + return tmp36 + }) + tmp34 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(156), kw_column, int(14), kw_end_DASH_line, int(160), kw_end_DASH_column, int(45)) + tmp35, err := lang.WithMeta(tmp33, tmp34.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp36 := lang.Apply(tmp32, []any{tmp35, nil, v25}) + _ = tmp36 + var tmp37 any = v9 + var tmp38 any = v10 + var tmp39 any = v11 + tmp41 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp42 := lang.Apply(tmp41, []any{v12}) + var tmp40 any = tmp42 + v9 = tmp37 + v10 = tmp38 + v11 = tmp39 + v12 = tmp40 + continue + } // end let + tmp13 = tmp16 + } else { + var tmp17 any + { // let + // let binding "temp__0__auto__" + tmp18 := checkDerefVar(var_glojure_DOT_core_seq) + tmp19 := lang.Apply(tmp18, []any{v9}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + var tmp22 any + { // let + // let binding "seq_627" + var v23 any = v20 + _ = v23 + var tmp24 any + tmp25 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp26 := lang.Apply(tmp25, []any{v23}) + if lang.IsTruthy(tmp26) { + var tmp27 any + { // let + // let binding "c__0__auto__" + tmp28 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp29 := lang.Apply(tmp28, []any{v23}) + var v30 any = tmp29 + _ = v30 + tmp32 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp33 := lang.Apply(tmp32, []any{v23}) + var tmp31 any = tmp33 + var tmp34 any = v30 + tmp36 := checkDerefVar(var_glojure_DOT_core_int) + tmp37 := checkDerefVar(var_glojure_DOT_core_count) + tmp38 := lang.Apply(tmp37, []any{v30}) + tmp39 := lang.Apply(tmp36, []any{tmp38}) + var tmp35 any = tmp39 + tmp41 := checkDerefVar(var_glojure_DOT_core_int) + tmp42 := lang.Apply(tmp41, []any{int64(0)}) + var tmp40 any = tmp42 + v9 = tmp31 + v10 = tmp34 + v11 = tmp35 + v12 = tmp40 + continue + } // end let + tmp24 = tmp27 + } else { + var tmp28 any + { // let + // let binding "vec__638" + tmp29 := checkDerefVar(var_glojure_DOT_core_first) + tmp30 := lang.Apply(tmp29, []any{v23}) + var v31 any = tmp30 + _ = v31 + // let binding "proto" + tmp32 := checkDerefVar(var_glojure_DOT_core_nth) + tmp33 := lang.Apply(tmp32, []any{v31, int64(0), nil}) + var v34 any = tmp33 + _ = v34 + // let binding "mmap" + tmp35 := checkDerefVar(var_glojure_DOT_core_nth) + tmp36 := lang.Apply(tmp35, []any{v31, int64(1), nil}) + var v37 any = tmp36 + _ = v37 + var tmp38 any + tmp39 := checkDerefVar(var_glojure_DOT_core_protocol_QMARK_) + tmp40 := lang.Apply(tmp39, []any{v34}) + if lang.IsTruthy(tmp40) { + } else { + tmp41 := checkDerefVar(var_glojure_DOT_core_str) + tmp42 := lang.Apply(tmp41, []any{v34, " is not a protocol"}) + tmp43 := lang.Apply(errors5.New, []any{tmp42}) + panic(tmp43) + } + _ = tmp38 + tmp44 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp45 lang.FnFunc + tmp45 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v46 := args[0] + _ = v46 + v47 := args[1] + _ = v47 + var tmp48 any + { // let + // let binding "vec__642" + var v49 any = v47 + _ = v49 + // let binding "k" + tmp50 := checkDerefVar(var_glojure_DOT_core_nth) + tmp51 := lang.Apply(tmp50, []any{v49, int64(0), nil}) + var v52 any = tmp51 + _ = v52 + // let binding "v" + tmp53 := checkDerefVar(var_glojure_DOT_core_nth) + tmp54 := lang.Apply(tmp53, []any{v49, int64(1), nil}) + var v55 any = tmp54 + _ = v55 + tmp56 := checkDerefVar(var_glojure_DOT_core_get_DASH_in) + tmp57 := checkDerefVar(var_glojure_DOT_core_deref) + tmp58 := lang.Apply(tmp57, []any{v34}) + tmp59 := lang.NewVector(kw_multis, v52) + tmp60 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(158), kw_column, int(33), kw_end_DASH_line, int(158), kw_end_DASH_column, int(43)) + tmp61, err := lang.WithMeta(tmp59, tmp60.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp62 := lang.Apply(tmp56, []any{tmp58, tmp61}) + var tmp63 lang.FnFunc + tmp63 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v64 := args[0] + _ = v64 + var v65 any = lang.NewList(args[1:]...) + _ = v65 + tmp66 := checkDerefVar(var_glojure_DOT_core_apply) + tmp67 := checkDerefVar(var_glojure_DOT_core_cons) + tmp68 := lang.Apply(tmp67, []any{v64, v65}) + tmp69 := lang.Apply(tmp66, []any{v55, tmp68}) + return tmp69 + } + }) + tmp64, _ := lang.FieldOrMethod(tmp62, "AddMethod") + if reflect.TypeOf(tmp64).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("AddMethod is not a function"))) + } + tmp65 := lang.Apply(tmp64, []any{v2, tmp63}) + tmp48 = tmp65 + } // end let + return tmp48 + }) + tmp46 := lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(156), kw_column, int(14), kw_end_DASH_line, int(160), kw_end_DASH_column, int(45)) + tmp47, err := lang.WithMeta(tmp45, tmp46.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp48 := lang.Apply(tmp44, []any{tmp47, nil, v37}) + _ = tmp48 + tmp50 := checkDerefVar(var_glojure_DOT_core_next) + tmp51 := lang.Apply(tmp50, []any{v23}) + var tmp49 any = tmp51 + var tmp52 any = nil + var tmp53 any = int64(0) + var tmp54 any = int64(0) + v9 = tmp49 + v10 = tmp52 + v11 = tmp53 + v12 = tmp54 + continue + } // end let + tmp24 = tmp28 + } + tmp22 = tmp24 + } // end let + tmp21 = tmp22 + } else { + } + tmp17 = tmp21 + } // end let + tmp13 = tmp17 + } + tmp4 = tmp13 + break + } + } // end let + return tmp4 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_extend = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_extend.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // for + { + tmp0 := sym_for.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_seq_DASH_exprs, sym_body_DASH_expr)), kw_doc, "List comprehension. Takes a vector of one or more\n binding-form/collection-expr pairs, each followed by zero or more\n modifiers, and yields a lazy sequence of evaluations of expr.\n Collections are iterated in a nested fashion, rightmost fastest,\n and nested coll-exprs can refer to bindings created in prior\n binding-forms. Supported modifiers are: :let [binding-form expr ...],\n :while test, :when test.\n\n (take 100 (for [x (range 100000000) y (range 1000000) :while (< y x)] [x y]))", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(11), kw_line, int(4646), kw_end_DASH_line, int(4646))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v4}) + if lang.IsTruthy(tmp8) { + } else { + tmp9 := checkDerefVar(var_glojure_DOT_core_str) + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp13 := checkDerefVar(var_glojure_DOT_core_meta) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(kw_line, []any{tmp14}) + tmp16 := lang.Apply(tmp9, []any{tmp11, " requires ", "a vector for its binding", " in ", tmp12, ":", tmp15}) + tmp17 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp16}) + panic(tmp17) + } + _ = tmp6 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_even_QMARK_) + tmp20 := checkDerefVar(var_glojure_DOT_core_count) + tmp21 := lang.Apply(tmp20, []any{v4}) + tmp22 := lang.Apply(tmp19, []any{tmp21}) + if lang.IsTruthy(tmp22) { + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp27 := checkDerefVar(var_glojure_DOT_core_meta) + tmp28 := lang.Apply(tmp27, []any{v2}) + tmp29 := lang.Apply(kw_line, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp25, " requires ", "an even number of forms in binding vector", " in ", tmp26, ":", tmp29}) + tmp31 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp31) + } + _ = tmp18 + var tmp32 any + { // let + // let binding "to-groups" + var tmp33 lang.FnFunc + tmp33 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v34 := args[0] + _ = v34 + tmp35 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp36 lang.FnFunc + tmp36 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v37 := args[0] + _ = v37 + v38 := args[1] + _ = v38 + var tmp39 any + { // let + // let binding "vec__715" + var v40 any = v38 + _ = v40 + // let binding "k" + tmp41 := checkDerefVar(var_glojure_DOT_core_nth) + tmp42 := lang.Apply(tmp41, []any{v40, int64(0), nil}) + var v43 any = tmp42 + _ = v43 + // let binding "v" + tmp44 := checkDerefVar(var_glojure_DOT_core_nth) + tmp45 := lang.Apply(tmp44, []any{v40, int64(1), nil}) + var v46 any = tmp45 + _ = v46 + var tmp47 any + tmp48 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp49 := lang.Apply(tmp48, []any{v43}) + if lang.IsTruthy(tmp49) { + tmp50 := checkDerefVar(var_glojure_DOT_core_conj) + tmp51 := checkDerefVar(var_glojure_DOT_core_pop) + tmp52 := lang.Apply(tmp51, []any{v37}) + tmp53 := checkDerefVar(var_glojure_DOT_core_conj) + tmp54 := checkDerefVar(var_glojure_DOT_core_peek) + tmp55 := lang.Apply(tmp54, []any{v37}) + tmp56 := lang.NewVector(v43, v46) + tmp57 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4664), kw_column, int(72), kw_end_DASH_line, int(4664), kw_end_DASH_column, int(76)) + tmp58, err := lang.WithMeta(tmp56, tmp57.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp59 := lang.Apply(tmp53, []any{tmp55, tmp58}) + tmp60 := lang.Apply(tmp50, []any{tmp52, tmp59}) + tmp47 = tmp60 + } else { + tmp61 := checkDerefVar(var_glojure_DOT_core_conj) + tmp62 := lang.NewVector(v43, v46) + tmp63 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4665), kw_column, int(46), kw_end_DASH_line, int(4665), kw_end_DASH_column, int(50)) + tmp64, err := lang.WithMeta(tmp62, tmp63.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp65 := lang.Apply(tmp61, []any{v37, tmp64}) + tmp47 = tmp65 + } + tmp39 = tmp47 + } // end let + return tmp39 + }) + tmp37 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4662), kw_column, int(30), kw_end_DASH_line, int(4665), kw_end_DASH_column, int(53)) + tmp38, err := lang.WithMeta(tmp36, tmp37.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp39 := lang.NewVector() + tmp40 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4666), kw_column, int(29), kw_end_DASH_line, int(4666), kw_end_DASH_column, int(30)) + tmp41, err := lang.WithMeta(tmp39, tmp40.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp42 := checkDerefVar(var_glojure_DOT_core_partition) + tmp43 := lang.Apply(tmp42, []any{int64(2), v34}) + tmp44 := lang.Apply(tmp35, []any{tmp38, tmp41, tmp43}) + return tmp44 + }) + tmp34 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4661), kw_column, int(19), kw_end_DASH_line, int(4666), kw_end_DASH_column, int(56)) + tmp35, err := lang.WithMeta(tmp33, tmp34.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v36 any = tmp35 + _ = v36 + // let binding "err" + var tmp37 lang.FnFunc + tmp37 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v38 any = lang.NewList(args[0:]...) + _ = v38 + tmp39 := checkDerefVar(var_glojure_DOT_core_apply) + tmp40 := checkDerefVar(var_glojure_DOT_core_str) + tmp41 := lang.Apply(tmp39, []any{tmp40, v38}) + tmp42 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp41}) + panic(tmp42) + } + }) + tmp38 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4667), kw_column, int(13), kw_end_DASH_line, int(4667), kw_end_DASH_column, int(125)) + tmp39, err := lang.WithMeta(tmp37, tmp38.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v40 any = tmp39 + _ = v40 + // let binding "emit-bind" + var tmp41 lang.FnFunc + { // function emit-bind + var v42 lang.FnFunc + tmp41 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v43 := args[0] + _ = v43 + var tmp44 any + { // let + // let binding "vec__719" + var v45 any = v43 + _ = v45 + // let binding "seq__720" + tmp46 := checkDerefVar(var_glojure_DOT_core_seq) + tmp47 := lang.Apply(tmp46, []any{v45}) + var v48 any = tmp47 + _ = v48 + // let binding "first__721" + tmp49 := checkDerefVar(var_glojure_DOT_core_first) + tmp50 := lang.Apply(tmp49, []any{v48}) + var v51 any = tmp50 + _ = v51 + // let binding "seq__720" + tmp52 := checkDerefVar(var_glojure_DOT_core_next) + tmp53 := lang.Apply(tmp52, []any{v48}) + var v54 any = tmp53 + _ = v54 + // let binding "vec__722" + var v55 any = v51 + _ = v55 + // let binding "seq__723" + tmp56 := checkDerefVar(var_glojure_DOT_core_seq) + tmp57 := lang.Apply(tmp56, []any{v55}) + var v58 any = tmp57 + _ = v58 + // let binding "first__724" + tmp59 := checkDerefVar(var_glojure_DOT_core_first) + tmp60 := lang.Apply(tmp59, []any{v58}) + var v61 any = tmp60 + _ = v61 + // let binding "seq__723" + tmp62 := checkDerefVar(var_glojure_DOT_core_next) + tmp63 := lang.Apply(tmp62, []any{v58}) + var v64 any = tmp63 + _ = v64 + // let binding "bind" + var v65 any = v61 + _ = v65 + // let binding "first__724" + tmp66 := checkDerefVar(var_glojure_DOT_core_first) + tmp67 := lang.Apply(tmp66, []any{v64}) + var v68 any = tmp67 + _ = v68 + // let binding "seq__723" + tmp69 := checkDerefVar(var_glojure_DOT_core_next) + tmp70 := lang.Apply(tmp69, []any{v64}) + var v71 any = tmp70 + _ = v71 + // let binding "expr" + var v72 any = v68 + _ = v72 + // let binding "mod-pairs" + var v73 any = v71 + _ = v73 + // let binding "vec__725" + var v74 any = v54 + _ = v74 + // let binding "vec__728" + tmp75 := checkDerefVar(var_glojure_DOT_core_nth) + tmp76 := lang.Apply(tmp75, []any{v74, int64(0), nil}) + var v77 any = tmp76 + _ = v77 + // let binding "_" + tmp78 := checkDerefVar(var_glojure_DOT_core_nth) + tmp79 := lang.Apply(tmp78, []any{v77, int64(0), nil}) + var v80 any = tmp79 + _ = v80 + // let binding "next-expr" + tmp81 := checkDerefVar(var_glojure_DOT_core_nth) + tmp82 := lang.Apply(tmp81, []any{v77, int64(1), nil}) + var v83 any = tmp82 + _ = v83 + // let binding "next-groups" + var v84 any = v74 + _ = v84 + var tmp85 any + { // let + // let binding "giter" + tmp86 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp87 := lang.Apply(tmp86, []any{"iter__"}) + var v88 any = tmp87 + _ = v88 + // let binding "gxs" + tmp89 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp90 := lang.Apply(tmp89, []any{"s__"}) + var v91 any = tmp90 + _ = v91 + // let binding "do-mod" + var tmp92 lang.FnFunc + { // function do-mod + var v93 lang.FnFunc + tmp92 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v94 := args[0] + _ = v94 + var tmp95 any + { // let + // let binding "vec__732" + var v96 any = v94 + _ = v96 + // let binding "seq__733" + tmp97 := checkDerefVar(var_glojure_DOT_core_seq) + tmp98 := lang.Apply(tmp97, []any{v96}) + var v99 any = tmp98 + _ = v99 + // let binding "first__734" + tmp100 := checkDerefVar(var_glojure_DOT_core_first) + tmp101 := lang.Apply(tmp100, []any{v99}) + var v102 any = tmp101 + _ = v102 + // let binding "seq__733" + tmp103 := checkDerefVar(var_glojure_DOT_core_next) + tmp104 := lang.Apply(tmp103, []any{v99}) + var v105 any = tmp104 + _ = v105 + // let binding "vec__735" + var v106 any = v102 + _ = v106 + // let binding "k" + tmp107 := checkDerefVar(var_glojure_DOT_core_nth) + tmp108 := lang.Apply(tmp107, []any{v106, int64(0), nil}) + var v109 any = tmp108 + _ = v109 + // let binding "v" + tmp110 := checkDerefVar(var_glojure_DOT_core_nth) + tmp111 := lang.Apply(tmp110, []any{v106, int64(1), nil}) + var v112 any = tmp111 + _ = v112 + // let binding "pair" + var v113 any = v106 + _ = v113 + // let binding "etc" + var v114 any = v105 + _ = v114 + var tmp115 any + tmp116 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp117 := lang.Apply(tmp116, []any{v109, kw_let}) + if lang.IsTruthy(tmp117) { + tmp118 := checkDerefVar(var_glojure_DOT_core_seq) + tmp119 := checkDerefVar(var_glojure_DOT_core_concat) + tmp120 := checkDerefVar(var_glojure_DOT_core_list) + tmp121 := lang.Apply(tmp120, []any{sym_glojure_DOT_core_SLASH_let}) + tmp122 := checkDerefVar(var_glojure_DOT_core_list) + tmp123 := lang.Apply(tmp122, []any{v112}) + tmp124 := checkDerefVar(var_glojure_DOT_core_list) + tmp125 := lang.Apply(v93, []any{v114}) + tmp126 := lang.Apply(tmp124, []any{tmp125}) + tmp127 := lang.Apply(tmp119, []any{tmp121, tmp123, tmp126}) + tmp128 := lang.Apply(tmp118, []any{tmp127}) + tmp115 = tmp128 + } else { + var tmp129 any + tmp130 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp131 := lang.Apply(tmp130, []any{v109, kw_while}) + if lang.IsTruthy(tmp131) { + tmp132 := checkDerefVar(var_glojure_DOT_core_seq) + tmp133 := checkDerefVar(var_glojure_DOT_core_concat) + tmp134 := checkDerefVar(var_glojure_DOT_core_list) + tmp135 := lang.Apply(tmp134, []any{sym_glojure_DOT_core_SLASH_when}) + tmp136 := checkDerefVar(var_glojure_DOT_core_list) + tmp137 := lang.Apply(tmp136, []any{v112}) + tmp138 := checkDerefVar(var_glojure_DOT_core_list) + tmp139 := lang.Apply(v93, []any{v114}) + tmp140 := lang.Apply(tmp138, []any{tmp139}) + tmp141 := lang.Apply(tmp133, []any{tmp135, tmp137, tmp140}) + tmp142 := lang.Apply(tmp132, []any{tmp141}) + tmp129 = tmp142 + } else { + var tmp143 any + tmp144 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp145 := lang.Apply(tmp144, []any{v109, kw_when}) + if lang.IsTruthy(tmp145) { + tmp146 := checkDerefVar(var_glojure_DOT_core_seq) + tmp147 := checkDerefVar(var_glojure_DOT_core_concat) + tmp148 := checkDerefVar(var_glojure_DOT_core_list) + tmp149 := lang.Apply(tmp148, []any{sym_if}) + tmp150 := checkDerefVar(var_glojure_DOT_core_list) + tmp151 := lang.Apply(tmp150, []any{v112}) + tmp152 := checkDerefVar(var_glojure_DOT_core_list) + tmp153 := lang.Apply(v93, []any{v114}) + tmp154 := lang.Apply(tmp152, []any{tmp153}) + tmp155 := checkDerefVar(var_glojure_DOT_core_list) + tmp156 := checkDerefVar(var_glojure_DOT_core_seq) + tmp157 := checkDerefVar(var_glojure_DOT_core_concat) + tmp158 := checkDerefVar(var_glojure_DOT_core_list) + tmp159 := lang.Apply(tmp158, []any{sym_recur}) + tmp160 := checkDerefVar(var_glojure_DOT_core_list) + tmp161 := checkDerefVar(var_glojure_DOT_core_seq) + tmp162 := checkDerefVar(var_glojure_DOT_core_concat) + tmp163 := checkDerefVar(var_glojure_DOT_core_list) + tmp164 := lang.Apply(tmp163, []any{sym_glojure_DOT_core_SLASH_rest}) + tmp165 := checkDerefVar(var_glojure_DOT_core_list) + tmp166 := lang.Apply(tmp165, []any{v91}) + tmp167 := lang.Apply(tmp162, []any{tmp164, tmp166}) + tmp168 := lang.Apply(tmp161, []any{tmp167}) + tmp169 := lang.Apply(tmp160, []any{tmp168}) + tmp170 := lang.Apply(tmp157, []any{tmp159, tmp169}) + tmp171 := lang.Apply(tmp156, []any{tmp170}) + tmp172 := lang.Apply(tmp155, []any{tmp171}) + tmp173 := lang.Apply(tmp147, []any{tmp149, tmp151, tmp154, tmp172}) + tmp174 := lang.Apply(tmp146, []any{tmp173}) + tmp143 = tmp174 + } else { + var tmp175 any + tmp176 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp177 := lang.Apply(tmp176, []any{v109}) + if lang.IsTruthy(tmp177) { + tmp178 := lang.Apply(v40, []any{"Invalid 'for' keyword ", v109}) + tmp175 = tmp178 + } else { + var tmp179 any + if lang.IsTruthy(v84) { + tmp180 := checkDerefVar(var_glojure_DOT_core_seq) + tmp181 := checkDerefVar(var_glojure_DOT_core_concat) + tmp182 := checkDerefVar(var_glojure_DOT_core_list) + tmp183 := lang.Apply(tmp182, []any{sym_glojure_DOT_core_SLASH_let}) + tmp184 := checkDerefVar(var_glojure_DOT_core_list) + tmp185 := checkDerefVar(var_glojure_DOT_core_apply) + tmp186 := checkDerefVar(var_glojure_DOT_core_vector) + tmp187 := checkDerefVar(var_glojure_DOT_core_seq) + tmp188 := checkDerefVar(var_glojure_DOT_core_concat) + tmp189 := checkDerefVar(var_glojure_DOT_core_list) + tmp190 := lang.Apply(tmp189, []any{sym_iterys__0__auto__}) + tmp191 := checkDerefVar(var_glojure_DOT_core_list) + tmp192 := lang.Apply(v42, []any{v84}) + tmp193 := lang.Apply(tmp191, []any{tmp192}) + tmp194 := checkDerefVar(var_glojure_DOT_core_list) + tmp195 := lang.Apply(tmp194, []any{sym_fs__1__auto__}) + tmp196 := checkDerefVar(var_glojure_DOT_core_list) + tmp197 := checkDerefVar(var_glojure_DOT_core_seq) + tmp198 := checkDerefVar(var_glojure_DOT_core_concat) + tmp199 := checkDerefVar(var_glojure_DOT_core_list) + tmp200 := lang.Apply(tmp199, []any{sym_glojure_DOT_core_SLASH_seq}) + tmp201 := checkDerefVar(var_glojure_DOT_core_list) + tmp202 := checkDerefVar(var_glojure_DOT_core_seq) + tmp203 := checkDerefVar(var_glojure_DOT_core_concat) + tmp204 := checkDerefVar(var_glojure_DOT_core_list) + tmp205 := lang.Apply(tmp204, []any{sym_iterys__0__auto__}) + tmp206 := checkDerefVar(var_glojure_DOT_core_list) + tmp207 := lang.Apply(tmp206, []any{v83}) + tmp208 := lang.Apply(tmp203, []any{tmp205, tmp207}) + tmp209 := lang.Apply(tmp202, []any{tmp208}) + tmp210 := lang.Apply(tmp201, []any{tmp209}) + tmp211 := lang.Apply(tmp198, []any{tmp200, tmp210}) + tmp212 := lang.Apply(tmp197, []any{tmp211}) + tmp213 := lang.Apply(tmp196, []any{tmp212}) + tmp214 := lang.Apply(tmp188, []any{tmp190, tmp193, tmp195, tmp213}) + tmp215 := lang.Apply(tmp187, []any{tmp214}) + tmp216 := lang.Apply(tmp185, []any{tmp186, tmp215}) + tmp217 := lang.Apply(tmp184, []any{tmp216}) + tmp218 := checkDerefVar(var_glojure_DOT_core_list) + tmp219 := checkDerefVar(var_glojure_DOT_core_seq) + tmp220 := checkDerefVar(var_glojure_DOT_core_concat) + tmp221 := checkDerefVar(var_glojure_DOT_core_list) + tmp222 := lang.Apply(tmp221, []any{sym_if}) + tmp223 := checkDerefVar(var_glojure_DOT_core_list) + tmp224 := lang.Apply(tmp223, []any{sym_fs__1__auto__}) + tmp225 := checkDerefVar(var_glojure_DOT_core_list) + tmp226 := checkDerefVar(var_glojure_DOT_core_seq) + tmp227 := checkDerefVar(var_glojure_DOT_core_concat) + tmp228 := checkDerefVar(var_glojure_DOT_core_list) + tmp229 := lang.Apply(tmp228, []any{sym_glojure_DOT_core_SLASH_concat}) + tmp230 := checkDerefVar(var_glojure_DOT_core_list) + tmp231 := lang.Apply(tmp230, []any{sym_fs__1__auto__}) + tmp232 := checkDerefVar(var_glojure_DOT_core_list) + tmp233 := checkDerefVar(var_glojure_DOT_core_seq) + tmp234 := checkDerefVar(var_glojure_DOT_core_concat) + tmp235 := checkDerefVar(var_glojure_DOT_core_list) + tmp236 := lang.Apply(tmp235, []any{v88}) + tmp237 := checkDerefVar(var_glojure_DOT_core_list) + tmp238 := checkDerefVar(var_glojure_DOT_core_seq) + tmp239 := checkDerefVar(var_glojure_DOT_core_concat) + tmp240 := checkDerefVar(var_glojure_DOT_core_list) + tmp241 := lang.Apply(tmp240, []any{sym_glojure_DOT_core_SLASH_rest}) + tmp242 := checkDerefVar(var_glojure_DOT_core_list) + tmp243 := lang.Apply(tmp242, []any{v91}) + tmp244 := lang.Apply(tmp239, []any{tmp241, tmp243}) + tmp245 := lang.Apply(tmp238, []any{tmp244}) + tmp246 := lang.Apply(tmp237, []any{tmp245}) + tmp247 := lang.Apply(tmp234, []any{tmp236, tmp246}) + tmp248 := lang.Apply(tmp233, []any{tmp247}) + tmp249 := lang.Apply(tmp232, []any{tmp248}) + tmp250 := lang.Apply(tmp227, []any{tmp229, tmp231, tmp249}) + tmp251 := lang.Apply(tmp226, []any{tmp250}) + tmp252 := lang.Apply(tmp225, []any{tmp251}) + tmp253 := checkDerefVar(var_glojure_DOT_core_list) + tmp254 := checkDerefVar(var_glojure_DOT_core_seq) + tmp255 := checkDerefVar(var_glojure_DOT_core_concat) + tmp256 := checkDerefVar(var_glojure_DOT_core_list) + tmp257 := lang.Apply(tmp256, []any{sym_recur}) + tmp258 := checkDerefVar(var_glojure_DOT_core_list) + tmp259 := checkDerefVar(var_glojure_DOT_core_seq) + tmp260 := checkDerefVar(var_glojure_DOT_core_concat) + tmp261 := checkDerefVar(var_glojure_DOT_core_list) + tmp262 := lang.Apply(tmp261, []any{sym_glojure_DOT_core_SLASH_rest}) + tmp263 := checkDerefVar(var_glojure_DOT_core_list) + tmp264 := lang.Apply(tmp263, []any{v91}) + tmp265 := lang.Apply(tmp260, []any{tmp262, tmp264}) + tmp266 := lang.Apply(tmp259, []any{tmp265}) + tmp267 := lang.Apply(tmp258, []any{tmp266}) + tmp268 := lang.Apply(tmp255, []any{tmp257, tmp267}) + tmp269 := lang.Apply(tmp254, []any{tmp268}) + tmp270 := lang.Apply(tmp253, []any{tmp269}) + tmp271 := lang.Apply(tmp220, []any{tmp222, tmp224, tmp252, tmp270}) + tmp272 := lang.Apply(tmp219, []any{tmp271}) + tmp273 := lang.Apply(tmp218, []any{tmp272}) + tmp274 := lang.Apply(tmp181, []any{tmp183, tmp217, tmp273}) + tmp275 := lang.Apply(tmp180, []any{tmp274}) + tmp179 = tmp275 + } else { + var tmp276 any + if lang.IsTruthy(kw_else) { + tmp277 := checkDerefVar(var_glojure_DOT_core_seq) + tmp278 := checkDerefVar(var_glojure_DOT_core_concat) + tmp279 := checkDerefVar(var_glojure_DOT_core_list) + tmp280 := lang.Apply(tmp279, []any{sym_glojure_DOT_core_SLASH_cons}) + tmp281 := checkDerefVar(var_glojure_DOT_core_list) + tmp282 := lang.Apply(tmp281, []any{v5}) + tmp283 := checkDerefVar(var_glojure_DOT_core_list) + tmp284 := checkDerefVar(var_glojure_DOT_core_seq) + tmp285 := checkDerefVar(var_glojure_DOT_core_concat) + tmp286 := checkDerefVar(var_glojure_DOT_core_list) + tmp287 := lang.Apply(tmp286, []any{v88}) + tmp288 := checkDerefVar(var_glojure_DOT_core_list) + tmp289 := checkDerefVar(var_glojure_DOT_core_seq) + tmp290 := checkDerefVar(var_glojure_DOT_core_concat) + tmp291 := checkDerefVar(var_glojure_DOT_core_list) + tmp292 := lang.Apply(tmp291, []any{sym_glojure_DOT_core_SLASH_rest}) + tmp293 := checkDerefVar(var_glojure_DOT_core_list) + tmp294 := lang.Apply(tmp293, []any{v91}) + tmp295 := lang.Apply(tmp290, []any{tmp292, tmp294}) + tmp296 := lang.Apply(tmp289, []any{tmp295}) + tmp297 := lang.Apply(tmp288, []any{tmp296}) + tmp298 := lang.Apply(tmp285, []any{tmp287, tmp297}) + tmp299 := lang.Apply(tmp284, []any{tmp298}) + tmp300 := lang.Apply(tmp283, []any{tmp299}) + tmp301 := lang.Apply(tmp278, []any{tmp280, tmp282, tmp300}) + tmp302 := lang.Apply(tmp277, []any{tmp301}) + tmp276 = tmp302 + } else { + } + tmp179 = tmp276 + } + tmp175 = tmp179 + } + tmp143 = tmp175 + } + tmp129 = tmp143 + } + tmp115 = tmp129 + } + tmp95 = tmp115 + } // end let + return tmp95 + }) + v93 = tmp92 + _ = v93 + } + tmp93 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4672), kw_column, int(34), kw_end_DASH_line, int(4687), kw_end_DASH_column, int(73)) + tmp94, err := lang.WithMeta(tmp92, tmp93.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v95 any = tmp94 + _ = v95 + var tmp96 any + if lang.IsTruthy(v84) { + tmp97 := checkDerefVar(var_glojure_DOT_core_seq) + tmp98 := checkDerefVar(var_glojure_DOT_core_concat) + tmp99 := checkDerefVar(var_glojure_DOT_core_list) + tmp100 := lang.Apply(tmp99, []any{sym_glojure_DOT_core_SLASH_fn}) + tmp101 := checkDerefVar(var_glojure_DOT_core_list) + tmp102 := lang.Apply(tmp101, []any{v88}) + tmp103 := checkDerefVar(var_glojure_DOT_core_list) + tmp104 := checkDerefVar(var_glojure_DOT_core_apply) + tmp105 := checkDerefVar(var_glojure_DOT_core_vector) + tmp106 := checkDerefVar(var_glojure_DOT_core_seq) + tmp107 := checkDerefVar(var_glojure_DOT_core_concat) + tmp108 := checkDerefVar(var_glojure_DOT_core_list) + tmp109 := lang.Apply(tmp108, []any{v91}) + tmp110 := lang.Apply(tmp107, []any{tmp109}) + tmp111 := lang.Apply(tmp106, []any{tmp110}) + tmp112 := lang.Apply(tmp104, []any{tmp105, tmp111}) + tmp113 := lang.Apply(tmp103, []any{tmp112}) + tmp114 := checkDerefVar(var_glojure_DOT_core_list) + tmp115 := checkDerefVar(var_glojure_DOT_core_seq) + tmp116 := checkDerefVar(var_glojure_DOT_core_concat) + tmp117 := checkDerefVar(var_glojure_DOT_core_list) + tmp118 := lang.Apply(tmp117, []any{sym_glojure_DOT_core_SLASH_lazy_DASH_seq}) + tmp119 := checkDerefVar(var_glojure_DOT_core_list) + tmp120 := checkDerefVar(var_glojure_DOT_core_seq) + tmp121 := checkDerefVar(var_glojure_DOT_core_concat) + tmp122 := checkDerefVar(var_glojure_DOT_core_list) + tmp123 := lang.Apply(tmp122, []any{sym_glojure_DOT_core_SLASH_loop}) + tmp124 := checkDerefVar(var_glojure_DOT_core_list) + tmp125 := checkDerefVar(var_glojure_DOT_core_apply) + tmp126 := checkDerefVar(var_glojure_DOT_core_vector) + tmp127 := checkDerefVar(var_glojure_DOT_core_seq) + tmp128 := checkDerefVar(var_glojure_DOT_core_concat) + tmp129 := checkDerefVar(var_glojure_DOT_core_list) + tmp130 := lang.Apply(tmp129, []any{v91}) + tmp131 := checkDerefVar(var_glojure_DOT_core_list) + tmp132 := lang.Apply(tmp131, []any{v91}) + tmp133 := lang.Apply(tmp128, []any{tmp130, tmp132}) + tmp134 := lang.Apply(tmp127, []any{tmp133}) + tmp135 := lang.Apply(tmp125, []any{tmp126, tmp134}) + tmp136 := lang.Apply(tmp124, []any{tmp135}) + tmp137 := checkDerefVar(var_glojure_DOT_core_list) + tmp138 := checkDerefVar(var_glojure_DOT_core_seq) + tmp139 := checkDerefVar(var_glojure_DOT_core_concat) + tmp140 := checkDerefVar(var_glojure_DOT_core_list) + tmp141 := lang.Apply(tmp140, []any{sym_glojure_DOT_core_SLASH_when_DASH_first}) + tmp142 := checkDerefVar(var_glojure_DOT_core_list) + tmp143 := checkDerefVar(var_glojure_DOT_core_apply) + tmp144 := checkDerefVar(var_glojure_DOT_core_vector) + tmp145 := checkDerefVar(var_glojure_DOT_core_seq) + tmp146 := checkDerefVar(var_glojure_DOT_core_concat) + tmp147 := checkDerefVar(var_glojure_DOT_core_list) + tmp148 := lang.Apply(tmp147, []any{v65}) + tmp149 := checkDerefVar(var_glojure_DOT_core_list) + tmp150 := lang.Apply(tmp149, []any{v91}) + tmp151 := lang.Apply(tmp146, []any{tmp148, tmp150}) + tmp152 := lang.Apply(tmp145, []any{tmp151}) + tmp153 := lang.Apply(tmp143, []any{tmp144, tmp152}) + tmp154 := lang.Apply(tmp142, []any{tmp153}) + tmp155 := checkDerefVar(var_glojure_DOT_core_list) + tmp156 := lang.Apply(v95, []any{v73}) + tmp157 := lang.Apply(tmp155, []any{tmp156}) + tmp158 := lang.Apply(tmp139, []any{tmp141, tmp154, tmp157}) + tmp159 := lang.Apply(tmp138, []any{tmp158}) + tmp160 := lang.Apply(tmp137, []any{tmp159}) + tmp161 := lang.Apply(tmp121, []any{tmp123, tmp136, tmp160}) + tmp162 := lang.Apply(tmp120, []any{tmp161}) + tmp163 := lang.Apply(tmp119, []any{tmp162}) + tmp164 := lang.Apply(tmp116, []any{tmp118, tmp163}) + tmp165 := lang.Apply(tmp115, []any{tmp164}) + tmp166 := lang.Apply(tmp114, []any{tmp165}) + tmp167 := lang.Apply(tmp98, []any{tmp100, tmp102, tmp113, tmp166}) + tmp168 := lang.Apply(tmp97, []any{tmp167}) + tmp96 = tmp168 + } else { + var tmp169 any + { // let + // let binding "gi" + tmp170 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp171 := lang.Apply(tmp170, []any{"i__"}) + var v172 any = tmp171 + _ = v172 + // let binding "gb" + tmp173 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp174 := lang.Apply(tmp173, []any{"b__"}) + var v175 any = tmp174 + _ = v175 + // let binding "do-cmod" + var tmp176 lang.FnFunc + { // function do-cmod + var v177 lang.FnFunc + tmp176 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v178 := args[0] + _ = v178 + var tmp179 any + { // let + // let binding "vec__739" + var v180 any = v178 + _ = v180 + // let binding "seq__740" + tmp181 := checkDerefVar(var_glojure_DOT_core_seq) + tmp182 := lang.Apply(tmp181, []any{v180}) + var v183 any = tmp182 + _ = v183 + // let binding "first__741" + tmp184 := checkDerefVar(var_glojure_DOT_core_first) + tmp185 := lang.Apply(tmp184, []any{v183}) + var v186 any = tmp185 + _ = v186 + // let binding "seq__740" + tmp187 := checkDerefVar(var_glojure_DOT_core_next) + tmp188 := lang.Apply(tmp187, []any{v183}) + var v189 any = tmp188 + _ = v189 + // let binding "vec__742" + var v190 any = v186 + _ = v190 + // let binding "k" + tmp191 := checkDerefVar(var_glojure_DOT_core_nth) + tmp192 := lang.Apply(tmp191, []any{v190, int64(0), nil}) + var v193 any = tmp192 + _ = v193 + // let binding "v" + tmp194 := checkDerefVar(var_glojure_DOT_core_nth) + tmp195 := lang.Apply(tmp194, []any{v190, int64(1), nil}) + var v196 any = tmp195 + _ = v196 + // let binding "pair" + var v197 any = v190 + _ = v197 + // let binding "etc" + var v198 any = v189 + _ = v198 + var tmp199 any + tmp200 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp201 := lang.Apply(tmp200, []any{v193, kw_let}) + if lang.IsTruthy(tmp201) { + tmp202 := checkDerefVar(var_glojure_DOT_core_seq) + tmp203 := checkDerefVar(var_glojure_DOT_core_concat) + tmp204 := checkDerefVar(var_glojure_DOT_core_list) + tmp205 := lang.Apply(tmp204, []any{sym_glojure_DOT_core_SLASH_let}) + tmp206 := checkDerefVar(var_glojure_DOT_core_list) + tmp207 := lang.Apply(tmp206, []any{v196}) + tmp208 := checkDerefVar(var_glojure_DOT_core_list) + tmp209 := lang.Apply(v177, []any{v198}) + tmp210 := lang.Apply(tmp208, []any{tmp209}) + tmp211 := lang.Apply(tmp203, []any{tmp205, tmp207, tmp210}) + tmp212 := lang.Apply(tmp202, []any{tmp211}) + tmp199 = tmp212 + } else { + var tmp213 any + tmp214 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp215 := lang.Apply(tmp214, []any{v193, kw_while}) + if lang.IsTruthy(tmp215) { + tmp216 := checkDerefVar(var_glojure_DOT_core_seq) + tmp217 := checkDerefVar(var_glojure_DOT_core_concat) + tmp218 := checkDerefVar(var_glojure_DOT_core_list) + tmp219 := lang.Apply(tmp218, []any{sym_glojure_DOT_core_SLASH_when}) + tmp220 := checkDerefVar(var_glojure_DOT_core_list) + tmp221 := lang.Apply(tmp220, []any{v196}) + tmp222 := checkDerefVar(var_glojure_DOT_core_list) + tmp223 := lang.Apply(v177, []any{v198}) + tmp224 := lang.Apply(tmp222, []any{tmp223}) + tmp225 := lang.Apply(tmp217, []any{tmp219, tmp221, tmp224}) + tmp226 := lang.Apply(tmp216, []any{tmp225}) + tmp213 = tmp226 + } else { + var tmp227 any + tmp228 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp229 := lang.Apply(tmp228, []any{v193, kw_when}) + if lang.IsTruthy(tmp229) { + tmp230 := checkDerefVar(var_glojure_DOT_core_seq) + tmp231 := checkDerefVar(var_glojure_DOT_core_concat) + tmp232 := checkDerefVar(var_glojure_DOT_core_list) + tmp233 := lang.Apply(tmp232, []any{sym_if}) + tmp234 := checkDerefVar(var_glojure_DOT_core_list) + tmp235 := lang.Apply(tmp234, []any{v196}) + tmp236 := checkDerefVar(var_glojure_DOT_core_list) + tmp237 := lang.Apply(v177, []any{v198}) + tmp238 := lang.Apply(tmp236, []any{tmp237}) + tmp239 := checkDerefVar(var_glojure_DOT_core_list) + tmp240 := checkDerefVar(var_glojure_DOT_core_seq) + tmp241 := checkDerefVar(var_glojure_DOT_core_concat) + tmp242 := checkDerefVar(var_glojure_DOT_core_list) + tmp243 := lang.Apply(tmp242, []any{sym_recur}) + tmp244 := checkDerefVar(var_glojure_DOT_core_list) + tmp245 := checkDerefVar(var_glojure_DOT_core_seq) + tmp246 := checkDerefVar(var_glojure_DOT_core_concat) + tmp247 := checkDerefVar(var_glojure_DOT_core_list) + tmp248 := lang.Apply(tmp247, []any{sym_glojure_DOT_core_SLASH_unchecked_DASH_inc}) + tmp249 := checkDerefVar(var_glojure_DOT_core_list) + tmp250 := lang.Apply(tmp249, []any{v172}) + tmp251 := lang.Apply(tmp246, []any{tmp248, tmp250}) + tmp252 := lang.Apply(tmp245, []any{tmp251}) + tmp253 := lang.Apply(tmp244, []any{tmp252}) + tmp254 := lang.Apply(tmp241, []any{tmp243, tmp253}) + tmp255 := lang.Apply(tmp240, []any{tmp254}) + tmp256 := lang.Apply(tmp239, []any{tmp255}) + tmp257 := lang.Apply(tmp231, []any{tmp233, tmp235, tmp238, tmp256}) + tmp258 := lang.Apply(tmp230, []any{tmp257}) + tmp227 = tmp258 + } else { + var tmp259 any + tmp260 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp261 := lang.Apply(tmp260, []any{v193}) + if lang.IsTruthy(tmp261) { + tmp262 := lang.Apply(v40, []any{"Invalid 'for' keyword ", v193}) + tmp259 = tmp262 + } else { + var tmp263 any + if lang.IsTruthy(kw_else) { + tmp264 := checkDerefVar(var_glojure_DOT_core_seq) + tmp265 := checkDerefVar(var_glojure_DOT_core_concat) + tmp266 := checkDerefVar(var_glojure_DOT_core_list) + tmp267 := lang.Apply(tmp266, []any{sym_do}) + tmp268 := checkDerefVar(var_glojure_DOT_core_list) + tmp269 := checkDerefVar(var_glojure_DOT_core_seq) + tmp270 := checkDerefVar(var_glojure_DOT_core_concat) + tmp271 := checkDerefVar(var_glojure_DOT_core_list) + tmp272 := lang.Apply(tmp271, []any{sym_glojure_DOT_core_SLASH_chunk_DASH_append}) + tmp273 := checkDerefVar(var_glojure_DOT_core_list) + tmp274 := lang.Apply(tmp273, []any{v175}) + tmp275 := checkDerefVar(var_glojure_DOT_core_list) + tmp276 := lang.Apply(tmp275, []any{v5}) + tmp277 := lang.Apply(tmp270, []any{tmp272, tmp274, tmp276}) + tmp278 := lang.Apply(tmp269, []any{tmp277}) + tmp279 := lang.Apply(tmp268, []any{tmp278}) + tmp280 := checkDerefVar(var_glojure_DOT_core_list) + tmp281 := checkDerefVar(var_glojure_DOT_core_seq) + tmp282 := checkDerefVar(var_glojure_DOT_core_concat) + tmp283 := checkDerefVar(var_glojure_DOT_core_list) + tmp284 := lang.Apply(tmp283, []any{sym_recur}) + tmp285 := checkDerefVar(var_glojure_DOT_core_list) + tmp286 := checkDerefVar(var_glojure_DOT_core_seq) + tmp287 := checkDerefVar(var_glojure_DOT_core_concat) + tmp288 := checkDerefVar(var_glojure_DOT_core_list) + tmp289 := lang.Apply(tmp288, []any{sym_glojure_DOT_core_SLASH_unchecked_DASH_inc}) + tmp290 := checkDerefVar(var_glojure_DOT_core_list) + tmp291 := lang.Apply(tmp290, []any{v172}) + tmp292 := lang.Apply(tmp287, []any{tmp289, tmp291}) + tmp293 := lang.Apply(tmp286, []any{tmp292}) + tmp294 := lang.Apply(tmp285, []any{tmp293}) + tmp295 := lang.Apply(tmp282, []any{tmp284, tmp294}) + tmp296 := lang.Apply(tmp281, []any{tmp295}) + tmp297 := lang.Apply(tmp280, []any{tmp296}) + tmp298 := lang.Apply(tmp265, []any{tmp267, tmp279, tmp297}) + tmp299 := lang.Apply(tmp264, []any{tmp298}) + tmp263 = tmp299 + } else { + } + tmp259 = tmp263 + } + tmp227 = tmp259 + } + tmp213 = tmp227 + } + tmp199 = tmp213 + } + tmp179 = tmp199 + } // end let + return tmp179 + }) + v177 = tmp176 + _ = v177 + } + tmp177 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4698), kw_column, int(39), kw_end_DASH_line, int(4710), kw_end_DASH_column, int(79)) + tmp178, err := lang.WithMeta(tmp176, tmp177.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v179 any = tmp178 + _ = v179 + tmp180 := checkDerefVar(var_glojure_DOT_core_seq) + tmp181 := checkDerefVar(var_glojure_DOT_core_concat) + tmp182 := checkDerefVar(var_glojure_DOT_core_list) + tmp183 := lang.Apply(tmp182, []any{sym_glojure_DOT_core_SLASH_fn}) + tmp184 := checkDerefVar(var_glojure_DOT_core_list) + tmp185 := lang.Apply(tmp184, []any{v88}) + tmp186 := checkDerefVar(var_glojure_DOT_core_list) + tmp187 := checkDerefVar(var_glojure_DOT_core_apply) + tmp188 := checkDerefVar(var_glojure_DOT_core_vector) + tmp189 := checkDerefVar(var_glojure_DOT_core_seq) + tmp190 := checkDerefVar(var_glojure_DOT_core_concat) + tmp191 := checkDerefVar(var_glojure_DOT_core_list) + tmp192 := lang.Apply(tmp191, []any{v91}) + tmp193 := lang.Apply(tmp190, []any{tmp192}) + tmp194 := lang.Apply(tmp189, []any{tmp193}) + tmp195 := lang.Apply(tmp187, []any{tmp188, tmp194}) + tmp196 := lang.Apply(tmp186, []any{tmp195}) + tmp197 := checkDerefVar(var_glojure_DOT_core_list) + tmp198 := checkDerefVar(var_glojure_DOT_core_seq) + tmp199 := checkDerefVar(var_glojure_DOT_core_concat) + tmp200 := checkDerefVar(var_glojure_DOT_core_list) + tmp201 := lang.Apply(tmp200, []any{sym_glojure_DOT_core_SLASH_lazy_DASH_seq}) + tmp202 := checkDerefVar(var_glojure_DOT_core_list) + tmp203 := checkDerefVar(var_glojure_DOT_core_seq) + tmp204 := checkDerefVar(var_glojure_DOT_core_concat) + tmp205 := checkDerefVar(var_glojure_DOT_core_list) + tmp206 := lang.Apply(tmp205, []any{sym_glojure_DOT_core_SLASH_loop}) + tmp207 := checkDerefVar(var_glojure_DOT_core_list) + tmp208 := checkDerefVar(var_glojure_DOT_core_apply) + tmp209 := checkDerefVar(var_glojure_DOT_core_vector) + tmp210 := checkDerefVar(var_glojure_DOT_core_seq) + tmp211 := checkDerefVar(var_glojure_DOT_core_concat) + tmp212 := checkDerefVar(var_glojure_DOT_core_list) + tmp213 := lang.Apply(tmp212, []any{v91}) + tmp214 := checkDerefVar(var_glojure_DOT_core_list) + tmp215 := lang.Apply(tmp214, []any{v91}) + tmp216 := lang.Apply(tmp211, []any{tmp213, tmp215}) + tmp217 := lang.Apply(tmp210, []any{tmp216}) + tmp218 := lang.Apply(tmp208, []any{tmp209, tmp217}) + tmp219 := lang.Apply(tmp207, []any{tmp218}) + tmp220 := checkDerefVar(var_glojure_DOT_core_list) + tmp221 := checkDerefVar(var_glojure_DOT_core_seq) + tmp222 := checkDerefVar(var_glojure_DOT_core_concat) + tmp223 := checkDerefVar(var_glojure_DOT_core_list) + tmp224 := lang.Apply(tmp223, []any{sym_glojure_DOT_core_SLASH_when_DASH_let}) + tmp225 := checkDerefVar(var_glojure_DOT_core_list) + tmp226 := checkDerefVar(var_glojure_DOT_core_apply) + tmp227 := checkDerefVar(var_glojure_DOT_core_vector) + tmp228 := checkDerefVar(var_glojure_DOT_core_seq) + tmp229 := checkDerefVar(var_glojure_DOT_core_concat) + tmp230 := checkDerefVar(var_glojure_DOT_core_list) + tmp231 := lang.Apply(tmp230, []any{v91}) + tmp232 := checkDerefVar(var_glojure_DOT_core_list) + tmp233 := checkDerefVar(var_glojure_DOT_core_seq) + tmp234 := checkDerefVar(var_glojure_DOT_core_concat) + tmp235 := checkDerefVar(var_glojure_DOT_core_list) + tmp236 := lang.Apply(tmp235, []any{sym_glojure_DOT_core_SLASH_seq}) + tmp237 := checkDerefVar(var_glojure_DOT_core_list) + tmp238 := lang.Apply(tmp237, []any{v91}) + tmp239 := lang.Apply(tmp234, []any{tmp236, tmp238}) + tmp240 := lang.Apply(tmp233, []any{tmp239}) + tmp241 := lang.Apply(tmp232, []any{tmp240}) + tmp242 := lang.Apply(tmp229, []any{tmp231, tmp241}) + tmp243 := lang.Apply(tmp228, []any{tmp242}) + tmp244 := lang.Apply(tmp226, []any{tmp227, tmp243}) + tmp245 := lang.Apply(tmp225, []any{tmp244}) + tmp246 := checkDerefVar(var_glojure_DOT_core_list) + tmp247 := checkDerefVar(var_glojure_DOT_core_seq) + tmp248 := checkDerefVar(var_glojure_DOT_core_concat) + tmp249 := checkDerefVar(var_glojure_DOT_core_list) + tmp250 := lang.Apply(tmp249, []any{sym_if}) + tmp251 := checkDerefVar(var_glojure_DOT_core_list) + tmp252 := checkDerefVar(var_glojure_DOT_core_seq) + tmp253 := checkDerefVar(var_glojure_DOT_core_concat) + tmp254 := checkDerefVar(var_glojure_DOT_core_list) + tmp255 := lang.Apply(tmp254, []any{sym_glojure_DOT_core_SLASH_chunked_DASH_seq_QMARK_}) + tmp256 := checkDerefVar(var_glojure_DOT_core_list) + tmp257 := lang.Apply(tmp256, []any{v91}) + tmp258 := lang.Apply(tmp253, []any{tmp255, tmp257}) + tmp259 := lang.Apply(tmp252, []any{tmp258}) + tmp260 := lang.Apply(tmp251, []any{tmp259}) + tmp261 := checkDerefVar(var_glojure_DOT_core_list) + tmp262 := checkDerefVar(var_glojure_DOT_core_seq) + tmp263 := checkDerefVar(var_glojure_DOT_core_concat) + tmp264 := checkDerefVar(var_glojure_DOT_core_list) + tmp265 := lang.Apply(tmp264, []any{sym_glojure_DOT_core_SLASH_let}) + tmp266 := checkDerefVar(var_glojure_DOT_core_list) + tmp267 := checkDerefVar(var_glojure_DOT_core_apply) + tmp268 := checkDerefVar(var_glojure_DOT_core_vector) + tmp269 := checkDerefVar(var_glojure_DOT_core_seq) + tmp270 := checkDerefVar(var_glojure_DOT_core_concat) + tmp271 := checkDerefVar(var_glojure_DOT_core_list) + tmp272 := lang.Apply(tmp271, []any{sym_c__0__auto__}) + tmp273 := checkDerefVar(var_glojure_DOT_core_list) + tmp274 := checkDerefVar(var_glojure_DOT_core_seq) + tmp275 := checkDerefVar(var_glojure_DOT_core_concat) + tmp276 := checkDerefVar(var_glojure_DOT_core_list) + tmp277 := lang.Apply(tmp276, []any{sym_glojure_DOT_core_SLASH_chunk_DASH_first}) + tmp278 := checkDerefVar(var_glojure_DOT_core_list) + tmp279 := lang.Apply(tmp278, []any{v91}) + tmp280 := lang.Apply(tmp275, []any{tmp277, tmp279}) + tmp281 := lang.Apply(tmp274, []any{tmp280}) + tmp282 := lang.Apply(tmp273, []any{tmp281}) + tmp283 := checkDerefVar(var_glojure_DOT_core_list) + tmp284 := lang.Apply(tmp283, []any{sym_size__1__auto__}) + tmp285 := checkDerefVar(var_glojure_DOT_core_list) + tmp286 := checkDerefVar(var_glojure_DOT_core_seq) + tmp287 := checkDerefVar(var_glojure_DOT_core_concat) + tmp288 := checkDerefVar(var_glojure_DOT_core_list) + tmp289 := lang.Apply(tmp288, []any{sym_glojure_DOT_core_SLASH_int}) + tmp290 := checkDerefVar(var_glojure_DOT_core_list) + tmp291 := checkDerefVar(var_glojure_DOT_core_seq) + tmp292 := checkDerefVar(var_glojure_DOT_core_concat) + tmp293 := checkDerefVar(var_glojure_DOT_core_list) + tmp294 := lang.Apply(tmp293, []any{sym_glojure_DOT_core_SLASH_count}) + tmp295 := checkDerefVar(var_glojure_DOT_core_list) + tmp296 := lang.Apply(tmp295, []any{sym_c__0__auto__}) + tmp297 := lang.Apply(tmp292, []any{tmp294, tmp296}) + tmp298 := lang.Apply(tmp291, []any{tmp297}) + tmp299 := lang.Apply(tmp290, []any{tmp298}) + tmp300 := lang.Apply(tmp287, []any{tmp289, tmp299}) + tmp301 := lang.Apply(tmp286, []any{tmp300}) + tmp302 := lang.Apply(tmp285, []any{tmp301}) + tmp303 := checkDerefVar(var_glojure_DOT_core_list) + tmp304 := lang.Apply(tmp303, []any{v175}) + tmp305 := checkDerefVar(var_glojure_DOT_core_list) + tmp306 := checkDerefVar(var_glojure_DOT_core_seq) + tmp307 := checkDerefVar(var_glojure_DOT_core_concat) + tmp308 := checkDerefVar(var_glojure_DOT_core_list) + tmp309 := lang.Apply(tmp308, []any{sym_glojure_DOT_core_SLASH_chunk_DASH_buffer}) + tmp310 := checkDerefVar(var_glojure_DOT_core_list) + tmp311 := lang.Apply(tmp310, []any{sym_size__1__auto__}) + tmp312 := lang.Apply(tmp307, []any{tmp309, tmp311}) + tmp313 := lang.Apply(tmp306, []any{tmp312}) + tmp314 := lang.Apply(tmp305, []any{tmp313}) + tmp315 := lang.Apply(tmp270, []any{tmp272, tmp282, tmp284, tmp302, tmp304, tmp314}) + tmp316 := lang.Apply(tmp269, []any{tmp315}) + tmp317 := lang.Apply(tmp267, []any{tmp268, tmp316}) + tmp318 := lang.Apply(tmp266, []any{tmp317}) + tmp319 := checkDerefVar(var_glojure_DOT_core_list) + tmp320 := checkDerefVar(var_glojure_DOT_core_seq) + tmp321 := checkDerefVar(var_glojure_DOT_core_concat) + tmp322 := checkDerefVar(var_glojure_DOT_core_list) + tmp323 := lang.Apply(tmp322, []any{sym_if}) + tmp324 := checkDerefVar(var_glojure_DOT_core_list) + tmp325 := checkDerefVar(var_glojure_DOT_core_seq) + tmp326 := checkDerefVar(var_glojure_DOT_core_concat) + tmp327 := checkDerefVar(var_glojure_DOT_core_list) + tmp328 := lang.Apply(tmp327, []any{sym_glojure_DOT_core_SLASH_loop}) + tmp329 := checkDerefVar(var_glojure_DOT_core_list) + tmp330 := checkDerefVar(var_glojure_DOT_core_apply) + tmp331 := checkDerefVar(var_glojure_DOT_core_vector) + tmp332 := checkDerefVar(var_glojure_DOT_core_seq) + tmp333 := checkDerefVar(var_glojure_DOT_core_concat) + tmp334 := checkDerefVar(var_glojure_DOT_core_list) + tmp335 := lang.Apply(tmp334, []any{v172}) + tmp336 := checkDerefVar(var_glojure_DOT_core_list) + tmp337 := checkDerefVar(var_glojure_DOT_core_seq) + tmp338 := checkDerefVar(var_glojure_DOT_core_concat) + tmp339 := checkDerefVar(var_glojure_DOT_core_list) + tmp340 := lang.Apply(tmp339, []any{sym_glojure_DOT_core_SLASH_int}) + tmp341 := checkDerefVar(var_glojure_DOT_core_list) + tmp342 := lang.Apply(tmp341, []any{int64(0)}) + tmp343 := lang.Apply(tmp338, []any{tmp340, tmp342}) + tmp344 := lang.Apply(tmp337, []any{tmp343}) + tmp345 := lang.Apply(tmp336, []any{tmp344}) + tmp346 := lang.Apply(tmp333, []any{tmp335, tmp345}) + tmp347 := lang.Apply(tmp332, []any{tmp346}) + tmp348 := lang.Apply(tmp330, []any{tmp331, tmp347}) + tmp349 := lang.Apply(tmp329, []any{tmp348}) + tmp350 := checkDerefVar(var_glojure_DOT_core_list) + tmp351 := checkDerefVar(var_glojure_DOT_core_seq) + tmp352 := checkDerefVar(var_glojure_DOT_core_concat) + tmp353 := checkDerefVar(var_glojure_DOT_core_list) + tmp354 := lang.Apply(tmp353, []any{sym_if}) + tmp355 := checkDerefVar(var_glojure_DOT_core_list) + tmp356 := checkDerefVar(var_glojure_DOT_core_seq) + tmp357 := checkDerefVar(var_glojure_DOT_core_concat) + tmp358 := checkDerefVar(var_glojure_DOT_core_list) + tmp359 := lang.Apply(tmp358, []any{sym_glojure_DOT_core_SLASH__LT_}) + tmp360 := checkDerefVar(var_glojure_DOT_core_list) + tmp361 := lang.Apply(tmp360, []any{v172}) + tmp362 := checkDerefVar(var_glojure_DOT_core_list) + tmp363 := lang.Apply(tmp362, []any{sym_size__1__auto__}) + tmp364 := lang.Apply(tmp357, []any{tmp359, tmp361, tmp363}) + tmp365 := lang.Apply(tmp356, []any{tmp364}) + tmp366 := lang.Apply(tmp355, []any{tmp365}) + tmp367 := checkDerefVar(var_glojure_DOT_core_list) + tmp368 := checkDerefVar(var_glojure_DOT_core_seq) + tmp369 := checkDerefVar(var_glojure_DOT_core_concat) + tmp370 := checkDerefVar(var_glojure_DOT_core_list) + tmp371 := lang.Apply(tmp370, []any{sym_glojure_DOT_core_SLASH_let}) + tmp372 := checkDerefVar(var_glojure_DOT_core_list) + tmp373 := checkDerefVar(var_glojure_DOT_core_apply) + tmp374 := checkDerefVar(var_glojure_DOT_core_vector) + tmp375 := checkDerefVar(var_glojure_DOT_core_seq) + tmp376 := checkDerefVar(var_glojure_DOT_core_concat) + tmp377 := checkDerefVar(var_glojure_DOT_core_list) + tmp378 := lang.Apply(tmp377, []any{v65}) + tmp379 := checkDerefVar(var_glojure_DOT_core_list) + tmp380 := checkDerefVar(var_glojure_DOT_core_seq) + tmp381 := checkDerefVar(var_glojure_DOT_core_concat) + tmp382 := checkDerefVar(var_glojure_DOT_core_list) + tmp383 := lang.Apply(tmp382, []any{sym__DOT_nth}) + tmp384 := checkDerefVar(var_glojure_DOT_core_list) + tmp385 := lang.Apply(tmp384, []any{sym_c__0__auto__}) + tmp386 := checkDerefVar(var_glojure_DOT_core_list) + tmp387 := lang.Apply(tmp386, []any{v172}) + tmp388 := lang.Apply(tmp381, []any{tmp383, tmp385, tmp387}) + tmp389 := lang.Apply(tmp380, []any{tmp388}) + tmp390 := lang.Apply(tmp379, []any{tmp389}) + tmp391 := lang.Apply(tmp376, []any{tmp378, tmp390}) + tmp392 := lang.Apply(tmp375, []any{tmp391}) + tmp393 := lang.Apply(tmp373, []any{tmp374, tmp392}) + tmp394 := lang.Apply(tmp372, []any{tmp393}) + tmp395 := checkDerefVar(var_glojure_DOT_core_list) + tmp396 := lang.Apply(v179, []any{v73}) + tmp397 := lang.Apply(tmp395, []any{tmp396}) + tmp398 := lang.Apply(tmp369, []any{tmp371, tmp394, tmp397}) + tmp399 := lang.Apply(tmp368, []any{tmp398}) + tmp400 := lang.Apply(tmp367, []any{tmp399}) + tmp401 := checkDerefVar(var_glojure_DOT_core_list) + tmp402 := lang.Apply(tmp401, []any{true}) + tmp403 := lang.Apply(tmp352, []any{tmp354, tmp366, tmp400, tmp402}) + tmp404 := lang.Apply(tmp351, []any{tmp403}) + tmp405 := lang.Apply(tmp350, []any{tmp404}) + tmp406 := lang.Apply(tmp326, []any{tmp328, tmp349, tmp405}) + tmp407 := lang.Apply(tmp325, []any{tmp406}) + tmp408 := lang.Apply(tmp324, []any{tmp407}) + tmp409 := checkDerefVar(var_glojure_DOT_core_list) + tmp410 := checkDerefVar(var_glojure_DOT_core_seq) + tmp411 := checkDerefVar(var_glojure_DOT_core_concat) + tmp412 := checkDerefVar(var_glojure_DOT_core_list) + tmp413 := lang.Apply(tmp412, []any{sym_glojure_DOT_core_SLASH_chunk_DASH_cons}) + tmp414 := checkDerefVar(var_glojure_DOT_core_list) + tmp415 := checkDerefVar(var_glojure_DOT_core_seq) + tmp416 := checkDerefVar(var_glojure_DOT_core_concat) + tmp417 := checkDerefVar(var_glojure_DOT_core_list) + tmp418 := lang.Apply(tmp417, []any{sym_glojure_DOT_core_SLASH_chunk}) + tmp419 := checkDerefVar(var_glojure_DOT_core_list) + tmp420 := lang.Apply(tmp419, []any{v175}) + tmp421 := lang.Apply(tmp416, []any{tmp418, tmp420}) + tmp422 := lang.Apply(tmp415, []any{tmp421}) + tmp423 := lang.Apply(tmp414, []any{tmp422}) + tmp424 := checkDerefVar(var_glojure_DOT_core_list) + tmp425 := checkDerefVar(var_glojure_DOT_core_seq) + tmp426 := checkDerefVar(var_glojure_DOT_core_concat) + tmp427 := checkDerefVar(var_glojure_DOT_core_list) + tmp428 := lang.Apply(tmp427, []any{v88}) + tmp429 := checkDerefVar(var_glojure_DOT_core_list) + tmp430 := checkDerefVar(var_glojure_DOT_core_seq) + tmp431 := checkDerefVar(var_glojure_DOT_core_concat) + tmp432 := checkDerefVar(var_glojure_DOT_core_list) + tmp433 := lang.Apply(tmp432, []any{sym_glojure_DOT_core_SLASH_chunk_DASH_rest}) + tmp434 := checkDerefVar(var_glojure_DOT_core_list) + tmp435 := lang.Apply(tmp434, []any{v91}) + tmp436 := lang.Apply(tmp431, []any{tmp433, tmp435}) + tmp437 := lang.Apply(tmp430, []any{tmp436}) + tmp438 := lang.Apply(tmp429, []any{tmp437}) + tmp439 := lang.Apply(tmp426, []any{tmp428, tmp438}) + tmp440 := lang.Apply(tmp425, []any{tmp439}) + tmp441 := lang.Apply(tmp424, []any{tmp440}) + tmp442 := lang.Apply(tmp411, []any{tmp413, tmp423, tmp441}) + tmp443 := lang.Apply(tmp410, []any{tmp442}) + tmp444 := lang.Apply(tmp409, []any{tmp443}) + tmp445 := checkDerefVar(var_glojure_DOT_core_list) + tmp446 := checkDerefVar(var_glojure_DOT_core_seq) + tmp447 := checkDerefVar(var_glojure_DOT_core_concat) + tmp448 := checkDerefVar(var_glojure_DOT_core_list) + tmp449 := lang.Apply(tmp448, []any{sym_glojure_DOT_core_SLASH_chunk_DASH_cons}) + tmp450 := checkDerefVar(var_glojure_DOT_core_list) + tmp451 := checkDerefVar(var_glojure_DOT_core_seq) + tmp452 := checkDerefVar(var_glojure_DOT_core_concat) + tmp453 := checkDerefVar(var_glojure_DOT_core_list) + tmp454 := lang.Apply(tmp453, []any{sym_glojure_DOT_core_SLASH_chunk}) + tmp455 := checkDerefVar(var_glojure_DOT_core_list) + tmp456 := lang.Apply(tmp455, []any{v175}) + tmp457 := lang.Apply(tmp452, []any{tmp454, tmp456}) + tmp458 := lang.Apply(tmp451, []any{tmp457}) + tmp459 := lang.Apply(tmp450, []any{tmp458}) + tmp460 := checkDerefVar(var_glojure_DOT_core_list) + tmp461 := lang.Apply(tmp460, []any{nil}) + tmp462 := lang.Apply(tmp447, []any{tmp449, tmp459, tmp461}) + tmp463 := lang.Apply(tmp446, []any{tmp462}) + tmp464 := lang.Apply(tmp445, []any{tmp463}) + tmp465 := lang.Apply(tmp321, []any{tmp323, tmp408, tmp444, tmp464}) + tmp466 := lang.Apply(tmp320, []any{tmp465}) + tmp467 := lang.Apply(tmp319, []any{tmp466}) + tmp468 := lang.Apply(tmp263, []any{tmp265, tmp318, tmp467}) + tmp469 := lang.Apply(tmp262, []any{tmp468}) + tmp470 := lang.Apply(tmp261, []any{tmp469}) + tmp471 := checkDerefVar(var_glojure_DOT_core_list) + tmp472 := checkDerefVar(var_glojure_DOT_core_seq) + tmp473 := checkDerefVar(var_glojure_DOT_core_concat) + tmp474 := checkDerefVar(var_glojure_DOT_core_list) + tmp475 := lang.Apply(tmp474, []any{sym_glojure_DOT_core_SLASH_let}) + tmp476 := checkDerefVar(var_glojure_DOT_core_list) + tmp477 := checkDerefVar(var_glojure_DOT_core_apply) + tmp478 := checkDerefVar(var_glojure_DOT_core_vector) + tmp479 := checkDerefVar(var_glojure_DOT_core_seq) + tmp480 := checkDerefVar(var_glojure_DOT_core_concat) + tmp481 := checkDerefVar(var_glojure_DOT_core_list) + tmp482 := lang.Apply(tmp481, []any{v65}) + tmp483 := checkDerefVar(var_glojure_DOT_core_list) + tmp484 := checkDerefVar(var_glojure_DOT_core_seq) + tmp485 := checkDerefVar(var_glojure_DOT_core_concat) + tmp486 := checkDerefVar(var_glojure_DOT_core_list) + tmp487 := lang.Apply(tmp486, []any{sym_glojure_DOT_core_SLASH_first}) + tmp488 := checkDerefVar(var_glojure_DOT_core_list) + tmp489 := lang.Apply(tmp488, []any{v91}) + tmp490 := lang.Apply(tmp485, []any{tmp487, tmp489}) + tmp491 := lang.Apply(tmp484, []any{tmp490}) + tmp492 := lang.Apply(tmp483, []any{tmp491}) + tmp493 := lang.Apply(tmp480, []any{tmp482, tmp492}) + tmp494 := lang.Apply(tmp479, []any{tmp493}) + tmp495 := lang.Apply(tmp477, []any{tmp478, tmp494}) + tmp496 := lang.Apply(tmp476, []any{tmp495}) + tmp497 := checkDerefVar(var_glojure_DOT_core_list) + tmp498 := lang.Apply(v95, []any{v73}) + tmp499 := lang.Apply(tmp497, []any{tmp498}) + tmp500 := lang.Apply(tmp473, []any{tmp475, tmp496, tmp499}) + tmp501 := lang.Apply(tmp472, []any{tmp500}) + tmp502 := lang.Apply(tmp471, []any{tmp501}) + tmp503 := lang.Apply(tmp248, []any{tmp250, tmp260, tmp470, tmp502}) + tmp504 := lang.Apply(tmp247, []any{tmp503}) + tmp505 := lang.Apply(tmp246, []any{tmp504}) + tmp506 := lang.Apply(tmp222, []any{tmp224, tmp245, tmp505}) + tmp507 := lang.Apply(tmp221, []any{tmp506}) + tmp508 := lang.Apply(tmp220, []any{tmp507}) + tmp509 := lang.Apply(tmp204, []any{tmp206, tmp219, tmp508}) + tmp510 := lang.Apply(tmp203, []any{tmp509}) + tmp511 := lang.Apply(tmp202, []any{tmp510}) + tmp512 := lang.Apply(tmp199, []any{tmp201, tmp511}) + tmp513 := lang.Apply(tmp198, []any{tmp512}) + tmp514 := lang.Apply(tmp197, []any{tmp513}) + tmp515 := lang.Apply(tmp181, []any{tmp183, tmp185, tmp196, tmp514}) + tmp516 := lang.Apply(tmp180, []any{tmp515}) + tmp169 = tmp516 + } // end let + tmp96 = tmp169 + } + tmp85 = tmp96 + } // end let + tmp44 = tmp85 + } // end let + return tmp44 + }) + v42 = tmp41 + _ = v42 + } + tmp42 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4668), kw_column, int(19), kw_end_DASH_line, int(4729), kw_end_DASH_column, int(68)) + tmp43, err := lang.WithMeta(tmp41, tmp42.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v44 any = tmp43 + _ = v44 + tmp45 := checkDerefVar(var_glojure_DOT_core_seq) + tmp46 := checkDerefVar(var_glojure_DOT_core_concat) + tmp47 := checkDerefVar(var_glojure_DOT_core_list) + tmp48 := lang.Apply(tmp47, []any{sym_glojure_DOT_core_SLASH_let}) + tmp49 := checkDerefVar(var_glojure_DOT_core_list) + tmp50 := checkDerefVar(var_glojure_DOT_core_apply) + tmp51 := checkDerefVar(var_glojure_DOT_core_vector) + tmp52 := checkDerefVar(var_glojure_DOT_core_seq) + tmp53 := checkDerefVar(var_glojure_DOT_core_concat) + tmp54 := checkDerefVar(var_glojure_DOT_core_list) + tmp55 := lang.Apply(tmp54, []any{sym_iter__0__auto__}) + tmp56 := checkDerefVar(var_glojure_DOT_core_list) + tmp57 := lang.Apply(v36, []any{v4}) + tmp58 := lang.Apply(v44, []any{tmp57}) + tmp59 := lang.Apply(tmp56, []any{tmp58}) + tmp60 := lang.Apply(tmp53, []any{tmp55, tmp59}) + tmp61 := lang.Apply(tmp52, []any{tmp60}) + tmp62 := lang.Apply(tmp50, []any{tmp51, tmp61}) + tmp63 := lang.Apply(tmp49, []any{tmp62}) + tmp64 := checkDerefVar(var_glojure_DOT_core_list) + tmp65 := checkDerefVar(var_glojure_DOT_core_seq) + tmp66 := checkDerefVar(var_glojure_DOT_core_concat) + tmp67 := checkDerefVar(var_glojure_DOT_core_list) + tmp68 := lang.Apply(tmp67, []any{sym_iter__0__auto__}) + tmp69 := checkDerefVar(var_glojure_DOT_core_list) + tmp70 := checkDerefVar(var_glojure_DOT_core_second) + tmp71 := lang.Apply(tmp70, []any{v4}) + tmp72 := lang.Apply(tmp69, []any{tmp71}) + tmp73 := lang.Apply(tmp66, []any{tmp68, tmp72}) + tmp74 := lang.Apply(tmp65, []any{tmp73}) + tmp75 := lang.Apply(tmp64, []any{tmp74}) + tmp76 := lang.Apply(tmp46, []any{tmp48, tmp63, tmp75}) + tmp77 := lang.Apply(tmp45, []any{tmp76}) + tmp32 = tmp77 + } // end let + return tmp32 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_for = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_for.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // let + { + tmp0 := sym_let.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "binding => binding-form init-expr\n binding-form => name, or destructuring-form\n destructuring-form => map-destructure-form, or seq-destructure-form\n\n Evaluates the exprs in a lexical context in which the symbols in\n the binding-forms are bound to their respective init-exprs or parts\n therein.\n\n See https://glojure.org/reference/special_forms#binding-forms for\n more information about destructuring.", kw_forms, lang.NewVector(lang.NewList(sym_let, lang.NewVector(sym_bindings_STAR_), sym_exprs_STAR_)), kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(11), kw_line, int(4496), kw_end_DASH_line, int(4496), kw_special_DASH_form, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v4}) + if lang.IsTruthy(tmp8) { + } else { + tmp9 := checkDerefVar(var_glojure_DOT_core_str) + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp13 := checkDerefVar(var_glojure_DOT_core_meta) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(kw_line, []any{tmp14}) + tmp16 := lang.Apply(tmp9, []any{tmp11, " requires ", "a vector for its binding", " in ", tmp12, ":", tmp15}) + tmp17 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp16}) + panic(tmp17) + } + _ = tmp6 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_even_QMARK_) + tmp20 := checkDerefVar(var_glojure_DOT_core_count) + tmp21 := lang.Apply(tmp20, []any{v4}) + tmp22 := lang.Apply(tmp19, []any{tmp21}) + if lang.IsTruthy(tmp22) { + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp27 := checkDerefVar(var_glojure_DOT_core_meta) + tmp28 := lang.Apply(tmp27, []any{v2}) + tmp29 := lang.Apply(kw_line, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp25, " requires ", "an even number of forms in binding vector", " in ", tmp26, ":", tmp29}) + tmp31 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp31) + } + _ = tmp18 + tmp32 := checkDerefVar(var_glojure_DOT_core_seq) + tmp33 := checkDerefVar(var_glojure_DOT_core_concat) + tmp34 := checkDerefVar(var_glojure_DOT_core_list) + tmp35 := lang.Apply(tmp34, []any{sym_let_STAR_}) + tmp36 := checkDerefVar(var_glojure_DOT_core_list) + tmp37 := checkDerefVar(var_glojure_DOT_core_destructure) + tmp38 := lang.Apply(tmp37, []any{v4}) + tmp39 := lang.Apply(tmp36, []any{tmp38}) + tmp40 := lang.Apply(tmp33, []any{tmp35, tmp39, v5}) + tmp41 := lang.Apply(tmp32, []any{tmp40}) + return tmp41 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_let = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_let.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // loop + { + tmp0 := sym_loop.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_bindings, sym__AMP_, sym_body)), kw_doc, "Evaluates the exprs in a lexical context in which the symbols in\n the binding-forms are bound to their respective init-exprs or parts\n therein. Acts as a recur target.", kw_forms, lang.NewVector(lang.NewList(sym_loop, lang.NewVector(sym_bindings_STAR_), sym_exprs_STAR_)), kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(11), kw_line, int(4597), kw_end_DASH_line, int(4597), kw_special_DASH_form, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v4}) + if lang.IsTruthy(tmp8) { + } else { + tmp9 := checkDerefVar(var_glojure_DOT_core_str) + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp13 := checkDerefVar(var_glojure_DOT_core_meta) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(kw_line, []any{tmp14}) + tmp16 := lang.Apply(tmp9, []any{tmp11, " requires ", "a vector for its binding", " in ", tmp12, ":", tmp15}) + tmp17 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp16}) + panic(tmp17) + } + _ = tmp6 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_even_QMARK_) + tmp20 := checkDerefVar(var_glojure_DOT_core_count) + tmp21 := lang.Apply(tmp20, []any{v4}) + tmp22 := lang.Apply(tmp19, []any{tmp21}) + if lang.IsTruthy(tmp22) { + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_str) + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v2}) + tmp26 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp27 := checkDerefVar(var_glojure_DOT_core_meta) + tmp28 := lang.Apply(tmp27, []any{v2}) + tmp29 := lang.Apply(kw_line, []any{tmp28}) + tmp30 := lang.Apply(tmp23, []any{tmp25, " requires ", "an even number of forms in binding vector", " in ", tmp26, ":", tmp29}) + tmp31 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp30}) + panic(tmp31) + } + _ = tmp18 + var tmp32 any + { // let + // let binding "db" + tmp33 := checkDerefVar(var_glojure_DOT_core_destructure) + tmp34 := lang.Apply(tmp33, []any{v4}) + var v35 any = tmp34 + _ = v35 + var tmp36 any + tmp37 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp38 := lang.Apply(tmp37, []any{v35, v4}) + if lang.IsTruthy(tmp38) { + tmp39 := checkDerefVar(var_glojure_DOT_core_seq) + tmp40 := checkDerefVar(var_glojure_DOT_core_concat) + tmp41 := checkDerefVar(var_glojure_DOT_core_list) + tmp42 := lang.Apply(tmp41, []any{sym_loop_STAR_}) + tmp43 := checkDerefVar(var_glojure_DOT_core_list) + tmp44 := lang.Apply(tmp43, []any{v4}) + tmp45 := lang.Apply(tmp40, []any{tmp42, tmp44, v5}) + tmp46 := lang.Apply(tmp39, []any{tmp45}) + tmp36 = tmp46 + } else { + var tmp47 any + { // let + // let binding "vs" + tmp48 := checkDerefVar(var_glojure_DOT_core_take_DASH_nth) + tmp49 := checkDerefVar(var_glojure_DOT_core_drop) + tmp50 := lang.Apply(tmp49, []any{int64(1), v4}) + tmp51 := lang.Apply(tmp48, []any{int64(2), tmp50}) + var v52 any = tmp51 + _ = v52 + // let binding "bs" + tmp53 := checkDerefVar(var_glojure_DOT_core_take_DASH_nth) + tmp54 := lang.Apply(tmp53, []any{int64(2), v4}) + var v55 any = tmp54 + _ = v55 + // let binding "gs" + tmp56 := checkDerefVar(var_glojure_DOT_core_map) + var tmp57 lang.FnFunc + tmp57 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v58 := args[0] + _ = v58 + var tmp59 any + tmp60 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp61 := lang.Apply(tmp60, []any{v58}) + if lang.IsTruthy(tmp61) { + tmp59 = v58 + } else { + tmp62 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp63 := lang.Apply(tmp62, nil) + tmp59 = tmp63 + } + return tmp59 + }) + tmp58 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4611), kw_column, int(23), kw_end_DASH_line, int(4611), kw_end_DASH_column, int(58)) + tmp59, err := lang.WithMeta(tmp57, tmp58.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp60 := lang.Apply(tmp56, []any{tmp59, v55}) + var v61 any = tmp60 + _ = v61 + // let binding "bfs" + tmp62 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp63 lang.FnFunc + tmp63 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v64 := args[0] + _ = v64 + v65 := args[1] + _ = v65 + var tmp66 any + { // let + // let binding "vec__708" + var v67 any = v65 + _ = v67 + // let binding "b" + tmp68 := checkDerefVar(var_glojure_DOT_core_nth) + tmp69 := lang.Apply(tmp68, []any{v67, int64(0), nil}) + var v70 any = tmp69 + _ = v70 + // let binding "v" + tmp71 := checkDerefVar(var_glojure_DOT_core_nth) + tmp72 := lang.Apply(tmp71, []any{v67, int64(1), nil}) + var v73 any = tmp72 + _ = v73 + // let binding "g" + tmp74 := checkDerefVar(var_glojure_DOT_core_nth) + tmp75 := lang.Apply(tmp74, []any{v67, int64(2), nil}) + var v76 any = tmp75 + _ = v76 + var tmp77 any + tmp78 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp79 := lang.Apply(tmp78, []any{v70}) + if lang.IsTruthy(tmp79) { + tmp80 := checkDerefVar(var_glojure_DOT_core_conj) + tmp81 := lang.Apply(tmp80, []any{v64, v76, v73}) + tmp77 = tmp81 + } else { + tmp82 := checkDerefVar(var_glojure_DOT_core_conj) + tmp83 := lang.Apply(tmp82, []any{v64, v76, v73, v70, v76}) + tmp77 = tmp83 + } + tmp66 = tmp77 + } // end let + return tmp66 + }) + tmp64 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4612), kw_column, int(28), kw_end_DASH_line, int(4615), kw_end_DASH_column, int(50)) + tmp65, err := lang.WithMeta(tmp63, tmp64.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp66 := lang.NewVector() + tmp67 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4616), kw_column, int(27), kw_end_DASH_line, int(4616), kw_end_DASH_column, int(28)) + tmp68, err := lang.WithMeta(tmp66, tmp67.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp69 := checkDerefVar(var_glojure_DOT_core_map) + tmp70 := checkDerefVar(var_glojure_DOT_core_vector) + tmp71 := lang.Apply(tmp69, []any{tmp70, v55, v52, v61}) + tmp72 := lang.Apply(tmp62, []any{tmp65, tmp68, tmp71}) + var v73 any = tmp72 + _ = v73 + tmp74 := checkDerefVar(var_glojure_DOT_core_seq) + tmp75 := checkDerefVar(var_glojure_DOT_core_concat) + tmp76 := checkDerefVar(var_glojure_DOT_core_list) + tmp77 := lang.Apply(tmp76, []any{sym_glojure_DOT_core_SLASH_let}) + tmp78 := checkDerefVar(var_glojure_DOT_core_list) + tmp79 := lang.Apply(tmp78, []any{v73}) + tmp80 := checkDerefVar(var_glojure_DOT_core_list) + tmp81 := checkDerefVar(var_glojure_DOT_core_seq) + tmp82 := checkDerefVar(var_glojure_DOT_core_concat) + tmp83 := checkDerefVar(var_glojure_DOT_core_list) + tmp84 := lang.Apply(tmp83, []any{sym_loop_STAR_}) + tmp85 := checkDerefVar(var_glojure_DOT_core_list) + tmp86 := checkDerefVar(var_glojure_DOT_core_vec) + tmp87 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp88 := lang.Apply(tmp87, []any{v61, v61}) + tmp89 := lang.Apply(tmp86, []any{tmp88}) + tmp90 := lang.Apply(tmp85, []any{tmp89}) + tmp91 := checkDerefVar(var_glojure_DOT_core_list) + tmp92 := checkDerefVar(var_glojure_DOT_core_seq) + tmp93 := checkDerefVar(var_glojure_DOT_core_concat) + tmp94 := checkDerefVar(var_glojure_DOT_core_list) + tmp95 := lang.Apply(tmp94, []any{sym_glojure_DOT_core_SLASH_let}) + tmp96 := checkDerefVar(var_glojure_DOT_core_list) + tmp97 := checkDerefVar(var_glojure_DOT_core_vec) + tmp98 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp99 := lang.Apply(tmp98, []any{v55, v61}) + tmp100 := lang.Apply(tmp97, []any{tmp99}) + tmp101 := lang.Apply(tmp96, []any{tmp100}) + tmp102 := lang.Apply(tmp93, []any{tmp95, tmp101, v5}) + tmp103 := lang.Apply(tmp92, []any{tmp102}) + tmp104 := lang.Apply(tmp91, []any{tmp103}) + tmp105 := lang.Apply(tmp82, []any{tmp84, tmp90, tmp104}) + tmp106 := lang.Apply(tmp81, []any{tmp105}) + tmp107 := lang.Apply(tmp80, []any{tmp106}) + tmp108 := lang.Apply(tmp75, []any{tmp77, tmp79, tmp107}) + tmp109 := lang.Apply(tmp74, []any{tmp108}) + tmp47 = tmp109 + } // end let + tmp36 = tmp47 + } + tmp32 = tmp36 + } // end let + return tmp32 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_loop = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_loop.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print-map + { + tmp0 := sym_print_DASH_map.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(252), kw_column, int(8), kw_end_DASH_line, int(252), kw_end_DASH_column, int(16), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_m, sym_print_DASH_one, sym_w)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_print_DASH_prefix_DASH_map) + tmp6 := lang.Apply(tmp5, []any{nil, v2, v3, v4}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_print_DASH_map = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_print_DASH_map.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + var closed11 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_seq_DASH_reduce) + tmp4 := lang.Apply(tmp3, []any{v1, v2}) + return tmp4 + case 3: + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + v3 := args[2] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_seq_DASH_reduce) + tmp5 := lang.Apply(tmp4, []any{v1, v2, v3}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + closed11 = tmp0 + } + var closed12 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_seq_DASH_reduce) + tmp4 := lang.Apply(tmp3, []any{v1, v2}) + return tmp4 + case 3: + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + v3 := args[2] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_seq_DASH_reduce) + tmp5 := lang.Apply(tmp4, []any{v1, v2, v3}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + closed12 = tmp0 + } + var closed14 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + v3 := args[2] + _ = v3 + recur_loop_1275: + var tmp4 any + { // let + // let binding "temp__0__auto__" + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := lang.Apply(tmp5, []any{v1}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + if lang.IsTruthy(v7) { + var tmp9 any + { // let + // let binding "s" + var v10 any = v7 + _ = v10 + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp13 := lang.Apply(tmp12, []any{v10}) + if lang.IsTruthy(tmp13) { + var tmp14 any + { // let + // let binding "ret" + tmp15 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp16 := lang.Apply(tmp15, []any{v10}) + tmp17, _ := lang.FieldOrMethod(tmp16, "ReduceInit") + if reflect.TypeOf(tmp17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) + } + tmp18 := lang.Apply(tmp17, []any{v2, v3}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + tmp21 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) + tmp22 := lang.Apply(tmp21, []any{v19}) + if lang.IsTruthy(tmp22) { + tmp23 := checkDerefVar(var_glojure_DOT_core_deref) + tmp24 := lang.Apply(tmp23, []any{v19}) + tmp20 = tmp24 + } else { + tmp26 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_next) + tmp27 := lang.Apply(tmp26, []any{v10}) + var tmp25 any = tmp27 + var tmp28 any = v2 + var tmp29 any = v19 + v1 = tmp25 + v2 = tmp28 + v3 = tmp29 + goto recur_loop_1275 + } + tmp14 = tmp20 + } // end let + tmp11 = tmp14 + } else { + tmp15 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_interface_DASH_or_DASH_naive_DASH_reduce) + tmp16 := lang.Apply(tmp15, []any{v10, v2, v3}) + tmp11 = tmp16 + } + tmp9 = tmp11 + } // end let + tmp8 = tmp9 + } else { + tmp8 = v3 + } + tmp4 = tmp8 + } // end let + return tmp4 + }) + closed14 = tmp0 + } + var closed15 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + v3 := args[2] + _ = v3 + var tmp4 any + { // let + // let binding "cls" + tmp5 := checkDerefVar(var_glojure_DOT_core_class) + tmp6 := lang.Apply(tmp5, []any{v1}) + var v7 any = tmp6 + _ = v7 + // let binding "s" + var v8 any = v1 + _ = v8 + // let binding "f" + var v9 any = v2 + _ = v9 + // let binding "val" + var v10 any = v3 + _ = v10 + for { + var tmp11 any + { // let + // let binding "temp__0__auto__" + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := lang.Apply(tmp12, []any{v8}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + var tmp16 any + { // let + // let binding "s" + var v17 any = v14 + _ = v17 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_identical_QMARK_) + tmp20 := checkDerefVar(var_glojure_DOT_core_class) + tmp21 := lang.Apply(tmp20, []any{v17}) + tmp22 := lang.Apply(tmp19, []any{tmp21, v7}) + if lang.IsTruthy(tmp22) { + var tmp23 any + { // let + // let binding "ret" + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v17}) + tmp26 := lang.Apply(v9, []any{v10, tmp25}) + var v27 any = tmp26 + _ = v27 + var tmp28 any + tmp29 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) + tmp30 := lang.Apply(tmp29, []any{v27}) + if lang.IsTruthy(tmp30) { + tmp31 := checkDerefVar(var_glojure_DOT_core_deref) + tmp32 := lang.Apply(tmp31, []any{v27}) + tmp28 = tmp32 + } else { + var tmp33 any = v7 + tmp35 := checkDerefVar(var_glojure_DOT_core_next) + tmp36 := lang.Apply(tmp35, []any{v17}) + var tmp34 any = tmp36 + var tmp37 any = v9 + var tmp38 any = v27 + v7 = tmp33 + v8 = tmp34 + v9 = tmp37 + v10 = tmp38 + continue + } + tmp23 = tmp28 + } // end let + tmp18 = tmp23 + } else { + tmp24 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_interface_DASH_or_DASH_naive_DASH_reduce) + tmp25 := lang.Apply(tmp24, []any{v17, v9, v10}) + tmp18 = tmp25 + } + tmp16 = tmp18 + } // end let + tmp15 = tmp16 + } else { + tmp15 = v10 + } + tmp11 = tmp15 + } // end let + tmp4 = tmp11 + break + } + } // end let + return tmp4 + }) + closed15 = tmp0 + } + // -protocols + { + tmp0 := sym__DASH_protocols.WithMeta(lang.NewMap(kw_private, true, kw_doc, "Private store of protocols. Go's reflection capabilities\n don't yet support a native interface-based implementation, so\n protocols are implemented in Glojure as maps from type to protocol\n method implementations.", kw_file, "glojure/core_deftype.glj", kw_line, int(21), kw_column, int(3), kw_end_DASH_line, int(26), kw_end_DASH_column, int(12), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v5 := args[0] + _ = v5 + var v6 any = lang.NewList(args[1:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_class) + tmp8 := lang.Apply(tmp7, []any{v5}) + return tmp8 + } + }) + tmp3 := lang.NewMultiFn("coll-reduce", tmp4, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v6 := args[0] + _ = v6 + var v7 any = lang.NewList(args[1:]...) + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_apply) + tmp9 := checkDerefVar(var_glojure_DOT_core_cons) + tmp10 := lang.Apply(tmp9, []any{v6, v7}) + tmp11 := lang.Apply(tmp8, []any{closed9, tmp10}) + return tmp11 + } + }) + tmp3.AddMethod(nil, tmp5) + tmp6 := reflect.TypeOf((*lang.IReduceInit)(nil)).Elem() + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v8 := args[0] + _ = v8 + var v9 any = lang.NewList(args[1:]...) + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_apply) + tmp11 := checkDerefVar(var_glojure_DOT_core_cons) + tmp12 := lang.Apply(tmp11, []any{v8, v9}) + tmp13 := lang.Apply(tmp10, []any{closed10, tmp12}) + return tmp13 + } + }) + tmp3.AddMethod(tmp6, tmp7) + tmp8 := reflect.TypeOf((*lang.LazySeq)(nil)) + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v10 := args[0] + _ = v10 + var v11 any = lang.NewList(args[1:]...) + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_apply) + tmp13 := checkDerefVar(var_glojure_DOT_core_cons) + tmp14 := lang.Apply(tmp13, []any{v10, v11}) + tmp15 := lang.Apply(tmp12, []any{closed11, tmp14}) + return tmp15 + } + }) + tmp3.AddMethod(tmp8, tmp9) + tmp10 := reflect.TypeOf((*lang.Vector)(nil)) + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v12 := args[0] + _ = v12 + var v13 any = lang.NewList(args[1:]...) + _ = v13 + tmp14 := checkDerefVar(var_glojure_DOT_core_apply) + tmp15 := checkDerefVar(var_glojure_DOT_core_cons) + tmp16 := lang.Apply(tmp15, []any{v12, v13}) + tmp17 := lang.Apply(tmp14, []any{closed12, tmp16}) + return tmp17 + } + }) + tmp3.AddMethod(tmp10, tmp11) + tmp2 := lang.NewAtom(lang.NewMap(kw_multis, lang.NewMap(kw_coll_DASH_reduce, tmp3), kw_on_DASH_interface, true, kw_sigs, lang.NewList(lang.NewList(sym_coll_DASH_reduce, lang.NewVector(sym_coll, sym_f), lang.NewVector(sym_coll, sym_f, sym_val))))) + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v15 := args[0] + _ = v15 + var v16 any = lang.NewList(args[1:]...) + _ = v16 + tmp17 := checkDerefVar(var_glojure_DOT_core_class) + tmp18 := lang.Apply(tmp17, []any{v15}) + return tmp18 + } + }) + tmp13 := lang.NewMultiFn("internal-reduce", tmp14, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) + var tmp15 lang.FnFunc + tmp15 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v16 := args[0] + _ = v16 + var v17 any = lang.NewList(args[1:]...) + _ = v17 + tmp18 := checkDerefVar(var_glojure_DOT_core_apply) + tmp19 := checkDerefVar(var_glojure_DOT_core_cons) + tmp20 := lang.Apply(tmp19, []any{v16, v17}) + tmp21 := lang.Apply(tmp18, []any{closed13, tmp20}) + return tmp21 + } + }) + tmp13.AddMethod(nil, tmp15) + tmp16 := reflect.TypeOf((*lang.IChunkedSeq)(nil)).Elem() + var tmp17 lang.FnFunc + tmp17 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v18 := args[0] + _ = v18 + var v19 any = lang.NewList(args[1:]...) + _ = v19 + tmp20 := checkDerefVar(var_glojure_DOT_core_apply) + tmp21 := checkDerefVar(var_glojure_DOT_core_cons) + tmp22 := lang.Apply(tmp21, []any{v18, v19}) + tmp23 := lang.Apply(tmp20, []any{closed14, tmp22}) + return tmp23 + } + }) + tmp13.AddMethod(tmp16, tmp17) + tmp18 := reflect.TypeOf((*lang.Object)(nil)).Elem() + var tmp19 lang.FnFunc + tmp19 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v20 := args[0] + _ = v20 + var v21 any = lang.NewList(args[1:]...) + _ = v21 + tmp22 := checkDerefVar(var_glojure_DOT_core_apply) + tmp23 := checkDerefVar(var_glojure_DOT_core_cons) + tmp24 := lang.Apply(tmp23, []any{v20, v21}) + tmp25 := lang.Apply(tmp22, []any{closed15, tmp24}) + return tmp25 + } + }) + tmp13.AddMethod(tmp18, tmp19) + tmp12 := lang.NewAtom(lang.NewMap(kw_multis, lang.NewMap(kw_internal_DASH_reduce, tmp13), kw_on_DASH_interface, true, kw_sigs, lang.NewList(lang.NewList(sym_internal_DASH_reduce, lang.NewVector(sym_seq, sym_f, sym_start))))) + var tmp22 lang.FnFunc + tmp22 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v23 := args[0] + _ = v23 + var v24 any = lang.NewList(args[1:]...) + _ = v24 + tmp25 := checkDerefVar(var_glojure_DOT_core_class) + tmp26 := lang.Apply(tmp25, []any{v23}) + return tmp26 + } + }) + tmp21 := lang.NewMultiFn("kv-reduce", tmp22, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) + tmp20 := lang.NewAtom(lang.NewMap(kw_multis, lang.NewMap(kw_kv_DASH_reduce, tmp21), kw_on_DASH_interface, true, kw_sigs, lang.NewList(lang.NewList(sym_kv_DASH_reduce, lang.NewVector(sym_amap, sym_f, sym_init))))) + var tmp25 lang.FnFunc + tmp25 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v26 := args[0] + _ = v26 + var v27 any = lang.NewList(args[1:]...) + _ = v27 + tmp28 := checkDerefVar(var_glojure_DOT_core_class) + tmp29 := lang.Apply(tmp28, []any{v26}) + return tmp29 + } + }) + tmp24 := lang.NewMultiFn("datafy", tmp25, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) + var tmp26 lang.FnFunc + tmp26 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v27 := args[0] + _ = v27 + var v28 any = lang.NewList(args[1:]...) + _ = v28 + tmp29 := checkDerefVar(var_glojure_DOT_core_apply) + tmp30 := checkDerefVar(var_glojure_DOT_core_cons) + tmp31 := lang.Apply(tmp30, []any{v27, v28}) + tmp32 := lang.Apply(tmp29, []any{closed16, tmp31}) + return tmp32 + } + }) + tmp24.AddMethod(nil, tmp26) + tmp23 := lang.NewAtom(lang.NewMap(kw_multis, lang.NewMap(kw_datafy, tmp24), kw_on_DASH_interface, true, kw_sigs, lang.NewList(lang.NewList(sym_datafy, lang.NewVector(sym_o), "return a representation of o as data (default identity)")))) + var tmp29 lang.FnFunc + tmp29 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v30 := args[0] + _ = v30 + var v31 any = lang.NewList(args[1:]...) + _ = v31 + tmp32 := checkDerefVar(var_glojure_DOT_core_class) + tmp33 := lang.Apply(tmp32, []any{v30}) + return tmp33 + } + }) + tmp28 := lang.NewMultiFn("nav", tmp29, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) + tmp27 := lang.NewAtom(lang.NewMap(kw_multis, lang.NewMap(kw_nav, tmp28), kw_on_DASH_interface, true, kw_sigs, lang.NewList(lang.NewList(sym_nav, lang.NewVector(sym_coll, sym_k, sym_v), "return (possibly transformed) v in the context of coll and k (a key/index or nil),\ndefaults to returning v.")))) + tmp1 := lang.NewAtom(lang.NewMap(sym_CollReduce, tmp2, sym_InternalReduce, tmp12, sym_IKVReduce, tmp20, sym_Datafiable, tmp23, sym_Navigable, tmp27)) + var_glojure_DOT_core__DASH_protocols = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core__DASH_protocols.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // add-classpath + { + tmp0 := sym_add_DASH_classpath.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_url)), kw_doc, "DEPRECATED \n\n Adds the url (String or URL object) to the classpath per\n URLClassLoader.addURL", kw_file, "glojure/core.glj", kw_deprecated, "1.1", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(5176), kw_end_DASH_line, int(5176))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_println) + tmp4 := lang.Apply(tmp3, []any{"WARNING: add-classpath is deprecated"}) + _ = tmp4 + tmp5 := lang.Apply(nil, []any{v2}) + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_add_DASH_classpath = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_add_DASH_classpath.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // case + { + tmp0 := sym_case.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_e, sym__AMP_, sym_clauses)), kw_doc, "Takes an expression, and a set of clauses.\n\n Each clause can take the form of either:\n\n test-constant result-expr\n\n (test-constant1 ... test-constantN) result-expr\n\n The test-constants are not evaluated. They must be compile-time\n literals, and need not be quoted. If the expression is equal to a\n test-constant, the corresponding result-expr is returned. A single\n default expression can follow the clauses, and its value will be\n returned if no clause matches. If no default expression is provided\n and no clause matches, an IllegalArgumentException is thrown.\n\n Unlike cond and condp, case does a constant-time dispatch, the\n clauses are not considered sequentially. All manner of constant\n expressions are acceptable in case, including numbers, strings,\n symbols, keywords, and (Clojure) composites thereof. Note that since\n lists are used to group multiple constants that map to the same\n expression, a vector can be used to match a list if needed. The\n test-constants need not be all of the same type.", kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(11), kw_line, int(6712), kw_end_DASH_line, int(6712))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + var tmp6 any + { // let + // let binding "ge" + tmp7 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp8 := checkDerefVar(var_glojure_DOT_core_gensym) + tmp9 := lang.Apply(tmp8, nil) + tmp10 := reflect.TypeOf((*lang.Object)(nil)).Elem() + tmp11 := lang.NewMap(kw_tag, tmp10) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6738), kw_column, int(32), kw_end_DASH_line, int(6738), kw_end_DASH_column, int(84)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp14 := lang.Apply(tmp7, []any{tmp9, tmp13}) + var v15 any = tmp14 + _ = v15 + // let binding "default" + var tmp16 any + tmp17 := checkDerefVar(var_glojure_DOT_core_odd_QMARK_) + tmp18 := checkDerefVar(var_glojure_DOT_core_count) + tmp19 := lang.Apply(tmp18, []any{v5}) + tmp20 := lang.Apply(tmp17, []any{tmp19}) + if lang.IsTruthy(tmp20) { + tmp21 := checkDerefVar(var_glojure_DOT_core_last) + tmp22 := lang.Apply(tmp21, []any{v5}) + tmp16 = tmp22 + } else { + tmp23 := checkDerefVar(var_glojure_DOT_core_seq) + tmp24 := checkDerefVar(var_glojure_DOT_core_concat) + tmp25 := checkDerefVar(var_glojure_DOT_core_list) + tmp26 := lang.Apply(tmp25, []any{sym_throw}) + tmp27 := checkDerefVar(var_glojure_DOT_core_list) + tmp28 := checkDerefVar(var_glojure_DOT_core_seq) + tmp29 := checkDerefVar(var_glojure_DOT_core_concat) + tmp30 := checkDerefVar(var_glojure_DOT_core_list) + tmp31 := lang.Apply(tmp30, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_NewIllegalArgumentError}) + tmp32 := checkDerefVar(var_glojure_DOT_core_list) + tmp33 := checkDerefVar(var_glojure_DOT_core_seq) + tmp34 := checkDerefVar(var_glojure_DOT_core_concat) + tmp35 := checkDerefVar(var_glojure_DOT_core_list) + tmp36 := lang.Apply(tmp35, []any{sym_glojure_DOT_core_SLASH_str}) + tmp37 := checkDerefVar(var_glojure_DOT_core_list) + tmp38 := lang.Apply(tmp37, []any{"No matching clause: "}) + tmp39 := checkDerefVar(var_glojure_DOT_core_list) + tmp40 := lang.Apply(tmp39, []any{v15}) + tmp41 := lang.Apply(tmp34, []any{tmp36, tmp38, tmp40}) + tmp42 := lang.Apply(tmp33, []any{tmp41}) + tmp43 := lang.Apply(tmp32, []any{tmp42}) + tmp44 := lang.Apply(tmp29, []any{tmp31, tmp43}) + tmp45 := lang.Apply(tmp28, []any{tmp44}) + tmp46 := lang.Apply(tmp27, []any{tmp45}) + tmp47 := lang.Apply(tmp24, []any{tmp26, tmp46}) + tmp48 := lang.Apply(tmp23, []any{tmp47}) + tmp16 = tmp48 + } + var v49 any = tmp16 + _ = v49 + var tmp50 any + tmp51 := checkDerefVar(var_glojure_DOT_core__GT_) + tmp52 := checkDerefVar(var_glojure_DOT_core_count) + tmp53 := lang.Apply(tmp52, []any{v5}) + tmp54 := lang.Apply(tmp51, []any{int64(2), tmp53}) + if lang.IsTruthy(tmp54) { + tmp55 := checkDerefVar(var_glojure_DOT_core_seq) + tmp56 := checkDerefVar(var_glojure_DOT_core_concat) + tmp57 := checkDerefVar(var_glojure_DOT_core_list) + tmp58 := lang.Apply(tmp57, []any{sym_glojure_DOT_core_SLASH_let}) + tmp59 := checkDerefVar(var_glojure_DOT_core_list) + tmp60 := checkDerefVar(var_glojure_DOT_core_apply) + tmp61 := checkDerefVar(var_glojure_DOT_core_vector) + tmp62 := checkDerefVar(var_glojure_DOT_core_seq) + tmp63 := checkDerefVar(var_glojure_DOT_core_concat) + tmp64 := checkDerefVar(var_glojure_DOT_core_list) + tmp65 := lang.Apply(tmp64, []any{v15}) + tmp66 := checkDerefVar(var_glojure_DOT_core_list) + tmp67 := lang.Apply(tmp66, []any{v4}) + tmp68 := lang.Apply(tmp63, []any{tmp65, tmp67}) + tmp69 := lang.Apply(tmp62, []any{tmp68}) + tmp70 := lang.Apply(tmp60, []any{tmp61, tmp69}) + tmp71 := lang.Apply(tmp59, []any{tmp70}) + tmp72 := checkDerefVar(var_glojure_DOT_core_list) + tmp73 := lang.Apply(tmp72, []any{v49}) + tmp74 := lang.Apply(tmp56, []any{tmp58, tmp71, tmp73}) + tmp75 := lang.Apply(tmp55, []any{tmp74}) + tmp50 = tmp75 + } else { + var tmp76 any + { // let + // let binding "pairs" + tmp77 := checkDerefVar(var_glojure_DOT_core_partition) + tmp78 := lang.Apply(tmp77, []any{int64(2), v5}) + var v79 any = tmp78 + _ = v79 + // let binding "assoc-test" + var tmp80 lang.FnFunc + { // function assoc-test + var v81 lang.FnFunc + tmp80 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v82 := args[0] + _ = v82 + v83 := args[1] + _ = v83 + v84 := args[2] + _ = v84 + var tmp85 any + tmp86 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp87 := lang.Apply(tmp86, []any{v82, v83}) + if lang.IsTruthy(tmp87) { + tmp88 := checkDerefVar(var_glojure_DOT_core_str) + tmp89 := lang.Apply(tmp88, []any{"Duplicate case test constant: ", v83}) + tmp90 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp89}) + panic(tmp90) + } else { + tmp91 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp92 := lang.Apply(tmp91, []any{v82, v83, v84}) + tmp85 = tmp92 + } + return tmp85 + }) + v81 = tmp80 + _ = v81 + } + tmp81 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6745), kw_column, int(24), kw_end_DASH_line, int(6748), kw_end_DASH_column, int(48)) + tmp82, err := lang.WithMeta(tmp80, tmp81.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v83 any = tmp82 + _ = v83 + // let binding "pairs" + tmp84 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp85 lang.FnFunc + tmp85 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v86 := args[0] + _ = v86 + v87 := args[1] + _ = v87 + var tmp88 any + { // let + // let binding "vec__868" + var v89 any = v87 + _ = v89 + // let binding "test" + tmp90 := checkDerefVar(var_glojure_DOT_core_nth) + tmp91 := lang.Apply(tmp90, []any{v89, int64(0), nil}) + var v92 any = tmp91 + _ = v92 + // let binding "expr" + tmp93 := checkDerefVar(var_glojure_DOT_core_nth) + tmp94 := lang.Apply(tmp93, []any{v89, int64(1), nil}) + var v95 any = tmp94 + _ = v95 + var tmp96 any + tmp97 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp98 := lang.Apply(tmp97, []any{v92}) + if lang.IsTruthy(tmp98) { + tmp99 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp100 lang.FnFunc + tmp100 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v101 := args[0] + _ = v101 + v102 := args[1] + _ = v102 + tmp103 := lang.Apply(v83, []any{v101, v102, v95}) + return tmp103 + }) + tmp101 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6752), kw_column, int(37), kw_end_DASH_line, int(6752), kw_end_DASH_column, int(60)) + tmp102, err := lang.WithMeta(tmp100, tmp101.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp103 := lang.Apply(tmp99, []any{tmp102, v86, v92}) + tmp96 = tmp103 + } else { + tmp104 := lang.Apply(v83, []any{v86, v92, v95}) + tmp96 = tmp104 + } + tmp88 = tmp96 + } // end let + return tmp88 + }) + tmp86 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6750), kw_column, int(24), kw_end_DASH_line, int(6753), kw_end_DASH_column, int(53)) + tmp87, err := lang.WithMeta(tmp85, tmp86.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp88 := lang.NewMap() + tmp89 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6754), kw_column, int(24), kw_end_DASH_line, int(6754), kw_end_DASH_column, int(25)) + tmp90, err := lang.WithMeta(tmp88, tmp89.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp91 := lang.Apply(tmp84, []any{tmp87, tmp90, v79}) + var v92 any = tmp91 + _ = v92 + // let binding "tests" + tmp93 := checkDerefVar(var_glojure_DOT_core_keys) + tmp94 := lang.Apply(tmp93, []any{v92}) + var v95 any = tmp94 + _ = v95 + // let binding "thens" + tmp96 := checkDerefVar(var_glojure_DOT_core_vals) + tmp97 := lang.Apply(tmp96, []any{v92}) + var v98 any = tmp97 + _ = v98 + // let binding "mode" + var tmp99 any + tmp100 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + var tmp101 lang.FnFunc + tmp101 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v102 := args[0] + _ = v102 + var tmp103 any + { // let + // let binding "and__0__auto__" + tmp104 := checkDerefVar(var_glojure_DOT_core_integer_QMARK_) + tmp105 := lang.Apply(tmp104, []any{v102}) + var v106 any = tmp105 + _ = v106 + var tmp107 any + if lang.IsTruthy(v106) { + tmp108 := checkDerefVar(var_glojure_DOT_core__LT__EQ_) + tmp109 := lang.Apply(tmp108, []any{math4.MinInt, v102, math4.MaxInt}) + tmp107 = tmp109 + } else { + tmp107 = v106 + } + tmp103 = tmp107 + } // end let + return tmp103 + }) + tmp102 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6758), kw_column, int(28), kw_end_DASH_line, int(6758), kw_end_DASH_column, int(77)) + tmp103, err := lang.WithMeta(tmp101, tmp102.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp104 := lang.Apply(tmp100, []any{tmp103, v95}) + if lang.IsTruthy(tmp104) { + tmp99 = kw_ints + } else { + var tmp105 any + tmp106 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) + tmp107 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp108 := lang.Apply(tmp106, []any{tmp107, v95}) + if lang.IsTruthy(tmp108) { + tmp105 = kw_identity + } else { + var tmp109 any + if lang.IsTruthy(kw_else) { + tmp109 = kw_hashes + } else { + } + tmp105 = tmp109 + } + tmp99 = tmp105 + } + var v110 any = tmp99 + _ = v110 + var tmp111 any + { // let + // let binding "pred__871" + tmp112 := checkDerefVar(var_glojure_DOT_core__EQ_) + var v113 any = tmp112 + _ = v113 + // let binding "expr__872" + var v114 any = v110 + _ = v114 + var tmp115 any + tmp116 := lang.Apply(v113, []any{kw_ints, v114}) + if lang.IsTruthy(tmp116) { + var tmp117 any + { // let + // let binding "vec__873" + tmp118 := checkDerefVar(var_glojure_DOT_core_prep_DASH_ints) + tmp119 := lang.Apply(tmp118, []any{v95, v98}) + var v120 any = tmp119 + _ = v120 + // let binding "shift" + tmp121 := checkDerefVar(var_glojure_DOT_core_nth) + tmp122 := lang.Apply(tmp121, []any{v120, int64(0), nil}) + var v123 any = tmp122 + _ = v123 + // let binding "mask" + tmp124 := checkDerefVar(var_glojure_DOT_core_nth) + tmp125 := lang.Apply(tmp124, []any{v120, int64(1), nil}) + var v126 any = tmp125 + _ = v126 + // let binding "imap" + tmp127 := checkDerefVar(var_glojure_DOT_core_nth) + tmp128 := lang.Apply(tmp127, []any{v120, int64(2), nil}) + var v129 any = tmp128 + _ = v129 + // let binding "switch-type" + tmp130 := checkDerefVar(var_glojure_DOT_core_nth) + tmp131 := lang.Apply(tmp130, []any{v120, int64(3), nil}) + var v132 any = tmp131 + _ = v132 + tmp133 := checkDerefVar(var_glojure_DOT_core_seq) + tmp134 := checkDerefVar(var_glojure_DOT_core_concat) + tmp135 := checkDerefVar(var_glojure_DOT_core_list) + tmp136 := lang.Apply(tmp135, []any{sym_glojure_DOT_core_SLASH_let}) + tmp137 := checkDerefVar(var_glojure_DOT_core_list) + tmp138 := checkDerefVar(var_glojure_DOT_core_apply) + tmp139 := checkDerefVar(var_glojure_DOT_core_vector) + tmp140 := checkDerefVar(var_glojure_DOT_core_seq) + tmp141 := checkDerefVar(var_glojure_DOT_core_concat) + tmp142 := checkDerefVar(var_glojure_DOT_core_list) + tmp143 := lang.Apply(tmp142, []any{v15}) + tmp144 := checkDerefVar(var_glojure_DOT_core_list) + tmp145 := lang.Apply(tmp144, []any{v4}) + tmp146 := lang.Apply(tmp141, []any{tmp143, tmp145}) + tmp147 := lang.Apply(tmp140, []any{tmp146}) + tmp148 := lang.Apply(tmp138, []any{tmp139, tmp147}) + tmp149 := lang.Apply(tmp137, []any{tmp148}) + tmp150 := checkDerefVar(var_glojure_DOT_core_list) + tmp151 := checkDerefVar(var_glojure_DOT_core_seq) + tmp152 := checkDerefVar(var_glojure_DOT_core_concat) + tmp153 := checkDerefVar(var_glojure_DOT_core_list) + tmp154 := lang.Apply(tmp153, []any{sym_case_STAR_}) + tmp155 := checkDerefVar(var_glojure_DOT_core_list) + tmp156 := lang.Apply(tmp155, []any{v15}) + tmp157 := checkDerefVar(var_glojure_DOT_core_list) + tmp158 := lang.Apply(tmp157, []any{v123}) + tmp159 := checkDerefVar(var_glojure_DOT_core_list) + tmp160 := lang.Apply(tmp159, []any{v126}) + tmp161 := checkDerefVar(var_glojure_DOT_core_list) + tmp162 := lang.Apply(tmp161, []any{v49}) + tmp163 := checkDerefVar(var_glojure_DOT_core_list) + tmp164 := lang.Apply(tmp163, []any{v129}) + tmp165 := checkDerefVar(var_glojure_DOT_core_list) + tmp166 := lang.Apply(tmp165, []any{v132}) + tmp167 := checkDerefVar(var_glojure_DOT_core_list) + tmp168 := lang.Apply(tmp167, []any{kw_int}) + tmp169 := lang.Apply(tmp152, []any{tmp154, tmp156, tmp158, tmp160, tmp162, tmp164, tmp166, tmp168}) + tmp170 := lang.Apply(tmp151, []any{tmp169}) + tmp171 := lang.Apply(tmp150, []any{tmp170}) + tmp172 := lang.Apply(tmp134, []any{tmp136, tmp149, tmp171}) + tmp173 := lang.Apply(tmp133, []any{tmp172}) + tmp117 = tmp173 + } // end let + tmp115 = tmp117 + } else { + var tmp118 any + tmp119 := lang.Apply(v113, []any{kw_hashes, v114}) + if lang.IsTruthy(tmp119) { + var tmp120 any + { // let + // let binding "vec__876" + tmp121 := checkDerefVar(var_glojure_DOT_core_prep_DASH_hashes) + tmp122 := lang.Apply(tmp121, []any{v15, v49, v95, v98}) + var v123 any = tmp122 + _ = v123 + // let binding "shift" + tmp124 := checkDerefVar(var_glojure_DOT_core_nth) + tmp125 := lang.Apply(tmp124, []any{v123, int64(0), nil}) + var v126 any = tmp125 + _ = v126 + // let binding "mask" + tmp127 := checkDerefVar(var_glojure_DOT_core_nth) + tmp128 := lang.Apply(tmp127, []any{v123, int64(1), nil}) + var v129 any = tmp128 + _ = v129 + // let binding "imap" + tmp130 := checkDerefVar(var_glojure_DOT_core_nth) + tmp131 := lang.Apply(tmp130, []any{v123, int64(2), nil}) + var v132 any = tmp131 + _ = v132 + // let binding "switch-type" + tmp133 := checkDerefVar(var_glojure_DOT_core_nth) + tmp134 := lang.Apply(tmp133, []any{v123, int64(3), nil}) + var v135 any = tmp134 + _ = v135 + // let binding "skip-check" + tmp136 := checkDerefVar(var_glojure_DOT_core_nth) + tmp137 := lang.Apply(tmp136, []any{v123, int64(4), nil}) + var v138 any = tmp137 + _ = v138 + tmp139 := checkDerefVar(var_glojure_DOT_core_seq) + tmp140 := checkDerefVar(var_glojure_DOT_core_concat) + tmp141 := checkDerefVar(var_glojure_DOT_core_list) + tmp142 := lang.Apply(tmp141, []any{sym_glojure_DOT_core_SLASH_let}) + tmp143 := checkDerefVar(var_glojure_DOT_core_list) + tmp144 := checkDerefVar(var_glojure_DOT_core_apply) + tmp145 := checkDerefVar(var_glojure_DOT_core_vector) + tmp146 := checkDerefVar(var_glojure_DOT_core_seq) + tmp147 := checkDerefVar(var_glojure_DOT_core_concat) + tmp148 := checkDerefVar(var_glojure_DOT_core_list) + tmp149 := lang.Apply(tmp148, []any{v15}) + tmp150 := checkDerefVar(var_glojure_DOT_core_list) + tmp151 := lang.Apply(tmp150, []any{v4}) + tmp152 := lang.Apply(tmp147, []any{tmp149, tmp151}) + tmp153 := lang.Apply(tmp146, []any{tmp152}) + tmp154 := lang.Apply(tmp144, []any{tmp145, tmp153}) + tmp155 := lang.Apply(tmp143, []any{tmp154}) + tmp156 := checkDerefVar(var_glojure_DOT_core_list) + tmp157 := checkDerefVar(var_glojure_DOT_core_seq) + tmp158 := checkDerefVar(var_glojure_DOT_core_concat) + tmp159 := checkDerefVar(var_glojure_DOT_core_list) + tmp160 := lang.Apply(tmp159, []any{sym_case_STAR_}) + tmp161 := checkDerefVar(var_glojure_DOT_core_list) + tmp162 := lang.Apply(tmp161, []any{v15}) + tmp163 := checkDerefVar(var_glojure_DOT_core_list) + tmp164 := lang.Apply(tmp163, []any{v126}) + tmp165 := checkDerefVar(var_glojure_DOT_core_list) + tmp166 := lang.Apply(tmp165, []any{v129}) + tmp167 := checkDerefVar(var_glojure_DOT_core_list) + tmp168 := lang.Apply(tmp167, []any{v49}) + tmp169 := checkDerefVar(var_glojure_DOT_core_list) + tmp170 := lang.Apply(tmp169, []any{v132}) + tmp171 := checkDerefVar(var_glojure_DOT_core_list) + tmp172 := lang.Apply(tmp171, []any{v135}) + tmp173 := checkDerefVar(var_glojure_DOT_core_list) + tmp174 := lang.Apply(tmp173, []any{kw_hash_DASH_equiv}) + tmp175 := checkDerefVar(var_glojure_DOT_core_list) + tmp176 := lang.Apply(tmp175, []any{v138}) + tmp177 := lang.Apply(tmp158, []any{tmp160, tmp162, tmp164, tmp166, tmp168, tmp170, tmp172, tmp174, tmp176}) + tmp178 := lang.Apply(tmp157, []any{tmp177}) + tmp179 := lang.Apply(tmp156, []any{tmp178}) + tmp180 := lang.Apply(tmp140, []any{tmp142, tmp155, tmp179}) + tmp181 := lang.Apply(tmp139, []any{tmp180}) + tmp120 = tmp181 + } // end let + tmp118 = tmp120 + } else { + var tmp121 any + tmp122 := lang.Apply(v113, []any{kw_identity, v114}) + if lang.IsTruthy(tmp122) { + var tmp123 any + { // let + // let binding "vec__879" + tmp124 := checkDerefVar(var_glojure_DOT_core_prep_DASH_hashes) + tmp125 := lang.Apply(tmp124, []any{v15, v49, v95, v98}) + var v126 any = tmp125 + _ = v126 + // let binding "shift" + tmp127 := checkDerefVar(var_glojure_DOT_core_nth) + tmp128 := lang.Apply(tmp127, []any{v126, int64(0), nil}) + var v129 any = tmp128 + _ = v129 + // let binding "mask" + tmp130 := checkDerefVar(var_glojure_DOT_core_nth) + tmp131 := lang.Apply(tmp130, []any{v126, int64(1), nil}) + var v132 any = tmp131 + _ = v132 + // let binding "imap" + tmp133 := checkDerefVar(var_glojure_DOT_core_nth) + tmp134 := lang.Apply(tmp133, []any{v126, int64(2), nil}) + var v135 any = tmp134 + _ = v135 + // let binding "switch-type" + tmp136 := checkDerefVar(var_glojure_DOT_core_nth) + tmp137 := lang.Apply(tmp136, []any{v126, int64(3), nil}) + var v138 any = tmp137 + _ = v138 + // let binding "skip-check" + tmp139 := checkDerefVar(var_glojure_DOT_core_nth) + tmp140 := lang.Apply(tmp139, []any{v126, int64(4), nil}) + var v141 any = tmp140 + _ = v141 + tmp142 := checkDerefVar(var_glojure_DOT_core_seq) + tmp143 := checkDerefVar(var_glojure_DOT_core_concat) + tmp144 := checkDerefVar(var_glojure_DOT_core_list) + tmp145 := lang.Apply(tmp144, []any{sym_glojure_DOT_core_SLASH_let}) + tmp146 := checkDerefVar(var_glojure_DOT_core_list) + tmp147 := checkDerefVar(var_glojure_DOT_core_apply) + tmp148 := checkDerefVar(var_glojure_DOT_core_vector) + tmp149 := checkDerefVar(var_glojure_DOT_core_seq) + tmp150 := checkDerefVar(var_glojure_DOT_core_concat) + tmp151 := checkDerefVar(var_glojure_DOT_core_list) + tmp152 := lang.Apply(tmp151, []any{v15}) + tmp153 := checkDerefVar(var_glojure_DOT_core_list) + tmp154 := lang.Apply(tmp153, []any{v4}) + tmp155 := lang.Apply(tmp150, []any{tmp152, tmp154}) + tmp156 := lang.Apply(tmp149, []any{tmp155}) + tmp157 := lang.Apply(tmp147, []any{tmp148, tmp156}) + tmp158 := lang.Apply(tmp146, []any{tmp157}) + tmp159 := checkDerefVar(var_glojure_DOT_core_list) + tmp160 := checkDerefVar(var_glojure_DOT_core_seq) + tmp161 := checkDerefVar(var_glojure_DOT_core_concat) + tmp162 := checkDerefVar(var_glojure_DOT_core_list) + tmp163 := lang.Apply(tmp162, []any{sym_case_STAR_}) + tmp164 := checkDerefVar(var_glojure_DOT_core_list) + tmp165 := lang.Apply(tmp164, []any{v15}) + tmp166 := checkDerefVar(var_glojure_DOT_core_list) + tmp167 := lang.Apply(tmp166, []any{v129}) + tmp168 := checkDerefVar(var_glojure_DOT_core_list) + tmp169 := lang.Apply(tmp168, []any{v132}) + tmp170 := checkDerefVar(var_glojure_DOT_core_list) + tmp171 := lang.Apply(tmp170, []any{v49}) + tmp172 := checkDerefVar(var_glojure_DOT_core_list) + tmp173 := lang.Apply(tmp172, []any{v135}) + tmp174 := checkDerefVar(var_glojure_DOT_core_list) + tmp175 := lang.Apply(tmp174, []any{v138}) + tmp176 := checkDerefVar(var_glojure_DOT_core_list) + tmp177 := lang.Apply(tmp176, []any{kw_hash_DASH_identity}) + tmp178 := checkDerefVar(var_glojure_DOT_core_list) + tmp179 := lang.Apply(tmp178, []any{v141}) + tmp180 := lang.Apply(tmp161, []any{tmp163, tmp165, tmp167, tmp169, tmp171, tmp173, tmp175, tmp177, tmp179}) + tmp181 := lang.Apply(tmp160, []any{tmp180}) + tmp182 := lang.Apply(tmp159, []any{tmp181}) + tmp183 := lang.Apply(tmp143, []any{tmp145, tmp158, tmp182}) + tmp184 := lang.Apply(tmp142, []any{tmp183}) + tmp123 = tmp184 + } // end let + tmp121 = tmp123 + } else { + tmp124 := checkDerefVar(var_glojure_DOT_core_str) + tmp125 := lang.Apply(tmp124, []any{"No matching clause: ", v114}) + tmp126 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp125}) + panic(tmp126) + } + tmp118 = tmp121 + } + tmp115 = tmp118 + } + tmp111 = tmp115 + } // end let + tmp76 = tmp111 + } // end let + tmp50 = tmp76 + } + tmp6 = tmp50 + } // end let + return tmp6 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_case = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_case.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // cat + { + tmp0 := sym_cat.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_rf)), kw_doc, "A transducer which concatenates the contents of each input, which must be a\n collection, into the reduction.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(7645), kw_end_DASH_line, int(7645))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "rrf" + tmp4 := checkDerefVar(var_glojure_DOT_core_preserving_DASH_reduced) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp8 := lang.Apply(v2, nil) + return tmp8 + case 1: + v8 := args[0] + _ = v8 + tmp9 := lang.Apply(v2, []any{v8}) + return tmp9 + case 2: + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_reduce) + tmp11 := lang.Apply(tmp10, []any{v6, v8, v9}) + return tmp11 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7651), kw_column, int(5), kw_end_DASH_line, int(7655), kw_end_DASH_column, int(36)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp3 = tmp9 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_cat = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_cat.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // mapcat + { + tmp0 := sym_mapcat.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym__AMP_, sym_colls)), kw_doc, "Returns the result of applying concat to the result of applying map\n to f and colls. Thus function f should return a collection. Returns\n a transducer when no collections are provided", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(2775), kw_end_DASH_line, int(2775))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_comp) + tmp4 := checkDerefVar(var_glojure_DOT_core_map) + tmp5 := lang.Apply(tmp4, []any{v2}) + tmp6 := checkDerefVar(var_glojure_DOT_core_cat) + tmp7 := lang.Apply(tmp3, []any{tmp5, tmp6}) + return tmp7 + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_apply) + tmp5 := checkDerefVar(var_glojure_DOT_core_concat) + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_map) + tmp8 := lang.Apply(tmp6, []any{tmp7, v2, v3}) + tmp9 := lang.Apply(tmp4, []any{tmp5, tmp8}) + return tmp9 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_mapcat = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_mapcat.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // merge-hash-collisions + { + tmp0 := sym_merge_DASH_hash_DASH_collisions.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_expr_DASH_sym, sym_default, sym_tests, sym_thens)), kw_doc, "Takes a case expression, default expression, and a sequence of test constants\n and a corresponding sequence of then expressions. Returns a tuple of\n [tests thens skip-check-set] where no tests have the same hash. Each set of\n input test constants with the same hash is replaced with a single test\n constant (the case int), and their respective thens are combined into:\n (condp = expr\n test-1 then-1\n ...\n test-n then-n\n default).\n The skip-check is a set of case ints for which post-switch equivalence\n checking must not be done (the cases holding the above condp thens).", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(28), kw_column, int(8), kw_line, int(6647), kw_end_DASH_line, int(6647), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var tmp6 any + { // let + // let binding "buckets" + var tmp7 any + { // let + // let binding "m" + tmp8 := lang.NewMap() + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6661), kw_column, int(26), kw_end_DASH_line, int(6661), kw_end_DASH_column, int(27)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v11 any = tmp10 + _ = v11 + // let binding "ks" + var v12 any = v4 + _ = v12 + // let binding "vs" + var v13 any = v5 + _ = v13 + for { + var tmp14 any + var tmp15 any + { // let + // let binding "and__0__auto__" + var v16 any = v12 + _ = v16 + var tmp17 any + if lang.IsTruthy(v16) { + tmp17 = v13 + } else { + tmp17 = v16 + } + tmp15 = tmp17 + } // end let + if lang.IsTruthy(tmp15) { + tmp17 := checkDerefVar(var_glojure_DOT_core_update) + tmp18 := checkDerefVar(var_glojure_DOT_core_first) + tmp19 := lang.Apply(tmp18, []any{v12}) + tmp20 := lang.Apply(lang.Hash, []any{tmp19}) + tmp21 := checkDerefVar(var_glojure_DOT_core_fnil) + tmp22 := checkDerefVar(var_glojure_DOT_core_conj) + tmp23 := lang.NewVector() + tmp24 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6664), kw_column, int(102), kw_end_DASH_line, int(6664), kw_end_DASH_column, int(103)) + tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp26 := lang.Apply(tmp21, []any{tmp22, tmp25}) + tmp27 := checkDerefVar(var_glojure_DOT_core_first) + tmp28 := lang.Apply(tmp27, []any{v12}) + tmp29 := checkDerefVar(var_glojure_DOT_core_first) + tmp30 := lang.Apply(tmp29, []any{v13}) + tmp31 := lang.NewVector(tmp28, tmp30) + tmp32 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6664), kw_column, int(106), kw_end_DASH_line, int(6664), kw_end_DASH_column, int(128)) + tmp33, err := lang.WithMeta(tmp31, tmp32.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp34 := lang.Apply(tmp17, []any{v11, tmp20, tmp26, tmp33}) + var tmp16 any = tmp34 + tmp36 := checkDerefVar(var_glojure_DOT_core_next) + tmp37 := lang.Apply(tmp36, []any{v12}) + var tmp35 any = tmp37 + tmp39 := checkDerefVar(var_glojure_DOT_core_next) + tmp40 := lang.Apply(tmp39, []any{v13}) + var tmp38 any = tmp40 + v11 = tmp16 + v12 = tmp35 + v13 = tmp38 + continue + } else { + tmp14 = v11 + } + tmp7 = tmp14 + break + } + } // end let + var v8 any = tmp7 + _ = v8 + // let binding "assoc-multi" + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + v12 := args[2] + _ = v12 + var tmp13 any + { // let + // let binding "testexprs" + tmp14 := checkDerefVar(var_glojure_DOT_core_mapcat) + var tmp15 lang.FnFunc + tmp15 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v16 := args[0] + _ = v16 + tmp17 := checkDerefVar(var_glojure_DOT_core_list) + tmp18 := checkDerefVar(var_glojure_DOT_core_first) + tmp19 := lang.Apply(tmp18, []any{v16}) + tmp20 := lang.Apply(tmp17, []any{sym_quote, tmp19}) + tmp21 := checkDerefVar(var_glojure_DOT_core_second) + tmp22 := lang.Apply(tmp21, []any{v16}) + tmp23 := lang.NewVector(tmp20, tmp22) + tmp24 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6668), kw_column, int(56), kw_end_DASH_line, int(6668), kw_end_DASH_column, int(93)) + tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp25 + }) + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6668), kw_column, int(47), kw_end_DASH_line, int(6668), kw_end_DASH_column, int(94)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp18 := lang.Apply(tmp14, []any{tmp17, v12}) + var v19 any = tmp18 + _ = v19 + // let binding "expr" + tmp20 := checkDerefVar(var_glojure_DOT_core_seq) + tmp21 := checkDerefVar(var_glojure_DOT_core_concat) + tmp22 := checkDerefVar(var_glojure_DOT_core_list) + tmp23 := lang.Apply(tmp22, []any{sym_glojure_DOT_core_SLASH_condp}) + tmp24 := checkDerefVar(var_glojure_DOT_core_list) + tmp25 := lang.Apply(tmp24, []any{sym_glojure_DOT_core_SLASH__EQ_}) + tmp26 := checkDerefVar(var_glojure_DOT_core_list) + tmp27 := lang.Apply(tmp26, []any{v2}) + tmp28 := checkDerefVar(var_glojure_DOT_core_list) + tmp29 := lang.Apply(tmp28, []any{v3}) + tmp30 := lang.Apply(tmp21, []any{tmp23, tmp25, tmp27, v19, tmp29}) + tmp31 := lang.Apply(tmp20, []any{tmp30}) + var v32 any = tmp31 + _ = v32 + tmp33 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp34 := lang.Apply(tmp33, []any{v10, v11, v32}) + tmp13 = tmp34 + } // end let + return tmp13 + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6667), kw_column, int(21), kw_end_DASH_line, int(6670), kw_end_DASH_column, int(42)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v12 any = tmp11 + _ = v12 + // let binding "hmap" + tmp13 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp14 lang.FnFunc + tmp14 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v15 := args[0] + _ = v15 + v16 := args[1] + _ = v16 + var tmp17 any + { // let + // let binding "vec__855" + var v18 any = v16 + _ = v18 + // let binding "h" + tmp19 := checkDerefVar(var_glojure_DOT_core_nth) + tmp20 := lang.Apply(tmp19, []any{v18, int64(0), nil}) + var v21 any = tmp20 + _ = v21 + // let binding "bucket" + tmp22 := checkDerefVar(var_glojure_DOT_core_nth) + tmp23 := lang.Apply(tmp22, []any{v18, int64(1), nil}) + var v24 any = tmp23 + _ = v24 + var tmp25 any + tmp26 := checkDerefVar(var_glojure_DOT_core__EQ__EQ_) + tmp27 := checkDerefVar(var_glojure_DOT_core_count) + tmp28 := lang.Apply(tmp27, []any{v24}) + tmp29 := lang.Apply(tmp26, []any{int64(1), tmp28}) + if lang.IsTruthy(tmp29) { + tmp30 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp31 := checkDerefVar(var_glojure_DOT_core_ffirst) + tmp32 := lang.Apply(tmp31, []any{v24}) + tmp33 := checkDerefVar(var_glojure_DOT_core_second) + tmp34 := checkDerefVar(var_glojure_DOT_core_first) + tmp35 := lang.Apply(tmp34, []any{v24}) + tmp36 := lang.Apply(tmp33, []any{tmp35}) + tmp37 := lang.Apply(tmp30, []any{v15, tmp32, tmp36}) + tmp25 = tmp37 + } else { + tmp38 := lang.Apply(v12, []any{v15, v21, v24}) + tmp25 = tmp38 + } + tmp17 = tmp25 + } // end let + return tmp17 + }) + tmp15 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6672), kw_column, int(16), kw_end_DASH_line, int(6675), kw_end_DASH_column, int(45)) + tmp16, err := lang.WithMeta(tmp14, tmp15.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp17 := lang.NewMap() + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6676), kw_column, int(16), kw_end_DASH_line, int(6676), kw_end_DASH_column, int(17)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp20 := lang.Apply(tmp13, []any{tmp16, tmp19, v8}) + var v21 any = tmp20 + _ = v21 + // let binding "skip-check" + tmp22 := checkDerefVar(var_glojure_DOT_core_into1) + tmp23 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp24 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6680), kw_column, int(29), kw_end_DASH_line, int(6680), kw_end_DASH_column, int(31)) + tmp25, err := lang.WithMeta(tmp23, tmp24.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp26 := checkDerefVar(var_glojure_DOT_core_map) + tmp27 := checkDerefVar(var_glojure_DOT_core_first) + tmp28 := checkDerefVar(var_glojure_DOT_core_filter) + var tmp29 lang.FnFunc + tmp29 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v30 := args[0] + _ = v30 + tmp31 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp32 := checkDerefVar(var_glojure_DOT_core_count) + tmp33 := checkDerefVar(var_glojure_DOT_core_second) + tmp34 := lang.Apply(tmp33, []any{v30}) + tmp35 := lang.Apply(tmp32, []any{tmp34}) + tmp36 := lang.Apply(tmp31, []any{int64(1), tmp35}) + return tmp36 + }) + tmp30 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6678), kw_column, int(30), kw_end_DASH_line, int(6678), kw_end_DASH_column, int(54)) + tmp31, err := lang.WithMeta(tmp29, tmp30.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp32 := lang.Apply(tmp28, []any{tmp31, v8}) + tmp33 := lang.Apply(tmp26, []any{tmp27, tmp32}) + tmp34 := lang.Apply(tmp22, []any{tmp25, tmp33}) + var v35 any = tmp34 + _ = v35 + tmp36 := checkDerefVar(var_glojure_DOT_core_keys) + tmp37 := lang.Apply(tmp36, []any{v21}) + tmp38 := checkDerefVar(var_glojure_DOT_core_vals) + tmp39 := lang.Apply(tmp38, []any{v21}) + tmp40 := lang.NewVector(tmp37, tmp39, v35) + tmp41 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6681), kw_column, int(5), kw_end_DASH_line, int(6681), kw_end_DASH_column, int(40)) + tmp42, err := lang.WithMeta(tmp40, tmp41.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp6 = tmp42 + } // end let + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_merge_DASH_hash_DASH_collisions = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_merge_DASH_hash_DASH_collisions.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // prep-hashes + { + tmp0 := sym_prep_DASH_hashes.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_expr_DASH_sym, sym_default, sym_tests, sym_thens)), kw_doc, "Takes a sequence of test constants and a corresponding sequence of then\n expressions. Returns a tuple of [shift mask case-map switch-type skip-check]\n where case-map is a map of int case values to [test then] tuples, switch-type\n is either :sparse or :compact, and skip-check is a set of case ints for which\n post-switch equivalence checking must not be done (occurs with hash\n collisions).", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(8), kw_line, int(6683), kw_end_DASH_line, int(6683), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var tmp6 any + { // let + // let binding "hashcode" + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v8 := args[0] + _ = v8 + tmp9 := lang.Apply(lang.Hash, []any{v8}) + return tmp9 + }) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6691), kw_column, int(18), kw_end_DASH_line, int(6691), kw_end_DASH_column, int(66)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v10 any = tmp9 + _ = v10 + // let binding "hashes" + tmp11 := checkDerefVar(var_glojure_DOT_core_into1) + tmp12 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6692), kw_column, int(23), kw_end_DASH_line, int(6692), kw_end_DASH_column, int(25)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp15 := checkDerefVar(var_glojure_DOT_core_map) + tmp16 := lang.Apply(tmp15, []any{v10, v4}) + tmp17 := lang.Apply(tmp11, []any{tmp14, tmp16}) + var v18 any = tmp17 + _ = v18 + var tmp19 any + tmp20 := checkDerefVar(var_glojure_DOT_core__EQ__EQ_) + tmp21 := checkDerefVar(var_glojure_DOT_core_count) + tmp22 := lang.Apply(tmp21, []any{v4}) + tmp23 := checkDerefVar(var_glojure_DOT_core_count) + tmp24 := lang.Apply(tmp23, []any{v18}) + tmp25 := lang.Apply(tmp20, []any{tmp22, tmp24}) + if lang.IsTruthy(tmp25) { + var tmp26 any + tmp27 := checkDerefVar(var_glojure_DOT_core_fits_DASH_table_QMARK_) + tmp28 := lang.Apply(tmp27, []any{v18}) + if lang.IsTruthy(tmp28) { + tmp29 := checkDerefVar(var_glojure_DOT_core_case_DASH_map) + tmp30 := checkDerefVar(var_glojure_DOT_core_identity) + tmp31 := lang.Apply(tmp29, []any{v10, tmp30, v4, v5}) + tmp32 := lang.NewVector(int64(0), int64(0), tmp31, kw_compact) + tmp33 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6696), kw_column, int(9), kw_end_DASH_line, int(6696), kw_end_DASH_column, int(63)) + tmp34, err := lang.WithMeta(tmp32, tmp33.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp26 = tmp34 + } else { + var tmp35 any + { // let + // let binding "vec__858" + var tmp36 any + { // let + // let binding "or__0__auto__" + tmp37 := checkDerefVar(var_glojure_DOT_core_maybe_DASH_min_DASH_hash) + tmp38 := lang.Apply(tmp37, []any{v18}) + var v39 any = tmp38 + _ = v39 + var tmp40 any + if lang.IsTruthy(v39) { + tmp40 = v39 + } else { + tmp41 := lang.NewVector(int64(0), int64(0)) + tmp42 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6697), kw_column, int(56), kw_end_DASH_line, int(6697), kw_end_DASH_column, int(60)) + tmp43, err := lang.WithMeta(tmp41, tmp42.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp40 = tmp43 + } + tmp36 = tmp40 + } // end let + var v37 any = tmp36 + _ = v37 + // let binding "shift" + tmp38 := checkDerefVar(var_glojure_DOT_core_nth) + tmp39 := lang.Apply(tmp38, []any{v37, int64(0), nil}) + var v40 any = tmp39 + _ = v40 + // let binding "mask" + tmp41 := checkDerefVar(var_glojure_DOT_core_nth) + tmp42 := lang.Apply(tmp41, []any{v37, int64(1), nil}) + var v43 any = tmp42 + _ = v43 + var tmp44 any + tmp45 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) + tmp46 := lang.Apply(tmp45, []any{v43}) + if lang.IsTruthy(tmp46) { + tmp47 := checkDerefVar(var_glojure_DOT_core_case_DASH_map) + tmp48 := checkDerefVar(var_glojure_DOT_core_identity) + tmp49 := lang.Apply(tmp47, []any{v10, tmp48, v4, v5}) + tmp50 := lang.NewVector(int64(0), int64(0), tmp49, kw_sparse) + tmp51 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6700), kw_column, int(13), kw_end_DASH_line, int(6700), kw_end_DASH_column, int(66)) + tmp52, err := lang.WithMeta(tmp50, tmp51.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp44 = tmp52 + } else { + tmp53 := checkDerefVar(var_glojure_DOT_core_case_DASH_map) + var tmp54 lang.FnFunc + tmp54 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v55 := args[0] + _ = v55 + tmp56 := checkDerefVar(var_glojure_DOT_core_shift_DASH_mask) + tmp57 := lang.Apply(v10, []any{v55}) + tmp58 := lang.Apply(tmp56, []any{v40, v43, tmp57}) + return tmp58 + }) + tmp55 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6702), kw_column, int(35), kw_end_DASH_line, int(6702), kw_end_DASH_column, int(71)) + tmp56, err := lang.WithMeta(tmp54, tmp55.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp57 := checkDerefVar(var_glojure_DOT_core_identity) + tmp58 := lang.Apply(tmp53, []any{tmp56, tmp57, v4, v5}) + tmp59 := lang.NewVector(v40, v43, tmp58, kw_compact) + tmp60 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6702), kw_column, int(13), kw_end_DASH_line, int(6702), kw_end_DASH_column, int(103)) + tmp61, err := lang.WithMeta(tmp59, tmp60.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp44 = tmp61 + } + tmp35 = tmp44 + } // end let + tmp26 = tmp35 + } + tmp19 = tmp26 + } else { + var tmp36 any + { // let + // let binding "vec__861" + tmp37 := checkDerefVar(var_glojure_DOT_core_merge_DASH_hash_DASH_collisions) + tmp38 := lang.Apply(tmp37, []any{v2, v3, v4, v5}) + var v39 any = tmp38 + _ = v39 + // let binding "tests" + tmp40 := checkDerefVar(var_glojure_DOT_core_nth) + tmp41 := lang.Apply(tmp40, []any{v39, int64(0), nil}) + var v42 any = tmp41 + _ = v42 + // let binding "thens" + tmp43 := checkDerefVar(var_glojure_DOT_core_nth) + tmp44 := lang.Apply(tmp43, []any{v39, int64(1), nil}) + var v45 any = tmp44 + _ = v45 + // let binding "skip-check" + tmp46 := checkDerefVar(var_glojure_DOT_core_nth) + tmp47 := lang.Apply(tmp46, []any{v39, int64(2), nil}) + var v48 any = tmp47 + _ = v48 + // let binding "vec__864" + tmp49 := checkDerefVar(var_glojure_DOT_core_prep_DASH_hashes) + tmp50 := lang.Apply(tmp49, []any{v2, v3, v42, v45}) + var v51 any = tmp50 + _ = v51 + // let binding "shift" + tmp52 := checkDerefVar(var_glojure_DOT_core_nth) + tmp53 := lang.Apply(tmp52, []any{v51, int64(0), nil}) + var v54 any = tmp53 + _ = v54 + // let binding "mask" + tmp55 := checkDerefVar(var_glojure_DOT_core_nth) + tmp56 := lang.Apply(tmp55, []any{v51, int64(1), nil}) + var v57 any = tmp56 + _ = v57 + // let binding "case-map" + tmp58 := checkDerefVar(var_glojure_DOT_core_nth) + tmp59 := lang.Apply(tmp58, []any{v51, int64(2), nil}) + var v60 any = tmp59 + _ = v60 + // let binding "switch-type" + tmp61 := checkDerefVar(var_glojure_DOT_core_nth) + tmp62 := lang.Apply(tmp61, []any{v51, int64(3), nil}) + var v63 any = tmp62 + _ = v63 + // let binding "skip-check" + var tmp64 any + tmp65 := checkDerefVar(var_glojure_DOT_core_zero_QMARK_) + tmp66 := lang.Apply(tmp65, []any{v57}) + if lang.IsTruthy(tmp66) { + tmp64 = v48 + } else { + tmp67 := checkDerefVar(var_glojure_DOT_core_into1) + tmp68 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp69 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6708), kw_column, int(33), kw_end_DASH_line, int(6708), kw_end_DASH_column, int(35)) + tmp70, err := lang.WithMeta(tmp68, tmp69.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp71 := checkDerefVar(var_glojure_DOT_core_map) + var tmp72 lang.FnFunc + tmp72 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v73 := args[0] + _ = v73 + tmp74 := checkDerefVar(var_glojure_DOT_core_shift_DASH_mask) + tmp75 := lang.Apply(tmp74, []any{v54, v57, v73}) + return tmp75 + }) + tmp73 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6708), kw_column, int(42), kw_end_DASH_line, int(6708), kw_end_DASH_column, int(67)) + tmp74, err := lang.WithMeta(tmp72, tmp73.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp75 := lang.Apply(tmp71, []any{tmp74, v48}) + tmp76 := lang.Apply(tmp67, []any{tmp70, tmp75}) + tmp64 = tmp76 + } + var v77 any = tmp64 + _ = v77 + tmp78 := lang.NewVector(v54, v57, v60, v63, v77) + tmp79 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6709), kw_column, int(9), kw_end_DASH_line, int(6709), kw_end_DASH_column, int(52)) + tmp80, err := lang.WithMeta(tmp78, tmp79.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp36 = tmp80 + } // end let + tmp19 = tmp36 + } + tmp6 = tmp19 + } // end let + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_prep_DASH_hashes = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_prep_DASH_hashes.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // tree-seq + { + tmp0 := sym_tree_DASH_seq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_branch_QMARK_, sym_children, sym_root)), kw_doc, "Returns a lazy sequence of the nodes in a tree, via a depth-first walk.\n branch? must be a fn of one arg that returns true if passed a node\n that can have children (but may not). children must be a fn of one\n arg that returns a sequence of the children. Will only be called on\n nodes for which branch? returns true. Root is the root node of the\n tree.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(4955), kw_end_DASH_line, int(4955))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + { // let + // let binding "walk" + var tmp6 lang.FnFunc + { // function walk + var v7 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v8 := args[0] + _ = v8 + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp10 := checkDerefVar(var_glojure_DOT_core_cons) + var tmp11 any + tmp12 := lang.Apply(v2, []any{v8}) + if lang.IsTruthy(tmp12) { + tmp13 := checkDerefVar(var_glojure_DOT_core_mapcat) + tmp14 := lang.Apply(v3, []any{v8}) + tmp15 := lang.Apply(tmp13, []any{v7, tmp14}) + tmp11 = tmp15 + } else { + } + tmp16 := lang.Apply(tmp10, []any{v8, tmp11}) + return tmp16 + }) + tmp10 := lang.Apply(lang.NewLazySeq, []any{tmp9}) + return tmp10 + }) + v7 = tmp6 + _ = v7 + } + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4965), kw_column, int(15), kw_end_DASH_line, int(4969), kw_end_DASH_column, int(53)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v9 any = tmp8 + _ = v9 + tmp10 := lang.Apply(v9, []any{v4}) + tmp5 = tmp10 + } // end let + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_tree_DASH_seq = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_tree_DASH_seq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // xml-seq + { + tmp0 := sym_xml_DASH_seq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_root)), kw_doc, "A tree seq on the xml elements as per xml/parse", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4982), kw_end_DASH_line, int(4982))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_tree_DASH_seq) + tmp4 := checkDerefVar(var_glojure_DOT_core_complement) + tmp5 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp6 := lang.Apply(tmp4, []any{tmp5}) + tmp7 := checkDerefVar(var_glojure_DOT_core_comp) + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := lang.Apply(tmp7, []any{tmp8, kw_content}) + tmp10 := lang.Apply(tmp3, []any{tmp6, tmp9, v2}) + return tmp10 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_xml_DASH_seq = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_xml_DASH_seq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // emit-extend-type + { + tmp0 := sym_emit_DASH_extend_DASH_type.WithMeta(lang.NewMap(kw_file, "glojure/core_deftype.glj", kw_line, int(175), kw_column, int(8), kw_end_DASH_line, int(175), kw_end_DASH_column, int(23), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_c, sym_specs)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "impls" + tmp5 := checkDerefVar(var_glojure_DOT_core_parse_DASH_impls) + tmp6 := lang.Apply(tmp5, []any{v3}) + var v7 any = tmp6 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_concat) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_extend}) + tmp12 := checkDerefVar(var_glojure_DOT_core_list) + tmp13 := lang.Apply(tmp12, []any{v2}) + tmp14 := checkDerefVar(var_glojure_DOT_core_mapcat) + tmp15 := checkDerefVar(var_glojure_DOT_core_partial) + tmp16 := checkDerefVar(var_glojure_DOT_core_emit_DASH_hinted_DASH_impl) + tmp17 := lang.Apply(tmp15, []any{tmp16, v2}) + tmp18 := lang.Apply(tmp14, []any{tmp17, v7}) + tmp19 := lang.Apply(tmp9, []any{tmp11, tmp13, tmp18}) + tmp20 := lang.Apply(tmp8, []any{tmp19}) + tmp4 = tmp20 + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_emit_DASH_extend_DASH_type = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_emit_DASH_extend_DASH_type.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // extend-type + { + tmp0 := sym_extend_DASH_type.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_t, sym__AMP_, sym_specs)), kw_doc, "A macro that expands into an extend call. Useful when you are\n supplying the definitions explicitly inline, extend-type\n automatically creates the maps required by extend. Propagates the\n class as a type hint on the first argument of all fns.\n\n (extend-type MyType \n Countable\n (cnt [c] ...)\n Foo\n (bar [x y] ...)\n (baz ([x] ...) ([x y & zs] ...)))\n\n expands into:\n\n (extend MyType\n Countable\n {:cnt (fn [c] ...)}\n Foo\n {:baz (fn ([x] ...) ([x y & zs] ...))\n :bar (fn [x y] ...)})", kw_file, "glojure/core_deftype.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(21), kw_column, int(11), kw_line, int(180), kw_end_DASH_line, int(180))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_emit_DASH_extend_DASH_type) + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_extend_DASH_type = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_extend_DASH_type.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // file-seq + { + tmp0 := sym_file_DASH_seq.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_dir)), kw_doc, "A tree seq on java.io.Files", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(4972), kw_end_DASH_line, int(4972))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_tree_DASH_seq) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v5 := args[0] + _ = v5 + tmp6, _ := lang.FieldOrMethod(v5, "isDirectory") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("isDirectory is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{}) + return tmp7 + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4978), kw_column, int(6), kw_end_DASH_line, int(4978), kw_end_DASH_column, int(47)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v8 := args[0] + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_seq) + tmp10, _ := lang.FieldOrMethod(v8, "listFiles") + if reflect.TypeOf(tmp10).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("listFiles is not a function"))) + } + tmp11 := lang.Apply(tmp10, []any{}) + tmp12 := lang.Apply(tmp9, []any{tmp11}) + return tmp12 + }) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(4979), kw_column, int(6), kw_end_DASH_line, int(4979), kw_end_DASH_column, int(51)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp10 := lang.Apply(tmp3, []any{tmp6, tmp9, v2}) + return tmp10 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_file_DASH_seq = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_file_DASH_seq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // flatten + { + tmp0 := sym_flatten.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Takes any nested combination of sequential things (lists, vectors,\n etc.) and returns their contents as a single, flat lazy sequence.\n (flatten nil) returns an empty sequence.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(7118), kw_end_DASH_line, int(7118))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_filter) + tmp4 := checkDerefVar(var_glojure_DOT_core_complement) + tmp5 := checkDerefVar(var_glojure_DOT_core_sequential_QMARK_) + tmp6 := lang.Apply(tmp4, []any{tmp5}) + tmp7 := checkDerefVar(var_glojure_DOT_core_rest) + tmp8 := checkDerefVar(var_glojure_DOT_core_tree_DASH_seq) + tmp9 := checkDerefVar(var_glojure_DOT_core_sequential_QMARK_) + tmp10 := checkDerefVar(var_glojure_DOT_core_seq) + tmp11 := lang.Apply(tmp8, []any{tmp9, tmp10, v2}) + tmp12 := lang.Apply(tmp7, []any{tmp11}) + tmp13 := lang.Apply(tmp3, []any{tmp6, tmp12}) + return tmp13 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_flatten = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_flatten.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // compile + { + tmp0 := sym_compile.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_lib)), kw_doc, "Compiles the namespace named by the symbol lib into a set of\n classfiles. The source for the lib must be in a proper\n classpath-relative directory. The output files will go into the\n directory specified by *compile-path*, and that directory too must\n be in the classpath.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(6114), kw_end_DASH_line, int(6114))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + tmp4 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp5 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp6 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_compile_DASH_files_STAR_) + tmp7 := lang.Apply(tmp5, []any{tmp6, true}) + tmp8 := lang.Apply(tmp4, []any{tmp7}) + _ = tmp8 + var tmp9 any + func() { + defer func() { + tmp10 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp11 := lang.Apply(tmp10, nil) + _ = tmp11 + }() + tmp12 := checkDerefVar(var_glojure_DOT_core_load_DASH_one) + tmp13 := lang.Apply(tmp12, []any{v2, true, true}) + tmp9 = tmp13 + }() + tmp3 = tmp9 + } // end let + _ = tmp3 + return v2 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_compile = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_compile.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // derive + { + tmp0 := sym_derive.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_tag, sym_parent), lang.NewVector(sym_h, sym_tag, sym_parent)), kw_doc, "Establishes a parent/child relationship between parent and\n tag. Parent must be a namespace-qualified symbol or keyword and\n child can be either a namespace-qualified symbol or keyword or a\n class. h must be a hierarchy obtained from make-hierarchy, if not\n supplied defaults to, and modifies, the global hierarchy.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(5605), kw_end_DASH_line, int(5605))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_alter_DASH_var_DASH_root) + tmp5 := lang.InternVarName(sym_glojure_DOT_core, sym_global_DASH_hierarchy) + tmp6 := checkDerefVar(var_glojure_DOT_core_derive) + tmp7 := lang.Apply(tmp4, []any{tmp5, tmp6, v2, v3}) + _ = tmp7 + return nil + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + { // let + // let binding "tp" + tmp6 := lang.Apply(kw_parents, []any{v2}) + var v7 any = tmp6 + _ = v7 + // let binding "td" + tmp8 := lang.Apply(kw_descendants, []any{v2}) + var v9 any = tmp8 + _ = v9 + // let binding "ta" + tmp10 := lang.Apply(kw_ancestors, []any{v2}) + var v11 any = tmp10 + _ = v11 + // let binding "tf" + var tmp12 lang.FnFunc + tmp12 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 5) + v13 := args[0] + _ = v13 + v14 := args[1] + _ = v14 + v15 := args[2] + _ = v15 + v16 := args[3] + _ = v16 + v17 := args[4] + _ = v17 + tmp18 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp19 lang.FnFunc + tmp19 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v20 := args[0] + _ = v20 + v21 := args[1] + _ = v21 + tmp22 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp23 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp24 := checkDerefVar(var_glojure_DOT_core_conj) + tmp25 := checkDerefVar(var_glojure_DOT_core_get) + tmp26 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp27 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5628), kw_column, int(61), kw_end_DASH_line, int(5628), kw_end_DASH_column, int(63)) + tmp28, err := lang.WithMeta(tmp26, tmp27.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp29 := lang.Apply(tmp25, []any{v17, v21, tmp28}) + tmp30 := checkDerefVar(var_glojure_DOT_core_cons) + tmp31 := lang.Apply(v17, []any{v16}) + tmp32 := lang.Apply(tmp30, []any{v16, tmp31}) + tmp33 := lang.Apply(tmp23, []any{tmp24, tmp29, tmp32}) + tmp34 := lang.Apply(tmp22, []any{v20, v21, tmp33}) + return tmp34 + }) + tmp20 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5626), kw_column, int(24), kw_end_DASH_line, int(5628), kw_end_DASH_column, int(98)) + tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp22 := checkDerefVar(var_glojure_DOT_core_cons) + tmp23 := lang.Apply(v15, []any{v14}) + tmp24 := lang.Apply(tmp22, []any{v14, tmp23}) + tmp25 := lang.Apply(tmp18, []any{tmp21, v13, tmp24}) + return tmp25 + }) + tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5625), kw_column, int(13), kw_end_DASH_line, int(5629), kw_end_DASH_column, int(56)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v15 any = tmp14 + _ = v15 + var tmp16 any + { // let + // let binding "or__0__auto__" + var tmp17 any + tmp18 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp19 := lang.Apply(v7, []any{v3}) + tmp20 := lang.Apply(tmp18, []any{tmp19, v4}) + if lang.IsTruthy(tmp20) { + } else { + var tmp21 any + tmp22 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp23 := lang.Apply(v11, []any{v3}) + tmp24 := lang.Apply(tmp22, []any{tmp23, v4}) + if lang.IsTruthy(tmp24) { + tmp25 := checkDerefVar(var_glojure_DOT_core_print_DASH_str) + tmp26 := lang.Apply(tmp25, []any{v3, "already has", v4, "as ancestor"}) + tmp27 := lang.Apply(lang.NewError, []any{tmp26}) + panic(tmp27) + } else { + } + _ = tmp21 + var tmp28 any + tmp29 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp30 := lang.Apply(v11, []any{v4}) + tmp31 := lang.Apply(tmp29, []any{tmp30, v3}) + if lang.IsTruthy(tmp31) { + tmp32 := checkDerefVar(var_glojure_DOT_core_print_DASH_str) + tmp33 := lang.Apply(tmp32, []any{"Cyclic derivation:", v4, "has", v3, "as ancestor"}) + tmp34 := lang.Apply(lang.NewError, []any{tmp33}) + panic(tmp34) + } else { + } + _ = tmp28 + tmp35 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp36 := lang.Apply(kw_parents, []any{v2}) + tmp37 := checkDerefVar(var_glojure_DOT_core_conj) + tmp38 := checkDerefVar(var_glojure_DOT_core_get) + tmp39 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp40 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5636), kw_column, int(61), kw_end_DASH_line, int(5636), kw_end_DASH_column, int(63)) + tmp41, err := lang.WithMeta(tmp39, tmp40.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp42 := lang.Apply(tmp38, []any{v7, v3, tmp41}) + tmp43 := lang.Apply(tmp37, []any{tmp42, v4}) + tmp44 := lang.Apply(tmp35, []any{tmp36, v3, tmp43}) + tmp45 := lang.Apply(kw_ancestors, []any{v2}) + tmp46 := lang.Apply(v15, []any{tmp45, v3, v9, v4, v11}) + tmp47 := lang.Apply(kw_descendants, []any{v2}) + tmp48 := lang.Apply(v15, []any{tmp47, v4, v11, v3, v9}) + tmp49 := lang.NewMap(kw_parents, tmp44, kw_ancestors, tmp46, kw_descendants, tmp48) + tmp50 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5636), kw_column, int(9), kw_end_DASH_line, int(5638), kw_end_DASH_column, int(61)) + tmp51, err := lang.WithMeta(tmp49, tmp50.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp17 = tmp51 + } + var v52 any = tmp17 + _ = v52 + var tmp53 any + if lang.IsTruthy(v52) { + tmp53 = v52 + } else { + tmp53 = v2 + } + tmp16 = tmp53 + } // end let + tmp5 = tmp16 + } // end let + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_derive = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_derive.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // underive + { + tmp0 := sym_underive.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_tag, sym_parent), lang.NewVector(sym_h, sym_tag, sym_parent)), kw_doc, "Removes a parent/child relationship between parent and\n tag. h must be a hierarchy obtained from make-hierarchy, if not\n supplied defaults to, and modifies, the global hierarchy.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(5643), kw_end_DASH_line, int(5643))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_alter_DASH_var_DASH_root) + tmp5 := lang.InternVarName(sym_glojure_DOT_core, sym_global_DASH_hierarchy) + tmp6 := checkDerefVar(var_glojure_DOT_core_underive) + tmp7 := lang.Apply(tmp4, []any{tmp5, tmp6, v2, v3}) + _ = tmp7 + return nil + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + { // let + // let binding "parentMap" + tmp6 := lang.Apply(kw_parents, []any{v2}) + var v7 any = tmp6 + _ = v7 + // let binding "childsParents" + var tmp8 any + tmp9 := lang.Apply(v7, []any{v3}) + if lang.IsTruthy(tmp9) { + tmp10 := checkDerefVar(var_glojure_DOT_core_disj) + tmp11 := lang.Apply(v7, []any{v3}) + tmp12 := lang.Apply(tmp10, []any{tmp11, v4}) + tmp8 = tmp12 + } else { + tmp13 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{})) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5652), kw_column, int(36), kw_end_DASH_line, int(5652), kw_end_DASH_column, int(38)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp8 = tmp15 + } + var v16 any = tmp8 + _ = v16 + // let binding "newParents" + var tmp17 any + tmp18 := checkDerefVar(var_glojure_DOT_core_not_DASH_empty) + tmp19 := lang.Apply(tmp18, []any{v16}) + if lang.IsTruthy(tmp19) { + tmp20 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp21 := lang.Apply(tmp20, []any{v7, v3, v16}) + tmp17 = tmp21 + } else { + tmp22 := checkDerefVar(var_glojure_DOT_core_dissoc) + tmp23 := lang.Apply(tmp22, []any{v7, v3}) + tmp17 = tmp23 + } + var v24 any = tmp17 + _ = v24 + // let binding "deriv-seq" + tmp25 := checkDerefVar(var_glojure_DOT_core_flatten) + tmp26 := checkDerefVar(var_glojure_DOT_core_map) + var tmp27 lang.FnFunc + tmp27 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v28 := args[0] + _ = v28 + tmp29 := checkDerefVar(var_glojure_DOT_core_cons) + tmp30 := checkDerefVar(var_glojure_DOT_core_key) + tmp31 := lang.Apply(tmp30, []any{v28}) + tmp32 := checkDerefVar(var_glojure_DOT_core_interpose) + tmp33 := checkDerefVar(var_glojure_DOT_core_key) + tmp34 := lang.Apply(tmp33, []any{v28}) + tmp35 := checkDerefVar(var_glojure_DOT_core_val) + tmp36 := lang.Apply(tmp35, []any{v28}) + tmp37 := lang.Apply(tmp32, []any{tmp34, tmp36}) + tmp38 := lang.Apply(tmp29, []any{tmp31, tmp37}) + return tmp38 + }) + tmp28 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5656), kw_column, int(28), kw_end_DASH_line, int(5656), kw_end_DASH_column, int(70)) + tmp29, err := lang.WithMeta(tmp27, tmp28.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp30 := checkDerefVar(var_glojure_DOT_core_seq) + tmp31 := lang.Apply(tmp30, []any{v24}) + tmp32 := lang.Apply(tmp26, []any{tmp29, tmp31}) + tmp33 := lang.Apply(tmp25, []any{tmp32}) + var v34 any = tmp33 + _ = v34 + var tmp35 any + tmp36 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp37 := lang.Apply(v7, []any{v3}) + tmp38 := lang.Apply(tmp36, []any{tmp37, v4}) + if lang.IsTruthy(tmp38) { + tmp39 := checkDerefVar(var_glojure_DOT_core_reduce1) + var tmp40 lang.FnFunc + tmp40 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v41 := args[0] + _ = v41 + v42 := args[1] + _ = v42 + tmp43 := checkDerefVar(var_glojure_DOT_core_apply) + tmp44 := checkDerefVar(var_glojure_DOT_core_derive) + tmp45 := lang.Apply(tmp43, []any{tmp44, v41, v42}) + return tmp45 + }) + tmp41 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5659), kw_column, int(11), kw_end_DASH_line, int(5659), kw_end_DASH_column, int(31)) + tmp42, err := lang.WithMeta(tmp40, tmp41.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp43 := checkDerefVar(var_glojure_DOT_core_make_DASH_hierarchy) + tmp44 := lang.Apply(tmp43, nil) + tmp45 := checkDerefVar(var_glojure_DOT_core_partition) + tmp46 := lang.Apply(tmp45, []any{int64(2), v34}) + tmp47 := lang.Apply(tmp39, []any{tmp42, tmp44, tmp46}) + tmp35 = tmp47 + } else { + tmp35 = v2 + } + tmp5 = tmp35 + } // end let + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_underive = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_underive.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // filterv + { + tmp0 := sym_filterv.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_pred, sym_coll)), kw_doc, "Returns a vector of the items in coll for which\n (pred item) returns logical true. pred must be free of side-effects.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.4", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(6961), kw_end_DASH_line, int(6961))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp5 := checkDerefVar(var_glojure_DOT_core_reduce) + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + var tmp9 any + tmp10 := lang.Apply(v2, []any{v8}) + if lang.IsTruthy(tmp10) { + tmp11 := checkDerefVar(var_glojure_DOT_core_conj_BANG_) + tmp12 := lang.Apply(tmp11, []any{v7, v8}) + tmp9 = tmp12 + } else { + tmp9 = v7 + } + return tmp9 + }) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6967), kw_column, int(15), kw_end_DASH_line, int(6967), kw_end_DASH_column, int(52)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp9 := checkDerefVar(var_glojure_DOT_core_transient) + tmp10 := lang.NewVector() + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6968), kw_column, int(26), kw_end_DASH_line, int(6968), kw_end_DASH_column, int(27)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := lang.Apply(tmp9, []any{tmp12}) + tmp14 := lang.Apply(tmp5, []any{tmp8, tmp13, v3}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_filterv = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_filterv.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // flush + { + tmp0 := sym_flush.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Flushes the output stream that is the current value of\n *out*", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3706), kw_end_DASH_line, int(3706))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp2 := checkDerefVar(var_glojure_DOT_core__STAR_out_STAR_) + tmp3, _ := lang.FieldOrMethod(tmp2, "Sync") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Sync is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{}) + _ = tmp4 + return nil + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_flush = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_flush.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // frequencies + { + tmp0 := sym_frequencies.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll)), kw_doc, "Returns a map from distinct items in coll to the number of times\n they appear.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(7185), kw_end_DASH_line, int(7185))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp4 := checkDerefVar(var_glojure_DOT_core_reduce) + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_assoc_BANG_) + tmp9 := checkDerefVar(var_glojure_DOT_core_inc) + tmp10 := checkDerefVar(var_glojure_DOT_core_get) + tmp11 := lang.Apply(tmp10, []any{v6, v7, int64(0)}) + tmp12 := lang.Apply(tmp9, []any{tmp11}) + tmp13 := lang.Apply(tmp8, []any{v6, v7, tmp12}) + return tmp13 + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7192), kw_column, int(12), kw_end_DASH_line, int(7193), kw_end_DASH_column, int(54)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp8 := checkDerefVar(var_glojure_DOT_core_transient) + tmp9 := lang.NewMap() + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7194), kw_column, int(23), kw_end_DASH_line, int(7194), kw_end_DASH_column, int(24)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp12 := lang.Apply(tmp8, []any{tmp11}) + tmp13 := lang.Apply(tmp4, []any{tmp7, tmp12, v2}) + tmp14 := lang.Apply(tmp3, []any{tmp13}) + return tmp14 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_frequencies = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_frequencies.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // group-by + { + tmp0 := sym_group_DASH_by.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_coll)), kw_doc, "Returns a map of the elements of coll keyed by the result of\n f on each element. The value at each key will be a vector of the\n corresponding elements, in the order they appeared in coll.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(7128), kw_end_DASH_line, int(7128))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp5 := checkDerefVar(var_glojure_DOT_core_reduce) + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + var tmp9 any + { // let + // let binding "k" + tmp10 := lang.Apply(v2, []any{v8}) + var v11 any = tmp10 + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_assoc_BANG_) + tmp13 := checkDerefVar(var_glojure_DOT_core_conj) + tmp14 := checkDerefVar(var_glojure_DOT_core_get) + tmp15 := lang.NewVector() + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7139), kw_column, int(40), kw_end_DASH_line, int(7139), kw_end_DASH_column, int(41)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp18 := lang.Apply(tmp14, []any{v7, v11, tmp17}) + tmp19 := lang.Apply(tmp13, []any{tmp18, v8}) + tmp20 := lang.Apply(tmp12, []any{v7, v11, tmp19}) + tmp9 = tmp20 + } // end let + return tmp9 + }) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7137), kw_column, int(5), kw_end_DASH_line, int(7139), kw_end_DASH_column, int(48)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp9 := checkDerefVar(var_glojure_DOT_core_transient) + tmp10 := lang.NewMap() + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7140), kw_column, int(16), kw_end_DASH_line, int(7140), kw_end_DASH_column, int(17)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := lang.Apply(tmp9, []any{tmp12}) + tmp14 := lang.Apply(tmp5, []any{tmp8, tmp13, v3}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_group_DASH_by = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_group_DASH_by.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // into + { + tmp0 := sym_into.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_to), lang.NewVector(sym_to, sym_from), lang.NewVector(sym_to, sym_xform, sym_from)), kw_doc, "Returns a new coll consisting of to with all of the items of\n from conjoined. A transducer may be supplied.\n (into x) returns x. (into) returns [].", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(6922), kw_end_DASH_line, int(6922))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp2 := lang.NewVector() + tmp3 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6928), kw_column, int(7), kw_end_DASH_line, int(6928), kw_end_DASH_column, int(8)) + tmp4, err := lang.WithMeta(tmp2, tmp3.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp4 + case 1: + v2 := args[0] + _ = v2 + return v2 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp6 := reflect.TypeOf((*lang.IEditableCollection)(nil)).Elem() + tmp7 := lang.Apply(tmp5, []any{tmp6, v2}) + if lang.IsTruthy(tmp7) { + tmp8 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp9 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp10 := checkDerefVar(var_glojure_DOT_core_reduce) + tmp11 := checkDerefVar(var_glojure_DOT_core_conj_BANG_) + tmp12 := checkDerefVar(var_glojure_DOT_core_transient) + tmp13 := lang.Apply(tmp12, []any{v2}) + tmp14 := lang.Apply(tmp10, []any{tmp11, tmp13, v3}) + tmp15 := lang.Apply(tmp9, []any{tmp14}) + tmp16 := checkDerefVar(var_glojure_DOT_core_meta) + tmp17 := lang.Apply(tmp16, []any{v2}) + tmp18 := lang.Apply(tmp8, []any{tmp15, tmp17}) + tmp4 = tmp18 + } else { + tmp19 := checkDerefVar(var_glojure_DOT_core_reduce) + tmp20 := checkDerefVar(var_glojure_DOT_core_conj) + tmp21 := lang.Apply(tmp19, []any{tmp20, v2, v3}) + tmp4 = tmp21 + } + return tmp4 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp7 := reflect.TypeOf((*lang.IEditableCollection)(nil)).Elem() + tmp8 := lang.Apply(tmp6, []any{tmp7, v2}) + if lang.IsTruthy(tmp8) { + var tmp9 any + { // let + // let binding "tm" + tmp10 := checkDerefVar(var_glojure_DOT_core_meta) + tmp11 := lang.Apply(tmp10, []any{v2}) + var v12 any = tmp11 + _ = v12 + // let binding "rf" + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v14 := args[0] + _ = v14 + tmp15 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp16 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp17 := lang.Apply(tmp16, []any{v14}) + tmp18 := lang.Apply(tmp15, []any{tmp17, v12}) + return tmp18 + case 2: + v14 := args[0] + _ = v14 + v15 := args[1] + _ = v15 + tmp16 := checkDerefVar(var_glojure_DOT_core_conj_BANG_) + tmp17 := lang.Apply(tmp16, []any{v14, v15}) + return tmp17 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6937), kw_column, int(17), kw_end_DASH_line, int(6939), kw_end_DASH_column, int(44)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v16 any = tmp15 + _ = v16 + tmp17 := checkDerefVar(var_glojure_DOT_core_transduce) + tmp18 := checkDerefVar(var_glojure_DOT_core_transient) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp17, []any{v3, v16, tmp19, v4}) + tmp9 = tmp20 + } // end let + tmp5 = tmp9 + } else { + tmp10 := checkDerefVar(var_glojure_DOT_core_transduce) + tmp11 := checkDerefVar(var_glojure_DOT_core_conj) + tmp12 := lang.Apply(tmp10, []any{v3, tmp11, v2, v4}) + tmp5 = tmp12 + } + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_into = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_into.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // partitionv + { + tmp0 := sym_partitionv.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n, sym_coll), lang.NewVector(sym_n, sym_step, sym_coll), lang.NewVector(sym_n, sym_step, sym_pad, sym_coll)), kw_doc, "Returns a lazy sequence of vectors of n items each, at offsets step\n apart. If step is not supplied, defaults to n, i.e. the partitions\n do not overlap. If a pad collection is supplied, use its elements as\n necessary to complete last partition upto n items. In case there are\n not enough padding elements, return a partition with less than n items.", kw_file, "glojure/core.glj", kw_added, "1.12", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(7), kw_line, int(7262), kw_end_DASH_line, int(7262))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_partitionv) + tmp5 := lang.Apply(tmp4, []any{v2, v2, v3}) + return tmp5 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp6 any + { // let + // let binding "temp__0__auto__" + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := lang.Apply(tmp7, []any{v4}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + var tmp11 any + { // let + // let binding "s" + var v12 any = v9 + _ = v12 + var tmp13 any + { // let + // let binding "p" + tmp14 := checkDerefVar(var_glojure_DOT_core_into) + tmp15 := lang.NewVector() + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7274), kw_column, int(22), kw_end_DASH_line, int(7274), kw_end_DASH_column, int(23)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp18 := checkDerefVar(var_glojure_DOT_core_take) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp14, []any{tmp17, tmp19, v12}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + tmp23 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp24 := checkDerefVar(var_glojure_DOT_core_count) + tmp25 := lang.Apply(tmp24, []any{v21}) + tmp26 := lang.Apply(tmp23, []any{v2, tmp25}) + if lang.IsTruthy(tmp26) { + tmp27 := checkDerefVar(var_glojure_DOT_core_cons) + tmp28 := checkDerefVar(var_glojure_DOT_core_partitionv) + tmp29 := checkDerefVar(var_glojure_DOT_core_nthrest) + tmp30 := lang.Apply(tmp29, []any{v12, v3}) + tmp31 := lang.Apply(tmp28, []any{v2, v3, tmp30}) + tmp32 := lang.Apply(tmp27, []any{v21, tmp31}) + tmp22 = tmp32 + } else { + } + tmp13 = tmp22 + } // end let + tmp11 = tmp13 + } // end let + tmp10 = tmp11 + } else { + } + tmp6 = tmp10 + } // end let + return tmp6 + }) + tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) + return tmp6 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp7 any + { // let + // let binding "temp__0__auto__" + tmp8 := checkDerefVar(var_glojure_DOT_core_seq) + tmp9 := lang.Apply(tmp8, []any{v5}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + if lang.IsTruthy(v10) { + var tmp12 any + { // let + // let binding "s" + var v13 any = v10 + _ = v13 + var tmp14 any + { // let + // let binding "p" + tmp15 := checkDerefVar(var_glojure_DOT_core_into) + tmp16 := lang.NewVector() + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7280), kw_column, int(22), kw_end_DASH_line, int(7280), kw_end_DASH_column, int(23)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp19 := checkDerefVar(var_glojure_DOT_core_take) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := lang.Apply(tmp15, []any{tmp18, tmp20, v13}) + var v22 any = tmp21 + _ = v22 + var tmp23 any + tmp24 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp25 := checkDerefVar(var_glojure_DOT_core_count) + tmp26 := lang.Apply(tmp25, []any{v22}) + tmp27 := lang.Apply(tmp24, []any{v2, tmp26}) + if lang.IsTruthy(tmp27) { + tmp28 := checkDerefVar(var_glojure_DOT_core_cons) + tmp29 := checkDerefVar(var_glojure_DOT_core_partitionv) + tmp30 := checkDerefVar(var_glojure_DOT_core_nthrest) + tmp31 := lang.Apply(tmp30, []any{v13, v3}) + tmp32 := lang.Apply(tmp29, []any{v2, v3, v4, tmp31}) + tmp33 := lang.Apply(tmp28, []any{v22, tmp32}) + tmp23 = tmp33 + } else { + tmp34 := checkDerefVar(var_glojure_DOT_core_list) + tmp35 := checkDerefVar(var_glojure_DOT_core_into) + tmp36 := lang.NewVector() + tmp37 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7283), kw_column, int(24), kw_end_DASH_line, int(7283), kw_end_DASH_column, int(25)) + tmp38, err := lang.WithMeta(tmp36, tmp37.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp39 := checkDerefVar(var_glojure_DOT_core_take) + tmp40 := lang.Apply(tmp39, []any{v2}) + tmp41 := checkDerefVar(var_glojure_DOT_core_concat) + tmp42 := lang.Apply(tmp41, []any{v22, v4}) + tmp43 := lang.Apply(tmp35, []any{tmp38, tmp40, tmp42}) + tmp44 := lang.Apply(tmp34, []any{tmp43}) + tmp23 = tmp44 + } + tmp14 = tmp23 + } // end let + tmp12 = tmp14 + } // end let + tmp11 = tmp12 + } else { + } + tmp7 = tmp11 + } // end let + return tmp7 + }) + tmp7 := lang.Apply(lang.NewLazySeq, []any{tmp6}) + return tmp7 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_partitionv = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_partitionv.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // partitionv-all + { + tmp0 := sym_partitionv_DASH_all.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n), lang.NewVector(sym_n, sym_coll), lang.NewVector(sym_n, sym_step, sym_coll)), kw_doc, "Returns a lazy sequence of vector partitions, but may include\n partitions with fewer than n items at the end.\n Returns a stateful transducer when no collection is provided.", kw_file, "glojure/core.glj", kw_added, "1.12", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(7285), kw_end_DASH_line, int(7285))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_partition_DASH_all) + tmp4 := lang.Apply(tmp3, []any{v2}) + return tmp4 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_partitionv_DASH_all) + tmp5 := lang.Apply(tmp4, []any{v2, v2, v3}) + return tmp5 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp6 any + { // let + // let binding "temp__0__auto__" + tmp7 := checkDerefVar(var_glojure_DOT_core_seq) + tmp8 := lang.Apply(tmp7, []any{v4}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + var tmp11 any + { // let + // let binding "s" + var v12 any = v9 + _ = v12 + var tmp13 any + { // let + // let binding "seg" + tmp14 := checkDerefVar(var_glojure_DOT_core_into) + tmp15 := lang.NewVector() + tmp16 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7297), kw_column, int(24), kw_end_DASH_line, int(7297), kw_end_DASH_column, int(25)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp18 := checkDerefVar(var_glojure_DOT_core_take) + tmp19 := lang.Apply(tmp18, []any{v2}) + tmp20 := lang.Apply(tmp14, []any{tmp17, tmp19, v4}) + var v21 any = tmp20 + _ = v21 + tmp22 := checkDerefVar(var_glojure_DOT_core_cons) + tmp23 := checkDerefVar(var_glojure_DOT_core_partitionv_DASH_all) + tmp24 := checkDerefVar(var_glojure_DOT_core_drop) + tmp25 := lang.Apply(tmp24, []any{v3, v12}) + tmp26 := lang.Apply(tmp23, []any{v2, v3, tmp25}) + tmp27 := lang.Apply(tmp22, []any{v21, tmp26}) + tmp13 = tmp27 + } // end let + tmp11 = tmp13 + } // end let + tmp10 = tmp11 + } else { + } + tmp6 = tmp10 + } // end let + return tmp6 + }) + tmp6 := lang.Apply(lang.NewLazySeq, []any{tmp5}) + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_partitionv_DASH_all = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_partitionv_DASH_all.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // splitv-at + { + tmp0 := sym_splitv_DASH_at.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_n, sym_coll)), kw_doc, "Returns a vector of [(into [] (take n) coll) (drop n coll)]", kw_file, "glojure/core.glj", kw_added, "1.12", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(7256), kw_end_DASH_line, int(7256))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_into) + tmp5 := lang.NewVector() + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7260), kw_column, int(10), kw_end_DASH_line, int(7260), kw_end_DASH_column, int(11)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp8 := checkDerefVar(var_glojure_DOT_core_take) + tmp9 := lang.Apply(tmp8, []any{v2}) + tmp10 := lang.Apply(tmp4, []any{tmp7, tmp9, v3}) + tmp11 := checkDerefVar(var_glojure_DOT_core_drop) + tmp12 := lang.Apply(tmp11, []any{v2, v3}) + tmp13 := lang.NewVector(tmp10, tmp12) + tmp14 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7260), kw_column, int(3), kw_end_DASH_line, int(7260), kw_end_DASH_column, int(41)) + tmp15, err := lang.WithMeta(tmp13, tmp14.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp15 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_splitv_DASH_at = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_splitv_DASH_at.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // iteration + { + tmp0 := sym_iteration.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_step, sym__AMP_, lang.NewMap(kw_keys, lang.NewVector(sym_somef, sym_vf, sym_kf, sym_initk), kw_or, lang.NewMap(sym_vf, sym_identity, sym_kf, sym_identity, sym_somef, sym_some_QMARK_, sym_initk, nil)))), kw_doc, "Creates a seqable/reducible via repeated calls to step,\n a function of some (continuation token) 'k'. The first call to step\n will be passed initk, returning 'ret'. Iff (somef ret) is true,\n (vf ret) will be included in the iteration, else iteration will\n terminate and vf/kf will not be called. If (kf ret) is non-nil it\n will be passed to the next step call, else iteration will terminate.\n\n This can be used e.g. to consume APIs that return paginated or batched data.\n\n step - (possibly impure) fn of 'k' -> 'ret'\n\n :somef - fn of 'ret' -> logical true/false, default 'some?'\n :vf - fn of 'ret' -> 'v', a value produced by the iteration, default 'identity'\n :kf - fn of 'ret' -> 'next-k' or nil (signaling 'do not continue'), default 'identity'\n :initk - the first value passed to step, default 'nil'\n\n It is presumed that step with non-initk is unreproducible/non-idempotent.\n If step with initk is unreproducible it is on the consumer to not consume twice.", kw_file, "glojure/core.glj", kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(7716), kw_end_DASH_line, int(7716))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + var tmp4 any + { // let + // let binding "map__683" + var v5 any = v3 + _ = v5 + // let binding "map__683" + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v5}) + if lang.IsTruthy(tmp8) { + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_next) + tmp11 := lang.Apply(tmp10, []any{v5}) + if lang.IsTruthy(tmp11) { + tmp12 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) + tmp13 := lang.Apply(tmp12, []any{v5}) + tmp14 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{tmp13}) + tmp9 = tmp14 + } else { + var tmp15 any + tmp16 := checkDerefVar(var_glojure_DOT_core_seq) + tmp17 := lang.Apply(tmp16, []any{v5}) + if lang.IsTruthy(tmp17) { + tmp18 := checkDerefVar(var_glojure_DOT_core_first) + tmp19 := lang.Apply(tmp18, []any{v5}) + tmp15 = tmp19 + } else { + } + tmp9 = tmp15 + } + tmp6 = tmp9 + } else { + tmp6 = v5 + } + var v20 any = tmp6 + _ = v20 + // let binding "somef" + tmp21 := checkDerefVar(var_glojure_DOT_core_get) + tmp22 := checkDerefVar(var_glojure_DOT_core_some_QMARK_) + tmp23 := lang.Apply(tmp21, []any{v20, kw_somef, tmp22}) + var v24 any = tmp23 + _ = v24 + // let binding "vf" + tmp25 := checkDerefVar(var_glojure_DOT_core_get) + tmp26 := checkDerefVar(var_glojure_DOT_core_identity) + tmp27 := lang.Apply(tmp25, []any{v20, kw_vf, tmp26}) + var v28 any = tmp27 + _ = v28 + // let binding "kf" + tmp29 := checkDerefVar(var_glojure_DOT_core_get) + tmp30 := checkDerefVar(var_glojure_DOT_core_identity) + tmp31 := lang.Apply(tmp29, []any{v20, kw_kf, tmp30}) + var v32 any = tmp31 + _ = v32 + // let binding "initk" + tmp33 := checkDerefVar(var_glojure_DOT_core_get) + tmp34 := lang.Apply(tmp33, []any{v20, kw_initk, nil}) + var v35 any = tmp34 + _ = v35 + tmp36 := checkDerefVar(var_glojure_DOT_core_seq) + tmp37 := lang.NewVector(nil) + tmp38 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7743), kw_column, int(9), kw_end_DASH_line, int(7743), kw_end_DASH_column, int(11)) + tmp39, err := lang.WithMeta(tmp37, tmp38.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var tmp40 lang.FnFunc + { // function next + var v41 lang.FnFunc + tmp40 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v42 := args[0] + _ = v42 + var tmp43 any + tmp44 := lang.Apply(v24, []any{v42}) + if lang.IsTruthy(tmp44) { + tmp45 := checkDerefVar(var_glojure_DOT_core_cons) + tmp46 := lang.Apply(v28, []any{v42}) + var tmp47 any + { // let + // let binding "temp__0__auto__" + tmp48 := lang.Apply(v32, []any{v42}) + var v49 any = tmp48 + _ = v49 + var tmp50 any + tmp51 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp52 := lang.Apply(tmp51, []any{v49}) + if lang.IsTruthy(tmp52) { + } else { + var tmp53 any + { // let + // let binding "k" + var v54 any = v49 + _ = v54 + var tmp55 lang.FnFunc + tmp55 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp56 := lang.Apply(v2, []any{v54}) + tmp57 := lang.Apply(v41, []any{tmp56}) + return tmp57 + }) + tmp56 := lang.Apply(lang.NewLazySeq, []any{tmp55}) + tmp53 = tmp56 + } // end let + tmp50 = tmp53 + } + tmp47 = tmp50 + } // end let + tmp48 := lang.Apply(tmp45, []any{tmp46, tmp47}) + tmp43 = tmp48 + } else { + } + return tmp43 + }) + v41 = tmp40 + _ = v41 + } + tmp41 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7744), kw_column, int(10), kw_end_DASH_line, int(7748), kw_end_DASH_column, int(51)) + tmp42, err := lang.WithMeta(tmp40, tmp41.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp43 := lang.Apply(v2, []any{v35}) + tmp44 := lang.Apply(tmp42, []any{tmp43}) + tmp45 := lang.Apply(tmp36, []any{tmp39, tmp44}) + tmp46 := reflect.TypeOf((*lang.IReduceInit)(nil)).Elem() + tmp47 := checkDerefVar(var_glojure_DOT_core_reduce) + tmp48 := lang.NewVector(nil, nil, nil) + tmp49 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7751), kw_column, int(12), kw_end_DASH_line, int(7751), kw_end_DASH_column, int(22)) + tmp50, err := lang.WithMeta(tmp48, tmp49.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var tmp51 any + { // let + // let binding "acc" + var v52 any = nil + _ = v52 + // let binding "ret" + tmp53 := lang.Apply(v2, []any{v35}) + var v54 any = tmp53 + _ = v54 + for { + var tmp55 any + tmp56 := lang.Apply(v24, []any{v54}) + if lang.IsTruthy(tmp56) { + var tmp57 any + { // let + // let binding "acc" + tmp58 := lang.Apply(v28, []any{v54}) + tmp59 := lang.Apply(nil, []any{v52, tmp58}) + var v60 any = tmp59 + _ = v60 + var tmp61 any + tmp62 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) + tmp63 := lang.Apply(tmp62, []any{v60}) + if lang.IsTruthy(tmp63) { + tmp64 := checkDerefVar(var_glojure_DOT_core_deref) + tmp65 := lang.Apply(tmp64, []any{v60}) + tmp61 = tmp65 + } else { + var tmp66 any + { // let + // let binding "temp__0__auto__" + tmp67 := lang.Apply(v32, []any{v54}) + var v68 any = tmp67 + _ = v68 + var tmp69 any + tmp70 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp71 := lang.Apply(tmp70, []any{v68}) + if lang.IsTruthy(tmp71) { + tmp69 = v60 + } else { + var tmp72 any + { // let + // let binding "k" + var v73 any = v68 + _ = v73 + var tmp74 any = v60 + tmp76 := lang.Apply(v2, []any{v73}) + var tmp75 any = tmp76 + v52 = tmp74 + v54 = tmp75 + continue + } // end let + tmp69 = tmp72 + } + tmp66 = tmp69 + } // end let + tmp61 = tmp66 + } + tmp57 = tmp61 + } // end let + tmp55 = tmp57 + } else { + tmp55 = v52 + } + tmp51 = tmp55 + break + } + } // end let + tmp52 := lang.Apply(tmp47, []any{tmp50, tmp51}) + tmp53 := lang.Apply(nil, []any{nil, tmp45, tmp46, tmp52}) + tmp4 = tmp53 + } // end let + return tmp4 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_iteration = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_iteration.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // load + { + tmp0 := sym_load.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_paths)), kw_doc, "Loads Clojure code from resources in classpath. A path is interpreted as\n classpath-relative if it begins with a slash or relative to the root\n directory for the current namespace otherwise.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_redef, true, kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(6095), kw_end_DASH_line, int(6095))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + var tmp3 any + { // let + // let binding "seq_824" + tmp4 := checkDerefVar(var_glojure_DOT_core_seq) + tmp5 := lang.Apply(tmp4, []any{v2}) + var v6 any = tmp5 + _ = v6 + // let binding "chunk_825" + var v7 any = nil + _ = v7 + // let binding "count_826" + var v8 any = int64(0) + _ = v8 + // let binding "i_827" + var v9 any = int64(0) + _ = v9 + for { + var tmp10 any + tmp11 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp12 := lang.Apply(tmp11, []any{v9, v8}) + if lang.IsTruthy(tmp12) { + var tmp13 any + { // let + // let binding "path" + tmp14, _ := lang.FieldOrMethod(v7, "nth") + if reflect.TypeOf(tmp14).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp15 := lang.Apply(tmp14, []any{v9}) + var v16 any = tmp15 + _ = v16 + var tmp17 any + { // let + // let binding "path" + var tmp18 any + tmp19 := lang.Apply(strings8.HasPrefix, []any{v16, "/"}) + if lang.IsTruthy(tmp19) { + tmp18 = v16 + } else { + tmp20 := checkDerefVar(var_glojure_DOT_core_str) + tmp21 := checkDerefVar(var_glojure_DOT_core_root_DASH_directory) + tmp22 := checkDerefVar(var_glojure_DOT_core_ns_DASH_name) + tmp23 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp24 := lang.Apply(tmp22, []any{tmp23}) + tmp25 := lang.Apply(tmp21, []any{tmp24}) + tmp26 := lang.Apply(tmp20, []any{tmp25, lang.NewChar(47), v16}) + tmp18 = tmp26 + } + var v27 any = tmp18 + _ = v27 + var tmp28 any + tmp29 := checkDerefVar(var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_) + if lang.IsTruthy(tmp29) { + tmp30 := checkDerefVar(var_glojure_DOT_core_printf) + tmp31 := lang.Apply(tmp30, []any{"(glojure.core/load \"%s\")\n", v27}) + _ = tmp31 + tmp32 := checkDerefVar(var_glojure_DOT_core_flush) + tmp33 := lang.Apply(tmp32, nil) + tmp28 = tmp33 + } else { + } + _ = tmp28 + tmp34 := checkDerefVar(var_glojure_DOT_core_check_DASH_cyclic_DASH_dependency) + tmp35 := lang.Apply(tmp34, []any{v27}) + _ = tmp35 + var tmp36 any + tmp37 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp38 := checkDerefVar(var_glojure_DOT_core_first) + tmp39 := checkDerefVar(var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_) + tmp40 := lang.Apply(tmp38, []any{tmp39}) + tmp41 := lang.Apply(tmp37, []any{v27, tmp40}) + if lang.IsTruthy(tmp41) { + } else { + var tmp42 any + { // let + tmp43 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp44 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp45 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_pending_DASH_paths_STAR_) + tmp46 := checkDerefVar(var_glojure_DOT_core_conj) + tmp47 := checkDerefVar(var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_) + tmp48 := lang.Apply(tmp46, []any{tmp47, v27}) + tmp49 := lang.Apply(tmp44, []any{tmp45, tmp48}) + tmp50 := lang.Apply(tmp43, []any{tmp49}) + _ = tmp50 + var tmp51 any + func() { + defer func() { + tmp52 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp53 := lang.Apply(tmp52, nil) + _ = tmp53 + }() + tmp54 := lang.Apply(strings8.TrimPrefix, []any{v27, "/"}) + tmp55, _ := lang.FieldOrMethod(runtime.RT, "Load") + if reflect.TypeOf(tmp55).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Load is not a function"))) + } + tmp56 := lang.Apply(tmp55, []any{tmp54}) + tmp51 = tmp56 + }() + tmp42 = tmp51 + } // end let + tmp36 = tmp42 + } + tmp17 = tmp36 + } // end let + _ = tmp17 + var tmp18 any = v6 + var tmp19 any = v7 + var tmp20 any = v8 + tmp22 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp23 := lang.Apply(tmp22, []any{v9}) + var tmp21 any = tmp23 + v6 = tmp18 + v7 = tmp19 + v8 = tmp20 + v9 = tmp21 + continue + } // end let + tmp10 = tmp13 + } else { + var tmp14 any + { // let + // let binding "temp__0__auto__" + tmp15 := checkDerefVar(var_glojure_DOT_core_seq) + tmp16 := lang.Apply(tmp15, []any{v6}) + var v17 any = tmp16 + _ = v17 + var tmp18 any + if lang.IsTruthy(v17) { + var tmp19 any + { // let + // let binding "seq_824" + var v20 any = v17 + _ = v20 + var tmp21 any + tmp22 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp23 := lang.Apply(tmp22, []any{v20}) + if lang.IsTruthy(tmp23) { + var tmp24 any + { // let + // let binding "c__0__auto__" + tmp25 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp26 := lang.Apply(tmp25, []any{v20}) + var v27 any = tmp26 + _ = v27 + tmp29 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp30 := lang.Apply(tmp29, []any{v20}) + var tmp28 any = tmp30 + var tmp31 any = v27 + tmp33 := checkDerefVar(var_glojure_DOT_core_int) + tmp34 := checkDerefVar(var_glojure_DOT_core_count) + tmp35 := lang.Apply(tmp34, []any{v27}) + tmp36 := lang.Apply(tmp33, []any{tmp35}) + var tmp32 any = tmp36 + tmp38 := checkDerefVar(var_glojure_DOT_core_int) + tmp39 := lang.Apply(tmp38, []any{int64(0)}) + var tmp37 any = tmp39 + v6 = tmp28 + v7 = tmp31 + v8 = tmp32 + v9 = tmp37 + continue + } // end let + tmp21 = tmp24 + } else { + var tmp25 any + { // let + // let binding "path" + tmp26 := checkDerefVar(var_glojure_DOT_core_first) + tmp27 := lang.Apply(tmp26, []any{v20}) + var v28 any = tmp27 + _ = v28 + var tmp29 any + { // let + // let binding "path" + var tmp30 any + tmp31 := lang.Apply(strings8.HasPrefix, []any{v28, "/"}) + if lang.IsTruthy(tmp31) { + tmp30 = v28 + } else { + tmp32 := checkDerefVar(var_glojure_DOT_core_str) + tmp33 := checkDerefVar(var_glojure_DOT_core_root_DASH_directory) + tmp34 := checkDerefVar(var_glojure_DOT_core_ns_DASH_name) + tmp35 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp36 := lang.Apply(tmp34, []any{tmp35}) + tmp37 := lang.Apply(tmp33, []any{tmp36}) + tmp38 := lang.Apply(tmp32, []any{tmp37, lang.NewChar(47), v28}) + tmp30 = tmp38 + } + var v39 any = tmp30 + _ = v39 + var tmp40 any + tmp41 := checkDerefVar(var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_) + if lang.IsTruthy(tmp41) { + tmp42 := checkDerefVar(var_glojure_DOT_core_printf) + tmp43 := lang.Apply(tmp42, []any{"(glojure.core/load \"%s\")\n", v39}) + _ = tmp43 + tmp44 := checkDerefVar(var_glojure_DOT_core_flush) + tmp45 := lang.Apply(tmp44, nil) + tmp40 = tmp45 + } else { + } + _ = tmp40 + tmp46 := checkDerefVar(var_glojure_DOT_core_check_DASH_cyclic_DASH_dependency) + tmp47 := lang.Apply(tmp46, []any{v39}) + _ = tmp47 + var tmp48 any + tmp49 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp50 := checkDerefVar(var_glojure_DOT_core_first) + tmp51 := checkDerefVar(var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_) + tmp52 := lang.Apply(tmp50, []any{tmp51}) + tmp53 := lang.Apply(tmp49, []any{v39, tmp52}) + if lang.IsTruthy(tmp53) { + } else { + var tmp54 any + { // let + tmp55 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp56 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp57 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_pending_DASH_paths_STAR_) + tmp58 := checkDerefVar(var_glojure_DOT_core_conj) + tmp59 := checkDerefVar(var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_) + tmp60 := lang.Apply(tmp58, []any{tmp59, v39}) + tmp61 := lang.Apply(tmp56, []any{tmp57, tmp60}) + tmp62 := lang.Apply(tmp55, []any{tmp61}) + _ = tmp62 + var tmp63 any + func() { + defer func() { + tmp64 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp65 := lang.Apply(tmp64, nil) + _ = tmp65 + }() + tmp66 := lang.Apply(strings8.TrimPrefix, []any{v39, "/"}) + tmp67, _ := lang.FieldOrMethod(runtime.RT, "Load") + if reflect.TypeOf(tmp67).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Load is not a function"))) + } + tmp68 := lang.Apply(tmp67, []any{tmp66}) + tmp63 = tmp68 + }() + tmp54 = tmp63 + } // end let + tmp48 = tmp54 + } + tmp29 = tmp48 + } // end let + _ = tmp29 + tmp31 := checkDerefVar(var_glojure_DOT_core_next) + tmp32 := lang.Apply(tmp31, []any{v20}) + var tmp30 any = tmp32 + var tmp33 any = nil + var tmp34 any = int64(0) + var tmp35 any = int64(0) + v6 = tmp30 + v7 = tmp33 + v8 = tmp34 + v9 = tmp35 + continue + } // end let + tmp21 = tmp25 + } + tmp19 = tmp21 + } // end let + tmp18 = tmp19 + } else { + } + tmp14 = tmp18 + } // end let + tmp10 = tmp14 + } + tmp3 = tmp10 + break + } + } // end let + return tmp3 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_load = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_load.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // load-one + { + tmp0 := sym_load_DASH_one.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_lib, sym_need_DASH_ns, sym_require)), kw_doc, "Loads a lib given its name. If need-ns, ensures that the associated\n namespace exists after loading. If require, records the load so any\n duplicate loads can be skipped.", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(8), kw_line, int(5879), kw_end_DASH_line, int(5879), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_load) + tmp6 := checkDerefVar(var_glojure_DOT_core_root_DASH_resource) + tmp7 := lang.Apply(tmp6, []any{v2}) + tmp8 := lang.Apply(tmp5, []any{tmp7}) + _ = tmp8 + tmp9 := checkDerefVar(var_glojure_DOT_core_throw_DASH_if) + var tmp10 any + { // let + // let binding "and__0__auto__" + var v11 any = v3 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + tmp13 := checkDerefVar(var_glojure_DOT_core_not) + tmp14 := checkDerefVar(var_glojure_DOT_core_find_DASH_ns) + tmp15 := lang.Apply(tmp14, []any{v2}) + tmp16 := lang.Apply(tmp13, []any{tmp15}) + tmp12 = tmp16 + } else { + tmp12 = v11 + } + tmp10 = tmp12 + } // end let + tmp11 := checkDerefVar(var_glojure_DOT_core_root_DASH_resource) + tmp12 := lang.Apply(tmp11, []any{v2}) + tmp13 := lang.Apply(tmp9, []any{tmp10, "namespace '%s' not found after loading '%s'", v2, tmp12}) + _ = tmp13 + var tmp14 any + if lang.IsTruthy(v4) { + var tmp15 lang.FnFunc + tmp15 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp16 := checkDerefVar(var_glojure_DOT_core_commute) + tmp17 := checkDerefVar(var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_) + tmp18 := checkDerefVar(var_glojure_DOT_core_conj) + tmp19 := lang.Apply(tmp16, []any{tmp17, tmp18, v2}) + return tmp19 + }) + tmp16, _ := lang.FieldOrMethod(lang.LockingTransaction, "RunInTransaction") + if reflect.TypeOf(tmp16).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("RunInTransaction is not a function"))) + } + tmp17 := lang.Apply(tmp16, []any{tmp15}) + tmp14 = tmp17 + } else { + } + return tmp14 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_load_DASH_one = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_load_DASH_one.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // load-all + { + tmp0 := sym_load_DASH_all.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_lib, sym_need_DASH_ns, sym_require)), kw_doc, "Loads a lib given its name and forces a load of any libs it directly or\n indirectly loads. If need-ns, ensures that the associated namespace\n exists after loading. If require, records the load so any duplicate loads\n can be skipped.", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(8), kw_line, int(5892), kw_end_DASH_line, int(5892), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp6 := checkDerefVar(var_glojure_DOT_core_commute) + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_) + var tmp8 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v9 := args[0] + _ = v9 + v10 := args[1] + _ = v10 + tmp11 := checkDerefVar(var_glojure_DOT_core_reduce1) + tmp12 := checkDerefVar(var_glojure_DOT_core_conj) + tmp13 := lang.Apply(tmp11, []any{tmp12, v9, v10}) + return tmp13 + }) + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5899), kw_column, int(27), kw_end_DASH_line, int(5899), kw_end_DASH_column, int(47)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var tmp11 any + { // let + tmp12 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp13 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp14 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_loaded_DASH_libs_STAR_) + tmp15 := checkDerefVar(var_glojure_DOT_core_ref) + tmp16 := checkDerefVar(var_glojure_DOT_core_sorted_DASH_set) + tmp17 := lang.Apply(tmp16, nil) + tmp18 := lang.Apply(tmp15, []any{tmp17}) + tmp19 := lang.Apply(tmp13, []any{tmp14, tmp18}) + tmp20 := lang.Apply(tmp12, []any{tmp19}) + _ = tmp20 + var tmp21 any + func() { + defer func() { + tmp22 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp23 := lang.Apply(tmp22, nil) + _ = tmp23 + }() + tmp24 := checkDerefVar(var_glojure_DOT_core_load_DASH_one) + tmp25 := lang.Apply(tmp24, []any{v2, v3, v4}) + _ = tmp25 + tmp26 := checkDerefVar(var_glojure_DOT_core_deref) + tmp27 := checkDerefVar(var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_) + tmp28 := lang.Apply(tmp26, []any{tmp27}) + tmp21 = tmp28 + }() + tmp11 = tmp21 + } // end let + tmp12 := lang.Apply(tmp6, []any{tmp7, tmp10, tmp11}) + return tmp12 + }) + tmp6, _ := lang.FieldOrMethod(lang.LockingTransaction, "RunInTransaction") + if reflect.TypeOf(tmp6).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("RunInTransaction is not a function"))) + } + tmp7 := lang.Apply(tmp6, []any{tmp5}) + return tmp7 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_load_DASH_all = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_load_DASH_all.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // load-data-reader-file + { + tmp0 := sym_load_DASH_data_DASH_reader_DASH_file.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7836), kw_column, int(8), kw_end_DASH_line, int(7836), kw_end_DASH_column, int(28), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_mappings, sym_url)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "rdr" + tmp5, ok := lang.FieldOrMethod(v3, "openStream") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "openStream"))) + } + var tmp6 any + switch reflect.TypeOf(tmp5).Kind() { + case reflect.Func: + tmp6 = lang.Apply(tmp5, nil) + default: + tmp6 = tmp5 + } + tmp7 := lang.Apply(nil, []any{tmp6, "UTF-8"}) + tmp8 := lang.Apply(nil, []any{tmp7}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + func() { + defer func() { + tmp11, ok := lang.FieldOrMethod(v9, "close") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v9, "close"))) + } + var tmp12 any + switch reflect.TypeOf(tmp11).Kind() { + case reflect.Func: + tmp12 = lang.Apply(tmp11, nil) + default: + tmp12 = tmp11 + } + _ = tmp12 + }() + var tmp13 any + { // let + tmp14 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp15 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp16 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_file_STAR_) + tmp17, ok := lang.FieldOrMethod(v3, "getFile") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getFile"))) + } + var tmp18 any + switch reflect.TypeOf(tmp17).Kind() { + case reflect.Func: + tmp18 = lang.Apply(tmp17, nil) + default: + tmp18 = tmp17 + } + tmp19 := lang.Apply(tmp15, []any{tmp16, tmp18}) + tmp20 := lang.Apply(tmp14, []any{tmp19}) + _ = tmp20 + var tmp21 any + func() { + defer func() { + tmp22 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp23 := lang.Apply(tmp22, nil) + _ = tmp23 + }() + var tmp24 any + { // let + // let binding "read-opts" + var tmp25 any + tmp26, ok := lang.FieldOrMethod(v3, "getPath") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getPath"))) + } + var tmp27 any + switch reflect.TypeOf(tmp26).Kind() { + case reflect.Func: + tmp27 = lang.Apply(tmp26, nil) + default: + tmp27 = tmp26 + } + tmp28, _ := lang.FieldOrMethod(tmp27, "endsWith") + if reflect.TypeOf(tmp28).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("endsWith is not a function"))) + } + tmp29 := lang.Apply(tmp28, []any{"cljc"}) + if lang.IsTruthy(tmp29) { + tmp30 := lang.NewMap(kw_eof, nil, kw_read_DASH_cond, kw_allow) + tmp31 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7842), kw_column, int(25), kw_end_DASH_line, int(7842), kw_end_DASH_column, int(52)) + tmp32, err := lang.WithMeta(tmp30, tmp31.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp25 = tmp32 + } else { + tmp33 := lang.NewMap(kw_eof, nil) + tmp34 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7843), kw_column, int(25), kw_end_DASH_line, int(7843), kw_end_DASH_column, int(34)) + tmp35, err := lang.WithMeta(tmp33, tmp34.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp25 = tmp35 + } + var v36 any = tmp25 + _ = v36 + // let binding "new-mappings" + tmp37 := checkDerefVar(var_glojure_DOT_core_read) + tmp38 := lang.Apply(tmp37, []any{v36, v9}) + var v39 any = tmp38 + _ = v39 + var tmp40 any + tmp41 := checkDerefVar(var_glojure_DOT_core_not) + tmp42 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp43 := lang.Apply(tmp42, []any{v39}) + tmp44 := lang.Apply(tmp41, []any{tmp43}) + if lang.IsTruthy(tmp44) { + tmp45 := checkDerefVar(var_glojure_DOT_core_ex_DASH_info) + tmp46 := checkDerefVar(var_glojure_DOT_core_str) + tmp47 := lang.Apply(tmp46, []any{"Not a valid data-reader map"}) + tmp48 := lang.NewMap(kw_url, v3) + tmp49 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7847), kw_column, int(27), kw_end_DASH_line, int(7847), kw_end_DASH_column, int(36)) + tmp50, err := lang.WithMeta(tmp48, tmp49.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp51 := lang.Apply(tmp45, []any{tmp47, tmp50}) + panic(tmp51) + } else { + } + _ = tmp40 + tmp52 := checkDerefVar(var_glojure_DOT_core_reduce) + var tmp53 lang.FnFunc + tmp53 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v54 := args[0] + _ = v54 + v55 := args[1] + _ = v55 + var tmp56 any + { // let + // let binding "vec__685" + var v57 any = v55 + _ = v57 + // let binding "k" + tmp58 := checkDerefVar(var_glojure_DOT_core_nth) + tmp59 := lang.Apply(tmp58, []any{v57, int64(0), nil}) + var v60 any = tmp59 + _ = v60 + // let binding "v" + tmp61 := checkDerefVar(var_glojure_DOT_core_nth) + tmp62 := lang.Apply(tmp61, []any{v57, int64(1), nil}) + var v63 any = tmp62 + _ = v63 + var tmp64 any + tmp65 := checkDerefVar(var_glojure_DOT_core_not) + tmp66 := checkDerefVar(var_glojure_DOT_core_symbol_QMARK_) + tmp67 := lang.Apply(tmp66, []any{v60}) + tmp68 := lang.Apply(tmp65, []any{tmp67}) + if lang.IsTruthy(tmp68) { + tmp69 := checkDerefVar(var_glojure_DOT_core_ex_DASH_info) + tmp70 := checkDerefVar(var_glojure_DOT_core_str) + tmp71 := lang.Apply(tmp70, []any{"Invalid form in data-reader file"}) + tmp72 := lang.NewMap(kw_url, v3, kw_form, v60) + tmp73 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7852), kw_column, int(30), kw_end_DASH_line, int(7853), kw_end_DASH_column, int(38)) + tmp74, err := lang.WithMeta(tmp72, tmp73.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp75 := lang.Apply(tmp69, []any{tmp71, tmp74}) + panic(tmp75) + } else { + } + _ = tmp64 + var tmp76 any + { // let + // let binding "v-var" + tmp77 := checkDerefVar(var_glojure_DOT_core_data_DASH_reader_DASH_var) + tmp78 := lang.Apply(tmp77, []any{v63}) + var v79 any = tmp78 + _ = v79 + var tmp80 any + var tmp81 any + { // let + // let binding "and__0__auto__" + tmp82 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp83 := lang.Apply(tmp82, []any{v2, v60}) + var v84 any = tmp83 + _ = v84 + var tmp85 any + if lang.IsTruthy(v84) { + tmp86 := checkDerefVar(var_glojure_DOT_core_not_EQ_) + tmp87 := lang.Apply(v2, []any{v60}) + tmp88 := lang.Apply(tmp86, []any{tmp87, v79}) + tmp85 = tmp88 + } else { + tmp85 = v84 + } + tmp81 = tmp85 + } // end let + if lang.IsTruthy(tmp81) { + tmp82 := checkDerefVar(var_glojure_DOT_core_ex_DASH_info) + tmp83 := lang.NewMap(kw_url, v3, kw_conflict, v60, kw_mappings, v54) + tmp84 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7858), kw_column, int(32), kw_end_DASH_line, int(7860), kw_end_DASH_column, int(44)) + tmp85, err := lang.WithMeta(tmp83, tmp84.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp86 := lang.Apply(tmp82, []any{"Conflicting data-reader mapping", tmp85}) + panic(tmp86) + } else { + } + _ = tmp80 + tmp87 := checkDerefVar(var_glojure_DOT_core_assoc) + tmp88 := lang.Apply(tmp87, []any{v54, v60, v79}) + tmp76 = tmp88 + } // end let + tmp56 = tmp76 + } // end let + return tmp56 + }) + tmp54 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7849), kw_column, int(10), kw_end_DASH_line, int(7861), kw_end_DASH_column, int(32)) + tmp55, err := lang.WithMeta(tmp53, tmp54.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp56 := lang.Apply(tmp52, []any{tmp55, v2, v39}) + tmp24 = tmp56 + } // end let + tmp21 = tmp24 + }() + tmp13 = tmp21 + } // end let + tmp10 = tmp13 + }() + tmp4 = tmp10 + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_load_DASH_data_DASH_reader_DASH_file = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_load_DASH_data_DASH_reader_DASH_file.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // load-data-readers + { + tmp0 := sym_load_DASH_data_DASH_readers.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7865), kw_column, int(8), kw_end_DASH_line, int(7865), kw_end_DASH_column, int(24), kw_private, true, kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp2 := checkDerefVar(var_glojure_DOT_core_alter_DASH_var_DASH_root) + tmp3 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_data_DASH_readers_STAR_) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v5 := args[0] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_reduce) + tmp7 := checkDerefVar(var_glojure_DOT_core_load_DASH_data_DASH_reader_DASH_file) + tmp8 := checkDerefVar(var_glojure_DOT_core_data_DASH_reader_DASH_urls) + tmp9 := lang.Apply(tmp8, nil) + tmp10 := lang.Apply(tmp6, []any{tmp7, v5, tmp9}) + return tmp10 + }) + tmp5 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7867), kw_column, int(19), kw_end_DASH_line, int(7869), kw_end_DASH_column, int(57)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp7 := lang.Apply(tmp2, []any{tmp3, tmp6}) + return tmp7 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_load_DASH_data_DASH_readers = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_load_DASH_data_DASH_readers.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // load-lib + { + tmp0 := sym_load_DASH_lib.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_prefix, sym_lib, sym__AMP_, sym_options)), kw_doc, "Loads a lib with options", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(8), kw_line, int(5904), kw_end_DASH_line, int(5904), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_throw_DASH_if) + var tmp6 any + { // let + // let binding "and__0__auto__" + var v7 any = v2 + _ = v7 + var tmp8 any + if lang.IsTruthy(v7) { + tmp9 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp10 := checkDerefVar(var_glojure_DOT_core_name) + tmp11 := lang.Apply(tmp10, []any{v3}) + tmp12 := checkDerefVar(var_glojure_DOT_core_int) + tmp13 := lang.Apply(tmp12, []any{lang.NewChar(46)}) + tmp14 := lang.Apply(strings8.Index, []any{tmp11, tmp13}) + tmp15 := lang.Apply(tmp9, []any{tmp14}) + tmp8 = tmp15 + } else { + tmp8 = v7 + } + tmp6 = tmp8 + } // end let + tmp7 := checkDerefVar(var_glojure_DOT_core_name) + tmp8 := lang.Apply(tmp7, []any{v3}) + tmp9 := lang.Apply(tmp5, []any{tmp6, "Found lib name '%s' containing period with prefix '%s'. lib names inside prefix lists must not contain periods", tmp8, v2}) + _ = tmp9 + var tmp10 any + { // let + // let binding "lib" + var tmp11 any + if lang.IsTruthy(v2) { + tmp12 := checkDerefVar(var_glojure_DOT_core_symbol) + tmp13 := checkDerefVar(var_glojure_DOT_core_str) + tmp14 := lang.Apply(tmp13, []any{v2, lang.NewChar(46), v3}) + tmp15 := lang.Apply(tmp12, []any{tmp14}) + tmp11 = tmp15 + } else { + tmp11 = v3 + } + var v16 any = tmp11 + _ = v16 + // let binding "opts" + tmp17 := checkDerefVar(var_glojure_DOT_core_apply) + tmp18 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp19 := lang.Apply(tmp17, []any{tmp18, v4}) + var v20 any = tmp19 + _ = v20 + // let binding "map__801" + var v21 any = v20 + _ = v21 + // let binding "map__801" + var tmp22 any + tmp23 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp24 := lang.Apply(tmp23, []any{v21}) + if lang.IsTruthy(tmp24) { + var tmp25 any + tmp26 := checkDerefVar(var_glojure_DOT_core_next) + tmp27 := lang.Apply(tmp26, []any{v21}) + if lang.IsTruthy(tmp27) { + tmp28 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) + tmp29 := lang.Apply(tmp28, []any{v21}) + tmp30 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{tmp29}) + tmp25 = tmp30 + } else { + var tmp31 any + tmp32 := checkDerefVar(var_glojure_DOT_core_seq) + tmp33 := lang.Apply(tmp32, []any{v21}) + if lang.IsTruthy(tmp33) { + tmp34 := checkDerefVar(var_glojure_DOT_core_first) + tmp35 := lang.Apply(tmp34, []any{v21}) + tmp31 = tmp35 + } else { + } + tmp25 = tmp31 + } + tmp22 = tmp25 + } else { + tmp22 = v21 + } + var v36 any = tmp22 + _ = v36 + // let binding "as" + tmp37 := checkDerefVar(var_glojure_DOT_core_get) + tmp38 := lang.Apply(tmp37, []any{v36, kw_as}) + var v39 any = tmp38 + _ = v39 + // let binding "reload" + tmp40 := checkDerefVar(var_glojure_DOT_core_get) + tmp41 := lang.Apply(tmp40, []any{v36, kw_reload}) + var v42 any = tmp41 + _ = v42 + // let binding "reload-all" + tmp43 := checkDerefVar(var_glojure_DOT_core_get) + tmp44 := lang.Apply(tmp43, []any{v36, kw_reload_DASH_all}) + var v45 any = tmp44 + _ = v45 + // let binding "require" + tmp46 := checkDerefVar(var_glojure_DOT_core_get) + tmp47 := lang.Apply(tmp46, []any{v36, kw_require}) + var v48 any = tmp47 + _ = v48 + // let binding "use" + tmp49 := checkDerefVar(var_glojure_DOT_core_get) + tmp50 := lang.Apply(tmp49, []any{v36, kw_use}) + var v51 any = tmp50 + _ = v51 + // let binding "verbose" + tmp52 := checkDerefVar(var_glojure_DOT_core_get) + tmp53 := lang.Apply(tmp52, []any{v36, kw_verbose}) + var v54 any = tmp53 + _ = v54 + // let binding "as-alias" + tmp55 := checkDerefVar(var_glojure_DOT_core_get) + tmp56 := lang.Apply(tmp55, []any{v36, kw_as_DASH_alias}) + var v57 any = tmp56 + _ = v57 + // let binding "loaded" + tmp58 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp59 := checkDerefVar(var_glojure_DOT_core_deref) + tmp60 := checkDerefVar(var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_) + tmp61 := lang.Apply(tmp59, []any{tmp60}) + tmp62 := lang.Apply(tmp58, []any{tmp61, v16}) + var v63 any = tmp62 + _ = v63 + // let binding "need-ns" + var tmp64 any + { // let + // let binding "or__0__auto__" + var v65 any = v39 + _ = v65 + var tmp66 any + if lang.IsTruthy(v65) { + tmp66 = v65 + } else { + tmp66 = v51 + } + tmp64 = tmp66 + } // end let + var v65 any = tmp64 + _ = v65 + // let binding "load" + var tmp66 any + if lang.IsTruthy(v45) { + tmp67 := checkDerefVar(var_glojure_DOT_core_load_DASH_all) + tmp66 = tmp67 + } else { + var tmp68 any + if lang.IsTruthy(v42) { + tmp69 := checkDerefVar(var_glojure_DOT_core_load_DASH_one) + tmp68 = tmp69 + } else { + var tmp70 any + tmp71 := checkDerefVar(var_glojure_DOT_core_not) + tmp72 := lang.Apply(tmp71, []any{v63}) + if lang.IsTruthy(tmp72) { + var tmp73 any + if lang.IsTruthy(v65) { + tmp74 := checkDerefVar(var_glojure_DOT_core_load_DASH_one) + tmp73 = tmp74 + } else { + var tmp75 any + if lang.IsTruthy(v57) { + var tmp76 lang.FnFunc + tmp76 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v77 := args[0] + _ = v77 + v78 := args[1] + _ = v78 + v79 := args[2] + _ = v79 + tmp80 := checkDerefVar(var_glojure_DOT_core_create_DASH_ns) + tmp81 := lang.Apply(tmp80, []any{v77}) + return tmp81 + }) + tmp77 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5918), kw_column, int(48), kw_end_DASH_line, int(5918), kw_end_DASH_column, int(88)) + tmp78, err := lang.WithMeta(tmp76, tmp77.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp75 = tmp78 + } else { + var tmp79 any + if lang.IsTruthy(kw_else) { + tmp80 := checkDerefVar(var_glojure_DOT_core_load_DASH_one) + tmp79 = tmp80 + } else { + } + tmp75 = tmp79 + } + tmp73 = tmp75 + } + tmp70 = tmp73 + } else { + } + tmp68 = tmp70 + } + tmp66 = tmp68 + } + var v81 any = tmp66 + _ = v81 + // let binding "filter-opts" + tmp82 := checkDerefVar(var_glojure_DOT_core_select_DASH_keys) + tmp83 := lang.Apply(tmp82, []any{v20, lang.NewList(kw_exclude, kw_only, kw_rename, kw_refer)}) + var v84 any = tmp83 + _ = v84 + // let binding "undefined-on-entry" + tmp85 := checkDerefVar(var_glojure_DOT_core_not) + tmp86 := checkDerefVar(var_glojure_DOT_core_find_DASH_ns) + tmp87 := lang.Apply(tmp86, []any{v16}) + tmp88 := lang.Apply(tmp85, []any{tmp87}) + var v89 any = tmp88 + _ = v89 + var tmp90 any + { // let + tmp91 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp92 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp93 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_loading_DASH_verbosely_STAR_) + var tmp94 any + { // let + // let binding "or__0__auto__" + tmp95 := checkDerefVar(var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_) + var v96 any = tmp95 + _ = v96 + var tmp97 any + if lang.IsTruthy(v96) { + tmp97 = v96 + } else { + tmp97 = v54 + } + tmp94 = tmp97 + } // end let + tmp95 := lang.Apply(tmp92, []any{tmp93, tmp94}) + tmp96 := lang.Apply(tmp91, []any{tmp95}) + _ = tmp96 + var tmp97 any + func() { + defer func() { + tmp98 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp99 := lang.Apply(tmp98, nil) + _ = tmp99 + }() + var tmp100 any + if lang.IsTruthy(v81) { + var tmp101 any + func() { + defer func() { + if r := recover(); r != nil { + if lang.CatchMatches(r, lang.Builtins["any"]) { + v102 := r + _ = v102 + var tmp103 any + if lang.IsTruthy(v89) { + tmp104 := checkDerefVar(var_glojure_DOT_core_remove_DASH_ns) + tmp105 := lang.Apply(tmp104, []any{v16}) + tmp103 = tmp105 + } else { + } + _ = tmp103 + panic(v102) + } else { + panic(r) + } + } + }() + tmp102 := lang.Apply(v81, []any{v16, v65, v48}) + tmp101 = tmp102 + }() + tmp100 = tmp101 + } else { + tmp103 := checkDerefVar(var_glojure_DOT_core_throw_DASH_if) + var tmp104 any + { // let + // let binding "and__0__auto__" + var v105 any = v65 + _ = v105 + var tmp106 any + if lang.IsTruthy(v105) { + tmp107 := checkDerefVar(var_glojure_DOT_core_not) + tmp108 := checkDerefVar(var_glojure_DOT_core_find_DASH_ns) + tmp109 := lang.Apply(tmp108, []any{v16}) + tmp110 := lang.Apply(tmp107, []any{tmp109}) + tmp106 = tmp110 + } else { + tmp106 = v105 + } + tmp104 = tmp106 + } // end let + tmp105 := lang.Apply(tmp103, []any{tmp104, "namespace '%s' not found", v16}) + tmp100 = tmp105 + } + _ = tmp100 + var tmp106 any + var tmp107 any + { // let + // let binding "and__0__auto__" + var v108 any = v65 + _ = v108 + var tmp109 any + if lang.IsTruthy(v108) { + tmp110 := checkDerefVar(var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_) + tmp109 = tmp110 + } else { + tmp109 = v108 + } + tmp107 = tmp109 + } // end let + if lang.IsTruthy(tmp107) { + tmp108 := checkDerefVar(var_glojure_DOT_core_printf) + tmp109 := checkDerefVar(var_glojure_DOT_core_ns_DASH_name) + tmp110 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + tmp111 := lang.Apply(tmp109, []any{tmp110}) + tmp112 := lang.Apply(tmp108, []any{"(glojure.core/in-ns '%s)\n", tmp111}) + tmp106 = tmp112 + } else { + } + _ = tmp106 + var tmp113 any + if lang.IsTruthy(v39) { + var tmp114 any + tmp115 := checkDerefVar(var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_) + if lang.IsTruthy(tmp115) { + tmp116 := checkDerefVar(var_glojure_DOT_core_printf) + tmp117 := lang.Apply(tmp116, []any{"(glojure.core/alias '%s '%s)\n", v39, v16}) + tmp114 = tmp117 + } else { + } + _ = tmp114 + tmp118 := checkDerefVar(var_glojure_DOT_core_alias) + tmp119 := lang.Apply(tmp118, []any{v39, v16}) + tmp113 = tmp119 + } else { + } + _ = tmp113 + var tmp120 any + if lang.IsTruthy(v57) { + var tmp121 any + tmp122 := checkDerefVar(var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_) + if lang.IsTruthy(tmp122) { + tmp123 := checkDerefVar(var_glojure_DOT_core_printf) + tmp124 := lang.Apply(tmp123, []any{"(glojure.core/alias '%s '%s)\n", v57, v16}) + tmp121 = tmp124 + } else { + } + _ = tmp121 + tmp125 := checkDerefVar(var_glojure_DOT_core_alias) + tmp126 := lang.Apply(tmp125, []any{v57, v16}) + tmp120 = tmp126 + } else { + } + _ = tmp120 + var tmp127 any + var tmp128 any + { // let + // let binding "or__0__auto__" + var v129 any = v51 + _ = v129 + var tmp130 any + if lang.IsTruthy(v129) { + tmp130 = v129 + } else { + tmp131 := lang.Apply(kw_refer, []any{v84}) + tmp130 = tmp131 + } + tmp128 = tmp130 + } // end let + if lang.IsTruthy(tmp128) { + var tmp129 any + tmp130 := checkDerefVar(var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_) + if lang.IsTruthy(tmp130) { + tmp131 := checkDerefVar(var_glojure_DOT_core_printf) + tmp132 := lang.Apply(tmp131, []any{"(glojure.core/refer '%s", v16}) + _ = tmp132 + var tmp133 any + { // let + // let binding "seq_802" + tmp134 := checkDerefVar(var_glojure_DOT_core_seq) + tmp135 := lang.Apply(tmp134, []any{v84}) + var v136 any = tmp135 + _ = v136 + // let binding "chunk_803" + var v137 any = nil + _ = v137 + // let binding "count_804" + var v138 any = int64(0) + _ = v138 + // let binding "i_805" + var v139 any = int64(0) + _ = v139 + for { + var tmp140 any + tmp141 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp142 := lang.Apply(tmp141, []any{v139, v138}) + if lang.IsTruthy(tmp142) { + var tmp143 any + { // let + // let binding "opt" + tmp144, _ := lang.FieldOrMethod(v137, "nth") + if reflect.TypeOf(tmp144).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp145 := lang.Apply(tmp144, []any{v139}) + var v146 any = tmp145 + _ = v146 + tmp147 := checkDerefVar(var_glojure_DOT_core_printf) + tmp148 := checkDerefVar(var_glojure_DOT_core_key) + tmp149 := lang.Apply(tmp148, []any{v146}) + tmp150 := checkDerefVar(var_glojure_DOT_core_print_DASH_str) + tmp151 := checkDerefVar(var_glojure_DOT_core_val) + tmp152 := lang.Apply(tmp151, []any{v146}) + tmp153 := lang.Apply(tmp150, []any{tmp152}) + tmp154 := lang.Apply(tmp147, []any{" %s '%s", tmp149, tmp153}) + _ = tmp154 + var tmp155 any = v136 + var tmp156 any = v137 + var tmp157 any = v138 + tmp159 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp160 := lang.Apply(tmp159, []any{v139}) + var tmp158 any = tmp160 + v136 = tmp155 + v137 = tmp156 + v138 = tmp157 + v139 = tmp158 + continue + } // end let + tmp140 = tmp143 + } else { + var tmp144 any + { // let + // let binding "temp__0__auto__" + tmp145 := checkDerefVar(var_glojure_DOT_core_seq) + tmp146 := lang.Apply(tmp145, []any{v136}) + var v147 any = tmp146 + _ = v147 + var tmp148 any + if lang.IsTruthy(v147) { + var tmp149 any + { // let + // let binding "seq_802" + var v150 any = v147 + _ = v150 + var tmp151 any + tmp152 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp153 := lang.Apply(tmp152, []any{v150}) + if lang.IsTruthy(tmp153) { + var tmp154 any + { // let + // let binding "c__0__auto__" + tmp155 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp156 := lang.Apply(tmp155, []any{v150}) + var v157 any = tmp156 + _ = v157 + tmp159 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp160 := lang.Apply(tmp159, []any{v150}) + var tmp158 any = tmp160 + var tmp161 any = v157 + tmp163 := checkDerefVar(var_glojure_DOT_core_int) + tmp164 := checkDerefVar(var_glojure_DOT_core_count) + tmp165 := lang.Apply(tmp164, []any{v157}) + tmp166 := lang.Apply(tmp163, []any{tmp165}) + var tmp162 any = tmp166 + tmp168 := checkDerefVar(var_glojure_DOT_core_int) + tmp169 := lang.Apply(tmp168, []any{int64(0)}) + var tmp167 any = tmp169 + v136 = tmp158 + v137 = tmp161 + v138 = tmp162 + v139 = tmp167 + continue + } // end let + tmp151 = tmp154 + } else { + var tmp155 any + { // let + // let binding "opt" + tmp156 := checkDerefVar(var_glojure_DOT_core_first) + tmp157 := lang.Apply(tmp156, []any{v150}) + var v158 any = tmp157 + _ = v158 + tmp159 := checkDerefVar(var_glojure_DOT_core_printf) + tmp160 := checkDerefVar(var_glojure_DOT_core_key) + tmp161 := lang.Apply(tmp160, []any{v158}) + tmp162 := checkDerefVar(var_glojure_DOT_core_print_DASH_str) + tmp163 := checkDerefVar(var_glojure_DOT_core_val) + tmp164 := lang.Apply(tmp163, []any{v158}) + tmp165 := lang.Apply(tmp162, []any{tmp164}) + tmp166 := lang.Apply(tmp159, []any{" %s '%s", tmp161, tmp165}) + _ = tmp166 + tmp168 := checkDerefVar(var_glojure_DOT_core_next) + tmp169 := lang.Apply(tmp168, []any{v150}) + var tmp167 any = tmp169 + var tmp170 any = nil + var tmp171 any = int64(0) + var tmp172 any = int64(0) + v136 = tmp167 + v137 = tmp170 + v138 = tmp171 + v139 = tmp172 + continue + } // end let + tmp151 = tmp155 + } + tmp149 = tmp151 + } // end let + tmp148 = tmp149 + } else { + } + tmp144 = tmp148 + } // end let + tmp140 = tmp144 + } + tmp133 = tmp140 + break + } + } // end let + _ = tmp133 + tmp134 := checkDerefVar(var_glojure_DOT_core_printf) + tmp135 := lang.Apply(tmp134, []any{")\n"}) + tmp129 = tmp135 + } else { + } + _ = tmp129 + tmp136 := checkDerefVar(var_glojure_DOT_core_apply) + tmp137 := checkDerefVar(var_glojure_DOT_core_refer) + tmp138 := checkDerefVar(var_glojure_DOT_core_mapcat) + tmp139 := checkDerefVar(var_glojure_DOT_core_seq) + tmp140 := lang.Apply(tmp138, []any{tmp139, v84}) + tmp141 := lang.Apply(tmp136, []any{tmp137, v16, tmp140}) + tmp127 = tmp141 + } else { + } + tmp97 = tmp127 + }() + tmp90 = tmp97 + } // end let + tmp10 = tmp90 + } // end let + return tmp10 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_load_DASH_lib = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_load_DASH_lib.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // load-libs + { + tmp0 := sym_load_DASH_libs.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_args)), kw_doc, "Loads libs, interpreting libspecs, prefix lists, and flags for\n forwarding to load-lib", kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(16), kw_column, int(8), kw_line, int(5951), kw_end_DASH_line, int(5951), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + var tmp3 any + { // let + // let binding "flags" + tmp4 := checkDerefVar(var_glojure_DOT_core_filter) + tmp5 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp6 := lang.Apply(tmp4, []any{tmp5, v2}) + var v7 any = tmp6 + _ = v7 + // let binding "opts" + tmp8 := checkDerefVar(var_glojure_DOT_core_interleave) + tmp9 := checkDerefVar(var_glojure_DOT_core_repeat) + tmp10 := lang.Apply(tmp9, []any{true}) + tmp11 := lang.Apply(tmp8, []any{v7, tmp10}) + var v12 any = tmp11 + _ = v12 + // let binding "args" + tmp13 := checkDerefVar(var_glojure_DOT_core_filter) + tmp14 := checkDerefVar(var_glojure_DOT_core_complement) + tmp15 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp16 := lang.Apply(tmp14, []any{tmp15}) + tmp17 := lang.Apply(tmp13, []any{tmp16, v2}) + var v18 any = tmp17 + _ = v18 + var tmp19 any + { // let + // let binding "supported" + tmp20 := lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{kw_as, kw_reload, kw_reload_DASH_all, kw_require, kw_use, kw_verbose, kw_refer, kw_as_DASH_alias})) + tmp21 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5959), kw_column, int(21), kw_end_DASH_line, int(5959), kw_end_DASH_column, int(86)) + tmp22, err := lang.WithMeta(tmp20, tmp21.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v23 any = tmp22 + _ = v23 + // let binding "unsupported" + tmp24 := checkDerefVar(var_glojure_DOT_core_seq) + tmp25 := checkDerefVar(var_glojure_DOT_core_remove) + tmp26 := lang.Apply(tmp25, []any{v23, v7}) + tmp27 := lang.Apply(tmp24, []any{tmp26}) + var v28 any = tmp27 + _ = v28 + tmp29 := checkDerefVar(var_glojure_DOT_core_throw_DASH_if) + tmp30 := checkDerefVar(var_glojure_DOT_core_apply) + tmp31 := checkDerefVar(var_glojure_DOT_core_str) + tmp32 := checkDerefVar(var_glojure_DOT_core_interpose) + tmp33 := lang.Apply(tmp32, []any{lang.NewChar(44), v28}) + tmp34 := lang.Apply(tmp30, []any{tmp31, "Unsupported option(s) supplied: ", tmp33}) + tmp35 := lang.Apply(tmp29, []any{v28, tmp34}) + tmp19 = tmp35 + } // end let + _ = tmp19 + tmp20 := checkDerefVar(var_glojure_DOT_core_throw_DASH_if) + tmp21 := checkDerefVar(var_glojure_DOT_core_not) + tmp22 := checkDerefVar(var_glojure_DOT_core_seq) + tmp23 := lang.Apply(tmp22, []any{v18}) + tmp24 := lang.Apply(tmp21, []any{tmp23}) + tmp25 := lang.Apply(tmp20, []any{tmp24, "Nothing specified to load"}) + _ = tmp25 + var tmp26 any + { // let + // let binding "seq_806" + tmp27 := checkDerefVar(var_glojure_DOT_core_seq) + tmp28 := lang.Apply(tmp27, []any{v18}) + var v29 any = tmp28 + _ = v29 + // let binding "chunk_807" + var v30 any = nil + _ = v30 + // let binding "count_808" + var v31 any = int64(0) + _ = v31 + // let binding "i_809" + var v32 any = int64(0) + _ = v32 + for { + var tmp33 any + tmp34 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp35 := lang.Apply(tmp34, []any{v32, v31}) + if lang.IsTruthy(tmp35) { + var tmp36 any + { // let + // let binding "arg" + tmp37, _ := lang.FieldOrMethod(v30, "nth") + if reflect.TypeOf(tmp37).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp38 := lang.Apply(tmp37, []any{v32}) + var v39 any = tmp38 + _ = v39 + var tmp40 any + tmp41 := checkDerefVar(var_glojure_DOT_core_libspec_QMARK_) + tmp42 := lang.Apply(tmp41, []any{v39}) + if lang.IsTruthy(tmp42) { + tmp43 := checkDerefVar(var_glojure_DOT_core_apply) + tmp44 := checkDerefVar(var_glojure_DOT_core_load_DASH_lib) + tmp45 := checkDerefVar(var_glojure_DOT_core_prependss) + tmp46 := lang.Apply(tmp45, []any{v39, v12}) + tmp47 := lang.Apply(tmp43, []any{tmp44, nil, tmp46}) + tmp40 = tmp47 + } else { + var tmp48 any + { // let + // let binding "vec__810" + var v49 any = v39 + _ = v49 + // let binding "seq__811" + tmp50 := checkDerefVar(var_glojure_DOT_core_seq) + tmp51 := lang.Apply(tmp50, []any{v49}) + var v52 any = tmp51 + _ = v52 + // let binding "first__812" + tmp53 := checkDerefVar(var_glojure_DOT_core_first) + tmp54 := lang.Apply(tmp53, []any{v52}) + var v55 any = tmp54 + _ = v55 + // let binding "seq__811" + tmp56 := checkDerefVar(var_glojure_DOT_core_next) + tmp57 := lang.Apply(tmp56, []any{v52}) + var v58 any = tmp57 + _ = v58 + // let binding "prefix" + var v59 any = v55 + _ = v59 + // let binding "args" + var v60 any = v58 + _ = v60 + tmp61 := checkDerefVar(var_glojure_DOT_core_throw_DASH_if) + tmp62 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp63 := lang.Apply(tmp62, []any{v59}) + tmp64 := lang.Apply(tmp61, []any{tmp63, "prefix cannot be nil"}) + _ = tmp64 + var tmp65 any + { // let + // let binding "seq_813" + tmp66 := checkDerefVar(var_glojure_DOT_core_seq) + tmp67 := lang.Apply(tmp66, []any{v60}) + var v68 any = tmp67 + _ = v68 + // let binding "chunk_814" + var v69 any = nil + _ = v69 + // let binding "count_815" + var v70 any = int64(0) + _ = v70 + // let binding "i_816" + var v71 any = int64(0) + _ = v71 + for { + var tmp72 any + tmp73 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp74 := lang.Apply(tmp73, []any{v71, v70}) + if lang.IsTruthy(tmp74) { + var tmp75 any + { // let + // let binding "arg" + tmp76, _ := lang.FieldOrMethod(v69, "nth") + if reflect.TypeOf(tmp76).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp77 := lang.Apply(tmp76, []any{v71}) + var v78 any = tmp77 + _ = v78 + tmp79 := checkDerefVar(var_glojure_DOT_core_apply) + tmp80 := checkDerefVar(var_glojure_DOT_core_load_DASH_lib) + tmp81 := checkDerefVar(var_glojure_DOT_core_prependss) + tmp82 := lang.Apply(tmp81, []any{v78, v12}) + tmp83 := lang.Apply(tmp79, []any{tmp80, v59, tmp82}) + _ = tmp83 + var tmp84 any = v68 + var tmp85 any = v69 + var tmp86 any = v70 + tmp88 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp89 := lang.Apply(tmp88, []any{v71}) + var tmp87 any = tmp89 + v68 = tmp84 + v69 = tmp85 + v70 = tmp86 + v71 = tmp87 + continue + } // end let + tmp72 = tmp75 + } else { + var tmp76 any + { // let + // let binding "temp__0__auto__" + tmp77 := checkDerefVar(var_glojure_DOT_core_seq) + tmp78 := lang.Apply(tmp77, []any{v68}) + var v79 any = tmp78 + _ = v79 + var tmp80 any + if lang.IsTruthy(v79) { + var tmp81 any + { // let + // let binding "seq_813" + var v82 any = v79 + _ = v82 + var tmp83 any + tmp84 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp85 := lang.Apply(tmp84, []any{v82}) + if lang.IsTruthy(tmp85) { + var tmp86 any + { // let + // let binding "c__0__auto__" + tmp87 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp88 := lang.Apply(tmp87, []any{v82}) + var v89 any = tmp88 + _ = v89 + tmp91 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp92 := lang.Apply(tmp91, []any{v82}) + var tmp90 any = tmp92 + var tmp93 any = v89 + tmp95 := checkDerefVar(var_glojure_DOT_core_int) + tmp96 := checkDerefVar(var_glojure_DOT_core_count) + tmp97 := lang.Apply(tmp96, []any{v89}) + tmp98 := lang.Apply(tmp95, []any{tmp97}) + var tmp94 any = tmp98 + tmp100 := checkDerefVar(var_glojure_DOT_core_int) + tmp101 := lang.Apply(tmp100, []any{int64(0)}) + var tmp99 any = tmp101 + v68 = tmp90 + v69 = tmp93 + v70 = tmp94 + v71 = tmp99 + continue + } // end let + tmp83 = tmp86 + } else { + var tmp87 any + { // let + // let binding "arg" + tmp88 := checkDerefVar(var_glojure_DOT_core_first) + tmp89 := lang.Apply(tmp88, []any{v82}) + var v90 any = tmp89 + _ = v90 + tmp91 := checkDerefVar(var_glojure_DOT_core_apply) + tmp92 := checkDerefVar(var_glojure_DOT_core_load_DASH_lib) + tmp93 := checkDerefVar(var_glojure_DOT_core_prependss) + tmp94 := lang.Apply(tmp93, []any{v90, v12}) + tmp95 := lang.Apply(tmp91, []any{tmp92, v59, tmp94}) + _ = tmp95 + tmp97 := checkDerefVar(var_glojure_DOT_core_next) + tmp98 := lang.Apply(tmp97, []any{v82}) + var tmp96 any = tmp98 + var tmp99 any = nil + var tmp100 any = int64(0) + var tmp101 any = int64(0) + v68 = tmp96 + v69 = tmp99 + v70 = tmp100 + v71 = tmp101 + continue + } // end let + tmp83 = tmp87 + } + tmp81 = tmp83 + } // end let + tmp80 = tmp81 + } else { + } + tmp76 = tmp80 + } // end let + tmp72 = tmp76 + } + tmp65 = tmp72 + break + } + } // end let + tmp48 = tmp65 + } // end let + tmp40 = tmp48 + } + _ = tmp40 + var tmp49 any = v29 + var tmp50 any = v30 + var tmp51 any = v31 + tmp53 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp54 := lang.Apply(tmp53, []any{v32}) + var tmp52 any = tmp54 + v29 = tmp49 + v30 = tmp50 + v31 = tmp51 + v32 = tmp52 + continue + } // end let + tmp33 = tmp36 + } else { + var tmp37 any + { // let + // let binding "temp__0__auto__" + tmp38 := checkDerefVar(var_glojure_DOT_core_seq) + tmp39 := lang.Apply(tmp38, []any{v29}) + var v40 any = tmp39 + _ = v40 + var tmp41 any + if lang.IsTruthy(v40) { + var tmp42 any + { // let + // let binding "seq_806" + var v43 any = v40 + _ = v43 + var tmp44 any + tmp45 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp46 := lang.Apply(tmp45, []any{v43}) + if lang.IsTruthy(tmp46) { + var tmp47 any + { // let + // let binding "c__0__auto__" + tmp48 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp49 := lang.Apply(tmp48, []any{v43}) + var v50 any = tmp49 + _ = v50 + tmp52 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp53 := lang.Apply(tmp52, []any{v43}) + var tmp51 any = tmp53 + var tmp54 any = v50 + tmp56 := checkDerefVar(var_glojure_DOT_core_int) + tmp57 := checkDerefVar(var_glojure_DOT_core_count) + tmp58 := lang.Apply(tmp57, []any{v50}) + tmp59 := lang.Apply(tmp56, []any{tmp58}) + var tmp55 any = tmp59 + tmp61 := checkDerefVar(var_glojure_DOT_core_int) + tmp62 := lang.Apply(tmp61, []any{int64(0)}) + var tmp60 any = tmp62 + v29 = tmp51 + v30 = tmp54 + v31 = tmp55 + v32 = tmp60 + continue + } // end let + tmp44 = tmp47 + } else { + var tmp48 any + { // let + // let binding "arg" + tmp49 := checkDerefVar(var_glojure_DOT_core_first) + tmp50 := lang.Apply(tmp49, []any{v43}) + var v51 any = tmp50 + _ = v51 + var tmp52 any + tmp53 := checkDerefVar(var_glojure_DOT_core_libspec_QMARK_) + tmp54 := lang.Apply(tmp53, []any{v51}) + if lang.IsTruthy(tmp54) { + tmp55 := checkDerefVar(var_glojure_DOT_core_apply) + tmp56 := checkDerefVar(var_glojure_DOT_core_load_DASH_lib) + tmp57 := checkDerefVar(var_glojure_DOT_core_prependss) + tmp58 := lang.Apply(tmp57, []any{v51, v12}) + tmp59 := lang.Apply(tmp55, []any{tmp56, nil, tmp58}) + tmp52 = tmp59 + } else { + var tmp60 any + { // let + // let binding "vec__817" + var v61 any = v51 + _ = v61 + // let binding "seq__818" + tmp62 := checkDerefVar(var_glojure_DOT_core_seq) + tmp63 := lang.Apply(tmp62, []any{v61}) + var v64 any = tmp63 + _ = v64 + // let binding "first__819" + tmp65 := checkDerefVar(var_glojure_DOT_core_first) + tmp66 := lang.Apply(tmp65, []any{v64}) + var v67 any = tmp66 + _ = v67 + // let binding "seq__818" + tmp68 := checkDerefVar(var_glojure_DOT_core_next) + tmp69 := lang.Apply(tmp68, []any{v64}) + var v70 any = tmp69 + _ = v70 + // let binding "prefix" + var v71 any = v67 + _ = v71 + // let binding "args" + var v72 any = v70 + _ = v72 + tmp73 := checkDerefVar(var_glojure_DOT_core_throw_DASH_if) + tmp74 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp75 := lang.Apply(tmp74, []any{v71}) + tmp76 := lang.Apply(tmp73, []any{tmp75, "prefix cannot be nil"}) + _ = tmp76 + var tmp77 any + { // let + // let binding "seq_820" + tmp78 := checkDerefVar(var_glojure_DOT_core_seq) + tmp79 := lang.Apply(tmp78, []any{v72}) + var v80 any = tmp79 + _ = v80 + // let binding "chunk_821" + var v81 any = nil + _ = v81 + // let binding "count_822" + var v82 any = int64(0) + _ = v82 + // let binding "i_823" + var v83 any = int64(0) + _ = v83 + for { + var tmp84 any + tmp85 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp86 := lang.Apply(tmp85, []any{v83, v82}) + if lang.IsTruthy(tmp86) { + var tmp87 any + { // let + // let binding "arg" + tmp88, _ := lang.FieldOrMethod(v81, "nth") + if reflect.TypeOf(tmp88).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp89 := lang.Apply(tmp88, []any{v83}) + var v90 any = tmp89 + _ = v90 + tmp91 := checkDerefVar(var_glojure_DOT_core_apply) + tmp92 := checkDerefVar(var_glojure_DOT_core_load_DASH_lib) + tmp93 := checkDerefVar(var_glojure_DOT_core_prependss) + tmp94 := lang.Apply(tmp93, []any{v90, v12}) + tmp95 := lang.Apply(tmp91, []any{tmp92, v71, tmp94}) + _ = tmp95 + var tmp96 any = v80 + var tmp97 any = v81 + var tmp98 any = v82 + tmp100 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp101 := lang.Apply(tmp100, []any{v83}) + var tmp99 any = tmp101 + v80 = tmp96 + v81 = tmp97 + v82 = tmp98 + v83 = tmp99 + continue + } // end let + tmp84 = tmp87 + } else { + var tmp88 any + { // let + // let binding "temp__0__auto__" + tmp89 := checkDerefVar(var_glojure_DOT_core_seq) + tmp90 := lang.Apply(tmp89, []any{v80}) + var v91 any = tmp90 + _ = v91 + var tmp92 any + if lang.IsTruthy(v91) { + var tmp93 any + { // let + // let binding "seq_820" + var v94 any = v91 + _ = v94 + var tmp95 any + tmp96 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp97 := lang.Apply(tmp96, []any{v94}) + if lang.IsTruthy(tmp97) { + var tmp98 any + { // let + // let binding "c__0__auto__" + tmp99 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp100 := lang.Apply(tmp99, []any{v94}) + var v101 any = tmp100 + _ = v101 + tmp103 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp104 := lang.Apply(tmp103, []any{v94}) + var tmp102 any = tmp104 + var tmp105 any = v101 + tmp107 := checkDerefVar(var_glojure_DOT_core_int) + tmp108 := checkDerefVar(var_glojure_DOT_core_count) + tmp109 := lang.Apply(tmp108, []any{v101}) + tmp110 := lang.Apply(tmp107, []any{tmp109}) + var tmp106 any = tmp110 + tmp112 := checkDerefVar(var_glojure_DOT_core_int) + tmp113 := lang.Apply(tmp112, []any{int64(0)}) + var tmp111 any = tmp113 + v80 = tmp102 + v81 = tmp105 + v82 = tmp106 + v83 = tmp111 + continue + } // end let + tmp95 = tmp98 + } else { + var tmp99 any + { // let + // let binding "arg" + tmp100 := checkDerefVar(var_glojure_DOT_core_first) + tmp101 := lang.Apply(tmp100, []any{v94}) + var v102 any = tmp101 + _ = v102 + tmp103 := checkDerefVar(var_glojure_DOT_core_apply) + tmp104 := checkDerefVar(var_glojure_DOT_core_load_DASH_lib) + tmp105 := checkDerefVar(var_glojure_DOT_core_prependss) + tmp106 := lang.Apply(tmp105, []any{v102, v12}) + tmp107 := lang.Apply(tmp103, []any{tmp104, v71, tmp106}) + _ = tmp107 + tmp109 := checkDerefVar(var_glojure_DOT_core_next) + tmp110 := lang.Apply(tmp109, []any{v94}) + var tmp108 any = tmp110 + var tmp111 any = nil + var tmp112 any = int64(0) + var tmp113 any = int64(0) + v80 = tmp108 + v81 = tmp111 + v82 = tmp112 + v83 = tmp113 + continue + } // end let + tmp95 = tmp99 + } + tmp93 = tmp95 + } // end let + tmp92 = tmp93 + } else { + } + tmp88 = tmp92 + } // end let + tmp84 = tmp88 + } + tmp77 = tmp84 + break + } + } // end let + tmp60 = tmp77 + } // end let + tmp52 = tmp60 + } + _ = tmp52 + tmp62 := checkDerefVar(var_glojure_DOT_core_next) + tmp63 := lang.Apply(tmp62, []any{v43}) + var tmp61 any = tmp63 + var tmp64 any = nil + var tmp65 any = int64(0) + var tmp66 any = int64(0) + v29 = tmp61 + v30 = tmp64 + v31 = tmp65 + v32 = tmp66 + continue + } // end let + tmp44 = tmp48 + } + tmp42 = tmp44 + } // end let + tmp41 = tmp42 + } else { + } + tmp37 = tmp41 + } // end let + tmp33 = tmp37 + } + tmp26 = tmp33 + break + } + } // end let + tmp3 = tmp26 + } // end let + return tmp3 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_load_DASH_libs = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_load_DASH_libs.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // require + { + tmp0 := sym_require.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_args)), kw_doc, "Loads libs, skipping any that are already loaded. Each argument is\n either a libspec that identifies a lib, a prefix list that identifies\n multiple libs whose names share a common prefix, or a flag that modifies\n how all the identified libs are loaded. Use :require in the ns macro\n in preference to calling this directly.\n\n Libs\n\n A 'lib' is a named set of resources in classpath whose contents define a\n library of Clojure code. Lib names are symbols and each lib is associated\n with a Clojure namespace and a Java package that share its name. A lib's\n name also locates its root directory within classpath using Java's\n package name to classpath-relative path mapping. All resources in a lib\n should be contained in the directory structure under its root directory.\n All definitions a lib makes should be in its associated namespace.\n\n 'require loads a lib by loading its root resource. The root resource path\n is derived from the lib name in the following manner:\n Consider a lib named by the symbol 'x.y.z; it has the root directory\n /x/y/, and its root resource is /x/y/z.clj, or\n /x/y/z.cljc if /x/y/z.clj does not exist. The\n root resource should contain code to create the lib's\n namespace (usually by using the ns macro) and load any additional\n lib resources.\n\n Libspecs\n\n A libspec is a lib name or a vector containing a lib name followed by\n options expressed as sequential keywords and arguments.\n\n Recognized options:\n :as takes a symbol as its argument and makes that symbol an alias to the\n lib's namespace in the current namespace.\n :as-alias takes a symbol as its argument and aliases like :as, however\n the lib will not be loaded. If the lib has not been loaded, a new\n empty namespace will be created (as with create-ns).\n :refer takes a list of symbols to refer from the namespace or the :all\n keyword to bring in all public vars.\n\n Prefix Lists\n\n It's common for Clojure code to depend on several libs whose names have\n the same prefix. When specifying libs, prefix lists can be used to reduce\n repetition. A prefix list contains the shared prefix followed by libspecs\n with the shared prefix removed from the lib names. After removing the\n prefix, the names that remain must not contain any periods.\n\n Flags\n\n A flag is a keyword.\n Recognized flags: :reload, :reload-all, :verbose\n :reload forces loading of all the identified libs even if they are\n already loaded (has no effect on libspecs using :as-alias)\n :reload-all implies :reload and also forces loading of all libs that the\n identified libs directly or indirectly load via require or use\n (has no effect on libspecs using :as-alias)\n :verbose triggers printing information about each load, alias, and refer\n\n Example:\n\n The following would load the libraries glojure.zip and glojure.set\n abbreviated as 's'.\n\n (require '(glojure zip [set :as s]))", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(5989), kw_end_DASH_line, int(5989))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_apply) + tmp4 := checkDerefVar(var_glojure_DOT_core_load_DASH_libs) + tmp5 := lang.Apply(tmp3, []any{tmp4, kw_require, v2}) + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_require = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_require.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // serialized-require + { + tmp0 := sym_serialized_DASH_require.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_args)), kw_doc, "Like 'require', but serializes loading.\n Interim function preferred over 'require' for known asynchronous loads.\n Future changes may make these equivalent.", kw_file, "glojure/core.glj", kw_added, "1.10", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(25), kw_column, int(8), kw_line, int(6059), kw_end_DASH_line, int(6059), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + var tmp3 any + { // let + // let binding "lockee__0__auto__" + var v4 any = nil + _ = v4 + var tmp5 any + func() { + var tmp6 any + { // let + // let binding "locklocal__1__auto__" + var v7 any = v4 + _ = v7 + tmp8 := lang.Apply(nil, []any{v7}) + _ = tmp8 + var tmp9 any + func() { + defer func() { + tmp10 := lang.Apply(nil, []any{v7}) + _ = tmp10 + }() + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + tmp12 := checkDerefVar(var_glojure_DOT_core_require) + tmp13 := lang.Apply(tmp11, []any{tmp12, v2}) + tmp9 = tmp13 + }() + tmp6 = tmp9 + } // end let + tmp5 = tmp6 + }() + tmp3 = tmp5 + } // end let + return tmp3 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_serialized_DASH_require = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_serialized_DASH_require.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // use + { + tmp0 := sym_use.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_args)), kw_doc, "Like 'require, but also refers to each lib's namespace using\n glojure.core/refer. Use :use in the ns macro in preference to calling\n this directly.\n\n 'use accepts additional options in libspecs: :exclude, :only, :rename.\n The arguments and semantics for :exclude, :only, and :rename are the same\n as those documented for glojure.core/refer.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(6079), kw_end_DASH_line, int(6079))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_apply) + tmp4 := checkDerefVar(var_glojure_DOT_core_load_DASH_libs) + tmp5 := lang.Apply(tmp3, []any{tmp4, kw_require, kw_use, v2}) + return tmp5 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_use = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_use.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // requiring-resolve + { + tmp0 := sym_requiring_DASH_resolve.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_sym)), kw_doc, "Resolves namespace-qualified sym per 'resolve'. If initial resolve\nfails, attempts to require sym's namespace and retries.", kw_file, "glojure/core.glj", kw_added, "1.10", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(23), kw_column, int(7), kw_line, int(6068), kw_end_DASH_line, int(6068))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_qualified_DASH_symbol_QMARK_) + tmp5 := lang.Apply(tmp4, []any{v2}) + if lang.IsTruthy(tmp5) { + var tmp6 any + { // let + // let binding "or__0__auto__" + tmp7 := checkDerefVar(var_glojure_DOT_core_resolve) + tmp8 := lang.Apply(tmp7, []any{v2}) + var v9 any = tmp8 + _ = v9 + var tmp10 any + if lang.IsTruthy(v9) { + tmp10 = v9 + } else { + tmp11 := checkDerefVar(var_glojure_DOT_core_serialized_DASH_require) + tmp12 := checkDerefVar(var_glojure_DOT_core_symbol) + tmp13 := checkDerefVar(var_glojure_DOT_core_namespace) + tmp14 := lang.Apply(tmp13, []any{v2}) + tmp15 := lang.Apply(tmp12, []any{tmp14}) + tmp16 := lang.Apply(tmp11, []any{tmp15}) + _ = tmp16 + tmp17 := checkDerefVar(var_glojure_DOT_core_resolve) + tmp18 := lang.Apply(tmp17, []any{v2}) + tmp10 = tmp18 + } + tmp6 = tmp10 + } // end let + tmp3 = tmp6 + } else { + tmp7 := checkDerefVar(var_glojure_DOT_core_str) + tmp8 := lang.Apply(tmp7, []any{"Not a qualified symbol: ", v2}) + tmp9 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp8}) + panic(tmp9) + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_requiring_DASH_resolve = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_requiring_DASH_resolve.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // mapv + { + tmp0 := sym_mapv.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_coll), lang.NewVector(sym_f, sym_c1, sym_c2), lang.NewVector(sym_f, sym_c1, sym_c2, sym_c3), lang.NewVector(sym_f, sym_c1, sym_c2, sym_c3, sym__AMP_, sym_colls)), kw_doc, "Returns a vector consisting of the result of applying f to the\n set of first items of each coll, followed by applying f to the set\n of second items in each coll, until any one of the colls is\n exhausted. Any remaining items in other colls are ignored. Function\n f should accept number-of-colls arguments.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.4", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(6943), kw_end_DASH_line, int(6943))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp5 := checkDerefVar(var_glojure_DOT_core_reduce) + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v7 := args[0] + _ = v7 + v8 := args[1] + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_conj_BANG_) + tmp10 := lang.Apply(v2, []any{v8}) + tmp11 := lang.Apply(tmp9, []any{v7, tmp10}) + return tmp11 + }) + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6952), kw_column, int(18), kw_end_DASH_line, int(6952), kw_end_DASH_column, int(43)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp9 := checkDerefVar(var_glojure_DOT_core_transient) + tmp10 := lang.NewVector() + tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6952), kw_column, int(56), kw_end_DASH_line, int(6952), kw_end_DASH_column, int(57)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp13 := lang.Apply(tmp9, []any{tmp12}) + tmp14 := lang.Apply(tmp5, []any{tmp8, tmp13, v3}) + tmp15 := lang.Apply(tmp4, []any{tmp14}) + return tmp15 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_into) + tmp6 := lang.NewVector() + tmp7 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6955), kw_column, int(12), kw_end_DASH_line, int(6955), kw_end_DASH_column, int(13)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp9 := checkDerefVar(var_glojure_DOT_core_map) + tmp10 := lang.Apply(tmp9, []any{v2, v3, v4}) + tmp11 := lang.Apply(tmp5, []any{tmp8, tmp10}) + return tmp11 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_into) + tmp7 := lang.NewVector() + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6957), kw_column, int(12), kw_end_DASH_line, int(6957), kw_end_DASH_column, int(13)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp10 := checkDerefVar(var_glojure_DOT_core_map) + tmp11 := lang.Apply(tmp10, []any{v2, v3, v4, v5}) + tmp12 := lang.Apply(tmp6, []any{tmp9, tmp11}) + return tmp12 + default: + checkArity(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var v6 any = lang.NewList(args[4:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_into) + tmp8 := lang.NewVector() + tmp9 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6959), kw_column, int(12), kw_end_DASH_line, int(6959), kw_end_DASH_column, int(13)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + tmp12 := checkDerefVar(var_glojure_DOT_core_map) + tmp13 := lang.Apply(tmp11, []any{tmp12, v2, v3, v4, v5, v6}) + tmp14 := lang.Apply(tmp7, []any{tmp10, tmp13}) + return tmp14 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_mapv = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_mapv.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // newline + { + tmp0 := sym_newline.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Writes a platform-specific newline to *out*", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(3698), kw_end_DASH_line, int(3698))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp2 := checkDerefVar(var_glojure_DOT_core__STAR_out_STAR_) + tmp3 := checkDerefVar(var_glojure_DOT_core_system_DASH_newline) + tmp4 := lang.Apply(lang.AppendWriter, []any{tmp2, tmp3}) + _ = tmp4 + return nil + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_newline = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_newline.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // normalize-slurp-opts + { + tmp0 := sym_normalize_DASH_slurp_DASH_opts.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6974), kw_column, int(8), kw_end_DASH_line, int(6974), kw_end_DASH_column, int(27), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_opts)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp5 := checkDerefVar(var_glojure_DOT_core_first) + tmp6 := lang.Apply(tmp5, []any{v2}) + tmp7 := lang.Apply(tmp4, []any{tmp6}) + if lang.IsTruthy(tmp7) { + tmp8 := checkDerefVar(var_glojure_DOT_core_println) + tmp9 := lang.Apply(tmp8, []any{"WARNING: (slurp f enc) is deprecated, use (slurp f :encoding enc)."}) + _ = tmp9 + tmp10 := checkDerefVar(var_glojure_DOT_core_first) + tmp11 := lang.Apply(tmp10, []any{v2}) + tmp12 := lang.NewVector(kw_encoding, tmp11) + tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(6979), kw_column, int(7), kw_end_DASH_line, int(6979), kw_end_DASH_column, int(30)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp3 = tmp14 + } else { + tmp3 = v2 + } + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_normalize_DASH_slurp_DASH_opts = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_normalize_DASH_slurp_DASH_opts.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // pr + { + tmp0 := sym_pr.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_x), lang.NewVector(sym_x, sym__AMP_, sym_more)), kw_doc, "Prints the object(s) to the output stream that is the current value\n of *out*. Prints the object(s), separated by spaces if there is\n more than one. By default, pr and prn print in a way that objects\n can be read by the reader", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(8), kw_column, int(7), kw_line, int(3678), kw_end_DASH_line, int(3678), kw_dynamic, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + return nil + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) + tmp4 := checkDerefVar(var_glojure_DOT_core__STAR_out_STAR_) + tmp5 := lang.Apply(tmp3, []any{v2, tmp4}) + return tmp5 + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + recur_loop_2211: + tmp4 := checkDerefVar(var_glojure_DOT_core_pr) + tmp5 := lang.Apply(tmp4, []any{v2}) + _ = tmp5 + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_out_STAR_) + tmp7 := lang.Apply(lang.AppendWriter, []any{tmp6, lang.NewChar(32)}) + _ = tmp7 + var tmp8 any + { // let + // let binding "temp__0__auto__" + tmp9 := checkDerefVar(var_glojure_DOT_core_next) + tmp10 := lang.Apply(tmp9, []any{v3}) + var v11 any = tmp10 + _ = v11 + var tmp12 any + if lang.IsTruthy(v11) { + var tmp13 any + { // let + // let binding "nmore" + var v14 any = v11 + _ = v14 + tmp16 := checkDerefVar(var_glojure_DOT_core_first) + tmp17 := lang.Apply(tmp16, []any{v3}) + var tmp15 any = tmp17 + var tmp18 any = v14 + v2 = tmp15 + v3 = tmp18 + goto recur_loop_2211 + } // end let + tmp12 = tmp13 + } else { + tmp14 := checkDerefVar(var_glojure_DOT_core_apply) + tmp15 := checkDerefVar(var_glojure_DOT_core_pr) + tmp16 := lang.Apply(tmp14, []any{tmp15, v3}) + tmp12 = tmp16 + } + tmp8 = tmp12 + } // end let + return tmp8 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_pr = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_pr.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // pr-str + { + tmp1 := reflect.TypeOf("") + tmp0 := sym_pr_DASH_str.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_xs)), kw_doc, "pr to a string, returning it", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(4758), kw_end_DASH_line, int(4758))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v3 any = lang.NewList(args[0:]...) + _ = v3 + var tmp4 any + { // let + // let binding "s__0__auto__" + var v5 any = "unimplemented: new with non-constant class type" + _ = v5 + var tmp6 any + { // let + tmp7 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp8 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp9 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) + tmp10 := lang.Apply(tmp8, []any{tmp9, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp10}) + _ = tmp11 + var tmp12 any + func() { + defer func() { + tmp13 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp14 := lang.Apply(tmp13, nil) + _ = tmp14 + }() + tmp15 := checkDerefVar(var_glojure_DOT_core_apply) + tmp16 := checkDerefVar(var_glojure_DOT_core_pr) + tmp17 := lang.Apply(tmp15, []any{tmp16, v3}) + _ = tmp17 + tmp18 := checkDerefVar(var_glojure_DOT_core_str) + tmp19 := lang.Apply(tmp18, []any{v5}) + tmp12 = tmp19 + }() + tmp6 = tmp12 + } // end let + tmp4 = tmp6 + } // end let + return tmp4 + } + }) + tmp3 := reflect.TypeOf("") + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_pr_DASH_str = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_pr_DASH_str.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print + { + tmp0 := sym_print.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_more)), kw_doc, "Prints the object(s) to the output stream that is the current value\n of *out*. print and println produce output for human consumption.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3725), kw_end_DASH_line, int(3725))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + var tmp3 any + { // let + tmp4 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp5 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp6 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_print_DASH_readably_STAR_) + tmp7 := lang.Apply(tmp5, []any{tmp6, nil}) + tmp8 := lang.Apply(tmp4, []any{tmp7}) + _ = tmp8 + var tmp9 any + func() { + defer func() { + tmp10 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp11 := lang.Apply(tmp10, nil) + _ = tmp11 + }() + tmp12 := checkDerefVar(var_glojure_DOT_core_apply) + tmp13 := checkDerefVar(var_glojure_DOT_core_pr) + tmp14 := lang.Apply(tmp12, []any{tmp13, v2}) + tmp9 = tmp14 + }() + tmp3 = tmp9 + } // end let + return tmp3 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_print = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_print.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print-str + { + tmp1 := reflect.TypeOf("") + tmp0 := sym_print_DASH_str.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_xs)), kw_doc, "print to a string, returning it", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(4776), kw_end_DASH_line, int(4776))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v3 any = lang.NewList(args[0:]...) + _ = v3 + var tmp4 any + { // let + // let binding "s__0__auto__" + var v5 any = "unimplemented: new with non-constant class type" + _ = v5 + var tmp6 any + { // let + tmp7 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp8 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp9 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) + tmp10 := lang.Apply(tmp8, []any{tmp9, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp10}) + _ = tmp11 + var tmp12 any + func() { + defer func() { + tmp13 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp14 := lang.Apply(tmp13, nil) + _ = tmp14 + }() + tmp15 := checkDerefVar(var_glojure_DOT_core_apply) + tmp16 := checkDerefVar(var_glojure_DOT_core_print) + tmp17 := lang.Apply(tmp15, []any{tmp16, v3}) + _ = tmp17 + tmp18 := checkDerefVar(var_glojure_DOT_core_str) + tmp19 := lang.Apply(tmp18, []any{v5}) + tmp12 = tmp19 + }() + tmp6 = tmp12 + } // end let + tmp4 = tmp6 + } // end let + return tmp4 + } + }) + tmp3 := reflect.TypeOf("") + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_print_DASH_str = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_print_DASH_str.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // printf + { + tmp0 := sym_printf.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_fmt, sym__AMP_, sym_args)), kw_doc, "Prints formatted output, as per format", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(5725), kw_end_DASH_line, int(5725))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_print) + tmp5 := checkDerefVar(var_glojure_DOT_core_apply) + tmp6 := checkDerefVar(var_glojure_DOT_core_format) + tmp7 := lang.Apply(tmp5, []any{tmp6, v2, v3}) + tmp8 := lang.Apply(tmp4, []any{tmp7}) + return tmp8 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_printf = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_printf.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // prn + { + tmp0 := sym_prn.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_more)), kw_doc, "Same as pr followed by (newline). Observes *flush-on-newline*", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(3715), kw_end_DASH_line, int(3715))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_apply) + tmp4 := checkDerefVar(var_glojure_DOT_core_pr) + tmp5 := lang.Apply(tmp3, []any{tmp4, v2}) + _ = tmp5 + tmp6 := checkDerefVar(var_glojure_DOT_core_newline) + tmp7 := lang.Apply(tmp6, nil) + _ = tmp7 + var tmp8 any + tmp9 := checkDerefVar(var_glojure_DOT_core__STAR_flush_DASH_on_DASH_newline_STAR_) + if lang.IsTruthy(tmp9) { + tmp10 := checkDerefVar(var_glojure_DOT_core_flush) + tmp11 := lang.Apply(tmp10, nil) + tmp8 = tmp11 + } else { + } + return tmp8 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_prn = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_prn.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // prn-str + { + tmp1 := reflect.TypeOf("") + tmp0 := sym_prn_DASH_str.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_xs)), kw_doc, "prn to a string, returning it", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(4767), kw_end_DASH_line, int(4767))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v3 any = lang.NewList(args[0:]...) + _ = v3 + var tmp4 any + { // let + // let binding "s__0__auto__" + var v5 any = "unimplemented: new with non-constant class type" + _ = v5 + var tmp6 any + { // let + tmp7 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp8 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp9 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) + tmp10 := lang.Apply(tmp8, []any{tmp9, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp10}) + _ = tmp11 + var tmp12 any + func() { + defer func() { + tmp13 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp14 := lang.Apply(tmp13, nil) + _ = tmp14 + }() + tmp15 := checkDerefVar(var_glojure_DOT_core_apply) + tmp16 := checkDerefVar(var_glojure_DOT_core_prn) + tmp17 := lang.Apply(tmp15, []any{tmp16, v3}) + _ = tmp17 + tmp18 := checkDerefVar(var_glojure_DOT_core_str) + tmp19 := lang.Apply(tmp18, []any{v5}) + tmp12 = tmp19 + }() + tmp6 = tmp12 + } // end let + tmp4 = tmp6 + } // end let + return tmp4 + } + }) + tmp3 := reflect.TypeOf("") + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_prn_DASH_str = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_prn_DASH_str.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // println + { + tmp0 := sym_println.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_more)), kw_doc, "Same as print followed by (newline)", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(3734), kw_end_DASH_line, int(3734))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v2 any = lang.NewList(args[0:]...) + _ = v2 + var tmp3 any + { // let + tmp4 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp5 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp6 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_print_DASH_readably_STAR_) + tmp7 := lang.Apply(tmp5, []any{tmp6, nil}) + tmp8 := lang.Apply(tmp4, []any{tmp7}) + _ = tmp8 + var tmp9 any + func() { + defer func() { + tmp10 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp11 := lang.Apply(tmp10, nil) + _ = tmp11 + }() + tmp12 := checkDerefVar(var_glojure_DOT_core_apply) + tmp13 := checkDerefVar(var_glojure_DOT_core_prn) + tmp14 := lang.Apply(tmp12, []any{tmp13, v2}) + tmp9 = tmp14 + }() + tmp3 = tmp9 + } // end let + return tmp3 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_println = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_println.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // println-str + { + tmp1 := reflect.TypeOf("") + tmp0 := sym_println_DASH_str.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_xs)), kw_doc, "println to a string, returning it", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(4785), kw_end_DASH_line, int(4785))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 0) + var v3 any = lang.NewList(args[0:]...) + _ = v3 + var tmp4 any + { // let + // let binding "s__0__auto__" + var v5 any = "unimplemented: new with non-constant class type" + _ = v5 + var tmp6 any + { // let + tmp7 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp8 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp9 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) + tmp10 := lang.Apply(tmp8, []any{tmp9, v5}) + tmp11 := lang.Apply(tmp7, []any{tmp10}) + _ = tmp11 + var tmp12 any + func() { + defer func() { + tmp13 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp14 := lang.Apply(tmp13, nil) + _ = tmp14 + }() + tmp15 := checkDerefVar(var_glojure_DOT_core_apply) + tmp16 := checkDerefVar(var_glojure_DOT_core_println) + tmp17 := lang.Apply(tmp15, []any{tmp16, v3}) + _ = tmp17 + tmp18 := checkDerefVar(var_glojure_DOT_core_str) + tmp19 := lang.Apply(tmp18, []any{v5}) + tmp12 = tmp19 + }() + tmp6 = tmp12 + } // end let + tmp4 = tmp6 + } // end let + return tmp4 + } + }) + tmp3 := reflect.TypeOf("") + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_println_DASH_str = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_println_DASH_str.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // pr-on + { + tmp0 := sym_pr_DASH_on.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x, sym_w)), kw_static, true, kw_file, "glojure/core.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(3669), kw_end_DASH_line, int(3669), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_dup_STAR_) + if lang.IsTruthy(tmp5) { + tmp6 := checkDerefVar(var_glojure_DOT_core_print_DASH_dup) + tmp7 := lang.Apply(tmp6, []any{v2, v3}) + tmp4 = tmp7 + } else { + tmp8 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp9 := lang.Apply(tmp8, []any{v2, v3}) + tmp4 = tmp9 + } + _ = tmp4 + return nil + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_pr_DASH_on = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_pr_DASH_on.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print-meta + { + tmp0 := sym_print_DASH_meta.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(70), kw_column, int(8), kw_end_DASH_line, int(70), kw_end_DASH_column, int(17), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_o, sym_w)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "temp__0__auto__" + tmp5 := checkDerefVar(var_glojure_DOT_core_meta) + tmp6 := lang.Apply(tmp5, []any{v2}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + if lang.IsTruthy(v7) { + var tmp9 any + { // let + // let binding "m" + var v10 any = v7 + _ = v10 + var tmp11 any + var tmp12 any + { // let + // let binding "and__0__auto__" + tmp13 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp14 := checkDerefVar(var_glojure_DOT_core_count) + tmp15 := lang.Apply(tmp14, []any{v10}) + tmp16 := lang.Apply(tmp13, []any{tmp15}) + var v17 any = tmp16 + _ = v17 + var tmp18 any + if lang.IsTruthy(v17) { + var tmp19 any + { // let + // let binding "or__0__auto__" + tmp20 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_dup_STAR_) + var v21 any = tmp20 + _ = v21 + var tmp22 any + if lang.IsTruthy(v21) { + tmp22 = v21 + } else { + var tmp23 any + { // let + // let binding "and__0__auto__" + tmp24 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_meta_STAR_) + var v25 any = tmp24 + _ = v25 + var tmp26 any + if lang.IsTruthy(v25) { + tmp27 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_readably_STAR_) + tmp26 = tmp27 + } else { + tmp26 = v25 + } + tmp23 = tmp26 + } // end let + tmp22 = tmp23 + } + tmp19 = tmp22 + } // end let + tmp18 = tmp19 + } else { + tmp18 = v17 + } + tmp12 = tmp18 + } // end let + if lang.IsTruthy(tmp12) { + tmp13 := lang.Apply(lang.WriteWriter, []any{v3, "^"}) + _ = tmp13 + var tmp14 any + var tmp15 any + { // let + // let binding "and__0__auto__" + tmp16 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp17 := checkDerefVar(var_glojure_DOT_core_count) + tmp18 := lang.Apply(tmp17, []any{v10}) + tmp19 := lang.Apply(tmp16, []any{tmp18, int64(1)}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + tmp22 := lang.Apply(kw_tag, []any{v10}) + tmp21 = tmp22 + } else { + tmp21 = v20 + } + tmp15 = tmp21 + } // end let + if lang.IsTruthy(tmp15) { + tmp16 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) + tmp17 := lang.Apply(kw_tag, []any{v10}) + tmp18 := lang.Apply(tmp16, []any{tmp17, v3}) + tmp14 = tmp18 + } else { + tmp19 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) + tmp20 := lang.Apply(tmp19, []any{v10, v3}) + tmp14 = tmp20 + } + _ = tmp14 + tmp21 := lang.Apply(lang.WriteWriter, []any{v3, " "}) + tmp11 = tmp21 + } else { + } + tmp9 = tmp11 + } // end let + tmp8 = tmp9 + } else { + } + tmp4 = tmp8 + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_print_DASH_meta = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_print_DASH_meta.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print-simple + { + tmp0 := sym_print_DASH_simple.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(81), kw_column, int(7), kw_end_DASH_line, int(81), kw_end_DASH_column, int(18), kw_arglists, lang.NewList(lang.NewVector(sym_o, sym_w)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + _ = tmp5 + tmp6 := checkDerefVar(var_glojure_DOT_core_str) + tmp7 := lang.Apply(tmp6, []any{v2}) + tmp8 := lang.Apply(lang.WriteWriter, []any{v3, tmp7}) + return tmp8 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_print_DASH_simple = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_print_DASH_simple.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print-dup + { + tmp0 := sym_print_DASH_dup.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3667), kw_column, int(11), kw_end_DASH_line, int(3667), kw_end_DASH_column, int(19), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_class) + tmp6 := lang.Apply(tmp5, []any{v3}) + return tmp6 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3667), kw_column, int(21), kw_end_DASH_line, int(3667), kw_end_DASH_column, int(45))).(lang.FnFunc) + tmp1 := lang.NewMultiFn("print-dup", tmp2, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp7 := lang.Apply(tmp6, []any{v4, v5}) + return tmp7 + }) + tmp1.AddMethod(nil, tmp3) + tmp4 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp9 := lang.Apply(tmp8, []any{v6, v7}) + return tmp9 + }) + tmp1.AddMethod(tmp4, tmp5) + tmp6 := reflect.TypeOf((*lang.IPersistentList)(nil)).Elem() + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp11 := lang.Apply(tmp10, []any{v8, v9}) + return tmp11 + }) + tmp1.AddMethod(tmp6, tmp7) + tmp8 := reflect.TypeOf((*lang.Symbol)(nil)) + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp13 := lang.Apply(tmp12, []any{v10, v11}) + return tmp13 + }) + tmp1.AddMethod(tmp8, tmp9) + tmp10 := reflect.TypeOf((*lang.IRecord)(nil)).Elem() + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v12 := args[0] + _ = v12 + v13 := args[1] + _ = v13 + tmp14 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) + tmp15 := lang.Apply(tmp14, []any{v12, v13}) + _ = tmp15 + tmp16 := lang.Apply(lang.WriteWriter, []any{v13, "#"}) + _ = tmp16 + tmp17 := checkDerefVar(var_glojure_DOT_core_class) + tmp18 := lang.Apply(tmp17, []any{v12}) + tmp19, ok := lang.FieldOrMethod(tmp18, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp18, "Name"))) + } + var tmp20 any + switch reflect.TypeOf(tmp19).Kind() { + case reflect.Func: + tmp20 = lang.Apply(tmp19, nil) + default: + tmp20 = tmp19 + } + tmp21 := lang.Apply(lang.WriteWriter, []any{v13, tmp20}) + _ = tmp21 + var tmp22 any + tmp23 := checkDerefVar(var_glojure_DOT_core__STAR_verbose_DASH_defrecords_STAR_) + if lang.IsTruthy(tmp23) { + tmp24 := checkDerefVar(var_glojure_DOT_core_print_DASH_map) + tmp25 := checkDerefVar(var_glojure_DOT_core_print_DASH_dup) + tmp26 := lang.Apply(tmp24, []any{v12, tmp25, v13}) + tmp22 = tmp26 + } else { + tmp27 := checkDerefVar(var_glojure_DOT_core_print_DASH_sequential) + tmp28 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) + tmp29 := checkDerefVar(var_glojure_DOT_core_vals) + tmp30 := lang.Apply(tmp29, []any{v12}) + tmp31 := lang.Apply(tmp27, []any{"[", tmp28, ", ", "]", tmp30, v13}) + tmp22 = tmp31 + } + return tmp22 + }) + tmp1.AddMethod(tmp10, tmp11) + tmp12 := reflect.TypeOf((*lang.Set)(nil)) + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v14 := args[0] + _ = v14 + v15 := args[1] + _ = v15 + tmp16 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp17 := lang.Apply(tmp16, []any{v14, v15}) + return tmp17 + }) + tmp1.AddMethod(tmp12, tmp13) + tmp14 := reflect.TypeOf((*lang.PersistentHashMap)(nil)) + var tmp15 lang.FnFunc + tmp15 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v16 := args[0] + _ = v16 + v17 := args[1] + _ = v17 + tmp18 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp19 := lang.Apply(tmp18, []any{v16, v17}) + return tmp19 + }) + tmp1.AddMethod(tmp14, tmp15) + tmp16 := reflect.TypeOf(int64(0)) + var tmp17 lang.FnFunc + tmp17 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v18 := args[0] + _ = v18 + v19 := args[1] + _ = v19 + tmp20 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp21 := lang.Apply(tmp20, []any{v18, v19}) + return tmp21 + }) + tmp1.AddMethod(tmp16, tmp17) + tmp18 := reflect.TypeOf((*lang.Vector)(nil)) + var tmp19 lang.FnFunc + tmp19 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v20 := args[0] + _ = v20 + v21 := args[1] + _ = v21 + tmp22 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp23 := lang.Apply(tmp22, []any{v20, v21}) + return tmp23 + }) + tmp1.AddMethod(tmp18, tmp19) + tmp20 := reflect.TypeOf(float64(0)) + var tmp21 lang.FnFunc + tmp21 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v22 := args[0] + _ = v22 + v23 := args[1] + _ = v23 + tmp24 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp25 := lang.Apply(tmp24, []any{v22, v23}) + return tmp25 + }) + tmp1.AddMethod(tmp20, tmp21) + tmp22 := reflect.TypeOf("") + var tmp23 lang.FnFunc + tmp23 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v24 := args[0] + _ = v24 + v25 := args[1] + _ = v25 + tmp26 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp27 := lang.Apply(tmp26, []any{v24, v25}) + return tmp27 + }) + tmp1.AddMethod(tmp22, tmp23) + tmp24 := reflect.TypeOf((*lang.IPersistentCollection)(nil)).Elem() + var tmp25 lang.FnFunc + tmp25 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v26 := args[0] + _ = v26 + v27 := args[1] + _ = v27 + tmp28 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) + tmp29 := lang.Apply(tmp28, []any{v26, v27}) + _ = tmp29 + tmp30 := lang.Apply(lang.WriteWriter, []any{v27, "#=("}) + _ = tmp30 + tmp31 := checkDerefVar(var_glojure_DOT_core_class) + tmp32 := lang.Apply(tmp31, []any{v26}) + tmp33, ok := lang.FieldOrMethod(tmp32, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp32, "Name"))) + } + var tmp34 any + switch reflect.TypeOf(tmp33).Kind() { + case reflect.Func: + tmp34 = lang.Apply(tmp33, nil) + default: + tmp34 = tmp33 + } + tmp35 := lang.Apply(lang.WriteWriter, []any{v27, tmp34}) + _ = tmp35 + tmp36 := lang.Apply(lang.WriteWriter, []any{v27, "/create "}) + _ = tmp36 + tmp37 := checkDerefVar(var_glojure_DOT_core_print_DASH_sequential) + tmp38 := checkDerefVar(var_glojure_DOT_core_print_DASH_dup) + tmp39 := lang.Apply(tmp37, []any{"[", tmp38, " ", "]", v26, v27}) + _ = tmp39 + tmp40 := lang.Apply(lang.WriteWriter, []any{v27, ")"}) + return tmp40 + }) + tmp1.AddMethod(tmp24, tmp25) + tmp26 := reflect.TypeOf(int32(0)) + var tmp27 lang.FnFunc + tmp27 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v28 := args[0] + _ = v28 + v29 := args[1] + _ = v29 + tmp30 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp31 := lang.Apply(tmp30, []any{v28, v29}) + return tmp31 + }) + tmp1.AddMethod(tmp26, tmp27) + tmp28 := reflect.TypeOf((*lang.IPersistentMap)(nil)).Elem() + var tmp29 lang.FnFunc + tmp29 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v30 := args[0] + _ = v30 + v31 := args[1] + _ = v31 + tmp32 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) + tmp33 := lang.Apply(tmp32, []any{v30, v31}) + _ = tmp33 + tmp34 := lang.Apply(lang.WriteWriter, []any{v31, "#=("}) + _ = tmp34 + tmp35 := checkDerefVar(var_glojure_DOT_core_class) + tmp36 := lang.Apply(tmp35, []any{v30}) + tmp37, ok := lang.FieldOrMethod(tmp36, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp36, "Name"))) + } + var tmp38 any + switch reflect.TypeOf(tmp37).Kind() { + case reflect.Func: + tmp38 = lang.Apply(tmp37, nil) + default: + tmp38 = tmp37 + } + tmp39 := lang.Apply(lang.WriteWriter, []any{v31, tmp38}) + _ = tmp39 + tmp40 := lang.Apply(lang.WriteWriter, []any{v31, "/create "}) + _ = tmp40 + tmp41 := checkDerefVar(var_glojure_DOT_core_print_DASH_map) + tmp42 := checkDerefVar(var_glojure_DOT_core_print_DASH_dup) + tmp43 := lang.Apply(tmp41, []any{v30, tmp42, v31}) + _ = tmp43 + tmp44 := lang.Apply(lang.WriteWriter, []any{v31, ")"}) + return tmp44 + }) + tmp1.AddMethod(tmp28, tmp29) + tmp30 := reflect.TypeOf((*lang.Namespace)(nil)) + var tmp31 lang.FnFunc + tmp31 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v32 := args[0] + _ = v32 + v33 := args[1] + _ = v33 + tmp34 := lang.Apply(lang.WriteWriter, []any{v33, "#=(find-ns "}) + _ = tmp34 + tmp35 := checkDerefVar(var_glojure_DOT_core_print_DASH_dup) + tmp36, ok := lang.FieldOrMethod(v32, "name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v32, "name"))) + } + var tmp37 any + switch reflect.TypeOf(tmp36).Kind() { + case reflect.Func: + tmp37 = lang.Apply(tmp36, nil) + default: + tmp37 = tmp36 + } + tmp38 := lang.Apply(tmp35, []any{tmp37, v33}) + _ = tmp38 + tmp39 := lang.Apply(lang.WriteWriter, []any{v33, ")"}) + return tmp39 + }) + tmp1.AddMethod(tmp30, tmp31) + tmp32 := reflect.TypeOf(false) + var tmp33 lang.FnFunc + tmp33 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v34 := args[0] + _ = v34 + v35 := args[1] + _ = v35 + tmp36 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp37 := lang.Apply(tmp36, []any{v34, v35}) + return tmp37 + }) + tmp1.AddMethod(tmp32, tmp33) + tmp34 := reflect.TypeOf((*regexp12.Regexp)(nil)) + var tmp35 lang.FnFunc + tmp35 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v36 := args[0] + _ = v36 + v37 := args[1] + _ = v37 + tmp38 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp39 := lang.Apply(tmp38, []any{v36, v37}) + return tmp39 + }) + tmp1.AddMethod(tmp34, tmp35) + tmp36 := reflect.TypeOf((*lang.Ratio)(nil)) + var tmp37 lang.FnFunc + tmp37 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v38 := args[0] + _ = v38 + v39 := args[1] + _ = v39 + tmp40 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp41 := lang.Apply(tmp40, []any{v38, v39}) + return tmp41 + }) + tmp1.AddMethod(tmp36, tmp37) + tmp38 := reflect.TypeOf((*lang.Var)(nil)) + var tmp39 lang.FnFunc + tmp39 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v40 := args[0] + _ = v40 + v41 := args[1] + _ = v41 + tmp42 := checkDerefVar(var_glojure_DOT_core_str) + tmp43, ok := lang.FieldOrMethod(v40, "Namespace") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v40, "Namespace"))) + } + var tmp44 any + switch reflect.TypeOf(tmp43).Kind() { + case reflect.Func: + tmp44 = lang.Apply(tmp43, nil) + default: + tmp44 = tmp43 + } + tmp45, ok := lang.FieldOrMethod(tmp44, "name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp44, "name"))) + } + var tmp46 any + switch reflect.TypeOf(tmp45).Kind() { + case reflect.Func: + tmp46 = lang.Apply(tmp45, nil) + default: + tmp46 = tmp45 + } + tmp47, ok := lang.FieldOrMethod(v40, "sym") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v40, "sym"))) + } + var tmp48 any + switch reflect.TypeOf(tmp47).Kind() { + case reflect.Func: + tmp48 = lang.Apply(tmp47, nil) + default: + tmp48 = tmp47 + } + tmp49 := lang.Apply(tmp42, []any{"#=(var ", tmp46, "/", tmp48, ")"}) + tmp50 := lang.Apply(lang.WriteWriter, []any{v41, tmp49}) + return tmp50 + }) + tmp1.AddMethod(tmp38, tmp39) + tmp40 := reflect.TypeOf((*lang.BigDecimal)(nil)) + var tmp41 lang.FnFunc + tmp41 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v42 := args[0] + _ = v42 + v43 := args[1] + _ = v43 + tmp44 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp45 := lang.Apply(tmp44, []any{v42, v43}) + return tmp45 + }) + tmp1.AddMethod(tmp40, tmp41) + tmp42 := reflect.TypeOf((*lang.BigInt)(nil)) + var tmp43 lang.FnFunc + tmp43 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v44 := args[0] + _ = v44 + v45 := args[1] + _ = v45 + tmp46 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp47 := lang.Apply(tmp46, []any{v44, v45}) + return tmp47 + }) + tmp1.AddMethod(tmp42, tmp43) + tmp44 := reflect.TypeOf((*runtime.Fn)(nil)) + var tmp45 lang.FnFunc + tmp45 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v46 := args[0] + _ = v46 + v47 := args[1] + _ = v47 + tmp48 := checkDerefVar(var_glojure_DOT_core_print_DASH_ctor) + var tmp49 lang.FnFunc + tmp49 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v50 := args[0] + _ = v50 + v51 := args[1] + _ = v51 + return nil + }) + tmp50 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(167), kw_column, int(17), kw_end_DASH_line, int(167), kw_end_DASH_column, int(26)) + tmp51, err := lang.WithMeta(tmp49, tmp50.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp52 := lang.Apply(tmp48, []any{v46, tmp51, v47}) + return tmp52 + }) + tmp1.AddMethod(tmp44, tmp45) + tmp46 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() + var tmp47 lang.FnFunc + tmp47 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v48 := args[0] + _ = v48 + v49 := args[1] + _ = v49 + tmp50 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp51 := lang.Apply(tmp50, []any{v48, v49}) + return tmp51 + }) + tmp1.AddMethod(tmp46, tmp47) + tmp48 := reflect.TypeOf((*lang.IPersistentCollection)(nil)).Elem() + tmp49 := reflect.TypeOf((*runtime.Fn)(nil)) + tmp1.PreferMethod(tmp48, tmp49) + tmp50 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() + tmp51 := reflect.TypeOf((*lang.IPersistentCollection)(nil)).Elem() + tmp1.PreferMethod(tmp50, tmp51) + tmp52 := reflect.TypeOf((*lang.IRecord)(nil)).Elem() + tmp53 := reflect.TypeOf((*lang.IPersistentMap)(nil)).Elem() + tmp1.PreferMethod(tmp52, tmp53) + tmp54 := reflect.TypeOf((*lang.IRecord)(nil)).Elem() + tmp55 := reflect.TypeOf((*lang.IPersistentCollection)(nil)).Elem() + tmp1.PreferMethod(tmp54, tmp55) + var_glojure_DOT_core_print_DASH_dup = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_print_DASH_dup.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print-method + { + tmp0 := sym_print_DASH_method.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3664), kw_column, int(11), kw_end_DASH_line, int(3664), kw_end_DASH_column, int(22), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v3 := args[0] + _ = v3 + v4 := args[1] + _ = v4 + var tmp5 any + { // let + // let binding "t" + tmp6 := checkDerefVar(var_glojure_DOT_core_get) + tmp7 := checkDerefVar(var_glojure_DOT_core_meta) + tmp8 := lang.Apply(tmp7, []any{v3}) + tmp9 := lang.Apply(tmp6, []any{tmp8, kw_type}) + var v10 any = tmp9 + _ = v10 + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp13 := lang.Apply(tmp12, []any{v10}) + if lang.IsTruthy(tmp13) { + tmp11 = v10 + } else { + tmp14 := checkDerefVar(var_glojure_DOT_core_class) + tmp15 := lang.Apply(tmp14, []any{v3}) + tmp11 = tmp15 + } + tmp5 = tmp11 + } // end let + return tmp5 + }) + tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3664), kw_column, int(24), kw_end_DASH_line, int(3666), kw_end_DASH_column, int(58))).(lang.FnFunc) + tmp1 := lang.NewMultiFn("print-method", tmp2, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v4 := args[0] + _ = v4 + v5 := args[1] + _ = v5 + tmp6 := lang.Apply(lang.WriteWriter, []any{v5, "nil"}) + return tmp6 + }) + tmp1.AddMethod(nil, tmp3) + tmp4 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_str) + tmp9 := lang.Apply(tmp8, []any{v6}) + tmp10 := lang.Apply(lang.WriteWriter, []any{v7, tmp9}) + return tmp10 + }) + tmp1.AddMethod(tmp4, tmp5) + tmp6 := reflect.TypeOf(uint32(0)) + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_str) + tmp11 := lang.Apply(tmp10, []any{v8}) + tmp12, _ := lang.FieldOrMethod(v9, "write") + if reflect.TypeOf(tmp12).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + } + tmp13 := lang.Apply(tmp12, []any{tmp11}) + return tmp13 + }) + tmp1.AddMethod(tmp6, tmp7) + tmp8 := reflect.TypeOf((*lang.Symbol)(nil)) + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_print_DASH_simple) + tmp13 := lang.Apply(tmp12, []any{v10, v11}) + return tmp13 + }) + tmp1.AddMethod(tmp8, tmp9) + tmp10 := reflect.TypeOf((*lang.IRecord)(nil)).Elem() + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v12 := args[0] + _ = v12 + v13 := args[1] + _ = v13 + tmp14 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) + tmp15 := lang.Apply(tmp14, []any{v12, v13}) + _ = tmp15 + tmp16 := lang.Apply(lang.WriteWriter, []any{v13, "#"}) + _ = tmp16 + tmp17 := checkDerefVar(var_glojure_DOT_core_class) + tmp18 := lang.Apply(tmp17, []any{v12}) + tmp19, ok := lang.FieldOrMethod(tmp18, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp18, "Name"))) + } + var tmp20 any + switch reflect.TypeOf(tmp19).Kind() { + case reflect.Func: + tmp20 = lang.Apply(tmp19, nil) + default: + tmp20 = tmp19 + } + tmp21 := lang.Apply(lang.WriteWriter, []any{v13, tmp20}) + _ = tmp21 + tmp22 := checkDerefVar(var_glojure_DOT_core_print_DASH_map) + tmp23 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) + tmp24 := lang.Apply(tmp22, []any{v12, tmp23, v13}) + return tmp24 + }) + tmp1.AddMethod(tmp10, tmp11) + tmp12 := reflect.TypeOf(uint(0)) + var tmp13 lang.FnFunc + tmp13 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v14 := args[0] + _ = v14 + v15 := args[1] + _ = v15 + tmp16 := checkDerefVar(var_glojure_DOT_core_str) + tmp17 := lang.Apply(tmp16, []any{v14}) + tmp18, _ := lang.FieldOrMethod(v15, "write") + if reflect.TypeOf(tmp18).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + } + tmp19 := lang.Apply(tmp18, []any{tmp17}) + return tmp19 + }) + tmp1.AddMethod(tmp12, tmp13) + tmp14 := reflect.TypeOf(int64(0)) + var tmp15 lang.FnFunc + tmp15 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v16 := args[0] + _ = v16 + v17 := args[1] + _ = v17 + tmp18 := checkDerefVar(var_glojure_DOT_core_str) + tmp19 := lang.Apply(tmp18, []any{v16}) + tmp20, _ := lang.FieldOrMethod(v17, "write") + if reflect.TypeOf(tmp20).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + } + tmp21 := lang.Apply(tmp20, []any{tmp19}) + return tmp21 + }) + tmp1.AddMethod(tmp14, tmp15) + var tmp16 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v17 := args[0] + _ = v17 + v18 := args[1] + _ = v18 + var tmp19 any + tmp20 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp21 := reflect.TypeOf((*lang.IObj)(nil)).Elem() + tmp22 := lang.Apply(tmp20, []any{tmp21, v17}) + if lang.IsTruthy(tmp22) { + tmp23 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp24 := checkDerefVar(var_glojure_DOT_core_vary_DASH_meta) + var tmp25 lang.FnFunc + tmp25 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v26 := args[0] + _ = v26 + tmp27 := checkDerefVar(var_glojure_DOT_core_dissoc) + tmp28 := lang.Apply(tmp27, []any{v26, kw_type}) + return tmp28 + }) + tmp26 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(87), kw_column, int(32), kw_end_DASH_line, int(87), kw_end_DASH_column, int(48)) + tmp27, err := lang.WithMeta(tmp25, tmp26.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp28 := lang.Apply(tmp24, []any{v17, tmp27}) + tmp29 := lang.Apply(tmp23, []any{tmp28, v18}) + tmp19 = tmp29 + } else { + tmp30 := checkDerefVar(var_glojure_DOT_core_print_DASH_simple) + tmp31 := lang.Apply(tmp30, []any{v17, v18}) + tmp19 = tmp31 + } + return tmp19 + }) + tmp1.AddMethod(kw_default, tmp16) + tmp17 := reflect.TypeOf(float64(0)) + var tmp18 lang.FnFunc + tmp18 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v19 := args[0] + _ = v19 + v20 := args[1] + _ = v20 + var tmp21 any + tmp22 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp23 := lang.Apply(math4.Inf, []any{int64(1)}) + tmp24 := lang.Apply(tmp22, []any{tmp23, v19}) + if lang.IsTruthy(tmp24) { + tmp25 := lang.Apply(lang.WriteWriter, []any{v20, "##Inf"}) + tmp21 = tmp25 + } else { + var tmp26 any + tmp27 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp28 := lang.Apply(math4.Inf, []any{int64(-1)}) + tmp29 := lang.Apply(tmp27, []any{tmp28, v19}) + if lang.IsTruthy(tmp29) { + tmp30 := lang.Apply(lang.WriteWriter, []any{v20, "##-Inf"}) + tmp26 = tmp30 + } else { + var tmp31 any + tmp32 := lang.Apply(math4.IsNaN, []any{v19}) + if lang.IsTruthy(tmp32) { + tmp33 := lang.Apply(lang.WriteWriter, []any{v20, "##NaN"}) + tmp31 = tmp33 + } else { + var tmp34 any + if lang.IsTruthy(kw_else) { + tmp35 := checkDerefVar(var_glojure_DOT_core_str) + tmp36 := lang.Apply(tmp35, []any{v19}) + tmp37 := lang.Apply(lang.WriteWriter, []any{v20, tmp36}) + tmp34 = tmp37 + } else { + } + tmp31 = tmp34 + } + tmp26 = tmp31 + } + tmp21 = tmp26 + } + return tmp21 + }) + tmp1.AddMethod(tmp17, tmp18) + tmp19 := reflect.TypeOf("") + var tmp20 lang.FnFunc + tmp20 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v21 := args[0] + _ = v21 + v22 := args[1] + _ = v22 + var tmp23 any + var tmp24 any + { // let + // let binding "or__0__auto__" + tmp25 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_dup_STAR_) + var v26 any = tmp25 + _ = v26 + var tmp27 any + if lang.IsTruthy(v26) { + tmp27 = v26 + } else { + tmp28 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_readably_STAR_) + tmp27 = tmp28 + } + tmp24 = tmp27 + } // end let + if lang.IsTruthy(tmp24) { + tmp25 := lang.Apply(lang.AppendWriter, []any{v22, lang.NewChar(34)}) + _ = tmp25 + var tmp26 any + { // let + // let binding "n__0__auto__" + tmp27 := checkDerefVar(var_glojure_DOT_core_long) + tmp28 := checkDerefVar(var_glojure_DOT_core_count) + tmp29 := lang.Apply(tmp28, []any{v21}) + tmp30 := lang.Apply(tmp27, []any{tmp29}) + var v31 any = tmp30 + _ = v31 + var tmp32 any + { // let + // let binding "n" + var v33 any = int64(0) + _ = v33 + for { + var tmp34 any + tmp35 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp36 := lang.Apply(tmp35, []any{v33, v31}) + if lang.IsTruthy(tmp36) { + var tmp37 any + { // let + // let binding "c" + tmp38 := lang.Apply(lang.CharAt, []any{v21, v33}) + var v39 any = tmp38 + _ = v39 + // let binding "e" + tmp40 := checkDerefVar(var_glojure_DOT_core_char_DASH_escape_DASH_string) + tmp41 := lang.Apply(tmp40, []any{v39}) + var v42 any = tmp41 + _ = v42 + var tmp43 any + if lang.IsTruthy(v42) { + tmp44 := lang.Apply(lang.WriteWriter, []any{v22, v42}) + tmp43 = tmp44 + } else { + tmp45 := lang.Apply(lang.AppendWriter, []any{v22, v39}) + tmp43 = tmp45 + } + tmp37 = tmp43 + } // end let + _ = tmp37 + tmp39 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp40 := lang.Apply(tmp39, []any{v33}) + var tmp38 any = tmp40 + v33 = tmp38 + continue + } else { + } + tmp32 = tmp34 + break + } + } // end let + tmp26 = tmp32 + } // end let + _ = tmp26 + tmp27 := lang.Apply(lang.AppendWriter, []any{v22, lang.NewChar(34)}) + tmp23 = tmp27 + } else { + tmp28 := lang.Apply(lang.WriteWriter, []any{v22, v21}) + tmp23 = tmp28 + } + _ = tmp23 + return nil + }) + tmp1.AddMethod(tmp19, tmp20) + tmp21 := reflect.TypeOf(int32(0)) + var tmp22 lang.FnFunc + tmp22 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v23 := args[0] + _ = v23 + v24 := args[1] + _ = v24 + var tmp25 any + var tmp26 any + { // let + // let binding "or__0__auto__" + tmp27 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_dup_STAR_) + var v28 any = tmp27 + _ = v28 + var tmp29 any + if lang.IsTruthy(v28) { + tmp29 = v28 + } else { + tmp30 := checkDerefVar(var_glojure_DOT_core__STAR_print_DASH_readably_STAR_) + tmp29 = tmp30 + } + tmp26 = tmp29 + } // end let + if lang.IsTruthy(tmp26) { + tmp27 := lang.Apply(lang.AppendWriter, []any{v24, lang.NewChar(92)}) + _ = tmp27 + var tmp28 any + { // let + // let binding "n" + tmp29 := checkDerefVar(var_glojure_DOT_core_char_DASH_name_DASH_string) + tmp30 := lang.Apply(tmp29, []any{v23}) + var v31 any = tmp30 + _ = v31 + var tmp32 any + if lang.IsTruthy(v31) { + tmp33 := lang.Apply(lang.WriteWriter, []any{v24, v31}) + tmp32 = tmp33 + } else { + tmp34 := lang.Apply(lang.AppendWriter, []any{v24, v23}) + tmp32 = tmp34 + } + tmp28 = tmp32 + } // end let + tmp25 = tmp28 + } else { + tmp29 := lang.Apply(lang.AppendWriter, []any{v24, v23}) + tmp25 = tmp29 + } + _ = tmp25 + return nil + }) + tmp1.AddMethod(tmp21, tmp22) + tmp23 := reflect.TypeOf((*lang.IPersistentMap)(nil)).Elem() + var tmp24 lang.FnFunc + tmp24 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v25 := args[0] + _ = v25 + v26 := args[1] + _ = v26 + tmp27 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) + tmp28 := lang.Apply(tmp27, []any{v25, v26}) + _ = tmp28 + var tmp29 any + { // let + // let binding "vec__925" + tmp30 := checkDerefVar(var_glojure_DOT_core_lift_DASH_ns) + tmp31 := lang.Apply(tmp30, []any{v25}) + var v32 any = tmp31 + _ = v32 + // let binding "ns" + tmp33 := checkDerefVar(var_glojure_DOT_core_nth) + tmp34 := lang.Apply(tmp33, []any{v32, int64(0), nil}) + var v35 any = tmp34 + _ = v35 + // let binding "lift-kvs" + tmp36 := checkDerefVar(var_glojure_DOT_core_nth) + tmp37 := lang.Apply(tmp36, []any{v32, int64(1), nil}) + var v38 any = tmp37 + _ = v38 + var tmp39 any + if lang.IsTruthy(v35) { + tmp40 := checkDerefVar(var_glojure_DOT_core_print_DASH_prefix_DASH_map) + tmp41 := checkDerefVar(var_glojure_DOT_core_str) + tmp42 := lang.Apply(tmp41, []any{"#:", v35}) + tmp43 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) + tmp44 := lang.Apply(tmp40, []any{tmp42, v38, tmp43, v26}) + tmp39 = tmp44 + } else { + tmp45 := checkDerefVar(var_glojure_DOT_core_print_DASH_map) + tmp46 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) + tmp47 := lang.Apply(tmp45, []any{v25, tmp46, v26}) + tmp39 = tmp47 + } + tmp29 = tmp39 + } // end let + return tmp29 + }) + tmp1.AddMethod(tmp23, tmp24) + tmp25 := reflect.TypeOf((*lang.IPersistentVector)(nil)).Elem() + var tmp26 lang.FnFunc + tmp26 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v27 := args[0] + _ = v27 + v28 := args[1] + _ = v28 + tmp29 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) + tmp30 := lang.Apply(tmp29, []any{v27, v28}) + _ = tmp30 + tmp31 := checkDerefVar(var_glojure_DOT_core_print_DASH_sequential) + tmp32 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) + tmp33 := lang.Apply(tmp31, []any{"[", tmp32, " ", "]", v27, v28}) + return tmp33 + }) + tmp1.AddMethod(tmp25, tmp26) + tmp27 := reflect.TypeOf((*lang.IPersistentSet)(nil)).Elem() + var tmp28 lang.FnFunc + tmp28 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v29 := args[0] + _ = v29 + v30 := args[1] + _ = v30 + tmp31 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) + tmp32 := lang.Apply(tmp31, []any{v29, v30}) + _ = tmp32 + tmp33 := checkDerefVar(var_glojure_DOT_core_print_DASH_sequential) + tmp34 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) + tmp35 := checkDerefVar(var_glojure_DOT_core_seq) + tmp36 := lang.Apply(tmp35, []any{v29}) + tmp37 := lang.Apply(tmp33, []any{"#{", tmp34, " ", "}", tmp36, v30}) + return tmp37 + }) + tmp1.AddMethod(tmp27, tmp28) + tmp29 := reflect.TypeOf(uint8(0)) + var tmp30 lang.FnFunc + tmp30 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v31 := args[0] + _ = v31 + v32 := args[1] + _ = v32 + tmp33 := checkDerefVar(var_glojure_DOT_core_str) + tmp34 := lang.Apply(tmp33, []any{v31}) + tmp35, _ := lang.FieldOrMethod(v32, "write") + if reflect.TypeOf(tmp35).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + } + tmp36 := lang.Apply(tmp35, []any{tmp34}) + return tmp36 + }) + tmp1.AddMethod(tmp29, tmp30) + tmp31 := reflect.TypeOf((*lang.IDeref)(nil)).Elem() + var tmp32 lang.FnFunc + tmp32 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v33 := args[0] + _ = v33 + v34 := args[1] + _ = v34 + tmp35 := checkDerefVar(var_glojure_DOT_core_print_DASH_tagged_DASH_object) + tmp36 := checkDerefVar(var_glojure_DOT_core_deref_DASH_as_DASH_map) + tmp37 := lang.Apply(tmp36, []any{v33}) + tmp38 := lang.Apply(tmp35, []any{v33, tmp37, v34}) + return tmp38 + }) + tmp1.AddMethod(tmp31, tmp32) + tmp33 := reflect.TypeOf(false) + var tmp34 lang.FnFunc + tmp34 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v35 := args[0] + _ = v35 + v36 := args[1] + _ = v36 + tmp37 := checkDerefVar(var_glojure_DOT_core_str) + tmp38 := lang.Apply(tmp37, []any{v35}) + tmp39 := lang.Apply(lang.WriteWriter, []any{v36, tmp38}) + return tmp39 + }) + tmp1.AddMethod(tmp33, tmp34) + tmp35 := reflect.TypeOf((*lang.Object)(nil)).Elem() + var tmp36 lang.FnFunc + tmp36 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v37 := args[0] + _ = v37 + v38 := args[1] + _ = v38 + tmp39 := checkDerefVar(var_glojure_DOT_core_print_DASH_object) + tmp40 := lang.Apply(tmp39, []any{v37, v38}) + return tmp40 + }) + tmp1.AddMethod(tmp35, tmp36) + tmp37 := reflect.TypeOf(int(0)) + var tmp38 lang.FnFunc + tmp38 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v39 := args[0] + _ = v39 + v40 := args[1] + _ = v40 + tmp41 := checkDerefVar(var_glojure_DOT_core_str) + tmp42 := lang.Apply(tmp41, []any{v39}) + tmp43, _ := lang.FieldOrMethod(v40, "write") + if reflect.TypeOf(tmp43).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + } + tmp44 := lang.Apply(tmp43, []any{tmp42}) + return tmp44 + }) + tmp1.AddMethod(tmp37, tmp38) + tmp39 := reflect.TypeOf((*regexp12.Regexp)(nil)) + var tmp40 lang.FnFunc + tmp40 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v41 := args[0] + _ = v41 + v42 := args[1] + _ = v42 + tmp43 := lang.Apply(lang.WriteWriter, []any{v42, "#\""}) + _ = tmp43 + var tmp44 any + { // let + // let binding "G__931" + tmp45 := checkDerefVar(var_glojure_DOT_core_seq) + tmp46, ok := lang.FieldOrMethod(v41, "String") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v41, "String"))) + } + var tmp47 any + switch reflect.TypeOf(tmp46).Kind() { + case reflect.Func: + tmp47 = lang.Apply(tmp46, nil) + default: + tmp47 = tmp46 + } + tmp48 := lang.Apply(tmp45, []any{tmp47}) + var v49 any = tmp48 + _ = v49 + // let binding "vec__932" + var v50 any = v49 + _ = v50 + // let binding "seq__933" + tmp51 := checkDerefVar(var_glojure_DOT_core_seq) + tmp52 := lang.Apply(tmp51, []any{v50}) + var v53 any = tmp52 + _ = v53 + // let binding "first__934" + tmp54 := checkDerefVar(var_glojure_DOT_core_first) + tmp55 := lang.Apply(tmp54, []any{v53}) + var v56 any = tmp55 + _ = v56 + // let binding "seq__933" + tmp57 := checkDerefVar(var_glojure_DOT_core_next) + tmp58 := lang.Apply(tmp57, []any{v53}) + var v59 any = tmp58 + _ = v59 + // let binding "c" + var v60 any = v56 + _ = v60 + // let binding "r" + var v61 any = v59 + _ = v61 + // let binding "s" + var v62 any = v50 + _ = v62 + // let binding "qmode" + var v63 any = false + _ = v63 + var tmp64 any + { // let + // let binding "G__931" + var v65 any = v49 + _ = v65 + // let binding "qmode" + var v66 any = v63 + _ = v66 + for { + var tmp67 any + { // let + // let binding "vec__935" + var v68 any = v65 + _ = v68 + // let binding "seq__936" + tmp69 := checkDerefVar(var_glojure_DOT_core_seq) + tmp70 := lang.Apply(tmp69, []any{v68}) + var v71 any = tmp70 + _ = v71 + // let binding "first__937" + tmp72 := checkDerefVar(var_glojure_DOT_core_first) + tmp73 := lang.Apply(tmp72, []any{v71}) + var v74 any = tmp73 + _ = v74 + // let binding "seq__936" + tmp75 := checkDerefVar(var_glojure_DOT_core_next) + tmp76 := lang.Apply(tmp75, []any{v71}) + var v77 any = tmp76 + _ = v77 + // let binding "c" + var v78 any = v74 + _ = v78 + // let binding "r" + var v79 any = v77 + _ = v79 + // let binding "s" + var v80 any = v68 + _ = v80 + // let binding "qmode" + var v81 any = v66 + _ = v81 + var tmp82 any + if lang.IsTruthy(v80) { + var tmp83 any + tmp84 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp85 := lang.Apply(tmp84, []any{v78, lang.NewChar(92)}) + if lang.IsTruthy(tmp85) { + var tmp86 any + { // let + // let binding "vec__938" + var v87 any = v79 + _ = v87 + // let binding "seq__939" + tmp88 := checkDerefVar(var_glojure_DOT_core_seq) + tmp89 := lang.Apply(tmp88, []any{v87}) + var v90 any = tmp89 + _ = v90 + // let binding "first__940" + tmp91 := checkDerefVar(var_glojure_DOT_core_first) + tmp92 := lang.Apply(tmp91, []any{v90}) + var v93 any = tmp92 + _ = v93 + // let binding "seq__939" + tmp94 := checkDerefVar(var_glojure_DOT_core_next) + tmp95 := lang.Apply(tmp94, []any{v90}) + var v96 any = tmp95 + _ = v96 + // let binding "c2" + var v97 any = v93 + _ = v97 + // let binding "r2" + var v98 any = v96 + _ = v98 + tmp99 := lang.Apply(lang.AppendWriter, []any{v42, lang.NewChar(92)}) + _ = tmp99 + tmp100 := lang.Apply(lang.AppendWriter, []any{v42, v97}) + _ = tmp100 + var tmp101 any + if lang.IsTruthy(v81) { + var tmp102 any = v98 + tmp104 := checkDerefVar(var_glojure_DOT_core_not_EQ_) + tmp105 := lang.Apply(tmp104, []any{v97, lang.NewChar(69)}) + var tmp103 any = tmp105 + v65 = tmp102 + v66 = tmp103 + continue + } else { + var tmp106 any = v98 + tmp108 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp109 := lang.Apply(tmp108, []any{v97, lang.NewChar(81)}) + var tmp107 any = tmp109 + v65 = tmp106 + v66 = tmp107 + continue + } + tmp86 = tmp101 + } // end let + tmp83 = tmp86 + } else { + var tmp87 any + tmp88 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp89 := lang.Apply(tmp88, []any{v78, lang.NewChar(34)}) + if lang.IsTruthy(tmp89) { + var tmp90 any + if lang.IsTruthy(v81) { + tmp91 := lang.Apply(lang.WriteWriter, []any{v42, "\\E\\\"\\Q"}) + tmp90 = tmp91 + } else { + tmp92 := lang.Apply(lang.WriteWriter, []any{v42, "\\\""}) + tmp90 = tmp92 + } + _ = tmp90 + var tmp93 any = v79 + var tmp94 any = v81 + v65 = tmp93 + v66 = tmp94 + continue + } else { + var tmp95 any + if lang.IsTruthy(kw_else) { + tmp96 := lang.Apply(lang.AppendWriter, []any{v42, v78}) + _ = tmp96 + var tmp97 any = v79 + var tmp98 any = v81 + v65 = tmp97 + v66 = tmp98 + continue + } else { + } + tmp87 = tmp95 + } + tmp83 = tmp87 + } + tmp82 = tmp83 + } else { + } + tmp67 = tmp82 + } // end let + tmp64 = tmp67 + break + } + } // end let + tmp44 = tmp64 + } // end let + _ = tmp44 + tmp45 := lang.Apply(lang.AppendWriter, []any{v42, lang.NewChar(34)}) + return tmp45 + }) + tmp1.AddMethod(tmp39, tmp40) + tmp41 := reflect.TypeOf(int32(0)) + var tmp42 lang.FnFunc + tmp42 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v43 := args[0] + _ = v43 + v44 := args[1] + _ = v44 + tmp45 := checkDerefVar(var_glojure_DOT_core_str) + tmp46 := lang.Apply(tmp45, []any{v43}) + tmp47, _ := lang.FieldOrMethod(v44, "write") + if reflect.TypeOf(tmp47).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + } + tmp48 := lang.Apply(tmp47, []any{tmp46}) + return tmp48 + }) + tmp1.AddMethod(tmp41, tmp42) + tmp43 := reflect.TypeOf((*lang.Ratio)(nil)) + var tmp44 lang.FnFunc + tmp44 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v45 := args[0] + _ = v45 + v46 := args[1] + _ = v46 + tmp47 := checkDerefVar(var_glojure_DOT_core_str) + tmp48 := lang.Apply(tmp47, []any{v45}) + tmp49, _ := lang.FieldOrMethod(v46, "write") + if reflect.TypeOf(tmp49).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + } + tmp50 := lang.Apply(tmp49, []any{tmp48}) + return tmp50 + }) + tmp1.AddMethod(tmp43, tmp44) + tmp45 := reflect.TypeOf(float32(0)) + var tmp46 lang.FnFunc + tmp46 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v47 := args[0] + _ = v47 + v48 := args[1] + _ = v48 + var tmp49 any + tmp50 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp51 := lang.Apply(math4.Inf, []any{int64(1)}) + tmp52 := lang.Apply(lang.Builtins["float32"], []any{tmp51}) + tmp53 := lang.Apply(tmp50, []any{tmp52, v47}) + if lang.IsTruthy(tmp53) { + tmp54 := lang.Apply(lang.WriteWriter, []any{v48, "##Inf"}) + tmp49 = tmp54 + } else { + var tmp55 any + tmp56 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp57 := lang.Apply(math4.Inf, []any{int64(-1)}) + tmp58 := lang.Apply(lang.Builtins["float32"], []any{tmp57}) + tmp59 := lang.Apply(tmp56, []any{tmp58, v47}) + if lang.IsTruthy(tmp59) { + tmp60 := lang.Apply(lang.WriteWriter, []any{v48, "##-Inf"}) + tmp55 = tmp60 + } else { + var tmp61 any + tmp62 := lang.Apply(math4.IsNaN, []any{v47}) + if lang.IsTruthy(tmp62) { + tmp63 := lang.Apply(lang.WriteWriter, []any{v48, "##NaN"}) + tmp61 = tmp63 + } else { + var tmp64 any + if lang.IsTruthy(kw_else) { + tmp65 := checkDerefVar(var_glojure_DOT_core_str) + tmp66 := lang.Apply(tmp65, []any{v47}) + tmp67 := lang.Apply(lang.WriteWriter, []any{v48, tmp66}) + tmp64 = tmp67 + } else { + } + tmp61 = tmp64 + } + tmp55 = tmp61 + } + tmp49 = tmp55 + } + return tmp49 + }) + tmp1.AddMethod(tmp45, tmp46) + tmp47 := reflect.TypeOf(int16(0)) + var tmp48 lang.FnFunc + tmp48 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v49 := args[0] + _ = v49 + v50 := args[1] + _ = v50 + tmp51 := checkDerefVar(var_glojure_DOT_core_str) + tmp52 := lang.Apply(tmp51, []any{v49}) + tmp53, _ := lang.FieldOrMethod(v50, "write") + if reflect.TypeOf(tmp53).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + } + tmp54 := lang.Apply(tmp53, []any{tmp52}) + return tmp54 + }) + tmp1.AddMethod(tmp47, tmp48) + tmp49 := reflect.TypeOf((*lang.Var)(nil)) + var tmp50 lang.FnFunc + tmp50 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v51 := args[0] + _ = v51 + v52 := args[1] + _ = v52 + tmp53 := checkDerefVar(var_glojure_DOT_core_print_DASH_simple) + tmp54 := lang.Apply(tmp53, []any{v51, v52}) + return tmp54 + }) + tmp1.AddMethod(tmp49, tmp50) + tmp51 := reflect.TypeOf(int8(0)) + var tmp52 lang.FnFunc + tmp52 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v53 := args[0] + _ = v53 + v54 := args[1] + _ = v54 + tmp55 := checkDerefVar(var_glojure_DOT_core_str) + tmp56 := lang.Apply(tmp55, []any{v53}) + tmp57, _ := lang.FieldOrMethod(v54, "write") + if reflect.TypeOf(tmp57).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + } + tmp58 := lang.Apply(tmp57, []any{tmp56}) + return tmp58 + }) + tmp1.AddMethod(tmp51, tmp52) + tmp53 := reflect.TypeOf(uint16(0)) + var tmp54 lang.FnFunc + tmp54 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v55 := args[0] + _ = v55 + v56 := args[1] + _ = v56 + tmp57 := checkDerefVar(var_glojure_DOT_core_str) + tmp58 := lang.Apply(tmp57, []any{v55}) + tmp59, _ := lang.FieldOrMethod(v56, "write") + if reflect.TypeOf(tmp59).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + } + tmp60 := lang.Apply(tmp59, []any{tmp58}) + return tmp60 + }) + tmp1.AddMethod(tmp53, tmp54) + tmp55 := reflect.TypeOf(uint64(0)) + var tmp56 lang.FnFunc + tmp56 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v57 := args[0] + _ = v57 + v58 := args[1] + _ = v58 + tmp59 := checkDerefVar(var_glojure_DOT_core_str) + tmp60 := lang.Apply(tmp59, []any{v57}) + tmp61, _ := lang.FieldOrMethod(v58, "write") + if reflect.TypeOf(tmp61).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("write is not a function"))) + } + tmp62 := lang.Apply(tmp61, []any{tmp60}) + return tmp62 + }) + tmp1.AddMethod(tmp55, tmp56) + tmp57 := reflect.TypeOf((*lang.BigDecimal)(nil)) + var tmp58 lang.FnFunc + tmp58 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v59 := args[0] + _ = v59 + v60 := args[1] + _ = v60 + tmp61 := checkDerefVar(var_glojure_DOT_core_str) + tmp62 := lang.Apply(tmp61, []any{v59}) + tmp63 := lang.Apply(lang.WriteWriter, []any{v60, tmp62}) + _ = tmp63 + tmp64 := lang.Apply(lang.WriteWriter, []any{v60, "M"}) + return tmp64 + }) + tmp1.AddMethod(tmp57, tmp58) + tmp59 := reflect.TypeOf((*lang.BigInt)(nil)) + var tmp60 lang.FnFunc + tmp60 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v61 := args[0] + _ = v61 + v62 := args[1] + _ = v62 + tmp63 := checkDerefVar(var_glojure_DOT_core_str) + tmp64 := lang.Apply(tmp63, []any{v61}) + tmp65 := lang.Apply(lang.WriteWriter, []any{v62, tmp64}) + _ = tmp65 + tmp66 := lang.Apply(lang.WriteWriter, []any{v62, "N"}) + return tmp66 + }) + tmp1.AddMethod(tmp59, tmp60) + tmp61 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() + var tmp62 lang.FnFunc + tmp62 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v63 := args[0] + _ = v63 + v64 := args[1] + _ = v64 + tmp65 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) + tmp66 := lang.Apply(tmp65, []any{v63, v64}) + _ = tmp66 + tmp67 := checkDerefVar(var_glojure_DOT_core_print_DASH_sequential) + tmp68 := checkDerefVar(var_glojure_DOT_core_pr_DASH_on) + tmp69 := lang.Apply(tmp67, []any{"(", tmp68, " ", ")", v63, v64}) + return tmp69 + }) + tmp1.AddMethod(tmp61, tmp62) + tmp63 := reflect.TypeOf((*lang.ISeq)(nil)).Elem() + tmp64 := reflect.TypeOf((*lang.IPersistentCollection)(nil)).Elem() + tmp1.PreferMethod(tmp63, tmp64) + tmp65 := reflect.TypeOf((*lang.IRecord)(nil)).Elem() + tmp66 := reflect.TypeOf((*lang.IPersistentMap)(nil)).Elem() + tmp1.PreferMethod(tmp65, tmp66) + var_glojure_DOT_core_print_DASH_method = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_print_DASH_method.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print-tagged-object + { + tmp0 := sym_print_DASH_tagged_DASH_object.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(102), kw_column, int(8), kw_end_DASH_line, int(102), kw_end_DASH_column, int(26), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_o, sym_rep, sym_w)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp7 := reflect.TypeOf((*lang.IMeta)(nil)).Elem() + tmp8 := lang.Apply(tmp6, []any{tmp7, v2}) + if lang.IsTruthy(tmp8) { + tmp9 := checkDerefVar(var_glojure_DOT_core_print_DASH_meta) + tmp10 := lang.Apply(tmp9, []any{v2, v4}) + tmp5 = tmp10 + } else { + } + _ = tmp5 + tmp11 := lang.Apply(lang.WriteWriter, []any{v4, "#object["}) + _ = tmp11 + var tmp12 any + { // let + // let binding "c" + tmp13 := checkDerefVar(var_glojure_DOT_core_class) + tmp14 := lang.Apply(tmp13, []any{v2}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + if lang.IsTruthy(false) { + tmp17 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp18, ok := lang.FieldOrMethod(v15, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v15, "Name"))) + } + var tmp19 any + switch reflect.TypeOf(tmp18).Kind() { + case reflect.Func: + tmp19 = lang.Apply(tmp18, nil) + default: + tmp19 = tmp18 + } + tmp20 := lang.Apply(tmp17, []any{tmp19, v4}) + tmp16 = tmp20 + } else { + tmp21, ok := lang.FieldOrMethod(v15, "Name") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v15, "Name"))) + } + var tmp22 any + switch reflect.TypeOf(tmp21).Kind() { + case reflect.Func: + tmp22 = lang.Apply(tmp21, nil) + default: + tmp22 = tmp21 + } + tmp23 := lang.Apply(lang.WriteWriter, []any{v4, tmp22}) + tmp16 = tmp23 + } + tmp12 = tmp16 + } // end let + _ = tmp12 + tmp13 := lang.Apply(lang.WriteWriter, []any{v4, " "}) + _ = tmp13 + tmp14 := checkDerefVar(var_glojure_DOT_core_format) + tmp15 := lang.Apply(lang.IdentityHash, []any{v2}) + tmp16 := lang.Apply(tmp14, []any{"0x%x ", tmp15}) + tmp17 := lang.Apply(lang.WriteWriter, []any{v4, tmp16}) + _ = tmp17 + tmp18 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp19 := lang.Apply(tmp18, []any{v3, v4}) + _ = tmp19 + tmp20 := lang.Apply(lang.WriteWriter, []any{v4, "]"}) + return tmp20 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_print_DASH_tagged_DASH_object = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_print_DASH_tagged_DASH_object.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print-throwable + { + tmp0 := sym_print_DASH_throwable.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(478), kw_column, int(8), kw_end_DASH_line, int(478), kw_end_DASH_column, int(22), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_o, sym_w)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := lang.Apply(lang.WriteWriter, []any{v3, "#error {\n :cause "}) + _ = tmp4 + var tmp5 any + { // let + // let binding "map__944" + tmp6 := checkDerefVar(var_glojure_DOT_core_Throwable_DASH__GT_map) + tmp7 := lang.Apply(tmp6, []any{v2}) + var v8 any = tmp7 + _ = v8 + // let binding "map__944" + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp11 := lang.Apply(tmp10, []any{v8}) + if lang.IsTruthy(tmp11) { + var tmp12 any + tmp13 := checkDerefVar(var_glojure_DOT_core_next) + tmp14 := lang.Apply(tmp13, []any{v8}) + if lang.IsTruthy(tmp14) { + tmp15 := checkDerefVar(var_glojure_DOT_core_to_DASH_array) + tmp16 := lang.Apply(tmp15, []any{v8}) + tmp17 := lang.Apply(lang.NewPersistentArrayMapAsIfByAssoc, []any{tmp16}) + tmp12 = tmp17 + } else { + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_seq) + tmp20 := lang.Apply(tmp19, []any{v8}) + if lang.IsTruthy(tmp20) { + tmp21 := checkDerefVar(var_glojure_DOT_core_first) + tmp22 := lang.Apply(tmp21, []any{v8}) + tmp18 = tmp22 + } else { + } + tmp12 = tmp18 + } + tmp9 = tmp12 + } else { + tmp9 = v8 + } + var v23 any = tmp9 + _ = v23 + // let binding "cause" + tmp24 := checkDerefVar(var_glojure_DOT_core_get) + tmp25 := lang.Apply(tmp24, []any{v23, kw_cause}) + var v26 any = tmp25 + _ = v26 + // let binding "data" + tmp27 := checkDerefVar(var_glojure_DOT_core_get) + tmp28 := lang.Apply(tmp27, []any{v23, kw_data}) + var v29 any = tmp28 + _ = v29 + // let binding "via" + tmp30 := checkDerefVar(var_glojure_DOT_core_get) + tmp31 := lang.Apply(tmp30, []any{v23, kw_via}) + var v32 any = tmp31 + _ = v32 + // let binding "trace" + tmp33 := checkDerefVar(var_glojure_DOT_core_get) + tmp34 := lang.Apply(tmp33, []any{v23, kw_trace}) + var v35 any = tmp34 + _ = v35 + // let binding "print-via" + var tmp36 lang.FnFunc + tmp36 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v37 := args[0] + _ = v37 + tmp38 := lang.Apply(lang.WriteWriter, []any{v3, "{:type "}) + _ = tmp38 + tmp39 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp40 := lang.Apply(kw_type, []any{v37}) + tmp41 := lang.Apply(tmp39, []any{tmp40, v3}) + _ = tmp41 + tmp42 := lang.Apply(lang.WriteWriter, []any{v3, "\n :message "}) + _ = tmp42 + tmp43 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp44 := lang.Apply(kw_message, []any{v37}) + tmp45 := lang.Apply(tmp43, []any{tmp44, v3}) + _ = tmp45 + var tmp46 any + { // let + // let binding "temp__0__auto__" + tmp47 := lang.Apply(kw_data, []any{v37}) + var v48 any = tmp47 + _ = v48 + var tmp49 any + if lang.IsTruthy(v48) { + var tmp50 any + { // let + // let binding "data" + var v51 any = v48 + _ = v51 + tmp52 := lang.Apply(lang.WriteWriter, []any{v3, "\n :data "}) + _ = tmp52 + tmp53 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp54 := lang.Apply(tmp53, []any{v51, v3}) + tmp50 = tmp54 + } // end let + tmp49 = tmp50 + } else { + } + tmp46 = tmp49 + } // end let + _ = tmp46 + var tmp47 any + { // let + // let binding "temp__0__auto__" + tmp48 := lang.Apply(kw_at, []any{v37}) + var v49 any = tmp48 + _ = v49 + var tmp50 any + if lang.IsTruthy(v49) { + var tmp51 any + { // let + // let binding "at" + var v52 any = v49 + _ = v52 + tmp53 := lang.Apply(lang.WriteWriter, []any{v3, "\n :at "}) + _ = tmp53 + tmp54 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp55 := lang.Apply(kw_at, []any{v37}) + tmp56 := lang.Apply(tmp54, []any{tmp55, v3}) + tmp51 = tmp56 + } // end let + tmp50 = tmp51 + } else { + } + tmp47 = tmp50 + } // end let + _ = tmp47 + tmp48 := lang.Apply(lang.WriteWriter, []any{v3, "}"}) + return tmp48 + }) + tmp37 := lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(481), kw_column, int(19), kw_end_DASH_line, int(491), kw_end_DASH_column, int(73)) + tmp38, err := lang.WithMeta(tmp36, tmp37.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v39 any = tmp38 + _ = v39 + tmp40 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp41 := lang.Apply(tmp40, []any{v26, v3}) + _ = tmp41 + var tmp42 any + if lang.IsTruthy(v29) { + tmp43 := lang.Apply(lang.WriteWriter, []any{v3, "\n :data "}) + _ = tmp43 + tmp44 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp45 := lang.Apply(tmp44, []any{v29, v3}) + tmp42 = tmp45 + } else { + } + _ = tmp42 + var tmp46 any + if lang.IsTruthy(v32) { + tmp47 := lang.Apply(lang.WriteWriter, []any{v3, "\n :via\n ["}) + _ = tmp47 + var tmp48 any + { // let + // let binding "temp__0__auto__" + tmp49 := checkDerefVar(var_glojure_DOT_core_first) + tmp50 := lang.Apply(tmp49, []any{v32}) + var v51 any = tmp50 + _ = v51 + var tmp52 any + if lang.IsTruthy(v51) { + var tmp53 any + { // let + // let binding "fv" + var v54 any = v51 + _ = v54 + tmp55 := lang.Apply(v39, []any{v54}) + _ = tmp55 + var tmp56 any + { // let + // let binding "seq_945" + tmp57 := checkDerefVar(var_glojure_DOT_core_seq) + tmp58 := checkDerefVar(var_glojure_DOT_core_rest) + tmp59 := lang.Apply(tmp58, []any{v32}) + tmp60 := lang.Apply(tmp57, []any{tmp59}) + var v61 any = tmp60 + _ = v61 + // let binding "chunk_946" + var v62 any = nil + _ = v62 + // let binding "count_947" + var v63 any = int64(0) + _ = v63 + // let binding "i_948" + var v64 any = int64(0) + _ = v64 + for { + var tmp65 any + tmp66 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp67 := lang.Apply(tmp66, []any{v64, v63}) + if lang.IsTruthy(tmp67) { + var tmp68 any + { // let + // let binding "v" + tmp69, _ := lang.FieldOrMethod(v62, "nth") + if reflect.TypeOf(tmp69).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp70 := lang.Apply(tmp69, []any{v64}) + var v71 any = tmp70 + _ = v71 + tmp72 := lang.Apply(lang.WriteWriter, []any{v3, "\n "}) + _ = tmp72 + tmp73 := lang.Apply(v39, []any{v71}) + _ = tmp73 + var tmp74 any = v61 + var tmp75 any = v62 + var tmp76 any = v63 + tmp78 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp79 := lang.Apply(tmp78, []any{v64}) + var tmp77 any = tmp79 + v61 = tmp74 + v62 = tmp75 + v63 = tmp76 + v64 = tmp77 + continue + } // end let + tmp65 = tmp68 + } else { + var tmp69 any + { // let + // let binding "temp__0__auto__" + tmp70 := checkDerefVar(var_glojure_DOT_core_seq) + tmp71 := lang.Apply(tmp70, []any{v61}) + var v72 any = tmp71 + _ = v72 + var tmp73 any + if lang.IsTruthy(v72) { + var tmp74 any + { // let + // let binding "seq_945" + var v75 any = v72 + _ = v75 + var tmp76 any + tmp77 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp78 := lang.Apply(tmp77, []any{v75}) + if lang.IsTruthy(tmp78) { + var tmp79 any + { // let + // let binding "c__0__auto__" + tmp80 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp81 := lang.Apply(tmp80, []any{v75}) + var v82 any = tmp81 + _ = v82 + tmp84 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp85 := lang.Apply(tmp84, []any{v75}) + var tmp83 any = tmp85 + var tmp86 any = v82 + tmp88 := checkDerefVar(var_glojure_DOT_core_int) + tmp89 := checkDerefVar(var_glojure_DOT_core_count) + tmp90 := lang.Apply(tmp89, []any{v82}) + tmp91 := lang.Apply(tmp88, []any{tmp90}) + var tmp87 any = tmp91 + tmp93 := checkDerefVar(var_glojure_DOT_core_int) + tmp94 := lang.Apply(tmp93, []any{int64(0)}) + var tmp92 any = tmp94 + v61 = tmp83 + v62 = tmp86 + v63 = tmp87 + v64 = tmp92 + continue + } // end let + tmp76 = tmp79 + } else { + var tmp80 any + { // let + // let binding "v" + tmp81 := checkDerefVar(var_glojure_DOT_core_first) + tmp82 := lang.Apply(tmp81, []any{v75}) + var v83 any = tmp82 + _ = v83 + tmp84 := lang.Apply(lang.WriteWriter, []any{v3, "\n "}) + _ = tmp84 + tmp85 := lang.Apply(v39, []any{v83}) + _ = tmp85 + tmp87 := checkDerefVar(var_glojure_DOT_core_next) + tmp88 := lang.Apply(tmp87, []any{v75}) + var tmp86 any = tmp88 + var tmp89 any = nil + var tmp90 any = int64(0) + var tmp91 any = int64(0) + v61 = tmp86 + v62 = tmp89 + v63 = tmp90 + v64 = tmp91 + continue + } // end let + tmp76 = tmp80 + } + tmp74 = tmp76 + } // end let + tmp73 = tmp74 + } else { + } + tmp69 = tmp73 + } // end let + tmp65 = tmp69 + } + tmp56 = tmp65 + break + } + } // end let + tmp53 = tmp56 + } // end let + tmp52 = tmp53 + } else { + } + tmp48 = tmp52 + } // end let + _ = tmp48 + tmp49 := lang.Apply(lang.WriteWriter, []any{v3, "]"}) + tmp46 = tmp49 + } else { + } + _ = tmp46 + var tmp50 any + if lang.IsTruthy(v35) { + tmp51 := lang.Apply(lang.WriteWriter, []any{v3, "\n :trace\n ["}) + _ = tmp51 + var tmp52 any + { // let + // let binding "temp__0__auto__" + tmp53 := checkDerefVar(var_glojure_DOT_core_first) + tmp54 := lang.Apply(tmp53, []any{v35}) + var v55 any = tmp54 + _ = v55 + var tmp56 any + if lang.IsTruthy(v55) { + var tmp57 any + { // let + // let binding "ft" + var v58 any = v55 + _ = v58 + tmp59 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp60 := lang.Apply(tmp59, []any{v58, v3}) + _ = tmp60 + var tmp61 any + { // let + // let binding "seq_949" + tmp62 := checkDerefVar(var_glojure_DOT_core_seq) + tmp63 := checkDerefVar(var_glojure_DOT_core_rest) + tmp64 := lang.Apply(tmp63, []any{v35}) + tmp65 := lang.Apply(tmp62, []any{tmp64}) + var v66 any = tmp65 + _ = v66 + // let binding "chunk_950" + var v67 any = nil + _ = v67 + // let binding "count_951" + var v68 any = int64(0) + _ = v68 + // let binding "i_952" + var v69 any = int64(0) + _ = v69 + for { + var tmp70 any + tmp71 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp72 := lang.Apply(tmp71, []any{v69, v68}) + if lang.IsTruthy(tmp72) { + var tmp73 any + { // let + // let binding "t" + tmp74, _ := lang.FieldOrMethod(v67, "nth") + if reflect.TypeOf(tmp74).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp75 := lang.Apply(tmp74, []any{v69}) + var v76 any = tmp75 + _ = v76 + tmp77 := lang.Apply(lang.WriteWriter, []any{v3, "\n "}) + _ = tmp77 + tmp78 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp79 := lang.Apply(tmp78, []any{v76, v3}) + _ = tmp79 + var tmp80 any = v66 + var tmp81 any = v67 + var tmp82 any = v68 + tmp84 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp85 := lang.Apply(tmp84, []any{v69}) + var tmp83 any = tmp85 + v66 = tmp80 + v67 = tmp81 + v68 = tmp82 + v69 = tmp83 + continue + } // end let + tmp70 = tmp73 + } else { + var tmp74 any + { // let + // let binding "temp__0__auto__" + tmp75 := checkDerefVar(var_glojure_DOT_core_seq) + tmp76 := lang.Apply(tmp75, []any{v66}) + var v77 any = tmp76 + _ = v77 + var tmp78 any + if lang.IsTruthy(v77) { + var tmp79 any + { // let + // let binding "seq_949" + var v80 any = v77 + _ = v80 + var tmp81 any + tmp82 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp83 := lang.Apply(tmp82, []any{v80}) + if lang.IsTruthy(tmp83) { + var tmp84 any + { // let + // let binding "c__0__auto__" + tmp85 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp86 := lang.Apply(tmp85, []any{v80}) + var v87 any = tmp86 + _ = v87 + tmp89 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp90 := lang.Apply(tmp89, []any{v80}) + var tmp88 any = tmp90 + var tmp91 any = v87 + tmp93 := checkDerefVar(var_glojure_DOT_core_int) + tmp94 := checkDerefVar(var_glojure_DOT_core_count) + tmp95 := lang.Apply(tmp94, []any{v87}) + tmp96 := lang.Apply(tmp93, []any{tmp95}) + var tmp92 any = tmp96 + tmp98 := checkDerefVar(var_glojure_DOT_core_int) + tmp99 := lang.Apply(tmp98, []any{int64(0)}) + var tmp97 any = tmp99 + v66 = tmp88 + v67 = tmp91 + v68 = tmp92 + v69 = tmp97 + continue + } // end let + tmp81 = tmp84 + } else { + var tmp85 any + { // let + // let binding "t" + tmp86 := checkDerefVar(var_glojure_DOT_core_first) + tmp87 := lang.Apply(tmp86, []any{v80}) + var v88 any = tmp87 + _ = v88 + tmp89 := lang.Apply(lang.WriteWriter, []any{v3, "\n "}) + _ = tmp89 + tmp90 := checkDerefVar(var_glojure_DOT_core_print_DASH_method) + tmp91 := lang.Apply(tmp90, []any{v88, v3}) + _ = tmp91 + tmp93 := checkDerefVar(var_glojure_DOT_core_next) + tmp94 := lang.Apply(tmp93, []any{v80}) + var tmp92 any = tmp94 + var tmp95 any = nil + var tmp96 any = int64(0) + var tmp97 any = int64(0) + v66 = tmp92 + v67 = tmp95 + v68 = tmp96 + v69 = tmp97 + continue + } // end let + tmp81 = tmp85 + } + tmp79 = tmp81 + } // end let + tmp78 = tmp79 + } else { + } + tmp74 = tmp78 + } // end let + tmp70 = tmp74 + } + tmp61 = tmp70 + break + } + } // end let + tmp57 = tmp61 + } // end let + tmp56 = tmp57 + } else { + } + tmp52 = tmp56 + } // end let + _ = tmp52 + tmp53 := lang.Apply(lang.WriteWriter, []any{v3, "]"}) + tmp50 = tmp53 + } else { + } + tmp5 = tmp50 + } // end let + _ = tmp5 + tmp6 := lang.Apply(lang.WriteWriter, []any{v3, "}"}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_print_DASH_throwable = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_print_DASH_throwable.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // print-object + { + tmp0 := sym_print_DASH_object.WithMeta(lang.NewMap(kw_file, "glojure/core_print.glj", kw_line, int(115), kw_column, int(8), kw_end_DASH_line, int(115), kw_end_DASH_column, int(19), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_o, sym_w)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_print_DASH_tagged_DASH_object) + tmp5 := checkDerefVar(var_glojure_DOT_core_str) + tmp6 := lang.Apply(tmp5, []any{v2}) + tmp7 := lang.Apply(tmp4, []any{v2, tmp6, v3}) + return tmp7 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_print_DASH_object = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_print_DASH_object.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // read + { + tmp0 := sym_read.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_stream), lang.NewVector(sym_stream, sym_eof_DASH_error_QMARK_, sym_eof_DASH_value), lang.NewVector(sym_stream, sym_eof_DASH_error_QMARK_, sym_eof_DASH_value, sym_recursive_QMARK_), lang.NewVector(sym_opts, sym_stream)), kw_doc, "Reads the next object from stream, which must be an instance of\n java.io.PushbackReader or some derivee. stream defaults to the\n current value of *in*.\n\n Opts is a persistent map with valid keys:\n :read-cond - :allow to process reader conditionals, or\n :preserve to keep all branches\n :features - persistent set of feature keywords for reader conditionals\n :eof - on eof, return value unless :eofthrow, then throw.\n if not specified, will throw\n\n Note that read can execute code (controlled by *read-eval*),\n and as such should be used only with trusted sources.\n\n For data structure interop use glojure.edn/read", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(3742), kw_end_DASH_line, int(3742))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp2 := checkDerefVar(var_glojure_DOT_core_read) + tmp3 := checkDerefVar(var_glojure_DOT_core__STAR_in_STAR_) + tmp4 := lang.Apply(tmp2, []any{tmp3}) + return tmp4 + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_read) + tmp4 := lang.Apply(tmp3, []any{v2, true, nil}) + return tmp4 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_read) + tmp6 := lang.Apply(tmp5, []any{v2, v3, v4, false}) + return tmp6 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_boolean) + tmp7 := lang.Apply(tmp6, []any{v3}) + tmp8, _ := lang.FieldOrMethod(nil, "read") + if reflect.TypeOf(tmp8).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("read is not a function"))) + } + tmp9 := lang.Apply(tmp8, []any{v2, tmp7, v4, v5}) + return tmp9 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4, _ := lang.FieldOrMethod(nil, "read") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("read is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v3, v2}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_read = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_read.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // read-line + { + tmp0 := sym_read_DASH_line.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector()), kw_doc, "Reads the next line from stream that is the current value of *in* .", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(3797), kw_end_DASH_line, int(3797))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp2 any + tmp3 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp4 := checkDerefVar(var_glojure_DOT_core__STAR_in_STAR_) + tmp5 := lang.Apply(tmp3, []any{nil, tmp4}) + if lang.IsTruthy(tmp5) { + tmp6 := checkDerefVar(var_glojure_DOT_core__STAR_in_STAR_) + tmp7, ok := lang.FieldOrMethod(tmp6, "readLine") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp6, "readLine"))) + } + var tmp8 any + switch reflect.TypeOf(tmp7).Kind() { + case reflect.Func: + tmp8 = lang.Apply(tmp7, nil) + default: + tmp8 = tmp7 + } + tmp2 = tmp8 + } else { + tmp9 := checkDerefVar(var_glojure_DOT_core__STAR_in_STAR_) + tmp10, ok := lang.FieldOrMethod(tmp9, "readLine") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp9, "readLine"))) + } + var tmp11 any + switch reflect.TypeOf(tmp10).Kind() { + case reflect.Func: + tmp11 = lang.Apply(tmp10, nil) + default: + tmp11 = tmp10 + } + tmp2 = tmp11 + } + return tmp2 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_read_DASH_line = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_read_DASH_line.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // read+string + { + tmp0 := sym_read_PLUS_string.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(), lang.NewVector(sym_stream), lang.NewVector(sym_stream, sym_eof_DASH_error_QMARK_, sym_eof_DASH_value), lang.NewVector(sym_stream, sym_eof_DASH_error_QMARK_, sym_eof_DASH_value, sym_recursive_QMARK_), lang.NewVector(sym_opts, sym_stream)), kw_doc, "Like read, and taking the same args. stream must be a LineNumberingPushbackReader.\n Returns a vector containing the object read and the (whitespace-trimmed) string read.", kw_file, "glojure/core.glj", kw_added, "1.10", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(3771), kw_end_DASH_line, int(3771))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp2 := checkDerefVar(var_glojure_DOT_core_read_PLUS_string) + tmp3 := checkDerefVar(var_glojure_DOT_core__STAR_in_STAR_) + tmp4 := lang.Apply(tmp2, []any{tmp3}) + return tmp4 + case 1: + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_read_PLUS_string) + tmp4 := lang.Apply(tmp3, []any{v2, true, nil}) + return tmp4 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_read_PLUS_string) + tmp6 := lang.Apply(tmp5, []any{v2, v3, v4, false}) + return tmp6 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var tmp6 any + func() { + defer func() { + if r := recover(); r != nil { + if lang.CatchMatches(r, lang.Throwable) { + v7 := r + _ = v7 + tmp8, ok := lang.FieldOrMethod(v2, "getString") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getString"))) + } + var tmp9 any + switch reflect.TypeOf(tmp8).Kind() { + case reflect.Func: + tmp9 = lang.Apply(tmp8, nil) + default: + tmp9 = tmp8 + } + _ = tmp9 + panic(v7) + } else { + panic(r) + } + } + }() + tmp7, ok := lang.FieldOrMethod(v2, "captureString") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "captureString"))) + } + var tmp8 any + switch reflect.TypeOf(tmp7).Kind() { + case reflect.Func: + tmp8 = lang.Apply(tmp7, nil) + default: + tmp8 = tmp7 + } + _ = tmp8 + var tmp9 any + { // let + // let binding "o" + tmp10 := checkDerefVar(var_glojure_DOT_core_read) + tmp11 := lang.Apply(tmp10, []any{v2, v3, v4, v5}) + var v12 any = tmp11 + _ = v12 + // let binding "s" + tmp13, ok := lang.FieldOrMethod(v2, "getString") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getString"))) + } + var tmp14 any + switch reflect.TypeOf(tmp13).Kind() { + case reflect.Func: + tmp14 = lang.Apply(tmp13, nil) + default: + tmp14 = tmp13 + } + tmp15, ok := lang.FieldOrMethod(tmp14, "trim") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp14, "trim"))) + } + var tmp16 any + switch reflect.TypeOf(tmp15).Kind() { + case reflect.Func: + tmp16 = lang.Apply(tmp15, nil) + default: + tmp16 = tmp15 + } + var v17 any = tmp16 + _ = v17 + tmp18 := lang.NewVector(v12, v17) + tmp19 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3783), kw_column, int(8), kw_end_DASH_line, int(3783), kw_end_DASH_column, int(12)) + tmp20, err := lang.WithMeta(tmp18, tmp19.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp9 = tmp20 + } // end let + tmp6 = tmp9 + }() + return tmp6 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + func() { + defer func() { + if r := recover(); r != nil { + if lang.CatchMatches(r, lang.Throwable) { + v5 := r + _ = v5 + tmp6, ok := lang.FieldOrMethod(v3, "getString") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getString"))) + } + var tmp7 any + switch reflect.TypeOf(tmp6).Kind() { + case reflect.Func: + tmp7 = lang.Apply(tmp6, nil) + default: + tmp7 = tmp6 + } + _ = tmp7 + panic(v5) + } else { + panic(r) + } + } + }() + tmp5, ok := lang.FieldOrMethod(v3, "captureString") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "captureString"))) + } + var tmp6 any + switch reflect.TypeOf(tmp5).Kind() { + case reflect.Func: + tmp6 = lang.Apply(tmp5, nil) + default: + tmp6 = tmp5 + } + _ = tmp6 + var tmp7 any + { // let + // let binding "o" + tmp8 := checkDerefVar(var_glojure_DOT_core_read) + tmp9 := lang.Apply(tmp8, []any{v2, v3}) + var v10 any = tmp9 + _ = v10 + // let binding "s" + tmp11, ok := lang.FieldOrMethod(v3, "getString") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v3, "getString"))) + } + var tmp12 any + switch reflect.TypeOf(tmp11).Kind() { + case reflect.Func: + tmp12 = lang.Apply(tmp11, nil) + default: + tmp12 = tmp11 + } + tmp13, ok := lang.FieldOrMethod(tmp12, "trim") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", tmp12, "trim"))) + } + var tmp14 any + switch reflect.TypeOf(tmp13).Kind() { + case reflect.Func: + tmp14 = lang.Apply(tmp13, nil) + default: + tmp14 = tmp13 + } + var v15 any = tmp14 + _ = v15 + tmp16 := lang.NewVector(v10, v15) + tmp17 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3792), kw_column, int(8), kw_end_DASH_line, int(3792), kw_end_DASH_column, int(12)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp7 = tmp18 + } // end let + tmp4 = tmp7 + }() + return tmp4 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_read_PLUS_string = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_read_PLUS_string.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reduce + { + tmp0 := sym_reduce.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_coll), lang.NewVector(sym_f, sym_val, sym_coll)), kw_doc, "f should be a function of 2 arguments. If val is not supplied,\n returns the result of applying f to the first 2 items in coll, then\n applying f to that result and the 3rd item, etc. If coll contains no\n items, f must accept no arguments as well, and reduce returns the\n result of calling f with no arguments. If coll has only 1 item, it\n is returned and f is not called. If val is supplied, returns the\n result of applying f to val and the first item in coll, then\n applying f to that result and the 2nd item, etc. If coll contains no\n items, returns val and f is not called.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(12), kw_column, int(7), kw_line, int(6860), kw_end_DASH_line, int(6860))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + tmp5 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp6 := reflect.TypeOf((*lang.IReduce)(nil)).Elem() + tmp7 := lang.Apply(tmp5, []any{tmp6, v3}) + if lang.IsTruthy(tmp7) { + tmp8, _ := lang.FieldOrMethod(v3, "Reduce") + if reflect.TypeOf(tmp8).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Reduce is not a function"))) + } + tmp9 := lang.Apply(tmp8, []any{v2}) + tmp4 = tmp9 + } else { + tmp10 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_coll_DASH_reduce) + tmp11 := lang.Apply(tmp10, []any{v3, v2}) + tmp4 = tmp11 + } + return tmp4 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp7 := reflect.TypeOf((*lang.IReduceInit)(nil)).Elem() + tmp8 := lang.Apply(tmp6, []any{tmp7, v4}) + if lang.IsTruthy(tmp8) { + tmp9, _ := lang.FieldOrMethod(v4, "ReduceInit") + if reflect.TypeOf(tmp9).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) + } + tmp10 := lang.Apply(tmp9, []any{v2, v3}) + tmp5 = tmp10 + } else { + tmp11 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_coll_DASH_reduce) + tmp12 := lang.Apply(tmp11, []any{v4, v2, v3}) + tmp5 = tmp12 + } + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_reduce = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_reduce.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // run! + { + tmp0 := sym_run_BANG_.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_proc, sym_coll)), kw_doc, "Runs the supplied procedure (via reduce), for purposes of side\n effects, on successive items in the collection. Returns nil", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(7708), kw_end_DASH_line, int(7708))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_reduce) + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v6 := args[0] + _ = v6 + v7 := args[1] + _ = v7 + tmp8 := lang.Apply(v2, []any{v7}) + return tmp8 + }) + tmp6 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7713), kw_column, int(11), kw_end_DASH_line, int(7713), kw_end_DASH_column, int(20)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp8 := lang.Apply(tmp4, []any{tmp7, nil, v3}) + _ = tmp8 + return nil + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_run_BANG_ = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_run_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // reduce-kv + { + tmp0 := sym_reduce_DASH_kv.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_init, sym_coll)), kw_doc, "Reduces an associative collection. f should be a function of 3\n arguments. Returns the result of applying f to init, the first key\n and the first value in coll, then applying f to that result and the\n 2nd key and value, etc. If coll contains no entries, returns init\n and f is not called. Note that reduce-kv is supported on vectors,\n where the keys will be the ordinals.", kw_file, "glojure/core.glj", kw_added, "1.4", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(6882), kw_end_DASH_line, int(6882))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_kv_DASH_reduce) + tmp6 := lang.Apply(tmp5, []any{v4, v2, v3}) + return tmp6 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_reduce_DASH_kv = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_reduce_DASH_kv.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // update-keys + { + tmp0 := sym_update_DASH_keys.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m, sym_f)), kw_doc, "m f => {(f k) v ...}\n\n Given a map m and a function f of 1-argument, returns a new map whose\n keys are the result of applying f to the keys of m, mapped to the\n corresponding values of m.\n f must return a unique key for each key of m, else the behavior is undefined.", kw_file, "glojure/core.glj", kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(7906), kw_end_DASH_line, int(7906))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "ret" + tmp5 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp6 := checkDerefVar(var_glojure_DOT_core_reduce_DASH_kv) + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + v10 := args[2] + _ = v10 + tmp11 := checkDerefVar(var_glojure_DOT_core_assoc_BANG_) + tmp12 := lang.Apply(v3, []any{v9}) + tmp13 := lang.Apply(tmp11, []any{v8, tmp12, v10}) + return tmp13 + }) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7916), kw_column, int(25), kw_end_DASH_line, int(7916), kw_end_DASH_column, int(59)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp10 := checkDerefVar(var_glojure_DOT_core_transient) + tmp11 := lang.NewMap() + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7917), kw_column, int(36), kw_end_DASH_line, int(7917), kw_end_DASH_column, int(37)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp14 := lang.Apply(tmp10, []any{tmp13}) + tmp15 := lang.Apply(tmp6, []any{tmp9, tmp14, v2}) + tmp16 := lang.Apply(tmp5, []any{tmp15}) + var v17 any = tmp16 + _ = v17 + tmp18 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp19 := checkDerefVar(var_glojure_DOT_core_meta) + tmp20 := lang.Apply(tmp19, []any{v2}) + tmp21 := lang.Apply(tmp18, []any{v17, tmp20}) + tmp4 = tmp21 + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_update_DASH_keys = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_update_DASH_keys.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // update-vals + { + tmp0 := sym_update_DASH_vals.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m, sym_f)), kw_doc, "m f => {k (f v) ...}\n\n Given a map m and a function f of 1-argument, returns a new map where the keys of m\n are mapped to result of applying f to the corresponding values of m.", kw_file, "glojure/core.glj", kw_added, "1.11", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(7890), kw_end_DASH_line, int(7890))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp5 := checkDerefVar(var_glojure_DOT_core_persistent_BANG_) + tmp6 := checkDerefVar(var_glojure_DOT_core_reduce_DASH_kv) + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + v10 := args[2] + _ = v10 + tmp11 := checkDerefVar(var_glojure_DOT_core_assoc_BANG_) + tmp12 := lang.Apply(v3, []any{v10}) + tmp13 := lang.Apply(tmp11, []any{v8, v9, tmp12}) + return tmp13 + }) + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7899), kw_column, int(17), kw_end_DASH_line, int(7899), kw_end_DASH_column, int(51)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var tmp10 any + tmp11 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp12 := reflect.TypeOf((*lang.IEditableCollection)(nil)).Elem() + tmp13 := lang.Apply(tmp11, []any{tmp12, v2}) + if lang.IsTruthy(tmp13) { + tmp14 := checkDerefVar(var_glojure_DOT_core_transient) + tmp15 := lang.Apply(tmp14, []any{v2}) + tmp10 = tmp15 + } else { + tmp16 := checkDerefVar(var_glojure_DOT_core_transient) + tmp17 := lang.NewMap() + tmp18 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7902), kw_column, int(30), kw_end_DASH_line, int(7902), kw_end_DASH_column, int(31)) + tmp19, err := lang.WithMeta(tmp17, tmp18.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp20 := lang.Apply(tmp16, []any{tmp19}) + tmp10 = tmp20 + } + tmp21 := lang.Apply(tmp6, []any{tmp9, tmp10, v2}) + tmp22 := lang.Apply(tmp5, []any{tmp21}) + tmp23 := checkDerefVar(var_glojure_DOT_core_meta) + tmp24 := lang.Apply(tmp23, []any{v2}) + tmp25 := lang.Apply(tmp4, []any{tmp22, tmp24}) + return tmp25 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_update_DASH_vals = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_update_DASH_vals.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // slurp + { + tmp1 := reflect.TypeOf("") + tmp0 := sym_slurp.WithMeta(lang.NewMap(kw_tag, tmp1, kw_arglists, lang.NewList(lang.NewVector(sym_f, sym__AMP_, sym_opts)), kw_doc, "Opens a reader on f and reads all its contents, returning a string.\n See glojure.java.io/reader for a complete list of supported arguments.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(11), kw_column, int(7), kw_line, int(6982), kw_end_DASH_line, int(6982))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v3 := args[0] + _ = v3 + var v4 any = lang.NewList(args[1:]...) + _ = v4 + var tmp5 any + { // let + // let binding "opts" + tmp6 := checkDerefVar(var_glojure_DOT_core_normalize_DASH_slurp_DASH_opts) + tmp7 := lang.Apply(tmp6, []any{v4}) + var v8 any = tmp7 + _ = v8 + // let binding "sw" + var v9 any = "unimplemented: new with non-constant class type" + _ = v9 + var tmp10 any + { // let + // let binding "r" + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + tmp12 := checkDerefVar(var_glojure_DOT_go_DOT_io_reader) + tmp13 := lang.Apply(tmp11, []any{tmp12, v3, v8}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + func() { + defer func() { + tmp16, ok := lang.FieldOrMethod(v14, "close") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v14, "close"))) + } + var tmp17 any + switch reflect.TypeOf(tmp16).Kind() { + case reflect.Func: + tmp17 = lang.Apply(tmp16, nil) + default: + tmp17 = tmp16 + } + _ = tmp17 + }() + tmp18 := checkDerefVar(var_glojure_DOT_go_DOT_io_copy) + tmp19 := lang.Apply(tmp18, []any{v14, v9}) + _ = tmp19 + tmp20 := lang.Apply(lang.ToString, []any{v9}) + tmp15 = tmp20 + }() + tmp10 = tmp15 + } // end let + tmp5 = tmp10 + } // end let + return tmp5 + } + }) + tmp3 := reflect.TypeOf("") + tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, tmp3)).(lang.FnFunc) + var_glojure_DOT_core_slurp = ns.InternWithValue(tmp0, tmp2, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_slurp.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // transduce + { + tmp0 := sym_transduce.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_xform, sym_f, sym_coll), lang.NewVector(sym_xform, sym_f, sym_init, sym_coll)), kw_doc, "reduce with a transformation of f (xf). If init is not\n supplied, (f) will be called to produce it. f should be a reducing\n step function that accepts both 1 and 2 arguments, if it accepts\n only 2 you can add the arity-1 with 'completing'. Returns the result\n of applying (the transformed) xf to init and the first item in coll,\n then applying xf to that result and the 2nd item, etc. If coll\n contains no items, returns init and f is not called. Note that\n certain transforms may inject or skip items.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(6905), kw_end_DASH_line, int(6905))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_transduce) + tmp6 := lang.Apply(v3, nil) + tmp7 := lang.Apply(tmp5, []any{v2, v3, tmp6, v4}) + return tmp7 + case 4: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var tmp6 any + { // let + // let binding "f" + tmp7 := lang.Apply(v2, []any{v3}) + var v8 any = tmp7 + _ = v8 + // let binding "ret" + var tmp9 any + tmp10 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp11 := reflect.TypeOf((*lang.IReduceInit)(nil)).Elem() + tmp12 := lang.Apply(tmp10, []any{tmp11, v5}) + if lang.IsTruthy(tmp12) { + tmp13, _ := lang.FieldOrMethod(v5, "ReduceInit") + if reflect.TypeOf(tmp13).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) + } + tmp14 := lang.Apply(tmp13, []any{v8, v4}) + tmp9 = tmp14 + } else { + tmp15 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_coll_DASH_reduce) + tmp16 := lang.Apply(tmp15, []any{v5, v8, v4}) + tmp9 = tmp16 + } + var v17 any = tmp9 + _ = v17 + tmp18 := lang.Apply(v8, []any{v17}) + tmp6 = tmp18 + } // end let + return tmp6 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_transduce = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_transduce.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } +} diff --git a/pkg/stdlib/glojure/protocols/loader.go b/pkg/stdlib/glojure/protocols/loader.go new file mode 100644 index 00000000..2d6ae4e6 --- /dev/null +++ b/pkg/stdlib/glojure/protocols/loader.go @@ -0,0 +1,1382 @@ +// Code generated by glojure codegen. DO NOT EDIT. + +package protocols + +import ( + fmt "fmt" + lang "github.com/glojurelang/glojure/pkg/lang" + runtime "github.com/glojurelang/glojure/pkg/runtime" + reflect "reflect" +) + +func init() { + runtime.RegisterNSLoader("glojure/core/protocols", LoadNS) +} + +func checkDerefVar(v *lang.Var) any { + if v.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) + } + return v.Get() +} + +func checkArity(args []any, expected int) { + if len(args) != expected { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + +// LoadNS initializes the namespace "glojure.core.protocols" +func LoadNS() { + sym_CollReduce := lang.NewSymbol("CollReduce") + sym_Datafiable := lang.NewSymbol("Datafiable") + sym_IKVReduce := lang.NewSymbol("IKVReduce") + sym_InternalReduce := lang.NewSymbol("InternalReduce") + sym_Navigable := lang.NewSymbol("Navigable") + sym_amap := lang.NewSymbol("amap") + sym_apply := lang.NewSymbol("apply") + sym_chunk_DASH_first := lang.NewSymbol("chunk-first") + sym_chunk_DASH_next := lang.NewSymbol("chunk-next") + sym_chunked_DASH_seq_QMARK_ := lang.NewSymbol("chunked-seq?") + sym_class := lang.NewSymbol("class") + sym_coll := lang.NewSymbol("coll") + sym_coll_DASH_reduce := lang.NewSymbol("coll-reduce") + sym_cons := lang.NewSymbol("cons") + sym_datafy := lang.NewSymbol("datafy") + sym_deref := lang.NewSymbol("deref") + sym_f := lang.NewSymbol("f") + sym_first := lang.NewSymbol("first") + sym_global_DASH_hierarchy := lang.NewSymbol("global-hierarchy") + sym_glojure_DOT_core := lang.NewSymbol("glojure.core") + sym_glojure_DOT_core_DOT_protocols := lang.NewSymbol("glojure.core.protocols") + sym_identical_QMARK_ := lang.NewSymbol("identical?") + sym_init := lang.NewSymbol("init") + sym_instance_QMARK_ := lang.NewSymbol("instance?") + sym_interface_DASH_or_DASH_naive_DASH_reduce := lang.NewSymbol("interface-or-naive-reduce") + sym_internal_DASH_reduce := lang.NewSymbol("internal-reduce") + sym_iter_DASH_reduce := lang.NewSymbol("iter-reduce") + sym_k := lang.NewSymbol("k") + sym_kv_DASH_reduce := lang.NewSymbol("kv-reduce") + sym_naive_DASH_seq_DASH_reduce := lang.NewSymbol("naive-seq-reduce") + sym_nav := lang.NewSymbol("nav") + sym_next := lang.NewSymbol("next") + sym_o := lang.NewSymbol("o") + sym_reduced_QMARK_ := lang.NewSymbol("reduced?") + sym_s := lang.NewSymbol("s") + sym_seq := lang.NewSymbol("seq") + sym_seq_DASH_reduce := lang.NewSymbol("seq-reduce") + sym_start := lang.NewSymbol("start") + sym_v := lang.NewSymbol("v") + sym_val := lang.NewSymbol("val") + kw_arglists := lang.NewKeyword("arglists") + kw_coll_DASH_reduce := lang.NewKeyword("coll-reduce") + kw_column := lang.NewKeyword("column") + kw_datafy := lang.NewKeyword("datafy") + kw_default := lang.NewKeyword("default") + kw_doc := lang.NewKeyword("doc") + kw_end_DASH_column := lang.NewKeyword("end-column") + kw_end_DASH_line := lang.NewKeyword("end-line") + kw_file := lang.NewKeyword("file") + kw_internal_DASH_reduce := lang.NewKeyword("internal-reduce") + kw_kv_DASH_reduce := lang.NewKeyword("kv-reduce") + kw_line := lang.NewKeyword("line") + kw_multis := lang.NewKeyword("multis") + kw_nav := lang.NewKeyword("nav") + kw_ns := lang.NewKeyword("ns") + kw_on_DASH_interface := lang.NewKeyword("on-interface") + kw_private := lang.NewKeyword("private") + kw_rettag := lang.NewKeyword("rettag") + kw_sigs := lang.NewKeyword("sigs") + // var glojure.core.protocols/CollReduce + var_glojure_DOT_core_DOT_protocols_CollReduce := lang.InternVarName(sym_glojure_DOT_core_DOT_protocols, sym_CollReduce) + // var glojure.core.protocols/Datafiable + var_glojure_DOT_core_DOT_protocols_Datafiable := lang.InternVarName(sym_glojure_DOT_core_DOT_protocols, sym_Datafiable) + // var glojure.core.protocols/IKVReduce + var_glojure_DOT_core_DOT_protocols_IKVReduce := lang.InternVarName(sym_glojure_DOT_core_DOT_protocols, sym_IKVReduce) + // var glojure.core.protocols/InternalReduce + var_glojure_DOT_core_DOT_protocols_InternalReduce := lang.InternVarName(sym_glojure_DOT_core_DOT_protocols, sym_InternalReduce) + // var glojure.core.protocols/Navigable + var_glojure_DOT_core_DOT_protocols_Navigable := lang.InternVarName(sym_glojure_DOT_core_DOT_protocols, sym_Navigable) + // var glojure.core.protocols/coll-reduce + var_glojure_DOT_core_DOT_protocols_coll_DASH_reduce := lang.InternVarName(sym_glojure_DOT_core_DOT_protocols, sym_coll_DASH_reduce) + // var glojure.core.protocols/datafy + var_glojure_DOT_core_DOT_protocols_datafy := lang.InternVarName(sym_glojure_DOT_core_DOT_protocols, sym_datafy) + // var glojure.core.protocols/interface-or-naive-reduce + var_glojure_DOT_core_DOT_protocols_interface_DASH_or_DASH_naive_DASH_reduce := lang.InternVarName(sym_glojure_DOT_core_DOT_protocols, sym_interface_DASH_or_DASH_naive_DASH_reduce) + // var glojure.core.protocols/internal-reduce + var_glojure_DOT_core_DOT_protocols_internal_DASH_reduce := lang.InternVarName(sym_glojure_DOT_core_DOT_protocols, sym_internal_DASH_reduce) + // var glojure.core.protocols/iter-reduce + var_glojure_DOT_core_DOT_protocols_iter_DASH_reduce := lang.InternVarName(sym_glojure_DOT_core_DOT_protocols, sym_iter_DASH_reduce) + // var glojure.core.protocols/kv-reduce + var_glojure_DOT_core_DOT_protocols_kv_DASH_reduce := lang.InternVarName(sym_glojure_DOT_core_DOT_protocols, sym_kv_DASH_reduce) + // var glojure.core.protocols/naive-seq-reduce + var_glojure_DOT_core_DOT_protocols_naive_DASH_seq_DASH_reduce := lang.InternVarName(sym_glojure_DOT_core_DOT_protocols, sym_naive_DASH_seq_DASH_reduce) + // var glojure.core.protocols/nav + var_glojure_DOT_core_DOT_protocols_nav := lang.InternVarName(sym_glojure_DOT_core_DOT_protocols, sym_nav) + // var glojure.core.protocols/seq-reduce + var_glojure_DOT_core_DOT_protocols_seq_DASH_reduce := lang.InternVarName(sym_glojure_DOT_core_DOT_protocols, sym_seq_DASH_reduce) + // var glojure.core/apply + var_glojure_DOT_core_apply := lang.InternVarName(sym_glojure_DOT_core, sym_apply) + // var glojure.core/chunk-first + var_glojure_DOT_core_chunk_DASH_first := lang.InternVarName(sym_glojure_DOT_core, sym_chunk_DASH_first) + // var glojure.core/chunk-next + var_glojure_DOT_core_chunk_DASH_next := lang.InternVarName(sym_glojure_DOT_core, sym_chunk_DASH_next) + // var glojure.core/chunked-seq? + var_glojure_DOT_core_chunked_DASH_seq_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_chunked_DASH_seq_QMARK_) + // var glojure.core/class + var_glojure_DOT_core_class := lang.InternVarName(sym_glojure_DOT_core, sym_class) + // var glojure.core/cons + var_glojure_DOT_core_cons := lang.InternVarName(sym_glojure_DOT_core, sym_cons) + // var glojure.core/deref + var_glojure_DOT_core_deref := lang.InternVarName(sym_glojure_DOT_core, sym_deref) + // var glojure.core/first + var_glojure_DOT_core_first := lang.InternVarName(sym_glojure_DOT_core, sym_first) + // var glojure.core/identical? + var_glojure_DOT_core_identical_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_identical_QMARK_) + // var glojure.core/instance? + var_glojure_DOT_core_instance_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_instance_QMARK_) + // var glojure.core/next + var_glojure_DOT_core_next := lang.InternVarName(sym_glojure_DOT_core, sym_next) + // var glojure.core/reduced? + var_glojure_DOT_core_reduced_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_reduced_QMARK_) + // var glojure.core/seq + var_glojure_DOT_core_seq := lang.InternVarName(sym_glojure_DOT_core, sym_seq) + // reference fmt to avoid unused import error + _ = fmt.Printf + // reference reflect to avoid unused import error + _ = reflect.TypeOf + ns := lang.FindOrCreateNamespace(sym_glojure_DOT_core_DOT_protocols) + _ = ns + var closed0 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + tmp3 := lang.Apply(v2, nil) + return tmp3 + case 3: + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + v3 := args[2] + _ = v3 + return v3 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + closed0 = tmp0 + } + var closed1 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + tmp3, _ := lang.FieldOrMethod(v1, "Reduce") + if reflect.TypeOf(tmp3).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Reduce is not a function"))) + } + tmp4 := lang.Apply(tmp3, []any{v2}) + return tmp4 + case 3: + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + v3 := args[2] + _ = v3 + tmp4, _ := lang.FieldOrMethod(v1, "ReduceInit") + if reflect.TypeOf(tmp4).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) + } + tmp5 := lang.Apply(tmp4, []any{v2, v3}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + closed1 = tmp0 + } + var closed4 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v1 := args[0] + _ = v1 + return nil + }) + closed4 = tmp0 + } + var closed5 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + v3 := args[2] + _ = v3 + return v3 + }) + closed5 = tmp0 + } + var closed2 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_seq_DASH_reduce) + tmp4 := lang.Apply(tmp3, []any{v1, v2}) + return tmp4 + case 3: + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + v3 := args[2] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_seq_DASH_reduce) + tmp5 := lang.Apply(tmp4, []any{v1, v2, v3}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + closed2 = tmp0 + } + var closed3 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_seq_DASH_reduce) + tmp4 := lang.Apply(tmp3, []any{v1, v2}) + return tmp4 + case 3: + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + v3 := args[2] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_seq_DASH_reduce) + tmp5 := lang.Apply(tmp4, []any{v1, v2, v3}) + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + closed3 = tmp0 + } + var closed6 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + v3 := args[2] + _ = v3 + recur_loop_1560: + var tmp4 any + { // let + // let binding "temp__0__auto__" + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := lang.Apply(tmp5, []any{v1}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + if lang.IsTruthy(v7) { + var tmp9 any + { // let + // let binding "s" + var v10 any = v7 + _ = v10 + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp13 := lang.Apply(tmp12, []any{v10}) + if lang.IsTruthy(tmp13) { + var tmp14 any + { // let + // let binding "ret" + tmp15 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp16 := lang.Apply(tmp15, []any{v10}) + tmp17, _ := lang.FieldOrMethod(tmp16, "ReduceInit") + if reflect.TypeOf(tmp17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) + } + tmp18 := lang.Apply(tmp17, []any{v2, v3}) + var v19 any = tmp18 + _ = v19 + var tmp20 any + tmp21 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) + tmp22 := lang.Apply(tmp21, []any{v19}) + if lang.IsTruthy(tmp22) { + tmp23 := checkDerefVar(var_glojure_DOT_core_deref) + tmp24 := lang.Apply(tmp23, []any{v19}) + tmp20 = tmp24 + } else { + tmp26 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_next) + tmp27 := lang.Apply(tmp26, []any{v10}) + var tmp25 any = tmp27 + var tmp28 any = v2 + var tmp29 any = v19 + v1 = tmp25 + v2 = tmp28 + v3 = tmp29 + goto recur_loop_1560 + } + tmp14 = tmp20 + } // end let + tmp11 = tmp14 + } else { + tmp15 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_interface_DASH_or_DASH_naive_DASH_reduce) + tmp16 := lang.Apply(tmp15, []any{v10, v2, v3}) + tmp11 = tmp16 + } + tmp9 = tmp11 + } // end let + tmp8 = tmp9 + } else { + tmp8 = v3 + } + tmp4 = tmp8 + } // end let + return tmp4 + }) + closed6 = tmp0 + } + var closed7 any + { + var tmp0 lang.FnFunc + tmp0 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v1 := args[0] + _ = v1 + v2 := args[1] + _ = v2 + v3 := args[2] + _ = v3 + var tmp4 any + { // let + // let binding "cls" + tmp5 := checkDerefVar(var_glojure_DOT_core_class) + tmp6 := lang.Apply(tmp5, []any{v1}) + var v7 any = tmp6 + _ = v7 + // let binding "s" + var v8 any = v1 + _ = v8 + // let binding "f" + var v9 any = v2 + _ = v9 + // let binding "val" + var v10 any = v3 + _ = v10 + for { + var tmp11 any + { // let + // let binding "temp__0__auto__" + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := lang.Apply(tmp12, []any{v8}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + var tmp16 any + { // let + // let binding "s" + var v17 any = v14 + _ = v17 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_identical_QMARK_) + tmp20 := checkDerefVar(var_glojure_DOT_core_class) + tmp21 := lang.Apply(tmp20, []any{v17}) + tmp22 := lang.Apply(tmp19, []any{tmp21, v7}) + if lang.IsTruthy(tmp22) { + var tmp23 any + { // let + // let binding "ret" + tmp24 := checkDerefVar(var_glojure_DOT_core_first) + tmp25 := lang.Apply(tmp24, []any{v17}) + tmp26 := lang.Apply(v9, []any{v10, tmp25}) + var v27 any = tmp26 + _ = v27 + var tmp28 any + tmp29 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) + tmp30 := lang.Apply(tmp29, []any{v27}) + if lang.IsTruthy(tmp30) { + tmp31 := checkDerefVar(var_glojure_DOT_core_deref) + tmp32 := lang.Apply(tmp31, []any{v27}) + tmp28 = tmp32 + } else { + var tmp33 any = v7 + tmp35 := checkDerefVar(var_glojure_DOT_core_next) + tmp36 := lang.Apply(tmp35, []any{v17}) + var tmp34 any = tmp36 + var tmp37 any = v9 + var tmp38 any = v27 + v7 = tmp33 + v8 = tmp34 + v9 = tmp37 + v10 = tmp38 + continue + } + tmp23 = tmp28 + } // end let + tmp18 = tmp23 + } else { + tmp24 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_interface_DASH_or_DASH_naive_DASH_reduce) + tmp25 := lang.Apply(tmp24, []any{v17, v9, v10}) + tmp18 = tmp25 + } + tmp16 = tmp18 + } // end let + tmp15 = tmp16 + } else { + tmp15 = v10 + } + tmp11 = tmp15 + } // end let + tmp4 = tmp11 + break + } + } // end let + return tmp4 + }) + closed7 = tmp0 + } + // CollReduce + { + tmp0 := sym_CollReduce.WithMeta(lang.NewMap(kw_file, "glojure/protocols.glj", kw_line, int(13), kw_column, int(14), kw_end_DASH_line, int(13), kw_end_DASH_column, int(23), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core_DOT_protocols))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v4 := args[0] + _ = v4 + var v5 any = lang.NewList(args[1:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_class) + tmp7 := lang.Apply(tmp6, []any{v4}) + return tmp7 + } + }) + tmp2 := lang.NewMultiFn("coll-reduce", tmp3, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v5 := args[0] + _ = v5 + var v6 any = lang.NewList(args[1:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_apply) + tmp8 := checkDerefVar(var_glojure_DOT_core_cons) + tmp9 := lang.Apply(tmp8, []any{v5, v6}) + tmp10 := lang.Apply(tmp7, []any{closed0, tmp9}) + return tmp10 + } + }) + tmp2.AddMethod(nil, tmp4) + tmp5 := reflect.TypeOf((*lang.IReduceInit)(nil)).Elem() + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v7 := args[0] + _ = v7 + var v8 any = lang.NewList(args[1:]...) + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_apply) + tmp10 := checkDerefVar(var_glojure_DOT_core_cons) + tmp11 := lang.Apply(tmp10, []any{v7, v8}) + tmp12 := lang.Apply(tmp9, []any{closed1, tmp11}) + return tmp12 + } + }) + tmp2.AddMethod(tmp5, tmp6) + tmp7 := reflect.TypeOf((*lang.LazySeq)(nil)) + var tmp8 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v9 := args[0] + _ = v9 + var v10 any = lang.NewList(args[1:]...) + _ = v10 + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + tmp12 := checkDerefVar(var_glojure_DOT_core_cons) + tmp13 := lang.Apply(tmp12, []any{v9, v10}) + tmp14 := lang.Apply(tmp11, []any{closed2, tmp13}) + return tmp14 + } + }) + tmp2.AddMethod(tmp7, tmp8) + tmp9 := reflect.TypeOf((*lang.Vector)(nil)) + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v11 := args[0] + _ = v11 + var v12 any = lang.NewList(args[1:]...) + _ = v12 + tmp13 := checkDerefVar(var_glojure_DOT_core_apply) + tmp14 := checkDerefVar(var_glojure_DOT_core_cons) + tmp15 := lang.Apply(tmp14, []any{v11, v12}) + tmp16 := lang.Apply(tmp13, []any{closed3, tmp15}) + return tmp16 + } + }) + tmp2.AddMethod(tmp9, tmp10) + tmp1 := lang.NewAtom(lang.NewMap(kw_multis, lang.NewMap(kw_coll_DASH_reduce, tmp2), kw_on_DASH_interface, true, kw_sigs, lang.NewList(lang.NewList(sym_coll_DASH_reduce, lang.NewVector(sym_coll, sym_f), lang.NewVector(sym_coll, sym_f, sym_val))))) + var_glojure_DOT_core_DOT_protocols_CollReduce = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_DOT_protocols_CollReduce.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // Datafiable + { + tmp0 := sym_Datafiable.WithMeta(lang.NewMap(kw_file, "glojure/protocols.glj", kw_line, int(183), kw_column, int(14), kw_end_DASH_line, int(183), kw_end_DASH_column, int(23), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core_DOT_protocols))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v4 := args[0] + _ = v4 + var v5 any = lang.NewList(args[1:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_class) + tmp7 := lang.Apply(tmp6, []any{v4}) + return tmp7 + } + }) + tmp2 := lang.NewMultiFn("datafy", tmp3, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v5 := args[0] + _ = v5 + var v6 any = lang.NewList(args[1:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_apply) + tmp8 := checkDerefVar(var_glojure_DOT_core_cons) + tmp9 := lang.Apply(tmp8, []any{v5, v6}) + tmp10 := lang.Apply(tmp7, []any{closed4, tmp9}) + return tmp10 + } + }) + tmp2.AddMethod(nil, tmp4) + tmp1 := lang.NewAtom(lang.NewMap(kw_multis, lang.NewMap(kw_datafy, tmp2), kw_on_DASH_interface, true, kw_sigs, lang.NewList(lang.NewList(sym_datafy, lang.NewVector(sym_o), "return a representation of o as data (default identity)")))) + var_glojure_DOT_core_DOT_protocols_Datafiable = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_DOT_protocols_Datafiable.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // IKVReduce + { + tmp0 := sym_IKVReduce.WithMeta(lang.NewMap(kw_file, "glojure/protocols.glj", kw_line, int(176), kw_column, int(14), kw_end_DASH_line, int(176), kw_end_DASH_column, int(22), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core_DOT_protocols))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v4 := args[0] + _ = v4 + var v5 any = lang.NewList(args[1:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_class) + tmp7 := lang.Apply(tmp6, []any{v4}) + return tmp7 + } + }) + tmp2 := lang.NewMultiFn("kv-reduce", tmp3, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) + tmp1 := lang.NewAtom(lang.NewMap(kw_multis, lang.NewMap(kw_kv_DASH_reduce, tmp2), kw_on_DASH_interface, true, kw_sigs, lang.NewList(lang.NewList(sym_kv_DASH_reduce, lang.NewVector(sym_amap, sym_f, sym_init))))) + var_glojure_DOT_core_DOT_protocols_IKVReduce = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_DOT_protocols_IKVReduce.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // InternalReduce + { + tmp0 := sym_InternalReduce.WithMeta(lang.NewMap(kw_file, "glojure/protocols.glj", kw_line, int(19), kw_column, int(14), kw_end_DASH_line, int(19), kw_end_DASH_column, int(27), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core_DOT_protocols))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v4 := args[0] + _ = v4 + var v5 any = lang.NewList(args[1:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_class) + tmp7 := lang.Apply(tmp6, []any{v4}) + return tmp7 + } + }) + tmp2 := lang.NewMultiFn("internal-reduce", tmp3, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v5 := args[0] + _ = v5 + var v6 any = lang.NewList(args[1:]...) + _ = v6 + tmp7 := checkDerefVar(var_glojure_DOT_core_apply) + tmp8 := checkDerefVar(var_glojure_DOT_core_cons) + tmp9 := lang.Apply(tmp8, []any{v5, v6}) + tmp10 := lang.Apply(tmp7, []any{closed5, tmp9}) + return tmp10 + } + }) + tmp2.AddMethod(nil, tmp4) + tmp5 := reflect.TypeOf((*lang.IChunkedSeq)(nil)).Elem() + var tmp6 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v7 := args[0] + _ = v7 + var v8 any = lang.NewList(args[1:]...) + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_apply) + tmp10 := checkDerefVar(var_glojure_DOT_core_cons) + tmp11 := lang.Apply(tmp10, []any{v7, v8}) + tmp12 := lang.Apply(tmp9, []any{closed6, tmp11}) + return tmp12 + } + }) + tmp2.AddMethod(tmp5, tmp6) + tmp7 := reflect.TypeOf((*lang.Object)(nil)).Elem() + var tmp8 lang.FnFunc + tmp8 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v9 := args[0] + _ = v9 + var v10 any = lang.NewList(args[1:]...) + _ = v10 + tmp11 := checkDerefVar(var_glojure_DOT_core_apply) + tmp12 := checkDerefVar(var_glojure_DOT_core_cons) + tmp13 := lang.Apply(tmp12, []any{v9, v10}) + tmp14 := lang.Apply(tmp11, []any{closed7, tmp13}) + return tmp14 + } + }) + tmp2.AddMethod(tmp7, tmp8) + tmp1 := lang.NewAtom(lang.NewMap(kw_multis, lang.NewMap(kw_internal_DASH_reduce, tmp2), kw_on_DASH_interface, true, kw_sigs, lang.NewList(lang.NewList(sym_internal_DASH_reduce, lang.NewVector(sym_seq, sym_f, sym_start))))) + var_glojure_DOT_core_DOT_protocols_InternalReduce = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_DOT_protocols_InternalReduce.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // Navigable + { + tmp0 := sym_Navigable.WithMeta(lang.NewMap(kw_file, "glojure/protocols.glj", kw_line, int(195), kw_column, int(14), kw_end_DASH_line, int(195), kw_end_DASH_column, int(22), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core_DOT_protocols))).(*lang.Symbol) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v4 := args[0] + _ = v4 + var v5 any = lang.NewList(args[1:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_class) + tmp7 := lang.Apply(tmp6, []any{v4}) + return tmp7 + } + }) + tmp2 := lang.NewMultiFn("nav", tmp3, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) + tmp1 := lang.NewAtom(lang.NewMap(kw_multis, lang.NewMap(kw_nav, tmp2), kw_on_DASH_interface, true, kw_sigs, lang.NewList(lang.NewList(sym_nav, lang.NewVector(sym_coll, sym_k, sym_v), "return (possibly transformed) v in the context of coll and k (a key/index or nil),\ndefaults to returning v.")))) + var_glojure_DOT_core_DOT_protocols_Navigable = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_DOT_protocols_Navigable.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // coll-reduce + { + tmp0 := sym_coll_DASH_reduce.WithMeta(lang.NewMap(kw_file, "glojure/protocols.glj", kw_line, int(17), kw_column, int(4), kw_end_DASH_line, int(17), kw_end_DASH_column, int(14), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core_DOT_protocols))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v3 := args[0] + _ = v3 + var v4 any = lang.NewList(args[1:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_class) + tmp6 := lang.Apply(tmp5, []any{v3}) + return tmp6 + } + }) + tmp1 := lang.NewMultiFn("coll-reduce", tmp2, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v4 := args[0] + _ = v4 + var v5 any = lang.NewList(args[1:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_cons) + tmp8 := lang.Apply(tmp7, []any{v4, v5}) + tmp9 := lang.Apply(tmp6, []any{closed0, tmp8}) + return tmp9 + } + }) + tmp1.AddMethod(nil, tmp3) + tmp4 := reflect.TypeOf((*lang.IReduceInit)(nil)).Elem() + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v6 := args[0] + _ = v6 + var v7 any = lang.NewList(args[1:]...) + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_apply) + tmp9 := checkDerefVar(var_glojure_DOT_core_cons) + tmp10 := lang.Apply(tmp9, []any{v6, v7}) + tmp11 := lang.Apply(tmp8, []any{closed1, tmp10}) + return tmp11 + } + }) + tmp1.AddMethod(tmp4, tmp5) + tmp6 := reflect.TypeOf((*lang.LazySeq)(nil)) + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v8 := args[0] + _ = v8 + var v9 any = lang.NewList(args[1:]...) + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_apply) + tmp11 := checkDerefVar(var_glojure_DOT_core_cons) + tmp12 := lang.Apply(tmp11, []any{v8, v9}) + tmp13 := lang.Apply(tmp10, []any{closed2, tmp12}) + return tmp13 + } + }) + tmp1.AddMethod(tmp6, tmp7) + tmp8 := reflect.TypeOf((*lang.Vector)(nil)) + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v10 := args[0] + _ = v10 + var v11 any = lang.NewList(args[1:]...) + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_apply) + tmp13 := checkDerefVar(var_glojure_DOT_core_cons) + tmp14 := lang.Apply(tmp13, []any{v10, v11}) + tmp15 := lang.Apply(tmp12, []any{closed3, tmp14}) + return tmp15 + } + }) + tmp1.AddMethod(tmp8, tmp9) + var_glojure_DOT_core_DOT_protocols_coll_DASH_reduce = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_DOT_protocols_coll_DASH_reduce.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // datafy + { + tmp0 := sym_datafy.WithMeta(lang.NewMap(kw_file, "glojure/protocols.glj", kw_line, int(186), kw_column, int(4), kw_end_DASH_line, int(186), kw_end_DASH_column, int(9), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core_DOT_protocols))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v3 := args[0] + _ = v3 + var v4 any = lang.NewList(args[1:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_class) + tmp6 := lang.Apply(tmp5, []any{v3}) + return tmp6 + } + }) + tmp1 := lang.NewMultiFn("datafy", tmp2, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v4 := args[0] + _ = v4 + var v5 any = lang.NewList(args[1:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_cons) + tmp8 := lang.Apply(tmp7, []any{v4, v5}) + tmp9 := lang.Apply(tmp6, []any{closed4, tmp8}) + return tmp9 + } + }) + tmp1.AddMethod(nil, tmp3) + var_glojure_DOT_core_DOT_protocols_datafy = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_DOT_protocols_datafy.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // interface-or-naive-reduce + { + tmp0 := sym_interface_DASH_or_DASH_naive_DASH_reduce.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_coll, sym_f, sym_val)), kw_doc, "Reduces via IReduceInit if possible, else naively.", kw_file, "glojure/protocols.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core_DOT_protocols), kw_end_DASH_column, int(32), kw_column, int(8), kw_line, int(68), kw_end_DASH_line, int(68), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp7 := reflect.TypeOf((*lang.IReduceInit)(nil)).Elem() + tmp8 := lang.Apply(tmp6, []any{tmp7, v2}) + if lang.IsTruthy(tmp8) { + tmp9, _ := lang.FieldOrMethod(v2, "ReduceInit") + if reflect.TypeOf(tmp9).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ReduceInit is not a function"))) + } + tmp10 := lang.Apply(tmp9, []any{v3, v4}) + tmp5 = tmp10 + } else { + tmp11 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_naive_DASH_seq_DASH_reduce) + tmp12 := lang.Apply(tmp11, []any{v2, v3, v4}) + tmp5 = tmp12 + } + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_DOT_protocols_interface_DASH_or_DASH_naive_DASH_reduce = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_DOT_protocols_interface_DASH_or_DASH_naive_DASH_reduce.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // internal-reduce + { + tmp0 := sym_internal_DASH_reduce.WithMeta(lang.NewMap(kw_file, "glojure/protocols.glj", kw_line, int(22), kw_column, int(4), kw_end_DASH_line, int(22), kw_end_DASH_column, int(18), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core_DOT_protocols))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v3 := args[0] + _ = v3 + var v4 any = lang.NewList(args[1:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_class) + tmp6 := lang.Apply(tmp5, []any{v3}) + return tmp6 + } + }) + tmp1 := lang.NewMultiFn("internal-reduce", tmp2, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v4 := args[0] + _ = v4 + var v5 any = lang.NewList(args[1:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_apply) + tmp7 := checkDerefVar(var_glojure_DOT_core_cons) + tmp8 := lang.Apply(tmp7, []any{v4, v5}) + tmp9 := lang.Apply(tmp6, []any{closed5, tmp8}) + return tmp9 + } + }) + tmp1.AddMethod(nil, tmp3) + tmp4 := reflect.TypeOf((*lang.IChunkedSeq)(nil)).Elem() + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v6 := args[0] + _ = v6 + var v7 any = lang.NewList(args[1:]...) + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_core_apply) + tmp9 := checkDerefVar(var_glojure_DOT_core_cons) + tmp10 := lang.Apply(tmp9, []any{v6, v7}) + tmp11 := lang.Apply(tmp8, []any{closed6, tmp10}) + return tmp11 + } + }) + tmp1.AddMethod(tmp4, tmp5) + tmp6 := reflect.TypeOf((*lang.Object)(nil)).Elem() + var tmp7 lang.FnFunc + tmp7 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v8 := args[0] + _ = v8 + var v9 any = lang.NewList(args[1:]...) + _ = v9 + tmp10 := checkDerefVar(var_glojure_DOT_core_apply) + tmp11 := checkDerefVar(var_glojure_DOT_core_cons) + tmp12 := lang.Apply(tmp11, []any{v8, v9}) + tmp13 := lang.Apply(tmp10, []any{closed7, tmp12}) + return tmp13 + } + }) + tmp1.AddMethod(tmp6, tmp7) + var_glojure_DOT_core_DOT_protocols_internal_DASH_reduce = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_DOT_protocols_internal_DASH_reduce.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // iter-reduce + { + tmp0 := sym_iter_DASH_reduce.WithMeta(lang.NewMap(kw_file, "glojure/protocols.glj", kw_line, int(33), kw_column, int(8), kw_end_DASH_line, int(33), kw_end_DASH_column, int(18), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_coll, sym_f), lang.NewVector(sym_coll, sym_f, sym_val)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core_DOT_protocols))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "iter" + tmp5, ok := lang.FieldOrMethod(v2, "iterator") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "iterator"))) + } + var tmp6 any + switch reflect.TypeOf(tmp5).Kind() { + case reflect.Func: + tmp6 = lang.Apply(tmp5, nil) + default: + tmp6 = tmp5 + } + var v7 any = tmp6 + _ = v7 + var tmp8 any + tmp9, ok := lang.FieldOrMethod(v7, "hasNext") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "hasNext"))) + } + var tmp10 any + switch reflect.TypeOf(tmp9).Kind() { + case reflect.Func: + tmp10 = lang.Apply(tmp9, nil) + default: + tmp10 = tmp9 + } + if lang.IsTruthy(tmp10) { + var tmp11 any + { // let + // let binding "ret" + tmp12, ok := lang.FieldOrMethod(v7, "next") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "next"))) + } + var tmp13 any + switch reflect.TypeOf(tmp12).Kind() { + case reflect.Func: + tmp13 = lang.Apply(tmp12, nil) + default: + tmp13 = tmp12 + } + var v14 any = tmp13 + _ = v14 + for { + var tmp15 any + tmp16, ok := lang.FieldOrMethod(v7, "hasNext") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "hasNext"))) + } + var tmp17 any + switch reflect.TypeOf(tmp16).Kind() { + case reflect.Func: + tmp17 = lang.Apply(tmp16, nil) + default: + tmp17 = tmp16 + } + if lang.IsTruthy(tmp17) { + var tmp18 any + { // let + // let binding "ret" + tmp19, ok := lang.FieldOrMethod(v7, "next") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "next"))) + } + var tmp20 any + switch reflect.TypeOf(tmp19).Kind() { + case reflect.Func: + tmp20 = lang.Apply(tmp19, nil) + default: + tmp20 = tmp19 + } + tmp21 := lang.Apply(v3, []any{v14, tmp20}) + var v22 any = tmp21 + _ = v22 + var tmp23 any + tmp24 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) + tmp25 := lang.Apply(tmp24, []any{v22}) + if lang.IsTruthy(tmp25) { + tmp26 := checkDerefVar(var_glojure_DOT_core_deref) + tmp27 := lang.Apply(tmp26, []any{v22}) + tmp23 = tmp27 + } else { + var tmp28 any = v22 + v14 = tmp28 + continue + } + tmp18 = tmp23 + } // end let + tmp15 = tmp18 + } else { + tmp15 = v14 + } + tmp11 = tmp15 + break + } + } // end let + tmp8 = tmp11 + } else { + tmp12 := lang.Apply(v3, nil) + tmp8 = tmp12 + } + tmp4 = tmp8 + } // end let + return tmp4 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + { // let + // let binding "iter" + tmp6, ok := lang.FieldOrMethod(v2, "iterator") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "iterator"))) + } + var tmp7 any + switch reflect.TypeOf(tmp6).Kind() { + case reflect.Func: + tmp7 = lang.Apply(tmp6, nil) + default: + tmp7 = tmp6 + } + var v8 any = tmp7 + _ = v8 + var tmp9 any + { // let + // let binding "ret" + var v10 any = v4 + _ = v10 + for { + var tmp11 any + tmp12, ok := lang.FieldOrMethod(v8, "hasNext") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "hasNext"))) + } + var tmp13 any + switch reflect.TypeOf(tmp12).Kind() { + case reflect.Func: + tmp13 = lang.Apply(tmp12, nil) + default: + tmp13 = tmp12 + } + if lang.IsTruthy(tmp13) { + var tmp14 any + { // let + // let binding "ret" + tmp15, ok := lang.FieldOrMethod(v8, "next") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "next"))) + } + var tmp16 any + switch reflect.TypeOf(tmp15).Kind() { + case reflect.Func: + tmp16 = lang.Apply(tmp15, nil) + default: + tmp16 = tmp15 + } + tmp17 := lang.Apply(v3, []any{v10, tmp16}) + var v18 any = tmp17 + _ = v18 + var tmp19 any + tmp20 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) + tmp21 := lang.Apply(tmp20, []any{v18}) + if lang.IsTruthy(tmp21) { + tmp22 := checkDerefVar(var_glojure_DOT_core_deref) + tmp23 := lang.Apply(tmp22, []any{v18}) + tmp19 = tmp23 + } else { + var tmp24 any = v18 + v10 = tmp24 + continue + } + tmp14 = tmp19 + } // end let + tmp11 = tmp14 + } else { + tmp11 = v10 + } + tmp9 = tmp11 + break + } + } // end let + tmp5 = tmp9 + } // end let + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_DOT_protocols_iter_DASH_reduce = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_DOT_protocols_iter_DASH_reduce.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // kv-reduce + { + tmp0 := sym_kv_DASH_reduce.WithMeta(lang.NewMap(kw_file, "glojure/protocols.glj", kw_line, int(181), kw_column, int(4), kw_end_DASH_line, int(181), kw_end_DASH_column, int(12), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core_DOT_protocols))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v3 := args[0] + _ = v3 + var v4 any = lang.NewList(args[1:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_class) + tmp6 := lang.Apply(tmp5, []any{v3}) + return tmp6 + } + }) + tmp1 := lang.NewMultiFn("kv-reduce", tmp2, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) + var_glojure_DOT_core_DOT_protocols_kv_DASH_reduce = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_DOT_protocols_kv_DASH_reduce.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // naive-seq-reduce + { + tmp0 := sym_naive_DASH_seq_DASH_reduce.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_s, sym_f, sym_val)), kw_doc, "Reduces a seq, ignoring any opportunities to switch to a more\n specialized implementation.", kw_file, "glojure/protocols.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core_DOT_protocols), kw_end_DASH_column, int(23), kw_column, int(8), kw_line, int(55), kw_end_DASH_line, int(55), kw_private, true)).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + { // let + // let binding "s" + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := lang.Apply(tmp6, []any{v2}) + var v8 any = tmp7 + _ = v8 + // let binding "val" + var v9 any = v4 + _ = v9 + for { + var tmp10 any + if lang.IsTruthy(v8) { + var tmp11 any + { // let + // let binding "ret" + tmp12 := checkDerefVar(var_glojure_DOT_core_first) + tmp13 := lang.Apply(tmp12, []any{v8}) + tmp14 := lang.Apply(v3, []any{v9, tmp13}) + var v15 any = tmp14 + _ = v15 + var tmp16 any + tmp17 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) + tmp18 := lang.Apply(tmp17, []any{v15}) + if lang.IsTruthy(tmp18) { + tmp19 := checkDerefVar(var_glojure_DOT_core_deref) + tmp20 := lang.Apply(tmp19, []any{v15}) + tmp16 = tmp20 + } else { + tmp22 := checkDerefVar(var_glojure_DOT_core_next) + tmp23 := lang.Apply(tmp22, []any{v8}) + var tmp21 any = tmp23 + var tmp24 any = v15 + v8 = tmp21 + v9 = tmp24 + continue + } + tmp11 = tmp16 + } // end let + tmp10 = tmp11 + } else { + tmp10 = v9 + } + tmp5 = tmp10 + break + } + } // end let + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_DOT_protocols_naive_DASH_seq_DASH_reduce = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_DOT_protocols_naive_DASH_seq_DASH_reduce.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // nav + { + tmp0 := sym_nav.WithMeta(lang.NewMap(kw_file, "glojure/protocols.glj", kw_line, int(198), kw_column, int(4), kw_end_DASH_line, int(198), kw_end_DASH_column, int(6), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core_DOT_protocols))).(*lang.Symbol) + var tmp2 lang.FnFunc + tmp2 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArity(args, 1) + v3 := args[0] + _ = v3 + var v4 any = lang.NewList(args[1:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_class) + tmp6 := lang.Apply(tmp5, []any{v3}) + return tmp6 + } + }) + tmp1 := lang.NewMultiFn("nav", tmp2, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) + var_glojure_DOT_core_DOT_protocols_nav = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_DOT_protocols_nav.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // seq-reduce + { + tmp0 := sym_seq_DASH_reduce.WithMeta(lang.NewMap(kw_file, "glojure/protocols.glj", kw_line, int(24), kw_column, int(8), kw_end_DASH_line, int(24), kw_end_DASH_column, int(17), kw_private, true, kw_arglists, lang.NewList(lang.NewVector(sym_coll, sym_f), lang.NewVector(sym_coll, sym_f, sym_val)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core_DOT_protocols))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "temp__0__auto__" + tmp5 := checkDerefVar(var_glojure_DOT_core_seq) + tmp6 := lang.Apply(tmp5, []any{v2}) + var v7 any = tmp6 + _ = v7 + var tmp8 any + if lang.IsTruthy(v7) { + var tmp9 any + { // let + // let binding "s" + var v10 any = v7 + _ = v10 + tmp11 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_internal_DASH_reduce) + tmp12 := checkDerefVar(var_glojure_DOT_core_next) + tmp13 := lang.Apply(tmp12, []any{v10}) + tmp14 := checkDerefVar(var_glojure_DOT_core_first) + tmp15 := lang.Apply(tmp14, []any{v10}) + tmp16 := lang.Apply(tmp11, []any{tmp13, v3, tmp15}) + tmp9 = tmp16 + } // end let + tmp8 = tmp9 + } else { + tmp10 := lang.Apply(v3, nil) + tmp8 = tmp10 + } + tmp4 = tmp8 + } // end let + return tmp4 + case 3: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + { // let + // let binding "s" + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := lang.Apply(tmp6, []any{v2}) + var v8 any = tmp7 + _ = v8 + tmp9 := checkDerefVar(var_glojure_DOT_core_DOT_protocols_internal_DASH_reduce) + tmp10 := lang.Apply(tmp9, []any{v8, v3, v4}) + tmp5 = tmp10 + } // end let + return tmp5 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_DOT_protocols_seq_DASH_reduce = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_DOT_protocols_seq_DASH_reduce.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } +} From 1d52821dcbbff5e2d9eae9f6188789f7da5f4737 Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sun, 31 Aug 2025 09:42:04 -0700 Subject: [PATCH 54/67] repl starts up with AOT Signed-off-by: James Hamlin --- Makefile | 5 +- pkg/lang/ifn.go | 2 +- pkg/runtime/codegen.go | 27 +- pkg/runtime/rtcompat.go | 2 - .../testdata/codegen/test/core/load.go.out | 17 +- pkg/stdlib/glojure/core/async/loader.go | 52 +- pkg/stdlib/glojure/core/loader.go | 529 +++++++++--------- pkg/stdlib/glojure/core_deftype/loader.go | 498 +++++++++-------- pkg/stdlib/glojure/core_print/loader.go | 529 +++++++++--------- pkg/stdlib/glojure/protocols/loader.go | 72 ++- 10 files changed, 929 insertions(+), 804 deletions(-) diff --git a/Makefile b/Makefile index 4237f6ea..f28807de 100644 --- a/Makefile +++ b/Makefile @@ -30,9 +30,8 @@ gocmd: .PHONY: generate generate: @go generate ./... - @echo "(compile 'glojure.core)" | GLOJURE_STDLIB_PATH=./pkg/stdlib $(GO_CMD) run ./cmd/glj - @echo "(compile 'glojure.core.async)" | GLOJURE_STDLIB_PATH=./pkg/stdlib $(GO_CMD) run ./cmd/glj - @echo "(compile 'glojure.protocols)" | GLOJURE_STDLIB_PATH=./pkg/stdlib $(GO_CMD) run ./cmd/glj + @echo "(map compile '[glojure.core glojure.core.async])" | \ + GLOJURE_STDLIB_PATH=./pkg/stdlib $(GO_CMD) run ./cmd/glj pkg/gen/gljimports/gljimports_%.go: ./scripts/gen-gljimports.sh ./cmd/gen-import-interop/main.go ./internal/genpkg/genpkg.go \ $(wildcard ./pkg/lang/*.go) $(wildcard ./pkg/runtime/*.go) diff --git a/pkg/lang/ifn.go b/pkg/lang/ifn.go index 6c9cd2a0..99dbda4e 100644 --- a/pkg/lang/ifn.go +++ b/pkg/lang/ifn.go @@ -21,7 +21,7 @@ func (f FnFunc) Invoke(args ...any) any { } func (f FnFunc) ApplyTo(args ISeq) any { - return f.fn(seqToSlice(args)) + return f.fn(seqToSlice(args)...) } func (f FnFunc) Meta() IPersistentMap { diff --git a/pkg/runtime/codegen.go b/pkg/runtime/codegen.go index 8c506493..cd983174 100644 --- a/pkg/runtime/codegen.go +++ b/pkg/runtime/codegen.go @@ -222,6 +222,13 @@ runtime.RegisterNSLoader(` + fmt.Sprintf("%q", rootResourceName) + `, LoadNS) } } +`) + initBuf.WriteString(`func checkArityGTE(args []any, min int) { + if len(args) < min { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + `) initBuf.WriteString(fmt.Sprintf("// LoadNS initializes the namespace %q\n", ns.Name().String())) initBuf.WriteString("func LoadNS() {\n") @@ -380,11 +387,15 @@ func (g *Generator) generateVar(nsVariableName string, name *lang.Symbol, vr *la meta := vr.Meta() varSym := g.allocateTempVar() + var isDynamic bool if lang.IsNil(meta) { g.writef("%s := %s\n", varSym, g.allocSymVar(name.String())) } else { metaVariable := g.generateValue(meta) g.writef("%s := %s.WithMeta(%s).(*lang.Symbol)\n", varSym, g.allocSymVar(name.String()), metaVariable) + if RT.BooleanCast(lang.Get(meta, lang.KWDynamic)) { + isDynamic = true + } } // check if the var has a value @@ -400,6 +411,9 @@ func (g *Generator) generateVar(nsVariableName string, name *lang.Symbol, vr *la g.writef("\t%s.SetMeta(%s.Meta().(lang.IPersistentMap))\n", varVar, varSym) g.writef("}\n") } + if isDynamic { + g.writef("%s.SetDynamic()\n", varVar) + } return nil } @@ -503,6 +517,12 @@ func (g *Generator) generateTypeValue(t reflect.Type) string { // generateZeroValueExpr generates a Go expression that creates a zero value // of the given type, handling package imports as needed func (g *Generator) generateZeroValueExpr(t reflect.Type) string { + // TODO: review this LLM slop + switch { + case t == reflect.TypeOf(lang.NewChar('a')): + return "lang.NewChar(0)" + } + switch t.Kind() { case reflect.Bool: return "false" @@ -744,6 +764,8 @@ func (g *Generator) generateSetValue(s lang.IPersistentSet) string { } func (g *Generator) generateMultiFn(mf *lang.MultiFn) string { + fmt.Println("Generating MultiFn:", mf.GetName()) + // Allocate a variable for the MultiFn mfVar := g.allocateTempVar() @@ -757,6 +779,7 @@ func (g *Generator) generateMultiFn(mf *lang.MultiFn) string { hierarchyVar := g.generateValue(mf.GetHierarchy()) // Create the MultiFn + g.writef("// MultiFn %s\n", mf.GetName()) g.writef("%s := lang.NewMultiFn(%#v, %s, %s, %s)\n", mfVar, mf.GetName(), dispatchFnVar, defaultValVar, hierarchyVar) @@ -771,6 +794,8 @@ func (g *Generator) generateMultiFn(mf *lang.MultiFn) string { dispatchValVar := g.generateValue(dispatchVal) methodVar := g.generateValue(method) + fmt.Println("Adding method for dispatch value:", dispatchVal) + g.writef("%s.AddMethod(%s, %s)\n", mfVar, dispatchValVar, methodVar) } } @@ -875,7 +900,7 @@ func (g *Generator) generateFn(fn *Fn) string { if variadicMethod != nil { variadicMethodNode := variadicMethod.Sub.(*ast.FnMethodNode) g.writef(" default:\n") - g.writef("checkArity(args, %d)\n", variadicMethodNode.FixedArity) + g.writef("checkArityGTE(args, %d)\n", variadicMethodNode.FixedArity) g.generateFnMethod(variadicMethodNode, "args") } else { // No variadic method - error on any other arity diff --git a/pkg/runtime/rtcompat.go b/pkg/runtime/rtcompat.go index 032a6829..d7119fc7 100644 --- a/pkg/runtime/rtcompat.go +++ b/pkg/runtime/rtcompat.go @@ -149,12 +149,10 @@ func (rt *RTMethods) Load(scriptBase string) { if useAot { // check nsloaders if loader := GetNSLoader(strings.TrimPrefix(scriptBase, "/")); loader != nil { - fmt.Printf("Using custom loader for %s\n", scriptBase) loader() return } } - fmt.Printf("Loading %s\n", scriptBase) filename := scriptBase + ".glj" diff --git a/pkg/runtime/testdata/codegen/test/core/load.go.out b/pkg/runtime/testdata/codegen/test/core/load.go.out index 80f8253b..f5815203 100644 --- a/pkg/runtime/testdata/codegen/test/core/load.go.out +++ b/pkg/runtime/testdata/codegen/test/core/load.go.out @@ -8455,7 +8455,7 @@ func LoadNS() { v3 := args[0] _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp5 := reflect.TypeOf(int32(0)) + tmp5 := reflect.TypeOf(lang.NewChar(0)) tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) return tmp6 }) @@ -48721,6 +48721,7 @@ func LoadNS() { return tmp8 } }) + // MultiFn coll-reduce tmp3 := lang.NewMultiFn("coll-reduce", tmp4, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) var tmp5 lang.FnFunc tmp5 = lang.NewFnFunc(func(args ...any) any { @@ -48808,6 +48809,7 @@ func LoadNS() { return tmp18 } }) + // MultiFn internal-reduce tmp13 := lang.NewMultiFn("internal-reduce", tmp14, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) var tmp15 lang.FnFunc tmp15 = lang.NewFnFunc(func(args ...any) any { @@ -48877,6 +48879,7 @@ func LoadNS() { return tmp26 } }) + // MultiFn kv-reduce tmp21 := lang.NewMultiFn("kv-reduce", tmp22, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) tmp20 := lang.NewAtom(lang.NewMap(kw_multis, lang.NewMap(kw_kv_DASH_reduce, tmp21), kw_on_DASH_interface, true, kw_sigs, lang.NewList(lang.NewList(sym_kv_DASH_reduce, lang.NewVector(sym_amap, sym_f, sym_init))))) var tmp25 lang.FnFunc @@ -48893,6 +48896,7 @@ func LoadNS() { return tmp29 } }) + // MultiFn datafy tmp24 := lang.NewMultiFn("datafy", tmp25, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) var tmp26 lang.FnFunc tmp26 = lang.NewFnFunc(func(args ...any) any { @@ -48926,6 +48930,7 @@ func LoadNS() { return tmp33 } }) + // MultiFn nav tmp28 := lang.NewMultiFn("nav", tmp29, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) tmp27 := lang.NewAtom(lang.NewMap(kw_multis, lang.NewMap(kw_nav, tmp28), kw_on_DASH_interface, true, kw_sigs, lang.NewList(lang.NewList(sym_nav, lang.NewVector(sym_coll, sym_k, sym_v), "return (possibly transformed) v in the context of coll and k (a key/index or nil),\ndefaults to returning v.")))) var tmp32 lang.FnFunc @@ -48942,6 +48947,7 @@ func LoadNS() { return tmp36 } }) + // MultiFn make-reader tmp31 := lang.NewMultiFn("make-reader", tmp32, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) tmp33 := reflect.TypeOf((*io4.Reader)(nil)).Elem() var tmp34 lang.FnFunc @@ -49011,6 +49017,7 @@ func LoadNS() { return tmp44 } }) + // MultiFn make-writer tmp39 := lang.NewMultiFn("make-writer", tmp40, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) tmp41 := reflect.TypeOf((*io4.Reader)(nil)).Elem() var tmp42 lang.FnFunc @@ -49080,6 +49087,7 @@ func LoadNS() { return tmp52 } }) + // MultiFn make-input-stream tmp47 := lang.NewMultiFn("make-input-stream", tmp48, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) tmp49 := reflect.TypeOf((*io4.Reader)(nil)).Elem() var tmp50 lang.FnFunc @@ -49167,6 +49175,7 @@ func LoadNS() { return tmp62 } }) + // MultiFn make-output-stream tmp57 := lang.NewMultiFn("make-output-stream", tmp58, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) tmp59 := reflect.TypeOf((*io4.Reader)(nil)).Elem() var tmp60 lang.FnFunc @@ -54640,6 +54649,7 @@ func LoadNS() { return tmp6 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3667), kw_column, int(21), kw_end_DASH_line, int(3667), kw_end_DASH_column, int(45))).(lang.FnFunc) + // MultiFn print-dup tmp1 := lang.NewMultiFn("print-dup", tmp2, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { @@ -54854,7 +54864,7 @@ func LoadNS() { return tmp40 }) tmp1.AddMethod(tmp24, tmp25) - tmp26 := reflect.TypeOf(int32(0)) + tmp26 := reflect.TypeOf(lang.NewChar(0)) var tmp27 lang.FnFunc tmp27 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 2) @@ -55136,6 +55146,7 @@ func LoadNS() { return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3664), kw_column, int(24), kw_end_DASH_line, int(3666), kw_end_DASH_column, int(58))).(lang.FnFunc) + // MultiFn print-method tmp1 := lang.NewMultiFn("print-method", tmp2, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { @@ -55441,7 +55452,7 @@ func LoadNS() { return nil }) tmp1.AddMethod(tmp19, tmp20) - tmp21 := reflect.TypeOf(int32(0)) + tmp21 := reflect.TypeOf(lang.NewChar(0)) var tmp22 lang.FnFunc tmp22 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 2) diff --git a/pkg/stdlib/glojure/core/async/loader.go b/pkg/stdlib/glojure/core/async/loader.go index c8ecc31f..ac75f31e 100644 --- a/pkg/stdlib/glojure/core/async/loader.go +++ b/pkg/stdlib/glojure/core/async/loader.go @@ -27,6 +27,12 @@ func checkArity(args []any, expected int) { } } +func checkArityGTE(args []any, min int) { + if len(args) < min { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + // LoadNS initializes the namespace "glojure.core.async" func LoadNS() { sym__AMP_ := lang.NewSymbol("&") @@ -409,7 +415,7 @@ func LoadNS() { _ = v2 var tmp3 any { // let - // let binding "vec__692" + // let binding "vec__1018" tmp4 := lang.Apply(lang.Builtins["recv"], []any{v2}) var v5 any = tmp4 _ = v5 @@ -443,7 +449,7 @@ func LoadNS() { _ = v2 var tmp3 any { // let - // let binding "vec__692" + // let binding "vec__1018" tmp4 := lang.Apply(lang.Builtins["recv"], []any{v2}) var v5 any = tmp4 _ = v5 @@ -474,7 +480,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -499,7 +505,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -528,17 +534,17 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) _ = v3 var tmp4 any { // let - // let binding "map__708" + // let binding "map__1034" var v5 any = v3 _ = v5 - // let binding "map__708" + // let binding "map__1034" var tmp6 any tmp7 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) tmp8 := lang.Apply(tmp7, []any{v5}) @@ -592,17 +598,17 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) _ = v3 var tmp4 any { // let - // let binding "map__708" + // let binding "map__1034" var v5 any = v3 _ = v5 - // let binding "map__708" + // let binding "map__1034" var tmp6 any tmp7 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) tmp8 := lang.Apply(tmp7, []any{v5}) @@ -758,7 +764,7 @@ func LoadNS() { tmp16 := lang.Apply(tmp15, []any{v11, v7}) var v17 any = tmp16 _ = v17 - // let binding "vec__709" + // let binding "vec__1035" tmp18 := checkDerefVar(var_glojure_DOT_core_reduce) var tmp19 lang.FnFunc tmp19 = lang.NewFnFunc(func(args ...any) any { @@ -769,7 +775,7 @@ func LoadNS() { _ = v21 var tmp22 any { // let - // let binding "vec__714" + // let binding "vec__1040" var v23 any = v20 _ = v23 // let binding "clauses" @@ -782,7 +788,7 @@ func LoadNS() { tmp28 := lang.Apply(tmp27, []any{v23, int64(1), nil}) var v29 any = tmp28 _ = v29 - // let binding "vec__717" + // let binding "vec__1043" var v30 any = v21 _ = v30 // let binding "ports" @@ -814,7 +820,7 @@ func LoadNS() { } var v44 any = tmp38 _ = v44 - // let binding "vec__720" + // let binding "vec__1046" tmp45 := checkDerefVar(var_glojure_DOT_core_reduce) var tmp46 lang.FnFunc tmp46 = lang.NewFnFunc(func(args ...any) any { @@ -825,7 +831,7 @@ func LoadNS() { _ = v48 var tmp49 any { // let - // let binding "vec__724" + // let binding "vec__1050" var v50 any = v47 _ = v50 // let binding "ports" @@ -844,7 +850,7 @@ func LoadNS() { if lang.IsTruthy(tmp59) { var tmp60 any { // let - // let binding "vec__727" + // let binding "vec__1053" var v61 any = v48 _ = v61 // let binding "port" @@ -1098,7 +1104,7 @@ func LoadNS() { _ = v111 var tmp112 any { // let - // let binding "vec__731" + // let binding "vec__1057" var v113 any = v111 _ = v113 // let binding "ports" @@ -1301,7 +1307,7 @@ func LoadNS() { tmp30 := lang.Apply(tmp29, nil) var v31 any = tmp30 _ = v31 - // let binding "vec__704" + // let binding "vec__1030" tmp32 := checkDerefVar(var_glojure_DOT_core_map) tmp33 := lang.Apply(tmp32, []any{lang.Builtins["deref"], v28}) tmp34 := lang.Apply(reflect.Select, []any{tmp33}) @@ -1401,7 +1407,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -1543,7 +1549,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -1724,7 +1730,7 @@ func LoadNS() { tmp5 := lang.Apply(tmp4, []any{v2}) var v6 any = tmp5 _ = v6 - // let binding "vec__701" + // let binding "vec__1027" var v7 any = v6 _ = v7 // let binding "val" @@ -1911,7 +1917,7 @@ func LoadNS() { tmp12 := lang.Apply(tmp11, nil) var v13 any = tmp12 _ = v13 - // let binding "vec__695" + // let binding "vec__1021" tmp14 := checkDerefVar(var_glojure_DOT_core_map) tmp15 := lang.NewVector(v10, v13) tmp16 := lang.NewMap(kw_file, "glojure/core/async.glj", kw_line, int(124), kw_column, int(55), kw_end_DASH_line, int(124), kw_end_DASH_column, int(62)) @@ -1972,7 +1978,7 @@ func LoadNS() { // let binding "_" var v7 any = nil _ = v7 - // let binding "vec__698" + // let binding "vec__1024" tmp8 := checkDerefVar(var_glojure_DOT_core_map) tmp9 := lang.NewVector(v4, v6) tmp10 := lang.NewMap(kw_file, "glojure/core/async.glj", kw_line, int(138), kw_column, int(55), kw_end_DASH_line, int(138), kw_end_DASH_column, int(62)) diff --git a/pkg/stdlib/glojure/core/loader.go b/pkg/stdlib/glojure/core/loader.go index 680d3ca4..b5ac737a 100644 --- a/pkg/stdlib/glojure/core/loader.go +++ b/pkg/stdlib/glojure/core/loader.go @@ -37,6 +37,12 @@ func checkArity(args []any, expected int) { } } +func checkArityGTE(args []any, min int) { + if len(args) < min { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + // LoadNS initializes the namespace "glojure.core" func LoadNS() { sym__PCT_ := lang.NewSymbol("%") @@ -3080,6 +3086,7 @@ func LoadNS() { if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_data_DASH_readers_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_data_DASH_readers_STAR_.SetDynamic() } // *default-data-reader-fn* { @@ -3088,6 +3095,7 @@ func LoadNS() { if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_default_DASH_data_DASH_reader_DASH_fn_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_default_DASH_data_DASH_reader_DASH_fn_STAR_.SetDynamic() } // *e { @@ -3129,6 +3137,7 @@ func LoadNS() { if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_.SetDynamic() } // *loading-verbosely* { @@ -3137,6 +3146,7 @@ func LoadNS() { if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_.SetDynamic() } // *ns* { @@ -3153,6 +3163,7 @@ func LoadNS() { if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_.SetDynamic() } // *print-dup* { @@ -3169,6 +3180,7 @@ func LoadNS() { if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_print_DASH_length_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_print_DASH_length_STAR_.SetDynamic() } // *print-level* { @@ -3177,6 +3189,7 @@ func LoadNS() { if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_print_DASH_level_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_print_DASH_level_STAR_.SetDynamic() } // *print-meta* { @@ -3193,6 +3206,7 @@ func LoadNS() { if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_print_DASH_namespace_DASH_maps_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_print_DASH_namespace_DASH_maps_STAR_.SetDynamic() } // *print-readably* { @@ -3217,6 +3231,7 @@ func LoadNS() { if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_repl_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_repl_STAR_.SetDynamic() } // *unchecked-math* { @@ -3233,6 +3248,7 @@ func LoadNS() { if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_verbose_DASH_defrecords_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_verbose_DASH_defrecords_STAR_.SetDynamic() } // *warn-on-reflection* { @@ -3339,7 +3355,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -3367,7 +3383,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -3395,7 +3411,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -3749,7 +3765,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -3772,7 +3788,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -3903,7 +3919,7 @@ func LoadNS() { tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v4 any = lang.NewList(args[0:]...) _ = v4 return v2 @@ -3969,7 +3985,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 tmp3 := lang.Apply(lang.CreatePersistentStructMapSlotMap, []any{v2}) @@ -4529,7 +4545,7 @@ func LoadNS() { } return tmp4 default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 tmp3 := lang.Apply(lang.CreatePersistentHashMap, []any{v2}) @@ -4574,7 +4590,7 @@ func LoadNS() { } return tmp4 default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 tmp3 := lang.Apply(nil, []any{v2}) @@ -6618,7 +6634,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 tmp3 := lang.Apply(lang.CreatePersistentTreeMap, []any{v2}) @@ -6638,7 +6654,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -6660,7 +6676,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 tmp3 := lang.Apply(lang.CreatePersistentTreeSet, []any{v2}) @@ -6680,7 +6696,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -6815,7 +6831,7 @@ func LoadNS() { } return tmp4 default: - checkArity(args, 1) + checkArityGTE(args, 1) v3 := args[0] _ = v3 var v4 any = lang.NewList(args[1:]...) @@ -7047,7 +7063,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -7069,7 +7085,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -7124,7 +7140,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -7152,7 +7168,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -7769,7 +7785,7 @@ func LoadNS() { } return tmp10 default: - checkArity(args, 6) + checkArityGTE(args, 6) v2 := args[0] _ = v2 v3 := args[1] @@ -7898,7 +7914,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -7927,7 +7943,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -8164,7 +8180,7 @@ func LoadNS() { tmp6 := lang.Apply(lang.Assoc, []any{v3, v4, v5}) return tmp6 default: - checkArity(args, 3) + checkArityGTE(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -8243,7 +8259,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -8382,7 +8398,7 @@ func LoadNS() { v3 := args[0] _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp5 := reflect.TypeOf(int32(0)) + tmp5 := reflect.TypeOf(lang.NewChar(0)) tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) return tmp6 }) @@ -8611,7 +8627,7 @@ func LoadNS() { tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) return tmp5 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -8716,7 +8732,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -8786,7 +8802,7 @@ func LoadNS() { tmp5 := lang.Apply(lang.Conj, []any{v3, v4}) return tmp5 default: - checkArity(args, 2) + checkArityGTE(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -9086,7 +9102,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 4) + checkArityGTE(args, 4) v2 := args[0] _ = v2 v3 := args[1] @@ -9141,7 +9157,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -9287,7 +9303,7 @@ func LoadNS() { } return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -9356,7 +9372,7 @@ func LoadNS() { tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -9423,7 +9439,7 @@ func LoadNS() { tmp5 := lang.Apply(tmp4, []any{v2, v3}) return tmp5 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -9483,7 +9499,7 @@ func LoadNS() { tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -9535,7 +9551,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -9614,7 +9630,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) @@ -10324,7 +10340,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) @@ -10571,7 +10587,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -11150,7 +11166,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) @@ -11380,7 +11396,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -11800,7 +11816,7 @@ func LoadNS() { tmp11 := lang.Apply(tmp6, []any{v2, tmp10}) return tmp11 default: - checkArity(args, 4) + checkArityGTE(args, 4) v2 := args[0] _ = v2 v3 := args[1] @@ -11902,7 +11918,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) @@ -12568,7 +12584,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -13526,7 +13542,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -13951,7 +13967,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) @@ -14250,7 +14266,7 @@ func LoadNS() { } // end let return tmp8 default: - checkArity(args, 3) + checkArityGTE(args, 3) v5 := args[0] _ = v5 v6 := args[1] @@ -14447,7 +14463,7 @@ func LoadNS() { } // end let return tmp9 default: - checkArity(args, 3) + checkArityGTE(args, 3) v6 := args[0] _ = v6 v7 := args[1] @@ -14757,7 +14773,7 @@ func LoadNS() { } // end let return tmp10 default: - checkArity(args, 3) + checkArityGTE(args, 3) v7 := args[0] _ = v7 v8 := args[1] @@ -14836,7 +14852,7 @@ func LoadNS() { } return tmp7 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -14965,7 +14981,7 @@ func LoadNS() { tmp19 := lang.Apply(tmp15, []any{tmp18, v9}) return tmp19 default: - checkArity(args, 3) + checkArityGTE(args, 3) v12 := args[0] _ = v12 v13 := args[1] @@ -15271,7 +15287,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 tmp3 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) @@ -16565,7 +16581,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 4) + checkArityGTE(args, 4) v2 := args[0] _ = v2 v3 := args[1] @@ -16874,7 +16890,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -16962,7 +16978,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -17070,7 +17086,7 @@ func LoadNS() { tmp15 := lang.Apply(tmp6, []any{tmp14}) return tmp15 default: - checkArity(args, 4) + checkArityGTE(args, 4) v2 := args[0] _ = v2 v3 := args[1] @@ -17154,7 +17170,7 @@ func LoadNS() { tmp5 := lang.Apply(lang.Equiv, []any{v3, v4}) return tmp5 default: - checkArity(args, 2) + checkArityGTE(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -17255,7 +17271,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 default: - checkArity(args, 2) + checkArityGTE(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -17358,7 +17374,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 default: - checkArity(args, 2) + checkArityGTE(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -17461,7 +17477,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 default: - checkArity(args, 2) + checkArityGTE(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -17564,7 +17580,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 default: - checkArity(args, 2) + checkArityGTE(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -17667,7 +17683,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 default: - checkArity(args, 2) + checkArityGTE(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -17796,7 +17812,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -17913,7 +17929,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -18016,7 +18032,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -18133,7 +18149,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -18236,7 +18252,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -18352,7 +18368,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -18455,7 +18471,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -18572,7 +18588,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -18675,7 +18691,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -18792,7 +18808,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -19063,7 +19079,7 @@ func LoadNS() { tmp9 := lang.Apply(lang.Apply, []any{v2, tmp8}) return tmp9 default: - checkArity(args, 5) + checkArityGTE(args, 5) v2 := args[0] _ = v2 v3 := args[1] @@ -19229,7 +19245,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 tmp3 := checkDerefVar(var_glojure_DOT_core_into_DASH_array) @@ -19409,7 +19425,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -19978,7 +19994,7 @@ func LoadNS() { tmp11 := lang.Apply(v2, []any{v7, v8, v9}) return tmp11 default: - checkArity(args, 3) + checkArityGTE(args, 3) v7 := args[0] _ = v7 v8 := args[1] @@ -20091,7 +20107,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -20201,7 +20217,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -20304,7 +20320,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -20414,7 +20430,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -20568,7 +20584,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -20678,7 +20694,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -20895,7 +20911,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -21005,7 +21021,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -21085,7 +21101,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) @@ -21201,7 +21217,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -21238,7 +21254,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 tmp3 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) @@ -21469,7 +21485,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) @@ -21683,7 +21699,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) @@ -21842,7 +21858,7 @@ func LoadNS() { tmp9 := lang.Apply(v2, []any{tmp8}) return tmp9 default: - checkArity(args, 3) + checkArityGTE(args, 3) v5 := args[0] _ = v5 v6 := args[1] @@ -21864,7 +21880,7 @@ func LoadNS() { } return tmp6 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -21965,7 +21981,7 @@ func LoadNS() { tmp8 := lang.Apply(tmp6, []any{tmp7}) return tmp8 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -22224,7 +22240,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -22354,7 +22370,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -22640,7 +22656,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -22752,7 +22768,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -23285,7 +23301,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -23923,7 +23939,7 @@ func LoadNS() { tmp10 := lang.Apply(tmp8, []any{tmp9}) return tmp10 default: - checkArity(args, 3) + checkArityGTE(args, 3) v5 := args[0] _ = v5 v6 := args[1] @@ -24128,7 +24144,7 @@ func LoadNS() { tmp11 := lang.Apply(tmp9, []any{tmp10}) return tmp11 default: - checkArity(args, 3) + checkArityGTE(args, 3) v6 := args[0] _ = v6 v7 := args[1] @@ -24446,7 +24462,7 @@ func LoadNS() { tmp12 := lang.Apply(tmp10, []any{tmp11}) return tmp12 default: - checkArity(args, 3) + checkArityGTE(args, 3) v7 := args[0] _ = v7 v8 := args[1] @@ -24527,7 +24543,7 @@ func LoadNS() { } return tmp7 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -24656,7 +24672,7 @@ func LoadNS() { tmp19 := lang.Apply(tmp15, []any{tmp18, v9}) return tmp19 default: - checkArity(args, 3) + checkArityGTE(args, 3) v12 := args[0] _ = v12 v13 := args[1] @@ -25030,7 +25046,7 @@ func LoadNS() { tmp11 := lang.Apply(v2, []any{tmp8, v6, v7}) return tmp11 default: - checkArity(args, 3) + checkArityGTE(args, 3) v5 := args[0] _ = v5 v6 := args[1] @@ -25117,7 +25133,7 @@ func LoadNS() { tmp15 := lang.Apply(v2, []any{tmp9, tmp12, v8}) return tmp15 default: - checkArity(args, 3) + checkArityGTE(args, 3) v6 := args[0] _ = v6 v7 := args[1] @@ -25222,7 +25238,7 @@ func LoadNS() { tmp19 := lang.Apply(v2, []any{tmp10, tmp13, tmp16}) return tmp19 default: - checkArity(args, 3) + checkArityGTE(args, 3) v7 := args[0] _ = v7 v8 := args[1] @@ -25284,7 +25300,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -25307,7 +25323,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -25502,7 +25518,7 @@ func LoadNS() { tmp17 := lang.Apply(tmp6, []any{tmp16}) return tmp17 default: - checkArity(args, 5) + checkArityGTE(args, 5) v2 := args[0] _ = v2 v3 := args[1] @@ -25672,7 +25688,7 @@ func LoadNS() { tmp17 := lang.Apply(tmp6, []any{tmp16}) return tmp17 default: - checkArity(args, 5) + checkArityGTE(args, 5) v2 := args[0] _ = v2 v3 := args[1] @@ -25919,7 +25935,7 @@ func LoadNS() { } return tmp10 default: - checkArity(args, 3) + checkArityGTE(args, 3) v4 := args[0] _ = v4 v5 := args[1] @@ -26006,7 +26022,7 @@ func LoadNS() { } return tmp12 default: - checkArity(args, 3) + checkArityGTE(args, 3) v5 := args[0] _ = v5 v6 := args[1] @@ -26101,7 +26117,7 @@ func LoadNS() { } return tmp14 default: - checkArity(args, 3) + checkArityGTE(args, 3) v6 := args[0] _ = v6 v7 := args[1] @@ -26132,7 +26148,7 @@ func LoadNS() { } return tmp7 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -26272,7 +26288,7 @@ func LoadNS() { tmp21 := lang.Apply(tmp14, []any{tmp17, tmp20, v9}) return tmp21 default: - checkArity(args, 3) + checkArityGTE(args, 3) v11 := args[0] _ = v11 v12 := args[1] @@ -26560,7 +26576,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -26593,7 +26609,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -26729,7 +26745,7 @@ func LoadNS() { tmp9 := lang.Apply(v4, []any{v6, tmp8}) return tmp9 default: - checkArity(args, 2) + checkArityGTE(args, 2) v6 := args[0] _ = v6 v7 := args[1] @@ -27016,7 +27032,7 @@ func LoadNS() { tmp7 := lang.Apply(lang.NewLazySeq, []any{tmp6}) return tmp7 default: - checkArity(args, 4) + checkArityGTE(args, 4) v2 := args[0] _ = v2 v3 := args[1] @@ -27194,7 +27210,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -27308,7 +27324,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -27360,7 +27376,7 @@ func LoadNS() { } return tmp5 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -27489,7 +27505,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -27562,7 +27578,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 var tmp3 any @@ -27626,7 +27642,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -27822,7 +27838,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -27936,7 +27952,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -27988,7 +28004,7 @@ func LoadNS() { } return tmp5 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -28263,7 +28279,7 @@ func LoadNS() { } // end let return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v5 := args[0] _ = v5 v6 := args[1] @@ -28464,7 +28480,7 @@ func LoadNS() { tmp7 := lang.Apply(closed24, []any{tmp6}) return tmp7 default: - checkArity(args, 3) + checkArityGTE(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -28521,7 +28537,7 @@ func LoadNS() { tmp7 := lang.Apply(closed24, []any{tmp6}) return tmp7 default: - checkArity(args, 3) + checkArityGTE(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -28564,7 +28580,7 @@ func LoadNS() { tmp8 := lang.Apply(tmp5, []any{tmp7}) return tmp8 default: - checkArity(args, 2) + checkArityGTE(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -29081,7 +29097,7 @@ func LoadNS() { _ = v4 return v4 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -29354,7 +29370,7 @@ func LoadNS() { tmp8 := lang.Apply(v2, []any{v3, v5, v6, v7}) return tmp8 default: - checkArity(args, 3) + checkArityGTE(args, 3) v5 := args[0] _ = v5 v6 := args[1] @@ -29409,7 +29425,7 @@ func LoadNS() { tmp9 := lang.Apply(v2, []any{v3, v4, v6, v7, v8}) return tmp9 default: - checkArity(args, 3) + checkArityGTE(args, 3) v6 := args[0] _ = v6 v7 := args[1] @@ -29466,7 +29482,7 @@ func LoadNS() { tmp10 := lang.Apply(v2, []any{v3, v4, v5, v7, v8, v9}) return tmp10 default: - checkArity(args, 3) + checkArityGTE(args, 3) v7 := args[0] _ = v7 v8 := args[1] @@ -29487,7 +29503,7 @@ func LoadNS() { } return tmp8 default: - checkArity(args, 4) + checkArityGTE(args, 4) v2 := args[0] _ = v2 v3 := args[1] @@ -29502,7 +29518,7 @@ func LoadNS() { tmp7 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v8 any = lang.NewList(args[0:]...) _ = v8 tmp9 := checkDerefVar(var_glojure_DOT_core_apply) @@ -29981,7 +29997,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -30524,7 +30540,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -31036,7 +31052,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -31591,7 +31607,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -31820,7 +31836,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -31920,7 +31936,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -32161,7 +32177,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -32469,7 +32485,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -32897,7 +32913,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -33166,7 +33182,7 @@ func LoadNS() { } // end let return tmp3 default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -33265,7 +33281,7 @@ func LoadNS() { tmp12 := lang.Apply(tmp8, []any{v2, v3, tmp11}) return tmp12 default: - checkArity(args, 6) + checkArityGTE(args, 6) v2 := args[0] _ = v2 v3 := args[1] @@ -33302,7 +33318,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -33403,7 +33419,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -33432,7 +33448,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -33566,7 +33582,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -33689,7 +33705,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -33822,7 +33838,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -33880,7 +33896,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -33930,7 +33946,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -33967,7 +33983,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -34050,7 +34066,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -34137,7 +34153,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -34280,7 +34296,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -34361,7 +34377,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -34474,7 +34490,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -34861,7 +34877,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -34977,7 +34993,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -35080,7 +35096,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -35196,7 +35212,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -35224,7 +35240,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -35350,7 +35366,7 @@ func LoadNS() { tmp5 := lang.Apply(lang.Get, []any{v3, v4}) return tmp5 default: - checkArity(args, 2) + checkArityGTE(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -35627,7 +35643,7 @@ func LoadNS() { _ = v4 return v4 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -35704,7 +35720,7 @@ func LoadNS() { } return tmp3 default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 var tmp3 any @@ -35804,7 +35820,7 @@ func LoadNS() { _ = tmp6 return v5 default: - checkArity(args, 3) + checkArityGTE(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -35850,7 +35866,7 @@ func LoadNS() { _ = tmp8 return v4 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -35896,7 +35912,7 @@ func LoadNS() { _ = tmp8 return v4 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -35942,7 +35958,7 @@ func LoadNS() { _ = tmp8 return v4 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -35988,7 +36004,7 @@ func LoadNS() { _ = tmp8 return v4 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -36034,7 +36050,7 @@ func LoadNS() { _ = tmp8 return v4 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -36080,7 +36096,7 @@ func LoadNS() { _ = tmp8 return v4 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -36126,7 +36142,7 @@ func LoadNS() { _ = tmp8 return v4 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -36172,7 +36188,7 @@ func LoadNS() { _ = tmp8 return v4 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -36296,6 +36312,7 @@ func LoadNS() { if tmp0.Meta() != nil { var_glojure_DOT_core_assert_DASH_valid_DASH_fdecl.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core_assert_DASH_valid_DASH_fdecl.SetDynamic() } // atom { @@ -36309,7 +36326,7 @@ func LoadNS() { tmp3 := lang.Apply(lang.NewAtom, []any{v2}) return tmp3 default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -36334,7 +36351,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -36535,7 +36552,7 @@ func LoadNS() { tmp7 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v8 any = lang.NewList(args[0:]...) _ = v8 tmp9 := checkDerefVar(var_glojure_DOT_core_apply) @@ -36601,7 +36618,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -36690,7 +36707,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -36834,7 +36851,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -37105,7 +37122,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -37432,7 +37449,7 @@ func LoadNS() { tmp8 := lang.Apply(tmp5, []any{tmp7}) return tmp8 default: - checkArity(args, 2) + checkArityGTE(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -37607,7 +37624,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -38243,7 +38260,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -38656,7 +38673,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -38714,7 +38731,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -39085,7 +39102,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -39314,7 +39331,7 @@ func LoadNS() { tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) return tmp5 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -39743,7 +39760,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -39788,7 +39805,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -40087,7 +40104,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v2, tmp5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -40545,7 +40562,7 @@ func LoadNS() { tmp10 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v11 any = lang.NewList(args[0:]...) _ = v11 var tmp12 any @@ -40612,7 +40629,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -41512,7 +41529,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 tmp3 := checkDerefVar(var_glojure_DOT_core_pmap) @@ -41926,7 +41943,7 @@ func LoadNS() { tmp3 := lang.Apply(lang.NewRef, []any{v2}) return tmp3 default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -42244,7 +42261,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -42270,7 +42287,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -42880,7 +42897,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -42998,7 +43015,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -43216,7 +43233,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -43679,7 +43696,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 4) + checkArityGTE(args, 4) v2 := args[0] _ = v2 v3 := args[1] @@ -43743,7 +43760,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 var tmp3 any @@ -43978,7 +43995,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -44265,7 +44282,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -44394,7 +44411,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -44523,7 +44540,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 4) + checkArityGTE(args, 4) v2 := args[0] _ = v2 v3 := args[1] @@ -44788,7 +44805,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -45840,7 +45857,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -45936,7 +45953,7 @@ func LoadNS() { tmp51 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v52 := args[0] _ = v52 var v53 any = lang.NewList(args[1:]...) @@ -46088,7 +46105,7 @@ func LoadNS() { tmp63 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v64 := args[0] _ = v64 var v65 any = lang.NewList(args[1:]...) @@ -46295,7 +46312,7 @@ func LoadNS() { tmp37 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v38 any = lang.NewList(args[0:]...) _ = v38 tmp39 := checkDerefVar(var_glojure_DOT_core_apply) @@ -47369,7 +47386,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -47440,7 +47457,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -47929,7 +47946,7 @@ func LoadNS() { tmp4 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v5 := args[0] _ = v5 var v6 any = lang.NewList(args[1:]...) @@ -47939,12 +47956,13 @@ func LoadNS() { return tmp8 } }) + // MultiFn coll-reduce tmp3 := lang.NewMultiFn("coll-reduce", tmp4, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) var tmp5 lang.FnFunc tmp5 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v6 := args[0] _ = v6 var v7 any = lang.NewList(args[1:]...) @@ -47962,7 +47980,7 @@ func LoadNS() { tmp7 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v8 := args[0] _ = v8 var v9 any = lang.NewList(args[1:]...) @@ -47980,7 +47998,7 @@ func LoadNS() { tmp9 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v10 := args[0] _ = v10 var v11 any = lang.NewList(args[1:]...) @@ -47998,7 +48016,7 @@ func LoadNS() { tmp11 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v12 := args[0] _ = v12 var v13 any = lang.NewList(args[1:]...) @@ -48016,7 +48034,7 @@ func LoadNS() { tmp14 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v15 := args[0] _ = v15 var v16 any = lang.NewList(args[1:]...) @@ -48026,12 +48044,13 @@ func LoadNS() { return tmp18 } }) + // MultiFn internal-reduce tmp13 := lang.NewMultiFn("internal-reduce", tmp14, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) var tmp15 lang.FnFunc tmp15 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v16 := args[0] _ = v16 var v17 any = lang.NewList(args[1:]...) @@ -48049,7 +48068,7 @@ func LoadNS() { tmp17 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v18 := args[0] _ = v18 var v19 any = lang.NewList(args[1:]...) @@ -48067,7 +48086,7 @@ func LoadNS() { tmp19 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v20 := args[0] _ = v20 var v21 any = lang.NewList(args[1:]...) @@ -48085,7 +48104,7 @@ func LoadNS() { tmp22 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v23 := args[0] _ = v23 var v24 any = lang.NewList(args[1:]...) @@ -48095,13 +48114,14 @@ func LoadNS() { return tmp26 } }) + // MultiFn kv-reduce tmp21 := lang.NewMultiFn("kv-reduce", tmp22, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) tmp20 := lang.NewAtom(lang.NewMap(kw_multis, lang.NewMap(kw_kv_DASH_reduce, tmp21), kw_on_DASH_interface, true, kw_sigs, lang.NewList(lang.NewList(sym_kv_DASH_reduce, lang.NewVector(sym_amap, sym_f, sym_init))))) var tmp25 lang.FnFunc tmp25 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v26 := args[0] _ = v26 var v27 any = lang.NewList(args[1:]...) @@ -48111,12 +48131,13 @@ func LoadNS() { return tmp29 } }) + // MultiFn datafy tmp24 := lang.NewMultiFn("datafy", tmp25, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) var tmp26 lang.FnFunc tmp26 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v27 := args[0] _ = v27 var v28 any = lang.NewList(args[1:]...) @@ -48134,7 +48155,7 @@ func LoadNS() { tmp29 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v30 := args[0] _ = v30 var v31 any = lang.NewList(args[1:]...) @@ -48144,6 +48165,7 @@ func LoadNS() { return tmp33 } }) + // MultiFn nav tmp28 := lang.NewMultiFn("nav", tmp29, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) tmp27 := lang.NewAtom(lang.NewMap(kw_multis, lang.NewMap(kw_nav, tmp28), kw_on_DASH_interface, true, kw_sigs, lang.NewList(lang.NewList(sym_nav, lang.NewVector(sym_coll, sym_k, sym_v), "return (possibly transformed) v in the context of coll and k (a key/index or nil),\ndefaults to returning v.")))) tmp1 := lang.NewAtom(lang.NewMap(sym_CollReduce, tmp2, sym_InternalReduce, tmp12, sym_IKVReduce, tmp20, sym_Datafiable, tmp23, sym_Navigable, tmp27)) @@ -48179,7 +48201,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -48794,7 +48816,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp3, []any{tmp5, tmp6}) return tmp7 default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -49478,7 +49500,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -50553,7 +50575,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -50779,7 +50801,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 var tmp3 any @@ -51499,7 +51521,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -52058,7 +52080,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 var tmp3 any @@ -52627,7 +52649,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 tmp3 := checkDerefVar(var_glojure_DOT_core_apply) @@ -52649,7 +52671,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 var tmp3 any @@ -52699,7 +52721,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 tmp3 := checkDerefVar(var_glojure_DOT_core_apply) @@ -52845,7 +52867,7 @@ func LoadNS() { tmp12 := lang.Apply(tmp6, []any{tmp9, tmp11}) return tmp12 default: - checkArity(args, 4) + checkArityGTE(args, 4) v2 := args[0] _ = v2 v3 := args[1] @@ -52947,7 +52969,7 @@ func LoadNS() { tmp5 := lang.Apply(tmp3, []any{v2, tmp4}) return tmp5 default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -52998,6 +53020,7 @@ func LoadNS() { if tmp0.Meta() != nil { var_glojure_DOT_core_pr.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core_pr.SetDynamic() } // pr-str { @@ -53007,7 +53030,7 @@ func LoadNS() { tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 var tmp4 any @@ -53059,7 +53082,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 var tmp3 any @@ -53101,7 +53124,7 @@ func LoadNS() { tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 var tmp4 any @@ -53153,7 +53176,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -53179,7 +53202,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 tmp3 := checkDerefVar(var_glojure_DOT_core_apply) @@ -53214,7 +53237,7 @@ func LoadNS() { tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 var tmp4 any @@ -53266,7 +53289,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 var tmp3 any @@ -53308,7 +53331,7 @@ func LoadNS() { tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 var tmp4 any @@ -53545,6 +53568,7 @@ func LoadNS() { return tmp6 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3667), kw_column, int(21), kw_end_DASH_line, int(3667), kw_end_DASH_column, int(45))).(lang.FnFunc) + // MultiFn print-dup tmp1 := lang.NewMultiFn("print-dup", tmp2, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { @@ -53759,7 +53783,7 @@ func LoadNS() { return tmp40 }) tmp1.AddMethod(tmp24, tmp25) - tmp26 := reflect.TypeOf(int32(0)) + tmp26 := reflect.TypeOf(lang.NewChar(0)) var tmp27 lang.FnFunc tmp27 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 2) @@ -54041,6 +54065,7 @@ func LoadNS() { return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3664), kw_column, int(24), kw_end_DASH_line, int(3666), kw_end_DASH_column, int(58))).(lang.FnFunc) + // MultiFn print-method tmp1 := lang.NewMultiFn("print-method", tmp2, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { @@ -54346,7 +54371,7 @@ func LoadNS() { return nil }) tmp1.AddMethod(tmp19, tmp20) - tmp21 := reflect.TypeOf(int32(0)) + tmp21 := reflect.TypeOf(lang.NewChar(0)) var tmp22 lang.FnFunc tmp22 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 2) @@ -56192,7 +56217,7 @@ func LoadNS() { tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v3 := args[0] _ = v3 var v4 any = lang.NewList(args[1:]...) diff --git a/pkg/stdlib/glojure/core_deftype/loader.go b/pkg/stdlib/glojure/core_deftype/loader.go index 6b8a5485..4def5f72 100644 --- a/pkg/stdlib/glojure/core_deftype/loader.go +++ b/pkg/stdlib/glojure/core_deftype/loader.go @@ -37,6 +37,12 @@ func checkArity(args []any, expected int) { } } +func checkArityGTE(args []any, min int) { + if len(args) < min { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + // LoadNS initializes the namespace "glojure.core" func LoadNS() { sym__PCT_ := lang.NewSymbol("%") @@ -2980,6 +2986,7 @@ func LoadNS() { if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_data_DASH_readers_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_data_DASH_readers_STAR_.SetDynamic() } // *default-data-reader-fn* { @@ -2988,6 +2995,7 @@ func LoadNS() { if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_default_DASH_data_DASH_reader_DASH_fn_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_default_DASH_data_DASH_reader_DASH_fn_STAR_.SetDynamic() } // *e { @@ -3029,6 +3037,7 @@ func LoadNS() { if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_.SetDynamic() } // *loading-verbosely* { @@ -3037,6 +3046,7 @@ func LoadNS() { if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_.SetDynamic() } // *ns* { @@ -3053,6 +3063,7 @@ func LoadNS() { if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_.SetDynamic() } // *print-dup* { @@ -3069,6 +3080,7 @@ func LoadNS() { if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_print_DASH_length_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_print_DASH_length_STAR_.SetDynamic() } // *print-level* { @@ -3077,6 +3089,7 @@ func LoadNS() { if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_print_DASH_level_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_print_DASH_level_STAR_.SetDynamic() } // *print-meta* { @@ -3093,6 +3106,7 @@ func LoadNS() { if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_print_DASH_namespace_DASH_maps_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_print_DASH_namespace_DASH_maps_STAR_.SetDynamic() } // *print-readably* { @@ -3117,6 +3131,7 @@ func LoadNS() { if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_repl_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_repl_STAR_.SetDynamic() } // *unchecked-math* { @@ -3133,6 +3148,7 @@ func LoadNS() { if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_verbose_DASH_defrecords_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_verbose_DASH_defrecords_STAR_.SetDynamic() } // *warn-on-reflection* { @@ -3239,7 +3255,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -3267,7 +3283,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -3295,7 +3311,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -3349,6 +3365,7 @@ func LoadNS() { if tmp0.Meta() != nil { var_glojure_DOT_core_assert_DASH_valid_DASH_fdecl.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core_assert_DASH_valid_DASH_fdecl.SetDynamic() } // bit-clear { @@ -3665,7 +3682,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -3688,7 +3705,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -3819,7 +3836,7 @@ func LoadNS() { tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v4 any = lang.NewList(args[0:]...) _ = v4 return v2 @@ -3885,7 +3902,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 tmp3 := lang.Apply(lang.CreatePersistentStructMapSlotMap, []any{v2}) @@ -4445,7 +4462,7 @@ func LoadNS() { } return tmp4 default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 tmp3 := lang.Apply(lang.CreatePersistentHashMap, []any{v2}) @@ -4490,7 +4507,7 @@ func LoadNS() { } return tmp4 default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 tmp3 := lang.Apply(nil, []any{v2}) @@ -6534,7 +6551,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 tmp3 := lang.Apply(lang.CreatePersistentTreeMap, []any{v2}) @@ -6554,7 +6571,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -6576,7 +6593,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 tmp3 := lang.Apply(lang.CreatePersistentTreeSet, []any{v2}) @@ -6596,7 +6613,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -6731,7 +6748,7 @@ func LoadNS() { } return tmp4 default: - checkArity(args, 1) + checkArityGTE(args, 1) v3 := args[0] _ = v3 var v4 any = lang.NewList(args[1:]...) @@ -6963,7 +6980,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -6985,7 +7002,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -7040,7 +7057,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -7068,7 +7085,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -7685,7 +7702,7 @@ func LoadNS() { } return tmp10 default: - checkArity(args, 6) + checkArityGTE(args, 6) v2 := args[0] _ = v2 v3 := args[1] @@ -7814,7 +7831,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -7843,7 +7860,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -8080,7 +8097,7 @@ func LoadNS() { tmp6 := lang.Apply(lang.Assoc, []any{v3, v4, v5}) return tmp6 default: - checkArity(args, 3) + checkArityGTE(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -8159,7 +8176,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -8298,7 +8315,7 @@ func LoadNS() { v3 := args[0] _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp5 := reflect.TypeOf(int32(0)) + tmp5 := reflect.TypeOf(lang.NewChar(0)) tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) return tmp6 }) @@ -8527,7 +8544,7 @@ func LoadNS() { tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) return tmp5 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -8632,7 +8649,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -8702,7 +8719,7 @@ func LoadNS() { tmp5 := lang.Apply(lang.Conj, []any{v3, v4}) return tmp5 default: - checkArity(args, 2) + checkArityGTE(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -9002,7 +9019,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 4) + checkArityGTE(args, 4) v2 := args[0] _ = v2 v3 := args[1] @@ -9057,7 +9074,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -9203,7 +9220,7 @@ func LoadNS() { } return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -9272,7 +9289,7 @@ func LoadNS() { tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -9339,7 +9356,7 @@ func LoadNS() { tmp5 := lang.Apply(tmp4, []any{v2, v3}) return tmp5 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -9399,7 +9416,7 @@ func LoadNS() { tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -9451,7 +9468,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -9530,7 +9547,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) @@ -10240,7 +10257,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) @@ -10487,7 +10504,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -11066,7 +11083,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) @@ -11296,7 +11313,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -11716,7 +11733,7 @@ func LoadNS() { tmp11 := lang.Apply(tmp6, []any{v2, tmp10}) return tmp11 default: - checkArity(args, 4) + checkArityGTE(args, 4) v2 := args[0] _ = v2 v3 := args[1] @@ -11818,7 +11835,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) @@ -12484,7 +12501,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -13442,7 +13459,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -13867,7 +13884,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) @@ -14417,7 +14434,7 @@ func LoadNS() { } // end let return tmp8 default: - checkArity(args, 3) + checkArityGTE(args, 3) v5 := args[0] _ = v5 v6 := args[1] @@ -14614,7 +14631,7 @@ func LoadNS() { } // end let return tmp9 default: - checkArity(args, 3) + checkArityGTE(args, 3) v6 := args[0] _ = v6 v7 := args[1] @@ -14924,7 +14941,7 @@ func LoadNS() { } // end let return tmp10 default: - checkArity(args, 3) + checkArityGTE(args, 3) v7 := args[0] _ = v7 v8 := args[1] @@ -15003,7 +15020,7 @@ func LoadNS() { } return tmp7 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -15132,7 +15149,7 @@ func LoadNS() { tmp19 := lang.Apply(tmp15, []any{tmp18, v9}) return tmp19 default: - checkArity(args, 3) + checkArityGTE(args, 3) v12 := args[0] _ = v12 v13 := args[1] @@ -15438,7 +15455,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 tmp3 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) @@ -16732,7 +16749,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 4) + checkArityGTE(args, 4) v2 := args[0] _ = v2 v3 := args[1] @@ -17041,7 +17058,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -17129,7 +17146,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -17237,7 +17254,7 @@ func LoadNS() { tmp15 := lang.Apply(tmp6, []any{tmp14}) return tmp15 default: - checkArity(args, 4) + checkArityGTE(args, 4) v2 := args[0] _ = v2 v3 := args[1] @@ -17321,7 +17338,7 @@ func LoadNS() { tmp5 := lang.Apply(lang.Equiv, []any{v3, v4}) return tmp5 default: - checkArity(args, 2) + checkArityGTE(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -17422,7 +17439,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 default: - checkArity(args, 2) + checkArityGTE(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -17525,7 +17542,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 default: - checkArity(args, 2) + checkArityGTE(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -17628,7 +17645,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 default: - checkArity(args, 2) + checkArityGTE(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -17731,7 +17748,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 default: - checkArity(args, 2) + checkArityGTE(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -17834,7 +17851,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 default: - checkArity(args, 2) + checkArityGTE(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -17963,7 +17980,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -18080,7 +18097,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -18183,7 +18200,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -18300,7 +18317,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -18403,7 +18420,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -18519,7 +18536,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -18622,7 +18639,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -18739,7 +18756,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -18842,7 +18859,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -18959,7 +18976,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -19230,7 +19247,7 @@ func LoadNS() { tmp9 := lang.Apply(lang.Apply, []any{v2, tmp8}) return tmp9 default: - checkArity(args, 5) + checkArityGTE(args, 5) v2 := args[0] _ = v2 v3 := args[1] @@ -19396,7 +19413,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 tmp3 := checkDerefVar(var_glojure_DOT_core_into_DASH_array) @@ -19576,7 +19593,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -20145,7 +20162,7 @@ func LoadNS() { tmp11 := lang.Apply(v2, []any{v7, v8, v9}) return tmp11 default: - checkArity(args, 3) + checkArityGTE(args, 3) v7 := args[0] _ = v7 v8 := args[1] @@ -20258,7 +20275,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -20368,7 +20385,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -20471,7 +20488,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -20581,7 +20598,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -20735,7 +20752,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -20845,7 +20862,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -21062,7 +21079,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -21172,7 +21189,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -21252,7 +21269,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) @@ -21368,7 +21385,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -21405,7 +21422,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 tmp3 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) @@ -21636,7 +21653,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) @@ -21850,7 +21867,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) @@ -22009,7 +22026,7 @@ func LoadNS() { tmp9 := lang.Apply(v2, []any{tmp8}) return tmp9 default: - checkArity(args, 3) + checkArityGTE(args, 3) v5 := args[0] _ = v5 v6 := args[1] @@ -22031,7 +22048,7 @@ func LoadNS() { } return tmp6 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -22132,7 +22149,7 @@ func LoadNS() { tmp8 := lang.Apply(tmp6, []any{tmp7}) return tmp8 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -22391,7 +22408,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -22521,7 +22538,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -22809,7 +22826,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -23086,7 +23103,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -23198,7 +23215,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -23731,7 +23748,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -24369,7 +24386,7 @@ func LoadNS() { tmp10 := lang.Apply(tmp8, []any{tmp9}) return tmp10 default: - checkArity(args, 3) + checkArityGTE(args, 3) v5 := args[0] _ = v5 v6 := args[1] @@ -24574,7 +24591,7 @@ func LoadNS() { tmp11 := lang.Apply(tmp9, []any{tmp10}) return tmp11 default: - checkArity(args, 3) + checkArityGTE(args, 3) v6 := args[0] _ = v6 v7 := args[1] @@ -24892,7 +24909,7 @@ func LoadNS() { tmp12 := lang.Apply(tmp10, []any{tmp11}) return tmp12 default: - checkArity(args, 3) + checkArityGTE(args, 3) v7 := args[0] _ = v7 v8 := args[1] @@ -24973,7 +24990,7 @@ func LoadNS() { } return tmp7 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -25102,7 +25119,7 @@ func LoadNS() { tmp19 := lang.Apply(tmp15, []any{tmp18, v9}) return tmp19 default: - checkArity(args, 3) + checkArityGTE(args, 3) v12 := args[0] _ = v12 v13 := args[1] @@ -25476,7 +25493,7 @@ func LoadNS() { tmp11 := lang.Apply(v2, []any{tmp8, v6, v7}) return tmp11 default: - checkArity(args, 3) + checkArityGTE(args, 3) v5 := args[0] _ = v5 v6 := args[1] @@ -25563,7 +25580,7 @@ func LoadNS() { tmp15 := lang.Apply(v2, []any{tmp9, tmp12, v8}) return tmp15 default: - checkArity(args, 3) + checkArityGTE(args, 3) v6 := args[0] _ = v6 v7 := args[1] @@ -25668,7 +25685,7 @@ func LoadNS() { tmp19 := lang.Apply(v2, []any{tmp10, tmp13, tmp16}) return tmp19 default: - checkArity(args, 3) + checkArityGTE(args, 3) v7 := args[0] _ = v7 v8 := args[1] @@ -25730,7 +25747,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -25753,7 +25770,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -25948,7 +25965,7 @@ func LoadNS() { tmp17 := lang.Apply(tmp6, []any{tmp16}) return tmp17 default: - checkArity(args, 5) + checkArityGTE(args, 5) v2 := args[0] _ = v2 v3 := args[1] @@ -26118,7 +26135,7 @@ func LoadNS() { tmp17 := lang.Apply(tmp6, []any{tmp16}) return tmp17 default: - checkArity(args, 5) + checkArityGTE(args, 5) v2 := args[0] _ = v2 v3 := args[1] @@ -26365,7 +26382,7 @@ func LoadNS() { } return tmp10 default: - checkArity(args, 3) + checkArityGTE(args, 3) v4 := args[0] _ = v4 v5 := args[1] @@ -26452,7 +26469,7 @@ func LoadNS() { } return tmp12 default: - checkArity(args, 3) + checkArityGTE(args, 3) v5 := args[0] _ = v5 v6 := args[1] @@ -26547,7 +26564,7 @@ func LoadNS() { } return tmp14 default: - checkArity(args, 3) + checkArityGTE(args, 3) v6 := args[0] _ = v6 v7 := args[1] @@ -26578,7 +26595,7 @@ func LoadNS() { } return tmp7 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -26718,7 +26735,7 @@ func LoadNS() { tmp21 := lang.Apply(tmp14, []any{tmp17, tmp20, v9}) return tmp21 default: - checkArity(args, 3) + checkArityGTE(args, 3) v11 := args[0] _ = v11 v12 := args[1] @@ -27006,7 +27023,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -27039,7 +27056,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -27175,7 +27192,7 @@ func LoadNS() { tmp9 := lang.Apply(v4, []any{v6, tmp8}) return tmp9 default: - checkArity(args, 2) + checkArityGTE(args, 2) v6 := args[0] _ = v6 v7 := args[1] @@ -27462,7 +27479,7 @@ func LoadNS() { tmp7 := lang.Apply(lang.NewLazySeq, []any{tmp6}) return tmp7 default: - checkArity(args, 4) + checkArityGTE(args, 4) v2 := args[0] _ = v2 v3 := args[1] @@ -27640,7 +27657,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -27754,7 +27771,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -27806,7 +27823,7 @@ func LoadNS() { } return tmp5 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -27935,7 +27952,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -28008,7 +28025,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 var tmp3 any @@ -28072,7 +28089,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -28268,7 +28285,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -28382,7 +28399,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -28434,7 +28451,7 @@ func LoadNS() { } return tmp5 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -28709,7 +28726,7 @@ func LoadNS() { } // end let return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v5 := args[0] _ = v5 v6 := args[1] @@ -28910,7 +28927,7 @@ func LoadNS() { tmp7 := lang.Apply(closed16, []any{tmp6}) return tmp7 default: - checkArity(args, 3) + checkArityGTE(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -28967,7 +28984,7 @@ func LoadNS() { tmp7 := lang.Apply(closed16, []any{tmp6}) return tmp7 default: - checkArity(args, 3) + checkArityGTE(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -29010,7 +29027,7 @@ func LoadNS() { tmp8 := lang.Apply(tmp5, []any{tmp7}) return tmp8 default: - checkArity(args, 2) + checkArityGTE(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -29527,7 +29544,7 @@ func LoadNS() { _ = v4 return v4 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -29800,7 +29817,7 @@ func LoadNS() { tmp8 := lang.Apply(v2, []any{v3, v5, v6, v7}) return tmp8 default: - checkArity(args, 3) + checkArityGTE(args, 3) v5 := args[0] _ = v5 v6 := args[1] @@ -29855,7 +29872,7 @@ func LoadNS() { tmp9 := lang.Apply(v2, []any{v3, v4, v6, v7, v8}) return tmp9 default: - checkArity(args, 3) + checkArityGTE(args, 3) v6 := args[0] _ = v6 v7 := args[1] @@ -29912,7 +29929,7 @@ func LoadNS() { tmp10 := lang.Apply(v2, []any{v3, v4, v5, v7, v8, v9}) return tmp10 default: - checkArity(args, 3) + checkArityGTE(args, 3) v7 := args[0] _ = v7 v8 := args[1] @@ -29933,7 +29950,7 @@ func LoadNS() { } return tmp8 default: - checkArity(args, 4) + checkArityGTE(args, 4) v2 := args[0] _ = v2 v3 := args[1] @@ -29948,7 +29965,7 @@ func LoadNS() { tmp7 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v8 any = lang.NewList(args[0:]...) _ = v8 tmp9 := checkDerefVar(var_glojure_DOT_core_apply) @@ -30427,7 +30444,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -30970,7 +30987,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -31482,7 +31499,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -32037,7 +32054,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -32266,7 +32283,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -32366,7 +32383,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -32607,7 +32624,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -32915,7 +32932,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -33343,7 +33360,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -33612,7 +33629,7 @@ func LoadNS() { } // end let return tmp3 default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -33711,7 +33728,7 @@ func LoadNS() { tmp12 := lang.Apply(tmp8, []any{v2, v3, tmp11}) return tmp12 default: - checkArity(args, 6) + checkArityGTE(args, 6) v2 := args[0] _ = v2 v3 := args[1] @@ -33748,7 +33765,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -33849,7 +33866,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -33878,7 +33895,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -34012,7 +34029,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -34135,7 +34152,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -34268,7 +34285,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -34326,7 +34343,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -34376,7 +34393,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -34413,7 +34430,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -34496,7 +34513,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -34583,7 +34600,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -34726,7 +34743,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -34807,7 +34824,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -34920,7 +34937,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -35307,7 +35324,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -35423,7 +35440,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -35526,7 +35543,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -35642,7 +35659,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -35670,7 +35687,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -35796,7 +35813,7 @@ func LoadNS() { tmp5 := lang.Apply(lang.Get, []any{v3, v4}) return tmp5 default: - checkArity(args, 2) + checkArityGTE(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -36073,7 +36090,7 @@ func LoadNS() { _ = v4 return v4 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -36150,7 +36167,7 @@ func LoadNS() { } return tmp3 default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 var tmp3 any @@ -36250,7 +36267,7 @@ func LoadNS() { _ = tmp6 return v5 default: - checkArity(args, 3) + checkArityGTE(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -36296,7 +36313,7 @@ func LoadNS() { _ = tmp8 return v4 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -36342,7 +36359,7 @@ func LoadNS() { _ = tmp8 return v4 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -36388,7 +36405,7 @@ func LoadNS() { _ = tmp8 return v4 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -36434,7 +36451,7 @@ func LoadNS() { _ = tmp8 return v4 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -36480,7 +36497,7 @@ func LoadNS() { _ = tmp8 return v4 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -36526,7 +36543,7 @@ func LoadNS() { _ = tmp8 return v4 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -36572,7 +36589,7 @@ func LoadNS() { _ = tmp8 return v4 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -36618,7 +36635,7 @@ func LoadNS() { _ = tmp8 return v4 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -36653,7 +36670,7 @@ func LoadNS() { tmp3 := lang.Apply(lang.NewAtom, []any{v2}) return tmp3 default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -36678,7 +36695,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -36879,7 +36896,7 @@ func LoadNS() { tmp7 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v8 any = lang.NewList(args[0:]...) _ = v8 tmp9 := checkDerefVar(var_glojure_DOT_core_apply) @@ -36945,7 +36962,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -37034,7 +37051,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -37178,7 +37195,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -37449,7 +37466,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -37776,7 +37793,7 @@ func LoadNS() { tmp8 := lang.Apply(tmp5, []any{tmp7}) return tmp8 default: - checkArity(args, 2) + checkArityGTE(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -37951,7 +37968,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -38587,7 +38604,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -39000,7 +39017,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -39058,7 +39075,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -39429,7 +39446,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -39658,7 +39675,7 @@ func LoadNS() { tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) return tmp5 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -40087,7 +40104,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -40132,7 +40149,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -40431,7 +40448,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v2, tmp5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -40889,7 +40906,7 @@ func LoadNS() { tmp10 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v11 any = lang.NewList(args[0:]...) _ = v11 var tmp12 any @@ -40956,7 +40973,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -41856,7 +41873,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 tmp3 := checkDerefVar(var_glojure_DOT_core_pmap) @@ -42270,7 +42287,7 @@ func LoadNS() { tmp3 := lang.Apply(lang.NewRef, []any{v2}) return tmp3 default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -42588,7 +42605,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -42614,7 +42631,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -42973,7 +42990,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -43091,7 +43108,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -43309,7 +43326,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -43772,7 +43789,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 4) + checkArityGTE(args, 4) v2 := args[0] _ = v2 v3 := args[1] @@ -43836,7 +43853,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 var tmp3 any @@ -44071,7 +44088,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -44358,7 +44375,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -44487,7 +44504,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -44616,7 +44633,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 4) + checkArityGTE(args, 4) v2 := args[0] _ = v2 v3 := args[1] @@ -45654,7 +45671,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -45750,7 +45767,7 @@ func LoadNS() { tmp51 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v52 := args[0] _ = v52 var v53 any = lang.NewList(args[1:]...) @@ -45902,7 +45919,7 @@ func LoadNS() { tmp63 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v64 := args[0] _ = v64 var v65 any = lang.NewList(args[1:]...) @@ -46109,7 +46126,7 @@ func LoadNS() { tmp37 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v38 any = lang.NewList(args[0:]...) _ = v38 tmp39 := checkDerefVar(var_glojure_DOT_core_apply) @@ -47183,7 +47200,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -47254,7 +47271,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -47523,7 +47540,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -48138,7 +48155,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp3, []any{tmp5, tmp6}) return tmp7 default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -48822,7 +48839,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -49897,7 +49914,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -50123,7 +50140,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 var tmp3 any @@ -50843,7 +50860,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -51402,7 +51419,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 var tmp3 any @@ -51971,7 +51988,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 tmp3 := checkDerefVar(var_glojure_DOT_core_apply) @@ -51993,7 +52010,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 var tmp3 any @@ -52043,7 +52060,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 tmp3 := checkDerefVar(var_glojure_DOT_core_apply) @@ -52189,7 +52206,7 @@ func LoadNS() { tmp12 := lang.Apply(tmp6, []any{tmp9, tmp11}) return tmp12 default: - checkArity(args, 4) + checkArityGTE(args, 4) v2 := args[0] _ = v2 v3 := args[1] @@ -52291,7 +52308,7 @@ func LoadNS() { tmp5 := lang.Apply(tmp3, []any{v2, tmp4}) return tmp5 default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -52342,6 +52359,7 @@ func LoadNS() { if tmp0.Meta() != nil { var_glojure_DOT_core_pr.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core_pr.SetDynamic() } // pr-str { @@ -52351,7 +52369,7 @@ func LoadNS() { tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 var tmp4 any @@ -52403,7 +52421,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 var tmp3 any @@ -52445,7 +52463,7 @@ func LoadNS() { tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 var tmp4 any @@ -52497,7 +52515,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -52523,7 +52541,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 tmp3 := checkDerefVar(var_glojure_DOT_core_apply) @@ -52558,7 +52576,7 @@ func LoadNS() { tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 var tmp4 any @@ -52610,7 +52628,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 var tmp3 any @@ -52652,7 +52670,7 @@ func LoadNS() { tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 var tmp4 any @@ -52889,6 +52907,7 @@ func LoadNS() { return tmp6 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3667), kw_column, int(21), kw_end_DASH_line, int(3667), kw_end_DASH_column, int(45))).(lang.FnFunc) + // MultiFn print-dup tmp1 := lang.NewMultiFn("print-dup", tmp2, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { @@ -53103,7 +53122,7 @@ func LoadNS() { return tmp40 }) tmp1.AddMethod(tmp24, tmp25) - tmp26 := reflect.TypeOf(int32(0)) + tmp26 := reflect.TypeOf(lang.NewChar(0)) var tmp27 lang.FnFunc tmp27 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 2) @@ -53385,6 +53404,7 @@ func LoadNS() { return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3664), kw_column, int(24), kw_end_DASH_line, int(3666), kw_end_DASH_column, int(58))).(lang.FnFunc) + // MultiFn print-method tmp1 := lang.NewMultiFn("print-method", tmp2, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { @@ -53690,7 +53710,7 @@ func LoadNS() { return nil }) tmp1.AddMethod(tmp19, tmp20) - tmp21 := reflect.TypeOf(int32(0)) + tmp21 := reflect.TypeOf(lang.NewChar(0)) var tmp22 lang.FnFunc tmp22 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 2) @@ -55536,7 +55556,7 @@ func LoadNS() { tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v3 := args[0] _ = v3 var v4 any = lang.NewList(args[1:]...) diff --git a/pkg/stdlib/glojure/core_print/loader.go b/pkg/stdlib/glojure/core_print/loader.go index 483d1311..2d2630fa 100644 --- a/pkg/stdlib/glojure/core_print/loader.go +++ b/pkg/stdlib/glojure/core_print/loader.go @@ -37,6 +37,12 @@ func checkArity(args []any, expected int) { } } +func checkArityGTE(args []any, min int) { + if len(args) < min { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + // LoadNS initializes the namespace "glojure.core" func LoadNS() { sym__PCT_ := lang.NewSymbol("%") @@ -3079,6 +3085,7 @@ func LoadNS() { if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_data_DASH_readers_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_data_DASH_readers_STAR_.SetDynamic() } // *default-data-reader-fn* { @@ -3087,6 +3094,7 @@ func LoadNS() { if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_default_DASH_data_DASH_reader_DASH_fn_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_default_DASH_data_DASH_reader_DASH_fn_STAR_.SetDynamic() } // *e { @@ -3128,6 +3136,7 @@ func LoadNS() { if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_.SetDynamic() } // *loading-verbosely* { @@ -3136,6 +3145,7 @@ func LoadNS() { if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_.SetDynamic() } // *ns* { @@ -3152,6 +3162,7 @@ func LoadNS() { if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_.SetDynamic() } // *print-dup* { @@ -3168,6 +3179,7 @@ func LoadNS() { if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_print_DASH_length_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_print_DASH_length_STAR_.SetDynamic() } // *print-level* { @@ -3176,6 +3188,7 @@ func LoadNS() { if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_print_DASH_level_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_print_DASH_level_STAR_.SetDynamic() } // *print-meta* { @@ -3192,6 +3205,7 @@ func LoadNS() { if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_print_DASH_namespace_DASH_maps_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_print_DASH_namespace_DASH_maps_STAR_.SetDynamic() } // *print-readably* { @@ -3216,6 +3230,7 @@ func LoadNS() { if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_repl_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_repl_STAR_.SetDynamic() } // *unchecked-math* { @@ -3232,6 +3247,7 @@ func LoadNS() { if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_verbose_DASH_defrecords_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_verbose_DASH_defrecords_STAR_.SetDynamic() } // *warn-on-reflection* { @@ -3338,7 +3354,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -3366,7 +3382,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -3394,7 +3410,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -3448,6 +3464,7 @@ func LoadNS() { if tmp0.Meta() != nil { var_glojure_DOT_core_assert_DASH_valid_DASH_fdecl.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core_assert_DASH_valid_DASH_fdecl.SetDynamic() } // bit-clear { @@ -3764,7 +3781,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -3787,7 +3804,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -3918,7 +3935,7 @@ func LoadNS() { tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v4 any = lang.NewList(args[0:]...) _ = v4 return v2 @@ -3984,7 +4001,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 tmp3 := lang.Apply(lang.CreatePersistentStructMapSlotMap, []any{v2}) @@ -4544,7 +4561,7 @@ func LoadNS() { } return tmp4 default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 tmp3 := lang.Apply(lang.CreatePersistentHashMap, []any{v2}) @@ -4589,7 +4606,7 @@ func LoadNS() { } return tmp4 default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 tmp3 := lang.Apply(nil, []any{v2}) @@ -6633,7 +6650,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 tmp3 := lang.Apply(lang.CreatePersistentTreeMap, []any{v2}) @@ -6653,7 +6670,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -6675,7 +6692,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 tmp3 := lang.Apply(lang.CreatePersistentTreeSet, []any{v2}) @@ -6695,7 +6712,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -6830,7 +6847,7 @@ func LoadNS() { } return tmp4 default: - checkArity(args, 1) + checkArityGTE(args, 1) v3 := args[0] _ = v3 var v4 any = lang.NewList(args[1:]...) @@ -7062,7 +7079,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -7084,7 +7101,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -7139,7 +7156,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -7167,7 +7184,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -7784,7 +7801,7 @@ func LoadNS() { } return tmp10 default: - checkArity(args, 6) + checkArityGTE(args, 6) v2 := args[0] _ = v2 v3 := args[1] @@ -7913,7 +7930,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -7942,7 +7959,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -8179,7 +8196,7 @@ func LoadNS() { tmp6 := lang.Apply(lang.Assoc, []any{v3, v4, v5}) return tmp6 default: - checkArity(args, 3) + checkArityGTE(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -8258,7 +8275,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -8397,7 +8414,7 @@ func LoadNS() { v3 := args[0] _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) - tmp5 := reflect.TypeOf(int32(0)) + tmp5 := reflect.TypeOf(lang.NewChar(0)) tmp6 := lang.Apply(tmp4, []any{tmp5, v3}) return tmp6 }) @@ -8626,7 +8643,7 @@ func LoadNS() { tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) return tmp5 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -8731,7 +8748,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -8801,7 +8818,7 @@ func LoadNS() { tmp5 := lang.Apply(lang.Conj, []any{v3, v4}) return tmp5 default: - checkArity(args, 2) + checkArityGTE(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -9101,7 +9118,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 4) + checkArityGTE(args, 4) v2 := args[0] _ = v2 v3 := args[1] @@ -9156,7 +9173,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -9302,7 +9319,7 @@ func LoadNS() { } return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -9371,7 +9388,7 @@ func LoadNS() { tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -9438,7 +9455,7 @@ func LoadNS() { tmp5 := lang.Apply(tmp4, []any{v2, v3}) return tmp5 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -9498,7 +9515,7 @@ func LoadNS() { tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -9550,7 +9567,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -9629,7 +9646,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) @@ -10339,7 +10356,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) @@ -10586,7 +10603,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -11165,7 +11182,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) @@ -11395,7 +11412,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -11815,7 +11832,7 @@ func LoadNS() { tmp11 := lang.Apply(tmp6, []any{v2, tmp10}) return tmp11 default: - checkArity(args, 4) + checkArityGTE(args, 4) v2 := args[0] _ = v2 v3 := args[1] @@ -11917,7 +11934,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) @@ -12583,7 +12600,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -13541,7 +13558,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -13966,7 +13983,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) @@ -14516,7 +14533,7 @@ func LoadNS() { } // end let return tmp8 default: - checkArity(args, 3) + checkArityGTE(args, 3) v5 := args[0] _ = v5 v6 := args[1] @@ -14713,7 +14730,7 @@ func LoadNS() { } // end let return tmp9 default: - checkArity(args, 3) + checkArityGTE(args, 3) v6 := args[0] _ = v6 v7 := args[1] @@ -15023,7 +15040,7 @@ func LoadNS() { } // end let return tmp10 default: - checkArity(args, 3) + checkArityGTE(args, 3) v7 := args[0] _ = v7 v8 := args[1] @@ -15102,7 +15119,7 @@ func LoadNS() { } return tmp7 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -15231,7 +15248,7 @@ func LoadNS() { tmp19 := lang.Apply(tmp15, []any{tmp18, v9}) return tmp19 default: - checkArity(args, 3) + checkArityGTE(args, 3) v12 := args[0] _ = v12 v13 := args[1] @@ -15537,7 +15554,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 tmp3 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) @@ -16831,7 +16848,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 4) + checkArityGTE(args, 4) v2 := args[0] _ = v2 v3 := args[1] @@ -17140,7 +17157,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -17228,7 +17245,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -17336,7 +17353,7 @@ func LoadNS() { tmp15 := lang.Apply(tmp6, []any{tmp14}) return tmp15 default: - checkArity(args, 4) + checkArityGTE(args, 4) v2 := args[0] _ = v2 v3 := args[1] @@ -17420,7 +17437,7 @@ func LoadNS() { tmp5 := lang.Apply(lang.Equiv, []any{v3, v4}) return tmp5 default: - checkArity(args, 2) + checkArityGTE(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -17521,7 +17538,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 default: - checkArity(args, 2) + checkArityGTE(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -17624,7 +17641,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 default: - checkArity(args, 2) + checkArityGTE(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -17727,7 +17744,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 default: - checkArity(args, 2) + checkArityGTE(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -17830,7 +17847,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 default: - checkArity(args, 2) + checkArityGTE(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -17933,7 +17950,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 default: - checkArity(args, 2) + checkArityGTE(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -18062,7 +18079,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -18179,7 +18196,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -18282,7 +18299,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -18399,7 +18416,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -18502,7 +18519,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -18618,7 +18635,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -18721,7 +18738,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -18838,7 +18855,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -18941,7 +18958,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -19058,7 +19075,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -19329,7 +19346,7 @@ func LoadNS() { tmp9 := lang.Apply(lang.Apply, []any{v2, tmp8}) return tmp9 default: - checkArity(args, 5) + checkArityGTE(args, 5) v2 := args[0] _ = v2 v3 := args[1] @@ -19495,7 +19512,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 tmp3 := checkDerefVar(var_glojure_DOT_core_into_DASH_array) @@ -19675,7 +19692,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -20244,7 +20261,7 @@ func LoadNS() { tmp11 := lang.Apply(v2, []any{v7, v8, v9}) return tmp11 default: - checkArity(args, 3) + checkArityGTE(args, 3) v7 := args[0] _ = v7 v8 := args[1] @@ -20357,7 +20374,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -20467,7 +20484,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -20570,7 +20587,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -20680,7 +20697,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -20834,7 +20851,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -20944,7 +20961,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -21161,7 +21178,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -21271,7 +21288,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -21351,7 +21368,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) @@ -21467,7 +21484,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -21504,7 +21521,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 tmp3 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) @@ -21735,7 +21752,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) @@ -21949,7 +21966,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) @@ -22108,7 +22125,7 @@ func LoadNS() { tmp9 := lang.Apply(v2, []any{tmp8}) return tmp9 default: - checkArity(args, 3) + checkArityGTE(args, 3) v5 := args[0] _ = v5 v6 := args[1] @@ -22130,7 +22147,7 @@ func LoadNS() { } return tmp6 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -22231,7 +22248,7 @@ func LoadNS() { tmp8 := lang.Apply(tmp6, []any{tmp7}) return tmp8 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -22490,7 +22507,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -22620,7 +22637,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -22908,7 +22925,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -23185,7 +23202,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -23297,7 +23314,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -23830,7 +23847,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -24468,7 +24485,7 @@ func LoadNS() { tmp10 := lang.Apply(tmp8, []any{tmp9}) return tmp10 default: - checkArity(args, 3) + checkArityGTE(args, 3) v5 := args[0] _ = v5 v6 := args[1] @@ -24673,7 +24690,7 @@ func LoadNS() { tmp11 := lang.Apply(tmp9, []any{tmp10}) return tmp11 default: - checkArity(args, 3) + checkArityGTE(args, 3) v6 := args[0] _ = v6 v7 := args[1] @@ -24991,7 +25008,7 @@ func LoadNS() { tmp12 := lang.Apply(tmp10, []any{tmp11}) return tmp12 default: - checkArity(args, 3) + checkArityGTE(args, 3) v7 := args[0] _ = v7 v8 := args[1] @@ -25072,7 +25089,7 @@ func LoadNS() { } return tmp7 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -25201,7 +25218,7 @@ func LoadNS() { tmp19 := lang.Apply(tmp15, []any{tmp18, v9}) return tmp19 default: - checkArity(args, 3) + checkArityGTE(args, 3) v12 := args[0] _ = v12 v13 := args[1] @@ -25575,7 +25592,7 @@ func LoadNS() { tmp11 := lang.Apply(v2, []any{tmp8, v6, v7}) return tmp11 default: - checkArity(args, 3) + checkArityGTE(args, 3) v5 := args[0] _ = v5 v6 := args[1] @@ -25662,7 +25679,7 @@ func LoadNS() { tmp15 := lang.Apply(v2, []any{tmp9, tmp12, v8}) return tmp15 default: - checkArity(args, 3) + checkArityGTE(args, 3) v6 := args[0] _ = v6 v7 := args[1] @@ -25767,7 +25784,7 @@ func LoadNS() { tmp19 := lang.Apply(v2, []any{tmp10, tmp13, tmp16}) return tmp19 default: - checkArity(args, 3) + checkArityGTE(args, 3) v7 := args[0] _ = v7 v8 := args[1] @@ -25829,7 +25846,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -25852,7 +25869,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -26047,7 +26064,7 @@ func LoadNS() { tmp17 := lang.Apply(tmp6, []any{tmp16}) return tmp17 default: - checkArity(args, 5) + checkArityGTE(args, 5) v2 := args[0] _ = v2 v3 := args[1] @@ -26217,7 +26234,7 @@ func LoadNS() { tmp17 := lang.Apply(tmp6, []any{tmp16}) return tmp17 default: - checkArity(args, 5) + checkArityGTE(args, 5) v2 := args[0] _ = v2 v3 := args[1] @@ -26464,7 +26481,7 @@ func LoadNS() { } return tmp10 default: - checkArity(args, 3) + checkArityGTE(args, 3) v4 := args[0] _ = v4 v5 := args[1] @@ -26551,7 +26568,7 @@ func LoadNS() { } return tmp12 default: - checkArity(args, 3) + checkArityGTE(args, 3) v5 := args[0] _ = v5 v6 := args[1] @@ -26646,7 +26663,7 @@ func LoadNS() { } return tmp14 default: - checkArity(args, 3) + checkArityGTE(args, 3) v6 := args[0] _ = v6 v7 := args[1] @@ -26677,7 +26694,7 @@ func LoadNS() { } return tmp7 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -26817,7 +26834,7 @@ func LoadNS() { tmp21 := lang.Apply(tmp14, []any{tmp17, tmp20, v9}) return tmp21 default: - checkArity(args, 3) + checkArityGTE(args, 3) v11 := args[0] _ = v11 v12 := args[1] @@ -27105,7 +27122,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -27138,7 +27155,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -27274,7 +27291,7 @@ func LoadNS() { tmp9 := lang.Apply(v4, []any{v6, tmp8}) return tmp9 default: - checkArity(args, 2) + checkArityGTE(args, 2) v6 := args[0] _ = v6 v7 := args[1] @@ -27561,7 +27578,7 @@ func LoadNS() { tmp7 := lang.Apply(lang.NewLazySeq, []any{tmp6}) return tmp7 default: - checkArity(args, 4) + checkArityGTE(args, 4) v2 := args[0] _ = v2 v3 := args[1] @@ -27739,7 +27756,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -27853,7 +27870,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -27905,7 +27922,7 @@ func LoadNS() { } return tmp5 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -28034,7 +28051,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -28107,7 +28124,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 var tmp3 any @@ -28171,7 +28188,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -28367,7 +28384,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -28481,7 +28498,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -28533,7 +28550,7 @@ func LoadNS() { } return tmp5 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -28808,7 +28825,7 @@ func LoadNS() { } // end let return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v5 := args[0] _ = v5 v6 := args[1] @@ -29009,7 +29026,7 @@ func LoadNS() { tmp7 := lang.Apply(closed24, []any{tmp6}) return tmp7 default: - checkArity(args, 3) + checkArityGTE(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -29066,7 +29083,7 @@ func LoadNS() { tmp7 := lang.Apply(closed24, []any{tmp6}) return tmp7 default: - checkArity(args, 3) + checkArityGTE(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -29109,7 +29126,7 @@ func LoadNS() { tmp8 := lang.Apply(tmp5, []any{tmp7}) return tmp8 default: - checkArity(args, 2) + checkArityGTE(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -29626,7 +29643,7 @@ func LoadNS() { _ = v4 return v4 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -29899,7 +29916,7 @@ func LoadNS() { tmp8 := lang.Apply(v2, []any{v3, v5, v6, v7}) return tmp8 default: - checkArity(args, 3) + checkArityGTE(args, 3) v5 := args[0] _ = v5 v6 := args[1] @@ -29954,7 +29971,7 @@ func LoadNS() { tmp9 := lang.Apply(v2, []any{v3, v4, v6, v7, v8}) return tmp9 default: - checkArity(args, 3) + checkArityGTE(args, 3) v6 := args[0] _ = v6 v7 := args[1] @@ -30011,7 +30028,7 @@ func LoadNS() { tmp10 := lang.Apply(v2, []any{v3, v4, v5, v7, v8, v9}) return tmp10 default: - checkArity(args, 3) + checkArityGTE(args, 3) v7 := args[0] _ = v7 v8 := args[1] @@ -30032,7 +30049,7 @@ func LoadNS() { } return tmp8 default: - checkArity(args, 4) + checkArityGTE(args, 4) v2 := args[0] _ = v2 v3 := args[1] @@ -30047,7 +30064,7 @@ func LoadNS() { tmp7 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v8 any = lang.NewList(args[0:]...) _ = v8 tmp9 := checkDerefVar(var_glojure_DOT_core_apply) @@ -30526,7 +30543,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -31069,7 +31086,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -31581,7 +31598,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -32136,7 +32153,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -32365,7 +32382,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -32465,7 +32482,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -32706,7 +32723,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -33014,7 +33031,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -33442,7 +33459,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -33711,7 +33728,7 @@ func LoadNS() { } // end let return tmp3 default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -33810,7 +33827,7 @@ func LoadNS() { tmp12 := lang.Apply(tmp8, []any{v2, v3, tmp11}) return tmp12 default: - checkArity(args, 6) + checkArityGTE(args, 6) v2 := args[0] _ = v2 v3 := args[1] @@ -33847,7 +33864,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -33948,7 +33965,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -33977,7 +33994,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -34111,7 +34128,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -34234,7 +34251,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -34367,7 +34384,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -34425,7 +34442,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -34475,7 +34492,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -34512,7 +34529,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -34595,7 +34612,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -34682,7 +34699,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -34825,7 +34842,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -34906,7 +34923,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -35019,7 +35036,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -35406,7 +35423,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -35522,7 +35539,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -35625,7 +35642,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -35741,7 +35758,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -35769,7 +35786,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -35895,7 +35912,7 @@ func LoadNS() { tmp5 := lang.Apply(lang.Get, []any{v3, v4}) return tmp5 default: - checkArity(args, 2) + checkArityGTE(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -36172,7 +36189,7 @@ func LoadNS() { _ = v4 return v4 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -36249,7 +36266,7 @@ func LoadNS() { } return tmp3 default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 var tmp3 any @@ -36349,7 +36366,7 @@ func LoadNS() { _ = tmp6 return v5 default: - checkArity(args, 3) + checkArityGTE(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -36395,7 +36412,7 @@ func LoadNS() { _ = tmp8 return v4 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -36441,7 +36458,7 @@ func LoadNS() { _ = tmp8 return v4 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -36487,7 +36504,7 @@ func LoadNS() { _ = tmp8 return v4 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -36533,7 +36550,7 @@ func LoadNS() { _ = tmp8 return v4 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -36579,7 +36596,7 @@ func LoadNS() { _ = tmp8 return v4 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -36625,7 +36642,7 @@ func LoadNS() { _ = tmp8 return v4 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -36671,7 +36688,7 @@ func LoadNS() { _ = tmp8 return v4 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -36717,7 +36734,7 @@ func LoadNS() { _ = tmp8 return v4 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -36752,7 +36769,7 @@ func LoadNS() { tmp3 := lang.Apply(lang.NewAtom, []any{v2}) return tmp3 default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -36777,7 +36794,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -36978,7 +36995,7 @@ func LoadNS() { tmp7 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v8 any = lang.NewList(args[0:]...) _ = v8 tmp9 := checkDerefVar(var_glojure_DOT_core_apply) @@ -37044,7 +37061,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -37133,7 +37150,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -37277,7 +37294,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -37548,7 +37565,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -37875,7 +37892,7 @@ func LoadNS() { tmp8 := lang.Apply(tmp5, []any{tmp7}) return tmp8 default: - checkArity(args, 2) + checkArityGTE(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -38050,7 +38067,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -38686,7 +38703,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -39099,7 +39116,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -39157,7 +39174,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -39528,7 +39545,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -39757,7 +39774,7 @@ func LoadNS() { tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) return tmp5 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -40186,7 +40203,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -40231,7 +40248,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -40530,7 +40547,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v2, tmp5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -40988,7 +41005,7 @@ func LoadNS() { tmp10 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v11 any = lang.NewList(args[0:]...) _ = v11 var tmp12 any @@ -41055,7 +41072,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -41955,7 +41972,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 tmp3 := checkDerefVar(var_glojure_DOT_core_pmap) @@ -42369,7 +42386,7 @@ func LoadNS() { tmp3 := lang.Apply(lang.NewRef, []any{v2}) return tmp3 default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -42687,7 +42704,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -42713,7 +42730,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -43072,7 +43089,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -43190,7 +43207,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -43408,7 +43425,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -43871,7 +43888,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 4) + checkArityGTE(args, 4) v2 := args[0] _ = v2 v3 := args[1] @@ -43935,7 +43952,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 var tmp3 any @@ -44170,7 +44187,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -44457,7 +44474,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -44586,7 +44603,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -44715,7 +44732,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 4) + checkArityGTE(args, 4) v2 := args[0] _ = v2 v3 := args[1] @@ -45753,7 +45770,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -45849,7 +45866,7 @@ func LoadNS() { tmp51 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v52 := args[0] _ = v52 var v53 any = lang.NewList(args[1:]...) @@ -46001,7 +46018,7 @@ func LoadNS() { tmp63 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v64 := args[0] _ = v64 var v65 any = lang.NewList(args[1:]...) @@ -46208,7 +46225,7 @@ func LoadNS() { tmp37 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v38 any = lang.NewList(args[0:]...) _ = v38 tmp39 := checkDerefVar(var_glojure_DOT_core_apply) @@ -47282,7 +47299,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -47353,7 +47370,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -47842,7 +47859,7 @@ func LoadNS() { tmp4 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v5 := args[0] _ = v5 var v6 any = lang.NewList(args[1:]...) @@ -47852,12 +47869,13 @@ func LoadNS() { return tmp8 } }) + // MultiFn coll-reduce tmp3 := lang.NewMultiFn("coll-reduce", tmp4, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) var tmp5 lang.FnFunc tmp5 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v6 := args[0] _ = v6 var v7 any = lang.NewList(args[1:]...) @@ -47875,7 +47893,7 @@ func LoadNS() { tmp7 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v8 := args[0] _ = v8 var v9 any = lang.NewList(args[1:]...) @@ -47893,7 +47911,7 @@ func LoadNS() { tmp9 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v10 := args[0] _ = v10 var v11 any = lang.NewList(args[1:]...) @@ -47911,7 +47929,7 @@ func LoadNS() { tmp11 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v12 := args[0] _ = v12 var v13 any = lang.NewList(args[1:]...) @@ -47929,7 +47947,7 @@ func LoadNS() { tmp14 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v15 := args[0] _ = v15 var v16 any = lang.NewList(args[1:]...) @@ -47939,12 +47957,13 @@ func LoadNS() { return tmp18 } }) + // MultiFn internal-reduce tmp13 := lang.NewMultiFn("internal-reduce", tmp14, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) var tmp15 lang.FnFunc tmp15 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v16 := args[0] _ = v16 var v17 any = lang.NewList(args[1:]...) @@ -47962,7 +47981,7 @@ func LoadNS() { tmp17 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v18 := args[0] _ = v18 var v19 any = lang.NewList(args[1:]...) @@ -47980,7 +47999,7 @@ func LoadNS() { tmp19 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v20 := args[0] _ = v20 var v21 any = lang.NewList(args[1:]...) @@ -47998,7 +48017,7 @@ func LoadNS() { tmp22 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v23 := args[0] _ = v23 var v24 any = lang.NewList(args[1:]...) @@ -48008,13 +48027,14 @@ func LoadNS() { return tmp26 } }) + // MultiFn kv-reduce tmp21 := lang.NewMultiFn("kv-reduce", tmp22, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) tmp20 := lang.NewAtom(lang.NewMap(kw_multis, lang.NewMap(kw_kv_DASH_reduce, tmp21), kw_on_DASH_interface, true, kw_sigs, lang.NewList(lang.NewList(sym_kv_DASH_reduce, lang.NewVector(sym_amap, sym_f, sym_init))))) var tmp25 lang.FnFunc tmp25 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v26 := args[0] _ = v26 var v27 any = lang.NewList(args[1:]...) @@ -48024,12 +48044,13 @@ func LoadNS() { return tmp29 } }) + // MultiFn datafy tmp24 := lang.NewMultiFn("datafy", tmp25, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) var tmp26 lang.FnFunc tmp26 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v27 := args[0] _ = v27 var v28 any = lang.NewList(args[1:]...) @@ -48047,7 +48068,7 @@ func LoadNS() { tmp29 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v30 := args[0] _ = v30 var v31 any = lang.NewList(args[1:]...) @@ -48057,6 +48078,7 @@ func LoadNS() { return tmp33 } }) + // MultiFn nav tmp28 := lang.NewMultiFn("nav", tmp29, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) tmp27 := lang.NewAtom(lang.NewMap(kw_multis, lang.NewMap(kw_nav, tmp28), kw_on_DASH_interface, true, kw_sigs, lang.NewList(lang.NewList(sym_nav, lang.NewVector(sym_coll, sym_k, sym_v), "return (possibly transformed) v in the context of coll and k (a key/index or nil),\ndefaults to returning v.")))) tmp1 := lang.NewAtom(lang.NewMap(sym_CollReduce, tmp2, sym_InternalReduce, tmp12, sym_IKVReduce, tmp20, sym_Datafiable, tmp23, sym_Navigable, tmp27)) @@ -48092,7 +48114,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -48707,7 +48729,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp3, []any{tmp5, tmp6}) return tmp7 default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -49391,7 +49413,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -50466,7 +50488,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -50692,7 +50714,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 var tmp3 any @@ -51412,7 +51434,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -51971,7 +51993,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 var tmp3 any @@ -52540,7 +52562,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 tmp3 := checkDerefVar(var_glojure_DOT_core_apply) @@ -52562,7 +52584,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 var tmp3 any @@ -52612,7 +52634,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 tmp3 := checkDerefVar(var_glojure_DOT_core_apply) @@ -52758,7 +52780,7 @@ func LoadNS() { tmp12 := lang.Apply(tmp6, []any{tmp9, tmp11}) return tmp12 default: - checkArity(args, 4) + checkArityGTE(args, 4) v2 := args[0] _ = v2 v3 := args[1] @@ -52860,7 +52882,7 @@ func LoadNS() { tmp5 := lang.Apply(tmp3, []any{v2, tmp4}) return tmp5 default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -52911,6 +52933,7 @@ func LoadNS() { if tmp0.Meta() != nil { var_glojure_DOT_core_pr.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core_pr.SetDynamic() } // pr-str { @@ -52920,7 +52943,7 @@ func LoadNS() { tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 var tmp4 any @@ -52972,7 +52995,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 var tmp3 any @@ -53014,7 +53037,7 @@ func LoadNS() { tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 var tmp4 any @@ -53066,7 +53089,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -53092,7 +53115,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 tmp3 := checkDerefVar(var_glojure_DOT_core_apply) @@ -53127,7 +53150,7 @@ func LoadNS() { tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 var tmp4 any @@ -53179,7 +53202,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 var tmp3 any @@ -53221,7 +53244,7 @@ func LoadNS() { tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 var tmp4 any @@ -53458,6 +53481,7 @@ func LoadNS() { return tmp6 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3667), kw_column, int(21), kw_end_DASH_line, int(3667), kw_end_DASH_column, int(45))).(lang.FnFunc) + // MultiFn print-dup tmp1 := lang.NewMultiFn("print-dup", tmp2, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { @@ -53672,7 +53696,7 @@ func LoadNS() { return tmp40 }) tmp1.AddMethod(tmp24, tmp25) - tmp26 := reflect.TypeOf(int32(0)) + tmp26 := reflect.TypeOf(lang.NewChar(0)) var tmp27 lang.FnFunc tmp27 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 2) @@ -53954,6 +53978,7 @@ func LoadNS() { return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3664), kw_column, int(24), kw_end_DASH_line, int(3666), kw_end_DASH_column, int(58))).(lang.FnFunc) + // MultiFn print-method tmp1 := lang.NewMultiFn("print-method", tmp2, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { @@ -54259,7 +54284,7 @@ func LoadNS() { return nil }) tmp1.AddMethod(tmp19, tmp20) - tmp21 := reflect.TypeOf(int32(0)) + tmp21 := reflect.TypeOf(lang.NewChar(0)) var tmp22 lang.FnFunc tmp22 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 2) @@ -56105,7 +56130,7 @@ func LoadNS() { tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v3 := args[0] _ = v3 var v4 any = lang.NewList(args[1:]...) diff --git a/pkg/stdlib/glojure/protocols/loader.go b/pkg/stdlib/glojure/protocols/loader.go index 2d6ae4e6..aae7b787 100644 --- a/pkg/stdlib/glojure/protocols/loader.go +++ b/pkg/stdlib/glojure/protocols/loader.go @@ -26,6 +26,12 @@ func checkArity(args []any, expected int) { } } +func checkArityGTE(args []any, min int) { + if len(args) < min { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + // LoadNS initializes the namespace "glojure.core.protocols" func LoadNS() { sym_CollReduce := lang.NewSymbol("CollReduce") @@ -307,7 +313,7 @@ func LoadNS() { _ = v2 v3 := args[2] _ = v3 - recur_loop_1560: + recur_loop_2815: var tmp4 any { // let // let binding "temp__0__auto__" @@ -354,7 +360,7 @@ func LoadNS() { v1 = tmp25 v2 = tmp28 v3 = tmp29 - goto recur_loop_1560 + goto recur_loop_2815 } tmp14 = tmp20 } // end let @@ -483,7 +489,7 @@ func LoadNS() { tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v4 := args[0] _ = v4 var v5 any = lang.NewList(args[1:]...) @@ -493,12 +499,13 @@ func LoadNS() { return tmp7 } }) + // MultiFn coll-reduce tmp2 := lang.NewMultiFn("coll-reduce", tmp3, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) var tmp4 lang.FnFunc tmp4 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v5 := args[0] _ = v5 var v6 any = lang.NewList(args[1:]...) @@ -516,7 +523,7 @@ func LoadNS() { tmp6 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v7 := args[0] _ = v7 var v8 any = lang.NewList(args[1:]...) @@ -534,7 +541,7 @@ func LoadNS() { tmp8 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v9 := args[0] _ = v9 var v10 any = lang.NewList(args[1:]...) @@ -552,7 +559,7 @@ func LoadNS() { tmp10 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v11 := args[0] _ = v11 var v12 any = lang.NewList(args[1:]...) @@ -578,7 +585,7 @@ func LoadNS() { tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v4 := args[0] _ = v4 var v5 any = lang.NewList(args[1:]...) @@ -588,12 +595,13 @@ func LoadNS() { return tmp7 } }) + // MultiFn datafy tmp2 := lang.NewMultiFn("datafy", tmp3, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) var tmp4 lang.FnFunc tmp4 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v5 := args[0] _ = v5 var v6 any = lang.NewList(args[1:]...) @@ -619,7 +627,7 @@ func LoadNS() { tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v4 := args[0] _ = v4 var v5 any = lang.NewList(args[1:]...) @@ -629,6 +637,7 @@ func LoadNS() { return tmp7 } }) + // MultiFn kv-reduce tmp2 := lang.NewMultiFn("kv-reduce", tmp3, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) tmp1 := lang.NewAtom(lang.NewMap(kw_multis, lang.NewMap(kw_kv_DASH_reduce, tmp2), kw_on_DASH_interface, true, kw_sigs, lang.NewList(lang.NewList(sym_kv_DASH_reduce, lang.NewVector(sym_amap, sym_f, sym_init))))) var_glojure_DOT_core_DOT_protocols_IKVReduce = ns.InternWithValue(tmp0, tmp1, true) @@ -643,7 +652,7 @@ func LoadNS() { tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v4 := args[0] _ = v4 var v5 any = lang.NewList(args[1:]...) @@ -653,12 +662,13 @@ func LoadNS() { return tmp7 } }) + // MultiFn internal-reduce tmp2 := lang.NewMultiFn("internal-reduce", tmp3, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) var tmp4 lang.FnFunc tmp4 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v5 := args[0] _ = v5 var v6 any = lang.NewList(args[1:]...) @@ -676,7 +686,7 @@ func LoadNS() { tmp6 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v7 := args[0] _ = v7 var v8 any = lang.NewList(args[1:]...) @@ -694,7 +704,7 @@ func LoadNS() { tmp8 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v9 := args[0] _ = v9 var v10 any = lang.NewList(args[1:]...) @@ -720,7 +730,7 @@ func LoadNS() { tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v4 := args[0] _ = v4 var v5 any = lang.NewList(args[1:]...) @@ -730,6 +740,7 @@ func LoadNS() { return tmp7 } }) + // MultiFn nav tmp2 := lang.NewMultiFn("nav", tmp3, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) tmp1 := lang.NewAtom(lang.NewMap(kw_multis, lang.NewMap(kw_nav, tmp2), kw_on_DASH_interface, true, kw_sigs, lang.NewList(lang.NewList(sym_nav, lang.NewVector(sym_coll, sym_k, sym_v), "return (possibly transformed) v in the context of coll and k (a key/index or nil),\ndefaults to returning v.")))) var_glojure_DOT_core_DOT_protocols_Navigable = ns.InternWithValue(tmp0, tmp1, true) @@ -744,7 +755,7 @@ func LoadNS() { tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v3 := args[0] _ = v3 var v4 any = lang.NewList(args[1:]...) @@ -754,12 +765,13 @@ func LoadNS() { return tmp6 } }) + // MultiFn coll-reduce tmp1 := lang.NewMultiFn("coll-reduce", tmp2, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v4 := args[0] _ = v4 var v5 any = lang.NewList(args[1:]...) @@ -777,7 +789,7 @@ func LoadNS() { tmp5 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v6 := args[0] _ = v6 var v7 any = lang.NewList(args[1:]...) @@ -795,7 +807,7 @@ func LoadNS() { tmp7 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v8 := args[0] _ = v8 var v9 any = lang.NewList(args[1:]...) @@ -813,7 +825,7 @@ func LoadNS() { tmp9 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v10 := args[0] _ = v10 var v11 any = lang.NewList(args[1:]...) @@ -838,7 +850,7 @@ func LoadNS() { tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v3 := args[0] _ = v3 var v4 any = lang.NewList(args[1:]...) @@ -848,12 +860,13 @@ func LoadNS() { return tmp6 } }) + // MultiFn datafy tmp1 := lang.NewMultiFn("datafy", tmp2, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v4 := args[0] _ = v4 var v5 any = lang.NewList(args[1:]...) @@ -914,7 +927,7 @@ func LoadNS() { tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v3 := args[0] _ = v3 var v4 any = lang.NewList(args[1:]...) @@ -924,12 +937,13 @@ func LoadNS() { return tmp6 } }) + // MultiFn internal-reduce tmp1 := lang.NewMultiFn("internal-reduce", tmp2, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) var tmp3 lang.FnFunc tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v4 := args[0] _ = v4 var v5 any = lang.NewList(args[1:]...) @@ -947,7 +961,7 @@ func LoadNS() { tmp5 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v6 := args[0] _ = v6 var v7 any = lang.NewList(args[1:]...) @@ -965,7 +979,7 @@ func LoadNS() { tmp7 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v8 := args[0] _ = v8 var v9 any = lang.NewList(args[1:]...) @@ -1202,7 +1216,7 @@ func LoadNS() { tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v3 := args[0] _ = v3 var v4 any = lang.NewList(args[1:]...) @@ -1212,6 +1226,7 @@ func LoadNS() { return tmp6 } }) + // MultiFn kv-reduce tmp1 := lang.NewMultiFn("kv-reduce", tmp2, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) var_glojure_DOT_core_DOT_protocols_kv_DASH_reduce = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { @@ -1292,7 +1307,7 @@ func LoadNS() { tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v3 := args[0] _ = v3 var v4 any = lang.NewList(args[1:]...) @@ -1302,6 +1317,7 @@ func LoadNS() { return tmp6 } }) + // MultiFn nav tmp1 := lang.NewMultiFn("nav", tmp2, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) var_glojure_DOT_core_DOT_protocols_nav = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { From b76a8d7307698b5b57255dba5d052a417152d5b6 Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sun, 31 Aug 2025 20:52:07 -0700 Subject: [PATCH 55/67] AOT on generate make Signed-off-by: James Hamlin --- Makefile | 2 +- pkg/gen/gljimports/gljimports_darwin_amd64.go | 3 + pkg/gen/gljimports/gljimports_darwin_arm64.go | 3 + pkg/gen/gljimports/gljimports_js_wasm.go | 3 + pkg/gen/gljimports/gljimports_linux_amd64.go | 3 + pkg/gen/gljimports/gljimports_linux_arm64.go | 3 + .../gljimports/gljimports_windows_amd64.go | 3 + pkg/gen/gljimports/gljimports_windows_arm.go | 3 + pkg/stdlib/glojure/template/loader.go | 175 ++++ pkg/stdlib/glojure/walk/loader.go | 752 ++++++++++++++++++ 10 files changed, 949 insertions(+), 1 deletion(-) create mode 100644 pkg/stdlib/glojure/template/loader.go create mode 100644 pkg/stdlib/glojure/walk/loader.go diff --git a/Makefile b/Makefile index f28807de..b108658b 100644 --- a/Makefile +++ b/Makefile @@ -30,7 +30,7 @@ gocmd: .PHONY: generate generate: @go generate ./... - @echo "(map compile '[glojure.core glojure.core.async])" | \ + @echo "(map compile '[glojure.core glojure.core.async glojure.walk glojure.template])" | \ GLOJURE_STDLIB_PATH=./pkg/stdlib $(GO_CMD) run ./cmd/glj pkg/gen/gljimports/gljimports_%.go: ./scripts/gen-gljimports.sh ./cmd/gen-import-interop/main.go ./internal/genpkg/genpkg.go \ diff --git a/pkg/gen/gljimports/gljimports_darwin_amd64.go b/pkg/gen/gljimports/gljimports_darwin_amd64.go index 0822164e..7f83ec74 100644 --- a/pkg/gen/gljimports/gljimports_darwin_amd64.go +++ b/pkg/gen/gljimports/gljimports_darwin_amd64.go @@ -3977,9 +3977,12 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/runtime.EvalOption", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.EvalOption)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.Fn", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Fn)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.*Fn", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Fn)(nil))) + _register("github.com/glojurelang/glojure/pkg/runtime.Generator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Generator)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/runtime.*Generator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Generator)(nil))) _register("github.com/glojurelang/glojure/pkg/runtime.GetNSLoader", github_com_glojurelang_glojure_pkg_runtime.GetNSLoader) _register("github.com/glojurelang/glojure/pkg/runtime.NewEnvironment", github_com_glojurelang_glojure_pkg_runtime.NewEnvironment) _register("github.com/glojurelang/glojure/pkg/runtime.NewFn", github_com_glojurelang_glojure_pkg_runtime.NewFn) + _register("github.com/glojurelang/glojure/pkg/runtime.NewGenerator", github_com_glojurelang_glojure_pkg_runtime.NewGenerator) _register("github.com/glojurelang/glojure/pkg/runtime.RT", github_com_glojurelang_glojure_pkg_runtime.RT) _register("github.com/glojurelang/glojure/pkg/runtime.RTEvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTEvalError)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.*RTEvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTEvalError)(nil))) diff --git a/pkg/gen/gljimports/gljimports_darwin_arm64.go b/pkg/gen/gljimports/gljimports_darwin_arm64.go index 59844132..4c71c2ae 100644 --- a/pkg/gen/gljimports/gljimports_darwin_arm64.go +++ b/pkg/gen/gljimports/gljimports_darwin_arm64.go @@ -3977,9 +3977,12 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/runtime.EvalOption", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.EvalOption)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.Fn", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Fn)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.*Fn", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Fn)(nil))) + _register("github.com/glojurelang/glojure/pkg/runtime.Generator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Generator)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/runtime.*Generator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Generator)(nil))) _register("github.com/glojurelang/glojure/pkg/runtime.GetNSLoader", github_com_glojurelang_glojure_pkg_runtime.GetNSLoader) _register("github.com/glojurelang/glojure/pkg/runtime.NewEnvironment", github_com_glojurelang_glojure_pkg_runtime.NewEnvironment) _register("github.com/glojurelang/glojure/pkg/runtime.NewFn", github_com_glojurelang_glojure_pkg_runtime.NewFn) + _register("github.com/glojurelang/glojure/pkg/runtime.NewGenerator", github_com_glojurelang_glojure_pkg_runtime.NewGenerator) _register("github.com/glojurelang/glojure/pkg/runtime.RT", github_com_glojurelang_glojure_pkg_runtime.RT) _register("github.com/glojurelang/glojure/pkg/runtime.RTEvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTEvalError)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.*RTEvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTEvalError)(nil))) diff --git a/pkg/gen/gljimports/gljimports_js_wasm.go b/pkg/gen/gljimports/gljimports_js_wasm.go index c27666e5..f5b8eec8 100644 --- a/pkg/gen/gljimports/gljimports_js_wasm.go +++ b/pkg/gen/gljimports/gljimports_js_wasm.go @@ -3977,9 +3977,12 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/runtime.EvalOption", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.EvalOption)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.Fn", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Fn)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.*Fn", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Fn)(nil))) + _register("github.com/glojurelang/glojure/pkg/runtime.Generator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Generator)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/runtime.*Generator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Generator)(nil))) _register("github.com/glojurelang/glojure/pkg/runtime.GetNSLoader", github_com_glojurelang_glojure_pkg_runtime.GetNSLoader) _register("github.com/glojurelang/glojure/pkg/runtime.NewEnvironment", github_com_glojurelang_glojure_pkg_runtime.NewEnvironment) _register("github.com/glojurelang/glojure/pkg/runtime.NewFn", github_com_glojurelang_glojure_pkg_runtime.NewFn) + _register("github.com/glojurelang/glojure/pkg/runtime.NewGenerator", github_com_glojurelang_glojure_pkg_runtime.NewGenerator) _register("github.com/glojurelang/glojure/pkg/runtime.RT", github_com_glojurelang_glojure_pkg_runtime.RT) _register("github.com/glojurelang/glojure/pkg/runtime.RTEvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTEvalError)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.*RTEvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTEvalError)(nil))) diff --git a/pkg/gen/gljimports/gljimports_linux_amd64.go b/pkg/gen/gljimports/gljimports_linux_amd64.go index c2b0d1a7..0c93078f 100644 --- a/pkg/gen/gljimports/gljimports_linux_amd64.go +++ b/pkg/gen/gljimports/gljimports_linux_amd64.go @@ -3977,9 +3977,12 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/runtime.EvalOption", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.EvalOption)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.Fn", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Fn)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.*Fn", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Fn)(nil))) + _register("github.com/glojurelang/glojure/pkg/runtime.Generator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Generator)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/runtime.*Generator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Generator)(nil))) _register("github.com/glojurelang/glojure/pkg/runtime.GetNSLoader", github_com_glojurelang_glojure_pkg_runtime.GetNSLoader) _register("github.com/glojurelang/glojure/pkg/runtime.NewEnvironment", github_com_glojurelang_glojure_pkg_runtime.NewEnvironment) _register("github.com/glojurelang/glojure/pkg/runtime.NewFn", github_com_glojurelang_glojure_pkg_runtime.NewFn) + _register("github.com/glojurelang/glojure/pkg/runtime.NewGenerator", github_com_glojurelang_glojure_pkg_runtime.NewGenerator) _register("github.com/glojurelang/glojure/pkg/runtime.RT", github_com_glojurelang_glojure_pkg_runtime.RT) _register("github.com/glojurelang/glojure/pkg/runtime.RTEvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTEvalError)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.*RTEvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTEvalError)(nil))) diff --git a/pkg/gen/gljimports/gljimports_linux_arm64.go b/pkg/gen/gljimports/gljimports_linux_arm64.go index 9249eccd..74d12e52 100644 --- a/pkg/gen/gljimports/gljimports_linux_arm64.go +++ b/pkg/gen/gljimports/gljimports_linux_arm64.go @@ -3977,9 +3977,12 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/runtime.EvalOption", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.EvalOption)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.Fn", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Fn)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.*Fn", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Fn)(nil))) + _register("github.com/glojurelang/glojure/pkg/runtime.Generator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Generator)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/runtime.*Generator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Generator)(nil))) _register("github.com/glojurelang/glojure/pkg/runtime.GetNSLoader", github_com_glojurelang_glojure_pkg_runtime.GetNSLoader) _register("github.com/glojurelang/glojure/pkg/runtime.NewEnvironment", github_com_glojurelang_glojure_pkg_runtime.NewEnvironment) _register("github.com/glojurelang/glojure/pkg/runtime.NewFn", github_com_glojurelang_glojure_pkg_runtime.NewFn) + _register("github.com/glojurelang/glojure/pkg/runtime.NewGenerator", github_com_glojurelang_glojure_pkg_runtime.NewGenerator) _register("github.com/glojurelang/glojure/pkg/runtime.RT", github_com_glojurelang_glojure_pkg_runtime.RT) _register("github.com/glojurelang/glojure/pkg/runtime.RTEvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTEvalError)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.*RTEvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTEvalError)(nil))) diff --git a/pkg/gen/gljimports/gljimports_windows_amd64.go b/pkg/gen/gljimports/gljimports_windows_amd64.go index 198e03cc..b547e9c9 100644 --- a/pkg/gen/gljimports/gljimports_windows_amd64.go +++ b/pkg/gen/gljimports/gljimports_windows_amd64.go @@ -3977,9 +3977,12 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/runtime.EvalOption", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.EvalOption)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.Fn", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Fn)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.*Fn", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Fn)(nil))) + _register("github.com/glojurelang/glojure/pkg/runtime.Generator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Generator)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/runtime.*Generator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Generator)(nil))) _register("github.com/glojurelang/glojure/pkg/runtime.GetNSLoader", github_com_glojurelang_glojure_pkg_runtime.GetNSLoader) _register("github.com/glojurelang/glojure/pkg/runtime.NewEnvironment", github_com_glojurelang_glojure_pkg_runtime.NewEnvironment) _register("github.com/glojurelang/glojure/pkg/runtime.NewFn", github_com_glojurelang_glojure_pkg_runtime.NewFn) + _register("github.com/glojurelang/glojure/pkg/runtime.NewGenerator", github_com_glojurelang_glojure_pkg_runtime.NewGenerator) _register("github.com/glojurelang/glojure/pkg/runtime.RT", github_com_glojurelang_glojure_pkg_runtime.RT) _register("github.com/glojurelang/glojure/pkg/runtime.RTEvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTEvalError)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.*RTEvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTEvalError)(nil))) diff --git a/pkg/gen/gljimports/gljimports_windows_arm.go b/pkg/gen/gljimports/gljimports_windows_arm.go index 4982ccb5..28d49684 100644 --- a/pkg/gen/gljimports/gljimports_windows_arm.go +++ b/pkg/gen/gljimports/gljimports_windows_arm.go @@ -3977,9 +3977,12 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/runtime.EvalOption", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.EvalOption)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.Fn", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Fn)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.*Fn", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Fn)(nil))) + _register("github.com/glojurelang/glojure/pkg/runtime.Generator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Generator)(nil)).Elem()) + _register("github.com/glojurelang/glojure/pkg/runtime.*Generator", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.Generator)(nil))) _register("github.com/glojurelang/glojure/pkg/runtime.GetNSLoader", github_com_glojurelang_glojure_pkg_runtime.GetNSLoader) _register("github.com/glojurelang/glojure/pkg/runtime.NewEnvironment", github_com_glojurelang_glojure_pkg_runtime.NewEnvironment) _register("github.com/glojurelang/glojure/pkg/runtime.NewFn", github_com_glojurelang_glojure_pkg_runtime.NewFn) + _register("github.com/glojurelang/glojure/pkg/runtime.NewGenerator", github_com_glojurelang_glojure_pkg_runtime.NewGenerator) _register("github.com/glojurelang/glojure/pkg/runtime.RT", github_com_glojurelang_glojure_pkg_runtime.RT) _register("github.com/glojurelang/glojure/pkg/runtime.RTEvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTEvalError)(nil)).Elem()) _register("github.com/glojurelang/glojure/pkg/runtime.*RTEvalError", reflect.TypeOf((*github_com_glojurelang_glojure_pkg_runtime.RTEvalError)(nil))) diff --git a/pkg/stdlib/glojure/template/loader.go b/pkg/stdlib/glojure/template/loader.go new file mode 100644 index 00000000..fdfed777 --- /dev/null +++ b/pkg/stdlib/glojure/template/loader.go @@ -0,0 +1,175 @@ +// Code generated by glojure codegen. DO NOT EDIT. + +package template + +import ( + fmt "fmt" + lang "github.com/glojurelang/glojure/pkg/lang" + runtime "github.com/glojurelang/glojure/pkg/runtime" + reflect "reflect" +) + +func init() { + runtime.RegisterNSLoader("glojure/template", LoadNS) +} + +func checkDerefVar(v *lang.Var) any { + if v.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) + } + return v.Get() +} + +func checkArity(args []any, expected int) { + if len(args) != expected { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + +func checkArityGTE(args []any, min int) { + if len(args) < min { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + +// LoadNS initializes the namespace "glojure.template" +func LoadNS() { + sym__AMP_ := lang.NewSymbol("&") + sym_apply_DASH_template := lang.NewSymbol("apply-template") + sym_argv := lang.NewSymbol("argv") + sym_concat := lang.NewSymbol("concat") + sym_count := lang.NewSymbol("count") + sym_do := lang.NewSymbol("do") + sym_do_DASH_template := lang.NewSymbol("do-template") + sym_expr := lang.NewSymbol("expr") + sym_glojure_DOT_core := lang.NewSymbol("glojure.core") + sym_glojure_DOT_template := lang.NewSymbol("glojure.template") + sym_glojure_DOT_walk := lang.NewSymbol("glojure.walk") + sym_list := lang.NewSymbol("list") + sym_map := lang.NewSymbol("map") + sym_partition := lang.NewSymbol("partition") + sym_postwalk_DASH_replace := lang.NewSymbol("postwalk-replace") + sym_seq := lang.NewSymbol("seq") + sym_values := lang.NewSymbol("values") + sym_zipmap := lang.NewSymbol("zipmap") + kw_arglists := lang.NewKeyword("arglists") + kw_column := lang.NewKeyword("column") + kw_doc := lang.NewKeyword("doc") + kw_end_DASH_column := lang.NewKeyword("end-column") + kw_end_DASH_line := lang.NewKeyword("end-line") + kw_file := lang.NewKeyword("file") + kw_line := lang.NewKeyword("line") + kw_macro := lang.NewKeyword("macro") + kw_ns := lang.NewKeyword("ns") + kw_rettag := lang.NewKeyword("rettag") + // var glojure.core/concat + var_glojure_DOT_core_concat := lang.InternVarName(sym_glojure_DOT_core, sym_concat) + // var glojure.core/count + var_glojure_DOT_core_count := lang.InternVarName(sym_glojure_DOT_core, sym_count) + // var glojure.core/list + var_glojure_DOT_core_list := lang.InternVarName(sym_glojure_DOT_core, sym_list) + // var glojure.core/map + var_glojure_DOT_core_map := lang.InternVarName(sym_glojure_DOT_core, sym_map) + // var glojure.core/partition + var_glojure_DOT_core_partition := lang.InternVarName(sym_glojure_DOT_core, sym_partition) + // var glojure.core/seq + var_glojure_DOT_core_seq := lang.InternVarName(sym_glojure_DOT_core, sym_seq) + // var glojure.core/zipmap + var_glojure_DOT_core_zipmap := lang.InternVarName(sym_glojure_DOT_core, sym_zipmap) + // var glojure.template/apply-template + var_glojure_DOT_template_apply_DASH_template := lang.InternVarName(sym_glojure_DOT_template, sym_apply_DASH_template) + // var glojure.template/do-template + var_glojure_DOT_template_do_DASH_template := lang.InternVarName(sym_glojure_DOT_template, sym_do_DASH_template) + // var glojure.walk/postwalk-replace + var_glojure_DOT_walk_postwalk_DASH_replace := lang.InternVarName(sym_glojure_DOT_walk, sym_postwalk_DASH_replace) + // reference fmt to avoid unused import error + _ = fmt.Printf + // reference reflect to avoid unused import error + _ = reflect.TypeOf + ns := lang.FindOrCreateNamespace(sym_glojure_DOT_template) + _ = ns + // apply-template + { + tmp0 := sym_apply_DASH_template.WithMeta(lang.NewMap(kw_file, "glojure/template.glj", kw_line, int(28), kw_column, int(7), kw_end_DASH_line, int(28), kw_end_DASH_column, int(20), kw_arglists, lang.NewList(lang.NewVector(sym_argv, sym_expr, sym_values)), kw_doc, "For use in macros. argv is an argument list, as in defn. expr is\n a quoted expression using the symbols in argv. values is a sequence\n of values to be used for the arguments.\n\n apply-template will recursively replace argument symbols in expr\n with their corresponding values, returning a modified expr.\n\n Example: (apply-template '[x] '(+ x x) '[2])\n ;=> (+ 2 2)", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_template))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_walk_postwalk_DASH_replace) + tmp6 := checkDerefVar(var_glojure_DOT_core_zipmap) + tmp7 := lang.Apply(tmp6, []any{v2, v4}) + tmp8 := lang.Apply(tmp5, []any{tmp7, v3}) + return tmp8 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_template_apply_DASH_template = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_template_apply_DASH_template.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // do-template + { + tmp0 := sym_do_DASH_template.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_argv, sym_expr, sym__AMP_, sym_values)), kw_doc, "Repeatedly copies expr (in a do block) for each group of arguments\n in values. values are automatically partitioned by the number of\n arguments in argv, an argument vector as in defn.\n\n Example: (macroexpand '(do-template [x y] (+ y x) 2 4 3 5))\n ;=> (do (+ 4 2) (+ 5 3))", kw_file, "glojure/template.glj", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_template), kw_end_DASH_column, int(21), kw_column, int(11), kw_line, int(43), kw_end_DASH_line, int(43))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArityGTE(args, 4) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + v5 := args[3] + _ = v5 + var v6 any = lang.NewList(args[4:]...) + _ = v6 + var tmp7 any + { // let + // let binding "c" + tmp8 := checkDerefVar(var_glojure_DOT_core_count) + tmp9 := lang.Apply(tmp8, []any{v4}) + var v10 any = tmp9 + _ = v10 + tmp11 := checkDerefVar(var_glojure_DOT_core_seq) + tmp12 := checkDerefVar(var_glojure_DOT_core_concat) + tmp13 := checkDerefVar(var_glojure_DOT_core_list) + tmp14 := lang.Apply(tmp13, []any{sym_do}) + tmp15 := checkDerefVar(var_glojure_DOT_core_map) + var tmp16 lang.FnFunc + tmp16 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v17 := args[0] + _ = v17 + tmp18 := checkDerefVar(var_glojure_DOT_template_apply_DASH_template) + tmp19 := lang.Apply(tmp18, []any{v4, v5, v17}) + return tmp19 + }) + tmp17 := lang.NewMap(kw_file, "glojure/template.glj", kw_line, int(52), kw_column, int(17), kw_end_DASH_line, int(52), kw_end_DASH_column, int(53)) + tmp18, err := lang.WithMeta(tmp16, tmp17.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp19 := checkDerefVar(var_glojure_DOT_core_partition) + tmp20 := lang.Apply(tmp19, []any{v10, v6}) + tmp21 := lang.Apply(tmp15, []any{tmp18, tmp20}) + tmp22 := lang.Apply(tmp12, []any{tmp14, tmp21}) + tmp23 := lang.Apply(tmp11, []any{tmp22}) + tmp7 = tmp23 + } // end let + return tmp7 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_template_do_DASH_template = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_template_do_DASH_template.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } +} diff --git a/pkg/stdlib/glojure/walk/loader.go b/pkg/stdlib/glojure/walk/loader.go new file mode 100644 index 00000000..3f696930 --- /dev/null +++ b/pkg/stdlib/glojure/walk/loader.go @@ -0,0 +1,752 @@ +// Code generated by glojure codegen. DO NOT EDIT. + +package walk + +import ( + fmt "fmt" + lang "github.com/glojurelang/glojure/pkg/lang" + runtime "github.com/glojurelang/glojure/pkg/runtime" + reflect "reflect" +) + +func init() { + runtime.RegisterNSLoader("glojure/walk", LoadNS) +} + +func checkDerefVar(v *lang.Var) any { + if v.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) + } + return v.Get() +} + +func checkArity(args []any, expected int) { + if len(args) != expected { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + +func checkArityGTE(args []any, min int) { + if len(args) < min { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + +// LoadNS initializes the namespace "glojure.walk" +func LoadNS() { + sym_apply := lang.NewSymbol("apply") + sym_coll_QMARK_ := lang.NewSymbol("coll?") + sym_conj := lang.NewSymbol("conj") + sym_contains_QMARK_ := lang.NewSymbol("contains?") + sym_doall := lang.NewSymbol("doall") + sym_empty := lang.NewSymbol("empty") + sym_f := lang.NewSymbol("f") + sym_form := lang.NewSymbol("form") + sym_glojure_DOT_core := lang.NewSymbol("glojure.core") + sym_glojure_DOT_walk := lang.NewSymbol("glojure.walk") + sym_identity := lang.NewSymbol("identity") + sym_inner := lang.NewSymbol("inner") + sym_instance_QMARK_ := lang.NewSymbol("instance?") + sym_into := lang.NewSymbol("into") + sym_key := lang.NewSymbol("key") + sym_keyword := lang.NewSymbol("keyword") + sym_keyword_QMARK_ := lang.NewSymbol("keyword?") + sym_keywordize_DASH_keys := lang.NewSymbol("keywordize-keys") + sym_list := lang.NewSymbol("list") + sym_list_QMARK_ := lang.NewSymbol("list?") + sym_m := lang.NewSymbol("m") + sym_macroexpand := lang.NewSymbol("macroexpand") + sym_macroexpand_DASH_all := lang.NewSymbol("macroexpand-all") + sym_map := lang.NewSymbol("map") + sym_map_QMARK_ := lang.NewSymbol("map?") + sym_meta := lang.NewSymbol("meta") + sym_name := lang.NewSymbol("name") + sym_nth := lang.NewSymbol("nth") + sym_outer := lang.NewSymbol("outer") + sym_partial := lang.NewSymbol("partial") + sym_postwalk := lang.NewSymbol("postwalk") + sym_postwalk_DASH_demo := lang.NewSymbol("postwalk-demo") + sym_postwalk_DASH_replace := lang.NewSymbol("postwalk-replace") + sym_prewalk := lang.NewSymbol("prewalk") + sym_prewalk_DASH_demo := lang.NewSymbol("prewalk-demo") + sym_prewalk_DASH_replace := lang.NewSymbol("prewalk-replace") + sym_print := lang.NewSymbol("print") + sym_prn := lang.NewSymbol("prn") + sym_reduce := lang.NewSymbol("reduce") + sym_seq_QMARK_ := lang.NewSymbol("seq?") + sym_smap := lang.NewSymbol("smap") + sym_string_QMARK_ := lang.NewSymbol("string?") + sym_stringify_DASH_keys := lang.NewSymbol("stringify-keys") + sym_val := lang.NewSymbol("val") + sym_walk := lang.NewSymbol("walk") + sym_with_DASH_meta := lang.NewSymbol("with-meta") + kw_added := lang.NewKeyword("added") + kw_arglists := lang.NewKeyword("arglists") + kw_column := lang.NewKeyword("column") + kw_doc := lang.NewKeyword("doc") + kw_else := lang.NewKeyword("else") + kw_end_DASH_column := lang.NewKeyword("end-column") + kw_end_DASH_line := lang.NewKeyword("end-line") + kw_file := lang.NewKeyword("file") + kw_line := lang.NewKeyword("line") + kw_ns := lang.NewKeyword("ns") + kw_rettag := lang.NewKeyword("rettag") + // var glojure.core/apply + var_glojure_DOT_core_apply := lang.InternVarName(sym_glojure_DOT_core, sym_apply) + // var glojure.core/coll? + var_glojure_DOT_core_coll_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_coll_QMARK_) + // var glojure.core/conj + var_glojure_DOT_core_conj := lang.InternVarName(sym_glojure_DOT_core, sym_conj) + // var glojure.core/contains? + var_glojure_DOT_core_contains_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_contains_QMARK_) + // var glojure.core/doall + var_glojure_DOT_core_doall := lang.InternVarName(sym_glojure_DOT_core, sym_doall) + // var glojure.core/empty + var_glojure_DOT_core_empty := lang.InternVarName(sym_glojure_DOT_core, sym_empty) + // var glojure.core/identity + var_glojure_DOT_core_identity := lang.InternVarName(sym_glojure_DOT_core, sym_identity) + // var glojure.core/instance? + var_glojure_DOT_core_instance_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_instance_QMARK_) + // var glojure.core/into + var_glojure_DOT_core_into := lang.InternVarName(sym_glojure_DOT_core, sym_into) + // var glojure.core/key + var_glojure_DOT_core_key := lang.InternVarName(sym_glojure_DOT_core, sym_key) + // var glojure.core/keyword + var_glojure_DOT_core_keyword := lang.InternVarName(sym_glojure_DOT_core, sym_keyword) + // var glojure.core/keyword? + var_glojure_DOT_core_keyword_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_keyword_QMARK_) + // var glojure.core/list + var_glojure_DOT_core_list := lang.InternVarName(sym_glojure_DOT_core, sym_list) + // var glojure.core/list? + var_glojure_DOT_core_list_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_list_QMARK_) + // var glojure.core/macroexpand + var_glojure_DOT_core_macroexpand := lang.InternVarName(sym_glojure_DOT_core, sym_macroexpand) + // var glojure.core/map + var_glojure_DOT_core_map := lang.InternVarName(sym_glojure_DOT_core, sym_map) + // var glojure.core/map? + var_glojure_DOT_core_map_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_map_QMARK_) + // var glojure.core/meta + var_glojure_DOT_core_meta := lang.InternVarName(sym_glojure_DOT_core, sym_meta) + // var glojure.core/name + var_glojure_DOT_core_name := lang.InternVarName(sym_glojure_DOT_core, sym_name) + // var glojure.core/nth + var_glojure_DOT_core_nth := lang.InternVarName(sym_glojure_DOT_core, sym_nth) + // var glojure.core/partial + var_glojure_DOT_core_partial := lang.InternVarName(sym_glojure_DOT_core, sym_partial) + // var glojure.core/print + var_glojure_DOT_core_print := lang.InternVarName(sym_glojure_DOT_core, sym_print) + // var glojure.core/prn + var_glojure_DOT_core_prn := lang.InternVarName(sym_glojure_DOT_core, sym_prn) + // var glojure.core/reduce + var_glojure_DOT_core_reduce := lang.InternVarName(sym_glojure_DOT_core, sym_reduce) + // var glojure.core/seq? + var_glojure_DOT_core_seq_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_seq_QMARK_) + // var glojure.core/string? + var_glojure_DOT_core_string_QMARK_ := lang.InternVarName(sym_glojure_DOT_core, sym_string_QMARK_) + // var glojure.core/val + var_glojure_DOT_core_val := lang.InternVarName(sym_glojure_DOT_core, sym_val) + // var glojure.core/with-meta + var_glojure_DOT_core_with_DASH_meta := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_meta) + // var glojure.walk/keywordize-keys + var_glojure_DOT_walk_keywordize_DASH_keys := lang.InternVarName(sym_glojure_DOT_walk, sym_keywordize_DASH_keys) + // var glojure.walk/macroexpand-all + var_glojure_DOT_walk_macroexpand_DASH_all := lang.InternVarName(sym_glojure_DOT_walk, sym_macroexpand_DASH_all) + // var glojure.walk/postwalk + var_glojure_DOT_walk_postwalk := lang.InternVarName(sym_glojure_DOT_walk, sym_postwalk) + // var glojure.walk/postwalk-demo + var_glojure_DOT_walk_postwalk_DASH_demo := lang.InternVarName(sym_glojure_DOT_walk, sym_postwalk_DASH_demo) + // var glojure.walk/postwalk-replace + var_glojure_DOT_walk_postwalk_DASH_replace := lang.InternVarName(sym_glojure_DOT_walk, sym_postwalk_DASH_replace) + // var glojure.walk/prewalk + var_glojure_DOT_walk_prewalk := lang.InternVarName(sym_glojure_DOT_walk, sym_prewalk) + // var glojure.walk/prewalk-demo + var_glojure_DOT_walk_prewalk_DASH_demo := lang.InternVarName(sym_glojure_DOT_walk, sym_prewalk_DASH_demo) + // var glojure.walk/prewalk-replace + var_glojure_DOT_walk_prewalk_DASH_replace := lang.InternVarName(sym_glojure_DOT_walk, sym_prewalk_DASH_replace) + // var glojure.walk/stringify-keys + var_glojure_DOT_walk_stringify_DASH_keys := lang.InternVarName(sym_glojure_DOT_walk, sym_stringify_DASH_keys) + // var glojure.walk/walk + var_glojure_DOT_walk_walk := lang.InternVarName(sym_glojure_DOT_walk, sym_walk) + // reference fmt to avoid unused import error + _ = fmt.Printf + // reference reflect to avoid unused import error + _ = reflect.TypeOf + ns := lang.FindOrCreateNamespace(sym_glojure_DOT_walk) + _ = ns + // keywordize-keys + { + tmp0 := sym_keywordize_DASH_keys.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m)), kw_doc, "Recursively transforms all map keys from strings to keywords.", kw_file, "glojure/walk.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_walk), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(83), kw_end_DASH_line, int(83))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "f" + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v5 := args[0] + _ = v5 + var tmp6 any + { // let + // let binding "vec__1061" + var v7 any = v5 + _ = v7 + // let binding "k" + tmp8 := checkDerefVar(var_glojure_DOT_core_nth) + tmp9 := lang.Apply(tmp8, []any{v7, int64(0), nil}) + var v10 any = tmp9 + _ = v10 + // let binding "v" + tmp11 := checkDerefVar(var_glojure_DOT_core_nth) + tmp12 := lang.Apply(tmp11, []any{v7, int64(1), nil}) + var v13 any = tmp12 + _ = v13 + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core_string_QMARK_) + tmp16 := lang.Apply(tmp15, []any{v10}) + if lang.IsTruthy(tmp16) { + tmp17 := checkDerefVar(var_glojure_DOT_core_keyword) + tmp18 := lang.Apply(tmp17, []any{v10}) + tmp19 := lang.NewVector(tmp18, v13) + tmp20 := lang.NewMap(kw_file, "glojure/walk.glj", kw_line, int(87), kw_column, int(39), kw_end_DASH_line, int(87), kw_end_DASH_column, int(53)) + tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp14 = tmp21 + } else { + tmp22 := lang.NewVector(v10, v13) + tmp23 := lang.NewMap(kw_file, "glojure/walk.glj", kw_line, int(87), kw_column, int(55), kw_end_DASH_line, int(87), kw_end_DASH_column, int(59)) + tmp24, err := lang.WithMeta(tmp22, tmp23.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp14 = tmp24 + } + tmp6 = tmp14 + } // end let + return tmp6 + }) + tmp5 := lang.NewMap(kw_file, "glojure/walk.glj", kw_line, int(87), kw_column, int(11), kw_end_DASH_line, int(87), kw_end_DASH_column, int(61)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v7 any = tmp6 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_walk_postwalk) + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v10 := args[0] + _ = v10 + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp13 := lang.Apply(tmp12, []any{v10}) + if lang.IsTruthy(tmp13) { + tmp14 := checkDerefVar(var_glojure_DOT_core_into) + tmp15 := lang.NewMap() + tmp16 := lang.NewMap(kw_file, "glojure/walk.glj", kw_line, int(89), kw_column, int(42), kw_end_DASH_line, int(89), kw_end_DASH_column, int(43)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp18 := checkDerefVar(var_glojure_DOT_core_map) + tmp19 := lang.Apply(tmp18, []any{v7, v10}) + tmp20 := lang.Apply(tmp14, []any{tmp17, tmp19}) + tmp11 = tmp20 + } else { + tmp11 = v10 + } + return tmp11 + }) + tmp10 := lang.NewMap(kw_file, "glojure/walk.glj", kw_line, int(89), kw_column, int(15), kw_end_DASH_line, int(89), kw_end_DASH_column, int(58)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp12 := lang.Apply(tmp8, []any{tmp11, v2}) + tmp3 = tmp12 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_walk_keywordize_DASH_keys = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_walk_keywordize_DASH_keys.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // macroexpand-all + { + tmp0 := sym_macroexpand_DASH_all.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_form)), kw_doc, "Recursively performs all possible macroexpansions in form.", kw_file, "glojure/walk.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_walk), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(115), kw_end_DASH_line, int(115))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_walk_prewalk) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v5 := args[0] + _ = v5 + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp8 := lang.Apply(tmp7, []any{v5}) + if lang.IsTruthy(tmp8) { + tmp9 := checkDerefVar(var_glojure_DOT_core_macroexpand) + tmp10 := lang.Apply(tmp9, []any{v5}) + tmp6 = tmp10 + } else { + tmp6 = v5 + } + return tmp6 + }) + tmp5 := lang.NewMap(kw_file, "glojure/walk.glj", kw_line, int(119), kw_column, int(12), kw_end_DASH_line, int(119), kw_end_DASH_column, int(51)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp7 := lang.Apply(tmp3, []any{tmp6, v2}) + return tmp7 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_walk_macroexpand_DASH_all = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_walk_macroexpand_DASH_all.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // postwalk + { + tmp0 := sym_postwalk.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_form)), kw_doc, "Performs a depth-first, post-order traversal of form. Calls f on\n each sub-form, uses f's return value in place of the original.\n Recognizes all Clojure data structures. Consumes seqs as with doall.", kw_file, "glojure/walk.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_walk), kw_end_DASH_column, int(14), kw_column, int(7), kw_line, int(42), kw_end_DASH_line, int(42))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_walk_walk) + tmp5 := checkDerefVar(var_glojure_DOT_core_partial) + tmp6 := checkDerefVar(var_glojure_DOT_walk_postwalk) + tmp7 := lang.Apply(tmp5, []any{tmp6, v2}) + tmp8 := lang.Apply(tmp4, []any{tmp7, v2, v3}) + return tmp8 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_walk_postwalk = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_walk_postwalk.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // postwalk-demo + { + tmp0 := sym_postwalk_DASH_demo.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_form)), kw_doc, "Demonstrates the behavior of postwalk by printing each form as it is\n walked. Returns form.", kw_file, "glojure/walk.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_walk), kw_end_DASH_column, int(19), kw_column, int(7), kw_line, int(69), kw_end_DASH_line, int(69))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_walk_postwalk) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v5 := args[0] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_print) + tmp7 := lang.Apply(tmp6, []any{"Walked: "}) + _ = tmp7 + tmp8 := checkDerefVar(var_glojure_DOT_core_prn) + tmp9 := lang.Apply(tmp8, []any{v5}) + _ = tmp9 + return v5 + }) + tmp5 := lang.NewMap(kw_file, "glojure/walk.glj", kw_line, int(74), kw_column, int(13), kw_end_DASH_line, int(74), kw_end_DASH_column, int(49)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp7 := lang.Apply(tmp3, []any{tmp6, v2}) + return tmp7 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_walk_postwalk_DASH_demo = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_walk_postwalk_DASH_demo.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // postwalk-replace + { + tmp0 := sym_postwalk_DASH_replace.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_smap, sym_form)), kw_doc, "Recursively transforms form by replacing keys in smap with their\n values. Like glojure/replace but works on any data structure. Does\n replacement at the leaves of the tree first.", kw_file, "glojure/walk.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_walk), kw_end_DASH_column, int(22), kw_column, int(7), kw_line, int(107), kw_end_DASH_line, int(107))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_walk_postwalk) + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v6 := args[0] + _ = v6 + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp9 := lang.Apply(tmp8, []any{v2, v6}) + if lang.IsTruthy(tmp9) { + tmp10 := lang.Apply(v2, []any{v6}) + tmp7 = tmp10 + } else { + tmp7 = v6 + } + return tmp7 + }) + tmp6 := lang.NewMap(kw_file, "glojure/walk.glj", kw_line, int(113), kw_column, int(13), kw_end_DASH_line, int(113), kw_end_DASH_column, int(55)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp8 := lang.Apply(tmp4, []any{tmp7, v3}) + return tmp8 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_walk_postwalk_DASH_replace = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_walk_postwalk_DASH_replace.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // prewalk + { + tmp0 := sym_prewalk.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f, sym_form)), kw_doc, "Like postwalk, but does pre-order traversal.", kw_file, "glojure/walk.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_walk), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(50), kw_end_DASH_line, int(50))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_walk_walk) + tmp5 := checkDerefVar(var_glojure_DOT_core_partial) + tmp6 := checkDerefVar(var_glojure_DOT_walk_prewalk) + tmp7 := lang.Apply(tmp5, []any{tmp6, v2}) + tmp8 := checkDerefVar(var_glojure_DOT_core_identity) + tmp9 := lang.Apply(v2, []any{v3}) + tmp10 := lang.Apply(tmp4, []any{tmp7, tmp8, tmp9}) + return tmp10 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_walk_prewalk = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_walk_prewalk.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // prewalk-demo + { + tmp0 := sym_prewalk_DASH_demo.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_form)), kw_doc, "Demonstrates the behavior of prewalk by printing each form as it is\n walked. Returns form.", kw_file, "glojure/walk.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_walk), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(76), kw_end_DASH_line, int(76))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := checkDerefVar(var_glojure_DOT_walk_prewalk) + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v5 := args[0] + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_print) + tmp7 := lang.Apply(tmp6, []any{"Walked: "}) + _ = tmp7 + tmp8 := checkDerefVar(var_glojure_DOT_core_prn) + tmp9 := lang.Apply(tmp8, []any{v5}) + _ = tmp9 + return v5 + }) + tmp5 := lang.NewMap(kw_file, "glojure/walk.glj", kw_line, int(81), kw_column, int(12), kw_end_DASH_line, int(81), kw_end_DASH_column, int(48)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp7 := lang.Apply(tmp3, []any{tmp6, v2}) + return tmp7 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_walk_prewalk_DASH_demo = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_walk_prewalk_DASH_demo.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // prewalk-replace + { + tmp0 := sym_prewalk_DASH_replace.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_smap, sym_form)), kw_doc, "Recursively transforms form by replacing keys in smap with their\n values. Like glojure/replace but works on any data structure. Does\n replacement at the root of the tree first.", kw_file, "glojure/walk.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_walk), kw_end_DASH_column, int(21), kw_column, int(7), kw_line, int(99), kw_end_DASH_line, int(99))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + tmp4 := checkDerefVar(var_glojure_DOT_walk_prewalk) + var tmp5 lang.FnFunc + tmp5 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v6 := args[0] + _ = v6 + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core_contains_QMARK_) + tmp9 := lang.Apply(tmp8, []any{v2, v6}) + if lang.IsTruthy(tmp9) { + tmp10 := lang.Apply(v2, []any{v6}) + tmp7 = tmp10 + } else { + tmp7 = v6 + } + return tmp7 + }) + tmp6 := lang.NewMap(kw_file, "glojure/walk.glj", kw_line, int(105), kw_column, int(12), kw_end_DASH_line, int(105), kw_end_DASH_column, int(54)) + tmp7, err := lang.WithMeta(tmp5, tmp6.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp8 := lang.Apply(tmp4, []any{tmp7, v3}) + return tmp8 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_walk_prewalk_DASH_replace = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_walk_prewalk_DASH_replace.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // stringify-keys + { + tmp0 := sym_stringify_DASH_keys.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_m)), kw_doc, "Recursively transforms all map keys from keywords to strings.", kw_file, "glojure/walk.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_walk), kw_end_DASH_column, int(20), kw_column, int(7), kw_line, int(91), kw_end_DASH_line, int(91))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "f" + var tmp4 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v5 := args[0] + _ = v5 + var tmp6 any + { // let + // let binding "vec__1065" + var v7 any = v5 + _ = v7 + // let binding "k" + tmp8 := checkDerefVar(var_glojure_DOT_core_nth) + tmp9 := lang.Apply(tmp8, []any{v7, int64(0), nil}) + var v10 any = tmp9 + _ = v10 + // let binding "v" + tmp11 := checkDerefVar(var_glojure_DOT_core_nth) + tmp12 := lang.Apply(tmp11, []any{v7, int64(1), nil}) + var v13 any = tmp12 + _ = v13 + var tmp14 any + tmp15 := checkDerefVar(var_glojure_DOT_core_keyword_QMARK_) + tmp16 := lang.Apply(tmp15, []any{v10}) + if lang.IsTruthy(tmp16) { + tmp17 := checkDerefVar(var_glojure_DOT_core_name) + tmp18 := lang.Apply(tmp17, []any{v10}) + tmp19 := lang.NewVector(tmp18, v13) + tmp20 := lang.NewMap(kw_file, "glojure/walk.glj", kw_line, int(95), kw_column, int(40), kw_end_DASH_line, int(95), kw_end_DASH_column, int(51)) + tmp21, err := lang.WithMeta(tmp19, tmp20.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp14 = tmp21 + } else { + tmp22 := lang.NewVector(v10, v13) + tmp23 := lang.NewMap(kw_file, "glojure/walk.glj", kw_line, int(95), kw_column, int(53), kw_end_DASH_line, int(95), kw_end_DASH_column, int(57)) + tmp24, err := lang.WithMeta(tmp22, tmp23.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp14 = tmp24 + } + tmp6 = tmp14 + } // end let + return tmp6 + }) + tmp5 := lang.NewMap(kw_file, "glojure/walk.glj", kw_line, int(95), kw_column, int(11), kw_end_DASH_line, int(95), kw_end_DASH_column, int(59)) + tmp6, err := lang.WithMeta(tmp4, tmp5.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v7 any = tmp6 + _ = v7 + tmp8 := checkDerefVar(var_glojure_DOT_walk_postwalk) + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v10 := args[0] + _ = v10 + var tmp11 any + tmp12 := checkDerefVar(var_glojure_DOT_core_map_QMARK_) + tmp13 := lang.Apply(tmp12, []any{v10}) + if lang.IsTruthy(tmp13) { + tmp14 := checkDerefVar(var_glojure_DOT_core_into) + tmp15 := lang.NewMap() + tmp16 := lang.NewMap(kw_file, "glojure/walk.glj", kw_line, int(97), kw_column, int(42), kw_end_DASH_line, int(97), kw_end_DASH_column, int(43)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp18 := checkDerefVar(var_glojure_DOT_core_map) + tmp19 := lang.Apply(tmp18, []any{v7, v10}) + tmp20 := lang.Apply(tmp14, []any{tmp17, tmp19}) + tmp11 = tmp20 + } else { + tmp11 = v10 + } + return tmp11 + }) + tmp10 := lang.NewMap(kw_file, "glojure/walk.glj", kw_line, int(97), kw_column, int(15), kw_end_DASH_line, int(97), kw_end_DASH_column, int(58)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp12 := lang.Apply(tmp8, []any{tmp11, v2}) + tmp3 = tmp12 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_walk_stringify_DASH_keys = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_walk_stringify_DASH_keys.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // walk + { + tmp0 := sym_walk.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_inner, sym_outer, sym_form)), kw_doc, "Traverses form, an arbitrary data structure. inner and outer are\n functions. Applies inner to each element of form, building up a\n data structure of the same type, then applies outer to the result.\n Recognizes all Clojure data structures. Consumes seqs as with doall.", kw_file, "glojure/walk.glj", kw_added, "1.1", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_walk), kw_end_DASH_column, int(10), kw_column, int(7), kw_line, int(24), kw_end_DASH_line, int(24))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var tmp5 any + tmp6 := checkDerefVar(var_glojure_DOT_core_list_QMARK_) + tmp7 := lang.Apply(tmp6, []any{v4}) + if lang.IsTruthy(tmp7) { + tmp8 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp9 := checkDerefVar(var_glojure_DOT_core_apply) + tmp10 := checkDerefVar(var_glojure_DOT_core_list) + tmp11 := checkDerefVar(var_glojure_DOT_core_map) + tmp12 := lang.Apply(tmp11, []any{v2, v4}) + tmp13 := lang.Apply(tmp9, []any{tmp10, tmp12}) + tmp14 := checkDerefVar(var_glojure_DOT_core_meta) + tmp15 := lang.Apply(tmp14, []any{v4}) + tmp16 := lang.Apply(tmp8, []any{tmp13, tmp15}) + tmp17 := lang.Apply(v3, []any{tmp16}) + tmp5 = tmp17 + } else { + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp20 := reflect.TypeOf((*lang.IMapEntry)(nil)).Elem() + tmp21 := lang.Apply(tmp19, []any{tmp20, v4}) + if lang.IsTruthy(tmp21) { + tmp22 := checkDerefVar(var_glojure_DOT_core_key) + tmp23 := lang.Apply(tmp22, []any{v4}) + tmp24 := lang.Apply(v2, []any{tmp23}) + tmp25 := checkDerefVar(var_glojure_DOT_core_val) + tmp26 := lang.Apply(tmp25, []any{v4}) + tmp27 := lang.Apply(v2, []any{tmp26}) + tmp28 := lang.Apply(nil, []any{tmp24, tmp27}) + tmp29 := lang.Apply(v3, []any{tmp28}) + tmp18 = tmp29 + } else { + var tmp30 any + tmp31 := checkDerefVar(var_glojure_DOT_core_seq_QMARK_) + tmp32 := lang.Apply(tmp31, []any{v4}) + if lang.IsTruthy(tmp32) { + tmp33 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) + tmp34 := checkDerefVar(var_glojure_DOT_core_doall) + tmp35 := checkDerefVar(var_glojure_DOT_core_map) + tmp36 := lang.Apply(tmp35, []any{v2, v4}) + tmp37 := lang.Apply(tmp34, []any{tmp36}) + tmp38 := checkDerefVar(var_glojure_DOT_core_meta) + tmp39 := lang.Apply(tmp38, []any{v4}) + tmp40 := lang.Apply(tmp33, []any{tmp37, tmp39}) + tmp41 := lang.Apply(v3, []any{tmp40}) + tmp30 = tmp41 + } else { + var tmp42 any + tmp43 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) + tmp44 := reflect.TypeOf((*lang.IRecord)(nil)).Elem() + tmp45 := lang.Apply(tmp43, []any{tmp44, v4}) + if lang.IsTruthy(tmp45) { + tmp46 := checkDerefVar(var_glojure_DOT_core_reduce) + var tmp47 lang.FnFunc + tmp47 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v48 := args[0] + _ = v48 + v49 := args[1] + _ = v49 + tmp50 := checkDerefVar(var_glojure_DOT_core_conj) + tmp51 := lang.Apply(v2, []any{v49}) + tmp52 := lang.Apply(tmp50, []any{v48, tmp51}) + return tmp52 + }) + tmp48 := lang.NewMap(kw_file, "glojure/walk.glj", kw_line, int(38), kw_column, int(21), kw_end_DASH_line, int(38), kw_end_DASH_column, int(49)) + tmp49, err := lang.WithMeta(tmp47, tmp48.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp50 := lang.Apply(tmp46, []any{tmp49, v4, v4}) + tmp51 := lang.Apply(v3, []any{tmp50}) + tmp42 = tmp51 + } else { + var tmp52 any + tmp53 := checkDerefVar(var_glojure_DOT_core_coll_QMARK_) + tmp54 := lang.Apply(tmp53, []any{v4}) + if lang.IsTruthy(tmp54) { + tmp55 := checkDerefVar(var_glojure_DOT_core_into) + tmp56 := checkDerefVar(var_glojure_DOT_core_empty) + tmp57 := lang.Apply(tmp56, []any{v4}) + tmp58 := checkDerefVar(var_glojure_DOT_core_map) + tmp59 := lang.Apply(tmp58, []any{v2, v4}) + tmp60 := lang.Apply(tmp55, []any{tmp57, tmp59}) + tmp61 := lang.Apply(v3, []any{tmp60}) + tmp52 = tmp61 + } else { + var tmp62 any + if lang.IsTruthy(kw_else) { + tmp63 := lang.Apply(v3, []any{v4}) + tmp62 = tmp63 + } else { + } + tmp52 = tmp62 + } + tmp42 = tmp52 + } + tmp30 = tmp42 + } + tmp18 = tmp30 + } + tmp5 = tmp18 + } + return tmp5 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_walk_walk = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_walk_walk.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } +} From 6a61aa74442e85a4e3e97a010cdb82cf1d7a7eca Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sun, 31 Aug 2025 21:51:37 -0700 Subject: [PATCH 56/67] Implement codegen for case Signed-off-by: James Hamlin --- pkg/runtime/codegen.go | 55 +- .../testdata/codegen/test/case_switch.glj | 18 + .../codegen/test/case_switch/load.go.out | 185 ++++++ .../codegen/test/const_keyword/load.go.out | 6 + .../codegen/test/const_number/load.go.out | 6 + .../codegen/test/const_string/load.go.out | 6 + .../testdata/codegen/test/core/load.go.out | 584 ++++++++++-------- .../codegen/test/def_simple/load.go.out | 6 + .../codegen/test/fn_closure/load.go.out | 6 + .../codegen/test/fn_recur/load.go.out | 10 +- .../codegen/test/loop_simple/load.go.out | 6 + .../codegen/test/maybe_class/load.go.out | 6 + .../testdata/codegen/test/multifn/load.go.out | 7 + .../testdata/codegen/test/ns_skip/load.go.out | 6 + .../codegen/test/quote_simple/load.go.out | 6 + .../testdata/codegen/test/ref/load.go.out | 6 + .../testdata/codegen/test/the_var/load.go.out | 6 + .../codegen/test/throw_simple/load.go.out | 6 + .../codegen/test/try_advanced/load.go.out | 6 + .../codegen/test/try_basic/load.go.out | 6 + .../testdata/codegen/test/values/load.go.out | 6 + .../codegen/test/with_meta/load.go.out | 6 + 22 files changed, 680 insertions(+), 275 deletions(-) create mode 100644 pkg/runtime/testdata/codegen/test/case_switch.glj create mode 100644 pkg/runtime/testdata/codegen/test/case_switch/load.go.out diff --git a/pkg/runtime/codegen.go b/pkg/runtime/codegen.go index cd983174..70e30df1 100644 --- a/pkg/runtime/codegen.go +++ b/pkg/runtime/codegen.go @@ -764,8 +764,6 @@ func (g *Generator) generateSetValue(s lang.IPersistentSet) string { } func (g *Generator) generateMultiFn(mf *lang.MultiFn) string { - fmt.Println("Generating MultiFn:", mf.GetName()) - // Allocate a variable for the MultiFn mfVar := g.allocateTempVar() @@ -986,8 +984,7 @@ func (g *Generator) generateASTNode(node *ast.Node) (res string) { fmt.Println("Go not yet implemented; returning nil") return "nil" case ast.OpCase: - fmt.Println("Case not yet implemented; returning nil") - return "nil" + return g.generateCase(node) case ast.OpTry: return g.generateTry(node) case ast.OpThrow: @@ -1040,7 +1037,6 @@ func (g *Generator) generateASTNode(node *ast.Node) (res string) { case ast.OpNew: return g.generateNew(node) default: - fmt.Printf("Generating code for AST node: %T %+v\n", node.Sub, node.Sub) panic(fmt.Sprintf("unsupported AST node type %T", node.Sub)) } } @@ -1135,6 +1131,55 @@ func (g *Generator) generateIf(node *ast.Node) string { return resultVar } +func (g *Generator) generateCase(node *ast.Node) string { + caseNode := node.Sub.(*ast.CaseNode) + + testExpr := g.generateASTNode(caseNode.Test) + resultVar := g.allocateTempVar() + + g.writef("// case\n") + g.writef("var %s any\n", resultVar) + // implement as if-else chain; evaluation of case clauses is order-dependent + // case tests are evaluated lazily, so we need to generate them in the if conditions + // moreover, the text expressions may produce multiple statements, so we need to generate them inline + // therefore we can't use a switch statement or || operator + // instead we generate a series of if-else statements + // each test expression is compared to the testExpr using lang.Equals + // if a test matches, we evaluate the corresponding body and assign to resultVar + // if no tests match, we evaluate the default body (if any) and assign to resultVar + // if no default body, panic + first := true + for i, node := range caseNode.Nodes { + caseNodeNode := node.Sub.(*ast.CaseNodeNode) + tests := caseNodeNode.Tests + g.writef("// case clause %d\n", i) + for _, test := range tests { + caseTestExpr := g.generateASTNode(test) + if first { + g.writef("if lang.Equals(%s, %s) {\n", testExpr, caseTestExpr) + first = false + } else { + g.writef("} else if lang.Equals(%s, %s) {\n", testExpr, caseTestExpr) + } + // Generate the then body + thenExpr := g.generateASTNode(caseNodeNode.Then) + g.writeAssign(resultVar, thenExpr) + } + } + if caseNode.Default != nil { + g.writef("} else {\n") + defaultExpr := g.generateASTNode(caseNode.Default) + g.writeAssign(resultVar, defaultExpr) + g.writef("}\n") + } else { + g.writef("} else {\n") + g.writef(" panic(fmt.Sprintf(\"no matching case clause: %%v\", %s))\n", testExpr) + g.writef("}\n") + } + + return resultVar +} + // generateLet generates code for a Let node func (g *Generator) generateLet(node *ast.Node, isLoop bool) string { letNode := node.Sub.(*ast.LetNode) diff --git a/pkg/runtime/testdata/codegen/test/case_switch.glj b/pkg/runtime/testdata/codegen/test/case_switch.glj new file mode 100644 index 00000000..9f873815 --- /dev/null +++ b/pkg/runtime/testdata/codegen/test/case_switch.glj @@ -0,0 +1,18 @@ +(ns codegen.test.case-switch) + +(defn case-test [x] + (case x + 1 :one + 2 :two + 3 :three + :other)) + +(defn case-test-throw [x] + (try + (case x + 1 :nope) + (catch go/any e + :caught))) + +(defn ^{:expected-output [:two :other :caught]} -main [] + [(case-test 2) (case-test 42) (case-test-throw 42)]) diff --git a/pkg/runtime/testdata/codegen/test/case_switch/load.go.out b/pkg/runtime/testdata/codegen/test/case_switch/load.go.out new file mode 100644 index 00000000..b731b0eb --- /dev/null +++ b/pkg/runtime/testdata/codegen/test/case_switch/load.go.out @@ -0,0 +1,185 @@ +// Code generated by glojure codegen. DO NOT EDIT. + +package case_DASH_switch + +import ( + fmt "fmt" + lang "github.com/glojurelang/glojure/pkg/lang" + runtime "github.com/glojurelang/glojure/pkg/runtime" + reflect "reflect" +) + +func init() { + runtime.RegisterNSLoader("codegen/test/case_switch", LoadNS) +} + +func checkDerefVar(v *lang.Var) any { + if v.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) + } + return v.Get() +} + +func checkArity(args []any, expected int) { + if len(args) != expected { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + +func checkArityGTE(args []any, min int) { + if len(args) < min { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + +// LoadNS initializes the namespace "codegen.test.case-switch" +func LoadNS() { + sym__DASH_main := lang.NewSymbol("-main") + sym_case_DASH_test := lang.NewSymbol("case-test") + sym_case_DASH_test_DASH_throw := lang.NewSymbol("case-test-throw") + sym_codegen_DOT_test_DOT_case_DASH_switch := lang.NewSymbol("codegen.test.case-switch") + sym_glojure_DOT_core := lang.NewSymbol("glojure.core") + sym_str := lang.NewSymbol("str") + sym_x := lang.NewSymbol("x") + kw_arglists := lang.NewKeyword("arglists") + kw_caught := lang.NewKeyword("caught") + kw_column := lang.NewKeyword("column") + kw_end_DASH_column := lang.NewKeyword("end-column") + kw_end_DASH_line := lang.NewKeyword("end-line") + kw_expected_DASH_output := lang.NewKeyword("expected-output") + kw_file := lang.NewKeyword("file") + kw_line := lang.NewKeyword("line") + kw_nope := lang.NewKeyword("nope") + kw_ns := lang.NewKeyword("ns") + kw_one := lang.NewKeyword("one") + kw_other := lang.NewKeyword("other") + kw_rettag := lang.NewKeyword("rettag") + kw_three := lang.NewKeyword("three") + kw_two := lang.NewKeyword("two") + // var codegen.test.case-switch/-main + var_codegen_DOT_test_DOT_case_DASH_switch__DASH_main := lang.InternVarName(sym_codegen_DOT_test_DOT_case_DASH_switch, sym__DASH_main) + // var codegen.test.case-switch/case-test + var_codegen_DOT_test_DOT_case_DASH_switch_case_DASH_test := lang.InternVarName(sym_codegen_DOT_test_DOT_case_DASH_switch, sym_case_DASH_test) + // var codegen.test.case-switch/case-test-throw + var_codegen_DOT_test_DOT_case_DASH_switch_case_DASH_test_DASH_throw := lang.InternVarName(sym_codegen_DOT_test_DOT_case_DASH_switch, sym_case_DASH_test_DASH_throw) + // var glojure.core/str + var_glojure_DOT_core_str := lang.InternVarName(sym_glojure_DOT_core, sym_str) + // reference fmt to avoid unused import error + _ = fmt.Printf + // reference reflect to avoid unused import error + _ = reflect.TypeOf + ns := lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_case_DASH_switch) + _ = ns + // case-test + { + tmp0 := sym_case_DASH_test.WithMeta(lang.NewMap(kw_file, "codegen/test/case_switch.glj", kw_line, int(3), kw_column, int(7), kw_end_DASH_line, int(3), kw_end_DASH_column, int(15), kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_case_DASH_switch))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + { // let + // let binding "G__366" + var v4 any = v2 + _ = v4 + // case + var tmp5 any + // case clause 0 + if lang.Equals(v4, int(1)) { + tmp5 = kw_one + // case clause 1 + } else if lang.Equals(v4, int(2)) { + tmp5 = kw_two + // case clause 2 + } else if lang.Equals(v4, int(3)) { + tmp5 = kw_three + } else { + tmp5 = kw_other + } + tmp3 = tmp5 + } // end let + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_codegen_DOT_test_DOT_case_DASH_switch_case_DASH_test = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_codegen_DOT_test_DOT_case_DASH_switch_case_DASH_test.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // -main + { + tmp0 := sym__DASH_main.WithMeta(lang.NewMap(kw_expected_DASH_output, lang.NewVector(kw_two, kw_other, kw_caught), kw_file, "codegen/test/case_switch.glj", kw_line, int(17), kw_column, int(7), kw_end_DASH_line, int(17), kw_end_DASH_column, int(53), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_case_DASH_switch))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp2 := checkDerefVar(var_codegen_DOT_test_DOT_case_DASH_switch_case_DASH_test) + tmp3 := lang.Apply(tmp2, []any{int64(2)}) + tmp4 := checkDerefVar(var_codegen_DOT_test_DOT_case_DASH_switch_case_DASH_test) + tmp5 := lang.Apply(tmp4, []any{int64(42)}) + tmp6 := checkDerefVar(var_codegen_DOT_test_DOT_case_DASH_switch_case_DASH_test_DASH_throw) + tmp7 := lang.Apply(tmp6, []any{int64(42)}) + tmp8 := lang.NewVector(tmp3, tmp5, tmp7) + tmp9 := lang.NewMap(kw_file, "codegen/test/case_switch.glj", kw_line, int(18), kw_column, int(3), kw_end_DASH_line, int(18), kw_end_DASH_column, int(53)) + tmp10, err := lang.WithMeta(tmp8, tmp9.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp10 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_codegen_DOT_test_DOT_case_DASH_switch__DASH_main = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_codegen_DOT_test_DOT_case_DASH_switch__DASH_main.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // case-test-throw + { + tmp0 := sym_case_DASH_test_DASH_throw.WithMeta(lang.NewMap(kw_file, "codegen/test/case_switch.glj", kw_line, int(10), kw_column, int(7), kw_end_DASH_line, int(10), kw_end_DASH_column, int(21), kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_case_DASH_switch))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + func() { + defer func() { + if r := recover(); r != nil { + if lang.CatchMatches(r, lang.Builtins["any"]) { + v4 := r + _ = v4 + tmp3 = kw_caught + } else { + panic(r) + } + } + }() + var tmp4 any + { // let + // let binding "G__367" + var v5 any = v2 + _ = v5 + // case + var tmp6 any + // case clause 0 + if lang.Equals(v5, int(1)) { + tmp6 = kw_nope + } else { + tmp7 := checkDerefVar(var_glojure_DOT_core_str) + tmp8 := lang.Apply(tmp7, []any{"No matching clause: ", v5}) + tmp9 := lang.Apply(lang.NewIllegalArgumentError, []any{tmp8}) + panic(tmp9) + } + tmp4 = tmp6 + } // end let + tmp3 = tmp4 + }() + return tmp3 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_codegen_DOT_test_DOT_case_DASH_switch_case_DASH_test_DASH_throw = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_codegen_DOT_test_DOT_case_DASH_switch_case_DASH_test_DASH_throw.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } +} diff --git a/pkg/runtime/testdata/codegen/test/const_keyword/load.go.out b/pkg/runtime/testdata/codegen/test/const_keyword/load.go.out index 840db50f..02a17093 100644 --- a/pkg/runtime/testdata/codegen/test/const_keyword/load.go.out +++ b/pkg/runtime/testdata/codegen/test/const_keyword/load.go.out @@ -26,6 +26,12 @@ func checkArity(args []any, expected int) { } } +func checkArityGTE(args []any, min int) { + if len(args) < min { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + // LoadNS initializes the namespace "codegen.test.const-keyword" func LoadNS() { sym_codegen_DOT_test_DOT_const_DASH_keyword := lang.NewSymbol("codegen.test.const-keyword") diff --git a/pkg/runtime/testdata/codegen/test/const_number/load.go.out b/pkg/runtime/testdata/codegen/test/const_number/load.go.out index 271013dd..ecf42b65 100644 --- a/pkg/runtime/testdata/codegen/test/const_number/load.go.out +++ b/pkg/runtime/testdata/codegen/test/const_number/load.go.out @@ -26,6 +26,12 @@ func checkArity(args []any, expected int) { } } +func checkArityGTE(args []any, min int) { + if len(args) < min { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + // LoadNS initializes the namespace "codegen.test.const-number" func LoadNS() { sym_codegen_DOT_test_DOT_const_DASH_number := lang.NewSymbol("codegen.test.const-number") diff --git a/pkg/runtime/testdata/codegen/test/const_string/load.go.out b/pkg/runtime/testdata/codegen/test/const_string/load.go.out index e9bc418d..4460d518 100644 --- a/pkg/runtime/testdata/codegen/test/const_string/load.go.out +++ b/pkg/runtime/testdata/codegen/test/const_string/load.go.out @@ -26,6 +26,12 @@ func checkArity(args []any, expected int) { } } +func checkArityGTE(args []any, min int) { + if len(args) < min { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + // LoadNS initializes the namespace "codegen.test.const-string" func LoadNS() { sym_codegen_DOT_test_DOT_const_DASH_string := lang.NewSymbol("codegen.test.const-string") diff --git a/pkg/runtime/testdata/codegen/test/core/load.go.out b/pkg/runtime/testdata/codegen/test/core/load.go.out index f5815203..fb745700 100644 --- a/pkg/runtime/testdata/codegen/test/core/load.go.out +++ b/pkg/runtime/testdata/codegen/test/core/load.go.out @@ -40,6 +40,12 @@ func checkArity(args []any, expected int) { } } +func checkArityGTE(args []any, min int) { + if len(args) < min { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + // LoadNS initializes the namespace "glojure.core" func LoadNS() { sym__PCT_ := lang.NewSymbol("%") @@ -255,6 +261,25 @@ func LoadNS() { sym_clauses := lang.NewSymbol("clauses") sym_clear_DASH_agent_DASH_errors := lang.NewSymbol("clear-agent-errors") sym_close := lang.NewSymbol("close") + sym_codegen_DOT_test_DOT_case_DASH_switch := lang.NewSymbol("codegen.test.case-switch") + sym_codegen_DOT_test_DOT_const_DASH_keyword := lang.NewSymbol("codegen.test.const-keyword") + sym_codegen_DOT_test_DOT_const_DASH_number := lang.NewSymbol("codegen.test.const-number") + sym_codegen_DOT_test_DOT_const_DASH_string := lang.NewSymbol("codegen.test.const-string") + sym_codegen_DOT_test_DOT_def_DASH_simple := lang.NewSymbol("codegen.test.def-simple") + sym_codegen_DOT_test_DOT_fn_DASH_closure := lang.NewSymbol("codegen.test.fn-closure") + sym_codegen_DOT_test_DOT_fn_DASH_recur := lang.NewSymbol("codegen.test.fn-recur") + sym_codegen_DOT_test_DOT_loop_DASH_simple := lang.NewSymbol("codegen.test.loop-simple") + sym_codegen_DOT_test_DOT_maybe_DASH_class := lang.NewSymbol("codegen.test.maybe-class") + sym_codegen_DOT_test_DOT_multifn := lang.NewSymbol("codegen.test.multifn") + sym_codegen_DOT_test_DOT_ns_DASH_skip := lang.NewSymbol("codegen.test.ns-skip") + sym_codegen_DOT_test_DOT_quote_DASH_simple := lang.NewSymbol("codegen.test.quote-simple") + sym_codegen_DOT_test_DOT_ref := lang.NewSymbol("codegen.test.ref") + sym_codegen_DOT_test_DOT_the_DASH_var := lang.NewSymbol("codegen.test.the-var") + sym_codegen_DOT_test_DOT_throw_DASH_simple := lang.NewSymbol("codegen.test.throw-simple") + sym_codegen_DOT_test_DOT_try_DASH_advanced := lang.NewSymbol("codegen.test.try-advanced") + sym_codegen_DOT_test_DOT_try_DASH_basic := lang.NewSymbol("codegen.test.try-basic") + sym_codegen_DOT_test_DOT_values := lang.NewSymbol("codegen.test.values") + sym_codegen_DOT_test_DOT_with_DASH_meta := lang.NewSymbol("codegen.test.with-meta") sym_coerce := lang.NewSymbol("coerce") sym_coll := lang.NewSymbol("coll") sym_coll_DASH_reduce := lang.NewSymbol("coll-reduce") @@ -3153,6 +3178,7 @@ func LoadNS() { if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_data_DASH_readers_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_data_DASH_readers_STAR_.SetDynamic() } // *default-data-reader-fn* { @@ -3161,6 +3187,7 @@ func LoadNS() { if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_default_DASH_data_DASH_reader_DASH_fn_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_default_DASH_data_DASH_reader_DASH_fn_STAR_.SetDynamic() } // *e { @@ -3197,11 +3224,12 @@ func LoadNS() { // *loaded-libs* { tmp0 := sym__STAR_loaded_DASH_libs_STAR_.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core.glj", kw_line, int(5817), kw_column, int(10), kw_end_DASH_line, int(5820), kw_end_DASH_column, int(15), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - tmp1 := lang.NewRef(lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{sym_glojure_DOT_core_DOT_protocols, sym_glojure_DOT_string, sym_glojure_DOT_go_DOT_io}))) + tmp1 := lang.NewRef(lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{sym_glojure_DOT_core_DOT_protocols, sym_glojure_DOT_string, sym_glojure_DOT_go_DOT_io, sym_codegen_DOT_test_DOT_case_DASH_switch, sym_codegen_DOT_test_DOT_const_DASH_keyword, sym_codegen_DOT_test_DOT_const_DASH_number, sym_codegen_DOT_test_DOT_const_DASH_string, sym_codegen_DOT_test_DOT_def_DASH_simple, sym_codegen_DOT_test_DOT_fn_DASH_closure, sym_codegen_DOT_test_DOT_fn_DASH_recur, sym_codegen_DOT_test_DOT_loop_DASH_simple, sym_codegen_DOT_test_DOT_maybe_DASH_class, sym_codegen_DOT_test_DOT_multifn, sym_codegen_DOT_test_DOT_ns_DASH_skip, sym_codegen_DOT_test_DOT_quote_DASH_simple, sym_codegen_DOT_test_DOT_ref, sym_codegen_DOT_test_DOT_the_DASH_var, sym_codegen_DOT_test_DOT_throw_DASH_simple, sym_codegen_DOT_test_DOT_try_DASH_advanced, sym_codegen_DOT_test_DOT_try_DASH_basic, sym_codegen_DOT_test_DOT_values, sym_codegen_DOT_test_DOT_with_DASH_meta}))) var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_.SetDynamic() } // *loading-verbosely* { @@ -3210,6 +3238,7 @@ func LoadNS() { if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_loading_DASH_verbosely_STAR_.SetDynamic() } // *ns* { @@ -3226,6 +3255,7 @@ func LoadNS() { if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_pending_DASH_paths_STAR_.SetDynamic() } // *print-dup* { @@ -3242,6 +3272,7 @@ func LoadNS() { if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_print_DASH_length_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_print_DASH_length_STAR_.SetDynamic() } // *print-level* { @@ -3250,6 +3281,7 @@ func LoadNS() { if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_print_DASH_level_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_print_DASH_level_STAR_.SetDynamic() } // *print-meta* { @@ -3266,6 +3298,7 @@ func LoadNS() { if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_print_DASH_namespace_DASH_maps_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_print_DASH_namespace_DASH_maps_STAR_.SetDynamic() } // *print-readably* { @@ -3290,6 +3323,7 @@ func LoadNS() { if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_repl_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_repl_STAR_.SetDynamic() } // *unchecked-math* { @@ -3306,6 +3340,7 @@ func LoadNS() { if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_verbose_DASH_defrecords_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_verbose_DASH_defrecords_STAR_.SetDynamic() } // *warn-on-reflection* { @@ -3412,7 +3447,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -3440,7 +3475,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -3468,7 +3503,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -3822,7 +3857,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -3845,7 +3880,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -3976,7 +4011,7 @@ func LoadNS() { tmp3 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v4 any = lang.NewList(args[0:]...) _ = v4 return v2 @@ -4042,7 +4077,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 tmp3 := lang.Apply(lang.CreatePersistentStructMapSlotMap, []any{v2}) @@ -4602,7 +4637,7 @@ func LoadNS() { } return tmp4 default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 tmp3 := lang.Apply(lang.CreatePersistentHashMap, []any{v2}) @@ -4647,7 +4682,7 @@ func LoadNS() { } return tmp4 default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 tmp3 := lang.Apply(nil, []any{v2}) @@ -6691,7 +6726,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 tmp3 := lang.Apply(lang.CreatePersistentTreeMap, []any{v2}) @@ -6711,7 +6746,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -6733,7 +6768,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 tmp3 := lang.Apply(lang.CreatePersistentTreeSet, []any{v2}) @@ -6753,7 +6788,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -6888,7 +6923,7 @@ func LoadNS() { } return tmp4 default: - checkArity(args, 1) + checkArityGTE(args, 1) v3 := args[0] _ = v3 var v4 any = lang.NewList(args[1:]...) @@ -7120,7 +7155,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -7142,7 +7177,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -7197,7 +7232,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -7225,7 +7260,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -7842,7 +7877,7 @@ func LoadNS() { } return tmp10 default: - checkArity(args, 6) + checkArityGTE(args, 6) v2 := args[0] _ = v2 v3 := args[1] @@ -7971,7 +8006,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -8000,7 +8035,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -8237,7 +8272,7 @@ func LoadNS() { tmp6 := lang.Apply(lang.Assoc, []any{v3, v4, v5}) return tmp6 default: - checkArity(args, 3) + checkArityGTE(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -8316,7 +8351,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -8684,7 +8719,7 @@ func LoadNS() { tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) return tmp5 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -8789,7 +8824,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -8859,7 +8894,7 @@ func LoadNS() { tmp5 := lang.Apply(lang.Conj, []any{v3, v4}) return tmp5 default: - checkArity(args, 2) + checkArityGTE(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -9159,7 +9194,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 4) + checkArityGTE(args, 4) v2 := args[0] _ = v2 v3 := args[1] @@ -9214,7 +9249,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -9360,7 +9395,7 @@ func LoadNS() { } return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -9429,7 +9464,7 @@ func LoadNS() { tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -9496,7 +9531,7 @@ func LoadNS() { tmp5 := lang.Apply(tmp4, []any{v2, v3}) return tmp5 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -9556,7 +9591,7 @@ func LoadNS() { tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -9608,7 +9643,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -9687,7 +9722,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) @@ -10397,7 +10432,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) @@ -10644,7 +10679,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -11223,7 +11258,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) @@ -11453,7 +11488,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -11873,7 +11908,7 @@ func LoadNS() { tmp11 := lang.Apply(tmp6, []any{v2, tmp10}) return tmp11 default: - checkArity(args, 4) + checkArityGTE(args, 4) v2 := args[0] _ = v2 v3 := args[1] @@ -11975,7 +12010,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) @@ -12641,7 +12676,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -13599,7 +13634,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -14024,7 +14059,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) @@ -14323,7 +14358,7 @@ func LoadNS() { } // end let return tmp8 default: - checkArity(args, 3) + checkArityGTE(args, 3) v5 := args[0] _ = v5 v6 := args[1] @@ -14520,7 +14555,7 @@ func LoadNS() { } // end let return tmp9 default: - checkArity(args, 3) + checkArityGTE(args, 3) v6 := args[0] _ = v6 v7 := args[1] @@ -14830,7 +14865,7 @@ func LoadNS() { } // end let return tmp10 default: - checkArity(args, 3) + checkArityGTE(args, 3) v7 := args[0] _ = v7 v8 := args[1] @@ -14909,7 +14944,7 @@ func LoadNS() { } return tmp7 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -15038,7 +15073,7 @@ func LoadNS() { tmp19 := lang.Apply(tmp15, []any{tmp18, v9}) return tmp19 default: - checkArity(args, 3) + checkArityGTE(args, 3) v12 := args[0] _ = v12 v13 := args[1] @@ -15344,7 +15379,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 tmp3 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) @@ -16638,7 +16673,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 4) + checkArityGTE(args, 4) v2 := args[0] _ = v2 v3 := args[1] @@ -16947,7 +16982,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -17035,7 +17070,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -17143,7 +17178,7 @@ func LoadNS() { tmp15 := lang.Apply(tmp6, []any{tmp14}) return tmp15 default: - checkArity(args, 4) + checkArityGTE(args, 4) v2 := args[0] _ = v2 v3 := args[1] @@ -17227,7 +17262,7 @@ func LoadNS() { tmp5 := lang.Apply(lang.Equiv, []any{v3, v4}) return tmp5 default: - checkArity(args, 2) + checkArityGTE(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -17328,7 +17363,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 default: - checkArity(args, 2) + checkArityGTE(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -17431,7 +17466,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 default: - checkArity(args, 2) + checkArityGTE(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -17534,7 +17569,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 default: - checkArity(args, 2) + checkArityGTE(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -17637,7 +17672,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 default: - checkArity(args, 2) + checkArityGTE(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -17740,7 +17775,7 @@ func LoadNS() { tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 default: - checkArity(args, 2) + checkArityGTE(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -17869,7 +17904,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -17986,7 +18021,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -18089,7 +18124,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -18206,7 +18241,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -18309,7 +18344,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -18425,7 +18460,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -18528,7 +18563,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -18645,7 +18680,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -18748,7 +18783,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -18865,7 +18900,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -19136,7 +19171,7 @@ func LoadNS() { tmp9 := lang.Apply(lang.Apply, []any{v2, tmp8}) return tmp9 default: - checkArity(args, 5) + checkArityGTE(args, 5) v2 := args[0] _ = v2 v3 := args[1] @@ -19302,7 +19337,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 tmp3 := checkDerefVar(var_glojure_DOT_core_into_DASH_array) @@ -19482,7 +19517,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -20051,7 +20086,7 @@ func LoadNS() { tmp11 := lang.Apply(v2, []any{v7, v8, v9}) return tmp11 default: - checkArity(args, 3) + checkArityGTE(args, 3) v7 := args[0] _ = v7 v8 := args[1] @@ -20164,7 +20199,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -20274,7 +20309,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -20377,7 +20412,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -20487,7 +20522,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -20641,7 +20676,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -20751,7 +20786,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -20968,7 +21003,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -21078,7 +21113,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -21158,7 +21193,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) @@ -21274,7 +21309,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -21311,7 +21346,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 tmp3 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) @@ -21542,7 +21577,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) @@ -21756,7 +21791,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) @@ -21915,7 +21950,7 @@ func LoadNS() { tmp9 := lang.Apply(v2, []any{tmp8}) return tmp9 default: - checkArity(args, 3) + checkArityGTE(args, 3) v5 := args[0] _ = v5 v6 := args[1] @@ -21937,7 +21972,7 @@ func LoadNS() { } return tmp6 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -22038,7 +22073,7 @@ func LoadNS() { tmp8 := lang.Apply(tmp6, []any{tmp7}) return tmp8 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -22297,7 +22332,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -22427,7 +22462,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -22713,7 +22748,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -22825,7 +22860,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -23358,7 +23393,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -23996,7 +24031,7 @@ func LoadNS() { tmp10 := lang.Apply(tmp8, []any{tmp9}) return tmp10 default: - checkArity(args, 3) + checkArityGTE(args, 3) v5 := args[0] _ = v5 v6 := args[1] @@ -24201,7 +24236,7 @@ func LoadNS() { tmp11 := lang.Apply(tmp9, []any{tmp10}) return tmp11 default: - checkArity(args, 3) + checkArityGTE(args, 3) v6 := args[0] _ = v6 v7 := args[1] @@ -24519,7 +24554,7 @@ func LoadNS() { tmp12 := lang.Apply(tmp10, []any{tmp11}) return tmp12 default: - checkArity(args, 3) + checkArityGTE(args, 3) v7 := args[0] _ = v7 v8 := args[1] @@ -24600,7 +24635,7 @@ func LoadNS() { } return tmp7 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -24729,7 +24764,7 @@ func LoadNS() { tmp19 := lang.Apply(tmp15, []any{tmp18, v9}) return tmp19 default: - checkArity(args, 3) + checkArityGTE(args, 3) v12 := args[0] _ = v12 v13 := args[1] @@ -25103,7 +25138,7 @@ func LoadNS() { tmp11 := lang.Apply(v2, []any{tmp8, v6, v7}) return tmp11 default: - checkArity(args, 3) + checkArityGTE(args, 3) v5 := args[0] _ = v5 v6 := args[1] @@ -25190,7 +25225,7 @@ func LoadNS() { tmp15 := lang.Apply(v2, []any{tmp9, tmp12, v8}) return tmp15 default: - checkArity(args, 3) + checkArityGTE(args, 3) v6 := args[0] _ = v6 v7 := args[1] @@ -25295,7 +25330,7 @@ func LoadNS() { tmp19 := lang.Apply(v2, []any{tmp10, tmp13, tmp16}) return tmp19 default: - checkArity(args, 3) + checkArityGTE(args, 3) v7 := args[0] _ = v7 v8 := args[1] @@ -25357,7 +25392,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -25380,7 +25415,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -25575,7 +25610,7 @@ func LoadNS() { tmp17 := lang.Apply(tmp6, []any{tmp16}) return tmp17 default: - checkArity(args, 5) + checkArityGTE(args, 5) v2 := args[0] _ = v2 v3 := args[1] @@ -25745,7 +25780,7 @@ func LoadNS() { tmp17 := lang.Apply(tmp6, []any{tmp16}) return tmp17 default: - checkArity(args, 5) + checkArityGTE(args, 5) v2 := args[0] _ = v2 v3 := args[1] @@ -25992,7 +26027,7 @@ func LoadNS() { } return tmp10 default: - checkArity(args, 3) + checkArityGTE(args, 3) v4 := args[0] _ = v4 v5 := args[1] @@ -26079,7 +26114,7 @@ func LoadNS() { } return tmp12 default: - checkArity(args, 3) + checkArityGTE(args, 3) v5 := args[0] _ = v5 v6 := args[1] @@ -26174,7 +26209,7 @@ func LoadNS() { } return tmp14 default: - checkArity(args, 3) + checkArityGTE(args, 3) v6 := args[0] _ = v6 v7 := args[1] @@ -26205,7 +26240,7 @@ func LoadNS() { } return tmp7 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -26345,7 +26380,7 @@ func LoadNS() { tmp21 := lang.Apply(tmp14, []any{tmp17, tmp20, v9}) return tmp21 default: - checkArity(args, 3) + checkArityGTE(args, 3) v11 := args[0] _ = v11 v12 := args[1] @@ -26633,7 +26668,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -26666,7 +26701,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -26802,7 +26837,7 @@ func LoadNS() { tmp9 := lang.Apply(v4, []any{v6, tmp8}) return tmp9 default: - checkArity(args, 2) + checkArityGTE(args, 2) v6 := args[0] _ = v6 v7 := args[1] @@ -27089,7 +27124,7 @@ func LoadNS() { tmp7 := lang.Apply(lang.NewLazySeq, []any{tmp6}) return tmp7 default: - checkArity(args, 4) + checkArityGTE(args, 4) v2 := args[0] _ = v2 v3 := args[1] @@ -27267,7 +27302,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -27381,7 +27416,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -27433,7 +27468,7 @@ func LoadNS() { } return tmp5 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -27562,7 +27597,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -27635,7 +27670,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 var tmp3 any @@ -27699,7 +27734,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -27895,7 +27930,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -28009,7 +28044,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -28061,7 +28096,7 @@ func LoadNS() { } return tmp5 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -28336,7 +28371,7 @@ func LoadNS() { } // end let return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v5 := args[0] _ = v5 v6 := args[1] @@ -28537,7 +28572,7 @@ func LoadNS() { tmp7 := lang.Apply(closed35, []any{tmp6}) return tmp7 default: - checkArity(args, 3) + checkArityGTE(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -28594,7 +28629,7 @@ func LoadNS() { tmp7 := lang.Apply(closed35, []any{tmp6}) return tmp7 default: - checkArity(args, 3) + checkArityGTE(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -28637,7 +28672,7 @@ func LoadNS() { tmp8 := lang.Apply(tmp5, []any{tmp7}) return tmp8 default: - checkArity(args, 2) + checkArityGTE(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -29154,7 +29189,7 @@ func LoadNS() { _ = v4 return v4 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -29284,6 +29319,17 @@ func LoadNS() { // let binding "G__365" var v7 any = v2 _ = v7 + // case + var tmp8 any + // case clause 0 + if lang.Equals(v7, "true") { + tmp8 = true + // case clause 1 + } else if lang.Equals(v7, "false") { + tmp8 = false + } else { + } + tmp6 = tmp8 } // end let tmp3 = tmp6 } else { @@ -29427,7 +29473,7 @@ func LoadNS() { tmp8 := lang.Apply(v2, []any{v3, v5, v6, v7}) return tmp8 default: - checkArity(args, 3) + checkArityGTE(args, 3) v5 := args[0] _ = v5 v6 := args[1] @@ -29482,7 +29528,7 @@ func LoadNS() { tmp9 := lang.Apply(v2, []any{v3, v4, v6, v7, v8}) return tmp9 default: - checkArity(args, 3) + checkArityGTE(args, 3) v6 := args[0] _ = v6 v7 := args[1] @@ -29539,7 +29585,7 @@ func LoadNS() { tmp10 := lang.Apply(v2, []any{v3, v4, v5, v7, v8, v9}) return tmp10 default: - checkArity(args, 3) + checkArityGTE(args, 3) v7 := args[0] _ = v7 v8 := args[1] @@ -29560,7 +29606,7 @@ func LoadNS() { } return tmp8 default: - checkArity(args, 4) + checkArityGTE(args, 4) v2 := args[0] _ = v2 v3 := args[1] @@ -29575,7 +29621,7 @@ func LoadNS() { tmp7 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v8 any = lang.NewList(args[0:]...) _ = v8 tmp9 := checkDerefVar(var_glojure_DOT_core_apply) @@ -30054,7 +30100,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -30597,7 +30643,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -31109,7 +31155,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -31664,7 +31710,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -31893,7 +31939,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -31993,7 +32039,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -32234,7 +32280,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -32542,7 +32588,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -32970,7 +33016,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -33239,7 +33285,7 @@ func LoadNS() { } // end let return tmp3 default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -33338,7 +33384,7 @@ func LoadNS() { tmp12 := lang.Apply(tmp8, []any{v2, v3, tmp11}) return tmp12 default: - checkArity(args, 6) + checkArityGTE(args, 6) v2 := args[0] _ = v2 v3 := args[1] @@ -33375,7 +33421,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -33476,7 +33522,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -33505,7 +33551,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -33639,7 +33685,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -33762,7 +33808,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -33895,7 +33941,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -33953,7 +33999,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -34003,7 +34049,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -34040,7 +34086,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -34123,7 +34169,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -34210,7 +34256,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -34353,7 +34399,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -34434,7 +34480,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -34547,7 +34593,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -34934,7 +34980,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -35050,7 +35096,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -35153,7 +35199,7 @@ func LoadNS() { } // end let return tmp4 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -35269,7 +35315,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v4 := args[0] _ = v4 v5 := args[1] @@ -35297,7 +35343,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -35423,7 +35469,7 @@ func LoadNS() { tmp5 := lang.Apply(lang.Get, []any{v3, v4}) return tmp5 default: - checkArity(args, 2) + checkArityGTE(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -35700,7 +35746,7 @@ func LoadNS() { _ = v4 return v4 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -35777,7 +35823,7 @@ func LoadNS() { } return tmp3 default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 var tmp3 any @@ -35877,7 +35923,7 @@ func LoadNS() { _ = tmp6 return v5 default: - checkArity(args, 3) + checkArityGTE(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -35923,7 +35969,7 @@ func LoadNS() { _ = tmp8 return v4 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -35969,7 +36015,7 @@ func LoadNS() { _ = tmp8 return v4 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -36015,7 +36061,7 @@ func LoadNS() { _ = tmp8 return v4 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -36061,7 +36107,7 @@ func LoadNS() { _ = tmp8 return v4 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -36107,7 +36153,7 @@ func LoadNS() { _ = tmp8 return v4 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -36153,7 +36199,7 @@ func LoadNS() { _ = tmp8 return v4 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -36199,7 +36245,7 @@ func LoadNS() { _ = tmp8 return v4 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -36245,7 +36291,7 @@ func LoadNS() { _ = tmp8 return v4 default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -36369,6 +36415,7 @@ func LoadNS() { if tmp0.Meta() != nil { var_glojure_DOT_core_assert_DASH_valid_DASH_fdecl.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core_assert_DASH_valid_DASH_fdecl.SetDynamic() } // atom { @@ -36382,7 +36429,7 @@ func LoadNS() { tmp3 := lang.Apply(lang.NewAtom, []any{v2}) return tmp3 default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -36407,7 +36454,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -36608,7 +36655,7 @@ func LoadNS() { tmp7 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v8 any = lang.NewList(args[0:]...) _ = v8 tmp9 := checkDerefVar(var_glojure_DOT_core_apply) @@ -36674,7 +36721,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -36763,7 +36810,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -36907,7 +36954,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -37178,7 +37225,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -37505,7 +37552,7 @@ func LoadNS() { tmp8 := lang.Apply(tmp5, []any{tmp7}) return tmp8 default: - checkArity(args, 2) + checkArityGTE(args, 2) v3 := args[0] _ = v3 v4 := args[1] @@ -37680,7 +37727,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -38316,7 +38363,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -38729,7 +38776,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -38787,7 +38834,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -39158,7 +39205,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -39387,7 +39434,7 @@ func LoadNS() { tmp5 := lang.Apply(lang.NewLazySeq, []any{tmp4}) return tmp5 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -39816,7 +39863,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -39861,7 +39908,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -40160,7 +40207,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp6, []any{v2, tmp5}) return tmp7 default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -40618,7 +40665,7 @@ func LoadNS() { tmp10 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v11 any = lang.NewList(args[0:]...) _ = v11 var tmp12 any @@ -40685,7 +40732,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -41585,7 +41632,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 tmp3 := checkDerefVar(var_glojure_DOT_core_pmap) @@ -41999,7 +42046,7 @@ func LoadNS() { tmp3 := lang.Apply(lang.NewRef, []any{v2}) return tmp3 default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -42317,7 +42364,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -42343,7 +42390,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -42953,7 +43000,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -43071,7 +43118,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -43289,7 +43336,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -43752,7 +43799,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 4) + checkArityGTE(args, 4) v2 := args[0] _ = v2 v3 := args[1] @@ -43816,7 +43863,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 var tmp3 any @@ -44051,7 +44098,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -44338,7 +44385,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -44467,7 +44514,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -44596,7 +44643,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 4) + checkArityGTE(args, 4) v2 := args[0] _ = v2 v3 := args[1] @@ -44861,7 +44908,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v3 := args[0] _ = v3 v4 := args[1] @@ -45913,7 +45960,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -46009,7 +46056,7 @@ func LoadNS() { tmp51 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v52 := args[0] _ = v52 var v53 any = lang.NewList(args[1:]...) @@ -46161,7 +46208,7 @@ func LoadNS() { tmp63 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v64 := args[0] _ = v64 var v65 any = lang.NewList(args[1:]...) @@ -46368,7 +46415,7 @@ func LoadNS() { tmp37 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v38 any = lang.NewList(args[0:]...) _ = v38 tmp39 := checkDerefVar(var_glojure_DOT_core_apply) @@ -47442,7 +47489,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -47513,7 +47560,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -48711,7 +48758,7 @@ func LoadNS() { tmp4 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v5 := args[0] _ = v5 var v6 any = lang.NewList(args[1:]...) @@ -48727,7 +48774,7 @@ func LoadNS() { tmp5 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v6 := args[0] _ = v6 var v7 any = lang.NewList(args[1:]...) @@ -48745,7 +48792,7 @@ func LoadNS() { tmp7 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v8 := args[0] _ = v8 var v9 any = lang.NewList(args[1:]...) @@ -48763,7 +48810,7 @@ func LoadNS() { tmp9 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v10 := args[0] _ = v10 var v11 any = lang.NewList(args[1:]...) @@ -48781,7 +48828,7 @@ func LoadNS() { tmp11 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v12 := args[0] _ = v12 var v13 any = lang.NewList(args[1:]...) @@ -48799,7 +48846,7 @@ func LoadNS() { tmp14 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v15 := args[0] _ = v15 var v16 any = lang.NewList(args[1:]...) @@ -48815,7 +48862,7 @@ func LoadNS() { tmp15 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v16 := args[0] _ = v16 var v17 any = lang.NewList(args[1:]...) @@ -48833,7 +48880,7 @@ func LoadNS() { tmp17 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v18 := args[0] _ = v18 var v19 any = lang.NewList(args[1:]...) @@ -48851,7 +48898,7 @@ func LoadNS() { tmp19 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v20 := args[0] _ = v20 var v21 any = lang.NewList(args[1:]...) @@ -48869,7 +48916,7 @@ func LoadNS() { tmp22 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v23 := args[0] _ = v23 var v24 any = lang.NewList(args[1:]...) @@ -48886,7 +48933,7 @@ func LoadNS() { tmp25 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v26 := args[0] _ = v26 var v27 any = lang.NewList(args[1:]...) @@ -48902,7 +48949,7 @@ func LoadNS() { tmp26 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v27 := args[0] _ = v27 var v28 any = lang.NewList(args[1:]...) @@ -48920,7 +48967,7 @@ func LoadNS() { tmp29 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v30 := args[0] _ = v30 var v31 any = lang.NewList(args[1:]...) @@ -48937,7 +48984,7 @@ func LoadNS() { tmp32 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v33 := args[0] _ = v33 var v34 any = lang.NewList(args[1:]...) @@ -48954,7 +49001,7 @@ func LoadNS() { tmp34 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v35 := args[0] _ = v35 var v36 any = lang.NewList(args[1:]...) @@ -48972,7 +49019,7 @@ func LoadNS() { tmp36 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v37 := args[0] _ = v37 var v38 any = lang.NewList(args[1:]...) @@ -48990,7 +49037,7 @@ func LoadNS() { tmp38 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v39 := args[0] _ = v39 var v40 any = lang.NewList(args[1:]...) @@ -49007,7 +49054,7 @@ func LoadNS() { tmp40 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v41 := args[0] _ = v41 var v42 any = lang.NewList(args[1:]...) @@ -49024,7 +49071,7 @@ func LoadNS() { tmp42 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v43 := args[0] _ = v43 var v44 any = lang.NewList(args[1:]...) @@ -49042,7 +49089,7 @@ func LoadNS() { tmp44 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v45 := args[0] _ = v45 var v46 any = lang.NewList(args[1:]...) @@ -49060,7 +49107,7 @@ func LoadNS() { tmp46 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v47 := args[0] _ = v47 var v48 any = lang.NewList(args[1:]...) @@ -49077,7 +49124,7 @@ func LoadNS() { tmp48 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v49 := args[0] _ = v49 var v50 any = lang.NewList(args[1:]...) @@ -49094,7 +49141,7 @@ func LoadNS() { tmp50 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v51 := args[0] _ = v51 var v52 any = lang.NewList(args[1:]...) @@ -49112,7 +49159,7 @@ func LoadNS() { tmp52 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v53 := args[0] _ = v53 var v54 any = lang.NewList(args[1:]...) @@ -49130,7 +49177,7 @@ func LoadNS() { tmp54 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v55 := args[0] _ = v55 var v56 any = lang.NewList(args[1:]...) @@ -49148,7 +49195,7 @@ func LoadNS() { tmp56 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v57 := args[0] _ = v57 var v58 any = lang.NewList(args[1:]...) @@ -49165,7 +49212,7 @@ func LoadNS() { tmp58 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v59 := args[0] _ = v59 var v60 any = lang.NewList(args[1:]...) @@ -49182,7 +49229,7 @@ func LoadNS() { tmp60 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v61 := args[0] _ = v61 var v62 any = lang.NewList(args[1:]...) @@ -49200,7 +49247,7 @@ func LoadNS() { tmp62 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v63 := args[0] _ = v63 var v64 any = lang.NewList(args[1:]...) @@ -49218,7 +49265,7 @@ func LoadNS() { tmp64 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v65 := args[0] _ = v65 var v66 any = lang.NewList(args[1:]...) @@ -49236,7 +49283,7 @@ func LoadNS() { tmp66 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v67 := args[0] _ = v67 var v68 any = lang.NewList(args[1:]...) @@ -49283,7 +49330,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -49898,7 +49945,7 @@ func LoadNS() { tmp7 := lang.Apply(tmp3, []any{tmp5, tmp6}) return tmp7 default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -50582,7 +50629,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 3) + checkArityGTE(args, 3) v2 := args[0] _ = v2 v3 := args[1] @@ -51657,7 +51704,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -51883,7 +51930,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 var tmp3 any @@ -52603,7 +52650,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 2) + checkArityGTE(args, 2) v2 := args[0] _ = v2 v3 := args[1] @@ -53162,7 +53209,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 var tmp3 any @@ -53731,7 +53778,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 tmp3 := checkDerefVar(var_glojure_DOT_core_apply) @@ -53753,7 +53800,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 var tmp3 any @@ -53803,7 +53850,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 tmp3 := checkDerefVar(var_glojure_DOT_core_apply) @@ -53949,7 +53996,7 @@ func LoadNS() { tmp12 := lang.Apply(tmp6, []any{tmp9, tmp11}) return tmp12 default: - checkArity(args, 4) + checkArityGTE(args, 4) v2 := args[0] _ = v2 v3 := args[1] @@ -54051,7 +54098,7 @@ func LoadNS() { tmp5 := lang.Apply(tmp3, []any{v2, tmp4}) return tmp5 default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -54102,6 +54149,7 @@ func LoadNS() { if tmp0.Meta() != nil { var_glojure_DOT_core_pr.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core_pr.SetDynamic() } // pr-str { @@ -54111,7 +54159,7 @@ func LoadNS() { tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 var tmp4 any @@ -54163,7 +54211,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 var tmp3 any @@ -54205,7 +54253,7 @@ func LoadNS() { tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 var tmp4 any @@ -54257,7 +54305,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v2 := args[0] _ = v2 var v3 any = lang.NewList(args[1:]...) @@ -54283,7 +54331,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 tmp3 := checkDerefVar(var_glojure_DOT_core_apply) @@ -54318,7 +54366,7 @@ func LoadNS() { tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 var tmp4 any @@ -54370,7 +54418,7 @@ func LoadNS() { tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v2 any = lang.NewList(args[0:]...) _ = v2 var tmp3 any @@ -54412,7 +54460,7 @@ func LoadNS() { tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 0) + checkArityGTE(args, 0) var v3 any = lang.NewList(args[0:]...) _ = v3 var tmp4 any @@ -57298,7 +57346,7 @@ func LoadNS() { tmp2 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: - checkArity(args, 1) + checkArityGTE(args, 1) v3 := args[0] _ = v3 var v4 any = lang.NewList(args[1:]...) diff --git a/pkg/runtime/testdata/codegen/test/def_simple/load.go.out b/pkg/runtime/testdata/codegen/test/def_simple/load.go.out index 0e2b3b43..7a378261 100644 --- a/pkg/runtime/testdata/codegen/test/def_simple/load.go.out +++ b/pkg/runtime/testdata/codegen/test/def_simple/load.go.out @@ -26,6 +26,12 @@ func checkArity(args []any, expected int) { } } +func checkArityGTE(args []any, min int) { + if len(args) < min { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + // LoadNS initializes the namespace "codegen.test.def-simple" func LoadNS() { sym_codegen_DOT_test_DOT_def_DASH_simple := lang.NewSymbol("codegen.test.def-simple") diff --git a/pkg/runtime/testdata/codegen/test/fn_closure/load.go.out b/pkg/runtime/testdata/codegen/test/fn_closure/load.go.out index fdfbe948..6db8e8f1 100644 --- a/pkg/runtime/testdata/codegen/test/fn_closure/load.go.out +++ b/pkg/runtime/testdata/codegen/test/fn_closure/load.go.out @@ -26,6 +26,12 @@ func checkArity(args []any, expected int) { } } +func checkArityGTE(args []any, min int) { + if len(args) < min { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + // LoadNS initializes the namespace "codegen.test.fn-closure" func LoadNS() { sym__DASH_main := lang.NewSymbol("-main") diff --git a/pkg/runtime/testdata/codegen/test/fn_recur/load.go.out b/pkg/runtime/testdata/codegen/test/fn_recur/load.go.out index 41c58d54..0e62fdef 100644 --- a/pkg/runtime/testdata/codegen/test/fn_recur/load.go.out +++ b/pkg/runtime/testdata/codegen/test/fn_recur/load.go.out @@ -26,6 +26,12 @@ func checkArity(args []any, expected int) { } } +func checkArityGTE(args []any, min int) { + if len(args) < min { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + // LoadNS initializes the namespace "codegen.test.fn-recur" func LoadNS() { sym__PLUS_ := lang.NewSymbol("+") @@ -100,7 +106,7 @@ func LoadNS() { _ = v7 v8 := args[2] _ = v8 - recur_loop_1612: + recur_loop_1617: var tmp9 any tmp10 := checkDerefVar(var_glojure_DOT_core__EQ_) tmp11 := lang.Apply(tmp10, []any{v8, v2}) @@ -117,7 +123,7 @@ func LoadNS() { v6 = tmp12 v7 = tmp13 v8 = tmp16 - goto recur_loop_1612 + goto recur_loop_1617 } return tmp9 }) diff --git a/pkg/runtime/testdata/codegen/test/loop_simple/load.go.out b/pkg/runtime/testdata/codegen/test/loop_simple/load.go.out index 2f3bfea2..9ce4defe 100644 --- a/pkg/runtime/testdata/codegen/test/loop_simple/load.go.out +++ b/pkg/runtime/testdata/codegen/test/loop_simple/load.go.out @@ -26,6 +26,12 @@ func checkArity(args []any, expected int) { } } +func checkArityGTE(args []any, min int) { + if len(args) < min { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + // LoadNS initializes the namespace "codegen.test.loop-simple" func LoadNS() { sym__DASH_main := lang.NewSymbol("-main") diff --git a/pkg/runtime/testdata/codegen/test/maybe_class/load.go.out b/pkg/runtime/testdata/codegen/test/maybe_class/load.go.out index ecaeebb8..c853add0 100644 --- a/pkg/runtime/testdata/codegen/test/maybe_class/load.go.out +++ b/pkg/runtime/testdata/codegen/test/maybe_class/load.go.out @@ -27,6 +27,12 @@ func checkArity(args []any, expected int) { } } +func checkArityGTE(args []any, min int) { + if len(args) < min { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + // LoadNS initializes the namespace "codegen.test.maybe-class" func LoadNS() { sym__DASH_main := lang.NewSymbol("-main") diff --git a/pkg/runtime/testdata/codegen/test/multifn/load.go.out b/pkg/runtime/testdata/codegen/test/multifn/load.go.out index b35ab5ad..3a27f45d 100644 --- a/pkg/runtime/testdata/codegen/test/multifn/load.go.out +++ b/pkg/runtime/testdata/codegen/test/multifn/load.go.out @@ -26,6 +26,12 @@ func checkArity(args []any, expected int) { } } +func checkArityGTE(args []any, min int) { + if len(args) < min { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + // LoadNS initializes the namespace "codegen.test.multifn" func LoadNS() { sym__PLUS_ := lang.NewSymbol("+") @@ -100,6 +106,7 @@ func LoadNS() { return tmp6 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_file, "codegen/test/multifn.glj", kw_line, int(3), kw_column, int(44), kw_end_DASH_line, int(3), kw_end_DASH_column, int(62))).(lang.FnFunc) + // MultiFn add tmp1 := lang.NewMultiFn("add", tmp2, kw_default, lang.FindOrCreateNamespace(sym_glojure_DOT_core).FindInternedVar(sym_global_DASH_hierarchy)) tmp3 := reflect.TypeOf(int64(0)) var tmp4 lang.FnFunc diff --git a/pkg/runtime/testdata/codegen/test/ns_skip/load.go.out b/pkg/runtime/testdata/codegen/test/ns_skip/load.go.out index 1a3cc8f4..b144ee3c 100644 --- a/pkg/runtime/testdata/codegen/test/ns_skip/load.go.out +++ b/pkg/runtime/testdata/codegen/test/ns_skip/load.go.out @@ -26,6 +26,12 @@ func checkArity(args []any, expected int) { } } +func checkArityGTE(args []any, min int) { + if len(args) < min { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + // LoadNS initializes the namespace "codegen.test.ns-skip" func LoadNS() { sym_codegen_DOT_test_DOT_ns_DASH_skip := lang.NewSymbol("codegen.test.ns-skip") diff --git a/pkg/runtime/testdata/codegen/test/quote_simple/load.go.out b/pkg/runtime/testdata/codegen/test/quote_simple/load.go.out index 8d74972f..60b0b88f 100644 --- a/pkg/runtime/testdata/codegen/test/quote_simple/load.go.out +++ b/pkg/runtime/testdata/codegen/test/quote_simple/load.go.out @@ -26,6 +26,12 @@ func checkArity(args []any, expected int) { } } +func checkArityGTE(args []any, min int) { + if len(args) < min { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + // LoadNS initializes the namespace "codegen.test.quote-simple" func LoadNS() { sym__DASH_main := lang.NewSymbol("-main") diff --git a/pkg/runtime/testdata/codegen/test/ref/load.go.out b/pkg/runtime/testdata/codegen/test/ref/load.go.out index 1a8e8e99..11e78721 100644 --- a/pkg/runtime/testdata/codegen/test/ref/load.go.out +++ b/pkg/runtime/testdata/codegen/test/ref/load.go.out @@ -26,6 +26,12 @@ func checkArity(args []any, expected int) { } } +func checkArityGTE(args []any, min int) { + if len(args) < min { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + // LoadNS initializes the namespace "codegen.test.ref" func LoadNS() { sym__DASH_main := lang.NewSymbol("-main") diff --git a/pkg/runtime/testdata/codegen/test/the_var/load.go.out b/pkg/runtime/testdata/codegen/test/the_var/load.go.out index 1cfaf7ac..de8dd858 100644 --- a/pkg/runtime/testdata/codegen/test/the_var/load.go.out +++ b/pkg/runtime/testdata/codegen/test/the_var/load.go.out @@ -26,6 +26,12 @@ func checkArity(args []any, expected int) { } } +func checkArityGTE(args []any, min int) { + if len(args) < min { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + // LoadNS initializes the namespace "codegen.test.the-var" func LoadNS() { sym__DASH_main := lang.NewSymbol("-main") diff --git a/pkg/runtime/testdata/codegen/test/throw_simple/load.go.out b/pkg/runtime/testdata/codegen/test/throw_simple/load.go.out index 89f1811a..ac1e0bbb 100644 --- a/pkg/runtime/testdata/codegen/test/throw_simple/load.go.out +++ b/pkg/runtime/testdata/codegen/test/throw_simple/load.go.out @@ -26,6 +26,12 @@ func checkArity(args []any, expected int) { } } +func checkArityGTE(args []any, min int) { + if len(args) < min { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + // LoadNS initializes the namespace "codegen.test.throw-simple" func LoadNS() { sym__DASH_main := lang.NewSymbol("-main") diff --git a/pkg/runtime/testdata/codegen/test/try_advanced/load.go.out b/pkg/runtime/testdata/codegen/test/try_advanced/load.go.out index a8843df5..50f91bf3 100644 --- a/pkg/runtime/testdata/codegen/test/try_advanced/load.go.out +++ b/pkg/runtime/testdata/codegen/test/try_advanced/load.go.out @@ -26,6 +26,12 @@ func checkArity(args []any, expected int) { } } +func checkArityGTE(args []any, min int) { + if len(args) < min { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + // LoadNS initializes the namespace "codegen.test.try-advanced" func LoadNS() { sym__DASH_main := lang.NewSymbol("-main") diff --git a/pkg/runtime/testdata/codegen/test/try_basic/load.go.out b/pkg/runtime/testdata/codegen/test/try_basic/load.go.out index 9fe7d228..5611931e 100644 --- a/pkg/runtime/testdata/codegen/test/try_basic/load.go.out +++ b/pkg/runtime/testdata/codegen/test/try_basic/load.go.out @@ -26,6 +26,12 @@ func checkArity(args []any, expected int) { } } +func checkArityGTE(args []any, min int) { + if len(args) < min { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + // LoadNS initializes the namespace "codegen.test.try-basic" func LoadNS() { sym__DASH_main := lang.NewSymbol("-main") diff --git a/pkg/runtime/testdata/codegen/test/values/load.go.out b/pkg/runtime/testdata/codegen/test/values/load.go.out index d2f460e7..cc88e07a 100644 --- a/pkg/runtime/testdata/codegen/test/values/load.go.out +++ b/pkg/runtime/testdata/codegen/test/values/load.go.out @@ -28,6 +28,12 @@ func checkArity(args []any, expected int) { } } +func checkArityGTE(args []any, min int) { + if len(args) < min { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + // LoadNS initializes the namespace "codegen.test.values" func LoadNS() { sym__DASH_main := lang.NewSymbol("-main") diff --git a/pkg/runtime/testdata/codegen/test/with_meta/load.go.out b/pkg/runtime/testdata/codegen/test/with_meta/load.go.out index 49d92d10..56ce699d 100644 --- a/pkg/runtime/testdata/codegen/test/with_meta/load.go.out +++ b/pkg/runtime/testdata/codegen/test/with_meta/load.go.out @@ -26,6 +26,12 @@ func checkArity(args []any, expected int) { } } +func checkArityGTE(args []any, min int) { + if len(args) < min { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + // LoadNS initializes the namespace "codegen.test.with-meta" func LoadNS() { sym__DASH_main := lang.NewSymbol("-main") From 16a011694fec1703e271c7870712c4e1d979ab81 Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Sun, 31 Aug 2025 22:08:47 -0700 Subject: [PATCH 57/67] Fix codegen run test Signed-off-by: James Hamlin --- pkg/runtime/codegengotest/codegengo_test.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkg/runtime/codegengotest/codegengo_test.go b/pkg/runtime/codegengotest/codegengo_test.go index 152f49eb..5cc3f390 100644 --- a/pkg/runtime/codegengotest/codegengo_test.go +++ b/pkg/runtime/codegengotest/codegengo_test.go @@ -214,13 +214,13 @@ import ( "fmt" "os" - "testprog/{{.PkgName}}" + testpkg "testprog/{{.PkgName}}" "github.com/glojurelang/glojure/pkg/lang" _ "github.com/glojurelang/glojure/pkg/glj" ) func main() { - {{.PkgName}}.LoadNS() + testpkg.LoadNS() ns := lang.FindNamespace(lang.NewSymbol("{{.NsName}}")) if ns == nil { From a1a3bda653e54bd8edf046754c4306b5ba47a88f Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Mon, 1 Sep 2025 00:57:58 -0700 Subject: [PATCH 58/67] Implement set! Signed-off-by: James Hamlin --- Makefile | 2 +- pkg/gen/gljimports/gljimports_darwin_amd64.go | 1 + pkg/gen/gljimports/gljimports_darwin_arm64.go | 1 + pkg/gen/gljimports/gljimports_js_wasm.go | 1 + pkg/gen/gljimports/gljimports_linux_amd64.go | 1 + pkg/gen/gljimports/gljimports_linux_arm64.go | 1 + .../gljimports/gljimports_windows_amd64.go | 1 + pkg/gen/gljimports/gljimports_windows_arm.go | 1 + pkg/lang/persistentstructmap.go | 4 + pkg/runtime/codegen.go | 140 +- .../testdata/codegen/test/core/load.go.out | 1649 ++++++++-------- .../testdata/codegen/test/set_bang.glj | 17 + .../codegen/test/set_bang/load.go.out | 218 +++ pkg/stdlib/glojure/core.glj | 232 +-- pkg/stdlib/glojure/core/async/loader.go | 322 +++- pkg/stdlib/glojure/core/loader.go | 1657 +++++++++-------- pkg/stdlib/glojure/core_deftype/loader.go | 1657 +++++++++-------- pkg/stdlib/glojure/core_print/loader.go | 1657 +++++++++-------- scripts/rewrite-core/rewrite.clj | 4 +- 19 files changed, 4082 insertions(+), 3484 deletions(-) create mode 100644 pkg/runtime/testdata/codegen/test/set_bang.glj create mode 100644 pkg/runtime/testdata/codegen/test/set_bang/load.go.out diff --git a/Makefile b/Makefile index b108658b..c3752460 100644 --- a/Makefile +++ b/Makefile @@ -43,7 +43,7 @@ pkg/stdlib/glojure/%.glj: scripts/rewrite-core/originals/%.clj scripts/rewrite-c @mkdir -p $(dir $@) @scripts/rewrite-core/run.sh $< > $@ -bin/%/glj: $(wildcard ./cmd/glj/*.go) $(wildcard ./pkg/**/*.go) $(wildcard ./internal/**/*.go) +bin/%/glj: generate $(wildcard ./cmd/glj/*.go) $(wildcard ./pkg/**/*.go) $(wildcard ./internal/**/*.go) @echo "Building $@" @mkdir -p $(dir $@) @scripts/build-glj.sh $@ $* diff --git a/pkg/gen/gljimports/gljimports_darwin_amd64.go b/pkg/gen/gljimports/gljimports_darwin_amd64.go index 7f83ec74..43392f34 100644 --- a/pkg/gen/gljimports/gljimports_darwin_amd64.go +++ b/pkg/gen/gljimports/gljimports_darwin_amd64.go @@ -3521,6 +3521,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.GT", github_com_glojurelang_glojure_pkg_lang.GT) _register("github.com/glojurelang/glojure/pkg/lang.Get", github_com_glojurelang_glojure_pkg_lang.Get) _register("github.com/glojurelang/glojure/pkg/lang.GetDefault", github_com_glojurelang_glojure_pkg_lang.GetDefault) + _register("github.com/glojurelang/glojure/pkg/lang.GetPersistentStructMapAccessor", github_com_glojurelang_glojure_pkg_lang.GetPersistentStructMapAccessor) _register("github.com/glojurelang/glojure/pkg/lang.GlobalEnv", github_com_glojurelang_glojure_pkg_lang.GlobalEnv) _register("github.com/glojurelang/glojure/pkg/lang.GoAppend", github_com_glojurelang_glojure_pkg_lang.GoAppend) _register("github.com/glojurelang/glojure/pkg/lang.GoCap", github_com_glojurelang_glojure_pkg_lang.GoCap) diff --git a/pkg/gen/gljimports/gljimports_darwin_arm64.go b/pkg/gen/gljimports/gljimports_darwin_arm64.go index 4c71c2ae..1b4c5cb6 100644 --- a/pkg/gen/gljimports/gljimports_darwin_arm64.go +++ b/pkg/gen/gljimports/gljimports_darwin_arm64.go @@ -3521,6 +3521,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.GT", github_com_glojurelang_glojure_pkg_lang.GT) _register("github.com/glojurelang/glojure/pkg/lang.Get", github_com_glojurelang_glojure_pkg_lang.Get) _register("github.com/glojurelang/glojure/pkg/lang.GetDefault", github_com_glojurelang_glojure_pkg_lang.GetDefault) + _register("github.com/glojurelang/glojure/pkg/lang.GetPersistentStructMapAccessor", github_com_glojurelang_glojure_pkg_lang.GetPersistentStructMapAccessor) _register("github.com/glojurelang/glojure/pkg/lang.GlobalEnv", github_com_glojurelang_glojure_pkg_lang.GlobalEnv) _register("github.com/glojurelang/glojure/pkg/lang.GoAppend", github_com_glojurelang_glojure_pkg_lang.GoAppend) _register("github.com/glojurelang/glojure/pkg/lang.GoCap", github_com_glojurelang_glojure_pkg_lang.GoCap) diff --git a/pkg/gen/gljimports/gljimports_js_wasm.go b/pkg/gen/gljimports/gljimports_js_wasm.go index f5b8eec8..222ad6b6 100644 --- a/pkg/gen/gljimports/gljimports_js_wasm.go +++ b/pkg/gen/gljimports/gljimports_js_wasm.go @@ -3521,6 +3521,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.GT", github_com_glojurelang_glojure_pkg_lang.GT) _register("github.com/glojurelang/glojure/pkg/lang.Get", github_com_glojurelang_glojure_pkg_lang.Get) _register("github.com/glojurelang/glojure/pkg/lang.GetDefault", github_com_glojurelang_glojure_pkg_lang.GetDefault) + _register("github.com/glojurelang/glojure/pkg/lang.GetPersistentStructMapAccessor", github_com_glojurelang_glojure_pkg_lang.GetPersistentStructMapAccessor) _register("github.com/glojurelang/glojure/pkg/lang.GlobalEnv", github_com_glojurelang_glojure_pkg_lang.GlobalEnv) _register("github.com/glojurelang/glojure/pkg/lang.GoAppend", github_com_glojurelang_glojure_pkg_lang.GoAppend) _register("github.com/glojurelang/glojure/pkg/lang.GoCap", github_com_glojurelang_glojure_pkg_lang.GoCap) diff --git a/pkg/gen/gljimports/gljimports_linux_amd64.go b/pkg/gen/gljimports/gljimports_linux_amd64.go index 0c93078f..c2c8066f 100644 --- a/pkg/gen/gljimports/gljimports_linux_amd64.go +++ b/pkg/gen/gljimports/gljimports_linux_amd64.go @@ -3521,6 +3521,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.GT", github_com_glojurelang_glojure_pkg_lang.GT) _register("github.com/glojurelang/glojure/pkg/lang.Get", github_com_glojurelang_glojure_pkg_lang.Get) _register("github.com/glojurelang/glojure/pkg/lang.GetDefault", github_com_glojurelang_glojure_pkg_lang.GetDefault) + _register("github.com/glojurelang/glojure/pkg/lang.GetPersistentStructMapAccessor", github_com_glojurelang_glojure_pkg_lang.GetPersistentStructMapAccessor) _register("github.com/glojurelang/glojure/pkg/lang.GlobalEnv", github_com_glojurelang_glojure_pkg_lang.GlobalEnv) _register("github.com/glojurelang/glojure/pkg/lang.GoAppend", github_com_glojurelang_glojure_pkg_lang.GoAppend) _register("github.com/glojurelang/glojure/pkg/lang.GoCap", github_com_glojurelang_glojure_pkg_lang.GoCap) diff --git a/pkg/gen/gljimports/gljimports_linux_arm64.go b/pkg/gen/gljimports/gljimports_linux_arm64.go index 74d12e52..4a9ba3c1 100644 --- a/pkg/gen/gljimports/gljimports_linux_arm64.go +++ b/pkg/gen/gljimports/gljimports_linux_arm64.go @@ -3521,6 +3521,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.GT", github_com_glojurelang_glojure_pkg_lang.GT) _register("github.com/glojurelang/glojure/pkg/lang.Get", github_com_glojurelang_glojure_pkg_lang.Get) _register("github.com/glojurelang/glojure/pkg/lang.GetDefault", github_com_glojurelang_glojure_pkg_lang.GetDefault) + _register("github.com/glojurelang/glojure/pkg/lang.GetPersistentStructMapAccessor", github_com_glojurelang_glojure_pkg_lang.GetPersistentStructMapAccessor) _register("github.com/glojurelang/glojure/pkg/lang.GlobalEnv", github_com_glojurelang_glojure_pkg_lang.GlobalEnv) _register("github.com/glojurelang/glojure/pkg/lang.GoAppend", github_com_glojurelang_glojure_pkg_lang.GoAppend) _register("github.com/glojurelang/glojure/pkg/lang.GoCap", github_com_glojurelang_glojure_pkg_lang.GoCap) diff --git a/pkg/gen/gljimports/gljimports_windows_amd64.go b/pkg/gen/gljimports/gljimports_windows_amd64.go index b547e9c9..3e87c1f3 100644 --- a/pkg/gen/gljimports/gljimports_windows_amd64.go +++ b/pkg/gen/gljimports/gljimports_windows_amd64.go @@ -3521,6 +3521,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.GT", github_com_glojurelang_glojure_pkg_lang.GT) _register("github.com/glojurelang/glojure/pkg/lang.Get", github_com_glojurelang_glojure_pkg_lang.Get) _register("github.com/glojurelang/glojure/pkg/lang.GetDefault", github_com_glojurelang_glojure_pkg_lang.GetDefault) + _register("github.com/glojurelang/glojure/pkg/lang.GetPersistentStructMapAccessor", github_com_glojurelang_glojure_pkg_lang.GetPersistentStructMapAccessor) _register("github.com/glojurelang/glojure/pkg/lang.GlobalEnv", github_com_glojurelang_glojure_pkg_lang.GlobalEnv) _register("github.com/glojurelang/glojure/pkg/lang.GoAppend", github_com_glojurelang_glojure_pkg_lang.GoAppend) _register("github.com/glojurelang/glojure/pkg/lang.GoCap", github_com_glojurelang_glojure_pkg_lang.GoCap) diff --git a/pkg/gen/gljimports/gljimports_windows_arm.go b/pkg/gen/gljimports/gljimports_windows_arm.go index 28d49684..14e7a08f 100644 --- a/pkg/gen/gljimports/gljimports_windows_arm.go +++ b/pkg/gen/gljimports/gljimports_windows_arm.go @@ -3521,6 +3521,7 @@ func RegisterImports(_register func(string, interface{})) { _register("github.com/glojurelang/glojure/pkg/lang.GT", github_com_glojurelang_glojure_pkg_lang.GT) _register("github.com/glojurelang/glojure/pkg/lang.Get", github_com_glojurelang_glojure_pkg_lang.Get) _register("github.com/glojurelang/glojure/pkg/lang.GetDefault", github_com_glojurelang_glojure_pkg_lang.GetDefault) + _register("github.com/glojurelang/glojure/pkg/lang.GetPersistentStructMapAccessor", github_com_glojurelang_glojure_pkg_lang.GetPersistentStructMapAccessor) _register("github.com/glojurelang/glojure/pkg/lang.GlobalEnv", github_com_glojurelang_glojure_pkg_lang.GlobalEnv) _register("github.com/glojurelang/glojure/pkg/lang.GoAppend", github_com_glojurelang_glojure_pkg_lang.GoAppend) _register("github.com/glojurelang/glojure/pkg/lang.GoCap", github_com_glojurelang_glojure_pkg_lang.GoCap) diff --git a/pkg/lang/persistentstructmap.go b/pkg/lang/persistentstructmap.go index 0d90cecb..a1554e51 100644 --- a/pkg/lang/persistentstructmap.go +++ b/pkg/lang/persistentstructmap.go @@ -108,6 +108,10 @@ func CreatePersistentStructMapSlotMap(keys ISeq) *PersistentStructMapDef { } } +func GetPersistentStructMapAccessor() any { + panic("not implemented") +} + func newPersistentStructMap(meta IPersistentMap, def *PersistentStructMapDef, vals []any, ext IPersistentMap) *PersistentStructMap { return &PersistentStructMap{ meta: meta, diff --git a/pkg/runtime/codegen.go b/pkg/runtime/codegen.go index 70e30df1..df864d4f 100644 --- a/pkg/runtime/codegen.go +++ b/pkg/runtime/codegen.go @@ -9,6 +9,7 @@ import ( "reflect" "sort" "strings" + "time" "github.com/glojurelang/glojure/pkg/ast" "github.com/glojurelang/glojure/pkg/lang" @@ -468,6 +469,11 @@ func (g *Generator) generateValue(value any) string { return fmt.Sprintf("int64(%d)", v) case float64: return fmt.Sprintf("float64(%g)", v) + case float32: + return fmt.Sprintf("float32(%g)", v) + case time.Duration: + alias := g.addImportWithAlias("time") + return fmt.Sprintf("%s.Duration(%d)", alias, int64(v)) case *lang.BigDecimal: return g.generateBigDecimalValue(v) case bool: @@ -517,10 +523,14 @@ func (g *Generator) generateTypeValue(t reflect.Type) string { // generateZeroValueExpr generates a Go expression that creates a zero value // of the given type, handling package imports as needed func (g *Generator) generateZeroValueExpr(t reflect.Type) string { - // TODO: review this LLM slop + // TODO: review this LLM slop. for numeric types, return the type + // cast of 0 with the (possibly aliased) type name switch { case t == reflect.TypeOf(lang.NewChar('a')): return "lang.NewChar(0)" + case t == reflect.TypeOf(time.Duration(0)): + alias := g.addImportWithAlias("time") + return fmt.Sprintf("%s.Duration(0)", alias) } switch t.Kind() { @@ -975,8 +985,7 @@ func (g *Generator) generateASTNode(node *ast.Node) (res string) { fmt.Println("Def not yet implemented; returning nil") return "nil" case ast.OpSetBang: - fmt.Println("SetBang not yet implemented; returning nil") - return "nil" + return g.generateSetBang(node) case ast.OpLetFn: fmt.Println("LetFn not yet implemented; returning nil") return "nil" @@ -1469,6 +1478,7 @@ var ( "java.io.StringReader": true, "java.util.concurrent.CountDownLatch": true, "java.util.concurrent": true, + "java.lang": true, } ) @@ -1489,6 +1499,10 @@ func (g *Generator) generateMaybeClass(node *ast.Node) string { } } + return g.generateGoExportedName(pkg) +} + +func (g *Generator) generateGoExportedName(pkg string) string { // find last dot in the package name dotIndex := strings.LastIndex(pkg, ".") if dotIndex == -1 { @@ -1510,6 +1524,11 @@ func (g *Generator) generateMaybeClass(node *ast.Node) string { } alias := g.addImportWithAlias(packageName) + if strings.HasPrefix(exportedName, "*") { + // pointers look like package.*Type + exportedName = exportedName[1:] + alias = "*" + alias + } return alias + "." + exportedName } @@ -1588,28 +1607,106 @@ func (g *Generator) generateTheVar(node *ast.Node) string { return resultId } +// generateSetBang generates code for a set! operation +func (g *Generator) generateSetBang(node *ast.Node) string { + setBangNode := node.Sub.(*ast.SetBangNode) + + // Generate the value expression + valExpr := g.generateASTNode(setBangNode.Val) + + // Handle the target + target := setBangNode.Target + switch target.Op { + case ast.OpVar: + // Setting a Var + varNode := target.Sub.(*ast.VarNode) + varNamespace := varNode.Var.Namespace() + varSymbol := varNode.Var.Symbol() + + // Look up the var variable + varId := g.allocVarVar(varNamespace.Name().String(), varSymbol.String()) + + // Call Set on the Var and return the value + resultId := g.allocateTempVar() + g.writef("%s := %s.Set(%s)\n", resultId, varId, valExpr) + return resultId + + case ast.OpHostInterop: + // Setting a host field + interopNode := target.Sub.(*ast.HostInteropNode) + tgt := interopNode.Target + targetExpr := g.generateASTNode(tgt) + field := interopNode.MOrF + + resultId := g.allocateTempVar() + + // Generate reflection-based field setting + g.writef("// set! host field\n") + g.writef("var %s any\n", resultId) + g.writef("{\n") + g.writef(" targetV := reflect.ValueOf(%s)\n", targetExpr) + g.writef(" if targetV.Kind() == reflect.Ptr {\n") + g.writef(" targetV = targetV.Elem()\n") + g.writef(" }\n") + g.writef(" fieldVal := targetV.FieldByName(%q)\n", field.Name()) + g.writef(" if !fieldVal.IsValid() {\n") + g.writef(" panic(fmt.Errorf(\"no such field %s\"))\n", field.Name()) + g.writef(" }\n") + g.writef(" if !fieldVal.CanSet() {\n") + g.writef(" panic(fmt.Errorf(\"cannot set field %s\"))\n", field.Name()) + g.writef(" }\n") + g.writef(" valV := reflect.ValueOf(%s)\n", valExpr) + g.writef(" if !valV.IsValid() {\n") + g.writef(" switch fieldVal.Kind() {\n") + g.writef(" case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Pointer, reflect.Slice, reflect.UnsafePointer:\n") + g.writef(" fieldVal.Set(reflect.Zero(fieldVal.Type()))\n") + g.writef(" default:\n") + g.writef(" panic(fmt.Errorf(\"cannot set field %s to nil\"))\n", field.Name()) + g.writef(" }\n") + g.writef(" } else {\n") + g.writef(" fieldVal.Set(valV)\n") + g.writef(" }\n") + g.writef(" %s = %s\n", resultId, valExpr) + g.writef("}\n") + return resultId + + default: + //return fmt.Sprintf("%q", "unimplemented: set! target type") + return `"unimplemented: set! target type"` + //panic(fmt.Sprintf("unsupported set! target: %v", target.Op)) + } +} + func (g *Generator) generateNew(node *ast.Node) string { newNode := node.Sub.(*ast.NewNode) // the interpreter is more lax; it allows for expressions that evaluate to a type // here we assume the class is a constant type. clojure's new form is similar - constNode, ok := newNode.Class.Sub.(*ast.ConstNode) - if !ok { - fmt.Println("Warning: glojure codegen only supports new with constant class types.") - return fmt.Sprintf("%q", "unimplemented: new with non-constant class type") - } - - class, ok := constNode.Value.(reflect.Type) - if !ok { - fmt.Println("Warning: glojure codegen only supports new with constant class types.") + switch sub := newNode.Class.Sub.(type) { + case *ast.ConstNode: + class, ok := sub.Value.(reflect.Type) + if !ok { + fmt.Printf("Warning: glojure codegen only supports new with constant class types. Got %T\n", sub.Value) + return fmt.Sprintf("%q", "unimplemented: new with non-constant class type") + } + // generate a reflect.Type for the class + classId := g.generateValue(class) + resultId := g.allocateTempVar() + g.writef("%s := reflect.New(%s).Interface()\n", resultId, classId) + return resultId + case *ast.MaybeClassNode: + resultId := g.allocateTempVar() + className := g.generateGoExportedName(sub.Class.(*lang.Symbol).FullName()) + if className == "nil" { + fmt.Printf("Failed to resolve class for new, generating nil: %v\n", sub.Class) + return "nil" + } + g.writef("%s := new(%s)\n", resultId, className) + return resultId + default: + fmt.Printf("Warning: glojure codegen only supports new with constant class types. Got %T\n", newNode.Class.Sub) return fmt.Sprintf("%q", "unimplemented: new with non-constant class type") } - - // generate a reflect.Type for the class - classId := g.generateValue(class) - resultId := g.allocateTempVar() - g.writef("%s := reflect.New(%s).Interface()\n", resultId, classId) - return resultId } //////////////////////////////////////////////////////////////////////////////// @@ -1947,7 +2044,12 @@ func isRuntimeOwnedVar(v *lang.Var) bool { } func getWellKnownFunctionName(fn any) (string, bool) { - ptr := reflect.ValueOf(fn).Pointer() + val := reflect.ValueOf(fn) + // ensure it's a function + if val.Kind() != reflect.Func { + return "", false + } + ptr := val.Pointer() name, ok := wellKnownFunctions[ptr] return name, ok } diff --git a/pkg/runtime/testdata/codegen/test/core/load.go.out b/pkg/runtime/testdata/codegen/test/core/load.go.out index fb745700..e7bcb159 100644 --- a/pkg/runtime/testdata/codegen/test/core/load.go.out +++ b/pkg/runtime/testdata/codegen/test/core/load.go.out @@ -274,6 +274,7 @@ func LoadNS() { sym_codegen_DOT_test_DOT_ns_DASH_skip := lang.NewSymbol("codegen.test.ns-skip") sym_codegen_DOT_test_DOT_quote_DASH_simple := lang.NewSymbol("codegen.test.quote-simple") sym_codegen_DOT_test_DOT_ref := lang.NewSymbol("codegen.test.ref") + sym_codegen_DOT_test_DOT_set_DASH_bang := lang.NewSymbol("codegen.test.set-bang") sym_codegen_DOT_test_DOT_the_DASH_var := lang.NewSymbol("codegen.test.the-var") sym_codegen_DOT_test_DOT_throw_DASH_simple := lang.NewSymbol("codegen.test.throw-simple") sym_codegen_DOT_test_DOT_try_DASH_advanced := lang.NewSymbol("codegen.test.try-advanced") @@ -512,68 +513,22 @@ func LoadNS() { sym_glojure_DOT_core_SLASH_Array := lang.NewSymbol("glojure.core/Array") sym_glojure_DOT_core_SLASH_Aset := lang.NewSymbol("glojure.core/Aset") sym_glojure_DOT_core_SLASH_AssertionError := lang.NewSymbol("glojure.core/AssertionError") - sym_glojure_DOT_core_SLASH_BooleanArray := lang.NewSymbol("glojure.core/BooleanArray") sym_glojure_DOT_core_SLASH_BooleanCast := lang.NewSymbol("glojure.core/BooleanCast") - sym_glojure_DOT_core_SLASH_Booleans := lang.NewSymbol("glojure.core/Booleans") - sym_glojure_DOT_core_SLASH_ByteArray := lang.NewSymbol("glojure.core/ByteArray") - sym_glojure_DOT_core_SLASH_Bytes := lang.NewSymbol("glojure.core/Bytes") - sym_glojure_DOT_core_SLASH_CharArray := lang.NewSymbol("glojure.core/CharArray") - sym_glojure_DOT_core_SLASH_Chars := lang.NewSymbol("glojure.core/Chars") sym_glojure_DOT_core_SLASH_Count := lang.NewSymbol("glojure.core/Count") - sym_glojure_DOT_core_SLASH_DecP := lang.NewSymbol("glojure.core/DecP") - sym_glojure_DOT_core_SLASH_DoubleArray := lang.NewSymbol("glojure.core/DoubleArray") sym_glojure_DOT_core_SLASH_DoubleCast := lang.NewSymbol("glojure.core/DoubleCast") - sym_glojure_DOT_core_SLASH_Doubles := lang.NewSymbol("glojure.core/Doubles") - sym_glojure_DOT_core_SLASH_Equiv := lang.NewSymbol("glojure.core/Equiv") - sym_glojure_DOT_core_SLASH_FloatArray := lang.NewSymbol("glojure.core/FloatArray") - sym_glojure_DOT_core_SLASH_Floats := lang.NewSymbol("glojure.core/Floats") sym_glojure_DOT_core_SLASH_Get := lang.NewSymbol("glojure.core/Get") - sym_glojure_DOT_core_SLASH_Gt := lang.NewSymbol("glojure.core/Gt") - sym_glojure_DOT_core_SLASH_Gte := lang.NewSymbol("glojure.core/Gte") sym_glojure_DOT_core_SLASH_IllegalStateException := lang.NewSymbol("glojure.core/IllegalStateException") - sym_glojure_DOT_core_SLASH_IncP := lang.NewSymbol("glojure.core/IncP") - sym_glojure_DOT_core_SLASH_IntArray := lang.NewSymbol("glojure.core/IntArray") - sym_glojure_DOT_core_SLASH_Ints := lang.NewSymbol("glojure.core/Ints") - sym_glojure_DOT_core_SLASH_IsNeg := lang.NewSymbol("glojure.core/IsNeg") - sym_glojure_DOT_core_SLASH_IsPos := lang.NewSymbol("glojure.core/IsPos") - sym_glojure_DOT_core_SLASH_IsZero := lang.NewSymbol("glojure.core/IsZero") - sym_glojure_DOT_core_SLASH_LongArray := lang.NewSymbol("glojure.core/LongArray") sym_glojure_DOT_core_SLASH_LongCast := lang.NewSymbol("glojure.core/LongCast") - sym_glojure_DOT_core_SLASH_Longs := lang.NewSymbol("glojure.core/Longs") - sym_glojure_DOT_core_SLASH_Lt := lang.NewSymbol("glojure.core/Lt") - sym_glojure_DOT_core_SLASH_Lte := lang.NewSymbol("glojure.core/Lte") - sym_glojure_DOT_core_SLASH_Not := lang.NewSymbol("glojure.core/Not") sym_glojure_DOT_core_SLASH_Nth := lang.NewSymbol("glojure.core/Nth") - sym_glojure_DOT_core_SLASH_Num := lang.NewSymbol("glojure.core/Num") sym_glojure_DOT_core_SLASH_Object_array := lang.NewSymbol("glojure.core/Object_array") - sym_glojure_DOT_core_SLASH_Quotient := lang.NewSymbol("glojure.core/Quotient") - sym_glojure_DOT_core_SLASH_Remainder := lang.NewSymbol("glojure.core/Remainder") sym_glojure_DOT_core_SLASH_RunInTransaction := lang.NewSymbol("glojure.core/RunInTransaction") - sym_glojure_DOT_core_SLASH_ShiftLeft := lang.NewSymbol("glojure.core/ShiftLeft") - sym_glojure_DOT_core_SLASH_ShiftRight := lang.NewSymbol("glojure.core/ShiftRight") - sym_glojure_DOT_core_SLASH_ShortArray := lang.NewSymbol("glojure.core/ShortArray") - sym_glojure_DOT_core_SLASH_Shorts := lang.NewSymbol("glojure.core/Shorts") - sym_glojure_DOT_core_SLASH_UncheckedAdd := lang.NewSymbol("glojure.core/UncheckedAdd") sym_glojure_DOT_core_SLASH_UncheckedByteCast := lang.NewSymbol("glojure.core/UncheckedByteCast") sym_glojure_DOT_core_SLASH_UncheckedCharCast := lang.NewSymbol("glojure.core/UncheckedCharCast") - sym_glojure_DOT_core_SLASH_UncheckedDec := lang.NewSymbol("glojure.core/UncheckedDec") sym_glojure_DOT_core_SLASH_UncheckedDoubleCast := lang.NewSymbol("glojure.core/UncheckedDoubleCast") sym_glojure_DOT_core_SLASH_UncheckedFloatCast := lang.NewSymbol("glojure.core/UncheckedFloatCast") sym_glojure_DOT_core_SLASH_UncheckedIntCast := lang.NewSymbol("glojure.core/UncheckedIntCast") - sym_glojure_DOT_core_SLASH_UncheckedIntDivide := lang.NewSymbol("glojure.core/UncheckedIntDivide") sym_glojure_DOT_core_SLASH_UncheckedLongCast := lang.NewSymbol("glojure.core/UncheckedLongCast") sym_glojure_DOT_core_SLASH_UncheckedShortCast := lang.NewSymbol("glojure.core/UncheckedShortCast") - sym_glojure_DOT_core_SLASH_Unchecked_inc := lang.NewSymbol("glojure.core/Unchecked_inc") - sym_glojure_DOT_core_SLASH_Unchecked_int_add := lang.NewSymbol("glojure.core/Unchecked_int_add") - sym_glojure_DOT_core_SLASH_Unchecked_int_dec := lang.NewSymbol("glojure.core/Unchecked_int_dec") - sym_glojure_DOT_core_SLASH_Unchecked_int_inc := lang.NewSymbol("glojure.core/Unchecked_int_inc") - sym_glojure_DOT_core_SLASH_Unchecked_int_multiply := lang.NewSymbol("glojure.core/Unchecked_int_multiply") - sym_glojure_DOT_core_SLASH_Unchecked_int_negate := lang.NewSymbol("glojure.core/Unchecked_int_negate") - sym_glojure_DOT_core_SLASH_Unchecked_int_remainder := lang.NewSymbol("glojure.core/Unchecked_int_remainder") - sym_glojure_DOT_core_SLASH_Unchecked_int_subtract := lang.NewSymbol("glojure.core/Unchecked_int_subtract") - sym_glojure_DOT_core_SLASH_Unchecked_minus := lang.NewSymbol("glojure.core/Unchecked_minus") - sym_glojure_DOT_core_SLASH_Unchecked_multiply := lang.NewSymbol("glojure.core/Unchecked_multiply") - sym_glojure_DOT_core_SLASH_UnsignedShiftRight := lang.NewSymbol("glojure.core/UnsignedShiftRight") sym_glojure_DOT_core_SLASH_aclone := lang.NewSymbol("glojure.core/aclone") sym_glojure_DOT_core_SLASH_aget := lang.NewSymbol("glojure.core/aget") sym_glojure_DOT_core_SLASH_alength := lang.NewSymbol("glojure.core/alength") @@ -588,8 +543,14 @@ func LoadNS() { sym_glojure_DOT_core_SLASH_assoc_DASH_in := lang.NewSymbol("glojure.core/assoc-in") sym_glojure_DOT_core_SLASH_atom := lang.NewSymbol("glojure.core/atom") sym_glojure_DOT_core_SLASH_binding := lang.NewSymbol("glojure.core/binding") + sym_glojure_DOT_core_SLASH_booleanArray := lang.NewSymbol("glojure.core/booleanArray") + sym_glojure_DOT_core_SLASH_booleans := lang.NewSymbol("glojure.core/booleans") sym_glojure_DOT_core_SLASH_bound_DASH_fn_STAR_ := lang.NewSymbol("glojure.core/bound-fn*") + sym_glojure_DOT_core_SLASH_byteArray := lang.NewSymbol("glojure.core/byteArray") + sym_glojure_DOT_core_SLASH_bytes := lang.NewSymbol("glojure.core/bytes") sym_glojure_DOT_core_SLASH_c := lang.NewSymbol("glojure.core/c") + sym_glojure_DOT_core_SLASH_charArray := lang.NewSymbol("glojure.core/charArray") + sym_glojure_DOT_core_SLASH_chars := lang.NewSymbol("glojure.core/chars") sym_glojure_DOT_core_SLASH_chunk := lang.NewSymbol("glojure.core/chunk") sym_glojure_DOT_core_SLASH_chunk_DASH_append := lang.NewSymbol("glojure.core/chunk-append") sym_glojure_DOT_core_SLASH_chunk_DASH_buffer := lang.NewSymbol("glojure.core/chunk-buffer") @@ -607,19 +568,26 @@ func LoadNS() { sym_glojure_DOT_core_SLASH_cons := lang.NewSymbol("glojure.core/cons") sym_glojure_DOT_core_SLASH_count := lang.NewSymbol("glojure.core/count") sym_glojure_DOT_core_SLASH_create_DASH_struct := lang.NewSymbol("glojure.core/create-struct") + sym_glojure_DOT_core_SLASH_decP := lang.NewSymbol("glojure.core/decP") sym_glojure_DOT_core_SLASH_defmulti := lang.NewSymbol("glojure.core/defmulti") sym_glojure_DOT_core_SLASH_defn := lang.NewSymbol("glojure.core/defn") sym_glojure_DOT_core_SLASH_deref := lang.NewSymbol("glojure.core/deref") sym_glojure_DOT_core_SLASH_dosync := lang.NewSymbol("glojure.core/dosync") sym_glojure_DOT_core_SLASH_double := lang.NewSymbol("glojure.core/double") + sym_glojure_DOT_core_SLASH_doubleArray := lang.NewSymbol("glojure.core/doubleArray") + sym_glojure_DOT_core_SLASH_doubles := lang.NewSymbol("glojure.core/doubles") sym_glojure_DOT_core_SLASH_equiv := lang.NewSymbol("glojure.core/equiv") sym_glojure_DOT_core_SLASH_extend := lang.NewSymbol("glojure.core/extend") sym_glojure_DOT_core_SLASH_extend_DASH_type := lang.NewSymbol("glojure.core/extend-type") sym_glojure_DOT_core_SLASH_first := lang.NewSymbol("glojure.core/first") + sym_glojure_DOT_core_SLASH_floatArray := lang.NewSymbol("glojure.core/floatArray") + sym_glojure_DOT_core_SLASH_floats := lang.NewSymbol("glojure.core/floats") sym_glojure_DOT_core_SLASH_fn := lang.NewSymbol("glojure.core/fn") sym_glojure_DOT_core_SLASH_future_DASH_call := lang.NewSymbol("glojure.core/future-call") sym_glojure_DOT_core_SLASH_gen_DASH_class := lang.NewSymbol("glojure.core/gen-class") sym_glojure_DOT_core_SLASH_get := lang.NewSymbol("glojure.core/get") + sym_glojure_DOT_core_SLASH_gt := lang.NewSymbol("glojure.core/gt") + sym_glojure_DOT_core_SLASH_gte := lang.NewSymbol("glojure.core/gte") sym_glojure_DOT_core_SLASH_hash_DASH_map := lang.NewSymbol("glojure.core/hash-map") sym_glojure_DOT_core_SLASH_i := lang.NewSymbol("glojure.core/i") sym_glojure_DOT_core_SLASH_identical := lang.NewSymbol("glojure.core/identical") @@ -627,13 +595,23 @@ func LoadNS() { sym_glojure_DOT_core_SLASH_if_DASH_not := lang.NewSymbol("glojure.core/if-not") sym_glojure_DOT_core_SLASH_if_DASH_some := lang.NewSymbol("glojure.core/if-some") sym_glojure_DOT_core_SLASH_in_DASH_ns := lang.NewSymbol("glojure.core/in-ns") + sym_glojure_DOT_core_SLASH_incP := lang.NewSymbol("glojure.core/incP") sym_glojure_DOT_core_SLASH_instance_QMARK_ := lang.NewSymbol("glojure.core/instance?") sym_glojure_DOT_core_SLASH_int := lang.NewSymbol("glojure.core/int") + sym_glojure_DOT_core_SLASH_intArray := lang.NewSymbol("glojure.core/intArray") + sym_glojure_DOT_core_SLASH_ints := lang.NewSymbol("glojure.core/ints") + sym_glojure_DOT_core_SLASH_isNeg := lang.NewSymbol("glojure.core/isNeg") + sym_glojure_DOT_core_SLASH_isPos := lang.NewSymbol("glojure.core/isPos") + sym_glojure_DOT_core_SLASH_isZero := lang.NewSymbol("glojure.core/isZero") sym_glojure_DOT_core_SLASH_keyword := lang.NewSymbol("glojure.core/keyword") sym_glojure_DOT_core_SLASH_lazy_DASH_seq := lang.NewSymbol("glojure.core/lazy-seq") sym_glojure_DOT_core_SLASH_let := lang.NewSymbol("glojure.core/let") sym_glojure_DOT_core_SLASH_long := lang.NewSymbol("glojure.core/long") + sym_glojure_DOT_core_SLASH_longArray := lang.NewSymbol("glojure.core/longArray") + sym_glojure_DOT_core_SLASH_longs := lang.NewSymbol("glojure.core/longs") sym_glojure_DOT_core_SLASH_loop := lang.NewSymbol("glojure.core/loop") + sym_glojure_DOT_core_SLASH_lt := lang.NewSymbol("glojure.core/lt") + sym_glojure_DOT_core_SLASH_lte := lang.NewSymbol("glojure.core/lte") sym_glojure_DOT_core_SLASH_merge := lang.NewSymbol("glojure.core/merge") sym_glojure_DOT_core_SLASH_meta := lang.NewSymbol("glojure.core/meta") sym_glojure_DOT_core_SLASH_next := lang.NewSymbol("glojure.core/next") @@ -641,24 +619,45 @@ func LoadNS() { sym_glojure_DOT_core_SLASH_nil_QMARK_ := lang.NewSymbol("glojure.core/nil?") sym_glojure_DOT_core_SLASH_not := lang.NewSymbol("glojure.core/not") sym_glojure_DOT_core_SLASH_nth := lang.NewSymbol("glojure.core/nth") + sym_glojure_DOT_core_SLASH_num := lang.NewSymbol("glojure.core/num") sym_glojure_DOT_core_SLASH_or := lang.NewSymbol("glojure.core/or") sym_glojure_DOT_core_SLASH_pcalls := lang.NewSymbol("glojure.core/pcalls") sym_glojure_DOT_core_SLASH_pop_DASH_thread_DASH_bindings := lang.NewSymbol("glojure.core/pop-thread-bindings") sym_glojure_DOT_core_SLASH_pr_DASH_str := lang.NewSymbol("glojure.core/pr-str") sym_glojure_DOT_core_SLASH_prn := lang.NewSymbol("glojure.core/prn") sym_glojure_DOT_core_SLASH_push_DASH_thread_DASH_bindings := lang.NewSymbol("glojure.core/push-thread-bindings") + sym_glojure_DOT_core_SLASH_quotient := lang.NewSymbol("glojure.core/quotient") sym_glojure_DOT_core_SLASH_refer := lang.NewSymbol("glojure.core/refer") + sym_glojure_DOT_core_SLASH_remainder := lang.NewSymbol("glojure.core/remainder") sym_glojure_DOT_core_SLASH_rest := lang.NewSymbol("glojure.core/rest") sym_glojure_DOT_core_SLASH_seq := lang.NewSymbol("glojure.core/seq") sym_glojure_DOT_core_SLASH_seq_QMARK_ := lang.NewSymbol("glojure.core/seq?") + sym_glojure_DOT_core_SLASH_shiftLeft := lang.NewSymbol("glojure.core/shiftLeft") + sym_glojure_DOT_core_SLASH_shiftRight := lang.NewSymbol("glojure.core/shiftRight") + sym_glojure_DOT_core_SLASH_shortArray := lang.NewSymbol("glojure.core/shortArray") + sym_glojure_DOT_core_SLASH_shorts := lang.NewSymbol("glojure.core/shorts") sym_glojure_DOT_core_SLASH_str := lang.NewSymbol("glojure.core/str") sym_glojure_DOT_core_SLASH_swap_BANG_ := lang.NewSymbol("glojure.core/swap!") sym_glojure_DOT_core_SLASH_sync := lang.NewSymbol("glojure.core/sync") sym_glojure_DOT_core_SLASH_to_DASH_array := lang.NewSymbol("glojure.core/to-array") sym_glojure_DOT_core_SLASH_unchecked_DASH_inc := lang.NewSymbol("glojure.core/unchecked-inc") sym_glojure_DOT_core_SLASH_unchecked_DASH_inc_DASH_int := lang.NewSymbol("glojure.core/unchecked-inc-int") + sym_glojure_DOT_core_SLASH_unchecked_add := lang.NewSymbol("glojure.core/unchecked_add") + sym_glojure_DOT_core_SLASH_unchecked_dec := lang.NewSymbol("glojure.core/unchecked_dec") + sym_glojure_DOT_core_SLASH_unchecked_inc := lang.NewSymbol("glojure.core/unchecked_inc") + sym_glojure_DOT_core_SLASH_unchecked_int_add := lang.NewSymbol("glojure.core/unchecked_int_add") + sym_glojure_DOT_core_SLASH_unchecked_int_dec := lang.NewSymbol("glojure.core/unchecked_int_dec") + sym_glojure_DOT_core_SLASH_unchecked_int_divide := lang.NewSymbol("glojure.core/unchecked_int_divide") + sym_glojure_DOT_core_SLASH_unchecked_int_inc := lang.NewSymbol("glojure.core/unchecked_int_inc") + sym_glojure_DOT_core_SLASH_unchecked_int_multiply := lang.NewSymbol("glojure.core/unchecked_int_multiply") + sym_glojure_DOT_core_SLASH_unchecked_int_negate := lang.NewSymbol("glojure.core/unchecked_int_negate") + sym_glojure_DOT_core_SLASH_unchecked_int_remainder := lang.NewSymbol("glojure.core/unchecked_int_remainder") + sym_glojure_DOT_core_SLASH_unchecked_int_subtract := lang.NewSymbol("glojure.core/unchecked_int_subtract") + sym_glojure_DOT_core_SLASH_unchecked_minus := lang.NewSymbol("glojure.core/unchecked_minus") + sym_glojure_DOT_core_SLASH_unchecked_multiply := lang.NewSymbol("glojure.core/unchecked_multiply") sym_glojure_DOT_core_SLASH_unquote := lang.NewSymbol("glojure.core/unquote") sym_glojure_DOT_core_SLASH_unquote_DASH_splicing := lang.NewSymbol("glojure.core/unquote-splicing") + sym_glojure_DOT_core_SLASH_unsignedShiftRight := lang.NewSymbol("glojure.core/unsignedShiftRight") sym_glojure_DOT_core_SLASH_when := lang.NewSymbol("glojure.core/when") sym_glojure_DOT_core_SLASH_when_DASH_first := lang.NewSymbol("glojure.core/when-first") sym_glojure_DOT_core_SLASH_when_DASH_let := lang.NewSymbol("glojure.core/when-let") @@ -3069,7 +3068,7 @@ func LoadNS() { if reflect.TypeOf(tmp3).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp4 := lang.Apply(tmp3, []any{nil, int64(0)}) + tmp4 := lang.Apply(tmp3, []any{v2, int64(0)}) return tmp4 }) tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -3090,7 +3089,7 @@ func LoadNS() { if reflect.TypeOf(tmp3).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp4 := lang.Apply(tmp3, []any{nil, int64(1)}) + tmp4 := lang.Apply(tmp3, []any{v2, int64(1)}) return tmp4 }) tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -3224,7 +3223,7 @@ func LoadNS() { // *loaded-libs* { tmp0 := sym__STAR_loaded_DASH_libs_STAR_.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core.glj", kw_line, int(5817), kw_column, int(10), kw_end_DASH_line, int(5820), kw_end_DASH_column, int(15), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - tmp1 := lang.NewRef(lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{sym_glojure_DOT_core_DOT_protocols, sym_glojure_DOT_string, sym_glojure_DOT_go_DOT_io, sym_codegen_DOT_test_DOT_case_DASH_switch, sym_codegen_DOT_test_DOT_const_DASH_keyword, sym_codegen_DOT_test_DOT_const_DASH_number, sym_codegen_DOT_test_DOT_const_DASH_string, sym_codegen_DOT_test_DOT_def_DASH_simple, sym_codegen_DOT_test_DOT_fn_DASH_closure, sym_codegen_DOT_test_DOT_fn_DASH_recur, sym_codegen_DOT_test_DOT_loop_DASH_simple, sym_codegen_DOT_test_DOT_maybe_DASH_class, sym_codegen_DOT_test_DOT_multifn, sym_codegen_DOT_test_DOT_ns_DASH_skip, sym_codegen_DOT_test_DOT_quote_DASH_simple, sym_codegen_DOT_test_DOT_ref, sym_codegen_DOT_test_DOT_the_DASH_var, sym_codegen_DOT_test_DOT_throw_DASH_simple, sym_codegen_DOT_test_DOT_try_DASH_advanced, sym_codegen_DOT_test_DOT_try_DASH_basic, sym_codegen_DOT_test_DOT_values, sym_codegen_DOT_test_DOT_with_DASH_meta}))) + tmp1 := lang.NewRef(lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{sym_glojure_DOT_core_DOT_protocols, sym_glojure_DOT_string, sym_glojure_DOT_go_DOT_io, sym_codegen_DOT_test_DOT_case_DASH_switch, sym_codegen_DOT_test_DOT_const_DASH_keyword, sym_codegen_DOT_test_DOT_const_DASH_number, sym_codegen_DOT_test_DOT_const_DASH_string, sym_codegen_DOT_test_DOT_def_DASH_simple, sym_codegen_DOT_test_DOT_fn_DASH_closure, sym_codegen_DOT_test_DOT_fn_DASH_recur, sym_codegen_DOT_test_DOT_loop_DASH_simple, sym_codegen_DOT_test_DOT_maybe_DASH_class, sym_codegen_DOT_test_DOT_multifn, sym_codegen_DOT_test_DOT_ns_DASH_skip, sym_codegen_DOT_test_DOT_quote_DASH_simple, sym_codegen_DOT_test_DOT_ref, sym_codegen_DOT_test_DOT_set_DASH_bang, sym_codegen_DOT_test_DOT_the_DASH_var, sym_codegen_DOT_test_DOT_throw_DASH_simple, sym_codegen_DOT_test_DOT_try_DASH_advanced, sym_codegen_DOT_test_DOT_try_DASH_basic, sym_codegen_DOT_test_DOT_values, sym_codegen_DOT_test_DOT_with_DASH_meta}))) var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -3360,12 +3359,8 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - tmp4, _ := lang.FieldOrMethod(nil, "getAccessor") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("getAccessor is not a function"))) - } - tmp5 := lang.Apply(tmp4, []any{v2, v3}) - return tmp5 + tmp4 := lang.Apply(lang.GetPersistentStructMapAccessor, []any{v2, v3}) + return tmp4 }) tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) var_glojure_DOT_core_accessor = ns.InternWithValue(tmp0, tmp1, true) @@ -3552,9 +3547,9 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "ClearBit") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "clearBit") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ClearBit is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("clearBit is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v2, v3}) return tmp5 @@ -3575,9 +3570,9 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "FlipBit") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "flipBit") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("FlipBit is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("flipBit is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v2, v3}) return tmp5 @@ -3598,9 +3593,9 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "SetBit") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "setBit") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("SetBit is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setBit is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v2, v3}) return tmp5 @@ -3621,9 +3616,9 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "TestBit") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "testBit") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("TestBit is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("testBit is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v2, v3}) return tmp5 @@ -5784,9 +5779,9 @@ func LoadNS() { checkArity(args, 1) v2 := args[0] _ = v2 - tmp3, _ := lang.FieldOrMethod(lang.Numbers, "Rationalize") + tmp3, _ := lang.FieldOrMethod(lang.Numbers, "rationalize") if reflect.TypeOf(tmp3).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Rationalize is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("rationalize is not a function"))) } tmp4 := lang.Apply(tmp3, []any{v2}) return tmp4 @@ -6473,7 +6468,7 @@ func LoadNS() { checkArity(args, 1) v2 := args[0] _ = v2 - return nil + return "unimplemented: set! target type" }) tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) var_glojure_DOT_core_set_DASH_agent_DASH_send_DASH_executor_BANG_ = ns.InternWithValue(tmp0, tmp1, true) @@ -6489,7 +6484,7 @@ func LoadNS() { checkArity(args, 1) v2 := args[0] _ = v2 - return nil + return "unimplemented: set! target type" }) tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) var_glojure_DOT_core_set_DASH_agent_DASH_send_DASH_off_DASH_executor_BANG_ = ns.InternWithValue(tmp0, tmp1, true) @@ -6976,10 +6971,11 @@ func LoadNS() { if err != nil { panic(err) } - tmp8 := checkDerefVar(var_glojure_DOT_core_cons) - tmp9 := lang.Apply(tmp8, []any{v3, v4}) - tmp10 := lang.Apply(tmp7, []any{"unimplemented: new with non-constant class type", tmp9}) - return tmp10 + tmp8 := new(strings11.Builder) + tmp9 := checkDerefVar(var_glojure_DOT_core_cons) + tmp10 := lang.Apply(tmp9, []any{v3, v4}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10}) + return tmp11 } }) tmp3 := reflect.TypeOf("") @@ -9104,9 +9100,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Dec") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "dec") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Dec is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("dec is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -9136,7 +9132,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_DecP}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_decP}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -9155,9 +9151,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "DecP") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "decP") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("DecP is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("decP is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -9732,7 +9728,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_DoubleArray}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_doubleArray}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := checkDerefVar(var_glojure_DOT_core_seq) tmp14 := checkDerefVar(var_glojure_DOT_core_concat) @@ -9758,9 +9754,9 @@ func LoadNS() { case 1: v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "DoubleArray") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "doubleArray") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("DoubleArray is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("doubleArray is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -9769,9 +9765,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "DoubleArrayInit") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "doubleArrayInit") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("DoubleArrayInit is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("doubleArrayInit is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -9820,7 +9816,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Doubles}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_doubles}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := lang.Apply(tmp12, []any{v3}) tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) @@ -9836,9 +9832,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Doubles") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "doubles") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Doubles is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("doubles is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -10442,7 +10438,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_FloatArray}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_floatArray}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := checkDerefVar(var_glojure_DOT_core_seq) tmp14 := checkDerefVar(var_glojure_DOT_core_concat) @@ -10468,9 +10464,9 @@ func LoadNS() { case 1: v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "FloatArray") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "floatArray") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("FloatArray is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("floatArray is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -10479,9 +10475,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "FloatArrayInit") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "floatArrayInit") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("FloatArrayInit is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("floatArrayInit is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -10545,7 +10541,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Floats}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_floats}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := lang.Apply(tmp12, []any{v3}) tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) @@ -10561,9 +10557,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Floats") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "floats") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Floats is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("floats is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -11073,9 +11069,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Inc") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "inc") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Inc is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("inc is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -11105,7 +11101,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_IncP}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_incP}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -11124,9 +11120,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "IncP") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "incP") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("IncP is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("incP is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -11268,7 +11264,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_IntArray}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_intArray}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := checkDerefVar(var_glojure_DOT_core_seq) tmp14 := checkDerefVar(var_glojure_DOT_core_concat) @@ -11294,9 +11290,9 @@ func LoadNS() { case 1: v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "IntArray") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "intArray") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("IntArray is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("intArray is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -11305,9 +11301,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "IntArrayInit") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "intArrayInit") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("IntArrayInit is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("intArrayInit is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -11452,7 +11448,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Ints}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_ints}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := lang.Apply(tmp12, []any{v3}) tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) @@ -11468,9 +11464,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Ints") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "ints") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Ints is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ints is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -12020,7 +12016,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_LongArray}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_longArray}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := checkDerefVar(var_glojure_DOT_core_seq) tmp14 := checkDerefVar(var_glojure_DOT_core_concat) @@ -12046,9 +12042,9 @@ func LoadNS() { case 1: v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "LongArray") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "longArray") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("LongArray is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("longArray is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -12057,9 +12053,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "LongArrayInit") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "longArrayInit") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("LongArrayInit is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("longArrayInit is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -12090,7 +12086,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Longs}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_longs}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := lang.Apply(tmp12, []any{v3}) tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) @@ -12106,9 +12102,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Longs") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "longs") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Longs is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("longs is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -12429,7 +12425,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_IsNeg}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_isNeg}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -12448,9 +12444,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "IsNeg") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "isNeg") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("IsNeg is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("isNeg is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -12793,7 +12789,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Num}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_num}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -12812,9 +12808,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Num") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "num") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Num is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("num is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -13047,7 +13043,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_IsPos}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_isPos}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -13066,9 +13062,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "IsPos") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "isPos") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("IsPos is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("isPos is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -13172,7 +13168,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Quotient}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_quotient}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -13195,9 +13191,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Quotient") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "quotient") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Quotient is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("quotient is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -13687,7 +13683,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Remainder}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_remainder}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -13710,9 +13706,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Remainder") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "remainder") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Remainder is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("remainder is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -14069,7 +14065,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_ShortArray}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_shortArray}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := checkDerefVar(var_glojure_DOT_core_seq) tmp14 := checkDerefVar(var_glojure_DOT_core_concat) @@ -14095,9 +14091,9 @@ func LoadNS() { case 1: v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "ShortArray") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "shortArray") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ShortArray is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("shortArray is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -14106,9 +14102,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "ShortArrayInit") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "shortArrayInit") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ShortArrayInit is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("shortArrayInit is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -14139,7 +14135,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Shorts}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_shorts}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := lang.Apply(tmp12, []any{v3}) tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) @@ -14155,9 +14151,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Shorts") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "shorts") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Shorts is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("shorts is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -15472,7 +15468,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_UncheckedAdd}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_unchecked_add}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -15495,9 +15491,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedAdd") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_add") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedAdd is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_add is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -15529,7 +15525,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_add}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_unchecked_int_add}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -15552,9 +15548,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_add") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_int_add") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_add is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_add is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -15682,7 +15678,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedDec}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_unchecked_dec}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -15701,9 +15697,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedDec") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_dec") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedDec is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_dec is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -15733,7 +15729,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_dec}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_unchecked_int_dec}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -15752,9 +15748,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_dec") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_int_dec") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_dec is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_dec is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -15786,7 +15782,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_UncheckedIntDivide}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_unchecked_int_divide}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -15809,9 +15805,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedIntDivide") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_int_divide") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedIntDivide is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_divide is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -15935,7 +15931,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Unchecked_inc}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_unchecked_inc}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -15954,9 +15950,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_inc") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_inc") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_inc is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_inc is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -15986,7 +15982,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_inc}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_unchecked_int_inc}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -16005,9 +16001,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_inc") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_int_inc") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_inc is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_inc is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -16133,7 +16129,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_multiply}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_unchecked_multiply}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -16156,9 +16152,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_multiply") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_multiply") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_multiply is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_multiply is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -16190,7 +16186,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_multiply}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_unchecked_int_multiply}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -16213,9 +16209,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_multiply") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_int_multiply") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_multiply is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_multiply is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -16245,7 +16241,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Unchecked_minus}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_unchecked_minus}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -16296,7 +16292,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_negate}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_unchecked_int_negate}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -16315,9 +16311,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_negate") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_int_negate") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_negate is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_negate is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -16349,7 +16345,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_remainder}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_unchecked_int_remainder}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -16372,9 +16368,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_remainder") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_int_remainder") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_remainder is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_remainder is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -16453,7 +16449,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_minus}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_unchecked_minus}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -16476,9 +16472,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_minus") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_minus") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_minus is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_minus is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -16510,7 +16506,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_subtract}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_unchecked_int_subtract}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -16533,9 +16529,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_subtract") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_int_subtract") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_subtract is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_subtract is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -16593,7 +16589,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_UnsignedShiftRight}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_unsignedShiftRight}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -16616,9 +16612,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "UnsignedShiftRight") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "unsignedShiftRight") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("UnsignedShiftRight is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unsignedShiftRight is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -16753,7 +16749,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_IsZero}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_isZero}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -16772,9 +16768,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "IsZero") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "isZero") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("IsZero is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("isZero is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -17328,7 +17324,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Equiv}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_equiv}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -17356,9 +17352,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Equiv") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "equiv") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Equiv is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("equiv is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -17431,7 +17427,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Gt}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_gt}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -17459,9 +17455,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "gt") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("gt is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -17534,7 +17530,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Gte}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_gte}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -17562,9 +17558,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Gte") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "gte") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gte is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("gte is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -17637,7 +17633,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Lt}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_lt}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -17665,9 +17661,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Lt") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "lt") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Lt is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("lt is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -17740,7 +17736,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Lte}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_lte}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -17768,9 +17764,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Lte") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "lte") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Lte is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("lte is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -17994,7 +17990,7 @@ func LoadNS() { if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + tmp5 := lang.Apply(tmp4, []any{v3, int64(1)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -18014,9 +18010,9 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Add") + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "add") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Add is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) } tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 @@ -18214,7 +18210,7 @@ func LoadNS() { if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + tmp5 := lang.Apply(tmp4, []any{v3, int64(1)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -18234,9 +18230,9 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "AddP") + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "addP") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("AddP is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("addP is not a function"))) } tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 @@ -18434,7 +18430,7 @@ func LoadNS() { if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + tmp5 := lang.Apply(tmp4, []any{v3, int64(1)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -18453,9 +18449,9 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Divide") + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "divide") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Divide is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("divide is not a function"))) } tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 @@ -18653,7 +18649,7 @@ func LoadNS() { if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + tmp5 := lang.Apply(tmp4, []any{v3, int64(1)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -18673,9 +18669,9 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Multiply") + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "multiply") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Multiply is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("multiply is not a function"))) } tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 @@ -18873,7 +18869,7 @@ func LoadNS() { if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + tmp5 := lang.Apply(tmp4, []any{v3, int64(1)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -18893,9 +18889,9 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "MultiplyP") + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "multiplyP") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("MultiplyP is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("multiplyP is not a function"))) } tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 @@ -20289,7 +20285,7 @@ func LoadNS() { if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + tmp5 := lang.Apply(tmp4, []any{v3, int64(1)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -20302,9 +20298,9 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "And") + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "and") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("And is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("and is not a function"))) } tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 @@ -20502,7 +20498,7 @@ func LoadNS() { if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + tmp5 := lang.Apply(tmp4, []any{v3, int64(1)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -20515,9 +20511,9 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "AndNot") + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "andNot") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("AndNot is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("andNot is not a function"))) } tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 @@ -20562,7 +20558,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Not}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_not}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -20581,9 +20577,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Not") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "not") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Not is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("not is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -20766,7 +20762,7 @@ func LoadNS() { if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + tmp5 := lang.Apply(tmp4, []any{v3, int64(1)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -20779,9 +20775,9 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Or") + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "or") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Or is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("or is not a function"))) } tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 @@ -20828,7 +20824,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_ShiftLeft}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_shiftLeft}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -20851,9 +20847,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "ShiftLeft") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "shiftLeft") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ShiftLeft is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("shiftLeft is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -20885,7 +20881,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_ShiftRight}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_shiftRight}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -20908,9 +20904,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "ShiftRight") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "shiftRight") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ShiftRight is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("shiftRight is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -21093,7 +21089,7 @@ func LoadNS() { if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + tmp5 := lang.Apply(tmp4, []any{v3, int64(1)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -21106,9 +21102,9 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Xor") + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "xor") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Xor is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("xor is not a function"))) } tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 @@ -21203,7 +21199,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_BooleanArray}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_booleanArray}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := checkDerefVar(var_glojure_DOT_core_seq) tmp14 := checkDerefVar(var_glojure_DOT_core_concat) @@ -21229,9 +21225,9 @@ func LoadNS() { case 1: v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "BooleanArray") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "booleanArray") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("BooleanArray is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("booleanArray is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -21240,9 +21236,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "BooleanArrayInit") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "booleanArrayInit") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("BooleanArrayInit is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("booleanArrayInit is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -21273,7 +21269,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Booleans}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_booleans}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := lang.Apply(tmp12, []any{v3}) tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) @@ -21289,9 +21285,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Booleans") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "booleans") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Booleans is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("booleans is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -21587,7 +21583,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_ByteArray}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_byteArray}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := checkDerefVar(var_glojure_DOT_core_seq) tmp14 := checkDerefVar(var_glojure_DOT_core_concat) @@ -21613,9 +21609,9 @@ func LoadNS() { case 1: v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "ByteArray") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "byteArray") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ByteArray is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("byteArray is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -21624,9 +21620,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "ByteArrayInit") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "byteArrayInit") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ByteArrayInit is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("byteArrayInit is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -21657,7 +21653,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Bytes}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_bytes}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := lang.Apply(tmp12, []any{v3}) tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) @@ -21673,9 +21669,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Bytes") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "bytes") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Bytes is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("bytes is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -21801,7 +21797,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_CharArray}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_charArray}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := checkDerefVar(var_glojure_DOT_core_seq) tmp14 := checkDerefVar(var_glojure_DOT_core_concat) @@ -21827,9 +21823,9 @@ func LoadNS() { case 1: v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "CharArray") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "charArray") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("CharArray is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("charArray is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -21838,9 +21834,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "CharArrayInit") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "charArrayInit") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("CharArrayInit is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("charArrayInit is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -21871,7 +21867,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Chars}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_chars}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := lang.Apply(tmp12, []any{v3}) tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) @@ -21887,9 +21883,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Chars") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "chars") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Chars is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("chars is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -27392,7 +27388,7 @@ func LoadNS() { if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + tmp5 := lang.Apply(tmp4, []any{v3, int64(1)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -27409,9 +27405,9 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Max") + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "max") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Max is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("max is not a function"))) } tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 @@ -28020,7 +28016,7 @@ func LoadNS() { if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + tmp5 := lang.Apply(tmp4, []any{v3, int64(1)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -28037,9 +28033,9 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Min") + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "min") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Min is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("min is not a function"))) } tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 @@ -29662,198 +29658,199 @@ func LoadNS() { var tmp5 any { // let // let binding "a" - var v6 any = "unimplemented: new with non-constant class type" - _ = v6 + tmp6 := new(lang.ArrayList) + var v7 any = tmp6 + _ = v7 // let binding "pv" - tmp7 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) - tmp8 := lang.Apply(tmp7, []any{kw_glojure_DOT_core_SLASH_none}) - var v9 any = tmp8 - _ = v9 - var tmp10 lang.FnFunc - tmp10 = lang.NewFnFunc(func(args ...any) any { + tmp8 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) + tmp9 := lang.Apply(tmp8, []any{kw_glojure_DOT_core_SLASH_none}) + var v10 any = tmp9 + _ = v10 + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - tmp11 := lang.Apply(v4, nil) - return tmp11 + tmp12 := lang.Apply(v4, nil) + return tmp12 case 1: - v11 := args[0] - _ = v11 - var tmp12 any + v12 := args[0] + _ = v12 + var tmp13 any { // let // let binding "result" - var tmp13 any - tmp14, ok := lang.FieldOrMethod(v6, "isEmpty") + var tmp14 any + tmp15, ok := lang.FieldOrMethod(v7, "isEmpty") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "isEmpty"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "isEmpty"))) } - var tmp15 any - switch reflect.TypeOf(tmp14).Kind() { + var tmp16 any + switch reflect.TypeOf(tmp15).Kind() { case reflect.Func: - tmp15 = lang.Apply(tmp14, nil) + tmp16 = lang.Apply(tmp15, nil) default: - tmp15 = tmp14 + tmp16 = tmp15 } - if lang.IsTruthy(tmp15) { - tmp13 = v11 + if lang.IsTruthy(tmp16) { + tmp14 = v12 } else { - var tmp16 any + var tmp17 any { // let // let binding "v" - tmp17 := checkDerefVar(var_glojure_DOT_core_vec) - tmp18, ok := lang.FieldOrMethod(v6, "toArray") + tmp18 := checkDerefVar(var_glojure_DOT_core_vec) + tmp19, ok := lang.FieldOrMethod(v7, "toArray") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "toArray"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "toArray"))) } - var tmp19 any - switch reflect.TypeOf(tmp18).Kind() { + var tmp20 any + switch reflect.TypeOf(tmp19).Kind() { case reflect.Func: - tmp19 = lang.Apply(tmp18, nil) + tmp20 = lang.Apply(tmp19, nil) default: - tmp19 = tmp18 + tmp20 = tmp19 } - tmp20 := lang.Apply(tmp17, []any{tmp19}) - var v21 any = tmp20 - _ = v21 - tmp22, ok := lang.FieldOrMethod(v6, "clear") + tmp21 := lang.Apply(tmp18, []any{tmp20}) + var v22 any = tmp21 + _ = v22 + tmp23, ok := lang.FieldOrMethod(v7, "clear") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "clear"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "clear"))) } - var tmp23 any - switch reflect.TypeOf(tmp22).Kind() { + var tmp24 any + switch reflect.TypeOf(tmp23).Kind() { case reflect.Func: - tmp23 = lang.Apply(tmp22, nil) + tmp24 = lang.Apply(tmp23, nil) default: - tmp23 = tmp22 + tmp24 = tmp23 } - _ = tmp23 - tmp24 := checkDerefVar(var_glojure_DOT_core_unreduced) - tmp25 := lang.Apply(v4, []any{v11, v21}) - tmp26 := lang.Apply(tmp24, []any{tmp25}) - tmp16 = tmp26 + _ = tmp24 + tmp25 := checkDerefVar(var_glojure_DOT_core_unreduced) + tmp26 := lang.Apply(v4, []any{v12, v22}) + tmp27 := lang.Apply(tmp25, []any{tmp26}) + tmp17 = tmp27 } // end let - tmp13 = tmp16 + tmp14 = tmp17 } - var v17 any = tmp13 - _ = v17 - tmp18 := lang.Apply(v4, []any{v17}) - tmp12 = tmp18 + var v18 any = tmp14 + _ = v18 + tmp19 := lang.Apply(v4, []any{v18}) + tmp13 = tmp19 } // end let - return tmp12 + return tmp13 case 2: - v11 := args[0] - _ = v11 - v12 := args[1] + v12 := args[0] _ = v12 - var tmp13 any + v13 := args[1] + _ = v13 + var tmp14 any { // let // let binding "pval" - tmp14 := checkDerefVar(var_glojure_DOT_core_deref) - tmp15 := lang.Apply(tmp14, []any{v9}) - var v16 any = tmp15 - _ = v16 + tmp15 := checkDerefVar(var_glojure_DOT_core_deref) + tmp16 := lang.Apply(tmp15, []any{v10}) + var v17 any = tmp16 + _ = v17 // let binding "val" - tmp17 := lang.Apply(v2, []any{v12}) - var v18 any = tmp17 - _ = v18 - tmp19 := checkDerefVar(var_glojure_DOT_core_vreset_BANG_) - tmp20 := lang.Apply(tmp19, []any{v9, v18}) - _ = tmp20 - var tmp21 any + tmp18 := lang.Apply(v2, []any{v13}) + var v19 any = tmp18 + _ = v19 + tmp20 := checkDerefVar(var_glojure_DOT_core_vreset_BANG_) + tmp21 := lang.Apply(tmp20, []any{v10, v19}) + _ = tmp21 var tmp22 any + var tmp23 any { // let // let binding "or__0__auto__" - tmp23 := checkDerefVar(var_glojure_DOT_core_identical_QMARK_) - tmp24 := lang.Apply(tmp23, []any{v16, kw_glojure_DOT_core_SLASH_none}) - var v25 any = tmp24 - _ = v25 - var tmp26 any - if lang.IsTruthy(v25) { - tmp26 = v25 + tmp24 := checkDerefVar(var_glojure_DOT_core_identical_QMARK_) + tmp25 := lang.Apply(tmp24, []any{v17, kw_glojure_DOT_core_SLASH_none}) + var v26 any = tmp25 + _ = v26 + var tmp27 any + if lang.IsTruthy(v26) { + tmp27 = v26 } else { - tmp27 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp28 := lang.Apply(tmp27, []any{v18, v16}) - tmp26 = tmp28 + tmp28 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp29 := lang.Apply(tmp28, []any{v19, v17}) + tmp27 = tmp29 } - tmp22 = tmp26 + tmp23 = tmp27 } // end let - if lang.IsTruthy(tmp22) { - tmp23, _ := lang.FieldOrMethod(v6, "add") - if reflect.TypeOf(tmp23).Kind() != reflect.Func { + if lang.IsTruthy(tmp23) { + tmp24, _ := lang.FieldOrMethod(v7, "add") + if reflect.TypeOf(tmp24).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) } - tmp24 := lang.Apply(tmp23, []any{v12}) - _ = tmp24 - tmp21 = v11 + tmp25 := lang.Apply(tmp24, []any{v13}) + _ = tmp25 + tmp22 = v12 } else { - var tmp25 any + var tmp26 any { // let // let binding "v" - tmp26 := checkDerefVar(var_glojure_DOT_core_vec) - tmp27, ok := lang.FieldOrMethod(v6, "toArray") + tmp27 := checkDerefVar(var_glojure_DOT_core_vec) + tmp28, ok := lang.FieldOrMethod(v7, "toArray") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "toArray"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "toArray"))) } - var tmp28 any - switch reflect.TypeOf(tmp27).Kind() { + var tmp29 any + switch reflect.TypeOf(tmp28).Kind() { case reflect.Func: - tmp28 = lang.Apply(tmp27, nil) + tmp29 = lang.Apply(tmp28, nil) default: - tmp28 = tmp27 + tmp29 = tmp28 } - tmp29 := lang.Apply(tmp26, []any{tmp28}) - var v30 any = tmp29 - _ = v30 - tmp31, ok := lang.FieldOrMethod(v6, "clear") + tmp30 := lang.Apply(tmp27, []any{tmp29}) + var v31 any = tmp30 + _ = v31 + tmp32, ok := lang.FieldOrMethod(v7, "clear") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "clear"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "clear"))) } - var tmp32 any - switch reflect.TypeOf(tmp31).Kind() { + var tmp33 any + switch reflect.TypeOf(tmp32).Kind() { case reflect.Func: - tmp32 = lang.Apply(tmp31, nil) + tmp33 = lang.Apply(tmp32, nil) default: - tmp32 = tmp31 + tmp33 = tmp32 } - _ = tmp32 - var tmp33 any + _ = tmp33 + var tmp34 any { // let // let binding "ret" - tmp34 := lang.Apply(v4, []any{v11, v30}) - var v35 any = tmp34 - _ = v35 - var tmp36 any - tmp37 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) - tmp38 := lang.Apply(tmp37, []any{v35}) - if lang.IsTruthy(tmp38) { + tmp35 := lang.Apply(v4, []any{v12, v31}) + var v36 any = tmp35 + _ = v36 + var tmp37 any + tmp38 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) + tmp39 := lang.Apply(tmp38, []any{v36}) + if lang.IsTruthy(tmp39) { } else { - tmp39, _ := lang.FieldOrMethod(v6, "add") - if reflect.TypeOf(tmp39).Kind() != reflect.Func { + tmp40, _ := lang.FieldOrMethod(v7, "add") + if reflect.TypeOf(tmp40).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) } - tmp40 := lang.Apply(tmp39, []any{v12}) - tmp36 = tmp40 + tmp41 := lang.Apply(tmp40, []any{v13}) + tmp37 = tmp41 } - _ = tmp36 - tmp33 = v35 + _ = tmp37 + tmp34 = v36 } // end let - tmp25 = tmp33 + tmp26 = tmp34 } // end let - tmp21 = tmp25 + tmp22 = tmp26 } - tmp13 = tmp21 + tmp14 = tmp22 } // end let - return tmp13 + return tmp14 default: checkArity(args, -1) panic("unreachable") } }) - tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7152), kw_column, int(7), kw_end_DASH_line, int(7176), kw_end_DASH_column, int(28)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7152), kw_column, int(7), kw_end_DASH_line, int(7176), kw_end_DASH_column, int(28)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp5 = tmp12 + tmp5 = tmp13 } // end let return tmp5 }) @@ -31336,30 +31333,30 @@ func LoadNS() { var tmp50 any if lang.IsTruthy(v49) { } else { - panic("unimplemented: new with non-constant class type") + panic(nil) } _ = tmp50 - tmp51 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) - var tmp52 any + tmp52 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + var tmp53 any { // let // let binding "or__0__auto__" - tmp53 := lang.Apply(v15, []any{v44}) - var v54 any = tmp53 - _ = v54 - var tmp55 any - if lang.IsTruthy(v54) { - tmp55 = v54 + tmp54 := lang.Apply(v15, []any{v44}) + var v55 any = tmp54 + _ = v55 + var tmp56 any + if lang.IsTruthy(v55) { + tmp56 = v55 } else { - tmp55 = v44 + tmp56 = v44 } - tmp52 = tmp55 + tmp53 = tmp56 } // end let - tmp53, _ := lang.FieldOrMethod(tmp51, "Refer") - if reflect.TypeOf(tmp53).Kind() != reflect.Func { + tmp54, _ := lang.FieldOrMethod(tmp52, "Refer") + if reflect.TypeOf(tmp54).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Refer is not a function"))) } - tmp54 := lang.Apply(tmp53, []any{tmp52, v49}) - tmp47 = tmp54 + tmp55 := lang.Apply(tmp54, []any{tmp53, v49}) + tmp47 = tmp55 } // end let tmp45 = tmp47 } @@ -31443,30 +31440,30 @@ func LoadNS() { var tmp62 any if lang.IsTruthy(v61) { } else { - panic("unimplemented: new with non-constant class type") + panic(nil) } _ = tmp62 - tmp63 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) - var tmp64 any + tmp64 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + var tmp65 any { // let // let binding "or__0__auto__" - tmp65 := lang.Apply(v15, []any{v56}) - var v66 any = tmp65 - _ = v66 - var tmp67 any - if lang.IsTruthy(v66) { - tmp67 = v66 + tmp66 := lang.Apply(v15, []any{v56}) + var v67 any = tmp66 + _ = v67 + var tmp68 any + if lang.IsTruthy(v67) { + tmp68 = v67 } else { - tmp67 = v56 + tmp68 = v56 } - tmp64 = tmp67 + tmp65 = tmp68 } // end let - tmp65, _ := lang.FieldOrMethod(tmp63, "Refer") - if reflect.TypeOf(tmp65).Kind() != reflect.Func { + tmp66, _ := lang.FieldOrMethod(tmp64, "Refer") + if reflect.TypeOf(tmp66).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Refer is not a function"))) } - tmp66 := lang.Apply(tmp65, []any{tmp64, v61}) - tmp59 = tmp66 + tmp67 := lang.Apply(tmp66, []any{tmp65, v61}) + tmp59 = tmp67 } // end let tmp57 = tmp59 } @@ -35070,7 +35067,7 @@ func LoadNS() { if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(0)}) + tmp5 := lang.Apply(tmp4, []any{v3, int64(0)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -35089,9 +35086,9 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Minus") + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "minus") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Minus is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("minus is not a function"))) } tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 @@ -35289,7 +35286,7 @@ func LoadNS() { if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(0)}) + tmp5 := lang.Apply(tmp4, []any{v3, int64(0)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -35308,9 +35305,9 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "MinusP") + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "minusP") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("MinusP is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("minusP is not a function"))) } tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 @@ -35351,58 +35348,59 @@ func LoadNS() { var tmp4 any { // let // let binding "a" - var v5 any = "unimplemented: new with non-constant class type" - _ = v5 + tmp5 := new(*lang.Agent) + var v6 any = tmp5 + _ = v6 // let binding "opts" - tmp6 := checkDerefVar(var_glojure_DOT_core_apply) - tmp7 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) - tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) - var v9 any = tmp8 - _ = v9 - tmp10 := checkDerefVar(var_glojure_DOT_core_setup_DASH_reference) - tmp11 := lang.Apply(tmp10, []any{v5, v3}) - _ = tmp11 - var tmp12 any - tmp13 := lang.Apply(kw_error_DASH_handler, []any{v9}) - if lang.IsTruthy(tmp13) { - tmp14 := lang.Apply(kw_error_DASH_handler, []any{v9}) - tmp15, _ := lang.FieldOrMethod(v5, "setErrorHandler") - if reflect.TypeOf(tmp15).Kind() != reflect.Func { + tmp7 := checkDerefVar(var_glojure_DOT_core_apply) + tmp8 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp9 := lang.Apply(tmp7, []any{tmp8, v3}) + var v10 any = tmp9 + _ = v10 + tmp11 := checkDerefVar(var_glojure_DOT_core_setup_DASH_reference) + tmp12 := lang.Apply(tmp11, []any{v6, v3}) + _ = tmp12 + var tmp13 any + tmp14 := lang.Apply(kw_error_DASH_handler, []any{v10}) + if lang.IsTruthy(tmp14) { + tmp15 := lang.Apply(kw_error_DASH_handler, []any{v10}) + tmp16, _ := lang.FieldOrMethod(v6, "setErrorHandler") + if reflect.TypeOf(tmp16).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorHandler is not a function"))) } - tmp16 := lang.Apply(tmp15, []any{tmp14}) - tmp12 = tmp16 + tmp17 := lang.Apply(tmp16, []any{tmp15}) + tmp13 = tmp17 } else { } - _ = tmp12 - var tmp17 any + _ = tmp13 + var tmp18 any { // let // let binding "or__0__auto__" - tmp18 := lang.Apply(kw_error_DASH_mode, []any{v9}) - var v19 any = tmp18 - _ = v19 - var tmp20 any - if lang.IsTruthy(v19) { - tmp20 = v19 + tmp19 := lang.Apply(kw_error_DASH_mode, []any{v10}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + tmp21 = v20 } else { - var tmp21 any - tmp22 := lang.Apply(kw_error_DASH_handler, []any{v9}) - if lang.IsTruthy(tmp22) { - tmp21 = kw_continue + var tmp22 any + tmp23 := lang.Apply(kw_error_DASH_handler, []any{v10}) + if lang.IsTruthy(tmp23) { + tmp22 = kw_continue } else { - tmp21 = kw_fail + tmp22 = kw_fail } - tmp20 = tmp21 + tmp21 = tmp22 } - tmp17 = tmp20 + tmp18 = tmp21 } // end let - tmp18, _ := lang.FieldOrMethod(v5, "setErrorMode") - if reflect.TypeOf(tmp18).Kind() != reflect.Func { + tmp19, _ := lang.FieldOrMethod(v6, "setErrorMode") + if reflect.TypeOf(tmp19).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorMode is not a function"))) } - tmp19 := lang.Apply(tmp18, []any{tmp17}) - _ = tmp19 - tmp4 = v5 + tmp20 := lang.Apply(tmp19, []any{tmp18}) + _ = tmp20 + tmp4 = v6 } // end let return tmp4 } @@ -43882,244 +43880,7 @@ func LoadNS() { var tmp8 any { // let // let binding "latch" - var v9 any = "unimplemented: new with non-constant class type" - _ = v9 - // let binding "count-down" - var tmp10 lang.FnFunc - tmp10 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v11 := args[0] - _ = v11 - tmp12, _ := lang.FieldOrMethod(v9, "countDown") - if reflect.TypeOf(tmp12).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("countDown is not a function"))) - } - tmp13 := lang.Apply(tmp12, []any{}) - _ = tmp13 - return v11 - }) - tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3279), kw_column, int(22), kw_end_DASH_line, int(3279), kw_end_DASH_column, int(61)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v13 any = tmp12 - _ = v13 - var tmp14 any - { // let - // let binding "seq_1" - tmp15 := checkDerefVar(var_glojure_DOT_core_seq) - tmp16 := lang.Apply(tmp15, []any{v2}) - var v17 any = tmp16 - _ = v17 - // let binding "chunk_2" - var v18 any = nil - _ = v18 - // let binding "count_3" - var v19 any = int64(0) - _ = v19 - // let binding "i_4" - var v20 any = int64(0) - _ = v20 - for { - var tmp21 any - tmp22 := checkDerefVar(var_glojure_DOT_core__LT_) - tmp23 := lang.Apply(tmp22, []any{v20, v19}) - if lang.IsTruthy(tmp23) { - var tmp24 any - { // let - // let binding "agent" - tmp25, _ := lang.FieldOrMethod(v18, "nth") - if reflect.TypeOf(tmp25).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) - } - tmp26 := lang.Apply(tmp25, []any{v20}) - var v27 any = tmp26 - _ = v27 - tmp28 := checkDerefVar(var_glojure_DOT_core_send) - tmp29 := lang.Apply(tmp28, []any{v27, v13}) - _ = tmp29 - var tmp30 any = v17 - var tmp31 any = v18 - var tmp32 any = v19 - tmp34 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) - tmp35 := lang.Apply(tmp34, []any{v20}) - var tmp33 any = tmp35 - v17 = tmp30 - v18 = tmp31 - v19 = tmp32 - v20 = tmp33 - continue - } // end let - tmp21 = tmp24 - } else { - var tmp25 any - { // let - // let binding "temp__0__auto__" - tmp26 := checkDerefVar(var_glojure_DOT_core_seq) - tmp27 := lang.Apply(tmp26, []any{v17}) - var v28 any = tmp27 - _ = v28 - var tmp29 any - if lang.IsTruthy(v28) { - var tmp30 any - { // let - // let binding "seq_1" - var v31 any = v28 - _ = v31 - var tmp32 any - tmp33 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) - tmp34 := lang.Apply(tmp33, []any{v31}) - if lang.IsTruthy(tmp34) { - var tmp35 any - { // let - // let binding "c__0__auto__" - tmp36 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) - tmp37 := lang.Apply(tmp36, []any{v31}) - var v38 any = tmp37 - _ = v38 - tmp40 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) - tmp41 := lang.Apply(tmp40, []any{v31}) - var tmp39 any = tmp41 - var tmp42 any = v38 - tmp44 := checkDerefVar(var_glojure_DOT_core_int) - tmp45 := checkDerefVar(var_glojure_DOT_core_count) - tmp46 := lang.Apply(tmp45, []any{v38}) - tmp47 := lang.Apply(tmp44, []any{tmp46}) - var tmp43 any = tmp47 - tmp49 := checkDerefVar(var_glojure_DOT_core_int) - tmp50 := lang.Apply(tmp49, []any{int64(0)}) - var tmp48 any = tmp50 - v17 = tmp39 - v18 = tmp42 - v19 = tmp43 - v20 = tmp48 - continue - } // end let - tmp32 = tmp35 - } else { - var tmp36 any - { // let - // let binding "agent" - tmp37 := checkDerefVar(var_glojure_DOT_core_first) - tmp38 := lang.Apply(tmp37, []any{v31}) - var v39 any = tmp38 - _ = v39 - tmp40 := checkDerefVar(var_glojure_DOT_core_send) - tmp41 := lang.Apply(tmp40, []any{v39, v13}) - _ = tmp41 - tmp43 := checkDerefVar(var_glojure_DOT_core_next) - tmp44 := lang.Apply(tmp43, []any{v31}) - var tmp42 any = tmp44 - var tmp45 any = nil - var tmp46 any = int64(0) - var tmp47 any = int64(0) - v17 = tmp42 - v18 = tmp45 - v19 = tmp46 - v20 = tmp47 - continue - } // end let - tmp32 = tmp36 - } - tmp30 = tmp32 - } // end let - tmp29 = tmp30 - } else { - } - tmp25 = tmp29 - } // end let - tmp21 = tmp25 - } - tmp14 = tmp21 - break - } - } // end let - _ = tmp14 - tmp15, _ := lang.FieldOrMethod(v9, "await") - if reflect.TypeOf(tmp15).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) - } - tmp16 := lang.Apply(tmp15, []any{}) - tmp8 = tmp16 - } // end let - tmp3 = tmp8 - } - return tmp3 - } - }) - tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - var_glojure_DOT_core_await = ns.InternWithValue(tmp0, tmp1, true) - if tmp0.Meta() != nil { - var_glojure_DOT_core_await.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // await1 - { - tmp0 := sym_await1.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(3284), kw_column, int(7), kw_end_DASH_line, int(3284), kw_end_DASH_column, int(21), kw_arglists, lang.NewList(lang.NewVector(sym_a)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - var tmp1 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v2 := args[0] - _ = v2 - var tmp3 any - tmp4 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) - tmp5, ok := lang.FieldOrMethod(v2, "getQueueCount") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getQueueCount"))) - } - var tmp6 any - switch reflect.TypeOf(tmp5).Kind() { - case reflect.Func: - tmp6 = lang.Apply(tmp5, nil) - default: - tmp6 = tmp5 - } - tmp7 := lang.Apply(tmp4, []any{tmp6}) - if lang.IsTruthy(tmp7) { - tmp8 := checkDerefVar(var_glojure_DOT_core_await) - tmp9 := lang.Apply(tmp8, []any{v2}) - tmp3 = tmp9 - } else { - } - _ = tmp3 - return v2 - }) - tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - var_glojure_DOT_core_await1 = ns.InternWithValue(tmp0, tmp1, true) - if tmp0.Meta() != nil { - var_glojure_DOT_core_await1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // await-for - { - tmp0 := sym_await_DASH_for.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_timeout_DASH_ms, sym__AMP_, sym_agents)), kw_doc, "Blocks the current thread until all actions dispatched thus\n far (from this thread or agent) to the agents have occurred, or the\n timeout (in milliseconds) has elapsed. Returns logical false if\n returning due to timeout, logical true otherwise.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(3289), kw_end_DASH_line, int(3289))).(*lang.Symbol) - var tmp1 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArityGTE(args, 1) - v2 := args[0] - _ = v2 - var v3 any = lang.NewList(args[1:]...) - _ = v3 - var tmp4 any - tmp5 := lang.Apply(nil, nil) - if lang.IsTruthy(tmp5) { - panic("unimplemented: new with non-constant class type") - } else { - var tmp6 any - tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_agent_STAR_) - if lang.IsTruthy(tmp7) { - tmp8 := lang.Apply(errors8.New, []any{"Can't await in agent action"}) - panic(tmp8) - } else { - } - _ = tmp6 - var tmp9 any - { // let - // let binding "latch" - var v10 any = "unimplemented: new with non-constant class type" + var v10 any = nil _ = v10 // let binding "count-down" var tmp11 lang.FnFunc @@ -44135,7 +43896,7 @@ func LoadNS() { _ = tmp14 return v12 }) - tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3301), kw_column, int(23), kw_end_DASH_line, int(3301), kw_end_DASH_column, int(62)) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3279), kw_column, int(22), kw_end_DASH_line, int(3279), kw_end_DASH_column, int(61)) tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) if err != nil { panic(err) @@ -44144,18 +43905,18 @@ func LoadNS() { _ = v14 var tmp15 any { // let - // let binding "seq_5" + // let binding "seq_1" tmp16 := checkDerefVar(var_glojure_DOT_core_seq) - tmp17 := lang.Apply(tmp16, []any{v3}) + tmp17 := lang.Apply(tmp16, []any{v2}) var v18 any = tmp17 _ = v18 - // let binding "chunk_6" + // let binding "chunk_2" var v19 any = nil _ = v19 - // let binding "count_7" + // let binding "count_3" var v20 any = int64(0) _ = v20 - // let binding "i_8" + // let binding "i_4" var v21 any = int64(0) _ = v21 for { @@ -44201,7 +43962,7 @@ func LoadNS() { if lang.IsTruthy(v29) { var tmp31 any { // let - // let binding "seq_5" + // let binding "seq_1" var v32 any = v29 _ = v32 var tmp33 any @@ -44273,23 +44034,260 @@ func LoadNS() { } } // end let _ = tmp15 - tmp16, ok := lang.FieldOrMethod(nil, "MILLISECONDS") + tmp16, _ := lang.FieldOrMethod(v10, "await") + if reflect.TypeOf(tmp16).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) + } + tmp17 := lang.Apply(tmp16, []any{}) + tmp8 = tmp17 + } // end let + tmp3 = tmp8 + } + return tmp3 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_await = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_await.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // await1 + { + tmp0 := sym_await1.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(3284), kw_column, int(7), kw_end_DASH_line, int(3284), kw_end_DASH_column, int(21), kw_arglists, lang.NewList(lang.NewVector(sym_a)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp5, ok := lang.FieldOrMethod(v2, "getQueueCount") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getQueueCount"))) + } + var tmp6 any + switch reflect.TypeOf(tmp5).Kind() { + case reflect.Func: + tmp6 = lang.Apply(tmp5, nil) + default: + tmp6 = tmp5 + } + tmp7 := lang.Apply(tmp4, []any{tmp6}) + if lang.IsTruthy(tmp7) { + tmp8 := checkDerefVar(var_glojure_DOT_core_await) + tmp9 := lang.Apply(tmp8, []any{v2}) + tmp3 = tmp9 + } else { + } + _ = tmp3 + return v2 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_await1 = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_await1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // await-for + { + tmp0 := sym_await_DASH_for.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_timeout_DASH_ms, sym__AMP_, sym_agents)), kw_doc, "Blocks the current thread until all actions dispatched thus\n far (from this thread or agent) to the agents have occurred, or the\n timeout (in milliseconds) has elapsed. Returns logical false if\n returning due to timeout, logical true otherwise.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(3289), kw_end_DASH_line, int(3289))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArityGTE(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + var tmp4 any + tmp5 := lang.Apply(nil, nil) + if lang.IsTruthy(tmp5) { + panic("unimplemented: new with non-constant class type") + } else { + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_agent_STAR_) + if lang.IsTruthy(tmp7) { + tmp8 := lang.Apply(errors8.New, []any{"Can't await in agent action"}) + panic(tmp8) + } else { + } + _ = tmp6 + var tmp9 any + { // let + // let binding "latch" + var v11 any = nil + _ = v11 + // let binding "count-down" + var tmp12 lang.FnFunc + tmp12 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v13 := args[0] + _ = v13 + tmp14, _ := lang.FieldOrMethod(v11, "countDown") + if reflect.TypeOf(tmp14).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("countDown is not a function"))) + } + tmp15 := lang.Apply(tmp14, []any{}) + _ = tmp15 + return v13 + }) + tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3301), kw_column, int(23), kw_end_DASH_line, int(3301), kw_end_DASH_column, int(62)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v15 any = tmp14 + _ = v15 + var tmp16 any + { // let + // let binding "seq_5" + tmp17 := checkDerefVar(var_glojure_DOT_core_seq) + tmp18 := lang.Apply(tmp17, []any{v3}) + var v19 any = tmp18 + _ = v19 + // let binding "chunk_6" + var v20 any = nil + _ = v20 + // let binding "count_7" + var v21 any = int64(0) + _ = v21 + // let binding "i_8" + var v22 any = int64(0) + _ = v22 + for { + var tmp23 any + tmp24 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp25 := lang.Apply(tmp24, []any{v22, v21}) + if lang.IsTruthy(tmp25) { + var tmp26 any + { // let + // let binding "agent" + tmp27, _ := lang.FieldOrMethod(v20, "nth") + if reflect.TypeOf(tmp27).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp28 := lang.Apply(tmp27, []any{v22}) + var v29 any = tmp28 + _ = v29 + tmp30 := checkDerefVar(var_glojure_DOT_core_send) + tmp31 := lang.Apply(tmp30, []any{v29, v15}) + _ = tmp31 + var tmp32 any = v19 + var tmp33 any = v20 + var tmp34 any = v21 + tmp36 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp37 := lang.Apply(tmp36, []any{v22}) + var tmp35 any = tmp37 + v19 = tmp32 + v20 = tmp33 + v21 = tmp34 + v22 = tmp35 + continue + } // end let + tmp23 = tmp26 + } else { + var tmp27 any + { // let + // let binding "temp__0__auto__" + tmp28 := checkDerefVar(var_glojure_DOT_core_seq) + tmp29 := lang.Apply(tmp28, []any{v19}) + var v30 any = tmp29 + _ = v30 + var tmp31 any + if lang.IsTruthy(v30) { + var tmp32 any + { // let + // let binding "seq_5" + var v33 any = v30 + _ = v33 + var tmp34 any + tmp35 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp36 := lang.Apply(tmp35, []any{v33}) + if lang.IsTruthy(tmp36) { + var tmp37 any + { // let + // let binding "c__0__auto__" + tmp38 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp39 := lang.Apply(tmp38, []any{v33}) + var v40 any = tmp39 + _ = v40 + tmp42 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp43 := lang.Apply(tmp42, []any{v33}) + var tmp41 any = tmp43 + var tmp44 any = v40 + tmp46 := checkDerefVar(var_glojure_DOT_core_int) + tmp47 := checkDerefVar(var_glojure_DOT_core_count) + tmp48 := lang.Apply(tmp47, []any{v40}) + tmp49 := lang.Apply(tmp46, []any{tmp48}) + var tmp45 any = tmp49 + tmp51 := checkDerefVar(var_glojure_DOT_core_int) + tmp52 := lang.Apply(tmp51, []any{int64(0)}) + var tmp50 any = tmp52 + v19 = tmp41 + v20 = tmp44 + v21 = tmp45 + v22 = tmp50 + continue + } // end let + tmp34 = tmp37 + } else { + var tmp38 any + { // let + // let binding "agent" + tmp39 := checkDerefVar(var_glojure_DOT_core_first) + tmp40 := lang.Apply(tmp39, []any{v33}) + var v41 any = tmp40 + _ = v41 + tmp42 := checkDerefVar(var_glojure_DOT_core_send) + tmp43 := lang.Apply(tmp42, []any{v41, v15}) + _ = tmp43 + tmp45 := checkDerefVar(var_glojure_DOT_core_next) + tmp46 := lang.Apply(tmp45, []any{v33}) + var tmp44 any = tmp46 + var tmp47 any = nil + var tmp48 any = int64(0) + var tmp49 any = int64(0) + v19 = tmp44 + v20 = tmp47 + v21 = tmp48 + v22 = tmp49 + continue + } // end let + tmp34 = tmp38 + } + tmp32 = tmp34 + } // end let + tmp31 = tmp32 + } else { + } + tmp27 = tmp31 + } // end let + tmp23 = tmp27 + } + tmp16 = tmp23 + break + } + } // end let + _ = tmp16 + tmp17, ok := lang.FieldOrMethod(nil, "MILLISECONDS") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "MILLISECONDS"))) } - var tmp17 any - switch reflect.TypeOf(tmp16).Kind() { + var tmp18 any + switch reflect.TypeOf(tmp17).Kind() { case reflect.Func: - tmp17 = lang.Apply(tmp16, nil) + tmp18 = lang.Apply(tmp17, nil) default: - tmp17 = tmp16 + tmp18 = tmp17 } - tmp18, _ := lang.FieldOrMethod(v10, "await") - if reflect.TypeOf(tmp18).Kind() != reflect.Func { + tmp19, _ := lang.FieldOrMethod(v11, "await") + if reflect.TypeOf(tmp19).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) } - tmp19 := lang.Apply(tmp18, []any{v2, tmp17}) - tmp9 = tmp19 + tmp20 := lang.Apply(tmp19, []any{v2, tmp18}) + tmp9 = tmp20 } // end let tmp4 = tmp9 } @@ -54165,34 +54163,35 @@ func LoadNS() { var tmp4 any { // let // let binding "s__0__auto__" - var v5 any = "unimplemented: new with non-constant class type" - _ = v5 - var tmp6 any + tmp5 := new(strings11.Builder) + var v6 any = tmp5 + _ = v6 + var tmp7 any { // let - tmp7 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) - tmp8 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) - tmp9 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) - tmp10 := lang.Apply(tmp8, []any{tmp9, v5}) - tmp11 := lang.Apply(tmp7, []any{tmp10}) - _ = tmp11 - var tmp12 any + tmp8 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp9 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp10 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) + tmp11 := lang.Apply(tmp9, []any{tmp10, v6}) + tmp12 := lang.Apply(tmp8, []any{tmp11}) + _ = tmp12 + var tmp13 any func() { defer func() { - tmp13 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) - tmp14 := lang.Apply(tmp13, nil) - _ = tmp14 + tmp14 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp15 := lang.Apply(tmp14, nil) + _ = tmp15 }() - tmp15 := checkDerefVar(var_glojure_DOT_core_apply) - tmp16 := checkDerefVar(var_glojure_DOT_core_pr) - tmp17 := lang.Apply(tmp15, []any{tmp16, v3}) - _ = tmp17 - tmp18 := checkDerefVar(var_glojure_DOT_core_str) - tmp19 := lang.Apply(tmp18, []any{v5}) - tmp12 = tmp19 + tmp16 := checkDerefVar(var_glojure_DOT_core_apply) + tmp17 := checkDerefVar(var_glojure_DOT_core_pr) + tmp18 := lang.Apply(tmp16, []any{tmp17, v3}) + _ = tmp18 + tmp19 := checkDerefVar(var_glojure_DOT_core_str) + tmp20 := lang.Apply(tmp19, []any{v6}) + tmp13 = tmp20 }() - tmp6 = tmp12 + tmp7 = tmp13 } // end let - tmp4 = tmp6 + tmp4 = tmp7 } // end let return tmp4 } @@ -54259,34 +54258,35 @@ func LoadNS() { var tmp4 any { // let // let binding "s__0__auto__" - var v5 any = "unimplemented: new with non-constant class type" - _ = v5 - var tmp6 any + tmp5 := new(strings11.Builder) + var v6 any = tmp5 + _ = v6 + var tmp7 any { // let - tmp7 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) - tmp8 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) - tmp9 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) - tmp10 := lang.Apply(tmp8, []any{tmp9, v5}) - tmp11 := lang.Apply(tmp7, []any{tmp10}) - _ = tmp11 - var tmp12 any + tmp8 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp9 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp10 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) + tmp11 := lang.Apply(tmp9, []any{tmp10, v6}) + tmp12 := lang.Apply(tmp8, []any{tmp11}) + _ = tmp12 + var tmp13 any func() { defer func() { - tmp13 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) - tmp14 := lang.Apply(tmp13, nil) - _ = tmp14 + tmp14 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp15 := lang.Apply(tmp14, nil) + _ = tmp15 }() - tmp15 := checkDerefVar(var_glojure_DOT_core_apply) - tmp16 := checkDerefVar(var_glojure_DOT_core_print) - tmp17 := lang.Apply(tmp15, []any{tmp16, v3}) - _ = tmp17 - tmp18 := checkDerefVar(var_glojure_DOT_core_str) - tmp19 := lang.Apply(tmp18, []any{v5}) - tmp12 = tmp19 + tmp16 := checkDerefVar(var_glojure_DOT_core_apply) + tmp17 := checkDerefVar(var_glojure_DOT_core_print) + tmp18 := lang.Apply(tmp16, []any{tmp17, v3}) + _ = tmp18 + tmp19 := checkDerefVar(var_glojure_DOT_core_str) + tmp20 := lang.Apply(tmp19, []any{v6}) + tmp13 = tmp20 }() - tmp6 = tmp12 + tmp7 = tmp13 } // end let - tmp4 = tmp6 + tmp4 = tmp7 } // end let return tmp4 } @@ -54372,34 +54372,35 @@ func LoadNS() { var tmp4 any { // let // let binding "s__0__auto__" - var v5 any = "unimplemented: new with non-constant class type" - _ = v5 - var tmp6 any + tmp5 := new(strings11.Builder) + var v6 any = tmp5 + _ = v6 + var tmp7 any { // let - tmp7 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) - tmp8 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) - tmp9 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) - tmp10 := lang.Apply(tmp8, []any{tmp9, v5}) - tmp11 := lang.Apply(tmp7, []any{tmp10}) - _ = tmp11 - var tmp12 any + tmp8 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp9 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp10 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) + tmp11 := lang.Apply(tmp9, []any{tmp10, v6}) + tmp12 := lang.Apply(tmp8, []any{tmp11}) + _ = tmp12 + var tmp13 any func() { defer func() { - tmp13 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) - tmp14 := lang.Apply(tmp13, nil) - _ = tmp14 + tmp14 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp15 := lang.Apply(tmp14, nil) + _ = tmp15 }() - tmp15 := checkDerefVar(var_glojure_DOT_core_apply) - tmp16 := checkDerefVar(var_glojure_DOT_core_prn) - tmp17 := lang.Apply(tmp15, []any{tmp16, v3}) - _ = tmp17 - tmp18 := checkDerefVar(var_glojure_DOT_core_str) - tmp19 := lang.Apply(tmp18, []any{v5}) - tmp12 = tmp19 + tmp16 := checkDerefVar(var_glojure_DOT_core_apply) + tmp17 := checkDerefVar(var_glojure_DOT_core_prn) + tmp18 := lang.Apply(tmp16, []any{tmp17, v3}) + _ = tmp18 + tmp19 := checkDerefVar(var_glojure_DOT_core_str) + tmp20 := lang.Apply(tmp19, []any{v6}) + tmp13 = tmp20 }() - tmp6 = tmp12 + tmp7 = tmp13 } // end let - tmp4 = tmp6 + tmp4 = tmp7 } // end let return tmp4 } @@ -54466,34 +54467,35 @@ func LoadNS() { var tmp4 any { // let // let binding "s__0__auto__" - var v5 any = "unimplemented: new with non-constant class type" - _ = v5 - var tmp6 any + tmp5 := new(strings11.Builder) + var v6 any = tmp5 + _ = v6 + var tmp7 any { // let - tmp7 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) - tmp8 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) - tmp9 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) - tmp10 := lang.Apply(tmp8, []any{tmp9, v5}) - tmp11 := lang.Apply(tmp7, []any{tmp10}) - _ = tmp11 - var tmp12 any + tmp8 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp9 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp10 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) + tmp11 := lang.Apply(tmp9, []any{tmp10, v6}) + tmp12 := lang.Apply(tmp8, []any{tmp11}) + _ = tmp12 + var tmp13 any func() { defer func() { - tmp13 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) - tmp14 := lang.Apply(tmp13, nil) - _ = tmp14 + tmp14 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp15 := lang.Apply(tmp14, nil) + _ = tmp15 }() - tmp15 := checkDerefVar(var_glojure_DOT_core_apply) - tmp16 := checkDerefVar(var_glojure_DOT_core_println) - tmp17 := lang.Apply(tmp15, []any{tmp16, v3}) - _ = tmp17 - tmp18 := checkDerefVar(var_glojure_DOT_core_str) - tmp19 := lang.Apply(tmp18, []any{v5}) - tmp12 = tmp19 + tmp16 := checkDerefVar(var_glojure_DOT_core_apply) + tmp17 := checkDerefVar(var_glojure_DOT_core_println) + tmp18 := lang.Apply(tmp16, []any{tmp17, v3}) + _ = tmp18 + tmp19 := checkDerefVar(var_glojure_DOT_core_str) + tmp20 := lang.Apply(tmp19, []any{v6}) + tmp13 = tmp20 }() - tmp6 = tmp12 + tmp7 = tmp13 } // end let - tmp4 = tmp6 + tmp4 = tmp7 } // end let return tmp4 } @@ -57359,41 +57361,42 @@ func LoadNS() { var v8 any = tmp7 _ = v8 // let binding "sw" - var v9 any = "unimplemented: new with non-constant class type" - _ = v9 - var tmp10 any + tmp9 := new(strings11.Builder) + var v10 any = tmp9 + _ = v10 + var tmp11 any { // let // let binding "r" - tmp11 := checkDerefVar(var_glojure_DOT_core_apply) - tmp12 := checkDerefVar(var_glojure_DOT_go_DOT_io_reader) - tmp13 := lang.Apply(tmp11, []any{tmp12, v3, v8}) - var v14 any = tmp13 - _ = v14 - var tmp15 any + tmp12 := checkDerefVar(var_glojure_DOT_core_apply) + tmp13 := checkDerefVar(var_glojure_DOT_go_DOT_io_reader) + tmp14 := lang.Apply(tmp12, []any{tmp13, v3, v8}) + var v15 any = tmp14 + _ = v15 + var tmp16 any func() { defer func() { - tmp16, ok := lang.FieldOrMethod(v14, "close") + tmp17, ok := lang.FieldOrMethod(v15, "close") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v14, "close"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v15, "close"))) } - var tmp17 any - switch reflect.TypeOf(tmp16).Kind() { + var tmp18 any + switch reflect.TypeOf(tmp17).Kind() { case reflect.Func: - tmp17 = lang.Apply(tmp16, nil) + tmp18 = lang.Apply(tmp17, nil) default: - tmp17 = tmp16 + tmp18 = tmp17 } - _ = tmp17 + _ = tmp18 }() - tmp18 := checkDerefVar(var_glojure_DOT_go_DOT_io_copy) - tmp19 := lang.Apply(tmp18, []any{v14, v9}) - _ = tmp19 - tmp20 := lang.Apply(lang.ToString, []any{v9}) - tmp15 = tmp20 + tmp19 := checkDerefVar(var_glojure_DOT_go_DOT_io_copy) + tmp20 := lang.Apply(tmp19, []any{v15, v10}) + _ = tmp20 + tmp21 := lang.Apply(lang.ToString, []any{v10}) + tmp16 = tmp21 }() - tmp10 = tmp15 + tmp11 = tmp16 } // end let - tmp5 = tmp10 + tmp5 = tmp11 } // end let return tmp5 } diff --git a/pkg/runtime/testdata/codegen/test/set_bang.glj b/pkg/runtime/testdata/codegen/test/set_bang.glj new file mode 100644 index 00000000..25185c3d --- /dev/null +++ b/pkg/runtime/testdata/codegen/test/set_bang.glj @@ -0,0 +1,17 @@ +(ns codegen.test.set-bang) + +(def ^:dynamic x 10) + +(defn set!-var [] + (binding [x 15] + (set! x 20) + (set! x (+ x 5)) + x)) + +(defn set!-host [] + (let [c (new net$http.Client)] + (set! (. c Timeout) (time.Duration 1000)) + (. c Timeout))) + +(defn ^{:expected-output [25 (time.Duration 1000)]} -main [] + [(set!-var) (set!-host)]) diff --git a/pkg/runtime/testdata/codegen/test/set_bang/load.go.out b/pkg/runtime/testdata/codegen/test/set_bang/load.go.out new file mode 100644 index 00000000..be957356 --- /dev/null +++ b/pkg/runtime/testdata/codegen/test/set_bang/load.go.out @@ -0,0 +1,218 @@ +// Code generated by glojure codegen. DO NOT EDIT. + +package set_DASH_bang + +import ( + fmt "fmt" + lang "github.com/glojurelang/glojure/pkg/lang" + runtime "github.com/glojurelang/glojure/pkg/runtime" + http5 "net/http" + reflect "reflect" + time4 "time" +) + +func init() { + runtime.RegisterNSLoader("codegen/test/set_bang", LoadNS) +} + +func checkDerefVar(v *lang.Var) any { + if v.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) + } + return v.Get() +} + +func checkArity(args []any, expected int) { + if len(args) != expected { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + +func checkArityGTE(args []any, min int) { + if len(args) < min { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + +// LoadNS initializes the namespace "codegen.test.set-bang" +func LoadNS() { + sym__PLUS_ := lang.NewSymbol("+") + sym__DASH_main := lang.NewSymbol("-main") + sym_codegen_DOT_test_DOT_set_DASH_bang := lang.NewSymbol("codegen.test.set-bang") + sym_glojure_DOT_core := lang.NewSymbol("glojure.core") + sym_hash_DASH_map := lang.NewSymbol("hash-map") + sym_pop_DASH_thread_DASH_bindings := lang.NewSymbol("pop-thread-bindings") + sym_push_DASH_thread_DASH_bindings := lang.NewSymbol("push-thread-bindings") + sym_set_BANG__DASH_host := lang.NewSymbol("set!-host") + sym_set_BANG__DASH_var := lang.NewSymbol("set!-var") + sym_x := lang.NewSymbol("x") + kw_arglists := lang.NewKeyword("arglists") + kw_column := lang.NewKeyword("column") + kw_dynamic := lang.NewKeyword("dynamic") + kw_end_DASH_column := lang.NewKeyword("end-column") + kw_end_DASH_line := lang.NewKeyword("end-line") + kw_expected_DASH_output := lang.NewKeyword("expected-output") + kw_file := lang.NewKeyword("file") + kw_line := lang.NewKeyword("line") + kw_ns := lang.NewKeyword("ns") + kw_rettag := lang.NewKeyword("rettag") + // var codegen.test.set-bang/-main + var_codegen_DOT_test_DOT_set_DASH_bang__DASH_main := lang.InternVarName(sym_codegen_DOT_test_DOT_set_DASH_bang, sym__DASH_main) + // var codegen.test.set-bang/set!-host + var_codegen_DOT_test_DOT_set_DASH_bang_set_BANG__DASH_host := lang.InternVarName(sym_codegen_DOT_test_DOT_set_DASH_bang, sym_set_BANG__DASH_host) + // var codegen.test.set-bang/set!-var + var_codegen_DOT_test_DOT_set_DASH_bang_set_BANG__DASH_var := lang.InternVarName(sym_codegen_DOT_test_DOT_set_DASH_bang, sym_set_BANG__DASH_var) + // var codegen.test.set-bang/x + var_codegen_DOT_test_DOT_set_DASH_bang_x := lang.InternVarName(sym_codegen_DOT_test_DOT_set_DASH_bang, sym_x) + // var glojure.core/+ + var_glojure_DOT_core__PLUS_ := lang.InternVarName(sym_glojure_DOT_core, sym__PLUS_) + // var glojure.core/hash-map + var_glojure_DOT_core_hash_DASH_map := lang.InternVarName(sym_glojure_DOT_core, sym_hash_DASH_map) + // var glojure.core/pop-thread-bindings + var_glojure_DOT_core_pop_DASH_thread_DASH_bindings := lang.InternVarName(sym_glojure_DOT_core, sym_pop_DASH_thread_DASH_bindings) + // var glojure.core/push-thread-bindings + var_glojure_DOT_core_push_DASH_thread_DASH_bindings := lang.InternVarName(sym_glojure_DOT_core, sym_push_DASH_thread_DASH_bindings) + // reference fmt to avoid unused import error + _ = fmt.Printf + // reference reflect to avoid unused import error + _ = reflect.TypeOf + ns := lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_set_DASH_bang) + _ = ns + // set!-host + { + tmp0 := sym_set_BANG__DASH_host.WithMeta(lang.NewMap(kw_file, "codegen/test/set_bang.glj", kw_line, int(11), kw_column, int(7), kw_end_DASH_line, int(11), kw_end_DASH_column, int(15), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_set_DASH_bang))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp2 any + { // let + // let binding "c" + tmp3 := new(http5.Client) + var v4 any = tmp3 + _ = v4 + tmp5 := reflect.TypeOf(time4.Duration(0)) + tmp6 := lang.Apply(tmp5, []any{int64(1000)}) + // set! host field + var tmp7 any + { + targetV := reflect.ValueOf(v4) + if targetV.Kind() == reflect.Ptr { + targetV = targetV.Elem() + } + fieldVal := targetV.FieldByName("Timeout") + if !fieldVal.IsValid() { + panic(fmt.Errorf("no such field Timeout")) + } + if !fieldVal.CanSet() { + panic(fmt.Errorf("cannot set field Timeout")) + } + valV := reflect.ValueOf(tmp6) + if !valV.IsValid() { + switch fieldVal.Kind() { + case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Pointer, reflect.Slice, reflect.UnsafePointer: + fieldVal.Set(reflect.Zero(fieldVal.Type())) + default: + panic(fmt.Errorf("cannot set field Timeout to nil")) + } + } else { + fieldVal.Set(valV) + } + tmp7 = tmp6 + } + _ = tmp7 + tmp8, ok := lang.FieldOrMethod(v4, "Timeout") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v4, "Timeout"))) + } + var tmp9 any + switch reflect.TypeOf(tmp8).Kind() { + case reflect.Func: + tmp9 = lang.Apply(tmp8, nil) + default: + tmp9 = tmp8 + } + tmp2 = tmp9 + } // end let + return tmp2 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_codegen_DOT_test_DOT_set_DASH_bang_set_BANG__DASH_host = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_codegen_DOT_test_DOT_set_DASH_bang_set_BANG__DASH_host.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // x + { + tmp0 := sym_x.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "codegen/test/set_bang.glj", kw_line, int(3), kw_column, int(6), kw_end_DASH_line, int(3), kw_end_DASH_column, int(16), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_set_DASH_bang))).(*lang.Symbol) + var_codegen_DOT_test_DOT_set_DASH_bang_x = ns.InternWithValue(tmp0, int64(10), true) + if tmp0.Meta() != nil { + var_codegen_DOT_test_DOT_set_DASH_bang_x.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + var_codegen_DOT_test_DOT_set_DASH_bang_x.SetDynamic() + } + // -main + { + tmp0 := sym__DASH_main.WithMeta(lang.NewMap(kw_expected_DASH_output, lang.NewVector(int64(25), time4.Duration(1000)), kw_file, "codegen/test/set_bang.glj", kw_line, int(16), kw_column, int(7), kw_end_DASH_line, int(16), kw_end_DASH_column, int(57), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_set_DASH_bang))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp2 := checkDerefVar(var_codegen_DOT_test_DOT_set_DASH_bang_set_BANG__DASH_var) + tmp3 := lang.Apply(tmp2, nil) + tmp4 := checkDerefVar(var_codegen_DOT_test_DOT_set_DASH_bang_set_BANG__DASH_host) + tmp5 := lang.Apply(tmp4, nil) + tmp6 := lang.NewVector(tmp3, tmp5) + tmp7 := lang.NewMap(kw_file, "codegen/test/set_bang.glj", kw_line, int(17), kw_column, int(3), kw_end_DASH_line, int(17), kw_end_DASH_column, int(26)) + tmp8, err := lang.WithMeta(tmp6, tmp7.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp8 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_codegen_DOT_test_DOT_set_DASH_bang__DASH_main = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_codegen_DOT_test_DOT_set_DASH_bang__DASH_main.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // set!-var + { + tmp0 := sym_set_BANG__DASH_var.WithMeta(lang.NewMap(kw_file, "codegen/test/set_bang.glj", kw_line, int(5), kw_column, int(7), kw_end_DASH_line, int(5), kw_end_DASH_column, int(14), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_set_DASH_bang))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp2 any + { // let + tmp3 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp4 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp5 := lang.InternVarName(sym_codegen_DOT_test_DOT_set_DASH_bang, sym_x) + tmp6 := lang.Apply(tmp4, []any{tmp5, int64(15)}) + tmp7 := lang.Apply(tmp3, []any{tmp6}) + _ = tmp7 + var tmp8 any + func() { + defer func() { + tmp9 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp10 := lang.Apply(tmp9, nil) + _ = tmp10 + }() + tmp11 := var_codegen_DOT_test_DOT_set_DASH_bang_x.Set(int64(20)) + _ = tmp11 + tmp12 := checkDerefVar(var_glojure_DOT_core__PLUS_) + tmp13 := checkDerefVar(var_codegen_DOT_test_DOT_set_DASH_bang_x) + tmp14 := lang.Apply(tmp12, []any{tmp13, int64(5)}) + tmp15 := var_codegen_DOT_test_DOT_set_DASH_bang_x.Set(tmp14) + _ = tmp15 + tmp16 := checkDerefVar(var_codegen_DOT_test_DOT_set_DASH_bang_x) + tmp8 = tmp16 + }() + tmp2 = tmp8 + } // end let + return tmp2 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_codegen_DOT_test_DOT_set_DASH_bang_set_BANG__DASH_var = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_codegen_DOT_test_DOT_set_DASH_bang_set_BANG__DASH_var.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } +} diff --git a/pkg/stdlib/glojure/core.glj b/pkg/stdlib/glojure/core.glj index bba93707..89bda698 100644 --- a/pkg/stdlib/glojure/core.glj +++ b/pkg/stdlib/glojure/core.glj @@ -860,9 +860,9 @@ (defn zero? "Returns true if num is zero, else false" { - :inline (fn [num] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (IsZero ~num))) + :inline (fn [num] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (isZero ~num))) :added "1.0"} - [num] (. github.com$glojurelang$glojure$pkg$lang.Numbers (IsZero num))) + [num] (. github.com$glojurelang$glojure$pkg$lang.Numbers (isZero num))) (defn count "Returns the number of items in the collection. (count nil) returns @@ -893,11 +893,11 @@ (defn < "Returns non-nil if nums are in monotonically increasing order, otherwise false." - {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Lt ~x ~y))) + {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (lt ~x ~y))) :inline-arities #{2} :added "1.0"} ([x] true) - ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Lt x y))) + ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (lt x y))) ([x y & more] (if (< x y) (if (next more) @@ -908,16 +908,16 @@ (defn inc' "Returns a number one greater than num. Supports arbitrary precision. See also: inc" - {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (IncP ~x))) + {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (incP ~x))) :added "1.0"} - [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (IncP x))) + [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (incP x))) (defn inc "Returns a number one greater than num. Does not auto-promote longs, will throw on overflow. See also: inc'" {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (~(if *unchecked-math* 'unchecked_inc 'inc) ~x))) :added "1.2"} - [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Inc x))) + [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (inc x))) ;; reduce is defined again later after InternalReduce loads (defn ^:private ^:static @@ -959,8 +959,8 @@ (fn [a b] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (~op ~a ~b))) `(. github.com$glojurelang$glojure$pkg$lang.Numbers (~op ~x ~y)) more)))))) -(defn ^:private >1? [n] (.Gt github.com$glojurelang$glojure$pkg$lang.Numbers N 1)) -(defn ^:private >0? [n] (.Gt github.com$glojurelang$glojure$pkg$lang.Numbers N 0)) +(defn ^:private >1? [n] (.Gt github.com$glojurelang$glojure$pkg$lang.Numbers n 1)) +(defn ^:private >0? [n] (.Gt github.com$glojurelang$glojure$pkg$lang.Numbers n 0)) (defn +' "Returns the sum of nums. (+') returns 0. Supports arbitrary precision. @@ -970,7 +970,7 @@ :added "1.0"} ([] 0) ([x] (github.com$glojurelang$glojure$pkg$lang.MustAsNumber x)) - ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (AddP x y))) + ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (addP x y))) ([x y & more] (reduce1 +' (+' x y) more))) @@ -982,7 +982,7 @@ :added "1.2"} ([] 0) ([x] (github.com$glojurelang$glojure$pkg$lang.MustAsNumber x)) - ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Add x y))) + ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (add x y))) ([x y & more] (reduce1 + (+ x y) more))) @@ -994,7 +994,7 @@ :added "1.0"} ([] 1) ([x] (github.com$glojurelang$glojure$pkg$lang.MustAsNumber x)) - ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (MultiplyP x y))) + ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (multiplyP x y))) ([x y & more] (reduce1 *' (*' x y) more))) @@ -1006,7 +1006,7 @@ :added "1.2"} ([] 1) ([x] (github.com$glojurelang$glojure$pkg$lang.MustAsNumber x)) - ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Multiply x y))) + ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (multiply x y))) ([x y & more] (reduce1 * (* x y) more))) @@ -1017,7 +1017,7 @@ :inline-arities >1? :added "1.0"} ([x] (/ 1 x)) - ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Divide x y))) + ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (divide x y))) ([x y & more] (reduce1 / (/ x y) more))) @@ -1029,7 +1029,7 @@ :inline-arities >0? :added "1.0"} ([x] (*' -1 x)) - ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (MinusP x y))) + ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (minusP x y))) ([x y & more] (reduce1 -' (-' x y) more))) @@ -1041,18 +1041,18 @@ :inline-arities >0? :added "1.2"} ([x] (* -1 x)) - ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Minus x y))) + ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (minus x y))) ([x y & more] (reduce1 - (- x y) more))) (defn <= "Returns non-nil if nums are in monotonically non-decreasing order, otherwise false." - {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Lte ~x ~y))) + {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (lte ~x ~y))) :inline-arities #{2} :added "1.0"} ([x] true) - ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Lte x y))) + ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (lte x y))) ([x y & more] (if (<= x y) (if (next more) @@ -1063,11 +1063,11 @@ (defn > "Returns non-nil if nums are in monotonically decreasing order, otherwise false." - {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Gt ~x ~y))) + {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (gt ~x ~y))) :inline-arities #{2} :added "1.0"} ([x] true) - ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Gt x y))) + ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (gt x y))) ([x y & more] (if (> x y) (if (next more) @@ -1078,11 +1078,11 @@ (defn >= "Returns non-nil if nums are in monotonically non-increasing order, otherwise false." - {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Gte ~x ~y))) + {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (gte ~x ~y))) :inline-arities #{2} :added "1.0"} ([x] true) - ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Gte x y))) + ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (gte x y))) ([x y & more] (if (>= x y) (if (next more) @@ -1093,11 +1093,11 @@ (defn == "Returns non-nil if nums all have the equivalent value (type-independent), otherwise false" - {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Equiv ~x ~y))) + {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (equiv ~x ~y))) :inline-arities #{2} :added "1.0"} ([x] true) - ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Equiv x y))) + ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (equiv x y))) ([x y & more] (if (== x y) (if (next more) @@ -1111,7 +1111,7 @@ :inline-arities >1? :inline (nary-inline 'max)} ([x] x) - ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Max x y))) + ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (max x y))) ([x y & more] (reduce1 max (max x y) more))) @@ -1121,7 +1121,7 @@ :inline-arities >1? :inline (nary-inline 'min)} ([x] x) - ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Min x y))) + ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (min x y))) ([x y & more] (reduce1 min (min x y) more))) @@ -1140,159 +1140,159 @@ (defn dec' "Returns a number one less than num. Supports arbitrary precision. See also: dec" - {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (DecP ~x))) + {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (decP ~x))) :added "1.0"} - [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (DecP x))) + [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (decP x))) (defn dec "Returns a number one less than num. Does not auto-promote longs, will throw on overflow. See also: dec'" {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (~(if *unchecked-math* 'unchecked_dec 'dec) ~x))) :added "1.2"} - [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Dec x))) + [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (dec x))) (defn unchecked-inc-int "Returns a number one greater than x, an int. Note - uses a primitive operator subject to overflow." - {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_int_inc ~x))) + {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_int_inc ~x))) :added "1.0"} - [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_int_inc x))) + [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_int_inc x))) (defn unchecked-inc "Returns a number one greater than x, a long. Note - uses a primitive operator subject to overflow." - {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_inc ~x))) + {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_inc ~x))) :added "1.0"} - [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_inc x))) + [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_inc x))) (defn unchecked-dec-int "Returns a number one less than x, an int. Note - uses a primitive operator subject to overflow." - {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_int_dec ~x))) + {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_int_dec ~x))) :added "1.0"} - [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_int_dec x))) + [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_int_dec x))) (defn unchecked-dec "Returns a number one less than x, a long. Note - uses a primitive operator subject to overflow." - {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (UncheckedDec ~x))) + {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_dec ~x))) :added "1.0"} - [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (UncheckedDec x))) + [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_dec x))) (defn unchecked-negate-int "Returns the negation of x, an int. Note - uses a primitive operator subject to overflow." - {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_int_negate ~x))) + {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_int_negate ~x))) :added "1.0"} - [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_int_negate x))) + [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_int_negate x))) (defn unchecked-negate "Returns the negation of x, a long. Note - uses a primitive operator subject to overflow." - {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_minus ~x))) + {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_minus ~x))) :added "1.0"} [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_negate x))) (defn unchecked-add-int "Returns the sum of x and y, both int. Note - uses a primitive operator subject to overflow." - {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_int_add ~x ~y))) + {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_int_add ~x ~y))) :added "1.0"} - [x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_int_add x y))) + [x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_int_add x y))) (defn unchecked-add "Returns the sum of x and y, both long. Note - uses a primitive operator subject to overflow." - {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (UncheckedAdd ~x ~y))) + {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_add ~x ~y))) :added "1.0"} - [x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (UncheckedAdd x y))) + [x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_add x y))) (defn unchecked-subtract-int "Returns the difference of x and y, both int. Note - uses a primitive operator subject to overflow." - {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_int_subtract ~x ~y))) + {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_int_subtract ~x ~y))) :added "1.0"} - [x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_int_subtract x y))) + [x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_int_subtract x y))) (defn unchecked-subtract "Returns the difference of x and y, both long. Note - uses a primitive operator subject to overflow." - {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_minus ~x ~y))) + {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_minus ~x ~y))) :added "1.0"} - [x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_minus x y))) + [x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_minus x y))) (defn unchecked-multiply-int "Returns the product of x and y, both int. Note - uses a primitive operator subject to overflow." - {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_int_multiply ~x ~y))) + {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_int_multiply ~x ~y))) :added "1.0"} - [x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_int_multiply x y))) + [x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_int_multiply x y))) (defn unchecked-multiply "Returns the product of x and y, both long. Note - uses a primitive operator subject to overflow." - {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_multiply ~x ~y))) + {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_multiply ~x ~y))) :added "1.0"} - [x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_multiply x y))) + [x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_multiply x y))) (defn unchecked-divide-int "Returns the division of x by y, both int. Note - uses a primitive operator subject to truncation." - {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (UncheckedIntDivide ~x ~y))) + {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_int_divide ~x ~y))) :added "1.0"} - [x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (UncheckedIntDivide x y))) + [x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_int_divide x y))) (defn unchecked-remainder-int "Returns the remainder of division of x by y, both int. Note - uses a primitive operator subject to truncation." - {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_int_remainder ~x ~y))) + {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_int_remainder ~x ~y))) :added "1.0"} - [x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Unchecked_int_remainder x y))) + [x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_int_remainder x y))) (defn pos? "Returns true if num is greater than zero, else false" { - :inline (fn [num] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (IsPos ~num))) + :inline (fn [num] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (isPos ~num))) :added "1.0"} - [num] (. github.com$glojurelang$glojure$pkg$lang.Numbers (IsPos num))) + [num] (. github.com$glojurelang$glojure$pkg$lang.Numbers (isPos num))) (defn neg? "Returns true if num is less than zero, else false" { - :inline (fn [num] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (IsNeg ~num))) + :inline (fn [num] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (isNeg ~num))) :added "1.0"} - [num] (. github.com$glojurelang$glojure$pkg$lang.Numbers (IsNeg num))) + [num] (. github.com$glojurelang$glojure$pkg$lang.Numbers (isNeg num))) (defn quot "quot[ient] of dividing numerator by denominator." {:added "1.0" :static true - :inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Quotient ~x ~y)))} + :inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (quotient ~x ~y)))} [num div] - (. github.com$glojurelang$glojure$pkg$lang.Numbers (Quotient num div))) + (. github.com$glojurelang$glojure$pkg$lang.Numbers (quotient num div))) (defn rem "remainder of dividing numerator by denominator." {:added "1.0" :static true - :inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Remainder ~x ~y)))} + :inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (remainder ~x ~y)))} [num div] - (. github.com$glojurelang$glojure$pkg$lang.Numbers (Remainder num div))) + (. github.com$glojurelang$glojure$pkg$lang.Numbers (remainder num div))) (defn rationalize "returns the rational value of num" {:added "1.0" :static true} [num] - (. github.com$glojurelang$glojure$pkg$lang.Numbers (Rationalize num))) + (. github.com$glojurelang$glojure$pkg$lang.Numbers (rationalize num))) ;;Bit ops (defn bit-not "Bitwise complement" - {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Not ~x))) + {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (not ~x))) :added "1.0"} - [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers Not x)) + [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers not x)) (defn bit-and @@ -1300,7 +1300,7 @@ {:inline (nary-inline 'and) :inline-arities >1? :added "1.0"} - ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers And x y)) + ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers and x y)) ([x y & more] (reduce1 bit-and (bit-and x y) more))) @@ -1309,7 +1309,7 @@ {:inline (nary-inline 'or) :inline-arities >1? :added "1.0"} - ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers Or x y)) + ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers or x y)) ([x y & more] (reduce1 bit-or (bit-or x y) more))) @@ -1318,7 +1318,7 @@ {:inline (nary-inline 'xor) :inline-arities >1? :added "1.0"} - ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers Xor x y)) + ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers xor x y)) ([x y & more] (reduce1 bit-xor (bit-xor x y) more))) @@ -1328,7 +1328,7 @@ :inline-arities >1? :added "1.0" :static true} - ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers AndNot x y)) + ([x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers andNot x y)) ([x y & more] (reduce1 bit-and-not (bit-and-not x y) more))) @@ -1337,44 +1337,44 @@ "Clear bit at index n" {:added "1.0" :static true} - [x n] (. github.com$glojurelang$glojure$pkg$lang.Numbers ClearBit x n)) + [x n] (. github.com$glojurelang$glojure$pkg$lang.Numbers clearBit x n)) (defn bit-set "Set bit at index n" {:added "1.0" :static true} - [x n] (. github.com$glojurelang$glojure$pkg$lang.Numbers SetBit x n)) + [x n] (. github.com$glojurelang$glojure$pkg$lang.Numbers setBit x n)) (defn bit-flip "Flip bit at index n" {:added "1.0" :static true} - [x n] (. github.com$glojurelang$glojure$pkg$lang.Numbers FlipBit x n)) + [x n] (. github.com$glojurelang$glojure$pkg$lang.Numbers flipBit x n)) (defn bit-test "Test bit at index n" {:added "1.0" :static true} - [x n] (. github.com$glojurelang$glojure$pkg$lang.Numbers TestBit x n)) + [x n] (. github.com$glojurelang$glojure$pkg$lang.Numbers testBit x n)) (defn bit-shift-left "Bitwise shift left" - {:inline (fn [x n] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (ShiftLeft ~x ~n))) + {:inline (fn [x n] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (shiftLeft ~x ~n))) :added "1.0"} - [x n] (. github.com$glojurelang$glojure$pkg$lang.Numbers ShiftLeft x n)) + [x n] (. github.com$glojurelang$glojure$pkg$lang.Numbers shiftLeft x n)) (defn bit-shift-right "Bitwise shift right" - {:inline (fn [x n] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (ShiftRight ~x ~n))) + {:inline (fn [x n] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (shiftRight ~x ~n))) :added "1.0"} - [x n] (. github.com$glojurelang$glojure$pkg$lang.Numbers ShiftRight x n)) + [x n] (. github.com$glojurelang$glojure$pkg$lang.Numbers shiftRight x n)) (defn unsigned-bit-shift-right "Bitwise shift right, without sign-extension." - {:inline (fn [x n] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (UnsignedShiftRight ~x ~n))) + {:inline (fn [x n] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (unsignedShiftRight ~x ~n))) :added "1.6"} - [x n] (. github.com$glojurelang$glojure$pkg$lang.Numbers UnsignedShiftRight x n)) + [x n] (. github.com$glojurelang$glojure$pkg$lang.Numbers unsignedShiftRight x n)) (defn integer? "Returns true if n is an integer" {:added "1.0", :static true} [n] (github.com$glojurelang$glojure$pkg$lang.IsInteger n)) @@ -3474,9 +3474,9 @@ (defn num "Coerce to Number" { - :inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (Num ~x))) + :inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (num ~x))) :added "1.0"} - [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (Num x))) + [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (num x))) (defn long "Coerce to long" @@ -4076,7 +4076,7 @@ {:added "1.0" :static true} [s key] - (. glojure.lang.PersistentStructMap (getAccessor s key))) + (github.com$glojurelang$glojure$pkg$lang.GetPersistentStructMapAccessor s key)) (defn load-reader "Sequentially read and evaluate the set of forms contained in the @@ -5300,51 +5300,51 @@ (defn float-array "Creates an array of floats" - {:inline (fn [& args] `(. github.com$glojurelang$glojure$pkg$lang.Numbers FloatArray (unquote-splicing args))) + {:inline (fn [& args] `(. github.com$glojurelang$glojure$pkg$lang.Numbers floatArray (unquote-splicing args))) :inline-arities #{1 2} :added "1.0"} - ([size-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers FloatArray size-or-seq)) - ([size init-val-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers FloatArrayInit size init-val-or-seq))) + ([size-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers floatArray size-or-seq)) + ([size init-val-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers floatArrayInit size init-val-or-seq))) (defn boolean-array "Creates an array of booleans" - {:inline (fn [& args] `(. github.com$glojurelang$glojure$pkg$lang.Numbers BooleanArray (unquote-splicing args))) + {:inline (fn [& args] `(. github.com$glojurelang$glojure$pkg$lang.Numbers booleanArray (unquote-splicing args))) :inline-arities #{1 2} :added "1.1"} - ([size-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers BooleanArray size-or-seq)) - ([size init-val-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers BooleanArrayInit size init-val-or-seq))) + ([size-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers booleanArray size-or-seq)) + ([size init-val-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers booleanArrayInit size init-val-or-seq))) (defn byte-array "Creates an array of bytes" - {:inline (fn [& args] `(. github.com$glojurelang$glojure$pkg$lang.Numbers ByteArray (unquote-splicing args))) + {:inline (fn [& args] `(. github.com$glojurelang$glojure$pkg$lang.Numbers byteArray (unquote-splicing args))) :inline-arities #{1 2} :added "1.1"} - ([size-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers ByteArray size-or-seq)) - ([size init-val-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers ByteArrayInit size init-val-or-seq))) + ([size-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers byteArray size-or-seq)) + ([size init-val-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers byteArrayInit size init-val-or-seq))) (defn char-array "Creates an array of chars" - {:inline (fn [& args] `(. github.com$glojurelang$glojure$pkg$lang.Numbers CharArray (unquote-splicing args))) + {:inline (fn [& args] `(. github.com$glojurelang$glojure$pkg$lang.Numbers charArray (unquote-splicing args))) :inline-arities #{1 2} :added "1.1"} - ([size-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers CharArray size-or-seq)) - ([size init-val-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers CharArrayInit size init-val-or-seq))) + ([size-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers charArray size-or-seq)) + ([size init-val-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers charArrayInit size init-val-or-seq))) (defn short-array "Creates an array of shorts" - {:inline (fn [& args] `(. github.com$glojurelang$glojure$pkg$lang.Numbers ShortArray (unquote-splicing args))) + {:inline (fn [& args] `(. github.com$glojurelang$glojure$pkg$lang.Numbers shortArray (unquote-splicing args))) :inline-arities #{1 2} :added "1.1"} - ([size-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers ShortArray size-or-seq)) - ([size init-val-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers ShortArrayInit size init-val-or-seq))) + ([size-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers shortArray size-or-seq)) + ([size init-val-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers shortArrayInit size init-val-or-seq))) (defn double-array "Creates an array of doubles" - {:inline (fn [& args] `(. github.com$glojurelang$glojure$pkg$lang.Numbers DoubleArray (unquote-splicing args))) + {:inline (fn [& args] `(. github.com$glojurelang$glojure$pkg$lang.Numbers doubleArray (unquote-splicing args))) :inline-arities #{1 2} :added "1.0"} - ([size-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers DoubleArray size-or-seq)) - ([size init-val-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers DoubleArrayInit size init-val-or-seq))) + ([size-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers doubleArray size-or-seq)) + ([size init-val-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers doubleArrayInit size init-val-or-seq))) (defn object-array "Creates an array of objects" @@ -5355,59 +5355,59 @@ (defn int-array "Creates an array of ints" - {:inline (fn [& args] `(. github.com$glojurelang$glojure$pkg$lang.Numbers IntArray (unquote-splicing args))) + {:inline (fn [& args] `(. github.com$glojurelang$glojure$pkg$lang.Numbers intArray (unquote-splicing args))) :inline-arities #{1 2} :added "1.0"} - ([size-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers IntArray size-or-seq)) - ([size init-val-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers IntArrayInit size init-val-or-seq))) + ([size-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers intArray size-or-seq)) + ([size init-val-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers intArrayInit size init-val-or-seq))) (defn long-array "Creates an array of longs" - {:inline (fn [& args] `(. github.com$glojurelang$glojure$pkg$lang.Numbers LongArray (unquote-splicing args))) + {:inline (fn [& args] `(. github.com$glojurelang$glojure$pkg$lang.Numbers longArray (unquote-splicing args))) :inline-arities #{1 2} :added "1.0"} - ([size-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers LongArray size-or-seq)) - ([size init-val-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers LongArrayInit size init-val-or-seq))) + ([size-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers longArray size-or-seq)) + ([size init-val-or-seq] (. github.com$glojurelang$glojure$pkg$lang.Numbers longArrayInit size init-val-or-seq))) (definline booleans "Casts to boolean[]" {:added "1.1"} - [xs] `(. github.com$glojurelang$glojure$pkg$lang.Numbers Booleans ~xs)) + [xs] `(. github.com$glojurelang$glojure$pkg$lang.Numbers booleans ~xs)) (definline bytes "Casts to bytes[]" {:added "1.1"} - [xs] `(. github.com$glojurelang$glojure$pkg$lang.Numbers Bytes ~xs)) + [xs] `(. github.com$glojurelang$glojure$pkg$lang.Numbers bytes ~xs)) (definline chars "Casts to chars[]" {:added "1.1"} - [xs] `(. github.com$glojurelang$glojure$pkg$lang.Numbers Chars ~xs)) + [xs] `(. github.com$glojurelang$glojure$pkg$lang.Numbers chars ~xs)) (definline shorts "Casts to shorts[]" {:added "1.1"} - [xs] `(. github.com$glojurelang$glojure$pkg$lang.Numbers Shorts ~xs)) + [xs] `(. github.com$glojurelang$glojure$pkg$lang.Numbers shorts ~xs)) (definline floats "Casts to float[]" {:added "1.0"} - [xs] `(. github.com$glojurelang$glojure$pkg$lang.Numbers Floats ~xs)) + [xs] `(. github.com$glojurelang$glojure$pkg$lang.Numbers floats ~xs)) (definline ints "Casts to int[]" {:added "1.0"} - [xs] `(. github.com$glojurelang$glojure$pkg$lang.Numbers Ints ~xs)) + [xs] `(. github.com$glojurelang$glojure$pkg$lang.Numbers ints ~xs)) (definline doubles "Casts to double[]" {:added "1.0"} - [xs] `(. github.com$glojurelang$glojure$pkg$lang.Numbers Doubles ~xs)) + [xs] `(. github.com$glojurelang$glojure$pkg$lang.Numbers doubles ~xs)) (definline longs "Casts to long[]" {:added "1.0"} - [xs] `(. github.com$glojurelang$glojure$pkg$lang.Numbers Longs ~xs)) + [xs] `(. github.com$glojurelang$glojure$pkg$lang.Numbers longs ~xs)) (defn bytes? "Return true if x is a byte array" diff --git a/pkg/stdlib/glojure/core/async/loader.go b/pkg/stdlib/glojure/core/async/loader.go index ac75f31e..3de5173b 100644 --- a/pkg/stdlib/glojure/core/async/loader.go +++ b/pkg/stdlib/glojure/core/async/loader.go @@ -393,9 +393,38 @@ func LoadNS() { var tmp2 any { // let // let binding "def" - var v3 any = "unimplemented: new with non-constant class type" - _ = v3 - tmp2 = v3 + tmp3 := new(reflect.SelectCase) + var v4 any = tmp3 + _ = v4 + // set! host field + var tmp5 any + { + targetV := reflect.ValueOf(v4) + if targetV.Kind() == reflect.Ptr { + targetV = targetV.Elem() + } + fieldVal := targetV.FieldByName("Dir") + if !fieldVal.IsValid() { + panic(fmt.Errorf("no such field Dir")) + } + if !fieldVal.CanSet() { + panic(fmt.Errorf("cannot set field Dir")) + } + valV := reflect.ValueOf(reflect.SelectDefault) + if !valV.IsValid() { + switch fieldVal.Kind() { + case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Pointer, reflect.Slice, reflect.UnsafePointer: + fieldVal.Set(reflect.Zero(fieldVal.Type())) + default: + panic(fmt.Errorf("cannot set field Dir to nil")) + } + } else { + fieldVal.Set(valV) + } + tmp5 = reflect.SelectDefault + } + _ = tmp5 + tmp2 = v4 } // end let return tmp2 }) @@ -1806,14 +1835,106 @@ func LoadNS() { var v14 any = tmp11 _ = v14 // let binding "select-case" - var v15 any = "unimplemented: new with non-constant class type" - _ = v15 - var tmp16 any + tmp15 := new(reflect.SelectCase) + var v16 any = tmp15 + _ = v16 + tmp17 := lang.Apply(reflect.ValueOf, []any{v10}) + // set! host field + var tmp18 any + { + targetV := reflect.ValueOf(v16) + if targetV.Kind() == reflect.Ptr { + targetV = targetV.Elem() + } + fieldVal := targetV.FieldByName("Chan") + if !fieldVal.IsValid() { + panic(fmt.Errorf("no such field Chan")) + } + if !fieldVal.CanSet() { + panic(fmt.Errorf("cannot set field Chan")) + } + valV := reflect.ValueOf(tmp17) + if !valV.IsValid() { + switch fieldVal.Kind() { + case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Pointer, reflect.Slice, reflect.UnsafePointer: + fieldVal.Set(reflect.Zero(fieldVal.Type())) + default: + panic(fmt.Errorf("cannot set field Chan to nil")) + } + } else { + fieldVal.Set(valV) + } + tmp18 = tmp17 + } + _ = tmp18 + var tmp19 any + if lang.IsTruthy(v8) { + tmp19 = reflect.SelectSend + } else { + tmp19 = reflect.SelectRecv + } + // set! host field + var tmp20 any + { + targetV := reflect.ValueOf(v16) + if targetV.Kind() == reflect.Ptr { + targetV = targetV.Elem() + } + fieldVal := targetV.FieldByName("Dir") + if !fieldVal.IsValid() { + panic(fmt.Errorf("no such field Dir")) + } + if !fieldVal.CanSet() { + panic(fmt.Errorf("cannot set field Dir")) + } + valV := reflect.ValueOf(tmp19) + if !valV.IsValid() { + switch fieldVal.Kind() { + case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Pointer, reflect.Slice, reflect.UnsafePointer: + fieldVal.Set(reflect.Zero(fieldVal.Type())) + default: + panic(fmt.Errorf("cannot set field Dir to nil")) + } + } else { + fieldVal.Set(valV) + } + tmp20 = tmp19 + } + _ = tmp20 + var tmp21 any if lang.IsTruthy(v8) { + // set! host field + var tmp22 any + { + targetV := reflect.ValueOf(v16) + if targetV.Kind() == reflect.Ptr { + targetV = targetV.Elem() + } + fieldVal := targetV.FieldByName("Send") + if !fieldVal.IsValid() { + panic(fmt.Errorf("no such field Send")) + } + if !fieldVal.CanSet() { + panic(fmt.Errorf("cannot set field Send")) + } + valV := reflect.ValueOf(v14) + if !valV.IsValid() { + switch fieldVal.Kind() { + case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Pointer, reflect.Slice, reflect.UnsafePointer: + fieldVal.Set(reflect.Zero(fieldVal.Type())) + default: + panic(fmt.Errorf("cannot set field Send to nil")) + } + } else { + fieldVal.Set(valV) + } + tmp22 = v14 + } + tmp21 = tmp22 } else { } - _ = tmp16 - tmp3 = v15 + _ = tmp21 + tmp3 = v16 } // end let return tmp3 }) @@ -1967,86 +2088,171 @@ func LoadNS() { var tmp3 any { // let // let binding "sc" - var v4 any = "unimplemented: new with non-constant class type" - _ = v4 - // let binding "_" - var v5 any = nil + tmp4 := new(reflect.SelectCase) + var v5 any = tmp4 _ = v5 + // let binding "_" + // set! host field + var tmp6 any + { + targetV := reflect.ValueOf(v5) + if targetV.Kind() == reflect.Ptr { + targetV = targetV.Elem() + } + fieldVal := targetV.FieldByName("Dir") + if !fieldVal.IsValid() { + panic(fmt.Errorf("no such field Dir")) + } + if !fieldVal.CanSet() { + panic(fmt.Errorf("cannot set field Dir")) + } + valV := reflect.ValueOf(reflect.SelectRecv) + if !valV.IsValid() { + switch fieldVal.Kind() { + case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Pointer, reflect.Slice, reflect.UnsafePointer: + fieldVal.Set(reflect.Zero(fieldVal.Type())) + default: + panic(fmt.Errorf("cannot set field Dir to nil")) + } + } else { + fieldVal.Set(valV) + } + tmp6 = reflect.SelectRecv + } + _ = tmp6 + tmp7 := lang.Apply(reflect.ValueOf, []any{v2}) + // set! host field + var tmp8 any + { + targetV := reflect.ValueOf(v5) + if targetV.Kind() == reflect.Ptr { + targetV = targetV.Elem() + } + fieldVal := targetV.FieldByName("Chan") + if !fieldVal.IsValid() { + panic(fmt.Errorf("no such field Chan")) + } + if !fieldVal.CanSet() { + panic(fmt.Errorf("cannot set field Chan")) + } + valV := reflect.ValueOf(tmp7) + if !valV.IsValid() { + switch fieldVal.Kind() { + case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Pointer, reflect.Slice, reflect.UnsafePointer: + fieldVal.Set(reflect.Zero(fieldVal.Type())) + default: + panic(fmt.Errorf("cannot set field Chan to nil")) + } + } else { + fieldVal.Set(valV) + } + tmp8 = tmp7 + } + var v9 any = tmp8 + _ = v9 // let binding "def" - var v6 any = "unimplemented: new with non-constant class type" - _ = v6 + tmp10 := new(reflect.SelectCase) + var v11 any = tmp10 + _ = v11 // let binding "_" - var v7 any = nil - _ = v7 + // set! host field + var tmp12 any + { + targetV := reflect.ValueOf(v11) + if targetV.Kind() == reflect.Ptr { + targetV = targetV.Elem() + } + fieldVal := targetV.FieldByName("Dir") + if !fieldVal.IsValid() { + panic(fmt.Errorf("no such field Dir")) + } + if !fieldVal.CanSet() { + panic(fmt.Errorf("cannot set field Dir")) + } + valV := reflect.ValueOf(reflect.SelectDefault) + if !valV.IsValid() { + switch fieldVal.Kind() { + case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Pointer, reflect.Slice, reflect.UnsafePointer: + fieldVal.Set(reflect.Zero(fieldVal.Type())) + default: + panic(fmt.Errorf("cannot set field Dir to nil")) + } + } else { + fieldVal.Set(valV) + } + tmp12 = reflect.SelectDefault + } + var v13 any = tmp12 + _ = v13 // let binding "vec__1024" - tmp8 := checkDerefVar(var_glojure_DOT_core_map) - tmp9 := lang.NewVector(v4, v6) - tmp10 := lang.NewMap(kw_file, "glojure/core/async.glj", kw_line, int(138), kw_column, int(55), kw_end_DASH_line, int(138), kw_end_DASH_column, int(62)) - tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + tmp14 := checkDerefVar(var_glojure_DOT_core_map) + tmp15 := lang.NewVector(v5, v11) + tmp16 := lang.NewMap(kw_file, "glojure/core/async.glj", kw_line, int(138), kw_column, int(55), kw_end_DASH_line, int(138), kw_end_DASH_column, int(62)) + tmp17, err := lang.WithMeta(tmp15, tmp16.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp12 := lang.Apply(tmp8, []any{lang.Builtins["deref"], tmp11}) - tmp13 := lang.Apply(reflect.Select, []any{tmp12}) - var v14 any = tmp13 - _ = v14 - // let binding "chosen" - tmp15 := checkDerefVar(var_glojure_DOT_core_nth) - tmp16 := lang.Apply(tmp15, []any{v14, int64(0), nil}) - var v17 any = tmp16 - _ = v17 - // let binding "val" - tmp18 := checkDerefVar(var_glojure_DOT_core_nth) - tmp19 := lang.Apply(tmp18, []any{v14, int64(1), nil}) + tmp18 := lang.Apply(tmp14, []any{lang.Builtins["deref"], tmp17}) + tmp19 := lang.Apply(reflect.Select, []any{tmp18}) var v20 any = tmp19 _ = v20 - // let binding "ok" + // let binding "chosen" tmp21 := checkDerefVar(var_glojure_DOT_core_nth) - tmp22 := lang.Apply(tmp21, []any{v14, int64(2), nil}) + tmp22 := lang.Apply(tmp21, []any{v20, int64(0), nil}) var v23 any = tmp22 _ = v23 - var tmp24 any - tmp25 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp26 := lang.Apply(tmp25, []any{int64(1), v17}) - if lang.IsTruthy(tmp26) { + // let binding "val" + tmp24 := checkDerefVar(var_glojure_DOT_core_nth) + tmp25 := lang.Apply(tmp24, []any{v20, int64(1), nil}) + var v26 any = tmp25 + _ = v26 + // let binding "ok" + tmp27 := checkDerefVar(var_glojure_DOT_core_nth) + tmp28 := lang.Apply(tmp27, []any{v20, int64(2), nil}) + var v29 any = tmp28 + _ = v29 + var tmp30 any + tmp31 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp32 := lang.Apply(tmp31, []any{int64(1), v23}) + if lang.IsTruthy(tmp32) { } else { - var tmp27 any - if lang.IsTruthy(v23) { - tmp28, ok := lang.FieldOrMethod(v20, "Interface") + var tmp33 any + if lang.IsTruthy(v29) { + tmp34, ok := lang.FieldOrMethod(v26, "Interface") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v20, "Interface"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v26, "Interface"))) } - var tmp29 any - switch reflect.TypeOf(tmp28).Kind() { + var tmp35 any + switch reflect.TypeOf(tmp34).Kind() { case reflect.Func: - tmp29 = lang.Apply(tmp28, nil) + tmp35 = lang.Apply(tmp34, nil) default: - tmp29 = tmp28 + tmp35 = tmp34 } - tmp30 := lang.NewVector(tmp29, true) - tmp31 := lang.NewMap(kw_file, "glojure/core/async.glj", kw_line, int(140), kw_column, int(14), kw_end_DASH_line, int(140), kw_end_DASH_column, int(36)) - tmp32, err := lang.WithMeta(tmp30, tmp31.(lang.IPersistentMap)) + tmp36 := lang.NewVector(tmp35, true) + tmp37 := lang.NewMap(kw_file, "glojure/core/async.glj", kw_line, int(140), kw_column, int(14), kw_end_DASH_line, int(140), kw_end_DASH_column, int(36)) + tmp38, err := lang.WithMeta(tmp36, tmp37.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp27 = tmp32 + tmp33 = tmp38 } else { - var tmp33 any + var tmp39 any if lang.IsTruthy(kw_else) { - tmp34 := lang.NewVector(nil, false) - tmp35 := lang.NewMap(kw_file, "glojure/core/async.glj", kw_line, int(141), kw_column, int(17), kw_end_DASH_line, int(141), kw_end_DASH_column, int(27)) - tmp36, err := lang.WithMeta(tmp34, tmp35.(lang.IPersistentMap)) + tmp40 := lang.NewVector(nil, false) + tmp41 := lang.NewMap(kw_file, "glojure/core/async.glj", kw_line, int(141), kw_column, int(17), kw_end_DASH_line, int(141), kw_end_DASH_column, int(27)) + tmp42, err := lang.WithMeta(tmp40, tmp41.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp33 = tmp36 + tmp39 = tmp42 } else { } - tmp27 = tmp33 + tmp33 = tmp39 } - tmp24 = tmp27 + tmp30 = tmp33 } - tmp3 = tmp24 + tmp3 = tmp30 } // end let return tmp3 }) diff --git a/pkg/stdlib/glojure/core/loader.go b/pkg/stdlib/glojure/core/loader.go index b5ac737a..94b2ad58 100644 --- a/pkg/stdlib/glojure/core/loader.go +++ b/pkg/stdlib/glojure/core/loader.go @@ -489,68 +489,22 @@ func LoadNS() { sym_glojure_DOT_core_SLASH_Array := lang.NewSymbol("glojure.core/Array") sym_glojure_DOT_core_SLASH_Aset := lang.NewSymbol("glojure.core/Aset") sym_glojure_DOT_core_SLASH_AssertionError := lang.NewSymbol("glojure.core/AssertionError") - sym_glojure_DOT_core_SLASH_BooleanArray := lang.NewSymbol("glojure.core/BooleanArray") sym_glojure_DOT_core_SLASH_BooleanCast := lang.NewSymbol("glojure.core/BooleanCast") - sym_glojure_DOT_core_SLASH_Booleans := lang.NewSymbol("glojure.core/Booleans") - sym_glojure_DOT_core_SLASH_ByteArray := lang.NewSymbol("glojure.core/ByteArray") - sym_glojure_DOT_core_SLASH_Bytes := lang.NewSymbol("glojure.core/Bytes") - sym_glojure_DOT_core_SLASH_CharArray := lang.NewSymbol("glojure.core/CharArray") - sym_glojure_DOT_core_SLASH_Chars := lang.NewSymbol("glojure.core/Chars") sym_glojure_DOT_core_SLASH_Count := lang.NewSymbol("glojure.core/Count") - sym_glojure_DOT_core_SLASH_DecP := lang.NewSymbol("glojure.core/DecP") - sym_glojure_DOT_core_SLASH_DoubleArray := lang.NewSymbol("glojure.core/DoubleArray") sym_glojure_DOT_core_SLASH_DoubleCast := lang.NewSymbol("glojure.core/DoubleCast") - sym_glojure_DOT_core_SLASH_Doubles := lang.NewSymbol("glojure.core/Doubles") - sym_glojure_DOT_core_SLASH_Equiv := lang.NewSymbol("glojure.core/Equiv") - sym_glojure_DOT_core_SLASH_FloatArray := lang.NewSymbol("glojure.core/FloatArray") - sym_glojure_DOT_core_SLASH_Floats := lang.NewSymbol("glojure.core/Floats") sym_glojure_DOT_core_SLASH_Get := lang.NewSymbol("glojure.core/Get") - sym_glojure_DOT_core_SLASH_Gt := lang.NewSymbol("glojure.core/Gt") - sym_glojure_DOT_core_SLASH_Gte := lang.NewSymbol("glojure.core/Gte") sym_glojure_DOT_core_SLASH_IllegalStateException := lang.NewSymbol("glojure.core/IllegalStateException") - sym_glojure_DOT_core_SLASH_IncP := lang.NewSymbol("glojure.core/IncP") - sym_glojure_DOT_core_SLASH_IntArray := lang.NewSymbol("glojure.core/IntArray") - sym_glojure_DOT_core_SLASH_Ints := lang.NewSymbol("glojure.core/Ints") - sym_glojure_DOT_core_SLASH_IsNeg := lang.NewSymbol("glojure.core/IsNeg") - sym_glojure_DOT_core_SLASH_IsPos := lang.NewSymbol("glojure.core/IsPos") - sym_glojure_DOT_core_SLASH_IsZero := lang.NewSymbol("glojure.core/IsZero") - sym_glojure_DOT_core_SLASH_LongArray := lang.NewSymbol("glojure.core/LongArray") sym_glojure_DOT_core_SLASH_LongCast := lang.NewSymbol("glojure.core/LongCast") - sym_glojure_DOT_core_SLASH_Longs := lang.NewSymbol("glojure.core/Longs") - sym_glojure_DOT_core_SLASH_Lt := lang.NewSymbol("glojure.core/Lt") - sym_glojure_DOT_core_SLASH_Lte := lang.NewSymbol("glojure.core/Lte") - sym_glojure_DOT_core_SLASH_Not := lang.NewSymbol("glojure.core/Not") sym_glojure_DOT_core_SLASH_Nth := lang.NewSymbol("glojure.core/Nth") - sym_glojure_DOT_core_SLASH_Num := lang.NewSymbol("glojure.core/Num") sym_glojure_DOT_core_SLASH_Object_array := lang.NewSymbol("glojure.core/Object_array") - sym_glojure_DOT_core_SLASH_Quotient := lang.NewSymbol("glojure.core/Quotient") - sym_glojure_DOT_core_SLASH_Remainder := lang.NewSymbol("glojure.core/Remainder") sym_glojure_DOT_core_SLASH_RunInTransaction := lang.NewSymbol("glojure.core/RunInTransaction") - sym_glojure_DOT_core_SLASH_ShiftLeft := lang.NewSymbol("glojure.core/ShiftLeft") - sym_glojure_DOT_core_SLASH_ShiftRight := lang.NewSymbol("glojure.core/ShiftRight") - sym_glojure_DOT_core_SLASH_ShortArray := lang.NewSymbol("glojure.core/ShortArray") - sym_glojure_DOT_core_SLASH_Shorts := lang.NewSymbol("glojure.core/Shorts") - sym_glojure_DOT_core_SLASH_UncheckedAdd := lang.NewSymbol("glojure.core/UncheckedAdd") sym_glojure_DOT_core_SLASH_UncheckedByteCast := lang.NewSymbol("glojure.core/UncheckedByteCast") sym_glojure_DOT_core_SLASH_UncheckedCharCast := lang.NewSymbol("glojure.core/UncheckedCharCast") - sym_glojure_DOT_core_SLASH_UncheckedDec := lang.NewSymbol("glojure.core/UncheckedDec") sym_glojure_DOT_core_SLASH_UncheckedDoubleCast := lang.NewSymbol("glojure.core/UncheckedDoubleCast") sym_glojure_DOT_core_SLASH_UncheckedFloatCast := lang.NewSymbol("glojure.core/UncheckedFloatCast") sym_glojure_DOT_core_SLASH_UncheckedIntCast := lang.NewSymbol("glojure.core/UncheckedIntCast") - sym_glojure_DOT_core_SLASH_UncheckedIntDivide := lang.NewSymbol("glojure.core/UncheckedIntDivide") sym_glojure_DOT_core_SLASH_UncheckedLongCast := lang.NewSymbol("glojure.core/UncheckedLongCast") sym_glojure_DOT_core_SLASH_UncheckedShortCast := lang.NewSymbol("glojure.core/UncheckedShortCast") - sym_glojure_DOT_core_SLASH_Unchecked_inc := lang.NewSymbol("glojure.core/Unchecked_inc") - sym_glojure_DOT_core_SLASH_Unchecked_int_add := lang.NewSymbol("glojure.core/Unchecked_int_add") - sym_glojure_DOT_core_SLASH_Unchecked_int_dec := lang.NewSymbol("glojure.core/Unchecked_int_dec") - sym_glojure_DOT_core_SLASH_Unchecked_int_inc := lang.NewSymbol("glojure.core/Unchecked_int_inc") - sym_glojure_DOT_core_SLASH_Unchecked_int_multiply := lang.NewSymbol("glojure.core/Unchecked_int_multiply") - sym_glojure_DOT_core_SLASH_Unchecked_int_negate := lang.NewSymbol("glojure.core/Unchecked_int_negate") - sym_glojure_DOT_core_SLASH_Unchecked_int_remainder := lang.NewSymbol("glojure.core/Unchecked_int_remainder") - sym_glojure_DOT_core_SLASH_Unchecked_int_subtract := lang.NewSymbol("glojure.core/Unchecked_int_subtract") - sym_glojure_DOT_core_SLASH_Unchecked_minus := lang.NewSymbol("glojure.core/Unchecked_minus") - sym_glojure_DOT_core_SLASH_Unchecked_multiply := lang.NewSymbol("glojure.core/Unchecked_multiply") - sym_glojure_DOT_core_SLASH_UnsignedShiftRight := lang.NewSymbol("glojure.core/UnsignedShiftRight") sym_glojure_DOT_core_SLASH_aclone := lang.NewSymbol("glojure.core/aclone") sym_glojure_DOT_core_SLASH_aget := lang.NewSymbol("glojure.core/aget") sym_glojure_DOT_core_SLASH_alength := lang.NewSymbol("glojure.core/alength") @@ -565,8 +519,14 @@ func LoadNS() { sym_glojure_DOT_core_SLASH_assoc_DASH_in := lang.NewSymbol("glojure.core/assoc-in") sym_glojure_DOT_core_SLASH_atom := lang.NewSymbol("glojure.core/atom") sym_glojure_DOT_core_SLASH_binding := lang.NewSymbol("glojure.core/binding") + sym_glojure_DOT_core_SLASH_booleanArray := lang.NewSymbol("glojure.core/booleanArray") + sym_glojure_DOT_core_SLASH_booleans := lang.NewSymbol("glojure.core/booleans") sym_glojure_DOT_core_SLASH_bound_DASH_fn_STAR_ := lang.NewSymbol("glojure.core/bound-fn*") + sym_glojure_DOT_core_SLASH_byteArray := lang.NewSymbol("glojure.core/byteArray") + sym_glojure_DOT_core_SLASH_bytes := lang.NewSymbol("glojure.core/bytes") sym_glojure_DOT_core_SLASH_c := lang.NewSymbol("glojure.core/c") + sym_glojure_DOT_core_SLASH_charArray := lang.NewSymbol("glojure.core/charArray") + sym_glojure_DOT_core_SLASH_chars := lang.NewSymbol("glojure.core/chars") sym_glojure_DOT_core_SLASH_chunk := lang.NewSymbol("glojure.core/chunk") sym_glojure_DOT_core_SLASH_chunk_DASH_append := lang.NewSymbol("glojure.core/chunk-append") sym_glojure_DOT_core_SLASH_chunk_DASH_buffer := lang.NewSymbol("glojure.core/chunk-buffer") @@ -584,19 +544,26 @@ func LoadNS() { sym_glojure_DOT_core_SLASH_cons := lang.NewSymbol("glojure.core/cons") sym_glojure_DOT_core_SLASH_count := lang.NewSymbol("glojure.core/count") sym_glojure_DOT_core_SLASH_create_DASH_struct := lang.NewSymbol("glojure.core/create-struct") + sym_glojure_DOT_core_SLASH_decP := lang.NewSymbol("glojure.core/decP") sym_glojure_DOT_core_SLASH_defmulti := lang.NewSymbol("glojure.core/defmulti") sym_glojure_DOT_core_SLASH_defn := lang.NewSymbol("glojure.core/defn") sym_glojure_DOT_core_SLASH_deref := lang.NewSymbol("glojure.core/deref") sym_glojure_DOT_core_SLASH_dosync := lang.NewSymbol("glojure.core/dosync") sym_glojure_DOT_core_SLASH_double := lang.NewSymbol("glojure.core/double") + sym_glojure_DOT_core_SLASH_doubleArray := lang.NewSymbol("glojure.core/doubleArray") + sym_glojure_DOT_core_SLASH_doubles := lang.NewSymbol("glojure.core/doubles") sym_glojure_DOT_core_SLASH_equiv := lang.NewSymbol("glojure.core/equiv") sym_glojure_DOT_core_SLASH_extend := lang.NewSymbol("glojure.core/extend") sym_glojure_DOT_core_SLASH_extend_DASH_type := lang.NewSymbol("glojure.core/extend-type") sym_glojure_DOT_core_SLASH_first := lang.NewSymbol("glojure.core/first") + sym_glojure_DOT_core_SLASH_floatArray := lang.NewSymbol("glojure.core/floatArray") + sym_glojure_DOT_core_SLASH_floats := lang.NewSymbol("glojure.core/floats") sym_glojure_DOT_core_SLASH_fn := lang.NewSymbol("glojure.core/fn") sym_glojure_DOT_core_SLASH_future_DASH_call := lang.NewSymbol("glojure.core/future-call") sym_glojure_DOT_core_SLASH_gen_DASH_class := lang.NewSymbol("glojure.core/gen-class") sym_glojure_DOT_core_SLASH_get := lang.NewSymbol("glojure.core/get") + sym_glojure_DOT_core_SLASH_gt := lang.NewSymbol("glojure.core/gt") + sym_glojure_DOT_core_SLASH_gte := lang.NewSymbol("glojure.core/gte") sym_glojure_DOT_core_SLASH_hash_DASH_map := lang.NewSymbol("glojure.core/hash-map") sym_glojure_DOT_core_SLASH_i := lang.NewSymbol("glojure.core/i") sym_glojure_DOT_core_SLASH_identical := lang.NewSymbol("glojure.core/identical") @@ -604,13 +571,23 @@ func LoadNS() { sym_glojure_DOT_core_SLASH_if_DASH_not := lang.NewSymbol("glojure.core/if-not") sym_glojure_DOT_core_SLASH_if_DASH_some := lang.NewSymbol("glojure.core/if-some") sym_glojure_DOT_core_SLASH_in_DASH_ns := lang.NewSymbol("glojure.core/in-ns") + sym_glojure_DOT_core_SLASH_incP := lang.NewSymbol("glojure.core/incP") sym_glojure_DOT_core_SLASH_instance_QMARK_ := lang.NewSymbol("glojure.core/instance?") sym_glojure_DOT_core_SLASH_int := lang.NewSymbol("glojure.core/int") + sym_glojure_DOT_core_SLASH_intArray := lang.NewSymbol("glojure.core/intArray") + sym_glojure_DOT_core_SLASH_ints := lang.NewSymbol("glojure.core/ints") + sym_glojure_DOT_core_SLASH_isNeg := lang.NewSymbol("glojure.core/isNeg") + sym_glojure_DOT_core_SLASH_isPos := lang.NewSymbol("glojure.core/isPos") + sym_glojure_DOT_core_SLASH_isZero := lang.NewSymbol("glojure.core/isZero") sym_glojure_DOT_core_SLASH_keyword := lang.NewSymbol("glojure.core/keyword") sym_glojure_DOT_core_SLASH_lazy_DASH_seq := lang.NewSymbol("glojure.core/lazy-seq") sym_glojure_DOT_core_SLASH_let := lang.NewSymbol("glojure.core/let") sym_glojure_DOT_core_SLASH_long := lang.NewSymbol("glojure.core/long") + sym_glojure_DOT_core_SLASH_longArray := lang.NewSymbol("glojure.core/longArray") + sym_glojure_DOT_core_SLASH_longs := lang.NewSymbol("glojure.core/longs") sym_glojure_DOT_core_SLASH_loop := lang.NewSymbol("glojure.core/loop") + sym_glojure_DOT_core_SLASH_lt := lang.NewSymbol("glojure.core/lt") + sym_glojure_DOT_core_SLASH_lte := lang.NewSymbol("glojure.core/lte") sym_glojure_DOT_core_SLASH_merge := lang.NewSymbol("glojure.core/merge") sym_glojure_DOT_core_SLASH_meta := lang.NewSymbol("glojure.core/meta") sym_glojure_DOT_core_SLASH_next := lang.NewSymbol("glojure.core/next") @@ -618,24 +595,45 @@ func LoadNS() { sym_glojure_DOT_core_SLASH_nil_QMARK_ := lang.NewSymbol("glojure.core/nil?") sym_glojure_DOT_core_SLASH_not := lang.NewSymbol("glojure.core/not") sym_glojure_DOT_core_SLASH_nth := lang.NewSymbol("glojure.core/nth") + sym_glojure_DOT_core_SLASH_num := lang.NewSymbol("glojure.core/num") sym_glojure_DOT_core_SLASH_or := lang.NewSymbol("glojure.core/or") sym_glojure_DOT_core_SLASH_pcalls := lang.NewSymbol("glojure.core/pcalls") sym_glojure_DOT_core_SLASH_pop_DASH_thread_DASH_bindings := lang.NewSymbol("glojure.core/pop-thread-bindings") sym_glojure_DOT_core_SLASH_pr_DASH_str := lang.NewSymbol("glojure.core/pr-str") sym_glojure_DOT_core_SLASH_prn := lang.NewSymbol("glojure.core/prn") sym_glojure_DOT_core_SLASH_push_DASH_thread_DASH_bindings := lang.NewSymbol("glojure.core/push-thread-bindings") + sym_glojure_DOT_core_SLASH_quotient := lang.NewSymbol("glojure.core/quotient") sym_glojure_DOT_core_SLASH_refer := lang.NewSymbol("glojure.core/refer") + sym_glojure_DOT_core_SLASH_remainder := lang.NewSymbol("glojure.core/remainder") sym_glojure_DOT_core_SLASH_rest := lang.NewSymbol("glojure.core/rest") sym_glojure_DOT_core_SLASH_seq := lang.NewSymbol("glojure.core/seq") sym_glojure_DOT_core_SLASH_seq_QMARK_ := lang.NewSymbol("glojure.core/seq?") + sym_glojure_DOT_core_SLASH_shiftLeft := lang.NewSymbol("glojure.core/shiftLeft") + sym_glojure_DOT_core_SLASH_shiftRight := lang.NewSymbol("glojure.core/shiftRight") + sym_glojure_DOT_core_SLASH_shortArray := lang.NewSymbol("glojure.core/shortArray") + sym_glojure_DOT_core_SLASH_shorts := lang.NewSymbol("glojure.core/shorts") sym_glojure_DOT_core_SLASH_str := lang.NewSymbol("glojure.core/str") sym_glojure_DOT_core_SLASH_swap_BANG_ := lang.NewSymbol("glojure.core/swap!") sym_glojure_DOT_core_SLASH_sync := lang.NewSymbol("glojure.core/sync") sym_glojure_DOT_core_SLASH_to_DASH_array := lang.NewSymbol("glojure.core/to-array") sym_glojure_DOT_core_SLASH_unchecked_DASH_inc := lang.NewSymbol("glojure.core/unchecked-inc") sym_glojure_DOT_core_SLASH_unchecked_DASH_inc_DASH_int := lang.NewSymbol("glojure.core/unchecked-inc-int") + sym_glojure_DOT_core_SLASH_unchecked_add := lang.NewSymbol("glojure.core/unchecked_add") + sym_glojure_DOT_core_SLASH_unchecked_dec := lang.NewSymbol("glojure.core/unchecked_dec") + sym_glojure_DOT_core_SLASH_unchecked_inc := lang.NewSymbol("glojure.core/unchecked_inc") + sym_glojure_DOT_core_SLASH_unchecked_int_add := lang.NewSymbol("glojure.core/unchecked_int_add") + sym_glojure_DOT_core_SLASH_unchecked_int_dec := lang.NewSymbol("glojure.core/unchecked_int_dec") + sym_glojure_DOT_core_SLASH_unchecked_int_divide := lang.NewSymbol("glojure.core/unchecked_int_divide") + sym_glojure_DOT_core_SLASH_unchecked_int_inc := lang.NewSymbol("glojure.core/unchecked_int_inc") + sym_glojure_DOT_core_SLASH_unchecked_int_multiply := lang.NewSymbol("glojure.core/unchecked_int_multiply") + sym_glojure_DOT_core_SLASH_unchecked_int_negate := lang.NewSymbol("glojure.core/unchecked_int_negate") + sym_glojure_DOT_core_SLASH_unchecked_int_remainder := lang.NewSymbol("glojure.core/unchecked_int_remainder") + sym_glojure_DOT_core_SLASH_unchecked_int_subtract := lang.NewSymbol("glojure.core/unchecked_int_subtract") + sym_glojure_DOT_core_SLASH_unchecked_minus := lang.NewSymbol("glojure.core/unchecked_minus") + sym_glojure_DOT_core_SLASH_unchecked_multiply := lang.NewSymbol("glojure.core/unchecked_multiply") sym_glojure_DOT_core_SLASH_unquote := lang.NewSymbol("glojure.core/unquote") sym_glojure_DOT_core_SLASH_unquote_DASH_splicing := lang.NewSymbol("glojure.core/unquote-splicing") + sym_glojure_DOT_core_SLASH_unsignedShiftRight := lang.NewSymbol("glojure.core/unsignedShiftRight") sym_glojure_DOT_core_SLASH_when := lang.NewSymbol("glojure.core/when") sym_glojure_DOT_core_SLASH_when_DASH_first := lang.NewSymbol("glojure.core/when-first") sym_glojure_DOT_core_SLASH_when_DASH_let := lang.NewSymbol("glojure.core/when-let") @@ -2977,7 +2975,7 @@ func LoadNS() { if reflect.TypeOf(tmp3).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp4 := lang.Apply(tmp3, []any{nil, int64(0)}) + tmp4 := lang.Apply(tmp3, []any{v2, int64(0)}) return tmp4 }) tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -2998,7 +2996,7 @@ func LoadNS() { if reflect.TypeOf(tmp3).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp4 := lang.Apply(tmp3, []any{nil, int64(1)}) + tmp4 := lang.Apply(tmp3, []any{v2, int64(1)}) return tmp4 }) tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -3268,12 +3266,8 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - tmp4, _ := lang.FieldOrMethod(nil, "getAccessor") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("getAccessor is not a function"))) - } - tmp5 := lang.Apply(tmp4, []any{v2, v3}) - return tmp5 + tmp4 := lang.Apply(lang.GetPersistentStructMapAccessor, []any{v2, v3}) + return tmp4 }) tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) var_glojure_DOT_core_accessor = ns.InternWithValue(tmp0, tmp1, true) @@ -3460,9 +3454,9 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "ClearBit") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "clearBit") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ClearBit is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("clearBit is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v2, v3}) return tmp5 @@ -3483,9 +3477,9 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "FlipBit") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "flipBit") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("FlipBit is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("flipBit is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v2, v3}) return tmp5 @@ -3506,9 +3500,9 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "SetBit") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "setBit") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("SetBit is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setBit is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v2, v3}) return tmp5 @@ -3529,9 +3523,9 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "TestBit") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "testBit") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("TestBit is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("testBit is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v2, v3}) return tmp5 @@ -5692,9 +5686,9 @@ func LoadNS() { checkArity(args, 1) v2 := args[0] _ = v2 - tmp3, _ := lang.FieldOrMethod(lang.Numbers, "Rationalize") + tmp3, _ := lang.FieldOrMethod(lang.Numbers, "rationalize") if reflect.TypeOf(tmp3).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Rationalize is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("rationalize is not a function"))) } tmp4 := lang.Apply(tmp3, []any{v2}) return tmp4 @@ -6381,7 +6375,7 @@ func LoadNS() { checkArity(args, 1) v2 := args[0] _ = v2 - return nil + return "unimplemented: set! target type" }) tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) var_glojure_DOT_core_set_DASH_agent_DASH_send_DASH_executor_BANG_ = ns.InternWithValue(tmp0, tmp1, true) @@ -6397,7 +6391,7 @@ func LoadNS() { checkArity(args, 1) v2 := args[0] _ = v2 - return nil + return "unimplemented: set! target type" }) tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) var_glojure_DOT_core_set_DASH_agent_DASH_send_DASH_off_DASH_executor_BANG_ = ns.InternWithValue(tmp0, tmp1, true) @@ -6884,10 +6878,11 @@ func LoadNS() { if err != nil { panic(err) } - tmp8 := checkDerefVar(var_glojure_DOT_core_cons) - tmp9 := lang.Apply(tmp8, []any{v3, v4}) - tmp10 := lang.Apply(tmp7, []any{"unimplemented: new with non-constant class type", tmp9}) - return tmp10 + tmp8 := new(strings8.Builder) + tmp9 := checkDerefVar(var_glojure_DOT_core_cons) + tmp10 := lang.Apply(tmp9, []any{v3, v4}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10}) + return tmp11 } }) tmp3 := reflect.TypeOf("") @@ -9012,9 +9007,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Dec") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "dec") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Dec is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("dec is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -9044,7 +9039,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_DecP}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_decP}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -9063,9 +9058,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "DecP") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "decP") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("DecP is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("decP is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -9640,7 +9635,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_DoubleArray}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_doubleArray}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := checkDerefVar(var_glojure_DOT_core_seq) tmp14 := checkDerefVar(var_glojure_DOT_core_concat) @@ -9666,9 +9661,9 @@ func LoadNS() { case 1: v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "DoubleArray") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "doubleArray") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("DoubleArray is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("doubleArray is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -9677,9 +9672,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "DoubleArrayInit") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "doubleArrayInit") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("DoubleArrayInit is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("doubleArrayInit is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -9728,7 +9723,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Doubles}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_doubles}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := lang.Apply(tmp12, []any{v3}) tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) @@ -9744,9 +9739,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Doubles") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "doubles") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Doubles is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("doubles is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -10350,7 +10345,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_FloatArray}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_floatArray}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := checkDerefVar(var_glojure_DOT_core_seq) tmp14 := checkDerefVar(var_glojure_DOT_core_concat) @@ -10376,9 +10371,9 @@ func LoadNS() { case 1: v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "FloatArray") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "floatArray") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("FloatArray is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("floatArray is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -10387,9 +10382,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "FloatArrayInit") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "floatArrayInit") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("FloatArrayInit is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("floatArrayInit is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -10453,7 +10448,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Floats}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_floats}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := lang.Apply(tmp12, []any{v3}) tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) @@ -10469,9 +10464,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Floats") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "floats") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Floats is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("floats is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -10981,9 +10976,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Inc") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "inc") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Inc is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("inc is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -11013,7 +11008,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_IncP}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_incP}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -11032,9 +11027,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "IncP") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "incP") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("IncP is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("incP is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -11176,7 +11171,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_IntArray}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_intArray}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := checkDerefVar(var_glojure_DOT_core_seq) tmp14 := checkDerefVar(var_glojure_DOT_core_concat) @@ -11202,9 +11197,9 @@ func LoadNS() { case 1: v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "IntArray") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "intArray") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("IntArray is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("intArray is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -11213,9 +11208,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "IntArrayInit") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "intArrayInit") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("IntArrayInit is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("intArrayInit is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -11360,7 +11355,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Ints}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_ints}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := lang.Apply(tmp12, []any{v3}) tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) @@ -11376,9 +11371,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Ints") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "ints") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Ints is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ints is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -11928,7 +11923,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_LongArray}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_longArray}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := checkDerefVar(var_glojure_DOT_core_seq) tmp14 := checkDerefVar(var_glojure_DOT_core_concat) @@ -11954,9 +11949,9 @@ func LoadNS() { case 1: v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "LongArray") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "longArray") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("LongArray is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("longArray is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -11965,9 +11960,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "LongArrayInit") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "longArrayInit") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("LongArrayInit is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("longArrayInit is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -11998,7 +11993,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Longs}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_longs}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := lang.Apply(tmp12, []any{v3}) tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) @@ -12014,9 +12009,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Longs") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "longs") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Longs is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("longs is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -12337,7 +12332,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_IsNeg}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_isNeg}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -12356,9 +12351,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "IsNeg") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "isNeg") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("IsNeg is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("isNeg is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -12701,7 +12696,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Num}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_num}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -12720,9 +12715,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Num") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "num") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Num is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("num is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -12955,7 +12950,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_IsPos}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_isPos}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -12974,9 +12969,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "IsPos") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "isPos") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("IsPos is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("isPos is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -13080,7 +13075,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Quotient}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_quotient}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -13103,9 +13098,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Quotient") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "quotient") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Quotient is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("quotient is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -13595,7 +13590,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Remainder}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_remainder}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -13618,9 +13613,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Remainder") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "remainder") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Remainder is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("remainder is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -13977,7 +13972,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_ShortArray}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_shortArray}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := checkDerefVar(var_glojure_DOT_core_seq) tmp14 := checkDerefVar(var_glojure_DOT_core_concat) @@ -14003,9 +13998,9 @@ func LoadNS() { case 1: v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "ShortArray") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "shortArray") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ShortArray is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("shortArray is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -14014,9 +14009,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "ShortArrayInit") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "shortArrayInit") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ShortArrayInit is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("shortArrayInit is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -14047,7 +14042,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Shorts}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_shorts}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := lang.Apply(tmp12, []any{v3}) tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) @@ -14063,9 +14058,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Shorts") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "shorts") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Shorts is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("shorts is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -15380,7 +15375,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_UncheckedAdd}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_unchecked_add}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -15403,9 +15398,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedAdd") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_add") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedAdd is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_add is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -15437,7 +15432,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_add}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_unchecked_int_add}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -15460,9 +15455,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_add") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_int_add") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_add is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_add is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -15590,7 +15585,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedDec}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_unchecked_dec}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -15609,9 +15604,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedDec") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_dec") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedDec is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_dec is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -15641,7 +15636,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_dec}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_unchecked_int_dec}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -15660,9 +15655,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_dec") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_int_dec") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_dec is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_dec is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -15694,7 +15689,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_UncheckedIntDivide}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_unchecked_int_divide}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -15717,9 +15712,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedIntDivide") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_int_divide") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedIntDivide is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_divide is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -15843,7 +15838,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Unchecked_inc}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_unchecked_inc}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -15862,9 +15857,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_inc") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_inc") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_inc is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_inc is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -15894,7 +15889,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_inc}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_unchecked_int_inc}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -15913,9 +15908,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_inc") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_int_inc") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_inc is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_inc is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -16041,7 +16036,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_multiply}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_unchecked_multiply}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -16064,9 +16059,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_multiply") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_multiply") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_multiply is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_multiply is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -16098,7 +16093,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_multiply}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_unchecked_int_multiply}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -16121,9 +16116,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_multiply") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_int_multiply") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_multiply is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_multiply is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -16153,7 +16148,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Unchecked_minus}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_unchecked_minus}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -16204,7 +16199,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_negate}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_unchecked_int_negate}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -16223,9 +16218,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_negate") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_int_negate") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_negate is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_negate is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -16257,7 +16252,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_remainder}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_unchecked_int_remainder}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -16280,9 +16275,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_remainder") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_int_remainder") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_remainder is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_remainder is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -16361,7 +16356,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_minus}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_unchecked_minus}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -16384,9 +16379,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_minus") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_minus") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_minus is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_minus is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -16418,7 +16413,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_subtract}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_unchecked_int_subtract}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -16441,9 +16436,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_subtract") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_int_subtract") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_subtract is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_subtract is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -16501,7 +16496,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_UnsignedShiftRight}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_unsignedShiftRight}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -16524,9 +16519,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "UnsignedShiftRight") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "unsignedShiftRight") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("UnsignedShiftRight is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unsignedShiftRight is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -16661,7 +16656,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_IsZero}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_isZero}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -16680,9 +16675,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "IsZero") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "isZero") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("IsZero is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("isZero is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -17236,7 +17231,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Equiv}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_equiv}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -17264,9 +17259,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Equiv") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "equiv") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Equiv is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("equiv is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -17339,7 +17334,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Gt}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_gt}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -17367,9 +17362,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "gt") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("gt is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -17442,7 +17437,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Gte}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_gte}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -17470,9 +17465,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Gte") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "gte") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gte is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("gte is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -17545,7 +17540,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Lt}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_lt}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -17573,9 +17568,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Lt") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "lt") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Lt is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("lt is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -17648,7 +17643,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Lte}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_lte}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -17676,9 +17671,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Lte") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "lte") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Lte is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("lte is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -17902,7 +17897,7 @@ func LoadNS() { if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + tmp5 := lang.Apply(tmp4, []any{v3, int64(1)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -17922,9 +17917,9 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Add") + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "add") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Add is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) } tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 @@ -18122,7 +18117,7 @@ func LoadNS() { if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + tmp5 := lang.Apply(tmp4, []any{v3, int64(1)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -18142,9 +18137,9 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "AddP") + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "addP") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("AddP is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("addP is not a function"))) } tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 @@ -18342,7 +18337,7 @@ func LoadNS() { if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + tmp5 := lang.Apply(tmp4, []any{v3, int64(1)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -18361,9 +18356,9 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Divide") + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "divide") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Divide is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("divide is not a function"))) } tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 @@ -18561,7 +18556,7 @@ func LoadNS() { if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + tmp5 := lang.Apply(tmp4, []any{v3, int64(1)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -18581,9 +18576,9 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Multiply") + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "multiply") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Multiply is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("multiply is not a function"))) } tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 @@ -18781,7 +18776,7 @@ func LoadNS() { if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + tmp5 := lang.Apply(tmp4, []any{v3, int64(1)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -18801,9 +18796,9 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "MultiplyP") + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "multiplyP") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("MultiplyP is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("multiplyP is not a function"))) } tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 @@ -20197,7 +20192,7 @@ func LoadNS() { if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + tmp5 := lang.Apply(tmp4, []any{v3, int64(1)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -20210,9 +20205,9 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "And") + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "and") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("And is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("and is not a function"))) } tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 @@ -20410,7 +20405,7 @@ func LoadNS() { if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + tmp5 := lang.Apply(tmp4, []any{v3, int64(1)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -20423,9 +20418,9 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "AndNot") + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "andNot") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("AndNot is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("andNot is not a function"))) } tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 @@ -20470,7 +20465,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Not}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_not}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -20489,9 +20484,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Not") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "not") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Not is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("not is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -20674,7 +20669,7 @@ func LoadNS() { if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + tmp5 := lang.Apply(tmp4, []any{v3, int64(1)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -20687,9 +20682,9 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Or") + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "or") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Or is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("or is not a function"))) } tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 @@ -20736,7 +20731,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_ShiftLeft}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_shiftLeft}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -20759,9 +20754,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "ShiftLeft") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "shiftLeft") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ShiftLeft is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("shiftLeft is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -20793,7 +20788,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_ShiftRight}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_shiftRight}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -20816,9 +20811,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "ShiftRight") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "shiftRight") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ShiftRight is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("shiftRight is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -21001,7 +20996,7 @@ func LoadNS() { if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + tmp5 := lang.Apply(tmp4, []any{v3, int64(1)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -21014,9 +21009,9 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Xor") + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "xor") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Xor is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("xor is not a function"))) } tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 @@ -21111,7 +21106,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_BooleanArray}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_booleanArray}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := checkDerefVar(var_glojure_DOT_core_seq) tmp14 := checkDerefVar(var_glojure_DOT_core_concat) @@ -21137,9 +21132,9 @@ func LoadNS() { case 1: v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "BooleanArray") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "booleanArray") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("BooleanArray is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("booleanArray is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -21148,9 +21143,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "BooleanArrayInit") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "booleanArrayInit") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("BooleanArrayInit is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("booleanArrayInit is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -21181,7 +21176,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Booleans}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_booleans}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := lang.Apply(tmp12, []any{v3}) tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) @@ -21197,9 +21192,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Booleans") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "booleans") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Booleans is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("booleans is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -21495,7 +21490,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_ByteArray}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_byteArray}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := checkDerefVar(var_glojure_DOT_core_seq) tmp14 := checkDerefVar(var_glojure_DOT_core_concat) @@ -21521,9 +21516,9 @@ func LoadNS() { case 1: v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "ByteArray") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "byteArray") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ByteArray is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("byteArray is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -21532,9 +21527,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "ByteArrayInit") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "byteArrayInit") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ByteArrayInit is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("byteArrayInit is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -21565,7 +21560,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Bytes}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_bytes}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := lang.Apply(tmp12, []any{v3}) tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) @@ -21581,9 +21576,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Bytes") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "bytes") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Bytes is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("bytes is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -21709,7 +21704,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_CharArray}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_charArray}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := checkDerefVar(var_glojure_DOT_core_seq) tmp14 := checkDerefVar(var_glojure_DOT_core_concat) @@ -21735,9 +21730,9 @@ func LoadNS() { case 1: v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "CharArray") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "charArray") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("CharArray is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("charArray is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -21746,9 +21741,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "CharArrayInit") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "charArrayInit") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("CharArrayInit is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("charArrayInit is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -21779,7 +21774,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Chars}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_chars}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := lang.Apply(tmp12, []any{v3}) tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) @@ -21795,9 +21790,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Chars") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "chars") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Chars is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("chars is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -27300,7 +27295,7 @@ func LoadNS() { if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + tmp5 := lang.Apply(tmp4, []any{v3, int64(1)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -27317,9 +27312,9 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Max") + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "max") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Max is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("max is not a function"))) } tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 @@ -27928,7 +27923,7 @@ func LoadNS() { if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + tmp5 := lang.Apply(tmp4, []any{v3, int64(1)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -27945,9 +27940,9 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Min") + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "min") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Min is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("min is not a function"))) } tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 @@ -29227,6 +29222,17 @@ func LoadNS() { // let binding "G__1017" var v7 any = v2 _ = v7 + // case + var tmp8 any + // case clause 0 + if lang.Equals(v7, "true") { + tmp8 = true + // case clause 1 + } else if lang.Equals(v7, "false") { + tmp8 = false + } else { + } + tmp6 = tmp8 } // end let tmp3 = tmp6 } else { @@ -29559,198 +29565,199 @@ func LoadNS() { var tmp5 any { // let // let binding "a" - var v6 any = "unimplemented: new with non-constant class type" - _ = v6 + tmp6 := new(lang.ArrayList) + var v7 any = tmp6 + _ = v7 // let binding "pv" - tmp7 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) - tmp8 := lang.Apply(tmp7, []any{kw_glojure_DOT_core_SLASH_none}) - var v9 any = tmp8 - _ = v9 - var tmp10 lang.FnFunc - tmp10 = lang.NewFnFunc(func(args ...any) any { + tmp8 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) + tmp9 := lang.Apply(tmp8, []any{kw_glojure_DOT_core_SLASH_none}) + var v10 any = tmp9 + _ = v10 + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - tmp11 := lang.Apply(v4, nil) - return tmp11 + tmp12 := lang.Apply(v4, nil) + return tmp12 case 1: - v11 := args[0] - _ = v11 - var tmp12 any + v12 := args[0] + _ = v12 + var tmp13 any { // let // let binding "result" - var tmp13 any - tmp14, ok := lang.FieldOrMethod(v6, "isEmpty") + var tmp14 any + tmp15, ok := lang.FieldOrMethod(v7, "isEmpty") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "isEmpty"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "isEmpty"))) } - var tmp15 any - switch reflect.TypeOf(tmp14).Kind() { + var tmp16 any + switch reflect.TypeOf(tmp15).Kind() { case reflect.Func: - tmp15 = lang.Apply(tmp14, nil) + tmp16 = lang.Apply(tmp15, nil) default: - tmp15 = tmp14 + tmp16 = tmp15 } - if lang.IsTruthy(tmp15) { - tmp13 = v11 + if lang.IsTruthy(tmp16) { + tmp14 = v12 } else { - var tmp16 any + var tmp17 any { // let // let binding "v" - tmp17 := checkDerefVar(var_glojure_DOT_core_vec) - tmp18, ok := lang.FieldOrMethod(v6, "toArray") + tmp18 := checkDerefVar(var_glojure_DOT_core_vec) + tmp19, ok := lang.FieldOrMethod(v7, "toArray") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "toArray"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "toArray"))) } - var tmp19 any - switch reflect.TypeOf(tmp18).Kind() { + var tmp20 any + switch reflect.TypeOf(tmp19).Kind() { case reflect.Func: - tmp19 = lang.Apply(tmp18, nil) + tmp20 = lang.Apply(tmp19, nil) default: - tmp19 = tmp18 + tmp20 = tmp19 } - tmp20 := lang.Apply(tmp17, []any{tmp19}) - var v21 any = tmp20 - _ = v21 - tmp22, ok := lang.FieldOrMethod(v6, "clear") + tmp21 := lang.Apply(tmp18, []any{tmp20}) + var v22 any = tmp21 + _ = v22 + tmp23, ok := lang.FieldOrMethod(v7, "clear") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "clear"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "clear"))) } - var tmp23 any - switch reflect.TypeOf(tmp22).Kind() { + var tmp24 any + switch reflect.TypeOf(tmp23).Kind() { case reflect.Func: - tmp23 = lang.Apply(tmp22, nil) + tmp24 = lang.Apply(tmp23, nil) default: - tmp23 = tmp22 + tmp24 = tmp23 } - _ = tmp23 - tmp24 := checkDerefVar(var_glojure_DOT_core_unreduced) - tmp25 := lang.Apply(v4, []any{v11, v21}) - tmp26 := lang.Apply(tmp24, []any{tmp25}) - tmp16 = tmp26 + _ = tmp24 + tmp25 := checkDerefVar(var_glojure_DOT_core_unreduced) + tmp26 := lang.Apply(v4, []any{v12, v22}) + tmp27 := lang.Apply(tmp25, []any{tmp26}) + tmp17 = tmp27 } // end let - tmp13 = tmp16 + tmp14 = tmp17 } - var v17 any = tmp13 - _ = v17 - tmp18 := lang.Apply(v4, []any{v17}) - tmp12 = tmp18 + var v18 any = tmp14 + _ = v18 + tmp19 := lang.Apply(v4, []any{v18}) + tmp13 = tmp19 } // end let - return tmp12 + return tmp13 case 2: - v11 := args[0] - _ = v11 - v12 := args[1] + v12 := args[0] _ = v12 - var tmp13 any + v13 := args[1] + _ = v13 + var tmp14 any { // let // let binding "pval" - tmp14 := checkDerefVar(var_glojure_DOT_core_deref) - tmp15 := lang.Apply(tmp14, []any{v9}) - var v16 any = tmp15 - _ = v16 + tmp15 := checkDerefVar(var_glojure_DOT_core_deref) + tmp16 := lang.Apply(tmp15, []any{v10}) + var v17 any = tmp16 + _ = v17 // let binding "val" - tmp17 := lang.Apply(v2, []any{v12}) - var v18 any = tmp17 - _ = v18 - tmp19 := checkDerefVar(var_glojure_DOT_core_vreset_BANG_) - tmp20 := lang.Apply(tmp19, []any{v9, v18}) - _ = tmp20 - var tmp21 any + tmp18 := lang.Apply(v2, []any{v13}) + var v19 any = tmp18 + _ = v19 + tmp20 := checkDerefVar(var_glojure_DOT_core_vreset_BANG_) + tmp21 := lang.Apply(tmp20, []any{v10, v19}) + _ = tmp21 var tmp22 any + var tmp23 any { // let // let binding "or__0__auto__" - tmp23 := checkDerefVar(var_glojure_DOT_core_identical_QMARK_) - tmp24 := lang.Apply(tmp23, []any{v16, kw_glojure_DOT_core_SLASH_none}) - var v25 any = tmp24 - _ = v25 - var tmp26 any - if lang.IsTruthy(v25) { - tmp26 = v25 + tmp24 := checkDerefVar(var_glojure_DOT_core_identical_QMARK_) + tmp25 := lang.Apply(tmp24, []any{v17, kw_glojure_DOT_core_SLASH_none}) + var v26 any = tmp25 + _ = v26 + var tmp27 any + if lang.IsTruthy(v26) { + tmp27 = v26 } else { - tmp27 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp28 := lang.Apply(tmp27, []any{v18, v16}) - tmp26 = tmp28 + tmp28 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp29 := lang.Apply(tmp28, []any{v19, v17}) + tmp27 = tmp29 } - tmp22 = tmp26 + tmp23 = tmp27 } // end let - if lang.IsTruthy(tmp22) { - tmp23, _ := lang.FieldOrMethod(v6, "add") - if reflect.TypeOf(tmp23).Kind() != reflect.Func { + if lang.IsTruthy(tmp23) { + tmp24, _ := lang.FieldOrMethod(v7, "add") + if reflect.TypeOf(tmp24).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) } - tmp24 := lang.Apply(tmp23, []any{v12}) - _ = tmp24 - tmp21 = v11 + tmp25 := lang.Apply(tmp24, []any{v13}) + _ = tmp25 + tmp22 = v12 } else { - var tmp25 any + var tmp26 any { // let // let binding "v" - tmp26 := checkDerefVar(var_glojure_DOT_core_vec) - tmp27, ok := lang.FieldOrMethod(v6, "toArray") + tmp27 := checkDerefVar(var_glojure_DOT_core_vec) + tmp28, ok := lang.FieldOrMethod(v7, "toArray") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "toArray"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "toArray"))) } - var tmp28 any - switch reflect.TypeOf(tmp27).Kind() { + var tmp29 any + switch reflect.TypeOf(tmp28).Kind() { case reflect.Func: - tmp28 = lang.Apply(tmp27, nil) + tmp29 = lang.Apply(tmp28, nil) default: - tmp28 = tmp27 + tmp29 = tmp28 } - tmp29 := lang.Apply(tmp26, []any{tmp28}) - var v30 any = tmp29 - _ = v30 - tmp31, ok := lang.FieldOrMethod(v6, "clear") + tmp30 := lang.Apply(tmp27, []any{tmp29}) + var v31 any = tmp30 + _ = v31 + tmp32, ok := lang.FieldOrMethod(v7, "clear") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "clear"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "clear"))) } - var tmp32 any - switch reflect.TypeOf(tmp31).Kind() { + var tmp33 any + switch reflect.TypeOf(tmp32).Kind() { case reflect.Func: - tmp32 = lang.Apply(tmp31, nil) + tmp33 = lang.Apply(tmp32, nil) default: - tmp32 = tmp31 + tmp33 = tmp32 } - _ = tmp32 - var tmp33 any + _ = tmp33 + var tmp34 any { // let // let binding "ret" - tmp34 := lang.Apply(v4, []any{v11, v30}) - var v35 any = tmp34 - _ = v35 - var tmp36 any - tmp37 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) - tmp38 := lang.Apply(tmp37, []any{v35}) - if lang.IsTruthy(tmp38) { + tmp35 := lang.Apply(v4, []any{v12, v31}) + var v36 any = tmp35 + _ = v36 + var tmp37 any + tmp38 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) + tmp39 := lang.Apply(tmp38, []any{v36}) + if lang.IsTruthy(tmp39) { } else { - tmp39, _ := lang.FieldOrMethod(v6, "add") - if reflect.TypeOf(tmp39).Kind() != reflect.Func { + tmp40, _ := lang.FieldOrMethod(v7, "add") + if reflect.TypeOf(tmp40).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) } - tmp40 := lang.Apply(tmp39, []any{v12}) - tmp36 = tmp40 + tmp41 := lang.Apply(tmp40, []any{v13}) + tmp37 = tmp41 } - _ = tmp36 - tmp33 = v35 + _ = tmp37 + tmp34 = v36 } // end let - tmp25 = tmp33 + tmp26 = tmp34 } // end let - tmp21 = tmp25 + tmp22 = tmp26 } - tmp13 = tmp21 + tmp14 = tmp22 } // end let - return tmp13 + return tmp14 default: checkArity(args, -1) panic("unreachable") } }) - tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7152), kw_column, int(7), kw_end_DASH_line, int(7176), kw_end_DASH_column, int(28)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7152), kw_column, int(7), kw_end_DASH_line, int(7176), kw_end_DASH_column, int(28)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp5 = tmp12 + tmp5 = tmp13 } // end let return tmp5 }) @@ -31233,30 +31240,30 @@ func LoadNS() { var tmp50 any if lang.IsTruthy(v49) { } else { - panic("unimplemented: new with non-constant class type") + panic(nil) } _ = tmp50 - tmp51 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) - var tmp52 any + tmp52 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + var tmp53 any { // let // let binding "or__0__auto__" - tmp53 := lang.Apply(v15, []any{v44}) - var v54 any = tmp53 - _ = v54 - var tmp55 any - if lang.IsTruthy(v54) { - tmp55 = v54 + tmp54 := lang.Apply(v15, []any{v44}) + var v55 any = tmp54 + _ = v55 + var tmp56 any + if lang.IsTruthy(v55) { + tmp56 = v55 } else { - tmp55 = v44 + tmp56 = v44 } - tmp52 = tmp55 + tmp53 = tmp56 } // end let - tmp53, _ := lang.FieldOrMethod(tmp51, "Refer") - if reflect.TypeOf(tmp53).Kind() != reflect.Func { + tmp54, _ := lang.FieldOrMethod(tmp52, "Refer") + if reflect.TypeOf(tmp54).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Refer is not a function"))) } - tmp54 := lang.Apply(tmp53, []any{tmp52, v49}) - tmp47 = tmp54 + tmp55 := lang.Apply(tmp54, []any{tmp53, v49}) + tmp47 = tmp55 } // end let tmp45 = tmp47 } @@ -31340,30 +31347,30 @@ func LoadNS() { var tmp62 any if lang.IsTruthy(v61) { } else { - panic("unimplemented: new with non-constant class type") + panic(nil) } _ = tmp62 - tmp63 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) - var tmp64 any + tmp64 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + var tmp65 any { // let // let binding "or__0__auto__" - tmp65 := lang.Apply(v15, []any{v56}) - var v66 any = tmp65 - _ = v66 - var tmp67 any - if lang.IsTruthy(v66) { - tmp67 = v66 + tmp66 := lang.Apply(v15, []any{v56}) + var v67 any = tmp66 + _ = v67 + var tmp68 any + if lang.IsTruthy(v67) { + tmp68 = v67 } else { - tmp67 = v56 + tmp68 = v56 } - tmp64 = tmp67 + tmp65 = tmp68 } // end let - tmp65, _ := lang.FieldOrMethod(tmp63, "Refer") - if reflect.TypeOf(tmp65).Kind() != reflect.Func { + tmp66, _ := lang.FieldOrMethod(tmp64, "Refer") + if reflect.TypeOf(tmp66).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Refer is not a function"))) } - tmp66 := lang.Apply(tmp65, []any{tmp64, v61}) - tmp59 = tmp66 + tmp67 := lang.Apply(tmp66, []any{tmp65, v61}) + tmp59 = tmp67 } // end let tmp57 = tmp59 } @@ -34967,7 +34974,7 @@ func LoadNS() { if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(0)}) + tmp5 := lang.Apply(tmp4, []any{v3, int64(0)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -34986,9 +34993,9 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Minus") + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "minus") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Minus is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("minus is not a function"))) } tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 @@ -35186,7 +35193,7 @@ func LoadNS() { if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(0)}) + tmp5 := lang.Apply(tmp4, []any{v3, int64(0)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -35205,9 +35212,9 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "MinusP") + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "minusP") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("MinusP is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("minusP is not a function"))) } tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 @@ -35248,58 +35255,59 @@ func LoadNS() { var tmp4 any { // let // let binding "a" - var v5 any = "unimplemented: new with non-constant class type" - _ = v5 + tmp5 := new(*lang.Agent) + var v6 any = tmp5 + _ = v6 // let binding "opts" - tmp6 := checkDerefVar(var_glojure_DOT_core_apply) - tmp7 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) - tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) - var v9 any = tmp8 - _ = v9 - tmp10 := checkDerefVar(var_glojure_DOT_core_setup_DASH_reference) - tmp11 := lang.Apply(tmp10, []any{v5, v3}) - _ = tmp11 - var tmp12 any - tmp13 := lang.Apply(kw_error_DASH_handler, []any{v9}) - if lang.IsTruthy(tmp13) { - tmp14 := lang.Apply(kw_error_DASH_handler, []any{v9}) - tmp15, _ := lang.FieldOrMethod(v5, "setErrorHandler") - if reflect.TypeOf(tmp15).Kind() != reflect.Func { + tmp7 := checkDerefVar(var_glojure_DOT_core_apply) + tmp8 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp9 := lang.Apply(tmp7, []any{tmp8, v3}) + var v10 any = tmp9 + _ = v10 + tmp11 := checkDerefVar(var_glojure_DOT_core_setup_DASH_reference) + tmp12 := lang.Apply(tmp11, []any{v6, v3}) + _ = tmp12 + var tmp13 any + tmp14 := lang.Apply(kw_error_DASH_handler, []any{v10}) + if lang.IsTruthy(tmp14) { + tmp15 := lang.Apply(kw_error_DASH_handler, []any{v10}) + tmp16, _ := lang.FieldOrMethod(v6, "setErrorHandler") + if reflect.TypeOf(tmp16).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorHandler is not a function"))) } - tmp16 := lang.Apply(tmp15, []any{tmp14}) - tmp12 = tmp16 + tmp17 := lang.Apply(tmp16, []any{tmp15}) + tmp13 = tmp17 } else { } - _ = tmp12 - var tmp17 any + _ = tmp13 + var tmp18 any { // let // let binding "or__0__auto__" - tmp18 := lang.Apply(kw_error_DASH_mode, []any{v9}) - var v19 any = tmp18 - _ = v19 - var tmp20 any - if lang.IsTruthy(v19) { - tmp20 = v19 + tmp19 := lang.Apply(kw_error_DASH_mode, []any{v10}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + tmp21 = v20 } else { - var tmp21 any - tmp22 := lang.Apply(kw_error_DASH_handler, []any{v9}) - if lang.IsTruthy(tmp22) { - tmp21 = kw_continue + var tmp22 any + tmp23 := lang.Apply(kw_error_DASH_handler, []any{v10}) + if lang.IsTruthy(tmp23) { + tmp22 = kw_continue } else { - tmp21 = kw_fail + tmp22 = kw_fail } - tmp20 = tmp21 + tmp21 = tmp22 } - tmp17 = tmp20 + tmp18 = tmp21 } // end let - tmp18, _ := lang.FieldOrMethod(v5, "setErrorMode") - if reflect.TypeOf(tmp18).Kind() != reflect.Func { + tmp19, _ := lang.FieldOrMethod(v6, "setErrorMode") + if reflect.TypeOf(tmp19).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorMode is not a function"))) } - tmp19 := lang.Apply(tmp18, []any{tmp17}) - _ = tmp19 - tmp4 = v5 + tmp20 := lang.Apply(tmp19, []any{tmp18}) + _ = tmp20 + tmp4 = v6 } // end let return tmp4 } @@ -43779,244 +43787,7 @@ func LoadNS() { var tmp8 any { // let // let binding "latch" - var v9 any = "unimplemented: new with non-constant class type" - _ = v9 - // let binding "count-down" - var tmp10 lang.FnFunc - tmp10 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v11 := args[0] - _ = v11 - tmp12, _ := lang.FieldOrMethod(v9, "countDown") - if reflect.TypeOf(tmp12).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("countDown is not a function"))) - } - tmp13 := lang.Apply(tmp12, []any{}) - _ = tmp13 - return v11 - }) - tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3279), kw_column, int(22), kw_end_DASH_line, int(3279), kw_end_DASH_column, int(61)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v13 any = tmp12 - _ = v13 - var tmp14 any - { // let - // let binding "seq_692" - tmp15 := checkDerefVar(var_glojure_DOT_core_seq) - tmp16 := lang.Apply(tmp15, []any{v2}) - var v17 any = tmp16 - _ = v17 - // let binding "chunk_693" - var v18 any = nil - _ = v18 - // let binding "count_694" - var v19 any = int64(0) - _ = v19 - // let binding "i_695" - var v20 any = int64(0) - _ = v20 - for { - var tmp21 any - tmp22 := checkDerefVar(var_glojure_DOT_core__LT_) - tmp23 := lang.Apply(tmp22, []any{v20, v19}) - if lang.IsTruthy(tmp23) { - var tmp24 any - { // let - // let binding "agent" - tmp25, _ := lang.FieldOrMethod(v18, "nth") - if reflect.TypeOf(tmp25).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) - } - tmp26 := lang.Apply(tmp25, []any{v20}) - var v27 any = tmp26 - _ = v27 - tmp28 := checkDerefVar(var_glojure_DOT_core_send) - tmp29 := lang.Apply(tmp28, []any{v27, v13}) - _ = tmp29 - var tmp30 any = v17 - var tmp31 any = v18 - var tmp32 any = v19 - tmp34 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) - tmp35 := lang.Apply(tmp34, []any{v20}) - var tmp33 any = tmp35 - v17 = tmp30 - v18 = tmp31 - v19 = tmp32 - v20 = tmp33 - continue - } // end let - tmp21 = tmp24 - } else { - var tmp25 any - { // let - // let binding "temp__0__auto__" - tmp26 := checkDerefVar(var_glojure_DOT_core_seq) - tmp27 := lang.Apply(tmp26, []any{v17}) - var v28 any = tmp27 - _ = v28 - var tmp29 any - if lang.IsTruthy(v28) { - var tmp30 any - { // let - // let binding "seq_692" - var v31 any = v28 - _ = v31 - var tmp32 any - tmp33 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) - tmp34 := lang.Apply(tmp33, []any{v31}) - if lang.IsTruthy(tmp34) { - var tmp35 any - { // let - // let binding "c__0__auto__" - tmp36 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) - tmp37 := lang.Apply(tmp36, []any{v31}) - var v38 any = tmp37 - _ = v38 - tmp40 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) - tmp41 := lang.Apply(tmp40, []any{v31}) - var tmp39 any = tmp41 - var tmp42 any = v38 - tmp44 := checkDerefVar(var_glojure_DOT_core_int) - tmp45 := checkDerefVar(var_glojure_DOT_core_count) - tmp46 := lang.Apply(tmp45, []any{v38}) - tmp47 := lang.Apply(tmp44, []any{tmp46}) - var tmp43 any = tmp47 - tmp49 := checkDerefVar(var_glojure_DOT_core_int) - tmp50 := lang.Apply(tmp49, []any{int64(0)}) - var tmp48 any = tmp50 - v17 = tmp39 - v18 = tmp42 - v19 = tmp43 - v20 = tmp48 - continue - } // end let - tmp32 = tmp35 - } else { - var tmp36 any - { // let - // let binding "agent" - tmp37 := checkDerefVar(var_glojure_DOT_core_first) - tmp38 := lang.Apply(tmp37, []any{v31}) - var v39 any = tmp38 - _ = v39 - tmp40 := checkDerefVar(var_glojure_DOT_core_send) - tmp41 := lang.Apply(tmp40, []any{v39, v13}) - _ = tmp41 - tmp43 := checkDerefVar(var_glojure_DOT_core_next) - tmp44 := lang.Apply(tmp43, []any{v31}) - var tmp42 any = tmp44 - var tmp45 any = nil - var tmp46 any = int64(0) - var tmp47 any = int64(0) - v17 = tmp42 - v18 = tmp45 - v19 = tmp46 - v20 = tmp47 - continue - } // end let - tmp32 = tmp36 - } - tmp30 = tmp32 - } // end let - tmp29 = tmp30 - } else { - } - tmp25 = tmp29 - } // end let - tmp21 = tmp25 - } - tmp14 = tmp21 - break - } - } // end let - _ = tmp14 - tmp15, _ := lang.FieldOrMethod(v9, "await") - if reflect.TypeOf(tmp15).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) - } - tmp16 := lang.Apply(tmp15, []any{}) - tmp8 = tmp16 - } // end let - tmp3 = tmp8 - } - return tmp3 - } - }) - tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - var_glojure_DOT_core_await = ns.InternWithValue(tmp0, tmp1, true) - if tmp0.Meta() != nil { - var_glojure_DOT_core_await.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // await1 - { - tmp0 := sym_await1.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(3284), kw_column, int(7), kw_end_DASH_line, int(3284), kw_end_DASH_column, int(21), kw_arglists, lang.NewList(lang.NewVector(sym_a)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - var tmp1 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v2 := args[0] - _ = v2 - var tmp3 any - tmp4 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) - tmp5, ok := lang.FieldOrMethod(v2, "getQueueCount") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getQueueCount"))) - } - var tmp6 any - switch reflect.TypeOf(tmp5).Kind() { - case reflect.Func: - tmp6 = lang.Apply(tmp5, nil) - default: - tmp6 = tmp5 - } - tmp7 := lang.Apply(tmp4, []any{tmp6}) - if lang.IsTruthy(tmp7) { - tmp8 := checkDerefVar(var_glojure_DOT_core_await) - tmp9 := lang.Apply(tmp8, []any{v2}) - tmp3 = tmp9 - } else { - } - _ = tmp3 - return v2 - }) - tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - var_glojure_DOT_core_await1 = ns.InternWithValue(tmp0, tmp1, true) - if tmp0.Meta() != nil { - var_glojure_DOT_core_await1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // await-for - { - tmp0 := sym_await_DASH_for.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_timeout_DASH_ms, sym__AMP_, sym_agents)), kw_doc, "Blocks the current thread until all actions dispatched thus\n far (from this thread or agent) to the agents have occurred, or the\n timeout (in milliseconds) has elapsed. Returns logical false if\n returning due to timeout, logical true otherwise.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(3289), kw_end_DASH_line, int(3289))).(*lang.Symbol) - var tmp1 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArityGTE(args, 1) - v2 := args[0] - _ = v2 - var v3 any = lang.NewList(args[1:]...) - _ = v3 - var tmp4 any - tmp5 := lang.Apply(nil, nil) - if lang.IsTruthy(tmp5) { - panic("unimplemented: new with non-constant class type") - } else { - var tmp6 any - tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_agent_STAR_) - if lang.IsTruthy(tmp7) { - tmp8 := lang.Apply(errors5.New, []any{"Can't await in agent action"}) - panic(tmp8) - } else { - } - _ = tmp6 - var tmp9 any - { // let - // let binding "latch" - var v10 any = "unimplemented: new with non-constant class type" + var v10 any = nil _ = v10 // let binding "count-down" var tmp11 lang.FnFunc @@ -44032,7 +43803,7 @@ func LoadNS() { _ = tmp14 return v12 }) - tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3301), kw_column, int(23), kw_end_DASH_line, int(3301), kw_end_DASH_column, int(62)) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3279), kw_column, int(22), kw_end_DASH_line, int(3279), kw_end_DASH_column, int(61)) tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) if err != nil { panic(err) @@ -44041,18 +43812,18 @@ func LoadNS() { _ = v14 var tmp15 any { // let - // let binding "seq_696" + // let binding "seq_692" tmp16 := checkDerefVar(var_glojure_DOT_core_seq) - tmp17 := lang.Apply(tmp16, []any{v3}) + tmp17 := lang.Apply(tmp16, []any{v2}) var v18 any = tmp17 _ = v18 - // let binding "chunk_697" + // let binding "chunk_693" var v19 any = nil _ = v19 - // let binding "count_698" + // let binding "count_694" var v20 any = int64(0) _ = v20 - // let binding "i_699" + // let binding "i_695" var v21 any = int64(0) _ = v21 for { @@ -44098,7 +43869,7 @@ func LoadNS() { if lang.IsTruthy(v29) { var tmp31 any { // let - // let binding "seq_696" + // let binding "seq_692" var v32 any = v29 _ = v32 var tmp33 any @@ -44170,23 +43941,260 @@ func LoadNS() { } } // end let _ = tmp15 - tmp16, ok := lang.FieldOrMethod(nil, "MILLISECONDS") + tmp16, _ := lang.FieldOrMethod(v10, "await") + if reflect.TypeOf(tmp16).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) + } + tmp17 := lang.Apply(tmp16, []any{}) + tmp8 = tmp17 + } // end let + tmp3 = tmp8 + } + return tmp3 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_await = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_await.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // await1 + { + tmp0 := sym_await1.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(3284), kw_column, int(7), kw_end_DASH_line, int(3284), kw_end_DASH_column, int(21), kw_arglists, lang.NewList(lang.NewVector(sym_a)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp5, ok := lang.FieldOrMethod(v2, "getQueueCount") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getQueueCount"))) + } + var tmp6 any + switch reflect.TypeOf(tmp5).Kind() { + case reflect.Func: + tmp6 = lang.Apply(tmp5, nil) + default: + tmp6 = tmp5 + } + tmp7 := lang.Apply(tmp4, []any{tmp6}) + if lang.IsTruthy(tmp7) { + tmp8 := checkDerefVar(var_glojure_DOT_core_await) + tmp9 := lang.Apply(tmp8, []any{v2}) + tmp3 = tmp9 + } else { + } + _ = tmp3 + return v2 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_await1 = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_await1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // await-for + { + tmp0 := sym_await_DASH_for.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_timeout_DASH_ms, sym__AMP_, sym_agents)), kw_doc, "Blocks the current thread until all actions dispatched thus\n far (from this thread or agent) to the agents have occurred, or the\n timeout (in milliseconds) has elapsed. Returns logical false if\n returning due to timeout, logical true otherwise.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(3289), kw_end_DASH_line, int(3289))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArityGTE(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + var tmp4 any + tmp5 := lang.Apply(nil, nil) + if lang.IsTruthy(tmp5) { + panic("unimplemented: new with non-constant class type") + } else { + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_agent_STAR_) + if lang.IsTruthy(tmp7) { + tmp8 := lang.Apply(errors5.New, []any{"Can't await in agent action"}) + panic(tmp8) + } else { + } + _ = tmp6 + var tmp9 any + { // let + // let binding "latch" + var v11 any = nil + _ = v11 + // let binding "count-down" + var tmp12 lang.FnFunc + tmp12 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v13 := args[0] + _ = v13 + tmp14, _ := lang.FieldOrMethod(v11, "countDown") + if reflect.TypeOf(tmp14).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("countDown is not a function"))) + } + tmp15 := lang.Apply(tmp14, []any{}) + _ = tmp15 + return v13 + }) + tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3301), kw_column, int(23), kw_end_DASH_line, int(3301), kw_end_DASH_column, int(62)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v15 any = tmp14 + _ = v15 + var tmp16 any + { // let + // let binding "seq_696" + tmp17 := checkDerefVar(var_glojure_DOT_core_seq) + tmp18 := lang.Apply(tmp17, []any{v3}) + var v19 any = tmp18 + _ = v19 + // let binding "chunk_697" + var v20 any = nil + _ = v20 + // let binding "count_698" + var v21 any = int64(0) + _ = v21 + // let binding "i_699" + var v22 any = int64(0) + _ = v22 + for { + var tmp23 any + tmp24 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp25 := lang.Apply(tmp24, []any{v22, v21}) + if lang.IsTruthy(tmp25) { + var tmp26 any + { // let + // let binding "agent" + tmp27, _ := lang.FieldOrMethod(v20, "nth") + if reflect.TypeOf(tmp27).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp28 := lang.Apply(tmp27, []any{v22}) + var v29 any = tmp28 + _ = v29 + tmp30 := checkDerefVar(var_glojure_DOT_core_send) + tmp31 := lang.Apply(tmp30, []any{v29, v15}) + _ = tmp31 + var tmp32 any = v19 + var tmp33 any = v20 + var tmp34 any = v21 + tmp36 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp37 := lang.Apply(tmp36, []any{v22}) + var tmp35 any = tmp37 + v19 = tmp32 + v20 = tmp33 + v21 = tmp34 + v22 = tmp35 + continue + } // end let + tmp23 = tmp26 + } else { + var tmp27 any + { // let + // let binding "temp__0__auto__" + tmp28 := checkDerefVar(var_glojure_DOT_core_seq) + tmp29 := lang.Apply(tmp28, []any{v19}) + var v30 any = tmp29 + _ = v30 + var tmp31 any + if lang.IsTruthy(v30) { + var tmp32 any + { // let + // let binding "seq_696" + var v33 any = v30 + _ = v33 + var tmp34 any + tmp35 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp36 := lang.Apply(tmp35, []any{v33}) + if lang.IsTruthy(tmp36) { + var tmp37 any + { // let + // let binding "c__0__auto__" + tmp38 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp39 := lang.Apply(tmp38, []any{v33}) + var v40 any = tmp39 + _ = v40 + tmp42 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp43 := lang.Apply(tmp42, []any{v33}) + var tmp41 any = tmp43 + var tmp44 any = v40 + tmp46 := checkDerefVar(var_glojure_DOT_core_int) + tmp47 := checkDerefVar(var_glojure_DOT_core_count) + tmp48 := lang.Apply(tmp47, []any{v40}) + tmp49 := lang.Apply(tmp46, []any{tmp48}) + var tmp45 any = tmp49 + tmp51 := checkDerefVar(var_glojure_DOT_core_int) + tmp52 := lang.Apply(tmp51, []any{int64(0)}) + var tmp50 any = tmp52 + v19 = tmp41 + v20 = tmp44 + v21 = tmp45 + v22 = tmp50 + continue + } // end let + tmp34 = tmp37 + } else { + var tmp38 any + { // let + // let binding "agent" + tmp39 := checkDerefVar(var_glojure_DOT_core_first) + tmp40 := lang.Apply(tmp39, []any{v33}) + var v41 any = tmp40 + _ = v41 + tmp42 := checkDerefVar(var_glojure_DOT_core_send) + tmp43 := lang.Apply(tmp42, []any{v41, v15}) + _ = tmp43 + tmp45 := checkDerefVar(var_glojure_DOT_core_next) + tmp46 := lang.Apply(tmp45, []any{v33}) + var tmp44 any = tmp46 + var tmp47 any = nil + var tmp48 any = int64(0) + var tmp49 any = int64(0) + v19 = tmp44 + v20 = tmp47 + v21 = tmp48 + v22 = tmp49 + continue + } // end let + tmp34 = tmp38 + } + tmp32 = tmp34 + } // end let + tmp31 = tmp32 + } else { + } + tmp27 = tmp31 + } // end let + tmp23 = tmp27 + } + tmp16 = tmp23 + break + } + } // end let + _ = tmp16 + tmp17, ok := lang.FieldOrMethod(nil, "MILLISECONDS") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "MILLISECONDS"))) } - var tmp17 any - switch reflect.TypeOf(tmp16).Kind() { + var tmp18 any + switch reflect.TypeOf(tmp17).Kind() { case reflect.Func: - tmp17 = lang.Apply(tmp16, nil) + tmp18 = lang.Apply(tmp17, nil) default: - tmp17 = tmp16 + tmp18 = tmp17 } - tmp18, _ := lang.FieldOrMethod(v10, "await") - if reflect.TypeOf(tmp18).Kind() != reflect.Func { + tmp19, _ := lang.FieldOrMethod(v11, "await") + if reflect.TypeOf(tmp19).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) } - tmp19 := lang.Apply(tmp18, []any{v2, tmp17}) - tmp9 = tmp19 + tmp20 := lang.Apply(tmp19, []any{v2, tmp18}) + tmp9 = tmp20 } // end let tmp4 = tmp9 } @@ -53036,34 +53044,35 @@ func LoadNS() { var tmp4 any { // let // let binding "s__0__auto__" - var v5 any = "unimplemented: new with non-constant class type" - _ = v5 - var tmp6 any + tmp5 := new(strings8.Builder) + var v6 any = tmp5 + _ = v6 + var tmp7 any { // let - tmp7 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) - tmp8 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) - tmp9 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) - tmp10 := lang.Apply(tmp8, []any{tmp9, v5}) - tmp11 := lang.Apply(tmp7, []any{tmp10}) - _ = tmp11 - var tmp12 any + tmp8 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp9 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp10 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) + tmp11 := lang.Apply(tmp9, []any{tmp10, v6}) + tmp12 := lang.Apply(tmp8, []any{tmp11}) + _ = tmp12 + var tmp13 any func() { defer func() { - tmp13 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) - tmp14 := lang.Apply(tmp13, nil) - _ = tmp14 + tmp14 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp15 := lang.Apply(tmp14, nil) + _ = tmp15 }() - tmp15 := checkDerefVar(var_glojure_DOT_core_apply) - tmp16 := checkDerefVar(var_glojure_DOT_core_pr) - tmp17 := lang.Apply(tmp15, []any{tmp16, v3}) - _ = tmp17 - tmp18 := checkDerefVar(var_glojure_DOT_core_str) - tmp19 := lang.Apply(tmp18, []any{v5}) - tmp12 = tmp19 + tmp16 := checkDerefVar(var_glojure_DOT_core_apply) + tmp17 := checkDerefVar(var_glojure_DOT_core_pr) + tmp18 := lang.Apply(tmp16, []any{tmp17, v3}) + _ = tmp18 + tmp19 := checkDerefVar(var_glojure_DOT_core_str) + tmp20 := lang.Apply(tmp19, []any{v6}) + tmp13 = tmp20 }() - tmp6 = tmp12 + tmp7 = tmp13 } // end let - tmp4 = tmp6 + tmp4 = tmp7 } // end let return tmp4 } @@ -53130,34 +53139,35 @@ func LoadNS() { var tmp4 any { // let // let binding "s__0__auto__" - var v5 any = "unimplemented: new with non-constant class type" - _ = v5 - var tmp6 any + tmp5 := new(strings8.Builder) + var v6 any = tmp5 + _ = v6 + var tmp7 any { // let - tmp7 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) - tmp8 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) - tmp9 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) - tmp10 := lang.Apply(tmp8, []any{tmp9, v5}) - tmp11 := lang.Apply(tmp7, []any{tmp10}) - _ = tmp11 - var tmp12 any + tmp8 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp9 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp10 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) + tmp11 := lang.Apply(tmp9, []any{tmp10, v6}) + tmp12 := lang.Apply(tmp8, []any{tmp11}) + _ = tmp12 + var tmp13 any func() { defer func() { - tmp13 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) - tmp14 := lang.Apply(tmp13, nil) - _ = tmp14 + tmp14 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp15 := lang.Apply(tmp14, nil) + _ = tmp15 }() - tmp15 := checkDerefVar(var_glojure_DOT_core_apply) - tmp16 := checkDerefVar(var_glojure_DOT_core_print) - tmp17 := lang.Apply(tmp15, []any{tmp16, v3}) - _ = tmp17 - tmp18 := checkDerefVar(var_glojure_DOT_core_str) - tmp19 := lang.Apply(tmp18, []any{v5}) - tmp12 = tmp19 + tmp16 := checkDerefVar(var_glojure_DOT_core_apply) + tmp17 := checkDerefVar(var_glojure_DOT_core_print) + tmp18 := lang.Apply(tmp16, []any{tmp17, v3}) + _ = tmp18 + tmp19 := checkDerefVar(var_glojure_DOT_core_str) + tmp20 := lang.Apply(tmp19, []any{v6}) + tmp13 = tmp20 }() - tmp6 = tmp12 + tmp7 = tmp13 } // end let - tmp4 = tmp6 + tmp4 = tmp7 } // end let return tmp4 } @@ -53243,34 +53253,35 @@ func LoadNS() { var tmp4 any { // let // let binding "s__0__auto__" - var v5 any = "unimplemented: new with non-constant class type" - _ = v5 - var tmp6 any + tmp5 := new(strings8.Builder) + var v6 any = tmp5 + _ = v6 + var tmp7 any { // let - tmp7 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) - tmp8 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) - tmp9 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) - tmp10 := lang.Apply(tmp8, []any{tmp9, v5}) - tmp11 := lang.Apply(tmp7, []any{tmp10}) - _ = tmp11 - var tmp12 any + tmp8 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp9 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp10 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) + tmp11 := lang.Apply(tmp9, []any{tmp10, v6}) + tmp12 := lang.Apply(tmp8, []any{tmp11}) + _ = tmp12 + var tmp13 any func() { defer func() { - tmp13 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) - tmp14 := lang.Apply(tmp13, nil) - _ = tmp14 + tmp14 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp15 := lang.Apply(tmp14, nil) + _ = tmp15 }() - tmp15 := checkDerefVar(var_glojure_DOT_core_apply) - tmp16 := checkDerefVar(var_glojure_DOT_core_prn) - tmp17 := lang.Apply(tmp15, []any{tmp16, v3}) - _ = tmp17 - tmp18 := checkDerefVar(var_glojure_DOT_core_str) - tmp19 := lang.Apply(tmp18, []any{v5}) - tmp12 = tmp19 + tmp16 := checkDerefVar(var_glojure_DOT_core_apply) + tmp17 := checkDerefVar(var_glojure_DOT_core_prn) + tmp18 := lang.Apply(tmp16, []any{tmp17, v3}) + _ = tmp18 + tmp19 := checkDerefVar(var_glojure_DOT_core_str) + tmp20 := lang.Apply(tmp19, []any{v6}) + tmp13 = tmp20 }() - tmp6 = tmp12 + tmp7 = tmp13 } // end let - tmp4 = tmp6 + tmp4 = tmp7 } // end let return tmp4 } @@ -53337,34 +53348,35 @@ func LoadNS() { var tmp4 any { // let // let binding "s__0__auto__" - var v5 any = "unimplemented: new with non-constant class type" - _ = v5 - var tmp6 any + tmp5 := new(strings8.Builder) + var v6 any = tmp5 + _ = v6 + var tmp7 any { // let - tmp7 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) - tmp8 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) - tmp9 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) - tmp10 := lang.Apply(tmp8, []any{tmp9, v5}) - tmp11 := lang.Apply(tmp7, []any{tmp10}) - _ = tmp11 - var tmp12 any + tmp8 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp9 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp10 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) + tmp11 := lang.Apply(tmp9, []any{tmp10, v6}) + tmp12 := lang.Apply(tmp8, []any{tmp11}) + _ = tmp12 + var tmp13 any func() { defer func() { - tmp13 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) - tmp14 := lang.Apply(tmp13, nil) - _ = tmp14 + tmp14 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp15 := lang.Apply(tmp14, nil) + _ = tmp15 }() - tmp15 := checkDerefVar(var_glojure_DOT_core_apply) - tmp16 := checkDerefVar(var_glojure_DOT_core_println) - tmp17 := lang.Apply(tmp15, []any{tmp16, v3}) - _ = tmp17 - tmp18 := checkDerefVar(var_glojure_DOT_core_str) - tmp19 := lang.Apply(tmp18, []any{v5}) - tmp12 = tmp19 + tmp16 := checkDerefVar(var_glojure_DOT_core_apply) + tmp17 := checkDerefVar(var_glojure_DOT_core_println) + tmp18 := lang.Apply(tmp16, []any{tmp17, v3}) + _ = tmp18 + tmp19 := checkDerefVar(var_glojure_DOT_core_str) + tmp20 := lang.Apply(tmp19, []any{v6}) + tmp13 = tmp20 }() - tmp6 = tmp12 + tmp7 = tmp13 } // end let - tmp4 = tmp6 + tmp4 = tmp7 } // end let return tmp4 } @@ -56230,41 +56242,42 @@ func LoadNS() { var v8 any = tmp7 _ = v8 // let binding "sw" - var v9 any = "unimplemented: new with non-constant class type" - _ = v9 - var tmp10 any + tmp9 := new(strings8.Builder) + var v10 any = tmp9 + _ = v10 + var tmp11 any { // let // let binding "r" - tmp11 := checkDerefVar(var_glojure_DOT_core_apply) - tmp12 := checkDerefVar(var_glojure_DOT_go_DOT_io_reader) - tmp13 := lang.Apply(tmp11, []any{tmp12, v3, v8}) - var v14 any = tmp13 - _ = v14 - var tmp15 any + tmp12 := checkDerefVar(var_glojure_DOT_core_apply) + tmp13 := checkDerefVar(var_glojure_DOT_go_DOT_io_reader) + tmp14 := lang.Apply(tmp12, []any{tmp13, v3, v8}) + var v15 any = tmp14 + _ = v15 + var tmp16 any func() { defer func() { - tmp16, ok := lang.FieldOrMethod(v14, "close") + tmp17, ok := lang.FieldOrMethod(v15, "close") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v14, "close"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v15, "close"))) } - var tmp17 any - switch reflect.TypeOf(tmp16).Kind() { + var tmp18 any + switch reflect.TypeOf(tmp17).Kind() { case reflect.Func: - tmp17 = lang.Apply(tmp16, nil) + tmp18 = lang.Apply(tmp17, nil) default: - tmp17 = tmp16 + tmp18 = tmp17 } - _ = tmp17 + _ = tmp18 }() - tmp18 := checkDerefVar(var_glojure_DOT_go_DOT_io_copy) - tmp19 := lang.Apply(tmp18, []any{v14, v9}) - _ = tmp19 - tmp20 := lang.Apply(lang.ToString, []any{v9}) - tmp15 = tmp20 + tmp19 := checkDerefVar(var_glojure_DOT_go_DOT_io_copy) + tmp20 := lang.Apply(tmp19, []any{v15, v10}) + _ = tmp20 + tmp21 := lang.Apply(lang.ToString, []any{v10}) + tmp16 = tmp21 }() - tmp10 = tmp15 + tmp11 = tmp16 } // end let - tmp5 = tmp10 + tmp5 = tmp11 } // end let return tmp5 } diff --git a/pkg/stdlib/glojure/core_deftype/loader.go b/pkg/stdlib/glojure/core_deftype/loader.go index 4def5f72..ba84d640 100644 --- a/pkg/stdlib/glojure/core_deftype/loader.go +++ b/pkg/stdlib/glojure/core_deftype/loader.go @@ -482,68 +482,22 @@ func LoadNS() { sym_glojure_DOT_core_SLASH_Array := lang.NewSymbol("glojure.core/Array") sym_glojure_DOT_core_SLASH_Aset := lang.NewSymbol("glojure.core/Aset") sym_glojure_DOT_core_SLASH_AssertionError := lang.NewSymbol("glojure.core/AssertionError") - sym_glojure_DOT_core_SLASH_BooleanArray := lang.NewSymbol("glojure.core/BooleanArray") sym_glojure_DOT_core_SLASH_BooleanCast := lang.NewSymbol("glojure.core/BooleanCast") - sym_glojure_DOT_core_SLASH_Booleans := lang.NewSymbol("glojure.core/Booleans") - sym_glojure_DOT_core_SLASH_ByteArray := lang.NewSymbol("glojure.core/ByteArray") - sym_glojure_DOT_core_SLASH_Bytes := lang.NewSymbol("glojure.core/Bytes") - sym_glojure_DOT_core_SLASH_CharArray := lang.NewSymbol("glojure.core/CharArray") - sym_glojure_DOT_core_SLASH_Chars := lang.NewSymbol("glojure.core/Chars") sym_glojure_DOT_core_SLASH_Count := lang.NewSymbol("glojure.core/Count") - sym_glojure_DOT_core_SLASH_DecP := lang.NewSymbol("glojure.core/DecP") - sym_glojure_DOT_core_SLASH_DoubleArray := lang.NewSymbol("glojure.core/DoubleArray") sym_glojure_DOT_core_SLASH_DoubleCast := lang.NewSymbol("glojure.core/DoubleCast") - sym_glojure_DOT_core_SLASH_Doubles := lang.NewSymbol("glojure.core/Doubles") - sym_glojure_DOT_core_SLASH_Equiv := lang.NewSymbol("glojure.core/Equiv") - sym_glojure_DOT_core_SLASH_FloatArray := lang.NewSymbol("glojure.core/FloatArray") - sym_glojure_DOT_core_SLASH_Floats := lang.NewSymbol("glojure.core/Floats") sym_glojure_DOT_core_SLASH_Get := lang.NewSymbol("glojure.core/Get") - sym_glojure_DOT_core_SLASH_Gt := lang.NewSymbol("glojure.core/Gt") - sym_glojure_DOT_core_SLASH_Gte := lang.NewSymbol("glojure.core/Gte") sym_glojure_DOT_core_SLASH_IllegalStateException := lang.NewSymbol("glojure.core/IllegalStateException") - sym_glojure_DOT_core_SLASH_IncP := lang.NewSymbol("glojure.core/IncP") - sym_glojure_DOT_core_SLASH_IntArray := lang.NewSymbol("glojure.core/IntArray") - sym_glojure_DOT_core_SLASH_Ints := lang.NewSymbol("glojure.core/Ints") - sym_glojure_DOT_core_SLASH_IsNeg := lang.NewSymbol("glojure.core/IsNeg") - sym_glojure_DOT_core_SLASH_IsPos := lang.NewSymbol("glojure.core/IsPos") - sym_glojure_DOT_core_SLASH_IsZero := lang.NewSymbol("glojure.core/IsZero") - sym_glojure_DOT_core_SLASH_LongArray := lang.NewSymbol("glojure.core/LongArray") sym_glojure_DOT_core_SLASH_LongCast := lang.NewSymbol("glojure.core/LongCast") - sym_glojure_DOT_core_SLASH_Longs := lang.NewSymbol("glojure.core/Longs") - sym_glojure_DOT_core_SLASH_Lt := lang.NewSymbol("glojure.core/Lt") - sym_glojure_DOT_core_SLASH_Lte := lang.NewSymbol("glojure.core/Lte") - sym_glojure_DOT_core_SLASH_Not := lang.NewSymbol("glojure.core/Not") sym_glojure_DOT_core_SLASH_Nth := lang.NewSymbol("glojure.core/Nth") - sym_glojure_DOT_core_SLASH_Num := lang.NewSymbol("glojure.core/Num") sym_glojure_DOT_core_SLASH_Object_array := lang.NewSymbol("glojure.core/Object_array") - sym_glojure_DOT_core_SLASH_Quotient := lang.NewSymbol("glojure.core/Quotient") - sym_glojure_DOT_core_SLASH_Remainder := lang.NewSymbol("glojure.core/Remainder") sym_glojure_DOT_core_SLASH_RunInTransaction := lang.NewSymbol("glojure.core/RunInTransaction") - sym_glojure_DOT_core_SLASH_ShiftLeft := lang.NewSymbol("glojure.core/ShiftLeft") - sym_glojure_DOT_core_SLASH_ShiftRight := lang.NewSymbol("glojure.core/ShiftRight") - sym_glojure_DOT_core_SLASH_ShortArray := lang.NewSymbol("glojure.core/ShortArray") - sym_glojure_DOT_core_SLASH_Shorts := lang.NewSymbol("glojure.core/Shorts") - sym_glojure_DOT_core_SLASH_UncheckedAdd := lang.NewSymbol("glojure.core/UncheckedAdd") sym_glojure_DOT_core_SLASH_UncheckedByteCast := lang.NewSymbol("glojure.core/UncheckedByteCast") sym_glojure_DOT_core_SLASH_UncheckedCharCast := lang.NewSymbol("glojure.core/UncheckedCharCast") - sym_glojure_DOT_core_SLASH_UncheckedDec := lang.NewSymbol("glojure.core/UncheckedDec") sym_glojure_DOT_core_SLASH_UncheckedDoubleCast := lang.NewSymbol("glojure.core/UncheckedDoubleCast") sym_glojure_DOT_core_SLASH_UncheckedFloatCast := lang.NewSymbol("glojure.core/UncheckedFloatCast") sym_glojure_DOT_core_SLASH_UncheckedIntCast := lang.NewSymbol("glojure.core/UncheckedIntCast") - sym_glojure_DOT_core_SLASH_UncheckedIntDivide := lang.NewSymbol("glojure.core/UncheckedIntDivide") sym_glojure_DOT_core_SLASH_UncheckedLongCast := lang.NewSymbol("glojure.core/UncheckedLongCast") sym_glojure_DOT_core_SLASH_UncheckedShortCast := lang.NewSymbol("glojure.core/UncheckedShortCast") - sym_glojure_DOT_core_SLASH_Unchecked_inc := lang.NewSymbol("glojure.core/Unchecked_inc") - sym_glojure_DOT_core_SLASH_Unchecked_int_add := lang.NewSymbol("glojure.core/Unchecked_int_add") - sym_glojure_DOT_core_SLASH_Unchecked_int_dec := lang.NewSymbol("glojure.core/Unchecked_int_dec") - sym_glojure_DOT_core_SLASH_Unchecked_int_inc := lang.NewSymbol("glojure.core/Unchecked_int_inc") - sym_glojure_DOT_core_SLASH_Unchecked_int_multiply := lang.NewSymbol("glojure.core/Unchecked_int_multiply") - sym_glojure_DOT_core_SLASH_Unchecked_int_negate := lang.NewSymbol("glojure.core/Unchecked_int_negate") - sym_glojure_DOT_core_SLASH_Unchecked_int_remainder := lang.NewSymbol("glojure.core/Unchecked_int_remainder") - sym_glojure_DOT_core_SLASH_Unchecked_int_subtract := lang.NewSymbol("glojure.core/Unchecked_int_subtract") - sym_glojure_DOT_core_SLASH_Unchecked_minus := lang.NewSymbol("glojure.core/Unchecked_minus") - sym_glojure_DOT_core_SLASH_Unchecked_multiply := lang.NewSymbol("glojure.core/Unchecked_multiply") - sym_glojure_DOT_core_SLASH_UnsignedShiftRight := lang.NewSymbol("glojure.core/UnsignedShiftRight") sym_glojure_DOT_core_SLASH_aclone := lang.NewSymbol("glojure.core/aclone") sym_glojure_DOT_core_SLASH_aget := lang.NewSymbol("glojure.core/aget") sym_glojure_DOT_core_SLASH_alength := lang.NewSymbol("glojure.core/alength") @@ -558,8 +512,14 @@ func LoadNS() { sym_glojure_DOT_core_SLASH_assoc_DASH_in := lang.NewSymbol("glojure.core/assoc-in") sym_glojure_DOT_core_SLASH_atom := lang.NewSymbol("glojure.core/atom") sym_glojure_DOT_core_SLASH_binding := lang.NewSymbol("glojure.core/binding") + sym_glojure_DOT_core_SLASH_booleanArray := lang.NewSymbol("glojure.core/booleanArray") + sym_glojure_DOT_core_SLASH_booleans := lang.NewSymbol("glojure.core/booleans") sym_glojure_DOT_core_SLASH_bound_DASH_fn_STAR_ := lang.NewSymbol("glojure.core/bound-fn*") + sym_glojure_DOT_core_SLASH_byteArray := lang.NewSymbol("glojure.core/byteArray") + sym_glojure_DOT_core_SLASH_bytes := lang.NewSymbol("glojure.core/bytes") sym_glojure_DOT_core_SLASH_c := lang.NewSymbol("glojure.core/c") + sym_glojure_DOT_core_SLASH_charArray := lang.NewSymbol("glojure.core/charArray") + sym_glojure_DOT_core_SLASH_chars := lang.NewSymbol("glojure.core/chars") sym_glojure_DOT_core_SLASH_chunk := lang.NewSymbol("glojure.core/chunk") sym_glojure_DOT_core_SLASH_chunk_DASH_append := lang.NewSymbol("glojure.core/chunk-append") sym_glojure_DOT_core_SLASH_chunk_DASH_buffer := lang.NewSymbol("glojure.core/chunk-buffer") @@ -577,19 +537,26 @@ func LoadNS() { sym_glojure_DOT_core_SLASH_cons := lang.NewSymbol("glojure.core/cons") sym_glojure_DOT_core_SLASH_count := lang.NewSymbol("glojure.core/count") sym_glojure_DOT_core_SLASH_create_DASH_struct := lang.NewSymbol("glojure.core/create-struct") + sym_glojure_DOT_core_SLASH_decP := lang.NewSymbol("glojure.core/decP") sym_glojure_DOT_core_SLASH_defmulti := lang.NewSymbol("glojure.core/defmulti") sym_glojure_DOT_core_SLASH_defn := lang.NewSymbol("glojure.core/defn") sym_glojure_DOT_core_SLASH_deref := lang.NewSymbol("glojure.core/deref") sym_glojure_DOT_core_SLASH_dosync := lang.NewSymbol("glojure.core/dosync") sym_glojure_DOT_core_SLASH_double := lang.NewSymbol("glojure.core/double") + sym_glojure_DOT_core_SLASH_doubleArray := lang.NewSymbol("glojure.core/doubleArray") + sym_glojure_DOT_core_SLASH_doubles := lang.NewSymbol("glojure.core/doubles") sym_glojure_DOT_core_SLASH_equiv := lang.NewSymbol("glojure.core/equiv") sym_glojure_DOT_core_SLASH_extend := lang.NewSymbol("glojure.core/extend") sym_glojure_DOT_core_SLASH_extend_DASH_type := lang.NewSymbol("glojure.core/extend-type") sym_glojure_DOT_core_SLASH_first := lang.NewSymbol("glojure.core/first") + sym_glojure_DOT_core_SLASH_floatArray := lang.NewSymbol("glojure.core/floatArray") + sym_glojure_DOT_core_SLASH_floats := lang.NewSymbol("glojure.core/floats") sym_glojure_DOT_core_SLASH_fn := lang.NewSymbol("glojure.core/fn") sym_glojure_DOT_core_SLASH_future_DASH_call := lang.NewSymbol("glojure.core/future-call") sym_glojure_DOT_core_SLASH_gen_DASH_class := lang.NewSymbol("glojure.core/gen-class") sym_glojure_DOT_core_SLASH_get := lang.NewSymbol("glojure.core/get") + sym_glojure_DOT_core_SLASH_gt := lang.NewSymbol("glojure.core/gt") + sym_glojure_DOT_core_SLASH_gte := lang.NewSymbol("glojure.core/gte") sym_glojure_DOT_core_SLASH_hash_DASH_map := lang.NewSymbol("glojure.core/hash-map") sym_glojure_DOT_core_SLASH_i := lang.NewSymbol("glojure.core/i") sym_glojure_DOT_core_SLASH_identical := lang.NewSymbol("glojure.core/identical") @@ -597,13 +564,23 @@ func LoadNS() { sym_glojure_DOT_core_SLASH_if_DASH_not := lang.NewSymbol("glojure.core/if-not") sym_glojure_DOT_core_SLASH_if_DASH_some := lang.NewSymbol("glojure.core/if-some") sym_glojure_DOT_core_SLASH_in_DASH_ns := lang.NewSymbol("glojure.core/in-ns") + sym_glojure_DOT_core_SLASH_incP := lang.NewSymbol("glojure.core/incP") sym_glojure_DOT_core_SLASH_instance_QMARK_ := lang.NewSymbol("glojure.core/instance?") sym_glojure_DOT_core_SLASH_int := lang.NewSymbol("glojure.core/int") + sym_glojure_DOT_core_SLASH_intArray := lang.NewSymbol("glojure.core/intArray") + sym_glojure_DOT_core_SLASH_ints := lang.NewSymbol("glojure.core/ints") + sym_glojure_DOT_core_SLASH_isNeg := lang.NewSymbol("glojure.core/isNeg") + sym_glojure_DOT_core_SLASH_isPos := lang.NewSymbol("glojure.core/isPos") + sym_glojure_DOT_core_SLASH_isZero := lang.NewSymbol("glojure.core/isZero") sym_glojure_DOT_core_SLASH_keyword := lang.NewSymbol("glojure.core/keyword") sym_glojure_DOT_core_SLASH_lazy_DASH_seq := lang.NewSymbol("glojure.core/lazy-seq") sym_glojure_DOT_core_SLASH_let := lang.NewSymbol("glojure.core/let") sym_glojure_DOT_core_SLASH_long := lang.NewSymbol("glojure.core/long") + sym_glojure_DOT_core_SLASH_longArray := lang.NewSymbol("glojure.core/longArray") + sym_glojure_DOT_core_SLASH_longs := lang.NewSymbol("glojure.core/longs") sym_glojure_DOT_core_SLASH_loop := lang.NewSymbol("glojure.core/loop") + sym_glojure_DOT_core_SLASH_lt := lang.NewSymbol("glojure.core/lt") + sym_glojure_DOT_core_SLASH_lte := lang.NewSymbol("glojure.core/lte") sym_glojure_DOT_core_SLASH_merge := lang.NewSymbol("glojure.core/merge") sym_glojure_DOT_core_SLASH_meta := lang.NewSymbol("glojure.core/meta") sym_glojure_DOT_core_SLASH_next := lang.NewSymbol("glojure.core/next") @@ -611,24 +588,45 @@ func LoadNS() { sym_glojure_DOT_core_SLASH_nil_QMARK_ := lang.NewSymbol("glojure.core/nil?") sym_glojure_DOT_core_SLASH_not := lang.NewSymbol("glojure.core/not") sym_glojure_DOT_core_SLASH_nth := lang.NewSymbol("glojure.core/nth") + sym_glojure_DOT_core_SLASH_num := lang.NewSymbol("glojure.core/num") sym_glojure_DOT_core_SLASH_or := lang.NewSymbol("glojure.core/or") sym_glojure_DOT_core_SLASH_pcalls := lang.NewSymbol("glojure.core/pcalls") sym_glojure_DOT_core_SLASH_pop_DASH_thread_DASH_bindings := lang.NewSymbol("glojure.core/pop-thread-bindings") sym_glojure_DOT_core_SLASH_pr_DASH_str := lang.NewSymbol("glojure.core/pr-str") sym_glojure_DOT_core_SLASH_prn := lang.NewSymbol("glojure.core/prn") sym_glojure_DOT_core_SLASH_push_DASH_thread_DASH_bindings := lang.NewSymbol("glojure.core/push-thread-bindings") + sym_glojure_DOT_core_SLASH_quotient := lang.NewSymbol("glojure.core/quotient") sym_glojure_DOT_core_SLASH_refer := lang.NewSymbol("glojure.core/refer") + sym_glojure_DOT_core_SLASH_remainder := lang.NewSymbol("glojure.core/remainder") sym_glojure_DOT_core_SLASH_rest := lang.NewSymbol("glojure.core/rest") sym_glojure_DOT_core_SLASH_seq := lang.NewSymbol("glojure.core/seq") sym_glojure_DOT_core_SLASH_seq_QMARK_ := lang.NewSymbol("glojure.core/seq?") + sym_glojure_DOT_core_SLASH_shiftLeft := lang.NewSymbol("glojure.core/shiftLeft") + sym_glojure_DOT_core_SLASH_shiftRight := lang.NewSymbol("glojure.core/shiftRight") + sym_glojure_DOT_core_SLASH_shortArray := lang.NewSymbol("glojure.core/shortArray") + sym_glojure_DOT_core_SLASH_shorts := lang.NewSymbol("glojure.core/shorts") sym_glojure_DOT_core_SLASH_str := lang.NewSymbol("glojure.core/str") sym_glojure_DOT_core_SLASH_swap_BANG_ := lang.NewSymbol("glojure.core/swap!") sym_glojure_DOT_core_SLASH_sync := lang.NewSymbol("glojure.core/sync") sym_glojure_DOT_core_SLASH_to_DASH_array := lang.NewSymbol("glojure.core/to-array") sym_glojure_DOT_core_SLASH_unchecked_DASH_inc := lang.NewSymbol("glojure.core/unchecked-inc") sym_glojure_DOT_core_SLASH_unchecked_DASH_inc_DASH_int := lang.NewSymbol("glojure.core/unchecked-inc-int") + sym_glojure_DOT_core_SLASH_unchecked_add := lang.NewSymbol("glojure.core/unchecked_add") + sym_glojure_DOT_core_SLASH_unchecked_dec := lang.NewSymbol("glojure.core/unchecked_dec") + sym_glojure_DOT_core_SLASH_unchecked_inc := lang.NewSymbol("glojure.core/unchecked_inc") + sym_glojure_DOT_core_SLASH_unchecked_int_add := lang.NewSymbol("glojure.core/unchecked_int_add") + sym_glojure_DOT_core_SLASH_unchecked_int_dec := lang.NewSymbol("glojure.core/unchecked_int_dec") + sym_glojure_DOT_core_SLASH_unchecked_int_divide := lang.NewSymbol("glojure.core/unchecked_int_divide") + sym_glojure_DOT_core_SLASH_unchecked_int_inc := lang.NewSymbol("glojure.core/unchecked_int_inc") + sym_glojure_DOT_core_SLASH_unchecked_int_multiply := lang.NewSymbol("glojure.core/unchecked_int_multiply") + sym_glojure_DOT_core_SLASH_unchecked_int_negate := lang.NewSymbol("glojure.core/unchecked_int_negate") + sym_glojure_DOT_core_SLASH_unchecked_int_remainder := lang.NewSymbol("glojure.core/unchecked_int_remainder") + sym_glojure_DOT_core_SLASH_unchecked_int_subtract := lang.NewSymbol("glojure.core/unchecked_int_subtract") + sym_glojure_DOT_core_SLASH_unchecked_minus := lang.NewSymbol("glojure.core/unchecked_minus") + sym_glojure_DOT_core_SLASH_unchecked_multiply := lang.NewSymbol("glojure.core/unchecked_multiply") sym_glojure_DOT_core_SLASH_unquote := lang.NewSymbol("glojure.core/unquote") sym_glojure_DOT_core_SLASH_unquote_DASH_splicing := lang.NewSymbol("glojure.core/unquote-splicing") + sym_glojure_DOT_core_SLASH_unsignedShiftRight := lang.NewSymbol("glojure.core/unsignedShiftRight") sym_glojure_DOT_core_SLASH_when := lang.NewSymbol("glojure.core/when") sym_glojure_DOT_core_SLASH_when_DASH_first := lang.NewSymbol("glojure.core/when-first") sym_glojure_DOT_core_SLASH_when_DASH_let := lang.NewSymbol("glojure.core/when-let") @@ -2877,7 +2875,7 @@ func LoadNS() { if reflect.TypeOf(tmp3).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp4 := lang.Apply(tmp3, []any{nil, int64(0)}) + tmp4 := lang.Apply(tmp3, []any{v2, int64(0)}) return tmp4 }) tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -2898,7 +2896,7 @@ func LoadNS() { if reflect.TypeOf(tmp3).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp4 := lang.Apply(tmp3, []any{nil, int64(1)}) + tmp4 := lang.Apply(tmp3, []any{v2, int64(1)}) return tmp4 }) tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -3168,12 +3166,8 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - tmp4, _ := lang.FieldOrMethod(nil, "getAccessor") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("getAccessor is not a function"))) - } - tmp5 := lang.Apply(tmp4, []any{v2, v3}) - return tmp5 + tmp4 := lang.Apply(lang.GetPersistentStructMapAccessor, []any{v2, v3}) + return tmp4 }) tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) var_glojure_DOT_core_accessor = ns.InternWithValue(tmp0, tmp1, true) @@ -3377,9 +3371,9 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "ClearBit") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "clearBit") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ClearBit is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("clearBit is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v2, v3}) return tmp5 @@ -3400,9 +3394,9 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "FlipBit") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "flipBit") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("FlipBit is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("flipBit is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v2, v3}) return tmp5 @@ -3423,9 +3417,9 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "SetBit") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "setBit") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("SetBit is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setBit is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v2, v3}) return tmp5 @@ -3446,9 +3440,9 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "TestBit") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "testBit") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("TestBit is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("testBit is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v2, v3}) return tmp5 @@ -5609,9 +5603,9 @@ func LoadNS() { checkArity(args, 1) v2 := args[0] _ = v2 - tmp3, _ := lang.FieldOrMethod(lang.Numbers, "Rationalize") + tmp3, _ := lang.FieldOrMethod(lang.Numbers, "rationalize") if reflect.TypeOf(tmp3).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Rationalize is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("rationalize is not a function"))) } tmp4 := lang.Apply(tmp3, []any{v2}) return tmp4 @@ -6298,7 +6292,7 @@ func LoadNS() { checkArity(args, 1) v2 := args[0] _ = v2 - return nil + return "unimplemented: set! target type" }) tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) var_glojure_DOT_core_set_DASH_agent_DASH_send_DASH_executor_BANG_ = ns.InternWithValue(tmp0, tmp1, true) @@ -6314,7 +6308,7 @@ func LoadNS() { checkArity(args, 1) v2 := args[0] _ = v2 - return nil + return "unimplemented: set! target type" }) tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) var_glojure_DOT_core_set_DASH_agent_DASH_send_DASH_off_DASH_executor_BANG_ = ns.InternWithValue(tmp0, tmp1, true) @@ -6801,10 +6795,11 @@ func LoadNS() { if err != nil { panic(err) } - tmp8 := checkDerefVar(var_glojure_DOT_core_cons) - tmp9 := lang.Apply(tmp8, []any{v3, v4}) - tmp10 := lang.Apply(tmp7, []any{"unimplemented: new with non-constant class type", tmp9}) - return tmp10 + tmp8 := new(strings8.Builder) + tmp9 := checkDerefVar(var_glojure_DOT_core_cons) + tmp10 := lang.Apply(tmp9, []any{v3, v4}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10}) + return tmp11 } }) tmp3 := reflect.TypeOf("") @@ -8929,9 +8924,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Dec") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "dec") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Dec is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("dec is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -8961,7 +8956,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_DecP}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_decP}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -8980,9 +8975,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "DecP") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "decP") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("DecP is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("decP is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -9557,7 +9552,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_DoubleArray}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_doubleArray}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := checkDerefVar(var_glojure_DOT_core_seq) tmp14 := checkDerefVar(var_glojure_DOT_core_concat) @@ -9583,9 +9578,9 @@ func LoadNS() { case 1: v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "DoubleArray") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "doubleArray") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("DoubleArray is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("doubleArray is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -9594,9 +9589,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "DoubleArrayInit") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "doubleArrayInit") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("DoubleArrayInit is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("doubleArrayInit is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -9645,7 +9640,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Doubles}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_doubles}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := lang.Apply(tmp12, []any{v3}) tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) @@ -9661,9 +9656,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Doubles") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "doubles") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Doubles is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("doubles is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -10267,7 +10262,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_FloatArray}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_floatArray}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := checkDerefVar(var_glojure_DOT_core_seq) tmp14 := checkDerefVar(var_glojure_DOT_core_concat) @@ -10293,9 +10288,9 @@ func LoadNS() { case 1: v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "FloatArray") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "floatArray") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("FloatArray is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("floatArray is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -10304,9 +10299,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "FloatArrayInit") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "floatArrayInit") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("FloatArrayInit is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("floatArrayInit is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -10370,7 +10365,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Floats}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_floats}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := lang.Apply(tmp12, []any{v3}) tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) @@ -10386,9 +10381,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Floats") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "floats") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Floats is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("floats is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -10898,9 +10893,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Inc") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "inc") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Inc is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("inc is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -10930,7 +10925,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_IncP}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_incP}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -10949,9 +10944,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "IncP") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "incP") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("IncP is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("incP is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -11093,7 +11088,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_IntArray}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_intArray}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := checkDerefVar(var_glojure_DOT_core_seq) tmp14 := checkDerefVar(var_glojure_DOT_core_concat) @@ -11119,9 +11114,9 @@ func LoadNS() { case 1: v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "IntArray") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "intArray") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("IntArray is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("intArray is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -11130,9 +11125,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "IntArrayInit") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "intArrayInit") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("IntArrayInit is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("intArrayInit is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -11277,7 +11272,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Ints}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_ints}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := lang.Apply(tmp12, []any{v3}) tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) @@ -11293,9 +11288,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Ints") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "ints") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Ints is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ints is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -11845,7 +11840,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_LongArray}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_longArray}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := checkDerefVar(var_glojure_DOT_core_seq) tmp14 := checkDerefVar(var_glojure_DOT_core_concat) @@ -11871,9 +11866,9 @@ func LoadNS() { case 1: v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "LongArray") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "longArray") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("LongArray is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("longArray is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -11882,9 +11877,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "LongArrayInit") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "longArrayInit") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("LongArrayInit is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("longArrayInit is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -11915,7 +11910,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Longs}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_longs}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := lang.Apply(tmp12, []any{v3}) tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) @@ -11931,9 +11926,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Longs") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "longs") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Longs is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("longs is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -12254,7 +12249,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_IsNeg}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_isNeg}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -12273,9 +12268,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "IsNeg") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "isNeg") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("IsNeg is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("isNeg is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -12618,7 +12613,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Num}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_num}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -12637,9 +12632,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Num") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "num") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Num is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("num is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -12872,7 +12867,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_IsPos}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_isPos}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -12891,9 +12886,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "IsPos") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "isPos") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("IsPos is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("isPos is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -12997,7 +12992,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Quotient}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_quotient}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -13020,9 +13015,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Quotient") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "quotient") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Quotient is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("quotient is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -13512,7 +13507,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Remainder}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_remainder}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -13535,9 +13530,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Remainder") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "remainder") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Remainder is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("remainder is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -13894,7 +13889,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_ShortArray}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_shortArray}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := checkDerefVar(var_glojure_DOT_core_seq) tmp14 := checkDerefVar(var_glojure_DOT_core_concat) @@ -13920,9 +13915,9 @@ func LoadNS() { case 1: v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "ShortArray") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "shortArray") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ShortArray is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("shortArray is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -13931,9 +13926,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "ShortArrayInit") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "shortArrayInit") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ShortArrayInit is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("shortArrayInit is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -13964,7 +13959,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Shorts}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_shorts}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := lang.Apply(tmp12, []any{v3}) tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) @@ -13980,9 +13975,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Shorts") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "shorts") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Shorts is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("shorts is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -15548,7 +15543,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_UncheckedAdd}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_unchecked_add}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -15571,9 +15566,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedAdd") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_add") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedAdd is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_add is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -15605,7 +15600,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_add}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_unchecked_int_add}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -15628,9 +15623,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_add") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_int_add") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_add is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_add is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -15758,7 +15753,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedDec}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_unchecked_dec}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -15777,9 +15772,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedDec") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_dec") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedDec is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_dec is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -15809,7 +15804,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_dec}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_unchecked_int_dec}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -15828,9 +15823,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_dec") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_int_dec") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_dec is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_dec is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -15862,7 +15857,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_UncheckedIntDivide}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_unchecked_int_divide}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -15885,9 +15880,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedIntDivide") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_int_divide") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedIntDivide is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_divide is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -16011,7 +16006,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Unchecked_inc}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_unchecked_inc}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -16030,9 +16025,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_inc") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_inc") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_inc is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_inc is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -16062,7 +16057,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_inc}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_unchecked_int_inc}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -16081,9 +16076,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_inc") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_int_inc") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_inc is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_inc is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -16209,7 +16204,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_multiply}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_unchecked_multiply}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -16232,9 +16227,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_multiply") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_multiply") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_multiply is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_multiply is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -16266,7 +16261,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_multiply}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_unchecked_int_multiply}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -16289,9 +16284,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_multiply") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_int_multiply") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_multiply is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_multiply is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -16321,7 +16316,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Unchecked_minus}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_unchecked_minus}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -16372,7 +16367,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_negate}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_unchecked_int_negate}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -16391,9 +16386,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_negate") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_int_negate") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_negate is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_negate is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -16425,7 +16420,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_remainder}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_unchecked_int_remainder}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -16448,9 +16443,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_remainder") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_int_remainder") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_remainder is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_remainder is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -16529,7 +16524,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_minus}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_unchecked_minus}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -16552,9 +16547,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_minus") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_minus") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_minus is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_minus is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -16586,7 +16581,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_subtract}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_unchecked_int_subtract}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -16609,9 +16604,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_subtract") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_int_subtract") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_subtract is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_subtract is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -16669,7 +16664,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_UnsignedShiftRight}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_unsignedShiftRight}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -16692,9 +16687,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "UnsignedShiftRight") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "unsignedShiftRight") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("UnsignedShiftRight is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unsignedShiftRight is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -16829,7 +16824,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_IsZero}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_isZero}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -16848,9 +16843,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "IsZero") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "isZero") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("IsZero is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("isZero is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -17404,7 +17399,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Equiv}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_equiv}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -17432,9 +17427,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Equiv") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "equiv") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Equiv is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("equiv is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -17507,7 +17502,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Gt}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_gt}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -17535,9 +17530,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "gt") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("gt is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -17610,7 +17605,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Gte}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_gte}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -17638,9 +17633,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Gte") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "gte") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gte is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("gte is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -17713,7 +17708,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Lt}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_lt}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -17741,9 +17736,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Lt") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "lt") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Lt is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("lt is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -17816,7 +17811,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Lte}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_lte}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -17844,9 +17839,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Lte") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "lte") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Lte is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("lte is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -18070,7 +18065,7 @@ func LoadNS() { if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + tmp5 := lang.Apply(tmp4, []any{v3, int64(1)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -18090,9 +18085,9 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Add") + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "add") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Add is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) } tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 @@ -18290,7 +18285,7 @@ func LoadNS() { if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + tmp5 := lang.Apply(tmp4, []any{v3, int64(1)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -18310,9 +18305,9 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "AddP") + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "addP") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("AddP is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("addP is not a function"))) } tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 @@ -18510,7 +18505,7 @@ func LoadNS() { if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + tmp5 := lang.Apply(tmp4, []any{v3, int64(1)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -18529,9 +18524,9 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Divide") + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "divide") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Divide is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("divide is not a function"))) } tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 @@ -18729,7 +18724,7 @@ func LoadNS() { if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + tmp5 := lang.Apply(tmp4, []any{v3, int64(1)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -18749,9 +18744,9 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Multiply") + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "multiply") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Multiply is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("multiply is not a function"))) } tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 @@ -18949,7 +18944,7 @@ func LoadNS() { if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + tmp5 := lang.Apply(tmp4, []any{v3, int64(1)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -18969,9 +18964,9 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "MultiplyP") + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "multiplyP") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("MultiplyP is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("multiplyP is not a function"))) } tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 @@ -20365,7 +20360,7 @@ func LoadNS() { if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + tmp5 := lang.Apply(tmp4, []any{v3, int64(1)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -20378,9 +20373,9 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "And") + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "and") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("And is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("and is not a function"))) } tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 @@ -20578,7 +20573,7 @@ func LoadNS() { if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + tmp5 := lang.Apply(tmp4, []any{v3, int64(1)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -20591,9 +20586,9 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "AndNot") + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "andNot") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("AndNot is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("andNot is not a function"))) } tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 @@ -20638,7 +20633,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Not}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_not}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -20657,9 +20652,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Not") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "not") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Not is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("not is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -20842,7 +20837,7 @@ func LoadNS() { if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + tmp5 := lang.Apply(tmp4, []any{v3, int64(1)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -20855,9 +20850,9 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Or") + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "or") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Or is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("or is not a function"))) } tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 @@ -20904,7 +20899,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_ShiftLeft}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_shiftLeft}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -20927,9 +20922,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "ShiftLeft") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "shiftLeft") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ShiftLeft is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("shiftLeft is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -20961,7 +20956,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_ShiftRight}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_shiftRight}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -20984,9 +20979,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "ShiftRight") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "shiftRight") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ShiftRight is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("shiftRight is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -21169,7 +21164,7 @@ func LoadNS() { if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + tmp5 := lang.Apply(tmp4, []any{v3, int64(1)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -21182,9 +21177,9 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Xor") + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "xor") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Xor is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("xor is not a function"))) } tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 @@ -21279,7 +21274,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_BooleanArray}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_booleanArray}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := checkDerefVar(var_glojure_DOT_core_seq) tmp14 := checkDerefVar(var_glojure_DOT_core_concat) @@ -21305,9 +21300,9 @@ func LoadNS() { case 1: v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "BooleanArray") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "booleanArray") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("BooleanArray is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("booleanArray is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -21316,9 +21311,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "BooleanArrayInit") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "booleanArrayInit") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("BooleanArrayInit is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("booleanArrayInit is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -21349,7 +21344,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Booleans}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_booleans}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := lang.Apply(tmp12, []any{v3}) tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) @@ -21365,9 +21360,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Booleans") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "booleans") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Booleans is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("booleans is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -21663,7 +21658,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_ByteArray}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_byteArray}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := checkDerefVar(var_glojure_DOT_core_seq) tmp14 := checkDerefVar(var_glojure_DOT_core_concat) @@ -21689,9 +21684,9 @@ func LoadNS() { case 1: v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "ByteArray") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "byteArray") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ByteArray is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("byteArray is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -21700,9 +21695,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "ByteArrayInit") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "byteArrayInit") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ByteArrayInit is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("byteArrayInit is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -21733,7 +21728,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Bytes}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_bytes}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := lang.Apply(tmp12, []any{v3}) tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) @@ -21749,9 +21744,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Bytes") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "bytes") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Bytes is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("bytes is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -21877,7 +21872,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_CharArray}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_charArray}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := checkDerefVar(var_glojure_DOT_core_seq) tmp14 := checkDerefVar(var_glojure_DOT_core_concat) @@ -21903,9 +21898,9 @@ func LoadNS() { case 1: v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "CharArray") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "charArray") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("CharArray is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("charArray is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -21914,9 +21909,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "CharArrayInit") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "charArrayInit") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("CharArrayInit is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("charArrayInit is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -21947,7 +21942,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Chars}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_chars}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := lang.Apply(tmp12, []any{v3}) tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) @@ -21963,9 +21958,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Chars") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "chars") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Chars is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("chars is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -27747,7 +27742,7 @@ func LoadNS() { if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + tmp5 := lang.Apply(tmp4, []any{v3, int64(1)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -27764,9 +27759,9 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Max") + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "max") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Max is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("max is not a function"))) } tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 @@ -28375,7 +28370,7 @@ func LoadNS() { if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + tmp5 := lang.Apply(tmp4, []any{v3, int64(1)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -28392,9 +28387,9 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Min") + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "min") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Min is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("min is not a function"))) } tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 @@ -29674,6 +29669,17 @@ func LoadNS() { // let binding "G__691" var v7 any = v2 _ = v7 + // case + var tmp8 any + // case clause 0 + if lang.Equals(v7, "true") { + tmp8 = true + // case clause 1 + } else if lang.Equals(v7, "false") { + tmp8 = false + } else { + } + tmp6 = tmp8 } // end let tmp3 = tmp6 } else { @@ -30006,198 +30012,199 @@ func LoadNS() { var tmp5 any { // let // let binding "a" - var v6 any = "unimplemented: new with non-constant class type" - _ = v6 + tmp6 := new(lang.ArrayList) + var v7 any = tmp6 + _ = v7 // let binding "pv" - tmp7 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) - tmp8 := lang.Apply(tmp7, []any{kw_glojure_DOT_core_SLASH_none}) - var v9 any = tmp8 - _ = v9 - var tmp10 lang.FnFunc - tmp10 = lang.NewFnFunc(func(args ...any) any { + tmp8 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) + tmp9 := lang.Apply(tmp8, []any{kw_glojure_DOT_core_SLASH_none}) + var v10 any = tmp9 + _ = v10 + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - tmp11 := lang.Apply(v4, nil) - return tmp11 + tmp12 := lang.Apply(v4, nil) + return tmp12 case 1: - v11 := args[0] - _ = v11 - var tmp12 any + v12 := args[0] + _ = v12 + var tmp13 any { // let // let binding "result" - var tmp13 any - tmp14, ok := lang.FieldOrMethod(v6, "isEmpty") + var tmp14 any + tmp15, ok := lang.FieldOrMethod(v7, "isEmpty") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "isEmpty"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "isEmpty"))) } - var tmp15 any - switch reflect.TypeOf(tmp14).Kind() { + var tmp16 any + switch reflect.TypeOf(tmp15).Kind() { case reflect.Func: - tmp15 = lang.Apply(tmp14, nil) + tmp16 = lang.Apply(tmp15, nil) default: - tmp15 = tmp14 + tmp16 = tmp15 } - if lang.IsTruthy(tmp15) { - tmp13 = v11 + if lang.IsTruthy(tmp16) { + tmp14 = v12 } else { - var tmp16 any + var tmp17 any { // let // let binding "v" - tmp17 := checkDerefVar(var_glojure_DOT_core_vec) - tmp18, ok := lang.FieldOrMethod(v6, "toArray") + tmp18 := checkDerefVar(var_glojure_DOT_core_vec) + tmp19, ok := lang.FieldOrMethod(v7, "toArray") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "toArray"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "toArray"))) } - var tmp19 any - switch reflect.TypeOf(tmp18).Kind() { + var tmp20 any + switch reflect.TypeOf(tmp19).Kind() { case reflect.Func: - tmp19 = lang.Apply(tmp18, nil) + tmp20 = lang.Apply(tmp19, nil) default: - tmp19 = tmp18 + tmp20 = tmp19 } - tmp20 := lang.Apply(tmp17, []any{tmp19}) - var v21 any = tmp20 - _ = v21 - tmp22, ok := lang.FieldOrMethod(v6, "clear") + tmp21 := lang.Apply(tmp18, []any{tmp20}) + var v22 any = tmp21 + _ = v22 + tmp23, ok := lang.FieldOrMethod(v7, "clear") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "clear"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "clear"))) } - var tmp23 any - switch reflect.TypeOf(tmp22).Kind() { + var tmp24 any + switch reflect.TypeOf(tmp23).Kind() { case reflect.Func: - tmp23 = lang.Apply(tmp22, nil) + tmp24 = lang.Apply(tmp23, nil) default: - tmp23 = tmp22 + tmp24 = tmp23 } - _ = tmp23 - tmp24 := checkDerefVar(var_glojure_DOT_core_unreduced) - tmp25 := lang.Apply(v4, []any{v11, v21}) - tmp26 := lang.Apply(tmp24, []any{tmp25}) - tmp16 = tmp26 + _ = tmp24 + tmp25 := checkDerefVar(var_glojure_DOT_core_unreduced) + tmp26 := lang.Apply(v4, []any{v12, v22}) + tmp27 := lang.Apply(tmp25, []any{tmp26}) + tmp17 = tmp27 } // end let - tmp13 = tmp16 + tmp14 = tmp17 } - var v17 any = tmp13 - _ = v17 - tmp18 := lang.Apply(v4, []any{v17}) - tmp12 = tmp18 + var v18 any = tmp14 + _ = v18 + tmp19 := lang.Apply(v4, []any{v18}) + tmp13 = tmp19 } // end let - return tmp12 + return tmp13 case 2: - v11 := args[0] - _ = v11 - v12 := args[1] + v12 := args[0] _ = v12 - var tmp13 any + v13 := args[1] + _ = v13 + var tmp14 any { // let // let binding "pval" - tmp14 := checkDerefVar(var_glojure_DOT_core_deref) - tmp15 := lang.Apply(tmp14, []any{v9}) - var v16 any = tmp15 - _ = v16 + tmp15 := checkDerefVar(var_glojure_DOT_core_deref) + tmp16 := lang.Apply(tmp15, []any{v10}) + var v17 any = tmp16 + _ = v17 // let binding "val" - tmp17 := lang.Apply(v2, []any{v12}) - var v18 any = tmp17 - _ = v18 - tmp19 := checkDerefVar(var_glojure_DOT_core_vreset_BANG_) - tmp20 := lang.Apply(tmp19, []any{v9, v18}) - _ = tmp20 - var tmp21 any + tmp18 := lang.Apply(v2, []any{v13}) + var v19 any = tmp18 + _ = v19 + tmp20 := checkDerefVar(var_glojure_DOT_core_vreset_BANG_) + tmp21 := lang.Apply(tmp20, []any{v10, v19}) + _ = tmp21 var tmp22 any + var tmp23 any { // let // let binding "or__0__auto__" - tmp23 := checkDerefVar(var_glojure_DOT_core_identical_QMARK_) - tmp24 := lang.Apply(tmp23, []any{v16, kw_glojure_DOT_core_SLASH_none}) - var v25 any = tmp24 - _ = v25 - var tmp26 any - if lang.IsTruthy(v25) { - tmp26 = v25 + tmp24 := checkDerefVar(var_glojure_DOT_core_identical_QMARK_) + tmp25 := lang.Apply(tmp24, []any{v17, kw_glojure_DOT_core_SLASH_none}) + var v26 any = tmp25 + _ = v26 + var tmp27 any + if lang.IsTruthy(v26) { + tmp27 = v26 } else { - tmp27 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp28 := lang.Apply(tmp27, []any{v18, v16}) - tmp26 = tmp28 + tmp28 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp29 := lang.Apply(tmp28, []any{v19, v17}) + tmp27 = tmp29 } - tmp22 = tmp26 + tmp23 = tmp27 } // end let - if lang.IsTruthy(tmp22) { - tmp23, _ := lang.FieldOrMethod(v6, "add") - if reflect.TypeOf(tmp23).Kind() != reflect.Func { + if lang.IsTruthy(tmp23) { + tmp24, _ := lang.FieldOrMethod(v7, "add") + if reflect.TypeOf(tmp24).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) } - tmp24 := lang.Apply(tmp23, []any{v12}) - _ = tmp24 - tmp21 = v11 + tmp25 := lang.Apply(tmp24, []any{v13}) + _ = tmp25 + tmp22 = v12 } else { - var tmp25 any + var tmp26 any { // let // let binding "v" - tmp26 := checkDerefVar(var_glojure_DOT_core_vec) - tmp27, ok := lang.FieldOrMethod(v6, "toArray") + tmp27 := checkDerefVar(var_glojure_DOT_core_vec) + tmp28, ok := lang.FieldOrMethod(v7, "toArray") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "toArray"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "toArray"))) } - var tmp28 any - switch reflect.TypeOf(tmp27).Kind() { + var tmp29 any + switch reflect.TypeOf(tmp28).Kind() { case reflect.Func: - tmp28 = lang.Apply(tmp27, nil) + tmp29 = lang.Apply(tmp28, nil) default: - tmp28 = tmp27 + tmp29 = tmp28 } - tmp29 := lang.Apply(tmp26, []any{tmp28}) - var v30 any = tmp29 - _ = v30 - tmp31, ok := lang.FieldOrMethod(v6, "clear") + tmp30 := lang.Apply(tmp27, []any{tmp29}) + var v31 any = tmp30 + _ = v31 + tmp32, ok := lang.FieldOrMethod(v7, "clear") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "clear"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "clear"))) } - var tmp32 any - switch reflect.TypeOf(tmp31).Kind() { + var tmp33 any + switch reflect.TypeOf(tmp32).Kind() { case reflect.Func: - tmp32 = lang.Apply(tmp31, nil) + tmp33 = lang.Apply(tmp32, nil) default: - tmp32 = tmp31 + tmp33 = tmp32 } - _ = tmp32 - var tmp33 any + _ = tmp33 + var tmp34 any { // let // let binding "ret" - tmp34 := lang.Apply(v4, []any{v11, v30}) - var v35 any = tmp34 - _ = v35 - var tmp36 any - tmp37 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) - tmp38 := lang.Apply(tmp37, []any{v35}) - if lang.IsTruthy(tmp38) { + tmp35 := lang.Apply(v4, []any{v12, v31}) + var v36 any = tmp35 + _ = v36 + var tmp37 any + tmp38 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) + tmp39 := lang.Apply(tmp38, []any{v36}) + if lang.IsTruthy(tmp39) { } else { - tmp39, _ := lang.FieldOrMethod(v6, "add") - if reflect.TypeOf(tmp39).Kind() != reflect.Func { + tmp40, _ := lang.FieldOrMethod(v7, "add") + if reflect.TypeOf(tmp40).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) } - tmp40 := lang.Apply(tmp39, []any{v12}) - tmp36 = tmp40 + tmp41 := lang.Apply(tmp40, []any{v13}) + tmp37 = tmp41 } - _ = tmp36 - tmp33 = v35 + _ = tmp37 + tmp34 = v36 } // end let - tmp25 = tmp33 + tmp26 = tmp34 } // end let - tmp21 = tmp25 + tmp22 = tmp26 } - tmp13 = tmp21 + tmp14 = tmp22 } // end let - return tmp13 + return tmp14 default: checkArity(args, -1) panic("unreachable") } }) - tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7152), kw_column, int(7), kw_end_DASH_line, int(7176), kw_end_DASH_column, int(28)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7152), kw_column, int(7), kw_end_DASH_line, int(7176), kw_end_DASH_column, int(28)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp5 = tmp12 + tmp5 = tmp13 } // end let return tmp5 }) @@ -31680,30 +31687,30 @@ func LoadNS() { var tmp50 any if lang.IsTruthy(v49) { } else { - panic("unimplemented: new with non-constant class type") + panic(nil) } _ = tmp50 - tmp51 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) - var tmp52 any + tmp52 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + var tmp53 any { // let // let binding "or__0__auto__" - tmp53 := lang.Apply(v15, []any{v44}) - var v54 any = tmp53 - _ = v54 - var tmp55 any - if lang.IsTruthy(v54) { - tmp55 = v54 + tmp54 := lang.Apply(v15, []any{v44}) + var v55 any = tmp54 + _ = v55 + var tmp56 any + if lang.IsTruthy(v55) { + tmp56 = v55 } else { - tmp55 = v44 + tmp56 = v44 } - tmp52 = tmp55 + tmp53 = tmp56 } // end let - tmp53, _ := lang.FieldOrMethod(tmp51, "Refer") - if reflect.TypeOf(tmp53).Kind() != reflect.Func { + tmp54, _ := lang.FieldOrMethod(tmp52, "Refer") + if reflect.TypeOf(tmp54).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Refer is not a function"))) } - tmp54 := lang.Apply(tmp53, []any{tmp52, v49}) - tmp47 = tmp54 + tmp55 := lang.Apply(tmp54, []any{tmp53, v49}) + tmp47 = tmp55 } // end let tmp45 = tmp47 } @@ -31787,30 +31794,30 @@ func LoadNS() { var tmp62 any if lang.IsTruthy(v61) { } else { - panic("unimplemented: new with non-constant class type") + panic(nil) } _ = tmp62 - tmp63 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) - var tmp64 any + tmp64 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + var tmp65 any { // let // let binding "or__0__auto__" - tmp65 := lang.Apply(v15, []any{v56}) - var v66 any = tmp65 - _ = v66 - var tmp67 any - if lang.IsTruthy(v66) { - tmp67 = v66 + tmp66 := lang.Apply(v15, []any{v56}) + var v67 any = tmp66 + _ = v67 + var tmp68 any + if lang.IsTruthy(v67) { + tmp68 = v67 } else { - tmp67 = v56 + tmp68 = v56 } - tmp64 = tmp67 + tmp65 = tmp68 } // end let - tmp65, _ := lang.FieldOrMethod(tmp63, "Refer") - if reflect.TypeOf(tmp65).Kind() != reflect.Func { + tmp66, _ := lang.FieldOrMethod(tmp64, "Refer") + if reflect.TypeOf(tmp66).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Refer is not a function"))) } - tmp66 := lang.Apply(tmp65, []any{tmp64, v61}) - tmp59 = tmp66 + tmp67 := lang.Apply(tmp66, []any{tmp65, v61}) + tmp59 = tmp67 } // end let tmp57 = tmp59 } @@ -35414,7 +35421,7 @@ func LoadNS() { if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(0)}) + tmp5 := lang.Apply(tmp4, []any{v3, int64(0)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -35433,9 +35440,9 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Minus") + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "minus") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Minus is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("minus is not a function"))) } tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 @@ -35633,7 +35640,7 @@ func LoadNS() { if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(0)}) + tmp5 := lang.Apply(tmp4, []any{v3, int64(0)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -35652,9 +35659,9 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "MinusP") + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "minusP") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("MinusP is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("minusP is not a function"))) } tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 @@ -35695,58 +35702,59 @@ func LoadNS() { var tmp4 any { // let // let binding "a" - var v5 any = "unimplemented: new with non-constant class type" - _ = v5 + tmp5 := new(*lang.Agent) + var v6 any = tmp5 + _ = v6 // let binding "opts" - tmp6 := checkDerefVar(var_glojure_DOT_core_apply) - tmp7 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) - tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) - var v9 any = tmp8 - _ = v9 - tmp10 := checkDerefVar(var_glojure_DOT_core_setup_DASH_reference) - tmp11 := lang.Apply(tmp10, []any{v5, v3}) - _ = tmp11 - var tmp12 any - tmp13 := lang.Apply(kw_error_DASH_handler, []any{v9}) - if lang.IsTruthy(tmp13) { - tmp14 := lang.Apply(kw_error_DASH_handler, []any{v9}) - tmp15, _ := lang.FieldOrMethod(v5, "setErrorHandler") - if reflect.TypeOf(tmp15).Kind() != reflect.Func { + tmp7 := checkDerefVar(var_glojure_DOT_core_apply) + tmp8 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp9 := lang.Apply(tmp7, []any{tmp8, v3}) + var v10 any = tmp9 + _ = v10 + tmp11 := checkDerefVar(var_glojure_DOT_core_setup_DASH_reference) + tmp12 := lang.Apply(tmp11, []any{v6, v3}) + _ = tmp12 + var tmp13 any + tmp14 := lang.Apply(kw_error_DASH_handler, []any{v10}) + if lang.IsTruthy(tmp14) { + tmp15 := lang.Apply(kw_error_DASH_handler, []any{v10}) + tmp16, _ := lang.FieldOrMethod(v6, "setErrorHandler") + if reflect.TypeOf(tmp16).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorHandler is not a function"))) } - tmp16 := lang.Apply(tmp15, []any{tmp14}) - tmp12 = tmp16 + tmp17 := lang.Apply(tmp16, []any{tmp15}) + tmp13 = tmp17 } else { } - _ = tmp12 - var tmp17 any + _ = tmp13 + var tmp18 any { // let // let binding "or__0__auto__" - tmp18 := lang.Apply(kw_error_DASH_mode, []any{v9}) - var v19 any = tmp18 - _ = v19 - var tmp20 any - if lang.IsTruthy(v19) { - tmp20 = v19 + tmp19 := lang.Apply(kw_error_DASH_mode, []any{v10}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + tmp21 = v20 } else { - var tmp21 any - tmp22 := lang.Apply(kw_error_DASH_handler, []any{v9}) - if lang.IsTruthy(tmp22) { - tmp21 = kw_continue + var tmp22 any + tmp23 := lang.Apply(kw_error_DASH_handler, []any{v10}) + if lang.IsTruthy(tmp23) { + tmp22 = kw_continue } else { - tmp21 = kw_fail + tmp22 = kw_fail } - tmp20 = tmp21 + tmp21 = tmp22 } - tmp17 = tmp20 + tmp18 = tmp21 } // end let - tmp18, _ := lang.FieldOrMethod(v5, "setErrorMode") - if reflect.TypeOf(tmp18).Kind() != reflect.Func { + tmp19, _ := lang.FieldOrMethod(v6, "setErrorMode") + if reflect.TypeOf(tmp19).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorMode is not a function"))) } - tmp19 := lang.Apply(tmp18, []any{tmp17}) - _ = tmp19 - tmp4 = v5 + tmp20 := lang.Apply(tmp19, []any{tmp18}) + _ = tmp20 + tmp4 = v6 } // end let return tmp4 } @@ -43872,244 +43880,7 @@ func LoadNS() { var tmp8 any { // let // let binding "latch" - var v9 any = "unimplemented: new with non-constant class type" - _ = v9 - // let binding "count-down" - var tmp10 lang.FnFunc - tmp10 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v11 := args[0] - _ = v11 - tmp12, _ := lang.FieldOrMethod(v9, "countDown") - if reflect.TypeOf(tmp12).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("countDown is not a function"))) - } - tmp13 := lang.Apply(tmp12, []any{}) - _ = tmp13 - return v11 - }) - tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3279), kw_column, int(22), kw_end_DASH_line, int(3279), kw_end_DASH_column, int(61)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v13 any = tmp12 - _ = v13 - var tmp14 any - { // let - // let binding "seq_692" - tmp15 := checkDerefVar(var_glojure_DOT_core_seq) - tmp16 := lang.Apply(tmp15, []any{v2}) - var v17 any = tmp16 - _ = v17 - // let binding "chunk_693" - var v18 any = nil - _ = v18 - // let binding "count_694" - var v19 any = int64(0) - _ = v19 - // let binding "i_695" - var v20 any = int64(0) - _ = v20 - for { - var tmp21 any - tmp22 := checkDerefVar(var_glojure_DOT_core__LT_) - tmp23 := lang.Apply(tmp22, []any{v20, v19}) - if lang.IsTruthy(tmp23) { - var tmp24 any - { // let - // let binding "agent" - tmp25, _ := lang.FieldOrMethod(v18, "nth") - if reflect.TypeOf(tmp25).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) - } - tmp26 := lang.Apply(tmp25, []any{v20}) - var v27 any = tmp26 - _ = v27 - tmp28 := checkDerefVar(var_glojure_DOT_core_send) - tmp29 := lang.Apply(tmp28, []any{v27, v13}) - _ = tmp29 - var tmp30 any = v17 - var tmp31 any = v18 - var tmp32 any = v19 - tmp34 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) - tmp35 := lang.Apply(tmp34, []any{v20}) - var tmp33 any = tmp35 - v17 = tmp30 - v18 = tmp31 - v19 = tmp32 - v20 = tmp33 - continue - } // end let - tmp21 = tmp24 - } else { - var tmp25 any - { // let - // let binding "temp__0__auto__" - tmp26 := checkDerefVar(var_glojure_DOT_core_seq) - tmp27 := lang.Apply(tmp26, []any{v17}) - var v28 any = tmp27 - _ = v28 - var tmp29 any - if lang.IsTruthy(v28) { - var tmp30 any - { // let - // let binding "seq_692" - var v31 any = v28 - _ = v31 - var tmp32 any - tmp33 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) - tmp34 := lang.Apply(tmp33, []any{v31}) - if lang.IsTruthy(tmp34) { - var tmp35 any - { // let - // let binding "c__0__auto__" - tmp36 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) - tmp37 := lang.Apply(tmp36, []any{v31}) - var v38 any = tmp37 - _ = v38 - tmp40 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) - tmp41 := lang.Apply(tmp40, []any{v31}) - var tmp39 any = tmp41 - var tmp42 any = v38 - tmp44 := checkDerefVar(var_glojure_DOT_core_int) - tmp45 := checkDerefVar(var_glojure_DOT_core_count) - tmp46 := lang.Apply(tmp45, []any{v38}) - tmp47 := lang.Apply(tmp44, []any{tmp46}) - var tmp43 any = tmp47 - tmp49 := checkDerefVar(var_glojure_DOT_core_int) - tmp50 := lang.Apply(tmp49, []any{int64(0)}) - var tmp48 any = tmp50 - v17 = tmp39 - v18 = tmp42 - v19 = tmp43 - v20 = tmp48 - continue - } // end let - tmp32 = tmp35 - } else { - var tmp36 any - { // let - // let binding "agent" - tmp37 := checkDerefVar(var_glojure_DOT_core_first) - tmp38 := lang.Apply(tmp37, []any{v31}) - var v39 any = tmp38 - _ = v39 - tmp40 := checkDerefVar(var_glojure_DOT_core_send) - tmp41 := lang.Apply(tmp40, []any{v39, v13}) - _ = tmp41 - tmp43 := checkDerefVar(var_glojure_DOT_core_next) - tmp44 := lang.Apply(tmp43, []any{v31}) - var tmp42 any = tmp44 - var tmp45 any = nil - var tmp46 any = int64(0) - var tmp47 any = int64(0) - v17 = tmp42 - v18 = tmp45 - v19 = tmp46 - v20 = tmp47 - continue - } // end let - tmp32 = tmp36 - } - tmp30 = tmp32 - } // end let - tmp29 = tmp30 - } else { - } - tmp25 = tmp29 - } // end let - tmp21 = tmp25 - } - tmp14 = tmp21 - break - } - } // end let - _ = tmp14 - tmp15, _ := lang.FieldOrMethod(v9, "await") - if reflect.TypeOf(tmp15).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) - } - tmp16 := lang.Apply(tmp15, []any{}) - tmp8 = tmp16 - } // end let - tmp3 = tmp8 - } - return tmp3 - } - }) - tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - var_glojure_DOT_core_await = ns.InternWithValue(tmp0, tmp1, true) - if tmp0.Meta() != nil { - var_glojure_DOT_core_await.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // await1 - { - tmp0 := sym_await1.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(3284), kw_column, int(7), kw_end_DASH_line, int(3284), kw_end_DASH_column, int(21), kw_arglists, lang.NewList(lang.NewVector(sym_a)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - var tmp1 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v2 := args[0] - _ = v2 - var tmp3 any - tmp4 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) - tmp5, ok := lang.FieldOrMethod(v2, "getQueueCount") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getQueueCount"))) - } - var tmp6 any - switch reflect.TypeOf(tmp5).Kind() { - case reflect.Func: - tmp6 = lang.Apply(tmp5, nil) - default: - tmp6 = tmp5 - } - tmp7 := lang.Apply(tmp4, []any{tmp6}) - if lang.IsTruthy(tmp7) { - tmp8 := checkDerefVar(var_glojure_DOT_core_await) - tmp9 := lang.Apply(tmp8, []any{v2}) - tmp3 = tmp9 - } else { - } - _ = tmp3 - return v2 - }) - tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - var_glojure_DOT_core_await1 = ns.InternWithValue(tmp0, tmp1, true) - if tmp0.Meta() != nil { - var_glojure_DOT_core_await1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // await-for - { - tmp0 := sym_await_DASH_for.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_timeout_DASH_ms, sym__AMP_, sym_agents)), kw_doc, "Blocks the current thread until all actions dispatched thus\n far (from this thread or agent) to the agents have occurred, or the\n timeout (in milliseconds) has elapsed. Returns logical false if\n returning due to timeout, logical true otherwise.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(3289), kw_end_DASH_line, int(3289))).(*lang.Symbol) - var tmp1 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArityGTE(args, 1) - v2 := args[0] - _ = v2 - var v3 any = lang.NewList(args[1:]...) - _ = v3 - var tmp4 any - tmp5 := lang.Apply(nil, nil) - if lang.IsTruthy(tmp5) { - panic("unimplemented: new with non-constant class type") - } else { - var tmp6 any - tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_agent_STAR_) - if lang.IsTruthy(tmp7) { - tmp8 := lang.Apply(errors5.New, []any{"Can't await in agent action"}) - panic(tmp8) - } else { - } - _ = tmp6 - var tmp9 any - { // let - // let binding "latch" - var v10 any = "unimplemented: new with non-constant class type" + var v10 any = nil _ = v10 // let binding "count-down" var tmp11 lang.FnFunc @@ -44125,7 +43896,7 @@ func LoadNS() { _ = tmp14 return v12 }) - tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3301), kw_column, int(23), kw_end_DASH_line, int(3301), kw_end_DASH_column, int(62)) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3279), kw_column, int(22), kw_end_DASH_line, int(3279), kw_end_DASH_column, int(61)) tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) if err != nil { panic(err) @@ -44134,18 +43905,18 @@ func LoadNS() { _ = v14 var tmp15 any { // let - // let binding "seq_696" + // let binding "seq_692" tmp16 := checkDerefVar(var_glojure_DOT_core_seq) - tmp17 := lang.Apply(tmp16, []any{v3}) + tmp17 := lang.Apply(tmp16, []any{v2}) var v18 any = tmp17 _ = v18 - // let binding "chunk_697" + // let binding "chunk_693" var v19 any = nil _ = v19 - // let binding "count_698" + // let binding "count_694" var v20 any = int64(0) _ = v20 - // let binding "i_699" + // let binding "i_695" var v21 any = int64(0) _ = v21 for { @@ -44191,7 +43962,7 @@ func LoadNS() { if lang.IsTruthy(v29) { var tmp31 any { // let - // let binding "seq_696" + // let binding "seq_692" var v32 any = v29 _ = v32 var tmp33 any @@ -44263,23 +44034,260 @@ func LoadNS() { } } // end let _ = tmp15 - tmp16, ok := lang.FieldOrMethod(nil, "MILLISECONDS") + tmp16, _ := lang.FieldOrMethod(v10, "await") + if reflect.TypeOf(tmp16).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) + } + tmp17 := lang.Apply(tmp16, []any{}) + tmp8 = tmp17 + } // end let + tmp3 = tmp8 + } + return tmp3 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_await = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_await.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // await1 + { + tmp0 := sym_await1.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(3284), kw_column, int(7), kw_end_DASH_line, int(3284), kw_end_DASH_column, int(21), kw_arglists, lang.NewList(lang.NewVector(sym_a)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp5, ok := lang.FieldOrMethod(v2, "getQueueCount") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getQueueCount"))) + } + var tmp6 any + switch reflect.TypeOf(tmp5).Kind() { + case reflect.Func: + tmp6 = lang.Apply(tmp5, nil) + default: + tmp6 = tmp5 + } + tmp7 := lang.Apply(tmp4, []any{tmp6}) + if lang.IsTruthy(tmp7) { + tmp8 := checkDerefVar(var_glojure_DOT_core_await) + tmp9 := lang.Apply(tmp8, []any{v2}) + tmp3 = tmp9 + } else { + } + _ = tmp3 + return v2 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_await1 = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_await1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // await-for + { + tmp0 := sym_await_DASH_for.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_timeout_DASH_ms, sym__AMP_, sym_agents)), kw_doc, "Blocks the current thread until all actions dispatched thus\n far (from this thread or agent) to the agents have occurred, or the\n timeout (in milliseconds) has elapsed. Returns logical false if\n returning due to timeout, logical true otherwise.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(3289), kw_end_DASH_line, int(3289))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArityGTE(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + var tmp4 any + tmp5 := lang.Apply(nil, nil) + if lang.IsTruthy(tmp5) { + panic("unimplemented: new with non-constant class type") + } else { + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_agent_STAR_) + if lang.IsTruthy(tmp7) { + tmp8 := lang.Apply(errors5.New, []any{"Can't await in agent action"}) + panic(tmp8) + } else { + } + _ = tmp6 + var tmp9 any + { // let + // let binding "latch" + var v11 any = nil + _ = v11 + // let binding "count-down" + var tmp12 lang.FnFunc + tmp12 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v13 := args[0] + _ = v13 + tmp14, _ := lang.FieldOrMethod(v11, "countDown") + if reflect.TypeOf(tmp14).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("countDown is not a function"))) + } + tmp15 := lang.Apply(tmp14, []any{}) + _ = tmp15 + return v13 + }) + tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3301), kw_column, int(23), kw_end_DASH_line, int(3301), kw_end_DASH_column, int(62)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v15 any = tmp14 + _ = v15 + var tmp16 any + { // let + // let binding "seq_696" + tmp17 := checkDerefVar(var_glojure_DOT_core_seq) + tmp18 := lang.Apply(tmp17, []any{v3}) + var v19 any = tmp18 + _ = v19 + // let binding "chunk_697" + var v20 any = nil + _ = v20 + // let binding "count_698" + var v21 any = int64(0) + _ = v21 + // let binding "i_699" + var v22 any = int64(0) + _ = v22 + for { + var tmp23 any + tmp24 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp25 := lang.Apply(tmp24, []any{v22, v21}) + if lang.IsTruthy(tmp25) { + var tmp26 any + { // let + // let binding "agent" + tmp27, _ := lang.FieldOrMethod(v20, "nth") + if reflect.TypeOf(tmp27).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp28 := lang.Apply(tmp27, []any{v22}) + var v29 any = tmp28 + _ = v29 + tmp30 := checkDerefVar(var_glojure_DOT_core_send) + tmp31 := lang.Apply(tmp30, []any{v29, v15}) + _ = tmp31 + var tmp32 any = v19 + var tmp33 any = v20 + var tmp34 any = v21 + tmp36 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp37 := lang.Apply(tmp36, []any{v22}) + var tmp35 any = tmp37 + v19 = tmp32 + v20 = tmp33 + v21 = tmp34 + v22 = tmp35 + continue + } // end let + tmp23 = tmp26 + } else { + var tmp27 any + { // let + // let binding "temp__0__auto__" + tmp28 := checkDerefVar(var_glojure_DOT_core_seq) + tmp29 := lang.Apply(tmp28, []any{v19}) + var v30 any = tmp29 + _ = v30 + var tmp31 any + if lang.IsTruthy(v30) { + var tmp32 any + { // let + // let binding "seq_696" + var v33 any = v30 + _ = v33 + var tmp34 any + tmp35 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp36 := lang.Apply(tmp35, []any{v33}) + if lang.IsTruthy(tmp36) { + var tmp37 any + { // let + // let binding "c__0__auto__" + tmp38 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp39 := lang.Apply(tmp38, []any{v33}) + var v40 any = tmp39 + _ = v40 + tmp42 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp43 := lang.Apply(tmp42, []any{v33}) + var tmp41 any = tmp43 + var tmp44 any = v40 + tmp46 := checkDerefVar(var_glojure_DOT_core_int) + tmp47 := checkDerefVar(var_glojure_DOT_core_count) + tmp48 := lang.Apply(tmp47, []any{v40}) + tmp49 := lang.Apply(tmp46, []any{tmp48}) + var tmp45 any = tmp49 + tmp51 := checkDerefVar(var_glojure_DOT_core_int) + tmp52 := lang.Apply(tmp51, []any{int64(0)}) + var tmp50 any = tmp52 + v19 = tmp41 + v20 = tmp44 + v21 = tmp45 + v22 = tmp50 + continue + } // end let + tmp34 = tmp37 + } else { + var tmp38 any + { // let + // let binding "agent" + tmp39 := checkDerefVar(var_glojure_DOT_core_first) + tmp40 := lang.Apply(tmp39, []any{v33}) + var v41 any = tmp40 + _ = v41 + tmp42 := checkDerefVar(var_glojure_DOT_core_send) + tmp43 := lang.Apply(tmp42, []any{v41, v15}) + _ = tmp43 + tmp45 := checkDerefVar(var_glojure_DOT_core_next) + tmp46 := lang.Apply(tmp45, []any{v33}) + var tmp44 any = tmp46 + var tmp47 any = nil + var tmp48 any = int64(0) + var tmp49 any = int64(0) + v19 = tmp44 + v20 = tmp47 + v21 = tmp48 + v22 = tmp49 + continue + } // end let + tmp34 = tmp38 + } + tmp32 = tmp34 + } // end let + tmp31 = tmp32 + } else { + } + tmp27 = tmp31 + } // end let + tmp23 = tmp27 + } + tmp16 = tmp23 + break + } + } // end let + _ = tmp16 + tmp17, ok := lang.FieldOrMethod(nil, "MILLISECONDS") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "MILLISECONDS"))) } - var tmp17 any - switch reflect.TypeOf(tmp16).Kind() { + var tmp18 any + switch reflect.TypeOf(tmp17).Kind() { case reflect.Func: - tmp17 = lang.Apply(tmp16, nil) + tmp18 = lang.Apply(tmp17, nil) default: - tmp17 = tmp16 + tmp18 = tmp17 } - tmp18, _ := lang.FieldOrMethod(v10, "await") - if reflect.TypeOf(tmp18).Kind() != reflect.Func { + tmp19, _ := lang.FieldOrMethod(v11, "await") + if reflect.TypeOf(tmp19).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) } - tmp19 := lang.Apply(tmp18, []any{v2, tmp17}) - tmp9 = tmp19 + tmp20 := lang.Apply(tmp19, []any{v2, tmp18}) + tmp9 = tmp20 } // end let tmp4 = tmp9 } @@ -52375,34 +52383,35 @@ func LoadNS() { var tmp4 any { // let // let binding "s__0__auto__" - var v5 any = "unimplemented: new with non-constant class type" - _ = v5 - var tmp6 any + tmp5 := new(strings8.Builder) + var v6 any = tmp5 + _ = v6 + var tmp7 any { // let - tmp7 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) - tmp8 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) - tmp9 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) - tmp10 := lang.Apply(tmp8, []any{tmp9, v5}) - tmp11 := lang.Apply(tmp7, []any{tmp10}) - _ = tmp11 - var tmp12 any + tmp8 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp9 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp10 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) + tmp11 := lang.Apply(tmp9, []any{tmp10, v6}) + tmp12 := lang.Apply(tmp8, []any{tmp11}) + _ = tmp12 + var tmp13 any func() { defer func() { - tmp13 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) - tmp14 := lang.Apply(tmp13, nil) - _ = tmp14 + tmp14 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp15 := lang.Apply(tmp14, nil) + _ = tmp15 }() - tmp15 := checkDerefVar(var_glojure_DOT_core_apply) - tmp16 := checkDerefVar(var_glojure_DOT_core_pr) - tmp17 := lang.Apply(tmp15, []any{tmp16, v3}) - _ = tmp17 - tmp18 := checkDerefVar(var_glojure_DOT_core_str) - tmp19 := lang.Apply(tmp18, []any{v5}) - tmp12 = tmp19 + tmp16 := checkDerefVar(var_glojure_DOT_core_apply) + tmp17 := checkDerefVar(var_glojure_DOT_core_pr) + tmp18 := lang.Apply(tmp16, []any{tmp17, v3}) + _ = tmp18 + tmp19 := checkDerefVar(var_glojure_DOT_core_str) + tmp20 := lang.Apply(tmp19, []any{v6}) + tmp13 = tmp20 }() - tmp6 = tmp12 + tmp7 = tmp13 } // end let - tmp4 = tmp6 + tmp4 = tmp7 } // end let return tmp4 } @@ -52469,34 +52478,35 @@ func LoadNS() { var tmp4 any { // let // let binding "s__0__auto__" - var v5 any = "unimplemented: new with non-constant class type" - _ = v5 - var tmp6 any + tmp5 := new(strings8.Builder) + var v6 any = tmp5 + _ = v6 + var tmp7 any { // let - tmp7 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) - tmp8 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) - tmp9 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) - tmp10 := lang.Apply(tmp8, []any{tmp9, v5}) - tmp11 := lang.Apply(tmp7, []any{tmp10}) - _ = tmp11 - var tmp12 any + tmp8 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp9 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp10 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) + tmp11 := lang.Apply(tmp9, []any{tmp10, v6}) + tmp12 := lang.Apply(tmp8, []any{tmp11}) + _ = tmp12 + var tmp13 any func() { defer func() { - tmp13 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) - tmp14 := lang.Apply(tmp13, nil) - _ = tmp14 + tmp14 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp15 := lang.Apply(tmp14, nil) + _ = tmp15 }() - tmp15 := checkDerefVar(var_glojure_DOT_core_apply) - tmp16 := checkDerefVar(var_glojure_DOT_core_print) - tmp17 := lang.Apply(tmp15, []any{tmp16, v3}) - _ = tmp17 - tmp18 := checkDerefVar(var_glojure_DOT_core_str) - tmp19 := lang.Apply(tmp18, []any{v5}) - tmp12 = tmp19 + tmp16 := checkDerefVar(var_glojure_DOT_core_apply) + tmp17 := checkDerefVar(var_glojure_DOT_core_print) + tmp18 := lang.Apply(tmp16, []any{tmp17, v3}) + _ = tmp18 + tmp19 := checkDerefVar(var_glojure_DOT_core_str) + tmp20 := lang.Apply(tmp19, []any{v6}) + tmp13 = tmp20 }() - tmp6 = tmp12 + tmp7 = tmp13 } // end let - tmp4 = tmp6 + tmp4 = tmp7 } // end let return tmp4 } @@ -52582,34 +52592,35 @@ func LoadNS() { var tmp4 any { // let // let binding "s__0__auto__" - var v5 any = "unimplemented: new with non-constant class type" - _ = v5 - var tmp6 any + tmp5 := new(strings8.Builder) + var v6 any = tmp5 + _ = v6 + var tmp7 any { // let - tmp7 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) - tmp8 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) - tmp9 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) - tmp10 := lang.Apply(tmp8, []any{tmp9, v5}) - tmp11 := lang.Apply(tmp7, []any{tmp10}) - _ = tmp11 - var tmp12 any + tmp8 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp9 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp10 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) + tmp11 := lang.Apply(tmp9, []any{tmp10, v6}) + tmp12 := lang.Apply(tmp8, []any{tmp11}) + _ = tmp12 + var tmp13 any func() { defer func() { - tmp13 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) - tmp14 := lang.Apply(tmp13, nil) - _ = tmp14 + tmp14 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp15 := lang.Apply(tmp14, nil) + _ = tmp15 }() - tmp15 := checkDerefVar(var_glojure_DOT_core_apply) - tmp16 := checkDerefVar(var_glojure_DOT_core_prn) - tmp17 := lang.Apply(tmp15, []any{tmp16, v3}) - _ = tmp17 - tmp18 := checkDerefVar(var_glojure_DOT_core_str) - tmp19 := lang.Apply(tmp18, []any{v5}) - tmp12 = tmp19 + tmp16 := checkDerefVar(var_glojure_DOT_core_apply) + tmp17 := checkDerefVar(var_glojure_DOT_core_prn) + tmp18 := lang.Apply(tmp16, []any{tmp17, v3}) + _ = tmp18 + tmp19 := checkDerefVar(var_glojure_DOT_core_str) + tmp20 := lang.Apply(tmp19, []any{v6}) + tmp13 = tmp20 }() - tmp6 = tmp12 + tmp7 = tmp13 } // end let - tmp4 = tmp6 + tmp4 = tmp7 } // end let return tmp4 } @@ -52676,34 +52687,35 @@ func LoadNS() { var tmp4 any { // let // let binding "s__0__auto__" - var v5 any = "unimplemented: new with non-constant class type" - _ = v5 - var tmp6 any + tmp5 := new(strings8.Builder) + var v6 any = tmp5 + _ = v6 + var tmp7 any { // let - tmp7 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) - tmp8 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) - tmp9 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) - tmp10 := lang.Apply(tmp8, []any{tmp9, v5}) - tmp11 := lang.Apply(tmp7, []any{tmp10}) - _ = tmp11 - var tmp12 any + tmp8 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp9 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp10 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) + tmp11 := lang.Apply(tmp9, []any{tmp10, v6}) + tmp12 := lang.Apply(tmp8, []any{tmp11}) + _ = tmp12 + var tmp13 any func() { defer func() { - tmp13 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) - tmp14 := lang.Apply(tmp13, nil) - _ = tmp14 + tmp14 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp15 := lang.Apply(tmp14, nil) + _ = tmp15 }() - tmp15 := checkDerefVar(var_glojure_DOT_core_apply) - tmp16 := checkDerefVar(var_glojure_DOT_core_println) - tmp17 := lang.Apply(tmp15, []any{tmp16, v3}) - _ = tmp17 - tmp18 := checkDerefVar(var_glojure_DOT_core_str) - tmp19 := lang.Apply(tmp18, []any{v5}) - tmp12 = tmp19 + tmp16 := checkDerefVar(var_glojure_DOT_core_apply) + tmp17 := checkDerefVar(var_glojure_DOT_core_println) + tmp18 := lang.Apply(tmp16, []any{tmp17, v3}) + _ = tmp18 + tmp19 := checkDerefVar(var_glojure_DOT_core_str) + tmp20 := lang.Apply(tmp19, []any{v6}) + tmp13 = tmp20 }() - tmp6 = tmp12 + tmp7 = tmp13 } // end let - tmp4 = tmp6 + tmp4 = tmp7 } // end let return tmp4 } @@ -55569,41 +55581,42 @@ func LoadNS() { var v8 any = tmp7 _ = v8 // let binding "sw" - var v9 any = "unimplemented: new with non-constant class type" - _ = v9 - var tmp10 any + tmp9 := new(strings8.Builder) + var v10 any = tmp9 + _ = v10 + var tmp11 any { // let // let binding "r" - tmp11 := checkDerefVar(var_glojure_DOT_core_apply) - tmp12 := checkDerefVar(var_glojure_DOT_go_DOT_io_reader) - tmp13 := lang.Apply(tmp11, []any{tmp12, v3, v8}) - var v14 any = tmp13 - _ = v14 - var tmp15 any + tmp12 := checkDerefVar(var_glojure_DOT_core_apply) + tmp13 := checkDerefVar(var_glojure_DOT_go_DOT_io_reader) + tmp14 := lang.Apply(tmp12, []any{tmp13, v3, v8}) + var v15 any = tmp14 + _ = v15 + var tmp16 any func() { defer func() { - tmp16, ok := lang.FieldOrMethod(v14, "close") + tmp17, ok := lang.FieldOrMethod(v15, "close") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v14, "close"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v15, "close"))) } - var tmp17 any - switch reflect.TypeOf(tmp16).Kind() { + var tmp18 any + switch reflect.TypeOf(tmp17).Kind() { case reflect.Func: - tmp17 = lang.Apply(tmp16, nil) + tmp18 = lang.Apply(tmp17, nil) default: - tmp17 = tmp16 + tmp18 = tmp17 } - _ = tmp17 + _ = tmp18 }() - tmp18 := checkDerefVar(var_glojure_DOT_go_DOT_io_copy) - tmp19 := lang.Apply(tmp18, []any{v14, v9}) - _ = tmp19 - tmp20 := lang.Apply(lang.ToString, []any{v9}) - tmp15 = tmp20 + tmp19 := checkDerefVar(var_glojure_DOT_go_DOT_io_copy) + tmp20 := lang.Apply(tmp19, []any{v15, v10}) + _ = tmp20 + tmp21 := lang.Apply(lang.ToString, []any{v10}) + tmp16 = tmp21 }() - tmp10 = tmp15 + tmp11 = tmp16 } // end let - tmp5 = tmp10 + tmp5 = tmp11 } // end let return tmp5 } diff --git a/pkg/stdlib/glojure/core_print/loader.go b/pkg/stdlib/glojure/core_print/loader.go index 2d2630fa..14b05e33 100644 --- a/pkg/stdlib/glojure/core_print/loader.go +++ b/pkg/stdlib/glojure/core_print/loader.go @@ -488,68 +488,22 @@ func LoadNS() { sym_glojure_DOT_core_SLASH_Array := lang.NewSymbol("glojure.core/Array") sym_glojure_DOT_core_SLASH_Aset := lang.NewSymbol("glojure.core/Aset") sym_glojure_DOT_core_SLASH_AssertionError := lang.NewSymbol("glojure.core/AssertionError") - sym_glojure_DOT_core_SLASH_BooleanArray := lang.NewSymbol("glojure.core/BooleanArray") sym_glojure_DOT_core_SLASH_BooleanCast := lang.NewSymbol("glojure.core/BooleanCast") - sym_glojure_DOT_core_SLASH_Booleans := lang.NewSymbol("glojure.core/Booleans") - sym_glojure_DOT_core_SLASH_ByteArray := lang.NewSymbol("glojure.core/ByteArray") - sym_glojure_DOT_core_SLASH_Bytes := lang.NewSymbol("glojure.core/Bytes") - sym_glojure_DOT_core_SLASH_CharArray := lang.NewSymbol("glojure.core/CharArray") - sym_glojure_DOT_core_SLASH_Chars := lang.NewSymbol("glojure.core/Chars") sym_glojure_DOT_core_SLASH_Count := lang.NewSymbol("glojure.core/Count") - sym_glojure_DOT_core_SLASH_DecP := lang.NewSymbol("glojure.core/DecP") - sym_glojure_DOT_core_SLASH_DoubleArray := lang.NewSymbol("glojure.core/DoubleArray") sym_glojure_DOT_core_SLASH_DoubleCast := lang.NewSymbol("glojure.core/DoubleCast") - sym_glojure_DOT_core_SLASH_Doubles := lang.NewSymbol("glojure.core/Doubles") - sym_glojure_DOT_core_SLASH_Equiv := lang.NewSymbol("glojure.core/Equiv") - sym_glojure_DOT_core_SLASH_FloatArray := lang.NewSymbol("glojure.core/FloatArray") - sym_glojure_DOT_core_SLASH_Floats := lang.NewSymbol("glojure.core/Floats") sym_glojure_DOT_core_SLASH_Get := lang.NewSymbol("glojure.core/Get") - sym_glojure_DOT_core_SLASH_Gt := lang.NewSymbol("glojure.core/Gt") - sym_glojure_DOT_core_SLASH_Gte := lang.NewSymbol("glojure.core/Gte") sym_glojure_DOT_core_SLASH_IllegalStateException := lang.NewSymbol("glojure.core/IllegalStateException") - sym_glojure_DOT_core_SLASH_IncP := lang.NewSymbol("glojure.core/IncP") - sym_glojure_DOT_core_SLASH_IntArray := lang.NewSymbol("glojure.core/IntArray") - sym_glojure_DOT_core_SLASH_Ints := lang.NewSymbol("glojure.core/Ints") - sym_glojure_DOT_core_SLASH_IsNeg := lang.NewSymbol("glojure.core/IsNeg") - sym_glojure_DOT_core_SLASH_IsPos := lang.NewSymbol("glojure.core/IsPos") - sym_glojure_DOT_core_SLASH_IsZero := lang.NewSymbol("glojure.core/IsZero") - sym_glojure_DOT_core_SLASH_LongArray := lang.NewSymbol("glojure.core/LongArray") sym_glojure_DOT_core_SLASH_LongCast := lang.NewSymbol("glojure.core/LongCast") - sym_glojure_DOT_core_SLASH_Longs := lang.NewSymbol("glojure.core/Longs") - sym_glojure_DOT_core_SLASH_Lt := lang.NewSymbol("glojure.core/Lt") - sym_glojure_DOT_core_SLASH_Lte := lang.NewSymbol("glojure.core/Lte") - sym_glojure_DOT_core_SLASH_Not := lang.NewSymbol("glojure.core/Not") sym_glojure_DOT_core_SLASH_Nth := lang.NewSymbol("glojure.core/Nth") - sym_glojure_DOT_core_SLASH_Num := lang.NewSymbol("glojure.core/Num") sym_glojure_DOT_core_SLASH_Object_array := lang.NewSymbol("glojure.core/Object_array") - sym_glojure_DOT_core_SLASH_Quotient := lang.NewSymbol("glojure.core/Quotient") - sym_glojure_DOT_core_SLASH_Remainder := lang.NewSymbol("glojure.core/Remainder") sym_glojure_DOT_core_SLASH_RunInTransaction := lang.NewSymbol("glojure.core/RunInTransaction") - sym_glojure_DOT_core_SLASH_ShiftLeft := lang.NewSymbol("glojure.core/ShiftLeft") - sym_glojure_DOT_core_SLASH_ShiftRight := lang.NewSymbol("glojure.core/ShiftRight") - sym_glojure_DOT_core_SLASH_ShortArray := lang.NewSymbol("glojure.core/ShortArray") - sym_glojure_DOT_core_SLASH_Shorts := lang.NewSymbol("glojure.core/Shorts") - sym_glojure_DOT_core_SLASH_UncheckedAdd := lang.NewSymbol("glojure.core/UncheckedAdd") sym_glojure_DOT_core_SLASH_UncheckedByteCast := lang.NewSymbol("glojure.core/UncheckedByteCast") sym_glojure_DOT_core_SLASH_UncheckedCharCast := lang.NewSymbol("glojure.core/UncheckedCharCast") - sym_glojure_DOT_core_SLASH_UncheckedDec := lang.NewSymbol("glojure.core/UncheckedDec") sym_glojure_DOT_core_SLASH_UncheckedDoubleCast := lang.NewSymbol("glojure.core/UncheckedDoubleCast") sym_glojure_DOT_core_SLASH_UncheckedFloatCast := lang.NewSymbol("glojure.core/UncheckedFloatCast") sym_glojure_DOT_core_SLASH_UncheckedIntCast := lang.NewSymbol("glojure.core/UncheckedIntCast") - sym_glojure_DOT_core_SLASH_UncheckedIntDivide := lang.NewSymbol("glojure.core/UncheckedIntDivide") sym_glojure_DOT_core_SLASH_UncheckedLongCast := lang.NewSymbol("glojure.core/UncheckedLongCast") sym_glojure_DOT_core_SLASH_UncheckedShortCast := lang.NewSymbol("glojure.core/UncheckedShortCast") - sym_glojure_DOT_core_SLASH_Unchecked_inc := lang.NewSymbol("glojure.core/Unchecked_inc") - sym_glojure_DOT_core_SLASH_Unchecked_int_add := lang.NewSymbol("glojure.core/Unchecked_int_add") - sym_glojure_DOT_core_SLASH_Unchecked_int_dec := lang.NewSymbol("glojure.core/Unchecked_int_dec") - sym_glojure_DOT_core_SLASH_Unchecked_int_inc := lang.NewSymbol("glojure.core/Unchecked_int_inc") - sym_glojure_DOT_core_SLASH_Unchecked_int_multiply := lang.NewSymbol("glojure.core/Unchecked_int_multiply") - sym_glojure_DOT_core_SLASH_Unchecked_int_negate := lang.NewSymbol("glojure.core/Unchecked_int_negate") - sym_glojure_DOT_core_SLASH_Unchecked_int_remainder := lang.NewSymbol("glojure.core/Unchecked_int_remainder") - sym_glojure_DOT_core_SLASH_Unchecked_int_subtract := lang.NewSymbol("glojure.core/Unchecked_int_subtract") - sym_glojure_DOT_core_SLASH_Unchecked_minus := lang.NewSymbol("glojure.core/Unchecked_minus") - sym_glojure_DOT_core_SLASH_Unchecked_multiply := lang.NewSymbol("glojure.core/Unchecked_multiply") - sym_glojure_DOT_core_SLASH_UnsignedShiftRight := lang.NewSymbol("glojure.core/UnsignedShiftRight") sym_glojure_DOT_core_SLASH_aclone := lang.NewSymbol("glojure.core/aclone") sym_glojure_DOT_core_SLASH_aget := lang.NewSymbol("glojure.core/aget") sym_glojure_DOT_core_SLASH_alength := lang.NewSymbol("glojure.core/alength") @@ -564,8 +518,14 @@ func LoadNS() { sym_glojure_DOT_core_SLASH_assoc_DASH_in := lang.NewSymbol("glojure.core/assoc-in") sym_glojure_DOT_core_SLASH_atom := lang.NewSymbol("glojure.core/atom") sym_glojure_DOT_core_SLASH_binding := lang.NewSymbol("glojure.core/binding") + sym_glojure_DOT_core_SLASH_booleanArray := lang.NewSymbol("glojure.core/booleanArray") + sym_glojure_DOT_core_SLASH_booleans := lang.NewSymbol("glojure.core/booleans") sym_glojure_DOT_core_SLASH_bound_DASH_fn_STAR_ := lang.NewSymbol("glojure.core/bound-fn*") + sym_glojure_DOT_core_SLASH_byteArray := lang.NewSymbol("glojure.core/byteArray") + sym_glojure_DOT_core_SLASH_bytes := lang.NewSymbol("glojure.core/bytes") sym_glojure_DOT_core_SLASH_c := lang.NewSymbol("glojure.core/c") + sym_glojure_DOT_core_SLASH_charArray := lang.NewSymbol("glojure.core/charArray") + sym_glojure_DOT_core_SLASH_chars := lang.NewSymbol("glojure.core/chars") sym_glojure_DOT_core_SLASH_chunk := lang.NewSymbol("glojure.core/chunk") sym_glojure_DOT_core_SLASH_chunk_DASH_append := lang.NewSymbol("glojure.core/chunk-append") sym_glojure_DOT_core_SLASH_chunk_DASH_buffer := lang.NewSymbol("glojure.core/chunk-buffer") @@ -583,19 +543,26 @@ func LoadNS() { sym_glojure_DOT_core_SLASH_cons := lang.NewSymbol("glojure.core/cons") sym_glojure_DOT_core_SLASH_count := lang.NewSymbol("glojure.core/count") sym_glojure_DOT_core_SLASH_create_DASH_struct := lang.NewSymbol("glojure.core/create-struct") + sym_glojure_DOT_core_SLASH_decP := lang.NewSymbol("glojure.core/decP") sym_glojure_DOT_core_SLASH_defmulti := lang.NewSymbol("glojure.core/defmulti") sym_glojure_DOT_core_SLASH_defn := lang.NewSymbol("glojure.core/defn") sym_glojure_DOT_core_SLASH_deref := lang.NewSymbol("glojure.core/deref") sym_glojure_DOT_core_SLASH_dosync := lang.NewSymbol("glojure.core/dosync") sym_glojure_DOT_core_SLASH_double := lang.NewSymbol("glojure.core/double") + sym_glojure_DOT_core_SLASH_doubleArray := lang.NewSymbol("glojure.core/doubleArray") + sym_glojure_DOT_core_SLASH_doubles := lang.NewSymbol("glojure.core/doubles") sym_glojure_DOT_core_SLASH_equiv := lang.NewSymbol("glojure.core/equiv") sym_glojure_DOT_core_SLASH_extend := lang.NewSymbol("glojure.core/extend") sym_glojure_DOT_core_SLASH_extend_DASH_type := lang.NewSymbol("glojure.core/extend-type") sym_glojure_DOT_core_SLASH_first := lang.NewSymbol("glojure.core/first") + sym_glojure_DOT_core_SLASH_floatArray := lang.NewSymbol("glojure.core/floatArray") + sym_glojure_DOT_core_SLASH_floats := lang.NewSymbol("glojure.core/floats") sym_glojure_DOT_core_SLASH_fn := lang.NewSymbol("glojure.core/fn") sym_glojure_DOT_core_SLASH_future_DASH_call := lang.NewSymbol("glojure.core/future-call") sym_glojure_DOT_core_SLASH_gen_DASH_class := lang.NewSymbol("glojure.core/gen-class") sym_glojure_DOT_core_SLASH_get := lang.NewSymbol("glojure.core/get") + sym_glojure_DOT_core_SLASH_gt := lang.NewSymbol("glojure.core/gt") + sym_glojure_DOT_core_SLASH_gte := lang.NewSymbol("glojure.core/gte") sym_glojure_DOT_core_SLASH_hash_DASH_map := lang.NewSymbol("glojure.core/hash-map") sym_glojure_DOT_core_SLASH_i := lang.NewSymbol("glojure.core/i") sym_glojure_DOT_core_SLASH_identical := lang.NewSymbol("glojure.core/identical") @@ -603,13 +570,23 @@ func LoadNS() { sym_glojure_DOT_core_SLASH_if_DASH_not := lang.NewSymbol("glojure.core/if-not") sym_glojure_DOT_core_SLASH_if_DASH_some := lang.NewSymbol("glojure.core/if-some") sym_glojure_DOT_core_SLASH_in_DASH_ns := lang.NewSymbol("glojure.core/in-ns") + sym_glojure_DOT_core_SLASH_incP := lang.NewSymbol("glojure.core/incP") sym_glojure_DOT_core_SLASH_instance_QMARK_ := lang.NewSymbol("glojure.core/instance?") sym_glojure_DOT_core_SLASH_int := lang.NewSymbol("glojure.core/int") + sym_glojure_DOT_core_SLASH_intArray := lang.NewSymbol("glojure.core/intArray") + sym_glojure_DOT_core_SLASH_ints := lang.NewSymbol("glojure.core/ints") + sym_glojure_DOT_core_SLASH_isNeg := lang.NewSymbol("glojure.core/isNeg") + sym_glojure_DOT_core_SLASH_isPos := lang.NewSymbol("glojure.core/isPos") + sym_glojure_DOT_core_SLASH_isZero := lang.NewSymbol("glojure.core/isZero") sym_glojure_DOT_core_SLASH_keyword := lang.NewSymbol("glojure.core/keyword") sym_glojure_DOT_core_SLASH_lazy_DASH_seq := lang.NewSymbol("glojure.core/lazy-seq") sym_glojure_DOT_core_SLASH_let := lang.NewSymbol("glojure.core/let") sym_glojure_DOT_core_SLASH_long := lang.NewSymbol("glojure.core/long") + sym_glojure_DOT_core_SLASH_longArray := lang.NewSymbol("glojure.core/longArray") + sym_glojure_DOT_core_SLASH_longs := lang.NewSymbol("glojure.core/longs") sym_glojure_DOT_core_SLASH_loop := lang.NewSymbol("glojure.core/loop") + sym_glojure_DOT_core_SLASH_lt := lang.NewSymbol("glojure.core/lt") + sym_glojure_DOT_core_SLASH_lte := lang.NewSymbol("glojure.core/lte") sym_glojure_DOT_core_SLASH_merge := lang.NewSymbol("glojure.core/merge") sym_glojure_DOT_core_SLASH_meta := lang.NewSymbol("glojure.core/meta") sym_glojure_DOT_core_SLASH_next := lang.NewSymbol("glojure.core/next") @@ -617,24 +594,45 @@ func LoadNS() { sym_glojure_DOT_core_SLASH_nil_QMARK_ := lang.NewSymbol("glojure.core/nil?") sym_glojure_DOT_core_SLASH_not := lang.NewSymbol("glojure.core/not") sym_glojure_DOT_core_SLASH_nth := lang.NewSymbol("glojure.core/nth") + sym_glojure_DOT_core_SLASH_num := lang.NewSymbol("glojure.core/num") sym_glojure_DOT_core_SLASH_or := lang.NewSymbol("glojure.core/or") sym_glojure_DOT_core_SLASH_pcalls := lang.NewSymbol("glojure.core/pcalls") sym_glojure_DOT_core_SLASH_pop_DASH_thread_DASH_bindings := lang.NewSymbol("glojure.core/pop-thread-bindings") sym_glojure_DOT_core_SLASH_pr_DASH_str := lang.NewSymbol("glojure.core/pr-str") sym_glojure_DOT_core_SLASH_prn := lang.NewSymbol("glojure.core/prn") sym_glojure_DOT_core_SLASH_push_DASH_thread_DASH_bindings := lang.NewSymbol("glojure.core/push-thread-bindings") + sym_glojure_DOT_core_SLASH_quotient := lang.NewSymbol("glojure.core/quotient") sym_glojure_DOT_core_SLASH_refer := lang.NewSymbol("glojure.core/refer") + sym_glojure_DOT_core_SLASH_remainder := lang.NewSymbol("glojure.core/remainder") sym_glojure_DOT_core_SLASH_rest := lang.NewSymbol("glojure.core/rest") sym_glojure_DOT_core_SLASH_seq := lang.NewSymbol("glojure.core/seq") sym_glojure_DOT_core_SLASH_seq_QMARK_ := lang.NewSymbol("glojure.core/seq?") + sym_glojure_DOT_core_SLASH_shiftLeft := lang.NewSymbol("glojure.core/shiftLeft") + sym_glojure_DOT_core_SLASH_shiftRight := lang.NewSymbol("glojure.core/shiftRight") + sym_glojure_DOT_core_SLASH_shortArray := lang.NewSymbol("glojure.core/shortArray") + sym_glojure_DOT_core_SLASH_shorts := lang.NewSymbol("glojure.core/shorts") sym_glojure_DOT_core_SLASH_str := lang.NewSymbol("glojure.core/str") sym_glojure_DOT_core_SLASH_swap_BANG_ := lang.NewSymbol("glojure.core/swap!") sym_glojure_DOT_core_SLASH_sync := lang.NewSymbol("glojure.core/sync") sym_glojure_DOT_core_SLASH_to_DASH_array := lang.NewSymbol("glojure.core/to-array") sym_glojure_DOT_core_SLASH_unchecked_DASH_inc := lang.NewSymbol("glojure.core/unchecked-inc") sym_glojure_DOT_core_SLASH_unchecked_DASH_inc_DASH_int := lang.NewSymbol("glojure.core/unchecked-inc-int") + sym_glojure_DOT_core_SLASH_unchecked_add := lang.NewSymbol("glojure.core/unchecked_add") + sym_glojure_DOT_core_SLASH_unchecked_dec := lang.NewSymbol("glojure.core/unchecked_dec") + sym_glojure_DOT_core_SLASH_unchecked_inc := lang.NewSymbol("glojure.core/unchecked_inc") + sym_glojure_DOT_core_SLASH_unchecked_int_add := lang.NewSymbol("glojure.core/unchecked_int_add") + sym_glojure_DOT_core_SLASH_unchecked_int_dec := lang.NewSymbol("glojure.core/unchecked_int_dec") + sym_glojure_DOT_core_SLASH_unchecked_int_divide := lang.NewSymbol("glojure.core/unchecked_int_divide") + sym_glojure_DOT_core_SLASH_unchecked_int_inc := lang.NewSymbol("glojure.core/unchecked_int_inc") + sym_glojure_DOT_core_SLASH_unchecked_int_multiply := lang.NewSymbol("glojure.core/unchecked_int_multiply") + sym_glojure_DOT_core_SLASH_unchecked_int_negate := lang.NewSymbol("glojure.core/unchecked_int_negate") + sym_glojure_DOT_core_SLASH_unchecked_int_remainder := lang.NewSymbol("glojure.core/unchecked_int_remainder") + sym_glojure_DOT_core_SLASH_unchecked_int_subtract := lang.NewSymbol("glojure.core/unchecked_int_subtract") + sym_glojure_DOT_core_SLASH_unchecked_minus := lang.NewSymbol("glojure.core/unchecked_minus") + sym_glojure_DOT_core_SLASH_unchecked_multiply := lang.NewSymbol("glojure.core/unchecked_multiply") sym_glojure_DOT_core_SLASH_unquote := lang.NewSymbol("glojure.core/unquote") sym_glojure_DOT_core_SLASH_unquote_DASH_splicing := lang.NewSymbol("glojure.core/unquote-splicing") + sym_glojure_DOT_core_SLASH_unsignedShiftRight := lang.NewSymbol("glojure.core/unsignedShiftRight") sym_glojure_DOT_core_SLASH_when := lang.NewSymbol("glojure.core/when") sym_glojure_DOT_core_SLASH_when_DASH_first := lang.NewSymbol("glojure.core/when-first") sym_glojure_DOT_core_SLASH_when_DASH_let := lang.NewSymbol("glojure.core/when-let") @@ -2976,7 +2974,7 @@ func LoadNS() { if reflect.TypeOf(tmp3).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp4 := lang.Apply(tmp3, []any{nil, int64(0)}) + tmp4 := lang.Apply(tmp3, []any{v2, int64(0)}) return tmp4 }) tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -2997,7 +2995,7 @@ func LoadNS() { if reflect.TypeOf(tmp3).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp4 := lang.Apply(tmp3, []any{nil, int64(1)}) + tmp4 := lang.Apply(tmp3, []any{v2, int64(1)}) return tmp4 }) tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -3267,12 +3265,8 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - tmp4, _ := lang.FieldOrMethod(nil, "getAccessor") - if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("getAccessor is not a function"))) - } - tmp5 := lang.Apply(tmp4, []any{v2, v3}) - return tmp5 + tmp4 := lang.Apply(lang.GetPersistentStructMapAccessor, []any{v2, v3}) + return tmp4 }) tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) var_glojure_DOT_core_accessor = ns.InternWithValue(tmp0, tmp1, true) @@ -3476,9 +3470,9 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "ClearBit") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "clearBit") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ClearBit is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("clearBit is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v2, v3}) return tmp5 @@ -3499,9 +3493,9 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "FlipBit") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "flipBit") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("FlipBit is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("flipBit is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v2, v3}) return tmp5 @@ -3522,9 +3516,9 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "SetBit") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "setBit") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("SetBit is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("setBit is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v2, v3}) return tmp5 @@ -3545,9 +3539,9 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "TestBit") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "testBit") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("TestBit is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("testBit is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v2, v3}) return tmp5 @@ -5708,9 +5702,9 @@ func LoadNS() { checkArity(args, 1) v2 := args[0] _ = v2 - tmp3, _ := lang.FieldOrMethod(lang.Numbers, "Rationalize") + tmp3, _ := lang.FieldOrMethod(lang.Numbers, "rationalize") if reflect.TypeOf(tmp3).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Rationalize is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("rationalize is not a function"))) } tmp4 := lang.Apply(tmp3, []any{v2}) return tmp4 @@ -6397,7 +6391,7 @@ func LoadNS() { checkArity(args, 1) v2 := args[0] _ = v2 - return nil + return "unimplemented: set! target type" }) tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) var_glojure_DOT_core_set_DASH_agent_DASH_send_DASH_executor_BANG_ = ns.InternWithValue(tmp0, tmp1, true) @@ -6413,7 +6407,7 @@ func LoadNS() { checkArity(args, 1) v2 := args[0] _ = v2 - return nil + return "unimplemented: set! target type" }) tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) var_glojure_DOT_core_set_DASH_agent_DASH_send_DASH_off_DASH_executor_BANG_ = ns.InternWithValue(tmp0, tmp1, true) @@ -6900,10 +6894,11 @@ func LoadNS() { if err != nil { panic(err) } - tmp8 := checkDerefVar(var_glojure_DOT_core_cons) - tmp9 := lang.Apply(tmp8, []any{v3, v4}) - tmp10 := lang.Apply(tmp7, []any{"unimplemented: new with non-constant class type", tmp9}) - return tmp10 + tmp8 := new(strings8.Builder) + tmp9 := checkDerefVar(var_glojure_DOT_core_cons) + tmp10 := lang.Apply(tmp9, []any{v3, v4}) + tmp11 := lang.Apply(tmp7, []any{tmp8, tmp10}) + return tmp11 } }) tmp3 := reflect.TypeOf("") @@ -9028,9 +9023,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Dec") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "dec") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Dec is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("dec is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -9060,7 +9055,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_DecP}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_decP}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -9079,9 +9074,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "DecP") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "decP") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("DecP is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("decP is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -9656,7 +9651,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_DoubleArray}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_doubleArray}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := checkDerefVar(var_glojure_DOT_core_seq) tmp14 := checkDerefVar(var_glojure_DOT_core_concat) @@ -9682,9 +9677,9 @@ func LoadNS() { case 1: v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "DoubleArray") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "doubleArray") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("DoubleArray is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("doubleArray is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -9693,9 +9688,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "DoubleArrayInit") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "doubleArrayInit") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("DoubleArrayInit is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("doubleArrayInit is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -9744,7 +9739,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Doubles}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_doubles}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := lang.Apply(tmp12, []any{v3}) tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) @@ -9760,9 +9755,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Doubles") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "doubles") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Doubles is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("doubles is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -10366,7 +10361,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_FloatArray}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_floatArray}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := checkDerefVar(var_glojure_DOT_core_seq) tmp14 := checkDerefVar(var_glojure_DOT_core_concat) @@ -10392,9 +10387,9 @@ func LoadNS() { case 1: v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "FloatArray") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "floatArray") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("FloatArray is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("floatArray is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -10403,9 +10398,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "FloatArrayInit") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "floatArrayInit") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("FloatArrayInit is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("floatArrayInit is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -10469,7 +10464,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Floats}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_floats}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := lang.Apply(tmp12, []any{v3}) tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) @@ -10485,9 +10480,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Floats") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "floats") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Floats is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("floats is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -10997,9 +10992,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Inc") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "inc") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Inc is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("inc is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -11029,7 +11024,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_IncP}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_incP}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -11048,9 +11043,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "IncP") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "incP") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("IncP is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("incP is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -11192,7 +11187,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_IntArray}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_intArray}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := checkDerefVar(var_glojure_DOT_core_seq) tmp14 := checkDerefVar(var_glojure_DOT_core_concat) @@ -11218,9 +11213,9 @@ func LoadNS() { case 1: v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "IntArray") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "intArray") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("IntArray is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("intArray is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -11229,9 +11224,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "IntArrayInit") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "intArrayInit") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("IntArrayInit is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("intArrayInit is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -11376,7 +11371,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Ints}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_ints}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := lang.Apply(tmp12, []any{v3}) tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) @@ -11392,9 +11387,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Ints") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "ints") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Ints is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("ints is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -11944,7 +11939,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_LongArray}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_longArray}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := checkDerefVar(var_glojure_DOT_core_seq) tmp14 := checkDerefVar(var_glojure_DOT_core_concat) @@ -11970,9 +11965,9 @@ func LoadNS() { case 1: v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "LongArray") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "longArray") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("LongArray is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("longArray is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -11981,9 +11976,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "LongArrayInit") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "longArrayInit") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("LongArrayInit is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("longArrayInit is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -12014,7 +12009,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Longs}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_longs}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := lang.Apply(tmp12, []any{v3}) tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) @@ -12030,9 +12025,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Longs") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "longs") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Longs is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("longs is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -12353,7 +12348,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_IsNeg}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_isNeg}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -12372,9 +12367,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "IsNeg") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "isNeg") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("IsNeg is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("isNeg is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -12717,7 +12712,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Num}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_num}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -12736,9 +12731,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Num") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "num") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Num is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("num is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -12971,7 +12966,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_IsPos}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_isPos}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -12990,9 +12985,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "IsPos") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "isPos") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("IsPos is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("isPos is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -13096,7 +13091,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Quotient}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_quotient}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -13119,9 +13114,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Quotient") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "quotient") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Quotient is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("quotient is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -13611,7 +13606,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Remainder}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_remainder}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -13634,9 +13629,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Remainder") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "remainder") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Remainder is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("remainder is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -13993,7 +13988,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_ShortArray}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_shortArray}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := checkDerefVar(var_glojure_DOT_core_seq) tmp14 := checkDerefVar(var_glojure_DOT_core_concat) @@ -14019,9 +14014,9 @@ func LoadNS() { case 1: v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "ShortArray") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "shortArray") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ShortArray is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("shortArray is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -14030,9 +14025,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "ShortArrayInit") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "shortArrayInit") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ShortArrayInit is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("shortArrayInit is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -14063,7 +14058,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Shorts}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_shorts}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := lang.Apply(tmp12, []any{v3}) tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) @@ -14079,9 +14074,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Shorts") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "shorts") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Shorts is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("shorts is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -15647,7 +15642,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_UncheckedAdd}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_unchecked_add}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -15670,9 +15665,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedAdd") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_add") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedAdd is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_add is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -15704,7 +15699,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_add}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_unchecked_int_add}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -15727,9 +15722,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_add") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_int_add") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_add is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_add is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -15857,7 +15852,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedDec}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_unchecked_dec}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -15876,9 +15871,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedDec") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_dec") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedDec is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_dec is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -15908,7 +15903,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_dec}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_unchecked_int_dec}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -15927,9 +15922,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_dec") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_int_dec") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_dec is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_dec is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -15961,7 +15956,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_UncheckedIntDivide}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_unchecked_int_divide}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -15984,9 +15979,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedIntDivide") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_int_divide") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedIntDivide is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_divide is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -16110,7 +16105,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Unchecked_inc}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_unchecked_inc}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -16129,9 +16124,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_inc") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_inc") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_inc is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_inc is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -16161,7 +16156,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_inc}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_unchecked_int_inc}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -16180,9 +16175,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_inc") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_int_inc") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_inc is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_inc is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -16308,7 +16303,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_multiply}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_unchecked_multiply}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -16331,9 +16326,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_multiply") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_multiply") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_multiply is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_multiply is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -16365,7 +16360,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_multiply}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_unchecked_int_multiply}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -16388,9 +16383,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_multiply") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_int_multiply") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_multiply is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_multiply is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -16420,7 +16415,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Unchecked_minus}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_unchecked_minus}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -16471,7 +16466,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_negate}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_unchecked_int_negate}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -16490,9 +16485,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_negate") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_int_negate") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_negate is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_negate is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -16524,7 +16519,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_remainder}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_unchecked_int_remainder}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -16547,9 +16542,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_remainder") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_int_remainder") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_remainder is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_remainder is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -16628,7 +16623,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_minus}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_unchecked_minus}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -16651,9 +16646,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_minus") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_minus") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_minus is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_minus is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -16685,7 +16680,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Unchecked_int_subtract}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_unchecked_int_subtract}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -16708,9 +16703,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Unchecked_int_subtract") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_int_subtract") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Unchecked_int_subtract is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_subtract is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -16768,7 +16763,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_UnsignedShiftRight}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_unsignedShiftRight}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -16791,9 +16786,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "UnsignedShiftRight") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "unsignedShiftRight") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("UnsignedShiftRight is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("unsignedShiftRight is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -16928,7 +16923,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_IsZero}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_isZero}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -16947,9 +16942,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "IsZero") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "isZero") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("IsZero is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("isZero is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -17503,7 +17498,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Equiv}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_equiv}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -17531,9 +17526,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Equiv") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "equiv") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Equiv is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("equiv is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -17606,7 +17601,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Gt}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_gt}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -17634,9 +17629,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Gt") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "gt") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("gt is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -17709,7 +17704,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Gte}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_gte}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -17737,9 +17732,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Gte") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "gte") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gte is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("gte is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -17812,7 +17807,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Lt}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_lt}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -17840,9 +17835,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Lt") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "lt") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Lt is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("lt is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -17915,7 +17910,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_Lte}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_lte}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -17943,9 +17938,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "Lte") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "lte") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Lte is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("lte is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -18169,7 +18164,7 @@ func LoadNS() { if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + tmp5 := lang.Apply(tmp4, []any{v3, int64(1)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -18189,9 +18184,9 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Add") + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "add") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Add is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) } tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 @@ -18389,7 +18384,7 @@ func LoadNS() { if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + tmp5 := lang.Apply(tmp4, []any{v3, int64(1)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -18409,9 +18404,9 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "AddP") + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "addP") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("AddP is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("addP is not a function"))) } tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 @@ -18609,7 +18604,7 @@ func LoadNS() { if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + tmp5 := lang.Apply(tmp4, []any{v3, int64(1)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -18628,9 +18623,9 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Divide") + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "divide") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Divide is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("divide is not a function"))) } tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 @@ -18828,7 +18823,7 @@ func LoadNS() { if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + tmp5 := lang.Apply(tmp4, []any{v3, int64(1)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -18848,9 +18843,9 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Multiply") + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "multiply") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Multiply is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("multiply is not a function"))) } tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 @@ -19048,7 +19043,7 @@ func LoadNS() { if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + tmp5 := lang.Apply(tmp4, []any{v3, int64(1)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -19068,9 +19063,9 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "MultiplyP") + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "multiplyP") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("MultiplyP is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("multiplyP is not a function"))) } tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 @@ -20464,7 +20459,7 @@ func LoadNS() { if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + tmp5 := lang.Apply(tmp4, []any{v3, int64(1)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -20477,9 +20472,9 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "And") + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "and") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("And is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("and is not a function"))) } tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 @@ -20677,7 +20672,7 @@ func LoadNS() { if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + tmp5 := lang.Apply(tmp4, []any{v3, int64(1)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -20690,9 +20685,9 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "AndNot") + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "andNot") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("AndNot is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("andNot is not a function"))) } tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 @@ -20737,7 +20732,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_Not}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_not}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -20756,9 +20751,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Not") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "not") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Not is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("not is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -20941,7 +20936,7 @@ func LoadNS() { if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + tmp5 := lang.Apply(tmp4, []any{v3, int64(1)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -20954,9 +20949,9 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Or") + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "or") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Or is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("or is not a function"))) } tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 @@ -21003,7 +20998,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_ShiftLeft}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_shiftLeft}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -21026,9 +21021,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "ShiftLeft") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "shiftLeft") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ShiftLeft is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("shiftLeft is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -21060,7 +21055,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_ShiftRight}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_shiftRight}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -21083,9 +21078,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "ShiftRight") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "shiftRight") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ShiftRight is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("shiftRight is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -21268,7 +21263,7 @@ func LoadNS() { if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + tmp5 := lang.Apply(tmp4, []any{v3, int64(1)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -21281,9 +21276,9 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Xor") + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "xor") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Xor is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("xor is not a function"))) } tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 @@ -21378,7 +21373,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_BooleanArray}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_booleanArray}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := checkDerefVar(var_glojure_DOT_core_seq) tmp14 := checkDerefVar(var_glojure_DOT_core_concat) @@ -21404,9 +21399,9 @@ func LoadNS() { case 1: v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "BooleanArray") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "booleanArray") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("BooleanArray is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("booleanArray is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -21415,9 +21410,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "BooleanArrayInit") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "booleanArrayInit") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("BooleanArrayInit is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("booleanArrayInit is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -21448,7 +21443,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Booleans}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_booleans}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := lang.Apply(tmp12, []any{v3}) tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) @@ -21464,9 +21459,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Booleans") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "booleans") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Booleans is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("booleans is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -21762,7 +21757,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_ByteArray}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_byteArray}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := checkDerefVar(var_glojure_DOT_core_seq) tmp14 := checkDerefVar(var_glojure_DOT_core_concat) @@ -21788,9 +21783,9 @@ func LoadNS() { case 1: v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "ByteArray") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "byteArray") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ByteArray is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("byteArray is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -21799,9 +21794,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "ByteArrayInit") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "byteArrayInit") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("ByteArrayInit is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("byteArrayInit is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -21832,7 +21827,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Bytes}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_bytes}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := lang.Apply(tmp12, []any{v3}) tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) @@ -21848,9 +21843,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Bytes") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "bytes") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Bytes is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("bytes is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -21976,7 +21971,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_CharArray}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_charArray}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := checkDerefVar(var_glojure_DOT_core_seq) tmp14 := checkDerefVar(var_glojure_DOT_core_concat) @@ -22002,9 +21997,9 @@ func LoadNS() { case 1: v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "CharArray") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "charArray") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("CharArray is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("charArray is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -22013,9 +22008,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "CharArrayInit") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "charArrayInit") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("CharArrayInit is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("charArrayInit is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -22046,7 +22041,7 @@ func LoadNS() { tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_Numbers}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) - tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_Chars}) + tmp11 := lang.Apply(tmp10, []any{sym_glojure_DOT_core_SLASH_chars}) tmp12 := checkDerefVar(var_glojure_DOT_core_list) tmp13 := lang.Apply(tmp12, []any{v3}) tmp14 := lang.Apply(tmp5, []any{tmp7, tmp9, tmp11, tmp13}) @@ -22062,9 +22057,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "Chars") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "chars") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Chars is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("chars is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -27846,7 +27841,7 @@ func LoadNS() { if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + tmp5 := lang.Apply(tmp4, []any{v3, int64(1)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -27863,9 +27858,9 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Max") + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "max") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Max is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("max is not a function"))) } tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 @@ -28474,7 +28469,7 @@ func LoadNS() { if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(1)}) + tmp5 := lang.Apply(tmp4, []any{v3, int64(1)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -28491,9 +28486,9 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Min") + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "min") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Min is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("min is not a function"))) } tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 @@ -29773,6 +29768,17 @@ func LoadNS() { // let binding "G__691" var v7 any = v2 _ = v7 + // case + var tmp8 any + // case clause 0 + if lang.Equals(v7, "true") { + tmp8 = true + // case clause 1 + } else if lang.Equals(v7, "false") { + tmp8 = false + } else { + } + tmp6 = tmp8 } // end let tmp3 = tmp6 } else { @@ -30105,198 +30111,199 @@ func LoadNS() { var tmp5 any { // let // let binding "a" - var v6 any = "unimplemented: new with non-constant class type" - _ = v6 + tmp6 := new(lang.ArrayList) + var v7 any = tmp6 + _ = v7 // let binding "pv" - tmp7 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) - tmp8 := lang.Apply(tmp7, []any{kw_glojure_DOT_core_SLASH_none}) - var v9 any = tmp8 - _ = v9 - var tmp10 lang.FnFunc - tmp10 = lang.NewFnFunc(func(args ...any) any { + tmp8 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) + tmp9 := lang.Apply(tmp8, []any{kw_glojure_DOT_core_SLASH_none}) + var v10 any = tmp9 + _ = v10 + var tmp11 lang.FnFunc + tmp11 = lang.NewFnFunc(func(args ...any) any { switch len(args) { case 0: - tmp11 := lang.Apply(v4, nil) - return tmp11 + tmp12 := lang.Apply(v4, nil) + return tmp12 case 1: - v11 := args[0] - _ = v11 - var tmp12 any + v12 := args[0] + _ = v12 + var tmp13 any { // let // let binding "result" - var tmp13 any - tmp14, ok := lang.FieldOrMethod(v6, "isEmpty") + var tmp14 any + tmp15, ok := lang.FieldOrMethod(v7, "isEmpty") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "isEmpty"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "isEmpty"))) } - var tmp15 any - switch reflect.TypeOf(tmp14).Kind() { + var tmp16 any + switch reflect.TypeOf(tmp15).Kind() { case reflect.Func: - tmp15 = lang.Apply(tmp14, nil) + tmp16 = lang.Apply(tmp15, nil) default: - tmp15 = tmp14 + tmp16 = tmp15 } - if lang.IsTruthy(tmp15) { - tmp13 = v11 + if lang.IsTruthy(tmp16) { + tmp14 = v12 } else { - var tmp16 any + var tmp17 any { // let // let binding "v" - tmp17 := checkDerefVar(var_glojure_DOT_core_vec) - tmp18, ok := lang.FieldOrMethod(v6, "toArray") + tmp18 := checkDerefVar(var_glojure_DOT_core_vec) + tmp19, ok := lang.FieldOrMethod(v7, "toArray") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "toArray"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "toArray"))) } - var tmp19 any - switch reflect.TypeOf(tmp18).Kind() { + var tmp20 any + switch reflect.TypeOf(tmp19).Kind() { case reflect.Func: - tmp19 = lang.Apply(tmp18, nil) + tmp20 = lang.Apply(tmp19, nil) default: - tmp19 = tmp18 + tmp20 = tmp19 } - tmp20 := lang.Apply(tmp17, []any{tmp19}) - var v21 any = tmp20 - _ = v21 - tmp22, ok := lang.FieldOrMethod(v6, "clear") + tmp21 := lang.Apply(tmp18, []any{tmp20}) + var v22 any = tmp21 + _ = v22 + tmp23, ok := lang.FieldOrMethod(v7, "clear") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "clear"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "clear"))) } - var tmp23 any - switch reflect.TypeOf(tmp22).Kind() { + var tmp24 any + switch reflect.TypeOf(tmp23).Kind() { case reflect.Func: - tmp23 = lang.Apply(tmp22, nil) + tmp24 = lang.Apply(tmp23, nil) default: - tmp23 = tmp22 + tmp24 = tmp23 } - _ = tmp23 - tmp24 := checkDerefVar(var_glojure_DOT_core_unreduced) - tmp25 := lang.Apply(v4, []any{v11, v21}) - tmp26 := lang.Apply(tmp24, []any{tmp25}) - tmp16 = tmp26 + _ = tmp24 + tmp25 := checkDerefVar(var_glojure_DOT_core_unreduced) + tmp26 := lang.Apply(v4, []any{v12, v22}) + tmp27 := lang.Apply(tmp25, []any{tmp26}) + tmp17 = tmp27 } // end let - tmp13 = tmp16 + tmp14 = tmp17 } - var v17 any = tmp13 - _ = v17 - tmp18 := lang.Apply(v4, []any{v17}) - tmp12 = tmp18 + var v18 any = tmp14 + _ = v18 + tmp19 := lang.Apply(v4, []any{v18}) + tmp13 = tmp19 } // end let - return tmp12 + return tmp13 case 2: - v11 := args[0] - _ = v11 - v12 := args[1] + v12 := args[0] _ = v12 - var tmp13 any + v13 := args[1] + _ = v13 + var tmp14 any { // let // let binding "pval" - tmp14 := checkDerefVar(var_glojure_DOT_core_deref) - tmp15 := lang.Apply(tmp14, []any{v9}) - var v16 any = tmp15 - _ = v16 + tmp15 := checkDerefVar(var_glojure_DOT_core_deref) + tmp16 := lang.Apply(tmp15, []any{v10}) + var v17 any = tmp16 + _ = v17 // let binding "val" - tmp17 := lang.Apply(v2, []any{v12}) - var v18 any = tmp17 - _ = v18 - tmp19 := checkDerefVar(var_glojure_DOT_core_vreset_BANG_) - tmp20 := lang.Apply(tmp19, []any{v9, v18}) - _ = tmp20 - var tmp21 any + tmp18 := lang.Apply(v2, []any{v13}) + var v19 any = tmp18 + _ = v19 + tmp20 := checkDerefVar(var_glojure_DOT_core_vreset_BANG_) + tmp21 := lang.Apply(tmp20, []any{v10, v19}) + _ = tmp21 var tmp22 any + var tmp23 any { // let // let binding "or__0__auto__" - tmp23 := checkDerefVar(var_glojure_DOT_core_identical_QMARK_) - tmp24 := lang.Apply(tmp23, []any{v16, kw_glojure_DOT_core_SLASH_none}) - var v25 any = tmp24 - _ = v25 - var tmp26 any - if lang.IsTruthy(v25) { - tmp26 = v25 + tmp24 := checkDerefVar(var_glojure_DOT_core_identical_QMARK_) + tmp25 := lang.Apply(tmp24, []any{v17, kw_glojure_DOT_core_SLASH_none}) + var v26 any = tmp25 + _ = v26 + var tmp27 any + if lang.IsTruthy(v26) { + tmp27 = v26 } else { - tmp27 := checkDerefVar(var_glojure_DOT_core__EQ_) - tmp28 := lang.Apply(tmp27, []any{v18, v16}) - tmp26 = tmp28 + tmp28 := checkDerefVar(var_glojure_DOT_core__EQ_) + tmp29 := lang.Apply(tmp28, []any{v19, v17}) + tmp27 = tmp29 } - tmp22 = tmp26 + tmp23 = tmp27 } // end let - if lang.IsTruthy(tmp22) { - tmp23, _ := lang.FieldOrMethod(v6, "add") - if reflect.TypeOf(tmp23).Kind() != reflect.Func { + if lang.IsTruthy(tmp23) { + tmp24, _ := lang.FieldOrMethod(v7, "add") + if reflect.TypeOf(tmp24).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) } - tmp24 := lang.Apply(tmp23, []any{v12}) - _ = tmp24 - tmp21 = v11 + tmp25 := lang.Apply(tmp24, []any{v13}) + _ = tmp25 + tmp22 = v12 } else { - var tmp25 any + var tmp26 any { // let // let binding "v" - tmp26 := checkDerefVar(var_glojure_DOT_core_vec) - tmp27, ok := lang.FieldOrMethod(v6, "toArray") + tmp27 := checkDerefVar(var_glojure_DOT_core_vec) + tmp28, ok := lang.FieldOrMethod(v7, "toArray") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "toArray"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "toArray"))) } - var tmp28 any - switch reflect.TypeOf(tmp27).Kind() { + var tmp29 any + switch reflect.TypeOf(tmp28).Kind() { case reflect.Func: - tmp28 = lang.Apply(tmp27, nil) + tmp29 = lang.Apply(tmp28, nil) default: - tmp28 = tmp27 + tmp29 = tmp28 } - tmp29 := lang.Apply(tmp26, []any{tmp28}) - var v30 any = tmp29 - _ = v30 - tmp31, ok := lang.FieldOrMethod(v6, "clear") + tmp30 := lang.Apply(tmp27, []any{tmp29}) + var v31 any = tmp30 + _ = v31 + tmp32, ok := lang.FieldOrMethod(v7, "clear") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v6, "clear"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "clear"))) } - var tmp32 any - switch reflect.TypeOf(tmp31).Kind() { + var tmp33 any + switch reflect.TypeOf(tmp32).Kind() { case reflect.Func: - tmp32 = lang.Apply(tmp31, nil) + tmp33 = lang.Apply(tmp32, nil) default: - tmp32 = tmp31 + tmp33 = tmp32 } - _ = tmp32 - var tmp33 any + _ = tmp33 + var tmp34 any { // let // let binding "ret" - tmp34 := lang.Apply(v4, []any{v11, v30}) - var v35 any = tmp34 - _ = v35 - var tmp36 any - tmp37 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) - tmp38 := lang.Apply(tmp37, []any{v35}) - if lang.IsTruthy(tmp38) { + tmp35 := lang.Apply(v4, []any{v12, v31}) + var v36 any = tmp35 + _ = v36 + var tmp37 any + tmp38 := checkDerefVar(var_glojure_DOT_core_reduced_QMARK_) + tmp39 := lang.Apply(tmp38, []any{v36}) + if lang.IsTruthy(tmp39) { } else { - tmp39, _ := lang.FieldOrMethod(v6, "add") - if reflect.TypeOf(tmp39).Kind() != reflect.Func { + tmp40, _ := lang.FieldOrMethod(v7, "add") + if reflect.TypeOf(tmp40).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("add is not a function"))) } - tmp40 := lang.Apply(tmp39, []any{v12}) - tmp36 = tmp40 + tmp41 := lang.Apply(tmp40, []any{v13}) + tmp37 = tmp41 } - _ = tmp36 - tmp33 = v35 + _ = tmp37 + tmp34 = v36 } // end let - tmp25 = tmp33 + tmp26 = tmp34 } // end let - tmp21 = tmp25 + tmp22 = tmp26 } - tmp13 = tmp21 + tmp14 = tmp22 } // end let - return tmp13 + return tmp14 default: checkArity(args, -1) panic("unreachable") } }) - tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7152), kw_column, int(7), kw_end_DASH_line, int(7176), kw_end_DASH_column, int(28)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7152), kw_column, int(7), kw_end_DASH_line, int(7176), kw_end_DASH_column, int(28)) + tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) if err != nil { panic(err) } - tmp5 = tmp12 + tmp5 = tmp13 } // end let return tmp5 }) @@ -31779,30 +31786,30 @@ func LoadNS() { var tmp50 any if lang.IsTruthy(v49) { } else { - panic("unimplemented: new with non-constant class type") + panic(nil) } _ = tmp50 - tmp51 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) - var tmp52 any + tmp52 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + var tmp53 any { // let // let binding "or__0__auto__" - tmp53 := lang.Apply(v15, []any{v44}) - var v54 any = tmp53 - _ = v54 - var tmp55 any - if lang.IsTruthy(v54) { - tmp55 = v54 + tmp54 := lang.Apply(v15, []any{v44}) + var v55 any = tmp54 + _ = v55 + var tmp56 any + if lang.IsTruthy(v55) { + tmp56 = v55 } else { - tmp55 = v44 + tmp56 = v44 } - tmp52 = tmp55 + tmp53 = tmp56 } // end let - tmp53, _ := lang.FieldOrMethod(tmp51, "Refer") - if reflect.TypeOf(tmp53).Kind() != reflect.Func { + tmp54, _ := lang.FieldOrMethod(tmp52, "Refer") + if reflect.TypeOf(tmp54).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Refer is not a function"))) } - tmp54 := lang.Apply(tmp53, []any{tmp52, v49}) - tmp47 = tmp54 + tmp55 := lang.Apply(tmp54, []any{tmp53, v49}) + tmp47 = tmp55 } // end let tmp45 = tmp47 } @@ -31886,30 +31893,30 @@ func LoadNS() { var tmp62 any if lang.IsTruthy(v61) { } else { - panic("unimplemented: new with non-constant class type") + panic(nil) } _ = tmp62 - tmp63 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) - var tmp64 any + tmp64 := checkDerefVar(var_glojure_DOT_core__STAR_ns_STAR_) + var tmp65 any { // let // let binding "or__0__auto__" - tmp65 := lang.Apply(v15, []any{v56}) - var v66 any = tmp65 - _ = v66 - var tmp67 any - if lang.IsTruthy(v66) { - tmp67 = v66 + tmp66 := lang.Apply(v15, []any{v56}) + var v67 any = tmp66 + _ = v67 + var tmp68 any + if lang.IsTruthy(v67) { + tmp68 = v67 } else { - tmp67 = v56 + tmp68 = v56 } - tmp64 = tmp67 + tmp65 = tmp68 } // end let - tmp65, _ := lang.FieldOrMethod(tmp63, "Refer") - if reflect.TypeOf(tmp65).Kind() != reflect.Func { + tmp66, _ := lang.FieldOrMethod(tmp64, "Refer") + if reflect.TypeOf(tmp66).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Refer is not a function"))) } - tmp66 := lang.Apply(tmp65, []any{tmp64, v61}) - tmp59 = tmp66 + tmp67 := lang.Apply(tmp66, []any{tmp65, v61}) + tmp59 = tmp67 } // end let tmp57 = tmp59 } @@ -35513,7 +35520,7 @@ func LoadNS() { if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(0)}) + tmp5 := lang.Apply(tmp4, []any{v3, int64(0)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -35532,9 +35539,9 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "Minus") + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "minus") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("Minus is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("minus is not a function"))) } tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 @@ -35732,7 +35739,7 @@ func LoadNS() { if reflect.TypeOf(tmp4).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("Gt is not a function"))) } - tmp5 := lang.Apply(tmp4, []any{nil, int64(0)}) + tmp5 := lang.Apply(tmp4, []any{v3, int64(0)}) return tmp5 }) tmp2 = tmp2.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) @@ -35751,9 +35758,9 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - tmp6, _ := lang.FieldOrMethod(lang.Numbers, "MinusP") + tmp6, _ := lang.FieldOrMethod(lang.Numbers, "minusP") if reflect.TypeOf(tmp6).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("MinusP is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("minusP is not a function"))) } tmp7 := lang.Apply(tmp6, []any{v4, v5}) return tmp7 @@ -35794,58 +35801,59 @@ func LoadNS() { var tmp4 any { // let // let binding "a" - var v5 any = "unimplemented: new with non-constant class type" - _ = v5 + tmp5 := new(*lang.Agent) + var v6 any = tmp5 + _ = v6 // let binding "opts" - tmp6 := checkDerefVar(var_glojure_DOT_core_apply) - tmp7 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) - tmp8 := lang.Apply(tmp6, []any{tmp7, v3}) - var v9 any = tmp8 - _ = v9 - tmp10 := checkDerefVar(var_glojure_DOT_core_setup_DASH_reference) - tmp11 := lang.Apply(tmp10, []any{v5, v3}) - _ = tmp11 - var tmp12 any - tmp13 := lang.Apply(kw_error_DASH_handler, []any{v9}) - if lang.IsTruthy(tmp13) { - tmp14 := lang.Apply(kw_error_DASH_handler, []any{v9}) - tmp15, _ := lang.FieldOrMethod(v5, "setErrorHandler") - if reflect.TypeOf(tmp15).Kind() != reflect.Func { + tmp7 := checkDerefVar(var_glojure_DOT_core_apply) + tmp8 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp9 := lang.Apply(tmp7, []any{tmp8, v3}) + var v10 any = tmp9 + _ = v10 + tmp11 := checkDerefVar(var_glojure_DOT_core_setup_DASH_reference) + tmp12 := lang.Apply(tmp11, []any{v6, v3}) + _ = tmp12 + var tmp13 any + tmp14 := lang.Apply(kw_error_DASH_handler, []any{v10}) + if lang.IsTruthy(tmp14) { + tmp15 := lang.Apply(kw_error_DASH_handler, []any{v10}) + tmp16, _ := lang.FieldOrMethod(v6, "setErrorHandler") + if reflect.TypeOf(tmp16).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorHandler is not a function"))) } - tmp16 := lang.Apply(tmp15, []any{tmp14}) - tmp12 = tmp16 + tmp17 := lang.Apply(tmp16, []any{tmp15}) + tmp13 = tmp17 } else { } - _ = tmp12 - var tmp17 any + _ = tmp13 + var tmp18 any { // let // let binding "or__0__auto__" - tmp18 := lang.Apply(kw_error_DASH_mode, []any{v9}) - var v19 any = tmp18 - _ = v19 - var tmp20 any - if lang.IsTruthy(v19) { - tmp20 = v19 + tmp19 := lang.Apply(kw_error_DASH_mode, []any{v10}) + var v20 any = tmp19 + _ = v20 + var tmp21 any + if lang.IsTruthy(v20) { + tmp21 = v20 } else { - var tmp21 any - tmp22 := lang.Apply(kw_error_DASH_handler, []any{v9}) - if lang.IsTruthy(tmp22) { - tmp21 = kw_continue + var tmp22 any + tmp23 := lang.Apply(kw_error_DASH_handler, []any{v10}) + if lang.IsTruthy(tmp23) { + tmp22 = kw_continue } else { - tmp21 = kw_fail + tmp22 = kw_fail } - tmp20 = tmp21 + tmp21 = tmp22 } - tmp17 = tmp20 + tmp18 = tmp21 } // end let - tmp18, _ := lang.FieldOrMethod(v5, "setErrorMode") - if reflect.TypeOf(tmp18).Kind() != reflect.Func { + tmp19, _ := lang.FieldOrMethod(v6, "setErrorMode") + if reflect.TypeOf(tmp19).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("setErrorMode is not a function"))) } - tmp19 := lang.Apply(tmp18, []any{tmp17}) - _ = tmp19 - tmp4 = v5 + tmp20 := lang.Apply(tmp19, []any{tmp18}) + _ = tmp20 + tmp4 = v6 } // end let return tmp4 } @@ -43971,244 +43979,7 @@ func LoadNS() { var tmp8 any { // let // let binding "latch" - var v9 any = "unimplemented: new with non-constant class type" - _ = v9 - // let binding "count-down" - var tmp10 lang.FnFunc - tmp10 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v11 := args[0] - _ = v11 - tmp12, _ := lang.FieldOrMethod(v9, "countDown") - if reflect.TypeOf(tmp12).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("countDown is not a function"))) - } - tmp13 := lang.Apply(tmp12, []any{}) - _ = tmp13 - return v11 - }) - tmp11 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3279), kw_column, int(22), kw_end_DASH_line, int(3279), kw_end_DASH_column, int(61)) - tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - var v13 any = tmp12 - _ = v13 - var tmp14 any - { // let - // let binding "seq_692" - tmp15 := checkDerefVar(var_glojure_DOT_core_seq) - tmp16 := lang.Apply(tmp15, []any{v2}) - var v17 any = tmp16 - _ = v17 - // let binding "chunk_693" - var v18 any = nil - _ = v18 - // let binding "count_694" - var v19 any = int64(0) - _ = v19 - // let binding "i_695" - var v20 any = int64(0) - _ = v20 - for { - var tmp21 any - tmp22 := checkDerefVar(var_glojure_DOT_core__LT_) - tmp23 := lang.Apply(tmp22, []any{v20, v19}) - if lang.IsTruthy(tmp23) { - var tmp24 any - { // let - // let binding "agent" - tmp25, _ := lang.FieldOrMethod(v18, "nth") - if reflect.TypeOf(tmp25).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) - } - tmp26 := lang.Apply(tmp25, []any{v20}) - var v27 any = tmp26 - _ = v27 - tmp28 := checkDerefVar(var_glojure_DOT_core_send) - tmp29 := lang.Apply(tmp28, []any{v27, v13}) - _ = tmp29 - var tmp30 any = v17 - var tmp31 any = v18 - var tmp32 any = v19 - tmp34 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) - tmp35 := lang.Apply(tmp34, []any{v20}) - var tmp33 any = tmp35 - v17 = tmp30 - v18 = tmp31 - v19 = tmp32 - v20 = tmp33 - continue - } // end let - tmp21 = tmp24 - } else { - var tmp25 any - { // let - // let binding "temp__0__auto__" - tmp26 := checkDerefVar(var_glojure_DOT_core_seq) - tmp27 := lang.Apply(tmp26, []any{v17}) - var v28 any = tmp27 - _ = v28 - var tmp29 any - if lang.IsTruthy(v28) { - var tmp30 any - { // let - // let binding "seq_692" - var v31 any = v28 - _ = v31 - var tmp32 any - tmp33 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) - tmp34 := lang.Apply(tmp33, []any{v31}) - if lang.IsTruthy(tmp34) { - var tmp35 any - { // let - // let binding "c__0__auto__" - tmp36 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) - tmp37 := lang.Apply(tmp36, []any{v31}) - var v38 any = tmp37 - _ = v38 - tmp40 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) - tmp41 := lang.Apply(tmp40, []any{v31}) - var tmp39 any = tmp41 - var tmp42 any = v38 - tmp44 := checkDerefVar(var_glojure_DOT_core_int) - tmp45 := checkDerefVar(var_glojure_DOT_core_count) - tmp46 := lang.Apply(tmp45, []any{v38}) - tmp47 := lang.Apply(tmp44, []any{tmp46}) - var tmp43 any = tmp47 - tmp49 := checkDerefVar(var_glojure_DOT_core_int) - tmp50 := lang.Apply(tmp49, []any{int64(0)}) - var tmp48 any = tmp50 - v17 = tmp39 - v18 = tmp42 - v19 = tmp43 - v20 = tmp48 - continue - } // end let - tmp32 = tmp35 - } else { - var tmp36 any - { // let - // let binding "agent" - tmp37 := checkDerefVar(var_glojure_DOT_core_first) - tmp38 := lang.Apply(tmp37, []any{v31}) - var v39 any = tmp38 - _ = v39 - tmp40 := checkDerefVar(var_glojure_DOT_core_send) - tmp41 := lang.Apply(tmp40, []any{v39, v13}) - _ = tmp41 - tmp43 := checkDerefVar(var_glojure_DOT_core_next) - tmp44 := lang.Apply(tmp43, []any{v31}) - var tmp42 any = tmp44 - var tmp45 any = nil - var tmp46 any = int64(0) - var tmp47 any = int64(0) - v17 = tmp42 - v18 = tmp45 - v19 = tmp46 - v20 = tmp47 - continue - } // end let - tmp32 = tmp36 - } - tmp30 = tmp32 - } // end let - tmp29 = tmp30 - } else { - } - tmp25 = tmp29 - } // end let - tmp21 = tmp25 - } - tmp14 = tmp21 - break - } - } // end let - _ = tmp14 - tmp15, _ := lang.FieldOrMethod(v9, "await") - if reflect.TypeOf(tmp15).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) - } - tmp16 := lang.Apply(tmp15, []any{}) - tmp8 = tmp16 - } // end let - tmp3 = tmp8 - } - return tmp3 - } - }) - tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - var_glojure_DOT_core_await = ns.InternWithValue(tmp0, tmp1, true) - if tmp0.Meta() != nil { - var_glojure_DOT_core_await.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // await1 - { - tmp0 := sym_await1.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(3284), kw_column, int(7), kw_end_DASH_line, int(3284), kw_end_DASH_column, int(21), kw_arglists, lang.NewList(lang.NewVector(sym_a)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - var tmp1 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v2 := args[0] - _ = v2 - var tmp3 any - tmp4 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) - tmp5, ok := lang.FieldOrMethod(v2, "getQueueCount") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getQueueCount"))) - } - var tmp6 any - switch reflect.TypeOf(tmp5).Kind() { - case reflect.Func: - tmp6 = lang.Apply(tmp5, nil) - default: - tmp6 = tmp5 - } - tmp7 := lang.Apply(tmp4, []any{tmp6}) - if lang.IsTruthy(tmp7) { - tmp8 := checkDerefVar(var_glojure_DOT_core_await) - tmp9 := lang.Apply(tmp8, []any{v2}) - tmp3 = tmp9 - } else { - } - _ = tmp3 - return v2 - }) - tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - var_glojure_DOT_core_await1 = ns.InternWithValue(tmp0, tmp1, true) - if tmp0.Meta() != nil { - var_glojure_DOT_core_await1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // await-for - { - tmp0 := sym_await_DASH_for.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_timeout_DASH_ms, sym__AMP_, sym_agents)), kw_doc, "Blocks the current thread until all actions dispatched thus\n far (from this thread or agent) to the agents have occurred, or the\n timeout (in milliseconds) has elapsed. Returns logical false if\n returning due to timeout, logical true otherwise.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(3289), kw_end_DASH_line, int(3289))).(*lang.Symbol) - var tmp1 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArityGTE(args, 1) - v2 := args[0] - _ = v2 - var v3 any = lang.NewList(args[1:]...) - _ = v3 - var tmp4 any - tmp5 := lang.Apply(nil, nil) - if lang.IsTruthy(tmp5) { - panic("unimplemented: new with non-constant class type") - } else { - var tmp6 any - tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_agent_STAR_) - if lang.IsTruthy(tmp7) { - tmp8 := lang.Apply(errors5.New, []any{"Can't await in agent action"}) - panic(tmp8) - } else { - } - _ = tmp6 - var tmp9 any - { // let - // let binding "latch" - var v10 any = "unimplemented: new with non-constant class type" + var v10 any = nil _ = v10 // let binding "count-down" var tmp11 lang.FnFunc @@ -44224,7 +43995,7 @@ func LoadNS() { _ = tmp14 return v12 }) - tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3301), kw_column, int(23), kw_end_DASH_line, int(3301), kw_end_DASH_column, int(62)) + tmp12 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3279), kw_column, int(22), kw_end_DASH_line, int(3279), kw_end_DASH_column, int(61)) tmp13, err := lang.WithMeta(tmp11, tmp12.(lang.IPersistentMap)) if err != nil { panic(err) @@ -44233,18 +44004,18 @@ func LoadNS() { _ = v14 var tmp15 any { // let - // let binding "seq_696" + // let binding "seq_692" tmp16 := checkDerefVar(var_glojure_DOT_core_seq) - tmp17 := lang.Apply(tmp16, []any{v3}) + tmp17 := lang.Apply(tmp16, []any{v2}) var v18 any = tmp17 _ = v18 - // let binding "chunk_697" + // let binding "chunk_693" var v19 any = nil _ = v19 - // let binding "count_698" + // let binding "count_694" var v20 any = int64(0) _ = v20 - // let binding "i_699" + // let binding "i_695" var v21 any = int64(0) _ = v21 for { @@ -44290,7 +44061,7 @@ func LoadNS() { if lang.IsTruthy(v29) { var tmp31 any { // let - // let binding "seq_696" + // let binding "seq_692" var v32 any = v29 _ = v32 var tmp33 any @@ -44362,23 +44133,260 @@ func LoadNS() { } } // end let _ = tmp15 - tmp16, ok := lang.FieldOrMethod(nil, "MILLISECONDS") + tmp16, _ := lang.FieldOrMethod(v10, "await") + if reflect.TypeOf(tmp16).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) + } + tmp17 := lang.Apply(tmp16, []any{}) + tmp8 = tmp17 + } // end let + tmp3 = tmp8 + } + return tmp3 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_await = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_await.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // await1 + { + tmp0 := sym_await1.WithMeta(lang.NewMap(kw_static, true, kw_file, "glojure/core.glj", kw_line, int(3284), kw_column, int(7), kw_end_DASH_line, int(3284), kw_end_DASH_column, int(21), kw_arglists, lang.NewList(lang.NewVector(sym_a)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + var tmp3 any + tmp4 := checkDerefVar(var_glojure_DOT_core_pos_QMARK_) + tmp5, ok := lang.FieldOrMethod(v2, "getQueueCount") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v2, "getQueueCount"))) + } + var tmp6 any + switch reflect.TypeOf(tmp5).Kind() { + case reflect.Func: + tmp6 = lang.Apply(tmp5, nil) + default: + tmp6 = tmp5 + } + tmp7 := lang.Apply(tmp4, []any{tmp6}) + if lang.IsTruthy(tmp7) { + tmp8 := checkDerefVar(var_glojure_DOT_core_await) + tmp9 := lang.Apply(tmp8, []any{v2}) + tmp3 = tmp9 + } else { + } + _ = tmp3 + return v2 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_await1 = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_await1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // await-for + { + tmp0 := sym_await_DASH_for.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_timeout_DASH_ms, sym__AMP_, sym_agents)), kw_doc, "Blocks the current thread until all actions dispatched thus\n far (from this thread or agent) to the agents have occurred, or the\n timeout (in milliseconds) has elapsed. Returns logical false if\n returning due to timeout, logical true otherwise.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(15), kw_column, int(7), kw_line, int(3289), kw_end_DASH_line, int(3289))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArityGTE(args, 1) + v2 := args[0] + _ = v2 + var v3 any = lang.NewList(args[1:]...) + _ = v3 + var tmp4 any + tmp5 := lang.Apply(nil, nil) + if lang.IsTruthy(tmp5) { + panic("unimplemented: new with non-constant class type") + } else { + var tmp6 any + tmp7 := checkDerefVar(var_glojure_DOT_core__STAR_agent_STAR_) + if lang.IsTruthy(tmp7) { + tmp8 := lang.Apply(errors5.New, []any{"Can't await in agent action"}) + panic(tmp8) + } else { + } + _ = tmp6 + var tmp9 any + { // let + // let binding "latch" + var v11 any = nil + _ = v11 + // let binding "count-down" + var tmp12 lang.FnFunc + tmp12 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v13 := args[0] + _ = v13 + tmp14, _ := lang.FieldOrMethod(v11, "countDown") + if reflect.TypeOf(tmp14).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("countDown is not a function"))) + } + tmp15 := lang.Apply(tmp14, []any{}) + _ = tmp15 + return v13 + }) + tmp13 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(3301), kw_column, int(23), kw_end_DASH_line, int(3301), kw_end_DASH_column, int(62)) + tmp14, err := lang.WithMeta(tmp12, tmp13.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + var v15 any = tmp14 + _ = v15 + var tmp16 any + { // let + // let binding "seq_696" + tmp17 := checkDerefVar(var_glojure_DOT_core_seq) + tmp18 := lang.Apply(tmp17, []any{v3}) + var v19 any = tmp18 + _ = v19 + // let binding "chunk_697" + var v20 any = nil + _ = v20 + // let binding "count_698" + var v21 any = int64(0) + _ = v21 + // let binding "i_699" + var v22 any = int64(0) + _ = v22 + for { + var tmp23 any + tmp24 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp25 := lang.Apply(tmp24, []any{v22, v21}) + if lang.IsTruthy(tmp25) { + var tmp26 any + { // let + // let binding "agent" + tmp27, _ := lang.FieldOrMethod(v20, "nth") + if reflect.TypeOf(tmp27).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp28 := lang.Apply(tmp27, []any{v22}) + var v29 any = tmp28 + _ = v29 + tmp30 := checkDerefVar(var_glojure_DOT_core_send) + tmp31 := lang.Apply(tmp30, []any{v29, v15}) + _ = tmp31 + var tmp32 any = v19 + var tmp33 any = v20 + var tmp34 any = v21 + tmp36 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp37 := lang.Apply(tmp36, []any{v22}) + var tmp35 any = tmp37 + v19 = tmp32 + v20 = tmp33 + v21 = tmp34 + v22 = tmp35 + continue + } // end let + tmp23 = tmp26 + } else { + var tmp27 any + { // let + // let binding "temp__0__auto__" + tmp28 := checkDerefVar(var_glojure_DOT_core_seq) + tmp29 := lang.Apply(tmp28, []any{v19}) + var v30 any = tmp29 + _ = v30 + var tmp31 any + if lang.IsTruthy(v30) { + var tmp32 any + { // let + // let binding "seq_696" + var v33 any = v30 + _ = v33 + var tmp34 any + tmp35 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp36 := lang.Apply(tmp35, []any{v33}) + if lang.IsTruthy(tmp36) { + var tmp37 any + { // let + // let binding "c__0__auto__" + tmp38 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp39 := lang.Apply(tmp38, []any{v33}) + var v40 any = tmp39 + _ = v40 + tmp42 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp43 := lang.Apply(tmp42, []any{v33}) + var tmp41 any = tmp43 + var tmp44 any = v40 + tmp46 := checkDerefVar(var_glojure_DOT_core_int) + tmp47 := checkDerefVar(var_glojure_DOT_core_count) + tmp48 := lang.Apply(tmp47, []any{v40}) + tmp49 := lang.Apply(tmp46, []any{tmp48}) + var tmp45 any = tmp49 + tmp51 := checkDerefVar(var_glojure_DOT_core_int) + tmp52 := lang.Apply(tmp51, []any{int64(0)}) + var tmp50 any = tmp52 + v19 = tmp41 + v20 = tmp44 + v21 = tmp45 + v22 = tmp50 + continue + } // end let + tmp34 = tmp37 + } else { + var tmp38 any + { // let + // let binding "agent" + tmp39 := checkDerefVar(var_glojure_DOT_core_first) + tmp40 := lang.Apply(tmp39, []any{v33}) + var v41 any = tmp40 + _ = v41 + tmp42 := checkDerefVar(var_glojure_DOT_core_send) + tmp43 := lang.Apply(tmp42, []any{v41, v15}) + _ = tmp43 + tmp45 := checkDerefVar(var_glojure_DOT_core_next) + tmp46 := lang.Apply(tmp45, []any{v33}) + var tmp44 any = tmp46 + var tmp47 any = nil + var tmp48 any = int64(0) + var tmp49 any = int64(0) + v19 = tmp44 + v20 = tmp47 + v21 = tmp48 + v22 = tmp49 + continue + } // end let + tmp34 = tmp38 + } + tmp32 = tmp34 + } // end let + tmp31 = tmp32 + } else { + } + tmp27 = tmp31 + } // end let + tmp23 = tmp27 + } + tmp16 = tmp23 + break + } + } // end let + _ = tmp16 + tmp17, ok := lang.FieldOrMethod(nil, "MILLISECONDS") if !ok { panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", nil, "MILLISECONDS"))) } - var tmp17 any - switch reflect.TypeOf(tmp16).Kind() { + var tmp18 any + switch reflect.TypeOf(tmp17).Kind() { case reflect.Func: - tmp17 = lang.Apply(tmp16, nil) + tmp18 = lang.Apply(tmp17, nil) default: - tmp17 = tmp16 + tmp18 = tmp17 } - tmp18, _ := lang.FieldOrMethod(v10, "await") - if reflect.TypeOf(tmp18).Kind() != reflect.Func { + tmp19, _ := lang.FieldOrMethod(v11, "await") + if reflect.TypeOf(tmp19).Kind() != reflect.Func { panic(lang.NewIllegalArgumentError(fmt.Sprintf("await is not a function"))) } - tmp19 := lang.Apply(tmp18, []any{v2, tmp17}) - tmp9 = tmp19 + tmp20 := lang.Apply(tmp19, []any{v2, tmp18}) + tmp9 = tmp20 } // end let tmp4 = tmp9 } @@ -52949,34 +52957,35 @@ func LoadNS() { var tmp4 any { // let // let binding "s__0__auto__" - var v5 any = "unimplemented: new with non-constant class type" - _ = v5 - var tmp6 any + tmp5 := new(strings8.Builder) + var v6 any = tmp5 + _ = v6 + var tmp7 any { // let - tmp7 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) - tmp8 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) - tmp9 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) - tmp10 := lang.Apply(tmp8, []any{tmp9, v5}) - tmp11 := lang.Apply(tmp7, []any{tmp10}) - _ = tmp11 - var tmp12 any + tmp8 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp9 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp10 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) + tmp11 := lang.Apply(tmp9, []any{tmp10, v6}) + tmp12 := lang.Apply(tmp8, []any{tmp11}) + _ = tmp12 + var tmp13 any func() { defer func() { - tmp13 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) - tmp14 := lang.Apply(tmp13, nil) - _ = tmp14 + tmp14 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp15 := lang.Apply(tmp14, nil) + _ = tmp15 }() - tmp15 := checkDerefVar(var_glojure_DOT_core_apply) - tmp16 := checkDerefVar(var_glojure_DOT_core_pr) - tmp17 := lang.Apply(tmp15, []any{tmp16, v3}) - _ = tmp17 - tmp18 := checkDerefVar(var_glojure_DOT_core_str) - tmp19 := lang.Apply(tmp18, []any{v5}) - tmp12 = tmp19 + tmp16 := checkDerefVar(var_glojure_DOT_core_apply) + tmp17 := checkDerefVar(var_glojure_DOT_core_pr) + tmp18 := lang.Apply(tmp16, []any{tmp17, v3}) + _ = tmp18 + tmp19 := checkDerefVar(var_glojure_DOT_core_str) + tmp20 := lang.Apply(tmp19, []any{v6}) + tmp13 = tmp20 }() - tmp6 = tmp12 + tmp7 = tmp13 } // end let - tmp4 = tmp6 + tmp4 = tmp7 } // end let return tmp4 } @@ -53043,34 +53052,35 @@ func LoadNS() { var tmp4 any { // let // let binding "s__0__auto__" - var v5 any = "unimplemented: new with non-constant class type" - _ = v5 - var tmp6 any + tmp5 := new(strings8.Builder) + var v6 any = tmp5 + _ = v6 + var tmp7 any { // let - tmp7 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) - tmp8 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) - tmp9 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) - tmp10 := lang.Apply(tmp8, []any{tmp9, v5}) - tmp11 := lang.Apply(tmp7, []any{tmp10}) - _ = tmp11 - var tmp12 any + tmp8 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp9 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp10 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) + tmp11 := lang.Apply(tmp9, []any{tmp10, v6}) + tmp12 := lang.Apply(tmp8, []any{tmp11}) + _ = tmp12 + var tmp13 any func() { defer func() { - tmp13 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) - tmp14 := lang.Apply(tmp13, nil) - _ = tmp14 + tmp14 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp15 := lang.Apply(tmp14, nil) + _ = tmp15 }() - tmp15 := checkDerefVar(var_glojure_DOT_core_apply) - tmp16 := checkDerefVar(var_glojure_DOT_core_print) - tmp17 := lang.Apply(tmp15, []any{tmp16, v3}) - _ = tmp17 - tmp18 := checkDerefVar(var_glojure_DOT_core_str) - tmp19 := lang.Apply(tmp18, []any{v5}) - tmp12 = tmp19 + tmp16 := checkDerefVar(var_glojure_DOT_core_apply) + tmp17 := checkDerefVar(var_glojure_DOT_core_print) + tmp18 := lang.Apply(tmp16, []any{tmp17, v3}) + _ = tmp18 + tmp19 := checkDerefVar(var_glojure_DOT_core_str) + tmp20 := lang.Apply(tmp19, []any{v6}) + tmp13 = tmp20 }() - tmp6 = tmp12 + tmp7 = tmp13 } // end let - tmp4 = tmp6 + tmp4 = tmp7 } // end let return tmp4 } @@ -53156,34 +53166,35 @@ func LoadNS() { var tmp4 any { // let // let binding "s__0__auto__" - var v5 any = "unimplemented: new with non-constant class type" - _ = v5 - var tmp6 any + tmp5 := new(strings8.Builder) + var v6 any = tmp5 + _ = v6 + var tmp7 any { // let - tmp7 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) - tmp8 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) - tmp9 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) - tmp10 := lang.Apply(tmp8, []any{tmp9, v5}) - tmp11 := lang.Apply(tmp7, []any{tmp10}) - _ = tmp11 - var tmp12 any + tmp8 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp9 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp10 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) + tmp11 := lang.Apply(tmp9, []any{tmp10, v6}) + tmp12 := lang.Apply(tmp8, []any{tmp11}) + _ = tmp12 + var tmp13 any func() { defer func() { - tmp13 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) - tmp14 := lang.Apply(tmp13, nil) - _ = tmp14 + tmp14 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp15 := lang.Apply(tmp14, nil) + _ = tmp15 }() - tmp15 := checkDerefVar(var_glojure_DOT_core_apply) - tmp16 := checkDerefVar(var_glojure_DOT_core_prn) - tmp17 := lang.Apply(tmp15, []any{tmp16, v3}) - _ = tmp17 - tmp18 := checkDerefVar(var_glojure_DOT_core_str) - tmp19 := lang.Apply(tmp18, []any{v5}) - tmp12 = tmp19 + tmp16 := checkDerefVar(var_glojure_DOT_core_apply) + tmp17 := checkDerefVar(var_glojure_DOT_core_prn) + tmp18 := lang.Apply(tmp16, []any{tmp17, v3}) + _ = tmp18 + tmp19 := checkDerefVar(var_glojure_DOT_core_str) + tmp20 := lang.Apply(tmp19, []any{v6}) + tmp13 = tmp20 }() - tmp6 = tmp12 + tmp7 = tmp13 } // end let - tmp4 = tmp6 + tmp4 = tmp7 } // end let return tmp4 } @@ -53250,34 +53261,35 @@ func LoadNS() { var tmp4 any { // let // let binding "s__0__auto__" - var v5 any = "unimplemented: new with non-constant class type" - _ = v5 - var tmp6 any + tmp5 := new(strings8.Builder) + var v6 any = tmp5 + _ = v6 + var tmp7 any { // let - tmp7 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) - tmp8 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) - tmp9 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) - tmp10 := lang.Apply(tmp8, []any{tmp9, v5}) - tmp11 := lang.Apply(tmp7, []any{tmp10}) - _ = tmp11 - var tmp12 any + tmp8 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) + tmp9 := checkDerefVar(var_glojure_DOT_core_hash_DASH_map) + tmp10 := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_out_STAR_) + tmp11 := lang.Apply(tmp9, []any{tmp10, v6}) + tmp12 := lang.Apply(tmp8, []any{tmp11}) + _ = tmp12 + var tmp13 any func() { defer func() { - tmp13 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) - tmp14 := lang.Apply(tmp13, nil) - _ = tmp14 + tmp14 := checkDerefVar(var_glojure_DOT_core_pop_DASH_thread_DASH_bindings) + tmp15 := lang.Apply(tmp14, nil) + _ = tmp15 }() - tmp15 := checkDerefVar(var_glojure_DOT_core_apply) - tmp16 := checkDerefVar(var_glojure_DOT_core_println) - tmp17 := lang.Apply(tmp15, []any{tmp16, v3}) - _ = tmp17 - tmp18 := checkDerefVar(var_glojure_DOT_core_str) - tmp19 := lang.Apply(tmp18, []any{v5}) - tmp12 = tmp19 + tmp16 := checkDerefVar(var_glojure_DOT_core_apply) + tmp17 := checkDerefVar(var_glojure_DOT_core_println) + tmp18 := lang.Apply(tmp16, []any{tmp17, v3}) + _ = tmp18 + tmp19 := checkDerefVar(var_glojure_DOT_core_str) + tmp20 := lang.Apply(tmp19, []any{v6}) + tmp13 = tmp20 }() - tmp6 = tmp12 + tmp7 = tmp13 } // end let - tmp4 = tmp6 + tmp4 = tmp7 } // end let return tmp4 } @@ -56143,41 +56155,42 @@ func LoadNS() { var v8 any = tmp7 _ = v8 // let binding "sw" - var v9 any = "unimplemented: new with non-constant class type" - _ = v9 - var tmp10 any + tmp9 := new(strings8.Builder) + var v10 any = tmp9 + _ = v10 + var tmp11 any { // let // let binding "r" - tmp11 := checkDerefVar(var_glojure_DOT_core_apply) - tmp12 := checkDerefVar(var_glojure_DOT_go_DOT_io_reader) - tmp13 := lang.Apply(tmp11, []any{tmp12, v3, v8}) - var v14 any = tmp13 - _ = v14 - var tmp15 any + tmp12 := checkDerefVar(var_glojure_DOT_core_apply) + tmp13 := checkDerefVar(var_glojure_DOT_go_DOT_io_reader) + tmp14 := lang.Apply(tmp12, []any{tmp13, v3, v8}) + var v15 any = tmp14 + _ = v15 + var tmp16 any func() { defer func() { - tmp16, ok := lang.FieldOrMethod(v14, "close") + tmp17, ok := lang.FieldOrMethod(v15, "close") if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v14, "close"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v15, "close"))) } - var tmp17 any - switch reflect.TypeOf(tmp16).Kind() { + var tmp18 any + switch reflect.TypeOf(tmp17).Kind() { case reflect.Func: - tmp17 = lang.Apply(tmp16, nil) + tmp18 = lang.Apply(tmp17, nil) default: - tmp17 = tmp16 + tmp18 = tmp17 } - _ = tmp17 + _ = tmp18 }() - tmp18 := checkDerefVar(var_glojure_DOT_go_DOT_io_copy) - tmp19 := lang.Apply(tmp18, []any{v14, v9}) - _ = tmp19 - tmp20 := lang.Apply(lang.ToString, []any{v9}) - tmp15 = tmp20 + tmp19 := checkDerefVar(var_glojure_DOT_go_DOT_io_copy) + tmp20 := lang.Apply(tmp19, []any{v15, v10}) + _ = tmp20 + tmp21 := lang.Apply(lang.ToString, []any{v10}) + tmp16 = tmp21 }() - tmp10 = tmp15 + tmp11 = tmp16 } // end let - tmp5 = tmp10 + tmp5 = tmp11 } // end let return tmp5 } diff --git a/scripts/rewrite-core/rewrite.clj b/scripts/rewrite-core/rewrite.clj index 8417a5c3..187c8dab 100644 --- a/scripts/rewrite-core/rewrite.clj +++ b/scripts/rewrite-core/rewrite.clj @@ -298,6 +298,8 @@ '(github.com$glojurelang$glojure$pkg$lang.CreatePersistentStructMap s inits)) (sexpr-replace '(. clojure.lang.PersistentStructMap (construct s vals)) '(github.com$glojurelang$glojure$pkg$lang.ConstructPersistentStructMap s vals)) + (sexpr-replace '(. clojure.lang.PersistentStructMap (getAccessor s key)) + '(github.com$glojurelang$glojure$pkg$lang.GetPersistentStructMapAccessor s key)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (sexpr-replace '(.. (name lib) @@ -735,7 +737,7 @@ (catch Exception e false))) (fn visit [zloc] (z/replace zloc (let [sym (-> zloc z/sexpr str)] - (symbol (str (string/upper-case (first sym)) (subs sym 1))))))] + (symbol (str (first sym) (subs sym 1))))))] (sexpr-splice-replace 'clojure.lang.Numbers/gt ['.Gt 'github.com$glojurelang$glojure$pkg$lang.Numbers]) From f1f46e94136241ba7ac039dcb21e455c361d9ac8 Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Mon, 1 Sep 2025 11:49:18 -0700 Subject: [PATCH 59/67] Add codegen for def Signed-off-by: James Hamlin --- pkg/runtime/codegen.go | 32 +++++- pkg/runtime/environment.go | 5 - pkg/runtime/evalast.go | 31 +++--- .../testdata/codegen/test/core/load.go.out | 11 ++ .../testdata/codegen/test/def_simple.glj | 10 +- .../codegen/test/def_simple/load.go.out | 105 ++++++++++++++++-- .../codegen/test/fn_recur/load.go.out | 4 +- 7 files changed, 161 insertions(+), 37 deletions(-) diff --git a/pkg/runtime/codegen.go b/pkg/runtime/codegen.go index df864d4f..32931911 100644 --- a/pkg/runtime/codegen.go +++ b/pkg/runtime/codegen.go @@ -982,16 +982,15 @@ func (g *Generator) generateFnMethod(methodNode *ast.FnMethodNode, argsVar strin func (g *Generator) generateASTNode(node *ast.Node) (res string) { switch node.Op { case ast.OpDef: - fmt.Println("Def not yet implemented; returning nil") - return "nil" - case ast.OpSetBang: - return g.generateSetBang(node) + return g.generateDef(node) case ast.OpLetFn: fmt.Println("LetFn not yet implemented; returning nil") return "nil" case ast.OpGo: fmt.Println("Go not yet implemented; returning nil") return "nil" + case ast.OpSetBang: + return g.generateSetBang(node) case ast.OpCase: return g.generateCase(node) case ast.OpTry: @@ -1050,6 +1049,31 @@ func (g *Generator) generateASTNode(node *ast.Node) (res string) { } } +func (g *Generator) generateDef(node *ast.Node) string { + defNode := node.Sub.(*ast.DefNode) + init := defNode.Init + vr := defNode.Var + meta := defNode.Meta + + vrVar := g.allocVarVar(vr.Namespace().Name().String(), vr.Symbol().String()) + if !lang.IsNil(meta) { + metaVar := g.generateASTNode(meta) + g.writef("%s.SetMeta(%s.(lang.IPersistentMap))\n", vrVar, metaVar) + // SetDynamic if dynamic kw true in meta + g.writef("if runtime.RT.BooleanCast(lang.Get(%s, lang.KWDynamic)) {\n", metaVar) + g.writef("\t%s.SetDynamic()\n", vrVar) + g.writef("}\n") + } + + if lang.IsNil(init) { + return vrVar // No initialization + } + initVar := g.generateASTNode(init) + g.writef("%s.BindRoot(%s)\n", vrVar, initVar) + + return vrVar +} + // generateVarDeref generates code for a Var dereference func (g *Generator) generateVarDeref(node *ast.Node) string { varNode := node.Sub.(*ast.VarNode) diff --git a/pkg/runtime/environment.go b/pkg/runtime/environment.go index 6baa4d39..e103640c 100644 --- a/pkg/runtime/environment.go +++ b/pkg/runtime/environment.go @@ -114,11 +114,6 @@ func (env *environment) DefVar(sym *lang.Symbol, val interface{}) *lang.Var { return v } -func (env *environment) DefineMacro(name string, fn lang.IFn) { - vr := env.DefVar(lang.NewSymbol(name), fn) - vr.SetMacro() -} - func (env *environment) lookup(sym *lang.Symbol) (res interface{}, ok bool) { v, ok := env.scope.lookup(sym) if ok { diff --git a/pkg/runtime/evalast.go b/pkg/runtime/evalast.go index 4cdbecd0..4bfe45af 100644 --- a/pkg/runtime/evalast.go +++ b/pkg/runtime/evalast.go @@ -125,34 +125,29 @@ func (env *environment) EvalAST(x interface{}) (ret interface{}, err error) { func (env *environment) EvalASTDef(n *ast.Node) (interface{}, error) { defNode := n.Sub.(*ast.DefNode) init := defNode.Init - if lang.IsNil(init) { - return defNode.Var, nil - } - - initVal, err := env.EvalAST(init) - if err != nil { - return nil, err - } - sym := defNode.Name - - // evaluate symbol metadata if present + vr := defNode.Var meta := defNode.Meta if !lang.IsNil(meta) { metaVal, err := env.EvalAST(meta) if err != nil { return nil, err } - s, err := lang.WithMeta(sym, metaVal.(lang.IPersistentMap)) - if err != nil { - return nil, err + vr.SetMeta(metaVal.(lang.IPersistentMap)) + // set dynamic if :dynamic true in meta + if RT.BooleanCast(lang.Get(vr.Meta(), lang.KWDynamic)) { + vr.SetDynamic() } - sym = s.(*lang.Symbol) + } + if lang.IsNil(init) { + return defNode.Var, nil } - vr := env.DefVar(sym, initVal) - if RT.BooleanCast(lang.Get(vr.Meta(), lang.KWDynamic)) { - vr.SetDynamic() + initVal, err := env.EvalAST(init) + if err != nil { + return nil, err } + vr.BindRoot(initVal) + return vr, nil } diff --git a/pkg/runtime/testdata/codegen/test/core/load.go.out b/pkg/runtime/testdata/codegen/test/core/load.go.out index e7bcb159..16f10987 100644 --- a/pkg/runtime/testdata/codegen/test/core/load.go.out +++ b/pkg/runtime/testdata/codegen/test/core/load.go.out @@ -1273,6 +1273,7 @@ func LoadNS() { sym_with_DASH_bindings := lang.NewSymbol("with-bindings") sym_with_DASH_bindings_STAR_ := lang.NewSymbol("with-bindings*") sym_with_DASH_in_DASH_str := lang.NewSymbol("with-in-str") + sym_with_DASH_init := lang.NewSymbol("with-init") sym_with_DASH_loading_DASH_context := lang.NewSymbol("with-loading-context") sym_with_DASH_local_DASH_vars := lang.NewSymbol("with-local-vars") sym_with_DASH_meta := lang.NewSymbol("with-meta") @@ -2790,6 +2791,8 @@ func LoadNS() { var_glojure_DOT_core_with_DASH_bindings_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_bindings_STAR_) // var glojure.core/with-in-str var_glojure_DOT_core_with_DASH_in_DASH_str := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_in_DASH_str) + // var glojure.core/with-init + var_glojure_DOT_core_with_DASH_init := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_init) // var glojure.core/with-loading-context var_glojure_DOT_core_with_DASH_loading_DASH_context := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_loading_DASH_context) // var glojure.core/with-local-vars @@ -8053,6 +8056,14 @@ func LoadNS() { var_glojure_DOT_core_when_DASH_not.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } + // with-init + { + tmp0 := sym_with_DASH_init.WithMeta(lang.NewMap(kw_file, "codegen/test/def_simple.glj", kw_line, int(7), kw_column, int(8), kw_end_DASH_line, int(7), kw_end_DASH_column, int(16), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) + var_glojure_DOT_core_with_DASH_init = ns.InternWithValue(tmp0, int64(42), true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_with_DASH_init.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } // with-meta { tmp0 := sym_with_DASH_meta.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_obj, sym_m)), kw_doc, "Returns an object of the same type and value as obj, with\n map m as its metadata.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(2), kw_line, int(211), kw_end_DASH_line, int(216))).(*lang.Symbol) diff --git a/pkg/runtime/testdata/codegen/test/def_simple.glj b/pkg/runtime/testdata/codegen/test/def_simple.glj index f7ff0f9c..25b24e50 100644 --- a/pkg/runtime/testdata/codegen/test/def_simple.glj +++ b/pkg/runtime/testdata/codegen/test/def_simple.glj @@ -1,3 +1,11 @@ (ns codegen.test.def-simple) -(def foo) +(defn deftest [val] + (def no-init) + (def with-init val)) + +(defn + ^{:expected-output ["Unbound: #'codegen.test.def-simple/no-init" 42]} + -main [] + (deftest 42) + [(str (deref #'no-init)) with-init]) diff --git a/pkg/runtime/testdata/codegen/test/def_simple/load.go.out b/pkg/runtime/testdata/codegen/test/def_simple/load.go.out index 7a378261..05c67ded 100644 --- a/pkg/runtime/testdata/codegen/test/def_simple/load.go.out +++ b/pkg/runtime/testdata/codegen/test/def_simple/load.go.out @@ -34,22 +34,113 @@ func checkArityGTE(args []any, min int) { // LoadNS initializes the namespace "codegen.test.def-simple" func LoadNS() { + sym__DASH_main := lang.NewSymbol("-main") sym_codegen_DOT_test_DOT_def_DASH_simple := lang.NewSymbol("codegen.test.def-simple") - sym_foo := lang.NewSymbol("foo") - // var codegen.test.def-simple/foo - var_codegen_DOT_test_DOT_def_DASH_simple_foo := lang.InternVarName(sym_codegen_DOT_test_DOT_def_DASH_simple, sym_foo) + sym_deftest := lang.NewSymbol("deftest") + sym_deref := lang.NewSymbol("deref") + sym_glojure_DOT_core := lang.NewSymbol("glojure.core") + sym_no_DASH_init := lang.NewSymbol("no-init") + sym_str := lang.NewSymbol("str") + sym_val := lang.NewSymbol("val") + sym_with_DASH_init := lang.NewSymbol("with-init") + kw_arglists := lang.NewKeyword("arglists") + kw_column := lang.NewKeyword("column") + kw_end_DASH_column := lang.NewKeyword("end-column") + kw_end_DASH_line := lang.NewKeyword("end-line") + kw_expected_DASH_output := lang.NewKeyword("expected-output") + kw_file := lang.NewKeyword("file") + kw_line := lang.NewKeyword("line") + kw_ns := lang.NewKeyword("ns") + kw_rettag := lang.NewKeyword("rettag") + // var codegen.test.def-simple/-main + var_codegen_DOT_test_DOT_def_DASH_simple__DASH_main := lang.InternVarName(sym_codegen_DOT_test_DOT_def_DASH_simple, sym__DASH_main) + // var codegen.test.def-simple/deftest + var_codegen_DOT_test_DOT_def_DASH_simple_deftest := lang.InternVarName(sym_codegen_DOT_test_DOT_def_DASH_simple, sym_deftest) + // var codegen.test.def-simple/no-init + var_codegen_DOT_test_DOT_def_DASH_simple_no_DASH_init := lang.InternVarName(sym_codegen_DOT_test_DOT_def_DASH_simple, sym_no_DASH_init) + // var codegen.test.def-simple/with-init + var_codegen_DOT_test_DOT_def_DASH_simple_with_DASH_init := lang.InternVarName(sym_codegen_DOT_test_DOT_def_DASH_simple, sym_with_DASH_init) + // var glojure.core/deref + var_glojure_DOT_core_deref := lang.InternVarName(sym_glojure_DOT_core, sym_deref) + // var glojure.core/str + var_glojure_DOT_core_str := lang.InternVarName(sym_glojure_DOT_core, sym_str) // reference fmt to avoid unused import error _ = fmt.Printf // reference reflect to avoid unused import error _ = reflect.TypeOf ns := lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_def_DASH_simple) _ = ns - // foo + // deftest { - tmp0 := sym_foo.WithMeta(lang.NewMap()).(*lang.Symbol) - var_codegen_DOT_test_DOT_def_DASH_simple_foo = ns.Intern(tmp0) + tmp0 := sym_deftest.WithMeta(lang.NewMap(kw_file, "codegen/test/def_simple.glj", kw_line, int(3), kw_column, int(7), kw_end_DASH_line, int(3), kw_end_DASH_column, int(13), kw_arglists, lang.NewList(lang.NewVector(sym_val)), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_def_DASH_simple))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v2 := args[0] + _ = v2 + tmp3 := lang.NewMap(kw_file, "codegen/test/def_simple.glj", kw_line, int(4), kw_column, int(8), kw_end_DASH_line, int(4), kw_end_DASH_column, int(14)) + var_codegen_DOT_test_DOT_def_DASH_simple_no_DASH_init.SetMeta(tmp3.(lang.IPersistentMap)) + if runtime.RT.BooleanCast(lang.Get(tmp3, lang.KWDynamic)) { + var_codegen_DOT_test_DOT_def_DASH_simple_no_DASH_init.SetDynamic() + } + _ = var_codegen_DOT_test_DOT_def_DASH_simple_no_DASH_init + tmp4 := lang.NewMap(kw_file, "codegen/test/def_simple.glj", kw_line, int(5), kw_column, int(8), kw_end_DASH_line, int(5), kw_end_DASH_column, int(16)) + var_codegen_DOT_test_DOT_def_DASH_simple_with_DASH_init.SetMeta(tmp4.(lang.IPersistentMap)) + if runtime.RT.BooleanCast(lang.Get(tmp4, lang.KWDynamic)) { + var_codegen_DOT_test_DOT_def_DASH_simple_with_DASH_init.SetDynamic() + } + var_codegen_DOT_test_DOT_def_DASH_simple_with_DASH_init.BindRoot(v2) + return var_codegen_DOT_test_DOT_def_DASH_simple_with_DASH_init + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_codegen_DOT_test_DOT_def_DASH_simple_deftest = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { - var_codegen_DOT_test_DOT_def_DASH_simple_foo.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + var_codegen_DOT_test_DOT_def_DASH_simple_deftest.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // no-init + { + tmp0 := sym_no_DASH_init.WithMeta(lang.NewMap()).(*lang.Symbol) + var_codegen_DOT_test_DOT_def_DASH_simple_no_DASH_init = ns.Intern(tmp0) + if tmp0.Meta() != nil { + var_codegen_DOT_test_DOT_def_DASH_simple_no_DASH_init.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // with-init + { + tmp0 := sym_with_DASH_init.WithMeta(lang.NewMap()).(*lang.Symbol) + var_codegen_DOT_test_DOT_def_DASH_simple_with_DASH_init = ns.Intern(tmp0) + if tmp0.Meta() != nil { + var_codegen_DOT_test_DOT_def_DASH_simple_with_DASH_init.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // -main + { + tmp0 := sym__DASH_main.WithMeta(lang.NewMap(kw_expected_DASH_output, lang.NewVector("Unbound: #'codegen.test.def-simple/no-init", int64(42)), kw_file, "codegen/test/def_simple.glj", kw_line, int(8), kw_column, int(3), kw_end_DASH_line, int(9), kw_end_DASH_column, int(7), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_def_DASH_simple))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + tmp2 := checkDerefVar(var_codegen_DOT_test_DOT_def_DASH_simple_deftest) + tmp3 := lang.Apply(tmp2, []any{int64(42)}) + _ = tmp3 + tmp4 := checkDerefVar(var_glojure_DOT_core_str) + tmp5 := checkDerefVar(var_glojure_DOT_core_deref) + tmp6 := lang.InternVarName(sym_codegen_DOT_test_DOT_def_DASH_simple, sym_no_DASH_init) + tmp7 := lang.Apply(tmp5, []any{tmp6}) + tmp8 := lang.Apply(tmp4, []any{tmp7}) + tmp9 := checkDerefVar(var_codegen_DOT_test_DOT_def_DASH_simple_with_DASH_init) + tmp10 := lang.NewVector(tmp8, tmp9) + tmp11 := lang.NewMap(kw_file, "codegen/test/def_simple.glj", kw_line, int(11), kw_column, int(3), kw_end_DASH_line, int(11), kw_end_DASH_column, int(37)) + tmp12, err := lang.WithMeta(tmp10, tmp11.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp12 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_codegen_DOT_test_DOT_def_DASH_simple__DASH_main = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_codegen_DOT_test_DOT_def_DASH_simple__DASH_main.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } } diff --git a/pkg/runtime/testdata/codegen/test/fn_recur/load.go.out b/pkg/runtime/testdata/codegen/test/fn_recur/load.go.out index 0e62fdef..7fca5b2d 100644 --- a/pkg/runtime/testdata/codegen/test/fn_recur/load.go.out +++ b/pkg/runtime/testdata/codegen/test/fn_recur/load.go.out @@ -106,7 +106,7 @@ func LoadNS() { _ = v7 v8 := args[2] _ = v8 - recur_loop_1617: + recur_loop_1619: var tmp9 any tmp10 := checkDerefVar(var_glojure_DOT_core__EQ_) tmp11 := lang.Apply(tmp10, []any{v8, v2}) @@ -123,7 +123,7 @@ func LoadNS() { v6 = tmp12 v7 = tmp13 v8 = tmp16 - goto recur_loop_1617 + goto recur_loop_1619 } return tmp9 }) From 573dad37fd287d40526def94e8405754f04d7985 Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Mon, 1 Sep 2025 12:08:07 -0700 Subject: [PATCH 60/67] Disable vet till gen code passes vet Signed-off-by: James Hamlin --- Makefile | 2 +- pkg/runtime/rtcompat.go | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/Makefile b/Makefile index c3752460..85ceb4c5 100644 --- a/Makefile +++ b/Makefile @@ -62,7 +62,7 @@ $(TEST_TARGETS): gocmd @$(GO_CMD) run ./cmd/glj/main.go $(basename $@) .PHONY: test -test: vet $(TEST_TARGETS) +test: $(TEST_TARGETS) # vet - vet is disabled until we fix errors in generated code .PHONY: format format: diff --git a/pkg/runtime/rtcompat.go b/pkg/runtime/rtcompat.go index d7119fc7..718c9bbd 100644 --- a/pkg/runtime/rtcompat.go +++ b/pkg/runtime/rtcompat.go @@ -175,6 +175,7 @@ func (rt *RTMethods) Load(scriptBase string) { } ReadEval(string(buf), WithFilename(filename)) + // if compileFiles is set, compile the namespace to a .go file compileFiles := VarCompileFiles.Get().(bool) if !compileFiles { return From d9091795c24972bafbd0c482bb55403e85287c31 Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Mon, 1 Sep 2025 12:21:46 -0700 Subject: [PATCH 61/67] Implement goroutine special form Signed-off-by: James Hamlin --- pkg/runtime/codegen.go | 23 ++- .../testdata/codegen/test/core/load.go.out | 32 ++-- .../testdata/codegen/test/goroutine.glj | 15 ++ .../codegen/test/goroutine/load.go.out | 180 ++++++++++++++++++ 4 files changed, 229 insertions(+), 21 deletions(-) create mode 100644 pkg/runtime/testdata/codegen/test/goroutine.glj create mode 100644 pkg/runtime/testdata/codegen/test/goroutine/load.go.out diff --git a/pkg/runtime/codegen.go b/pkg/runtime/codegen.go index 32931911..59569a96 100644 --- a/pkg/runtime/codegen.go +++ b/pkg/runtime/codegen.go @@ -987,8 +987,7 @@ func (g *Generator) generateASTNode(node *ast.Node) (res string) { fmt.Println("LetFn not yet implemented; returning nil") return "nil" case ast.OpGo: - fmt.Println("Go not yet implemented; returning nil") - return "nil" + return g.generateGo(node) case ast.OpSetBang: return g.generateSetBang(node) case ast.OpCase: @@ -1074,6 +1073,26 @@ func (g *Generator) generateDef(node *ast.Node) string { return vrVar } +func (g *Generator) generateGo(node *ast.Node) string { + goNode := node.Sub.(*ast.GoNode) + + invokeNode := goNode.Invoke.Sub.(*ast.InvokeNode) + fn := invokeNode.Fn + args := invokeNode.Args + + // Generate the function expression + fnExpr := g.generateASTNode(fn) + + // Generate the arguments + var argExprs []string + for _, arg := range args { + argExprs = append(argExprs, g.generateASTNode(arg)) + } + + g.writef("go lang.Apply(%s, []any{%s})\n", fnExpr, strings.Join(argExprs, ", ")) + return "nil" // starting a goroutine returns nil +} + // generateVarDeref generates code for a Var dereference func (g *Generator) generateVarDeref(node *ast.Node) string { varNode := node.Sub.(*ast.VarNode) diff --git a/pkg/runtime/testdata/codegen/test/core/load.go.out b/pkg/runtime/testdata/codegen/test/core/load.go.out index 16f10987..1a6e9a96 100644 --- a/pkg/runtime/testdata/codegen/test/core/load.go.out +++ b/pkg/runtime/testdata/codegen/test/core/load.go.out @@ -268,6 +268,7 @@ func LoadNS() { sym_codegen_DOT_test_DOT_def_DASH_simple := lang.NewSymbol("codegen.test.def-simple") sym_codegen_DOT_test_DOT_fn_DASH_closure := lang.NewSymbol("codegen.test.fn-closure") sym_codegen_DOT_test_DOT_fn_DASH_recur := lang.NewSymbol("codegen.test.fn-recur") + sym_codegen_DOT_test_DOT_goroutine := lang.NewSymbol("codegen.test.goroutine") sym_codegen_DOT_test_DOT_loop_DASH_simple := lang.NewSymbol("codegen.test.loop-simple") sym_codegen_DOT_test_DOT_maybe_DASH_class := lang.NewSymbol("codegen.test.maybe-class") sym_codegen_DOT_test_DOT_multifn := lang.NewSymbol("codegen.test.multifn") @@ -1273,7 +1274,6 @@ func LoadNS() { sym_with_DASH_bindings := lang.NewSymbol("with-bindings") sym_with_DASH_bindings_STAR_ := lang.NewSymbol("with-bindings*") sym_with_DASH_in_DASH_str := lang.NewSymbol("with-in-str") - sym_with_DASH_init := lang.NewSymbol("with-init") sym_with_DASH_loading_DASH_context := lang.NewSymbol("with-loading-context") sym_with_DASH_local_DASH_vars := lang.NewSymbol("with-local-vars") sym_with_DASH_meta := lang.NewSymbol("with-meta") @@ -2791,8 +2791,6 @@ func LoadNS() { var_glojure_DOT_core_with_DASH_bindings_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_bindings_STAR_) // var glojure.core/with-in-str var_glojure_DOT_core_with_DASH_in_DASH_str := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_in_DASH_str) - // var glojure.core/with-init - var_glojure_DOT_core_with_DASH_init := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_init) // var glojure.core/with-loading-context var_glojure_DOT_core_with_DASH_loading_DASH_context := lang.InternVarName(sym_glojure_DOT_core, sym_with_DASH_loading_DASH_context) // var glojure.core/with-local-vars @@ -3103,27 +3101,30 @@ func LoadNS() { } // *1 { - tmp0 := sym__STAR_1.WithMeta(lang.NewMap()).(*lang.Symbol) + tmp0 := sym__STAR_1.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core.glj", kw_line, int(6268), kw_column, int(6), kw_end_DASH_line, int(6271), kw_end_DASH_column, int(3), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var_glojure_DOT_core__STAR_1 = ns.Intern(tmp0) if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_1.SetDynamic() } // *2 { - tmp0 := sym__STAR_2.WithMeta(lang.NewMap()).(*lang.Symbol) + tmp0 := sym__STAR_2.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core.glj", kw_line, int(6273), kw_column, int(6), kw_end_DASH_line, int(6276), kw_end_DASH_column, int(3), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var_glojure_DOT_core__STAR_2 = ns.Intern(tmp0) if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_2.SetDynamic() } // *3 { - tmp0 := sym__STAR_3.WithMeta(lang.NewMap()).(*lang.Symbol) + tmp0 := sym__STAR_3.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core.glj", kw_line, int(6278), kw_column, int(6), kw_end_DASH_line, int(6281), kw_end_DASH_column, int(3), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var_glojure_DOT_core__STAR_3 = ns.Intern(tmp0) if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_3.SetDynamic() } // *agent* { @@ -3193,11 +3194,12 @@ func LoadNS() { } // *e { - tmp0 := sym__STAR_e.WithMeta(lang.NewMap()).(*lang.Symbol) + tmp0 := sym__STAR_e.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core.glj", kw_line, int(6283), kw_column, int(6), kw_end_DASH_line, int(6286), kw_end_DASH_column, int(3), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var_glojure_DOT_core__STAR_e = ns.Intern(tmp0) if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_e.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_e.SetDynamic() } // *err* { @@ -3226,7 +3228,7 @@ func LoadNS() { // *loaded-libs* { tmp0 := sym__STAR_loaded_DASH_libs_STAR_.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core.glj", kw_line, int(5817), kw_column, int(10), kw_end_DASH_line, int(5820), kw_end_DASH_column, int(15), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - tmp1 := lang.NewRef(lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{sym_glojure_DOT_core_DOT_protocols, sym_glojure_DOT_string, sym_glojure_DOT_go_DOT_io, sym_codegen_DOT_test_DOT_case_DASH_switch, sym_codegen_DOT_test_DOT_const_DASH_keyword, sym_codegen_DOT_test_DOT_const_DASH_number, sym_codegen_DOT_test_DOT_const_DASH_string, sym_codegen_DOT_test_DOT_def_DASH_simple, sym_codegen_DOT_test_DOT_fn_DASH_closure, sym_codegen_DOT_test_DOT_fn_DASH_recur, sym_codegen_DOT_test_DOT_loop_DASH_simple, sym_codegen_DOT_test_DOT_maybe_DASH_class, sym_codegen_DOT_test_DOT_multifn, sym_codegen_DOT_test_DOT_ns_DASH_skip, sym_codegen_DOT_test_DOT_quote_DASH_simple, sym_codegen_DOT_test_DOT_ref, sym_codegen_DOT_test_DOT_set_DASH_bang, sym_codegen_DOT_test_DOT_the_DASH_var, sym_codegen_DOT_test_DOT_throw_DASH_simple, sym_codegen_DOT_test_DOT_try_DASH_advanced, sym_codegen_DOT_test_DOT_try_DASH_basic, sym_codegen_DOT_test_DOT_values, sym_codegen_DOT_test_DOT_with_DASH_meta}))) + tmp1 := lang.NewRef(lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{sym_glojure_DOT_core_DOT_protocols, sym_glojure_DOT_string, sym_glojure_DOT_go_DOT_io, sym_codegen_DOT_test_DOT_case_DASH_switch, sym_codegen_DOT_test_DOT_const_DASH_keyword, sym_codegen_DOT_test_DOT_const_DASH_number, sym_codegen_DOT_test_DOT_const_DASH_string, sym_codegen_DOT_test_DOT_def_DASH_simple, sym_codegen_DOT_test_DOT_fn_DASH_closure, sym_codegen_DOT_test_DOT_fn_DASH_recur, sym_codegen_DOT_test_DOT_goroutine, sym_codegen_DOT_test_DOT_loop_DASH_simple, sym_codegen_DOT_test_DOT_maybe_DASH_class, sym_codegen_DOT_test_DOT_multifn, sym_codegen_DOT_test_DOT_ns_DASH_skip, sym_codegen_DOT_test_DOT_quote_DASH_simple, sym_codegen_DOT_test_DOT_ref, sym_codegen_DOT_test_DOT_set_DASH_bang, sym_codegen_DOT_test_DOT_the_DASH_var, sym_codegen_DOT_test_DOT_throw_DASH_simple, sym_codegen_DOT_test_DOT_try_DASH_advanced, sym_codegen_DOT_test_DOT_try_DASH_basic, sym_codegen_DOT_test_DOT_values, sym_codegen_DOT_test_DOT_with_DASH_meta}))) var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -4530,7 +4532,7 @@ func LoadNS() { } // gen-class { - tmp0 := sym_gen_DASH_class.WithMeta(lang.NewMap()).(*lang.Symbol) + tmp0 := sym_gen_DASH_class.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5732), kw_column, int(10), kw_end_DASH_line, int(5732), kw_end_DASH_column, int(18), kw_declared, true, kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var_glojure_DOT_core_gen_DASH_class = ns.Intern(tmp0) if tmp0.Meta() != nil { var_glojure_DOT_core_gen_DASH_class.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -7618,7 +7620,7 @@ func LoadNS() { } // unquote { - tmp0 := sym_unquote.WithMeta(lang.NewMap()).(*lang.Symbol) + tmp0 := sym_unquote.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(11), kw_column, int(6), kw_end_DASH_line, int(11), kw_end_DASH_column, int(12), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var_glojure_DOT_core_unquote = ns.Intern(tmp0) if tmp0.Meta() != nil { var_glojure_DOT_core_unquote.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -7626,7 +7628,7 @@ func LoadNS() { } // unquote-splicing { - tmp0 := sym_unquote_DASH_splicing.WithMeta(lang.NewMap()).(*lang.Symbol) + tmp0 := sym_unquote_DASH_splicing.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(12), kw_column, int(6), kw_end_DASH_line, int(12), kw_end_DASH_column, int(21), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var_glojure_DOT_core_unquote_DASH_splicing = ns.Intern(tmp0) if tmp0.Meta() != nil { var_glojure_DOT_core_unquote_DASH_splicing.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -8056,14 +8058,6 @@ func LoadNS() { var_glojure_DOT_core_when_DASH_not.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // with-init - { - tmp0 := sym_with_DASH_init.WithMeta(lang.NewMap(kw_file, "codegen/test/def_simple.glj", kw_line, int(7), kw_column, int(8), kw_end_DASH_line, int(7), kw_end_DASH_column, int(16), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - var_glojure_DOT_core_with_DASH_init = ns.InternWithValue(tmp0, int64(42), true) - if tmp0.Meta() != nil { - var_glojure_DOT_core_with_DASH_init.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } // with-meta { tmp0 := sym_with_DASH_meta.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_obj, sym_m)), kw_doc, "Returns an object of the same type and value as obj, with\n map m as its metadata.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(10), kw_column, int(2), kw_line, int(211), kw_end_DASH_line, int(216))).(*lang.Symbol) diff --git a/pkg/runtime/testdata/codegen/test/goroutine.glj b/pkg/runtime/testdata/codegen/test/goroutine.glj new file mode 100644 index 00000000..c9b29243 --- /dev/null +++ b/pkg/runtime/testdata/codegen/test/goroutine.glj @@ -0,0 +1,15 @@ +(ns codegen.test.goroutine) + +(defn send-on-chan [ch val] + (let [chVal (reflect.ValueOf ch) + valVal (reflect.ValueOf val)] + (.Send chVal valVal))) + +(defn ^{:expected-output 42} -main [] + (let [ch (go/make (go/chan-of go/int64)) + chVal (reflect.ValueOf ch)] + (go/go (send-on-chan ch 42)) + (let [[recvResult ok] (.Recv chVal)] + (if (not ok) + (throw (fmt.Errorf "Channel closed"))) + (.Interface recvResult)))) diff --git a/pkg/runtime/testdata/codegen/test/goroutine/load.go.out b/pkg/runtime/testdata/codegen/test/goroutine/load.go.out new file mode 100644 index 00000000..713700af --- /dev/null +++ b/pkg/runtime/testdata/codegen/test/goroutine/load.go.out @@ -0,0 +1,180 @@ +// Code generated by glojure codegen. DO NOT EDIT. + +package goroutine + +import ( + fmt "fmt" + lang "github.com/glojurelang/glojure/pkg/lang" + runtime "github.com/glojurelang/glojure/pkg/runtime" + reflect "reflect" +) + +func init() { + runtime.RegisterNSLoader("codegen/test/goroutine", LoadNS) +} + +func checkDerefVar(v *lang.Var) any { + if v.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) + } + return v.Get() +} + +func checkArity(args []any, expected int) { + if len(args) != expected { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + +func checkArityGTE(args []any, min int) { + if len(args) < min { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + +// LoadNS initializes the namespace "codegen.test.goroutine" +func LoadNS() { + sym__DASH_main := lang.NewSymbol("-main") + sym_ch := lang.NewSymbol("ch") + sym_codegen_DOT_test_DOT_goroutine := lang.NewSymbol("codegen.test.goroutine") + sym_glojure_DOT_core := lang.NewSymbol("glojure.core") + sym_not := lang.NewSymbol("not") + sym_nth := lang.NewSymbol("nth") + sym_send_DASH_on_DASH_chan := lang.NewSymbol("send-on-chan") + sym_val := lang.NewSymbol("val") + kw_arglists := lang.NewKeyword("arglists") + kw_column := lang.NewKeyword("column") + kw_end_DASH_column := lang.NewKeyword("end-column") + kw_end_DASH_line := lang.NewKeyword("end-line") + kw_expected_DASH_output := lang.NewKeyword("expected-output") + kw_file := lang.NewKeyword("file") + kw_line := lang.NewKeyword("line") + kw_ns := lang.NewKeyword("ns") + kw_rettag := lang.NewKeyword("rettag") + // var codegen.test.goroutine/-main + var_codegen_DOT_test_DOT_goroutine__DASH_main := lang.InternVarName(sym_codegen_DOT_test_DOT_goroutine, sym__DASH_main) + // var codegen.test.goroutine/send-on-chan + var_codegen_DOT_test_DOT_goroutine_send_DASH_on_DASH_chan := lang.InternVarName(sym_codegen_DOT_test_DOT_goroutine, sym_send_DASH_on_DASH_chan) + // var glojure.core/not + var_glojure_DOT_core_not := lang.InternVarName(sym_glojure_DOT_core, sym_not) + // var glojure.core/nth + var_glojure_DOT_core_nth := lang.InternVarName(sym_glojure_DOT_core, sym_nth) + // reference fmt to avoid unused import error + _ = fmt.Printf + // reference reflect to avoid unused import error + _ = reflect.TypeOf + ns := lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_goroutine) + _ = ns + // send-on-chan + { + tmp0 := sym_send_DASH_on_DASH_chan.WithMeta(lang.NewMap(kw_file, "codegen/test/goroutine.glj", kw_line, int(3), kw_column, int(7), kw_end_DASH_line, int(3), kw_end_DASH_column, int(18), kw_arglists, lang.NewList(lang.NewVector(sym_ch, sym_val)), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_goroutine))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // let + // let binding "chVal" + tmp5 := lang.Apply(reflect.ValueOf, []any{v2}) + var v6 any = tmp5 + _ = v6 + // let binding "valVal" + tmp7 := lang.Apply(reflect.ValueOf, []any{v3}) + var v8 any = tmp7 + _ = v8 + tmp9, _ := lang.FieldOrMethod(v6, "Send") + if reflect.TypeOf(tmp9).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("Send is not a function"))) + } + tmp10 := lang.Apply(tmp9, []any{v8}) + tmp4 = tmp10 + } // end let + return tmp4 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_codegen_DOT_test_DOT_goroutine_send_DASH_on_DASH_chan = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_codegen_DOT_test_DOT_goroutine_send_DASH_on_DASH_chan.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // -main + { + tmp0 := sym__DASH_main.WithMeta(lang.NewMap(kw_expected_DASH_output, int64(42), kw_file, "codegen/test/goroutine.glj", kw_line, int(8), kw_column, int(7), kw_end_DASH_line, int(8), kw_end_DASH_column, int(34), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_goroutine))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp2 any + { // let + // let binding "ch" + tmp3 := lang.Apply(lang.Builtins["chan-of"], []any{lang.Builtins["int64"]}) + tmp4 := lang.Apply(lang.Builtins["make"], []any{tmp3}) + var v5 any = tmp4 + _ = v5 + // let binding "chVal" + tmp6 := lang.Apply(reflect.ValueOf, []any{v5}) + var v7 any = tmp6 + _ = v7 + tmp8 := checkDerefVar(var_codegen_DOT_test_DOT_goroutine_send_DASH_on_DASH_chan) + go lang.Apply(tmp8, []any{v5, int64(42)}) + var tmp9 any + { // let + // let binding "vec__368" + tmp10, ok := lang.FieldOrMethod(v7, "Recv") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v7, "Recv"))) + } + var tmp11 any + switch reflect.TypeOf(tmp10).Kind() { + case reflect.Func: + tmp11 = lang.Apply(tmp10, nil) + default: + tmp11 = tmp10 + } + var v12 any = tmp11 + _ = v12 + // let binding "recvResult" + tmp13 := checkDerefVar(var_glojure_DOT_core_nth) + tmp14 := lang.Apply(tmp13, []any{v12, int64(0), nil}) + var v15 any = tmp14 + _ = v15 + // let binding "ok" + tmp16 := checkDerefVar(var_glojure_DOT_core_nth) + tmp17 := lang.Apply(tmp16, []any{v12, int64(1), nil}) + var v18 any = tmp17 + _ = v18 + var tmp19 any + tmp20 := checkDerefVar(var_glojure_DOT_core_not) + tmp21 := lang.Apply(tmp20, []any{v18}) + if lang.IsTruthy(tmp21) { + tmp22 := lang.Apply(fmt.Errorf, []any{"Channel closed"}) + panic(tmp22) + } else { + } + _ = tmp19 + tmp23, ok := lang.FieldOrMethod(v15, "Interface") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v15, "Interface"))) + } + var tmp24 any + switch reflect.TypeOf(tmp23).Kind() { + case reflect.Func: + tmp24 = lang.Apply(tmp23, nil) + default: + tmp24 = tmp23 + } + tmp9 = tmp24 + } // end let + tmp2 = tmp9 + } // end let + return tmp2 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_codegen_DOT_test_DOT_goroutine__DASH_main = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_codegen_DOT_test_DOT_goroutine__DASH_main.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } +} From c8591481d2b6f26cdfb611ee01282d2dc22122c8 Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Mon, 1 Sep 2025 12:30:37 -0700 Subject: [PATCH 62/67] Implement codegen for letfn Signed-off-by: James Hamlin --- pkg/runtime/codegen.go | 39 +- .../testdata/codegen/test/core/load.go.out | 821 ++++++++++++------ pkg/runtime/testdata/codegen/test/letfn.glj | 11 + .../testdata/codegen/test/letfn/load.go.out | 117 +++ 4 files changed, 732 insertions(+), 256 deletions(-) create mode 100644 pkg/runtime/testdata/codegen/test/letfn.glj create mode 100644 pkg/runtime/testdata/codegen/test/letfn/load.go.out diff --git a/pkg/runtime/codegen.go b/pkg/runtime/codegen.go index 59569a96..73feb135 100644 --- a/pkg/runtime/codegen.go +++ b/pkg/runtime/codegen.go @@ -984,8 +984,7 @@ func (g *Generator) generateASTNode(node *ast.Node) (res string) { case ast.OpDef: return g.generateDef(node) case ast.OpLetFn: - fmt.Println("LetFn not yet implemented; returning nil") - return "nil" + return g.generateLetFn(node) case ast.OpGo: return g.generateGo(node) case ast.OpSetBang: @@ -1294,6 +1293,42 @@ func (g *Generator) generateLet(node *ast.Node, isLoop bool) string { return resultId } +func (g *Generator) generateLetFn(node *ast.Node) string { + letFnNode := node.Sub.(*ast.LetFnNode) + + resultId := g.allocateTempVar() + g.writef("var %s any\n", resultId) + + // Push a new variable scope for the letfn bindings + g.writef("{ // letfn\n") + g.pushVarScope() + defer func() { + g.popVarScope() + g.writef("} // end letfn\n") + }() + + // Emit bindings directly to g.w + for _, binding := range letFnNode.Bindings { + bindingNode := binding.Sub.(*ast.BindingNode) + name := bindingNode.Name + fn := bindingNode.Init + + // Allocate a Go variable for the Clojure name + g.writef("// letfn binding \"%s\"\n", name) + varName := g.allocateLocal(name.Name()) + // declare the variable now to allow for recursion + g.writef("var %s lang.FnFunc\n", varName) + fnVar := g.generateASTNode(fn) + g.writeAssign(varName, fnVar) + g.writeAssign("_", varName) // Prevent unused variable warning + } + + // Return the body expression (r-value) + result := g.generateASTNode(letFnNode.Body) + g.writeAssign(resultId, result) + return resultId +} + func (g *Generator) generateRecur(node *ast.Node) string { recurNode := node.Sub.(*ast.RecurNode) diff --git a/pkg/runtime/testdata/codegen/test/core/load.go.out b/pkg/runtime/testdata/codegen/test/core/load.go.out index 1a6e9a96..d744e54a 100644 --- a/pkg/runtime/testdata/codegen/test/core/load.go.out +++ b/pkg/runtime/testdata/codegen/test/core/load.go.out @@ -269,6 +269,7 @@ func LoadNS() { sym_codegen_DOT_test_DOT_fn_DASH_closure := lang.NewSymbol("codegen.test.fn-closure") sym_codegen_DOT_test_DOT_fn_DASH_recur := lang.NewSymbol("codegen.test.fn-recur") sym_codegen_DOT_test_DOT_goroutine := lang.NewSymbol("codegen.test.goroutine") + sym_codegen_DOT_test_DOT_letfn := lang.NewSymbol("codegen.test.letfn") sym_codegen_DOT_test_DOT_loop_DASH_simple := lang.NewSymbol("codegen.test.loop-simple") sym_codegen_DOT_test_DOT_maybe_DASH_class := lang.NewSymbol("codegen.test.maybe-class") sym_codegen_DOT_test_DOT_multifn := lang.NewSymbol("codegen.test.multifn") @@ -3228,7 +3229,7 @@ func LoadNS() { // *loaded-libs* { tmp0 := sym__STAR_loaded_DASH_libs_STAR_.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core.glj", kw_line, int(5817), kw_column, int(10), kw_end_DASH_line, int(5820), kw_end_DASH_column, int(15), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - tmp1 := lang.NewRef(lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{sym_glojure_DOT_core_DOT_protocols, sym_glojure_DOT_string, sym_glojure_DOT_go_DOT_io, sym_codegen_DOT_test_DOT_case_DASH_switch, sym_codegen_DOT_test_DOT_const_DASH_keyword, sym_codegen_DOT_test_DOT_const_DASH_number, sym_codegen_DOT_test_DOT_const_DASH_string, sym_codegen_DOT_test_DOT_def_DASH_simple, sym_codegen_DOT_test_DOT_fn_DASH_closure, sym_codegen_DOT_test_DOT_fn_DASH_recur, sym_codegen_DOT_test_DOT_goroutine, sym_codegen_DOT_test_DOT_loop_DASH_simple, sym_codegen_DOT_test_DOT_maybe_DASH_class, sym_codegen_DOT_test_DOT_multifn, sym_codegen_DOT_test_DOT_ns_DASH_skip, sym_codegen_DOT_test_DOT_quote_DASH_simple, sym_codegen_DOT_test_DOT_ref, sym_codegen_DOT_test_DOT_set_DASH_bang, sym_codegen_DOT_test_DOT_the_DASH_var, sym_codegen_DOT_test_DOT_throw_DASH_simple, sym_codegen_DOT_test_DOT_try_DASH_advanced, sym_codegen_DOT_test_DOT_try_DASH_basic, sym_codegen_DOT_test_DOT_values, sym_codegen_DOT_test_DOT_with_DASH_meta}))) + tmp1 := lang.NewRef(lang.CreatePersistentTreeSet(lang.NewSliceSeq([]any{sym_glojure_DOT_core_DOT_protocols, sym_glojure_DOT_string, sym_glojure_DOT_go_DOT_io, sym_codegen_DOT_test_DOT_case_DASH_switch, sym_codegen_DOT_test_DOT_const_DASH_keyword, sym_codegen_DOT_test_DOT_const_DASH_number, sym_codegen_DOT_test_DOT_const_DASH_string, sym_codegen_DOT_test_DOT_def_DASH_simple, sym_codegen_DOT_test_DOT_fn_DASH_closure, sym_codegen_DOT_test_DOT_fn_DASH_recur, sym_codegen_DOT_test_DOT_goroutine, sym_codegen_DOT_test_DOT_letfn, sym_codegen_DOT_test_DOT_loop_DASH_simple, sym_codegen_DOT_test_DOT_maybe_DASH_class, sym_codegen_DOT_test_DOT_multifn, sym_codegen_DOT_test_DOT_ns_DASH_skip, sym_codegen_DOT_test_DOT_quote_DASH_simple, sym_codegen_DOT_test_DOT_ref, sym_codegen_DOT_test_DOT_set_DASH_bang, sym_codegen_DOT_test_DOT_the_DASH_var, sym_codegen_DOT_test_DOT_throw_DASH_simple, sym_codegen_DOT_test_DOT_try_DASH_advanced, sym_codegen_DOT_test_DOT_try_DASH_basic, sym_codegen_DOT_test_DOT_values, sym_codegen_DOT_test_DOT_with_DASH_meta}))) var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_ = ns.InternWithValue(tmp0, tmp1, true) if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_loaded_DASH_libs_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -11589,119 +11590,6 @@ func LoadNS() { var_glojure_DOT_core_io_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // keep-indexed - { - tmp0 := sym_keep_DASH_indexed.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_coll)), kw_doc, "Returns a lazy sequence of the non-nil results of (f index item). Note,\n this means false return values will be included. f must be free of\n side-effects. Returns a stateful transducer when no collection is\n provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(7372), kw_end_DASH_line, int(7372))).(*lang.Symbol) - var tmp1 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v2 := args[0] - _ = v2 - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - var tmp5 any - { // let - // let binding "iv" - tmp6 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) - tmp7 := lang.Apply(tmp6, []any{int64(-1)}) - var v8 any = tmp7 - _ = v8 - var tmp9 lang.FnFunc - tmp9 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp10 := lang.Apply(v4, nil) - return tmp10 - case 1: - v10 := args[0] - _ = v10 - tmp11 := lang.Apply(v4, []any{v10}) - return tmp11 - case 2: - v10 := args[0] - _ = v10 - v11 := args[1] - _ = v11 - var tmp12 any - { // let - // let binding "i" - tmp13 := checkDerefVar(var_glojure_DOT_core_inc) - tmp14, ok := lang.FieldOrMethod(v8, "Deref") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "Deref"))) - } - var tmp15 any - switch reflect.TypeOf(tmp14).Kind() { - case reflect.Func: - tmp15 = lang.Apply(tmp14, nil) - default: - tmp15 = tmp14 - } - tmp16 := lang.Apply(tmp13, []any{tmp15}) - tmp17, _ := lang.FieldOrMethod(v8, "reset") - if reflect.TypeOf(tmp17).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) - } - tmp18 := lang.Apply(tmp17, []any{tmp16}) - var v19 any = tmp18 - _ = v19 - // let binding "v" - tmp20 := lang.Apply(v2, []any{v19, v11}) - var v21 any = tmp20 - _ = v21 - var tmp22 any - tmp23 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) - tmp24 := lang.Apply(tmp23, []any{v21}) - if lang.IsTruthy(tmp24) { - tmp22 = v10 - } else { - tmp25 := lang.Apply(v4, []any{v10, v21}) - tmp22 = tmp25 - } - tmp12 = tmp22 - } // end let - return tmp12 - default: - checkArity(args, -1) - panic("unreachable") - } - }) - tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7382), kw_column, int(8), kw_end_DASH_line, int(7390), kw_end_DASH_column, int(33)) - tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp5 = tmp11 - } // end let - return tmp5 - }) - tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7380), kw_column, int(4), kw_end_DASH_line, int(7390), kw_end_DASH_column, int(35)) - tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp5 - case 2: - v2 := args[0] - _ = v2 - v3 := args[1] - _ = v3 - return nil - default: - checkArity(args, -1) - panic("unreachable") - } - }) - tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - var_glojure_DOT_core_keep_DASH_indexed = ns.InternWithValue(tmp0, tmp1, true) - if tmp0.Meta() != nil { - var_glojure_DOT_core_keep_DASH_indexed.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } // keyword { tmp1 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() @@ -12155,101 +12043,6 @@ func LoadNS() { var_glojure_DOT_core_macroexpand.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // map-indexed - { - tmp0 := sym_map_DASH_indexed.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_coll)), kw_doc, "Returns a lazy sequence consisting of the result of applying f to 0\n and the first item of coll, followed by applying f to 1 and the second\n item in coll, etc, until coll is exhausted. Thus function f should\n accept 2 arguments, index and item. Returns a stateful transducer when\n no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(7309), kw_end_DASH_line, int(7309))).(*lang.Symbol) - var tmp1 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v2 := args[0] - _ = v2 - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - var tmp5 any - { // let - // let binding "i" - tmp6 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) - tmp7 := lang.Apply(tmp6, []any{int64(-1)}) - var v8 any = tmp7 - _ = v8 - var tmp9 lang.FnFunc - tmp9 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp10 := lang.Apply(v4, nil) - return tmp10 - case 1: - v10 := args[0] - _ = v10 - tmp11 := lang.Apply(v4, []any{v10}) - return tmp11 - case 2: - v10 := args[0] - _ = v10 - v11 := args[1] - _ = v11 - tmp12 := checkDerefVar(var_glojure_DOT_core_inc) - tmp13, ok := lang.FieldOrMethod(v8, "Deref") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "Deref"))) - } - var tmp14 any - switch reflect.TypeOf(tmp13).Kind() { - case reflect.Func: - tmp14 = lang.Apply(tmp13, nil) - default: - tmp14 = tmp13 - } - tmp15 := lang.Apply(tmp12, []any{tmp14}) - tmp16, _ := lang.FieldOrMethod(v8, "reset") - if reflect.TypeOf(tmp16).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) - } - tmp17 := lang.Apply(tmp16, []any{tmp15}) - tmp18 := lang.Apply(v2, []any{tmp17, v11}) - tmp19 := lang.Apply(v4, []any{v10, tmp18}) - return tmp19 - default: - checkArity(args, -1) - panic("unreachable") - } - }) - tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7320), kw_column, int(8), kw_end_DASH_line, int(7324), kw_end_DASH_column, int(48)) - tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp5 = tmp11 - } // end let - return tmp5 - }) - tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7318), kw_column, int(4), kw_end_DASH_line, int(7324), kw_end_DASH_column, int(50)) - tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp5 - case 2: - v2 := args[0] - _ = v2 - v3 := args[1] - _ = v3 - return nil - default: - checkArity(args, -1) - panic("unreachable") - } - }) - tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - var_glojure_DOT_core_map_DASH_indexed = ns.InternWithValue(tmp0, tmp1, true) - if tmp0.Meta() != nil { - var_glojure_DOT_core_map_DASH_indexed.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } // maybe-destructured { tmp0 := sym_maybe_DASH_destructured.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(4514), kw_column, int(7), kw_end_DASH_line, int(4515), kw_end_DASH_column, int(20), kw_arglists, lang.NewList(lang.NewVector(sym_params, sym_body)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) @@ -26662,57 +26455,342 @@ func LoadNS() { var_glojure_DOT_core_keep.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // lazy-seq - { - tmp0 := sym_lazy_DASH_seq.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_body)), kw_doc, "Takes a body of expressions that returns an ISeq or nil, and yields\n a Seqable object that will invoke the body only the first time seq\n is called, and will cache the result and return it on all subsequent\n seq calls. See also - realized?", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(11), kw_line, int(676), kw_end_DASH_line, int(676))).(*lang.Symbol) - var tmp1 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - default: - checkArityGTE(args, 2) - v2 := args[0] - _ = v2 - v3 := args[1] - _ = v3 - var v4 any = lang.NewList(args[2:]...) - _ = v4 - tmp5 := checkDerefVar(var_glojure_DOT_core_list) - tmp6 := checkDerefVar(var_glojure_DOT_core_list_STAR_) - tmp7 := lang.NewVector() - tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(683), kw_column, int(101), kw_end_DASH_line, int(683), kw_end_DASH_column, int(102)) - tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp10 := lang.Apply(tmp6, []any{sym_fn_STAR_, tmp9, v4}) - tmp11 := lang.Apply(tmp5, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_NewLazySeq, tmp10}) - return tmp11 - } - }) - tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - var_glojure_DOT_core_lazy_DASH_seq = ns.InternWithValue(tmp0, tmp1, true) - if tmp0.Meta() != nil { - var_glojure_DOT_core_lazy_DASH_seq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } - // locking + // keep-indexed { - tmp0 := sym_locking.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_x, sym__AMP_, sym_body)), kw_doc, "Executes exprs in an implicit do, while holding the monitor of x.\n Will release the monitor of x in all circumstances.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(1643), kw_end_DASH_line, int(1643))).(*lang.Symbol) + tmp0 := sym_keep_DASH_indexed.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_coll)), kw_doc, "Returns a lazy sequence of the non-nil results of (f index item). Note,\n this means false return values will be included. f must be free of\n side-effects. Returns a stateful transducer when no collection is\n provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(7372), kw_end_DASH_line, int(7372))).(*lang.Symbol) var tmp1 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { switch len(args) { - default: - checkArityGTE(args, 3) + case 1: v2 := args[0] _ = v2 - v3 := args[1] - _ = v3 - v4 := args[2] - _ = v4 - var v5 any = lang.NewList(args[3:]...) - _ = v5 - tmp6 := checkDerefVar(var_glojure_DOT_core_seq) - tmp7 := checkDerefVar(var_glojure_DOT_core_concat) + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 any + { // let + // let binding "iv" + tmp6 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) + tmp7 := lang.Apply(tmp6, []any{int64(-1)}) + var v8 any = tmp7 + _ = v8 + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp10 := lang.Apply(v4, nil) + return tmp10 + case 1: + v10 := args[0] + _ = v10 + tmp11 := lang.Apply(v4, []any{v10}) + return tmp11 + case 2: + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + var tmp12 any + { // let + // let binding "i" + tmp13 := checkDerefVar(var_glojure_DOT_core_inc) + tmp14, ok := lang.FieldOrMethod(v8, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "Deref"))) + } + var tmp15 any + switch reflect.TypeOf(tmp14).Kind() { + case reflect.Func: + tmp15 = lang.Apply(tmp14, nil) + default: + tmp15 = tmp14 + } + tmp16 := lang.Apply(tmp13, []any{tmp15}) + tmp17, _ := lang.FieldOrMethod(v8, "reset") + if reflect.TypeOf(tmp17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) + } + tmp18 := lang.Apply(tmp17, []any{tmp16}) + var v19 any = tmp18 + _ = v19 + // let binding "v" + tmp20 := lang.Apply(v2, []any{v19, v11}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + tmp23 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp24 := lang.Apply(tmp23, []any{v21}) + if lang.IsTruthy(tmp24) { + tmp22 = v10 + } else { + tmp25 := lang.Apply(v4, []any{v10, v21}) + tmp22 = tmp25 + } + tmp12 = tmp22 + } // end let + return tmp12 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7382), kw_column, int(8), kw_end_DASH_line, int(7390), kw_end_DASH_column, int(33)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp5 = tmp11 + } // end let + return tmp5 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7380), kw_column, int(4), kw_end_DASH_line, int(7390), kw_end_DASH_column, int(35)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // letfn + // letfn binding "keepi" + var v5 lang.FnFunc + var tmp6 lang.FnFunc + { // function keepi + var v7 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp11 any + { // let + // let binding "temp__0__auto__" + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := lang.Apply(tmp12, []any{v9}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + var tmp16 any + { // let + // let binding "s" + var v17 any = v14 + _ = v17 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp20 := lang.Apply(tmp19, []any{v17}) + if lang.IsTruthy(tmp20) { + var tmp21 any + { // let + // let binding "c" + tmp22 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp23 := lang.Apply(tmp22, []any{v17}) + var v24 any = tmp23 + _ = v24 + // let binding "size" + tmp25 := checkDerefVar(var_glojure_DOT_core_count) + tmp26 := lang.Apply(tmp25, []any{v24}) + var v27 any = tmp26 + _ = v27 + // let binding "b" + tmp28 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_buffer) + tmp29 := lang.Apply(tmp28, []any{v27}) + var v30 any = tmp29 + _ = v30 + var tmp31 any + { // let + // let binding "n__0__auto__" + tmp32 := checkDerefVar(var_glojure_DOT_core_long) + tmp33 := lang.Apply(tmp32, []any{v27}) + var v34 any = tmp33 + _ = v34 + var tmp35 any + { // let + // let binding "i" + var v36 any = int64(0) + _ = v36 + for { + var tmp37 any + tmp38 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp39 := lang.Apply(tmp38, []any{v36, v34}) + if lang.IsTruthy(tmp39) { + var tmp40 any + { // let + // let binding "x" + tmp41 := checkDerefVar(var_glojure_DOT_core__PLUS_) + tmp42 := lang.Apply(tmp41, []any{v8, v36}) + tmp43, _ := lang.FieldOrMethod(v24, "nth") + if reflect.TypeOf(tmp43).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp44 := lang.Apply(tmp43, []any{v36}) + tmp45 := lang.Apply(v2, []any{tmp42, tmp44}) + var v46 any = tmp45 + _ = v46 + var tmp47 any + tmp48 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp49 := lang.Apply(tmp48, []any{v46}) + if lang.IsTruthy(tmp49) { + } else { + tmp50 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_append) + tmp51 := lang.Apply(tmp50, []any{v30, v46}) + tmp47 = tmp51 + } + tmp40 = tmp47 + } // end let + _ = tmp40 + tmp42 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp43 := lang.Apply(tmp42, []any{v36}) + var tmp41 any = tmp43 + v36 = tmp41 + continue + } else { + } + tmp35 = tmp37 + break + } + } // end let + tmp31 = tmp35 + } // end let + _ = tmp31 + tmp32 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_cons) + tmp33 := checkDerefVar(var_glojure_DOT_core_chunk) + tmp34 := lang.Apply(tmp33, []any{v30}) + tmp35 := checkDerefVar(var_glojure_DOT_core__PLUS_) + tmp36 := lang.Apply(tmp35, []any{v8, v27}) + tmp37 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp38 := lang.Apply(tmp37, []any{v17}) + tmp39 := lang.Apply(v7, []any{tmp36, tmp38}) + tmp40 := lang.Apply(tmp32, []any{tmp34, tmp39}) + tmp21 = tmp40 + } // end let + tmp18 = tmp21 + } else { + var tmp22 any + { // let + // let binding "x" + tmp23 := checkDerefVar(var_glojure_DOT_core_first) + tmp24 := lang.Apply(tmp23, []any{v17}) + tmp25 := lang.Apply(v2, []any{v8, tmp24}) + var v26 any = tmp25 + _ = v26 + var tmp27 any + tmp28 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp29 := lang.Apply(tmp28, []any{v26}) + if lang.IsTruthy(tmp29) { + tmp30 := checkDerefVar(var_glojure_DOT_core_inc) + tmp31 := lang.Apply(tmp30, []any{v8}) + tmp32 := checkDerefVar(var_glojure_DOT_core_rest) + tmp33 := lang.Apply(tmp32, []any{v17}) + tmp34 := lang.Apply(v7, []any{tmp31, tmp33}) + tmp27 = tmp34 + } else { + tmp35 := checkDerefVar(var_glojure_DOT_core_cons) + tmp36 := checkDerefVar(var_glojure_DOT_core_inc) + tmp37 := lang.Apply(tmp36, []any{v8}) + tmp38 := checkDerefVar(var_glojure_DOT_core_rest) + tmp39 := lang.Apply(tmp38, []any{v17}) + tmp40 := lang.Apply(v7, []any{tmp37, tmp39}) + tmp41 := lang.Apply(tmp35, []any{v26, tmp40}) + tmp27 = tmp41 + } + tmp22 = tmp27 + } // end let + tmp18 = tmp22 + } + tmp16 = tmp18 + } // end let + tmp15 = tmp16 + } else { + } + tmp11 = tmp15 + } // end let + return tmp11 + }) + tmp11 := lang.Apply(lang.NewLazySeq, []any{tmp10}) + return tmp11 + }) + v7 = tmp6 + _ = v7 + } + v5 = tmp6 + _ = v5 + tmp7 := lang.Apply(v5, []any{int64(0), v3}) + tmp4 = tmp7 + } // end letfn + return tmp4 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_keep_DASH_indexed = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_keep_DASH_indexed.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // lazy-seq + { + tmp0 := sym_lazy_DASH_seq.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_body)), kw_doc, "Takes a body of expressions that returns an ISeq or nil, and yields\n a Seqable object that will invoke the body only the first time seq\n is called, and will cache the result and return it on all subsequent\n seq calls. See also - realized?", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(11), kw_line, int(676), kw_end_DASH_line, int(676))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArityGTE(args, 2) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var v4 any = lang.NewList(args[2:]...) + _ = v4 + tmp5 := checkDerefVar(var_glojure_DOT_core_list) + tmp6 := checkDerefVar(var_glojure_DOT_core_list_STAR_) + tmp7 := lang.NewVector() + tmp8 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(683), kw_column, int(101), kw_end_DASH_line, int(683), kw_end_DASH_column, int(102)) + tmp9, err := lang.WithMeta(tmp7, tmp8.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp10 := lang.Apply(tmp6, []any{sym_fn_STAR_, tmp9, v4}) + tmp11 := lang.Apply(tmp5, []any{sym_github_DOT_com_DOLLAR_glojurelang_DOLLAR_glojure_DOLLAR_pkg_DOLLAR_lang_DOT_NewLazySeq, tmp10}) + return tmp11 + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_lazy_DASH_seq = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_lazy_DASH_seq.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } + // locking + { + tmp0 := sym_locking.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym_x, sym__AMP_, sym_body)), kw_doc, "Executes exprs in an implicit do, while holding the monitor of x.\n Will release the monitor of x in all circumstances.", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(11), kw_line, int(1643), kw_end_DASH_line, int(1643))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + default: + checkArityGTE(args, 3) + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + v4 := args[2] + _ = v4 + var v5 any = lang.NewList(args[3:]...) + _ = v5 + tmp6 := checkDerefVar(var_glojure_DOT_core_seq) + tmp7 := checkDerefVar(var_glojure_DOT_core_concat) tmp8 := checkDerefVar(var_glojure_DOT_core_list) tmp9 := lang.Apply(tmp8, []any{sym_glojure_DOT_core_SLASH_let}) tmp10 := checkDerefVar(var_glojure_DOT_core_list) @@ -27221,6 +27299,241 @@ func LoadNS() { var_glojure_DOT_core_map.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } + // map-indexed + { + tmp0 := sym_map_DASH_indexed.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_coll)), kw_doc, "Returns a lazy sequence consisting of the result of applying f to 0\n and the first item of coll, followed by applying f to 1 and the second\n item in coll, etc, until coll is exhausted. Thus function f should\n accept 2 arguments, index and item. Returns a stateful transducer when\n no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(7309), kw_end_DASH_line, int(7309))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 any + { // let + // let binding "i" + tmp6 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) + tmp7 := lang.Apply(tmp6, []any{int64(-1)}) + var v8 any = tmp7 + _ = v8 + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp10 := lang.Apply(v4, nil) + return tmp10 + case 1: + v10 := args[0] + _ = v10 + tmp11 := lang.Apply(v4, []any{v10}) + return tmp11 + case 2: + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_inc) + tmp13, ok := lang.FieldOrMethod(v8, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "Deref"))) + } + var tmp14 any + switch reflect.TypeOf(tmp13).Kind() { + case reflect.Func: + tmp14 = lang.Apply(tmp13, nil) + default: + tmp14 = tmp13 + } + tmp15 := lang.Apply(tmp12, []any{tmp14}) + tmp16, _ := lang.FieldOrMethod(v8, "reset") + if reflect.TypeOf(tmp16).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) + } + tmp17 := lang.Apply(tmp16, []any{tmp15}) + tmp18 := lang.Apply(v2, []any{tmp17, v11}) + tmp19 := lang.Apply(v4, []any{v10, tmp18}) + return tmp19 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7320), kw_column, int(8), kw_end_DASH_line, int(7324), kw_end_DASH_column, int(48)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp5 = tmp11 + } // end let + return tmp5 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7318), kw_column, int(4), kw_end_DASH_line, int(7324), kw_end_DASH_column, int(50)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // letfn + // letfn binding "mapi" + var v5 lang.FnFunc + var tmp6 lang.FnFunc + { // function mapi + var v7 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp11 any + { // let + // let binding "temp__0__auto__" + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := lang.Apply(tmp12, []any{v9}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + var tmp16 any + { // let + // let binding "s" + var v17 any = v14 + _ = v17 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp20 := lang.Apply(tmp19, []any{v17}) + if lang.IsTruthy(tmp20) { + var tmp21 any + { // let + // let binding "c" + tmp22 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp23 := lang.Apply(tmp22, []any{v17}) + var v24 any = tmp23 + _ = v24 + // let binding "size" + tmp25 := checkDerefVar(var_glojure_DOT_core_int) + tmp26 := checkDerefVar(var_glojure_DOT_core_count) + tmp27 := lang.Apply(tmp26, []any{v24}) + tmp28 := lang.Apply(tmp25, []any{tmp27}) + var v29 any = tmp28 + _ = v29 + // let binding "b" + tmp30 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_buffer) + tmp31 := lang.Apply(tmp30, []any{v29}) + var v32 any = tmp31 + _ = v32 + var tmp33 any + { // let + // let binding "n__0__auto__" + tmp34 := checkDerefVar(var_glojure_DOT_core_long) + tmp35 := lang.Apply(tmp34, []any{v29}) + var v36 any = tmp35 + _ = v36 + var tmp37 any + { // let + // let binding "i" + var v38 any = int64(0) + _ = v38 + for { + var tmp39 any + tmp40 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp41 := lang.Apply(tmp40, []any{v38, v36}) + if lang.IsTruthy(tmp41) { + tmp42 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_append) + tmp43 := checkDerefVar(var_glojure_DOT_core__PLUS_) + tmp44 := lang.Apply(tmp43, []any{v8, v38}) + tmp45, _ := lang.FieldOrMethod(v24, "nth") + if reflect.TypeOf(tmp45).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp46 := lang.Apply(tmp45, []any{v38}) + tmp47 := lang.Apply(v2, []any{tmp44, tmp46}) + tmp48 := lang.Apply(tmp42, []any{v32, tmp47}) + _ = tmp48 + tmp50 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp51 := lang.Apply(tmp50, []any{v38}) + var tmp49 any = tmp51 + v38 = tmp49 + continue + } else { + } + tmp37 = tmp39 + break + } + } // end let + tmp33 = tmp37 + } // end let + _ = tmp33 + tmp34 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_cons) + tmp35 := checkDerefVar(var_glojure_DOT_core_chunk) + tmp36 := lang.Apply(tmp35, []any{v32}) + tmp37 := checkDerefVar(var_glojure_DOT_core__PLUS_) + tmp38 := lang.Apply(tmp37, []any{v8, v29}) + tmp39 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp40 := lang.Apply(tmp39, []any{v17}) + tmp41 := lang.Apply(v7, []any{tmp38, tmp40}) + tmp42 := lang.Apply(tmp34, []any{tmp36, tmp41}) + tmp21 = tmp42 + } // end let + tmp18 = tmp21 + } else { + tmp22 := checkDerefVar(var_glojure_DOT_core_cons) + tmp23 := checkDerefVar(var_glojure_DOT_core_first) + tmp24 := lang.Apply(tmp23, []any{v17}) + tmp25 := lang.Apply(v2, []any{v8, tmp24}) + tmp26 := checkDerefVar(var_glojure_DOT_core_inc) + tmp27 := lang.Apply(tmp26, []any{v8}) + tmp28 := checkDerefVar(var_glojure_DOT_core_rest) + tmp29 := lang.Apply(tmp28, []any{v17}) + tmp30 := lang.Apply(v7, []any{tmp27, tmp29}) + tmp31 := lang.Apply(tmp22, []any{tmp25, tmp30}) + tmp18 = tmp31 + } + tmp16 = tmp18 + } // end let + tmp15 = tmp16 + } else { + } + tmp11 = tmp15 + } // end let + return tmp11 + }) + tmp11 := lang.Apply(lang.NewLazySeq, []any{tmp10}) + return tmp11 + }) + v7 = tmp6 + _ = v7 + } + v5 = tmp6 + _ = v5 + tmp7 := lang.Apply(v5, []any{int64(0), v3}) + tmp4 = tmp7 + } // end letfn + return tmp4 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_map_DASH_indexed = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_map_DASH_indexed.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } // max { var tmp1 lang.FnFunc diff --git a/pkg/runtime/testdata/codegen/test/letfn.glj b/pkg/runtime/testdata/codegen/test/letfn.glj new file mode 100644 index 00000000..935946ee --- /dev/null +++ b/pkg/runtime/testdata/codegen/test/letfn.glj @@ -0,0 +1,11 @@ +(ns codegen.test.letfn) + +(defn + ^{:expected-output 55} + -main [] + ;; recursive function using letfn + (letfn [(fib [n] + (if (<= n 1) + n + (+ (fib (- n 1)) (fib (- n 2)))))] + (fib 10))) diff --git a/pkg/runtime/testdata/codegen/test/letfn/load.go.out b/pkg/runtime/testdata/codegen/test/letfn/load.go.out new file mode 100644 index 00000000..3e3beddc --- /dev/null +++ b/pkg/runtime/testdata/codegen/test/letfn/load.go.out @@ -0,0 +1,117 @@ +// Code generated by glojure codegen. DO NOT EDIT. + +package letfn + +import ( + fmt "fmt" + lang "github.com/glojurelang/glojure/pkg/lang" + runtime "github.com/glojurelang/glojure/pkg/runtime" + reflect "reflect" +) + +func init() { + runtime.RegisterNSLoader("codegen/test/letfn", LoadNS) +} + +func checkDerefVar(v *lang.Var) any { + if v.IsMacro() { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("can't take value of macro: %v", v))) + } + return v.Get() +} + +func checkArity(args []any, expected int) { + if len(args) != expected { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + +func checkArityGTE(args []any, min int) { + if len(args) < min { + panic(lang.NewIllegalArgumentError("wrong number of arguments (" + fmt.Sprint(len(args)) + ")")) + } +} + +// LoadNS initializes the namespace "codegen.test.letfn" +func LoadNS() { + sym__PLUS_ := lang.NewSymbol("+") + sym__DASH_ := lang.NewSymbol("-") + sym__DASH_main := lang.NewSymbol("-main") + sym__LT__EQ_ := lang.NewSymbol("<=") + sym_codegen_DOT_test_DOT_letfn := lang.NewSymbol("codegen.test.letfn") + sym_glojure_DOT_core := lang.NewSymbol("glojure.core") + kw_arglists := lang.NewKeyword("arglists") + kw_column := lang.NewKeyword("column") + kw_end_DASH_column := lang.NewKeyword("end-column") + kw_end_DASH_line := lang.NewKeyword("end-line") + kw_expected_DASH_output := lang.NewKeyword("expected-output") + kw_file := lang.NewKeyword("file") + kw_line := lang.NewKeyword("line") + kw_ns := lang.NewKeyword("ns") + kw_rettag := lang.NewKeyword("rettag") + // var codegen.test.letfn/-main + var_codegen_DOT_test_DOT_letfn__DASH_main := lang.InternVarName(sym_codegen_DOT_test_DOT_letfn, sym__DASH_main) + // var glojure.core/- + var_glojure_DOT_core__DASH_ := lang.InternVarName(sym_glojure_DOT_core, sym__DASH_) + // var glojure.core/<= + var_glojure_DOT_core__LT__EQ_ := lang.InternVarName(sym_glojure_DOT_core, sym__LT__EQ_) + // var glojure.core/+ + var_glojure_DOT_core__PLUS_ := lang.InternVarName(sym_glojure_DOT_core, sym__PLUS_) + // reference fmt to avoid unused import error + _ = fmt.Printf + // reference reflect to avoid unused import error + _ = reflect.TypeOf + ns := lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_letfn) + _ = ns + // -main + { + tmp0 := sym__DASH_main.WithMeta(lang.NewMap(kw_expected_DASH_output, int64(55), kw_file, "codegen/test/letfn.glj", kw_line, int(4), kw_column, int(3), kw_end_DASH_line, int(5), kw_end_DASH_column, int(7), kw_arglists, lang.NewList(lang.NewVector()), kw_ns, lang.FindOrCreateNamespace(sym_codegen_DOT_test_DOT_letfn))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp2 any + { // letfn + // letfn binding "fib" + var v3 lang.FnFunc + var tmp4 lang.FnFunc + { // function fib + var v5 lang.FnFunc + tmp4 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v6 := args[0] + _ = v6 + var tmp7 any + tmp8 := checkDerefVar(var_glojure_DOT_core__LT__EQ_) + tmp9 := lang.Apply(tmp8, []any{v6, int64(1)}) + if lang.IsTruthy(tmp9) { + tmp7 = v6 + } else { + tmp10 := checkDerefVar(var_glojure_DOT_core__PLUS_) + tmp11 := checkDerefVar(var_glojure_DOT_core__DASH_) + tmp12 := lang.Apply(tmp11, []any{v6, int64(1)}) + tmp13 := lang.Apply(v5, []any{tmp12}) + tmp14 := checkDerefVar(var_glojure_DOT_core__DASH_) + tmp15 := lang.Apply(tmp14, []any{v6, int64(2)}) + tmp16 := lang.Apply(v5, []any{tmp15}) + tmp17 := lang.Apply(tmp10, []any{tmp13, tmp16}) + tmp7 = tmp17 + } + return tmp7 + }) + v5 = tmp4 + _ = v5 + } + v3 = tmp4 + _ = v3 + tmp5 := lang.Apply(v3, []any{int64(10)}) + tmp2 = tmp5 + } // end letfn + return tmp2 + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_codegen_DOT_test_DOT_letfn__DASH_main = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_codegen_DOT_test_DOT_letfn__DASH_main.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } +} From 132750e33c714dd2feb3e074d3b7154e473c030f Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Mon, 1 Sep 2025 20:15:07 -0700 Subject: [PATCH 63/67] Fix number method renames Signed-off-by: James Hamlin --- pkg/stdlib/glojure/core.glj | 16 ++++++++-------- scripts/rewrite-core/rewrite.clj | 6 +++--- 2 files changed, 11 insertions(+), 11 deletions(-) diff --git a/pkg/stdlib/glojure/core.glj b/pkg/stdlib/glojure/core.glj index 89bda698..206991b9 100644 --- a/pkg/stdlib/glojure/core.glj +++ b/pkg/stdlib/glojure/core.glj @@ -977,7 +977,7 @@ (defn + "Returns the sum of nums. (+) returns 0. Does not auto-promote longs, will throw on overflow. See also: +'" - {:inline (nary-inline 'add 'unchecked_add) + {:inline (nary-inline 'add 'UncheckedAdd) :inline-arities >1? :added "1.2"} ([] 0) @@ -1147,7 +1147,7 @@ (defn dec "Returns a number one less than num. Does not auto-promote longs, will throw on overflow. See also: dec'" - {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (~(if *unchecked-math* 'unchecked_dec 'dec) ~x))) + {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (~(if *unchecked-math* 'UncheckedDec 'dec) ~x))) :added "1.2"} [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (dec x))) @@ -1175,9 +1175,9 @@ (defn unchecked-dec "Returns a number one less than x, a long. Note - uses a primitive operator subject to overflow." - {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_dec ~x))) + {:inline (fn [x] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (UncheckedDec ~x))) :added "1.0"} - [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_dec x))) + [x] (. github.com$glojurelang$glojure$pkg$lang.Numbers (UncheckedDec x))) (defn unchecked-negate-int "Returns the negation of x, an int. @@ -1203,9 +1203,9 @@ (defn unchecked-add "Returns the sum of x and y, both long. Note - uses a primitive operator subject to overflow." - {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_add ~x ~y))) + {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (UncheckedAdd ~x ~y))) :added "1.0"} - [x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_add x y))) + [x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (UncheckedAdd x y))) (defn unchecked-subtract-int "Returns the difference of x and y, both int. @@ -1238,9 +1238,9 @@ (defn unchecked-divide-int "Returns the division of x by y, both int. Note - uses a primitive operator subject to truncation." - {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_int_divide ~x ~y))) + {:inline (fn [x y] `(. github.com$glojurelang$glojure$pkg$lang.Numbers (UncheckedIntDivide ~x ~y))) :added "1.0"} - [x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (unchecked_int_divide x y))) + [x y] (. github.com$glojurelang$glojure$pkg$lang.Numbers (UncheckedIntDivide x y))) (defn unchecked-remainder-int "Returns the remainder of division of x by y, both int. diff --git a/scripts/rewrite-core/rewrite.clj b/scripts/rewrite-core/rewrite.clj index 187c8dab..fd5a5b05 100644 --- a/scripts/rewrite-core/rewrite.clj +++ b/scripts/rewrite-core/rewrite.clj @@ -754,9 +754,9 @@ (sexpr-replace 'clojure.lang.Numbers/abs 'github.com$glojurelang$glojure$pkg$lang.Abs) - (sexpr-replace 'Unchecked_add 'UncheckedAdd) - (sexpr-replace 'Unchecked_dec 'UncheckedDec) - (sexpr-replace 'Unchecked_int_divide 'UncheckedIntDivide) + (sexpr-replace 'unchecked_add 'UncheckedAdd) + (sexpr-replace 'unchecked_dec 'UncheckedDec) + (sexpr-replace 'unchecked_int_divide 'UncheckedIntDivide) (sexpr-replace '(unchecked_minus x) '(Unchecked_negate x)) ;; ===== Numeric Array Replacements ===== From fd81b50aca7612edf1c7fdecfec7db5c844e5185 Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Mon, 1 Sep 2025 20:17:47 -0700 Subject: [PATCH 64/67] Default stdlib AOT to true Signed-off-by: James Hamlin --- pkg/runtime/rtcompat.go | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/pkg/runtime/rtcompat.go b/pkg/runtime/rtcompat.go index 718c9bbd..de95367e 100644 --- a/pkg/runtime/rtcompat.go +++ b/pkg/runtime/rtcompat.go @@ -27,7 +27,11 @@ var ( loadPath = []fs.FS{} loadPathLock sync.Mutex - useAot = os.Getenv("GLOJURE_USE_AOT") == "1" + useAot = func() bool { + // default to true + gua := strings.ToLower(os.Getenv("GLOJURE_USE_AOT")) + return !(gua == "0" || gua == "false" || gua == "no" || gua == "false") + }() ) func init() { From 9f270c14dc6d4dbfbcd45274e2dd2a437c1512db Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Mon, 1 Sep 2025 20:23:41 -0700 Subject: [PATCH 65/67] Fix redundant GLOJURE_USE_AOT case Signed-off-by: James Hamlin --- pkg/runtime/rtcompat.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pkg/runtime/rtcompat.go b/pkg/runtime/rtcompat.go index de95367e..43c74bea 100644 --- a/pkg/runtime/rtcompat.go +++ b/pkg/runtime/rtcompat.go @@ -30,7 +30,7 @@ var ( useAot = func() bool { // default to true gua := strings.ToLower(os.Getenv("GLOJURE_USE_AOT")) - return !(gua == "0" || gua == "false" || gua == "no" || gua == "false") + return !(gua == "0" || gua == "false" || gua == "no" || gua == "off") }() ) From 8ba8170629cba0a8d14965de09ef406d7e536ebf Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Mon, 1 Sep 2025 21:40:36 -0700 Subject: [PATCH 66/67] Fix codegen for rest arguments Signed-off-by: James Hamlin --- pkg/runtime/codegen.go | 11 +- pkg/runtime/codegen_test.go | 7 + .../testdata/codegen/test/core/load.go.out | 42 +- pkg/stdlib/glojure/core/async/loader.go | 38 +- pkg/stdlib/glojure/core/loader.go | 2282 ++++++++++++---- pkg/stdlib/glojure/core_deftype/loader.go | 2208 ++++++++++++---- pkg/stdlib/glojure/core_print/loader.go | 2286 +++++++++++++---- pkg/stdlib/glojure/protocols/loader.go | 156 +- pkg/stdlib/glojure/template/loader.go | 6 +- 9 files changed, 5513 insertions(+), 1523 deletions(-) diff --git a/pkg/runtime/codegen.go b/pkg/runtime/codegen.go index 73feb135..77f8b177 100644 --- a/pkg/runtime/codegen.go +++ b/pkg/runtime/codegen.go @@ -84,8 +84,9 @@ type Generator struct { var ( omittedVars = map[string]bool{ // initialized by the runtime - "#'glojure.core/*in*": true, - "#'glojure.core/*out*": true, + "#'glojure.core/*in*": true, + "#'glojure.core/*out*": true, + "#'glojure.core/*compile-files*": true, } ) @@ -953,7 +954,11 @@ func (g *Generator) generateFnMethod(methodNode *ast.FnMethodNode, argsVar strin paramVars[i] = paramVar } else { // Variadic parameter - collect rest args - g.writef("var %s any = lang.NewList(%s[%d:]...)\n", paramVar, argsVar, methodNode.FixedArity) + g.writef("restArgs := %s[%d:]\n", argsVar, methodNode.FixedArity) + g.writef("var %s any\n", paramVar) + g.writef("if len(restArgs) > 0 {\n") + g.writef(" %s = lang.NewList(restArgs...)\n", paramVar) + g.writef("}\n") g.writeAssign("_", paramVar) // Prevent unused variable warning paramVars = append(paramVars, paramVar) } diff --git a/pkg/runtime/codegen_test.go b/pkg/runtime/codegen_test.go index 28c4e481..ef06cfa1 100644 --- a/pkg/runtime/codegen_test.go +++ b/pkg/runtime/codegen_test.go @@ -132,6 +132,13 @@ func generateAndTestNamespace(t *testing.T, ns *lang.Namespace, goldenFile strin } // run go vet on the temp file with .go extension + // - two exceptions: core and try_basic generate unreachable code + // TODO: fix the code generation to avoid unreachable code + if ns.Name().String() == "glojure.core" || ns.Name().String() == "codegen.test.try-basic" { + t.Logf("skipping go vet for %s", goldenFile) + return + } + cmd := exec.Command("go", "vet", "-all", tempFile.Name()) var stderr bytes.Buffer cmd.Stderr = &stderr diff --git a/pkg/runtime/testdata/codegen/test/core/load.go.out b/pkg/runtime/testdata/codegen/test/core/load.go.out index d744e54a..6502c05d 100644 --- a/pkg/runtime/testdata/codegen/test/core/load.go.out +++ b/pkg/runtime/testdata/codegen/test/core/load.go.out @@ -122,6 +122,8 @@ func LoadNS() { sym_SetMacro := lang.NewSymbol("SetMacro") sym_StackTraceElement_DASH__GT_vec := lang.NewSymbol("StackTraceElement->vec") sym_Throwable_DASH__GT_map := lang.NewSymbol("Throwable->map") + sym_UncheckedAdd := lang.NewSymbol("UncheckedAdd") + sym_UncheckedDec := lang.NewSymbol("UncheckedDec") sym_a := lang.NewSymbol("a") sym_a__0__auto__ := lang.NewSymbol("a__0__auto__") sym_abs := lang.NewSymbol("abs") @@ -524,11 +526,14 @@ func LoadNS() { sym_glojure_DOT_core_SLASH_Nth := lang.NewSymbol("glojure.core/Nth") sym_glojure_DOT_core_SLASH_Object_array := lang.NewSymbol("glojure.core/Object_array") sym_glojure_DOT_core_SLASH_RunInTransaction := lang.NewSymbol("glojure.core/RunInTransaction") + sym_glojure_DOT_core_SLASH_UncheckedAdd := lang.NewSymbol("glojure.core/UncheckedAdd") sym_glojure_DOT_core_SLASH_UncheckedByteCast := lang.NewSymbol("glojure.core/UncheckedByteCast") sym_glojure_DOT_core_SLASH_UncheckedCharCast := lang.NewSymbol("glojure.core/UncheckedCharCast") + sym_glojure_DOT_core_SLASH_UncheckedDec := lang.NewSymbol("glojure.core/UncheckedDec") sym_glojure_DOT_core_SLASH_UncheckedDoubleCast := lang.NewSymbol("glojure.core/UncheckedDoubleCast") sym_glojure_DOT_core_SLASH_UncheckedFloatCast := lang.NewSymbol("glojure.core/UncheckedFloatCast") sym_glojure_DOT_core_SLASH_UncheckedIntCast := lang.NewSymbol("glojure.core/UncheckedIntCast") + sym_glojure_DOT_core_SLASH_UncheckedIntDivide := lang.NewSymbol("glojure.core/UncheckedIntDivide") sym_glojure_DOT_core_SLASH_UncheckedLongCast := lang.NewSymbol("glojure.core/UncheckedLongCast") sym_glojure_DOT_core_SLASH_UncheckedShortCast := lang.NewSymbol("glojure.core/UncheckedShortCast") sym_glojure_DOT_core_SLASH_aclone := lang.NewSymbol("glojure.core/aclone") @@ -644,12 +649,9 @@ func LoadNS() { sym_glojure_DOT_core_SLASH_to_DASH_array := lang.NewSymbol("glojure.core/to-array") sym_glojure_DOT_core_SLASH_unchecked_DASH_inc := lang.NewSymbol("glojure.core/unchecked-inc") sym_glojure_DOT_core_SLASH_unchecked_DASH_inc_DASH_int := lang.NewSymbol("glojure.core/unchecked-inc-int") - sym_glojure_DOT_core_SLASH_unchecked_add := lang.NewSymbol("glojure.core/unchecked_add") - sym_glojure_DOT_core_SLASH_unchecked_dec := lang.NewSymbol("glojure.core/unchecked_dec") sym_glojure_DOT_core_SLASH_unchecked_inc := lang.NewSymbol("glojure.core/unchecked_inc") sym_glojure_DOT_core_SLASH_unchecked_int_add := lang.NewSymbol("glojure.core/unchecked_int_add") sym_glojure_DOT_core_SLASH_unchecked_int_dec := lang.NewSymbol("glojure.core/unchecked_int_dec") - sym_glojure_DOT_core_SLASH_unchecked_int_divide := lang.NewSymbol("glojure.core/unchecked_int_divide") sym_glojure_DOT_core_SLASH_unchecked_int_inc := lang.NewSymbol("glojure.core/unchecked_int_inc") sym_glojure_DOT_core_SLASH_unchecked_int_multiply := lang.NewSymbol("glojure.core/unchecked_int_multiply") sym_glojure_DOT_core_SLASH_unchecked_int_negate := lang.NewSymbol("glojure.core/unchecked_int_negate") @@ -1224,8 +1226,6 @@ func LoadNS() { sym_uncheckedFloatCast := lang.NewSymbol("uncheckedFloatCast") sym_uncheckedIntCast := lang.NewSymbol("uncheckedIntCast") sym_uncheckedShortCast := lang.NewSymbol("uncheckedShortCast") - sym_unchecked_add := lang.NewSymbol("unchecked_add") - sym_unchecked_dec := lang.NewSymbol("unchecked_dec") sym_unchecked_inc := lang.NewSymbol("unchecked_inc") sym_unchecked_minus := lang.NewSymbol("unchecked_minus") sym_unchecked_multiply := lang.NewSymbol("unchecked_multiply") @@ -1474,8 +1474,6 @@ func LoadNS() { var_glojure_DOT_core__STAR_assert_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_assert_STAR_) // var glojure.core/*command-line-args* var_glojure_DOT_core__STAR_command_DASH_line_DASH_args_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_command_DASH_line_DASH_args_STAR_) - // var glojure.core/*compile-files* - var_glojure_DOT_core__STAR_compile_DASH_files_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_compile_DASH_files_STAR_) // var glojure.core/*compile-path* var_glojure_DOT_core__STAR_compile_DASH_path_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_compile_DASH_path_STAR_) // var glojure.core/*compiler-options* @@ -2970,7 +2968,7 @@ func LoadNS() { } var closed3 any { - closed3 = sym_unchecked_add + closed3 = sym_UncheckedAdd } var closed30 any { @@ -3151,14 +3149,6 @@ func LoadNS() { var_glojure_DOT_core__STAR_command_DASH_line_DASH_args_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // *compile-files* - { - tmp0 := sym__STAR_compile_DASH_files_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "Set to true when compiling files, false otherwise.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - var_glojure_DOT_core__STAR_compile_DASH_files_STAR_ = ns.InternWithValue(tmp0, false, true) - if tmp0.Meta() != nil { - var_glojure_DOT_core__STAR_compile_DASH_files_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } // *compile-path* { tmp0 := sym__STAR_compile_DASH_path_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "Specifies the directory where 'compile' will write out .class\n files. This directory must be in the classpath for 'compile' to\n work.\n\n Defaults to \"classes\"", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) @@ -9083,7 +9073,7 @@ func LoadNS() { var tmp14 any tmp15 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp15) { - tmp14 = sym_unchecked_dec + tmp14 = sym_UncheckedDec } else { tmp14 = sym_dec } @@ -15266,7 +15256,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_unchecked_add}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_UncheckedAdd}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -15289,9 +15279,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_add") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedAdd") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_add is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedAdd is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -15476,7 +15466,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_unchecked_dec}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedDec}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -15495,9 +15485,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_dec") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedDec") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_dec is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedDec is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -15580,7 +15570,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_unchecked_int_divide}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_UncheckedIntDivide}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -15603,9 +15593,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_int_divide") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedIntDivide") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_divide is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedIntDivide is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 diff --git a/pkg/stdlib/glojure/core/async/loader.go b/pkg/stdlib/glojure/core/async/loader.go index 3de5173b..088b1b7c 100644 --- a/pkg/stdlib/glojure/core/async/loader.go +++ b/pkg/stdlib/glojure/core/async/loader.go @@ -514,7 +514,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_DOT_async_do_DASH_alt) tmp6 := lang.Apply(tmp5, []any{sym_glojure_DOT_core_DOT_async_SLASH_alts_BANG_, v4}) @@ -539,7 +543,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_seq) tmp6 := checkDerefVar(var_glojure_DOT_core_concat) @@ -566,7 +574,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 var tmp4 any { // let @@ -630,7 +642,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 var tmp4 any { // let @@ -1441,7 +1457,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_seq) tmp6 := checkDerefVar(var_glojure_DOT_core_concat) @@ -1585,7 +1605,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_seq) tmp7 := checkDerefVar(var_glojure_DOT_core_concat) @@ -1727,6 +1751,7 @@ func LoadNS() { }) var v10 any = tmp9 _ = v10 + go lang.Apply(v10, []any{}) tmp11 := lang.Apply(lang.Builtins["<-chan-of"], []any{lang.Builtins["any"]}) tmp12 := lang.Apply(tmp11, []any{v8}) tmp5 = tmp12 @@ -1995,6 +2020,7 @@ func LoadNS() { }) var v17 any = tmp16 _ = v17 + go lang.Apply(v17, []any{}) tmp18 := lang.Apply(lang.Builtins["<-chan-of"], []any{lang.Builtins["any"]}) tmp19 := lang.Apply(tmp18, []any{v15}) tmp12 = tmp19 diff --git a/pkg/stdlib/glojure/core/loader.go b/pkg/stdlib/glojure/core/loader.go index 94b2ad58..0c7d9d1a 100644 --- a/pkg/stdlib/glojure/core/loader.go +++ b/pkg/stdlib/glojure/core/loader.go @@ -118,6 +118,8 @@ func LoadNS() { sym_SetMacro := lang.NewSymbol("SetMacro") sym_StackTraceElement_DASH__GT_vec := lang.NewSymbol("StackTraceElement->vec") sym_Throwable_DASH__GT_map := lang.NewSymbol("Throwable->map") + sym_UncheckedAdd := lang.NewSymbol("UncheckedAdd") + sym_UncheckedDec := lang.NewSymbol("UncheckedDec") sym_a := lang.NewSymbol("a") sym_a__0__auto__ := lang.NewSymbol("a__0__auto__") sym_abs := lang.NewSymbol("abs") @@ -498,11 +500,14 @@ func LoadNS() { sym_glojure_DOT_core_SLASH_Nth := lang.NewSymbol("glojure.core/Nth") sym_glojure_DOT_core_SLASH_Object_array := lang.NewSymbol("glojure.core/Object_array") sym_glojure_DOT_core_SLASH_RunInTransaction := lang.NewSymbol("glojure.core/RunInTransaction") + sym_glojure_DOT_core_SLASH_UncheckedAdd := lang.NewSymbol("glojure.core/UncheckedAdd") sym_glojure_DOT_core_SLASH_UncheckedByteCast := lang.NewSymbol("glojure.core/UncheckedByteCast") sym_glojure_DOT_core_SLASH_UncheckedCharCast := lang.NewSymbol("glojure.core/UncheckedCharCast") + sym_glojure_DOT_core_SLASH_UncheckedDec := lang.NewSymbol("glojure.core/UncheckedDec") sym_glojure_DOT_core_SLASH_UncheckedDoubleCast := lang.NewSymbol("glojure.core/UncheckedDoubleCast") sym_glojure_DOT_core_SLASH_UncheckedFloatCast := lang.NewSymbol("glojure.core/UncheckedFloatCast") sym_glojure_DOT_core_SLASH_UncheckedIntCast := lang.NewSymbol("glojure.core/UncheckedIntCast") + sym_glojure_DOT_core_SLASH_UncheckedIntDivide := lang.NewSymbol("glojure.core/UncheckedIntDivide") sym_glojure_DOT_core_SLASH_UncheckedLongCast := lang.NewSymbol("glojure.core/UncheckedLongCast") sym_glojure_DOT_core_SLASH_UncheckedShortCast := lang.NewSymbol("glojure.core/UncheckedShortCast") sym_glojure_DOT_core_SLASH_aclone := lang.NewSymbol("glojure.core/aclone") @@ -618,12 +623,9 @@ func LoadNS() { sym_glojure_DOT_core_SLASH_to_DASH_array := lang.NewSymbol("glojure.core/to-array") sym_glojure_DOT_core_SLASH_unchecked_DASH_inc := lang.NewSymbol("glojure.core/unchecked-inc") sym_glojure_DOT_core_SLASH_unchecked_DASH_inc_DASH_int := lang.NewSymbol("glojure.core/unchecked-inc-int") - sym_glojure_DOT_core_SLASH_unchecked_add := lang.NewSymbol("glojure.core/unchecked_add") - sym_glojure_DOT_core_SLASH_unchecked_dec := lang.NewSymbol("glojure.core/unchecked_dec") sym_glojure_DOT_core_SLASH_unchecked_inc := lang.NewSymbol("glojure.core/unchecked_inc") sym_glojure_DOT_core_SLASH_unchecked_int_add := lang.NewSymbol("glojure.core/unchecked_int_add") sym_glojure_DOT_core_SLASH_unchecked_int_dec := lang.NewSymbol("glojure.core/unchecked_int_dec") - sym_glojure_DOT_core_SLASH_unchecked_int_divide := lang.NewSymbol("glojure.core/unchecked_int_divide") sym_glojure_DOT_core_SLASH_unchecked_int_inc := lang.NewSymbol("glojure.core/unchecked_int_inc") sym_glojure_DOT_core_SLASH_unchecked_int_multiply := lang.NewSymbol("glojure.core/unchecked_int_multiply") sym_glojure_DOT_core_SLASH_unchecked_int_negate := lang.NewSymbol("glojure.core/unchecked_int_negate") @@ -1194,8 +1196,6 @@ func LoadNS() { sym_uncheckedFloatCast := lang.NewSymbol("uncheckedFloatCast") sym_uncheckedIntCast := lang.NewSymbol("uncheckedIntCast") sym_uncheckedShortCast := lang.NewSymbol("uncheckedShortCast") - sym_unchecked_add := lang.NewSymbol("unchecked_add") - sym_unchecked_dec := lang.NewSymbol("unchecked_dec") sym_unchecked_inc := lang.NewSymbol("unchecked_inc") sym_unchecked_minus := lang.NewSymbol("unchecked_minus") sym_unchecked_multiply := lang.NewSymbol("unchecked_multiply") @@ -1441,8 +1441,6 @@ func LoadNS() { var_glojure_DOT_core__STAR_assert_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_assert_STAR_) // var glojure.core/*command-line-args* var_glojure_DOT_core__STAR_command_DASH_line_DASH_args_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_command_DASH_line_DASH_args_STAR_) - // var glojure.core/*compile-files* - var_glojure_DOT_core__STAR_compile_DASH_files_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_compile_DASH_files_STAR_) // var glojure.core/*compile-path* var_glojure_DOT_core__STAR_compile_DASH_path_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_compile_DASH_path_STAR_) // var glojure.core/*compiler-options* @@ -2914,7 +2912,7 @@ func LoadNS() { } var closed3 any { - closed3 = sym_unchecked_add + closed3 = sym_UncheckedAdd } var closed4 any { @@ -3007,27 +3005,30 @@ func LoadNS() { } // *1 { - tmp0 := sym__STAR_1.WithMeta(lang.NewMap()).(*lang.Symbol) + tmp0 := sym__STAR_1.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core.glj", kw_line, int(6268), kw_column, int(6), kw_end_DASH_line, int(6271), kw_end_DASH_column, int(3), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var_glojure_DOT_core__STAR_1 = ns.Intern(tmp0) if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_1.SetDynamic() } // *2 { - tmp0 := sym__STAR_2.WithMeta(lang.NewMap()).(*lang.Symbol) + tmp0 := sym__STAR_2.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core.glj", kw_line, int(6273), kw_column, int(6), kw_end_DASH_line, int(6276), kw_end_DASH_column, int(3), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var_glojure_DOT_core__STAR_2 = ns.Intern(tmp0) if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_2.SetDynamic() } // *3 { - tmp0 := sym__STAR_3.WithMeta(lang.NewMap()).(*lang.Symbol) + tmp0 := sym__STAR_3.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core.glj", kw_line, int(6278), kw_column, int(6), kw_end_DASH_line, int(6281), kw_end_DASH_column, int(3), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var_glojure_DOT_core__STAR_3 = ns.Intern(tmp0) if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_3.SetDynamic() } // *agent* { @@ -3053,14 +3054,6 @@ func LoadNS() { var_glojure_DOT_core__STAR_command_DASH_line_DASH_args_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // *compile-files* - { - tmp0 := sym__STAR_compile_DASH_files_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "Set to true when compiling files, false otherwise.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - var_glojure_DOT_core__STAR_compile_DASH_files_STAR_ = ns.InternWithValue(tmp0, true, true) - if tmp0.Meta() != nil { - var_glojure_DOT_core__STAR_compile_DASH_files_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } // *compile-path* { tmp0 := sym__STAR_compile_DASH_path_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "Specifies the directory where 'compile' will write out .class\n files. This directory must be in the classpath for 'compile' to\n work.\n\n Defaults to \"classes\"", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) @@ -3097,11 +3090,12 @@ func LoadNS() { } // *e { - tmp0 := sym__STAR_e.WithMeta(lang.NewMap()).(*lang.Symbol) + tmp0 := sym__STAR_e.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core.glj", kw_line, int(6283), kw_column, int(6), kw_end_DASH_line, int(6286), kw_end_DASH_column, int(3), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var_glojure_DOT_core__STAR_e = ns.Intern(tmp0) if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_e.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_e.SetDynamic() } // *err* { @@ -3354,7 +3348,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5, _ := lang.FieldOrMethod(v2, "alter") if reflect.TypeOf(tmp5).Kind() != reflect.Func { @@ -3382,7 +3380,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5, _ := lang.FieldOrMethod(v2, "AlterMeta") if reflect.TypeOf(tmp5).Kind() != reflect.Func { @@ -3410,7 +3412,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5, _ := lang.FieldOrMethod(v2, "alterRoot") if reflect.TypeOf(tmp5).Kind() != reflect.Func { @@ -3764,7 +3770,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 return nil } @@ -3787,7 +3797,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5, _ := lang.FieldOrMethod(v2, "Commute") if reflect.TypeOf(tmp5).Kind() != reflect.Func { @@ -3914,7 +3928,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v4 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 return v2 } @@ -3980,7 +3998,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 tmp3 := lang.Apply(lang.CreatePersistentStructMapSlotMap, []any{v2}) return tmp3 @@ -4434,7 +4456,7 @@ func LoadNS() { } // gen-class { - tmp0 := sym_gen_DASH_class.WithMeta(lang.NewMap()).(*lang.Symbol) + tmp0 := sym_gen_DASH_class.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5732), kw_column, int(10), kw_end_DASH_line, int(5732), kw_end_DASH_column, int(18), kw_declared, true, kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var_glojure_DOT_core_gen_DASH_class = ns.Intern(tmp0) if tmp0.Meta() != nil { var_glojure_DOT_core_gen_DASH_class.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -4540,7 +4562,11 @@ func LoadNS() { return tmp4 default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 tmp3 := lang.Apply(lang.CreatePersistentHashMap, []any{v2}) return tmp3 @@ -4585,7 +4611,11 @@ func LoadNS() { return tmp4 default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 tmp3 := lang.Apply(nil, []any{v2}) return tmp3 @@ -6629,7 +6659,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 tmp3 := lang.Apply(lang.CreatePersistentTreeMap, []any{v2}) return tmp3 @@ -6651,7 +6685,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 tmp4 := lang.Apply(nil, []any{v2, v3}) return tmp4 @@ -6671,7 +6709,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 tmp3 := lang.Apply(lang.CreatePersistentTreeSet, []any{v2}) return tmp3 @@ -6693,7 +6735,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 tmp4 := lang.Apply(lang.CreatePersistentTreeSetWithComparator, []any{v2, v3}) return tmp4 @@ -6828,7 +6874,11 @@ func LoadNS() { checkArityGTE(args, 1) v3 := args[0] _ = v3 - var v4 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 lang.FnFunc tmp5 = lang.NewFnFunc(func(args ...any) any { @@ -7061,7 +7111,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 tmp4 := lang.Apply(lang.ConstructPersistentStructMap, []any{v2, v3}) return tmp4 @@ -7083,7 +7137,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 tmp4 := lang.Apply(lang.CreatePersistentStructMap, []any{v2, v3}) return tmp4 @@ -7140,7 +7198,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5, _ := lang.FieldOrMethod(v2, "swap") if reflect.TypeOf(tmp5).Kind() != reflect.Func { @@ -7168,7 +7230,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5, _ := lang.FieldOrMethod(v2, "swapVals") if reflect.TypeOf(tmp5).Kind() != reflect.Func { @@ -7522,7 +7588,7 @@ func LoadNS() { } // unquote { - tmp0 := sym_unquote.WithMeta(lang.NewMap()).(*lang.Symbol) + tmp0 := sym_unquote.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(11), kw_column, int(6), kw_end_DASH_line, int(11), kw_end_DASH_column, int(12), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var_glojure_DOT_core_unquote = ns.Intern(tmp0) if tmp0.Meta() != nil { var_glojure_DOT_core_unquote.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -7530,7 +7596,7 @@ func LoadNS() { } // unquote-splicing { - tmp0 := sym_unquote_DASH_splicing.WithMeta(lang.NewMap()).(*lang.Symbol) + tmp0 := sym_unquote_DASH_splicing.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(12), kw_column, int(6), kw_end_DASH_line, int(12), kw_end_DASH_column, int(21), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var_glojure_DOT_core_unquote_DASH_splicing = ns.Intern(tmp0) if tmp0.Meta() != nil { var_glojure_DOT_core_unquote_DASH_splicing.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -7793,7 +7859,11 @@ func LoadNS() { _ = v6 v7 := args[5] _ = v7 - var v8 any = lang.NewList(args[6:]...) + restArgs := args[6:] + var v8 any + if len(restArgs) > 0 { + v8 = lang.NewList(restArgs...) + } _ = v8 tmp9 := checkDerefVar(var_glojure_DOT_core_cons) tmp10 := checkDerefVar(var_glojure_DOT_core_cons) @@ -7916,7 +7986,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_list) tmp7 := checkDerefVar(var_glojure_DOT_core_cons) @@ -7945,7 +8019,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_list) tmp7 := checkDerefVar(var_glojure_DOT_core_cons) @@ -8182,7 +8260,11 @@ func LoadNS() { _ = v4 v5 := args[2] _ = v5 - var v6 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 recur_loop_1564: var tmp7 any @@ -8261,7 +8343,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 recur_loop_2149: var tmp6 any @@ -8627,7 +8713,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -8732,7 +8822,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any if lang.IsTruthy(v4) { @@ -8802,7 +8896,11 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - var v5 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 recur_loop_1550: var tmp6 any @@ -8984,7 +9082,7 @@ func LoadNS() { var tmp14 any tmp15 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp15) { - tmp14 = sym_unchecked_dec + tmp14 = sym_UncheckedDec } else { tmp14 = sym_dec } @@ -9106,7 +9204,11 @@ func LoadNS() { _ = v4 v5 := args[3] _ = v5 - var v6 any = lang.NewList(args[4:]...) + restArgs := args[4:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_seq) tmp8 := checkDerefVar(var_glojure_DOT_core_concat) @@ -9159,7 +9261,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_seq) tmp7 := checkDerefVar(var_glojure_DOT_core_concat) @@ -9303,7 +9409,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 recur_loop_1844: var tmp5 any @@ -9372,7 +9482,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 recur_loop_2155: var tmp5 any @@ -9439,7 +9553,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 recur_loop_1841: var tmp5 any @@ -9499,7 +9617,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 recur_loop_2151: var tmp5 any @@ -9551,7 +9673,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_seq) tmp6 := checkDerefVar(var_glojure_DOT_core_concat) @@ -9626,7 +9752,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v3 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) tmp5 := checkDerefVar(var_glojure_DOT_core_concat) @@ -10336,7 +10466,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v3 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) tmp5 := checkDerefVar(var_glojure_DOT_core_concat) @@ -10587,7 +10721,11 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - var v5 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_seq) tmp7 := checkDerefVar(var_glojure_DOT_core_concat) @@ -11162,7 +11300,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v3 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) tmp5 := checkDerefVar(var_glojure_DOT_core_concat) @@ -11396,7 +11538,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -11491,119 +11637,6 @@ func LoadNS() { var_glojure_DOT_core_io_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // keep-indexed - { - tmp0 := sym_keep_DASH_indexed.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_coll)), kw_doc, "Returns a lazy sequence of the non-nil results of (f index item). Note,\n this means false return values will be included. f must be free of\n side-effects. Returns a stateful transducer when no collection is\n provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(7372), kw_end_DASH_line, int(7372))).(*lang.Symbol) - var tmp1 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v2 := args[0] - _ = v2 - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - var tmp5 any - { // let - // let binding "iv" - tmp6 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) - tmp7 := lang.Apply(tmp6, []any{int64(-1)}) - var v8 any = tmp7 - _ = v8 - var tmp9 lang.FnFunc - tmp9 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp10 := lang.Apply(v4, nil) - return tmp10 - case 1: - v10 := args[0] - _ = v10 - tmp11 := lang.Apply(v4, []any{v10}) - return tmp11 - case 2: - v10 := args[0] - _ = v10 - v11 := args[1] - _ = v11 - var tmp12 any - { // let - // let binding "i" - tmp13 := checkDerefVar(var_glojure_DOT_core_inc) - tmp14, ok := lang.FieldOrMethod(v8, "Deref") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "Deref"))) - } - var tmp15 any - switch reflect.TypeOf(tmp14).Kind() { - case reflect.Func: - tmp15 = lang.Apply(tmp14, nil) - default: - tmp15 = tmp14 - } - tmp16 := lang.Apply(tmp13, []any{tmp15}) - tmp17, _ := lang.FieldOrMethod(v8, "reset") - if reflect.TypeOf(tmp17).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) - } - tmp18 := lang.Apply(tmp17, []any{tmp16}) - var v19 any = tmp18 - _ = v19 - // let binding "v" - tmp20 := lang.Apply(v2, []any{v19, v11}) - var v21 any = tmp20 - _ = v21 - var tmp22 any - tmp23 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) - tmp24 := lang.Apply(tmp23, []any{v21}) - if lang.IsTruthy(tmp24) { - tmp22 = v10 - } else { - tmp25 := lang.Apply(v4, []any{v10, v21}) - tmp22 = tmp25 - } - tmp12 = tmp22 - } // end let - return tmp12 - default: - checkArity(args, -1) - panic("unreachable") - } - }) - tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7382), kw_column, int(8), kw_end_DASH_line, int(7390), kw_end_DASH_column, int(33)) - tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp5 = tmp11 - } // end let - return tmp5 - }) - tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7380), kw_column, int(4), kw_end_DASH_line, int(7390), kw_end_DASH_column, int(35)) - tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp5 - case 2: - v2 := args[0] - _ = v2 - v3 := args[1] - _ = v3 - return nil - default: - checkArity(args, -1) - panic("unreachable") - } - }) - tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - var_glojure_DOT_core_keep_DASH_indexed = ns.InternWithValue(tmp0, tmp1, true) - if tmp0.Meta() != nil { - var_glojure_DOT_core_keep_DASH_indexed.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } // keyword { tmp1 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() @@ -11820,7 +11853,11 @@ func LoadNS() { _ = v4 v5 := args[3] _ = v5 - var v6 any = lang.NewList(args[4:]...) + restArgs := args[4:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_cons) tmp8 := checkDerefVar(var_glojure_DOT_core_cons) @@ -11914,7 +11951,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v3 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) tmp5 := checkDerefVar(var_glojure_DOT_core_concat) @@ -12057,101 +12098,6 @@ func LoadNS() { var_glojure_DOT_core_macroexpand.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // map-indexed - { - tmp0 := sym_map_DASH_indexed.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_coll)), kw_doc, "Returns a lazy sequence consisting of the result of applying f to 0\n and the first item of coll, followed by applying f to 1 and the second\n item in coll, etc, until coll is exhausted. Thus function f should\n accept 2 arguments, index and item. Returns a stateful transducer when\n no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(7309), kw_end_DASH_line, int(7309))).(*lang.Symbol) - var tmp1 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v2 := args[0] - _ = v2 - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - var tmp5 any - { // let - // let binding "i" - tmp6 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) - tmp7 := lang.Apply(tmp6, []any{int64(-1)}) - var v8 any = tmp7 - _ = v8 - var tmp9 lang.FnFunc - tmp9 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp10 := lang.Apply(v4, nil) - return tmp10 - case 1: - v10 := args[0] - _ = v10 - tmp11 := lang.Apply(v4, []any{v10}) - return tmp11 - case 2: - v10 := args[0] - _ = v10 - v11 := args[1] - _ = v11 - tmp12 := checkDerefVar(var_glojure_DOT_core_inc) - tmp13, ok := lang.FieldOrMethod(v8, "Deref") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "Deref"))) - } - var tmp14 any - switch reflect.TypeOf(tmp13).Kind() { - case reflect.Func: - tmp14 = lang.Apply(tmp13, nil) - default: - tmp14 = tmp13 - } - tmp15 := lang.Apply(tmp12, []any{tmp14}) - tmp16, _ := lang.FieldOrMethod(v8, "reset") - if reflect.TypeOf(tmp16).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) - } - tmp17 := lang.Apply(tmp16, []any{tmp15}) - tmp18 := lang.Apply(v2, []any{tmp17, v11}) - tmp19 := lang.Apply(v4, []any{v10, tmp18}) - return tmp19 - default: - checkArity(args, -1) - panic("unreachable") - } - }) - tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7320), kw_column, int(8), kw_end_DASH_line, int(7324), kw_end_DASH_column, int(48)) - tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp5 = tmp11 - } // end let - return tmp5 - }) - tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7318), kw_column, int(4), kw_end_DASH_line, int(7324), kw_end_DASH_column, int(50)) - tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp5 - case 2: - v2 := args[0] - _ = v2 - v3 := args[1] - _ = v3 - return nil - default: - checkArity(args, -1) - panic("unreachable") - } - }) - tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - var_glojure_DOT_core_map_DASH_indexed = ns.InternWithValue(tmp0, tmp1, true) - if tmp0.Meta() != nil { - var_glojure_DOT_core_map_DASH_indexed.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } // maybe-destructured { tmp0 := sym_maybe_DASH_destructured.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(4514), kw_column, int(7), kw_end_DASH_line, int(4515), kw_end_DASH_column, int(20), kw_arglists, lang.NewList(lang.NewVector(sym_params, sym_body)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) @@ -12584,7 +12530,11 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - var v5 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_seq) tmp7 := checkDerefVar(var_glojure_DOT_core_concat) @@ -13542,7 +13492,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_seq) tmp6 := checkDerefVar(var_glojure_DOT_core_concat) @@ -13963,7 +13917,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v3 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) tmp5 := checkDerefVar(var_glojure_DOT_core_concat) @@ -14268,7 +14226,11 @@ func LoadNS() { _ = v6 v7 := args[2] _ = v7 - var v8 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v8 any + if len(restArgs) > 0 { + v8 = lang.NewList(restArgs...) + } _ = v8 var tmp9 any { // let @@ -14465,7 +14427,11 @@ func LoadNS() { _ = v7 v8 := args[2] _ = v8 - var v9 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v9 any + if len(restArgs) > 0 { + v9 = lang.NewList(restArgs...) + } _ = v9 var tmp10 any { // let @@ -14775,7 +14741,11 @@ func LoadNS() { _ = v8 v9 := args[2] _ = v9 - var v10 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v10 any + if len(restArgs) > 0 { + v10 = lang.NewList(restArgs...) + } _ = v10 var tmp11 any { // let @@ -14854,7 +14824,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -14983,7 +14957,11 @@ func LoadNS() { _ = v13 v14 := args[2] _ = v14 - var v15 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v15 any + if len(restArgs) > 0 { + v15 = lang.NewList(restArgs...) + } _ = v15 var tmp16 any { // let @@ -15283,7 +15261,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 tmp3 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) var tmp4 lang.FnFunc @@ -15375,7 +15357,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_unchecked_add}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_UncheckedAdd}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -15398,9 +15380,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_add") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedAdd") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_add is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedAdd is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -15585,7 +15567,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_unchecked_dec}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedDec}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -15604,9 +15586,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_dec") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedDec") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_dec is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedDec is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -15689,7 +15671,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_unchecked_int_divide}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_UncheckedIntDivide}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -15712,9 +15694,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_int_divide") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedIntDivide") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_divide is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedIntDivide is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -16585,7 +16567,11 @@ func LoadNS() { _ = v4 v5 := args[3] _ = v5 - var v6 any = lang.NewList(args[4:]...) + restArgs := args[4:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 var tmp7 any { // let @@ -16892,7 +16878,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -16980,7 +16970,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -17090,7 +17084,11 @@ func LoadNS() { _ = v4 v5 := args[3] _ = v5 - var v6 any = lang.NewList(args[4:]...) + restArgs := args[4:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_seq) tmp8 := checkDerefVar(var_glojure_DOT_core_concat) @@ -17170,7 +17168,11 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - var v5 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 recur_loop_1666: var tmp6 any @@ -17271,7 +17273,11 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - var v5 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 recur_loop_1746: var tmp6 any @@ -17374,7 +17380,11 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - var v5 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 recur_loop_1738: var tmp6 any @@ -17477,7 +17487,11 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - var v5 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 recur_loop_1742: var tmp6 any @@ -17580,7 +17594,11 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - var v5 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 recur_loop_1690: var tmp6 any @@ -17683,7 +17701,11 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - var v5 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 recur_loop_1734: var tmp6 any @@ -17812,7 +17834,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -17929,7 +17955,11 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - var v6 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) tmp8 := checkDerefVar(var_glojure_DOT_core__PLUS_) @@ -18032,7 +18062,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -18149,7 +18183,11 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - var v6 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) tmp8 := checkDerefVar(var_glojure_DOT_core__PLUS__TICK_) @@ -18252,7 +18290,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -18368,7 +18410,11 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - var v6 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) tmp8 := checkDerefVar(var_glojure_DOT_core__SLASH_) @@ -18471,7 +18517,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -18588,7 +18638,11 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - var v6 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) tmp8 := checkDerefVar(var_glojure_DOT_core__STAR_) @@ -18691,7 +18745,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -18808,7 +18866,11 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - var v6 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) tmp8 := checkDerefVar(var_glojure_DOT_core__STAR__TICK_) @@ -19085,7 +19147,11 @@ func LoadNS() { _ = v5 v6 := args[4] _ = v6 - var v7 any = lang.NewList(args[5:]...) + restArgs := args[5:] + var v7 any + if len(restArgs) > 0 { + v7 = lang.NewList(restArgs...) + } _ = v7 tmp8 := checkDerefVar(var_glojure_DOT_core_cons) tmp9 := checkDerefVar(var_glojure_DOT_core_cons) @@ -19241,7 +19307,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 tmp3 := checkDerefVar(var_glojure_DOT_core_into_DASH_array) tmp4 := lang.Apply(tmp3, []any{v2}) @@ -19425,7 +19495,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_seq) tmp6 := checkDerefVar(var_glojure_DOT_core_concat) @@ -19996,7 +20070,11 @@ func LoadNS() { _ = v8 v9 := args[2] _ = v9 - var v10 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v10 any + if len(restArgs) > 0 { + v10 = lang.NewList(restArgs...) + } _ = v10 tmp11 := lang.Apply(lang.ResetThreadBindingFrame, []any{v5}) _ = tmp11 @@ -20107,7 +20185,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -20217,7 +20299,11 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - var v6 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) tmp8 := checkDerefVar(var_glojure_DOT_core_bit_DASH_and) @@ -20320,7 +20406,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -20430,7 +20520,11 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - var v6 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) tmp8 := checkDerefVar(var_glojure_DOT_core_bit_DASH_and_DASH_not) @@ -20584,7 +20678,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -20694,7 +20792,11 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - var v6 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) tmp8 := checkDerefVar(var_glojure_DOT_core_bit_DASH_or) @@ -20911,7 +21013,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -21021,7 +21127,11 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - var v6 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) tmp8 := checkDerefVar(var_glojure_DOT_core_bit_DASH_xor) @@ -21097,7 +21207,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v3 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) tmp5 := checkDerefVar(var_glojure_DOT_core_concat) @@ -21217,7 +21331,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_seq) tmp6 := checkDerefVar(var_glojure_DOT_core_concat) @@ -21250,7 +21368,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 tmp3 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) var tmp4 lang.FnFunc @@ -21481,7 +21603,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v3 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) tmp5 := checkDerefVar(var_glojure_DOT_core_concat) @@ -21695,7 +21821,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v3 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) tmp5 := checkDerefVar(var_glojure_DOT_core_concat) @@ -21860,7 +21990,11 @@ func LoadNS() { _ = v6 v7 := args[2] _ = v7 - var v8 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v8 any + if len(restArgs) > 0 { + v8 = lang.NewList(restArgs...) + } _ = v8 tmp9 := checkDerefVar(var_glojure_DOT_core_apply) tmp10 := lang.Apply(tmp9, []any{v3, v5, v6, v7, v8}) @@ -21880,7 +22014,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_reduce1) tmp6 := checkDerefVar(var_glojure_DOT_core_comp) @@ -21981,7 +22119,11 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - var v6 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_not) tmp8 := checkDerefVar(var_glojure_DOT_core_apply) @@ -22242,7 +22384,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -22372,7 +22518,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -22658,7 +22808,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_list_STAR_) tmp7 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) @@ -22768,7 +22922,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_list) tmp6 := checkDerefVar(var_glojure_DOT_core_list_STAR_) @@ -23303,7 +23461,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) @@ -23941,7 +24103,11 @@ func LoadNS() { _ = v6 v7 := args[2] _ = v7 - var v8 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v8 any + if len(restArgs) > 0 { + v8 = lang.NewList(restArgs...) + } _ = v8 tmp9 := checkDerefVar(var_glojure_DOT_core_boolean) var tmp10 any @@ -24146,7 +24312,11 @@ func LoadNS() { _ = v7 v8 := args[2] _ = v8 - var v9 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v9 any + if len(restArgs) > 0 { + v9 = lang.NewList(restArgs...) + } _ = v9 tmp10 := checkDerefVar(var_glojure_DOT_core_boolean) var tmp11 any @@ -24464,7 +24634,11 @@ func LoadNS() { _ = v8 v9 := args[2] _ = v9 - var v10 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v10 any + if len(restArgs) > 0 { + v10 = lang.NewList(restArgs...) + } _ = v10 tmp11 := checkDerefVar(var_glojure_DOT_core_boolean) var tmp12 any @@ -24545,7 +24719,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -24674,7 +24852,11 @@ func LoadNS() { _ = v13 v14 := args[2] _ = v14 - var v15 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v15 any + if len(restArgs) > 0 { + v15 = lang.NewList(restArgs...) + } _ = v15 tmp16 := checkDerefVar(var_glojure_DOT_core_boolean) var tmp17 any @@ -25048,7 +25230,11 @@ func LoadNS() { _ = v6 v7 := args[2] _ = v7 - var v8 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v8 any + if len(restArgs) > 0 { + v8 = lang.NewList(restArgs...) + } _ = v8 tmp9 := checkDerefVar(var_glojure_DOT_core_apply) var tmp10 any @@ -25135,7 +25321,11 @@ func LoadNS() { _ = v7 v8 := args[2] _ = v8 - var v9 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v9 any + if len(restArgs) > 0 { + v9 = lang.NewList(restArgs...) + } _ = v9 tmp10 := checkDerefVar(var_glojure_DOT_core_apply) var tmp11 any @@ -25240,7 +25430,11 @@ func LoadNS() { _ = v8 v9 := args[2] _ = v9 - var v10 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v10 any + if len(restArgs) > 0 { + v10 = lang.NewList(restArgs...) + } _ = v10 tmp11 := checkDerefVar(var_glojure_DOT_core_apply) var tmp12 any @@ -25298,7 +25492,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_apply) tmp5 := lang.Apply(tmp4, []any{fmt.Sprintf, v2, v3}) @@ -25323,7 +25521,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_seq) tmp6 := checkDerefVar(var_glojure_DOT_core_concat) @@ -25524,7 +25726,11 @@ func LoadNS() { _ = v5 v6 := args[4] _ = v6 - var v7 any = lang.NewList(args[5:]...) + restArgs := args[5:] + var v7 any + if len(restArgs) > 0 { + v7 = lang.NewList(restArgs...) + } _ = v7 var tmp8 any tmp9 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) @@ -25694,7 +25900,11 @@ func LoadNS() { _ = v5 v6 := args[4] _ = v6 - var v7 any = lang.NewList(args[5:]...) + restArgs := args[5:] + var v7 any + if len(restArgs) > 0 { + v7 = lang.NewList(restArgs...) + } _ = v7 var tmp8 any tmp9 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) @@ -25937,7 +26147,11 @@ func LoadNS() { _ = v5 v6 := args[2] _ = v6 - var v7 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v7 any + if len(restArgs) > 0 { + v7 = lang.NewList(restArgs...) + } _ = v7 tmp8 := checkDerefVar(var_glojure_DOT_core_apply) tmp9 := lang.Apply(tmp8, []any{v2, v4, v5, v6, v7}) @@ -26024,7 +26238,11 @@ func LoadNS() { _ = v6 v7 := args[2] _ = v7 - var v8 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v8 any + if len(restArgs) > 0 { + v8 = lang.NewList(restArgs...) + } _ = v8 tmp9 := checkDerefVar(var_glojure_DOT_core_apply) tmp10 := lang.Apply(tmp9, []any{v2, v5, v6, v7, v8}) @@ -26119,7 +26337,11 @@ func LoadNS() { _ = v7 v8 := args[2] _ = v8 - var v9 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v9 any + if len(restArgs) > 0 { + v9 = lang.NewList(restArgs...) + } _ = v9 tmp10 := checkDerefVar(var_glojure_DOT_core_apply) tmp11 := lang.Apply(tmp10, []any{v2, v6, v7, v8, v9}) @@ -26150,7 +26372,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -26290,7 +26516,11 @@ func LoadNS() { _ = v12 v13 := args[2] _ = v13 - var v14 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v14 any + if len(restArgs) > 0 { + v14 = lang.NewList(restArgs...) + } _ = v14 tmp15 := checkDerefVar(var_glojure_DOT_core_reduce1) var tmp16 lang.FnFunc @@ -26564,6 +26794,291 @@ func LoadNS() { var_glojure_DOT_core_keep.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } + // keep-indexed + { + tmp0 := sym_keep_DASH_indexed.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_coll)), kw_doc, "Returns a lazy sequence of the non-nil results of (f index item). Note,\n this means false return values will be included. f must be free of\n side-effects. Returns a stateful transducer when no collection is\n provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(7372), kw_end_DASH_line, int(7372))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 any + { // let + // let binding "iv" + tmp6 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) + tmp7 := lang.Apply(tmp6, []any{int64(-1)}) + var v8 any = tmp7 + _ = v8 + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp10 := lang.Apply(v4, nil) + return tmp10 + case 1: + v10 := args[0] + _ = v10 + tmp11 := lang.Apply(v4, []any{v10}) + return tmp11 + case 2: + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + var tmp12 any + { // let + // let binding "i" + tmp13 := checkDerefVar(var_glojure_DOT_core_inc) + tmp14, ok := lang.FieldOrMethod(v8, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "Deref"))) + } + var tmp15 any + switch reflect.TypeOf(tmp14).Kind() { + case reflect.Func: + tmp15 = lang.Apply(tmp14, nil) + default: + tmp15 = tmp14 + } + tmp16 := lang.Apply(tmp13, []any{tmp15}) + tmp17, _ := lang.FieldOrMethod(v8, "reset") + if reflect.TypeOf(tmp17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) + } + tmp18 := lang.Apply(tmp17, []any{tmp16}) + var v19 any = tmp18 + _ = v19 + // let binding "v" + tmp20 := lang.Apply(v2, []any{v19, v11}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + tmp23 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp24 := lang.Apply(tmp23, []any{v21}) + if lang.IsTruthy(tmp24) { + tmp22 = v10 + } else { + tmp25 := lang.Apply(v4, []any{v10, v21}) + tmp22 = tmp25 + } + tmp12 = tmp22 + } // end let + return tmp12 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7382), kw_column, int(8), kw_end_DASH_line, int(7390), kw_end_DASH_column, int(33)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp5 = tmp11 + } // end let + return tmp5 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7380), kw_column, int(4), kw_end_DASH_line, int(7390), kw_end_DASH_column, int(35)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // letfn + // letfn binding "keepi" + var v5 lang.FnFunc + var tmp6 lang.FnFunc + { // function keepi + var v7 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp11 any + { // let + // let binding "temp__0__auto__" + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := lang.Apply(tmp12, []any{v9}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + var tmp16 any + { // let + // let binding "s" + var v17 any = v14 + _ = v17 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp20 := lang.Apply(tmp19, []any{v17}) + if lang.IsTruthy(tmp20) { + var tmp21 any + { // let + // let binding "c" + tmp22 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp23 := lang.Apply(tmp22, []any{v17}) + var v24 any = tmp23 + _ = v24 + // let binding "size" + tmp25 := checkDerefVar(var_glojure_DOT_core_count) + tmp26 := lang.Apply(tmp25, []any{v24}) + var v27 any = tmp26 + _ = v27 + // let binding "b" + tmp28 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_buffer) + tmp29 := lang.Apply(tmp28, []any{v27}) + var v30 any = tmp29 + _ = v30 + var tmp31 any + { // let + // let binding "n__0__auto__" + tmp32 := checkDerefVar(var_glojure_DOT_core_long) + tmp33 := lang.Apply(tmp32, []any{v27}) + var v34 any = tmp33 + _ = v34 + var tmp35 any + { // let + // let binding "i" + var v36 any = int64(0) + _ = v36 + for { + var tmp37 any + tmp38 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp39 := lang.Apply(tmp38, []any{v36, v34}) + if lang.IsTruthy(tmp39) { + var tmp40 any + { // let + // let binding "x" + tmp41 := checkDerefVar(var_glojure_DOT_core__PLUS_) + tmp42 := lang.Apply(tmp41, []any{v8, v36}) + tmp43, _ := lang.FieldOrMethod(v24, "nth") + if reflect.TypeOf(tmp43).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp44 := lang.Apply(tmp43, []any{v36}) + tmp45 := lang.Apply(v2, []any{tmp42, tmp44}) + var v46 any = tmp45 + _ = v46 + var tmp47 any + tmp48 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp49 := lang.Apply(tmp48, []any{v46}) + if lang.IsTruthy(tmp49) { + } else { + tmp50 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_append) + tmp51 := lang.Apply(tmp50, []any{v30, v46}) + tmp47 = tmp51 + } + tmp40 = tmp47 + } // end let + _ = tmp40 + tmp42 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp43 := lang.Apply(tmp42, []any{v36}) + var tmp41 any = tmp43 + v36 = tmp41 + continue + } else { + } + tmp35 = tmp37 + break + } + } // end let + tmp31 = tmp35 + } // end let + _ = tmp31 + tmp32 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_cons) + tmp33 := checkDerefVar(var_glojure_DOT_core_chunk) + tmp34 := lang.Apply(tmp33, []any{v30}) + tmp35 := checkDerefVar(var_glojure_DOT_core__PLUS_) + tmp36 := lang.Apply(tmp35, []any{v8, v27}) + tmp37 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp38 := lang.Apply(tmp37, []any{v17}) + tmp39 := lang.Apply(v7, []any{tmp36, tmp38}) + tmp40 := lang.Apply(tmp32, []any{tmp34, tmp39}) + tmp21 = tmp40 + } // end let + tmp18 = tmp21 + } else { + var tmp22 any + { // let + // let binding "x" + tmp23 := checkDerefVar(var_glojure_DOT_core_first) + tmp24 := lang.Apply(tmp23, []any{v17}) + tmp25 := lang.Apply(v2, []any{v8, tmp24}) + var v26 any = tmp25 + _ = v26 + var tmp27 any + tmp28 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp29 := lang.Apply(tmp28, []any{v26}) + if lang.IsTruthy(tmp29) { + tmp30 := checkDerefVar(var_glojure_DOT_core_inc) + tmp31 := lang.Apply(tmp30, []any{v8}) + tmp32 := checkDerefVar(var_glojure_DOT_core_rest) + tmp33 := lang.Apply(tmp32, []any{v17}) + tmp34 := lang.Apply(v7, []any{tmp31, tmp33}) + tmp27 = tmp34 + } else { + tmp35 := checkDerefVar(var_glojure_DOT_core_cons) + tmp36 := checkDerefVar(var_glojure_DOT_core_inc) + tmp37 := lang.Apply(tmp36, []any{v8}) + tmp38 := checkDerefVar(var_glojure_DOT_core_rest) + tmp39 := lang.Apply(tmp38, []any{v17}) + tmp40 := lang.Apply(v7, []any{tmp37, tmp39}) + tmp41 := lang.Apply(tmp35, []any{v26, tmp40}) + tmp27 = tmp41 + } + tmp22 = tmp27 + } // end let + tmp18 = tmp22 + } + tmp16 = tmp18 + } // end let + tmp15 = tmp16 + } else { + } + tmp11 = tmp15 + } // end let + return tmp11 + }) + tmp11 := lang.Apply(lang.NewLazySeq, []any{tmp10}) + return tmp11 + }) + v7 = tmp6 + _ = v7 + } + v5 = tmp6 + _ = v5 + tmp7 := lang.Apply(v5, []any{int64(0), v3}) + tmp4 = tmp7 + } // end letfn + return tmp4 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_keep_DASH_indexed = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_keep_DASH_indexed.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } // lazy-seq { tmp0 := sym_lazy_DASH_seq.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_body)), kw_doc, "Takes a body of expressions that returns an ISeq or nil, and yields\n a Seqable object that will invoke the body only the first time seq\n is called, and will cache the result and return it on all subsequent\n seq calls. See also - realized?", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(11), kw_line, int(676), kw_end_DASH_line, int(676))).(*lang.Symbol) @@ -26576,7 +27091,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_list) tmp6 := checkDerefVar(var_glojure_DOT_core_list_STAR_) @@ -26611,7 +27130,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_seq) tmp7 := checkDerefVar(var_glojure_DOT_core_concat) @@ -26745,7 +27268,11 @@ func LoadNS() { _ = v6 v7 := args[1] _ = v7 - var v8 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v8 any + if len(restArgs) > 0 { + v8 = lang.NewList(restArgs...) + } _ = v8 tmp9 := checkDerefVar(var_glojure_DOT_core_apply) tmp10 := lang.Apply(tmp9, []any{v2, v7, v8}) @@ -27036,7 +27563,11 @@ func LoadNS() { _ = v4 v5 := args[3] _ = v5 - var v6 any = lang.NewList(args[4:]...) + restArgs := args[4:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 var tmp7 any { // let @@ -27123,6 +27654,241 @@ func LoadNS() { var_glojure_DOT_core_map.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } + // map-indexed + { + tmp0 := sym_map_DASH_indexed.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_coll)), kw_doc, "Returns a lazy sequence consisting of the result of applying f to 0\n and the first item of coll, followed by applying f to 1 and the second\n item in coll, etc, until coll is exhausted. Thus function f should\n accept 2 arguments, index and item. Returns a stateful transducer when\n no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(7309), kw_end_DASH_line, int(7309))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 any + { // let + // let binding "i" + tmp6 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) + tmp7 := lang.Apply(tmp6, []any{int64(-1)}) + var v8 any = tmp7 + _ = v8 + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp10 := lang.Apply(v4, nil) + return tmp10 + case 1: + v10 := args[0] + _ = v10 + tmp11 := lang.Apply(v4, []any{v10}) + return tmp11 + case 2: + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_inc) + tmp13, ok := lang.FieldOrMethod(v8, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "Deref"))) + } + var tmp14 any + switch reflect.TypeOf(tmp13).Kind() { + case reflect.Func: + tmp14 = lang.Apply(tmp13, nil) + default: + tmp14 = tmp13 + } + tmp15 := lang.Apply(tmp12, []any{tmp14}) + tmp16, _ := lang.FieldOrMethod(v8, "reset") + if reflect.TypeOf(tmp16).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) + } + tmp17 := lang.Apply(tmp16, []any{tmp15}) + tmp18 := lang.Apply(v2, []any{tmp17, v11}) + tmp19 := lang.Apply(v4, []any{v10, tmp18}) + return tmp19 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7320), kw_column, int(8), kw_end_DASH_line, int(7324), kw_end_DASH_column, int(48)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp5 = tmp11 + } // end let + return tmp5 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7318), kw_column, int(4), kw_end_DASH_line, int(7324), kw_end_DASH_column, int(50)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // letfn + // letfn binding "mapi" + var v5 lang.FnFunc + var tmp6 lang.FnFunc + { // function mapi + var v7 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp11 any + { // let + // let binding "temp__0__auto__" + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := lang.Apply(tmp12, []any{v9}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + var tmp16 any + { // let + // let binding "s" + var v17 any = v14 + _ = v17 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp20 := lang.Apply(tmp19, []any{v17}) + if lang.IsTruthy(tmp20) { + var tmp21 any + { // let + // let binding "c" + tmp22 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp23 := lang.Apply(tmp22, []any{v17}) + var v24 any = tmp23 + _ = v24 + // let binding "size" + tmp25 := checkDerefVar(var_glojure_DOT_core_int) + tmp26 := checkDerefVar(var_glojure_DOT_core_count) + tmp27 := lang.Apply(tmp26, []any{v24}) + tmp28 := lang.Apply(tmp25, []any{tmp27}) + var v29 any = tmp28 + _ = v29 + // let binding "b" + tmp30 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_buffer) + tmp31 := lang.Apply(tmp30, []any{v29}) + var v32 any = tmp31 + _ = v32 + var tmp33 any + { // let + // let binding "n__0__auto__" + tmp34 := checkDerefVar(var_glojure_DOT_core_long) + tmp35 := lang.Apply(tmp34, []any{v29}) + var v36 any = tmp35 + _ = v36 + var tmp37 any + { // let + // let binding "i" + var v38 any = int64(0) + _ = v38 + for { + var tmp39 any + tmp40 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp41 := lang.Apply(tmp40, []any{v38, v36}) + if lang.IsTruthy(tmp41) { + tmp42 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_append) + tmp43 := checkDerefVar(var_glojure_DOT_core__PLUS_) + tmp44 := lang.Apply(tmp43, []any{v8, v38}) + tmp45, _ := lang.FieldOrMethod(v24, "nth") + if reflect.TypeOf(tmp45).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp46 := lang.Apply(tmp45, []any{v38}) + tmp47 := lang.Apply(v2, []any{tmp44, tmp46}) + tmp48 := lang.Apply(tmp42, []any{v32, tmp47}) + _ = tmp48 + tmp50 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp51 := lang.Apply(tmp50, []any{v38}) + var tmp49 any = tmp51 + v38 = tmp49 + continue + } else { + } + tmp37 = tmp39 + break + } + } // end let + tmp33 = tmp37 + } // end let + _ = tmp33 + tmp34 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_cons) + tmp35 := checkDerefVar(var_glojure_DOT_core_chunk) + tmp36 := lang.Apply(tmp35, []any{v32}) + tmp37 := checkDerefVar(var_glojure_DOT_core__PLUS_) + tmp38 := lang.Apply(tmp37, []any{v8, v29}) + tmp39 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp40 := lang.Apply(tmp39, []any{v17}) + tmp41 := lang.Apply(v7, []any{tmp38, tmp40}) + tmp42 := lang.Apply(tmp34, []any{tmp36, tmp41}) + tmp21 = tmp42 + } // end let + tmp18 = tmp21 + } else { + tmp22 := checkDerefVar(var_glojure_DOT_core_cons) + tmp23 := checkDerefVar(var_glojure_DOT_core_first) + tmp24 := lang.Apply(tmp23, []any{v17}) + tmp25 := lang.Apply(v2, []any{v8, tmp24}) + tmp26 := checkDerefVar(var_glojure_DOT_core_inc) + tmp27 := lang.Apply(tmp26, []any{v8}) + tmp28 := checkDerefVar(var_glojure_DOT_core_rest) + tmp29 := lang.Apply(tmp28, []any{v17}) + tmp30 := lang.Apply(v7, []any{tmp27, tmp29}) + tmp31 := lang.Apply(tmp22, []any{tmp25, tmp30}) + tmp18 = tmp31 + } + tmp16 = tmp18 + } // end let + tmp15 = tmp16 + } else { + } + tmp11 = tmp15 + } // end let + return tmp11 + }) + tmp11 := lang.Apply(lang.NewLazySeq, []any{tmp10}) + return tmp11 + }) + v7 = tmp6 + _ = v7 + } + v5 = tmp6 + _ = v5 + tmp7 := lang.Apply(v5, []any{int64(0), v3}) + tmp4 = tmp7 + } // end letfn + return tmp4 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_map_DASH_indexed = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_map_DASH_indexed.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } // max { var tmp1 lang.FnFunc @@ -27210,7 +27976,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -27324,7 +28094,11 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - var v6 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) tmp8 := checkDerefVar(var_glojure_DOT_core_max) @@ -27378,7 +28152,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -27507,7 +28285,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -27574,7 +28356,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 var tmp3 any tmp4 := checkDerefVar(var_glojure_DOT_core_some) @@ -27640,7 +28426,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 var tmp4 any tmp5 := checkDerefVar(var_glojure_DOT_core_some) @@ -27838,7 +28628,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -27952,7 +28746,11 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - var v6 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) tmp8 := checkDerefVar(var_glojure_DOT_core_min) @@ -28006,7 +28804,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -28279,7 +29081,11 @@ func LoadNS() { _ = v5 v6 := args[1] _ = v6 - var v7 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v7 any + if len(restArgs) > 0 { + v7 = lang.NewList(restArgs...) + } _ = v7 var tmp8 any { // let @@ -28482,7 +29288,11 @@ func LoadNS() { _ = v4 v5 := args[2] _ = v5 - var v6 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_apply) tmp8 := lang.Apply(tmp7, []any{closed25, v3, v4, v5, v6}) @@ -28539,7 +29349,11 @@ func LoadNS() { _ = v4 v5 := args[2] _ = v5 - var v6 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_apply) tmp8 := lang.Apply(tmp7, []any{closed26, v3, v4, v5, v6}) @@ -28580,7 +29394,11 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - var v5 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_not) tmp7 := checkDerefVar(var_glojure_DOT_core_apply) @@ -29099,7 +29917,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_seq) tmp7 := checkDerefVar(var_glojure_DOT_core_concat) @@ -29383,7 +30205,11 @@ func LoadNS() { _ = v6 v7 := args[2] _ = v7 - var v8 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v8 any + if len(restArgs) > 0 { + v8 = lang.NewList(restArgs...) + } _ = v8 tmp9 := checkDerefVar(var_glojure_DOT_core_apply) tmp10 := lang.Apply(tmp9, []any{v2, v3, v5, v6, v7, v8}) @@ -29438,7 +30264,11 @@ func LoadNS() { _ = v7 v8 := args[2] _ = v8 - var v9 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v9 any + if len(restArgs) > 0 { + v9 = lang.NewList(restArgs...) + } _ = v9 tmp10 := checkDerefVar(var_glojure_DOT_core_apply) tmp11 := lang.Apply(tmp10, []any{v2, v3, v4, v6, v7, v8, v9}) @@ -29495,7 +30325,11 @@ func LoadNS() { _ = v8 v9 := args[2] _ = v9 - var v10 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v10 any + if len(restArgs) > 0 { + v10 = lang.NewList(restArgs...) + } _ = v10 tmp11 := checkDerefVar(var_glojure_DOT_core_apply) tmp12 := lang.Apply(tmp11, []any{v2, v3, v4, v5, v7, v8, v9, v10}) @@ -29518,14 +30352,22 @@ func LoadNS() { _ = v4 v5 := args[3] _ = v5 - var v6 any = lang.NewList(args[4:]...) + restArgs := args[4:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 var tmp7 lang.FnFunc tmp7 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: checkArityGTE(args, 0) - var v8 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v8 any + if len(restArgs) > 0 { + v8 = lang.NewList(restArgs...) + } _ = v8 tmp9 := checkDerefVar(var_glojure_DOT_core_apply) tmp10 := checkDerefVar(var_glojure_DOT_core_concat) @@ -30009,7 +30851,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -30552,7 +31398,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_seq) tmp6 := checkDerefVar(var_glojure_DOT_core_concat) @@ -31062,7 +31912,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 var tmp4 any { // let @@ -31619,7 +32473,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -31850,7 +32708,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -31948,7 +32810,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -32189,7 +33055,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -32499,7 +33369,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_seq) tmp7 := checkDerefVar(var_glojure_DOT_core_concat) @@ -32925,7 +33799,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any if lang.IsTruthy(v2) { @@ -33192,7 +34070,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_trampoline) var tmp5 lang.FnFunc @@ -33301,7 +34183,11 @@ func LoadNS() { _ = v6 v7 := args[5] _ = v7 - var v8 any = lang.NewList(args[6:]...) + restArgs := args[6:] + var v8 any + if len(restArgs) > 0 { + v8 = lang.NewList(restArgs...) + } _ = v8 tmp9 := checkDerefVar(var_glojure_DOT_core_assoc) tmp10 := checkDerefVar(var_glojure_DOT_core_apply) @@ -33332,7 +34218,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -33431,7 +34321,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) tmp6 := checkDerefVar(var_glojure_DOT_core_apply) @@ -33462,7 +34356,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) @@ -33596,7 +34494,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) @@ -33719,7 +34621,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) @@ -33852,7 +34758,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_seq) tmp7 := checkDerefVar(var_glojure_DOT_core_concat) @@ -33910,7 +34820,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_seq) tmp7 := checkDerefVar(var_glojure_DOT_core_concat) @@ -33958,7 +34872,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) tmp6 := lang.Apply(tmp5, []any{v2}) @@ -33997,7 +34915,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_seq) tmp7 := checkDerefVar(var_glojure_DOT_core_concat) @@ -34078,7 +35000,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_seq) tmp6 := checkDerefVar(var_glojure_DOT_core_concat) @@ -34167,7 +35093,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) @@ -34308,7 +35238,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_seq) tmp6 := checkDerefVar(var_glojure_DOT_core_concat) @@ -34391,7 +35325,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -34504,7 +35442,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_seq) tmp7 := checkDerefVar(var_glojure_DOT_core_concat) @@ -34889,7 +35831,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -35005,7 +35951,11 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - var v6 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) tmp8 := checkDerefVar(var_glojure_DOT_core__DASH_) @@ -35108,7 +36058,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -35224,7 +36178,11 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - var v6 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) tmp8 := checkDerefVar(var_glojure_DOT_core__DASH__TICK_) @@ -35250,7 +36208,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 var tmp4 any { // let @@ -35379,7 +36341,11 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - var v5 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_apply) tmp7 := checkDerefVar(var_glojure_DOT_core_aget) @@ -35658,7 +36624,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_seq) tmp7 := checkDerefVar(var_glojure_DOT_core_concat) @@ -35729,7 +36699,11 @@ func LoadNS() { return tmp3 default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 var tmp3 any { // let @@ -35835,7 +36809,11 @@ func LoadNS() { _ = v4 v5 := args[2] _ = v5 - var v6 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_apply) tmp8 := checkDerefVar(var_glojure_DOT_core_aset) @@ -35881,7 +36859,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_apply) tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_boolean) @@ -35927,7 +36909,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_apply) tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_byte) @@ -35973,7 +36959,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_apply) tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_char) @@ -36019,7 +37009,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_apply) tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_double) @@ -36065,7 +37059,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_apply) tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_float) @@ -36111,7 +37109,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_apply) tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_int) @@ -36157,7 +37159,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_apply) tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_long) @@ -36203,7 +37209,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_apply) tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_short) @@ -36337,7 +37347,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_setup_DASH_reference) tmp5 := checkDerefVar(var_glojure_DOT_core_atom) @@ -36366,7 +37380,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) @@ -36561,7 +37579,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v8 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v8 any + if len(restArgs) > 0 { + v8 = lang.NewList(restArgs...) + } _ = v8 tmp9 := checkDerefVar(var_glojure_DOT_core_apply) tmp10 := checkDerefVar(var_glojure_DOT_core_with_DASH_bindings_STAR_) @@ -36629,7 +37651,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 var tmp4 any tmp5 := checkDerefVar(var_glojure_DOT_core_seq) @@ -36720,7 +37746,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_seq) tmp6 := checkDerefVar(var_glojure_DOT_core_concat) @@ -36866,7 +37896,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -37137,7 +38171,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -37462,7 +38500,11 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - var v5 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any tmp7 := checkDerefVar(var_glojure_DOT_core_not_EQ_) @@ -37639,7 +38681,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) @@ -38275,7 +39321,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -38688,7 +39738,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_emit_DASH_extend_DASH_protocol) tmp7 := lang.Apply(tmp6, []any{v4, v5}) @@ -38744,7 +39798,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -39115,7 +40173,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -39344,7 +40406,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 lang.FnFunc tmp5 = lang.NewFnFunc(func(args ...any) any { @@ -39773,7 +40839,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_seq) tmp6 := checkDerefVar(var_glojure_DOT_core_concat) @@ -39820,7 +40890,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_seq) tmp7 := checkDerefVar(var_glojure_DOT_core_concat) @@ -40117,7 +41191,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -40571,7 +41649,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v11 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v11 any + if len(restArgs) > 0 { + v11 = lang.NewList(restArgs...) + } _ = v11 var tmp12 any { // let @@ -40644,7 +41726,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -41538,7 +42624,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 tmp3 := checkDerefVar(var_glojure_DOT_core_pmap) var tmp4 lang.FnFunc @@ -41954,7 +43044,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 var tmp4 any { // let @@ -42274,7 +43368,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_apply) tmp6 := checkDerefVar(var_glojure_DOT_core_send_DASH_via) @@ -42300,7 +43398,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_apply) tmp6 := checkDerefVar(var_glojure_DOT_core_send_DASH_via) @@ -42912,7 +44014,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -43030,7 +44136,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -43248,7 +44358,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) @@ -43713,7 +44827,11 @@ func LoadNS() { _ = v4 v5 := args[3] _ = v5 - var v6 any = lang.NewList(args[4:]...) + restArgs := args[4:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_seq) tmp8 := checkDerefVar(var_glojure_DOT_core_concat) @@ -43769,7 +44887,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 var tmp3 any tmp4 := lang.Apply(nil, nil) @@ -44006,7 +45128,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 var tmp4 any tmp5 := lang.Apply(nil, nil) @@ -44297,7 +45423,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -44426,7 +45556,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -44557,7 +45691,11 @@ func LoadNS() { _ = v4 v5 := args[3] _ = v5 - var v6 any = lang.NewList(args[4:]...) + restArgs := args[4:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 var tmp7 any { // let @@ -44820,7 +45958,11 @@ func LoadNS() { _ = v4 v5 := args[2] _ = v5 - var v6 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 var tmp7 any tmp8 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) @@ -45868,7 +47010,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 var tmp4 any { // let @@ -45964,7 +47110,11 @@ func LoadNS() { checkArityGTE(args, 1) v52 := args[0] _ = v52 - var v53 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v53 any + if len(restArgs) > 0 { + v53 = lang.NewList(restArgs...) + } _ = v53 tmp54 := checkDerefVar(var_glojure_DOT_core_apply) tmp55 := checkDerefVar(var_glojure_DOT_core_cons) @@ -46116,7 +47266,11 @@ func LoadNS() { checkArityGTE(args, 1) v64 := args[0] _ = v64 - var v65 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v65 any + if len(restArgs) > 0 { + v65 = lang.NewList(restArgs...) + } _ = v65 tmp66 := checkDerefVar(var_glojure_DOT_core_apply) tmp67 := checkDerefVar(var_glojure_DOT_core_cons) @@ -46321,7 +47475,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v38 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v38 any + if len(restArgs) > 0 { + v38 = lang.NewList(restArgs...) + } _ = v38 tmp39 := checkDerefVar(var_glojure_DOT_core_apply) tmp40 := checkDerefVar(var_glojure_DOT_core_str) @@ -47401,7 +48559,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) @@ -47472,7 +48634,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) @@ -47957,7 +49123,11 @@ func LoadNS() { checkArityGTE(args, 1) v5 := args[0] _ = v5 - var v6 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_class) tmp8 := lang.Apply(tmp7, []any{v5}) @@ -47973,7 +49143,11 @@ func LoadNS() { checkArityGTE(args, 1) v6 := args[0] _ = v6 - var v7 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v7 any + if len(restArgs) > 0 { + v7 = lang.NewList(restArgs...) + } _ = v7 tmp8 := checkDerefVar(var_glojure_DOT_core_apply) tmp9 := checkDerefVar(var_glojure_DOT_core_cons) @@ -47991,7 +49165,11 @@ func LoadNS() { checkArityGTE(args, 1) v8 := args[0] _ = v8 - var v9 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v9 any + if len(restArgs) > 0 { + v9 = lang.NewList(restArgs...) + } _ = v9 tmp10 := checkDerefVar(var_glojure_DOT_core_apply) tmp11 := checkDerefVar(var_glojure_DOT_core_cons) @@ -48009,7 +49187,11 @@ func LoadNS() { checkArityGTE(args, 1) v10 := args[0] _ = v10 - var v11 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v11 any + if len(restArgs) > 0 { + v11 = lang.NewList(restArgs...) + } _ = v11 tmp12 := checkDerefVar(var_glojure_DOT_core_apply) tmp13 := checkDerefVar(var_glojure_DOT_core_cons) @@ -48027,7 +49209,11 @@ func LoadNS() { checkArityGTE(args, 1) v12 := args[0] _ = v12 - var v13 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v13 any + if len(restArgs) > 0 { + v13 = lang.NewList(restArgs...) + } _ = v13 tmp14 := checkDerefVar(var_glojure_DOT_core_apply) tmp15 := checkDerefVar(var_glojure_DOT_core_cons) @@ -48045,7 +49231,11 @@ func LoadNS() { checkArityGTE(args, 1) v15 := args[0] _ = v15 - var v16 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v16 any + if len(restArgs) > 0 { + v16 = lang.NewList(restArgs...) + } _ = v16 tmp17 := checkDerefVar(var_glojure_DOT_core_class) tmp18 := lang.Apply(tmp17, []any{v15}) @@ -48061,7 +49251,11 @@ func LoadNS() { checkArityGTE(args, 1) v16 := args[0] _ = v16 - var v17 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v17 any + if len(restArgs) > 0 { + v17 = lang.NewList(restArgs...) + } _ = v17 tmp18 := checkDerefVar(var_glojure_DOT_core_apply) tmp19 := checkDerefVar(var_glojure_DOT_core_cons) @@ -48079,7 +49273,11 @@ func LoadNS() { checkArityGTE(args, 1) v18 := args[0] _ = v18 - var v19 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v19 any + if len(restArgs) > 0 { + v19 = lang.NewList(restArgs...) + } _ = v19 tmp20 := checkDerefVar(var_glojure_DOT_core_apply) tmp21 := checkDerefVar(var_glojure_DOT_core_cons) @@ -48097,7 +49295,11 @@ func LoadNS() { checkArityGTE(args, 1) v20 := args[0] _ = v20 - var v21 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v21 any + if len(restArgs) > 0 { + v21 = lang.NewList(restArgs...) + } _ = v21 tmp22 := checkDerefVar(var_glojure_DOT_core_apply) tmp23 := checkDerefVar(var_glojure_DOT_core_cons) @@ -48115,7 +49317,11 @@ func LoadNS() { checkArityGTE(args, 1) v23 := args[0] _ = v23 - var v24 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v24 any + if len(restArgs) > 0 { + v24 = lang.NewList(restArgs...) + } _ = v24 tmp25 := checkDerefVar(var_glojure_DOT_core_class) tmp26 := lang.Apply(tmp25, []any{v23}) @@ -48132,7 +49338,11 @@ func LoadNS() { checkArityGTE(args, 1) v26 := args[0] _ = v26 - var v27 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v27 any + if len(restArgs) > 0 { + v27 = lang.NewList(restArgs...) + } _ = v27 tmp28 := checkDerefVar(var_glojure_DOT_core_class) tmp29 := lang.Apply(tmp28, []any{v26}) @@ -48148,7 +49358,11 @@ func LoadNS() { checkArityGTE(args, 1) v27 := args[0] _ = v27 - var v28 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v28 any + if len(restArgs) > 0 { + v28 = lang.NewList(restArgs...) + } _ = v28 tmp29 := checkDerefVar(var_glojure_DOT_core_apply) tmp30 := checkDerefVar(var_glojure_DOT_core_cons) @@ -48166,7 +49380,11 @@ func LoadNS() { checkArityGTE(args, 1) v30 := args[0] _ = v30 - var v31 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v31 any + if len(restArgs) > 0 { + v31 = lang.NewList(restArgs...) + } _ = v31 tmp32 := checkDerefVar(var_glojure_DOT_core_class) tmp33 := lang.Apply(tmp32, []any{v30}) @@ -48216,7 +49434,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -48827,7 +50049,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_apply) tmp5 := checkDerefVar(var_glojure_DOT_core_concat) @@ -49515,7 +50741,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_emit_DASH_extend_DASH_type) tmp7 := lang.Apply(tmp6, []any{v4, v5}) @@ -50586,7 +51816,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 var tmp4 any { // let @@ -50810,7 +52044,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 var tmp3 any { // let @@ -51534,7 +52772,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_throw_DASH_if) var tmp6 any @@ -52089,7 +53331,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 var tmp3 any { // let @@ -52658,7 +53904,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 tmp3 := checkDerefVar(var_glojure_DOT_core_apply) tmp4 := checkDerefVar(var_glojure_DOT_core_load_DASH_libs) @@ -52680,7 +53930,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 var tmp3 any { // let @@ -52730,7 +53984,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 tmp3 := checkDerefVar(var_glojure_DOT_core_apply) tmp4 := checkDerefVar(var_glojure_DOT_core_load_DASH_libs) @@ -52884,7 +54142,11 @@ func LoadNS() { _ = v4 v5 := args[3] _ = v5 - var v6 any = lang.NewList(args[4:]...) + restArgs := args[4:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_into) tmp8 := lang.NewVector() @@ -52980,7 +54242,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 recur_loop_2211: tmp4 := checkDerefVar(var_glojure_DOT_core_pr) @@ -53039,7 +54305,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v3 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 var tmp4 any { // let @@ -53092,7 +54362,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 var tmp3 any { // let @@ -53134,7 +54408,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v3 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 var tmp4 any { // let @@ -53189,7 +54467,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_print) tmp5 := checkDerefVar(var_glojure_DOT_core_apply) @@ -53213,7 +54495,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 tmp3 := checkDerefVar(var_glojure_DOT_core_apply) tmp4 := checkDerefVar(var_glojure_DOT_core_pr) @@ -53248,7 +54534,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v3 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 var tmp4 any { // let @@ -53301,7 +54591,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 var tmp3 any { // let @@ -53343,7 +54637,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v3 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 var tmp4 any { // let @@ -56232,7 +57530,11 @@ func LoadNS() { checkArityGTE(args, 1) v3 := args[0] _ = v3 - var v4 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let diff --git a/pkg/stdlib/glojure/core_deftype/loader.go b/pkg/stdlib/glojure/core_deftype/loader.go index ba84d640..63ae2efc 100644 --- a/pkg/stdlib/glojure/core_deftype/loader.go +++ b/pkg/stdlib/glojure/core_deftype/loader.go @@ -113,6 +113,8 @@ func LoadNS() { sym_SetMacro := lang.NewSymbol("SetMacro") sym_StackTraceElement_DASH__GT_vec := lang.NewSymbol("StackTraceElement->vec") sym_Throwable_DASH__GT_map := lang.NewSymbol("Throwable->map") + sym_UncheckedAdd := lang.NewSymbol("UncheckedAdd") + sym_UncheckedDec := lang.NewSymbol("UncheckedDec") sym_a := lang.NewSymbol("a") sym_a__0__auto__ := lang.NewSymbol("a__0__auto__") sym_abs := lang.NewSymbol("abs") @@ -491,11 +493,14 @@ func LoadNS() { sym_glojure_DOT_core_SLASH_Nth := lang.NewSymbol("glojure.core/Nth") sym_glojure_DOT_core_SLASH_Object_array := lang.NewSymbol("glojure.core/Object_array") sym_glojure_DOT_core_SLASH_RunInTransaction := lang.NewSymbol("glojure.core/RunInTransaction") + sym_glojure_DOT_core_SLASH_UncheckedAdd := lang.NewSymbol("glojure.core/UncheckedAdd") sym_glojure_DOT_core_SLASH_UncheckedByteCast := lang.NewSymbol("glojure.core/UncheckedByteCast") sym_glojure_DOT_core_SLASH_UncheckedCharCast := lang.NewSymbol("glojure.core/UncheckedCharCast") + sym_glojure_DOT_core_SLASH_UncheckedDec := lang.NewSymbol("glojure.core/UncheckedDec") sym_glojure_DOT_core_SLASH_UncheckedDoubleCast := lang.NewSymbol("glojure.core/UncheckedDoubleCast") sym_glojure_DOT_core_SLASH_UncheckedFloatCast := lang.NewSymbol("glojure.core/UncheckedFloatCast") sym_glojure_DOT_core_SLASH_UncheckedIntCast := lang.NewSymbol("glojure.core/UncheckedIntCast") + sym_glojure_DOT_core_SLASH_UncheckedIntDivide := lang.NewSymbol("glojure.core/UncheckedIntDivide") sym_glojure_DOT_core_SLASH_UncheckedLongCast := lang.NewSymbol("glojure.core/UncheckedLongCast") sym_glojure_DOT_core_SLASH_UncheckedShortCast := lang.NewSymbol("glojure.core/UncheckedShortCast") sym_glojure_DOT_core_SLASH_aclone := lang.NewSymbol("glojure.core/aclone") @@ -611,12 +616,9 @@ func LoadNS() { sym_glojure_DOT_core_SLASH_to_DASH_array := lang.NewSymbol("glojure.core/to-array") sym_glojure_DOT_core_SLASH_unchecked_DASH_inc := lang.NewSymbol("glojure.core/unchecked-inc") sym_glojure_DOT_core_SLASH_unchecked_DASH_inc_DASH_int := lang.NewSymbol("glojure.core/unchecked-inc-int") - sym_glojure_DOT_core_SLASH_unchecked_add := lang.NewSymbol("glojure.core/unchecked_add") - sym_glojure_DOT_core_SLASH_unchecked_dec := lang.NewSymbol("glojure.core/unchecked_dec") sym_glojure_DOT_core_SLASH_unchecked_inc := lang.NewSymbol("glojure.core/unchecked_inc") sym_glojure_DOT_core_SLASH_unchecked_int_add := lang.NewSymbol("glojure.core/unchecked_int_add") sym_glojure_DOT_core_SLASH_unchecked_int_dec := lang.NewSymbol("glojure.core/unchecked_int_dec") - sym_glojure_DOT_core_SLASH_unchecked_int_divide := lang.NewSymbol("glojure.core/unchecked_int_divide") sym_glojure_DOT_core_SLASH_unchecked_int_inc := lang.NewSymbol("glojure.core/unchecked_int_inc") sym_glojure_DOT_core_SLASH_unchecked_int_multiply := lang.NewSymbol("glojure.core/unchecked_int_multiply") sym_glojure_DOT_core_SLASH_unchecked_int_negate := lang.NewSymbol("glojure.core/unchecked_int_negate") @@ -1183,8 +1185,6 @@ func LoadNS() { sym_uncheckedFloatCast := lang.NewSymbol("uncheckedFloatCast") sym_uncheckedIntCast := lang.NewSymbol("uncheckedIntCast") sym_uncheckedShortCast := lang.NewSymbol("uncheckedShortCast") - sym_unchecked_add := lang.NewSymbol("unchecked_add") - sym_unchecked_dec := lang.NewSymbol("unchecked_dec") sym_unchecked_inc := lang.NewSymbol("unchecked_inc") sym_unchecked_minus := lang.NewSymbol("unchecked_minus") sym_unchecked_multiply := lang.NewSymbol("unchecked_multiply") @@ -1421,8 +1421,6 @@ func LoadNS() { var_glojure_DOT_core__STAR_assert_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_assert_STAR_) // var glojure.core/*command-line-args* var_glojure_DOT_core__STAR_command_DASH_line_DASH_args_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_command_DASH_line_DASH_args_STAR_) - // var glojure.core/*compile-files* - var_glojure_DOT_core__STAR_compile_DASH_files_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_compile_DASH_files_STAR_) // var glojure.core/*compile-path* var_glojure_DOT_core__STAR_compile_DASH_path_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_compile_DASH_path_STAR_) // var glojure.core/*compiler-options* @@ -2828,7 +2826,7 @@ func LoadNS() { } var closed3 any { - closed3 = sym_unchecked_add + closed3 = sym_UncheckedAdd } var closed4 any { @@ -2907,27 +2905,30 @@ func LoadNS() { } // *1 { - tmp0 := sym__STAR_1.WithMeta(lang.NewMap()).(*lang.Symbol) + tmp0 := sym__STAR_1.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core.glj", kw_line, int(6268), kw_column, int(6), kw_end_DASH_line, int(6271), kw_end_DASH_column, int(3), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var_glojure_DOT_core__STAR_1 = ns.Intern(tmp0) if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_1.SetDynamic() } // *2 { - tmp0 := sym__STAR_2.WithMeta(lang.NewMap()).(*lang.Symbol) + tmp0 := sym__STAR_2.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core.glj", kw_line, int(6273), kw_column, int(6), kw_end_DASH_line, int(6276), kw_end_DASH_column, int(3), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var_glojure_DOT_core__STAR_2 = ns.Intern(tmp0) if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_2.SetDynamic() } // *3 { - tmp0 := sym__STAR_3.WithMeta(lang.NewMap()).(*lang.Symbol) + tmp0 := sym__STAR_3.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core.glj", kw_line, int(6278), kw_column, int(6), kw_end_DASH_line, int(6281), kw_end_DASH_column, int(3), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var_glojure_DOT_core__STAR_3 = ns.Intern(tmp0) if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_3.SetDynamic() } // *agent* { @@ -2953,14 +2954,6 @@ func LoadNS() { var_glojure_DOT_core__STAR_command_DASH_line_DASH_args_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // *compile-files* - { - tmp0 := sym__STAR_compile_DASH_files_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "Set to true when compiling files, false otherwise.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - var_glojure_DOT_core__STAR_compile_DASH_files_STAR_ = ns.InternWithValue(tmp0, true, true) - if tmp0.Meta() != nil { - var_glojure_DOT_core__STAR_compile_DASH_files_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } // *compile-path* { tmp0 := sym__STAR_compile_DASH_path_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "Specifies the directory where 'compile' will write out .class\n files. This directory must be in the classpath for 'compile' to\n work.\n\n Defaults to \"classes\"", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) @@ -2997,11 +2990,12 @@ func LoadNS() { } // *e { - tmp0 := sym__STAR_e.WithMeta(lang.NewMap()).(*lang.Symbol) + tmp0 := sym__STAR_e.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core.glj", kw_line, int(6283), kw_column, int(6), kw_end_DASH_line, int(6286), kw_end_DASH_column, int(3), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var_glojure_DOT_core__STAR_e = ns.Intern(tmp0) if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_e.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_e.SetDynamic() } // *err* { @@ -3254,7 +3248,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5, _ := lang.FieldOrMethod(v2, "alter") if reflect.TypeOf(tmp5).Kind() != reflect.Func { @@ -3282,7 +3280,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5, _ := lang.FieldOrMethod(v2, "AlterMeta") if reflect.TypeOf(tmp5).Kind() != reflect.Func { @@ -3310,7 +3312,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5, _ := lang.FieldOrMethod(v2, "alterRoot") if reflect.TypeOf(tmp5).Kind() != reflect.Func { @@ -3681,7 +3687,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 return nil } @@ -3704,7 +3714,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5, _ := lang.FieldOrMethod(v2, "Commute") if reflect.TypeOf(tmp5).Kind() != reflect.Func { @@ -3831,7 +3845,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v4 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 return v2 } @@ -3897,7 +3915,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 tmp3 := lang.Apply(lang.CreatePersistentStructMapSlotMap, []any{v2}) return tmp3 @@ -4351,7 +4373,7 @@ func LoadNS() { } // gen-class { - tmp0 := sym_gen_DASH_class.WithMeta(lang.NewMap()).(*lang.Symbol) + tmp0 := sym_gen_DASH_class.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5732), kw_column, int(10), kw_end_DASH_line, int(5732), kw_end_DASH_column, int(18), kw_declared, true, kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var_glojure_DOT_core_gen_DASH_class = ns.Intern(tmp0) if tmp0.Meta() != nil { var_glojure_DOT_core_gen_DASH_class.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -4457,7 +4479,11 @@ func LoadNS() { return tmp4 default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 tmp3 := lang.Apply(lang.CreatePersistentHashMap, []any{v2}) return tmp3 @@ -4502,7 +4528,11 @@ func LoadNS() { return tmp4 default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 tmp3 := lang.Apply(nil, []any{v2}) return tmp3 @@ -6546,7 +6576,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 tmp3 := lang.Apply(lang.CreatePersistentTreeMap, []any{v2}) return tmp3 @@ -6568,7 +6602,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 tmp4 := lang.Apply(nil, []any{v2, v3}) return tmp4 @@ -6588,7 +6626,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 tmp3 := lang.Apply(lang.CreatePersistentTreeSet, []any{v2}) return tmp3 @@ -6610,7 +6652,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 tmp4 := lang.Apply(lang.CreatePersistentTreeSetWithComparator, []any{v2, v3}) return tmp4 @@ -6745,7 +6791,11 @@ func LoadNS() { checkArityGTE(args, 1) v3 := args[0] _ = v3 - var v4 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 lang.FnFunc tmp5 = lang.NewFnFunc(func(args ...any) any { @@ -6978,7 +7028,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 tmp4 := lang.Apply(lang.ConstructPersistentStructMap, []any{v2, v3}) return tmp4 @@ -7000,7 +7054,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 tmp4 := lang.Apply(lang.CreatePersistentStructMap, []any{v2, v3}) return tmp4 @@ -7057,7 +7115,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5, _ := lang.FieldOrMethod(v2, "swap") if reflect.TypeOf(tmp5).Kind() != reflect.Func { @@ -7085,7 +7147,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5, _ := lang.FieldOrMethod(v2, "swapVals") if reflect.TypeOf(tmp5).Kind() != reflect.Func { @@ -7439,7 +7505,7 @@ func LoadNS() { } // unquote { - tmp0 := sym_unquote.WithMeta(lang.NewMap()).(*lang.Symbol) + tmp0 := sym_unquote.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(11), kw_column, int(6), kw_end_DASH_line, int(11), kw_end_DASH_column, int(12), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var_glojure_DOT_core_unquote = ns.Intern(tmp0) if tmp0.Meta() != nil { var_glojure_DOT_core_unquote.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -7447,7 +7513,7 @@ func LoadNS() { } // unquote-splicing { - tmp0 := sym_unquote_DASH_splicing.WithMeta(lang.NewMap()).(*lang.Symbol) + tmp0 := sym_unquote_DASH_splicing.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(12), kw_column, int(6), kw_end_DASH_line, int(12), kw_end_DASH_column, int(21), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var_glojure_DOT_core_unquote_DASH_splicing = ns.Intern(tmp0) if tmp0.Meta() != nil { var_glojure_DOT_core_unquote_DASH_splicing.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -7710,7 +7776,11 @@ func LoadNS() { _ = v6 v7 := args[5] _ = v7 - var v8 any = lang.NewList(args[6:]...) + restArgs := args[6:] + var v8 any + if len(restArgs) > 0 { + v8 = lang.NewList(restArgs...) + } _ = v8 tmp9 := checkDerefVar(var_glojure_DOT_core_cons) tmp10 := checkDerefVar(var_glojure_DOT_core_cons) @@ -7833,7 +7903,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_list) tmp7 := checkDerefVar(var_glojure_DOT_core_cons) @@ -7862,7 +7936,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_list) tmp7 := checkDerefVar(var_glojure_DOT_core_cons) @@ -8099,7 +8177,11 @@ func LoadNS() { _ = v4 v5 := args[2] _ = v5 - var v6 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 recur_loop_1564: var tmp7 any @@ -8178,7 +8260,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 recur_loop_2149: var tmp6 any @@ -8544,7 +8630,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -8649,7 +8739,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any if lang.IsTruthy(v4) { @@ -8719,7 +8813,11 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - var v5 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 recur_loop_1550: var tmp6 any @@ -8901,7 +8999,7 @@ func LoadNS() { var tmp14 any tmp15 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp15) { - tmp14 = sym_unchecked_dec + tmp14 = sym_UncheckedDec } else { tmp14 = sym_dec } @@ -9023,7 +9121,11 @@ func LoadNS() { _ = v4 v5 := args[3] _ = v5 - var v6 any = lang.NewList(args[4:]...) + restArgs := args[4:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_seq) tmp8 := checkDerefVar(var_glojure_DOT_core_concat) @@ -9076,7 +9178,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_seq) tmp7 := checkDerefVar(var_glojure_DOT_core_concat) @@ -9220,7 +9326,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 recur_loop_1844: var tmp5 any @@ -9289,7 +9399,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 recur_loop_2155: var tmp5 any @@ -9356,7 +9470,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 recur_loop_1841: var tmp5 any @@ -9416,7 +9534,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 recur_loop_2151: var tmp5 any @@ -9468,7 +9590,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_seq) tmp6 := checkDerefVar(var_glojure_DOT_core_concat) @@ -9543,7 +9669,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v3 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) tmp5 := checkDerefVar(var_glojure_DOT_core_concat) @@ -10253,7 +10383,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v3 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) tmp5 := checkDerefVar(var_glojure_DOT_core_concat) @@ -10504,7 +10638,11 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - var v5 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_seq) tmp7 := checkDerefVar(var_glojure_DOT_core_concat) @@ -11079,7 +11217,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v3 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) tmp5 := checkDerefVar(var_glojure_DOT_core_concat) @@ -11313,7 +11455,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -11408,119 +11554,6 @@ func LoadNS() { var_glojure_DOT_core_io_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // keep-indexed - { - tmp0 := sym_keep_DASH_indexed.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_coll)), kw_doc, "Returns a lazy sequence of the non-nil results of (f index item). Note,\n this means false return values will be included. f must be free of\n side-effects. Returns a stateful transducer when no collection is\n provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(7372), kw_end_DASH_line, int(7372))).(*lang.Symbol) - var tmp1 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v2 := args[0] - _ = v2 - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - var tmp5 any - { // let - // let binding "iv" - tmp6 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) - tmp7 := lang.Apply(tmp6, []any{int64(-1)}) - var v8 any = tmp7 - _ = v8 - var tmp9 lang.FnFunc - tmp9 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp10 := lang.Apply(v4, nil) - return tmp10 - case 1: - v10 := args[0] - _ = v10 - tmp11 := lang.Apply(v4, []any{v10}) - return tmp11 - case 2: - v10 := args[0] - _ = v10 - v11 := args[1] - _ = v11 - var tmp12 any - { // let - // let binding "i" - tmp13 := checkDerefVar(var_glojure_DOT_core_inc) - tmp14, ok := lang.FieldOrMethod(v8, "Deref") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "Deref"))) - } - var tmp15 any - switch reflect.TypeOf(tmp14).Kind() { - case reflect.Func: - tmp15 = lang.Apply(tmp14, nil) - default: - tmp15 = tmp14 - } - tmp16 := lang.Apply(tmp13, []any{tmp15}) - tmp17, _ := lang.FieldOrMethod(v8, "reset") - if reflect.TypeOf(tmp17).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) - } - tmp18 := lang.Apply(tmp17, []any{tmp16}) - var v19 any = tmp18 - _ = v19 - // let binding "v" - tmp20 := lang.Apply(v2, []any{v19, v11}) - var v21 any = tmp20 - _ = v21 - var tmp22 any - tmp23 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) - tmp24 := lang.Apply(tmp23, []any{v21}) - if lang.IsTruthy(tmp24) { - tmp22 = v10 - } else { - tmp25 := lang.Apply(v4, []any{v10, v21}) - tmp22 = tmp25 - } - tmp12 = tmp22 - } // end let - return tmp12 - default: - checkArity(args, -1) - panic("unreachable") - } - }) - tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7382), kw_column, int(8), kw_end_DASH_line, int(7390), kw_end_DASH_column, int(33)) - tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp5 = tmp11 - } // end let - return tmp5 - }) - tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7380), kw_column, int(4), kw_end_DASH_line, int(7390), kw_end_DASH_column, int(35)) - tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp5 - case 2: - v2 := args[0] - _ = v2 - v3 := args[1] - _ = v3 - return nil - default: - checkArity(args, -1) - panic("unreachable") - } - }) - tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - var_glojure_DOT_core_keep_DASH_indexed = ns.InternWithValue(tmp0, tmp1, true) - if tmp0.Meta() != nil { - var_glojure_DOT_core_keep_DASH_indexed.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } // keyword { tmp1 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() @@ -11737,7 +11770,11 @@ func LoadNS() { _ = v4 v5 := args[3] _ = v5 - var v6 any = lang.NewList(args[4:]...) + restArgs := args[4:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_cons) tmp8 := checkDerefVar(var_glojure_DOT_core_cons) @@ -11831,7 +11868,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v3 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) tmp5 := checkDerefVar(var_glojure_DOT_core_concat) @@ -11974,101 +12015,6 @@ func LoadNS() { var_glojure_DOT_core_macroexpand.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // map-indexed - { - tmp0 := sym_map_DASH_indexed.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_coll)), kw_doc, "Returns a lazy sequence consisting of the result of applying f to 0\n and the first item of coll, followed by applying f to 1 and the second\n item in coll, etc, until coll is exhausted. Thus function f should\n accept 2 arguments, index and item. Returns a stateful transducer when\n no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(7309), kw_end_DASH_line, int(7309))).(*lang.Symbol) - var tmp1 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v2 := args[0] - _ = v2 - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - var tmp5 any - { // let - // let binding "i" - tmp6 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) - tmp7 := lang.Apply(tmp6, []any{int64(-1)}) - var v8 any = tmp7 - _ = v8 - var tmp9 lang.FnFunc - tmp9 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp10 := lang.Apply(v4, nil) - return tmp10 - case 1: - v10 := args[0] - _ = v10 - tmp11 := lang.Apply(v4, []any{v10}) - return tmp11 - case 2: - v10 := args[0] - _ = v10 - v11 := args[1] - _ = v11 - tmp12 := checkDerefVar(var_glojure_DOT_core_inc) - tmp13, ok := lang.FieldOrMethod(v8, "Deref") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "Deref"))) - } - var tmp14 any - switch reflect.TypeOf(tmp13).Kind() { - case reflect.Func: - tmp14 = lang.Apply(tmp13, nil) - default: - tmp14 = tmp13 - } - tmp15 := lang.Apply(tmp12, []any{tmp14}) - tmp16, _ := lang.FieldOrMethod(v8, "reset") - if reflect.TypeOf(tmp16).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) - } - tmp17 := lang.Apply(tmp16, []any{tmp15}) - tmp18 := lang.Apply(v2, []any{tmp17, v11}) - tmp19 := lang.Apply(v4, []any{v10, tmp18}) - return tmp19 - default: - checkArity(args, -1) - panic("unreachable") - } - }) - tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7320), kw_column, int(8), kw_end_DASH_line, int(7324), kw_end_DASH_column, int(48)) - tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp5 = tmp11 - } // end let - return tmp5 - }) - tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7318), kw_column, int(4), kw_end_DASH_line, int(7324), kw_end_DASH_column, int(50)) - tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp5 - case 2: - v2 := args[0] - _ = v2 - v3 := args[1] - _ = v3 - return nil - default: - checkArity(args, -1) - panic("unreachable") - } - }) - tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - var_glojure_DOT_core_map_DASH_indexed = ns.InternWithValue(tmp0, tmp1, true) - if tmp0.Meta() != nil { - var_glojure_DOT_core_map_DASH_indexed.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } // maybe-destructured { tmp0 := sym_maybe_DASH_destructured.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(4514), kw_column, int(7), kw_end_DASH_line, int(4515), kw_end_DASH_column, int(20), kw_arglists, lang.NewList(lang.NewVector(sym_params, sym_body)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) @@ -12501,7 +12447,11 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - var v5 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_seq) tmp7 := checkDerefVar(var_glojure_DOT_core_concat) @@ -13459,7 +13409,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_seq) tmp6 := checkDerefVar(var_glojure_DOT_core_concat) @@ -13880,7 +13834,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v3 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) tmp5 := checkDerefVar(var_glojure_DOT_core_concat) @@ -14436,7 +14394,11 @@ func LoadNS() { _ = v6 v7 := args[2] _ = v7 - var v8 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v8 any + if len(restArgs) > 0 { + v8 = lang.NewList(restArgs...) + } _ = v8 var tmp9 any { // let @@ -14633,7 +14595,11 @@ func LoadNS() { _ = v7 v8 := args[2] _ = v8 - var v9 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v9 any + if len(restArgs) > 0 { + v9 = lang.NewList(restArgs...) + } _ = v9 var tmp10 any { // let @@ -14943,7 +14909,11 @@ func LoadNS() { _ = v8 v9 := args[2] _ = v9 - var v10 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v10 any + if len(restArgs) > 0 { + v10 = lang.NewList(restArgs...) + } _ = v10 var tmp11 any { // let @@ -15022,7 +14992,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -15151,7 +15125,11 @@ func LoadNS() { _ = v13 v14 := args[2] _ = v14 - var v15 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v15 any + if len(restArgs) > 0 { + v15 = lang.NewList(restArgs...) + } _ = v15 var tmp16 any { // let @@ -15451,7 +15429,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 tmp3 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) var tmp4 lang.FnFunc @@ -15543,7 +15525,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_unchecked_add}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_UncheckedAdd}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -15566,9 +15548,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_add") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedAdd") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_add is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedAdd is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -15753,7 +15735,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_unchecked_dec}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedDec}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -15772,9 +15754,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_dec") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedDec") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_dec is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedDec is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -15857,7 +15839,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_unchecked_int_divide}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_UncheckedIntDivide}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -15880,9 +15862,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_int_divide") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedIntDivide") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_divide is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedIntDivide is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -16753,7 +16735,11 @@ func LoadNS() { _ = v4 v5 := args[3] _ = v5 - var v6 any = lang.NewList(args[4:]...) + restArgs := args[4:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 var tmp7 any { // let @@ -17060,7 +17046,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -17148,7 +17138,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -17258,7 +17252,11 @@ func LoadNS() { _ = v4 v5 := args[3] _ = v5 - var v6 any = lang.NewList(args[4:]...) + restArgs := args[4:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_seq) tmp8 := checkDerefVar(var_glojure_DOT_core_concat) @@ -17338,7 +17336,11 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - var v5 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 recur_loop_1666: var tmp6 any @@ -17439,7 +17441,11 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - var v5 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 recur_loop_1746: var tmp6 any @@ -17542,7 +17548,11 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - var v5 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 recur_loop_1738: var tmp6 any @@ -17645,7 +17655,11 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - var v5 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 recur_loop_1742: var tmp6 any @@ -17748,7 +17762,11 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - var v5 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 recur_loop_1690: var tmp6 any @@ -17851,7 +17869,11 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - var v5 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 recur_loop_1734: var tmp6 any @@ -17980,7 +18002,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -18097,7 +18123,11 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - var v6 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) tmp8 := checkDerefVar(var_glojure_DOT_core__PLUS_) @@ -18200,7 +18230,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -18317,7 +18351,11 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - var v6 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) tmp8 := checkDerefVar(var_glojure_DOT_core__PLUS__TICK_) @@ -18420,7 +18458,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -18536,7 +18578,11 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - var v6 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) tmp8 := checkDerefVar(var_glojure_DOT_core__SLASH_) @@ -18639,7 +18685,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -18756,7 +18806,11 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - var v6 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) tmp8 := checkDerefVar(var_glojure_DOT_core__STAR_) @@ -18859,7 +18913,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -18976,7 +19034,11 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - var v6 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) tmp8 := checkDerefVar(var_glojure_DOT_core__STAR__TICK_) @@ -19253,7 +19315,11 @@ func LoadNS() { _ = v5 v6 := args[4] _ = v6 - var v7 any = lang.NewList(args[5:]...) + restArgs := args[5:] + var v7 any + if len(restArgs) > 0 { + v7 = lang.NewList(restArgs...) + } _ = v7 tmp8 := checkDerefVar(var_glojure_DOT_core_cons) tmp9 := checkDerefVar(var_glojure_DOT_core_cons) @@ -19409,7 +19475,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 tmp3 := checkDerefVar(var_glojure_DOT_core_into_DASH_array) tmp4 := lang.Apply(tmp3, []any{v2}) @@ -19593,7 +19663,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_seq) tmp6 := checkDerefVar(var_glojure_DOT_core_concat) @@ -20164,7 +20238,11 @@ func LoadNS() { _ = v8 v9 := args[2] _ = v9 - var v10 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v10 any + if len(restArgs) > 0 { + v10 = lang.NewList(restArgs...) + } _ = v10 tmp11 := lang.Apply(lang.ResetThreadBindingFrame, []any{v5}) _ = tmp11 @@ -20275,7 +20353,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -20385,7 +20467,11 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - var v6 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) tmp8 := checkDerefVar(var_glojure_DOT_core_bit_DASH_and) @@ -20488,7 +20574,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -20598,7 +20688,11 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - var v6 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) tmp8 := checkDerefVar(var_glojure_DOT_core_bit_DASH_and_DASH_not) @@ -20752,7 +20846,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -20862,7 +20960,11 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - var v6 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) tmp8 := checkDerefVar(var_glojure_DOT_core_bit_DASH_or) @@ -21079,7 +21181,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -21189,7 +21295,11 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - var v6 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) tmp8 := checkDerefVar(var_glojure_DOT_core_bit_DASH_xor) @@ -21265,7 +21375,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v3 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) tmp5 := checkDerefVar(var_glojure_DOT_core_concat) @@ -21385,7 +21499,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_seq) tmp6 := checkDerefVar(var_glojure_DOT_core_concat) @@ -21418,7 +21536,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 tmp3 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) var tmp4 lang.FnFunc @@ -21649,7 +21771,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v3 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) tmp5 := checkDerefVar(var_glojure_DOT_core_concat) @@ -21863,7 +21989,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v3 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) tmp5 := checkDerefVar(var_glojure_DOT_core_concat) @@ -22028,7 +22158,11 @@ func LoadNS() { _ = v6 v7 := args[2] _ = v7 - var v8 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v8 any + if len(restArgs) > 0 { + v8 = lang.NewList(restArgs...) + } _ = v8 tmp9 := checkDerefVar(var_glojure_DOT_core_apply) tmp10 := lang.Apply(tmp9, []any{v3, v5, v6, v7, v8}) @@ -22048,7 +22182,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_reduce1) tmp6 := checkDerefVar(var_glojure_DOT_core_comp) @@ -22149,7 +22287,11 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - var v6 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_not) tmp8 := checkDerefVar(var_glojure_DOT_core_apply) @@ -22410,7 +22552,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -22540,7 +22686,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -22828,7 +22978,11 @@ func LoadNS() { _ = v4 v5 := args[2] _ = v5 - var v6 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 var tmp7 any tmp8 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) @@ -23105,7 +23259,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_list_STAR_) tmp7 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) @@ -23215,7 +23373,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_list) tmp6 := checkDerefVar(var_glojure_DOT_core_list_STAR_) @@ -23750,7 +23912,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) @@ -24388,7 +24554,11 @@ func LoadNS() { _ = v6 v7 := args[2] _ = v7 - var v8 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v8 any + if len(restArgs) > 0 { + v8 = lang.NewList(restArgs...) + } _ = v8 tmp9 := checkDerefVar(var_glojure_DOT_core_boolean) var tmp10 any @@ -24593,7 +24763,11 @@ func LoadNS() { _ = v7 v8 := args[2] _ = v8 - var v9 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v9 any + if len(restArgs) > 0 { + v9 = lang.NewList(restArgs...) + } _ = v9 tmp10 := checkDerefVar(var_glojure_DOT_core_boolean) var tmp11 any @@ -24911,7 +25085,11 @@ func LoadNS() { _ = v8 v9 := args[2] _ = v9 - var v10 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v10 any + if len(restArgs) > 0 { + v10 = lang.NewList(restArgs...) + } _ = v10 tmp11 := checkDerefVar(var_glojure_DOT_core_boolean) var tmp12 any @@ -24992,7 +25170,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -25121,7 +25303,11 @@ func LoadNS() { _ = v13 v14 := args[2] _ = v14 - var v15 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v15 any + if len(restArgs) > 0 { + v15 = lang.NewList(restArgs...) + } _ = v15 tmp16 := checkDerefVar(var_glojure_DOT_core_boolean) var tmp17 any @@ -25495,7 +25681,11 @@ func LoadNS() { _ = v6 v7 := args[2] _ = v7 - var v8 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v8 any + if len(restArgs) > 0 { + v8 = lang.NewList(restArgs...) + } _ = v8 tmp9 := checkDerefVar(var_glojure_DOT_core_apply) var tmp10 any @@ -25582,7 +25772,11 @@ func LoadNS() { _ = v7 v8 := args[2] _ = v8 - var v9 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v9 any + if len(restArgs) > 0 { + v9 = lang.NewList(restArgs...) + } _ = v9 tmp10 := checkDerefVar(var_glojure_DOT_core_apply) var tmp11 any @@ -25687,7 +25881,11 @@ func LoadNS() { _ = v8 v9 := args[2] _ = v9 - var v10 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v10 any + if len(restArgs) > 0 { + v10 = lang.NewList(restArgs...) + } _ = v10 tmp11 := checkDerefVar(var_glojure_DOT_core_apply) var tmp12 any @@ -25745,7 +25943,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_apply) tmp5 := lang.Apply(tmp4, []any{fmt.Sprintf, v2, v3}) @@ -25770,7 +25972,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_seq) tmp6 := checkDerefVar(var_glojure_DOT_core_concat) @@ -25971,7 +26177,11 @@ func LoadNS() { _ = v5 v6 := args[4] _ = v6 - var v7 any = lang.NewList(args[5:]...) + restArgs := args[5:] + var v7 any + if len(restArgs) > 0 { + v7 = lang.NewList(restArgs...) + } _ = v7 var tmp8 any tmp9 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) @@ -26141,7 +26351,11 @@ func LoadNS() { _ = v5 v6 := args[4] _ = v6 - var v7 any = lang.NewList(args[5:]...) + restArgs := args[5:] + var v7 any + if len(restArgs) > 0 { + v7 = lang.NewList(restArgs...) + } _ = v7 var tmp8 any tmp9 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) @@ -26384,7 +26598,11 @@ func LoadNS() { _ = v5 v6 := args[2] _ = v6 - var v7 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v7 any + if len(restArgs) > 0 { + v7 = lang.NewList(restArgs...) + } _ = v7 tmp8 := checkDerefVar(var_glojure_DOT_core_apply) tmp9 := lang.Apply(tmp8, []any{v2, v4, v5, v6, v7}) @@ -26471,7 +26689,11 @@ func LoadNS() { _ = v6 v7 := args[2] _ = v7 - var v8 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v8 any + if len(restArgs) > 0 { + v8 = lang.NewList(restArgs...) + } _ = v8 tmp9 := checkDerefVar(var_glojure_DOT_core_apply) tmp10 := lang.Apply(tmp9, []any{v2, v5, v6, v7, v8}) @@ -26566,7 +26788,11 @@ func LoadNS() { _ = v7 v8 := args[2] _ = v8 - var v9 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v9 any + if len(restArgs) > 0 { + v9 = lang.NewList(restArgs...) + } _ = v9 tmp10 := checkDerefVar(var_glojure_DOT_core_apply) tmp11 := lang.Apply(tmp10, []any{v2, v6, v7, v8, v9}) @@ -26597,7 +26823,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -26737,7 +26967,11 @@ func LoadNS() { _ = v12 v13 := args[2] _ = v13 - var v14 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v14 any + if len(restArgs) > 0 { + v14 = lang.NewList(restArgs...) + } _ = v14 tmp15 := checkDerefVar(var_glojure_DOT_core_reduce1) var tmp16 lang.FnFunc @@ -27011,6 +27245,291 @@ func LoadNS() { var_glojure_DOT_core_keep.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } + // keep-indexed + { + tmp0 := sym_keep_DASH_indexed.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_coll)), kw_doc, "Returns a lazy sequence of the non-nil results of (f index item). Note,\n this means false return values will be included. f must be free of\n side-effects. Returns a stateful transducer when no collection is\n provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(7372), kw_end_DASH_line, int(7372))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 any + { // let + // let binding "iv" + tmp6 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) + tmp7 := lang.Apply(tmp6, []any{int64(-1)}) + var v8 any = tmp7 + _ = v8 + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp10 := lang.Apply(v4, nil) + return tmp10 + case 1: + v10 := args[0] + _ = v10 + tmp11 := lang.Apply(v4, []any{v10}) + return tmp11 + case 2: + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + var tmp12 any + { // let + // let binding "i" + tmp13 := checkDerefVar(var_glojure_DOT_core_inc) + tmp14, ok := lang.FieldOrMethod(v8, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "Deref"))) + } + var tmp15 any + switch reflect.TypeOf(tmp14).Kind() { + case reflect.Func: + tmp15 = lang.Apply(tmp14, nil) + default: + tmp15 = tmp14 + } + tmp16 := lang.Apply(tmp13, []any{tmp15}) + tmp17, _ := lang.FieldOrMethod(v8, "reset") + if reflect.TypeOf(tmp17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) + } + tmp18 := lang.Apply(tmp17, []any{tmp16}) + var v19 any = tmp18 + _ = v19 + // let binding "v" + tmp20 := lang.Apply(v2, []any{v19, v11}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + tmp23 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp24 := lang.Apply(tmp23, []any{v21}) + if lang.IsTruthy(tmp24) { + tmp22 = v10 + } else { + tmp25 := lang.Apply(v4, []any{v10, v21}) + tmp22 = tmp25 + } + tmp12 = tmp22 + } // end let + return tmp12 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7382), kw_column, int(8), kw_end_DASH_line, int(7390), kw_end_DASH_column, int(33)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp5 = tmp11 + } // end let + return tmp5 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7380), kw_column, int(4), kw_end_DASH_line, int(7390), kw_end_DASH_column, int(35)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // letfn + // letfn binding "keepi" + var v5 lang.FnFunc + var tmp6 lang.FnFunc + { // function keepi + var v7 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp11 any + { // let + // let binding "temp__0__auto__" + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := lang.Apply(tmp12, []any{v9}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + var tmp16 any + { // let + // let binding "s" + var v17 any = v14 + _ = v17 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp20 := lang.Apply(tmp19, []any{v17}) + if lang.IsTruthy(tmp20) { + var tmp21 any + { // let + // let binding "c" + tmp22 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp23 := lang.Apply(tmp22, []any{v17}) + var v24 any = tmp23 + _ = v24 + // let binding "size" + tmp25 := checkDerefVar(var_glojure_DOT_core_count) + tmp26 := lang.Apply(tmp25, []any{v24}) + var v27 any = tmp26 + _ = v27 + // let binding "b" + tmp28 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_buffer) + tmp29 := lang.Apply(tmp28, []any{v27}) + var v30 any = tmp29 + _ = v30 + var tmp31 any + { // let + // let binding "n__0__auto__" + tmp32 := checkDerefVar(var_glojure_DOT_core_long) + tmp33 := lang.Apply(tmp32, []any{v27}) + var v34 any = tmp33 + _ = v34 + var tmp35 any + { // let + // let binding "i" + var v36 any = int64(0) + _ = v36 + for { + var tmp37 any + tmp38 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp39 := lang.Apply(tmp38, []any{v36, v34}) + if lang.IsTruthy(tmp39) { + var tmp40 any + { // let + // let binding "x" + tmp41 := checkDerefVar(var_glojure_DOT_core__PLUS_) + tmp42 := lang.Apply(tmp41, []any{v8, v36}) + tmp43, _ := lang.FieldOrMethod(v24, "nth") + if reflect.TypeOf(tmp43).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp44 := lang.Apply(tmp43, []any{v36}) + tmp45 := lang.Apply(v2, []any{tmp42, tmp44}) + var v46 any = tmp45 + _ = v46 + var tmp47 any + tmp48 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp49 := lang.Apply(tmp48, []any{v46}) + if lang.IsTruthy(tmp49) { + } else { + tmp50 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_append) + tmp51 := lang.Apply(tmp50, []any{v30, v46}) + tmp47 = tmp51 + } + tmp40 = tmp47 + } // end let + _ = tmp40 + tmp42 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp43 := lang.Apply(tmp42, []any{v36}) + var tmp41 any = tmp43 + v36 = tmp41 + continue + } else { + } + tmp35 = tmp37 + break + } + } // end let + tmp31 = tmp35 + } // end let + _ = tmp31 + tmp32 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_cons) + tmp33 := checkDerefVar(var_glojure_DOT_core_chunk) + tmp34 := lang.Apply(tmp33, []any{v30}) + tmp35 := checkDerefVar(var_glojure_DOT_core__PLUS_) + tmp36 := lang.Apply(tmp35, []any{v8, v27}) + tmp37 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp38 := lang.Apply(tmp37, []any{v17}) + tmp39 := lang.Apply(v7, []any{tmp36, tmp38}) + tmp40 := lang.Apply(tmp32, []any{tmp34, tmp39}) + tmp21 = tmp40 + } // end let + tmp18 = tmp21 + } else { + var tmp22 any + { // let + // let binding "x" + tmp23 := checkDerefVar(var_glojure_DOT_core_first) + tmp24 := lang.Apply(tmp23, []any{v17}) + tmp25 := lang.Apply(v2, []any{v8, tmp24}) + var v26 any = tmp25 + _ = v26 + var tmp27 any + tmp28 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp29 := lang.Apply(tmp28, []any{v26}) + if lang.IsTruthy(tmp29) { + tmp30 := checkDerefVar(var_glojure_DOT_core_inc) + tmp31 := lang.Apply(tmp30, []any{v8}) + tmp32 := checkDerefVar(var_glojure_DOT_core_rest) + tmp33 := lang.Apply(tmp32, []any{v17}) + tmp34 := lang.Apply(v7, []any{tmp31, tmp33}) + tmp27 = tmp34 + } else { + tmp35 := checkDerefVar(var_glojure_DOT_core_cons) + tmp36 := checkDerefVar(var_glojure_DOT_core_inc) + tmp37 := lang.Apply(tmp36, []any{v8}) + tmp38 := checkDerefVar(var_glojure_DOT_core_rest) + tmp39 := lang.Apply(tmp38, []any{v17}) + tmp40 := lang.Apply(v7, []any{tmp37, tmp39}) + tmp41 := lang.Apply(tmp35, []any{v26, tmp40}) + tmp27 = tmp41 + } + tmp22 = tmp27 + } // end let + tmp18 = tmp22 + } + tmp16 = tmp18 + } // end let + tmp15 = tmp16 + } else { + } + tmp11 = tmp15 + } // end let + return tmp11 + }) + tmp11 := lang.Apply(lang.NewLazySeq, []any{tmp10}) + return tmp11 + }) + v7 = tmp6 + _ = v7 + } + v5 = tmp6 + _ = v5 + tmp7 := lang.Apply(v5, []any{int64(0), v3}) + tmp4 = tmp7 + } // end letfn + return tmp4 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_keep_DASH_indexed = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_keep_DASH_indexed.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } // lazy-seq { tmp0 := sym_lazy_DASH_seq.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_body)), kw_doc, "Takes a body of expressions that returns an ISeq or nil, and yields\n a Seqable object that will invoke the body only the first time seq\n is called, and will cache the result and return it on all subsequent\n seq calls. See also - realized?", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(11), kw_line, int(676), kw_end_DASH_line, int(676))).(*lang.Symbol) @@ -27023,7 +27542,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_list) tmp6 := checkDerefVar(var_glojure_DOT_core_list_STAR_) @@ -27058,7 +27581,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_seq) tmp7 := checkDerefVar(var_glojure_DOT_core_concat) @@ -27192,7 +27719,11 @@ func LoadNS() { _ = v6 v7 := args[1] _ = v7 - var v8 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v8 any + if len(restArgs) > 0 { + v8 = lang.NewList(restArgs...) + } _ = v8 tmp9 := checkDerefVar(var_glojure_DOT_core_apply) tmp10 := lang.Apply(tmp9, []any{v2, v7, v8}) @@ -27483,7 +28014,11 @@ func LoadNS() { _ = v4 v5 := args[3] _ = v5 - var v6 any = lang.NewList(args[4:]...) + restArgs := args[4:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 var tmp7 any { // let @@ -27570,6 +28105,241 @@ func LoadNS() { var_glojure_DOT_core_map.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } + // map-indexed + { + tmp0 := sym_map_DASH_indexed.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_coll)), kw_doc, "Returns a lazy sequence consisting of the result of applying f to 0\n and the first item of coll, followed by applying f to 1 and the second\n item in coll, etc, until coll is exhausted. Thus function f should\n accept 2 arguments, index and item. Returns a stateful transducer when\n no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(7309), kw_end_DASH_line, int(7309))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 any + { // let + // let binding "i" + tmp6 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) + tmp7 := lang.Apply(tmp6, []any{int64(-1)}) + var v8 any = tmp7 + _ = v8 + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp10 := lang.Apply(v4, nil) + return tmp10 + case 1: + v10 := args[0] + _ = v10 + tmp11 := lang.Apply(v4, []any{v10}) + return tmp11 + case 2: + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_inc) + tmp13, ok := lang.FieldOrMethod(v8, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "Deref"))) + } + var tmp14 any + switch reflect.TypeOf(tmp13).Kind() { + case reflect.Func: + tmp14 = lang.Apply(tmp13, nil) + default: + tmp14 = tmp13 + } + tmp15 := lang.Apply(tmp12, []any{tmp14}) + tmp16, _ := lang.FieldOrMethod(v8, "reset") + if reflect.TypeOf(tmp16).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) + } + tmp17 := lang.Apply(tmp16, []any{tmp15}) + tmp18 := lang.Apply(v2, []any{tmp17, v11}) + tmp19 := lang.Apply(v4, []any{v10, tmp18}) + return tmp19 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7320), kw_column, int(8), kw_end_DASH_line, int(7324), kw_end_DASH_column, int(48)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp5 = tmp11 + } // end let + return tmp5 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7318), kw_column, int(4), kw_end_DASH_line, int(7324), kw_end_DASH_column, int(50)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // letfn + // letfn binding "mapi" + var v5 lang.FnFunc + var tmp6 lang.FnFunc + { // function mapi + var v7 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp11 any + { // let + // let binding "temp__0__auto__" + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := lang.Apply(tmp12, []any{v9}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + var tmp16 any + { // let + // let binding "s" + var v17 any = v14 + _ = v17 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp20 := lang.Apply(tmp19, []any{v17}) + if lang.IsTruthy(tmp20) { + var tmp21 any + { // let + // let binding "c" + tmp22 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp23 := lang.Apply(tmp22, []any{v17}) + var v24 any = tmp23 + _ = v24 + // let binding "size" + tmp25 := checkDerefVar(var_glojure_DOT_core_int) + tmp26 := checkDerefVar(var_glojure_DOT_core_count) + tmp27 := lang.Apply(tmp26, []any{v24}) + tmp28 := lang.Apply(tmp25, []any{tmp27}) + var v29 any = tmp28 + _ = v29 + // let binding "b" + tmp30 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_buffer) + tmp31 := lang.Apply(tmp30, []any{v29}) + var v32 any = tmp31 + _ = v32 + var tmp33 any + { // let + // let binding "n__0__auto__" + tmp34 := checkDerefVar(var_glojure_DOT_core_long) + tmp35 := lang.Apply(tmp34, []any{v29}) + var v36 any = tmp35 + _ = v36 + var tmp37 any + { // let + // let binding "i" + var v38 any = int64(0) + _ = v38 + for { + var tmp39 any + tmp40 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp41 := lang.Apply(tmp40, []any{v38, v36}) + if lang.IsTruthy(tmp41) { + tmp42 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_append) + tmp43 := checkDerefVar(var_glojure_DOT_core__PLUS_) + tmp44 := lang.Apply(tmp43, []any{v8, v38}) + tmp45, _ := lang.FieldOrMethod(v24, "nth") + if reflect.TypeOf(tmp45).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp46 := lang.Apply(tmp45, []any{v38}) + tmp47 := lang.Apply(v2, []any{tmp44, tmp46}) + tmp48 := lang.Apply(tmp42, []any{v32, tmp47}) + _ = tmp48 + tmp50 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp51 := lang.Apply(tmp50, []any{v38}) + var tmp49 any = tmp51 + v38 = tmp49 + continue + } else { + } + tmp37 = tmp39 + break + } + } // end let + tmp33 = tmp37 + } // end let + _ = tmp33 + tmp34 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_cons) + tmp35 := checkDerefVar(var_glojure_DOT_core_chunk) + tmp36 := lang.Apply(tmp35, []any{v32}) + tmp37 := checkDerefVar(var_glojure_DOT_core__PLUS_) + tmp38 := lang.Apply(tmp37, []any{v8, v29}) + tmp39 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp40 := lang.Apply(tmp39, []any{v17}) + tmp41 := lang.Apply(v7, []any{tmp38, tmp40}) + tmp42 := lang.Apply(tmp34, []any{tmp36, tmp41}) + tmp21 = tmp42 + } // end let + tmp18 = tmp21 + } else { + tmp22 := checkDerefVar(var_glojure_DOT_core_cons) + tmp23 := checkDerefVar(var_glojure_DOT_core_first) + tmp24 := lang.Apply(tmp23, []any{v17}) + tmp25 := lang.Apply(v2, []any{v8, tmp24}) + tmp26 := checkDerefVar(var_glojure_DOT_core_inc) + tmp27 := lang.Apply(tmp26, []any{v8}) + tmp28 := checkDerefVar(var_glojure_DOT_core_rest) + tmp29 := lang.Apply(tmp28, []any{v17}) + tmp30 := lang.Apply(v7, []any{tmp27, tmp29}) + tmp31 := lang.Apply(tmp22, []any{tmp25, tmp30}) + tmp18 = tmp31 + } + tmp16 = tmp18 + } // end let + tmp15 = tmp16 + } else { + } + tmp11 = tmp15 + } // end let + return tmp11 + }) + tmp11 := lang.Apply(lang.NewLazySeq, []any{tmp10}) + return tmp11 + }) + v7 = tmp6 + _ = v7 + } + v5 = tmp6 + _ = v5 + tmp7 := lang.Apply(v5, []any{int64(0), v3}) + tmp4 = tmp7 + } // end letfn + return tmp4 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_map_DASH_indexed = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_map_DASH_indexed.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } // max { var tmp1 lang.FnFunc @@ -27657,7 +28427,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -27771,7 +28545,11 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - var v6 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) tmp8 := checkDerefVar(var_glojure_DOT_core_max) @@ -27825,7 +28603,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -27954,7 +28736,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -28021,7 +28807,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 var tmp3 any tmp4 := checkDerefVar(var_glojure_DOT_core_some) @@ -28087,7 +28877,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 var tmp4 any tmp5 := checkDerefVar(var_glojure_DOT_core_some) @@ -28285,7 +29079,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -28399,7 +29197,11 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - var v6 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) tmp8 := checkDerefVar(var_glojure_DOT_core_min) @@ -28453,7 +29255,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -28726,7 +29532,11 @@ func LoadNS() { _ = v5 v6 := args[1] _ = v6 - var v7 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v7 any + if len(restArgs) > 0 { + v7 = lang.NewList(restArgs...) + } _ = v7 var tmp8 any { // let @@ -28929,7 +29739,11 @@ func LoadNS() { _ = v4 v5 := args[2] _ = v5 - var v6 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_apply) tmp8 := lang.Apply(tmp7, []any{closed17, v3, v4, v5, v6}) @@ -28986,7 +29800,11 @@ func LoadNS() { _ = v4 v5 := args[2] _ = v5 - var v6 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_apply) tmp8 := lang.Apply(tmp7, []any{closed18, v3, v4, v5, v6}) @@ -29027,7 +29845,11 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - var v5 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_not) tmp7 := checkDerefVar(var_glojure_DOT_core_apply) @@ -29546,7 +30368,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_seq) tmp7 := checkDerefVar(var_glojure_DOT_core_concat) @@ -29830,7 +30656,11 @@ func LoadNS() { _ = v6 v7 := args[2] _ = v7 - var v8 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v8 any + if len(restArgs) > 0 { + v8 = lang.NewList(restArgs...) + } _ = v8 tmp9 := checkDerefVar(var_glojure_DOT_core_apply) tmp10 := lang.Apply(tmp9, []any{v2, v3, v5, v6, v7, v8}) @@ -29885,7 +30715,11 @@ func LoadNS() { _ = v7 v8 := args[2] _ = v8 - var v9 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v9 any + if len(restArgs) > 0 { + v9 = lang.NewList(restArgs...) + } _ = v9 tmp10 := checkDerefVar(var_glojure_DOT_core_apply) tmp11 := lang.Apply(tmp10, []any{v2, v3, v4, v6, v7, v8, v9}) @@ -29942,7 +30776,11 @@ func LoadNS() { _ = v8 v9 := args[2] _ = v9 - var v10 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v10 any + if len(restArgs) > 0 { + v10 = lang.NewList(restArgs...) + } _ = v10 tmp11 := checkDerefVar(var_glojure_DOT_core_apply) tmp12 := lang.Apply(tmp11, []any{v2, v3, v4, v5, v7, v8, v9, v10}) @@ -29965,14 +30803,22 @@ func LoadNS() { _ = v4 v5 := args[3] _ = v5 - var v6 any = lang.NewList(args[4:]...) + restArgs := args[4:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 var tmp7 lang.FnFunc tmp7 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: checkArityGTE(args, 0) - var v8 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v8 any + if len(restArgs) > 0 { + v8 = lang.NewList(restArgs...) + } _ = v8 tmp9 := checkDerefVar(var_glojure_DOT_core_apply) tmp10 := checkDerefVar(var_glojure_DOT_core_concat) @@ -30456,7 +31302,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -30999,7 +31849,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_seq) tmp6 := checkDerefVar(var_glojure_DOT_core_concat) @@ -31509,7 +32363,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 var tmp4 any { // let @@ -32066,7 +32924,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -32297,7 +33159,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -32395,7 +33261,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -32636,7 +33506,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -32946,7 +33820,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_seq) tmp7 := checkDerefVar(var_glojure_DOT_core_concat) @@ -33372,7 +34250,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any if lang.IsTruthy(v2) { @@ -33639,7 +34521,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_trampoline) var tmp5 lang.FnFunc @@ -33748,7 +34634,11 @@ func LoadNS() { _ = v6 v7 := args[5] _ = v7 - var v8 any = lang.NewList(args[6:]...) + restArgs := args[6:] + var v8 any + if len(restArgs) > 0 { + v8 = lang.NewList(restArgs...) + } _ = v8 tmp9 := checkDerefVar(var_glojure_DOT_core_assoc) tmp10 := checkDerefVar(var_glojure_DOT_core_apply) @@ -33779,7 +34669,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -33878,7 +34772,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) tmp6 := checkDerefVar(var_glojure_DOT_core_apply) @@ -33909,7 +34807,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) @@ -34043,7 +34945,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) @@ -34166,7 +35072,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) @@ -34299,7 +35209,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_seq) tmp7 := checkDerefVar(var_glojure_DOT_core_concat) @@ -34357,7 +35271,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_seq) tmp7 := checkDerefVar(var_glojure_DOT_core_concat) @@ -34405,7 +35323,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) tmp6 := lang.Apply(tmp5, []any{v2}) @@ -34444,7 +35366,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_seq) tmp7 := checkDerefVar(var_glojure_DOT_core_concat) @@ -34525,7 +35451,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_seq) tmp6 := checkDerefVar(var_glojure_DOT_core_concat) @@ -34614,7 +35544,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) @@ -34755,7 +35689,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_seq) tmp6 := checkDerefVar(var_glojure_DOT_core_concat) @@ -34838,7 +35776,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -34951,7 +35893,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_seq) tmp7 := checkDerefVar(var_glojure_DOT_core_concat) @@ -35336,7 +36282,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -35452,7 +36402,11 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - var v6 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) tmp8 := checkDerefVar(var_glojure_DOT_core__DASH_) @@ -35555,7 +36509,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -35671,7 +36629,11 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - var v6 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) tmp8 := checkDerefVar(var_glojure_DOT_core__DASH__TICK_) @@ -35697,7 +36659,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 var tmp4 any { // let @@ -35826,7 +36792,11 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - var v5 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_apply) tmp7 := checkDerefVar(var_glojure_DOT_core_aget) @@ -36105,7 +37075,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_seq) tmp7 := checkDerefVar(var_glojure_DOT_core_concat) @@ -36176,7 +37150,11 @@ func LoadNS() { return tmp3 default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 var tmp3 any { // let @@ -36282,7 +37260,11 @@ func LoadNS() { _ = v4 v5 := args[2] _ = v5 - var v6 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_apply) tmp8 := checkDerefVar(var_glojure_DOT_core_aset) @@ -36328,7 +37310,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_apply) tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_boolean) @@ -36374,7 +37360,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_apply) tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_byte) @@ -36420,7 +37410,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_apply) tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_char) @@ -36466,7 +37460,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_apply) tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_double) @@ -36512,7 +37510,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_apply) tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_float) @@ -36558,7 +37560,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_apply) tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_int) @@ -36604,7 +37610,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_apply) tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_long) @@ -36650,7 +37660,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_apply) tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_short) @@ -36681,7 +37695,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_setup_DASH_reference) tmp5 := checkDerefVar(var_glojure_DOT_core_atom) @@ -36710,7 +37728,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) @@ -36905,7 +37927,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v8 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v8 any + if len(restArgs) > 0 { + v8 = lang.NewList(restArgs...) + } _ = v8 tmp9 := checkDerefVar(var_glojure_DOT_core_apply) tmp10 := checkDerefVar(var_glojure_DOT_core_with_DASH_bindings_STAR_) @@ -36973,7 +37999,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 var tmp4 any tmp5 := checkDerefVar(var_glojure_DOT_core_seq) @@ -37064,7 +38094,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_seq) tmp6 := checkDerefVar(var_glojure_DOT_core_concat) @@ -37210,7 +38244,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -37481,7 +38519,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -37806,7 +38848,11 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - var v5 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any tmp7 := checkDerefVar(var_glojure_DOT_core_not_EQ_) @@ -37983,7 +39029,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) @@ -38619,7 +39669,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -39032,7 +40086,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_emit_DASH_extend_DASH_protocol) tmp7 := lang.Apply(tmp6, []any{v4, v5}) @@ -39088,7 +40146,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -39459,7 +40521,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -39688,7 +40754,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 lang.FnFunc tmp5 = lang.NewFnFunc(func(args ...any) any { @@ -40117,7 +41187,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_seq) tmp6 := checkDerefVar(var_glojure_DOT_core_concat) @@ -40164,7 +41238,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_seq) tmp7 := checkDerefVar(var_glojure_DOT_core_concat) @@ -40461,7 +41539,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -40915,7 +41997,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v11 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v11 any + if len(restArgs) > 0 { + v11 = lang.NewList(restArgs...) + } _ = v11 var tmp12 any { // let @@ -40988,7 +42074,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -41882,7 +42972,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 tmp3 := checkDerefVar(var_glojure_DOT_core_pmap) var tmp4 lang.FnFunc @@ -42298,7 +43392,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 var tmp4 any { // let @@ -42618,7 +43716,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_apply) tmp6 := checkDerefVar(var_glojure_DOT_core_send_DASH_via) @@ -42644,7 +43746,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_apply) tmp6 := checkDerefVar(var_glojure_DOT_core_send_DASH_via) @@ -43005,7 +44111,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -43123,7 +44233,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -43341,7 +44455,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) @@ -43806,7 +44924,11 @@ func LoadNS() { _ = v4 v5 := args[3] _ = v5 - var v6 any = lang.NewList(args[4:]...) + restArgs := args[4:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_seq) tmp8 := checkDerefVar(var_glojure_DOT_core_concat) @@ -43862,7 +44984,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 var tmp3 any tmp4 := lang.Apply(nil, nil) @@ -44099,7 +45225,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 var tmp4 any tmp5 := lang.Apply(nil, nil) @@ -44390,7 +45520,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -44519,7 +45653,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -44650,7 +45788,11 @@ func LoadNS() { _ = v4 v5 := args[3] _ = v5 - var v6 any = lang.NewList(args[4:]...) + restArgs := args[4:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 var tmp7 any { // let @@ -45682,7 +46824,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 var tmp4 any { // let @@ -45778,7 +46924,11 @@ func LoadNS() { checkArityGTE(args, 1) v52 := args[0] _ = v52 - var v53 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v53 any + if len(restArgs) > 0 { + v53 = lang.NewList(restArgs...) + } _ = v53 tmp54 := checkDerefVar(var_glojure_DOT_core_apply) tmp55 := checkDerefVar(var_glojure_DOT_core_cons) @@ -45930,7 +47080,11 @@ func LoadNS() { checkArityGTE(args, 1) v64 := args[0] _ = v64 - var v65 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v65 any + if len(restArgs) > 0 { + v65 = lang.NewList(restArgs...) + } _ = v65 tmp66 := checkDerefVar(var_glojure_DOT_core_apply) tmp67 := checkDerefVar(var_glojure_DOT_core_cons) @@ -46135,7 +47289,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v38 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v38 any + if len(restArgs) > 0 { + v38 = lang.NewList(restArgs...) + } _ = v38 tmp39 := checkDerefVar(var_glojure_DOT_core_apply) tmp40 := checkDerefVar(var_glojure_DOT_core_str) @@ -47215,7 +48373,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) @@ -47286,7 +48448,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) @@ -47555,7 +48721,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -48095,7 +49265,7 @@ func LoadNS() { } // cat { - tmp0 := sym_cat.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_rf)), kw_doc, "A transducer which concatenates the contents of each input, which must be a\n collection, into the reduction.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(7645), kw_end_DASH_line, int(7645))).(*lang.Symbol) + tmp0 := sym_cat.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2773), kw_column, int(10), kw_end_DASH_line, int(2773), kw_end_DASH_column, int(12), kw_declared, true, kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp1 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) @@ -48166,7 +49336,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_apply) tmp5 := checkDerefVar(var_glojure_DOT_core_concat) @@ -48854,7 +50028,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_emit_DASH_extend_DASH_type) tmp7 := lang.Apply(tmp6, []any{v4, v5}) @@ -48923,7 +50101,7 @@ func LoadNS() { } // flatten { - tmp0 := sym_flatten.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Takes any nested combination of sequential things (lists, vectors,\n etc.) and returns their contents as a single, flat lazy sequence.\n (flatten nil) returns an empty sequence.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(7118), kw_end_DASH_line, int(7118))).(*lang.Symbol) + tmp0 := sym_flatten.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5641), kw_column, int(10), kw_end_DASH_line, int(5641), kw_end_DASH_column, int(16), kw_declared, true, kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp1 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) @@ -49925,7 +51103,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 var tmp4 any { // let @@ -50149,7 +51331,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 var tmp3 any { // let @@ -50873,7 +52059,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_throw_DASH_if) var tmp6 any @@ -51428,7 +52618,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 var tmp3 any { // let @@ -51997,7 +53191,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 tmp3 := checkDerefVar(var_glojure_DOT_core_apply) tmp4 := checkDerefVar(var_glojure_DOT_core_load_DASH_libs) @@ -52019,7 +53217,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 var tmp3 any { // let @@ -52069,7 +53271,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 tmp3 := checkDerefVar(var_glojure_DOT_core_apply) tmp4 := checkDerefVar(var_glojure_DOT_core_load_DASH_libs) @@ -52223,7 +53429,11 @@ func LoadNS() { _ = v4 v5 := args[3] _ = v5 - var v6 any = lang.NewList(args[4:]...) + restArgs := args[4:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_into) tmp8 := lang.NewVector() @@ -52319,7 +53529,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 recur_loop_2211: tmp4 := checkDerefVar(var_glojure_DOT_core_pr) @@ -52378,7 +53592,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v3 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 var tmp4 any { // let @@ -52431,7 +53649,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 var tmp3 any { // let @@ -52473,7 +53695,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v3 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 var tmp4 any { // let @@ -52528,7 +53754,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_print) tmp5 := checkDerefVar(var_glojure_DOT_core_apply) @@ -52552,7 +53782,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 tmp3 := checkDerefVar(var_glojure_DOT_core_apply) tmp4 := checkDerefVar(var_glojure_DOT_core_pr) @@ -52587,7 +53821,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v3 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 var tmp4 any { // let @@ -52640,7 +53878,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 var tmp3 any { // let @@ -52682,7 +53924,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v3 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 var tmp4 any { // let @@ -55571,7 +56817,11 @@ func LoadNS() { checkArityGTE(args, 1) v3 := args[0] _ = v3 - var v4 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let diff --git a/pkg/stdlib/glojure/core_print/loader.go b/pkg/stdlib/glojure/core_print/loader.go index 14b05e33..4d309b1d 100644 --- a/pkg/stdlib/glojure/core_print/loader.go +++ b/pkg/stdlib/glojure/core_print/loader.go @@ -118,6 +118,8 @@ func LoadNS() { sym_SetMacro := lang.NewSymbol("SetMacro") sym_StackTraceElement_DASH__GT_vec := lang.NewSymbol("StackTraceElement->vec") sym_Throwable_DASH__GT_map := lang.NewSymbol("Throwable->map") + sym_UncheckedAdd := lang.NewSymbol("UncheckedAdd") + sym_UncheckedDec := lang.NewSymbol("UncheckedDec") sym_a := lang.NewSymbol("a") sym_a__0__auto__ := lang.NewSymbol("a__0__auto__") sym_abs := lang.NewSymbol("abs") @@ -497,11 +499,14 @@ func LoadNS() { sym_glojure_DOT_core_SLASH_Nth := lang.NewSymbol("glojure.core/Nth") sym_glojure_DOT_core_SLASH_Object_array := lang.NewSymbol("glojure.core/Object_array") sym_glojure_DOT_core_SLASH_RunInTransaction := lang.NewSymbol("glojure.core/RunInTransaction") + sym_glojure_DOT_core_SLASH_UncheckedAdd := lang.NewSymbol("glojure.core/UncheckedAdd") sym_glojure_DOT_core_SLASH_UncheckedByteCast := lang.NewSymbol("glojure.core/UncheckedByteCast") sym_glojure_DOT_core_SLASH_UncheckedCharCast := lang.NewSymbol("glojure.core/UncheckedCharCast") + sym_glojure_DOT_core_SLASH_UncheckedDec := lang.NewSymbol("glojure.core/UncheckedDec") sym_glojure_DOT_core_SLASH_UncheckedDoubleCast := lang.NewSymbol("glojure.core/UncheckedDoubleCast") sym_glojure_DOT_core_SLASH_UncheckedFloatCast := lang.NewSymbol("glojure.core/UncheckedFloatCast") sym_glojure_DOT_core_SLASH_UncheckedIntCast := lang.NewSymbol("glojure.core/UncheckedIntCast") + sym_glojure_DOT_core_SLASH_UncheckedIntDivide := lang.NewSymbol("glojure.core/UncheckedIntDivide") sym_glojure_DOT_core_SLASH_UncheckedLongCast := lang.NewSymbol("glojure.core/UncheckedLongCast") sym_glojure_DOT_core_SLASH_UncheckedShortCast := lang.NewSymbol("glojure.core/UncheckedShortCast") sym_glojure_DOT_core_SLASH_aclone := lang.NewSymbol("glojure.core/aclone") @@ -617,12 +622,9 @@ func LoadNS() { sym_glojure_DOT_core_SLASH_to_DASH_array := lang.NewSymbol("glojure.core/to-array") sym_glojure_DOT_core_SLASH_unchecked_DASH_inc := lang.NewSymbol("glojure.core/unchecked-inc") sym_glojure_DOT_core_SLASH_unchecked_DASH_inc_DASH_int := lang.NewSymbol("glojure.core/unchecked-inc-int") - sym_glojure_DOT_core_SLASH_unchecked_add := lang.NewSymbol("glojure.core/unchecked_add") - sym_glojure_DOT_core_SLASH_unchecked_dec := lang.NewSymbol("glojure.core/unchecked_dec") sym_glojure_DOT_core_SLASH_unchecked_inc := lang.NewSymbol("glojure.core/unchecked_inc") sym_glojure_DOT_core_SLASH_unchecked_int_add := lang.NewSymbol("glojure.core/unchecked_int_add") sym_glojure_DOT_core_SLASH_unchecked_int_dec := lang.NewSymbol("glojure.core/unchecked_int_dec") - sym_glojure_DOT_core_SLASH_unchecked_int_divide := lang.NewSymbol("glojure.core/unchecked_int_divide") sym_glojure_DOT_core_SLASH_unchecked_int_inc := lang.NewSymbol("glojure.core/unchecked_int_inc") sym_glojure_DOT_core_SLASH_unchecked_int_multiply := lang.NewSymbol("glojure.core/unchecked_int_multiply") sym_glojure_DOT_core_SLASH_unchecked_int_negate := lang.NewSymbol("glojure.core/unchecked_int_negate") @@ -1193,8 +1195,6 @@ func LoadNS() { sym_uncheckedFloatCast := lang.NewSymbol("uncheckedFloatCast") sym_uncheckedIntCast := lang.NewSymbol("uncheckedIntCast") sym_uncheckedShortCast := lang.NewSymbol("uncheckedShortCast") - sym_unchecked_add := lang.NewSymbol("unchecked_add") - sym_unchecked_dec := lang.NewSymbol("unchecked_dec") sym_unchecked_inc := lang.NewSymbol("unchecked_inc") sym_unchecked_minus := lang.NewSymbol("unchecked_minus") sym_unchecked_multiply := lang.NewSymbol("unchecked_multiply") @@ -1440,8 +1440,6 @@ func LoadNS() { var_glojure_DOT_core__STAR_assert_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_assert_STAR_) // var glojure.core/*command-line-args* var_glojure_DOT_core__STAR_command_DASH_line_DASH_args_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_command_DASH_line_DASH_args_STAR_) - // var glojure.core/*compile-files* - var_glojure_DOT_core__STAR_compile_DASH_files_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_compile_DASH_files_STAR_) // var glojure.core/*compile-path* var_glojure_DOT_core__STAR_compile_DASH_path_STAR_ := lang.InternVarName(sym_glojure_DOT_core, sym__STAR_compile_DASH_path_STAR_) // var glojure.core/*compiler-options* @@ -2913,7 +2911,7 @@ func LoadNS() { } var closed3 any { - closed3 = sym_unchecked_add + closed3 = sym_UncheckedAdd } var closed4 any { @@ -3006,27 +3004,30 @@ func LoadNS() { } // *1 { - tmp0 := sym__STAR_1.WithMeta(lang.NewMap()).(*lang.Symbol) + tmp0 := sym__STAR_1.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core.glj", kw_line, int(6268), kw_column, int(6), kw_end_DASH_line, int(6271), kw_end_DASH_column, int(3), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var_glojure_DOT_core__STAR_1 = ns.Intern(tmp0) if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_1.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_1.SetDynamic() } // *2 { - tmp0 := sym__STAR_2.WithMeta(lang.NewMap()).(*lang.Symbol) + tmp0 := sym__STAR_2.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core.glj", kw_line, int(6273), kw_column, int(6), kw_end_DASH_line, int(6276), kw_end_DASH_column, int(3), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var_glojure_DOT_core__STAR_2 = ns.Intern(tmp0) if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_2.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_2.SetDynamic() } // *3 { - tmp0 := sym__STAR_3.WithMeta(lang.NewMap()).(*lang.Symbol) + tmp0 := sym__STAR_3.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core.glj", kw_line, int(6278), kw_column, int(6), kw_end_DASH_line, int(6281), kw_end_DASH_column, int(3), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var_glojure_DOT_core__STAR_3 = ns.Intern(tmp0) if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_3.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_3.SetDynamic() } // *agent* { @@ -3052,14 +3053,6 @@ func LoadNS() { var_glojure_DOT_core__STAR_command_DASH_line_DASH_args_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // *compile-files* - { - tmp0 := sym__STAR_compile_DASH_files_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "Set to true when compiling files, false otherwise.", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) - var_glojure_DOT_core__STAR_compile_DASH_files_STAR_ = ns.InternWithValue(tmp0, true, true) - if tmp0.Meta() != nil { - var_glojure_DOT_core__STAR_compile_DASH_files_STAR_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } // *compile-path* { tmp0 := sym__STAR_compile_DASH_path_STAR_.WithMeta(lang.NewMap(kw_added, "1.0", kw_doc, "Specifies the directory where 'compile' will write out .class\n files. This directory must be in the classpath for 'compile' to\n work.\n\n Defaults to \"classes\"", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) @@ -3096,11 +3089,12 @@ func LoadNS() { } // *e { - tmp0 := sym__STAR_e.WithMeta(lang.NewMap()).(*lang.Symbol) + tmp0 := sym__STAR_e.WithMeta(lang.NewMap(kw_dynamic, true, kw_file, "glojure/core.glj", kw_line, int(6283), kw_column, int(6), kw_end_DASH_line, int(6286), kw_end_DASH_column, int(3), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var_glojure_DOT_core__STAR_e = ns.Intern(tmp0) if tmp0.Meta() != nil { var_glojure_DOT_core__STAR_e.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } + var_glojure_DOT_core__STAR_e.SetDynamic() } // *err* { @@ -3353,7 +3347,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5, _ := lang.FieldOrMethod(v2, "alter") if reflect.TypeOf(tmp5).Kind() != reflect.Func { @@ -3381,7 +3379,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5, _ := lang.FieldOrMethod(v2, "AlterMeta") if reflect.TypeOf(tmp5).Kind() != reflect.Func { @@ -3409,7 +3411,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5, _ := lang.FieldOrMethod(v2, "alterRoot") if reflect.TypeOf(tmp5).Kind() != reflect.Func { @@ -3780,7 +3786,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 return nil } @@ -3803,7 +3813,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5, _ := lang.FieldOrMethod(v2, "Commute") if reflect.TypeOf(tmp5).Kind() != reflect.Func { @@ -3930,7 +3944,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v4 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 return v2 } @@ -3996,7 +4014,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 tmp3 := lang.Apply(lang.CreatePersistentStructMapSlotMap, []any{v2}) return tmp3 @@ -4450,7 +4472,7 @@ func LoadNS() { } // gen-class { - tmp0 := sym_gen_DASH_class.WithMeta(lang.NewMap()).(*lang.Symbol) + tmp0 := sym_gen_DASH_class.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5732), kw_column, int(10), kw_end_DASH_line, int(5732), kw_end_DASH_column, int(18), kw_declared, true, kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var_glojure_DOT_core_gen_DASH_class = ns.Intern(tmp0) if tmp0.Meta() != nil { var_glojure_DOT_core_gen_DASH_class.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -4556,7 +4578,11 @@ func LoadNS() { return tmp4 default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 tmp3 := lang.Apply(lang.CreatePersistentHashMap, []any{v2}) return tmp3 @@ -4601,7 +4627,11 @@ func LoadNS() { return tmp4 default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 tmp3 := lang.Apply(nil, []any{v2}) return tmp3 @@ -6645,7 +6675,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 tmp3 := lang.Apply(lang.CreatePersistentTreeMap, []any{v2}) return tmp3 @@ -6667,7 +6701,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 tmp4 := lang.Apply(nil, []any{v2, v3}) return tmp4 @@ -6687,7 +6725,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 tmp3 := lang.Apply(lang.CreatePersistentTreeSet, []any{v2}) return tmp3 @@ -6709,7 +6751,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 tmp4 := lang.Apply(lang.CreatePersistentTreeSetWithComparator, []any{v2, v3}) return tmp4 @@ -6844,7 +6890,11 @@ func LoadNS() { checkArityGTE(args, 1) v3 := args[0] _ = v3 - var v4 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 lang.FnFunc tmp5 = lang.NewFnFunc(func(args ...any) any { @@ -7077,7 +7127,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 tmp4 := lang.Apply(lang.ConstructPersistentStructMap, []any{v2, v3}) return tmp4 @@ -7099,7 +7153,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 tmp4 := lang.Apply(lang.CreatePersistentStructMap, []any{v2, v3}) return tmp4 @@ -7156,7 +7214,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5, _ := lang.FieldOrMethod(v2, "swap") if reflect.TypeOf(tmp5).Kind() != reflect.Func { @@ -7184,7 +7246,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5, _ := lang.FieldOrMethod(v2, "swapVals") if reflect.TypeOf(tmp5).Kind() != reflect.Func { @@ -7538,7 +7604,7 @@ func LoadNS() { } // unquote { - tmp0 := sym_unquote.WithMeta(lang.NewMap()).(*lang.Symbol) + tmp0 := sym_unquote.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(11), kw_column, int(6), kw_end_DASH_line, int(11), kw_end_DASH_column, int(12), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var_glojure_DOT_core_unquote = ns.Intern(tmp0) if tmp0.Meta() != nil { var_glojure_DOT_core_unquote.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -7546,7 +7612,7 @@ func LoadNS() { } // unquote-splicing { - tmp0 := sym_unquote_DASH_splicing.WithMeta(lang.NewMap()).(*lang.Symbol) + tmp0 := sym_unquote_DASH_splicing.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(12), kw_column, int(6), kw_end_DASH_line, int(12), kw_end_DASH_column, int(21), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var_glojure_DOT_core_unquote_DASH_splicing = ns.Intern(tmp0) if tmp0.Meta() != nil { var_glojure_DOT_core_unquote_DASH_splicing.SetMeta(tmp0.Meta().(lang.IPersistentMap)) @@ -7809,7 +7875,11 @@ func LoadNS() { _ = v6 v7 := args[5] _ = v7 - var v8 any = lang.NewList(args[6:]...) + restArgs := args[6:] + var v8 any + if len(restArgs) > 0 { + v8 = lang.NewList(restArgs...) + } _ = v8 tmp9 := checkDerefVar(var_glojure_DOT_core_cons) tmp10 := checkDerefVar(var_glojure_DOT_core_cons) @@ -7932,7 +8002,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_list) tmp7 := checkDerefVar(var_glojure_DOT_core_cons) @@ -7961,7 +8035,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_list) tmp7 := checkDerefVar(var_glojure_DOT_core_cons) @@ -8198,7 +8276,11 @@ func LoadNS() { _ = v4 v5 := args[2] _ = v5 - var v6 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 recur_loop_1564: var tmp7 any @@ -8277,7 +8359,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 recur_loop_2149: var tmp6 any @@ -8643,7 +8729,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -8748,7 +8838,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any if lang.IsTruthy(v4) { @@ -8818,7 +8912,11 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - var v5 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 recur_loop_1550: var tmp6 any @@ -9000,7 +9098,7 @@ func LoadNS() { var tmp14 any tmp15 := checkDerefVar(var_glojure_DOT_core__STAR_unchecked_DASH_math_STAR_) if lang.IsTruthy(tmp15) { - tmp14 = sym_unchecked_dec + tmp14 = sym_UncheckedDec } else { tmp14 = sym_dec } @@ -9122,7 +9220,11 @@ func LoadNS() { _ = v4 v5 := args[3] _ = v5 - var v6 any = lang.NewList(args[4:]...) + restArgs := args[4:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_seq) tmp8 := checkDerefVar(var_glojure_DOT_core_concat) @@ -9175,7 +9277,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_seq) tmp7 := checkDerefVar(var_glojure_DOT_core_concat) @@ -9319,7 +9425,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 recur_loop_1844: var tmp5 any @@ -9388,7 +9498,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 recur_loop_2155: var tmp5 any @@ -9455,7 +9569,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 recur_loop_1841: var tmp5 any @@ -9515,7 +9633,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 recur_loop_2151: var tmp5 any @@ -9567,7 +9689,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_seq) tmp6 := checkDerefVar(var_glojure_DOT_core_concat) @@ -9642,7 +9768,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v3 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) tmp5 := checkDerefVar(var_glojure_DOT_core_concat) @@ -10352,7 +10482,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v3 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) tmp5 := checkDerefVar(var_glojure_DOT_core_concat) @@ -10603,7 +10737,11 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - var v5 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_seq) tmp7 := checkDerefVar(var_glojure_DOT_core_concat) @@ -11178,7 +11316,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v3 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) tmp5 := checkDerefVar(var_glojure_DOT_core_concat) @@ -11412,7 +11554,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -11507,119 +11653,6 @@ func LoadNS() { var_glojure_DOT_core_io_BANG_.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // keep-indexed - { - tmp0 := sym_keep_DASH_indexed.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_coll)), kw_doc, "Returns a lazy sequence of the non-nil results of (f index item). Note,\n this means false return values will be included. f must be free of\n side-effects. Returns a stateful transducer when no collection is\n provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(7372), kw_end_DASH_line, int(7372))).(*lang.Symbol) - var tmp1 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v2 := args[0] - _ = v2 - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - var tmp5 any - { // let - // let binding "iv" - tmp6 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) - tmp7 := lang.Apply(tmp6, []any{int64(-1)}) - var v8 any = tmp7 - _ = v8 - var tmp9 lang.FnFunc - tmp9 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp10 := lang.Apply(v4, nil) - return tmp10 - case 1: - v10 := args[0] - _ = v10 - tmp11 := lang.Apply(v4, []any{v10}) - return tmp11 - case 2: - v10 := args[0] - _ = v10 - v11 := args[1] - _ = v11 - var tmp12 any - { // let - // let binding "i" - tmp13 := checkDerefVar(var_glojure_DOT_core_inc) - tmp14, ok := lang.FieldOrMethod(v8, "Deref") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "Deref"))) - } - var tmp15 any - switch reflect.TypeOf(tmp14).Kind() { - case reflect.Func: - tmp15 = lang.Apply(tmp14, nil) - default: - tmp15 = tmp14 - } - tmp16 := lang.Apply(tmp13, []any{tmp15}) - tmp17, _ := lang.FieldOrMethod(v8, "reset") - if reflect.TypeOf(tmp17).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) - } - tmp18 := lang.Apply(tmp17, []any{tmp16}) - var v19 any = tmp18 - _ = v19 - // let binding "v" - tmp20 := lang.Apply(v2, []any{v19, v11}) - var v21 any = tmp20 - _ = v21 - var tmp22 any - tmp23 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) - tmp24 := lang.Apply(tmp23, []any{v21}) - if lang.IsTruthy(tmp24) { - tmp22 = v10 - } else { - tmp25 := lang.Apply(v4, []any{v10, v21}) - tmp22 = tmp25 - } - tmp12 = tmp22 - } // end let - return tmp12 - default: - checkArity(args, -1) - panic("unreachable") - } - }) - tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7382), kw_column, int(8), kw_end_DASH_line, int(7390), kw_end_DASH_column, int(33)) - tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp5 = tmp11 - } // end let - return tmp5 - }) - tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7380), kw_column, int(4), kw_end_DASH_line, int(7390), kw_end_DASH_column, int(35)) - tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp5 - case 2: - v2 := args[0] - _ = v2 - v3 := args[1] - _ = v3 - return nil - default: - checkArity(args, -1) - panic("unreachable") - } - }) - tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - var_glojure_DOT_core_keep_DASH_indexed = ns.InternWithValue(tmp0, tmp1, true) - if tmp0.Meta() != nil { - var_glojure_DOT_core_keep_DASH_indexed.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } // keyword { tmp1 := reflect.TypeOf((*lang.Keyword)(nil)).Elem() @@ -11836,7 +11869,11 @@ func LoadNS() { _ = v4 v5 := args[3] _ = v5 - var v6 any = lang.NewList(args[4:]...) + restArgs := args[4:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_cons) tmp8 := checkDerefVar(var_glojure_DOT_core_cons) @@ -11930,7 +11967,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v3 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) tmp5 := checkDerefVar(var_glojure_DOT_core_concat) @@ -12073,101 +12114,6 @@ func LoadNS() { var_glojure_DOT_core_macroexpand.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } - // map-indexed - { - tmp0 := sym_map_DASH_indexed.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_coll)), kw_doc, "Returns a lazy sequence consisting of the result of applying f to 0\n and the first item of coll, followed by applying f to 1 and the second\n item in coll, etc, until coll is exhausted. Thus function f should\n accept 2 arguments, index and item. Returns a stateful transducer when\n no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(7309), kw_end_DASH_line, int(7309))).(*lang.Symbol) - var tmp1 lang.FnFunc - tmp1 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 1: - v2 := args[0] - _ = v2 - var tmp3 lang.FnFunc - tmp3 = lang.NewFnFunc(func(args ...any) any { - checkArity(args, 1) - v4 := args[0] - _ = v4 - var tmp5 any - { // let - // let binding "i" - tmp6 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) - tmp7 := lang.Apply(tmp6, []any{int64(-1)}) - var v8 any = tmp7 - _ = v8 - var tmp9 lang.FnFunc - tmp9 = lang.NewFnFunc(func(args ...any) any { - switch len(args) { - case 0: - tmp10 := lang.Apply(v4, nil) - return tmp10 - case 1: - v10 := args[0] - _ = v10 - tmp11 := lang.Apply(v4, []any{v10}) - return tmp11 - case 2: - v10 := args[0] - _ = v10 - v11 := args[1] - _ = v11 - tmp12 := checkDerefVar(var_glojure_DOT_core_inc) - tmp13, ok := lang.FieldOrMethod(v8, "Deref") - if !ok { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "Deref"))) - } - var tmp14 any - switch reflect.TypeOf(tmp13).Kind() { - case reflect.Func: - tmp14 = lang.Apply(tmp13, nil) - default: - tmp14 = tmp13 - } - tmp15 := lang.Apply(tmp12, []any{tmp14}) - tmp16, _ := lang.FieldOrMethod(v8, "reset") - if reflect.TypeOf(tmp16).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) - } - tmp17 := lang.Apply(tmp16, []any{tmp15}) - tmp18 := lang.Apply(v2, []any{tmp17, v11}) - tmp19 := lang.Apply(v4, []any{v10, tmp18}) - return tmp19 - default: - checkArity(args, -1) - panic("unreachable") - } - }) - tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7320), kw_column, int(8), kw_end_DASH_line, int(7324), kw_end_DASH_column, int(48)) - tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - tmp5 = tmp11 - } // end let - return tmp5 - }) - tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7318), kw_column, int(4), kw_end_DASH_line, int(7324), kw_end_DASH_column, int(50)) - tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) - if err != nil { - panic(err) - } - return tmp5 - case 2: - v2 := args[0] - _ = v2 - v3 := args[1] - _ = v3 - return nil - default: - checkArity(args, -1) - panic("unreachable") - } - }) - tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) - var_glojure_DOT_core_map_DASH_indexed = ns.InternWithValue(tmp0, tmp1, true) - if tmp0.Meta() != nil { - var_glojure_DOT_core_map_DASH_indexed.SetMeta(tmp0.Meta().(lang.IPersistentMap)) - } - } // maybe-destructured { tmp0 := sym_maybe_DASH_destructured.WithMeta(lang.NewMap(kw_private, true, kw_file, "glojure/core.glj", kw_line, int(4514), kw_column, int(7), kw_end_DASH_line, int(4515), kw_end_DASH_column, int(20), kw_arglists, lang.NewList(lang.NewVector(sym_params, sym_body)), kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) @@ -12600,7 +12546,11 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - var v5 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_seq) tmp7 := checkDerefVar(var_glojure_DOT_core_concat) @@ -13558,7 +13508,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_seq) tmp6 := checkDerefVar(var_glojure_DOT_core_concat) @@ -13979,7 +13933,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v3 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) tmp5 := checkDerefVar(var_glojure_DOT_core_concat) @@ -14535,7 +14493,11 @@ func LoadNS() { _ = v6 v7 := args[2] _ = v7 - var v8 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v8 any + if len(restArgs) > 0 { + v8 = lang.NewList(restArgs...) + } _ = v8 var tmp9 any { // let @@ -14732,7 +14694,11 @@ func LoadNS() { _ = v7 v8 := args[2] _ = v8 - var v9 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v9 any + if len(restArgs) > 0 { + v9 = lang.NewList(restArgs...) + } _ = v9 var tmp10 any { // let @@ -15042,7 +15008,11 @@ func LoadNS() { _ = v8 v9 := args[2] _ = v9 - var v10 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v10 any + if len(restArgs) > 0 { + v10 = lang.NewList(restArgs...) + } _ = v10 var tmp11 any { // let @@ -15121,7 +15091,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -15250,7 +15224,11 @@ func LoadNS() { _ = v13 v14 := args[2] _ = v14 - var v15 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v15 any + if len(restArgs) > 0 { + v15 = lang.NewList(restArgs...) + } _ = v15 var tmp16 any { // let @@ -15550,7 +15528,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 tmp3 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) var tmp4 lang.FnFunc @@ -15642,7 +15624,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_unchecked_add}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_UncheckedAdd}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -15665,9 +15647,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_add") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedAdd") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_add is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedAdd is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -15852,7 +15834,7 @@ func LoadNS() { tmp11 := checkDerefVar(var_glojure_DOT_core_seq) tmp12 := checkDerefVar(var_glojure_DOT_core_concat) tmp13 := checkDerefVar(var_glojure_DOT_core_list) - tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_unchecked_dec}) + tmp14 := lang.Apply(tmp13, []any{sym_glojure_DOT_core_SLASH_UncheckedDec}) tmp15 := checkDerefVar(var_glojure_DOT_core_list) tmp16 := lang.Apply(tmp15, []any{v3}) tmp17 := lang.Apply(tmp12, []any{tmp14, tmp16}) @@ -15871,9 +15853,9 @@ func LoadNS() { checkArity(args, 1) v3 := args[0] _ = v3 - tmp4, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_dec") + tmp4, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedDec") if reflect.TypeOf(tmp4).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_dec is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedDec is not a function"))) } tmp5 := lang.Apply(tmp4, []any{v3}) return tmp5 @@ -15956,7 +15938,7 @@ func LoadNS() { tmp12 := checkDerefVar(var_glojure_DOT_core_seq) tmp13 := checkDerefVar(var_glojure_DOT_core_concat) tmp14 := checkDerefVar(var_glojure_DOT_core_list) - tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_unchecked_int_divide}) + tmp15 := lang.Apply(tmp14, []any{sym_glojure_DOT_core_SLASH_UncheckedIntDivide}) tmp16 := checkDerefVar(var_glojure_DOT_core_list) tmp17 := lang.Apply(tmp16, []any{v3}) tmp18 := checkDerefVar(var_glojure_DOT_core_list) @@ -15979,9 +15961,9 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - tmp5, _ := lang.FieldOrMethod(lang.Numbers, "unchecked_int_divide") + tmp5, _ := lang.FieldOrMethod(lang.Numbers, "UncheckedIntDivide") if reflect.TypeOf(tmp5).Kind() != reflect.Func { - panic(lang.NewIllegalArgumentError(fmt.Sprintf("unchecked_int_divide is not a function"))) + panic(lang.NewIllegalArgumentError(fmt.Sprintf("UncheckedIntDivide is not a function"))) } tmp6 := lang.Apply(tmp5, []any{v3, v4}) return tmp6 @@ -16852,7 +16834,11 @@ func LoadNS() { _ = v4 v5 := args[3] _ = v5 - var v6 any = lang.NewList(args[4:]...) + restArgs := args[4:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 var tmp7 any { // let @@ -17159,7 +17145,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -17247,7 +17237,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -17357,7 +17351,11 @@ func LoadNS() { _ = v4 v5 := args[3] _ = v5 - var v6 any = lang.NewList(args[4:]...) + restArgs := args[4:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_seq) tmp8 := checkDerefVar(var_glojure_DOT_core_concat) @@ -17437,7 +17435,11 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - var v5 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 recur_loop_1666: var tmp6 any @@ -17538,7 +17540,11 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - var v5 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 recur_loop_1746: var tmp6 any @@ -17641,7 +17647,11 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - var v5 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 recur_loop_1738: var tmp6 any @@ -17744,7 +17754,11 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - var v5 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 recur_loop_1742: var tmp6 any @@ -17847,7 +17861,11 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - var v5 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 recur_loop_1690: var tmp6 any @@ -17950,7 +17968,11 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - var v5 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 recur_loop_1734: var tmp6 any @@ -18079,7 +18101,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -18196,7 +18222,11 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - var v6 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) tmp8 := checkDerefVar(var_glojure_DOT_core__PLUS_) @@ -18299,7 +18329,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -18416,7 +18450,11 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - var v6 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) tmp8 := checkDerefVar(var_glojure_DOT_core__PLUS__TICK_) @@ -18519,7 +18557,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -18635,7 +18677,11 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - var v6 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) tmp8 := checkDerefVar(var_glojure_DOT_core__SLASH_) @@ -18738,7 +18784,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -18855,7 +18905,11 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - var v6 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) tmp8 := checkDerefVar(var_glojure_DOT_core__STAR_) @@ -18958,7 +19012,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -19075,7 +19133,11 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - var v6 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) tmp8 := checkDerefVar(var_glojure_DOT_core__STAR__TICK_) @@ -19352,7 +19414,11 @@ func LoadNS() { _ = v5 v6 := args[4] _ = v6 - var v7 any = lang.NewList(args[5:]...) + restArgs := args[5:] + var v7 any + if len(restArgs) > 0 { + v7 = lang.NewList(restArgs...) + } _ = v7 tmp8 := checkDerefVar(var_glojure_DOT_core_cons) tmp9 := checkDerefVar(var_glojure_DOT_core_cons) @@ -19508,7 +19574,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 tmp3 := checkDerefVar(var_glojure_DOT_core_into_DASH_array) tmp4 := lang.Apply(tmp3, []any{v2}) @@ -19692,7 +19762,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_seq) tmp6 := checkDerefVar(var_glojure_DOT_core_concat) @@ -20263,7 +20337,11 @@ func LoadNS() { _ = v8 v9 := args[2] _ = v9 - var v10 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v10 any + if len(restArgs) > 0 { + v10 = lang.NewList(restArgs...) + } _ = v10 tmp11 := lang.Apply(lang.ResetThreadBindingFrame, []any{v5}) _ = tmp11 @@ -20374,7 +20452,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -20484,7 +20566,11 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - var v6 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) tmp8 := checkDerefVar(var_glojure_DOT_core_bit_DASH_and) @@ -20587,7 +20673,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -20697,7 +20787,11 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - var v6 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) tmp8 := checkDerefVar(var_glojure_DOT_core_bit_DASH_and_DASH_not) @@ -20851,7 +20945,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -20961,7 +21059,11 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - var v6 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) tmp8 := checkDerefVar(var_glojure_DOT_core_bit_DASH_or) @@ -21178,7 +21280,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -21288,7 +21394,11 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - var v6 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) tmp8 := checkDerefVar(var_glojure_DOT_core_bit_DASH_xor) @@ -21364,7 +21474,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v3 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) tmp5 := checkDerefVar(var_glojure_DOT_core_concat) @@ -21484,7 +21598,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_seq) tmp6 := checkDerefVar(var_glojure_DOT_core_concat) @@ -21517,7 +21635,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 tmp3 := checkDerefVar(var_glojure_DOT_core_every_QMARK_) var tmp4 lang.FnFunc @@ -21748,7 +21870,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v3 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) tmp5 := checkDerefVar(var_glojure_DOT_core_concat) @@ -21962,7 +22088,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v3 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_seq) tmp5 := checkDerefVar(var_glojure_DOT_core_concat) @@ -22127,7 +22257,11 @@ func LoadNS() { _ = v6 v7 := args[2] _ = v7 - var v8 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v8 any + if len(restArgs) > 0 { + v8 = lang.NewList(restArgs...) + } _ = v8 tmp9 := checkDerefVar(var_glojure_DOT_core_apply) tmp10 := lang.Apply(tmp9, []any{v3, v5, v6, v7, v8}) @@ -22147,7 +22281,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_reduce1) tmp6 := checkDerefVar(var_glojure_DOT_core_comp) @@ -22248,7 +22386,11 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - var v6 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_not) tmp8 := checkDerefVar(var_glojure_DOT_core_apply) @@ -22509,7 +22651,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -22639,7 +22785,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -22927,7 +23077,11 @@ func LoadNS() { _ = v4 v5 := args[2] _ = v5 - var v6 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 var tmp7 any tmp8 := checkDerefVar(var_glojure_DOT_core_instance_QMARK_) @@ -23204,7 +23358,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_list_STAR_) tmp7 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) @@ -23314,7 +23472,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_list) tmp6 := checkDerefVar(var_glojure_DOT_core_list_STAR_) @@ -23849,7 +24011,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) @@ -24487,7 +24653,11 @@ func LoadNS() { _ = v6 v7 := args[2] _ = v7 - var v8 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v8 any + if len(restArgs) > 0 { + v8 = lang.NewList(restArgs...) + } _ = v8 tmp9 := checkDerefVar(var_glojure_DOT_core_boolean) var tmp10 any @@ -24692,7 +24862,11 @@ func LoadNS() { _ = v7 v8 := args[2] _ = v8 - var v9 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v9 any + if len(restArgs) > 0 { + v9 = lang.NewList(restArgs...) + } _ = v9 tmp10 := checkDerefVar(var_glojure_DOT_core_boolean) var tmp11 any @@ -25010,7 +25184,11 @@ func LoadNS() { _ = v8 v9 := args[2] _ = v9 - var v10 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v10 any + if len(restArgs) > 0 { + v10 = lang.NewList(restArgs...) + } _ = v10 tmp11 := checkDerefVar(var_glojure_DOT_core_boolean) var tmp12 any @@ -25091,7 +25269,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -25220,7 +25402,11 @@ func LoadNS() { _ = v13 v14 := args[2] _ = v14 - var v15 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v15 any + if len(restArgs) > 0 { + v15 = lang.NewList(restArgs...) + } _ = v15 tmp16 := checkDerefVar(var_glojure_DOT_core_boolean) var tmp17 any @@ -25594,7 +25780,11 @@ func LoadNS() { _ = v6 v7 := args[2] _ = v7 - var v8 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v8 any + if len(restArgs) > 0 { + v8 = lang.NewList(restArgs...) + } _ = v8 tmp9 := checkDerefVar(var_glojure_DOT_core_apply) var tmp10 any @@ -25681,7 +25871,11 @@ func LoadNS() { _ = v7 v8 := args[2] _ = v8 - var v9 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v9 any + if len(restArgs) > 0 { + v9 = lang.NewList(restArgs...) + } _ = v9 tmp10 := checkDerefVar(var_glojure_DOT_core_apply) var tmp11 any @@ -25786,7 +25980,11 @@ func LoadNS() { _ = v8 v9 := args[2] _ = v9 - var v10 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v10 any + if len(restArgs) > 0 { + v10 = lang.NewList(restArgs...) + } _ = v10 tmp11 := checkDerefVar(var_glojure_DOT_core_apply) var tmp12 any @@ -25844,7 +26042,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_apply) tmp5 := lang.Apply(tmp4, []any{fmt.Sprintf, v2, v3}) @@ -25869,7 +26071,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_seq) tmp6 := checkDerefVar(var_glojure_DOT_core_concat) @@ -26070,7 +26276,11 @@ func LoadNS() { _ = v5 v6 := args[4] _ = v6 - var v7 any = lang.NewList(args[5:]...) + restArgs := args[5:] + var v7 any + if len(restArgs) > 0 { + v7 = lang.NewList(restArgs...) + } _ = v7 var tmp8 any tmp9 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) @@ -26240,7 +26450,11 @@ func LoadNS() { _ = v5 v6 := args[4] _ = v6 - var v7 any = lang.NewList(args[5:]...) + restArgs := args[5:] + var v7 any + if len(restArgs) > 0 { + v7 = lang.NewList(restArgs...) + } _ = v7 var tmp8 any tmp9 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) @@ -26483,7 +26697,11 @@ func LoadNS() { _ = v5 v6 := args[2] _ = v6 - var v7 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v7 any + if len(restArgs) > 0 { + v7 = lang.NewList(restArgs...) + } _ = v7 tmp8 := checkDerefVar(var_glojure_DOT_core_apply) tmp9 := lang.Apply(tmp8, []any{v2, v4, v5, v6, v7}) @@ -26570,7 +26788,11 @@ func LoadNS() { _ = v6 v7 := args[2] _ = v7 - var v8 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v8 any + if len(restArgs) > 0 { + v8 = lang.NewList(restArgs...) + } _ = v8 tmp9 := checkDerefVar(var_glojure_DOT_core_apply) tmp10 := lang.Apply(tmp9, []any{v2, v5, v6, v7, v8}) @@ -26665,7 +26887,11 @@ func LoadNS() { _ = v7 v8 := args[2] _ = v8 - var v9 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v9 any + if len(restArgs) > 0 { + v9 = lang.NewList(restArgs...) + } _ = v9 tmp10 := checkDerefVar(var_glojure_DOT_core_apply) tmp11 := lang.Apply(tmp10, []any{v2, v6, v7, v8, v9}) @@ -26696,7 +26922,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -26836,7 +27066,11 @@ func LoadNS() { _ = v12 v13 := args[2] _ = v13 - var v14 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v14 any + if len(restArgs) > 0 { + v14 = lang.NewList(restArgs...) + } _ = v14 tmp15 := checkDerefVar(var_glojure_DOT_core_reduce1) var tmp16 lang.FnFunc @@ -27110,6 +27344,291 @@ func LoadNS() { var_glojure_DOT_core_keep.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } + // keep-indexed + { + tmp0 := sym_keep_DASH_indexed.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_coll)), kw_doc, "Returns a lazy sequence of the non-nil results of (f index item). Note,\n this means false return values will be included. f must be free of\n side-effects. Returns a stateful transducer when no collection is\n provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(7), kw_line, int(7372), kw_end_DASH_line, int(7372))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 any + { // let + // let binding "iv" + tmp6 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) + tmp7 := lang.Apply(tmp6, []any{int64(-1)}) + var v8 any = tmp7 + _ = v8 + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp10 := lang.Apply(v4, nil) + return tmp10 + case 1: + v10 := args[0] + _ = v10 + tmp11 := lang.Apply(v4, []any{v10}) + return tmp11 + case 2: + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + var tmp12 any + { // let + // let binding "i" + tmp13 := checkDerefVar(var_glojure_DOT_core_inc) + tmp14, ok := lang.FieldOrMethod(v8, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "Deref"))) + } + var tmp15 any + switch reflect.TypeOf(tmp14).Kind() { + case reflect.Func: + tmp15 = lang.Apply(tmp14, nil) + default: + tmp15 = tmp14 + } + tmp16 := lang.Apply(tmp13, []any{tmp15}) + tmp17, _ := lang.FieldOrMethod(v8, "reset") + if reflect.TypeOf(tmp17).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) + } + tmp18 := lang.Apply(tmp17, []any{tmp16}) + var v19 any = tmp18 + _ = v19 + // let binding "v" + tmp20 := lang.Apply(v2, []any{v19, v11}) + var v21 any = tmp20 + _ = v21 + var tmp22 any + tmp23 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp24 := lang.Apply(tmp23, []any{v21}) + if lang.IsTruthy(tmp24) { + tmp22 = v10 + } else { + tmp25 := lang.Apply(v4, []any{v10, v21}) + tmp22 = tmp25 + } + tmp12 = tmp22 + } // end let + return tmp12 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7382), kw_column, int(8), kw_end_DASH_line, int(7390), kw_end_DASH_column, int(33)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp5 = tmp11 + } // end let + return tmp5 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7380), kw_column, int(4), kw_end_DASH_line, int(7390), kw_end_DASH_column, int(35)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // letfn + // letfn binding "keepi" + var v5 lang.FnFunc + var tmp6 lang.FnFunc + { // function keepi + var v7 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp11 any + { // let + // let binding "temp__0__auto__" + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := lang.Apply(tmp12, []any{v9}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + var tmp16 any + { // let + // let binding "s" + var v17 any = v14 + _ = v17 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp20 := lang.Apply(tmp19, []any{v17}) + if lang.IsTruthy(tmp20) { + var tmp21 any + { // let + // let binding "c" + tmp22 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp23 := lang.Apply(tmp22, []any{v17}) + var v24 any = tmp23 + _ = v24 + // let binding "size" + tmp25 := checkDerefVar(var_glojure_DOT_core_count) + tmp26 := lang.Apply(tmp25, []any{v24}) + var v27 any = tmp26 + _ = v27 + // let binding "b" + tmp28 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_buffer) + tmp29 := lang.Apply(tmp28, []any{v27}) + var v30 any = tmp29 + _ = v30 + var tmp31 any + { // let + // let binding "n__0__auto__" + tmp32 := checkDerefVar(var_glojure_DOT_core_long) + tmp33 := lang.Apply(tmp32, []any{v27}) + var v34 any = tmp33 + _ = v34 + var tmp35 any + { // let + // let binding "i" + var v36 any = int64(0) + _ = v36 + for { + var tmp37 any + tmp38 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp39 := lang.Apply(tmp38, []any{v36, v34}) + if lang.IsTruthy(tmp39) { + var tmp40 any + { // let + // let binding "x" + tmp41 := checkDerefVar(var_glojure_DOT_core__PLUS_) + tmp42 := lang.Apply(tmp41, []any{v8, v36}) + tmp43, _ := lang.FieldOrMethod(v24, "nth") + if reflect.TypeOf(tmp43).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp44 := lang.Apply(tmp43, []any{v36}) + tmp45 := lang.Apply(v2, []any{tmp42, tmp44}) + var v46 any = tmp45 + _ = v46 + var tmp47 any + tmp48 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp49 := lang.Apply(tmp48, []any{v46}) + if lang.IsTruthy(tmp49) { + } else { + tmp50 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_append) + tmp51 := lang.Apply(tmp50, []any{v30, v46}) + tmp47 = tmp51 + } + tmp40 = tmp47 + } // end let + _ = tmp40 + tmp42 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp43 := lang.Apply(tmp42, []any{v36}) + var tmp41 any = tmp43 + v36 = tmp41 + continue + } else { + } + tmp35 = tmp37 + break + } + } // end let + tmp31 = tmp35 + } // end let + _ = tmp31 + tmp32 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_cons) + tmp33 := checkDerefVar(var_glojure_DOT_core_chunk) + tmp34 := lang.Apply(tmp33, []any{v30}) + tmp35 := checkDerefVar(var_glojure_DOT_core__PLUS_) + tmp36 := lang.Apply(tmp35, []any{v8, v27}) + tmp37 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp38 := lang.Apply(tmp37, []any{v17}) + tmp39 := lang.Apply(v7, []any{tmp36, tmp38}) + tmp40 := lang.Apply(tmp32, []any{tmp34, tmp39}) + tmp21 = tmp40 + } // end let + tmp18 = tmp21 + } else { + var tmp22 any + { // let + // let binding "x" + tmp23 := checkDerefVar(var_glojure_DOT_core_first) + tmp24 := lang.Apply(tmp23, []any{v17}) + tmp25 := lang.Apply(v2, []any{v8, tmp24}) + var v26 any = tmp25 + _ = v26 + var tmp27 any + tmp28 := checkDerefVar(var_glojure_DOT_core_nil_QMARK_) + tmp29 := lang.Apply(tmp28, []any{v26}) + if lang.IsTruthy(tmp29) { + tmp30 := checkDerefVar(var_glojure_DOT_core_inc) + tmp31 := lang.Apply(tmp30, []any{v8}) + tmp32 := checkDerefVar(var_glojure_DOT_core_rest) + tmp33 := lang.Apply(tmp32, []any{v17}) + tmp34 := lang.Apply(v7, []any{tmp31, tmp33}) + tmp27 = tmp34 + } else { + tmp35 := checkDerefVar(var_glojure_DOT_core_cons) + tmp36 := checkDerefVar(var_glojure_DOT_core_inc) + tmp37 := lang.Apply(tmp36, []any{v8}) + tmp38 := checkDerefVar(var_glojure_DOT_core_rest) + tmp39 := lang.Apply(tmp38, []any{v17}) + tmp40 := lang.Apply(v7, []any{tmp37, tmp39}) + tmp41 := lang.Apply(tmp35, []any{v26, tmp40}) + tmp27 = tmp41 + } + tmp22 = tmp27 + } // end let + tmp18 = tmp22 + } + tmp16 = tmp18 + } // end let + tmp15 = tmp16 + } else { + } + tmp11 = tmp15 + } // end let + return tmp11 + }) + tmp11 := lang.Apply(lang.NewLazySeq, []any{tmp10}) + return tmp11 + }) + v7 = tmp6 + _ = v7 + } + v5 = tmp6 + _ = v5 + tmp7 := lang.Apply(v5, []any{int64(0), v3}) + tmp4 = tmp7 + } // end letfn + return tmp4 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_keep_DASH_indexed = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_keep_DASH_indexed.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } // lazy-seq { tmp0 := sym_lazy_DASH_seq.WithMeta(lang.NewMap(kw_macro, true, kw_arglists, lang.NewList(lang.NewVector(sym__AMP_, sym_body)), kw_doc, "Takes a body of expressions that returns an ISeq or nil, and yields\n a Seqable object that will invoke the body only the first time seq\n is called, and will cache the result and return it on all subsequent\n seq calls. See also - realized?", kw_file, "glojure/core.glj", kw_added, "1.0", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(18), kw_column, int(11), kw_line, int(676), kw_end_DASH_line, int(676))).(*lang.Symbol) @@ -27122,7 +27641,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_list) tmp6 := checkDerefVar(var_glojure_DOT_core_list_STAR_) @@ -27157,7 +27680,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_seq) tmp7 := checkDerefVar(var_glojure_DOT_core_concat) @@ -27291,7 +27818,11 @@ func LoadNS() { _ = v6 v7 := args[1] _ = v7 - var v8 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v8 any + if len(restArgs) > 0 { + v8 = lang.NewList(restArgs...) + } _ = v8 tmp9 := checkDerefVar(var_glojure_DOT_core_apply) tmp10 := lang.Apply(tmp9, []any{v2, v7, v8}) @@ -27582,7 +28113,11 @@ func LoadNS() { _ = v4 v5 := args[3] _ = v5 - var v6 any = lang.NewList(args[4:]...) + restArgs := args[4:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 var tmp7 any { // let @@ -27669,6 +28204,241 @@ func LoadNS() { var_glojure_DOT_core_map.SetMeta(tmp0.Meta().(lang.IPersistentMap)) } } + // map-indexed + { + tmp0 := sym_map_DASH_indexed.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_f), lang.NewVector(sym_f, sym_coll)), kw_doc, "Returns a lazy sequence consisting of the result of applying f to 0\n and the first item of coll, followed by applying f to 1 and the second\n item in coll, etc, until coll is exhausted. Thus function f should\n accept 2 arguments, index and item. Returns a stateful transducer when\n no collection is provided.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(17), kw_column, int(7), kw_line, int(7309), kw_end_DASH_line, int(7309))).(*lang.Symbol) + var tmp1 lang.FnFunc + tmp1 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 1: + v2 := args[0] + _ = v2 + var tmp3 lang.FnFunc + tmp3 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 1) + v4 := args[0] + _ = v4 + var tmp5 any + { // let + // let binding "i" + tmp6 := checkDerefVar(var_glojure_DOT_core_volatile_BANG_) + tmp7 := lang.Apply(tmp6, []any{int64(-1)}) + var v8 any = tmp7 + _ = v8 + var tmp9 lang.FnFunc + tmp9 = lang.NewFnFunc(func(args ...any) any { + switch len(args) { + case 0: + tmp10 := lang.Apply(v4, nil) + return tmp10 + case 1: + v10 := args[0] + _ = v10 + tmp11 := lang.Apply(v4, []any{v10}) + return tmp11 + case 2: + v10 := args[0] + _ = v10 + v11 := args[1] + _ = v11 + tmp12 := checkDerefVar(var_glojure_DOT_core_inc) + tmp13, ok := lang.FieldOrMethod(v8, "Deref") + if !ok { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("no such field or method on %T: %s", v8, "Deref"))) + } + var tmp14 any + switch reflect.TypeOf(tmp13).Kind() { + case reflect.Func: + tmp14 = lang.Apply(tmp13, nil) + default: + tmp14 = tmp13 + } + tmp15 := lang.Apply(tmp12, []any{tmp14}) + tmp16, _ := lang.FieldOrMethod(v8, "reset") + if reflect.TypeOf(tmp16).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("reset is not a function"))) + } + tmp17 := lang.Apply(tmp16, []any{tmp15}) + tmp18 := lang.Apply(v2, []any{tmp17, v11}) + tmp19 := lang.Apply(v4, []any{v10, tmp18}) + return tmp19 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp10 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7320), kw_column, int(8), kw_end_DASH_line, int(7324), kw_end_DASH_column, int(48)) + tmp11, err := lang.WithMeta(tmp9, tmp10.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + tmp5 = tmp11 + } // end let + return tmp5 + }) + tmp4 := lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(7318), kw_column, int(4), kw_end_DASH_line, int(7324), kw_end_DASH_column, int(50)) + tmp5, err := lang.WithMeta(tmp3, tmp4.(lang.IPersistentMap)) + if err != nil { + panic(err) + } + return tmp5 + case 2: + v2 := args[0] + _ = v2 + v3 := args[1] + _ = v3 + var tmp4 any + { // letfn + // letfn binding "mapi" + var v5 lang.FnFunc + var tmp6 lang.FnFunc + { // function mapi + var v7 lang.FnFunc + tmp6 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 2) + v8 := args[0] + _ = v8 + v9 := args[1] + _ = v9 + var tmp10 lang.FnFunc + tmp10 = lang.NewFnFunc(func(args ...any) any { + checkArity(args, 0) + var tmp11 any + { // let + // let binding "temp__0__auto__" + tmp12 := checkDerefVar(var_glojure_DOT_core_seq) + tmp13 := lang.Apply(tmp12, []any{v9}) + var v14 any = tmp13 + _ = v14 + var tmp15 any + if lang.IsTruthy(v14) { + var tmp16 any + { // let + // let binding "s" + var v17 any = v14 + _ = v17 + var tmp18 any + tmp19 := checkDerefVar(var_glojure_DOT_core_chunked_DASH_seq_QMARK_) + tmp20 := lang.Apply(tmp19, []any{v17}) + if lang.IsTruthy(tmp20) { + var tmp21 any + { // let + // let binding "c" + tmp22 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_first) + tmp23 := lang.Apply(tmp22, []any{v17}) + var v24 any = tmp23 + _ = v24 + // let binding "size" + tmp25 := checkDerefVar(var_glojure_DOT_core_int) + tmp26 := checkDerefVar(var_glojure_DOT_core_count) + tmp27 := lang.Apply(tmp26, []any{v24}) + tmp28 := lang.Apply(tmp25, []any{tmp27}) + var v29 any = tmp28 + _ = v29 + // let binding "b" + tmp30 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_buffer) + tmp31 := lang.Apply(tmp30, []any{v29}) + var v32 any = tmp31 + _ = v32 + var tmp33 any + { // let + // let binding "n__0__auto__" + tmp34 := checkDerefVar(var_glojure_DOT_core_long) + tmp35 := lang.Apply(tmp34, []any{v29}) + var v36 any = tmp35 + _ = v36 + var tmp37 any + { // let + // let binding "i" + var v38 any = int64(0) + _ = v38 + for { + var tmp39 any + tmp40 := checkDerefVar(var_glojure_DOT_core__LT_) + tmp41 := lang.Apply(tmp40, []any{v38, v36}) + if lang.IsTruthy(tmp41) { + tmp42 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_append) + tmp43 := checkDerefVar(var_glojure_DOT_core__PLUS_) + tmp44 := lang.Apply(tmp43, []any{v8, v38}) + tmp45, _ := lang.FieldOrMethod(v24, "nth") + if reflect.TypeOf(tmp45).Kind() != reflect.Func { + panic(lang.NewIllegalArgumentError(fmt.Sprintf("nth is not a function"))) + } + tmp46 := lang.Apply(tmp45, []any{v38}) + tmp47 := lang.Apply(v2, []any{tmp44, tmp46}) + tmp48 := lang.Apply(tmp42, []any{v32, tmp47}) + _ = tmp48 + tmp50 := checkDerefVar(var_glojure_DOT_core_unchecked_DASH_inc) + tmp51 := lang.Apply(tmp50, []any{v38}) + var tmp49 any = tmp51 + v38 = tmp49 + continue + } else { + } + tmp37 = tmp39 + break + } + } // end let + tmp33 = tmp37 + } // end let + _ = tmp33 + tmp34 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_cons) + tmp35 := checkDerefVar(var_glojure_DOT_core_chunk) + tmp36 := lang.Apply(tmp35, []any{v32}) + tmp37 := checkDerefVar(var_glojure_DOT_core__PLUS_) + tmp38 := lang.Apply(tmp37, []any{v8, v29}) + tmp39 := checkDerefVar(var_glojure_DOT_core_chunk_DASH_rest) + tmp40 := lang.Apply(tmp39, []any{v17}) + tmp41 := lang.Apply(v7, []any{tmp38, tmp40}) + tmp42 := lang.Apply(tmp34, []any{tmp36, tmp41}) + tmp21 = tmp42 + } // end let + tmp18 = tmp21 + } else { + tmp22 := checkDerefVar(var_glojure_DOT_core_cons) + tmp23 := checkDerefVar(var_glojure_DOT_core_first) + tmp24 := lang.Apply(tmp23, []any{v17}) + tmp25 := lang.Apply(v2, []any{v8, tmp24}) + tmp26 := checkDerefVar(var_glojure_DOT_core_inc) + tmp27 := lang.Apply(tmp26, []any{v8}) + tmp28 := checkDerefVar(var_glojure_DOT_core_rest) + tmp29 := lang.Apply(tmp28, []any{v17}) + tmp30 := lang.Apply(v7, []any{tmp27, tmp29}) + tmp31 := lang.Apply(tmp22, []any{tmp25, tmp30}) + tmp18 = tmp31 + } + tmp16 = tmp18 + } // end let + tmp15 = tmp16 + } else { + } + tmp11 = tmp15 + } // end let + return tmp11 + }) + tmp11 := lang.Apply(lang.NewLazySeq, []any{tmp10}) + return tmp11 + }) + v7 = tmp6 + _ = v7 + } + v5 = tmp6 + _ = v5 + tmp7 := lang.Apply(v5, []any{int64(0), v3}) + tmp4 = tmp7 + } // end letfn + return tmp4 + default: + checkArity(args, -1) + panic("unreachable") + } + }) + tmp1 = tmp1.WithMeta(lang.NewMap(kw_rettag, nil)).(lang.FnFunc) + var_glojure_DOT_core_map_DASH_indexed = ns.InternWithValue(tmp0, tmp1, true) + if tmp0.Meta() != nil { + var_glojure_DOT_core_map_DASH_indexed.SetMeta(tmp0.Meta().(lang.IPersistentMap)) + } + } // max { var tmp1 lang.FnFunc @@ -27756,7 +28526,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -27870,7 +28644,11 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - var v6 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) tmp8 := checkDerefVar(var_glojure_DOT_core_max) @@ -27924,7 +28702,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -28053,7 +28835,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -28120,7 +28906,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 var tmp3 any tmp4 := checkDerefVar(var_glojure_DOT_core_some) @@ -28186,7 +28976,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 var tmp4 any tmp5 := checkDerefVar(var_glojure_DOT_core_some) @@ -28384,7 +29178,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -28498,7 +29296,11 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - var v6 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) tmp8 := checkDerefVar(var_glojure_DOT_core_min) @@ -28552,7 +29354,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -28825,7 +29631,11 @@ func LoadNS() { _ = v5 v6 := args[1] _ = v6 - var v7 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v7 any + if len(restArgs) > 0 { + v7 = lang.NewList(restArgs...) + } _ = v7 var tmp8 any { // let @@ -29028,7 +29838,11 @@ func LoadNS() { _ = v4 v5 := args[2] _ = v5 - var v6 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_apply) tmp8 := lang.Apply(tmp7, []any{closed25, v3, v4, v5, v6}) @@ -29085,7 +29899,11 @@ func LoadNS() { _ = v4 v5 := args[2] _ = v5 - var v6 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_apply) tmp8 := lang.Apply(tmp7, []any{closed26, v3, v4, v5, v6}) @@ -29126,7 +29944,11 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - var v5 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_not) tmp7 := checkDerefVar(var_glojure_DOT_core_apply) @@ -29645,7 +30467,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_seq) tmp7 := checkDerefVar(var_glojure_DOT_core_concat) @@ -29929,7 +30755,11 @@ func LoadNS() { _ = v6 v7 := args[2] _ = v7 - var v8 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v8 any + if len(restArgs) > 0 { + v8 = lang.NewList(restArgs...) + } _ = v8 tmp9 := checkDerefVar(var_glojure_DOT_core_apply) tmp10 := lang.Apply(tmp9, []any{v2, v3, v5, v6, v7, v8}) @@ -29984,7 +30814,11 @@ func LoadNS() { _ = v7 v8 := args[2] _ = v8 - var v9 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v9 any + if len(restArgs) > 0 { + v9 = lang.NewList(restArgs...) + } _ = v9 tmp10 := checkDerefVar(var_glojure_DOT_core_apply) tmp11 := lang.Apply(tmp10, []any{v2, v3, v4, v6, v7, v8, v9}) @@ -30041,7 +30875,11 @@ func LoadNS() { _ = v8 v9 := args[2] _ = v9 - var v10 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v10 any + if len(restArgs) > 0 { + v10 = lang.NewList(restArgs...) + } _ = v10 tmp11 := checkDerefVar(var_glojure_DOT_core_apply) tmp12 := lang.Apply(tmp11, []any{v2, v3, v4, v5, v7, v8, v9, v10}) @@ -30064,14 +30902,22 @@ func LoadNS() { _ = v4 v5 := args[3] _ = v5 - var v6 any = lang.NewList(args[4:]...) + restArgs := args[4:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 var tmp7 lang.FnFunc tmp7 = lang.NewFnFunc(func(args ...any) any { switch len(args) { default: checkArityGTE(args, 0) - var v8 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v8 any + if len(restArgs) > 0 { + v8 = lang.NewList(restArgs...) + } _ = v8 tmp9 := checkDerefVar(var_glojure_DOT_core_apply) tmp10 := checkDerefVar(var_glojure_DOT_core_concat) @@ -30555,7 +31401,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -31098,7 +31948,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_seq) tmp6 := checkDerefVar(var_glojure_DOT_core_concat) @@ -31608,7 +32462,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 var tmp4 any { // let @@ -32165,7 +33023,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -32396,7 +33258,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -32494,7 +33360,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -32735,7 +33605,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -33045,7 +33919,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_seq) tmp7 := checkDerefVar(var_glojure_DOT_core_concat) @@ -33471,7 +34349,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any if lang.IsTruthy(v2) { @@ -33738,7 +34620,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_trampoline) var tmp5 lang.FnFunc @@ -33847,7 +34733,11 @@ func LoadNS() { _ = v6 v7 := args[5] _ = v7 - var v8 any = lang.NewList(args[6:]...) + restArgs := args[6:] + var v8 any + if len(restArgs) > 0 { + v8 = lang.NewList(restArgs...) + } _ = v8 tmp9 := checkDerefVar(var_glojure_DOT_core_assoc) tmp10 := checkDerefVar(var_glojure_DOT_core_apply) @@ -33878,7 +34768,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -33977,7 +34871,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_with_DASH_meta) tmp6 := checkDerefVar(var_glojure_DOT_core_apply) @@ -34008,7 +34906,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) @@ -34142,7 +35044,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) @@ -34265,7 +35171,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) @@ -34398,7 +35308,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_seq) tmp7 := checkDerefVar(var_glojure_DOT_core_concat) @@ -34456,7 +35370,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_seq) tmp7 := checkDerefVar(var_glojure_DOT_core_concat) @@ -34504,7 +35422,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_push_DASH_thread_DASH_bindings) tmp6 := lang.Apply(tmp5, []any{v2}) @@ -34543,7 +35465,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_seq) tmp7 := checkDerefVar(var_glojure_DOT_core_concat) @@ -34624,7 +35550,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_seq) tmp6 := checkDerefVar(var_glojure_DOT_core_concat) @@ -34713,7 +35643,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) @@ -34854,7 +35788,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_seq) tmp6 := checkDerefVar(var_glojure_DOT_core_concat) @@ -34937,7 +35875,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -35050,7 +35992,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_seq) tmp7 := checkDerefVar(var_glojure_DOT_core_concat) @@ -35435,7 +36381,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -35551,7 +36501,11 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - var v6 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) tmp8 := checkDerefVar(var_glojure_DOT_core__DASH_) @@ -35654,7 +36608,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -35770,7 +36728,11 @@ func LoadNS() { _ = v4 v5 := args[1] _ = v5 - var v6 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_reduce1) tmp8 := checkDerefVar(var_glojure_DOT_core__DASH__TICK_) @@ -35796,7 +36758,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 var tmp4 any { // let @@ -35925,7 +36891,11 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - var v5 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_apply) tmp7 := checkDerefVar(var_glojure_DOT_core_aget) @@ -36204,7 +37174,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_seq) tmp7 := checkDerefVar(var_glojure_DOT_core_concat) @@ -36275,7 +37249,11 @@ func LoadNS() { return tmp3 default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 var tmp3 any { // let @@ -36381,7 +37359,11 @@ func LoadNS() { _ = v4 v5 := args[2] _ = v5 - var v6 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_apply) tmp8 := checkDerefVar(var_glojure_DOT_core_aset) @@ -36427,7 +37409,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_apply) tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_boolean) @@ -36473,7 +37459,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_apply) tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_byte) @@ -36519,7 +37509,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_apply) tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_char) @@ -36565,7 +37559,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_apply) tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_double) @@ -36611,7 +37609,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_apply) tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_float) @@ -36657,7 +37659,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_apply) tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_int) @@ -36703,7 +37709,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_apply) tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_long) @@ -36749,7 +37759,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_apply) tmp7 := checkDerefVar(var_glojure_DOT_core_aset_DASH_short) @@ -36780,7 +37794,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_setup_DASH_reference) tmp5 := checkDerefVar(var_glojure_DOT_core_atom) @@ -36809,7 +37827,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) @@ -37004,7 +38026,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v8 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v8 any + if len(restArgs) > 0 { + v8 = lang.NewList(restArgs...) + } _ = v8 tmp9 := checkDerefVar(var_glojure_DOT_core_apply) tmp10 := checkDerefVar(var_glojure_DOT_core_with_DASH_bindings_STAR_) @@ -37072,7 +38098,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 var tmp4 any tmp5 := checkDerefVar(var_glojure_DOT_core_seq) @@ -37163,7 +38193,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_seq) tmp6 := checkDerefVar(var_glojure_DOT_core_concat) @@ -37309,7 +38343,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -37580,7 +38618,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -37905,7 +38947,11 @@ func LoadNS() { _ = v3 v4 := args[1] _ = v4 - var v5 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any tmp7 := checkDerefVar(var_glojure_DOT_core_not_EQ_) @@ -38082,7 +39128,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) @@ -38718,7 +39768,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -39131,7 +40185,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_emit_DASH_extend_DASH_protocol) tmp7 := lang.Apply(tmp6, []any{v4, v5}) @@ -39187,7 +40245,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -39558,7 +40620,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -39787,7 +40853,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 lang.FnFunc tmp5 = lang.NewFnFunc(func(args ...any) any { @@ -40216,7 +41286,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_seq) tmp6 := checkDerefVar(var_glojure_DOT_core_concat) @@ -40263,7 +41337,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_seq) tmp7 := checkDerefVar(var_glojure_DOT_core_concat) @@ -40560,7 +41638,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let @@ -41014,7 +42096,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v11 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v11 any + if len(restArgs) > 0 { + v11 = lang.NewList(restArgs...) + } _ = v11 var tmp12 any { // let @@ -41087,7 +42173,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -41981,7 +43071,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 tmp3 := checkDerefVar(var_glojure_DOT_core_pmap) var tmp4 lang.FnFunc @@ -42397,7 +43491,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 var tmp4 any { // let @@ -42717,7 +43815,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_apply) tmp6 := checkDerefVar(var_glojure_DOT_core_send_DASH_via) @@ -42743,7 +43845,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_apply) tmp6 := checkDerefVar(var_glojure_DOT_core_send_DASH_via) @@ -43104,7 +44210,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -43222,7 +44332,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -43440,7 +44554,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) @@ -43905,7 +45023,11 @@ func LoadNS() { _ = v4 v5 := args[3] _ = v5 - var v6 any = lang.NewList(args[4:]...) + restArgs := args[4:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_seq) tmp8 := checkDerefVar(var_glojure_DOT_core_concat) @@ -43961,7 +45083,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 var tmp3 any tmp4 := lang.Apply(nil, nil) @@ -44198,7 +45324,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 var tmp4 any tmp5 := lang.Apply(nil, nil) @@ -44489,7 +45619,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -44618,7 +45752,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -44749,7 +45887,11 @@ func LoadNS() { _ = v4 v5 := args[3] _ = v5 - var v6 any = lang.NewList(args[4:]...) + restArgs := args[4:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 var tmp7 any { // let @@ -45781,7 +46923,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 var tmp4 any { // let @@ -45877,7 +47023,11 @@ func LoadNS() { checkArityGTE(args, 1) v52 := args[0] _ = v52 - var v53 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v53 any + if len(restArgs) > 0 { + v53 = lang.NewList(restArgs...) + } _ = v53 tmp54 := checkDerefVar(var_glojure_DOT_core_apply) tmp55 := checkDerefVar(var_glojure_DOT_core_cons) @@ -46029,7 +47179,11 @@ func LoadNS() { checkArityGTE(args, 1) v64 := args[0] _ = v64 - var v65 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v65 any + if len(restArgs) > 0 { + v65 = lang.NewList(restArgs...) + } _ = v65 tmp66 := checkDerefVar(var_glojure_DOT_core_apply) tmp67 := checkDerefVar(var_glojure_DOT_core_cons) @@ -46234,7 +47388,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v38 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v38 any + if len(restArgs) > 0 { + v38 = lang.NewList(restArgs...) + } _ = v38 tmp39 := checkDerefVar(var_glojure_DOT_core_apply) tmp40 := checkDerefVar(var_glojure_DOT_core_str) @@ -47314,7 +48472,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) @@ -47385,7 +48547,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any tmp7 := checkDerefVar(var_glojure_DOT_core_vector_QMARK_) @@ -47870,7 +49036,11 @@ func LoadNS() { checkArityGTE(args, 1) v5 := args[0] _ = v5 - var v6 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_class) tmp8 := lang.Apply(tmp7, []any{v5}) @@ -47886,7 +49056,11 @@ func LoadNS() { checkArityGTE(args, 1) v6 := args[0] _ = v6 - var v7 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v7 any + if len(restArgs) > 0 { + v7 = lang.NewList(restArgs...) + } _ = v7 tmp8 := checkDerefVar(var_glojure_DOT_core_apply) tmp9 := checkDerefVar(var_glojure_DOT_core_cons) @@ -47904,7 +49078,11 @@ func LoadNS() { checkArityGTE(args, 1) v8 := args[0] _ = v8 - var v9 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v9 any + if len(restArgs) > 0 { + v9 = lang.NewList(restArgs...) + } _ = v9 tmp10 := checkDerefVar(var_glojure_DOT_core_apply) tmp11 := checkDerefVar(var_glojure_DOT_core_cons) @@ -47922,7 +49100,11 @@ func LoadNS() { checkArityGTE(args, 1) v10 := args[0] _ = v10 - var v11 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v11 any + if len(restArgs) > 0 { + v11 = lang.NewList(restArgs...) + } _ = v11 tmp12 := checkDerefVar(var_glojure_DOT_core_apply) tmp13 := checkDerefVar(var_glojure_DOT_core_cons) @@ -47940,7 +49122,11 @@ func LoadNS() { checkArityGTE(args, 1) v12 := args[0] _ = v12 - var v13 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v13 any + if len(restArgs) > 0 { + v13 = lang.NewList(restArgs...) + } _ = v13 tmp14 := checkDerefVar(var_glojure_DOT_core_apply) tmp15 := checkDerefVar(var_glojure_DOT_core_cons) @@ -47958,7 +49144,11 @@ func LoadNS() { checkArityGTE(args, 1) v15 := args[0] _ = v15 - var v16 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v16 any + if len(restArgs) > 0 { + v16 = lang.NewList(restArgs...) + } _ = v16 tmp17 := checkDerefVar(var_glojure_DOT_core_class) tmp18 := lang.Apply(tmp17, []any{v15}) @@ -47974,7 +49164,11 @@ func LoadNS() { checkArityGTE(args, 1) v16 := args[0] _ = v16 - var v17 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v17 any + if len(restArgs) > 0 { + v17 = lang.NewList(restArgs...) + } _ = v17 tmp18 := checkDerefVar(var_glojure_DOT_core_apply) tmp19 := checkDerefVar(var_glojure_DOT_core_cons) @@ -47992,7 +49186,11 @@ func LoadNS() { checkArityGTE(args, 1) v18 := args[0] _ = v18 - var v19 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v19 any + if len(restArgs) > 0 { + v19 = lang.NewList(restArgs...) + } _ = v19 tmp20 := checkDerefVar(var_glojure_DOT_core_apply) tmp21 := checkDerefVar(var_glojure_DOT_core_cons) @@ -48010,7 +49208,11 @@ func LoadNS() { checkArityGTE(args, 1) v20 := args[0] _ = v20 - var v21 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v21 any + if len(restArgs) > 0 { + v21 = lang.NewList(restArgs...) + } _ = v21 tmp22 := checkDerefVar(var_glojure_DOT_core_apply) tmp23 := checkDerefVar(var_glojure_DOT_core_cons) @@ -48028,7 +49230,11 @@ func LoadNS() { checkArityGTE(args, 1) v23 := args[0] _ = v23 - var v24 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v24 any + if len(restArgs) > 0 { + v24 = lang.NewList(restArgs...) + } _ = v24 tmp25 := checkDerefVar(var_glojure_DOT_core_class) tmp26 := lang.Apply(tmp25, []any{v23}) @@ -48045,7 +49251,11 @@ func LoadNS() { checkArityGTE(args, 1) v26 := args[0] _ = v26 - var v27 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v27 any + if len(restArgs) > 0 { + v27 = lang.NewList(restArgs...) + } _ = v27 tmp28 := checkDerefVar(var_glojure_DOT_core_class) tmp29 := lang.Apply(tmp28, []any{v26}) @@ -48061,7 +49271,11 @@ func LoadNS() { checkArityGTE(args, 1) v27 := args[0] _ = v27 - var v28 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v28 any + if len(restArgs) > 0 { + v28 = lang.NewList(restArgs...) + } _ = v28 tmp29 := checkDerefVar(var_glojure_DOT_core_apply) tmp30 := checkDerefVar(var_glojure_DOT_core_cons) @@ -48079,7 +49293,11 @@ func LoadNS() { checkArityGTE(args, 1) v30 := args[0] _ = v30 - var v31 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v31 any + if len(restArgs) > 0 { + v31 = lang.NewList(restArgs...) + } _ = v31 tmp32 := checkDerefVar(var_glojure_DOT_core_class) tmp33 := lang.Apply(tmp32, []any{v30}) @@ -48129,7 +49347,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 var tmp6 any { // let @@ -48669,7 +49891,7 @@ func LoadNS() { } // cat { - tmp0 := sym_cat.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_rf)), kw_doc, "A transducer which concatenates the contents of each input, which must be a\n collection, into the reduction.", kw_file, "glojure/core.glj", kw_added, "1.7", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(9), kw_column, int(7), kw_line, int(7645), kw_end_DASH_line, int(7645))).(*lang.Symbol) + tmp0 := sym_cat.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(2773), kw_column, int(10), kw_end_DASH_line, int(2773), kw_end_DASH_column, int(12), kw_declared, true, kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp1 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) @@ -48740,7 +49962,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_apply) tmp5 := checkDerefVar(var_glojure_DOT_core_concat) @@ -49428,7 +50654,11 @@ func LoadNS() { _ = v3 v4 := args[2] _ = v4 - var v5 any = lang.NewList(args[3:]...) + restArgs := args[3:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_emit_DASH_extend_DASH_type) tmp7 := lang.Apply(tmp6, []any{v4, v5}) @@ -49497,7 +50727,7 @@ func LoadNS() { } // flatten { - tmp0 := sym_flatten.WithMeta(lang.NewMap(kw_arglists, lang.NewList(lang.NewVector(sym_x)), kw_doc, "Takes any nested combination of sequential things (lists, vectors,\n etc.) and returns their contents as a single, flat lazy sequence.\n (flatten nil) returns an empty sequence.", kw_static, true, kw_file, "glojure/core.glj", kw_added, "1.2", kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core), kw_end_DASH_column, int(13), kw_column, int(7), kw_line, int(7118), kw_end_DASH_line, int(7118))).(*lang.Symbol) + tmp0 := sym_flatten.WithMeta(lang.NewMap(kw_file, "glojure/core.glj", kw_line, int(5641), kw_column, int(10), kw_end_DASH_line, int(5641), kw_end_DASH_column, int(16), kw_declared, true, kw_ns, lang.FindOrCreateNamespace(sym_glojure_DOT_core))).(*lang.Symbol) var tmp1 lang.FnFunc tmp1 = lang.NewFnFunc(func(args ...any) any { checkArity(args, 1) @@ -50499,7 +51729,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 var tmp4 any { // let @@ -50723,7 +51957,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 var tmp3 any { // let @@ -51447,7 +52685,11 @@ func LoadNS() { _ = v2 v3 := args[1] _ = v3 - var v4 any = lang.NewList(args[2:]...) + restArgs := args[2:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_throw_DASH_if) var tmp6 any @@ -52002,7 +53244,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 var tmp3 any { // let @@ -52571,7 +53817,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 tmp3 := checkDerefVar(var_glojure_DOT_core_apply) tmp4 := checkDerefVar(var_glojure_DOT_core_load_DASH_libs) @@ -52593,7 +53843,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 var tmp3 any { // let @@ -52643,7 +53897,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 tmp3 := checkDerefVar(var_glojure_DOT_core_apply) tmp4 := checkDerefVar(var_glojure_DOT_core_load_DASH_libs) @@ -52797,7 +54055,11 @@ func LoadNS() { _ = v4 v5 := args[3] _ = v5 - var v6 any = lang.NewList(args[4:]...) + restArgs := args[4:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_into) tmp8 := lang.NewVector() @@ -52893,7 +54155,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 recur_loop_2211: tmp4 := checkDerefVar(var_glojure_DOT_core_pr) @@ -52952,7 +54218,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v3 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 var tmp4 any { // let @@ -53005,7 +54275,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 var tmp3 any { // let @@ -53047,7 +54321,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v3 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 var tmp4 any { // let @@ -53102,7 +54380,11 @@ func LoadNS() { checkArityGTE(args, 1) v2 := args[0] _ = v2 - var v3 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 tmp4 := checkDerefVar(var_glojure_DOT_core_print) tmp5 := checkDerefVar(var_glojure_DOT_core_apply) @@ -53126,7 +54408,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 tmp3 := checkDerefVar(var_glojure_DOT_core_apply) tmp4 := checkDerefVar(var_glojure_DOT_core_pr) @@ -53161,7 +54447,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v3 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 var tmp4 any { // let @@ -53214,7 +54504,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v2 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v2 any + if len(restArgs) > 0 { + v2 = lang.NewList(restArgs...) + } _ = v2 var tmp3 any { // let @@ -53256,7 +54550,11 @@ func LoadNS() { switch len(args) { default: checkArityGTE(args, 0) - var v3 any = lang.NewList(args[0:]...) + restArgs := args[0:] + var v3 any + if len(restArgs) > 0 { + v3 = lang.NewList(restArgs...) + } _ = v3 var tmp4 any { // let @@ -56145,7 +57443,11 @@ func LoadNS() { checkArityGTE(args, 1) v3 := args[0] _ = v3 - var v4 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 var tmp5 any { // let diff --git a/pkg/stdlib/glojure/protocols/loader.go b/pkg/stdlib/glojure/protocols/loader.go index aae7b787..4921fa60 100644 --- a/pkg/stdlib/glojure/protocols/loader.go +++ b/pkg/stdlib/glojure/protocols/loader.go @@ -492,7 +492,11 @@ func LoadNS() { checkArityGTE(args, 1) v4 := args[0] _ = v4 - var v5 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_class) tmp7 := lang.Apply(tmp6, []any{v4}) @@ -508,7 +512,11 @@ func LoadNS() { checkArityGTE(args, 1) v5 := args[0] _ = v5 - var v6 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_apply) tmp8 := checkDerefVar(var_glojure_DOT_core_cons) @@ -526,7 +534,11 @@ func LoadNS() { checkArityGTE(args, 1) v7 := args[0] _ = v7 - var v8 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v8 any + if len(restArgs) > 0 { + v8 = lang.NewList(restArgs...) + } _ = v8 tmp9 := checkDerefVar(var_glojure_DOT_core_apply) tmp10 := checkDerefVar(var_glojure_DOT_core_cons) @@ -544,7 +556,11 @@ func LoadNS() { checkArityGTE(args, 1) v9 := args[0] _ = v9 - var v10 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v10 any + if len(restArgs) > 0 { + v10 = lang.NewList(restArgs...) + } _ = v10 tmp11 := checkDerefVar(var_glojure_DOT_core_apply) tmp12 := checkDerefVar(var_glojure_DOT_core_cons) @@ -562,7 +578,11 @@ func LoadNS() { checkArityGTE(args, 1) v11 := args[0] _ = v11 - var v12 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v12 any + if len(restArgs) > 0 { + v12 = lang.NewList(restArgs...) + } _ = v12 tmp13 := checkDerefVar(var_glojure_DOT_core_apply) tmp14 := checkDerefVar(var_glojure_DOT_core_cons) @@ -588,7 +608,11 @@ func LoadNS() { checkArityGTE(args, 1) v4 := args[0] _ = v4 - var v5 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_class) tmp7 := lang.Apply(tmp6, []any{v4}) @@ -604,7 +628,11 @@ func LoadNS() { checkArityGTE(args, 1) v5 := args[0] _ = v5 - var v6 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_apply) tmp8 := checkDerefVar(var_glojure_DOT_core_cons) @@ -630,7 +658,11 @@ func LoadNS() { checkArityGTE(args, 1) v4 := args[0] _ = v4 - var v5 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_class) tmp7 := lang.Apply(tmp6, []any{v4}) @@ -655,7 +687,11 @@ func LoadNS() { checkArityGTE(args, 1) v4 := args[0] _ = v4 - var v5 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_class) tmp7 := lang.Apply(tmp6, []any{v4}) @@ -671,7 +707,11 @@ func LoadNS() { checkArityGTE(args, 1) v5 := args[0] _ = v5 - var v6 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 tmp7 := checkDerefVar(var_glojure_DOT_core_apply) tmp8 := checkDerefVar(var_glojure_DOT_core_cons) @@ -689,7 +729,11 @@ func LoadNS() { checkArityGTE(args, 1) v7 := args[0] _ = v7 - var v8 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v8 any + if len(restArgs) > 0 { + v8 = lang.NewList(restArgs...) + } _ = v8 tmp9 := checkDerefVar(var_glojure_DOT_core_apply) tmp10 := checkDerefVar(var_glojure_DOT_core_cons) @@ -707,7 +751,11 @@ func LoadNS() { checkArityGTE(args, 1) v9 := args[0] _ = v9 - var v10 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v10 any + if len(restArgs) > 0 { + v10 = lang.NewList(restArgs...) + } _ = v10 tmp11 := checkDerefVar(var_glojure_DOT_core_apply) tmp12 := checkDerefVar(var_glojure_DOT_core_cons) @@ -733,7 +781,11 @@ func LoadNS() { checkArityGTE(args, 1) v4 := args[0] _ = v4 - var v5 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_class) tmp7 := lang.Apply(tmp6, []any{v4}) @@ -758,7 +810,11 @@ func LoadNS() { checkArityGTE(args, 1) v3 := args[0] _ = v3 - var v4 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_class) tmp6 := lang.Apply(tmp5, []any{v3}) @@ -774,7 +830,11 @@ func LoadNS() { checkArityGTE(args, 1) v4 := args[0] _ = v4 - var v5 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_apply) tmp7 := checkDerefVar(var_glojure_DOT_core_cons) @@ -792,7 +852,11 @@ func LoadNS() { checkArityGTE(args, 1) v6 := args[0] _ = v6 - var v7 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v7 any + if len(restArgs) > 0 { + v7 = lang.NewList(restArgs...) + } _ = v7 tmp8 := checkDerefVar(var_glojure_DOT_core_apply) tmp9 := checkDerefVar(var_glojure_DOT_core_cons) @@ -810,7 +874,11 @@ func LoadNS() { checkArityGTE(args, 1) v8 := args[0] _ = v8 - var v9 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v9 any + if len(restArgs) > 0 { + v9 = lang.NewList(restArgs...) + } _ = v9 tmp10 := checkDerefVar(var_glojure_DOT_core_apply) tmp11 := checkDerefVar(var_glojure_DOT_core_cons) @@ -828,7 +896,11 @@ func LoadNS() { checkArityGTE(args, 1) v10 := args[0] _ = v10 - var v11 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v11 any + if len(restArgs) > 0 { + v11 = lang.NewList(restArgs...) + } _ = v11 tmp12 := checkDerefVar(var_glojure_DOT_core_apply) tmp13 := checkDerefVar(var_glojure_DOT_core_cons) @@ -853,7 +925,11 @@ func LoadNS() { checkArityGTE(args, 1) v3 := args[0] _ = v3 - var v4 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_class) tmp6 := lang.Apply(tmp5, []any{v3}) @@ -869,7 +945,11 @@ func LoadNS() { checkArityGTE(args, 1) v4 := args[0] _ = v4 - var v5 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_apply) tmp7 := checkDerefVar(var_glojure_DOT_core_cons) @@ -930,7 +1010,11 @@ func LoadNS() { checkArityGTE(args, 1) v3 := args[0] _ = v3 - var v4 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_class) tmp6 := lang.Apply(tmp5, []any{v3}) @@ -946,7 +1030,11 @@ func LoadNS() { checkArityGTE(args, 1) v4 := args[0] _ = v4 - var v5 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v5 any + if len(restArgs) > 0 { + v5 = lang.NewList(restArgs...) + } _ = v5 tmp6 := checkDerefVar(var_glojure_DOT_core_apply) tmp7 := checkDerefVar(var_glojure_DOT_core_cons) @@ -964,7 +1052,11 @@ func LoadNS() { checkArityGTE(args, 1) v6 := args[0] _ = v6 - var v7 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v7 any + if len(restArgs) > 0 { + v7 = lang.NewList(restArgs...) + } _ = v7 tmp8 := checkDerefVar(var_glojure_DOT_core_apply) tmp9 := checkDerefVar(var_glojure_DOT_core_cons) @@ -982,7 +1074,11 @@ func LoadNS() { checkArityGTE(args, 1) v8 := args[0] _ = v8 - var v9 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v9 any + if len(restArgs) > 0 { + v9 = lang.NewList(restArgs...) + } _ = v9 tmp10 := checkDerefVar(var_glojure_DOT_core_apply) tmp11 := checkDerefVar(var_glojure_DOT_core_cons) @@ -1219,7 +1315,11 @@ func LoadNS() { checkArityGTE(args, 1) v3 := args[0] _ = v3 - var v4 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_class) tmp6 := lang.Apply(tmp5, []any{v3}) @@ -1310,7 +1410,11 @@ func LoadNS() { checkArityGTE(args, 1) v3 := args[0] _ = v3 - var v4 any = lang.NewList(args[1:]...) + restArgs := args[1:] + var v4 any + if len(restArgs) > 0 { + v4 = lang.NewList(restArgs...) + } _ = v4 tmp5 := checkDerefVar(var_glojure_DOT_core_class) tmp6 := lang.Apply(tmp5, []any{v3}) diff --git a/pkg/stdlib/glojure/template/loader.go b/pkg/stdlib/glojure/template/loader.go index fdfed777..3defbd7c 100644 --- a/pkg/stdlib/glojure/template/loader.go +++ b/pkg/stdlib/glojure/template/loader.go @@ -128,7 +128,11 @@ func LoadNS() { _ = v4 v5 := args[3] _ = v5 - var v6 any = lang.NewList(args[4:]...) + restArgs := args[4:] + var v6 any + if len(restArgs) > 0 { + v6 = lang.NewList(restArgs...) + } _ = v6 var tmp7 any { // let From 8e7918b3824a024cda089b12668c9953001a2b42 Mon Sep 17 00:00:00 2001 From: James Hamlin Date: Mon, 1 Sep 2025 21:44:54 -0700 Subject: [PATCH 67/67] Revert FnFunc struct wrapping Signed-off-by: James Hamlin --- pkg/lang/ifn.go | 26 ++++++++------------------ 1 file changed, 8 insertions(+), 18 deletions(-) diff --git a/pkg/lang/ifn.go b/pkg/lang/ifn.go index 99dbda4e..ecd5d915 100644 --- a/pkg/lang/ifn.go +++ b/pkg/lang/ifn.go @@ -1,39 +1,29 @@ package lang // FnFunc is a wrapped Go function that implements the IFn interface. -type FnFunc struct { - fn func(args ...any) any - meta IPersistentMap -} +type FnFunc func(args ...any) any var ( - _ IFn = FnFunc{} + _ IFn = FnFunc(nil) ) func NewFnFunc(fn func(args ...any) any) FnFunc { - return FnFunc{ - fn: fn, - } + return FnFunc(fn) } func (f FnFunc) Invoke(args ...any) any { - return f.fn(args...) + return f(args...) } func (f FnFunc) ApplyTo(args ISeq) any { - return f.fn(seqToSlice(args)...) + return f(seqToSlice(args)...) } func (f FnFunc) Meta() IPersistentMap { - return f.meta + return nil } func (f FnFunc) WithMeta(meta IPersistentMap) any { - if f.meta == meta { - return f - } - - cpy := f - cpy.meta = meta - return cpy + // no-op + return f }